diff --git a/.clang-format b/.clang-format
new file mode 100644
index 00000000..b8f4f9b8
--- /dev/null
+++ b/.clang-format
@@ -0,0 +1,89 @@
+---
+Language:	Cpp
+BasedOnStyle: Google
+AccessModifierOffset: -4
+AlignAfterOpenBracket:	Align
+AlignConsecutiveAssignments:	true
+AlignConsecutiveDeclarations:	true
+AlignEscapedNewlinesLeft:	true
+AlignOperands:	true
+AlignTrailingComments:	true
+AllowAllParametersOfDeclarationOnNextLine:	true
+AllowShortBlocksOnASingleLine:	false
+AllowShortCaseLabelsOnASingleLine:	false
+AllowShortFunctionsOnASingleLine:	Empty
+AllowShortIfStatementsOnASingleLine:	false
+AllowShortLoopsOnASingleLine:	false
+AlwaysBreakAfterDefinitionReturnType:	None
+AlwaysBreakAfterReturnType:	None
+AlwaysBreakBeforeMultilineStrings:	false
+AlwaysBreakTemplateDeclarations:	false
+BinPackArguments:	true
+BinPackParameters:	true
+BraceWrapping:
+  AfterClass:	false
+  AfterControlStatement:	false
+  AfterEnum:	false
+  AfterFunction:	false
+  AfterNamespace:	false
+  AfterObjCDeclaration:	false
+  AfterStruct:	false
+  AfterUnion:	false
+  BeforeCatch:	true
+  BeforeElse:	true
+  IndentBraces:	false
+BreakBeforeBinaryOperators:	NonAssignment
+BreakBeforeBraces:	Custom
+BreakBeforeTernaryOperators:	true
+BreakConstructorInitializersBeforeComma:	false
+ColumnLimit:	160
+CommentPragmas:	'^ IWYU pragma:'
+ConstructorInitializerAllOnOneLineOrOnePerLine:	true
+ConstructorInitializerIndentWidth:	4
+ContinuationIndentWidth:	4
+Cpp11BracedListStyle:	false
+DerivePointerAlignment:	false
+DisableFormat:	false
+ExperimentalAutoDetectBinPacking:	false
+ForEachMacros:	[ foreach, Q_FOREACH, BOOST_FOREACH ]
+IncludeCategories:
+  - Regex:	'^"(llvm|llvm-c|clang|clang-c)/'
+    Priority:	2
+  - Regex:	'^(<|"(gtest|isl|json)/)'
+    Priority:	3
+  - Regex:	'.*'
+    Priority:	1
+IndentCaseLabels:	false
+IndentWidth: 4
+IndentWrappedFunctionNames:	false
+KeepEmptyLinesAtTheStartOfBlocks:	true
+MacroBlockBegin:	''
+MacroBlockEnd:	''
+MaxEmptyLinesToKeep:	1
+NamespaceIndentation:	None
+ObjCBlockIndentWidth:	4
+ObjCSpaceAfterProperty:	false
+ObjCSpaceBeforeProtocolList:	true
+PenaltyBreakBeforeFirstCallParameter:	19
+PenaltyBreakComment:	300
+PenaltyBreakFirstLessLess:	200
+PenaltyBreakString:	1000
+PenaltyExcessCharacter:	1000000
+PenaltyReturnTypeOnItsOwnLine:	60
+PointerAlignment:	Right
+ReflowComments:	true
+SortIncludes:	false
+SpaceAfterCStyleCast:	false
+SpaceBeforeAssignmentOperators:	true
+SpaceBeforeParens: Never
+SpaceInEmptyParentheses:	false
+SpacesInCStyleCastParentheses:	false
+SpacesBeforeTrailingComments:	2
+SpacesInAngles:	false
+SpacesInContainerLiterals:	true
+SpacesInParentheses:	false
+SpacesInSquareBrackets:	false
+SpaceBeforeRangeBasedForLoopColon: false
+Standard:	Cpp11
+TabWidth:	4
+UseTab:	Never
diff --git a/.clang-tidy b/.clang-tidy
new file mode 100644
index 00000000..b809e8ec
--- /dev/null
+++ b/.clang-tidy
@@ -0,0 +1,177 @@
+# Generated from CLion Inspection settings
+---
+Checks: '-*,
+bugprone-argument-comment,
+bugprone-assert-side-effect,
+bugprone-bad-signal-to-kill-thread,
+bugprone-branch-clone,
+bugprone-copy-constructor-init,
+bugprone-dangling-handle,
+bugprone-dynamic-static-initializers,
+bugprone-fold-init-type,
+bugprone-forward-declaration-namespace,
+bugprone-forwarding-reference-overload,
+bugprone-inaccurate-erase,
+bugprone-incorrect-roundings,
+bugprone-integer-division,
+bugprone-lambda-function-name,
+bugprone-macro-parentheses,
+bugprone-macro-repeated-side-effects,
+bugprone-misplaced-operator-in-strlen-in-alloc,
+bugprone-misplaced-pointer-arithmetic-in-alloc,
+bugprone-misplaced-widening-cast,
+bugprone-move-forwarding-reference,
+bugprone-multiple-statement-macro,
+bugprone-no-escape,
+bugprone-parent-virtual-call,
+bugprone-posix-return,
+bugprone-reserved-identifier,
+bugprone-sizeof-container,
+bugprone-sizeof-expression,
+bugprone-spuriously-wake-up-functions,
+bugprone-string-constructor,
+bugprone-string-integer-assignment,
+bugprone-string-literal-with-embedded-nul,
+bugprone-suspicious-enum-usage,
+bugprone-suspicious-include,
+bugprone-suspicious-memset-usage,
+bugprone-suspicious-missing-comma,
+bugprone-suspicious-semicolon,
+bugprone-suspicious-string-compare,
+bugprone-suspicious-memory-comparison,
+bugprone-suspicious-realloc-usage,
+bugprone-swapped-arguments,
+bugprone-terminating-continue,
+bugprone-throw-keyword-missing,
+bugprone-too-small-loop-variable,
+bugprone-undefined-memory-manipulation,
+bugprone-undelegated-constructor,
+bugprone-unhandled-self-assignment,
+bugprone-unused-raii,
+bugprone-unused-return-value,
+bugprone-use-after-move,
+bugprone-virtual-near-miss,
+cert-dcl21-cpp,
+cert-dcl58-cpp,
+cert-err34-c,
+cert-err52-cpp,
+cert-err60-cpp,
+cert-flp30-c,
+cert-msc50-cpp,
+cert-msc51-cpp,
+cert-str34-c,
+cppcoreguidelines-interfaces-global-init,
+cppcoreguidelines-narrowing-conversions,
+cppcoreguidelines-pro-type-member-init,
+cppcoreguidelines-pro-type-static-cast-downcast,
+cppcoreguidelines-avoid-capturing-lambda-coroutines,
+cppcoreguidelines-avoid-const-or-ref-data-members,
+cppcoreguidelines-avoid-do-while,
+cppcoreguidelines-avoid-goto,
+cppcoreguidelines-avoid-non-const-global-variables,
+cppcoreguidelines-avoid-reference-coroutine-parameters,
+cppcoreguidelines-init-variables,
+cppcoreguidelines-interfaces-global-init,
+cppcoreguidelines-macro-usage,
+cppcoreguidelines-misleading-capture-default-by-value,
+cppcoreguidelines-missing-std-forward,
+cppcoreguidelines-narrowing-conversions,
+cppcoreguidelines-no-malloc,
+cppcoreguidelines-no-suspend-with-lock,
+cppcoreguidelines-owning-memory,
+cppcoreguidelines-prefer-member-initializer,
+cppcoreguidelines-pro-bounds-array-to-pointer-decay,
+cppcoreguidelines-pro-bounds-constant-array-index,
+cppcoreguidelines-pro-bounds-pointer-arithmetic,
+cppcoreguidelines-pro-type-const-cast,
+cppcoreguidelines-pro-type-cstyle-cast,
+cppcoreguidelines-pro-type-member-init,
+cppcoreguidelines-pro-type-reinterpret-cast,
+cppcoreguidelines-pro-type-static-cast-downcast,
+cppcoreguidelines-pro-type-union-access,
+cppcoreguidelines-pro-type-vararg,
+cppcoreguidelines-rvalue-reference-param-not-moved,
+cppcoreguidelines-special-member-functions,
+cppcoreguidelines-virtual-class-destructor,
+cppcoreguidelines-slicing,
+google-default-arguments,
+google-explicit-constructor,
+google-runtime-operator,
+hicpp-exception-baseclass,
+hicpp-multiway-paths-covered,
+misc-misplaced-const,
+misc-new-delete-overloads,
+misc-no-recursion,
+misc-non-copyable-objects,
+misc-throw-by-value-catch-by-reference,
+misc-unconventional-assign-operator,
+misc-uniqueptr-reset-release,
+modernize-avoid-bind,
+modernize-concat-nested-namespaces,
+modernize-deprecated-headers,
+modernize-deprecated-ios-base-aliases,
+modernize-loop-convert,
+modernize-make-shared,
+modernize-make-unique,
+modernize-pass-by-value,
+modernize-raw-string-literal,
+modernize-redundant-void-arg,
+modernize-replace-auto-ptr,
+modernize-replace-disallow-copy-and-assign-macro,
+modernize-replace-random-shuffle,
+modernize-return-braced-init-list,
+modernize-shrink-to-fit,
+modernize-unary-static-assert,
+modernize-use-auto,
+modernize-use-bool-literals,
+modernize-use-emplace,
+modernize-use-equals-default,
+modernize-use-equals-delete,
+modernize-use-nodiscard,
+modernize-use-noexcept,
+modernize-use-nullptr,
+modernize-use-override,
+modernize-use-transparent-functors,
+modernize-use-uncaught-exceptions,
+mpi-buffer-deref,
+mpi-type-mismatch,
+openmp-use-default-none,
+performance-faster-string-find,
+performance-for-range-copy,
+performance-implicit-conversion-in-loop,
+performance-inefficient-algorithm,
+performance-inefficient-string-concatenation,
+performance-inefficient-vector-operation,
+performance-move-const-arg,
+performance-move-constructor-init,
+performance-no-automatic-move,
+performance-noexcept-move-constructor,
+performance-trivially-destructible,
+performance-type-promotion-in-math-fn,
+performance-unnecessary-copy-initialization,
+performance-unnecessary-value-param,
+portability-simd-intrinsics,
+readability-avoid-const-params-in-decls,
+readability-const-return-type,
+readability-container-size-empty,
+readability-convert-member-functions-to-static,
+readability-delete-null-pointer,
+readability-deleted-default,
+readability-inconsistent-declaration-parameter-name,
+readability-make-member-function-const,
+readability-misleading-indentation,
+readability-misplaced-array-index,
+readability-non-const-parameter,
+readability-redundant-control-flow,
+readability-redundant-declaration,
+readability-redundant-function-ptr-dereference,
+readability-redundant-smartptr-get,
+readability-redundant-string-cstr,
+readability-redundant-string-init,
+readability-simplify-subscript-expr,
+readability-static-accessed-through-instance,
+readability-static-definition-in-anonymous-namespace,
+readability-string-compare,
+readability-uniqueptr-delete-release,
+readability-use-anyofallof'
+HeaderFilterRegex: '^(src|include)/.*'
diff --git a/.cmake-format.py b/.cmake-format.py
new file mode 100644
index 00000000..1bce6cda
--- /dev/null
+++ b/.cmake-format.py
@@ -0,0 +1,97 @@
+# -----------------------------
+# Options affecting formatting.
+# -----------------------------
+with section("format"):
+
+  # Disable formatting entirely, making cmake-format a no-op
+  disable = False
+
+  # How wide to allow formatted cmake files
+  line_width = 120
+
+  # How many spaces to tab for indent
+  tab_size = 4
+
+  # If true, lines are indented using tab characters (utf-8 0x09) instead of
+  # <tab_size> space characters (utf-8 0x20). In cases where the layout would
+  # require a fractional tab character, the behavior of the  fractional
+  # indentation is governed by <fractional_tab_policy>
+  use_tabchars = False
+
+  # If <use_tabchars> is True, then the value of this variable indicates how
+  # fractional indentions are handled during whitespace replacement. If set to
+  # 'use-space', fractional indentation is left as spaces (utf-8 0x20). If set
+  # to `round-up` fractional indentation is replaced with a single tab character
+  # (utf-8 0x09) effectively shifting the column to the next tabstop
+  fractional_tab_policy = 'use-space'
+
+  # If an argument group contains more than this many sub-groups (parg or kwarg
+  # groups) then force it to a vertical layout.
+  max_subgroups_hwrap = 4
+
+  # If a positional argument group contains more than this many arguments, then
+  # force it to a vertical layout.
+  max_pargs_hwrap = 6
+
+  # If a cmdline positional group consumes more than this many lines without
+  # nesting, then invalidate the layout (and nest)
+  max_rows_cmdline = 2
+
+  # If true, separate flow control names from their parentheses with a space
+  separate_ctrl_name_with_space = False
+
+  # If true, separate function names from parentheses with a space
+  separate_fn_name_with_space = False
+
+  # If a statement is wrapped to more than one line, than dangle the closing
+  # parenthesis on its own line.
+  dangle_parens = True
+
+  # If the trailing parenthesis must be 'dangled' on its on line, then align it
+  # to this reference: `prefix`: the start of the statement,  `prefix-indent`:
+  # the start of the statement, plus one indentation  level, `child`: align to
+  # the column of the arguments
+  dangle_align = 'prefix'
+
+  # If the statement spelling length (including space and parenthesis) is
+  # smaller than this amount, then force reject nested layouts.
+  min_prefix_chars = 4
+
+  # If the statement spelling length (including space and parenthesis) is larger
+  # than the tab width by more than this amount, then force reject un-nested
+  # layouts.
+  max_prefix_chars = 10
+
+  # If a candidate layout is wrapped horizontally but it exceeds this many
+  # lines, then reject the layout.
+  max_lines_hwrap = 2
+
+  # What style line endings to use in the output.
+  line_ending = 'unix'
+
+  # Format command names consistently as 'lower' or 'upper' case
+  command_case = 'canonical'
+
+  # Format keywords consistently as 'lower' or 'upper' case
+  keyword_case = 'unchanged'
+
+  # A list of command names which should always be wrapped
+  always_wrap = []
+
+  # If true, the argument lists which are known to be sortable will be sorted
+  # lexicographicall
+  enable_sort = True
+
+  # If true, the parsers may infer whether or not an argument list is sortable
+  # (without annotation).
+  autosort = False
+
+  # By default, if cmake-format cannot successfully fit everything into the
+  # desired linewidth it will apply the last, most agressive attempt that it
+  # made. If this flag is True, however, cmake-format will print error, exit
+  # with non-zero status code, and write-out nothing
+  require_valid_layout = False
+
+  # A dictionary mapping layout nodes to a list of wrap decisions. See the
+  # documentation for more information.
+  layout_passes = {}
\ No newline at end of file
diff --git a/.github/ISSUE_TEMPLATE/bug_report.md b/.github/ISSUE_TEMPLATE/bug_report.md
new file mode 100644
index 00000000..d692ef52
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/bug_report.md
@@ -0,0 +1,39 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+**Describe the bug**  
+A clear and concise description of what the bug is.
+
+**Reproduction Steps**  
+Steps to reproduce the behavior:
+
+**Expected behavior**  
+A clear and concise description of what you expected to happen.
+
+**Log Output**  
+Include relevant log entries or error messages that are related to the problem.You can attach log files if they are too large.
+
+**System Environment:**
+
+- OS: Name and version (e.g., Windows 10, Ubuntu 20.04).
+- Architecture: x86_64, armv7, etc.
+- Visual Studio/GCC：Version A.B.C
+
+**Tool/SDK Version:**
+
+- SDK: Version A.B.C
+- OrbbecViewer：: Version A.B.C
+
+**Device Information:**
+
+- Model: Device model name.
+- Firmware Version: Firmware revision number.
+
+**Additional context**  
+Add any other context about the problem here.
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 00000000..1e7cb805
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,901 @@
+# Built application files
+*.apk
+*.ap_
+*.aab
+*.attach_pid*
+
+# Files for the ART/Dalvik VM
+*.dex
+
+# Java class files
+*.class
+build-release*/
+*.zip
+# Generated files
+# bin/
+gen/
+out/
+#  Uncomment the following line in case you need and you don't have the release build type files in your app
+# release/
+
+#vscode
+.vscode
+
+#vs
+.vs
+
+# Gradle files
+.gradle/
+
+# cache & build output
+build/
+build_win_x64/
+build_win_x86/
+build_linux_x86_64/
+build_linux_arm64/
+build_linux_aarch64/
+build_linux_arm/
+build_android_aarch64/
+build_android_arm/
+build_macos_arm64/
+build_macos_x64
+cmake_build
+install/
+version.txt
+
+# Local configuration file (sdk path, etc)
+local.properties
+
+# Proguard folder generated by Eclipse
+proguard/
+
+# Log Files
+*.log
+
+# Android Studio Navigation editor temp files
+.navigation/
+
+# Android Studio captures folder
+captures/
+
+# IntelliJ
+.idea
+*.iml
+.idea/workspace.xml
+.idea/tasks.xml
+.idea/gradle.xml
+.idea/assetWizardSettings.xml
+.idea/dictionaries
+.idea/libraries
+# Android Studio 3 in .gitignore file.
+.idea/caches
+.idea/modules.xml
+# Comment next line if keeping position of elements in Navigation Editor is relevant for you
+.idea/navEditor.xml
+
+# Keystore files
+# Uncomment the following lines if you do not want to check your keystore files in.
+#*.jks
+#*.keystore
+
+# External native build folder generated in Android Studio 2.2 and later
+.externalNativeBuild
+.cxx/
+
+# Google Services (e.g. APIs or Firebase)
+# google-services.json
+
+# Freeline
+freeline.py
+freeline/
+freeline_project_description.json
+
+# fastlane
+fastlane/report.xml
+fastlane/Preview.html
+fastlane/screenshots
+fastlane/test_output
+fastlane/readme.md
+
+# Version control
+vcs.xml
+
+# lint
+lint/intermediates/
+lint/generated/
+lint/outputs/
+lint/tmp/
+# lint/reports/
+
+# Android Profiling
+*.hprof
+/wrappers/android/Test Results*.html
+/wrappers/android/obsensor_jni/api
+/wrappers/android/local.properties
+
+
+third_party/SoftD2CSrc/Source/version/version.h
+third_party/SoftD2CSrc/Source/version/version.rc
+
+visual_studio/
+visual_studio_win32/
+visual_studio_x86/
+cmake-build-debug/
+
+*.pyc
+.DS_Store
+aarch64_custom_toolchain.cmake
+.aderc
+package_name.txt
+
+include/libobsensor/h/Export.h
+
+# Created by https://www.toptal.com/developers/gitignore/api/visualstudio,visualstudiocode,c++,python,jetbrains+all,ros,ros2
+# Edit at https://www.toptal.com/developers/gitignore?templates=visualstudio,visualstudiocode,c++,python,jetbrains+all,ros,ros2
+
+### C++ ###
+# Prerequisites
+*.d
+
+# Compiled Object files
+*.slo
+*.lo
+*.o
+*.obj
+*.deb
+*.ddeb
+debian/
+# Precompiled Headers
+*.gch
+*.pch
+
+# Compiled Dynamic libraries
+# *.so
+# *.Dylib
+# *.dll
+
+# Fortran module files
+*.mod
+*.smod
+
+# Compiled Static libraries
+*.lai
+*.la
+*.a
+# *.lib
+
+# Executables
+*.exe
+*.out
+*.app
+
+### JetBrains+all ###
+# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio, WebStorm and Rider
+# Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839
+
+# User-specific stuff
+.idea/**/workspace.xml
+.idea/**/tasks.xml
+.idea/**/usage.statistics.xml
+.idea/**/dictionaries
+.idea/**/shelf
+
+# AWS User-specific
+.idea/**/aws.xml
+
+# Generated files
+.idea/**/contentModel.xml
+
+# Sensitive or high-churn files
+.idea/**/dataSources/
+.idea/**/dataSources.ids
+.idea/**/dataSources.local.xml
+.idea/**/sqlDataSources.xml
+.idea/**/dynamic.xml
+.idea/**/uiDesigner.xml
+.idea/**/dbnavigator.xml
+
+# Gradle
+.idea/**/gradle.xml
+.idea/**/libraries
+
+# Gradle and Maven with auto-import
+# When using Gradle or Maven with auto-import, you should exclude module files,
+# since they will be recreated, and may cause churn.  Uncomment if using
+# auto-import.
+# .idea/artifacts
+# .idea/compiler.xml
+# .idea/jarRepositories.xml
+# .idea/modules.xml
+# .idea/*.iml
+# .idea/modules
+# *.iml
+# *.ipr
+
+# CMake
+cmake-build-*/
+
+# Mongo Explorer plugin
+.idea/**/mongoSettings.xml
+
+# File-based project format
+*.iws
+
+# IntelliJ
+out/
+
+# mpeltonen/sbt-idea plugin
+.idea_modules/
+
+# JIRA plugin
+atlassian-ide-plugin.xml
+
+# Cursive Clojure plugin
+.idea/replstate.xml
+
+# SonarLint plugin
+.idea/sonarlint/
+
+# Crashlytics plugin (for Android Studio and IntelliJ)
+com_crashlytics_export_strings.xml
+crashlytics.properties
+crashlytics-build.properties
+fabric.properties
+
+# Editor-based Rest Client
+.idea/httpRequests
+
+# Android studio 3.1+ serialized cache file
+.idea/caches/build_file_checksums.ser
+
+### JetBrains+all Patch ###
+# Ignore everything but code style settings and run configurations
+# that are supposed to be shared within teams.
+
+.idea/*
+
+!.idea/codeStyles
+!.idea/runConfigurations
+
+### Python ###
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+# lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+### ROS ###
+devel/
+logs/
+bin/
+msg_gen/
+srv_gen/
+msg/*Action.msg
+msg/*ActionFeedback.msg
+msg/*ActionGoal.msg
+msg/*ActionResult.msg
+msg/*Feedback.msg
+msg/*Goal.msg
+msg/*Result.msg
+msg/_*.py
+build_isolated/
+devel_isolated/
+
+# Generated by dynamic reconfigure
+*.cfgc
+/cfg/cpp/
+/cfg/*.py
+
+# Ignore generated docs
+*.dox
+*.wikidoc
+
+# eclipse stuff
+.project
+.cproject
+
+# qcreator stuff
+CMakeLists.txt.user
+
+srv/_*.py
+*.pcd
+*.pyc
+qtcreator-*
+*.user
+
+/planning/cfg
+/planning/docs
+/planning/src
+
+*~
+
+# Emacs
+.#*
+
+# Catkin custom files
+CATKIN_IGNORE
+
+### ROS 2 ###
+install/
+log/
+.obj-x86_64-linux-gnu/
+
+# Ignore generated docs
+
+# eclipse stuff
+
+# qcreator stuff
+
+
+
+# Emacs
+
+# Colcon custom files
+COLCON_IGNORE
+AMENT_IGNORE
+
+### VisualStudioCode ###
+.vscode/*
+
+# Local History for Visual Studio Code
+.history/
+
+# Built Visual Studio Code Extensions
+*.vsix
+
+### VisualStudioCode Patch ###
+# Ignore all local history of files
+.history
+.ionide
+
+# Support for Project snippet scope
+.vscode/*.code-snippets
+
+# Ignore code-workspaces
+*.code-workspace
+
+### VisualStudio ###
+## Ignore Visual Studio temporary files, build results, and
+## files generated by popular Visual Studio add-ons.
+##
+## Get latest from https://github.com/github/gitignore/blob/main/VisualStudio.gitignore
+
+# User-specific files
+*.rsuser
+*.suo
+*.userosscache
+*.sln.docstates
+
+# User-specific files (MonoDevelop/Xamarin Studio)
+*.userprefs
+
+# Mono auto generated files
+mono_crash.*
+
+# Build results
+[Dd]ebug/
+[Dd]ebugPublic/
+[Rr]elease/
+[Rr]eleases/
+x64/
+x86/
+[Ww][Ii][Nn]32/
+[Aa][Rr][Mm]/
+[Aa][Rr][Mm]64/
+bld/
+[Bb]in/
+[Oo]bj/
+[Ll]og/
+[Ll]ogs/
+
+# Visual Studio 2015/2017 cache/options directory
+.vs/
+# Uncomment if you have tasks that create the project's static files in wwwroot
+#wwwroot/
+
+# Visual Studio 2017 auto generated files
+Generated\ Files/
+
+# MSTest test Results
+[Tt]est[Rr]esult*/
+[Bb]uild[Ll]og.*
+
+# NUnit
+*.VisualState.xml
+TestResult.xml
+nunit-*.xml
+
+# Build Results of an ATL Project
+[Dd]ebugPS/
+[Rr]eleasePS/
+dlldata.c
+
+# Benchmark Results
+BenchmarkDotNet.Artifacts/
+
+# .NET Core
+project.lock.json
+project.fragment.lock.json
+artifacts/
+
+# ASP.NET Scaffolding
+ScaffoldingReadMe.txt
+
+# StyleCop
+StyleCopReport.xml
+
+# Files built by Visual Studio
+*_i.c
+*_p.c
+*_h.h
+*.ilk
+*.meta
+*.iobj
+*.pdb
+*.ipdb
+*.pgc
+*.pgd
+*.rsp
+*.sbr
+*.tlb
+*.tli
+*.tlh
+*.tmp
+*.tmp_proj
+*_wpftmp.csproj
+*.tlog
+*.vspscc
+*.vssscc
+.builds
+*.pidb
+*.svclog
+*.scc
+
+# Chutzpah Test files
+_Chutzpah*
+
+# Visual C++ cache files
+ipch/
+*.aps
+*.ncb
+*.opendb
+*.opensdf
+*.sdf
+*.cachefile
+*.VC.db
+*.VC.VC.opendb
+
+# Visual Studio profiler
+*.psess
+*.vsp
+*.vspx
+*.sap
+
+# Visual Studio Trace Files
+*.e2e
+
+# TFS 2012 Local Workspace
+$tf/
+
+# Guidance Automation Toolkit
+*.gpState
+
+# ReSharper is a .NET coding add-in
+_ReSharper*/
+*.[Rr]e[Ss]harper
+*.DotSettings.user
+
+# TeamCity is a build add-in
+_TeamCity*
+
+# DotCover is a Code Coverage Tool
+*.dotCover
+
+# AxoCover is a Code Coverage Tool
+.axoCover/*
+!.axoCover/settings.json
+
+# Coverlet is a free, cross platform Code Coverage Tool
+coverage*.json
+coverage*.xml
+coverage*.info
+
+# Visual Studio code coverage results
+*.coverage
+*.coveragexml
+
+# NCrunch
+_NCrunch_*
+.*crunch*.local.xml
+nCrunchTemp_*
+
+# MightyMoose
+*.mm.*
+AutoTest.Net/
+
+# Web workbench (sass)
+.sass-cache/
+
+# Installshield output folder
+[Ee]xpress/
+
+# DocProject is a documentation generator add-in
+DocProject/buildhelp/
+DocProject/Help/*.HxT
+DocProject/Help/*.HxC
+DocProject/Help/*.hhc
+DocProject/Help/*.hhk
+DocProject/Help/*.hhp
+DocProject/Help/Html2
+DocProject/Help/html
+
+# Click-Once directory
+publish/
+
+# Publish Web Output
+*.[Pp]ublish.xml
+*.azurePubxml
+# Note: Comment the next line if you want to checkin your web deploy settings,
+# but database connection strings (with potential passwords) will be unencrypted
+*.pubxml
+*.publishproj
+
+# Microsoft Azure Web App publish settings. Comment the next line if you want to
+# checkin your Azure Web App publish settings, but sensitive information contained
+# in these scripts will be unencrypted
+PublishScripts/
+
+# NuGet Packages
+*.nupkg
+# NuGet Symbol Packages
+*.snupkg
+# The packages folder can be ignored because of Package Restore
+**/[Pp]ackages/*
+# except build/, which is used as an MSBuild target.
+!**/[Pp]ackages/build/
+# Uncomment if necessary however generally it will be regenerated when needed
+#!**/[Pp]ackages/repositories.config
+# NuGet v3's project.json files produces more ignorable files
+*.nuget.props
+*.nuget.targets
+
+# Microsoft Azure Build Output
+csx/
+*.build.csdef
+
+# Microsoft Azure Emulator
+ecf/
+rcf/
+
+# Windows Store app package directories and files
+AppPackages/
+BundleArtifacts/
+Package.StoreAssociation.xml
+_pkginfo.txt
+*.appx
+*.appxbundle
+*.appxupload
+
+# Visual Studio cache files
+# files ending in .cache can be ignored
+*.[Cc]ache
+# but keep track of directories ending in .cache
+!?*.[Cc]ache/
+
+# Others
+ClientBin/
+~$*
+*.dbmdl
+*.dbproj.schemaview
+*.jfm
+*.pfx
+*.publishsettings
+orleans.codegen.cs
+
+# Including strong name files can present a security risk
+# (https://github.com/github/gitignore/pull/2483#issue-259490424)
+#*.snk
+
+# Since there are multiple workflows, uncomment next line to ignore bower_components
+# (https://github.com/github/gitignore/pull/1529#issuecomment-104372622)
+#bower_components/
+
+# RIA/Silverlight projects
+Generated_Code/
+
+# Backup & report files from converting an old project file
+# to a newer Visual Studio version. Backup files are not needed,
+# because we have git ;-)
+_UpgradeReport_Files/
+Backup*/
+UpgradeLog*.XML
+UpgradeLog*.htm
+ServiceFabricBackup/
+*.rptproj.bak
+
+# SQL Server files
+*.mdf
+*.ldf
+*.ndf
+
+# Business Intelligence projects
+*.rdl.data
+*.bim.layout
+*.bim_*.settings
+*.rptproj.rsuser
+*- [Bb]ackup.rdl
+*- [Bb]ackup ([0-9]).rdl
+*- [Bb]ackup ([0-9][0-9]).rdl
+
+# Microsoft Fakes
+FakesAssemblies/
+
+# GhostDoc plugin setting file
+*.GhostDoc.xml
+
+# Node.js Tools for Visual Studio
+.ntvs_analysis.dat
+node_modules/
+
+# Visual Studio 6 build log
+*.plg
+
+# Visual Studio 6 workspace options file
+*.opt
+
+# Visual Studio 6 auto-generated workspace file (contains which files were open etc.)
+*.vbw
+
+# Visual Studio 6 auto-generated project file (contains which files were open etc.)
+*.vbp
+
+# Visual Studio 6 workspace and project file (working project files containing files to include in project)
+*.dsw
+*.dsp
+
+# Visual Studio 6 technical files
+
+# Visual Studio LightSwitch build output
+**/*.HTMLClient/GeneratedArtifacts
+**/*.DesktopClient/GeneratedArtifacts
+**/*.DesktopClient/ModelManifest.xml
+**/*.Server/GeneratedArtifacts
+**/*.Server/ModelManifest.xml
+_Pvt_Extensions
+
+# Paket dependency manager
+.paket/paket.exe
+paket-files/
+
+# FAKE - F# Make
+.fake/
+
+# CodeRush personal settings
+.cr/personal
+
+# Python Tools for Visual Studio (PTVS)
+
+# Cake - Uncomment if you are using it
+# tools/**
+# !tools/packages.config
+
+# Tabs Studio
+*.tss
+
+# Telerik's JustMock configuration file
+*.jmconfig
+
+# BizTalk build output
+*.btp.cs
+*.btm.cs
+*.odx.cs
+*.xsd.cs
+
+# OpenCover UI analysis results
+OpenCover/
+
+# Azure Stream Analytics local run output
+ASALocalRun/
+
+# MSBuild Binary and Structured Log
+*.binlog
+
+# NVidia Nsight GPU debugger configuration file
+*.nvuser
+
+# MFractors (Xamarin productivity tool) working folder
+.mfractor/
+
+# Local History for Visual Studio
+.localhistory/
+
+# Visual Studio History (VSHistory) files
+.vshistory/
+
+# BeatPulse healthcheck temp database
+healthchecksdb
+
+# Backup folder for Package Reference Convert tool in Visual Studio 2017
+MigrationBackup/
+
+# Ionide (cross platform F# VS Code tools) working folder
+.ionide/
+
+# Fody - auto-generated XML schema
+FodyWeavers.xsd
+
+# VS Code files for those working on multiple tools
+
+# Local History for Visual Studio Code
+
+# Windows Installer files from build outputs
+*.cab
+*.msi
+*.msix
+*.msm
+*.msp
+.obj-aarch64-linux-gnu/
+*.deb
+*.ddeb
+
+# JetBrains Rider
+*.sln.iml
+
+### VisualStudio Patch ###
+# Additional files built by Visual Studio
+
+# End of https://www.toptal.com/developers/gitignore/api/visualstudio,visualstudiocode,c++,python,jetbrains+all,ros,ros2
diff --git a/3rdparty/cmrc/src/cmake_resource.cmake b/3rdparty/cmrc/src/cmake_resource.cmake
new file mode 100644
index 00000000..88528ce8
--- /dev/null
+++ b/3rdparty/cmrc/src/cmake_resource.cmake
@@ -0,0 +1,644 @@
+# This block is executed when generating an intermediate resource file, not when
+# running in CMake configure mode
+if(_CMRC_GENERATE_MODE)
+    # Read in the digits
+    file(READ "${INPUT_FILE}" bytes HEX)
+    # Format each pair into a character literal. Heuristics seem to favor doing
+    # the conversion in groups of five for fastest conversion
+    string(REGEX REPLACE "(..)(..)(..)(..)(..)" "'\\\\x\\1','\\\\x\\2','\\\\x\\3','\\\\x\\4','\\\\x\\5'," chars "${bytes}")
+    # Since we did this in groups, we have some leftovers to clean up
+    string(LENGTH "${bytes}" n_bytes2)
+    math(EXPR n_bytes "${n_bytes2} / 2")
+    math(EXPR remainder "${n_bytes} % 5") # <-- '5' is the grouping count from above
+    set(cleanup_re "$")
+    set(cleanup_sub )
+    while(remainder)
+        set(cleanup_re "(..)${cleanup_re}")
+        set(cleanup_sub "'\\\\x\\${remainder}',${cleanup_sub}")
+        math(EXPR remainder "${remainder} - 1")
+    endwhile()
+    if(NOT cleanup_re STREQUAL "$")
+        string(REGEX REPLACE "${cleanup_re}" "${cleanup_sub}" chars "${chars}")
+    endif()
+    string(CONFIGURE [[
+        namespace { const char file_array[] = { @chars@ 0 }; }
+        namespace cmrc { namespace @NAMESPACE@ { namespace res_chars {
+        extern const char* const @SYMBOL@_begin = file_array;
+        extern const char* const @SYMBOL@_end = file_array + @n_bytes@;
+        }}}
+    ]] code)
+    file(WRITE "${OUTPUT_FILE}" "${code}")
+    # Exit from the script. Nothing else needs to be processed
+    return()
+endif()
+
+set(_version 2.0.0)
+
+cmake_minimum_required(VERSION 3.3)
+include(CMakeParseArguments)
+
+if(COMMAND cmrc_add_resource_library)
+    if(NOT DEFINED _CMRC_VERSION OR NOT (_version STREQUAL _CMRC_VERSION))
+        message(WARNING "More than one CMakeRC version has been included in this project.")
+    endif()
+    # CMakeRC has already been included! Don't do anything
+    return()
+endif()
+
+set(_CMRC_VERSION "${_version}" CACHE INTERNAL "CMakeRC version. Used for checking for conflicts")
+
+set(_CMRC_SCRIPT "${CMAKE_CURRENT_LIST_FILE}" CACHE INTERNAL "Path to CMakeRC script")
+
+function(_cmrc_normalize_path var)
+    set(path "${${var}}")
+    file(TO_CMAKE_PATH "${path}" path)
+    while(path MATCHES "//")
+        string(REPLACE "//" "/" path "${path}")
+    endwhile()
+    string(REGEX REPLACE "/+$" "" path "${path}")
+    set("${var}" "${path}" PARENT_SCOPE)
+endfunction()
+
+get_filename_component(_inc_dir "${CMAKE_BINARY_DIR}/_cmrc/include" ABSOLUTE)
+set(CMRC_INCLUDE_DIR "${_inc_dir}" CACHE INTERNAL "Directory for CMakeRC include files")
+# Let's generate the primary include file
+file(MAKE_DIRECTORY "${CMRC_INCLUDE_DIR}/cmrc")
+set(hpp_content [==[
+#ifndef CMRC_CMRC_HPP_INCLUDED
+#define CMRC_CMRC_HPP_INCLUDED
+
+#include <cassert>
+#include <functional>
+#include <iterator>
+#include <list>
+#include <map>
+#include <mutex>
+#include <string>
+#include <system_error>
+#include <type_traits>
+
+#if !(defined(__EXCEPTIONS) || defined(__cpp_exceptions) || defined(_CPPUNWIND) || defined(CMRC_NO_EXCEPTIONS))
+#define CMRC_NO_EXCEPTIONS 1
+#endif
+
+namespace cmrc { namespace detail { struct dummy; } }
+
+#define CMRC_DECLARE(libid) \
+    namespace cmrc { namespace detail { \
+    struct dummy; \
+    static_assert(std::is_same<dummy, ::cmrc::detail::dummy>::value, "CMRC_DECLARE() must only appear at the global namespace"); \
+    } } \
+    namespace cmrc { namespace libid { \
+    cmrc::embedded_filesystem get_filesystem(); \
+    } } static_assert(true, "")
+
+namespace cmrc {
+
+class file {
+    const char* _begin = nullptr;
+    const char* _end = nullptr;
+
+public:
+    using iterator = const char*;
+    using const_iterator = iterator;
+    iterator begin() const noexcept { return _begin; }
+    iterator cbegin() const noexcept { return _begin; }
+    iterator end() const noexcept { return _end; }
+    iterator cend() const noexcept { return _end; }
+    std::size_t size() const { return static_cast<std::size_t>(std::distance(begin(), end())); }
+
+    file() = default;
+    file(iterator beg, iterator end) noexcept : _begin(beg), _end(end) {}
+};
+
+class directory_entry;
+
+namespace detail {
+
+class directory;
+class file_data;
+
+class file_or_directory {
+    union _data_t {
+        class file_data* file_data;
+        class directory* directory;
+    } _data;
+    bool _is_file = true;
+
+public:
+    explicit file_or_directory(file_data& f) {
+        _data.file_data = &f;
+    }
+    explicit file_or_directory(directory& d) {
+        _data.directory = &d;
+        _is_file = false;
+    }
+    bool is_file() const noexcept {
+        return _is_file;
+    }
+    bool is_directory() const noexcept {
+        return !is_file();
+    }
+    const directory& as_directory() const noexcept {
+        assert(!is_file());
+        return *_data.directory;
+    }
+    const file_data& as_file() const noexcept {
+        assert(is_file());
+        return *_data.file_data;
+    }
+};
+
+class file_data {
+public:
+    const char* begin_ptr;
+    const char* end_ptr;
+    file_data(const file_data&) = delete;
+    file_data(const char* b, const char* e) : begin_ptr(b), end_ptr(e) {}
+};
+
+inline std::pair<std::string, std::string> split_path(const std::string& path) {
+    auto first_sep = path.find("/");
+    if (first_sep == path.npos) {
+        return std::make_pair(path, "");
+    } else {
+        return std::make_pair(path.substr(0, first_sep), path.substr(first_sep + 1));
+    }
+}
+
+struct created_subdirectory {
+    class directory& directory;
+    class file_or_directory& index_entry;
+};
+
+class directory {
+    std::list<file_data> _files;
+    std::list<directory> _dirs;
+    std::map<std::string, file_or_directory> _index;
+
+    using base_iterator = std::map<std::string, file_or_directory>::const_iterator;
+
+public:
+
+    directory() = default;
+    directory(const directory&) = delete;
+
+    created_subdirectory add_subdir(std::string name) & {
+        _dirs.emplace_back();
+        auto& back = _dirs.back();
+        auto& fod = _index.emplace(name, file_or_directory{back}).first->second;
+        return created_subdirectory{back, fod};
+    }
+
+    file_or_directory* add_file(std::string name, const char* begin, const char* end) & {
+        assert(_index.find(name) == _index.end());
+        _files.emplace_back(begin, end);
+        return &_index.emplace(name, file_or_directory{_files.back()}).first->second;
+    }
+
+    const file_or_directory* get(const std::string& path) const {
+        auto pair = split_path(path);
+        auto child = _index.find(pair.first);
+        if (child == _index.end()) {
+            return nullptr;
+        }
+        auto& entry  = child->second;
+        if (pair.second.empty()) {
+            // We're at the end of the path
+            return &entry;
+        }
+
+        if (entry.is_file()) {
+            // We can't traverse into a file. Stop.
+            return nullptr;
+        }
+        // Keep going down
+        return entry.as_directory().get(pair.second);
+    }
+
+    class iterator {
+        base_iterator _base_iter;
+        base_iterator _end_iter;
+    public:
+        using value_type = directory_entry;
+        using difference_type = std::ptrdiff_t;
+        using pointer = const value_type*;
+        using reference = const value_type&;
+        using iterator_category = std::input_iterator_tag;
+
+        iterator() = default;
+        explicit iterator(base_iterator iter, base_iterator end) : _base_iter(iter), _end_iter(end) {}
+
+        iterator begin() const noexcept {
+            return *this;
+        }
+
+        iterator end() const noexcept {
+            return iterator(_end_iter, _end_iter);
+        }
+
+        inline value_type operator*() const noexcept;
+
+        bool operator==(const iterator& rhs) const noexcept {
+            return _base_iter == rhs._base_iter;
+        }
+
+        bool operator!=(const iterator& rhs) const noexcept {
+            return !(*this == rhs);
+        }
+
+        iterator& operator++() noexcept {
+            ++_base_iter;
+            return *this;
+        }
+
+        iterator operator++(int) noexcept {
+            auto cp = *this;
+            ++_base_iter;
+            return cp;
+        }
+    };
+
+    using const_iterator = iterator;
+
+    iterator begin() const noexcept {
+        return iterator(_index.begin(), _index.end());
+    }
+
+    iterator end() const noexcept {
+        return iterator();
+    }
+};
+
+inline std::string normalize_path(std::string path) {
+    while (path.find("/") == 0) {
+        path.erase(path.begin());
+    }
+    while (!path.empty() && (path.rfind("/") == path.size() - 1)) {
+        path.pop_back();
+    }
+    auto off = path.npos;
+    while ((off = path.find("//")) != path.npos) {
+        path.erase(path.begin() + static_cast<std::string::difference_type>(off));
+    }
+    return path;
+}
+
+using index_type = std::map<std::string, const cmrc::detail::file_or_directory*>;
+
+} // detail
+
+class directory_entry {
+    std::string _fname;
+    const detail::file_or_directory* _item;
+
+public:
+    directory_entry() = delete;
+    explicit directory_entry(std::string filename, const detail::file_or_directory& item)
+        : _fname(filename)
+        , _item(&item)
+    {}
+
+    const std::string& filename() const & {
+        return _fname;
+    }
+    std::string filename() const && {
+        return std::move(_fname);
+    }
+
+    bool is_file() const {
+        return _item->is_file();
+    }
+
+    bool is_directory() const {
+        return _item->is_directory();
+    }
+};
+
+directory_entry detail::directory::iterator::operator*() const noexcept {
+    assert(begin() != end());
+    return directory_entry(_base_iter->first, _base_iter->second);
+}
+
+using directory_iterator = detail::directory::iterator;
+
+class embedded_filesystem {
+    // Never-null:
+    const cmrc::detail::index_type* _index;
+    const detail::file_or_directory* _get(std::string path) const {
+        path = detail::normalize_path(path);
+        auto found = _index->find(path);
+        if (found == _index->end()) {
+            return nullptr;
+        } else {
+            return found->second;
+        }
+    }
+
+public:
+    explicit embedded_filesystem(const detail::index_type& index)
+        : _index(&index)
+    {}
+
+    file open(const std::string& path) const {
+        auto entry_ptr = _get(path);
+        if (!entry_ptr || !entry_ptr->is_file()) {
+#ifdef CMRC_NO_EXCEPTIONS
+            fprintf(stderr, "Error no such file or directory: %s\n", path.c_str());
+            abort();
+#else
+            throw std::system_error(make_error_code(std::errc::no_such_file_or_directory), path);
+#endif
+        }
+        auto& dat = entry_ptr->as_file();
+        return file{dat.begin_ptr, dat.end_ptr};
+    }
+
+    bool is_file(const std::string& path) const noexcept {
+        auto entry_ptr = _get(path);
+        return entry_ptr && entry_ptr->is_file();
+    }
+
+    bool is_directory(const std::string& path) const noexcept {
+        auto entry_ptr = _get(path);
+        return entry_ptr && entry_ptr->is_directory();
+    }
+
+    bool exists(const std::string& path) const noexcept {
+        return !!_get(path);
+    }
+
+    directory_iterator iterate_directory(const std::string& path) const {
+        auto entry_ptr = _get(path);
+        if (!entry_ptr) {
+#ifdef CMRC_NO_EXCEPTIONS
+            fprintf(stderr, "Error no such file or directory: %s\n", path.c_str());
+            abort();
+#else
+            throw std::system_error(make_error_code(std::errc::no_such_file_or_directory), path);
+#endif
+        }
+        if (!entry_ptr->is_directory()) {
+#ifdef CMRC_NO_EXCEPTIONS
+            fprintf(stderr, "Error not a directory: %s\n", path.c_str());
+            abort();
+#else
+            throw std::system_error(make_error_code(std::errc::not_a_directory), path);
+#endif
+        }
+        return entry_ptr->as_directory().begin();
+    }
+};
+
+}
+
+#endif // CMRC_CMRC_HPP_INCLUDED
+]==])
+
+set(cmrc_hpp "${CMRC_INCLUDE_DIR}/cmrc/cmrc.hpp" CACHE INTERNAL "")
+set(_generate 1)
+if(EXISTS "${cmrc_hpp}")
+    file(READ "${cmrc_hpp}" _current)
+    if(_current STREQUAL hpp_content)
+        set(_generate 0)
+    endif()
+endif()
+file(GENERATE OUTPUT "${cmrc_hpp}" CONTENT "${hpp_content}" CONDITION ${_generate})
+
+add_library(cmrc-base INTERFACE)
+target_include_directories(cmrc-base INTERFACE $<BUILD_INTERFACE:${CMRC_INCLUDE_DIR}>)
+# Signal a basic C++11 feature to require C++11.
+target_compile_features(cmrc-base INTERFACE cxx_nullptr)
+set_property(TARGET cmrc-base PROPERTY INTERFACE_CXX_EXTENSIONS OFF)
+add_library(cmrc::base ALIAS cmrc-base)
+
+function(cmrc_add_resource_library name)
+    set(args ALIAS NAMESPACE TYPE)
+    cmake_parse_arguments(ARG "" "${args}" "" "${ARGN}")
+    # Generate the identifier for the resource library's namespace
+    set(ns_re "[a-zA-Z_][a-zA-Z0-9_]*")
+    if(NOT DEFINED ARG_NAMESPACE)
+        # Check that the library name is also a valid namespace
+        if(NOT name MATCHES "${ns_re}")
+            message(SEND_ERROR "Library name is not a valid namespace. Specify the NAMESPACE argument")
+        endif()
+        set(ARG_NAMESPACE "${name}")
+    else()
+        if(NOT ARG_NAMESPACE MATCHES "${ns_re}")
+            message(SEND_ERROR "NAMESPACE for ${name} is not a valid C++ namespace identifier (${ARG_NAMESPACE})")
+        endif()
+    endif()
+    set(libname "${name}")
+    # Check that type is either "STATIC" or "OBJECT", or default to "STATIC" if
+    # not set
+    if(NOT DEFINED ARG_TYPE)
+        set(ARG_TYPE STATIC)
+    elseif(NOT "${ARG_TYPE}" MATCHES "^(STATIC|OBJECT)$")
+        message(SEND_ERROR "${ARG_TYPE} is not a valid TYPE (STATIC and OBJECT are acceptable)")
+        set(ARG_TYPE STATIC)
+    endif()
+    # Generate a library with the compiled in character arrays.
+    string(CONFIGURE [=[
+        #include <cmrc/cmrc.hpp>
+        #include <map>
+        #include <utility>
+
+        namespace cmrc {
+        namespace @ARG_NAMESPACE@ {
+
+        namespace res_chars {
+        // These are the files which are available in this resource library
+        $<JOIN:$<TARGET_PROPERTY:@libname@,CMRC_EXTERN_DECLS>,
+        >
+        }
+
+        namespace {
+
+        const cmrc::detail::index_type&
+        get_root_index() {
+            static cmrc::detail::directory root_directory_;
+            static cmrc::detail::file_or_directory root_directory_fod{root_directory_};
+            static cmrc::detail::index_type root_index;
+            root_index.emplace("", &root_directory_fod);
+            struct dir_inl {
+                class cmrc::detail::directory& directory;
+            };
+            dir_inl root_directory_dir{root_directory_};
+            (void)root_directory_dir;
+            $<JOIN:$<TARGET_PROPERTY:@libname@,CMRC_MAKE_DIRS>,
+            >
+            $<JOIN:$<TARGET_PROPERTY:@libname@,CMRC_MAKE_FILES>,
+            >
+            return root_index;
+        }
+
+        }
+
+        cmrc::embedded_filesystem get_filesystem() {
+            static auto& index = get_root_index();
+            return cmrc::embedded_filesystem{index};
+        }
+
+        } // @ARG_NAMESPACE@
+        } // cmrc
+    ]=] cpp_content @ONLY)
+    get_filename_component(libdir "${CMAKE_CURRENT_BINARY_DIR}/__cmrc_${name}" ABSOLUTE)
+    get_filename_component(lib_tmp_cpp "${libdir}/lib_.cpp" ABSOLUTE)
+    string(REPLACE "\n        " "\n" cpp_content "${cpp_content}")
+    file(GENERATE OUTPUT "${lib_tmp_cpp}" CONTENT "${cpp_content}")
+    get_filename_component(libcpp "${libdir}/lib.cpp" ABSOLUTE)
+    add_custom_command(OUTPUT "${libcpp}"
+        DEPENDS "${lib_tmp_cpp}" "${cmrc_hpp}"
+        COMMAND ${CMAKE_COMMAND} -E copy_if_different "${lib_tmp_cpp}" "${libcpp}"
+        COMMENT "Generating ${name} resource loader"
+        )
+    # Generate the actual static library. Each source file is just a single file
+    # with a character array compiled in containing the contents of the
+    # corresponding resource file.
+    add_library(${name} ${ARG_TYPE} ${libcpp})
+    set_property(TARGET ${name} PROPERTY CMRC_LIBDIR "${libdir}")
+    set_property(TARGET ${name} PROPERTY CMRC_NAMESPACE "${ARG_NAMESPACE}")
+    target_link_libraries(${name} PUBLIC cmrc::base)
+    set_property(TARGET ${name} PROPERTY CMRC_IS_RESOURCE_LIBRARY TRUE)
+    if(ARG_ALIAS)
+        add_library("${ARG_ALIAS}" ALIAS ${name})
+    endif()
+    cmrc_add_resources(${name} ${ARG_UNPARSED_ARGUMENTS})
+endfunction()
+
+function(_cmrc_register_dirs name dirpath)
+    if(dirpath STREQUAL "")
+        return()
+    endif()
+    # Skip this dir if we have already registered it
+    get_target_property(registered "${name}" _CMRC_REGISTERED_DIRS)
+    if(dirpath IN_LIST registered)
+        return()
+    endif()
+    # Register the parent directory first
+    get_filename_component(parent "${dirpath}" DIRECTORY)
+    if(NOT parent STREQUAL "")
+        _cmrc_register_dirs("${name}" "${parent}")
+    endif()
+    # Now generate the registration
+    set_property(TARGET "${name}" APPEND PROPERTY _CMRC_REGISTERED_DIRS "${dirpath}")
+    _cm_encode_fpath(sym "${dirpath}")
+    if(parent STREQUAL "")
+        set(parent_sym root_directory)
+    else()
+        _cm_encode_fpath(parent_sym "${parent}")
+    endif()
+    get_filename_component(leaf "${dirpath}" NAME)
+    set_property(
+        TARGET "${name}"
+        APPEND PROPERTY CMRC_MAKE_DIRS
+        "static auto ${sym}_dir = ${parent_sym}_dir.directory.add_subdir(\"${leaf}\")\;"
+        "root_index.emplace(\"${dirpath}\", &${sym}_dir.index_entry)\;"
+        )
+endfunction()
+
+function(cmrc_add_resources name)
+    get_target_property(is_reslib ${name} CMRC_IS_RESOURCE_LIBRARY)
+    if(NOT TARGET ${name} OR NOT is_reslib)
+        message(SEND_ERROR "cmrc_add_resources called on target '${name}' which is not an existing resource library")
+        return()
+    endif()
+
+    set(options)
+    set(args WHENCE PREFIX)
+    set(list_args)
+    cmake_parse_arguments(ARG "${options}" "${args}" "${list_args}" "${ARGN}")
+
+    if(NOT ARG_WHENCE)
+        set(ARG_WHENCE ${CMAKE_CURRENT_SOURCE_DIR})
+    endif()
+    _cmrc_normalize_path(ARG_WHENCE)
+    get_filename_component(ARG_WHENCE "${ARG_WHENCE}" ABSOLUTE)
+
+    # Generate the identifier for the resource library's namespace
+    get_target_property(lib_ns "${name}" CMRC_NAMESPACE)
+
+    get_target_property(libdir ${name} CMRC_LIBDIR)
+    get_target_property(target_dir ${name} SOURCE_DIR)
+    file(RELATIVE_PATH reldir "${target_dir}" "${CMAKE_CURRENT_SOURCE_DIR}")
+    if(reldir MATCHES "^\\.\\.")
+        message(SEND_ERROR "Cannot call cmrc_add_resources in a parent directory from the resource library target")
+        return()
+    endif()
+
+    foreach(input IN LISTS ARG_UNPARSED_ARGUMENTS)
+        _cmrc_normalize_path(input)
+        get_filename_component(abs_in "${input}" ABSOLUTE)
+        # Generate a filename based on the input filename that we can put in
+        # the intermediate directory.
+        file(RELATIVE_PATH relpath "${ARG_WHENCE}" "${abs_in}")
+        if(relpath MATCHES "^\\.\\.")
+            # For now we just error on files that exist outside of the soure dir.
+            message(SEND_ERROR "Cannot add file '${input}': File must be in a subdirectory of ${ARG_WHENCE}")
+            continue()
+        endif()
+        if(DEFINED ARG_PREFIX)
+            _cmrc_normalize_path(ARG_PREFIX)
+        endif()
+        if(ARG_PREFIX AND NOT ARG_PREFIX MATCHES "/$")
+            set(ARG_PREFIX "${ARG_PREFIX}/")
+        endif()
+        get_filename_component(dirpath "${ARG_PREFIX}${relpath}" DIRECTORY)
+        _cmrc_register_dirs("${name}" "${dirpath}")
+        get_filename_component(abs_out "${libdir}/intermediate/${ARG_PREFIX}${relpath}.cpp" ABSOLUTE)
+        # Generate a symbol name relpath the file's character array
+        _cm_encode_fpath(sym "${relpath}")
+        # Get the symbol name for the parent directory
+        if(dirpath STREQUAL "")
+            set(parent_sym root_directory)
+        else()
+            _cm_encode_fpath(parent_sym "${dirpath}")
+        endif()
+        # Generate the rule for the intermediate source file
+        _cmrc_generate_intermediate_cpp(${lib_ns} ${sym} "${abs_out}" "${abs_in}")
+        target_sources(${name} PRIVATE "${abs_out}")
+        set_property(TARGET ${name} APPEND PROPERTY CMRC_EXTERN_DECLS
+            "// Pointers to ${input}"
+            "extern const char* const ${sym}_begin\;"
+            "extern const char* const ${sym}_end\;"
+            )
+        get_filename_component(leaf "${relpath}" NAME)
+        set_property(
+            TARGET ${name}
+            APPEND PROPERTY CMRC_MAKE_FILES
+            "root_index.emplace("
+            "    \"${ARG_PREFIX}${relpath}\","
+            "    ${parent_sym}_dir.directory.add_file("
+            "        \"${leaf}\","
+            "        res_chars::${sym}_begin,"
+            "        res_chars::${sym}_end"
+            "    )"
+            ")\;"
+            )
+    endforeach()
+endfunction()
+
+function(_cmrc_generate_intermediate_cpp lib_ns symbol outfile infile)
+    add_custom_command(
+        # This is the file we will generate
+        OUTPUT "${outfile}"
+        # These are the primary files that affect the output
+        DEPENDS "${infile}" "${_CMRC_SCRIPT}"
+        COMMAND
+            "${CMAKE_COMMAND}"
+                -D_CMRC_GENERATE_MODE=TRUE
+                -DNAMESPACE=${lib_ns}
+                -DSYMBOL=${symbol}
+                "-DINPUT_FILE=${infile}"
+                "-DOUTPUT_FILE=${outfile}"
+                -P "${_CMRC_SCRIPT}"
+        COMMENT "Generating intermediate file for ${infile}"
+    )
+endfunction()
+
+function(_cm_encode_fpath var fpath)
+    string(MAKE_C_IDENTIFIER "${fpath}" ident)
+    string(MD5 hash "${fpath}")
+    string(SUBSTRING "${hash}" 0 4 hash)
+    set(${var} f_${hash}_${ident} PARENT_SCOPE)
+endfunction()
\ No newline at end of file
diff --git a/3rdparty/dylib/CMakeLists.txt b/3rdparty/dylib/CMakeLists.txt
new file mode 100644
index 00000000..2f1ff544
--- /dev/null
+++ b/3rdparty/dylib/CMakeLists.txt
@@ -0,0 +1,9 @@
+cmake_minimum_required(VERSION 3.5)
+
+add_library(dylib INTERFACE)
+target_include_directories(dylib INTERFACE ${CMAKE_CURRENT_LIST_DIR}/src/include)
+if(UNIX)
+    target_link_libraries(dylib INTERFACE dl)
+endif()
+
+add_library(dylib::dylib ALIAS dylib)
diff --git a/3rdparty/dylib/src/.gitignore b/3rdparty/dylib/src/.gitignore
new file mode 100644
index 00000000..f56f7819
--- /dev/null
+++ b/3rdparty/dylib/src/.gitignore
@@ -0,0 +1,18 @@
+# Editor files and folders
+
+.idea/
+.vscode/
+.DS_Store
+*~
+\#*#
+
+# Build Folders
+
+cmake-build-*
+build
+
+# Coverage files
+
+*.gcda
+*.gcno
+*.gcov
\ No newline at end of file
diff --git a/3rdparty/dylib/src/CMakeLists.txt b/3rdparty/dylib/src/CMakeLists.txt
new file mode 100644
index 00000000..158ac18b
--- /dev/null
+++ b/3rdparty/dylib/src/CMakeLists.txt
@@ -0,0 +1,72 @@
+cmake_minimum_required(VERSION 3.14)
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake/")
+include(dylib)
+
+project(dylib CXX)
+
+if(NOT "${CMAKE_CXX_STANDARD}")
+  set(CMAKE_CXX_STANDARD 11)
+endif()
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+add_library(dylib INTERFACE)
+target_include_directories(dylib INTERFACE ${CMAKE_CURRENT_SOURCE_DIR}/include)
+if(UNIX)
+    target_link_libraries(dylib INTERFACE dl)
+endif()
+
+option(DYLIB_BUILD_TESTS "When set to ON, build unit tests" OFF)
+option(DYLIB_WARNING_AS_ERRORS "Treat warnings as errors" OFF)
+
+if(DYLIB_BUILD_TESTS)
+    set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR})
+    set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR})
+
+    find_package(googletest QUIET)
+    include(FetchContent)
+    FetchContent_Declare(
+        googletest
+        URL https://github.com/google/googletest/archive/refs/tags/release-1.12.1.zip
+    )
+    set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
+    FetchContent_MakeAvailable(googletest)
+
+    if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+        add_compile_options(-Wall -Wextra -Weffc++)
+    elseif(CMAKE_CXX_COMPILER_ID MATCHES ".*Clang")
+        add_compile_options(-Wall -Wextra)
+    elseif(MSVC)
+        add_compile_options(/W4)
+    endif()
+
+    if(DYLIB_WARNING_AS_ERRORS)
+        if(MSVC)
+            add_compile_options(/WX)
+        elseif(CMAKE_CXX_COMPILER_ID STREQUAL "GNU" OR CMAKE_CXX_COMPILER_ID MATCHES ".*Clang")
+            add_compile_options(-Werror)
+        endif()
+    endif()
+
+    add_library(dynamic_lib SHARED tests/lib.cpp)
+    if(WIN32 AND MINGW)
+        set_target_properties(dynamic_lib PROPERTIES PREFIX "")
+    endif()
+
+    enable_testing()
+
+    if(UNIX AND NOT APPLE)
+        add_compile_options(-fprofile-arcs -ftest-coverage)
+    endif()
+
+    add_executable(unit_tests tests/tests.cpp)
+    add_dependencies(unit_tests dynamic_lib)
+    target_link_libraries(unit_tests PRIVATE gtest_main dylib)
+
+    if(UNIX AND NOT APPLE)
+        target_link_libraries(unit_tests PRIVATE gcov)
+    endif()
+
+    include(GoogleTest)
+    gtest_discover_tests(unit_tests PROPERTIES DISCOVERY_TIMEOUT 600 WORKING_DIRECTORY ${PROJECT_BINARY_DIR})
+endif()
diff --git a/3rdparty/dylib/src/LICENSE b/3rdparty/dylib/src/LICENSE
new file mode 100644
index 00000000..60004464
--- /dev/null
+++ b/3rdparty/dylib/src/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Martin Olivier
+
+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.
diff --git a/3rdparty/dylib/src/README.md b/3rdparty/dylib/src/README.md
new file mode 100644
index 00000000..d71487a7
--- /dev/null
+++ b/3rdparty/dylib/src/README.md
@@ -0,0 +1,185 @@
+# dylib
+
+[![version](https://img.shields.io/badge/Version-2.2.1-blue.svg)](https://github.com/martin-olivier/dylib/releases/tag/v2.2.1)
+[![license](https://img.shields.io/badge/License-MIT-orange.svg)](https://github.com/martin-olivier/dylib/blob/main/LICENSE)
+[![cpp](https://img.shields.io/badge/Compatibility-C++11-darkgreen.svg)](https://isocpp.org)
+
+[![ci](https://github.com/martin-olivier/dylib/actions/workflows/CI.yml/badge.svg)](https://github.com/martin-olivier/dylib/actions/workflows/CI.yml)
+[![coverage](https://codecov.io/gh/martin-olivier/dylib/branch/main/graph/badge.svg)](https://codecov.io/gh/martin-olivier/dylib)
+
+The goal of this C++ library is to load dynamic libraries (.so, .dll, .dylib) and access its functions and global variables at runtime.
+
+`⭐ Don't forget to put a star if you like the project!`
+
+## Compatibility
+
+Works on `Linux`, `Windows`, `MacOS`
+
+## Installation
+
+You can fetch `dylib` to your project using `CMake`:
+
+```cmake
+include(FetchContent)
+
+FetchContent_Declare(
+    dylib
+    GIT_REPOSITORY "https://github.com/martin-olivier/dylib"
+    GIT_TAG        "v2.2.1"
+)
+
+FetchContent_MakeAvailable(dylib)
+```
+
+You can also click [HERE](https://github.com/martin-olivier/dylib/releases/download/v2.2.1/dylib.hpp) to download the `dylib` header file.
+
+## Documentation
+
+### Constructor
+
+The `dylib` class can load a dynamic library from the system library path
+
+```c++
+// Load "foo" library from the system library path
+
+dylib lib("foo");
+```
+
+The `dylib` class can also load a dynamic library from a specific path
+
+```c++
+// Load "foo" library from relative path "./libs"
+
+dylib lib("./libs", "foo");
+
+// Load "foo" library from full path "/usr/lib"
+
+dylib lib("/usr/lib", "foo");
+```
+
+The `dylib` class will automatically add the filename decorations of the current os to the library name, but you can disable that by setting `decorations` parameter to `dylib::no_filename_decorations`
+
+```c++
+// Windows -> "foo.dll"
+// MacOS   -> "libfoo.dylib"
+// Linux   -> "libfoo.so"
+
+dylib lib("foo");
+
+// Windows -> "foo.lib"
+// MacOS   -> "foo.lib"
+// Linux   -> "foo.lib"
+
+dylib lib("foo.lib", dylib::no_filename_decorations);
+```
+
+### Get a function or a variable
+
+`get_function`  
+Get a function from the dynamic library currently loaded in the object  
+
+`get_variable`  
+Get a global variable from the dynamic library currently loaded in the object
+
+```c++
+// Load "foo" dynamic library
+
+dylib lib("foo");
+
+// Get the function "adder" (get_function<T> will return T*)
+
+auto adder = lib.get_function<double(double, double)>("adder");
+
+// Get the variable "pi_value" (get_variable<T> will return T&)
+
+double pi = lib.get_variable<double>("pi_value");
+
+// Use the function "adder" with "pi_value"
+
+double result = adder(pi, pi);
+```
+
+### Miscellaneous tools
+
+`has_symbol`  
+Returns true if the symbol passed as parameter exists in the dynamic library, false otherwise
+
+`get_symbol`  
+Get a symbol from the dynamic library currently loaded in the object  
+
+`native_handle`  
+Returns the dynamic library handle
+
+```c++
+dylib lib("foo");
+
+if (lib.has_symbol("GetModule") == false)
+    std::cerr << "symbol 'GetModule' not found in 'foo' lib" << std::endl;
+
+dylib::native_handle_type handle = lib.native_handle();
+dylib::native_symbol_type symbol = lib.get_symbol("GetModule");
+
+assert(handle != nullptr && symbol != nullptr);
+assert(symbol == dlsym(handle, "GetModule"));
+```
+
+### Exceptions
+
+`load_error`  
+This exception is raised when the library failed to load or the library encountered symbol resolution issues  
+
+`symbol_error`  
+This exception is raised when the library failed to load a symbol  
+
+Those exceptions inherit from `dylib::exception`
+
+```c++
+try {
+    dylib lib("foo");
+    double pi_value = lib.get_variable<double>("pi_value");
+    std::cout << pi_value << std::endl;
+} catch (const dylib::load_error &) {
+    std::cerr << "failed to load 'foo' library" << std::endl;
+} catch (const dylib::symbol_error &) {
+    std::cerr << "failed to get 'pi_value' symbol" << std::endl;
+}
+```
+
+## Example
+
+A full example about the usage of the `dylib` library is available [HERE](example)
+
+## Tests
+
+To build unit tests, enter the following commands:
+
+```sh
+cmake . -B build -DDYLIB_BUILD_TESTS=ON
+cmake --build build
+```
+
+To run unit tests, enter the following command inside `build` directory:
+
+```sh
+ctest
+```
+
+## Community
+
+If you have any question about the usage of the library, do not hesitate to open a [discussion](https://github.com/martin-olivier/dylib/discussions)
+
+If you want to report a bug or provide a feature, do not hesitate to open an [issue](https://github.com/martin-olivier/dylib/issues) or submit a [pull request](https://github.com/martin-olivier/dylib/pulls)
+
+## Contributing
+
+Set the cmake flag `DYLIB_BUILD_TESTS` to `ON` to enable tests and make it easier for you to contribute
+
+```sh
+cmake . -B build -DDYLIB_BUILD_TESTS=ON
+```
+
+> Do not forget to sign your commits and use [conventional commits](https://www.conventionalcommits.org/en/v1.0.0/) when providing a pull request
+
+```sh
+git commit -s -m "feat: ..."
+```
diff --git a/3rdparty/dylib/src/cmake/dylib.cmake b/3rdparty/dylib/src/cmake/dylib.cmake
new file mode 100644
index 00000000..2293233a
--- /dev/null
+++ b/3rdparty/dylib/src/cmake/dylib.cmake
@@ -0,0 +1,76 @@
+set(CPACK_PACKAGE_NAME "dylib")
+set(CPACK_PACKAGE_VENDOR "Martin Olivier")
+set(CPACK_PACKAGE_VERSION_MAJOR "2")
+set(CPACK_PACKAGE_VERSION_MINOR "2")
+set(CPACK_PACKAGE_VERSION_PATCH "1")
+set(CPACK_PACKAGE_VERSION "${CPACK_PACKAGE_VERSION_MAJOR}.${CPACK_PACKAGE_VERSION_MINOR}.${CPACK_PACKAGE_VERSION_PATCH}")
+set(CPACK_PACKAGE_DESCRIPTION "C++ cross-platform wrapper around dynamic loading of shared libraries")
+set(CPACK_DEBIAN_PACKAGE_NAME "${CPACK_PACKAGE_NAME}")
+set(CPACK_RPM_PACKAGE_NAME "${CPACK_PACKAGE_NAME}")
+
+include(CPackComponent)
+include(CMakePackageConfigHelpers)
+
+set(PackagingTemplatesDir "${CMAKE_CURRENT_SOURCE_DIR}/packaging")
+
+set(LIB_NAME "dylib")
+set(CMAKE_EXPORT_NAME "${LIB_NAME}")
+set(PKG_CONFIG_NAME "${LIB_NAME}")
+
+cpack_add_component(dev
+	DISPLAY_NAME "${LIB_NAME} header"
+	DESCRIPTION "The header needed for using ${LIB_NAME} in own software"
+)
+
+install(FILES "${CMAKE_CURRENT_SOURCE_DIR}/include/${LIB_NAME}.hpp"
+	TYPE INCLUDE
+	COMPONENT "dev"
+)
+
+set(PKG_CONFIG_FILE_NAME "${CMAKE_CURRENT_BINARY_DIR}/${PKG_CONFIG_NAME}.pc")
+configure_file("${PackagingTemplatesDir}/pkgconfig.pc.in" "${PKG_CONFIG_FILE_NAME}" @ONLY)
+install(FILES "${PKG_CONFIG_FILE_NAME}"
+	DESTINATION "${CMAKE_INSTALL_LIBDIR}/pkgconfig"
+	COMPONENT "dev"
+)
+
+set(CMAKE_CONFIG_FILE_BASENAME "${CMAKE_EXPORT_NAME}Config.cmake")
+set(CMAKE_CONFIG_VERSION_FILE_BASENAME "${CMAKE_EXPORT_NAME}ConfigVersion.cmake")
+set(CMAKE_CONFIG_FILE_NAME "${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CONFIG_FILE_BASENAME}")
+configure_package_config_file("${PackagingTemplatesDir}/CMakeConfig.cmake.in" "${CMAKE_CONFIG_FILE_NAME}"
+	INSTALL_DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake"
+)
+
+set(CMAKE_CONFIG_VERSION_FILE_NAME "${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CONFIG_VERSION_FILE_BASENAME}")
+write_basic_package_version_file(
+	"${CMAKE_CONFIG_VERSION_FILE_NAME}"
+	VERSION "100500.100500.100500" # any version of same bitness suits. CMake cannot compare to infinity
+	COMPATIBILITY AnyNewerVersion
+)
+
+install(FILES "${CMAKE_CONFIG_FILE_NAME}" "${CMAKE_CONFIG_VERSION_FILE_NAME}"
+	DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/${CMAKE_EXPORT_NAME}"
+	COMPONENT "dev"
+)
+
+set("CPACK_DEBIAN_DEV_PACKAGE_NAME" "lib${LIB_NAME}-dev")
+set("CPACK_DEBIAN_DEV_PACKAGE_DEPENDS" "libc6-dev")
+set("CPACK_DEBIAN_DEV_PACKAGE_SUGGESTS" "cmake, pkg-config, pkg-conf")
+
+set("CPACK_RPM_DEV_PACKAGE_NAME" "lib${LIB_NAME}-devel")
+set("CPACK_RPM_DEV_PACKAGE_SUGGESTS" "${CPACK_DEBIAN_DEV_PACKAGE_SUGGESTS}")
+
+set(CPACK_COMPONENTS_ALL "dev")
+
+set(CPACK_PACKAGE_HOMEPAGE_URL "https://github.com/martin-olivier/dylib")
+set(CPACK_PACKAGE_MAINTAINER "${CPACK_PACKAGE_VENDOR}")
+set(CPACK_DEBIAN_PACKAGE_MAINTAINER "${CPACK_PACKAGE_MAINTAINER}")
+set(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_CURRENT_SOURCE_DIR}/LICENSE")
+set(CPACK_RESOURCE_FILE_README "${CMAKE_CURRENT_SOURCE_DIR}/README.md")
+set(CPACK_PACKAGE_MAINTAINER "${CPACK_PACKAGE_VENDOR}")
+set(CPACK_DEB_COMPONENT_INSTALL ON)
+set(CPACK_RPM_COMPONENT_INSTALL ON)
+set(CPACK_NSIS_COMPONENT_INSTALL ON)
+set(CPACK_DEBIAN_COMPRESSION_TYPE "xz")
+
+include(CPack)
diff --git a/3rdparty/dylib/src/example/CMakeLists.txt b/3rdparty/dylib/src/example/CMakeLists.txt
new file mode 100644
index 00000000..25deb7c0
--- /dev/null
+++ b/3rdparty/dylib/src/example/CMakeLists.txt
@@ -0,0 +1,30 @@
+cmake_minimum_required(VERSION 3.14)
+
+project(dylib_example)
+
+set(CMAKE_CXX_STANDARD 11)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR})
+set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR})
+
+# dylib fetch
+
+include(FetchContent)
+
+FetchContent_Declare(
+    dylib
+    GIT_REPOSITORY  "https://github.com/martin-olivier/dylib"
+    GIT_TAG         "v2.2.0"
+)
+
+FetchContent_MakeAvailable(dylib)
+
+# build lib.cpp into a shared library
+
+add_library(dynamic_lib SHARED lib.cpp)
+
+# build main.cpp into an executable
+
+add_executable(dylib_example main.cpp)
+target_link_libraries(dylib_example PRIVATE dylib)
diff --git a/3rdparty/dylib/src/example/README.md b/3rdparty/dylib/src/example/README.md
new file mode 100644
index 00000000..7f5d1f1a
--- /dev/null
+++ b/3rdparty/dylib/src/example/README.md
@@ -0,0 +1,129 @@
+# dylib example
+
+Here is an example about the usage of the `dylib` library in a project
+
+The functions and variables of our forthcoming dynamic library are located inside [lib.cpp](lib.cpp)
+
+```c++
+// lib.cpp
+
+#include <iostream>
+
+#if defined(_WIN32) || defined(_WIN64)
+#define LIB_EXPORT __declspec(dllexport)
+#else
+#define LIB_EXPORT
+#endif
+
+extern "C" {
+
+LIB_EXPORT double pi_value = 3.14159;
+LIB_EXPORT void *ptr = (void *)1;
+
+LIB_EXPORT double adder(double a, double b) {
+    return a + b;
+}
+
+LIB_EXPORT void print_hello() {
+    std::cout << "Hello" << std::endl;
+}
+
+} // extern "C"
+```
+
+The code that will load functions and global variables of our dynamic library at runtime is located inside [main.cpp](main.cpp)
+
+```c++
+// main.cpp
+
+#include <iostream>
+#include "dylib.hpp"
+
+int main() {
+    dylib lib("./", "dynamic_lib");
+
+    auto adder = lib.get_function<double(double, double)>("adder");
+    std::cout << adder(5, 10) << std::endl;
+
+    auto printer = lib.get_function<void()>("print_hello");
+    printer();
+
+    double pi_value = lib.get_variable<double>("pi_value");
+    std::cout << pi_value << std::endl;
+
+    void *ptr = lib.get_variable<void *>("ptr");
+    if (ptr == (void *)1) std::cout << 1 << std::endl;
+
+    return EXIT_SUCCESS;
+}
+```
+
+Then, we want a build system that will:
+
+- Fetch `dylib` into the project
+- Build [lib.cpp](lib.cpp) into a dynamic library
+- Build [main.cpp](main.cpp) into an executable
+
+This build system is located inside [CMakeLists.txt](CMakeLists.txt)
+
+```cmake
+# CMakeLists.txt
+
+cmake_minimum_required(VERSION 3.14)
+
+project(dylib_example)
+
+set(CMAKE_CXX_STANDARD 11)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR})
+set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR})
+
+# dylib fetch
+
+include(FetchContent)
+
+FetchContent_Declare(
+    dylib
+    GIT_REPOSITORY  "https://github.com/martin-olivier/Dylib"
+    GIT_TAG         "v2.2.0"
+)
+
+FetchContent_MakeAvailable(dylib)
+
+# build lib.cpp into a shared library
+
+add_library(dynamic_lib SHARED lib.cpp)
+
+# build main.cpp into an executable
+
+add_executable(dylib_example main.cpp)
+target_link_libraries(dylib_example PRIVATE dylib)
+```
+
+Let's build our code:
+> Make sure to type the following commands inside the `example` folder
+
+```sh
+cmake . -B build
+cmake --build build
+```
+
+Let's run our code:
+
+```sh
+# on unix, run the following command inside "build" folder
+./dylib_example
+
+# on windows, run the following command inside "build/Debug" folder
+./dylib_example.exe
+```
+
+You will have the following result:
+
+```sh
+15
+Hello
+3.14159
+1
+```
diff --git a/3rdparty/dylib/src/example/lib.cpp b/3rdparty/dylib/src/example/lib.cpp
new file mode 100644
index 00000000..25786a7e
--- /dev/null
+++ b/3rdparty/dylib/src/example/lib.cpp
@@ -0,0 +1,22 @@
+#include <iostream>
+
+#if defined(_WIN32) || defined(_WIN64)
+#define LIB_EXPORT __declspec(dllexport)
+#else
+#define LIB_EXPORT
+#endif
+
+extern "C" {
+
+LIB_EXPORT double pi_value = 3.14159;
+LIB_EXPORT void *ptr = (void *)1;
+
+LIB_EXPORT double adder(double a, double b) {
+    return a + b;
+}
+
+LIB_EXPORT void print_hello() {
+    std::cout << "Hello" << std::endl;
+}
+
+} // extern "C"
diff --git a/3rdparty/dylib/src/example/main.cpp b/3rdparty/dylib/src/example/main.cpp
new file mode 100644
index 00000000..f31b9dd4
--- /dev/null
+++ b/3rdparty/dylib/src/example/main.cpp
@@ -0,0 +1,20 @@
+#include <iostream>
+#include "dylib.hpp"
+
+int main() {
+    dylib lib("./", "dynamic_lib");
+
+    auto adder = lib.get_function<double(double, double)>("adder");
+    std::cout << adder(5, 10) << std::endl;
+
+    auto printer = lib.get_function<void()>("print_hello");
+    printer();
+
+    double pi_value = lib.get_variable<double>("pi_value");
+    std::cout << pi_value << std::endl;
+
+    void *ptr = lib.get_variable<void *>("ptr");
+    if (ptr == (void *)1) std::cout << 1 << std::endl;
+
+    return EXIT_SUCCESS;
+}
\ No newline at end of file
diff --git a/3rdparty/dylib/src/include/dylib.hpp b/3rdparty/dylib/src/include/dylib.hpp
new file mode 100644
index 00000000..e67654b1
--- /dev/null
+++ b/3rdparty/dylib/src/include/dylib.hpp
@@ -0,0 +1,310 @@
+/**
+ * @file dynamic_library.hpp
+ * @version 2.2.1
+ * @brief C++ cross-platform wrapper around dynamic loading of shared libraries
+ * @link https://github.com/martin-olivier/dynamic_library
+ *
+ * @author Martin Olivier <martin.olivier@live.fr>
+ * @copyright (c) 2023 Martin Olivier
+ *
+ * This library is released under MIT license
+ */
+
+#pragma once
+
+#include <string>
+#include <stdexcept>
+#include <utility>
+
+#if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L)
+#define DYLIB_CPP17
+#include <filesystem>
+#endif
+
+#if (defined(_WIN32) || defined(_WIN64))
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#undef WIN32_LEAN_AND_MEAN
+#else
+#include <windows.h>
+#endif
+#else
+#include <dlfcn.h>
+#endif
+
+#if (defined(_WIN32) || defined(_WIN64))
+#define DYLIB_WIN_MAC_OTHER(win_def, mac_def, other_def) win_def
+#define DYLIB_WIN_OTHER(win_def, other_def) win_def
+#elif defined(__APPLE__)
+#define DYLIB_WIN_MAC_OTHER(win_def, mac_def, other_def) mac_def
+#define DYLIB_WIN_OTHER(win_def, other_def) other_def
+#else
+#define DYLIB_WIN_MAC_OTHER(win_def, mac_def, other_def) other_def
+#define DYLIB_WIN_OTHER(win_def, other_def) other_def
+#endif
+
+/**
+ *  The dynamic_library class can hold a dynamic library instance and interact with it
+ *  by getting its symbols like functions or global variables
+ */
+class dylib {
+public:
+    struct filename_components {
+        static constexpr const char *prefix = DYLIB_WIN_OTHER("", "lib");
+        static constexpr const char *suffix = DYLIB_WIN_MAC_OTHER(".dll", ".dylib", ".so");
+    };
+    using native_handle_type = DYLIB_WIN_OTHER(HINSTANCE, void *);
+    using native_symbol_type = DYLIB_WIN_OTHER(FARPROC, void *);
+
+    static_assert(std::is_pointer<native_handle_type>::value, "Expecting HINSTANCE to be a pointer");
+    static_assert(std::is_pointer<native_symbol_type>::value, "Expecting FARPROC to be a pointer");
+
+    static constexpr bool add_filename_decorations = true;
+    static constexpr bool no_filename_decorations = false;
+
+    /**
+     *  This exception is raised when the library failed to load a dynamic library or a symbol
+     *
+     *  @param message the error message
+     */
+    class exception : public std::runtime_error {
+    public:
+        explicit exception(const std::string &message) : std::runtime_error(message) {}
+    };
+
+    /**
+     *  This exception is raised when the library failed to load or encountered symbol resolution issues
+     *
+     *  @param message the error message
+     */
+    class load_error : public exception {
+    public:
+        explicit load_error(const std::string &message) : exception(message) {}
+    };
+
+    /**
+     *  This exception is raised when the library failed to load a symbol
+     *
+     *  @param message the error message
+     */
+    class symbol_error : public exception {
+    public:
+        explicit symbol_error(const std::string &message) : exception(message) {}
+    };
+
+    dylib(const dylib &) = delete;
+    dylib & operator=(const dylib &) = delete;
+
+    dylib(dylib &&other) noexcept : m_handle(other.m_handle) {
+        other.m_handle = nullptr;
+    }
+
+    dylib & operator=(dylib &&other) noexcept {
+        if (this != &other)
+            std::swap(m_handle, other.m_handle);
+        return *this;
+    }
+
+    /**
+     *  @brief Loads a dynamic library
+     *
+     *  @throws dylib::load_error if the library could not be opened (including
+     *  the case of the library file not being found)
+     *
+     *  @param dir_path the directory path where is located the dynamic library you want to load
+     *  @param name the name of the dynamic library to load
+     *  @param decorations add os decorations to the library name
+     */
+    ///@{
+    dylib(const char *dir_path, const char *lib_name, bool decorations = add_filename_decorations) {
+        if (!dir_path || !lib_name)
+            throw std::invalid_argument("Null parameter");
+
+        std::string final_name = lib_name;
+        std::string final_path = dir_path;
+
+        if (decorations)
+            final_name = filename_components::prefix + final_name + filename_components::suffix;
+
+        if (!final_path.empty() && final_path.find_last_of('/') != final_path.size() - 1)
+            final_path += '/';
+
+        m_handle = open((final_path + final_name).c_str());
+
+        if(!m_handle) {
+            throw load_error("Could not load library \"" + final_path + final_name + "\"\n" + get_error_description());
+        }
+    }
+
+    dylib(const std::string &dir_path, const std::string &lib_name, bool decorations = add_filename_decorations)
+        : dylib(dir_path.c_str(), lib_name.c_str(), decorations) {}
+
+    dylib(const std::string &dir_path, const char *lib_name, bool decorations = add_filename_decorations)
+        : dylib(dir_path.c_str(), lib_name, decorations) {}
+
+    dylib(const char *dir_path, const std::string &lib_name, bool decorations = add_filename_decorations)
+        : dylib(dir_path, lib_name.c_str(), decorations) {}
+
+    explicit dylib(const std::string &lib_name, bool decorations = add_filename_decorations)
+        : dylib("", lib_name.c_str(), decorations) {}
+
+    explicit dylib(const char *lib_name, bool decorations = add_filename_decorations)
+        : dylib("", lib_name, decorations) {}
+
+#ifdef DYLIB_CPP17
+    explicit dylib(const std::filesystem::path &lib_path)
+        : dylib("", lib_path.string().c_str(), no_filename_decorations) {}
+
+    dylib(const std::filesystem::path &dir_path, const std::string &lib_name, bool decorations = add_filename_decorations)
+        : dylib(dir_path.string().c_str(), lib_name.c_str(), decorations) {}
+
+    dylib(const std::filesystem::path &dir_path, const char *lib_name, bool decorations = add_filename_decorations)
+        : dylib(dir_path.string().c_str(), lib_name, decorations) {}
+#endif
+    ///@}
+
+    ~dylib() {
+        if (m_handle)
+            close(m_handle);
+    }
+
+    /**
+     *  Get a symbol from the dynamic library currently loaded in the object
+     *
+     *  @throws dylib::symbol_error if the symbol could not be found
+     *
+     *  @param symbol_name the symbol name to get from the dynamic library
+     *
+     *  @return a pointer to the requested symbol
+     */
+    native_symbol_type get_symbol(const char *symbol_name) const {
+        if (!symbol_name)
+            throw std::invalid_argument("Null parameter");
+        if (!m_handle)
+            throw std::logic_error("The dynamic library handle is null");
+
+        auto symbol = locate_symbol(m_handle, symbol_name);
+
+        if (symbol == nullptr)
+            throw symbol_error("Could not get symbol \"" + std::string(symbol_name) + "\"\n" + get_error_description());
+        return symbol;
+    }
+
+    native_symbol_type get_symbol(const std::string &symbol_name) const {
+        return get_symbol(symbol_name.c_str());
+    }
+
+    /**
+     *  Get a function from the dynamic library currently loaded in the object
+     *
+     *  @throws dylib::symbol_error if the symbol could not be found
+     *
+     *  @param T the template argument must be the function prototype to get
+     *  @param symbol_name the symbol name of a function to get from the dynamic library
+     *
+     *  @return a pointer to the requested function
+     */
+    template<typename T>
+    T *get_function(const char *symbol_name) const {
+#if (defined(__GNUC__) && __GNUC__ >= 8)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wcast-function-type"
+#endif
+        return reinterpret_cast<T *>(get_symbol(symbol_name));
+#if (defined(__GNUC__) && __GNUC__ >= 8)
+#pragma GCC diagnostic pop
+#endif
+    }
+
+    template<typename T>
+    T *get_function(const std::string &symbol_name) const {
+        return get_function<T>(symbol_name.c_str());
+    }
+
+    /**
+     *  Get a variable from the dynamic library currently loaded in the object
+     *
+     *  @throws dylib::symbol_error if the symbol could not be found
+     *
+     *  @param T the template argument must be the type of the variable to get
+     *  @param symbol_name the symbol name of a variable to get from the dynamic library
+     *
+     *  @return a reference to the requested variable
+     */
+    template<typename T>
+    T &get_variable(const char *symbol_name) const {
+        return *reinterpret_cast<T *>(get_symbol(symbol_name));
+    }
+
+    template<typename T>
+    T &get_variable(const std::string &symbol_name) const {
+        return get_variable<T>(symbol_name.c_str());
+    }
+
+    /**
+     *  Check if a symbol exists in the currently loaded dynamic library.
+     *  This method will return false if no dynamic library is currently loaded
+     *  or if the symbol name is nullptr
+     *
+     *  @param symbol_name the symbol name to look for
+     *
+     *  @return true if the symbol exists in the dynamic library, false otherwise
+     */
+    bool has_symbol(const char *symbol_name) const noexcept {
+        if (!m_handle || !symbol_name)
+            return false;
+        return locate_symbol(m_handle, symbol_name) != nullptr;
+    }
+
+    bool has_symbol(const std::string &symbol) const noexcept {
+        return has_symbol(symbol.c_str());
+    }
+
+    /**
+     *  @return the dynamic library handle
+     */
+    native_handle_type native_handle() noexcept {
+        return m_handle;
+    }
+
+protected:
+    native_handle_type m_handle{nullptr};
+
+    static native_handle_type open(const char *path) noexcept {
+#if (defined(_WIN32) || defined(_WIN64))
+        return LoadLibraryA(path);
+#else
+        return dlopen(path, RTLD_NOW | RTLD_LOCAL);
+#endif
+    }
+
+    static native_symbol_type locate_symbol(native_handle_type lib, const char *name) noexcept {
+        return DYLIB_WIN_OTHER(GetProcAddress, dlsym)(lib, name);
+    }
+
+    static void close(native_handle_type lib) noexcept {
+        DYLIB_WIN_OTHER(FreeLibrary, dlclose)(lib);
+    }
+
+    static std::string get_error_description() noexcept {
+#if (defined(_WIN32) || defined(_WIN64))
+        constexpr const size_t buf_size = 512;
+        auto error_code = GetLastError();
+        if (!error_code)
+            return "Unknown error (GetLastError failed)";
+        char description[512];
+        auto lang = MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US);
+        const DWORD length =
+            FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM, nullptr, error_code, lang, description, buf_size, nullptr);
+        return (length == 0) ? "Unknown error (FormatMessage failed)" : description;
+#else
+        auto description = dlerror();
+        return (description == nullptr) ? "Unknown error (dlerror failed)" : description;
+#endif
+    }
+};
+
+#undef DYLIB_WIN_MAC_OTHER
+#undef DYLIB_WIN_OTHER
+#undef DYLIB_CPP17
diff --git a/3rdparty/dylib/src/packaging/CMakeConfig.cmake.in b/3rdparty/dylib/src/packaging/CMakeConfig.cmake.in
new file mode 100644
index 00000000..5b417369
--- /dev/null
+++ b/3rdparty/dylib/src/packaging/CMakeConfig.cmake.in
@@ -0,0 +1,7 @@
+@PACKAGE_INIT@
+
+
+message(STATUS "@CMAKE_EXPORT_NAME@Config.cmake")
+find_package(PkgConfig REQUIRED)
+pkg_check_modules("@CMAKE_EXPORT_NAME@" "@PKG_CONFIG_NAME@")
+check_required_components("@CMAKE_EXPORT_NAME@")
\ No newline at end of file
diff --git a/3rdparty/dylib/src/packaging/pkgconfig.pc.in b/3rdparty/dylib/src/packaging/pkgconfig.pc.in
new file mode 100644
index 00000000..ac5bd2ce
--- /dev/null
+++ b/3rdparty/dylib/src/packaging/pkgconfig.pc.in
@@ -0,0 +1,9 @@
+prefix=@CMAKE_INSTALL_PREFIX@
+libdir=${prefix}/@CMAKE_INSTALL_LIBDIR@
+includedir=${prefix}/@CMAKE_INSTALL_INCLUDEDIR@
+
+Name: @PKG_CONFIG_NAME@
+Description: @CPACK_PACKAGE_DESCRIPTION@
+Version: @CPACK_PACKAGE_VERSION@
+Libs: -L${libdir} -l@LIB_FILE_NAME@
+Cflags: -I${includedir}
\ No newline at end of file
diff --git a/3rdparty/dylib/src/tests/lib.cpp b/3rdparty/dylib/src/tests/lib.cpp
new file mode 100644
index 00000000..f68ad488
--- /dev/null
+++ b/3rdparty/dylib/src/tests/lib.cpp
@@ -0,0 +1,22 @@
+#include <iostream>
+
+#if defined(_WIN32) || defined(_WIN64)
+#define LIB_EXPORT __declspec(dllexport)
+#else
+#define LIB_EXPORT
+#endif
+
+extern "C" {
+
+LIB_EXPORT double pi_value = 3.14159;
+LIB_EXPORT void *ptr = (void *)1;
+
+LIB_EXPORT double adder(double a, double b) {
+    return a + b;
+}
+
+LIB_EXPORT void print_hello() {
+    std::cout << "Hello" << std::endl;
+}
+
+} // extern "C"
\ No newline at end of file
diff --git a/3rdparty/dylib/src/tests/tests.cpp b/3rdparty/dylib/src/tests/tests.cpp
new file mode 100644
index 00000000..0c3c1a0a
--- /dev/null
+++ b/3rdparty/dylib/src/tests/tests.cpp
@@ -0,0 +1,188 @@
+#include <gtest/gtest.h>
+#include <utility>
+#include "Dylib.hpp"
+
+TEST(example, example_test) {
+    testing::internal::CaptureStdout();
+    dylib lib("./", "dynamic_lib");
+
+    auto adder = lib.get_function<double(double, double)>("adder");
+    EXPECT_EQ(adder(5, 10), 15);
+
+    auto printer = lib.get_function<void()>("print_hello");
+    printer();
+    EXPECT_EQ(testing::internal::GetCapturedStdout(), "Hello\n");
+
+    double pi_value = lib.get_variable<double>("pi_value");
+    EXPECT_EQ(pi_value, 3.14159);
+
+    void *ptr = lib.get_variable<void *>("ptr");
+    EXPECT_EQ(ptr, (void *)1);
+}
+
+TEST(ctor, bad_library) {
+    try {
+        dylib lib("./", "no_such_library");
+        EXPECT_EQ(true, false);
+    }
+    catch (const dylib::load_error &) {
+        EXPECT_EQ(true, true);
+    }
+}
+
+TEST(multiple_handles, basic_test) {
+    dylib libA("./", "dynamic_lib");
+    dylib libB("./", "dynamic_lib");
+}
+
+TEST(get_function, bad_symbol) {
+    try {
+        dylib lib("./", "dynamic_lib");
+        lib.get_function<double(double, double)>("unknown");
+        EXPECT_EQ(true, false);
+    }
+    catch (const dylib::symbol_error &) {
+        EXPECT_EQ(true, true);
+    }
+}
+
+TEST(get_variable, bad_symbol) {
+    try {
+        dylib lib("./", "dynamic_lib");
+        lib.get_variable<double>("unknown");
+        EXPECT_EQ(true, false);
+    }
+    catch (const dylib::symbol_error &) {
+        EXPECT_EQ(true, true);
+    }
+}
+
+TEST(get_variable, alter_variables) {
+    dylib lib("./", "dynamic_lib");
+
+    auto &pi = lib.get_variable<double>("pi_value");
+    EXPECT_EQ(pi, 3.14159);
+    pi = 123;
+    auto &pi1 = lib.get_variable<double>("pi_value");
+    EXPECT_EQ(pi1, 123);
+
+    auto &ptr = lib.get_variable<void *>("ptr");
+    EXPECT_EQ(ptr, (void *)1);
+    ptr = &lib;
+    auto &ptr1 = lib.get_variable<void *>("ptr");
+    EXPECT_EQ(ptr1, &lib);
+}
+
+TEST(invalid_argument, null_pointer) {
+    try {
+        dylib(nullptr);
+        EXPECT_EQ(true, false);
+    }
+    catch (const std::invalid_argument &) {
+        EXPECT_EQ(true, true);
+    }
+    try {
+        dylib lib("./", "dynamic_lib");
+        lib.get_function<void()>(nullptr);
+        EXPECT_EQ(true, false);
+    }
+    catch (const std::invalid_argument &) {
+        EXPECT_EQ(true, true);
+    }
+    try {
+        dylib lib("./", "dynamic_lib");
+        lib.get_variable<void *>(nullptr);
+        EXPECT_EQ(true, false);
+    }
+    catch (const std::invalid_argument &) {
+        EXPECT_EQ(true, true);
+    }
+}
+
+TEST(manual_decorations, basic_test) {
+    dylib lib(".", dylib::filename_components::prefix + std::string("dynamic_lib") + dylib::filename_components::suffix, dylib::no_filename_decorations);
+    auto pi = lib.get_variable<double>("pi_value");
+    EXPECT_EQ(pi, 3.14159);
+}
+
+TEST(std_move, basic_test) {
+    try {
+        dylib lib("./", "dynamic_lib");
+        dylib other(std::move(lib));
+        auto pi = other.get_variable<double>("pi_value");
+        EXPECT_EQ(pi, 3.14159);
+        lib = std::move(other);
+        auto ptr = lib.get_variable<void *>("ptr");
+        EXPECT_EQ(ptr, (void *)1);
+        other.get_variable<double>("pi_value");
+        EXPECT_EQ(true, false);
+    }
+    catch (const std::logic_error &) {
+        EXPECT_EQ(true, true);
+    }
+}
+
+TEST(has_symbol, basic_test) {
+    dylib dummy("./", "dynamic_lib");
+    dylib lib(std::move(dummy));
+
+    EXPECT_TRUE(lib.has_symbol("pi_value"));
+    EXPECT_FALSE(lib.has_symbol("bad_symbol"));
+    EXPECT_FALSE(lib.has_symbol(nullptr));
+    EXPECT_FALSE(dummy.has_symbol("pi_value"));
+}
+
+TEST(handle_management, basic_test) {
+    dylib lib("./", "dynamic_lib");
+    EXPECT_FALSE(lib.native_handle() == nullptr);
+    auto handle = lib.native_handle();
+#if (defined(_WIN32) || defined(_WIN64))
+    auto sym = GetProcAddress(handle, "adder");
+#else
+    auto sym = dlsym(handle, "adder");
+#endif
+    EXPECT_FALSE(sym == nullptr);
+#if (defined(__GNUC__) && __GNUC__ >= 8)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wcast-function-type"
+#endif
+    auto res = ((double (*)(double, double))(sym))(10, 10);
+#if (defined(__GNUC__) && __GNUC__ >= 8)
+#pragma GCC diagnostic pop
+#endif
+    EXPECT_EQ(res, 20);
+}
+
+TEST(system_lib, basic_test) {
+#if (defined(_WIN32) || defined(_WIN64))
+    dylib lib("kernel32");
+    lib.get_function<DWORD()>("GetCurrentThreadId");
+#elif defined(__APPLE__)
+    dylib lib("ssh2");
+    lib.get_function<const char *(int)>("libssh2_version");
+#endif
+}
+
+#if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L)
+TEST(filesystem, basic_test) {
+    bool has_sym = dylib(std::filesystem::path("."), "dynamic_lib").has_symbol("pi_value");
+    EXPECT_TRUE(has_sym);
+
+    bool found = false;
+    for (const auto &file : std::filesystem::recursive_directory_iterator(".")) {
+        if (file.path().extension() == dylib::filename_components::suffix) {
+            try {
+                dylib lib(file.path());
+                if (lib.has_symbol("pi_value"))
+                    found = true;
+            } catch (const std::exception &) {}
+        }
+    }
+    EXPECT_TRUE(found);
+}
+#endif
+
+int main(int ac, char **av) {
+    testing::InitGoogleTest(&ac, av);
+    return RUN_ALL_TESTS();
+}
diff --git a/3rdparty/jsoncpp/CMakeLists.txt b/3rdparty/jsoncpp/CMakeLists.txt
new file mode 100644
index 00000000..972c502b
--- /dev/null
+++ b/3rdparty/jsoncpp/CMakeLists.txt
@@ -0,0 +1,12 @@
+cmake_minimum_required(VERSION 3.5)
+
+add_subdirectory(src)
+
+# remove warning as error
+get_target_property(compile_options jsoncpp_static COMPILE_OPTIONS)
+list(REMOVE_ITEM compile_options "-Werror" "/WX" "-Wpedantic")
+set_target_properties(jsoncpp_static PROPERTIES COMPILE_OPTIONS "${compile_options}")
+
+add_library(jsoncpp::jsoncpp ALIAS jsoncpp_static)
+ob_source_group(jsoncpp::jsoncpp)
+set_target_properties(jsoncpp_static PROPERTIES FOLDER "dependencies")
diff --git a/3rdparty/jsoncpp/src/.clang-format b/3rdparty/jsoncpp/src/.clang-format
new file mode 100644
index 00000000..2a806695
--- /dev/null
+++ b/3rdparty/jsoncpp/src/.clang-format
@@ -0,0 +1,4 @@
+BasedOnStyle:  LLVM
+DerivePointerAlignment: false
+PointerAlignment: Left
+
diff --git a/3rdparty/jsoncpp/src/.clang-tidy b/3rdparty/jsoncpp/src/.clang-tidy
new file mode 100644
index 00000000..99e914df
--- /dev/null
+++ b/3rdparty/jsoncpp/src/.clang-tidy
@@ -0,0 +1,11 @@
+---
+Checks:          'google-readability-casting,modernize-deprecated-headers,modernize-loop-convert,modernize-use-auto,modernize-use-default-member-init,modernize-use-using,readability-else-after-return,readability-redundant-member-init,readability-redundant-string-cstr'
+WarningsAsErrors: ''
+HeaderFilterRegex: ''
+AnalyzeTemporaryDtors: false
+FormatStyle:     none
+CheckOptions:
+  - key:             modernize-use-using.IgnoreMacros
+    value:           '0'
+...
+
diff --git a/3rdparty/jsoncpp/src/.gitattributes b/3rdparty/jsoncpp/src/.gitattributes
new file mode 100644
index 00000000..22d2b7a4
--- /dev/null
+++ b/3rdparty/jsoncpp/src/.gitattributes
@@ -0,0 +1,11 @@
+*           text=auto
+*.h         text
+*.cpp       text
+*.json      text
+*.in        text
+*.sh        eol=lf
+*.bat       eol=crlf
+*.vcproj    eol=crlf
+*.vcxproj   eol=crlf
+*.sln       eol=crlf
+devtools/agent_vm* eol=crlf
diff --git a/3rdparty/jsoncpp/src/.github/ISSUE_TEMPLATE/bug_report.md b/3rdparty/jsoncpp/src/.github/ISSUE_TEMPLATE/bug_report.md
new file mode 100644
index 00000000..35477097
--- /dev/null
+++ b/3rdparty/jsoncpp/src/.github/ISSUE_TEMPLATE/bug_report.md
@@ -0,0 +1,26 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+**To Reproduce**
+Steps to reproduce the behavior:
+1.
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.
+
+**Desktop (please complete the following information):**
+ - OS: [e.g. iOS]
+ - Meson version
+ - Ninja version
+
+**Additional context**
+Add any other context about the problem here.
diff --git a/3rdparty/jsoncpp/src/.github/ISSUE_TEMPLATE/feature_request.md b/3rdparty/jsoncpp/src/.github/ISSUE_TEMPLATE/feature_request.md
new file mode 100644
index 00000000..bbcbbe7d
--- /dev/null
+++ b/3rdparty/jsoncpp/src/.github/ISSUE_TEMPLATE/feature_request.md
@@ -0,0 +1,20 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.
diff --git a/3rdparty/jsoncpp/src/.gitignore b/3rdparty/jsoncpp/src/.gitignore
new file mode 100644
index 00000000..9682782f
--- /dev/null
+++ b/3rdparty/jsoncpp/src/.gitignore
@@ -0,0 +1,57 @@
+/build/
+/build-*/
+*.pyc
+*.swp
+*.actual
+*.actual-rewrite
+*.process-output
+*.rewrite
+/bin/
+/libs/
+/doc/doxyfile
+/dist/
+/.cache/
+
+# MSVC project files:
+*.sln
+*.vcxproj
+*.filters
+*.user
+*.sdf
+*.opensdf
+*.suo
+
+# MSVC build files:
+*.lib
+*.obj
+*.tlog/
+*.pdb
+
+# CMake-generated files:
+CMakeFiles/
+/pkg-config/jsoncpp.pc
+jsoncpp_lib_static.dir/
+compile_commands.json
+
+# In case someone runs cmake in the root-dir:
+/CMakeCache.txt
+/Makefile
+/include/Makefile
+/src/Makefile
+/src/jsontestrunner/Makefile
+/src/jsontestrunner/jsontestrunner_exe
+/src/lib_json/Makefile
+/src/test_lib_json/Makefile
+/src/test_lib_json/jsoncpp_test
+*.a
+
+# eclipse project files
+.project
+.cproject
+/.settings/
+
+# DS_Store
+.DS_Store
+
+# temps
+/version
diff --git a/3rdparty/jsoncpp/src/.travis.yml b/3rdparty/jsoncpp/src/.travis.yml
new file mode 100644
index 00000000..23acd4e5
--- /dev/null
+++ b/3rdparty/jsoncpp/src/.travis.yml
@@ -0,0 +1,71 @@
+# Build matrix / environment variables are explained on:
+# http://about.travis-ci.com/docs/user/build-configuration/
+# This file can be validated on: http://www.yamllint.com/
+# Or using the Ruby based travel command line tool:
+# gem install travis --no-rdoc --no-ri
+# travis lint .travis.yml
+language: cpp
+sudo: false
+addons:
+  homebrew:
+    packages:
+    - clang-format
+    - meson
+    - ninja
+    update: false # do not update homebrew by default
+  apt:
+    sources:
+    - ubuntu-toolchain-r-test
+    - llvm-toolchain-xenial-8
+    packages:
+    - clang-format-8
+    - clang-8
+    - valgrind
+matrix:
+  include:
+    - name: Mac clang meson static release testing
+      os: osx
+      osx_image: xcode11
+      compiler: clang
+      env:
+         CXX="clang++"
+         CC="clang"
+         LIB_TYPE=static
+         BUILD_TYPE=release
+      script: ./.travis_scripts/meson_builder.sh
+    - name: Linux xenial clang meson static release testing
+      os: linux
+      dist: xenial
+      compiler: clang
+      env:
+         CXX="clang++"
+         CC="clang"
+         LIB_TYPE=static
+         BUILD_TYPE=release
+         PYTHONUSERBASE="$(pwd)/LOCAL"
+         PATH="$PYTHONUSERBASE/bin:$PATH"
+      # before_install and install steps only needed for linux meson builds
+      before_install:
+          - source ./.travis_scripts/travis.before_install.${TRAVIS_OS_NAME}.sh
+      install:
+           - source ./.travis_scripts/travis.install.${TRAVIS_OS_NAME}.sh
+      script: ./.travis_scripts/meson_builder.sh
+    - name: Linux xenial gcc cmake coverage
+      os: linux
+      dist: xenial
+      compiler: gcc
+      env:
+        CXX=g++
+        CC=gcc
+        DO_Coverage=ON
+        BUILD_TOOL="Unix Makefiles"
+        BUILD_TYPE=Debug
+        LIB_TYPE=shared
+        DESTDIR=/tmp/cmake_json_cpp
+      before_install:
+          - pip install --user cpp-coveralls
+      script: ./.travis_scripts/cmake_builder.sh
+      after_success:
+          - coveralls --include src/lib_json --include include
+notifications:
+  email: false
diff --git a/3rdparty/jsoncpp/src/.travis_scripts/cmake_builder.sh b/3rdparty/jsoncpp/src/.travis_scripts/cmake_builder.sh
new file mode 100644
index 00000000..f3d4e46b
--- /dev/null
+++ b/3rdparty/jsoncpp/src/.travis_scripts/cmake_builder.sh
@@ -0,0 +1,130 @@
+#!/usr/bin/env sh
+# This script can be used on the command line directly to configure several
+# different build environments.
+# This is called by `.travis.yml` via Travis CI.
+# Travis supplies $TRAVIS_OS_NAME.
+#  http://docs.travis-ci.com/user/multi-os/
+# Our .travis.yml also defines:
+
+#   - BUILD_TYPE=Release/Debug
+#   - LIB_TYPE=static/shared
+#
+# Optional environmental variables
+#   - DESTDIR <- used for setting the install prefix
+#   - BUILD_TOOL=["Unix Makefile"|"Ninja"]
+#   - BUILDNAME <- how to identify this build on the dashboard
+#   - DO_MemCheck <- if set, try to use valgrind
+#   - DO_Coverage <- if set, try to do dashboard coverage testing
+#
+
+env_set=1
+if ${BUILD_TYPE+false}; then
+  echo "BUILD_TYPE not set in environment."
+  env_set=0
+fi
+if ${LIB_TYPE+false}; then
+  echo "LIB_TYPE not set in environment."
+  env_set=0
+fi
+if ${CXX+false}; then
+  echo "CXX not set in environment."
+  env_set=0
+fi
+
+
+if [ ${env_set} -eq 0 ]; then
+  echo "USAGE:  CXX=$(which clang++)  BUILD_TYPE=[Release|Debug] LIB_TYPE=[static|shared] $0"
+  echo ""
+  echo "Examples:"
+  echo "           CXX=$(which clang++) BUILD_TYPE=Release LIB_TYPE=shared DESTDIR=/tmp/cmake_json_cpp $0"
+  echo "           CXX=$(which clang++) BUILD_TYPE=Debug   LIB_TYPE=shared DESTDIR=/tmp/cmake_json_cpp $0"
+  echo "           CXX=$(which clang++) BUILD_TYPE=Release LIB_TYPE=static DESTDIR=/tmp/cmake_json_cpp $0"
+  echo "           CXX=$(which clang++) BUILD_TYPE=Debug   LIB_TYPE=static DESTDIR=/tmp/cmake_json_cpp $0"
+
+  echo "           CXX=$(which g++)     BUILD_TYPE=Release LIB_TYPE=shared DESTDIR=/tmp/cmake_json_cpp $0"
+  echo "           CXX=$(which g++)     BUILD_TYPE=Debug   LIB_TYPE=shared DESTDIR=/tmp/cmake_json_cpp $0"
+  echo "           CXX=$(which g++)     BUILD_TYPE=Release LIB_TYPE=static DESTDIR=/tmp/cmake_json_cpp $0"
+  echo "           CXX=$(which g++)     BUILD_TYPE=Debug   LIB_TYPE=static DESTDIR=/tmp/cmake_json_cpp $0"
+
+  exit -1
+fi
+
+if ${DESTDIR+false}; then
+  DESTDIR="/usr/local"
+fi
+
+# -e: fail on error
+# -v: show commands
+# -x: show expanded commands
+set -vex
+
+env | sort
+
+which cmake
+cmake --version
+
+echo ${CXX}
+${CXX} --version
+_COMPILER_NAME=`basename ${CXX}`
+if [ "${LIB_TYPE}" = "shared" ]; then
+  _CMAKE_BUILD_SHARED_LIBS=ON
+else
+  _CMAKE_BUILD_SHARED_LIBS=OFF
+fi
+
+CTEST_TESTING_OPTION="-D ExperimentalTest"
+#   - DO_MemCheck <- if set, try to use valgrind
+if ! ${DO_MemCheck+false}; then
+   valgrind --version
+   CTEST_TESTING_OPTION="-D ExperimentalMemCheck"
+else
+#   - DO_Coverage <- if set, try to do dashboard coverage testing
+  if ! ${DO_Coverage+false}; then
+     export CXXFLAGS="-fprofile-arcs -ftest-coverage"
+     export LDFLAGS="-fprofile-arcs -ftest-coverage"
+     CTEST_TESTING_OPTION="-D ExperimentalTest -D ExperimentalCoverage"
+     #gcov --version
+  fi
+fi
+
+#  Ninja                        = Generates build.ninja files.
+if ${BUILD_TOOL+false}; then
+  BUILD_TOOL="Ninja"
+  export _BUILD_EXE=ninja
+  which ninja
+  ninja --version
+else
+#  Unix Makefiles               = Generates standard UNIX makefiles.
+  export _BUILD_EXE=make
+fi
+
+_BUILD_DIR_NAME="build-cmake_${BUILD_TYPE}_${LIB_TYPE}_${_COMPILER_NAME}_${_BUILD_EXE}"
+mkdir -p ${_BUILD_DIR_NAME}
+cd "${_BUILD_DIR_NAME}"
+  if ${BUILDNAME+false}; then
+     _HOSTNAME=`hostname -s`
+     BUILDNAME="${_HOSTNAME}_${BUILD_TYPE}_${LIB_TYPE}_${_COMPILER_NAME}_${_BUILD_EXE}"
+  fi
+  cmake \
+    -G "${BUILD_TOOL}" \
+    -DBUILDNAME:STRING="${BUILDNAME}" \
+    -DCMAKE_CXX_COMPILER:PATH=${CXX} \
+    -DCMAKE_BUILD_TYPE:STRING=${BUILD_TYPE} \
+    -DBUILD_SHARED_LIBS:BOOL=${_CMAKE_BUILD_SHARED_LIBS} \
+    -DCMAKE_INSTALL_PREFIX:PATH=${DESTDIR} \
+    ../
+
+  ctest -C ${BUILD_TYPE} -D ExperimentalStart -D ExperimentalConfigure -D ExperimentalBuild ${CTEST_TESTING_OPTION} -D ExperimentalSubmit
+  # Final step is to verify that installation succeeds
+  cmake --build . --config ${BUILD_TYPE} --target install
+
+  if [ "${DESTDIR}" != "/usr/local" ]; then
+     ${_BUILD_EXE} install
+  fi
+cd -
+
+if ${CLEANUP+false}; then
+  echo "Skipping cleanup: build directory will persist."
+else
+  rm -r "${_BUILD_DIR_NAME}"
+fi
diff --git a/3rdparty/jsoncpp/src/.travis_scripts/meson_builder.sh b/3rdparty/jsoncpp/src/.travis_scripts/meson_builder.sh
new file mode 100644
index 00000000..bc74732f
--- /dev/null
+++ b/3rdparty/jsoncpp/src/.travis_scripts/meson_builder.sh
@@ -0,0 +1,83 @@
+#!/usr/bin/env sh
+# This script can be used on the command line directly to configure several
+# different build environments.
+# This is called by `.travis.yml` via Travis CI.
+# Travis supplies $TRAVIS_OS_NAME.
+#  http://docs.travis-ci.com/user/multi-os/
+# Our .travis.yml also defines:
+
+#   - BUILD_TYPE=release/debug
+#   - LIB_TYPE=static/shared
+
+env_set=1
+if ${BUILD_TYPE+false}; then
+  echo "BUILD_TYPE not set in environment."
+  env_set=0
+fi
+if ${LIB_TYPE+false}; then
+  echo "LIB_TYPE not set in environment."
+  env_set=0
+fi
+if ${CXX+false}; then
+  echo "CXX not set in environment."
+  env_set=0
+fi
+
+
+if [ ${env_set} -eq 0 ]; then
+  echo "USAGE:  CXX=$(which clang++)  BUILD_TYPE=[release|debug] LIB_TYPE=[static|shared] $0"
+  echo ""
+  echo "Examples:"
+  echo "           CXX=$(which clang++) BUILD_TYPE=release LIB_TYPE=shared DESTDIR=/tmp/meson_json_cpp $0"
+  echo "           CXX=$(which clang++) BUILD_TYPE=debug   LIB_TYPE=shared DESTDIR=/tmp/meson_json_cpp $0"
+  echo "           CXX=$(which clang++) BUILD_TYPE=release LIB_TYPE=static DESTDIR=/tmp/meson_json_cpp $0"
+  echo "           CXX=$(which clang++) BUILD_TYPE=debug   LIB_TYPE=static DESTDIR=/tmp/meson_json_cpp $0"
+
+  echo "           CXX=$(which g++)     BUILD_TYPE=release LIB_TYPE=shared DESTDIR=/tmp/meson_json_cpp $0"
+  echo "           CXX=$(which g++)     BUILD_TYPE=debug   LIB_TYPE=shared DESTDIR=/tmp/meson_json_cpp $0"
+  echo "           CXX=$(which g++)     BUILD_TYPE=release LIB_TYPE=static DESTDIR=/tmp/meson_json_cpp $0"
+  echo "           CXX=$(which g++)     BUILD_TYPE=debug   LIB_TYPE=static DESTDIR=/tmp/meson_json_cpp $0"
+
+  exit -1
+fi
+
+if ${DESTDIR+false}; then
+  DESTDIR="/usr/local"
+fi
+
+# -e: fail on error
+# -v: show commands
+# -x: show expanded commands
+set -vex
+
+
+env | sort
+
+which python3
+which meson
+which ninja
+echo ${CXX}
+${CXX} --version
+python3 --version
+meson --version
+ninja --version
+_COMPILER_NAME=`basename ${CXX}`
+_BUILD_DIR_NAME="build-${BUILD_TYPE}_${LIB_TYPE}_${_COMPILER_NAME}"
+
+#./.travis_scripts/run-clang-format.sh
+meson --fatal-meson-warnings --werror --buildtype ${BUILD_TYPE} --default-library ${LIB_TYPE} . "${_BUILD_DIR_NAME}"
+ninja -v -j 2 -C "${_BUILD_DIR_NAME}"
+
+cd "${_BUILD_DIR_NAME}"
+  meson test --no-rebuild --print-errorlogs
+
+  if [ "${DESTDIR}" != "/usr/local" ]; then
+     ninja install
+  fi
+cd -
+
+if ${CLEANUP+false}; then
+  echo "Skipping cleanup:  build directory will persist."
+else
+  rm -r "${_BUILD_DIR_NAME}"
+fi
diff --git a/3rdparty/jsoncpp/src/.travis_scripts/run-clang-format.py b/3rdparty/jsoncpp/src/.travis_scripts/run-clang-format.py
new file mode 100644
index 00000000..605b5aad
--- /dev/null
+++ b/3rdparty/jsoncpp/src/.travis_scripts/run-clang-format.py
@@ -0,0 +1,356 @@
+#!/usr/bin/env python
+"""A wrapper script around clang-format, suitable for linting multiple files
+and to use for continuous integration.
+This is an alternative API for the clang-format command line.
+It runs over multiple files and directories in parallel.
+A diff output is produced and a sensible exit code is returned.
+
+NOTE: pulled from https://github.com/Sarcasm/run-clang-format, which is
+licensed under the MIT license.
+"""
+
+from __future__ import print_function, unicode_literals
+
+import argparse
+import codecs
+import difflib
+import fnmatch
+import io
+import multiprocessing
+import os
+import signal
+import subprocess
+import sys
+import traceback
+
+from functools import partial
+
+try:
+    from subprocess import DEVNULL  # py3k
+except ImportError:
+    DEVNULL = open(os.devnull, "wb")
+
+
+DEFAULT_EXTENSIONS = 'c,h,C,H,cpp,hpp,cc,hh,c++,h++,cxx,hxx'
+
+
+class ExitStatus:
+    SUCCESS = 0
+    DIFF = 1
+    TROUBLE = 2
+
+
+def list_files(files, recursive=False, extensions=None, exclude=None):
+    if extensions is None:
+        extensions = []
+    if exclude is None:
+        exclude = []
+
+    out = []
+    for file in files:
+        if recursive and os.path.isdir(file):
+            for dirpath, dnames, fnames in os.walk(file):
+                fpaths = [os.path.join(dirpath, fname) for fname in fnames]
+                for pattern in exclude:
+                    # os.walk() supports trimming down the dnames list
+                    # by modifying it in-place,
+                    # to avoid unnecessary directory listings.
+                    dnames[:] = [
+                        x for x in dnames
+                        if
+                        not fnmatch.fnmatch(os.path.join(dirpath, x), pattern)
+                    ]
+                    fpaths = [
+                        x for x in fpaths if not fnmatch.fnmatch(x, pattern)
+                    ]
+                for f in fpaths:
+                    ext = os.path.splitext(f)[1][1:]
+                    if ext in extensions:
+                        out.append(f)
+        else:
+            out.append(file)
+    return out
+
+
+def make_diff(file, original, reformatted):
+    return list(
+        difflib.unified_diff(
+            original,
+            reformatted,
+            fromfile='{}\t(original)'.format(file),
+            tofile='{}\t(reformatted)'.format(file),
+            n=3))
+
+
+class DiffError(Exception):
+    def __init__(self, message, errs=None):
+        super(DiffError, self).__init__(message)
+        self.errs = errs or []
+
+
+class UnexpectedError(Exception):
+    def __init__(self, message, exc=None):
+        super(UnexpectedError, self).__init__(message)
+        self.formatted_traceback = traceback.format_exc()
+        self.exc = exc
+
+
+def run_clang_format_diff_wrapper(args, file):
+    try:
+        ret = run_clang_format_diff(args, file)
+        return ret
+    except DiffError:
+        raise
+    except Exception as e:
+        raise UnexpectedError('{}: {}: {}'.format(file, e.__class__.__name__,
+                                                  e), e)
+
+
+def run_clang_format_diff(args, file):
+    try:
+        with io.open(file, 'r', encoding='utf-8') as f:
+            original = f.readlines()
+    except IOError as exc:
+        raise DiffError(str(exc))
+    invocation = [args.clang_format_executable, file]
+
+    # Use of utf-8 to decode the process output.
+    #
+    # Hopefully, this is the correct thing to do.
+    #
+    # It's done due to the following assumptions (which may be incorrect):
+    # - clang-format will returns the bytes read from the files as-is,
+    #   without conversion, and it is already assumed that the files use utf-8.
+    # - if the diagnostics were internationalized, they would use utf-8:
+    #   > Adding Translations to Clang
+    #   >
+    #   > Not possible yet!
+    #   > Diagnostic strings should be written in UTF-8,
+    #   > the client can translate to the relevant code page if needed.
+    #   > Each translation completely replaces the format string
+    #   > for the diagnostic.
+    #   > -- http://clang.llvm.org/docs/InternalsManual.html#internals-diag-translation
+    #
+    # It's not pretty, due to Python 2 & 3 compatibility.
+    encoding_py3 = {}
+    if sys.version_info[0] >= 3:
+        encoding_py3['encoding'] = 'utf-8'
+
+    try:
+        proc = subprocess.Popen(
+            invocation,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            universal_newlines=True,
+            **encoding_py3)
+    except OSError as exc:
+        raise DiffError(
+            "Command '{}' failed to start: {}".format(
+                subprocess.list2cmdline(invocation), exc
+            )
+        )
+    proc_stdout = proc.stdout
+    proc_stderr = proc.stderr
+    if sys.version_info[0] < 3:
+        # make the pipes compatible with Python 3,
+        # reading lines should output unicode
+        encoding = 'utf-8'
+        proc_stdout = codecs.getreader(encoding)(proc_stdout)
+        proc_stderr = codecs.getreader(encoding)(proc_stderr)
+    # hopefully the stderr pipe won't get full and block the process
+    outs = list(proc_stdout.readlines())
+    errs = list(proc_stderr.readlines())
+    proc.wait()
+    if proc.returncode:
+        raise DiffError(
+            "Command '{}' returned non-zero exit status {}".format(
+                subprocess.list2cmdline(invocation), proc.returncode
+            ),
+            errs,
+        )
+    return make_diff(file, original, outs), errs
+
+
+def bold_red(s):
+    return '\x1b[1m\x1b[31m' + s + '\x1b[0m'
+
+
+def colorize(diff_lines):
+    def bold(s):
+        return '\x1b[1m' + s + '\x1b[0m'
+
+    def cyan(s):
+        return '\x1b[36m' + s + '\x1b[0m'
+
+    def green(s):
+        return '\x1b[32m' + s + '\x1b[0m'
+
+    def red(s):
+        return '\x1b[31m' + s + '\x1b[0m'
+
+    for line in diff_lines:
+        if line[:4] in ['--- ', '+++ ']:
+            yield bold(line)
+        elif line.startswith('@@ '):
+            yield cyan(line)
+        elif line.startswith('+'):
+            yield green(line)
+        elif line.startswith('-'):
+            yield red(line)
+        else:
+            yield line
+
+
+def print_diff(diff_lines, use_color):
+    if use_color:
+        diff_lines = colorize(diff_lines)
+    if sys.version_info[0] < 3:
+        sys.stdout.writelines((l.encode('utf-8') for l in diff_lines))
+    else:
+        sys.stdout.writelines(diff_lines)
+
+
+def print_trouble(prog, message, use_colors):
+    error_text = 'error:'
+    if use_colors:
+        error_text = bold_red(error_text)
+    print("{}: {} {}".format(prog, error_text, message), file=sys.stderr)
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        '--clang-format-executable',
+        metavar='EXECUTABLE',
+        help='path to the clang-format executable',
+        default='clang-format')
+    parser.add_argument(
+        '--extensions',
+        help='comma separated list of file extensions (default: {})'.format(
+            DEFAULT_EXTENSIONS),
+        default=DEFAULT_EXTENSIONS)
+    parser.add_argument(
+        '-r',
+        '--recursive',
+        action='store_true',
+        help='run recursively over directories')
+    parser.add_argument('files', metavar='file', nargs='+')
+    parser.add_argument(
+        '-q',
+        '--quiet',
+        action='store_true')
+    parser.add_argument(
+        '-j',
+        metavar='N',
+        type=int,
+        default=0,
+        help='run N clang-format jobs in parallel'
+        ' (default number of cpus + 1)')
+    parser.add_argument(
+        '--color',
+        default='auto',
+        choices=['auto', 'always', 'never'],
+        help='show colored diff (default: auto)')
+    parser.add_argument(
+        '-e',
+        '--exclude',
+        metavar='PATTERN',
+        action='append',
+        default=[],
+        help='exclude paths matching the given glob-like pattern(s)'
+        ' from recursive search')
+
+    args = parser.parse_args()
+
+    # use default signal handling, like diff return SIGINT value on ^C
+    # https://bugs.python.org/issue14229#msg156446
+    signal.signal(signal.SIGINT, signal.SIG_DFL)
+    try:
+        signal.SIGPIPE
+    except AttributeError:
+        # compatibility, SIGPIPE does not exist on Windows
+        pass
+    else:
+        signal.signal(signal.SIGPIPE, signal.SIG_DFL)
+
+    colored_stdout = False
+    colored_stderr = False
+    if args.color == 'always':
+        colored_stdout = True
+        colored_stderr = True
+    elif args.color == 'auto':
+        colored_stdout = sys.stdout.isatty()
+        colored_stderr = sys.stderr.isatty()
+
+    version_invocation = [args.clang_format_executable, str("--version")]
+    try:
+        subprocess.check_call(version_invocation, stdout=DEVNULL)
+    except subprocess.CalledProcessError as e:
+        print_trouble(parser.prog, str(e), use_colors=colored_stderr)
+        return ExitStatus.TROUBLE
+    except OSError as e:
+        print_trouble(
+            parser.prog,
+            "Command '{}' failed to start: {}".format(
+                subprocess.list2cmdline(version_invocation), e
+            ),
+            use_colors=colored_stderr,
+        )
+        return ExitStatus.TROUBLE
+
+    retcode = ExitStatus.SUCCESS
+    files = list_files(
+        args.files,
+        recursive=args.recursive,
+        exclude=args.exclude,
+        extensions=args.extensions.split(','))
+
+    if not files:
+        return
+
+    njobs = args.j
+    if njobs == 0:
+        njobs = multiprocessing.cpu_count() + 1
+    njobs = min(len(files), njobs)
+
+    if njobs == 1:
+        # execute directly instead of in a pool,
+        # less overhead, simpler stacktraces
+        it = (run_clang_format_diff_wrapper(args, file) for file in files)
+        pool = None
+    else:
+        pool = multiprocessing.Pool(njobs)
+        it = pool.imap_unordered(
+            partial(run_clang_format_diff_wrapper, args), files)
+    while True:
+        try:
+            outs, errs = next(it)
+        except StopIteration:
+            break
+        except DiffError as e:
+            print_trouble(parser.prog, str(e), use_colors=colored_stderr)
+            retcode = ExitStatus.TROUBLE
+            sys.stderr.writelines(e.errs)
+        except UnexpectedError as e:
+            print_trouble(parser.prog, str(e), use_colors=colored_stderr)
+            sys.stderr.write(e.formatted_traceback)
+            retcode = ExitStatus.TROUBLE
+            # stop at the first unexpected error,
+            # something could be very wrong,
+            # don't process all files unnecessarily
+            if pool:
+                pool.terminate()
+            break
+        else:
+            sys.stderr.writelines(errs)
+            if outs == []:
+                continue
+            if not args.quiet:
+                print_diff(outs, use_color=colored_stdout)
+            if retcode == ExitStatus.SUCCESS:
+                retcode = ExitStatus.DIFF
+    return retcode
+
+
+if __name__ == '__main__':
+    sys.exit(main())
diff --git a/3rdparty/jsoncpp/src/.travis_scripts/run-clang-format.sh b/3rdparty/jsoncpp/src/.travis_scripts/run-clang-format.sh
new file mode 100644
index 00000000..ded76aaf
--- /dev/null
+++ b/3rdparty/jsoncpp/src/.travis_scripts/run-clang-format.sh
@@ -0,0 +1,4 @@
+#!/usr/bin/env bash
+
+DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )"
+python $DIR/run-clang-format.py -r $DIR/../src/**/ $DIR/../include/**/
diff --git a/3rdparty/jsoncpp/src/.travis_scripts/travis.before_install.linux.sh b/3rdparty/jsoncpp/src/.travis_scripts/travis.before_install.linux.sh
new file mode 100644
index 00000000..9b556de1
--- /dev/null
+++ b/3rdparty/jsoncpp/src/.travis_scripts/travis.before_install.linux.sh
@@ -0,0 +1,8 @@
+set -vex
+
+# Preinstalled versions of python are dependent on which Ubuntu distribution
+# you are running. The below version needs to be updated whenever we roll
+# the Ubuntu version used in Travis.
+# https://docs.travis-ci.com/user/languages/python/
+
+pyenv global 3.7.1
diff --git a/3rdparty/jsoncpp/src/.travis_scripts/travis.before_install.osx.sh b/3rdparty/jsoncpp/src/.travis_scripts/travis.before_install.osx.sh
new file mode 100644
index 00000000..e69de29b
diff --git a/3rdparty/jsoncpp/src/.travis_scripts/travis.install.linux.sh b/3rdparty/jsoncpp/src/.travis_scripts/travis.install.linux.sh
new file mode 100644
index 00000000..6495fefe
--- /dev/null
+++ b/3rdparty/jsoncpp/src/.travis_scripts/travis.install.linux.sh
@@ -0,0 +1,5 @@
+set -vex
+
+pip3 install --user meson ninja
+which meson
+which ninja
diff --git a/3rdparty/jsoncpp/src/.travis_scripts/travis.install.osx.sh b/3rdparty/jsoncpp/src/.travis_scripts/travis.install.osx.sh
new file mode 100644
index 00000000..5d83c0c7
--- /dev/null
+++ b/3rdparty/jsoncpp/src/.travis_scripts/travis.install.osx.sh
@@ -0,0 +1 @@
+# NOTHING TO DO HERE
diff --git a/3rdparty/jsoncpp/src/AUTHORS b/3rdparty/jsoncpp/src/AUTHORS
new file mode 100644
index 00000000..e1fa0fc3
--- /dev/null
+++ b/3rdparty/jsoncpp/src/AUTHORS
@@ -0,0 +1,115 @@
+Baptiste Lepilleur <blep@users.sourceforge.net>
+
+Aaron Jacobs <aaronjjacobs@gmail.com>
+Aaron Jacobs <jacobsa@google.com>
+Adam Boseley <ABoseley@agjunction.com>
+Adam Boseley <adam.boseley@gmail.com>
+Aleksandr Derbenev <13alexac@gmail.com>
+Alexander Gazarov <DrMetallius@users.noreply.github.com>
+Alexander V. Brezgin <abrezgin@appliedtech.ru>
+Alexandr Brezgin <albrezgin@mail.ru>
+Alexey Kruchinin <alexey@mopals.com>
+Anton Indrawan <anton.indrawan@gmail.com>
+Baptiste Jonglez <git@bitsofnetworks.org>
+Baptiste Lepilleur <baptiste.lepilleur@gmail.com>
+Baruch Siach <baruch@tkos.co.il>
+Ben Boeckel <mathstuf@gmail.com>
+Benjamin Knecht <bknecht@logitech.com>
+Bernd Kuhls <bernd.kuhls@t-online.de>
+Billy Donahue <billydonahue@google.com>
+Braden McDorman <bmcdorman@gmail.com>
+Brandon Myers <bmyers1788@gmail.com>
+Brendan Drew <brendan.drew@daqri.com>
+chason <cxchao802@gmail.com>
+chenguoping <chenguopingdota@163.com>
+Chris Gilling <cgilling@iparadigms.com>
+Christopher Dawes <christopher.dawes.1981@googlemail.com>
+Christopher Dunn <cdunn2001@gmail.com>
+Chuck Atkins <chuck.atkins@kitware.com>
+Cody P Schafer <dev@codyps.com>
+Connor Manning <connor@hobu.co>
+Cory Quammen <cory.quammen@kitware.com>
+Cristóvão B da Cruz e Silva <CrisXed@gmail.com>
+Daniel Krügler <daniel.kruegler@gmail.com>
+Dani-Hub <daniel.kruegler@googlemail.com>
+Dan Liu <gzliudan>
+datadiode <datadiode@users.noreply.github.com>
+datadiode <jochen.neubeck@vodafone.de>
+David Seifert <soap@gentoo.org>
+David West <david-west@idexx.com>
+dawesc <chris.dawes@eftlab.co.uk>
+Devin Jeanpierre <jeanpierreda@google.com>
+Dmitry Marakasov <amdmi3@amdmi3.ru>
+dominicpezzuto <dom@dompezzuto.com>
+Don Milham <dmilham@gmail.com>
+drgler <daniel.kruegler@gmail.com>
+ds283 <D.Seery@sussex.ac.uk>
+Egor Tensin <Egor.Tensin@gmail.com>
+eightnoteight <mr.eightnoteight@gmail.com>
+Evince <baneyue@gmail.com>
+filipjs <filipjs@users.noreply.github.com>
+findblar <ft@finbarr.ca>
+Florian Meier <florian.meier@koalo.de>
+Gaëtan Lehmann <gaetan.lehmann@gmail.com>
+Gaurav <g.gupta@samsung.com>
+Gergely Nagy <ngg@ngg.hu>
+Gida Pataki <gida.pataki@prezi.com>
+I3ck <buckmartin@buckmartin.de>
+Iñaki Baz Castillo <ibc@aliax.net>
+Jacco <jacco@geul.net>
+Jean-Christophe Fillion-Robin <jchris.fillionr@kitware.com>
+Jonas Platte <mail@jonasplatte.de>
+Jordan Bayles <bayles.jordan@gmail.com>
+Jörg Krause <joerg.krause@embedded.rocks>
+Keith Lea <keith@whamcitylights.com>
+Kevin Grant <kbradleygrant@gmail.com>
+Kirill V. Lyadvinsky <jia3ep@gmail.com>
+Kirill V. Lyadvinsky <mail@codeatcpp.com>
+Kobi Gurkan <kobigurk@gmail.com>
+Magnus Bjerke Vik <mbvett@gmail.com>
+Malay Shah <malays@users.sourceforge.net>
+Mara Kim <hacker.root@gmail.com>
+Marek Kotewicz <marek.kotewicz@gmail.com>
+Mark Lakata <mark@lakata.org>
+Mark Zeren <mzeren@vmware.com>
+Martin Buck <buckmartin@buckmartin.de>
+Martyn Gigg <martyn.gigg@gmail.com>
+Mattes D <github@xoft.cz>
+Matthias Loy <matthias.loy@hbm.com>
+Merlyn Morgan-Graham <kavika@gmail.com>
+Michael Shields <mshields@google.com>
+Michał Górny <mgorny@gentoo.org>
+Mike Naberezny <mike@naberezny.com>
+mloy <matthias.loy@googlemail.com>
+Motti <lanzkron@gmail.com>
+nnkur <nnkur@mail.ru>
+Omkar Wagh <owagh@owaghlinux.ny.tower-research.com>
+paulo <paulobrizolara@users.noreply.github.com>
+pavel.pimenov <pavel.pimenov@gmail.com>
+Paweł Bylica <chfast@gmail.com>
+Péricles Lopes Machado <pericles.raskolnikoff@gmail.com>
+Peter Spiess-Knafl <psk@autistici.org>
+pffang <pffang@vip.qq.com>
+Rémi Verschelde <remi@verschelde.fr>
+renu555 <renu.tyagi@samsung.com>
+Robert Dailey <rcdailey@gmail.com>
+Sam Clegg <sbc@chromium.org>
+selaselah <selah@outlook.com>
+Sergiy80 <sil2004@gmail.com>
+sergzub <sergzub@gmail.com>
+Stefan Schweter <stefan@schweter.it>
+Stefano Fiorentino <stefano.fiore84@gmail.com>
+Steffen Kieß <Steffen.Kiess@ipvs.uni-stuttgart.de>
+Steven Hahn <hahnse@ornl.gov>
+Stuart Eichert <stuart@fivemicro.com>
+SuperManitu <supermanitu@gmail.com>
+Techwolf <dring@g33kworld.net>
+Tengiz Sharafiev <btolfa+github@gmail.com>
+Tomasz Maciejewski <tmaciejewsk@gmail.com>
+Vicente Olivert Riera <Vincent.Riera@imgtec.com>
+xiaoyur347 <xiaoyur347@gmail.com>
+ycqiu <429148848@qq.com>
+yiqiju <fred_ju@selinc.com>
+Yu Xiaolei <dreifachstein@gmail.com>
+
+Google Inc.
diff --git a/3rdparty/jsoncpp/src/BUILD.bazel b/3rdparty/jsoncpp/src/BUILD.bazel
new file mode 100644
index 00000000..6d7ac3da
--- /dev/null
+++ b/3rdparty/jsoncpp/src/BUILD.bazel
@@ -0,0 +1,37 @@
+licenses(["unencumbered"])  # Public Domain or MIT
+
+exports_files(["LICENSE"])
+
+cc_library(
+    name = "jsoncpp",
+    srcs = [
+        "src/lib_json/json_reader.cpp",
+        "src/lib_json/json_tool.h",
+        "src/lib_json/json_value.cpp",
+        "src/lib_json/json_writer.cpp",
+    ],
+    hdrs = [
+        "include/json/allocator.h",
+        "include/json/assertions.h",
+        "include/json/config.h",
+        "include/json/json_features.h",
+        "include/json/forwards.h",
+        "include/json/json.h",
+        "include/json/reader.h",
+        "include/json/value.h",
+        "include/json/version.h",
+        "include/json/writer.h",
+    ],
+    copts = [
+        "-DJSON_USE_EXCEPTION=0",
+        "-DJSON_HAS_INT64",
+    ],
+    includes = ["include"],
+    visibility = ["//visibility:public"],
+    deps = [":private"],
+)
+
+cc_library(
+    name = "private",
+    textual_hdrs = ["src/lib_json/json_valueiterator.inl"],
+)
diff --git a/3rdparty/jsoncpp/src/CMakeLists.txt b/3rdparty/jsoncpp/src/CMakeLists.txt
new file mode 100644
index 00000000..5d68e679
--- /dev/null
+++ b/3rdparty/jsoncpp/src/CMakeLists.txt
@@ -0,0 +1,213 @@
+# vim: et ts=4 sts=4 sw=4 tw=0
+
+# ==== Define cmake build policies that affect compilation and linkage default behaviors
+#
+# Set the JSONCPP_NEWEST_VALIDATED_POLICIES_VERSION string to the newest cmake version
+# policies that provide successful builds. By setting JSONCPP_NEWEST_VALIDATED_POLICIES_VERSION
+# to a value greater than the oldest policies, all policies between
+# JSONCPP_OLDEST_VALIDATED_POLICIES_VERSION and CMAKE_VERSION (used for this build)
+# are set to their NEW behaivor, thereby suppressing policy warnings related to policies
+# between the JSONCPP_OLDEST_VALIDATED_POLICIES_VERSION and CMAKE_VERSION.
+#
+# CMake versions greater than the JSONCPP_NEWEST_VALIDATED_POLICIES_VERSION policies will
+# continue to generate policy warnings "CMake Warning (dev)...Policy CMP0XXX is not set:"
+#
+set(JSONCPP_OLDEST_VALIDATED_POLICIES_VERSION "3.8.0")
+set(JSONCPP_NEWEST_VALIDATED_POLICIES_VERSION "3.13.2")
+cmake_minimum_required(VERSION ${JSONCPP_OLDEST_VALIDATED_POLICIES_VERSION})
+if("${CMAKE_VERSION}" VERSION_LESS "${JSONCPP_NEWEST_VALIDATED_POLICIES_VERSION}")
+    #Set and use the newest available cmake policies that are validated to work
+    set(JSONCPP_CMAKE_POLICY_VERSION "${CMAKE_VERSION}")
+else()
+    set(JSONCPP_CMAKE_POLICY_VERSION "${JSONCPP_NEWEST_VALIDATED_POLICIES_VERSION}")
+endif()
+cmake_policy(VERSION ${JSONCPP_CMAKE_POLICY_VERSION})
+if(POLICY CMP0091)
+    cmake_policy(SET CMP0091 NEW)
+endif()
+#
+# Now enumerate specific policies newer than JSONCPP_NEWEST_VALIDATED_POLICIES_VERSION
+# that may need to be individually set to NEW/OLD
+#
+foreach(pnew "") # Currently Empty
+    if(POLICY ${pnew})
+        cmake_policy(SET ${pnew} NEW)
+    endif()
+endforeach()
+foreach(pold "") # Currently Empty
+    if(POLICY ${pold})
+        cmake_policy(SET ${pold} OLD)
+    endif()
+endforeach()
+
+# Build the library with C++11 standard support, independent from other including
+# software which may use a different CXX_STANDARD or CMAKE_CXX_STANDARD.
+set(CMAKE_CXX_STANDARD 11)
+set(CMAKE_CXX_EXTENSIONS OFF)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+# Ensure that CMAKE_BUILD_TYPE has a value specified for single configuration generators.
+if(NOT DEFINED CMAKE_BUILD_TYPE AND NOT DEFINED CMAKE_CONFIGURATION_TYPES)
+    set(CMAKE_BUILD_TYPE Release CACHE STRING
+        "Choose the type of build, options are: None Debug Release RelWithDebInfo MinSizeRel Coverage.")
+endif()
+
+set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
+
+# ---------------------------------------------------------------------------
+# use ccache if found, has to be done before project()
+# ---------------------------------------------------------------------------
+find_program(CCACHE_EXECUTABLE "ccache" HINTS /usr/local/bin /opt/local/bin)
+if(CCACHE_EXECUTABLE)
+    message(STATUS "use ccache")
+    set(CMAKE_CXX_COMPILER_LAUNCHER "${CCACHE_EXECUTABLE}" CACHE PATH "ccache" FORCE)
+    set(CMAKE_C_COMPILER_LAUNCHER "${CCACHE_EXECUTABLE}" CACHE PATH "ccache" FORCE)
+endif()
+
+project(jsoncpp
+        # Note: version must be updated in three places when doing a release. This
+        # annoying process ensures that amalgamate, CMake, and meson all report the
+        # correct version.
+        # 1. ./meson.build
+        # 2. ./include/json/version.h
+        # 3. ./CMakeLists.txt
+        # IMPORTANT: also update the PROJECT_SOVERSION!!
+        VERSION 1.9.5 # <major>[.<minor>[.<patch>[.<tweak>]]]
+        LANGUAGES CXX)
+
+message(STATUS "JsonCpp Version: ${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH}")
+set(PROJECT_SOVERSION 25)
+
+include(${CMAKE_CURRENT_SOURCE_DIR}/include/PreventInSourceBuilds.cmake)
+include(${CMAKE_CURRENT_SOURCE_DIR}/include/PreventInBuildInstalls.cmake)
+
+option(JSONCPP_WITH_TESTS "Compile and (for jsoncpp_check) run JsonCpp test executables" OFF)
+option(JSONCPP_WITH_POST_BUILD_UNITTEST "Automatically run unit-tests as a post build step" OFF)
+option(JSONCPP_WITH_WARNING_AS_ERROR "Force compilation to fail if a warning occurs" OFF)
+option(JSONCPP_WITH_STRICT_ISO "Issue all the warnings demanded by strict ISO C and ISO C++" ON)
+option(JSONCPP_WITH_PKGCONFIG_SUPPORT "Generate and install .pc files" OFF)
+option(JSONCPP_WITH_CMAKE_PACKAGE "Generate and install cmake package files" OFF)
+option(JSONCPP_WITH_EXAMPLE "Compile JsonCpp example" OFF)
+option(JSONCPP_STATIC_WINDOWS_RUNTIME "Use static (MT/MTd) Windows runtime" OFF)
+option(BUILD_SHARED_LIBS "Build jsoncpp_lib as a shared library." OFF)
+option(BUILD_STATIC_LIBS "Build jsoncpp_lib as a static library." ON)
+option(BUILD_OBJECT_LIBS "Build jsoncpp_lib as a object library." OFF)
+
+# Adhere to GNU filesystem layout conventions
+include(GNUInstallDirs)
+
+set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/lib" CACHE PATH "Archive output dir.")
+set(CMAKE_LIBRARY_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/lib" CACHE PATH "Library output dir.")
+set(CMAKE_PDB_OUTPUT_DIRECTORY     "${CMAKE_BINARY_DIR}/bin" CACHE PATH "PDB (MSVC debug symbol)output dir.")
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin" CACHE PATH "Executable/dll output dir.")
+
+set(JSONCPP_USE_SECURE_MEMORY "0" CACHE STRING "-D...=1 to use memory-wiping allocator for STL")
+
+configure_file("${PROJECT_SOURCE_DIR}/version.in"
+    "${PROJECT_BINARY_DIR}/version"
+    NEWLINE_STYLE UNIX)
+
+macro(use_compilation_warning_as_error)
+    if(MSVC)
+        # Only enabled in debug because some old versions of VS STL generate
+        # warnings when compiled in release configuration.
+        add_compile_options($<$<CONFIG:Debug>:/WX>)
+    elseif(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+        add_compile_options(-Werror)
+        if(JSONCPP_WITH_STRICT_ISO)
+            add_compile_options(-pedantic-errors)
+        endif()
+    endif()
+endmacro()
+
+# Include our configuration header
+include_directories(${jsoncpp_SOURCE_DIR}/include)
+
+if(MSVC)
+    # Only enabled in debug because some old versions of VS STL generate
+    # unreachable code warning when compiled in release configuration.
+    add_compile_options($<$<CONFIG:Debug>:/W4>)
+    if (JSONCPP_STATIC_WINDOWS_RUNTIME)
+        set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
+    endif()
+endif()
+
+if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+    # using regular Clang or AppleClang
+    add_compile_options(-Wall -Wconversion -Wshadow)
+
+    if(JSONCPP_WITH_WARNING_AS_ERROR)
+        add_compile_options(-Werror=conversion -Werror=sign-compare)
+    endif()
+elseif(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+    # using GCC
+    add_compile_options(-Wall -Wconversion -Wshadow -Wextra)
+    # not yet ready for -Wsign-conversion
+
+    if(JSONCPP_WITH_STRICT_ISO)
+        add_compile_options(-Wpedantic)
+    endif()
+    if(JSONCPP_WITH_WARNING_AS_ERROR)
+        add_compile_options(-Werror=conversion)
+    endif()
+elseif(CMAKE_CXX_COMPILER_ID STREQUAL "Intel")
+    # using Intel compiler
+    add_compile_options(-Wall -Wconversion -Wshadow -Wextra)
+
+    if(JSONCPP_WITH_WARNING_AS_ERROR)
+        add_compile_options(-Werror=conversion)
+    elseif(JSONCPP_WITH_STRICT_ISO)
+        add_compile_options(-Wpedantic)
+    endif()
+endif()
+
+if(JSONCPP_WITH_WARNING_AS_ERROR)
+    use_compilation_warning_as_error()
+endif()
+
+# if(JSONCPP_WITH_PKGCONFIG_SUPPORT)
+#     include(JoinPaths)
+
+#     join_paths(libdir_for_pc_file "\${exec_prefix}" "${CMAKE_INSTALL_LIBDIR}")
+#     join_paths(includedir_for_pc_file "\${prefix}" "${CMAKE_INSTALL_INCLUDEDIR}")
+
+#     configure_file(
+#         "pkg-config/jsoncpp.pc.in"
+#         "pkg-config/jsoncpp.pc"
+#         @ONLY)
+#     install(FILES "${CMAKE_CURRENT_BINARY_DIR}/pkg-config/jsoncpp.pc"
+#         DESTINATION "${CMAKE_INSTALL_LIBDIR}/pkgconfig")
+# endif()
+
+# if(JSONCPP_WITH_CMAKE_PACKAGE)
+#     include(CMakePackageConfigHelpers)
+#     install(EXPORT jsoncpp
+#         DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/jsoncpp
+#         FILE        jsoncpp-targets.cmake)
+#     configure_package_config_file(jsoncppConfig.cmake.in ${CMAKE_CURRENT_BINARY_DIR}/jsoncppConfig.cmake
+#         INSTALL_DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/jsoncpp)
+
+#     write_basic_package_version_file("${CMAKE_CURRENT_BINARY_DIR}/jsoncppConfigVersion.cmake"
+#         VERSION ${PROJECT_VERSION}
+#         COMPATIBILITY SameMajorVersion)
+#     install(FILES
+#         ${CMAKE_CURRENT_BINARY_DIR}/jsoncppConfigVersion.cmake ${CMAKE_CURRENT_BINARY_DIR}/jsoncppConfig.cmake
+#         ${CMAKE_CURRENT_SOURCE_DIR}/jsoncpp-namespaced-targets.cmake
+#         DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/jsoncpp)
+# endif()
+
+if(JSONCPP_WITH_TESTS)
+    enable_testing()
+    include(CTest)
+endif()
+
+# Build the different applications
+add_subdirectory(src)
+
+#install the includes
+# add_subdirectory(include)
+
+#install the example
+if(JSONCPP_WITH_EXAMPLE)
+    add_subdirectory(example)
+endif()
diff --git a/3rdparty/jsoncpp/src/CONTRIBUTING.md b/3rdparty/jsoncpp/src/CONTRIBUTING.md
new file mode 100644
index 00000000..8d992bee
--- /dev/null
+++ b/3rdparty/jsoncpp/src/CONTRIBUTING.md
@@ -0,0 +1,152 @@
+# Contributing to JsonCpp
+
+## Building
+
+Both CMake and Meson tools are capable of generating a variety of build environments for you preferred development environment.
+Using cmake or meson you can generate an XCode, Visual Studio, Unix Makefile, Ninja, or other environment that fits your needs.
+
+An example of a common Meson/Ninja environment is described next.
+
+## Building and testing with Meson/Ninja
+Thanks to David Seifert (@SoapGentoo), we (the maintainers) now use
+[meson](http://mesonbuild.com/) and [ninja](https://ninja-build.org/) to build
+for debugging, as well as for continuous integration (see
+[`./.travis_scripts/meson_builder.sh`](./.travis_scripts/meson_builder.sh) ). Other systems may work, but minor
+things like version strings might break.
+
+First, install both meson (which requires Python3) and ninja.
+If you wish to install to a directory other than /usr/local, set an environment variable called DESTDIR with the desired path:
+    DESTDIR=/path/to/install/dir
+
+Then,
+```sh
+    cd jsoncpp/
+    BUILD_TYPE=debug
+    #BUILD_TYPE=release
+    LIB_TYPE=shared
+    #LIB_TYPE=static
+    meson --buildtype ${BUILD_TYPE} --default-library ${LIB_TYPE} . build-${LIB_TYPE}
+    ninja -v -C build-${LIB_TYPE}
+
+    ninja -C build-static/ test
+
+    # Or
+    #cd build-${LIB_TYPE}
+    #meson test --no-rebuild --print-errorlogs
+
+    sudo ninja install
+```
+
+## Building and testing with other build systems
+See https://github.com/open-source-parsers/jsoncpp/wiki/Building
+
+## Running the tests manually
+
+You need to run tests manually only if you are troubleshooting an issue.
+
+In the instructions below, replace `path/to/jsontest` with the path of the
+`jsontest` executable that was compiled on your platform.
+
+    cd test
+    # This will run the Reader/Writer tests
+    python runjsontests.py path/to/jsontest
+
+    # This will run the Reader/Writer tests, using JSONChecker test suite
+    # (http://www.json.org/JSON_checker/).
+    # Notes: not all tests pass: JsonCpp is too lenient (for example,
+    # it allows an integer to start with '0'). The goal is to improve
+    # strict mode parsing to get all tests to pass.
+    python runjsontests.py --with-json-checker path/to/jsontest
+
+    # This will run the unit tests (mostly Value)
+    python rununittests.py path/to/test_lib_json
+
+    # You can run the tests using valgrind:
+    python rununittests.py --valgrind path/to/test_lib_json
+
+## Building the documentation
+
+Run the Python script `doxybuild.py` from the top directory:
+
+    python doxybuild.py --doxygen=$(which doxygen) --open --with-dot
+
+See `doxybuild.py --help` for options.
+
+## Adding a reader/writer test
+
+To add a test, you need to create two files in test/data:
+
+* a `TESTNAME.json` file, that contains the input document in JSON format.
+* a `TESTNAME.expected` file, that contains a flatened representation of the
+  input document.
+
+The `TESTNAME.expected` file format is as follows:
+
+* Each line represents a JSON element of the element tree represented by the
+  input document.
+* Each line has two parts: the path to access the element separated from the
+  element value by `=`. Array and object values are always empty (i.e.
+  represented by either `[]` or `{}`).
+* Element path `.` represents the root element, and is used to separate object
+  members. `[N]` is used to specify the value of an array element at index `N`.
+
+See the examples `test_complex_01.json` and `test_complex_01.expected` to better understand element paths.
+
+## Understanding reader/writer test output
+
+When a test is run, output files are generated beside the input test files. Below is a short description of the content of each file:
+
+* `test_complex_01.json`: input JSON document.
+* `test_complex_01.expected`: flattened JSON element tree used to check if
+  parsing was corrected.
+* `test_complex_01.actual`: flattened JSON element tree produced by `jsontest`
+  from reading `test_complex_01.json`.
+* `test_complex_01.rewrite`: JSON document written by `jsontest` using the
+  `Json::Value` parsed from `test_complex_01.json` and serialized using
+  `Json::StyledWritter`.
+* `test_complex_01.actual-rewrite`: flattened JSON element tree produced by
+  `jsontest` from reading `test_complex_01.rewrite`.
+* `test_complex_01.process-output`: `jsontest` output, typically useful for
+  understanding parsing errors.
+
+## Versioning rules
+
+Consumers of this library require a strict approach to incrementing versioning of the JsonCpp library. Currently, we follow the below set of rules:
+
+* Any new public symbols require a minor version bump.
+* Any alteration or removal of public symbols requires a major version bump, including changing the size of a class. This is necessary for
+consumers to do dependency injection properly.
+
+## Preparing code for submission
+
+Generally, JsonCpp's style guide has been pretty relaxed, with the following common themes:
+
+* Variables and function names use lower camel case (E.g. parseValue or collectComments).
+* Class use camel case (e.g. OurReader)
+* Member variables have a trailing underscore
+* Prefer `nullptr` over `NULL`.
+* Passing by non-const reference is allowed.
+* Single statement if blocks may omit brackets.
+* Generally prefer less space over more space.
+
+For an example:
+
+```c++
+bool Reader::decodeNumber(Token& token) {
+  Value decoded;
+  if (!decodeNumber(token, decoded))
+    return false;
+  currentValue().swapPayload(decoded);
+  currentValue().setOffsetStart(token.start_ - begin_);
+  currentValue().setOffsetLimit(token.end_ - begin_);
+  return true;
+}
+```
+
+Before submitting your code, ensure that you meet the versioning requirements above, follow the style guide of the file you are modifying (or the above rules for new files), and run clang format. Meson exposes clang format with the following command:
+```
+ninja -v -C build-${LIB_TYPE}/ clang-format
+```
+
+For convenience, you can also run the `reformat.sh` script located in the root directory.
+
diff --git a/3rdparty/jsoncpp/src/CTestConfig.cmake b/3rdparty/jsoncpp/src/CTestConfig.cmake
new file mode 100644
index 00000000..b8fc6d55
--- /dev/null
+++ b/3rdparty/jsoncpp/src/CTestConfig.cmake
@@ -0,0 +1,15 @@
+## This file should be placed in the root directory of your project.
+## Then modify the CMakeLists.txt file in the root directory of your
+## project to incorporate the testing dashboard.
+##
+## # The following are required to submit to the CDash dashboard:
+##   ENABLE_TESTING()
+##   INCLUDE(CTest)
+
+set(CTEST_PROJECT_NAME "jsoncpp")
+set(CTEST_NIGHTLY_START_TIME "01:23:45 UTC")
+
+set(CTEST_DROP_METHOD "https")
+set(CTEST_DROP_SITE "my.cdash.org")
+set(CTEST_DROP_LOCATION "/submit.php?project=jsoncpp")
+set(CTEST_DROP_SITE_CDASH TRUE)
diff --git a/3rdparty/jsoncpp/src/LICENSE b/3rdparty/jsoncpp/src/LICENSE
new file mode 100644
index 00000000..c41a1d1c
--- /dev/null
+++ b/3rdparty/jsoncpp/src/LICENSE
@@ -0,0 +1,55 @@
+The JsonCpp library's source code, including accompanying documentation,
+tests and demonstration applications, are licensed under the following
+conditions...
+
+Baptiste Lepilleur and The JsonCpp Authors explicitly disclaim copyright in all
+jurisdictions which recognize such a disclaimer. In such jurisdictions,
+this software is released into the Public Domain.
+
+In jurisdictions which do not recognize Public Domain property (e.g. Germany as of
+2010), this software is Copyright (c) 2007-2010 by Baptiste Lepilleur and
+The JsonCpp Authors, and is released under the terms of the MIT License (see below).
+
+In jurisdictions which recognize Public Domain property, the user of this
+software may choose to accept it either as 1) Public Domain, 2) under the
+conditions of the MIT License (see below), or 3) under the terms of dual
+Public Domain/MIT License conditions described here, as they choose.
+
+The MIT License is about as close to Public Domain as a license can get, and is
+described in clear, concise terms at:
+
+   http://en.wikipedia.org/wiki/MIT_License
+
+The full text of the MIT License follows:
+
+========================================================================
+Copyright (c) 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
+
+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.
+========================================================================
+(END LICENSE TEXT)
+
+The MIT license is compatible with both the GPL and commercial
+software, affording one all of the rights of Public Domain with the
+minor nuisance of being required to keep the above copyright notice
+and license text in the source code. Note also that by accepting the
+Public Domain "license" you can re-license your copy using whatever
+license you like.
diff --git a/3rdparty/jsoncpp/src/README.md b/3rdparty/jsoncpp/src/README.md
new file mode 100644
index 00000000..5bff8dca
--- /dev/null
+++ b/3rdparty/jsoncpp/src/README.md
@@ -0,0 +1,67 @@
+# JsonCpp
+
+[![badge](https://img.shields.io/badge/conan.io-jsoncpp%2F1.8.0-green.svg?logo=data:image/png;base64%2CiVBORw0KGgoAAAANSUhEUgAAAA4AAAAOCAMAAAAolt3jAAAA1VBMVEUAAABhlctjlstkl8tlmMtlmMxlmcxmmcxnmsxpnMxpnM1qnc1sn85voM91oM11oc1xotB2oc56pNF6pNJ2ptJ8ptJ8ptN9ptN8p9N5qNJ9p9N9p9R8qtOBqdSAqtOAqtR%2BrNSCrNJ/rdWDrNWCsNWCsNaJs9eLs9iRvNuVvdyVv9yXwd2Zwt6axN6dxt%2Bfx%2BChyeGiyuGjyuCjyuGly%2BGlzOKmzOGozuKoz%2BKqz%2BOq0OOv1OWw1OWw1eWx1eWy1uay1%2Baz1%2Baz1%2Bez2Oe02Oe12ee22ujUGwH3AAAAAXRSTlMAQObYZgAAAAFiS0dEAIgFHUgAAAAJcEhZcwAACxMAAAsTAQCanBgAAAAHdElNRQfgBQkREyOxFIh/AAAAiklEQVQI12NgAAMbOwY4sLZ2NtQ1coVKWNvoc/Eq8XDr2wB5Ig62ekza9vaOqpK2TpoMzOxaFtwqZua2Bm4makIM7OzMAjoaCqYuxooSUqJALjs7o4yVpbowvzSUy87KqSwmxQfnsrPISyFzWeWAXCkpMaBVIC4bmCsOdgiUKwh3JojLgAQ4ZCE0AMm2D29tZwe6AAAAAElFTkSuQmCC)](https://bintray.com/theirix/conan-repo/jsoncpp%3Atheirix)
+[![badge](https://img.shields.io/badge/license-MIT-blue)](https://github.com/open-source-parsers/jsoncpp/blob/master/LICENSE)
+[![badge](https://img.shields.io/badge/document-doxygen-brightgreen)](http://open-source-parsers.github.io/jsoncpp-docs/doxygen/index.html)
+[![Coverage Status](https://coveralls.io/repos/github/open-source-parsers/jsoncpp/badge.svg?branch=master)](https://coveralls.io/github/open-source-parsers/jsoncpp?branch=master)
+
+
+[JSON][json-org] is a lightweight data-interchange format. It can represent
+numbers, strings, ordered sequences of values, and collections of name/value
+pairs.
+
+[json-org]: http://json.org/
+
+JsonCpp is a C++ library that allows manipulating JSON values, including
+serialization and deserialization to and from strings. It can also preserve
+existing comment in unserialization/serialization steps, making it a convenient
+format to store user input files.
+
+
+## Documentation
+
+[JsonCpp documentation][JsonCpp-documentation] is generated using [Doxygen][].
+
+[JsonCpp-documentation]: http://open-source-parsers.github.io/jsoncpp-docs/doxygen/index.html
+[Doxygen]: http://www.doxygen.org
+
+
+## A note on backward-compatibility
+
+* `1.y.z` is built with C++11.
+* `0.y.z` can be used with older compilers.
+* `00.11.z` can be used both in old and new compilers.
+* Major versions maintain binary-compatibility.
+
+### Special note
+The branch `00.11.z`is a new branch, its major version number `00` is to show that it is
+different from `0.y.z` and `1.y.z`, the main purpose of this branch is to make a balance
+between the other two branches. Thus, users can use some new features in this new branch
+that introduced in 1.y.z, but can hardly applied into 0.y.z.
+
+## Using JsonCpp in your project
+
+### The vcpkg dependency manager
+You can download and install JsonCpp using the [vcpkg](https://github.com/Microsoft/vcpkg/) dependency manager:
+
+    git clone https://github.com/Microsoft/vcpkg.git
+    cd vcpkg
+    ./bootstrap-vcpkg.sh
+    ./vcpkg integrate install
+    ./vcpkg install jsoncpp
+
+The JsonCpp 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.
+
+### Amalgamated source
+https://github.com/open-source-parsers/jsoncpp/wiki/Amalgamated-(Possibly-outdated)
+
+### The Meson Build System
+If you are using the [Meson Build System](http://mesonbuild.com), then you can get a wrap file by downloading it from [Meson WrapDB](https://wrapdb.mesonbuild.com/jsoncpp), or simply use `meson wrap install jsoncpp`.
+
+### Other ways
+If you have trouble, see the [Wiki](https://github.com/open-source-parsers/jsoncpp/wiki), or post a question as an Issue.
+
+## License
+
+See the `LICENSE` file for details. In summary, JsonCpp is licensed under the
+MIT license, or public domain if desired and recognized in your jurisdiction.
diff --git a/3rdparty/jsoncpp/src/amalgamate.py b/3rdparty/jsoncpp/src/amalgamate.py
new file mode 100644
index 00000000..4a328ab5
--- /dev/null
+++ b/3rdparty/jsoncpp/src/amalgamate.py
@@ -0,0 +1,161 @@
+#!/usr/bin/env python
+
+"""Amalgamate json-cpp library sources into a single source and header file.
+
+Works with python2.6+ and python3.4+.
+
+Example of invocation (must be invoked from json-cpp top directory):
+python amalgamate.py
+"""
+import os
+import os.path
+import sys
+
+INCLUDE_PATH = "include/json"
+SRC_PATH = "src/lib_json"
+
+class AmalgamationFile:
+    def __init__(self, top_dir):
+        self.top_dir = top_dir
+        self.blocks = []
+
+    def add_text(self, text):
+        if not text.endswith("\n"):
+            text += "\n"
+        self.blocks.append(text)
+
+    def add_file(self, relative_input_path, wrap_in_comment=False):
+        def add_marker(prefix):
+            self.add_text("")
+            self.add_text("// " + "/"*70)
+            self.add_text("// %s of content of file: %s" % (prefix, relative_input_path.replace("\\","/")))
+            self.add_text("// " + "/"*70)
+            self.add_text("")
+        add_marker("Beginning")
+        f = open(os.path.join(self.top_dir, relative_input_path), "rt")
+        content = f.read()
+        if wrap_in_comment:
+            content = "/*\n" + content + "\n*/"
+        self.add_text(content)
+        f.close()
+        add_marker("End")
+        self.add_text("\n\n\n\n")
+
+    def get_value(self):
+        return "".join(self.blocks).replace("\r\n","\n")
+
+    def write_to(self, output_path):
+        output_dir = os.path.dirname(output_path)
+        if output_dir and not os.path.isdir(output_dir):
+            os.makedirs(output_dir)
+        f = open(output_path, "wb")
+        f.write(str.encode(self.get_value(), 'UTF-8'))
+        f.close()
+
+def amalgamate_source(source_top_dir=None,
+                       target_source_path=None,
+                       header_include_path=None):
+    """Produces amalgamated source.
+       Parameters:
+           source_top_dir: top-directory
+           target_source_path: output .cpp path
+           header_include_path: generated header path relative to target_source_path.
+    """
+    print("Amalgamating header...")
+    header = AmalgamationFile(source_top_dir)
+    header.add_text("/// Json-cpp amalgamated header (http://jsoncpp.sourceforge.net/).")
+    header.add_text('/// It is intended to be used with #include "%s"' % header_include_path)
+    header.add_file("LICENSE", wrap_in_comment=True)
+    header.add_text("#ifndef JSON_AMALGAMATED_H_INCLUDED")
+    header.add_text("# define JSON_AMALGAMATED_H_INCLUDED")
+    header.add_text("/// If defined, indicates that the source file is amalgamated")
+    header.add_text("/// to prevent private header inclusion.")
+    header.add_text("#define JSON_IS_AMALGAMATION")
+    header.add_file(os.path.join(INCLUDE_PATH, "version.h"))
+    header.add_file(os.path.join(INCLUDE_PATH, "allocator.h"))
+    header.add_file(os.path.join(INCLUDE_PATH, "config.h"))
+    header.add_file(os.path.join(INCLUDE_PATH, "forwards.h"))
+    header.add_file(os.path.join(INCLUDE_PATH, "json_features.h"))
+    header.add_file(os.path.join(INCLUDE_PATH, "value.h"))
+    header.add_file(os.path.join(INCLUDE_PATH, "reader.h"))
+    header.add_file(os.path.join(INCLUDE_PATH, "writer.h"))
+    header.add_file(os.path.join(INCLUDE_PATH, "assertions.h"))
+    header.add_text("#endif //ifndef JSON_AMALGAMATED_H_INCLUDED")
+
+    target_header_path = os.path.join(os.path.dirname(target_source_path), header_include_path)
+    print("Writing amalgamated header to %r" % target_header_path)
+    header.write_to(target_header_path)
+
+    base, ext = os.path.splitext(header_include_path)
+    forward_header_include_path = base + "-forwards" + ext
+    print("Amalgamating forward header...")
+    header = AmalgamationFile(source_top_dir)
+    header.add_text("/// Json-cpp amalgamated forward header (http://jsoncpp.sourceforge.net/).")
+    header.add_text('/// It is intended to be used with #include "%s"' % forward_header_include_path)
+    header.add_text("/// This header provides forward declaration for all JsonCpp types.")
+    header.add_file("LICENSE", wrap_in_comment=True)
+    header.add_text("#ifndef JSON_FORWARD_AMALGAMATED_H_INCLUDED")
+    header.add_text("# define JSON_FORWARD_AMALGAMATED_H_INCLUDED")
+    header.add_text("/// If defined, indicates that the source file is amalgamated")
+    header.add_text("/// to prevent private header inclusion.")
+    header.add_text("#define JSON_IS_AMALGAMATION")
+    header.add_file(os.path.join(INCLUDE_PATH, "version.h"))
+    header.add_file(os.path.join(INCLUDE_PATH, "allocator.h"))
+    header.add_file(os.path.join(INCLUDE_PATH, "config.h"))
+    header.add_file(os.path.join(INCLUDE_PATH, "forwards.h"))
+    header.add_text("#endif //ifndef JSON_FORWARD_AMALGAMATED_H_INCLUDED")
+
+    target_forward_header_path = os.path.join(os.path.dirname(target_source_path),
+                                               forward_header_include_path)
+    print("Writing amalgamated forward header to %r" % target_forward_header_path)
+    header.write_to(target_forward_header_path)
+
+    print("Amalgamating source...")
+    source = AmalgamationFile(source_top_dir)
+    source.add_text("/// Json-cpp amalgamated source (http://jsoncpp.sourceforge.net/).")
+    source.add_text('/// It is intended to be used with #include "%s"' % header_include_path)
+    source.add_file("LICENSE", wrap_in_comment=True)
+    source.add_text("")
+    source.add_text('#include "%s"' % header_include_path)
+    source.add_text("""
+#ifndef JSON_IS_AMALGAMATION
+#error "Compile with -I PATH_TO_JSON_DIRECTORY"
+#endif
+""")
+    source.add_text("")
+    source.add_file(os.path.join(SRC_PATH, "json_tool.h"))
+    source.add_file(os.path.join(SRC_PATH, "json_reader.cpp"))
+    source.add_file(os.path.join(SRC_PATH, "json_valueiterator.inl"))
+    source.add_file(os.path.join(SRC_PATH, "json_value.cpp"))
+    source.add_file(os.path.join(SRC_PATH, "json_writer.cpp"))
+
+    print("Writing amalgamated source to %r" % target_source_path)
+    source.write_to(target_source_path)
+
+def main():
+    usage = """%prog [options]
+Generate a single amalgamated source and header file from the sources.
+"""
+    from optparse import OptionParser
+    parser = OptionParser(usage=usage)
+    parser.allow_interspersed_args = False
+    parser.add_option("-s", "--source", dest="target_source_path", action="store", default="dist/jsoncpp.cpp",
+        help="""Output .cpp source path. [Default: %default]""")
+    parser.add_option("-i", "--include", dest="header_include_path", action="store", default="json/json.h",
+        help="""Header include path. Used to include the header from the amalgamated source file. [Default: %default]""")
+    parser.add_option("-t", "--top-dir", dest="top_dir", action="store", default=os.getcwd(),
+        help="""Source top-directory. [Default: %default]""")
+    parser.enable_interspersed_args()
+    options, args = parser.parse_args()
+
+    msg = amalgamate_source(source_top_dir=options.top_dir,
+                             target_source_path=options.target_source_path,
+                             header_include_path=options.header_include_path)
+    if msg:
+        sys.stderr.write(msg + "\n")
+        sys.exit(1)
+    else:
+        print("Source successfully amalgamated")
+
+if __name__ == "__main__":
+    main()
diff --git a/3rdparty/jsoncpp/src/appveyor.yml b/3rdparty/jsoncpp/src/appveyor.yml
new file mode 100644
index 00000000..cccce429
--- /dev/null
+++ b/3rdparty/jsoncpp/src/appveyor.yml
@@ -0,0 +1,37 @@
+clone_folder: c:\projects\jsoncpp
+
+environment:
+
+  matrix:
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+      CMAKE_GENERATOR: Visual Studio 14 2015
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+      CMAKE_GENERATOR: Visual Studio 14 2015 Win64
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
+      CMAKE_GENERATOR: Visual Studio 15 2017
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
+      CMAKE_GENERATOR: Visual Studio 15 2017 Win64
+
+build_script:
+  - cmake --version
+  # The build script starts in root.
+  - set JSONCPP_FOLDER=%cd%
+  - set JSONCPP_BUILD_FOLDER=%JSONCPP_FOLDER%\build\release
+  - mkdir -p %JSONCPP_BUILD_FOLDER%
+  - cd %JSONCPP_BUILD_FOLDER%
+  - cmake -G "%CMAKE_GENERATOR%" -DCMAKE_INSTALL_PREFIX:PATH=%CD:\=/%/install -DBUILD_SHARED_LIBS:BOOL=ON %JSONCPP_FOLDER%
+  # Use ctest to make a dashboard build:
+  # - ctest -D Experimental(Start|Update|Configure|Build|Test|Coverage|MemCheck|Submit)
+  # NOTE: Testing on windows is not yet finished:
+  # - ctest -C Release -D ExperimentalStart -D ExperimentalConfigure -D ExperimentalBuild -D ExperimentalTest -D ExperimentalSubmit
+  - ctest -C Release -D ExperimentalStart -D ExperimentalConfigure -D ExperimentalBuild -D ExperimentalSubmit
+  # Final step is to verify that installation succeeds
+  - cmake --build . --config Release --target install
+
+deploy:
+    provider: GitHub
+    auth_token:
+        secure: K2Tp1q8pIZ7rs0Ot24ZMWuwr12Ev6Tc6QkhMjGQxoQG3ng1pXtgPasiJ45IDXGdg
+    on:
+        branch: master
+        appveyor_repo_tag: true
diff --git a/3rdparty/jsoncpp/src/cmake/JoinPaths.cmake b/3rdparty/jsoncpp/src/cmake/JoinPaths.cmake
new file mode 100644
index 00000000..2b376b73
--- /dev/null
+++ b/3rdparty/jsoncpp/src/cmake/JoinPaths.cmake
@@ -0,0 +1,23 @@
+# This module provides a function for joining paths
+# known from most languages
+#
+# SPDX-License-Identifier: (MIT OR CC0-1.0)
+# Copyright 2020 Jan Tojnar
+# https://github.com/jtojnar/cmake-snips
+#
+# Modelled after Python’s os.path.join
+# https://docs.python.org/3.7/library/os.path.html#os.path.join
+# Windows not supported
+function(join_paths joined_path first_path_segment)
+    set(temp_path "${first_path_segment}")
+    foreach(current_segment IN LISTS ARGN)
+        if(NOT ("${current_segment}" STREQUAL ""))
+            if(IS_ABSOLUTE "${current_segment}")
+                set(temp_path "${current_segment}")
+            else()
+                set(temp_path "${temp_path}/${current_segment}")
+            endif()
+        endif()
+    endforeach()
+    set(${joined_path} "${temp_path}" PARENT_SCOPE)
+endfunction()
diff --git a/3rdparty/jsoncpp/src/dev.makefile b/3rdparty/jsoncpp/src/dev.makefile
new file mode 100644
index 00000000..545ff273
--- /dev/null
+++ b/3rdparty/jsoncpp/src/dev.makefile
@@ -0,0 +1,37 @@
+# This is only for jsoncpp developers/contributors.
+# We use this to sign releases, generate documentation, etc.
+VER?=$(shell cat version)
+
+default:
+	@echo "VER=${VER}"
+update-version:
+	perl get_version.pl meson.build >| version
+sign: jsoncpp-${VER}.tar.gz
+	gpg --armor --detach-sign $<
+	gpg --verify $<.asc
+	# Then upload .asc to the release.
+jsoncpp-%.tar.gz:
+	curl https://github.com/open-source-parsers/jsoncpp/archive/$*.tar.gz -o $@
+dox:
+	python doxybuild.py --doxygen=$$(which doxygen) --in doc/web_doxyfile.in
+	rsync -va -c --delete dist/doxygen/jsoncpp-api-html-${VER}/ ../jsoncpp-docs/doxygen/
+	# Then 'git add -A' and 'git push' in jsoncpp-docs.
+build:
+	mkdir -p build/debug
+	cd build/debug; cmake -DCMAKE_BUILD_TYPE=debug -DBUILD_SHARED_LIBS=ON -G "Unix Makefiles" ../..
+	make -C build/debug
+
+# Currently, this depends on include/json/version.h generated
+# by cmake.
+test-amalgamate:
+	python2.7 amalgamate.py
+	python3.4 amalgamate.py
+	cd dist; gcc -I. -c jsoncpp.cpp
+
+valgrind:
+	valgrind --error-exitcode=42 --leak-check=full ./build/debug/src/test_lib_json/jsoncpp_test
+
+clean:
+	\rm -rf *.gz *.asc dist/
+
+.PHONY: build
diff --git a/3rdparty/jsoncpp/src/devtools/__init__.py b/3rdparty/jsoncpp/src/devtools/__init__.py
new file mode 100644
index 00000000..4a51e651
--- /dev/null
+++ b/3rdparty/jsoncpp/src/devtools/__init__.py
@@ -0,0 +1,6 @@
+# Copyright 2010 Baptiste Lepilleur and The JsonCpp Authors
+# Distributed under MIT license, or public domain if desired and
+# recognized in your jurisdiction.
+# See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+# module
diff --git a/3rdparty/jsoncpp/src/devtools/agent_vmw7.json b/3rdparty/jsoncpp/src/devtools/agent_vmw7.json
new file mode 100644
index 00000000..cd7b777f
--- /dev/null
+++ b/3rdparty/jsoncpp/src/devtools/agent_vmw7.json
@@ -0,0 +1,33 @@
+{
+    "cmake_variants" : [
+        {"name": "generator",
+         "generators": [
+            {"generator": [
+                "Visual Studio 7 .NET 2003",
+                "Visual Studio 9 2008",
+                "Visual Studio 9 2008 Win64",
+                "Visual Studio 10",
+                "Visual Studio 10 Win64",
+                "Visual Studio 11",
+                "Visual Studio 11 Win64"
+                ]
+            },
+            {"generator": ["MinGW Makefiles"],
+             "env_prepend": [{"path": "c:/wut/prg/MinGW/bin"}]
+            }
+         ]
+        },
+        {"name": "shared_dll",
+         "variables": [
+            ["BUILD_SHARED_LIBS=true"],
+            ["BUILD_SHARED_LIBS=false"]
+          ]
+        },
+        {"name": "build_type",
+         "build_types": [
+            "debug",
+            "release"
+            ]
+        }
+    ]
+}
diff --git a/3rdparty/jsoncpp/src/devtools/agent_vmxp.json b/3rdparty/jsoncpp/src/devtools/agent_vmxp.json
new file mode 100644
index 00000000..f82a0773
--- /dev/null
+++ b/3rdparty/jsoncpp/src/devtools/agent_vmxp.json
@@ -0,0 +1,26 @@
+{
+    "cmake_variants" : [
+        {"name": "generator",
+         "generators": [
+            {"generator": [
+                "Visual Studio 6",
+                "Visual Studio 7",
+                "Visual Studio 8 2005"
+                ]
+            }
+         ]
+        },
+        {"name": "shared_dll",
+         "variables": [
+            ["BUILD_SHARED_LIBS=true"],
+            ["BUILD_SHARED_LIBS=false"]
+          ]
+        },
+        {"name": "build_type",
+         "build_types": [
+            "debug",
+            "release"
+            ]
+        }
+    ]
+}
diff --git a/3rdparty/jsoncpp/src/devtools/antglob.py b/3rdparty/jsoncpp/src/devtools/antglob.py
new file mode 100644
index 00000000..bd2d7aee
--- /dev/null
+++ b/3rdparty/jsoncpp/src/devtools/antglob.py
@@ -0,0 +1,205 @@
+#!/usr/bin/env python
+# encoding: utf-8
+# Copyright 2009 Baptiste Lepilleur and The JsonCpp Authors
+# Distributed under MIT license, or public domain if desired and
+# recognized in your jurisdiction.
+# See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+from __future__ import print_function
+from dircache import listdir
+import re
+import fnmatch
+import os.path
+
+
+# These fnmatch expressions are used by default to prune the directory tree
+# while doing the recursive traversal in the glob_impl method of glob function.
+prune_dirs = '.git .bzr .hg .svn _MTN _darcs CVS SCCS '
+
+# These fnmatch expressions are used by default to exclude files and dirs
+# while doing the recursive traversal in the glob_impl method of glob function.
+##exclude_pats = prune_pats + '*~ #*# .#* %*% ._* .gitignore .cvsignore vssver.scc .DS_Store'.split()
+
+# These ant_glob expressions are used by default to exclude files and dirs and also prune the directory tree
+# while doing the recursive traversal in the glob_impl method of glob function.
+default_excludes = '''
+**/*~
+**/#*#
+**/.#*
+**/%*%
+**/._*
+**/CVS
+**/CVS/**
+**/.cvsignore
+**/SCCS
+**/SCCS/**
+**/vssver.scc
+**/.svn
+**/.svn/**
+**/.git
+**/.git/**
+**/.gitignore
+**/.bzr
+**/.bzr/**
+**/.hg
+**/.hg/**
+**/_MTN
+**/_MTN/**
+**/_darcs
+**/_darcs/**
+**/.DS_Store '''
+
+DIR = 1
+FILE = 2
+DIR_LINK = 4
+FILE_LINK = 8
+LINKS = DIR_LINK | FILE_LINK
+ALL_NO_LINK = DIR | FILE
+ALL = DIR | FILE | LINKS
+
+_ANT_RE = re.compile(r'(/\*\*/)|(\*\*/)|(/\*\*)|(\*)|(/)|([^\*/]*)')
+
+def ant_pattern_to_re(ant_pattern):
+    """Generates a regular expression from the ant pattern.
+    Matching convention:
+    **/a: match 'a', 'dir/a', 'dir1/dir2/a'
+    a/**/b: match 'a/b', 'a/c/b', 'a/d/c/b'
+    *.py: match 'script.py' but not 'a/script.py'
+    """
+    rex = ['^']
+    next_pos = 0
+    sep_rex = r'(?:/|%s)' % re.escape(os.path.sep)
+##    print 'Converting', ant_pattern
+    for match in _ANT_RE.finditer(ant_pattern):
+##        print 'Matched', match.group()
+##        print match.start(0), next_pos
+        if match.start(0) != next_pos:
+            raise ValueError("Invalid ant pattern")
+        if match.group(1): # /**/
+            rex.append(sep_rex + '(?:.*%s)?' % sep_rex)
+        elif match.group(2): # **/
+            rex.append('(?:.*%s)?' % sep_rex)
+        elif match.group(3): # /**
+            rex.append(sep_rex + '.*')
+        elif match.group(4): # *
+            rex.append('[^/%s]*' % re.escape(os.path.sep))
+        elif match.group(5): # /
+            rex.append(sep_rex)
+        else: # somepath
+            rex.append(re.escape(match.group(6)))
+        next_pos = match.end()
+    rex.append('$')
+    return re.compile(''.join(rex))
+
+def _as_list(l):
+    if isinstance(l, basestring):
+        return l.split()
+    return l
+
+def glob(dir_path,
+         includes = '**/*',
+         excludes = default_excludes,
+         entry_type = FILE,
+         prune_dirs = prune_dirs,
+         max_depth = 25):
+    include_filter = [ant_pattern_to_re(p) for p in _as_list(includes)]
+    exclude_filter = [ant_pattern_to_re(p) for p in _as_list(excludes)]
+    prune_dirs = [p.replace('/',os.path.sep) for p in _as_list(prune_dirs)]
+    dir_path = dir_path.replace('/',os.path.sep)
+    entry_type_filter = entry_type
+
+    def is_pruned_dir(dir_name):
+        for pattern in prune_dirs:
+            if fnmatch.fnmatch(dir_name, pattern):
+                return True
+        return False
+
+    def apply_filter(full_path, filter_rexs):
+        """Return True if at least one of the filter regular expression match full_path."""
+        for rex in filter_rexs:
+            if rex.match(full_path):
+                return True
+        return False
+
+    def glob_impl(root_dir_path):
+        child_dirs = [root_dir_path]
+        while child_dirs:
+            dir_path = child_dirs.pop()
+            for entry in listdir(dir_path):
+                full_path = os.path.join(dir_path, entry)
+##                print 'Testing:', full_path,
+                is_dir = os.path.isdir(full_path)
+                if is_dir and not is_pruned_dir(entry): # explore child directory ?
+##                    print '===> marked for recursion',
+                    child_dirs.append(full_path)
+                included = apply_filter(full_path, include_filter)
+                rejected = apply_filter(full_path, exclude_filter)
+                if not included or rejected: # do not include entry ?
+##                    print '=> not included or rejected'
+                    continue
+                link = os.path.islink(full_path)
+                is_file = os.path.isfile(full_path)
+                if not is_file and not is_dir:
+##                    print '=> unknown entry type'
+                    continue
+                if link:
+                    entry_type = is_file and FILE_LINK or DIR_LINK
+                else:
+                    entry_type = is_file and FILE or DIR
+##                print '=> type: %d' % entry_type,
+                if (entry_type & entry_type_filter) != 0:
+##                    print ' => KEEP'
+                    yield os.path.join(dir_path, entry)
+##                else:
+##                    print ' => TYPE REJECTED'
+    return list(glob_impl(dir_path))
+
+
+if __name__ == "__main__":
+    import unittest
+
+    class AntPatternToRETest(unittest.TestCase):
+##        def test_conversion(self):
+##            self.assertEqual('^somepath$', ant_pattern_to_re('somepath').pattern)
+
+        def test_matching(self):
+            test_cases = [ ('path',
+                             ['path'],
+                             ['somepath', 'pathsuffix', '/path', '/path']),
+                           ('*.py',
+                             ['source.py', 'source.ext.py', '.py'],
+                             ['path/source.py', '/.py', 'dir.py/z', 'z.pyc', 'z.c']),
+                           ('**/path',
+                             ['path', '/path', '/a/path', 'c:/a/path', '/a/b/path', '//a/path', '/a/path/b/path'],
+                             ['path/', 'a/path/b', 'dir.py/z', 'somepath', 'pathsuffix', 'a/somepath']),
+                           ('path/**',
+                             ['path/a', 'path/path/a', 'path//'],
+                             ['path', 'somepath/a', 'a/path', 'a/path/a', 'pathsuffix/a']),
+                           ('/**/path',
+                             ['/path', '/a/path', '/a/b/path/path', '/path/path'],
+                             ['path', 'path/', 'a/path', '/pathsuffix', '/somepath']),
+                           ('a/b',
+                             ['a/b'],
+                             ['somea/b', 'a/bsuffix', 'a/b/c']),
+                           ('**/*.py',
+                             ['script.py', 'src/script.py', 'a/b/script.py', '/a/b/script.py'],
+                             ['script.pyc', 'script.pyo', 'a.py/b']),
+                           ('src/**/*.py',
+                             ['src/a.py', 'src/dir/a.py'],
+                             ['a/src/a.py', '/src/a.py']),
+                           ]
+            for ant_pattern, accepted_matches, rejected_matches in list(test_cases):
+                def local_path(paths):
+                    return [ p.replace('/',os.path.sep) for p in paths ]
+                test_cases.append((ant_pattern, local_path(accepted_matches), local_path(rejected_matches)))
+            for ant_pattern, accepted_matches, rejected_matches in test_cases:
+                rex = ant_pattern_to_re(ant_pattern)
+                print('ant_pattern:', ant_pattern, ' => ', rex.pattern)
+                for accepted_match in accepted_matches:
+                    print('Accepted?:', accepted_match)
+                    self.assertTrue(rex.match(accepted_match) is not None)
+                for rejected_match in rejected_matches:
+                    print('Rejected?:', rejected_match)
+                    self.assertTrue(rex.match(rejected_match) is None)
+
+    unittest.main()
diff --git a/3rdparty/jsoncpp/src/devtools/batchbuild.py b/3rdparty/jsoncpp/src/devtools/batchbuild.py
new file mode 100644
index 00000000..0eb0690e
--- /dev/null
+++ b/3rdparty/jsoncpp/src/devtools/batchbuild.py
@@ -0,0 +1,278 @@
+from __future__ import print_function
+import collections
+import itertools
+import json
+import os
+import os.path
+import re
+import shutil
+import string
+import subprocess
+import sys
+import cgi
+
+class BuildDesc:
+    def __init__(self, prepend_envs=None, variables=None, build_type=None, generator=None):
+        self.prepend_envs = prepend_envs or [] # [ { "var": "value" } ]
+        self.variables = variables or []
+        self.build_type = build_type
+        self.generator = generator
+
+    def merged_with(self, build_desc):
+        """Returns a new BuildDesc by merging field content.
+           Prefer build_desc fields to self fields for single valued field.
+        """
+        return BuildDesc(self.prepend_envs + build_desc.prepend_envs,
+                          self.variables + build_desc.variables,
+                          build_desc.build_type or self.build_type,
+                          build_desc.generator or self.generator)
+
+    def env(self):
+        environ = os.environ.copy()
+        for values_by_name in self.prepend_envs:
+            for var, value in list(values_by_name.items()):
+                var = var.upper()
+                if type(value) is unicode:
+                    value = value.encode(sys.getdefaultencoding())
+                if var in environ:
+                    environ[var] = value + os.pathsep + environ[var]
+                else:
+                    environ[var] = value
+        return environ
+
+    def cmake_args(self):
+        args = ["-D%s" % var for var in self.variables]
+        # skip build type for Visual Studio solution as it cause warning
+        if self.build_type and 'Visual' not in self.generator:
+            args.append("-DCMAKE_BUILD_TYPE=%s" % self.build_type)
+        if self.generator:
+            args.extend(['-G', self.generator])
+        return args
+
+    def __repr__(self):
+        return "BuildDesc(%s, build_type=%s)" %  (" ".join(self.cmake_args()), self.build_type)
+
+class BuildData:
+    def __init__(self, desc, work_dir, source_dir):
+        self.desc = desc
+        self.work_dir = work_dir
+        self.source_dir = source_dir
+        self.cmake_log_path = os.path.join(work_dir, 'batchbuild_cmake.log')
+        self.build_log_path = os.path.join(work_dir, 'batchbuild_build.log')
+        self.cmake_succeeded = False
+        self.build_succeeded = False
+
+    def execute_build(self):
+        print('Build %s' % self.desc)
+        self._make_new_work_dir()
+        self.cmake_succeeded = self._generate_makefiles()
+        if self.cmake_succeeded:
+            self.build_succeeded = self._build_using_makefiles()
+        return self.build_succeeded
+
+    def _generate_makefiles(self):
+        print('  Generating makefiles: ', end=' ')
+        cmd = ['cmake'] + self.desc.cmake_args() + [os.path.abspath(self.source_dir)]
+        succeeded = self._execute_build_subprocess(cmd, self.desc.env(), self.cmake_log_path)
+        print('done' if succeeded else 'FAILED')
+        return succeeded
+
+    def _build_using_makefiles(self):
+        print('  Building:', end=' ')
+        cmd = ['cmake', '--build', self.work_dir]
+        if self.desc.build_type:
+            cmd += ['--config', self.desc.build_type]
+        succeeded = self._execute_build_subprocess(cmd, self.desc.env(), self.build_log_path)
+        print('done' if succeeded else 'FAILED')
+        return succeeded
+
+    def _execute_build_subprocess(self, cmd, env, log_path):
+        process = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, cwd=self.work_dir,
+                                    env=env)
+        stdout, _ = process.communicate()
+        succeeded = (process.returncode == 0)
+        with open(log_path, 'wb') as flog:
+            log = ' '.join(cmd) + '\n' + stdout + '\nExit code: %r\n' % process.returncode
+            flog.write(fix_eol(log))
+        return succeeded
+
+    def _make_new_work_dir(self):
+        if os.path.isdir(self.work_dir):
+            print('  Removing work directory', self.work_dir)
+            shutil.rmtree(self.work_dir, ignore_errors=True)
+        if not os.path.isdir(self.work_dir):
+            os.makedirs(self.work_dir)
+
+def fix_eol(stdout):
+    """Fixes wrong EOL produced by cmake --build on Windows (\r\r\n instead of \r\n).
+    """
+    return re.sub('\r*\n', os.linesep, stdout)
+
+def load_build_variants_from_config(config_path):
+    with open(config_path, 'rb') as fconfig:
+        data = json.load(fconfig)
+    variants = data[ 'cmake_variants' ]
+    build_descs_by_axis = collections.defaultdict(list)
+    for axis in variants:
+        axis_name = axis["name"]
+        build_descs = []
+        if "generators" in axis:
+            for generator_data in axis["generators"]:
+                for generator in generator_data["generator"]:
+                    build_desc = BuildDesc(generator=generator,
+                                            prepend_envs=generator_data.get("env_prepend"))
+                    build_descs.append(build_desc)
+        elif "variables" in axis:
+            for variables in axis["variables"]:
+                build_desc = BuildDesc(variables=variables)
+                build_descs.append(build_desc)
+        elif "build_types" in axis:
+            for build_type in axis["build_types"]:
+                build_desc = BuildDesc(build_type=build_type)
+                build_descs.append(build_desc)
+        build_descs_by_axis[axis_name].extend(build_descs)
+    return build_descs_by_axis
+
+def generate_build_variants(build_descs_by_axis):
+    """Returns a list of BuildDesc generated for the partial BuildDesc for each axis."""
+    axis_names = list(build_descs_by_axis.keys())
+    build_descs = []
+    for axis_name, axis_build_descs in list(build_descs_by_axis.items()):
+        if len(build_descs):
+            # for each existing build_desc and each axis build desc, create a new build_desc
+            new_build_descs = []
+            for prototype_build_desc, axis_build_desc in itertools.product(build_descs, axis_build_descs):
+                new_build_descs.append(prototype_build_desc.merged_with(axis_build_desc))
+            build_descs = new_build_descs
+        else:
+            build_descs = axis_build_descs
+    return build_descs
+
+HTML_TEMPLATE = string.Template('''<html>
+<head>
+    <title>$title</title>
+    <style type="text/css">
+    td.failed {background-color:#f08080;}
+    td.ok {background-color:#c0eec0;}
+    </style>
+</head>
+<body>
+<table border="1">
+<thead>
+    <tr>
+        <th>Variables</th>
+        $th_vars
+    </tr>
+    <tr>
+        <th>Build type</th>
+        $th_build_types
+    </tr>
+</thead>
+<tbody>
+$tr_builds
+</tbody>
+</table>
+</body></html>''')
+
+def generate_html_report(html_report_path, builds):
+    report_dir = os.path.dirname(html_report_path)
+    # Vertical axis: generator
+    # Horizontal: variables, then build_type
+    builds_by_generator = collections.defaultdict(list)
+    variables = set()
+    build_types_by_variable = collections.defaultdict(set)
+    build_by_pos_key = {} # { (generator, var_key, build_type): build }
+    for build in builds:
+        builds_by_generator[build.desc.generator].append(build)
+        var_key = tuple(sorted(build.desc.variables))
+        variables.add(var_key)
+        build_types_by_variable[var_key].add(build.desc.build_type)
+        pos_key = (build.desc.generator, var_key, build.desc.build_type)
+        build_by_pos_key[pos_key] = build
+    variables = sorted(variables)
+    th_vars = []
+    th_build_types = []
+    for variable in variables:
+        build_types = sorted(build_types_by_variable[variable])
+        nb_build_type = len(build_types_by_variable[variable])
+        th_vars.append('<th colspan="%d">%s</th>' % (nb_build_type, cgi.escape(' '.join(variable))))
+        for build_type in build_types:
+            th_build_types.append('<th>%s</th>' % cgi.escape(build_type))
+    tr_builds = []
+    for generator in sorted(builds_by_generator):
+        tds = [ '<td>%s</td>\n' % cgi.escape(generator) ]
+        for variable in variables:
+            build_types = sorted(build_types_by_variable[variable])
+            for build_type in build_types:
+                pos_key = (generator, variable, build_type)
+                build = build_by_pos_key.get(pos_key)
+                if build:
+                    cmake_status = 'ok' if build.cmake_succeeded else 'FAILED'
+                    build_status = 'ok' if build.build_succeeded else 'FAILED'
+                    cmake_log_url = os.path.relpath(build.cmake_log_path, report_dir)
+                    build_log_url = os.path.relpath(build.build_log_path, report_dir)
+                    td = '<td class="%s"><a href="%s" class="%s">CMake: %s</a>' % (                        build_status.lower(), cmake_log_url, cmake_status.lower(), cmake_status)
+                    if build.cmake_succeeded:
+                        td += '<br><a href="%s" class="%s">Build: %s</a>' % (                            build_log_url, build_status.lower(), build_status)
+                    td += '</td>'
+                else:
+                    td = '<td></td>'
+                tds.append(td)
+        tr_builds.append('<tr>%s</tr>' % '\n'.join(tds))
+    html = HTML_TEMPLATE.substitute(        title='Batch build report',
+        th_vars=' '.join(th_vars),
+        th_build_types=' '.join(th_build_types),
+        tr_builds='\n'.join(tr_builds))
+    with open(html_report_path, 'wt') as fhtml:
+        fhtml.write(html)
+    print('HTML report generated in:', html_report_path)
+
+def main():
+    usage = r"""%prog WORK_DIR SOURCE_DIR CONFIG_JSON_PATH [CONFIG2_JSON_PATH...]
+Build a given CMake based project located in SOURCE_DIR with multiple generators/options.dry_run
+as described in CONFIG_JSON_PATH building in WORK_DIR.
+
+Example of call:
+python devtools\batchbuild.py e:\buildbots\jsoncpp\build . devtools\agent_vmw7.json
+"""
+    from optparse import OptionParser
+    parser = OptionParser(usage=usage)
+    parser.allow_interspersed_args = True
+#    parser.add_option('-v', '--verbose', dest="verbose", action='store_true',
+#        help="""Be verbose.""")
+    parser.enable_interspersed_args()
+    options, args = parser.parse_args()
+    if len(args) < 3:
+        parser.error("Missing one of WORK_DIR SOURCE_DIR CONFIG_JSON_PATH.")
+    work_dir = args[0]
+    source_dir = args[1].rstrip('/\\')
+    config_paths = args[2:]
+    for config_path in config_paths:
+        if not os.path.isfile(config_path):
+            parser.error("Can not read: %r" % config_path)
+
+    # generate build variants
+    build_descs = []
+    for config_path in config_paths:
+        build_descs_by_axis = load_build_variants_from_config(config_path)
+        build_descs.extend(generate_build_variants(build_descs_by_axis))
+    print('Build variants (%d):' % len(build_descs))
+    # assign build directory for each variant
+    if not os.path.isdir(work_dir):
+        os.makedirs(work_dir)
+    builds = []
+    with open(os.path.join(work_dir, 'matrix-dir-map.txt'), 'wt') as fmatrixmap:
+        for index, build_desc in enumerate(build_descs):
+            build_desc_work_dir = os.path.join(work_dir, '%03d' % (index+1))
+            builds.append(BuildData(build_desc, build_desc_work_dir, source_dir))
+            fmatrixmap.write('%s: %s\n' % (build_desc_work_dir, build_desc))
+    for build in builds:
+        build.execute_build()
+    html_report_path = os.path.join(work_dir, 'batchbuild-report.html')
+    generate_html_report(html_report_path, builds)
+    print('Done')
+
+
+if __name__ == '__main__':
+    main()
+
diff --git a/3rdparty/jsoncpp/src/devtools/fixeol.py b/3rdparty/jsoncpp/src/devtools/fixeol.py
new file mode 100644
index 00000000..11e1ce2a
--- /dev/null
+++ b/3rdparty/jsoncpp/src/devtools/fixeol.py
@@ -0,0 +1,70 @@
+# Copyright 2010 Baptiste Lepilleur and The JsonCpp Authors
+# Distributed under MIT license, or public domain if desired and
+# recognized in your jurisdiction.
+# See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+from __future__ import print_function
+import os.path
+import sys
+
+def fix_source_eol(path, is_dry_run = True, verbose = True, eol = '\n'):
+    """Makes sure that all sources have the specified eol sequence (default: unix)."""
+    if not os.path.isfile(path):
+        raise ValueError('Path "%s" is not a file' % path)
+    try:
+        f = open(path, 'rb')
+    except IOError as msg:
+        print("%s: I/O Error: %s" % (file, str(msg)), file=sys.stderr)
+        return False
+    try:
+        raw_lines = f.readlines()
+    finally:
+        f.close()
+    fixed_lines = [line.rstrip('\r\n') + eol for line in raw_lines]
+    if raw_lines != fixed_lines:
+        print('%s =>' % path, end=' ')
+        if not is_dry_run:
+            f = open(path, "wb")
+            try:
+                f.writelines(fixed_lines)
+            finally:
+                f.close()
+        if verbose:
+            print(is_dry_run and ' NEED FIX' or ' FIXED')
+    return True
+##
+##
+##
+##def _do_fix(is_dry_run = True):
+##    from waftools import antglob
+##    python_sources = antglob.glob('.',
+##        includes = '**/*.py **/wscript **/wscript_build',
+##        excludes = antglob.default_excludes + './waf.py',
+##        prune_dirs = antglob.prune_dirs + 'waf-* ./build')
+##    for path in python_sources:
+##        _fix_python_source(path, is_dry_run)
+##
+##    cpp_sources = antglob.glob('.',
+##        includes = '**/*.cpp **/*.h **/*.inl',
+##        prune_dirs = antglob.prune_dirs + 'waf-* ./build')
+##    for path in cpp_sources:
+##        _fix_source_eol(path, is_dry_run)
+##
+##
+##def dry_fix(context):
+##    _do_fix(is_dry_run = True)
+##
+##def fix(context):
+##    _do_fix(is_dry_run = False)
+##
+##def shutdown():
+##    pass
+##
+##def check(context):
+##    # Unit tests are run when "check" target is used
+##    ut = UnitTest.unit_test()
+##    ut.change_to_testfile_dir = True
+##    ut.want_to_see_test_output = True
+##    ut.want_to_see_test_error = True
+##    ut.run()
+##    ut.print_results()
diff --git a/3rdparty/jsoncpp/src/devtools/licenseupdater.py b/3rdparty/jsoncpp/src/devtools/licenseupdater.py
new file mode 100644
index 00000000..d9b662e0
--- /dev/null
+++ b/3rdparty/jsoncpp/src/devtools/licenseupdater.py
@@ -0,0 +1,94 @@
+"""Updates the license text in source file.
+"""
+from __future__ import print_function
+
+# An existing license is found if the file starts with the string below,
+# and ends with the first blank line.
+LICENSE_BEGIN = "// Copyright "
+
+BRIEF_LICENSE = LICENSE_BEGIN + """2007-2010 Baptiste Lepilleur and The JsonCpp Authors
+// Distributed under MIT license, or public domain if desired and
+// recognized in your jurisdiction.
+// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+""".replace('\r\n','\n')
+
+def update_license(path, dry_run, show_diff):
+    """Update the license statement in the specified file.
+    Parameters:
+      path: path of the C++ source file to update.
+      dry_run: if True, just print the path of the file that would be updated,
+               but don't change it.
+      show_diff: if True, print the path of the file that would be modified,
+                 as well as the change made to the file.
+    """
+    with open(path, 'rt') as fin:
+        original_text = fin.read().replace('\r\n','\n')
+        newline = fin.newlines and fin.newlines[0] or '\n'
+    if not original_text.startswith(LICENSE_BEGIN):
+        # No existing license found => prepend it
+        new_text = BRIEF_LICENSE + original_text
+    else:
+        license_end_index = original_text.index('\n\n') # search first blank line
+        new_text = BRIEF_LICENSE + original_text[license_end_index+2:]
+    if original_text != new_text:
+        if not dry_run:
+            with open(path, 'wb') as fout:
+                fout.write(new_text.replace('\n', newline))
+        print('Updated', path)
+        if show_diff:
+            import difflib
+            print('\n'.join(difflib.unified_diff(original_text.split('\n'),
+                                                   new_text.split('\n'))))
+        return True
+    return False
+
+def update_license_in_source_directories(source_dirs, dry_run, show_diff):
+    """Updates license text in C++ source files found in directory source_dirs.
+    Parameters:
+      source_dirs: list of directory to scan for C++ sources. Directories are
+                   scanned recursively.
+      dry_run: if True, just print the path of the file that would be updated,
+               but don't change it.
+      show_diff: if True, print the path of the file that would be modified,
+                 as well as the change made to the file.
+    """
+    from devtools import antglob
+    prune_dirs = antglob.prune_dirs + 'scons-local* ./build* ./libs ./dist'
+    for source_dir in source_dirs:
+        cpp_sources = antglob.glob(source_dir,
+            includes = '''**/*.h **/*.cpp **/*.inl''',
+            prune_dirs = prune_dirs)
+        for source in cpp_sources:
+            update_license(source, dry_run, show_diff)
+
+def main():
+    usage = """%prog DIR [DIR2...]
+Updates license text in sources of the project in source files found
+in the directory specified on the command-line.
+
+Example of call:
+python devtools\licenseupdater.py include src -n --diff
+=> Show change that would be made to the sources.
+
+python devtools\licenseupdater.py include src
+=> Update license statement on all sources in directories include/ and src/.
+"""
+    from optparse import OptionParser
+    parser = OptionParser(usage=usage)
+    parser.allow_interspersed_args = False
+    parser.add_option('-n', '--dry-run', dest="dry_run", action='store_true', default=False,
+        help="""Only show what files are updated, do not update the files""")
+    parser.add_option('--diff', dest="show_diff", action='store_true', default=False,
+        help="""On update, show change made to the file.""")
+    parser.enable_interspersed_args()
+    options, args = parser.parse_args()
+    update_license_in_source_directories(args, options.dry_run, options.show_diff)
+    print('Done')
+
+if __name__ == '__main__':
+    import sys
+    import os.path
+    sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+    main()
+
diff --git a/3rdparty/jsoncpp/src/devtools/tarball.py b/3rdparty/jsoncpp/src/devtools/tarball.py
new file mode 100644
index 00000000..3c0ba65e
--- /dev/null
+++ b/3rdparty/jsoncpp/src/devtools/tarball.py
@@ -0,0 +1,52 @@
+# Copyright 2010 Baptiste Lepilleur and The JsonCpp Authors
+# Distributed under MIT license, or public domain if desired and
+# recognized in your jurisdiction.
+# See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+from contextlib import closing
+import os
+import tarfile
+
+TARGZ_DEFAULT_COMPRESSION_LEVEL = 9
+
+def make_tarball(tarball_path, sources, base_dir, prefix_dir=''):
+    """Parameters:
+    tarball_path: output path of the .tar.gz file
+    sources: list of sources to include in the tarball, relative to the current directory
+    base_dir: if a source file is in a sub-directory of base_dir, then base_dir is stripped
+        from path in the tarball.
+    prefix_dir: all files stored in the tarball be sub-directory of prefix_dir. Set to ''
+        to make them child of root.
+    """
+    base_dir = os.path.normpath(os.path.abspath(base_dir))
+    def archive_name(path):
+        """Makes path relative to base_dir."""
+        path = os.path.normpath(os.path.abspath(path))
+        common_path = os.path.commonprefix((base_dir, path))
+        archive_name = path[len(common_path):]
+        if os.path.isabs(archive_name):
+            archive_name = archive_name[1:]
+        return os.path.join(prefix_dir, archive_name)
+    def visit(tar, dirname, names):
+        for name in names:
+            path = os.path.join(dirname, name)
+            if os.path.isfile(path):
+                path_in_tar = archive_name(path)
+                tar.add(path, path_in_tar)
+    compression = TARGZ_DEFAULT_COMPRESSION_LEVEL
+    with closing(tarfile.TarFile.open(tarball_path, 'w:gz',
+            compresslevel=compression)) as tar:
+        for source in sources:
+            source_path = source
+            if os.path.isdir(source):
+                for dirpath, dirnames, filenames in os.walk(source_path):
+                    visit(tar, dirpath, filenames)
+            else:
+                path_in_tar = archive_name(source_path)
+                tar.add(source_path, path_in_tar)      # filename, arcname
+
+def decompress(tarball_path, base_dir):
+    """Decompress the gzipped tarball into directory base_dir.
+    """
+    with closing(tarfile.TarFile.open(tarball_path)) as tar:
+        tar.extractall(base_dir)
diff --git a/3rdparty/jsoncpp/src/doc/doxyfile.in b/3rdparty/jsoncpp/src/doc/doxyfile.in
new file mode 100644
index 00000000..dcf514ea
--- /dev/null
+++ b/3rdparty/jsoncpp/src/doc/doxyfile.in
@@ -0,0 +1,2302 @@
+# Doxyfile 1.8.5
+
+# 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 config 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 http://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           = "JsonCpp"
+
+# 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         = %JSONCPP_VERSION%
+
+# 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 an logo or 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       = %DOC_TOPDIR%
+
+# 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
+
+# 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, Brazilian, Catalan, Chinese, Chinese-
+# Traditional, Croatian, Czech, Danish, Dutch, English, Esperanto, Farsi,
+# Finnish, French, German, Greek, Hungarian, Italian, Japanese, Japanese-en,
+# Korean, Korean-en, Latvian, Norwegian, Macedonian, Persian, Polish,
+# Portuguese, Romanian, Russian, Serbian, 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        = %TOPDIR%
+
+# 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    = %TOPDIR%/include
+
+# 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 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
+
+# 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               = 3
+
+# 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.
+
+ALIASES                = "testCaseSetup=\link CppUT::TestCase::setUp() setUp()\endlink" \
+                         "testCaseRun=\link CppUT::TestCase::run() run()\endlink" \
+                         "testCaseTearDown=\link CppUT::TestCase::tearDown() tearDown()\endlink" \
+                         "json_ref=<a HREF='http://www.json.org/'>JSON (JavaScript Object Notation)</a>"
+
+# This tag can be used to specify a number of word-keyword mappings (TCL only).
+# A mapping has the form "name=value". For example adding "class=itcl::class"
+# will allow you to use the command class in the itcl::class meaning.
+
+TCL_SUBST              =
+
+# 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  = NO
+
+# 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
+
+# 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,
+# C#, C, C++, D, PHP, Objective-C, Python, Fortran, VHDL. 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.
+
+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 http://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 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 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    = YES
+
+# 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:
+# http://www.riverbankcomputing.co.uk/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
+
+# 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
+
+#---------------------------------------------------------------------------
+# 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_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         = YES
+
+# 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  = NO
+
+# This flag is only useful for Objective-C code. When 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 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
+# (class|struct|union) 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          = YES
+
+# If the CASE_SENSE_NAMES tag is set to NO then doxygen will only generate file
+# names in lower-case letters. If set to YES upper-case letters are also
+# allowed. This is useful if you have classes or files whose names only differ
+# in case and if your file system supports case sensitive file names. Windows
+# and Mac users are advised to set this option to NO.
+# The default value is: system dependent.
+
+CASE_SENSE_NAMES       = NO
+
+# 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 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 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.
+# 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     = YES
+
+# 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      = NO
+
+# 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       = NO
+
+# 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 http://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. Do not use file names with spaces, bibtex cannot handle them. 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                  = NO
+
+# 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.
+# The default value is: NO.
+
+WARN_NO_PARAMDOC       = 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           = %WARNING_LOG_PATH%
+
+#---------------------------------------------------------------------------
+# 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.
+# Note: If this tag is empty the current directory is searched.
+
+INPUT                  = ../include \
+                         ../src/lib_json \
+                         .
+
+# 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: http://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. 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, *.py, *.f90, *.f, *.for, *.tcl, *.vhd, *.vhdl, *.ucf,
+# *.qsf, *.as and *.js.
+
+FILE_PATTERNS          = *.h \
+                         *.cpp \
+                         *.inl \
+                         *.dox
+
+# 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              = YES
+
+# 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.
+
+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.
+
+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         = YES
+
+# 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
+# function all documented functions referencing it will be listed.
+# The default value is: NO.
+
+REFERENCED_BY_RELATION = YES
+
+# 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    = YES
+
+# 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 http://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 config 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
+
+#---------------------------------------------------------------------------
+# 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
+TOC_INCLUDE_HEADINGS = 2
+
+# The COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns in
+# which the alphabetical index list will be split.
+# Minimum value: 1, maximum value: 20, default value: 5.
+# This tag requires that the tag ALPHABETICAL_INDEX is set to YES.
+
+COLS_IN_ALPHA_INDEX    = 5
+
+# 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_OUTPUT%
+
+# 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            = header.html
+
+# 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            = footer.html
+
+# 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 an additional user-
+# defined cascading style sheet that is 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 file to the output directory. 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 stylesheet and background images according to
+# this color. Hue is specified as an angle on a colorwheel, see
+# http://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_TIMESTAMP tag is set to YES then the footer of each generated HTML
+# page will contain the date and time when the page was generated. Setting this
+# to NO can help when comparing the output of multiple runs.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_TIMESTAMP         = 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  = YES
+
+# 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: http://developer.apple.com/tools/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 http://developer.apple.com/tools/creatingdocsetswithdoxygen.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: http://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      = %HTML_HELP%
+
+# 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               = jsoncpp-%JSONCPP_VERSION%.chm
+
+# 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           = "c:\Program Files\HTML Help Workshop\hhc.exe"
+
+# The GENERATE_CHI flag controls if a separate .chi index file is generated (
+# YES) or that it should be included in the master .chm file ( NO).
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
+
+GENERATE_CHI           = YES
+
+# 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.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
+
+BINARY_TOC             = YES
+
+# 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             = YES
+
+# 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: http://qt-project.org/doc/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          =
+
+# 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: http://qt-project.org/doc/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: http://qt-project.org/doc/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: http://qt-project.org/doc/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:
+# http://qt-project.org/doc/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 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 stylesheets (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
+
+# When 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
+
+# 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
+
+# Use the FORMULA_TRANPARENT tag to determine whether or not the images
+# generated for formulas are transparent PNGs. Transparent PNGs are not
+# supported properly for IE 6.0, but are supported on all modern browsers.
+#
+# Note that when changing this option you need to delete any form_*.png files in
+# the HTML output directory before the changes have effect.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+FORMULA_TRANSPARENT    = YES
+
+# Enable the USE_MATHJAX option to render LaTeX formulas using MathJax (see
+# http://www.mathjax.org) which uses client side JavaScript for the rendering
+# instead of using prerendered 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/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 http://www.mathjax.org before deployment.
+# The default value is: http://cdn.mathjax.org/mathjax/latest.
+# This tag requires that the tag USE_MATHJAX is set to YES.
+
+MATHJAX_RELPATH        = http://cdn.mathjax.org/mathjax/latest
+
+# 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/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           = NO
+
+# 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 flavours 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: http://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: http://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 enabling USE_PDFLATEX this option is only used for generating
+# bitmaps for formulas in the HTML output, but not in the Makefile that is
+# written to the output directory.
+# The default file is: latex.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_CMD_NAME         = latex
+
+# The MAKEINDEX_CMD_NAME tag can be used to specify the command name to generate
+# index for LaTeX.
+# The default file is: makeindex.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+MAKEINDEX_CMD_NAME     = 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             = a4wide
+
+# The EXTRA_PACKAGES tag can be used to specify one or more LaTeX package names
+# that should be included in the LaTeX output. To get the times font for
+# instance you can specify
+# EXTRA_PACKAGES=times
+# 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. Doxygen will
+# replace them by respectively the title of the page, the current date and time,
+# only the current date, the version number of doxygen, the project name (see
+# PROJECT_NAME), or the project number (see PROJECT_NUMBER).
+# 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.
+#
+# 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_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         = NO
+
+# If the LATEX_PDFLATEX tag is set to YES, doxygen will use pdflatex to generate
+# the PDF file directly from the LaTeX files. Set this option to YES to get a
+# higher quality PDF documentation.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+USE_PDFLATEX           = NO
+
+# 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
+
+# If the LATEX_SOURCE_CODE tag is set to YES then doxygen will include source
+# code with syntax highlighting in the LaTeX output.
+#
+# Note that which sources are shown also depends on other settings such as
+# SOURCE_BROWSER.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_SOURCE_CODE      = NO
+
+# The LATEX_BIB_STYLE tag can be used to specify the style to use for the
+# bibliography, e.g. plainnat, or ieeetr. See
+# http://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
+
+#---------------------------------------------------------------------------
+# 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 config
+# 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 config 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           = NO
+
+# 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
+
+# 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
+
+# The XML_SCHEMA tag can be used to specify a XML schema, which can be used by a
+# validating XML parser to check the syntax of the XML files.
+# This tag requires that the tag GENERATE_XML is set to YES.
+
+XML_SCHEMA             =
+
+# The XML_DTD tag can be used to specify a XML DTD, which can be used by a
+# validating XML parser to check the syntax of the XML files.
+# This tag requires that the tag GENERATE_XML is set to YES.
+
+XML_DTD                =
+
+# 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
+
+#---------------------------------------------------------------------------
+# 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.sf.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     = NO
+
+# If the SEARCH_INCLUDES tag is set to YES the includes 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           = ../include
+
+# 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  = *.h
+
+# 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             = "_MSC_VER=1800" \
+                         _CPPRTTI \
+                         _WIN32 \
+                         JSONCPP_DOC_EXCLUDE_IMPLEMENTATION
+
+# 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 an 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
+
+# The PERL_PATH should be the absolute path and name of the perl script
+# interpreter (i.e. the result of 'which perl').
+# The default file (with absolute path) is: /usr/bin/perl.
+
+PERL_PATH              = /usr/bin/perl
+
+#---------------------------------------------------------------------------
+# Configuration options related to the dot tool
+#---------------------------------------------------------------------------
+
+# If the CLASS_DIAGRAMS tag is set to YES doxygen will generate a class diagram
+# (in HTML and LaTeX) for classes with base or super classes. Setting the tag to
+# NO turns the diagrams off. Note that this option also works with HAVE_DOT
+# disabled, but it is recommended to install and use dot, since it yields more
+# powerful graphs.
+# The default value is: YES.
+
+CLASS_DIAGRAMS         = NO
+
+# You can define message sequence charts within doxygen comments using the \msc
+# command. Doxygen will then run the mscgen tool (see:
+# http://www.mcternan.me.uk/mscgen/)) to produce the chart and insert it in the
+# documentation. The MSCGEN_PATH tag allows you to specify the directory where
+# the mscgen tool resides. If left empty the tool is assumed to be found in the
+# default search path.
+
+MSCGEN_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   = NO
+
+# 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: NO.
+
+HAVE_DOT               = %HAVE_DOT%
+
+# 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
+
+# When you want a differently looking font n the dot files that doxygen
+# generates you can specify the font name using DOT_FONTNAME. You need to make
+# sure dot is able to find the font, which can be done by putting it in a
+# standard location or by setting the DOTFONTPATH environment variable or by
+# setting DOT_FONTPATH to the directory containing the font.
+# The default value is: Helvetica.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_FONTNAME           = FreeSans
+
+# The DOT_FONTSIZE tag can be used to set the size (in points) of the font of
+# dot graphs.
+# Minimum value: 4, maximum value: 24, default value: 10.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_FONTSIZE           = 10
+
+# 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               = %UML_LOOK%
+
+# 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 HAVE_DOT is set to YES.
+
+UML_LIMIT_NUM_FIELDS   = 10
+
+# 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     = YES
+
+# 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.
+# 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.
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+CALLER_GRAPH           = YES
+
+# 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.
+# 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, jpg, gif and svg.
+# 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               = %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 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    = 1000
+
+# Set the DOT_TRANSPARENT tag to YES to generate images with a transparent
+# background. This is disabled by default, because dot on Windows does not seem
+# to support this out of the box.
+#
+# Warning: Depending on the platform used, enabling this option may lead to
+# badly anti-aliased labels on the edges of a graph (i.e. they become hard to
+# read).
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_TRANSPARENT        = NO
+
+# Set the DOT_MULTI_TARGETS tag to YES 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      = YES
+
+# 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 dot
+# files that are used to generate the various graphs.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_CLEANUP            = YES
diff --git a/3rdparty/jsoncpp/src/doc/footer.html b/3rdparty/jsoncpp/src/doc/footer.html
new file mode 100644
index 00000000..a24bf2b9
--- /dev/null
+++ b/3rdparty/jsoncpp/src/doc/footer.html
@@ -0,0 +1,21 @@
+<!-- HTML footer for doxygen 1.8.13-->
+<!-- start footer part -->
+<!--BEGIN GENERATE_TREEVIEW-->
+<div id="nav-path" class="navpath"><!-- id is needed for treeview function! -->
+  <ul>
+    $navpath
+    <li class="footer">$generatedby
+    <a href="http://www.doxygen.org/index.html">
+    <img class="footer" src="$relpath^doxygen.png" alt="doxygen"/></a> $doxygenversion </li>
+  </ul>
+</div>
+<!--END GENERATE_TREEVIEW-->
+<!--BEGIN !GENERATE_TREEVIEW-->
+<hr class="footer"/><address class="footer"><small>
+$generatedby &#160;<a href="http://www.doxygen.org/index.html">
+<img class="footer" src="$relpath^doxygen.png" alt="doxygen"/>
+</a> $doxygenversion
+</small></address>
+<!--END !GENERATE_TREEVIEW-->
+</body>
+</html>
diff --git a/3rdparty/jsoncpp/src/doc/header.html b/3rdparty/jsoncpp/src/doc/header.html
new file mode 100644
index 00000000..f0b93e08
--- /dev/null
+++ b/3rdparty/jsoncpp/src/doc/header.html
@@ -0,0 +1,64 @@
+<!-- HTML header for doxygen 1.8.13-->
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen $doxygenversion"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<link href="$relpath^tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="$relpath^jquery.js"></script>
+<script type="text/javascript" src="$relpath^dynsections.js"></script>
+$treeview
+$search
+$mathjax
+<link href="$relpath^$stylesheet" rel="stylesheet" type="text/css" />
+$extrastylesheet
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+
+<!--BEGIN TITLEAREA-->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+  <!--BEGIN PROJECT_LOGO-->
+  <td id="projectlogo"><img alt="Logo" src="$relpath^$projectlogo"/></td>
+  <!--END PROJECT_LOGO-->
+  <!--BEGIN DISABLE_INDEX-->
+   <!--BEGIN SEARCHENGINE-->
+   <td>$searchbox</td>
+   <!--END SEARCHENGINE-->
+  <!--END DISABLE_INDEX-->
+ </tr>
+ </tbody>
+</table>
+</div>
+<!--END TITLEAREA-->
+<body bgcolor="#ffffff">
+<table width="100%">
+  <tr>
+    <td width="30%" align="left" valign="center">
+      <a href="https://github.com/open-source-parsers/jsoncpp">
+      JsonCpp project page
+      </a>
+    </td>
+    <td width="20%" align="center" valign="center">
+      <a href="hierarchy.html">
+        Classes
+      </a>
+    </td>
+    <td width="20%" align="center" valign="center">
+      <a href="namespace_json.html">
+        Namespace
+      </a>
+    </td>
+    <td width="30%" align="right" valign="center">
+      <a href="http://open-source-parsers.github.io/jsoncpp-docs/doxygen/">JsonCpp home page</a>
+    </td>
+  </tr>
+</table>
+
+<hr>
+<!-- end header part -->
diff --git a/3rdparty/jsoncpp/src/doc/readme.txt b/3rdparty/jsoncpp/src/doc/readme.txt
new file mode 100644
index 00000000..0e42cdfb
--- /dev/null
+++ b/3rdparty/jsoncpp/src/doc/readme.txt
@@ -0,0 +1 @@
+The documentation is generated using doxygen (http://www.doxygen.org).
diff --git a/3rdparty/jsoncpp/src/doc/web_doxyfile.in b/3rdparty/jsoncpp/src/doc/web_doxyfile.in
new file mode 100644
index 00000000..df09dcca
--- /dev/null
+++ b/3rdparty/jsoncpp/src/doc/web_doxyfile.in
@@ -0,0 +1,2290 @@
+# Doxyfile 1.8.5
+
+# 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 config 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 http://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           = "JsonCpp"
+
+# 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         = %JSONCPP_VERSION%
+
+# 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           = "JSON data format manipulation library"
+
+# With the PROJECT_LOGO tag one can specify an logo or 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       = %DOC_TOPDIR%
+
+# 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
+
+# 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, Brazilian, Catalan, Chinese, Chinese-
+# Traditional, Croatian, Czech, Danish, Dutch, English, Esperanto, Farsi,
+# Finnish, French, German, Greek, Hungarian, Italian, Japanese, Japanese-en,
+# Korean, Korean-en, Latvian, Norwegian, Macedonian, Persian, Polish,
+# Portuguese, Romanian, Russian, Serbian, 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        = %TOPDIR%
+
+# 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    = %TOPDIR%/include
+
+# 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 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
+
+# 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               = 3
+
+# 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.
+
+ALIASES                = "testCaseSetup=\link CppUT::TestCase::setUp() setUp()\endlink" \
+                         "testCaseRun=\link CppUT::TestCase::run() run()\endlink" \
+                         "testCaseTearDown=\link CppUT::TestCase::tearDown() tearDown()\endlink" \
+                         "json_ref=<a HREF='http://www.json.org/'>JSON (JavaScript Object Notation)</a>"
+
+# This tag can be used to specify a number of word-keyword mappings (TCL only).
+# A mapping has the form "name=value". For example adding "class=itcl::class"
+# will allow you to use the command class in the itcl::class meaning.
+
+TCL_SUBST              =
+
+# 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  = NO
+
+# 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
+
+# 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,
+# C#, C, C++, D, PHP, Objective-C, Python, Fortran, VHDL. 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.
+
+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 http://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 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 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    = YES
+
+# 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:
+# http://www.riverbankcomputing.co.uk/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
+
+# 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
+
+#---------------------------------------------------------------------------
+# 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_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         = YES
+
+# 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  = NO
+
+# This flag is only useful for Objective-C code. When 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 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
+# (class|struct|union) 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          = YES
+
+# If the CASE_SENSE_NAMES tag is set to NO then doxygen will only generate file
+# names in lower-case letters. If set to YES upper-case letters are also
+# allowed. This is useful if you have classes or files whose names only differ
+# in case and if your file system supports case sensitive file names. Windows
+# and Mac users are advised to set this option to NO.
+# The default value is: system dependent.
+
+CASE_SENSE_NAMES       = NO
+
+# 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 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 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.
+# 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     = YES
+
+# 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      = NO
+
+# 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       = NO
+
+# 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 http://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. Do not use file names with spaces, bibtex cannot handle them. 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                  = NO
+
+# 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.
+# The default value is: NO.
+
+WARN_NO_PARAMDOC       = 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           = %WARNING_LOG_PATH%
+
+#---------------------------------------------------------------------------
+# 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.
+# Note: If this tag is empty the current directory is searched.
+
+INPUT                  = ../include \
+                         ../src/lib_json \
+                         .
+
+# 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: http://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. 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, *.py, *.f90, *.f, *.for, *.tcl, *.vhd, *.vhdl, *.ucf,
+# *.qsf, *.as and *.js.
+
+FILE_PATTERNS          = *.h \
+                         *.cpp \
+                         *.inl \
+                         *.dox
+
+# 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              = YES
+
+# 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.
+
+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.
+
+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
+# function 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 http://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 config 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       = NO
+
+#---------------------------------------------------------------------------
+# 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
+TOC_INCLUDE_HEADINGS = 2
+
+# The COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns in
+# which the alphabetical index list will be split.
+# Minimum value: 1, maximum value: 20, default value: 5.
+# This tag requires that the tag ALPHABETICAL_INDEX is set to YES.
+
+COLS_IN_ALPHA_INDEX    = 5
+
+# 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_OUTPUT%
+
+# 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            = header.html
+
+# 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            = footer.html
+
+# 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 an additional user-
+# defined cascading style sheet that is 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 file to the output directory. 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 stylesheet and background images according to
+# this color. Hue is specified as an angle on a colorwheel, see
+# http://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_TIMESTAMP tag is set to YES then the footer of each generated HTML
+# page will contain the date and time when the page was generated. Setting this
+# to NO can help when comparing the output of multiple runs.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_TIMESTAMP         = NO
+
+# 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  = YES
+
+# 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: http://developer.apple.com/tools/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 http://developer.apple.com/tools/creatingdocsetswithdoxygen.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: http://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      = %HTML_HELP%
+
+# 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               = jsoncpp-%JSONCPP_VERSION%.chm
+
+# 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           = "c:\Program Files\HTML Help Workshop\hhc.exe"
+
+# The GENERATE_CHI flag controls if a separate .chi index file is generated (
+# YES) or that it should be included in the master .chm file ( NO).
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
+
+GENERATE_CHI           = YES
+
+# 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.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
+
+BINARY_TOC             = YES
+
+# 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             = YES
+
+# 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: http://qt-project.org/doc/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          =
+
+# 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: http://qt-project.org/doc/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: http://qt-project.org/doc/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: http://qt-project.org/doc/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:
+# http://qt-project.org/doc/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 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 stylesheets (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      = YES
+
+# 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
+
+# When 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
+
+# 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
+
+# Use the FORMULA_TRANPARENT tag to determine whether or not the images
+# generated for formulas are transparent PNGs. Transparent PNGs are not
+# supported properly for IE 6.0, but are supported on all modern browsers.
+#
+# Note that when changing this option you need to delete any form_*.png files in
+# the HTML output directory before the changes have effect.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+FORMULA_TRANSPARENT    = YES
+
+# Enable the USE_MATHJAX option to render LaTeX formulas using MathJax (see
+# http://www.mathjax.org) which uses client side JavaScript for the rendering
+# instead of using prerendered 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/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 http://www.mathjax.org before deployment.
+# The default value is: http://cdn.mathjax.org/mathjax/latest.
+# This tag requires that the tag USE_MATHJAX is set to YES.
+
+MATHJAX_RELPATH        = http://cdn.mathjax.org/mathjax/latest
+
+# 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/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           = NO
+
+# 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 flavours 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: http://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: http://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 enabling USE_PDFLATEX this option is only used for generating
+# bitmaps for formulas in the HTML output, but not in the Makefile that is
+# written to the output directory.
+# The default file is: latex.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_CMD_NAME         = latex
+
+# The MAKEINDEX_CMD_NAME tag can be used to specify the command name to generate
+# index for LaTeX.
+# The default file is: makeindex.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+MAKEINDEX_CMD_NAME     = 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             = a4wide
+
+# The EXTRA_PACKAGES tag can be used to specify one or more LaTeX package names
+# that should be included in the LaTeX output. To get the times font for
+# instance you can specify
+# EXTRA_PACKAGES=times
+# 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. Doxygen will
+# replace them by respectively the title of the page, the current date and time,
+# only the current date, the version number of doxygen, the project name (see
+# PROJECT_NAME), or the project number (see PROJECT_NUMBER).
+# 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.
+#
+# 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_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         = NO
+
+# If the LATEX_PDFLATEX tag is set to YES, doxygen will use pdflatex to generate
+# the PDF file directly from the LaTeX files. Set this option to YES to get a
+# higher quality PDF documentation.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+USE_PDFLATEX           = NO
+
+# 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
+
+# If the LATEX_SOURCE_CODE tag is set to YES then doxygen will include source
+# code with syntax highlighting in the LaTeX output.
+#
+# Note that which sources are shown also depends on other settings such as
+# SOURCE_BROWSER.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_SOURCE_CODE      = NO
+
+# The LATEX_BIB_STYLE tag can be used to specify the style to use for the
+# bibliography, e.g. plainnat, or ieeetr. See
+# http://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
+
+#---------------------------------------------------------------------------
+# 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 config
+# 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 config 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           = NO
+
+# 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
+
+# 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
+
+#---------------------------------------------------------------------------
+# 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.sf.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     = NO
+
+# If the SEARCH_INCLUDES tag is set to YES the includes 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           = ../include
+
+# 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  = *.h
+
+# 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             = "_MSC_VER=1800" \
+                         _CPPRTTI \
+                         _WIN32 \
+                         JSONCPP_DOC_EXCLUDE_IMPLEMENTATION
+
+# 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 an 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
+
+# The PERL_PATH should be the absolute path and name of the perl script
+# interpreter (i.e. the result of 'which perl').
+# The default file (with absolute path) is: /usr/bin/perl.
+
+PERL_PATH              = /usr/bin/perl
+
+#---------------------------------------------------------------------------
+# Configuration options related to the dot tool
+#---------------------------------------------------------------------------
+
+# If the CLASS_DIAGRAMS tag is set to YES doxygen will generate a class diagram
+# (in HTML and LaTeX) for classes with base or super classes. Setting the tag to
+# NO turns the diagrams off. Note that this option also works with HAVE_DOT
+# disabled, but it is recommended to install and use dot, since it yields more
+# powerful graphs.
+# The default value is: YES.
+
+CLASS_DIAGRAMS         = NO
+
+# You can define message sequence charts within doxygen comments using the \msc
+# command. Doxygen will then run the mscgen tool (see:
+# http://www.mcternan.me.uk/mscgen/)) to produce the chart and insert it in the
+# documentation. The MSCGEN_PATH tag allows you to specify the directory where
+# the mscgen tool resides. If left empty the tool is assumed to be found in the
+# default search path.
+
+MSCGEN_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   = NO
+
+# 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: NO.
+
+HAVE_DOT               = %HAVE_DOT%
+
+# 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
+
+# When you want a differently looking font n the dot files that doxygen
+# generates you can specify the font name using DOT_FONTNAME. You need to make
+# sure dot is able to find the font, which can be done by putting it in a
+# standard location or by setting the DOTFONTPATH environment variable or by
+# setting DOT_FONTPATH to the directory containing the font.
+# The default value is: Helvetica.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_FONTNAME           = FreeSans
+
+# The DOT_FONTSIZE tag can be used to set the size (in points) of the font of
+# dot graphs.
+# Minimum value: 4, maximum value: 24, default value: 10.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_FONTSIZE           = 10
+
+# 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               = %UML_LOOK%
+
+# 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 HAVE_DOT is set to YES.
+
+UML_LIMIT_NUM_FIELDS   = 10
+
+# 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     = YES
+
+# 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.
+# 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.
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+CALLER_GRAPH           = YES
+
+# 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.
+# 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, jpg, gif and svg.
+# 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               = %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 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    = 1000
+
+# Set the DOT_TRANSPARENT tag to YES to generate images with a transparent
+# background. This is disabled by default, because dot on Windows does not seem
+# to support this out of the box.
+#
+# Warning: Depending on the platform used, enabling this option may lead to
+# badly anti-aliased labels on the edges of a graph (i.e. they become hard to
+# read).
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_TRANSPARENT        = NO
+
+# Set the DOT_MULTI_TARGETS tag to YES 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      = YES
+
+# 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 dot
+# files that are used to generate the various graphs.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_CLEANUP            = YES
diff --git a/3rdparty/jsoncpp/src/doxybuild.py b/3rdparty/jsoncpp/src/doxybuild.py
new file mode 100644
index 00000000..254ab714
--- /dev/null
+++ b/3rdparty/jsoncpp/src/doxybuild.py
@@ -0,0 +1,189 @@
+"""Script to generate doxygen documentation.
+"""
+from __future__ import print_function
+from __future__ import unicode_literals
+from devtools import tarball
+from contextlib import contextmanager
+import subprocess
+import traceback
+import re
+import os
+import sys
+import shutil
+
+@contextmanager
+def cd(newdir):
+    """
+    http://stackoverflow.com/questions/431684/how-do-i-cd-in-python
+    """
+    prevdir = os.getcwd()
+    os.chdir(newdir)
+    try:
+        yield
+    finally:
+        os.chdir(prevdir)
+
+def find_program(*filenames):
+    """find a program in folders path_lst, and sets env[var]
+    @param filenames: a list of possible names of the program to search for
+    @return: the full path of the filename if found, or '' if filename could not be found
+"""
+    paths = os.environ.get('PATH', '').split(os.pathsep)
+    suffixes = ('win32' in sys.platform) and '.exe .com .bat .cmd' or ''
+    for filename in filenames:
+        for name in [filename+ext for ext in suffixes.split(' ')]:
+            for directory in paths:
+                full_path = os.path.join(directory, name)
+                if os.path.isfile(full_path):
+                    return full_path
+    return ''
+
+def do_subst_in_file(targetfile, sourcefile, dict):
+    """Replace all instances of the keys of dict with their values.
+    For example, if dict is {'%VERSION%': '1.2345', '%BASE%': 'MyProg'},
+    then all instances of %VERSION% in the file will be replaced with 1.2345 etc.
+    """
+    with open(sourcefile, 'r') as f:
+        contents = f.read()
+    for (k,v) in list(dict.items()):
+        v = v.replace('\\','\\\\')
+        contents = re.sub(k, v, contents)
+    with open(targetfile, 'w') as f:
+        f.write(contents)
+
+def getstatusoutput(cmd):
+    """cmd is a list.
+    """
+    try:
+        process = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
+        output, _ = process.communicate()
+        status = process.returncode
+    except:
+        status = -1
+        output = traceback.format_exc()
+    return status, output
+
+def run_cmd(cmd, silent=False):
+    """Raise exception on failure.
+    """
+    info = 'Running: %r in %r' %(' '.join(cmd), os.getcwd())
+    print(info)
+    sys.stdout.flush()
+    if silent:
+        status, output = getstatusoutput(cmd)
+    else:
+        status, output = subprocess.call(cmd), ''
+    if status:
+        msg = 'Error while %s ...\n\terror=%d, output="""%s"""' %(info, status, output)
+        raise Exception(msg)
+
+def assert_is_exe(path):
+    if not path:
+        raise Exception('path is empty.')
+    if not os.path.isfile(path):
+        raise Exception('%r is not a file.' %path)
+    if not os.access(path, os.X_OK):
+        raise Exception('%r is not executable by this user.' %path)
+
+def run_doxygen(doxygen_path, config_file, working_dir, is_silent):
+    assert_is_exe(doxygen_path)
+    config_file = os.path.abspath(config_file)
+    with cd(working_dir):
+        cmd = [doxygen_path, config_file]
+        run_cmd(cmd, is_silent)
+
+def build_doc(options,  make_release=False):
+    if make_release:
+        options.make_tarball = True
+        options.with_dot = True
+        options.with_html_help = True
+        options.with_uml_look = True
+        options.open = False
+        options.silent = True
+
+    version = open('version', 'rt').read().strip()
+    output_dir = 'dist/doxygen' # relative to doc/doxyfile location.
+    if not os.path.isdir(output_dir):
+        os.makedirs(output_dir)
+    top_dir = os.path.abspath('.')
+    html_output_dirname = 'jsoncpp-api-html-' + version
+    tarball_path = os.path.join('dist', html_output_dirname + '.tar.gz')
+    warning_log_path = os.path.join(output_dir, '../jsoncpp-doxygen-warning.log')
+    html_output_path = os.path.join(output_dir, html_output_dirname)
+    def yesno(bool):
+        return bool and 'YES' or 'NO'
+    subst_keys = {
+        '%JSONCPP_VERSION%': version,
+        '%DOC_TOPDIR%': '',
+        '%TOPDIR%': top_dir,
+        '%HTML_OUTPUT%': os.path.join('..', output_dir, html_output_dirname),
+        '%HAVE_DOT%': yesno(options.with_dot),
+        '%DOT_PATH%': os.path.split(options.dot_path)[0],
+        '%HTML_HELP%': yesno(options.with_html_help),
+        '%UML_LOOK%': yesno(options.with_uml_look),
+        '%WARNING_LOG_PATH%': os.path.join('..', warning_log_path)
+        }
+
+    if os.path.isdir(output_dir):
+        print('Deleting directory:', output_dir)
+        shutil.rmtree(output_dir)
+    if not os.path.isdir(output_dir):
+        os.makedirs(output_dir)
+
+    do_subst_in_file('doc/doxyfile', options.doxyfile_input_path, subst_keys)
+    run_doxygen(options.doxygen_path, 'doc/doxyfile', 'doc', is_silent=options.silent)
+    if not options.silent:
+        print(open(warning_log_path, 'r').read())
+    index_path = os.path.abspath(os.path.join('doc', subst_keys['%HTML_OUTPUT%'], 'index.html'))
+    print('Generated documentation can be found in:')
+    print(index_path)
+    if options.open:
+        import webbrowser
+        webbrowser.open('file://' + index_path)
+    if options.make_tarball:
+        print('Generating doc tarball to', tarball_path)
+        tarball_sources = [
+            output_dir,
+            'README.md',
+            'LICENSE',
+            'NEWS.txt',
+            'version'
+            ]
+        tarball_basedir = os.path.join(output_dir, html_output_dirname)
+        tarball.make_tarball(tarball_path, tarball_sources, tarball_basedir, html_output_dirname)
+    return tarball_path, html_output_dirname
+
+def main():
+    usage = """%prog
+    Generates doxygen documentation in build/doxygen.
+    Optionally makes a tarball of the documentation to dist/.
+
+    Must be started in the project top directory.
+    """
+    from optparse import OptionParser
+    parser = OptionParser(usage=usage)
+    parser.allow_interspersed_args = False
+    parser.add_option('--with-dot', dest="with_dot", action='store_true', default=False,
+        help="""Enable usage of DOT to generate collaboration diagram""")
+    parser.add_option('--dot', dest="dot_path", action='store', default=find_program('dot'),
+        help="""Path to GraphViz dot tool. Must be full qualified path. [Default: %default]""")
+    parser.add_option('--doxygen', dest="doxygen_path", action='store', default=find_program('doxygen'),
+        help="""Path to Doxygen tool. [Default: %default]""")
+    parser.add_option('--in', dest="doxyfile_input_path", action='store', default='doc/doxyfile.in',
+        help="""Path to doxygen inputs. [Default: %default]""")
+    parser.add_option('--with-html-help', dest="with_html_help", action='store_true', default=False,
+        help="""Enable generation of Microsoft HTML HELP""")
+    parser.add_option('--no-uml-look', dest="with_uml_look", action='store_false', default=True,
+        help="""Generates DOT graph without UML look [Default: False]""")
+    parser.add_option('--open', dest="open", action='store_true', default=False,
+        help="""Open the HTML index in the web browser after generation""")
+    parser.add_option('--tarball', dest="make_tarball", action='store_true', default=False,
+        help="""Generates a tarball of the documentation in dist/ directory""")
+    parser.add_option('-s', '--silent', dest="silent", action='store_true', default=False,
+        help="""Hides doxygen output""")
+    parser.enable_interspersed_args()
+    options, args = parser.parse_args()
+    build_doc(options)
+
+if __name__ == '__main__':
+    main()
diff --git a/3rdparty/jsoncpp/src/example/CMakeLists.txt b/3rdparty/jsoncpp/src/example/CMakeLists.txt
new file mode 100644
index 00000000..230d1bd7
--- /dev/null
+++ b/3rdparty/jsoncpp/src/example/CMakeLists.txt
@@ -0,0 +1,27 @@
+#vim: et ts =4 sts = 4 sw = 4 tw = 0
+set(EXAMPLES
+    readFromString
+    readFromStream
+    stringWrite
+    streamWrite
+)
+add_definitions(-D_GLIBCXX_USE_CXX11_ABI)
+
+if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU" OR CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
+    add_compile_options(-Wall -Wextra)
+elseif(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
+    add_definitions(
+        -D_SCL_SECURE_NO_WARNINGS
+        -D_CRT_SECURE_NO_WARNINGS
+        -D_WIN32_WINNT=0x601
+        -D_WINSOCK_DEPRECATED_NO_WARNINGS
+    )
+endif()
+
+foreach(example ${EXAMPLES})
+    add_executable(${example} ${example}/${example}.cpp)
+    target_include_directories(${example} PUBLIC ${CMAKE_SOURCE_DIR}/include)
+    target_link_libraries(${example} jsoncpp_lib)
+endforeach()
+
+add_custom_target(examples ALL DEPENDS ${EXAMPLES})
diff --git a/3rdparty/jsoncpp/src/example/README.md b/3rdparty/jsoncpp/src/example/README.md
new file mode 100644
index 00000000..92b925c9
--- /dev/null
+++ b/3rdparty/jsoncpp/src/example/README.md
@@ -0,0 +1,13 @@
+***NOTE***
+
+If you get linker errors about undefined references to symbols that involve types in the `std::__cxx11` namespace or the tag
+`[abi:cxx11]` then it probably indicates that you are trying to link together object files that were compiled with different
+values for the _GLIBCXX_USE_CXX11_ABI marco. This commonly happens when linking to a third-party library that was compiled with
+an older version of GCC. If the third-party library cannot be rebuilt with the new ABI, then you need to recompile your code with
+the old ABI,just like:
+**g++ stringWrite.cpp -ljsoncpp -std=c++11 -D_GLIBCXX_USE_CXX11_ABI=0 -o stringWrite**
+
+Not all of uses of the new ABI will cause changes in symbol names, for example a class with a `std::string` member variable will
+have the same mangled name whether compiled with the older or new ABI. In order to detect such problems, the new types and functions
+are annotated with the abi_tag attribute, allowing the compiler to warn about potential ABI incompatibilities in code using them.
+Those warnings can be enabled with the `-Wabi-tag` option.
diff --git a/3rdparty/jsoncpp/src/example/readFromStream/errorFormat.json b/3rdparty/jsoncpp/src/example/readFromStream/errorFormat.json
new file mode 100644
index 00000000..2d13290b
--- /dev/null
+++ b/3rdparty/jsoncpp/src/example/readFromStream/errorFormat.json
@@ -0,0 +1,3 @@
+{
+    1: "value"
+}
\ No newline at end of file
diff --git a/3rdparty/jsoncpp/src/example/readFromStream/readFromStream.cpp b/3rdparty/jsoncpp/src/example/readFromStream/readFromStream.cpp
new file mode 100644
index 00000000..358d2cab
--- /dev/null
+++ b/3rdparty/jsoncpp/src/example/readFromStream/readFromStream.cpp
@@ -0,0 +1,30 @@
+#include "json/json.h"
+#include <fstream>
+#include <iostream>
+/** \brief Parse from stream, collect comments and capture error info.
+ * Example Usage:
+ * $g++ readFromStream.cpp -ljsoncpp -std=c++11 -o readFromStream
+ * $./readFromStream
+ * // comment head
+ * {
+ *    // comment before
+ *    "key" : "value"
+ * }
+ * // comment after
+ * // comment tail
+ */
+int main(int argc, char* argv[]) {
+  Json::Value root;
+  std::ifstream ifs;
+  ifs.open(argv[1]);
+
+  Json::CharReaderBuilder builder;
+  builder["collectComments"] = true;
+  JSONCPP_STRING errs;
+  if (!parseFromStream(builder, ifs, &root, &errs)) {
+    std::cout << errs << std::endl;
+    return EXIT_FAILURE;
+  }
+  std::cout << root << std::endl;
+  return EXIT_SUCCESS;
+}
diff --git a/3rdparty/jsoncpp/src/example/readFromStream/withComment.json b/3rdparty/jsoncpp/src/example/readFromStream/withComment.json
new file mode 100644
index 00000000..7a8c8282
--- /dev/null
+++ b/3rdparty/jsoncpp/src/example/readFromStream/withComment.json
@@ -0,0 +1,6 @@
+// comment head
+{
+    // comment before
+    "key" : "value"
+    // comment after
+}// comment tail
diff --git a/3rdparty/jsoncpp/src/example/readFromString/readFromString.cpp b/3rdparty/jsoncpp/src/example/readFromString/readFromString.cpp
new file mode 100644
index 00000000..0b29a4e8
--- /dev/null
+++ b/3rdparty/jsoncpp/src/example/readFromString/readFromString.cpp
@@ -0,0 +1,38 @@
+#include "json/json.h"
+#include <iostream>
+#include <memory>
+/**
+ * \brief Parse a raw string into Value object using the CharReaderBuilder
+ * class, or the legacy Reader class.
+ * Example Usage:
+ * $g++ readFromString.cpp -ljsoncpp -std=c++11 -o readFromString
+ * $./readFromString
+ * colin
+ * 20
+ */
+int main() {
+  const std::string rawJson = R"({"Age": 20, "Name": "colin"})";
+  const auto rawJsonLength = static_cast<int>(rawJson.length());
+  constexpr bool shouldUseOldWay = false;
+  JSONCPP_STRING err;
+  Json::Value root;
+
+  if (shouldUseOldWay) {
+    Json::Reader reader;
+    reader.parse(rawJson, root);
+  } else {
+    Json::CharReaderBuilder builder;
+    const std::unique_ptr<Json::CharReader> reader(builder.newCharReader());
+    if (!reader->parse(rawJson.c_str(), rawJson.c_str() + rawJsonLength, &root,
+                       &err)) {
+      std::cout << "error" << std::endl;
+      return EXIT_FAILURE;
+    }
+  }
+  const std::string name = root["Name"].asString();
+  const int age = root["Age"].asInt();
+
+  std::cout << name << std::endl;
+  std::cout << age << std::endl;
+  return EXIT_SUCCESS;
+}
diff --git a/3rdparty/jsoncpp/src/example/streamWrite/streamWrite.cpp b/3rdparty/jsoncpp/src/example/streamWrite/streamWrite.cpp
new file mode 100644
index 00000000..a72f5a52
--- /dev/null
+++ b/3rdparty/jsoncpp/src/example/streamWrite/streamWrite.cpp
@@ -0,0 +1,23 @@
+#include "json/json.h"
+#include <iostream>
+#include <memory>
+/** \brief Write the Value object to a stream.
+ * Example Usage:
+ * $g++ streamWrite.cpp -ljsoncpp -std=c++11 -o streamWrite
+ * $./streamWrite
+ * {
+ *     "Age" : 20,
+ *     "Name" : "robin"
+ * }
+ */
+int main() {
+  Json::Value root;
+  Json::StreamWriterBuilder builder;
+  const std::unique_ptr<Json::StreamWriter> writer(builder.newStreamWriter());
+
+  root["Name"] = "robin";
+  root["Age"] = 20;
+  writer->write(root, &std::cout);
+
+  return EXIT_SUCCESS;
+}
diff --git a/3rdparty/jsoncpp/src/example/stringWrite/stringWrite.cpp b/3rdparty/jsoncpp/src/example/stringWrite/stringWrite.cpp
new file mode 100644
index 00000000..d501ba94
--- /dev/null
+++ b/3rdparty/jsoncpp/src/example/stringWrite/stringWrite.cpp
@@ -0,0 +1,33 @@
+#include "json/json.h"
+#include <iostream>
+/** \brief Write a Value object to a string.
+ * Example Usage:
+ * $g++ stringWrite.cpp -ljsoncpp -std=c++11 -o stringWrite
+ * $./stringWrite
+ * {
+ *     "action" : "run",
+ *     "data" :
+ *     {
+ *         "number" : 1
+ *     }
+ * }
+ */
+int main() {
+  Json::Value root;
+  Json::Value data;
+  constexpr bool shouldUseOldWay = false;
+  root["action"] = "run";
+  data["number"] = 1;
+  root["data"] = data;
+
+  if (shouldUseOldWay) {
+    Json::FastWriter writer;
+    const std::string json_file = writer.write(root);
+    std::cout << json_file << std::endl;
+  } else {
+    Json::StreamWriterBuilder builder;
+    const std::string json_file = Json::writeString(builder, root);
+    std::cout << json_file << std::endl;
+  }
+  return EXIT_SUCCESS;
+}
diff --git a/3rdparty/jsoncpp/src/get_version.pl b/3rdparty/jsoncpp/src/get_version.pl
new file mode 100644
index 00000000..19b6a543
--- /dev/null
+++ b/3rdparty/jsoncpp/src/get_version.pl
@@ -0,0 +1,5 @@
+while (<>) {
+	if (/version : '(.+)',/) {
+		print "$1";
+	}
+}
diff --git a/3rdparty/jsoncpp/src/include/CMakeLists.txt b/3rdparty/jsoncpp/src/include/CMakeLists.txt
new file mode 100644
index 00000000..dc40d95e
--- /dev/null
+++ b/3rdparty/jsoncpp/src/include/CMakeLists.txt
@@ -0,0 +1,5 @@
+file(GLOB INCLUDE_FILES "json/*.h")
+install(FILES
+    ${INCLUDE_FILES}
+    DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/json)
+
diff --git a/3rdparty/jsoncpp/src/include/PreventInBuildInstalls.cmake b/3rdparty/jsoncpp/src/include/PreventInBuildInstalls.cmake
new file mode 100644
index 00000000..accfea64
--- /dev/null
+++ b/3rdparty/jsoncpp/src/include/PreventInBuildInstalls.cmake
@@ -0,0 +1,9 @@
+string(TOLOWER "${CMAKE_INSTALL_PREFIX}" _PREFIX)
+string(TOLOWER "${ITK_BINARY_DIR}" _BUILD)
+if("${_PREFIX}" STREQUAL "${_BUILD}")
+  message(FATAL_ERROR
+    "The current CMAKE_INSTALL_PREFIX points at the build tree:\n"
+    "  ${CMAKE_INSTALL_PREFIX}\n"
+    "This is not supported."
+    )
+endif()
diff --git a/3rdparty/jsoncpp/src/include/PreventInSourceBuilds.cmake b/3rdparty/jsoncpp/src/include/PreventInSourceBuilds.cmake
new file mode 100644
index 00000000..7ddda546
--- /dev/null
+++ b/3rdparty/jsoncpp/src/include/PreventInSourceBuilds.cmake
@@ -0,0 +1,45 @@
+#
+# This function will prevent in-source builds
+function(AssureOutOfSourceBuilds)
+  # make sure the user doesn't play dirty with symlinks
+  get_filename_component(srcdir "${CMAKE_SOURCE_DIR}" REALPATH)
+  get_filename_component(bindir "${CMAKE_BINARY_DIR}" REALPATH)
+
+  # disallow in-source builds
+  if("${srcdir}" STREQUAL "${bindir}")
+    message("######################################################")
+    message("# jsoncpp should not be configured & built in the jsoncpp source directory")
+    message("# You must run cmake in a build directory.")
+    message("# For example:")
+    message("# mkdir jsoncpp-Sandbox ; cd jsoncpp-sandbox")
+    message("# git clone https://github.com/open-source-parsers/jsoncpp.git # or download & unpack the source tarball")
+    message("# mkdir jsoncpp-build")
+    message("# this will create the following directory structure")
+    message("#")
+    message("# jsoncpp-Sandbox")
+    message("#  +--jsoncpp")
+    message("#  +--jsoncpp-build")
+    message("#")
+    message("# Then you can proceed to configure and build")
+    message("# by using the following commands")
+    message("#")
+    message("# cd jsoncpp-build")
+    message("# cmake ../jsoncpp # or ccmake, or cmake-gui ")
+    message("# make")
+    message("#")
+    message("# NOTE: Given that you already tried to make an in-source build")
+    message("#       CMake have already created several files & directories")
+    message("#       in your source tree. run 'git status' to find them and")
+    message("#       remove them by doing:")
+    message("#")
+    message("#       cd jsoncpp-Sandbox/jsoncpp")
+    message("#       git clean -n -d")
+    message("#       git clean -f -d")
+    message("#       git checkout --")
+    message("#")
+    message("######################################################")
+    message(FATAL_ERROR "Quitting configuration")
+  endif()
+endfunction()
+
+AssureOutOfSourceBuilds()
diff --git a/3rdparty/jsoncpp/src/include/json/allocator.h b/3rdparty/jsoncpp/src/include/json/allocator.h
new file mode 100644
index 00000000..aa820538
--- /dev/null
+++ b/3rdparty/jsoncpp/src/include/json/allocator.h
@@ -0,0 +1,90 @@
+// Copyright 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
+// Distributed under MIT license, or public domain if desired and
+// recognized in your jurisdiction.
+// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+#ifndef JSON_ALLOCATOR_H_INCLUDED
+#define JSON_ALLOCATOR_H_INCLUDED
+
+#include <cstring>
+#include <memory>
+
+#pragma pack(push, 8)
+
+namespace Json {
+template <typename T> class SecureAllocator {
+public:
+  // Type definitions
+  using value_type = T;
+  using pointer = T*;
+  using const_pointer = const T*;
+  using reference = T&;
+  using const_reference = const T&;
+  using size_type = std::size_t;
+  using difference_type = std::ptrdiff_t;
+
+  /**
+   * Allocate memory for N items using the standard allocator.
+   */
+  pointer allocate(size_type n) {
+    // allocate using "global operator new"
+    return static_cast<pointer>(::operator new(n * sizeof(T)));
+  }
+
+  /**
+   * Release memory which was allocated for N items at pointer P.
+   *
+   * The memory block is filled with zeroes before being released.
+   */
+  void deallocate(pointer p, size_type n) {
+    // memset_s is used because memset may be optimized away by the compiler
+    memset_s(p, n * sizeof(T), 0, n * sizeof(T));
+    // free using "global operator delete"
+    ::operator delete(p);
+  }
+
+  /**
+   * Construct an item in-place at pointer P.
+   */
+  template <typename... Args> void construct(pointer p, Args&&... args) {
+    // construct using "placement new" and "perfect forwarding"
+    ::new (static_cast<void*>(p)) T(std::forward<Args>(args)...);
+  }
+
+  size_type max_size() const { return size_t(-1) / sizeof(T); }
+
+  pointer address(reference x) const { return std::addressof(x); }
+
+  const_pointer address(const_reference x) const { return std::addressof(x); }
+
+  /**
+   * Destroy an item in-place at pointer P.
+   */
+  void destroy(pointer p) {
+    // destroy using "explicit destructor"
+    p->~T();
+  }
+
+  // Boilerplate
+  SecureAllocator() {}
+  template <typename U> SecureAllocator(const SecureAllocator<U>&) {}
+  template <typename U> struct rebind {
+    using other = SecureAllocator<U>;
+  };
+};
+
+template <typename T, typename U>
+bool operator==(const SecureAllocator<T>&, const SecureAllocator<U>&) {
+  return true;
+}
+
+template <typename T, typename U>
+bool operator!=(const SecureAllocator<T>&, const SecureAllocator<U>&) {
+  return false;
+}
+
+} // namespace Json
+
+#pragma pack(pop)
+
+#endif // JSON_ALLOCATOR_H_INCLUDED
diff --git a/3rdparty/jsoncpp/src/include/json/assertions.h b/3rdparty/jsoncpp/src/include/json/assertions.h
new file mode 100644
index 00000000..666fa7f5
--- /dev/null
+++ b/3rdparty/jsoncpp/src/include/json/assertions.h
@@ -0,0 +1,61 @@
+// Copyright 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
+// Distributed under MIT license, or public domain if desired and
+// recognized in your jurisdiction.
+// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+#ifndef JSON_ASSERTIONS_H_INCLUDED
+#define JSON_ASSERTIONS_H_INCLUDED
+
+#include <cstdlib>
+#include <sstream>
+
+#if !defined(JSON_IS_AMALGAMATION)
+#include "config.h"
+#endif // if !defined(JSON_IS_AMALGAMATION)
+
+/** It should not be possible for a maliciously designed file to
+ *  cause an abort() or seg-fault, so these macros are used only
+ *  for pre-condition violations and internal logic errors.
+ */
+#if JSON_USE_EXCEPTION
+
+// @todo <= add detail about condition in exception
+#define JSON_ASSERT(condition)                                                 \
+  do {                                                                         \
+    if (!(condition)) {                                                        \
+      Json::throwLogicError("assert json failed");                             \
+    }                                                                          \
+  } while (0)
+
+#define JSON_FAIL_MESSAGE(message)                                             \
+  do {                                                                         \
+    OStringStream oss;                                                         \
+    oss << message;                                                            \
+    Json::throwLogicError(oss.str());                                          \
+    abort();                                                                   \
+  } while (0)
+
+#else // JSON_USE_EXCEPTION
+
+#define JSON_ASSERT(condition) assert(condition)
+
+// The call to assert() will show the failure message in debug builds. In
+// release builds we abort, for a core-dump or debugger.
+#define JSON_FAIL_MESSAGE(message)                                             \
+  {                                                                            \
+    OStringStream oss;                                                         \
+    oss << message;                                                            \
+    assert(false && oss.str().c_str());                                        \
+    abort();                                                                   \
+  }
+
+#endif
+
+#define JSON_ASSERT_MESSAGE(condition, message)                                \
+  do {                                                                         \
+    if (!(condition)) {                                                        \
+      JSON_FAIL_MESSAGE(message);                                              \
+    }                                                                          \
+  } while (0)
+
+#endif // JSON_ASSERTIONS_H_INCLUDED
diff --git a/3rdparty/jsoncpp/src/include/json/config.h b/3rdparty/jsoncpp/src/include/json/config.h
new file mode 100644
index 00000000..6359273a
--- /dev/null
+++ b/3rdparty/jsoncpp/src/include/json/config.h
@@ -0,0 +1,150 @@
+// Copyright 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
+// Distributed under MIT license, or public domain if desired and
+// recognized in your jurisdiction.
+// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+#ifndef JSON_CONFIG_H_INCLUDED
+#define JSON_CONFIG_H_INCLUDED
+#include <cstddef>
+#include <cstdint>
+#include <istream>
+#include <memory>
+#include <ostream>
+#include <sstream>
+#include <string>
+#include <type_traits>
+
+// If non-zero, the library uses exceptions to report bad input instead of C
+// assertion macros. The default is to use exceptions.
+#ifndef JSON_USE_EXCEPTION
+#define JSON_USE_EXCEPTION 1
+#endif
+
+// Temporary, tracked for removal with issue #982.
+#ifndef JSON_USE_NULLREF
+#define JSON_USE_NULLREF 1
+#endif
+
+/// If defined, indicates that the source file is amalgamated
+/// to prevent private header inclusion.
+/// Remarks: it is automatically defined in the generated amalgamated header.
+// #define JSON_IS_AMALGAMATION
+
+// Export macros for DLL visibility
+#if defined(JSON_DLL_BUILD)
+#if defined(_MSC_VER) || defined(__MINGW32__)
+#define JSON_API __declspec(dllexport)
+#define JSONCPP_DISABLE_DLL_INTERFACE_WARNING
+#elif defined(__GNUC__) || defined(__clang__)
+#define JSON_API __attribute__((visibility("default")))
+#endif // if defined(_MSC_VER)
+
+#elif defined(JSON_DLL)
+#if defined(_MSC_VER) || defined(__MINGW32__)
+#define JSON_API __declspec(dllimport)
+#define JSONCPP_DISABLE_DLL_INTERFACE_WARNING
+#endif // if defined(_MSC_VER)
+#endif // ifdef JSON_DLL_BUILD
+
+#if !defined(JSON_API)
+#define JSON_API
+#endif
+
+#if defined(_MSC_VER) && _MSC_VER < 1800
+#error                                                                         \
+    "ERROR:  Visual Studio 12 (2013) with _MSC_VER=1800 is the oldest supported compiler with sufficient C++11 capabilities"
+#endif
+
+#if defined(_MSC_VER) && _MSC_VER < 1900
+// As recommended at
+// https://stackoverflow.com/questions/2915672/snprintf-and-visual-studio-2010
+extern JSON_API int msvc_pre1900_c99_snprintf(char* outBuf, size_t size,
+                                              const char* format, ...);
+#define jsoncpp_snprintf msvc_pre1900_c99_snprintf
+#else
+#define jsoncpp_snprintf std::snprintf
+#endif
+
+// If JSON_NO_INT64 is defined, then Json only support C++ "int" type for
+// integer
+// Storages, and 64 bits integer support is disabled.
+// #define JSON_NO_INT64 1
+
+// JSONCPP_OVERRIDE is maintained for backwards compatibility of external tools.
+// C++11 should be used directly in JSONCPP.
+#define JSONCPP_OVERRIDE override
+
+#ifdef __clang__
+#if __has_extension(attribute_deprecated_with_message)
+#define JSONCPP_DEPRECATED(message) __attribute__((deprecated(message)))
+#endif
+#elif defined(__GNUC__) // not clang (gcc comes later since clang emulates gcc)
+#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5))
+#define JSONCPP_DEPRECATED(message) __attribute__((deprecated(message)))
+#elif (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 1))
+#define JSONCPP_DEPRECATED(message) __attribute__((__deprecated__))
+#endif                  // GNUC version
+#elif defined(_MSC_VER) // MSVC (after clang because clang on Windows emulates
+                        // MSVC)
+#define JSONCPP_DEPRECATED(message) __declspec(deprecated(message))
+#endif // __clang__ || __GNUC__ || _MSC_VER
+
+#if !defined(JSONCPP_DEPRECATED)
+#define JSONCPP_DEPRECATED(message)
+#endif // if !defined(JSONCPP_DEPRECATED)
+
+#if defined(__clang__) || (defined(__GNUC__) && (__GNUC__ >= 6))
+#define JSON_USE_INT64_DOUBLE_CONVERSION 1
+#endif
+
+#if !defined(JSON_IS_AMALGAMATION)
+
+#include "allocator.h"
+#include "version.h"
+
+#endif // if !defined(JSON_IS_AMALGAMATION)
+
+namespace Json {
+using Int = int;
+using UInt = unsigned int;
+#if defined(JSON_NO_INT64)
+using LargestInt = int;
+using LargestUInt = unsigned int;
+#undef JSON_HAS_INT64
+#else                 // if defined(JSON_NO_INT64)
+// For Microsoft Visual use specific types as long long is not supported
+#if defined(_MSC_VER) // Microsoft Visual Studio
+using Int64 = __int64;
+using UInt64 = unsigned __int64;
+#else                 // if defined(_MSC_VER) // Other platforms, use long long
+using Int64 = int64_t;
+using UInt64 = uint64_t;
+#endif                // if defined(_MSC_VER)
+using LargestInt = Int64;
+using LargestUInt = UInt64;
+#define JSON_HAS_INT64
+#endif // if defined(JSON_NO_INT64)
+
+template <typename T>
+using Allocator =
+    typename std::conditional<JSONCPP_USING_SECURE_MEMORY, SecureAllocator<T>,
+                              std::allocator<T>>::type;
+using String = std::basic_string<char, std::char_traits<char>, Allocator<char>>;
+using IStringStream =
+    std::basic_istringstream<String::value_type, String::traits_type,
+                             String::allocator_type>;
+using OStringStream =
+    std::basic_ostringstream<String::value_type, String::traits_type,
+                             String::allocator_type>;
+using IStream = std::istream;
+using OStream = std::ostream;
+} // namespace Json
+
+// Legacy names (formerly macros).
+using JSONCPP_STRING = Json::String;
+using JSONCPP_ISTRINGSTREAM = Json::IStringStream;
+using JSONCPP_OSTRINGSTREAM = Json::OStringStream;
+using JSONCPP_ISTREAM = Json::IStream;
+using JSONCPP_OSTREAM = Json::OStream;
+
+#endif // JSON_CONFIG_H_INCLUDED
diff --git a/3rdparty/jsoncpp/src/include/json/forwards.h b/3rdparty/jsoncpp/src/include/json/forwards.h
new file mode 100644
index 00000000..affe33a7
--- /dev/null
+++ b/3rdparty/jsoncpp/src/include/json/forwards.h
@@ -0,0 +1,43 @@
+// Copyright 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
+// Distributed under MIT license, or public domain if desired and
+// recognized in your jurisdiction.
+// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+#ifndef JSON_FORWARDS_H_INCLUDED
+#define JSON_FORWARDS_H_INCLUDED
+
+#if !defined(JSON_IS_AMALGAMATION)
+#include "config.h"
+#endif // if !defined(JSON_IS_AMALGAMATION)
+
+namespace Json {
+
+// writer.h
+class StreamWriter;
+class StreamWriterBuilder;
+class Writer;
+class FastWriter;
+class StyledWriter;
+class StyledStreamWriter;
+
+// reader.h
+class Reader;
+class CharReader;
+class CharReaderBuilder;
+
+// json_features.h
+class Features;
+
+// value.h
+using ArrayIndex = unsigned int;
+class StaticString;
+class Path;
+class PathArgument;
+class Value;
+class ValueIteratorBase;
+class ValueIterator;
+class ValueConstIterator;
+
+} // namespace Json
+
+#endif // JSON_FORWARDS_H_INCLUDED
diff --git a/3rdparty/jsoncpp/src/include/json/json.h b/3rdparty/jsoncpp/src/include/json/json.h
new file mode 100644
index 00000000..5c776a16
--- /dev/null
+++ b/3rdparty/jsoncpp/src/include/json/json.h
@@ -0,0 +1,15 @@
+// Copyright 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
+// Distributed under MIT license, or public domain if desired and
+// recognized in your jurisdiction.
+// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+#ifndef JSON_JSON_H_INCLUDED
+#define JSON_JSON_H_INCLUDED
+
+#include "config.h"
+#include "json_features.h"
+#include "reader.h"
+#include "value.h"
+#include "writer.h"
+
+#endif // JSON_JSON_H_INCLUDED
diff --git a/3rdparty/jsoncpp/src/include/json/json_features.h b/3rdparty/jsoncpp/src/include/json/json_features.h
new file mode 100644
index 00000000..7c7e9f5d
--- /dev/null
+++ b/3rdparty/jsoncpp/src/include/json/json_features.h
@@ -0,0 +1,61 @@
+// Copyright 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
+// Distributed under MIT license, or public domain if desired and
+// recognized in your jurisdiction.
+// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+#ifndef JSON_FEATURES_H_INCLUDED
+#define JSON_FEATURES_H_INCLUDED
+
+#if !defined(JSON_IS_AMALGAMATION)
+#include "forwards.h"
+#endif // if !defined(JSON_IS_AMALGAMATION)
+
+#pragma pack(push, 8)
+
+namespace Json {
+
+/** \brief Configuration passed to reader and writer.
+ * This configuration object can be used to force the Reader or Writer
+ * to behave in a standard conforming way.
+ */
+class JSON_API Features {
+public:
+  /** \brief A configuration that allows all features and assumes all strings
+   * are UTF-8.
+   * - C & C++ comments are allowed
+   * - Root object can be any JSON value
+   * - Assumes Value strings are encoded in UTF-8
+   */
+  static Features all();
+
+  /** \brief A configuration that is strictly compatible with the JSON
+   * specification.
+   * - Comments are forbidden.
+   * - Root object must be either an array or an object value.
+   * - Assumes Value strings are encoded in UTF-8
+   */
+  static Features strictMode();
+
+  /** \brief Initialize the configuration like JsonConfig::allFeatures;
+   */
+  Features();
+
+  /// \c true if comments are allowed. Default: \c true.
+  bool allowComments_{true};
+
+  /// \c true if root must be either an array or an object value. Default: \c
+  /// false.
+  bool strictRoot_{false};
+
+  /// \c true if dropped null placeholders are allowed. Default: \c false.
+  bool allowDroppedNullPlaceholders_{false};
+
+  /// \c true if numeric object key are allowed. Default: \c false.
+  bool allowNumericKeys_{false};
+};
+
+} // namespace Json
+
+#pragma pack(pop)
+
+#endif // JSON_FEATURES_H_INCLUDED
diff --git a/3rdparty/jsoncpp/src/include/json/reader.h b/3rdparty/jsoncpp/src/include/json/reader.h
new file mode 100644
index 00000000..4ad10aff
--- /dev/null
+++ b/3rdparty/jsoncpp/src/include/json/reader.h
@@ -0,0 +1,405 @@
+// Copyright 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
+// Distributed under MIT license, or public domain if desired and
+// recognized in your jurisdiction.
+// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+#ifndef JSON_READER_H_INCLUDED
+#define JSON_READER_H_INCLUDED
+
+#if !defined(JSON_IS_AMALGAMATION)
+#include "json_features.h"
+#include "value.h"
+#endif // if !defined(JSON_IS_AMALGAMATION)
+#include <deque>
+#include <iosfwd>
+#include <istream>
+#include <stack>
+#include <string>
+
+// Disable warning C4251: <data member>: <type> needs to have dll-interface to
+// be used by...
+#if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
+#pragma warning(push)
+#pragma warning(disable : 4251)
+#endif // if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
+
+#pragma pack(push, 8)
+
+namespace Json {
+
+/** \brief Unserialize a <a HREF="http://www.json.org">JSON</a> document into a
+ * Value.
+ *
+ * \deprecated Use CharReader and CharReaderBuilder.
+ */
+
+class JSON_API Reader {
+public:
+  using Char = char;
+  using Location = const Char*;
+
+  /** \brief An error tagged with where in the JSON text it was encountered.
+   *
+   * The offsets give the [start, limit) range of bytes within the text. Note
+   * that this is bytes, not codepoints.
+   */
+  struct StructuredError {
+    ptrdiff_t offset_start;
+    ptrdiff_t offset_limit;
+    String message;
+  };
+
+  /** \brief Constructs a Reader allowing all features for parsing.
+   * \deprecated Use CharReader and CharReaderBuilder.
+   */
+  Reader();
+
+  /** \brief Constructs a Reader allowing the specified feature set for parsing.
+   * \deprecated Use CharReader and CharReaderBuilder.
+   */
+  Reader(const Features& features);
+
+  /** \brief Read a Value from a <a HREF="http://www.json.org">JSON</a>
+   * document.
+   *
+   * \param      document        UTF-8 encoded string containing the document
+   *                             to read.
+   * \param[out] root            Contains the root value of the document if it
+   *                             was successfully parsed.
+   * \param      collectComments \c true to collect comment and allow writing
+   *                             them back during serialization, \c false to
+   *                             discard comments.  This parameter is ignored
+   *                             if Features::allowComments_ is \c false.
+   * \return \c true if the document was successfully parsed, \c false if an
+   * error occurred.
+   */
+  bool parse(const std::string& document, Value& root,
+             bool collectComments = true);
+
+  /** \brief Read a Value from a <a HREF="http://www.json.org">JSON</a>
+   * document.
+   *
+   * \param      beginDoc        Pointer on the beginning of the UTF-8 encoded
+   *                             string of the document to read.
+   * \param      endDoc          Pointer on the end of the UTF-8 encoded string
+   *                             of the document to read.  Must be >= beginDoc.
+   * \param[out] root            Contains the root value of the document if it
+   *                             was successfully parsed.
+   * \param      collectComments \c true to collect comment and allow writing
+   *                             them back during serialization, \c false to
+   *                             discard comments.  This parameter is ignored
+   *                             if Features::allowComments_ is \c false.
+   * \return \c true if the document was successfully parsed, \c false if an
+   * error occurred.
+   */
+  bool parse(const char* beginDoc, const char* endDoc, Value& root,
+             bool collectComments = true);
+
+  /// \brief Parse from input stream.
+  /// \see Json::operator>>(std::istream&, Json::Value&).
+  bool parse(IStream& is, Value& root, bool collectComments = true);
+
+  /** \brief Returns a user friendly string that list errors in the parsed
+   * document.
+   *
+   * \return Formatted error message with the list of errors with their
+   * location in the parsed document. An empty string is returned if no error
+   * occurred during parsing.
+   * \deprecated Use getFormattedErrorMessages() instead (typo fix).
+   */
+  JSONCPP_DEPRECATED("Use getFormattedErrorMessages() instead.")
+  String getFormatedErrorMessages() const;
+
+  /** \brief Returns a user friendly string that list errors in the parsed
+   * document.
+   *
+   * \return Formatted error message with the list of errors with their
+   * location in the parsed document. An empty string is returned if no error
+   * occurred during parsing.
+   */
+  String getFormattedErrorMessages() const;
+
+  /** \brief Returns a vector of structured errors encountered while parsing.
+   *
+   * \return A (possibly empty) vector of StructuredError objects. Currently
+   * only one error can be returned, but the caller should tolerate multiple
+   * errors.  This can occur if the parser recovers from a non-fatal parse
+   * error and then encounters additional errors.
+   */
+  std::vector<StructuredError> getStructuredErrors() const;
+
+  /** \brief Add a semantic error message.
+   *
+   * \param value   JSON Value location associated with the error
+   * \param message The error message.
+   * \return \c true if the error was successfully added, \c false if the Value
+   * offset exceeds the document size.
+   */
+  bool pushError(const Value& value, const String& message);
+
+  /** \brief Add a semantic error message with extra context.
+   *
+   * \param value   JSON Value location associated with the error
+   * \param message The error message.
+   * \param extra   Additional JSON Value location to contextualize the error
+   * \return \c true if the error was successfully added, \c false if either
+   * Value offset exceeds the document size.
+   */
+  bool pushError(const Value& value, const String& message, const Value& extra);
+
+  /** \brief Return whether there are any errors.
+   *
+   * \return \c true if there are no errors to report \c false if errors have
+   * occurred.
+   */
+  bool good() const;
+
+private:
+  enum TokenType {
+    tokenEndOfStream = 0,
+    tokenObjectBegin,
+    tokenObjectEnd,
+    tokenArrayBegin,
+    tokenArrayEnd,
+    tokenString,
+    tokenNumber,
+    tokenTrue,
+    tokenFalse,
+    tokenNull,
+    tokenArraySeparator,
+    tokenMemberSeparator,
+    tokenComment,
+    tokenError
+  };
+
+  class Token {
+  public:
+    TokenType type_;
+    Location start_;
+    Location end_;
+  };
+
+  class ErrorInfo {
+  public:
+    Token token_;
+    String message_;
+    Location extra_;
+  };
+
+  using Errors = std::deque<ErrorInfo>;
+
+  bool readToken(Token& token);
+  void skipSpaces();
+  bool match(const Char* pattern, int patternLength);
+  bool readComment();
+  bool readCStyleComment();
+  bool readCppStyleComment();
+  bool readString();
+  void readNumber();
+  bool readValue();
+  bool readObject(Token& token);
+  bool readArray(Token& token);
+  bool decodeNumber(Token& token);
+  bool decodeNumber(Token& token, Value& decoded);
+  bool decodeString(Token& token);
+  bool decodeString(Token& token, String& decoded);
+  bool decodeDouble(Token& token);
+  bool decodeDouble(Token& token, Value& decoded);
+  bool decodeUnicodeCodePoint(Token& token, Location& current, Location end,
+                              unsigned int& unicode);
+  bool decodeUnicodeEscapeSequence(Token& token, Location& current,
+                                   Location end, unsigned int& unicode);
+  bool addError(const String& message, Token& token, Location extra = nullptr);
+  bool recoverFromError(TokenType skipUntilToken);
+  bool addErrorAndRecover(const String& message, Token& token,
+                          TokenType skipUntilToken);
+  void skipUntilSpace();
+  Value& currentValue();
+  Char getNextChar();
+  void getLocationLineAndColumn(Location location, int& line,
+                                int& column) const;
+  String getLocationLineAndColumn(Location location) const;
+  void addComment(Location begin, Location end, CommentPlacement placement);
+  void skipCommentTokens(Token& token);
+
+  static bool containsNewLine(Location begin, Location end);
+  static String normalizeEOL(Location begin, Location end);
+
+  using Nodes = std::stack<Value*>;
+  Nodes nodes_;
+  Errors errors_;
+  String document_;
+  Location begin_{};
+  Location end_{};
+  Location current_{};
+  Location lastValueEnd_{};
+  Value* lastValue_{};
+  String commentsBefore_;
+  Features features_;
+  bool collectComments_{};
+}; // Reader
+
+/** Interface for reading JSON from a char array.
+ */
+class JSON_API CharReader {
+public:
+  virtual ~CharReader() = default;
+  /** \brief Read a Value from a <a HREF="http://www.json.org">JSON</a>
+   * document. The document must be a UTF-8 encoded string containing the
+   * document to read.
+   *
+   * \param      beginDoc Pointer on the beginning of the UTF-8 encoded string
+   *                      of the document to read.
+   * \param      endDoc   Pointer on the end of the UTF-8 encoded string of the
+   *                      document to read. Must be >= beginDoc.
+   * \param[out] root     Contains the root value of the document if it was
+   *                      successfully parsed.
+   * \param[out] errs     Formatted error messages (if not NULL) a user
+   *                      friendly string that lists errors in the parsed
+   *                      document.
+   * \return \c true if the document was successfully parsed, \c false if an
+   * error occurred.
+   */
+  virtual bool parse(char const* beginDoc, char const* endDoc, Value* root,
+                     String* errs) = 0;
+
+  class JSON_API Factory {
+  public:
+    virtual ~Factory() = default;
+    /** \brief Allocate a CharReader via operator new().
+     * \throw std::exception if something goes wrong (e.g. invalid settings)
+     */
+    virtual CharReader* newCharReader() const = 0;
+  }; // Factory
+};   // CharReader
+
+/** \brief Build a CharReader implementation.
+ *
+ * Usage:
+ *   \code
+ *   using namespace Json;
+ *   CharReaderBuilder builder;
+ *   builder["collectComments"] = false;
+ *   Value value;
+ *   String errs;
+ *   bool ok = parseFromStream(builder, std::cin, &value, &errs);
+ *   \endcode
+ */
+class JSON_API CharReaderBuilder : public CharReader::Factory {
+public:
+  // Note: We use a Json::Value so that we can add data-members to this class
+  // without a major version bump.
+  /** Configuration of this builder.
+   * These are case-sensitive.
+   * Available settings (case-sensitive):
+   * - `"collectComments": false or true`
+   *   - true to collect comment and allow writing them back during
+   *     serialization, false to discard comments.  This parameter is ignored
+   *     if allowComments is false.
+   * - `"allowComments": false or true`
+   *   - true if comments are allowed.
+   * - `"allowTrailingCommas": false or true`
+   *   - true if trailing commas in objects and arrays are allowed.
+   * - `"strictRoot": false or true`
+   *   - true if root must be either an array or an object value
+   * - `"allowDroppedNullPlaceholders": false or true`
+   *   - true if dropped null placeholders are allowed. (See
+   *     StreamWriterBuilder.)
+   * - `"allowNumericKeys": false or true`
+   *   - true if numeric object keys are allowed.
+   * - `"allowSingleQuotes": false or true`
+   *   - true if '' are allowed for strings (both keys and values)
+   * - `"stackLimit": integer`
+   *   - Exceeding stackLimit (recursive depth of `readValue()`) will cause an
+   *     exception.
+   *   - This is a security issue (seg-faults caused by deeply nested JSON), so
+   *     the default is low.
+   * - `"failIfExtra": false or true`
+   *   - If true, `parse()` returns false when extra non-whitespace trails the
+   *     JSON value in the input string.
+   * - `"rejectDupKeys": false or true`
+   *   - If true, `parse()` returns false when a key is duplicated within an
+   *     object.
+   * - `"allowSpecialFloats": false or true`
+   *   - If true, special float values (NaNs and infinities) are allowed and
+   *     their values are lossfree restorable.
+   * - `"skipBom": false or true`
+   *   - If true, if the input starts with the Unicode byte order mark (BOM),
+   *     it is skipped.
+   *
+   * You can examine 'settings_` yourself to see the defaults. You can also
+   * write and read them just like any JSON Value.
+   * \sa setDefaults()
+   */
+  Json::Value settings_;
+
+  CharReaderBuilder();
+  ~CharReaderBuilder() override;
+
+  CharReader* newCharReader() const override;
+
+  /** \return true if 'settings' are legal and consistent;
+   *   otherwise, indicate bad settings via 'invalid'.
+   */
+  bool validate(Json::Value* invalid) const;
+
+  /** A simple way to update a specific setting.
+   */
+  Value& operator[](const String& key);
+
+  /** Called by ctor, but you can use this to reset settings_.
+   * \pre 'settings' != NULL (but Json::null is fine)
+   * \remark Defaults:
+   * \snippet src/lib_json/json_reader.cpp CharReaderBuilderDefaults
+   */
+  static void setDefaults(Json::Value* settings);
+  /** Same as old Features::strictMode().
+   * \pre 'settings' != NULL (but Json::null is fine)
+   * \remark Defaults:
+   * \snippet src/lib_json/json_reader.cpp CharReaderBuilderStrictMode
+   */
+  static void strictMode(Json::Value* settings);
+};
+
+/** Consume entire stream and use its begin/end.
+ * Someday we might have a real StreamReader, but for now this
+ * is convenient.
+ */
+bool JSON_API parseFromStream(CharReader::Factory const&, IStream&, Value* root,
+                              String* errs);
+
+/** \brief Read from 'sin' into 'root'.
+ *
+ * Always keep comments from the input JSON.
+ *
+ * This can be used to read a file into a particular sub-object.
+ * For example:
+ *   \code
+ *   Json::Value root;
+ *   cin >> root["dir"]["file"];
+ *   cout << root;
+ *   \endcode
+ * Result:
+ * \verbatim
+ * {
+ * "dir": {
+ *    "file": {
+ *    // The input stream JSON would be nested here.
+ *    }
+ * }
+ * }
+ * \endverbatim
+ * \throw std::exception on parse error.
+ * \see Json::operator<<()
+ */
+JSON_API IStream& operator>>(IStream&, Value&);
+
+} // namespace Json
+
+#pragma pack(pop)
+
+#if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
+#pragma warning(pop)
+#endif // if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
+
+#endif // JSON_READER_H_INCLUDED
diff --git a/3rdparty/jsoncpp/src/include/json/value.h b/3rdparty/jsoncpp/src/include/json/value.h
new file mode 100644
index 00000000..0edeb050
--- /dev/null
+++ b/3rdparty/jsoncpp/src/include/json/value.h
@@ -0,0 +1,935 @@
+// Copyright 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
+// Distributed under MIT license, or public domain if desired and
+// recognized in your jurisdiction.
+// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+#ifndef JSON_H_INCLUDED
+#define JSON_H_INCLUDED
+
+#if !defined(JSON_IS_AMALGAMATION)
+#include "forwards.h"
+#endif // if !defined(JSON_IS_AMALGAMATION)
+
+// Conditional NORETURN attribute on the throw functions would:
+// a) suppress false positives from static code analysis
+// b) possibly improve optimization opportunities.
+#if !defined(JSONCPP_NORETURN)
+#if defined(_MSC_VER) && _MSC_VER == 1800
+#define JSONCPP_NORETURN __declspec(noreturn)
+#else
+#define JSONCPP_NORETURN [[noreturn]]
+#endif
+#endif
+
+// Support for '= delete' with template declarations was a late addition
+// to the c++11 standard and is rejected by clang 3.8 and Apple clang 8.2
+// even though these declare themselves to be c++11 compilers.
+#if !defined(JSONCPP_TEMPLATE_DELETE)
+#if defined(__clang__) && defined(__apple_build_version__)
+#if __apple_build_version__ <= 8000042
+#define JSONCPP_TEMPLATE_DELETE
+#endif
+#elif defined(__clang__)
+#if __clang_major__ == 3 && __clang_minor__ <= 8
+#define JSONCPP_TEMPLATE_DELETE
+#endif
+#endif
+#if !defined(JSONCPP_TEMPLATE_DELETE)
+#define JSONCPP_TEMPLATE_DELETE = delete
+#endif
+#endif
+
+#include <array>
+#include <exception>
+#include <map>
+#include <memory>
+#include <string>
+#include <vector>
+
+// Disable warning C4251: <data member>: <type> needs to have dll-interface to
+// be used by...
+#if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
+#pragma warning(push)
+#pragma warning(disable : 4251 4275)
+#endif // if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
+
+#pragma pack(push, 8)
+
+/** \brief JSON (JavaScript Object Notation).
+ */
+namespace Json {
+
+#if JSON_USE_EXCEPTION
+/** Base class for all exceptions we throw.
+ *
+ * We use nothing but these internally. Of course, STL can throw others.
+ */
+class JSON_API Exception : public std::exception {
+public:
+  Exception(String msg);
+  ~Exception() noexcept override;
+  char const* what() const noexcept override;
+
+protected:
+  String msg_;
+};
+
+/** Exceptions which the user cannot easily avoid.
+ *
+ * E.g. out-of-memory (when we use malloc), stack-overflow, malicious input
+ *
+ * \remark derived from Json::Exception
+ */
+class JSON_API RuntimeError : public Exception {
+public:
+  RuntimeError(String const& msg);
+};
+
+/** Exceptions thrown by JSON_ASSERT/JSON_FAIL macros.
+ *
+ * These are precondition-violations (user bugs) and internal errors (our bugs).
+ *
+ * \remark derived from Json::Exception
+ */
+class JSON_API LogicError : public Exception {
+public:
+  LogicError(String const& msg);
+};
+#endif
+
+/// used internally
+JSONCPP_NORETURN void throwRuntimeError(String const& msg);
+/// used internally
+JSONCPP_NORETURN void throwLogicError(String const& msg);
+
+/** \brief Type of the value held by a Value object.
+ */
+enum ValueType {
+  nullValue = 0, ///< 'null' value
+  intValue,      ///< signed integer value
+  uintValue,     ///< unsigned integer value
+  realValue,     ///< double value
+  stringValue,   ///< UTF-8 string value
+  booleanValue,  ///< bool value
+  arrayValue,    ///< array value (ordered list)
+  objectValue    ///< object value (collection of name/value pairs).
+};
+
+enum CommentPlacement {
+  commentBefore = 0,      ///< a comment placed on the line before a value
+  commentAfterOnSameLine, ///< a comment just after a value on the same line
+  commentAfter, ///< a comment on the line after a value (only make sense for
+  /// root value)
+  numberOfCommentPlacement
+};
+
+/** \brief Type of precision for formatting of real values.
+ */
+enum PrecisionType {
+  significantDigits = 0, ///< we set max number of significant digits in string
+  decimalPlaces          ///< we set max number of digits after "." in string
+};
+
+/** \brief Lightweight wrapper to tag static string.
+ *
+ * Value constructor and objectValue member assignment takes advantage of the
+ * StaticString and avoid the cost of string duplication when storing the
+ * string or the member name.
+ *
+ * Example of usage:
+ * \code
+ * Json::Value aValue( StaticString("some text") );
+ * Json::Value object;
+ * static const StaticString code("code");
+ * object[code] = 1234;
+ * \endcode
+ */
+class JSON_API StaticString {
+public:
+  explicit StaticString(const char* czstring) : c_str_(czstring) {}
+
+  operator const char*() const { return c_str_; }
+
+  const char* c_str() const { return c_str_; }
+
+private:
+  const char* c_str_;
+};
+
+/** \brief Represents a <a HREF="http://www.json.org">JSON</a> value.
+ *
+ * This class is a discriminated union wrapper that can represents a:
+ * - signed integer [range: Value::minInt - Value::maxInt]
+ * - unsigned integer (range: 0 - Value::maxUInt)
+ * - double
+ * - UTF-8 string
+ * - boolean
+ * - 'null'
+ * - an ordered list of Value
+ * - collection of name/value pairs (javascript object)
+ *
+ * The type of the held value is represented by a #ValueType and
+ * can be obtained using type().
+ *
+ * Values of an #objectValue or #arrayValue can be accessed using operator[]()
+ * methods.
+ * Non-const methods will automatically create the a #nullValue element
+ * if it does not exist.
+ * The sequence of an #arrayValue will be automatically resized and initialized
+ * with #nullValue. resize() can be used to enlarge or truncate an #arrayValue.
+ *
+ * The get() methods can be used to obtain default value in the case the
+ * required element does not exist.
+ *
+ * It is possible to iterate over the list of member keys of an object using
+ * the getMemberNames() method.
+ *
+ * \note #Value string-length fit in size_t, but keys must be < 2^30.
+ * (The reason is an implementation detail.) A #CharReader will raise an
+ * exception if a bound is exceeded to avoid security holes in your app,
+ * but the Value API does *not* check bounds. That is the responsibility
+ * of the caller.
+ */
+class JSON_API Value {
+  friend class ValueIteratorBase;
+
+public:
+  using Members = std::vector<String>;
+  using iterator = ValueIterator;
+  using const_iterator = ValueConstIterator;
+  using UInt = Json::UInt;
+  using Int = Json::Int;
+#if defined(JSON_HAS_INT64)
+  using UInt64 = Json::UInt64;
+  using Int64 = Json::Int64;
+#endif // defined(JSON_HAS_INT64)
+  using LargestInt = Json::LargestInt;
+  using LargestUInt = Json::LargestUInt;
+  using ArrayIndex = Json::ArrayIndex;
+
+  // Required for boost integration, e. g. BOOST_TEST
+  using value_type = std::string;
+
+#if JSON_USE_NULLREF
+  // Binary compatibility kludges, do not use.
+  static const Value& null;
+  static const Value& nullRef;
+#endif
+
+  // null and nullRef are deprecated, use this instead.
+  static Value const& nullSingleton();
+
+  /// Minimum signed integer value that can be stored in a Json::Value.
+  static constexpr LargestInt minLargestInt =
+      LargestInt(~(LargestUInt(-1) / 2));
+  /// Maximum signed integer value that can be stored in a Json::Value.
+  static constexpr LargestInt maxLargestInt = LargestInt(LargestUInt(-1) / 2);
+  /// Maximum unsigned integer value that can be stored in a Json::Value.
+  static constexpr LargestUInt maxLargestUInt = LargestUInt(-1);
+
+  /// Minimum signed int value that can be stored in a Json::Value.
+  static constexpr Int minInt = Int(~(UInt(-1) / 2));
+  /// Maximum signed int value that can be stored in a Json::Value.
+  static constexpr Int maxInt = Int(UInt(-1) / 2);
+  /// Maximum unsigned int value that can be stored in a Json::Value.
+  static constexpr UInt maxUInt = UInt(-1);
+
+#if defined(JSON_HAS_INT64)
+  /// Minimum signed 64 bits int value that can be stored in a Json::Value.
+  static constexpr Int64 minInt64 = Int64(~(UInt64(-1) / 2));
+  /// Maximum signed 64 bits int value that can be stored in a Json::Value.
+  static constexpr Int64 maxInt64 = Int64(UInt64(-1) / 2);
+  /// Maximum unsigned 64 bits int value that can be stored in a Json::Value.
+  static constexpr UInt64 maxUInt64 = UInt64(-1);
+#endif // defined(JSON_HAS_INT64)
+  /// Default precision for real value for string representation.
+  static constexpr UInt defaultRealPrecision = 17;
+  // The constant is hard-coded because some compiler have trouble
+  // converting Value::maxUInt64 to a double correctly (AIX/xlC).
+  // Assumes that UInt64 is a 64 bits integer.
+  static constexpr double maxUInt64AsDouble = 18446744073709551615.0;
+// Workaround for bug in the NVIDIAs CUDA 9.1 nvcc compiler
+// when using gcc and clang backend compilers.  CZString
+// cannot be defined as private.  See issue #486
+#ifdef __NVCC__
+public:
+#else
+private:
+#endif
+#ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION
+  class CZString {
+  public:
+    enum DuplicationPolicy { noDuplication = 0, duplicate, duplicateOnCopy };
+    CZString(ArrayIndex index);
+    CZString(char const* str, unsigned length, DuplicationPolicy allocate);
+    CZString(CZString const& other);
+    CZString(CZString&& other) noexcept;
+    ~CZString();
+    CZString& operator=(const CZString& other);
+    CZString& operator=(CZString&& other) noexcept;
+
+    bool operator<(CZString const& other) const;
+    bool operator==(CZString const& other) const;
+    ArrayIndex index() const;
+    // const char* c_str() const; ///< \deprecated
+    char const* data() const;
+    unsigned length() const;
+    bool isStaticString() const;
+
+  private:
+    void swap(CZString& other);
+
+    struct StringStorage {
+      unsigned policy_ : 2;
+      unsigned length_ : 30; // 1GB max
+    };
+
+    char const* cstr_; // actually, a prefixed string, unless policy is noDup
+    union {
+      ArrayIndex index_;
+      StringStorage storage_;
+    };
+  };
+
+public:
+  typedef std::map<CZString, Value> ObjectValues;
+#endif // ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION
+
+public:
+  /**
+   * \brief Create a default Value of the given type.
+   *
+   * This is a very useful constructor.
+   * To create an empty array, pass arrayValue.
+   * To create an empty object, pass objectValue.
+   * Another Value can then be set to this one by assignment.
+   * This is useful since clear() and resize() will not alter types.
+   *
+   * Examples:
+   *   \code
+   *   Json::Value null_value; // null
+   *   Json::Value arr_value(Json::arrayValue); // []
+   *   Json::Value obj_value(Json::objectValue); // {}
+   *   \endcode
+   */
+  Value(ValueType type = nullValue);
+  Value(Int value);
+  Value(UInt value);
+#if defined(JSON_HAS_INT64)
+  Value(Int64 value);
+  Value(UInt64 value);
+#endif // if defined(JSON_HAS_INT64)
+  Value(double value);
+  Value(const char* value); ///< Copy til first 0. (NULL causes to seg-fault.)
+  Value(const char* begin, const char* end); ///< Copy all, incl zeroes.
+  /**
+   * \brief Constructs a value from a static string.
+   *
+   * Like other value string constructor but do not duplicate the string for
+   * internal storage. The given string must remain alive after the call to
+   * this constructor.
+   *
+   * \note This works only for null-terminated strings. (We cannot change the
+   * size of this class, so we have nowhere to store the length, which might be
+   * computed later for various operations.)
+   *
+   * Example of usage:
+   *   \code
+   *   static StaticString foo("some text");
+   *   Json::Value aValue(foo);
+   *   \endcode
+   */
+  Value(const StaticString& value);
+  Value(const String& value);
+  Value(bool value);
+  Value(std::nullptr_t ptr) = delete;
+  Value(const Value& other);
+  Value(Value&& other) noexcept;
+  ~Value();
+
+  /// \note Overwrite existing comments. To preserve comments, use
+  /// #swapPayload().
+  Value& operator=(const Value& other);
+  Value& operator=(Value&& other) noexcept;
+
+  /// Swap everything.
+  void swap(Value& other);
+  /// Swap values but leave comments and source offsets in place.
+  void swapPayload(Value& other);
+
+  /// copy everything.
+  void copy(const Value& other);
+  /// copy values but leave comments and source offsets in place.
+  void copyPayload(const Value& other);
+
+  ValueType type() const;
+
+  /// Compare payload only, not comments etc.
+  bool operator<(const Value& other) const;
+  bool operator<=(const Value& other) const;
+  bool operator>=(const Value& other) const;
+  bool operator>(const Value& other) const;
+  bool operator==(const Value& other) const;
+  bool operator!=(const Value& other) const;
+  int compare(const Value& other) const;
+
+  const char* asCString() const; ///< Embedded zeroes could cause you trouble!
+#if JSONCPP_USING_SECURE_MEMORY
+  unsigned getCStringLength() const; // Allows you to understand the length of
+                                     // the CString
+#endif
+  String asString() const; ///< Embedded zeroes are possible.
+  /** Get raw char* of string-value.
+   *  \return false if !string. (Seg-fault if str or end are NULL.)
+   */
+  bool getString(char const** begin, char const** end) const;
+  Int asInt() const;
+  UInt asUInt() const;
+#if defined(JSON_HAS_INT64)
+  Int64 asInt64() const;
+  UInt64 asUInt64() const;
+#endif // if defined(JSON_HAS_INT64)
+  LargestInt asLargestInt() const;
+  LargestUInt asLargestUInt() const;
+  float asFloat() const;
+  double asDouble() const;
+  bool asBool() const;
+
+  bool isNull() const;
+  bool isBool() const;
+  bool isInt() const;
+  bool isInt64() const;
+  bool isUInt() const;
+  bool isUInt64() const;
+  bool isIntegral() const;
+  bool isDouble() const;
+  bool isNumeric() const;
+  bool isString() const;
+  bool isArray() const;
+  bool isObject() const;
+
+  /// The `as<T>` and `is<T>` member function templates and specializations.
+  template <typename T> T as() const JSONCPP_TEMPLATE_DELETE;
+  template <typename T> bool is() const JSONCPP_TEMPLATE_DELETE;
+
+  bool isConvertibleTo(ValueType other) const;
+
+  /// Number of values in array or object
+  ArrayIndex size() const;
+
+  /// \brief Return true if empty array, empty object, or null;
+  /// otherwise, false.
+  bool empty() const;
+
+  /// Return !isNull()
+  explicit operator bool() const;
+
+  /// Remove all object members and array elements.
+  /// \pre type() is arrayValue, objectValue, or nullValue
+  /// \post type() is unchanged
+  void clear();
+
+  /// Resize the array to newSize elements.
+  /// New elements are initialized to null.
+  /// May only be called on nullValue or arrayValue.
+  /// \pre type() is arrayValue or nullValue
+  /// \post type() is arrayValue
+  void resize(ArrayIndex newSize);
+
+  //@{
+  /// Access an array element (zero based index). If the array contains less
+  /// than index element, then null value are inserted in the array so that
+  /// its size is index+1.
+  /// (You may need to say 'value[0u]' to get your compiler to distinguish
+  /// this from the operator[] which takes a string.)
+  Value& operator[](ArrayIndex index);
+  Value& operator[](int index);
+  //@}
+
+  //@{
+  /// Access an array element (zero based index).
+  /// (You may need to say 'value[0u]' to get your compiler to distinguish
+  /// this from the operator[] which takes a string.)
+  const Value& operator[](ArrayIndex index) const;
+  const Value& operator[](int index) const;
+  //@}
+
+  /// If the array contains at least index+1 elements, returns the element
+  /// value, otherwise returns defaultValue.
+  Value get(ArrayIndex index, const Value& defaultValue) const;
+  /// Return true if index < size().
+  bool isValidIndex(ArrayIndex index) const;
+  /// \brief Append value to array at the end.
+  ///
+  /// Equivalent to jsonvalue[jsonvalue.size()] = value;
+  Value& append(const Value& value);
+  Value& append(Value&& value);
+
+  /// \brief Insert value in array at specific index
+  bool insert(ArrayIndex index, const Value& newValue);
+  bool insert(ArrayIndex index, Value&& newValue);
+
+  /// Access an object value by name, create a null member if it does not exist.
+  /// \note Because of our implementation, keys are limited to 2^30 -1 chars.
+  /// Exceeding that will cause an exception.
+  Value& operator[](const char* key);
+  /// Access an object value by name, returns null if there is no member with
+  /// that name.
+  const Value& operator[](const char* key) const;
+  /// Access an object value by name, create a null member if it does not exist.
+  /// \param key may contain embedded nulls.
+  Value& operator[](const String& key);
+  /// Access an object value by name, returns null if there is no member with
+  /// that name.
+  /// \param key may contain embedded nulls.
+  const Value& operator[](const String& key) const;
+  /** \brief Access an object value by name, create a null member if it does not
+   * exist.
+   *
+   * If the object has no entry for that name, then the member name used to
+   * store the new entry is not duplicated.
+   * Example of use:
+   *   \code
+   *   Json::Value object;
+   *   static const StaticString code("code");
+   *   object[code] = 1234;
+   *   \endcode
+   */
+  Value& operator[](const StaticString& key);
+  /// Return the member named key if it exist, defaultValue otherwise.
+  /// \note deep copy
+  Value get(const char* key, const Value& defaultValue) const;
+  /// Return the member named key if it exist, defaultValue otherwise.
+  /// \note deep copy
+  /// \note key may contain embedded nulls.
+  Value get(const char* begin, const char* end,
+            const Value& defaultValue) const;
+  /// Return the member named key if it exist, defaultValue otherwise.
+  /// \note deep copy
+  /// \param key may contain embedded nulls.
+  Value get(const String& key, const Value& defaultValue) const;
+  /// Most general and efficient version of isMember()const, get()const,
+  /// and operator[]const
+  /// \note As stated elsewhere, behavior is undefined if (end-begin) >= 2^30
+  Value const* find(char const* begin, char const* end) const;
+  /// Most general and efficient version of object-mutators.
+  /// \note As stated elsewhere, behavior is undefined if (end-begin) >= 2^30
+  /// \return non-zero, but JSON_ASSERT if this is neither object nor nullValue.
+  Value* demand(char const* begin, char const* end);
+  /// \brief Remove and return the named member.
+  ///
+  /// Do nothing if it did not exist.
+  /// \pre type() is objectValue or nullValue
+  /// \post type() is unchanged
+  void removeMember(const char* key);
+  /// Same as removeMember(const char*)
+  /// \param key may contain embedded nulls.
+  void removeMember(const String& key);
+  /// Same as removeMember(const char* begin, const char* end, Value* removed),
+  /// but 'key' is null-terminated.
+  bool removeMember(const char* key, Value* removed);
+  /** \brief Remove the named map member.
+   *
+   *  Update 'removed' iff removed.
+   *  \param key may contain embedded nulls.
+   *  \return true iff removed (no exceptions)
+   */
+  bool removeMember(String const& key, Value* removed);
+  /// Same as removeMember(String const& key, Value* removed)
+  bool removeMember(const char* begin, const char* end, Value* removed);
+  /** \brief Remove the indexed array element.
+   *
+   *  O(n) expensive operations.
+   *  Update 'removed' iff removed.
+   *  \return true if removed (no exceptions)
+   */
+  bool removeIndex(ArrayIndex index, Value* removed);
+
+  /// Return true if the object has a member named key.
+  /// \note 'key' must be null-terminated.
+  bool isMember(const char* key) const;
+  /// Return true if the object has a member named key.
+  /// \param key may contain embedded nulls.
+  bool isMember(const String& key) const;
+  /// Same as isMember(String const& key)const
+  bool isMember(const char* begin, const char* end) const;
+
+  /// \brief Return a list of the member names.
+  ///
+  /// If null, return an empty list.
+  /// \pre type() is objectValue or nullValue
+  /// \post if type() was nullValue, it remains nullValue
+  Members getMemberNames() const;
+
+  /// \deprecated Always pass len.
+  JSONCPP_DEPRECATED("Use setComment(String const&) instead.")
+  void setComment(const char* comment, CommentPlacement placement) {
+    setComment(String(comment, strlen(comment)), placement);
+  }
+  /// Comments must be //... or /* ... */
+  void setComment(const char* comment, size_t len, CommentPlacement placement) {
+    setComment(String(comment, len), placement);
+  }
+  /// Comments must be //... or /* ... */
+  void setComment(String comment, CommentPlacement placement);
+  bool hasComment(CommentPlacement placement) const;
+  /// Include delimiters and embedded newlines.
+  String getComment(CommentPlacement placement) const;
+
+  String toStyledString() const;
+
+  const_iterator begin() const;
+  const_iterator end() const;
+
+  iterator begin();
+  iterator end();
+
+  // Accessors for the [start, limit) range of bytes within the JSON text from
+  // which this value was parsed, if any.
+  void setOffsetStart(ptrdiff_t start);
+  void setOffsetLimit(ptrdiff_t limit);
+  ptrdiff_t getOffsetStart() const;
+  ptrdiff_t getOffsetLimit() const;
+
+private:
+  void setType(ValueType v) {
+    bits_.value_type_ = static_cast<unsigned char>(v);
+  }
+  bool isAllocated() const { return bits_.allocated_; }
+  void setIsAllocated(bool v) { bits_.allocated_ = v; }
+
+  void initBasic(ValueType type, bool allocated = false);
+  void dupPayload(const Value& other);
+  void releasePayload();
+  void dupMeta(const Value& other);
+
+  Value& resolveReference(const char* key);
+  Value& resolveReference(const char* key, const char* end);
+
+  // struct MemberNamesTransform
+  //{
+  //   typedef const char *result_type;
+  //   const char *operator()( const CZString &name ) const
+  //   {
+  //      return name.c_str();
+  //   }
+  //};
+
+  union ValueHolder {
+    LargestInt int_;
+    LargestUInt uint_;
+    double real_;
+    bool bool_;
+    char* string_; // if allocated_, ptr to { unsigned, char[] }.
+    ObjectValues* map_;
+  } value_;
+
+  struct {
+    // Really a ValueType, but types should agree for bitfield packing.
+    unsigned int value_type_ : 8;
+    // Unless allocated_, string_ must be null-terminated.
+    unsigned int allocated_ : 1;
+  } bits_;
+
+  class Comments {
+  public:
+    Comments() = default;
+    Comments(const Comments& that);
+    Comments(Comments&& that) noexcept;
+    Comments& operator=(const Comments& that);
+    Comments& operator=(Comments&& that) noexcept;
+    bool has(CommentPlacement slot) const;
+    String get(CommentPlacement slot) const;
+    void set(CommentPlacement slot, String comment);
+
+  private:
+    using Array = std::array<String, numberOfCommentPlacement>;
+    std::unique_ptr<Array> ptr_;
+  };
+  Comments comments_;
+
+  // [start, limit) byte offsets in the source JSON text from which this Value
+  // was extracted.
+  ptrdiff_t start_;
+  ptrdiff_t limit_;
+};
+
+template <> inline bool Value::as<bool>() const { return asBool(); }
+template <> inline bool Value::is<bool>() const { return isBool(); }
+
+template <> inline Int Value::as<Int>() const { return asInt(); }
+template <> inline bool Value::is<Int>() const { return isInt(); }
+
+template <> inline UInt Value::as<UInt>() const { return asUInt(); }
+template <> inline bool Value::is<UInt>() const { return isUInt(); }
+
+#if defined(JSON_HAS_INT64)
+template <> inline Int64 Value::as<Int64>() const { return asInt64(); }
+template <> inline bool Value::is<Int64>() const { return isInt64(); }
+
+template <> inline UInt64 Value::as<UInt64>() const { return asUInt64(); }
+template <> inline bool Value::is<UInt64>() const { return isUInt64(); }
+#endif
+
+template <> inline double Value::as<double>() const { return asDouble(); }
+template <> inline bool Value::is<double>() const { return isDouble(); }
+
+template <> inline String Value::as<String>() const { return asString(); }
+template <> inline bool Value::is<String>() const { return isString(); }
+
+/// These `as` specializations are type conversions, and do not have a
+/// corresponding `is`.
+template <> inline float Value::as<float>() const { return asFloat(); }
+template <> inline const char* Value::as<const char*>() const {
+  return asCString();
+}
+
+/** \brief Experimental and untested: represents an element of the "path" to
+ * access a node.
+ */
+class JSON_API PathArgument {
+public:
+  friend class Path;
+
+  PathArgument();
+  PathArgument(ArrayIndex index);
+  PathArgument(const char* key);
+  PathArgument(String key);
+
+private:
+  enum Kind { kindNone = 0, kindIndex, kindKey };
+  String key_;
+  ArrayIndex index_{};
+  Kind kind_{kindNone};
+};
+
+/** \brief Experimental and untested: represents a "path" to access a node.
+ *
+ * Syntax:
+ * - "." => root node
+ * - ".[n]" => elements at index 'n' of root node (an array value)
+ * - ".name" => member named 'name' of root node (an object value)
+ * - ".name1.name2.name3"
+ * - ".[0][1][2].name1[3]"
+ * - ".%" => member name is provided as parameter
+ * - ".[%]" => index is provided as parameter
+ */
+class JSON_API Path {
+public:
+  Path(const String& path, const PathArgument& a1 = PathArgument(),
+       const PathArgument& a2 = PathArgument(),
+       const PathArgument& a3 = PathArgument(),
+       const PathArgument& a4 = PathArgument(),
+       const PathArgument& a5 = PathArgument());
+
+  const Value& resolve(const Value& root) const;
+  Value resolve(const Value& root, const Value& defaultValue) const;
+  /// Creates the "path" to access the specified node and returns a reference on
+  /// the node.
+  Value& make(Value& root) const;
+
+private:
+  using InArgs = std::vector<const PathArgument*>;
+  using Args = std::vector<PathArgument>;
+
+  void makePath(const String& path, const InArgs& in);
+  void addPathInArg(const String& path, const InArgs& in,
+                    InArgs::const_iterator& itInArg, PathArgument::Kind kind);
+  static void invalidPath(const String& path, int location);
+
+  Args args_;
+};
+
+/** \brief base class for Value iterators.
+ *
+ */
+class JSON_API ValueIteratorBase {
+public:
+  using iterator_category = std::bidirectional_iterator_tag;
+  using size_t = unsigned int;
+  using difference_type = int;
+  using SelfType = ValueIteratorBase;
+
+  bool operator==(const SelfType& other) const { return isEqual(other); }
+
+  bool operator!=(const SelfType& other) const { return !isEqual(other); }
+
+  difference_type operator-(const SelfType& other) const {
+    return other.computeDistance(*this);
+  }
+
+  /// Return either the index or the member name of the referenced value as a
+  /// Value.
+  Value key() const;
+
+  /// Return the index of the referenced Value, or -1 if it is not an
+  /// arrayValue.
+  UInt index() const;
+
+  /// Return the member name of the referenced Value, or "" if it is not an
+  /// objectValue.
+  /// \note Avoid `c_str()` on result, as embedded zeroes are possible.
+  String name() const;
+
+  /// Return the member name of the referenced Value. "" if it is not an
+  /// objectValue.
+  /// \deprecated This cannot be used for UTF-8 strings, since there can be
+  /// embedded nulls.
+  JSONCPP_DEPRECATED("Use `key = name();` instead.")
+  char const* memberName() const;
+  /// Return the member name of the referenced Value, or NULL if it is not an
+  /// objectValue.
+  /// \note Better version than memberName(). Allows embedded nulls.
+  char const* memberName(char const** end) const;
+
+protected:
+  /*! Internal utility functions to assist with implementing
+   *   other iterator functions. The const and non-const versions
+   *   of the "deref" protected methods expose the protected
+   *   current_ member variable in a way that can often be
+   *   optimized away by the compiler.
+   */
+  const Value& deref() const;
+  Value& deref();
+
+  void increment();
+
+  void decrement();
+
+  difference_type computeDistance(const SelfType& other) const;
+
+  bool isEqual(const SelfType& other) const;
+
+  void copy(const SelfType& other);
+
+private:
+  Value::ObjectValues::iterator current_;
+  // Indicates that iterator is for a null value.
+  bool isNull_{true};
+
+public:
+  // For some reason, BORLAND needs these at the end, rather
+  // than earlier. No idea why.
+  ValueIteratorBase();
+  explicit ValueIteratorBase(const Value::ObjectValues::iterator& current);
+};
+
+/** \brief const iterator for object and array value.
+ *
+ */
+class JSON_API ValueConstIterator : public ValueIteratorBase {
+  friend class Value;
+
+public:
+  using value_type = const Value;
+  // typedef unsigned int size_t;
+  // typedef int difference_type;
+  using reference = const Value&;
+  using pointer = const Value*;
+  using SelfType = ValueConstIterator;
+
+  ValueConstIterator();
+  ValueConstIterator(ValueIterator const& other);
+
+private:
+  /*! \internal Use by Value to create an iterator.
+   */
+  explicit ValueConstIterator(const Value::ObjectValues::iterator& current);
+
+public:
+  SelfType& operator=(const ValueIteratorBase& other);
+
+  SelfType operator++(int) {
+    SelfType temp(*this);
+    ++*this;
+    return temp;
+  }
+
+  SelfType operator--(int) {
+    SelfType temp(*this);
+    --*this;
+    return temp;
+  }
+
+  SelfType& operator--() {
+    decrement();
+    return *this;
+  }
+
+  SelfType& operator++() {
+    increment();
+    return *this;
+  }
+
+  reference operator*() const { return deref(); }
+
+  pointer operator->() const { return &deref(); }
+};
+
+/** \brief Iterator for object and array value.
+ */
+class JSON_API ValueIterator : public ValueIteratorBase {
+  friend class Value;
+
+public:
+  using value_type = Value;
+  using size_t = unsigned int;
+  using difference_type = int;
+  using reference = Value&;
+  using pointer = Value*;
+  using SelfType = ValueIterator;
+
+  ValueIterator();
+  explicit ValueIterator(const ValueConstIterator& other);
+  ValueIterator(const ValueIterator& other);
+
+private:
+  /*! \internal Use by Value to create an iterator.
+   */
+  explicit ValueIterator(const Value::ObjectValues::iterator& current);
+
+public:
+  SelfType& operator=(const SelfType& other);
+
+  SelfType operator++(int) {
+    SelfType temp(*this);
+    ++*this;
+    return temp;
+  }
+
+  SelfType operator--(int) {
+    SelfType temp(*this);
+    --*this;
+    return temp;
+  }
+
+  SelfType& operator--() {
+    decrement();
+    return *this;
+  }
+
+  SelfType& operator++() {
+    increment();
+    return *this;
+  }
+
+  /*! The return value of non-const iterators can be
+   *  changed, so the these functions are not const
+   *  because the returned references/pointers can be used
+   *  to change state of the base class.
+   */
+  reference operator*() const { return const_cast<reference>(deref()); }
+  pointer operator->() const { return const_cast<pointer>(&deref()); }
+};
+
+inline void swap(Value& a, Value& b) { a.swap(b); }
+
+} // namespace Json
+
+#pragma pack(pop)
+
+#if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
+#pragma warning(pop)
+#endif // if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
+
+#endif // JSON_H_INCLUDED
diff --git a/3rdparty/jsoncpp/src/include/json/version.h b/3rdparty/jsoncpp/src/include/json/version.h
new file mode 100644
index 00000000..e931d038
--- /dev/null
+++ b/3rdparty/jsoncpp/src/include/json/version.h
@@ -0,0 +1,28 @@
+#ifndef JSON_VERSION_H_INCLUDED
+#define JSON_VERSION_H_INCLUDED
+
+// Note: version must be updated in three places when doing a release. This
+// annoying process ensures that amalgamate, CMake, and meson all report the
+// correct version.
+// 1. /meson.build
+// 2. /include/json/version.h
+// 3. /CMakeLists.txt
+// IMPORTANT: also update the SOVERSION!!
+
+#define JSONCPP_VERSION_STRING "1.9.5"
+#define JSONCPP_VERSION_MAJOR 1
+#define JSONCPP_VERSION_MINOR 9
+#define JSONCPP_VERSION_PATCH 5
+#define JSONCPP_VERSION_QUALIFIER
+#define JSONCPP_VERSION_HEXA                                                   \
+  ((JSONCPP_VERSION_MAJOR << 24) | (JSONCPP_VERSION_MINOR << 16) |             \
+   (JSONCPP_VERSION_PATCH << 8))
+
+#ifdef JSONCPP_USING_SECURE_MEMORY
+#undef JSONCPP_USING_SECURE_MEMORY
+#endif
+#define JSONCPP_USING_SECURE_MEMORY 0
+// If non-zero, the library zeroes any memory that it has allocated before
+// it frees its memory.
+
+#endif // JSON_VERSION_H_INCLUDED
diff --git a/3rdparty/jsoncpp/src/include/json/writer.h b/3rdparty/jsoncpp/src/include/json/writer.h
new file mode 100644
index 00000000..1b855749
--- /dev/null
+++ b/3rdparty/jsoncpp/src/include/json/writer.h
@@ -0,0 +1,366 @@
+// Copyright 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
+// Distributed under MIT license, or public domain if desired and
+// recognized in your jurisdiction.
+// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+#ifndef JSON_WRITER_H_INCLUDED
+#define JSON_WRITER_H_INCLUDED
+
+#if !defined(JSON_IS_AMALGAMATION)
+#include "value.h"
+#endif // if !defined(JSON_IS_AMALGAMATION)
+#include <ostream>
+#include <string>
+#include <vector>
+
+// Disable warning C4251: <data member>: <type> needs to have dll-interface to
+// be used by...
+#if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING) && defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable : 4251)
+#endif // if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
+
+#pragma pack(push, 8)
+
+namespace Json {
+
+class Value;
+
+/**
+ *
+ * Usage:
+ *  \code
+ *  using namespace Json;
+ *  void writeToStdout(StreamWriter::Factory const& factory, Value const& value)
+ * { std::unique_ptr<StreamWriter> const writer( factory.newStreamWriter());
+ *    writer->write(value, &std::cout);
+ *    std::cout << std::endl;  // add lf and flush
+ *  }
+ *  \endcode
+ */
+class JSON_API StreamWriter {
+protected:
+  OStream* sout_; // not owned; will not delete
+public:
+  StreamWriter();
+  virtual ~StreamWriter();
+  /** Write Value into document as configured in sub-class.
+   *   Do not take ownership of sout, but maintain a reference during function.
+   *   \pre sout != NULL
+   *   \return zero on success (For now, we always return zero, so check the
+   *   stream instead.) \throw std::exception possibly, depending on
+   * configuration
+   */
+  virtual int write(Value const& root, OStream* sout) = 0;
+
+  /** \brief A simple abstract factory.
+   */
+  class JSON_API Factory {
+  public:
+    virtual ~Factory();
+    /** \brief Allocate a CharReader via operator new().
+     * \throw std::exception if something goes wrong (e.g. invalid settings)
+     */
+    virtual StreamWriter* newStreamWriter() const = 0;
+  }; // Factory
+};   // StreamWriter
+
+/** \brief Write into stringstream, then return string, for convenience.
+ * A StreamWriter will be created from the factory, used, and then deleted.
+ */
+String JSON_API writeString(StreamWriter::Factory const& factory,
+                            Value const& root);
+
+/** \brief Build a StreamWriter implementation.
+
+* Usage:
+*   \code
+*   using namespace Json;
+*   Value value = ...;
+*   StreamWriterBuilder builder;
+*   builder["commentStyle"] = "None";
+*   builder["indentation"] = "   ";  // or whatever you like
+*   std::unique_ptr<Json::StreamWriter> writer(
+*      builder.newStreamWriter());
+*   writer->write(value, &std::cout);
+*   std::cout << std::endl;  // add lf and flush
+*   \endcode
+*/
+class JSON_API StreamWriterBuilder : public StreamWriter::Factory {
+public:
+  // Note: We use a Json::Value so that we can add data-members to this class
+  // without a major version bump.
+  /** Configuration of this builder.
+   *  Available settings (case-sensitive):
+   *  - "commentStyle": "None" or "All"
+   *  - "indentation":  "<anything>".
+   *  - Setting this to an empty string also omits newline characters.
+   *  - "enableYAMLCompatibility": false or true
+   *  - slightly change the whitespace around colons
+   *  - "dropNullPlaceholders": false or true
+   *  - Drop the "null" string from the writer's output for nullValues.
+   *    Strictly speaking, this is not valid JSON. But when the output is being
+   *    fed to a browser's JavaScript, it makes for smaller output and the
+   *    browser can handle the output just fine.
+   *  - "useSpecialFloats": false or true
+   *  - If true, outputs non-finite floating point values in the following way:
+   *    NaN values as "NaN", positive infinity as "Infinity", and negative
+   *  infinity as "-Infinity".
+   *  - "precision": int
+   *  - Number of precision digits for formatting of real values.
+   *  - "precisionType": "significant"(default) or "decimal"
+   *  - Type of precision for formatting of real values.
+   *  - "emitUTF8": false or true
+   *  - If true, outputs raw UTF8 strings instead of escaping them.
+
+   *  You can examine 'settings_` yourself
+   *  to see the defaults. You can also write and read them just like any
+   *  JSON Value.
+   *  \sa setDefaults()
+   */
+  Json::Value settings_;
+
+  StreamWriterBuilder();
+  ~StreamWriterBuilder() override;
+
+  /**
+   * \throw std::exception if something goes wrong (e.g. invalid settings)
+   */
+  StreamWriter* newStreamWriter() const override;
+
+  /** \return true if 'settings' are legal and consistent;
+   *   otherwise, indicate bad settings via 'invalid'.
+   */
+  bool validate(Json::Value* invalid) const;
+  /** A simple way to update a specific setting.
+   */
+  Value& operator[](const String& key);
+
+  /** Called by ctor, but you can use this to reset settings_.
+   * \pre 'settings' != NULL (but Json::null is fine)
+   * \remark Defaults:
+   * \snippet src/lib_json/json_writer.cpp StreamWriterBuilderDefaults
+   */
+  static void setDefaults(Json::Value* settings);
+};
+
+/** \brief Abstract class for writers.
+ * \deprecated Use StreamWriter. (And really, this is an implementation detail.)
+ */
+class JSON_API Writer {
+public:
+  virtual ~Writer();
+
+  virtual String write(const Value& root) = 0;
+};
+
+/** \brief Outputs a Value in <a HREF="http://www.json.org">JSON</a> format
+ *without formatting (not human friendly).
+ *
+ * The JSON document is written in a single line. It is not intended for 'human'
+ *consumption,
+ * but may be useful to support feature such as RPC where bandwidth is limited.
+ * \sa Reader, Value
+ * \deprecated Use StreamWriterBuilder.
+ */
+#if defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable : 4996) // Deriving from deprecated class
+#endif
+class JSON_API FastWriter : public Writer {
+public:
+  FastWriter();
+  ~FastWriter() override = default;
+
+  void enableYAMLCompatibility();
+
+  /** \brief Drop the "null" string from the writer's output for nullValues.
+   * Strictly speaking, this is not valid JSON. But when the output is being
+   * fed to a browser's JavaScript, it makes for smaller output and the
+   * browser can handle the output just fine.
+   */
+  void dropNullPlaceholders();
+
+  void omitEndingLineFeed();
+
+public: // overridden from Writer
+  String write(const Value& root) override;
+
+private:
+  void writeValue(const Value& value);
+
+  String document_;
+  bool yamlCompatibilityEnabled_{false};
+  bool dropNullPlaceholders_{false};
+  bool omitEndingLineFeed_{false};
+};
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif
+
+/** \brief Writes a Value in <a HREF="http://www.json.org">JSON</a> format in a
+ *human friendly way.
+ *
+ * The rules for line break and indent are as follow:
+ * - Object value:
+ *     - if empty then print {} without indent and line break
+ *     - if not empty the print '{', line break & indent, print one value per
+ *line
+ *       and then unindent and line break and print '}'.
+ * - Array value:
+ *     - if empty then print [] without indent and line break
+ *     - if the array contains no object value, empty array or some other value
+ *types,
+ *       and all the values fit on one lines, then print the array on a single
+ *line.
+ *     - otherwise, it the values do not fit on one line, or the array contains
+ *       object or non empty array, then print one value per line.
+ *
+ * If the Value have comments then they are outputed according to their
+ *#CommentPlacement.
+ *
+ * \sa Reader, Value, Value::setComment()
+ * \deprecated Use StreamWriterBuilder.
+ */
+#if defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable : 4996) // Deriving from deprecated class
+#endif
+class JSON_API StyledWriter : public Writer {
+public:
+  StyledWriter();
+  ~StyledWriter() override = default;
+
+public: // overridden from Writer
+  /** \brief Serialize a Value in <a HREF="http://www.json.org">JSON</a> format.
+   * \param root Value to serialize.
+   * \return String containing the JSON document that represents the root value.
+   */
+  String write(const Value& root) override;
+
+private:
+  void writeValue(const Value& value);
+  void writeArrayValue(const Value& value);
+  bool isMultilineArray(const Value& value);
+  void pushValue(const String& value);
+  void writeIndent();
+  void writeWithIndent(const String& value);
+  void indent();
+  void unindent();
+  void writeCommentBeforeValue(const Value& root);
+  void writeCommentAfterValueOnSameLine(const Value& root);
+  static bool hasCommentForValue(const Value& value);
+  static String normalizeEOL(const String& text);
+
+  using ChildValues = std::vector<String>;
+
+  ChildValues childValues_;
+  String document_;
+  String indentString_;
+  unsigned int rightMargin_{74};
+  unsigned int indentSize_{3};
+  bool addChildValues_{false};
+};
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif
+
+/** \brief Writes a Value in <a HREF="http://www.json.org">JSON</a> format in a
+ human friendly way,
+     to a stream rather than to a string.
+ *
+ * The rules for line break and indent are as follow:
+ * - Object value:
+ *     - if empty then print {} without indent and line break
+ *     - if not empty the print '{', line break & indent, print one value per
+ line
+ *       and then unindent and line break and print '}'.
+ * - Array value:
+ *     - if empty then print [] without indent and line break
+ *     - if the array contains no object value, empty array or some other value
+ types,
+ *       and all the values fit on one lines, then print the array on a single
+ line.
+ *     - otherwise, it the values do not fit on one line, or the array contains
+ *       object or non empty array, then print one value per line.
+ *
+ * If the Value have comments then they are outputed according to their
+ #CommentPlacement.
+ *
+ * \sa Reader, Value, Value::setComment()
+ * \deprecated Use StreamWriterBuilder.
+ */
+#if defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable : 4996) // Deriving from deprecated class
+#endif
+class JSON_API StyledStreamWriter {
+public:
+  /**
+   * \param indentation Each level will be indented by this amount extra.
+   */
+  StyledStreamWriter(String indentation = "\t");
+  ~StyledStreamWriter() = default;
+
+public:
+  /** \brief Serialize a Value in <a HREF="http://www.json.org">JSON</a> format.
+   * \param out Stream to write to. (Can be ostringstream, e.g.)
+   * \param root Value to serialize.
+   * \note There is no point in deriving from Writer, since write() should not
+   * return a value.
+   */
+  void write(OStream& out, const Value& root);
+
+private:
+  void writeValue(const Value& value);
+  void writeArrayValue(const Value& value);
+  bool isMultilineArray(const Value& value);
+  void pushValue(const String& value);
+  void writeIndent();
+  void writeWithIndent(const String& value);
+  void indent();
+  void unindent();
+  void writeCommentBeforeValue(const Value& root);
+  void writeCommentAfterValueOnSameLine(const Value& root);
+  static bool hasCommentForValue(const Value& value);
+  static String normalizeEOL(const String& text);
+
+  using ChildValues = std::vector<String>;
+
+  ChildValues childValues_;
+  OStream* document_;
+  String indentString_;
+  unsigned int rightMargin_{74};
+  String indentation_;
+  bool addChildValues_ : 1;
+  bool indented_ : 1;
+};
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif
+
+#if defined(JSON_HAS_INT64)
+String JSON_API valueToString(Int value);
+String JSON_API valueToString(UInt value);
+#endif // if defined(JSON_HAS_INT64)
+String JSON_API valueToString(LargestInt value);
+String JSON_API valueToString(LargestUInt value);
+String JSON_API valueToString(
+    double value, unsigned int precision = Value::defaultRealPrecision,
+    PrecisionType precisionType = PrecisionType::significantDigits);
+String JSON_API valueToString(bool value);
+String JSON_API valueToQuotedString(const char* value);
+
+/// \brief Output using the StyledStreamWriter.
+/// \see Json::operator>>()
+JSON_API OStream& operator<<(OStream&, const Value& root);
+
+} // namespace Json
+
+#pragma pack(pop)
+
+#if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
+#pragma warning(pop)
+#endif // if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
+
+#endif // JSON_WRITER_H_INCLUDED
diff --git a/3rdparty/jsoncpp/src/jsoncpp-namespaced-targets.cmake b/3rdparty/jsoncpp/src/jsoncpp-namespaced-targets.cmake
new file mode 100644
index 00000000..ac1504e0
--- /dev/null
+++ b/3rdparty/jsoncpp/src/jsoncpp-namespaced-targets.cmake
@@ -0,0 +1,7 @@
+if (TARGET jsoncpp_static)
+    add_library(JsonCpp::JsonCpp INTERFACE IMPORTED)
+    set_target_properties(JsonCpp::JsonCpp PROPERTIES INTERFACE_LINK_LIBRARIES "jsoncpp_static")
+elseif (TARGET jsoncpp_lib)
+    add_library(JsonCpp::JsonCpp INTERFACE IMPORTED)
+    set_target_properties(JsonCpp::JsonCpp PROPERTIES INTERFACE_LINK_LIBRARIES "jsoncpp_lib")
+endif ()
\ No newline at end of file
diff --git a/3rdparty/jsoncpp/src/jsoncppConfig.cmake.in b/3rdparty/jsoncpp/src/jsoncppConfig.cmake.in
new file mode 100644
index 00000000..76570bc3
--- /dev/null
+++ b/3rdparty/jsoncpp/src/jsoncppConfig.cmake.in
@@ -0,0 +1,11 @@
+cmake_policy(PUSH)
+cmake_policy(VERSION 3.0)
+
+@PACKAGE_INIT@
+
+include ( "${CMAKE_CURRENT_LIST_DIR}/jsoncpp-targets.cmake" )
+include ( "${CMAKE_CURRENT_LIST_DIR}/jsoncpp-namespaced-targets.cmake" )
+
+check_required_components(JsonCpp)
+
+cmake_policy(POP)
diff --git a/3rdparty/jsoncpp/src/meson.build b/3rdparty/jsoncpp/src/meson.build
new file mode 100644
index 00000000..f68db30d
--- /dev/null
+++ b/3rdparty/jsoncpp/src/meson.build
@@ -0,0 +1,119 @@
+project(
+  'jsoncpp',
+  'cpp',
+
+  # Note: version must be updated in three places when doing a release. This
+  # annoying process ensures that amalgamate, CMake, and meson all report the
+  # correct version.
+  # 1. /meson.build
+  # 2. /include/json/version.h
+  # 3. /CMakeLists.txt
+  # IMPORTANT: also update the SOVERSION!!
+  version : '1.9.4',
+  default_options : [
+    'buildtype=release',
+    'cpp_std=c++11',
+    'warning_level=1'],
+  license : 'Public Domain',
+  meson_version : '>= 0.49.0')
+
+
+jsoncpp_headers = files([
+  'include/json/allocator.h',
+  'include/json/assertions.h',
+  'include/json/config.h',
+  'include/json/json_features.h',
+  'include/json/forwards.h',
+  'include/json/json.h',
+  'include/json/reader.h',
+  'include/json/value.h',
+  'include/json/version.h',
+  'include/json/writer.h',
+])
+jsoncpp_include_directories = include_directories('include')
+
+install_headers(
+  jsoncpp_headers,
+  subdir : 'json')
+
+if get_option('default_library') == 'shared' and meson.get_compiler('cpp').get_id() == 'msvc'
+  dll_export_flag = '-DJSON_DLL_BUILD'
+  dll_import_flag = '-DJSON_DLL'
+else
+  dll_export_flag = []
+  dll_import_flag = []
+endif
+
+jsoncpp_lib = library(
+  'jsoncpp', files([
+    'src/lib_json/json_reader.cpp',
+    'src/lib_json/json_value.cpp',
+    'src/lib_json/json_writer.cpp',
+  ]),
+  soversion : 25,
+  install : true,
+  include_directories : jsoncpp_include_directories,
+  cpp_args: dll_export_flag)
+
+import('pkgconfig').generate(
+  libraries : jsoncpp_lib,
+  version : meson.project_version(),
+  name : 'jsoncpp',
+  filebase : 'jsoncpp',
+  description : 'A C++ library for interacting with JSON')
+
+# for libraries bundling jsoncpp
+jsoncpp_dep = declare_dependency(
+  include_directories : jsoncpp_include_directories,
+  link_with : jsoncpp_lib,
+  version : meson.project_version())
+
+# tests
+if meson.is_subproject() or not get_option('tests')
+  subdir_done()
+endif
+
+python = import('python').find_installation()
+
+jsoncpp_test = executable(
+  'jsoncpp_test', files([
+    'src/test_lib_json/jsontest.cpp',
+    'src/test_lib_json/main.cpp',
+    'src/test_lib_json/fuzz.cpp',
+  ]),
+  include_directories : jsoncpp_include_directories,
+  link_with : jsoncpp_lib,
+  install : false,
+  cpp_args: dll_import_flag)
+test(
+  'unittest_jsoncpp_test',
+  jsoncpp_test)
+
+jsontestrunner = executable(
+  'jsontestrunner',
+  'src/jsontestrunner/main.cpp',
+  include_directories : jsoncpp_include_directories,
+  link_with : jsoncpp_lib,
+  install : false,
+  cpp_args: dll_import_flag)
+test(
+  'unittest_jsontestrunner',
+  python,
+  args : [
+    '-B',
+    join_paths(meson.current_source_dir(), 'test/runjsontests.py'),
+    jsontestrunner,
+    join_paths(meson.current_source_dir(), 'test/data')],
+  )
+test(
+  'jsonchecker_jsontestrunner',
+  python,
+  is_parallel : false,
+  args : [
+    '-B',
+    join_paths(meson.current_source_dir(), 'test/runjsontests.py'),
+    '--with-json-checker',
+    jsontestrunner,
+    join_paths(meson.current_source_dir(), 'test/data')],
+    workdir : join_paths(meson.current_source_dir(), 'test/data'),
+  )
diff --git a/3rdparty/jsoncpp/src/meson_options.txt b/3rdparty/jsoncpp/src/meson_options.txt
new file mode 100644
index 00000000..9c215ae6
--- /dev/null
+++ b/3rdparty/jsoncpp/src/meson_options.txt
@@ -0,0 +1,5 @@
+option(
+  'tests',
+  type : 'boolean',
+  value : true,
+  description : 'Enable building tests')
diff --git a/3rdparty/jsoncpp/src/pkg-config/jsoncpp.pc.in b/3rdparty/jsoncpp/src/pkg-config/jsoncpp.pc.in
new file mode 100644
index 00000000..2a222106
--- /dev/null
+++ b/3rdparty/jsoncpp/src/pkg-config/jsoncpp.pc.in
@@ -0,0 +1,11 @@
+prefix=@CMAKE_INSTALL_PREFIX@
+exec_prefix=@CMAKE_INSTALL_PREFIX@
+libdir=@libdir_for_pc_file@
+includedir=@includedir_for_pc_file@
+
+Name: jsoncpp
+Description: A C++ library for interacting with JSON
+Version: @PROJECT_VERSION@
+URL: https://github.com/open-source-parsers/jsoncpp
+Libs: -L${libdir} -ljsoncpp
+Cflags: -I${includedir}
diff --git a/3rdparty/jsoncpp/src/reformat.sh b/3rdparty/jsoncpp/src/reformat.sh
new file mode 100644
index 00000000..cdc03b1e
--- /dev/null
+++ b/3rdparty/jsoncpp/src/reformat.sh
@@ -0,0 +1 @@
+find src -name '*.cpp' -or -name '*.h' | xargs clang-format -i
diff --git a/3rdparty/jsoncpp/src/src/CMakeLists.txt b/3rdparty/jsoncpp/src/src/CMakeLists.txt
new file mode 100644
index 00000000..f09c905f
--- /dev/null
+++ b/3rdparty/jsoncpp/src/src/CMakeLists.txt
@@ -0,0 +1,5 @@
+add_subdirectory(lib_json)
+if(JSONCPP_WITH_TESTS)
+   add_subdirectory(jsontestrunner)
+   add_subdirectory(test_lib_json)
+endif()
diff --git a/3rdparty/jsoncpp/src/src/jsontestrunner/CMakeLists.txt b/3rdparty/jsoncpp/src/src/jsontestrunner/CMakeLists.txt
new file mode 100644
index 00000000..1fc71ea8
--- /dev/null
+++ b/3rdparty/jsoncpp/src/src/jsontestrunner/CMakeLists.txt
@@ -0,0 +1,51 @@
+if(CMAKE_VERSION VERSION_GREATER_EQUAL 3.12.0)
+    # The new Python3 module is much more robust than the previous PythonInterp
+    find_package(Python3 COMPONENTS Interpreter)
+    # Set variables for backwards compatibility with cmake < 3.12.0
+    set(PYTHONINTERP_FOUND ${Python3_Interpreter_FOUND})
+    set(PYTHON_EXECUTABLE ${Python3_EXECUTABLE})
+else()
+    set(Python_ADDITIONAL_VERSIONS 3.8)
+    find_package(PythonInterp 3)
+endif()
+
+add_executable(jsontestrunner_exe
+    main.cpp
+)
+
+if(BUILD_SHARED_LIBS)
+    if(CMAKE_VERSION VERSION_GREATER_EQUAL 3.12.0)
+        add_compile_definitions( JSON_DLL )
+    else()
+        add_definitions(-DJSON_DLL)
+    endif()
+    target_link_libraries(jsontestrunner_exe jsoncpp_lib)
+else()
+    target_link_libraries(jsontestrunner_exe jsoncpp_static)
+endif()
+
+set_target_properties(jsontestrunner_exe PROPERTIES OUTPUT_NAME jsontestrunner_exe)
+
+if(PYTHONINTERP_FOUND)
+    # Run end to end parser/writer tests
+    set(TEST_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../../test)
+    set(RUNJSONTESTS_PATH ${TEST_DIR}/runjsontests.py)
+
+    # Run unit tests in post-build
+    # (default cmake workflow hides away the test result into a file, resulting in poor dev workflow?!?)
+    add_custom_target(jsoncpp_readerwriter_tests
+        "${PYTHON_EXECUTABLE}" -B "${RUNJSONTESTS_PATH}" $<TARGET_FILE:jsontestrunner_exe> "${TEST_DIR}/data"
+        DEPENDS jsontestrunner_exe jsoncpp_test
+    )
+    add_custom_target(jsoncpp_check DEPENDS jsoncpp_readerwriter_tests)
+
+    ## Create tests for dashboard submission, allows easy review of CI results https://my.cdash.org/index.php?project=jsoncpp
+    add_test(NAME jsoncpp_readerwriter
+        COMMAND "${PYTHON_EXECUTABLE}" -B "${RUNJSONTESTS_PATH}" $<TARGET_FILE:jsontestrunner_exe> "${TEST_DIR}/data"
+        WORKING_DIRECTORY "${TEST_DIR}/data"
+    )
+    add_test(NAME jsoncpp_readerwriter_json_checker
+        COMMAND "${PYTHON_EXECUTABLE}" -B "${RUNJSONTESTS_PATH}" --with-json-checker  $<TARGET_FILE:jsontestrunner_exe> "${TEST_DIR}/data"
+        WORKING_DIRECTORY "${TEST_DIR}/data"
+    )
+endif()
diff --git a/3rdparty/jsoncpp/src/src/jsontestrunner/main.cpp b/3rdparty/jsoncpp/src/src/jsontestrunner/main.cpp
new file mode 100644
index 00000000..df717ffd
--- /dev/null
+++ b/3rdparty/jsoncpp/src/src/jsontestrunner/main.cpp
@@ -0,0 +1,343 @@
+// Copyright 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
+// Distributed under MIT license, or public domain if desired and
+// recognized in your jurisdiction.
+// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+#if defined(__GNUC__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#elif defined(_MSC_VER)
+#pragma warning(disable : 4996)
+#endif
+
+/* This executable is used for testing parser/writer using real JSON files.
+ */
+
+#include <algorithm> // sort
+#include <cstdio>
+#include <iostream>
+#include <json/json.h>
+#include <memory>
+#include <sstream>
+
+struct Options {
+  Json::String path;
+  Json::Features features;
+  bool parseOnly;
+  using writeFuncType = Json::String (*)(Json::Value const&);
+  writeFuncType write;
+};
+
+static Json::String normalizeFloatingPointStr(double value) {
+  char buffer[32];
+  jsoncpp_snprintf(buffer, sizeof(buffer), "%.16g", value);
+  buffer[sizeof(buffer) - 1] = 0;
+  Json::String s(buffer);
+  Json::String::size_type index = s.find_last_of("eE");
+  if (index != Json::String::npos) {
+    Json::String::size_type hasSign =
+        (s[index + 1] == '+' || s[index + 1] == '-') ? 1 : 0;
+    Json::String::size_type exponentStartIndex = index + 1 + hasSign;
+    Json::String normalized = s.substr(0, exponentStartIndex);
+    Json::String::size_type indexDigit =
+        s.find_first_not_of('0', exponentStartIndex);
+    Json::String exponent = "0";
+    if (indexDigit != Json::String::npos) // There is an exponent different
+                                          // from 0
+    {
+      exponent = s.substr(indexDigit);
+    }
+    return normalized + exponent;
+  }
+  return s;
+}
+
+static Json::String readInputTestFile(const char* path) {
+  FILE* file = fopen(path, "rb");
+  if (!file)
+    return "";
+  fseek(file, 0, SEEK_END);
+  auto const size = ftell(file);
+  auto const usize = static_cast<size_t>(size);
+  fseek(file, 0, SEEK_SET);
+  auto buffer = new char[size + 1];
+  buffer[size] = 0;
+  Json::String text;
+  if (fread(buffer, 1, usize, file) == usize)
+    text = buffer;
+  fclose(file);
+  delete[] buffer;
+  return text;
+}
+
+static void printValueTree(FILE* fout, Json::Value& value,
+                           const Json::String& path = ".") {
+  if (value.hasComment(Json::commentBefore)) {
+    fprintf(fout, "%s\n", value.getComment(Json::commentBefore).c_str());
+  }
+  switch (value.type()) {
+  case Json::nullValue:
+    fprintf(fout, "%s=null\n", path.c_str());
+    break;
+  case Json::intValue:
+    fprintf(fout, "%s=%s\n", path.c_str(),
+            Json::valueToString(value.asLargestInt()).c_str());
+    break;
+  case Json::uintValue:
+    fprintf(fout, "%s=%s\n", path.c_str(),
+            Json::valueToString(value.asLargestUInt()).c_str());
+    break;
+  case Json::realValue:
+    fprintf(fout, "%s=%s\n", path.c_str(),
+            normalizeFloatingPointStr(value.asDouble()).c_str());
+    break;
+  case Json::stringValue:
+    fprintf(fout, "%s=\"%s\"\n", path.c_str(), value.asString().c_str());
+    break;
+  case Json::booleanValue:
+    fprintf(fout, "%s=%s\n", path.c_str(), value.asBool() ? "true" : "false");
+    break;
+  case Json::arrayValue: {
+    fprintf(fout, "%s=[]\n", path.c_str());
+    Json::ArrayIndex size = value.size();
+    for (Json::ArrayIndex index = 0; index < size; ++index) {
+      static char buffer[16];
+      jsoncpp_snprintf(buffer, sizeof(buffer), "[%u]", index);
+      printValueTree(fout, value[index], path + buffer);
+    }
+  } break;
+  case Json::objectValue: {
+    fprintf(fout, "%s={}\n", path.c_str());
+    Json::Value::Members members(value.getMemberNames());
+    std::sort(members.begin(), members.end());
+    Json::String suffix = *(path.end() - 1) == '.' ? "" : ".";
+    for (const auto& name : members) {
+      printValueTree(fout, value[name], path + suffix + name);
+    }
+  } break;
+  default:
+    break;
+  }
+
+  if (value.hasComment(Json::commentAfter)) {
+    fprintf(fout, "%s\n", value.getComment(Json::commentAfter).c_str());
+  }
+}
+
+static int parseAndSaveValueTree(const Json::String& input,
+                                 const Json::String& actual,
+                                 const Json::String& kind,
+                                 const Json::Features& features, bool parseOnly,
+                                 Json::Value* root, bool use_legacy) {
+  if (!use_legacy) {
+    Json::CharReaderBuilder builder;
+
+    builder.settings_["allowComments"] = features.allowComments_;
+    builder.settings_["strictRoot"] = features.strictRoot_;
+    builder.settings_["allowDroppedNullPlaceholders"] =
+        features.allowDroppedNullPlaceholders_;
+    builder.settings_["allowNumericKeys"] = features.allowNumericKeys_;
+
+    std::unique_ptr<Json::CharReader> reader(builder.newCharReader());
+    Json::String errors;
+    const bool parsingSuccessful =
+        reader->parse(input.data(), input.data() + input.size(), root, &errors);
+
+    if (!parsingSuccessful) {
+      std::cerr << "Failed to parse " << kind << " file: " << std::endl
+                << errors << std::endl;
+      return 1;
+    }
+
+    // We may instead check the legacy implementation (to ensure it doesn't
+    // randomly get broken).
+  } else {
+    Json::Reader reader(features);
+    const bool parsingSuccessful =
+        reader.parse(input.data(), input.data() + input.size(), *root);
+    if (!parsingSuccessful) {
+      std::cerr << "Failed to parse " << kind << " file: " << std::endl
+                << reader.getFormatedErrorMessages() << std::endl;
+      return 1;
+    }
+  }
+
+  if (!parseOnly) {
+    FILE* factual = fopen(actual.c_str(), "wt");
+    if (!factual) {
+      std::cerr << "Failed to create '" << kind << "' actual file."
+                << std::endl;
+      return 2;
+    }
+    printValueTree(factual, *root);
+    fclose(factual);
+  }
+  return 0;
+}
+// static Json::String useFastWriter(Json::Value const& root) {
+//   Json::FastWriter writer;
+//   writer.enableYAMLCompatibility();
+//   return writer.write(root);
+// }
+static Json::String useStyledWriter(Json::Value const& root) {
+  Json::StyledWriter writer;
+  return writer.write(root);
+}
+static Json::String useStyledStreamWriter(Json::Value const& root) {
+  Json::StyledStreamWriter writer;
+  Json::OStringStream sout;
+  writer.write(sout, root);
+  return sout.str();
+}
+static Json::String useBuiltStyledStreamWriter(Json::Value const& root) {
+  Json::StreamWriterBuilder builder;
+  return Json::writeString(builder, root);
+}
+static int rewriteValueTree(const Json::String& rewritePath,
+                            const Json::Value& root,
+                            Options::writeFuncType write,
+                            Json::String* rewrite) {
+  *rewrite = write(root);
+  FILE* fout = fopen(rewritePath.c_str(), "wt");
+  if (!fout) {
+    std::cerr << "Failed to create rewrite file: " << rewritePath << std::endl;
+    return 2;
+  }
+  fprintf(fout, "%s\n", rewrite->c_str());
+  fclose(fout);
+  return 0;
+}
+
+static Json::String removeSuffix(const Json::String& path,
+                                 const Json::String& extension) {
+  if (extension.length() >= path.length())
+    return Json::String("");
+  Json::String suffix = path.substr(path.length() - extension.length());
+  if (suffix != extension)
+    return Json::String("");
+  return path.substr(0, path.length() - extension.length());
+}
+
+static void printConfig() {
+// Print the configuration used to compile JsonCpp
+#if defined(JSON_NO_INT64)
+  std::cout << "JSON_NO_INT64=1" << std::endl;
+#else
+  std::cout << "JSON_NO_INT64=0" << std::endl;
+#endif
+}
+
+static int printUsage(const char* argv[]) {
+  std::cout << "Usage: " << argv[0] << " [--strict] input-json-file"
+            << std::endl;
+  return 3;
+}
+
+static int parseCommandLine(int argc, const char* argv[], Options* opts) {
+  opts->parseOnly = false;
+  opts->write = &useStyledWriter;
+  if (argc < 2) {
+    return printUsage(argv);
+  }
+  int index = 1;
+  if (Json::String(argv[index]) == "--json-checker") {
+    opts->features = Json::Features::strictMode();
+    opts->parseOnly = true;
+    ++index;
+  }
+  if (Json::String(argv[index]) == "--json-config") {
+    printConfig();
+    return 3;
+  }
+  if (Json::String(argv[index]) == "--json-writer") {
+    ++index;
+    Json::String const writerName(argv[index++]);
+    if (writerName == "StyledWriter") {
+      opts->write = &useStyledWriter;
+    } else if (writerName == "StyledStreamWriter") {
+      opts->write = &useStyledStreamWriter;
+    } else if (writerName == "BuiltStyledStreamWriter") {
+      opts->write = &useBuiltStyledStreamWriter;
+    } else {
+      std::cerr << "Unknown '--json-writer' " << writerName << std::endl;
+      return 4;
+    }
+  }
+  if (index == argc || index + 1 < argc) {
+    return printUsage(argv);
+  }
+  opts->path = argv[index];
+  return 0;
+}
+
+static int runTest(Options const& opts, bool use_legacy) {
+  int exitCode = 0;
+
+  Json::String input = readInputTestFile(opts.path.c_str());
+  if (input.empty()) {
+    std::cerr << "Invalid input file: " << opts.path << std::endl;
+    return 3;
+  }
+
+  Json::String basePath = removeSuffix(opts.path, ".json");
+  if (!opts.parseOnly && basePath.empty()) {
+    std::cerr << "Bad input path '" << opts.path
+              << "'. Must end with '.expected'" << std::endl;
+    return 3;
+  }
+
+  Json::String const actualPath = basePath + ".actual";
+  Json::String const rewritePath = basePath + ".rewrite";
+  Json::String const rewriteActualPath = basePath + ".actual-rewrite";
+
+  Json::Value root;
+  exitCode = parseAndSaveValueTree(input, actualPath, "input", opts.features,
+                                   opts.parseOnly, &root, use_legacy);
+  if (exitCode || opts.parseOnly) {
+    return exitCode;
+  }
+
+  Json::String rewrite;
+  exitCode = rewriteValueTree(rewritePath, root, opts.write, &rewrite);
+  if (exitCode) {
+    return exitCode;
+  }
+
+  Json::Value rewriteRoot;
+  exitCode = parseAndSaveValueTree(rewrite, rewriteActualPath, "rewrite",
+                                   opts.features, opts.parseOnly, &rewriteRoot,
+                                   use_legacy);
+
+  return exitCode;
+}
+
+int main(int argc, const char* argv[]) {
+  Options opts;
+  try {
+    int exitCode = parseCommandLine(argc, argv, &opts);
+    if (exitCode != 0) {
+      std::cerr << "Failed to parse command-line." << std::endl;
+      return exitCode;
+    }
+
+    const int modern_return_code = runTest(opts, false);
+    if (modern_return_code) {
+      return modern_return_code;
+    }
+
+    const std::string filename =
+        opts.path.substr(opts.path.find_last_of("\\/") + 1);
+    const bool should_run_legacy = (filename.rfind("legacy_", 0) == 0);
+    if (should_run_legacy) {
+      return runTest(opts, true);
+    }
+  } catch (const std::exception& e) {
+    std::cerr << "Unhandled exception:" << std::endl << e.what() << std::endl;
+    return 1;
+  }
+  return 0;
+}
+
+#if defined(__GNUC__)
+#pragma GCC diagnostic pop
+#endif
diff --git a/3rdparty/jsoncpp/src/src/lib_json/CMakeLists.txt b/3rdparty/jsoncpp/src/src/lib_json/CMakeLists.txt
new file mode 100644
index 00000000..43fbee6c
--- /dev/null
+++ b/3rdparty/jsoncpp/src/src/lib_json/CMakeLists.txt
@@ -0,0 +1,213 @@
+if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU" AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 4.1.2)
+    #-Werror=* was introduced -after- GCC 4.1.2
+    add_compile_options("-Werror=strict-aliasing")
+endif()
+
+include(CheckIncludeFileCXX)
+include(CheckTypeSize)
+include(CheckStructHasMember)
+include(CheckCXXSymbolExists)
+
+check_include_file_cxx(clocale HAVE_CLOCALE)
+check_cxx_symbol_exists(localeconv clocale HAVE_LOCALECONV)
+
+set(CMAKE_EXTRA_INCLUDE_FILES clocale)
+check_type_size(lconv LCONV_SIZE LANGUAGE CXX)
+unset(CMAKE_EXTRA_INCLUDE_FILES)
+check_struct_has_member(lconv decimal_point clocale HAVE_DECIMAL_POINT LANGUAGE CXX)
+
+if(NOT (HAVE_CLOCALE AND HAVE_LCONV_SIZE AND HAVE_DECIMAL_POINT AND HAVE_LOCALECONV))
+    message(WARNING "Locale functionality is not supported")
+    if(CMAKE_VERSION VERSION_GREATER_EQUAL 3.12.0)
+        add_compile_definitions(JSONCPP_NO_LOCALE_SUPPORT)
+    else()
+        add_definitions(-DJSONCPP_NO_LOCALE_SUPPORT)
+    endif()
+endif()
+
+set(JSONCPP_INCLUDE_DIR ../../include)
+
+set(PUBLIC_HEADERS
+    ${JSONCPP_INCLUDE_DIR}/json/config.h
+    ${JSONCPP_INCLUDE_DIR}/json/forwards.h
+    ${JSONCPP_INCLUDE_DIR}/json/json_features.h
+    ${JSONCPP_INCLUDE_DIR}/json/value.h
+    ${JSONCPP_INCLUDE_DIR}/json/reader.h
+    ${JSONCPP_INCLUDE_DIR}/json/version.h
+    ${JSONCPP_INCLUDE_DIR}/json/writer.h
+    ${JSONCPP_INCLUDE_DIR}/json/assertions.h
+)
+
+source_group("Public API" FILES ${PUBLIC_HEADERS})
+
+set(JSONCPP_SOURCES
+    json_tool.h
+    json_reader.cpp
+    json_valueiterator.inl
+    json_value.cpp
+    json_writer.cpp
+)
+
+# Install instructions for this target
+if(JSONCPP_WITH_CMAKE_PACKAGE)
+    set(INSTALL_EXPORT EXPORT jsoncpp)
+else()
+    set(INSTALL_EXPORT)
+endif()
+
+# Specify compiler features required when compiling a given target.
+# See https://cmake.org/cmake/help/v3.1/prop_gbl/CMAKE_CXX_KNOWN_FEATURES.html#prop_gbl:CMAKE_CXX_KNOWN_FEATURES
+# for complete list of features available
+list(APPEND REQUIRED_FEATURES
+        cxx_std_11 # Compiler mode is aware of C++ 11.
+        #MSVC 1900 cxx_alignas # Alignment control alignas, as defined in N2341.
+        #MSVC 1900 cxx_alignof # Alignment control alignof, as defined in N2341.
+        #MSVC 1900 cxx_attributes # Generic attributes, as defined in N2761.
+        cxx_auto_type # Automatic type deduction, as defined in N1984.
+        #MSVC 1900 cxx_constexpr # Constant expressions, as defined in N2235.
+        cxx_decltype # Decltype, as defined in N2343.
+        cxx_default_function_template_args # Default template arguments for function templates, as defined in DR226
+        cxx_defaulted_functions # Defaulted functions, as defined in N2346.
+        #MSVC 1900 cxx_defaulted_move_initializers # Defaulted move initializers, as defined in N3053.
+        cxx_delegating_constructors # Delegating constructors, as defined in N1986.
+        #MSVC 1900 cxx_deleted_functions # Deleted functions, as defined in N2346.
+        cxx_enum_forward_declarations # Enum forward declarations, as defined in N2764.
+        cxx_explicit_conversions # Explicit conversion operators, as defined in N2437.
+        cxx_extended_friend_declarations # Extended friend declarations, as defined in N1791.
+        cxx_extern_templates # Extern templates, as defined in N1987.
+        cxx_final # Override control final keyword, as defined in N2928, N3206 and N3272.
+        #MSVC 1900 cxx_func_identifier # Predefined __func__ identifier, as defined in N2340.
+        #MSVC 1900 cxx_generalized_initializers # Initializer lists, as defined in N2672.
+        #MSVC 1900 cxx_inheriting_constructors # Inheriting constructors, as defined in N2540.
+        #MSVC 1900 cxx_inline_namespaces # Inline namespaces, as defined in N2535.
+        cxx_lambdas # Lambda functions, as defined in N2927.
+        #MSVC 1900 cxx_local_type_template_args # Local and unnamed types as template arguments, as defined in N2657.
+        cxx_long_long_type # long long type, as defined in N1811.
+        #MSVC 1900 cxx_noexcept # Exception specifications, as defined in N3050.
+        #MSVC 1900 cxx_nonstatic_member_init # Non-static data member initialization, as defined in N2756.
+        cxx_nullptr # Null pointer, as defined in N2431.
+        cxx_override # Override control override keyword, as defined in N2928, N3206 and N3272.
+        cxx_range_for # Range-based for, as defined in N2930.
+        cxx_raw_string_literals # Raw string literals, as defined in N2442.
+        #MSVC 1900 cxx_reference_qualified_functions # Reference qualified functions, as defined in N2439.
+        cxx_right_angle_brackets # Right angle bracket parsing, as defined in N1757.
+        cxx_rvalue_references # R-value references, as defined in N2118.
+        #MSVC 1900 cxx_sizeof_member # Size of non-static data members, as defined in N2253.
+        cxx_static_assert # Static assert, as defined in N1720.
+        cxx_strong_enums # Strongly typed enums, as defined in N2347.
+        #MSVC 1900 cxx_thread_local # Thread-local variables, as defined in N2659.
+        cxx_trailing_return_types # Automatic function return type, as defined in N2541.
+        #MSVC 1900 cxx_unicode_literals # Unicode string literals, as defined in N2442.
+        cxx_uniform_initialization # Uniform initialization, as defined in N2640.
+        #MSVC 1900 cxx_unrestricted_unions # Unrestricted unions, as defined in N2544.
+        #MSVC 1900 cxx_user_literals # User-defined literals, as defined in N2765.
+        cxx_variadic_macros # Variadic macros, as defined in N1653.
+        cxx_variadic_templates # Variadic templates, as defined in N2242.
+)
+
+
+if(BUILD_SHARED_LIBS)
+    if(CMAKE_VERSION VERSION_GREATER_EQUAL 3.12.0)
+        add_compile_definitions(JSON_DLL_BUILD)
+    else()
+        add_definitions(-DJSON_DLL_BUILD)
+    endif()
+
+    set(SHARED_LIB ${PROJECT_NAME}_lib)
+    add_library(${SHARED_LIB} SHARED ${PUBLIC_HEADERS} ${JSONCPP_SOURCES})
+    set_target_properties(${SHARED_LIB} PROPERTIES
+        OUTPUT_NAME jsoncpp
+        VERSION ${PROJECT_VERSION}
+        SOVERSION ${PROJECT_SOVERSION}
+        POSITION_INDEPENDENT_CODE ${BUILD_SHARED_LIBS}
+    )
+
+    # Set library's runtime search path on OSX
+    if(APPLE)
+        set_target_properties(${SHARED_LIB} PROPERTIES INSTALL_RPATH "@loader_path/.")
+    endif()
+
+    target_compile_features(${SHARED_LIB} PUBLIC ${REQUIRED_FEATURES})
+
+    target_include_directories(${SHARED_LIB} PUBLIC
+        $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
+        $<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/${JSONCPP_INCLUDE_DIR}>
+        $<BUILD_INTERFACE:${PROJECT_BINARY_DIR}/include/json>
+    )
+
+    list(APPEND CMAKE_TARGETS ${SHARED_LIB})
+endif()
+
+if(BUILD_STATIC_LIBS)
+    set(STATIC_LIB ${PROJECT_NAME}_static)
+    add_library(${STATIC_LIB} STATIC ${PUBLIC_HEADERS} ${JSONCPP_SOURCES})
+
+    # avoid name clashes on windows as the shared import lib is alse named jsoncpp.lib
+    if(NOT DEFINED STATIC_SUFFIX AND BUILD_SHARED_LIBS)
+        if (MSVC)
+            set(STATIC_SUFFIX "_static")
+        else()
+            set(STATIC_SUFFIX "")
+        endif()
+    endif()
+
+    if (UNIX AND NOT APPLE AND NOT (OB_BUILD_LINUX_ARM32 OR OB_BUILD_LINUX_ARM64))
+        target_compile_options(${STATIC_LIB} PUBLIC -fPIC)
+    endif()
+
+    set_target_properties(${STATIC_LIB} PROPERTIES
+        OUTPUT_NAME ob_jsoncpp${STATIC_SUFFIX}
+        VERSION ${PROJECT_VERSION}
+    )
+
+    # Set library's runtime search path on OSX
+    if(APPLE)
+        set_target_properties(${STATIC_LIB} PROPERTIES INSTALL_RPATH "@loader_path/.")
+    endif()
+
+    target_compile_features(${STATIC_LIB} PUBLIC ${REQUIRED_FEATURES})
+
+    target_include_directories(${STATIC_LIB} PUBLIC
+        $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
+        $<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/${JSONCPP_INCLUDE_DIR}>
+        $<BUILD_INTERFACE:${PROJECT_BINARY_DIR}/include/json>
+    )
+
+    list(APPEND CMAKE_TARGETS ${STATIC_LIB})
+endif()
+
+if(BUILD_OBJECT_LIBS)
+    set(OBJECT_LIB ${PROJECT_NAME}_object)
+    message(STATUS "Building object library ${OBJECT_LIB}")
+    add_library(${OBJECT_LIB} OBJECT ${PUBLIC_HEADERS} ${JSONCPP_SOURCES})
+
+    set_target_properties(${OBJECT_LIB} PROPERTIES
+        OUTPUT_NAME jsoncpp
+        VERSION ${PROJECT_VERSION}
+        SOVERSION ${PROJECT_SOVERSION}
+        POSITION_INDEPENDENT_CODE ${BUILD_SHARED_LIBS}
+    )
+
+    # Set library's runtime search path on OSX
+    if(APPLE)
+        set_target_properties(${OBJECT_LIB} PROPERTIES INSTALL_RPATH "@loader_path/.")
+    endif()
+
+    target_compile_features(${OBJECT_LIB} PUBLIC ${REQUIRED_FEATURES})
+
+    target_include_directories(${OBJECT_LIB} PUBLIC
+        $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
+        $<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/${JSONCPP_INCLUDE_DIR}>
+        $<BUILD_INTERFACE:${PROJECT_BINARY_DIR}/include/json>
+    )
+
+    list(APPEND CMAKE_TARGETS ${OBJECT_LIB})
+endif()
+
+# install(TARGETS ${CMAKE_TARGETS} ${INSTALL_EXPORT}
+#     RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+#     LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+#     ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+#     OBJECTS DESTINATION ${CMAKE_INSTALL_LIBDIR}
+# )
+
diff --git a/3rdparty/jsoncpp/src/src/lib_json/json_reader.cpp b/3rdparty/jsoncpp/src/src/lib_json/json_reader.cpp
new file mode 100644
index 00000000..a6a3f4e3
--- /dev/null
+++ b/3rdparty/jsoncpp/src/src/lib_json/json_reader.cpp
@@ -0,0 +1,1992 @@
+// Copyright 2007-2011 Baptiste Lepilleur and The JsonCpp Authors
+// Copyright (C) 2016 InfoTeCS JSC. All rights reserved.
+// Distributed under MIT license, or public domain if desired and
+// recognized in your jurisdiction.
+// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+#if !defined(JSON_IS_AMALGAMATION)
+#include "json_tool.h"
+#include <json/assertions.h>
+#include <json/reader.h>
+#include <json/value.h>
+#endif // if !defined(JSON_IS_AMALGAMATION)
+#include <algorithm>
+#include <cassert>
+#include <cstring>
+#include <iostream>
+#include <istream>
+#include <limits>
+#include <memory>
+#include <set>
+#include <sstream>
+#include <utility>
+
+#include <cstdio>
+#if __cplusplus >= 201103L
+
+#if !defined(sscanf)
+#define sscanf std::sscanf
+#endif
+
+#endif //__cplusplus
+
+#if defined(_MSC_VER)
+#if !defined(_CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES)
+#define _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES 1
+#endif //_CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES
+#endif //_MSC_VER
+
+#if defined(_MSC_VER)
+// Disable warning about strdup being deprecated.
+#pragma warning(disable : 4996)
+#endif
+
+// Define JSONCPP_DEPRECATED_STACK_LIMIT as an appropriate integer at compile
+// time to change the stack limit
+#if !defined(JSONCPP_DEPRECATED_STACK_LIMIT)
+#define JSONCPP_DEPRECATED_STACK_LIMIT 1000
+#endif
+
+static size_t const stackLimit_g =
+    JSONCPP_DEPRECATED_STACK_LIMIT; // see readValue()
+
+namespace Json {
+
+#if __cplusplus >= 201103L || (defined(_CPPLIB_VER) && _CPPLIB_VER >= 520)
+using CharReaderPtr = std::unique_ptr<CharReader>;
+#else
+using CharReaderPtr = std::auto_ptr<CharReader>;
+#endif
+
+// Implementation of class Features
+// ////////////////////////////////
+
+Features::Features() = default;
+
+Features Features::all() { return {}; }
+
+Features Features::strictMode() {
+  Features features;
+  features.allowComments_ = false;
+  features.strictRoot_ = true;
+  features.allowDroppedNullPlaceholders_ = false;
+  features.allowNumericKeys_ = false;
+  return features;
+}
+
+// Implementation of class Reader
+// ////////////////////////////////
+
+bool Reader::containsNewLine(Reader::Location begin, Reader::Location end) {
+  return std::any_of(begin, end, [](char b) { return b == '\n' || b == '\r'; });
+}
+
+// Class Reader
+// //////////////////////////////////////////////////////////////////
+
+Reader::Reader() : features_(Features::all()) {}
+
+Reader::Reader(const Features& features) : features_(features) {}
+
+bool Reader::parse(const std::string& document, Value& root,
+                   bool collectComments) {
+  document_.assign(document.begin(), document.end());
+  const char* begin = document_.c_str();
+  const char* end = begin + document_.length();
+  return parse(begin, end, root, collectComments);
+}
+
+bool Reader::parse(std::istream& is, Value& root, bool collectComments) {
+  // std::istream_iterator<char> begin(is);
+  // std::istream_iterator<char> end;
+  // Those would allow streamed input from a file, if parse() were a
+  // template function.
+
+  // Since String is reference-counted, this at least does not
+  // create an extra copy.
+  String doc(std::istreambuf_iterator<char>(is), {});
+  return parse(doc.data(), doc.data() + doc.size(), root, collectComments);
+}
+
+bool Reader::parse(const char* beginDoc, const char* endDoc, Value& root,
+                   bool collectComments) {
+  if (!features_.allowComments_) {
+    collectComments = false;
+  }
+
+  begin_ = beginDoc;
+  end_ = endDoc;
+  collectComments_ = collectComments;
+  current_ = begin_;
+  lastValueEnd_ = nullptr;
+  lastValue_ = nullptr;
+  commentsBefore_.clear();
+  errors_.clear();
+  while (!nodes_.empty())
+    nodes_.pop();
+  nodes_.push(&root);
+
+  bool successful = readValue();
+  Token token;
+  skipCommentTokens(token);
+  if (collectComments_ && !commentsBefore_.empty())
+    root.setComment(commentsBefore_, commentAfter);
+  if (features_.strictRoot_) {
+    if (!root.isArray() && !root.isObject()) {
+      // Set error location to start of doc, ideally should be first token found
+      // in doc
+      token.type_ = tokenError;
+      token.start_ = beginDoc;
+      token.end_ = endDoc;
+      addError(
+          "A valid JSON document must be either an array or an object value.",
+          token);
+      return false;
+    }
+  }
+  return successful;
+}
+
+bool Reader::readValue() {
+  // readValue() may call itself only if it calls readObject() or ReadArray().
+  // These methods execute nodes_.push() just before and nodes_.pop)() just
+  // after calling readValue(). parse() executes one nodes_.push(), so > instead
+  // of >=.
+  if (nodes_.size() > stackLimit_g)
+    throwRuntimeError("Exceeded stackLimit in readValue().");
+
+  Token token;
+  skipCommentTokens(token);
+  bool successful = true;
+
+  if (collectComments_ && !commentsBefore_.empty()) {
+    currentValue().setComment(commentsBefore_, commentBefore);
+    commentsBefore_.clear();
+  }
+
+  switch (token.type_) {
+  case tokenObjectBegin:
+    successful = readObject(token);
+    currentValue().setOffsetLimit(current_ - begin_);
+    break;
+  case tokenArrayBegin:
+    successful = readArray(token);
+    currentValue().setOffsetLimit(current_ - begin_);
+    break;
+  case tokenNumber:
+    successful = decodeNumber(token);
+    break;
+  case tokenString:
+    successful = decodeString(token);
+    break;
+  case tokenTrue: {
+    Value v(true);
+    currentValue().swapPayload(v);
+    currentValue().setOffsetStart(token.start_ - begin_);
+    currentValue().setOffsetLimit(token.end_ - begin_);
+  } break;
+  case tokenFalse: {
+    Value v(false);
+    currentValue().swapPayload(v);
+    currentValue().setOffsetStart(token.start_ - begin_);
+    currentValue().setOffsetLimit(token.end_ - begin_);
+  } break;
+  case tokenNull: {
+    Value v;
+    currentValue().swapPayload(v);
+    currentValue().setOffsetStart(token.start_ - begin_);
+    currentValue().setOffsetLimit(token.end_ - begin_);
+  } break;
+  case tokenArraySeparator:
+  case tokenObjectEnd:
+  case tokenArrayEnd:
+    if (features_.allowDroppedNullPlaceholders_) {
+      // "Un-read" the current token and mark the current value as a null
+      // token.
+      current_--;
+      Value v;
+      currentValue().swapPayload(v);
+      currentValue().setOffsetStart(current_ - begin_ - 1);
+      currentValue().setOffsetLimit(current_ - begin_);
+      break;
+    } // Else, fall through...
+  default:
+    currentValue().setOffsetStart(token.start_ - begin_);
+    currentValue().setOffsetLimit(token.end_ - begin_);
+    return addError("Syntax error: value, object or array expected.", token);
+  }
+
+  if (collectComments_) {
+    lastValueEnd_ = current_;
+    lastValue_ = &currentValue();
+  }
+
+  return successful;
+}
+
+void Reader::skipCommentTokens(Token& token) {
+  if (features_.allowComments_) {
+    do {
+      readToken(token);
+    } while (token.type_ == tokenComment);
+  } else {
+    readToken(token);
+  }
+}
+
+bool Reader::readToken(Token& token) {
+  skipSpaces();
+  token.start_ = current_;
+  Char c = getNextChar();
+  bool ok = true;
+  switch (c) {
+  case '{':
+    token.type_ = tokenObjectBegin;
+    break;
+  case '}':
+    token.type_ = tokenObjectEnd;
+    break;
+  case '[':
+    token.type_ = tokenArrayBegin;
+    break;
+  case ']':
+    token.type_ = tokenArrayEnd;
+    break;
+  case '"':
+    token.type_ = tokenString;
+    ok = readString();
+    break;
+  case '/':
+    token.type_ = tokenComment;
+    ok = readComment();
+    break;
+  case '0':
+  case '1':
+  case '2':
+  case '3':
+  case '4':
+  case '5':
+  case '6':
+  case '7':
+  case '8':
+  case '9':
+  case '-':
+    token.type_ = tokenNumber;
+    readNumber();
+    break;
+  case 't':
+    token.type_ = tokenTrue;
+    ok = match("rue", 3);
+    break;
+  case 'f':
+    token.type_ = tokenFalse;
+    ok = match("alse", 4);
+    break;
+  case 'n':
+    token.type_ = tokenNull;
+    ok = match("ull", 3);
+    break;
+  case ',':
+    token.type_ = tokenArraySeparator;
+    break;
+  case ':':
+    token.type_ = tokenMemberSeparator;
+    break;
+  case 0:
+    token.type_ = tokenEndOfStream;
+    break;
+  default:
+    ok = false;
+    break;
+  }
+  if (!ok)
+    token.type_ = tokenError;
+  token.end_ = current_;
+  return ok;
+}
+
+void Reader::skipSpaces() {
+  while (current_ != end_) {
+    Char c = *current_;
+    if (c == ' ' || c == '\t' || c == '\r' || c == '\n')
+      ++current_;
+    else
+      break;
+  }
+}
+
+bool Reader::match(const Char* pattern, int patternLength) {
+  if (end_ - current_ < patternLength)
+    return false;
+  int index = patternLength;
+  while (index--)
+    if (current_[index] != pattern[index])
+      return false;
+  current_ += patternLength;
+  return true;
+}
+
+bool Reader::readComment() {
+  Location commentBegin = current_ - 1;
+  Char c = getNextChar();
+  bool successful = false;
+  if (c == '*')
+    successful = readCStyleComment();
+  else if (c == '/')
+    successful = readCppStyleComment();
+  if (!successful)
+    return false;
+
+  if (collectComments_) {
+    CommentPlacement placement = commentBefore;
+    if (lastValueEnd_ && !containsNewLine(lastValueEnd_, commentBegin)) {
+      if (c != '*' || !containsNewLine(commentBegin, current_))
+        placement = commentAfterOnSameLine;
+    }
+
+    addComment(commentBegin, current_, placement);
+  }
+  return true;
+}
+
+String Reader::normalizeEOL(Reader::Location begin, Reader::Location end) {
+  String normalized;
+  normalized.reserve(static_cast<size_t>(end - begin));
+  Reader::Location current = begin;
+  while (current != end) {
+    char c = *current++;
+    if (c == '\r') {
+      if (current != end && *current == '\n')
+        // convert dos EOL
+        ++current;
+      // convert Mac EOL
+      normalized += '\n';
+    } else {
+      normalized += c;
+    }
+  }
+  return normalized;
+}
+
+void Reader::addComment(Location begin, Location end,
+                        CommentPlacement placement) {
+  assert(collectComments_);
+  const String& normalized = normalizeEOL(begin, end);
+  if (placement == commentAfterOnSameLine) {
+    assert(lastValue_ != nullptr);
+    lastValue_->setComment(normalized, placement);
+  } else {
+    commentsBefore_ += normalized;
+  }
+}
+
+bool Reader::readCStyleComment() {
+  while ((current_ + 1) < end_) {
+    Char c = getNextChar();
+    if (c == '*' && *current_ == '/')
+      break;
+  }
+  return getNextChar() == '/';
+}
+
+bool Reader::readCppStyleComment() {
+  while (current_ != end_) {
+    Char c = getNextChar();
+    if (c == '\n')
+      break;
+    if (c == '\r') {
+      // Consume DOS EOL. It will be normalized in addComment.
+      if (current_ != end_ && *current_ == '\n')
+        getNextChar();
+      // Break on Moc OS 9 EOL.
+      break;
+    }
+  }
+  return true;
+}
+
+void Reader::readNumber() {
+  Location p = current_;
+  char c = '0'; // stopgap for already consumed character
+  // integral part
+  while (c >= '0' && c <= '9')
+    c = (current_ = p) < end_ ? *p++ : '\0';
+  // fractional part
+  if (c == '.') {
+    c = (current_ = p) < end_ ? *p++ : '\0';
+    while (c >= '0' && c <= '9')
+      c = (current_ = p) < end_ ? *p++ : '\0';
+  }
+  // exponential part
+  if (c == 'e' || c == 'E') {
+    c = (current_ = p) < end_ ? *p++ : '\0';
+    if (c == '+' || c == '-')
+      c = (current_ = p) < end_ ? *p++ : '\0';
+    while (c >= '0' && c <= '9')
+      c = (current_ = p) < end_ ? *p++ : '\0';
+  }
+}
+
+bool Reader::readString() {
+  Char c = '\0';
+  while (current_ != end_) {
+    c = getNextChar();
+    if (c == '\\')
+      getNextChar();
+    else if (c == '"')
+      break;
+  }
+  return c == '"';
+}
+
+bool Reader::readObject(Token& token) {
+  Token tokenName;
+  String name;
+  Value init(objectValue);
+  currentValue().swapPayload(init);
+  currentValue().setOffsetStart(token.start_ - begin_);
+  while (readToken(tokenName)) {
+    bool initialTokenOk = true;
+    while (tokenName.type_ == tokenComment && initialTokenOk)
+      initialTokenOk = readToken(tokenName);
+    if (!initialTokenOk)
+      break;
+    if (tokenName.type_ == tokenObjectEnd && name.empty()) // empty object
+      return true;
+    name.clear();
+    if (tokenName.type_ == tokenString) {
+      if (!decodeString(tokenName, name))
+        return recoverFromError(tokenObjectEnd);
+    } else if (tokenName.type_ == tokenNumber && features_.allowNumericKeys_) {
+      Value numberName;
+      if (!decodeNumber(tokenName, numberName))
+        return recoverFromError(tokenObjectEnd);
+      name = numberName.asString();
+    } else {
+      break;
+    }
+
+    Token colon;
+    if (!readToken(colon) || colon.type_ != tokenMemberSeparator) {
+      return addErrorAndRecover("Missing ':' after object member name", colon,
+                                tokenObjectEnd);
+    }
+    Value& value = currentValue()[name];
+    nodes_.push(&value);
+    bool ok = readValue();
+    nodes_.pop();
+    if (!ok) // error already set
+      return recoverFromError(tokenObjectEnd);
+
+    Token comma;
+    if (!readToken(comma) ||
+        (comma.type_ != tokenObjectEnd && comma.type_ != tokenArraySeparator &&
+         comma.type_ != tokenComment)) {
+      return addErrorAndRecover("Missing ',' or '}' in object declaration",
+                                comma, tokenObjectEnd);
+    }
+    bool finalizeTokenOk = true;
+    while (comma.type_ == tokenComment && finalizeTokenOk)
+      finalizeTokenOk = readToken(comma);
+    if (comma.type_ == tokenObjectEnd)
+      return true;
+  }
+  return addErrorAndRecover("Missing '}' or object member name", tokenName,
+                            tokenObjectEnd);
+}
+
+bool Reader::readArray(Token& token) {
+  Value init(arrayValue);
+  currentValue().swapPayload(init);
+  currentValue().setOffsetStart(token.start_ - begin_);
+  skipSpaces();
+  if (current_ != end_ && *current_ == ']') // empty array
+  {
+    Token endArray;
+    readToken(endArray);
+    return true;
+  }
+  int index = 0;
+  for (;;) {
+    Value& value = currentValue()[index++];
+    nodes_.push(&value);
+    bool ok = readValue();
+    nodes_.pop();
+    if (!ok) // error already set
+      return recoverFromError(tokenArrayEnd);
+
+    Token currentToken;
+    // Accept Comment after last item in the array.
+    ok = readToken(currentToken);
+    while (currentToken.type_ == tokenComment && ok) {
+      ok = readToken(currentToken);
+    }
+    bool badTokenType = (currentToken.type_ != tokenArraySeparator &&
+                         currentToken.type_ != tokenArrayEnd);
+    if (!ok || badTokenType) {
+      return addErrorAndRecover("Missing ',' or ']' in array declaration",
+                                currentToken, tokenArrayEnd);
+    }
+    if (currentToken.type_ == tokenArrayEnd)
+      break;
+  }
+  return true;
+}
+
+bool Reader::decodeNumber(Token& token) {
+  Value decoded;
+  if (!decodeNumber(token, decoded))
+    return false;
+  currentValue().swapPayload(decoded);
+  currentValue().setOffsetStart(token.start_ - begin_);
+  currentValue().setOffsetLimit(token.end_ - begin_);
+  return true;
+}
+
+bool Reader::decodeNumber(Token& token, Value& decoded) {
+  // Attempts to parse the number as an integer. If the number is
+  // larger than the maximum supported value of an integer then
+  // we decode the number as a double.
+  Location current = token.start_;
+  bool isNegative = *current == '-';
+  if (isNegative)
+    ++current;
+  // TODO: Help the compiler do the div and mod at compile time or get rid of
+  // them.
+  Value::LargestUInt maxIntegerValue =
+      isNegative ? Value::LargestUInt(Value::maxLargestInt) + 1
+                 : Value::maxLargestUInt;
+  Value::LargestUInt threshold = maxIntegerValue / 10;
+  Value::LargestUInt value = 0;
+  while (current < token.end_) {
+    Char c = *current++;
+    if (c < '0' || c > '9')
+      return decodeDouble(token, decoded);
+    auto digit(static_cast<Value::UInt>(c - '0'));
+    if (value >= threshold) {
+      // We've hit or exceeded the max value divided by 10 (rounded down). If
+      // a) we've only just touched the limit, b) this is the last digit, and
+      // c) it's small enough to fit in that rounding delta, we're okay.
+      // Otherwise treat this number as a double to avoid overflow.
+      if (value > threshold || current != token.end_ ||
+          digit > maxIntegerValue % 10) {
+        return decodeDouble(token, decoded);
+      }
+    }
+    value = value * 10 + digit;
+  }
+  if (isNegative && value == maxIntegerValue)
+    decoded = Value::minLargestInt;
+  else if (isNegative)
+    decoded = -Value::LargestInt(value);
+  else if (value <= Value::LargestUInt(Value::maxInt))
+    decoded = Value::LargestInt(value);
+  else
+    decoded = value;
+  return true;
+}
+
+bool Reader::decodeDouble(Token& token) {
+  Value decoded;
+  if (!decodeDouble(token, decoded))
+    return false;
+  currentValue().swapPayload(decoded);
+  currentValue().setOffsetStart(token.start_ - begin_);
+  currentValue().setOffsetLimit(token.end_ - begin_);
+  return true;
+}
+
+bool Reader::decodeDouble(Token& token, Value& decoded) {
+  double value = 0;
+  String buffer(token.start_, token.end_);
+  IStringStream is(buffer);
+  if (!(is >> value))
+    return addError(
+        "'" + String(token.start_, token.end_) + "' is not a number.", token);
+  decoded = value;
+  return true;
+}
+
+bool Reader::decodeString(Token& token) {
+  String decoded_string;
+  if (!decodeString(token, decoded_string))
+    return false;
+  Value decoded(decoded_string);
+  currentValue().swapPayload(decoded);
+  currentValue().setOffsetStart(token.start_ - begin_);
+  currentValue().setOffsetLimit(token.end_ - begin_);
+  return true;
+}
+
+bool Reader::decodeString(Token& token, String& decoded) {
+  decoded.reserve(static_cast<size_t>(token.end_ - token.start_ - 2));
+  Location current = token.start_ + 1; // skip '"'
+  Location end = token.end_ - 1;       // do not include '"'
+  while (current != end) {
+    Char c = *current++;
+    if (c == '"')
+      break;
+    if (c == '\\') {
+      if (current == end)
+        return addError("Empty escape sequence in string", token, current);
+      Char escape = *current++;
+      switch (escape) {
+      case '"':
+        decoded += '"';
+        break;
+      case '/':
+        decoded += '/';
+        break;
+      case '\\':
+        decoded += '\\';
+        break;
+      case 'b':
+        decoded += '\b';
+        break;
+      case 'f':
+        decoded += '\f';
+        break;
+      case 'n':
+        decoded += '\n';
+        break;
+      case 'r':
+        decoded += '\r';
+        break;
+      case 't':
+        decoded += '\t';
+        break;
+      case 'u': {
+        unsigned int unicode;
+        if (!decodeUnicodeCodePoint(token, current, end, unicode))
+          return false;
+        decoded += codePointToUTF8(unicode);
+      } break;
+      default:
+        return addError("Bad escape sequence in string", token, current);
+      }
+    } else {
+      decoded += c;
+    }
+  }
+  return true;
+}
+
+bool Reader::decodeUnicodeCodePoint(Token& token, Location& current,
+                                    Location end, unsigned int& unicode) {
+
+  if (!decodeUnicodeEscapeSequence(token, current, end, unicode))
+    return false;
+  if (unicode >= 0xD800 && unicode <= 0xDBFF) {
+    // surrogate pairs
+    if (end - current < 6)
+      return addError(
+          "additional six characters expected to parse unicode surrogate pair.",
+          token, current);
+    if (*(current++) == '\\' && *(current++) == 'u') {
+      unsigned int surrogatePair;
+      if (decodeUnicodeEscapeSequence(token, current, end, surrogatePair)) {
+        unicode = 0x10000 + ((unicode & 0x3FF) << 10) + (surrogatePair & 0x3FF);
+      } else
+        return false;
+    } else
+      return addError("expecting another \\u token to begin the second half of "
+                      "a unicode surrogate pair",
+                      token, current);
+  }
+  return true;
+}
+
+bool Reader::decodeUnicodeEscapeSequence(Token& token, Location& current,
+                                         Location end,
+                                         unsigned int& ret_unicode) {
+  if (end - current < 4)
+    return addError(
+        "Bad unicode escape sequence in string: four digits expected.", token,
+        current);
+  int unicode = 0;
+  for (int index = 0; index < 4; ++index) {
+    Char c = *current++;
+    unicode *= 16;
+    if (c >= '0' && c <= '9')
+      unicode += c - '0';
+    else if (c >= 'a' && c <= 'f')
+      unicode += c - 'a' + 10;
+    else if (c >= 'A' && c <= 'F')
+      unicode += c - 'A' + 10;
+    else
+      return addError(
+          "Bad unicode escape sequence in string: hexadecimal digit expected.",
+          token, current);
+  }
+  ret_unicode = static_cast<unsigned int>(unicode);
+  return true;
+}
+
+bool Reader::addError(const String& message, Token& token, Location extra) {
+  ErrorInfo info;
+  info.token_ = token;
+  info.message_ = message;
+  info.extra_ = extra;
+  errors_.push_back(info);
+  return false;
+}
+
+bool Reader::recoverFromError(TokenType skipUntilToken) {
+  size_t const errorCount = errors_.size();
+  Token skip;
+  for (;;) {
+    if (!readToken(skip))
+      errors_.resize(errorCount); // discard errors caused by recovery
+    if (skip.type_ == skipUntilToken || skip.type_ == tokenEndOfStream)
+      break;
+  }
+  errors_.resize(errorCount);
+  return false;
+}
+
+bool Reader::addErrorAndRecover(const String& message, Token& token,
+                                TokenType skipUntilToken) {
+  addError(message, token);
+  return recoverFromError(skipUntilToken);
+}
+
+Value& Reader::currentValue() { return *(nodes_.top()); }
+
+Reader::Char Reader::getNextChar() {
+  if (current_ == end_)
+    return 0;
+  return *current_++;
+}
+
+void Reader::getLocationLineAndColumn(Location location, int& line,
+                                      int& column) const {
+  Location current = begin_;
+  Location lastLineStart = current;
+  line = 0;
+  while (current < location && current != end_) {
+    Char c = *current++;
+    if (c == '\r') {
+      if (*current == '\n')
+        ++current;
+      lastLineStart = current;
+      ++line;
+    } else if (c == '\n') {
+      lastLineStart = current;
+      ++line;
+    }
+  }
+  // column & line start at 1
+  column = int(location - lastLineStart) + 1;
+  ++line;
+}
+
+String Reader::getLocationLineAndColumn(Location location) const {
+  int line, column;
+  getLocationLineAndColumn(location, line, column);
+  char buffer[18 + 16 + 16 + 1];
+  jsoncpp_snprintf(buffer, sizeof(buffer), "Line %d, Column %d", line, column);
+  return buffer;
+}
+
+// Deprecated. Preserved for backward compatibility
+String Reader::getFormatedErrorMessages() const {
+  return getFormattedErrorMessages();
+}
+
+String Reader::getFormattedErrorMessages() const {
+  String formattedMessage;
+  for (const auto& error : errors_) {
+    formattedMessage +=
+        "* " + getLocationLineAndColumn(error.token_.start_) + "\n";
+    formattedMessage += "  " + error.message_ + "\n";
+    if (error.extra_)
+      formattedMessage +=
+          "See " + getLocationLineAndColumn(error.extra_) + " for detail.\n";
+  }
+  return formattedMessage;
+}
+
+std::vector<Reader::StructuredError> Reader::getStructuredErrors() const {
+  std::vector<Reader::StructuredError> allErrors;
+  for (const auto& error : errors_) {
+    Reader::StructuredError structured;
+    structured.offset_start = error.token_.start_ - begin_;
+    structured.offset_limit = error.token_.end_ - begin_;
+    structured.message = error.message_;
+    allErrors.push_back(structured);
+  }
+  return allErrors;
+}
+
+bool Reader::pushError(const Value& value, const String& message) {
+  ptrdiff_t const length = end_ - begin_;
+  if (value.getOffsetStart() > length || value.getOffsetLimit() > length)
+    return false;
+  Token token;
+  token.type_ = tokenError;
+  token.start_ = begin_ + value.getOffsetStart();
+  token.end_ = begin_ + value.getOffsetLimit();
+  ErrorInfo info;
+  info.token_ = token;
+  info.message_ = message;
+  info.extra_ = nullptr;
+  errors_.push_back(info);
+  return true;
+}
+
+bool Reader::pushError(const Value& value, const String& message,
+                       const Value& extra) {
+  ptrdiff_t const length = end_ - begin_;
+  if (value.getOffsetStart() > length || value.getOffsetLimit() > length ||
+      extra.getOffsetLimit() > length)
+    return false;
+  Token token;
+  token.type_ = tokenError;
+  token.start_ = begin_ + value.getOffsetStart();
+  token.end_ = begin_ + value.getOffsetLimit();
+  ErrorInfo info;
+  info.token_ = token;
+  info.message_ = message;
+  info.extra_ = begin_ + extra.getOffsetStart();
+  errors_.push_back(info);
+  return true;
+}
+
+bool Reader::good() const { return errors_.empty(); }
+
+// Originally copied from the Features class (now deprecated), used internally
+// for features implementation.
+class OurFeatures {
+public:
+  static OurFeatures all();
+  bool allowComments_;
+  bool allowTrailingCommas_;
+  bool strictRoot_;
+  bool allowDroppedNullPlaceholders_;
+  bool allowNumericKeys_;
+  bool allowSingleQuotes_;
+  bool failIfExtra_;
+  bool rejectDupKeys_;
+  bool allowSpecialFloats_;
+  bool skipBom_;
+  size_t stackLimit_;
+}; // OurFeatures
+
+OurFeatures OurFeatures::all() { return {}; }
+
+// Implementation of class Reader
+// ////////////////////////////////
+
+// Originally copied from the Reader class (now deprecated), used internally
+// for implementing JSON reading.
+class OurReader {
+public:
+  using Char = char;
+  using Location = const Char*;
+  struct StructuredError {
+    ptrdiff_t offset_start;
+    ptrdiff_t offset_limit;
+    String message;
+  };
+
+  explicit OurReader(OurFeatures const& features);
+  bool parse(const char* beginDoc, const char* endDoc, Value& root,
+             bool collectComments = true);
+  String getFormattedErrorMessages() const;
+  std::vector<StructuredError> getStructuredErrors() const;
+
+private:
+  OurReader(OurReader const&);      // no impl
+  void operator=(OurReader const&); // no impl
+
+  enum TokenType {
+    tokenEndOfStream = 0,
+    tokenObjectBegin,
+    tokenObjectEnd,
+    tokenArrayBegin,
+    tokenArrayEnd,
+    tokenString,
+    tokenNumber,
+    tokenTrue,
+    tokenFalse,
+    tokenNull,
+    tokenNaN,
+    tokenPosInf,
+    tokenNegInf,
+    tokenArraySeparator,
+    tokenMemberSeparator,
+    tokenComment,
+    tokenError
+  };
+
+  class Token {
+  public:
+    TokenType type_;
+    Location start_;
+    Location end_;
+  };
+
+  class ErrorInfo {
+  public:
+    Token token_;
+    String message_;
+    Location extra_;
+  };
+
+  using Errors = std::deque<ErrorInfo>;
+
+  bool readToken(Token& token);
+  void skipSpaces();
+  void skipBom(bool skipBom);
+  bool match(const Char* pattern, int patternLength);
+  bool readComment();
+  bool readCStyleComment(bool* containsNewLineResult);
+  bool readCppStyleComment();
+  bool readString();
+  bool readStringSingleQuote();
+  bool readNumber(bool checkInf);
+  bool readValue();
+  bool readObject(Token& token);
+  bool readArray(Token& token);
+  bool decodeNumber(Token& token);
+  bool decodeNumber(Token& token, Value& decoded);
+  bool decodeString(Token& token);
+  bool decodeString(Token& token, String& decoded);
+  bool decodeDouble(Token& token);
+  bool decodeDouble(Token& token, Value& decoded);
+  bool decodeUnicodeCodePoint(Token& token, Location& current, Location end,
+                              unsigned int& unicode);
+  bool decodeUnicodeEscapeSequence(Token& token, Location& current,
+                                   Location end, unsigned int& unicode);
+  bool addError(const String& message, Token& token, Location extra = nullptr);
+  bool recoverFromError(TokenType skipUntilToken);
+  bool addErrorAndRecover(const String& message, Token& token,
+                          TokenType skipUntilToken);
+  void skipUntilSpace();
+  Value& currentValue();
+  Char getNextChar();
+  void getLocationLineAndColumn(Location location, int& line,
+                                int& column) const;
+  String getLocationLineAndColumn(Location location) const;
+  void addComment(Location begin, Location end, CommentPlacement placement);
+  void skipCommentTokens(Token& token);
+
+  static String normalizeEOL(Location begin, Location end);
+  static bool containsNewLine(Location begin, Location end);
+
+  using Nodes = std::stack<Value*>;
+
+  Nodes nodes_{};
+  Errors errors_{};
+  String document_{};
+  Location begin_ = nullptr;
+  Location end_ = nullptr;
+  Location current_ = nullptr;
+  Location lastValueEnd_ = nullptr;
+  Value* lastValue_ = nullptr;
+  bool lastValueHasAComment_ = false;
+  String commentsBefore_{};
+
+  OurFeatures const features_;
+  bool collectComments_ = false;
+}; // OurReader
+
+// complete copy of Read impl, for OurReader
+
+bool OurReader::containsNewLine(OurReader::Location begin,
+                                OurReader::Location end) {
+  return std::any_of(begin, end, [](char b) { return b == '\n' || b == '\r'; });
+}
+
+OurReader::OurReader(OurFeatures const& features) : features_(features) {}
+
+bool OurReader::parse(const char* beginDoc, const char* endDoc, Value& root,
+                      bool collectComments) {
+  if (!features_.allowComments_) {
+    collectComments = false;
+  }
+
+  begin_ = beginDoc;
+  end_ = endDoc;
+  collectComments_ = collectComments;
+  current_ = begin_;
+  lastValueEnd_ = nullptr;
+  lastValue_ = nullptr;
+  commentsBefore_.clear();
+  errors_.clear();
+  while (!nodes_.empty())
+    nodes_.pop();
+  nodes_.push(&root);
+
+  // skip byte order mark if it exists at the beginning of the UTF-8 text.
+  skipBom(features_.skipBom_);
+  bool successful = readValue();
+  nodes_.pop();
+  Token token;
+  skipCommentTokens(token);
+  if (features_.failIfExtra_ && (token.type_ != tokenEndOfStream)) {
+    addError("Extra non-whitespace after JSON value.", token);
+    return false;
+  }
+  if (collectComments_ && !commentsBefore_.empty())
+    root.setComment(commentsBefore_, commentAfter);
+  if (features_.strictRoot_) {
+    if (!root.isArray() && !root.isObject()) {
+      // Set error location to start of doc, ideally should be first token found
+      // in doc
+      token.type_ = tokenError;
+      token.start_ = beginDoc;
+      token.end_ = endDoc;
+      addError(
+          "A valid JSON document must be either an array or an object value.",
+          token);
+      return false;
+    }
+  }
+  return successful;
+}
+
+bool OurReader::readValue() {
+  //  To preserve the old behaviour we cast size_t to int.
+  if (nodes_.size() > features_.stackLimit_)
+    throwRuntimeError("Exceeded stackLimit in readValue().");
+  Token token;
+  skipCommentTokens(token);
+  bool successful = true;
+
+  if (collectComments_ && !commentsBefore_.empty()) {
+    currentValue().setComment(commentsBefore_, commentBefore);
+    commentsBefore_.clear();
+  }
+
+  switch (token.type_) {
+  case tokenObjectBegin:
+    successful = readObject(token);
+    currentValue().setOffsetLimit(current_ - begin_);
+    break;
+  case tokenArrayBegin:
+    successful = readArray(token);
+    currentValue().setOffsetLimit(current_ - begin_);
+    break;
+  case tokenNumber:
+    successful = decodeNumber(token);
+    break;
+  case tokenString:
+    successful = decodeString(token);
+    break;
+  case tokenTrue: {
+    Value v(true);
+    currentValue().swapPayload(v);
+    currentValue().setOffsetStart(token.start_ - begin_);
+    currentValue().setOffsetLimit(token.end_ - begin_);
+  } break;
+  case tokenFalse: {
+    Value v(false);
+    currentValue().swapPayload(v);
+    currentValue().setOffsetStart(token.start_ - begin_);
+    currentValue().setOffsetLimit(token.end_ - begin_);
+  } break;
+  case tokenNull: {
+    Value v;
+    currentValue().swapPayload(v);
+    currentValue().setOffsetStart(token.start_ - begin_);
+    currentValue().setOffsetLimit(token.end_ - begin_);
+  } break;
+  case tokenNaN: {
+    Value v(std::numeric_limits<double>::quiet_NaN());
+    currentValue().swapPayload(v);
+    currentValue().setOffsetStart(token.start_ - begin_);
+    currentValue().setOffsetLimit(token.end_ - begin_);
+  } break;
+  case tokenPosInf: {
+    Value v(std::numeric_limits<double>::infinity());
+    currentValue().swapPayload(v);
+    currentValue().setOffsetStart(token.start_ - begin_);
+    currentValue().setOffsetLimit(token.end_ - begin_);
+  } break;
+  case tokenNegInf: {
+    Value v(-std::numeric_limits<double>::infinity());
+    currentValue().swapPayload(v);
+    currentValue().setOffsetStart(token.start_ - begin_);
+    currentValue().setOffsetLimit(token.end_ - begin_);
+  } break;
+  case tokenArraySeparator:
+  case tokenObjectEnd:
+  case tokenArrayEnd:
+    if (features_.allowDroppedNullPlaceholders_) {
+      // "Un-read" the current token and mark the current value as a null
+      // token.
+      current_--;
+      Value v;
+      currentValue().swapPayload(v);
+      currentValue().setOffsetStart(current_ - begin_ - 1);
+      currentValue().setOffsetLimit(current_ - begin_);
+      break;
+    } // else, fall through ...
+  default:
+    currentValue().setOffsetStart(token.start_ - begin_);
+    currentValue().setOffsetLimit(token.end_ - begin_);
+    return addError("Syntax error: value, object or array expected.", token);
+  }
+
+  if (collectComments_) {
+    lastValueEnd_ = current_;
+    lastValueHasAComment_ = false;
+    lastValue_ = &currentValue();
+  }
+
+  return successful;
+}
+
+void OurReader::skipCommentTokens(Token& token) {
+  if (features_.allowComments_) {
+    do {
+      readToken(token);
+    } while (token.type_ == tokenComment);
+  } else {
+    readToken(token);
+  }
+}
+
+bool OurReader::readToken(Token& token) {
+  skipSpaces();
+  token.start_ = current_;
+  Char c = getNextChar();
+  bool ok = true;
+  switch (c) {
+  case '{':
+    token.type_ = tokenObjectBegin;
+    break;
+  case '}':
+    token.type_ = tokenObjectEnd;
+    break;
+  case '[':
+    token.type_ = tokenArrayBegin;
+    break;
+  case ']':
+    token.type_ = tokenArrayEnd;
+    break;
+  case '"':
+    token.type_ = tokenString;
+    ok = readString();
+    break;
+  case '\'':
+    if (features_.allowSingleQuotes_) {
+      token.type_ = tokenString;
+      ok = readStringSingleQuote();
+    } else {
+      // If we don't allow single quotes, this is a failure case.
+      ok = false;
+    }
+    break;
+  case '/':
+    token.type_ = tokenComment;
+    ok = readComment();
+    break;
+  case '0':
+  case '1':
+  case '2':
+  case '3':
+  case '4':
+  case '5':
+  case '6':
+  case '7':
+  case '8':
+  case '9':
+    token.type_ = tokenNumber;
+    readNumber(false);
+    break;
+  case '-':
+    if (readNumber(true)) {
+      token.type_ = tokenNumber;
+    } else {
+      token.type_ = tokenNegInf;
+      ok = features_.allowSpecialFloats_ && match("nfinity", 7);
+    }
+    break;
+  case '+':
+    if (readNumber(true)) {
+      token.type_ = tokenNumber;
+    } else {
+      token.type_ = tokenPosInf;
+      ok = features_.allowSpecialFloats_ && match("nfinity", 7);
+    }
+    break;
+  case 't':
+    token.type_ = tokenTrue;
+    ok = match("rue", 3);
+    break;
+  case 'f':
+    token.type_ = tokenFalse;
+    ok = match("alse", 4);
+    break;
+  case 'n':
+    token.type_ = tokenNull;
+    ok = match("ull", 3);
+    break;
+  case 'N':
+    if (features_.allowSpecialFloats_) {
+      token.type_ = tokenNaN;
+      ok = match("aN", 2);
+    } else {
+      ok = false;
+    }
+    break;
+  case 'I':
+    if (features_.allowSpecialFloats_) {
+      token.type_ = tokenPosInf;
+      ok = match("nfinity", 7);
+    } else {
+      ok = false;
+    }
+    break;
+  case ',':
+    token.type_ = tokenArraySeparator;
+    break;
+  case ':':
+    token.type_ = tokenMemberSeparator;
+    break;
+  case 0:
+    token.type_ = tokenEndOfStream;
+    break;
+  default:
+    ok = false;
+    break;
+  }
+  if (!ok)
+    token.type_ = tokenError;
+  token.end_ = current_;
+  return ok;
+}
+
+void OurReader::skipSpaces() {
+  while (current_ != end_) {
+    Char c = *current_;
+    if (c == ' ' || c == '\t' || c == '\r' || c == '\n')
+      ++current_;
+    else
+      break;
+  }
+}
+
+void OurReader::skipBom(bool skipBom) {
+  // The default behavior is to skip BOM.
+  if (skipBom) {
+    if ((end_ - begin_) >= 3 && strncmp(begin_, "\xEF\xBB\xBF", 3) == 0) {
+      begin_ += 3;
+      current_ = begin_;
+    }
+  }
+}
+
+bool OurReader::match(const Char* pattern, int patternLength) {
+  if (end_ - current_ < patternLength)
+    return false;
+  int index = patternLength;
+  while (index--)
+    if (current_[index] != pattern[index])
+      return false;
+  current_ += patternLength;
+  return true;
+}
+
+bool OurReader::readComment() {
+  const Location commentBegin = current_ - 1;
+  const Char c = getNextChar();
+  bool successful = false;
+  bool cStyleWithEmbeddedNewline = false;
+
+  const bool isCStyleComment = (c == '*');
+  const bool isCppStyleComment = (c == '/');
+  if (isCStyleComment) {
+    successful = readCStyleComment(&cStyleWithEmbeddedNewline);
+  } else if (isCppStyleComment) {
+    successful = readCppStyleComment();
+  }
+
+  if (!successful)
+    return false;
+
+  if (collectComments_) {
+    CommentPlacement placement = commentBefore;
+
+    if (!lastValueHasAComment_) {
+      if (lastValueEnd_ && !containsNewLine(lastValueEnd_, commentBegin)) {
+        if (isCppStyleComment || !cStyleWithEmbeddedNewline) {
+          placement = commentAfterOnSameLine;
+          lastValueHasAComment_ = true;
+        }
+      }
+    }
+
+    addComment(commentBegin, current_, placement);
+  }
+  return true;
+}
+
+String OurReader::normalizeEOL(OurReader::Location begin,
+                               OurReader::Location end) {
+  String normalized;
+  normalized.reserve(static_cast<size_t>(end - begin));
+  OurReader::Location current = begin;
+  while (current != end) {
+    char c = *current++;
+    if (c == '\r') {
+      if (current != end && *current == '\n')
+        // convert dos EOL
+        ++current;
+      // convert Mac EOL
+      normalized += '\n';
+    } else {
+      normalized += c;
+    }
+  }
+  return normalized;
+}
+
+void OurReader::addComment(Location begin, Location end,
+                           CommentPlacement placement) {
+  assert(collectComments_);
+  const String& normalized = normalizeEOL(begin, end);
+  if (placement == commentAfterOnSameLine) {
+    assert(lastValue_ != nullptr);
+    lastValue_->setComment(normalized, placement);
+  } else {
+    commentsBefore_ += normalized;
+  }
+}
+
+bool OurReader::readCStyleComment(bool* containsNewLineResult) {
+  *containsNewLineResult = false;
+
+  while ((current_ + 1) < end_) {
+    Char c = getNextChar();
+    if (c == '*' && *current_ == '/')
+      break;
+    if (c == '\n')
+      *containsNewLineResult = true;
+  }
+
+  return getNextChar() == '/';
+}
+
+bool OurReader::readCppStyleComment() {
+  while (current_ != end_) {
+    Char c = getNextChar();
+    if (c == '\n')
+      break;
+    if (c == '\r') {
+      // Consume DOS EOL. It will be normalized in addComment.
+      if (current_ != end_ && *current_ == '\n')
+        getNextChar();
+      // Break on Moc OS 9 EOL.
+      break;
+    }
+  }
+  return true;
+}
+
+bool OurReader::readNumber(bool checkInf) {
+  Location p = current_;
+  if (checkInf && p != end_ && *p == 'I') {
+    current_ = ++p;
+    return false;
+  }
+  char c = '0'; // stopgap for already consumed character
+  // integral part
+  while (c >= '0' && c <= '9')
+    c = (current_ = p) < end_ ? *p++ : '\0';
+  // fractional part
+  if (c == '.') {
+    c = (current_ = p) < end_ ? *p++ : '\0';
+    while (c >= '0' && c <= '9')
+      c = (current_ = p) < end_ ? *p++ : '\0';
+  }
+  // exponential part
+  if (c == 'e' || c == 'E') {
+    c = (current_ = p) < end_ ? *p++ : '\0';
+    if (c == '+' || c == '-')
+      c = (current_ = p) < end_ ? *p++ : '\0';
+    while (c >= '0' && c <= '9')
+      c = (current_ = p) < end_ ? *p++ : '\0';
+  }
+  return true;
+}
+bool OurReader::readString() {
+  Char c = 0;
+  while (current_ != end_) {
+    c = getNextChar();
+    if (c == '\\')
+      getNextChar();
+    else if (c == '"')
+      break;
+  }
+  return c == '"';
+}
+
+bool OurReader::readStringSingleQuote() {
+  Char c = 0;
+  while (current_ != end_) {
+    c = getNextChar();
+    if (c == '\\')
+      getNextChar();
+    else if (c == '\'')
+      break;
+  }
+  return c == '\'';
+}
+
+bool OurReader::readObject(Token& token) {
+  Token tokenName;
+  String name;
+  Value init(objectValue);
+  currentValue().swapPayload(init);
+  currentValue().setOffsetStart(token.start_ - begin_);
+  while (readToken(tokenName)) {
+    bool initialTokenOk = true;
+    while (tokenName.type_ == tokenComment && initialTokenOk)
+      initialTokenOk = readToken(tokenName);
+    if (!initialTokenOk)
+      break;
+    if (tokenName.type_ == tokenObjectEnd &&
+        (name.empty() ||
+         features_.allowTrailingCommas_)) // empty object or trailing comma
+      return true;
+    name.clear();
+    if (tokenName.type_ == tokenString) {
+      if (!decodeString(tokenName, name))
+        return recoverFromError(tokenObjectEnd);
+    } else if (tokenName.type_ == tokenNumber && features_.allowNumericKeys_) {
+      Value numberName;
+      if (!decodeNumber(tokenName, numberName))
+        return recoverFromError(tokenObjectEnd);
+      name = numberName.asString();
+    } else {
+      break;
+    }
+    if (name.length() >= (1U << 30))
+      throwRuntimeError("keylength >= 2^30");
+    if (features_.rejectDupKeys_ && currentValue().isMember(name)) {
+      String msg = "Duplicate key: '" + name + "'";
+      return addErrorAndRecover(msg, tokenName, tokenObjectEnd);
+    }
+
+    Token colon;
+    if (!readToken(colon) || colon.type_ != tokenMemberSeparator) {
+      return addErrorAndRecover("Missing ':' after object member name", colon,
+                                tokenObjectEnd);
+    }
+    Value& value = currentValue()[name];
+    nodes_.push(&value);
+    bool ok = readValue();
+    nodes_.pop();
+    if (!ok) // error already set
+      return recoverFromError(tokenObjectEnd);
+
+    Token comma;
+    if (!readToken(comma) ||
+        (comma.type_ != tokenObjectEnd && comma.type_ != tokenArraySeparator &&
+         comma.type_ != tokenComment)) {
+      return addErrorAndRecover("Missing ',' or '}' in object declaration",
+                                comma, tokenObjectEnd);
+    }
+    bool finalizeTokenOk = true;
+    while (comma.type_ == tokenComment && finalizeTokenOk)
+      finalizeTokenOk = readToken(comma);
+    if (comma.type_ == tokenObjectEnd)
+      return true;
+  }
+  return addErrorAndRecover("Missing '}' or object member name", tokenName,
+                            tokenObjectEnd);
+}
+
+bool OurReader::readArray(Token& token) {
+  Value init(arrayValue);
+  currentValue().swapPayload(init);
+  currentValue().setOffsetStart(token.start_ - begin_);
+  int index = 0;
+  for (;;) {
+    skipSpaces();
+    if (current_ != end_ && *current_ == ']' &&
+        (index == 0 ||
+         (features_.allowTrailingCommas_ &&
+          !features_.allowDroppedNullPlaceholders_))) // empty array or trailing
+                                                      // comma
+    {
+      Token endArray;
+      readToken(endArray);
+      return true;
+    }
+    Value& value = currentValue()[index++];
+    nodes_.push(&value);
+    bool ok = readValue();
+    nodes_.pop();
+    if (!ok) // error already set
+      return recoverFromError(tokenArrayEnd);
+
+    Token currentToken;
+    // Accept Comment after last item in the array.
+    ok = readToken(currentToken);
+    while (currentToken.type_ == tokenComment && ok) {
+      ok = readToken(currentToken);
+    }
+    bool badTokenType = (currentToken.type_ != tokenArraySeparator &&
+                         currentToken.type_ != tokenArrayEnd);
+    if (!ok || badTokenType) {
+      return addErrorAndRecover("Missing ',' or ']' in array declaration",
+                                currentToken, tokenArrayEnd);
+    }
+    if (currentToken.type_ == tokenArrayEnd)
+      break;
+  }
+  return true;
+}
+
+bool OurReader::decodeNumber(Token& token) {
+  Value decoded;
+  if (!decodeNumber(token, decoded))
+    return false;
+  currentValue().swapPayload(decoded);
+  currentValue().setOffsetStart(token.start_ - begin_);
+  currentValue().setOffsetLimit(token.end_ - begin_);
+  return true;
+}
+
+bool OurReader::decodeNumber(Token& token, Value& decoded) {
+  // Attempts to parse the number as an integer. If the number is
+  // larger than the maximum supported value of an integer then
+  // we decode the number as a double.
+  Location current = token.start_;
+  const bool isNegative = *current == '-';
+  if (isNegative) {
+    ++current;
+  }
+
+  // We assume we can represent the largest and smallest integer types as
+  // unsigned integers with separate sign. This is only true if they can fit
+  // into an unsigned integer.
+  static_assert(Value::maxLargestInt <= Value::maxLargestUInt,
+                "Int must be smaller than UInt");
+
+  // We need to convert minLargestInt into a positive number. The easiest way
+  // to do this conversion is to assume our "threshold" value of minLargestInt
+  // divided by 10 can fit in maxLargestInt when absolute valued. This should
+  // be a safe assumption.
+  static_assert(Value::minLargestInt <= -Value::maxLargestInt,
+                "The absolute value of minLargestInt must be greater than or "
+                "equal to maxLargestInt");
+  static_assert(Value::minLargestInt / 10 >= -Value::maxLargestInt,
+                "The absolute value of minLargestInt must be only 1 magnitude "
+                "larger than maxLargest Int");
+
+  static constexpr Value::LargestUInt positive_threshold =
+      Value::maxLargestUInt / 10;
+  static constexpr Value::UInt positive_last_digit = Value::maxLargestUInt % 10;
+
+  // For the negative values, we have to be more careful. Since typically
+  // -Value::minLargestInt will cause an overflow, we first divide by 10 and
+  // then take the inverse. This assumes that minLargestInt is only a single
+  // power of 10 different in magnitude, which we check above. For the last
+  // digit, we take the modulus before negating for the same reason.
+  static constexpr auto negative_threshold =
+      Value::LargestUInt(-(Value::minLargestInt / 10));
+  static constexpr auto negative_last_digit =
+      Value::UInt(-(Value::minLargestInt % 10));
+
+  const Value::LargestUInt threshold =
+      isNegative ? negative_threshold : positive_threshold;
+  const Value::UInt max_last_digit =
+      isNegative ? negative_last_digit : positive_last_digit;
+
+  Value::LargestUInt value = 0;
+  while (current < token.end_) {
+    Char c = *current++;
+    if (c < '0' || c > '9')
+      return decodeDouble(token, decoded);
+
+    const auto digit(static_cast<Value::UInt>(c - '0'));
+    if (value >= threshold) {
+      // We've hit or exceeded the max value divided by 10 (rounded down). If
+      // a) we've only just touched the limit, meaing value == threshold,
+      // b) this is the last digit, or
+      // c) it's small enough to fit in that rounding delta, we're okay.
+      // Otherwise treat this number as a double to avoid overflow.
+      if (value > threshold || current != token.end_ ||
+          digit > max_last_digit) {
+        return decodeDouble(token, decoded);
+      }
+    }
+    value = value * 10 + digit;
+  }
+
+  if (isNegative) {
+    // We use the same magnitude assumption here, just in case.
+    const auto last_digit = static_cast<Value::UInt>(value % 10);
+    decoded = -Value::LargestInt(value / 10) * 10 - last_digit;
+  } else if (value <= Value::LargestUInt(Value::maxLargestInt)) {
+    decoded = Value::LargestInt(value);
+  } else {
+    decoded = value;
+  }
+
+  return true;
+}
+
+bool OurReader::decodeDouble(Token& token) {
+  Value decoded;
+  if (!decodeDouble(token, decoded))
+    return false;
+  currentValue().swapPayload(decoded);
+  currentValue().setOffsetStart(token.start_ - begin_);
+  currentValue().setOffsetLimit(token.end_ - begin_);
+  return true;
+}
+
+bool OurReader::decodeDouble(Token& token, Value& decoded) {
+  double value = 0;
+  const String buffer(token.start_, token.end_);
+  IStringStream is(buffer);
+  if (!(is >> value)) {
+    return addError(
+        "'" + String(token.start_, token.end_) + "' is not a number.", token);
+  }
+  decoded = value;
+  return true;
+}
+
+bool OurReader::decodeString(Token& token) {
+  String decoded_string;
+  if (!decodeString(token, decoded_string))
+    return false;
+  Value decoded(decoded_string);
+  currentValue().swapPayload(decoded);
+  currentValue().setOffsetStart(token.start_ - begin_);
+  currentValue().setOffsetLimit(token.end_ - begin_);
+  return true;
+}
+
+bool OurReader::decodeString(Token& token, String& decoded) {
+  decoded.reserve(static_cast<size_t>(token.end_ - token.start_ - 2));
+  Location current = token.start_ + 1; // skip '"'
+  Location end = token.end_ - 1;       // do not include '"'
+  while (current != end) {
+    Char c = *current++;
+    if (c == '"')
+      break;
+    if (c == '\\') {
+      if (current == end)
+        return addError("Empty escape sequence in string", token, current);
+      Char escape = *current++;
+      switch (escape) {
+      case '"':
+        decoded += '"';
+        break;
+      case '/':
+        decoded += '/';
+        break;
+      case '\\':
+        decoded += '\\';
+        break;
+      case 'b':
+        decoded += '\b';
+        break;
+      case 'f':
+        decoded += '\f';
+        break;
+      case 'n':
+        decoded += '\n';
+        break;
+      case 'r':
+        decoded += '\r';
+        break;
+      case 't':
+        decoded += '\t';
+        break;
+      case 'u': {
+        unsigned int unicode;
+        if (!decodeUnicodeCodePoint(token, current, end, unicode))
+          return false;
+        decoded += codePointToUTF8(unicode);
+      } break;
+      default:
+        return addError("Bad escape sequence in string", token, current);
+      }
+    } else {
+      decoded += c;
+    }
+  }
+  return true;
+}
+
+bool OurReader::decodeUnicodeCodePoint(Token& token, Location& current,
+                                       Location end, unsigned int& unicode) {
+
+  if (!decodeUnicodeEscapeSequence(token, current, end, unicode))
+    return false;
+  if (unicode >= 0xD800 && unicode <= 0xDBFF) {
+    // surrogate pairs
+    if (end - current < 6)
+      return addError(
+          "additional six characters expected to parse unicode surrogate pair.",
+          token, current);
+    if (*(current++) == '\\' && *(current++) == 'u') {
+      unsigned int surrogatePair;
+      if (decodeUnicodeEscapeSequence(token, current, end, surrogatePair)) {
+        unicode = 0x10000 + ((unicode & 0x3FF) << 10) + (surrogatePair & 0x3FF);
+      } else
+        return false;
+    } else
+      return addError("expecting another \\u token to begin the second half of "
+                      "a unicode surrogate pair",
+                      token, current);
+  }
+  return true;
+}
+
+bool OurReader::decodeUnicodeEscapeSequence(Token& token, Location& current,
+                                            Location end,
+                                            unsigned int& ret_unicode) {
+  if (end - current < 4)
+    return addError(
+        "Bad unicode escape sequence in string: four digits expected.", token,
+        current);
+  int unicode = 0;
+  for (int index = 0; index < 4; ++index) {
+    Char c = *current++;
+    unicode *= 16;
+    if (c >= '0' && c <= '9')
+      unicode += c - '0';
+    else if (c >= 'a' && c <= 'f')
+      unicode += c - 'a' + 10;
+    else if (c >= 'A' && c <= 'F')
+      unicode += c - 'A' + 10;
+    else
+      return addError(
+          "Bad unicode escape sequence in string: hexadecimal digit expected.",
+          token, current);
+  }
+  ret_unicode = static_cast<unsigned int>(unicode);
+  return true;
+}
+
+bool OurReader::addError(const String& message, Token& token, Location extra) {
+  ErrorInfo info;
+  info.token_ = token;
+  info.message_ = message;
+  info.extra_ = extra;
+  errors_.push_back(info);
+  return false;
+}
+
+bool OurReader::recoverFromError(TokenType skipUntilToken) {
+  size_t errorCount = errors_.size();
+  Token skip;
+  for (;;) {
+    if (!readToken(skip))
+      errors_.resize(errorCount); // discard errors caused by recovery
+    if (skip.type_ == skipUntilToken || skip.type_ == tokenEndOfStream)
+      break;
+  }
+  errors_.resize(errorCount);
+  return false;
+}
+
+bool OurReader::addErrorAndRecover(const String& message, Token& token,
+                                   TokenType skipUntilToken) {
+  addError(message, token);
+  return recoverFromError(skipUntilToken);
+}
+
+Value& OurReader::currentValue() { return *(nodes_.top()); }
+
+OurReader::Char OurReader::getNextChar() {
+  if (current_ == end_)
+    return 0;
+  return *current_++;
+}
+
+void OurReader::getLocationLineAndColumn(Location location, int& line,
+                                         int& column) const {
+  Location current = begin_;
+  Location lastLineStart = current;
+  line = 0;
+  while (current < location && current != end_) {
+    Char c = *current++;
+    if (c == '\r') {
+      if (*current == '\n')
+        ++current;
+      lastLineStart = current;
+      ++line;
+    } else if (c == '\n') {
+      lastLineStart = current;
+      ++line;
+    }
+  }
+  // column & line start at 1
+  column = int(location - lastLineStart) + 1;
+  ++line;
+}
+
+String OurReader::getLocationLineAndColumn(Location location) const {
+  int line, column;
+  getLocationLineAndColumn(location, line, column);
+  char buffer[18 + 16 + 16 + 1];
+  jsoncpp_snprintf(buffer, sizeof(buffer), "Line %d, Column %d", line, column);
+  return buffer;
+}
+
+String OurReader::getFormattedErrorMessages() const {
+  String formattedMessage;
+  for (const auto& error : errors_) {
+    formattedMessage +=
+        "* " + getLocationLineAndColumn(error.token_.start_) + "\n";
+    formattedMessage += "  " + error.message_ + "\n";
+    if (error.extra_)
+      formattedMessage +=
+          "See " + getLocationLineAndColumn(error.extra_) + " for detail.\n";
+  }
+  return formattedMessage;
+}
+
+std::vector<OurReader::StructuredError> OurReader::getStructuredErrors() const {
+  std::vector<OurReader::StructuredError> allErrors;
+  for (const auto& error : errors_) {
+    OurReader::StructuredError structured;
+    structured.offset_start = error.token_.start_ - begin_;
+    structured.offset_limit = error.token_.end_ - begin_;
+    structured.message = error.message_;
+    allErrors.push_back(structured);
+  }
+  return allErrors;
+}
+
+class OurCharReader : public CharReader {
+  bool const collectComments_;
+  OurReader reader_;
+
+public:
+  OurCharReader(bool collectComments, OurFeatures const& features)
+      : collectComments_(collectComments), reader_(features) {}
+  bool parse(char const* beginDoc, char const* endDoc, Value* root,
+             String* errs) override {
+    bool ok = reader_.parse(beginDoc, endDoc, *root, collectComments_);
+    if (errs) {
+      *errs = reader_.getFormattedErrorMessages();
+    }
+    return ok;
+  }
+};
+
+CharReaderBuilder::CharReaderBuilder() { setDefaults(&settings_); }
+CharReaderBuilder::~CharReaderBuilder() = default;
+CharReader* CharReaderBuilder::newCharReader() const {
+  bool collectComments = settings_["collectComments"].asBool();
+  OurFeatures features = OurFeatures::all();
+  features.allowComments_ = settings_["allowComments"].asBool();
+  features.allowTrailingCommas_ = settings_["allowTrailingCommas"].asBool();
+  features.strictRoot_ = settings_["strictRoot"].asBool();
+  features.allowDroppedNullPlaceholders_ =
+      settings_["allowDroppedNullPlaceholders"].asBool();
+  features.allowNumericKeys_ = settings_["allowNumericKeys"].asBool();
+  features.allowSingleQuotes_ = settings_["allowSingleQuotes"].asBool();
+
+  // Stack limit is always a size_t, so we get this as an unsigned int
+  // regardless of it we have 64-bit integer support enabled.
+  features.stackLimit_ = static_cast<size_t>(settings_["stackLimit"].asUInt());
+  features.failIfExtra_ = settings_["failIfExtra"].asBool();
+  features.rejectDupKeys_ = settings_["rejectDupKeys"].asBool();
+  features.allowSpecialFloats_ = settings_["allowSpecialFloats"].asBool();
+  features.skipBom_ = settings_["skipBom"].asBool();
+  return new OurCharReader(collectComments, features);
+}
+
+bool CharReaderBuilder::validate(Json::Value* invalid) const {
+  static const auto& valid_keys = *new std::set<String>{
+      "collectComments",
+      "allowComments",
+      "allowTrailingCommas",
+      "strictRoot",
+      "allowDroppedNullPlaceholders",
+      "allowNumericKeys",
+      "allowSingleQuotes",
+      "stackLimit",
+      "failIfExtra",
+      "rejectDupKeys",
+      "allowSpecialFloats",
+      "skipBom",
+  };
+  for (auto si = settings_.begin(); si != settings_.end(); ++si) {
+    auto key = si.name();
+    if (valid_keys.count(key))
+      continue;
+    if (invalid)
+      (*invalid)[key] = *si;
+    else
+      return false;
+  }
+  return invalid ? invalid->empty() : true;
+}
+
+Value& CharReaderBuilder::operator[](const String& key) {
+  return settings_[key];
+}
+// static
+void CharReaderBuilder::strictMode(Json::Value* settings) {
+  //! [CharReaderBuilderStrictMode]
+  (*settings)["allowComments"] = false;
+  (*settings)["allowTrailingCommas"] = false;
+  (*settings)["strictRoot"] = true;
+  (*settings)["allowDroppedNullPlaceholders"] = false;
+  (*settings)["allowNumericKeys"] = false;
+  (*settings)["allowSingleQuotes"] = false;
+  (*settings)["stackLimit"] = 1000;
+  (*settings)["failIfExtra"] = true;
+  (*settings)["rejectDupKeys"] = true;
+  (*settings)["allowSpecialFloats"] = false;
+  (*settings)["skipBom"] = true;
+  //! [CharReaderBuilderStrictMode]
+}
+// static
+void CharReaderBuilder::setDefaults(Json::Value* settings) {
+  //! [CharReaderBuilderDefaults]
+  (*settings)["collectComments"] = true;
+  (*settings)["allowComments"] = true;
+  (*settings)["allowTrailingCommas"] = true;
+  (*settings)["strictRoot"] = false;
+  (*settings)["allowDroppedNullPlaceholders"] = false;
+  (*settings)["allowNumericKeys"] = false;
+  (*settings)["allowSingleQuotes"] = false;
+  (*settings)["stackLimit"] = 1000;
+  (*settings)["failIfExtra"] = false;
+  (*settings)["rejectDupKeys"] = false;
+  (*settings)["allowSpecialFloats"] = false;
+  (*settings)["skipBom"] = true;
+  //! [CharReaderBuilderDefaults]
+}
+
+//////////////////////////////////
+// global functions
+
+bool parseFromStream(CharReader::Factory const& fact, IStream& sin, Value* root,
+                     String* errs) {
+  OStringStream ssin;
+  ssin << sin.rdbuf();
+  String doc = ssin.str();
+  char const* begin = doc.data();
+  char const* end = begin + doc.size();
+  // Note that we do not actually need a null-terminator.
+  CharReaderPtr const reader(fact.newCharReader());
+  return reader->parse(begin, end, root, errs);
+}
+
+IStream& operator>>(IStream& sin, Value& root) {
+  CharReaderBuilder b;
+  String errs;
+  bool ok = parseFromStream(b, sin, &root, &errs);
+  if (!ok) {
+    throwRuntimeError(errs);
+  }
+  return sin;
+}
+
+} // namespace Json
diff --git a/3rdparty/jsoncpp/src/src/lib_json/json_tool.h b/3rdparty/jsoncpp/src/src/lib_json/json_tool.h
new file mode 100644
index 00000000..b952c191
--- /dev/null
+++ b/3rdparty/jsoncpp/src/src/lib_json/json_tool.h
@@ -0,0 +1,138 @@
+// Copyright 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
+// Distributed under MIT license, or public domain if desired and
+// recognized in your jurisdiction.
+// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+#ifndef LIB_JSONCPP_JSON_TOOL_H_INCLUDED
+#define LIB_JSONCPP_JSON_TOOL_H_INCLUDED
+
+#if !defined(JSON_IS_AMALGAMATION)
+#include <json/config.h>
+#endif
+
+// Also support old flag NO_LOCALE_SUPPORT
+#ifdef NO_LOCALE_SUPPORT
+#define JSONCPP_NO_LOCALE_SUPPORT
+#endif
+
+#ifndef JSONCPP_NO_LOCALE_SUPPORT
+#include <clocale>
+#endif
+
+/* This header provides common string manipulation support, such as UTF-8,
+ * portable conversion from/to string...
+ *
+ * It is an internal header that must not be exposed.
+ */
+
+namespace Json {
+static inline char getDecimalPoint() {
+#ifdef JSONCPP_NO_LOCALE_SUPPORT
+  return '\0';
+#else
+  struct lconv* lc = localeconv();
+  return lc ? *(lc->decimal_point) : '\0';
+#endif
+}
+
+/// Converts a unicode code-point to UTF-8.
+static inline String codePointToUTF8(unsigned int cp) {
+  String result;
+
+  // based on description from http://en.wikipedia.org/wiki/UTF-8
+
+  if (cp <= 0x7f) {
+    result.resize(1);
+    result[0] = static_cast<char>(cp);
+  } else if (cp <= 0x7FF) {
+    result.resize(2);
+    result[1] = static_cast<char>(0x80 | (0x3f & cp));
+    result[0] = static_cast<char>(0xC0 | (0x1f & (cp >> 6)));
+  } else if (cp <= 0xFFFF) {
+    result.resize(3);
+    result[2] = static_cast<char>(0x80 | (0x3f & cp));
+    result[1] = static_cast<char>(0x80 | (0x3f & (cp >> 6)));
+    result[0] = static_cast<char>(0xE0 | (0xf & (cp >> 12)));
+  } else if (cp <= 0x10FFFF) {
+    result.resize(4);
+    result[3] = static_cast<char>(0x80 | (0x3f & cp));
+    result[2] = static_cast<char>(0x80 | (0x3f & (cp >> 6)));
+    result[1] = static_cast<char>(0x80 | (0x3f & (cp >> 12)));
+    result[0] = static_cast<char>(0xF0 | (0x7 & (cp >> 18)));
+  }
+
+  return result;
+}
+
+enum {
+  /// Constant that specify the size of the buffer that must be passed to
+  /// uintToString.
+  uintToStringBufferSize = 3 * sizeof(LargestUInt) + 1
+};
+
+// Defines a char buffer for use with uintToString().
+using UIntToStringBuffer = char[uintToStringBufferSize];
+
+/** Converts an unsigned integer to string.
+ * @param value Unsigned integer to convert to string
+ * @param current Input/Output string buffer.
+ *        Must have at least uintToStringBufferSize chars free.
+ */
+static inline void uintToString(LargestUInt value, char*& current) {
+  *--current = 0;
+  do {
+    *--current = static_cast<char>(value % 10U + static_cast<unsigned>('0'));
+    value /= 10;
+  } while (value != 0);
+}
+
+/** Change ',' to '.' everywhere in buffer.
+ *
+ * We had a sophisticated way, but it did not work in WinCE.
+ * @see https://github.com/open-source-parsers/jsoncpp/pull/9
+ */
+template <typename Iter> Iter fixNumericLocale(Iter begin, Iter end) {
+  for (; begin != end; ++begin) {
+    if (*begin == ',') {
+      *begin = '.';
+    }
+  }
+  return begin;
+}
+
+template <typename Iter> void fixNumericLocaleInput(Iter begin, Iter end) {
+  char decimalPoint = getDecimalPoint();
+  if (decimalPoint == '\0' || decimalPoint == '.') {
+    return;
+  }
+  for (; begin != end; ++begin) {
+    if (*begin == '.') {
+      *begin = decimalPoint;
+    }
+  }
+}
+
+/**
+ * Return iterator that would be the new end of the range [begin,end), if we
+ * were to delete zeros in the end of string, but not the last zero before '.'.
+ */
+template <typename Iter>
+Iter fixZerosInTheEnd(Iter begin, Iter end, unsigned int precision) {
+  for (; begin != end; --end) {
+    if (*(end - 1) != '0') {
+      return end;
+    }
+    // Don't delete the last zero before the decimal point.
+    if (begin != (end - 1) && begin != (end - 2) && *(end - 2) == '.') {
+      if (precision) {
+        return end;
+      }
+      return end - 2;
+    }
+  }
+  return end;
+}
+
+} // namespace Json
+
+#endif // LIB_JSONCPP_JSON_TOOL_H_INCLUDED
diff --git a/3rdparty/jsoncpp/src/src/lib_json/json_value.cpp b/3rdparty/jsoncpp/src/src/lib_json/json_value.cpp
new file mode 100644
index 00000000..aa2b744c
--- /dev/null
+++ b/3rdparty/jsoncpp/src/src/lib_json/json_value.cpp
@@ -0,0 +1,1634 @@
+// Copyright 2011 Baptiste Lepilleur and The JsonCpp Authors
+// Distributed under MIT license, or public domain if desired and
+// recognized in your jurisdiction.
+// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+#if !defined(JSON_IS_AMALGAMATION)
+#include <json/assertions.h>
+#include <json/value.h>
+#include <json/writer.h>
+#endif // if !defined(JSON_IS_AMALGAMATION)
+#include <algorithm>
+#include <cassert>
+#include <cmath>
+#include <cstddef>
+#include <cstring>
+#include <iostream>
+#include <sstream>
+#include <utility>
+
+// Provide implementation equivalent of std::snprintf for older _MSC compilers
+#if defined(_MSC_VER) && _MSC_VER < 1900
+#include <stdarg.h>
+static int msvc_pre1900_c99_vsnprintf(char* outBuf, size_t size,
+                                      const char* format, va_list ap) {
+  int count = -1;
+  if (size != 0)
+    count = _vsnprintf_s(outBuf, size, _TRUNCATE, format, ap);
+  if (count == -1)
+    count = _vscprintf(format, ap);
+  return count;
+}
+
+int JSON_API msvc_pre1900_c99_snprintf(char* outBuf, size_t size,
+                                       const char* format, ...) {
+  va_list ap;
+  va_start(ap, format);
+  const int count = msvc_pre1900_c99_vsnprintf(outBuf, size, format, ap);
+  va_end(ap);
+  return count;
+}
+#endif
+
+// Disable warning C4702 : unreachable code
+#if defined(_MSC_VER)
+#pragma warning(disable : 4702)
+#endif
+
+#define JSON_ASSERT_UNREACHABLE assert(false)
+
+namespace Json {
+template <typename T>
+static std::unique_ptr<T> cloneUnique(const std::unique_ptr<T>& p) {
+  std::unique_ptr<T> r;
+  if (p) {
+    r = std::unique_ptr<T>(new T(*p));
+  }
+  return r;
+}
+
+// This is a walkaround to avoid the static initialization of Value::null.
+// kNull must be word-aligned to avoid crashing on ARM.  We use an alignment of
+// 8 (instead of 4) as a bit of future-proofing.
+#if defined(__ARMEL__)
+#define ALIGNAS(byte_alignment) __attribute__((aligned(byte_alignment)))
+#else
+#define ALIGNAS(byte_alignment)
+#endif
+
+// static
+Value const& Value::nullSingleton() {
+  static Value const nullStatic;
+  return nullStatic;
+}
+
+#if JSON_USE_NULLREF
+// for backwards compatibility, we'll leave these global references around, but
+// DO NOT use them in JSONCPP library code any more!
+// static
+Value const& Value::null = Value::nullSingleton();
+
+// static
+Value const& Value::nullRef = Value::nullSingleton();
+#endif
+
+#if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
+template <typename T, typename U>
+static inline bool InRange(double d, T min, U max) {
+  // The casts can lose precision, but we are looking only for
+  // an approximate range. Might fail on edge cases though. ~cdunn
+  return d >= static_cast<double>(min) && d <= static_cast<double>(max);
+}
+#else  // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
+static inline double integerToDouble(Json::UInt64 value) {
+  return static_cast<double>(Int64(value / 2)) * 2.0 +
+         static_cast<double>(Int64(value & 1));
+}
+
+template <typename T> static inline double integerToDouble(T value) {
+  return static_cast<double>(value);
+}
+
+template <typename T, typename U>
+static inline bool InRange(double d, T min, U max) {
+  return d >= integerToDouble(min) && d <= integerToDouble(max);
+}
+#endif // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
+
+/** Duplicates the specified string value.
+ * @param value Pointer to the string to duplicate. Must be zero-terminated if
+ *              length is "unknown".
+ * @param length Length of the value. if equals to unknown, then it will be
+ *               computed using strlen(value).
+ * @return Pointer on the duplicate instance of string.
+ */
+static inline char* duplicateStringValue(const char* value, size_t length) {
+  // Avoid an integer overflow in the call to malloc below by limiting length
+  // to a sane value.
+  if (length >= static_cast<size_t>(Value::maxInt))
+    length = Value::maxInt - 1;
+
+  auto newString = static_cast<char*>(malloc(length + 1));
+  if (newString == nullptr) {
+    throwRuntimeError("in Json::Value::duplicateStringValue(): "
+                      "Failed to allocate string value buffer");
+  }
+  memcpy(newString, value, length);
+  newString[length] = 0;
+  return newString;
+}
+
+/* Record the length as a prefix.
+ */
+static inline char* duplicateAndPrefixStringValue(const char* value,
+                                                  unsigned int length) {
+  // Avoid an integer overflow in the call to malloc below by limiting length
+  // to a sane value.
+  JSON_ASSERT_MESSAGE(length <= static_cast<unsigned>(Value::maxInt) -
+                                    sizeof(unsigned) - 1U,
+                      "in Json::Value::duplicateAndPrefixStringValue(): "
+                      "length too big for prefixing");
+  size_t actualLength = sizeof(length) + length + 1;
+  auto newString = static_cast<char*>(malloc(actualLength));
+  if (newString == nullptr) {
+    throwRuntimeError("in Json::Value::duplicateAndPrefixStringValue(): "
+                      "Failed to allocate string value buffer");
+  }
+  *reinterpret_cast<unsigned*>(newString) = length;
+  memcpy(newString + sizeof(unsigned), value, length);
+  newString[actualLength - 1U] =
+      0; // to avoid buffer over-run accidents by users later
+  return newString;
+}
+inline static void decodePrefixedString(bool isPrefixed, char const* prefixed,
+                                        unsigned* length, char const** value) {
+  if (!isPrefixed) {
+    *length = static_cast<unsigned>(strlen(prefixed));
+    *value = prefixed;
+  } else {
+    *length = *reinterpret_cast<unsigned const*>(prefixed);
+    *value = prefixed + sizeof(unsigned);
+  }
+}
+/** Free the string duplicated by
+ * duplicateStringValue()/duplicateAndPrefixStringValue().
+ */
+#if JSONCPP_USING_SECURE_MEMORY
+static inline void releasePrefixedStringValue(char* value) {
+  unsigned length = 0;
+  char const* valueDecoded;
+  decodePrefixedString(true, value, &length, &valueDecoded);
+  size_t const size = sizeof(unsigned) + length + 1U;
+  memset(value, 0, size);
+  free(value);
+}
+static inline void releaseStringValue(char* value, unsigned length) {
+  // length==0 => we allocated the strings memory
+  size_t size = (length == 0) ? strlen(value) : length;
+  memset(value, 0, size);
+  free(value);
+}
+#else  // !JSONCPP_USING_SECURE_MEMORY
+static inline void releasePrefixedStringValue(char* value) { free(value); }
+static inline void releaseStringValue(char* value, unsigned) { free(value); }
+#endif // JSONCPP_USING_SECURE_MEMORY
+
+} // namespace Json
+
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// ValueInternals...
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+#if !defined(JSON_IS_AMALGAMATION)
+
+#include "json_valueiterator.inl"
+#endif // if !defined(JSON_IS_AMALGAMATION)
+
+namespace Json {
+
+#if JSON_USE_EXCEPTION
+Exception::Exception(String msg) : msg_(std::move(msg)) {}
+Exception::~Exception() noexcept = default;
+char const* Exception::what() const noexcept { return msg_.c_str(); }
+RuntimeError::RuntimeError(String const& msg) : Exception(msg) {}
+LogicError::LogicError(String const& msg) : Exception(msg) {}
+JSONCPP_NORETURN void throwRuntimeError(String const& msg) {
+  throw RuntimeError(msg);
+}
+JSONCPP_NORETURN void throwLogicError(String const& msg) {
+  throw LogicError(msg);
+}
+#else // !JSON_USE_EXCEPTION
+JSONCPP_NORETURN void throwRuntimeError(String const& msg) {
+  std::cerr << msg << std::endl;
+  abort();
+}
+JSONCPP_NORETURN void throwLogicError(String const& msg) {
+  std::cerr << msg << std::endl;
+  abort();
+}
+#endif
+
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// class Value::CZString
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+
+// Notes: policy_ indicates if the string was allocated when
+// a string is stored.
+
+Value::CZString::CZString(ArrayIndex index) : cstr_(nullptr), index_(index) {}
+
+Value::CZString::CZString(char const* str, unsigned length,
+                          DuplicationPolicy allocate)
+    : cstr_(str) {
+  // allocate != duplicate
+  storage_.policy_ = allocate & 0x3;
+  storage_.length_ = length & 0x3FFFFFFF;
+}
+
+Value::CZString::CZString(const CZString& other) {
+  cstr_ = (other.storage_.policy_ != noDuplication && other.cstr_ != nullptr
+               ? duplicateStringValue(other.cstr_, other.storage_.length_)
+               : other.cstr_);
+  storage_.policy_ =
+      static_cast<unsigned>(
+          other.cstr_
+              ? (static_cast<DuplicationPolicy>(other.storage_.policy_) ==
+                         noDuplication
+                     ? noDuplication
+                     : duplicate)
+              : static_cast<DuplicationPolicy>(other.storage_.policy_)) &
+      3U;
+  storage_.length_ = other.storage_.length_;
+}
+
+Value::CZString::CZString(CZString&& other) noexcept
+    : cstr_(other.cstr_), index_(other.index_) {
+  other.cstr_ = nullptr;
+}
+
+Value::CZString::~CZString() {
+  if (cstr_ && storage_.policy_ == duplicate) {
+    releaseStringValue(const_cast<char*>(cstr_),
+                       storage_.length_ + 1U); // +1 for null terminating
+                                               // character for sake of
+                                               // completeness but not actually
+                                               // necessary
+  }
+}
+
+void Value::CZString::swap(CZString& other) {
+  std::swap(cstr_, other.cstr_);
+  std::swap(index_, other.index_);
+}
+
+Value::CZString& Value::CZString::operator=(const CZString& other) {
+  cstr_ = other.cstr_;
+  index_ = other.index_;
+  return *this;
+}
+
+Value::CZString& Value::CZString::operator=(CZString&& other) noexcept {
+  cstr_ = other.cstr_;
+  index_ = other.index_;
+  other.cstr_ = nullptr;
+  return *this;
+}
+
+bool Value::CZString::operator<(const CZString& other) const {
+  if (!cstr_)
+    return index_ < other.index_;
+  // return strcmp(cstr_, other.cstr_) < 0;
+  // Assume both are strings.
+  unsigned this_len = this->storage_.length_;
+  unsigned other_len = other.storage_.length_;
+  unsigned min_len = std::min<unsigned>(this_len, other_len);
+  JSON_ASSERT(this->cstr_ && other.cstr_);
+  int comp = memcmp(this->cstr_, other.cstr_, min_len);
+  if (comp < 0)
+    return true;
+  if (comp > 0)
+    return false;
+  return (this_len < other_len);
+}
+
+bool Value::CZString::operator==(const CZString& other) const {
+  if (!cstr_)
+    return index_ == other.index_;
+  // return strcmp(cstr_, other.cstr_) == 0;
+  // Assume both are strings.
+  unsigned this_len = this->storage_.length_;
+  unsigned other_len = other.storage_.length_;
+  if (this_len != other_len)
+    return false;
+  JSON_ASSERT(this->cstr_ && other.cstr_);
+  int comp = memcmp(this->cstr_, other.cstr_, this_len);
+  return comp == 0;
+}
+
+ArrayIndex Value::CZString::index() const { return index_; }
+
+// const char* Value::CZString::c_str() const { return cstr_; }
+const char* Value::CZString::data() const { return cstr_; }
+unsigned Value::CZString::length() const { return storage_.length_; }
+bool Value::CZString::isStaticString() const {
+  return storage_.policy_ == noDuplication;
+}
+
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// class Value::Value
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+
+/*! \internal Default constructor initialization must be equivalent to:
+ * memset( this, 0, sizeof(Value) )
+ * This optimization is used in ValueInternalMap fast allocator.
+ */
+Value::Value(ValueType type) {
+  static char const emptyString[] = "";
+  initBasic(type);
+  switch (type) {
+  case nullValue:
+    break;
+  case intValue:
+  case uintValue:
+    value_.int_ = 0;
+    break;
+  case realValue:
+    value_.real_ = 0.0;
+    break;
+  case stringValue:
+    // allocated_ == false, so this is safe.
+    value_.string_ = const_cast<char*>(static_cast<char const*>(emptyString));
+    break;
+  case arrayValue:
+  case objectValue:
+    value_.map_ = new ObjectValues();
+    break;
+  case booleanValue:
+    value_.bool_ = false;
+    break;
+  default:
+    JSON_ASSERT_UNREACHABLE;
+  }
+}
+
+Value::Value(Int value) {
+  initBasic(intValue);
+  value_.int_ = value;
+}
+
+Value::Value(UInt value) {
+  initBasic(uintValue);
+  value_.uint_ = value;
+}
+#if defined(JSON_HAS_INT64)
+Value::Value(Int64 value) {
+  initBasic(intValue);
+  value_.int_ = value;
+}
+Value::Value(UInt64 value) {
+  initBasic(uintValue);
+  value_.uint_ = value;
+}
+#endif // defined(JSON_HAS_INT64)
+
+Value::Value(double value) {
+  initBasic(realValue);
+  value_.real_ = value;
+}
+
+Value::Value(const char* value) {
+  initBasic(stringValue, true);
+  JSON_ASSERT_MESSAGE(value != nullptr,
+                      "Null Value Passed to Value Constructor");
+  value_.string_ = duplicateAndPrefixStringValue(
+      value, static_cast<unsigned>(strlen(value)));
+}
+
+Value::Value(const char* begin, const char* end) {
+  initBasic(stringValue, true);
+  value_.string_ =
+      duplicateAndPrefixStringValue(begin, static_cast<unsigned>(end - begin));
+}
+
+Value::Value(const String& value) {
+  initBasic(stringValue, true);
+  value_.string_ = duplicateAndPrefixStringValue(
+      value.data(), static_cast<unsigned>(value.length()));
+}
+
+Value::Value(const StaticString& value) {
+  initBasic(stringValue);
+  value_.string_ = const_cast<char*>(value.c_str());
+}
+
+Value::Value(bool value) {
+  initBasic(booleanValue);
+  value_.bool_ = value;
+}
+
+Value::Value(const Value& other) {
+  dupPayload(other);
+  dupMeta(other);
+}
+
+Value::Value(Value&& other) noexcept {
+  initBasic(nullValue);
+  swap(other);
+}
+
+Value::~Value() {
+  releasePayload();
+  value_.uint_ = 0;
+}
+
+Value& Value::operator=(const Value& other) {
+  Value(other).swap(*this);
+  return *this;
+}
+
+Value& Value::operator=(Value&& other) noexcept {
+  other.swap(*this);
+  return *this;
+}
+
+void Value::swapPayload(Value& other) {
+  std::swap(bits_, other.bits_);
+  std::swap(value_, other.value_);
+}
+
+void Value::copyPayload(const Value& other) {
+  releasePayload();
+  dupPayload(other);
+}
+
+void Value::swap(Value& other) {
+  swapPayload(other);
+  std::swap(comments_, other.comments_);
+  std::swap(start_, other.start_);
+  std::swap(limit_, other.limit_);
+}
+
+void Value::copy(const Value& other) {
+  copyPayload(other);
+  dupMeta(other);
+}
+
+ValueType Value::type() const {
+  return static_cast<ValueType>(bits_.value_type_);
+}
+
+int Value::compare(const Value& other) const {
+  if (*this < other)
+    return -1;
+  if (*this > other)
+    return 1;
+  return 0;
+}
+
+bool Value::operator<(const Value& other) const {
+  int typeDelta = type() - other.type();
+  if (typeDelta)
+    return typeDelta < 0;
+  switch (type()) {
+  case nullValue:
+    return false;
+  case intValue:
+    return value_.int_ < other.value_.int_;
+  case uintValue:
+    return value_.uint_ < other.value_.uint_;
+  case realValue:
+    return value_.real_ < other.value_.real_;
+  case booleanValue:
+    return value_.bool_ < other.value_.bool_;
+  case stringValue: {
+    if ((value_.string_ == nullptr) || (other.value_.string_ == nullptr)) {
+      return other.value_.string_ != nullptr;
+    }
+    unsigned this_len;
+    unsigned other_len;
+    char const* this_str;
+    char const* other_str;
+    decodePrefixedString(this->isAllocated(), this->value_.string_, &this_len,
+                         &this_str);
+    decodePrefixedString(other.isAllocated(), other.value_.string_, &other_len,
+                         &other_str);
+    unsigned min_len = std::min<unsigned>(this_len, other_len);
+    JSON_ASSERT(this_str && other_str);
+    int comp = memcmp(this_str, other_str, min_len);
+    if (comp < 0)
+      return true;
+    if (comp > 0)
+      return false;
+    return (this_len < other_len);
+  }
+  case arrayValue:
+  case objectValue: {
+    auto thisSize = value_.map_->size();
+    auto otherSize = other.value_.map_->size();
+    if (thisSize != otherSize)
+      return thisSize < otherSize;
+    return (*value_.map_) < (*other.value_.map_);
+  }
+  default:
+    JSON_ASSERT_UNREACHABLE;
+  }
+  return false; // unreachable
+}
+
+bool Value::operator<=(const Value& other) const { return !(other < *this); }
+
+bool Value::operator>=(const Value& other) const { return !(*this < other); }
+
+bool Value::operator>(const Value& other) const { return other < *this; }
+
+bool Value::operator==(const Value& other) const {
+  if (type() != other.type())
+    return false;
+  switch (type()) {
+  case nullValue:
+    return true;
+  case intValue:
+    return value_.int_ == other.value_.int_;
+  case uintValue:
+    return value_.uint_ == other.value_.uint_;
+  case realValue:
+    return value_.real_ == other.value_.real_;
+  case booleanValue:
+    return value_.bool_ == other.value_.bool_;
+  case stringValue: {
+    if ((value_.string_ == nullptr) || (other.value_.string_ == nullptr)) {
+      return (value_.string_ == other.value_.string_);
+    }
+    unsigned this_len;
+    unsigned other_len;
+    char const* this_str;
+    char const* other_str;
+    decodePrefixedString(this->isAllocated(), this->value_.string_, &this_len,
+                         &this_str);
+    decodePrefixedString(other.isAllocated(), other.value_.string_, &other_len,
+                         &other_str);
+    if (this_len != other_len)
+      return false;
+    JSON_ASSERT(this_str && other_str);
+    int comp = memcmp(this_str, other_str, this_len);
+    return comp == 0;
+  }
+  case arrayValue:
+  case objectValue:
+    return value_.map_->size() == other.value_.map_->size() &&
+           (*value_.map_) == (*other.value_.map_);
+  default:
+    JSON_ASSERT_UNREACHABLE;
+  }
+  return false; // unreachable
+}
+
+bool Value::operator!=(const Value& other) const { return !(*this == other); }
+
+const char* Value::asCString() const {
+  JSON_ASSERT_MESSAGE(type() == stringValue,
+                      "in Json::Value::asCString(): requires stringValue");
+  if (value_.string_ == nullptr)
+    return nullptr;
+  unsigned this_len;
+  char const* this_str;
+  decodePrefixedString(this->isAllocated(), this->value_.string_, &this_len,
+                       &this_str);
+  return this_str;
+}
+
+#if JSONCPP_USING_SECURE_MEMORY
+unsigned Value::getCStringLength() const {
+  JSON_ASSERT_MESSAGE(type() == stringValue,
+                      "in Json::Value::asCString(): requires stringValue");
+  if (value_.string_ == 0)
+    return 0;
+  unsigned this_len;
+  char const* this_str;
+  decodePrefixedString(this->isAllocated(), this->value_.string_, &this_len,
+                       &this_str);
+  return this_len;
+}
+#endif
+
+bool Value::getString(char const** begin, char const** end) const {
+  if (type() != stringValue)
+    return false;
+  if (value_.string_ == nullptr)
+    return false;
+  unsigned length;
+  decodePrefixedString(this->isAllocated(), this->value_.string_, &length,
+                       begin);
+  *end = *begin + length;
+  return true;
+}
+
+String Value::asString() const {
+  switch (type()) {
+  case nullValue:
+    return "";
+  case stringValue: {
+    if (value_.string_ == nullptr)
+      return "";
+    unsigned this_len;
+    char const* this_str;
+    decodePrefixedString(this->isAllocated(), this->value_.string_, &this_len,
+                         &this_str);
+    return String(this_str, this_len);
+  }
+  case booleanValue:
+    return value_.bool_ ? "true" : "false";
+  case intValue:
+    return valueToString(value_.int_);
+  case uintValue:
+    return valueToString(value_.uint_);
+  case realValue:
+    return valueToString(value_.real_);
+  default:
+    JSON_FAIL_MESSAGE("Type is not convertible to string");
+  }
+}
+
+Value::Int Value::asInt() const {
+  switch (type()) {
+  case intValue:
+    JSON_ASSERT_MESSAGE(isInt(), "LargestInt out of Int range");
+    return Int(value_.int_);
+  case uintValue:
+    JSON_ASSERT_MESSAGE(isInt(), "LargestUInt out of Int range");
+    return Int(value_.uint_);
+  case realValue:
+    JSON_ASSERT_MESSAGE(InRange(value_.real_, minInt, maxInt),
+                        "double out of Int range");
+    return Int(value_.real_);
+  case nullValue:
+    return 0;
+  case booleanValue:
+    return value_.bool_ ? 1 : 0;
+  default:
+    break;
+  }
+  JSON_FAIL_MESSAGE("Value is not convertible to Int.");
+}
+
+Value::UInt Value::asUInt() const {
+  switch (type()) {
+  case intValue:
+    JSON_ASSERT_MESSAGE(isUInt(), "LargestInt out of UInt range");
+    return UInt(value_.int_);
+  case uintValue:
+    JSON_ASSERT_MESSAGE(isUInt(), "LargestUInt out of UInt range");
+    return UInt(value_.uint_);
+  case realValue:
+    JSON_ASSERT_MESSAGE(InRange(value_.real_, 0, maxUInt),
+                        "double out of UInt range");
+    return UInt(value_.real_);
+  case nullValue:
+    return 0;
+  case booleanValue:
+    return value_.bool_ ? 1 : 0;
+  default:
+    break;
+  }
+  JSON_FAIL_MESSAGE("Value is not convertible to UInt.");
+}
+
+#if defined(JSON_HAS_INT64)
+
+Value::Int64 Value::asInt64() const {
+  switch (type()) {
+  case intValue:
+    return Int64(value_.int_);
+  case uintValue:
+    JSON_ASSERT_MESSAGE(isInt64(), "LargestUInt out of Int64 range");
+    return Int64(value_.uint_);
+  case realValue:
+    JSON_ASSERT_MESSAGE(InRange(value_.real_, minInt64, maxInt64),
+                        "double out of Int64 range");
+    return Int64(value_.real_);
+  case nullValue:
+    return 0;
+  case booleanValue:
+    return value_.bool_ ? 1 : 0;
+  default:
+    break;
+  }
+  JSON_FAIL_MESSAGE("Value is not convertible to Int64.");
+}
+
+Value::UInt64 Value::asUInt64() const {
+  switch (type()) {
+  case intValue:
+    JSON_ASSERT_MESSAGE(isUInt64(), "LargestInt out of UInt64 range");
+    return UInt64(value_.int_);
+  case uintValue:
+    return UInt64(value_.uint_);
+  case realValue:
+    JSON_ASSERT_MESSAGE(InRange(value_.real_, 0, maxUInt64),
+                        "double out of UInt64 range");
+    return UInt64(value_.real_);
+  case nullValue:
+    return 0;
+  case booleanValue:
+    return value_.bool_ ? 1 : 0;
+  default:
+    break;
+  }
+  JSON_FAIL_MESSAGE("Value is not convertible to UInt64.");
+}
+#endif // if defined(JSON_HAS_INT64)
+
+LargestInt Value::asLargestInt() const {
+#if defined(JSON_NO_INT64)
+  return asInt();
+#else
+  return asInt64();
+#endif
+}
+
+LargestUInt Value::asLargestUInt() const {
+#if defined(JSON_NO_INT64)
+  return asUInt();
+#else
+  return asUInt64();
+#endif
+}
+
+double Value::asDouble() const {
+  switch (type()) {
+  case intValue:
+    return static_cast<double>(value_.int_);
+  case uintValue:
+#if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
+    return static_cast<double>(value_.uint_);
+#else  // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
+    return integerToDouble(value_.uint_);
+#endif // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
+  case realValue:
+    return value_.real_;
+  case nullValue:
+    return 0.0;
+  case booleanValue:
+    return value_.bool_ ? 1.0 : 0.0;
+  default:
+    break;
+  }
+  JSON_FAIL_MESSAGE("Value is not convertible to double.");
+}
+
+float Value::asFloat() const {
+  switch (type()) {
+  case intValue:
+    return static_cast<float>(value_.int_);
+  case uintValue:
+#if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
+    return static_cast<float>(value_.uint_);
+#else  // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
+    // This can fail (silently?) if the value is bigger than MAX_FLOAT.
+    return static_cast<float>(integerToDouble(value_.uint_));
+#endif // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
+  case realValue:
+    return static_cast<float>(value_.real_);
+  case nullValue:
+    return 0.0;
+  case booleanValue:
+    return value_.bool_ ? 1.0F : 0.0F;
+  default:
+    break;
+  }
+  JSON_FAIL_MESSAGE("Value is not convertible to float.");
+}
+
+bool Value::asBool() const {
+  switch (type()) {
+  case booleanValue:
+    return value_.bool_;
+  case nullValue:
+    return false;
+  case intValue:
+    return value_.int_ != 0;
+  case uintValue:
+    return value_.uint_ != 0;
+  case realValue: {
+    // According to JavaScript language zero or NaN is regarded as false
+    const auto value_classification = std::fpclassify(value_.real_);
+    return value_classification != FP_ZERO && value_classification != FP_NAN;
+  }
+  default:
+    break;
+  }
+  JSON_FAIL_MESSAGE("Value is not convertible to bool.");
+}
+
+bool Value::isConvertibleTo(ValueType other) const {
+  switch (other) {
+  case nullValue:
+    return (isNumeric() && asDouble() == 0.0) ||
+           (type() == booleanValue && !value_.bool_) ||
+           (type() == stringValue && asString().empty()) ||
+           (type() == arrayValue && value_.map_->empty()) ||
+           (type() == objectValue && value_.map_->empty()) ||
+           type() == nullValue;
+  case intValue:
+    return isInt() ||
+           (type() == realValue && InRange(value_.real_, minInt, maxInt)) ||
+           type() == booleanValue || type() == nullValue;
+  case uintValue:
+    return isUInt() ||
+           (type() == realValue && InRange(value_.real_, 0, maxUInt)) ||
+           type() == booleanValue || type() == nullValue;
+  case realValue:
+    return isNumeric() || type() == booleanValue || type() == nullValue;
+  case booleanValue:
+    return isNumeric() || type() == booleanValue || type() == nullValue;
+  case stringValue:
+    return isNumeric() || type() == booleanValue || type() == stringValue ||
+           type() == nullValue;
+  case arrayValue:
+    return type() == arrayValue || type() == nullValue;
+  case objectValue:
+    return type() == objectValue || type() == nullValue;
+  }
+  JSON_ASSERT_UNREACHABLE;
+  return false;
+}
+
+/// Number of values in array or object
+ArrayIndex Value::size() const {
+  switch (type()) {
+  case nullValue:
+  case intValue:
+  case uintValue:
+  case realValue:
+  case booleanValue:
+  case stringValue:
+    return 0;
+  case arrayValue: // size of the array is highest index + 1
+    if (!value_.map_->empty()) {
+      ObjectValues::const_iterator itLast = value_.map_->end();
+      --itLast;
+      return (*itLast).first.index() + 1;
+    }
+    return 0;
+  case objectValue:
+    return ArrayIndex(value_.map_->size());
+  }
+  JSON_ASSERT_UNREACHABLE;
+  return 0; // unreachable;
+}
+
+bool Value::empty() const {
+  if (isNull() || isArray() || isObject())
+    return size() == 0U;
+  return false;
+}
+
+Value::operator bool() const { return !isNull(); }
+
+void Value::clear() {
+  JSON_ASSERT_MESSAGE(type() == nullValue || type() == arrayValue ||
+                          type() == objectValue,
+                      "in Json::Value::clear(): requires complex value");
+  start_ = 0;
+  limit_ = 0;
+  switch (type()) {
+  case arrayValue:
+  case objectValue:
+    value_.map_->clear();
+    break;
+  default:
+    break;
+  }
+}
+
+void Value::resize(ArrayIndex newSize) {
+  JSON_ASSERT_MESSAGE(type() == nullValue || type() == arrayValue,
+                      "in Json::Value::resize(): requires arrayValue");
+  if (type() == nullValue)
+    *this = Value(arrayValue);
+  ArrayIndex oldSize = size();
+  if (newSize == 0)
+    clear();
+  else if (newSize > oldSize)
+    for (ArrayIndex i = oldSize; i < newSize; ++i)
+      (*this)[i];
+  else {
+    for (ArrayIndex index = newSize; index < oldSize; ++index) {
+      value_.map_->erase(index);
+    }
+    JSON_ASSERT(size() == newSize);
+  }
+}
+
+Value& Value::operator[](ArrayIndex index) {
+  JSON_ASSERT_MESSAGE(
+      type() == nullValue || type() == arrayValue,
+      "in Json::Value::operator[](ArrayIndex): requires arrayValue");
+  if (type() == nullValue)
+    *this = Value(arrayValue);
+  CZString key(index);
+  auto it = value_.map_->lower_bound(key);
+  if (it != value_.map_->end() && (*it).first == key)
+    return (*it).second;
+
+  ObjectValues::value_type defaultValue(key, nullSingleton());
+  it = value_.map_->insert(it, defaultValue);
+  return (*it).second;
+}
+
+Value& Value::operator[](int index) {
+  JSON_ASSERT_MESSAGE(
+      index >= 0,
+      "in Json::Value::operator[](int index): index cannot be negative");
+  return (*this)[ArrayIndex(index)];
+}
+
+const Value& Value::operator[](ArrayIndex index) const {
+  JSON_ASSERT_MESSAGE(
+      type() == nullValue || type() == arrayValue,
+      "in Json::Value::operator[](ArrayIndex)const: requires arrayValue");
+  if (type() == nullValue)
+    return nullSingleton();
+  CZString key(index);
+  ObjectValues::const_iterator it = value_.map_->find(key);
+  if (it == value_.map_->end())
+    return nullSingleton();
+  return (*it).second;
+}
+
+const Value& Value::operator[](int index) const {
+  JSON_ASSERT_MESSAGE(
+      index >= 0,
+      "in Json::Value::operator[](int index) const: index cannot be negative");
+  return (*this)[ArrayIndex(index)];
+}
+
+void Value::initBasic(ValueType type, bool allocated) {
+  setType(type);
+  setIsAllocated(allocated);
+  comments_ = Comments{};
+  start_ = 0;
+  limit_ = 0;
+}
+
+void Value::dupPayload(const Value& other) {
+  setType(other.type());
+  setIsAllocated(false);
+  switch (type()) {
+  case nullValue:
+  case intValue:
+  case uintValue:
+  case realValue:
+  case booleanValue:
+    value_ = other.value_;
+    break;
+  case stringValue:
+    if (other.value_.string_ && other.isAllocated()) {
+      unsigned len;
+      char const* str;
+      decodePrefixedString(other.isAllocated(), other.value_.string_, &len,
+                           &str);
+      value_.string_ = duplicateAndPrefixStringValue(str, len);
+      setIsAllocated(true);
+    } else {
+      value_.string_ = other.value_.string_;
+    }
+    break;
+  case arrayValue:
+  case objectValue:
+    value_.map_ = new ObjectValues(*other.value_.map_);
+    break;
+  default:
+    JSON_ASSERT_UNREACHABLE;
+  }
+}
+
+void Value::releasePayload() {
+  switch (type()) {
+  case nullValue:
+  case intValue:
+  case uintValue:
+  case realValue:
+  case booleanValue:
+    break;
+  case stringValue:
+    if (isAllocated())
+      releasePrefixedStringValue(value_.string_);
+    break;
+  case arrayValue:
+  case objectValue:
+    delete value_.map_;
+    break;
+  default:
+    JSON_ASSERT_UNREACHABLE;
+  }
+}
+
+void Value::dupMeta(const Value& other) {
+  comments_ = other.comments_;
+  start_ = other.start_;
+  limit_ = other.limit_;
+}
+
+// Access an object value by name, create a null member if it does not exist.
+// @pre Type of '*this' is object or null.
+// @param key is null-terminated.
+Value& Value::resolveReference(const char* key) {
+  JSON_ASSERT_MESSAGE(
+      type() == nullValue || type() == objectValue,
+      "in Json::Value::resolveReference(): requires objectValue");
+  if (type() == nullValue)
+    *this = Value(objectValue);
+  CZString actualKey(key, static_cast<unsigned>(strlen(key)),
+                     CZString::noDuplication); // NOTE!
+  auto it = value_.map_->lower_bound(actualKey);
+  if (it != value_.map_->end() && (*it).first == actualKey)
+    return (*it).second;
+
+  ObjectValues::value_type defaultValue(actualKey, nullSingleton());
+  it = value_.map_->insert(it, defaultValue);
+  Value& value = (*it).second;
+  return value;
+}
+
+// @param key is not null-terminated.
+Value& Value::resolveReference(char const* key, char const* end) {
+  JSON_ASSERT_MESSAGE(
+      type() == nullValue || type() == objectValue,
+      "in Json::Value::resolveReference(key, end): requires objectValue");
+  if (type() == nullValue)
+    *this = Value(objectValue);
+  CZString actualKey(key, static_cast<unsigned>(end - key),
+                     CZString::duplicateOnCopy);
+  auto it = value_.map_->lower_bound(actualKey);
+  if (it != value_.map_->end() && (*it).first == actualKey)
+    return (*it).second;
+
+  ObjectValues::value_type defaultValue(actualKey, nullSingleton());
+  it = value_.map_->insert(it, defaultValue);
+  Value& value = (*it).second;
+  return value;
+}
+
+Value Value::get(ArrayIndex index, const Value& defaultValue) const {
+  const Value* value = &((*this)[index]);
+  return value == &nullSingleton() ? defaultValue : *value;
+}
+
+bool Value::isValidIndex(ArrayIndex index) const { return index < size(); }
+
+Value const* Value::find(char const* begin, char const* end) const {
+  JSON_ASSERT_MESSAGE(type() == nullValue || type() == objectValue,
+                      "in Json::Value::find(begin, end): requires "
+                      "objectValue or nullValue");
+  if (type() == nullValue)
+    return nullptr;
+  CZString actualKey(begin, static_cast<unsigned>(end - begin),
+                     CZString::noDuplication);
+  ObjectValues::const_iterator it = value_.map_->find(actualKey);
+  if (it == value_.map_->end())
+    return nullptr;
+  return &(*it).second;
+}
+Value* Value::demand(char const* begin, char const* end) {
+  JSON_ASSERT_MESSAGE(type() == nullValue || type() == objectValue,
+                      "in Json::Value::demand(begin, end): requires "
+                      "objectValue or nullValue");
+  return &resolveReference(begin, end);
+}
+const Value& Value::operator[](const char* key) const {
+  Value const* found = find(key, key + strlen(key));
+  if (!found)
+    return nullSingleton();
+  return *found;
+}
+Value const& Value::operator[](const String& key) const {
+  Value const* found = find(key.data(), key.data() + key.length());
+  if (!found)
+    return nullSingleton();
+  return *found;
+}
+
+Value& Value::operator[](const char* key) {
+  return resolveReference(key, key + strlen(key));
+}
+
+Value& Value::operator[](const String& key) {
+  return resolveReference(key.data(), key.data() + key.length());
+}
+
+Value& Value::operator[](const StaticString& key) {
+  return resolveReference(key.c_str());
+}
+
+Value& Value::append(const Value& value) { return append(Value(value)); }
+
+Value& Value::append(Value&& value) {
+  JSON_ASSERT_MESSAGE(type() == nullValue || type() == arrayValue,
+                      "in Json::Value::append: requires arrayValue");
+  if (type() == nullValue) {
+    *this = Value(arrayValue);
+  }
+  return this->value_.map_->emplace(size(), std::move(value)).first->second;
+}
+
+bool Value::insert(ArrayIndex index, const Value& newValue) {
+  return insert(index, Value(newValue));
+}
+
+bool Value::insert(ArrayIndex index, Value&& newValue) {
+  JSON_ASSERT_MESSAGE(type() == nullValue || type() == arrayValue,
+                      "in Json::Value::insert: requires arrayValue");
+  ArrayIndex length = size();
+  if (index > length) {
+    return false;
+  }
+  for (ArrayIndex i = length; i > index; i--) {
+    (*this)[i] = std::move((*this)[i - 1]);
+  }
+  (*this)[index] = std::move(newValue);
+  return true;
+}
+
+Value Value::get(char const* begin, char const* end,
+                 Value const& defaultValue) const {
+  Value const* found = find(begin, end);
+  return !found ? defaultValue : *found;
+}
+Value Value::get(char const* key, Value const& defaultValue) const {
+  return get(key, key + strlen(key), defaultValue);
+}
+Value Value::get(String const& key, Value const& defaultValue) const {
+  return get(key.data(), key.data() + key.length(), defaultValue);
+}
+
+bool Value::removeMember(const char* begin, const char* end, Value* removed) {
+  if (type() != objectValue) {
+    return false;
+  }
+  CZString actualKey(begin, static_cast<unsigned>(end - begin),
+                     CZString::noDuplication);
+  auto it = value_.map_->find(actualKey);
+  if (it == value_.map_->end())
+    return false;
+  if (removed)
+    *removed = std::move(it->second);
+  value_.map_->erase(it);
+  return true;
+}
+bool Value::removeMember(const char* key, Value* removed) {
+  return removeMember(key, key + strlen(key), removed);
+}
+bool Value::removeMember(String const& key, Value* removed) {
+  return removeMember(key.data(), key.data() + key.length(), removed);
+}
+void Value::removeMember(const char* key) {
+  JSON_ASSERT_MESSAGE(type() == nullValue || type() == objectValue,
+                      "in Json::Value::removeMember(): requires objectValue");
+  if (type() == nullValue)
+    return;
+
+  CZString actualKey(key, unsigned(strlen(key)), CZString::noDuplication);
+  value_.map_->erase(actualKey);
+}
+void Value::removeMember(const String& key) { removeMember(key.c_str()); }
+
+bool Value::removeIndex(ArrayIndex index, Value* removed) {
+  if (type() != arrayValue) {
+    return false;
+  }
+  CZString key(index);
+  auto it = value_.map_->find(key);
+  if (it == value_.map_->end()) {
+    return false;
+  }
+  if (removed)
+    *removed = it->second;
+  ArrayIndex oldSize = size();
+  // shift left all items left, into the place of the "removed"
+  for (ArrayIndex i = index; i < (oldSize - 1); ++i) {
+    CZString keey(i);
+    (*value_.map_)[keey] = (*this)[i + 1];
+  }
+  // erase the last one ("leftover")
+  CZString keyLast(oldSize - 1);
+  auto itLast = value_.map_->find(keyLast);
+  value_.map_->erase(itLast);
+  return true;
+}
+
+bool Value::isMember(char const* begin, char const* end) const {
+  Value const* value = find(begin, end);
+  return nullptr != value;
+}
+bool Value::isMember(char const* key) const {
+  return isMember(key, key + strlen(key));
+}
+bool Value::isMember(String const& key) const {
+  return isMember(key.data(), key.data() + key.length());
+}
+
+Value::Members Value::getMemberNames() const {
+  JSON_ASSERT_MESSAGE(
+      type() == nullValue || type() == objectValue,
+      "in Json::Value::getMemberNames(), value must be objectValue");
+  if (type() == nullValue)
+    return Value::Members();
+  Members members;
+  members.reserve(value_.map_->size());
+  ObjectValues::const_iterator it = value_.map_->begin();
+  ObjectValues::const_iterator itEnd = value_.map_->end();
+  for (; it != itEnd; ++it) {
+    members.push_back(String((*it).first.data(), (*it).first.length()));
+  }
+  return members;
+}
+
+static bool IsIntegral(double d) {
+  double integral_part;
+  return modf(d, &integral_part) == 0.0;
+}
+
+bool Value::isNull() const { return type() == nullValue; }
+
+bool Value::isBool() const { return type() == booleanValue; }
+
+bool Value::isInt() const {
+  switch (type()) {
+  case intValue:
+#if defined(JSON_HAS_INT64)
+    return value_.int_ >= minInt && value_.int_ <= maxInt;
+#else
+    return true;
+#endif
+  case uintValue:
+    return value_.uint_ <= UInt(maxInt);
+  case realValue:
+    return value_.real_ >= minInt && value_.real_ <= maxInt &&
+           IsIntegral(value_.real_);
+  default:
+    break;
+  }
+  return false;
+}
+
+bool Value::isUInt() const {
+  switch (type()) {
+  case intValue:
+#if defined(JSON_HAS_INT64)
+    return value_.int_ >= 0 && LargestUInt(value_.int_) <= LargestUInt(maxUInt);
+#else
+    return value_.int_ >= 0;
+#endif
+  case uintValue:
+#if defined(JSON_HAS_INT64)
+    return value_.uint_ <= maxUInt;
+#else
+    return true;
+#endif
+  case realValue:
+    return value_.real_ >= 0 && value_.real_ <= maxUInt &&
+           IsIntegral(value_.real_);
+  default:
+    break;
+  }
+  return false;
+}
+
+bool Value::isInt64() const {
+#if defined(JSON_HAS_INT64)
+  switch (type()) {
+  case intValue:
+    return true;
+  case uintValue:
+    return value_.uint_ <= UInt64(maxInt64);
+  case realValue:
+    // Note that maxInt64 (= 2^63 - 1) is not exactly representable as a
+    // double, so double(maxInt64) will be rounded up to 2^63. Therefore we
+    // require the value to be strictly less than the limit.
+    return value_.real_ >= double(minInt64) &&
+           value_.real_ < double(maxInt64) && IsIntegral(value_.real_);
+  default:
+    break;
+  }
+#endif // JSON_HAS_INT64
+  return false;
+}
+
+bool Value::isUInt64() const {
+#if defined(JSON_HAS_INT64)
+  switch (type()) {
+  case intValue:
+    return value_.int_ >= 0;
+  case uintValue:
+    return true;
+  case realValue:
+    // Note that maxUInt64 (= 2^64 - 1) is not exactly representable as a
+    // double, so double(maxUInt64) will be rounded up to 2^64. Therefore we
+    // require the value to be strictly less than the limit.
+    return value_.real_ >= 0 && value_.real_ < maxUInt64AsDouble &&
+           IsIntegral(value_.real_);
+  default:
+    break;
+  }
+#endif // JSON_HAS_INT64
+  return false;
+}
+
+bool Value::isIntegral() const {
+  switch (type()) {
+  case intValue:
+  case uintValue:
+    return true;
+  case realValue:
+#if defined(JSON_HAS_INT64)
+    // Note that maxUInt64 (= 2^64 - 1) is not exactly representable as a
+    // double, so double(maxUInt64) will be rounded up to 2^64. Therefore we
+    // require the value to be strictly less than the limit.
+    return value_.real_ >= double(minInt64) &&
+           value_.real_ < maxUInt64AsDouble && IsIntegral(value_.real_);
+#else
+    return value_.real_ >= minInt && value_.real_ <= maxUInt &&
+           IsIntegral(value_.real_);
+#endif // JSON_HAS_INT64
+  default:
+    break;
+  }
+  return false;
+}
+
+bool Value::isDouble() const {
+  return type() == intValue || type() == uintValue || type() == realValue;
+}
+
+bool Value::isNumeric() const { return isDouble(); }
+
+bool Value::isString() const { return type() == stringValue; }
+
+bool Value::isArray() const { return type() == arrayValue; }
+
+bool Value::isObject() const { return type() == objectValue; }
+
+Value::Comments::Comments(const Comments& that)
+    : ptr_{cloneUnique(that.ptr_)} {}
+
+Value::Comments::Comments(Comments&& that) noexcept
+    : ptr_{std::move(that.ptr_)} {}
+
+Value::Comments& Value::Comments::operator=(const Comments& that) {
+  ptr_ = cloneUnique(that.ptr_);
+  return *this;
+}
+
+Value::Comments& Value::Comments::operator=(Comments&& that) noexcept {
+  ptr_ = std::move(that.ptr_);
+  return *this;
+}
+
+bool Value::Comments::has(CommentPlacement slot) const {
+  return ptr_ && !(*ptr_)[slot].empty();
+}
+
+String Value::Comments::get(CommentPlacement slot) const {
+  if (!ptr_)
+    return {};
+  return (*ptr_)[slot];
+}
+
+void Value::Comments::set(CommentPlacement slot, String comment) {
+  if (slot >= CommentPlacement::numberOfCommentPlacement)
+    return;
+  if (!ptr_)
+    ptr_ = std::unique_ptr<Array>(new Array());
+  (*ptr_)[slot] = std::move(comment);
+}
+
+void Value::setComment(String comment, CommentPlacement placement) {
+  if (!comment.empty() && (comment.back() == '\n')) {
+    // Always discard trailing newline, to aid indentation.
+    comment.pop_back();
+  }
+  JSON_ASSERT(!comment.empty());
+  JSON_ASSERT_MESSAGE(
+      comment[0] == '\0' || comment[0] == '/',
+      "in Json::Value::setComment(): Comments must start with /");
+  comments_.set(placement, std::move(comment));
+}
+
+bool Value::hasComment(CommentPlacement placement) const {
+  return comments_.has(placement);
+}
+
+String Value::getComment(CommentPlacement placement) const {
+  return comments_.get(placement);
+}
+
+void Value::setOffsetStart(ptrdiff_t start) { start_ = start; }
+
+void Value::setOffsetLimit(ptrdiff_t limit) { limit_ = limit; }
+
+ptrdiff_t Value::getOffsetStart() const { return start_; }
+
+ptrdiff_t Value::getOffsetLimit() const { return limit_; }
+
+String Value::toStyledString() const {
+  StreamWriterBuilder builder;
+
+  String out = this->hasComment(commentBefore) ? "\n" : "";
+  out += Json::writeString(builder, *this);
+  out += '\n';
+
+  return out;
+}
+
+Value::const_iterator Value::begin() const {
+  switch (type()) {
+  case arrayValue:
+  case objectValue:
+    if (value_.map_)
+      return const_iterator(value_.map_->begin());
+    break;
+  default:
+    break;
+  }
+  return {};
+}
+
+Value::const_iterator Value::end() const {
+  switch (type()) {
+  case arrayValue:
+  case objectValue:
+    if (value_.map_)
+      return const_iterator(value_.map_->end());
+    break;
+  default:
+    break;
+  }
+  return {};
+}
+
+Value::iterator Value::begin() {
+  switch (type()) {
+  case arrayValue:
+  case objectValue:
+    if (value_.map_)
+      return iterator(value_.map_->begin());
+    break;
+  default:
+    break;
+  }
+  return iterator();
+}
+
+Value::iterator Value::end() {
+  switch (type()) {
+  case arrayValue:
+  case objectValue:
+    if (value_.map_)
+      return iterator(value_.map_->end());
+    break;
+  default:
+    break;
+  }
+  return iterator();
+}
+
+// class PathArgument
+// //////////////////////////////////////////////////////////////////
+
+PathArgument::PathArgument() = default;
+
+PathArgument::PathArgument(ArrayIndex index)
+    : index_(index), kind_(kindIndex) {}
+
+PathArgument::PathArgument(const char* key) : key_(key), kind_(kindKey) {}
+
+PathArgument::PathArgument(String key) : key_(std::move(key)), kind_(kindKey) {}
+
+// class Path
+// //////////////////////////////////////////////////////////////////
+
+Path::Path(const String& path, const PathArgument& a1, const PathArgument& a2,
+           const PathArgument& a3, const PathArgument& a4,
+           const PathArgument& a5) {
+  InArgs in;
+  in.reserve(5);
+  in.push_back(&a1);
+  in.push_back(&a2);
+  in.push_back(&a3);
+  in.push_back(&a4);
+  in.push_back(&a5);
+  makePath(path, in);
+}
+
+void Path::makePath(const String& path, const InArgs& in) {
+  const char* current = path.c_str();
+  const char* end = current + path.length();
+  auto itInArg = in.begin();
+  while (current != end) {
+    if (*current == '[') {
+      ++current;
+      if (*current == '%')
+        addPathInArg(path, in, itInArg, PathArgument::kindIndex);
+      else {
+        ArrayIndex index = 0;
+        for (; current != end && *current >= '0' && *current <= '9'; ++current)
+          index = index * 10 + ArrayIndex(*current - '0');
+        args_.push_back(index);
+      }
+      if (current == end || *++current != ']')
+        invalidPath(path, int(current - path.c_str()));
+    } else if (*current == '%') {
+      addPathInArg(path, in, itInArg, PathArgument::kindKey);
+      ++current;
+    } else if (*current == '.' || *current == ']') {
+      ++current;
+    } else {
+      const char* beginName = current;
+      while (current != end && !strchr("[.", *current))
+        ++current;
+      args_.push_back(String(beginName, current));
+    }
+  }
+}
+
+void Path::addPathInArg(const String& /*path*/, const InArgs& in,
+                        InArgs::const_iterator& itInArg,
+                        PathArgument::Kind kind) {
+  if (itInArg == in.end()) {
+    // Error: missing argument %d
+  } else if ((*itInArg)->kind_ != kind) {
+    // Error: bad argument type
+  } else {
+    args_.push_back(**itInArg++);
+  }
+}
+
+void Path::invalidPath(const String& /*path*/, int /*location*/) {
+  // Error: invalid path.
+}
+
+const Value& Path::resolve(const Value& root) const {
+  const Value* node = &root;
+  for (const auto& arg : args_) {
+    if (arg.kind_ == PathArgument::kindIndex) {
+      if (!node->isArray() || !node->isValidIndex(arg.index_)) {
+        // Error: unable to resolve path (array value expected at position... )
+        return Value::nullSingleton();
+      }
+      node = &((*node)[arg.index_]);
+    } else if (arg.kind_ == PathArgument::kindKey) {
+      if (!node->isObject()) {
+        // Error: unable to resolve path (object value expected at position...)
+        return Value::nullSingleton();
+      }
+      node = &((*node)[arg.key_]);
+      if (node == &Value::nullSingleton()) {
+        // Error: unable to resolve path (object has no member named '' at
+        // position...)
+        return Value::nullSingleton();
+      }
+    }
+  }
+  return *node;
+}
+
+Value Path::resolve(const Value& root, const Value& defaultValue) const {
+  const Value* node = &root;
+  for (const auto& arg : args_) {
+    if (arg.kind_ == PathArgument::kindIndex) {
+      if (!node->isArray() || !node->isValidIndex(arg.index_))
+        return defaultValue;
+      node = &((*node)[arg.index_]);
+    } else if (arg.kind_ == PathArgument::kindKey) {
+      if (!node->isObject())
+        return defaultValue;
+      node = &((*node)[arg.key_]);
+      if (node == &Value::nullSingleton())
+        return defaultValue;
+    }
+  }
+  return *node;
+}
+
+Value& Path::make(Value& root) const {
+  Value* node = &root;
+  for (const auto& arg : args_) {
+    if (arg.kind_ == PathArgument::kindIndex) {
+      if (!node->isArray()) {
+        // Error: node is not an array at position ...
+      }
+      node = &((*node)[arg.index_]);
+    } else if (arg.kind_ == PathArgument::kindKey) {
+      if (!node->isObject()) {
+        // Error: node is not an object at position...
+      }
+      node = &((*node)[arg.key_]);
+    }
+  }
+  return *node;
+}
+
+} // namespace Json
diff --git a/3rdparty/jsoncpp/src/src/lib_json/json_valueiterator.inl b/3rdparty/jsoncpp/src/src/lib_json/json_valueiterator.inl
new file mode 100644
index 00000000..d6128b8e
--- /dev/null
+++ b/3rdparty/jsoncpp/src/src/lib_json/json_valueiterator.inl
@@ -0,0 +1,156 @@
+// Copyright 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
+// Distributed under MIT license, or public domain if desired and
+// recognized in your jurisdiction.
+// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+// included by json_value.cpp
+
+namespace Json {
+
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// class ValueIteratorBase
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+
+ValueIteratorBase::ValueIteratorBase() : current_() {}
+
+ValueIteratorBase::ValueIteratorBase(
+    const Value::ObjectValues::iterator& current)
+    : current_(current), isNull_(false) {}
+
+Value& ValueIteratorBase::deref() { return current_->second; }
+const Value& ValueIteratorBase::deref() const { return current_->second; }
+
+void ValueIteratorBase::increment() { ++current_; }
+
+void ValueIteratorBase::decrement() { --current_; }
+
+ValueIteratorBase::difference_type
+ValueIteratorBase::computeDistance(const SelfType& other) const {
+  // Iterator for null value are initialized using the default
+  // constructor, which initialize current_ to the default
+  // std::map::iterator. As begin() and end() are two instance
+  // of the default std::map::iterator, they can not be compared.
+  // To allow this, we handle this comparison specifically.
+  if (isNull_ && other.isNull_) {
+    return 0;
+  }
+
+  // Usage of std::distance is not portable (does not compile with Sun Studio 12
+  // RogueWave STL,
+  // which is the one used by default).
+  // Using a portable hand-made version for non random iterator instead:
+  //   return difference_type( std::distance( current_, other.current_ ) );
+  difference_type myDistance = 0;
+  for (Value::ObjectValues::iterator it = current_; it != other.current_;
+       ++it) {
+    ++myDistance;
+  }
+  return myDistance;
+}
+
+bool ValueIteratorBase::isEqual(const SelfType& other) const {
+  if (isNull_) {
+    return other.isNull_;
+  }
+  return current_ == other.current_;
+}
+
+void ValueIteratorBase::copy(const SelfType& other) {
+  current_ = other.current_;
+  isNull_ = other.isNull_;
+}
+
+Value ValueIteratorBase::key() const {
+  const Value::CZString czstring = (*current_).first;
+  if (czstring.data()) {
+    if (czstring.isStaticString())
+      return Value(StaticString(czstring.data()));
+    return Value(czstring.data(), czstring.data() + czstring.length());
+  }
+  return Value(czstring.index());
+}
+
+UInt ValueIteratorBase::index() const {
+  const Value::CZString czstring = (*current_).first;
+  if (!czstring.data())
+    return czstring.index();
+  return Value::UInt(-1);
+}
+
+String ValueIteratorBase::name() const {
+  char const* keey;
+  char const* end;
+  keey = memberName(&end);
+  if (!keey)
+    return String();
+  return String(keey, end);
+}
+
+char const* ValueIteratorBase::memberName() const {
+  const char* cname = (*current_).first.data();
+  return cname ? cname : "";
+}
+
+char const* ValueIteratorBase::memberName(char const** end) const {
+  const char* cname = (*current_).first.data();
+  if (!cname) {
+    *end = nullptr;
+    return nullptr;
+  }
+  *end = cname + (*current_).first.length();
+  return cname;
+}
+
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// class ValueConstIterator
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+
+ValueConstIterator::ValueConstIterator() = default;
+
+ValueConstIterator::ValueConstIterator(
+    const Value::ObjectValues::iterator& current)
+    : ValueIteratorBase(current) {}
+
+ValueConstIterator::ValueConstIterator(ValueIterator const& other)
+    : ValueIteratorBase(other) {}
+
+ValueConstIterator& ValueConstIterator::
+operator=(const ValueIteratorBase& other) {
+  copy(other);
+  return *this;
+}
+
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// class ValueIterator
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+
+ValueIterator::ValueIterator() = default;
+
+ValueIterator::ValueIterator(const Value::ObjectValues::iterator& current)
+    : ValueIteratorBase(current) {}
+
+ValueIterator::ValueIterator(const ValueConstIterator& other)
+    : ValueIteratorBase(other) {
+  throwRuntimeError("ConstIterator to Iterator should never be allowed.");
+}
+
+ValueIterator::ValueIterator(const ValueIterator& other) = default;
+
+ValueIterator& ValueIterator::operator=(const SelfType& other) {
+  copy(other);
+  return *this;
+}
+
+} // namespace Json
diff --git a/3rdparty/jsoncpp/src/src/lib_json/json_writer.cpp b/3rdparty/jsoncpp/src/src/lib_json/json_writer.cpp
new file mode 100644
index 00000000..239c429a
--- /dev/null
+++ b/3rdparty/jsoncpp/src/src/lib_json/json_writer.cpp
@@ -0,0 +1,1260 @@
+// Copyright 2011 Baptiste Lepilleur and The JsonCpp Authors
+// Distributed under MIT license, or public domain if desired and
+// recognized in your jurisdiction.
+// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+#if !defined(JSON_IS_AMALGAMATION)
+#include "json_tool.h"
+#include <json/writer.h>
+#endif // if !defined(JSON_IS_AMALGAMATION)
+#include <algorithm>
+#include <cassert>
+#include <cctype>
+#include <cstring>
+#include <iomanip>
+#include <memory>
+#include <set>
+#include <sstream>
+#include <utility>
+
+#if __cplusplus >= 201103L
+#include <cmath>
+#include <cstdio>
+
+#if !defined(isnan)
+#define isnan std::isnan
+#endif
+
+#if !defined(isfinite)
+#define isfinite std::isfinite
+#endif
+
+#else
+#include <cmath>
+#include <cstdio>
+
+#if defined(_MSC_VER)
+#if !defined(isnan)
+#include <float.h>
+#define isnan _isnan
+#endif
+
+#if !defined(isfinite)
+#include <float.h>
+#define isfinite _finite
+#endif
+
+#if !defined(_CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES)
+#define _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES 1
+#endif //_CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES
+
+#endif //_MSC_VER
+
+#if defined(__sun) && defined(__SVR4) // Solaris
+#if !defined(isfinite)
+#include <ieeefp.h>
+#define isfinite finite
+#endif
+#endif
+
+#if defined(__hpux)
+#if !defined(isfinite)
+#if defined(__ia64) && !defined(finite)
+#define isfinite(x)                                                            \
+  ((sizeof(x) == sizeof(float) ? _Isfinitef(x) : _IsFinite(x)))
+#endif
+#endif
+#endif
+
+#if !defined(isnan)
+// IEEE standard states that NaN values will not compare to themselves
+#define isnan(x) ((x) != (x))
+#endif
+
+#if !defined(__APPLE__)
+#if !defined(isfinite)
+#define isfinite finite
+#endif
+#endif
+#endif
+
+#if defined(_MSC_VER)
+// Disable warning about strdup being deprecated.
+#pragma warning(disable : 4996)
+#endif
+
+namespace Json {
+
+#if __cplusplus >= 201103L || (defined(_CPPLIB_VER) && _CPPLIB_VER >= 520)
+using StreamWriterPtr = std::unique_ptr<StreamWriter>;
+#else
+using StreamWriterPtr = std::auto_ptr<StreamWriter>;
+#endif
+
+String valueToString(LargestInt value) {
+  UIntToStringBuffer buffer;
+  char* current = buffer + sizeof(buffer);
+  if (value == Value::minLargestInt) {
+    uintToString(LargestUInt(Value::maxLargestInt) + 1, current);
+    *--current = '-';
+  } else if (value < 0) {
+    uintToString(LargestUInt(-value), current);
+    *--current = '-';
+  } else {
+    uintToString(LargestUInt(value), current);
+  }
+  assert(current >= buffer);
+  return current;
+}
+
+String valueToString(LargestUInt value) {
+  UIntToStringBuffer buffer;
+  char* current = buffer + sizeof(buffer);
+  uintToString(value, current);
+  assert(current >= buffer);
+  return current;
+}
+
+#if defined(JSON_HAS_INT64)
+
+String valueToString(Int value) { return valueToString(LargestInt(value)); }
+
+String valueToString(UInt value) { return valueToString(LargestUInt(value)); }
+
+#endif // # if defined(JSON_HAS_INT64)
+
+namespace {
+String valueToString(double value, bool useSpecialFloats,
+                     unsigned int precision, PrecisionType precisionType) {
+  // Print into the buffer. We need not request the alternative representation
+  // that always has a decimal point because JSON doesn't distinguish the
+  // concepts of reals and integers.
+  if (!isfinite(value)) {
+    static const char* const reps[2][3] = {{"NaN", "-Infinity", "Infinity"},
+                                           {"null", "-1e+9999", "1e+9999"}};
+    return reps[useSpecialFloats ? 0 : 1][isnan(value)  ? 0
+                                          : (value < 0) ? 1
+                                                        : 2];
+  }
+
+  String buffer(size_t(36), '\0');
+  while (true) {
+    int len = jsoncpp_snprintf(
+        &*buffer.begin(), buffer.size(),
+        (precisionType == PrecisionType::significantDigits) ? "%.*g" : "%.*f",
+        precision, value);
+    assert(len >= 0);
+    auto wouldPrint = static_cast<size_t>(len);
+    if (wouldPrint >= buffer.size()) {
+      buffer.resize(wouldPrint + 1);
+      continue;
+    }
+    buffer.resize(wouldPrint);
+    break;
+  }
+
+  buffer.erase(fixNumericLocale(buffer.begin(), buffer.end()), buffer.end());
+
+  // try to ensure we preserve the fact that this was given to us as a double on
+  // input
+  if (buffer.find('.') == buffer.npos && buffer.find('e') == buffer.npos) {
+    buffer += ".0";
+  }
+
+  // strip the zero padding from the right
+  if (precisionType == PrecisionType::decimalPlaces) {
+    buffer.erase(fixZerosInTheEnd(buffer.begin(), buffer.end(), precision),
+                 buffer.end());
+  }
+
+  return buffer;
+}
+} // namespace
+
+String valueToString(double value, unsigned int precision,
+                     PrecisionType precisionType) {
+  return valueToString(value, false, precision, precisionType);
+}
+
+String valueToString(bool value) { return value ? "true" : "false"; }
+
+static bool doesAnyCharRequireEscaping(char const* s, size_t n) {
+  assert(s || !n);
+
+  return std::any_of(s, s + n, [](unsigned char c) {
+    return c == '\\' || c == '"' || c < 0x20 || c > 0x7F;
+  });
+}
+
+static unsigned int utf8ToCodepoint(const char*& s, const char* e) {
+  const unsigned int REPLACEMENT_CHARACTER = 0xFFFD;
+
+  unsigned int firstByte = static_cast<unsigned char>(*s);
+
+  if (firstByte < 0x80)
+    return firstByte;
+
+  if (firstByte < 0xE0) {
+    if (e - s < 2)
+      return REPLACEMENT_CHARACTER;
+
+    unsigned int calculated =
+        ((firstByte & 0x1F) << 6) | (static_cast<unsigned int>(s[1]) & 0x3F);
+    s += 1;
+    // oversized encoded characters are invalid
+    return calculated < 0x80 ? REPLACEMENT_CHARACTER : calculated;
+  }
+
+  if (firstByte < 0xF0) {
+    if (e - s < 3)
+      return REPLACEMENT_CHARACTER;
+
+    unsigned int calculated = ((firstByte & 0x0F) << 12) |
+                              ((static_cast<unsigned int>(s[1]) & 0x3F) << 6) |
+                              (static_cast<unsigned int>(s[2]) & 0x3F);
+    s += 2;
+    // surrogates aren't valid codepoints itself
+    // shouldn't be UTF-8 encoded
+    if (calculated >= 0xD800 && calculated <= 0xDFFF)
+      return REPLACEMENT_CHARACTER;
+    // oversized encoded characters are invalid
+    return calculated < 0x800 ? REPLACEMENT_CHARACTER : calculated;
+  }
+
+  if (firstByte < 0xF8) {
+    if (e - s < 4)
+      return REPLACEMENT_CHARACTER;
+
+    unsigned int calculated = ((firstByte & 0x07) << 18) |
+                              ((static_cast<unsigned int>(s[1]) & 0x3F) << 12) |
+                              ((static_cast<unsigned int>(s[2]) & 0x3F) << 6) |
+                              (static_cast<unsigned int>(s[3]) & 0x3F);
+    s += 3;
+    // oversized encoded characters are invalid
+    return calculated < 0x10000 ? REPLACEMENT_CHARACTER : calculated;
+  }
+
+  return REPLACEMENT_CHARACTER;
+}
+
+static const char hex2[] = "000102030405060708090a0b0c0d0e0f"
+                           "101112131415161718191a1b1c1d1e1f"
+                           "202122232425262728292a2b2c2d2e2f"
+                           "303132333435363738393a3b3c3d3e3f"
+                           "404142434445464748494a4b4c4d4e4f"
+                           "505152535455565758595a5b5c5d5e5f"
+                           "606162636465666768696a6b6c6d6e6f"
+                           "707172737475767778797a7b7c7d7e7f"
+                           "808182838485868788898a8b8c8d8e8f"
+                           "909192939495969798999a9b9c9d9e9f"
+                           "a0a1a2a3a4a5a6a7a8a9aaabacadaeaf"
+                           "b0b1b2b3b4b5b6b7b8b9babbbcbdbebf"
+                           "c0c1c2c3c4c5c6c7c8c9cacbcccdcecf"
+                           "d0d1d2d3d4d5d6d7d8d9dadbdcdddedf"
+                           "e0e1e2e3e4e5e6e7e8e9eaebecedeeef"
+                           "f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff";
+
+static String toHex16Bit(unsigned int x) {
+  const unsigned int hi = (x >> 8) & 0xff;
+  const unsigned int lo = x & 0xff;
+  String result(4, ' ');
+  result[0] = hex2[2 * hi];
+  result[1] = hex2[2 * hi + 1];
+  result[2] = hex2[2 * lo];
+  result[3] = hex2[2 * lo + 1];
+  return result;
+}
+
+static void appendRaw(String& result, unsigned ch) {
+  result += static_cast<char>(ch);
+}
+
+static void appendHex(String& result, unsigned ch) {
+  result.append("\\u").append(toHex16Bit(ch));
+}
+
+static String valueToQuotedStringN(const char* value, size_t length,
+                                   bool emitUTF8 = false) {
+  if (value == nullptr)
+    return "";
+
+  if (!doesAnyCharRequireEscaping(value, length))
+    return String("\"") + value + "\"";
+  // We have to walk value and escape any special characters.
+  // Appending to String is not efficient, but this should be rare.
+  // (Note: forward slashes are *not* rare, but I am not escaping them.)
+  String::size_type maxsize = length * 2 + 3; // allescaped+quotes+NULL
+  String result;
+  result.reserve(maxsize); // to avoid lots of mallocs
+  result += "\"";
+  char const* end = value + length;
+  for (const char* c = value; c != end; ++c) {
+    switch (*c) {
+    case '\"':
+      result += "\\\"";
+      break;
+    case '\\':
+      result += "\\\\";
+      break;
+    case '\b':
+      result += "\\b";
+      break;
+    case '\f':
+      result += "\\f";
+      break;
+    case '\n':
+      result += "\\n";
+      break;
+    case '\r':
+      result += "\\r";
+      break;
+    case '\t':
+      result += "\\t";
+      break;
+    // case '/':
+    // Even though \/ is considered a legal escape in JSON, a bare
+    // slash is also legal, so I see no reason to escape it.
+    // (I hope I am not misunderstanding something.)
+    // blep notes: actually escaping \/ may be useful in javascript to avoid </
+    // sequence.
+    // Should add a flag to allow this compatibility mode and prevent this
+    // sequence from occurring.
+    default: {
+      if (emitUTF8) {
+        unsigned codepoint = static_cast<unsigned char>(*c);
+        if (codepoint < 0x20) {
+          appendHex(result, codepoint);
+        } else {
+          appendRaw(result, codepoint);
+        }
+      } else {
+        unsigned codepoint = utf8ToCodepoint(c, end); // modifies `c`
+        if (codepoint < 0x20) {
+          appendHex(result, codepoint);
+        } else if (codepoint < 0x80) {
+          appendRaw(result, codepoint);
+        } else if (codepoint < 0x10000) {
+          // Basic Multilingual Plane
+          appendHex(result, codepoint);
+        } else {
+          // Extended Unicode. Encode 20 bits as a surrogate pair.
+          codepoint -= 0x10000;
+          appendHex(result, 0xd800 + ((codepoint >> 10) & 0x3ff));
+          appendHex(result, 0xdc00 + (codepoint & 0x3ff));
+        }
+      }
+    } break;
+    }
+  }
+  result += "\"";
+  return result;
+}
+
+String valueToQuotedString(const char* value) {
+  return valueToQuotedStringN(value, strlen(value));
+}
+
+// Class Writer
+// //////////////////////////////////////////////////////////////////
+Writer::~Writer() = default;
+
+// Class FastWriter
+// //////////////////////////////////////////////////////////////////
+
+FastWriter::FastWriter()
+
+    = default;
+
+void FastWriter::enableYAMLCompatibility() { yamlCompatibilityEnabled_ = true; }
+
+void FastWriter::dropNullPlaceholders() { dropNullPlaceholders_ = true; }
+
+void FastWriter::omitEndingLineFeed() { omitEndingLineFeed_ = true; }
+
+String FastWriter::write(const Value& root) {
+  document_.clear();
+  writeValue(root);
+  if (!omitEndingLineFeed_)
+    document_ += '\n';
+  return document_;
+}
+
+void FastWriter::writeValue(const Value& value) {
+  switch (value.type()) {
+  case nullValue:
+    if (!dropNullPlaceholders_)
+      document_ += "null";
+    break;
+  case intValue:
+    document_ += valueToString(value.asLargestInt());
+    break;
+  case uintValue:
+    document_ += valueToString(value.asLargestUInt());
+    break;
+  case realValue:
+    document_ += valueToString(value.asDouble());
+    break;
+  case stringValue: {
+    // Is NULL possible for value.string_? No.
+    char const* str;
+    char const* end;
+    bool ok = value.getString(&str, &end);
+    if (ok)
+      document_ += valueToQuotedStringN(str, static_cast<size_t>(end - str));
+    break;
+  }
+  case booleanValue:
+    document_ += valueToString(value.asBool());
+    break;
+  case arrayValue: {
+    document_ += '[';
+    ArrayIndex size = value.size();
+    for (ArrayIndex index = 0; index < size; ++index) {
+      if (index > 0)
+        document_ += ',';
+      writeValue(value[index]);
+    }
+    document_ += ']';
+  } break;
+  case objectValue: {
+    Value::Members members(value.getMemberNames());
+    document_ += '{';
+    for (auto it = members.begin(); it != members.end(); ++it) {
+      const String& name = *it;
+      if (it != members.begin())
+        document_ += ',';
+      document_ += valueToQuotedStringN(name.data(), name.length());
+      document_ += yamlCompatibilityEnabled_ ? ": " : ":";
+      writeValue(value[name]);
+    }
+    document_ += '}';
+  } break;
+  }
+}
+
+// Class StyledWriter
+// //////////////////////////////////////////////////////////////////
+
+StyledWriter::StyledWriter() = default;
+
+String StyledWriter::write(const Value& root) {
+  document_.clear();
+  addChildValues_ = false;
+  indentString_.clear();
+  writeCommentBeforeValue(root);
+  writeValue(root);
+  writeCommentAfterValueOnSameLine(root);
+  document_ += '\n';
+  return document_;
+}
+
+void StyledWriter::writeValue(const Value& value) {
+  switch (value.type()) {
+  case nullValue:
+    pushValue("null");
+    break;
+  case intValue:
+    pushValue(valueToString(value.asLargestInt()));
+    break;
+  case uintValue:
+    pushValue(valueToString(value.asLargestUInt()));
+    break;
+  case realValue:
+    pushValue(valueToString(value.asDouble()));
+    break;
+  case stringValue: {
+    // Is NULL possible for value.string_? No.
+    char const* str;
+    char const* end;
+    bool ok = value.getString(&str, &end);
+    if (ok)
+      pushValue(valueToQuotedStringN(str, static_cast<size_t>(end - str)));
+    else
+      pushValue("");
+    break;
+  }
+  case booleanValue:
+    pushValue(valueToString(value.asBool()));
+    break;
+  case arrayValue:
+    writeArrayValue(value);
+    break;
+  case objectValue: {
+    Value::Members members(value.getMemberNames());
+    if (members.empty())
+      pushValue("{}");
+    else {
+      writeWithIndent("{");
+      indent();
+      auto it = members.begin();
+      for (;;) {
+        const String& name = *it;
+        const Value& childValue = value[name];
+        writeCommentBeforeValue(childValue);
+        writeWithIndent(valueToQuotedString(name.c_str()));
+        document_ += " : ";
+        writeValue(childValue);
+        if (++it == members.end()) {
+          writeCommentAfterValueOnSameLine(childValue);
+          break;
+        }
+        document_ += ',';
+        writeCommentAfterValueOnSameLine(childValue);
+      }
+      unindent();
+      writeWithIndent("}");
+    }
+  } break;
+  }
+}
+
+void StyledWriter::writeArrayValue(const Value& value) {
+  size_t size = value.size();
+  if (size == 0)
+    pushValue("[]");
+  else {
+    bool isArrayMultiLine = isMultilineArray(value);
+    if (isArrayMultiLine) {
+      writeWithIndent("[");
+      indent();
+      bool hasChildValue = !childValues_.empty();
+      ArrayIndex index = 0;
+      for (;;) {
+        const Value& childValue = value[index];
+        writeCommentBeforeValue(childValue);
+        if (hasChildValue)
+          writeWithIndent(childValues_[index]);
+        else {
+          writeIndent();
+          writeValue(childValue);
+        }
+        if (++index == size) {
+          writeCommentAfterValueOnSameLine(childValue);
+          break;
+        }
+        document_ += ',';
+        writeCommentAfterValueOnSameLine(childValue);
+      }
+      unindent();
+      writeWithIndent("]");
+    } else // output on a single line
+    {
+      assert(childValues_.size() == size);
+      document_ += "[ ";
+      for (size_t index = 0; index < size; ++index) {
+        if (index > 0)
+          document_ += ", ";
+        document_ += childValues_[index];
+      }
+      document_ += " ]";
+    }
+  }
+}
+
+bool StyledWriter::isMultilineArray(const Value& value) {
+  ArrayIndex const size = value.size();
+  bool isMultiLine = size * 3 >= rightMargin_;
+  childValues_.clear();
+  for (ArrayIndex index = 0; index < size && !isMultiLine; ++index) {
+    const Value& childValue = value[index];
+    isMultiLine = ((childValue.isArray() || childValue.isObject()) &&
+                   !childValue.empty());
+  }
+  if (!isMultiLine) // check if line length > max line length
+  {
+    childValues_.reserve(size);
+    addChildValues_ = true;
+    ArrayIndex lineLength = 4 + (size - 1) * 2; // '[ ' + ', '*n + ' ]'
+    for (ArrayIndex index = 0; index < size; ++index) {
+      if (hasCommentForValue(value[index])) {
+        isMultiLine = true;
+      }
+      writeValue(value[index]);
+      lineLength += static_cast<ArrayIndex>(childValues_[index].length());
+    }
+    addChildValues_ = false;
+    isMultiLine = isMultiLine || lineLength >= rightMargin_;
+  }
+  return isMultiLine;
+}
+
+void StyledWriter::pushValue(const String& value) {
+  if (addChildValues_)
+    childValues_.push_back(value);
+  else
+    document_ += value;
+}
+
+void StyledWriter::writeIndent() {
+  if (!document_.empty()) {
+    char last = document_[document_.length() - 1];
+    if (last == ' ') // already indented
+      return;
+    if (last != '\n') // Comments may add new-line
+      document_ += '\n';
+  }
+  document_ += indentString_;
+}
+
+void StyledWriter::writeWithIndent(const String& value) {
+  writeIndent();
+  document_ += value;
+}
+
+void StyledWriter::indent() { indentString_ += String(indentSize_, ' '); }
+
+void StyledWriter::unindent() {
+  assert(indentString_.size() >= indentSize_);
+  indentString_.resize(indentString_.size() - indentSize_);
+}
+
+void StyledWriter::writeCommentBeforeValue(const Value& root) {
+  if (!root.hasComment(commentBefore))
+    return;
+
+  document_ += '\n';
+  writeIndent();
+  const String& comment = root.getComment(commentBefore);
+  String::const_iterator iter = comment.begin();
+  while (iter != comment.end()) {
+    document_ += *iter;
+    if (*iter == '\n' && ((iter + 1) != comment.end() && *(iter + 1) == '/'))
+      writeIndent();
+    ++iter;
+  }
+
+  // Comments are stripped of trailing newlines, so add one here
+  document_ += '\n';
+}
+
+void StyledWriter::writeCommentAfterValueOnSameLine(const Value& root) {
+  if (root.hasComment(commentAfterOnSameLine))
+    document_ += " " + root.getComment(commentAfterOnSameLine);
+
+  if (root.hasComment(commentAfter)) {
+    document_ += '\n';
+    document_ += root.getComment(commentAfter);
+    document_ += '\n';
+  }
+}
+
+bool StyledWriter::hasCommentForValue(const Value& value) {
+  return value.hasComment(commentBefore) ||
+         value.hasComment(commentAfterOnSameLine) ||
+         value.hasComment(commentAfter);
+}
+
+// Class StyledStreamWriter
+// //////////////////////////////////////////////////////////////////
+
+StyledStreamWriter::StyledStreamWriter(String indentation)
+    : document_(nullptr), indentation_(std::move(indentation)),
+      addChildValues_(), indented_(false) {}
+
+void StyledStreamWriter::write(OStream& out, const Value& root) {
+  document_ = &out;
+  addChildValues_ = false;
+  indentString_.clear();
+  indented_ = true;
+  writeCommentBeforeValue(root);
+  if (!indented_)
+    writeIndent();
+  indented_ = true;
+  writeValue(root);
+  writeCommentAfterValueOnSameLine(root);
+  *document_ << "\n";
+  document_ = nullptr; // Forget the stream, for safety.
+}
+
+void StyledStreamWriter::writeValue(const Value& value) {
+  switch (value.type()) {
+  case nullValue:
+    pushValue("null");
+    break;
+  case intValue:
+    pushValue(valueToString(value.asLargestInt()));
+    break;
+  case uintValue:
+    pushValue(valueToString(value.asLargestUInt()));
+    break;
+  case realValue:
+    pushValue(valueToString(value.asDouble()));
+    break;
+  case stringValue: {
+    // Is NULL possible for value.string_? No.
+    char const* str;
+    char const* end;
+    bool ok = value.getString(&str, &end);
+    if (ok)
+      pushValue(valueToQuotedStringN(str, static_cast<size_t>(end - str)));
+    else
+      pushValue("");
+    break;
+  }
+  case booleanValue:
+    pushValue(valueToString(value.asBool()));
+    break;
+  case arrayValue:
+    writeArrayValue(value);
+    break;
+  case objectValue: {
+    Value::Members members(value.getMemberNames());
+    if (members.empty())
+      pushValue("{}");
+    else {
+      writeWithIndent("{");
+      indent();
+      auto it = members.begin();
+      for (;;) {
+        const String& name = *it;
+        const Value& childValue = value[name];
+        writeCommentBeforeValue(childValue);
+        writeWithIndent(valueToQuotedString(name.c_str()));
+        *document_ << " : ";
+        writeValue(childValue);
+        if (++it == members.end()) {
+          writeCommentAfterValueOnSameLine(childValue);
+          break;
+        }
+        *document_ << ",";
+        writeCommentAfterValueOnSameLine(childValue);
+      }
+      unindent();
+      writeWithIndent("}");
+    }
+  } break;
+  }
+}
+
+void StyledStreamWriter::writeArrayValue(const Value& value) {
+  unsigned size = value.size();
+  if (size == 0)
+    pushValue("[]");
+  else {
+    bool isArrayMultiLine = isMultilineArray(value);
+    if (isArrayMultiLine) {
+      writeWithIndent("[");
+      indent();
+      bool hasChildValue = !childValues_.empty();
+      unsigned index = 0;
+      for (;;) {
+        const Value& childValue = value[index];
+        writeCommentBeforeValue(childValue);
+        if (hasChildValue)
+          writeWithIndent(childValues_[index]);
+        else {
+          if (!indented_)
+            writeIndent();
+          indented_ = true;
+          writeValue(childValue);
+          indented_ = false;
+        }
+        if (++index == size) {
+          writeCommentAfterValueOnSameLine(childValue);
+          break;
+        }
+        *document_ << ",";
+        writeCommentAfterValueOnSameLine(childValue);
+      }
+      unindent();
+      writeWithIndent("]");
+    } else // output on a single line
+    {
+      assert(childValues_.size() == size);
+      *document_ << "[ ";
+      for (unsigned index = 0; index < size; ++index) {
+        if (index > 0)
+          *document_ << ", ";
+        *document_ << childValues_[index];
+      }
+      *document_ << " ]";
+    }
+  }
+}
+
+bool StyledStreamWriter::isMultilineArray(const Value& value) {
+  ArrayIndex const size = value.size();
+  bool isMultiLine = size * 3 >= rightMargin_;
+  childValues_.clear();
+  for (ArrayIndex index = 0; index < size && !isMultiLine; ++index) {
+    const Value& childValue = value[index];
+    isMultiLine = ((childValue.isArray() || childValue.isObject()) &&
+                   !childValue.empty());
+  }
+  if (!isMultiLine) // check if line length > max line length
+  {
+    childValues_.reserve(size);
+    addChildValues_ = true;
+    ArrayIndex lineLength = 4 + (size - 1) * 2; // '[ ' + ', '*n + ' ]'
+    for (ArrayIndex index = 0; index < size; ++index) {
+      if (hasCommentForValue(value[index])) {
+        isMultiLine = true;
+      }
+      writeValue(value[index]);
+      lineLength += static_cast<ArrayIndex>(childValues_[index].length());
+    }
+    addChildValues_ = false;
+    isMultiLine = isMultiLine || lineLength >= rightMargin_;
+  }
+  return isMultiLine;
+}
+
+void StyledStreamWriter::pushValue(const String& value) {
+  if (addChildValues_)
+    childValues_.push_back(value);
+  else
+    *document_ << value;
+}
+
+void StyledStreamWriter::writeIndent() {
+  // blep intended this to look at the so-far-written string
+  // to determine whether we are already indented, but
+  // with a stream we cannot do that. So we rely on some saved state.
+  // The caller checks indented_.
+  *document_ << '\n' << indentString_;
+}
+
+void StyledStreamWriter::writeWithIndent(const String& value) {
+  if (!indented_)
+    writeIndent();
+  *document_ << value;
+  indented_ = false;
+}
+
+void StyledStreamWriter::indent() { indentString_ += indentation_; }
+
+void StyledStreamWriter::unindent() {
+  assert(indentString_.size() >= indentation_.size());
+  indentString_.resize(indentString_.size() - indentation_.size());
+}
+
+void StyledStreamWriter::writeCommentBeforeValue(const Value& root) {
+  if (!root.hasComment(commentBefore))
+    return;
+
+  if (!indented_)
+    writeIndent();
+  const String& comment = root.getComment(commentBefore);
+  String::const_iterator iter = comment.begin();
+  while (iter != comment.end()) {
+    *document_ << *iter;
+    if (*iter == '\n' && ((iter + 1) != comment.end() && *(iter + 1) == '/'))
+      // writeIndent();  // would include newline
+      *document_ << indentString_;
+    ++iter;
+  }
+  indented_ = false;
+}
+
+void StyledStreamWriter::writeCommentAfterValueOnSameLine(const Value& root) {
+  if (root.hasComment(commentAfterOnSameLine))
+    *document_ << ' ' << root.getComment(commentAfterOnSameLine);
+
+  if (root.hasComment(commentAfter)) {
+    writeIndent();
+    *document_ << root.getComment(commentAfter);
+  }
+  indented_ = false;
+}
+
+bool StyledStreamWriter::hasCommentForValue(const Value& value) {
+  return value.hasComment(commentBefore) ||
+         value.hasComment(commentAfterOnSameLine) ||
+         value.hasComment(commentAfter);
+}
+
+//////////////////////////
+// BuiltStyledStreamWriter
+
+/// Scoped enums are not available until C++11.
+struct CommentStyle {
+  /// Decide whether to write comments.
+  enum Enum {
+    None, ///< Drop all comments.
+    Most, ///< Recover odd behavior of previous versions (not implemented yet).
+    All   ///< Keep all comments.
+  };
+};
+
+struct BuiltStyledStreamWriter : public StreamWriter {
+  BuiltStyledStreamWriter(String indentation, CommentStyle::Enum cs,
+                          String colonSymbol, String nullSymbol,
+                          String endingLineFeedSymbol, bool useSpecialFloats,
+                          bool emitUTF8, unsigned int precision,
+                          PrecisionType precisionType);
+  int write(Value const& root, OStream* sout) override;
+
+private:
+  void writeValue(Value const& value);
+  void writeArrayValue(Value const& value);
+  bool isMultilineArray(Value const& value);
+  void pushValue(String const& value);
+  void writeIndent();
+  void writeWithIndent(String const& value);
+  void indent();
+  void unindent();
+  void writeCommentBeforeValue(Value const& root);
+  void writeCommentAfterValueOnSameLine(Value const& root);
+  static bool hasCommentForValue(const Value& value);
+
+  using ChildValues = std::vector<String>;
+
+  ChildValues childValues_;
+  String indentString_;
+  unsigned int rightMargin_;
+  String indentation_;
+  CommentStyle::Enum cs_;
+  String colonSymbol_;
+  String nullSymbol_;
+  String endingLineFeedSymbol_;
+  bool addChildValues_ : 1;
+  bool indented_ : 1;
+  bool useSpecialFloats_ : 1;
+  bool emitUTF8_ : 1;
+  unsigned int precision_;
+  PrecisionType precisionType_;
+};
+BuiltStyledStreamWriter::BuiltStyledStreamWriter(
+    String indentation, CommentStyle::Enum cs, String colonSymbol,
+    String nullSymbol, String endingLineFeedSymbol, bool useSpecialFloats,
+    bool emitUTF8, unsigned int precision, PrecisionType precisionType)
+    : rightMargin_(74), indentation_(std::move(indentation)), cs_(cs),
+      colonSymbol_(std::move(colonSymbol)), nullSymbol_(std::move(nullSymbol)),
+      endingLineFeedSymbol_(std::move(endingLineFeedSymbol)),
+      addChildValues_(false), indented_(false),
+      useSpecialFloats_(useSpecialFloats), emitUTF8_(emitUTF8),
+      precision_(precision), precisionType_(precisionType) {}
+int BuiltStyledStreamWriter::write(Value const& root, OStream* sout) {
+  sout_ = sout;
+  addChildValues_ = false;
+  indented_ = true;
+  indentString_.clear();
+  writeCommentBeforeValue(root);
+  if (!indented_)
+    writeIndent();
+  indented_ = true;
+  writeValue(root);
+  writeCommentAfterValueOnSameLine(root);
+  *sout_ << endingLineFeedSymbol_;
+  sout_ = nullptr;
+  return 0;
+}
+void BuiltStyledStreamWriter::writeValue(Value const& value) {
+  switch (value.type()) {
+  case nullValue:
+    pushValue(nullSymbol_);
+    break;
+  case intValue:
+    pushValue(valueToString(value.asLargestInt()));
+    break;
+  case uintValue:
+    pushValue(valueToString(value.asLargestUInt()));
+    break;
+  case realValue:
+    pushValue(valueToString(value.asDouble(), useSpecialFloats_, precision_,
+                            precisionType_));
+    break;
+  case stringValue: {
+    // Is NULL is possible for value.string_? No.
+    char const* str;
+    char const* end;
+    bool ok = value.getString(&str, &end);
+    if (ok)
+      pushValue(
+          valueToQuotedStringN(str, static_cast<size_t>(end - str), emitUTF8_));
+    else
+      pushValue("");
+    break;
+  }
+  case booleanValue:
+    pushValue(valueToString(value.asBool()));
+    break;
+  case arrayValue:
+    writeArrayValue(value);
+    break;
+  case objectValue: {
+    Value::Members members(value.getMemberNames());
+    if (members.empty())
+      pushValue("{}");
+    else {
+      writeWithIndent("{");
+      indent();
+      auto it = members.begin();
+      for (;;) {
+        String const& name = *it;
+        Value const& childValue = value[name];
+        writeCommentBeforeValue(childValue);
+        writeWithIndent(
+            valueToQuotedStringN(name.data(), name.length(), emitUTF8_));
+        *sout_ << colonSymbol_;
+        writeValue(childValue);
+        if (++it == members.end()) {
+          writeCommentAfterValueOnSameLine(childValue);
+          break;
+        }
+        *sout_ << ",";
+        writeCommentAfterValueOnSameLine(childValue);
+      }
+      unindent();
+      writeWithIndent("}");
+    }
+  } break;
+  }
+}
+
+void BuiltStyledStreamWriter::writeArrayValue(Value const& value) {
+  unsigned size = value.size();
+  if (size == 0)
+    pushValue("[]");
+  else {
+    bool isMultiLine = (cs_ == CommentStyle::All) || isMultilineArray(value);
+    if (isMultiLine) {
+      writeWithIndent("[");
+      indent();
+      bool hasChildValue = !childValues_.empty();
+      unsigned index = 0;
+      for (;;) {
+        Value const& childValue = value[index];
+        writeCommentBeforeValue(childValue);
+        if (hasChildValue)
+          writeWithIndent(childValues_[index]);
+        else {
+          if (!indented_)
+            writeIndent();
+          indented_ = true;
+          writeValue(childValue);
+          indented_ = false;
+        }
+        if (++index == size) {
+          writeCommentAfterValueOnSameLine(childValue);
+          break;
+        }
+        *sout_ << ",";
+        writeCommentAfterValueOnSameLine(childValue);
+      }
+      unindent();
+      writeWithIndent("]");
+    } else // output on a single line
+    {
+      assert(childValues_.size() == size);
+      *sout_ << "[";
+      if (!indentation_.empty())
+        *sout_ << " ";
+      for (unsigned index = 0; index < size; ++index) {
+        if (index > 0)
+          *sout_ << ((!indentation_.empty()) ? ", " : ",");
+        *sout_ << childValues_[index];
+      }
+      if (!indentation_.empty())
+        *sout_ << " ";
+      *sout_ << "]";
+    }
+  }
+}
+
+bool BuiltStyledStreamWriter::isMultilineArray(Value const& value) {
+  ArrayIndex const size = value.size();
+  bool isMultiLine = size * 3 >= rightMargin_;
+  childValues_.clear();
+  for (ArrayIndex index = 0; index < size && !isMultiLine; ++index) {
+    Value const& childValue = value[index];
+    isMultiLine = ((childValue.isArray() || childValue.isObject()) &&
+                   !childValue.empty());
+  }
+  if (!isMultiLine) // check if line length > max line length
+  {
+    childValues_.reserve(size);
+    addChildValues_ = true;
+    ArrayIndex lineLength = 4 + (size - 1) * 2; // '[ ' + ', '*n + ' ]'
+    for (ArrayIndex index = 0; index < size; ++index) {
+      if (hasCommentForValue(value[index])) {
+        isMultiLine = true;
+      }
+      writeValue(value[index]);
+      lineLength += static_cast<ArrayIndex>(childValues_[index].length());
+    }
+    addChildValues_ = false;
+    isMultiLine = isMultiLine || lineLength >= rightMargin_;
+  }
+  return isMultiLine;
+}
+
+void BuiltStyledStreamWriter::pushValue(String const& value) {
+  if (addChildValues_)
+    childValues_.push_back(value);
+  else
+    *sout_ << value;
+}
+
+void BuiltStyledStreamWriter::writeIndent() {
+  // blep intended this to look at the so-far-written string
+  // to determine whether we are already indented, but
+  // with a stream we cannot do that. So we rely on some saved state.
+  // The caller checks indented_.
+
+  if (!indentation_.empty()) {
+    // In this case, drop newlines too.
+    *sout_ << '\n' << indentString_;
+  }
+}
+
+void BuiltStyledStreamWriter::writeWithIndent(String const& value) {
+  if (!indented_)
+    writeIndent();
+  *sout_ << value;
+  indented_ = false;
+}
+
+void BuiltStyledStreamWriter::indent() { indentString_ += indentation_; }
+
+void BuiltStyledStreamWriter::unindent() {
+  assert(indentString_.size() >= indentation_.size());
+  indentString_.resize(indentString_.size() - indentation_.size());
+}
+
+void BuiltStyledStreamWriter::writeCommentBeforeValue(Value const& root) {
+  if (cs_ == CommentStyle::None)
+    return;
+  if (!root.hasComment(commentBefore))
+    return;
+
+  if (!indented_)
+    writeIndent();
+  const String& comment = root.getComment(commentBefore);
+  String::const_iterator iter = comment.begin();
+  while (iter != comment.end()) {
+    *sout_ << *iter;
+    if (*iter == '\n' && ((iter + 1) != comment.end() && *(iter + 1) == '/'))
+      // writeIndent();  // would write extra newline
+      *sout_ << indentString_;
+    ++iter;
+  }
+  indented_ = false;
+}
+
+void BuiltStyledStreamWriter::writeCommentAfterValueOnSameLine(
+    Value const& root) {
+  if (cs_ == CommentStyle::None)
+    return;
+  if (root.hasComment(commentAfterOnSameLine))
+    *sout_ << " " + root.getComment(commentAfterOnSameLine);
+
+  if (root.hasComment(commentAfter)) {
+    writeIndent();
+    *sout_ << root.getComment(commentAfter);
+  }
+}
+
+// static
+bool BuiltStyledStreamWriter::hasCommentForValue(const Value& value) {
+  return value.hasComment(commentBefore) ||
+         value.hasComment(commentAfterOnSameLine) ||
+         value.hasComment(commentAfter);
+}
+
+///////////////
+// StreamWriter
+
+StreamWriter::StreamWriter() : sout_(nullptr) {}
+StreamWriter::~StreamWriter() = default;
+StreamWriter::Factory::~Factory() = default;
+StreamWriterBuilder::StreamWriterBuilder() { setDefaults(&settings_); }
+StreamWriterBuilder::~StreamWriterBuilder() = default;
+StreamWriter* StreamWriterBuilder::newStreamWriter() const {
+  const String indentation = settings_["indentation"].asString();
+  const String cs_str = settings_["commentStyle"].asString();
+  const String pt_str = settings_["precisionType"].asString();
+  const bool eyc = settings_["enableYAMLCompatibility"].asBool();
+  const bool dnp = settings_["dropNullPlaceholders"].asBool();
+  const bool usf = settings_["useSpecialFloats"].asBool();
+  const bool emitUTF8 = settings_["emitUTF8"].asBool();
+  unsigned int pre = settings_["precision"].asUInt();
+  CommentStyle::Enum cs = CommentStyle::All;
+  if (cs_str == "All") {
+    cs = CommentStyle::All;
+  } else if (cs_str == "None") {
+    cs = CommentStyle::None;
+  } else {
+    throwRuntimeError("commentStyle must be 'All' or 'None'");
+  }
+  PrecisionType precisionType(significantDigits);
+  if (pt_str == "significant") {
+    precisionType = PrecisionType::significantDigits;
+  } else if (pt_str == "decimal") {
+    precisionType = PrecisionType::decimalPlaces;
+  } else {
+    throwRuntimeError("precisionType must be 'significant' or 'decimal'");
+  }
+  String colonSymbol = " : ";
+  if (eyc) {
+    colonSymbol = ": ";
+  } else if (indentation.empty()) {
+    colonSymbol = ":";
+  }
+  String nullSymbol = "null";
+  if (dnp) {
+    nullSymbol.clear();
+  }
+  if (pre > 17)
+    pre = 17;
+  String endingLineFeedSymbol;
+  return new BuiltStyledStreamWriter(indentation, cs, colonSymbol, nullSymbol,
+                                     endingLineFeedSymbol, usf, emitUTF8, pre,
+                                     precisionType);
+}
+
+bool StreamWriterBuilder::validate(Json::Value* invalid) const {
+  static const auto& valid_keys = *new std::set<String>{
+      "indentation",
+      "commentStyle",
+      "enableYAMLCompatibility",
+      "dropNullPlaceholders",
+      "useSpecialFloats",
+      "emitUTF8",
+      "precision",
+      "precisionType",
+  };
+  for (auto si = settings_.begin(); si != settings_.end(); ++si) {
+    auto key = si.name();
+    if (valid_keys.count(key))
+      continue;
+    if (invalid)
+      (*invalid)[key] = *si;
+    else
+      return false;
+  }
+  return invalid ? invalid->empty() : true;
+}
+
+Value& StreamWriterBuilder::operator[](const String& key) {
+  return settings_[key];
+}
+// static
+void StreamWriterBuilder::setDefaults(Json::Value* settings) {
+  //! [StreamWriterBuilderDefaults]
+  (*settings)["commentStyle"] = "All";
+  (*settings)["indentation"] = "\t";
+  (*settings)["enableYAMLCompatibility"] = false;
+  (*settings)["dropNullPlaceholders"] = false;
+  (*settings)["useSpecialFloats"] = false;
+  (*settings)["emitUTF8"] = false;
+  (*settings)["precision"] = 17;
+  (*settings)["precisionType"] = "significant";
+  //! [StreamWriterBuilderDefaults]
+}
+
+String writeString(StreamWriter::Factory const& factory, Value const& root) {
+  OStringStream sout;
+  StreamWriterPtr const writer(factory.newStreamWriter());
+  writer->write(root, &sout);
+  return sout.str();
+}
+
+OStream& operator<<(OStream& sout, Value const& root) {
+  StreamWriterBuilder builder;
+  StreamWriterPtr const writer(builder.newStreamWriter());
+  writer->write(root, &sout);
+  return sout;
+}
+
+} // namespace Json
diff --git a/3rdparty/jsoncpp/src/src/test_lib_json/CMakeLists.txt b/3rdparty/jsoncpp/src/src/test_lib_json/CMakeLists.txt
new file mode 100644
index 00000000..1c3fce91
--- /dev/null
+++ b/3rdparty/jsoncpp/src/src/test_lib_json/CMakeLists.txt
@@ -0,0 +1,39 @@
+# vim: et ts=4 sts=4 sw=4 tw=0
+
+add_executable(jsoncpp_test
+    jsontest.cpp
+    jsontest.h
+    fuzz.cpp
+    fuzz.h
+    main.cpp
+)
+
+
+if(BUILD_SHARED_LIBS)
+    if(CMAKE_VERSION VERSION_GREATER_EQUAL 3.12.0)
+        add_compile_definitions( JSON_DLL )
+    else()
+        add_definitions( -DJSON_DLL )
+    endif()
+    target_link_libraries(jsoncpp_test jsoncpp_lib)
+else()
+    target_link_libraries(jsoncpp_test jsoncpp_static)
+endif()
+
+# another way to solve issue #90
+#set_target_properties(jsoncpp_test PROPERTIES COMPILE_FLAGS -ffloat-store)
+
+## Create tests for dashboard submission, allows easy review of CI results https://my.cdash.org/index.php?project=jsoncpp
+add_test(NAME jsoncpp_test
+    COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:jsoncpp_test>
+)
+set_target_properties(jsoncpp_test PROPERTIES OUTPUT_NAME jsoncpp_test)
+
+# Run unit tests in post-build
+# (default cmake workflow hides away the test result into a file, resulting in poor dev workflow?!?)
+if(JSONCPP_WITH_POST_BUILD_UNITTEST)
+    add_custom_command(TARGET jsoncpp_test
+        POST_BUILD
+        COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:jsoncpp_test>
+    )
+endif()
diff --git a/3rdparty/jsoncpp/src/src/test_lib_json/fuzz.cpp b/3rdparty/jsoncpp/src/src/test_lib_json/fuzz.cpp
new file mode 100644
index 00000000..5b75c22e
--- /dev/null
+++ b/3rdparty/jsoncpp/src/src/test_lib_json/fuzz.cpp
@@ -0,0 +1,54 @@
+// Copyright 2007-2019 The JsonCpp Authors
+// Distributed under MIT license, or public domain if desired and
+// recognized in your jurisdiction.
+// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+#include "fuzz.h"
+
+#include <cstdint>
+#include <json/config.h>
+#include <json/json.h>
+#include <memory>
+#include <string>
+
+namespace Json {
+class Exception;
+}
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
+  Json::CharReaderBuilder builder;
+
+  if (size < sizeof(uint32_t)) {
+    return 0;
+  }
+
+  const uint32_t hash_settings = static_cast<uint32_t>(data[0]) |
+                                 (static_cast<uint32_t>(data[1]) << 8) |
+                                 (static_cast<uint32_t>(data[2]) << 16) |
+                                 (static_cast<uint32_t>(data[3]) << 24);
+  data += sizeof(uint32_t);
+  size -= sizeof(uint32_t);
+
+  builder.settings_["failIfExtra"] = hash_settings & (1 << 0);
+  builder.settings_["allowComments_"] = hash_settings & (1 << 1);
+  builder.settings_["strictRoot_"] = hash_settings & (1 << 2);
+  builder.settings_["allowDroppedNullPlaceholders_"] = hash_settings & (1 << 3);
+  builder.settings_["allowNumericKeys_"] = hash_settings & (1 << 4);
+  builder.settings_["allowSingleQuotes_"] = hash_settings & (1 << 5);
+  builder.settings_["failIfExtra_"] = hash_settings & (1 << 6);
+  builder.settings_["rejectDupKeys_"] = hash_settings & (1 << 7);
+  builder.settings_["allowSpecialFloats_"] = hash_settings & (1 << 8);
+  builder.settings_["collectComments"] = hash_settings & (1 << 9);
+  builder.settings_["allowTrailingCommas_"] = hash_settings & (1 << 10);
+
+  std::unique_ptr<Json::CharReader> reader(builder.newCharReader());
+
+  Json::Value root;
+  const auto data_str = reinterpret_cast<const char*>(data);
+  try {
+    reader->parse(data_str, data_str + size, &root, nullptr);
+  } catch (Json::Exception const&) {
+  }
+  // Whether it succeeded or not doesn't matter.
+  return 0;
+}
diff --git a/3rdparty/jsoncpp/src/src/test_lib_json/fuzz.dict b/3rdparty/jsoncpp/src/src/test_lib_json/fuzz.dict
new file mode 100644
index 00000000..725423d2
--- /dev/null
+++ b/3rdparty/jsoncpp/src/src/test_lib_json/fuzz.dict
@@ -0,0 +1,54 @@
+#
+# AFL dictionary for JSON
+# -----------------------
+#
+# Just the very basics.
+#
+# Inspired by a dictionary by Jakub Wilk <jwilk@jwilk.net>
+#
+# https://github.com/rc0r/afl-fuzz/blob/master/dictionaries/json.dict
+#
+
+"0"
+",0"
+":0"
+"0:"
+"-1.2e+3"
+
+"true"
+"false"
+"null"
+
+"\"\""
+",\"\""
+":\"\""
+"\"\":"
+
+"{}"
+",{}"
+":{}"
+"{\"\":0}"
+"{{}}"
+
+"[]"
+",[]"
+":[]"
+"[0]"
+"[[]]"
+
+"''"
+"\\"
+"\\b"
+"\\f"
+"\\n"
+"\\r"
+"\\t"
+"\\u0000"
+"\\x00"
+"\\0"
+"\\uD800\\uDC00"
+"\\uDBFF\\uDFFF"
+
+"\"\":0"
+"//"
+"/**/"
diff --git a/3rdparty/jsoncpp/src/src/test_lib_json/fuzz.h b/3rdparty/jsoncpp/src/src/test_lib_json/fuzz.h
new file mode 100644
index 00000000..0816d275
--- /dev/null
+++ b/3rdparty/jsoncpp/src/src/test_lib_json/fuzz.h
@@ -0,0 +1,14 @@
+// Copyright 2007-2010 The JsonCpp Authors
+// Distributed under MIT license, or public domain if desired and
+// recognized in your jurisdiction.
+// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+#ifndef FUZZ_H_INCLUDED
+#define FUZZ_H_INCLUDED
+
+#include <cstddef>
+#include <stdint.h>
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size);
+
+#endif // ifndef FUZZ_H_INCLUDED
diff --git a/3rdparty/jsoncpp/src/src/test_lib_json/jsontest.cpp b/3rdparty/jsoncpp/src/src/test_lib_json/jsontest.cpp
new file mode 100644
index 00000000..0b7d12b9
--- /dev/null
+++ b/3rdparty/jsoncpp/src/src/test_lib_json/jsontest.cpp
@@ -0,0 +1,430 @@
+// Copyright 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
+// Distributed under MIT license, or public domain if desired and
+// recognized in your jurisdiction.
+// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+#define _CRT_SECURE_NO_WARNINGS 1 // Prevents deprecation warning with MSVC
+#include "jsontest.h"
+#include <cstdio>
+#include <string>
+
+#if defined(_MSC_VER)
+// Used to install a report hook that prevent dialog on assertion and error.
+#include <crtdbg.h>
+#endif // if defined(_MSC_VER)
+
+#if defined(_WIN32)
+// Used to prevent dialog on memory fault.
+// Limits headers included by Windows.h
+#define WIN32_LEAN_AND_MEAN
+#define NOSERVICE
+#define NOMCX
+#define NOIME
+#define NOSOUND
+#define NOCOMM
+#define NORPC
+#define NOGDI
+#define NOUSER
+#define NODRIVERS
+#define NOLOGERROR
+#define NOPROFILER
+#define NOMEMMGR
+#define NOLFILEIO
+#define NOOPENFILE
+#define NORESOURCE
+#define NOATOM
+#define NOLANGUAGE
+#define NOLSTRING
+#define NODBCS
+#define NOKEYBOARDINFO
+#define NOGDICAPMASKS
+#define NOCOLOR
+#define NOGDIOBJ
+#define NODRAWTEXT
+#define NOTEXTMETRIC
+#define NOSCALABLEFONT
+#define NOBITMAP
+#define NORASTEROPS
+#define NOMETAFILE
+#define NOSYSMETRICS
+#define NOSYSTEMPARAMSINFO
+#define NOMSG
+#define NOWINSTYLES
+#define NOWINOFFSETS
+#define NOSHOWWINDOW
+#define NODEFERWINDOWPOS
+#define NOVIRTUALKEYCODES
+#define NOKEYSTATES
+#define NOWH
+#define NOMENUS
+#define NOSCROLL
+#define NOCLIPBOARD
+#define NOICONS
+#define NOMB
+#define NOSYSCOMMANDS
+#define NOMDI
+#define NOCTLMGR
+#define NOWINMESSAGES
+#include <windows.h>
+#endif // if defined(_WIN32)
+
+namespace JsonTest {
+
+// class TestResult
+// //////////////////////////////////////////////////////////////////
+
+TestResult::TestResult() {
+  // The root predicate has id 0
+  rootPredicateNode_.id_ = 0;
+  rootPredicateNode_.next_ = nullptr;
+  predicateStackTail_ = &rootPredicateNode_;
+}
+
+void TestResult::setTestName(const Json::String& name) { name_ = name; }
+
+TestResult& TestResult::addFailure(const char* file, unsigned int line,
+                                   const char* expr) {
+  /// Walks the PredicateContext stack adding them to failures_ if not already
+  /// added.
+  unsigned int nestingLevel = 0;
+  PredicateContext* lastNode = rootPredicateNode_.next_;
+  for (; lastNode != nullptr; lastNode = lastNode->next_) {
+    if (lastNode->id_ > lastUsedPredicateId_) // new PredicateContext
+    {
+      lastUsedPredicateId_ = lastNode->id_;
+      addFailureInfo(lastNode->file_, lastNode->line_, lastNode->expr_,
+                     nestingLevel);
+      // Link the PredicateContext to the failure for message target when
+      // popping the PredicateContext.
+      lastNode->failure_ = &(failures_.back());
+    }
+    ++nestingLevel;
+  }
+
+  // Adds the failed assertion
+  addFailureInfo(file, line, expr, nestingLevel);
+  messageTarget_ = &(failures_.back());
+  return *this;
+}
+
+void TestResult::addFailureInfo(const char* file, unsigned int line,
+                                const char* expr, unsigned int nestingLevel) {
+  Failure failure;
+  failure.file_ = file;
+  failure.line_ = line;
+  if (expr) {
+    failure.expr_ = expr;
+  }
+  failure.nestingLevel_ = nestingLevel;
+  failures_.push_back(failure);
+}
+
+TestResult& TestResult::popPredicateContext() {
+  PredicateContext* lastNode = &rootPredicateNode_;
+  while (lastNode->next_ != nullptr && lastNode->next_->next_ != nullptr) {
+    lastNode = lastNode->next_;
+  }
+  // Set message target to popped failure
+  PredicateContext* tail = lastNode->next_;
+  if (tail != nullptr && tail->failure_ != nullptr) {
+    messageTarget_ = tail->failure_;
+  }
+  // Remove tail from list
+  predicateStackTail_ = lastNode;
+  lastNode->next_ = nullptr;
+  return *this;
+}
+
+bool TestResult::failed() const { return !failures_.empty(); }
+
+void TestResult::printFailure(bool printTestName) const {
+  if (failures_.empty()) {
+    return;
+  }
+
+  if (printTestName) {
+    printf("* Detail of %s test failure:\n", name_.c_str());
+  }
+
+  // Print in reverse to display the callstack in the right order
+  for (const auto& failure : failures_) {
+    Json::String indent(failure.nestingLevel_ * 2, ' ');
+    if (failure.file_) {
+      printf("%s%s(%u): ", indent.c_str(), failure.file_, failure.line_);
+    }
+    if (!failure.expr_.empty()) {
+      printf("%s\n", failure.expr_.c_str());
+    } else if (failure.file_) {
+      printf("\n");
+    }
+    if (!failure.message_.empty()) {
+      Json::String reindented = indentText(failure.message_, indent + "  ");
+      printf("%s\n", reindented.c_str());
+    }
+  }
+}
+
+Json::String TestResult::indentText(const Json::String& text,
+                                    const Json::String& indent) {
+  Json::String reindented;
+  Json::String::size_type lastIndex = 0;
+  while (lastIndex < text.size()) {
+    Json::String::size_type nextIndex = text.find('\n', lastIndex);
+    if (nextIndex == Json::String::npos) {
+      nextIndex = text.size() - 1;
+    }
+    reindented += indent;
+    reindented += text.substr(lastIndex, nextIndex - lastIndex + 1);
+    lastIndex = nextIndex + 1;
+  }
+  return reindented;
+}
+
+TestResult& TestResult::addToLastFailure(const Json::String& message) {
+  if (messageTarget_ != nullptr) {
+    messageTarget_->message_ += message;
+  }
+  return *this;
+}
+
+TestResult& TestResult::operator<<(Json::Int64 value) {
+  return addToLastFailure(Json::valueToString(value));
+}
+
+TestResult& TestResult::operator<<(Json::UInt64 value) {
+  return addToLastFailure(Json::valueToString(value));
+}
+
+TestResult& TestResult::operator<<(bool value) {
+  return addToLastFailure(value ? "true" : "false");
+}
+
+// class TestCase
+// //////////////////////////////////////////////////////////////////
+
+TestCase::TestCase() = default;
+
+TestCase::~TestCase() = default;
+
+void TestCase::run(TestResult& result) {
+  result_ = &result;
+  runTestCase();
+}
+
+// class Runner
+// //////////////////////////////////////////////////////////////////
+
+Runner::Runner() = default;
+
+Runner& Runner::add(TestCaseFactory factory) {
+  tests_.push_back(factory);
+  return *this;
+}
+
+size_t Runner::testCount() const { return tests_.size(); }
+
+Json::String Runner::testNameAt(size_t index) const {
+  TestCase* test = tests_[index]();
+  Json::String name = test->testName();
+  delete test;
+  return name;
+}
+
+void Runner::runTestAt(size_t index, TestResult& result) const {
+  TestCase* test = tests_[index]();
+  result.setTestName(test->testName());
+  printf("Testing %s: ", test->testName());
+  fflush(stdout);
+#if JSON_USE_EXCEPTION
+  try {
+#endif // if JSON_USE_EXCEPTION
+    test->run(result);
+#if JSON_USE_EXCEPTION
+  } catch (const std::exception& e) {
+    result.addFailure(__FILE__, __LINE__, "Unexpected exception caught:")
+        << e.what();
+  }
+#endif // if JSON_USE_EXCEPTION
+  delete test;
+  const char* status = result.failed() ? "FAILED" : "OK";
+  printf("%s\n", status);
+  fflush(stdout);
+}
+
+bool Runner::runAllTest(bool printSummary) const {
+  size_t const count = testCount();
+  std::deque<TestResult> failures;
+  for (size_t index = 0; index < count; ++index) {
+    TestResult result;
+    runTestAt(index, result);
+    if (result.failed()) {
+      failures.push_back(result);
+    }
+  }
+
+  if (failures.empty()) {
+    if (printSummary) {
+      printf("All %zu tests passed\n", count);
+    }
+    return true;
+  }
+  for (auto& result : failures) {
+    result.printFailure(count > 1);
+  }
+
+  if (printSummary) {
+    size_t const failedCount = failures.size();
+    size_t const passedCount = count - failedCount;
+    printf("%zu/%zu tests passed (%zu failure(s))\n", passedCount, count,
+           failedCount);
+  }
+  return false;
+}
+
+bool Runner::testIndex(const Json::String& testName, size_t& indexOut) const {
+  const size_t count = testCount();
+  for (size_t index = 0; index < count; ++index) {
+    if (testNameAt(index) == testName) {
+      indexOut = index;
+      return true;
+    }
+  }
+  return false;
+}
+
+void Runner::listTests() const {
+  const size_t count = testCount();
+  for (size_t index = 0; index < count; ++index) {
+    printf("%s\n", testNameAt(index).c_str());
+  }
+}
+
+int Runner::runCommandLine(int argc, const char* argv[]) const {
+  // typedef std::deque<String> TestNames;
+  Runner subrunner;
+  for (int index = 1; index < argc; ++index) {
+    Json::String opt = argv[index];
+    if (opt == "--list-tests") {
+      listTests();
+      return 0;
+    }
+    if (opt == "--test-auto") {
+      preventDialogOnCrash();
+    } else if (opt == "--test") {
+      ++index;
+      if (index < argc) {
+        size_t testNameIndex;
+        if (testIndex(argv[index], testNameIndex)) {
+          subrunner.add(tests_[testNameIndex]);
+        } else {
+          fprintf(stderr, "Test '%s' does not exist!\n", argv[index]);
+          return 2;
+        }
+      } else {
+        printUsage(argv[0]);
+        return 2;
+      }
+    } else {
+      printUsage(argv[0]);
+      return 2;
+    }
+  }
+  bool succeeded;
+  if (subrunner.testCount() > 0) {
+    succeeded = subrunner.runAllTest(subrunner.testCount() > 1);
+  } else {
+    succeeded = runAllTest(true);
+  }
+  return succeeded ? 0 : 1;
+}
+
+#if defined(_MSC_VER) && defined(_DEBUG)
+// Hook MSVCRT assertions to prevent dialog from appearing
+static int msvcrtSilentReportHook(int reportType, char* message,
+                                  int* /*returnValue*/) {
+  // The default CRT handling of error and assertion is to display
+  // an error dialog to the user.
+  // Instead, when an error or an assertion occurs, we force the
+  // application to terminate using abort() after display
+  // the message on stderr.
+  if (reportType == _CRT_ERROR || reportType == _CRT_ASSERT) {
+    // calling abort() cause the ReportHook to be called
+    // The following is used to detect this case and let's the
+    // error handler fallback on its default behaviour (
+    // display a warning message)
+    static volatile bool isAborting = false;
+    if (isAborting) {
+      return TRUE;
+    }
+    isAborting = true;
+
+    fprintf(stderr, "CRT Error/Assert:\n%s\n", message);
+    fflush(stderr);
+    abort();
+  }
+  // Let's other reportType (_CRT_WARNING) be handled as they would by default
+  return FALSE;
+}
+#endif // if defined(_MSC_VER)
+
+void Runner::preventDialogOnCrash() {
+#if defined(_MSC_VER) && defined(_DEBUG)
+  // Install a hook to prevent MSVCRT error and assertion from
+  // popping a dialog
+  // This function a NO-OP in release configuration
+  // (which cause warning since msvcrtSilentReportHook is not referenced)
+  _CrtSetReportHook(&msvcrtSilentReportHook);
+#endif // if defined(_MSC_VER)
+
+  // @todo investigate this handler (for buffer overflow)
+  // _set_security_error_handler
+
+#if defined(_WIN32)
+  // Prevents the system from popping a dialog for debugging if the
+  // application fails due to invalid memory access.
+  SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOGPFAULTERRORBOX |
+               SEM_NOOPENFILEERRORBOX);
+#endif // if defined(_WIN32)
+}
+
+void Runner::printUsage(const char* appName) {
+  printf("Usage: %s [options]\n"
+         "\n"
+         "If --test is not specified, then all the test cases be run.\n"
+         "\n"
+         "Valid options:\n"
+         "--list-tests: print the name of all test cases on the standard\n"
+         "              output and exit.\n"
+         "--test TESTNAME: executes the test case with the specified name.\n"
+         "                 May be repeated.\n"
+         "--test-auto: prevent dialog prompting for debugging on crash.\n",
+         appName);
+}
+
+// Assertion functions
+// //////////////////////////////////////////////////////////////////
+
+Json::String ToJsonString(const char* toConvert) {
+  return Json::String(toConvert);
+}
+
+Json::String ToJsonString(Json::String in) { return in; }
+
+#if JSONCPP_USING_SECURE_MEMORY
+Json::String ToJsonString(std::string in) {
+  return Json::String(in.data(), in.data() + in.length());
+}
+#endif
+
+TestResult& checkStringEqual(TestResult& result, const Json::String& expected,
+                             const Json::String& actual, const char* file,
+                             unsigned int line, const char* expr) {
+  if (expected != actual) {
+    result.addFailure(file, line, expr);
+    result << "Expected: '" << expected << "'\n";
+    result << "Actual  : '" << actual << "'";
+  }
+  return result;
+}
+
+} // namespace JsonTest
diff --git a/3rdparty/jsoncpp/src/src/test_lib_json/jsontest.h b/3rdparty/jsoncpp/src/src/test_lib_json/jsontest.h
new file mode 100644
index 00000000..4e8af0f2
--- /dev/null
+++ b/3rdparty/jsoncpp/src/src/test_lib_json/jsontest.h
@@ -0,0 +1,288 @@
+// Copyright 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
+// Distributed under MIT license, or public domain if desired and
+// recognized in your jurisdiction.
+// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+#ifndef JSONTEST_H_INCLUDED
+#define JSONTEST_H_INCLUDED
+
+#include <cstdio>
+#include <deque>
+#include <iomanip>
+#include <json/config.h>
+#include <json/value.h>
+#include <json/writer.h>
+#include <sstream>
+#include <string>
+
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// Mini Unit Testing framework
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+
+/** \brief Unit testing framework.
+ * \warning: all assertions are non-aborting, test case execution will continue
+ *           even if an assertion namespace.
+ *           This constraint is for portability: the framework needs to compile
+ *           on Visual Studio 6 and must not require exception usage.
+ */
+namespace JsonTest {
+
+class Failure {
+public:
+  const char* file_;
+  unsigned int line_;
+  Json::String expr_;
+  Json::String message_;
+  unsigned int nestingLevel_;
+};
+
+/// Context used to create the assertion callstack on failure.
+/// Must be a POD to allow inline initialisation without stepping
+/// into the debugger.
+struct PredicateContext {
+  using Id = unsigned int;
+  Id id_;
+  const char* file_;
+  unsigned int line_;
+  const char* expr_;
+  PredicateContext* next_;
+  /// Related Failure, set when the PredicateContext is converted
+  /// into a Failure.
+  Failure* failure_;
+};
+
+class TestResult {
+public:
+  TestResult();
+
+  /// \internal Implementation detail for assertion macros
+  /// Not encapsulated to prevent step into when debugging failed assertions
+  /// Incremented by one on assertion predicate entry, decreased by one
+  /// by addPredicateContext().
+  PredicateContext::Id predicateId_{1};
+
+  /// \internal Implementation detail for predicate macros
+  PredicateContext* predicateStackTail_;
+
+  void setTestName(const Json::String& name);
+
+  /// Adds an assertion failure.
+  TestResult& addFailure(const char* file, unsigned int line,
+                         const char* expr = nullptr);
+
+  /// Removes the last PredicateContext added to the predicate stack
+  /// chained list.
+  /// Next messages will be targed at the PredicateContext that was removed.
+  TestResult& popPredicateContext();
+
+  bool failed() const;
+
+  void printFailure(bool printTestName) const;
+
+  // Generic operator that will work with anything ostream can deal with.
+  template <typename T> TestResult& operator<<(const T& value) {
+    Json::OStringStream oss;
+    oss << std::setprecision(16) << std::hexfloat << value;
+    return addToLastFailure(oss.str());
+  }
+
+  // Specialized versions.
+  TestResult& operator<<(bool value);
+  // std:ostream does not support 64bits integers on all STL implementation
+  TestResult& operator<<(Json::Int64 value);
+  TestResult& operator<<(Json::UInt64 value);
+
+private:
+  TestResult& addToLastFailure(const Json::String& message);
+  /// Adds a failure or a predicate context
+  void addFailureInfo(const char* file, unsigned int line, const char* expr,
+                      unsigned int nestingLevel);
+  static Json::String indentText(const Json::String& text,
+                                 const Json::String& indent);
+
+  using Failures = std::deque<Failure>;
+  Failures failures_;
+  Json::String name_;
+  PredicateContext rootPredicateNode_;
+  PredicateContext::Id lastUsedPredicateId_{0};
+  /// Failure which is the target of the messages added using operator <<
+  Failure* messageTarget_{nullptr};
+};
+
+class TestCase {
+public:
+  TestCase();
+
+  virtual ~TestCase();
+
+  void run(TestResult& result);
+
+  virtual const char* testName() const = 0;
+
+protected:
+  TestResult* result_{nullptr};
+
+private:
+  virtual void runTestCase() = 0;
+};
+
+/// Function pointer type for TestCase factory
+using TestCaseFactory = TestCase* (*)();
+
+class Runner {
+public:
+  Runner();
+
+  /// Adds a test to the suite
+  Runner& add(TestCaseFactory factory);
+
+  /// Runs test as specified on the command-line
+  /// If no command-line arguments are provided, run all tests.
+  /// If --list-tests is provided, then print the list of all test cases
+  /// If --test <testname> is provided, then run test testname.
+  int runCommandLine(int argc, const char* argv[]) const;
+
+  /// Runs all the test cases
+  bool runAllTest(bool printSummary) const;
+
+  /// Returns the number of test case in the suite
+  size_t testCount() const;
+
+  /// Returns the name of the test case at the specified index
+  Json::String testNameAt(size_t index) const;
+
+  /// Runs the test case at the specified index using the specified TestResult
+  void runTestAt(size_t index, TestResult& result) const;
+
+  static void printUsage(const char* appName);
+
+private: // prevents copy construction and assignment
+  Runner(const Runner& other) = delete;
+  Runner& operator=(const Runner& other) = delete;
+
+private:
+  void listTests() const;
+  bool testIndex(const Json::String& testName, size_t& indexOut) const;
+  static void preventDialogOnCrash();
+
+private:
+  using Factories = std::deque<TestCaseFactory>;
+  Factories tests_;
+};
+
+template <typename T, typename U>
+TestResult& checkEqual(TestResult& result, T expected, U actual,
+                       const char* file, unsigned int line, const char* expr) {
+  if (static_cast<U>(expected) != actual) {
+    result.addFailure(file, line, expr);
+    result << "Expected: " << static_cast<U>(expected) << "\n";
+    result << "Actual  : " << actual;
+  }
+  return result;
+}
+
+Json::String ToJsonString(const char* toConvert);
+Json::String ToJsonString(Json::String in);
+#if JSONCPP_USING_SECURE_MEMORY
+Json::String ToJsonString(std::string in);
+#endif
+
+TestResult& checkStringEqual(TestResult& result, const Json::String& expected,
+                             const Json::String& actual, const char* file,
+                             unsigned int line, const char* expr);
+
+} // namespace JsonTest
+
+/// \brief Asserts that the given expression is true.
+/// JSONTEST_ASSERT( x == y ) << "x=" << x << ", y=" << y;
+/// JSONTEST_ASSERT( x == y );
+#define JSONTEST_ASSERT(expr)                                                  \
+  if (expr) {                                                                  \
+  } else                                                                       \
+    result_->addFailure(__FILE__, __LINE__, #expr)
+
+/// \brief Asserts that the given predicate is true.
+/// The predicate may do other assertions and be a member function of the
+/// fixture.
+#define JSONTEST_ASSERT_PRED(expr)                                             \
+  do {                                                                         \
+    JsonTest::PredicateContext _minitest_Context = {                           \
+        result_->predicateId_, __FILE__, __LINE__, #expr, NULL, NULL};         \
+    result_->predicateStackTail_->next_ = &_minitest_Context;                  \
+    result_->predicateId_ += 1;                                                \
+    result_->predicateStackTail_ = &_minitest_Context;                         \
+    (expr);                                                                    \
+    result_->popPredicateContext();                                            \
+  } while (0)
+
+/// \brief Asserts that two values are equals.
+#define JSONTEST_ASSERT_EQUAL(expected, actual)                                \
+  JsonTest::checkEqual(*result_, expected, actual, __FILE__, __LINE__,         \
+                       #expected " == " #actual)
+
+/// \brief Asserts that two values are equals.
+#define JSONTEST_ASSERT_STRING_EQUAL(expected, actual)                         \
+  JsonTest::checkStringEqual(*result_, JsonTest::ToJsonString(expected),       \
+                             JsonTest::ToJsonString(actual), __FILE__,         \
+                             __LINE__, #expected " == " #actual)
+
+/// \brief Asserts that a given expression throws an exception
+#define JSONTEST_ASSERT_THROWS(expr)                                           \
+  do {                                                                         \
+    bool _threw = false;                                                       \
+    try {                                                                      \
+      expr;                                                                    \
+    } catch (...) {                                                            \
+      _threw = true;                                                           \
+    }                                                                          \
+    if (!_threw)                                                               \
+      result_->addFailure(__FILE__, __LINE__,                                  \
+                          "expected exception thrown: " #expr);                \
+  } while (0)
+
+/// \brief Begin a fixture test case.
+#define JSONTEST_FIXTURE(FixtureType, name)                                    \
+  class Test##FixtureType##name : public FixtureType {                         \
+  public:                                                                      \
+    static JsonTest::TestCase* factory() {                                     \
+      return new Test##FixtureType##name();                                    \
+    }                                                                          \
+                                                                               \
+  public: /* overridden from TestCase */                                       \
+    const char* testName() const override { return #FixtureType "/" #name; }   \
+    void runTestCase() override;                                               \
+  };                                                                           \
+                                                                               \
+  void Test##FixtureType##name::runTestCase()
+
+#define JSONTEST_FIXTURE_FACTORY(FixtureType, name)                            \
+  &Test##FixtureType##name::factory
+
+#define JSONTEST_REGISTER_FIXTURE(runner, FixtureType, name)                   \
+  (runner).add(JSONTEST_FIXTURE_FACTORY(FixtureType, name))
+
+/// \brief Begin a fixture test case.
+#define JSONTEST_FIXTURE_V2(FixtureType, name, collections)                    \
+  class Test##FixtureType##name : public FixtureType {                         \
+  public:                                                                      \
+    static JsonTest::TestCase* factory() {                                     \
+      return new Test##FixtureType##name();                                    \
+    }                                                                          \
+    static bool collect() {                                                    \
+      (collections).push_back(JSONTEST_FIXTURE_FACTORY(FixtureType, name));    \
+      return true;                                                             \
+    }                                                                          \
+                                                                               \
+  public: /* overridden from TestCase */                                       \
+    const char* testName() const override { return #FixtureType "/" #name; }   \
+    void runTestCase() override;                                               \
+  };                                                                           \
+                                                                               \
+  static bool test##FixtureType##name##collect =                               \
+      Test##FixtureType##name::collect();                                      \
+                                                                               \
+  void Test##FixtureType##name::runTestCase()
+
+#endif // ifndef JSONTEST_H_INCLUDED
diff --git a/3rdparty/jsoncpp/src/src/test_lib_json/main.cpp b/3rdparty/jsoncpp/src/src/test_lib_json/main.cpp
new file mode 100644
index 00000000..d0f5364a
--- /dev/null
+++ b/3rdparty/jsoncpp/src/src/test_lib_json/main.cpp
@@ -0,0 +1,3971 @@
+// Copyright 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
+// Distributed under MIT license, or public domain if desired and
+// recognized in your jurisdiction.
+// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+#if defined(__GNUC__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#elif defined(_MSC_VER)
+#pragma warning(disable : 4996)
+#endif
+
+#include "fuzz.h"
+#include "jsontest.h"
+#include <algorithm>
+#include <cmath>
+#include <cstring>
+#include <functional>
+#include <iomanip>
+#include <iostream>
+#include <iterator>
+#include <json/config.h>
+#include <json/json.h>
+#include <limits>
+#include <memory>
+#include <sstream>
+#include <string>
+#include <vector>
+
+using CharReaderPtr = std::unique_ptr<Json::CharReader>;
+
+// Make numeric limits more convenient to talk about.
+// Assumes int type in 32 bits.
+#define kint32max Json::Value::maxInt
+#define kint32min Json::Value::minInt
+#define kuint32max Json::Value::maxUInt
+#define kint64max Json::Value::maxInt64
+#define kint64min Json::Value::minInt64
+#define kuint64max Json::Value::maxUInt64
+
+// static const double kdint64max = double(kint64max);
+// static const float kfint64max = float(kint64max);
+static const float kfint32max = float(kint32max);
+static const float kfuint32max = float(kuint32max);
+
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// Json Library test cases
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+
+#if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
+static inline double uint64ToDouble(Json::UInt64 value) {
+  return static_cast<double>(value);
+}
+#else  // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
+static inline double uint64ToDouble(Json::UInt64 value) {
+  return static_cast<double>(Json::Int64(value / 2)) * 2.0 +
+         static_cast<double>(Json::Int64(value & 1));
+}
+#endif // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
+
+// local_ is the collection for the testcases in this code file.
+static std::deque<JsonTest::TestCaseFactory> local_;
+#define JSONTEST_FIXTURE_LOCAL(FixtureType, name)                              \
+  JSONTEST_FIXTURE_V2(FixtureType, name, local_)
+
+struct ValueTest : JsonTest::TestCase {
+  Json::Value null_;
+  Json::Value emptyArray_{Json::arrayValue};
+  Json::Value emptyObject_{Json::objectValue};
+  Json::Value integer_{123456789};
+  Json::Value unsignedInteger_{34567890};
+  Json::Value smallUnsignedInteger_{Json::Value::UInt(Json::Value::maxInt)};
+  Json::Value real_{1234.56789};
+  Json::Value float_{0.00390625f};
+  Json::Value array1_;
+  Json::Value object1_;
+  Json::Value emptyString_{""};
+  Json::Value string1_{"a"};
+  Json::Value string_{"sometext with space"};
+  Json::Value true_{true};
+  Json::Value false_{false};
+
+  ValueTest() {
+    array1_.append(1234);
+    object1_["id"] = 1234;
+  }
+
+  struct IsCheck {
+    /// Initialize all checks to \c false by default.
+    IsCheck();
+
+    bool isObject_{false};
+    bool isArray_{false};
+    bool isBool_{false};
+    bool isString_{false};
+    bool isNull_{false};
+
+    bool isInt_{false};
+    bool isInt64_{false};
+    bool isUInt_{false};
+    bool isUInt64_{false};
+    bool isIntegral_{false};
+    bool isDouble_{false};
+    bool isNumeric_{false};
+  };
+
+  void checkConstMemberCount(const Json::Value& value,
+                             unsigned int expectedCount);
+
+  void checkMemberCount(Json::Value& value, unsigned int expectedCount);
+
+  void checkIs(const Json::Value& value, const IsCheck& check);
+
+  void checkIsLess(const Json::Value& x, const Json::Value& y);
+
+  void checkIsEqual(const Json::Value& x, const Json::Value& y);
+
+  /// Normalize the representation of floating-point number by stripped leading
+  /// 0 in exponent.
+  static Json::String normalizeFloatingPointStr(const Json::String& s);
+};
+
+Json::String ValueTest::normalizeFloatingPointStr(const Json::String& s) {
+  auto index = s.find_last_of("eE");
+  if (index == s.npos)
+    return s;
+  std::size_t signWidth = (s[index + 1] == '+' || s[index + 1] == '-') ? 1 : 0;
+  auto exponentStartIndex = index + 1 + signWidth;
+  Json::String normalized = s.substr(0, exponentStartIndex);
+  auto indexDigit = s.find_first_not_of('0', exponentStartIndex);
+  Json::String exponent = "0";
+  if (indexDigit != s.npos) { // nonzero exponent
+    exponent = s.substr(indexDigit);
+  }
+  return normalized + exponent;
+}
+
+JSONTEST_FIXTURE_LOCAL(ValueTest, checkNormalizeFloatingPointStr) {
+  struct TestData {
+    std::string in;
+    std::string out;
+  } const testData[] = {
+      {"0.0", "0.0"},
+      {"0e0", "0e0"},
+      {"1234.0", "1234.0"},
+      {"1234.0e0", "1234.0e0"},
+      {"1234.0e-1", "1234.0e-1"},
+      {"1234.0e+0", "1234.0e+0"},
+      {"1234.0e+001", "1234.0e+1"},
+      {"1234e-1", "1234e-1"},
+      {"1234e+000", "1234e+0"},
+      {"1234e+001", "1234e+1"},
+      {"1234e10", "1234e10"},
+      {"1234e010", "1234e10"},
+      {"1234e+010", "1234e+10"},
+      {"1234e-010", "1234e-10"},
+      {"1234e+100", "1234e+100"},
+      {"1234e-100", "1234e-100"},
+  };
+  for (const auto& td : testData) {
+    JSONTEST_ASSERT_STRING_EQUAL(normalizeFloatingPointStr(td.in), td.out);
+  }
+}
+
+JSONTEST_FIXTURE_LOCAL(ValueTest, memberCount) {
+  JSONTEST_ASSERT_PRED(checkMemberCount(emptyArray_, 0));
+  JSONTEST_ASSERT_PRED(checkMemberCount(emptyObject_, 0));
+  JSONTEST_ASSERT_PRED(checkMemberCount(array1_, 1));
+  JSONTEST_ASSERT_PRED(checkMemberCount(object1_, 1));
+  JSONTEST_ASSERT_PRED(checkMemberCount(null_, 0));
+  JSONTEST_ASSERT_PRED(checkMemberCount(integer_, 0));
+  JSONTEST_ASSERT_PRED(checkMemberCount(unsignedInteger_, 0));
+  JSONTEST_ASSERT_PRED(checkMemberCount(smallUnsignedInteger_, 0));
+  JSONTEST_ASSERT_PRED(checkMemberCount(real_, 0));
+  JSONTEST_ASSERT_PRED(checkMemberCount(emptyString_, 0));
+  JSONTEST_ASSERT_PRED(checkMemberCount(string_, 0));
+  JSONTEST_ASSERT_PRED(checkMemberCount(true_, 0));
+  JSONTEST_ASSERT_PRED(checkMemberCount(false_, 0));
+  JSONTEST_ASSERT_PRED(checkMemberCount(string1_, 0));
+  JSONTEST_ASSERT_PRED(checkMemberCount(float_, 0));
+}
+
+JSONTEST_FIXTURE_LOCAL(ValueTest, objects) {
+  // Types
+  IsCheck checks;
+  checks.isObject_ = true;
+  JSONTEST_ASSERT_PRED(checkIs(emptyObject_, checks));
+  JSONTEST_ASSERT_PRED(checkIs(object1_, checks));
+
+  JSONTEST_ASSERT_EQUAL(Json::objectValue, emptyObject_.type());
+
+  // Empty object okay
+  JSONTEST_ASSERT(emptyObject_.isConvertibleTo(Json::nullValue));
+
+  // Non-empty object not okay
+  JSONTEST_ASSERT(!object1_.isConvertibleTo(Json::nullValue));
+
+  // Always okay
+  JSONTEST_ASSERT(emptyObject_.isConvertibleTo(Json::objectValue));
+
+  // Never okay
+  JSONTEST_ASSERT(!emptyObject_.isConvertibleTo(Json::arrayValue));
+  JSONTEST_ASSERT(!emptyObject_.isConvertibleTo(Json::intValue));
+  JSONTEST_ASSERT(!emptyObject_.isConvertibleTo(Json::uintValue));
+  JSONTEST_ASSERT(!emptyObject_.isConvertibleTo(Json::realValue));
+  JSONTEST_ASSERT(!emptyObject_.isConvertibleTo(Json::booleanValue));
+  JSONTEST_ASSERT(!emptyObject_.isConvertibleTo(Json::stringValue));
+
+  // Access through const reference
+  const Json::Value& constObject = object1_;
+
+  JSONTEST_ASSERT_EQUAL(Json::Value(1234), constObject["id"]);
+  JSONTEST_ASSERT_EQUAL(Json::Value(), constObject["unknown id"]);
+
+  // Access through find()
+  const char idKey[] = "id";
+  const Json::Value* foundId = object1_.find(idKey, idKey + strlen(idKey));
+  JSONTEST_ASSERT(foundId != nullptr);
+  JSONTEST_ASSERT_EQUAL(Json::Value(1234), *foundId);
+
+  const char unknownIdKey[] = "unknown id";
+  const Json::Value* foundUnknownId =
+      object1_.find(unknownIdKey, unknownIdKey + strlen(unknownIdKey));
+  JSONTEST_ASSERT_EQUAL(nullptr, foundUnknownId);
+
+  // Access through demand()
+  const char yetAnotherIdKey[] = "yet another id";
+  const Json::Value* foundYetAnotherId =
+      object1_.find(yetAnotherIdKey, yetAnotherIdKey + strlen(yetAnotherIdKey));
+  JSONTEST_ASSERT_EQUAL(nullptr, foundYetAnotherId);
+  Json::Value* demandedYetAnotherId = object1_.demand(
+      yetAnotherIdKey, yetAnotherIdKey + strlen(yetAnotherIdKey));
+  JSONTEST_ASSERT(demandedYetAnotherId != nullptr);
+  *demandedYetAnotherId = "baz";
+
+  JSONTEST_ASSERT_EQUAL(Json::Value("baz"), object1_["yet another id"]);
+
+  // Access through non-const reference
+  JSONTEST_ASSERT_EQUAL(Json::Value(1234), object1_["id"]);
+  JSONTEST_ASSERT_EQUAL(Json::Value(), object1_["unknown id"]);
+
+  object1_["some other id"] = "foo";
+  JSONTEST_ASSERT_EQUAL(Json::Value("foo"), object1_["some other id"]);
+  JSONTEST_ASSERT_EQUAL(Json::Value("foo"), object1_["some other id"]);
+
+  // Remove.
+  Json::Value got;
+  bool did;
+  did = object1_.removeMember("some other id", &got);
+  JSONTEST_ASSERT_EQUAL(Json::Value("foo"), got);
+  JSONTEST_ASSERT_EQUAL(true, did);
+  got = Json::Value("bar");
+  did = object1_.removeMember("some other id", &got);
+  JSONTEST_ASSERT_EQUAL(Json::Value("bar"), got);
+  JSONTEST_ASSERT_EQUAL(false, did);
+
+  object1_["some other id"] = "foo";
+  Json::Value* gotPtr = nullptr;
+  did = object1_.removeMember("some other id", gotPtr);
+  JSONTEST_ASSERT_EQUAL(nullptr, gotPtr);
+  JSONTEST_ASSERT_EQUAL(true, did);
+
+  // Using other removeMember interfaces, the test idea is the same as above.
+  object1_["some other id"] = "foo";
+  const Json::String key("some other id");
+  did = object1_.removeMember(key, &got);
+  JSONTEST_ASSERT_EQUAL(Json::Value("foo"), got);
+  JSONTEST_ASSERT_EQUAL(true, did);
+  got = Json::Value("bar");
+  did = object1_.removeMember(key, &got);
+  JSONTEST_ASSERT_EQUAL(Json::Value("bar"), got);
+  JSONTEST_ASSERT_EQUAL(false, did);
+
+  object1_["some other id"] = "foo";
+  object1_.removeMember(key);
+  JSONTEST_ASSERT_EQUAL(Json::nullValue, object1_[key]);
+}
+
+JSONTEST_FIXTURE_LOCAL(ValueTest, arrays) {
+  const unsigned int index0 = 0;
+
+  // Types
+  IsCheck checks;
+  checks.isArray_ = true;
+  JSONTEST_ASSERT_PRED(checkIs(emptyArray_, checks));
+  JSONTEST_ASSERT_PRED(checkIs(array1_, checks));
+
+  JSONTEST_ASSERT_EQUAL(Json::arrayValue, array1_.type());
+
+  // Empty array okay
+  JSONTEST_ASSERT(emptyArray_.isConvertibleTo(Json::nullValue));
+
+  // Non-empty array not okay
+  JSONTEST_ASSERT(!array1_.isConvertibleTo(Json::nullValue));
+
+  // Always okay
+  JSONTEST_ASSERT(emptyArray_.isConvertibleTo(Json::arrayValue));
+
+  // Never okay
+  JSONTEST_ASSERT(!emptyArray_.isConvertibleTo(Json::objectValue));
+  JSONTEST_ASSERT(!emptyArray_.isConvertibleTo(Json::intValue));
+  JSONTEST_ASSERT(!emptyArray_.isConvertibleTo(Json::uintValue));
+  JSONTEST_ASSERT(!emptyArray_.isConvertibleTo(Json::realValue));
+  JSONTEST_ASSERT(!emptyArray_.isConvertibleTo(Json::booleanValue));
+  JSONTEST_ASSERT(!emptyArray_.isConvertibleTo(Json::stringValue));
+
+  // Access through const reference
+  const Json::Value& constArray = array1_;
+  JSONTEST_ASSERT_EQUAL(Json::Value(1234), constArray[index0]);
+  JSONTEST_ASSERT_EQUAL(Json::Value(1234), constArray[0]);
+
+  // Access through non-const reference
+  JSONTEST_ASSERT_EQUAL(Json::Value(1234), array1_[index0]);
+  JSONTEST_ASSERT_EQUAL(Json::Value(1234), array1_[0]);
+
+  array1_[2] = Json::Value(17);
+  JSONTEST_ASSERT_EQUAL(Json::Value(), array1_[1]);
+  JSONTEST_ASSERT_EQUAL(Json::Value(17), array1_[2]);
+  Json::Value got;
+  JSONTEST_ASSERT_EQUAL(true, array1_.removeIndex(2, &got));
+  JSONTEST_ASSERT_EQUAL(Json::Value(17), got);
+  JSONTEST_ASSERT_EQUAL(false, array1_.removeIndex(2, &got)); // gone now
+}
+JSONTEST_FIXTURE_LOCAL(ValueTest, resizeArray) {
+  Json::Value array;
+  {
+    for (Json::ArrayIndex i = 0; i < 10; i++)
+      array[i] = i;
+    JSONTEST_ASSERT_EQUAL(array.size(), 10);
+    // The length set is greater than the length of the array.
+    array.resize(15);
+    JSONTEST_ASSERT_EQUAL(array.size(), 15);
+
+    // The length set is less than the length of the array.
+    array.resize(5);
+    JSONTEST_ASSERT_EQUAL(array.size(), 5);
+
+    // The length of the array is set to 0.
+    array.resize(0);
+    JSONTEST_ASSERT_EQUAL(array.size(), 0);
+  }
+  {
+    for (Json::ArrayIndex i = 0; i < 10; i++)
+      array[i] = i;
+    JSONTEST_ASSERT_EQUAL(array.size(), 10);
+    array.clear();
+    JSONTEST_ASSERT_EQUAL(array.size(), 0);
+  }
+}
+
+JSONTEST_FIXTURE_LOCAL(ValueTest, resizePopulatesAllMissingElements) {
+  Json::ArrayIndex n = 10;
+  Json::Value v;
+  v.resize(n);
+  JSONTEST_ASSERT_EQUAL(n, v.size());
+  JSONTEST_ASSERT_EQUAL(n, std::distance(v.begin(), v.end()));
+  for (const Json::Value& e : v)
+    JSONTEST_ASSERT_EQUAL(e, Json::Value{});
+}
+
+JSONTEST_FIXTURE_LOCAL(ValueTest, getArrayValue) {
+  Json::Value array;
+  for (Json::ArrayIndex i = 0; i < 5; i++)
+    array[i] = i;
+
+  JSONTEST_ASSERT_EQUAL(array.size(), 5);
+  const Json::Value defaultValue(10);
+  Json::ArrayIndex index = 0;
+  for (; index <= 4; index++)
+    JSONTEST_ASSERT_EQUAL(index, array.get(index, defaultValue).asInt());
+
+  index = 4;
+  JSONTEST_ASSERT_EQUAL(array.isValidIndex(index), true);
+  index = 5;
+  JSONTEST_ASSERT_EQUAL(array.isValidIndex(index), false);
+  JSONTEST_ASSERT_EQUAL(defaultValue, array.get(index, defaultValue));
+  JSONTEST_ASSERT_EQUAL(array.isValidIndex(index), false);
+}
+JSONTEST_FIXTURE_LOCAL(ValueTest, arrayIssue252) {
+  int count = 5;
+  Json::Value root;
+  Json::Value item;
+  root["array"] = Json::Value::nullSingleton();
+  for (int i = 0; i < count; i++) {
+    item["a"] = i;
+    item["b"] = i;
+    root["array"][i] = item;
+  }
+  // JSONTEST_ASSERT_EQUAL(5, root["array"].size());
+}
+
+JSONTEST_FIXTURE_LOCAL(ValueTest, arrayInsertAtRandomIndex) {
+  Json::Value array;
+  const Json::Value str0("index2");
+  const Json::Value str1("index3");
+  array.append("index0"); // append rvalue
+  array.append("index1");
+  array.append(str0); // append lvalue
+
+  std::vector<Json::Value*> vec; // storage value address for checking
+  for (Json::ArrayIndex i = 0; i < 3; i++) {
+    vec.push_back(&array[i]);
+  }
+  JSONTEST_ASSERT_EQUAL(Json::Value("index0"), array[0]); // check append
+  JSONTEST_ASSERT_EQUAL(Json::Value("index1"), array[1]);
+  JSONTEST_ASSERT_EQUAL(Json::Value("index2"), array[2]);
+
+  // insert lvalue at the head
+  JSONTEST_ASSERT(array.insert(0, str1));
+  JSONTEST_ASSERT_EQUAL(Json::Value("index3"), array[0]);
+  JSONTEST_ASSERT_EQUAL(Json::Value("index0"), array[1]);
+  JSONTEST_ASSERT_EQUAL(Json::Value("index1"), array[2]);
+  JSONTEST_ASSERT_EQUAL(Json::Value("index2"), array[3]);
+  // checking address
+  for (Json::ArrayIndex i = 0; i < 3; i++) {
+    JSONTEST_ASSERT_EQUAL(vec[i], &array[i]);
+  }
+  vec.push_back(&array[3]);
+  // insert rvalue at middle
+  JSONTEST_ASSERT(array.insert(2, "index4"));
+  JSONTEST_ASSERT_EQUAL(Json::Value("index3"), array[0]);
+  JSONTEST_ASSERT_EQUAL(Json::Value("index0"), array[1]);
+  JSONTEST_ASSERT_EQUAL(Json::Value("index4"), array[2]);
+  JSONTEST_ASSERT_EQUAL(Json::Value("index1"), array[3]);
+  JSONTEST_ASSERT_EQUAL(Json::Value("index2"), array[4]);
+  // checking address
+  for (Json::ArrayIndex i = 0; i < 4; i++) {
+    JSONTEST_ASSERT_EQUAL(vec[i], &array[i]);
+  }
+  vec.push_back(&array[4]);
+  // insert rvalue at the tail
+  JSONTEST_ASSERT(array.insert(5, "index5"));
+  JSONTEST_ASSERT_EQUAL(Json::Value("index3"), array[0]);
+  JSONTEST_ASSERT_EQUAL(Json::Value("index0"), array[1]);
+  JSONTEST_ASSERT_EQUAL(Json::Value("index4"), array[2]);
+  JSONTEST_ASSERT_EQUAL(Json::Value("index1"), array[3]);
+  JSONTEST_ASSERT_EQUAL(Json::Value("index2"), array[4]);
+  JSONTEST_ASSERT_EQUAL(Json::Value("index5"), array[5]);
+  // checking address
+  for (Json::ArrayIndex i = 0; i < 5; i++) {
+    JSONTEST_ASSERT_EQUAL(vec[i], &array[i]);
+  }
+  vec.push_back(&array[5]);
+  // beyond max array size, it should not be allowed to insert into its tail
+  JSONTEST_ASSERT(!array.insert(10, "index10"));
+}
+
+JSONTEST_FIXTURE_LOCAL(ValueTest, null) {
+  JSONTEST_ASSERT_EQUAL(Json::nullValue, null_.type());
+
+  IsCheck checks;
+  checks.isNull_ = true;
+  JSONTEST_ASSERT_PRED(checkIs(null_, checks));
+
+  JSONTEST_ASSERT(null_.isConvertibleTo(Json::nullValue));
+  JSONTEST_ASSERT(null_.isConvertibleTo(Json::intValue));
+  JSONTEST_ASSERT(null_.isConvertibleTo(Json::uintValue));
+  JSONTEST_ASSERT(null_.isConvertibleTo(Json::realValue));
+  JSONTEST_ASSERT(null_.isConvertibleTo(Json::booleanValue));
+  JSONTEST_ASSERT(null_.isConvertibleTo(Json::stringValue));
+  JSONTEST_ASSERT(null_.isConvertibleTo(Json::arrayValue));
+  JSONTEST_ASSERT(null_.isConvertibleTo(Json::objectValue));
+
+  JSONTEST_ASSERT_EQUAL(Json::Int(0), null_.asInt());
+  JSONTEST_ASSERT_EQUAL(Json::LargestInt(0), null_.asLargestInt());
+  JSONTEST_ASSERT_EQUAL(Json::UInt(0), null_.asUInt());
+  JSONTEST_ASSERT_EQUAL(Json::LargestUInt(0), null_.asLargestUInt());
+  JSONTEST_ASSERT_EQUAL(0.0, null_.asDouble());
+  JSONTEST_ASSERT_EQUAL(0.0, null_.asFloat());
+  JSONTEST_ASSERT_STRING_EQUAL("", null_.asString());
+
+  JSONTEST_ASSERT_EQUAL(Json::Value::nullSingleton(), null_);
+
+  // Test using a Value in a boolean context (false iff null)
+  JSONTEST_ASSERT_EQUAL(null_, false);
+  JSONTEST_ASSERT_EQUAL(object1_, true);
+  JSONTEST_ASSERT_EQUAL(!null_, true);
+  JSONTEST_ASSERT_EQUAL(!object1_, false);
+}
+
+JSONTEST_FIXTURE_LOCAL(ValueTest, strings) {
+  JSONTEST_ASSERT_EQUAL(Json::stringValue, string1_.type());
+
+  IsCheck checks;
+  checks.isString_ = true;
+  JSONTEST_ASSERT_PRED(checkIs(emptyString_, checks));
+  JSONTEST_ASSERT_PRED(checkIs(string_, checks));
+  JSONTEST_ASSERT_PRED(checkIs(string1_, checks));
+
+  // Empty string okay
+  JSONTEST_ASSERT(emptyString_.isConvertibleTo(Json::nullValue));
+
+  // Non-empty string not okay
+  JSONTEST_ASSERT(!string1_.isConvertibleTo(Json::nullValue));
+
+  // Always okay
+  JSONTEST_ASSERT(string1_.isConvertibleTo(Json::stringValue));
+
+  // Never okay
+  JSONTEST_ASSERT(!string1_.isConvertibleTo(Json::objectValue));
+  JSONTEST_ASSERT(!string1_.isConvertibleTo(Json::arrayValue));
+  JSONTEST_ASSERT(!string1_.isConvertibleTo(Json::intValue));
+  JSONTEST_ASSERT(!string1_.isConvertibleTo(Json::uintValue));
+  JSONTEST_ASSERT(!string1_.isConvertibleTo(Json::realValue));
+
+  JSONTEST_ASSERT_STRING_EQUAL("a", string1_.asString());
+  JSONTEST_ASSERT_STRING_EQUAL("a", string1_.asCString());
+}
+
+JSONTEST_FIXTURE_LOCAL(ValueTest, bools) {
+  JSONTEST_ASSERT_EQUAL(Json::booleanValue, false_.type());
+
+  IsCheck checks;
+  checks.isBool_ = true;
+  JSONTEST_ASSERT_PRED(checkIs(false_, checks));
+  JSONTEST_ASSERT_PRED(checkIs(true_, checks));
+
+  // False okay
+  JSONTEST_ASSERT(false_.isConvertibleTo(Json::nullValue));
+
+  // True not okay
+  JSONTEST_ASSERT(!true_.isConvertibleTo(Json::nullValue));
+
+  // Always okay
+  JSONTEST_ASSERT(true_.isConvertibleTo(Json::intValue));
+  JSONTEST_ASSERT(true_.isConvertibleTo(Json::uintValue));
+  JSONTEST_ASSERT(true_.isConvertibleTo(Json::realValue));
+  JSONTEST_ASSERT(true_.isConvertibleTo(Json::booleanValue));
+  JSONTEST_ASSERT(true_.isConvertibleTo(Json::stringValue));
+
+  // Never okay
+  JSONTEST_ASSERT(!true_.isConvertibleTo(Json::arrayValue));
+  JSONTEST_ASSERT(!true_.isConvertibleTo(Json::objectValue));
+
+  JSONTEST_ASSERT_EQUAL(true, true_.asBool());
+  JSONTEST_ASSERT_EQUAL(1, true_.asInt());
+  JSONTEST_ASSERT_EQUAL(1, true_.asLargestInt());
+  JSONTEST_ASSERT_EQUAL(1, true_.asUInt());
+  JSONTEST_ASSERT_EQUAL(1, true_.asLargestUInt());
+  JSONTEST_ASSERT_EQUAL(1.0, true_.asDouble());
+  JSONTEST_ASSERT_EQUAL(1.0, true_.asFloat());
+
+  JSONTEST_ASSERT_EQUAL(false, false_.asBool());
+  JSONTEST_ASSERT_EQUAL(0, false_.asInt());
+  JSONTEST_ASSERT_EQUAL(0, false_.asLargestInt());
+  JSONTEST_ASSERT_EQUAL(0, false_.asUInt());
+  JSONTEST_ASSERT_EQUAL(0, false_.asLargestUInt());
+  JSONTEST_ASSERT_EQUAL(0.0, false_.asDouble());
+  JSONTEST_ASSERT_EQUAL(0.0, false_.asFloat());
+}
+
+JSONTEST_FIXTURE_LOCAL(ValueTest, integers) {
+  IsCheck checks;
+  Json::Value val;
+
+  // Conversions that don't depend on the value.
+  JSONTEST_ASSERT(Json::Value(17).isConvertibleTo(Json::realValue));
+  JSONTEST_ASSERT(Json::Value(17).isConvertibleTo(Json::stringValue));
+  JSONTEST_ASSERT(Json::Value(17).isConvertibleTo(Json::booleanValue));
+  JSONTEST_ASSERT(!Json::Value(17).isConvertibleTo(Json::arrayValue));
+  JSONTEST_ASSERT(!Json::Value(17).isConvertibleTo(Json::objectValue));
+
+  JSONTEST_ASSERT(Json::Value(17U).isConvertibleTo(Json::realValue));
+  JSONTEST_ASSERT(Json::Value(17U).isConvertibleTo(Json::stringValue));
+  JSONTEST_ASSERT(Json::Value(17U).isConvertibleTo(Json::booleanValue));
+  JSONTEST_ASSERT(!Json::Value(17U).isConvertibleTo(Json::arrayValue));
+  JSONTEST_ASSERT(!Json::Value(17U).isConvertibleTo(Json::objectValue));
+
+  JSONTEST_ASSERT(Json::Value(17.0).isConvertibleTo(Json::realValue));
+  JSONTEST_ASSERT(Json::Value(17.0).isConvertibleTo(Json::stringValue));
+  JSONTEST_ASSERT(Json::Value(17.0).isConvertibleTo(Json::booleanValue));
+  JSONTEST_ASSERT(!Json::Value(17.0).isConvertibleTo(Json::arrayValue));
+  JSONTEST_ASSERT(!Json::Value(17.0).isConvertibleTo(Json::objectValue));
+
+  // Default int
+  val = Json::Value(Json::intValue);
+
+  JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
+
+  checks = IsCheck();
+  checks.isInt_ = true;
+  checks.isInt64_ = true;
+  checks.isUInt_ = true;
+  checks.isUInt64_ = true;
+  checks.isIntegral_ = true;
+  checks.isDouble_ = true;
+  checks.isNumeric_ = true;
+  JSONTEST_ASSERT_PRED(checkIs(val, checks));
+
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::nullValue));
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
+
+  JSONTEST_ASSERT_EQUAL(0, val.asInt());
+  JSONTEST_ASSERT_EQUAL(0, val.asLargestInt());
+  JSONTEST_ASSERT_EQUAL(0, val.asUInt());
+  JSONTEST_ASSERT_EQUAL(0, val.asLargestUInt());
+  JSONTEST_ASSERT_EQUAL(0.0, val.asDouble());
+  JSONTEST_ASSERT_EQUAL(0.0, val.asFloat());
+  JSONTEST_ASSERT_EQUAL(false, val.asBool());
+  JSONTEST_ASSERT_STRING_EQUAL("0", val.asString());
+
+  // Default uint
+  val = Json::Value(Json::uintValue);
+
+  JSONTEST_ASSERT_EQUAL(Json::uintValue, val.type());
+
+  checks = IsCheck();
+  checks.isInt_ = true;
+  checks.isInt64_ = true;
+  checks.isUInt_ = true;
+  checks.isUInt64_ = true;
+  checks.isIntegral_ = true;
+  checks.isDouble_ = true;
+  checks.isNumeric_ = true;
+  JSONTEST_ASSERT_PRED(checkIs(val, checks));
+
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::nullValue));
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
+
+  JSONTEST_ASSERT_EQUAL(0, val.asInt());
+  JSONTEST_ASSERT_EQUAL(0, val.asLargestInt());
+  JSONTEST_ASSERT_EQUAL(0, val.asUInt());
+  JSONTEST_ASSERT_EQUAL(0, val.asLargestUInt());
+  JSONTEST_ASSERT_EQUAL(0.0, val.asDouble());
+  JSONTEST_ASSERT_EQUAL(0.0, val.asFloat());
+  JSONTEST_ASSERT_EQUAL(false, val.asBool());
+  JSONTEST_ASSERT_STRING_EQUAL("0", val.asString());
+
+  // Default real
+  val = Json::Value(Json::realValue);
+
+  JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
+
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::nullValue));
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
+
+  checks = IsCheck();
+  checks.isInt_ = true;
+  checks.isInt64_ = true;
+  checks.isUInt_ = true;
+  checks.isUInt64_ = true;
+  checks.isIntegral_ = true;
+  checks.isDouble_ = true;
+  checks.isNumeric_ = true;
+  JSONTEST_ASSERT_PRED(checkIs(val, checks));
+
+  JSONTEST_ASSERT_EQUAL(0, val.asInt());
+  JSONTEST_ASSERT_EQUAL(0, val.asLargestInt());
+  JSONTEST_ASSERT_EQUAL(0, val.asUInt());
+  JSONTEST_ASSERT_EQUAL(0, val.asLargestUInt());
+  JSONTEST_ASSERT_EQUAL(0.0, val.asDouble());
+  JSONTEST_ASSERT_EQUAL(0.0, val.asFloat());
+  JSONTEST_ASSERT_EQUAL(false, val.asBool());
+  JSONTEST_ASSERT_STRING_EQUAL("0.0", val.asString());
+
+  // Zero (signed constructor arg)
+  val = Json::Value(0);
+
+  JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
+
+  checks = IsCheck();
+  checks.isInt_ = true;
+  checks.isInt64_ = true;
+  checks.isUInt_ = true;
+  checks.isUInt64_ = true;
+  checks.isIntegral_ = true;
+  checks.isDouble_ = true;
+  checks.isNumeric_ = true;
+  JSONTEST_ASSERT_PRED(checkIs(val, checks));
+
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::nullValue));
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
+
+  JSONTEST_ASSERT_EQUAL(0, val.asInt());
+  JSONTEST_ASSERT_EQUAL(0, val.asLargestInt());
+  JSONTEST_ASSERT_EQUAL(0, val.asUInt());
+  JSONTEST_ASSERT_EQUAL(0, val.asLargestUInt());
+  JSONTEST_ASSERT_EQUAL(0.0, val.asDouble());
+  JSONTEST_ASSERT_EQUAL(0.0, val.asFloat());
+  JSONTEST_ASSERT_EQUAL(false, val.asBool());
+  JSONTEST_ASSERT_STRING_EQUAL("0", val.asString());
+
+  // Zero (unsigned constructor arg)
+  val = Json::Value(0u);
+
+  JSONTEST_ASSERT_EQUAL(Json::uintValue, val.type());
+
+  checks = IsCheck();
+  checks.isInt_ = true;
+  checks.isInt64_ = true;
+  checks.isUInt_ = true;
+  checks.isUInt64_ = true;
+  checks.isIntegral_ = true;
+  checks.isDouble_ = true;
+  checks.isNumeric_ = true;
+  JSONTEST_ASSERT_PRED(checkIs(val, checks));
+
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::nullValue));
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
+
+  JSONTEST_ASSERT_EQUAL(0, val.asInt());
+  JSONTEST_ASSERT_EQUAL(0, val.asLargestInt());
+  JSONTEST_ASSERT_EQUAL(0, val.asUInt());
+  JSONTEST_ASSERT_EQUAL(0, val.asLargestUInt());
+  JSONTEST_ASSERT_EQUAL(0.0, val.asDouble());
+  JSONTEST_ASSERT_EQUAL(0.0, val.asFloat());
+  JSONTEST_ASSERT_EQUAL(false, val.asBool());
+  JSONTEST_ASSERT_STRING_EQUAL("0", val.asString());
+
+  // Zero (floating-point constructor arg)
+  val = Json::Value(0.0);
+
+  JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
+
+  checks = IsCheck();
+  checks.isInt_ = true;
+  checks.isInt64_ = true;
+  checks.isUInt_ = true;
+  checks.isUInt64_ = true;
+  checks.isIntegral_ = true;
+  checks.isDouble_ = true;
+  checks.isNumeric_ = true;
+  JSONTEST_ASSERT_PRED(checkIs(val, checks));
+
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::nullValue));
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
+
+  JSONTEST_ASSERT_EQUAL(0, val.asInt());
+  JSONTEST_ASSERT_EQUAL(0, val.asLargestInt());
+  JSONTEST_ASSERT_EQUAL(0, val.asUInt());
+  JSONTEST_ASSERT_EQUAL(0, val.asLargestUInt());
+  JSONTEST_ASSERT_EQUAL(0.0, val.asDouble());
+  JSONTEST_ASSERT_EQUAL(0.0, val.asFloat());
+  JSONTEST_ASSERT_EQUAL(false, val.asBool());
+  JSONTEST_ASSERT_STRING_EQUAL("0.0", val.asString());
+
+  // 2^20 (signed constructor arg)
+  val = Json::Value(1 << 20);
+
+  JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
+  checks = IsCheck();
+  checks.isInt_ = true;
+  checks.isInt64_ = true;
+  checks.isUInt_ = true;
+  checks.isUInt64_ = true;
+  checks.isIntegral_ = true;
+  checks.isDouble_ = true;
+  checks.isNumeric_ = true;
+  JSONTEST_ASSERT_PRED(checkIs(val, checks));
+
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
+
+  JSONTEST_ASSERT_EQUAL((1 << 20), val.asInt());
+  JSONTEST_ASSERT_EQUAL((1 << 20), val.asLargestInt());
+  JSONTEST_ASSERT_EQUAL((1 << 20), val.asUInt());
+  JSONTEST_ASSERT_EQUAL((1 << 20), val.asLargestUInt());
+  JSONTEST_ASSERT_EQUAL((1 << 20), val.asDouble());
+  JSONTEST_ASSERT_EQUAL((1 << 20), val.asFloat());
+  JSONTEST_ASSERT_EQUAL(true, val.asBool());
+  JSONTEST_ASSERT_STRING_EQUAL("1048576", val.asString());
+
+  // 2^20 (unsigned constructor arg)
+  val = Json::Value(Json::UInt(1 << 20));
+
+  JSONTEST_ASSERT_EQUAL(Json::uintValue, val.type());
+
+  checks = IsCheck();
+  checks.isInt_ = true;
+  checks.isInt64_ = true;
+  checks.isUInt_ = true;
+  checks.isUInt64_ = true;
+  checks.isIntegral_ = true;
+  checks.isDouble_ = true;
+  checks.isNumeric_ = true;
+  JSONTEST_ASSERT_PRED(checkIs(val, checks));
+
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
+
+  JSONTEST_ASSERT_EQUAL((1 << 20), val.asInt());
+  JSONTEST_ASSERT_EQUAL((1 << 20), val.asLargestInt());
+  JSONTEST_ASSERT_EQUAL((1 << 20), val.asUInt());
+  JSONTEST_ASSERT_EQUAL((1 << 20), val.asLargestUInt());
+  JSONTEST_ASSERT_EQUAL((1 << 20), val.asDouble());
+  JSONTEST_ASSERT_EQUAL((1 << 20), val.asFloat());
+  JSONTEST_ASSERT_EQUAL(true, val.asBool());
+  JSONTEST_ASSERT_STRING_EQUAL("1048576", val.asString());
+
+  // 2^20 (floating-point constructor arg)
+  val = Json::Value((1 << 20) / 1.0);
+
+  JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
+
+  checks = IsCheck();
+  checks.isInt_ = true;
+  checks.isInt64_ = true;
+  checks.isUInt_ = true;
+  checks.isUInt64_ = true;
+  checks.isIntegral_ = true;
+  checks.isDouble_ = true;
+  checks.isNumeric_ = true;
+  JSONTEST_ASSERT_PRED(checkIs(val, checks));
+
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
+
+  JSONTEST_ASSERT_EQUAL((1 << 20), val.asInt());
+  JSONTEST_ASSERT_EQUAL((1 << 20), val.asLargestInt());
+  JSONTEST_ASSERT_EQUAL((1 << 20), val.asUInt());
+  JSONTEST_ASSERT_EQUAL((1 << 20), val.asLargestUInt());
+  JSONTEST_ASSERT_EQUAL((1 << 20), val.asDouble());
+  JSONTEST_ASSERT_EQUAL((1 << 20), val.asFloat());
+  JSONTEST_ASSERT_EQUAL(true, val.asBool());
+  JSONTEST_ASSERT_STRING_EQUAL(
+      "1048576.0",
+      normalizeFloatingPointStr(JsonTest::ToJsonString(val.asString())));
+
+  // -2^20
+  val = Json::Value(-(1 << 20));
+
+  JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
+
+  checks = IsCheck();
+  checks.isInt_ = true;
+  checks.isInt64_ = true;
+  checks.isIntegral_ = true;
+  checks.isDouble_ = true;
+  checks.isNumeric_ = true;
+  JSONTEST_ASSERT_PRED(checkIs(val, checks));
+
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
+
+  JSONTEST_ASSERT_EQUAL(-(1 << 20), val.asInt());
+  JSONTEST_ASSERT_EQUAL(-(1 << 20), val.asLargestInt());
+  JSONTEST_ASSERT_EQUAL(-(1 << 20), val.asDouble());
+  JSONTEST_ASSERT_EQUAL(-(1 << 20), val.asFloat());
+  JSONTEST_ASSERT_EQUAL(true, val.asBool());
+  JSONTEST_ASSERT_STRING_EQUAL("-1048576", val.asString());
+
+  // int32 max
+  val = Json::Value(kint32max);
+
+  JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
+
+  checks = IsCheck();
+  checks.isInt_ = true;
+  checks.isInt64_ = true;
+  checks.isUInt_ = true;
+  checks.isUInt64_ = true;
+  checks.isIntegral_ = true;
+  checks.isDouble_ = true;
+  checks.isNumeric_ = true;
+  JSONTEST_ASSERT_PRED(checkIs(val, checks));
+
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
+
+  JSONTEST_ASSERT_EQUAL(kint32max, val.asInt());
+  JSONTEST_ASSERT_EQUAL(kint32max, val.asLargestInt());
+  JSONTEST_ASSERT_EQUAL(kint32max, val.asUInt());
+  JSONTEST_ASSERT_EQUAL(kint32max, val.asLargestUInt());
+  JSONTEST_ASSERT_EQUAL(kint32max, val.asDouble());
+  JSONTEST_ASSERT_EQUAL(kfint32max, val.asFloat());
+  JSONTEST_ASSERT_EQUAL(true, val.asBool());
+  JSONTEST_ASSERT_STRING_EQUAL("2147483647", val.asString());
+
+  // int32 min
+  val = Json::Value(kint32min);
+
+  JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
+
+  checks = IsCheck();
+  checks.isInt_ = true;
+  checks.isInt64_ = true;
+  checks.isIntegral_ = true;
+  checks.isDouble_ = true;
+  checks.isNumeric_ = true;
+  JSONTEST_ASSERT_PRED(checkIs(val, checks));
+
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
+
+  JSONTEST_ASSERT_EQUAL(kint32min, val.asInt());
+  JSONTEST_ASSERT_EQUAL(kint32min, val.asLargestInt());
+  JSONTEST_ASSERT_EQUAL(kint32min, val.asDouble());
+  JSONTEST_ASSERT_EQUAL(kint32min, val.asFloat());
+  JSONTEST_ASSERT_EQUAL(true, val.asBool());
+  JSONTEST_ASSERT_STRING_EQUAL("-2147483648", val.asString());
+
+  // uint32 max
+  val = Json::Value(kuint32max);
+
+  JSONTEST_ASSERT_EQUAL(Json::uintValue, val.type());
+
+  checks = IsCheck();
+  checks.isInt64_ = true;
+  checks.isUInt_ = true;
+  checks.isUInt64_ = true;
+  checks.isIntegral_ = true;
+  checks.isDouble_ = true;
+  checks.isNumeric_ = true;
+  JSONTEST_ASSERT_PRED(checkIs(val, checks));
+
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
+
+#ifndef JSON_NO_INT64
+  JSONTEST_ASSERT_EQUAL(kuint32max, val.asLargestInt());
+#endif
+  JSONTEST_ASSERT_EQUAL(kuint32max, val.asUInt());
+  JSONTEST_ASSERT_EQUAL(kuint32max, val.asLargestUInt());
+  JSONTEST_ASSERT_EQUAL(kuint32max, val.asDouble());
+  JSONTEST_ASSERT_EQUAL(kfuint32max, val.asFloat());
+  JSONTEST_ASSERT_EQUAL(true, val.asBool());
+  JSONTEST_ASSERT_STRING_EQUAL("4294967295", val.asString());
+
+#ifdef JSON_NO_INT64
+  // int64 max
+  val = Json::Value(double(kint64max));
+
+  JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
+
+  checks = IsCheck();
+  checks.isDouble_ = true;
+  checks.isNumeric_ = true;
+  JSONTEST_ASSERT_PRED(checkIs(val, checks));
+
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
+
+  JSONTEST_ASSERT_EQUAL(double(kint64max), val.asDouble());
+  JSONTEST_ASSERT_EQUAL(float(kint64max), val.asFloat());
+  JSONTEST_ASSERT_EQUAL(true, val.asBool());
+  JSONTEST_ASSERT_STRING_EQUAL("9.22337e+18", val.asString());
+
+  // int64 min
+  val = Json::Value(double(kint64min));
+
+  JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
+
+  checks = IsCheck();
+  checks.isDouble_ = true;
+  checks.isNumeric_ = true;
+  JSONTEST_ASSERT_PRED(checkIs(val, checks));
+
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
+
+  JSONTEST_ASSERT_EQUAL(double(kint64min), val.asDouble());
+  JSONTEST_ASSERT_EQUAL(float(kint64min), val.asFloat());
+  JSONTEST_ASSERT_EQUAL(true, val.asBool());
+  JSONTEST_ASSERT_STRING_EQUAL("-9.22337e+18", val.asString());
+
+  // uint64 max
+  val = Json::Value(double(kuint64max));
+
+  JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
+
+  checks = IsCheck();
+  checks.isDouble_ = true;
+  checks.isNumeric_ = true;
+  JSONTEST_ASSERT_PRED(checkIs(val, checks));
+
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
+
+  JSONTEST_ASSERT_EQUAL(double(kuint64max), val.asDouble());
+  JSONTEST_ASSERT_EQUAL(float(kuint64max), val.asFloat());
+  JSONTEST_ASSERT_EQUAL(true, val.asBool());
+  JSONTEST_ASSERT_STRING_EQUAL("1.84467e+19", val.asString());
+#else // ifdef JSON_NO_INT64
+  // 2^40 (signed constructor arg)
+  val = Json::Value(Json::Int64(1) << 40);
+
+  JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
+
+  checks = IsCheck();
+  checks.isInt64_ = true;
+  checks.isUInt64_ = true;
+  checks.isIntegral_ = true;
+  checks.isDouble_ = true;
+  checks.isNumeric_ = true;
+  JSONTEST_ASSERT_PRED(checkIs(val, checks));
+
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
+
+  JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asInt64());
+  JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asLargestInt());
+  JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asUInt64());
+  JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asLargestUInt());
+  JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asDouble());
+  JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asFloat());
+  JSONTEST_ASSERT_EQUAL(true, val.asBool());
+  JSONTEST_ASSERT_STRING_EQUAL("1099511627776", val.asString());
+
+  // 2^40 (unsigned constructor arg)
+  val = Json::Value(Json::UInt64(1) << 40);
+
+  JSONTEST_ASSERT_EQUAL(Json::uintValue, val.type());
+
+  checks = IsCheck();
+  checks.isInt64_ = true;
+  checks.isUInt64_ = true;
+  checks.isIntegral_ = true;
+  checks.isDouble_ = true;
+  checks.isNumeric_ = true;
+  JSONTEST_ASSERT_PRED(checkIs(val, checks));
+
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
+
+  JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asInt64());
+  JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asLargestInt());
+  JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asUInt64());
+  JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asLargestUInt());
+  JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asDouble());
+  JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asFloat());
+  JSONTEST_ASSERT_EQUAL(true, val.asBool());
+  JSONTEST_ASSERT_STRING_EQUAL("1099511627776", val.asString());
+
+  // 2^40 (floating-point constructor arg)
+  val = Json::Value((Json::Int64(1) << 40) / 1.0);
+
+  JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
+
+  checks = IsCheck();
+  checks.isInt64_ = true;
+  checks.isUInt64_ = true;
+  checks.isIntegral_ = true;
+  checks.isDouble_ = true;
+  checks.isNumeric_ = true;
+  JSONTEST_ASSERT_PRED(checkIs(val, checks));
+
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
+
+  JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asInt64());
+  JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asLargestInt());
+  JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asUInt64());
+  JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asLargestUInt());
+  JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asDouble());
+  JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asFloat());
+  JSONTEST_ASSERT_EQUAL(true, val.asBool());
+  JSONTEST_ASSERT_STRING_EQUAL(
+      "1099511627776.0",
+      normalizeFloatingPointStr(JsonTest::ToJsonString(val.asString())));
+
+  // -2^40
+  val = Json::Value(-(Json::Int64(1) << 40));
+
+  JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
+
+  checks = IsCheck();
+  checks.isInt64_ = true;
+  checks.isIntegral_ = true;
+  checks.isDouble_ = true;
+  checks.isNumeric_ = true;
+  JSONTEST_ASSERT_PRED(checkIs(val, checks));
+
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
+
+  JSONTEST_ASSERT_EQUAL(-(Json::Int64(1) << 40), val.asInt64());
+  JSONTEST_ASSERT_EQUAL(-(Json::Int64(1) << 40), val.asLargestInt());
+  JSONTEST_ASSERT_EQUAL(-(Json::Int64(1) << 40), val.asDouble());
+  JSONTEST_ASSERT_EQUAL(-(Json::Int64(1) << 40), val.asFloat());
+  JSONTEST_ASSERT_EQUAL(true, val.asBool());
+  JSONTEST_ASSERT_STRING_EQUAL("-1099511627776", val.asString());
+
+  // int64 max
+  val = Json::Value(Json::Int64(kint64max));
+
+  JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
+
+  checks = IsCheck();
+  checks.isInt64_ = true;
+  checks.isUInt64_ = true;
+  checks.isIntegral_ = true;
+  checks.isDouble_ = true;
+  checks.isNumeric_ = true;
+  JSONTEST_ASSERT_PRED(checkIs(val, checks));
+
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
+
+  JSONTEST_ASSERT_EQUAL(kint64max, val.asInt64());
+  JSONTEST_ASSERT_EQUAL(kint64max, val.asLargestInt());
+  JSONTEST_ASSERT_EQUAL(kint64max, val.asUInt64());
+  JSONTEST_ASSERT_EQUAL(kint64max, val.asLargestUInt());
+  JSONTEST_ASSERT_EQUAL(double(kint64max), val.asDouble());
+  JSONTEST_ASSERT_EQUAL(float(kint64max), val.asFloat());
+  JSONTEST_ASSERT_EQUAL(true, val.asBool());
+  JSONTEST_ASSERT_STRING_EQUAL("9223372036854775807", val.asString());
+
+  // int64 max (floating point constructor). Note that kint64max is not exactly
+  // representable as a double, and will be rounded up to be higher.
+  val = Json::Value(double(kint64max));
+
+  JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
+
+  checks = IsCheck();
+  checks.isUInt64_ = true;
+  checks.isIntegral_ = true;
+  checks.isDouble_ = true;
+  checks.isNumeric_ = true;
+  JSONTEST_ASSERT_PRED(checkIs(val, checks));
+
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
+
+  JSONTEST_ASSERT_EQUAL(Json::UInt64(1) << 63, val.asUInt64());
+  JSONTEST_ASSERT_EQUAL(Json::UInt64(1) << 63, val.asLargestUInt());
+  JSONTEST_ASSERT_EQUAL(uint64ToDouble(Json::UInt64(1) << 63), val.asDouble());
+  JSONTEST_ASSERT_EQUAL(float(Json::UInt64(1) << 63), val.asFloat());
+
+  JSONTEST_ASSERT_EQUAL(true, val.asBool());
+  JSONTEST_ASSERT_STRING_EQUAL(
+      "9.2233720368547758e+18",
+      normalizeFloatingPointStr(JsonTest::ToJsonString(val.asString())));
+
+  // int64 min
+  val = Json::Value(Json::Int64(kint64min));
+
+  JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
+
+  checks = IsCheck();
+  checks.isInt64_ = true;
+  checks.isIntegral_ = true;
+  checks.isDouble_ = true;
+  checks.isNumeric_ = true;
+  JSONTEST_ASSERT_PRED(checkIs(val, checks));
+
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
+
+  JSONTEST_ASSERT_EQUAL(kint64min, val.asInt64());
+  JSONTEST_ASSERT_EQUAL(kint64min, val.asLargestInt());
+  JSONTEST_ASSERT_EQUAL(double(kint64min), val.asDouble());
+  JSONTEST_ASSERT_EQUAL(float(kint64min), val.asFloat());
+  JSONTEST_ASSERT_EQUAL(true, val.asBool());
+  JSONTEST_ASSERT_STRING_EQUAL("-9223372036854775808", val.asString());
+
+  // int64 min (floating point constructor). Note that kint64min *is* exactly
+  // representable as a double.
+  val = Json::Value(double(kint64min));
+
+  JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
+
+  checks = IsCheck();
+  checks.isInt64_ = true;
+  checks.isIntegral_ = true;
+  checks.isDouble_ = true;
+  checks.isNumeric_ = true;
+  JSONTEST_ASSERT_PRED(checkIs(val, checks));
+
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
+
+  JSONTEST_ASSERT_EQUAL(kint64min, val.asInt64());
+  JSONTEST_ASSERT_EQUAL(kint64min, val.asLargestInt());
+  JSONTEST_ASSERT_EQUAL(-9223372036854775808.0, val.asDouble());
+  JSONTEST_ASSERT_EQUAL(-9223372036854775808.0, val.asFloat());
+  JSONTEST_ASSERT_EQUAL(true, val.asBool());
+  JSONTEST_ASSERT_STRING_EQUAL(
+      "-9.2233720368547758e+18",
+      normalizeFloatingPointStr(JsonTest::ToJsonString(val.asString())));
+
+  // 10^19
+  const auto ten_to_19 = static_cast<Json::UInt64>(1e19);
+  val = Json::Value(Json::UInt64(ten_to_19));
+
+  JSONTEST_ASSERT_EQUAL(Json::uintValue, val.type());
+
+  checks = IsCheck();
+  checks.isUInt64_ = true;
+  checks.isIntegral_ = true;
+  checks.isDouble_ = true;
+  checks.isNumeric_ = true;
+  JSONTEST_ASSERT_PRED(checkIs(val, checks));
+
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
+
+  JSONTEST_ASSERT_EQUAL(ten_to_19, val.asUInt64());
+  JSONTEST_ASSERT_EQUAL(ten_to_19, val.asLargestUInt());
+  JSONTEST_ASSERT_EQUAL(uint64ToDouble(ten_to_19), val.asDouble());
+  JSONTEST_ASSERT_EQUAL(float(uint64ToDouble(ten_to_19)), val.asFloat());
+  JSONTEST_ASSERT_EQUAL(true, val.asBool());
+  JSONTEST_ASSERT_STRING_EQUAL("10000000000000000000", val.asString());
+
+  // 10^19 (double constructor). Note that 10^19 is not exactly representable
+  // as a double.
+  val = Json::Value(uint64ToDouble(ten_to_19));
+
+  JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
+
+  checks = IsCheck();
+  checks.isUInt64_ = true;
+  checks.isIntegral_ = true;
+  checks.isDouble_ = true;
+  checks.isNumeric_ = true;
+  JSONTEST_ASSERT_PRED(checkIs(val, checks));
+
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
+
+  JSONTEST_ASSERT_EQUAL(1e19, val.asDouble());
+  JSONTEST_ASSERT_EQUAL(1e19, val.asFloat());
+  JSONTEST_ASSERT_EQUAL(true, val.asBool());
+  JSONTEST_ASSERT_STRING_EQUAL(
+      "1e+19",
+      normalizeFloatingPointStr(JsonTest::ToJsonString(val.asString())));
+
+  // uint64 max
+  val = Json::Value(Json::UInt64(kuint64max));
+
+  JSONTEST_ASSERT_EQUAL(Json::uintValue, val.type());
+
+  checks = IsCheck();
+  checks.isUInt64_ = true;
+  checks.isIntegral_ = true;
+  checks.isDouble_ = true;
+  checks.isNumeric_ = true;
+  JSONTEST_ASSERT_PRED(checkIs(val, checks));
+
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
+
+  JSONTEST_ASSERT_EQUAL(kuint64max, val.asUInt64());
+  JSONTEST_ASSERT_EQUAL(kuint64max, val.asLargestUInt());
+  JSONTEST_ASSERT_EQUAL(uint64ToDouble(kuint64max), val.asDouble());
+  JSONTEST_ASSERT_EQUAL(float(uint64ToDouble(kuint64max)), val.asFloat());
+  JSONTEST_ASSERT_EQUAL(true, val.asBool());
+  JSONTEST_ASSERT_STRING_EQUAL("18446744073709551615", val.asString());
+
+  // uint64 max (floating point constructor). Note that kuint64max is not
+  // exactly representable as a double, and will be rounded up to be higher.
+  val = Json::Value(uint64ToDouble(kuint64max));
+
+  JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
+
+  checks = IsCheck();
+  checks.isDouble_ = true;
+  checks.isNumeric_ = true;
+  JSONTEST_ASSERT_PRED(checkIs(val, checks));
+
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
+
+  JSONTEST_ASSERT_EQUAL(18446744073709551616.0, val.asDouble());
+  JSONTEST_ASSERT_EQUAL(18446744073709551616.0, val.asFloat());
+  JSONTEST_ASSERT_EQUAL(true, val.asBool());
+  JSONTEST_ASSERT_STRING_EQUAL(
+      "1.8446744073709552e+19",
+      normalizeFloatingPointStr(JsonTest::ToJsonString(val.asString())));
+#endif
+}
+
+JSONTEST_FIXTURE_LOCAL(ValueTest, nonIntegers) {
+  IsCheck checks;
+  Json::Value val;
+
+  // Small positive number
+  val = Json::Value(1.5);
+
+  JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
+
+  checks = IsCheck();
+  checks.isDouble_ = true;
+  checks.isNumeric_ = true;
+  JSONTEST_ASSERT_PRED(checkIs(val, checks));
+
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::realValue));
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::booleanValue));
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::stringValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::arrayValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::objectValue));
+
+  JSONTEST_ASSERT_EQUAL(1.5, val.asDouble());
+  JSONTEST_ASSERT_EQUAL(1.5, val.asFloat());
+  JSONTEST_ASSERT_EQUAL(1, val.asInt());
+  JSONTEST_ASSERT_EQUAL(1, val.asLargestInt());
+  JSONTEST_ASSERT_EQUAL(1, val.asUInt());
+  JSONTEST_ASSERT_EQUAL(1, val.asLargestUInt());
+  JSONTEST_ASSERT_EQUAL(true, val.asBool());
+  JSONTEST_ASSERT_EQUAL("1.5", val.asString());
+
+  // Small negative number
+  val = Json::Value(-1.5);
+
+  JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
+
+  checks = IsCheck();
+  checks.isDouble_ = true;
+  checks.isNumeric_ = true;
+  JSONTEST_ASSERT_PRED(checkIs(val, checks));
+
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::realValue));
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::booleanValue));
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::stringValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::arrayValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::objectValue));
+
+  JSONTEST_ASSERT_EQUAL(-1.5, val.asDouble());
+  JSONTEST_ASSERT_EQUAL(-1.5, val.asFloat());
+  JSONTEST_ASSERT_EQUAL(-1, val.asInt());
+  JSONTEST_ASSERT_EQUAL(-1, val.asLargestInt());
+  JSONTEST_ASSERT_EQUAL(true, val.asBool());
+  JSONTEST_ASSERT_EQUAL("-1.5", val.asString());
+
+  // A bit over int32 max
+  val = Json::Value(kint32max + 0.5);
+
+  JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
+
+  checks = IsCheck();
+  checks.isDouble_ = true;
+  checks.isNumeric_ = true;
+  JSONTEST_ASSERT_PRED(checkIs(val, checks));
+
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::realValue));
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::booleanValue));
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::stringValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::arrayValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::objectValue));
+
+  JSONTEST_ASSERT_EQUAL(2147483647.5, val.asDouble());
+  JSONTEST_ASSERT_EQUAL(float(2147483647.5), val.asFloat());
+  JSONTEST_ASSERT_EQUAL(2147483647U, val.asUInt());
+#ifdef JSON_HAS_INT64
+  JSONTEST_ASSERT_EQUAL(2147483647L, val.asLargestInt());
+  JSONTEST_ASSERT_EQUAL(2147483647U, val.asLargestUInt());
+#endif
+  JSONTEST_ASSERT_EQUAL(true, val.asBool());
+  JSONTEST_ASSERT_EQUAL(
+      "2147483647.5",
+      normalizeFloatingPointStr(JsonTest::ToJsonString(val.asString())));
+
+  // A bit under int32 min
+  val = Json::Value(kint32min - 0.5);
+
+  JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
+
+  checks = IsCheck();
+  checks.isDouble_ = true;
+  checks.isNumeric_ = true;
+  JSONTEST_ASSERT_PRED(checkIs(val, checks));
+
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::realValue));
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::booleanValue));
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::stringValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::arrayValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::objectValue));
+
+  JSONTEST_ASSERT_EQUAL(-2147483648.5, val.asDouble());
+  JSONTEST_ASSERT_EQUAL(float(-2147483648.5), val.asFloat());
+#ifdef JSON_HAS_INT64
+  JSONTEST_ASSERT_EQUAL(-(Json::Int64(1) << 31), val.asLargestInt());
+#endif
+  JSONTEST_ASSERT_EQUAL(true, val.asBool());
+  JSONTEST_ASSERT_EQUAL(
+      "-2147483648.5",
+      normalizeFloatingPointStr(JsonTest::ToJsonString(val.asString())));
+
+  // A bit over uint32 max
+  val = Json::Value(kuint32max + 0.5);
+
+  JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
+
+  checks = IsCheck();
+  checks.isDouble_ = true;
+  checks.isNumeric_ = true;
+  JSONTEST_ASSERT_PRED(checkIs(val, checks));
+
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::realValue));
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::booleanValue));
+  JSONTEST_ASSERT(val.isConvertibleTo(Json::stringValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::arrayValue));
+  JSONTEST_ASSERT(!val.isConvertibleTo(Json::objectValue));
+
+  JSONTEST_ASSERT_EQUAL(4294967295.5, val.asDouble());
+  JSONTEST_ASSERT_EQUAL(float(4294967295.5), val.asFloat());
+#ifdef JSON_HAS_INT64
+  JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 32) - 1, val.asLargestInt());
+  JSONTEST_ASSERT_EQUAL((Json::UInt64(1) << 32) - Json::UInt64(1),
+                        val.asLargestUInt());
+#endif
+  JSONTEST_ASSERT_EQUAL(true, val.asBool());
+  JSONTEST_ASSERT_EQUAL(
+      "4294967295.5",
+      normalizeFloatingPointStr(JsonTest::ToJsonString(val.asString())));
+
+  val = Json::Value(1.2345678901234);
+  JSONTEST_ASSERT_STRING_EQUAL(
+      "1.2345678901234001",
+      normalizeFloatingPointStr(JsonTest::ToJsonString(val.asString())));
+
+  // A 16-digit floating point number.
+  val = Json::Value(2199023255552000.0f);
+  JSONTEST_ASSERT_EQUAL(float(2199023255552000.0f), val.asFloat());
+  JSONTEST_ASSERT_STRING_EQUAL(
+      "2199023255552000.0",
+      normalizeFloatingPointStr(JsonTest::ToJsonString(val.asString())));
+
+  // A very large floating point number.
+  val = Json::Value(3.402823466385289e38);
+  JSONTEST_ASSERT_EQUAL(float(3.402823466385289e38), val.asFloat());
+  JSONTEST_ASSERT_STRING_EQUAL(
+      "3.402823466385289e+38",
+      normalizeFloatingPointStr(JsonTest::ToJsonString(val.asString())));
+
+  // An even larger floating point number.
+  val = Json::Value(1.2345678e300);
+  JSONTEST_ASSERT_EQUAL(double(1.2345678e300), val.asDouble());
+  JSONTEST_ASSERT_STRING_EQUAL(
+      "1.2345678e+300",
+      normalizeFloatingPointStr(JsonTest::ToJsonString(val.asString())));
+}
+
+void ValueTest::checkConstMemberCount(const Json::Value& value,
+                                      unsigned int expectedCount) {
+  unsigned int count = 0;
+  Json::Value::const_iterator itEnd = value.end();
+  for (Json::Value::const_iterator it = value.begin(); it != itEnd; ++it) {
+    ++count;
+  }
+  JSONTEST_ASSERT_EQUAL(expectedCount, count) << "Json::Value::const_iterator";
+}
+
+void ValueTest::checkMemberCount(Json::Value& value,
+                                 unsigned int expectedCount) {
+  JSONTEST_ASSERT_EQUAL(expectedCount, value.size());
+
+  unsigned int count = 0;
+  Json::Value::iterator itEnd = value.end();
+  for (Json::Value::iterator it = value.begin(); it != itEnd; ++it) {
+    ++count;
+  }
+  JSONTEST_ASSERT_EQUAL(expectedCount, count) << "Json::Value::iterator";
+
+  JSONTEST_ASSERT_PRED(checkConstMemberCount(value, expectedCount));
+}
+
+ValueTest::IsCheck::IsCheck() = default;
+
+void ValueTest::checkIs(const Json::Value& value, const IsCheck& check) {
+  JSONTEST_ASSERT_EQUAL(check.isObject_, value.isObject());
+  JSONTEST_ASSERT_EQUAL(check.isArray_, value.isArray());
+  JSONTEST_ASSERT_EQUAL(check.isBool_, value.isBool());
+  JSONTEST_ASSERT_EQUAL(check.isDouble_, value.isDouble());
+  JSONTEST_ASSERT_EQUAL(check.isInt_, value.isInt());
+  JSONTEST_ASSERT_EQUAL(check.isUInt_, value.isUInt());
+  JSONTEST_ASSERT_EQUAL(check.isIntegral_, value.isIntegral());
+  JSONTEST_ASSERT_EQUAL(check.isNumeric_, value.isNumeric());
+  JSONTEST_ASSERT_EQUAL(check.isString_, value.isString());
+  JSONTEST_ASSERT_EQUAL(check.isNull_, value.isNull());
+
+#ifdef JSON_HAS_INT64
+  JSONTEST_ASSERT_EQUAL(check.isInt64_, value.isInt64());
+  JSONTEST_ASSERT_EQUAL(check.isUInt64_, value.isUInt64());
+#else
+  JSONTEST_ASSERT_EQUAL(false, value.isInt64());
+  JSONTEST_ASSERT_EQUAL(false, value.isUInt64());
+#endif
+}
+
+JSONTEST_FIXTURE_LOCAL(ValueTest, compareNull) {
+  JSONTEST_ASSERT_PRED(checkIsEqual(Json::Value(), Json::Value()));
+  JSONTEST_ASSERT_PRED(
+      checkIsEqual(Json::Value::nullSingleton(), Json::Value()));
+  JSONTEST_ASSERT_PRED(
+      checkIsEqual(Json::Value::nullSingleton(), Json::Value::nullSingleton()));
+}
+
+JSONTEST_FIXTURE_LOCAL(ValueTest, compareInt) {
+  JSONTEST_ASSERT_PRED(checkIsLess(0, 10));
+  JSONTEST_ASSERT_PRED(checkIsEqual(10, 10));
+  JSONTEST_ASSERT_PRED(checkIsEqual(-10, -10));
+  JSONTEST_ASSERT_PRED(checkIsLess(-10, 0));
+}
+
+JSONTEST_FIXTURE_LOCAL(ValueTest, compareUInt) {
+  JSONTEST_ASSERT_PRED(checkIsLess(0u, 10u));
+  JSONTEST_ASSERT_PRED(checkIsLess(0u, Json::Value::maxUInt));
+  JSONTEST_ASSERT_PRED(checkIsEqual(10u, 10u));
+}
+
+JSONTEST_FIXTURE_LOCAL(ValueTest, compareDouble) {
+  JSONTEST_ASSERT_PRED(checkIsLess(0.0, 10.0));
+  JSONTEST_ASSERT_PRED(checkIsEqual(10.0, 10.0));
+  JSONTEST_ASSERT_PRED(checkIsEqual(-10.0, -10.0));
+  JSONTEST_ASSERT_PRED(checkIsLess(-10.0, 0.0));
+}
+
+JSONTEST_FIXTURE_LOCAL(ValueTest, compareString) {
+  JSONTEST_ASSERT_PRED(checkIsLess("", " "));
+  JSONTEST_ASSERT_PRED(checkIsLess("", "a"));
+  JSONTEST_ASSERT_PRED(checkIsLess("abcd", "zyui"));
+  JSONTEST_ASSERT_PRED(checkIsLess("abc", "abcd"));
+  JSONTEST_ASSERT_PRED(checkIsEqual("abcd", "abcd"));
+  JSONTEST_ASSERT_PRED(checkIsEqual(" ", " "));
+  JSONTEST_ASSERT_PRED(checkIsLess("ABCD", "abcd"));
+  JSONTEST_ASSERT_PRED(checkIsEqual("ABCD", "ABCD"));
+}
+
+JSONTEST_FIXTURE_LOCAL(ValueTest, compareBoolean) {
+  JSONTEST_ASSERT_PRED(checkIsLess(false, true));
+  JSONTEST_ASSERT_PRED(checkIsEqual(false, false));
+  JSONTEST_ASSERT_PRED(checkIsEqual(true, true));
+}
+
+JSONTEST_FIXTURE_LOCAL(ValueTest, compareArray) {
+  // array compare size then content
+  Json::Value emptyArray(Json::arrayValue);
+  Json::Value l1aArray;
+  l1aArray.append(0);
+  Json::Value l1bArray;
+  l1bArray.append(10);
+  Json::Value l2aArray;
+  l2aArray.append(0);
+  l2aArray.append(0);
+  Json::Value l2bArray;
+  l2bArray.append(0);
+  l2bArray.append(10);
+  JSONTEST_ASSERT_PRED(checkIsLess(emptyArray, l1aArray));
+  JSONTEST_ASSERT_PRED(checkIsLess(emptyArray, l2aArray));
+  JSONTEST_ASSERT_PRED(checkIsLess(l1aArray, l1bArray));
+  JSONTEST_ASSERT_PRED(checkIsLess(l1bArray, l2aArray));
+  JSONTEST_ASSERT_PRED(checkIsLess(l2aArray, l2bArray));
+  JSONTEST_ASSERT_PRED(checkIsEqual(emptyArray, Json::Value(emptyArray)));
+  JSONTEST_ASSERT_PRED(checkIsEqual(l1aArray, Json::Value(l1aArray)));
+  JSONTEST_ASSERT_PRED(checkIsEqual(l1bArray, Json::Value(l1bArray)));
+  JSONTEST_ASSERT_PRED(checkIsEqual(l2aArray, Json::Value(l2aArray)));
+  JSONTEST_ASSERT_PRED(checkIsEqual(l2bArray, Json::Value(l2bArray)));
+}
+
+JSONTEST_FIXTURE_LOCAL(ValueTest, compareObject) {
+  // object compare size then content
+  Json::Value emptyObject(Json::objectValue);
+  Json::Value l1aObject;
+  l1aObject["key1"] = 0;
+  Json::Value l1bObject;
+  l1bObject["key1"] = 10;
+  Json::Value l2aObject;
+  l2aObject["key1"] = 0;
+  l2aObject["key2"] = 0;
+  Json::Value l2bObject;
+  l2bObject["key1"] = 10;
+  l2bObject["key2"] = 0;
+  JSONTEST_ASSERT_PRED(checkIsLess(emptyObject, l1aObject));
+  JSONTEST_ASSERT_PRED(checkIsLess(l1aObject, l1bObject));
+  JSONTEST_ASSERT_PRED(checkIsLess(l1bObject, l2aObject));
+  JSONTEST_ASSERT_PRED(checkIsLess(l2aObject, l2bObject));
+  JSONTEST_ASSERT_PRED(checkIsEqual(emptyObject, Json::Value(emptyObject)));
+  JSONTEST_ASSERT_PRED(checkIsEqual(l1aObject, Json::Value(l1aObject)));
+  JSONTEST_ASSERT_PRED(checkIsEqual(l1bObject, Json::Value(l1bObject)));
+  JSONTEST_ASSERT_PRED(checkIsEqual(l2aObject, Json::Value(l2aObject)));
+  JSONTEST_ASSERT_PRED(checkIsEqual(l2bObject, Json::Value(l2bObject)));
+  {
+    Json::Value aObject;
+    aObject["a"] = 10;
+    Json::Value bObject;
+    bObject["b"] = 0;
+    Json::Value cObject;
+    cObject["c"] = 20;
+    cObject["f"] = 15;
+    Json::Value dObject;
+    dObject["d"] = -2;
+    dObject["e"] = 10;
+    JSONTEST_ASSERT_PRED(checkIsLess(aObject, bObject));
+    JSONTEST_ASSERT_PRED(checkIsLess(bObject, cObject));
+    JSONTEST_ASSERT_PRED(checkIsLess(cObject, dObject));
+    JSONTEST_ASSERT_PRED(checkIsEqual(aObject, Json::Value(aObject)));
+    JSONTEST_ASSERT_PRED(checkIsEqual(bObject, Json::Value(bObject)));
+    JSONTEST_ASSERT_PRED(checkIsEqual(cObject, Json::Value(cObject)));
+    JSONTEST_ASSERT_PRED(checkIsEqual(dObject, Json::Value(dObject)));
+  }
+}
+
+JSONTEST_FIXTURE_LOCAL(ValueTest, compareType) {
+  // object of different type are ordered according to their type
+  JSONTEST_ASSERT_PRED(checkIsLess(Json::Value(), Json::Value(1)));
+  JSONTEST_ASSERT_PRED(checkIsLess(Json::Value(1), Json::Value(1u)));
+  JSONTEST_ASSERT_PRED(checkIsLess(Json::Value(1u), Json::Value(1.0)));
+  JSONTEST_ASSERT_PRED(checkIsLess(Json::Value(1.0), Json::Value("a")));
+  JSONTEST_ASSERT_PRED(checkIsLess(Json::Value("a"), Json::Value(true)));
+  JSONTEST_ASSERT_PRED(
+      checkIsLess(Json::Value(true), Json::Value(Json::arrayValue)));
+  JSONTEST_ASSERT_PRED(checkIsLess(Json::Value(Json::arrayValue),
+                                   Json::Value(Json::objectValue)));
+}
+
+JSONTEST_FIXTURE_LOCAL(ValueTest, CopyObject) {
+  Json::Value arrayVal;
+  arrayVal.append("val1");
+  arrayVal.append("val2");
+  arrayVal.append("val3");
+  Json::Value stringVal("string value");
+  Json::Value copy1, copy2;
+  {
+    Json::Value arrayCopy, stringCopy;
+    arrayCopy.copy(arrayVal);
+    stringCopy.copy(stringVal);
+    JSONTEST_ASSERT_PRED(checkIsEqual(arrayCopy, arrayVal));
+    JSONTEST_ASSERT_PRED(checkIsEqual(stringCopy, stringVal));
+    arrayCopy.append("val4");
+    JSONTEST_ASSERT(arrayCopy.size() == 4);
+    arrayVal.append("new4");
+    arrayVal.append("new5");
+    JSONTEST_ASSERT(arrayVal.size() == 5);
+    JSONTEST_ASSERT(!(arrayCopy == arrayVal));
+    stringCopy = "another string";
+    JSONTEST_ASSERT(!(stringCopy == stringVal));
+    copy1.copy(arrayCopy);
+    copy2.copy(stringCopy);
+  }
+  JSONTEST_ASSERT(arrayVal.size() == 5);
+  JSONTEST_ASSERT(stringVal == "string value");
+  JSONTEST_ASSERT(copy1.size() == 4);
+  JSONTEST_ASSERT(copy2 == "another string");
+  copy1.copy(stringVal);
+  JSONTEST_ASSERT(copy1 == "string value");
+  copy2.copy(arrayVal);
+  JSONTEST_ASSERT(copy2.size() == 5);
+  {
+    Json::Value srcObject, objectCopy, otherObject;
+    srcObject["key0"] = 10;
+    objectCopy.copy(srcObject);
+    JSONTEST_ASSERT(srcObject["key0"] == 10);
+    JSONTEST_ASSERT(objectCopy["key0"] == 10);
+    JSONTEST_ASSERT(srcObject.getMemberNames().size() == 1);
+    JSONTEST_ASSERT(objectCopy.getMemberNames().size() == 1);
+    otherObject["key1"] = 15;
+    otherObject["key2"] = 16;
+    JSONTEST_ASSERT(otherObject.getMemberNames().size() == 2);
+    objectCopy.copy(otherObject);
+    JSONTEST_ASSERT(objectCopy["key1"] == 15);
+    JSONTEST_ASSERT(objectCopy["key2"] == 16);
+    JSONTEST_ASSERT(objectCopy.getMemberNames().size() == 2);
+    otherObject["key1"] = 20;
+    JSONTEST_ASSERT(objectCopy["key1"] == 15);
+  }
+}
+
+void ValueTest::checkIsLess(const Json::Value& x, const Json::Value& y) {
+  JSONTEST_ASSERT(x < y);
+  JSONTEST_ASSERT(y > x);
+  JSONTEST_ASSERT(x <= y);
+  JSONTEST_ASSERT(y >= x);
+  JSONTEST_ASSERT(!(x == y));
+  JSONTEST_ASSERT(!(y == x));
+  JSONTEST_ASSERT(!(x >= y));
+  JSONTEST_ASSERT(!(y <= x));
+  JSONTEST_ASSERT(!(x > y));
+  JSONTEST_ASSERT(!(y < x));
+  JSONTEST_ASSERT(x.compare(y) < 0);
+  JSONTEST_ASSERT(y.compare(x) >= 0);
+}
+
+void ValueTest::checkIsEqual(const Json::Value& x, const Json::Value& y) {
+  JSONTEST_ASSERT(x == y);
+  JSONTEST_ASSERT(y == x);
+  JSONTEST_ASSERT(x <= y);
+  JSONTEST_ASSERT(y <= x);
+  JSONTEST_ASSERT(x >= y);
+  JSONTEST_ASSERT(y >= x);
+  JSONTEST_ASSERT(!(x < y));
+  JSONTEST_ASSERT(!(y < x));
+  JSONTEST_ASSERT(!(x > y));
+  JSONTEST_ASSERT(!(y > x));
+  JSONTEST_ASSERT(x.compare(y) == 0);
+  JSONTEST_ASSERT(y.compare(x) == 0);
+}
+
+JSONTEST_FIXTURE_LOCAL(ValueTest, typeChecksThrowExceptions) {
+#if JSON_USE_EXCEPTION
+
+  Json::Value intVal(1);
+  Json::Value strVal("Test");
+  Json::Value objVal(Json::objectValue);
+  Json::Value arrVal(Json::arrayValue);
+
+  JSONTEST_ASSERT_THROWS(intVal["test"]);
+  JSONTEST_ASSERT_THROWS(strVal["test"]);
+  JSONTEST_ASSERT_THROWS(arrVal["test"]);
+
+  JSONTEST_ASSERT_THROWS(intVal.removeMember("test"));
+  JSONTEST_ASSERT_THROWS(strVal.removeMember("test"));
+  JSONTEST_ASSERT_THROWS(arrVal.removeMember("test"));
+
+  JSONTEST_ASSERT_THROWS(intVal.getMemberNames());
+  JSONTEST_ASSERT_THROWS(strVal.getMemberNames());
+  JSONTEST_ASSERT_THROWS(arrVal.getMemberNames());
+
+  JSONTEST_ASSERT_THROWS(intVal[0]);
+  JSONTEST_ASSERT_THROWS(objVal[0]);
+  JSONTEST_ASSERT_THROWS(strVal[0]);
+
+  JSONTEST_ASSERT_THROWS(intVal.clear());
+
+  JSONTEST_ASSERT_THROWS(intVal.resize(1));
+  JSONTEST_ASSERT_THROWS(strVal.resize(1));
+  JSONTEST_ASSERT_THROWS(objVal.resize(1));
+
+  JSONTEST_ASSERT_THROWS(intVal.asCString());
+
+  JSONTEST_ASSERT_THROWS(objVal.asString());
+  JSONTEST_ASSERT_THROWS(arrVal.asString());
+
+  JSONTEST_ASSERT_THROWS(strVal.asInt());
+  JSONTEST_ASSERT_THROWS(objVal.asInt());
+  JSONTEST_ASSERT_THROWS(arrVal.asInt());
+
+  JSONTEST_ASSERT_THROWS(strVal.asUInt());
+  JSONTEST_ASSERT_THROWS(objVal.asUInt());
+  JSONTEST_ASSERT_THROWS(arrVal.asUInt());
+
+  JSONTEST_ASSERT_THROWS(strVal.asInt64());
+  JSONTEST_ASSERT_THROWS(objVal.asInt64());
+  JSONTEST_ASSERT_THROWS(arrVal.asInt64());
+
+  JSONTEST_ASSERT_THROWS(strVal.asUInt64());
+  JSONTEST_ASSERT_THROWS(objVal.asUInt64());
+  JSONTEST_ASSERT_THROWS(arrVal.asUInt64());
+
+  JSONTEST_ASSERT_THROWS(strVal.asDouble());
+  JSONTEST_ASSERT_THROWS(objVal.asDouble());
+  JSONTEST_ASSERT_THROWS(arrVal.asDouble());
+
+  JSONTEST_ASSERT_THROWS(strVal.asFloat());
+  JSONTEST_ASSERT_THROWS(objVal.asFloat());
+  JSONTEST_ASSERT_THROWS(arrVal.asFloat());
+
+  JSONTEST_ASSERT_THROWS(strVal.asBool());
+  JSONTEST_ASSERT_THROWS(objVal.asBool());
+  JSONTEST_ASSERT_THROWS(arrVal.asBool());
+
+#endif
+}
+
+JSONTEST_FIXTURE_LOCAL(ValueTest, offsetAccessors) {
+  Json::Value x;
+  JSONTEST_ASSERT(x.getOffsetStart() == 0);
+  JSONTEST_ASSERT(x.getOffsetLimit() == 0);
+  x.setOffsetStart(10);
+  x.setOffsetLimit(20);
+  JSONTEST_ASSERT(x.getOffsetStart() == 10);
+  JSONTEST_ASSERT(x.getOffsetLimit() == 20);
+  Json::Value y(x);
+  JSONTEST_ASSERT(y.getOffsetStart() == 10);
+  JSONTEST_ASSERT(y.getOffsetLimit() == 20);
+  Json::Value z;
+  z.swap(y);
+  JSONTEST_ASSERT(z.getOffsetStart() == 10);
+  JSONTEST_ASSERT(z.getOffsetLimit() == 20);
+  JSONTEST_ASSERT(y.getOffsetStart() == 0);
+  JSONTEST_ASSERT(y.getOffsetLimit() == 0);
+}
+
+JSONTEST_FIXTURE_LOCAL(ValueTest, StaticString) {
+  char mutant[] = "hello";
+  Json::StaticString ss(mutant);
+  Json::String regular(mutant);
+  mutant[1] = 'a';
+  JSONTEST_ASSERT_STRING_EQUAL("hallo", ss.c_str());
+  JSONTEST_ASSERT_STRING_EQUAL("hello", regular.c_str());
+  {
+    Json::Value root;
+    root["top"] = ss;
+    JSONTEST_ASSERT_STRING_EQUAL("hallo", root["top"].asString());
+    mutant[1] = 'u';
+    JSONTEST_ASSERT_STRING_EQUAL("hullo", root["top"].asString());
+  }
+  {
+    Json::Value root;
+    root["top"] = regular;
+    JSONTEST_ASSERT_STRING_EQUAL("hello", root["top"].asString());
+    mutant[1] = 'u';
+    JSONTEST_ASSERT_STRING_EQUAL("hello", root["top"].asString());
+  }
+}
+
+JSONTEST_FIXTURE_LOCAL(ValueTest, WideString) {
+  // https://github.com/open-source-parsers/jsoncpp/issues/756
+  const std::string uni = u8"\u5f0f\uff0c\u8fdb"; // "式，进"
+  std::string styled;
+  {
+    Json::Value v;
+    v["abc"] = uni;
+    styled = v.toStyledString();
+  }
+  Json::Value root;
+  {
+    JSONCPP_STRING errs;
+    std::istringstream iss(styled);
+    bool ok = parseFromStream(Json::CharReaderBuilder(), iss, &root, &errs);
+    JSONTEST_ASSERT(ok);
+    if (!ok) {
+      std::cerr << "errs: " << errs << std::endl;
+    }
+  }
+  JSONTEST_ASSERT_STRING_EQUAL(root["abc"].asString(), uni);
+}
+
+JSONTEST_FIXTURE_LOCAL(ValueTest, CommentBefore) {
+  Json::Value val; // fill val
+  val.setComment(Json::String("// this comment should appear before"),
+                 Json::commentBefore);
+  Json::StreamWriterBuilder wbuilder;
+  wbuilder.settings_["commentStyle"] = "All";
+  {
+    char const expected[] = "// this comment should appear before\nnull";
+    Json::String result = Json::writeString(wbuilder, val);
+    JSONTEST_ASSERT_STRING_EQUAL(expected, result);
+    Json::String res2 = val.toStyledString();
+    Json::String exp2 = "\n";
+    exp2 += expected;
+    exp2 += "\n";
+    JSONTEST_ASSERT_STRING_EQUAL(exp2, res2);
+  }
+  Json::Value other = "hello";
+  val.swapPayload(other);
+  {
+    char const expected[] = "// this comment should appear before\n\"hello\"";
+    Json::String result = Json::writeString(wbuilder, val);
+    JSONTEST_ASSERT_STRING_EQUAL(expected, result);
+    Json::String res2 = val.toStyledString();
+    Json::String exp2 = "\n";
+    exp2 += expected;
+    exp2 += "\n";
+    JSONTEST_ASSERT_STRING_EQUAL(exp2, res2);
+    JSONTEST_ASSERT_STRING_EQUAL("null\n", other.toStyledString());
+  }
+  val = "hello";
+  // val.setComment("// this comment should appear before",
+  // Json::CommentPlacement::commentBefore); Assignment over-writes comments.
+  {
+    char const expected[] = "\"hello\"";
+    Json::String result = Json::writeString(wbuilder, val);
+    JSONTEST_ASSERT_STRING_EQUAL(expected, result);
+    Json::String res2 = val.toStyledString();
+    Json::String exp2;
+    exp2 += expected;
+    exp2 += "\n";
+    JSONTEST_ASSERT_STRING_EQUAL(exp2, res2);
+  }
+}
+
+JSONTEST_FIXTURE_LOCAL(ValueTest, zeroes) {
+  char const cstr[] = "h\0i";
+  Json::String binary(cstr, sizeof(cstr)); // include trailing 0
+  JSONTEST_ASSERT_EQUAL(4U, binary.length());
+  Json::StreamWriterBuilder b;
+  {
+    Json::Value root;
+    root = binary;
+    JSONTEST_ASSERT_STRING_EQUAL(binary, root.asString());
+  }
+  {
+    char const top[] = "top";
+    Json::Value root;
+    root[top] = binary;
+    JSONTEST_ASSERT_STRING_EQUAL(binary, root[top].asString());
+    Json::Value removed;
+    bool did;
+    did = root.removeMember(top, top + sizeof(top) - 1U, &removed);
+    JSONTEST_ASSERT(did);
+    JSONTEST_ASSERT_STRING_EQUAL(binary, removed.asString());
+    did = root.removeMember(top, top + sizeof(top) - 1U, &removed);
+    JSONTEST_ASSERT(!did);
+    JSONTEST_ASSERT_STRING_EQUAL(binary, removed.asString()); // still
+  }
+}
+
+JSONTEST_FIXTURE_LOCAL(ValueTest, zeroesInKeys) {
+  char const cstr[] = "h\0i";
+  Json::String binary(cstr, sizeof(cstr)); // include trailing 0
+  JSONTEST_ASSERT_EQUAL(4U, binary.length());
+  {
+    Json::Value root;
+    root[binary] = "there";
+    JSONTEST_ASSERT_STRING_EQUAL("there", root[binary].asString());
+    JSONTEST_ASSERT(!root.isMember("h"));
+    JSONTEST_ASSERT(root.isMember(binary));
+    JSONTEST_ASSERT_STRING_EQUAL(
+        "there", root.get(binary, Json::Value::nullSingleton()).asString());
+    Json::Value removed;
+    bool did;
+    did = root.removeMember(binary.data(), binary.data() + binary.length(),
+                            &removed);
+    JSONTEST_ASSERT(did);
+    JSONTEST_ASSERT_STRING_EQUAL("there", removed.asString());
+    did = root.removeMember(binary.data(), binary.data() + binary.length(),
+                            &removed);
+    JSONTEST_ASSERT(!did);
+    JSONTEST_ASSERT_STRING_EQUAL("there", removed.asString()); // still
+    JSONTEST_ASSERT(!root.isMember(binary));
+    JSONTEST_ASSERT_STRING_EQUAL(
+        "", root.get(binary, Json::Value::nullSingleton()).asString());
+  }
+}
+
+JSONTEST_FIXTURE_LOCAL(ValueTest, specialFloats) {
+  Json::StreamWriterBuilder b;
+  b.settings_["useSpecialFloats"] = true;
+
+  Json::Value v = std::numeric_limits<double>::quiet_NaN();
+  Json::String expected = "NaN";
+  Json::String result = Json::writeString(b, v);
+  JSONTEST_ASSERT_STRING_EQUAL(expected, result);
+
+  v = std::numeric_limits<double>::infinity();
+  expected = "Infinity";
+  result = Json::writeString(b, v);
+  JSONTEST_ASSERT_STRING_EQUAL(expected, result);
+
+  v = -std::numeric_limits<double>::infinity();
+  expected = "-Infinity";
+  result = Json::writeString(b, v);
+  JSONTEST_ASSERT_STRING_EQUAL(expected, result);
+}
+
+JSONTEST_FIXTURE_LOCAL(ValueTest, precision) {
+  Json::StreamWriterBuilder b;
+  b.settings_["precision"] = 5;
+
+  Json::Value v = 100.0 / 3;
+  Json::String expected = "33.333";
+  Json::String result = Json::writeString(b, v);
+  JSONTEST_ASSERT_STRING_EQUAL(expected, result);
+
+  v = 0.25000000;
+  expected = "0.25";
+  result = Json::writeString(b, v);
+  JSONTEST_ASSERT_STRING_EQUAL(expected, result);
+
+  v = 0.2563456;
+  expected = "0.25635";
+  result = Json::writeString(b, v);
+  JSONTEST_ASSERT_STRING_EQUAL(expected, result);
+
+  b.settings_["precision"] = 1;
+  expected = "0.3";
+  result = Json::writeString(b, v);
+  JSONTEST_ASSERT_STRING_EQUAL(expected, result);
+
+  b.settings_["precision"] = 17;
+  v = 1234857476305.256345694873740545068;
+  expected = "1234857476305.2563";
+  result = Json::writeString(b, v);
+  JSONTEST_ASSERT_STRING_EQUAL(expected, result);
+
+  b.settings_["precision"] = 24;
+  v = 0.256345694873740545068;
+  expected = "0.25634569487374054";
+  result = Json::writeString(b, v);
+  JSONTEST_ASSERT_STRING_EQUAL(expected, result);
+
+  b.settings_["precision"] = 5;
+  b.settings_["precisionType"] = "decimal";
+  v = 0.256345694873740545068;
+  expected = "0.25635";
+  result = Json::writeString(b, v);
+  JSONTEST_ASSERT_STRING_EQUAL(expected, result);
+
+  b.settings_["precision"] = 1;
+  b.settings_["precisionType"] = "decimal";
+  v = 0.256345694873740545068;
+  expected = "0.3";
+  result = Json::writeString(b, v);
+  JSONTEST_ASSERT_STRING_EQUAL(expected, result);
+
+  b.settings_["precision"] = 0;
+  b.settings_["precisionType"] = "decimal";
+  v = 123.56345694873740545068;
+  expected = "124";
+  result = Json::writeString(b, v);
+  JSONTEST_ASSERT_STRING_EQUAL(expected, result);
+
+  b.settings_["precision"] = 1;
+  b.settings_["precisionType"] = "decimal";
+  v = 1230.001;
+  expected = "1230.0";
+  result = Json::writeString(b, v);
+  JSONTEST_ASSERT_STRING_EQUAL(expected, result);
+
+  b.settings_["precision"] = 0;
+  b.settings_["precisionType"] = "decimal";
+  v = 1230.001;
+  expected = "1230";
+  result = Json::writeString(b, v);
+  JSONTEST_ASSERT_STRING_EQUAL(expected, result);
+
+  b.settings_["precision"] = 0;
+  b.settings_["precisionType"] = "decimal";
+  v = 1231.5;
+  expected = "1232";
+  result = Json::writeString(b, v);
+  JSONTEST_ASSERT_STRING_EQUAL(expected, result);
+
+  b.settings_["precision"] = 10;
+  b.settings_["precisionType"] = "decimal";
+  v = 0.23300000;
+  expected = "0.233";
+  result = Json::writeString(b, v);
+  JSONTEST_ASSERT_STRING_EQUAL(expected, result);
+}
+JSONTEST_FIXTURE_LOCAL(ValueTest, searchValueByPath) {
+  Json::Value root, subroot;
+  root["property1"][0] = 0;
+  root["property1"][1] = 1;
+  subroot["object"] = "object";
+  root["property2"] = subroot;
+
+  const Json::Value defaultValue("error");
+  Json::FastWriter writer;
+
+  {
+    const Json::String expected("{"
+                                "\"property1\":[0,1],"
+                                "\"property2\":{\"object\":\"object\"}"
+                                "}\n");
+    Json::String outcome = writer.write(root);
+    JSONTEST_ASSERT_STRING_EQUAL(expected, outcome);
+
+    // Array member exists.
+    const Json::Path path1(".property1.[%]", 1);
+    Json::Value result = path1.resolve(root);
+    JSONTEST_ASSERT_EQUAL(Json::Value(1), result);
+    result = path1.resolve(root, defaultValue);
+    JSONTEST_ASSERT_EQUAL(Json::Value(1), result);
+
+    // Array member does not exist.
+    const Json::Path path2(".property1.[2]");
+    result = path2.resolve(root);
+    JSONTEST_ASSERT_EQUAL(Json::nullValue, result);
+    result = path2.resolve(root, defaultValue);
+    JSONTEST_ASSERT_EQUAL(defaultValue, result);
+
+    // Access array path form error
+    const Json::Path path3(".property1.0");
+    result = path3.resolve(root);
+    JSONTEST_ASSERT_EQUAL(Json::nullValue, result);
+    result = path3.resolve(root, defaultValue);
+    JSONTEST_ASSERT_EQUAL(defaultValue, result);
+
+    // Object member exists.
+    const Json::Path path4(".property2.%", "object");
+    result = path4.resolve(root);
+    JSONTEST_ASSERT_EQUAL(Json::Value("object"), result);
+    result = path4.resolve(root, defaultValue);
+    JSONTEST_ASSERT_EQUAL(Json::Value("object"), result);
+
+    // Object member does not exist.
+    const Json::Path path5(".property2.hello");
+    result = path5.resolve(root);
+    JSONTEST_ASSERT_EQUAL(Json::nullValue, result);
+    result = path5.resolve(root, defaultValue);
+    JSONTEST_ASSERT_EQUAL(defaultValue, result);
+
+    // Access object path form error
+    const Json::Path path6(".property2.[0]");
+    result = path5.resolve(root);
+    JSONTEST_ASSERT_EQUAL(Json::nullValue, result);
+    result = path6.resolve(root, defaultValue);
+    JSONTEST_ASSERT_EQUAL(defaultValue, result);
+
+    // resolve will not change the value
+    outcome = writer.write(root);
+    JSONTEST_ASSERT_STRING_EQUAL(expected, outcome);
+  }
+  {
+    const Json::String expected("{"
+                                "\"property1\":[0,1,null],"
+                                "\"property2\":{"
+                                "\"hello\":null,"
+                                "\"object\":\"object\"}}\n");
+    Json::Path path1(".property1.[%]", 2);
+    Json::Value& value1 = path1.make(root);
+    JSONTEST_ASSERT_EQUAL(Json::nullValue, value1);
+
+    Json::Path path2(".property2.%", "hello");
+    Json::Value& value2 = path2.make(root);
+    JSONTEST_ASSERT_EQUAL(Json::nullValue, value2);
+
+    // make will change the value
+    const Json::String outcome = writer.write(root);
+    JSONTEST_ASSERT_STRING_EQUAL(expected, outcome);
+  }
+}
+struct FastWriterTest : JsonTest::TestCase {};
+
+JSONTEST_FIXTURE_LOCAL(FastWriterTest, dropNullPlaceholders) {
+  Json::FastWriter writer;
+  Json::Value nullValue;
+  JSONTEST_ASSERT(writer.write(nullValue) == "null\n");
+
+  writer.dropNullPlaceholders();
+  JSONTEST_ASSERT(writer.write(nullValue) == "\n");
+}
+
+JSONTEST_FIXTURE_LOCAL(FastWriterTest, enableYAMLCompatibility) {
+  Json::FastWriter writer;
+  Json::Value root;
+  root["hello"] = "world";
+
+  JSONTEST_ASSERT(writer.write(root) == "{\"hello\":\"world\"}\n");
+
+  writer.enableYAMLCompatibility();
+  JSONTEST_ASSERT(writer.write(root) == "{\"hello\": \"world\"}\n");
+}
+
+JSONTEST_FIXTURE_LOCAL(FastWriterTest, omitEndingLineFeed) {
+  Json::FastWriter writer;
+  Json::Value nullValue;
+
+  JSONTEST_ASSERT(writer.write(nullValue) == "null\n");
+
+  writer.omitEndingLineFeed();
+  JSONTEST_ASSERT(writer.write(nullValue) == "null");
+}
+
+JSONTEST_FIXTURE_LOCAL(FastWriterTest, writeNumericValue) {
+  Json::FastWriter writer;
+  const Json::String expected("{"
+                              "\"emptyValue\":null,"
+                              "\"false\":false,"
+                              "\"null\":\"null\","
+                              "\"number\":-6200000000000000.0,"
+                              "\"real\":1.256,"
+                              "\"uintValue\":17"
+                              "}\n");
+  Json::Value root;
+  root["emptyValue"] = Json::nullValue;
+  root["false"] = false;
+  root["null"] = "null";
+  root["number"] = -6.2e+15;
+  root["real"] = 1.256;
+  root["uintValue"] = Json::Value(17U);
+
+  const Json::String result = writer.write(root);
+  JSONTEST_ASSERT_STRING_EQUAL(expected, result);
+}
+
+JSONTEST_FIXTURE_LOCAL(FastWriterTest, writeArrays) {
+  Json::FastWriter writer;
+  const Json::String expected("{"
+                              "\"property1\":[\"value1\",\"value2\"],"
+                              "\"property2\":[]"
+                              "}\n");
+  Json::Value root;
+  root["property1"][0] = "value1";
+  root["property1"][1] = "value2";
+  root["property2"] = Json::arrayValue;
+
+  const Json::String result = writer.write(root);
+  JSONTEST_ASSERT_STRING_EQUAL(expected, result);
+}
+
+JSONTEST_FIXTURE_LOCAL(FastWriterTest, writeNestedObjects) {
+  Json::FastWriter writer;
+  const Json::String expected("{"
+                              "\"object1\":{"
+                              "\"bool\":true,"
+                              "\"nested\":123"
+                              "},"
+                              "\"object2\":{}"
+                              "}\n");
+  Json::Value root, child;
+  child["nested"] = 123;
+  child["bool"] = true;
+  root["object1"] = child;
+  root["object2"] = Json::objectValue;
+
+  const Json::String result = writer.write(root);
+  JSONTEST_ASSERT_STRING_EQUAL(expected, result);
+}
+
+struct StyledWriterTest : JsonTest::TestCase {};
+
+JSONTEST_FIXTURE_LOCAL(StyledWriterTest, writeNumericValue) {
+  Json::StyledWriter writer;
+  const Json::String expected("{\n"
+                              "   \"emptyValue\" : null,\n"
+                              "   \"false\" : false,\n"
+                              "   \"null\" : \"null\",\n"
+                              "   \"number\" : -6200000000000000.0,\n"
+                              "   \"real\" : 1.256,\n"
+                              "   \"uintValue\" : 17\n"
+                              "}\n");
+  Json::Value root;
+  root["emptyValue"] = Json::nullValue;
+  root["false"] = false;
+  root["null"] = "null";
+  root["number"] = -6.2e+15;
+  root["real"] = 1.256;
+  root["uintValue"] = Json::Value(17U);
+
+  const Json::String result = writer.write(root);
+  JSONTEST_ASSERT_STRING_EQUAL(expected, result);
+}
+
+JSONTEST_FIXTURE_LOCAL(StyledWriterTest, writeArrays) {
+  Json::StyledWriter writer;
+  const Json::String expected("{\n"
+                              "   \"property1\" : [ \"value1\", \"value2\" ],\n"
+                              "   \"property2\" : []\n"
+                              "}\n");
+  Json::Value root;
+  root["property1"][0] = "value1";
+  root["property1"][1] = "value2";
+  root["property2"] = Json::arrayValue;
+
+  const Json::String result = writer.write(root);
+  JSONTEST_ASSERT_STRING_EQUAL(expected, result);
+}
+
+JSONTEST_FIXTURE_LOCAL(StyledWriterTest, writeNestedObjects) {
+  Json::StyledWriter writer;
+  const Json::String expected("{\n"
+                              "   \"object1\" : {\n"
+                              "      \"bool\" : true,\n"
+                              "      \"nested\" : 123\n"
+                              "   },\n"
+                              "   \"object2\" : {}\n"
+                              "}\n");
+  Json::Value root, child;
+  child["nested"] = 123;
+  child["bool"] = true;
+  root["object1"] = child;
+  root["object2"] = Json::objectValue;
+
+  const Json::String result = writer.write(root);
+  JSONTEST_ASSERT_STRING_EQUAL(expected, result);
+}
+
+JSONTEST_FIXTURE_LOCAL(StyledWriterTest, multiLineArray) {
+  Json::StyledWriter writer;
+  {
+    // Array member has more than 20 print effect rendering lines
+    const Json::String expected("[\n   "
+                                "0,\n   1,\n   2,\n   "
+                                "3,\n   4,\n   5,\n   "
+                                "6,\n   7,\n   8,\n   "
+                                "9,\n   10,\n   11,\n   "
+                                "12,\n   13,\n   14,\n   "
+                                "15,\n   16,\n   17,\n   "
+                                "18,\n   19,\n   20\n]\n");
+    Json::Value root;
+    for (Json::ArrayIndex i = 0; i < 21; i++)
+      root[i] = i;
+    const Json::String result = writer.write(root);
+    JSONTEST_ASSERT_STRING_EQUAL(expected, result);
+  }
+  {
+    // Array members do not exceed 21 print effects to render a single line
+    const Json::String expected("[ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ]\n");
+    Json::Value root;
+    for (Json::ArrayIndex i = 0; i < 10; i++)
+      root[i] = i;
+    const Json::String result = writer.write(root);
+    JSONTEST_ASSERT_STRING_EQUAL(expected, result);
+  }
+}
+
+JSONTEST_FIXTURE_LOCAL(StyledWriterTest, writeValueWithComment) {
+  Json::StyledWriter writer;
+  {
+    const Json::String expected("\n//commentBeforeValue\n\"hello\"\n");
+    Json::Value root = "hello";
+    root.setComment(Json::String("//commentBeforeValue"), Json::commentBefore);
+    const Json::String result = writer.write(root);
+    JSONTEST_ASSERT_STRING_EQUAL(expected, result);
+  }
+  {
+    const Json::String expected("\"hello\" //commentAfterValueOnSameLine\n");
+    Json::Value root = "hello";
+    root.setComment(Json::String("//commentAfterValueOnSameLine"),
+                    Json::commentAfterOnSameLine);
+    const Json::String result = writer.write(root);
+    JSONTEST_ASSERT_STRING_EQUAL(expected, result);
+  }
+  {
+    const Json::String expected("\"hello\"\n//commentAfter\n\n");
+    Json::Value root = "hello";
+    root.setComment(Json::String("//commentAfter"), Json::commentAfter);
+    const Json::String result = writer.write(root);
+    JSONTEST_ASSERT_STRING_EQUAL(expected, result);
+  }
+}
+
+struct StyledStreamWriterTest : JsonTest::TestCase {};
+
+JSONTEST_FIXTURE_LOCAL(StyledStreamWriterTest, writeNumericValue) {
+  Json::StyledStreamWriter writer;
+  const Json::String expected("{\n"
+                              "\t\"emptyValue\" : null,\n"
+                              "\t\"false\" : false,\n"
+                              "\t\"null\" : \"null\",\n"
+                              "\t\"number\" : -6200000000000000.0,\n"
+                              "\t\"real\" : 1.256,\n"
+                              "\t\"uintValue\" : 17\n"
+                              "}\n");
+
+  Json::Value root;
+  root["emptyValue"] = Json::nullValue;
+  root["false"] = false;
+  root["null"] = "null";
+  root["number"] = -6.2e+15; // big float number
+  root["real"] = 1.256;      // float number
+  root["uintValue"] = Json::Value(17U);
+
+  Json::OStringStream sout;
+  writer.write(sout, root);
+  const Json::String result = sout.str();
+  JSONTEST_ASSERT_STRING_EQUAL(expected, result);
+}
+
+JSONTEST_FIXTURE_LOCAL(StyledStreamWriterTest, writeArrays) {
+  Json::StyledStreamWriter writer;
+  const Json::String expected("{\n"
+                              "\t\"property1\" : [ \"value1\", \"value2\" ],\n"
+                              "\t\"property2\" : []\n"
+                              "}\n");
+  Json::Value root;
+  root["property1"][0] = "value1";
+  root["property1"][1] = "value2";
+  root["property2"] = Json::arrayValue;
+
+  Json::OStringStream sout;
+  writer.write(sout, root);
+  const Json::String result = sout.str();
+  JSONTEST_ASSERT_STRING_EQUAL(expected, result);
+}
+
+JSONTEST_FIXTURE_LOCAL(StyledStreamWriterTest, writeNestedObjects) {
+  Json::StyledStreamWriter writer;
+  const Json::String expected("{\n"
+                              "\t\"object1\" : \n"
+                              "\t"
+                              "{\n"
+                              "\t\t\"bool\" : true,\n"
+                              "\t\t\"nested\" : 123\n"
+                              "\t},\n"
+                              "\t\"object2\" : {}\n"
+                              "}\n");
+  Json::Value root, child;
+  child["nested"] = 123;
+  child["bool"] = true;
+  root["object1"] = child;
+  root["object2"] = Json::objectValue;
+
+  Json::OStringStream sout;
+  writer.write(sout, root);
+  const Json::String result = sout.str();
+  JSONTEST_ASSERT_STRING_EQUAL(expected, result);
+}
+
+JSONTEST_FIXTURE_LOCAL(StyledStreamWriterTest, multiLineArray) {
+  {
+    // Array member has more than 20 print effect rendering lines
+    const Json::String expected("[\n\t0,"
+                                "\n\t1,"
+                                "\n\t2,"
+                                "\n\t3,"
+                                "\n\t4,"
+                                "\n\t5,"
+                                "\n\t6,"
+                                "\n\t7,"
+                                "\n\t8,"
+                                "\n\t9,"
+                                "\n\t10,"
+                                "\n\t11,"
+                                "\n\t12,"
+                                "\n\t13,"
+                                "\n\t14,"
+                                "\n\t15,"
+                                "\n\t16,"
+                                "\n\t17,"
+                                "\n\t18,"
+                                "\n\t19,"
+                                "\n\t20\n]\n");
+    Json::StyledStreamWriter writer;
+    Json::Value root;
+    for (Json::ArrayIndex i = 0; i < 21; i++)
+      root[i] = i;
+    Json::OStringStream sout;
+    writer.write(sout, root);
+    const Json::String result = sout.str();
+    JSONTEST_ASSERT_STRING_EQUAL(expected, result);
+  }
+  {
+    Json::StyledStreamWriter writer;
+    // Array members do not exceed 21 print effects to render a single line
+    const Json::String expected("[ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ]\n");
+    Json::Value root;
+    for (Json::ArrayIndex i = 0; i < 10; i++)
+      root[i] = i;
+    Json::OStringStream sout;
+    writer.write(sout, root);
+    const Json::String result = sout.str();
+    JSONTEST_ASSERT_STRING_EQUAL(expected, result);
+  }
+}
+
+JSONTEST_FIXTURE_LOCAL(StyledStreamWriterTest, writeValueWithComment) {
+  Json::StyledStreamWriter writer("\t");
+  {
+    const Json::String expected("//commentBeforeValue\n\"hello\"\n");
+    Json::Value root = "hello";
+    Json::OStringStream sout;
+    root.setComment(Json::String("//commentBeforeValue"), Json::commentBefore);
+    writer.write(sout, root);
+    const Json::String result = sout.str();
+    JSONTEST_ASSERT_STRING_EQUAL(expected, result);
+  }
+  {
+    const Json::String expected("\"hello\" //commentAfterValueOnSameLine\n");
+    Json::Value root = "hello";
+    Json::OStringStream sout;
+    root.setComment(Json::String("//commentAfterValueOnSameLine"),
+                    Json::commentAfterOnSameLine);
+    writer.write(sout, root);
+    const Json::String result = sout.str();
+    JSONTEST_ASSERT_STRING_EQUAL(expected, result);
+  }
+  {
+    const Json::String expected("\"hello\"\n//commentAfter\n");
+    Json::Value root = "hello";
+    Json::OStringStream sout;
+    root.setComment(Json::String("//commentAfter"), Json::commentAfter);
+    writer.write(sout, root);
+    const Json::String result = sout.str();
+    JSONTEST_ASSERT_STRING_EQUAL(expected, result);
+  }
+}
+
+struct StreamWriterTest : JsonTest::TestCase {};
+
+JSONTEST_FIXTURE_LOCAL(StreamWriterTest, writeNumericValue) {
+  Json::StreamWriterBuilder writer;
+  const Json::String expected("{\n"
+                              "\t\"emptyValue\" : null,\n"
+                              "\t\"false\" : false,\n"
+                              "\t\"null\" : \"null\",\n"
+                              "\t\"number\" : -6200000000000000.0,\n"
+                              "\t\"real\" : 1.256,\n"
+                              "\t\"uintValue\" : 17\n"
+                              "}");
+  Json::Value root;
+  root["emptyValue"] = Json::nullValue;
+  root["false"] = false;
+  root["null"] = "null";
+  root["number"] = -6.2e+15;
+  root["real"] = 1.256;
+  root["uintValue"] = Json::Value(17U);
+
+  const Json::String result = Json::writeString(writer, root);
+  JSONTEST_ASSERT_STRING_EQUAL(expected, result);
+}
+
+JSONTEST_FIXTURE_LOCAL(StreamWriterTest, writeArrays) {
+  Json::StreamWriterBuilder writer;
+  const Json::String expected("{\n"
+                              "\t\"property1\" : \n"
+                              "\t[\n"
+                              "\t\t\"value1\",\n"
+                              "\t\t\"value2\"\n"
+                              "\t],\n"
+                              "\t\"property2\" : []\n"
+                              "}");
+
+  Json::Value root;
+  root["property1"][0] = "value1";
+  root["property1"][1] = "value2";
+  root["property2"] = Json::arrayValue;
+
+  const Json::String result = Json::writeString(writer, root);
+  JSONTEST_ASSERT_STRING_EQUAL(expected, result);
+}
+
+JSONTEST_FIXTURE_LOCAL(StreamWriterTest, writeNestedObjects) {
+  Json::StreamWriterBuilder writer;
+  const Json::String expected("{\n"
+                              "\t\"object1\" : \n"
+                              "\t{\n"
+                              "\t\t\"bool\" : true,\n"
+                              "\t\t\"nested\" : 123\n"
+                              "\t},\n"
+                              "\t\"object2\" : {}\n"
+                              "}");
+
+  Json::Value root, child;
+  child["nested"] = 123;
+  child["bool"] = true;
+  root["object1"] = child;
+  root["object2"] = Json::objectValue;
+
+  const Json::String result = Json::writeString(writer, root);
+  JSONTEST_ASSERT_STRING_EQUAL(expected, result);
+}
+
+JSONTEST_FIXTURE_LOCAL(StreamWriterTest, multiLineArray) {
+  Json::StreamWriterBuilder wb;
+  wb.settings_["commentStyle"] = "None";
+  {
+    // When wb.settings_["commentStyle"] = "None", the effect of
+    // printing multiple lines will be displayed when there are
+    // more than 20 array members.
+    const Json::String expected("[\n\t0,"
+                                "\n\t1,"
+                                "\n\t2,"
+                                "\n\t3,"
+                                "\n\t4,"
+                                "\n\t5,"
+                                "\n\t6,"
+                                "\n\t7,"
+                                "\n\t8,"
+                                "\n\t9,"
+                                "\n\t10,"
+                                "\n\t11,"
+                                "\n\t12,"
+                                "\n\t13,"
+                                "\n\t14,"
+                                "\n\t15,"
+                                "\n\t16,"
+                                "\n\t17,"
+                                "\n\t18,"
+                                "\n\t19,"
+                                "\n\t20\n]");
+    Json::Value root;
+    for (Json::ArrayIndex i = 0; i < 21; i++)
+      root[i] = i;
+    const Json::String result = Json::writeString(wb, root);
+    JSONTEST_ASSERT_STRING_EQUAL(expected, result);
+  }
+  {
+    // Array members do not exceed 21 print effects to render a single line
+    const Json::String expected("[ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ]");
+    Json::Value root;
+    for (Json::ArrayIndex i = 0; i < 10; i++)
+      root[i] = i;
+    const Json::String result = Json::writeString(wb, root);
+    JSONTEST_ASSERT_STRING_EQUAL(expected, result);
+  }
+}
+
+JSONTEST_FIXTURE_LOCAL(StreamWriterTest, dropNullPlaceholders) {
+  Json::StreamWriterBuilder b;
+  Json::Value nullValue;
+  b.settings_["dropNullPlaceholders"] = false;
+  JSONTEST_ASSERT(Json::writeString(b, nullValue) == "null");
+  b.settings_["dropNullPlaceholders"] = true;
+  JSONTEST_ASSERT(Json::writeString(b, nullValue).empty());
+}
+
+JSONTEST_FIXTURE_LOCAL(StreamWriterTest, enableYAMLCompatibility) {
+  Json::StreamWriterBuilder b;
+  Json::Value root;
+  root["hello"] = "world";
+
+  b.settings_["indentation"] = "";
+  JSONTEST_ASSERT(Json::writeString(b, root) == "{\"hello\":\"world\"}");
+
+  b.settings_["enableYAMLCompatibility"] = true;
+  JSONTEST_ASSERT(Json::writeString(b, root) == "{\"hello\": \"world\"}");
+
+  b.settings_["enableYAMLCompatibility"] = false;
+  JSONTEST_ASSERT(Json::writeString(b, root) == "{\"hello\":\"world\"}");
+}
+
+JSONTEST_FIXTURE_LOCAL(StreamWriterTest, indentation) {
+  Json::StreamWriterBuilder b;
+  Json::Value root;
+  root["hello"] = "world";
+
+  b.settings_["indentation"] = "";
+  JSONTEST_ASSERT(Json::writeString(b, root) == "{\"hello\":\"world\"}");
+
+  b.settings_["indentation"] = "\t";
+  JSONTEST_ASSERT(Json::writeString(b, root) ==
+                  "{\n\t\"hello\" : \"world\"\n}");
+}
+
+JSONTEST_FIXTURE_LOCAL(StreamWriterTest, writeZeroes) {
+  Json::String binary("hi", 3); // include trailing 0
+  JSONTEST_ASSERT_EQUAL(3, binary.length());
+  Json::String expected(R"("hi\u0000")"); // unicoded zero
+  Json::StreamWriterBuilder b;
+  {
+    Json::Value root;
+    root = binary;
+    JSONTEST_ASSERT_STRING_EQUAL(binary, root.asString());
+    Json::String out = Json::writeString(b, root);
+    JSONTEST_ASSERT_EQUAL(expected.size(), out.size());
+    JSONTEST_ASSERT_STRING_EQUAL(expected, out);
+  }
+  {
+    Json::Value root;
+    root["top"] = binary;
+    JSONTEST_ASSERT_STRING_EQUAL(binary, root["top"].asString());
+    Json::String out = Json::writeString(b, root["top"]);
+    JSONTEST_ASSERT_STRING_EQUAL(expected, out);
+  }
+}
+
+JSONTEST_FIXTURE_LOCAL(StreamWriterTest, unicode) {
+  // Create a Json value containing UTF-8 string with some chars that need
+  // escape (tab,newline).
+  Json::Value root;
+  root["test"] = "\t\n\xF0\x91\xA2\xA1\x3D\xC4\xB3\xF0\x9B\x84\x9B\xEF\xBD\xA7";
+
+  Json::StreamWriterBuilder b;
+
+  // Default settings - should be unicode escaped.
+  JSONTEST_ASSERT(Json::writeString(b, root) ==
+                  "{\n\t\"test\" : "
+                  "\"\\t\\n\\ud806\\udca1=\\u0133\\ud82c\\udd1b\\uff67\"\n}");
+
+  b.settings_["emitUTF8"] = true;
+
+  // Should not be unicode escaped.
+  JSONTEST_ASSERT(
+      Json::writeString(b, root) ==
+      "{\n\t\"test\" : "
+      "\"\\t\\n\xF0\x91\xA2\xA1=\xC4\xB3\xF0\x9B\x84\x9B\xEF\xBD\xA7\"\n}");
+
+  b.settings_["emitUTF8"] = false;
+
+  // Should be unicode escaped.
+  JSONTEST_ASSERT(Json::writeString(b, root) ==
+                  "{\n\t\"test\" : "
+                  "\"\\t\\n\\ud806\\udca1=\\u0133\\ud82c\\udd1b\\uff67\"\n}");
+}
+
+// Control chars should be escaped regardless of UTF-8 input encoding.
+JSONTEST_FIXTURE_LOCAL(StreamWriterTest, escapeControlCharacters) {
+  auto uEscape = [](unsigned ch) {
+    static const char h[] = "0123456789abcdef";
+    std::string r = "\\u";
+    r += h[(ch >> (3 * 4)) & 0xf];
+    r += h[(ch >> (2 * 4)) & 0xf];
+    r += h[(ch >> (1 * 4)) & 0xf];
+    r += h[(ch >> (0 * 4)) & 0xf];
+    return r;
+  };
+  auto shortEscape = [](unsigned ch) -> const char* {
+    switch (ch) {
+    case '\"':
+      return "\\\"";
+    case '\\':
+      return "\\\\";
+    case '\b':
+      return "\\b";
+    case '\f':
+      return "\\f";
+    case '\n':
+      return "\\n";
+    case '\r':
+      return "\\r";
+    case '\t':
+      return "\\t";
+    default:
+      return nullptr;
+    }
+  };
+
+  Json::StreamWriterBuilder b;
+
+  for (bool emitUTF8 : {true, false}) {
+    b.settings_["emitUTF8"] = emitUTF8;
+
+    for (unsigned i = 0; i != 0x100; ++i) {
+      if (!emitUTF8 && i >= 0x80)
+        break; // The algorithm would try to parse UTF-8, so stop here.
+
+      std::string raw({static_cast<char>(i)});
+      std::string esc = raw;
+      if (i < 0x20)
+        esc = uEscape(i);
+      if (const char* shEsc = shortEscape(i))
+        esc = shEsc;
+
+      // std::cout << "emit=" << emitUTF8 << ", i=" << std::hex << i << std::dec
+      //          << std::endl;
+
+      Json::Value root;
+      root["test"] = raw;
+      JSONTEST_ASSERT_STRING_EQUAL(
+          std::string("{\n\t\"test\" : \"").append(esc).append("\"\n}"),
+          Json::writeString(b, root))
+          << ", emit=" << emitUTF8 << ", i=" << i << ", raw=\"" << raw << "\""
+          << ", esc=\"" << esc << "\"";
+    }
+  }
+}
+
+#ifdef _WIN32
+JSONTEST_FIXTURE_LOCAL(StreamWriterTest, escapeTabCharacterWindows) {
+  // Get the current locale before changing it
+  std::string currentLocale = setlocale(LC_ALL, NULL);
+  setlocale(LC_ALL, "English_United States.1252");
+
+  Json::Value root;
+  root["test"] = "\tTabTesting\t";
+
+  Json::StreamWriterBuilder b;
+
+  JSONTEST_ASSERT(Json::writeString(b, root) == "{\n\t\"test\" : "
+                                                "\"\\tTabTesting\\t\"\n}");
+
+  b.settings_["emitUTF8"] = true;
+  JSONTEST_ASSERT(Json::writeString(b, root) == "{\n\t\"test\" : "
+                                                "\"\\tTabTesting\\t\"\n}");
+
+  b.settings_["emitUTF8"] = false;
+  JSONTEST_ASSERT(Json::writeString(b, root) == "{\n\t\"test\" : "
+                                                "\"\\tTabTesting\\t\"\n}");
+
+  // Restore the locale
+  if (!currentLocale.empty())
+    setlocale(LC_ALL, currentLocale.c_str());
+}
+#endif
+
+struct ReaderTest : JsonTest::TestCase {
+  void setStrictMode() {
+    reader = std::unique_ptr<Json::Reader>(
+        new Json::Reader(Json::Features{}.strictMode()));
+  }
+
+  void setFeatures(Json::Features& features) {
+    reader = std::unique_ptr<Json::Reader>(new Json::Reader(features));
+  }
+
+  void checkStructuredErrors(
+      const std::vector<Json::Reader::StructuredError>& actual,
+      const std::vector<Json::Reader::StructuredError>& expected) {
+    JSONTEST_ASSERT_EQUAL(expected.size(), actual.size());
+    for (size_t i = 0; i < actual.size(); ++i) {
+      const auto& a = actual[i];
+      const auto& e = expected[i];
+      JSONTEST_ASSERT_EQUAL(e.offset_start, a.offset_start) << i;
+      JSONTEST_ASSERT_EQUAL(e.offset_limit, a.offset_limit) << i;
+      JSONTEST_ASSERT_EQUAL(e.message, a.message) << i;
+    }
+  }
+
+  template <typename Input> void checkParse(Input&& input) {
+    JSONTEST_ASSERT(reader->parse(input, root));
+  }
+
+  template <typename Input>
+  void
+  checkParse(Input&& input,
+             const std::vector<Json::Reader::StructuredError>& structured) {
+    JSONTEST_ASSERT(!reader->parse(input, root));
+    checkStructuredErrors(reader->getStructuredErrors(), structured);
+  }
+
+  template <typename Input>
+  void checkParse(Input&& input,
+                  const std::vector<Json::Reader::StructuredError>& structured,
+                  const std::string& formatted) {
+    checkParse(input, structured);
+    JSONTEST_ASSERT_EQUAL(formatted, reader->getFormattedErrorMessages());
+  }
+
+  std::unique_ptr<Json::Reader> reader{new Json::Reader()};
+  Json::Value root;
+};
+
+JSONTEST_FIXTURE_LOCAL(ReaderTest, parseWithNoErrors) {
+  checkParse(R"({ "property" : "value" })");
+}
+
+JSONTEST_FIXTURE_LOCAL(ReaderTest, parseObject) {
+  checkParse(R"({"property"})",
+             {{11, 12, "Missing ':' after object member name"}},
+             "* Line 1, Column 12\n  Missing ':' after object member name\n");
+  checkParse(
+      R"({"property" : "value" )",
+      {{22, 22, "Missing ',' or '}' in object declaration"}},
+      "* Line 1, Column 23\n  Missing ',' or '}' in object declaration\n");
+  checkParse(R"({"property" : "value", )",
+             {{23, 23, "Missing '}' or object member name"}},
+             "* Line 1, Column 24\n  Missing '}' or object member name\n");
+}
+
+JSONTEST_FIXTURE_LOCAL(ReaderTest, parseArray) {
+  checkParse(
+      R"([ "value" )", {{10, 10, "Missing ',' or ']' in array declaration"}},
+      "* Line 1, Column 11\n  Missing ',' or ']' in array declaration\n");
+  checkParse(
+      R"([ "value1" "value2" ] )",
+      {{11, 19, "Missing ',' or ']' in array declaration"}},
+      "* Line 1, Column 12\n  Missing ',' or ']' in array declaration\n");
+}
+
+JSONTEST_FIXTURE_LOCAL(ReaderTest, parseString) {
+  checkParse(R"([ "\u8a2a" ])");
+  checkParse(
+      R"([ "\ud801" ])",
+      {{2, 10,
+        "additional six characters expected to parse unicode surrogate "
+        "pair."}},
+      "* Line 1, Column 3\n"
+      "  additional six characters expected to parse unicode surrogate pair.\n"
+      "See Line 1, Column 10 for detail.\n");
+  checkParse(R"([ "\ud801\d1234" ])",
+             {{2, 16,
+               "expecting another \\u token to begin the "
+               "second half of a unicode surrogate pair"}},
+             "* Line 1, Column 3\n"
+             "  expecting another \\u token to begin the "
+             "second half of a unicode surrogate pair\n"
+             "See Line 1, Column 12 for detail.\n");
+  checkParse(R"([ "\ua3t@" ])",
+             {{2, 10,
+               "Bad unicode escape sequence in string: "
+               "hexadecimal digit expected."}},
+             "* Line 1, Column 3\n"
+             "  Bad unicode escape sequence in string: "
+             "hexadecimal digit expected.\n"
+             "See Line 1, Column 9 for detail.\n");
+  checkParse(
+      R"([ "\ua3t" ])",
+      {{2, 9, "Bad unicode escape sequence in string: four digits expected."}},
+      "* Line 1, Column 3\n"
+      "  Bad unicode escape sequence in string: four digits expected.\n"
+      "See Line 1, Column 6 for detail.\n");
+}
+
+JSONTEST_FIXTURE_LOCAL(ReaderTest, parseComment) {
+  checkParse(
+      R"({ /*commentBeforeValue*/ "property" : "value" }//commentAfterValue)"
+      "\n");
+  checkParse(" true //comment1\n//comment2\r//comment3\r\n");
+}
+
+JSONTEST_FIXTURE_LOCAL(ReaderTest, streamParseWithNoErrors) {
+  std::string styled = R"({ "property" : "value" })";
+  std::istringstream iss(styled);
+  checkParse(iss);
+}
+
+JSONTEST_FIXTURE_LOCAL(ReaderTest, parseWithNoErrorsTestingOffsets) {
+  checkParse(R"({)"
+             R"( "property" : ["value", "value2"],)"
+             R"( "obj" : { "nested" : -6.2e+15, "bool" : true},)"
+             R"( "null" : null,)"
+             R"( "false" : false)"
+             R"( })");
+  auto checkOffsets = [&](const Json::Value& v, int start, int limit) {
+    JSONTEST_ASSERT_EQUAL(start, v.getOffsetStart());
+    JSONTEST_ASSERT_EQUAL(limit, v.getOffsetLimit());
+  };
+  checkOffsets(root, 0, 115);
+  checkOffsets(root["property"], 15, 34);
+  checkOffsets(root["property"][0], 16, 23);
+  checkOffsets(root["property"][1], 25, 33);
+  checkOffsets(root["obj"], 44, 81);
+  checkOffsets(root["obj"]["nested"], 57, 65);
+  checkOffsets(root["obj"]["bool"], 76, 80);
+  checkOffsets(root["null"], 92, 96);
+  checkOffsets(root["false"], 108, 113);
+}
+
+JSONTEST_FIXTURE_LOCAL(ReaderTest, parseWithOneError) {
+  checkParse(R"({ "property" :: "value" })",
+             {{14, 15, "Syntax error: value, object or array expected."}},
+             "* Line 1, Column 15\n  Syntax error: value, object or array "
+             "expected.\n");
+  checkParse("s", {{0, 1, "Syntax error: value, object or array expected."}},
+             "* Line 1, Column 1\n  Syntax error: value, object or array "
+             "expected.\n");
+}
+
+JSONTEST_FIXTURE_LOCAL(ReaderTest, parseSpecialFloat) {
+  checkParse(R"({ "a" : Infi })",
+             {{8, 9, "Syntax error: value, object or array expected."}},
+             "* Line 1, Column 9\n  Syntax error: value, object or array "
+             "expected.\n");
+  checkParse(R"({ "a" : Infiniaa })",
+             {{8, 9, "Syntax error: value, object or array expected."}},
+             "* Line 1, Column 9\n  Syntax error: value, object or array "
+             "expected.\n");
+}
+
+JSONTEST_FIXTURE_LOCAL(ReaderTest, strictModeParseNumber) {
+  setStrictMode();
+  checkParse(
+      "123",
+      {{0, 3,
+        "A valid JSON document must be either an array or an object value."}},
+      "* Line 1, Column 1\n"
+      "  A valid JSON document must be either an array or an object value.\n");
+}
+
+JSONTEST_FIXTURE_LOCAL(ReaderTest, parseChineseWithOneError) {
+  checkParse(R"({ "pr)"
+             u8"\u4f50\u85e4" // 佐藤
+             R"(erty" :: "value" })",
+             {{18, 19, "Syntax error: value, object or array expected."}},
+             "* Line 1, Column 19\n  Syntax error: value, object or array "
+             "expected.\n");
+}
+
+JSONTEST_FIXTURE_LOCAL(ReaderTest, parseWithDetailError) {
+  checkParse(R"({ "property" : "v\alue" })",
+             {{15, 23, "Bad escape sequence in string"}},
+             "* Line 1, Column 16\n"
+             "  Bad escape sequence in string\n"
+             "See Line 1, Column 20 for detail.\n");
+}
+
+JSONTEST_FIXTURE_LOCAL(ReaderTest, pushErrorTest) {
+  checkParse(R"({ "AUTHOR" : 123 })");
+  if (!root["AUTHOR"].isString()) {
+    JSONTEST_ASSERT(
+        reader->pushError(root["AUTHOR"], "AUTHOR must be a string"));
+  }
+  JSONTEST_ASSERT_STRING_EQUAL(reader->getFormattedErrorMessages(),
+                               "* Line 1, Column 14\n"
+                               "  AUTHOR must be a string\n");
+
+  checkParse(R"({ "AUTHOR" : 123 })");
+  if (!root["AUTHOR"].isString()) {
+    JSONTEST_ASSERT(reader->pushError(root["AUTHOR"], "AUTHOR must be a string",
+                                      root["AUTHOR"]));
+  }
+  JSONTEST_ASSERT_STRING_EQUAL(reader->getFormattedErrorMessages(),
+                               "* Line 1, Column 14\n"
+                               "  AUTHOR must be a string\n"
+                               "See Line 1, Column 14 for detail.\n");
+}
+
+JSONTEST_FIXTURE_LOCAL(ReaderTest, allowNumericKeysTest) {
+  Json::Features features;
+  features.allowNumericKeys_ = true;
+  setFeatures(features);
+  checkParse(R"({ 123 : "abc" })");
+}
+
+struct CharReaderTest : JsonTest::TestCase {};
+
+JSONTEST_FIXTURE_LOCAL(CharReaderTest, parseWithNoErrors) {
+  Json::CharReaderBuilder b;
+  CharReaderPtr reader(b.newCharReader());
+  Json::String errs;
+  Json::Value root;
+  char const doc[] = R"({ "property" : "value" })";
+  bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
+  JSONTEST_ASSERT(ok);
+  JSONTEST_ASSERT(errs.empty());
+}
+
+JSONTEST_FIXTURE_LOCAL(CharReaderTest, parseWithNoErrorsTestingOffsets) {
+  Json::CharReaderBuilder b;
+  CharReaderPtr reader(b.newCharReader());
+  Json::String errs;
+  Json::Value root;
+  char const doc[] = "{ \"property\" : [\"value\", \"value2\"], \"obj\" : "
+                     "{ \"nested\" : -6.2e+15, \"num\" : +123, \"bool\" : "
+                     "true}, \"null\" : null, \"false\" : false }";
+  bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
+  JSONTEST_ASSERT(ok);
+  JSONTEST_ASSERT(errs.empty());
+}
+
+JSONTEST_FIXTURE_LOCAL(CharReaderTest, parseNumber) {
+  Json::CharReaderBuilder b;
+  CharReaderPtr reader(b.newCharReader());
+  Json::String errs;
+  Json::Value root;
+  {
+    // if intvalue > threshold, treat the number as a double.
+    // 21 digits
+    char const doc[] = "[111111111111111111111]";
+    bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
+    JSONTEST_ASSERT(ok);
+    JSONTEST_ASSERT(errs.empty());
+    JSONTEST_ASSERT_EQUAL(1.1111111111111111e+020, root[0]);
+  }
+}
+
+JSONTEST_FIXTURE_LOCAL(CharReaderTest, parseString) {
+  Json::CharReaderBuilder b;
+  CharReaderPtr reader(b.newCharReader());
+  Json::Value root;
+  Json::String errs;
+  {
+    char const doc[] = "[\"\"]";
+    bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
+    JSONTEST_ASSERT(ok);
+    JSONTEST_ASSERT(errs.empty());
+    JSONTEST_ASSERT_EQUAL("", root[0]);
+  }
+  {
+    char const doc[] = R"(["\u8A2a"])";
+    bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
+    JSONTEST_ASSERT(ok);
+    JSONTEST_ASSERT(errs.empty());
+    JSONTEST_ASSERT_EQUAL(u8"\u8A2a", root[0].asString()); // "訪"
+  }
+  {
+    char const doc[] = R"([ "\uD801" ])";
+    bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
+    JSONTEST_ASSERT(!ok);
+    JSONTEST_ASSERT(errs == "* Line 1, Column 3\n"
+                            "  additional six characters expected to "
+                            "parse unicode surrogate pair.\n"
+                            "See Line 1, Column 10 for detail.\n");
+  }
+  {
+    char const doc[] = R"([ "\uD801\d1234" ])";
+    bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
+    JSONTEST_ASSERT(!ok);
+    JSONTEST_ASSERT(errs == "* Line 1, Column 3\n"
+                            "  expecting another \\u token to begin the "
+                            "second half of a unicode surrogate pair\n"
+                            "See Line 1, Column 12 for detail.\n");
+  }
+  {
+    char const doc[] = R"([ "\ua3t@" ])";
+    bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
+    JSONTEST_ASSERT(!ok);
+    JSONTEST_ASSERT(errs == "* Line 1, Column 3\n"
+                            "  Bad unicode escape sequence in string: "
+                            "hexadecimal digit expected.\n"
+                            "See Line 1, Column 9 for detail.\n");
+  }
+  {
+    char const doc[] = R"([ "\ua3t" ])";
+    bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
+    JSONTEST_ASSERT(!ok);
+    JSONTEST_ASSERT(
+        errs ==
+        "* Line 1, Column 3\n"
+        "  Bad unicode escape sequence in string: four digits expected.\n"
+        "See Line 1, Column 6 for detail.\n");
+  }
+  {
+    b.settings_["allowSingleQuotes"] = true;
+    CharReaderPtr charreader(b.newCharReader());
+    char const doc[] = R"({'a': 'x\ty', "b":'x\\y'})";
+    bool ok = charreader->parse(doc, doc + std::strlen(doc), &root, &errs);
+    JSONTEST_ASSERT(ok);
+    JSONTEST_ASSERT_STRING_EQUAL("", errs);
+    JSONTEST_ASSERT_EQUAL(2u, root.size());
+    JSONTEST_ASSERT_STRING_EQUAL("x\ty", root["a"].asString());
+    JSONTEST_ASSERT_STRING_EQUAL("x\\y", root["b"].asString());
+  }
+}
+
+JSONTEST_FIXTURE_LOCAL(CharReaderTest, parseComment) {
+  Json::CharReaderBuilder b;
+  CharReaderPtr reader(b.newCharReader());
+  Json::Value root;
+  Json::String errs;
+  {
+    char const doc[] = "//comment1\n { //comment2\n \"property\" :"
+                       " \"value\" //comment3\n } //comment4\n";
+    bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
+    JSONTEST_ASSERT(ok);
+    JSONTEST_ASSERT(errs.empty());
+    JSONTEST_ASSERT_EQUAL("value", root["property"]);
+  }
+  {
+    char const doc[] = "{ \"property\" //comment\n : \"value\" }";
+    bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
+    JSONTEST_ASSERT(!ok);
+    JSONTEST_ASSERT(errs == "* Line 1, Column 14\n"
+                            "  Missing ':' after object member name\n");
+  }
+  {
+    char const doc[] = "//comment1\n [ //comment2\n \"value\" //comment3\n,"
+                       " //comment4\n true //comment5\n ] //comment6\n";
+    bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
+    JSONTEST_ASSERT(ok);
+    JSONTEST_ASSERT(errs.empty());
+    JSONTEST_ASSERT_EQUAL("value", root[0]);
+    JSONTEST_ASSERT_EQUAL(true, root[1]);
+  }
+}
+
+JSONTEST_FIXTURE_LOCAL(CharReaderTest, parseObjectWithErrors) {
+  Json::CharReaderBuilder b;
+  CharReaderPtr reader(b.newCharReader());
+  Json::Value root;
+  Json::String errs;
+  {
+    char const doc[] = R"({ "property" : "value" )";
+    bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
+    JSONTEST_ASSERT(!ok);
+    JSONTEST_ASSERT(errs == "* Line 1, Column 24\n"
+                            "  Missing ',' or '}' in object declaration\n");
+    JSONTEST_ASSERT_EQUAL("value", root["property"]);
+  }
+  {
+    char const doc[] = R"({ "property" : "value" ,)";
+    bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
+    JSONTEST_ASSERT(!ok);
+    JSONTEST_ASSERT(errs == "* Line 1, Column 25\n"
+                            "  Missing '}' or object member name\n");
+    JSONTEST_ASSERT_EQUAL("value", root["property"]);
+  }
+}
+
+JSONTEST_FIXTURE_LOCAL(CharReaderTest, parseArrayWithErrors) {
+  Json::CharReaderBuilder b;
+  CharReaderPtr reader(b.newCharReader());
+  Json::Value root;
+  Json::String errs;
+  {
+    char const doc[] = "[ \"value\" ";
+    bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
+    JSONTEST_ASSERT(!ok);
+    JSONTEST_ASSERT(errs == "* Line 1, Column 11\n"
+                            "  Missing ',' or ']' in array declaration\n");
+    JSONTEST_ASSERT_EQUAL("value", root[0]);
+  }
+  {
+    char const doc[] = R"([ "value1" "value2" ])";
+    bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
+    JSONTEST_ASSERT(!ok);
+    JSONTEST_ASSERT(errs == "* Line 1, Column 12\n"
+                            "  Missing ',' or ']' in array declaration\n");
+    JSONTEST_ASSERT_EQUAL("value1", root[0]);
+  }
+}
+
+JSONTEST_FIXTURE_LOCAL(CharReaderTest, parseWithOneError) {
+  Json::CharReaderBuilder b;
+  CharReaderPtr reader(b.newCharReader());
+  Json::String errs;
+  Json::Value root;
+  char const doc[] = R"({ "property" :: "value" })";
+  bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
+  JSONTEST_ASSERT(!ok);
+  JSONTEST_ASSERT(errs ==
+                  "* Line 1, Column 15\n  Syntax error: value, object or array "
+                  "expected.\n");
+}
+
+JSONTEST_FIXTURE_LOCAL(CharReaderTest, parseChineseWithOneError) {
+  Json::CharReaderBuilder b;
+  CharReaderPtr reader(b.newCharReader());
+  Json::String errs;
+  Json::Value root;
+  char const doc[] = "{ \"pr佐藤erty\" :: \"value\" }";
+  bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
+  JSONTEST_ASSERT(!ok);
+  JSONTEST_ASSERT(errs ==
+                  "* Line 1, Column 19\n  Syntax error: value, object or array "
+                  "expected.\n");
+}
+
+JSONTEST_FIXTURE_LOCAL(CharReaderTest, parseWithDetailError) {
+  Json::CharReaderBuilder b;
+  CharReaderPtr reader(b.newCharReader());
+  Json::String errs;
+  Json::Value root;
+  char const doc[] = R"({ "property" : "v\alue" })";
+  bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
+  JSONTEST_ASSERT(!ok);
+  JSONTEST_ASSERT(errs ==
+                  "* Line 1, Column 16\n  Bad escape sequence in string\nSee "
+                  "Line 1, Column 20 for detail.\n");
+}
+
+JSONTEST_FIXTURE_LOCAL(CharReaderTest, parseWithStackLimit) {
+  Json::CharReaderBuilder b;
+  Json::Value root;
+  char const doc[] = R"({ "property" : "value" })";
+  {
+    b.settings_["stackLimit"] = 2;
+    CharReaderPtr reader(b.newCharReader());
+    Json::String errs;
+    bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
+    JSONTEST_ASSERT(ok);
+    JSONTEST_ASSERT(errs.empty());
+    JSONTEST_ASSERT_EQUAL("value", root["property"]);
+  }
+  {
+    b.settings_["stackLimit"] = 1;
+    CharReaderPtr reader(b.newCharReader());
+    Json::String errs;
+    JSONTEST_ASSERT_THROWS(
+        reader->parse(doc, doc + std::strlen(doc), &root, &errs));
+  }
+}
+
+JSONTEST_FIXTURE_LOCAL(CharReaderTest, testOperator) {
+  const std::string styled = R"({ "property" : "value" })";
+  std::istringstream iss(styled);
+  Json::Value root;
+  iss >> root;
+  JSONTEST_ASSERT_EQUAL("value", root["property"]);
+}
+
+struct CharReaderStrictModeTest : JsonTest::TestCase {};
+
+JSONTEST_FIXTURE_LOCAL(CharReaderStrictModeTest, dupKeys) {
+  Json::CharReaderBuilder b;
+  Json::Value root;
+  char const doc[] =
+      R"({ "property" : "value", "key" : "val1", "key" : "val2" })";
+  {
+    b.strictMode(&b.settings_);
+    CharReaderPtr reader(b.newCharReader());
+    Json::String errs;
+    bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
+    JSONTEST_ASSERT(!ok);
+    JSONTEST_ASSERT_STRING_EQUAL("* Line 1, Column 41\n"
+                                 "  Duplicate key: 'key'\n",
+                                 errs);
+    JSONTEST_ASSERT_EQUAL("val1", root["key"]); // so far
+  }
+}
+struct CharReaderFailIfExtraTest : JsonTest::TestCase {};
+
+JSONTEST_FIXTURE_LOCAL(CharReaderFailIfExtraTest, issue164) {
+  // This is interpreted as a string value followed by a colon.
+  Json::CharReaderBuilder b;
+  Json::Value root;
+  char const doc[] = R"( "property" : "value" })";
+  {
+    b.settings_["failIfExtra"] = false;
+    CharReaderPtr reader(b.newCharReader());
+    Json::String errs;
+    bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
+    JSONTEST_ASSERT(ok);
+    JSONTEST_ASSERT(errs.empty());
+    JSONTEST_ASSERT_EQUAL("property", root);
+  }
+  {
+    b.settings_["failIfExtra"] = true;
+    CharReaderPtr reader(b.newCharReader());
+    Json::String errs;
+    bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
+    JSONTEST_ASSERT(!ok);
+    JSONTEST_ASSERT_STRING_EQUAL("* Line 1, Column 13\n"
+                                 "  Extra non-whitespace after JSON value.\n",
+                                 errs);
+    JSONTEST_ASSERT_EQUAL("property", root);
+  }
+  {
+    b.strictMode(&b.settings_);
+    CharReaderPtr reader(b.newCharReader());
+    Json::String errs;
+    bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
+    JSONTEST_ASSERT(!ok);
+    JSONTEST_ASSERT_STRING_EQUAL("* Line 1, Column 13\n"
+                                 "  Extra non-whitespace after JSON value.\n",
+                                 errs);
+    JSONTEST_ASSERT_EQUAL("property", root);
+  }
+  {
+    b.strictMode(&b.settings_);
+    b.settings_["failIfExtra"] = false;
+    CharReaderPtr reader(b.newCharReader());
+    Json::String errs;
+    bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
+    JSONTEST_ASSERT(!ok);
+    JSONTEST_ASSERT_STRING_EQUAL(
+        "* Line 1, Column 1\n"
+        "  A valid JSON document must be either an array or an object value.\n",
+        errs);
+    JSONTEST_ASSERT_EQUAL("property", root);
+  }
+}
+
+JSONTEST_FIXTURE_LOCAL(CharReaderFailIfExtraTest, issue107) {
+  // This is interpreted as an int value followed by a colon.
+  Json::CharReaderBuilder b;
+  Json::Value root;
+  char const doc[] = "1:2:3";
+  b.settings_["failIfExtra"] = true;
+  CharReaderPtr reader(b.newCharReader());
+  Json::String errs;
+  bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
+  JSONTEST_ASSERT(!ok);
+  JSONTEST_ASSERT_STRING_EQUAL("* Line 1, Column 2\n"
+                               "  Extra non-whitespace after JSON value.\n",
+                               errs);
+  JSONTEST_ASSERT_EQUAL(1, root.asInt());
+}
+JSONTEST_FIXTURE_LOCAL(CharReaderFailIfExtraTest, commentAfterObject) {
+  Json::CharReaderBuilder b;
+  Json::Value root;
+  {
+    char const doc[] = "{ \"property\" : \"value\" } //trailing\n//comment\n";
+    b.settings_["failIfExtra"] = true;
+    CharReaderPtr reader(b.newCharReader());
+    Json::String errs;
+    bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
+    JSONTEST_ASSERT(ok);
+    JSONTEST_ASSERT_STRING_EQUAL("", errs);
+    JSONTEST_ASSERT_EQUAL("value", root["property"]);
+  }
+}
+JSONTEST_FIXTURE_LOCAL(CharReaderFailIfExtraTest, commentAfterArray) {
+  Json::CharReaderBuilder b;
+  Json::Value root;
+  char const doc[] = "[ \"property\" , \"value\" ] //trailing\n//comment\n";
+  b.settings_["failIfExtra"] = true;
+  CharReaderPtr reader(b.newCharReader());
+  Json::String errs;
+  bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
+  JSONTEST_ASSERT(ok);
+  JSONTEST_ASSERT_STRING_EQUAL("", errs);
+  JSONTEST_ASSERT_EQUAL("value", root[1u]);
+}
+JSONTEST_FIXTURE_LOCAL(CharReaderFailIfExtraTest, commentAfterBool) {
+  Json::CharReaderBuilder b;
+  Json::Value root;
+  char const doc[] = " true /*trailing\ncomment*/";
+  b.settings_["failIfExtra"] = true;
+  CharReaderPtr reader(b.newCharReader());
+  Json::String errs;
+  bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
+  JSONTEST_ASSERT(ok);
+  JSONTEST_ASSERT_STRING_EQUAL("", errs);
+  JSONTEST_ASSERT_EQUAL(true, root.asBool());
+}
+
+JSONTEST_FIXTURE_LOCAL(CharReaderFailIfExtraTest, parseComment) {
+  Json::CharReaderBuilder b;
+  b.settings_["failIfExtra"] = true;
+  CharReaderPtr reader(b.newCharReader());
+  Json::Value root;
+  Json::String errs;
+  {
+    char const doc[] = " true //comment1\n//comment2\r//comment3\r\n";
+    bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
+    JSONTEST_ASSERT(ok);
+    JSONTEST_ASSERT_STRING_EQUAL("", errs);
+    JSONTEST_ASSERT_EQUAL(true, root.asBool());
+  }
+  {
+    char const doc[] = " true //com\rment";
+    bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
+    JSONTEST_ASSERT(!ok);
+    JSONTEST_ASSERT_STRING_EQUAL("* Line 2, Column 1\n"
+                                 "  Extra non-whitespace after JSON value.\n",
+                                 errs);
+    JSONTEST_ASSERT_EQUAL(true, root.asBool());
+  }
+  {
+    char const doc[] = " true //com\nment";
+    bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
+    JSONTEST_ASSERT(!ok);
+    JSONTEST_ASSERT_STRING_EQUAL("* Line 2, Column 1\n"
+                                 "  Extra non-whitespace after JSON value.\n",
+                                 errs);
+    JSONTEST_ASSERT_EQUAL(true, root.asBool());
+  }
+}
+
+struct CharReaderAllowDropNullTest : JsonTest::TestCase {
+  using Value = Json::Value;
+  using ValueCheck = std::function<void(const Value&)>;
+
+  Value nullValue = Value{Json::nullValue};
+  Value emptyArray = Value{Json::arrayValue};
+
+  ValueCheck checkEq(const Value& v) {
+    return [=](const Value& root) { JSONTEST_ASSERT_EQUAL(root, v); };
+  }
+
+  static ValueCheck objGetAnd(std::string idx, ValueCheck f) {
+    return [=](const Value& root) { f(root.get(idx, true)); };
+  }
+
+  static ValueCheck arrGetAnd(int idx, ValueCheck f) {
+    return [=](const Value& root) { f(root[idx]); };
+  }
+};
+
+JSONTEST_FIXTURE_LOCAL(CharReaderAllowDropNullTest, issue178) {
+  struct TestSpec {
+    int line;
+    std::string doc;
+    size_t rootSize;
+    ValueCheck onRoot;
+  };
+  const TestSpec specs[] = {
+      {__LINE__, R"({"a":,"b":true})", 2, objGetAnd("a", checkEq(nullValue))},
+      {__LINE__, R"({"a":,"b":true})", 2, objGetAnd("a", checkEq(nullValue))},
+      {__LINE__, R"({"a":})", 1, objGetAnd("a", checkEq(nullValue))},
+      {__LINE__, "[]", 0, checkEq(emptyArray)},
+      {__LINE__, "[null]", 1, nullptr},
+      {__LINE__, "[,]", 2, nullptr},
+      {__LINE__, "[,,,]", 4, nullptr},
+      {__LINE__, "[null,]", 2, nullptr},
+      {__LINE__, "[,null]", 2, nullptr},
+      {__LINE__, "[,,]", 3, nullptr},
+      {__LINE__, "[null,,]", 3, nullptr},
+      {__LINE__, "[,null,]", 3, nullptr},
+      {__LINE__, "[,,null]", 3, nullptr},
+      {__LINE__, "[[],,,]", 4, arrGetAnd(0, checkEq(emptyArray))},
+      {__LINE__, "[,[],,]", 4, arrGetAnd(1, checkEq(emptyArray))},
+      {__LINE__, "[,,,[]]", 4, arrGetAnd(3, checkEq(emptyArray))},
+  };
+  for (const auto& spec : specs) {
+    Json::CharReaderBuilder b;
+    b.settings_["allowDroppedNullPlaceholders"] = true;
+    std::unique_ptr<Json::CharReader> reader(b.newCharReader());
+
+    Json::Value root;
+    Json::String errs;
+    bool ok = reader->parse(spec.doc.data(), spec.doc.data() + spec.doc.size(),
+                            &root, &errs);
+    JSONTEST_ASSERT(ok);
+    JSONTEST_ASSERT_STRING_EQUAL(errs, "");
+    if (spec.onRoot) {
+      spec.onRoot(root);
+    }
+  }
+}
+
+struct CharReaderAllowNumericKeysTest : JsonTest::TestCase {};
+
+JSONTEST_FIXTURE_LOCAL(CharReaderAllowNumericKeysTest, allowNumericKeys) {
+  Json::CharReaderBuilder b;
+  b.settings_["allowNumericKeys"] = true;
+  Json::Value root;
+  Json::String errs;
+  CharReaderPtr reader(b.newCharReader());
+  char const doc[] = "{15:true,-16:true,12.01:true}";
+  bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
+  JSONTEST_ASSERT(ok);
+  JSONTEST_ASSERT_STRING_EQUAL("", errs);
+  JSONTEST_ASSERT_EQUAL(3u, root.size());
+  JSONTEST_ASSERT_EQUAL(true, root.get("15", false));
+  JSONTEST_ASSERT_EQUAL(true, root.get("-16", false));
+  JSONTEST_ASSERT_EQUAL(true, root.get("12.01", false));
+}
+
+struct CharReaderAllowSingleQuotesTest : JsonTest::TestCase {};
+
+JSONTEST_FIXTURE_LOCAL(CharReaderAllowSingleQuotesTest, issue182) {
+  Json::CharReaderBuilder b;
+  b.settings_["allowSingleQuotes"] = true;
+  Json::Value root;
+  Json::String errs;
+  CharReaderPtr reader(b.newCharReader());
+  {
+    char const doc[] = "{'a':true,\"b\":true}";
+    bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
+    JSONTEST_ASSERT(ok);
+    JSONTEST_ASSERT_STRING_EQUAL("", errs);
+    JSONTEST_ASSERT_EQUAL(2u, root.size());
+    JSONTEST_ASSERT_EQUAL(true, root.get("a", false));
+    JSONTEST_ASSERT_EQUAL(true, root.get("b", false));
+  }
+  {
+    char const doc[] = "{'a': 'x', \"b\":'y'}";
+    bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
+    JSONTEST_ASSERT(ok);
+    JSONTEST_ASSERT_STRING_EQUAL("", errs);
+    JSONTEST_ASSERT_EQUAL(2u, root.size());
+    JSONTEST_ASSERT_STRING_EQUAL("x", root["a"].asString());
+    JSONTEST_ASSERT_STRING_EQUAL("y", root["b"].asString());
+  }
+}
+
+struct CharReaderAllowZeroesTest : JsonTest::TestCase {};
+
+JSONTEST_FIXTURE_LOCAL(CharReaderAllowZeroesTest, issue176) {
+  Json::CharReaderBuilder b;
+  b.settings_["allowSingleQuotes"] = true;
+  Json::Value root;
+  Json::String errs;
+  CharReaderPtr reader(b.newCharReader());
+  {
+    char const doc[] = "{'a':true,\"b\":true}";
+    bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
+    JSONTEST_ASSERT(ok);
+    JSONTEST_ASSERT_STRING_EQUAL("", errs);
+    JSONTEST_ASSERT_EQUAL(2u, root.size());
+    JSONTEST_ASSERT_EQUAL(true, root.get("a", false));
+    JSONTEST_ASSERT_EQUAL(true, root.get("b", false));
+  }
+  {
+    char const doc[] = "{'a': 'x', \"b\":'y'}";
+    bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
+    JSONTEST_ASSERT(ok);
+    JSONTEST_ASSERT_STRING_EQUAL("", errs);
+    JSONTEST_ASSERT_EQUAL(2u, root.size());
+    JSONTEST_ASSERT_STRING_EQUAL("x", root["a"].asString());
+    JSONTEST_ASSERT_STRING_EQUAL("y", root["b"].asString());
+  }
+}
+
+struct CharReaderAllowSpecialFloatsTest : JsonTest::TestCase {};
+
+JSONTEST_FIXTURE_LOCAL(CharReaderAllowSpecialFloatsTest, specialFloat) {
+  Json::CharReaderBuilder b;
+  CharReaderPtr reader(b.newCharReader());
+  Json::Value root;
+  Json::String errs;
+  {
+    char const doc[] = "{\"a\": NaN}";
+    bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
+    JSONTEST_ASSERT(!ok);
+    JSONTEST_ASSERT_STRING_EQUAL(
+        "* Line 1, Column 7\n"
+        "  Syntax error: value, object or array expected.\n",
+        errs);
+  }
+  {
+    char const doc[] = "{\"a\": Infinity}";
+    bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
+    JSONTEST_ASSERT(!ok);
+    JSONTEST_ASSERT_STRING_EQUAL(
+        "* Line 1, Column 7\n"
+        "  Syntax error: value, object or array expected.\n",
+        errs);
+  }
+}
+
+JSONTEST_FIXTURE_LOCAL(CharReaderAllowSpecialFloatsTest, issue209) {
+  Json::CharReaderBuilder b;
+  b.settings_["allowSpecialFloats"] = true;
+  Json::Value root;
+  Json::String errs;
+  CharReaderPtr reader(b.newCharReader());
+  {
+    char const doc[] = R"({"a":NaN,"b":Infinity,"c":-Infinity,"d":+Infinity})";
+    bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
+    JSONTEST_ASSERT(ok);
+    JSONTEST_ASSERT_STRING_EQUAL("", errs);
+    JSONTEST_ASSERT_EQUAL(4u, root.size());
+    double n = root["a"].asDouble();
+    JSONTEST_ASSERT(std::isnan(n));
+    JSONTEST_ASSERT_EQUAL(std::numeric_limits<double>::infinity(),
+                          root.get("b", 0.0));
+    JSONTEST_ASSERT_EQUAL(-std::numeric_limits<double>::infinity(),
+                          root.get("c", 0.0));
+    JSONTEST_ASSERT_EQUAL(std::numeric_limits<double>::infinity(),
+                          root.get("d", 0.0));
+  }
+
+  struct TestData {
+    int line;
+    bool ok;
+    Json::String in;
+  };
+  const TestData test_data[] = {
+      {__LINE__, true, "{\"a\":9}"},          //
+      {__LINE__, false, "{\"a\":0Infinity}"}, //
+      {__LINE__, false, "{\"a\":1Infinity}"}, //
+      {__LINE__, false, "{\"a\":9Infinity}"}, //
+      {__LINE__, false, "{\"a\":0nfinity}"},  //
+      {__LINE__, false, "{\"a\":1nfinity}"},  //
+      {__LINE__, false, "{\"a\":9nfinity}"},  //
+      {__LINE__, false, "{\"a\":nfinity}"},   //
+      {__LINE__, false, "{\"a\":.nfinity}"},  //
+      {__LINE__, false, "{\"a\":9nfinity}"},  //
+      {__LINE__, false, "{\"a\":-nfinity}"},  //
+      {__LINE__, true, "{\"a\":Infinity}"},   //
+      {__LINE__, false, "{\"a\":.Infinity}"}, //
+      {__LINE__, false, "{\"a\":_Infinity}"}, //
+      {__LINE__, false, "{\"a\":_nfinity}"},  //
+      {__LINE__, true, "{\"a\":-Infinity}"},  //
+      {__LINE__, true, "{\"a\":+Infinity}"}   //
+  };
+  for (const auto& td : test_data) {
+    bool ok = reader->parse(&*td.in.begin(), &*td.in.begin() + td.in.size(),
+                            &root, &errs);
+    JSONTEST_ASSERT(td.ok == ok) << "line:" << td.line << "\n"
+                                 << "  expected: {"
+                                 << "ok:" << td.ok << ", in:\'" << td.in << "\'"
+                                 << "}\n"
+                                 << "  actual: {"
+                                 << "ok:" << ok << "}\n";
+  }
+
+  {
+    char const doc[] = R"({"posInf": +Infinity, "NegInf": -Infinity})";
+    bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
+    JSONTEST_ASSERT(ok);
+    JSONTEST_ASSERT_STRING_EQUAL("", errs);
+    JSONTEST_ASSERT_EQUAL(2u, root.size());
+    JSONTEST_ASSERT_EQUAL(std::numeric_limits<double>::infinity(),
+                          root["posInf"].asDouble());
+    JSONTEST_ASSERT_EQUAL(-std::numeric_limits<double>::infinity(),
+                          root["NegInf"].asDouble());
+  }
+}
+
+struct EscapeSequenceTest : JsonTest::TestCase {};
+
+JSONTEST_FIXTURE_LOCAL(EscapeSequenceTest, readerParseEscapeSequence) {
+  Json::Reader reader;
+  Json::Value root;
+  bool ok = reader.parse("[\"\\\"\",\"\\/\",\"\\\\\",\"\\b\","
+                         "\"\\f\",\"\\n\",\"\\r\",\"\\t\","
+                         "\"\\u0278\",\"\\ud852\\udf62\"]\n",
+                         root);
+  JSONTEST_ASSERT(ok);
+  JSONTEST_ASSERT(reader.getFormattedErrorMessages().empty());
+  JSONTEST_ASSERT(reader.getStructuredErrors().empty());
+}
+
+JSONTEST_FIXTURE_LOCAL(EscapeSequenceTest, charReaderParseEscapeSequence) {
+  Json::CharReaderBuilder b;
+  CharReaderPtr reader(b.newCharReader());
+  Json::Value root;
+  Json::String errs;
+  char const doc[] = "[\"\\\"\",\"\\/\",\"\\\\\",\"\\b\","
+                     "\"\\f\",\"\\n\",\"\\r\",\"\\t\","
+                     "\"\\u0278\",\"\\ud852\\udf62\"]";
+  bool ok = reader->parse(doc, doc + std::strlen(doc), &root, &errs);
+  JSONTEST_ASSERT(ok);
+  JSONTEST_ASSERT(errs.empty());
+}
+
+JSONTEST_FIXTURE_LOCAL(EscapeSequenceTest, writeEscapeSequence) {
+  Json::FastWriter writer;
+  const Json::String expected("[\"\\\"\",\"\\\\\",\"\\b\","
+                              "\"\\f\",\"\\n\",\"\\r\",\"\\t\","
+                              "\"\\u0278\",\"\\ud852\\udf62\"]\n");
+  Json::Value root;
+  root[0] = "\"";
+  root[1] = "\\";
+  root[2] = "\b";
+  root[3] = "\f";
+  root[4] = "\n";
+  root[5] = "\r";
+  root[6] = "\t";
+  root[7] = "ɸ";
+  root[8] = "𤭢";
+  const Json::String result = writer.write(root);
+  JSONTEST_ASSERT_STRING_EQUAL(expected, result);
+}
+
+struct BuilderTest : JsonTest::TestCase {};
+
+JSONTEST_FIXTURE_LOCAL(BuilderTest, settings) {
+  {
+    Json::Value errs;
+    Json::CharReaderBuilder rb;
+    JSONTEST_ASSERT_EQUAL(false, rb.settings_.isMember("foo"));
+    JSONTEST_ASSERT_EQUAL(true, rb.validate(&errs));
+    rb["foo"] = "bar";
+    JSONTEST_ASSERT_EQUAL(true, rb.settings_.isMember("foo"));
+    JSONTEST_ASSERT_EQUAL(false, rb.validate(&errs));
+  }
+  {
+    Json::Value errs;
+    Json::StreamWriterBuilder wb;
+    JSONTEST_ASSERT_EQUAL(false, wb.settings_.isMember("foo"));
+    JSONTEST_ASSERT_EQUAL(true, wb.validate(&errs));
+    wb["foo"] = "bar";
+    JSONTEST_ASSERT_EQUAL(true, wb.settings_.isMember("foo"));
+    JSONTEST_ASSERT_EQUAL(false, wb.validate(&errs));
+  }
+}
+
+struct BomTest : JsonTest::TestCase {};
+
+JSONTEST_FIXTURE_LOCAL(BomTest, skipBom) {
+  const std::string with_bom = "\xEF\xBB\xBF{\"key\" : \"value\"}";
+  Json::Value root;
+  JSONCPP_STRING errs;
+  std::istringstream iss(with_bom);
+  bool ok = parseFromStream(Json::CharReaderBuilder(), iss, &root, &errs);
+  // The default behavior is to skip the BOM, so we can parse it normally.
+  JSONTEST_ASSERT(ok);
+  JSONTEST_ASSERT(errs.empty());
+  JSONTEST_ASSERT_STRING_EQUAL(root["key"].asString(), "value");
+}
+JSONTEST_FIXTURE_LOCAL(BomTest, notSkipBom) {
+  const std::string with_bom = "\xEF\xBB\xBF{\"key\" : \"value\"}";
+  Json::Value root;
+  JSONCPP_STRING errs;
+  std::istringstream iss(with_bom);
+  Json::CharReaderBuilder b;
+  b.settings_["skipBom"] = false;
+  bool ok = parseFromStream(b, iss, &root, &errs);
+  // Detect the BOM, and failed on it.
+  JSONTEST_ASSERT(!ok);
+  JSONTEST_ASSERT(!errs.empty());
+}
+
+struct IteratorTest : JsonTest::TestCase {};
+
+JSONTEST_FIXTURE_LOCAL(IteratorTest, convert) {
+  Json::Value j;
+  const Json::Value& cj = j;
+  auto it = j.begin();
+  Json::Value::const_iterator cit;
+  cit = it;
+  JSONTEST_ASSERT(cit == cj.begin());
+}
+
+JSONTEST_FIXTURE_LOCAL(IteratorTest, decrement) {
+  Json::Value json;
+  json["k1"] = "a";
+  json["k2"] = "b";
+  std::vector<std::string> values;
+  for (auto it = json.end(); it != json.begin();) {
+    --it;
+    values.push_back(it->asString());
+  }
+  JSONTEST_ASSERT((values == std::vector<std::string>{"b", "a"}));
+}
+
+JSONTEST_FIXTURE_LOCAL(IteratorTest, reverseIterator) {
+  Json::Value json;
+  json["k1"] = "a";
+  json["k2"] = "b";
+  std::vector<std::string> values;
+  using Iter = decltype(json.begin());
+  auto re = std::reverse_iterator<Iter>(json.begin());
+  for (auto it = std::reverse_iterator<Iter>(json.end()); it != re; ++it) {
+    values.push_back(it->asString());
+  }
+  JSONTEST_ASSERT((values == std::vector<std::string>{"b", "a"}));
+}
+
+JSONTEST_FIXTURE_LOCAL(IteratorTest, distance) {
+  {
+    Json::Value json;
+    json["k1"] = "a";
+    json["k2"] = "b";
+    int i = 0;
+    auto it = json.begin();
+    for (;; ++it, ++i) {
+      auto dist = it - json.begin();
+      JSONTEST_ASSERT_EQUAL(i, dist);
+      if (it == json.end())
+        break;
+    }
+  }
+  {
+    Json::Value empty;
+    JSONTEST_ASSERT_EQUAL(0, empty.end() - empty.end());
+    JSONTEST_ASSERT_EQUAL(0, empty.end() - empty.begin());
+  }
+}
+
+JSONTEST_FIXTURE_LOCAL(IteratorTest, nullValues) {
+  {
+    Json::Value json;
+    auto end = json.end();
+    auto endCopy = end;
+    JSONTEST_ASSERT(endCopy == end);
+    endCopy = end;
+    JSONTEST_ASSERT(endCopy == end);
+  }
+  {
+    // Same test, now with const Value.
+    const Json::Value json;
+    auto end = json.end();
+    auto endCopy = end;
+    JSONTEST_ASSERT(endCopy == end);
+    endCopy = end;
+    JSONTEST_ASSERT(endCopy == end);
+  }
+}
+
+JSONTEST_FIXTURE_LOCAL(IteratorTest, staticStringKey) {
+  Json::Value json;
+  json[Json::StaticString("k1")] = "a";
+  JSONTEST_ASSERT_EQUAL(Json::Value("k1"), json.begin().key());
+}
+
+JSONTEST_FIXTURE_LOCAL(IteratorTest, names) {
+  Json::Value json;
+  json["k1"] = "a";
+  json["k2"] = "b";
+  Json::ValueIterator it = json.begin();
+  JSONTEST_ASSERT(it != json.end());
+  JSONTEST_ASSERT_EQUAL(Json::Value("k1"), it.key());
+  JSONTEST_ASSERT_STRING_EQUAL("k1", it.name());
+  JSONTEST_ASSERT_STRING_EQUAL("k1", it.memberName());
+  JSONTEST_ASSERT_EQUAL(-1, it.index());
+  ++it;
+  JSONTEST_ASSERT(it != json.end());
+  JSONTEST_ASSERT_EQUAL(Json::Value("k2"), it.key());
+  JSONTEST_ASSERT_STRING_EQUAL("k2", it.name());
+  JSONTEST_ASSERT_STRING_EQUAL("k2", it.memberName());
+  JSONTEST_ASSERT_EQUAL(-1, it.index());
+  ++it;
+  JSONTEST_ASSERT(it == json.end());
+}
+
+JSONTEST_FIXTURE_LOCAL(IteratorTest, indexes) {
+  Json::Value json;
+  json[0] = "a";
+  json[1] = "b";
+  Json::ValueIterator it = json.begin();
+  JSONTEST_ASSERT(it != json.end());
+  JSONTEST_ASSERT_EQUAL(Json::Value(Json::ArrayIndex(0)), it.key());
+  JSONTEST_ASSERT_STRING_EQUAL("", it.name());
+  JSONTEST_ASSERT_EQUAL(0, it.index());
+  ++it;
+  JSONTEST_ASSERT(it != json.end());
+  JSONTEST_ASSERT_EQUAL(Json::Value(Json::ArrayIndex(1)), it.key());
+  JSONTEST_ASSERT_STRING_EQUAL("", it.name());
+  JSONTEST_ASSERT_EQUAL(1, it.index());
+  ++it;
+  JSONTEST_ASSERT(it == json.end());
+}
+
+JSONTEST_FIXTURE_LOCAL(IteratorTest, constness) {
+  Json::Value const v;
+  JSONTEST_ASSERT_THROWS(
+      Json::Value::iterator it(v.begin())); // Compile, but throw.
+
+  Json::Value value;
+
+  for (int i = 9; i < 12; ++i) {
+    Json::OStringStream out;
+    out << std::setw(2) << i;
+    Json::String str = out.str();
+    value[str] = str;
+  }
+
+  Json::OStringStream out;
+  // in old code, this will get a compile error
+  Json::Value::const_iterator iter = value.begin();
+  for (; iter != value.end(); ++iter) {
+    out << *iter << ',';
+  }
+  Json::String expected = R"(" 9","10","11",)";
+  JSONTEST_ASSERT_STRING_EQUAL(expected, out.str());
+}
+
+struct RValueTest : JsonTest::TestCase {};
+
+JSONTEST_FIXTURE_LOCAL(RValueTest, moveConstruction) {
+  Json::Value json;
+  json["key"] = "value";
+  Json::Value moved = std::move(json);
+  JSONTEST_ASSERT(moved != json); // Possibly not nullValue; definitely not
+                                  // equal.
+  JSONTEST_ASSERT_EQUAL(Json::objectValue, moved.type());
+  JSONTEST_ASSERT_EQUAL(Json::stringValue, moved["key"].type());
+}
+
+struct FuzzTest : JsonTest::TestCase {};
+
+// Build and run the fuzz test without any fuzzer, so that it's guaranteed not
+// go out of date, even if it's never run as an actual fuzz test.
+JSONTEST_FIXTURE_LOCAL(FuzzTest, fuzzDoesntCrash) {
+  const std::string example = "{}";
+  JSONTEST_ASSERT_EQUAL(
+      0,
+      LLVMFuzzerTestOneInput(reinterpret_cast<const uint8_t*>(example.c_str()),
+                             example.size()));
+}
+
+int main(int argc, const char* argv[]) {
+  JsonTest::Runner runner;
+
+  for (auto& local : local_) {
+    runner.add(local);
+  }
+
+  return runner.runCommandLine(argc, argv);
+}
+
+struct MemberTemplateAs : JsonTest::TestCase {
+  template <typename T, typename F>
+  JsonTest::TestResult& EqEval(T v, F f) const {
+    const Json::Value j = v;
+    return JSONTEST_ASSERT_EQUAL(j.as<T>(), f(j));
+  }
+};
+
+JSONTEST_FIXTURE_LOCAL(MemberTemplateAs, BehavesSameAsNamedAs) {
+  const Json::Value jstr = "hello world";
+  JSONTEST_ASSERT_STRING_EQUAL(jstr.as<const char*>(), jstr.asCString());
+  JSONTEST_ASSERT_STRING_EQUAL(jstr.as<Json::String>(), jstr.asString());
+  EqEval(Json::Int(64), [](const Json::Value& j) { return j.asInt(); });
+  EqEval(Json::UInt(64), [](const Json::Value& j) { return j.asUInt(); });
+#if defined(JSON_HAS_INT64)
+  EqEval(Json::Int64(64), [](const Json::Value& j) { return j.asInt64(); });
+  EqEval(Json::UInt64(64), [](const Json::Value& j) { return j.asUInt64(); });
+#endif // if defined(JSON_HAS_INT64)
+  EqEval(Json::LargestInt(64),
+         [](const Json::Value& j) { return j.asLargestInt(); });
+  EqEval(Json::LargestUInt(64),
+         [](const Json::Value& j) { return j.asLargestUInt(); });
+
+  EqEval(69.69f, [](const Json::Value& j) { return j.asFloat(); });
+  EqEval(69.69, [](const Json::Value& j) { return j.asDouble(); });
+  EqEval(false, [](const Json::Value& j) { return j.asBool(); });
+  EqEval(true, [](const Json::Value& j) { return j.asBool(); });
+}
+
+class MemberTemplateIs : public JsonTest::TestCase {};
+
+JSONTEST_FIXTURE_LOCAL(MemberTemplateIs, BehavesSameAsNamedIs) {
+  const Json::Value values[] = {true, 142, 40.63, "hello world"};
+  for (const Json::Value& j : values) {
+    JSONTEST_ASSERT_EQUAL(j.is<bool>(), j.isBool());
+    JSONTEST_ASSERT_EQUAL(j.is<Json::Int>(), j.isInt());
+    JSONTEST_ASSERT_EQUAL(j.is<Json::Int64>(), j.isInt64());
+    JSONTEST_ASSERT_EQUAL(j.is<Json::UInt>(), j.isUInt());
+    JSONTEST_ASSERT_EQUAL(j.is<Json::UInt64>(), j.isUInt64());
+    JSONTEST_ASSERT_EQUAL(j.is<double>(), j.isDouble());
+    JSONTEST_ASSERT_EQUAL(j.is<Json::String>(), j.isString());
+  }
+}
+
+class VersionTest : public JsonTest::TestCase {};
+
+JSONTEST_FIXTURE_LOCAL(VersionTest, VersionNumbersMatch) {
+  std::ostringstream vstr;
+  vstr << JSONCPP_VERSION_MAJOR << '.' << JSONCPP_VERSION_MINOR << '.'
+       << JSONCPP_VERSION_PATCH;
+  JSONTEST_ASSERT_EQUAL(vstr.str(), std::string(JSONCPP_VERSION_STRING));
+}
+
+#if defined(__GNUC__)
+#pragma GCC diagnostic pop
+#endif
diff --git a/3rdparty/jsoncpp/src/test/cleantests.py b/3rdparty/jsoncpp/src/test/cleantests.py
new file mode 100644
index 00000000..36d5b9b4
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/cleantests.py
@@ -0,0 +1,16 @@
+# Copyright 2007 Baptiste Lepilleur and The JsonCpp Authors
+# Distributed under MIT license, or public domain if desired and
+# recognized in your jurisdiction.
+# See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+"""Removes all files created during testing."""
+
+import glob
+import os
+
+paths = []
+for pattern in [ '*.actual', '*.actual-rewrite', '*.rewrite', '*.process-output' ]:
+    paths += glob.glob('data/' + pattern)
+
+for path in paths:
+    os.unlink(path)
diff --git a/3rdparty/jsoncpp/src/test/data/fail_invalid_quote.json b/3rdparty/jsoncpp/src/test/data/fail_invalid_quote.json
new file mode 100644
index 00000000..dae27f53
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/fail_invalid_quote.json
@@ -0,0 +1 @@
+{'//this is bad JSON.'}
\ No newline at end of file
diff --git a/3rdparty/jsoncpp/src/test/data/fail_test_array_01.json b/3rdparty/jsoncpp/src/test/data/fail_test_array_01.json
new file mode 100644
index 00000000..f72a6d07
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/fail_test_array_01.json
@@ -0,0 +1 @@
+[ 1 2 3]
diff --git a/3rdparty/jsoncpp/src/test/data/fail_test_array_02.json b/3rdparty/jsoncpp/src/test/data/fail_test_array_02.json
new file mode 100644
index 00000000..222a1b47
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/fail_test_array_02.json
@@ -0,0 +1 @@
+[1,,]
diff --git a/3rdparty/jsoncpp/src/test/data/fail_test_object_01.json b/3rdparty/jsoncpp/src/test/data/fail_test_object_01.json
new file mode 100644
index 00000000..46fd39ab
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/fail_test_object_01.json
@@ -0,0 +1 @@
+{ "count" : 1234,, }
diff --git a/3rdparty/jsoncpp/src/test/data/fail_test_stack_limit.json b/3rdparty/jsoncpp/src/test/data/fail_test_stack_limit.json
new file mode 100644
index 00000000..7524e0bb
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/fail_test_stack_limit.json
@@ -0,0 +1 @@
+[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_array_01.expected b/3rdparty/jsoncpp/src/test/data/legacy_test_array_01.expected
new file mode 100644
index 00000000..a341ff75
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_array_01.expected
@@ -0,0 +1 @@
+.=[]
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_array_01.json b/3rdparty/jsoncpp/src/test/data/legacy_test_array_01.json
new file mode 100644
index 00000000..fe51488c
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_array_01.json
@@ -0,0 +1 @@
+[]
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_array_02.expected b/3rdparty/jsoncpp/src/test/data/legacy_test_array_02.expected
new file mode 100644
index 00000000..ef1f2623
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_array_02.expected
@@ -0,0 +1,2 @@
+.=[]
+.[0]=1
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_array_02.json b/3rdparty/jsoncpp/src/test/data/legacy_test_array_02.json
new file mode 100644
index 00000000..7660873d
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_array_02.json
@@ -0,0 +1 @@
+[1]
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_array_03.expected b/3rdparty/jsoncpp/src/test/data/legacy_test_array_03.expected
new file mode 100644
index 00000000..3d8dc18e
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_array_03.expected
@@ -0,0 +1,6 @@
+.=[]
+.[0]=1
+.[1]=2
+.[2]=3
+.[3]=4
+.[4]=5
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_array_03.json b/3rdparty/jsoncpp/src/test/data/legacy_test_array_03.json
new file mode 100644
index 00000000..9b3f9247
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_array_03.json
@@ -0,0 +1 @@
+[ 1, 2 ,  3,4,5]
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_array_04.expected b/3rdparty/jsoncpp/src/test/data/legacy_test_array_04.expected
new file mode 100644
index 00000000..ad4add97
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_array_04.expected
@@ -0,0 +1,5 @@
+.=[]
+.[0]=1
+.[1]="abc"
+.[2]=12.3
+.[3]=-4
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_array_04.json b/3rdparty/jsoncpp/src/test/data/legacy_test_array_04.json
new file mode 100644
index 00000000..ecca546b
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_array_04.json
@@ -0,0 +1 @@
+[1, "abc" , 12.3, -4]
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_array_05.expected b/3rdparty/jsoncpp/src/test/data/legacy_test_array_05.expected
new file mode 100644
index 00000000..76cff87c
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_array_05.expected
@@ -0,0 +1,100 @@
+.=[]
+.[0]=1
+.[1]=2
+.[2]=3
+.[3]=4
+.[4]=5
+.[5]=6
+.[6]=7
+.[7]=8
+.[8]=9
+.[9]=10
+.[10]=11
+.[11]=12
+.[12]=13
+.[13]=14
+.[14]=15
+.[15]=16
+.[16]=17
+.[17]=18
+.[18]=19
+.[19]=20
+.[20]=21
+.[21]=22
+.[22]=23
+.[23]=24
+.[24]=25
+.[25]=26
+.[26]=27
+.[27]=28
+.[28]=29
+.[29]=30
+.[30]=31
+.[31]=32
+.[32]=33
+.[33]=34
+.[34]=35
+.[35]=36
+.[36]=37
+.[37]=38
+.[38]=39
+.[39]=40
+.[40]=41
+.[41]=42
+.[42]=43
+.[43]=44
+.[44]=45
+.[45]=46
+.[46]=47
+.[47]=48
+.[48]=49
+.[49]=50
+.[50]=51
+.[51]=52
+.[52]=53
+.[53]=54
+.[54]=55
+.[55]=56
+.[56]=57
+.[57]=58
+.[58]=59
+.[59]=60
+.[60]=61
+.[61]=62
+.[62]=63
+.[63]=64
+.[64]=65
+.[65]=66
+.[66]=67
+.[67]=68
+.[68]=69
+.[69]=70
+.[70]=71
+.[71]=72
+.[72]=73
+.[73]=74
+.[74]=75
+.[75]=76
+.[76]=77
+.[77]=78
+.[78]=79
+.[79]=80
+.[80]=81
+.[81]=82
+.[82]=83
+.[83]=84
+.[84]=85
+.[85]=86
+.[86]=87
+.[87]=88
+.[88]=89
+.[89]=90
+.[90]=91
+.[91]=92
+.[92]=93
+.[93]=94
+.[94]=95
+.[95]=96
+.[96]=97
+.[97]=98
+.[98]=99
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_array_05.json b/3rdparty/jsoncpp/src/test/data/legacy_test_array_05.json
new file mode 100644
index 00000000..7809d6c9
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_array_05.json
@@ -0,0 +1 @@
+[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99]
\ No newline at end of file
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_array_06.expected b/3rdparty/jsoncpp/src/test/data/legacy_test_array_06.expected
new file mode 100644
index 00000000..5c9f48ea
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_array_06.expected
@@ -0,0 +1,5 @@
+.=[]
+.[0]="aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+.[1]="bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
+.[2]="ccccccccccccccccccccccc"
+.[3]="dddddddddddddddddddddddddddddddddddddddddddddddddddd"
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_array_06.json b/3rdparty/jsoncpp/src/test/data/legacy_test_array_06.json
new file mode 100644
index 00000000..1fda03bb
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_array_06.json
@@ -0,0 +1,4 @@
+[ "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+  "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
+  "ccccccccccccccccccccccc",
+  "dddddddddddddddddddddddddddddddddddddddddddddddddddd" ]
\ No newline at end of file
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_array_07.expected b/3rdparty/jsoncpp/src/test/data/legacy_test_array_07.expected
new file mode 100644
index 00000000..ee2fafc0
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_array_07.expected
@@ -0,0 +1,2122 @@
+.=[]
+.[0]=[]
+.[0][0]="A"
+.[0][1]=0
+.[0][2]=1
+.[0][3]=2
+.[0][4]=3
+.[0][5]=4
+.[0][6]=5
+.[0][7]=6
+.[0][8]=7
+.[0][9]=8
+.[0][10]=9
+.[0][11]=10
+.[0][12]=11
+.[0][13]=12
+.[0][14]=13
+.[0][15]=14
+.[0][16]=15
+.[0][17]=16
+.[0][18]=17
+.[0][19]=18
+.[0][20]=19
+.[0][21]=20
+.[0][22]=21
+.[0][23]=22
+.[0][24]=23
+.[0][25]=24
+.[0][26]=25
+.[0][27]=26
+.[0][28]=27
+.[0][29]=28
+.[0][30]=29
+.[0][31]=30
+.[0][32]=31
+.[0][33]=32
+.[0][34]=33
+.[0][35]=34
+.[0][36]=35
+.[0][37]=36
+.[0][38]=37
+.[0][39]=38
+.[0][40]=39
+.[0][41]=40
+.[0][42]=41
+.[0][43]=42
+.[0][44]=43
+.[0][45]=44
+.[0][46]=45
+.[0][47]=46
+.[0][48]=47
+.[0][49]=48
+.[0][50]=49
+.[0][51]=50
+.[0][52]=51
+.[0][53]=52
+.[0][54]=53
+.[0][55]=54
+.[0][56]=55
+.[0][57]=56
+.[0][58]=57
+.[0][59]=58
+.[0][60]=59
+.[0][61]=60
+.[0][62]=61
+.[0][63]=62
+.[0][64]=63
+.[0][65]=64
+.[0][66]=65
+.[0][67]=66
+.[0][68]=67
+.[0][69]=68
+.[0][70]=69
+.[0][71]=70
+.[0][72]=71
+.[0][73]=72
+.[0][74]=73
+.[0][75]=74
+.[0][76]=75
+.[0][77]=76
+.[0][78]=77
+.[0][79]=78
+.[0][80]=79
+.[0][81]=80
+.[0][82]=81
+.[0][83]=82
+.[0][84]=83
+.[0][85]=84
+.[0][86]=85
+.[0][87]=86
+.[0][88]=87
+.[0][89]=88
+.[0][90]=89
+.[0][91]=90
+.[0][92]=91
+.[0][93]=92
+.[0][94]=93
+.[0][95]=94
+.[0][96]=95
+.[0][97]=96
+.[0][98]=97
+.[0][99]=98
+.[0][100]=99
+.[0][101]=100
+.[0][102]=101
+.[0][103]=102
+.[0][104]=103
+.[0][105]=104
+.[0][106]=105
+.[0][107]=106
+.[0][108]=107
+.[0][109]=108
+.[0][110]=109
+.[0][111]=110
+.[0][112]=111
+.[0][113]=112
+.[0][114]=113
+.[0][115]=114
+.[0][116]=115
+.[0][117]=116
+.[0][118]=117
+.[0][119]=118
+.[0][120]=119
+.[0][121]=120
+.[0][122]=121
+.[0][123]=122
+.[0][124]=123
+.[0][125]=124
+.[0][126]=125
+.[0][127]=126
+.[0][128]=127
+.[0][129]=128
+.[0][130]=129
+.[0][131]=130
+.[0][132]=131
+.[0][133]=132
+.[0][134]=133
+.[0][135]=134
+.[0][136]=135
+.[0][137]=136
+.[0][138]=137
+.[0][139]=138
+.[0][140]=139
+.[0][141]=140
+.[0][142]=141
+.[0][143]=142
+.[0][144]=143
+.[0][145]=144
+.[0][146]=145
+.[0][147]=146
+.[0][148]=147
+.[0][149]=148
+.[0][150]=149
+.[0][151]=150
+.[0][152]=151
+.[0][153]=152
+.[0][154]=153
+.[0][155]=154
+.[0][156]=155
+.[0][157]=156
+.[0][158]=157
+.[0][159]=158
+.[0][160]=159
+.[0][161]=160
+.[0][162]=161
+.[0][163]=162
+.[0][164]=163
+.[0][165]=164
+.[0][166]=165
+.[0][167]=166
+.[0][168]=167
+.[0][169]=168
+.[0][170]=169
+.[0][171]=170
+.[0][172]=171
+.[0][173]=172
+.[0][174]=173
+.[0][175]=174
+.[0][176]=175
+.[0][177]=176
+.[0][178]=177
+.[0][179]=178
+.[0][180]=179
+.[0][181]=180
+.[0][182]=181
+.[0][183]=182
+.[0][184]=183
+.[0][185]=184
+.[0][186]=185
+.[0][187]=186
+.[0][188]=187
+.[0][189]=188
+.[0][190]=189
+.[0][191]=190
+.[0][192]=191
+.[0][193]=192
+.[0][194]=193
+.[0][195]=194
+.[0][196]=195
+.[0][197]=196
+.[0][198]=197
+.[0][199]=198
+.[0][200]=199
+.[0][201]=200
+.[0][202]=201
+.[0][203]=202
+.[0][204]=203
+.[0][205]=204
+.[0][206]=205
+.[0][207]=206
+.[0][208]=207
+.[0][209]=208
+.[0][210]=209
+.[0][211]=210
+.[0][212]=211
+.[0][213]=212
+.[0][214]=213
+.[0][215]=214
+.[0][216]=215
+.[0][217]=216
+.[0][218]=217
+.[0][219]=218
+.[0][220]=219
+.[0][221]=220
+.[0][222]=221
+.[0][223]=222
+.[0][224]=223
+.[0][225]=224
+.[0][226]=225
+.[0][227]=226
+.[0][228]=227
+.[0][229]=228
+.[0][230]=229
+.[0][231]=230
+.[0][232]=231
+.[0][233]=232
+.[0][234]=233
+.[0][235]=234
+.[0][236]=235
+.[0][237]=236
+.[0][238]=237
+.[0][239]=238
+.[0][240]=239
+.[0][241]=240
+.[0][242]=241
+.[0][243]=242
+.[0][244]=243
+.[0][245]=244
+.[0][246]=245
+.[0][247]=246
+.[0][248]=247
+.[0][249]=248
+.[0][250]=249
+.[0][251]=250
+.[0][252]=251
+.[0][253]=252
+.[0][254]=253
+.[0][255]=254
+.[0][256]=255
+.[0][257]=256
+.[0][258]=257
+.[0][259]=258
+.[0][260]=259
+.[0][261]=260
+.[0][262]=261
+.[0][263]=262
+.[0][264]=263
+.[0][265]=264
+.[0][266]=265
+.[0][267]=266
+.[0][268]=267
+.[0][269]=268
+.[0][270]=269
+.[0][271]=270
+.[0][272]=271
+.[0][273]=272
+.[0][274]=273
+.[0][275]=274
+.[0][276]=275
+.[0][277]=276
+.[0][278]=277
+.[0][279]=278
+.[0][280]=279
+.[0][281]=280
+.[0][282]=281
+.[0][283]=282
+.[0][284]=283
+.[0][285]=284
+.[0][286]=285
+.[0][287]=286
+.[0][288]=287
+.[0][289]=288
+.[0][290]=289
+.[0][291]=290
+.[0][292]=291
+.[0][293]=292
+.[0][294]=293
+.[0][295]=294
+.[0][296]=295
+.[0][297]=296
+.[0][298]=297
+.[0][299]=298
+.[0][300]=299
+.[0][301]=300
+.[0][302]=301
+.[0][303]=302
+.[0][304]=303
+.[0][305]=304
+.[0][306]=305
+.[0][307]=306
+.[0][308]=307
+.[0][309]=308
+.[0][310]=309
+.[0][311]=310
+.[0][312]=311
+.[0][313]=312
+.[0][314]=313
+.[0][315]=314
+.[0][316]=315
+.[0][317]=316
+.[0][318]=317
+.[0][319]=318
+.[0][320]=319
+.[0][321]=320
+.[0][322]=321
+.[0][323]=322
+.[0][324]=323
+.[0][325]=324
+.[0][326]=325
+.[0][327]=326
+.[0][328]=327
+.[0][329]=328
+.[0][330]=329
+.[0][331]=330
+.[0][332]=331
+.[0][333]=332
+.[0][334]=333
+.[0][335]=334
+.[0][336]=335
+.[0][337]=336
+.[0][338]=337
+.[0][339]=338
+.[0][340]=339
+.[0][341]=340
+.[0][342]=341
+.[0][343]=342
+.[0][344]=343
+.[0][345]=344
+.[0][346]=345
+.[0][347]=346
+.[0][348]=347
+.[0][349]=348
+.[0][350]=349
+.[0][351]=350
+.[0][352]=351
+.[0][353]=352
+.[0][354]=353
+.[0][355]=354
+.[0][356]=355
+.[0][357]=356
+.[0][358]=357
+.[0][359]=358
+.[0][360]=359
+.[0][361]=360
+.[0][362]=361
+.[0][363]=362
+.[0][364]=363
+.[0][365]=364
+.[0][366]=365
+.[0][367]=366
+.[0][368]=367
+.[0][369]=368
+.[0][370]=369
+.[0][371]=370
+.[0][372]=371
+.[0][373]=372
+.[0][374]=373
+.[0][375]=374
+.[0][376]=375
+.[0][377]=376
+.[0][378]=377
+.[0][379]=378
+.[0][380]=379
+.[0][381]=380
+.[0][382]=381
+.[0][383]=382
+.[0][384]=383
+.[0][385]=384
+.[0][386]=385
+.[0][387]=386
+.[0][388]=387
+.[0][389]=388
+.[0][390]=389
+.[0][391]=390
+.[0][392]=391
+.[0][393]=392
+.[0][394]=393
+.[0][395]=394
+.[0][396]=395
+.[0][397]=396
+.[0][398]=397
+.[0][399]=398
+.[0][400]=399
+.[0][401]=400
+.[0][402]=401
+.[0][403]=402
+.[0][404]=403
+.[0][405]=404
+.[0][406]=405
+.[0][407]=406
+.[0][408]=407
+.[0][409]=408
+.[0][410]=409
+.[0][411]=410
+.[0][412]=411
+.[0][413]=412
+.[0][414]=413
+.[0][415]=414
+.[0][416]=415
+.[0][417]=416
+.[0][418]=417
+.[0][419]=418
+.[0][420]=419
+.[0][421]=420
+.[0][422]=421
+.[0][423]=422
+.[0][424]=423
+.[0][425]=424
+.[0][426]=425
+.[0][427]=426
+.[0][428]=427
+.[0][429]=428
+.[0][430]=429
+.[0][431]=430
+.[0][432]=431
+.[0][433]=432
+.[0][434]=433
+.[0][435]=434
+.[0][436]=435
+.[0][437]=436
+.[0][438]=437
+.[0][439]=438
+.[0][440]=439
+.[0][441]=440
+.[0][442]=441
+.[0][443]=442
+.[0][444]=443
+.[0][445]=444
+.[0][446]=445
+.[0][447]=446
+.[0][448]=447
+.[0][449]=448
+.[0][450]=449
+.[0][451]=450
+.[0][452]=451
+.[0][453]=452
+.[0][454]=453
+.[0][455]=454
+.[0][456]=455
+.[0][457]=456
+.[0][458]=457
+.[0][459]=458
+.[0][460]=459
+.[0][461]=460
+.[0][462]=461
+.[0][463]=462
+.[0][464]=463
+.[0][465]=464
+.[0][466]=465
+.[0][467]=466
+.[0][468]=467
+.[0][469]=468
+.[0][470]=469
+.[0][471]=470
+.[0][472]=471
+.[0][473]=472
+.[0][474]=473
+.[0][475]=474
+.[0][476]=475
+.[0][477]=476
+.[0][478]=477
+.[0][479]=478
+.[0][480]=479
+.[0][481]=480
+.[0][482]=481
+.[0][483]=482
+.[0][484]=483
+.[0][485]=484
+.[0][486]=485
+.[0][487]=486
+.[0][488]=487
+.[0][489]=488
+.[0][490]=489
+.[0][491]=490
+.[0][492]=491
+.[0][493]=492
+.[0][494]=493
+.[0][495]=494
+.[0][496]=495
+.[0][497]=496
+.[0][498]=497
+.[0][499]=498
+.[0][500]=499
+.[0][501]=500
+.[0][502]=501
+.[0][503]=502
+.[0][504]=503
+.[0][505]=504
+.[0][506]=505
+.[0][507]=506
+.[0][508]=507
+.[0][509]=508
+.[0][510]=509
+.[0][511]=510
+.[0][512]=511
+.[0][513]=512
+.[0][514]=513
+.[0][515]=514
+.[0][516]=515
+.[0][517]=516
+.[0][518]=517
+.[0][519]=518
+.[0][520]=519
+.[0][521]=520
+.[0][522]=521
+.[0][523]=522
+.[0][524]=523
+.[0][525]=524
+.[0][526]=525
+.[0][527]=526
+.[0][528]=527
+.[0][529]=528
+.[0][530]=529
+.[0][531]=530
+.[0][532]=531
+.[0][533]=532
+.[0][534]=533
+.[0][535]=534
+.[0][536]=535
+.[0][537]=536
+.[0][538]=537
+.[0][539]=538
+.[0][540]=539
+.[0][541]=540
+.[0][542]=541
+.[0][543]=542
+.[0][544]=543
+.[0][545]=544
+.[0][546]=545
+.[0][547]=546
+.[0][548]=547
+.[0][549]=548
+.[0][550]=549
+.[0][551]=550
+.[0][552]=551
+.[0][553]=552
+.[0][554]=553
+.[0][555]=554
+.[0][556]=555
+.[0][557]=556
+.[0][558]=557
+.[0][559]=558
+.[0][560]=559
+.[0][561]=560
+.[0][562]=561
+.[0][563]=562
+.[0][564]=563
+.[0][565]=564
+.[0][566]=565
+.[0][567]=566
+.[0][568]=567
+.[0][569]=568
+.[0][570]=569
+.[0][571]=570
+.[0][572]=571
+.[0][573]=572
+.[0][574]=573
+.[0][575]=574
+.[0][576]=575
+.[0][577]=576
+.[0][578]=577
+.[0][579]=578
+.[0][580]=579
+.[0][581]=580
+.[0][582]=581
+.[0][583]=582
+.[0][584]=583
+.[0][585]=584
+.[0][586]=585
+.[0][587]=586
+.[0][588]=587
+.[0][589]=588
+.[0][590]=589
+.[0][591]=590
+.[0][592]=591
+.[0][593]=592
+.[0][594]=593
+.[0][595]=594
+.[0][596]=595
+.[0][597]=596
+.[0][598]=597
+.[0][599]=598
+.[0][600]=599
+.[0][601]=600
+.[0][602]=601
+.[0][603]=602
+.[0][604]=603
+.[0][605]=604
+.[0][606]=605
+.[0][607]=606
+.[0][608]=607
+.[0][609]=608
+.[0][610]=609
+.[0][611]=610
+.[0][612]=611
+.[0][613]=612
+.[0][614]=613
+.[0][615]=614
+.[0][616]=615
+.[0][617]=616
+.[0][618]=617
+.[0][619]=618
+.[0][620]=619
+.[0][621]=620
+.[0][622]=621
+.[0][623]=622
+.[0][624]=623
+.[0][625]=624
+.[0][626]=625
+.[0][627]=626
+.[0][628]=627
+.[0][629]=628
+.[0][630]=629
+.[0][631]=630
+.[0][632]=631
+.[0][633]=632
+.[0][634]=633
+.[0][635]=634
+.[0][636]=635
+.[0][637]=636
+.[0][638]=637
+.[0][639]=638
+.[0][640]=639
+.[0][641]=640
+.[0][642]=641
+.[0][643]=642
+.[0][644]=643
+.[0][645]=644
+.[0][646]=645
+.[0][647]=646
+.[0][648]=647
+.[0][649]=648
+.[0][650]=649
+.[0][651]=650
+.[0][652]=651
+.[0][653]=652
+.[0][654]=653
+.[0][655]=654
+.[0][656]=655
+.[0][657]=656
+.[0][658]=657
+.[0][659]=658
+.[0][660]=659
+.[0][661]=660
+.[0][662]=661
+.[0][663]=662
+.[0][664]=663
+.[0][665]=664
+.[0][666]=665
+.[0][667]=666
+.[0][668]=667
+.[0][669]=668
+.[0][670]=669
+.[0][671]=670
+.[0][672]=671
+.[0][673]=672
+.[0][674]=673
+.[0][675]=674
+.[0][676]=675
+.[0][677]=676
+.[0][678]=677
+.[0][679]=678
+.[0][680]=679
+.[0][681]=680
+.[0][682]=681
+.[0][683]=682
+.[0][684]=683
+.[0][685]=684
+.[0][686]=685
+.[0][687]=686
+.[0][688]=687
+.[0][689]=688
+.[0][690]=689
+.[0][691]=690
+.[0][692]=691
+.[0][693]=692
+.[0][694]=693
+.[0][695]=694
+.[0][696]=695
+.[0][697]=696
+.[0][698]=697
+.[0][699]=698
+.[0][700]=699
+.[0][701]=700
+.[0][702]=701
+.[0][703]=702
+.[0][704]=703
+.[0][705]=704
+.[0][706]=705
+.[0][707]=706
+.[0][708]=707
+.[0][709]=708
+.[0][710]=709
+.[0][711]=710
+.[0][712]=711
+.[0][713]=712
+.[0][714]=713
+.[0][715]=714
+.[0][716]=715
+.[0][717]=716
+.[0][718]=717
+.[0][719]=718
+.[0][720]=719
+.[0][721]=720
+.[0][722]=721
+.[0][723]=722
+.[0][724]=723
+.[0][725]=724
+.[0][726]=725
+.[0][727]=726
+.[0][728]=727
+.[0][729]=728
+.[0][730]=729
+.[0][731]=730
+.[0][732]=731
+.[0][733]=732
+.[0][734]=733
+.[0][735]=734
+.[0][736]=735
+.[0][737]=736
+.[0][738]=737
+.[0][739]=738
+.[0][740]=739
+.[0][741]=740
+.[0][742]=741
+.[0][743]=742
+.[0][744]=743
+.[0][745]=744
+.[0][746]=745
+.[0][747]=746
+.[0][748]=747
+.[0][749]=748
+.[0][750]=749
+.[0][751]=750
+.[0][752]=751
+.[0][753]=752
+.[0][754]=753
+.[0][755]=754
+.[0][756]=755
+.[0][757]=756
+.[0][758]=757
+.[0][759]=758
+.[0][760]=759
+.[0][761]=760
+.[0][762]=761
+.[0][763]=762
+.[0][764]=763
+.[0][765]=764
+.[0][766]=765
+.[0][767]=766
+.[0][768]=767
+.[0][769]=768
+.[0][770]=769
+.[0][771]=770
+.[0][772]=771
+.[0][773]=772
+.[0][774]=773
+.[0][775]=774
+.[0][776]=775
+.[0][777]=776
+.[0][778]=777
+.[0][779]=778
+.[0][780]=779
+.[0][781]=780
+.[0][782]=781
+.[0][783]=782
+.[0][784]=783
+.[0][785]=784
+.[0][786]=785
+.[0][787]=786
+.[0][788]=787
+.[0][789]=788
+.[0][790]=789
+.[0][791]=790
+.[0][792]=791
+.[0][793]=792
+.[0][794]=793
+.[0][795]=794
+.[0][796]=795
+.[0][797]=796
+.[0][798]=797
+.[0][799]=798
+.[0][800]=799
+.[0][801]=800
+.[0][802]=801
+.[0][803]=802
+.[0][804]=803
+.[0][805]=804
+.[0][806]=805
+.[0][807]=806
+.[0][808]=807
+.[0][809]=808
+.[0][810]=809
+.[0][811]=810
+.[0][812]=811
+.[0][813]=812
+.[0][814]=813
+.[0][815]=814
+.[0][816]=815
+.[0][817]=816
+.[0][818]=817
+.[0][819]=818
+.[0][820]=819
+.[0][821]=820
+.[0][822]=821
+.[0][823]=822
+.[0][824]=823
+.[0][825]=824
+.[0][826]=825
+.[0][827]=826
+.[0][828]=827
+.[0][829]=828
+.[0][830]=829
+.[0][831]=830
+.[0][832]=831
+.[0][833]=832
+.[0][834]=833
+.[0][835]=834
+.[0][836]=835
+.[0][837]=836
+.[0][838]=837
+.[0][839]=838
+.[0][840]=839
+.[0][841]=840
+.[0][842]=841
+.[0][843]=842
+.[0][844]=843
+.[0][845]=844
+.[0][846]=845
+.[0][847]=846
+.[0][848]=847
+.[0][849]=848
+.[0][850]=849
+.[0][851]=850
+.[0][852]=851
+.[0][853]=852
+.[0][854]=853
+.[0][855]=854
+.[0][856]=855
+.[0][857]=856
+.[0][858]=857
+.[0][859]=858
+.[0][860]=859
+.[0][861]=860
+.[0][862]=861
+.[0][863]=862
+.[0][864]=863
+.[0][865]=864
+.[0][866]=865
+.[0][867]=866
+.[0][868]=867
+.[0][869]=868
+.[0][870]=869
+.[0][871]=870
+.[0][872]=871
+.[0][873]=872
+.[0][874]=873
+.[0][875]=874
+.[0][876]=875
+.[0][877]=876
+.[0][878]=877
+.[0][879]=878
+.[0][880]=879
+.[0][881]=880
+.[0][882]=881
+.[0][883]=882
+.[0][884]=883
+.[0][885]=884
+.[0][886]=885
+.[0][887]=886
+.[0][888]=887
+.[0][889]=888
+.[0][890]=889
+.[0][891]=890
+.[0][892]=891
+.[0][893]=892
+.[0][894]=893
+.[0][895]=894
+.[0][896]=895
+.[0][897]=896
+.[0][898]=897
+.[0][899]=898
+.[0][900]=899
+.[0][901]=900
+.[0][902]=901
+.[0][903]=902
+.[0][904]=903
+.[0][905]=904
+.[0][906]=905
+.[0][907]=906
+.[0][908]=907
+.[0][909]=908
+.[0][910]=909
+.[0][911]=910
+.[0][912]=911
+.[0][913]=912
+.[0][914]=913
+.[0][915]=914
+.[0][916]=915
+.[0][917]=916
+.[0][918]=917
+.[0][919]=918
+.[0][920]=919
+.[0][921]=920
+.[0][922]=921
+.[0][923]=922
+.[0][924]=923
+.[0][925]=924
+.[0][926]=925
+.[0][927]=926
+.[0][928]=927
+.[0][929]=928
+.[0][930]=929
+.[0][931]=930
+.[0][932]=931
+.[0][933]=932
+.[0][934]=933
+.[0][935]=934
+.[0][936]=935
+.[0][937]=936
+.[0][938]=937
+.[0][939]=938
+.[0][940]=939
+.[0][941]=940
+.[0][942]=941
+.[0][943]=942
+.[0][944]=943
+.[0][945]=944
+.[0][946]=945
+.[0][947]=946
+.[0][948]=947
+.[0][949]=948
+.[0][950]=949
+.[0][951]=950
+.[0][952]=951
+.[0][953]=952
+.[0][954]=953
+.[0][955]=954
+.[0][956]=955
+.[0][957]=956
+.[0][958]=957
+.[0][959]=958
+.[0][960]=959
+.[0][961]=960
+.[0][962]=961
+.[0][963]=962
+.[0][964]=963
+.[0][965]=964
+.[0][966]=965
+.[0][967]=966
+.[0][968]=967
+.[0][969]=968
+.[0][970]=969
+.[0][971]=970
+.[0][972]=971
+.[0][973]=972
+.[0][974]=973
+.[0][975]=974
+.[0][976]=975
+.[0][977]=976
+.[0][978]=977
+.[0][979]=978
+.[0][980]=979
+.[0][981]=980
+.[0][982]=981
+.[0][983]=982
+.[0][984]=983
+.[0][985]=984
+.[0][986]=985
+.[0][987]=986
+.[0][988]=987
+.[0][989]=988
+.[0][990]=989
+.[0][991]=990
+.[0][992]=991
+.[0][993]=992
+.[0][994]=993
+.[0][995]=994
+.[0][996]=995
+.[0][997]=996
+.[0][998]=997
+.[0][999]=998
+.[0][1000]=999
+.[0][1001]=1000
+.[0][1002]=1001
+.[0][1003]=1002
+.[0][1004]=1003
+.[0][1005]=1004
+.[0][1006]=1005
+.[0][1007]=1006
+.[0][1008]=1007
+.[0][1009]=1008
+.[0][1010]=1009
+.[0][1011]=1010
+.[0][1012]=1011
+.[0][1013]=1012
+.[0][1014]=1013
+.[0][1015]=1014
+.[0][1016]=1015
+.[0][1017]=1016
+.[0][1018]=1017
+.[0][1019]=1018
+.[0][1020]=1019
+.[0][1021]=1020
+.[0][1022]=1021
+.[0][1023]=1022
+.[0][1024]=1023
+.[0][1025]=1024
+.[0][1026]=1025
+.[0][1027]=1026
+.[0][1028]=1027
+.[0][1029]=1028
+.[0][1030]=1029
+.[0][1031]=1030
+.[0][1032]=1031
+.[0][1033]=1032
+.[0][1034]=1033
+.[0][1035]=1034
+.[0][1036]=1035
+.[0][1037]=1036
+.[0][1038]=1037
+.[0][1039]=1038
+.[0][1040]=1039
+.[0][1041]=1040
+.[0][1042]=1041
+.[0][1043]=1042
+.[0][1044]=1043
+.[0][1045]=1044
+.[0][1046]=1045
+.[0][1047]=1046
+.[0][1048]=1047
+.[0][1049]=1048
+.[0][1050]=1049
+.[0][1051]=1050
+.[0][1052]=1051
+.[0][1053]=1052
+.[0][1054]=1053
+.[0][1055]=1054
+.[0][1056]=1055
+.[0][1057]=1056
+.[0][1058]=1057
+.[0][1059]=1058
+.[0][1060]=1059
+.[0][1061]=1060
+.[0][1062]=1061
+.[0][1063]=1062
+.[0][1064]=1063
+.[0][1065]=1064
+.[0][1066]=1065
+.[0][1067]=1066
+.[0][1068]=1067
+.[0][1069]=1068
+.[0][1070]=1069
+.[0][1071]=1070
+.[0][1072]=1071
+.[0][1073]=1072
+.[0][1074]=1073
+.[0][1075]=1074
+.[0][1076]=1075
+.[0][1077]=1076
+.[0][1078]=1077
+.[0][1079]=1078
+.[0][1080]=1079
+.[0][1081]=1080
+.[0][1082]=1081
+.[0][1083]=1082
+.[0][1084]=1083
+.[0][1085]=1084
+.[0][1086]=1085
+.[0][1087]=1086
+.[0][1088]=1087
+.[0][1089]=1088
+.[0][1090]=1089
+.[0][1091]=1090
+.[0][1092]=1091
+.[0][1093]=1092
+.[0][1094]=1093
+.[0][1095]=1094
+.[0][1096]=1095
+.[0][1097]=1096
+.[0][1098]=1097
+.[0][1099]=1098
+.[0][1100]=1099
+.[0][1101]=1100
+.[0][1102]=1101
+.[0][1103]=1102
+.[0][1104]=1103
+.[0][1105]=1104
+.[0][1106]=1105
+.[0][1107]=1106
+.[0][1108]=1107
+.[0][1109]=1108
+.[0][1110]=1109
+.[0][1111]=1110
+.[0][1112]=1111
+.[0][1113]=1112
+.[0][1114]=1113
+.[0][1115]=1114
+.[0][1116]=1115
+.[0][1117]=1116
+.[0][1118]=1117
+.[0][1119]=1118
+.[0][1120]=1119
+.[0][1121]=1120
+.[0][1122]=1121
+.[0][1123]=1122
+.[0][1124]=1123
+.[0][1125]=1124
+.[0][1126]=1125
+.[0][1127]=1126
+.[0][1128]=1127
+.[0][1129]=1128
+.[0][1130]=1129
+.[0][1131]=1130
+.[0][1132]=1131
+.[0][1133]=1132
+.[0][1134]=1133
+.[0][1135]=1134
+.[0][1136]=1135
+.[0][1137]=1136
+.[0][1138]=1137
+.[0][1139]=1138
+.[0][1140]=1139
+.[0][1141]=1140
+.[0][1142]=1141
+.[0][1143]=1142
+.[0][1144]=1143
+.[0][1145]=1144
+.[0][1146]=1145
+.[0][1147]=1146
+.[0][1148]=1147
+.[0][1149]=1148
+.[0][1150]=1149
+.[0][1151]=1150
+.[0][1152]=1151
+.[0][1153]=1152
+.[0][1154]=1153
+.[0][1155]=1154
+.[0][1156]=1155
+.[0][1157]=1156
+.[0][1158]=1157
+.[0][1159]=1158
+.[0][1160]=1159
+.[0][1161]=1160
+.[0][1162]=1161
+.[0][1163]=1162
+.[0][1164]=1163
+.[0][1165]=1164
+.[0][1166]=1165
+.[0][1167]=1166
+.[0][1168]=1167
+.[0][1169]=1168
+.[0][1170]=1169
+.[0][1171]=1170
+.[0][1172]=1171
+.[0][1173]=1172
+.[0][1174]=1173
+.[0][1175]=1174
+.[0][1176]=1175
+.[0][1177]=1176
+.[0][1178]=1177
+.[0][1179]=1178
+.[0][1180]=1179
+.[0][1181]=1180
+.[0][1182]=1181
+.[0][1183]=1182
+.[0][1184]=1183
+.[0][1185]=1184
+.[0][1186]=1185
+.[0][1187]=1186
+.[0][1188]=1187
+.[0][1189]=1188
+.[0][1190]=1189
+.[0][1191]=1190
+.[0][1192]=1191
+.[0][1193]=1192
+.[0][1194]=1193
+.[0][1195]=1194
+.[0][1196]=1195
+.[0][1197]=1196
+.[0][1198]=1197
+.[0][1199]=1198
+.[0][1200]=1199
+.[0][1201]=1200
+.[0][1202]=1201
+.[0][1203]=1202
+.[0][1204]=1203
+.[0][1205]=1204
+.[0][1206]=1205
+.[0][1207]=1206
+.[0][1208]=1207
+.[0][1209]=1208
+.[0][1210]=1209
+.[0][1211]=1210
+.[0][1212]=1211
+.[0][1213]=1212
+.[0][1214]=1213
+.[0][1215]=1214
+.[0][1216]=1215
+.[0][1217]=1216
+.[0][1218]=1217
+.[0][1219]=1218
+.[0][1220]=1219
+.[0][1221]=1220
+.[0][1222]=1221
+.[0][1223]=1222
+.[0][1224]=1223
+.[0][1225]=1224
+.[0][1226]=1225
+.[0][1227]=1226
+.[0][1228]=1227
+.[0][1229]=1228
+.[0][1230]=1229
+.[0][1231]=1230
+.[0][1232]=1231
+.[0][1233]=1232
+.[0][1234]=1233
+.[0][1235]=1234
+.[0][1236]=1235
+.[0][1237]=1236
+.[0][1238]=1237
+.[0][1239]=1238
+.[0][1240]=1239
+.[0][1241]=1240
+.[0][1242]=1241
+.[0][1243]=1242
+.[0][1244]=1243
+.[0][1245]=1244
+.[0][1246]=1245
+.[0][1247]=1246
+.[0][1248]=1247
+.[0][1249]=1248
+.[0][1250]=1249
+.[0][1251]=1250
+.[0][1252]=1251
+.[0][1253]=1252
+.[0][1254]=1253
+.[0][1255]=1254
+.[0][1256]=1255
+.[0][1257]=1256
+.[0][1258]=1257
+.[0][1259]=1258
+.[0][1260]=1259
+.[0][1261]=1260
+.[0][1262]=1261
+.[0][1263]=1262
+.[0][1264]=1263
+.[0][1265]=1264
+.[0][1266]=1265
+.[0][1267]=1266
+.[0][1268]=1267
+.[0][1269]=1268
+.[0][1270]=1269
+.[0][1271]=1270
+.[0][1272]=1271
+.[0][1273]=1272
+.[0][1274]=1273
+.[0][1275]=1274
+.[0][1276]=1275
+.[0][1277]=1276
+.[0][1278]=1277
+.[0][1279]=1278
+.[0][1280]=1279
+.[0][1281]=1280
+.[0][1282]=1281
+.[0][1283]=1282
+.[0][1284]=1283
+.[0][1285]=1284
+.[0][1286]=1285
+.[0][1287]=1286
+.[0][1288]=1287
+.[0][1289]=1288
+.[0][1290]=1289
+.[0][1291]=1290
+.[0][1292]=1291
+.[0][1293]=1292
+.[0][1294]=1293
+.[0][1295]=1294
+.[0][1296]=1295
+.[0][1297]=1296
+.[0][1298]=1297
+.[0][1299]=1298
+.[0][1300]=1299
+.[0][1301]=1300
+.[0][1302]=1301
+.[0][1303]=1302
+.[0][1304]=1303
+.[0][1305]=1304
+.[0][1306]=1305
+.[0][1307]=1306
+.[0][1308]=1307
+.[0][1309]=1308
+.[0][1310]=1309
+.[0][1311]=1310
+.[0][1312]=1311
+.[0][1313]=1312
+.[0][1314]=1313
+.[0][1315]=1314
+.[0][1316]=1315
+.[0][1317]=1316
+.[0][1318]=1317
+.[0][1319]=1318
+.[0][1320]=1319
+.[0][1321]=1320
+.[0][1322]=1321
+.[0][1323]=1322
+.[0][1324]=1323
+.[0][1325]=1324
+.[0][1326]=1325
+.[0][1327]=1326
+.[0][1328]=1327
+.[0][1329]=1328
+.[0][1330]=1329
+.[0][1331]=1330
+.[0][1332]=1331
+.[0][1333]=1332
+.[0][1334]=1333
+.[0][1335]=1334
+.[0][1336]=1335
+.[0][1337]=1336
+.[0][1338]=1337
+.[0][1339]=1338
+.[0][1340]=1339
+.[0][1341]=1340
+.[0][1342]=1341
+.[0][1343]=1342
+.[0][1344]=1343
+.[0][1345]=1344
+.[0][1346]=1345
+.[0][1347]=1346
+.[0][1348]=1347
+.[0][1349]=1348
+.[0][1350]=1349
+.[0][1351]=1350
+.[0][1352]=1351
+.[0][1353]=1352
+.[0][1354]=1353
+.[0][1355]=1354
+.[0][1356]=1355
+.[0][1357]=1356
+.[0][1358]=1357
+.[0][1359]=1358
+.[0][1360]=1359
+.[0][1361]=1360
+.[0][1362]=1361
+.[0][1363]=1362
+.[0][1364]=1363
+.[0][1365]=1364
+.[0][1366]=1365
+.[0][1367]=1366
+.[0][1368]=1367
+.[0][1369]=1368
+.[0][1370]=1369
+.[0][1371]=1370
+.[0][1372]=1371
+.[0][1373]=1372
+.[0][1374]=1373
+.[0][1375]=1374
+.[0][1376]=1375
+.[0][1377]=1376
+.[0][1378]=1377
+.[0][1379]=1378
+.[0][1380]=1379
+.[0][1381]=1380
+.[0][1382]=1381
+.[0][1383]=1382
+.[0][1384]=1383
+.[0][1385]=1384
+.[0][1386]=1385
+.[0][1387]=1386
+.[0][1388]=1387
+.[0][1389]=1388
+.[0][1390]=1389
+.[0][1391]=1390
+.[0][1392]=1391
+.[0][1393]=1392
+.[0][1394]=1393
+.[0][1395]=1394
+.[0][1396]=1395
+.[0][1397]=1396
+.[0][1398]=1397
+.[0][1399]=1398
+.[0][1400]=1399
+.[0][1401]=1400
+.[0][1402]=1401
+.[0][1403]=1402
+.[0][1404]=1403
+.[0][1405]=1404
+.[0][1406]=1405
+.[0][1407]=1406
+.[0][1408]=1407
+.[0][1409]=1408
+.[0][1410]=1409
+.[0][1411]=1410
+.[0][1412]=1411
+.[0][1413]=1412
+.[0][1414]=1413
+.[0][1415]=1414
+.[0][1416]=1415
+.[0][1417]=1416
+.[0][1418]=1417
+.[0][1419]=1418
+.[0][1420]=1419
+.[0][1421]=1420
+.[0][1422]=1421
+.[0][1423]=1422
+.[0][1424]=1423
+.[0][1425]=1424
+.[0][1426]=1425
+.[0][1427]=1426
+.[0][1428]=1427
+.[0][1429]=1428
+.[0][1430]=1429
+.[0][1431]=1430
+.[0][1432]=1431
+.[0][1433]=1432
+.[0][1434]=1433
+.[0][1435]=1434
+.[0][1436]=1435
+.[0][1437]=1436
+.[0][1438]=1437
+.[0][1439]=1438
+.[0][1440]=1439
+.[0][1441]=1440
+.[0][1442]=1441
+.[0][1443]=1442
+.[0][1444]=1443
+.[0][1445]=1444
+.[0][1446]=1445
+.[0][1447]=1446
+.[0][1448]=1447
+.[0][1449]=1448
+.[0][1450]=1449
+.[0][1451]=1450
+.[0][1452]=1451
+.[0][1453]=1452
+.[0][1454]=1453
+.[0][1455]=1454
+.[0][1456]=1455
+.[0][1457]=1456
+.[0][1458]=1457
+.[0][1459]=1458
+.[0][1460]=1459
+.[0][1461]=1460
+.[0][1462]=1461
+.[0][1463]=1462
+.[0][1464]=1463
+.[0][1465]=1464
+.[0][1466]=1465
+.[0][1467]=1466
+.[0][1468]=1467
+.[0][1469]=1468
+.[0][1470]=1469
+.[0][1471]=1470
+.[0][1472]=1471
+.[0][1473]=1472
+.[0][1474]=1473
+.[0][1475]=1474
+.[0][1476]=1475
+.[0][1477]=1476
+.[0][1478]=1477
+.[0][1479]=1478
+.[0][1480]=1479
+.[0][1481]=1480
+.[0][1482]=1481
+.[0][1483]=1482
+.[0][1484]=1483
+.[0][1485]=1484
+.[0][1486]=1485
+.[0][1487]=1486
+.[0][1488]=1487
+.[0][1489]=1488
+.[0][1490]=1489
+.[0][1491]=1490
+.[0][1492]=1491
+.[0][1493]=1492
+.[0][1494]=1493
+.[0][1495]=1494
+.[0][1496]=1495
+.[0][1497]=1496
+.[0][1498]=1497
+.[0][1499]=1498
+.[0][1500]=1499
+.[0][1501]=1500
+.[0][1502]=1501
+.[0][1503]=1502
+.[0][1504]=1503
+.[0][1505]=1504
+.[0][1506]=1505
+.[0][1507]=1506
+.[0][1508]=1507
+.[0][1509]=1508
+.[0][1510]=1509
+.[0][1511]=1510
+.[0][1512]=1511
+.[0][1513]=1512
+.[0][1514]=1513
+.[0][1515]=1514
+.[0][1516]=1515
+.[0][1517]=1516
+.[0][1518]=1517
+.[0][1519]=1518
+.[0][1520]=1519
+.[0][1521]=1520
+.[0][1522]=1521
+.[0][1523]=1522
+.[0][1524]=1523
+.[0][1525]=1524
+.[0][1526]=1525
+.[0][1527]=1526
+.[0][1528]=1527
+.[0][1529]=1528
+.[0][1530]=1529
+.[0][1531]=1530
+.[0][1532]=1531
+.[0][1533]=1532
+.[0][1534]=1533
+.[0][1535]=1534
+.[0][1536]=1535
+.[0][1537]=1536
+.[0][1538]=1537
+.[0][1539]=1538
+.[0][1540]=1539
+.[0][1541]=1540
+.[0][1542]=1541
+.[0][1543]=1542
+.[0][1544]=1543
+.[0][1545]=1544
+.[0][1546]=1545
+.[0][1547]=1546
+.[0][1548]=1547
+.[0][1549]=1548
+.[0][1550]=1549
+.[0][1551]=1550
+.[0][1552]=1551
+.[0][1553]=1552
+.[0][1554]=1553
+.[0][1555]=1554
+.[0][1556]=1555
+.[0][1557]=1556
+.[0][1558]=1557
+.[0][1559]=1558
+.[0][1560]=1559
+.[0][1561]=1560
+.[0][1562]=1561
+.[0][1563]=1562
+.[0][1564]=1563
+.[0][1565]=1564
+.[0][1566]=1565
+.[0][1567]=1566
+.[0][1568]=1567
+.[0][1569]=1568
+.[0][1570]=1569
+.[0][1571]=1570
+.[0][1572]=1571
+.[0][1573]=1572
+.[0][1574]=1573
+.[0][1575]=1574
+.[0][1576]=1575
+.[0][1577]=1576
+.[0][1578]=1577
+.[0][1579]=1578
+.[0][1580]=1579
+.[0][1581]=1580
+.[0][1582]=1581
+.[0][1583]=1582
+.[0][1584]=1583
+.[0][1585]=1584
+.[0][1586]=1585
+.[0][1587]=1586
+.[0][1588]=1587
+.[0][1589]=1588
+.[0][1590]=1589
+.[0][1591]=1590
+.[0][1592]=1591
+.[0][1593]=1592
+.[0][1594]=1593
+.[0][1595]=1594
+.[0][1596]=1595
+.[0][1597]=1596
+.[0][1598]=1597
+.[0][1599]=1598
+.[0][1600]=1599
+.[0][1601]=1600
+.[0][1602]=1601
+.[0][1603]=1602
+.[0][1604]=1603
+.[0][1605]=1604
+.[0][1606]=1605
+.[0][1607]=1606
+.[0][1608]=1607
+.[0][1609]=1608
+.[0][1610]=1609
+.[0][1611]=1610
+.[0][1612]=1611
+.[0][1613]=1612
+.[0][1614]=1613
+.[0][1615]=1614
+.[0][1616]=1615
+.[0][1617]=1616
+.[0][1618]=1617
+.[0][1619]=1618
+.[0][1620]=1619
+.[0][1621]=1620
+.[0][1622]=1621
+.[0][1623]=1622
+.[0][1624]=1623
+.[0][1625]=1624
+.[0][1626]=1625
+.[0][1627]=1626
+.[0][1628]=1627
+.[0][1629]=1628
+.[0][1630]=1629
+.[0][1631]=1630
+.[0][1632]=1631
+.[0][1633]=1632
+.[0][1634]=1633
+.[0][1635]=1634
+.[0][1636]=1635
+.[0][1637]=1636
+.[0][1638]=1637
+.[0][1639]=1638
+.[0][1640]=1639
+.[0][1641]=1640
+.[0][1642]=1641
+.[0][1643]=1642
+.[0][1644]=1643
+.[0][1645]=1644
+.[0][1646]=1645
+.[0][1647]=1646
+.[0][1648]=1647
+.[0][1649]=1648
+.[0][1650]=1649
+.[0][1651]=1650
+.[0][1652]=1651
+.[0][1653]=1652
+.[0][1654]=1653
+.[0][1655]=1654
+.[0][1656]=1655
+.[0][1657]=1656
+.[0][1658]=1657
+.[0][1659]=1658
+.[0][1660]=1659
+.[0][1661]=1660
+.[0][1662]=1661
+.[0][1663]=1662
+.[0][1664]=1663
+.[0][1665]=1664
+.[0][1666]=1665
+.[0][1667]=1666
+.[0][1668]=1667
+.[0][1669]=1668
+.[0][1670]=1669
+.[0][1671]=1670
+.[0][1672]=1671
+.[0][1673]=1672
+.[0][1674]=1673
+.[0][1675]=1674
+.[0][1676]=1675
+.[0][1677]=1676
+.[0][1678]=1677
+.[0][1679]=1678
+.[0][1680]=1679
+.[0][1681]=1680
+.[0][1682]=1681
+.[0][1683]=1682
+.[0][1684]=1683
+.[0][1685]=1684
+.[0][1686]=1685
+.[0][1687]=1686
+.[0][1688]=1687
+.[0][1689]=1688
+.[0][1690]=1689
+.[0][1691]=1690
+.[0][1692]=1691
+.[0][1693]=1692
+.[0][1694]=1693
+.[0][1695]=1694
+.[0][1696]=1695
+.[0][1697]=1696
+.[0][1698]=1697
+.[0][1699]=1698
+.[0][1700]=1699
+.[0][1701]=1700
+.[0][1702]=1701
+.[0][1703]=1702
+.[0][1704]=1703
+.[0][1705]=1704
+.[0][1706]=1705
+.[0][1707]=1706
+.[0][1708]=1707
+.[0][1709]=1708
+.[0][1710]=1709
+.[0][1711]=1710
+.[0][1712]=1711
+.[0][1713]=1712
+.[0][1714]=1713
+.[0][1715]=1714
+.[0][1716]=1715
+.[0][1717]=1716
+.[0][1718]=1717
+.[0][1719]=1718
+.[0][1720]=1719
+.[0][1721]=1720
+.[0][1722]=1721
+.[0][1723]=1722
+.[0][1724]=1723
+.[0][1725]=1724
+.[0][1726]=1725
+.[0][1727]=1726
+.[0][1728]=1727
+.[0][1729]=1728
+.[0][1730]=1729
+.[0][1731]=1730
+.[0][1732]=1731
+.[0][1733]=1732
+.[0][1734]=1733
+.[0][1735]=1734
+.[0][1736]=1735
+.[0][1737]=1736
+.[0][1738]=1737
+.[0][1739]=1738
+.[0][1740]=1739
+.[0][1741]=1740
+.[0][1742]=1741
+.[0][1743]=1742
+.[0][1744]=1743
+.[0][1745]=1744
+.[0][1746]=1745
+.[0][1747]=1746
+.[0][1748]=1747
+.[0][1749]=1748
+.[0][1750]=1749
+.[0][1751]=1750
+.[0][1752]=1751
+.[0][1753]=1752
+.[0][1754]=1753
+.[0][1755]=1754
+.[0][1756]=1755
+.[0][1757]=1756
+.[0][1758]=1757
+.[0][1759]=1758
+.[0][1760]=1759
+.[0][1761]=1760
+.[0][1762]=1761
+.[0][1763]=1762
+.[0][1764]=1763
+.[0][1765]=1764
+.[0][1766]=1765
+.[0][1767]=1766
+.[0][1768]=1767
+.[0][1769]=1768
+.[0][1770]=1769
+.[0][1771]=1770
+.[0][1772]=1771
+.[0][1773]=1772
+.[0][1774]=1773
+.[0][1775]=1774
+.[0][1776]=1775
+.[0][1777]=1776
+.[0][1778]=1777
+.[0][1779]=1778
+.[0][1780]=1779
+.[0][1781]=1780
+.[0][1782]=1781
+.[0][1783]=1782
+.[0][1784]=1783
+.[0][1785]=1784
+.[0][1786]=1785
+.[0][1787]=1786
+.[0][1788]=1787
+.[0][1789]=1788
+.[0][1790]=1789
+.[0][1791]=1790
+.[0][1792]=1791
+.[0][1793]=1792
+.[0][1794]=1793
+.[0][1795]=1794
+.[0][1796]=1795
+.[0][1797]=1796
+.[0][1798]=1797
+.[0][1799]=1798
+.[0][1800]=1799
+.[0][1801]=1800
+.[0][1802]=1801
+.[0][1803]=1802
+.[0][1804]=1803
+.[0][1805]=1804
+.[0][1806]=1805
+.[0][1807]=1806
+.[0][1808]=1807
+.[0][1809]=1808
+.[0][1810]=1809
+.[0][1811]=1810
+.[0][1812]=1811
+.[0][1813]=1812
+.[0][1814]=1813
+.[0][1815]=1814
+.[0][1816]=1815
+.[0][1817]=1816
+.[0][1818]=1817
+.[0][1819]=1818
+.[0][1820]=1819
+.[0][1821]=1820
+.[0][1822]=1821
+.[0][1823]=1822
+.[0][1824]=1823
+.[0][1825]=1824
+.[0][1826]=1825
+.[0][1827]=1826
+.[0][1828]=1827
+.[0][1829]=1828
+.[0][1830]=1829
+.[0][1831]=1830
+.[0][1832]=1831
+.[0][1833]=1832
+.[0][1834]=1833
+.[0][1835]=1834
+.[0][1836]=1835
+.[0][1837]=1836
+.[0][1838]=1837
+.[0][1839]=1838
+.[0][1840]=1839
+.[0][1841]=1840
+.[0][1842]=1841
+.[0][1843]=1842
+.[0][1844]=1843
+.[0][1845]=1844
+.[0][1846]=1845
+.[0][1847]=1846
+.[0][1848]=1847
+.[0][1849]=1848
+.[0][1850]=1849
+.[0][1851]=1850
+.[0][1852]=1851
+.[0][1853]=1852
+.[0][1854]=1853
+.[0][1855]=1854
+.[0][1856]=1855
+.[0][1857]=1856
+.[0][1858]=1857
+.[0][1859]=1858
+.[0][1860]=1859
+.[0][1861]=1860
+.[0][1862]=1861
+.[0][1863]=1862
+.[0][1864]=1863
+.[0][1865]=1864
+.[0][1866]=1865
+.[0][1867]=1866
+.[0][1868]=1867
+.[0][1869]=1868
+.[0][1870]=1869
+.[0][1871]=1870
+.[0][1872]=1871
+.[0][1873]=1872
+.[0][1874]=1873
+.[0][1875]=1874
+.[0][1876]=1875
+.[0][1877]=1876
+.[0][1878]=1877
+.[0][1879]=1878
+.[0][1880]=1879
+.[0][1881]=1880
+.[0][1882]=1881
+.[0][1883]=1882
+.[0][1884]=1883
+.[0][1885]=1884
+.[0][1886]=1885
+.[0][1887]=1886
+.[0][1888]=1887
+.[0][1889]=1888
+.[0][1890]=1889
+.[0][1891]=1890
+.[0][1892]=1891
+.[0][1893]=1892
+.[0][1894]=1893
+.[0][1895]=1894
+.[0][1896]=1895
+.[0][1897]=1896
+.[0][1898]=1897
+.[0][1899]=1898
+.[0][1900]=1899
+.[0][1901]=1900
+.[0][1902]=1901
+.[0][1903]=1902
+.[0][1904]=1903
+.[0][1905]=1904
+.[0][1906]=1905
+.[0][1907]=1906
+.[0][1908]=1907
+.[0][1909]=1908
+.[0][1910]=1909
+.[0][1911]=1910
+.[0][1912]=1911
+.[0][1913]=1912
+.[0][1914]=1913
+.[0][1915]=1914
+.[0][1916]=1915
+.[0][1917]=1916
+.[0][1918]=1917
+.[0][1919]=1918
+.[0][1920]=1919
+.[0][1921]=1920
+.[0][1922]=1921
+.[0][1923]=1922
+.[0][1924]=1923
+.[0][1925]=1924
+.[0][1926]=1925
+.[0][1927]=1926
+.[0][1928]=1927
+.[0][1929]=1928
+.[0][1930]=1929
+.[0][1931]=1930
+.[0][1932]=1931
+.[0][1933]=1932
+.[0][1934]=1933
+.[0][1935]=1934
+.[0][1936]=1935
+.[0][1937]=1936
+.[0][1938]=1937
+.[0][1939]=1938
+.[0][1940]=1939
+.[0][1941]=1940
+.[0][1942]=1941
+.[0][1943]=1942
+.[0][1944]=1943
+.[0][1945]=1944
+.[0][1946]=1945
+.[0][1947]=1946
+.[0][1948]=1947
+.[0][1949]=1948
+.[0][1950]=1949
+.[0][1951]=1950
+.[0][1952]=1951
+.[0][1953]=1952
+.[0][1954]=1953
+.[0][1955]=1954
+.[0][1956]=1955
+.[0][1957]=1956
+.[0][1958]=1957
+.[0][1959]=1958
+.[0][1960]=1959
+.[0][1961]=1960
+.[0][1962]=1961
+.[0][1963]=1962
+.[0][1964]=1963
+.[0][1965]=1964
+.[0][1966]=1965
+.[0][1967]=1966
+.[0][1968]=1967
+.[0][1969]=1968
+.[0][1970]=1969
+.[0][1971]=1970
+.[0][1972]=1971
+.[0][1973]=1972
+.[0][1974]=1973
+.[0][1975]=1974
+.[0][1976]=1975
+.[0][1977]=1976
+.[0][1978]=1977
+.[0][1979]=1978
+.[0][1980]=1979
+.[0][1981]=1980
+.[0][1982]=1981
+.[0][1983]=1982
+.[0][1984]=1983
+.[0][1985]=1984
+.[0][1986]=1985
+.[0][1987]=1986
+.[0][1988]=1987
+.[0][1989]=1988
+.[0][1990]=1989
+.[0][1991]=1990
+.[0][1992]=1991
+.[0][1993]=1992
+.[0][1994]=1993
+.[0][1995]=1994
+.[0][1996]=1995
+.[0][1997]=1996
+.[0][1998]=1997
+.[0][1999]=1998
+.[0][2000]=1999
+.[0][2001]=2000
+.[0][2002]=2001
+.[0][2003]=2002
+.[0][2004]=2003
+.[0][2005]=2004
+.[0][2006]=2005
+.[0][2007]=2006
+.[0][2008]=2007
+.[0][2009]=2008
+.[0][2010]=2009
+.[0][2011]=2010
+.[0][2012]=2011
+.[0][2013]=2012
+.[0][2014]=2013
+.[0][2015]=2014
+.[0][2016]=2015
+.[0][2017]=2016
+.[0][2018]=2017
+.[0][2019]=2018
+.[0][2020]=2019
+.[0][2021]=2020
+.[0][2022]=2021
+.[0][2023]=2022
+.[0][2024]=2023
+.[0][2025]=2024
+.[0][2026]=2025
+.[0][2027]=2026
+.[0][2028]=2027
+.[0][2029]=2028
+.[0][2030]=2029
+.[0][2031]=2030
+.[0][2032]=2031
+.[0][2033]=2032
+.[0][2034]=2033
+.[0][2035]=2034
+.[0][2036]=2035
+.[0][2037]=2036
+.[0][2038]=2037
+.[0][2039]=2038
+.[0][2040]=2039
+.[0][2041]=2040
+.[0][2042]=2041
+.[0][2043]=2042
+.[0][2044]=2043
+.[0][2045]=2044
+.[0][2046]=2045
+.[0][2047]=2046
+.[0][2048]=2047
+.[0][2049]=2048
+.[0][2050]=2049
+.[0][2051]=2050
+.[0][2052]=2051
+.[0][2053]=2052
+.[0][2054]=2053
+.[0][2055]=2054
+.[0][2056]=2055
+.[0][2057]=2056
+.[0][2058]=2057
+.[0][2059]=2058
+.[0][2060]=2059
+.[0][2061]=2060
+.[0][2062]=2061
+.[0][2063]=2062
+.[0][2064]=2063
+.[0][2065]=2064
+.[0][2066]=2065
+.[0][2067]=2066
+.[0][2068]=2067
+.[0][2069]=2068
+.[0][2070]=2069
+.[0][2071]=2070
+.[0][2072]=2071
+.[0][2073]=2072
+.[0][2074]=2073
+.[0][2075]=2074
+.[0][2076]=2075
+.[0][2077]=2076
+.[0][2078]=2077
+.[0][2079]=2078
+.[0][2080]=2079
+.[0][2081]=2080
+.[0][2082]=2081
+.[0][2083]=2082
+.[0][2084]=2083
+.[0][2085]=2084
+.[0][2086]=2085
+.[0][2087]=2086
+.[0][2088]=2087
+.[0][2089]=2088
+.[0][2090]=2089
+.[0][2091]=2090
+.[0][2092]=2091
+.[0][2093]=2092
+.[0][2094]=2093
+.[0][2095]=2094
+.[0][2096]=2095
+.[0][2097]=2096
+.[0][2098]=2097
+.[0][2099]=2098
+.[0][2100]=2099
+.[0][2101]=2100
+.[0][2102]=2101
+.[0][2103]=2102
+.[0][2104]=2103
+.[0][2105]=2104
+.[0][2106]=2105
+.[0][2107]=2106
+.[0][2108]=2107
+.[0][2109]=2108
+.[0][2110]=2109
+.[0][2111]=2110
+.[0][2112]=2111
+.[0][2113]=2112
+.[0][2114]=2113
+.[0][2115]=2114
+.[0][2116]=2115
+.[0][2117]=2116
+.[0][2118]=2117
+.[0][2119]=2118
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_array_07.json b/3rdparty/jsoncpp/src/test/data/legacy_test_array_07.json
new file mode 100644
index 00000000..e4ab4cd4
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_array_07.json
@@ -0,0 +1,2 @@
+[["A",0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,261,262,263,264,265,266,267,268,269,270,271,272,273,274,275,276,277,278,279,280,281,282,283,284,285,286,287,288,289,290,291,292,293,294,295,296,297,298,299,300,301,302,303,304,305,306,307,308,309,310,311,312,313,314,315,316,317,318,319,320,321,322,323,324,325,326,327,328,329,330,331,332,333,334,335,336,337,338,339,340,341,342,343,344,345,346,347,348,349,350,351,352,353,354,355,356,357,358,359,360,361,362,363,364,365,366,367,368,369,370,371,372,373,374,375,376,377,378,379,380,381,382,383,384,385,386,387,388,389,390,391,392,393,394,395,396,397,398,399,400,401,402,403,404,405,406,407,408,409,410,411,412,413,414,415,416,417,418,419,420,421,422,423,424,425,426,427,428,429,430,431,432,433,434,435,436,437,438,439,440,441,442,443,444,445,446,447,448,449,450,451,452,453,454,455,456,457,458,459,460,461,462,463,464,465,466,467,468,469,470,471,472,473,474,475,476,477,478,479,480,481,482,483,484,485,486,487,488,489,490,491,492,493,494,495,496,497,498,499,500,501,502,503,504,505,506,507,508,509,510,511,512,513,514,515,516,517,518,519,520,521,522,523,524,525,526,527,528,529,530,531,532,533,534,535,536,537,538,539,540,541,542,543,544,545,546,547,548,549,550,551,552,553,554,555,556,557,558,559,560,561,562,563,564,565,566,567,568,569,570,571,572,573,574,575,576,577,578,579,580,581,582,583,584,585,586,587,588,589,590,591,592,593,594,595,596,597,598,599,600,601,602,603,604,605,606,607,608,609,610,611,612,613,614,615,616,617,618,619,620,621,622,623,624,625,626,627,628,629,630,631,632,633,634,635,636,637,638,639,640,641,642,643,644,645,646,647,648,649,650,651,652,653,654,655,656,657,658,659,660,661,662,663,664,665,666,667,668,669,670,671,672,673,674,675,676,677,678,679,680,681,682,683,684,685,686,687,688,689,690,691,692,693,694,695,696,697,698,699,700,701,702,703,704,705,706,707,708,709,710,711,712,713,714,715,716,717,718,719,720,721,722,723,724,725,726,727,728,729,730,731,732,733,734,735,736,737,738,739,740,741,742,743,744,745,746,747,748,749,750,751,752,753,754,755,756,757,758,759,760,761,762,763,764,765,766,767,768,769,770,771,772,773,774,775,776,777,778,779,780,781,782,783,784,785,786,787,788,789,790,791,792,793,794,795,796,797,798,799,800,801,802,803,804,805,806,807,808,809,810,811,812,813,814,815,816,817,818,819,820,821,822,823,824,825,826,827,828,829,830,831,832,833,834,835,836,837,838,839,840,841,842,843,844,845,846,847,848,849,850,851,852,853,854,855,856,857,858,859,860,861,862,863,864,865,866,867,868,869,870,871,872,873,874,875,876,877,878,879,880,881,882,883,884,885,886,887,888,889,890,891,892,893,894,895,896,897,898,899,900,901,902,903,904,905,906,907,908,909,910,911,912,913,914,915,916,917,918,919,920,921,922,923,924,925,926,927,928,929,930,931,932,933,934,935,936,937,938,939,940,941,942,943,944,945,946,947,948,949,950,951,952,953,954,955,956,957,958,959,960,961,962,963,964,965,966,967,968,969,970,971,972,973,974,975,976,977,978,979,980,981,982,983,984,985,986,987,988,989,990,991,992,993,994,995,996,997,998,999,1000,1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1011,1012,1013,1014,1015,1016,1017,1018,1019,1020,1021,1022,1023,1024,1025,1026,1027,1028,1029,1030,1031,1032,1033,1034,1035,1036,1037,1038,1039,1040,1041,1042,1043,1044,1045,1046,1047,1048,1049,1050,1051,1052,1053,1054,1055,1056,1057,1058,1059,1060,1061,1062,1063,1064,1065,1066,1067,1068,1069,1070,1071,1072,1073,1074,1075,1076,1077,1078,1079,1080,1081,1082,1083,1084,1085,1086,1087,1088,1089,1090,1091,1092,1093,1094,1095,1096,1097,1098,1099,1100,1101,1102,1103,1104,1105,1106,1107,1108,1109,1110,1111,1112,1113,1114,1115,1116,1117,1118,1119,1120,1121,1122,1123,1124,1125,1126,1127,1128,1129,1130,1131,1132,1133,1134,1135,1136,1137,1138,1139,1140,1141,1142,1143,1144,1145,1146,1147,1148,1149,1150,1151,1152,1153,1154,1155,1156,1157,1158,1159,1160,1161,1162,1163,1164,1165,1166,1167,1168,1169,1170,1171,1172,1173,1174,1175,1176,1177,1178,1179,1180,1181,1182,1183,1184,1185,1186,1187,1188,1189,1190,1191,1192,1193,1194,1195,1196,1197,1198,1199,1200,1201,1202,1203,1204,1205,1206,1207,1208,1209,1210,1211,1212,1213,1214,1215,1216,1217,1218,1219,1220,1221,1222,1223,1224,1225,1226,1227,1228,1229,1230,1231,1232,1233,1234,1235,1236,1237,1238,1239,1240,1241,1242,1243,1244,1245,1246,1247,1248,1249,1250,1251,1252,1253,1254,1255,1256,1257,1258,1259,1260,1261,1262,1263,1264,1265,1266,1267,1268,1269,1270,1271,1272,1273,1274,1275,1276,1277,1278,1279,1280,1281,1282,1283,1284,1285,1286,1287,1288,1289,1290,1291,1292,1293,1294,1295,1296,1297,1298,1299,1300,1301,1302,1303,1304,1305,1306,1307,1308,1309,1310,1311,1312,1313,1314,1315,1316,1317,1318,1319,1320,1321,1322,1323,1324,1325,1326,1327,1328,1329,1330,1331,1332,1333,1334,1335,1336,1337,1338,1339,1340,1341,1342,1343,1344,1345,1346,1347,1348,1349,1350,1351,1352,1353,1354,1355,1356,1357,1358,1359,1360,1361,1362,1363,1364,1365,1366,1367,1368,1369,1370,1371,1372,1373,1374,1375,1376,1377,1378,1379,1380,1381,1382,1383,1384,1385,1386,1387,1388,1389,1390,1391,1392,1393,1394,1395,1396,1397,1398,1399,1400,1401,1402,1403,1404,1405,1406,1407,1408,1409,1410,1411,1412,1413,1414,1415,1416,1417,1418,1419,1420,1421,1422,1423,1424,1425,1426,1427,1428,1429,1430,1431,1432,1433,1434,1435,1436,1437,1438,1439,1440,1441,1442,1443,1444,1445,1446,1447,1448,1449,1450,1451,1452,1453,1454,1455,1456,1457,1458,1459,1460,1461,1462,1463,1464,1465,1466,1467,1468,1469,1470,1471,1472,1473,1474,1475,1476,1477,1478,1479,1480,1481,1482,1483,1484,1485,1486,1487,1488,1489,1490,1491,1492,1493,1494,1495,1496,1497,1498,1499,1500,1501,1502,1503,1504,1505,1506,1507,1508,1509,1510,1511,1512,1513,1514,1515,1516,1517,1518,1519,1520,1521,1522,1523,1524,1525,1526,1527,1528,1529,1530,1531,1532,1533,1534,1535,1536,1537,1538,1539,1540,1541,1542,1543,1544,1545,1546,1547,1548,1549,1550,1551,1552,1553,1554,1555,1556,1557,1558,1559,1560,1561,1562,1563,1564,1565,1566,1567,1568,1569,1570,1571,1572,1573,1574,1575,1576,1577,1578,1579,1580,1581,1582,1583,1584,1585,1586,1587,1588,1589,1590,1591,1592,1593,1594,1595,1596,1597,1598,1599,1600,1601,1602,1603,1604,1605,1606,1607,1608,1609,1610,1611,1612,1613,1614,1615,1616,1617,1618,1619,1620,1621,1622,1623,1624,1625,1626,1627,1628,1629,1630,1631,1632,1633,1634,1635,1636,1637,1638,1639,1640,1641,1642,1643,1644,1645,1646,1647,1648,1649,1650,1651,1652,1653,1654,1655,1656,1657,1658,1659,1660,1661,1662,1663,1664,1665,1666,1667,1668,1669,1670,1671,1672,1673,1674,1675,1676,1677,1678,1679,1680,1681,1682,1683,1684,1685,1686,1687,1688,1689,1690,1691,1692,1693,1694,1695,1696,1697,1698,1699,1700,1701,1702,1703,1704,1705,1706,1707,1708,1709,1710,1711,1712,1713,1714,1715,1716,1717,1718,1719,1720,1721,1722,1723,1724,1725,1726,1727,1728,1729,1730,1731,1732,1733,1734,1735,1736,1737,1738,1739,1740,1741,1742,1743,1744,1745,1746,1747,1748,1749,1750,1751,1752,1753,1754,1755,1756,1757,1758,1759,1760,1761,1762,1763,1764,1765,1766,1767,1768,1769,1770,1771,1772,1773,1774,1775,1776,1777,1778,1779,1780,1781,1782,1783,1784,1785,1786,1787,1788,1789,1790,1791,1792,1793,1794,1795,1796,1797,1798,1799,1800,1801,1802,1803,1804,1805,1806,1807,1808,1809,1810,1811,1812,1813,1814,1815,1816,1817,1818,1819,1820,1821,1822,1823,1824,1825,1826,1827,1828,1829,1830,1831,1832,1833,1834,1835,1836,1837,1838,1839,1840,1841,1842,1843,1844,1845,1846,1847,1848,1849,1850,1851,1852,1853,1854,1855,1856,1857,1858,1859,1860,1861,1862,1863,1864,1865,1866,1867,1868,1869,1870,1871,1872,1873,1874,1875,1876,1877,1878,1879,1880,1881,1882,1883,1884,1885,1886,1887,1888,1889,1890,1891,1892,1893,1894,1895,1896,1897,1898,1899,1900,1901,1902,1903,1904,1905,1906,1907,1908,1909,1910,1911,1912,1913,1914,1915,1916,1917,1918,1919,1920,1921,1922,1923,1924,1925,1926,1927,1928,1929,1930,1931,1932,1933,1934,1935,1936,1937,1938,1939,1940,1941,1942,1943,1944,1945,1946,1947,1948,1949,1950,1951,1952,1953,1954,1955,1956,1957,1958,1959,1960,1961,1962,1963,1964,1965,1966,1967,1968,1969,1970,1971,1972,1973,1974,1975,1976,1977,1978,1979,1980,1981,1982,1983,1984,1985,1986,1987,1988,1989,1990,1991,1992,1993,1994,1995,1996,1997,1998,1999,2000,2001,2002,2003,2004,2005,2006,2007,2008,2009,2010,2011,2012,2013,2014,2015,2016,2017,2018,2019,2020,2021,2022,2023,2024,2025,2026,2027,2028,2029,2030,2031,2032,2033,2034,2035,2036,2037,2038,2039,2040,2041,2042,2043,2044,2045,2046,2047,2048,2049,2050,2051,2052,2053,2054,2055,2056,2057,2058,2059,2060,2061,2062,2063,2064,2065,2066,2067,2068,2069,2070,2071,2072,2073,2074,2075,2076,2077,2078,2079,2080,2081,2082,2083,2084,2085,2086,2087,2088,2089,2090,2091,2092,2093,2094,2095,2096,2097,2098,2099,2100,2101,2102,2103,2104,2105,2106,2107,2108,2109,2110,2111,2112,2113,2114,2115,2116,2117,2118]
+]
\ No newline at end of file
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_basic_01.expected b/3rdparty/jsoncpp/src/test/data/legacy_test_basic_01.expected
new file mode 100644
index 00000000..d761fce1
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_basic_01.expected
@@ -0,0 +1 @@
+.=123456789
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_basic_01.json b/3rdparty/jsoncpp/src/test/data/legacy_test_basic_01.json
new file mode 100644
index 00000000..11f11f9b
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_basic_01.json
@@ -0,0 +1 @@
+0123456789
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_basic_02.expected b/3rdparty/jsoncpp/src/test/data/legacy_test_basic_02.expected
new file mode 100644
index 00000000..650e37cb
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_basic_02.expected
@@ -0,0 +1 @@
+.=-123456789
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_basic_02.json b/3rdparty/jsoncpp/src/test/data/legacy_test_basic_02.json
new file mode 100644
index 00000000..bf11bcea
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_basic_02.json
@@ -0,0 +1 @@
+-0123456789
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_basic_03.expected b/3rdparty/jsoncpp/src/test/data/legacy_test_basic_03.expected
new file mode 100644
index 00000000..1da2d395
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_basic_03.expected
@@ -0,0 +1,3 @@
+.=1.2345678
+
+
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_basic_03.json b/3rdparty/jsoncpp/src/test/data/legacy_test_basic_03.json
new file mode 100644
index 00000000..a92b6bd2
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_basic_03.json
@@ -0,0 +1,3 @@
+1.2345678
+
+
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_basic_04.expected b/3rdparty/jsoncpp/src/test/data/legacy_test_basic_04.expected
new file mode 100644
index 00000000..013f424f
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_basic_04.expected
@@ -0,0 +1,2 @@
+.="abcdef"
+
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_basic_04.json b/3rdparty/jsoncpp/src/test/data/legacy_test_basic_04.json
new file mode 100644
index 00000000..17eeb99e
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_basic_04.json
@@ -0,0 +1,2 @@
+"abcdef"
+
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_basic_05.expected b/3rdparty/jsoncpp/src/test/data/legacy_test_basic_05.expected
new file mode 100644
index 00000000..c8db822e
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_basic_05.expected
@@ -0,0 +1,2 @@
+.=null
+
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_basic_05.json b/3rdparty/jsoncpp/src/test/data/legacy_test_basic_05.json
new file mode 100644
index 00000000..d0aaea21
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_basic_05.json
@@ -0,0 +1,2 @@
+null
+
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_basic_06.expected b/3rdparty/jsoncpp/src/test/data/legacy_test_basic_06.expected
new file mode 100644
index 00000000..49be55a9
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_basic_06.expected
@@ -0,0 +1,2 @@
+.=true
+
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_basic_06.json b/3rdparty/jsoncpp/src/test/data/legacy_test_basic_06.json
new file mode 100644
index 00000000..7eead1ee
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_basic_06.json
@@ -0,0 +1,2 @@
+true
+
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_basic_07.expected b/3rdparty/jsoncpp/src/test/data/legacy_test_basic_07.expected
new file mode 100644
index 00000000..fe55a6a8
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_basic_07.expected
@@ -0,0 +1,2 @@
+.=false
+
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_basic_07.json b/3rdparty/jsoncpp/src/test/data/legacy_test_basic_07.json
new file mode 100644
index 00000000..a864bc48
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_basic_07.json
@@ -0,0 +1,2 @@
+false
+
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_basic_08.expected b/3rdparty/jsoncpp/src/test/data/legacy_test_basic_08.expected
new file mode 100644
index 00000000..caf5352a
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_basic_08.expected
@@ -0,0 +1,3 @@
+// C++ style comment
+.=null
+
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_basic_08.json b/3rdparty/jsoncpp/src/test/data/legacy_test_basic_08.json
new file mode 100644
index 00000000..fd78837c
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_basic_08.json
@@ -0,0 +1,3 @@
+// C++ style comment
+null
+
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_basic_09.expected b/3rdparty/jsoncpp/src/test/data/legacy_test_basic_09.expected
new file mode 100644
index 00000000..8b129da4
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_basic_09.expected
@@ -0,0 +1,4 @@
+/* C style comment
+ */
+.=null
+
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_basic_09.json b/3rdparty/jsoncpp/src/test/data/legacy_test_basic_09.json
new file mode 100644
index 00000000..fc95f0f5
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_basic_09.json
@@ -0,0 +1,4 @@
+/* C style comment
+ */
+null
+
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_comment_00.expected b/3rdparty/jsoncpp/src/test/data/legacy_test_comment_00.expected
new file mode 100644
index 00000000..284a797d
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_comment_00.expected
@@ -0,0 +1,4 @@
+// Comment for array
+.=[]
+// Comment within array
+.[0]="one-element"
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_comment_00.json b/3rdparty/jsoncpp/src/test/data/legacy_test_comment_00.json
new file mode 100644
index 00000000..4df577a8
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_comment_00.json
@@ -0,0 +1,5 @@
+// Comment for array
+[
+   // Comment within array
+   "one-element"
+]
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_comment_01.expected b/3rdparty/jsoncpp/src/test/data/legacy_test_comment_01.expected
new file mode 100644
index 00000000..1ed01ba1
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_comment_01.expected
@@ -0,0 +1,10 @@
+.={}
+// Comment for array
+.test=[]
+// Comment within array
+.test[0]={}
+.test[0].a="aaa"
+.test[1]={}
+.test[1].b="bbb"
+.test[2]={}
+.test[2].c="ccc"
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_comment_01.json b/3rdparty/jsoncpp/src/test/data/legacy_test_comment_01.json
new file mode 100644
index 00000000..6defe400
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_comment_01.json
@@ -0,0 +1,10 @@
+{
+    "test":
+    // Comment for array
+    [
+       // Comment within array
+       { "a" : "aaa" }, // Comment for a
+       { "b" : "bbb" }, // Comment for b
+       { "c" : "ccc" } // Comment for c
+    ]
+}
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_comment_02.expected b/3rdparty/jsoncpp/src/test/data/legacy_test_comment_02.expected
new file mode 100644
index 00000000..8986dbac
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_comment_02.expected
@@ -0,0 +1,23 @@
+.={}
+/* C-style comment
+
+    C-style-2 comment */
+.c-test={}
+.c-test.a=1
+/* Internal comment c-style */
+.c-test.b=2
+// C++-style comment
+.cpp-test={}
+// Multiline comment cpp-style
+// Second line
+.cpp-test.c=3
+// Comment before double
+.cpp-test.d=4.1
+// Comment before string
+.cpp-test.e="e-string"
+// Comment before true
+.cpp-test.f=true
+// Comment before false
+.cpp-test.g=false
+// Comment before null
+.cpp-test.h=null
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_comment_02.json b/3rdparty/jsoncpp/src/test/data/legacy_test_comment_02.json
new file mode 100644
index 00000000..f5042e0d
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_comment_02.json
@@ -0,0 +1,26 @@
+{
+   /* C-style comment
+
+    C-style-2 comment */
+   "c-test" : {
+      "a" : 1,
+      /* Internal comment c-style */
+      "b" : 2
+   },
+   // C++-style comment
+   "cpp-test" : {
+      // Multiline comment cpp-style
+      // Second line
+      "c" : 3,
+      // Comment before double
+      "d" : 4.1,
+      // Comment before string
+      "e" : "e-string",
+      // Comment before true
+      "f" : true,
+      // Comment before false
+      "g" : false,
+      // Comment before null
+      "h" : null
+   }
+}
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_complex_01.expected b/3rdparty/jsoncpp/src/test/data/legacy_test_complex_01.expected
new file mode 100644
index 00000000..7573c881
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_complex_01.expected
@@ -0,0 +1,20 @@
+.={}
+.attribute=[]
+.attribute[0]="random"
+.attribute[1]="short"
+.attribute[2]="bold"
+.attribute[3]=12
+.attribute[4]={}
+.attribute[4].height=7
+.attribute[4].width=64
+.count=1234
+.name={}
+.name.aka="T.E.S.T."
+.name.id=123987
+.test={}
+.test.1={}
+.test.1.2={}
+.test.1.2.3={}
+.test.1.2.3.coord=[]
+.test.1.2.3.coord[0]=1
+.test.1.2.3.coord[1]=2
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_complex_01.json b/3rdparty/jsoncpp/src/test/data/legacy_test_complex_01.json
new file mode 100644
index 00000000..2c4a869a
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_complex_01.json
@@ -0,0 +1,17 @@
+{
+	"count" : 1234,
+	"name" : { "aka" : "T.E.S.T.", "id" : 123987 },
+	"attribute" : [
+		"random",
+		"short",
+		"bold",
+		12,
+		{ "height" : 7, "width" : 64 }
+		],
+	"test": { "1" :
+		{ "2" :
+			{ "3" :  { "coord" : [ 1,2] }
+			}
+		}
+	}
+}
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_integer_01.expected b/3rdparty/jsoncpp/src/test/data/legacy_test_integer_01.expected
new file mode 100644
index 00000000..463e149d
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_integer_01.expected
@@ -0,0 +1,2 @@
+// Max signed integer
+.=2147483647
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_integer_01.json b/3rdparty/jsoncpp/src/test/data/legacy_test_integer_01.json
new file mode 100644
index 00000000..5ab12ffe
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_integer_01.json
@@ -0,0 +1,2 @@
+// Max signed integer
+2147483647
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_integer_02.expected b/3rdparty/jsoncpp/src/test/data/legacy_test_integer_02.expected
new file mode 100644
index 00000000..0773e085
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_integer_02.expected
@@ -0,0 +1,2 @@
+// Min signed integer
+.=-2147483648
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_integer_02.json b/3rdparty/jsoncpp/src/test/data/legacy_test_integer_02.json
new file mode 100644
index 00000000..056c8500
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_integer_02.json
@@ -0,0 +1,2 @@
+// Min signed integer
+-2147483648
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_integer_03.expected b/3rdparty/jsoncpp/src/test/data/legacy_test_integer_03.expected
new file mode 100644
index 00000000..c7efff79
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_integer_03.expected
@@ -0,0 +1,2 @@
+// Max unsigned integer
+.=4294967295
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_integer_03.json b/3rdparty/jsoncpp/src/test/data/legacy_test_integer_03.json
new file mode 100644
index 00000000..12ef3fbb
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_integer_03.json
@@ -0,0 +1,2 @@
+// Max unsigned integer
+4294967295
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_integer_04.expected b/3rdparty/jsoncpp/src/test/data/legacy_test_integer_04.expected
new file mode 100644
index 00000000..39f85670
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_integer_04.expected
@@ -0,0 +1,3 @@
+// Min unsigned integer
+.=0
+
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_integer_04.json b/3rdparty/jsoncpp/src/test/data/legacy_test_integer_04.json
new file mode 100644
index 00000000..bf814994
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_integer_04.json
@@ -0,0 +1,3 @@
+// Min unsigned integer
+0
+
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_integer_05.expected b/3rdparty/jsoncpp/src/test/data/legacy_test_integer_05.expected
new file mode 100644
index 00000000..0caea9d3
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_integer_05.expected
@@ -0,0 +1,2 @@
+.=1
+
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_integer_05.json b/3rdparty/jsoncpp/src/test/data/legacy_test_integer_05.json
new file mode 100644
index 00000000..d474e1b4
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_integer_05.json
@@ -0,0 +1,2 @@
+1
+
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_integer_06_64bits.expected b/3rdparty/jsoncpp/src/test/data/legacy_test_integer_06_64bits.expected
new file mode 100644
index 00000000..131b085f
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_integer_06_64bits.expected
@@ -0,0 +1 @@
+.=9223372036854775808
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_integer_06_64bits.json b/3rdparty/jsoncpp/src/test/data/legacy_test_integer_06_64bits.json
new file mode 100644
index 00000000..cfedfe5e
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_integer_06_64bits.json
@@ -0,0 +1,2 @@
+9223372036854775808
+
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_integer_07_64bits.expected b/3rdparty/jsoncpp/src/test/data/legacy_test_integer_07_64bits.expected
new file mode 100644
index 00000000..c8524a32
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_integer_07_64bits.expected
@@ -0,0 +1 @@
+.=-9223372036854775808
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_integer_07_64bits.json b/3rdparty/jsoncpp/src/test/data/legacy_test_integer_07_64bits.json
new file mode 100644
index 00000000..a964ad2e
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_integer_07_64bits.json
@@ -0,0 +1,2 @@
+-9223372036854775808
+
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_integer_08_64bits.expected b/3rdparty/jsoncpp/src/test/data/legacy_test_integer_08_64bits.expected
new file mode 100644
index 00000000..321bba5a
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_integer_08_64bits.expected
@@ -0,0 +1 @@
+.=18446744073709551615
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_integer_08_64bits.json b/3rdparty/jsoncpp/src/test/data/legacy_test_integer_08_64bits.json
new file mode 100644
index 00000000..4c15a01b
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_integer_08_64bits.json
@@ -0,0 +1,2 @@
+18446744073709551615
+
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_large_01.expected b/3rdparty/jsoncpp/src/test/data/legacy_test_large_01.expected
new file mode 100644
index 00000000..ee2fafc0
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_large_01.expected
@@ -0,0 +1,2122 @@
+.=[]
+.[0]=[]
+.[0][0]="A"
+.[0][1]=0
+.[0][2]=1
+.[0][3]=2
+.[0][4]=3
+.[0][5]=4
+.[0][6]=5
+.[0][7]=6
+.[0][8]=7
+.[0][9]=8
+.[0][10]=9
+.[0][11]=10
+.[0][12]=11
+.[0][13]=12
+.[0][14]=13
+.[0][15]=14
+.[0][16]=15
+.[0][17]=16
+.[0][18]=17
+.[0][19]=18
+.[0][20]=19
+.[0][21]=20
+.[0][22]=21
+.[0][23]=22
+.[0][24]=23
+.[0][25]=24
+.[0][26]=25
+.[0][27]=26
+.[0][28]=27
+.[0][29]=28
+.[0][30]=29
+.[0][31]=30
+.[0][32]=31
+.[0][33]=32
+.[0][34]=33
+.[0][35]=34
+.[0][36]=35
+.[0][37]=36
+.[0][38]=37
+.[0][39]=38
+.[0][40]=39
+.[0][41]=40
+.[0][42]=41
+.[0][43]=42
+.[0][44]=43
+.[0][45]=44
+.[0][46]=45
+.[0][47]=46
+.[0][48]=47
+.[0][49]=48
+.[0][50]=49
+.[0][51]=50
+.[0][52]=51
+.[0][53]=52
+.[0][54]=53
+.[0][55]=54
+.[0][56]=55
+.[0][57]=56
+.[0][58]=57
+.[0][59]=58
+.[0][60]=59
+.[0][61]=60
+.[0][62]=61
+.[0][63]=62
+.[0][64]=63
+.[0][65]=64
+.[0][66]=65
+.[0][67]=66
+.[0][68]=67
+.[0][69]=68
+.[0][70]=69
+.[0][71]=70
+.[0][72]=71
+.[0][73]=72
+.[0][74]=73
+.[0][75]=74
+.[0][76]=75
+.[0][77]=76
+.[0][78]=77
+.[0][79]=78
+.[0][80]=79
+.[0][81]=80
+.[0][82]=81
+.[0][83]=82
+.[0][84]=83
+.[0][85]=84
+.[0][86]=85
+.[0][87]=86
+.[0][88]=87
+.[0][89]=88
+.[0][90]=89
+.[0][91]=90
+.[0][92]=91
+.[0][93]=92
+.[0][94]=93
+.[0][95]=94
+.[0][96]=95
+.[0][97]=96
+.[0][98]=97
+.[0][99]=98
+.[0][100]=99
+.[0][101]=100
+.[0][102]=101
+.[0][103]=102
+.[0][104]=103
+.[0][105]=104
+.[0][106]=105
+.[0][107]=106
+.[0][108]=107
+.[0][109]=108
+.[0][110]=109
+.[0][111]=110
+.[0][112]=111
+.[0][113]=112
+.[0][114]=113
+.[0][115]=114
+.[0][116]=115
+.[0][117]=116
+.[0][118]=117
+.[0][119]=118
+.[0][120]=119
+.[0][121]=120
+.[0][122]=121
+.[0][123]=122
+.[0][124]=123
+.[0][125]=124
+.[0][126]=125
+.[0][127]=126
+.[0][128]=127
+.[0][129]=128
+.[0][130]=129
+.[0][131]=130
+.[0][132]=131
+.[0][133]=132
+.[0][134]=133
+.[0][135]=134
+.[0][136]=135
+.[0][137]=136
+.[0][138]=137
+.[0][139]=138
+.[0][140]=139
+.[0][141]=140
+.[0][142]=141
+.[0][143]=142
+.[0][144]=143
+.[0][145]=144
+.[0][146]=145
+.[0][147]=146
+.[0][148]=147
+.[0][149]=148
+.[0][150]=149
+.[0][151]=150
+.[0][152]=151
+.[0][153]=152
+.[0][154]=153
+.[0][155]=154
+.[0][156]=155
+.[0][157]=156
+.[0][158]=157
+.[0][159]=158
+.[0][160]=159
+.[0][161]=160
+.[0][162]=161
+.[0][163]=162
+.[0][164]=163
+.[0][165]=164
+.[0][166]=165
+.[0][167]=166
+.[0][168]=167
+.[0][169]=168
+.[0][170]=169
+.[0][171]=170
+.[0][172]=171
+.[0][173]=172
+.[0][174]=173
+.[0][175]=174
+.[0][176]=175
+.[0][177]=176
+.[0][178]=177
+.[0][179]=178
+.[0][180]=179
+.[0][181]=180
+.[0][182]=181
+.[0][183]=182
+.[0][184]=183
+.[0][185]=184
+.[0][186]=185
+.[0][187]=186
+.[0][188]=187
+.[0][189]=188
+.[0][190]=189
+.[0][191]=190
+.[0][192]=191
+.[0][193]=192
+.[0][194]=193
+.[0][195]=194
+.[0][196]=195
+.[0][197]=196
+.[0][198]=197
+.[0][199]=198
+.[0][200]=199
+.[0][201]=200
+.[0][202]=201
+.[0][203]=202
+.[0][204]=203
+.[0][205]=204
+.[0][206]=205
+.[0][207]=206
+.[0][208]=207
+.[0][209]=208
+.[0][210]=209
+.[0][211]=210
+.[0][212]=211
+.[0][213]=212
+.[0][214]=213
+.[0][215]=214
+.[0][216]=215
+.[0][217]=216
+.[0][218]=217
+.[0][219]=218
+.[0][220]=219
+.[0][221]=220
+.[0][222]=221
+.[0][223]=222
+.[0][224]=223
+.[0][225]=224
+.[0][226]=225
+.[0][227]=226
+.[0][228]=227
+.[0][229]=228
+.[0][230]=229
+.[0][231]=230
+.[0][232]=231
+.[0][233]=232
+.[0][234]=233
+.[0][235]=234
+.[0][236]=235
+.[0][237]=236
+.[0][238]=237
+.[0][239]=238
+.[0][240]=239
+.[0][241]=240
+.[0][242]=241
+.[0][243]=242
+.[0][244]=243
+.[0][245]=244
+.[0][246]=245
+.[0][247]=246
+.[0][248]=247
+.[0][249]=248
+.[0][250]=249
+.[0][251]=250
+.[0][252]=251
+.[0][253]=252
+.[0][254]=253
+.[0][255]=254
+.[0][256]=255
+.[0][257]=256
+.[0][258]=257
+.[0][259]=258
+.[0][260]=259
+.[0][261]=260
+.[0][262]=261
+.[0][263]=262
+.[0][264]=263
+.[0][265]=264
+.[0][266]=265
+.[0][267]=266
+.[0][268]=267
+.[0][269]=268
+.[0][270]=269
+.[0][271]=270
+.[0][272]=271
+.[0][273]=272
+.[0][274]=273
+.[0][275]=274
+.[0][276]=275
+.[0][277]=276
+.[0][278]=277
+.[0][279]=278
+.[0][280]=279
+.[0][281]=280
+.[0][282]=281
+.[0][283]=282
+.[0][284]=283
+.[0][285]=284
+.[0][286]=285
+.[0][287]=286
+.[0][288]=287
+.[0][289]=288
+.[0][290]=289
+.[0][291]=290
+.[0][292]=291
+.[0][293]=292
+.[0][294]=293
+.[0][295]=294
+.[0][296]=295
+.[0][297]=296
+.[0][298]=297
+.[0][299]=298
+.[0][300]=299
+.[0][301]=300
+.[0][302]=301
+.[0][303]=302
+.[0][304]=303
+.[0][305]=304
+.[0][306]=305
+.[0][307]=306
+.[0][308]=307
+.[0][309]=308
+.[0][310]=309
+.[0][311]=310
+.[0][312]=311
+.[0][313]=312
+.[0][314]=313
+.[0][315]=314
+.[0][316]=315
+.[0][317]=316
+.[0][318]=317
+.[0][319]=318
+.[0][320]=319
+.[0][321]=320
+.[0][322]=321
+.[0][323]=322
+.[0][324]=323
+.[0][325]=324
+.[0][326]=325
+.[0][327]=326
+.[0][328]=327
+.[0][329]=328
+.[0][330]=329
+.[0][331]=330
+.[0][332]=331
+.[0][333]=332
+.[0][334]=333
+.[0][335]=334
+.[0][336]=335
+.[0][337]=336
+.[0][338]=337
+.[0][339]=338
+.[0][340]=339
+.[0][341]=340
+.[0][342]=341
+.[0][343]=342
+.[0][344]=343
+.[0][345]=344
+.[0][346]=345
+.[0][347]=346
+.[0][348]=347
+.[0][349]=348
+.[0][350]=349
+.[0][351]=350
+.[0][352]=351
+.[0][353]=352
+.[0][354]=353
+.[0][355]=354
+.[0][356]=355
+.[0][357]=356
+.[0][358]=357
+.[0][359]=358
+.[0][360]=359
+.[0][361]=360
+.[0][362]=361
+.[0][363]=362
+.[0][364]=363
+.[0][365]=364
+.[0][366]=365
+.[0][367]=366
+.[0][368]=367
+.[0][369]=368
+.[0][370]=369
+.[0][371]=370
+.[0][372]=371
+.[0][373]=372
+.[0][374]=373
+.[0][375]=374
+.[0][376]=375
+.[0][377]=376
+.[0][378]=377
+.[0][379]=378
+.[0][380]=379
+.[0][381]=380
+.[0][382]=381
+.[0][383]=382
+.[0][384]=383
+.[0][385]=384
+.[0][386]=385
+.[0][387]=386
+.[0][388]=387
+.[0][389]=388
+.[0][390]=389
+.[0][391]=390
+.[0][392]=391
+.[0][393]=392
+.[0][394]=393
+.[0][395]=394
+.[0][396]=395
+.[0][397]=396
+.[0][398]=397
+.[0][399]=398
+.[0][400]=399
+.[0][401]=400
+.[0][402]=401
+.[0][403]=402
+.[0][404]=403
+.[0][405]=404
+.[0][406]=405
+.[0][407]=406
+.[0][408]=407
+.[0][409]=408
+.[0][410]=409
+.[0][411]=410
+.[0][412]=411
+.[0][413]=412
+.[0][414]=413
+.[0][415]=414
+.[0][416]=415
+.[0][417]=416
+.[0][418]=417
+.[0][419]=418
+.[0][420]=419
+.[0][421]=420
+.[0][422]=421
+.[0][423]=422
+.[0][424]=423
+.[0][425]=424
+.[0][426]=425
+.[0][427]=426
+.[0][428]=427
+.[0][429]=428
+.[0][430]=429
+.[0][431]=430
+.[0][432]=431
+.[0][433]=432
+.[0][434]=433
+.[0][435]=434
+.[0][436]=435
+.[0][437]=436
+.[0][438]=437
+.[0][439]=438
+.[0][440]=439
+.[0][441]=440
+.[0][442]=441
+.[0][443]=442
+.[0][444]=443
+.[0][445]=444
+.[0][446]=445
+.[0][447]=446
+.[0][448]=447
+.[0][449]=448
+.[0][450]=449
+.[0][451]=450
+.[0][452]=451
+.[0][453]=452
+.[0][454]=453
+.[0][455]=454
+.[0][456]=455
+.[0][457]=456
+.[0][458]=457
+.[0][459]=458
+.[0][460]=459
+.[0][461]=460
+.[0][462]=461
+.[0][463]=462
+.[0][464]=463
+.[0][465]=464
+.[0][466]=465
+.[0][467]=466
+.[0][468]=467
+.[0][469]=468
+.[0][470]=469
+.[0][471]=470
+.[0][472]=471
+.[0][473]=472
+.[0][474]=473
+.[0][475]=474
+.[0][476]=475
+.[0][477]=476
+.[0][478]=477
+.[0][479]=478
+.[0][480]=479
+.[0][481]=480
+.[0][482]=481
+.[0][483]=482
+.[0][484]=483
+.[0][485]=484
+.[0][486]=485
+.[0][487]=486
+.[0][488]=487
+.[0][489]=488
+.[0][490]=489
+.[0][491]=490
+.[0][492]=491
+.[0][493]=492
+.[0][494]=493
+.[0][495]=494
+.[0][496]=495
+.[0][497]=496
+.[0][498]=497
+.[0][499]=498
+.[0][500]=499
+.[0][501]=500
+.[0][502]=501
+.[0][503]=502
+.[0][504]=503
+.[0][505]=504
+.[0][506]=505
+.[0][507]=506
+.[0][508]=507
+.[0][509]=508
+.[0][510]=509
+.[0][511]=510
+.[0][512]=511
+.[0][513]=512
+.[0][514]=513
+.[0][515]=514
+.[0][516]=515
+.[0][517]=516
+.[0][518]=517
+.[0][519]=518
+.[0][520]=519
+.[0][521]=520
+.[0][522]=521
+.[0][523]=522
+.[0][524]=523
+.[0][525]=524
+.[0][526]=525
+.[0][527]=526
+.[0][528]=527
+.[0][529]=528
+.[0][530]=529
+.[0][531]=530
+.[0][532]=531
+.[0][533]=532
+.[0][534]=533
+.[0][535]=534
+.[0][536]=535
+.[0][537]=536
+.[0][538]=537
+.[0][539]=538
+.[0][540]=539
+.[0][541]=540
+.[0][542]=541
+.[0][543]=542
+.[0][544]=543
+.[0][545]=544
+.[0][546]=545
+.[0][547]=546
+.[0][548]=547
+.[0][549]=548
+.[0][550]=549
+.[0][551]=550
+.[0][552]=551
+.[0][553]=552
+.[0][554]=553
+.[0][555]=554
+.[0][556]=555
+.[0][557]=556
+.[0][558]=557
+.[0][559]=558
+.[0][560]=559
+.[0][561]=560
+.[0][562]=561
+.[0][563]=562
+.[0][564]=563
+.[0][565]=564
+.[0][566]=565
+.[0][567]=566
+.[0][568]=567
+.[0][569]=568
+.[0][570]=569
+.[0][571]=570
+.[0][572]=571
+.[0][573]=572
+.[0][574]=573
+.[0][575]=574
+.[0][576]=575
+.[0][577]=576
+.[0][578]=577
+.[0][579]=578
+.[0][580]=579
+.[0][581]=580
+.[0][582]=581
+.[0][583]=582
+.[0][584]=583
+.[0][585]=584
+.[0][586]=585
+.[0][587]=586
+.[0][588]=587
+.[0][589]=588
+.[0][590]=589
+.[0][591]=590
+.[0][592]=591
+.[0][593]=592
+.[0][594]=593
+.[0][595]=594
+.[0][596]=595
+.[0][597]=596
+.[0][598]=597
+.[0][599]=598
+.[0][600]=599
+.[0][601]=600
+.[0][602]=601
+.[0][603]=602
+.[0][604]=603
+.[0][605]=604
+.[0][606]=605
+.[0][607]=606
+.[0][608]=607
+.[0][609]=608
+.[0][610]=609
+.[0][611]=610
+.[0][612]=611
+.[0][613]=612
+.[0][614]=613
+.[0][615]=614
+.[0][616]=615
+.[0][617]=616
+.[0][618]=617
+.[0][619]=618
+.[0][620]=619
+.[0][621]=620
+.[0][622]=621
+.[0][623]=622
+.[0][624]=623
+.[0][625]=624
+.[0][626]=625
+.[0][627]=626
+.[0][628]=627
+.[0][629]=628
+.[0][630]=629
+.[0][631]=630
+.[0][632]=631
+.[0][633]=632
+.[0][634]=633
+.[0][635]=634
+.[0][636]=635
+.[0][637]=636
+.[0][638]=637
+.[0][639]=638
+.[0][640]=639
+.[0][641]=640
+.[0][642]=641
+.[0][643]=642
+.[0][644]=643
+.[0][645]=644
+.[0][646]=645
+.[0][647]=646
+.[0][648]=647
+.[0][649]=648
+.[0][650]=649
+.[0][651]=650
+.[0][652]=651
+.[0][653]=652
+.[0][654]=653
+.[0][655]=654
+.[0][656]=655
+.[0][657]=656
+.[0][658]=657
+.[0][659]=658
+.[0][660]=659
+.[0][661]=660
+.[0][662]=661
+.[0][663]=662
+.[0][664]=663
+.[0][665]=664
+.[0][666]=665
+.[0][667]=666
+.[0][668]=667
+.[0][669]=668
+.[0][670]=669
+.[0][671]=670
+.[0][672]=671
+.[0][673]=672
+.[0][674]=673
+.[0][675]=674
+.[0][676]=675
+.[0][677]=676
+.[0][678]=677
+.[0][679]=678
+.[0][680]=679
+.[0][681]=680
+.[0][682]=681
+.[0][683]=682
+.[0][684]=683
+.[0][685]=684
+.[0][686]=685
+.[0][687]=686
+.[0][688]=687
+.[0][689]=688
+.[0][690]=689
+.[0][691]=690
+.[0][692]=691
+.[0][693]=692
+.[0][694]=693
+.[0][695]=694
+.[0][696]=695
+.[0][697]=696
+.[0][698]=697
+.[0][699]=698
+.[0][700]=699
+.[0][701]=700
+.[0][702]=701
+.[0][703]=702
+.[0][704]=703
+.[0][705]=704
+.[0][706]=705
+.[0][707]=706
+.[0][708]=707
+.[0][709]=708
+.[0][710]=709
+.[0][711]=710
+.[0][712]=711
+.[0][713]=712
+.[0][714]=713
+.[0][715]=714
+.[0][716]=715
+.[0][717]=716
+.[0][718]=717
+.[0][719]=718
+.[0][720]=719
+.[0][721]=720
+.[0][722]=721
+.[0][723]=722
+.[0][724]=723
+.[0][725]=724
+.[0][726]=725
+.[0][727]=726
+.[0][728]=727
+.[0][729]=728
+.[0][730]=729
+.[0][731]=730
+.[0][732]=731
+.[0][733]=732
+.[0][734]=733
+.[0][735]=734
+.[0][736]=735
+.[0][737]=736
+.[0][738]=737
+.[0][739]=738
+.[0][740]=739
+.[0][741]=740
+.[0][742]=741
+.[0][743]=742
+.[0][744]=743
+.[0][745]=744
+.[0][746]=745
+.[0][747]=746
+.[0][748]=747
+.[0][749]=748
+.[0][750]=749
+.[0][751]=750
+.[0][752]=751
+.[0][753]=752
+.[0][754]=753
+.[0][755]=754
+.[0][756]=755
+.[0][757]=756
+.[0][758]=757
+.[0][759]=758
+.[0][760]=759
+.[0][761]=760
+.[0][762]=761
+.[0][763]=762
+.[0][764]=763
+.[0][765]=764
+.[0][766]=765
+.[0][767]=766
+.[0][768]=767
+.[0][769]=768
+.[0][770]=769
+.[0][771]=770
+.[0][772]=771
+.[0][773]=772
+.[0][774]=773
+.[0][775]=774
+.[0][776]=775
+.[0][777]=776
+.[0][778]=777
+.[0][779]=778
+.[0][780]=779
+.[0][781]=780
+.[0][782]=781
+.[0][783]=782
+.[0][784]=783
+.[0][785]=784
+.[0][786]=785
+.[0][787]=786
+.[0][788]=787
+.[0][789]=788
+.[0][790]=789
+.[0][791]=790
+.[0][792]=791
+.[0][793]=792
+.[0][794]=793
+.[0][795]=794
+.[0][796]=795
+.[0][797]=796
+.[0][798]=797
+.[0][799]=798
+.[0][800]=799
+.[0][801]=800
+.[0][802]=801
+.[0][803]=802
+.[0][804]=803
+.[0][805]=804
+.[0][806]=805
+.[0][807]=806
+.[0][808]=807
+.[0][809]=808
+.[0][810]=809
+.[0][811]=810
+.[0][812]=811
+.[0][813]=812
+.[0][814]=813
+.[0][815]=814
+.[0][816]=815
+.[0][817]=816
+.[0][818]=817
+.[0][819]=818
+.[0][820]=819
+.[0][821]=820
+.[0][822]=821
+.[0][823]=822
+.[0][824]=823
+.[0][825]=824
+.[0][826]=825
+.[0][827]=826
+.[0][828]=827
+.[0][829]=828
+.[0][830]=829
+.[0][831]=830
+.[0][832]=831
+.[0][833]=832
+.[0][834]=833
+.[0][835]=834
+.[0][836]=835
+.[0][837]=836
+.[0][838]=837
+.[0][839]=838
+.[0][840]=839
+.[0][841]=840
+.[0][842]=841
+.[0][843]=842
+.[0][844]=843
+.[0][845]=844
+.[0][846]=845
+.[0][847]=846
+.[0][848]=847
+.[0][849]=848
+.[0][850]=849
+.[0][851]=850
+.[0][852]=851
+.[0][853]=852
+.[0][854]=853
+.[0][855]=854
+.[0][856]=855
+.[0][857]=856
+.[0][858]=857
+.[0][859]=858
+.[0][860]=859
+.[0][861]=860
+.[0][862]=861
+.[0][863]=862
+.[0][864]=863
+.[0][865]=864
+.[0][866]=865
+.[0][867]=866
+.[0][868]=867
+.[0][869]=868
+.[0][870]=869
+.[0][871]=870
+.[0][872]=871
+.[0][873]=872
+.[0][874]=873
+.[0][875]=874
+.[0][876]=875
+.[0][877]=876
+.[0][878]=877
+.[0][879]=878
+.[0][880]=879
+.[0][881]=880
+.[0][882]=881
+.[0][883]=882
+.[0][884]=883
+.[0][885]=884
+.[0][886]=885
+.[0][887]=886
+.[0][888]=887
+.[0][889]=888
+.[0][890]=889
+.[0][891]=890
+.[0][892]=891
+.[0][893]=892
+.[0][894]=893
+.[0][895]=894
+.[0][896]=895
+.[0][897]=896
+.[0][898]=897
+.[0][899]=898
+.[0][900]=899
+.[0][901]=900
+.[0][902]=901
+.[0][903]=902
+.[0][904]=903
+.[0][905]=904
+.[0][906]=905
+.[0][907]=906
+.[0][908]=907
+.[0][909]=908
+.[0][910]=909
+.[0][911]=910
+.[0][912]=911
+.[0][913]=912
+.[0][914]=913
+.[0][915]=914
+.[0][916]=915
+.[0][917]=916
+.[0][918]=917
+.[0][919]=918
+.[0][920]=919
+.[0][921]=920
+.[0][922]=921
+.[0][923]=922
+.[0][924]=923
+.[0][925]=924
+.[0][926]=925
+.[0][927]=926
+.[0][928]=927
+.[0][929]=928
+.[0][930]=929
+.[0][931]=930
+.[0][932]=931
+.[0][933]=932
+.[0][934]=933
+.[0][935]=934
+.[0][936]=935
+.[0][937]=936
+.[0][938]=937
+.[0][939]=938
+.[0][940]=939
+.[0][941]=940
+.[0][942]=941
+.[0][943]=942
+.[0][944]=943
+.[0][945]=944
+.[0][946]=945
+.[0][947]=946
+.[0][948]=947
+.[0][949]=948
+.[0][950]=949
+.[0][951]=950
+.[0][952]=951
+.[0][953]=952
+.[0][954]=953
+.[0][955]=954
+.[0][956]=955
+.[0][957]=956
+.[0][958]=957
+.[0][959]=958
+.[0][960]=959
+.[0][961]=960
+.[0][962]=961
+.[0][963]=962
+.[0][964]=963
+.[0][965]=964
+.[0][966]=965
+.[0][967]=966
+.[0][968]=967
+.[0][969]=968
+.[0][970]=969
+.[0][971]=970
+.[0][972]=971
+.[0][973]=972
+.[0][974]=973
+.[0][975]=974
+.[0][976]=975
+.[0][977]=976
+.[0][978]=977
+.[0][979]=978
+.[0][980]=979
+.[0][981]=980
+.[0][982]=981
+.[0][983]=982
+.[0][984]=983
+.[0][985]=984
+.[0][986]=985
+.[0][987]=986
+.[0][988]=987
+.[0][989]=988
+.[0][990]=989
+.[0][991]=990
+.[0][992]=991
+.[0][993]=992
+.[0][994]=993
+.[0][995]=994
+.[0][996]=995
+.[0][997]=996
+.[0][998]=997
+.[0][999]=998
+.[0][1000]=999
+.[0][1001]=1000
+.[0][1002]=1001
+.[0][1003]=1002
+.[0][1004]=1003
+.[0][1005]=1004
+.[0][1006]=1005
+.[0][1007]=1006
+.[0][1008]=1007
+.[0][1009]=1008
+.[0][1010]=1009
+.[0][1011]=1010
+.[0][1012]=1011
+.[0][1013]=1012
+.[0][1014]=1013
+.[0][1015]=1014
+.[0][1016]=1015
+.[0][1017]=1016
+.[0][1018]=1017
+.[0][1019]=1018
+.[0][1020]=1019
+.[0][1021]=1020
+.[0][1022]=1021
+.[0][1023]=1022
+.[0][1024]=1023
+.[0][1025]=1024
+.[0][1026]=1025
+.[0][1027]=1026
+.[0][1028]=1027
+.[0][1029]=1028
+.[0][1030]=1029
+.[0][1031]=1030
+.[0][1032]=1031
+.[0][1033]=1032
+.[0][1034]=1033
+.[0][1035]=1034
+.[0][1036]=1035
+.[0][1037]=1036
+.[0][1038]=1037
+.[0][1039]=1038
+.[0][1040]=1039
+.[0][1041]=1040
+.[0][1042]=1041
+.[0][1043]=1042
+.[0][1044]=1043
+.[0][1045]=1044
+.[0][1046]=1045
+.[0][1047]=1046
+.[0][1048]=1047
+.[0][1049]=1048
+.[0][1050]=1049
+.[0][1051]=1050
+.[0][1052]=1051
+.[0][1053]=1052
+.[0][1054]=1053
+.[0][1055]=1054
+.[0][1056]=1055
+.[0][1057]=1056
+.[0][1058]=1057
+.[0][1059]=1058
+.[0][1060]=1059
+.[0][1061]=1060
+.[0][1062]=1061
+.[0][1063]=1062
+.[0][1064]=1063
+.[0][1065]=1064
+.[0][1066]=1065
+.[0][1067]=1066
+.[0][1068]=1067
+.[0][1069]=1068
+.[0][1070]=1069
+.[0][1071]=1070
+.[0][1072]=1071
+.[0][1073]=1072
+.[0][1074]=1073
+.[0][1075]=1074
+.[0][1076]=1075
+.[0][1077]=1076
+.[0][1078]=1077
+.[0][1079]=1078
+.[0][1080]=1079
+.[0][1081]=1080
+.[0][1082]=1081
+.[0][1083]=1082
+.[0][1084]=1083
+.[0][1085]=1084
+.[0][1086]=1085
+.[0][1087]=1086
+.[0][1088]=1087
+.[0][1089]=1088
+.[0][1090]=1089
+.[0][1091]=1090
+.[0][1092]=1091
+.[0][1093]=1092
+.[0][1094]=1093
+.[0][1095]=1094
+.[0][1096]=1095
+.[0][1097]=1096
+.[0][1098]=1097
+.[0][1099]=1098
+.[0][1100]=1099
+.[0][1101]=1100
+.[0][1102]=1101
+.[0][1103]=1102
+.[0][1104]=1103
+.[0][1105]=1104
+.[0][1106]=1105
+.[0][1107]=1106
+.[0][1108]=1107
+.[0][1109]=1108
+.[0][1110]=1109
+.[0][1111]=1110
+.[0][1112]=1111
+.[0][1113]=1112
+.[0][1114]=1113
+.[0][1115]=1114
+.[0][1116]=1115
+.[0][1117]=1116
+.[0][1118]=1117
+.[0][1119]=1118
+.[0][1120]=1119
+.[0][1121]=1120
+.[0][1122]=1121
+.[0][1123]=1122
+.[0][1124]=1123
+.[0][1125]=1124
+.[0][1126]=1125
+.[0][1127]=1126
+.[0][1128]=1127
+.[0][1129]=1128
+.[0][1130]=1129
+.[0][1131]=1130
+.[0][1132]=1131
+.[0][1133]=1132
+.[0][1134]=1133
+.[0][1135]=1134
+.[0][1136]=1135
+.[0][1137]=1136
+.[0][1138]=1137
+.[0][1139]=1138
+.[0][1140]=1139
+.[0][1141]=1140
+.[0][1142]=1141
+.[0][1143]=1142
+.[0][1144]=1143
+.[0][1145]=1144
+.[0][1146]=1145
+.[0][1147]=1146
+.[0][1148]=1147
+.[0][1149]=1148
+.[0][1150]=1149
+.[0][1151]=1150
+.[0][1152]=1151
+.[0][1153]=1152
+.[0][1154]=1153
+.[0][1155]=1154
+.[0][1156]=1155
+.[0][1157]=1156
+.[0][1158]=1157
+.[0][1159]=1158
+.[0][1160]=1159
+.[0][1161]=1160
+.[0][1162]=1161
+.[0][1163]=1162
+.[0][1164]=1163
+.[0][1165]=1164
+.[0][1166]=1165
+.[0][1167]=1166
+.[0][1168]=1167
+.[0][1169]=1168
+.[0][1170]=1169
+.[0][1171]=1170
+.[0][1172]=1171
+.[0][1173]=1172
+.[0][1174]=1173
+.[0][1175]=1174
+.[0][1176]=1175
+.[0][1177]=1176
+.[0][1178]=1177
+.[0][1179]=1178
+.[0][1180]=1179
+.[0][1181]=1180
+.[0][1182]=1181
+.[0][1183]=1182
+.[0][1184]=1183
+.[0][1185]=1184
+.[0][1186]=1185
+.[0][1187]=1186
+.[0][1188]=1187
+.[0][1189]=1188
+.[0][1190]=1189
+.[0][1191]=1190
+.[0][1192]=1191
+.[0][1193]=1192
+.[0][1194]=1193
+.[0][1195]=1194
+.[0][1196]=1195
+.[0][1197]=1196
+.[0][1198]=1197
+.[0][1199]=1198
+.[0][1200]=1199
+.[0][1201]=1200
+.[0][1202]=1201
+.[0][1203]=1202
+.[0][1204]=1203
+.[0][1205]=1204
+.[0][1206]=1205
+.[0][1207]=1206
+.[0][1208]=1207
+.[0][1209]=1208
+.[0][1210]=1209
+.[0][1211]=1210
+.[0][1212]=1211
+.[0][1213]=1212
+.[0][1214]=1213
+.[0][1215]=1214
+.[0][1216]=1215
+.[0][1217]=1216
+.[0][1218]=1217
+.[0][1219]=1218
+.[0][1220]=1219
+.[0][1221]=1220
+.[0][1222]=1221
+.[0][1223]=1222
+.[0][1224]=1223
+.[0][1225]=1224
+.[0][1226]=1225
+.[0][1227]=1226
+.[0][1228]=1227
+.[0][1229]=1228
+.[0][1230]=1229
+.[0][1231]=1230
+.[0][1232]=1231
+.[0][1233]=1232
+.[0][1234]=1233
+.[0][1235]=1234
+.[0][1236]=1235
+.[0][1237]=1236
+.[0][1238]=1237
+.[0][1239]=1238
+.[0][1240]=1239
+.[0][1241]=1240
+.[0][1242]=1241
+.[0][1243]=1242
+.[0][1244]=1243
+.[0][1245]=1244
+.[0][1246]=1245
+.[0][1247]=1246
+.[0][1248]=1247
+.[0][1249]=1248
+.[0][1250]=1249
+.[0][1251]=1250
+.[0][1252]=1251
+.[0][1253]=1252
+.[0][1254]=1253
+.[0][1255]=1254
+.[0][1256]=1255
+.[0][1257]=1256
+.[0][1258]=1257
+.[0][1259]=1258
+.[0][1260]=1259
+.[0][1261]=1260
+.[0][1262]=1261
+.[0][1263]=1262
+.[0][1264]=1263
+.[0][1265]=1264
+.[0][1266]=1265
+.[0][1267]=1266
+.[0][1268]=1267
+.[0][1269]=1268
+.[0][1270]=1269
+.[0][1271]=1270
+.[0][1272]=1271
+.[0][1273]=1272
+.[0][1274]=1273
+.[0][1275]=1274
+.[0][1276]=1275
+.[0][1277]=1276
+.[0][1278]=1277
+.[0][1279]=1278
+.[0][1280]=1279
+.[0][1281]=1280
+.[0][1282]=1281
+.[0][1283]=1282
+.[0][1284]=1283
+.[0][1285]=1284
+.[0][1286]=1285
+.[0][1287]=1286
+.[0][1288]=1287
+.[0][1289]=1288
+.[0][1290]=1289
+.[0][1291]=1290
+.[0][1292]=1291
+.[0][1293]=1292
+.[0][1294]=1293
+.[0][1295]=1294
+.[0][1296]=1295
+.[0][1297]=1296
+.[0][1298]=1297
+.[0][1299]=1298
+.[0][1300]=1299
+.[0][1301]=1300
+.[0][1302]=1301
+.[0][1303]=1302
+.[0][1304]=1303
+.[0][1305]=1304
+.[0][1306]=1305
+.[0][1307]=1306
+.[0][1308]=1307
+.[0][1309]=1308
+.[0][1310]=1309
+.[0][1311]=1310
+.[0][1312]=1311
+.[0][1313]=1312
+.[0][1314]=1313
+.[0][1315]=1314
+.[0][1316]=1315
+.[0][1317]=1316
+.[0][1318]=1317
+.[0][1319]=1318
+.[0][1320]=1319
+.[0][1321]=1320
+.[0][1322]=1321
+.[0][1323]=1322
+.[0][1324]=1323
+.[0][1325]=1324
+.[0][1326]=1325
+.[0][1327]=1326
+.[0][1328]=1327
+.[0][1329]=1328
+.[0][1330]=1329
+.[0][1331]=1330
+.[0][1332]=1331
+.[0][1333]=1332
+.[0][1334]=1333
+.[0][1335]=1334
+.[0][1336]=1335
+.[0][1337]=1336
+.[0][1338]=1337
+.[0][1339]=1338
+.[0][1340]=1339
+.[0][1341]=1340
+.[0][1342]=1341
+.[0][1343]=1342
+.[0][1344]=1343
+.[0][1345]=1344
+.[0][1346]=1345
+.[0][1347]=1346
+.[0][1348]=1347
+.[0][1349]=1348
+.[0][1350]=1349
+.[0][1351]=1350
+.[0][1352]=1351
+.[0][1353]=1352
+.[0][1354]=1353
+.[0][1355]=1354
+.[0][1356]=1355
+.[0][1357]=1356
+.[0][1358]=1357
+.[0][1359]=1358
+.[0][1360]=1359
+.[0][1361]=1360
+.[0][1362]=1361
+.[0][1363]=1362
+.[0][1364]=1363
+.[0][1365]=1364
+.[0][1366]=1365
+.[0][1367]=1366
+.[0][1368]=1367
+.[0][1369]=1368
+.[0][1370]=1369
+.[0][1371]=1370
+.[0][1372]=1371
+.[0][1373]=1372
+.[0][1374]=1373
+.[0][1375]=1374
+.[0][1376]=1375
+.[0][1377]=1376
+.[0][1378]=1377
+.[0][1379]=1378
+.[0][1380]=1379
+.[0][1381]=1380
+.[0][1382]=1381
+.[0][1383]=1382
+.[0][1384]=1383
+.[0][1385]=1384
+.[0][1386]=1385
+.[0][1387]=1386
+.[0][1388]=1387
+.[0][1389]=1388
+.[0][1390]=1389
+.[0][1391]=1390
+.[0][1392]=1391
+.[0][1393]=1392
+.[0][1394]=1393
+.[0][1395]=1394
+.[0][1396]=1395
+.[0][1397]=1396
+.[0][1398]=1397
+.[0][1399]=1398
+.[0][1400]=1399
+.[0][1401]=1400
+.[0][1402]=1401
+.[0][1403]=1402
+.[0][1404]=1403
+.[0][1405]=1404
+.[0][1406]=1405
+.[0][1407]=1406
+.[0][1408]=1407
+.[0][1409]=1408
+.[0][1410]=1409
+.[0][1411]=1410
+.[0][1412]=1411
+.[0][1413]=1412
+.[0][1414]=1413
+.[0][1415]=1414
+.[0][1416]=1415
+.[0][1417]=1416
+.[0][1418]=1417
+.[0][1419]=1418
+.[0][1420]=1419
+.[0][1421]=1420
+.[0][1422]=1421
+.[0][1423]=1422
+.[0][1424]=1423
+.[0][1425]=1424
+.[0][1426]=1425
+.[0][1427]=1426
+.[0][1428]=1427
+.[0][1429]=1428
+.[0][1430]=1429
+.[0][1431]=1430
+.[0][1432]=1431
+.[0][1433]=1432
+.[0][1434]=1433
+.[0][1435]=1434
+.[0][1436]=1435
+.[0][1437]=1436
+.[0][1438]=1437
+.[0][1439]=1438
+.[0][1440]=1439
+.[0][1441]=1440
+.[0][1442]=1441
+.[0][1443]=1442
+.[0][1444]=1443
+.[0][1445]=1444
+.[0][1446]=1445
+.[0][1447]=1446
+.[0][1448]=1447
+.[0][1449]=1448
+.[0][1450]=1449
+.[0][1451]=1450
+.[0][1452]=1451
+.[0][1453]=1452
+.[0][1454]=1453
+.[0][1455]=1454
+.[0][1456]=1455
+.[0][1457]=1456
+.[0][1458]=1457
+.[0][1459]=1458
+.[0][1460]=1459
+.[0][1461]=1460
+.[0][1462]=1461
+.[0][1463]=1462
+.[0][1464]=1463
+.[0][1465]=1464
+.[0][1466]=1465
+.[0][1467]=1466
+.[0][1468]=1467
+.[0][1469]=1468
+.[0][1470]=1469
+.[0][1471]=1470
+.[0][1472]=1471
+.[0][1473]=1472
+.[0][1474]=1473
+.[0][1475]=1474
+.[0][1476]=1475
+.[0][1477]=1476
+.[0][1478]=1477
+.[0][1479]=1478
+.[0][1480]=1479
+.[0][1481]=1480
+.[0][1482]=1481
+.[0][1483]=1482
+.[0][1484]=1483
+.[0][1485]=1484
+.[0][1486]=1485
+.[0][1487]=1486
+.[0][1488]=1487
+.[0][1489]=1488
+.[0][1490]=1489
+.[0][1491]=1490
+.[0][1492]=1491
+.[0][1493]=1492
+.[0][1494]=1493
+.[0][1495]=1494
+.[0][1496]=1495
+.[0][1497]=1496
+.[0][1498]=1497
+.[0][1499]=1498
+.[0][1500]=1499
+.[0][1501]=1500
+.[0][1502]=1501
+.[0][1503]=1502
+.[0][1504]=1503
+.[0][1505]=1504
+.[0][1506]=1505
+.[0][1507]=1506
+.[0][1508]=1507
+.[0][1509]=1508
+.[0][1510]=1509
+.[0][1511]=1510
+.[0][1512]=1511
+.[0][1513]=1512
+.[0][1514]=1513
+.[0][1515]=1514
+.[0][1516]=1515
+.[0][1517]=1516
+.[0][1518]=1517
+.[0][1519]=1518
+.[0][1520]=1519
+.[0][1521]=1520
+.[0][1522]=1521
+.[0][1523]=1522
+.[0][1524]=1523
+.[0][1525]=1524
+.[0][1526]=1525
+.[0][1527]=1526
+.[0][1528]=1527
+.[0][1529]=1528
+.[0][1530]=1529
+.[0][1531]=1530
+.[0][1532]=1531
+.[0][1533]=1532
+.[0][1534]=1533
+.[0][1535]=1534
+.[0][1536]=1535
+.[0][1537]=1536
+.[0][1538]=1537
+.[0][1539]=1538
+.[0][1540]=1539
+.[0][1541]=1540
+.[0][1542]=1541
+.[0][1543]=1542
+.[0][1544]=1543
+.[0][1545]=1544
+.[0][1546]=1545
+.[0][1547]=1546
+.[0][1548]=1547
+.[0][1549]=1548
+.[0][1550]=1549
+.[0][1551]=1550
+.[0][1552]=1551
+.[0][1553]=1552
+.[0][1554]=1553
+.[0][1555]=1554
+.[0][1556]=1555
+.[0][1557]=1556
+.[0][1558]=1557
+.[0][1559]=1558
+.[0][1560]=1559
+.[0][1561]=1560
+.[0][1562]=1561
+.[0][1563]=1562
+.[0][1564]=1563
+.[0][1565]=1564
+.[0][1566]=1565
+.[0][1567]=1566
+.[0][1568]=1567
+.[0][1569]=1568
+.[0][1570]=1569
+.[0][1571]=1570
+.[0][1572]=1571
+.[0][1573]=1572
+.[0][1574]=1573
+.[0][1575]=1574
+.[0][1576]=1575
+.[0][1577]=1576
+.[0][1578]=1577
+.[0][1579]=1578
+.[0][1580]=1579
+.[0][1581]=1580
+.[0][1582]=1581
+.[0][1583]=1582
+.[0][1584]=1583
+.[0][1585]=1584
+.[0][1586]=1585
+.[0][1587]=1586
+.[0][1588]=1587
+.[0][1589]=1588
+.[0][1590]=1589
+.[0][1591]=1590
+.[0][1592]=1591
+.[0][1593]=1592
+.[0][1594]=1593
+.[0][1595]=1594
+.[0][1596]=1595
+.[0][1597]=1596
+.[0][1598]=1597
+.[0][1599]=1598
+.[0][1600]=1599
+.[0][1601]=1600
+.[0][1602]=1601
+.[0][1603]=1602
+.[0][1604]=1603
+.[0][1605]=1604
+.[0][1606]=1605
+.[0][1607]=1606
+.[0][1608]=1607
+.[0][1609]=1608
+.[0][1610]=1609
+.[0][1611]=1610
+.[0][1612]=1611
+.[0][1613]=1612
+.[0][1614]=1613
+.[0][1615]=1614
+.[0][1616]=1615
+.[0][1617]=1616
+.[0][1618]=1617
+.[0][1619]=1618
+.[0][1620]=1619
+.[0][1621]=1620
+.[0][1622]=1621
+.[0][1623]=1622
+.[0][1624]=1623
+.[0][1625]=1624
+.[0][1626]=1625
+.[0][1627]=1626
+.[0][1628]=1627
+.[0][1629]=1628
+.[0][1630]=1629
+.[0][1631]=1630
+.[0][1632]=1631
+.[0][1633]=1632
+.[0][1634]=1633
+.[0][1635]=1634
+.[0][1636]=1635
+.[0][1637]=1636
+.[0][1638]=1637
+.[0][1639]=1638
+.[0][1640]=1639
+.[0][1641]=1640
+.[0][1642]=1641
+.[0][1643]=1642
+.[0][1644]=1643
+.[0][1645]=1644
+.[0][1646]=1645
+.[0][1647]=1646
+.[0][1648]=1647
+.[0][1649]=1648
+.[0][1650]=1649
+.[0][1651]=1650
+.[0][1652]=1651
+.[0][1653]=1652
+.[0][1654]=1653
+.[0][1655]=1654
+.[0][1656]=1655
+.[0][1657]=1656
+.[0][1658]=1657
+.[0][1659]=1658
+.[0][1660]=1659
+.[0][1661]=1660
+.[0][1662]=1661
+.[0][1663]=1662
+.[0][1664]=1663
+.[0][1665]=1664
+.[0][1666]=1665
+.[0][1667]=1666
+.[0][1668]=1667
+.[0][1669]=1668
+.[0][1670]=1669
+.[0][1671]=1670
+.[0][1672]=1671
+.[0][1673]=1672
+.[0][1674]=1673
+.[0][1675]=1674
+.[0][1676]=1675
+.[0][1677]=1676
+.[0][1678]=1677
+.[0][1679]=1678
+.[0][1680]=1679
+.[0][1681]=1680
+.[0][1682]=1681
+.[0][1683]=1682
+.[0][1684]=1683
+.[0][1685]=1684
+.[0][1686]=1685
+.[0][1687]=1686
+.[0][1688]=1687
+.[0][1689]=1688
+.[0][1690]=1689
+.[0][1691]=1690
+.[0][1692]=1691
+.[0][1693]=1692
+.[0][1694]=1693
+.[0][1695]=1694
+.[0][1696]=1695
+.[0][1697]=1696
+.[0][1698]=1697
+.[0][1699]=1698
+.[0][1700]=1699
+.[0][1701]=1700
+.[0][1702]=1701
+.[0][1703]=1702
+.[0][1704]=1703
+.[0][1705]=1704
+.[0][1706]=1705
+.[0][1707]=1706
+.[0][1708]=1707
+.[0][1709]=1708
+.[0][1710]=1709
+.[0][1711]=1710
+.[0][1712]=1711
+.[0][1713]=1712
+.[0][1714]=1713
+.[0][1715]=1714
+.[0][1716]=1715
+.[0][1717]=1716
+.[0][1718]=1717
+.[0][1719]=1718
+.[0][1720]=1719
+.[0][1721]=1720
+.[0][1722]=1721
+.[0][1723]=1722
+.[0][1724]=1723
+.[0][1725]=1724
+.[0][1726]=1725
+.[0][1727]=1726
+.[0][1728]=1727
+.[0][1729]=1728
+.[0][1730]=1729
+.[0][1731]=1730
+.[0][1732]=1731
+.[0][1733]=1732
+.[0][1734]=1733
+.[0][1735]=1734
+.[0][1736]=1735
+.[0][1737]=1736
+.[0][1738]=1737
+.[0][1739]=1738
+.[0][1740]=1739
+.[0][1741]=1740
+.[0][1742]=1741
+.[0][1743]=1742
+.[0][1744]=1743
+.[0][1745]=1744
+.[0][1746]=1745
+.[0][1747]=1746
+.[0][1748]=1747
+.[0][1749]=1748
+.[0][1750]=1749
+.[0][1751]=1750
+.[0][1752]=1751
+.[0][1753]=1752
+.[0][1754]=1753
+.[0][1755]=1754
+.[0][1756]=1755
+.[0][1757]=1756
+.[0][1758]=1757
+.[0][1759]=1758
+.[0][1760]=1759
+.[0][1761]=1760
+.[0][1762]=1761
+.[0][1763]=1762
+.[0][1764]=1763
+.[0][1765]=1764
+.[0][1766]=1765
+.[0][1767]=1766
+.[0][1768]=1767
+.[0][1769]=1768
+.[0][1770]=1769
+.[0][1771]=1770
+.[0][1772]=1771
+.[0][1773]=1772
+.[0][1774]=1773
+.[0][1775]=1774
+.[0][1776]=1775
+.[0][1777]=1776
+.[0][1778]=1777
+.[0][1779]=1778
+.[0][1780]=1779
+.[0][1781]=1780
+.[0][1782]=1781
+.[0][1783]=1782
+.[0][1784]=1783
+.[0][1785]=1784
+.[0][1786]=1785
+.[0][1787]=1786
+.[0][1788]=1787
+.[0][1789]=1788
+.[0][1790]=1789
+.[0][1791]=1790
+.[0][1792]=1791
+.[0][1793]=1792
+.[0][1794]=1793
+.[0][1795]=1794
+.[0][1796]=1795
+.[0][1797]=1796
+.[0][1798]=1797
+.[0][1799]=1798
+.[0][1800]=1799
+.[0][1801]=1800
+.[0][1802]=1801
+.[0][1803]=1802
+.[0][1804]=1803
+.[0][1805]=1804
+.[0][1806]=1805
+.[0][1807]=1806
+.[0][1808]=1807
+.[0][1809]=1808
+.[0][1810]=1809
+.[0][1811]=1810
+.[0][1812]=1811
+.[0][1813]=1812
+.[0][1814]=1813
+.[0][1815]=1814
+.[0][1816]=1815
+.[0][1817]=1816
+.[0][1818]=1817
+.[0][1819]=1818
+.[0][1820]=1819
+.[0][1821]=1820
+.[0][1822]=1821
+.[0][1823]=1822
+.[0][1824]=1823
+.[0][1825]=1824
+.[0][1826]=1825
+.[0][1827]=1826
+.[0][1828]=1827
+.[0][1829]=1828
+.[0][1830]=1829
+.[0][1831]=1830
+.[0][1832]=1831
+.[0][1833]=1832
+.[0][1834]=1833
+.[0][1835]=1834
+.[0][1836]=1835
+.[0][1837]=1836
+.[0][1838]=1837
+.[0][1839]=1838
+.[0][1840]=1839
+.[0][1841]=1840
+.[0][1842]=1841
+.[0][1843]=1842
+.[0][1844]=1843
+.[0][1845]=1844
+.[0][1846]=1845
+.[0][1847]=1846
+.[0][1848]=1847
+.[0][1849]=1848
+.[0][1850]=1849
+.[0][1851]=1850
+.[0][1852]=1851
+.[0][1853]=1852
+.[0][1854]=1853
+.[0][1855]=1854
+.[0][1856]=1855
+.[0][1857]=1856
+.[0][1858]=1857
+.[0][1859]=1858
+.[0][1860]=1859
+.[0][1861]=1860
+.[0][1862]=1861
+.[0][1863]=1862
+.[0][1864]=1863
+.[0][1865]=1864
+.[0][1866]=1865
+.[0][1867]=1866
+.[0][1868]=1867
+.[0][1869]=1868
+.[0][1870]=1869
+.[0][1871]=1870
+.[0][1872]=1871
+.[0][1873]=1872
+.[0][1874]=1873
+.[0][1875]=1874
+.[0][1876]=1875
+.[0][1877]=1876
+.[0][1878]=1877
+.[0][1879]=1878
+.[0][1880]=1879
+.[0][1881]=1880
+.[0][1882]=1881
+.[0][1883]=1882
+.[0][1884]=1883
+.[0][1885]=1884
+.[0][1886]=1885
+.[0][1887]=1886
+.[0][1888]=1887
+.[0][1889]=1888
+.[0][1890]=1889
+.[0][1891]=1890
+.[0][1892]=1891
+.[0][1893]=1892
+.[0][1894]=1893
+.[0][1895]=1894
+.[0][1896]=1895
+.[0][1897]=1896
+.[0][1898]=1897
+.[0][1899]=1898
+.[0][1900]=1899
+.[0][1901]=1900
+.[0][1902]=1901
+.[0][1903]=1902
+.[0][1904]=1903
+.[0][1905]=1904
+.[0][1906]=1905
+.[0][1907]=1906
+.[0][1908]=1907
+.[0][1909]=1908
+.[0][1910]=1909
+.[0][1911]=1910
+.[0][1912]=1911
+.[0][1913]=1912
+.[0][1914]=1913
+.[0][1915]=1914
+.[0][1916]=1915
+.[0][1917]=1916
+.[0][1918]=1917
+.[0][1919]=1918
+.[0][1920]=1919
+.[0][1921]=1920
+.[0][1922]=1921
+.[0][1923]=1922
+.[0][1924]=1923
+.[0][1925]=1924
+.[0][1926]=1925
+.[0][1927]=1926
+.[0][1928]=1927
+.[0][1929]=1928
+.[0][1930]=1929
+.[0][1931]=1930
+.[0][1932]=1931
+.[0][1933]=1932
+.[0][1934]=1933
+.[0][1935]=1934
+.[0][1936]=1935
+.[0][1937]=1936
+.[0][1938]=1937
+.[0][1939]=1938
+.[0][1940]=1939
+.[0][1941]=1940
+.[0][1942]=1941
+.[0][1943]=1942
+.[0][1944]=1943
+.[0][1945]=1944
+.[0][1946]=1945
+.[0][1947]=1946
+.[0][1948]=1947
+.[0][1949]=1948
+.[0][1950]=1949
+.[0][1951]=1950
+.[0][1952]=1951
+.[0][1953]=1952
+.[0][1954]=1953
+.[0][1955]=1954
+.[0][1956]=1955
+.[0][1957]=1956
+.[0][1958]=1957
+.[0][1959]=1958
+.[0][1960]=1959
+.[0][1961]=1960
+.[0][1962]=1961
+.[0][1963]=1962
+.[0][1964]=1963
+.[0][1965]=1964
+.[0][1966]=1965
+.[0][1967]=1966
+.[0][1968]=1967
+.[0][1969]=1968
+.[0][1970]=1969
+.[0][1971]=1970
+.[0][1972]=1971
+.[0][1973]=1972
+.[0][1974]=1973
+.[0][1975]=1974
+.[0][1976]=1975
+.[0][1977]=1976
+.[0][1978]=1977
+.[0][1979]=1978
+.[0][1980]=1979
+.[0][1981]=1980
+.[0][1982]=1981
+.[0][1983]=1982
+.[0][1984]=1983
+.[0][1985]=1984
+.[0][1986]=1985
+.[0][1987]=1986
+.[0][1988]=1987
+.[0][1989]=1988
+.[0][1990]=1989
+.[0][1991]=1990
+.[0][1992]=1991
+.[0][1993]=1992
+.[0][1994]=1993
+.[0][1995]=1994
+.[0][1996]=1995
+.[0][1997]=1996
+.[0][1998]=1997
+.[0][1999]=1998
+.[0][2000]=1999
+.[0][2001]=2000
+.[0][2002]=2001
+.[0][2003]=2002
+.[0][2004]=2003
+.[0][2005]=2004
+.[0][2006]=2005
+.[0][2007]=2006
+.[0][2008]=2007
+.[0][2009]=2008
+.[0][2010]=2009
+.[0][2011]=2010
+.[0][2012]=2011
+.[0][2013]=2012
+.[0][2014]=2013
+.[0][2015]=2014
+.[0][2016]=2015
+.[0][2017]=2016
+.[0][2018]=2017
+.[0][2019]=2018
+.[0][2020]=2019
+.[0][2021]=2020
+.[0][2022]=2021
+.[0][2023]=2022
+.[0][2024]=2023
+.[0][2025]=2024
+.[0][2026]=2025
+.[0][2027]=2026
+.[0][2028]=2027
+.[0][2029]=2028
+.[0][2030]=2029
+.[0][2031]=2030
+.[0][2032]=2031
+.[0][2033]=2032
+.[0][2034]=2033
+.[0][2035]=2034
+.[0][2036]=2035
+.[0][2037]=2036
+.[0][2038]=2037
+.[0][2039]=2038
+.[0][2040]=2039
+.[0][2041]=2040
+.[0][2042]=2041
+.[0][2043]=2042
+.[0][2044]=2043
+.[0][2045]=2044
+.[0][2046]=2045
+.[0][2047]=2046
+.[0][2048]=2047
+.[0][2049]=2048
+.[0][2050]=2049
+.[0][2051]=2050
+.[0][2052]=2051
+.[0][2053]=2052
+.[0][2054]=2053
+.[0][2055]=2054
+.[0][2056]=2055
+.[0][2057]=2056
+.[0][2058]=2057
+.[0][2059]=2058
+.[0][2060]=2059
+.[0][2061]=2060
+.[0][2062]=2061
+.[0][2063]=2062
+.[0][2064]=2063
+.[0][2065]=2064
+.[0][2066]=2065
+.[0][2067]=2066
+.[0][2068]=2067
+.[0][2069]=2068
+.[0][2070]=2069
+.[0][2071]=2070
+.[0][2072]=2071
+.[0][2073]=2072
+.[0][2074]=2073
+.[0][2075]=2074
+.[0][2076]=2075
+.[0][2077]=2076
+.[0][2078]=2077
+.[0][2079]=2078
+.[0][2080]=2079
+.[0][2081]=2080
+.[0][2082]=2081
+.[0][2083]=2082
+.[0][2084]=2083
+.[0][2085]=2084
+.[0][2086]=2085
+.[0][2087]=2086
+.[0][2088]=2087
+.[0][2089]=2088
+.[0][2090]=2089
+.[0][2091]=2090
+.[0][2092]=2091
+.[0][2093]=2092
+.[0][2094]=2093
+.[0][2095]=2094
+.[0][2096]=2095
+.[0][2097]=2096
+.[0][2098]=2097
+.[0][2099]=2098
+.[0][2100]=2099
+.[0][2101]=2100
+.[0][2102]=2101
+.[0][2103]=2102
+.[0][2104]=2103
+.[0][2105]=2104
+.[0][2106]=2105
+.[0][2107]=2106
+.[0][2108]=2107
+.[0][2109]=2108
+.[0][2110]=2109
+.[0][2111]=2110
+.[0][2112]=2111
+.[0][2113]=2112
+.[0][2114]=2113
+.[0][2115]=2114
+.[0][2116]=2115
+.[0][2117]=2116
+.[0][2118]=2117
+.[0][2119]=2118
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_large_01.json b/3rdparty/jsoncpp/src/test/data/legacy_test_large_01.json
new file mode 100644
index 00000000..e4ab4cd4
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_large_01.json
@@ -0,0 +1,2 @@
+[["A",0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,261,262,263,264,265,266,267,268,269,270,271,272,273,274,275,276,277,278,279,280,281,282,283,284,285,286,287,288,289,290,291,292,293,294,295,296,297,298,299,300,301,302,303,304,305,306,307,308,309,310,311,312,313,314,315,316,317,318,319,320,321,322,323,324,325,326,327,328,329,330,331,332,333,334,335,336,337,338,339,340,341,342,343,344,345,346,347,348,349,350,351,352,353,354,355,356,357,358,359,360,361,362,363,364,365,366,367,368,369,370,371,372,373,374,375,376,377,378,379,380,381,382,383,384,385,386,387,388,389,390,391,392,393,394,395,396,397,398,399,400,401,402,403,404,405,406,407,408,409,410,411,412,413,414,415,416,417,418,419,420,421,422,423,424,425,426,427,428,429,430,431,432,433,434,435,436,437,438,439,440,441,442,443,444,445,446,447,448,449,450,451,452,453,454,455,456,457,458,459,460,461,462,463,464,465,466,467,468,469,470,471,472,473,474,475,476,477,478,479,480,481,482,483,484,485,486,487,488,489,490,491,492,493,494,495,496,497,498,499,500,501,502,503,504,505,506,507,508,509,510,511,512,513,514,515,516,517,518,519,520,521,522,523,524,525,526,527,528,529,530,531,532,533,534,535,536,537,538,539,540,541,542,543,544,545,546,547,548,549,550,551,552,553,554,555,556,557,558,559,560,561,562,563,564,565,566,567,568,569,570,571,572,573,574,575,576,577,578,579,580,581,582,583,584,585,586,587,588,589,590,591,592,593,594,595,596,597,598,599,600,601,602,603,604,605,606,607,608,609,610,611,612,613,614,615,616,617,618,619,620,621,622,623,624,625,626,627,628,629,630,631,632,633,634,635,636,637,638,639,640,641,642,643,644,645,646,647,648,649,650,651,652,653,654,655,656,657,658,659,660,661,662,663,664,665,666,667,668,669,670,671,672,673,674,675,676,677,678,679,680,681,682,683,684,685,686,687,688,689,690,691,692,693,694,695,696,697,698,699,700,701,702,703,704,705,706,707,708,709,710,711,712,713,714,715,716,717,718,719,720,721,722,723,724,725,726,727,728,729,730,731,732,733,734,735,736,737,738,739,740,741,742,743,744,745,746,747,748,749,750,751,752,753,754,755,756,757,758,759,760,761,762,763,764,765,766,767,768,769,770,771,772,773,774,775,776,777,778,779,780,781,782,783,784,785,786,787,788,789,790,791,792,793,794,795,796,797,798,799,800,801,802,803,804,805,806,807,808,809,810,811,812,813,814,815,816,817,818,819,820,821,822,823,824,825,826,827,828,829,830,831,832,833,834,835,836,837,838,839,840,841,842,843,844,845,846,847,848,849,850,851,852,853,854,855,856,857,858,859,860,861,862,863,864,865,866,867,868,869,870,871,872,873,874,875,876,877,878,879,880,881,882,883,884,885,886,887,888,889,890,891,892,893,894,895,896,897,898,899,900,901,902,903,904,905,906,907,908,909,910,911,912,913,914,915,916,917,918,919,920,921,922,923,924,925,926,927,928,929,930,931,932,933,934,935,936,937,938,939,940,941,942,943,944,945,946,947,948,949,950,951,952,953,954,955,956,957,958,959,960,961,962,963,964,965,966,967,968,969,970,971,972,973,974,975,976,977,978,979,980,981,982,983,984,985,986,987,988,989,990,991,992,993,994,995,996,997,998,999,1000,1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1011,1012,1013,1014,1015,1016,1017,1018,1019,1020,1021,1022,1023,1024,1025,1026,1027,1028,1029,1030,1031,1032,1033,1034,1035,1036,1037,1038,1039,1040,1041,1042,1043,1044,1045,1046,1047,1048,1049,1050,1051,1052,1053,1054,1055,1056,1057,1058,1059,1060,1061,1062,1063,1064,1065,1066,1067,1068,1069,1070,1071,1072,1073,1074,1075,1076,1077,1078,1079,1080,1081,1082,1083,1084,1085,1086,1087,1088,1089,1090,1091,1092,1093,1094,1095,1096,1097,1098,1099,1100,1101,1102,1103,1104,1105,1106,1107,1108,1109,1110,1111,1112,1113,1114,1115,1116,1117,1118,1119,1120,1121,1122,1123,1124,1125,1126,1127,1128,1129,1130,1131,1132,1133,1134,1135,1136,1137,1138,1139,1140,1141,1142,1143,1144,1145,1146,1147,1148,1149,1150,1151,1152,1153,1154,1155,1156,1157,1158,1159,1160,1161,1162,1163,1164,1165,1166,1167,1168,1169,1170,1171,1172,1173,1174,1175,1176,1177,1178,1179,1180,1181,1182,1183,1184,1185,1186,1187,1188,1189,1190,1191,1192,1193,1194,1195,1196,1197,1198,1199,1200,1201,1202,1203,1204,1205,1206,1207,1208,1209,1210,1211,1212,1213,1214,1215,1216,1217,1218,1219,1220,1221,1222,1223,1224,1225,1226,1227,1228,1229,1230,1231,1232,1233,1234,1235,1236,1237,1238,1239,1240,1241,1242,1243,1244,1245,1246,1247,1248,1249,1250,1251,1252,1253,1254,1255,1256,1257,1258,1259,1260,1261,1262,1263,1264,1265,1266,1267,1268,1269,1270,1271,1272,1273,1274,1275,1276,1277,1278,1279,1280,1281,1282,1283,1284,1285,1286,1287,1288,1289,1290,1291,1292,1293,1294,1295,1296,1297,1298,1299,1300,1301,1302,1303,1304,1305,1306,1307,1308,1309,1310,1311,1312,1313,1314,1315,1316,1317,1318,1319,1320,1321,1322,1323,1324,1325,1326,1327,1328,1329,1330,1331,1332,1333,1334,1335,1336,1337,1338,1339,1340,1341,1342,1343,1344,1345,1346,1347,1348,1349,1350,1351,1352,1353,1354,1355,1356,1357,1358,1359,1360,1361,1362,1363,1364,1365,1366,1367,1368,1369,1370,1371,1372,1373,1374,1375,1376,1377,1378,1379,1380,1381,1382,1383,1384,1385,1386,1387,1388,1389,1390,1391,1392,1393,1394,1395,1396,1397,1398,1399,1400,1401,1402,1403,1404,1405,1406,1407,1408,1409,1410,1411,1412,1413,1414,1415,1416,1417,1418,1419,1420,1421,1422,1423,1424,1425,1426,1427,1428,1429,1430,1431,1432,1433,1434,1435,1436,1437,1438,1439,1440,1441,1442,1443,1444,1445,1446,1447,1448,1449,1450,1451,1452,1453,1454,1455,1456,1457,1458,1459,1460,1461,1462,1463,1464,1465,1466,1467,1468,1469,1470,1471,1472,1473,1474,1475,1476,1477,1478,1479,1480,1481,1482,1483,1484,1485,1486,1487,1488,1489,1490,1491,1492,1493,1494,1495,1496,1497,1498,1499,1500,1501,1502,1503,1504,1505,1506,1507,1508,1509,1510,1511,1512,1513,1514,1515,1516,1517,1518,1519,1520,1521,1522,1523,1524,1525,1526,1527,1528,1529,1530,1531,1532,1533,1534,1535,1536,1537,1538,1539,1540,1541,1542,1543,1544,1545,1546,1547,1548,1549,1550,1551,1552,1553,1554,1555,1556,1557,1558,1559,1560,1561,1562,1563,1564,1565,1566,1567,1568,1569,1570,1571,1572,1573,1574,1575,1576,1577,1578,1579,1580,1581,1582,1583,1584,1585,1586,1587,1588,1589,1590,1591,1592,1593,1594,1595,1596,1597,1598,1599,1600,1601,1602,1603,1604,1605,1606,1607,1608,1609,1610,1611,1612,1613,1614,1615,1616,1617,1618,1619,1620,1621,1622,1623,1624,1625,1626,1627,1628,1629,1630,1631,1632,1633,1634,1635,1636,1637,1638,1639,1640,1641,1642,1643,1644,1645,1646,1647,1648,1649,1650,1651,1652,1653,1654,1655,1656,1657,1658,1659,1660,1661,1662,1663,1664,1665,1666,1667,1668,1669,1670,1671,1672,1673,1674,1675,1676,1677,1678,1679,1680,1681,1682,1683,1684,1685,1686,1687,1688,1689,1690,1691,1692,1693,1694,1695,1696,1697,1698,1699,1700,1701,1702,1703,1704,1705,1706,1707,1708,1709,1710,1711,1712,1713,1714,1715,1716,1717,1718,1719,1720,1721,1722,1723,1724,1725,1726,1727,1728,1729,1730,1731,1732,1733,1734,1735,1736,1737,1738,1739,1740,1741,1742,1743,1744,1745,1746,1747,1748,1749,1750,1751,1752,1753,1754,1755,1756,1757,1758,1759,1760,1761,1762,1763,1764,1765,1766,1767,1768,1769,1770,1771,1772,1773,1774,1775,1776,1777,1778,1779,1780,1781,1782,1783,1784,1785,1786,1787,1788,1789,1790,1791,1792,1793,1794,1795,1796,1797,1798,1799,1800,1801,1802,1803,1804,1805,1806,1807,1808,1809,1810,1811,1812,1813,1814,1815,1816,1817,1818,1819,1820,1821,1822,1823,1824,1825,1826,1827,1828,1829,1830,1831,1832,1833,1834,1835,1836,1837,1838,1839,1840,1841,1842,1843,1844,1845,1846,1847,1848,1849,1850,1851,1852,1853,1854,1855,1856,1857,1858,1859,1860,1861,1862,1863,1864,1865,1866,1867,1868,1869,1870,1871,1872,1873,1874,1875,1876,1877,1878,1879,1880,1881,1882,1883,1884,1885,1886,1887,1888,1889,1890,1891,1892,1893,1894,1895,1896,1897,1898,1899,1900,1901,1902,1903,1904,1905,1906,1907,1908,1909,1910,1911,1912,1913,1914,1915,1916,1917,1918,1919,1920,1921,1922,1923,1924,1925,1926,1927,1928,1929,1930,1931,1932,1933,1934,1935,1936,1937,1938,1939,1940,1941,1942,1943,1944,1945,1946,1947,1948,1949,1950,1951,1952,1953,1954,1955,1956,1957,1958,1959,1960,1961,1962,1963,1964,1965,1966,1967,1968,1969,1970,1971,1972,1973,1974,1975,1976,1977,1978,1979,1980,1981,1982,1983,1984,1985,1986,1987,1988,1989,1990,1991,1992,1993,1994,1995,1996,1997,1998,1999,2000,2001,2002,2003,2004,2005,2006,2007,2008,2009,2010,2011,2012,2013,2014,2015,2016,2017,2018,2019,2020,2021,2022,2023,2024,2025,2026,2027,2028,2029,2030,2031,2032,2033,2034,2035,2036,2037,2038,2039,2040,2041,2042,2043,2044,2045,2046,2047,2048,2049,2050,2051,2052,2053,2054,2055,2056,2057,2058,2059,2060,2061,2062,2063,2064,2065,2066,2067,2068,2069,2070,2071,2072,2073,2074,2075,2076,2077,2078,2079,2080,2081,2082,2083,2084,2085,2086,2087,2088,2089,2090,2091,2092,2093,2094,2095,2096,2097,2098,2099,2100,2101,2102,2103,2104,2105,2106,2107,2108,2109,2110,2111,2112,2113,2114,2115,2116,2117,2118]
+]
\ No newline at end of file
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_object_01.expected b/3rdparty/jsoncpp/src/test/data/legacy_test_object_01.expected
new file mode 100644
index 00000000..67444e57
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_object_01.expected
@@ -0,0 +1 @@
+.={}
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_object_01.json b/3rdparty/jsoncpp/src/test/data/legacy_test_object_01.json
new file mode 100644
index 00000000..0967ef42
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_object_01.json
@@ -0,0 +1 @@
+{}
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_object_02.expected b/3rdparty/jsoncpp/src/test/data/legacy_test_object_02.expected
new file mode 100644
index 00000000..79391c2a
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_object_02.expected
@@ -0,0 +1,2 @@
+.={}
+.count=1234
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_object_02.json b/3rdparty/jsoncpp/src/test/data/legacy_test_object_02.json
new file mode 100644
index 00000000..d0f2faca
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_object_02.json
@@ -0,0 +1 @@
+{ "count" : 1234 }
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_object_03.expected b/3rdparty/jsoncpp/src/test/data/legacy_test_object_03.expected
new file mode 100644
index 00000000..5e961137
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_object_03.expected
@@ -0,0 +1,4 @@
+.={}
+.attribute="random"
+.count=1234
+.name="test"
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_object_03.json b/3rdparty/jsoncpp/src/test/data/legacy_test_object_03.json
new file mode 100644
index 00000000..90dba2af
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_object_03.json
@@ -0,0 +1,5 @@
+{
+	"count" : 1234,
+	"name" : "test",
+	"attribute" : "random"
+}
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_object_04.expected b/3rdparty/jsoncpp/src/test/data/legacy_test_object_04.expected
new file mode 100644
index 00000000..812965b0
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_object_04.expected
@@ -0,0 +1,2 @@
+.={}
+.=1234
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_object_04.json b/3rdparty/jsoncpp/src/test/data/legacy_test_object_04.json
new file mode 100644
index 00000000..9e43ff89
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_object_04.json
@@ -0,0 +1,3 @@
+{
+	"" : 1234
+}
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_preserve_comment_01.expected b/3rdparty/jsoncpp/src/test/data/legacy_test_preserve_comment_01.expected
new file mode 100644
index 00000000..d6c11b4c
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_preserve_comment_01.expected
@@ -0,0 +1,11 @@
+/* A comment
+   at the beginning of the file.
+ */
+.={}
+.first=1
+/* Comment before 'second'
+ */
+.second=2
+/* A comment at
+   the end of the file.
+ */
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_preserve_comment_01.json b/3rdparty/jsoncpp/src/test/data/legacy_test_preserve_comment_01.json
new file mode 100644
index 00000000..21b5ea7f
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_preserve_comment_01.json
@@ -0,0 +1,14 @@
+/* A comment
+   at the beginning of the file.
+ */
+{
+   "first" : 1, // comment after 'first' on the same line
+
+/* Comment before 'second'
+ */
+   "second" : 2
+}
+
+/* A comment at
+   the end of the file.
+ */
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_real_01.expected b/3rdparty/jsoncpp/src/test/data/legacy_test_real_01.expected
new file mode 100644
index 00000000..95148270
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_real_01.expected
@@ -0,0 +1,3 @@
+// 2^33 => out of integer range, switch to double
+.=8589934592
+
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_real_01.json b/3rdparty/jsoncpp/src/test/data/legacy_test_real_01.json
new file mode 100644
index 00000000..358452d3
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_real_01.json
@@ -0,0 +1,3 @@
+// 2^33 => out of integer range, switch to double
+8589934592
+
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_real_02.expected b/3rdparty/jsoncpp/src/test/data/legacy_test_real_02.expected
new file mode 100644
index 00000000..b80c0048
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_real_02.expected
@@ -0,0 +1,3 @@
+// -2^32 => out of signed integer range, switch to double
+.=-4294967295
+
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_real_02.json b/3rdparty/jsoncpp/src/test/data/legacy_test_real_02.json
new file mode 100644
index 00000000..936c706b
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_real_02.json
@@ -0,0 +1,3 @@
+// -2^32 => out of signed integer range, switch to double
+-4294967295
+
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_real_03.expected b/3rdparty/jsoncpp/src/test/data/legacy_test_real_03.expected
new file mode 100644
index 00000000..b80c0048
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_real_03.expected
@@ -0,0 +1,3 @@
+// -2^32 => out of signed integer range, switch to double
+.=-4294967295
+
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_real_03.json b/3rdparty/jsoncpp/src/test/data/legacy_test_real_03.json
new file mode 100644
index 00000000..936c706b
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_real_03.json
@@ -0,0 +1,3 @@
+// -2^32 => out of signed integer range, switch to double
+-4294967295
+
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_real_04.expected b/3rdparty/jsoncpp/src/test/data/legacy_test_real_04.expected
new file mode 100644
index 00000000..ff71a23e
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_real_04.expected
@@ -0,0 +1,3 @@
+// 1.2345678
+.=1.2345678
+
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_real_04.json b/3rdparty/jsoncpp/src/test/data/legacy_test_real_04.json
new file mode 100644
index 00000000..a8eb6d0c
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_real_04.json
@@ -0,0 +1,3 @@
+// 1.2345678
+12345678e-7
+
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_real_05.expected b/3rdparty/jsoncpp/src/test/data/legacy_test_real_05.expected
new file mode 100644
index 00000000..7a460932
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_real_05.expected
@@ -0,0 +1,4 @@
+// 1234567.8
+.=1234567.8
+
+
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_real_05.json b/3rdparty/jsoncpp/src/test/data/legacy_test_real_05.json
new file mode 100644
index 00000000..f7923bab
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_real_05.json
@@ -0,0 +1,3 @@
+// 1234567.8
+0.12345678e7
+
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_real_06.expected b/3rdparty/jsoncpp/src/test/data/legacy_test_real_06.expected
new file mode 100644
index 00000000..a4a004de
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_real_06.expected
@@ -0,0 +1,4 @@
+// -1.2345678
+.=-1.2345678
+
+
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_real_06.json b/3rdparty/jsoncpp/src/test/data/legacy_test_real_06.json
new file mode 100644
index 00000000..485419a2
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_real_06.json
@@ -0,0 +1,3 @@
+// -1.2345678
+-12345678e-7
+
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_real_07.expected b/3rdparty/jsoncpp/src/test/data/legacy_test_real_07.expected
new file mode 100644
index 00000000..dc02a895
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_real_07.expected
@@ -0,0 +1,4 @@
+// -1234567.8
+.=-1234567.8
+
+
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_real_07.json b/3rdparty/jsoncpp/src/test/data/legacy_test_real_07.json
new file mode 100644
index 00000000..8013eb5c
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_real_07.json
@@ -0,0 +1,3 @@
+// -1234567.8
+-0.12345678e7
+
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_real_08.expected b/3rdparty/jsoncpp/src/test/data/legacy_test_real_08.expected
new file mode 100644
index 00000000..b1deef91
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_real_08.expected
@@ -0,0 +1,4 @@
+// Out of 32-bit integer range, switch to double in 32-bit mode. Length the
+// same as UINT_MAX in base 10 and digit less than UINT_MAX's last digit in
+// order to catch a bug in the parsing code.
+.=4300000001
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_real_08.json b/3rdparty/jsoncpp/src/test/data/legacy_test_real_08.json
new file mode 100644
index 00000000..cca950d9
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_real_08.json
@@ -0,0 +1,4 @@
+// Out of 32-bit integer range, switch to double in 32-bit mode. Length the
+// same as UINT_MAX in base 10 and digit less than UINT_MAX's last digit in
+// order to catch a bug in the parsing code.
+4300000001
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_real_09.expected b/3rdparty/jsoncpp/src/test/data/legacy_test_real_09.expected
new file mode 100644
index 00000000..aa2dbb28
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_real_09.expected
@@ -0,0 +1,4 @@
+// Out of 64-bit integer range, switch to double in all modes. Length the same
+// as ULONG_MAX in base 10 and digit less than ULONG_MAX's last digit in order
+// to catch a bug in the parsing code.
+.=1.9e+19
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_real_09.json b/3rdparty/jsoncpp/src/test/data/legacy_test_real_09.json
new file mode 100644
index 00000000..e65d50c9
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_real_09.json
@@ -0,0 +1,4 @@
+// Out of 64-bit integer range, switch to double in all modes. Length the same
+// as ULONG_MAX in base 10 and digit less than ULONG_MAX's last digit in order
+// to catch a bug in the parsing code.
+19000000000000000001
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_real_10.expected b/3rdparty/jsoncpp/src/test/data/legacy_test_real_10.expected
new file mode 100644
index 00000000..d28a430e
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_real_10.expected
@@ -0,0 +1,4 @@
+// Out of 32-bit signed integer range, switch to double in all modes. Length
+// the same as INT_MIN in base 10 and digit less than INT_MIN's last digit in
+// order to catch a bug in the parsing code.
+.=-2200000001
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_real_10.json b/3rdparty/jsoncpp/src/test/data/legacy_test_real_10.json
new file mode 100644
index 00000000..a6a8bcef
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_real_10.json
@@ -0,0 +1,4 @@
+// Out of 32-bit signed integer range, switch to double in all modes. Length
+// the same as INT_MIN in base 10 and digit less than INT_MIN's last digit in
+// order to catch a bug in the parsing code.
+-2200000001
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_real_11.expected b/3rdparty/jsoncpp/src/test/data/legacy_test_real_11.expected
new file mode 100644
index 00000000..2551946f
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_real_11.expected
@@ -0,0 +1,4 @@
+// Out of 64-bit signed integer range, switch to double in all modes. Length
+// the same as LONG_MIN in base 10 and digit less than LONG_MIN's last digit in
+// order to catch a bug in the parsing code.
+.=-9.3e+18
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_real_11.json b/3rdparty/jsoncpp/src/test/data/legacy_test_real_11.json
new file mode 100644
index 00000000..63cdb36f
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_real_11.json
@@ -0,0 +1,4 @@
+// Out of 64-bit signed integer range, switch to double in all modes. Length
+// the same as LONG_MIN in base 10 and digit less than LONG_MIN's last digit in
+// order to catch a bug in the parsing code.
+-9300000000000000001
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_real_12.expected b/3rdparty/jsoncpp/src/test/data/legacy_test_real_12.expected
new file mode 100644
index 00000000..93e2417d
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_real_12.expected
@@ -0,0 +1,2 @@
+// 2^64 -> switch to double.
+.=1.844674407370955e+19
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_real_12.json b/3rdparty/jsoncpp/src/test/data/legacy_test_real_12.json
new file mode 100644
index 00000000..0a13eed2
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_real_12.json
@@ -0,0 +1,2 @@
+// 2^64 -> switch to double.
+18446744073709551616
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_string_01.expected b/3rdparty/jsoncpp/src/test/data/legacy_test_string_01.expected
new file mode 100644
index 00000000..8fd37b1e
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_string_01.expected
@@ -0,0 +1 @@
+.="!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~"
\ No newline at end of file
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_string_01.json b/3rdparty/jsoncpp/src/test/data/legacy_test_string_01.json
new file mode 100644
index 00000000..6cd0db44
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_string_01.json
@@ -0,0 +1 @@
+"!\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~"
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_string_02.expected b/3rdparty/jsoncpp/src/test/data/legacy_test_string_02.expected
new file mode 100644
index 00000000..0443bc36
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_string_02.expected
@@ -0,0 +1 @@
+.="!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~"
\ No newline at end of file
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_string_02.json b/3rdparty/jsoncpp/src/test/data/legacy_test_string_02.json
new file mode 100644
index 00000000..9a7e5dca
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_string_02.json
@@ -0,0 +1 @@
+"!\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~!\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~!\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~!\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~!\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~!\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~!\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~!\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~!\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~!\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~!\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~!\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~!\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~!\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~!\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~!\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~!\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~!\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~!\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~!\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~"
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_string_03.expected b/3rdparty/jsoncpp/src/test/data/legacy_test_string_03.expected
new file mode 100644
index 00000000..6ed627a8
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_string_03.expected
@@ -0,0 +1 @@
+.="http://jsoncpp.sourceforge.net/"
\ No newline at end of file
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_string_03.json b/3rdparty/jsoncpp/src/test/data/legacy_test_string_03.json
new file mode 100644
index 00000000..2d38180a
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_string_03.json
@@ -0,0 +1 @@
+"http:\/\/jsoncpp.sourceforge.net\/"
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_string_04.expected b/3rdparty/jsoncpp/src/test/data/legacy_test_string_04.expected
new file mode 100644
index 00000000..f57d5256
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_string_04.expected
@@ -0,0 +1,2 @@
+.=""abc\def""
+
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_string_04.json b/3rdparty/jsoncpp/src/test/data/legacy_test_string_04.json
new file mode 100644
index 00000000..01fe7524
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_string_04.json
@@ -0,0 +1,2 @@
+"\"abc\\def\""
+
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_string_05.expected b/3rdparty/jsoncpp/src/test/data/legacy_test_string_05.expected
new file mode 100644
index 00000000..9794dddb
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_string_05.expected
@@ -0,0 +1,2 @@
+.="\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\"
+
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_string_05.json b/3rdparty/jsoncpp/src/test/data/legacy_test_string_05.json
new file mode 100644
index 00000000..e156024d
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_string_05.json
@@ -0,0 +1,2 @@
+"\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\"
+
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_string_unicode_01.expected b/3rdparty/jsoncpp/src/test/data/legacy_test_string_unicode_01.expected
new file mode 100644
index 00000000..1f3be7fb
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_string_unicode_01.expected
@@ -0,0 +1 @@
+.="a"
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_string_unicode_01.json b/3rdparty/jsoncpp/src/test/data/legacy_test_string_unicode_01.json
new file mode 100644
index 00000000..024114bc
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_string_unicode_01.json
@@ -0,0 +1 @@
+"\u0061"
\ No newline at end of file
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_string_unicode_02.expected b/3rdparty/jsoncpp/src/test/data/legacy_test_string_unicode_02.expected
new file mode 100644
index 00000000..1388f539
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_string_unicode_02.expected
@@ -0,0 +1 @@
+.="¢"
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_string_unicode_02.json b/3rdparty/jsoncpp/src/test/data/legacy_test_string_unicode_02.json
new file mode 100644
index 00000000..4961024f
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_string_unicode_02.json
@@ -0,0 +1 @@
+"\u00A2"
\ No newline at end of file
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_string_unicode_03.expected b/3rdparty/jsoncpp/src/test/data/legacy_test_string_unicode_03.expected
new file mode 100644
index 00000000..9b80b271
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_string_unicode_03.expected
@@ -0,0 +1 @@
+.="€"
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_string_unicode_03.json b/3rdparty/jsoncpp/src/test/data/legacy_test_string_unicode_03.json
new file mode 100644
index 00000000..e7e1a9e1
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_string_unicode_03.json
@@ -0,0 +1 @@
+"\u20AC"
\ No newline at end of file
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_string_unicode_04.expected b/3rdparty/jsoncpp/src/test/data/legacy_test_string_unicode_04.expected
new file mode 100644
index 00000000..b9e7fe3b
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_string_unicode_04.expected
@@ -0,0 +1 @@
+.="𝄞"
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_string_unicode_04.json b/3rdparty/jsoncpp/src/test/data/legacy_test_string_unicode_04.json
new file mode 100644
index 00000000..dae65c51
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_string_unicode_04.json
@@ -0,0 +1 @@
+"\uD834\uDD1E"
\ No newline at end of file
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_string_unicode_05.expected b/3rdparty/jsoncpp/src/test/data/legacy_test_string_unicode_05.expected
new file mode 100644
index 00000000..c2e67f99
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_string_unicode_05.expected
@@ -0,0 +1,2 @@
+.="Zażółć gęślą jaźń"
+
diff --git a/3rdparty/jsoncpp/src/test/data/legacy_test_string_unicode_05.json b/3rdparty/jsoncpp/src/test/data/legacy_test_string_unicode_05.json
new file mode 100644
index 00000000..87704109
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/legacy_test_string_unicode_05.json
@@ -0,0 +1 @@
+"Zażółć gęślą jaźń"
\ No newline at end of file
diff --git a/3rdparty/jsoncpp/src/test/data/test_array_08.expected b/3rdparty/jsoncpp/src/test/data/test_array_08.expected
new file mode 100644
index 00000000..ef1f2623
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/test_array_08.expected
@@ -0,0 +1,2 @@
+.=[]
+.[0]=1
diff --git a/3rdparty/jsoncpp/src/test/data/test_array_08.json b/3rdparty/jsoncpp/src/test/data/test_array_08.json
new file mode 100644
index 00000000..e8b1a170
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/test_array_08.json
@@ -0,0 +1 @@
+[1,]
diff --git a/3rdparty/jsoncpp/src/test/data/test_object_05.expected b/3rdparty/jsoncpp/src/test/data/test_object_05.expected
new file mode 100644
index 00000000..79391c2a
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/test_object_05.expected
@@ -0,0 +1,2 @@
+.={}
+.count=1234
diff --git a/3rdparty/jsoncpp/src/test/data/test_object_05.json b/3rdparty/jsoncpp/src/test/data/test_object_05.json
new file mode 100644
index 00000000..c4344b17
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/data/test_object_05.json
@@ -0,0 +1 @@
+{ "count" : 1234, }
diff --git a/3rdparty/jsoncpp/src/test/generate_expected.py b/3rdparty/jsoncpp/src/test/generate_expected.py
new file mode 100644
index 00000000..e049ab5f
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/generate_expected.py
@@ -0,0 +1,17 @@
+# Copyright 2007 Baptiste Lepilleur and The JsonCpp Authors
+# Distributed under MIT license, or public domain if desired and
+# recognized in your jurisdiction.
+# See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+from __future__ import print_function
+import glob
+import os.path
+for path in glob.glob('*.json'):
+    text = file(path,'rt').read()
+    target = os.path.splitext(path)[0] + '.expected'
+    if os.path.exists(target):
+        print('skipping:', target)
+    else:
+        print('creating:', target)
+        file(target,'wt').write(text)
+
diff --git a/3rdparty/jsoncpp/src/test/jsonchecker/fail1.json b/3rdparty/jsoncpp/src/test/jsonchecker/fail1.json
new file mode 100644
index 00000000..6216b865
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/jsonchecker/fail1.json
@@ -0,0 +1 @@
+"A JSON payload should be an object or array, not a string."
\ No newline at end of file
diff --git a/3rdparty/jsoncpp/src/test/jsonchecker/fail10.json b/3rdparty/jsoncpp/src/test/jsonchecker/fail10.json
new file mode 100644
index 00000000..5d8c0047
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/jsonchecker/fail10.json
@@ -0,0 +1 @@
+{"Extra value after close": true} "misplaced quoted value"
\ No newline at end of file
diff --git a/3rdparty/jsoncpp/src/test/jsonchecker/fail11.json b/3rdparty/jsoncpp/src/test/jsonchecker/fail11.json
new file mode 100644
index 00000000..76eb95b4
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/jsonchecker/fail11.json
@@ -0,0 +1 @@
+{"Illegal expression": 1 + 2}
\ No newline at end of file
diff --git a/3rdparty/jsoncpp/src/test/jsonchecker/fail12.json b/3rdparty/jsoncpp/src/test/jsonchecker/fail12.json
new file mode 100644
index 00000000..77580a45
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/jsonchecker/fail12.json
@@ -0,0 +1 @@
+{"Illegal invocation": alert()}
\ No newline at end of file
diff --git a/3rdparty/jsoncpp/src/test/jsonchecker/fail13.json b/3rdparty/jsoncpp/src/test/jsonchecker/fail13.json
new file mode 100644
index 00000000..379406b5
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/jsonchecker/fail13.json
@@ -0,0 +1 @@
+{"Numbers cannot have leading zeroes": 013}
\ No newline at end of file
diff --git a/3rdparty/jsoncpp/src/test/jsonchecker/fail14.json b/3rdparty/jsoncpp/src/test/jsonchecker/fail14.json
new file mode 100644
index 00000000..0ed366b3
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/jsonchecker/fail14.json
@@ -0,0 +1 @@
+{"Numbers cannot be hex": 0x14}
\ No newline at end of file
diff --git a/3rdparty/jsoncpp/src/test/jsonchecker/fail15.json b/3rdparty/jsoncpp/src/test/jsonchecker/fail15.json
new file mode 100644
index 00000000..fc8376b6
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/jsonchecker/fail15.json
@@ -0,0 +1 @@
+["Illegal backslash escape: \x15"]
\ No newline at end of file
diff --git a/3rdparty/jsoncpp/src/test/jsonchecker/fail16.json b/3rdparty/jsoncpp/src/test/jsonchecker/fail16.json
new file mode 100644
index 00000000..3fe21d4b
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/jsonchecker/fail16.json
@@ -0,0 +1 @@
+[\naked]
\ No newline at end of file
diff --git a/3rdparty/jsoncpp/src/test/jsonchecker/fail17.json b/3rdparty/jsoncpp/src/test/jsonchecker/fail17.json
new file mode 100644
index 00000000..62b9214a
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/jsonchecker/fail17.json
@@ -0,0 +1 @@
+["Illegal backslash escape: \017"]
\ No newline at end of file
diff --git a/3rdparty/jsoncpp/src/test/jsonchecker/fail18.json b/3rdparty/jsoncpp/src/test/jsonchecker/fail18.json
new file mode 100644
index 00000000..edac9271
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/jsonchecker/fail18.json
@@ -0,0 +1 @@
+[[[[[[[[[[[[[[[[[[[["Too deep"]]]]]]]]]]]]]]]]]]]]
\ No newline at end of file
diff --git a/3rdparty/jsoncpp/src/test/jsonchecker/fail19.json b/3rdparty/jsoncpp/src/test/jsonchecker/fail19.json
new file mode 100644
index 00000000..3b9c46fa
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/jsonchecker/fail19.json
@@ -0,0 +1 @@
+{"Missing colon" null}
\ No newline at end of file
diff --git a/3rdparty/jsoncpp/src/test/jsonchecker/fail2.json b/3rdparty/jsoncpp/src/test/jsonchecker/fail2.json
new file mode 100644
index 00000000..6b7c11e5
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/jsonchecker/fail2.json
@@ -0,0 +1 @@
+["Unclosed array"
\ No newline at end of file
diff --git a/3rdparty/jsoncpp/src/test/jsonchecker/fail20.json b/3rdparty/jsoncpp/src/test/jsonchecker/fail20.json
new file mode 100644
index 00000000..27c1af3e
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/jsonchecker/fail20.json
@@ -0,0 +1 @@
+{"Double colon":: null}
\ No newline at end of file
diff --git a/3rdparty/jsoncpp/src/test/jsonchecker/fail21.json b/3rdparty/jsoncpp/src/test/jsonchecker/fail21.json
new file mode 100644
index 00000000..62474573
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/jsonchecker/fail21.json
@@ -0,0 +1 @@
+{"Comma instead of colon", null}
\ No newline at end of file
diff --git a/3rdparty/jsoncpp/src/test/jsonchecker/fail22.json b/3rdparty/jsoncpp/src/test/jsonchecker/fail22.json
new file mode 100644
index 00000000..a7752581
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/jsonchecker/fail22.json
@@ -0,0 +1 @@
+["Colon instead of comma": false]
\ No newline at end of file
diff --git a/3rdparty/jsoncpp/src/test/jsonchecker/fail23.json b/3rdparty/jsoncpp/src/test/jsonchecker/fail23.json
new file mode 100644
index 00000000..494add1c
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/jsonchecker/fail23.json
@@ -0,0 +1 @@
+["Bad value", truth]
\ No newline at end of file
diff --git a/3rdparty/jsoncpp/src/test/jsonchecker/fail24.json b/3rdparty/jsoncpp/src/test/jsonchecker/fail24.json
new file mode 100644
index 00000000..caff239b
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/jsonchecker/fail24.json
@@ -0,0 +1 @@
+['single quote']
\ No newline at end of file
diff --git a/3rdparty/jsoncpp/src/test/jsonchecker/fail25.json b/3rdparty/jsoncpp/src/test/jsonchecker/fail25.json
new file mode 100644
index 00000000..8b7ad23e
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/jsonchecker/fail25.json
@@ -0,0 +1 @@
+["	tab	character	in	string	"]
\ No newline at end of file
diff --git a/3rdparty/jsoncpp/src/test/jsonchecker/fail26.json b/3rdparty/jsoncpp/src/test/jsonchecker/fail26.json
new file mode 100644
index 00000000..845d26a6
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/jsonchecker/fail26.json
@@ -0,0 +1 @@
+["tab\   character\   in\  string\  "]
\ No newline at end of file
diff --git a/3rdparty/jsoncpp/src/test/jsonchecker/fail27.json b/3rdparty/jsoncpp/src/test/jsonchecker/fail27.json
new file mode 100644
index 00000000..6b01a2ca
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/jsonchecker/fail27.json
@@ -0,0 +1,2 @@
+["line
+break"]
\ No newline at end of file
diff --git a/3rdparty/jsoncpp/src/test/jsonchecker/fail28.json b/3rdparty/jsoncpp/src/test/jsonchecker/fail28.json
new file mode 100644
index 00000000..621a0101
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/jsonchecker/fail28.json
@@ -0,0 +1,2 @@
+["line\
+break"]
\ No newline at end of file
diff --git a/3rdparty/jsoncpp/src/test/jsonchecker/fail29.json b/3rdparty/jsoncpp/src/test/jsonchecker/fail29.json
new file mode 100644
index 00000000..47ec421b
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/jsonchecker/fail29.json
@@ -0,0 +1 @@
+[0e]
\ No newline at end of file
diff --git a/3rdparty/jsoncpp/src/test/jsonchecker/fail3.json b/3rdparty/jsoncpp/src/test/jsonchecker/fail3.json
new file mode 100644
index 00000000..168c81eb
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/jsonchecker/fail3.json
@@ -0,0 +1 @@
+{unquoted_key: "keys must be quoted"}
\ No newline at end of file
diff --git a/3rdparty/jsoncpp/src/test/jsonchecker/fail30.json b/3rdparty/jsoncpp/src/test/jsonchecker/fail30.json
new file mode 100644
index 00000000..8ab0bc4b
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/jsonchecker/fail30.json
@@ -0,0 +1 @@
+[0e+]
\ No newline at end of file
diff --git a/3rdparty/jsoncpp/src/test/jsonchecker/fail31.json b/3rdparty/jsoncpp/src/test/jsonchecker/fail31.json
new file mode 100644
index 00000000..1cce602b
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/jsonchecker/fail31.json
@@ -0,0 +1 @@
+[0e+-1]
\ No newline at end of file
diff --git a/3rdparty/jsoncpp/src/test/jsonchecker/fail32.json b/3rdparty/jsoncpp/src/test/jsonchecker/fail32.json
new file mode 100644
index 00000000..45cba739
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/jsonchecker/fail32.json
@@ -0,0 +1 @@
+{"Comma instead if closing brace": true,
\ No newline at end of file
diff --git a/3rdparty/jsoncpp/src/test/jsonchecker/fail33.json b/3rdparty/jsoncpp/src/test/jsonchecker/fail33.json
new file mode 100644
index 00000000..ca5eb19d
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/jsonchecker/fail33.json
@@ -0,0 +1 @@
+["mismatch"}
\ No newline at end of file
diff --git a/3rdparty/jsoncpp/src/test/jsonchecker/fail4.json b/3rdparty/jsoncpp/src/test/jsonchecker/fail4.json
new file mode 100644
index 00000000..9de168bf
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/jsonchecker/fail4.json
@@ -0,0 +1 @@
+["extra comma",]
\ No newline at end of file
diff --git a/3rdparty/jsoncpp/src/test/jsonchecker/fail5.json b/3rdparty/jsoncpp/src/test/jsonchecker/fail5.json
new file mode 100644
index 00000000..ddf3ce3d
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/jsonchecker/fail5.json
@@ -0,0 +1 @@
+["double extra comma",,]
\ No newline at end of file
diff --git a/3rdparty/jsoncpp/src/test/jsonchecker/fail6.json b/3rdparty/jsoncpp/src/test/jsonchecker/fail6.json
new file mode 100644
index 00000000..ed91580e
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/jsonchecker/fail6.json
@@ -0,0 +1 @@
+[   , "<-- missing value"]
\ No newline at end of file
diff --git a/3rdparty/jsoncpp/src/test/jsonchecker/fail7.json b/3rdparty/jsoncpp/src/test/jsonchecker/fail7.json
new file mode 100644
index 00000000..8a96af3e
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/jsonchecker/fail7.json
@@ -0,0 +1 @@
+["Comma after the close"],
\ No newline at end of file
diff --git a/3rdparty/jsoncpp/src/test/jsonchecker/fail8.json b/3rdparty/jsoncpp/src/test/jsonchecker/fail8.json
new file mode 100644
index 00000000..b28479c6
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/jsonchecker/fail8.json
@@ -0,0 +1 @@
+["Extra close"]]
\ No newline at end of file
diff --git a/3rdparty/jsoncpp/src/test/jsonchecker/fail9.json b/3rdparty/jsoncpp/src/test/jsonchecker/fail9.json
new file mode 100644
index 00000000..5815574f
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/jsonchecker/fail9.json
@@ -0,0 +1 @@
+{"Extra comma": true,}
\ No newline at end of file
diff --git a/3rdparty/jsoncpp/src/test/jsonchecker/pass1.json b/3rdparty/jsoncpp/src/test/jsonchecker/pass1.json
new file mode 100644
index 00000000..70e26854
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/jsonchecker/pass1.json
@@ -0,0 +1,58 @@
+[
+    "JSON Test Pattern pass1",
+    {"object with 1 member":["array with 1 element"]},
+    {},
+    [],
+    -42,
+    true,
+    false,
+    null,
+    {
+        "integer": 1234567890,
+        "real": -9876.543210,
+        "e": 0.123456789e-12,
+        "E": 1.234567890E+34,
+        "":  23456789012E66,
+        "zero": 0,
+        "one": 1,
+        "space": " ",
+        "quote": "\"",
+        "backslash": "\\",
+        "controls": "\b\f\n\r\t",
+        "slash": "/ & \/",
+        "alpha": "abcdefghijklmnopqrstuvwyz",
+        "ALPHA": "ABCDEFGHIJKLMNOPQRSTUVWYZ",
+        "digit": "0123456789",
+        "0123456789": "digit",
+        "special": "`1~!@#$%^&*()_+-={':[,]}|;.</>?",
+        "hex": "\u0123\u4567\u89AB\uCDEF\uabcd\uef4A",
+        "true": true,
+        "false": false,
+        "null": null,
+        "array":[  ],
+        "object":{  },
+        "address": "50 St. James Street",
+        "url": "http://www.JSON.org/",
+        "comment": "// /* <!-- --",
+        "# -- --> */": " ",
+        " s p a c e d " :[1,2 , 3
+
+,
+
+4 , 5        ,          6           ,7        ],"compact":[1,2,3,4,5,6,7],
+        "jsontext": "{\"object with 1 member\":[\"array with 1 element\"]}",
+        "quotes": "&#34; \u0022 %22 0x22 034 &#x22;",
+        "\/\\\"\uCAFE\uBABE\uAB98\uFCDE\ubcda\uef4A\b\f\n\r\t`1~!@#$%^&*()_+-=[]{}|;:',./<>?"
+: "A key can be any string"
+    },
+    0.5 ,98.6
+,
+99.44
+,
+
+1066,
+1e1,
+0.1e1,
+1e-1,
+1e00,2e+00,2e-00
+,"rosebud"]
\ No newline at end of file
diff --git a/3rdparty/jsoncpp/src/test/jsonchecker/pass2.json b/3rdparty/jsoncpp/src/test/jsonchecker/pass2.json
new file mode 100644
index 00000000..d3c63c7a
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/jsonchecker/pass2.json
@@ -0,0 +1 @@
+[[[[[[[[[[[[[[[[[[["Not too deep"]]]]]]]]]]]]]]]]]]]
\ No newline at end of file
diff --git a/3rdparty/jsoncpp/src/test/jsonchecker/pass3.json b/3rdparty/jsoncpp/src/test/jsonchecker/pass3.json
new file mode 100644
index 00000000..4528d51f
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/jsonchecker/pass3.json
@@ -0,0 +1,6 @@
+{
+    "JSON Test Pattern pass3": {
+        "The outermost value": "must be an object or array.",
+        "In this test": "It is an object."
+    }
+}
diff --git a/3rdparty/jsoncpp/src/test/jsonchecker/readme.txt b/3rdparty/jsoncpp/src/test/jsonchecker/readme.txt
new file mode 100644
index 00000000..321d89d9
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/jsonchecker/readme.txt
@@ -0,0 +1,3 @@
+Test suite from http://json.org/JSON_checker/.
+
+If the JSON_checker is working correctly, it must accept all of the pass*.json files and reject all of the fail*.json files.
diff --git a/3rdparty/jsoncpp/src/test/pyjsontestrunner.py b/3rdparty/jsoncpp/src/test/pyjsontestrunner.py
new file mode 100644
index 00000000..8acdbd2d
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/pyjsontestrunner.py
@@ -0,0 +1,71 @@
+# Copyright 2007 Baptiste Lepilleur and The JsonCpp Authors
+# Distributed under MIT license, or public domain if desired and
+# recognized in your jurisdiction.
+# See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+"""Simple implementation of a json test runner to run the test against
+json-py."""
+
+from __future__ import print_function
+import sys
+import os.path
+import json
+import types
+
+if len(sys.argv) != 2:
+    print("Usage: %s input-json-file", sys.argv[0])
+    sys.exit(3)
+
+input_path = sys.argv[1]
+base_path = os.path.splitext(input_path)[0]
+actual_path = base_path + '.actual'
+rewrite_path = base_path + '.rewrite'
+rewrite_actual_path = base_path + '.actual-rewrite'
+
+def valueTreeToString(fout, value, path = '.'):
+    ty = type(value)
+    if ty  is types.DictType:
+        fout.write('%s={}\n' % path)
+        suffix = path[-1] != '.' and '.' or ''
+        names = value.keys()
+        names.sort()
+        for name in names:
+            valueTreeToString(fout, value[name], path + suffix + name)
+    elif ty is types.ListType:
+        fout.write('%s=[]\n' % path)
+        for index, childValue in zip(xrange(0,len(value)), value):
+            valueTreeToString(fout, childValue, path + '[%d]' % index)
+    elif ty is types.StringType:
+        fout.write('%s="%s"\n' % (path,value))
+    elif ty is types.IntType:
+        fout.write('%s=%d\n' % (path,value))
+    elif ty is types.FloatType:
+        fout.write('%s=%.16g\n' % (path,value))
+    elif value is True:
+        fout.write('%s=true\n' % path)
+    elif value is False:
+        fout.write('%s=false\n' % path)
+    elif value is None:
+        fout.write('%s=null\n' % path)
+    else:
+        assert False and "Unexpected value type"
+
+def parseAndSaveValueTree(input, actual_path):
+    root = json.loads(input)
+    fout = file(actual_path, 'wt')
+    valueTreeToString(fout, root)
+    fout.close()
+    return root
+
+def rewriteValueTree(value, rewrite_path):
+    rewrite = json.dumps(value)
+    #rewrite = rewrite[1:-1]  # Somehow the string is quoted ! jsonpy bug ?
+    file(rewrite_path, 'wt').write(rewrite + '\n')
+    return rewrite
+
+input = file(input_path, 'rt').read()
+root = parseAndSaveValueTree(input, actual_path)
+rewrite = rewriteValueTree(json.write(root), rewrite_path)
+rewrite_root = parseAndSaveValueTree(rewrite, rewrite_actual_path)
+
+sys.exit(0)
diff --git a/3rdparty/jsoncpp/src/test/runjsontests.py b/3rdparty/jsoncpp/src/test/runjsontests.py
new file mode 100644
index 00000000..5496e2c5
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/runjsontests.py
@@ -0,0 +1,191 @@
+# Copyright 2007 Baptiste Lepilleur and The JsonCpp Authors
+# Distributed under MIT license, or public domain if desired and
+# recognized in your jurisdiction.
+# See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+from __future__ import print_function
+from __future__ import unicode_literals
+from io import open
+from glob import glob
+import sys
+import os
+import os.path
+import optparse
+
+VALGRIND_CMD = 'valgrind --tool=memcheck --leak-check=yes --undef-value-errors=yes '
+
+def getStatusOutput(cmd):
+    """
+    Return int, unicode (for both Python 2 and 3).
+    Note: os.popen().close() would return None for 0.
+    """
+    print(cmd, file=sys.stderr)
+    pipe = os.popen(cmd)
+    process_output = pipe.read()
+    try:
+        # We have been using os.popen(). When we read() the result
+        # we get 'str' (bytes) in py2, and 'str' (unicode) in py3.
+        # Ugh! There must be a better way to handle this.
+        process_output = process_output.decode('utf-8')
+    except AttributeError:
+        pass  # python3
+    status = pipe.close()
+    return status, process_output
+def compareOutputs(expected, actual, message):
+    expected = expected.strip().replace('\r','').split('\n')
+    actual = actual.strip().replace('\r','').split('\n')
+    diff_line = 0
+    max_line_to_compare = min(len(expected), len(actual))
+    for index in range(0,max_line_to_compare):
+        if expected[index].strip() != actual[index].strip():
+            diff_line = index + 1
+            break
+    if diff_line == 0 and len(expected) != len(actual):
+        diff_line = max_line_to_compare+1
+    if diff_line == 0:
+        return None
+    def safeGetLine(lines, index):
+        index += -1
+        if index >= len(lines):
+            return ''
+        return lines[index].strip()
+    return """  Difference in %s at line %d:
+  Expected: '%s'
+  Actual:   '%s'
+""" % (message, diff_line,
+       safeGetLine(expected,diff_line),
+       safeGetLine(actual,diff_line))
+
+def safeReadFile(path):
+    try:
+        return open(path, 'rt', encoding = 'utf-8').read()
+    except IOError as e:
+        return '<File "%s" is missing: %s>' % (path,e)
+
+class FailError(Exception):
+    def __init__(self, msg):
+        super(Exception, self).__init__(msg)
+
+def runAllTests(jsontest_executable_path, input_dir = None,
+                 use_valgrind=False, with_json_checker=False,
+                 writerClass='StyledWriter'):
+    if not input_dir:
+        input_dir = os.path.join(os.getcwd(), 'data')
+    tests = glob(os.path.join(input_dir, '*.json'))
+    if with_json_checker:
+        all_tests = glob(os.path.join(input_dir, '../jsonchecker', '*.json'))
+        # These tests fail with strict json support, but pass with JsonCPP's
+        # extra leniency features. When adding a new exclusion to this list,
+        # remember to add the test's number and reasoning here:
+        known = ["fail{}.json".format(n) for n in [
+            4, 9, # fail because we allow trailing commas
+            7,    # fails because we allow commas after close
+            8,    # fails because we allow extra close
+            10,   # fails because we allow extra values after close
+            13,   # fails because we allow leading zeroes in numbers
+            18,   # fails because we allow deeply nested values
+            25,   # fails because we allow tab characters in strings
+            27,   # fails because we allow string line breaks
+        ]]
+        test_jsonchecker = [ test for test in all_tests
+                             if os.path.basename(test) not in known]
+
+    else:
+        test_jsonchecker = []
+
+    failed_tests = []
+    valgrind_path = use_valgrind and VALGRIND_CMD or ''
+    for input_path in tests + test_jsonchecker:
+        expect_failure = os.path.basename(input_path).startswith('fail')
+        is_json_checker_test = (input_path in test_jsonchecker) or expect_failure
+        print('TESTING:', input_path, end=' ')
+        options = is_json_checker_test and '--json-checker' or ''
+        options += ' --json-writer %s'%writerClass
+        cmd = '%s%s %s "%s"' % (            valgrind_path, jsontest_executable_path, options,
+            input_path)
+        status, process_output = getStatusOutput(cmd)
+        if is_json_checker_test:
+            if expect_failure:
+                if not status:
+                    print('FAILED')
+                    failed_tests.append((input_path, 'Parsing should have failed:\n%s' %
+                                          safeReadFile(input_path)))
+                else:
+                    print('OK')
+            else:
+                if status:
+                    print('FAILED')
+                    failed_tests.append((input_path, 'Parsing failed:\n' + process_output))
+                else:
+                    print('OK')
+        else:
+            base_path = os.path.splitext(input_path)[0]
+            actual_output = safeReadFile(base_path + '.actual')
+            actual_rewrite_output = safeReadFile(base_path + '.actual-rewrite')
+            open(base_path + '.process-output', 'wt', encoding = 'utf-8').write(process_output)
+            if status:
+                print('parsing failed')
+                failed_tests.append((input_path, 'Parsing failed:\n' + process_output))
+            else:
+                expected_output_path = os.path.splitext(input_path)[0] + '.expected'
+                expected_output = open(expected_output_path, 'rt', encoding = 'utf-8').read()
+                detail = (compareOutputs(expected_output, actual_output, 'input')
+                            or compareOutputs(expected_output, actual_rewrite_output, 'rewrite'))
+                if detail:
+                    print('FAILED')
+                    failed_tests.append((input_path, detail))
+                else:
+                    print('OK')
+
+    if failed_tests:
+        print()
+        print('Failure details:')
+        for failed_test in failed_tests:
+            print('* Test', failed_test[0])
+            print(failed_test[1])
+            print()
+        print('Test results: %d passed, %d failed.' % (len(tests)-len(failed_tests),
+                                                       len(failed_tests)))
+        raise FailError(repr(failed_tests))
+    else:
+        print('All %d tests passed.' % len(tests))
+
+def main():
+    from optparse import OptionParser
+    parser = OptionParser(usage="%prog [options] <path to jsontestrunner.exe> [test case directory]")
+    parser.add_option("--valgrind",
+                  action="store_true", dest="valgrind", default=False,
+                  help="run all the tests using valgrind to detect memory leaks")
+    parser.add_option("-c", "--with-json-checker",
+                  action="store_true", dest="with_json_checker", default=False,
+                  help="run all the tests from the official JSONChecker test suite of json.org")
+    parser.enable_interspersed_args()
+    options, args = parser.parse_args()
+
+    if len(args) < 1 or len(args) > 2:
+        parser.error('Must provides at least path to jsontestrunner executable.')
+        sys.exit(1)
+
+    jsontest_executable_path = os.path.normpath(os.path.abspath(args[0]))
+    if len(args) > 1:
+        input_path = os.path.normpath(os.path.abspath(args[1]))
+    else:
+        input_path = None
+    runAllTests(jsontest_executable_path, input_path,
+                         use_valgrind=options.valgrind,
+                         with_json_checker=options.with_json_checker,
+                         writerClass='StyledWriter')
+    runAllTests(jsontest_executable_path, input_path,
+                         use_valgrind=options.valgrind,
+                         with_json_checker=options.with_json_checker,
+                         writerClass='StyledStreamWriter')
+    runAllTests(jsontest_executable_path, input_path,
+                         use_valgrind=options.valgrind,
+                         with_json_checker=options.with_json_checker,
+                         writerClass='BuiltStyledStreamWriter')
+
+if __name__ == '__main__':
+    try:
+        main()
+    except FailError:
+        sys.exit(1)
diff --git a/3rdparty/jsoncpp/src/test/rununittests.py b/3rdparty/jsoncpp/src/test/rununittests.py
new file mode 100644
index 00000000..6634e724
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test/rununittests.py
@@ -0,0 +1,84 @@
+# Copyright 2009 Baptiste Lepilleur and The JsonCpp Authors
+# Distributed under MIT license, or public domain if desired and
+# recognized in your jurisdiction.
+# See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+from __future__ import print_function
+from __future__ import unicode_literals
+from io import open
+from glob import glob
+import sys
+import os
+import os.path
+import subprocess
+import optparse
+
+VALGRIND_CMD = 'valgrind --tool=memcheck --leak-check=yes --undef-value-errors=yes'
+
+class TestProxy(object):
+    def __init__(self, test_exe_path, use_valgrind=False):
+        self.test_exe_path = os.path.normpath(os.path.abspath(test_exe_path))
+        self.use_valgrind = use_valgrind
+
+    def run(self, options):
+        if self.use_valgrind:
+            cmd = VALGRIND_CMD.split()
+        else:
+            cmd = []
+        cmd.extend([self.test_exe_path, '--test-auto'] + options)
+        try:
+            process = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
+        except:
+            print(cmd)
+            raise
+        stdout = process.communicate()[0]
+        if process.returncode:
+            return False, stdout
+        return True, stdout
+
+def runAllTests(exe_path, use_valgrind=False):
+    test_proxy = TestProxy(exe_path, use_valgrind=use_valgrind)
+    status, test_names = test_proxy.run(['--list-tests'])
+    if not status:
+        print("Failed to obtain unit tests list:\n" + test_names, file=sys.stderr)
+        return 1
+    test_names = [name.strip() for name in test_names.decode('utf-8').strip().split('\n')]
+    failures = []
+    for name in test_names:
+        print('TESTING %s:' % name, end=' ')
+        succeed, result = test_proxy.run(['--test', name])
+        if succeed:
+            print('OK')
+        else:
+            failures.append((name, result))
+            print('FAILED')
+    failed_count = len(failures)
+    pass_count = len(test_names) - failed_count
+    if failed_count:
+        print()
+        for name, result in failures:
+            print(result)
+        print('%d/%d tests passed (%d failure(s))' % (            pass_count, len(test_names), failed_count))
+        return 1
+    else:
+        print('All %d tests passed' % len(test_names))
+        return 0
+
+def main():
+    from optparse import OptionParser
+    parser = OptionParser(usage="%prog [options] <path to test_lib_json.exe>")
+    parser.add_option("--valgrind",
+                  action="store_true", dest="valgrind", default=False,
+                  help="run all the tests using valgrind to detect memory leaks")
+    parser.enable_interspersed_args()
+    options, args = parser.parse_args()
+
+    if len(args) != 1:
+        parser.error('Must provides at least path to test_lib_json executable.')
+        sys.exit(1)
+
+    exit_code = runAllTests(args[0], use_valgrind=options.valgrind)
+    sys.exit(exit_code)
+
+if __name__ == '__main__':
+    main()
diff --git a/3rdparty/jsoncpp/src/version.in b/3rdparty/jsoncpp/src/version.in
new file mode 100644
index 00000000..bfc03f7d
--- /dev/null
+++ b/3rdparty/jsoncpp/src/version.in
@@ -0,0 +1 @@
+@JSONCPP_VERSION@
diff --git a/3rdparty/libjpeg/CMakeLists.txt b/3rdparty/libjpeg/CMakeLists.txt
new file mode 100644
index 00000000..4e04273a
--- /dev/null
+++ b/3rdparty/libjpeg/CMakeLists.txt
@@ -0,0 +1,21 @@
+cmake_minimum_required(VERSION 3.5)
+
+add_subdirectory(src)
+
+get_target_property(compile_options turbojpeg_static COMPILE_OPTIONS)
+list(REMOVE_ITEM compile_options "-Werror" "/WX")
+set_target_properties(turbojpeg_static PROPERTIES COMPILE_OPTIONS "${compile_options}")
+
+get_target_property(compile_options jpeg_static COMPILE_OPTIONS)
+list(REMOVE_ITEM compile_options "-Werror" "/WX")
+set_target_properties(jpeg_static PROPERTIES COMPILE_OPTIONS "${compile_options}")
+
+get_target_property(compile_options simd COMPILE_OPTIONS)
+list(REMOVE_ITEM compile_options "-Werror" "/WX")
+set_target_properties(simd PROPERTIES COMPILE_OPTIONS "${compile_options}")
+
+target_include_directories(turbojpeg_static PUBLIC ${CMAKE_CURRENT_LIST_DIR}/src)
+add_library(libjpeg::libjpeg ALIAS turbojpeg_static)
+
+ob_source_group(libjpeg::libjpeg)
+set_target_properties(turbojpeg_static jpeg_static simd croptest testclean tjtest PROPERTIES FOLDER "dependencies")
\ No newline at end of file
diff --git a/3rdparty/libjpeg/src/BUILDING.md b/3rdparty/libjpeg/src/BUILDING.md
new file mode 100644
index 00000000..b5106eeb
--- /dev/null
+++ b/3rdparty/libjpeg/src/BUILDING.md
@@ -0,0 +1,709 @@
+Building libjpeg-turbo
+======================
+
+
+Build Requirements
+------------------
+
+
+### All Systems
+
+- [CMake](http://www.cmake.org) v2.8.12 or later
+
+- [NASM](http://www.nasm.us) or [YASM](http://yasm.tortall.net)
+  (if building x86 or x86-64 SIMD extensions)
+  * If using NASM, 2.13 or later is required.
+  * If using YASM, 1.2.0 or later is required.
+  * If building on macOS, NASM or YASM can be obtained from
+    [MacPorts](http://www.macports.org/) or [Homebrew](http://brew.sh/).
+     - NOTE: Currently, if it is desirable to hide the SIMD function symbols in
+       Mac executables or shared libraries that statically link with
+       libjpeg-turbo, then NASM 2.14 or later or YASM must be used when
+       building libjpeg-turbo.
+  * If building on Windows, **nasm.exe**/**yasm.exe** should be in your `PATH`.
+  * NASM and YASM are located in the CRB (Code Ready Builder) repository on
+    Red Hat Enterprise Linux 8 and in the PowerTools repository on CentOS 8,
+    which is not enabled by default.
+
+  The binary RPMs released by the NASM project do not work on older Linux
+  systems, such as Red Hat Enterprise Linux 5.  On such systems, you can easily
+  build and install NASM from a source RPM by downloading one of the SRPMs from
+
+  <http://www.nasm.us/pub/nasm/releasebuilds>
+
+  and executing the following as root:
+
+        ARCH=`uname -m`
+        rpmbuild --rebuild nasm-{version}.src.rpm
+        rpm -Uvh /usr/src/redhat/RPMS/$ARCH/nasm-{version}.$ARCH.rpm
+
+  NOTE: the NASM build will fail if texinfo is not installed.
+
+
+### Un*x Platforms (including Linux, Mac, FreeBSD, Solaris, and Cygwin)
+
+- GCC v4.1 (or later) or Clang recommended for best performance
+
+- If building the TurboJPEG Java wrapper, JDK or OpenJDK 1.5 or later is
+  required.  Most modern Linux distributions, as well as Solaris 10 and later,
+  include JDK or OpenJDK.  For other systems, you can obtain the Oracle Java
+  Development Kit from
+  <http://www.oracle.com/technetwork/java/javase/downloads>.
+
+  * If using JDK 11 or later, CMake 3.10.x or later must also be used.
+
+### Windows
+
+- Microsoft Visual C++ 2005 or later
+
+  If you don't already have Visual C++, then the easiest way to get it is by
+  installing
+  [Visual Studio Community Edition](https://visualstudio.microsoft.com),
+  which includes everything necessary to build libjpeg-turbo.
+
+  * You can also download and install the standalone Windows SDK (for Windows 7
+    or later), which includes command-line versions of the 32-bit and 64-bit
+    Visual C++ compilers.
+  * If you intend to build libjpeg-turbo from the command line, then add the
+    appropriate compiler and SDK directories to the `INCLUDE`, `LIB`, and
+    `PATH` environment variables.  This is generally accomplished by
+    executing `vcvars32.bat` or `vcvars64.bat`, which are located in the same
+    directory as the compiler.
+  * If built with Visual C++ 2015 or later, the libjpeg-turbo static libraries
+    cannot be used with earlier versions of Visual C++, and vice versa.
+  * The libjpeg API DLL (**jpeg{version}.dll**) will depend on the C run-time
+    DLLs corresponding to the version of Visual C++ that was used to build it.
+
+   ... OR ...
+
+- MinGW
+
+  [MSYS2](http://msys2.github.io/) or [tdm-gcc](http://tdm-gcc.tdragon.net/)
+  recommended if building on a Windows machine.  Both distributions install a
+  Start Menu link that can be used to launch a command prompt with the
+  appropriate compiler paths automatically set.
+
+- If building the TurboJPEG Java wrapper, JDK 1.5 or later is required.  This
+  can be downloaded from
+  <http://www.oracle.com/technetwork/java/javase/downloads>.
+
+  * If using JDK 11 or later, CMake 3.10.x or later must also be used.
+
+
+Out-of-Tree Builds
+------------------
+
+Binary objects, libraries, and executables are generated in the directory from
+which CMake is executed (the "binary directory"), and this directory need not
+necessarily be the same as the libjpeg-turbo source directory.  You can create
+multiple independent binary directories, in which different versions of
+libjpeg-turbo can be built from the same source tree using different compilers
+or settings.  In the sections below, *{build_directory}* refers to the binary
+directory, whereas *{source_directory}* refers to the libjpeg-turbo source
+directory.  For in-tree builds, these directories are the same.
+
+
+Build Procedure
+---------------
+
+NOTE: The build procedures below assume that CMake is invoked from the command
+line, but all of these procedures can be adapted to the CMake GUI as
+well.
+
+
+### Un*x
+
+The following procedure will build libjpeg-turbo on Unix and Unix-like systems.
+(On Solaris, this generates a 32-bit build.  See "Build Recipes" below for
+64-bit build instructions.)
+
+    cd {build_directory}
+    cmake -G"Unix Makefiles" [additional CMake flags] {source_directory}
+    make
+
+This will generate the following files under *{build_directory}*:
+
+**libjpeg.a**<br>
+Static link library for the libjpeg API
+
+**libjpeg.so.{version}** (Linux, Unix)<br>
+**libjpeg.{version}.dylib** (Mac)<br>
+**cygjpeg-{version}.dll** (Cygwin)<br>
+Shared library for the libjpeg API
+
+By default, *{version}* is 62.2.0, 7.2.0, or 8.1.2, depending on whether
+libjpeg v6b (default), v7, or v8 emulation is enabled.  If using Cygwin,
+*{version}* is 62, 7, or 8.
+
+**libjpeg.so** (Linux, Unix)<br>
+**libjpeg.dylib** (Mac)<br>
+Development symlink for the libjpeg API
+
+**libjpeg.dll.a** (Cygwin)<br>
+Import library for the libjpeg API
+
+**libturbojpeg.a**<br>
+Static link library for the TurboJPEG API
+
+**libturbojpeg.so.0.2.0** (Linux, Unix)<br>
+**libturbojpeg.0.2.0.dylib** (Mac)<br>
+**cygturbojpeg-0.dll** (Cygwin)<br>
+Shared library for the TurboJPEG API
+
+**libturbojpeg.so** (Linux, Unix)<br>
+**libturbojpeg.dylib** (Mac)<br>
+Development symlink for the TurboJPEG API
+
+**libturbojpeg.dll.a** (Cygwin)<br>
+Import library for the TurboJPEG API
+
+
+### Visual C++ (Command Line)
+
+    cd {build_directory}
+    cmake -G"NMake Makefiles" -DCMAKE_BUILD_TYPE=Release [additional CMake flags] {source_directory}
+    nmake
+
+This will build either a 32-bit or a 64-bit version of libjpeg-turbo, depending
+on which version of **cl.exe** is in the `PATH`.
+
+The following files will be generated under *{build_directory}*:
+
+**jpeg-static.lib**<br>
+Static link library for the libjpeg API
+
+**jpeg{version}.dll**<br>
+DLL for the libjpeg API
+
+**jpeg.lib**<br>
+Import library for the libjpeg API
+
+**turbojpeg-static.lib**<br>
+Static link library for the TurboJPEG API
+
+**turbojpeg.dll**<br>
+DLL for the TurboJPEG API
+
+**turbojpeg.lib**<br>
+Import library for the TurboJPEG API
+
+*{version}* is 62, 7, or 8, depending on whether libjpeg v6b (default), v7, or
+v8 emulation is enabled.
+
+
+### Visual C++ (IDE)
+
+Choose the appropriate CMake generator option for your version of Visual Studio
+(run `cmake` with no arguments for a list of available generators.)  For
+instance:
+
+    cd {build_directory}
+    cmake -G"Visual Studio 10" [additional CMake flags] {source_directory}
+
+NOTE: Add "Win64" to the generator name (for example, "Visual Studio 10 Win64")
+to build a 64-bit version of libjpeg-turbo.  A separate build directory must be
+used for 32-bit and 64-bit builds.
+
+You can then open **ALL_BUILD.vcproj** in Visual Studio and build one of the
+configurations in that project ("Debug", "Release", etc.) to generate a full
+build of libjpeg-turbo.
+
+This will generate the following files under *{build_directory}*:
+
+**{configuration}/jpeg-static.lib**<br>
+Static link library for the libjpeg API
+
+**{configuration}/jpeg{version}.dll**<br>
+DLL for the libjpeg API
+
+**{configuration}/jpeg.lib**<br>
+Import library for the libjpeg API
+
+**{configuration}/turbojpeg-static.lib**<br>
+Static link library for the TurboJPEG API
+
+**{configuration}/turbojpeg.dll**<br>
+DLL for the TurboJPEG API
+
+**{configuration}/turbojpeg.lib**<br>
+Import library for the TurboJPEG API
+
+*{configuration}* is Debug, Release, RelWithDebInfo, or MinSizeRel, depending
+on the configuration you built in the IDE, and *{version}* is 62, 7, or 8,
+depending on whether libjpeg v6b (default), v7, or v8 emulation is enabled.
+
+
+### MinGW
+
+NOTE: This assumes that you are building on a Windows machine using the MSYS
+environment.  If you are cross-compiling on a Un*x platform (including Mac and
+Cygwin), then see "Build Recipes" below.
+
+    cd {build_directory}
+    cmake -G"MSYS Makefiles" [additional CMake flags] {source_directory}
+    make
+
+This will generate the following files under *{build_directory}*:
+
+**libjpeg.a**<br>
+Static link library for the libjpeg API
+
+**libjpeg-{version}.dll**<br>
+DLL for the libjpeg API
+
+**libjpeg.dll.a**<br>
+Import library for the libjpeg API
+
+**libturbojpeg.a**<br>
+Static link library for the TurboJPEG API
+
+**libturbojpeg.dll**<br>
+DLL for the TurboJPEG API
+
+**libturbojpeg.dll.a**<br>
+Import library for the TurboJPEG API
+
+*{version}* is 62, 7, or 8, depending on whether libjpeg v6b (default), v7, or
+v8 emulation is enabled.
+
+
+### Debug Build
+
+Add `-DCMAKE_BUILD_TYPE=Debug` to the CMake command line.  Or, if building
+with NMake, remove `-DCMAKE_BUILD_TYPE=Release` (Debug builds are the default
+with NMake.)
+
+
+### libjpeg v7 or v8 API/ABI Emulation
+
+Add `-DWITH_JPEG7=1` to the CMake command line to build a version of
+libjpeg-turbo that is API/ABI-compatible with libjpeg v7.  Add `-DWITH_JPEG8=1`
+to the CMake command line to build a version of libjpeg-turbo that is
+API/ABI-compatible with libjpeg v8.  See [README.md](README.md) for more
+information about libjpeg v7 and v8 emulation.
+
+
+### In-Memory Source/Destination Managers
+
+When using libjpeg v6b or v7 API/ABI emulation, add `-DWITH_MEM_SRCDST=0` to
+the CMake command line to build a version of libjpeg-turbo that lacks the
+`jpeg_mem_src()` and `jpeg_mem_dest()` functions.  These functions were not
+part of the original libjpeg v6b and v7 APIs, so removing them ensures strict
+conformance with those APIs.  See [README.md](README.md) for more information.
+
+
+### Arithmetic Coding Support
+
+Since the patent on arithmetic coding has expired, this functionality has been
+included in this release of libjpeg-turbo.  libjpeg-turbo's implementation is
+based on the implementation in libjpeg v8, but it works when emulating libjpeg
+v7 or v6b as well.  The default is to enable both arithmetic encoding and
+decoding, but those who have philosophical objections to arithmetic coding can
+add `-DWITH_ARITH_ENC=0` or `-DWITH_ARITH_DEC=0` to the CMake command line to
+disable encoding or decoding (respectively.)
+
+
+### TurboJPEG Java Wrapper
+
+Add `-DWITH_JAVA=1` to the CMake command line to incorporate an optional Java
+Native Interface (JNI) wrapper into the TurboJPEG shared library and build the
+Java front-end classes to support it.  This allows the TurboJPEG shared library
+to be used directly from Java applications.  See [java/README](java/README) for
+more details.
+
+If Java is not in your `PATH`, or if you wish to use an alternate JDK to
+build/test libjpeg-turbo, then (prior to running CMake) set the `JAVA_HOME`
+environment variable to the location of the JDK that you wish to use.  The
+`Java_JAVAC_EXECUTABLE`, `Java_JAVA_EXECUTABLE`, and `Java_JAR_EXECUTABLE`
+CMake variables can also be used to specify alternate commands or locations for
+javac, jar, and java (respectively.)  You can also set the
+`CMAKE_JAVA_COMPILE_FLAGS` CMake variable or the `JAVAFLAGS` environment
+variable to specify arguments that should be passed to the Java compiler when
+building the TurboJPEG classes, and the `JAVAARGS` CMake variable to specify
+arguments that should be passed to the JRE when running the TurboJPEG Java unit
+tests.
+
+
+Build Recipes
+-------------
+
+
+### 32-bit Build on 64-bit Linux/Unix
+
+Use export/setenv to set the following environment variables before running
+CMake:
+
+    CFLAGS=-m32
+    LDFLAGS=-m32
+
+
+### 64-bit Build on Solaris
+
+Use export/setenv to set the following environment variables before running
+CMake:
+
+    CFLAGS=-m64
+    LDFLAGS=-m64
+
+
+### Other Compilers
+
+On Un*x systems, prior to running CMake, you can set the `CC` environment
+variable to the command used to invoke the C compiler.
+
+
+### 32-bit MinGW Build on Un*x (including Mac and Cygwin)
+
+Create a file called **toolchain.cmake** under *{build_directory}*, with the
+following contents:
+
+    set(CMAKE_SYSTEM_NAME Windows)
+    set(CMAKE_SYSTEM_PROCESSOR X86)
+    set(CMAKE_C_COMPILER {mingw_binary_path}/i686-w64-mingw32-gcc)
+    set(CMAKE_RC_COMPILER {mingw_binary_path}/i686-w64-mingw32-windres)
+
+*{mingw\_binary\_path}* is the directory under which the MinGW binaries are
+located (usually **/usr/bin**.)  Next, execute the following commands:
+
+    cd {build_directory}
+    cmake -G"Unix Makefiles" -DCMAKE_TOOLCHAIN_FILE=toolchain.cmake \
+      [additional CMake flags] {source_directory}
+    make
+
+
+### 64-bit MinGW Build on Un*x (including Mac and Cygwin)
+
+Create a file called **toolchain.cmake** under *{build_directory}*, with the
+following contents:
+
+    set(CMAKE_SYSTEM_NAME Windows)
+    set(CMAKE_SYSTEM_PROCESSOR AMD64)
+    set(CMAKE_C_COMPILER {mingw_binary_path}/x86_64-w64-mingw32-gcc)
+    set(CMAKE_RC_COMPILER {mingw_binary_path}/x86_64-w64-mingw32-windres)
+
+*{mingw\_binary\_path}* is the directory under which the MinGW binaries are
+located (usually **/usr/bin**.)  Next, execute the following commands:
+
+    cd {build_directory}
+    cmake -G"Unix Makefiles" -DCMAKE_TOOLCHAIN_FILE=toolchain.cmake \
+      [additional CMake flags] {source_directory}
+    make
+
+
+Building libjpeg-turbo for iOS
+------------------------------
+
+iOS platforms, such as the iPhone and iPad, use Arm processors, and all
+currently supported models include Neon instructions.  Thus, they can take
+advantage of libjpeg-turbo's SIMD extensions to significantly accelerate JPEG
+compression/decompression.  This section describes how to build libjpeg-turbo
+for these platforms.
+
+
+### Armv8 (64-bit)
+
+**Xcode 5 or later required, Xcode 6.3.x or later recommended**
+
+The following script demonstrates how to build libjpeg-turbo to run on the
+iPhone 5S/iPad Mini 2/iPad Air and newer.
+
+    IOS_PLATFORMDIR=/Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform
+    IOS_SYSROOT=($IOS_PLATFORMDIR/Developer/SDKs/iPhoneOS*.sdk)
+    export CFLAGS="-Wall -arch arm64 -miphoneos-version-min=8.0 -funwind-tables"
+
+    cd {build_directory}
+
+    cat <<EOF >toolchain.cmake
+    set(CMAKE_SYSTEM_NAME Darwin)
+    set(CMAKE_SYSTEM_PROCESSOR aarch64)
+    set(CMAKE_C_COMPILER /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/clang)
+    EOF
+
+    cmake -G"Unix Makefiles" -DCMAKE_TOOLCHAIN_FILE=toolchain.cmake \
+      -DCMAKE_OSX_SYSROOT=${IOS_SYSROOT[0]} \
+      [additional CMake flags] {source_directory}
+    make
+
+
+Building libjpeg-turbo for Android
+----------------------------------
+
+Building libjpeg-turbo for Android platforms requires v13b or later of the
+[Android NDK](https://developer.android.com/tools/sdk/ndk).
+
+
+### Armv7 (32-bit)
+
+**NDK r19 or later with Clang recommended**
+
+The following is a general recipe script that can be modified for your specific
+needs.
+
+    # Set these variables to suit your needs
+    NDK_PATH={full path to the NDK directory-- for example,
+      /opt/android/android-ndk-r16b}
+    TOOLCHAIN={"gcc" or "clang"-- "gcc" must be used with NDK r16b and earlier,
+      and "clang" must be used with NDK r17c and later}
+    ANDROID_VERSION={the minimum version of Android to support-- for example,
+      "16", "19", etc.}
+
+    cd {build_directory}
+    cmake -G"Unix Makefiles" \
+      -DANDROID_ABI=armeabi-v7a \
+      -DANDROID_ARM_MODE=arm \
+      -DANDROID_PLATFORM=android-${ANDROID_VERSION} \
+      -DANDROID_TOOLCHAIN=${TOOLCHAIN} \
+      -DCMAKE_ASM_FLAGS="--target=arm-linux-androideabi${ANDROID_VERSION}" \
+      -DCMAKE_TOOLCHAIN_FILE=${NDK_PATH}/build/cmake/android.toolchain.cmake \
+      [additional CMake flags] {source_directory}
+    make
+
+
+### Armv8 (64-bit)
+
+**Clang recommended**
+
+The following is a general recipe script that can be modified for your specific
+needs.
+
+    # Set these variables to suit your needs
+    NDK_PATH={full path to the NDK directory-- for example,
+      /opt/android/android-ndk-r16b}
+    TOOLCHAIN={"gcc" or "clang"-- "gcc" must be used with NDK r14b and earlier,
+      and "clang" must be used with NDK r17c and later}
+    ANDROID_VERSION={the minimum version of Android to support.  "21" or later
+      is required for a 64-bit build.}
+
+    cd {build_directory}
+    cmake -G"Unix Makefiles" \
+      -DANDROID_ABI=arm64-v8a \
+      -DANDROID_ARM_MODE=arm \
+      -DANDROID_PLATFORM=android-${ANDROID_VERSION} \
+      -DANDROID_TOOLCHAIN=${TOOLCHAIN} \
+      -DCMAKE_ASM_FLAGS="--target=aarch64-linux-android${ANDROID_VERSION}" \
+      -DCMAKE_TOOLCHAIN_FILE=${NDK_PATH}/build/cmake/android.toolchain.cmake \
+      [additional CMake flags] {source_directory}
+    make
+
+
+### x86 (32-bit)
+
+The following is a general recipe script that can be modified for your specific
+needs.
+
+    # Set these variables to suit your needs
+    NDK_PATH={full path to the NDK directory-- for example,
+      /opt/android/android-ndk-r16b}
+    TOOLCHAIN={"gcc" or "clang"-- "gcc" must be used with NDK r14b and earlier,
+      and "clang" must be used with NDK r17c and later}
+    ANDROID_VERSION={The minimum version of Android to support-- for example,
+      "16", "19", etc.}
+
+    cd {build_directory}
+    cmake -G"Unix Makefiles" \
+      -DANDROID_ABI=x86 \
+      -DANDROID_PLATFORM=android-${ANDROID_VERSION} \
+      -DANDROID_TOOLCHAIN=${TOOLCHAIN} \
+      -DCMAKE_TOOLCHAIN_FILE=${NDK_PATH}/build/cmake/android.toolchain.cmake \
+      [additional CMake flags] {source_directory}
+    make
+
+
+### x86-64 (64-bit)
+
+The following is a general recipe script that can be modified for your specific
+needs.
+
+    # Set these variables to suit your needs
+    NDK_PATH={full path to the NDK directory-- for example,
+      /opt/android/android-ndk-r16b}
+    TOOLCHAIN={"gcc" or "clang"-- "gcc" must be used with NDK r14b and earlier,
+      and "clang" must be used with NDK r17c and later}
+    ANDROID_VERSION={the minimum version of Android to support.  "21" or later
+      is required for a 64-bit build.}
+
+    cd {build_directory}
+    cmake -G"Unix Makefiles" \
+      -DANDROID_ABI=x86_64 \
+      -DANDROID_PLATFORM=android-${ANDROID_VERSION} \
+      -DANDROID_TOOLCHAIN=${TOOLCHAIN} \
+      -DCMAKE_TOOLCHAIN_FILE=${NDK_PATH}/build/cmake/android.toolchain.cmake \
+      [additional CMake flags] {source_directory}
+    make
+
+
+Advanced CMake Options
+----------------------
+
+To list and configure other CMake options not specifically mentioned in this
+guide, run
+
+    ccmake {source_directory}
+
+or
+
+    cmake-gui {source_directory}
+
+from the build directory after initially configuring the build.  CCMake is a
+text-based interactive version of CMake, and CMake-GUI is a GUI version.  Both
+will display all variables that are relevant to the libjpeg-turbo build, their
+current values, and a help string describing what they do.
+
+
+Installing libjpeg-turbo
+========================
+
+You can use the build system to install libjpeg-turbo (as opposed to creating
+an installer package.)  To do this, run `make install` or `nmake install`
+(or build the "install" target in the Visual Studio IDE.)  Running
+`make uninstall` or `nmake uninstall` (or building the "uninstall" target in
+the Visual Studio IDE) will uninstall libjpeg-turbo.
+
+The `CMAKE_INSTALL_PREFIX` CMake variable can be modified in order to install
+libjpeg-turbo into a directory of your choosing.  If you don't specify
+`CMAKE_INSTALL_PREFIX`, then the default is:
+
+**c:\libjpeg-turbo**<br>
+Visual Studio 32-bit build
+
+**c:\libjpeg-turbo64**<br>
+Visual Studio 64-bit build
+
+**c:\libjpeg-turbo-gcc**<br>
+MinGW 32-bit build
+
+**c:\libjpeg-turbo-gcc64**<br>
+MinGW 64-bit build
+
+**/opt/libjpeg-turbo**<br>
+Un*x
+
+The default value of `CMAKE_INSTALL_PREFIX` causes the libjpeg-turbo files to
+be installed with a directory structure resembling that of the official
+libjpeg-turbo binary packages.  Changing the value of `CMAKE_INSTALL_PREFIX`
+(for instance, to **/usr/local**) causes the libjpeg-turbo files to be
+installed with a directory structure that conforms to GNU standards.
+
+The `CMAKE_INSTALL_BINDIR`, `CMAKE_INSTALL_DATAROOTDIR`,
+`CMAKE_INSTALL_DOCDIR`, `CMAKE_INSTALL_INCLUDEDIR`, `CMAKE_INSTALL_JAVADIR`,
+`CMAKE_INSTALL_LIBDIR`, and `CMAKE_INSTALL_MANDIR` CMake variables allow a
+finer degree of control over where specific files in the libjpeg-turbo
+distribution should be installed.  These directory variables can either be
+specified as absolute paths or as paths relative to `CMAKE_INSTALL_PREFIX` (for
+instance, setting `CMAKE_INSTALL_DOCDIR` to **doc** would cause the
+documentation to be installed in **${CMAKE\_INSTALL\_PREFIX}/doc**.)  If a
+directory variable contains the name of another directory variable in angle
+brackets, then its final value will depend on the final value of that other
+variable.  For instance, the default value of `CMAKE_INSTALL_MANDIR` is
+**\<CMAKE\_INSTALL\_DATAROOTDIR\>/man**.
+
+NOTE: If setting one of these directory variables to a relative path using the
+CMake command line, you must specify that the variable is of type `PATH`.
+For example:
+
+    cmake -G"{generator type}" -DCMAKE_INSTALL_LIBDIR:PATH=lib {source_directory}
+
+Otherwise, CMake will assume that the path is relative to the build directory
+rather than the install directory.
+
+
+Creating Distribution Packages
+==============================
+
+The following commands can be used to create various types of distribution
+packages:
+
+
+Linux
+-----
+
+    make rpm
+
+Create Red Hat-style binary RPM package.  Requires RPM v4 or later.
+
+    make srpm
+
+This runs `make dist` to create a pristine source tarball, then creates a
+Red Hat-style source RPM package from the tarball.  Requires RPM v4 or later.
+
+    make deb
+
+Create Debian-style binary package.  Requires dpkg.
+
+
+Mac
+---
+
+    make dmg
+
+Create Mac package/disk image.  This requires pkgbuild and productbuild, which
+are installed by default on OS X/macOS 10.7 and later.
+
+In order to create a Mac package/disk image that contains universal
+x86-64/Arm binaries, set the following CMake variable:
+
+* `ARMV8_BUILD`: Directory containing an Armv8 (64-bit) iOS or macOS build of
+  libjpeg-turbo to include in the universal binaries
+
+You should first use CMake to configure an Armv8 sub-build of libjpeg-turbo
+(see "Building libjpeg-turbo for iOS" above, if applicable) in a build
+directory that matches the one specified in the aforementioned CMake variable.
+Next, configure the primary (x86-64) build of libjpeg-turbo as an out-of-tree
+build, specifying the aforementioned CMake variable, and build it.  Once the
+primary build has been built, run `make dmg` from the build directory.  The
+packaging system will build the sub-build, use lipo to combine it with the
+primary build into a single set of universal binaries, then package the
+universal binaries.
+
+
+Windows
+-------
+
+If using NMake:
+
+    cd {build_directory}
+    nmake installer
+
+If using MinGW:
+
+    cd {build_directory}
+    make installer
+
+If using the Visual Studio IDE, build the "installer" target.
+
+The installer package (libjpeg-turbo-*{version}*[-gcc|-vc][64].exe) will be
+located under *{build_directory}*.  If building using the Visual Studio IDE,
+then the installer package will be located in a subdirectory with the same name
+as the configuration you built (such as *{build_directory}*\Debug\ or
+*{build_directory}*\Release\).
+
+Building a Windows installer requires the
+[Nullsoft Install System](http://nsis.sourceforge.net/).  makensis.exe should
+be in your `PATH`.
+
+
+Regression testing
+==================
+
+The most common way to test libjpeg-turbo is by invoking `make test` (Un*x) or
+`nmake test` (Windows command line) or by building the "RUN_TESTS" target
+(Visual Studio IDE), once the build has completed.  This runs a series of tests
+to ensure that mathematical compatibility has been maintained between
+libjpeg-turbo and libjpeg v6b.  This also invokes the TurboJPEG unit tests,
+which ensure that the colorspace extensions, YUV encoding, decompression
+scaling, and other features of the TurboJPEG C and Java APIs are working
+properly (and, by extension, that the equivalent features of the underlying
+libjpeg API are also working.)
+
+Invoking `make testclean` (Un*x) or `nmake testclean` (Windows command line) or
+building the "testclean" target (Visual Studio IDE) will clean up the output
+images generated by the tests.
+
+On Un*x platforms, more extensive tests of the TurboJPEG C and Java wrappers
+can be run by invoking `make tjtest`.  These extended TurboJPEG tests
+essentially iterate through all of the available features of the TurboJPEG APIs
+that are not covered by the TurboJPEG unit tests (including the lossless
+transform options) and compare the images generated by each feature to images
+generated using the equivalent feature in the libjpeg API.  The extended
+TurboJPEG tests are meant to test for regressions in the TurboJPEG wrappers,
+not in the underlying libjpeg API library.
diff --git a/3rdparty/libjpeg/src/CMakeLists.txt b/3rdparty/libjpeg/src/CMakeLists.txt
new file mode 100644
index 00000000..02c98266
--- /dev/null
+++ b/3rdparty/libjpeg/src/CMakeLists.txt
@@ -0,0 +1,1593 @@
+cmake_minimum_required(VERSION 2.8.12)
+
+if(CMAKE_EXECUTABLE_SUFFIX)
+  set(CMAKE_EXECUTABLE_SUFFIX_TMP ${CMAKE_EXECUTABLE_SUFFIX})
+endif()
+
+project(libjpeg-turbo C)
+enable_language(C CXX ASM)
+set(VERSION 2.0.90)
+string(REPLACE "." ";" VERSION_TRIPLET ${VERSION})
+list(GET VERSION_TRIPLET 0 VERSION_MAJOR)
+list(GET VERSION_TRIPLET 1 VERSION_MINOR)
+list(GET VERSION_TRIPLET 2 VERSION_REVISION)
+
+function(pad_number NUMBER OUTPUT_LEN)
+  string(LENGTH "${${NUMBER}}" INPUT_LEN)
+
+  if(INPUT_LEN LESS OUTPUT_LEN)
+    math(EXPR ZEROES "${OUTPUT_LEN} - ${INPUT_LEN} - 1")
+    set(NUM ${${NUMBER}})
+
+    foreach(C RANGE ${ZEROES})
+      set(NUM "0${NUM}")
+    endforeach()
+
+    set(${NUMBER} ${NUM} PARENT_SCOPE)
+  endif()
+endfunction()
+
+pad_number(VERSION_MINOR 3)
+pad_number(VERSION_REVISION 3)
+set(LIBJPEG_TURBO_VERSION_NUMBER ${VERSION_MAJOR}${VERSION_MINOR}${VERSION_REVISION})
+
+string(TIMESTAMP DEFAULT_BUILD "%Y%m%d")
+set(BUILD ${DEFAULT_BUILD} CACHE STRING "Build string (default: ${DEFAULT_BUILD})")
+
+# NOTE: On Windows, this does nothing except when using MinGW or Cygwin.
+# CMAKE_BUILD_TYPE has no meaning in Visual Studio, and it always defaults to
+# Debug when using NMake.
+if(NOT CMAKE_BUILD_TYPE)
+  set(CMAKE_BUILD_TYPE Release)
+endif()
+
+message(STATUS "CMAKE_BUILD_TYPE = ${CMAKE_BUILD_TYPE}")
+
+message(STATUS "VERSION = ${VERSION}, BUILD = ${BUILD}")
+
+# Detect CPU type and whether we're building 64-bit or 32-bit code
+math(EXPR BITS "${CMAKE_SIZEOF_VOID_P} * 8")
+string(TOLOWER ${CMAKE_SYSTEM_PROCESSOR} CMAKE_SYSTEM_PROCESSOR_LC)
+
+if(CMAKE_SYSTEM_PROCESSOR_LC MATCHES "x86_64" OR
+  CMAKE_SYSTEM_PROCESSOR_LC MATCHES "amd64" OR
+  CMAKE_SYSTEM_PROCESSOR_LC MATCHES "i[0-9]86" OR
+  CMAKE_SYSTEM_PROCESSOR_LC MATCHES "x86" OR
+  CMAKE_SYSTEM_PROCESSOR_LC MATCHES "ia32")
+  if(BITS EQUAL 64 OR CMAKE_C_COMPILER_ABI MATCHES "ELF X32")
+    set(CPU_TYPE x86_64)
+  else()
+    set(CPU_TYPE i386)
+  endif()
+
+  if(NOT CMAKE_SYSTEM_PROCESSOR STREQUAL ${CPU_TYPE})
+    set(CMAKE_SYSTEM_PROCESSOR ${CPU_TYPE})
+  endif()
+elseif(CMAKE_SYSTEM_PROCESSOR_LC STREQUAL "aarch64" OR
+  CMAKE_SYSTEM_PROCESSOR_LC MATCHES "arm*")
+  if(BITS EQUAL 64)
+    set(CPU_TYPE arm64)
+  else()
+    set(CPU_TYPE arm)
+  endif()
+elseif(CMAKE_SYSTEM_PROCESSOR_LC MATCHES "ppc*" OR
+  CMAKE_SYSTEM_PROCESSOR_LC MATCHES "powerpc*")
+  set(CPU_TYPE powerpc)
+else()
+  set(CPU_TYPE ${CMAKE_SYSTEM_PROCESSOR_LC})
+endif()
+
+message(STATUS "${BITS}-bit build (${CPU_TYPE})")
+
+# ##############################################################################
+# INSTALL DIRECTORIES
+# ##############################################################################
+if(WIN32)
+  if(MSVC)
+    set(CMAKE_INSTALL_DEFAULT_PREFIX "c:/${CMAKE_PROJECT_NAME}")
+  else()
+    set(CMAKE_INSTALL_DEFAULT_PREFIX "c:/${CMAKE_PROJECT_NAME}-gcc")
+  endif()
+
+  if(BITS EQUAL 64)
+    set(CMAKE_INSTALL_DEFAULT_PREFIX "${CMAKE_INSTALL_DEFAULT_PREFIX}64")
+  endif()
+else()
+  if(NOT CMAKE_INSTALL_DEFAULT_PREFIX)
+    set(CMAKE_INSTALL_DEFAULT_PREFIX /opt/${CMAKE_PROJECT_NAME})
+  endif()
+endif()
+
+if(CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT)
+  set(CMAKE_INSTALL_PREFIX "${CMAKE_INSTALL_DEFAULT_PREFIX}" CACHE PATH
+    "Directory into which to install ${CMAKE_PROJECT_NAME} (default: ${CMAKE_INSTALL_DEFAULT_PREFIX})"
+    FORCE)
+endif()
+
+message(STATUS "CMAKE_INSTALL_PREFIX = ${CMAKE_INSTALL_PREFIX}")
+
+# When the prefix is /opt/${CMAKE_PROJECT_NAME}, we assume that an "official"
+# build is being created, and thus we install things into specific locations.
+if(CMAKE_INSTALL_PREFIX STREQUAL "${CMAKE_INSTALL_DEFAULT_PREFIX}")
+  set(CMAKE_INSTALL_DEFAULT_DATAROOTDIR "")
+  set(CMAKE_INSTALL_DEFAULT_DOCDIR "<CMAKE_INSTALL_DATAROOTDIR>/doc")
+  set(CMAKE_INSTALL_DEFAULT_JAVADIR "<CMAKE_INSTALL_DATAROOTDIR>/classes")
+
+  if(UNIX AND NOT APPLE)
+    if(BITS EQUAL 64)
+      set(CMAKE_INSTALL_DEFAULT_LIBDIR "lib64")
+    elseif(CMAKE_C_COMPILER_ABI MATCHES "ELF X32")
+      set(CMAKE_INSTALL_DEFAULT_LIBDIR "libx32")
+    else()
+      set(CMAKE_INSTALL_DEFAULT_LIBDIR "lib32")
+    endif()
+  endif()
+endif()
+
+include(cmakescripts/GNUInstallDirs.cmake)
+
+macro(report_directory var)
+  if(CMAKE_INSTALL_${var} STREQUAL CMAKE_INSTALL_FULL_${var})
+    message(STATUS "CMAKE_INSTALL_${var} = ${CMAKE_INSTALL_${var}}")
+  else()
+    message(STATUS "CMAKE_INSTALL_${var} = ${CMAKE_INSTALL_${var}} (${CMAKE_INSTALL_FULL_${var}})")
+  endif()
+
+  mark_as_advanced(CLEAR CMAKE_INSTALL_${var})
+endmacro()
+
+set(DIRLIST "BINDIR;DATAROOTDIR;DOCDIR;INCLUDEDIR;LIBDIR")
+
+if(UNIX)
+  list(APPEND DIRLIST "MANDIR")
+endif()
+
+foreach(dir ${DIRLIST})
+  report_directory(${dir})
+endforeach()
+
+# ##############################################################################
+# CONFIGURATION OPTIONS
+# ##############################################################################
+macro(boolean_number var)
+  if(${var})
+    set(${var} 1 ${ARGN})
+  else()
+    set(${var} 0 ${ARGN})
+  endif()
+endmacro()
+
+option(ENABLE_SHARED "Build shared libraries" FALSE)
+boolean_number(ENABLE_SHARED)
+option(ENABLE_STATIC "Build static libraries" TRUE)
+boolean_number(ENABLE_STATIC)
+option(REQUIRE_SIMD "Generate a fatal error if SIMD extensions are not available for this platform (default is to fall back to a non-SIMD build)" FALSE)
+boolean_number(REQUIRE_SIMD)
+option(WITH_12BIT "Encode/decode JPEG images with 12-bit samples (implies WITH_ARITH_DEC=0 WITH_ARITH_ENC=0 WITH_JAVA=0 WITH_SIMD=0 WITH_TURBOJPEG=0 )" FALSE)
+boolean_number(WITH_12BIT)
+option(WITH_ARITH_DEC "Include arithmetic decoding support when emulating the libjpeg v6b API/ABI" TRUE)
+boolean_number(WITH_ARITH_DEC)
+option(WITH_ARITH_ENC "Include arithmetic encoding support when emulating the libjpeg v6b API/ABI" TRUE)
+boolean_number(WITH_ARITH_ENC)
+
+if(CMAKE_C_COMPILER_ABI MATCHES "ELF X32")
+  set(WITH_JAVA 0)
+else()
+  option(WITH_JAVA "Build Java wrapper for the TurboJPEG API library (implies ENABLE_SHARED=1)" FALSE)
+  boolean_number(WITH_JAVA)
+endif()
+
+option(WITH_JPEG7 "Emulate libjpeg v7 API/ABI (this makes ${CMAKE_PROJECT_NAME} backward-incompatible with libjpeg v6b)" FALSE)
+boolean_number(WITH_JPEG7)
+option(WITH_JPEG8 "Emulate libjpeg v8 API/ABI (this makes ${CMAKE_PROJECT_NAME} backward-incompatible with libjpeg v6b)" TRUE)
+boolean_number(WITH_JPEG8)
+option(WITH_MEM_SRCDST "Include in-memory source/destination manager functions when emulating the libjpeg v6b or v7 API/ABI" TRUE)
+boolean_number(WITH_MEM_SRCDST)
+
+if(BUILD_ANDROID)
+  option(WITH_SIMD "Include SIMD extensions, if available for this platform" TRUE)
+else()
+  option(WITH_SIMD "Include SIMD extensions, if available for this platform" FALSE)
+endif()
+
+boolean_number(WITH_SIMD)
+option(WITH_TURBOJPEG "Include the TurboJPEG API library and associated test programs" TRUE)
+boolean_number(WITH_TURBOJPEG)
+
+macro(report_option var desc)
+  if(${var})
+    message(STATUS "${desc} enabled (${var} = ${${var}})")
+  else()
+    message(STATUS "${desc} disabled (${var} = ${${var}})")
+  endif()
+endmacro()
+
+if(WITH_JAVA)
+  set(ENABLE_SHARED 1)
+endif()
+
+# Explicitly setting CMAKE_POSITION_INDEPENDENT_CODE=FALSE disables PIC for all
+# targets, which will cause the shared library builds to fail.  Thus, if shared
+# libraries are enabled and CMAKE_POSITION_INDEPENDENT_CODE is explicitly set
+# to FALSE, we need to unset it, thus restoring the default behavior
+# (automatically using PIC for shared library targets.)
+if(DEFINED CMAKE_POSITION_INDEPENDENT_CODE AND
+  NOT CMAKE_POSITION_INDEPENDENT_CODE AND ENABLE_SHARED)
+  unset(CMAKE_POSITION_INDEPENDENT_CODE CACHE)
+endif()
+
+report_option(ENABLE_SHARED "Shared libraries")
+report_option(ENABLE_STATIC "Static libraries")
+
+if(ENABLE_SHARED)
+  set(CMAKE_INSTALL_RPATH ${CMAKE_INSTALL_FULL_LIBDIR})
+endif()
+
+if(WITH_JPEG8 OR WITH_JPEG7)
+  set(WITH_ARITH_ENC 1)
+  set(WITH_ARITH_DEC 1)
+endif()
+
+if(WITH_JPEG8)
+  set(WITH_MEM_SRCDST 0)
+endif()
+
+if(WITH_12BIT)
+  set(WITH_ARITH_DEC 0)
+  set(WITH_ARITH_ENC 0)
+  set(WITH_JAVA 0)
+  set(WITH_SIMD 0)
+  set(WITH_TURBOJPEG 0)
+  set(BITS_IN_JSAMPLE 12)
+else()
+  set(BITS_IN_JSAMPLE 8)
+endif()
+
+report_option(WITH_12BIT "12-bit JPEG support")
+
+if(WITH_ARITH_DEC)
+  set(D_ARITH_CODING_SUPPORTED 1)
+endif()
+
+if(NOT WITH_12BIT)
+  report_option(WITH_ARITH_DEC "Arithmetic decoding support")
+endif()
+
+if(WITH_ARITH_ENC)
+  set(C_ARITH_CODING_SUPPORTED 1)
+endif()
+
+if(NOT WITH_12BIT)
+  report_option(WITH_ARITH_ENC "Arithmetic encoding support")
+endif()
+
+if(NOT WITH_12BIT)
+  report_option(WITH_TURBOJPEG "TurboJPEG API library")
+  report_option(WITH_JAVA "TurboJPEG Java wrapper")
+endif()
+
+if(WITH_MEM_SRCDST)
+  set(MEM_SRCDST_SUPPORTED 1)
+  set(MEM_SRCDST_FUNCTIONS "global:  jpeg_mem_dest;  jpeg_mem_src;")
+endif()
+
+if(NOT WITH_JPEG8)
+  report_option(WITH_MEM_SRCDST "In-memory source/destination managers")
+endif()
+
+set(SO_AGE 2)
+
+if(WITH_MEM_SRCDST)
+  set(SO_AGE 3)
+endif()
+
+if(WITH_JPEG8)
+  set(JPEG_LIB_VERSION 80)
+elseif(WITH_JPEG7)
+  set(JPEG_LIB_VERSION 70)
+else()
+  set(JPEG_LIB_VERSION 62)
+endif()
+
+math(EXPR JPEG_LIB_VERSION_DIV10 "${JPEG_LIB_VERSION} / 10")
+math(EXPR JPEG_LIB_VERSION_MOD10 "${JPEG_LIB_VERSION} % 10")
+
+if(JPEG_LIB_VERSION STREQUAL "62")
+  set(DEFAULT_SO_MAJOR_VERSION ${JPEG_LIB_VERSION})
+else()
+  set(DEFAULT_SO_MAJOR_VERSION ${JPEG_LIB_VERSION_DIV10})
+endif()
+
+if(JPEG_LIB_VERSION STREQUAL "80")
+  set(DEFAULT_SO_MINOR_VERSION 2)
+else()
+  set(DEFAULT_SO_MINOR_VERSION 0)
+endif()
+
+# This causes SO_MAJOR_VERSION/SO_MINOR_VERSION to reset to defaults if
+# WITH_JPEG7 or WITH_JPEG8 has changed.
+if((DEFINED WITH_JPEG7_INT AND NOT WITH_JPEG7 EQUAL WITH_JPEG7_INT) OR
+  (DEFINED WITH_JPEG8_INT AND NOT WITH_JPEG8 EQUAL WITH_JPEG8_INT))
+  set(FORCE_SO_VERSION "FORCE")
+endif()
+
+set(WITH_JPEG7_INT ${WITH_JPEG7} CACHE INTERNAL "")
+set(WITH_JPEG8_INT ${WITH_JPEG8} CACHE INTERNAL "")
+
+set(SO_MAJOR_VERSION ${DEFAULT_SO_MAJOR_VERSION} CACHE STRING
+  "Major version of the libjpeg API shared library (default: ${DEFAULT_SO_MAJOR_VERSION})"
+  ${FORCE_SO_VERSION})
+set(SO_MINOR_VERSION ${DEFAULT_SO_MINOR_VERSION} CACHE STRING
+  "Minor version of the libjpeg API shared library (default: ${DEFAULT_SO_MINOR_VERSION})"
+  ${FORCE_SO_VERSION})
+
+set(JPEG_LIB_VERSION_DECIMAL "${JPEG_LIB_VERSION_DIV10}.${JPEG_LIB_VERSION_MOD10}")
+message(STATUS "Emulating libjpeg API/ABI v${JPEG_LIB_VERSION_DECIMAL} (WITH_JPEG7 = ${WITH_JPEG7}, WITH_JPEG8 = ${WITH_JPEG8})")
+message(STATUS "libjpeg API shared library version = ${SO_MAJOR_VERSION}.${SO_AGE}.${SO_MINOR_VERSION}")
+
+# Because the TurboJPEG API library uses versioned symbols and changes the
+# names of functions whenever they are modified in a backward-incompatible
+# manner, it is always backward-ABI-compatible with itself, so the major and
+# minor SO versions don't change.  However, we increase the middle number (the
+# SO "age") whenever functions are added to the API.
+set(TURBOJPEG_SO_MAJOR_VERSION 0)
+set(TURBOJPEG_SO_VERSION 0.2.0)
+
+# ##############################################################################
+# COMPILER SETTINGS
+# ##############################################################################
+if(MSVC)
+  option(WITH_CRT_DLL
+    "Link all ${CMAKE_PROJECT_NAME} libraries and executables with the C run-time DLL (msvcr*.dll) instead of the static C run-time library (libcmt*.lib.)  The default is to use the C run-time DLL only with the libraries and executables that need it."
+    FALSE)
+
+  if(NOT WITH_CRT_DLL)
+    # Use the static C library for all build types
+    foreach(var CMAKE_C_FLAGS CMAKE_C_FLAGS_DEBUG CMAKE_C_FLAGS_RELEASE
+      CMAKE_C_FLAGS_MINSIZEREL CMAKE_C_FLAGS_RELWITHDEBINFO)
+      if(${var} MATCHES "/MD")
+        string(REGEX REPLACE "/MD" "/MT" ${var} "${${var}}")
+      endif()
+    endforeach()
+  endif()
+
+  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /W3 /wd4996")
+endif()
+
+if(CMAKE_COMPILER_IS_GNUCC OR CMAKE_C_COMPILER_ID STREQUAL "Clang")
+  # Use the maximum optimization level for release builds
+  foreach(var CMAKE_C_FLAGS_RELEASE CMAKE_C_FLAGS_RELWITHDEBINFO)
+    if(${var} MATCHES "-O2")
+      string(REGEX REPLACE "-O2" "-O3" ${var} "${${var}}")
+    endif()
+  endforeach()
+endif()
+
+if(CMAKE_SYSTEM_NAME STREQUAL "SunOS")
+  if(CMAKE_C_COMPILER_ID MATCHES "SunPro")
+    # Use the maximum optimization level for release builds
+    foreach(var CMAKE_C_FLAGS_RELEASE CMAKE_C_FLAGS_RELWITHDEBINFO)
+      if(${var} MATCHES "-xO3")
+        string(REGEX REPLACE "-xO3" "-xO5" ${var} "${${var}}")
+      endif()
+
+      if(${var} MATCHES "-xO2")
+        string(REGEX REPLACE "-xO2" "-xO5" ${var} "${${var}}")
+      endif()
+    endforeach()
+  endif()
+endif()
+
+string(TOUPPER ${CMAKE_BUILD_TYPE} CMAKE_BUILD_TYPE_UC)
+
+set(EFFECTIVE_C_FLAGS "${CMAKE_C_FLAGS} ${CMAKE_C_FLAGS_${CMAKE_BUILD_TYPE_UC}}")
+message(STATUS "Compiler flags = ${EFFECTIVE_C_FLAGS}")
+
+set(EFFECTIVE_LD_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${CMAKE_EXE_LINKER_FLAGS_${CMAKE_BUILD_TYPE_UC}}")
+message(STATUS "Linker flags = ${EFFECTIVE_LD_FLAGS}")
+
+include(CheckCSourceCompiles)
+include(CheckIncludeFiles)
+include(CheckTypeSize)
+
+check_type_size("size_t" SIZE_T)
+check_type_size("unsigned long" UNSIGNED_LONG)
+
+if(SIZE_T EQUAL UNSIGNED_LONG)
+  check_c_source_compiles("int main(int argc, char **argv) { unsigned long a = argc;  return __builtin_ctzl(a); }"
+    HAVE_BUILTIN_CTZL)
+endif()
+
+if(MSVC)
+  check_include_files("intrin.h" HAVE_INTRIN_H)
+endif()
+
+if(UNIX)
+  # Check for headers
+  check_include_files(locale.h HAVE_LOCALE_H)
+  check_include_files(stddef.h HAVE_STDDEF_H)
+  check_include_files(stdlib.h HAVE_STDLIB_H)
+  check_include_files(sys/types.h NEED_SYS_TYPES_H)
+
+  # Check for functions
+  include(CheckSymbolExists)
+  check_symbol_exists(memset string.h HAVE_MEMSET)
+  check_symbol_exists(memcpy string.h HAVE_MEMCPY)
+
+  if(NOT HAVE_MEMSET AND NOT HAVE_MEMCPY)
+    set(NEED_BSD_STRINGS 1)
+  endif()
+
+  # Check for types
+  check_type_size("unsigned char" UNSIGNED_CHAR)
+  check_type_size("unsigned short" UNSIGNED_SHORT)
+
+  # Check for compiler features
+  check_c_source_compiles("int main(void) { typedef struct undefined_structure *undef_struct_ptr;  undef_struct_ptr ptr = 0;  return ptr != 0; }"
+    INCOMPLETE_TYPES)
+
+  if(INCOMPLETE_TYPES)
+    message(STATUS "Compiler supports pointers to undefined structures.")
+  else()
+    set(INCOMPLETE_TYPES_BROKEN 1)
+    message(STATUS "Compiler does not support pointers to undefined structures.")
+  endif()
+
+  if(CMAKE_CROSSCOMPILING)
+    set(RIGHT_SHIFT_IS_UNSIGNED 0)
+  else()
+    include(CheckCSourceRuns)
+    check_c_source_runs("
+      #include <stdio.h>
+      #include <stdlib.h>
+      int is_shifting_signed (long arg) {
+        long res = arg >> 4;
+        if (res == -0x7F7E80CL)
+          return 1; /* right shift is signed */
+        /* see if unsigned-shift hack will fix it. */
+        /* we can't just test exact value since it depends on width of long... */
+        res |= (~0L) << (32-4);
+        if (res == -0x7F7E80CL)
+          return 0; /* right shift is unsigned */
+        printf(\"Right shift isn't acting as I expect it to.\\\\n\");
+        printf(\"I fear the JPEG software will not work at all.\\\\n\\\\n\");
+        return 0; /* try it with unsigned anyway */
+      }
+      int main (void) {
+        exit(is_shifting_signed(-0x7F7E80B1L));
+      }" RIGHT_SHIFT_IS_UNSIGNED)
+  endif()
+endif()
+
+if(MSVC)
+  set(INLINE_OPTIONS "__inline;inline")
+else()
+  set(INLINE_OPTIONS "__inline__;inline")
+endif()
+
+option(FORCE_INLINE "Force function inlining" TRUE)
+boolean_number(FORCE_INLINE)
+
+if(FORCE_INLINE)
+  if(MSVC)
+    list(INSERT INLINE_OPTIONS 0 "__forceinline")
+  else()
+    list(INSERT INLINE_OPTIONS 0 "inline __attribute__((always_inline))")
+    list(INSERT INLINE_OPTIONS 0 "__inline__ __attribute__((always_inline))")
+  endif()
+endif()
+
+foreach(inline ${INLINE_OPTIONS})
+  check_c_source_compiles("${inline} static int foo(void) { return 0; } int main(void) { return foo(); }"
+    INLINE_WORKS)
+
+  if(INLINE_WORKS)
+    set(INLINE ${inline})
+    break()
+  endif()
+endforeach()
+
+if(NOT INLINE_WORKS)
+  #message(FATAL_ERROR "Could not determine how to inline functions.")
+endif()
+
+message(STATUS "INLINE = ${INLINE} (FORCE_INLINE = ${FORCE_INLINE})")
+
+if(WITH_TURBOJPEG)
+  if(MSVC)
+    set(THREAD_LOCAL "__declspec(thread)")
+  else()
+    set(THREAD_LOCAL "__thread")
+  endif()
+
+  check_c_source_compiles("${THREAD_LOCAL} int i;  int main(void) { i = 0;  return i; }" HAVE_THREAD_LOCAL)
+
+  if(HAVE_THREAD_LOCAL)
+    message(STATUS "THREAD_LOCAL = ${THREAD_LOCAL}")
+  else()
+    message(WARNING "Thread-local storage is not available.  The TurboJPEG API library's global error handler will not be thread-safe.")
+    unset(THREAD_LOCAL)
+  endif()
+endif()
+
+if(UNIX AND NOT APPLE)
+  file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/conftest.map "VERS_1 { global: *; };")
+  set(CMAKE_REQUIRED_FLAGS
+    "-Wl,--version-script,${CMAKE_CURRENT_BINARY_DIR}/conftest.map")
+  check_c_source_compiles("int main(void) { return 0; }" HAVE_VERSION_SCRIPT)
+  set(CMAKE_REQUIRED_FLAGS)
+  file(REMOVE ${CMAKE_CURRENT_BINARY_DIR}/conftest.map)
+
+  if(HAVE_VERSION_SCRIPT)
+    message(STATUS "Linker supports GNU-style version scripts")
+    set(MAPFLAG "-Wl,--version-script,")
+    set(TJMAPFLAG "-Wl,--version-script,")
+  else()
+    message(STATUS "Linker does not support GNU-style version scripts")
+
+    if(CMAKE_SYSTEM_NAME STREQUAL "SunOS")
+      # The Solaris linker doesn't like our version script for the libjpeg API
+      # library, but the version script for the TurboJPEG API library should
+      # still work.
+      file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/conftest.map
+        "VERS_1 { global: foo;  local: *; }; VERS_2 { global: foo2; } VERS_1;")
+      set(CMAKE_REQUIRED_FLAGS "-Wl,-M,${CMAKE_CURRENT_BINARY_DIR}/conftest.map -shared")
+      check_c_source_compiles("int foo() { return 0; } int foo2() { return 2; }"
+        HAVE_MAPFILE)
+      set(CMAKE_REQUIRED_FLAGS)
+      file(REMOVE ${CMAKE_CURRENT_BINARY_DIR}/conftest.map)
+
+      if(HAVE_MAPFILE)
+        message(STATUS "Linker supports mapfiles")
+        set(TJMAPFLAG "-Wl,-M,")
+      else()
+        message(STATUS "Linker does not support mapfiles")
+      endif()
+    endif()
+  endif()
+endif()
+
+# Generate files
+if(WIN32)
+  configure_file(win/jconfig.h.in ${CMAKE_CURRENT_BINARY_DIR}/jconfig.h)
+else()
+  configure_file(jconfig.h.in ${CMAKE_CURRENT_BINARY_DIR}/jconfig.h)
+endif()
+
+configure_file(jconfigint.h.in ${CMAKE_CURRENT_BINARY_DIR}/jconfigint.h)
+
+if(UNIX)
+  configure_file(libjpeg.map.in ${CMAKE_CURRENT_BINARY_DIR}/libjpeg.map)
+endif()
+
+# Include directories and compiler definitions
+include_directories(${CMAKE_CURRENT_BINARY_DIR} ${CMAKE_CURRENT_SOURCE_DIR})
+
+# ##############################################################################
+# TARGETS
+# ##############################################################################
+if(CMAKE_EXECUTABLE_SUFFIX_TMP)
+  set(CMAKE_EXECUTABLE_SUFFIX ${CMAKE_EXECUTABLE_SUFFIX_TMP})
+endif()
+
+message(STATUS "CMAKE_EXECUTABLE_SUFFIX = ${CMAKE_EXECUTABLE_SUFFIX}")
+
+set(JPEG_SOURCES jcapimin.c jcapistd.c jccoefct.c jccolor.c jcdctmgr.c jchuff.c
+  jcicc.c jcinit.c jcmainct.c jcmarker.c jcmaster.c jcomapi.c jcparam.c
+  jcphuff.c jcprepct.c jcsample.c jctrans.c jdapimin.c jdapistd.c jdatadst.c
+  jdatasrc.c jdcoefct.c jdcolor.c jddctmgr.c jdhuff.c jdicc.c jdinput.c
+  jdmainct.c jdmarker.c jdmaster.c jdmerge.c jdphuff.c jdpostct.c jdsample.c
+  jdtrans.c jerror.c jfdctflt.c jfdctfst.c jfdctint.c jidctflt.c jidctfst.c
+  jidctint.c jidctred.c jquant1.c jquant2.c jutils.c jmemmgr.c jmemnobs.c)
+
+if(WITH_ARITH_ENC OR WITH_ARITH_DEC)
+  set(JPEG_SOURCES ${JPEG_SOURCES} jaricom.c)
+endif()
+
+if(WITH_ARITH_ENC)
+  set(JPEG_SOURCES ${JPEG_SOURCES} jcarith.c)
+endif()
+
+if(WITH_ARITH_DEC)
+  set(JPEG_SOURCES ${JPEG_SOURCES} jdarith.c)
+endif()
+
+if(WITH_SIMD)
+  set(SIMD_SOURCES_ALL "")
+  add_subdirectory(simd)
+
+  if(NEON_INTRINSICS)
+    add_definitions(-DNEON_INTRINSICS)
+  endif()
+elseif(NOT WITH_12BIT)
+  message(STATUS "SIMD extensions: None (WITH_SIMD = ${WITH_SIMD})")
+endif()
+
+if(WITH_SIMD)
+  message(STATUS "SIMD extensions: ${CPU_TYPE} (WITH_SIMD = ${WITH_SIMD})")
+
+  if(MSVC_IDE OR XCODE)
+    set_source_files_properties(${SIMD_OBJS} PROPERTIES GENERATED 1)
+  endif()
+else()
+  message(STATUS "============== ADD SIMD")
+  add_library(simd OBJECT jsimd_none.c)
+endif()
+
+if(WITH_JAVA)
+  add_subdirectory(java)
+endif()
+
+if(ENABLE_SHARED)
+  add_subdirectory(sharedlib)
+endif()
+
+if(ENABLE_STATIC)
+  include_directories(${CMAKE_CURRENT_BINARY_DIR}/simd/arm)
+  include_directories(${CMAKE_CURRENT_BINARY_DIR}/simd/mips64)
+  include_directories(${CMAKE_CURRENT_BINARY_DIR}/simd/mips)
+  include_directories(${CMAKE_CURRENT_BINARY_DIR}/simd/powerpc)
+  add_library(jpeg_static STATIC ${JPEG_SOURCES}
+
+    # $<TARGET_OBJECTS:simd>
+    # ${SIMD_OBJS}
+    ${SIMD_SOURCES_ALL}
+  )
+
+  if(NOT MSVC)
+    set_target_properties(jpeg_static PROPERTIES OUTPUT_NAME jpeg)
+  endif()
+endif()
+
+if(WITH_TURBOJPEG)
+  if(ENABLE_SHARED)
+    set(TURBOJPEG_SOURCES ${JPEG_SOURCES}
+      $<TARGET_OBJECTS:simd> ${SIMD_OBJS}
+      turbojpeg.c transupp.c jdatadst-tj.c jdatasrc-tj.c rdbmp.c rdppm.c
+      wrbmp.c wrppm.c)
+    set(TJMAPFILE ${CMAKE_CURRENT_SOURCE_DIR}/turbojpeg-mapfile)
+
+    if(WITH_JAVA)
+      set(TURBOJPEG_SOURCES ${TURBOJPEG_SOURCES} turbojpeg-jni.c)
+      include_directories(${JAVA_INCLUDE_PATH} ${JAVA_INCLUDE_PATH2})
+      set(TJMAPFILE ${CMAKE_CURRENT_SOURCE_DIR}/turbojpeg-mapfile.jni)
+    endif()
+
+    add_library(turbojpeg SHARED ${TURBOJPEG_SOURCES})
+    set_property(TARGET turbojpeg PROPERTY COMPILE_FLAGS
+      "-DBMP_SUPPORTED -DPPM_SUPPORTED")
+
+    if(WIN32)
+      set_target_properties(turbojpeg PROPERTIES DEFINE_SYMBOL DLLDEFINE)
+    endif()
+
+    if(MINGW)
+      set_target_properties(turbojpeg PROPERTIES LINK_FLAGS -Wl,--kill-at)
+    endif()
+
+    if(APPLE AND(NOT CMAKE_OSX_DEPLOYMENT_TARGET OR
+      CMAKE_OSX_DEPLOYMENT_TARGET VERSION_GREATER 10.4))
+      if(NOT CMAKE_SHARED_LIBRARY_RUNTIME_C_FLAG)
+        set(CMAKE_SHARED_LIBRARY_RUNTIME_C_FLAG "-Wl,-rpath,")
+      endif()
+
+      set_target_properties(turbojpeg PROPERTIES MACOSX_RPATH 1)
+    endif()
+
+    set_target_properties(turbojpeg PROPERTIES
+      SOVERSION ${TURBOJPEG_SO_MAJOR_VERSION} VERSION ${TURBOJPEG_SO_VERSION})
+
+    if(TJMAPFLAG)
+      set_target_properties(turbojpeg PROPERTIES
+        LINK_FLAGS "${TJMAPFLAG}${TJMAPFILE}")
+    endif()
+
+    # add_executable(tjunittest tjunittest.c tjutil.c md5/md5.c md5/md5hl.c)
+    # target_link_libraries(tjunittest turbojpeg)
+
+    # add_executable(tjbench tjbench.c tjutil.c)
+    # target_link_libraries(tjbench turbojpeg)
+    # if(UNIX)
+    # target_link_libraries(tjbench m)
+    # endif()
+
+    # add_executable(tjexample tjexample.c)
+    # target_link_libraries(tjexample turbojpeg)
+  endif()
+
+  if(ENABLE_STATIC)
+    if(BUILD_ANDROID)
+      add_library(turbojpeg_static STATIC
+              ${JPEG_SOURCES}
+              ${SIMD_SOURCES_ALL}
+              turbojpeg.c transupp.c jdatadst-tj.c jdatasrc-tj.c rdbmp.c
+              rdppm.c wrbmp.c wrppm.c)
+    else()
+      add_library(turbojpeg_static STATIC
+        ${JPEG_SOURCES}
+        $<TARGET_OBJECTS:simd>
+        ${SIMD_OBJS}
+
+        # ${SIMD_SOURCES_ALL}
+        turbojpeg.c transupp.c jdatadst-tj.c jdatasrc-tj.c rdbmp.c
+        rdppm.c wrbmp.c wrppm.c)
+    endif()
+
+    set_property(TARGET turbojpeg_static PROPERTY COMPILE_FLAGS
+      "-DBMP_SUPPORTED -DPPM_SUPPORTED")
+
+    if(NOT MSVC)
+      set_target_properties(turbojpeg_static PROPERTIES OUTPUT_NAME turbojpeg)
+    endif()
+
+    # add_executable(tjunittest-static tjunittest.c tjutil.c md5/md5.c
+    # md5/md5hl.c)
+    # target_link_libraries(tjunittest-static turbojpeg_static)
+    # add_executable(tjbench-static tjbench.c tjutil.c)
+    # target_link_libraries(tjbench-static turbojpeg_static)
+
+    # if(UNIX)
+    #   target_link_libraries(tjbench-static m)
+    # endif()
+  endif()
+endif()
+
+if(WIN32)
+  set(USE_SETMODE "-DUSE_SETMODE")
+endif()
+
+if(WITH_12BIT)
+  set(COMPILE_FLAGS "-DGIF_SUPPORTED -DPPM_SUPPORTED ${USE_SETMODE}")
+else()
+  set(COMPILE_FLAGS "-DBMP_SUPPORTED -DGIF_SUPPORTED -DPPM_SUPPORTED -DTARGA_SUPPORTED ${USE_SETMODE}")
+  set(CJPEG_BMP_SOURCES rdbmp.c rdtarga.c)
+  set(DJPEG_BMP_SOURCES wrbmp.c wrtarga.c)
+endif()
+
+if(ENABLE_STATIC)
+  # add_executable(cjpeg_static cjpeg.c cdjpeg.c rdgif.c rdppm.c rdswitch.c
+  # ${CJPEG_BMP_SOURCES})
+  # set_property(TARGET cjpeg_static PROPERTY COMPILE_FLAGS ${COMPILE_FLAGS})
+  # target_link_libraries(cjpeg_static jpeg_static)
+
+  # add_executable(djpeg_static djpeg.c cdjpeg.c rdcolmap.c rdswitch.c wrgif.c
+  # wrppm.c ${DJPEG_BMP_SOURCES})
+  # set_property(TARGET djpeg_static PROPERTY COMPILE_FLAGS ${COMPILE_FLAGS})
+  # target_link_libraries(djpeg_static jpeg_static)
+
+  # add_executable(jpegtran-static jpegtran.c cdjpeg.c rdswitch.c transupp.c)
+  # target_link_libraries(jpegtran-static jpeg_static)
+  # set_property(TARGET jpegtran-static PROPERTY COMPILE_FLAGS "${USE_SETMODE}")
+endif()
+
+# add_executable(rdjpgcom rdjpgcom.c)
+
+# add_executable(wrjpgcom wrjpgcom.c)
+
+# ##############################################################################
+# TESTS
+# ##############################################################################
+add_subdirectory(md5)
+
+if(MSVC_IDE OR XCODE)
+  set(OBJDIR "\${CTEST_CONFIGURATION_TYPE}/")
+else()
+  set(OBJDIR "")
+endif()
+
+enable_testing()
+
+if(WITH_12BIT)
+  set(TESTORIG testorig12.jpg)
+  set(MD5_JPEG_RGB_ISLOW 9d7369207c520d37f2c1cbfcb82b2964)
+  set(MD5_JPEG_RGB_ISLOW2 a00bd20d8ae49684640ef7177d2e0b64)
+  set(MD5_PPM_RGB_ISLOW f3301d2219783b8b3d942b7239fa50c0)
+  set(MD5_JPEG_422_IFAST_OPT 7322e3bd2f127f7de4b40d4480ce60e4)
+  set(MD5_PPM_422_IFAST 79807fa552899e66a04708f533e16950)
+  set(MD5_JPEG_440_ISLOW e25c1912e38367be505a89c410c1c2d2)
+  set(MD5_PPM_440_ISLOW e7d2e26288870cfcb30f3114ad01e380)
+  set(MD5_PPM_422M_IFAST 07737bfe8a7c1c87aaa393a0098d16b0)
+  set(MD5_JPEG_420_IFAST_Q100_PROG 008ab68d6ddbba04a8f01deee4e0f9f8)
+  set(MD5_PPM_420_Q100_IFAST 1b3730122709f53d007255e8dfd3305e)
+  set(MD5_PPM_420M_Q100_IFAST 980a1a3c5bf9510022869d30b7d26566)
+  set(MD5_JPEG_GRAY_ISLOW 235c90707b16e2e069f37c888b2636d9)
+  set(MD5_PPM_GRAY_ISLOW 7213c10af507ad467da5578ca5ee1fca)
+  set(MD5_PPM_GRAY_ISLOW_RGB e96ee81c30a6ed422d466338bd3de65d)
+  set(MD5_JPEG_420S_IFAST_OPT 7af8e60be4d9c227ec63ac9b6630855e)
+
+  set(MD5_JPEG_3x2_FLOAT_PROG_SSE a8c17daf77b457725ec929e215b603f8)
+  set(MD5_PPM_3x2_FLOAT_SSE 42876ab9e5c2f76a87d08db5fbd57956)
+  set(MD5_JPEG_3x2_FLOAT_PROG_NO_FP_CONTRACT a8c17daf77b457725ec929e215b603f8)
+  set(MD5_PPM_3x2_FLOAT_NO_FP_CONTRACT ${MD5_PPM_3x2_FLOAT_SSE})
+  set(MD5_JPEG_3x2_FLOAT_PROG_FP_CONTRACT
+    ${MD5_JPEG_3x2_FLOAT_PROG_NO_FP_CONTRACT})
+  set(MD5_PPM_3x2_FLOAT_FP_CONTRACT ${MD5_PPM_3x2_FLOAT_SSE})
+  set(MD5_JPEG_3x2_FLOAT_PROG_387 bc6dbbefac2872f6b9d6c4a0ae60c3c0)
+  set(MD5_PPM_3x2_FLOAT_387 bcc5723c61560463ac60f772e742d092)
+  set(MD5_JPEG_3x2_FLOAT_PROG_MSVC e27840755870fa849872e58aa0cd1400)
+  set(MD5_PPM_3x2_FLOAT_MSVC 6c2880b83bb1aa41dfe330e7a9768690)
+
+  set(MD5_JPEG_3x2_IFAST_PROG 1396cc2b7185cfe943d408c9d305339e)
+  set(MD5_PPM_3x2_IFAST 3975985ef6eeb0a2cdc58daa651ccc00)
+  set(MD5_PPM_420M_ISLOW_2_1 4ca6be2a6f326ff9eaab63e70a8259c0)
+  set(MD5_PPM_420M_ISLOW_15_8 12aa9f9534c1b3d7ba047322226365eb)
+  set(MD5_PPM_420M_ISLOW_13_8 f7e22817c7b25e1393e4ec101e9d4e96)
+  set(MD5_PPM_420M_ISLOW_11_8 800a16f9f4dc9b293197bfe11be10a82)
+  set(MD5_PPM_420M_ISLOW_9_8 06b7a92a9bc69f4dc36ec40f1937d55c)
+  set(MD5_PPM_420M_ISLOW_7_8 3ec444a14a4ab4eab88ffc49c48eca43)
+  set(MD5_PPM_420M_ISLOW_3_4 3e726b7ea872445b19437d1c1d4f0d93)
+  set(MD5_PPM_420M_ISLOW_5_8 a8a771abdc94301d20ffac119b2caccd)
+  set(MD5_PPM_420M_ISLOW_1_2 b419124dd5568b085787234866102866)
+  set(MD5_PPM_420M_ISLOW_3_8 343d19015531b7bbe746124127244fa8)
+  set(MD5_PPM_420M_ISLOW_1_4 35fd59d866e44659edfa3c18db2a3edb)
+  set(MD5_PPM_420M_ISLOW_1_8 ccaed48ac0aedefda5d4abe4013f4ad7)
+  set(MD5_PPM_420_ISLOW_SKIP15_31 86664cd9dc956536409e44e244d20a97)
+  set(MD5_PPM_420_ISLOW_PROG_CROP62x62_71_71 452a21656115a163029cfba5c04fa76a)
+  set(MD5_PPM_444_ISLOW_SKIP1_6 ef63901f71ef7a75cd78253fc0914f84)
+  set(MD5_PPM_444_ISLOW_PROG_CROP98x98_13_13 15b173fb5872d9575572fbcc1b05956f)
+  set(MD5_JPEG_CROP cdb35ff4b4519392690ea040c56ea99c)
+else()
+  set(TESTORIG testorig.jpg)
+  set(MD5_JPEG_RGB_ISLOW 1d44a406f61da743b5fd31c0a9abdca3)
+  set(MD5_JPEG_RGB_ISLOW2 31d121e57b6c2934c890a7fc7763bcd4)
+  set(MD5_PPM_RGB_ISLOW 00a257f5393fef8821f2b88ac7421291)
+  set(MD5_BMP_RGB_ISLOW_565 f07d2e75073e4bb10f6c6f4d36e2e3be)
+  set(MD5_BMP_RGB_ISLOW_565D 4cfa0928ef3e6bb626d7728c924cfda4)
+  set(MD5_JPEG_422_IFAST_OPT 2540287b79d913f91665e660303ab2c8)
+  set(MD5_PPM_422_IFAST 35bd6b3f833bad23de82acea847129fa)
+  set(MD5_JPEG_440_ISLOW 538bc02bd4b4658fd85de6ece6cbeda6)
+  set(MD5_PPM_440_ISLOW 11e7eab7ef7ef3276934bb7e7b6bb377)
+  set(MD5_PPM_422M_IFAST 8dbc65323d62cca7c91ba02dd1cfa81d)
+  set(MD5_BMP_422M_IFAST_565 3294bd4d9a1f2b3d08ea6020d0db7065)
+  set(MD5_BMP_422M_IFAST_565D da98c9c7b6039511be4a79a878a9abc1)
+  set(MD5_JPEG_420_IFAST_Q100_PROG e59bb462016a8d9a748c330a3474bb55)
+  set(MD5_PPM_420_Q100_IFAST 5a732542015c278ff43635e473a8a294)
+  set(MD5_PPM_420M_Q100_IFAST ff692ee9323a3b424894862557c092f1)
+  set(MD5_JPEG_GRAY_ISLOW 72b51f894b8f4a10b3ee3066770aa38d)
+  set(MD5_PPM_GRAY_ISLOW 8d3596c56eace32f205deccc229aa5ed)
+  set(MD5_PPM_GRAY_ISLOW_RGB 116424ac07b79e5e801f00508eab48ec)
+  set(MD5_BMP_GRAY_ISLOW_565 12f78118e56a2f48b966f792fedf23cc)
+  set(MD5_BMP_GRAY_ISLOW_565D bdbbd616441a24354c98553df5dc82db)
+  set(MD5_JPEG_420S_IFAST_OPT 388708217ac46273ca33086b22827ed8)
+
+  set(MD5_JPEG_3x2_FLOAT_PROG_SSE 343e3f8caf8af5986ebaf0bdc13b5c71)
+  set(MD5_PPM_3x2_FLOAT_SSE 1a75f36e5904d6fc3a85a43da9ad89bb)
+  set(MD5_JPEG_3x2_FLOAT_PROG_NO_FP_CONTRACT 9bca803d2042bd1eb03819e2bf92b3e5)
+  set(MD5_PPM_3x2_FLOAT_NO_FP_CONTRACT f6bfab038438ed8f5522fbd33595dcdc)
+  set(MD5_JPEG_3x2_FLOAT_PROG_FP_CONTRACT
+    ${MD5_JPEG_3x2_FLOAT_PROG_NO_FP_CONTRACT})
+  set(MD5_PPM_3x2_FLOAT_FP_CONTRACT 0e917a34193ef976b679a6b069b1be26)
+  set(MD5_JPEG_3x2_FLOAT_PROG_387 1657664a410e0822c924b54f6f65e6e9)
+  set(MD5_PPM_3x2_FLOAT_387 cb0a1f027f3d2917c902b5640214e025)
+  set(MD5_JPEG_3x2_FLOAT_PROG_MSVC 7999ce9cd0ee9b6c7043b7351ab7639d)
+  set(MD5_PPM_3x2_FLOAT_MSVC 28cdc448a6b75e97892f0e0f8d4b21f3)
+
+  set(MD5_JPEG_3x2_IFAST_PROG 1ee5d2c1a77f2da495f993c8c7cceca5)
+  set(MD5_PPM_3x2_IFAST fd283664b3b49127984af0a7f118fccd)
+  set(MD5_JPEG_420_ISLOW_ARI e986fb0a637a8d833d96e8a6d6d84ea1)
+  set(MD5_JPEG_444_ISLOW_PROGARI 0a8f1c8f66e113c3cf635df0a475a617)
+  set(MD5_PPM_420M_IFAST_ARI 57251da28a35b46eecb7177d82d10e0e)
+  set(MD5_JPEG_420_ISLOW 9a68f56bc76e466aa7e52f415d0f4a5f)
+  set(MD5_PPM_420M_ISLOW_2_1 9f9de8c0612f8d06869b960b05abf9c9)
+  set(MD5_PPM_420M_ISLOW_15_8 b6875bc070720b899566cc06459b63b7)
+  set(MD5_PPM_420M_ISLOW_13_8 bc3452573c8152f6ae552939ee19f82f)
+  set(MD5_PPM_420M_ISLOW_11_8 d8cc73c0aaacd4556569b59437ba00a5)
+  set(MD5_PPM_420M_ISLOW_9_8 d25e61bc7eac0002f5b393aa223747b6)
+  set(MD5_PPM_420M_ISLOW_7_8 ddb564b7c74a09494016d6cd7502a946)
+  set(MD5_PPM_420M_ISLOW_3_4 8ed8e68808c3fbc4ea764fc9d2968646)
+  set(MD5_PPM_420M_ISLOW_5_8 a3363274999da2366a024efae6d16c9b)
+  set(MD5_PPM_420M_ISLOW_1_2 e692a315cea26b988c8e8b29a5dbcd81)
+  set(MD5_PPM_420M_ISLOW_3_8 79eca9175652ced755155c90e785a996)
+  set(MD5_PPM_420M_ISLOW_1_4 79cd778f8bf1a117690052cacdd54eca)
+  set(MD5_PPM_420M_ISLOW_1_8 391b3d4aca640c8567d6f8745eb2142f)
+  set(MD5_BMP_420_ISLOW_256 4980185e3776e89bd931736e1cddeee6)
+  set(MD5_BMP_420_ISLOW_565 bf9d13e16c4923b92e1faa604d7922cb)
+  set(MD5_BMP_420_ISLOW_565D 6bde71526acc44bcff76f696df8638d2)
+  set(MD5_BMP_420M_ISLOW_565 8dc0185245353cfa32ad97027342216f)
+  set(MD5_BMP_420M_ISLOW_565D ce034037d212bc403330df6f915c161b)
+  set(MD5_PPM_420_ISLOW_SKIP15_31 c4c65c1e43d7275cd50328a61e6534f0)
+  set(MD5_PPM_420_ISLOW_ARI_SKIP16_139 087c6b123db16ac00cb88c5b590bb74a)
+  set(MD5_PPM_420_ISLOW_PROG_CROP62x62_71_71 26eb36ccc7d1f0cb80cdabb0ac8b5d99)
+  set(MD5_PPM_420_ISLOW_ARI_CROP53x53_4_4 886c6775af22370257122f8b16207e6d)
+  set(MD5_PPM_444_ISLOW_SKIP1_6 5606f86874cf26b8fcee1117a0a436a6)
+  set(MD5_PPM_444_ISLOW_PROG_CROP98x98_13_13 db87dc7ce26bcdc7a6b56239ce2b9d6c)
+  set(MD5_PPM_444_ISLOW_ARI_CROP37x37_0_0 cb57b32bd6d03e35432362f7bf184b6d)
+  set(MD5_JPEG_CROP b4197f377e621c4e9b1d20471432610d)
+endif()
+
+if(WITH_JAVA)
+  add_test(TJUnitTest
+    ${Java_JAVA_EXECUTABLE} ${JAVAARGS} -cp java/turbojpeg.jar
+    -Djava.library.path=${CMAKE_CURRENT_BINARY_DIR}/${OBJDIR}
+    TJUnitTest)
+  add_test(TJUnitTest-yuv
+    ${Java_JAVA_EXECUTABLE} ${JAVAARGS} -cp java/turbojpeg.jar
+    -Djava.library.path=${CMAKE_CURRENT_BINARY_DIR}/${OBJDIR}
+    TJUnitTest -yuv)
+  add_test(TJUnitTest-yuv-nopad
+    ${Java_JAVA_EXECUTABLE} ${JAVAARGS} -cp java/turbojpeg.jar
+    -Djava.library.path=${CMAKE_CURRENT_BINARY_DIR}/${OBJDIR}
+    TJUnitTest -yuv -noyuvpad)
+  add_test(TJUnitTest-bi
+    ${Java_JAVA_EXECUTABLE} ${JAVAARGS} -cp java/turbojpeg.jar
+    -Djava.library.path=${CMAKE_CURRENT_BINARY_DIR}/${OBJDIR}
+    TJUnitTest -bi)
+  add_test(TJUnitTest-bi-yuv
+    ${Java_JAVA_EXECUTABLE} ${JAVAARGS} -cp java/turbojpeg.jar
+    -Djava.library.path=${CMAKE_CURRENT_BINARY_DIR}/${OBJDIR}
+    TJUnitTest -bi -yuv)
+  add_test(TJUnitTest-bi-yuv-nopad
+    ${Java_JAVA_EXECUTABLE} ${JAVAARGS} -cp java/turbojpeg.jar
+    -Djava.library.path=${CMAKE_CURRENT_BINARY_DIR}/${OBJDIR}
+    TJUnitTest -bi -yuv -noyuvpad)
+endif()
+
+set(TEST_LIBTYPES "")
+
+if(ENABLE_SHARED)
+  set(TEST_LIBTYPES ${TEST_LIBTYPES} shared)
+endif()
+
+if(ENABLE_STATIC)
+  set(TEST_LIBTYPES ${TEST_LIBTYPES} static)
+endif()
+
+set(TESTIMAGES ${CMAKE_CURRENT_SOURCE_DIR}/testimages)
+set(MD5CMP ${CMAKE_CURRENT_BINARY_DIR}/md5/md5cmp)
+
+if(CMAKE_CROSSCOMPILING)
+  file(RELATIVE_PATH TESTIMAGES ${CMAKE_CURRENT_BINARY_DIR} ${TESTIMAGES})
+  file(RELATIVE_PATH MD5CMP ${CMAKE_CURRENT_BINARY_DIR} ${MD5CMP})
+endif()
+
+# The output of the floating point DCT/IDCT algorithms differs depending on the
+# type of floating point math used, so the FLOATTEST CMake variable must be
+# set in order to tell the testing system which floating point results it
+# should expect:
+#
+# sse = validate against the expected results from the libjpeg-turbo SSE SIMD
+# extensions
+# no-fp-contract = validate against the expected results from the C code when
+# floating point expression contraction is disabled (the
+# default with Clang, with GCC when building for platforms
+# that lack fused multiply-add [FMA] instructions, or when
+# passing -ffp-contract=off to the compiler)
+# fp-contract = validate against the expected results from the C code when
+# floating point expression contraction is enabled (the default
+# with GCC when building for platforms that have fused multiply-
+# add [FMA] instructions or when passing -ffp-contract=fast to
+# the compiler)
+# 387 = validate against the expected results from the C code when the 387 FPU
+# is being used for floating point math (which is generally the default
+# with x86 compilers)
+# msvc = validate against the expected results from the C code when compiled
+# with a 32-bit version of Visual C++
+if(CPU_TYPE STREQUAL "x86_64" OR CPU_TYPE STREQUAL "i386")
+  if(WITH_SIMD)
+    set(DEFAULT_FLOATTEST sse)
+  elseif(CPU_TYPE STREQUAL "x86_64")
+    set(DEFAULT_FLOATTEST no-fp-contract)
+  elseif(CPU_TYPE STREQUAL "i386" AND MSVC)
+    set(DEFAULT_FLOATTEST msvc)
+
+    # else we can't really set an intelligent default for i386.  The appropriate
+    # value could be 387, no-fp-contract, or fp-contract, depending on the
+    # compiler and compiler options.  We leave it to the user to set FLOATTEST
+    # manually.
+  endif()
+else()
+  if((CPU_TYPE STREQUAL "powerpc" OR CPU_TYPE STREQUAL "arm64") AND
+    NOT CMAKE_C_COMPILER_ID STREQUAL "Clang" AND NOT MSVC)
+    set(DEFAULT_FLOATTEST fp-contract)
+  else()
+    set(DEFAULT_FLOATTEST no-fp-contract)
+  endif()
+endif()
+
+# This causes FLOATTEST to reset to the default value if WITH_SIMD has
+# changed.
+if(DEFINED WITH_SIMD_INT AND NOT WITH_SIMD EQUAL WITH_SIMD_INT)
+  set(FORCE_FLOATTEST "FORCE")
+endif()
+
+set(WITH_SIMD_INT ${WITH_SIMD} CACHE INTERNAL "")
+set(FLOATTEST ${DEFAULT_FLOATTEST} CACHE STRING
+  "The type of floating point math used by the floating point DCT/IDCT algorithms.  This tells the testing system which numerical results it should expect from those tests.  [sse = libjpeg-turbo x86/x86-64 SIMD extensions, no-fp-contract = generic FPU with floating point expression contraction disabled, fp-contract = generic FPU with floating point expression contraction enabled, 387 = 387 FPU, msvc = 32-bit Visual Studio] (default = ${DEFAULT_FLOATTEST})"
+  ${FORCE_FLOATTEST})
+message(STATUS "FLOATTEST = ${FLOATTEST}")
+
+if(FLOATTEST)
+  string(TOUPPER ${FLOATTEST} FLOATTEST_UC)
+  string(REGEX REPLACE "-" "_" FLOATTEST_UC ${FLOATTEST_UC})
+  string(TOLOWER ${FLOATTEST} FLOATTEST)
+
+  if(NOT FLOATTEST STREQUAL "sse" AND
+    NOT FLOATTEST STREQUAL "no-fp-contract" AND
+    NOT FLOATTEST STREQUAL "fp-contract" AND NOT FLOATTEST STREQUAL "387" AND
+    NOT FLOATTEST STREQUAL "msvc")
+    message(FATAL_ERROR "\"${FLOATTEST}\" is not a valid value for FLOATTEST.")
+  endif()
+endif()
+
+foreach(libtype ${TEST_LIBTYPES})
+  if(libtype STREQUAL "static")
+    set(suffix -static)
+  endif()
+
+  if(WITH_TURBOJPEG)
+    add_test(tjunittest-${libtype}
+      ${CMAKE_CROSSCOMPILING_EMULATOR} tjunittest${suffix})
+    add_test(tjunittest-${libtype}-alloc
+      ${CMAKE_CROSSCOMPILING_EMULATOR} tjunittest${suffix} -alloc)
+    add_test(tjunittest-${libtype}-yuv
+      ${CMAKE_CROSSCOMPILING_EMULATOR} tjunittest${suffix} -yuv)
+    add_test(tjunittest-${libtype}-yuv-alloc
+      ${CMAKE_CROSSCOMPILING_EMULATOR} tjunittest${suffix} -yuv -alloc)
+    add_test(tjunittest-${libtype}-yuv-nopad
+      ${CMAKE_CROSSCOMPILING_EMULATOR} tjunittest${suffix} -yuv -noyuvpad)
+    add_test(tjunittest-${libtype}-bmp
+      ${CMAKE_CROSSCOMPILING_EMULATOR} tjunittest${suffix} -bmp)
+
+    set(MD5_PPM_GRAY_TILE 89d3ca21213d9d864b50b4e4e7de4ca6)
+    set(MD5_PPM_420_8x8_TILE 847fceab15c5b7b911cb986cf0f71de3)
+    set(MD5_PPM_420_16x16_TILE ca45552a93687e078f7137cc4126a7b0)
+    set(MD5_PPM_420_32x32_TILE d8676f1d6b68df358353bba9844f4a00)
+    set(MD5_PPM_420_64x64_TILE 4e4c1a3d7ea4bace4f868bcbe83b7050)
+    set(MD5_PPM_420_128x128_TILE f24c3429c52265832beab9df72a0ceae)
+    set(MD5_PPM_420M_8x8_TILE bc25320e1f4c31ce2e610e43e9fd173c)
+    set(MD5_PPM_420M_TILE 75ffdf14602258c5c189522af57fa605)
+    set(MD5_PPM_422_8x8_TILE d83dacd9fc73b0a6f10c09acad64eb1e)
+    set(MD5_PPM_422_16x16_TILE 35077fb610d72dd743b1eb0cbcfe10fb)
+    set(MD5_PPM_422_32x32_TILE e6902ed8a449ecc0f0d6f2bf945f65f7)
+    set(MD5_PPM_422_64x64_TILE 2b4502a8f316cedbde1da7bce3d2231e)
+    set(MD5_PPM_422_128x128_TILE f0b5617d578f5e13c8eee215d64d4877)
+    set(MD5_PPM_422M_8x8_TILE 828941d7f41cd6283abd6beffb7fd51d)
+    set(MD5_PPM_422M_TILE e877ae1324c4a280b95376f7f018172f)
+    set(MD5_PPM_444_TILE 7964e41e67cfb8d0a587c0aa4798f9c3)
+
+    # Test compressing from/decompressing to an arbitrary subregion of a larger
+    # image buffer
+    add_test(tjbench-${libtype}-tile-cp
+      ${CMAKE_COMMAND} -E copy_if_different ${TESTIMAGES}/testorig.ppm
+      testout_tile.ppm)
+    add_test(tjbench-${libtype}-tile
+      ${CMAKE_CROSSCOMPILING_EMULATOR} tjbench${suffix} testout_tile.ppm 95
+      -rgb -quiet -tile -benchtime 0.01 -warmup 0)
+    set_tests_properties(tjbench-${libtype}-tile
+      PROPERTIES DEPENDS tjbench-${libtype}-tile-cp)
+
+    foreach(tile 8 16 32 64 128)
+      add_test(tjbench-${libtype}-tile-gray-${tile}x${tile}-cmp
+        ${CMAKE_CROSSCOMPILING_EMULATOR} ${MD5CMP} ${MD5_PPM_GRAY_TILE}
+        testout_tile_GRAY_Q95_${tile}x${tile}.ppm)
+
+      foreach(subsamp 420 422)
+        add_test(tjbench-${libtype}-tile-${subsamp}-${tile}x${tile}-cmp
+          ${CMAKE_CROSSCOMPILING_EMULATOR} ${MD5CMP}
+          ${MD5_PPM_${subsamp}_${tile}x${tile}_TILE}
+          testout_tile_${subsamp}_Q95_${tile}x${tile}.ppm)
+      endforeach()
+
+      add_test(tjbench-${libtype}-tile-444-${tile}x${tile}-cmp
+        ${CMAKE_CROSSCOMPILING_EMULATOR} ${MD5CMP} ${MD5_PPM_444_TILE}
+        testout_tile_444_Q95_${tile}x${tile}.ppm)
+
+      foreach(subsamp gray 420 422 444)
+        set_tests_properties(tjbench-${libtype}-tile-${subsamp}-${tile}x${tile}-cmp
+          PROPERTIES DEPENDS tjbench-${libtype}-tile)
+      endforeach()
+    endforeach()
+
+    add_test(tjbench-${libtype}-tilem-cp
+      ${CMAKE_COMMAND} -E copy_if_different ${TESTIMAGES}/testorig.ppm
+      testout_tilem.ppm)
+    add_test(tjbench-${libtype}-tilem
+      ${CMAKE_CROSSCOMPILING_EMULATOR} tjbench${suffix} testout_tilem.ppm 95
+      -rgb -fastupsample -quiet -tile -benchtime 0.01 -warmup 0)
+    set_tests_properties(tjbench-${libtype}-tilem
+      PROPERTIES DEPENDS tjbench-${libtype}-tilem-cp)
+
+    add_test(tjbench-${libtype}-tile-420m-8x8-cmp
+      ${CMAKE_CROSSCOMPILING_EMULATOR} ${MD5CMP} ${MD5_PPM_420M_8x8_TILE}
+      testout_tilem_420_Q95_8x8.ppm)
+    add_test(tjbench-${libtype}-tile-422m-8x8-cmp
+      ${CMAKE_CROSSCOMPILING_EMULATOR} ${MD5CMP} ${MD5_PPM_422M_8x8_TILE}
+      testout_tilem_422_Q95_8x8.ppm)
+
+    foreach(tile 16 32 64 128)
+      foreach(subsamp 420 422)
+        add_test(tjbench-${libtype}-tile-${subsamp}m-${tile}x${tile}-cmp
+          ${CMAKE_CROSSCOMPILING_EMULATOR} ${MD5CMP}
+          ${MD5_PPM_${subsamp}M_TILE}
+          testout_tilem_${subsamp}_Q95_${tile}x${tile}.ppm)
+      endforeach()
+    endforeach()
+
+    foreach(tile 8 16 32 64 128)
+      foreach(subsamp 420 422)
+        set_tests_properties(tjbench-${libtype}-tile-${subsamp}m-${tile}x${tile}-cmp
+          PROPERTIES DEPENDS tjbench-${libtype}-tilem)
+      endforeach()
+    endforeach()
+  endif()
+
+  # These tests are carefully crafted to provide full coverage of as many of
+  # the underlying algorithms as possible (including all of the
+  # SIMD-accelerated ones.)
+  macro(add_bittest PROG NAME ARGS OUTFILE INFILE MD5SUM)
+    add_test(${PROG}-${libtype}-${NAME}
+      ${CMAKE_CROSSCOMPILING_EMULATOR} ${PROG}${suffix} ${ARGS}
+      -outfile ${OUTFILE} ${INFILE})
+    add_test(${PROG}-${libtype}-${NAME}-cmp
+      ${CMAKE_CROSSCOMPILING_EMULATOR} ${MD5CMP} ${MD5SUM} ${OUTFILE})
+    set_tests_properties(${PROG}-${libtype}-${NAME}-cmp PROPERTIES
+      DEPENDS ${PROG}-${libtype}-${NAME})
+
+    if(${ARGC} GREATER 6)
+      set(DEPENDS ${ARGN})
+      set_tests_properties(${PROG}-${libtype}-${NAME} PROPERTIES
+        DEPENDS ${DEPENDS})
+    endif()
+  endmacro()
+
+  # CC: null  SAMP: fullsize  FDCT: islow  ENT: huff
+  add_bittest(cjpeg rgb-islow "-rgb;-dct;int;-icc;${TESTIMAGES}/test1.icc"
+    testout_rgb_islow.jpg ${TESTIMAGES}/testorig.ppm
+    ${MD5_JPEG_RGB_ISLOW})
+
+  # CC: null  SAMP: fullsize  IDCT: islow  ENT: huff
+  add_bittest(djpeg rgb-islow "-dct;int;-ppm;-icc;testout_rgb_islow.icc"
+    testout_rgb_islow.ppm testout_rgb_islow.jpg
+    ${MD5_PPM_RGB_ISLOW} cjpeg-${libtype}-rgb-islow)
+
+  add_test(djpeg-${libtype}-rgb-islow-icc-cmp
+    ${CMAKE_CROSSCOMPILING_EMULATOR} ${MD5CMP}
+    b06a39d730129122e85c1363ed1bbc9e testout_rgb_islow.icc)
+  set_tests_properties(djpeg-${libtype}-rgb-islow-icc-cmp PROPERTIES
+    DEPENDS djpeg-${libtype}-rgb-islow)
+
+  add_bittest(jpegtran icc "-copy;all;-icc;${TESTIMAGES}/test2.icc"
+    testout_rgb_islow2.jpg testout_rgb_islow.jpg
+    ${MD5_JPEG_RGB_ISLOW2} cjpeg-${libtype}-rgb-islow)
+
+  if(NOT WITH_12BIT)
+    # CC: RGB->RGB565  SAMP: fullsize  IDCT: islow  ENT: huff
+    add_bittest(djpeg rgb-islow-565 "-dct;int;-rgb565;-dither;none;-bmp"
+      testout_rgb_islow_565.bmp testout_rgb_islow.jpg
+      ${MD5_BMP_RGB_ISLOW_565} cjpeg-${libtype}-rgb-islow)
+
+    # CC: RGB->RGB565 (dithered)  SAMP: fullsize  IDCT: islow  ENT: huff
+    add_bittest(djpeg rgb-islow-565D "-dct;int;-rgb565;-bmp"
+      testout_rgb_islow_565D.bmp testout_rgb_islow.jpg
+      ${MD5_BMP_RGB_ISLOW_565D} cjpeg-${libtype}-rgb-islow)
+  endif()
+
+  # CC: RGB->YCC  SAMP: fullsize/h2v1  FDCT: ifast  ENT: 2-pass huff
+  add_bittest(cjpeg 422-ifast-opt "-sample;2x1;-dct;fast;-opt"
+    testout_422_ifast_opt.jpg ${TESTIMAGES}/testorig.ppm
+    ${MD5_JPEG_422_IFAST_OPT})
+
+  # CC: YCC->RGB  SAMP: fullsize/h2v1 fancy  IDCT: ifast  ENT: huff
+  add_bittest(djpeg 422-ifast "-dct;fast"
+    testout_422_ifast.ppm testout_422_ifast_opt.jpg
+    ${MD5_PPM_422_IFAST} cjpeg-${libtype}-422-ifast-opt)
+
+  # CC: RGB->YCC  SAMP: fullsize/h1v2  FDCT: islow  ENT: huff
+  add_bittest(cjpeg 440-islow "-sample;1x2;-dct;int"
+    testout_440_islow.jpg ${TESTIMAGES}/testorig.ppm
+    ${MD5_JPEG_440_ISLOW})
+
+  # CC: YCC->RGB  SAMP: fullsize/h1v2 fancy  IDCT: islow  ENT: huff
+  add_bittest(djpeg 440-islow "-dct;int"
+    testout_440_islow.ppm testout_440_islow.jpg
+    ${MD5_PPM_440_ISLOW} cjpeg-${libtype}-440-islow)
+
+  # CC: YCC->RGB  SAMP: h2v1 merged  IDCT: ifast  ENT: huff
+  add_bittest(djpeg 422m-ifast "-dct;fast;-nosmooth"
+    testout_422m_ifast.ppm testout_422_ifast_opt.jpg
+    ${MD5_PPM_422M_IFAST} cjpeg-${libtype}-422-ifast-opt)
+
+  if(NOT WITH_12BIT)
+    # CC: YCC->RGB565  SAMP: h2v1 merged  IDCT: ifast  ENT: huff
+    add_bittest(djpeg 422m-ifast-565
+      "-dct;int;-nosmooth;-rgb565;-dither;none;-bmp"
+      testout_422m_ifast_565.bmp testout_422_ifast_opt.jpg
+      ${MD5_BMP_422M_IFAST_565} cjpeg-${libtype}-422-ifast-opt)
+
+    # CC: YCC->RGB565 (dithered)  SAMP: h2v1 merged  IDCT: ifast  ENT: huff
+    add_bittest(djpeg 422m-ifast-565D "-dct;int;-nosmooth;-rgb565;-bmp"
+      testout_422m_ifast_565D.bmp testout_422_ifast_opt.jpg
+      ${MD5_BMP_422M_IFAST_565D} cjpeg-${libtype}-422-ifast-opt)
+  endif()
+
+  # CC: RGB->YCC  SAMP: fullsize/h2v2  FDCT: ifast  ENT: prog huff
+  add_bittest(cjpeg 420-q100-ifast-prog
+    "-sample;2x2;-quality;100;-dct;fast;-scans;${TESTIMAGES}/test.scan"
+    testout_420_q100_ifast_prog.jpg ${TESTIMAGES}/testorig.ppm
+    ${MD5_JPEG_420_IFAST_Q100_PROG})
+
+  # CC: YCC->RGB  SAMP: fullsize/h2v2 fancy  IDCT: ifast  ENT: prog huff
+  add_bittest(djpeg 420-q100-ifast-prog "-dct;fast"
+    testout_420_q100_ifast.ppm testout_420_q100_ifast_prog.jpg
+    ${MD5_PPM_420_Q100_IFAST} cjpeg-${libtype}-420-q100-ifast-prog)
+
+  # CC: YCC->RGB  SAMP: h2v2 merged  IDCT: ifast  ENT: prog huff
+  add_bittest(djpeg 420m-q100-ifast-prog "-dct;fast;-nosmooth"
+    testout_420m_q100_ifast.ppm testout_420_q100_ifast_prog.jpg
+    ${MD5_PPM_420M_Q100_IFAST} cjpeg-${libtype}-420-q100-ifast-prog)
+
+  # CC: RGB->Gray  SAMP: fullsize  FDCT: islow  ENT: huff
+  add_bittest(cjpeg gray-islow "-gray;-dct;int"
+    testout_gray_islow.jpg ${TESTIMAGES}/testorig.ppm
+    ${MD5_JPEG_GRAY_ISLOW})
+
+  # CC: Gray->Gray  SAMP: fullsize  IDCT: islow  ENT: huff
+  add_bittest(djpeg gray-islow "-dct;int"
+    testout_gray_islow.ppm testout_gray_islow.jpg
+    ${MD5_PPM_GRAY_ISLOW} cjpeg-${libtype}-gray-islow)
+
+  # CC: Gray->RGB  SAMP: fullsize  IDCT: islow  ENT: huff
+  add_bittest(djpeg gray-islow-rgb "-dct;int;-rgb"
+    testout_gray_islow_rgb.ppm testout_gray_islow.jpg
+    ${MD5_PPM_GRAY_ISLOW_RGB} cjpeg-${libtype}-gray-islow)
+
+  if(NOT WITH_12BIT)
+    # CC: Gray->RGB565  SAMP: fullsize  IDCT: islow  ENT: huff
+    add_bittest(djpeg gray-islow-565 "-dct;int;-rgb565;-dither;none;-bmp"
+      testout_gray_islow_565.bmp testout_gray_islow.jpg
+      ${MD5_BMP_GRAY_ISLOW_565} cjpeg-${libtype}-gray-islow)
+
+    # CC: Gray->RGB565 (dithered)  SAMP: fullsize  IDCT: islow  ENT: huff
+    add_bittest(djpeg gray-islow-565D "-dct;int;-rgb565;-bmp"
+      testout_gray_islow_565D.bmp testout_gray_islow.jpg
+      ${MD5_BMP_GRAY_ISLOW_565D} cjpeg-${libtype}-gray-islow)
+  endif()
+
+  # CC: RGB->YCC  SAMP: fullsize smooth/h2v2 smooth  FDCT: islow
+  # ENT: 2-pass huff
+  add_bittest(cjpeg 420s-ifast-opt "-sample;2x2;-smooth;1;-dct;int;-opt"
+    testout_420s_ifast_opt.jpg ${TESTIMAGES}/testorig.ppm
+    ${MD5_JPEG_420S_IFAST_OPT})
+
+  if(FLOATTEST)
+    # CC: RGB->YCC  SAMP: fullsize/int  FDCT: float  ENT: prog huff
+    add_bittest(cjpeg 3x2-float-prog "-sample;3x2;-dct;float;-prog"
+      testout_3x2_float_prog.jpg ${TESTIMAGES}/testorig.ppm
+      ${MD5_JPEG_3x2_FLOAT_PROG_${FLOATTEST_UC}})
+
+    # CC: YCC->RGB  SAMP: fullsize/int  IDCT: float  ENT: prog huff
+    add_bittest(djpeg 3x2-float-prog "-dct;float"
+      testout_3x2_float.ppm testout_3x2_float_prog.jpg
+      ${MD5_PPM_3x2_FLOAT_${FLOATTEST_UC}} cjpeg-${libtype}-3x2-float-prog)
+  endif()
+
+  # CC: RGB->YCC  SAMP: fullsize/int  FDCT: ifast  ENT: prog huff
+  add_bittest(cjpeg 3x2-ifast-prog "-sample;3x2;-dct;fast;-prog"
+    testout_3x2_ifast_prog.jpg ${TESTIMAGES}/testorig.ppm
+    ${MD5_JPEG_3x2_IFAST_PROG})
+
+  # CC: YCC->RGB  SAMP: fullsize/int  IDCT: ifast  ENT: prog huff
+  add_bittest(djpeg 3x2-ifast-prog "-dct;fast"
+    testout_3x2_ifast.ppm testout_3x2_ifast_prog.jpg
+    ${MD5_PPM_3x2_IFAST} cjpeg-${libtype}-3x2-ifast-prog)
+
+  if(WITH_ARITH_ENC)
+    # CC: YCC->RGB  SAMP: fullsize/h2v2  FDCT: islow  ENT: arith
+    add_bittest(cjpeg 420-islow-ari "-dct;int;-arithmetic"
+      testout_420_islow_ari.jpg ${TESTIMAGES}/testorig.ppm
+      ${MD5_JPEG_420_ISLOW_ARI})
+
+    add_bittest(jpegtran 420-islow-ari "-arithmetic"
+      testout_420_islow_ari2.jpg ${TESTIMAGES}/testimgint.jpg
+      ${MD5_JPEG_420_ISLOW_ARI})
+
+    # CC: YCC->RGB  SAMP: fullsize  FDCT: islow  ENT: prog arith
+    add_bittest(cjpeg 444-islow-progari
+      "-sample;1x1;-dct;int;-prog;-arithmetic"
+      testout_444_islow_progari.jpg ${TESTIMAGES}/testorig.ppm
+      ${MD5_JPEG_444_ISLOW_PROGARI})
+  endif()
+
+  if(WITH_ARITH_DEC)
+    # CC: RGB->YCC  SAMP: h2v2 merged  IDCT: ifast  ENT: arith
+    add_bittest(djpeg 420m-ifast-ari "-fast;-skip;1,20;-ppm"
+      testout_420m_ifast_ari.ppm ${TESTIMAGES}/testimgari.jpg
+      ${MD5_PPM_420M_IFAST_ARI})
+
+    add_bittest(jpegtran 420-islow ""
+      testout_420_islow.jpg ${TESTIMAGES}/testimgari.jpg
+      ${MD5_JPEG_420_ISLOW})
+  endif()
+
+  # 2/1--   CC: YCC->RGB  SAMP: h2v2 merged  IDCT: 16x16 islow  ENT: huff
+  # 15/8--  CC: YCC->RGB  SAMP: h2v2 merged  IDCT: 15x15 islow  ENT: huff
+  # 13/8--  CC: YCC->RGB  SAMP: h2v2 merged  IDCT: 13x13 islow  ENT: huff
+  # 11/8--  CC: YCC->RGB  SAMP: h2v2 merged  IDCT: 11x11 islow  ENT: huff
+  # 9/8--   CC: YCC->RGB  SAMP: h2v2 merged  IDCT: 9x9 islow  ENT: huff
+  # 7/8--   CC: YCC->RGB  SAMP: h2v2 merged  IDCT: 7x7 islow/14x14 islow
+  # ENT: huff
+  # 3/4--   CC: YCC->RGB  SAMP: h2v2 merged  IDCT: 6x6 islow/12x12 islow
+  # ENT: huff
+  # 5/8--   CC: YCC->RGB  SAMP: h2v2 merged  IDCT: 5x5 islow/10x10 islow
+  # ENT: huff
+  # 1/2--   CC: YCC->RGB  SAMP: h2v2 merged  IDCT: 4x4 islow/8x8 islow
+  # ENT: huff
+  # 3/8--   CC: YCC->RGB  SAMP: h2v2 merged  IDCT: 3x3 islow/6x6 islow
+  # ENT: huff
+  # 1/4--   CC: YCC->RGB  SAMP: h2v2 merged  IDCT: 2x2 islow/4x4 islow
+  # ENT: huff
+  # 1/8--   CC: YCC->RGB  SAMP: h2v2 merged  IDCT: 1x1 islow/2x2 islow
+  # ENT: huff
+  foreach(scale 2_1 15_8 13_8 11_8 9_8 7_8 3_4 5_8 1_2 3_8 1_4 1_8)
+    string(REGEX REPLACE "_" "/" scalearg ${scale})
+    add_bittest(djpeg 420m-islow-${scale}
+      "-dct;int;-scale;${scalearg};-nosmooth;-ppm"
+      testout_420m_islow_${scale}.ppm ${TESTIMAGES}/${TESTORIG}
+      ${MD5_PPM_420M_ISLOW_${scale}})
+  endforeach()
+
+  if(NOT WITH_12BIT)
+    # CC: YCC->RGB (dithered)  SAMP: h2v2 fancy  IDCT: islow  ENT: huff
+    add_bittest(djpeg 420-islow-256 "-dct;int;-colors;256;-bmp"
+      testout_420_islow_256.bmp ${TESTIMAGES}/${TESTORIG}
+      ${MD5_BMP_420_ISLOW_256})
+
+    # CC: YCC->RGB565  SAMP: h2v2 fancy  IDCT: islow  ENT: huff
+    add_bittest(djpeg 420-islow-565 "-dct;int;-rgb565;-dither;none;-bmp"
+      testout_420_islow_565.bmp ${TESTIMAGES}/${TESTORIG}
+      ${MD5_BMP_420_ISLOW_565})
+
+    # CC: YCC->RGB565 (dithered)  SAMP: h2v2 fancy  IDCT: islow  ENT: huff
+    add_bittest(djpeg 420-islow-565D "-dct;int;-rgb565;-bmp"
+      testout_420_islow_565D.bmp ${TESTIMAGES}/${TESTORIG}
+      ${MD5_BMP_420_ISLOW_565D})
+
+    # CC: YCC->RGB565  SAMP: h2v2 merged  IDCT: islow  ENT: huff
+    add_bittest(djpeg 420m-islow-565
+      "-dct;int;-nosmooth;-rgb565;-dither;none;-bmp"
+      testout_420m_islow_565.bmp ${TESTIMAGES}/${TESTORIG}
+      ${MD5_BMP_420M_ISLOW_565})
+
+    # CC: YCC->RGB565 (dithered)  SAMP: h2v2 merged  IDCT: islow  ENT: huff
+    add_bittest(djpeg 420m-islow-565D "-dct;int;-nosmooth;-rgb565;-bmp"
+      testout_420m_islow_565D.bmp ${TESTIMAGES}/${TESTORIG}
+      ${MD5_BMP_420M_ISLOW_565D})
+  endif()
+
+  # Partial decode tests.  These tests are designed to cover all of the
+  # possible code paths in jpeg_skip_scanlines().
+
+  # Context rows: Yes  Intra-iMCU row: Yes  iMCU row prefetch: No   ENT: huff
+  add_bittest(djpeg 420-islow-skip15_31 "-dct;int;-skip;15,31;-ppm"
+    testout_420_islow_skip15,31.ppm ${TESTIMAGES}/${TESTORIG}
+    ${MD5_PPM_420_ISLOW_SKIP15_31})
+
+  # Context rows: Yes  Intra-iMCU row: No   iMCU row prefetch: Yes  ENT: arith
+  if(WITH_ARITH_DEC)
+    add_bittest(djpeg 420-islow-ari-skip16_139 "-dct;int;-skip;16,139;-ppm"
+      testout_420_islow_ari_skip16,139.ppm ${TESTIMAGES}/testimgari.jpg
+      ${MD5_PPM_420_ISLOW_ARI_SKIP16_139})
+  endif()
+
+  # Context rows: Yes  Intra-iMCU row: No   iMCU row prefetch: No   ENT: prog huff
+  add_test(cjpeg-${libtype}-420-islow-prog
+    ${CMAKE_CROSSCOMPILING_EMULATOR} cjpeg${suffix} -dct int -prog
+    -outfile testout_420_islow_prog.jpg ${TESTIMAGES}/testorig.ppm)
+  add_bittest(djpeg 420-islow-prog-crop62x62_71_71
+    "-dct;int;-crop;62x62+71+71;-ppm"
+    testout_420_islow_prog_crop62x62,71,71.ppm testout_420_islow_prog.jpg
+    ${MD5_PPM_420_ISLOW_PROG_CROP62x62_71_71} cjpeg-${libtype}-420-islow-prog)
+
+  # Context rows: Yes  Intra-iMCU row: No   iMCU row prefetch: No   ENT: arith
+  if(WITH_ARITH_DEC)
+    add_bittest(djpeg 420-islow-ari-crop53x53_4_4
+      "-dct;int;-crop;53x53+4+4;-ppm"
+      testout_420_islow_ari_crop53x53,4,4.ppm ${TESTIMAGES}/testimgari.jpg
+      ${MD5_PPM_420_ISLOW_ARI_CROP53x53_4_4})
+  endif()
+
+  # Context rows: No   Intra-iMCU row: Yes  ENT: huff
+  add_test(cjpeg-${libtype}-444-islow
+    ${CMAKE_CROSSCOMPILING_EMULATOR} cjpeg${suffix} -dct int -sample 1x1
+    -outfile testout_444_islow.jpg ${TESTIMAGES}/testorig.ppm)
+  add_bittest(djpeg 444-islow-skip1_6 "-dct;int;-skip;1,6;-ppm"
+    testout_444_islow_skip1,6.ppm testout_444_islow.jpg
+    ${MD5_PPM_444_ISLOW_SKIP1_6} cjpeg-${libtype}-444-islow)
+
+  # Context rows: No   Intra-iMCU row: No   ENT: prog huff
+  add_test(cjpeg-${libtype}-444-islow-prog
+    ${CMAKE_CROSSCOMPILING_EMULATOR} cjpeg${suffix} -dct int -prog -sample 1x1
+    -outfile testout_444_islow_prog.jpg ${TESTIMAGES}/testorig.ppm)
+  add_bittest(djpeg 444-islow-prog-crop98x98_13_13
+    "-dct;int;-crop;98x98+13+13;-ppm"
+    testout_444_islow_prog_crop98x98,13,13.ppm testout_444_islow_prog.jpg
+    ${MD5_PPM_444_ISLOW_PROG_CROP98x98_13_13} cjpeg-${libtype}-444-islow-prog)
+
+  # Context rows: No   Intra-iMCU row: No   ENT: arith
+  if(WITH_ARITH_ENC)
+    add_test(cjpeg-${libtype}-444-islow-ari
+      ${CMAKE_CROSSCOMPILING_EMULATOR} cjpeg${suffix} -dct int -arithmetic
+      -sample 1x1 -outfile testout_444_islow_ari.jpg
+      ${TESTIMAGES}/testorig.ppm)
+
+    if(WITH_ARITH_DEC)
+      add_bittest(djpeg 444-islow-ari-crop37x37_0_0
+        "-dct;int;-crop;37x37+0+0;-ppm"
+        testout_444_islow_ari_crop37x37,0,0.ppm testout_444_islow_ari.jpg
+        ${MD5_PPM_444_ISLOW_ARI_CROP37x37_0_0} cjpeg-${libtype}-444-islow-ari)
+    endif()
+  endif()
+
+  add_bittest(jpegtran crop "-crop;120x90+20+50;-transpose;-perfect"
+    testout_crop.jpg ${TESTIMAGES}/${TESTORIG}
+    ${MD5_JPEG_CROP})
+endforeach()
+
+add_custom_target(testclean COMMAND ${CMAKE_COMMAND} -P
+  ${CMAKE_CURRENT_SOURCE_DIR}/cmakescripts/testclean.cmake)
+
+configure_file(croptest.in croptest @ONLY)
+add_custom_target(croptest
+  COMMAND echo croptest
+  COMMAND ${BASH} ${CMAKE_CURRENT_BINARY_DIR}/croptest)
+
+if(WITH_TURBOJPEG)
+  configure_file(tjbenchtest.in tjbenchtest @ONLY)
+  configure_file(tjexampletest.in tjexampletest @ONLY)
+
+  if(WIN32)
+    set(BASH bash)
+  endif()
+
+  if(WITH_JAVA)
+    configure_file(tjbenchtest.java.in tjbenchtest.java @ONLY)
+    configure_file(tjexampletest.java.in tjexampletest.java @ONLY)
+    add_custom_target(tjtest
+      COMMAND echo tjbenchtest
+      COMMAND ${BASH} ${CMAKE_CURRENT_BINARY_DIR}/tjbenchtest
+      COMMAND echo tjbenchtest -alloc
+      COMMAND ${BASH} ${CMAKE_CURRENT_BINARY_DIR}/tjbenchtest -alloc
+      COMMAND echo tjbenchtest -yuv
+      COMMAND ${BASH} ${CMAKE_CURRENT_BINARY_DIR}/tjbenchtest -yuv
+      COMMAND echo tjbenchtest -yuv -alloc
+      COMMAND ${BASH} ${CMAKE_CURRENT_BINARY_DIR}/tjbenchtest -yuv -alloc
+      COMMAND echo tjbenchtest -progressive
+      COMMAND ${BASH} ${CMAKE_CURRENT_BINARY_DIR}/tjbenchtest -progressive
+      COMMAND echo tjbenchtest -progressive -yuv
+      COMMAND ${BASH} ${CMAKE_CURRENT_BINARY_DIR}/tjbenchtest -progressive -yuv
+      COMMAND echo tjexampletest
+      COMMAND ${BASH} ${CMAKE_CURRENT_BINARY_DIR}/tjexampletest
+      COMMAND echo tjbenchtest.java
+      COMMAND ${BASH} ${CMAKE_CURRENT_BINARY_DIR}/tjbenchtest.java
+      COMMAND echo tjbenchtest.java -yuv
+      COMMAND ${BASH} ${CMAKE_CURRENT_BINARY_DIR}/tjbenchtest.java -yuv
+      COMMAND echo tjbenchtest.java -progressive
+      COMMAND ${BASH} ${CMAKE_CURRENT_BINARY_DIR}/tjbenchtest.java -progressive
+      COMMAND echo tjexampletest.java -progressive -yuv
+      COMMAND ${BASH} ${CMAKE_CURRENT_BINARY_DIR}/tjbenchtest.java
+      -progressive -yuv
+      COMMAND echo tjexampletest.java
+      COMMAND ${BASH} ${CMAKE_CURRENT_BINARY_DIR}/tjexampletest.java
+      DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/tjbenchtest
+      ${CMAKE_CURRENT_BINARY_DIR}/tjbenchtest.java
+      ${CMAKE_CURRENT_BINARY_DIR}/tjexampletest)
+  else()
+    add_custom_target(tjtest
+      COMMAND echo tjbenchtest
+      COMMAND ${BASH} ${CMAKE_CURRENT_BINARY_DIR}/tjbenchtest
+      COMMAND echo tjbenchtest -alloc
+      COMMAND ${BASH} ${CMAKE_CURRENT_BINARY_DIR}/tjbenchtest -alloc
+      COMMAND echo tjbenchtest -yuv
+      COMMAND ${BASH} ${CMAKE_CURRENT_BINARY_DIR}/tjbenchtest -yuv
+      COMMAND echo tjbenchtest -yuv -alloc
+      COMMAND ${BASH} ${CMAKE_CURRENT_BINARY_DIR}/tjbenchtest -yuv -alloc
+      COMMAND echo tjbenchtest -progressive
+      COMMAND ${BASH} ${CMAKE_CURRENT_BINARY_DIR}/tjbenchtest -progressive
+      COMMAND echo tjbenchtest -progressive -yuv
+      COMMAND ${BASH} ${CMAKE_CURRENT_BINARY_DIR}/tjbenchtest -progressive -yuv
+      COMMAND echo tjexampletest
+      COMMAND ${BASH} ${CMAKE_CURRENT_BINARY_DIR}/tjexampletest
+      DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/tjbenchtest)
+  endif()
+endif()
+
+# ##############################################################################
+# INSTALLATION
+# ##############################################################################
+set(EXE ${CMAKE_EXECUTABLE_SUFFIX})
+
+# if(WITH_TURBOJPEG)
+# if(ENABLE_SHARED)
+# install(TARGETS turbojpeg EXPORT ${CMAKE_PROJECT_NAME}Targets
+# INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
+# ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+# LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+# RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
+# install(TARGETS tjbench
+# RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
+# if(NOT CMAKE_VERSION VERSION_LESS "3.1" AND MSVC AND
+# CMAKE_C_LINKER_SUPPORTS_PDB)
+# install(FILES "$<TARGET_PDB_FILE:turbojpeg>"
+# DESTINATION ${CMAKE_INSTALL_BINDIR} OPTIONAL)
+# endif()
+# endif()
+# if(ENABLE_STATIC)
+# install(TARGETS turbojpeg_static EXPORT ${CMAKE_PROJECT_NAME}Targets
+# INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
+# ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
+# if(NOT ENABLE_SHARED)
+# if(MSVC_IDE OR XCODE)
+# set(DIR "${CMAKE_CURRENT_BINARY_DIR}/\${CMAKE_INSTALL_CONFIG_NAME}")
+# else()
+# set(DIR ${CMAKE_CURRENT_BINARY_DIR})
+# endif()
+# install(PROGRAMS ${DIR}/tjbench-static${EXE}
+# DESTINATION ${CMAKE_INSTALL_BINDIR} RENAME tjbench${EXE})
+# endif()
+# endif()
+# install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/turbojpeg.h
+# DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
+# endif()
+
+# if(ENABLE_STATIC)
+# # install(TARGETS jpeg_static EXPORT ${CMAKE_PROJECT_NAME}Targets
+# #   INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
+# #   ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
+# if(NOT ENABLE_SHARED)
+# if(MSVC_IDE OR XCODE)
+# set(DIR "${CMAKE_CURRENT_BINARY_DIR}/\${CMAKE_INSTALL_CONFIG_NAME}")
+# else()
+# set(DIR ${CMAKE_CURRENT_BINARY_DIR})
+# endif()
+# # install(PROGRAMS ${DIR}/cjpeg_static${EXE}
+# #   DESTINATION ${CMAKE_INSTALL_BINDIR} RENAME cjpeg${EXE})
+# # install(PROGRAMS ${DIR}/djpeg_static${EXE}
+# #   DESTINATION ${CMAKE_INSTALL_BINDIR} RENAME djpeg${EXE})
+# # install(PROGRAMS ${DIR}/jpegtran-static${EXE}
+# #   DESTINATION ${CMAKE_INSTALL_BINDIR} RENAME jpegtran${EXE})
+# endif()
+# endif()
+
+# # install(TARGETS rdjpgcom wrjpgcom RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
+
+# # install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/README.ijg
+# #   ${CMAKE_CURRENT_SOURCE_DIR}/README.md ${CMAKE_CURRENT_SOURCE_DIR}/example.txt
+# #   ${CMAKE_CURRENT_SOURCE_DIR}/tjexample.c
+# #   ${CMAKE_CURRENT_SOURCE_DIR}/libjpeg.txt
+# #   ${CMAKE_CURRENT_SOURCE_DIR}/structure.txt
+# #   ${CMAKE_CURRENT_SOURCE_DIR}/usage.txt ${CMAKE_CURRENT_SOURCE_DIR}/wizard.txt
+# #   ${CMAKE_CURRENT_SOURCE_DIR}/LICENSE.md DESTINATION ${CMAKE_INSTALL_DOCDIR})
+# if(WITH_JAVA)
+# install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/java/TJExample.java
+# DESTINATION ${CMAKE_INSTALL_DOCDIR})
+# endif()
+
+# if(UNIX OR MINGW)
+# # install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/cjpeg.1
+# #   ${CMAKE_CURRENT_SOURCE_DIR}/djpeg.1 ${CMAKE_CURRENT_SOURCE_DIR}/jpegtran.1
+# #   ${CMAKE_CURRENT_SOURCE_DIR}/rdjpgcom.1
+# #   ${CMAKE_CURRENT_SOURCE_DIR}/wrjpgcom.1
+# #   DESTINATION ${CMAKE_INSTALL_MANDIR}/man1)
+# endif()
+# # install(FILES ${CMAKE_CURRENT_BINARY_DIR}/pkgscripts/libjpeg.pc
+# #   ${CMAKE_CURRENT_BINARY_DIR}/pkgscripts/libturbojpeg.pc
+# #   DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig)
+# # install(FILES
+# #   ${CMAKE_CURRENT_BINARY_DIR}/pkgscripts/${CMAKE_PROJECT_NAME}Config.cmake
+# #   ${CMAKE_CURRENT_BINARY_DIR}/pkgscripts/${CMAKE_PROJECT_NAME}ConfigVersion.cmake
+# #   DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/${CMAKE_PROJECT_NAME})
+# # install(EXPORT ${CMAKE_PROJECT_NAME}Targets
+# #   NAMESPACE ${CMAKE_PROJECT_NAME}::
+# #   DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/${CMAKE_PROJECT_NAME})
+
+# # install(FILES ${CMAKE_CURRENT_BINARY_DIR}/jconfig.h
+# #   ${CMAKE_CURRENT_SOURCE_DIR}/jerror.h ${CMAKE_CURRENT_SOURCE_DIR}/jmorecfg.h
+# #   ${CMAKE_CURRENT_SOURCE_DIR}/jpeglib.h
+# #   DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
+
+# include(cmakescripts/BuildPackages.cmake)
+
+# configure_file("${CMAKE_CURRENT_SOURCE_DIR}/cmakescripts/cmake_uninstall.cmake.in"
+# "cmake_uninstall.cmake" IMMEDIATE @ONLY)
+
+# add_custom_target(uninstall COMMAND ${CMAKE_COMMAND} -P cmake_uninstall.cmake)
diff --git a/3rdparty/libjpeg/src/ChangeLog.md b/3rdparty/libjpeg/src/ChangeLog.md
new file mode 100644
index 00000000..6eb06f0e
--- /dev/null
+++ b/3rdparty/libjpeg/src/ChangeLog.md
@@ -0,0 +1,1701 @@
+2.0.90 (2.1 beta1)
+==================
+
+### Significant changes relative to 2.0.6:
+
+1. The build system, x86-64 SIMD extensions, and accelerated Huffman codec now
+support the x32 ABI on Linux, which allows for using x86-64 instructions with
+32-bit pointers.  The x32 ABI is generally enabled by adding `-mx32` to the
+compiler flags.
+
+     Caveats:
+     - CMake 3.9.0 or later is required in order for the build system to
+automatically detect an x32 build.
+     - Java does not support the x32 ABI, and thus the TurboJPEG Java API will
+automatically be disabled with x32 builds.
+
+2. Added Loongson MMI SIMD implementations of the RGB-to-grayscale, 4:2:2 fancy
+chroma upsampling, 4:2:2 and 4:2:0 merged chroma upsampling/color conversion,
+and fast integer DCT/IDCT algorithms.  Relative to libjpeg-turbo 2.0.x, this
+speeds up:
+
+     - the compression of RGB source images into grayscale JPEG images by
+approximately 20%
+     - the decompression of 4:2:2 JPEG images by approximately 40-60% when
+using fancy upsampling
+     - the decompression of 4:2:2 and 4:2:0 JPEG images by approximately
+15-20% when using merged upsampling
+     - the compression of RGB source images by approximately 30-45% when using
+the fast integer DCT
+     - the decompression of JPEG images into RGB destination images by
+approximately 2x when using the fast integer IDCT
+
+    The overall decompression speedup for RGB images is now approximately
+2.3-3.7x (compared to 2-3.5x with libjpeg-turbo 2.0.x.)
+
+3. 32-bit (Armv7 or Armv7s) iOS builds of libjpeg-turbo are no longer
+supported, and the libjpeg-turbo build system can no longer be used to package
+such builds.  32-bit iOS apps cannot run in iOS 11 and later, and the App Store
+no longer allows them.
+
+4. 32-bit (i386) OS X/macOS builds of libjpeg-turbo are no longer supported,
+and the libjpeg-turbo build system can no longer be used to package such
+builds.  32-bit Mac applications cannot run in macOS 10.15 "Catalina" and
+later, and the App Store no longer allows them.
+
+5. The SSE2 (x86 SIMD) and C Huffman encoding algorithms have been
+significantly optimized, resulting in a measured average overall compression
+speedup of 12-28% for 64-bit code and 22-52% for 32-bit code on various Intel
+and AMD CPUs, as well as a measured average overall compression speedup of
+0-23% on platforms that do not have a SIMD-accelerated Huffman encoding
+implementation.
+
+6. The block smoothing algorithm that is applied by default when decompressing
+progressive Huffman-encoded JPEG images has been improved in the following
+ways:
+
+     - The algorithm is now more fault-tolerant.  Previously, if a particular
+scan was incomplete, then the smoothing parameters for the incomplete scan
+would be applied to the entire output image, including the parts of the image
+that were generated by the prior (complete) scan.  Visually, this had the
+effect of removing block smoothing from lower-frequency scans if they were
+followed by an incomplete higher-frequency scan.  libjpeg-turbo now applies
+block smoothing parameters to each iMCU row based on which scan generated the
+pixels in that row, rather than always using the block smoothing parameters for
+the most recent scan.
+     - When applying block smoothing to DC scans, a Gaussian-like kernel with a
+5x5 window is used to reduce the "blocky" appearance.
+
+7. Added SIMD acceleration for progressive Huffman encoding on Arm platforms.
+This speeds up the compression of full-color progressive JPEGs by about 30-40%
+on average (relative to libjpeg-turbo 2.0.x) when using modern Arm CPUs.
+
+8. Added configure-time and run-time auto-detection of Loongson MMI SIMD
+instructions, so that the Loongson MMI SIMD extensions can be included in any
+MIPS64 libjpeg-turbo build.
+
+9. Added fault tolerance features to djpeg and jpegtran, mainly to demonstrate
+methods by which applications can guard against the exploits of the JPEG format
+described in the report
+["Two Issues with the JPEG Standard"](https://libjpeg-turbo.org/pmwiki/uploads/About/TwoIssueswiththeJPEGStandard.pdf).
+
+     - Both programs now accept a `-maxscans` argument, which can be used to
+limit the number of allowable scans in the input file.
+     - Both programs now accept a `-strict` argument, which can be used to
+treat all warnings as fatal.
+
+10. CMake package config files are now included for both the libjpeg and
+TurboJPEG API libraries.  This facilitates using libjpeg-turbo with CMake's
+`find_package()` function.  For example:
+
+        find_package(libjpeg-turbo CONFIG REQUIRED)
+
+        add_executable(libjpeg_program libjpeg_program.c)
+        target_link_libraries(libjpeg_program PUBLIC libjpeg-turbo::jpeg)
+
+        add_executable(libjpeg_program_static libjpeg_program.c)
+        target_link_libraries(libjpeg_program_static PUBLIC
+          libjpeg-turbo::jpeg-static)
+
+        add_executable(turbojpeg_program turbojpeg_program.c)
+        target_link_libraries(turbojpeg_program PUBLIC
+          libjpeg-turbo::turbojpeg)
+
+        add_executable(turbojpeg_program_static turbojpeg_program.c)
+        target_link_libraries(turbojpeg_program_static PUBLIC
+          libjpeg-turbo::turbojpeg-static)
+
+11. Since the Unisys LZW patent has long expired, cjpeg and djpeg can now
+read/write both LZW-compressed and uncompressed GIF files (feature ported from
+jpeg-6a and jpeg-9d.)
+
+12. jpegtran now includes the `-wipe` and `-drop` options from jpeg-9a and
+jpeg-9d, as well as the ability to expand the image size using the `-crop`
+option.  Refer to jpegtran.1 or usage.txt for more details.
+
+13. Added a complete intrinsics implementation of the Arm Neon SIMD extensions,
+thus providing SIMD acceleration on Arm platforms for all of the algorithms
+that are SIMD-accelerated on x86 platforms.  This new implementation is
+significantly faster in some cases than the old GAS implementation--
+depending on the algorithms used, the type of CPU core, and the compiler.  GCC,
+as of this writing, does not provide a full or optimal set of Neon intrinsics,
+so for performance reasons, the default when building libjpeg-turbo with GCC is
+to continue using the GAS implementation of the following algorithms:
+
+     - 32-bit RGB-to-YCbCr color conversion
+     - 32-bit fast and accurate inverse DCT
+     - 64-bit RGB-to-YCbCr and YCbCr-to-RGB color conversion
+     - 64-bit accurate forward and inverse DCT
+     - 64-bit Huffman encoding
+
+    A new CMake variable (`NEON_INTRINSICS`) can be used to override this
+default.
+
+    Since the new intrinsics implementation includes SIMD acceleration
+for merged upsampling/color conversion, 1.5.1[5] is no longer necessary and has
+been reverted.
+
+14. The Arm Neon SIMD extensions can now be built using Visual Studio.
+
+15. The build system can now be used to generate a universal x86-64 + Armv8
+libjpeg-turbo SDK package for both iOS and macOS.
+
+
+2.0.6
+=====
+
+### Significant changes relative to 2.0.5:
+
+1. Fixed "using JNI after critical get" errors that occurred on Android
+platforms when using any of the YUV encoding/compression/decompression/decoding
+methods in the TurboJPEG Java API.
+
+2. Fixed or worked around multiple issues with `jpeg_skip_scanlines()`:
+
+     - Fixed segfaults or "Corrupt JPEG data: premature end of data segment"
+errors in `jpeg_skip_scanlines()` that occurred when decompressing 4:2:2 or
+4:2:0 JPEG images using merged (non-fancy) upsampling/color conversion (that
+is, when setting `cinfo.do_fancy_upsampling` to `FALSE`.)  2.0.0[6] was a
+similar fix, but it did not cover all cases.
+     - `jpeg_skip_scanlines()` now throws an error if two-pass color
+quantization is enabled.  Two-pass color quantization never worked properly
+with `jpeg_skip_scanlines()`, and the issues could not readily be fixed.
+     - Fixed an issue whereby `jpeg_skip_scanlines()` always returned 0 when
+skipping past the end of an image.
+
+3. The Arm 64-bit (Armv8) Neon SIMD extensions can now be built using MinGW
+toolchains targetting Arm64 (AArch64) Windows binaries.
+
+4. Fixed unexpected visual artifacts that occurred when using
+`jpeg_crop_scanline()` and interblock smoothing while decompressing only the DC
+scan of a progressive JPEG image.
+
+5. Fixed an issue whereby libjpeg-turbo would not build if 12-bit-per-component
+JPEG support (`WITH_12BIT`) was enabled along with libjpeg v7 or libjpeg v8
+API/ABI emulation (`WITH_JPEG7` or `WITH_JPEG8`.)
+
+
+2.0.5
+=====
+
+### Significant changes relative to 2.0.4:
+
+1. Worked around issues in the MIPS DSPr2 SIMD extensions that caused failures
+in the libjpeg-turbo regression tests.  Specifically, the
+`jsimd_h2v1_downsample_dspr2()` and `jsimd_h2v2_downsample_dspr2()` functions
+in the MIPS DSPr2 SIMD extensions are now disabled until/unless they can be
+fixed, and other functions that are incompatible with big endian MIPS CPUs are
+disabled when building libjpeg-turbo for such CPUs.
+
+2. Fixed an oversight in the `TJCompressor.compress(int)` method in the
+TurboJPEG Java API that caused an error ("java.lang.IllegalStateException: No
+source image is associated with this instance") when attempting to use that
+method to compress a YUV image.
+
+3. Fixed an issue (CVE-2020-13790) in the PPM reader that caused a buffer
+overrun in cjpeg, TJBench, or the `tjLoadImage()` function if one of the values
+in a binary PPM/PGM input file exceeded the maximum value defined in the file's
+header and that maximum value was less than 255.  libjpeg-turbo 1.5.0 already
+included a similar fix for binary PPM/PGM files with maximum values greater
+than 255.
+
+4. The TurboJPEG API library's global error handler, which is used in functions
+such as `tjBufSize()` and `tjLoadImage()` that do not require a TurboJPEG
+instance handle, is now thread-safe on platforms that support thread-local
+storage.
+
+
+2.0.4
+=====
+
+### Significant changes relative to 2.0.3:
+
+1. Fixed a regression in the Windows packaging system (introduced by
+2.0 beta1[2]) whereby, if both the 64-bit libjpeg-turbo SDK for GCC and the
+64-bit libjpeg-turbo SDK for Visual C++ were installed on the same system, only
+one of them could be uninstalled.
+
+2. Fixed a signed integer overflow and subsequent segfault that occurred when
+attempting to decompress images with more than 715827882 pixels using the
+64-bit C version of TJBench.
+
+3. Fixed out-of-bounds write in `tjDecompressToYUV2()` and
+`tjDecompressToYUVPlanes()` (sometimes manifesting as a double free) that
+occurred when attempting to decompress grayscale JPEG images that were
+compressed with a sampling factor other than 1 (for instance, with
+`cjpeg -grayscale -sample 2x2`).
+
+4. Fixed a regression introduced by 2.0.2[5] that caused the TurboJPEG API to
+incorrectly identify some JPEG images with unusual sampling factors as 4:4:4
+JPEG images.  This was known to cause a buffer overflow when attempting to
+decompress some such images using `tjDecompressToYUV2()` or
+`tjDecompressToYUVPlanes()`.
+
+5. Fixed an issue, detected by ASan, whereby attempting to losslessly transform
+a specially-crafted malformed JPEG image containing an extremely-high-frequency
+coefficient block (junk image data that could never be generated by a
+legitimate JPEG compressor) could cause the Huffman encoder's local buffer to
+be overrun. (Refer to 1.4.0[9] and 1.4beta1[15].)  Given that the buffer
+overrun was fully contained within the stack and did not cause a segfault or
+other user-visible errant behavior, and given that the lossless transformer
+(unlike the decompressor) is not generally exposed to arbitrary data exploits,
+this issue did not likely pose a security risk.
+
+6. The Arm 64-bit (Armv8) Neon SIMD assembly code now stores constants in a
+separate read-only data section rather than in the text section, to support
+execute-only memory layouts.
+
+
+2.0.3
+=====
+
+### Significant changes relative to 2.0.2:
+
+1. Fixed "using JNI after critical get" errors that occurred on Android
+platforms when passing invalid arguments to certain methods in the TurboJPEG
+Java API.
+
+2. Fixed a regression in the SIMD feature detection code, introduced by
+the AVX2 SIMD extensions (2.0 beta1[1]), that was known to cause an illegal
+instruction exception, in rare cases, on CPUs that lack support for CPUID leaf
+07H (or on which the maximum CPUID leaf has been limited by way of a BIOS
+setting.)
+
+3. The 4:4:0 (h1v2) fancy (smooth) chroma upsampling algorithm in the
+decompressor now uses a similar bias pattern to that of the 4:2:2 (h2v1) fancy
+chroma upsampling algorithm, rounding up or down the upsampled result for
+alternate pixels rather than always rounding down.  This ensures that,
+regardless of whether a 4:2:2 JPEG image is rotated or transposed prior to
+decompression (in the frequency domain) or after decompression (in the spatial
+domain), the final image will be similar.
+
+4. Fixed an integer overflow and subsequent segfault that occurred when
+attempting to compress or decompress images with more than 1 billion pixels
+using the TurboJPEG API.
+
+5. Fixed a regression introduced by 2.0 beta1[15] whereby attempting to
+generate a progressive JPEG image on an SSE2-capable CPU using a scan script
+containing one or more scans with lengths divisible by 16 would result in an
+error ("Missing Huffman code table entry") and an invalid JPEG image.
+
+6. Fixed an issue whereby `tjDecodeYUV()` and `tjDecodeYUVPlanes()` would throw
+an error ("Invalid progressive parameters") or a warning ("Inconsistent
+progression sequence") if passed a TurboJPEG instance that was previously used
+to decompress a progressive JPEG image.
+
+
+2.0.2
+=====
+
+### Significant changes relative to 2.0.1:
+
+1. Fixed a regression introduced by 2.0.1[5] that prevented a runtime search
+path (rpath) from being embedded in the libjpeg-turbo shared libraries and
+executables for macOS and iOS.  This caused a fatal error of the form
+"dyld: Library not loaded" when attempting to use one of the executables,
+unless `DYLD_LIBRARY_PATH` was explicitly set to the location of the
+libjpeg-turbo shared libraries.
+
+2. Fixed an integer overflow and subsequent segfault (CVE-2018-20330) that
+occurred when attempting to load a BMP file with more than 1 billion pixels
+using the `tjLoadImage()` function.
+
+3. Fixed a buffer overrun (CVE-2018-19664) that occurred when attempting to
+decompress a specially-crafted malformed JPEG image to a 256-color BMP using
+djpeg.
+
+4. Fixed a floating point exception that occurred when attempting to
+decompress a specially-crafted malformed JPEG image with a specified image
+width or height of 0 using the C version of TJBench.
+
+5. The TurboJPEG API will now decompress 4:4:4 JPEG images with 2x1, 1x2, 3x1,
+or 1x3 luminance and chrominance sampling factors.  This is a non-standard way
+of specifying 1x subsampling (normally 4:4:4 JPEGs have 1x1 luminance and
+chrominance sampling factors), but the JPEG format and the libjpeg API both
+allow it.
+
+6. Fixed a regression introduced by 2.0 beta1[7] that caused djpeg to generate
+incorrect PPM images when used with the `-colors` option.
+
+7. Fixed an issue whereby a static build of libjpeg-turbo (a build in which
+`ENABLE_SHARED` is `0`) could not be installed using the Visual Studio IDE.
+
+8. Fixed a severe performance issue in the Loongson MMI SIMD extensions that
+occurred when compressing RGB images whose image rows were not 64-bit-aligned.
+
+
+2.0.1
+=====
+
+### Significant changes relative to 2.0.0:
+
+1. Fixed a regression introduced with the new CMake-based Un*x build system,
+whereby jconfig.h could cause compiler warnings of the form
+`"HAVE_*_H" redefined` if it was included by downstream Autotools-based
+projects that used `AC_CHECK_HEADERS()` to check for the existence of locale.h,
+stddef.h, or stdlib.h.
+
+2. The `jsimd_quantize_float_dspr2()` and `jsimd_convsamp_float_dspr2()`
+functions in the MIPS DSPr2 SIMD extensions are now disabled at compile time
+if the soft float ABI is enabled.  Those functions use instructions that are
+incompatible with the soft float ABI.
+
+3. Fixed a regression in the SIMD feature detection code, introduced by
+the AVX2 SIMD extensions (2.0 beta1[1]), that caused libjpeg-turbo to crash on
+Windows 7 if Service Pack 1 was not installed.
+
+4. Fixed out-of-bounds read in cjpeg that occurred when attempting to compress
+a specially-crafted malformed color-index (8-bit-per-sample) Targa file in
+which some of the samples (color indices) exceeded the bounds of the Targa
+file's color table.
+
+5. Fixed an issue whereby installing a fully static build of libjpeg-turbo
+(a build in which `CFLAGS` contains `-static` and `ENABLE_SHARED` is `0`) would
+fail with "No valid ELF RPATH or RUNPATH entry exists in the file."
+
+
+2.0.0
+=====
+
+### Significant changes relative to 2.0 beta1:
+
+1. The TurboJPEG API can now decompress CMYK JPEG images that have subsampled M
+and Y components (not to be confused with YCCK JPEG images, in which the C/M/Y
+components have been transformed into luma and chroma.)   Previously, an error
+was generated ("Could not determine subsampling type for JPEG image") when such
+an image was passed to `tjDecompressHeader3()`, `tjTransform()`,
+`tjDecompressToYUVPlanes()`, `tjDecompressToYUV2()`, or the equivalent Java
+methods.
+
+2. Fixed an issue (CVE-2018-11813) whereby a specially-crafted malformed input
+file (specifically, a file with a valid Targa header but incomplete pixel data)
+would cause cjpeg to generate a JPEG file that was potentially thousands of
+times larger than the input file.  The Targa reader in cjpeg was not properly
+detecting that the end of the input file had been reached prematurely, so after
+all valid pixels had been read from the input, the reader injected dummy pixels
+with values of 255 into the JPEG compressor until the number of pixels
+specified in the Targa header had been compressed.  The Targa reader in cjpeg
+now behaves like the PPM reader and aborts compression if the end of the input
+file is reached prematurely.  Because this issue only affected cjpeg and not
+the underlying library, and because it did not involve any out-of-bounds reads
+or other exploitable behaviors, it was not believed to represent a security
+threat.
+
+3. Fixed an issue whereby the `tjLoadImage()` and `tjSaveImage()` functions
+would produce a "Bogus message code" error message if the underlying bitmap and
+PPM readers/writers threw an error that was specific to the readers/writers
+(as opposed to a general libjpeg API error.)
+
+4. Fixed an issue (CVE-2018-1152) whereby a specially-crafted malformed BMP
+file, one in which the header specified an image width of 1073741824 pixels,
+would trigger a floating point exception (division by zero) in the
+`tjLoadImage()` function when attempting to load the BMP file into a
+4-component image buffer.
+
+5. Fixed an issue whereby certain combinations of calls to
+`jpeg_skip_scanlines()` and `jpeg_read_scanlines()` could trigger an infinite
+loop when decompressing progressive JPEG images that use vertical chroma
+subsampling (for instance, 4:2:0 or 4:4:0.)
+
+6. Fixed a segfault in `jpeg_skip_scanlines()` that occurred when decompressing
+a 4:2:2 or 4:2:0 JPEG image using the merged (non-fancy) upsampling algorithms
+(that is, when setting `cinfo.do_fancy_upsampling` to `FALSE`.)
+
+7. The new CMake-based build system will now disable the MIPS DSPr2 SIMD
+extensions if it detects that the compiler does not support DSPr2 instructions.
+
+8. Fixed out-of-bounds read in cjpeg (CVE-2018-14498) that occurred when
+attempting to compress a specially-crafted malformed color-index
+(8-bit-per-sample) BMP file in which some of the samples (color indices)
+exceeded the bounds of the BMP file's color table.
+
+9. Fixed a signed integer overflow in the progressive Huffman decoder, detected
+by the Clang and GCC undefined behavior sanitizers, that could be triggered by
+attempting to decompress a specially-crafted malformed JPEG image.  This issue
+did not pose a security threat, but removing the warning made it easier to
+detect actual security issues, should they arise in the future.
+
+
+1.5.90 (2.0 beta1)
+==================
+
+### Significant changes relative to 1.5.3:
+
+1. Added AVX2 SIMD implementations of the colorspace conversion, chroma
+downsampling and upsampling, integer quantization and sample conversion, and
+accurate integer DCT/IDCT algorithms.  When using the accurate integer DCT/IDCT
+algorithms on AVX2-equipped CPUs, the compression of RGB images is
+approximately 13-36% (avg. 22%) faster (relative to libjpeg-turbo 1.5.x) with
+64-bit code and 11-21% (avg. 17%) faster with 32-bit code, and the
+decompression of RGB images is approximately 9-35% (avg. 17%) faster with
+64-bit code and 7-17% (avg. 12%) faster with 32-bit code.  (As tested on a
+3 GHz Intel Core i7.  Actual mileage may vary.)
+
+2. Overhauled the build system to use CMake on all platforms, and removed the
+autotools-based build system.  This decision resulted from extensive
+discussions within the libjpeg-turbo community.  libjpeg-turbo traditionally
+used CMake only for Windows builds, but there was an increasing amount of
+demand to extend CMake support to other platforms.  However, because of the
+unique nature of our code base (the need to support different assemblers on
+each platform, the need for Java support, etc.), providing dual build systems
+as other OSS imaging libraries do (including libpng and libtiff) would have
+created a maintenance burden.  The use of CMake greatly simplifies some aspects
+of our build system, owing to CMake's built-in support for various assemblers,
+Java, and unit testing, as well as generally fewer quirks that have to be
+worked around in order to implement our packaging system.  Eliminating
+autotools puts our project slightly at odds with the traditional practices of
+the OSS community, since most "system libraries" tend to be built with
+autotools, but it is believed that the benefits of this move outweigh the
+risks.  In addition to providing a unified build environment, switching to
+CMake allows for the use of various build tools and IDEs that aren't supported
+under autotools, including XCode, Ninja, and Eclipse.  It also eliminates the
+need to install autotools via MacPorts/Homebrew on OS X and allows
+libjpeg-turbo to be configured without the use of a terminal/command prompt.
+Extensive testing was conducted to ensure that all features provided by the
+autotools-based build system are provided by the new build system.
+
+3. The libjpeg API in this version of libjpeg-turbo now includes two additional
+functions, `jpeg_read_icc_profile()` and `jpeg_write_icc_profile()`, that can
+be used to extract ICC profile data from a JPEG file while decompressing or to
+embed ICC profile data in a JPEG file while compressing or transforming.  This
+eliminates the need for downstream projects, such as color management libraries
+and browsers, to include their own glueware for accomplishing this.
+
+4. Improved error handling in the TurboJPEG API library:
+
+     - Introduced a new function (`tjGetErrorStr2()`) in the TurboJPEG C API
+that allows compression/decompression/transform error messages to be retrieved
+in a thread-safe manner.  Retrieving error messages from global functions, such
+as `tjInitCompress()` or `tjBufSize()`, is still thread-unsafe, but since those
+functions will only throw errors if passed an invalid argument or if a memory
+allocation failure occurs, thread safety is not as much of a concern.
+     - Introduced a new function (`tjGetErrorCode()`) in the TurboJPEG C API
+and a new method (`TJException.getErrorCode()`) in the TurboJPEG Java API that
+can be used to determine the severity of the last
+compression/decompression/transform error.  This allows applications to
+choose whether to ignore warnings (non-fatal errors) from the underlying
+libjpeg API or to treat them as fatal.
+     - Introduced a new flag (`TJFLAG_STOPONWARNING` in the TurboJPEG C API and
+`TJ.FLAG_STOPONWARNING` in the TurboJPEG Java API) that causes the library to
+immediately halt a compression/decompression/transform operation if it
+encounters a warning from the underlying libjpeg API (the default behavior is
+to allow the operation to complete unless a fatal error is encountered.)
+
+5. Introduced a new flag in the TurboJPEG C and Java APIs (`TJFLAG_PROGRESSIVE`
+and `TJ.FLAG_PROGRESSIVE`, respectively) that causes the library to use
+progressive entropy coding in JPEG images generated by compression and
+transform operations.  Additionally, a new transform option
+(`TJXOPT_PROGRESSIVE` in the C API and `TJTransform.OPT_PROGRESSIVE` in the
+Java API) has been introduced, allowing progressive entropy coding to be
+enabled for selected transforms in a multi-transform operation.
+
+6. Introduced a new transform option in the TurboJPEG API (`TJXOPT_COPYNONE` in
+the C API and `TJTransform.OPT_COPYNONE` in the Java API) that allows the
+copying of markers (including EXIF and ICC profile data) to be disabled for a
+particular transform.
+
+7. Added two functions to the TurboJPEG C API (`tjLoadImage()` and
+`tjSaveImage()`) that can be used to load/save a BMP or PPM/PGM image to/from a
+memory buffer with a specified pixel format and layout.  These functions
+replace the project-private (and slow) bmp API, which was previously used by
+TJBench, and they also provide a convenient way for first-time users of
+libjpeg-turbo to quickly develop a complete JPEG compression/decompression
+program.
+
+8. The TurboJPEG C API now includes a new convenience array (`tjAlphaOffset[]`)
+that contains the alpha component index for each pixel format (or -1 if the
+pixel format lacks an alpha component.)  The TurboJPEG Java API now includes a
+new method (`TJ.getAlphaOffset()`) that returns the same value.  In addition,
+the `tjRedOffset[]`, `tjGreenOffset[]`, and `tjBlueOffset[]` arrays-- and the
+corresponding `TJ.getRedOffset()`, `TJ.getGreenOffset()`, and
+`TJ.getBlueOffset()` methods-- now return -1 for `TJPF_GRAY`/`TJ.PF_GRAY`
+rather than 0.  This allows programs to easily determine whether a pixel format
+has red, green, blue, and alpha components.
+
+9. Added a new example (tjexample.c) that demonstrates the basic usage of the
+TurboJPEG C API.  This example mirrors the functionality of TJExample.java.
+Both files are now included in the libjpeg-turbo documentation.
+
+10. Fixed two signed integer overflows in the arithmetic decoder, detected by
+the Clang undefined behavior sanitizer, that could be triggered by attempting
+to decompress a specially-crafted malformed JPEG image.  These issues did not
+pose a security threat, but removing the warnings makes it easier to detect
+actual security issues, should they arise in the future.
+
+11. Fixed a bug in the merged 4:2:0 upsampling/dithered RGB565 color conversion
+algorithm that caused incorrect dithering in the output image.  This algorithm
+now produces bitwise-identical results to the unmerged algorithms.
+
+12. The SIMD function symbols for x86[-64]/ELF, MIPS/ELF, macOS/x86[-64] (if
+libjpeg-turbo is built with YASM), and iOS/Arm[64] builds are now private.
+This prevents those symbols from being exposed in applications or shared
+libraries that link statically with libjpeg-turbo.
+
+13. Added Loongson MMI SIMD implementations of the RGB-to-YCbCr and
+YCbCr-to-RGB colorspace conversion, 4:2:0 chroma downsampling, 4:2:0 fancy
+chroma upsampling, integer quantization, and accurate integer DCT/IDCT
+algorithms.  When using the accurate integer DCT/IDCT, this speeds up the
+compression of RGB images by approximately 70-100% and the decompression of RGB
+images by approximately 2-3.5x.
+
+14. Fixed a build error when building with older MinGW releases (regression
+caused by 1.5.1[7].)
+
+15. Added SIMD acceleration for progressive Huffman encoding on SSE2-capable
+x86 and x86-64 platforms.  This speeds up the compression of full-color
+progressive JPEGs by about 85-90% on average (relative to libjpeg-turbo 1.5.x)
+when using modern Intel and AMD CPUs.
+
+
+1.5.3
+=====
+
+### Significant changes relative to 1.5.2:
+
+1. Fixed a NullPointerException in the TurboJPEG Java wrapper that occurred
+when using the YUVImage constructor that creates an instance backed by separate
+image planes and allocates memory for the image planes.
+
+2. Fixed an issue whereby the Java version of TJUnitTest would fail when
+testing BufferedImage encoding/decoding on big endian systems.
+
+3. Fixed a segfault in djpeg that would occur if an output format other than
+PPM/PGM was selected along with the `-crop` option.  The `-crop` option now
+works with the GIF and Targa formats as well (unfortunately, it cannot be made
+to work with the BMP and RLE formats due to the fact that those output engines
+write scanlines in bottom-up order.)  djpeg will now exit gracefully if an
+output format other than PPM/PGM, GIF, or Targa is selected along with the
+`-crop` option.
+
+4. Fixed an issue (CVE-2017-15232) whereby `jpeg_skip_scanlines()` would
+segfault if color quantization was enabled.
+
+5. TJBench (both C and Java versions) will now display usage information if any
+command-line argument is unrecognized.  This prevents the program from silently
+ignoring typos.
+
+6. Fixed an access violation in tjbench.exe (Windows) that occurred when the
+program was used to decompress an existing JPEG image.
+
+7. Fixed an ArrayIndexOutOfBoundsException in the TJExample Java program that
+occurred when attempting to decompress a JPEG image that had been compressed
+with 4:1:1 chrominance subsampling.
+
+8. Fixed an issue whereby, when using `jpeg_skip_scanlines()` to skip to the
+end of a single-scan (non-progressive) image, subsequent calls to
+`jpeg_consume_input()` would return `JPEG_SUSPENDED` rather than
+`JPEG_REACHED_EOI`.
+
+9. `jpeg_crop_scanline()` now works correctly when decompressing grayscale JPEG
+images that were compressed with a sampling factor other than 1 (for instance,
+with `cjpeg -grayscale -sample 2x2`).
+
+
+1.5.2
+=====
+
+### Significant changes relative to 1.5.1:
+
+1. Fixed a regression introduced by 1.5.1[7] that prevented libjpeg-turbo from
+building with Android NDK platforms prior to android-21 (5.0).
+
+2. Fixed a regression introduced by 1.5.1[1] that prevented the MIPS DSPR2 SIMD
+code in libjpeg-turbo from building.
+
+3. Fixed a regression introduced by 1.5 beta1[11] that prevented the Java
+version of TJBench from outputting any reference images (the `-nowrite` switch
+was accidentally enabled by default.)
+
+4. libjpeg-turbo should now build and run with full AltiVec SIMD acceleration
+on PowerPC-based AmigaOS 4 and OpenBSD systems.
+
+5. Fixed build and runtime errors on Windows that occurred when building
+libjpeg-turbo with libjpeg v7 API/ABI emulation and the in-memory
+source/destination managers.  Due to an oversight, the `jpeg_skip_scanlines()`
+and `jpeg_crop_scanline()` functions were not being included in jpeg7.dll when
+libjpeg-turbo was built with `-DWITH_JPEG7=1` and `-DWITH_MEMSRCDST=1`.
+
+6. Fixed "Bogus virtual array access" error that occurred when using the
+lossless crop feature in jpegtran or the TurboJPEG API, if libjpeg-turbo was
+built with libjpeg v7 API/ABI emulation.  This was apparently a long-standing
+bug that has existed since the introduction of libjpeg v7/v8 API/ABI emulation
+in libjpeg-turbo v1.1.
+
+7. The lossless transform features in jpegtran and the TurboJPEG API will now
+always attempt to adjust the EXIF image width and height tags if the image size
+changed as a result of the transform.  This behavior has always existed when
+using libjpeg v8 API/ABI emulation.  It was supposed to be available with
+libjpeg v7 API/ABI emulation as well but did not work properly due to a bug.
+Furthermore, there was never any good reason not to enable it with libjpeg v6b
+API/ABI emulation, since the behavior is entirely internal.  Note that
+`-copy all` must be passed to jpegtran in order to transfer the EXIF tags from
+the source image to the destination image.
+
+8. Fixed several memory leaks in the TurboJPEG API library that could occur
+if the library was built with certain compilers and optimization levels
+(known to occur with GCC 4.x and clang with `-O1` and higher but not with
+GCC 5.x or 6.x) and one of the underlying libjpeg API functions threw an error
+after a TurboJPEG API function allocated a local buffer.
+
+9. The libjpeg-turbo memory manager will now honor the `max_memory_to_use`
+structure member in jpeg\_memory\_mgr, which can be set to the maximum amount
+of memory (in bytes) that libjpeg-turbo should use during decompression or
+multi-pass (including progressive) compression.  This limit can also be set
+using the `JPEGMEM` environment variable or using the `-maxmemory` switch in
+cjpeg/djpeg/jpegtran (refer to the respective man pages for more details.)
+This has been a documented feature of libjpeg since v5, but the
+`malloc()`/`free()` implementation of the memory manager (jmemnobs.c) never
+implemented the feature.  Restricting libjpeg-turbo's memory usage is useful
+for two reasons:  it allows testers to more easily work around the 2 GB limit
+in libFuzzer, and it allows developers of security-sensitive applications to
+more easily defend against one of the progressive JPEG exploits (LJT-01-004)
+identified in
+[this report](http://www.libjpeg-turbo.org/pmwiki/uploads/About/TwoIssueswiththeJPEGStandard.pdf).
+
+10. TJBench will now run each benchmark for 1 second prior to starting the
+timer, in order to improve the consistency of the results.  Furthermore, the
+`-warmup` option is now used to specify the amount of warmup time rather than
+the number of warmup iterations.
+
+11. Fixed an error (`short jump is out of range`) that occurred when assembling
+the 32-bit x86 SIMD extensions with NASM versions prior to 2.04.  This was a
+regression introduced by 1.5 beta1[12].
+
+
+1.5.1
+=====
+
+### Significant changes relative to 1.5.0:
+
+1. Previously, the undocumented `JSIMD_FORCE*` environment variables could be
+used to force-enable a particular SIMD instruction set if multiple instruction
+sets were available on a particular platform.  On x86 platforms, where CPU
+feature detection is bulletproof and multiple SIMD instruction sets are
+available, it makes sense for those environment variables to allow forcing the
+use of an instruction set only if that instruction set is available.  However,
+since the ARM implementations of libjpeg-turbo can only use one SIMD
+instruction set, and since their feature detection code is less bulletproof
+(parsing /proc/cpuinfo), it makes sense for the `JSIMD_FORCENEON` environment
+variable to bypass the feature detection code and really force the use of NEON
+instructions.  A new environment variable (`JSIMD_FORCEDSPR2`) was introduced
+in the MIPS implementation for the same reasons, and the existing
+`JSIMD_FORCENONE` environment variable was extended to that implementation.
+These environment variables provide a workaround for those attempting to test
+ARM and MIPS builds of libjpeg-turbo in QEMU, which passes through
+/proc/cpuinfo from the host system.
+
+2. libjpeg-turbo previously assumed that AltiVec instructions were always
+available on PowerPC platforms, which led to "illegal instruction" errors when
+running on PowerPC chips that lack AltiVec support (such as the older 7xx/G3
+and newer e5500 series.)  libjpeg-turbo now examines /proc/cpuinfo on
+Linux/Android systems and enables AltiVec instructions only if the CPU supports
+them.  It also now provides two environment variables, `JSIMD_FORCEALTIVEC` and
+`JSIMD_FORCENONE`, to force-enable and force-disable AltiVec instructions in
+environments where /proc/cpuinfo is an unreliable means of CPU feature
+detection (such as when running in QEMU.)  On OS X, libjpeg-turbo continues to
+assume that AltiVec support is always available, which means that libjpeg-turbo
+cannot be used with G3 Macs unless you set the environment variable
+`JSIMD_FORCENONE` to `1`.
+
+3. Fixed an issue whereby 64-bit ARM (AArch64) builds of libjpeg-turbo would
+crash when built with recent releases of the Clang/LLVM compiler.  This was
+caused by an ABI conformance issue in some of libjpeg-turbo's 64-bit NEON SIMD
+routines.  Those routines were incorrectly using 64-bit instructions to
+transfer a 32-bit JDIMENSION argument, whereas the ABI allows the upper
+(unused) 32 bits of a 32-bit argument's register to be undefined.  The new
+Clang/LLVM optimizer uses load combining to transfer multiple adjacent 32-bit
+structure members into a single 64-bit register, and this exposed the ABI
+conformance issue.
+
+4. Fancy upsampling is now supported when decompressing JPEG images that use
+4:4:0 (h1v2) chroma subsampling.  These images are generated when losslessly
+rotating or transposing JPEG images that use 4:2:2 (h2v1) chroma subsampling.
+The h1v2 fancy upsampling algorithm is not currently SIMD-accelerated.
+
+5. If merged upsampling isn't SIMD-accelerated but YCbCr-to-RGB conversion is,
+then libjpeg-turbo will now disable merged upsampling when decompressing YCbCr
+JPEG images into RGB or extended RGB output images.  This significantly speeds
+up the decompression of 4:2:0 and 4:2:2 JPEGs on ARM platforms if fancy
+upsampling is not used (for example, if the `-nosmooth` option to djpeg is
+specified.)
+
+6. The TurboJPEG API will now decompress 4:2:2 and 4:4:0 JPEG images with
+2x2 luminance sampling factors and 2x1 or 1x2 chrominance sampling factors.
+This is a non-standard way of specifying 2x subsampling (normally 4:2:2 JPEGs
+have 2x1 luminance and 1x1 chrominance sampling factors, and 4:4:0 JPEGs have
+1x2 luminance and 1x1 chrominance sampling factors), but the JPEG format and
+the libjpeg API both allow it.
+
+7. Fixed an unsigned integer overflow in the libjpeg memory manager, detected
+by the Clang undefined behavior sanitizer, that could be triggered by
+attempting to decompress a specially-crafted malformed JPEG image.  This issue
+affected only 32-bit code and did not pose a security threat, but removing the
+warning makes it easier to detect actual security issues, should they arise in
+the future.
+
+8. Fixed additional negative left shifts and other issues reported by the GCC
+and Clang undefined behavior sanitizers when attempting to decompress
+specially-crafted malformed JPEG images.  None of these issues posed a security
+threat, but removing the warnings makes it easier to detect actual security
+issues, should they arise in the future.
+
+9. Fixed an out-of-bounds array reference, introduced by 1.4.90[2] (partial
+image decompression) and detected by the Clang undefined behavior sanitizer,
+that could be triggered by a specially-crafted malformed JPEG image with more
+than four components.  Because the out-of-bounds reference was still within the
+same structure, it was not known to pose a security threat, but removing the
+warning makes it easier to detect actual security issues, should they arise in
+the future.
+
+10. Fixed another ABI conformance issue in the 64-bit ARM (AArch64) NEON SIMD
+code.  Some of the routines were incorrectly reading and storing data below the
+stack pointer, which caused segfaults in certain applications under specific
+circumstances.
+
+
+1.5.0
+=====
+
+### Significant changes relative to 1.5 beta1:
+
+1. Fixed an issue whereby a malformed motion-JPEG frame could cause the "fast
+path" of libjpeg-turbo's Huffman decoder to read from uninitialized memory.
+
+2. Added libjpeg-turbo version and build information to the global string table
+of the libjpeg and TurboJPEG API libraries.  This is a common practice in other
+infrastructure libraries, such as OpenSSL and libpng, because it makes it easy
+to examine an application binary and determine which version of the library the
+application was linked against.
+
+3. Fixed a couple of issues in the PPM reader that would cause buffer overruns
+in cjpeg if one of the values in a binary PPM/PGM input file exceeded the
+maximum value defined in the file's header and that maximum value was greater
+than 255.  libjpeg-turbo 1.4.2 already included a similar fix for ASCII PPM/PGM
+files.  Note that these issues were not security bugs, since they were confined
+to the cjpeg program and did not affect any of the libjpeg-turbo libraries.
+
+4. Fixed an issue whereby attempting to decompress a JPEG file with a corrupt
+header using the `tjDecompressToYUV2()` function would cause the function to
+abort without returning an error and, under certain circumstances, corrupt the
+stack.  This only occurred if `tjDecompressToYUV2()` was called prior to
+calling `tjDecompressHeader3()`, or if the return value from
+`tjDecompressHeader3()` was ignored (both cases represent incorrect usage of
+the TurboJPEG API.)
+
+5. Fixed an issue in the ARM 32-bit SIMD-accelerated Huffman encoder that
+prevented the code from assembling properly with clang.
+
+6. The `jpeg_stdio_src()`, `jpeg_mem_src()`, `jpeg_stdio_dest()`, and
+`jpeg_mem_dest()` functions in the libjpeg API will now throw an error if a
+source/destination manager has already been assigned to the compress or
+decompress object by a different function or by the calling program.  This
+prevents these functions from attempting to reuse a source/destination manager
+structure that was allocated elsewhere, because there is no way to ensure that
+it would be big enough to accommodate the new source/destination manager.
+
+
+1.4.90 (1.5 beta1)
+==================
+
+### Significant changes relative to 1.4.2:
+
+1. Added full SIMD acceleration for PowerPC platforms using AltiVec VMX
+(128-bit SIMD) instructions.  Although the performance of libjpeg-turbo on
+PowerPC was already good, due to the increased number of registers available
+to the compiler vs. x86, it was still possible to speed up compression by about
+3-4x and decompression by about 2-2.5x (relative to libjpeg v6b) through the
+use of AltiVec instructions.
+
+2. Added two new libjpeg API functions (`jpeg_skip_scanlines()` and
+`jpeg_crop_scanline()`) that can be used to partially decode a JPEG image.  See
+[libjpeg.txt](libjpeg.txt) for more details.
+
+3. The TJCompressor and TJDecompressor classes in the TurboJPEG Java API now
+implement the Closeable interface, so those classes can be used with a
+try-with-resources statement.
+
+4. The TurboJPEG Java classes now throw unchecked idiomatic exceptions
+(IllegalArgumentException, IllegalStateException) for unrecoverable errors
+caused by incorrect API usage, and those classes throw a new checked exception
+type (TJException) for errors that are passed through from the C library.
+
+5. Source buffers for the TurboJPEG C API functions, as well as the
+`jpeg_mem_src()` function in the libjpeg API, are now declared as const
+pointers.  This facilitates passing read-only buffers to those functions and
+ensures the caller that the source buffer will not be modified.  This should
+not create any backward API or ABI incompatibilities with prior libjpeg-turbo
+releases.
+
+6. The MIPS DSPr2 SIMD code can now be compiled to support either FR=0 or FR=1
+FPUs.
+
+7. Fixed additional negative left shifts and other issues reported by the GCC
+and Clang undefined behavior sanitizers.  Most of these issues affected only
+32-bit code, and none of them was known to pose a security threat, but removing
+the warnings makes it easier to detect actual security issues, should they
+arise in the future.
+
+8. Removed the unnecessary `.arch` directive from the ARM64 NEON SIMD code.
+This directive was preventing the code from assembling using the clang
+integrated assembler.
+
+9. Fixed a regression caused by 1.4.1[6] that prevented 32-bit and 64-bit
+libjpeg-turbo RPMs from being installed simultaneously on recent Red Hat/Fedora
+distributions.  This was due to the addition of a macro in jconfig.h that
+allows the Huffman codec to determine the word size at compile time.  Since
+that macro differs between 32-bit and 64-bit builds, this caused a conflict
+between the i386 and x86_64 RPMs (any differing files, other than executables,
+are not allowed when 32-bit and 64-bit RPMs are installed simultaneously.)
+Since the macro is used only internally, it has been moved into jconfigint.h.
+
+10. The x86-64 SIMD code can now be disabled at run time by setting the
+`JSIMD_FORCENONE` environment variable to `1` (the other SIMD implementations
+already had this capability.)
+
+11. Added a new command-line argument to TJBench (`-nowrite`) that prevents the
+benchmark from outputting any images.  This removes any potential operating
+system overhead that might be caused by lazy writes to disk and thus improves
+the consistency of the performance measurements.
+
+12. Added SIMD acceleration for Huffman encoding on SSE2-capable x86 and x86-64
+platforms.  This speeds up the compression of full-color JPEGs by about 10-15%
+on average (relative to libjpeg-turbo 1.4.x) when using modern Intel and AMD
+CPUs.  Additionally, this works around an issue in the clang optimizer that
+prevents it (as of this writing) from achieving the same performance as GCC
+when compiling the C version of the Huffman encoder
+(<https://llvm.org/bugs/show_bug.cgi?id=16035>).  For the purposes of
+benchmarking or regression testing, SIMD-accelerated Huffman encoding can be
+disabled by setting the `JSIMD_NOHUFFENC` environment variable to `1`.
+
+13. Added ARM 64-bit (ARMv8) NEON SIMD implementations of the commonly-used
+compression algorithms (including the accurate integer forward DCT and h2v2 &
+h2v1 downsampling algorithms, which are not accelerated in the 32-bit NEON
+implementation.)  This speeds up the compression of full-color JPEGs by about
+75% on average on a Cavium ThunderX processor and by about 2-2.5x on average on
+Cortex-A53 and Cortex-A57 cores.
+
+14. Added SIMD acceleration for Huffman encoding on NEON-capable ARM 32-bit
+and 64-bit platforms.
+
+    For 32-bit code, this speeds up the compression of full-color JPEGs by
+about 30% on average on a typical iOS device (iPhone 4S, Cortex-A9) and by
+about 6-7% on average on a typical Android device (Nexus 5X, Cortex-A53 and
+Cortex-A57), relative to libjpeg-turbo 1.4.x.  Note that the larger speedup
+under iOS is due to the fact that iOS builds use LLVM, which does not optimize
+the C Huffman encoder as well as GCC does.
+
+    For 64-bit code, NEON-accelerated Huffman encoding speeds up the
+compression of full-color JPEGs by about 40% on average on a typical iOS device
+(iPhone 5S, Apple A7) and by about 7-8% on average on a typical Android device
+(Nexus 5X, Cortex-A53 and Cortex-A57), in addition to the speedup described in
+[13] above.
+
+    For the purposes of benchmarking or regression testing, SIMD-accelerated
+Huffman encoding can be disabled by setting the `JSIMD_NOHUFFENC` environment
+variable to `1`.
+
+15. pkg-config (.pc) scripts are now included for both the libjpeg and
+TurboJPEG API libraries on Un*x systems.  Note that if a project's build system
+relies on these scripts, then it will not be possible to build that project
+with libjpeg or with a prior version of libjpeg-turbo.
+
+16. Optimized the ARM 64-bit (ARMv8) NEON SIMD decompression routines to
+improve performance on CPUs with in-order pipelines.  This speeds up the
+decompression of full-color JPEGs by nearly 2x on average on a Cavium ThunderX
+processor and by about 15% on average on a Cortex-A53 core.
+
+17. Fixed an issue in the accelerated Huffman decoder that could have caused
+the decoder to read past the end of the input buffer when a malformed,
+specially-crafted JPEG image was being decompressed.  In prior versions of
+libjpeg-turbo, the accelerated Huffman decoder was invoked (in most cases) only
+if there were > 128 bytes of data in the input buffer.  However, it is possible
+to construct a JPEG image in which a single Huffman block is over 430 bytes
+long, so this version of libjpeg-turbo activates the accelerated Huffman
+decoder only if there are > 512 bytes of data in the input buffer.
+
+18. Fixed a memory leak in tjunittest encountered when running the program
+with the `-yuv` option.
+
+
+1.4.2
+=====
+
+### Significant changes relative to 1.4.1:
+
+1. Fixed an issue whereby cjpeg would segfault if a Windows bitmap with a
+negative width or height was used as an input image (Windows bitmaps can have
+a negative height if they are stored in top-down order, but such files are
+rare and not supported by libjpeg-turbo.)
+
+2. Fixed an issue whereby, under certain circumstances, libjpeg-turbo would
+incorrectly encode certain JPEG images when quality=100 and the fast integer
+forward DCT were used.  This was known to cause `make test` to fail when the
+library was built with `-march=haswell` on x86 systems.
+
+3. Fixed an issue whereby libjpeg-turbo would crash when built with the latest
+& greatest development version of the Clang/LLVM compiler.  This was caused by
+an x86-64 ABI conformance issue in some of libjpeg-turbo's 64-bit SSE2 SIMD
+routines.  Those routines were incorrectly using a 64-bit `mov` instruction to
+transfer a 32-bit JDIMENSION argument, whereas the x86-64 ABI allows the upper
+(unused) 32 bits of a 32-bit argument's register to be undefined.  The new
+Clang/LLVM optimizer uses load combining to transfer multiple adjacent 32-bit
+structure members into a single 64-bit register, and this exposed the ABI
+conformance issue.
+
+4. Fixed a bug in the MIPS DSPr2 4:2:0 "plain" (non-fancy and non-merged)
+upsampling routine that caused a buffer overflow (and subsequent segfault) when
+decompressing a 4:2:0 JPEG image whose scaled output width was less than 16
+pixels.  The "plain" upsampling routines are normally only used when
+decompressing a non-YCbCr JPEG image, but they are also used when decompressing
+a JPEG image whose scaled output height is 1.
+
+5. Fixed various negative left shifts and other issues reported by the GCC and
+Clang undefined behavior sanitizers.  None of these was known to pose a
+security threat, but removing the warnings makes it easier to detect actual
+security issues, should they arise in the future.
+
+
+1.4.1
+=====
+
+### Significant changes relative to 1.4.0:
+
+1. tjbench now properly handles CMYK/YCCK JPEG files.  Passing an argument of
+`-cmyk` (instead of, for instance, `-rgb`) will cause tjbench to internally
+convert the source bitmap to CMYK prior to compression, to generate YCCK JPEG
+files, and to internally convert the decompressed CMYK pixels back to RGB after
+decompression (the latter is done automatically if a CMYK or YCCK JPEG is
+passed to tjbench as a source image.)  The CMYK<->RGB conversion operation is
+not benchmarked.  NOTE: The quick & dirty CMYK<->RGB conversions that tjbench
+uses are suitable for testing only.  Proper conversion between CMYK and RGB
+requires a color management system.
+
+2. `make test` now performs additional bitwise regression tests using tjbench,
+mainly for the purpose of testing compression from/decompression to a subregion
+of a larger image buffer.
+
+3. `make test` no longer tests the regression of the floating point DCT/IDCT
+by default, since the results of those tests can vary if the algorithms in
+question are not implemented using SIMD instructions on a particular platform.
+See the comments in [Makefile.am](Makefile.am) for information on how to
+re-enable the tests and to specify an expected result for them based on the
+particulars of your platform.
+
+4. The NULL color conversion routines have been significantly optimized,
+which speeds up the compression of RGB and CMYK JPEGs by 5-20% when using
+64-bit code and 0-3% when using 32-bit code, and the decompression of those
+images by 10-30% when using 64-bit code and 3-12% when using 32-bit code.
+
+5. Fixed an "illegal instruction" error that occurred when djpeg from a
+SIMD-enabled libjpeg-turbo MIPS build was executed with the `-nosmooth` option
+on a MIPS machine that lacked DSPr2 support.  The MIPS SIMD routines for h2v1
+and h2v2 merged upsampling were not properly checking for the existence of
+DSPr2.
+
+6. Performance has been improved significantly on 64-bit non-Linux and
+non-Windows platforms (generally 10-20% faster compression and 5-10% faster
+decompression.)  Due to an oversight, the 64-bit version of the accelerated
+Huffman codec was not being compiled in when libjpeg-turbo was built on
+platforms other than Windows or Linux.  Oops.
+
+7. Fixed an extremely rare bug in the Huffman encoder that caused 64-bit
+builds of libjpeg-turbo to incorrectly encode a few specific test images when
+quality=98, an optimized Huffman table, and the accurate integer forward DCT
+were used.
+
+8. The Windows (CMake) build system now supports building only static or only
+shared libraries.  This is accomplished by adding either `-DENABLE_STATIC=0` or
+`-DENABLE_SHARED=0` to the CMake command line.
+
+9. TurboJPEG API functions will now return an error code if a warning is
+triggered in the underlying libjpeg API.  For instance, if a JPEG file is
+corrupt, the TurboJPEG decompression functions will attempt to decompress
+as much of the image as possible, but those functions will now return -1 to
+indicate that the decompression was not entirely successful.
+
+10. Fixed a bug in the MIPS DSPr2 4:2:2 fancy upsampling routine that caused a
+buffer overflow (and subsequent segfault) when decompressing a 4:2:2 JPEG image
+in which the right-most MCU was 5 or 6 pixels wide.
+
+
+1.4.0
+=====
+
+### Significant changes relative to 1.4 beta1:
+
+1. Fixed a build issue on OS X PowerPC platforms (md5cmp failed to build
+because OS X does not provide the `le32toh()` and `htole32()` functions.)
+
+2. The non-SIMD RGB565 color conversion code did not work correctly on big
+endian machines.  This has been fixed.
+
+3. Fixed an issue in `tjPlaneSizeYUV()` whereby it would erroneously return 1
+instead of -1 if `componentID` was > 0 and `subsamp` was `TJSAMP_GRAY`.
+
+3. Fixed an issue in `tjBufSizeYUV2()` whereby it would erroneously return 0
+instead of -1 if `width` was < 1.
+
+5. The Huffman encoder now uses `clz` and `bsr` instructions for bit counting
+on ARM64 platforms (see 1.4 beta1[5].)
+
+6. The `close()` method in the TJCompressor and TJDecompressor Java classes is
+now idempotent.  Previously, that method would call the native `tjDestroy()`
+function even if the TurboJPEG instance had already been destroyed.  This
+caused an exception to be thrown during finalization, if the `close()` method
+had already been called.  The exception was caught, but it was still an
+expensive operation.
+
+7. The TurboJPEG API previously generated an error (`Could not determine
+subsampling type for JPEG image`) when attempting to decompress grayscale JPEG
+images that were compressed with a sampling factor other than 1 (for instance,
+with `cjpeg -grayscale -sample 2x2`).  Subsampling technically has no meaning
+with grayscale JPEGs, and thus the horizontal and vertical sampling factors
+for such images are ignored by the decompressor.  However, the TurboJPEG API
+was being too rigid and was expecting the sampling factors to be equal to 1
+before it treated the image as a grayscale JPEG.
+
+8. cjpeg, djpeg, and jpegtran now accept an argument of `-version`, which will
+print the library version and exit.
+
+9. Referring to 1.4 beta1[15], another extremely rare circumstance was
+discovered under which the Huffman encoder's local buffer can be overrun
+when a buffered destination manager is being used and an
+extremely-high-frequency block (basically junk image data) is being encoded.
+Even though the Huffman local buffer was increased from 128 bytes to 136 bytes
+to address the previous issue, the new issue caused even the larger buffer to
+be overrun.  Further analysis reveals that, in the absolute worst case (such as
+setting alternating AC coefficients to 32767 and -32768 in the JPEG scanning
+order), the Huffman encoder can produce encoded blocks that approach double the
+size of the unencoded blocks.  Thus, the Huffman local buffer was increased to
+256 bytes, which should prevent any such issue from re-occurring in the future.
+
+10. The new `tjPlaneSizeYUV()`, `tjPlaneWidth()`, and `tjPlaneHeight()`
+functions were not actually usable on any platform except OS X and Windows,
+because those functions were not included in the libturbojpeg mapfile.  This
+has been fixed.
+
+11. Restored the `JPP()`, `JMETHOD()`, and `FAR` macros in the libjpeg-turbo
+header files.  The `JPP()` and `JMETHOD()` macros were originally implemented
+in libjpeg as a way of supporting non-ANSI compilers that lacked support for
+prototype parameters.  libjpeg-turbo has never supported such compilers, but
+some software packages still use the macros to define their own prototypes.
+Similarly, libjpeg-turbo has never supported MS-DOS and other platforms that
+have far symbols, but some software packages still use the `FAR` macro.  A
+pretty good argument can be made that this is a bad practice on the part of the
+software in question, but since this affects more than one package, it's just
+easier to fix it here.
+
+12. Fixed issues that were preventing the ARM 64-bit SIMD code from compiling
+for iOS, and included an ARMv8 architecture in all of the binaries installed by
+the "official" libjpeg-turbo SDK for OS X.
+
+
+1.3.90 (1.4 beta1)
+==================
+
+### Significant changes relative to 1.3.1:
+
+1. New features in the TurboJPEG API:
+
+     - YUV planar images can now be generated with an arbitrary line padding
+(previously only 4-byte padding, which was compatible with X Video, was
+supported.)
+     - The decompress-to-YUV function has been extended to support image
+scaling.
+     - JPEG images can now be compressed from YUV planar source images.
+     - YUV planar images can now be decoded into RGB or grayscale images.
+     - 4:1:1 subsampling is now supported.  This is mainly included for
+compatibility, since 4:1:1 is not fully accelerated in libjpeg-turbo and has no
+significant advantages relative to 4:2:0.
+     - CMYK images are now supported.  This feature allows CMYK source images
+to be compressed to YCCK JPEGs and YCCK or CMYK JPEGs to be decompressed to
+CMYK destination images.  Conversion between CMYK/YCCK and RGB or YUV images is
+not supported.  Such conversion requires a color management system and is thus
+out of scope for a codec library.
+     - The handling of YUV images in the Java API has been significantly
+refactored and should now be much more intuitive.
+     - The Java API now supports encoding a YUV image from an arbitrary
+position in a large image buffer.
+     - All of the YUV functions now have a corresponding function that operates
+on separate image planes instead of a unified image buffer.  This allows for
+compressing/decoding from or decompressing/encoding to a subregion of a larger
+YUV image.  It also allows for handling YUV formats that swap the order of the
+U and V planes.
+
+2. Added SIMD acceleration for DSPr2-capable MIPS platforms.  This speeds up
+the compression of full-color JPEGs by 70-80% on such platforms and
+decompression by 25-35%.
+
+3. If an application attempts to decompress a Huffman-coded JPEG image whose
+header does not contain Huffman tables, libjpeg-turbo will now insert the
+default Huffman tables.  In order to save space, many motion JPEG video frames
+are encoded without the default Huffman tables, so these frames can now be
+successfully decompressed by libjpeg-turbo without additional work on the part
+of the application.  An application can still override the Huffman tables, for
+instance to re-use tables from a previous frame of the same video.
+
+4. The Mac packaging system now uses pkgbuild and productbuild rather than
+PackageMaker (which is obsolete and no longer supported.)  This means that
+OS X 10.6 "Snow Leopard" or later must be used when packaging libjpeg-turbo,
+although the packages produced can be installed on OS X 10.5 "Leopard" or
+later.  OS X 10.4 "Tiger" is no longer supported.
+
+5. The Huffman encoder now uses `clz` and `bsr` instructions for bit counting
+on ARM platforms rather than a lookup table.  This reduces the memory footprint
+by 64k, which may be important for some mobile applications.  Out of four
+Android devices that were tested, two demonstrated a small overall performance
+loss (~3-4% on average) with ARMv6 code and a small gain (also ~3-4%) with
+ARMv7 code when enabling this new feature, but the other two devices
+demonstrated a significant overall performance gain with both ARMv6 and ARMv7
+code (~10-20%) when enabling the feature.  Actual mileage may vary.
+
+6. Worked around an issue with Visual C++ 2010 and later that caused incorrect
+pixels to be generated when decompressing a JPEG image to a 256-color bitmap,
+if compiler optimization was enabled when libjpeg-turbo was built.  This caused
+the regression tests to fail when doing a release build under Visual C++ 2010
+and later.
+
+7. Improved the accuracy and performance of the non-SIMD implementation of the
+floating point inverse DCT (using code borrowed from libjpeg v8a and later.)
+The accuracy of this implementation now matches the accuracy of the SSE/SSE2
+implementation.  Note, however, that the floating point DCT/IDCT algorithms are
+mainly a legacy feature.  They generally do not produce significantly better
+accuracy than the accurate integer DCT/IDCT algorithms, and they are quite a
+bit slower.
+
+8. Added a new output colorspace (`JCS_RGB565`) to the libjpeg API that allows
+for decompressing JPEG images into RGB565 (16-bit) pixels.  If dithering is not
+used, then this code path is SIMD-accelerated on ARM platforms.
+
+9. Numerous obsolete features, such as support for non-ANSI compilers and
+support for the MS-DOS memory model, were removed from the libjpeg code,
+greatly improving its readability and making it easier to maintain and extend.
+
+10. Fixed a segfault that occurred when calling `output_message()` with
+`msg_code` set to `JMSG_COPYRIGHT`.
+
+11. Fixed an issue whereby wrjpgcom was allowing comments longer than 65k
+characters to be passed on the command line, which was causing it to generate
+incorrect JPEG files.
+
+12. Fixed a bug in the build system that was causing the Windows version of
+wrjpgcom to be built using the rdjpgcom source code.
+
+13. Restored 12-bit-per-component JPEG support.  A 12-bit version of
+libjpeg-turbo can now be built by passing an argument of `--with-12bit` to
+configure (Unix) or `-DWITH_12BIT=1` to cmake (Windows.)  12-bit JPEG support
+is included only for convenience.  Enabling this feature disables all of the
+performance features in libjpeg-turbo, as well as arithmetic coding and the
+TurboJPEG API.  The resulting library still contains the other libjpeg-turbo
+features (such as the colorspace extensions), but in general, it performs no
+faster than libjpeg v6b.
+
+14. Added ARM 64-bit SIMD acceleration for the YCC-to-RGB color conversion
+and IDCT algorithms (both are used during JPEG decompression.)  For unknown
+reasons (probably related to clang), this code cannot currently be compiled for
+iOS.
+
+15. Fixed an extremely rare bug (CVE-2014-9092) that could cause the Huffman
+encoder's local buffer to overrun when a very high-frequency MCU is compressed
+using quality 100 and no subsampling, and when the JPEG output buffer is being
+dynamically resized by the destination manager.  This issue was so rare that,
+even with a test program specifically designed to make the bug occur (by
+injecting random high-frequency YUV data into the compressor), it was
+reproducible only once in about every 25 million iterations.
+
+16. Fixed an oversight in the TurboJPEG C wrapper:  if any of the JPEG
+compression functions was called repeatedly with the same
+automatically-allocated destination buffer, then TurboJPEG would erroneously
+assume that the `jpegSize` parameter was equal to the size of the buffer, when
+in fact that parameter was probably equal to the size of the most recently
+compressed JPEG image.  If the size of the previous JPEG image was not as large
+as the current JPEG image, then TurboJPEG would unnecessarily reallocate the
+destination buffer.
+
+
+1.3.1
+=====
+
+### Significant changes relative to 1.3.0:
+
+1. On Un*x systems, `make install` now installs the libjpeg-turbo libraries
+into /opt/libjpeg-turbo/lib32 by default on any 32-bit system, not just x86,
+and into /opt/libjpeg-turbo/lib64 by default on any 64-bit system, not just
+x86-64.  You can override this by overriding either the `prefix` or `libdir`
+configure variables.
+
+2. The Windows installer now places a copy of the TurboJPEG DLLs in the same
+directory as the rest of the libjpeg-turbo binaries.  This was mainly done
+to support TurboVNC 1.3, which bundles the DLLs in its Windows installation.
+When using a 32-bit version of CMake on 64-bit Windows, it is impossible to
+access the c:\WINDOWS\system32 directory, which made it impossible for the
+TurboVNC build scripts to bundle the 64-bit TurboJPEG DLL.
+
+3. Fixed a bug whereby attempting to encode a progressive JPEG with arithmetic
+entropy coding (by passing arguments of `-progressive -arithmetic` to cjpeg or
+jpegtran, for instance) would result in an error, `Requested feature was
+omitted at compile time`.
+
+4. Fixed a couple of issues (CVE-2013-6629 and CVE-2013-6630) whereby malformed
+JPEG images would cause libjpeg-turbo to use uninitialized memory during
+decompression.
+
+5. Fixed an error (`Buffer passed to JPEG library is too small`) that occurred
+when calling the TurboJPEG YUV encoding function with a very small (< 5x5)
+source image, and added a unit test to check for this error.
+
+6. The Java classes should now build properly under Visual Studio 2010 and
+later.
+
+7. Fixed an issue that prevented SRPMs generated using the in-tree packaging
+tools from being rebuilt on certain newer Linux distributions.
+
+8. Numerous minor fixes to eliminate compilation and build/packaging system
+warnings, fix cosmetic issues, improve documentation clarity, and other general
+source cleanup.
+
+
+1.3.0
+=====
+
+### Significant changes relative to 1.3 beta1:
+
+1. `make test` now works properly on FreeBSD, and it no longer requires the
+md5sum executable to be present on other Un*x platforms.
+
+2. Overhauled the packaging system:
+
+     - To avoid conflict with vendor-supplied libjpeg-turbo packages, the
+official RPMs and DEBs for libjpeg-turbo have been renamed to
+"libjpeg-turbo-official".
+     - The TurboJPEG libraries are now located under /opt/libjpeg-turbo in the
+official Linux and Mac packages, to avoid conflict with vendor-supplied
+packages and also to streamline the packaging system.
+     - Release packages are now created with the directory structure defined
+by the configure variables `prefix`, `bindir`, `libdir`, etc. (Un\*x) or by the
+`CMAKE_INSTALL_PREFIX` variable (Windows.)  The exception is that the docs are
+always located under the system default documentation directory on Un\*x and
+Mac systems, and on Windows, the TurboJPEG DLL is always located in the Windows
+system directory.
+     - To avoid confusion, official libjpeg-turbo packages on Linux/Unix
+platforms (except for Mac) will always install the 32-bit libraries in
+/opt/libjpeg-turbo/lib32 and the 64-bit libraries in /opt/libjpeg-turbo/lib64.
+     - Fixed an issue whereby, in some cases, the libjpeg-turbo executables on
+Un*x systems were not properly linking with the shared libraries installed by
+the same package.
+     - Fixed an issue whereby building the "installer" target on Windows when
+`WITH_JAVA=1` would fail if the TurboJPEG JAR had not been previously built.
+     - Building the "install" target on Windows now installs files into the
+same places that the installer does.
+
+3. Fixed a Huffman encoder bug that prevented I/O suspension from working
+properly.
+
+
+1.2.90 (1.3 beta1)
+==================
+
+### Significant changes relative to 1.2.1:
+
+1. Added support for additional scaling factors (3/8, 5/8, 3/4, 7/8, 9/8, 5/4,
+11/8, 3/2, 13/8, 7/4, 15/8, and 2) when decompressing.  Note that the IDCT will
+not be SIMD-accelerated when using any of these new scaling factors.
+
+2. The TurboJPEG dynamic library is now versioned.  It was not strictly
+necessary to do so, because TurboJPEG uses versioned symbols, and if a function
+changes in an ABI-incompatible way, that function is renamed and a legacy
+function is provided to maintain backward compatibility.  However, certain
+Linux distro maintainers have a policy against accepting any library that isn't
+versioned.
+
+3. Extended the TurboJPEG Java API so that it can be used to compress a JPEG
+image from and decompress a JPEG image to an arbitrary position in a large
+image buffer.
+
+4. The `tjDecompressToYUV()` function now supports the `TJFLAG_FASTDCT` flag.
+
+5. The 32-bit supplementary package for amd64 Debian systems now provides
+symlinks in /usr/lib/i386-linux-gnu for the TurboJPEG libraries in /usr/lib32.
+This allows those libraries to be used on MultiArch-compatible systems (such as
+Ubuntu 11 and later) without setting the linker path.
+
+6. The TurboJPEG Java wrapper should now find the JNI library on Mac systems
+without having to pass `-Djava.library.path=/usr/lib` to java.
+
+7. TJBench has been ported to Java to provide a convenient way of validating
+the performance of the TurboJPEG Java API.  It can be run with
+`java -cp turbojpeg.jar TJBench`.
+
+8. cjpeg can now be used to generate JPEG files with the RGB colorspace
+(feature ported from jpeg-8d.)
+
+9. The width and height in the `-crop` argument passed to jpegtran can now be
+suffixed with `f` to indicate that, when the upper left corner of the cropping
+region is automatically moved to the nearest iMCU boundary, the bottom right
+corner should be moved by the same amount.  In other words, this feature causes
+jpegtran to strictly honor the specified width/height rather than the specified
+bottom right corner (feature ported from jpeg-8d.)
+
+10. JPEG files using the RGB colorspace can now be decompressed into grayscale
+images (feature ported from jpeg-8d.)
+
+11. Fixed a regression caused by 1.2.1[7] whereby the build would fail with
+multiple "Mismatch in operand sizes" errors when attempting to build the x86
+SIMD code with NASM 0.98.
+
+12. The in-memory source/destination managers (`jpeg_mem_src()` and
+`jpeg_mem_dest()`) are now included by default when building libjpeg-turbo with
+libjpeg v6b or v7 emulation, so that programs can take advantage of these
+functions without requiring the use of the backward-incompatible libjpeg v8
+ABI.  The "age number" of the libjpeg-turbo library on Un*x systems has been
+incremented by 1 to reflect this.  You can disable this feature with a
+configure/CMake switch in order to retain strict API/ABI compatibility with the
+libjpeg v6b or v7 API/ABI (or with previous versions of libjpeg-turbo.)  See
+[README.md](README.md) for more details.
+
+13. Added ARMv7s architecture to libjpeg.a and libturbojpeg.a in the official
+libjpeg-turbo binary package for OS X, so that those libraries can be used to
+build applications that leverage the faster CPUs in the iPhone 5 and iPad 4.
+
+
+1.2.1
+=====
+
+### Significant changes relative to 1.2.0:
+
+1. Creating or decoding a JPEG file that uses the RGB colorspace should now
+properly work when the input or output colorspace is one of the libjpeg-turbo
+colorspace extensions.
+
+2. When libjpeg-turbo was built without SIMD support and merged (non-fancy)
+upsampling was used along with an alpha-enabled colorspace during
+decompression, the unused byte of the decompressed pixels was not being set to
+0xFF.  This has been fixed.  TJUnitTest has also been extended to test for the
+correct behavior of the colorspace extensions when merged upsampling is used.
+
+3. Fixed a bug whereby the libjpeg-turbo SSE2 SIMD code would not preserve the
+upper 64 bits of xmm6 and xmm7 on Win64 platforms, which violated the Win64
+calling conventions.
+
+4. Fixed a regression (CVE-2012-2806) caused by 1.2.0[6] whereby decompressing
+corrupt JPEG images (specifically, images in which the component count was
+erroneously set to a large value) would cause libjpeg-turbo to segfault.
+
+5. Worked around a severe performance issue with "Bobcat" (AMD Embedded APU)
+processors.  The `MASKMOVDQU` instruction, which was used by the libjpeg-turbo
+SSE2 SIMD code, is apparently implemented in microcode on AMD processors, and
+it is painfully slow on Bobcat processors in particular.  Eliminating the use
+of this instruction improved performance by an order of magnitude on Bobcat
+processors and by a small amount (typically 5%) on AMD desktop processors.
+
+6. Added SIMD acceleration for performing 4:2:2 upsampling on NEON-capable ARM
+platforms.  This speeds up the decompression of 4:2:2 JPEGs by 20-25% on such
+platforms.
+
+7. Fixed a regression caused by 1.2.0[2] whereby, on Linux/x86 platforms
+running the 32-bit SSE2 SIMD code in libjpeg-turbo, decompressing a 4:2:0 or
+4:2:2 JPEG image into a 32-bit (RGBX, BGRX, etc.) buffer without using fancy
+upsampling would produce several incorrect columns of pixels at the right-hand
+side of the output image if each row in the output image was not evenly
+divisible by 16 bytes.
+
+8. Fixed an issue whereby attempting to build the SIMD extensions with Xcode
+4.3 on OS X platforms would cause NASM to return numerous errors of the form
+"'%define' expects a macro identifier".
+
+9. Added flags to the TurboJPEG API that allow the caller to force the use of
+either the fast or the accurate DCT/IDCT algorithms in the underlying codec.
+
+
+1.2.0
+=====
+
+### Significant changes relative to 1.2 beta1:
+
+1. Fixed build issue with YASM on Unix systems (the libjpeg-turbo build system
+was not adding the current directory to the assembler include path, so YASM
+was not able to find jsimdcfg.inc.)
+
+2. Fixed out-of-bounds read in SSE2 SIMD code that occurred when decompressing
+a JPEG image to a bitmap buffer whose size was not a multiple of 16 bytes.
+This was more of an annoyance than an actual bug, since it did not cause any
+actual run-time problems, but the issue showed up when running libjpeg-turbo in
+valgrind.  See <http://crbug.com/72399> for more information.
+
+3. Added a compile-time macro (`LIBJPEG_TURBO_VERSION`) that can be used to
+check the version of libjpeg-turbo against which an application was compiled.
+
+4. Added new RGBA/BGRA/ABGR/ARGB colorspace extension constants (libjpeg API)
+and pixel formats (TurboJPEG API), which allow applications to specify that,
+when decompressing to a 4-component RGB buffer, the unused byte should be set
+to 0xFF so that it can be interpreted as an opaque alpha channel.
+
+5. Fixed regression issue whereby DevIL failed to build against libjpeg-turbo
+because libjpeg-turbo's distributed version of jconfig.h contained an `INLINE`
+macro, which conflicted with a similar macro in DevIL.  This macro is used only
+internally when building libjpeg-turbo, so it was moved into config.h.
+
+6. libjpeg-turbo will now correctly decompress erroneous CMYK/YCCK JPEGs whose
+K component is assigned a component ID of 1 instead of 4.  Although these files
+are in violation of the spec, other JPEG implementations handle them
+correctly.
+
+7. Added ARMv6 and ARMv7 architectures to libjpeg.a and libturbojpeg.a in
+the official libjpeg-turbo binary package for OS X, so that those libraries can
+be used to build both OS X and iOS applications.
+
+
+1.1.90 (1.2 beta1)
+==================
+
+### Significant changes relative to 1.1.1:
+
+1. Added a Java wrapper for the TurboJPEG API.  See [java/README](java/README)
+for more details.
+
+2. The TurboJPEG API can now be used to scale down images during
+decompression.
+
+3. Added SIMD routines for RGB-to-grayscale color conversion, which
+significantly improves the performance of grayscale JPEG compression from an
+RGB source image.
+
+4. Improved the performance of the C color conversion routines, which are used
+on platforms for which SIMD acceleration is not available.
+
+5. Added a function to the TurboJPEG API that performs lossless transforms.
+This function is implemented using the same back end as jpegtran, but it
+performs transcoding entirely in memory and allows multiple transforms and/or
+crop operations to be batched together, so the source coefficients only need to
+be read once.  This is useful when generating image tiles from a single source
+JPEG.
+
+6. Added tests for the new TurboJPEG scaled decompression and lossless
+transform features to tjbench (the TurboJPEG benchmark, formerly called
+"jpgtest".)
+
+7. Added support for 4:4:0 (transposed 4:2:2) subsampling in TurboJPEG, which
+was necessary in order for it to read 4:2:2 JPEG files that had been losslessly
+transposed or rotated 90 degrees.
+
+8. All legacy VirtualGL code has been re-factored, and this has allowed
+libjpeg-turbo, in its entirety, to be re-licensed under a BSD-style license.
+
+9. libjpeg-turbo can now be built with YASM.
+
+10. Added SIMD acceleration for ARM Linux and iOS platforms that support
+NEON instructions.
+
+11. Refactored the TurboJPEG C API and documented it using Doxygen.  The
+TurboJPEG 1.2 API uses pixel formats to define the size and component order of
+the uncompressed source/destination images, and it includes a more efficient
+version of `TJBUFSIZE()` that computes a worst-case JPEG size based on the
+level of chrominance subsampling.  The refactored implementation of the
+TurboJPEG API now uses the libjpeg memory source and destination managers,
+which allows the TurboJPEG compressor to grow the JPEG buffer as necessary.
+
+12. Eliminated errors in the output of jpegtran on Windows that occurred when
+the application was invoked using I/O redirection
+(`jpegtran <input.jpg >output.jpg`.)
+
+13. The inclusion of libjpeg v7 and v8 emulation as well as arithmetic coding
+support in libjpeg-turbo v1.1.0 introduced several new error constants in
+jerror.h, and these were mistakenly enabled for all emulation modes, causing
+the error enum in libjpeg-turbo to sometimes have different values than the
+same enum in libjpeg.  This represents an ABI incompatibility, and it caused
+problems with rare applications that took specific action based on a particular
+error value.  The fix was to include the new error constants conditionally
+based on whether libjpeg v7 or v8 emulation was enabled.
+
+14. Fixed an issue whereby Windows applications that used libjpeg-turbo would
+fail to compile if the Windows system headers were included before jpeglib.h.
+This issue was caused by a conflict in the definition of the INT32 type.
+
+15. Fixed 32-bit supplementary package for amd64 Debian systems, which was
+broken by enhancements to the packaging system in 1.1.
+
+16. When decompressing a JPEG image using an output colorspace of
+`JCS_EXT_RGBX`, `JCS_EXT_BGRX`, `JCS_EXT_XBGR`, or `JCS_EXT_XRGB`,
+libjpeg-turbo will now set the unused byte to 0xFF, which allows applications
+to interpret that byte as an alpha channel (0xFF = opaque).
+
+
+1.1.1
+=====
+
+### Significant changes relative to 1.1.0:
+
+1. Fixed a 1-pixel error in row 0, column 21 of the luminance plane generated
+by `tjEncodeYUV()`.
+
+2. libjpeg-turbo's accelerated Huffman decoder previously ignored unexpected
+markers found in the middle of the JPEG data stream during decompression.  It
+will now hand off decoding of a particular block to the unaccelerated Huffman
+decoder if an unexpected marker is found, so that the unaccelerated Huffman
+decoder can generate an appropriate warning.
+
+3. Older versions of MinGW64 prefixed symbol names with underscores by
+default, which differed from the behavior of 64-bit Visual C++.  MinGW64 1.0
+has adopted the behavior of 64-bit Visual C++ as the default, so to accommodate
+this, the libjpeg-turbo SIMD function names are no longer prefixed with an
+underscore when building with MinGW64.  This means that, when building
+libjpeg-turbo with older versions of MinGW64, you will now have to add
+`-fno-leading-underscore` to the `CFLAGS`.
+
+4. Fixed a regression bug in the NSIS script that caused the Windows installer
+build to fail when using the Visual Studio IDE.
+
+5. Fixed a bug in `jpeg_read_coefficients()` whereby it would not initialize
+`cinfo->image_width` and `cinfo->image_height` if libjpeg v7 or v8 emulation
+was enabled.  This specifically caused the jpegoptim program to fail if it was
+linked against a version of libjpeg-turbo that was built with libjpeg v7 or v8
+emulation.
+
+6. Eliminated excessive I/O overhead that occurred when reading BMP files in
+cjpeg.
+
+7. Eliminated errors in the output of cjpeg on Windows that occurred when the
+application was invoked using I/O redirection (`cjpeg <inputfile >output.jpg`.)
+
+
+1.1.0
+=====
+
+### Significant changes relative to 1.1 beta1:
+
+1. The algorithm used by the SIMD quantization function cannot produce correct
+results when the JPEG quality is >= 98 and the fast integer forward DCT is
+used.  Thus, the non-SIMD quantization function is now used for those cases,
+and libjpeg-turbo should now produce identical output to libjpeg v6b in all
+cases.
+
+2. Despite the above, the fast integer forward DCT still degrades somewhat for
+JPEG qualities greater than 95, so the TurboJPEG wrapper will now automatically
+use the accurate integer forward DCT when generating JPEG images of quality 96
+or greater.  This reduces compression performance by as much as 15% for these
+high-quality images but is necessary to ensure that the images are perceptually
+lossless.  It also ensures that the library can avoid the performance pitfall
+created by [1].
+
+3. Ported jpgtest.cxx to pure C to avoid the need for a C++ compiler.
+
+4. Fixed visual artifacts in grayscale JPEG compression caused by a typo in
+the RGB-to-luminance lookup tables.
+
+5. The Windows distribution packages now include the libjpeg run-time programs
+(cjpeg, etc.)
+
+6. All packages now include jpgtest.
+
+7. The TurboJPEG dynamic library now uses versioned symbols.
+
+8. Added two new TurboJPEG API functions, `tjEncodeYUV()` and
+`tjDecompressToYUV()`, to replace the somewhat hackish `TJ_YUV` flag.
+
+
+1.0.90 (1.1 beta1)
+==================
+
+### Significant changes relative to 1.0.1:
+
+1. Added emulation of the libjpeg v7 and v8 APIs and ABIs.  See
+[README.md](README.md) for more details.  This feature was sponsored by
+CamTrace SAS.
+
+2. Created a new CMake-based build system for the Visual C++ and MinGW builds.
+
+3. Grayscale bitmaps can now be compressed from/decompressed to using the
+TurboJPEG API.
+
+4. jpgtest can now be used to test decompression performance with existing
+JPEG images.
+
+5. If the default install prefix (/opt/libjpeg-turbo) is used, then
+`make install` now creates /opt/libjpeg-turbo/lib32 and
+/opt/libjpeg-turbo/lib64 sym links to duplicate the behavior of the binary
+packages.
+
+6. All symbols in the libjpeg-turbo dynamic library are now versioned, even
+when the library is built with libjpeg v6b emulation.
+
+7. Added arithmetic encoding and decoding support (can be disabled with
+configure or CMake options)
+
+8. Added a `TJ_YUV` flag to the TurboJPEG API, which causes both the compressor
+and decompressor to output planar YUV images.
+
+9. Added an extended version of `tjDecompressHeader()` to the TurboJPEG API,
+which allows the caller to determine the type of subsampling used in a JPEG
+image.
+
+10. Added further protections against invalid Huffman codes.
+
+
+1.0.1
+=====
+
+### Significant changes relative to 1.0.0:
+
+1. The Huffman decoder will now handle erroneous Huffman codes (for instance,
+from a corrupt JPEG image.)  Previously, these would cause libjpeg-turbo to
+crash under certain circumstances.
+
+2. Fixed typo in SIMD dispatch routines that was causing 4:2:2 upsampling to
+be used instead of 4:2:0 when decompressing JPEG images using SSE2 code.
+
+3. The configure script will now automatically determine whether the
+`INCOMPLETE_TYPES_BROKEN` macro should be defined.
+
+
+1.0.0
+=====
+
+### Significant changes relative to 0.0.93:
+
+1. 2983700: Further FreeBSD build tweaks (no longer necessary to specify
+`--host` when configuring on a 64-bit system)
+
+2. Created symlinks in the Unix/Linux packages so that the TurboJPEG
+include file can always be found in /opt/libjpeg-turbo/include, the 32-bit
+static libraries can always be found in /opt/libjpeg-turbo/lib32, and the
+64-bit static libraries can always be found in /opt/libjpeg-turbo/lib64.
+
+3. The Unix/Linux distribution packages now include the libjpeg run-time
+programs (cjpeg, etc.) and man pages.
+
+4. Created a 32-bit supplementary package for amd64 Debian systems, which
+contains just the 32-bit libjpeg-turbo libraries.
+
+5. Moved the libraries from */lib32 to */lib in the i386 Debian package.
+
+6. Include distribution package for Cygwin
+
+7. No longer necessary to specify `--without-simd` on non-x86 architectures,
+and unit tests now work on those architectures.
+
+
+0.0.93
+======
+
+### Significant changes since 0.0.91:
+
+1. 2982659: Fixed x86-64 build on FreeBSD systems
+
+2. 2988188: Added support for Windows 64-bit systems
+
+
+0.0.91
+======
+
+### Significant changes relative to 0.0.90:
+
+1. Added documentation to .deb packages
+
+2. 2968313: Fixed data corruption issues when decompressing large JPEG images
+and/or using buffered I/O with the libjpeg-turbo decompressor
+
+
+0.0.90
+======
+
+Initial release
diff --git a/3rdparty/libjpeg/src/LICENSE.md b/3rdparty/libjpeg/src/LICENSE.md
new file mode 100644
index 00000000..99c9aadc
--- /dev/null
+++ b/3rdparty/libjpeg/src/LICENSE.md
@@ -0,0 +1,132 @@
+libjpeg-turbo Licenses
+======================
+
+libjpeg-turbo is covered by three compatible BSD-style open source licenses:
+
+- The IJG (Independent JPEG Group) License, which is listed in
+  [README.ijg](README.ijg)
+
+  This license applies to the libjpeg API library and associated programs
+  (any code inherited from libjpeg, and any modifications to that code.)
+
+- The Modified (3-clause) BSD License, which is listed below
+
+  This license covers the TurboJPEG API library and associated programs, as
+  well as the build system.
+
+- The [zlib License](https://opensource.org/licenses/Zlib)
+
+  This license is a subset of the other two, and it covers the libjpeg-turbo
+  SIMD extensions.
+
+
+Complying with the libjpeg-turbo Licenses
+=========================================
+
+This section provides a roll-up of the libjpeg-turbo licensing terms, to the
+best of our understanding.
+
+1.  If you are distributing a modified version of the libjpeg-turbo source,
+    then:
+
+    1.  You cannot alter or remove any existing copyright or license notices
+        from the source.
+
+        **Origin**
+        - Clause 1 of the IJG License
+        - Clause 1 of the Modified BSD License
+        - Clauses 1 and 3 of the zlib License
+
+    2.  You must add your own copyright notice to the header of each source
+        file you modified, so others can tell that you modified that file (if
+        there is not an existing copyright header in that file, then you can
+        simply add a notice stating that you modified the file.)
+
+        **Origin**
+        - Clause 1 of the IJG License
+        - Clause 2 of the zlib License
+
+    3.  You must include the IJG README file, and you must not alter any of the
+        copyright or license text in that file.
+
+        **Origin**
+        - Clause 1 of the IJG License
+
+2.  If you are distributing only libjpeg-turbo binaries without the source, or
+    if you are distributing an application that statically links with
+    libjpeg-turbo, then:
+
+    1.  Your product documentation must include a message stating:
+
+        This software is based in part on the work of the Independent JPEG
+        Group.
+
+        **Origin**
+        - Clause 2 of the IJG license
+
+    2.  If your binary distribution includes or uses the TurboJPEG API, then
+        your product documentation must include the text of the Modified BSD
+        License (see below.)
+
+        **Origin**
+        - Clause 2 of the Modified BSD License
+
+3.  You cannot use the name of the IJG or The libjpeg-turbo Project or the
+    contributors thereof in advertising, publicity, etc.
+
+    **Origin**
+    - IJG License
+    - Clause 3 of the Modified BSD License
+
+4.  The IJG and The libjpeg-turbo Project do not warrant libjpeg-turbo to be
+    free of defects, nor do we accept any liability for undesirable
+    consequences resulting from your use of the software.
+
+    **Origin**
+    - IJG License
+    - Modified BSD License
+    - zlib License
+
+
+The Modified (3-clause) BSD License
+===================================
+
+Copyright (C)2009-2020 D. R. Commander.  All Rights Reserved.
+Copyright (C)2015 Viktor Szathmáry.  All Rights Reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+- Redistributions of source code must retain the above copyright notice,
+  this list of conditions and the following disclaimer.
+- Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+- Neither the name of the libjpeg-turbo Project nor the names of its
+  contributors may be used to endorse or promote products derived from this
+  software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE 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 HOLDERS 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.
+
+
+Why Three Licenses?
+===================
+
+The zlib License could have been used instead of the Modified (3-clause) BSD
+License, and since the IJG License effectively subsumes the distribution
+conditions of the zlib License, this would have effectively placed
+libjpeg-turbo binary distributions under the IJG License.  However, the IJG
+License specifically refers to the Independent JPEG Group and does not extend
+attribution and endorsement protections to other entities.  Thus, it was
+desirable to choose a license that granted us the same protections for new code
+that were granted to the IJG for code derived from their software.
diff --git a/3rdparty/libjpeg/src/README.ijg b/3rdparty/libjpeg/src/README.ijg
new file mode 100644
index 00000000..9453c195
--- /dev/null
+++ b/3rdparty/libjpeg/src/README.ijg
@@ -0,0 +1,258 @@
+libjpeg-turbo note:  This file has been modified by The libjpeg-turbo Project
+to include only information relevant to libjpeg-turbo, to wordsmith certain
+sections, and to remove impolitic language that existed in the libjpeg v8
+README.  It is included only for reference.  Please see README.md for
+information specific to libjpeg-turbo.
+
+
+The Independent JPEG Group's JPEG software
+==========================================
+
+This distribution contains a release of the Independent JPEG Group's free JPEG
+software.  You are welcome to redistribute this software and to use it for any
+purpose, subject to the conditions under LEGAL ISSUES, below.
+
+This software is the work of Tom Lane, Guido Vollbeding, Philip Gladstone,
+Bill Allombert, Jim Boucher, Lee Crocker, Bob Friesenhahn, Ben Jackson,
+Julian Minguillon, Luis Ortiz, George Phillips, Davide Rossi, Ge' Weijers,
+and other members of the Independent JPEG Group.
+
+IJG is not affiliated with the ISO/IEC JTC1/SC29/WG1 standards committee
+(also known as JPEG, together with ITU-T SG16).
+
+
+DOCUMENTATION ROADMAP
+=====================
+
+This file contains the following sections:
+
+OVERVIEW            General description of JPEG and the IJG software.
+LEGAL ISSUES        Copyright, lack of warranty, terms of distribution.
+REFERENCES          Where to learn more about JPEG.
+ARCHIVE LOCATIONS   Where to find newer versions of this software.
+FILE FORMAT WARS    Software *not* to get.
+TO DO               Plans for future IJG releases.
+
+Other documentation files in the distribution are:
+
+User documentation:
+  usage.txt         Usage instructions for cjpeg, djpeg, jpegtran,
+                    rdjpgcom, and wrjpgcom.
+  *.1               Unix-style man pages for programs (same info as usage.txt).
+  wizard.txt        Advanced usage instructions for JPEG wizards only.
+  change.log        Version-to-version change highlights.
+Programmer and internal documentation:
+  libjpeg.txt       How to use the JPEG library in your own programs.
+  example.txt       Sample code for calling the JPEG library.
+  structure.txt     Overview of the JPEG library's internal structure.
+  coderules.txt     Coding style rules --- please read if you contribute code.
+
+Please read at least usage.txt.  Some information can also be found in the JPEG
+FAQ (Frequently Asked Questions) article.  See ARCHIVE LOCATIONS below to find
+out where to obtain the FAQ article.
+
+If you want to understand how the JPEG code works, we suggest reading one or
+more of the REFERENCES, then looking at the documentation files (in roughly
+the order listed) before diving into the code.
+
+
+OVERVIEW
+========
+
+This package contains C software to implement JPEG image encoding, decoding,
+and transcoding.  JPEG (pronounced "jay-peg") is a standardized compression
+method for full-color and grayscale images.  JPEG's strong suit is compressing
+photographic images or other types of images that have smooth color and
+brightness transitions between neighboring pixels.  Images with sharp lines or
+other abrupt features may not compress well with JPEG, and a higher JPEG
+quality may have to be used to avoid visible compression artifacts with such
+images.
+
+JPEG is lossy, meaning that the output pixels are not necessarily identical to
+the input pixels.  However, on photographic content and other "smooth" images,
+very good compression ratios can be obtained with no visible compression
+artifacts, and extremely high compression ratios are possible if you are
+willing to sacrifice image quality (by reducing the "quality" setting in the
+compressor.)
+
+This software implements JPEG baseline, extended-sequential, and progressive
+compression processes.  Provision is made for supporting all variants of these
+processes, although some uncommon parameter settings aren't implemented yet.
+We have made no provision for supporting the hierarchical or lossless
+processes defined in the standard.
+
+We provide a set of library routines for reading and writing JPEG image files,
+plus two sample applications "cjpeg" and "djpeg", which use the library to
+perform conversion between JPEG and some other popular image file formats.
+The library is intended to be reused in other applications.
+
+In order to support file conversion and viewing software, we have included
+considerable functionality beyond the bare JPEG coding/decoding capability;
+for example, the color quantization modules are not strictly part of JPEG
+decoding, but they are essential for output to colormapped file formats or
+colormapped displays.  These extra functions can be compiled out of the
+library if not required for a particular application.
+
+We have also included "jpegtran", a utility for lossless transcoding between
+different JPEG processes, and "rdjpgcom" and "wrjpgcom", two simple
+applications for inserting and extracting textual comments in JFIF files.
+
+The emphasis in designing this software has been on achieving portability and
+flexibility, while also making it fast enough to be useful.  In particular,
+the software is not intended to be read as a tutorial on JPEG.  (See the
+REFERENCES section for introductory material.)  Rather, it is intended to
+be reliable, portable, industrial-strength code.  We do not claim to have
+achieved that goal in every aspect of the software, but we strive for it.
+
+We welcome the use of this software as a component of commercial products.
+No royalty is required, but we do ask for an acknowledgement in product
+documentation, as described under LEGAL ISSUES.
+
+
+LEGAL ISSUES
+============
+
+In plain English:
+
+1. We don't promise that this software works.  (But if you find any bugs,
+   please let us know!)
+2. You can use this software for whatever you want.  You don't have to pay us.
+3. You may not pretend that you wrote this software.  If you use it in a
+   program, you must acknowledge somewhere in your documentation that
+   you've used the IJG code.
+
+In legalese:
+
+The authors make NO WARRANTY or representation, either express or implied,
+with respect to this software, its quality, accuracy, merchantability, or
+fitness for a particular purpose.  This software is provided "AS IS", and you,
+its user, assume the entire risk as to its quality and accuracy.
+
+This software is copyright (C) 1991-2020, Thomas G. Lane, Guido Vollbeding.
+All Rights Reserved except as specified below.
+
+Permission is hereby granted to use, copy, modify, and distribute this
+software (or portions thereof) for any purpose, without fee, subject to these
+conditions:
+(1) If any part of the source code for this software is distributed, then this
+README file must be included, with this copyright and no-warranty notice
+unaltered; and any additions, deletions, or changes to the original files
+must be clearly indicated in accompanying documentation.
+(2) If only executable code is distributed, then the accompanying
+documentation must state that "this software is based in part on the work of
+the Independent JPEG Group".
+(3) Permission for use of this software is granted only if the user accepts
+full responsibility for any undesirable consequences; the authors accept
+NO LIABILITY for damages of any kind.
+
+These conditions apply to any software derived from or based on the IJG code,
+not just to the unmodified library.  If you use our work, you ought to
+acknowledge us.
+
+Permission is NOT granted for the use of any IJG author's name or company name
+in advertising or publicity relating to this software or products derived from
+it.  This software may be referred to only as "the Independent JPEG Group's
+software".
+
+We specifically permit and encourage the use of this software as the basis of
+commercial products, provided that all warranty or liability claims are
+assumed by the product vendor.
+
+
+REFERENCES
+==========
+
+We recommend reading one or more of these references before trying to
+understand the innards of the JPEG software.
+
+The best short technical introduction to the JPEG compression algorithm is
+        Wallace, Gregory K.  "The JPEG Still Picture Compression Standard",
+        Communications of the ACM, April 1991 (vol. 34 no. 4), pp. 30-44.
+(Adjacent articles in that issue discuss MPEG motion picture compression,
+applications of JPEG, and related topics.)  If you don't have the CACM issue
+handy, a PDF file containing a revised version of Wallace's article is
+available at http://www.ijg.org/files/Wallace.JPEG.pdf.  The file (actually
+a preprint for an article that appeared in IEEE Trans. Consumer Electronics)
+omits the sample images that appeared in CACM, but it includes corrections
+and some added material.  Note: the Wallace article is copyright ACM and IEEE,
+and it may not be used for commercial purposes.
+
+A somewhat less technical, more leisurely introduction to JPEG can be found in
+"The Data Compression Book" by Mark Nelson and Jean-loup Gailly, published by
+M&T Books (New York), 2nd ed. 1996, ISBN 1-55851-434-1.  This book provides
+good explanations and example C code for a multitude of compression methods
+including JPEG.  It is an excellent source if you are comfortable reading C
+code but don't know much about data compression in general.  The book's JPEG
+sample code is far from industrial-strength, but when you are ready to look
+at a full implementation, you've got one here...
+
+The best currently available description of JPEG is the textbook "JPEG Still
+Image Data Compression Standard" by William B. Pennebaker and Joan L.
+Mitchell, published by Van Nostrand Reinhold, 1993, ISBN 0-442-01272-1.
+Price US$59.95, 638 pp.  The book includes the complete text of the ISO JPEG
+standards (DIS 10918-1 and draft DIS 10918-2).
+
+The original JPEG standard is divided into two parts, Part 1 being the actual
+specification, while Part 2 covers compliance testing methods.  Part 1 is
+titled "Digital Compression and Coding of Continuous-tone Still Images,
+Part 1: Requirements and guidelines" and has document numbers ISO/IEC IS
+10918-1, ITU-T T.81.  Part 2 is titled "Digital Compression and Coding of
+Continuous-tone Still Images, Part 2: Compliance testing" and has document
+numbers ISO/IEC IS 10918-2, ITU-T T.83.
+
+The JPEG standard does not specify all details of an interchangeable file
+format.  For the omitted details, we follow the "JFIF" conventions, revision
+1.02.  JFIF version 1 has been adopted as ISO/IEC 10918-5 (05/2013) and
+Recommendation ITU-T T.871 (05/2011): Information technology - Digital
+compression and coding of continuous-tone still images: JPEG File Interchange
+Format (JFIF).  It is available as a free download in PDF file format from
+https://www.iso.org/standard/54989.html and http://www.itu.int/rec/T-REC-T.871.
+A PDF file of the older JFIF 1.02 specification is available at
+http://www.w3.org/Graphics/JPEG/jfif3.pdf.
+
+The TIFF 6.0 file format specification can be obtained from
+http://mirrors.ctan.org/graphics/tiff/TIFF6.ps.gz.  The JPEG incorporation
+scheme found in the TIFF 6.0 spec of 3-June-92 has a number of serious
+problems.  IJG does not recommend use of the TIFF 6.0 design (TIFF Compression
+tag 6).  Instead, we recommend the JPEG design proposed by TIFF Technical Note
+#2 (Compression tag 7).  Copies of this Note can be obtained from
+http://www.ijg.org/files/.  It is expected that the next revision
+of the TIFF spec will replace the 6.0 JPEG design with the Note's design.
+Although IJG's own code does not support TIFF/JPEG, the free libtiff library
+uses our library to implement TIFF/JPEG per the Note.
+
+
+ARCHIVE LOCATIONS
+=================
+
+The "official" archive site for this software is www.ijg.org.
+The most recent released version can always be found there in
+directory "files".
+
+The JPEG FAQ (Frequently Asked Questions) article is a source of some
+general information about JPEG.  It is available at
+http://www.faqs.org/faqs/jpeg-faq.
+
+
+FILE FORMAT COMPATIBILITY
+=========================
+
+This software implements ITU T.81 | ISO/IEC 10918 with some extensions from
+ITU T.871 | ISO/IEC 10918-5 (JPEG File Interchange Format-- see REFERENCES).
+Informally, the term "JPEG image" or "JPEG file" most often refers to JFIF or
+a subset thereof, but there are other formats containing the name "JPEG" that
+are incompatible with the DCT-based JPEG standard or with JFIF (for instance,
+JPEG 2000 and JPEG XR).  This software therefore does not support these
+formats.  Indeed, one of the original reasons for developing this free software
+was to help force convergence on a common, interoperable format standard for
+JPEG files.
+
+JFIF is a minimal or "low end" representation.  TIFF/JPEG (TIFF revision 6.0 as
+modified by TIFF Technical Note #2) can be used for "high end" applications
+that need to record a lot of additional data about an image.
+
+
+TO DO
+=====
+
+Please send bug reports, offers of help, etc. to jpeg-info@jpegclub.org.
diff --git a/3rdparty/libjpeg/src/README.md b/3rdparty/libjpeg/src/README.md
new file mode 100644
index 00000000..01e391ea
--- /dev/null
+++ b/3rdparty/libjpeg/src/README.md
@@ -0,0 +1,357 @@
+Background
+==========
+
+libjpeg-turbo is a JPEG image codec that uses SIMD instructions to accelerate
+baseline JPEG compression and decompression on x86, x86-64, Arm, PowerPC, and
+MIPS systems, as well as progressive JPEG compression on x86, x86-64, and Arm
+systems.  On such systems, libjpeg-turbo is generally 2-6x as fast as libjpeg,
+all else being equal.  On other types of systems, libjpeg-turbo can still
+outperform libjpeg by a significant amount, by virtue of its highly-optimized
+Huffman coding routines.  In many cases, the performance of libjpeg-turbo
+rivals that of proprietary high-speed JPEG codecs.
+
+libjpeg-turbo implements both the traditional libjpeg API as well as the less
+powerful but more straightforward TurboJPEG API.  libjpeg-turbo also features
+colorspace extensions that allow it to compress from/decompress to 32-bit and
+big-endian pixel buffers (RGBX, XBGR, etc.), as well as a full-featured Java
+interface.
+
+libjpeg-turbo was originally based on libjpeg/SIMD, an MMX-accelerated
+derivative of libjpeg v6b developed by Miyasaka Masaru.  The TigerVNC and
+VirtualGL projects made numerous enhancements to the codec in 2009, and in
+early 2010, libjpeg-turbo spun off into an independent project, with the goal
+of making high-speed JPEG compression/decompression technology available to a
+broader range of users and developers.
+
+
+License
+=======
+
+libjpeg-turbo is covered by three compatible BSD-style open source licenses.
+Refer to [LICENSE.md](LICENSE.md) for a roll-up of license terms.
+
+
+Building libjpeg-turbo
+======================
+
+Refer to [BUILDING.md](BUILDING.md) for complete instructions.
+
+
+Using libjpeg-turbo
+===================
+
+libjpeg-turbo includes two APIs that can be used to compress and decompress
+JPEG images:
+
+- **TurboJPEG API**<br>
+  This API provides an easy-to-use interface for compressing and decompressing
+  JPEG images in memory.  It also provides some functionality that would not be
+  straightforward to achieve using the underlying libjpeg API, such as
+  generating planar YUV images and performing multiple simultaneous lossless
+  transforms on an image.  The Java interface for libjpeg-turbo is written on
+  top of the TurboJPEG API.  The TurboJPEG API is recommended for first-time
+  users of libjpeg-turbo.  Refer to [tjexample.c](tjexample.c) and
+  [TJExample.java](java/TJExample.java) for examples of its usage and to
+  <http://libjpeg-turbo.org/Documentation/Documentation> for API documentation.
+
+- **libjpeg API**<br>
+  This is the de facto industry-standard API for compressing and decompressing
+  JPEG images.  It is more difficult to use than the TurboJPEG API but also
+  more powerful.  The libjpeg API implementation in libjpeg-turbo is both
+  API/ABI-compatible and mathematically compatible with libjpeg v6b.  It can
+  also optionally be configured to be API/ABI-compatible with libjpeg v7 and v8
+  (see below.)  Refer to [cjpeg.c](cjpeg.c) and [djpeg.c](djpeg.c) for examples
+  of its usage and to [libjpeg.txt](libjpeg.txt) for API documentation.
+
+There is no significant performance advantage to either API when both are used
+to perform similar operations.
+
+Colorspace Extensions
+---------------------
+
+libjpeg-turbo includes extensions that allow JPEG images to be compressed
+directly from (and decompressed directly to) buffers that use BGR, BGRX,
+RGBX, XBGR, and XRGB pixel ordering.  This is implemented with ten new
+colorspace constants:
+
+    JCS_EXT_RGB   /* red/green/blue */
+    JCS_EXT_RGBX  /* red/green/blue/x */
+    JCS_EXT_BGR   /* blue/green/red */
+    JCS_EXT_BGRX  /* blue/green/red/x */
+    JCS_EXT_XBGR  /* x/blue/green/red */
+    JCS_EXT_XRGB  /* x/red/green/blue */
+    JCS_EXT_RGBA  /* red/green/blue/alpha */
+    JCS_EXT_BGRA  /* blue/green/red/alpha */
+    JCS_EXT_ABGR  /* alpha/blue/green/red */
+    JCS_EXT_ARGB  /* alpha/red/green/blue */
+
+Setting `cinfo.in_color_space` (compression) or `cinfo.out_color_space`
+(decompression) to one of these values will cause libjpeg-turbo to read the
+red, green, and blue values from (or write them to) the appropriate position in
+the pixel when compressing from/decompressing to an RGB buffer.
+
+Your application can check for the existence of these extensions at compile
+time with:
+
+    #ifdef JCS_EXTENSIONS
+
+At run time, attempting to use these extensions with a libjpeg implementation
+that does not support them will result in a "Bogus input colorspace" error.
+Applications can trap this error in order to test whether run-time support is
+available for the colorspace extensions.
+
+When using the RGBX, BGRX, XBGR, and XRGB colorspaces during decompression, the
+X byte is undefined, and in order to ensure the best performance, libjpeg-turbo
+can set that byte to whatever value it wishes.  If an application expects the X
+byte to be used as an alpha channel, then it should specify `JCS_EXT_RGBA`,
+`JCS_EXT_BGRA`, `JCS_EXT_ABGR`, or `JCS_EXT_ARGB`.  When these colorspace
+constants are used, the X byte is guaranteed to be 0xFF, which is interpreted
+as opaque.
+
+Your application can check for the existence of the alpha channel colorspace
+extensions at compile time with:
+
+    #ifdef JCS_ALPHA_EXTENSIONS
+
+[jcstest.c](jcstest.c), located in the libjpeg-turbo source tree, demonstrates
+how to check for the existence of the colorspace extensions at compile time and
+run time.
+
+libjpeg v7 and v8 API/ABI Emulation
+-----------------------------------
+
+With libjpeg v7 and v8, new features were added that necessitated extending the
+compression and decompression structures.  Unfortunately, due to the exposed
+nature of those structures, extending them also necessitated breaking backward
+ABI compatibility with previous libjpeg releases.  Thus, programs that were
+built to use libjpeg v7 or v8 did not work with libjpeg-turbo, since it is
+based on the libjpeg v6b code base.  Although libjpeg v7 and v8 are not
+as widely used as v6b, enough programs (including a few Linux distros) made
+the switch that there was a demand to emulate the libjpeg v7 and v8 ABIs
+in libjpeg-turbo.  It should be noted, however, that this feature was added
+primarily so that applications that had already been compiled to use libjpeg
+v7+ could take advantage of accelerated baseline JPEG encoding/decoding
+without recompiling.  libjpeg-turbo does not claim to support all of the
+libjpeg v7+ features, nor to produce identical output to libjpeg v7+ in all
+cases (see below.)
+
+By passing an argument of `-DWITH_JPEG7=1` or `-DWITH_JPEG8=1` to `cmake`, you
+can build a version of libjpeg-turbo that emulates the libjpeg v7 or v8 ABI, so
+that programs that are built against libjpeg v7 or v8 can be run with
+libjpeg-turbo.  The following section describes which libjpeg v7+ features are
+supported and which aren't.
+
+### Support for libjpeg v7 and v8 Features
+
+#### Fully supported
+
+- **libjpeg API: IDCT scaling extensions in decompressor**<br>
+  libjpeg-turbo supports IDCT scaling with scaling factors of 1/8, 1/4, 3/8,
+  1/2, 5/8, 3/4, 7/8, 9/8, 5/4, 11/8, 3/2, 13/8, 7/4, 15/8, and 2/1 (only 1/4
+  and 1/2 are SIMD-accelerated.)
+
+- **libjpeg API: Arithmetic coding**
+
+- **libjpeg API: In-memory source and destination managers**<br>
+  See notes below.
+
+- **cjpeg: Separate quality settings for luminance and chrominance**<br>
+  Note that the libpjeg v7+ API was extended to accommodate this feature only
+  for convenience purposes.  It has always been possible to implement this
+  feature with libjpeg v6b (see rdswitch.c for an example.)
+
+- **cjpeg: 32-bit BMP support**
+
+- **cjpeg: `-rgb` option**
+
+- **jpegtran: Lossless cropping**
+
+- **jpegtran: `-perfect` option**
+
+- **jpegtran: Forcing width/height when performing lossless crop**
+
+- **rdjpgcom: `-raw` option**
+
+- **rdjpgcom: Locale awareness**
+
+
+#### Not supported
+
+NOTE:  As of this writing, extensive research has been conducted into the
+usefulness of DCT scaling as a means of data reduction and SmartScale as a
+means of quality improvement.  Readers are invited to peruse the research at
+<http://www.libjpeg-turbo.org/About/SmartScale> and draw their own conclusions,
+but it is the general belief of our project that these features have not
+demonstrated sufficient usefulness to justify inclusion in libjpeg-turbo.
+
+- **libjpeg API: DCT scaling in compressor**<br>
+  `cinfo.scale_num` and `cinfo.scale_denom` are silently ignored.
+  There is no technical reason why DCT scaling could not be supported when
+  emulating the libjpeg v7+ API/ABI, but without the SmartScale extension (see
+  below), only scaling factors of 1/2, 8/15, 4/7, 8/13, 2/3, 8/11, 4/5, and
+  8/9 would be available, which is of limited usefulness.
+
+- **libjpeg API: SmartScale**<br>
+  `cinfo.block_size` is silently ignored.
+  SmartScale is an extension to the JPEG format that allows for DCT block
+  sizes other than 8x8.  Providing support for this new format would be
+  feasible (particularly without full acceleration.)  However, until/unless
+  the format becomes either an official industry standard or, at minimum, an
+  accepted solution in the community, we are hesitant to implement it, as
+  there is no sense of whether or how it might change in the future.  It is
+  our belief that SmartScale has not demonstrated sufficient usefulness as a
+  lossless format nor as a means of quality enhancement, and thus our primary
+  interest in providing this feature would be as a means of supporting
+  additional DCT scaling factors.
+
+- **libjpeg API: Fancy downsampling in compressor**<br>
+  `cinfo.do_fancy_downsampling` is silently ignored.
+  This requires the DCT scaling feature, which is not supported.
+
+- **jpegtran: Scaling**<br>
+  This requires both the DCT scaling and SmartScale features, which are not
+  supported.
+
+- **Lossless RGB JPEG files**<br>
+  This requires the SmartScale feature, which is not supported.
+
+### What About libjpeg v9?
+
+libjpeg v9 introduced yet another field to the JPEG compression structure
+(`color_transform`), thus making the ABI backward incompatible with that of
+libjpeg v8.  This new field was introduced solely for the purpose of supporting
+lossless SmartScale encoding.  Furthermore, there was actually no reason to
+extend the API in this manner, as the color transform could have just as easily
+been activated by way of a new JPEG colorspace constant, thus preserving
+backward ABI compatibility.
+
+Our research (see link above) has shown that lossless SmartScale does not
+generally accomplish anything that can't already be accomplished better with
+existing, standard lossless formats.  Therefore, at this time it is our belief
+that there is not sufficient technical justification for software projects to
+upgrade from libjpeg v8 to libjpeg v9, and thus there is not sufficient
+technical justification for us to emulate the libjpeg v9 ABI.
+
+In-Memory Source/Destination Managers
+-------------------------------------
+
+By default, libjpeg-turbo 1.3 and later includes the `jpeg_mem_src()` and
+`jpeg_mem_dest()` functions, even when not emulating the libjpeg v8 API/ABI.
+Previously, it was necessary to build libjpeg-turbo from source with libjpeg v8
+API/ABI emulation in order to use the in-memory source/destination managers,
+but several projects requested that those functions be included when emulating
+the libjpeg v6b API/ABI as well.  This allows the use of those functions by
+programs that need them, without breaking ABI compatibility for programs that
+don't, and it allows those functions to be provided in the "official"
+libjpeg-turbo binaries.
+
+Those who are concerned about maintaining strict conformance with the libjpeg
+v6b or v7 API can pass an argument of `-DWITH_MEM_SRCDST=0` to `cmake` prior to
+building libjpeg-turbo.  This will restore the pre-1.3 behavior, in which
+`jpeg_mem_src()` and `jpeg_mem_dest()` are only included when emulating the
+libjpeg v8 API/ABI.
+
+On Un*x systems, including the in-memory source/destination managers changes
+the dynamic library version from 62.2.0 to 62.3.0 if using libjpeg v6b API/ABI
+emulation and from 7.2.0 to 7.3.0 if using libjpeg v7 API/ABI emulation.
+
+Note that, on most Un*x systems, the dynamic linker will not look for a
+function in a library until that function is actually used.  Thus, if a program
+is built against libjpeg-turbo 1.3+ and uses `jpeg_mem_src()` or
+`jpeg_mem_dest()`, that program will not fail if run against an older version
+of libjpeg-turbo or against libjpeg v7- until the program actually tries to
+call `jpeg_mem_src()` or `jpeg_mem_dest()`.  Such is not the case on Windows.
+If a program is built against the libjpeg-turbo 1.3+ DLL and uses
+`jpeg_mem_src()` or `jpeg_mem_dest()`, then it must use the libjpeg-turbo 1.3+
+DLL at run time.
+
+Both cjpeg and djpeg have been extended to allow testing the in-memory
+source/destination manager functions.  See their respective man pages for more
+details.
+
+
+Mathematical Compatibility
+==========================
+
+For the most part, libjpeg-turbo should produce identical output to libjpeg
+v6b.  The one exception to this is when using the floating point DCT/IDCT, in
+which case the outputs of libjpeg v6b and libjpeg-turbo can differ for the
+following reasons:
+
+- The SSE/SSE2 floating point DCT implementation in libjpeg-turbo is ever so
+  slightly more accurate than the implementation in libjpeg v6b, but not by
+  any amount perceptible to human vision (generally in the range of 0.01 to
+  0.08 dB gain in PNSR.)
+
+- When not using the SIMD extensions, libjpeg-turbo uses the more accurate
+  (and slightly faster) floating point IDCT algorithm introduced in libjpeg
+  v8a as opposed to the algorithm used in libjpeg v6b.  It should be noted,
+  however, that this algorithm basically brings the accuracy of the floating
+  point IDCT in line with the accuracy of the accurate integer IDCT.  The
+  floating point DCT/IDCT algorithms are mainly a legacy feature, and they do
+  not produce significantly more accuracy than the accurate integer algorithms
+  (to put numbers on this, the typical difference in PNSR between the two
+  algorithms is less than 0.10 dB, whereas changing the quality level by 1 in
+  the upper range of the quality scale is typically more like a 1.0 dB
+  difference.)
+
+- If the floating point algorithms in libjpeg-turbo are not implemented using
+  SIMD instructions on a particular platform, then the accuracy of the
+  floating point DCT/IDCT can depend on the compiler settings.
+
+While libjpeg-turbo does emulate the libjpeg v8 API/ABI, under the hood it is
+still using the same algorithms as libjpeg v6b, so there are several specific
+cases in which libjpeg-turbo cannot be expected to produce the same output as
+libjpeg v8:
+
+- When decompressing using scaling factors of 1/2 and 1/4, because libjpeg v8
+  implements those scaling algorithms differently than libjpeg v6b does, and
+  libjpeg-turbo's SIMD extensions are based on the libjpeg v6b behavior.
+
+- When using chrominance subsampling, because libjpeg v8 implements this
+  with its DCT/IDCT scaling algorithms rather than with a separate
+  downsampling/upsampling algorithm.  In our testing, the subsampled/upsampled
+  output of libjpeg v8 is less accurate than that of libjpeg v6b for this
+  reason.
+
+- When decompressing using a scaling factor > 1 and merged (AKA "non-fancy" or
+  "non-smooth") chrominance upsampling, because libjpeg v8 does not support
+  merged upsampling with scaling factors > 1.
+
+
+Performance Pitfalls
+====================
+
+Restart Markers
+---------------
+
+The optimized Huffman decoder in libjpeg-turbo does not handle restart markers
+in a way that makes the rest of the libjpeg infrastructure happy, so it is
+necessary to use the slow Huffman decoder when decompressing a JPEG image that
+has restart markers.  This can cause the decompression performance to drop by
+as much as 20%, but the performance will still be much greater than that of
+libjpeg.  Many consumer packages, such as Photoshop, use restart markers when
+generating JPEG images, so images generated by those programs will experience
+this issue.
+
+Fast Integer Forward DCT at High Quality Levels
+-----------------------------------------------
+
+The algorithm used by the SIMD-accelerated quantization function cannot produce
+correct results whenever the fast integer forward DCT is used along with a JPEG
+quality of 98-100.  Thus, libjpeg-turbo must use the non-SIMD quantization
+function in those cases.  This causes performance to drop by as much as 40%.
+It is therefore strongly advised that you use the accurate integer forward DCT
+whenever encoding images with a JPEG quality of 98 or higher.
+
+
+Memory Debugger Pitfalls
+========================
+
+Valgrind and Memory Sanitizer (MSan) can generate false positives
+(specifically, incorrect reports of uninitialized memory accesses) when used
+with libjpeg-turbo's SIMD extensions.  It is generally recommended that the
+SIMD extensions be disabled, either by passing an argument of `-DWITH_SIMD=0`
+to `cmake` when configuring the build or by setting the environment variable
+`JSIMD_FORCENONE` to `1` at run time, when testing libjpeg-turbo with Valgrind,
+MSan, or other memory debuggers.
diff --git a/3rdparty/libjpeg/src/cderror.h b/3rdparty/libjpeg/src/cderror.h
new file mode 100644
index 00000000..a386b693
--- /dev/null
+++ b/3rdparty/libjpeg/src/cderror.h
@@ -0,0 +1,120 @@
+/*
+ * cderror.h
+ *
+ * Copyright (C) 1994-1997, Thomas G. Lane.
+ * Modified 2009-2017 by Guido Vollbeding.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file defines the error and message codes for the cjpeg/djpeg
+ * applications.  These strings are not needed as part of the JPEG library
+ * proper.
+ * Edit this file to add new codes, or to translate the message strings to
+ * some other language.
+ */
+
+/*
+ * To define the enum list of message codes, include this file without
+ * defining macro JMESSAGE.  To create a message string table, include it
+ * again with a suitable JMESSAGE definition (see jerror.c for an example).
+ */
+#ifndef JMESSAGE
+#ifndef CDERROR_H
+#define CDERROR_H
+/* First time through, define the enum list */
+#define JMAKE_ENUM_LIST
+#else
+/* Repeated inclusions of this file are no-ops unless JMESSAGE is defined */
+#define JMESSAGE(code, string)
+#endif /* CDERROR_H */
+#endif /* JMESSAGE */
+
+#ifdef JMAKE_ENUM_LIST
+
+typedef enum {
+
+#define JMESSAGE(code, string)  code,
+
+#endif /* JMAKE_ENUM_LIST */
+
+JMESSAGE(JMSG_FIRSTADDONCODE = 1000, NULL) /* Must be first entry! */
+
+#ifdef BMP_SUPPORTED
+JMESSAGE(JERR_BMP_BADCMAP, "Unsupported BMP colormap format")
+JMESSAGE(JERR_BMP_BADDEPTH, "Only 8-, 24-, and 32-bit BMP files are supported")
+JMESSAGE(JERR_BMP_BADHEADER, "Invalid BMP file: bad header length")
+JMESSAGE(JERR_BMP_BADPLANES, "Invalid BMP file: biPlanes not equal to 1")
+JMESSAGE(JERR_BMP_COLORSPACE, "BMP output must be grayscale or RGB")
+JMESSAGE(JERR_BMP_COMPRESSED, "Sorry, compressed BMPs not yet supported")
+JMESSAGE(JERR_BMP_EMPTY, "Empty BMP image")
+JMESSAGE(JERR_BMP_NOT, "Not a BMP file - does not start with BM")
+JMESSAGE(JERR_BMP_OUTOFRANGE, "Numeric value out of range in BMP file")
+JMESSAGE(JTRC_BMP, "%ux%u %d-bit BMP image")
+JMESSAGE(JTRC_BMP_MAPPED, "%ux%u 8-bit colormapped BMP image")
+JMESSAGE(JTRC_BMP_OS2, "%ux%u %d-bit OS2 BMP image")
+JMESSAGE(JTRC_BMP_OS2_MAPPED, "%ux%u 8-bit colormapped OS2 BMP image")
+#endif /* BMP_SUPPORTED */
+
+#ifdef GIF_SUPPORTED
+JMESSAGE(JERR_GIF_BUG, "GIF output got confused")
+JMESSAGE(JERR_GIF_CODESIZE, "Bogus GIF codesize %d")
+JMESSAGE(JERR_GIF_COLORSPACE, "GIF output must be grayscale or RGB")
+JMESSAGE(JERR_GIF_IMAGENOTFOUND, "Too few images in GIF file")
+JMESSAGE(JERR_GIF_NOT, "Not a GIF file")
+JMESSAGE(JTRC_GIF, "%ux%ux%d GIF image")
+JMESSAGE(JTRC_GIF_BADVERSION,
+         "Warning: unexpected GIF version number '%c%c%c'")
+JMESSAGE(JTRC_GIF_EXTENSION, "Ignoring GIF extension block of type 0x%02x")
+JMESSAGE(JTRC_GIF_NONSQUARE, "Caution: nonsquare pixels in input")
+JMESSAGE(JWRN_GIF_BADDATA, "Corrupt data in GIF file")
+JMESSAGE(JWRN_GIF_CHAR, "Bogus char 0x%02x in GIF file, ignoring")
+JMESSAGE(JWRN_GIF_ENDCODE, "Premature end of GIF image")
+JMESSAGE(JWRN_GIF_NOMOREDATA, "Ran out of GIF bits")
+#endif /* GIF_SUPPORTED */
+
+#ifdef PPM_SUPPORTED
+JMESSAGE(JERR_PPM_COLORSPACE, "PPM output must be grayscale or RGB")
+JMESSAGE(JERR_PPM_NONNUMERIC, "Nonnumeric data in PPM file")
+JMESSAGE(JERR_PPM_NOT, "Not a PPM/PGM file")
+JMESSAGE(JERR_PPM_OUTOFRANGE, "Numeric value out of range in PPM file")
+JMESSAGE(JTRC_PGM, "%ux%u PGM image")
+JMESSAGE(JTRC_PGM_TEXT, "%ux%u text PGM image")
+JMESSAGE(JTRC_PPM, "%ux%u PPM image")
+JMESSAGE(JTRC_PPM_TEXT, "%ux%u text PPM image")
+#endif /* PPM_SUPPORTED */
+
+#ifdef TARGA_SUPPORTED
+JMESSAGE(JERR_TGA_BADCMAP, "Unsupported Targa colormap format")
+JMESSAGE(JERR_TGA_BADPARMS, "Invalid or unsupported Targa file")
+JMESSAGE(JERR_TGA_COLORSPACE, "Targa output must be grayscale or RGB")
+JMESSAGE(JTRC_TGA, "%ux%u RGB Targa image")
+JMESSAGE(JTRC_TGA_GRAY, "%ux%u grayscale Targa image")
+JMESSAGE(JTRC_TGA_MAPPED, "%ux%u colormapped Targa image")
+#else
+JMESSAGE(JERR_TGA_NOTCOMP, "Targa support was not compiled")
+#endif /* TARGA_SUPPORTED */
+
+JMESSAGE(JERR_BAD_CMAP_FILE,
+         "Color map file is invalid or of unsupported format")
+JMESSAGE(JERR_TOO_MANY_COLORS,
+         "Output file format cannot handle %d colormap entries")
+JMESSAGE(JERR_UNGETC_FAILED, "ungetc failed")
+#ifdef TARGA_SUPPORTED
+JMESSAGE(JERR_UNKNOWN_FORMAT,
+         "Unrecognized input file format --- perhaps you need -targa")
+#else
+JMESSAGE(JERR_UNKNOWN_FORMAT, "Unrecognized input file format")
+#endif
+JMESSAGE(JERR_UNSUPPORTED_FORMAT, "Unsupported output file format")
+
+#ifdef JMAKE_ENUM_LIST
+
+  JMSG_LASTADDONCODE
+} ADDON_MESSAGE_CODE;
+
+#undef JMAKE_ENUM_LIST
+#endif /* JMAKE_ENUM_LIST */
+
+/* Zap JMESSAGE macro so that future re-inclusions do nothing by default */
+#undef JMESSAGE
diff --git a/3rdparty/libjpeg/src/cdjpeg.c b/3rdparty/libjpeg/src/cdjpeg.c
new file mode 100644
index 00000000..5278c1db
--- /dev/null
+++ b/3rdparty/libjpeg/src/cdjpeg.c
@@ -0,0 +1,156 @@
+/*
+ * cdjpeg.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1991-1997, Thomas G. Lane.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2019, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains common support routines used by the IJG application
+ * programs (cjpeg, djpeg, jpegtran).
+ */
+
+#include "cdjpeg.h"             /* Common decls for cjpeg/djpeg applications */
+#include <ctype.h>              /* to declare isupper(), tolower() */
+#ifdef USE_SETMODE
+#include <fcntl.h>              /* to declare setmode()'s parameter macros */
+/* If you have setmode() but not <io.h>, just delete this line: */
+#include <io.h>                 /* to declare setmode() */
+#endif
+
+
+/*
+ * Optional progress monitor: display a percent-done figure on stderr.
+ */
+
+METHODDEF(void)
+progress_monitor(j_common_ptr cinfo)
+{
+  cd_progress_ptr prog = (cd_progress_ptr)cinfo->progress;
+
+  if (prog->max_scans != 0 && cinfo->is_decompressor) {
+    int scan_no = ((j_decompress_ptr)cinfo)->input_scan_number;
+
+    if (scan_no > (int)prog->max_scans) {
+      fprintf(stderr, "Scan number %d exceeds maximum scans (%d)\n", scan_no,
+              prog->max_scans);
+      exit(EXIT_FAILURE);
+    }
+  }
+
+  if (prog->report) {
+    int total_passes = prog->pub.total_passes + prog->total_extra_passes;
+    int percent_done =
+      (int)(prog->pub.pass_counter * 100L / prog->pub.pass_limit);
+
+    if (percent_done != prog->percent_done) {
+      prog->percent_done = percent_done;
+      if (total_passes > 1) {
+        fprintf(stderr, "\rPass %d/%d: %3d%% ",
+                prog->pub.completed_passes + prog->completed_extra_passes + 1,
+                total_passes, percent_done);
+      } else {
+        fprintf(stderr, "\r %3d%% ", percent_done);
+      }
+      fflush(stderr);
+    }
+  }
+}
+
+
+GLOBAL(void)
+start_progress_monitor(j_common_ptr cinfo, cd_progress_ptr progress)
+{
+  /* Enable progress display, unless trace output is on */
+  if (cinfo->err->trace_level == 0) {
+    progress->pub.progress_monitor = progress_monitor;
+    progress->completed_extra_passes = 0;
+    progress->total_extra_passes = 0;
+    progress->max_scans = 0;
+    progress->report = FALSE;
+    progress->percent_done = -1;
+    cinfo->progress = &progress->pub;
+  }
+}
+
+
+GLOBAL(void)
+end_progress_monitor(j_common_ptr cinfo)
+{
+  /* Clear away progress display */
+  if (cinfo->err->trace_level == 0) {
+    fprintf(stderr, "\r                \r");
+    fflush(stderr);
+  }
+}
+
+
+/*
+ * Case-insensitive matching of possibly-abbreviated keyword switches.
+ * keyword is the constant keyword (must be lower case already),
+ * minchars is length of minimum legal abbreviation.
+ */
+
+GLOBAL(boolean)
+keymatch(char *arg, const char *keyword, int minchars)
+{
+  register int ca, ck;
+  register int nmatched = 0;
+
+  while ((ca = *arg++) != '\0') {
+    if ((ck = *keyword++) == '\0')
+      return FALSE;             /* arg longer than keyword, no good */
+    if (isupper(ca))            /* force arg to lcase (assume ck is already) */
+      ca = tolower(ca);
+    if (ca != ck)
+      return FALSE;             /* no good */
+    nmatched++;                 /* count matched characters */
+  }
+  /* reached end of argument; fail if it's too short for unique abbrev */
+  if (nmatched < minchars)
+    return FALSE;
+  return TRUE;                  /* A-OK */
+}
+
+
+/*
+ * Routines to establish binary I/O mode for stdin and stdout.
+ * Non-Unix systems often require some hacking to get out of text mode.
+ */
+
+GLOBAL(FILE *)
+read_stdin(void)
+{
+  FILE *input_file = stdin;
+
+#ifdef USE_SETMODE              /* need to hack file mode? */
+  setmode(fileno(stdin), O_BINARY);
+#endif
+#ifdef USE_FDOPEN               /* need to re-open in binary mode? */
+  if ((input_file = fdopen(fileno(stdin), READ_BINARY)) == NULL) {
+    fprintf(stderr, "Cannot reopen stdin\n");
+    exit(EXIT_FAILURE);
+  }
+#endif
+  return input_file;
+}
+
+
+GLOBAL(FILE *)
+write_stdout(void)
+{
+  FILE *output_file = stdout;
+
+#ifdef USE_SETMODE              /* need to hack file mode? */
+  setmode(fileno(stdout), O_BINARY);
+#endif
+#ifdef USE_FDOPEN               /* need to re-open in binary mode? */
+  if ((output_file = fdopen(fileno(stdout), WRITE_BINARY)) == NULL) {
+    fprintf(stderr, "Cannot reopen stdout\n");
+    exit(EXIT_FAILURE);
+  }
+#endif
+  return output_file;
+}
diff --git a/3rdparty/libjpeg/src/cdjpeg.h b/3rdparty/libjpeg/src/cdjpeg.h
new file mode 100644
index 00000000..71b0c4fb
--- /dev/null
+++ b/3rdparty/libjpeg/src/cdjpeg.h
@@ -0,0 +1,158 @@
+/*
+ * cdjpeg.h
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1994-1997, Thomas G. Lane.
+ * Modified 2019 by Guido Vollbeding.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2017, 2019, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains common declarations for the sample applications
+ * cjpeg and djpeg.  It is NOT used by the core JPEG library.
+ */
+
+#define JPEG_CJPEG_DJPEG        /* define proper options in jconfig.h */
+#define JPEG_INTERNAL_OPTIONS   /* cjpeg.c,djpeg.c need to see xxx_SUPPORTED */
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jerror.h"             /* get library error codes too */
+#include "cderror.h"            /* get application-specific error codes */
+
+
+/*
+ * Object interface for cjpeg's source file decoding modules
+ */
+
+typedef struct cjpeg_source_struct *cjpeg_source_ptr;
+
+struct cjpeg_source_struct {
+  void (*start_input) (j_compress_ptr cinfo, cjpeg_source_ptr sinfo);
+  JDIMENSION (*get_pixel_rows) (j_compress_ptr cinfo, cjpeg_source_ptr sinfo);
+  void (*finish_input) (j_compress_ptr cinfo, cjpeg_source_ptr sinfo);
+
+  FILE *input_file;
+
+  JSAMPARRAY buffer;
+  JDIMENSION buffer_height;
+};
+
+
+/*
+ * Object interface for djpeg's output file encoding modules
+ */
+
+typedef struct djpeg_dest_struct *djpeg_dest_ptr;
+
+struct djpeg_dest_struct {
+  /* start_output is called after jpeg_start_decompress finishes.
+   * The color map will be ready at this time, if one is needed.
+   */
+  void (*start_output) (j_decompress_ptr cinfo, djpeg_dest_ptr dinfo);
+  /* Emit the specified number of pixel rows from the buffer. */
+  void (*put_pixel_rows) (j_decompress_ptr cinfo, djpeg_dest_ptr dinfo,
+                          JDIMENSION rows_supplied);
+  /* Finish up at the end of the image. */
+  void (*finish_output) (j_decompress_ptr cinfo, djpeg_dest_ptr dinfo);
+  /* Re-calculate buffer dimensions based on output dimensions (for use with
+     partial image decompression.)  If this is NULL, then the output format
+     does not support partial image decompression (BMP, in particular, cannot
+     support partial decompression because it uses an inversion buffer to write
+     the image in bottom-up order.) */
+  void (*calc_buffer_dimensions) (j_decompress_ptr cinfo,
+                                  djpeg_dest_ptr dinfo);
+
+
+  /* Target file spec; filled in by djpeg.c after object is created. */
+  FILE *output_file;
+
+  /* Output pixel-row buffer.  Created by module init or start_output.
+   * Width is cinfo->output_width * cinfo->output_components;
+   * height is buffer_height.
+   */
+  JSAMPARRAY buffer;
+  JDIMENSION buffer_height;
+};
+
+
+/*
+ * cjpeg/djpeg may need to perform extra passes to convert to or from
+ * the source/destination file format.  The JPEG library does not know
+ * about these passes, but we'd like them to be counted by the progress
+ * monitor.  We use an expanded progress monitor object to hold the
+ * additional pass count.
+ */
+
+struct cdjpeg_progress_mgr {
+  struct jpeg_progress_mgr pub; /* fields known to JPEG library */
+  int completed_extra_passes;   /* extra passes completed */
+  int total_extra_passes;       /* total extra */
+  JDIMENSION max_scans;         /* abort if the number of scans exceeds this
+                                   value and the value is non-zero */
+  boolean report;               /* whether or not to report progress */
+  /* last printed percentage stored here to avoid multiple printouts */
+  int percent_done;
+};
+
+typedef struct cdjpeg_progress_mgr *cd_progress_ptr;
+
+
+/* Module selection routines for I/O modules. */
+
+EXTERN(cjpeg_source_ptr) jinit_read_bmp(j_compress_ptr cinfo,
+                                        boolean use_inversion_array);
+EXTERN(djpeg_dest_ptr) jinit_write_bmp(j_decompress_ptr cinfo, boolean is_os2,
+                                       boolean use_inversion_array);
+EXTERN(cjpeg_source_ptr) jinit_read_gif(j_compress_ptr cinfo);
+EXTERN(djpeg_dest_ptr) jinit_write_gif(j_decompress_ptr cinfo, boolean is_lzw);
+EXTERN(cjpeg_source_ptr) jinit_read_ppm(j_compress_ptr cinfo);
+EXTERN(djpeg_dest_ptr) jinit_write_ppm(j_decompress_ptr cinfo);
+EXTERN(cjpeg_source_ptr) jinit_read_targa(j_compress_ptr cinfo);
+EXTERN(djpeg_dest_ptr) jinit_write_targa(j_decompress_ptr cinfo);
+
+/* cjpeg support routines (in rdswitch.c) */
+
+EXTERN(boolean) read_quant_tables(j_compress_ptr cinfo, char *filename,
+                                  boolean force_baseline);
+EXTERN(boolean) read_scan_script(j_compress_ptr cinfo, char *filename);
+EXTERN(boolean) set_quality_ratings(j_compress_ptr cinfo, char *arg,
+                                    boolean force_baseline);
+EXTERN(boolean) set_quant_slots(j_compress_ptr cinfo, char *arg);
+EXTERN(boolean) set_sample_factors(j_compress_ptr cinfo, char *arg);
+
+/* djpeg support routines (in rdcolmap.c) */
+
+EXTERN(void) read_color_map(j_decompress_ptr cinfo, FILE *infile);
+
+/* common support routines (in cdjpeg.c) */
+
+EXTERN(void) start_progress_monitor(j_common_ptr cinfo,
+                                    cd_progress_ptr progress);
+EXTERN(void) end_progress_monitor(j_common_ptr cinfo);
+EXTERN(boolean) keymatch(char *arg, const char *keyword, int minchars);
+EXTERN(FILE *) read_stdin(void);
+EXTERN(FILE *) write_stdout(void);
+
+/* miscellaneous useful macros */
+
+#ifdef DONT_USE_B_MODE          /* define mode parameters for fopen() */
+#define READ_BINARY     "r"
+#define WRITE_BINARY    "w"
+#else
+#define READ_BINARY     "rb"
+#define WRITE_BINARY    "wb"
+#endif
+
+#ifndef EXIT_FAILURE            /* define exit() codes if not provided */
+#define EXIT_FAILURE  1
+#endif
+#ifndef EXIT_SUCCESS
+#define EXIT_SUCCESS  0
+#endif
+#ifndef EXIT_WARNING
+#define EXIT_WARNING  2
+#endif
+
+#define IsExtRGB(cs) \
+  (cs == JCS_RGB || (cs >= JCS_EXT_RGB && cs <= JCS_EXT_ARGB))
diff --git a/3rdparty/libjpeg/src/cjpeg.1 b/3rdparty/libjpeg/src/cjpeg.1
new file mode 100644
index 00000000..569dc3fa
--- /dev/null
+++ b/3rdparty/libjpeg/src/cjpeg.1
@@ -0,0 +1,360 @@
+.TH CJPEG 1 "4 November 2020"
+.SH NAME
+cjpeg \- compress an image file to a JPEG file
+.SH SYNOPSIS
+.B cjpeg
+[
+.I options
+]
+[
+.I filename
+]
+.LP
+.SH DESCRIPTION
+.LP
+.B cjpeg
+compresses the named image file, or the standard input if no file is
+named, and produces a JPEG/JFIF file on the standard output.
+The currently supported input file formats are: PPM (PBMPLUS color
+format), PGM (PBMPLUS grayscale format), BMP, GIF, and Targa.
+.SH OPTIONS
+All switch names may be abbreviated; for example,
+.B \-grayscale
+may be written
+.B \-gray
+or
+.BR \-gr .
+Most of the "basic" switches can be abbreviated to as little as one letter.
+Upper and lower case are equivalent (thus
+.B \-BMP
+is the same as
+.BR \-bmp ).
+British spellings are also accepted (e.g.,
+.BR \-greyscale ),
+though for brevity these are not mentioned below.
+.PP
+The basic switches are:
+.TP
+.BI \-quality " N[,...]"
+Scale quantization tables to adjust image quality.  Quality is 0 (worst) to
+100 (best); default is 75.  (See below for more info.)
+.TP
+.B \-grayscale
+Create monochrome JPEG file from color input.  Be sure to use this switch when
+compressing a grayscale BMP or GIF file, because
+.B cjpeg
+isn't bright enough to notice whether a BMP or GIF file uses only shades of
+gray.  By saying
+.BR \-grayscale,
+you'll get a smaller JPEG file that takes less time to process.
+.TP
+.B \-rgb
+Create RGB JPEG file.
+Using this switch suppresses the conversion from RGB
+colorspace input to the default YCbCr JPEG colorspace.
+.TP
+.B \-optimize
+Perform optimization of entropy encoding parameters.  Without this, default
+encoding parameters are used.
+.B \-optimize
+usually makes the JPEG file a little smaller, but
+.B cjpeg
+runs somewhat slower and needs much more memory.  Image quality and speed of
+decompression are unaffected by
+.BR \-optimize .
+.TP
+.B \-progressive
+Create progressive JPEG file (see below).
+.TP
+.B \-targa
+Input file is Targa format.  Targa files that contain an "identification"
+field will not be automatically recognized by
+.BR cjpeg ;
+for such files you must specify
+.B \-targa
+to make
+.B cjpeg
+treat the input as Targa format.
+For most Targa files, you won't need this switch.
+.PP
+The
+.B \-quality
+switch lets you trade off compressed file size against quality of the
+reconstructed image: the higher the quality setting, the larger the JPEG file,
+and the closer the output image will be to the original input.  Normally you
+want to use the lowest quality setting (smallest file) that decompresses into
+something visually indistinguishable from the original image.  For this
+purpose the quality setting should generally be between 50 and 95 (the default
+is 75) for photographic images.  If you see defects at
+.B \-quality
+75, then go up 5 or 10 counts at a time until you are happy with the output
+image.  (The optimal setting will vary from one image to another.)
+.PP
+.B \-quality
+100 will generate a quantization table of all 1's, minimizing loss in the
+quantization step (but there is still information loss in subsampling, as well
+as roundoff error.)  For most images, specifying a quality value above
+about 95 will increase the size of the compressed file dramatically, and while
+the quality gain from these higher quality values is measurable (using metrics
+such as PSNR or SSIM), it is rarely perceivable by human vision.
+.PP
+In the other direction, quality values below 50 will produce very small files
+of low image quality.  Settings around 5 to 10 might be useful in preparing an
+index of a large image library, for example.  Try
+.B \-quality
+2 (or so) for some amusing Cubist effects.  (Note: quality
+values below about 25 generate 2-byte quantization tables, which are
+considered optional in the JPEG standard.
+.B cjpeg
+emits a warning message when you give such a quality value, because some
+other JPEG programs may be unable to decode the resulting file.  Use
+.B \-baseline
+if you need to ensure compatibility at low quality values.)
+.PP
+The \fB-quality\fR option has been extended in this version of \fBcjpeg\fR to
+support separate quality settings for luminance and chrominance (or, in
+general, separate settings for every quantization table slot.)  The principle
+is the same as chrominance subsampling:  since the human eye is more sensitive
+to spatial changes in brightness than spatial changes in color, the chrominance
+components can be quantized more than the luminance components without
+incurring any visible image quality loss.  However, unlike subsampling, this
+feature reduces data in the frequency domain instead of the spatial domain,
+which allows for more fine-grained control.  This option is useful in
+quality-sensitive applications, for which the artifacts generated by
+subsampling may be unacceptable.
+.PP
+The \fB-quality\fR option accepts a comma-separated list of parameters, which
+respectively refer to the quality levels that should be assigned to the
+quantization table slots.  If there are more q-table slots than parameters,
+then the last parameter is replicated.  Thus, if only one quality parameter is
+given, this is used for both luminance and chrominance (slots 0 and 1,
+respectively), preserving the legacy behavior of cjpeg v6b and prior.
+More (or customized) quantization tables can be set with the \fB-qtables\fR
+option and assigned to components with the \fB-qslots\fR option (see the
+"wizard" switches below.)
+.PP
+JPEG files generated with separate luminance and chrominance quality are fully
+compliant with standard JPEG decoders.
+.PP
+.BR CAUTION:
+For this setting to be useful, be sure to pass an argument of \fB-sample 1x1\fR
+to \fBcjpeg\fR to disable chrominance subsampling.  Otherwise, the default
+subsampling level (2x2, AKA "4:2:0") will be used.
+.PP
+The
+.B \-progressive
+switch creates a "progressive JPEG" file.  In this type of JPEG file, the data
+is stored in multiple scans of increasing quality.  If the file is being
+transmitted over a slow communications link, the decoder can use the first
+scan to display a low-quality image very quickly, and can then improve the
+display with each subsequent scan.  The final image is exactly equivalent to a
+standard JPEG file of the same quality setting, and the total file size is
+about the same --- often a little smaller.
+.PP
+Switches for advanced users:
+.TP
+.B \-arithmetic
+Use arithmetic coding.
+.B Caution:
+arithmetic coded JPEG is not yet widely implemented, so many decoders will be
+unable to view an arithmetic coded JPEG file at all.
+.TP
+.B \-dct int
+Use accurate integer DCT method (default).
+.TP
+.B \-dct fast
+Use less accurate integer DCT method [legacy feature].
+When the Independent JPEG Group's software was first released in 1991, the
+compression time for a 1-megapixel JPEG image on a mainstream PC was measured
+in minutes.  Thus, the \fBfast\fR integer DCT algorithm provided noticeable
+performance benefits.  On modern CPUs running libjpeg-turbo, however, the
+compression time for a 1-megapixel JPEG image is measured in milliseconds, and
+thus the performance benefits of the \fBfast\fR algorithm are much less
+noticeable.  On modern x86/x86-64 CPUs that support AVX2 instructions, the
+\fBfast\fR and \fBint\fR methods have similar performance.  On other types of
+CPUs, the \fBfast\fR method is generally about 5-15% faster than the \fBint\fR
+method.
+
+For quality levels of 90 and below, there should be little or no perceptible
+quality difference between the two algorithms.  For quality levels above 90,
+however, the difference between the \fBfast\fR and \fBint\fR methods becomes
+more pronounced.  With quality=97, for instance, the \fBfast\fR method incurs
+generally about a 1-3 dB loss in PSNR relative to the \fBint\fR method, but
+this can be larger for some images.  Do not use the \fBfast\fR method with
+quality levels above 97.  The algorithm often degenerates at quality=98 and
+above and can actually produce a more lossy image than if lower quality levels
+had been used.  Also, in libjpeg-turbo, the \fBfast\fR method is not fully
+accelerated for quality levels above 97, so it will be slower than the
+\fBint\fR method.
+.TP
+.B \-dct float
+Use floating-point DCT method [legacy feature].
+The \fBfloat\fR method does not produce significantly more accurate results
+than the \fBint\fR method, and it is much slower.  The \fBfloat\fR method may
+also give different results on different machines due to varying roundoff
+behavior, whereas the integer methods should give the same results on all
+machines.
+.TP
+.BI \-icc " file"
+Embed ICC color management profile contained in the specified file.
+.TP
+.BI \-restart " N"
+Emit a JPEG restart marker every N MCU rows, or every N MCU blocks if "B" is
+attached to the number.
+.B \-restart 0
+(the default) means no restart markers.
+.TP
+.BI \-smooth " N"
+Smooth the input image to eliminate dithering noise.  N, ranging from 1 to
+100, indicates the strength of smoothing.  0 (the default) means no smoothing.
+.TP
+.BI \-maxmemory " N"
+Set limit for amount of memory to use in processing large images.  Value is
+in thousands of bytes, or millions of bytes if "M" is attached to the
+number.  For example,
+.B \-max 4m
+selects 4000000 bytes.  If more space is needed, an error will occur.
+.TP
+.BI \-outfile " name"
+Send output image to the named file, not to standard output.
+.TP
+.BI \-memdst
+Compress to memory instead of a file.  This feature was implemented mainly as a
+way of testing the in-memory destination manager (jpeg_mem_dest()), but it is
+also useful for benchmarking, since it reduces the I/O overhead.
+.TP
+.BI \-report
+Report compression progress.
+.TP
+.B \-verbose
+Enable debug printout.  More
+.BR \-v 's
+give more output.  Also, version information is printed at startup.
+.TP
+.B \-debug
+Same as
+.BR \-verbose .
+.TP
+.B \-version
+Print version information and exit.
+.PP
+The
+.B \-restart
+option inserts extra markers that allow a JPEG decoder to resynchronize after
+a transmission error.  Without restart markers, any damage to a compressed
+file will usually ruin the image from the point of the error to the end of the
+image; with restart markers, the damage is usually confined to the portion of
+the image up to the next restart marker.  Of course, the restart markers
+occupy extra space.  We recommend
+.B \-restart 1
+for images that will be transmitted across unreliable networks such as Usenet.
+.PP
+The
+.B \-smooth
+option filters the input to eliminate fine-scale noise.  This is often useful
+when converting dithered images to JPEG: a moderate smoothing factor of 10 to
+50 gets rid of dithering patterns in the input file, resulting in a smaller
+JPEG file and a better-looking image.  Too large a smoothing factor will
+visibly blur the image, however.
+.PP
+Switches for wizards:
+.TP
+.B \-baseline
+Force baseline-compatible quantization tables to be generated.  This clamps
+quantization values to 8 bits even at low quality settings.  (This switch is
+poorly named, since it does not ensure that the output is actually baseline
+JPEG.  For example, you can use
+.B \-baseline
+and
+.B \-progressive
+together.)
+.TP
+.BI \-qtables " file"
+Use the quantization tables given in the specified text file.
+.TP
+.BI \-qslots " N[,...]"
+Select which quantization table to use for each color component.
+.TP
+.BI \-sample " HxV[,...]"
+Set JPEG sampling factors for each color component.
+.TP
+.BI \-scans " file"
+Use the scan script given in the specified text file.
+.PP
+The "wizard" switches are intended for experimentation with JPEG.  If you
+don't know what you are doing, \fBdon't use them\fR.  These switches are
+documented further in the file wizard.txt.
+.SH EXAMPLES
+.LP
+This example compresses the PPM file foo.ppm with a quality factor of
+60 and saves the output as foo.jpg:
+.IP
+.B cjpeg \-quality
+.I 60 foo.ppm
+.B >
+.I foo.jpg
+.SH HINTS
+Color GIF files are not the ideal input for JPEG; JPEG is really intended for
+compressing full-color (24-bit) images.  In particular, don't try to convert
+cartoons, line drawings, and other images that have only a few distinct
+colors.  GIF works great on these, JPEG does not.  If you want to convert a
+GIF to JPEG, you should experiment with
+.BR cjpeg 's
+.B \-quality
+and
+.B \-smooth
+options to get a satisfactory conversion.
+.B \-smooth 10
+or so is often helpful.
+.PP
+Avoid running an image through a series of JPEG compression/decompression
+cycles.  Image quality loss will accumulate; after ten or so cycles the image
+may be noticeably worse than it was after one cycle.  It's best to use a
+lossless format while manipulating an image, then convert to JPEG format when
+you are ready to file the image away.
+.PP
+The
+.B \-optimize
+option to
+.B cjpeg
+is worth using when you are making a "final" version for posting or archiving.
+It's also a win when you are using low quality settings to make very small
+JPEG files; the percentage improvement is often a lot more than it is on
+larger files.  (At present,
+.B \-optimize
+mode is always selected when generating progressive JPEG files.)
+.SH ENVIRONMENT
+.TP
+.B JPEGMEM
+If this environment variable is set, its value is the default memory limit.
+The value is specified as described for the
+.B \-maxmemory
+switch.
+.B JPEGMEM
+overrides the default value specified when the program was compiled, and
+itself is overridden by an explicit
+.BR \-maxmemory .
+.SH SEE ALSO
+.BR djpeg (1),
+.BR jpegtran (1),
+.BR rdjpgcom (1),
+.BR wrjpgcom (1)
+.br
+.BR ppm (5),
+.BR pgm (5)
+.br
+Wallace, Gregory K.  "The JPEG Still Picture Compression Standard",
+Communications of the ACM, April 1991 (vol. 34, no. 4), pp. 30-44.
+.SH AUTHOR
+Independent JPEG Group
+.PP
+This file was modified by The libjpeg-turbo Project to include only information
+relevant to libjpeg-turbo, to wordsmith certain sections, and to describe
+features not present in libjpeg.
+.SH ISSUES
+Not all variants of BMP and Targa file formats are supported.
+.PP
+The
+.B \-targa
+switch is not a bug, it's a feature.  (It would be a bug if the Targa format
+designers had not been clueless.)
diff --git a/3rdparty/libjpeg/src/cjpeg.c b/3rdparty/libjpeg/src/cjpeg.c
new file mode 100644
index 00000000..e5a92112
--- /dev/null
+++ b/3rdparty/libjpeg/src/cjpeg.c
@@ -0,0 +1,693 @@
+/*
+ * cjpeg.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1991-1998, Thomas G. Lane.
+ * Modified 2003-2011 by Guido Vollbeding.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2010, 2013-2014, 2017, 2019-2020, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains a command-line user interface for the JPEG compressor.
+ * It should work on any system with Unix- or MS-DOS-style command lines.
+ *
+ * Two different command line styles are permitted, depending on the
+ * compile-time switch TWO_FILE_COMMANDLINE:
+ *      cjpeg [options]  inputfile outputfile
+ *      cjpeg [options]  [inputfile]
+ * In the second style, output is always to standard output, which you'd
+ * normally redirect to a file or pipe to some other program.  Input is
+ * either from a named file or from standard input (typically redirected).
+ * The second style is convenient on Unix but is unhelpful on systems that
+ * don't support pipes.  Also, you MUST use the first style if your system
+ * doesn't do binary I/O to stdin/stdout.
+ * To simplify script writing, the "-outfile" switch is provided.  The syntax
+ *      cjpeg [options]  -outfile outputfile  inputfile
+ * works regardless of which command line style is used.
+ */
+
+#include "cdjpeg.h"             /* Common decls for cjpeg/djpeg applications */
+#include "jversion.h"           /* for version message */
+#include "jconfigint.h"
+
+#ifndef HAVE_STDLIB_H           /* <stdlib.h> should declare malloc(),free() */
+extern void *malloc(size_t size);
+extern void free(void *ptr);
+#endif
+
+#ifdef USE_CCOMMAND             /* command-line reader for Macintosh */
+#ifdef __MWERKS__
+#include <SIOUX.h>              /* Metrowerks needs this */
+#include <console.h>            /* ... and this */
+#endif
+#ifdef THINK_C
+#include <console.h>            /* Think declares it here */
+#endif
+#endif
+
+
+/* Create the add-on message string table. */
+
+#define JMESSAGE(code, string)  string,
+
+static const char * const cdjpeg_message_table[] = {
+#include "cderror.h"
+  NULL
+};
+
+
+/*
+ * This routine determines what format the input file is,
+ * and selects the appropriate input-reading module.
+ *
+ * To determine which family of input formats the file belongs to,
+ * we may look only at the first byte of the file, since C does not
+ * guarantee that more than one character can be pushed back with ungetc.
+ * Looking at additional bytes would require one of these approaches:
+ *     1) assume we can fseek() the input file (fails for piped input);
+ *     2) assume we can push back more than one character (works in
+ *        some C implementations, but unportable);
+ *     3) provide our own buffering (breaks input readers that want to use
+ *        stdio directly);
+ * or  4) don't put back the data, and modify the input_init methods to assume
+ *        they start reading after the start of file.
+ * #1 is attractive for MS-DOS but is untenable on Unix.
+ *
+ * The most portable solution for file types that can't be identified by their
+ * first byte is to make the user tell us what they are.  This is also the
+ * only approach for "raw" file types that contain only arbitrary values.
+ * We presently apply this method for Targa files.  Most of the time Targa
+ * files start with 0x00, so we recognize that case.  Potentially, however,
+ * a Targa file could start with any byte value (byte 0 is the length of the
+ * seldom-used ID field), so we provide a switch to force Targa input mode.
+ */
+
+static boolean is_targa;        /* records user -targa switch */
+
+
+LOCAL(cjpeg_source_ptr)
+select_file_type(j_compress_ptr cinfo, FILE *infile)
+{
+  int c;
+
+  if (is_targa) {
+#ifdef TARGA_SUPPORTED
+    return jinit_read_targa(cinfo);
+#else
+    ERREXIT(cinfo, JERR_TGA_NOTCOMP);
+#endif
+  }
+
+  if ((c = getc(infile)) == EOF)
+    ERREXIT(cinfo, JERR_INPUT_EMPTY);
+  if (ungetc(c, infile) == EOF)
+    ERREXIT(cinfo, JERR_UNGETC_FAILED);
+
+  switch (c) {
+#ifdef BMP_SUPPORTED
+  case 'B':
+    return jinit_read_bmp(cinfo, TRUE);
+#endif
+#ifdef GIF_SUPPORTED
+  case 'G':
+    return jinit_read_gif(cinfo);
+#endif
+#ifdef PPM_SUPPORTED
+  case 'P':
+    return jinit_read_ppm(cinfo);
+#endif
+#ifdef TARGA_SUPPORTED
+  case 0x00:
+    return jinit_read_targa(cinfo);
+#endif
+  default:
+    ERREXIT(cinfo, JERR_UNKNOWN_FORMAT);
+    break;
+  }
+
+  return NULL;                  /* suppress compiler warnings */
+}
+
+
+/*
+ * Argument-parsing code.
+ * The switch parser is designed to be useful with DOS-style command line
+ * syntax, ie, intermixed switches and file names, where only the switches
+ * to the left of a given file name affect processing of that file.
+ * The main program in this file doesn't actually use this capability...
+ */
+
+
+static const char *progname;    /* program name for error messages */
+static char *icc_filename;      /* for -icc switch */
+static char *outfilename;       /* for -outfile switch */
+boolean memdst;                 /* for -memdst switch */
+boolean report;                 /* for -report switch */
+
+
+LOCAL(void)
+usage(void)
+/* complain about bad command line */
+{
+  fprintf(stderr, "usage: %s [switches] ", progname);
+#ifdef TWO_FILE_COMMANDLINE
+  fprintf(stderr, "inputfile outputfile\n");
+#else
+  fprintf(stderr, "[inputfile]\n");
+#endif
+
+  fprintf(stderr, "Switches (names may be abbreviated):\n");
+  fprintf(stderr, "  -quality N[,...]   Compression quality (0..100; 5-95 is most useful range,\n");
+  fprintf(stderr, "                     default is 75)\n");
+  fprintf(stderr, "  -grayscale     Create monochrome JPEG file\n");
+  fprintf(stderr, "  -rgb           Create RGB JPEG file\n");
+#ifdef ENTROPY_OPT_SUPPORTED
+  fprintf(stderr, "  -optimize      Optimize Huffman table (smaller file, but slow compression)\n");
+#endif
+#ifdef C_PROGRESSIVE_SUPPORTED
+  fprintf(stderr, "  -progressive   Create progressive JPEG file\n");
+#endif
+#ifdef TARGA_SUPPORTED
+  fprintf(stderr, "  -targa         Input file is Targa format (usually not needed)\n");
+#endif
+  fprintf(stderr, "Switches for advanced users:\n");
+#ifdef C_ARITH_CODING_SUPPORTED
+  fprintf(stderr, "  -arithmetic    Use arithmetic coding\n");
+#endif
+#ifdef DCT_ISLOW_SUPPORTED
+  fprintf(stderr, "  -dct int       Use accurate integer DCT method%s\n",
+          (JDCT_DEFAULT == JDCT_ISLOW ? " (default)" : ""));
+#endif
+#ifdef DCT_IFAST_SUPPORTED
+  fprintf(stderr, "  -dct fast      Use less accurate integer DCT method [legacy feature]%s\n",
+          (JDCT_DEFAULT == JDCT_IFAST ? " (default)" : ""));
+#endif
+#ifdef DCT_FLOAT_SUPPORTED
+  fprintf(stderr, "  -dct float     Use floating-point DCT method [legacy feature]%s\n",
+          (JDCT_DEFAULT == JDCT_FLOAT ? " (default)" : ""));
+#endif
+  fprintf(stderr, "  -icc FILE      Embed ICC profile contained in FILE\n");
+  fprintf(stderr, "  -restart N     Set restart interval in rows, or in blocks with B\n");
+#ifdef INPUT_SMOOTHING_SUPPORTED
+  fprintf(stderr, "  -smooth N      Smooth dithered input (N=1..100 is strength)\n");
+#endif
+  fprintf(stderr, "  -maxmemory N   Maximum memory to use (in kbytes)\n");
+  fprintf(stderr, "  -outfile name  Specify name for output file\n");
+#if JPEG_LIB_VERSION >= 80 || defined(MEM_SRCDST_SUPPORTED)
+  fprintf(stderr, "  -memdst        Compress to memory instead of file (useful for benchmarking)\n");
+#endif
+  fprintf(stderr, "  -report        Report compression progress\n");
+  fprintf(stderr, "  -verbose  or  -debug   Emit debug output\n");
+  fprintf(stderr, "  -version       Print version information and exit\n");
+  fprintf(stderr, "Switches for wizards:\n");
+  fprintf(stderr, "  -baseline      Force baseline quantization tables\n");
+  fprintf(stderr, "  -qtables FILE  Use quantization tables given in FILE\n");
+  fprintf(stderr, "  -qslots N[,...]    Set component quantization tables\n");
+  fprintf(stderr, "  -sample HxV[,...]  Set component sampling factors\n");
+#ifdef C_MULTISCAN_FILES_SUPPORTED
+  fprintf(stderr, "  -scans FILE    Create multi-scan JPEG per script FILE\n");
+#endif
+  exit(EXIT_FAILURE);
+}
+
+
+LOCAL(int)
+parse_switches(j_compress_ptr cinfo, int argc, char **argv,
+               int last_file_arg_seen, boolean for_real)
+/* Parse optional switches.
+ * Returns argv[] index of first file-name argument (== argc if none).
+ * Any file names with indexes <= last_file_arg_seen are ignored;
+ * they have presumably been processed in a previous iteration.
+ * (Pass 0 for last_file_arg_seen on the first or only iteration.)
+ * for_real is FALSE on the first (dummy) pass; we may skip any expensive
+ * processing.
+ */
+{
+  int argn;
+  char *arg;
+  boolean force_baseline;
+  boolean simple_progressive;
+  char *qualityarg = NULL;      /* saves -quality parm if any */
+  char *qtablefile = NULL;      /* saves -qtables filename if any */
+  char *qslotsarg = NULL;       /* saves -qslots parm if any */
+  char *samplearg = NULL;       /* saves -sample parm if any */
+  char *scansarg = NULL;        /* saves -scans parm if any */
+
+  /* Set up default JPEG parameters. */
+
+  force_baseline = FALSE;       /* by default, allow 16-bit quantizers */
+  simple_progressive = FALSE;
+  is_targa = FALSE;
+  icc_filename = NULL;
+  outfilename = NULL;
+  memdst = FALSE;
+  report = FALSE;
+  cinfo->err->trace_level = 0;
+
+  /* Scan command line options, adjust parameters */
+
+  for (argn = 1; argn < argc; argn++) {
+    arg = argv[argn];
+    if (*arg != '-') {
+      /* Not a switch, must be a file name argument */
+      if (argn <= last_file_arg_seen) {
+        outfilename = NULL;     /* -outfile applies to just one input file */
+        continue;               /* ignore this name if previously processed */
+      }
+      break;                    /* else done parsing switches */
+    }
+    arg++;                      /* advance past switch marker character */
+
+    if (keymatch(arg, "arithmetic", 1)) {
+      /* Use arithmetic coding. */
+#ifdef C_ARITH_CODING_SUPPORTED
+      cinfo->arith_code = TRUE;
+#else
+      fprintf(stderr, "%s: sorry, arithmetic coding not supported\n",
+              progname);
+      exit(EXIT_FAILURE);
+#endif
+
+    } else if (keymatch(arg, "baseline", 1)) {
+      /* Force baseline-compatible output (8-bit quantizer values). */
+      force_baseline = TRUE;
+
+    } else if (keymatch(arg, "dct", 2)) {
+      /* Select DCT algorithm. */
+      if (++argn >= argc)       /* advance to next argument */
+        usage();
+      if (keymatch(argv[argn], "int", 1)) {
+        cinfo->dct_method = JDCT_ISLOW;
+      } else if (keymatch(argv[argn], "fast", 2)) {
+        cinfo->dct_method = JDCT_IFAST;
+      } else if (keymatch(argv[argn], "float", 2)) {
+        cinfo->dct_method = JDCT_FLOAT;
+      } else
+        usage();
+
+    } else if (keymatch(arg, "debug", 1) || keymatch(arg, "verbose", 1)) {
+      /* Enable debug printouts. */
+      /* On first -d, print version identification */
+      static boolean printed_version = FALSE;
+
+      if (!printed_version) {
+        fprintf(stderr, "%s version %s (build %s)\n",
+                PACKAGE_NAME, VERSION, BUILD);
+        fprintf(stderr, "%s\n\n", JCOPYRIGHT);
+        fprintf(stderr, "Emulating The Independent JPEG Group's software, version %s\n\n",
+                JVERSION);
+        printed_version = TRUE;
+      }
+      cinfo->err->trace_level++;
+
+    } else if (keymatch(arg, "version", 4)) {
+      fprintf(stderr, "%s version %s (build %s)\n",
+              PACKAGE_NAME, VERSION, BUILD);
+      exit(EXIT_SUCCESS);
+
+    } else if (keymatch(arg, "grayscale", 2) ||
+               keymatch(arg, "greyscale", 2)) {
+      /* Force a monochrome JPEG file to be generated. */
+      jpeg_set_colorspace(cinfo, JCS_GRAYSCALE);
+
+    } else if (keymatch(arg, "rgb", 3)) {
+      /* Force an RGB JPEG file to be generated. */
+      jpeg_set_colorspace(cinfo, JCS_RGB);
+
+    } else if (keymatch(arg, "icc", 1)) {
+      /* Set ICC filename. */
+      if (++argn >= argc)       /* advance to next argument */
+        usage();
+      icc_filename = argv[argn];
+
+    } else if (keymatch(arg, "maxmemory", 3)) {
+      /* Maximum memory in Kb (or Mb with 'm'). */
+      long lval;
+      char ch = 'x';
+
+      if (++argn >= argc)       /* advance to next argument */
+        usage();
+      if (sscanf(argv[argn], "%ld%c", &lval, &ch) < 1)
+        usage();
+      if (ch == 'm' || ch == 'M')
+        lval *= 1000L;
+      cinfo->mem->max_memory_to_use = lval * 1000L;
+
+    } else if (keymatch(arg, "optimize", 1) || keymatch(arg, "optimise", 1)) {
+      /* Enable entropy parm optimization. */
+#ifdef ENTROPY_OPT_SUPPORTED
+      cinfo->optimize_coding = TRUE;
+#else
+      fprintf(stderr, "%s: sorry, entropy optimization was not compiled in\n",
+              progname);
+      exit(EXIT_FAILURE);
+#endif
+
+    } else if (keymatch(arg, "outfile", 4)) {
+      /* Set output file name. */
+      if (++argn >= argc)       /* advance to next argument */
+        usage();
+      outfilename = argv[argn]; /* save it away for later use */
+
+    } else if (keymatch(arg, "progressive", 1)) {
+      /* Select simple progressive mode. */
+#ifdef C_PROGRESSIVE_SUPPORTED
+      simple_progressive = TRUE;
+      /* We must postpone execution until num_components is known. */
+#else
+      fprintf(stderr, "%s: sorry, progressive output was not compiled in\n",
+              progname);
+      exit(EXIT_FAILURE);
+#endif
+
+    } else if (keymatch(arg, "memdst", 2)) {
+      /* Use in-memory destination manager */
+#if JPEG_LIB_VERSION >= 80 || defined(MEM_SRCDST_SUPPORTED)
+      memdst = TRUE;
+#else
+      fprintf(stderr, "%s: sorry, in-memory destination manager was not compiled in\n",
+              progname);
+      exit(EXIT_FAILURE);
+#endif
+
+    } else if (keymatch(arg, "quality", 1)) {
+      /* Quality ratings (quantization table scaling factors). */
+      if (++argn >= argc)       /* advance to next argument */
+        usage();
+      qualityarg = argv[argn];
+
+    } else if (keymatch(arg, "qslots", 2)) {
+      /* Quantization table slot numbers. */
+      if (++argn >= argc)       /* advance to next argument */
+        usage();
+      qslotsarg = argv[argn];
+      /* Must delay setting qslots until after we have processed any
+       * colorspace-determining switches, since jpeg_set_colorspace sets
+       * default quant table numbers.
+       */
+
+    } else if (keymatch(arg, "qtables", 2)) {
+      /* Quantization tables fetched from file. */
+      if (++argn >= argc)       /* advance to next argument */
+        usage();
+      qtablefile = argv[argn];
+      /* We postpone actually reading the file in case -quality comes later. */
+
+    } else if (keymatch(arg, "report", 3)) {
+      report = TRUE;
+
+    } else if (keymatch(arg, "restart", 1)) {
+      /* Restart interval in MCU rows (or in MCUs with 'b'). */
+      long lval;
+      char ch = 'x';
+
+      if (++argn >= argc)       /* advance to next argument */
+        usage();
+      if (sscanf(argv[argn], "%ld%c", &lval, &ch) < 1)
+        usage();
+      if (lval < 0 || lval > 65535L)
+        usage();
+      if (ch == 'b' || ch == 'B') {
+        cinfo->restart_interval = (unsigned int)lval;
+        cinfo->restart_in_rows = 0; /* else prior '-restart n' overrides me */
+      } else {
+        cinfo->restart_in_rows = (int)lval;
+        /* restart_interval will be computed during startup */
+      }
+
+    } else if (keymatch(arg, "sample", 2)) {
+      /* Set sampling factors. */
+      if (++argn >= argc)       /* advance to next argument */
+        usage();
+      samplearg = argv[argn];
+      /* Must delay setting sample factors until after we have processed any
+       * colorspace-determining switches, since jpeg_set_colorspace sets
+       * default sampling factors.
+       */
+
+    } else if (keymatch(arg, "scans", 4)) {
+      /* Set scan script. */
+#ifdef C_MULTISCAN_FILES_SUPPORTED
+      if (++argn >= argc)       /* advance to next argument */
+        usage();
+      scansarg = argv[argn];
+      /* We must postpone reading the file in case -progressive appears. */
+#else
+      fprintf(stderr, "%s: sorry, multi-scan output was not compiled in\n",
+              progname);
+      exit(EXIT_FAILURE);
+#endif
+
+    } else if (keymatch(arg, "smooth", 2)) {
+      /* Set input smoothing factor. */
+      int val;
+
+      if (++argn >= argc)       /* advance to next argument */
+        usage();
+      if (sscanf(argv[argn], "%d", &val) != 1)
+        usage();
+      if (val < 0 || val > 100)
+        usage();
+      cinfo->smoothing_factor = val;
+
+    } else if (keymatch(arg, "targa", 1)) {
+      /* Input file is Targa format. */
+      is_targa = TRUE;
+
+    } else {
+      usage();                  /* bogus switch */
+    }
+  }
+
+  /* Post-switch-scanning cleanup */
+
+  if (for_real) {
+
+    /* Set quantization tables for selected quality. */
+    /* Some or all may be overridden if -qtables is present. */
+    if (qualityarg != NULL)     /* process -quality if it was present */
+      if (!set_quality_ratings(cinfo, qualityarg, force_baseline))
+        usage();
+
+    if (qtablefile != NULL)     /* process -qtables if it was present */
+      if (!read_quant_tables(cinfo, qtablefile, force_baseline))
+        usage();
+
+    if (qslotsarg != NULL)      /* process -qslots if it was present */
+      if (!set_quant_slots(cinfo, qslotsarg))
+        usage();
+
+    if (samplearg != NULL)      /* process -sample if it was present */
+      if (!set_sample_factors(cinfo, samplearg))
+        usage();
+
+#ifdef C_PROGRESSIVE_SUPPORTED
+    if (simple_progressive)     /* process -progressive; -scans can override */
+      jpeg_simple_progression(cinfo);
+#endif
+
+#ifdef C_MULTISCAN_FILES_SUPPORTED
+    if (scansarg != NULL)       /* process -scans if it was present */
+      if (!read_scan_script(cinfo, scansarg))
+        usage();
+#endif
+  }
+
+  return argn;                  /* return index of next arg (file name) */
+}
+
+
+/*
+ * The main program.
+ */
+
+int
+main(int argc, char **argv)
+{
+  struct jpeg_compress_struct cinfo;
+  struct jpeg_error_mgr jerr;
+  struct cdjpeg_progress_mgr progress;
+  int file_index;
+  cjpeg_source_ptr src_mgr;
+  FILE *input_file;
+  FILE *icc_file;
+  JOCTET *icc_profile = NULL;
+  long icc_len = 0;
+  FILE *output_file = NULL;
+  unsigned char *outbuffer = NULL;
+  unsigned long outsize = 0;
+  JDIMENSION num_scanlines;
+
+  /* On Mac, fetch a command line. */
+#ifdef USE_CCOMMAND
+  argc = ccommand(&argv);
+#endif
+
+  progname = argv[0];
+  if (progname == NULL || progname[0] == 0)
+    progname = "cjpeg";         /* in case C library doesn't provide it */
+
+  /* Initialize the JPEG compression object with default error handling. */
+  cinfo.err = jpeg_std_error(&jerr);
+  jpeg_create_compress(&cinfo);
+  /* Add some application-specific error messages (from cderror.h) */
+  jerr.addon_message_table = cdjpeg_message_table;
+  jerr.first_addon_message = JMSG_FIRSTADDONCODE;
+  jerr.last_addon_message = JMSG_LASTADDONCODE;
+
+  /* Initialize JPEG parameters.
+   * Much of this may be overridden later.
+   * In particular, we don't yet know the input file's color space,
+   * but we need to provide some value for jpeg_set_defaults() to work.
+   */
+
+  cinfo.in_color_space = JCS_RGB; /* arbitrary guess */
+  jpeg_set_defaults(&cinfo);
+
+  /* Scan command line to find file names.
+   * It is convenient to use just one switch-parsing routine, but the switch
+   * values read here are ignored; we will rescan the switches after opening
+   * the input file.
+   */
+
+  file_index = parse_switches(&cinfo, argc, argv, 0, FALSE);
+
+#ifdef TWO_FILE_COMMANDLINE
+  if (!memdst) {
+    /* Must have either -outfile switch or explicit output file name */
+    if (outfilename == NULL) {
+      if (file_index != argc - 2) {
+        fprintf(stderr, "%s: must name one input and one output file\n",
+                progname);
+        usage();
+      }
+      outfilename = argv[file_index + 1];
+    } else {
+      if (file_index != argc - 1) {
+        fprintf(stderr, "%s: must name one input and one output file\n",
+                progname);
+        usage();
+      }
+    }
+  }
+#else
+  /* Unix style: expect zero or one file name */
+  if (file_index < argc - 1) {
+    fprintf(stderr, "%s: only one input file\n", progname);
+    usage();
+  }
+#endif /* TWO_FILE_COMMANDLINE */
+
+  /* Open the input file. */
+  if (file_index < argc) {
+    if ((input_file = fopen(argv[file_index], READ_BINARY)) == NULL) {
+      fprintf(stderr, "%s: can't open %s\n", progname, argv[file_index]);
+      exit(EXIT_FAILURE);
+    }
+  } else {
+    /* default input file is stdin */
+    input_file = read_stdin();
+  }
+
+  /* Open the output file. */
+  if (outfilename != NULL) {
+    if ((output_file = fopen(outfilename, WRITE_BINARY)) == NULL) {
+      fprintf(stderr, "%s: can't open %s\n", progname, outfilename);
+      exit(EXIT_FAILURE);
+    }
+  } else if (!memdst) {
+    /* default output file is stdout */
+    output_file = write_stdout();
+  }
+
+  if (icc_filename != NULL) {
+    if ((icc_file = fopen(icc_filename, READ_BINARY)) == NULL) {
+      fprintf(stderr, "%s: can't open %s\n", progname, icc_filename);
+      exit(EXIT_FAILURE);
+    }
+    if (fseek(icc_file, 0, SEEK_END) < 0 ||
+        (icc_len = ftell(icc_file)) < 1 ||
+        fseek(icc_file, 0, SEEK_SET) < 0) {
+      fprintf(stderr, "%s: can't determine size of %s\n", progname,
+              icc_filename);
+      exit(EXIT_FAILURE);
+    }
+    if ((icc_profile = (JOCTET *)malloc(icc_len)) == NULL) {
+      fprintf(stderr, "%s: can't allocate memory for ICC profile\n", progname);
+      fclose(icc_file);
+      exit(EXIT_FAILURE);
+    }
+    if (fread(icc_profile, icc_len, 1, icc_file) < 1) {
+      fprintf(stderr, "%s: can't read ICC profile from %s\n", progname,
+              icc_filename);
+      free(icc_profile);
+      fclose(icc_file);
+      exit(EXIT_FAILURE);
+    }
+    fclose(icc_file);
+  }
+
+  if (report) {
+    start_progress_monitor((j_common_ptr)&cinfo, &progress);
+    progress.report = report;
+  }
+
+  /* Figure out the input file format, and set up to read it. */
+  src_mgr = select_file_type(&cinfo, input_file);
+  src_mgr->input_file = input_file;
+
+  /* Read the input file header to obtain file size & colorspace. */
+  (*src_mgr->start_input) (&cinfo, src_mgr);
+
+  /* Now that we know input colorspace, fix colorspace-dependent defaults */
+  jpeg_default_colorspace(&cinfo);
+
+  /* Adjust default compression parameters by re-parsing the options */
+  file_index = parse_switches(&cinfo, argc, argv, 0, TRUE);
+
+  /* Specify data destination for compression */
+#if JPEG_LIB_VERSION >= 80 || defined(MEM_SRCDST_SUPPORTED)
+  if (memdst)
+    jpeg_mem_dest(&cinfo, &outbuffer, &outsize);
+  else
+#endif
+    jpeg_stdio_dest(&cinfo, output_file);
+
+  /* Start compressor */
+  jpeg_start_compress(&cinfo, TRUE);
+
+  if (icc_profile != NULL)
+    jpeg_write_icc_profile(&cinfo, icc_profile, (unsigned int)icc_len);
+
+  /* Process data */
+  while (cinfo.next_scanline < cinfo.image_height) {
+    num_scanlines = (*src_mgr->get_pixel_rows) (&cinfo, src_mgr);
+    (void)jpeg_write_scanlines(&cinfo, src_mgr->buffer, num_scanlines);
+  }
+
+  /* Finish compression and release memory */
+  (*src_mgr->finish_input) (&cinfo, src_mgr);
+  jpeg_finish_compress(&cinfo);
+  jpeg_destroy_compress(&cinfo);
+
+  /* Close files, if we opened them */
+  if (input_file != stdin)
+    fclose(input_file);
+  if (output_file != stdout && output_file != NULL)
+    fclose(output_file);
+
+  if (report)
+    end_progress_monitor((j_common_ptr)&cinfo);
+
+  if (memdst) {
+    fprintf(stderr, "Compressed size:  %lu bytes\n", outsize);
+    free(outbuffer);
+  }
+
+  free(icc_profile);
+
+  /* All done. */
+  exit(jerr.num_warnings ? EXIT_WARNING : EXIT_SUCCESS);
+  return 0;                     /* suppress no-return-value warnings */
+}
diff --git a/3rdparty/libjpeg/src/cmakescripts/BuildPackages.cmake b/3rdparty/libjpeg/src/cmakescripts/BuildPackages.cmake
new file mode 100644
index 00000000..0c7ed11c
--- /dev/null
+++ b/3rdparty/libjpeg/src/cmakescripts/BuildPackages.cmake
@@ -0,0 +1,181 @@
+# This file is included from the top-level CMakeLists.txt.  We just store it
+# here to avoid cluttering up that file.
+
+set(PKGNAME ${CMAKE_PROJECT_NAME} CACHE STRING
+  "Distribution package name (default: ${CMAKE_PROJECT_NAME})")
+set(PKGVENDOR "The ${CMAKE_PROJECT_NAME} Project" CACHE STRING
+  "Vendor name to be included in distribution package descriptions (default: The ${CMAKE_PROJECT_NAME} Project)")
+set(PKGURL "http://www.${CMAKE_PROJECT_NAME}.org" CACHE STRING
+  "URL of project web site to be included in distribution package descriptions (default: http://www.${CMAKE_PROJECT_NAME}.org)")
+set(PKGEMAIL "information@${CMAKE_PROJECT_NAME}.org" CACHE STRING
+  "E-mail of project maintainer to be included in distribution package descriptions (default: information@${CMAKE_PROJECT_NAME}.org")
+set(PKGID "com.${CMAKE_PROJECT_NAME}.${PKGNAME}" CACHE STRING
+  "Globally unique package identifier (reverse DNS notation) (default: com.${CMAKE_PROJECT_NAME}.${PKGNAME})")
+
+
+###############################################################################
+# Linux RPM and DEB
+###############################################################################
+
+if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
+
+set(RPMARCH ${CMAKE_SYSTEM_PROCESSOR})
+if(CPU_TYPE STREQUAL "x86_64")
+  set(DEBARCH amd64)
+elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "armv7*")
+  set(RPMARCH armv7hl)
+  set(DEBARCH armhf)
+elseif(CPU_TYPE STREQUAL "arm64")
+  set(DEBARCH ${CPU_TYPE})
+elseif(CPU_TYPE STREQUAL "arm")
+  if(CMAKE_C_COMPILER MATCHES "gnueabihf")
+    set(RPMARCH armv7hl)
+    set(DEBARCH armhf)
+  else()
+    set(RPMARCH armel)
+    set(DEBARCH armel)
+  endif()
+elseif(CMAKE_SYSTEM_PROCESSOR_LC STREQUAL "ppc64le")
+  set(DEBARCH ppc64el)
+elseif(CPU_TYPE STREQUAL "powerpc" AND BITS EQUAL 32)
+  set(RPMARCH ppc)
+  set(DEBARCH ppc)
+else()
+  set(DEBARCH ${CMAKE_SYSTEM_PROCESSOR})
+endif()
+message(STATUS "RPM architecture = ${RPMARCH}, DEB architecture = ${DEBARCH}")
+
+# Re-set CMAKE_POSITION_INDEPENDENT_CODE so that the RPM spec file works
+# properly
+boolean_number(CMAKE_POSITION_INDEPENDENT_CODE)
+
+configure_file(release/makerpm.in pkgscripts/makerpm)
+configure_file(release/rpm.spec.in pkgscripts/rpm.spec @ONLY)
+
+add_custom_target(rpm pkgscripts/makerpm
+  SOURCES pkgscripts/makerpm)
+
+configure_file(release/makesrpm.in pkgscripts/makesrpm)
+
+add_custom_target(srpm pkgscripts/makesrpm
+  SOURCES pkgscripts/makesrpm
+  DEPENDS dist)
+
+configure_file(release/makedpkg.in pkgscripts/makedpkg)
+configure_file(release/deb-control.in pkgscripts/deb-control)
+
+add_custom_target(deb pkgscripts/makedpkg
+  SOURCES pkgscripts/makedpkg)
+
+endif() # Linux
+
+
+###############################################################################
+# Windows installer (NullSoft Installer)
+###############################################################################
+
+if(WIN32)
+
+if(MSVC)
+  set(INST_PLATFORM "Visual C++")
+  set(INST_ID vc)
+  set(INST_NAME ${CMAKE_PROJECT_NAME}-${VERSION}-${INST_ID})
+  set(INST_REG_NAME ${CMAKE_PROJECT_NAME})
+elseif(MINGW)
+  set(INST_PLATFORM GCC)
+  set(INST_ID gcc)
+  set(INST_NAME ${CMAKE_PROJECT_NAME}-${VERSION}-${INST_ID})
+  set(INST_REG_NAME ${CMAKE_PROJECT_NAME}-${INST_ID})
+  set(INST_DEFS -DGCC)
+endif()
+
+if(BITS EQUAL 64)
+  set(INST_PLATFORM "${INST_PLATFORM} 64-bit")
+  set(INST_NAME ${INST_NAME}64)
+  set(INST_REG_NAME ${INST_REG_NAME}64)
+  set(INST_DEFS ${INST_DEFS} -DWIN64)
+endif()
+
+if(WITH_JAVA)
+  set(INST_DEFS ${INST_DEFS} -DJAVA)
+endif()
+
+if(MSVC_IDE)
+  set(INST_DEFS ${INST_DEFS} "-DBUILDDIR=${CMAKE_CFG_INTDIR}\\")
+else()
+  set(INST_DEFS ${INST_DEFS} "-DBUILDDIR=")
+endif()
+
+string(REGEX REPLACE "/" "\\\\" INST_DIR ${CMAKE_INSTALL_PREFIX})
+
+configure_file(release/installer.nsi.in installer.nsi @ONLY)
+# TODO: It would be nice to eventually switch to CPack and eliminate this mess,
+# but not today.
+configure_file(win/projectTargets.cmake.in
+  win/${CMAKE_PROJECT_NAME}Targets.cmake @ONLY)
+configure_file(win/${INST_ID}/projectTargets-release.cmake.in
+  win/${CMAKE_PROJECT_NAME}Targets-release.cmake @ONLY)
+
+if(WITH_JAVA)
+  set(JAVA_DEPEND turbojpeg-java)
+endif()
+add_custom_target(installer
+  makensis -nocd ${INST_DEFS} installer.nsi
+  DEPENDS jpeg jpeg-static turbojpeg turbojpeg-static rdjpgcom wrjpgcom
+    cjpeg djpeg jpegtran tjbench ${JAVA_DEPEND}
+  SOURCES installer.nsi)
+
+endif() # WIN32
+
+
+###############################################################################
+# Mac DMG
+###############################################################################
+
+if(APPLE)
+
+set(ARMV8_BUILD "" CACHE PATH
+  "Directory containing Armv8 iOS or macOS build to include in universal binaries")
+
+set(MACOS_APP_CERT_NAME "" CACHE STRING
+  "Name of the Developer ID Application certificate (in the macOS keychain) that should be used to sign the libjpeg-turbo DMG.  Leave this blank to generate an unsigned DMG.")
+set(MACOS_INST_CERT_NAME "" CACHE STRING
+  "Name of the Developer ID Installer certificate (in the macOS keychain) that should be used to sign the libjpeg-turbo installer package.  Leave this blank to generate an unsigned package.")
+
+configure_file(release/makemacpkg.in pkgscripts/makemacpkg)
+configure_file(release/Distribution.xml.in pkgscripts/Distribution.xml)
+configure_file(release/Welcome.rtf.in pkgscripts/Welcome.rtf)
+configure_file(release/uninstall.in pkgscripts/uninstall)
+
+add_custom_target(dmg pkgscripts/makemacpkg
+  SOURCES pkgscripts/makemacpkg)
+
+endif() # APPLE
+
+
+###############################################################################
+# Generic
+###############################################################################
+
+add_custom_target(dist
+  COMMAND git archive --prefix=${CMAKE_PROJECT_NAME}-${VERSION}/ HEAD |
+    gzip > ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_PROJECT_NAME}-${VERSION}.tar.gz
+    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
+
+configure_file(release/maketarball.in pkgscripts/maketarball)
+
+add_custom_target(tarball pkgscripts/maketarball
+  SOURCES pkgscripts/maketarball)
+
+configure_file(release/libjpeg.pc.in pkgscripts/libjpeg.pc @ONLY)
+
+configure_file(release/libturbojpeg.pc.in pkgscripts/libturbojpeg.pc @ONLY)
+
+include(CMakePackageConfigHelpers)
+write_basic_package_version_file(
+  pkgscripts/${CMAKE_PROJECT_NAME}ConfigVersion.cmake
+  VERSION ${VERSION} COMPATIBILITY AnyNewerVersion)
+
+configure_package_config_file(release/Config.cmake.in
+  pkgscripts/${CMAKE_PROJECT_NAME}Config.cmake
+  INSTALL_DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/${CMAKE_PROJECT_NAME})
diff --git a/3rdparty/libjpeg/src/cmakescripts/GNUInstallDirs.cmake b/3rdparty/libjpeg/src/cmakescripts/GNUInstallDirs.cmake
new file mode 100644
index 00000000..6408fca7
--- /dev/null
+++ b/3rdparty/libjpeg/src/cmakescripts/GNUInstallDirs.cmake
@@ -0,0 +1,419 @@
+#.rst:
+# GNUInstallDirs
+# --------------
+#
+# Define GNU standard installation directories
+#
+# Provides install directory variables as defined by the
+# `GNU Coding Standards`_.
+#
+# .. _`GNU Coding Standards`: https://www.gnu.org/prep/standards/html_node/Directory-Variables.html
+#
+# Result Variables
+# ^^^^^^^^^^^^^^^^
+#
+# Inclusion of this module defines the following variables:
+#
+# ``CMAKE_INSTALL_<dir>``
+#
+#   Destination for files of a given type.  This value may be passed to
+#   the ``DESTINATION`` options of :command:`install` commands for the
+#   corresponding file type.
+#
+# ``CMAKE_INSTALL_FULL_<dir>``
+#
+#   The absolute path generated from the corresponding ``CMAKE_INSTALL_<dir>``
+#   value.  If the value is not already an absolute path, an absolute path
+#   is constructed typically by prepending the value of the
+#   :variable:`CMAKE_INSTALL_PREFIX` variable.  However, there are some
+#   `special cases`_ as documented below.
+#
+# where ``<dir>`` is one of:
+#
+# ``BINDIR``
+#   user executables (``bin``)
+# ``SBINDIR``
+#   system admin executables (``sbin``)
+# ``LIBEXECDIR``
+#   program executables (``libexec``)
+# ``SYSCONFDIR``
+#   read-only single-machine data (``etc``)
+# ``SHAREDSTATEDIR``
+#   modifiable architecture-independent data (``com``)
+# ``LOCALSTATEDIR``
+#   modifiable single-machine data (``var``)
+# ``LIBDIR``
+#   object code libraries (``lib`` or ``lib64``
+#   or ``lib/<multiarch-tuple>`` on Debian)
+# ``INCLUDEDIR``
+#   C header files (``include``)
+# ``OLDINCLUDEDIR``
+#   C header files for non-gcc (``/usr/include``)
+# ``DATAROOTDIR``
+#   read-only architecture-independent data root (``share``)
+# ``DATADIR``
+#   read-only architecture-independent data (``DATAROOTDIR``)
+# ``INFODIR``
+#   info documentation (``DATAROOTDIR/info``)
+# ``LOCALEDIR``
+#   locale-dependent data (``DATAROOTDIR/locale``)
+# ``MANDIR``
+#   man documentation (``DATAROOTDIR/man``)
+# ``DOCDIR``
+#   documentation root (``DATAROOTDIR/doc/PROJECT_NAME``)
+#
+# If the includer does not define a value the above-shown default will be
+# used and the value will appear in the cache for editing by the user.
+#
+# Special Cases
+# ^^^^^^^^^^^^^
+#
+# The following values of :variable:`CMAKE_INSTALL_PREFIX` are special:
+#
+# ``/``
+#
+#   For ``<dir>`` other than the ``SYSCONFDIR`` and ``LOCALSTATEDIR``,
+#   the value of ``CMAKE_INSTALL_<dir>`` is prefixed with ``usr/`` if
+#   it is not user-specified as an absolute path.  For example, the
+#   ``INCLUDEDIR`` value ``include`` becomes ``usr/include``.
+#   This is required by the `GNU Coding Standards`_, which state:
+#
+#     When building the complete GNU system, the prefix will be empty
+#     and ``/usr`` will be a symbolic link to ``/``.
+#
+# ``/usr``
+#
+#   For ``<dir>`` equal to ``SYSCONFDIR`` or ``LOCALSTATEDIR``, the
+#   ``CMAKE_INSTALL_FULL_<dir>`` is computed by prepending just ``/``
+#   to the value of ``CMAKE_INSTALL_<dir>`` if it is not user-specified
+#   as an absolute path.  For example, the ``SYSCONFDIR`` value ``etc``
+#   becomes ``/etc``.  This is required by the `GNU Coding Standards`_.
+#
+# ``/opt/...``
+#
+#   For ``<dir>`` equal to ``SYSCONFDIR`` or ``LOCALSTATEDIR``, the
+#   ``CMAKE_INSTALL_FULL_<dir>`` is computed by *appending* the prefix
+#   to the value of ``CMAKE_INSTALL_<dir>`` if it is not user-specified
+#   as an absolute path.  For example, the ``SYSCONFDIR`` value ``etc``
+#   becomes ``/etc/opt/...``.  This is defined by the
+#   `Filesystem Hierarchy Standard`_.
+#
+# .. _`Filesystem Hierarchy Standard`: https://refspecs.linuxfoundation.org/FHS_3.0/fhs/index.html
+#
+# Macros
+# ^^^^^^
+#
+# .. command:: GNUInstallDirs_get_absolute_install_dir
+#
+#   ::
+#
+#     GNUInstallDirs_get_absolute_install_dir(absvar var)
+#
+#   Set the given variable ``absvar`` to the absolute path contained
+#   within the variable ``var``.  This is to allow the computation of an
+#   absolute path, accounting for all the special cases documented
+#   above.  While this macro is used to compute the various
+#   ``CMAKE_INSTALL_FULL_<dir>`` variables, it is exposed publicly to
+#   allow users who create additional path variables to also compute
+#   absolute paths where necessary, using the same logic.
+
+#=============================================================================
+# Copyright 2018 Matthias Räncker
+# Copyright 2016, 2019 D. R. Commander
+# Copyright 2016 Dmitry Marakasov
+# Copyright 2016 Roger Leigh
+# Copyright 2015 Alex Turbov
+# Copyright 2014 Rolf Eike Beer
+# Copyright 2014 Daniele E. Domenichelli
+# Copyright 2013 Dimitri John Ledkov
+# Copyright 2011 Alex Neundorf
+# Copyright 2011 Eric NOULARD
+# Copyright 2011, 2013-2015 Kitware, Inc.
+# Copyright 2011 Nikita Krupen'ko
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#
+# * Redistributions of source code must retain the above copyright
+#   notice, this list of conditions and the following disclaimer.
+#
+# * Redistributions in binary form must reproduce the above copyright
+#   notice, this list of conditions and the following disclaimer in the
+#   documentation and/or other materials provided with the distribution.
+#
+# * Neither the names of Kitware, Inc., the Insight Software Consortium,
+#   nor the names of their contributors may be used to endorse or promote
+#   products derived from this software without specific prior written
+#   permission.
+#
+# 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.
+#=============================================================================
+
+# Installation directories
+#
+
+macro(GNUInstallDirs_set_install_dir var docstring)
+  # If CMAKE_INSTALL_PREFIX changes and CMAKE_INSTALL_*DIR is still set to the
+  # default value, then modify it accordingly.  This presumes that the default
+  # value may change based on the prefix.
+
+  set(_GNUInstallDirs_CMAKE_INSTALL_FORCE_${var} "")
+  if(NOT DEFINED CMAKE_INSTALL_${var})
+    set(_GNUInstallDirs_CMAKE_INSTALL_DEFAULT_${var} 1 CACHE INTERNAL
+      "CMAKE_INSTALL_${var} has default value")
+  elseif(DEFINED _GNUInstallDirs_CMAKE_INSTALL_LAST_DEFAULT_${var} AND
+    NOT "${_GNUInstallDirs_CMAKE_INSTALL_LAST_DEFAULT_${var}}" STREQUAL
+      "${CMAKE_INSTALL_DEFAULT_${var}}" AND
+    _GNUInstallDirs_CMAKE_INSTALL_DEFAULT_${var} AND
+    "${_GNUInstallDirs_CMAKE_INSTALL_LAST_${var}}" STREQUAL
+      "${CMAKE_INSTALL_${var}}")
+    set(_GNUInstallDirs_CMAKE_INSTALL_FORCE_${var} "FORCE")
+  endif()
+
+  set(CMAKE_INSTALL_${var} "${CMAKE_INSTALL_DEFAULT_${var}}" CACHE PATH
+    "${docstring} (Default: ${CMAKE_INSTALL_DEFAULT_${var}})"
+    ${_GNUInstallDirs_CMAKE_INSTALL_FORCE_${var}})
+
+  if(NOT CMAKE_INSTALL_${var} STREQUAL CMAKE_INSTALL_DEFAULT_${var})
+    unset(_GNUInstallDirs_CMAKE_INSTALL_DEFAULT_${var} CACHE)
+  endif()
+
+  # Save for next run
+  set(_GNUInstallDirs_CMAKE_INSTALL_LAST_${var} "${CMAKE_INSTALL_${var}}"
+    CACHE INTERNAL "CMAKE_INSTALL_${var} during last run")
+  set(_GNUInstallDirs_CMAKE_INSTALL_LAST_DEFAULT_${var}
+    "${CMAKE_INSTALL_DEFAULT_${var}}" CACHE INTERNAL
+    "CMAKE_INSTALL_DEFAULT_${var} during last run")
+endmacro()
+
+if(NOT DEFINED CMAKE_INSTALL_DEFAULT_BINDIR)
+  set(CMAKE_INSTALL_DEFAULT_BINDIR "bin")
+endif()
+GNUInstallDirs_set_install_dir(BINDIR
+  "Directory into which user executables should be installed")
+
+if(NOT DEFINED CMAKE_INSTALL_DEFAULT_SBINDIR)
+  set(CMAKE_INSTALL_DEFAULT_SBINDIR "sbin")
+endif()
+GNUInstallDirs_set_install_dir(SBINDIR
+  "Directory into which system admin executables should be installed")
+
+if(NOT DEFINED CMAKE_INSTALL_DEFAULT_LIBEXECDIR)
+  set(CMAKE_INSTALL_DEFAULT_LIBEXECDIR "libexec")
+endif()
+GNUInstallDirs_set_install_dir(LIBEXECDIR
+  "Directory under which executables run by other programs should be installed")
+
+if(NOT DEFINED CMAKE_INSTALL_DEFAULT_SYSCONFDIR)
+  set(CMAKE_INSTALL_DEFAULT_SYSCONFDIR "etc")
+endif()
+GNUInstallDirs_set_install_dir(SYSCONFDIR
+  "Directory into which machine-specific read-only ASCII data and configuration files should be installed")
+
+if(NOT DEFINED CMAKE_INSTALL_DEFAULT_SHAREDSTATEDIR)
+  set(CMAKE_INSTALL_DEFAULT_SHAREDSTATEDIR "com")
+endif()
+GNUInstallDirs_set_install_dir(SHAREDSTATEDIR
+  "Directory into which architecture-independent run-time-modifiable data files should be installed")
+
+if(NOT DEFINED CMAKE_INSTALL_DEFAULT_LOCALSTATEDIR)
+  set(CMAKE_INSTALL_DEFAULT_LOCALSTATEDIR "var")
+endif()
+GNUInstallDirs_set_install_dir(LOCALSTATEDIR
+  "Directory into which machine-specific run-time-modifiable data files should be installed")
+
+if(NOT DEFINED CMAKE_INSTALL_DEFAULT_LIBDIR)
+  set(CMAKE_INSTALL_DEFAULT_LIBDIR "lib")
+  # Override this default 'lib' with 'lib64' iff:
+  #  - we are on Linux system but NOT cross-compiling
+  #  - we are NOT on debian
+  #  - we are on a 64 bits system
+  # reason is: amd64 ABI: http://www.x86-64.org/documentation/abi.pdf
+  # For Debian with multiarch, use 'lib/${CMAKE_LIBRARY_ARCHITECTURE}' if
+  # CMAKE_LIBRARY_ARCHITECTURE is set (which contains e.g. "i386-linux-gnu"
+  # and CMAKE_INSTALL_PREFIX is "/usr"
+  # See http://wiki.debian.org/Multiarch
+  if(CMAKE_SYSTEM_NAME MATCHES "^(Linux|kFreeBSD|GNU)$"
+      AND NOT CMAKE_CROSSCOMPILING)
+    if (EXISTS "/etc/debian_version") # is this a debian system ?
+      if(CMAKE_LIBRARY_ARCHITECTURE)
+        if("${CMAKE_INSTALL_PREFIX}" MATCHES "^/usr/?$")
+          set(CMAKE_INSTALL_DEFAULT_LIBDIR "lib/${CMAKE_LIBRARY_ARCHITECTURE}")
+        endif()
+      endif()
+    else() # not debian, rely on CMAKE_SIZEOF_VOID_P:
+      if(NOT DEFINED CMAKE_SIZEOF_VOID_P)
+        message(AUTHOR_WARNING
+          "Unable to determine default CMAKE_INSTALL_LIBDIR directory because no target architecture is known. "
+          "Please enable at least one language before including GNUInstallDirs.")
+      else()
+        if("${CMAKE_SIZEOF_VOID_P}" EQUAL "8")
+          set(CMAKE_INSTALL_DEFAULT_LIBDIR "lib64")
+        elseif(CMAKE_C_COMPILER_ABI MATCHES "ELF X32")
+          set(CMAKE_INSTALL_DEFAULT_LIBDIR "libx32")
+        endif()
+      endif()
+    endif()
+  endif()
+endif()
+GNUInstallDirs_set_install_dir(LIBDIR
+  "Directory into which object files and object code libraries should be installed")
+
+if(NOT DEFINED CMAKE_INSTALL_DEFAULT_INCLUDEDIR)
+  set(CMAKE_INSTALL_DEFAULT_INCLUDEDIR "include")
+endif()
+GNUInstallDirs_set_install_dir(INCLUDEDIR
+  "Directory into which C header files should be installed")
+
+if(NOT DEFINED CMAKE_INSTALL_DEFAULT_OLDINCLUDEDIR)
+  set(CMAKE_INSTALL_DEFAULT_OLDINCLUDEDIR "/usr/include")
+endif()
+GNUInstallDirs_set_install_dir(OLDINCLUDEDIR
+  PATH "Directory into which C header files for non-GCC compilers should be installed")
+
+if(NOT DEFINED CMAKE_INSTALL_DEFAULT_DATAROOTDIR)
+  set(CMAKE_INSTALL_DEFAULT_DATAROOTDIR "share")
+endif()
+GNUInstallDirs_set_install_dir(DATAROOTDIR
+  "The root of the directory tree for read-only architecture-independent data files")
+
+#-----------------------------------------------------------------------------
+# Values whose defaults are relative to DATAROOTDIR.  Store empty values in
+# the cache and store the defaults in local variables if the cache values are
+# not set explicitly.  This auto-updates the defaults as DATAROOTDIR changes.
+
+if(NOT DEFINED CMAKE_INSTALL_DEFAULT_DATADIR)
+  set(CMAKE_INSTALL_DEFAULT_DATADIR "<CMAKE_INSTALL_DATAROOTDIR>")
+endif()
+GNUInstallDirs_set_install_dir(DATADIR
+  "The directory under which read-only architecture-independent data files should be installed")
+
+if(NOT DEFINED CMAKE_INSTALL_DEFAULT_INFODIR)
+  if(CMAKE_SYSTEM_NAME MATCHES "^(.*BSD|DragonFly)$")
+    set(CMAKE_INSTALL_DEFAULT_INFODIR "info")
+  else()
+    set(CMAKE_INSTALL_DEFAULT_INFODIR "<CMAKE_INSTALL_DATAROOTDIR>/info")
+  endif()
+endif()
+GNUInstallDirs_set_install_dir(INFODIR
+  "The directory into which info documentation files should be installed")
+
+if(NOT DEFINED CMAKE_INSTALL_DEFAULT_MANDIR)
+  if(CMAKE_SYSTEM_NAME MATCHES "^(.*BSD|DragonFly)$")
+    set(CMAKE_INSTALL_DEFAULT_MANDIR "man")
+  else()
+    set(CMAKE_INSTALL_DEFAULT_MANDIR "<CMAKE_INSTALL_DATAROOTDIR>/man")
+  endif()
+endif()
+GNUInstallDirs_set_install_dir(MANDIR
+  "The directory under which man pages should be installed")
+
+if(NOT DEFINED CMAKE_INSTALL_DEFAULT_LOCALEDIR)
+  set(CMAKE_INSTALL_DEFAULT_LOCALEDIR "<CMAKE_INSTALL_DATAROOTDIR>/locale")
+endif()
+GNUInstallDirs_set_install_dir(LOCALEDIR
+  "The directory under which locale-specific message catalogs should be installed")
+
+if(NOT DEFINED CMAKE_INSTALL_DEFAULT_DOCDIR)
+  set(CMAKE_INSTALL_DEFAULT_DOCDIR "<CMAKE_INSTALL_DATAROOTDIR>/doc/${PROJECT_NAME}")
+endif()
+GNUInstallDirs_set_install_dir(DOCDIR
+  "The directory into which documentation files (other than info files) should be installed")
+
+#-----------------------------------------------------------------------------
+
+mark_as_advanced(
+  CMAKE_INSTALL_BINDIR
+  CMAKE_INSTALL_SBINDIR
+  CMAKE_INSTALL_LIBEXECDIR
+  CMAKE_INSTALL_SYSCONFDIR
+  CMAKE_INSTALL_SHAREDSTATEDIR
+  CMAKE_INSTALL_LOCALSTATEDIR
+  CMAKE_INSTALL_LIBDIR
+  CMAKE_INSTALL_INCLUDEDIR
+  CMAKE_INSTALL_OLDINCLUDEDIR
+  CMAKE_INSTALL_DATAROOTDIR
+  CMAKE_INSTALL_DATADIR
+  CMAKE_INSTALL_INFODIR
+  CMAKE_INSTALL_LOCALEDIR
+  CMAKE_INSTALL_MANDIR
+  CMAKE_INSTALL_DOCDIR
+  )
+
+macro(GNUInstallDirs_get_absolute_install_dir absvar var)
+  string(REGEX REPLACE "[<>]" "@" ${var} "${${var}}")
+  # Handle the specific case of an empty CMAKE_INSTALL_DATAROOTDIR
+  if(NOT CMAKE_INSTALL_DATAROOTDIR AND
+    ${var} MATCHES "\@CMAKE_INSTALL_DATAROOTDIR\@/")
+    string(CONFIGURE "${${var}}" ${var} @ONLY)
+    string(REGEX REPLACE "^/" "" ${var} "${${var}}")
+  else()
+    string(CONFIGURE "${${var}}" ${var} @ONLY)
+  endif()
+  if(NOT IS_ABSOLUTE "${${var}}")
+    # Handle special cases:
+    # - CMAKE_INSTALL_PREFIX == /
+    # - CMAKE_INSTALL_PREFIX == /usr
+    # - CMAKE_INSTALL_PREFIX == /opt/...
+    if("${CMAKE_INSTALL_PREFIX}" STREQUAL "/")
+      if("${dir}" STREQUAL "SYSCONFDIR" OR "${dir}" STREQUAL "LOCALSTATEDIR")
+        set(${absvar} "/${${var}}")
+      else()
+        if (NOT "${${var}}" MATCHES "^usr/")
+          set(${var} "usr/${${var}}")
+        endif()
+        set(${absvar} "/${${var}}")
+      endif()
+    elseif("${CMAKE_INSTALL_PREFIX}" MATCHES "^/usr/?$")
+      if("${dir}" STREQUAL "SYSCONFDIR" OR "${dir}" STREQUAL "LOCALSTATEDIR")
+        set(${absvar} "/${${var}}")
+      else()
+        set(${absvar} "${CMAKE_INSTALL_PREFIX}/${${var}}")
+      endif()
+    elseif("${CMAKE_INSTALL_PREFIX}" MATCHES "^/opt/.*")
+      if("${dir}" STREQUAL "SYSCONFDIR" OR "${dir}" STREQUAL "LOCALSTATEDIR")
+        set(${absvar} "/${${var}}${CMAKE_INSTALL_PREFIX}")
+      else()
+        set(${absvar} "${CMAKE_INSTALL_PREFIX}/${${var}}")
+      endif()
+    else()
+      set(${absvar} "${CMAKE_INSTALL_PREFIX}/${${var}}")
+    endif()
+  else()
+    set(${absvar} "${${var}}")
+  endif()
+  string(REGEX REPLACE "/$" "" ${absvar} "${${absvar}}")
+endmacro()
+
+# Result directories
+#
+foreach(dir
+    BINDIR
+    SBINDIR
+    LIBEXECDIR
+    SYSCONFDIR
+    SHAREDSTATEDIR
+    LOCALSTATEDIR
+    LIBDIR
+    INCLUDEDIR
+    OLDINCLUDEDIR
+    DATAROOTDIR
+    DATADIR
+    INFODIR
+    LOCALEDIR
+    MANDIR
+    DOCDIR
+    )
+  GNUInstallDirs_get_absolute_install_dir(CMAKE_INSTALL_FULL_${dir} CMAKE_INSTALL_${dir})
+endforeach()
diff --git a/3rdparty/libjpeg/src/cmakescripts/cmake_uninstall.cmake.in b/3rdparty/libjpeg/src/cmakescripts/cmake_uninstall.cmake.in
new file mode 100644
index 00000000..6726a0d6
--- /dev/null
+++ b/3rdparty/libjpeg/src/cmakescripts/cmake_uninstall.cmake.in
@@ -0,0 +1,24 @@
+# This code is from the CMake FAQ
+
+if (NOT EXISTS "@CMAKE_BINARY_DIR@/install_manifest.txt")
+  message(FATAL_ERROR "Cannot find install manifest: \"@CMAKE_BINARY_DIR@/install_manifest.txt\"")
+endif(NOT EXISTS "@CMAKE_BINARY_DIR@/install_manifest.txt")
+
+file(READ "@CMAKE_BINARY_DIR@/install_manifest.txt" files)
+string(REGEX REPLACE "\n" ";" files "${files}")
+list(REVERSE files)
+foreach (file ${files})
+  message(STATUS "Uninstalling \"$ENV{DESTDIR}${file}\"")
+    if (EXISTS "$ENV{DESTDIR}${file}")
+      execute_process(
+        COMMAND "@CMAKE_COMMAND@" -E remove "$ENV{DESTDIR}${file}"
+        OUTPUT_VARIABLE rm_out
+        RESULT_VARIABLE rm_retval
+      )
+    if(NOT ${rm_retval} EQUAL 0)
+      message(FATAL_ERROR "Problem when removing \"$ENV{DESTDIR}${file}\"")
+    endif (NOT ${rm_retval} EQUAL 0)
+  else (EXISTS "$ENV{DESTDIR}${file}")
+    message(STATUS "File \"$ENV{DESTDIR}${file}\" does not exist.")
+  endif (EXISTS "$ENV{DESTDIR}${file}")
+endforeach(file)
diff --git a/3rdparty/libjpeg/src/cmakescripts/testclean.cmake b/3rdparty/libjpeg/src/cmakescripts/testclean.cmake
new file mode 100644
index 00000000..fc3fc25e
--- /dev/null
+++ b/3rdparty/libjpeg/src/cmakescripts/testclean.cmake
@@ -0,0 +1,41 @@
+file(GLOB FILES
+  testout*
+  *_GRAY_*.bmp
+  *_GRAY_*.png
+  *_GRAY_*.ppm
+  *_GRAY_*.jpg
+  *_GRAY.yuv
+  *_420_*.bmp
+  *_420_*.png
+  *_420_*.ppm
+  *_420_*.jpg
+  *_420.yuv
+  *_422_*.bmp
+  *_422_*.png
+  *_422_*.ppm
+  *_422_*.jpg
+  *_422.yuv
+  *_444_*.bmp
+  *_444_*.png
+  *_444_*.ppm
+  *_444_*.jpg
+  *_444.yuv
+  *_440_*.bmp
+  *_440_*.png
+  *_440_*.ppm
+  *_440_*.jpg
+  *_440.yuv
+  *_411_*.bmp
+  *_411_*.png
+  *_411_*.ppm
+  *_411_*.jpg
+  *_411.yuv
+  tjbenchtest*.log
+  tjexampletest*.log)
+
+if(NOT FILES STREQUAL "")
+  message(STATUS "Removing test files")
+  file(REMOVE ${FILES})
+else()
+  message(STATUS "No files to remove")
+endif()
diff --git a/3rdparty/libjpeg/src/cmyk.h b/3rdparty/libjpeg/src/cmyk.h
new file mode 100644
index 00000000..48187a8f
--- /dev/null
+++ b/3rdparty/libjpeg/src/cmyk.h
@@ -0,0 +1,61 @@
+/*
+ * cmyk.h
+ *
+ * Copyright (C) 2017-2018, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains convenience functions for performing quick & dirty
+ * CMYK<->RGB conversion.  This algorithm is suitable for testing purposes
+ * only.  Properly converting between CMYK and RGB requires a color management
+ * system.
+ */
+
+#ifndef CMYK_H
+#define CMYK_H
+
+#include <jinclude.h>
+#define JPEG_INTERNALS
+#include <jpeglib.h>
+#include "jconfigint.h"
+
+
+/* Fully reversible */
+
+INLINE
+LOCAL(void)
+rgb_to_cmyk(JSAMPLE r, JSAMPLE g, JSAMPLE b, JSAMPLE *c, JSAMPLE *m,
+            JSAMPLE *y, JSAMPLE *k)
+{
+  double ctmp = 1.0 - ((double)r / 255.0);
+  double mtmp = 1.0 - ((double)g / 255.0);
+  double ytmp = 1.0 - ((double)b / 255.0);
+  double ktmp = MIN(MIN(ctmp, mtmp), ytmp);
+
+  if (ktmp == 1.0) ctmp = mtmp = ytmp = 0.0;
+  else {
+    ctmp = (ctmp - ktmp) / (1.0 - ktmp);
+    mtmp = (mtmp - ktmp) / (1.0 - ktmp);
+    ytmp = (ytmp - ktmp) / (1.0 - ktmp);
+  }
+  *c = (JSAMPLE)(255.0 - ctmp * 255.0 + 0.5);
+  *m = (JSAMPLE)(255.0 - mtmp * 255.0 + 0.5);
+  *y = (JSAMPLE)(255.0 - ytmp * 255.0 + 0.5);
+  *k = (JSAMPLE)(255.0 - ktmp * 255.0 + 0.5);
+}
+
+
+/* Fully reversible only for C/M/Y/K values generated with rgb_to_cmyk() */
+
+INLINE
+LOCAL(void)
+cmyk_to_rgb(JSAMPLE c, JSAMPLE m, JSAMPLE y, JSAMPLE k, JSAMPLE *r, JSAMPLE *g,
+            JSAMPLE *b)
+{
+  *r = (JSAMPLE)((double)c * (double)k / 255.0 + 0.5);
+  *g = (JSAMPLE)((double)m * (double)k / 255.0 + 0.5);
+  *b = (JSAMPLE)((double)y * (double)k / 255.0 + 0.5);
+}
+
+
+#endif /* CMYK_H */
diff --git a/3rdparty/libjpeg/src/coderules.txt b/3rdparty/libjpeg/src/coderules.txt
new file mode 100644
index 00000000..a2f593ad
--- /dev/null
+++ b/3rdparty/libjpeg/src/coderules.txt
@@ -0,0 +1,78 @@
+IJG JPEG LIBRARY:  CODING RULES
+
+This file was part of the Independent JPEG Group's software:
+Copyright (C) 1991-1996, Thomas G. Lane.
+It was modified by The libjpeg-turbo Project to include only information
+relevant to libjpeg-turbo.
+For conditions of distribution and use, see the accompanying README.ijg file.
+
+
+Since numerous people will be contributing code and bug fixes, it's important
+to establish a common coding style.  The goal of using similar coding styles
+is much more important than the details of just what that style is.
+
+In general we follow the recommendations of "Recommended C Style and Coding
+Standards" revision 6.1 (Cannon et al. as modified by Spencer, Keppel and
+Brader).  This document is available in the IJG FTP archive (see
+jpeg/doc/cstyle.ms.tbl.Z, or cstyle.txt.Z for those without nroff/tbl).
+
+Block comments should be laid out thusly:
+
+/*
+ *  Block comments in this style.
+ */
+
+We indent statements in K&R style, e.g.,
+        if (test) {
+          then-part;
+        } else {
+          else-part;
+        }
+with two spaces per indentation level.  (This indentation convention is
+handled automatically by GNU Emacs and many other text editors.)
+
+Multi-word names should be written in lower case with underscores, e.g.,
+multi_word_name (not multiWordName).  Preprocessor symbols and enum constants
+are similar but upper case (MULTI_WORD_NAME).  Names should be unique within
+the first fifteen characters.
+
+Note that each function definition must begin with GLOBAL(type), LOCAL(type),
+or METHODDEF(type).  These macros expand to "static type" or just "type" as
+appropriate.  They provide a readable indication of the routine's usage and
+can readily be changed for special needs.  (For instance, special linkage
+keywords can be inserted for use in Windows DLLs.)
+
+A similar solution is used for external function declarations (see the EXTERN
+macro.)
+
+
+The JPEG library is intended to be used within larger programs.  Furthermore,
+we want it to be reentrant so that it can be used by applications that process
+multiple images concurrently.  The following rules support these requirements:
+
+1. Avoid direct use of file I/O, "malloc", error report printouts, etc;
+pass these through the common routines provided.
+
+2. Minimize global namespace pollution.  Functions should be declared static
+wherever possible.  (Note that our method-based calling conventions help this
+a lot: in many modules only the initialization function will ever need to be
+called directly, so only that function need be externally visible.)  All
+global function names should begin with "jpeg_".
+
+3. Don't use global variables; anything that must be used in another module
+should be in the common data structures.
+
+4. Don't use static variables except for read-only constant tables.  Variables
+that should be private to a module can be placed into private structures (see
+the system architecture document, structure.txt).
+
+5. Source file names should begin with "j" for files that are part of the
+library proper; source files that are not part of the library, such as cjpeg.c
+and djpeg.c, do not begin with "j".  Keep compression and decompression code in
+separate source files --- some applications may want only one half of the
+library.
+
+Note: these rules (particularly #4) are not followed religiously in the
+modules that are used in cjpeg/djpeg but are not part of the JPEG library
+proper.  Those modules are not really intended to be used in other
+applications.
diff --git a/3rdparty/libjpeg/src/croptest.in b/3rdparty/libjpeg/src/croptest.in
new file mode 100644
index 00000000..7e3c2931
--- /dev/null
+++ b/3rdparty/libjpeg/src/croptest.in
@@ -0,0 +1,95 @@
+#!/bin/bash
+
+set -u
+set -e
+trap onexit INT
+trap onexit TERM
+trap onexit EXIT
+
+onexit()
+{
+	if [ -d $OUTDIR ]; then
+		rm -rf $OUTDIR
+	fi
+}
+
+runme()
+{
+	echo \*\*\* $*
+	$*
+}
+
+IMAGE=vgl_6548_0026a.bmp
+WIDTH=128
+HEIGHT=95
+IMGDIR=@CMAKE_CURRENT_SOURCE_DIR@/testimages
+OUTDIR=`mktemp -d /tmp/__croptest_output.XXXXXX`
+EXEDIR=@CMAKE_CURRENT_BINARY_DIR@
+
+if [ -d $OUTDIR ]; then
+	rm -rf $OUTDIR
+fi
+mkdir -p $OUTDIR
+
+exec >$EXEDIR/croptest.log
+
+echo "============================================================"
+echo "$IMAGE ($WIDTH x $HEIGHT)"
+echo "============================================================"
+echo
+
+for PROGARG in "" -progressive; do
+
+	cp $IMGDIR/$IMAGE $OUTDIR
+	basename=`basename $IMAGE .bmp`
+	echo "------------------------------------------------------------"
+	echo "Generating test images"
+	echo "------------------------------------------------------------"
+	echo
+	runme $EXEDIR/cjpeg $PROGARG -grayscale -outfile $OUTDIR/${basename}_GRAY.jpg $IMGDIR/${basename}.bmp
+	runme $EXEDIR/cjpeg $PROGARG -sample 2x2 -outfile $OUTDIR/${basename}_420.jpg $IMGDIR/${basename}.bmp
+	runme $EXEDIR/cjpeg $PROGARG -sample 2x1 -outfile $OUTDIR/${basename}_422.jpg $IMGDIR/${basename}.bmp
+	runme $EXEDIR/cjpeg $PROGARG -sample 1x2 -outfile $OUTDIR/${basename}_440.jpg $IMGDIR/${basename}.bmp
+	runme $EXEDIR/cjpeg $PROGARG -sample 1x1 -outfile $OUTDIR/${basename}_444.jpg $IMGDIR/${basename}.bmp
+	echo
+
+	for NSARG in "" -nosmooth; do
+
+		for COLORSARG in "" "-colors 256 -dither none -onepass"; do
+
+			for Y in {0..16}; do
+
+				for H in {1..16}; do
+
+					X=$(( (Y*16)%128 ))
+					W=$(( WIDTH-X-7 ))
+					if [ $Y -le 15 ]; then
+						CROPSPEC="${W}x${H}+${X}+${Y}"
+					else
+						Y2=$(( HEIGHT-H ));
+						CROPSPEC="${W}x${H}+${X}+${Y2}"
+					fi
+
+					echo "------------------------------------------------------------"
+					echo $PROGARG $NSARG $COLORSARG -crop $CROPSPEC
+					echo "------------------------------------------------------------"
+					echo
+					for samp in GRAY 420 422 440 444; do
+						$EXEDIR/djpeg $NSARG $COLORSARG -rgb -outfile $OUTDIR/${basename}_${samp}_full.ppm $OUTDIR/${basename}_${samp}.jpg
+						convert -crop $CROPSPEC $OUTDIR/${basename}_${samp}_full.ppm $OUTDIR/${basename}_${samp}_ref.ppm
+						runme $EXEDIR/djpeg $NSARG $COLORSARG -crop $CROPSPEC -rgb -outfile $OUTDIR/${basename}_${samp}.ppm $OUTDIR/${basename}_${samp}.jpg
+						runme cmp $OUTDIR/${basename}_${samp}.ppm $OUTDIR/${basename}_${samp}_ref.ppm
+					done
+					echo
+
+				done
+
+			done
+
+		done
+
+	done
+
+done
+
+echo SUCCESS!
diff --git a/3rdparty/libjpeg/src/djpeg.1 b/3rdparty/libjpeg/src/djpeg.1
new file mode 100644
index 00000000..31431b98
--- /dev/null
+++ b/3rdparty/libjpeg/src/djpeg.1
@@ -0,0 +1,320 @@
+.TH DJPEG 1 "4 November 2020"
+.SH NAME
+djpeg \- decompress a JPEG file to an image file
+.SH SYNOPSIS
+.B djpeg
+[
+.I options
+]
+[
+.I filename
+]
+.LP
+.SH DESCRIPTION
+.LP
+.B djpeg
+decompresses the named JPEG file, or the standard input if no file is named,
+and produces an image file on the standard output.  PBMPLUS (PPM/PGM), BMP,
+GIF, or Targa output format can be selected.
+.SH OPTIONS
+All switch names may be abbreviated; for example,
+.B \-grayscale
+may be written
+.B \-gray
+or
+.BR \-gr .
+Most of the "basic" switches can be abbreviated to as little as one letter.
+Upper and lower case are equivalent (thus
+.B \-BMP
+is the same as
+.BR \-bmp ).
+British spellings are also accepted (e.g.,
+.BR \-greyscale ),
+though for brevity these are not mentioned below.
+.PP
+The basic switches are:
+.TP
+.BI \-colors " N"
+Reduce image to at most N colors.  This reduces the number of colors used in
+the output image, so that it can be displayed on a colormapped display or
+stored in a colormapped file format.  For example, if you have an 8-bit
+display, you'd need to reduce to 256 or fewer colors.
+.TP
+.BI \-quantize " N"
+Same as
+.BR \-colors .
+.B \-colors
+is the recommended name,
+.B \-quantize
+is provided only for backwards compatibility.
+.TP
+.B \-fast
+Select recommended processing options for fast, low quality output.  (The
+default options are chosen for highest quality output.)  Currently, this is
+equivalent to \fB\-dct fast \-nosmooth \-onepass \-dither ordered\fR.
+.TP
+.B \-grayscale
+Force grayscale output even if JPEG file is color.  Useful for viewing on
+monochrome displays; also,
+.B djpeg
+runs noticeably faster in this mode.
+.TP
+.B \-rgb
+Force RGB output even if JPEG file is grayscale.
+.TP
+.BI \-scale " M/N"
+Scale the output image by a factor M/N.  Currently the scale factor must be
+M/8, where M is an integer between 1 and 16 inclusive, or any reduced fraction
+thereof (such as 1/2, 3/4, etc.)  Scaling is handy if the image is larger than
+your screen; also,
+.B djpeg
+runs much faster when scaling down the output.
+.TP
+.B \-bmp
+Select BMP output format (Windows flavor).  8-bit colormapped format is
+emitted if
+.B \-colors
+or
+.B \-grayscale
+is specified, or if the JPEG file is grayscale; otherwise, 24-bit full-color
+format is emitted.
+.TP
+.B \-gif
+Select GIF output format (LZW-compressed).  Since GIF does not support more
+than 256 colors,
+.B \-colors 256
+is assumed (unless you specify a smaller number of colors).  If you specify
+.BR \-fast,
+the default number of colors is 216.
+.TP
+.B \-gif0
+Select GIF output format (uncompressed).  Since GIF does not support more than
+256 colors,
+.B \-colors 256
+is assumed (unless you specify a smaller number of colors).  If you specify
+.BR \-fast,
+the default number of colors is 216.
+.TP
+.B \-os2
+Select BMP output format (OS/2 1.x flavor).  8-bit colormapped format is
+emitted if
+.B \-colors
+or
+.B \-grayscale
+is specified, or if the JPEG file is grayscale; otherwise, 24-bit full-color
+format is emitted.
+.TP
+.B \-pnm
+Select PBMPLUS (PPM/PGM) output format (this is the default format).
+PGM is emitted if the JPEG file is grayscale or if
+.B \-grayscale
+is specified; otherwise PPM is emitted.
+.TP
+.B \-targa
+Select Targa output format.  Grayscale format is emitted if the JPEG file is
+grayscale or if
+.B \-grayscale
+is specified; otherwise, colormapped format is emitted if
+.B \-colors
+is specified; otherwise, 24-bit full-color format is emitted.
+.PP
+Switches for advanced users:
+.TP
+.B \-dct int
+Use accurate integer DCT method (default).
+.TP
+.B \-dct fast
+Use less accurate integer DCT method [legacy feature].
+When the Independent JPEG Group's software was first released in 1991, the
+decompression time for a 1-megapixel JPEG image on a mainstream PC was measured
+in minutes.  Thus, the \fBfast\fR integer DCT algorithm provided noticeable
+performance benefits.  On modern CPUs running libjpeg-turbo, however, the
+decompression time for a 1-megapixel JPEG image is measured in milliseconds,
+and thus the performance benefits of the \fBfast\fR algorithm are much less
+noticeable.  On modern x86/x86-64 CPUs that support AVX2 instructions, the
+\fBfast\fR and \fBint\fR methods have similar performance.  On other types of
+CPUs, the \fBfast\fR method is generally about 5-15% faster than the \fBint\fR
+method.
+
+If the JPEG image was compressed using a quality level of 85 or below, then
+there should be little or no perceptible quality difference between the two
+algorithms.  When decompressing images that were compressed using quality
+levels above 85, however, the difference between the \fBfast\fR and \fBint\fR
+methods becomes more pronounced.  With images compressed using quality=97, for
+instance, the \fBfast\fR method incurs generally about a 4-6 dB loss in PSNR
+relative to the \fBint\fR method, but this can be larger for some images.  If
+you can avoid it, do not use the \fBfast\fR method when decompressing images
+that were compressed using quality levels above 97.  The algorithm often
+degenerates for such images and can actually produce a more lossy output image
+than if the JPEG image had been compressed using lower quality levels.
+.TP
+.B \-dct float
+Use floating-point DCT method [legacy feature].
+The \fBfloat\fR method does not produce significantly more accurate results
+than the \fBint\fR method, and it is much slower.  The \fBfloat\fR method may
+also give different results on different machines due to varying roundoff
+behavior, whereas the integer methods should give the same results on all
+machines.
+.TP
+.B \-dither fs
+Use Floyd-Steinberg dithering in color quantization.
+.TP
+.B \-dither ordered
+Use ordered dithering in color quantization.
+.TP
+.B \-dither none
+Do not use dithering in color quantization.
+By default, Floyd-Steinberg dithering is applied when quantizing colors; this
+is slow but usually produces the best results.  Ordered dither is a compromise
+between speed and quality; no dithering is fast but usually looks awful.  Note
+that these switches have no effect unless color quantization is being done.
+Ordered dither is only available in
+.B \-onepass
+mode.
+.TP
+.BI \-icc " file"
+Extract ICC color management profile to the specified file.
+.TP
+.BI \-map " file"
+Quantize to the colors used in the specified image file.  This is useful for
+producing multiple files with identical color maps, or for forcing a
+predefined set of colors to be used.  The
+.I file
+must be a GIF or PPM file. This option overrides
+.B \-colors
+and
+.BR \-onepass .
+.TP
+.B \-nosmooth
+Use a faster, lower-quality upsampling routine.
+.TP
+.B \-onepass
+Use one-pass instead of two-pass color quantization.  The one-pass method is
+faster and needs less memory, but it produces a lower-quality image.
+.B \-onepass
+is ignored unless you also say
+.B \-colors
+.IR N .
+Also, the one-pass method is always used for grayscale output (the two-pass
+method is no improvement then).
+.TP
+.BI \-maxmemory " N"
+Set limit for amount of memory to use in processing large images.  Value is
+in thousands of bytes, or millions of bytes if "M" is attached to the
+number.  For example,
+.B \-max 4m
+selects 4000000 bytes.  If more space is needed, an error will occur.
+.TP
+.BI \-maxscans " N"
+Abort if the JPEG image contains more than
+.I N
+scans.  This feature demonstrates a method by which applications can guard
+against denial-of-service attacks instigated by specially-crafted malformed
+JPEG images containing numerous scans with missing image data or image data
+consisting only of "EOB runs" (a feature of progressive JPEG images that allows
+potentially hundreds of thousands of adjoining zero-value pixels to be
+represented using only a few bytes.)  Attempting to decompress such malformed
+JPEG images can cause excessive CPU activity, since the decompressor must fully
+process each scan (even if the scan is corrupt) before it can proceed to the
+next scan.
+.TP
+.BI \-outfile " name"
+Send output image to the named file, not to standard output.
+.TP
+.BI \-memsrc
+Load input file into memory before decompressing.  This feature was implemented
+mainly as a way of testing the in-memory source manager (jpeg_mem_src().)
+.TP
+.BI \-report
+Report decompression progress.
+.TP
+.BI \-skip " Y0,Y1"
+Decompress all rows of the JPEG image except those between Y0 and Y1
+(inclusive.)  Note that if decompression scaling is being used, then Y0 and Y1
+are relative to the scaled image dimensions.
+.TP
+.BI \-crop " WxH+X+Y"
+Decompress only a rectangular subregion of the image, starting at point X,Y
+with width W and height H.  If necessary, X will be shifted left to the nearest
+iMCU boundary, and the width will be increased accordingly.  Note that if
+decompression scaling is being used, then X, Y, W, and H are relative to the
+scaled image dimensions.  Currently this option only works with the
+PBMPLUS (PPM/PGM), GIF, and Targa output formats.
+.TP
+.BI \-strict
+Treat all warnings as fatal.  This feature also demonstrates a method by which
+applications can guard against attacks instigated by specially-crafted
+malformed JPEG images.  Enabling this option will cause the decompressor to
+abort if the JPEG image contains incomplete or corrupt image data.
+.TP
+.B \-verbose
+Enable debug printout.  More
+.BR \-v 's
+give more output.  Also, version information is printed at startup.
+.TP
+.B \-debug
+Same as
+.BR \-verbose .
+.TP
+.B \-version
+Print version information and exit.
+.SH EXAMPLES
+.LP
+This example decompresses the JPEG file foo.jpg, quantizes it to
+256 colors, and saves the output in 8-bit BMP format in foo.bmp:
+.IP
+.B djpeg \-colors 256 \-bmp
+.I foo.jpg
+.B >
+.I foo.bmp
+.SH HINTS
+To get a quick preview of an image, use the
+.B \-grayscale
+and/or
+.B \-scale
+switches.
+.B \-grayscale \-scale 1/8
+is the fastest case.
+.PP
+Several options are available that trade off image quality to gain speed.
+.B \-fast
+turns on the recommended settings.
+.PP
+.B \-dct fast
+and/or
+.B \-nosmooth
+gain speed at a small sacrifice in quality.
+When producing a color-quantized image,
+.B \-onepass \-dither ordered
+is fast but much lower quality than the default behavior.
+.B \-dither none
+may give acceptable results in two-pass mode, but is seldom tolerable in
+one-pass mode.
+.SH ENVIRONMENT
+.TP
+.B JPEGMEM
+If this environment variable is set, its value is the default memory limit.
+The value is specified as described for the
+.B \-maxmemory
+switch.
+.B JPEGMEM
+overrides the default value specified when the program was compiled, and
+itself is overridden by an explicit
+.BR \-maxmemory .
+.SH SEE ALSO
+.BR cjpeg (1),
+.BR jpegtran (1),
+.BR rdjpgcom (1),
+.BR wrjpgcom (1)
+.br
+.BR ppm (5),
+.BR pgm (5)
+.br
+Wallace, Gregory K.  "The JPEG Still Picture Compression Standard",
+Communications of the ACM, April 1991 (vol. 34, no. 4), pp. 30-44.
+.SH AUTHOR
+Independent JPEG Group
+.PP
+This file was modified by The libjpeg-turbo Project to include only information
+relevant to libjpeg-turbo, to wordsmith certain sections, and to describe
+features not present in libjpeg.
diff --git a/3rdparty/libjpeg/src/djpeg.c b/3rdparty/libjpeg/src/djpeg.c
new file mode 100644
index 00000000..d47984e6
--- /dev/null
+++ b/3rdparty/libjpeg/src/djpeg.c
@@ -0,0 +1,868 @@
+/*
+ * djpeg.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1991-1997, Thomas G. Lane.
+ * Modified 2013-2019 by Guido Vollbeding.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2010-2011, 2013-2017, 2019-2020, D. R. Commander.
+ * Copyright (C) 2015, Google, Inc.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains a command-line user interface for the JPEG decompressor.
+ * It should work on any system with Unix- or MS-DOS-style command lines.
+ *
+ * Two different command line styles are permitted, depending on the
+ * compile-time switch TWO_FILE_COMMANDLINE:
+ *      djpeg [options]  inputfile outputfile
+ *      djpeg [options]  [inputfile]
+ * In the second style, output is always to standard output, which you'd
+ * normally redirect to a file or pipe to some other program.  Input is
+ * either from a named file or from standard input (typically redirected).
+ * The second style is convenient on Unix but is unhelpful on systems that
+ * don't support pipes.  Also, you MUST use the first style if your system
+ * doesn't do binary I/O to stdin/stdout.
+ * To simplify script writing, the "-outfile" switch is provided.  The syntax
+ *      djpeg [options]  -outfile outputfile  inputfile
+ * works regardless of which command line style is used.
+ */
+
+#include "cdjpeg.h"             /* Common decls for cjpeg/djpeg applications */
+#include "jversion.h"           /* for version message */
+#include "jconfigint.h"
+
+#ifndef HAVE_STDLIB_H           /* <stdlib.h> should declare free() */
+extern void free(void *ptr);
+#endif
+
+#include <ctype.h>              /* to declare isprint() */
+
+#ifdef USE_CCOMMAND             /* command-line reader for Macintosh */
+#ifdef __MWERKS__
+#include <SIOUX.h>              /* Metrowerks needs this */
+#include <console.h>            /* ... and this */
+#endif
+#ifdef THINK_C
+#include <console.h>            /* Think declares it here */
+#endif
+#endif
+
+
+/* Create the add-on message string table. */
+
+#define JMESSAGE(code, string)  string,
+
+static const char * const cdjpeg_message_table[] = {
+#include "cderror.h"
+  NULL
+};
+
+
+/*
+ * This list defines the known output image formats
+ * (not all of which need be supported by a given version).
+ * You can change the default output format by defining DEFAULT_FMT;
+ * indeed, you had better do so if you undefine PPM_SUPPORTED.
+ */
+
+typedef enum {
+  FMT_BMP,                      /* BMP format (Windows flavor) */
+  FMT_GIF,                      /* GIF format (LZW-compressed) */
+  FMT_GIF0,                     /* GIF format (uncompressed) */
+  FMT_OS2,                      /* BMP format (OS/2 flavor) */
+  FMT_PPM,                      /* PPM/PGM (PBMPLUS formats) */
+  FMT_TARGA,                    /* Targa format */
+  FMT_TIFF                      /* TIFF format */
+} IMAGE_FORMATS;
+
+#ifndef DEFAULT_FMT             /* so can override from CFLAGS in Makefile */
+#define DEFAULT_FMT     FMT_PPM
+#endif
+
+static IMAGE_FORMATS requested_fmt;
+
+
+/*
+ * Argument-parsing code.
+ * The switch parser is designed to be useful with DOS-style command line
+ * syntax, ie, intermixed switches and file names, where only the switches
+ * to the left of a given file name affect processing of that file.
+ * The main program in this file doesn't actually use this capability...
+ */
+
+
+static const char *progname;    /* program name for error messages */
+static char *icc_filename;      /* for -icc switch */
+JDIMENSION max_scans;           /* for -maxscans switch */
+static char *outfilename;       /* for -outfile switch */
+boolean memsrc;                 /* for -memsrc switch */
+boolean report;                 /* for -report switch */
+boolean skip, crop;
+JDIMENSION skip_start, skip_end;
+JDIMENSION crop_x, crop_y, crop_width, crop_height;
+boolean strict;                 /* for -strict switch */
+#define INPUT_BUF_SIZE  4096
+
+
+LOCAL(void)
+usage(void)
+/* complain about bad command line */
+{
+  fprintf(stderr, "usage: %s [switches] ", progname);
+#ifdef TWO_FILE_COMMANDLINE
+  fprintf(stderr, "inputfile outputfile\n");
+#else
+  fprintf(stderr, "[inputfile]\n");
+#endif
+
+  fprintf(stderr, "Switches (names may be abbreviated):\n");
+  fprintf(stderr, "  -colors N      Reduce image to no more than N colors\n");
+  fprintf(stderr, "  -fast          Fast, low-quality processing\n");
+  fprintf(stderr, "  -grayscale     Force grayscale output\n");
+  fprintf(stderr, "  -rgb           Force RGB output\n");
+  fprintf(stderr, "  -rgb565        Force RGB565 output\n");
+#ifdef IDCT_SCALING_SUPPORTED
+  fprintf(stderr, "  -scale M/N     Scale output image by fraction M/N, eg, 1/8\n");
+#endif
+#ifdef BMP_SUPPORTED
+  fprintf(stderr, "  -bmp           Select BMP output format (Windows style)%s\n",
+          (DEFAULT_FMT == FMT_BMP ? " (default)" : ""));
+#endif
+#ifdef GIF_SUPPORTED
+  fprintf(stderr, "  -gif           Select GIF output format (LZW-compressed)%s\n",
+          (DEFAULT_FMT == FMT_GIF ? " (default)" : ""));
+  fprintf(stderr, "  -gif0          Select GIF output format (uncompressed)%s\n",
+          (DEFAULT_FMT == FMT_GIF0 ? " (default)" : ""));
+#endif
+#ifdef BMP_SUPPORTED
+  fprintf(stderr, "  -os2           Select BMP output format (OS/2 style)%s\n",
+          (DEFAULT_FMT == FMT_OS2 ? " (default)" : ""));
+#endif
+#ifdef PPM_SUPPORTED
+  fprintf(stderr, "  -pnm           Select PBMPLUS (PPM/PGM) output format%s\n",
+          (DEFAULT_FMT == FMT_PPM ? " (default)" : ""));
+#endif
+#ifdef TARGA_SUPPORTED
+  fprintf(stderr, "  -targa         Select Targa output format%s\n",
+          (DEFAULT_FMT == FMT_TARGA ? " (default)" : ""));
+#endif
+  fprintf(stderr, "Switches for advanced users:\n");
+#ifdef DCT_ISLOW_SUPPORTED
+  fprintf(stderr, "  -dct int       Use accurate integer DCT method%s\n",
+          (JDCT_DEFAULT == JDCT_ISLOW ? " (default)" : ""));
+#endif
+#ifdef DCT_IFAST_SUPPORTED
+  fprintf(stderr, "  -dct fast      Use less accurate integer DCT method [legacy feature]%s\n",
+          (JDCT_DEFAULT == JDCT_IFAST ? " (default)" : ""));
+#endif
+#ifdef DCT_FLOAT_SUPPORTED
+  fprintf(stderr, "  -dct float     Use floating-point DCT method [legacy feature]%s\n",
+          (JDCT_DEFAULT == JDCT_FLOAT ? " (default)" : ""));
+#endif
+  fprintf(stderr, "  -dither fs     Use F-S dithering (default)\n");
+  fprintf(stderr, "  -dither none   Don't use dithering in quantization\n");
+  fprintf(stderr, "  -dither ordered  Use ordered dither (medium speed, quality)\n");
+  fprintf(stderr, "  -icc FILE      Extract ICC profile to FILE\n");
+#ifdef QUANT_2PASS_SUPPORTED
+  fprintf(stderr, "  -map FILE      Map to colors used in named image file\n");
+#endif
+  fprintf(stderr, "  -nosmooth      Don't use high-quality upsampling\n");
+#ifdef QUANT_1PASS_SUPPORTED
+  fprintf(stderr, "  -onepass       Use 1-pass quantization (fast, low quality)\n");
+#endif
+  fprintf(stderr, "  -maxmemory N   Maximum memory to use (in kbytes)\n");
+  fprintf(stderr, "  -maxscans N    Maximum number of scans to allow in input file\n");
+  fprintf(stderr, "  -outfile name  Specify name for output file\n");
+#if JPEG_LIB_VERSION >= 80 || defined(MEM_SRCDST_SUPPORTED)
+  fprintf(stderr, "  -memsrc        Load input file into memory before decompressing\n");
+#endif
+  fprintf(stderr, "  -report        Report decompression progress\n");
+  fprintf(stderr, "  -skip Y0,Y1    Decompress all rows except those between Y0 and Y1 (inclusive)\n");
+  fprintf(stderr, "  -crop WxH+X+Y  Decompress only a rectangular subregion of the image\n");
+  fprintf(stderr, "                 [requires PBMPLUS (PPM/PGM), GIF, or Targa output format]\n");
+  fprintf(stderr, "  -strict        Treat all warnings as fatal\n");
+  fprintf(stderr, "  -verbose  or  -debug   Emit debug output\n");
+  fprintf(stderr, "  -version       Print version information and exit\n");
+  exit(EXIT_FAILURE);
+}
+
+
+LOCAL(int)
+parse_switches(j_decompress_ptr cinfo, int argc, char **argv,
+               int last_file_arg_seen, boolean for_real)
+/* Parse optional switches.
+ * Returns argv[] index of first file-name argument (== argc if none).
+ * Any file names with indexes <= last_file_arg_seen are ignored;
+ * they have presumably been processed in a previous iteration.
+ * (Pass 0 for last_file_arg_seen on the first or only iteration.)
+ * for_real is FALSE on the first (dummy) pass; we may skip any expensive
+ * processing.
+ */
+{
+  int argn;
+  char *arg;
+
+  /* Set up default JPEG parameters. */
+  requested_fmt = DEFAULT_FMT;  /* set default output file format */
+  icc_filename = NULL;
+  max_scans = 0;
+  outfilename = NULL;
+  memsrc = FALSE;
+  report = FALSE;
+  skip = FALSE;
+  crop = FALSE;
+  strict = FALSE;
+  cinfo->err->trace_level = 0;
+
+  /* Scan command line options, adjust parameters */
+
+  for (argn = 1; argn < argc; argn++) {
+    arg = argv[argn];
+    if (*arg != '-') {
+      /* Not a switch, must be a file name argument */
+      if (argn <= last_file_arg_seen) {
+        outfilename = NULL;     /* -outfile applies to just one input file */
+        continue;               /* ignore this name if previously processed */
+      }
+      break;                    /* else done parsing switches */
+    }
+    arg++;                      /* advance past switch marker character */
+
+    if (keymatch(arg, "bmp", 1)) {
+      /* BMP output format (Windows flavor). */
+      requested_fmt = FMT_BMP;
+
+    } else if (keymatch(arg, "colors", 1) || keymatch(arg, "colours", 1) ||
+               keymatch(arg, "quantize", 1) || keymatch(arg, "quantise", 1)) {
+      /* Do color quantization. */
+      int val;
+
+      if (++argn >= argc)       /* advance to next argument */
+        usage();
+      if (sscanf(argv[argn], "%d", &val) != 1)
+        usage();
+      cinfo->desired_number_of_colors = val;
+      cinfo->quantize_colors = TRUE;
+
+    } else if (keymatch(arg, "dct", 2)) {
+      /* Select IDCT algorithm. */
+      if (++argn >= argc)       /* advance to next argument */
+        usage();
+      if (keymatch(argv[argn], "int", 1)) {
+        cinfo->dct_method = JDCT_ISLOW;
+      } else if (keymatch(argv[argn], "fast", 2)) {
+        cinfo->dct_method = JDCT_IFAST;
+      } else if (keymatch(argv[argn], "float", 2)) {
+        cinfo->dct_method = JDCT_FLOAT;
+      } else
+        usage();
+
+    } else if (keymatch(arg, "dither", 2)) {
+      /* Select dithering algorithm. */
+      if (++argn >= argc)       /* advance to next argument */
+        usage();
+      if (keymatch(argv[argn], "fs", 2)) {
+        cinfo->dither_mode = JDITHER_FS;
+      } else if (keymatch(argv[argn], "none", 2)) {
+        cinfo->dither_mode = JDITHER_NONE;
+      } else if (keymatch(argv[argn], "ordered", 2)) {
+        cinfo->dither_mode = JDITHER_ORDERED;
+      } else
+        usage();
+
+    } else if (keymatch(arg, "debug", 1) || keymatch(arg, "verbose", 1)) {
+      /* Enable debug printouts. */
+      /* On first -d, print version identification */
+      static boolean printed_version = FALSE;
+
+      if (!printed_version) {
+        fprintf(stderr, "%s version %s (build %s)\n",
+                PACKAGE_NAME, VERSION, BUILD);
+        fprintf(stderr, "%s\n\n", JCOPYRIGHT);
+        fprintf(stderr, "Emulating The Independent JPEG Group's software, version %s\n\n",
+                JVERSION);
+        printed_version = TRUE;
+      }
+      cinfo->err->trace_level++;
+
+    } else if (keymatch(arg, "version", 4)) {
+      fprintf(stderr, "%s version %s (build %s)\n",
+              PACKAGE_NAME, VERSION, BUILD);
+      exit(EXIT_SUCCESS);
+
+    } else if (keymatch(arg, "fast", 1)) {
+      /* Select recommended processing options for quick-and-dirty output. */
+      cinfo->two_pass_quantize = FALSE;
+      cinfo->dither_mode = JDITHER_ORDERED;
+      if (!cinfo->quantize_colors) /* don't override an earlier -colors */
+        cinfo->desired_number_of_colors = 216;
+      cinfo->dct_method = JDCT_FASTEST;
+      cinfo->do_fancy_upsampling = FALSE;
+
+    } else if (keymatch(arg, "gif", 1)) {
+      /* GIF output format (LZW-compressed). */
+      requested_fmt = FMT_GIF;
+
+    } else if (keymatch(arg, "gif0", 4)) {
+      /* GIF output format (uncompressed). */
+      requested_fmt = FMT_GIF0;
+
+    } else if (keymatch(arg, "grayscale", 2) ||
+               keymatch(arg, "greyscale", 2)) {
+      /* Force monochrome output. */
+      cinfo->out_color_space = JCS_GRAYSCALE;
+
+    } else if (keymatch(arg, "rgb", 2)) {
+      /* Force RGB output. */
+      cinfo->out_color_space = JCS_RGB;
+
+    } else if (keymatch(arg, "rgb565", 2)) {
+      /* Force RGB565 output. */
+      cinfo->out_color_space = JCS_RGB565;
+
+    } else if (keymatch(arg, "icc", 1)) {
+      /* Set ICC filename. */
+      if (++argn >= argc)       /* advance to next argument */
+        usage();
+      icc_filename = argv[argn];
+      jpeg_save_markers(cinfo, JPEG_APP0 + 2, 0xFFFF);
+
+    } else if (keymatch(arg, "map", 3)) {
+      /* Quantize to a color map taken from an input file. */
+      if (++argn >= argc)       /* advance to next argument */
+        usage();
+      if (for_real) {           /* too expensive to do twice! */
+#ifdef QUANT_2PASS_SUPPORTED    /* otherwise can't quantize to supplied map */
+        FILE *mapfile;
+
+        if ((mapfile = fopen(argv[argn], READ_BINARY)) == NULL) {
+          fprintf(stderr, "%s: can't open %s\n", progname, argv[argn]);
+          exit(EXIT_FAILURE);
+        }
+        read_color_map(cinfo, mapfile);
+        fclose(mapfile);
+        cinfo->quantize_colors = TRUE;
+#else
+        ERREXIT(cinfo, JERR_NOT_COMPILED);
+#endif
+      }
+
+    } else if (keymatch(arg, "maxmemory", 3)) {
+      /* Maximum memory in Kb (or Mb with 'm'). */
+      long lval;
+      char ch = 'x';
+
+      if (++argn >= argc)       /* advance to next argument */
+        usage();
+      if (sscanf(argv[argn], "%ld%c", &lval, &ch) < 1)
+        usage();
+      if (ch == 'm' || ch == 'M')
+        lval *= 1000L;
+      cinfo->mem->max_memory_to_use = lval * 1000L;
+
+    } else if (keymatch(arg, "maxscans", 4)) {
+      if (++argn >= argc)       /* advance to next argument */
+        usage();
+      if (sscanf(argv[argn], "%u", &max_scans) != 1)
+        usage();
+
+    } else if (keymatch(arg, "nosmooth", 3)) {
+      /* Suppress fancy upsampling */
+      cinfo->do_fancy_upsampling = FALSE;
+
+    } else if (keymatch(arg, "onepass", 3)) {
+      /* Use fast one-pass quantization. */
+      cinfo->two_pass_quantize = FALSE;
+
+    } else if (keymatch(arg, "os2", 3)) {
+      /* BMP output format (OS/2 flavor). */
+      requested_fmt = FMT_OS2;
+
+    } else if (keymatch(arg, "outfile", 4)) {
+      /* Set output file name. */
+      if (++argn >= argc)       /* advance to next argument */
+        usage();
+      outfilename = argv[argn]; /* save it away for later use */
+
+    } else if (keymatch(arg, "memsrc", 2)) {
+      /* Use in-memory source manager */
+#if JPEG_LIB_VERSION >= 80 || defined(MEM_SRCDST_SUPPORTED)
+      memsrc = TRUE;
+#else
+      fprintf(stderr, "%s: sorry, in-memory source manager was not compiled in\n",
+              progname);
+      exit(EXIT_FAILURE);
+#endif
+
+    } else if (keymatch(arg, "pnm", 1) || keymatch(arg, "ppm", 1)) {
+      /* PPM/PGM output format. */
+      requested_fmt = FMT_PPM;
+
+    } else if (keymatch(arg, "report", 2)) {
+      report = TRUE;
+
+    } else if (keymatch(arg, "scale", 2)) {
+      /* Scale the output image by a fraction M/N. */
+      if (++argn >= argc)       /* advance to next argument */
+        usage();
+      if (sscanf(argv[argn], "%u/%u",
+                 &cinfo->scale_num, &cinfo->scale_denom) != 2)
+        usage();
+
+    } else if (keymatch(arg, "skip", 2)) {
+      if (++argn >= argc)
+        usage();
+      if (sscanf(argv[argn], "%u,%u", &skip_start, &skip_end) != 2 ||
+          skip_start > skip_end)
+        usage();
+      skip = TRUE;
+
+    } else if (keymatch(arg, "crop", 2)) {
+      char c;
+      if (++argn >= argc)
+        usage();
+      if (sscanf(argv[argn], "%u%c%u+%u+%u", &crop_width, &c, &crop_height,
+                 &crop_x, &crop_y) != 5 ||
+          (c != 'X' && c != 'x') || crop_width < 1 || crop_height < 1)
+        usage();
+      crop = TRUE;
+
+    } else if (keymatch(arg, "strict", 2)) {
+      strict = TRUE;
+
+    } else if (keymatch(arg, "targa", 1)) {
+      /* Targa output format. */
+      requested_fmt = FMT_TARGA;
+
+    } else {
+      usage();                  /* bogus switch */
+    }
+  }
+
+  return argn;                  /* return index of next arg (file name) */
+}
+
+
+/*
+ * Marker processor for COM and interesting APPn markers.
+ * This replaces the library's built-in processor, which just skips the marker.
+ * We want to print out the marker as text, to the extent possible.
+ * Note this code relies on a non-suspending data source.
+ */
+
+LOCAL(unsigned int)
+jpeg_getc(j_decompress_ptr cinfo)
+/* Read next byte */
+{
+  struct jpeg_source_mgr *datasrc = cinfo->src;
+
+  if (datasrc->bytes_in_buffer == 0) {
+    if (!(*datasrc->fill_input_buffer) (cinfo))
+      ERREXIT(cinfo, JERR_CANT_SUSPEND);
+  }
+  datasrc->bytes_in_buffer--;
+  return *datasrc->next_input_byte++;
+}
+
+
+METHODDEF(boolean)
+print_text_marker(j_decompress_ptr cinfo)
+{
+  boolean traceit = (cinfo->err->trace_level >= 1);
+  long length;
+  unsigned int ch;
+  unsigned int lastch = 0;
+
+  length = jpeg_getc(cinfo) << 8;
+  length += jpeg_getc(cinfo);
+  length -= 2;                  /* discount the length word itself */
+
+  if (traceit) {
+    if (cinfo->unread_marker == JPEG_COM)
+      fprintf(stderr, "Comment, length %ld:\n", (long)length);
+    else                        /* assume it is an APPn otherwise */
+      fprintf(stderr, "APP%d, length %ld:\n",
+              cinfo->unread_marker - JPEG_APP0, (long)length);
+  }
+
+  while (--length >= 0) {
+    ch = jpeg_getc(cinfo);
+    if (traceit) {
+      /* Emit the character in a readable form.
+       * Nonprintables are converted to \nnn form,
+       * while \ is converted to \\.
+       * Newlines in CR, CR/LF, or LF form will be printed as one newline.
+       */
+      if (ch == '\r') {
+        fprintf(stderr, "\n");
+      } else if (ch == '\n') {
+        if (lastch != '\r')
+          fprintf(stderr, "\n");
+      } else if (ch == '\\') {
+        fprintf(stderr, "\\\\");
+      } else if (isprint(ch)) {
+        putc(ch, stderr);
+      } else {
+        fprintf(stderr, "\\%03o", ch);
+      }
+      lastch = ch;
+    }
+  }
+
+  if (traceit)
+    fprintf(stderr, "\n");
+
+  return TRUE;
+}
+
+
+METHODDEF(void)
+my_emit_message(j_common_ptr cinfo, int msg_level)
+{
+  if (msg_level < 0) {
+    /* Treat warning as fatal */
+    cinfo->err->error_exit(cinfo);
+  } else {
+    if (cinfo->err->trace_level >= msg_level)
+      cinfo->err->output_message(cinfo);
+  }
+}
+
+
+/*
+ * The main program.
+ */
+
+int
+main(int argc, char **argv)
+{
+  struct jpeg_decompress_struct cinfo;
+  struct jpeg_error_mgr jerr;
+  struct cdjpeg_progress_mgr progress;
+  int file_index;
+  djpeg_dest_ptr dest_mgr = NULL;
+  FILE *input_file;
+  FILE *output_file;
+  unsigned char *inbuffer = NULL;
+#if JPEG_LIB_VERSION >= 80 || defined(MEM_SRCDST_SUPPORTED)
+  unsigned long insize = 0;
+#endif
+  JDIMENSION num_scanlines;
+
+  /* On Mac, fetch a command line. */
+#ifdef USE_CCOMMAND
+  argc = ccommand(&argv);
+#endif
+
+  progname = argv[0];
+  if (progname == NULL || progname[0] == 0)
+    progname = "djpeg";         /* in case C library doesn't provide it */
+
+  /* Initialize the JPEG decompression object with default error handling. */
+  cinfo.err = jpeg_std_error(&jerr);
+  jpeg_create_decompress(&cinfo);
+  /* Add some application-specific error messages (from cderror.h) */
+  jerr.addon_message_table = cdjpeg_message_table;
+  jerr.first_addon_message = JMSG_FIRSTADDONCODE;
+  jerr.last_addon_message = JMSG_LASTADDONCODE;
+
+  /* Insert custom marker processor for COM and APP12.
+   * APP12 is used by some digital camera makers for textual info,
+   * so we provide the ability to display it as text.
+   * If you like, additional APPn marker types can be selected for display,
+   * but don't try to override APP0 or APP14 this way (see libjpeg.txt).
+   */
+  jpeg_set_marker_processor(&cinfo, JPEG_COM, print_text_marker);
+  jpeg_set_marker_processor(&cinfo, JPEG_APP0 + 12, print_text_marker);
+
+  /* Scan command line to find file names. */
+  /* It is convenient to use just one switch-parsing routine, but the switch
+   * values read here are ignored; we will rescan the switches after opening
+   * the input file.
+   * (Exception: tracing level set here controls verbosity for COM markers
+   * found during jpeg_read_header...)
+   */
+
+  file_index = parse_switches(&cinfo, argc, argv, 0, FALSE);
+
+  if (strict)
+    jerr.emit_message = my_emit_message;
+
+#ifdef TWO_FILE_COMMANDLINE
+  /* Must have either -outfile switch or explicit output file name */
+  if (outfilename == NULL) {
+    if (file_index != argc - 2) {
+      fprintf(stderr, "%s: must name one input and one output file\n",
+              progname);
+      usage();
+    }
+    outfilename = argv[file_index + 1];
+  } else {
+    if (file_index != argc - 1) {
+      fprintf(stderr, "%s: must name one input and one output file\n",
+              progname);
+      usage();
+    }
+  }
+#else
+  /* Unix style: expect zero or one file name */
+  if (file_index < argc - 1) {
+    fprintf(stderr, "%s: only one input file\n", progname);
+    usage();
+  }
+#endif /* TWO_FILE_COMMANDLINE */
+
+  /* Open the input file. */
+  if (file_index < argc) {
+    if ((input_file = fopen(argv[file_index], READ_BINARY)) == NULL) {
+      fprintf(stderr, "%s: can't open %s\n", progname, argv[file_index]);
+      exit(EXIT_FAILURE);
+    }
+  } else {
+    /* default input file is stdin */
+    input_file = read_stdin();
+  }
+
+  /* Open the output file. */
+  if (outfilename != NULL) {
+    if ((output_file = fopen(outfilename, WRITE_BINARY)) == NULL) {
+      fprintf(stderr, "%s: can't open %s\n", progname, outfilename);
+      exit(EXIT_FAILURE);
+    }
+  } else {
+    /* default output file is stdout */
+    output_file = write_stdout();
+  }
+
+  if (report || max_scans != 0) {
+    start_progress_monitor((j_common_ptr)&cinfo, &progress);
+    progress.report = report;
+    progress.max_scans = max_scans;
+  }
+
+  /* Specify data source for decompression */
+#if JPEG_LIB_VERSION >= 80 || defined(MEM_SRCDST_SUPPORTED)
+  if (memsrc) {
+    size_t nbytes;
+    do {
+      inbuffer = (unsigned char *)realloc(inbuffer, insize + INPUT_BUF_SIZE);
+      if (inbuffer == NULL) {
+        fprintf(stderr, "%s: memory allocation failure\n", progname);
+        exit(EXIT_FAILURE);
+      }
+      nbytes = JFREAD(input_file, &inbuffer[insize], INPUT_BUF_SIZE);
+      if (nbytes < INPUT_BUF_SIZE && ferror(input_file)) {
+        if (file_index < argc)
+          fprintf(stderr, "%s: can't read from %s\n", progname,
+                  argv[file_index]);
+        else
+          fprintf(stderr, "%s: can't read from stdin\n", progname);
+      }
+      insize += (unsigned long)nbytes;
+    } while (nbytes == INPUT_BUF_SIZE);
+    fprintf(stderr, "Compressed size:  %lu bytes\n", insize);
+    jpeg_mem_src(&cinfo, inbuffer, insize);
+  } else
+#endif
+    jpeg_stdio_src(&cinfo, input_file);
+
+  /* Read file header, set default decompression parameters */
+  (void)jpeg_read_header(&cinfo, TRUE);
+
+  /* Adjust default decompression parameters by re-parsing the options */
+  file_index = parse_switches(&cinfo, argc, argv, 0, TRUE);
+
+  /* Initialize the output module now to let it override any crucial
+   * option settings (for instance, GIF wants to force color quantization).
+   */
+  switch (requested_fmt) {
+#ifdef BMP_SUPPORTED
+  case FMT_BMP:
+    dest_mgr = jinit_write_bmp(&cinfo, FALSE, TRUE);
+    break;
+  case FMT_OS2:
+    dest_mgr = jinit_write_bmp(&cinfo, TRUE, TRUE);
+    break;
+#endif
+#ifdef GIF_SUPPORTED
+  case FMT_GIF:
+    dest_mgr = jinit_write_gif(&cinfo, TRUE);
+    break;
+  case FMT_GIF0:
+    dest_mgr = jinit_write_gif(&cinfo, FALSE);
+    break;
+#endif
+#ifdef PPM_SUPPORTED
+  case FMT_PPM:
+    dest_mgr = jinit_write_ppm(&cinfo);
+    break;
+#endif
+#ifdef TARGA_SUPPORTED
+  case FMT_TARGA:
+    dest_mgr = jinit_write_targa(&cinfo);
+    break;
+#endif
+  default:
+    ERREXIT(&cinfo, JERR_UNSUPPORTED_FORMAT);
+    break;
+  }
+  dest_mgr->output_file = output_file;
+
+  /* Start decompressor */
+  (void)jpeg_start_decompress(&cinfo);
+
+  /* Skip rows */
+  if (skip) {
+    JDIMENSION tmp;
+
+    /* Check for valid skip_end.  We cannot check this value until after
+     * jpeg_start_decompress() is called.  Note that we have already verified
+     * that skip_start <= skip_end.
+     */
+    if (skip_end > cinfo.output_height - 1) {
+      fprintf(stderr, "%s: skip region exceeds image height %d\n", progname,
+              cinfo.output_height);
+      exit(EXIT_FAILURE);
+    }
+
+    /* Write output file header.  This is a hack to ensure that the destination
+     * manager creates an output image of the proper size.
+     */
+    tmp = cinfo.output_height;
+    cinfo.output_height -= (skip_end - skip_start + 1);
+    (*dest_mgr->start_output) (&cinfo, dest_mgr);
+    cinfo.output_height = tmp;
+
+    /* Process data */
+    while (cinfo.output_scanline < skip_start) {
+      num_scanlines = jpeg_read_scanlines(&cinfo, dest_mgr->buffer,
+                                          dest_mgr->buffer_height);
+      (*dest_mgr->put_pixel_rows) (&cinfo, dest_mgr, num_scanlines);
+    }
+    if ((tmp = jpeg_skip_scanlines(&cinfo, skip_end - skip_start + 1)) !=
+        skip_end - skip_start + 1) {
+      fprintf(stderr, "%s: jpeg_skip_scanlines() returned %d rather than %d\n",
+              progname, tmp, skip_end - skip_start + 1);
+      exit(EXIT_FAILURE);
+    }
+    while (cinfo.output_scanline < cinfo.output_height) {
+      num_scanlines = jpeg_read_scanlines(&cinfo, dest_mgr->buffer,
+                                          dest_mgr->buffer_height);
+      (*dest_mgr->put_pixel_rows) (&cinfo, dest_mgr, num_scanlines);
+    }
+
+  /* Decompress a subregion */
+  } else if (crop) {
+    JDIMENSION tmp;
+
+    /* Check for valid crop dimensions.  We cannot check these values until
+     * after jpeg_start_decompress() is called.
+     */
+    if (crop_x + crop_width > cinfo.output_width ||
+        crop_y + crop_height > cinfo.output_height) {
+      fprintf(stderr, "%s: crop dimensions exceed image dimensions %d x %d\n",
+              progname, cinfo.output_width, cinfo.output_height);
+      exit(EXIT_FAILURE);
+    }
+
+    jpeg_crop_scanline(&cinfo, &crop_x, &crop_width);
+    if (dest_mgr->calc_buffer_dimensions)
+      (*dest_mgr->calc_buffer_dimensions) (&cinfo, dest_mgr);
+    else
+      ERREXIT(&cinfo, JERR_UNSUPPORTED_FORMAT);
+
+    /* Write output file header.  This is a hack to ensure that the destination
+     * manager creates an output image of the proper size.
+     */
+    tmp = cinfo.output_height;
+    cinfo.output_height = crop_height;
+    (*dest_mgr->start_output) (&cinfo, dest_mgr);
+    cinfo.output_height = tmp;
+
+    /* Process data */
+    if ((tmp = jpeg_skip_scanlines(&cinfo, crop_y)) != crop_y) {
+      fprintf(stderr, "%s: jpeg_skip_scanlines() returned %d rather than %d\n",
+              progname, tmp, crop_y);
+      exit(EXIT_FAILURE);
+    }
+    while (cinfo.output_scanline < crop_y + crop_height) {
+      num_scanlines = jpeg_read_scanlines(&cinfo, dest_mgr->buffer,
+                                          dest_mgr->buffer_height);
+      (*dest_mgr->put_pixel_rows) (&cinfo, dest_mgr, num_scanlines);
+    }
+    if ((tmp =
+         jpeg_skip_scanlines(&cinfo,
+                             cinfo.output_height - crop_y - crop_height)) !=
+        cinfo.output_height - crop_y - crop_height) {
+      fprintf(stderr, "%s: jpeg_skip_scanlines() returned %d rather than %d\n",
+              progname, tmp, cinfo.output_height - crop_y - crop_height);
+      exit(EXIT_FAILURE);
+    }
+
+  /* Normal full-image decompress */
+  } else {
+    /* Write output file header */
+    (*dest_mgr->start_output) (&cinfo, dest_mgr);
+
+    /* Process data */
+    while (cinfo.output_scanline < cinfo.output_height) {
+      num_scanlines = jpeg_read_scanlines(&cinfo, dest_mgr->buffer,
+                                          dest_mgr->buffer_height);
+      (*dest_mgr->put_pixel_rows) (&cinfo, dest_mgr, num_scanlines);
+    }
+  }
+
+  /* Hack: count final pass as done in case finish_output does an extra pass.
+   * The library won't have updated completed_passes.
+   */
+  if (report || max_scans != 0)
+    progress.pub.completed_passes = progress.pub.total_passes;
+
+  if (icc_filename != NULL) {
+    FILE *icc_file;
+    JOCTET *icc_profile;
+    unsigned int icc_len;
+
+    if ((icc_file = fopen(icc_filename, WRITE_BINARY)) == NULL) {
+      fprintf(stderr, "%s: can't open %s\n", progname, icc_filename);
+      exit(EXIT_FAILURE);
+    }
+    if (jpeg_read_icc_profile(&cinfo, &icc_profile, &icc_len)) {
+      if (fwrite(icc_profile, icc_len, 1, icc_file) < 1) {
+        fprintf(stderr, "%s: can't read ICC profile from %s\n", progname,
+                icc_filename);
+        free(icc_profile);
+        fclose(icc_file);
+        exit(EXIT_FAILURE);
+      }
+      free(icc_profile);
+      fclose(icc_file);
+    } else if (cinfo.err->msg_code != JWRN_BOGUS_ICC)
+      fprintf(stderr, "%s: no ICC profile data in JPEG file\n", progname);
+  }
+
+  /* Finish decompression and release memory.
+   * I must do it in this order because output module has allocated memory
+   * of lifespan JPOOL_IMAGE; it needs to finish before releasing memory.
+   */
+  (*dest_mgr->finish_output) (&cinfo, dest_mgr);
+  (void)jpeg_finish_decompress(&cinfo);
+  jpeg_destroy_decompress(&cinfo);
+
+  /* Close files, if we opened them */
+  if (input_file != stdin)
+    fclose(input_file);
+  if (output_file != stdout)
+    fclose(output_file);
+
+  if (report || max_scans != 0)
+    end_progress_monitor((j_common_ptr)&cinfo);
+
+  if (memsrc)
+    free(inbuffer);
+
+  /* All done. */
+  exit(jerr.num_warnings ? EXIT_WARNING : EXIT_SUCCESS);
+  return 0;                     /* suppress no-return-value warnings */
+}
diff --git a/3rdparty/libjpeg/src/doc/html/annotated.html b/3rdparty/libjpeg/src/doc/html/annotated.html
new file mode 100644
index 00000000..08282d97
--- /dev/null
+++ b/3rdparty/libjpeg/src/doc/html/annotated.html
@@ -0,0 +1,83 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.8.20"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>TurboJPEG: Data Structures</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="search/search.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="search/searchdata.js"></script>
+<script type="text/javascript" src="search/search.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+  <td id="projectalign" style="padding-left: 0.5em;">
+   <div id="projectname">TurboJPEG
+   &#160;<span id="projectnumber">2.0</span>
+   </div>
+  </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.8.20 -->
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+var searchBox = new SearchBox("searchBox", "search",false,'Search');
+/* @license-end */
+</script>
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+  initMenu('',true,false,'search.php','Search');
+  $(document).ready(function() { init_search(); });
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<!-- window showing the filter options -->
+<div id="MSearchSelectWindow"
+     onmouseover="return searchBox.OnSearchSelectShow()"
+     onmouseout="return searchBox.OnSearchSelectHide()"
+     onkeydown="return searchBox.OnSearchSelectKey(event)">
+</div>
+
+<!-- iframe showing the search results (closed by default) -->
+<div id="MSearchResultsWindow">
+<iframe src="javascript:void(0)" frameborder="0" 
+        name="MSearchResults" id="MSearchResults">
+</iframe>
+</div>
+
+<div class="header">
+  <div class="headertitle">
+<div class="title">Data Structures</div>  </div>
+</div><!--header-->
+<div class="contents">
+<div class="textblock">Here are the data structures with brief descriptions:</div><div class="directory">
+<table class="directory">
+<tr id="row_0_" class="even"><td class="entry"><span style="width:16px;display:inline-block;">&#160;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="structtjregion.html" target="_self">tjregion</a></td><td class="desc">Cropping region </td></tr>
+<tr id="row_1_"><td class="entry"><span style="width:16px;display:inline-block;">&#160;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="structtjscalingfactor.html" target="_self">tjscalingfactor</a></td><td class="desc">Scaling factor </td></tr>
+<tr id="row_2_" class="even"><td class="entry"><span style="width:16px;display:inline-block;">&#160;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="structtjtransform.html" target="_self">tjtransform</a></td><td class="desc">Lossless transform </td></tr>
+</table>
+</div><!-- directory -->
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated by&#160;<a href="http://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.8.20
+</small></address>
+</body>
+</html>
diff --git a/3rdparty/libjpeg/src/doc/html/bc_s.png b/3rdparty/libjpeg/src/doc/html/bc_s.png
new file mode 100644
index 00000000..224b29aa
Binary files /dev/null and b/3rdparty/libjpeg/src/doc/html/bc_s.png differ
diff --git a/3rdparty/libjpeg/src/doc/html/bdwn.png b/3rdparty/libjpeg/src/doc/html/bdwn.png
new file mode 100644
index 00000000..940a0b95
Binary files /dev/null and b/3rdparty/libjpeg/src/doc/html/bdwn.png differ
diff --git a/3rdparty/libjpeg/src/doc/html/classes.html b/3rdparty/libjpeg/src/doc/html/classes.html
new file mode 100644
index 00000000..756dfa92
--- /dev/null
+++ b/3rdparty/libjpeg/src/doc/html/classes.html
@@ -0,0 +1,89 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.8.20"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>TurboJPEG: Data Structure Index</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="search/search.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="search/searchdata.js"></script>
+<script type="text/javascript" src="search/search.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+  <td id="projectalign" style="padding-left: 0.5em;">
+   <div id="projectname">TurboJPEG
+   &#160;<span id="projectnumber">2.0</span>
+   </div>
+  </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.8.20 -->
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+var searchBox = new SearchBox("searchBox", "search",false,'Search');
+/* @license-end */
+</script>
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+  initMenu('',true,false,'search.php','Search');
+  $(document).ready(function() { init_search(); });
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<!-- window showing the filter options -->
+<div id="MSearchSelectWindow"
+     onmouseover="return searchBox.OnSearchSelectShow()"
+     onmouseout="return searchBox.OnSearchSelectHide()"
+     onkeydown="return searchBox.OnSearchSelectKey(event)">
+</div>
+
+<!-- iframe showing the search results (closed by default) -->
+<div id="MSearchResultsWindow">
+<iframe src="javascript:void(0)" frameborder="0" 
+        name="MSearchResults" id="MSearchResults">
+</iframe>
+</div>
+
+<div class="header">
+  <div class="headertitle">
+<div class="title">Data Structure Index</div>  </div>
+</div><!--header-->
+<div class="contents">
+<div class="qindex"><a class="qindex" href="#letter_t">t</a></div>
+<table class="classindex">
+<tr><td rowspan="2" valign="bottom"><a name="letter_t"></a><table border="0" cellspacing="0" cellpadding="0"><tr><td><div class="ah">&#160;&#160;t&#160;&#160;</div></td></tr></table>
+</td>
+<td valign="top"><a class="el" href="structtjscalingfactor.html">tjscalingfactor</a>&#160;&#160;&#160;</td>
+<td valign="top"><a class="el" href="structtjtransform.html">tjtransform</a>&#160;&#160;&#160;</td>
+<td></td></tr>
+<tr><td></td><td></td><td></td></tr>
+<tr><td valign="top"><a class="el" href="structtjregion.html">tjregion</a>&#160;&#160;&#160;</td>
+<td></td><td></td><td></td></tr>
+<tr><td></td><td></td><td></td><td></td></tr>
+</table>
+<div class="qindex"><a class="qindex" href="#letter_t">t</a></div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated by&#160;<a href="http://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.8.20
+</small></address>
+</body>
+</html>
diff --git a/3rdparty/libjpeg/src/doc/html/closed.png b/3rdparty/libjpeg/src/doc/html/closed.png
new file mode 100644
index 00000000..98cc2c90
Binary files /dev/null and b/3rdparty/libjpeg/src/doc/html/closed.png differ
diff --git a/3rdparty/libjpeg/src/doc/html/doc.png b/3rdparty/libjpeg/src/doc/html/doc.png
new file mode 100644
index 00000000..17edabff
Binary files /dev/null and b/3rdparty/libjpeg/src/doc/html/doc.png differ
diff --git a/3rdparty/libjpeg/src/doc/html/doxygen-extra.css b/3rdparty/libjpeg/src/doc/html/doxygen-extra.css
new file mode 100644
index 00000000..f1bd4c26
--- /dev/null
+++ b/3rdparty/libjpeg/src/doc/html/doxygen-extra.css
@@ -0,0 +1,3 @@
+code {
+	color: #4665A2;
+}
diff --git a/3rdparty/libjpeg/src/doc/html/doxygen.css b/3rdparty/libjpeg/src/doc/html/doxygen.css
new file mode 100644
index 00000000..f640966e
--- /dev/null
+++ b/3rdparty/libjpeg/src/doc/html/doxygen.css
@@ -0,0 +1,1732 @@
+/* The standard CSS for doxygen 1.8.20 */
+
+body, table, div, p, dl {
+	font: 400 14px/22px Roboto,sans-serif;
+}
+
+p.reference, p.definition {
+	font: 400 14px/22px Roboto,sans-serif;
+}
+
+/* @group Heading Levels */
+
+h1.groupheader {
+	font-size: 150%;
+}
+
+.title {
+	font: 400 14px/28px Roboto,sans-serif;
+	font-size: 150%;
+	font-weight: bold;
+	margin: 10px 2px;
+}
+
+h2.groupheader {
+	border-bottom: 1px solid #879ECB;
+	color: #354C7B;
+	font-size: 150%;
+	font-weight: normal;
+	margin-top: 1.75em;
+	padding-top: 8px;
+	padding-bottom: 4px;
+	width: 100%;
+}
+
+h3.groupheader {
+	font-size: 100%;
+}
+
+h1, h2, h3, h4, h5, h6 {
+	-webkit-transition: text-shadow 0.5s linear;
+	-moz-transition: text-shadow 0.5s linear;
+	-ms-transition: text-shadow 0.5s linear;
+	-o-transition: text-shadow 0.5s linear;
+	transition: text-shadow 0.5s linear;
+	margin-right: 15px;
+}
+
+h1.glow, h2.glow, h3.glow, h4.glow, h5.glow, h6.glow {
+	text-shadow: 0 0 15px cyan;
+}
+
+dt {
+	font-weight: bold;
+}
+
+ul.multicol {
+	-moz-column-gap: 1em;
+	-webkit-column-gap: 1em;
+	column-gap: 1em;
+	-moz-column-count: 3;
+	-webkit-column-count: 3;
+	column-count: 3;
+}
+
+p.startli, p.startdd {
+	margin-top: 2px;
+}
+
+th p.starttd, th p.intertd, th p.endtd {
+        font-size: 100%;
+        font-weight: 700;
+}
+
+p.starttd {
+	margin-top: 0px;
+}
+
+p.endli {
+	margin-bottom: 0px;
+}
+
+p.enddd {
+	margin-bottom: 4px;
+}
+
+p.endtd {
+	margin-bottom: 2px;
+}
+
+p.interli {
+}
+
+p.interdd {
+}
+
+p.intertd {
+}
+
+/* @end */
+
+caption {
+	font-weight: bold;
+}
+
+span.legend {
+        font-size: 70%;
+        text-align: center;
+}
+
+h3.version {
+        font-size: 90%;
+        text-align: center;
+}
+
+div.qindex, div.navtab{
+	background-color: #EBEFF6;
+	border: 1px solid #A3B4D7;
+	text-align: center;
+}
+
+div.qindex, div.navpath {
+	width: 100%;
+	line-height: 140%;
+}
+
+div.navtab {
+	margin-right: 15px;
+}
+
+/* @group Link Styling */
+
+a {
+	color: #3D578C;
+	font-weight: normal;
+	text-decoration: none;
+}
+
+.contents a:visited {
+	color: #4665A2;
+}
+
+a:hover {
+	text-decoration: underline;
+}
+
+a.qindex {
+	font-weight: bold;
+}
+
+a.qindexHL {
+	font-weight: bold;
+	background-color: #9CAFD4;
+	color: #FFFFFF;
+	border: 1px double #869DCA;
+}
+
+.contents a.qindexHL:visited {
+        color: #FFFFFF;
+}
+
+a.el {
+	font-weight: bold;
+}
+
+a.elRef {
+}
+
+a.code, a.code:visited, a.line, a.line:visited {
+	color: #4665A2; 
+}
+
+a.codeRef, a.codeRef:visited, a.lineRef, a.lineRef:visited {
+	color: #4665A2; 
+}
+
+/* @end */
+
+dl.el {
+	margin-left: -1cm;
+}
+
+ul {
+  overflow: hidden; /*Fixed: list item bullets overlap floating elements*/
+}
+
+#side-nav ul {
+  overflow: visible; /* reset ul rule for scroll bar in GENERATE_TREEVIEW window */
+}
+
+#main-nav ul {
+  overflow: visible; /* reset ul rule for the navigation bar drop down lists */
+}
+
+.fragment {
+  text-align: left;
+  direction: ltr;
+  overflow-x: auto; /*Fixed: fragment lines overlap floating elements*/
+  overflow-y: hidden;
+}
+
+pre.fragment {
+        border: 1px solid #C4CFE5;
+        background-color: #FBFCFD;
+        padding: 4px 6px;
+        margin: 4px 8px 4px 2px;
+        overflow: auto;
+        word-wrap: break-word;
+        font-size:  9pt;
+        line-height: 125%;
+        font-family: monospace, fixed;
+        font-size: 105%;
+}
+
+div.fragment {
+  padding: 0 0 1px 0; /*Fixed: last line underline overlap border*/
+  margin: 4px 8px 4px 2px;
+	background-color: #FBFCFD;
+	border: 1px solid #C4CFE5;
+}
+
+div.line {
+	font-family: monospace, fixed;
+        font-size: 13px;
+	min-height: 13px;
+	line-height: 1.0;
+	text-wrap: unrestricted;
+	white-space: -moz-pre-wrap; /* Moz */
+	white-space: -pre-wrap;     /* Opera 4-6 */
+	white-space: -o-pre-wrap;   /* Opera 7 */
+	white-space: pre-wrap;      /* CSS3  */
+	word-wrap: break-word;      /* IE 5.5+ */
+	text-indent: -53px;
+	padding-left: 53px;
+	padding-bottom: 0px;
+	margin: 0px;
+	-webkit-transition-property: background-color, box-shadow;
+	-webkit-transition-duration: 0.5s;
+	-moz-transition-property: background-color, box-shadow;
+	-moz-transition-duration: 0.5s;
+	-ms-transition-property: background-color, box-shadow;
+	-ms-transition-duration: 0.5s;
+	-o-transition-property: background-color, box-shadow;
+	-o-transition-duration: 0.5s;
+	transition-property: background-color, box-shadow;
+	transition-duration: 0.5s;
+}
+
+div.line:after {
+    content:"\000A";
+    white-space: pre;
+}
+
+div.line.glow {
+	background-color: cyan;
+	box-shadow: 0 0 10px cyan;
+}
+
+
+span.lineno {
+	padding-right: 4px;
+	text-align: right;
+	border-right: 2px solid #0F0;
+	background-color: #E8E8E8;
+        white-space: pre;
+}
+span.lineno a {
+	background-color: #D8D8D8;
+}
+
+span.lineno a:hover {
+	background-color: #C8C8C8;
+}
+
+.lineno {
+	-webkit-touch-callout: none;
+	-webkit-user-select: none;
+	-khtml-user-select: none;
+	-moz-user-select: none;
+	-ms-user-select: none;
+	user-select: none;
+}
+
+div.ah, span.ah {
+	background-color: black;
+	font-weight: bold;
+	color: #FFFFFF;
+	margin-bottom: 3px;
+	margin-top: 3px;
+	padding: 0.2em;
+	border: solid thin #333;
+	border-radius: 0.5em;
+	-webkit-border-radius: .5em;
+	-moz-border-radius: .5em;
+	box-shadow: 2px 2px 3px #999;
+	-webkit-box-shadow: 2px 2px 3px #999;
+	-moz-box-shadow: rgba(0, 0, 0, 0.15) 2px 2px 2px;
+	background-image: -webkit-gradient(linear, left top, left bottom, from(#eee), to(#000),color-stop(0.3, #444));
+	background-image: -moz-linear-gradient(center top, #eee 0%, #444 40%, #000 110%);
+}
+
+div.classindex ul {
+        list-style: none;
+        padding-left: 0;
+}
+
+div.classindex span.ai {
+        display: inline-block;
+}
+
+div.groupHeader {
+	margin-left: 16px;
+	margin-top: 12px;
+	font-weight: bold;
+}
+
+div.groupText {
+	margin-left: 16px;
+	font-style: italic;
+}
+
+body {
+	background-color: white;
+	color: black;
+        margin: 0;
+}
+
+div.contents {
+	margin-top: 10px;
+	margin-left: 12px;
+	margin-right: 8px;
+}
+
+td.indexkey {
+	background-color: #EBEFF6;
+	font-weight: bold;
+	border: 1px solid #C4CFE5;
+	margin: 2px 0px 2px 0;
+	padding: 2px 10px;
+        white-space: nowrap;
+        vertical-align: top;
+}
+
+td.indexvalue {
+	background-color: #EBEFF6;
+	border: 1px solid #C4CFE5;
+	padding: 2px 10px;
+	margin: 2px 0px;
+}
+
+tr.memlist {
+	background-color: #EEF1F7;
+}
+
+p.formulaDsp {
+	text-align: center;
+}
+
+img.formulaDsp {
+	
+}
+
+img.formulaInl, img.inline {
+	vertical-align: middle;
+}
+
+div.center {
+	text-align: center;
+        margin-top: 0px;
+        margin-bottom: 0px;
+        padding: 0px;
+}
+
+div.center img {
+	border: 0px;
+}
+
+address.footer {
+	text-align: right;
+	padding-right: 12px;
+}
+
+img.footer {
+	border: 0px;
+	vertical-align: middle;
+}
+
+/* @group Code Colorization */
+
+span.keyword {
+	color: #008000
+}
+
+span.keywordtype {
+	color: #604020
+}
+
+span.keywordflow {
+	color: #e08000
+}
+
+span.comment {
+	color: #800000
+}
+
+span.preprocessor {
+	color: #806020
+}
+
+span.stringliteral {
+	color: #002080
+}
+
+span.charliteral {
+	color: #008080
+}
+
+span.vhdldigit { 
+	color: #ff00ff 
+}
+
+span.vhdlchar { 
+	color: #000000 
+}
+
+span.vhdlkeyword { 
+	color: #700070 
+}
+
+span.vhdllogic { 
+	color: #ff0000 
+}
+
+blockquote {
+        background-color: #F7F8FB;
+        border-left: 2px solid #9CAFD4;
+        margin: 0 24px 0 4px;
+        padding: 0 12px 0 16px;
+}
+
+blockquote.DocNodeRTL {
+   border-left: 0;
+   border-right: 2px solid #9CAFD4;
+   margin: 0 4px 0 24px;
+   padding: 0 16px 0 12px;
+}
+
+/* @end */
+
+/*
+.search {
+	color: #003399;
+	font-weight: bold;
+}
+
+form.search {
+	margin-bottom: 0px;
+	margin-top: 0px;
+}
+
+input.search {
+	font-size: 75%;
+	color: #000080;
+	font-weight: normal;
+	background-color: #e8eef2;
+}
+*/
+
+td.tiny {
+	font-size: 75%;
+}
+
+.dirtab {
+	padding: 4px;
+	border-collapse: collapse;
+	border: 1px solid #A3B4D7;
+}
+
+th.dirtab {
+	background: #EBEFF6;
+	font-weight: bold;
+}
+
+hr {
+	height: 0px;
+	border: none;
+	border-top: 1px solid #4A6AAA;
+}
+
+hr.footer {
+	height: 1px;
+}
+
+/* @group Member Descriptions */
+
+table.memberdecls {
+	border-spacing: 0px;
+	padding: 0px;
+}
+
+.memberdecls td, .fieldtable tr {
+	-webkit-transition-property: background-color, box-shadow;
+	-webkit-transition-duration: 0.5s;
+	-moz-transition-property: background-color, box-shadow;
+	-moz-transition-duration: 0.5s;
+	-ms-transition-property: background-color, box-shadow;
+	-ms-transition-duration: 0.5s;
+	-o-transition-property: background-color, box-shadow;
+	-o-transition-duration: 0.5s;
+	transition-property: background-color, box-shadow;
+	transition-duration: 0.5s;
+}
+
+.memberdecls td.glow, .fieldtable tr.glow {
+	background-color: cyan;
+	box-shadow: 0 0 15px cyan;
+}
+
+.mdescLeft, .mdescRight,
+.memItemLeft, .memItemRight,
+.memTemplItemLeft, .memTemplItemRight, .memTemplParams {
+	background-color: #F9FAFC;
+	border: none;
+	margin: 4px;
+	padding: 1px 0 0 8px;
+}
+
+.mdescLeft, .mdescRight {
+	padding: 0px 8px 4px 8px;
+	color: #555;
+}
+
+.memSeparator {
+        border-bottom: 1px solid #DEE4F0;
+        line-height: 1px;
+        margin: 0px;
+        padding: 0px;
+}
+
+.memItemLeft, .memTemplItemLeft {
+        white-space: nowrap;
+}
+
+.memItemRight, .memTemplItemRight {
+	width: 100%;
+}
+
+.memTemplParams {
+	color: #4665A2;
+        white-space: nowrap;
+	font-size: 80%;
+}
+
+/* @end */
+
+/* @group Member Details */
+
+/* Styles for detailed member documentation */
+
+.memtitle {
+	padding: 8px;
+	border-top: 1px solid #A8B8D9;
+	border-left: 1px solid #A8B8D9;
+	border-right: 1px solid #A8B8D9;
+	border-top-right-radius: 4px;
+	border-top-left-radius: 4px;
+	margin-bottom: -1px;
+	background-image: url('nav_f.png');
+	background-repeat: repeat-x;
+	background-color: #E2E8F2;
+	line-height: 1.25;
+	font-weight: 300;
+	float:left;
+}
+
+.permalink
+{
+        font-size: 65%;
+        display: inline-block;
+        vertical-align: middle;
+}
+
+.memtemplate {
+	font-size: 80%;
+	color: #4665A2;
+	font-weight: normal;
+	margin-left: 9px;
+}
+
+.memnav {
+	background-color: #EBEFF6;
+	border: 1px solid #A3B4D7;
+	text-align: center;
+	margin: 2px;
+	margin-right: 15px;
+	padding: 2px;
+}
+
+.mempage {
+	width: 100%;
+}
+
+.memitem {
+	padding: 0;
+	margin-bottom: 10px;
+	margin-right: 5px;
+        -webkit-transition: box-shadow 0.5s linear;
+        -moz-transition: box-shadow 0.5s linear;
+        -ms-transition: box-shadow 0.5s linear;
+        -o-transition: box-shadow 0.5s linear;
+        transition: box-shadow 0.5s linear;
+        display: table !important;
+        width: 100%;
+}
+
+.memitem.glow {
+         box-shadow: 0 0 15px cyan;
+}
+
+.memname {
+        font-weight: 400;
+        margin-left: 6px;
+}
+
+.memname td {
+	vertical-align: bottom;
+}
+
+.memproto, dl.reflist dt {
+        border-top: 1px solid #A8B8D9;
+        border-left: 1px solid #A8B8D9;
+        border-right: 1px solid #A8B8D9;
+        padding: 6px 0px 6px 0px;
+        color: #253555;
+        font-weight: bold;
+        text-shadow: 0px 1px 1px rgba(255, 255, 255, 0.9);
+        background-color: #DFE5F1;
+        /* opera specific markup */
+        box-shadow: 5px 5px 5px rgba(0, 0, 0, 0.15);
+        border-top-right-radius: 4px;
+        /* firefox specific markup */
+        -moz-box-shadow: rgba(0, 0, 0, 0.15) 5px 5px 5px;
+        -moz-border-radius-topright: 4px;
+        /* webkit specific markup */
+        -webkit-box-shadow: 5px 5px 5px rgba(0, 0, 0, 0.15);
+        -webkit-border-top-right-radius: 4px;
+
+}
+
+.overload {
+        font-family: "courier new",courier,monospace;
+	font-size: 65%;
+}
+
+.memdoc, dl.reflist dd {
+        border-bottom: 1px solid #A8B8D9;      
+        border-left: 1px solid #A8B8D9;      
+        border-right: 1px solid #A8B8D9; 
+        padding: 6px 10px 2px 10px;
+        background-color: #FBFCFD;
+        border-top-width: 0;
+        background-image:url('nav_g.png');
+        background-repeat:repeat-x;
+        background-color: #FFFFFF;
+        /* opera specific markup */
+        border-bottom-left-radius: 4px;
+        border-bottom-right-radius: 4px;
+        box-shadow: 5px 5px 5px rgba(0, 0, 0, 0.15);
+        /* firefox specific markup */
+        -moz-border-radius-bottomleft: 4px;
+        -moz-border-radius-bottomright: 4px;
+        -moz-box-shadow: rgba(0, 0, 0, 0.15) 5px 5px 5px;
+        /* webkit specific markup */
+        -webkit-border-bottom-left-radius: 4px;
+        -webkit-border-bottom-right-radius: 4px;
+        -webkit-box-shadow: 5px 5px 5px rgba(0, 0, 0, 0.15);
+}
+
+dl.reflist dt {
+        padding: 5px;
+}
+
+dl.reflist dd {
+        margin: 0px 0px 10px 0px;
+        padding: 5px;
+}
+
+.paramkey {
+	text-align: right;
+}
+
+.paramtype {
+	white-space: nowrap;
+}
+
+.paramname {
+	color: #602020;
+	white-space: nowrap;
+}
+.paramname em {
+	font-style: normal;
+}
+.paramname code {
+        line-height: 14px;
+}
+
+.params, .retval, .exception, .tparams {
+        margin-left: 0px;
+        padding-left: 0px;
+}       
+
+.params .paramname, .retval .paramname, .tparams .paramname, .exception .paramname {
+        font-weight: bold;
+        vertical-align: top;
+}
+        
+.params .paramtype, .tparams .paramtype {
+        font-style: italic;
+        vertical-align: top;
+}       
+        
+.params .paramdir, .tparams .paramdir {
+        font-family: "courier new",courier,monospace;
+        vertical-align: top;
+}
+
+table.mlabels {
+	border-spacing: 0px;
+}
+
+td.mlabels-left {
+	width: 100%;
+	padding: 0px;
+}
+
+td.mlabels-right {
+	vertical-align: bottom;
+	padding: 0px;
+	white-space: nowrap;
+}
+
+span.mlabels {
+        margin-left: 8px;
+}
+
+span.mlabel {
+        background-color: #728DC1;
+        border-top:1px solid #5373B4;
+        border-left:1px solid #5373B4;
+        border-right:1px solid #C4CFE5;
+        border-bottom:1px solid #C4CFE5;
+	text-shadow: none;
+	color: white;
+	margin-right: 4px;
+	padding: 2px 3px;
+	border-radius: 3px;
+	font-size: 7pt;
+	white-space: nowrap;
+	vertical-align: middle;
+}
+
+
+
+/* @end */
+
+/* these are for tree view inside a (index) page */
+
+div.directory {
+        margin: 10px 0px;
+        border-top: 1px solid #9CAFD4;
+        border-bottom: 1px solid #9CAFD4;
+        width: 100%;
+}
+
+.directory table {
+        border-collapse:collapse;
+}
+
+.directory td {
+        margin: 0px;
+        padding: 0px;
+	vertical-align: top;
+}
+
+.directory td.entry {
+        white-space: nowrap;
+        padding-right: 6px;
+	padding-top: 3px;
+}
+
+.directory td.entry a {
+        outline:none;
+}
+
+.directory td.entry a img {
+        border: none;
+}
+
+.directory td.desc {
+        width: 100%;
+        padding-left: 6px;
+	padding-right: 6px;
+	padding-top: 3px;
+	border-left: 1px solid rgba(0,0,0,0.05);
+}
+
+.directory tr.even {
+	padding-left: 6px;
+	background-color: #F7F8FB;
+}
+
+.directory img {
+	vertical-align: -30%;
+}
+
+.directory .levels {
+        white-space: nowrap;
+        width: 100%;
+        text-align: right;
+        font-size: 9pt;
+}
+
+.directory .levels span {
+        cursor: pointer;
+        padding-left: 2px;
+        padding-right: 2px;
+	color: #3D578C;
+}
+
+.arrow {
+    color: #9CAFD4;
+    -webkit-user-select: none;
+    -khtml-user-select: none;
+    -moz-user-select: none;
+    -ms-user-select: none;
+    user-select: none;
+    cursor: pointer;
+    font-size: 80%;
+    display: inline-block;
+    width: 16px;
+    height: 22px;
+}
+
+.icon {
+    font-family: Arial, Helvetica;
+    font-weight: bold;
+    font-size: 12px;
+    height: 14px;
+    width: 16px;
+    display: inline-block;
+    background-color: #728DC1;
+    color: white;
+    text-align: center;
+    border-radius: 4px;
+    margin-left: 2px;
+    margin-right: 2px;
+}
+
+.icona {
+    width: 24px;
+    height: 22px;
+    display: inline-block;
+}
+
+.iconfopen {
+    width: 24px;
+    height: 18px;
+    margin-bottom: 4px;
+    background-image:url('folderopen.png');
+    background-position: 0px -4px;
+    background-repeat: repeat-y;
+    vertical-align:top;
+    display: inline-block;
+}
+
+.iconfclosed {
+    width: 24px;
+    height: 18px;
+    margin-bottom: 4px;
+    background-image:url('folderclosed.png');
+    background-position: 0px -4px;
+    background-repeat: repeat-y;
+    vertical-align:top;
+    display: inline-block;
+}
+
+.icondoc {
+    width: 24px;
+    height: 18px;
+    margin-bottom: 4px;
+    background-image:url('doc.png');
+    background-position: 0px -4px;
+    background-repeat: repeat-y;
+    vertical-align:top;
+    display: inline-block;
+}
+
+table.directory {
+    font: 400 14px Roboto,sans-serif;
+}
+
+/* @end */
+
+div.dynheader {
+        margin-top: 8px;
+	-webkit-touch-callout: none;
+	-webkit-user-select: none;
+	-khtml-user-select: none;
+	-moz-user-select: none;
+	-ms-user-select: none;
+	user-select: none;
+}
+
+address {
+	font-style: normal;
+	color: #2A3D61;
+}
+
+table.doxtable caption {
+	caption-side: top;
+}
+
+table.doxtable {
+	border-collapse:collapse;
+        margin-top: 4px;
+        margin-bottom: 4px;
+}
+
+table.doxtable td, table.doxtable th {
+	border: 1px solid #2D4068;
+	padding: 3px 7px 2px;
+}
+
+table.doxtable th {
+	background-color: #374F7F;
+	color: #FFFFFF;
+	font-size: 110%;
+	padding-bottom: 4px;
+	padding-top: 5px;
+}
+
+table.fieldtable {
+        /*width: 100%;*/
+        margin-bottom: 10px;
+        border: 1px solid #A8B8D9;
+        border-spacing: 0px;
+        -moz-border-radius: 4px;
+        -webkit-border-radius: 4px;
+        border-radius: 4px;
+        -moz-box-shadow: rgba(0, 0, 0, 0.15) 2px 2px 2px;
+        -webkit-box-shadow: 2px 2px 2px rgba(0, 0, 0, 0.15);
+        box-shadow: 2px 2px 2px rgba(0, 0, 0, 0.15);
+}
+
+.fieldtable td, .fieldtable th {
+        padding: 3px 7px 2px;
+}
+
+.fieldtable td.fieldtype, .fieldtable td.fieldname {
+        white-space: nowrap;
+        border-right: 1px solid #A8B8D9;
+        border-bottom: 1px solid #A8B8D9;
+        vertical-align: top;
+}
+
+.fieldtable td.fieldname {
+        padding-top: 3px;
+}
+
+.fieldtable td.fielddoc {
+        border-bottom: 1px solid #A8B8D9;
+        /*width: 100%;*/
+}
+
+.fieldtable td.fielddoc p:first-child {
+        margin-top: 0px;
+}       
+        
+.fieldtable td.fielddoc p:last-child {
+        margin-bottom: 2px;
+}
+
+.fieldtable tr:last-child td {
+        border-bottom: none;
+}
+
+.fieldtable th {
+        background-image:url('nav_f.png');
+        background-repeat:repeat-x;
+        background-color: #E2E8F2;
+        font-size: 90%;
+        color: #253555;
+        padding-bottom: 4px;
+        padding-top: 5px;
+        text-align:left;
+        font-weight: 400;
+        -moz-border-radius-topleft: 4px;
+        -moz-border-radius-topright: 4px;
+        -webkit-border-top-left-radius: 4px;
+        -webkit-border-top-right-radius: 4px;
+        border-top-left-radius: 4px;
+        border-top-right-radius: 4px;
+        border-bottom: 1px solid #A8B8D9;
+}
+
+
+.tabsearch {
+	top: 0px;
+	left: 10px;
+	height: 36px;
+	background-image: url('tab_b.png');
+	z-index: 101;
+	overflow: hidden;
+	font-size: 13px;
+}
+
+.navpath ul
+{
+	font-size: 11px;
+	background-image:url('tab_b.png');
+	background-repeat:repeat-x;
+	background-position: 0 -5px;
+	height:30px;
+	line-height:30px;
+	color:#8AA0CC;
+	border:solid 1px #C2CDE4;
+	overflow:hidden;
+	margin:0px;
+	padding:0px;
+}
+
+.navpath li
+{
+	list-style-type:none;
+	float:left;
+	padding-left:10px;
+	padding-right:15px;
+	background-image:url('bc_s.png');
+	background-repeat:no-repeat;
+	background-position:right;
+	color:#364D7C;
+}
+
+.navpath li.navelem a
+{
+	height:32px;
+	display:block;
+	text-decoration: none;
+	outline: none;
+	color: #283A5D;
+	font-family: 'Lucida Grande',Geneva,Helvetica,Arial,sans-serif;
+	text-shadow: 0px 1px 1px rgba(255, 255, 255, 0.9);
+	text-decoration: none;        
+}
+
+.navpath li.navelem a:hover
+{
+	color:#6884BD;
+}
+
+.navpath li.footer
+{
+        list-style-type:none;
+        float:right;
+        padding-left:10px;
+        padding-right:15px;
+        background-image:none;
+        background-repeat:no-repeat;
+        background-position:right;
+        color:#364D7C;
+        font-size: 8pt;
+}
+
+
+div.summary
+{
+	float: right;
+	font-size: 8pt;
+	padding-right: 5px;
+	width: 50%;
+	text-align: right;
+}       
+
+div.summary a
+{
+	white-space: nowrap;
+}
+
+table.classindex
+{
+        margin: 10px;
+        white-space: nowrap;
+        margin-left: 3%;
+        margin-right: 3%;
+        width: 94%;
+        border: 0;
+        border-spacing: 0; 
+        padding: 0;
+}
+
+div.ingroups
+{
+	font-size: 8pt;
+	width: 50%;
+	text-align: left;
+}
+
+div.ingroups a
+{
+	white-space: nowrap;
+}
+
+div.header
+{
+        background-image:url('nav_h.png');
+        background-repeat:repeat-x;
+	background-color: #F9FAFC;
+	margin:  0px;
+	border-bottom: 1px solid #C4CFE5;
+}
+
+div.headertitle
+{
+	padding: 5px 5px 5px 10px;
+}
+
+.PageDocRTL-title div.headertitle {
+  text-align: right;
+  direction: rtl;
+}
+
+dl {
+        padding: 0 0 0 0;
+}
+
+/* dl.note, dl.warning, dl.attention, dl.pre, dl.post, dl.invariant, dl.deprecated, dl.todo, dl.test, dl.bug, dl.examples */
+dl.section {
+	margin-left: 0px;
+	padding-left: 0px;
+}
+
+dl.section.DocNodeRTL {
+  margin-right: 0px;
+  padding-right: 0px;
+}
+
+dl.note {
+  margin-left: -7px;
+  padding-left: 3px;
+  border-left: 4px solid;
+  border-color: #D0C000;
+}
+
+dl.note.DocNodeRTL {
+  margin-left: 0;
+  padding-left: 0;
+  border-left: 0;
+  margin-right: -7px;
+  padding-right: 3px;
+  border-right: 4px solid;
+  border-color: #D0C000;
+}
+
+dl.warning, dl.attention {
+  margin-left: -7px;
+  padding-left: 3px;
+  border-left: 4px solid;
+  border-color: #FF0000;
+}
+
+dl.warning.DocNodeRTL, dl.attention.DocNodeRTL {
+  margin-left: 0;
+  padding-left: 0;
+  border-left: 0;
+  margin-right: -7px;
+  padding-right: 3px;
+  border-right: 4px solid;
+  border-color: #FF0000;
+}
+
+dl.pre, dl.post, dl.invariant {
+  margin-left: -7px;
+  padding-left: 3px;
+  border-left: 4px solid;
+  border-color: #00D000;
+}
+
+dl.pre.DocNodeRTL, dl.post.DocNodeRTL, dl.invariant.DocNodeRTL {
+  margin-left: 0;
+  padding-left: 0;
+  border-left: 0;
+  margin-right: -7px;
+  padding-right: 3px;
+  border-right: 4px solid;
+  border-color: #00D000;
+}
+
+dl.deprecated {
+  margin-left: -7px;
+  padding-left: 3px;
+  border-left: 4px solid;
+  border-color: #505050;
+}
+
+dl.deprecated.DocNodeRTL {
+  margin-left: 0;
+  padding-left: 0;
+  border-left: 0;
+  margin-right: -7px;
+  padding-right: 3px;
+  border-right: 4px solid;
+  border-color: #505050;
+}
+
+dl.todo {
+  margin-left: -7px;
+  padding-left: 3px;
+  border-left: 4px solid;
+  border-color: #00C0E0;
+}
+
+dl.todo.DocNodeRTL {
+  margin-left: 0;
+  padding-left: 0;
+  border-left: 0;
+  margin-right: -7px;
+  padding-right: 3px;
+  border-right: 4px solid;
+  border-color: #00C0E0;
+}
+
+dl.test {
+  margin-left: -7px;
+  padding-left: 3px;
+  border-left: 4px solid;
+  border-color: #3030E0;
+}
+
+dl.test.DocNodeRTL {
+  margin-left: 0;
+  padding-left: 0;
+  border-left: 0;
+  margin-right: -7px;
+  padding-right: 3px;
+  border-right: 4px solid;
+  border-color: #3030E0;
+}
+
+dl.bug {
+  margin-left: -7px;
+  padding-left: 3px;
+  border-left: 4px solid;
+  border-color: #C08050;
+}
+
+dl.bug.DocNodeRTL {
+  margin-left: 0;
+  padding-left: 0;
+  border-left: 0;
+  margin-right: -7px;
+  padding-right: 3px;
+  border-right: 4px solid;
+  border-color: #C08050;
+}
+
+dl.section dd {
+	margin-bottom: 6px;
+}
+
+
+#projectlogo
+{
+	text-align: center;
+	vertical-align: bottom;
+	border-collapse: separate;
+}
+ 
+#projectlogo img
+{ 
+	border: 0px none;
+}
+ 
+#projectalign
+{
+        vertical-align: middle;
+}
+
+#projectname
+{
+	font: 300% Tahoma, Arial,sans-serif;
+	margin: 0px;
+	padding: 2px 0px;
+}
+    
+#projectbrief
+{
+	font: 120% Tahoma, Arial,sans-serif;
+	margin: 0px;
+	padding: 0px;
+}
+
+#projectnumber
+{
+	font: 50% Tahoma, Arial,sans-serif;
+	margin: 0px;
+	padding: 0px;
+}
+
+#titlearea
+{
+	padding: 0px;
+	margin: 0px;
+	width: 100%;
+	border-bottom: 1px solid #5373B4;
+}
+
+.image
+{
+        text-align: center;
+}
+
+.dotgraph
+{
+        text-align: center;
+}
+
+.mscgraph
+{
+        text-align: center;
+}
+
+.plantumlgraph
+{
+        text-align: center;
+}
+
+.diagraph
+{
+        text-align: center;
+}
+
+.caption
+{
+	font-weight: bold;
+}
+
+div.zoom
+{
+	border: 1px solid #90A5CE;
+}
+
+dl.citelist {
+        margin-bottom:50px;
+}
+
+dl.citelist dt {
+        color:#334975;
+        float:left;
+        font-weight:bold;
+        margin-right:10px;
+        padding:5px;
+        text-align:right;
+        width:52px;
+}
+
+dl.citelist dd {
+        margin:2px 0 2px 72px;
+        padding:5px 0;
+}
+
+div.toc {
+        padding: 14px 25px;
+        background-color: #F4F6FA;
+        border: 1px solid #D8DFEE;
+        border-radius: 7px 7px 7px 7px;
+        float: right;
+        height: auto;
+        margin: 0 8px 10px 10px;
+        width: 200px;
+}
+
+.PageDocRTL-title div.toc {
+  float: left !important;
+  text-align: right;
+}
+
+div.toc li {
+        background: url("bdwn.png") no-repeat scroll 0 5px transparent;
+        font: 10px/1.2 Verdana,DejaVu Sans,Geneva,sans-serif;
+        margin-top: 5px;
+        padding-left: 10px;
+        padding-top: 2px;
+}
+
+.PageDocRTL-title div.toc li {
+  background-position-x: right !important;
+  padding-left: 0 !important;
+  padding-right: 10px;
+}
+
+div.toc h3 {
+        font: bold 12px/1.2 Arial,FreeSans,sans-serif;
+	color: #4665A2;
+        border-bottom: 0 none;
+        margin: 0;
+}
+
+div.toc ul {
+        list-style: none outside none;
+        border: medium none;
+        padding: 0px;
+}       
+
+div.toc li.level1 {
+        margin-left: 0px;
+}
+
+div.toc li.level2 {
+        margin-left: 15px;
+}
+
+div.toc li.level3 {
+        margin-left: 30px;
+}
+
+div.toc li.level4 {
+        margin-left: 45px;
+}
+
+.PageDocRTL-title div.toc li.level1 {
+  margin-left: 0 !important;
+  margin-right: 0;
+}
+
+.PageDocRTL-title div.toc li.level2 {
+  margin-left: 0 !important;
+  margin-right: 15px;
+}
+
+.PageDocRTL-title div.toc li.level3 {
+  margin-left: 0 !important;
+  margin-right: 30px;
+}
+
+.PageDocRTL-title div.toc li.level4 {
+  margin-left: 0 !important;
+  margin-right: 45px;
+}
+
+.inherit_header {
+        font-weight: bold;
+        color: gray;
+        cursor: pointer;
+	-webkit-touch-callout: none;
+	-webkit-user-select: none;
+	-khtml-user-select: none;
+	-moz-user-select: none;
+	-ms-user-select: none;
+	user-select: none;
+}
+
+.inherit_header td {
+        padding: 6px 0px 2px 5px;
+}
+
+.inherit {
+        display: none;
+}
+
+tr.heading h2 {
+        margin-top: 12px;
+        margin-bottom: 4px;
+}
+
+/* tooltip related style info */
+
+.ttc {
+        position: absolute;
+        display: none;
+}
+
+#powerTip {
+	cursor: default;
+	white-space: nowrap;
+	background-color: white;
+	border: 1px solid gray;
+	border-radius: 4px 4px 4px 4px;
+	box-shadow: 1px 1px 7px gray;
+	display: none;
+	font-size: smaller;
+	max-width: 80%;
+	opacity: 0.9;
+	padding: 1ex 1em 1em;
+	position: absolute;
+	z-index: 2147483647;
+}
+
+#powerTip div.ttdoc {
+        color: grey;
+	font-style: italic;
+}
+
+#powerTip div.ttname a {
+        font-weight: bold;
+}
+
+#powerTip div.ttname {
+        font-weight: bold;
+}
+
+#powerTip div.ttdeci {
+        color: #006318;
+}
+
+#powerTip div {
+        margin: 0px;
+        padding: 0px;
+        font: 12px/16px Roboto,sans-serif;
+}
+
+#powerTip:before, #powerTip:after {
+	content: "";
+	position: absolute;
+	margin: 0px;
+}
+
+#powerTip.n:after,  #powerTip.n:before,
+#powerTip.s:after,  #powerTip.s:before,
+#powerTip.w:after,  #powerTip.w:before,
+#powerTip.e:after,  #powerTip.e:before,
+#powerTip.ne:after, #powerTip.ne:before,
+#powerTip.se:after, #powerTip.se:before,
+#powerTip.nw:after, #powerTip.nw:before,
+#powerTip.sw:after, #powerTip.sw:before {
+	border: solid transparent;
+	content: " ";
+	height: 0;
+	width: 0;
+	position: absolute;
+}
+
+#powerTip.n:after,  #powerTip.s:after,
+#powerTip.w:after,  #powerTip.e:after,
+#powerTip.nw:after, #powerTip.ne:after,
+#powerTip.sw:after, #powerTip.se:after {
+	border-color: rgba(255, 255, 255, 0);
+}
+
+#powerTip.n:before,  #powerTip.s:before,
+#powerTip.w:before,  #powerTip.e:before,
+#powerTip.nw:before, #powerTip.ne:before,
+#powerTip.sw:before, #powerTip.se:before {
+	border-color: rgba(128, 128, 128, 0);
+}
+
+#powerTip.n:after,  #powerTip.n:before,
+#powerTip.ne:after, #powerTip.ne:before,
+#powerTip.nw:after, #powerTip.nw:before {
+	top: 100%;
+}
+
+#powerTip.n:after, #powerTip.ne:after, #powerTip.nw:after {
+	border-top-color: #FFFFFF;
+	border-width: 10px;
+	margin: 0px -10px;
+}
+#powerTip.n:before {
+	border-top-color: #808080;
+	border-width: 11px;
+	margin: 0px -11px;
+}
+#powerTip.n:after, #powerTip.n:before {
+	left: 50%;
+}
+
+#powerTip.nw:after, #powerTip.nw:before {
+	right: 14px;
+}
+
+#powerTip.ne:after, #powerTip.ne:before {
+	left: 14px;
+}
+
+#powerTip.s:after,  #powerTip.s:before,
+#powerTip.se:after, #powerTip.se:before,
+#powerTip.sw:after, #powerTip.sw:before {
+	bottom: 100%;
+}
+
+#powerTip.s:after, #powerTip.se:after, #powerTip.sw:after {
+	border-bottom-color: #FFFFFF;
+	border-width: 10px;
+	margin: 0px -10px;
+}
+
+#powerTip.s:before, #powerTip.se:before, #powerTip.sw:before {
+	border-bottom-color: #808080;
+	border-width: 11px;
+	margin: 0px -11px;
+}
+
+#powerTip.s:after, #powerTip.s:before {
+	left: 50%;
+}
+
+#powerTip.sw:after, #powerTip.sw:before {
+	right: 14px;
+}
+
+#powerTip.se:after, #powerTip.se:before {
+	left: 14px;
+}
+
+#powerTip.e:after, #powerTip.e:before {
+	left: 100%;
+}
+#powerTip.e:after {
+	border-left-color: #FFFFFF;
+	border-width: 10px;
+	top: 50%;
+	margin-top: -10px;
+}
+#powerTip.e:before {
+	border-left-color: #808080;
+	border-width: 11px;
+	top: 50%;
+	margin-top: -11px;
+}
+
+#powerTip.w:after, #powerTip.w:before {
+	right: 100%;
+}
+#powerTip.w:after {
+	border-right-color: #FFFFFF;
+	border-width: 10px;
+	top: 50%;
+	margin-top: -10px;
+}
+#powerTip.w:before {
+	border-right-color: #808080;
+	border-width: 11px;
+	top: 50%;
+	margin-top: -11px;
+}
+
+@media print
+{
+  #top { display: none; }
+  #side-nav { display: none; }
+  #nav-path { display: none; }
+  body { overflow:visible; }
+  h1, h2, h3, h4, h5, h6 { page-break-after: avoid; }
+  .summary { display: none; }
+  .memitem { page-break-inside: avoid; }
+  #doc-content
+  {
+    margin-left:0 !important;
+    height:auto !important;
+    width:auto !important;
+    overflow:inherit;
+    display:inline;
+  }
+}
+
+/* @group Markdown */
+
+table.markdownTable {
+	border-collapse:collapse;
+        margin-top: 4px;
+        margin-bottom: 4px;
+}
+
+table.markdownTable td, table.markdownTable th {
+	border: 1px solid #2D4068;
+	padding: 3px 7px 2px;
+}
+
+table.markdownTable tr {
+}
+
+th.markdownTableHeadLeft, th.markdownTableHeadRight, th.markdownTableHeadCenter, th.markdownTableHeadNone {
+	background-color: #374F7F;
+	color: #FFFFFF;
+	font-size: 110%;
+	padding-bottom: 4px;
+	padding-top: 5px;
+}
+
+th.markdownTableHeadLeft, td.markdownTableBodyLeft {
+	text-align: left
+}
+
+th.markdownTableHeadRight, td.markdownTableBodyRight {
+	text-align: right
+}
+
+th.markdownTableHeadCenter, td.markdownTableBodyCenter {
+	text-align: center
+}
+
+.DocNodeRTL {
+  text-align: right;
+  direction: rtl;
+}
+
+.DocNodeLTR {
+  text-align: left;
+  direction: ltr;
+}
+
+table.DocNodeRTL {
+   width: auto;
+   margin-right: 0;
+   margin-left: auto;
+}
+
+table.DocNodeLTR {
+   width: auto;
+   margin-right: auto;
+   margin-left: 0;
+}
+
+tt, code, kbd, samp
+{
+  display: inline-block;
+  direction:ltr; 
+}
+/* @end */
+
+u {
+	text-decoration: underline;
+}
+
diff --git a/3rdparty/libjpeg/src/doc/html/doxygen.svg b/3rdparty/libjpeg/src/doc/html/doxygen.svg
new file mode 100644
index 00000000..d42dad52
--- /dev/null
+++ b/3rdparty/libjpeg/src/doc/html/doxygen.svg
@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<svg version="1.1" viewBox="0 0 104 31" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
+ <defs>
+  <linearGradient id="a">
+   <stop stop-color="#5373B4" offset="0"/>
+   <stop stop-color="#7C95C6" offset="1"/>
+  </linearGradient>
+  <linearGradient id="d" x1="31.474" x2="31.474" y1="24.821" y2="26.773" gradientUnits="userSpaceOnUse" xlink:href="#a"/>
+  <linearGradient id="c" x1="31.474" x2="31.474" y1="24.821" y2="26.773" gradientTransform="matrix(.6816 0 0 1.0248 72.391 -.91809)" gradientUnits="userSpaceOnUse" xlink:href="#a"/>
+  <linearGradient id="b" x1="56.295" x2="56.295" y1="24.622" y2="26.574" gradientUnits="userSpaceOnUse" xlink:href="#a"/>
+  <linearGradient id="e" x1="49.067" x2="48.956" y1="19.719" y2="9.5227" gradientTransform="matrix(.97968 0 0 1.0207 -.25579 -.25579)" gradientUnits="userSpaceOnUse">
+   <stop stop-color="#C0CCE3" offset="0"/>
+   <stop stop-color="#EEF1F7" offset="1"/>
+  </linearGradient>
+  <filter id="f" x="-.010676" y="-.045304" width="1.0214" height="1.0906" color-interpolation-filters="sRGB">
+   <feGaussianBlur stdDeviation="0.45293203"/>
+  </filter>
+ </defs>
+ <g>
+  <path transform="translate(-2.5759 -27.848)" d="m13.609 32.203v6.8633h-0.05078c-0.40533-0.66867-0.96254-1.1715-1.6719-1.5059-0.69244-0.35193-1.4282-0.52734-2.2051-0.52734-0.96267 0-1.807 0.2027-2.5332 0.60742-0.72622 0.38713-1.3344 0.90556-1.8242 1.5566-0.47289 0.65108-0.83456 1.4092-1.0879 2.2715-0.23644 0.84464-0.35547 1.7236-0.35547 2.6387 0 0.95022 0.11902 1.8643 0.35547 2.7441 0.25333 0.87983 0.615 1.6633 1.0879 2.3496 0.48978 0.66867 1.1065 1.2066 1.8496 1.6113 0.74311 0.38713 1.6044 0.58008 2.584 0.58008 0.86133 0 1.6311-0.15787 2.3066-0.47461 0.69244-0.33434 1.2497-0.87227 1.6719-1.6113h0.05078v1.7422h3.4199v-18.846zm12.875 4.8301c-1.0302 0-1.9596 0.17541-2.7871 0.52734-0.82756 0.33434-1.5358 0.81965-2.127 1.4531-0.59111 0.61588-1.0483 1.3721-1.3691 2.2695-0.32089 0.87983-0.48047 1.866-0.48047 2.957s0.15958 2.0752 0.48047 2.9551c0.32089 0.87983 0.77803 1.6361 1.3691 2.2695 0.59111 0.61588 1.2994 1.0914 2.127 1.4258 0.82756 0.33434 1.7569 0.50195 2.7871 0.50195 1.0302 0 1.9596-0.16762 2.7871-0.50195 0.84444-0.33434 1.5612-0.8099 2.1523-1.4258 0.59111-0.63348 1.0483-1.3897 1.3691-2.2695 0.32089-0.87983 0.48047-1.8641 0.48047-2.9551s-0.15958-2.0772-0.48047-2.957c-0.32089-0.89743-0.77803-1.6536-1.3691-2.2695-0.59111-0.63348-1.3079-1.1188-2.1523-1.4531-0.82756-0.35193-1.7569-0.52734-2.7871-0.52734zm41.715 0c-0.912 0-1.7223 0.18516-2.4316 0.55469-0.69244 0.36953-1.2752 0.87043-1.748 1.5039-0.47289 0.61588-0.83651 1.337-1.0898 2.1641-0.23645 0.80944-0.35352 1.6553-0.35352 2.5352 0 0.93262 0.10007 1.8214 0.30273 2.666 0.21956 0.82704 0.55767 1.556 1.0137 2.1895 0.456 0.61588 1.0387 1.109 1.748 1.4785 0.70933 0.35193 1.5536 0.5293 2.5332 0.5293 0.79378 0 1.5446-0.16762 2.2539-0.50195 0.72622-0.35193 1.2834-0.88986 1.6719-1.6113h0.05078v1.7949c0.01689 0.96782-0.21071 1.7689-0.68359 2.4023-0.456 0.63348-1.1898 0.95117-2.2031 0.95117-0.64178 0-1.2075-0.14228-1.6973-0.42383-0.48978-0.26395-0.81939-0.74731-0.98828-1.4512h-3.5723c0.05067 0.77425 0.25276 1.435 0.60742 1.9805 0.37156 0.56309 0.8287 1.0192 1.3691 1.3711 0.55733 0.35193 1.1656 0.60726 1.8242 0.76562 0.67556 0.17597 1.3328 0.26562 1.9746 0.26562 1.5031 0 2.7025-0.21245 3.5977-0.63477 0.89511-0.42232 1.5798-0.94076 2.0527-1.5566 0.47289-0.59829 0.777-1.2493 0.91211-1.9531 0.152-0.70386 0.22656-1.3295 0.22656-1.875v-12.775h-3.4199v1.8223h-0.05078c-0.43911-0.79185-0.98782-1.3551-1.6465-1.6895-0.64178-0.33434-1.3926-0.50195-2.2539-0.50195zm16.523 0c-0.99644 0-1.9088 0.18516-2.7363 0.55469-0.81067 0.36953-1.5124 0.88018-2.1035 1.5312-0.59111 0.63348-1.0463 1.3897-1.3672 2.2695s-0.48047 1.831-0.48047 2.8516c0 1.0558 0.15108 2.0225 0.45508 2.9023 0.32089 0.87983 0.76758 1.6361 1.3418 2.2695 0.57422 0.63348 1.276 1.1266 2.1035 1.4785 0.82756 0.33434 1.7569 0.50195 2.7871 0.50195 1.4862 0 2.7517-0.35277 3.7988-1.0566 1.0471-0.70387 1.8254-1.8733 2.332-3.5098h-3.168c-0.11822 0.42232-0.43934 0.82772-0.96289 1.2148-0.52355 0.36953-1.1468 0.55274-1.873 0.55273-1.0133 0-1.7916-0.27286-2.332-0.81836-0.54044-0.5455-0.83605-1.4245-0.88672-2.6387h9.4492c0.06756-1.0558-0.01551-2.0673-0.25195-3.0352-0.23644-0.96782-0.62557-1.8293-1.166-2.5859-0.52356-0.75666-1.1998-1.355-2.0273-1.7949-0.82756-0.45751-1.7974-0.6875-2.9121-0.6875zm16.189 0c-0.76 0-1.5023 0.18516-2.2285 0.55469-0.72622 0.35193-1.3174 0.92299-1.7734 1.7148h-0.07617v-1.9004h-3.4199v13.646h3.5977v-7.1523c0-1.3901 0.21909-2.3841 0.6582-2.9824 0.43911-0.61588 1.1494-0.92383 2.1289-0.92383 0.86133 0 1.4611 0.28066 1.7988 0.84375 0.33777 0.5455 0.50586 1.3816 0.50586 2.5078v7.707h3.5976v-8.3926c0-0.84464-0.0765-1.6106-0.22851-2.2969-0.13511-0.70387-0.37971-1.2925-0.73438-1.7676-0.35466-0.49271-0.84386-0.87277-1.4688-1.1367-0.608-0.28155-1.3948-0.42188-2.3574-0.42188zm-66.063 0.36914 4.3066 6.4668-4.7129 7.1797h4.0293l2.7363-4.3027 2.7344 4.3027h4.1055l-4.8398-7.2578 4.3066-6.3887h-3.9766l-2.2793 3.5645-2.3066-3.5645zm13.275 0 4.584 12.803c0.10133 0.26395 0.15234 0.54461 0.15234 0.84375 0 0.40472-0.11707 0.77504-0.35352 1.1094-0.21956 0.33434-0.56617 0.52729-1.0391 0.58008-0.35467 0.0176-0.70979 0.0098-1.0645-0.02539-0.35467-0.03519-0.70128-0.07028-1.0391-0.10547v3.0879c0.37156 0.03519 0.73518 0.06051 1.0898 0.07813 0.37156 0.03519 0.74368 0.05273 1.1152 0.05273 1.2329 0 2.1943-0.23778 2.8867-0.71289 0.69244-0.47511 1.2326-1.2664 1.6211-2.375l5.4727-15.336h-3.7246l-2.8613 9.3438h-0.05078l-2.9648-9.3438zm-37.48 2.4551c0.59111 0 1.0823 0.12279 1.4707 0.36914 0.38844 0.24635 0.6991 0.57184 0.93555 0.97656 0.25333 0.38713 0.43187 0.84515 0.5332 1.373 0.10133 0.5103 0.15234 1.0482 0.15234 1.6113 0 0.56309-0.05101 1.1069-0.15234 1.6348-0.10133 0.5279-0.27137 1.0035-0.50781 1.4258-0.23644 0.40472-0.5556 0.73021-0.96094 0.97656-0.38844 0.24635-0.87959 0.36914-1.4707 0.36914-0.55733 0-1.038-0.12279-1.4434-0.36914-0.38844-0.26395-0.71806-0.59723-0.98828-1.002-0.25333-0.42232-0.43842-0.89788-0.55664-1.4258s-0.17773-1.0561-0.17773-1.584c-1e-7 -0.56309 0.05101-1.0991 0.15234-1.6094 0.11822-0.5279 0.29481-0.99567 0.53125-1.4004 0.25333-0.40472 0.58295-0.73021 0.98828-0.97656 0.40533-0.24635 0.90303-0.36914 1.4941-0.36914zm15.84 0c0.608 0 1.1142 0.13253 1.5195 0.39648 0.42222 0.24635 0.75184 0.57184 0.98828 0.97656 0.25333 0.40472 0.42992 0.87054 0.53125 1.3984 0.10133 0.5279 0.15234 1.0658 0.15234 1.6113 0 0.5455-0.05101 1.0815-0.15234 1.6094-0.10134 0.5103-0.27792 0.97612-0.53125 1.3984-0.23644 0.40472-0.56606 0.73021-0.98828 0.97656-0.40533 0.24635-0.91153 0.36914-1.5195 0.36914-0.608 0-1.1142-0.12279-1.5195-0.36914s-0.73495-0.57184-0.98828-0.97656c-0.23644-0.42232-0.40648-0.88814-0.50781-1.3984-0.10133-0.5279-0.15234-1.0639-0.15234-1.6094 0-0.5455 0.05101-1.0834 0.15234-1.6113 0.10133-0.5279 0.27137-0.99371 0.50781-1.3984 0.25333-0.40472 0.58295-0.73021 0.98828-0.97656 0.40533-0.26395 0.91153-0.39648 1.5195-0.39648zm42.602 0c0.59111 0 1.0803 0.11499 1.4688 0.34375 0.38844 0.22876 0.70105 0.5367 0.9375 0.92383 0.23644 0.38713 0.40648 0.8354 0.50781 1.3457 0.10133 0.49271 0.15039 1.0209 0.15039 1.584 0 0.4927-0.06606 0.96827-0.20117 1.4258-0.11822 0.43992-0.30526 0.83557-0.55859 1.1875-0.25333 0.35193-0.57445 0.63259-0.96289 0.84375-0.38844 0.21116-0.83513 0.31836-1.3418 0.31836-0.55733 0-1.021-0.12474-1.3926-0.37109-0.37156-0.24635-0.67566-0.56209-0.91211-0.94922-0.21956-0.38713-0.38109-0.81786-0.48242-1.293-0.08444-0.49271-0.12695-0.98581-0.12695-1.4785 0-0.5103 0.05101-0.99366 0.15234-1.4512 0.11822-0.47511 0.29676-0.89025 0.5332-1.2422 0.25333-0.36953 0.55744-0.65993 0.91211-0.87109 0.37156-0.21116 0.80974-0.31641 1.3164-0.31641zm15.535 0c0.87822 0 1.529 0.24753 1.9512 0.74023 0.43911 0.49271 0.74322 1.2138 0.91211 2.1641h-5.8535c0.01689-0.26395 0.0679-0.5641 0.15234-0.89844 0.10133-0.33434 0.26287-0.65008 0.48242-0.94922 0.23644-0.29914 0.54055-0.54667 0.91211-0.74023 0.38845-0.21116 0.86914-0.31641 1.4434-0.31641z" filter="url(#f)" opacity=".3" stroke="#969696" xlink:href="#path141"/>
+  <path d="m0.97202 24.161 43.605-0.0019 0.0508 3.3061-43.6 0.04174z" fill="url(#d)" stroke="#000" stroke-width=".5"/>
+  <path d="m10.283 3.5547v6.8633h-0.05078c-0.40533-0.66867-0.96254-1.1715-1.6719-1.5059-0.69244-0.35193-1.4282-0.52734-2.2051-0.52734-0.96267 0-1.807 0.2027-2.5332 0.60742-0.72622 0.38713-1.3344 0.90556-1.8242 1.5566-0.47289 0.65108-0.83456 1.4092-1.0879 2.2715-0.23644 0.84464-0.35547 1.7236-0.35547 2.6387 0 0.95022 0.11902 1.8643 0.35547 2.7441 0.25333 0.87983 0.615 1.6633 1.0879 2.3496 0.48978 0.66867 1.1065 1.2066 1.8496 1.6113 0.74311 0.38713 1.6044 0.58008 2.584 0.58008 0.86133 0 1.6311-0.15787 2.3066-0.47461 0.69244-0.33434 1.2497-0.87227 1.6719-1.6113h0.05078v1.7422h3.4199v-18.846zm12.875 4.8301c-1.0302 0-1.9596 0.17541-2.7871 0.52734-0.82756 0.33434-1.5358 0.81965-2.127 1.4531-0.59111 0.61588-1.0483 1.3721-1.3691 2.2695-0.32089 0.87983-0.48047 1.866-0.48047 2.957s0.15958 2.0752 0.48047 2.9551c0.32089 0.87983 0.77803 1.6361 1.3691 2.2695 0.59111 0.61588 1.2994 1.0914 2.127 1.4258 0.82756 0.33434 1.7569 0.50195 2.7871 0.50195 1.0302 0 1.9596-0.16762 2.7871-0.50195 0.84444-0.33434 1.5612-0.8099 2.1523-1.4258 0.59111-0.63348 1.0483-1.3897 1.3691-2.2695 0.32089-0.87983 0.48047-1.8641 0.48047-2.9551s-0.15958-2.0772-0.48047-2.957c-0.32089-0.89743-0.77803-1.6536-1.3691-2.2695-0.59111-0.63348-1.3079-1.1188-2.1523-1.4531-0.82756-0.35193-1.7569-0.52734-2.7871-0.52734zm41.715 0c-0.912 0-1.7223 0.18516-2.4316 0.55469-0.69244 0.36953-1.2752 0.87043-1.748 1.5039-0.47289 0.61588-0.83651 1.337-1.0898 2.1641-0.23644 0.80944-0.35352 1.6553-0.35352 2.5352 0 0.93262 0.10007 1.8214 0.30273 2.666 0.21956 0.82704 0.55767 1.556 1.0137 2.1895 0.456 0.61588 1.0387 1.109 1.748 1.4785 0.70933 0.35193 1.5536 0.5293 2.5332 0.5293 0.79378 0 1.5446-0.16762 2.2539-0.50195 0.72622-0.35193 1.2834-0.88986 1.6719-1.6113h0.05078v1.7949c0.01689 0.96782-0.21071 1.7689-0.68359 2.4023-0.456 0.63348-1.1898 0.95117-2.2031 0.95117-0.64178 0-1.2075-0.14228-1.6973-0.42383-0.48978-0.26395-0.81939-0.74731-0.98828-1.4512h-3.5723c0.05067 0.77425 0.25276 1.435 0.60742 1.9805 0.37156 0.56309 0.8287 1.0192 1.3691 1.3711 0.55733 0.35193 1.1656 0.60726 1.8242 0.76562 0.67556 0.17597 1.3328 0.26562 1.9746 0.26562 1.5031 0 2.7025-0.21245 3.5977-0.63477 0.89511-0.42232 1.5798-0.94076 2.0527-1.5566 0.47289-0.59829 0.777-1.2493 0.91211-1.9531 0.152-0.70386 0.22656-1.3295 0.22656-1.875v-12.775h-3.4199v1.8223h-0.05078c-0.43911-0.79185-0.98782-1.3551-1.6465-1.6895-0.64178-0.33434-1.3926-0.50195-2.2539-0.50195zm16.523 0c-0.99644 0-1.9088 0.18516-2.7363 0.55469-0.81067 0.36953-1.5124 0.88017-2.1035 1.5312-0.59111 0.63348-1.0463 1.3897-1.3672 2.2695s-0.48047 1.831-0.48047 2.8516c0 1.0558 0.15108 2.0225 0.45508 2.9023 0.32089 0.87983 0.76758 1.6361 1.3418 2.2695 0.57422 0.63348 1.276 1.1266 2.1035 1.4785 0.82756 0.33434 1.7569 0.50195 2.7871 0.50195 1.4862 0 2.7517-0.35278 3.7988-1.0566 1.0471-0.70386 1.8254-1.8733 2.332-3.5098h-3.168c-0.11822 0.42232-0.43934 0.82772-0.96289 1.2148-0.52355 0.36953-1.1468 0.55274-1.873 0.55273-1.0133 0-1.7916-0.27286-2.332-0.81836-0.54044-0.5455-0.83605-1.4245-0.88672-2.6387h9.4492c0.06756-1.0558-0.01551-2.0673-0.25195-3.0352-0.23644-0.96782-0.62557-1.8293-1.166-2.5859-0.52356-0.75666-1.1998-1.355-2.0273-1.7949-0.82756-0.45751-1.7974-0.6875-2.9121-0.6875zm16.189 0c-0.76 0-1.5023 0.18516-2.2285 0.55469-0.72622 0.35193-1.3174 0.923-1.7734 1.7148h-0.07617v-1.9004h-3.4199v13.646h3.5977v-7.1523c0-1.3901 0.21909-2.3841 0.6582-2.9824 0.43911-0.61588 1.1494-0.92383 2.1289-0.92383 0.86133 0 1.461 0.28066 1.7988 0.84375 0.33778 0.5455 0.50586 1.3816 0.50586 2.5078v7.707h3.5977v-8.3926c0-0.84464-0.0765-1.6106-0.22852-2.2969-0.13511-0.70387-0.3797-1.2925-0.73437-1.7676-0.35466-0.49271-0.84386-0.87277-1.4688-1.1367-0.608-0.28155-1.3948-0.42188-2.3574-0.42188zm-66.062 0.36914 4.3066 6.4668-4.7129 7.1797h4.0293l2.7363-4.3027 2.7344 4.3027h4.1055l-4.8398-7.2578 4.3066-6.3887h-3.9766l-2.2793 3.5645-2.3066-3.5645zm13.275 0 4.584 12.803c0.10133 0.26395 0.15234 0.54461 0.15234 0.84375 0 0.40472-0.11707 0.77504-0.35352 1.1094-0.21956 0.33434-0.56617 0.52729-1.0391 0.58008-0.35467 0.0176-0.70979 0.0098-1.0645-0.02539-0.35467-0.03519-0.70128-0.07027-1.0391-0.10547v3.0879c0.37156 0.03519 0.73518 0.06052 1.0898 0.07813 0.37156 0.03519 0.74368 0.05273 1.1152 0.05273 1.2329 0 2.1943-0.23778 2.8867-0.71289 0.69244-0.47511 1.2326-1.2664 1.6211-2.375l5.4727-15.336h-3.7246l-2.8613 9.3437h-0.05078l-2.9648-9.3437zm-37.48 2.4551c0.59111 0 1.0823 0.12279 1.4707 0.36914s0.6991 0.57184 0.93555 0.97656c0.25333 0.38713 0.43187 0.84515 0.5332 1.373 0.10133 0.5103 0.15234 1.0482 0.15234 1.6113 0 0.56309-0.05101 1.1069-0.15234 1.6348-0.10133 0.5279-0.27137 1.0035-0.50781 1.4258-0.23644 0.40472-0.5556 0.73021-0.96094 0.97656-0.38844 0.24635-0.87959 0.36914-1.4707 0.36914-0.55733 0-1.038-0.12279-1.4434-0.36914-0.38844-0.26395-0.71806-0.59723-0.98828-1.002-0.25333-0.42232-0.43842-0.89788-0.55664-1.4258s-0.17773-1.0561-0.17773-1.584c-1e-7 -0.56309 0.05101-1.0991 0.15234-1.6094 0.11822-0.5279 0.29481-0.99567 0.53125-1.4004 0.25333-0.40472 0.58295-0.73021 0.98828-0.97656 0.40533-0.24635 0.90303-0.36914 1.4941-0.36914zm15.84 0c0.608 0 1.1142 0.13254 1.5195 0.39648 0.42222 0.24635 0.75184 0.57184 0.98828 0.97656 0.25333 0.40472 0.42992 0.87054 0.53125 1.3984 0.10133 0.5279 0.15234 1.0658 0.15234 1.6113 0 0.5455-0.05101 1.0815-0.15234 1.6094-0.10133 0.5103-0.27792 0.97612-0.53125 1.3984-0.23644 0.40472-0.56606 0.73021-0.98828 0.97656-0.40533 0.24635-0.91153 0.36914-1.5195 0.36914-0.608 0-1.1142-0.12279-1.5195-0.36914s-0.73495-0.57184-0.98828-0.97656c-0.23644-0.42232-0.40648-0.88813-0.50781-1.3984-0.10133-0.5279-0.15234-1.0639-0.15234-1.6094 0-0.5455 0.05101-1.0834 0.15234-1.6113 0.10133-0.5279 0.27137-0.99371 0.50781-1.3984 0.25333-0.40472 0.58295-0.73021 0.98828-0.97656 0.40533-0.26395 0.91153-0.39648 1.5195-0.39648zm42.602 0c0.59111 0 1.0803 0.11499 1.4688 0.34375 0.38844 0.22876 0.70106 0.5367 0.9375 0.92383 0.23644 0.38713 0.40648 0.8354 0.50781 1.3457 0.10133 0.49271 0.15039 1.0209 0.15039 1.584 0 0.49271-0.06606 0.96827-0.20117 1.4258-0.11822 0.43992-0.30526 0.83557-0.55859 1.1875-0.25333 0.35193-0.57445 0.63259-0.96289 0.84375-0.38844 0.21116-0.83513 0.31836-1.3418 0.31836-0.55733 0-1.021-0.12474-1.3926-0.37109-0.37156-0.24635-0.67566-0.56209-0.91211-0.94922-0.21956-0.38713-0.38109-0.81786-0.48242-1.293-0.08444-0.49271-0.12695-0.98581-0.12695-1.4785 0-0.5103 0.05101-0.99366 0.15234-1.4512 0.11822-0.47511 0.29676-0.89026 0.5332-1.2422 0.25333-0.36953 0.55744-0.65993 0.91211-0.87109 0.37156-0.21116 0.80974-0.31641 1.3164-0.31641zm15.535 0c0.87822 0 1.529 0.24753 1.9512 0.74024 0.43911 0.49271 0.74322 1.2138 0.91211 2.1641h-5.8535c0.01689-0.26395 0.0679-0.5641 0.15234-0.89844 0.10133-0.33434 0.26287-0.65008 0.48242-0.94922 0.23644-0.29914 0.54055-0.54667 0.91211-0.74023 0.38845-0.21116 0.86914-0.31641 1.4434-0.31641z" fill="url(#e)" stroke="#4665A2" stroke-width=".7"/>
+  <path d="m52.988 27.291c0.99602-1.0359 1.3944-1.8725 1.7928-3.1076l3.8247-0.03984c0.3113 1.6096 0.82413 2.5137 1.6335 3.1474z" fill="url(#b)" stroke="#000" stroke-width=".5"/>
+  <path d="m73.89 24.04 28.885-0.2011-0.12476 3.3879-31.033 0.16229c1.2621-1.0234 1.9665-2.2859 2.2724-3.3491z" fill="url(#c)" stroke="#000" stroke-width=".41788"/>
+ </g>
+</svg>
diff --git a/3rdparty/libjpeg/src/doc/html/dynsections.js b/3rdparty/libjpeg/src/doc/html/dynsections.js
new file mode 100644
index 00000000..3174bd7b
--- /dev/null
+++ b/3rdparty/libjpeg/src/doc/html/dynsections.js
@@ -0,0 +1,121 @@
+/*
+ @licstart  The following is the entire license notice for the JavaScript code in this file.
+
+ The MIT License (MIT)
+
+ Copyright (C) 1997-2020 by Dimitri van Heesch
+
+ 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.
+
+ @licend  The above is the entire license notice for the JavaScript code in this file
+ */
+function toggleVisibility(linkObj)
+{
+ var base = $(linkObj).attr('id');
+ var summary = $('#'+base+'-summary');
+ var content = $('#'+base+'-content');
+ var trigger = $('#'+base+'-trigger');
+ var src=$(trigger).attr('src');
+ if (content.is(':visible')===true) {
+   content.hide();
+   summary.show();
+   $(linkObj).addClass('closed').removeClass('opened');
+   $(trigger).attr('src',src.substring(0,src.length-8)+'closed.png');
+ } else {
+   content.show();
+   summary.hide();
+   $(linkObj).removeClass('closed').addClass('opened');
+   $(trigger).attr('src',src.substring(0,src.length-10)+'open.png');
+ }
+ return false;
+}
+
+function updateStripes()
+{
+  $('table.directory tr').
+       removeClass('even').filter(':visible:even').addClass('even');
+}
+
+function toggleLevel(level)
+{
+  $('table.directory tr').each(function() {
+    var l = this.id.split('_').length-1;
+    var i = $('#img'+this.id.substring(3));
+    var a = $('#arr'+this.id.substring(3));
+    if (l<level+1) {
+      i.removeClass('iconfopen iconfclosed').addClass('iconfopen');
+      a.html('&#9660;');
+      $(this).show();
+    } else if (l==level+1) {
+      i.removeClass('iconfclosed iconfopen').addClass('iconfclosed');
+      a.html('&#9658;');
+      $(this).show();
+    } else {
+      $(this).hide();
+    }
+  });
+  updateStripes();
+}
+
+function toggleFolder(id)
+{
+  // the clicked row
+  var currentRow = $('#row_'+id);
+
+  // all rows after the clicked row
+  var rows = currentRow.nextAll("tr");
+
+  var re = new RegExp('^row_'+id+'\\d+_$', "i"); //only one sub
+
+  // only match elements AFTER this one (can't hide elements before)
+  var childRows = rows.filter(function() { return this.id.match(re); });
+
+  // first row is visible we are HIDING
+  if (childRows.filter(':first').is(':visible')===true) {
+    // replace down arrow by right arrow for current row
+    var currentRowSpans = currentRow.find("span");
+    currentRowSpans.filter(".iconfopen").removeClass("iconfopen").addClass("iconfclosed");
+    currentRowSpans.filter(".arrow").html('&#9658;');
+    rows.filter("[id^=row_"+id+"]").hide(); // hide all children
+  } else { // we are SHOWING
+    // replace right arrow by down arrow for current row
+    var currentRowSpans = currentRow.find("span");
+    currentRowSpans.filter(".iconfclosed").removeClass("iconfclosed").addClass("iconfopen");
+    currentRowSpans.filter(".arrow").html('&#9660;');
+    // replace down arrows by right arrows for child rows
+    var childRowsSpans = childRows.find("span");
+    childRowsSpans.filter(".iconfopen").removeClass("iconfopen").addClass("iconfclosed");
+    childRowsSpans.filter(".arrow").html('&#9658;');
+    childRows.show(); //show all children
+  }
+  updateStripes();
+}
+
+
+function toggleInherit(id)
+{
+  var rows = $('tr.inherit.'+id);
+  var img = $('tr.inherit_header.'+id+' img');
+  var src = $(img).attr('src');
+  if (rows.filter(':first').is(':visible')===true) {
+    rows.css('display','none');
+    $(img).attr('src',src.substring(0,src.length-8)+'closed.png');
+  } else {
+    rows.css('display','table-row'); // using show() causes jump in firefox
+    $(img).attr('src',src.substring(0,src.length-10)+'open.png');
+  }
+}
+/* @license-end */
diff --git a/3rdparty/libjpeg/src/doc/html/folderclosed.png b/3rdparty/libjpeg/src/doc/html/folderclosed.png
new file mode 100644
index 00000000..bb8ab35e
Binary files /dev/null and b/3rdparty/libjpeg/src/doc/html/folderclosed.png differ
diff --git a/3rdparty/libjpeg/src/doc/html/folderopen.png b/3rdparty/libjpeg/src/doc/html/folderopen.png
new file mode 100644
index 00000000..d6c7f676
Binary files /dev/null and b/3rdparty/libjpeg/src/doc/html/folderopen.png differ
diff --git a/3rdparty/libjpeg/src/doc/html/functions.html b/3rdparty/libjpeg/src/doc/html/functions.html
new file mode 100644
index 00000000..7f85093c
--- /dev/null
+++ b/3rdparty/libjpeg/src/doc/html/functions.html
@@ -0,0 +1,107 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.8.20"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>TurboJPEG: Data Fields</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="search/search.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="search/searchdata.js"></script>
+<script type="text/javascript" src="search/search.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+  <td id="projectalign" style="padding-left: 0.5em;">
+   <div id="projectname">TurboJPEG
+   &#160;<span id="projectnumber">2.0</span>
+   </div>
+  </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.8.20 -->
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+var searchBox = new SearchBox("searchBox", "search",false,'Search');
+/* @license-end */
+</script>
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+  initMenu('',true,false,'search.php','Search');
+  $(document).ready(function() { init_search(); });
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<!-- window showing the filter options -->
+<div id="MSearchSelectWindow"
+     onmouseover="return searchBox.OnSearchSelectShow()"
+     onmouseout="return searchBox.OnSearchSelectHide()"
+     onkeydown="return searchBox.OnSearchSelectKey(event)">
+</div>
+
+<!-- iframe showing the search results (closed by default) -->
+<div id="MSearchResultsWindow">
+<iframe src="javascript:void(0)" frameborder="0" 
+        name="MSearchResults" id="MSearchResults">
+</iframe>
+</div>
+
+<div class="contents">
+<div class="textblock">Here is a list of all documented struct and union fields with links to the struct/union documentation for each field:</div><ul>
+<li>customFilter
+: <a class="el" href="structtjtransform.html#afd7fc262df33f741e120ef4183202ef5">tjtransform</a>
+</li>
+<li>data
+: <a class="el" href="structtjtransform.html#a688fe8f1a8ecc12a538d9e561cf338e3">tjtransform</a>
+</li>
+<li>denom
+: <a class="el" href="structtjscalingfactor.html#aefbcdf3e9e62274b2d312c695f133ce3">tjscalingfactor</a>
+</li>
+<li>h
+: <a class="el" href="structtjregion.html#aecefc45a26f4d8b60dd4d825c1710115">tjregion</a>
+</li>
+<li>num
+: <a class="el" href="structtjscalingfactor.html#a9b011e57f981ee23083e2c1aa5e640ec">tjscalingfactor</a>
+</li>
+<li>op
+: <a class="el" href="structtjtransform.html#a2525aab4ba6978a1c273f74fef50e498">tjtransform</a>
+</li>
+<li>options
+: <a class="el" href="structtjtransform.html#ac0e74655baa4402209a21e1ae481c8f6">tjtransform</a>
+</li>
+<li>r
+: <a class="el" href="structtjtransform.html#ac324e5e442abec8a961e5bf219db12cf">tjtransform</a>
+</li>
+<li>w
+: <a class="el" href="structtjregion.html#ab6eb73ceef584fc23c8c8097926dce42">tjregion</a>
+</li>
+<li>x
+: <a class="el" href="structtjregion.html#a4b6a37a93997091b26a75831fa291ad9">tjregion</a>
+</li>
+<li>y
+: <a class="el" href="structtjregion.html#a7b3e0c24cfe87acc80e334cafdcf22c2">tjregion</a>
+</li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated by&#160;<a href="http://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.8.20
+</small></address>
+</body>
+</html>
diff --git a/3rdparty/libjpeg/src/doc/html/functions_vars.html b/3rdparty/libjpeg/src/doc/html/functions_vars.html
new file mode 100644
index 00000000..68e20e1b
--- /dev/null
+++ b/3rdparty/libjpeg/src/doc/html/functions_vars.html
@@ -0,0 +1,107 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.8.20"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>TurboJPEG: Data Fields - Variables</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="search/search.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="search/searchdata.js"></script>
+<script type="text/javascript" src="search/search.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+  <td id="projectalign" style="padding-left: 0.5em;">
+   <div id="projectname">TurboJPEG
+   &#160;<span id="projectnumber">2.0</span>
+   </div>
+  </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.8.20 -->
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+var searchBox = new SearchBox("searchBox", "search",false,'Search');
+/* @license-end */
+</script>
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+  initMenu('',true,false,'search.php','Search');
+  $(document).ready(function() { init_search(); });
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<!-- window showing the filter options -->
+<div id="MSearchSelectWindow"
+     onmouseover="return searchBox.OnSearchSelectShow()"
+     onmouseout="return searchBox.OnSearchSelectHide()"
+     onkeydown="return searchBox.OnSearchSelectKey(event)">
+</div>
+
+<!-- iframe showing the search results (closed by default) -->
+<div id="MSearchResultsWindow">
+<iframe src="javascript:void(0)" frameborder="0" 
+        name="MSearchResults" id="MSearchResults">
+</iframe>
+</div>
+
+<div class="contents">
+&#160;<ul>
+<li>customFilter
+: <a class="el" href="structtjtransform.html#afd7fc262df33f741e120ef4183202ef5">tjtransform</a>
+</li>
+<li>data
+: <a class="el" href="structtjtransform.html#a688fe8f1a8ecc12a538d9e561cf338e3">tjtransform</a>
+</li>
+<li>denom
+: <a class="el" href="structtjscalingfactor.html#aefbcdf3e9e62274b2d312c695f133ce3">tjscalingfactor</a>
+</li>
+<li>h
+: <a class="el" href="structtjregion.html#aecefc45a26f4d8b60dd4d825c1710115">tjregion</a>
+</li>
+<li>num
+: <a class="el" href="structtjscalingfactor.html#a9b011e57f981ee23083e2c1aa5e640ec">tjscalingfactor</a>
+</li>
+<li>op
+: <a class="el" href="structtjtransform.html#a2525aab4ba6978a1c273f74fef50e498">tjtransform</a>
+</li>
+<li>options
+: <a class="el" href="structtjtransform.html#ac0e74655baa4402209a21e1ae481c8f6">tjtransform</a>
+</li>
+<li>r
+: <a class="el" href="structtjtransform.html#ac324e5e442abec8a961e5bf219db12cf">tjtransform</a>
+</li>
+<li>w
+: <a class="el" href="structtjregion.html#ab6eb73ceef584fc23c8c8097926dce42">tjregion</a>
+</li>
+<li>x
+: <a class="el" href="structtjregion.html#a4b6a37a93997091b26a75831fa291ad9">tjregion</a>
+</li>
+<li>y
+: <a class="el" href="structtjregion.html#a7b3e0c24cfe87acc80e334cafdcf22c2">tjregion</a>
+</li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated by&#160;<a href="http://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.8.20
+</small></address>
+</body>
+</html>
diff --git a/3rdparty/libjpeg/src/doc/html/group___turbo_j_p_e_g.html b/3rdparty/libjpeg/src/doc/html/group___turbo_j_p_e_g.html
new file mode 100644
index 00000000..8c82803b
--- /dev/null
+++ b/3rdparty/libjpeg/src/doc/html/group___turbo_j_p_e_g.html
@@ -0,0 +1,2852 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.8.20"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>TurboJPEG: TurboJPEG</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="search/search.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="search/searchdata.js"></script>
+<script type="text/javascript" src="search/search.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+  <td id="projectalign" style="padding-left: 0.5em;">
+   <div id="projectname">TurboJPEG
+   &#160;<span id="projectnumber">2.0</span>
+   </div>
+  </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.8.20 -->
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+var searchBox = new SearchBox("searchBox", "search",false,'Search');
+/* @license-end */
+</script>
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+  initMenu('',true,false,'search.php','Search');
+  $(document).ready(function() { init_search(); });
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<!-- window showing the filter options -->
+<div id="MSearchSelectWindow"
+     onmouseover="return searchBox.OnSearchSelectShow()"
+     onmouseout="return searchBox.OnSearchSelectHide()"
+     onkeydown="return searchBox.OnSearchSelectKey(event)">
+</div>
+
+<!-- iframe showing the search results (closed by default) -->
+<div id="MSearchResultsWindow">
+<iframe src="javascript:void(0)" frameborder="0" 
+        name="MSearchResults" id="MSearchResults">
+</iframe>
+</div>
+
+<div class="header">
+  <div class="summary">
+<a href="#nested-classes">Data Structures</a> &#124;
+<a href="#define-members">Macros</a> &#124;
+<a href="#typedef-members">Typedefs</a> &#124;
+<a href="#enum-members">Enumerations</a> &#124;
+<a href="#func-members">Functions</a> &#124;
+<a href="#var-members">Variables</a>  </div>
+  <div class="headertitle">
+<div class="title">TurboJPEG</div>  </div>
+</div><!--header-->
+<div class="contents">
+
+<p>TurboJPEG API.  
+<a href="#details">More...</a></p>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="nested-classes"></a>
+Data Structures</h2></td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">struct &#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structtjscalingfactor.html">tjscalingfactor</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft">&#160;</td><td class="mdescRight">Scaling factor.  <a href="structtjscalingfactor.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">struct &#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structtjregion.html">tjregion</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft">&#160;</td><td class="mdescRight">Cropping region.  <a href="structtjregion.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">struct &#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structtjtransform.html">tjtransform</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft">&#160;</td><td class="mdescRight">Lossless transform.  <a href="structtjtransform.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2">&#160;</td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="define-members"></a>
+Macros</h2></td></tr>
+<tr class="memitem:ga5ef3d169162ce77ce348e292a0b7477c"><td class="memItemLeft" align="right" valign="top">#define&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group___turbo_j_p_e_g.html#ga5ef3d169162ce77ce348e292a0b7477c">TJ_NUMSAMP</a></td></tr>
+<tr class="memdesc:ga5ef3d169162ce77ce348e292a0b7477c"><td class="mdescLeft">&#160;</td><td class="mdescRight">The number of chrominance subsampling options.  <a href="group___turbo_j_p_e_g.html#ga5ef3d169162ce77ce348e292a0b7477c">More...</a><br /></td></tr>
+<tr class="separator:ga5ef3d169162ce77ce348e292a0b7477c"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:ga7010a4402f54a45ba822ad8675a4655e"><td class="memItemLeft" align="right" valign="top">#define&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group___turbo_j_p_e_g.html#ga7010a4402f54a45ba822ad8675a4655e">TJ_NUMPF</a></td></tr>
+<tr class="memdesc:ga7010a4402f54a45ba822ad8675a4655e"><td class="mdescLeft">&#160;</td><td class="mdescRight">The number of pixel formats.  <a href="group___turbo_j_p_e_g.html#ga7010a4402f54a45ba822ad8675a4655e">More...</a><br /></td></tr>
+<tr class="separator:ga7010a4402f54a45ba822ad8675a4655e"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:ga39f57a6fb02d9cf32e7b6890099b5a71"><td class="memItemLeft" align="right" valign="top">#define&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group___turbo_j_p_e_g.html#ga39f57a6fb02d9cf32e7b6890099b5a71">TJ_NUMCS</a></td></tr>
+<tr class="memdesc:ga39f57a6fb02d9cf32e7b6890099b5a71"><td class="mdescLeft">&#160;</td><td class="mdescRight">The number of JPEG colorspaces.  <a href="group___turbo_j_p_e_g.html#ga39f57a6fb02d9cf32e7b6890099b5a71">More...</a><br /></td></tr>
+<tr class="separator:ga39f57a6fb02d9cf32e7b6890099b5a71"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:ga72ecf4ebe6eb702d3c6f5ca27455e1ec"><td class="memItemLeft" align="right" valign="top">#define&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group___turbo_j_p_e_g.html#ga72ecf4ebe6eb702d3c6f5ca27455e1ec">TJFLAG_BOTTOMUP</a></td></tr>
+<tr class="memdesc:ga72ecf4ebe6eb702d3c6f5ca27455e1ec"><td class="mdescLeft">&#160;</td><td class="mdescRight">The uncompressed source/destination image is stored in bottom-up (Windows, OpenGL) order, not top-down (X11) order.  <a href="group___turbo_j_p_e_g.html#ga72ecf4ebe6eb702d3c6f5ca27455e1ec">More...</a><br /></td></tr>
+<tr class="separator:ga72ecf4ebe6eb702d3c6f5ca27455e1ec"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:ga4ee4506c81177a06f77e2504a22efd2d"><td class="memItemLeft" align="right" valign="top">#define&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group___turbo_j_p_e_g.html#ga4ee4506c81177a06f77e2504a22efd2d">TJFLAG_FASTUPSAMPLE</a></td></tr>
+<tr class="memdesc:ga4ee4506c81177a06f77e2504a22efd2d"><td class="mdescLeft">&#160;</td><td class="mdescRight">When decompressing an image that was compressed using chrominance subsampling, use the fastest chrominance upsampling algorithm available in the underlying codec.  <a href="group___turbo_j_p_e_g.html#ga4ee4506c81177a06f77e2504a22efd2d">More...</a><br /></td></tr>
+<tr class="separator:ga4ee4506c81177a06f77e2504a22efd2d"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:ga8808d403c68b62aaa58a4c1e58e98963"><td class="memItemLeft" align="right" valign="top">#define&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group___turbo_j_p_e_g.html#ga8808d403c68b62aaa58a4c1e58e98963">TJFLAG_NOREALLOC</a></td></tr>
+<tr class="memdesc:ga8808d403c68b62aaa58a4c1e58e98963"><td class="mdescLeft">&#160;</td><td class="mdescRight">Disable buffer (re)allocation.  <a href="group___turbo_j_p_e_g.html#ga8808d403c68b62aaa58a4c1e58e98963">More...</a><br /></td></tr>
+<tr class="separator:ga8808d403c68b62aaa58a4c1e58e98963"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:gaabce235db80d3f698b27f36cbd453da2"><td class="memItemLeft" align="right" valign="top">#define&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group___turbo_j_p_e_g.html#gaabce235db80d3f698b27f36cbd453da2">TJFLAG_FASTDCT</a></td></tr>
+<tr class="memdesc:gaabce235db80d3f698b27f36cbd453da2"><td class="mdescLeft">&#160;</td><td class="mdescRight">Use the fastest DCT/IDCT algorithm available in the underlying codec.  <a href="group___turbo_j_p_e_g.html#gaabce235db80d3f698b27f36cbd453da2">More...</a><br /></td></tr>
+<tr class="separator:gaabce235db80d3f698b27f36cbd453da2"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:gacb233cfd722d66d1ccbf48a7de81f0e0"><td class="memItemLeft" align="right" valign="top">#define&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group___turbo_j_p_e_g.html#gacb233cfd722d66d1ccbf48a7de81f0e0">TJFLAG_ACCURATEDCT</a></td></tr>
+<tr class="memdesc:gacb233cfd722d66d1ccbf48a7de81f0e0"><td class="mdescLeft">&#160;</td><td class="mdescRight">Use the most accurate DCT/IDCT algorithm available in the underlying codec.  <a href="group___turbo_j_p_e_g.html#gacb233cfd722d66d1ccbf48a7de81f0e0">More...</a><br /></td></tr>
+<tr class="separator:gacb233cfd722d66d1ccbf48a7de81f0e0"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:ga519cfa4ef6c18d9e5b455fdf59306a3a"><td class="memItemLeft" align="right" valign="top">#define&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group___turbo_j_p_e_g.html#ga519cfa4ef6c18d9e5b455fdf59306a3a">TJFLAG_STOPONWARNING</a></td></tr>
+<tr class="memdesc:ga519cfa4ef6c18d9e5b455fdf59306a3a"><td class="mdescLeft">&#160;</td><td class="mdescRight">Immediately discontinue the current compression/decompression/transform operation if the underlying codec throws a warning (non-fatal error).  <a href="group___turbo_j_p_e_g.html#ga519cfa4ef6c18d9e5b455fdf59306a3a">More...</a><br /></td></tr>
+<tr class="separator:ga519cfa4ef6c18d9e5b455fdf59306a3a"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:ga43b426750b46190a25d34a67ef76df1b"><td class="memItemLeft" align="right" valign="top">#define&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group___turbo_j_p_e_g.html#ga43b426750b46190a25d34a67ef76df1b">TJFLAG_PROGRESSIVE</a></td></tr>
+<tr class="memdesc:ga43b426750b46190a25d34a67ef76df1b"><td class="mdescLeft">&#160;</td><td class="mdescRight">Use progressive entropy coding in JPEG images generated by the compression and transform functions.  <a href="group___turbo_j_p_e_g.html#ga43b426750b46190a25d34a67ef76df1b">More...</a><br /></td></tr>
+<tr class="separator:ga43b426750b46190a25d34a67ef76df1b"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:ga79bde1b4a3e2351e00887e47781b966e"><td class="memItemLeft" align="right" valign="top">#define&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group___turbo_j_p_e_g.html#ga79bde1b4a3e2351e00887e47781b966e">TJ_NUMERR</a></td></tr>
+<tr class="memdesc:ga79bde1b4a3e2351e00887e47781b966e"><td class="mdescLeft">&#160;</td><td class="mdescRight">The number of error codes.  <a href="group___turbo_j_p_e_g.html#ga79bde1b4a3e2351e00887e47781b966e">More...</a><br /></td></tr>
+<tr class="separator:ga79bde1b4a3e2351e00887e47781b966e"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:ga0f6dbd18adf38b7d46ac547f0f4d562c"><td class="memItemLeft" align="right" valign="top">#define&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group___turbo_j_p_e_g.html#ga0f6dbd18adf38b7d46ac547f0f4d562c">TJ_NUMXOP</a></td></tr>
+<tr class="memdesc:ga0f6dbd18adf38b7d46ac547f0f4d562c"><td class="mdescLeft">&#160;</td><td class="mdescRight">The number of transform operations.  <a href="group___turbo_j_p_e_g.html#ga0f6dbd18adf38b7d46ac547f0f4d562c">More...</a><br /></td></tr>
+<tr class="separator:ga0f6dbd18adf38b7d46ac547f0f4d562c"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:ga50e03cb5ed115330e212417429600b00"><td class="memItemLeft" align="right" valign="top">#define&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group___turbo_j_p_e_g.html#ga50e03cb5ed115330e212417429600b00">TJXOPT_PERFECT</a></td></tr>
+<tr class="memdesc:ga50e03cb5ed115330e212417429600b00"><td class="mdescLeft">&#160;</td><td class="mdescRight">This option will cause <a class="el" href="group___turbo_j_p_e_g.html#ga9cb8abf4cc91881e04a0329b2270be25" title="Losslessly transform a JPEG image into another JPEG image.">tjTransform()</a> to return an error if the transform is not perfect.  <a href="group___turbo_j_p_e_g.html#ga50e03cb5ed115330e212417429600b00">More...</a><br /></td></tr>
+<tr class="separator:ga50e03cb5ed115330e212417429600b00"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:ga319826b7eb1583c0595bbe7b95428709"><td class="memItemLeft" align="right" valign="top">#define&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group___turbo_j_p_e_g.html#ga319826b7eb1583c0595bbe7b95428709">TJXOPT_TRIM</a></td></tr>
+<tr class="memdesc:ga319826b7eb1583c0595bbe7b95428709"><td class="mdescLeft">&#160;</td><td class="mdescRight">This option will cause <a class="el" href="group___turbo_j_p_e_g.html#ga9cb8abf4cc91881e04a0329b2270be25" title="Losslessly transform a JPEG image into another JPEG image.">tjTransform()</a> to discard any partial MCU blocks that cannot be transformed.  <a href="group___turbo_j_p_e_g.html#ga319826b7eb1583c0595bbe7b95428709">More...</a><br /></td></tr>
+<tr class="separator:ga319826b7eb1583c0595bbe7b95428709"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:ga9c771a757fc1294add611906b89ab2d2"><td class="memItemLeft" align="right" valign="top">#define&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group___turbo_j_p_e_g.html#ga9c771a757fc1294add611906b89ab2d2">TJXOPT_CROP</a></td></tr>
+<tr class="memdesc:ga9c771a757fc1294add611906b89ab2d2"><td class="mdescLeft">&#160;</td><td class="mdescRight">This option will enable lossless cropping.  <a href="group___turbo_j_p_e_g.html#ga9c771a757fc1294add611906b89ab2d2">More...</a><br /></td></tr>
+<tr class="separator:ga9c771a757fc1294add611906b89ab2d2"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:ga3acee7b48ade1b99e5588736007c2589"><td class="memItemLeft" align="right" valign="top">#define&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group___turbo_j_p_e_g.html#ga3acee7b48ade1b99e5588736007c2589">TJXOPT_GRAY</a></td></tr>
+<tr class="memdesc:ga3acee7b48ade1b99e5588736007c2589"><td class="mdescLeft">&#160;</td><td class="mdescRight">This option will discard the color data in the input image and produce a grayscale output image.  <a href="group___turbo_j_p_e_g.html#ga3acee7b48ade1b99e5588736007c2589">More...</a><br /></td></tr>
+<tr class="separator:ga3acee7b48ade1b99e5588736007c2589"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:gafbf992bbf6e006705886333703ffab31"><td class="memItemLeft" align="right" valign="top">#define&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group___turbo_j_p_e_g.html#gafbf992bbf6e006705886333703ffab31">TJXOPT_NOOUTPUT</a></td></tr>
+<tr class="memdesc:gafbf992bbf6e006705886333703ffab31"><td class="mdescLeft">&#160;</td><td class="mdescRight">This option will prevent <a class="el" href="group___turbo_j_p_e_g.html#ga9cb8abf4cc91881e04a0329b2270be25" title="Losslessly transform a JPEG image into another JPEG image.">tjTransform()</a> from outputting a JPEG image for this particular transform (this can be used in conjunction with a custom filter to capture the transformed DCT coefficients without transcoding them.)  <a href="group___turbo_j_p_e_g.html#gafbf992bbf6e006705886333703ffab31">More...</a><br /></td></tr>
+<tr class="separator:gafbf992bbf6e006705886333703ffab31"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:gad2371c80674584ecc1a7d75e564cf026"><td class="memItemLeft" align="right" valign="top">#define&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group___turbo_j_p_e_g.html#gad2371c80674584ecc1a7d75e564cf026">TJXOPT_PROGRESSIVE</a></td></tr>
+<tr class="memdesc:gad2371c80674584ecc1a7d75e564cf026"><td class="mdescLeft">&#160;</td><td class="mdescRight">This option will enable progressive entropy coding in the output image generated by this particular transform.  <a href="group___turbo_j_p_e_g.html#gad2371c80674584ecc1a7d75e564cf026">More...</a><br /></td></tr>
+<tr class="separator:gad2371c80674584ecc1a7d75e564cf026"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:ga153b468cfb905d0de61706c838986fe8"><td class="memItemLeft" align="right" valign="top">#define&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group___turbo_j_p_e_g.html#ga153b468cfb905d0de61706c838986fe8">TJXOPT_COPYNONE</a></td></tr>
+<tr class="memdesc:ga153b468cfb905d0de61706c838986fe8"><td class="mdescLeft">&#160;</td><td class="mdescRight">This option will prevent <a class="el" href="group___turbo_j_p_e_g.html#ga9cb8abf4cc91881e04a0329b2270be25" title="Losslessly transform a JPEG image into another JPEG image.">tjTransform()</a> from copying any extra markers (including EXIF and ICC profile data) from the source image to the output image.  <a href="group___turbo_j_p_e_g.html#ga153b468cfb905d0de61706c838986fe8">More...</a><br /></td></tr>
+<tr class="separator:ga153b468cfb905d0de61706c838986fe8"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:ga0aba955473315e405295d978f0c16511"><td class="memItemLeft" align="right" valign="top">#define&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group___turbo_j_p_e_g.html#ga0aba955473315e405295d978f0c16511">TJPAD</a>(width)</td></tr>
+<tr class="memdesc:ga0aba955473315e405295d978f0c16511"><td class="mdescLeft">&#160;</td><td class="mdescRight">Pad the given width to the nearest 32-bit boundary.  <a href="group___turbo_j_p_e_g.html#ga0aba955473315e405295d978f0c16511">More...</a><br /></td></tr>
+<tr class="separator:ga0aba955473315e405295d978f0c16511"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:ga84878bb65404204743aa18cac02781df"><td class="memItemLeft" align="right" valign="top">#define&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group___turbo_j_p_e_g.html#ga84878bb65404204743aa18cac02781df">TJSCALED</a>(dimension,  scalingFactor)</td></tr>
+<tr class="memdesc:ga84878bb65404204743aa18cac02781df"><td class="mdescLeft">&#160;</td><td class="mdescRight">Compute the scaled value of <code>dimension</code> using the given scaling factor.  <a href="group___turbo_j_p_e_g.html#ga84878bb65404204743aa18cac02781df">More...</a><br /></td></tr>
+<tr class="separator:ga84878bb65404204743aa18cac02781df"><td class="memSeparator" colspan="2">&#160;</td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="typedef-members"></a>
+Typedefs</h2></td></tr>
+<tr class="memitem:ga504805ec0161f1b505397ca0118bf8fd"><td class="memItemLeft" align="right" valign="top">typedef struct <a class="el" href="structtjtransform.html">tjtransform</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group___turbo_j_p_e_g.html#ga504805ec0161f1b505397ca0118bf8fd">tjtransform</a></td></tr>
+<tr class="memdesc:ga504805ec0161f1b505397ca0118bf8fd"><td class="mdescLeft">&#160;</td><td class="mdescRight">Lossless transform.  <a href="group___turbo_j_p_e_g.html#ga504805ec0161f1b505397ca0118bf8fd">More...</a><br /></td></tr>
+<tr class="separator:ga504805ec0161f1b505397ca0118bf8fd"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:ga758d2634ecb4949de7815cba621f5763"><td class="memItemLeft" align="right" valign="top">typedef void *&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group___turbo_j_p_e_g.html#ga758d2634ecb4949de7815cba621f5763">tjhandle</a></td></tr>
+<tr class="memdesc:ga758d2634ecb4949de7815cba621f5763"><td class="mdescLeft">&#160;</td><td class="mdescRight">TurboJPEG instance handle.  <a href="group___turbo_j_p_e_g.html#ga758d2634ecb4949de7815cba621f5763">More...</a><br /></td></tr>
+<tr class="separator:ga758d2634ecb4949de7815cba621f5763"><td class="memSeparator" colspan="2">&#160;</td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="enum-members"></a>
+Enumerations</h2></td></tr>
+<tr class="memitem:ga1d047060ea80bb9820d540bb928e9074"><td class="memItemLeft" align="right" valign="top">enum &#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group___turbo_j_p_e_g.html#ga1d047060ea80bb9820d540bb928e9074">TJSAMP</a> { <br />
+&#160;&#160;<a class="el" href="group___turbo_j_p_e_g.html#gga1d047060ea80bb9820d540bb928e9074afb8da4f44197837bdec0a4f593dacae3">TJSAMP_444</a>, 
+<a class="el" href="group___turbo_j_p_e_g.html#gga1d047060ea80bb9820d540bb928e9074a136130902cc578f11f32429b59368404">TJSAMP_422</a>, 
+<a class="el" href="group___turbo_j_p_e_g.html#gga1d047060ea80bb9820d540bb928e9074a63085dbf683cfe39e513cdb6343e3737">TJSAMP_420</a>, 
+<a class="el" href="group___turbo_j_p_e_g.html#gga1d047060ea80bb9820d540bb928e9074a3f1c9504842ddc7a48d0f690754b6248">TJSAMP_GRAY</a>, 
+<br />
+&#160;&#160;<a class="el" href="group___turbo_j_p_e_g.html#gga1d047060ea80bb9820d540bb928e9074accf740e6f3aa6ba20ba922cad13cb974">TJSAMP_440</a>, 
+<a class="el" href="group___turbo_j_p_e_g.html#gga1d047060ea80bb9820d540bb928e9074a28ec62575e5ea295c3fde3001dc628e2">TJSAMP_411</a>
+<br />
+ }</td></tr>
+<tr class="memdesc:ga1d047060ea80bb9820d540bb928e9074"><td class="mdescLeft">&#160;</td><td class="mdescRight">Chrominance subsampling options.  <a href="group___turbo_j_p_e_g.html#ga1d047060ea80bb9820d540bb928e9074">More...</a><br /></td></tr>
+<tr class="separator:ga1d047060ea80bb9820d540bb928e9074"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:gac916144e26c3817ac514e64ae5d12e2a"><td class="memItemLeft" align="right" valign="top">enum &#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group___turbo_j_p_e_g.html#gac916144e26c3817ac514e64ae5d12e2a">TJPF</a> { <br />
+&#160;&#160;<a class="el" href="group___turbo_j_p_e_g.html#ggac916144e26c3817ac514e64ae5d12e2aa7ce93230bff449518ce387c17e6ed37c">TJPF_RGB</a>, 
+<a class="el" href="group___turbo_j_p_e_g.html#ggac916144e26c3817ac514e64ae5d12e2aab10624437fb8ef495a0b153e65749839">TJPF_BGR</a>, 
+<a class="el" href="group___turbo_j_p_e_g.html#ggac916144e26c3817ac514e64ae5d12e2aa83973bebb7e2dc6fa8bae89ff3f42e01">TJPF_RGBX</a>, 
+<a class="el" href="group___turbo_j_p_e_g.html#ggac916144e26c3817ac514e64ae5d12e2aa2a1fbf569ca79897eae886e3376ca4c8">TJPF_BGRX</a>, 
+<br />
+&#160;&#160;<a class="el" href="group___turbo_j_p_e_g.html#ggac916144e26c3817ac514e64ae5d12e2aaf6603b27147de47e212e75dac027b2af">TJPF_XBGR</a>, 
+<a class="el" href="group___turbo_j_p_e_g.html#ggac916144e26c3817ac514e64ae5d12e2aadae996905efcfa3b42a0bb3bea7f9d84">TJPF_XRGB</a>, 
+<a class="el" href="group___turbo_j_p_e_g.html#ggac916144e26c3817ac514e64ae5d12e2aa5431b54b015337705f13118073711a1a">TJPF_GRAY</a>, 
+<a class="el" href="group___turbo_j_p_e_g.html#ggac916144e26c3817ac514e64ae5d12e2aa88d2e88fab67f6503cf972e14851cc12">TJPF_RGBA</a>, 
+<br />
+&#160;&#160;<a class="el" href="group___turbo_j_p_e_g.html#ggac916144e26c3817ac514e64ae5d12e2aac037ff1845cf9b74bb81a3659c2b9fb4">TJPF_BGRA</a>, 
+<a class="el" href="group___turbo_j_p_e_g.html#ggac916144e26c3817ac514e64ae5d12e2aa1ba1a7f1631dbeaa49a0a85fc4a40081">TJPF_ABGR</a>, 
+<a class="el" href="group___turbo_j_p_e_g.html#ggac916144e26c3817ac514e64ae5d12e2aae8f846ed9d9de99b6e1dfe448848765c">TJPF_ARGB</a>, 
+<a class="el" href="group___turbo_j_p_e_g.html#ggac916144e26c3817ac514e64ae5d12e2aa7f5100ec44c91994e243f1cf55553f8b">TJPF_CMYK</a>, 
+<br />
+&#160;&#160;<a class="el" href="group___turbo_j_p_e_g.html#ggac916144e26c3817ac514e64ae5d12e2aa84c1a6cead7952998e2fb895844a21ed">TJPF_UNKNOWN</a>
+<br />
+ }</td></tr>
+<tr class="memdesc:gac916144e26c3817ac514e64ae5d12e2a"><td class="mdescLeft">&#160;</td><td class="mdescRight">Pixel formats.  <a href="group___turbo_j_p_e_g.html#gac916144e26c3817ac514e64ae5d12e2a">More...</a><br /></td></tr>
+<tr class="separator:gac916144e26c3817ac514e64ae5d12e2a"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:ga4f83ad3368e0e29d1957be0efa7c3720"><td class="memItemLeft" align="right" valign="top">enum &#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group___turbo_j_p_e_g.html#ga4f83ad3368e0e29d1957be0efa7c3720">TJCS</a> { <br />
+&#160;&#160;<a class="el" href="group___turbo_j_p_e_g.html#gga4f83ad3368e0e29d1957be0efa7c3720a677cb7ccb85c4038ac41964a2e09e555">TJCS_RGB</a>, 
+<a class="el" href="group___turbo_j_p_e_g.html#gga4f83ad3368e0e29d1957be0efa7c3720a7389b8f65bb387ffedce3efd0d78ec75">TJCS_YCbCr</a>, 
+<a class="el" href="group___turbo_j_p_e_g.html#gga4f83ad3368e0e29d1957be0efa7c3720ab3e7d6a87f695e45b81c1b5262b5a50a">TJCS_GRAY</a>, 
+<a class="el" href="group___turbo_j_p_e_g.html#gga4f83ad3368e0e29d1957be0efa7c3720a6c8b636152ac8195b869587db315ee53">TJCS_CMYK</a>, 
+<br />
+&#160;&#160;<a class="el" href="group___turbo_j_p_e_g.html#gga4f83ad3368e0e29d1957be0efa7c3720a53839e0fe867b76b58d16b0a1a7c598e">TJCS_YCCK</a>
+<br />
+ }</td></tr>
+<tr class="memdesc:ga4f83ad3368e0e29d1957be0efa7c3720"><td class="mdescLeft">&#160;</td><td class="mdescRight">JPEG colorspaces.  <a href="group___turbo_j_p_e_g.html#ga4f83ad3368e0e29d1957be0efa7c3720">More...</a><br /></td></tr>
+<tr class="separator:ga4f83ad3368e0e29d1957be0efa7c3720"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:gafbc17cfa57d0d5d11fea35ac025950fe"><td class="memItemLeft" align="right" valign="top">enum &#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group___turbo_j_p_e_g.html#gafbc17cfa57d0d5d11fea35ac025950fe">TJERR</a> { <a class="el" href="group___turbo_j_p_e_g.html#ggafbc17cfa57d0d5d11fea35ac025950fea342dd6e2aedb47bb257b4e7568329b59">TJERR_WARNING</a>, 
+<a class="el" href="group___turbo_j_p_e_g.html#ggafbc17cfa57d0d5d11fea35ac025950feafc9cceeada13122b09e4851e3788039a">TJERR_FATAL</a>
+ }</td></tr>
+<tr class="memdesc:gafbc17cfa57d0d5d11fea35ac025950fe"><td class="mdescLeft">&#160;</td><td class="mdescRight">Error codes.  <a href="group___turbo_j_p_e_g.html#gafbc17cfa57d0d5d11fea35ac025950fe">More...</a><br /></td></tr>
+<tr class="separator:gafbc17cfa57d0d5d11fea35ac025950fe"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:ga2de531af4e7e6c4f124908376b354866"><td class="memItemLeft" align="right" valign="top">enum &#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group___turbo_j_p_e_g.html#ga2de531af4e7e6c4f124908376b354866">TJXOP</a> { <br />
+&#160;&#160;<a class="el" href="group___turbo_j_p_e_g.html#gga2de531af4e7e6c4f124908376b354866aad88c0366cd3f7d0eac9d7a3fa1c2c27">TJXOP_NONE</a>, 
+<a class="el" href="group___turbo_j_p_e_g.html#gga2de531af4e7e6c4f124908376b354866aa0df69776caa30f0fa28e26332d311ce">TJXOP_HFLIP</a>, 
+<a class="el" href="group___turbo_j_p_e_g.html#gga2de531af4e7e6c4f124908376b354866a324eddfbec53b7e691f61e56929d0d5d">TJXOP_VFLIP</a>, 
+<a class="el" href="group___turbo_j_p_e_g.html#gga2de531af4e7e6c4f124908376b354866a31060aed199f886afdd417f80499c32d">TJXOP_TRANSPOSE</a>, 
+<br />
+&#160;&#160;<a class="el" href="group___turbo_j_p_e_g.html#gga2de531af4e7e6c4f124908376b354866af3b14d488aea6ece9e5b3df73a74d6a4">TJXOP_TRANSVERSE</a>, 
+<a class="el" href="group___turbo_j_p_e_g.html#gga2de531af4e7e6c4f124908376b354866a43b2bbb23bc4bd548422d43fbe9af128">TJXOP_ROT90</a>, 
+<a class="el" href="group___turbo_j_p_e_g.html#gga2de531af4e7e6c4f124908376b354866a140952eb8dd0300accfcc22726d69692">TJXOP_ROT180</a>, 
+<a class="el" href="group___turbo_j_p_e_g.html#gga2de531af4e7e6c4f124908376b354866a3064ee5dfb7f032df332818587567a08">TJXOP_ROT270</a>
+<br />
+ }</td></tr>
+<tr class="memdesc:ga2de531af4e7e6c4f124908376b354866"><td class="mdescLeft">&#160;</td><td class="mdescRight">Transform operations for <a class="el" href="group___turbo_j_p_e_g.html#ga9cb8abf4cc91881e04a0329b2270be25" title="Losslessly transform a JPEG image into another JPEG image.">tjTransform()</a>  <a href="group___turbo_j_p_e_g.html#ga2de531af4e7e6c4f124908376b354866">More...</a><br /></td></tr>
+<tr class="separator:ga2de531af4e7e6c4f124908376b354866"><td class="memSeparator" colspan="2">&#160;</td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="func-members"></a>
+Functions</h2></td></tr>
+<tr class="memitem:ga9d63a05fc6d813f4aae06107041a37e8"><td class="memItemLeft" align="right" valign="top">DLLEXPORT <a class="el" href="group___turbo_j_p_e_g.html#ga758d2634ecb4949de7815cba621f5763">tjhandle</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group___turbo_j_p_e_g.html#ga9d63a05fc6d813f4aae06107041a37e8">tjInitCompress</a> (void)</td></tr>
+<tr class="memdesc:ga9d63a05fc6d813f4aae06107041a37e8"><td class="mdescLeft">&#160;</td><td class="mdescRight">Create a TurboJPEG compressor instance.  <a href="group___turbo_j_p_e_g.html#ga9d63a05fc6d813f4aae06107041a37e8">More...</a><br /></td></tr>
+<tr class="separator:ga9d63a05fc6d813f4aae06107041a37e8"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:gafbdce0112fd78fd38efae841443a9bcf"><td class="memItemLeft" align="right" valign="top">DLLEXPORT int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group___turbo_j_p_e_g.html#gafbdce0112fd78fd38efae841443a9bcf">tjCompress2</a> (<a class="el" href="group___turbo_j_p_e_g.html#ga758d2634ecb4949de7815cba621f5763">tjhandle</a> handle, const unsigned char *srcBuf, int width, int pitch, int height, int pixelFormat, unsigned char **jpegBuf, unsigned long *jpegSize, int jpegSubsamp, int jpegQual, int flags)</td></tr>
+<tr class="memdesc:gafbdce0112fd78fd38efae841443a9bcf"><td class="mdescLeft">&#160;</td><td class="mdescRight">Compress an RGB, grayscale, or CMYK image into a JPEG image.  <a href="group___turbo_j_p_e_g.html#gafbdce0112fd78fd38efae841443a9bcf">More...</a><br /></td></tr>
+<tr class="separator:gafbdce0112fd78fd38efae841443a9bcf"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:ga7622a459b79aa1007e005b58783f875b"><td class="memItemLeft" align="right" valign="top">DLLEXPORT int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group___turbo_j_p_e_g.html#ga7622a459b79aa1007e005b58783f875b">tjCompressFromYUV</a> (<a class="el" href="group___turbo_j_p_e_g.html#ga758d2634ecb4949de7815cba621f5763">tjhandle</a> handle, const unsigned char *srcBuf, int width, int pad, int height, int subsamp, unsigned char **jpegBuf, unsigned long *jpegSize, int jpegQual, int flags)</td></tr>
+<tr class="memdesc:ga7622a459b79aa1007e005b58783f875b"><td class="mdescLeft">&#160;</td><td class="mdescRight">Compress a YUV planar image into a JPEG image.  <a href="group___turbo_j_p_e_g.html#ga7622a459b79aa1007e005b58783f875b">More...</a><br /></td></tr>
+<tr class="separator:ga7622a459b79aa1007e005b58783f875b"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:ga29ec5dfbd2d84b8724e951d6fa0d5d9e"><td class="memItemLeft" align="right" valign="top">DLLEXPORT int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group___turbo_j_p_e_g.html#ga29ec5dfbd2d84b8724e951d6fa0d5d9e">tjCompressFromYUVPlanes</a> (<a class="el" href="group___turbo_j_p_e_g.html#ga758d2634ecb4949de7815cba621f5763">tjhandle</a> handle, const unsigned char **srcPlanes, int width, const int *strides, int height, int subsamp, unsigned char **jpegBuf, unsigned long *jpegSize, int jpegQual, int flags)</td></tr>
+<tr class="memdesc:ga29ec5dfbd2d84b8724e951d6fa0d5d9e"><td class="mdescLeft">&#160;</td><td class="mdescRight">Compress a set of Y, U (Cb), and V (Cr) image planes into a JPEG image.  <a href="group___turbo_j_p_e_g.html#ga29ec5dfbd2d84b8724e951d6fa0d5d9e">More...</a><br /></td></tr>
+<tr class="separator:ga29ec5dfbd2d84b8724e951d6fa0d5d9e"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:ga67ac12fee79073242cb216e07c9f1f90"><td class="memItemLeft" align="right" valign="top">DLLEXPORT unsigned long&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group___turbo_j_p_e_g.html#ga67ac12fee79073242cb216e07c9f1f90">tjBufSize</a> (int width, int height, int jpegSubsamp)</td></tr>
+<tr class="memdesc:ga67ac12fee79073242cb216e07c9f1f90"><td class="mdescLeft">&#160;</td><td class="mdescRight">The maximum size of the buffer (in bytes) required to hold a JPEG image with the given parameters.  <a href="group___turbo_j_p_e_g.html#ga67ac12fee79073242cb216e07c9f1f90">More...</a><br /></td></tr>
+<tr class="separator:ga67ac12fee79073242cb216e07c9f1f90"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:ga2be2b9969d4df9ecce9b05deed273194"><td class="memItemLeft" align="right" valign="top">DLLEXPORT unsigned long&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group___turbo_j_p_e_g.html#ga2be2b9969d4df9ecce9b05deed273194">tjBufSizeYUV2</a> (int width, int pad, int height, int subsamp)</td></tr>
+<tr class="memdesc:ga2be2b9969d4df9ecce9b05deed273194"><td class="mdescLeft">&#160;</td><td class="mdescRight">The size of the buffer (in bytes) required to hold a YUV planar image with the given parameters.  <a href="group___turbo_j_p_e_g.html#ga2be2b9969d4df9ecce9b05deed273194">More...</a><br /></td></tr>
+<tr class="separator:ga2be2b9969d4df9ecce9b05deed273194"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:gab4ab7b24f6e797d79abaaa670373961d"><td class="memItemLeft" align="right" valign="top">DLLEXPORT unsigned long&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group___turbo_j_p_e_g.html#gab4ab7b24f6e797d79abaaa670373961d">tjPlaneSizeYUV</a> (int componentID, int width, int stride, int height, int subsamp)</td></tr>
+<tr class="memdesc:gab4ab7b24f6e797d79abaaa670373961d"><td class="mdescLeft">&#160;</td><td class="mdescRight">The size of the buffer (in bytes) required to hold a YUV image plane with the given parameters.  <a href="group___turbo_j_p_e_g.html#gab4ab7b24f6e797d79abaaa670373961d">More...</a><br /></td></tr>
+<tr class="separator:gab4ab7b24f6e797d79abaaa670373961d"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:ga63fb66bb1e36c74008c4634360becbb1"><td class="memItemLeft" align="right" valign="top">DLLEXPORT int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group___turbo_j_p_e_g.html#ga63fb66bb1e36c74008c4634360becbb1">tjPlaneWidth</a> (int componentID, int width, int subsamp)</td></tr>
+<tr class="memdesc:ga63fb66bb1e36c74008c4634360becbb1"><td class="mdescLeft">&#160;</td><td class="mdescRight">The plane width of a YUV image plane with the given parameters.  <a href="group___turbo_j_p_e_g.html#ga63fb66bb1e36c74008c4634360becbb1">More...</a><br /></td></tr>
+<tr class="separator:ga63fb66bb1e36c74008c4634360becbb1"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:ga1a209696c6a80748f20e134b3c64789f"><td class="memItemLeft" align="right" valign="top">DLLEXPORT int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group___turbo_j_p_e_g.html#ga1a209696c6a80748f20e134b3c64789f">tjPlaneHeight</a> (int componentID, int height, int subsamp)</td></tr>
+<tr class="memdesc:ga1a209696c6a80748f20e134b3c64789f"><td class="mdescLeft">&#160;</td><td class="mdescRight">The plane height of a YUV image plane with the given parameters.  <a href="group___turbo_j_p_e_g.html#ga1a209696c6a80748f20e134b3c64789f">More...</a><br /></td></tr>
+<tr class="separator:ga1a209696c6a80748f20e134b3c64789f"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:gac519b922cdf446e97d0cdcba513636bf"><td class="memItemLeft" align="right" valign="top">DLLEXPORT int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group___turbo_j_p_e_g.html#gac519b922cdf446e97d0cdcba513636bf">tjEncodeYUV3</a> (<a class="el" href="group___turbo_j_p_e_g.html#ga758d2634ecb4949de7815cba621f5763">tjhandle</a> handle, const unsigned char *srcBuf, int width, int pitch, int height, int pixelFormat, unsigned char *dstBuf, int pad, int subsamp, int flags)</td></tr>
+<tr class="memdesc:gac519b922cdf446e97d0cdcba513636bf"><td class="mdescLeft">&#160;</td><td class="mdescRight">Encode an RGB or grayscale image into a YUV planar image.  <a href="group___turbo_j_p_e_g.html#gac519b922cdf446e97d0cdcba513636bf">More...</a><br /></td></tr>
+<tr class="separator:gac519b922cdf446e97d0cdcba513636bf"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:gae2d04c72457fe7f4d60cf78ab1b1feb1"><td class="memItemLeft" align="right" valign="top">DLLEXPORT int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group___turbo_j_p_e_g.html#gae2d04c72457fe7f4d60cf78ab1b1feb1">tjEncodeYUVPlanes</a> (<a class="el" href="group___turbo_j_p_e_g.html#ga758d2634ecb4949de7815cba621f5763">tjhandle</a> handle, const unsigned char *srcBuf, int width, int pitch, int height, int pixelFormat, unsigned char **dstPlanes, int *strides, int subsamp, int flags)</td></tr>
+<tr class="memdesc:gae2d04c72457fe7f4d60cf78ab1b1feb1"><td class="mdescLeft">&#160;</td><td class="mdescRight">Encode an RGB or grayscale image into separate Y, U (Cb), and V (Cr) image planes.  <a href="group___turbo_j_p_e_g.html#gae2d04c72457fe7f4d60cf78ab1b1feb1">More...</a><br /></td></tr>
+<tr class="separator:gae2d04c72457fe7f4d60cf78ab1b1feb1"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:ga52300eac3f3d9ef4bab303bc244f62d3"><td class="memItemLeft" align="right" valign="top">DLLEXPORT <a class="el" href="group___turbo_j_p_e_g.html#ga758d2634ecb4949de7815cba621f5763">tjhandle</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group___turbo_j_p_e_g.html#ga52300eac3f3d9ef4bab303bc244f62d3">tjInitDecompress</a> (void)</td></tr>
+<tr class="memdesc:ga52300eac3f3d9ef4bab303bc244f62d3"><td class="mdescLeft">&#160;</td><td class="mdescRight">Create a TurboJPEG decompressor instance.  <a href="group___turbo_j_p_e_g.html#ga52300eac3f3d9ef4bab303bc244f62d3">More...</a><br /></td></tr>
+<tr class="separator:ga52300eac3f3d9ef4bab303bc244f62d3"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:ga0595681096bba7199cc6f3533cb25f77"><td class="memItemLeft" align="right" valign="top">DLLEXPORT int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group___turbo_j_p_e_g.html#ga0595681096bba7199cc6f3533cb25f77">tjDecompressHeader3</a> (<a class="el" href="group___turbo_j_p_e_g.html#ga758d2634ecb4949de7815cba621f5763">tjhandle</a> handle, const unsigned char *jpegBuf, unsigned long jpegSize, int *width, int *height, int *jpegSubsamp, int *jpegColorspace)</td></tr>
+<tr class="memdesc:ga0595681096bba7199cc6f3533cb25f77"><td class="mdescLeft">&#160;</td><td class="mdescRight">Retrieve information about a JPEG image without decompressing it.  <a href="group___turbo_j_p_e_g.html#ga0595681096bba7199cc6f3533cb25f77">More...</a><br /></td></tr>
+<tr class="separator:ga0595681096bba7199cc6f3533cb25f77"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:gac3854476006b10787bd128f7ede48057"><td class="memItemLeft" align="right" valign="top">DLLEXPORT <a class="el" href="structtjscalingfactor.html">tjscalingfactor</a> *&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group___turbo_j_p_e_g.html#gac3854476006b10787bd128f7ede48057">tjGetScalingFactors</a> (int *numscalingfactors)</td></tr>
+<tr class="memdesc:gac3854476006b10787bd128f7ede48057"><td class="mdescLeft">&#160;</td><td class="mdescRight">Returns a list of fractional scaling factors that the JPEG decompressor in this implementation of TurboJPEG supports.  <a href="group___turbo_j_p_e_g.html#gac3854476006b10787bd128f7ede48057">More...</a><br /></td></tr>
+<tr class="separator:gac3854476006b10787bd128f7ede48057"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:gae9eccef8b682a48f43a9117c231ed013"><td class="memItemLeft" align="right" valign="top">DLLEXPORT int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group___turbo_j_p_e_g.html#gae9eccef8b682a48f43a9117c231ed013">tjDecompress2</a> (<a class="el" href="group___turbo_j_p_e_g.html#ga758d2634ecb4949de7815cba621f5763">tjhandle</a> handle, const unsigned char *jpegBuf, unsigned long jpegSize, unsigned char *dstBuf, int width, int pitch, int height, int pixelFormat, int flags)</td></tr>
+<tr class="memdesc:gae9eccef8b682a48f43a9117c231ed013"><td class="mdescLeft">&#160;</td><td class="mdescRight">Decompress a JPEG image to an RGB, grayscale, or CMYK image.  <a href="group___turbo_j_p_e_g.html#gae9eccef8b682a48f43a9117c231ed013">More...</a><br /></td></tr>
+<tr class="separator:gae9eccef8b682a48f43a9117c231ed013"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:ga04d1e839ff9a0860dd1475cff78d3364"><td class="memItemLeft" align="right" valign="top">DLLEXPORT int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group___turbo_j_p_e_g.html#ga04d1e839ff9a0860dd1475cff78d3364">tjDecompressToYUV2</a> (<a class="el" href="group___turbo_j_p_e_g.html#ga758d2634ecb4949de7815cba621f5763">tjhandle</a> handle, const unsigned char *jpegBuf, unsigned long jpegSize, unsigned char *dstBuf, int width, int pad, int height, int flags)</td></tr>
+<tr class="memdesc:ga04d1e839ff9a0860dd1475cff78d3364"><td class="mdescLeft">&#160;</td><td class="mdescRight">Decompress a JPEG image to a YUV planar image.  <a href="group___turbo_j_p_e_g.html#ga04d1e839ff9a0860dd1475cff78d3364">More...</a><br /></td></tr>
+<tr class="separator:ga04d1e839ff9a0860dd1475cff78d3364"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:gaa59f901a5258ada5bd0185ad59368540"><td class="memItemLeft" align="right" valign="top">DLLEXPORT int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group___turbo_j_p_e_g.html#gaa59f901a5258ada5bd0185ad59368540">tjDecompressToYUVPlanes</a> (<a class="el" href="group___turbo_j_p_e_g.html#ga758d2634ecb4949de7815cba621f5763">tjhandle</a> handle, const unsigned char *jpegBuf, unsigned long jpegSize, unsigned char **dstPlanes, int width, int *strides, int height, int flags)</td></tr>
+<tr class="memdesc:gaa59f901a5258ada5bd0185ad59368540"><td class="mdescLeft">&#160;</td><td class="mdescRight">Decompress a JPEG image into separate Y, U (Cb), and V (Cr) image planes.  <a href="group___turbo_j_p_e_g.html#gaa59f901a5258ada5bd0185ad59368540">More...</a><br /></td></tr>
+<tr class="separator:gaa59f901a5258ada5bd0185ad59368540"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:ga70abbf38f77a26fd6da8813bef96f695"><td class="memItemLeft" align="right" valign="top">DLLEXPORT int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group___turbo_j_p_e_g.html#ga70abbf38f77a26fd6da8813bef96f695">tjDecodeYUV</a> (<a class="el" href="group___turbo_j_p_e_g.html#ga758d2634ecb4949de7815cba621f5763">tjhandle</a> handle, const unsigned char *srcBuf, int pad, int subsamp, unsigned char *dstBuf, int width, int pitch, int height, int pixelFormat, int flags)</td></tr>
+<tr class="memdesc:ga70abbf38f77a26fd6da8813bef96f695"><td class="mdescLeft">&#160;</td><td class="mdescRight">Decode a YUV planar image into an RGB or grayscale image.  <a href="group___turbo_j_p_e_g.html#ga70abbf38f77a26fd6da8813bef96f695">More...</a><br /></td></tr>
+<tr class="separator:ga70abbf38f77a26fd6da8813bef96f695"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:ga10e837c07fa9d25770565b237d3898d9"><td class="memItemLeft" align="right" valign="top">DLLEXPORT int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group___turbo_j_p_e_g.html#ga10e837c07fa9d25770565b237d3898d9">tjDecodeYUVPlanes</a> (<a class="el" href="group___turbo_j_p_e_g.html#ga758d2634ecb4949de7815cba621f5763">tjhandle</a> handle, const unsigned char **srcPlanes, const int *strides, int subsamp, unsigned char *dstBuf, int width, int pitch, int height, int pixelFormat, int flags)</td></tr>
+<tr class="memdesc:ga10e837c07fa9d25770565b237d3898d9"><td class="mdescLeft">&#160;</td><td class="mdescRight">Decode a set of Y, U (Cb), and V (Cr) image planes into an RGB or grayscale image.  <a href="group___turbo_j_p_e_g.html#ga10e837c07fa9d25770565b237d3898d9">More...</a><br /></td></tr>
+<tr class="separator:ga10e837c07fa9d25770565b237d3898d9"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:ga928beff6ac248ceadf01089fc6b41957"><td class="memItemLeft" align="right" valign="top">DLLEXPORT <a class="el" href="group___turbo_j_p_e_g.html#ga758d2634ecb4949de7815cba621f5763">tjhandle</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group___turbo_j_p_e_g.html#ga928beff6ac248ceadf01089fc6b41957">tjInitTransform</a> (void)</td></tr>
+<tr class="memdesc:ga928beff6ac248ceadf01089fc6b41957"><td class="mdescLeft">&#160;</td><td class="mdescRight">Create a new TurboJPEG transformer instance.  <a href="group___turbo_j_p_e_g.html#ga928beff6ac248ceadf01089fc6b41957">More...</a><br /></td></tr>
+<tr class="separator:ga928beff6ac248ceadf01089fc6b41957"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:ga9cb8abf4cc91881e04a0329b2270be25"><td class="memItemLeft" align="right" valign="top">DLLEXPORT int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group___turbo_j_p_e_g.html#ga9cb8abf4cc91881e04a0329b2270be25">tjTransform</a> (<a class="el" href="group___turbo_j_p_e_g.html#ga758d2634ecb4949de7815cba621f5763">tjhandle</a> handle, const unsigned char *jpegBuf, unsigned long jpegSize, int n, unsigned char **dstBufs, unsigned long *dstSizes, <a class="el" href="structtjtransform.html">tjtransform</a> *transforms, int flags)</td></tr>
+<tr class="memdesc:ga9cb8abf4cc91881e04a0329b2270be25"><td class="mdescLeft">&#160;</td><td class="mdescRight">Losslessly transform a JPEG image into another JPEG image.  <a href="group___turbo_j_p_e_g.html#ga9cb8abf4cc91881e04a0329b2270be25">More...</a><br /></td></tr>
+<tr class="separator:ga9cb8abf4cc91881e04a0329b2270be25"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:ga75f355fa27225ba1a4ee392c852394d2"><td class="memItemLeft" align="right" valign="top">DLLEXPORT int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group___turbo_j_p_e_g.html#ga75f355fa27225ba1a4ee392c852394d2">tjDestroy</a> (<a class="el" href="group___turbo_j_p_e_g.html#ga758d2634ecb4949de7815cba621f5763">tjhandle</a> handle)</td></tr>
+<tr class="memdesc:ga75f355fa27225ba1a4ee392c852394d2"><td class="mdescLeft">&#160;</td><td class="mdescRight">Destroy a TurboJPEG compressor, decompressor, or transformer instance.  <a href="group___turbo_j_p_e_g.html#ga75f355fa27225ba1a4ee392c852394d2">More...</a><br /></td></tr>
+<tr class="separator:ga75f355fa27225ba1a4ee392c852394d2"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:gaec627dd4c5f30b7a775a7aea3bec5d83"><td class="memItemLeft" align="right" valign="top">DLLEXPORT unsigned char *&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group___turbo_j_p_e_g.html#gaec627dd4c5f30b7a775a7aea3bec5d83">tjAlloc</a> (int bytes)</td></tr>
+<tr class="memdesc:gaec627dd4c5f30b7a775a7aea3bec5d83"><td class="mdescLeft">&#160;</td><td class="mdescRight">Allocate an image buffer for use with TurboJPEG.  <a href="group___turbo_j_p_e_g.html#gaec627dd4c5f30b7a775a7aea3bec5d83">More...</a><br /></td></tr>
+<tr class="separator:gaec627dd4c5f30b7a775a7aea3bec5d83"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:gaffbd83c375e79f5db4b5c5d8ad4466e7"><td class="memItemLeft" align="right" valign="top">DLLEXPORT unsigned char *&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group___turbo_j_p_e_g.html#gaffbd83c375e79f5db4b5c5d8ad4466e7">tjLoadImage</a> (const char *filename, int *width, int align, int *height, int *pixelFormat, int flags)</td></tr>
+<tr class="memdesc:gaffbd83c375e79f5db4b5c5d8ad4466e7"><td class="mdescLeft">&#160;</td><td class="mdescRight">Load an uncompressed image from disk into memory.  <a href="group___turbo_j_p_e_g.html#gaffbd83c375e79f5db4b5c5d8ad4466e7">More...</a><br /></td></tr>
+<tr class="separator:gaffbd83c375e79f5db4b5c5d8ad4466e7"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:ga6f445b22d8933ae4815b3370a538d879"><td class="memItemLeft" align="right" valign="top">DLLEXPORT int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group___turbo_j_p_e_g.html#ga6f445b22d8933ae4815b3370a538d879">tjSaveImage</a> (const char *filename, unsigned char *buffer, int width, int pitch, int height, int pixelFormat, int flags)</td></tr>
+<tr class="memdesc:ga6f445b22d8933ae4815b3370a538d879"><td class="mdescLeft">&#160;</td><td class="mdescRight">Save an uncompressed image from memory to disk.  <a href="group___turbo_j_p_e_g.html#ga6f445b22d8933ae4815b3370a538d879">More...</a><br /></td></tr>
+<tr class="separator:ga6f445b22d8933ae4815b3370a538d879"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:gaea863d2da0cdb609563aabdf9196514b"><td class="memItemLeft" align="right" valign="top">DLLEXPORT void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group___turbo_j_p_e_g.html#gaea863d2da0cdb609563aabdf9196514b">tjFree</a> (unsigned char *buffer)</td></tr>
+<tr class="memdesc:gaea863d2da0cdb609563aabdf9196514b"><td class="mdescLeft">&#160;</td><td class="mdescRight">Free an image buffer previously allocated by TurboJPEG.  <a href="group___turbo_j_p_e_g.html#gaea863d2da0cdb609563aabdf9196514b">More...</a><br /></td></tr>
+<tr class="separator:gaea863d2da0cdb609563aabdf9196514b"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:ga1ead8574f9f39fbafc6b497124e7aafa"><td class="memItemLeft" align="right" valign="top">DLLEXPORT char *&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group___turbo_j_p_e_g.html#ga1ead8574f9f39fbafc6b497124e7aafa">tjGetErrorStr2</a> (<a class="el" href="group___turbo_j_p_e_g.html#ga758d2634ecb4949de7815cba621f5763">tjhandle</a> handle)</td></tr>
+<tr class="memdesc:ga1ead8574f9f39fbafc6b497124e7aafa"><td class="mdescLeft">&#160;</td><td class="mdescRight">Returns a descriptive error message explaining why the last command failed.  <a href="group___turbo_j_p_e_g.html#ga1ead8574f9f39fbafc6b497124e7aafa">More...</a><br /></td></tr>
+<tr class="separator:ga1ead8574f9f39fbafc6b497124e7aafa"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:ga414feeffbf860ebd31c745df203de410"><td class="memItemLeft" align="right" valign="top">DLLEXPORT int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group___turbo_j_p_e_g.html#ga414feeffbf860ebd31c745df203de410">tjGetErrorCode</a> (<a class="el" href="group___turbo_j_p_e_g.html#ga758d2634ecb4949de7815cba621f5763">tjhandle</a> handle)</td></tr>
+<tr class="memdesc:ga414feeffbf860ebd31c745df203de410"><td class="mdescLeft">&#160;</td><td class="mdescRight">Returns a code indicating the severity of the last error.  <a href="group___turbo_j_p_e_g.html#ga414feeffbf860ebd31c745df203de410">More...</a><br /></td></tr>
+<tr class="separator:ga414feeffbf860ebd31c745df203de410"><td class="memSeparator" colspan="2">&#160;</td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="var-members"></a>
+Variables</h2></td></tr>
+<tr class="memitem:ga9e61e7cd47a15a173283ba94e781308c"><td class="memItemLeft" align="right" valign="top">static const int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group___turbo_j_p_e_g.html#ga9e61e7cd47a15a173283ba94e781308c">tjMCUWidth</a> [<a class="el" href="group___turbo_j_p_e_g.html#ga5ef3d169162ce77ce348e292a0b7477c">TJ_NUMSAMP</a>]</td></tr>
+<tr class="memdesc:ga9e61e7cd47a15a173283ba94e781308c"><td class="mdescLeft">&#160;</td><td class="mdescRight">MCU block width (in pixels) for a given level of chrominance subsampling.  <a href="group___turbo_j_p_e_g.html#ga9e61e7cd47a15a173283ba94e781308c">More...</a><br /></td></tr>
+<tr class="separator:ga9e61e7cd47a15a173283ba94e781308c"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:gabd247bb9fecb393eca57366feb8327bf"><td class="memItemLeft" align="right" valign="top">static const int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group___turbo_j_p_e_g.html#gabd247bb9fecb393eca57366feb8327bf">tjMCUHeight</a> [<a class="el" href="group___turbo_j_p_e_g.html#ga5ef3d169162ce77ce348e292a0b7477c">TJ_NUMSAMP</a>]</td></tr>
+<tr class="memdesc:gabd247bb9fecb393eca57366feb8327bf"><td class="mdescLeft">&#160;</td><td class="mdescRight">MCU block height (in pixels) for a given level of chrominance subsampling.  <a href="group___turbo_j_p_e_g.html#gabd247bb9fecb393eca57366feb8327bf">More...</a><br /></td></tr>
+<tr class="separator:gabd247bb9fecb393eca57366feb8327bf"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:gadd9b446742ac8a3923f7992c7988fea8"><td class="memItemLeft" align="right" valign="top">static const int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group___turbo_j_p_e_g.html#gadd9b446742ac8a3923f7992c7988fea8">tjRedOffset</a> [<a class="el" href="group___turbo_j_p_e_g.html#ga7010a4402f54a45ba822ad8675a4655e">TJ_NUMPF</a>]</td></tr>
+<tr class="memdesc:gadd9b446742ac8a3923f7992c7988fea8"><td class="mdescLeft">&#160;</td><td class="mdescRight">Red offset (in bytes) for a given pixel format.  <a href="group___turbo_j_p_e_g.html#gadd9b446742ac8a3923f7992c7988fea8">More...</a><br /></td></tr>
+<tr class="separator:gadd9b446742ac8a3923f7992c7988fea8"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:ga82d6e35da441112a411da41923c0ba2f"><td class="memItemLeft" align="right" valign="top">static const int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group___turbo_j_p_e_g.html#ga82d6e35da441112a411da41923c0ba2f">tjGreenOffset</a> [<a class="el" href="group___turbo_j_p_e_g.html#ga7010a4402f54a45ba822ad8675a4655e">TJ_NUMPF</a>]</td></tr>
+<tr class="memdesc:ga82d6e35da441112a411da41923c0ba2f"><td class="mdescLeft">&#160;</td><td class="mdescRight">Green offset (in bytes) for a given pixel format.  <a href="group___turbo_j_p_e_g.html#ga82d6e35da441112a411da41923c0ba2f">More...</a><br /></td></tr>
+<tr class="separator:ga82d6e35da441112a411da41923c0ba2f"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:ga84e2e35d3f08025f976ec1ec53693dea"><td class="memItemLeft" align="right" valign="top">static const int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group___turbo_j_p_e_g.html#ga84e2e35d3f08025f976ec1ec53693dea">tjBlueOffset</a> [<a class="el" href="group___turbo_j_p_e_g.html#ga7010a4402f54a45ba822ad8675a4655e">TJ_NUMPF</a>]</td></tr>
+<tr class="memdesc:ga84e2e35d3f08025f976ec1ec53693dea"><td class="mdescLeft">&#160;</td><td class="mdescRight">Blue offset (in bytes) for a given pixel format.  <a href="group___turbo_j_p_e_g.html#ga84e2e35d3f08025f976ec1ec53693dea">More...</a><br /></td></tr>
+<tr class="separator:ga84e2e35d3f08025f976ec1ec53693dea"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:ga5af0ab065feefd526debf1e20c43e837"><td class="memItemLeft" align="right" valign="top">static const int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group___turbo_j_p_e_g.html#ga5af0ab065feefd526debf1e20c43e837">tjAlphaOffset</a> [<a class="el" href="group___turbo_j_p_e_g.html#ga7010a4402f54a45ba822ad8675a4655e">TJ_NUMPF</a>]</td></tr>
+<tr class="memdesc:ga5af0ab065feefd526debf1e20c43e837"><td class="mdescLeft">&#160;</td><td class="mdescRight">Alpha offset (in bytes) for a given pixel format.  <a href="group___turbo_j_p_e_g.html#ga5af0ab065feefd526debf1e20c43e837">More...</a><br /></td></tr>
+<tr class="separator:ga5af0ab065feefd526debf1e20c43e837"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:gad77cf8fe5b2bfd3cb3f53098146abb4c"><td class="memItemLeft" align="right" valign="top">static const int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="group___turbo_j_p_e_g.html#gad77cf8fe5b2bfd3cb3f53098146abb4c">tjPixelSize</a> [<a class="el" href="group___turbo_j_p_e_g.html#ga7010a4402f54a45ba822ad8675a4655e">TJ_NUMPF</a>]</td></tr>
+<tr class="memdesc:gad77cf8fe5b2bfd3cb3f53098146abb4c"><td class="mdescLeft">&#160;</td><td class="mdescRight">Pixel size (in bytes) for a given pixel format.  <a href="group___turbo_j_p_e_g.html#gad77cf8fe5b2bfd3cb3f53098146abb4c">More...</a><br /></td></tr>
+<tr class="separator:gad77cf8fe5b2bfd3cb3f53098146abb4c"><td class="memSeparator" colspan="2">&#160;</td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<p>TurboJPEG API. </p>
+<p>This API provides an interface for generating, decoding, and transforming planar YUV and JPEG images in memory.</p>
+<p><a class="anchor" id="YUVnotes"></a></p>
+<h2><a class="anchor" id="autotoc_md0"></a>
+YUV Image Format Notes</h2>
+<p>Technically, the JPEG format uses the YCbCr colorspace (which is technically not a colorspace but a color transform), but per the convention of the digital video community, the TurboJPEG API uses "YUV" to refer to an image format consisting of Y, Cb, and Cr image planes.</p>
+<p>Each plane is simply a 2D array of bytes, each byte representing the value of one of the components (Y, Cb, or Cr) at a particular location in the image. The width and height of each plane are determined by the image width, height, and level of chrominance subsampling. The luminance plane width is the image width padded to the nearest multiple of the horizontal subsampling factor (2 in the case of 4:2:0 and 4:2:2, 4 in the case of 4:1:1, 1 in the case of 4:4:4 or grayscale.) Similarly, the luminance plane height is the image height padded to the nearest multiple of the vertical subsampling factor (2 in the case of 4:2:0 or 4:4:0, 1 in the case of 4:4:4 or grayscale.) This is irrespective of any additional padding that may be specified as an argument to the various YUV functions. The chrominance plane width is equal to the luminance plane width divided by the horizontal subsampling factor, and the chrominance plane height is equal to the luminance plane height divided by the vertical subsampling factor.</p>
+<p>For example, if the source image is 35 x 35 pixels and 4:2:2 subsampling is used, then the luminance plane would be 36 x 35 bytes, and each of the chrominance planes would be 18 x 35 bytes. If you specify a line padding of 4 bytes on top of this, then the luminance plane would be 36 x 35 bytes, and each of the chrominance planes would be 20 x 35 bytes. </p>
+<h2 class="groupheader">Macro Definition Documentation</h2>
+<a id="ga39f57a6fb02d9cf32e7b6890099b5a71"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga39f57a6fb02d9cf32e7b6890099b5a71">&#9670;&nbsp;</a></span>TJ_NUMCS</h2>
+
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">#define TJ_NUMCS</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+
+<p>The number of JPEG colorspaces. </p>
+
+</div>
+</div>
+<a id="ga79bde1b4a3e2351e00887e47781b966e"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga79bde1b4a3e2351e00887e47781b966e">&#9670;&nbsp;</a></span>TJ_NUMERR</h2>
+
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">#define TJ_NUMERR</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+
+<p>The number of error codes. </p>
+
+</div>
+</div>
+<a id="ga7010a4402f54a45ba822ad8675a4655e"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga7010a4402f54a45ba822ad8675a4655e">&#9670;&nbsp;</a></span>TJ_NUMPF</h2>
+
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">#define TJ_NUMPF</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+
+<p>The number of pixel formats. </p>
+
+</div>
+</div>
+<a id="ga5ef3d169162ce77ce348e292a0b7477c"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga5ef3d169162ce77ce348e292a0b7477c">&#9670;&nbsp;</a></span>TJ_NUMSAMP</h2>
+
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">#define TJ_NUMSAMP</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+
+<p>The number of chrominance subsampling options. </p>
+
+</div>
+</div>
+<a id="ga0f6dbd18adf38b7d46ac547f0f4d562c"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga0f6dbd18adf38b7d46ac547f0f4d562c">&#9670;&nbsp;</a></span>TJ_NUMXOP</h2>
+
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">#define TJ_NUMXOP</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+
+<p>The number of transform operations. </p>
+
+</div>
+</div>
+<a id="gacb233cfd722d66d1ccbf48a7de81f0e0"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gacb233cfd722d66d1ccbf48a7de81f0e0">&#9670;&nbsp;</a></span>TJFLAG_ACCURATEDCT</h2>
+
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">#define TJFLAG_ACCURATEDCT</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+
+<p>Use the most accurate DCT/IDCT algorithm available in the underlying codec. </p>
+<p>The default if this flag is not specified is implementation-specific. For example, the implementation of TurboJPEG for libjpeg[-turbo] uses the fast algorithm by default when compressing, because this has been shown to have only a very slight effect on accuracy, but it uses the accurate algorithm when decompressing, because this has been shown to have a larger effect. </p>
+
+</div>
+</div>
+<a id="ga72ecf4ebe6eb702d3c6f5ca27455e1ec"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga72ecf4ebe6eb702d3c6f5ca27455e1ec">&#9670;&nbsp;</a></span>TJFLAG_BOTTOMUP</h2>
+
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">#define TJFLAG_BOTTOMUP</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+
+<p>The uncompressed source/destination image is stored in bottom-up (Windows, OpenGL) order, not top-down (X11) order. </p>
+
+</div>
+</div>
+<a id="gaabce235db80d3f698b27f36cbd453da2"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gaabce235db80d3f698b27f36cbd453da2">&#9670;&nbsp;</a></span>TJFLAG_FASTDCT</h2>
+
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">#define TJFLAG_FASTDCT</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+
+<p>Use the fastest DCT/IDCT algorithm available in the underlying codec. </p>
+<p>The default if this flag is not specified is implementation-specific. For example, the implementation of TurboJPEG for libjpeg[-turbo] uses the fast algorithm by default when compressing, because this has been shown to have only a very slight effect on accuracy, but it uses the accurate algorithm when decompressing, because this has been shown to have a larger effect. </p>
+
+</div>
+</div>
+<a id="ga4ee4506c81177a06f77e2504a22efd2d"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga4ee4506c81177a06f77e2504a22efd2d">&#9670;&nbsp;</a></span>TJFLAG_FASTUPSAMPLE</h2>
+
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">#define TJFLAG_FASTUPSAMPLE</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+
+<p>When decompressing an image that was compressed using chrominance subsampling, use the fastest chrominance upsampling algorithm available in the underlying codec. </p>
+<p>The default is to use smooth upsampling, which creates a smooth transition between neighboring chrominance components in order to reduce upsampling artifacts in the decompressed image. </p>
+
+</div>
+</div>
+<a id="ga8808d403c68b62aaa58a4c1e58e98963"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga8808d403c68b62aaa58a4c1e58e98963">&#9670;&nbsp;</a></span>TJFLAG_NOREALLOC</h2>
+
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">#define TJFLAG_NOREALLOC</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+
+<p>Disable buffer (re)allocation. </p>
+<p>If passed to one of the JPEG compression or transform functions, this flag will cause those functions to generate an error if the JPEG image buffer is invalid or too small rather than attempting to allocate or reallocate that buffer. This reproduces the behavior of earlier versions of TurboJPEG. </p>
+
+</div>
+</div>
+<a id="ga43b426750b46190a25d34a67ef76df1b"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga43b426750b46190a25d34a67ef76df1b">&#9670;&nbsp;</a></span>TJFLAG_PROGRESSIVE</h2>
+
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">#define TJFLAG_PROGRESSIVE</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+
+<p>Use progressive entropy coding in JPEG images generated by the compression and transform functions. </p>
+<p>Progressive entropy coding will generally improve compression relative to baseline entropy coding (the default), but it will reduce compression and decompression performance considerably. </p>
+
+</div>
+</div>
+<a id="ga519cfa4ef6c18d9e5b455fdf59306a3a"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga519cfa4ef6c18d9e5b455fdf59306a3a">&#9670;&nbsp;</a></span>TJFLAG_STOPONWARNING</h2>
+
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">#define TJFLAG_STOPONWARNING</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+
+<p>Immediately discontinue the current compression/decompression/transform operation if the underlying codec throws a warning (non-fatal error). </p>
+<p>The default behavior is to allow the operation to complete unless a fatal error is encountered. </p>
+
+</div>
+</div>
+<a id="ga0aba955473315e405295d978f0c16511"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga0aba955473315e405295d978f0c16511">&#9670;&nbsp;</a></span>TJPAD</h2>
+
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">#define TJPAD</td>
+          <td>(</td>
+          <td class="paramtype">&#160;</td>
+          <td class="paramname">width</td><td>)</td>
+          <td></td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+
+<p>Pad the given width to the nearest 32-bit boundary. </p>
+
+</div>
+</div>
+<a id="ga84878bb65404204743aa18cac02781df"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga84878bb65404204743aa18cac02781df">&#9670;&nbsp;</a></span>TJSCALED</h2>
+
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">#define TJSCALED</td>
+          <td>(</td>
+          <td class="paramtype">&#160;</td>
+          <td class="paramname">dimension, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">&#160;</td>
+          <td class="paramname">scalingFactor&#160;</td>
+        </tr>
+        <tr>
+          <td></td>
+          <td>)</td>
+          <td></td><td></td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+
+<p>Compute the scaled value of <code>dimension</code> using the given scaling factor. </p>
+<p>This macro performs the integer equivalent of <code>ceil(dimension * scalingFactor)</code>. </p>
+
+</div>
+</div>
+<a id="ga153b468cfb905d0de61706c838986fe8"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga153b468cfb905d0de61706c838986fe8">&#9670;&nbsp;</a></span>TJXOPT_COPYNONE</h2>
+
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">#define TJXOPT_COPYNONE</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+
+<p>This option will prevent <a class="el" href="group___turbo_j_p_e_g.html#ga9cb8abf4cc91881e04a0329b2270be25" title="Losslessly transform a JPEG image into another JPEG image.">tjTransform()</a> from copying any extra markers (including EXIF and ICC profile data) from the source image to the output image. </p>
+
+</div>
+</div>
+<a id="ga9c771a757fc1294add611906b89ab2d2"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga9c771a757fc1294add611906b89ab2d2">&#9670;&nbsp;</a></span>TJXOPT_CROP</h2>
+
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">#define TJXOPT_CROP</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+
+<p>This option will enable lossless cropping. </p>
+<p>See <a class="el" href="group___turbo_j_p_e_g.html#ga9cb8abf4cc91881e04a0329b2270be25" title="Losslessly transform a JPEG image into another JPEG image.">tjTransform()</a> for more information. </p>
+
+</div>
+</div>
+<a id="ga3acee7b48ade1b99e5588736007c2589"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga3acee7b48ade1b99e5588736007c2589">&#9670;&nbsp;</a></span>TJXOPT_GRAY</h2>
+
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">#define TJXOPT_GRAY</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+
+<p>This option will discard the color data in the input image and produce a grayscale output image. </p>
+
+</div>
+</div>
+<a id="gafbf992bbf6e006705886333703ffab31"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gafbf992bbf6e006705886333703ffab31">&#9670;&nbsp;</a></span>TJXOPT_NOOUTPUT</h2>
+
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">#define TJXOPT_NOOUTPUT</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+
+<p>This option will prevent <a class="el" href="group___turbo_j_p_e_g.html#ga9cb8abf4cc91881e04a0329b2270be25" title="Losslessly transform a JPEG image into another JPEG image.">tjTransform()</a> from outputting a JPEG image for this particular transform (this can be used in conjunction with a custom filter to capture the transformed DCT coefficients without transcoding them.) </p>
+
+</div>
+</div>
+<a id="ga50e03cb5ed115330e212417429600b00"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga50e03cb5ed115330e212417429600b00">&#9670;&nbsp;</a></span>TJXOPT_PERFECT</h2>
+
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">#define TJXOPT_PERFECT</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+
+<p>This option will cause <a class="el" href="group___turbo_j_p_e_g.html#ga9cb8abf4cc91881e04a0329b2270be25" title="Losslessly transform a JPEG image into another JPEG image.">tjTransform()</a> to return an error if the transform is not perfect. </p>
+<p>Lossless transforms operate on MCU blocks, whose size depends on the level of chrominance subsampling used (see <a class="el" href="group___turbo_j_p_e_g.html#ga9e61e7cd47a15a173283ba94e781308c" title="MCU block width (in pixels) for a given level of chrominance subsampling.">tjMCUWidth</a> and <a class="el" href="group___turbo_j_p_e_g.html#gabd247bb9fecb393eca57366feb8327bf" title="MCU block height (in pixels) for a given level of chrominance subsampling.">tjMCUHeight</a>.) If the image's width or height is not evenly divisible by the MCU block size, then there will be partial MCU blocks on the right and/or bottom edges. It is not possible to move these partial MCU blocks to the top or left of the image, so any transform that would require that is "imperfect." If this option is not specified, then any partial MCU blocks that cannot be transformed will be left in place, which will create odd-looking strips on the right or bottom edge of the image. </p>
+
+</div>
+</div>
+<a id="gad2371c80674584ecc1a7d75e564cf026"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gad2371c80674584ecc1a7d75e564cf026">&#9670;&nbsp;</a></span>TJXOPT_PROGRESSIVE</h2>
+
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">#define TJXOPT_PROGRESSIVE</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+
+<p>This option will enable progressive entropy coding in the output image generated by this particular transform. </p>
+<p>Progressive entropy coding will generally improve compression relative to baseline entropy coding (the default), but it will reduce compression and decompression performance considerably. </p>
+
+</div>
+</div>
+<a id="ga319826b7eb1583c0595bbe7b95428709"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga319826b7eb1583c0595bbe7b95428709">&#9670;&nbsp;</a></span>TJXOPT_TRIM</h2>
+
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">#define TJXOPT_TRIM</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+
+<p>This option will cause <a class="el" href="group___turbo_j_p_e_g.html#ga9cb8abf4cc91881e04a0329b2270be25" title="Losslessly transform a JPEG image into another JPEG image.">tjTransform()</a> to discard any partial MCU blocks that cannot be transformed. </p>
+
+</div>
+</div>
+<h2 class="groupheader">Typedef Documentation</h2>
+<a id="ga758d2634ecb4949de7815cba621f5763"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga758d2634ecb4949de7815cba621f5763">&#9670;&nbsp;</a></span>tjhandle</h2>
+
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">typedef void* <a class="el" href="group___turbo_j_p_e_g.html#ga758d2634ecb4949de7815cba621f5763">tjhandle</a></td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+
+<p>TurboJPEG instance handle. </p>
+
+</div>
+</div>
+<a id="ga504805ec0161f1b505397ca0118bf8fd"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga504805ec0161f1b505397ca0118bf8fd">&#9670;&nbsp;</a></span>tjtransform</h2>
+
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">typedef struct <a class="el" href="structtjtransform.html">tjtransform</a> <a class="el" href="structtjtransform.html">tjtransform</a></td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+
+<p>Lossless transform. </p>
+
+</div>
+</div>
+<h2 class="groupheader">Enumeration Type Documentation</h2>
+<a id="ga4f83ad3368e0e29d1957be0efa7c3720"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga4f83ad3368e0e29d1957be0efa7c3720">&#9670;&nbsp;</a></span>TJCS</h2>
+
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">enum <a class="el" href="group___turbo_j_p_e_g.html#ga4f83ad3368e0e29d1957be0efa7c3720">TJCS</a></td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+
+<p>JPEG colorspaces. </p>
+<table class="fieldtable">
+<tr><th colspan="2">Enumerator</th></tr><tr><td class="fieldname"><a id="gga4f83ad3368e0e29d1957be0efa7c3720a677cb7ccb85c4038ac41964a2e09e555"></a>TJCS_RGB&#160;</td><td class="fielddoc"><p>RGB colorspace. </p>
+<p>When compressing the JPEG image, the R, G, and B components in the source image are reordered into image planes, but no colorspace conversion or subsampling is performed. RGB JPEG images can be decompressed to any of the extended RGB pixel formats or grayscale, but they cannot be decompressed to YUV images. </p>
+</td></tr>
+<tr><td class="fieldname"><a id="gga4f83ad3368e0e29d1957be0efa7c3720a7389b8f65bb387ffedce3efd0d78ec75"></a>TJCS_YCbCr&#160;</td><td class="fielddoc"><p>YCbCr colorspace. </p>
+<p>YCbCr is not an absolute colorspace but rather a mathematical transformation of RGB designed solely for storage and transmission. YCbCr images must be converted to RGB before they can actually be displayed. In the YCbCr colorspace, the Y (luminance) component represents the black &amp; white portion of the original image, and the Cb and Cr (chrominance) components represent the color portion of the original image. Originally, the analog equivalent of this transformation allowed the same signal to drive both black &amp; white and color televisions, but JPEG images use YCbCr primarily because it allows the color data to be optionally subsampled for the purposes of reducing bandwidth or disk space. YCbCr is the most common JPEG colorspace, and YCbCr JPEG images can be compressed from and decompressed to any of the extended RGB pixel formats or grayscale, or they can be decompressed to YUV planar images. </p>
+</td></tr>
+<tr><td class="fieldname"><a id="gga4f83ad3368e0e29d1957be0efa7c3720ab3e7d6a87f695e45b81c1b5262b5a50a"></a>TJCS_GRAY&#160;</td><td class="fielddoc"><p>Grayscale colorspace. </p>
+<p>The JPEG image retains only the luminance data (Y component), and any color data from the source image is discarded. Grayscale JPEG images can be compressed from and decompressed to any of the extended RGB pixel formats or grayscale, or they can be decompressed to YUV planar images. </p>
+</td></tr>
+<tr><td class="fieldname"><a id="gga4f83ad3368e0e29d1957be0efa7c3720a6c8b636152ac8195b869587db315ee53"></a>TJCS_CMYK&#160;</td><td class="fielddoc"><p>CMYK colorspace. </p>
+<p>When compressing the JPEG image, the C, M, Y, and K components in the source image are reordered into image planes, but no colorspace conversion or subsampling is performed. CMYK JPEG images can only be decompressed to CMYK pixels. </p>
+</td></tr>
+<tr><td class="fieldname"><a id="gga4f83ad3368e0e29d1957be0efa7c3720a53839e0fe867b76b58d16b0a1a7c598e"></a>TJCS_YCCK&#160;</td><td class="fielddoc"><p>YCCK colorspace. </p>
+<p>YCCK (AKA "YCbCrK") is not an absolute colorspace but rather a mathematical transformation of CMYK designed solely for storage and transmission. It is to CMYK as YCbCr is to RGB. CMYK pixels can be reversibly transformed into YCCK, and as with YCbCr, the chrominance components in the YCCK pixels can be subsampled without incurring major perceptual loss. YCCK JPEG images can only be compressed from and decompressed to CMYK pixels. </p>
+</td></tr>
+</table>
+
+</div>
+</div>
+<a id="gafbc17cfa57d0d5d11fea35ac025950fe"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gafbc17cfa57d0d5d11fea35ac025950fe">&#9670;&nbsp;</a></span>TJERR</h2>
+
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">enum <a class="el" href="group___turbo_j_p_e_g.html#gafbc17cfa57d0d5d11fea35ac025950fe">TJERR</a></td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+
+<p>Error codes. </p>
+<table class="fieldtable">
+<tr><th colspan="2">Enumerator</th></tr><tr><td class="fieldname"><a id="ggafbc17cfa57d0d5d11fea35ac025950fea342dd6e2aedb47bb257b4e7568329b59"></a>TJERR_WARNING&#160;</td><td class="fielddoc"><p>The error was non-fatal and recoverable, but the image may still be corrupt. </p>
+</td></tr>
+<tr><td class="fieldname"><a id="ggafbc17cfa57d0d5d11fea35ac025950feafc9cceeada13122b09e4851e3788039a"></a>TJERR_FATAL&#160;</td><td class="fielddoc"><p>The error was fatal and non-recoverable. </p>
+</td></tr>
+</table>
+
+</div>
+</div>
+<a id="gac916144e26c3817ac514e64ae5d12e2a"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gac916144e26c3817ac514e64ae5d12e2a">&#9670;&nbsp;</a></span>TJPF</h2>
+
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">enum <a class="el" href="group___turbo_j_p_e_g.html#gac916144e26c3817ac514e64ae5d12e2a">TJPF</a></td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+
+<p>Pixel formats. </p>
+<table class="fieldtable">
+<tr><th colspan="2">Enumerator</th></tr><tr><td class="fieldname"><a id="ggac916144e26c3817ac514e64ae5d12e2aa7ce93230bff449518ce387c17e6ed37c"></a>TJPF_RGB&#160;</td><td class="fielddoc"><p>RGB pixel format. </p>
+<p>The red, green, and blue components in the image are stored in 3-byte pixels in the order R, G, B from lowest to highest byte address within each pixel. </p>
+</td></tr>
+<tr><td class="fieldname"><a id="ggac916144e26c3817ac514e64ae5d12e2aab10624437fb8ef495a0b153e65749839"></a>TJPF_BGR&#160;</td><td class="fielddoc"><p>BGR pixel format. </p>
+<p>The red, green, and blue components in the image are stored in 3-byte pixels in the order B, G, R from lowest to highest byte address within each pixel. </p>
+</td></tr>
+<tr><td class="fieldname"><a id="ggac916144e26c3817ac514e64ae5d12e2aa83973bebb7e2dc6fa8bae89ff3f42e01"></a>TJPF_RGBX&#160;</td><td class="fielddoc"><p>RGBX pixel format. </p>
+<p>The red, green, and blue components in the image are stored in 4-byte pixels in the order R, G, B from lowest to highest byte address within each pixel. The X component is ignored when compressing and undefined when decompressing. </p>
+</td></tr>
+<tr><td class="fieldname"><a id="ggac916144e26c3817ac514e64ae5d12e2aa2a1fbf569ca79897eae886e3376ca4c8"></a>TJPF_BGRX&#160;</td><td class="fielddoc"><p>BGRX pixel format. </p>
+<p>The red, green, and blue components in the image are stored in 4-byte pixels in the order B, G, R from lowest to highest byte address within each pixel. The X component is ignored when compressing and undefined when decompressing. </p>
+</td></tr>
+<tr><td class="fieldname"><a id="ggac916144e26c3817ac514e64ae5d12e2aaf6603b27147de47e212e75dac027b2af"></a>TJPF_XBGR&#160;</td><td class="fielddoc"><p>XBGR pixel format. </p>
+<p>The red, green, and blue components in the image are stored in 4-byte pixels in the order R, G, B from highest to lowest byte address within each pixel. The X component is ignored when compressing and undefined when decompressing. </p>
+</td></tr>
+<tr><td class="fieldname"><a id="ggac916144e26c3817ac514e64ae5d12e2aadae996905efcfa3b42a0bb3bea7f9d84"></a>TJPF_XRGB&#160;</td><td class="fielddoc"><p>XRGB pixel format. </p>
+<p>The red, green, and blue components in the image are stored in 4-byte pixels in the order B, G, R from highest to lowest byte address within each pixel. The X component is ignored when compressing and undefined when decompressing. </p>
+</td></tr>
+<tr><td class="fieldname"><a id="ggac916144e26c3817ac514e64ae5d12e2aa5431b54b015337705f13118073711a1a"></a>TJPF_GRAY&#160;</td><td class="fielddoc"><p>Grayscale pixel format. </p>
+<p>Each 1-byte pixel represents a luminance (brightness) level from 0 to 255. </p>
+</td></tr>
+<tr><td class="fieldname"><a id="ggac916144e26c3817ac514e64ae5d12e2aa88d2e88fab67f6503cf972e14851cc12"></a>TJPF_RGBA&#160;</td><td class="fielddoc"><p>RGBA pixel format. </p>
+<p>This is the same as <a class="el" href="group___turbo_j_p_e_g.html#ggac916144e26c3817ac514e64ae5d12e2aa83973bebb7e2dc6fa8bae89ff3f42e01">TJPF_RGBX</a>, except that when decompressing, the X component is guaranteed to be 0xFF, which can be interpreted as an opaque alpha channel. </p>
+</td></tr>
+<tr><td class="fieldname"><a id="ggac916144e26c3817ac514e64ae5d12e2aac037ff1845cf9b74bb81a3659c2b9fb4"></a>TJPF_BGRA&#160;</td><td class="fielddoc"><p>BGRA pixel format. </p>
+<p>This is the same as <a class="el" href="group___turbo_j_p_e_g.html#ggac916144e26c3817ac514e64ae5d12e2aa2a1fbf569ca79897eae886e3376ca4c8">TJPF_BGRX</a>, except that when decompressing, the X component is guaranteed to be 0xFF, which can be interpreted as an opaque alpha channel. </p>
+</td></tr>
+<tr><td class="fieldname"><a id="ggac916144e26c3817ac514e64ae5d12e2aa1ba1a7f1631dbeaa49a0a85fc4a40081"></a>TJPF_ABGR&#160;</td><td class="fielddoc"><p>ABGR pixel format. </p>
+<p>This is the same as <a class="el" href="group___turbo_j_p_e_g.html#ggac916144e26c3817ac514e64ae5d12e2aaf6603b27147de47e212e75dac027b2af">TJPF_XBGR</a>, except that when decompressing, the X component is guaranteed to be 0xFF, which can be interpreted as an opaque alpha channel. </p>
+</td></tr>
+<tr><td class="fieldname"><a id="ggac916144e26c3817ac514e64ae5d12e2aae8f846ed9d9de99b6e1dfe448848765c"></a>TJPF_ARGB&#160;</td><td class="fielddoc"><p>ARGB pixel format. </p>
+<p>This is the same as <a class="el" href="group___turbo_j_p_e_g.html#ggac916144e26c3817ac514e64ae5d12e2aadae996905efcfa3b42a0bb3bea7f9d84">TJPF_XRGB</a>, except that when decompressing, the X component is guaranteed to be 0xFF, which can be interpreted as an opaque alpha channel. </p>
+</td></tr>
+<tr><td class="fieldname"><a id="ggac916144e26c3817ac514e64ae5d12e2aa7f5100ec44c91994e243f1cf55553f8b"></a>TJPF_CMYK&#160;</td><td class="fielddoc"><p>CMYK pixel format. </p>
+<p>Unlike RGB, which is an additive color model used primarily for display, CMYK (Cyan/Magenta/Yellow/Key) is a subtractive color model used primarily for printing. In the CMYK color model, the value of each color component typically corresponds to an amount of cyan, magenta, yellow, or black ink that is applied to a white background. In order to convert between CMYK and RGB, it is necessary to use a color management system (CMS.) A CMS will attempt to map colors within the printer's gamut to perceptually similar colors in the display's gamut and vice versa, but the mapping is typically not 1:1 or reversible, nor can it be defined with a simple formula. Thus, such a conversion is out of scope for a codec library. However, the TurboJPEG API allows for compressing CMYK pixels into a YCCK JPEG image (see <a class="el" href="group___turbo_j_p_e_g.html#gga4f83ad3368e0e29d1957be0efa7c3720a53839e0fe867b76b58d16b0a1a7c598e" title="YCCK colorspace.">TJCS_YCCK</a>) and decompressing YCCK JPEG images into CMYK pixels. </p>
+</td></tr>
+<tr><td class="fieldname"><a id="ggac916144e26c3817ac514e64ae5d12e2aa84c1a6cead7952998e2fb895844a21ed"></a>TJPF_UNKNOWN&#160;</td><td class="fielddoc"><p>Unknown pixel format. </p>
+<p>Currently this is only used by <a class="el" href="group___turbo_j_p_e_g.html#gaffbd83c375e79f5db4b5c5d8ad4466e7" title="Load an uncompressed image from disk into memory.">tjLoadImage()</a>. </p>
+</td></tr>
+</table>
+
+</div>
+</div>
+<a id="ga1d047060ea80bb9820d540bb928e9074"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga1d047060ea80bb9820d540bb928e9074">&#9670;&nbsp;</a></span>TJSAMP</h2>
+
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">enum <a class="el" href="group___turbo_j_p_e_g.html#ga1d047060ea80bb9820d540bb928e9074">TJSAMP</a></td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+
+<p>Chrominance subsampling options. </p>
+<p>When pixels are converted from RGB to YCbCr (see <a class="el" href="group___turbo_j_p_e_g.html#gga4f83ad3368e0e29d1957be0efa7c3720a7389b8f65bb387ffedce3efd0d78ec75" title="YCbCr colorspace.">TJCS_YCbCr</a>) or from CMYK to YCCK (see <a class="el" href="group___turbo_j_p_e_g.html#gga4f83ad3368e0e29d1957be0efa7c3720a53839e0fe867b76b58d16b0a1a7c598e" title="YCCK colorspace.">TJCS_YCCK</a>) as part of the JPEG compression process, some of the Cb and Cr (chrominance) components can be discarded or averaged together to produce a smaller image with little perceptible loss of image clarity (the human eye is more sensitive to small changes in brightness than to small changes in color.) This is called "chrominance subsampling". </p>
+<table class="fieldtable">
+<tr><th colspan="2">Enumerator</th></tr><tr><td class="fieldname"><a id="gga1d047060ea80bb9820d540bb928e9074afb8da4f44197837bdec0a4f593dacae3"></a>TJSAMP_444&#160;</td><td class="fielddoc"><p>4:4:4 chrominance subsampling (no chrominance subsampling). </p>
+<p>The JPEG or YUV image will contain one chrominance component for every pixel in the source image. </p>
+</td></tr>
+<tr><td class="fieldname"><a id="gga1d047060ea80bb9820d540bb928e9074a136130902cc578f11f32429b59368404"></a>TJSAMP_422&#160;</td><td class="fielddoc"><p>4:2:2 chrominance subsampling. </p>
+<p>The JPEG or YUV image will contain one chrominance component for every 2x1 block of pixels in the source image. </p>
+</td></tr>
+<tr><td class="fieldname"><a id="gga1d047060ea80bb9820d540bb928e9074a63085dbf683cfe39e513cdb6343e3737"></a>TJSAMP_420&#160;</td><td class="fielddoc"><p>4:2:0 chrominance subsampling. </p>
+<p>The JPEG or YUV image will contain one chrominance component for every 2x2 block of pixels in the source image. </p>
+</td></tr>
+<tr><td class="fieldname"><a id="gga1d047060ea80bb9820d540bb928e9074a3f1c9504842ddc7a48d0f690754b6248"></a>TJSAMP_GRAY&#160;</td><td class="fielddoc"><p>Grayscale. </p>
+<p>The JPEG or YUV image will contain no chrominance components. </p>
+</td></tr>
+<tr><td class="fieldname"><a id="gga1d047060ea80bb9820d540bb928e9074accf740e6f3aa6ba20ba922cad13cb974"></a>TJSAMP_440&#160;</td><td class="fielddoc"><p>4:4:0 chrominance subsampling. </p>
+<p>The JPEG or YUV image will contain one chrominance component for every 1x2 block of pixels in the source image.</p>
+<dl class="section note"><dt>Note</dt><dd>4:4:0 subsampling is not fully accelerated in libjpeg-turbo. </dd></dl>
+</td></tr>
+<tr><td class="fieldname"><a id="gga1d047060ea80bb9820d540bb928e9074a28ec62575e5ea295c3fde3001dc628e2"></a>TJSAMP_411&#160;</td><td class="fielddoc"><p>4:1:1 chrominance subsampling. </p>
+<p>The JPEG or YUV image will contain one chrominance component for every 4x1 block of pixels in the source image. JPEG images compressed with 4:1:1 subsampling will be almost exactly the same size as those compressed with 4:2:0 subsampling, and in the aggregate, both subsampling methods produce approximately the same perceptual quality. However, 4:1:1 is better able to reproduce sharp horizontal features.</p>
+<dl class="section note"><dt>Note</dt><dd>4:1:1 subsampling is not fully accelerated in libjpeg-turbo. </dd></dl>
+</td></tr>
+</table>
+
+</div>
+</div>
+<a id="ga2de531af4e7e6c4f124908376b354866"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga2de531af4e7e6c4f124908376b354866">&#9670;&nbsp;</a></span>TJXOP</h2>
+
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">enum <a class="el" href="group___turbo_j_p_e_g.html#ga2de531af4e7e6c4f124908376b354866">TJXOP</a></td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+
+<p>Transform operations for <a class="el" href="group___turbo_j_p_e_g.html#ga9cb8abf4cc91881e04a0329b2270be25" title="Losslessly transform a JPEG image into another JPEG image.">tjTransform()</a> </p>
+<table class="fieldtable">
+<tr><th colspan="2">Enumerator</th></tr><tr><td class="fieldname"><a id="gga2de531af4e7e6c4f124908376b354866aad88c0366cd3f7d0eac9d7a3fa1c2c27"></a>TJXOP_NONE&#160;</td><td class="fielddoc"><p>Do not transform the position of the image pixels. </p>
+</td></tr>
+<tr><td class="fieldname"><a id="gga2de531af4e7e6c4f124908376b354866aa0df69776caa30f0fa28e26332d311ce"></a>TJXOP_HFLIP&#160;</td><td class="fielddoc"><p>Flip (mirror) image horizontally. </p>
+<p>This transform is imperfect if there are any partial MCU blocks on the right edge (see <a class="el" href="group___turbo_j_p_e_g.html#ga50e03cb5ed115330e212417429600b00" title="This option will cause tjTransform() to return an error if the transform is not perfect.">TJXOPT_PERFECT</a>.) </p>
+</td></tr>
+<tr><td class="fieldname"><a id="gga2de531af4e7e6c4f124908376b354866a324eddfbec53b7e691f61e56929d0d5d"></a>TJXOP_VFLIP&#160;</td><td class="fielddoc"><p>Flip (mirror) image vertically. </p>
+<p>This transform is imperfect if there are any partial MCU blocks on the bottom edge (see <a class="el" href="group___turbo_j_p_e_g.html#ga50e03cb5ed115330e212417429600b00" title="This option will cause tjTransform() to return an error if the transform is not perfect.">TJXOPT_PERFECT</a>.) </p>
+</td></tr>
+<tr><td class="fieldname"><a id="gga2de531af4e7e6c4f124908376b354866a31060aed199f886afdd417f80499c32d"></a>TJXOP_TRANSPOSE&#160;</td><td class="fielddoc"><p>Transpose image (flip/mirror along upper left to lower right axis.) This transform is always perfect. </p>
+</td></tr>
+<tr><td class="fieldname"><a id="gga2de531af4e7e6c4f124908376b354866af3b14d488aea6ece9e5b3df73a74d6a4"></a>TJXOP_TRANSVERSE&#160;</td><td class="fielddoc"><p>Transverse transpose image (flip/mirror along upper right to lower left axis.) This transform is imperfect if there are any partial MCU blocks in the image (see <a class="el" href="group___turbo_j_p_e_g.html#ga50e03cb5ed115330e212417429600b00" title="This option will cause tjTransform() to return an error if the transform is not perfect.">TJXOPT_PERFECT</a>.) </p>
+</td></tr>
+<tr><td class="fieldname"><a id="gga2de531af4e7e6c4f124908376b354866a43b2bbb23bc4bd548422d43fbe9af128"></a>TJXOP_ROT90&#160;</td><td class="fielddoc"><p>Rotate image clockwise by 90 degrees. </p>
+<p>This transform is imperfect if there are any partial MCU blocks on the bottom edge (see <a class="el" href="group___turbo_j_p_e_g.html#ga50e03cb5ed115330e212417429600b00" title="This option will cause tjTransform() to return an error if the transform is not perfect.">TJXOPT_PERFECT</a>.) </p>
+</td></tr>
+<tr><td class="fieldname"><a id="gga2de531af4e7e6c4f124908376b354866a140952eb8dd0300accfcc22726d69692"></a>TJXOP_ROT180&#160;</td><td class="fielddoc"><p>Rotate image 180 degrees. </p>
+<p>This transform is imperfect if there are any partial MCU blocks in the image (see <a class="el" href="group___turbo_j_p_e_g.html#ga50e03cb5ed115330e212417429600b00" title="This option will cause tjTransform() to return an error if the transform is not perfect.">TJXOPT_PERFECT</a>.) </p>
+</td></tr>
+<tr><td class="fieldname"><a id="gga2de531af4e7e6c4f124908376b354866a3064ee5dfb7f032df332818587567a08"></a>TJXOP_ROT270&#160;</td><td class="fielddoc"><p>Rotate image counter-clockwise by 90 degrees. </p>
+<p>This transform is imperfect if there are any partial MCU blocks on the right edge (see <a class="el" href="group___turbo_j_p_e_g.html#ga50e03cb5ed115330e212417429600b00" title="This option will cause tjTransform() to return an error if the transform is not perfect.">TJXOPT_PERFECT</a>.) </p>
+</td></tr>
+</table>
+
+</div>
+</div>
+<h2 class="groupheader">Function Documentation</h2>
+<a id="gaec627dd4c5f30b7a775a7aea3bec5d83"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gaec627dd4c5f30b7a775a7aea3bec5d83">&#9670;&nbsp;</a></span>tjAlloc()</h2>
+
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">DLLEXPORT unsigned char* tjAlloc </td>
+          <td>(</td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>bytes</em></td><td>)</td>
+          <td></td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+
+<p>Allocate an image buffer for use with TurboJPEG. </p>
+<p>You should always use this function to allocate the JPEG destination buffer(s) for the compression and transform functions unless you are disabling automatic buffer (re)allocation (by setting <a class="el" href="group___turbo_j_p_e_g.html#ga8808d403c68b62aaa58a4c1e58e98963" title="Disable buffer (re)allocation.">TJFLAG_NOREALLOC</a>.)</p>
+<dl class="params"><dt>Parameters</dt><dd>
+  <table class="params">
+    <tr><td class="paramname">bytes</td><td>the number of bytes to allocate</td></tr>
+  </table>
+  </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>a pointer to a newly-allocated buffer with the specified number of bytes.</dd></dl>
+<dl class="section see"><dt>See also</dt><dd><a class="el" href="group___turbo_j_p_e_g.html#gaea863d2da0cdb609563aabdf9196514b" title="Free an image buffer previously allocated by TurboJPEG.">tjFree()</a> </dd></dl>
+
+</div>
+</div>
+<a id="ga67ac12fee79073242cb216e07c9f1f90"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga67ac12fee79073242cb216e07c9f1f90">&#9670;&nbsp;</a></span>tjBufSize()</h2>
+
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">DLLEXPORT unsigned long tjBufSize </td>
+          <td>(</td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>width</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>height</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>jpegSubsamp</em>&#160;</td>
+        </tr>
+        <tr>
+          <td></td>
+          <td>)</td>
+          <td></td><td></td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+
+<p>The maximum size of the buffer (in bytes) required to hold a JPEG image with the given parameters. </p>
+<p>The number of bytes returned by this function is larger than the size of the uncompressed source image. The reason for this is that the JPEG format uses 16-bit coefficients, and it is thus possible for a very high-quality JPEG image with very high-frequency content to expand rather than compress when converted to the JPEG format. Such images represent a very rare corner case, but since there is no way to predict the size of a JPEG image prior to compression, the corner case has to be handled.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+  <table class="params">
+    <tr><td class="paramname">width</td><td>width (in pixels) of the image</td></tr>
+    <tr><td class="paramname">height</td><td>height (in pixels) of the image</td></tr>
+    <tr><td class="paramname">jpegSubsamp</td><td>the level of chrominance subsampling to be used when generating the JPEG image (see <a class="el" href="group___turbo_j_p_e_g.html#ga1d047060ea80bb9820d540bb928e9074">Chrominance subsampling options</a>.)</td></tr>
+  </table>
+  </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>the maximum size of the buffer (in bytes) required to hold the image, or -1 if the arguments are out of bounds. </dd></dl>
+
+</div>
+</div>
+<a id="ga2be2b9969d4df9ecce9b05deed273194"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga2be2b9969d4df9ecce9b05deed273194">&#9670;&nbsp;</a></span>tjBufSizeYUV2()</h2>
+
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">DLLEXPORT unsigned long tjBufSizeYUV2 </td>
+          <td>(</td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>width</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>pad</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>height</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>subsamp</em>&#160;</td>
+        </tr>
+        <tr>
+          <td></td>
+          <td>)</td>
+          <td></td><td></td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+
+<p>The size of the buffer (in bytes) required to hold a YUV planar image with the given parameters. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+  <table class="params">
+    <tr><td class="paramname">width</td><td>width (in pixels) of the image</td></tr>
+    <tr><td class="paramname">pad</td><td>the width of each line in each plane of the image is padded to the nearest multiple of this number of bytes (must be a power of 2.)</td></tr>
+    <tr><td class="paramname">height</td><td>height (in pixels) of the image</td></tr>
+    <tr><td class="paramname">subsamp</td><td>level of chrominance subsampling in the image (see <a class="el" href="group___turbo_j_p_e_g.html#ga1d047060ea80bb9820d540bb928e9074">Chrominance subsampling options</a>.)</td></tr>
+  </table>
+  </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>the size of the buffer (in bytes) required to hold the image, or -1 if the arguments are out of bounds. </dd></dl>
+
+</div>
+</div>
+<a id="gafbdce0112fd78fd38efae841443a9bcf"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gafbdce0112fd78fd38efae841443a9bcf">&#9670;&nbsp;</a></span>tjCompress2()</h2>
+
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">DLLEXPORT int tjCompress2 </td>
+          <td>(</td>
+          <td class="paramtype"><a class="el" href="group___turbo_j_p_e_g.html#ga758d2634ecb4949de7815cba621f5763">tjhandle</a>&#160;</td>
+          <td class="paramname"><em>handle</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">const unsigned char *&#160;</td>
+          <td class="paramname"><em>srcBuf</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>width</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>pitch</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>height</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>pixelFormat</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">unsigned char **&#160;</td>
+          <td class="paramname"><em>jpegBuf</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">unsigned long *&#160;</td>
+          <td class="paramname"><em>jpegSize</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>jpegSubsamp</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>jpegQual</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>flags</em>&#160;</td>
+        </tr>
+        <tr>
+          <td></td>
+          <td>)</td>
+          <td></td><td></td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+
+<p>Compress an RGB, grayscale, or CMYK image into a JPEG image. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+  <table class="params">
+    <tr><td class="paramname">handle</td><td>a handle to a TurboJPEG compressor or transformer instance</td></tr>
+    <tr><td class="paramname">srcBuf</td><td>pointer to an image buffer containing RGB, grayscale, or CMYK pixels to be compressed</td></tr>
+    <tr><td class="paramname">width</td><td>width (in pixels) of the source image</td></tr>
+    <tr><td class="paramname">pitch</td><td>bytes per line in the source image. Normally, this should be <code>width * <a class="el" href="group___turbo_j_p_e_g.html#gad77cf8fe5b2bfd3cb3f53098146abb4c" title="Pixel size (in bytes) for a given pixel format.">tjPixelSize</a>[pixelFormat]</code> if the image is unpadded, or <code><a class="el" href="group___turbo_j_p_e_g.html#ga0aba955473315e405295d978f0c16511" title="Pad the given width to the nearest 32-bit boundary.">TJPAD</a>(width * <a class="el" href="group___turbo_j_p_e_g.html#gad77cf8fe5b2bfd3cb3f53098146abb4c" title="Pixel size (in bytes) for a given pixel format.">tjPixelSize</a>[pixelFormat])</code> if each line of the image is padded to the nearest 32-bit boundary, as is the case for Windows bitmaps. You can also be clever and use this parameter to skip lines, etc. Setting this parameter to 0 is the equivalent of setting it to <code>width * <a class="el" href="group___turbo_j_p_e_g.html#gad77cf8fe5b2bfd3cb3f53098146abb4c" title="Pixel size (in bytes) for a given pixel format.">tjPixelSize</a>[pixelFormat]</code>.</td></tr>
+    <tr><td class="paramname">height</td><td>height (in pixels) of the source image</td></tr>
+    <tr><td class="paramname">pixelFormat</td><td>pixel format of the source image (see <a class="el" href="group___turbo_j_p_e_g.html#gac916144e26c3817ac514e64ae5d12e2a">Pixel formats</a>.)</td></tr>
+    <tr><td class="paramname">jpegBuf</td><td>address of a pointer to an image buffer that will receive the JPEG image. TurboJPEG has the ability to reallocate the JPEG buffer to accommodate the size of the JPEG image. Thus, you can choose to:<ol type="1">
+<li>pre-allocate the JPEG buffer with an arbitrary size using <a class="el" href="group___turbo_j_p_e_g.html#gaec627dd4c5f30b7a775a7aea3bec5d83" title="Allocate an image buffer for use with TurboJPEG.">tjAlloc()</a> and let TurboJPEG grow the buffer as needed,</li>
+<li>set <code>*jpegBuf</code> to NULL to tell TurboJPEG to allocate the buffer for you, or</li>
+<li>pre-allocate the buffer to a "worst case" size determined by calling <a class="el" href="group___turbo_j_p_e_g.html#ga67ac12fee79073242cb216e07c9f1f90" title="The maximum size of the buffer (in bytes) required to hold a JPEG image with the given parameters.">tjBufSize()</a>. This should ensure that the buffer never has to be re-allocated (setting <a class="el" href="group___turbo_j_p_e_g.html#ga8808d403c68b62aaa58a4c1e58e98963" title="Disable buffer (re)allocation.">TJFLAG_NOREALLOC</a> guarantees that it won't be.)</li>
+</ol>
+If you choose option 1, <code>*jpegSize</code> should be set to the size of your pre-allocated buffer. In any case, unless you have set <a class="el" href="group___turbo_j_p_e_g.html#ga8808d403c68b62aaa58a4c1e58e98963" title="Disable buffer (re)allocation.">TJFLAG_NOREALLOC</a>, you should always check <code>*jpegBuf</code> upon return from this function, as it may have changed.</td></tr>
+    <tr><td class="paramname">jpegSize</td><td>pointer to an unsigned long variable that holds the size of the JPEG image buffer. If <code>*jpegBuf</code> points to a pre-allocated buffer, then <code>*jpegSize</code> should be set to the size of the buffer. Upon return, <code>*jpegSize</code> will contain the size of the JPEG image (in bytes.) If <code>*jpegBuf</code> points to a JPEG image buffer that is being reused from a previous call to one of the JPEG compression functions, then <code>*jpegSize</code> is ignored.</td></tr>
+    <tr><td class="paramname">jpegSubsamp</td><td>the level of chrominance subsampling to be used when generating the JPEG image (see <a class="el" href="group___turbo_j_p_e_g.html#ga1d047060ea80bb9820d540bb928e9074">Chrominance subsampling options</a>.)</td></tr>
+    <tr><td class="paramname">jpegQual</td><td>the image quality of the generated JPEG image (1 = worst, 100 = best)</td></tr>
+    <tr><td class="paramname">flags</td><td>the bitwise OR of one or more of the <a class="el" href="group___turbo_j_p_e_g.html#gacb233cfd722d66d1ccbf48a7de81f0e0">flags</a></td></tr>
+  </table>
+  </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>0 if successful, or -1 if an error occurred (see <a class="el" href="group___turbo_j_p_e_g.html#ga1ead8574f9f39fbafc6b497124e7aafa" title="Returns a descriptive error message explaining why the last command failed.">tjGetErrorStr2()</a> and <a class="el" href="group___turbo_j_p_e_g.html#ga414feeffbf860ebd31c745df203de410" title="Returns a code indicating the severity of the last error.">tjGetErrorCode()</a>.) </dd></dl>
+
+</div>
+</div>
+<a id="ga7622a459b79aa1007e005b58783f875b"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga7622a459b79aa1007e005b58783f875b">&#9670;&nbsp;</a></span>tjCompressFromYUV()</h2>
+
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">DLLEXPORT int tjCompressFromYUV </td>
+          <td>(</td>
+          <td class="paramtype"><a class="el" href="group___turbo_j_p_e_g.html#ga758d2634ecb4949de7815cba621f5763">tjhandle</a>&#160;</td>
+          <td class="paramname"><em>handle</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">const unsigned char *&#160;</td>
+          <td class="paramname"><em>srcBuf</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>width</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>pad</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>height</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>subsamp</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">unsigned char **&#160;</td>
+          <td class="paramname"><em>jpegBuf</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">unsigned long *&#160;</td>
+          <td class="paramname"><em>jpegSize</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>jpegQual</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>flags</em>&#160;</td>
+        </tr>
+        <tr>
+          <td></td>
+          <td>)</td>
+          <td></td><td></td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+
+<p>Compress a YUV planar image into a JPEG image. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+  <table class="params">
+    <tr><td class="paramname">handle</td><td>a handle to a TurboJPEG compressor or transformer instance</td></tr>
+    <tr><td class="paramname">srcBuf</td><td>pointer to an image buffer containing a YUV planar image to be compressed. The size of this buffer should match the value returned by <a class="el" href="group___turbo_j_p_e_g.html#ga2be2b9969d4df9ecce9b05deed273194" title="The size of the buffer (in bytes) required to hold a YUV planar image with the given parameters.">tjBufSizeYUV2()</a> for the given image width, height, padding, and level of chrominance subsampling. The Y, U (Cb), and V (Cr) image planes should be stored sequentially in the source buffer (refer to <a class="el" href="group___turbo_j_p_e_g.html#YUVnotes">YUV Image Format Notes</a>.)</td></tr>
+    <tr><td class="paramname">width</td><td>width (in pixels) of the source image. If the width is not an even multiple of the MCU block width (see <a class="el" href="group___turbo_j_p_e_g.html#ga9e61e7cd47a15a173283ba94e781308c" title="MCU block width (in pixels) for a given level of chrominance subsampling.">tjMCUWidth</a>), then an intermediate buffer copy will be performed within TurboJPEG.</td></tr>
+    <tr><td class="paramname">pad</td><td>the line padding used in the source image. For instance, if each line in each plane of the YUV image is padded to the nearest multiple of 4 bytes, then <code>pad</code> should be set to 4.</td></tr>
+    <tr><td class="paramname">height</td><td>height (in pixels) of the source image. If the height is not an even multiple of the MCU block height (see <a class="el" href="group___turbo_j_p_e_g.html#gabd247bb9fecb393eca57366feb8327bf" title="MCU block height (in pixels) for a given level of chrominance subsampling.">tjMCUHeight</a>), then an intermediate buffer copy will be performed within TurboJPEG.</td></tr>
+    <tr><td class="paramname">subsamp</td><td>the level of chrominance subsampling used in the source image (see <a class="el" href="group___turbo_j_p_e_g.html#ga1d047060ea80bb9820d540bb928e9074">Chrominance subsampling options</a>.)</td></tr>
+    <tr><td class="paramname">jpegBuf</td><td>address of a pointer to an image buffer that will receive the JPEG image. TurboJPEG has the ability to reallocate the JPEG buffer to accommodate the size of the JPEG image. Thus, you can choose to:<ol type="1">
+<li>pre-allocate the JPEG buffer with an arbitrary size using <a class="el" href="group___turbo_j_p_e_g.html#gaec627dd4c5f30b7a775a7aea3bec5d83" title="Allocate an image buffer for use with TurboJPEG.">tjAlloc()</a> and let TurboJPEG grow the buffer as needed,</li>
+<li>set <code>*jpegBuf</code> to NULL to tell TurboJPEG to allocate the buffer for you, or</li>
+<li>pre-allocate the buffer to a "worst case" size determined by calling <a class="el" href="group___turbo_j_p_e_g.html#ga67ac12fee79073242cb216e07c9f1f90" title="The maximum size of the buffer (in bytes) required to hold a JPEG image with the given parameters.">tjBufSize()</a>. This should ensure that the buffer never has to be re-allocated (setting <a class="el" href="group___turbo_j_p_e_g.html#ga8808d403c68b62aaa58a4c1e58e98963" title="Disable buffer (re)allocation.">TJFLAG_NOREALLOC</a> guarantees that it won't be.)</li>
+</ol>
+If you choose option 1, <code>*jpegSize</code> should be set to the size of your pre-allocated buffer. In any case, unless you have set <a class="el" href="group___turbo_j_p_e_g.html#ga8808d403c68b62aaa58a4c1e58e98963" title="Disable buffer (re)allocation.">TJFLAG_NOREALLOC</a>, you should always check <code>*jpegBuf</code> upon return from this function, as it may have changed.</td></tr>
+    <tr><td class="paramname">jpegSize</td><td>pointer to an unsigned long variable that holds the size of the JPEG image buffer. If <code>*jpegBuf</code> points to a pre-allocated buffer, then <code>*jpegSize</code> should be set to the size of the buffer. Upon return, <code>*jpegSize</code> will contain the size of the JPEG image (in bytes.) If <code>*jpegBuf</code> points to a JPEG image buffer that is being reused from a previous call to one of the JPEG compression functions, then <code>*jpegSize</code> is ignored.</td></tr>
+    <tr><td class="paramname">jpegQual</td><td>the image quality of the generated JPEG image (1 = worst, 100 = best)</td></tr>
+    <tr><td class="paramname">flags</td><td>the bitwise OR of one or more of the <a class="el" href="group___turbo_j_p_e_g.html#gacb233cfd722d66d1ccbf48a7de81f0e0">flags</a></td></tr>
+  </table>
+  </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>0 if successful, or -1 if an error occurred (see <a class="el" href="group___turbo_j_p_e_g.html#ga1ead8574f9f39fbafc6b497124e7aafa" title="Returns a descriptive error message explaining why the last command failed.">tjGetErrorStr2()</a> and <a class="el" href="group___turbo_j_p_e_g.html#ga414feeffbf860ebd31c745df203de410" title="Returns a code indicating the severity of the last error.">tjGetErrorCode()</a>.) </dd></dl>
+
+</div>
+</div>
+<a id="ga29ec5dfbd2d84b8724e951d6fa0d5d9e"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga29ec5dfbd2d84b8724e951d6fa0d5d9e">&#9670;&nbsp;</a></span>tjCompressFromYUVPlanes()</h2>
+
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">DLLEXPORT int tjCompressFromYUVPlanes </td>
+          <td>(</td>
+          <td class="paramtype"><a class="el" href="group___turbo_j_p_e_g.html#ga758d2634ecb4949de7815cba621f5763">tjhandle</a>&#160;</td>
+          <td class="paramname"><em>handle</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">const unsigned char **&#160;</td>
+          <td class="paramname"><em>srcPlanes</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>width</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">const int *&#160;</td>
+          <td class="paramname"><em>strides</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>height</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>subsamp</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">unsigned char **&#160;</td>
+          <td class="paramname"><em>jpegBuf</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">unsigned long *&#160;</td>
+          <td class="paramname"><em>jpegSize</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>jpegQual</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>flags</em>&#160;</td>
+        </tr>
+        <tr>
+          <td></td>
+          <td>)</td>
+          <td></td><td></td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+
+<p>Compress a set of Y, U (Cb), and V (Cr) image planes into a JPEG image. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+  <table class="params">
+    <tr><td class="paramname">handle</td><td>a handle to a TurboJPEG compressor or transformer instance</td></tr>
+    <tr><td class="paramname">srcPlanes</td><td>an array of pointers to Y, U (Cb), and V (Cr) image planes (or just a Y plane, if compressing a grayscale image) that contain a YUV image to be compressed. These planes can be contiguous or non-contiguous in memory. The size of each plane should match the value returned by <a class="el" href="group___turbo_j_p_e_g.html#gab4ab7b24f6e797d79abaaa670373961d" title="The size of the buffer (in bytes) required to hold a YUV image plane with the given parameters.">tjPlaneSizeYUV()</a> for the given image width, height, strides, and level of chrominance subsampling. Refer to <a class="el" href="group___turbo_j_p_e_g.html#YUVnotes">YUV Image Format Notes</a> for more details.</td></tr>
+    <tr><td class="paramname">width</td><td>width (in pixels) of the source image. If the width is not an even multiple of the MCU block width (see <a class="el" href="group___turbo_j_p_e_g.html#ga9e61e7cd47a15a173283ba94e781308c" title="MCU block width (in pixels) for a given level of chrominance subsampling.">tjMCUWidth</a>), then an intermediate buffer copy will be performed within TurboJPEG.</td></tr>
+    <tr><td class="paramname">strides</td><td>an array of integers, each specifying the number of bytes per line in the corresponding plane of the YUV source image. Setting the stride for any plane to 0 is the same as setting it to the plane width (see <a class="el" href="group___turbo_j_p_e_g.html#YUVnotes">YUV Image Format Notes</a>.) If <code>strides</code> is NULL, then the strides for all planes will be set to their respective plane widths. You can adjust the strides in order to specify an arbitrary amount of line padding in each plane or to create a JPEG image from a subregion of a larger YUV planar image.</td></tr>
+    <tr><td class="paramname">height</td><td>height (in pixels) of the source image. If the height is not an even multiple of the MCU block height (see <a class="el" href="group___turbo_j_p_e_g.html#gabd247bb9fecb393eca57366feb8327bf" title="MCU block height (in pixels) for a given level of chrominance subsampling.">tjMCUHeight</a>), then an intermediate buffer copy will be performed within TurboJPEG.</td></tr>
+    <tr><td class="paramname">subsamp</td><td>the level of chrominance subsampling used in the source image (see <a class="el" href="group___turbo_j_p_e_g.html#ga1d047060ea80bb9820d540bb928e9074">Chrominance subsampling options</a>.)</td></tr>
+    <tr><td class="paramname">jpegBuf</td><td>address of a pointer to an image buffer that will receive the JPEG image. TurboJPEG has the ability to reallocate the JPEG buffer to accommodate the size of the JPEG image. Thus, you can choose to:<ol type="1">
+<li>pre-allocate the JPEG buffer with an arbitrary size using <a class="el" href="group___turbo_j_p_e_g.html#gaec627dd4c5f30b7a775a7aea3bec5d83" title="Allocate an image buffer for use with TurboJPEG.">tjAlloc()</a> and let TurboJPEG grow the buffer as needed,</li>
+<li>set <code>*jpegBuf</code> to NULL to tell TurboJPEG to allocate the buffer for you, or</li>
+<li>pre-allocate the buffer to a "worst case" size determined by calling <a class="el" href="group___turbo_j_p_e_g.html#ga67ac12fee79073242cb216e07c9f1f90" title="The maximum size of the buffer (in bytes) required to hold a JPEG image with the given parameters.">tjBufSize()</a>. This should ensure that the buffer never has to be re-allocated (setting <a class="el" href="group___turbo_j_p_e_g.html#ga8808d403c68b62aaa58a4c1e58e98963" title="Disable buffer (re)allocation.">TJFLAG_NOREALLOC</a> guarantees that it won't be.)</li>
+</ol>
+If you choose option 1, <code>*jpegSize</code> should be set to the size of your pre-allocated buffer. In any case, unless you have set <a class="el" href="group___turbo_j_p_e_g.html#ga8808d403c68b62aaa58a4c1e58e98963" title="Disable buffer (re)allocation.">TJFLAG_NOREALLOC</a>, you should always check <code>*jpegBuf</code> upon return from this function, as it may have changed.</td></tr>
+    <tr><td class="paramname">jpegSize</td><td>pointer to an unsigned long variable that holds the size of the JPEG image buffer. If <code>*jpegBuf</code> points to a pre-allocated buffer, then <code>*jpegSize</code> should be set to the size of the buffer. Upon return, <code>*jpegSize</code> will contain the size of the JPEG image (in bytes.) If <code>*jpegBuf</code> points to a JPEG image buffer that is being reused from a previous call to one of the JPEG compression functions, then <code>*jpegSize</code> is ignored.</td></tr>
+    <tr><td class="paramname">jpegQual</td><td>the image quality of the generated JPEG image (1 = worst, 100 = best)</td></tr>
+    <tr><td class="paramname">flags</td><td>the bitwise OR of one or more of the <a class="el" href="group___turbo_j_p_e_g.html#gacb233cfd722d66d1ccbf48a7de81f0e0">flags</a></td></tr>
+  </table>
+  </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>0 if successful, or -1 if an error occurred (see <a class="el" href="group___turbo_j_p_e_g.html#ga1ead8574f9f39fbafc6b497124e7aafa" title="Returns a descriptive error message explaining why the last command failed.">tjGetErrorStr2()</a> and <a class="el" href="group___turbo_j_p_e_g.html#ga414feeffbf860ebd31c745df203de410" title="Returns a code indicating the severity of the last error.">tjGetErrorCode()</a>.) </dd></dl>
+
+</div>
+</div>
+<a id="ga70abbf38f77a26fd6da8813bef96f695"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga70abbf38f77a26fd6da8813bef96f695">&#9670;&nbsp;</a></span>tjDecodeYUV()</h2>
+
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">DLLEXPORT int tjDecodeYUV </td>
+          <td>(</td>
+          <td class="paramtype"><a class="el" href="group___turbo_j_p_e_g.html#ga758d2634ecb4949de7815cba621f5763">tjhandle</a>&#160;</td>
+          <td class="paramname"><em>handle</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">const unsigned char *&#160;</td>
+          <td class="paramname"><em>srcBuf</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>pad</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>subsamp</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">unsigned char *&#160;</td>
+          <td class="paramname"><em>dstBuf</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>width</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>pitch</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>height</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>pixelFormat</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>flags</em>&#160;</td>
+        </tr>
+        <tr>
+          <td></td>
+          <td>)</td>
+          <td></td><td></td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+
+<p>Decode a YUV planar image into an RGB or grayscale image. </p>
+<p>This function uses the accelerated color conversion routines in the underlying codec but does not execute any of the other steps in the JPEG decompression process.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+  <table class="params">
+    <tr><td class="paramname">handle</td><td>a handle to a TurboJPEG decompressor or transformer instance</td></tr>
+    <tr><td class="paramname">srcBuf</td><td>pointer to an image buffer containing a YUV planar image to be decoded. The size of this buffer should match the value returned by <a class="el" href="group___turbo_j_p_e_g.html#ga2be2b9969d4df9ecce9b05deed273194" title="The size of the buffer (in bytes) required to hold a YUV planar image with the given parameters.">tjBufSizeYUV2()</a> for the given image width, height, padding, and level of chrominance subsampling. The Y, U (Cb), and V (Cr) image planes should be stored sequentially in the source buffer (refer to <a class="el" href="group___turbo_j_p_e_g.html#YUVnotes">YUV Image Format Notes</a>.)</td></tr>
+    <tr><td class="paramname">pad</td><td>Use this parameter to specify that the width of each line in each plane of the YUV source image is padded to the nearest multiple of this number of bytes (must be a power of 2.)</td></tr>
+    <tr><td class="paramname">subsamp</td><td>the level of chrominance subsampling used in the YUV source image (see <a class="el" href="group___turbo_j_p_e_g.html#ga1d047060ea80bb9820d540bb928e9074">Chrominance subsampling options</a>.)</td></tr>
+    <tr><td class="paramname">dstBuf</td><td>pointer to an image buffer that will receive the decoded image. This buffer should normally be <code>pitch * height</code> bytes in size, but the <code>dstBuf</code> pointer can also be used to decode into a specific region of a larger buffer.</td></tr>
+    <tr><td class="paramname">width</td><td>width (in pixels) of the source and destination images</td></tr>
+    <tr><td class="paramname">pitch</td><td>bytes per line in the destination image. Normally, this should be <code>width * <a class="el" href="group___turbo_j_p_e_g.html#gad77cf8fe5b2bfd3cb3f53098146abb4c" title="Pixel size (in bytes) for a given pixel format.">tjPixelSize</a>[pixelFormat]</code> if the destination image is unpadded, or <code><a class="el" href="group___turbo_j_p_e_g.html#ga0aba955473315e405295d978f0c16511" title="Pad the given width to the nearest 32-bit boundary.">TJPAD</a>(width * <a class="el" href="group___turbo_j_p_e_g.html#gad77cf8fe5b2bfd3cb3f53098146abb4c" title="Pixel size (in bytes) for a given pixel format.">tjPixelSize</a>[pixelFormat])</code> if each line of the destination image should be padded to the nearest 32-bit boundary, as is the case for Windows bitmaps. You can also be clever and use the pitch parameter to skip lines, etc. Setting this parameter to 0 is the equivalent of setting it to <code>width * <a class="el" href="group___turbo_j_p_e_g.html#gad77cf8fe5b2bfd3cb3f53098146abb4c" title="Pixel size (in bytes) for a given pixel format.">tjPixelSize</a>[pixelFormat]</code>.</td></tr>
+    <tr><td class="paramname">height</td><td>height (in pixels) of the source and destination images</td></tr>
+    <tr><td class="paramname">pixelFormat</td><td>pixel format of the destination image (see <a class="el" href="group___turbo_j_p_e_g.html#gac916144e26c3817ac514e64ae5d12e2a">Pixel formats</a>.)</td></tr>
+    <tr><td class="paramname">flags</td><td>the bitwise OR of one or more of the <a class="el" href="group___turbo_j_p_e_g.html#gacb233cfd722d66d1ccbf48a7de81f0e0">flags</a></td></tr>
+  </table>
+  </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>0 if successful, or -1 if an error occurred (see <a class="el" href="group___turbo_j_p_e_g.html#ga1ead8574f9f39fbafc6b497124e7aafa" title="Returns a descriptive error message explaining why the last command failed.">tjGetErrorStr2()</a> and <a class="el" href="group___turbo_j_p_e_g.html#ga414feeffbf860ebd31c745df203de410" title="Returns a code indicating the severity of the last error.">tjGetErrorCode()</a>.) </dd></dl>
+
+</div>
+</div>
+<a id="ga10e837c07fa9d25770565b237d3898d9"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga10e837c07fa9d25770565b237d3898d9">&#9670;&nbsp;</a></span>tjDecodeYUVPlanes()</h2>
+
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">DLLEXPORT int tjDecodeYUVPlanes </td>
+          <td>(</td>
+          <td class="paramtype"><a class="el" href="group___turbo_j_p_e_g.html#ga758d2634ecb4949de7815cba621f5763">tjhandle</a>&#160;</td>
+          <td class="paramname"><em>handle</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">const unsigned char **&#160;</td>
+          <td class="paramname"><em>srcPlanes</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">const int *&#160;</td>
+          <td class="paramname"><em>strides</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>subsamp</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">unsigned char *&#160;</td>
+          <td class="paramname"><em>dstBuf</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>width</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>pitch</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>height</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>pixelFormat</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>flags</em>&#160;</td>
+        </tr>
+        <tr>
+          <td></td>
+          <td>)</td>
+          <td></td><td></td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+
+<p>Decode a set of Y, U (Cb), and V (Cr) image planes into an RGB or grayscale image. </p>
+<p>This function uses the accelerated color conversion routines in the underlying codec but does not execute any of the other steps in the JPEG decompression process.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+  <table class="params">
+    <tr><td class="paramname">handle</td><td>a handle to a TurboJPEG decompressor or transformer instance</td></tr>
+    <tr><td class="paramname">srcPlanes</td><td>an array of pointers to Y, U (Cb), and V (Cr) image planes (or just a Y plane, if decoding a grayscale image) that contain a YUV image to be decoded. These planes can be contiguous or non-contiguous in memory. The size of each plane should match the value returned by <a class="el" href="group___turbo_j_p_e_g.html#gab4ab7b24f6e797d79abaaa670373961d" title="The size of the buffer (in bytes) required to hold a YUV image plane with the given parameters.">tjPlaneSizeYUV()</a> for the given image width, height, strides, and level of chrominance subsampling. Refer to <a class="el" href="group___turbo_j_p_e_g.html#YUVnotes">YUV Image Format Notes</a> for more details.</td></tr>
+    <tr><td class="paramname">strides</td><td>an array of integers, each specifying the number of bytes per line in the corresponding plane of the YUV source image. Setting the stride for any plane to 0 is the same as setting it to the plane width (see <a class="el" href="group___turbo_j_p_e_g.html#YUVnotes">YUV Image Format Notes</a>.) If <code>strides</code> is NULL, then the strides for all planes will be set to their respective plane widths. You can adjust the strides in order to specify an arbitrary amount of line padding in each plane or to decode a subregion of a larger YUV planar image.</td></tr>
+    <tr><td class="paramname">subsamp</td><td>the level of chrominance subsampling used in the YUV source image (see <a class="el" href="group___turbo_j_p_e_g.html#ga1d047060ea80bb9820d540bb928e9074">Chrominance subsampling options</a>.)</td></tr>
+    <tr><td class="paramname">dstBuf</td><td>pointer to an image buffer that will receive the decoded image. This buffer should normally be <code>pitch * height</code> bytes in size, but the <code>dstBuf</code> pointer can also be used to decode into a specific region of a larger buffer.</td></tr>
+    <tr><td class="paramname">width</td><td>width (in pixels) of the source and destination images</td></tr>
+    <tr><td class="paramname">pitch</td><td>bytes per line in the destination image. Normally, this should be <code>width * <a class="el" href="group___turbo_j_p_e_g.html#gad77cf8fe5b2bfd3cb3f53098146abb4c" title="Pixel size (in bytes) for a given pixel format.">tjPixelSize</a>[pixelFormat]</code> if the destination image is unpadded, or <code><a class="el" href="group___turbo_j_p_e_g.html#ga0aba955473315e405295d978f0c16511" title="Pad the given width to the nearest 32-bit boundary.">TJPAD</a>(width * <a class="el" href="group___turbo_j_p_e_g.html#gad77cf8fe5b2bfd3cb3f53098146abb4c" title="Pixel size (in bytes) for a given pixel format.">tjPixelSize</a>[pixelFormat])</code> if each line of the destination image should be padded to the nearest 32-bit boundary, as is the case for Windows bitmaps. You can also be clever and use the pitch parameter to skip lines, etc. Setting this parameter to 0 is the equivalent of setting it to <code>width * <a class="el" href="group___turbo_j_p_e_g.html#gad77cf8fe5b2bfd3cb3f53098146abb4c" title="Pixel size (in bytes) for a given pixel format.">tjPixelSize</a>[pixelFormat]</code>.</td></tr>
+    <tr><td class="paramname">height</td><td>height (in pixels) of the source and destination images</td></tr>
+    <tr><td class="paramname">pixelFormat</td><td>pixel format of the destination image (see <a class="el" href="group___turbo_j_p_e_g.html#gac916144e26c3817ac514e64ae5d12e2a">Pixel formats</a>.)</td></tr>
+    <tr><td class="paramname">flags</td><td>the bitwise OR of one or more of the <a class="el" href="group___turbo_j_p_e_g.html#gacb233cfd722d66d1ccbf48a7de81f0e0">flags</a></td></tr>
+  </table>
+  </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>0 if successful, or -1 if an error occurred (see <a class="el" href="group___turbo_j_p_e_g.html#ga1ead8574f9f39fbafc6b497124e7aafa" title="Returns a descriptive error message explaining why the last command failed.">tjGetErrorStr2()</a> and <a class="el" href="group___turbo_j_p_e_g.html#ga414feeffbf860ebd31c745df203de410" title="Returns a code indicating the severity of the last error.">tjGetErrorCode()</a>.) </dd></dl>
+
+</div>
+</div>
+<a id="gae9eccef8b682a48f43a9117c231ed013"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gae9eccef8b682a48f43a9117c231ed013">&#9670;&nbsp;</a></span>tjDecompress2()</h2>
+
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">DLLEXPORT int tjDecompress2 </td>
+          <td>(</td>
+          <td class="paramtype"><a class="el" href="group___turbo_j_p_e_g.html#ga758d2634ecb4949de7815cba621f5763">tjhandle</a>&#160;</td>
+          <td class="paramname"><em>handle</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">const unsigned char *&#160;</td>
+          <td class="paramname"><em>jpegBuf</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">unsigned long&#160;</td>
+          <td class="paramname"><em>jpegSize</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">unsigned char *&#160;</td>
+          <td class="paramname"><em>dstBuf</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>width</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>pitch</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>height</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>pixelFormat</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>flags</em>&#160;</td>
+        </tr>
+        <tr>
+          <td></td>
+          <td>)</td>
+          <td></td><td></td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+
+<p>Decompress a JPEG image to an RGB, grayscale, or CMYK image. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+  <table class="params">
+    <tr><td class="paramname">handle</td><td>a handle to a TurboJPEG decompressor or transformer instance</td></tr>
+    <tr><td class="paramname">jpegBuf</td><td>pointer to a buffer containing the JPEG image to decompress</td></tr>
+    <tr><td class="paramname">jpegSize</td><td>size of the JPEG image (in bytes)</td></tr>
+    <tr><td class="paramname">dstBuf</td><td>pointer to an image buffer that will receive the decompressed image. This buffer should normally be <code>pitch * scaledHeight</code> bytes in size, where <code>scaledHeight</code> can be determined by calling <a class="el" href="group___turbo_j_p_e_g.html#ga84878bb65404204743aa18cac02781df" title="Compute the scaled value of dimension using the given scaling factor.">TJSCALED()</a> with the JPEG image height and one of the scaling factors returned by <a class="el" href="group___turbo_j_p_e_g.html#gac3854476006b10787bd128f7ede48057" title="Returns a list of fractional scaling factors that the JPEG decompressor in this implementation of Tur...">tjGetScalingFactors()</a>. The <code>dstBuf</code> pointer may also be used to decompress into a specific region of a larger buffer.</td></tr>
+    <tr><td class="paramname">width</td><td>desired width (in pixels) of the destination image. If this is different than the width of the JPEG image being decompressed, then TurboJPEG will use scaling in the JPEG decompressor to generate the largest possible image that will fit within the desired width. If <code>width</code> is set to 0, then only the height will be considered when determining the scaled image size.</td></tr>
+    <tr><td class="paramname">pitch</td><td>bytes per line in the destination image. Normally, this is <code>scaledWidth * <a class="el" href="group___turbo_j_p_e_g.html#gad77cf8fe5b2bfd3cb3f53098146abb4c" title="Pixel size (in bytes) for a given pixel format.">tjPixelSize</a>[pixelFormat]</code> if the decompressed image is unpadded, else <code><a class="el" href="group___turbo_j_p_e_g.html#ga0aba955473315e405295d978f0c16511" title="Pad the given width to the nearest 32-bit boundary.">TJPAD</a>(scaledWidth * <a class="el" href="group___turbo_j_p_e_g.html#gad77cf8fe5b2bfd3cb3f53098146abb4c" title="Pixel size (in bytes) for a given pixel format.">tjPixelSize</a>[pixelFormat])</code> if each line of the decompressed image is padded to the nearest 32-bit boundary, as is the case for Windows bitmaps. (NOTE: <code>scaledWidth</code> can be determined by calling <a class="el" href="group___turbo_j_p_e_g.html#ga84878bb65404204743aa18cac02781df" title="Compute the scaled value of dimension using the given scaling factor.">TJSCALED()</a> with the JPEG image width and one of the scaling factors returned by <a class="el" href="group___turbo_j_p_e_g.html#gac3854476006b10787bd128f7ede48057" title="Returns a list of fractional scaling factors that the JPEG decompressor in this implementation of Tur...">tjGetScalingFactors()</a>.) You can also be clever and use the pitch parameter to skip lines, etc. Setting this parameter to 0 is the equivalent of setting it to <code>scaledWidth * <a class="el" href="group___turbo_j_p_e_g.html#gad77cf8fe5b2bfd3cb3f53098146abb4c" title="Pixel size (in bytes) for a given pixel format.">tjPixelSize</a>[pixelFormat]</code>.</td></tr>
+    <tr><td class="paramname">height</td><td>desired height (in pixels) of the destination image. If this is different than the height of the JPEG image being decompressed, then TurboJPEG will use scaling in the JPEG decompressor to generate the largest possible image that will fit within the desired height. If <code>height</code> is set to 0, then only the width will be considered when determining the scaled image size.</td></tr>
+    <tr><td class="paramname">pixelFormat</td><td>pixel format of the destination image (see <a class="el" href="group___turbo_j_p_e_g.html#gac916144e26c3817ac514e64ae5d12e2a">Pixel formats</a>.)</td></tr>
+    <tr><td class="paramname">flags</td><td>the bitwise OR of one or more of the <a class="el" href="group___turbo_j_p_e_g.html#gacb233cfd722d66d1ccbf48a7de81f0e0">flags</a></td></tr>
+  </table>
+  </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>0 if successful, or -1 if an error occurred (see <a class="el" href="group___turbo_j_p_e_g.html#ga1ead8574f9f39fbafc6b497124e7aafa" title="Returns a descriptive error message explaining why the last command failed.">tjGetErrorStr2()</a> and <a class="el" href="group___turbo_j_p_e_g.html#ga414feeffbf860ebd31c745df203de410" title="Returns a code indicating the severity of the last error.">tjGetErrorCode()</a>.) </dd></dl>
+
+</div>
+</div>
+<a id="ga0595681096bba7199cc6f3533cb25f77"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga0595681096bba7199cc6f3533cb25f77">&#9670;&nbsp;</a></span>tjDecompressHeader3()</h2>
+
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">DLLEXPORT int tjDecompressHeader3 </td>
+          <td>(</td>
+          <td class="paramtype"><a class="el" href="group___turbo_j_p_e_g.html#ga758d2634ecb4949de7815cba621f5763">tjhandle</a>&#160;</td>
+          <td class="paramname"><em>handle</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">const unsigned char *&#160;</td>
+          <td class="paramname"><em>jpegBuf</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">unsigned long&#160;</td>
+          <td class="paramname"><em>jpegSize</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int *&#160;</td>
+          <td class="paramname"><em>width</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int *&#160;</td>
+          <td class="paramname"><em>height</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int *&#160;</td>
+          <td class="paramname"><em>jpegSubsamp</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int *&#160;</td>
+          <td class="paramname"><em>jpegColorspace</em>&#160;</td>
+        </tr>
+        <tr>
+          <td></td>
+          <td>)</td>
+          <td></td><td></td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+
+<p>Retrieve information about a JPEG image without decompressing it. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+  <table class="params">
+    <tr><td class="paramname">handle</td><td>a handle to a TurboJPEG decompressor or transformer instance</td></tr>
+    <tr><td class="paramname">jpegBuf</td><td>pointer to a buffer containing a JPEG image</td></tr>
+    <tr><td class="paramname">jpegSize</td><td>size of the JPEG image (in bytes)</td></tr>
+    <tr><td class="paramname">width</td><td>pointer to an integer variable that will receive the width (in pixels) of the JPEG image</td></tr>
+    <tr><td class="paramname">height</td><td>pointer to an integer variable that will receive the height (in pixels) of the JPEG image</td></tr>
+    <tr><td class="paramname">jpegSubsamp</td><td>pointer to an integer variable that will receive the level of chrominance subsampling used when the JPEG image was compressed (see <a class="el" href="group___turbo_j_p_e_g.html#ga1d047060ea80bb9820d540bb928e9074">Chrominance subsampling options</a>.)</td></tr>
+    <tr><td class="paramname">jpegColorspace</td><td>pointer to an integer variable that will receive one of the JPEG colorspace constants, indicating the colorspace of the JPEG image (see <a class="el" href="group___turbo_j_p_e_g.html#ga4f83ad3368e0e29d1957be0efa7c3720">JPEG colorspaces</a>.)</td></tr>
+  </table>
+  </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>0 if successful, or -1 if an error occurred (see <a class="el" href="group___turbo_j_p_e_g.html#ga1ead8574f9f39fbafc6b497124e7aafa" title="Returns a descriptive error message explaining why the last command failed.">tjGetErrorStr2()</a> and <a class="el" href="group___turbo_j_p_e_g.html#ga414feeffbf860ebd31c745df203de410" title="Returns a code indicating the severity of the last error.">tjGetErrorCode()</a>.) </dd></dl>
+
+</div>
+</div>
+<a id="ga04d1e839ff9a0860dd1475cff78d3364"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga04d1e839ff9a0860dd1475cff78d3364">&#9670;&nbsp;</a></span>tjDecompressToYUV2()</h2>
+
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">DLLEXPORT int tjDecompressToYUV2 </td>
+          <td>(</td>
+          <td class="paramtype"><a class="el" href="group___turbo_j_p_e_g.html#ga758d2634ecb4949de7815cba621f5763">tjhandle</a>&#160;</td>
+          <td class="paramname"><em>handle</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">const unsigned char *&#160;</td>
+          <td class="paramname"><em>jpegBuf</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">unsigned long&#160;</td>
+          <td class="paramname"><em>jpegSize</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">unsigned char *&#160;</td>
+          <td class="paramname"><em>dstBuf</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>width</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>pad</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>height</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>flags</em>&#160;</td>
+        </tr>
+        <tr>
+          <td></td>
+          <td>)</td>
+          <td></td><td></td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+
+<p>Decompress a JPEG image to a YUV planar image. </p>
+<p>This function performs JPEG decompression but leaves out the color conversion step, so a planar YUV image is generated instead of an RGB image.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+  <table class="params">
+    <tr><td class="paramname">handle</td><td>a handle to a TurboJPEG decompressor or transformer instance</td></tr>
+    <tr><td class="paramname">jpegBuf</td><td>pointer to a buffer containing the JPEG image to decompress</td></tr>
+    <tr><td class="paramname">jpegSize</td><td>size of the JPEG image (in bytes)</td></tr>
+    <tr><td class="paramname">dstBuf</td><td>pointer to an image buffer that will receive the YUV image. Use <a class="el" href="group___turbo_j_p_e_g.html#ga2be2b9969d4df9ecce9b05deed273194" title="The size of the buffer (in bytes) required to hold a YUV planar image with the given parameters.">tjBufSizeYUV2()</a> to determine the appropriate size for this buffer based on the image width, height, padding, and level of subsampling. The Y, U (Cb), and V (Cr) image planes will be stored sequentially in the buffer (refer to <a class="el" href="group___turbo_j_p_e_g.html#YUVnotes">YUV Image Format Notes</a>.)</td></tr>
+    <tr><td class="paramname">width</td><td>desired width (in pixels) of the YUV image. If this is different than the width of the JPEG image being decompressed, then TurboJPEG will use scaling in the JPEG decompressor to generate the largest possible image that will fit within the desired width. If <code>width</code> is set to 0, then only the height will be considered when determining the scaled image size. If the scaled width is not an even multiple of the MCU block width (see <a class="el" href="group___turbo_j_p_e_g.html#ga9e61e7cd47a15a173283ba94e781308c" title="MCU block width (in pixels) for a given level of chrominance subsampling.">tjMCUWidth</a>), then an intermediate buffer copy will be performed within TurboJPEG.</td></tr>
+    <tr><td class="paramname">pad</td><td>the width of each line in each plane of the YUV image will be padded to the nearest multiple of this number of bytes (must be a power of 2.) To generate images suitable for X Video, <code>pad</code> should be set to 4.</td></tr>
+    <tr><td class="paramname">height</td><td>desired height (in pixels) of the YUV image. If this is different than the height of the JPEG image being decompressed, then TurboJPEG will use scaling in the JPEG decompressor to generate the largest possible image that will fit within the desired height. If <code>height</code> is set to 0, then only the width will be considered when determining the scaled image size. If the scaled height is not an even multiple of the MCU block height (see <a class="el" href="group___turbo_j_p_e_g.html#gabd247bb9fecb393eca57366feb8327bf" title="MCU block height (in pixels) for a given level of chrominance subsampling.">tjMCUHeight</a>), then an intermediate buffer copy will be performed within TurboJPEG.</td></tr>
+    <tr><td class="paramname">flags</td><td>the bitwise OR of one or more of the <a class="el" href="group___turbo_j_p_e_g.html#gacb233cfd722d66d1ccbf48a7de81f0e0">flags</a></td></tr>
+  </table>
+  </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>0 if successful, or -1 if an error occurred (see <a class="el" href="group___turbo_j_p_e_g.html#ga1ead8574f9f39fbafc6b497124e7aafa" title="Returns a descriptive error message explaining why the last command failed.">tjGetErrorStr2()</a> and <a class="el" href="group___turbo_j_p_e_g.html#ga414feeffbf860ebd31c745df203de410" title="Returns a code indicating the severity of the last error.">tjGetErrorCode()</a>.) </dd></dl>
+
+</div>
+</div>
+<a id="gaa59f901a5258ada5bd0185ad59368540"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gaa59f901a5258ada5bd0185ad59368540">&#9670;&nbsp;</a></span>tjDecompressToYUVPlanes()</h2>
+
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">DLLEXPORT int tjDecompressToYUVPlanes </td>
+          <td>(</td>
+          <td class="paramtype"><a class="el" href="group___turbo_j_p_e_g.html#ga758d2634ecb4949de7815cba621f5763">tjhandle</a>&#160;</td>
+          <td class="paramname"><em>handle</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">const unsigned char *&#160;</td>
+          <td class="paramname"><em>jpegBuf</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">unsigned long&#160;</td>
+          <td class="paramname"><em>jpegSize</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">unsigned char **&#160;</td>
+          <td class="paramname"><em>dstPlanes</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>width</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int *&#160;</td>
+          <td class="paramname"><em>strides</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>height</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>flags</em>&#160;</td>
+        </tr>
+        <tr>
+          <td></td>
+          <td>)</td>
+          <td></td><td></td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+
+<p>Decompress a JPEG image into separate Y, U (Cb), and V (Cr) image planes. </p>
+<p>This function performs JPEG decompression but leaves out the color conversion step, so a planar YUV image is generated instead of an RGB image.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+  <table class="params">
+    <tr><td class="paramname">handle</td><td>a handle to a TurboJPEG decompressor or transformer instance</td></tr>
+    <tr><td class="paramname">jpegBuf</td><td>pointer to a buffer containing the JPEG image to decompress</td></tr>
+    <tr><td class="paramname">jpegSize</td><td>size of the JPEG image (in bytes)</td></tr>
+    <tr><td class="paramname">dstPlanes</td><td>an array of pointers to Y, U (Cb), and V (Cr) image planes (or just a Y plane, if decompressing a grayscale image) that will receive the YUV image. These planes can be contiguous or non-contiguous in memory. Use <a class="el" href="group___turbo_j_p_e_g.html#gab4ab7b24f6e797d79abaaa670373961d" title="The size of the buffer (in bytes) required to hold a YUV image plane with the given parameters.">tjPlaneSizeYUV()</a> to determine the appropriate size for each plane based on the scaled image width, scaled image height, strides, and level of chrominance subsampling. Refer to <a class="el" href="group___turbo_j_p_e_g.html#YUVnotes">YUV Image Format Notes</a> for more details.</td></tr>
+    <tr><td class="paramname">width</td><td>desired width (in pixels) of the YUV image. If this is different than the width of the JPEG image being decompressed, then TurboJPEG will use scaling in the JPEG decompressor to generate the largest possible image that will fit within the desired width. If <code>width</code> is set to 0, then only the height will be considered when determining the scaled image size. If the scaled width is not an even multiple of the MCU block width (see <a class="el" href="group___turbo_j_p_e_g.html#ga9e61e7cd47a15a173283ba94e781308c" title="MCU block width (in pixels) for a given level of chrominance subsampling.">tjMCUWidth</a>), then an intermediate buffer copy will be performed within TurboJPEG.</td></tr>
+    <tr><td class="paramname">strides</td><td>an array of integers, each specifying the number of bytes per line in the corresponding plane of the output image. Setting the stride for any plane to 0 is the same as setting it to the scaled plane width (see <a class="el" href="group___turbo_j_p_e_g.html#YUVnotes">YUV Image Format Notes</a>.) If <code>strides</code> is NULL, then the strides for all planes will be set to their respective scaled plane widths. You can adjust the strides in order to add an arbitrary amount of line padding to each plane or to decompress the JPEG image into a subregion of a larger YUV planar image.</td></tr>
+    <tr><td class="paramname">height</td><td>desired height (in pixels) of the YUV image. If this is different than the height of the JPEG image being decompressed, then TurboJPEG will use scaling in the JPEG decompressor to generate the largest possible image that will fit within the desired height. If <code>height</code> is set to 0, then only the width will be considered when determining the scaled image size. If the scaled height is not an even multiple of the MCU block height (see <a class="el" href="group___turbo_j_p_e_g.html#gabd247bb9fecb393eca57366feb8327bf" title="MCU block height (in pixels) for a given level of chrominance subsampling.">tjMCUHeight</a>), then an intermediate buffer copy will be performed within TurboJPEG.</td></tr>
+    <tr><td class="paramname">flags</td><td>the bitwise OR of one or more of the <a class="el" href="group___turbo_j_p_e_g.html#gacb233cfd722d66d1ccbf48a7de81f0e0">flags</a></td></tr>
+  </table>
+  </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>0 if successful, or -1 if an error occurred (see <a class="el" href="group___turbo_j_p_e_g.html#ga1ead8574f9f39fbafc6b497124e7aafa" title="Returns a descriptive error message explaining why the last command failed.">tjGetErrorStr2()</a> and <a class="el" href="group___turbo_j_p_e_g.html#ga414feeffbf860ebd31c745df203de410" title="Returns a code indicating the severity of the last error.">tjGetErrorCode()</a>.) </dd></dl>
+
+</div>
+</div>
+<a id="ga75f355fa27225ba1a4ee392c852394d2"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga75f355fa27225ba1a4ee392c852394d2">&#9670;&nbsp;</a></span>tjDestroy()</h2>
+
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">DLLEXPORT int tjDestroy </td>
+          <td>(</td>
+          <td class="paramtype"><a class="el" href="group___turbo_j_p_e_g.html#ga758d2634ecb4949de7815cba621f5763">tjhandle</a>&#160;</td>
+          <td class="paramname"><em>handle</em></td><td>)</td>
+          <td></td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+
+<p>Destroy a TurboJPEG compressor, decompressor, or transformer instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+  <table class="params">
+    <tr><td class="paramname">handle</td><td>a handle to a TurboJPEG compressor, decompressor or transformer instance</td></tr>
+  </table>
+  </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>0 if successful, or -1 if an error occurred (see <a class="el" href="group___turbo_j_p_e_g.html#ga1ead8574f9f39fbafc6b497124e7aafa" title="Returns a descriptive error message explaining why the last command failed.">tjGetErrorStr2()</a>.) </dd></dl>
+
+</div>
+</div>
+<a id="gac519b922cdf446e97d0cdcba513636bf"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gac519b922cdf446e97d0cdcba513636bf">&#9670;&nbsp;</a></span>tjEncodeYUV3()</h2>
+
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">DLLEXPORT int tjEncodeYUV3 </td>
+          <td>(</td>
+          <td class="paramtype"><a class="el" href="group___turbo_j_p_e_g.html#ga758d2634ecb4949de7815cba621f5763">tjhandle</a>&#160;</td>
+          <td class="paramname"><em>handle</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">const unsigned char *&#160;</td>
+          <td class="paramname"><em>srcBuf</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>width</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>pitch</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>height</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>pixelFormat</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">unsigned char *&#160;</td>
+          <td class="paramname"><em>dstBuf</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>pad</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>subsamp</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>flags</em>&#160;</td>
+        </tr>
+        <tr>
+          <td></td>
+          <td>)</td>
+          <td></td><td></td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+
+<p>Encode an RGB or grayscale image into a YUV planar image. </p>
+<p>This function uses the accelerated color conversion routines in the underlying codec but does not execute any of the other steps in the JPEG compression process.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+  <table class="params">
+    <tr><td class="paramname">handle</td><td>a handle to a TurboJPEG compressor or transformer instance</td></tr>
+    <tr><td class="paramname">srcBuf</td><td>pointer to an image buffer containing RGB or grayscale pixels to be encoded</td></tr>
+    <tr><td class="paramname">width</td><td>width (in pixels) of the source image</td></tr>
+    <tr><td class="paramname">pitch</td><td>bytes per line in the source image. Normally, this should be <code>width * <a class="el" href="group___turbo_j_p_e_g.html#gad77cf8fe5b2bfd3cb3f53098146abb4c" title="Pixel size (in bytes) for a given pixel format.">tjPixelSize</a>[pixelFormat]</code> if the image is unpadded, or <code><a class="el" href="group___turbo_j_p_e_g.html#ga0aba955473315e405295d978f0c16511" title="Pad the given width to the nearest 32-bit boundary.">TJPAD</a>(width * <a class="el" href="group___turbo_j_p_e_g.html#gad77cf8fe5b2bfd3cb3f53098146abb4c" title="Pixel size (in bytes) for a given pixel format.">tjPixelSize</a>[pixelFormat])</code> if each line of the image is padded to the nearest 32-bit boundary, as is the case for Windows bitmaps. You can also be clever and use this parameter to skip lines, etc. Setting this parameter to 0 is the equivalent of setting it to <code>width * <a class="el" href="group___turbo_j_p_e_g.html#gad77cf8fe5b2bfd3cb3f53098146abb4c" title="Pixel size (in bytes) for a given pixel format.">tjPixelSize</a>[pixelFormat]</code>.</td></tr>
+    <tr><td class="paramname">height</td><td>height (in pixels) of the source image</td></tr>
+    <tr><td class="paramname">pixelFormat</td><td>pixel format of the source image (see <a class="el" href="group___turbo_j_p_e_g.html#gac916144e26c3817ac514e64ae5d12e2a">Pixel formats</a>.)</td></tr>
+    <tr><td class="paramname">dstBuf</td><td>pointer to an image buffer that will receive the YUV image. Use <a class="el" href="group___turbo_j_p_e_g.html#ga2be2b9969d4df9ecce9b05deed273194" title="The size of the buffer (in bytes) required to hold a YUV planar image with the given parameters.">tjBufSizeYUV2()</a> to determine the appropriate size for this buffer based on the image width, height, padding, and level of chrominance subsampling. The Y, U (Cb), and V (Cr) image planes will be stored sequentially in the buffer (refer to <a class="el" href="group___turbo_j_p_e_g.html#YUVnotes">YUV Image Format Notes</a>.)</td></tr>
+    <tr><td class="paramname">pad</td><td>the width of each line in each plane of the YUV image will be padded to the nearest multiple of this number of bytes (must be a power of 2.) To generate images suitable for X Video, <code>pad</code> should be set to 4.</td></tr>
+    <tr><td class="paramname">subsamp</td><td>the level of chrominance subsampling to be used when generating the YUV image (see <a class="el" href="group___turbo_j_p_e_g.html#ga1d047060ea80bb9820d540bb928e9074">Chrominance subsampling options</a>.) To generate images suitable for X Video, <code>subsamp</code> should be set to <a class="el" href="group___turbo_j_p_e_g.html#gga1d047060ea80bb9820d540bb928e9074a63085dbf683cfe39e513cdb6343e3737">TJSAMP_420</a>. This produces an image compatible with the I420 (AKA "YUV420P") format.</td></tr>
+    <tr><td class="paramname">flags</td><td>the bitwise OR of one or more of the <a class="el" href="group___turbo_j_p_e_g.html#gacb233cfd722d66d1ccbf48a7de81f0e0">flags</a></td></tr>
+  </table>
+  </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>0 if successful, or -1 if an error occurred (see <a class="el" href="group___turbo_j_p_e_g.html#ga1ead8574f9f39fbafc6b497124e7aafa" title="Returns a descriptive error message explaining why the last command failed.">tjGetErrorStr2()</a> and <a class="el" href="group___turbo_j_p_e_g.html#ga414feeffbf860ebd31c745df203de410" title="Returns a code indicating the severity of the last error.">tjGetErrorCode()</a>.) </dd></dl>
+
+</div>
+</div>
+<a id="gae2d04c72457fe7f4d60cf78ab1b1feb1"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gae2d04c72457fe7f4d60cf78ab1b1feb1">&#9670;&nbsp;</a></span>tjEncodeYUVPlanes()</h2>
+
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">DLLEXPORT int tjEncodeYUVPlanes </td>
+          <td>(</td>
+          <td class="paramtype"><a class="el" href="group___turbo_j_p_e_g.html#ga758d2634ecb4949de7815cba621f5763">tjhandle</a>&#160;</td>
+          <td class="paramname"><em>handle</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">const unsigned char *&#160;</td>
+          <td class="paramname"><em>srcBuf</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>width</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>pitch</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>height</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>pixelFormat</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">unsigned char **&#160;</td>
+          <td class="paramname"><em>dstPlanes</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int *&#160;</td>
+          <td class="paramname"><em>strides</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>subsamp</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>flags</em>&#160;</td>
+        </tr>
+        <tr>
+          <td></td>
+          <td>)</td>
+          <td></td><td></td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+
+<p>Encode an RGB or grayscale image into separate Y, U (Cb), and V (Cr) image planes. </p>
+<p>This function uses the accelerated color conversion routines in the underlying codec but does not execute any of the other steps in the JPEG compression process.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+  <table class="params">
+    <tr><td class="paramname">handle</td><td>a handle to a TurboJPEG compressor or transformer instance</td></tr>
+    <tr><td class="paramname">srcBuf</td><td>pointer to an image buffer containing RGB or grayscale pixels to be encoded</td></tr>
+    <tr><td class="paramname">width</td><td>width (in pixels) of the source image</td></tr>
+    <tr><td class="paramname">pitch</td><td>bytes per line in the source image. Normally, this should be <code>width * <a class="el" href="group___turbo_j_p_e_g.html#gad77cf8fe5b2bfd3cb3f53098146abb4c" title="Pixel size (in bytes) for a given pixel format.">tjPixelSize</a>[pixelFormat]</code> if the image is unpadded, or <code><a class="el" href="group___turbo_j_p_e_g.html#ga0aba955473315e405295d978f0c16511" title="Pad the given width to the nearest 32-bit boundary.">TJPAD</a>(width * <a class="el" href="group___turbo_j_p_e_g.html#gad77cf8fe5b2bfd3cb3f53098146abb4c" title="Pixel size (in bytes) for a given pixel format.">tjPixelSize</a>[pixelFormat])</code> if each line of the image is padded to the nearest 32-bit boundary, as is the case for Windows bitmaps. You can also be clever and use this parameter to skip lines, etc. Setting this parameter to 0 is the equivalent of setting it to <code>width * <a class="el" href="group___turbo_j_p_e_g.html#gad77cf8fe5b2bfd3cb3f53098146abb4c" title="Pixel size (in bytes) for a given pixel format.">tjPixelSize</a>[pixelFormat]</code>.</td></tr>
+    <tr><td class="paramname">height</td><td>height (in pixels) of the source image</td></tr>
+    <tr><td class="paramname">pixelFormat</td><td>pixel format of the source image (see <a class="el" href="group___turbo_j_p_e_g.html#gac916144e26c3817ac514e64ae5d12e2a">Pixel formats</a>.)</td></tr>
+    <tr><td class="paramname">dstPlanes</td><td>an array of pointers to Y, U (Cb), and V (Cr) image planes (or just a Y plane, if generating a grayscale image) that will receive the encoded image. These planes can be contiguous or non-contiguous in memory. Use <a class="el" href="group___turbo_j_p_e_g.html#gab4ab7b24f6e797d79abaaa670373961d" title="The size of the buffer (in bytes) required to hold a YUV image plane with the given parameters.">tjPlaneSizeYUV()</a> to determine the appropriate size for each plane based on the image width, height, strides, and level of chrominance subsampling. Refer to <a class="el" href="group___turbo_j_p_e_g.html#YUVnotes">YUV Image Format Notes</a> for more details.</td></tr>
+    <tr><td class="paramname">strides</td><td>an array of integers, each specifying the number of bytes per line in the corresponding plane of the output image. Setting the stride for any plane to 0 is the same as setting it to the plane width (see <a class="el" href="group___turbo_j_p_e_g.html#YUVnotes">YUV Image Format Notes</a>.) If <code>strides</code> is NULL, then the strides for all planes will be set to their respective plane widths. You can adjust the strides in order to add an arbitrary amount of line padding to each plane or to encode an RGB or grayscale image into a subregion of a larger YUV planar image.</td></tr>
+    <tr><td class="paramname">subsamp</td><td>the level of chrominance subsampling to be used when generating the YUV image (see <a class="el" href="group___turbo_j_p_e_g.html#ga1d047060ea80bb9820d540bb928e9074">Chrominance subsampling options</a>.) To generate images suitable for X Video, <code>subsamp</code> should be set to <a class="el" href="group___turbo_j_p_e_g.html#gga1d047060ea80bb9820d540bb928e9074a63085dbf683cfe39e513cdb6343e3737">TJSAMP_420</a>. This produces an image compatible with the I420 (AKA "YUV420P") format.</td></tr>
+    <tr><td class="paramname">flags</td><td>the bitwise OR of one or more of the <a class="el" href="group___turbo_j_p_e_g.html#gacb233cfd722d66d1ccbf48a7de81f0e0">flags</a></td></tr>
+  </table>
+  </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>0 if successful, or -1 if an error occurred (see <a class="el" href="group___turbo_j_p_e_g.html#ga1ead8574f9f39fbafc6b497124e7aafa" title="Returns a descriptive error message explaining why the last command failed.">tjGetErrorStr2()</a> and <a class="el" href="group___turbo_j_p_e_g.html#ga414feeffbf860ebd31c745df203de410" title="Returns a code indicating the severity of the last error.">tjGetErrorCode()</a>.) </dd></dl>
+
+</div>
+</div>
+<a id="gaea863d2da0cdb609563aabdf9196514b"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gaea863d2da0cdb609563aabdf9196514b">&#9670;&nbsp;</a></span>tjFree()</h2>
+
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">DLLEXPORT void tjFree </td>
+          <td>(</td>
+          <td class="paramtype">unsigned char *&#160;</td>
+          <td class="paramname"><em>buffer</em></td><td>)</td>
+          <td></td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+
+<p>Free an image buffer previously allocated by TurboJPEG. </p>
+<p>You should always use this function to free JPEG destination buffer(s) that were automatically (re)allocated by the compression and transform functions or that were manually allocated using <a class="el" href="group___turbo_j_p_e_g.html#gaec627dd4c5f30b7a775a7aea3bec5d83" title="Allocate an image buffer for use with TurboJPEG.">tjAlloc()</a>.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+  <table class="params">
+    <tr><td class="paramname">buffer</td><td>address of the buffer to free. If the address is NULL, then this function has no effect.</td></tr>
+  </table>
+  </dd>
+</dl>
+<dl class="section see"><dt>See also</dt><dd><a class="el" href="group___turbo_j_p_e_g.html#gaec627dd4c5f30b7a775a7aea3bec5d83" title="Allocate an image buffer for use with TurboJPEG.">tjAlloc()</a> </dd></dl>
+
+</div>
+</div>
+<a id="ga414feeffbf860ebd31c745df203de410"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga414feeffbf860ebd31c745df203de410">&#9670;&nbsp;</a></span>tjGetErrorCode()</h2>
+
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">DLLEXPORT int tjGetErrorCode </td>
+          <td>(</td>
+          <td class="paramtype"><a class="el" href="group___turbo_j_p_e_g.html#ga758d2634ecb4949de7815cba621f5763">tjhandle</a>&#160;</td>
+          <td class="paramname"><em>handle</em></td><td>)</td>
+          <td></td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+
+<p>Returns a code indicating the severity of the last error. </p>
+<p>See <a class="el" href="group___turbo_j_p_e_g.html#gafbc17cfa57d0d5d11fea35ac025950fe">Error codes</a>.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+  <table class="params">
+    <tr><td class="paramname">handle</td><td>a handle to a TurboJPEG compressor, decompressor or transformer instance</td></tr>
+  </table>
+  </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>a code indicating the severity of the last error. See <a class="el" href="group___turbo_j_p_e_g.html#gafbc17cfa57d0d5d11fea35ac025950fe">Error codes</a>. </dd></dl>
+
+</div>
+</div>
+<a id="ga1ead8574f9f39fbafc6b497124e7aafa"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga1ead8574f9f39fbafc6b497124e7aafa">&#9670;&nbsp;</a></span>tjGetErrorStr2()</h2>
+
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">DLLEXPORT char* tjGetErrorStr2 </td>
+          <td>(</td>
+          <td class="paramtype"><a class="el" href="group___turbo_j_p_e_g.html#ga758d2634ecb4949de7815cba621f5763">tjhandle</a>&#160;</td>
+          <td class="paramname"><em>handle</em></td><td>)</td>
+          <td></td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+
+<p>Returns a descriptive error message explaining why the last command failed. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+  <table class="params">
+    <tr><td class="paramname">handle</td><td>a handle to a TurboJPEG compressor, decompressor, or transformer instance, or NULL if the error was generated by a global function (but note that retrieving the error message for a global function is thread-safe only on platforms that support thread-local storage.)</td></tr>
+  </table>
+  </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>a descriptive error message explaining why the last command failed. </dd></dl>
+
+</div>
+</div>
+<a id="gac3854476006b10787bd128f7ede48057"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gac3854476006b10787bd128f7ede48057">&#9670;&nbsp;</a></span>tjGetScalingFactors()</h2>
+
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">DLLEXPORT <a class="el" href="structtjscalingfactor.html">tjscalingfactor</a>* tjGetScalingFactors </td>
+          <td>(</td>
+          <td class="paramtype">int *&#160;</td>
+          <td class="paramname"><em>numscalingfactors</em></td><td>)</td>
+          <td></td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+
+<p>Returns a list of fractional scaling factors that the JPEG decompressor in this implementation of TurboJPEG supports. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+  <table class="params">
+    <tr><td class="paramname">numscalingfactors</td><td>pointer to an integer variable that will receive the number of elements in the list</td></tr>
+  </table>
+  </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>a pointer to a list of fractional scaling factors, or NULL if an error is encountered (see <a class="el" href="group___turbo_j_p_e_g.html#ga1ead8574f9f39fbafc6b497124e7aafa" title="Returns a descriptive error message explaining why the last command failed.">tjGetErrorStr2()</a>.) </dd></dl>
+
+</div>
+</div>
+<a id="ga9d63a05fc6d813f4aae06107041a37e8"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga9d63a05fc6d813f4aae06107041a37e8">&#9670;&nbsp;</a></span>tjInitCompress()</h2>
+
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">DLLEXPORT <a class="el" href="group___turbo_j_p_e_g.html#ga758d2634ecb4949de7815cba621f5763">tjhandle</a> tjInitCompress </td>
+          <td>(</td>
+          <td class="paramtype">void&#160;</td>
+          <td class="paramname"></td><td>)</td>
+          <td></td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+
+<p>Create a TurboJPEG compressor instance. </p>
+<dl class="section return"><dt>Returns</dt><dd>a handle to the newly-created instance, or NULL if an error occurred (see <a class="el" href="group___turbo_j_p_e_g.html#ga1ead8574f9f39fbafc6b497124e7aafa" title="Returns a descriptive error message explaining why the last command failed.">tjGetErrorStr2()</a>.) </dd></dl>
+
+</div>
+</div>
+<a id="ga52300eac3f3d9ef4bab303bc244f62d3"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga52300eac3f3d9ef4bab303bc244f62d3">&#9670;&nbsp;</a></span>tjInitDecompress()</h2>
+
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">DLLEXPORT <a class="el" href="group___turbo_j_p_e_g.html#ga758d2634ecb4949de7815cba621f5763">tjhandle</a> tjInitDecompress </td>
+          <td>(</td>
+          <td class="paramtype">void&#160;</td>
+          <td class="paramname"></td><td>)</td>
+          <td></td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+
+<p>Create a TurboJPEG decompressor instance. </p>
+<dl class="section return"><dt>Returns</dt><dd>a handle to the newly-created instance, or NULL if an error occurred (see <a class="el" href="group___turbo_j_p_e_g.html#ga1ead8574f9f39fbafc6b497124e7aafa" title="Returns a descriptive error message explaining why the last command failed.">tjGetErrorStr2()</a>.) </dd></dl>
+
+</div>
+</div>
+<a id="ga928beff6ac248ceadf01089fc6b41957"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga928beff6ac248ceadf01089fc6b41957">&#9670;&nbsp;</a></span>tjInitTransform()</h2>
+
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">DLLEXPORT <a class="el" href="group___turbo_j_p_e_g.html#ga758d2634ecb4949de7815cba621f5763">tjhandle</a> tjInitTransform </td>
+          <td>(</td>
+          <td class="paramtype">void&#160;</td>
+          <td class="paramname"></td><td>)</td>
+          <td></td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+
+<p>Create a new TurboJPEG transformer instance. </p>
+<dl class="section return"><dt>Returns</dt><dd>a handle to the newly-created instance, or NULL if an error occurred (see <a class="el" href="group___turbo_j_p_e_g.html#ga1ead8574f9f39fbafc6b497124e7aafa" title="Returns a descriptive error message explaining why the last command failed.">tjGetErrorStr2()</a>.) </dd></dl>
+
+</div>
+</div>
+<a id="gaffbd83c375e79f5db4b5c5d8ad4466e7"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gaffbd83c375e79f5db4b5c5d8ad4466e7">&#9670;&nbsp;</a></span>tjLoadImage()</h2>
+
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">DLLEXPORT unsigned char* tjLoadImage </td>
+          <td>(</td>
+          <td class="paramtype">const char *&#160;</td>
+          <td class="paramname"><em>filename</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int *&#160;</td>
+          <td class="paramname"><em>width</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>align</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int *&#160;</td>
+          <td class="paramname"><em>height</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int *&#160;</td>
+          <td class="paramname"><em>pixelFormat</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>flags</em>&#160;</td>
+        </tr>
+        <tr>
+          <td></td>
+          <td>)</td>
+          <td></td><td></td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+
+<p>Load an uncompressed image from disk into memory. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+  <table class="params">
+    <tr><td class="paramname">filename</td><td>name of a file containing an uncompressed image in Windows BMP or PBMPLUS (PPM/PGM) format</td></tr>
+    <tr><td class="paramname">width</td><td>pointer to an integer variable that will receive the width (in pixels) of the uncompressed image</td></tr>
+    <tr><td class="paramname">align</td><td>row alignment of the image buffer to be returned (must be a power of 2.) For instance, setting this parameter to 4 will cause all rows in the image buffer to be padded to the nearest 32-bit boundary, and setting this parameter to 1 will cause all rows in the image buffer to be unpadded.</td></tr>
+    <tr><td class="paramname">height</td><td>pointer to an integer variable that will receive the height (in pixels) of the uncompressed image</td></tr>
+    <tr><td class="paramname">pixelFormat</td><td>pointer to an integer variable that specifies or will receive the pixel format of the uncompressed image buffer. The behavior of <a class="el" href="group___turbo_j_p_e_g.html#gaffbd83c375e79f5db4b5c5d8ad4466e7" title="Load an uncompressed image from disk into memory.">tjLoadImage()</a> will vary depending on the value of <code>*pixelFormat</code> passed to the function:<ul>
+<li><a class="el" href="group___turbo_j_p_e_g.html#ggac916144e26c3817ac514e64ae5d12e2aa84c1a6cead7952998e2fb895844a21ed">TJPF_UNKNOWN</a> : The uncompressed image buffer returned by the function will use the most optimal pixel format for the file type, and <code>*pixelFormat</code> will contain the ID of this pixel format upon successful return from the function.</li>
+<li><a class="el" href="group___turbo_j_p_e_g.html#ggac916144e26c3817ac514e64ae5d12e2aa5431b54b015337705f13118073711a1a">TJPF_GRAY</a> : Only PGM files and 8-bit BMP files with a grayscale colormap can be loaded.</li>
+<li><a class="el" href="group___turbo_j_p_e_g.html#ggac916144e26c3817ac514e64ae5d12e2aa7f5100ec44c91994e243f1cf55553f8b">TJPF_CMYK</a> : The RGB or grayscale pixels stored in the file will be converted using a quick &amp; dirty algorithm that is suitable only for testing purposes (proper conversion between CMYK and other formats requires a color management system.)</li>
+<li>Other <a class="el" href="group___turbo_j_p_e_g.html#gac916144e26c3817ac514e64ae5d12e2a">pixel formats</a> : The uncompressed image buffer will use the specified pixel format, and pixel format conversion will be performed if necessary.</li>
+</ul>
+</td></tr>
+    <tr><td class="paramname">flags</td><td>the bitwise OR of one or more of the <a class="el" href="group___turbo_j_p_e_g.html#ga72ecf4ebe6eb702d3c6f5ca27455e1ec">flags</a>.</td></tr>
+  </table>
+  </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>a pointer to a newly-allocated buffer containing the uncompressed image, converted to the chosen pixel format and with the chosen row alignment, or NULL if an error occurred (see <a class="el" href="group___turbo_j_p_e_g.html#ga1ead8574f9f39fbafc6b497124e7aafa" title="Returns a descriptive error message explaining why the last command failed.">tjGetErrorStr2()</a>.) This buffer should be freed using <a class="el" href="group___turbo_j_p_e_g.html#gaea863d2da0cdb609563aabdf9196514b" title="Free an image buffer previously allocated by TurboJPEG.">tjFree()</a>. </dd></dl>
+
+</div>
+</div>
+<a id="ga1a209696c6a80748f20e134b3c64789f"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga1a209696c6a80748f20e134b3c64789f">&#9670;&nbsp;</a></span>tjPlaneHeight()</h2>
+
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">DLLEXPORT int tjPlaneHeight </td>
+          <td>(</td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>componentID</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>height</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>subsamp</em>&#160;</td>
+        </tr>
+        <tr>
+          <td></td>
+          <td>)</td>
+          <td></td><td></td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+
+<p>The plane height of a YUV image plane with the given parameters. </p>
+<p>Refer to <a class="el" href="group___turbo_j_p_e_g.html#YUVnotes">YUV Image Format Notes</a> for a description of plane height.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+  <table class="params">
+    <tr><td class="paramname">componentID</td><td>ID number of the image plane (0 = Y, 1 = U/Cb, 2 = V/Cr)</td></tr>
+    <tr><td class="paramname">height</td><td>height (in pixels) of the YUV image</td></tr>
+    <tr><td class="paramname">subsamp</td><td>level of chrominance subsampling in the image (see <a class="el" href="group___turbo_j_p_e_g.html#ga1d047060ea80bb9820d540bb928e9074">Chrominance subsampling options</a>.)</td></tr>
+  </table>
+  </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>the plane height of a YUV image plane with the given parameters, or -1 if the arguments are out of bounds. </dd></dl>
+
+</div>
+</div>
+<a id="gab4ab7b24f6e797d79abaaa670373961d"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gab4ab7b24f6e797d79abaaa670373961d">&#9670;&nbsp;</a></span>tjPlaneSizeYUV()</h2>
+
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">DLLEXPORT unsigned long tjPlaneSizeYUV </td>
+          <td>(</td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>componentID</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>width</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>stride</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>height</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>subsamp</em>&#160;</td>
+        </tr>
+        <tr>
+          <td></td>
+          <td>)</td>
+          <td></td><td></td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+
+<p>The size of the buffer (in bytes) required to hold a YUV image plane with the given parameters. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+  <table class="params">
+    <tr><td class="paramname">componentID</td><td>ID number of the image plane (0 = Y, 1 = U/Cb, 2 = V/Cr)</td></tr>
+    <tr><td class="paramname">width</td><td>width (in pixels) of the YUV image. NOTE: this is the width of the whole image, not the plane width.</td></tr>
+    <tr><td class="paramname">stride</td><td>bytes per line in the image plane. Setting this to 0 is the equivalent of setting it to the plane width.</td></tr>
+    <tr><td class="paramname">height</td><td>height (in pixels) of the YUV image. NOTE: this is the height of the whole image, not the plane height.</td></tr>
+    <tr><td class="paramname">subsamp</td><td>level of chrominance subsampling in the image (see <a class="el" href="group___turbo_j_p_e_g.html#ga1d047060ea80bb9820d540bb928e9074">Chrominance subsampling options</a>.)</td></tr>
+  </table>
+  </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>the size of the buffer (in bytes) required to hold the YUV image plane, or -1 if the arguments are out of bounds. </dd></dl>
+
+</div>
+</div>
+<a id="ga63fb66bb1e36c74008c4634360becbb1"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga63fb66bb1e36c74008c4634360becbb1">&#9670;&nbsp;</a></span>tjPlaneWidth()</h2>
+
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">DLLEXPORT int tjPlaneWidth </td>
+          <td>(</td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>componentID</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>width</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>subsamp</em>&#160;</td>
+        </tr>
+        <tr>
+          <td></td>
+          <td>)</td>
+          <td></td><td></td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+
+<p>The plane width of a YUV image plane with the given parameters. </p>
+<p>Refer to <a class="el" href="group___turbo_j_p_e_g.html#YUVnotes">YUV Image Format Notes</a> for a description of plane width.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+  <table class="params">
+    <tr><td class="paramname">componentID</td><td>ID number of the image plane (0 = Y, 1 = U/Cb, 2 = V/Cr)</td></tr>
+    <tr><td class="paramname">width</td><td>width (in pixels) of the YUV image</td></tr>
+    <tr><td class="paramname">subsamp</td><td>level of chrominance subsampling in the image (see <a class="el" href="group___turbo_j_p_e_g.html#ga1d047060ea80bb9820d540bb928e9074">Chrominance subsampling options</a>.)</td></tr>
+  </table>
+  </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>the plane width of a YUV image plane with the given parameters, or -1 if the arguments are out of bounds. </dd></dl>
+
+</div>
+</div>
+<a id="ga6f445b22d8933ae4815b3370a538d879"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga6f445b22d8933ae4815b3370a538d879">&#9670;&nbsp;</a></span>tjSaveImage()</h2>
+
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">DLLEXPORT int tjSaveImage </td>
+          <td>(</td>
+          <td class="paramtype">const char *&#160;</td>
+          <td class="paramname"><em>filename</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">unsigned char *&#160;</td>
+          <td class="paramname"><em>buffer</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>width</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>pitch</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>height</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>pixelFormat</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>flags</em>&#160;</td>
+        </tr>
+        <tr>
+          <td></td>
+          <td>)</td>
+          <td></td><td></td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+
+<p>Save an uncompressed image from memory to disk. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+  <table class="params">
+    <tr><td class="paramname">filename</td><td>name of a file to which to save the uncompressed image. The image will be stored in Windows BMP or PBMPLUS (PPM/PGM) format, depending on the file extension.</td></tr>
+    <tr><td class="paramname">buffer</td><td>pointer to an image buffer containing RGB, grayscale, or CMYK pixels to be saved</td></tr>
+    <tr><td class="paramname">width</td><td>width (in pixels) of the uncompressed image</td></tr>
+    <tr><td class="paramname">pitch</td><td>bytes per line in the image buffer. Setting this parameter to 0 is the equivalent of setting it to <code>width * <a class="el" href="group___turbo_j_p_e_g.html#gad77cf8fe5b2bfd3cb3f53098146abb4c" title="Pixel size (in bytes) for a given pixel format.">tjPixelSize</a>[pixelFormat]</code>.</td></tr>
+    <tr><td class="paramname">height</td><td>height (in pixels) of the uncompressed image</td></tr>
+    <tr><td class="paramname">pixelFormat</td><td>pixel format of the image buffer (see <a class="el" href="group___turbo_j_p_e_g.html#gac916144e26c3817ac514e64ae5d12e2a">Pixel formats</a>.) If this parameter is set to <a class="el" href="group___turbo_j_p_e_g.html#ggac916144e26c3817ac514e64ae5d12e2aa5431b54b015337705f13118073711a1a">TJPF_GRAY</a>, then the image will be stored in PGM or 8-bit (indexed color) BMP format. Otherwise, the image will be stored in PPM or 24-bit BMP format. If this parameter is set to <a class="el" href="group___turbo_j_p_e_g.html#ggac916144e26c3817ac514e64ae5d12e2aa7f5100ec44c91994e243f1cf55553f8b">TJPF_CMYK</a>, then the CMYK pixels will be converted to RGB using a quick &amp; dirty algorithm that is suitable only for testing (proper conversion between CMYK and other formats requires a color management system.)</td></tr>
+    <tr><td class="paramname">flags</td><td>the bitwise OR of one or more of the <a class="el" href="group___turbo_j_p_e_g.html#ga72ecf4ebe6eb702d3c6f5ca27455e1ec">flags</a>.</td></tr>
+  </table>
+  </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>0 if successful, or -1 if an error occurred (see <a class="el" href="group___turbo_j_p_e_g.html#ga1ead8574f9f39fbafc6b497124e7aafa" title="Returns a descriptive error message explaining why the last command failed.">tjGetErrorStr2()</a>.) </dd></dl>
+
+</div>
+</div>
+<a id="ga9cb8abf4cc91881e04a0329b2270be25"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga9cb8abf4cc91881e04a0329b2270be25">&#9670;&nbsp;</a></span>tjTransform()</h2>
+
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">DLLEXPORT int tjTransform </td>
+          <td>(</td>
+          <td class="paramtype"><a class="el" href="group___turbo_j_p_e_g.html#ga758d2634ecb4949de7815cba621f5763">tjhandle</a>&#160;</td>
+          <td class="paramname"><em>handle</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">const unsigned char *&#160;</td>
+          <td class="paramname"><em>jpegBuf</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">unsigned long&#160;</td>
+          <td class="paramname"><em>jpegSize</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>n</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">unsigned char **&#160;</td>
+          <td class="paramname"><em>dstBufs</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">unsigned long *&#160;</td>
+          <td class="paramname"><em>dstSizes</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype"><a class="el" href="structtjtransform.html">tjtransform</a> *&#160;</td>
+          <td class="paramname"><em>transforms</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>flags</em>&#160;</td>
+        </tr>
+        <tr>
+          <td></td>
+          <td>)</td>
+          <td></td><td></td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+
+<p>Losslessly transform a JPEG image into another JPEG image. </p>
+<p>Lossless transforms work by moving the raw DCT coefficients from one JPEG image structure to another without altering the values of the coefficients. While this is typically faster than decompressing the image, transforming it, and re-compressing it, lossless transforms are not free. Each lossless transform requires reading and performing Huffman decoding on all of the coefficients in the source image, regardless of the size of the destination image. Thus, this function provides a means of generating multiple transformed images from the same source or applying multiple transformations simultaneously, in order to eliminate the need to read the source coefficients multiple times.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+  <table class="params">
+    <tr><td class="paramname">handle</td><td>a handle to a TurboJPEG transformer instance</td></tr>
+    <tr><td class="paramname">jpegBuf</td><td>pointer to a buffer containing the JPEG source image to transform</td></tr>
+    <tr><td class="paramname">jpegSize</td><td>size of the JPEG source image (in bytes)</td></tr>
+    <tr><td class="paramname">n</td><td>the number of transformed JPEG images to generate</td></tr>
+    <tr><td class="paramname">dstBufs</td><td>pointer to an array of n image buffers. <code>dstBufs[i]</code> will receive a JPEG image that has been transformed using the parameters in <code>transforms[i]</code>. TurboJPEG has the ability to reallocate the JPEG buffer to accommodate the size of the JPEG image. Thus, you can choose to:<ol type="1">
+<li>pre-allocate the JPEG buffer with an arbitrary size using <a class="el" href="group___turbo_j_p_e_g.html#gaec627dd4c5f30b7a775a7aea3bec5d83" title="Allocate an image buffer for use with TurboJPEG.">tjAlloc()</a> and let TurboJPEG grow the buffer as needed,</li>
+<li>set <code>dstBufs[i]</code> to NULL to tell TurboJPEG to allocate the buffer for you, or</li>
+<li>pre-allocate the buffer to a "worst case" size determined by calling <a class="el" href="group___turbo_j_p_e_g.html#ga67ac12fee79073242cb216e07c9f1f90" title="The maximum size of the buffer (in bytes) required to hold a JPEG image with the given parameters.">tjBufSize()</a> with the transformed or cropped width and height. Under normal circumstances, this should ensure that the buffer never has to be re-allocated (setting <a class="el" href="group___turbo_j_p_e_g.html#ga8808d403c68b62aaa58a4c1e58e98963" title="Disable buffer (re)allocation.">TJFLAG_NOREALLOC</a> guarantees that it won't be.) Note, however, that there are some rare cases (such as transforming images with a large amount of embedded EXIF or ICC profile data) in which the output image will be larger than the worst-case size, and <a class="el" href="group___turbo_j_p_e_g.html#ga8808d403c68b62aaa58a4c1e58e98963" title="Disable buffer (re)allocation.">TJFLAG_NOREALLOC</a> cannot be used in those cases.</li>
+</ol>
+If you choose option 1, <code>dstSizes[i]</code> should be set to the size of your pre-allocated buffer. In any case, unless you have set <a class="el" href="group___turbo_j_p_e_g.html#ga8808d403c68b62aaa58a4c1e58e98963" title="Disable buffer (re)allocation.">TJFLAG_NOREALLOC</a>, you should always check <code>dstBufs[i]</code> upon return from this function, as it may have changed.</td></tr>
+    <tr><td class="paramname">dstSizes</td><td>pointer to an array of n unsigned long variables that will receive the actual sizes (in bytes) of each transformed JPEG image. If <code>dstBufs[i]</code> points to a pre-allocated buffer, then <code>dstSizes[i]</code> should be set to the size of the buffer. Upon return, <code>dstSizes[i]</code> will contain the size of the JPEG image (in bytes.)</td></tr>
+    <tr><td class="paramname">transforms</td><td>pointer to an array of n <a class="el" href="structtjtransform.html" title="Lossless transform.">tjtransform</a> structures, each of which specifies the transform parameters and/or cropping region for the corresponding transformed output image.</td></tr>
+    <tr><td class="paramname">flags</td><td>the bitwise OR of one or more of the <a class="el" href="group___turbo_j_p_e_g.html#gacb233cfd722d66d1ccbf48a7de81f0e0">flags</a></td></tr>
+  </table>
+  </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>0 if successful, or -1 if an error occurred (see <a class="el" href="group___turbo_j_p_e_g.html#ga1ead8574f9f39fbafc6b497124e7aafa" title="Returns a descriptive error message explaining why the last command failed.">tjGetErrorStr2()</a> and <a class="el" href="group___turbo_j_p_e_g.html#ga414feeffbf860ebd31c745df203de410" title="Returns a code indicating the severity of the last error.">tjGetErrorCode()</a>.) </dd></dl>
+
+</div>
+</div>
+<h2 class="groupheader">Variable Documentation</h2>
+<a id="ga5af0ab065feefd526debf1e20c43e837"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga5af0ab065feefd526debf1e20c43e837">&#9670;&nbsp;</a></span>tjAlphaOffset</h2>
+
+<div class="memitem">
+<div class="memproto">
+<table class="mlabels">
+  <tr>
+  <td class="mlabels-left">
+      <table class="memname">
+        <tr>
+          <td class="memname">const int tjAlphaOffset[<a class="el" href="group___turbo_j_p_e_g.html#ga7010a4402f54a45ba822ad8675a4655e">TJ_NUMPF</a>]</td>
+        </tr>
+      </table>
+  </td>
+  <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">static</span></span>  </td>
+  </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Alpha offset (in bytes) for a given pixel format. </p>
+<p>This specifies the number of bytes that the Alpha component is offset from the start of the pixel. For instance, if a pixel of format TJ_BGRA is stored in <code>char pixel[]</code>, then the alpha component will be <code>pixel[tjAlphaOffset[TJ_BGRA]]</code>. This will be -1 if the pixel format does not have an alpha component. </p>
+
+</div>
+</div>
+<a id="ga84e2e35d3f08025f976ec1ec53693dea"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga84e2e35d3f08025f976ec1ec53693dea">&#9670;&nbsp;</a></span>tjBlueOffset</h2>
+
+<div class="memitem">
+<div class="memproto">
+<table class="mlabels">
+  <tr>
+  <td class="mlabels-left">
+      <table class="memname">
+        <tr>
+          <td class="memname">const int tjBlueOffset[<a class="el" href="group___turbo_j_p_e_g.html#ga7010a4402f54a45ba822ad8675a4655e">TJ_NUMPF</a>]</td>
+        </tr>
+      </table>
+  </td>
+  <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">static</span></span>  </td>
+  </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Blue offset (in bytes) for a given pixel format. </p>
+<p>This specifies the number of bytes that the Blue component is offset from the start of the pixel. For instance, if a pixel of format TJ_BGRX is stored in <code>char pixel[]</code>, then the blue component will be <code>pixel[tjBlueOffset[TJ_BGRX]]</code>. This will be -1 if the pixel format does not have a blue component. </p>
+
+</div>
+</div>
+<a id="ga82d6e35da441112a411da41923c0ba2f"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga82d6e35da441112a411da41923c0ba2f">&#9670;&nbsp;</a></span>tjGreenOffset</h2>
+
+<div class="memitem">
+<div class="memproto">
+<table class="mlabels">
+  <tr>
+  <td class="mlabels-left">
+      <table class="memname">
+        <tr>
+          <td class="memname">const int tjGreenOffset[<a class="el" href="group___turbo_j_p_e_g.html#ga7010a4402f54a45ba822ad8675a4655e">TJ_NUMPF</a>]</td>
+        </tr>
+      </table>
+  </td>
+  <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">static</span></span>  </td>
+  </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Green offset (in bytes) for a given pixel format. </p>
+<p>This specifies the number of bytes that the green component is offset from the start of the pixel. For instance, if a pixel of format TJ_BGRX is stored in <code>char pixel[]</code>, then the green component will be <code>pixel[tjGreenOffset[TJ_BGRX]]</code>. This will be -1 if the pixel format does not have a green component. </p>
+
+</div>
+</div>
+<a id="gabd247bb9fecb393eca57366feb8327bf"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gabd247bb9fecb393eca57366feb8327bf">&#9670;&nbsp;</a></span>tjMCUHeight</h2>
+
+<div class="memitem">
+<div class="memproto">
+<table class="mlabels">
+  <tr>
+  <td class="mlabels-left">
+      <table class="memname">
+        <tr>
+          <td class="memname">const int tjMCUHeight[<a class="el" href="group___turbo_j_p_e_g.html#ga5ef3d169162ce77ce348e292a0b7477c">TJ_NUMSAMP</a>]</td>
+        </tr>
+      </table>
+  </td>
+  <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">static</span></span>  </td>
+  </tr>
+</table>
+</div><div class="memdoc">
+
+<p>MCU block height (in pixels) for a given level of chrominance subsampling. </p>
+<p>MCU block sizes:</p><ul>
+<li>8x8 for no subsampling or grayscale</li>
+<li>16x8 for 4:2:2</li>
+<li>8x16 for 4:4:0</li>
+<li>16x16 for 4:2:0</li>
+<li>32x8 for 4:1:1 </li>
+</ul>
+
+</div>
+</div>
+<a id="ga9e61e7cd47a15a173283ba94e781308c"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga9e61e7cd47a15a173283ba94e781308c">&#9670;&nbsp;</a></span>tjMCUWidth</h2>
+
+<div class="memitem">
+<div class="memproto">
+<table class="mlabels">
+  <tr>
+  <td class="mlabels-left">
+      <table class="memname">
+        <tr>
+          <td class="memname">const int tjMCUWidth[<a class="el" href="group___turbo_j_p_e_g.html#ga5ef3d169162ce77ce348e292a0b7477c">TJ_NUMSAMP</a>]</td>
+        </tr>
+      </table>
+  </td>
+  <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">static</span></span>  </td>
+  </tr>
+</table>
+</div><div class="memdoc">
+
+<p>MCU block width (in pixels) for a given level of chrominance subsampling. </p>
+<p>MCU block sizes:</p><ul>
+<li>8x8 for no subsampling or grayscale</li>
+<li>16x8 for 4:2:2</li>
+<li>8x16 for 4:4:0</li>
+<li>16x16 for 4:2:0</li>
+<li>32x8 for 4:1:1 </li>
+</ul>
+
+</div>
+</div>
+<a id="gad77cf8fe5b2bfd3cb3f53098146abb4c"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gad77cf8fe5b2bfd3cb3f53098146abb4c">&#9670;&nbsp;</a></span>tjPixelSize</h2>
+
+<div class="memitem">
+<div class="memproto">
+<table class="mlabels">
+  <tr>
+  <td class="mlabels-left">
+      <table class="memname">
+        <tr>
+          <td class="memname">const int tjPixelSize[<a class="el" href="group___turbo_j_p_e_g.html#ga7010a4402f54a45ba822ad8675a4655e">TJ_NUMPF</a>]</td>
+        </tr>
+      </table>
+  </td>
+  <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">static</span></span>  </td>
+  </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Pixel size (in bytes) for a given pixel format. </p>
+
+</div>
+</div>
+<a id="gadd9b446742ac8a3923f7992c7988fea8"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gadd9b446742ac8a3923f7992c7988fea8">&#9670;&nbsp;</a></span>tjRedOffset</h2>
+
+<div class="memitem">
+<div class="memproto">
+<table class="mlabels">
+  <tr>
+  <td class="mlabels-left">
+      <table class="memname">
+        <tr>
+          <td class="memname">const int tjRedOffset[<a class="el" href="group___turbo_j_p_e_g.html#ga7010a4402f54a45ba822ad8675a4655e">TJ_NUMPF</a>]</td>
+        </tr>
+      </table>
+  </td>
+  <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">static</span></span>  </td>
+  </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Red offset (in bytes) for a given pixel format. </p>
+<p>This specifies the number of bytes that the red component is offset from the start of the pixel. For instance, if a pixel of format TJ_BGRX is stored in <code>char pixel[]</code>, then the red component will be <code>pixel[tjRedOffset[TJ_BGRX]]</code>. This will be -1 if the pixel format does not have a red component. </p>
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated by&#160;<a href="http://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.8.20
+</small></address>
+</body>
+</html>
diff --git a/3rdparty/libjpeg/src/doc/html/index.html b/3rdparty/libjpeg/src/doc/html/index.html
new file mode 100644
index 00000000..c5ed7780
--- /dev/null
+++ b/3rdparty/libjpeg/src/doc/html/index.html
@@ -0,0 +1,76 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.8.20"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>TurboJPEG: Main Page</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="search/search.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="search/searchdata.js"></script>
+<script type="text/javascript" src="search/search.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+  <td id="projectalign" style="padding-left: 0.5em;">
+   <div id="projectname">TurboJPEG
+   &#160;<span id="projectnumber">2.0</span>
+   </div>
+  </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.8.20 -->
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+var searchBox = new SearchBox("searchBox", "search",false,'Search');
+/* @license-end */
+</script>
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+  initMenu('',true,false,'search.php','Search');
+  $(document).ready(function() { init_search(); });
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<!-- window showing the filter options -->
+<div id="MSearchSelectWindow"
+     onmouseover="return searchBox.OnSearchSelectShow()"
+     onmouseout="return searchBox.OnSearchSelectHide()"
+     onkeydown="return searchBox.OnSearchSelectKey(event)">
+</div>
+
+<!-- iframe showing the search results (closed by default) -->
+<div id="MSearchResultsWindow">
+<iframe src="javascript:void(0)" frameborder="0" 
+        name="MSearchResults" id="MSearchResults">
+</iframe>
+</div>
+
+<div class="header">
+  <div class="headertitle">
+<div class="title">TurboJPEG Documentation</div>  </div>
+</div><!--header-->
+<div class="contents">
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated by&#160;<a href="http://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.8.20
+</small></address>
+</body>
+</html>
diff --git a/3rdparty/libjpeg/src/doc/html/jquery.js b/3rdparty/libjpeg/src/doc/html/jquery.js
new file mode 100644
index 00000000..103c32d7
--- /dev/null
+++ b/3rdparty/libjpeg/src/doc/html/jquery.js
@@ -0,0 +1,35 @@
+/*! jQuery v3.4.1 | (c) JS Foundation and other contributors | jquery.org/license */
+!function(e,t){"use strict";"object"==typeof module&&"object"==typeof module.exports?module.exports=e.document?t(e,!0):function(e){if(!e.document)throw new Error("jQuery requires a window with a document");return t(e)}:t(e)}("undefined"!=typeof window?window:this,function(C,e){"use strict";var t=[],E=C.document,r=Object.getPrototypeOf,s=t.slice,g=t.concat,u=t.push,i=t.indexOf,n={},o=n.toString,v=n.hasOwnProperty,a=v.toString,l=a.call(Object),y={},m=function(e){return"function"==typeof e&&"number"!=typeof e.nodeType},x=function(e){return null!=e&&e===e.window},c={type:!0,src:!0,nonce:!0,noModule:!0};function b(e,t,n){var r,i,o=(n=n||E).createElement("script");if(o.text=e,t)for(r in c)(i=t[r]||t.getAttribute&&t.getAttribute(r))&&o.setAttribute(r,i);n.head.appendChild(o).parentNode.removeChild(o)}function w(e){return null==e?e+"":"object"==typeof e||"function"==typeof e?n[o.call(e)]||"object":typeof e}var f="3.4.1",k=function(e,t){return new k.fn.init(e,t)},p=/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g;function d(e){var t=!!e&&"length"in e&&e.length,n=w(e);return!m(e)&&!x(e)&&("array"===n||0===t||"number"==typeof t&&0<t&&t-1 in e)}k.fn=k.prototype={jquery:f,constructor:k,length:0,toArray:function(){return s.call(this)},get:function(e){return null==e?s.call(this):e<0?this[e+this.length]:this[e]},pushStack:function(e){var t=k.merge(this.constructor(),e);return t.prevObject=this,t},each:function(e){return k.each(this,e)},map:function(n){return this.pushStack(k.map(this,function(e,t){return n.call(e,t,e)}))},slice:function(){return this.pushStack(s.apply(this,arguments))},first:function(){return this.eq(0)},last:function(){return this.eq(-1)},eq:function(e){var t=this.length,n=+e+(e<0?t:0);return this.pushStack(0<=n&&n<t?[this[n]]:[])},end:function(){return this.prevObject||this.constructor()},push:u,sort:t.sort,splice:t.splice},k.extend=k.fn.extend=function(){var e,t,n,r,i,o,a=arguments[0]||{},s=1,u=arguments.length,l=!1;for("boolean"==typeof a&&(l=a,a=arguments[s]||{},s++),"object"==typeof a||m(a)||(a={}),s===u&&(a=this,s--);s<u;s++)if(null!=(e=arguments[s]))for(t in e)r=e[t],"__proto__"!==t&&a!==r&&(l&&r&&(k.isPlainObject(r)||(i=Array.isArray(r)))?(n=a[t],o=i&&!Array.isArray(n)?[]:i||k.isPlainObject(n)?n:{},i=!1,a[t]=k.extend(l,o,r)):void 0!==r&&(a[t]=r));return a},k.extend({expando:"jQuery"+(f+Math.random()).replace(/\D/g,""),isReady:!0,error:function(e){throw new Error(e)},noop:function(){},isPlainObject:function(e){var t,n;return!(!e||"[object Object]"!==o.call(e))&&(!(t=r(e))||"function"==typeof(n=v.call(t,"constructor")&&t.constructor)&&a.call(n)===l)},isEmptyObject:function(e){var t;for(t in e)return!1;return!0},globalEval:function(e,t){b(e,{nonce:t&&t.nonce})},each:function(e,t){var n,r=0;if(d(e)){for(n=e.length;r<n;r++)if(!1===t.call(e[r],r,e[r]))break}else for(r in e)if(!1===t.call(e[r],r,e[r]))break;return e},trim:function(e){return null==e?"":(e+"").replace(p,"")},makeArray:function(e,t){var n=t||[];return null!=e&&(d(Object(e))?k.merge(n,"string"==typeof e?[e]:e):u.call(n,e)),n},inArray:function(e,t,n){return null==t?-1:i.call(t,e,n)},merge:function(e,t){for(var n=+t.length,r=0,i=e.length;r<n;r++)e[i++]=t[r];return e.length=i,e},grep:function(e,t,n){for(var r=[],i=0,o=e.length,a=!n;i<o;i++)!t(e[i],i)!==a&&r.push(e[i]);return r},map:function(e,t,n){var r,i,o=0,a=[];if(d(e))for(r=e.length;o<r;o++)null!=(i=t(e[o],o,n))&&a.push(i);else for(o in e)null!=(i=t(e[o],o,n))&&a.push(i);return g.apply([],a)},guid:1,support:y}),"function"==typeof Symbol&&(k.fn[Symbol.iterator]=t[Symbol.iterator]),k.each("Boolean Number String Function Array Date RegExp Object Error Symbol".split(" "),function(e,t){n["[object "+t+"]"]=t.toLowerCase()});var h=function(n){var e,d,b,o,i,h,f,g,w,u,l,T,C,a,E,v,s,c,y,k="sizzle"+1*new Date,m=n.document,S=0,r=0,p=ue(),x=ue(),N=ue(),A=ue(),D=function(e,t){return e===t&&(l=!0),0},j={}.hasOwnProperty,t=[],q=t.pop,L=t.push,H=t.push,O=t.slice,P=function(e,t){for(var n=0,r=e.length;n<r;n++)if(e[n]===t)return n;return-1},R="checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped",M="[\\x20\\t\\r\\n\\f]",I="(?:\\\\.|[\\w-]|[^\0-\\xa0])+",W="\\["+M+"*("+I+")(?:"+M+"*([*^$|!~]?=)"+M+"*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|("+I+"))|)"+M+"*\\]",$=":("+I+")(?:\\((('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|((?:\\\\.|[^\\\\()[\\]]|"+W+")*)|.*)\\)|)",F=new RegExp(M+"+","g"),B=new RegExp("^"+M+"+|((?:^|[^\\\\])(?:\\\\.)*)"+M+"+$","g"),_=new RegExp("^"+M+"*,"+M+"*"),z=new RegExp("^"+M+"*([>+~]|"+M+")"+M+"*"),U=new RegExp(M+"|>"),X=new RegExp($),V=new RegExp("^"+I+"$"),G={ID:new RegExp("^#("+I+")"),CLASS:new RegExp("^\\.("+I+")"),TAG:new RegExp("^("+I+"|[*])"),ATTR:new RegExp("^"+W),PSEUDO:new RegExp("^"+$),CHILD:new RegExp("^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\("+M+"*(even|odd|(([+-]|)(\\d*)n|)"+M+"*(?:([+-]|)"+M+"*(\\d+)|))"+M+"*\\)|)","i"),bool:new RegExp("^(?:"+R+")$","i"),needsContext:new RegExp("^"+M+"*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\("+M+"*((?:-\\d)?\\d*)"+M+"*\\)|)(?=[^-]|$)","i")},Y=/HTML$/i,Q=/^(?:input|select|textarea|button)$/i,J=/^h\d$/i,K=/^[^{]+\{\s*\[native \w/,Z=/^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,ee=/[+~]/,te=new RegExp("\\\\([\\da-f]{1,6}"+M+"?|("+M+")|.)","ig"),ne=function(e,t,n){var r="0x"+t-65536;return r!=r||n?t:r<0?String.fromCharCode(r+65536):String.fromCharCode(r>>10|55296,1023&r|56320)},re=/([\0-\x1f\x7f]|^-?\d)|^-$|[^\0-\x1f\x7f-\uFFFF\w-]/g,ie=function(e,t){return t?"\0"===e?"\ufffd":e.slice(0,-1)+"\\"+e.charCodeAt(e.length-1).toString(16)+" ":"\\"+e},oe=function(){T()},ae=be(function(e){return!0===e.disabled&&"fieldset"===e.nodeName.toLowerCase()},{dir:"parentNode",next:"legend"});try{H.apply(t=O.call(m.childNodes),m.childNodes),t[m.childNodes.length].nodeType}catch(e){H={apply:t.length?function(e,t){L.apply(e,O.call(t))}:function(e,t){var n=e.length,r=0;while(e[n++]=t[r++]);e.length=n-1}}}function se(t,e,n,r){var i,o,a,s,u,l,c,f=e&&e.ownerDocument,p=e?e.nodeType:9;if(n=n||[],"string"!=typeof t||!t||1!==p&&9!==p&&11!==p)return n;if(!r&&((e?e.ownerDocument||e:m)!==C&&T(e),e=e||C,E)){if(11!==p&&(u=Z.exec(t)))if(i=u[1]){if(9===p){if(!(a=e.getElementById(i)))return n;if(a.id===i)return n.push(a),n}else if(f&&(a=f.getElementById(i))&&y(e,a)&&a.id===i)return n.push(a),n}else{if(u[2])return H.apply(n,e.getElementsByTagName(t)),n;if((i=u[3])&&d.getElementsByClassName&&e.getElementsByClassName)return H.apply(n,e.getElementsByClassName(i)),n}if(d.qsa&&!A[t+" "]&&(!v||!v.test(t))&&(1!==p||"object"!==e.nodeName.toLowerCase())){if(c=t,f=e,1===p&&U.test(t)){(s=e.getAttribute("id"))?s=s.replace(re,ie):e.setAttribute("id",s=k),o=(l=h(t)).length;while(o--)l[o]="#"+s+" "+xe(l[o]);c=l.join(","),f=ee.test(t)&&ye(e.parentNode)||e}try{return H.apply(n,f.querySelectorAll(c)),n}catch(e){A(t,!0)}finally{s===k&&e.removeAttribute("id")}}}return g(t.replace(B,"$1"),e,n,r)}function ue(){var r=[];return function e(t,n){return r.push(t+" ")>b.cacheLength&&delete e[r.shift()],e[t+" "]=n}}function le(e){return e[k]=!0,e}function ce(e){var t=C.createElement("fieldset");try{return!!e(t)}catch(e){return!1}finally{t.parentNode&&t.parentNode.removeChild(t),t=null}}function fe(e,t){var n=e.split("|"),r=n.length;while(r--)b.attrHandle[n[r]]=t}function pe(e,t){var n=t&&e,r=n&&1===e.nodeType&&1===t.nodeType&&e.sourceIndex-t.sourceIndex;if(r)return r;if(n)while(n=n.nextSibling)if(n===t)return-1;return e?1:-1}function de(t){return function(e){return"input"===e.nodeName.toLowerCase()&&e.type===t}}function he(n){return function(e){var t=e.nodeName.toLowerCase();return("input"===t||"button"===t)&&e.type===n}}function ge(t){return function(e){return"form"in e?e.parentNode&&!1===e.disabled?"label"in e?"label"in e.parentNode?e.parentNode.disabled===t:e.disabled===t:e.isDisabled===t||e.isDisabled!==!t&&ae(e)===t:e.disabled===t:"label"in e&&e.disabled===t}}function ve(a){return le(function(o){return o=+o,le(function(e,t){var n,r=a([],e.length,o),i=r.length;while(i--)e[n=r[i]]&&(e[n]=!(t[n]=e[n]))})})}function ye(e){return e&&"undefined"!=typeof e.getElementsByTagName&&e}for(e in d=se.support={},i=se.isXML=function(e){var t=e.namespaceURI,n=(e.ownerDocument||e).documentElement;return!Y.test(t||n&&n.nodeName||"HTML")},T=se.setDocument=function(e){var t,n,r=e?e.ownerDocument||e:m;return r!==C&&9===r.nodeType&&r.documentElement&&(a=(C=r).documentElement,E=!i(C),m!==C&&(n=C.defaultView)&&n.top!==n&&(n.addEventListener?n.addEventListener("unload",oe,!1):n.attachEvent&&n.attachEvent("onunload",oe)),d.attributes=ce(function(e){return e.className="i",!e.getAttribute("className")}),d.getElementsByTagName=ce(function(e){return e.appendChild(C.createComment("")),!e.getElementsByTagName("*").length}),d.getElementsByClassName=K.test(C.getElementsByClassName),d.getById=ce(function(e){return a.appendChild(e).id=k,!C.getElementsByName||!C.getElementsByName(k).length}),d.getById?(b.filter.ID=function(e){var t=e.replace(te,ne);return function(e){return e.getAttribute("id")===t}},b.find.ID=function(e,t){if("undefined"!=typeof t.getElementById&&E){var n=t.getElementById(e);return n?[n]:[]}}):(b.filter.ID=function(e){var n=e.replace(te,ne);return function(e){var t="undefined"!=typeof e.getAttributeNode&&e.getAttributeNode("id");return t&&t.value===n}},b.find.ID=function(e,t){if("undefined"!=typeof t.getElementById&&E){var n,r,i,o=t.getElementById(e);if(o){if((n=o.getAttributeNode("id"))&&n.value===e)return[o];i=t.getElementsByName(e),r=0;while(o=i[r++])if((n=o.getAttributeNode("id"))&&n.value===e)return[o]}return[]}}),b.find.TAG=d.getElementsByTagName?function(e,t){return"undefined"!=typeof t.getElementsByTagName?t.getElementsByTagName(e):d.qsa?t.querySelectorAll(e):void 0}:function(e,t){var n,r=[],i=0,o=t.getElementsByTagName(e);if("*"===e){while(n=o[i++])1===n.nodeType&&r.push(n);return r}return o},b.find.CLASS=d.getElementsByClassName&&function(e,t){if("undefined"!=typeof t.getElementsByClassName&&E)return t.getElementsByClassName(e)},s=[],v=[],(d.qsa=K.test(C.querySelectorAll))&&(ce(function(e){a.appendChild(e).innerHTML="<a id='"+k+"'></a><select id='"+k+"-\r\\' msallowcapture=''><option selected=''></option></select>",e.querySelectorAll("[msallowcapture^='']").length&&v.push("[*^$]="+M+"*(?:''|\"\")"),e.querySelectorAll("[selected]").length||v.push("\\["+M+"*(?:value|"+R+")"),e.querySelectorAll("[id~="+k+"-]").length||v.push("~="),e.querySelectorAll(":checked").length||v.push(":checked"),e.querySelectorAll("a#"+k+"+*").length||v.push(".#.+[+~]")}),ce(function(e){e.innerHTML="<a href='' disabled='disabled'></a><select disabled='disabled'><option/></select>";var t=C.createElement("input");t.setAttribute("type","hidden"),e.appendChild(t).setAttribute("name","D"),e.querySelectorAll("[name=d]").length&&v.push("name"+M+"*[*^$|!~]?="),2!==e.querySelectorAll(":enabled").length&&v.push(":enabled",":disabled"),a.appendChild(e).disabled=!0,2!==e.querySelectorAll(":disabled").length&&v.push(":enabled",":disabled"),e.querySelectorAll("*,:x"),v.push(",.*:")})),(d.matchesSelector=K.test(c=a.matches||a.webkitMatchesSelector||a.mozMatchesSelector||a.oMatchesSelector||a.msMatchesSelector))&&ce(function(e){d.disconnectedMatch=c.call(e,"*"),c.call(e,"[s!='']:x"),s.push("!=",$)}),v=v.length&&new RegExp(v.join("|")),s=s.length&&new RegExp(s.join("|")),t=K.test(a.compareDocumentPosition),y=t||K.test(a.contains)?function(e,t){var n=9===e.nodeType?e.documentElement:e,r=t&&t.parentNode;return e===r||!(!r||1!==r.nodeType||!(n.contains?n.contains(r):e.compareDocumentPosition&&16&e.compareDocumentPosition(r)))}:function(e,t){if(t)while(t=t.parentNode)if(t===e)return!0;return!1},D=t?function(e,t){if(e===t)return l=!0,0;var n=!e.compareDocumentPosition-!t.compareDocumentPosition;return n||(1&(n=(e.ownerDocument||e)===(t.ownerDocument||t)?e.compareDocumentPosition(t):1)||!d.sortDetached&&t.compareDocumentPosition(e)===n?e===C||e.ownerDocument===m&&y(m,e)?-1:t===C||t.ownerDocument===m&&y(m,t)?1:u?P(u,e)-P(u,t):0:4&n?-1:1)}:function(e,t){if(e===t)return l=!0,0;var n,r=0,i=e.parentNode,o=t.parentNode,a=[e],s=[t];if(!i||!o)return e===C?-1:t===C?1:i?-1:o?1:u?P(u,e)-P(u,t):0;if(i===o)return pe(e,t);n=e;while(n=n.parentNode)a.unshift(n);n=t;while(n=n.parentNode)s.unshift(n);while(a[r]===s[r])r++;return r?pe(a[r],s[r]):a[r]===m?-1:s[r]===m?1:0}),C},se.matches=function(e,t){return se(e,null,null,t)},se.matchesSelector=function(e,t){if((e.ownerDocument||e)!==C&&T(e),d.matchesSelector&&E&&!A[t+" "]&&(!s||!s.test(t))&&(!v||!v.test(t)))try{var n=c.call(e,t);if(n||d.disconnectedMatch||e.document&&11!==e.document.nodeType)return n}catch(e){A(t,!0)}return 0<se(t,C,null,[e]).length},se.contains=function(e,t){return(e.ownerDocument||e)!==C&&T(e),y(e,t)},se.attr=function(e,t){(e.ownerDocument||e)!==C&&T(e);var n=b.attrHandle[t.toLowerCase()],r=n&&j.call(b.attrHandle,t.toLowerCase())?n(e,t,!E):void 0;return void 0!==r?r:d.attributes||!E?e.getAttribute(t):(r=e.getAttributeNode(t))&&r.specified?r.value:null},se.escape=function(e){return(e+"").replace(re,ie)},se.error=function(e){throw new Error("Syntax error, unrecognized expression: "+e)},se.uniqueSort=function(e){var t,n=[],r=0,i=0;if(l=!d.detectDuplicates,u=!d.sortStable&&e.slice(0),e.sort(D),l){while(t=e[i++])t===e[i]&&(r=n.push(i));while(r--)e.splice(n[r],1)}return u=null,e},o=se.getText=function(e){var t,n="",r=0,i=e.nodeType;if(i){if(1===i||9===i||11===i){if("string"==typeof e.textContent)return e.textContent;for(e=e.firstChild;e;e=e.nextSibling)n+=o(e)}else if(3===i||4===i)return e.nodeValue}else while(t=e[r++])n+=o(t);return n},(b=se.selectors={cacheLength:50,createPseudo:le,match:G,attrHandle:{},find:{},relative:{">":{dir:"parentNode",first:!0}," ":{dir:"parentNode"},"+":{dir:"previousSibling",first:!0},"~":{dir:"previousSibling"}},preFilter:{ATTR:function(e){return e[1]=e[1].replace(te,ne),e[3]=(e[3]||e[4]||e[5]||"").replace(te,ne),"~="===e[2]&&(e[3]=" "+e[3]+" "),e.slice(0,4)},CHILD:function(e){return e[1]=e[1].toLowerCase(),"nth"===e[1].slice(0,3)?(e[3]||se.error(e[0]),e[4]=+(e[4]?e[5]+(e[6]||1):2*("even"===e[3]||"odd"===e[3])),e[5]=+(e[7]+e[8]||"odd"===e[3])):e[3]&&se.error(e[0]),e},PSEUDO:function(e){var t,n=!e[6]&&e[2];return G.CHILD.test(e[0])?null:(e[3]?e[2]=e[4]||e[5]||"":n&&X.test(n)&&(t=h(n,!0))&&(t=n.indexOf(")",n.length-t)-n.length)&&(e[0]=e[0].slice(0,t),e[2]=n.slice(0,t)),e.slice(0,3))}},filter:{TAG:function(e){var t=e.replace(te,ne).toLowerCase();return"*"===e?function(){return!0}:function(e){return e.nodeName&&e.nodeName.toLowerCase()===t}},CLASS:function(e){var t=p[e+" "];return t||(t=new RegExp("(^|"+M+")"+e+"("+M+"|$)"))&&p(e,function(e){return t.test("string"==typeof e.className&&e.className||"undefined"!=typeof e.getAttribute&&e.getAttribute("class")||"")})},ATTR:function(n,r,i){return function(e){var t=se.attr(e,n);return null==t?"!="===r:!r||(t+="","="===r?t===i:"!="===r?t!==i:"^="===r?i&&0===t.indexOf(i):"*="===r?i&&-1<t.indexOf(i):"$="===r?i&&t.slice(-i.length)===i:"~="===r?-1<(" "+t.replace(F," ")+" ").indexOf(i):"|="===r&&(t===i||t.slice(0,i.length+1)===i+"-"))}},CHILD:function(h,e,t,g,v){var y="nth"!==h.slice(0,3),m="last"!==h.slice(-4),x="of-type"===e;return 1===g&&0===v?function(e){return!!e.parentNode}:function(e,t,n){var r,i,o,a,s,u,l=y!==m?"nextSibling":"previousSibling",c=e.parentNode,f=x&&e.nodeName.toLowerCase(),p=!n&&!x,d=!1;if(c){if(y){while(l){a=e;while(a=a[l])if(x?a.nodeName.toLowerCase()===f:1===a.nodeType)return!1;u=l="only"===h&&!u&&"nextSibling"}return!0}if(u=[m?c.firstChild:c.lastChild],m&&p){d=(s=(r=(i=(o=(a=c)[k]||(a[k]={}))[a.uniqueID]||(o[a.uniqueID]={}))[h]||[])[0]===S&&r[1])&&r[2],a=s&&c.childNodes[s];while(a=++s&&a&&a[l]||(d=s=0)||u.pop())if(1===a.nodeType&&++d&&a===e){i[h]=[S,s,d];break}}else if(p&&(d=s=(r=(i=(o=(a=e)[k]||(a[k]={}))[a.uniqueID]||(o[a.uniqueID]={}))[h]||[])[0]===S&&r[1]),!1===d)while(a=++s&&a&&a[l]||(d=s=0)||u.pop())if((x?a.nodeName.toLowerCase()===f:1===a.nodeType)&&++d&&(p&&((i=(o=a[k]||(a[k]={}))[a.uniqueID]||(o[a.uniqueID]={}))[h]=[S,d]),a===e))break;return(d-=v)===g||d%g==0&&0<=d/g}}},PSEUDO:function(e,o){var t,a=b.pseudos[e]||b.setFilters[e.toLowerCase()]||se.error("unsupported pseudo: "+e);return a[k]?a(o):1<a.length?(t=[e,e,"",o],b.setFilters.hasOwnProperty(e.toLowerCase())?le(function(e,t){var n,r=a(e,o),i=r.length;while(i--)e[n=P(e,r[i])]=!(t[n]=r[i])}):function(e){return a(e,0,t)}):a}},pseudos:{not:le(function(e){var r=[],i=[],s=f(e.replace(B,"$1"));return s[k]?le(function(e,t,n,r){var i,o=s(e,null,r,[]),a=e.length;while(a--)(i=o[a])&&(e[a]=!(t[a]=i))}):function(e,t,n){return r[0]=e,s(r,null,n,i),r[0]=null,!i.pop()}}),has:le(function(t){return function(e){return 0<se(t,e).length}}),contains:le(function(t){return t=t.replace(te,ne),function(e){return-1<(e.textContent||o(e)).indexOf(t)}}),lang:le(function(n){return V.test(n||"")||se.error("unsupported lang: "+n),n=n.replace(te,ne).toLowerCase(),function(e){var t;do{if(t=E?e.lang:e.getAttribute("xml:lang")||e.getAttribute("lang"))return(t=t.toLowerCase())===n||0===t.indexOf(n+"-")}while((e=e.parentNode)&&1===e.nodeType);return!1}}),target:function(e){var t=n.location&&n.location.hash;return t&&t.slice(1)===e.id},root:function(e){return e===a},focus:function(e){return e===C.activeElement&&(!C.hasFocus||C.hasFocus())&&!!(e.type||e.href||~e.tabIndex)},enabled:ge(!1),disabled:ge(!0),checked:function(e){var t=e.nodeName.toLowerCase();return"input"===t&&!!e.checked||"option"===t&&!!e.selected},selected:function(e){return e.parentNode&&e.parentNode.selectedIndex,!0===e.selected},empty:function(e){for(e=e.firstChild;e;e=e.nextSibling)if(e.nodeType<6)return!1;return!0},parent:function(e){return!b.pseudos.empty(e)},header:function(e){return J.test(e.nodeName)},input:function(e){return Q.test(e.nodeName)},button:function(e){var t=e.nodeName.toLowerCase();return"input"===t&&"button"===e.type||"button"===t},text:function(e){var t;return"input"===e.nodeName.toLowerCase()&&"text"===e.type&&(null==(t=e.getAttribute("type"))||"text"===t.toLowerCase())},first:ve(function(){return[0]}),last:ve(function(e,t){return[t-1]}),eq:ve(function(e,t,n){return[n<0?n+t:n]}),even:ve(function(e,t){for(var n=0;n<t;n+=2)e.push(n);return e}),odd:ve(function(e,t){for(var n=1;n<t;n+=2)e.push(n);return e}),lt:ve(function(e,t,n){for(var r=n<0?n+t:t<n?t:n;0<=--r;)e.push(r);return e}),gt:ve(function(e,t,n){for(var r=n<0?n+t:n;++r<t;)e.push(r);return e})}}).pseudos.nth=b.pseudos.eq,{radio:!0,checkbox:!0,file:!0,password:!0,image:!0})b.pseudos[e]=de(e);for(e in{submit:!0,reset:!0})b.pseudos[e]=he(e);function me(){}function xe(e){for(var t=0,n=e.length,r="";t<n;t++)r+=e[t].value;return r}function be(s,e,t){var u=e.dir,l=e.next,c=l||u,f=t&&"parentNode"===c,p=r++;return e.first?function(e,t,n){while(e=e[u])if(1===e.nodeType||f)return s(e,t,n);return!1}:function(e,t,n){var r,i,o,a=[S,p];if(n){while(e=e[u])if((1===e.nodeType||f)&&s(e,t,n))return!0}else while(e=e[u])if(1===e.nodeType||f)if(i=(o=e[k]||(e[k]={}))[e.uniqueID]||(o[e.uniqueID]={}),l&&l===e.nodeName.toLowerCase())e=e[u]||e;else{if((r=i[c])&&r[0]===S&&r[1]===p)return a[2]=r[2];if((i[c]=a)[2]=s(e,t,n))return!0}return!1}}function we(i){return 1<i.length?function(e,t,n){var r=i.length;while(r--)if(!i[r](e,t,n))return!1;return!0}:i[0]}function Te(e,t,n,r,i){for(var o,a=[],s=0,u=e.length,l=null!=t;s<u;s++)(o=e[s])&&(n&&!n(o,r,i)||(a.push(o),l&&t.push(s)));return a}function Ce(d,h,g,v,y,e){return v&&!v[k]&&(v=Ce(v)),y&&!y[k]&&(y=Ce(y,e)),le(function(e,t,n,r){var i,o,a,s=[],u=[],l=t.length,c=e||function(e,t,n){for(var r=0,i=t.length;r<i;r++)se(e,t[r],n);return n}(h||"*",n.nodeType?[n]:n,[]),f=!d||!e&&h?c:Te(c,s,d,n,r),p=g?y||(e?d:l||v)?[]:t:f;if(g&&g(f,p,n,r),v){i=Te(p,u),v(i,[],n,r),o=i.length;while(o--)(a=i[o])&&(p[u[o]]=!(f[u[o]]=a))}if(e){if(y||d){if(y){i=[],o=p.length;while(o--)(a=p[o])&&i.push(f[o]=a);y(null,p=[],i,r)}o=p.length;while(o--)(a=p[o])&&-1<(i=y?P(e,a):s[o])&&(e[i]=!(t[i]=a))}}else p=Te(p===t?p.splice(l,p.length):p),y?y(null,t,p,r):H.apply(t,p)})}function Ee(e){for(var i,t,n,r=e.length,o=b.relative[e[0].type],a=o||b.relative[" "],s=o?1:0,u=be(function(e){return e===i},a,!0),l=be(function(e){return-1<P(i,e)},a,!0),c=[function(e,t,n){var r=!o&&(n||t!==w)||((i=t).nodeType?u(e,t,n):l(e,t,n));return i=null,r}];s<r;s++)if(t=b.relative[e[s].type])c=[be(we(c),t)];else{if((t=b.filter[e[s].type].apply(null,e[s].matches))[k]){for(n=++s;n<r;n++)if(b.relative[e[n].type])break;return Ce(1<s&&we(c),1<s&&xe(e.slice(0,s-1).concat({value:" "===e[s-2].type?"*":""})).replace(B,"$1"),t,s<n&&Ee(e.slice(s,n)),n<r&&Ee(e=e.slice(n)),n<r&&xe(e))}c.push(t)}return we(c)}return me.prototype=b.filters=b.pseudos,b.setFilters=new me,h=se.tokenize=function(e,t){var n,r,i,o,a,s,u,l=x[e+" "];if(l)return t?0:l.slice(0);a=e,s=[],u=b.preFilter;while(a){for(o in n&&!(r=_.exec(a))||(r&&(a=a.slice(r[0].length)||a),s.push(i=[])),n=!1,(r=z.exec(a))&&(n=r.shift(),i.push({value:n,type:r[0].replace(B," ")}),a=a.slice(n.length)),b.filter)!(r=G[o].exec(a))||u[o]&&!(r=u[o](r))||(n=r.shift(),i.push({value:n,type:o,matches:r}),a=a.slice(n.length));if(!n)break}return t?a.length:a?se.error(e):x(e,s).slice(0)},f=se.compile=function(e,t){var n,v,y,m,x,r,i=[],o=[],a=N[e+" "];if(!a){t||(t=h(e)),n=t.length;while(n--)(a=Ee(t[n]))[k]?i.push(a):o.push(a);(a=N(e,(v=o,m=0<(y=i).length,x=0<v.length,r=function(e,t,n,r,i){var o,a,s,u=0,l="0",c=e&&[],f=[],p=w,d=e||x&&b.find.TAG("*",i),h=S+=null==p?1:Math.random()||.1,g=d.length;for(i&&(w=t===C||t||i);l!==g&&null!=(o=d[l]);l++){if(x&&o){a=0,t||o.ownerDocument===C||(T(o),n=!E);while(s=v[a++])if(s(o,t||C,n)){r.push(o);break}i&&(S=h)}m&&((o=!s&&o)&&u--,e&&c.push(o))}if(u+=l,m&&l!==u){a=0;while(s=y[a++])s(c,f,t,n);if(e){if(0<u)while(l--)c[l]||f[l]||(f[l]=q.call(r));f=Te(f)}H.apply(r,f),i&&!e&&0<f.length&&1<u+y.length&&se.uniqueSort(r)}return i&&(S=h,w=p),c},m?le(r):r))).selector=e}return a},g=se.select=function(e,t,n,r){var i,o,a,s,u,l="function"==typeof e&&e,c=!r&&h(e=l.selector||e);if(n=n||[],1===c.length){if(2<(o=c[0]=c[0].slice(0)).length&&"ID"===(a=o[0]).type&&9===t.nodeType&&E&&b.relative[o[1].type]){if(!(t=(b.find.ID(a.matches[0].replace(te,ne),t)||[])[0]))return n;l&&(t=t.parentNode),e=e.slice(o.shift().value.length)}i=G.needsContext.test(e)?0:o.length;while(i--){if(a=o[i],b.relative[s=a.type])break;if((u=b.find[s])&&(r=u(a.matches[0].replace(te,ne),ee.test(o[0].type)&&ye(t.parentNode)||t))){if(o.splice(i,1),!(e=r.length&&xe(o)))return H.apply(n,r),n;break}}}return(l||f(e,c))(r,t,!E,n,!t||ee.test(e)&&ye(t.parentNode)||t),n},d.sortStable=k.split("").sort(D).join("")===k,d.detectDuplicates=!!l,T(),d.sortDetached=ce(function(e){return 1&e.compareDocumentPosition(C.createElement("fieldset"))}),ce(function(e){return e.innerHTML="<a href='#'></a>","#"===e.firstChild.getAttribute("href")})||fe("type|href|height|width",function(e,t,n){if(!n)return e.getAttribute(t,"type"===t.toLowerCase()?1:2)}),d.attributes&&ce(function(e){return e.innerHTML="<input/>",e.firstChild.setAttribute("value",""),""===e.firstChild.getAttribute("value")})||fe("value",function(e,t,n){if(!n&&"input"===e.nodeName.toLowerCase())return e.defaultValue}),ce(function(e){return null==e.getAttribute("disabled")})||fe(R,function(e,t,n){var r;if(!n)return!0===e[t]?t.toLowerCase():(r=e.getAttributeNode(t))&&r.specified?r.value:null}),se}(C);k.find=h,k.expr=h.selectors,k.expr[":"]=k.expr.pseudos,k.uniqueSort=k.unique=h.uniqueSort,k.text=h.getText,k.isXMLDoc=h.isXML,k.contains=h.contains,k.escapeSelector=h.escape;var T=function(e,t,n){var r=[],i=void 0!==n;while((e=e[t])&&9!==e.nodeType)if(1===e.nodeType){if(i&&k(e).is(n))break;r.push(e)}return r},S=function(e,t){for(var n=[];e;e=e.nextSibling)1===e.nodeType&&e!==t&&n.push(e);return n},N=k.expr.match.needsContext;function A(e,t){return e.nodeName&&e.nodeName.toLowerCase()===t.toLowerCase()}var D=/^<([a-z][^\/\0>:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i;function j(e,n,r){return m(n)?k.grep(e,function(e,t){return!!n.call(e,t,e)!==r}):n.nodeType?k.grep(e,function(e){return e===n!==r}):"string"!=typeof n?k.grep(e,function(e){return-1<i.call(n,e)!==r}):k.filter(n,e,r)}k.filter=function(e,t,n){var r=t[0];return n&&(e=":not("+e+")"),1===t.length&&1===r.nodeType?k.find.matchesSelector(r,e)?[r]:[]:k.find.matches(e,k.grep(t,function(e){return 1===e.nodeType}))},k.fn.extend({find:function(e){var t,n,r=this.length,i=this;if("string"!=typeof e)return this.pushStack(k(e).filter(function(){for(t=0;t<r;t++)if(k.contains(i[t],this))return!0}));for(n=this.pushStack([]),t=0;t<r;t++)k.find(e,i[t],n);return 1<r?k.uniqueSort(n):n},filter:function(e){return this.pushStack(j(this,e||[],!1))},not:function(e){return this.pushStack(j(this,e||[],!0))},is:function(e){return!!j(this,"string"==typeof e&&N.test(e)?k(e):e||[],!1).length}});var q,L=/^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]+))$/;(k.fn.init=function(e,t,n){var r,i;if(!e)return this;if(n=n||q,"string"==typeof e){if(!(r="<"===e[0]&&">"===e[e.length-1]&&3<=e.length?[null,e,null]:L.exec(e))||!r[1]&&t)return!t||t.jquery?(t||n).find(e):this.constructor(t).find(e);if(r[1]){if(t=t instanceof k?t[0]:t,k.merge(this,k.parseHTML(r[1],t&&t.nodeType?t.ownerDocument||t:E,!0)),D.test(r[1])&&k.isPlainObject(t))for(r in t)m(this[r])?this[r](t[r]):this.attr(r,t[r]);return this}return(i=E.getElementById(r[2]))&&(this[0]=i,this.length=1),this}return e.nodeType?(this[0]=e,this.length=1,this):m(e)?void 0!==n.ready?n.ready(e):e(k):k.makeArray(e,this)}).prototype=k.fn,q=k(E);var H=/^(?:parents|prev(?:Until|All))/,O={children:!0,contents:!0,next:!0,prev:!0};function P(e,t){while((e=e[t])&&1!==e.nodeType);return e}k.fn.extend({has:function(e){var t=k(e,this),n=t.length;return this.filter(function(){for(var e=0;e<n;e++)if(k.contains(this,t[e]))return!0})},closest:function(e,t){var n,r=0,i=this.length,o=[],a="string"!=typeof e&&k(e);if(!N.test(e))for(;r<i;r++)for(n=this[r];n&&n!==t;n=n.parentNode)if(n.nodeType<11&&(a?-1<a.index(n):1===n.nodeType&&k.find.matchesSelector(n,e))){o.push(n);break}return this.pushStack(1<o.length?k.uniqueSort(o):o)},index:function(e){return e?"string"==typeof e?i.call(k(e),this[0]):i.call(this,e.jquery?e[0]:e):this[0]&&this[0].parentNode?this.first().prevAll().length:-1},add:function(e,t){return this.pushStack(k.uniqueSort(k.merge(this.get(),k(e,t))))},addBack:function(e){return this.add(null==e?this.prevObject:this.prevObject.filter(e))}}),k.each({parent:function(e){var t=e.parentNode;return t&&11!==t.nodeType?t:null},parents:function(e){return T(e,"parentNode")},parentsUntil:function(e,t,n){return T(e,"parentNode",n)},next:function(e){return P(e,"nextSibling")},prev:function(e){return P(e,"previousSibling")},nextAll:function(e){return T(e,"nextSibling")},prevAll:function(e){return T(e,"previousSibling")},nextUntil:function(e,t,n){return T(e,"nextSibling",n)},prevUntil:function(e,t,n){return T(e,"previousSibling",n)},siblings:function(e){return S((e.parentNode||{}).firstChild,e)},children:function(e){return S(e.firstChild)},contents:function(e){return"undefined"!=typeof e.contentDocument?e.contentDocument:(A(e,"template")&&(e=e.content||e),k.merge([],e.childNodes))}},function(r,i){k.fn[r]=function(e,t){var n=k.map(this,i,e);return"Until"!==r.slice(-5)&&(t=e),t&&"string"==typeof t&&(n=k.filter(t,n)),1<this.length&&(O[r]||k.uniqueSort(n),H.test(r)&&n.reverse()),this.pushStack(n)}});var R=/[^\x20\t\r\n\f]+/g;function M(e){return e}function I(e){throw e}function W(e,t,n,r){var i;try{e&&m(i=e.promise)?i.call(e).done(t).fail(n):e&&m(i=e.then)?i.call(e,t,n):t.apply(void 0,[e].slice(r))}catch(e){n.apply(void 0,[e])}}k.Callbacks=function(r){var e,n;r="string"==typeof r?(e=r,n={},k.each(e.match(R)||[],function(e,t){n[t]=!0}),n):k.extend({},r);var i,t,o,a,s=[],u=[],l=-1,c=function(){for(a=a||r.once,o=i=!0;u.length;l=-1){t=u.shift();while(++l<s.length)!1===s[l].apply(t[0],t[1])&&r.stopOnFalse&&(l=s.length,t=!1)}r.memory||(t=!1),i=!1,a&&(s=t?[]:"")},f={add:function(){return s&&(t&&!i&&(l=s.length-1,u.push(t)),function n(e){k.each(e,function(e,t){m(t)?r.unique&&f.has(t)||s.push(t):t&&t.length&&"string"!==w(t)&&n(t)})}(arguments),t&&!i&&c()),this},remove:function(){return k.each(arguments,function(e,t){var n;while(-1<(n=k.inArray(t,s,n)))s.splice(n,1),n<=l&&l--}),this},has:function(e){return e?-1<k.inArray(e,s):0<s.length},empty:function(){return s&&(s=[]),this},disable:function(){return a=u=[],s=t="",this},disabled:function(){return!s},lock:function(){return a=u=[],t||i||(s=t=""),this},locked:function(){return!!a},fireWith:function(e,t){return a||(t=[e,(t=t||[]).slice?t.slice():t],u.push(t),i||c()),this},fire:function(){return f.fireWith(this,arguments),this},fired:function(){return!!o}};return f},k.extend({Deferred:function(e){var o=[["notify","progress",k.Callbacks("memory"),k.Callbacks("memory"),2],["resolve","done",k.Callbacks("once memory"),k.Callbacks("once memory"),0,"resolved"],["reject","fail",k.Callbacks("once memory"),k.Callbacks("once memory"),1,"rejected"]],i="pending",a={state:function(){return i},always:function(){return s.done(arguments).fail(arguments),this},"catch":function(e){return a.then(null,e)},pipe:function(){var i=arguments;return k.Deferred(function(r){k.each(o,function(e,t){var n=m(i[t[4]])&&i[t[4]];s[t[1]](function(){var e=n&&n.apply(this,arguments);e&&m(e.promise)?e.promise().progress(r.notify).done(r.resolve).fail(r.reject):r[t[0]+"With"](this,n?[e]:arguments)})}),i=null}).promise()},then:function(t,n,r){var u=0;function l(i,o,a,s){return function(){var n=this,r=arguments,e=function(){var e,t;if(!(i<u)){if((e=a.apply(n,r))===o.promise())throw new TypeError("Thenable self-resolution");t=e&&("object"==typeof e||"function"==typeof e)&&e.then,m(t)?s?t.call(e,l(u,o,M,s),l(u,o,I,s)):(u++,t.call(e,l(u,o,M,s),l(u,o,I,s),l(u,o,M,o.notifyWith))):(a!==M&&(n=void 0,r=[e]),(s||o.resolveWith)(n,r))}},t=s?e:function(){try{e()}catch(e){k.Deferred.exceptionHook&&k.Deferred.exceptionHook(e,t.stackTrace),u<=i+1&&(a!==I&&(n=void 0,r=[e]),o.rejectWith(n,r))}};i?t():(k.Deferred.getStackHook&&(t.stackTrace=k.Deferred.getStackHook()),C.setTimeout(t))}}return k.Deferred(function(e){o[0][3].add(l(0,e,m(r)?r:M,e.notifyWith)),o[1][3].add(l(0,e,m(t)?t:M)),o[2][3].add(l(0,e,m(n)?n:I))}).promise()},promise:function(e){return null!=e?k.extend(e,a):a}},s={};return k.each(o,function(e,t){var n=t[2],r=t[5];a[t[1]]=n.add,r&&n.add(function(){i=r},o[3-e][2].disable,o[3-e][3].disable,o[0][2].lock,o[0][3].lock),n.add(t[3].fire),s[t[0]]=function(){return s[t[0]+"With"](this===s?void 0:this,arguments),this},s[t[0]+"With"]=n.fireWith}),a.promise(s),e&&e.call(s,s),s},when:function(e){var n=arguments.length,t=n,r=Array(t),i=s.call(arguments),o=k.Deferred(),a=function(t){return function(e){r[t]=this,i[t]=1<arguments.length?s.call(arguments):e,--n||o.resolveWith(r,i)}};if(n<=1&&(W(e,o.done(a(t)).resolve,o.reject,!n),"pending"===o.state()||m(i[t]&&i[t].then)))return o.then();while(t--)W(i[t],a(t),o.reject);return o.promise()}});var $=/^(Eval|Internal|Range|Reference|Syntax|Type|URI)Error$/;k.Deferred.exceptionHook=function(e,t){C.console&&C.console.warn&&e&&$.test(e.name)&&C.console.warn("jQuery.Deferred exception: "+e.message,e.stack,t)},k.readyException=function(e){C.setTimeout(function(){throw e})};var F=k.Deferred();function B(){E.removeEventListener("DOMContentLoaded",B),C.removeEventListener("load",B),k.ready()}k.fn.ready=function(e){return F.then(e)["catch"](function(e){k.readyException(e)}),this},k.extend({isReady:!1,readyWait:1,ready:function(e){(!0===e?--k.readyWait:k.isReady)||(k.isReady=!0)!==e&&0<--k.readyWait||F.resolveWith(E,[k])}}),k.ready.then=F.then,"complete"===E.readyState||"loading"!==E.readyState&&!E.documentElement.doScroll?C.setTimeout(k.ready):(E.addEventListener("DOMContentLoaded",B),C.addEventListener("load",B));var _=function(e,t,n,r,i,o,a){var s=0,u=e.length,l=null==n;if("object"===w(n))for(s in i=!0,n)_(e,t,s,n[s],!0,o,a);else if(void 0!==r&&(i=!0,m(r)||(a=!0),l&&(a?(t.call(e,r),t=null):(l=t,t=function(e,t,n){return l.call(k(e),n)})),t))for(;s<u;s++)t(e[s],n,a?r:r.call(e[s],s,t(e[s],n)));return i?e:l?t.call(e):u?t(e[0],n):o},z=/^-ms-/,U=/-([a-z])/g;function X(e,t){return t.toUpperCase()}function V(e){return e.replace(z,"ms-").replace(U,X)}var G=function(e){return 1===e.nodeType||9===e.nodeType||!+e.nodeType};function Y(){this.expando=k.expando+Y.uid++}Y.uid=1,Y.prototype={cache:function(e){var t=e[this.expando];return t||(t={},G(e)&&(e.nodeType?e[this.expando]=t:Object.defineProperty(e,this.expando,{value:t,configurable:!0}))),t},set:function(e,t,n){var r,i=this.cache(e);if("string"==typeof t)i[V(t)]=n;else for(r in t)i[V(r)]=t[r];return i},get:function(e,t){return void 0===t?this.cache(e):e[this.expando]&&e[this.expando][V(t)]},access:function(e,t,n){return void 0===t||t&&"string"==typeof t&&void 0===n?this.get(e,t):(this.set(e,t,n),void 0!==n?n:t)},remove:function(e,t){var n,r=e[this.expando];if(void 0!==r){if(void 0!==t){n=(t=Array.isArray(t)?t.map(V):(t=V(t))in r?[t]:t.match(R)||[]).length;while(n--)delete r[t[n]]}(void 0===t||k.isEmptyObject(r))&&(e.nodeType?e[this.expando]=void 0:delete e[this.expando])}},hasData:function(e){var t=e[this.expando];return void 0!==t&&!k.isEmptyObject(t)}};var Q=new Y,J=new Y,K=/^(?:\{[\w\W]*\}|\[[\w\W]*\])$/,Z=/[A-Z]/g;function ee(e,t,n){var r,i;if(void 0===n&&1===e.nodeType)if(r="data-"+t.replace(Z,"-$&").toLowerCase(),"string"==typeof(n=e.getAttribute(r))){try{n="true"===(i=n)||"false"!==i&&("null"===i?null:i===+i+""?+i:K.test(i)?JSON.parse(i):i)}catch(e){}J.set(e,t,n)}else n=void 0;return n}k.extend({hasData:function(e){return J.hasData(e)||Q.hasData(e)},data:function(e,t,n){return J.access(e,t,n)},removeData:function(e,t){J.remove(e,t)},_data:function(e,t,n){return Q.access(e,t,n)},_removeData:function(e,t){Q.remove(e,t)}}),k.fn.extend({data:function(n,e){var t,r,i,o=this[0],a=o&&o.attributes;if(void 0===n){if(this.length&&(i=J.get(o),1===o.nodeType&&!Q.get(o,"hasDataAttrs"))){t=a.length;while(t--)a[t]&&0===(r=a[t].name).indexOf("data-")&&(r=V(r.slice(5)),ee(o,r,i[r]));Q.set(o,"hasDataAttrs",!0)}return i}return"object"==typeof n?this.each(function(){J.set(this,n)}):_(this,function(e){var t;if(o&&void 0===e)return void 0!==(t=J.get(o,n))?t:void 0!==(t=ee(o,n))?t:void 0;this.each(function(){J.set(this,n,e)})},null,e,1<arguments.length,null,!0)},removeData:function(e){return this.each(function(){J.remove(this,e)})}}),k.extend({queue:function(e,t,n){var r;if(e)return t=(t||"fx")+"queue",r=Q.get(e,t),n&&(!r||Array.isArray(n)?r=Q.access(e,t,k.makeArray(n)):r.push(n)),r||[]},dequeue:function(e,t){t=t||"fx";var n=k.queue(e,t),r=n.length,i=n.shift(),o=k._queueHooks(e,t);"inprogress"===i&&(i=n.shift(),r--),i&&("fx"===t&&n.unshift("inprogress"),delete o.stop,i.call(e,function(){k.dequeue(e,t)},o)),!r&&o&&o.empty.fire()},_queueHooks:function(e,t){var n=t+"queueHooks";return Q.get(e,n)||Q.access(e,n,{empty:k.Callbacks("once memory").add(function(){Q.remove(e,[t+"queue",n])})})}}),k.fn.extend({queue:function(t,n){var e=2;return"string"!=typeof t&&(n=t,t="fx",e--),arguments.length<e?k.queue(this[0],t):void 0===n?this:this.each(function(){var e=k.queue(this,t,n);k._queueHooks(this,t),"fx"===t&&"inprogress"!==e[0]&&k.dequeue(this,t)})},dequeue:function(e){return this.each(function(){k.dequeue(this,e)})},clearQueue:function(e){return this.queue(e||"fx",[])},promise:function(e,t){var n,r=1,i=k.Deferred(),o=this,a=this.length,s=function(){--r||i.resolveWith(o,[o])};"string"!=typeof e&&(t=e,e=void 0),e=e||"fx";while(a--)(n=Q.get(o[a],e+"queueHooks"))&&n.empty&&(r++,n.empty.add(s));return s(),i.promise(t)}});var te=/[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/.source,ne=new RegExp("^(?:([+-])=|)("+te+")([a-z%]*)$","i"),re=["Top","Right","Bottom","Left"],ie=E.documentElement,oe=function(e){return k.contains(e.ownerDocument,e)},ae={composed:!0};ie.getRootNode&&(oe=function(e){return k.contains(e.ownerDocument,e)||e.getRootNode(ae)===e.ownerDocument});var se=function(e,t){return"none"===(e=t||e).style.display||""===e.style.display&&oe(e)&&"none"===k.css(e,"display")},ue=function(e,t,n,r){var i,o,a={};for(o in t)a[o]=e.style[o],e.style[o]=t[o];for(o in i=n.apply(e,r||[]),t)e.style[o]=a[o];return i};function le(e,t,n,r){var i,o,a=20,s=r?function(){return r.cur()}:function(){return k.css(e,t,"")},u=s(),l=n&&n[3]||(k.cssNumber[t]?"":"px"),c=e.nodeType&&(k.cssNumber[t]||"px"!==l&&+u)&&ne.exec(k.css(e,t));if(c&&c[3]!==l){u/=2,l=l||c[3],c=+u||1;while(a--)k.style(e,t,c+l),(1-o)*(1-(o=s()/u||.5))<=0&&(a=0),c/=o;c*=2,k.style(e,t,c+l),n=n||[]}return n&&(c=+c||+u||0,i=n[1]?c+(n[1]+1)*n[2]:+n[2],r&&(r.unit=l,r.start=c,r.end=i)),i}var ce={};function fe(e,t){for(var n,r,i,o,a,s,u,l=[],c=0,f=e.length;c<f;c++)(r=e[c]).style&&(n=r.style.display,t?("none"===n&&(l[c]=Q.get(r,"display")||null,l[c]||(r.style.display="")),""===r.style.display&&se(r)&&(l[c]=(u=a=o=void 0,a=(i=r).ownerDocument,s=i.nodeName,(u=ce[s])||(o=a.body.appendChild(a.createElement(s)),u=k.css(o,"display"),o.parentNode.removeChild(o),"none"===u&&(u="block"),ce[s]=u)))):"none"!==n&&(l[c]="none",Q.set(r,"display",n)));for(c=0;c<f;c++)null!=l[c]&&(e[c].style.display=l[c]);return e}k.fn.extend({show:function(){return fe(this,!0)},hide:function(){return fe(this)},toggle:function(e){return"boolean"==typeof e?e?this.show():this.hide():this.each(function(){se(this)?k(this).show():k(this).hide()})}});var pe=/^(?:checkbox|radio)$/i,de=/<([a-z][^\/\0>\x20\t\r\n\f]*)/i,he=/^$|^module$|\/(?:java|ecma)script/i,ge={option:[1,"<select multiple='multiple'>","</select>"],thead:[1,"<table>","</table>"],col:[2,"<table><colgroup>","</colgroup></table>"],tr:[2,"<table><tbody>","</tbody></table>"],td:[3,"<table><tbody><tr>","</tr></tbody></table>"],_default:[0,"",""]};function ve(e,t){var n;return n="undefined"!=typeof e.getElementsByTagName?e.getElementsByTagName(t||"*"):"undefined"!=typeof e.querySelectorAll?e.querySelectorAll(t||"*"):[],void 0===t||t&&A(e,t)?k.merge([e],n):n}function ye(e,t){for(var n=0,r=e.length;n<r;n++)Q.set(e[n],"globalEval",!t||Q.get(t[n],"globalEval"))}ge.optgroup=ge.option,ge.tbody=ge.tfoot=ge.colgroup=ge.caption=ge.thead,ge.th=ge.td;var me,xe,be=/<|&#?\w+;/;function we(e,t,n,r,i){for(var o,a,s,u,l,c,f=t.createDocumentFragment(),p=[],d=0,h=e.length;d<h;d++)if((o=e[d])||0===o)if("object"===w(o))k.merge(p,o.nodeType?[o]:o);else if(be.test(o)){a=a||f.appendChild(t.createElement("div")),s=(de.exec(o)||["",""])[1].toLowerCase(),u=ge[s]||ge._default,a.innerHTML=u[1]+k.htmlPrefilter(o)+u[2],c=u[0];while(c--)a=a.lastChild;k.merge(p,a.childNodes),(a=f.firstChild).textContent=""}else p.push(t.createTextNode(o));f.textContent="",d=0;while(o=p[d++])if(r&&-1<k.inArray(o,r))i&&i.push(o);else if(l=oe(o),a=ve(f.appendChild(o),"script"),l&&ye(a),n){c=0;while(o=a[c++])he.test(o.type||"")&&n.push(o)}return f}me=E.createDocumentFragment().appendChild(E.createElement("div")),(xe=E.createElement("input")).setAttribute("type","radio"),xe.setAttribute("checked","checked"),xe.setAttribute("name","t"),me.appendChild(xe),y.checkClone=me.cloneNode(!0).cloneNode(!0).lastChild.checked,me.innerHTML="<textarea>x</textarea>",y.noCloneChecked=!!me.cloneNode(!0).lastChild.defaultValue;var Te=/^key/,Ce=/^(?:mouse|pointer|contextmenu|drag|drop)|click/,Ee=/^([^.]*)(?:\.(.+)|)/;function ke(){return!0}function Se(){return!1}function Ne(e,t){return e===function(){try{return E.activeElement}catch(e){}}()==("focus"===t)}function Ae(e,t,n,r,i,o){var a,s;if("object"==typeof t){for(s in"string"!=typeof n&&(r=r||n,n=void 0),t)Ae(e,s,n,r,t[s],o);return e}if(null==r&&null==i?(i=n,r=n=void 0):null==i&&("string"==typeof n?(i=r,r=void 0):(i=r,r=n,n=void 0)),!1===i)i=Se;else if(!i)return e;return 1===o&&(a=i,(i=function(e){return k().off(e),a.apply(this,arguments)}).guid=a.guid||(a.guid=k.guid++)),e.each(function(){k.event.add(this,t,i,r,n)})}function De(e,i,o){o?(Q.set(e,i,!1),k.event.add(e,i,{namespace:!1,handler:function(e){var t,n,r=Q.get(this,i);if(1&e.isTrigger&&this[i]){if(r.length)(k.event.special[i]||{}).delegateType&&e.stopPropagation();else if(r=s.call(arguments),Q.set(this,i,r),t=o(this,i),this[i](),r!==(n=Q.get(this,i))||t?Q.set(this,i,!1):n={},r!==n)return e.stopImmediatePropagation(),e.preventDefault(),n.value}else r.length&&(Q.set(this,i,{value:k.event.trigger(k.extend(r[0],k.Event.prototype),r.slice(1),this)}),e.stopImmediatePropagation())}})):void 0===Q.get(e,i)&&k.event.add(e,i,ke)}k.event={global:{},add:function(t,e,n,r,i){var o,a,s,u,l,c,f,p,d,h,g,v=Q.get(t);if(v){n.handler&&(n=(o=n).handler,i=o.selector),i&&k.find.matchesSelector(ie,i),n.guid||(n.guid=k.guid++),(u=v.events)||(u=v.events={}),(a=v.handle)||(a=v.handle=function(e){return"undefined"!=typeof k&&k.event.triggered!==e.type?k.event.dispatch.apply(t,arguments):void 0}),l=(e=(e||"").match(R)||[""]).length;while(l--)d=g=(s=Ee.exec(e[l])||[])[1],h=(s[2]||"").split(".").sort(),d&&(f=k.event.special[d]||{},d=(i?f.delegateType:f.bindType)||d,f=k.event.special[d]||{},c=k.extend({type:d,origType:g,data:r,handler:n,guid:n.guid,selector:i,needsContext:i&&k.expr.match.needsContext.test(i),namespace:h.join(".")},o),(p=u[d])||((p=u[d]=[]).delegateCount=0,f.setup&&!1!==f.setup.call(t,r,h,a)||t.addEventListener&&t.addEventListener(d,a)),f.add&&(f.add.call(t,c),c.handler.guid||(c.handler.guid=n.guid)),i?p.splice(p.delegateCount++,0,c):p.push(c),k.event.global[d]=!0)}},remove:function(e,t,n,r,i){var o,a,s,u,l,c,f,p,d,h,g,v=Q.hasData(e)&&Q.get(e);if(v&&(u=v.events)){l=(t=(t||"").match(R)||[""]).length;while(l--)if(d=g=(s=Ee.exec(t[l])||[])[1],h=(s[2]||"").split(".").sort(),d){f=k.event.special[d]||{},p=u[d=(r?f.delegateType:f.bindType)||d]||[],s=s[2]&&new RegExp("(^|\\.)"+h.join("\\.(?:.*\\.|)")+"(\\.|$)"),a=o=p.length;while(o--)c=p[o],!i&&g!==c.origType||n&&n.guid!==c.guid||s&&!s.test(c.namespace)||r&&r!==c.selector&&("**"!==r||!c.selector)||(p.splice(o,1),c.selector&&p.delegateCount--,f.remove&&f.remove.call(e,c));a&&!p.length&&(f.teardown&&!1!==f.teardown.call(e,h,v.handle)||k.removeEvent(e,d,v.handle),delete u[d])}else for(d in u)k.event.remove(e,d+t[l],n,r,!0);k.isEmptyObject(u)&&Q.remove(e,"handle events")}},dispatch:function(e){var t,n,r,i,o,a,s=k.event.fix(e),u=new Array(arguments.length),l=(Q.get(this,"events")||{})[s.type]||[],c=k.event.special[s.type]||{};for(u[0]=s,t=1;t<arguments.length;t++)u[t]=arguments[t];if(s.delegateTarget=this,!c.preDispatch||!1!==c.preDispatch.call(this,s)){a=k.event.handlers.call(this,s,l),t=0;while((i=a[t++])&&!s.isPropagationStopped()){s.currentTarget=i.elem,n=0;while((o=i.handlers[n++])&&!s.isImmediatePropagationStopped())s.rnamespace&&!1!==o.namespace&&!s.rnamespace.test(o.namespace)||(s.handleObj=o,s.data=o.data,void 0!==(r=((k.event.special[o.origType]||{}).handle||o.handler).apply(i.elem,u))&&!1===(s.result=r)&&(s.preventDefault(),s.stopPropagation()))}return c.postDispatch&&c.postDispatch.call(this,s),s.result}},handlers:function(e,t){var n,r,i,o,a,s=[],u=t.delegateCount,l=e.target;if(u&&l.nodeType&&!("click"===e.type&&1<=e.button))for(;l!==this;l=l.parentNode||this)if(1===l.nodeType&&("click"!==e.type||!0!==l.disabled)){for(o=[],a={},n=0;n<u;n++)void 0===a[i=(r=t[n]).selector+" "]&&(a[i]=r.needsContext?-1<k(i,this).index(l):k.find(i,this,null,[l]).length),a[i]&&o.push(r);o.length&&s.push({elem:l,handlers:o})}return l=this,u<t.length&&s.push({elem:l,handlers:t.slice(u)}),s},addProp:function(t,e){Object.defineProperty(k.Event.prototype,t,{enumerable:!0,configurable:!0,get:m(e)?function(){if(this.originalEvent)return e(this.originalEvent)}:function(){if(this.originalEvent)return this.originalEvent[t]},set:function(e){Object.defineProperty(this,t,{enumerable:!0,configurable:!0,writable:!0,value:e})}})},fix:function(e){return e[k.expando]?e:new k.Event(e)},special:{load:{noBubble:!0},click:{setup:function(e){var t=this||e;return pe.test(t.type)&&t.click&&A(t,"input")&&De(t,"click",ke),!1},trigger:function(e){var t=this||e;return pe.test(t.type)&&t.click&&A(t,"input")&&De(t,"click"),!0},_default:function(e){var t=e.target;return pe.test(t.type)&&t.click&&A(t,"input")&&Q.get(t,"click")||A(t,"a")}},beforeunload:{postDispatch:function(e){void 0!==e.result&&e.originalEvent&&(e.originalEvent.returnValue=e.result)}}}},k.removeEvent=function(e,t,n){e.removeEventListener&&e.removeEventListener(t,n)},k.Event=function(e,t){if(!(this instanceof k.Event))return new k.Event(e,t);e&&e.type?(this.originalEvent=e,this.type=e.type,this.isDefaultPrevented=e.defaultPrevented||void 0===e.defaultPrevented&&!1===e.returnValue?ke:Se,this.target=e.target&&3===e.target.nodeType?e.target.parentNode:e.target,this.currentTarget=e.currentTarget,this.relatedTarget=e.relatedTarget):this.type=e,t&&k.extend(this,t),this.timeStamp=e&&e.timeStamp||Date.now(),this[k.expando]=!0},k.Event.prototype={constructor:k.Event,isDefaultPrevented:Se,isPropagationStopped:Se,isImmediatePropagationStopped:Se,isSimulated:!1,preventDefault:function(){var e=this.originalEvent;this.isDefaultPrevented=ke,e&&!this.isSimulated&&e.preventDefault()},stopPropagation:function(){var e=this.originalEvent;this.isPropagationStopped=ke,e&&!this.isSimulated&&e.stopPropagation()},stopImmediatePropagation:function(){var e=this.originalEvent;this.isImmediatePropagationStopped=ke,e&&!this.isSimulated&&e.stopImmediatePropagation(),this.stopPropagation()}},k.each({altKey:!0,bubbles:!0,cancelable:!0,changedTouches:!0,ctrlKey:!0,detail:!0,eventPhase:!0,metaKey:!0,pageX:!0,pageY:!0,shiftKey:!0,view:!0,"char":!0,code:!0,charCode:!0,key:!0,keyCode:!0,button:!0,buttons:!0,clientX:!0,clientY:!0,offsetX:!0,offsetY:!0,pointerId:!0,pointerType:!0,screenX:!0,screenY:!0,targetTouches:!0,toElement:!0,touches:!0,which:function(e){var t=e.button;return null==e.which&&Te.test(e.type)?null!=e.charCode?e.charCode:e.keyCode:!e.which&&void 0!==t&&Ce.test(e.type)?1&t?1:2&t?3:4&t?2:0:e.which}},k.event.addProp),k.each({focus:"focusin",blur:"focusout"},function(e,t){k.event.special[e]={setup:function(){return De(this,e,Ne),!1},trigger:function(){return De(this,e),!0},delegateType:t}}),k.each({mouseenter:"mouseover",mouseleave:"mouseout",pointerenter:"pointerover",pointerleave:"pointerout"},function(e,i){k.event.special[e]={delegateType:i,bindType:i,handle:function(e){var t,n=e.relatedTarget,r=e.handleObj;return n&&(n===this||k.contains(this,n))||(e.type=r.origType,t=r.handler.apply(this,arguments),e.type=i),t}}}),k.fn.extend({on:function(e,t,n,r){return Ae(this,e,t,n,r)},one:function(e,t,n,r){return Ae(this,e,t,n,r,1)},off:function(e,t,n){var r,i;if(e&&e.preventDefault&&e.handleObj)return r=e.handleObj,k(e.delegateTarget).off(r.namespace?r.origType+"."+r.namespace:r.origType,r.selector,r.handler),this;if("object"==typeof e){for(i in e)this.off(i,t,e[i]);return this}return!1!==t&&"function"!=typeof t||(n=t,t=void 0),!1===n&&(n=Se),this.each(function(){k.event.remove(this,e,n,t)})}});var je=/<(?!area|br|col|embed|hr|img|input|link|meta|param)(([a-z][^\/\0>\x20\t\r\n\f]*)[^>]*)\/>/gi,qe=/<script|<style|<link/i,Le=/checked\s*(?:[^=]|=\s*.checked.)/i,He=/^\s*<!(?:\[CDATA\[|--)|(?:\]\]|--)>\s*$/g;function Oe(e,t){return A(e,"table")&&A(11!==t.nodeType?t:t.firstChild,"tr")&&k(e).children("tbody")[0]||e}function Pe(e){return e.type=(null!==e.getAttribute("type"))+"/"+e.type,e}function Re(e){return"true/"===(e.type||"").slice(0,5)?e.type=e.type.slice(5):e.removeAttribute("type"),e}function Me(e,t){var n,r,i,o,a,s,u,l;if(1===t.nodeType){if(Q.hasData(e)&&(o=Q.access(e),a=Q.set(t,o),l=o.events))for(i in delete a.handle,a.events={},l)for(n=0,r=l[i].length;n<r;n++)k.event.add(t,i,l[i][n]);J.hasData(e)&&(s=J.access(e),u=k.extend({},s),J.set(t,u))}}function Ie(n,r,i,o){r=g.apply([],r);var e,t,a,s,u,l,c=0,f=n.length,p=f-1,d=r[0],h=m(d);if(h||1<f&&"string"==typeof d&&!y.checkClone&&Le.test(d))return n.each(function(e){var t=n.eq(e);h&&(r[0]=d.call(this,e,t.html())),Ie(t,r,i,o)});if(f&&(t=(e=we(r,n[0].ownerDocument,!1,n,o)).firstChild,1===e.childNodes.length&&(e=t),t||o)){for(s=(a=k.map(ve(e,"script"),Pe)).length;c<f;c++)u=e,c!==p&&(u=k.clone(u,!0,!0),s&&k.merge(a,ve(u,"script"))),i.call(n[c],u,c);if(s)for(l=a[a.length-1].ownerDocument,k.map(a,Re),c=0;c<s;c++)u=a[c],he.test(u.type||"")&&!Q.access(u,"globalEval")&&k.contains(l,u)&&(u.src&&"module"!==(u.type||"").toLowerCase()?k._evalUrl&&!u.noModule&&k._evalUrl(u.src,{nonce:u.nonce||u.getAttribute("nonce")}):b(u.textContent.replace(He,""),u,l))}return n}function We(e,t,n){for(var r,i=t?k.filter(t,e):e,o=0;null!=(r=i[o]);o++)n||1!==r.nodeType||k.cleanData(ve(r)),r.parentNode&&(n&&oe(r)&&ye(ve(r,"script")),r.parentNode.removeChild(r));return e}k.extend({htmlPrefilter:function(e){return e.replace(je,"<$1></$2>")},clone:function(e,t,n){var r,i,o,a,s,u,l,c=e.cloneNode(!0),f=oe(e);if(!(y.noCloneChecked||1!==e.nodeType&&11!==e.nodeType||k.isXMLDoc(e)))for(a=ve(c),r=0,i=(o=ve(e)).length;r<i;r++)s=o[r],u=a[r],void 0,"input"===(l=u.nodeName.toLowerCase())&&pe.test(s.type)?u.checked=s.checked:"input"!==l&&"textarea"!==l||(u.defaultValue=s.defaultValue);if(t)if(n)for(o=o||ve(e),a=a||ve(c),r=0,i=o.length;r<i;r++)Me(o[r],a[r]);else Me(e,c);return 0<(a=ve(c,"script")).length&&ye(a,!f&&ve(e,"script")),c},cleanData:function(e){for(var t,n,r,i=k.event.special,o=0;void 0!==(n=e[o]);o++)if(G(n)){if(t=n[Q.expando]){if(t.events)for(r in t.events)i[r]?k.event.remove(n,r):k.removeEvent(n,r,t.handle);n[Q.expando]=void 0}n[J.expando]&&(n[J.expando]=void 0)}}}),k.fn.extend({detach:function(e){return We(this,e,!0)},remove:function(e){return We(this,e)},text:function(e){return _(this,function(e){return void 0===e?k.text(this):this.empty().each(function(){1!==this.nodeType&&11!==this.nodeType&&9!==this.nodeType||(this.textContent=e)})},null,e,arguments.length)},append:function(){return Ie(this,arguments,function(e){1!==this.nodeType&&11!==this.nodeType&&9!==this.nodeType||Oe(this,e).appendChild(e)})},prepend:function(){return Ie(this,arguments,function(e){if(1===this.nodeType||11===this.nodeType||9===this.nodeType){var t=Oe(this,e);t.insertBefore(e,t.firstChild)}})},before:function(){return Ie(this,arguments,function(e){this.parentNode&&this.parentNode.insertBefore(e,this)})},after:function(){return Ie(this,arguments,function(e){this.parentNode&&this.parentNode.insertBefore(e,this.nextSibling)})},empty:function(){for(var e,t=0;null!=(e=this[t]);t++)1===e.nodeType&&(k.cleanData(ve(e,!1)),e.textContent="");return this},clone:function(e,t){return e=null!=e&&e,t=null==t?e:t,this.map(function(){return k.clone(this,e,t)})},html:function(e){return _(this,function(e){var t=this[0]||{},n=0,r=this.length;if(void 0===e&&1===t.nodeType)return t.innerHTML;if("string"==typeof e&&!qe.test(e)&&!ge[(de.exec(e)||["",""])[1].toLowerCase()]){e=k.htmlPrefilter(e);try{for(;n<r;n++)1===(t=this[n]||{}).nodeType&&(k.cleanData(ve(t,!1)),t.innerHTML=e);t=0}catch(e){}}t&&this.empty().append(e)},null,e,arguments.length)},replaceWith:function(){var n=[];return Ie(this,arguments,function(e){var t=this.parentNode;k.inArray(this,n)<0&&(k.cleanData(ve(this)),t&&t.replaceChild(e,this))},n)}}),k.each({appendTo:"append",prependTo:"prepend",insertBefore:"before",insertAfter:"after",replaceAll:"replaceWith"},function(e,a){k.fn[e]=function(e){for(var t,n=[],r=k(e),i=r.length-1,o=0;o<=i;o++)t=o===i?this:this.clone(!0),k(r[o])[a](t),u.apply(n,t.get());return this.pushStack(n)}});var $e=new RegExp("^("+te+")(?!px)[a-z%]+$","i"),Fe=function(e){var t=e.ownerDocument.defaultView;return t&&t.opener||(t=C),t.getComputedStyle(e)},Be=new RegExp(re.join("|"),"i");function _e(e,t,n){var r,i,o,a,s=e.style;return(n=n||Fe(e))&&(""!==(a=n.getPropertyValue(t)||n[t])||oe(e)||(a=k.style(e,t)),!y.pixelBoxStyles()&&$e.test(a)&&Be.test(t)&&(r=s.width,i=s.minWidth,o=s.maxWidth,s.minWidth=s.maxWidth=s.width=a,a=n.width,s.width=r,s.minWidth=i,s.maxWidth=o)),void 0!==a?a+"":a}function ze(e,t){return{get:function(){if(!e())return(this.get=t).apply(this,arguments);delete this.get}}}!function(){function e(){if(u){s.style.cssText="position:absolute;left:-11111px;width:60px;margin-top:1px;padding:0;border:0",u.style.cssText="position:relative;display:block;box-sizing:border-box;overflow:scroll;margin:auto;border:1px;padding:1px;width:60%;top:1%",ie.appendChild(s).appendChild(u);var e=C.getComputedStyle(u);n="1%"!==e.top,a=12===t(e.marginLeft),u.style.right="60%",o=36===t(e.right),r=36===t(e.width),u.style.position="absolute",i=12===t(u.offsetWidth/3),ie.removeChild(s),u=null}}function t(e){return Math.round(parseFloat(e))}var n,r,i,o,a,s=E.createElement("div"),u=E.createElement("div");u.style&&(u.style.backgroundClip="content-box",u.cloneNode(!0).style.backgroundClip="",y.clearCloneStyle="content-box"===u.style.backgroundClip,k.extend(y,{boxSizingReliable:function(){return e(),r},pixelBoxStyles:function(){return e(),o},pixelPosition:function(){return e(),n},reliableMarginLeft:function(){return e(),a},scrollboxSize:function(){return e(),i}}))}();var Ue=["Webkit","Moz","ms"],Xe=E.createElement("div").style,Ve={};function Ge(e){var t=k.cssProps[e]||Ve[e];return t||(e in Xe?e:Ve[e]=function(e){var t=e[0].toUpperCase()+e.slice(1),n=Ue.length;while(n--)if((e=Ue[n]+t)in Xe)return e}(e)||e)}var Ye=/^(none|table(?!-c[ea]).+)/,Qe=/^--/,Je={position:"absolute",visibility:"hidden",display:"block"},Ke={letterSpacing:"0",fontWeight:"400"};function Ze(e,t,n){var r=ne.exec(t);return r?Math.max(0,r[2]-(n||0))+(r[3]||"px"):t}function et(e,t,n,r,i,o){var a="width"===t?1:0,s=0,u=0;if(n===(r?"border":"content"))return 0;for(;a<4;a+=2)"margin"===n&&(u+=k.css(e,n+re[a],!0,i)),r?("content"===n&&(u-=k.css(e,"padding"+re[a],!0,i)),"margin"!==n&&(u-=k.css(e,"border"+re[a]+"Width",!0,i))):(u+=k.css(e,"padding"+re[a],!0,i),"padding"!==n?u+=k.css(e,"border"+re[a]+"Width",!0,i):s+=k.css(e,"border"+re[a]+"Width",!0,i));return!r&&0<=o&&(u+=Math.max(0,Math.ceil(e["offset"+t[0].toUpperCase()+t.slice(1)]-o-u-s-.5))||0),u}function tt(e,t,n){var r=Fe(e),i=(!y.boxSizingReliable()||n)&&"border-box"===k.css(e,"boxSizing",!1,r),o=i,a=_e(e,t,r),s="offset"+t[0].toUpperCase()+t.slice(1);if($e.test(a)){if(!n)return a;a="auto"}return(!y.boxSizingReliable()&&i||"auto"===a||!parseFloat(a)&&"inline"===k.css(e,"display",!1,r))&&e.getClientRects().length&&(i="border-box"===k.css(e,"boxSizing",!1,r),(o=s in e)&&(a=e[s])),(a=parseFloat(a)||0)+et(e,t,n||(i?"border":"content"),o,r,a)+"px"}function nt(e,t,n,r,i){return new nt.prototype.init(e,t,n,r,i)}k.extend({cssHooks:{opacity:{get:function(e,t){if(t){var n=_e(e,"opacity");return""===n?"1":n}}}},cssNumber:{animationIterationCount:!0,columnCount:!0,fillOpacity:!0,flexGrow:!0,flexShrink:!0,fontWeight:!0,gridArea:!0,gridColumn:!0,gridColumnEnd:!0,gridColumnStart:!0,gridRow:!0,gridRowEnd:!0,gridRowStart:!0,lineHeight:!0,opacity:!0,order:!0,orphans:!0,widows:!0,zIndex:!0,zoom:!0},cssProps:{},style:function(e,t,n,r){if(e&&3!==e.nodeType&&8!==e.nodeType&&e.style){var i,o,a,s=V(t),u=Qe.test(t),l=e.style;if(u||(t=Ge(s)),a=k.cssHooks[t]||k.cssHooks[s],void 0===n)return a&&"get"in a&&void 0!==(i=a.get(e,!1,r))?i:l[t];"string"===(o=typeof n)&&(i=ne.exec(n))&&i[1]&&(n=le(e,t,i),o="number"),null!=n&&n==n&&("number"!==o||u||(n+=i&&i[3]||(k.cssNumber[s]?"":"px")),y.clearCloneStyle||""!==n||0!==t.indexOf("background")||(l[t]="inherit"),a&&"set"in a&&void 0===(n=a.set(e,n,r))||(u?l.setProperty(t,n):l[t]=n))}},css:function(e,t,n,r){var i,o,a,s=V(t);return Qe.test(t)||(t=Ge(s)),(a=k.cssHooks[t]||k.cssHooks[s])&&"get"in a&&(i=a.get(e,!0,n)),void 0===i&&(i=_e(e,t,r)),"normal"===i&&t in Ke&&(i=Ke[t]),""===n||n?(o=parseFloat(i),!0===n||isFinite(o)?o||0:i):i}}),k.each(["height","width"],function(e,u){k.cssHooks[u]={get:function(e,t,n){if(t)return!Ye.test(k.css(e,"display"))||e.getClientRects().length&&e.getBoundingClientRect().width?tt(e,u,n):ue(e,Je,function(){return tt(e,u,n)})},set:function(e,t,n){var r,i=Fe(e),o=!y.scrollboxSize()&&"absolute"===i.position,a=(o||n)&&"border-box"===k.css(e,"boxSizing",!1,i),s=n?et(e,u,n,a,i):0;return a&&o&&(s-=Math.ceil(e["offset"+u[0].toUpperCase()+u.slice(1)]-parseFloat(i[u])-et(e,u,"border",!1,i)-.5)),s&&(r=ne.exec(t))&&"px"!==(r[3]||"px")&&(e.style[u]=t,t=k.css(e,u)),Ze(0,t,s)}}}),k.cssHooks.marginLeft=ze(y.reliableMarginLeft,function(e,t){if(t)return(parseFloat(_e(e,"marginLeft"))||e.getBoundingClientRect().left-ue(e,{marginLeft:0},function(){return e.getBoundingClientRect().left}))+"px"}),k.each({margin:"",padding:"",border:"Width"},function(i,o){k.cssHooks[i+o]={expand:function(e){for(var t=0,n={},r="string"==typeof e?e.split(" "):[e];t<4;t++)n[i+re[t]+o]=r[t]||r[t-2]||r[0];return n}},"margin"!==i&&(k.cssHooks[i+o].set=Ze)}),k.fn.extend({css:function(e,t){return _(this,function(e,t,n){var r,i,o={},a=0;if(Array.isArray(t)){for(r=Fe(e),i=t.length;a<i;a++)o[t[a]]=k.css(e,t[a],!1,r);return o}return void 0!==n?k.style(e,t,n):k.css(e,t)},e,t,1<arguments.length)}}),((k.Tween=nt).prototype={constructor:nt,init:function(e,t,n,r,i,o){this.elem=e,this.prop=n,this.easing=i||k.easing._default,this.options=t,this.start=this.now=this.cur(),this.end=r,this.unit=o||(k.cssNumber[n]?"":"px")},cur:function(){var e=nt.propHooks[this.prop];return e&&e.get?e.get(this):nt.propHooks._default.get(this)},run:function(e){var t,n=nt.propHooks[this.prop];return this.options.duration?this.pos=t=k.easing[this.easing](e,this.options.duration*e,0,1,this.options.duration):this.pos=t=e,this.now=(this.end-this.start)*t+this.start,this.options.step&&this.options.step.call(this.elem,this.now,this),n&&n.set?n.set(this):nt.propHooks._default.set(this),this}}).init.prototype=nt.prototype,(nt.propHooks={_default:{get:function(e){var t;return 1!==e.elem.nodeType||null!=e.elem[e.prop]&&null==e.elem.style[e.prop]?e.elem[e.prop]:(t=k.css(e.elem,e.prop,""))&&"auto"!==t?t:0},set:function(e){k.fx.step[e.prop]?k.fx.step[e.prop](e):1!==e.elem.nodeType||!k.cssHooks[e.prop]&&null==e.elem.style[Ge(e.prop)]?e.elem[e.prop]=e.now:k.style(e.elem,e.prop,e.now+e.unit)}}}).scrollTop=nt.propHooks.scrollLeft={set:function(e){e.elem.nodeType&&e.elem.parentNode&&(e.elem[e.prop]=e.now)}},k.easing={linear:function(e){return e},swing:function(e){return.5-Math.cos(e*Math.PI)/2},_default:"swing"},k.fx=nt.prototype.init,k.fx.step={};var rt,it,ot,at,st=/^(?:toggle|show|hide)$/,ut=/queueHooks$/;function lt(){it&&(!1===E.hidden&&C.requestAnimationFrame?C.requestAnimationFrame(lt):C.setTimeout(lt,k.fx.interval),k.fx.tick())}function ct(){return C.setTimeout(function(){rt=void 0}),rt=Date.now()}function ft(e,t){var n,r=0,i={height:e};for(t=t?1:0;r<4;r+=2-t)i["margin"+(n=re[r])]=i["padding"+n]=e;return t&&(i.opacity=i.width=e),i}function pt(e,t,n){for(var r,i=(dt.tweeners[t]||[]).concat(dt.tweeners["*"]),o=0,a=i.length;o<a;o++)if(r=i[o].call(n,t,e))return r}function dt(o,e,t){var n,a,r=0,i=dt.prefilters.length,s=k.Deferred().always(function(){delete u.elem}),u=function(){if(a)return!1;for(var e=rt||ct(),t=Math.max(0,l.startTime+l.duration-e),n=1-(t/l.duration||0),r=0,i=l.tweens.length;r<i;r++)l.tweens[r].run(n);return s.notifyWith(o,[l,n,t]),n<1&&i?t:(i||s.notifyWith(o,[l,1,0]),s.resolveWith(o,[l]),!1)},l=s.promise({elem:o,props:k.extend({},e),opts:k.extend(!0,{specialEasing:{},easing:k.easing._default},t),originalProperties:e,originalOptions:t,startTime:rt||ct(),duration:t.duration,tweens:[],createTween:function(e,t){var n=k.Tween(o,l.opts,e,t,l.opts.specialEasing[e]||l.opts.easing);return l.tweens.push(n),n},stop:function(e){var t=0,n=e?l.tweens.length:0;if(a)return this;for(a=!0;t<n;t++)l.tweens[t].run(1);return e?(s.notifyWith(o,[l,1,0]),s.resolveWith(o,[l,e])):s.rejectWith(o,[l,e]),this}}),c=l.props;for(!function(e,t){var n,r,i,o,a;for(n in e)if(i=t[r=V(n)],o=e[n],Array.isArray(o)&&(i=o[1],o=e[n]=o[0]),n!==r&&(e[r]=o,delete e[n]),(a=k.cssHooks[r])&&"expand"in a)for(n in o=a.expand(o),delete e[r],o)n in e||(e[n]=o[n],t[n]=i);else t[r]=i}(c,l.opts.specialEasing);r<i;r++)if(n=dt.prefilters[r].call(l,o,c,l.opts))return m(n.stop)&&(k._queueHooks(l.elem,l.opts.queue).stop=n.stop.bind(n)),n;return k.map(c,pt,l),m(l.opts.start)&&l.opts.start.call(o,l),l.progress(l.opts.progress).done(l.opts.done,l.opts.complete).fail(l.opts.fail).always(l.opts.always),k.fx.timer(k.extend(u,{elem:o,anim:l,queue:l.opts.queue})),l}k.Animation=k.extend(dt,{tweeners:{"*":[function(e,t){var n=this.createTween(e,t);return le(n.elem,e,ne.exec(t),n),n}]},tweener:function(e,t){m(e)?(t=e,e=["*"]):e=e.match(R);for(var n,r=0,i=e.length;r<i;r++)n=e[r],dt.tweeners[n]=dt.tweeners[n]||[],dt.tweeners[n].unshift(t)},prefilters:[function(e,t,n){var r,i,o,a,s,u,l,c,f="width"in t||"height"in t,p=this,d={},h=e.style,g=e.nodeType&&se(e),v=Q.get(e,"fxshow");for(r in n.queue||(null==(a=k._queueHooks(e,"fx")).unqueued&&(a.unqueued=0,s=a.empty.fire,a.empty.fire=function(){a.unqueued||s()}),a.unqueued++,p.always(function(){p.always(function(){a.unqueued--,k.queue(e,"fx").length||a.empty.fire()})})),t)if(i=t[r],st.test(i)){if(delete t[r],o=o||"toggle"===i,i===(g?"hide":"show")){if("show"!==i||!v||void 0===v[r])continue;g=!0}d[r]=v&&v[r]||k.style(e,r)}if((u=!k.isEmptyObject(t))||!k.isEmptyObject(d))for(r in f&&1===e.nodeType&&(n.overflow=[h.overflow,h.overflowX,h.overflowY],null==(l=v&&v.display)&&(l=Q.get(e,"display")),"none"===(c=k.css(e,"display"))&&(l?c=l:(fe([e],!0),l=e.style.display||l,c=k.css(e,"display"),fe([e]))),("inline"===c||"inline-block"===c&&null!=l)&&"none"===k.css(e,"float")&&(u||(p.done(function(){h.display=l}),null==l&&(c=h.display,l="none"===c?"":c)),h.display="inline-block")),n.overflow&&(h.overflow="hidden",p.always(function(){h.overflow=n.overflow[0],h.overflowX=n.overflow[1],h.overflowY=n.overflow[2]})),u=!1,d)u||(v?"hidden"in v&&(g=v.hidden):v=Q.access(e,"fxshow",{display:l}),o&&(v.hidden=!g),g&&fe([e],!0),p.done(function(){for(r in g||fe([e]),Q.remove(e,"fxshow"),d)k.style(e,r,d[r])})),u=pt(g?v[r]:0,r,p),r in v||(v[r]=u.start,g&&(u.end=u.start,u.start=0))}],prefilter:function(e,t){t?dt.prefilters.unshift(e):dt.prefilters.push(e)}}),k.speed=function(e,t,n){var r=e&&"object"==typeof e?k.extend({},e):{complete:n||!n&&t||m(e)&&e,duration:e,easing:n&&t||t&&!m(t)&&t};return k.fx.off?r.duration=0:"number"!=typeof r.duration&&(r.duration in k.fx.speeds?r.duration=k.fx.speeds[r.duration]:r.duration=k.fx.speeds._default),null!=r.queue&&!0!==r.queue||(r.queue="fx"),r.old=r.complete,r.complete=function(){m(r.old)&&r.old.call(this),r.queue&&k.dequeue(this,r.queue)},r},k.fn.extend({fadeTo:function(e,t,n,r){return this.filter(se).css("opacity",0).show().end().animate({opacity:t},e,n,r)},animate:function(t,e,n,r){var i=k.isEmptyObject(t),o=k.speed(e,n,r),a=function(){var e=dt(this,k.extend({},t),o);(i||Q.get(this,"finish"))&&e.stop(!0)};return a.finish=a,i||!1===o.queue?this.each(a):this.queue(o.queue,a)},stop:function(i,e,o){var a=function(e){var t=e.stop;delete e.stop,t(o)};return"string"!=typeof i&&(o=e,e=i,i=void 0),e&&!1!==i&&this.queue(i||"fx",[]),this.each(function(){var e=!0,t=null!=i&&i+"queueHooks",n=k.timers,r=Q.get(this);if(t)r[t]&&r[t].stop&&a(r[t]);else for(t in r)r[t]&&r[t].stop&&ut.test(t)&&a(r[t]);for(t=n.length;t--;)n[t].elem!==this||null!=i&&n[t].queue!==i||(n[t].anim.stop(o),e=!1,n.splice(t,1));!e&&o||k.dequeue(this,i)})},finish:function(a){return!1!==a&&(a=a||"fx"),this.each(function(){var e,t=Q.get(this),n=t[a+"queue"],r=t[a+"queueHooks"],i=k.timers,o=n?n.length:0;for(t.finish=!0,k.queue(this,a,[]),r&&r.stop&&r.stop.call(this,!0),e=i.length;e--;)i[e].elem===this&&i[e].queue===a&&(i[e].anim.stop(!0),i.splice(e,1));for(e=0;e<o;e++)n[e]&&n[e].finish&&n[e].finish.call(this);delete t.finish})}}),k.each(["toggle","show","hide"],function(e,r){var i=k.fn[r];k.fn[r]=function(e,t,n){return null==e||"boolean"==typeof e?i.apply(this,arguments):this.animate(ft(r,!0),e,t,n)}}),k.each({slideDown:ft("show"),slideUp:ft("hide"),slideToggle:ft("toggle"),fadeIn:{opacity:"show"},fadeOut:{opacity:"hide"},fadeToggle:{opacity:"toggle"}},function(e,r){k.fn[e]=function(e,t,n){return this.animate(r,e,t,n)}}),k.timers=[],k.fx.tick=function(){var e,t=0,n=k.timers;for(rt=Date.now();t<n.length;t++)(e=n[t])()||n[t]!==e||n.splice(t--,1);n.length||k.fx.stop(),rt=void 0},k.fx.timer=function(e){k.timers.push(e),k.fx.start()},k.fx.interval=13,k.fx.start=function(){it||(it=!0,lt())},k.fx.stop=function(){it=null},k.fx.speeds={slow:600,fast:200,_default:400},k.fn.delay=function(r,e){return r=k.fx&&k.fx.speeds[r]||r,e=e||"fx",this.queue(e,function(e,t){var n=C.setTimeout(e,r);t.stop=function(){C.clearTimeout(n)}})},ot=E.createElement("input"),at=E.createElement("select").appendChild(E.createElement("option")),ot.type="checkbox",y.checkOn=""!==ot.value,y.optSelected=at.selected,(ot=E.createElement("input")).value="t",ot.type="radio",y.radioValue="t"===ot.value;var ht,gt=k.expr.attrHandle;k.fn.extend({attr:function(e,t){return _(this,k.attr,e,t,1<arguments.length)},removeAttr:function(e){return this.each(function(){k.removeAttr(this,e)})}}),k.extend({attr:function(e,t,n){var r,i,o=e.nodeType;if(3!==o&&8!==o&&2!==o)return"undefined"==typeof e.getAttribute?k.prop(e,t,n):(1===o&&k.isXMLDoc(e)||(i=k.attrHooks[t.toLowerCase()]||(k.expr.match.bool.test(t)?ht:void 0)),void 0!==n?null===n?void k.removeAttr(e,t):i&&"set"in i&&void 0!==(r=i.set(e,n,t))?r:(e.setAttribute(t,n+""),n):i&&"get"in i&&null!==(r=i.get(e,t))?r:null==(r=k.find.attr(e,t))?void 0:r)},attrHooks:{type:{set:function(e,t){if(!y.radioValue&&"radio"===t&&A(e,"input")){var n=e.value;return e.setAttribute("type",t),n&&(e.value=n),t}}}},removeAttr:function(e,t){var n,r=0,i=t&&t.match(R);if(i&&1===e.nodeType)while(n=i[r++])e.removeAttribute(n)}}),ht={set:function(e,t,n){return!1===t?k.removeAttr(e,n):e.setAttribute(n,n),n}},k.each(k.expr.match.bool.source.match(/\w+/g),function(e,t){var a=gt[t]||k.find.attr;gt[t]=function(e,t,n){var r,i,o=t.toLowerCase();return n||(i=gt[o],gt[o]=r,r=null!=a(e,t,n)?o:null,gt[o]=i),r}});var vt=/^(?:input|select|textarea|button)$/i,yt=/^(?:a|area)$/i;function mt(e){return(e.match(R)||[]).join(" ")}function xt(e){return e.getAttribute&&e.getAttribute("class")||""}function bt(e){return Array.isArray(e)?e:"string"==typeof e&&e.match(R)||[]}k.fn.extend({prop:function(e,t){return _(this,k.prop,e,t,1<arguments.length)},removeProp:function(e){return this.each(function(){delete this[k.propFix[e]||e]})}}),k.extend({prop:function(e,t,n){var r,i,o=e.nodeType;if(3!==o&&8!==o&&2!==o)return 1===o&&k.isXMLDoc(e)||(t=k.propFix[t]||t,i=k.propHooks[t]),void 0!==n?i&&"set"in i&&void 0!==(r=i.set(e,n,t))?r:e[t]=n:i&&"get"in i&&null!==(r=i.get(e,t))?r:e[t]},propHooks:{tabIndex:{get:function(e){var t=k.find.attr(e,"tabindex");return t?parseInt(t,10):vt.test(e.nodeName)||yt.test(e.nodeName)&&e.href?0:-1}}},propFix:{"for":"htmlFor","class":"className"}}),y.optSelected||(k.propHooks.selected={get:function(e){var t=e.parentNode;return t&&t.parentNode&&t.parentNode.selectedIndex,null},set:function(e){var t=e.parentNode;t&&(t.selectedIndex,t.parentNode&&t.parentNode.selectedIndex)}}),k.each(["tabIndex","readOnly","maxLength","cellSpacing","cellPadding","rowSpan","colSpan","useMap","frameBorder","contentEditable"],function(){k.propFix[this.toLowerCase()]=this}),k.fn.extend({addClass:function(t){var e,n,r,i,o,a,s,u=0;if(m(t))return this.each(function(e){k(this).addClass(t.call(this,e,xt(this)))});if((e=bt(t)).length)while(n=this[u++])if(i=xt(n),r=1===n.nodeType&&" "+mt(i)+" "){a=0;while(o=e[a++])r.indexOf(" "+o+" ")<0&&(r+=o+" ");i!==(s=mt(r))&&n.setAttribute("class",s)}return this},removeClass:function(t){var e,n,r,i,o,a,s,u=0;if(m(t))return this.each(function(e){k(this).removeClass(t.call(this,e,xt(this)))});if(!arguments.length)return this.attr("class","");if((e=bt(t)).length)while(n=this[u++])if(i=xt(n),r=1===n.nodeType&&" "+mt(i)+" "){a=0;while(o=e[a++])while(-1<r.indexOf(" "+o+" "))r=r.replace(" "+o+" "," ");i!==(s=mt(r))&&n.setAttribute("class",s)}return this},toggleClass:function(i,t){var o=typeof i,a="string"===o||Array.isArray(i);return"boolean"==typeof t&&a?t?this.addClass(i):this.removeClass(i):m(i)?this.each(function(e){k(this).toggleClass(i.call(this,e,xt(this),t),t)}):this.each(function(){var e,t,n,r;if(a){t=0,n=k(this),r=bt(i);while(e=r[t++])n.hasClass(e)?n.removeClass(e):n.addClass(e)}else void 0!==i&&"boolean"!==o||((e=xt(this))&&Q.set(this,"__className__",e),this.setAttribute&&this.setAttribute("class",e||!1===i?"":Q.get(this,"__className__")||""))})},hasClass:function(e){var t,n,r=0;t=" "+e+" ";while(n=this[r++])if(1===n.nodeType&&-1<(" "+mt(xt(n))+" ").indexOf(t))return!0;return!1}});var wt=/\r/g;k.fn.extend({val:function(n){var r,e,i,t=this[0];return arguments.length?(i=m(n),this.each(function(e){var t;1===this.nodeType&&(null==(t=i?n.call(this,e,k(this).val()):n)?t="":"number"==typeof t?t+="":Array.isArray(t)&&(t=k.map(t,function(e){return null==e?"":e+""})),(r=k.valHooks[this.type]||k.valHooks[this.nodeName.toLowerCase()])&&"set"in r&&void 0!==r.set(this,t,"value")||(this.value=t))})):t?(r=k.valHooks[t.type]||k.valHooks[t.nodeName.toLowerCase()])&&"get"in r&&void 0!==(e=r.get(t,"value"))?e:"string"==typeof(e=t.value)?e.replace(wt,""):null==e?"":e:void 0}}),k.extend({valHooks:{option:{get:function(e){var t=k.find.attr(e,"value");return null!=t?t:mt(k.text(e))}},select:{get:function(e){var t,n,r,i=e.options,o=e.selectedIndex,a="select-one"===e.type,s=a?null:[],u=a?o+1:i.length;for(r=o<0?u:a?o:0;r<u;r++)if(((n=i[r]).selected||r===o)&&!n.disabled&&(!n.parentNode.disabled||!A(n.parentNode,"optgroup"))){if(t=k(n).val(),a)return t;s.push(t)}return s},set:function(e,t){var n,r,i=e.options,o=k.makeArray(t),a=i.length;while(a--)((r=i[a]).selected=-1<k.inArray(k.valHooks.option.get(r),o))&&(n=!0);return n||(e.selectedIndex=-1),o}}}}),k.each(["radio","checkbox"],function(){k.valHooks[this]={set:function(e,t){if(Array.isArray(t))return e.checked=-1<k.inArray(k(e).val(),t)}},y.checkOn||(k.valHooks[this].get=function(e){return null===e.getAttribute("value")?"on":e.value})}),y.focusin="onfocusin"in C;var Tt=/^(?:focusinfocus|focusoutblur)$/,Ct=function(e){e.stopPropagation()};k.extend(k.event,{trigger:function(e,t,n,r){var i,o,a,s,u,l,c,f,p=[n||E],d=v.call(e,"type")?e.type:e,h=v.call(e,"namespace")?e.namespace.split("."):[];if(o=f=a=n=n||E,3!==n.nodeType&&8!==n.nodeType&&!Tt.test(d+k.event.triggered)&&(-1<d.indexOf(".")&&(d=(h=d.split(".")).shift(),h.sort()),u=d.indexOf(":")<0&&"on"+d,(e=e[k.expando]?e:new k.Event(d,"object"==typeof e&&e)).isTrigger=r?2:3,e.namespace=h.join("."),e.rnamespace=e.namespace?new RegExp("(^|\\.)"+h.join("\\.(?:.*\\.|)")+"(\\.|$)"):null,e.result=void 0,e.target||(e.target=n),t=null==t?[e]:k.makeArray(t,[e]),c=k.event.special[d]||{},r||!c.trigger||!1!==c.trigger.apply(n,t))){if(!r&&!c.noBubble&&!x(n)){for(s=c.delegateType||d,Tt.test(s+d)||(o=o.parentNode);o;o=o.parentNode)p.push(o),a=o;a===(n.ownerDocument||E)&&p.push(a.defaultView||a.parentWindow||C)}i=0;while((o=p[i++])&&!e.isPropagationStopped())f=o,e.type=1<i?s:c.bindType||d,(l=(Q.get(o,"events")||{})[e.type]&&Q.get(o,"handle"))&&l.apply(o,t),(l=u&&o[u])&&l.apply&&G(o)&&(e.result=l.apply(o,t),!1===e.result&&e.preventDefault());return e.type=d,r||e.isDefaultPrevented()||c._default&&!1!==c._default.apply(p.pop(),t)||!G(n)||u&&m(n[d])&&!x(n)&&((a=n[u])&&(n[u]=null),k.event.triggered=d,e.isPropagationStopped()&&f.addEventListener(d,Ct),n[d](),e.isPropagationStopped()&&f.removeEventListener(d,Ct),k.event.triggered=void 0,a&&(n[u]=a)),e.result}},simulate:function(e,t,n){var r=k.extend(new k.Event,n,{type:e,isSimulated:!0});k.event.trigger(r,null,t)}}),k.fn.extend({trigger:function(e,t){return this.each(function(){k.event.trigger(e,t,this)})},triggerHandler:function(e,t){var n=this[0];if(n)return k.event.trigger(e,t,n,!0)}}),y.focusin||k.each({focus:"focusin",blur:"focusout"},function(n,r){var i=function(e){k.event.simulate(r,e.target,k.event.fix(e))};k.event.special[r]={setup:function(){var e=this.ownerDocument||this,t=Q.access(e,r);t||e.addEventListener(n,i,!0),Q.access(e,r,(t||0)+1)},teardown:function(){var e=this.ownerDocument||this,t=Q.access(e,r)-1;t?Q.access(e,r,t):(e.removeEventListener(n,i,!0),Q.remove(e,r))}}});var Et=C.location,kt=Date.now(),St=/\?/;k.parseXML=function(e){var t;if(!e||"string"!=typeof e)return null;try{t=(new C.DOMParser).parseFromString(e,"text/xml")}catch(e){t=void 0}return t&&!t.getElementsByTagName("parsererror").length||k.error("Invalid XML: "+e),t};var Nt=/\[\]$/,At=/\r?\n/g,Dt=/^(?:submit|button|image|reset|file)$/i,jt=/^(?:input|select|textarea|keygen)/i;function qt(n,e,r,i){var t;if(Array.isArray(e))k.each(e,function(e,t){r||Nt.test(n)?i(n,t):qt(n+"["+("object"==typeof t&&null!=t?e:"")+"]",t,r,i)});else if(r||"object"!==w(e))i(n,e);else for(t in e)qt(n+"["+t+"]",e[t],r,i)}k.param=function(e,t){var n,r=[],i=function(e,t){var n=m(t)?t():t;r[r.length]=encodeURIComponent(e)+"="+encodeURIComponent(null==n?"":n)};if(null==e)return"";if(Array.isArray(e)||e.jquery&&!k.isPlainObject(e))k.each(e,function(){i(this.name,this.value)});else for(n in e)qt(n,e[n],t,i);return r.join("&")},k.fn.extend({serialize:function(){return k.param(this.serializeArray())},serializeArray:function(){return this.map(function(){var e=k.prop(this,"elements");return e?k.makeArray(e):this}).filter(function(){var e=this.type;return this.name&&!k(this).is(":disabled")&&jt.test(this.nodeName)&&!Dt.test(e)&&(this.checked||!pe.test(e))}).map(function(e,t){var n=k(this).val();return null==n?null:Array.isArray(n)?k.map(n,function(e){return{name:t.name,value:e.replace(At,"\r\n")}}):{name:t.name,value:n.replace(At,"\r\n")}}).get()}});var Lt=/%20/g,Ht=/#.*$/,Ot=/([?&])_=[^&]*/,Pt=/^(.*?):[ \t]*([^\r\n]*)$/gm,Rt=/^(?:GET|HEAD)$/,Mt=/^\/\//,It={},Wt={},$t="*/".concat("*"),Ft=E.createElement("a");function Bt(o){return function(e,t){"string"!=typeof e&&(t=e,e="*");var n,r=0,i=e.toLowerCase().match(R)||[];if(m(t))while(n=i[r++])"+"===n[0]?(n=n.slice(1)||"*",(o[n]=o[n]||[]).unshift(t)):(o[n]=o[n]||[]).push(t)}}function _t(t,i,o,a){var s={},u=t===Wt;function l(e){var r;return s[e]=!0,k.each(t[e]||[],function(e,t){var n=t(i,o,a);return"string"!=typeof n||u||s[n]?u?!(r=n):void 0:(i.dataTypes.unshift(n),l(n),!1)}),r}return l(i.dataTypes[0])||!s["*"]&&l("*")}function zt(e,t){var n,r,i=k.ajaxSettings.flatOptions||{};for(n in t)void 0!==t[n]&&((i[n]?e:r||(r={}))[n]=t[n]);return r&&k.extend(!0,e,r),e}Ft.href=Et.href,k.extend({active:0,lastModified:{},etag:{},ajaxSettings:{url:Et.href,type:"GET",isLocal:/^(?:about|app|app-storage|.+-extension|file|res|widget):$/.test(Et.protocol),global:!0,processData:!0,async:!0,contentType:"application/x-www-form-urlencoded; charset=UTF-8",accepts:{"*":$t,text:"text/plain",html:"text/html",xml:"application/xml, text/xml",json:"application/json, text/javascript"},contents:{xml:/\bxml\b/,html:/\bhtml/,json:/\bjson\b/},responseFields:{xml:"responseXML",text:"responseText",json:"responseJSON"},converters:{"* text":String,"text html":!0,"text json":JSON.parse,"text xml":k.parseXML},flatOptions:{url:!0,context:!0}},ajaxSetup:function(e,t){return t?zt(zt(e,k.ajaxSettings),t):zt(k.ajaxSettings,e)},ajaxPrefilter:Bt(It),ajaxTransport:Bt(Wt),ajax:function(e,t){"object"==typeof e&&(t=e,e=void 0),t=t||{};var c,f,p,n,d,r,h,g,i,o,v=k.ajaxSetup({},t),y=v.context||v,m=v.context&&(y.nodeType||y.jquery)?k(y):k.event,x=k.Deferred(),b=k.Callbacks("once memory"),w=v.statusCode||{},a={},s={},u="canceled",T={readyState:0,getResponseHeader:function(e){var t;if(h){if(!n){n={};while(t=Pt.exec(p))n[t[1].toLowerCase()+" "]=(n[t[1].toLowerCase()+" "]||[]).concat(t[2])}t=n[e.toLowerCase()+" "]}return null==t?null:t.join(", ")},getAllResponseHeaders:function(){return h?p:null},setRequestHeader:function(e,t){return null==h&&(e=s[e.toLowerCase()]=s[e.toLowerCase()]||e,a[e]=t),this},overrideMimeType:function(e){return null==h&&(v.mimeType=e),this},statusCode:function(e){var t;if(e)if(h)T.always(e[T.status]);else for(t in e)w[t]=[w[t],e[t]];return this},abort:function(e){var t=e||u;return c&&c.abort(t),l(0,t),this}};if(x.promise(T),v.url=((e||v.url||Et.href)+"").replace(Mt,Et.protocol+"//"),v.type=t.method||t.type||v.method||v.type,v.dataTypes=(v.dataType||"*").toLowerCase().match(R)||[""],null==v.crossDomain){r=E.createElement("a");try{r.href=v.url,r.href=r.href,v.crossDomain=Ft.protocol+"//"+Ft.host!=r.protocol+"//"+r.host}catch(e){v.crossDomain=!0}}if(v.data&&v.processData&&"string"!=typeof v.data&&(v.data=k.param(v.data,v.traditional)),_t(It,v,t,T),h)return T;for(i in(g=k.event&&v.global)&&0==k.active++&&k.event.trigger("ajaxStart"),v.type=v.type.toUpperCase(),v.hasContent=!Rt.test(v.type),f=v.url.replace(Ht,""),v.hasContent?v.data&&v.processData&&0===(v.contentType||"").indexOf("application/x-www-form-urlencoded")&&(v.data=v.data.replace(Lt,"+")):(o=v.url.slice(f.length),v.data&&(v.processData||"string"==typeof v.data)&&(f+=(St.test(f)?"&":"?")+v.data,delete v.data),!1===v.cache&&(f=f.replace(Ot,"$1"),o=(St.test(f)?"&":"?")+"_="+kt+++o),v.url=f+o),v.ifModified&&(k.lastModified[f]&&T.setRequestHeader("If-Modified-Since",k.lastModified[f]),k.etag[f]&&T.setRequestHeader("If-None-Match",k.etag[f])),(v.data&&v.hasContent&&!1!==v.contentType||t.contentType)&&T.setRequestHeader("Content-Type",v.contentType),T.setRequestHeader("Accept",v.dataTypes[0]&&v.accepts[v.dataTypes[0]]?v.accepts[v.dataTypes[0]]+("*"!==v.dataTypes[0]?", "+$t+"; q=0.01":""):v.accepts["*"]),v.headers)T.setRequestHeader(i,v.headers[i]);if(v.beforeSend&&(!1===v.beforeSend.call(y,T,v)||h))return T.abort();if(u="abort",b.add(v.complete),T.done(v.success),T.fail(v.error),c=_t(Wt,v,t,T)){if(T.readyState=1,g&&m.trigger("ajaxSend",[T,v]),h)return T;v.async&&0<v.timeout&&(d=C.setTimeout(function(){T.abort("timeout")},v.timeout));try{h=!1,c.send(a,l)}catch(e){if(h)throw e;l(-1,e)}}else l(-1,"No Transport");function l(e,t,n,r){var i,o,a,s,u,l=t;h||(h=!0,d&&C.clearTimeout(d),c=void 0,p=r||"",T.readyState=0<e?4:0,i=200<=e&&e<300||304===e,n&&(s=function(e,t,n){var r,i,o,a,s=e.contents,u=e.dataTypes;while("*"===u[0])u.shift(),void 0===r&&(r=e.mimeType||t.getResponseHeader("Content-Type"));if(r)for(i in s)if(s[i]&&s[i].test(r)){u.unshift(i);break}if(u[0]in n)o=u[0];else{for(i in n){if(!u[0]||e.converters[i+" "+u[0]]){o=i;break}a||(a=i)}o=o||a}if(o)return o!==u[0]&&u.unshift(o),n[o]}(v,T,n)),s=function(e,t,n,r){var i,o,a,s,u,l={},c=e.dataTypes.slice();if(c[1])for(a in e.converters)l[a.toLowerCase()]=e.converters[a];o=c.shift();while(o)if(e.responseFields[o]&&(n[e.responseFields[o]]=t),!u&&r&&e.dataFilter&&(t=e.dataFilter(t,e.dataType)),u=o,o=c.shift())if("*"===o)o=u;else if("*"!==u&&u!==o){if(!(a=l[u+" "+o]||l["* "+o]))for(i in l)if((s=i.split(" "))[1]===o&&(a=l[u+" "+s[0]]||l["* "+s[0]])){!0===a?a=l[i]:!0!==l[i]&&(o=s[0],c.unshift(s[1]));break}if(!0!==a)if(a&&e["throws"])t=a(t);else try{t=a(t)}catch(e){return{state:"parsererror",error:a?e:"No conversion from "+u+" to "+o}}}return{state:"success",data:t}}(v,s,T,i),i?(v.ifModified&&((u=T.getResponseHeader("Last-Modified"))&&(k.lastModified[f]=u),(u=T.getResponseHeader("etag"))&&(k.etag[f]=u)),204===e||"HEAD"===v.type?l="nocontent":304===e?l="notmodified":(l=s.state,o=s.data,i=!(a=s.error))):(a=l,!e&&l||(l="error",e<0&&(e=0))),T.status=e,T.statusText=(t||l)+"",i?x.resolveWith(y,[o,l,T]):x.rejectWith(y,[T,l,a]),T.statusCode(w),w=void 0,g&&m.trigger(i?"ajaxSuccess":"ajaxError",[T,v,i?o:a]),b.fireWith(y,[T,l]),g&&(m.trigger("ajaxComplete",[T,v]),--k.active||k.event.trigger("ajaxStop")))}return T},getJSON:function(e,t,n){return k.get(e,t,n,"json")},getScript:function(e,t){return k.get(e,void 0,t,"script")}}),k.each(["get","post"],function(e,i){k[i]=function(e,t,n,r){return m(t)&&(r=r||n,n=t,t=void 0),k.ajax(k.extend({url:e,type:i,dataType:r,data:t,success:n},k.isPlainObject(e)&&e))}}),k._evalUrl=function(e,t){return k.ajax({url:e,type:"GET",dataType:"script",cache:!0,async:!1,global:!1,converters:{"text script":function(){}},dataFilter:function(e){k.globalEval(e,t)}})},k.fn.extend({wrapAll:function(e){var t;return this[0]&&(m(e)&&(e=e.call(this[0])),t=k(e,this[0].ownerDocument).eq(0).clone(!0),this[0].parentNode&&t.insertBefore(this[0]),t.map(function(){var e=this;while(e.firstElementChild)e=e.firstElementChild;return e}).append(this)),this},wrapInner:function(n){return m(n)?this.each(function(e){k(this).wrapInner(n.call(this,e))}):this.each(function(){var e=k(this),t=e.contents();t.length?t.wrapAll(n):e.append(n)})},wrap:function(t){var n=m(t);return this.each(function(e){k(this).wrapAll(n?t.call(this,e):t)})},unwrap:function(e){return this.parent(e).not("body").each(function(){k(this).replaceWith(this.childNodes)}),this}}),k.expr.pseudos.hidden=function(e){return!k.expr.pseudos.visible(e)},k.expr.pseudos.visible=function(e){return!!(e.offsetWidth||e.offsetHeight||e.getClientRects().length)},k.ajaxSettings.xhr=function(){try{return new C.XMLHttpRequest}catch(e){}};var Ut={0:200,1223:204},Xt=k.ajaxSettings.xhr();y.cors=!!Xt&&"withCredentials"in Xt,y.ajax=Xt=!!Xt,k.ajaxTransport(function(i){var o,a;if(y.cors||Xt&&!i.crossDomain)return{send:function(e,t){var n,r=i.xhr();if(r.open(i.type,i.url,i.async,i.username,i.password),i.xhrFields)for(n in i.xhrFields)r[n]=i.xhrFields[n];for(n in i.mimeType&&r.overrideMimeType&&r.overrideMimeType(i.mimeType),i.crossDomain||e["X-Requested-With"]||(e["X-Requested-With"]="XMLHttpRequest"),e)r.setRequestHeader(n,e[n]);o=function(e){return function(){o&&(o=a=r.onload=r.onerror=r.onabort=r.ontimeout=r.onreadystatechange=null,"abort"===e?r.abort():"error"===e?"number"!=typeof r.status?t(0,"error"):t(r.status,r.statusText):t(Ut[r.status]||r.status,r.statusText,"text"!==(r.responseType||"text")||"string"!=typeof r.responseText?{binary:r.response}:{text:r.responseText},r.getAllResponseHeaders()))}},r.onload=o(),a=r.onerror=r.ontimeout=o("error"),void 0!==r.onabort?r.onabort=a:r.onreadystatechange=function(){4===r.readyState&&C.setTimeout(function(){o&&a()})},o=o("abort");try{r.send(i.hasContent&&i.data||null)}catch(e){if(o)throw e}},abort:function(){o&&o()}}}),k.ajaxPrefilter(function(e){e.crossDomain&&(e.contents.script=!1)}),k.ajaxSetup({accepts:{script:"text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"},contents:{script:/\b(?:java|ecma)script\b/},converters:{"text script":function(e){return k.globalEval(e),e}}}),k.ajaxPrefilter("script",function(e){void 0===e.cache&&(e.cache=!1),e.crossDomain&&(e.type="GET")}),k.ajaxTransport("script",function(n){var r,i;if(n.crossDomain||n.scriptAttrs)return{send:function(e,t){r=k("<script>").attr(n.scriptAttrs||{}).prop({charset:n.scriptCharset,src:n.url}).on("load error",i=function(e){r.remove(),i=null,e&&t("error"===e.type?404:200,e.type)}),E.head.appendChild(r[0])},abort:function(){i&&i()}}});var Vt,Gt=[],Yt=/(=)\?(?=&|$)|\?\?/;k.ajaxSetup({jsonp:"callback",jsonpCallback:function(){var e=Gt.pop()||k.expando+"_"+kt++;return this[e]=!0,e}}),k.ajaxPrefilter("json jsonp",function(e,t,n){var r,i,o,a=!1!==e.jsonp&&(Yt.test(e.url)?"url":"string"==typeof e.data&&0===(e.contentType||"").indexOf("application/x-www-form-urlencoded")&&Yt.test(e.data)&&"data");if(a||"jsonp"===e.dataTypes[0])return r=e.jsonpCallback=m(e.jsonpCallback)?e.jsonpCallback():e.jsonpCallback,a?e[a]=e[a].replace(Yt,"$1"+r):!1!==e.jsonp&&(e.url+=(St.test(e.url)?"&":"?")+e.jsonp+"="+r),e.converters["script json"]=function(){return o||k.error(r+" was not called"),o[0]},e.dataTypes[0]="json",i=C[r],C[r]=function(){o=arguments},n.always(function(){void 0===i?k(C).removeProp(r):C[r]=i,e[r]&&(e.jsonpCallback=t.jsonpCallback,Gt.push(r)),o&&m(i)&&i(o[0]),o=i=void 0}),"script"}),y.createHTMLDocument=((Vt=E.implementation.createHTMLDocument("").body).innerHTML="<form></form><form></form>",2===Vt.childNodes.length),k.parseHTML=function(e,t,n){return"string"!=typeof e?[]:("boolean"==typeof t&&(n=t,t=!1),t||(y.createHTMLDocument?((r=(t=E.implementation.createHTMLDocument("")).createElement("base")).href=E.location.href,t.head.appendChild(r)):t=E),o=!n&&[],(i=D.exec(e))?[t.createElement(i[1])]:(i=we([e],t,o),o&&o.length&&k(o).remove(),k.merge([],i.childNodes)));var r,i,o},k.fn.load=function(e,t,n){var r,i,o,a=this,s=e.indexOf(" ");return-1<s&&(r=mt(e.slice(s)),e=e.slice(0,s)),m(t)?(n=t,t=void 0):t&&"object"==typeof t&&(i="POST"),0<a.length&&k.ajax({url:e,type:i||"GET",dataType:"html",data:t}).done(function(e){o=arguments,a.html(r?k("<div>").append(k.parseHTML(e)).find(r):e)}).always(n&&function(e,t){a.each(function(){n.apply(this,o||[e.responseText,t,e])})}),this},k.each(["ajaxStart","ajaxStop","ajaxComplete","ajaxError","ajaxSuccess","ajaxSend"],function(e,t){k.fn[t]=function(e){return this.on(t,e)}}),k.expr.pseudos.animated=function(t){return k.grep(k.timers,function(e){return t===e.elem}).length},k.offset={setOffset:function(e,t,n){var r,i,o,a,s,u,l=k.css(e,"position"),c=k(e),f={};"static"===l&&(e.style.position="relative"),s=c.offset(),o=k.css(e,"top"),u=k.css(e,"left"),("absolute"===l||"fixed"===l)&&-1<(o+u).indexOf("auto")?(a=(r=c.position()).top,i=r.left):(a=parseFloat(o)||0,i=parseFloat(u)||0),m(t)&&(t=t.call(e,n,k.extend({},s))),null!=t.top&&(f.top=t.top-s.top+a),null!=t.left&&(f.left=t.left-s.left+i),"using"in t?t.using.call(e,f):c.css(f)}},k.fn.extend({offset:function(t){if(arguments.length)return void 0===t?this:this.each(function(e){k.offset.setOffset(this,t,e)});var e,n,r=this[0];return r?r.getClientRects().length?(e=r.getBoundingClientRect(),n=r.ownerDocument.defaultView,{top:e.top+n.pageYOffset,left:e.left+n.pageXOffset}):{top:0,left:0}:void 0},position:function(){if(this[0]){var e,t,n,r=this[0],i={top:0,left:0};if("fixed"===k.css(r,"position"))t=r.getBoundingClientRect();else{t=this.offset(),n=r.ownerDocument,e=r.offsetParent||n.documentElement;while(e&&(e===n.body||e===n.documentElement)&&"static"===k.css(e,"position"))e=e.parentNode;e&&e!==r&&1===e.nodeType&&((i=k(e).offset()).top+=k.css(e,"borderTopWidth",!0),i.left+=k.css(e,"borderLeftWidth",!0))}return{top:t.top-i.top-k.css(r,"marginTop",!0),left:t.left-i.left-k.css(r,"marginLeft",!0)}}},offsetParent:function(){return this.map(function(){var e=this.offsetParent;while(e&&"static"===k.css(e,"position"))e=e.offsetParent;return e||ie})}}),k.each({scrollLeft:"pageXOffset",scrollTop:"pageYOffset"},function(t,i){var o="pageYOffset"===i;k.fn[t]=function(e){return _(this,function(e,t,n){var r;if(x(e)?r=e:9===e.nodeType&&(r=e.defaultView),void 0===n)return r?r[i]:e[t];r?r.scrollTo(o?r.pageXOffset:n,o?n:r.pageYOffset):e[t]=n},t,e,arguments.length)}}),k.each(["top","left"],function(e,n){k.cssHooks[n]=ze(y.pixelPosition,function(e,t){if(t)return t=_e(e,n),$e.test(t)?k(e).position()[n]+"px":t})}),k.each({Height:"height",Width:"width"},function(a,s){k.each({padding:"inner"+a,content:s,"":"outer"+a},function(r,o){k.fn[o]=function(e,t){var n=arguments.length&&(r||"boolean"!=typeof e),i=r||(!0===e||!0===t?"margin":"border");return _(this,function(e,t,n){var r;return x(e)?0===o.indexOf("outer")?e["inner"+a]:e.document.documentElement["client"+a]:9===e.nodeType?(r=e.documentElement,Math.max(e.body["scroll"+a],r["scroll"+a],e.body["offset"+a],r["offset"+a],r["client"+a])):void 0===n?k.css(e,t,i):k.style(e,t,n,i)},s,n?e:void 0,n)}})}),k.each("blur focus focusin focusout resize scroll click dblclick mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave change select submit keydown keypress keyup contextmenu".split(" "),function(e,n){k.fn[n]=function(e,t){return 0<arguments.length?this.on(n,null,e,t):this.trigger(n)}}),k.fn.extend({hover:function(e,t){return this.mouseenter(e).mouseleave(t||e)}}),k.fn.extend({bind:function(e,t,n){return this.on(e,null,t,n)},unbind:function(e,t){return this.off(e,null,t)},delegate:function(e,t,n,r){return this.on(t,e,n,r)},undelegate:function(e,t,n){return 1===arguments.length?this.off(e,"**"):this.off(t,e||"**",n)}}),k.proxy=function(e,t){var n,r,i;if("string"==typeof t&&(n=e[t],t=e,e=n),m(e))return r=s.call(arguments,2),(i=function(){return e.apply(t||this,r.concat(s.call(arguments)))}).guid=e.guid=e.guid||k.guid++,i},k.holdReady=function(e){e?k.readyWait++:k.ready(!0)},k.isArray=Array.isArray,k.parseJSON=JSON.parse,k.nodeName=A,k.isFunction=m,k.isWindow=x,k.camelCase=V,k.type=w,k.now=Date.now,k.isNumeric=function(e){var t=k.type(e);return("number"===t||"string"===t)&&!isNaN(e-parseFloat(e))},"function"==typeof define&&define.amd&&define("jquery",[],function(){return k});var Qt=C.jQuery,Jt=C.$;return k.noConflict=function(e){return C.$===k&&(C.$=Jt),e&&C.jQuery===k&&(C.jQuery=Qt),k},e||(C.jQuery=C.$=k),k});
+/*! jQuery UI - v1.12.1 - 2019-01-27
+* http://jqueryui.com
+* Includes: widget.js, position.js, data.js, disable-selection.js, focusable.js, form-reset-mixin.js, jquery-1-7.js, keycode.js, labels.js, scroll-parent.js, tabbable.js, unique-id.js, widgets/resizable.js, widgets/mouse.js
+* Copyright jQuery Foundation and other contributors; Licensed MIT */
+
+(function(t){"function"==typeof define&&define.amd?define(["jquery"],t):t(jQuery)})(function(t){function e(t){for(var e=t.css("visibility");"inherit"===e;)t=t.parent(),e=t.css("visibility");return"hidden"!==e}t.ui=t.ui||{},t.ui.version="1.12.1";var i=0,s=Array.prototype.slice;t.cleanData=function(e){return function(i){var s,n,o;for(o=0;null!=(n=i[o]);o++)try{s=t._data(n,"events"),s&&s.remove&&t(n).triggerHandler("remove")}catch(a){}e(i)}}(t.cleanData),t.widget=function(e,i,s){var n,o,a,r={},h=e.split(".")[0];e=e.split(".")[1];var l=h+"-"+e;return s||(s=i,i=t.Widget),t.isArray(s)&&(s=t.extend.apply(null,[{}].concat(s))),t.expr[":"][l.toLowerCase()]=function(e){return!!t.data(e,l)},t[h]=t[h]||{},n=t[h][e],o=t[h][e]=function(t,e){return this._createWidget?(arguments.length&&this._createWidget(t,e),void 0):new o(t,e)},t.extend(o,n,{version:s.version,_proto:t.extend({},s),_childConstructors:[]}),a=new i,a.options=t.widget.extend({},a.options),t.each(s,function(e,s){return t.isFunction(s)?(r[e]=function(){function t(){return i.prototype[e].apply(this,arguments)}function n(t){return i.prototype[e].apply(this,t)}return function(){var e,i=this._super,o=this._superApply;return this._super=t,this._superApply=n,e=s.apply(this,arguments),this._super=i,this._superApply=o,e}}(),void 0):(r[e]=s,void 0)}),o.prototype=t.widget.extend(a,{widgetEventPrefix:n?a.widgetEventPrefix||e:e},r,{constructor:o,namespace:h,widgetName:e,widgetFullName:l}),n?(t.each(n._childConstructors,function(e,i){var s=i.prototype;t.widget(s.namespace+"."+s.widgetName,o,i._proto)}),delete n._childConstructors):i._childConstructors.push(o),t.widget.bridge(e,o),o},t.widget.extend=function(e){for(var i,n,o=s.call(arguments,1),a=0,r=o.length;r>a;a++)for(i in o[a])n=o[a][i],o[a].hasOwnProperty(i)&&void 0!==n&&(e[i]=t.isPlainObject(n)?t.isPlainObject(e[i])?t.widget.extend({},e[i],n):t.widget.extend({},n):n);return e},t.widget.bridge=function(e,i){var n=i.prototype.widgetFullName||e;t.fn[e]=function(o){var a="string"==typeof o,r=s.call(arguments,1),h=this;return a?this.length||"instance"!==o?this.each(function(){var i,s=t.data(this,n);return"instance"===o?(h=s,!1):s?t.isFunction(s[o])&&"_"!==o.charAt(0)?(i=s[o].apply(s,r),i!==s&&void 0!==i?(h=i&&i.jquery?h.pushStack(i.get()):i,!1):void 0):t.error("no such method '"+o+"' for "+e+" widget instance"):t.error("cannot call methods on "+e+" prior to initialization; "+"attempted to call method '"+o+"'")}):h=void 0:(r.length&&(o=t.widget.extend.apply(null,[o].concat(r))),this.each(function(){var e=t.data(this,n);e?(e.option(o||{}),e._init&&e._init()):t.data(this,n,new i(o,this))})),h}},t.Widget=function(){},t.Widget._childConstructors=[],t.Widget.prototype={widgetName:"widget",widgetEventPrefix:"",defaultElement:"<div>",options:{classes:{},disabled:!1,create:null},_createWidget:function(e,s){s=t(s||this.defaultElement||this)[0],this.element=t(s),this.uuid=i++,this.eventNamespace="."+this.widgetName+this.uuid,this.bindings=t(),this.hoverable=t(),this.focusable=t(),this.classesElementLookup={},s!==this&&(t.data(s,this.widgetFullName,this),this._on(!0,this.element,{remove:function(t){t.target===s&&this.destroy()}}),this.document=t(s.style?s.ownerDocument:s.document||s),this.window=t(this.document[0].defaultView||this.document[0].parentWindow)),this.options=t.widget.extend({},this.options,this._getCreateOptions(),e),this._create(),this.options.disabled&&this._setOptionDisabled(this.options.disabled),this._trigger("create",null,this._getCreateEventData()),this._init()},_getCreateOptions:function(){return{}},_getCreateEventData:t.noop,_create:t.noop,_init:t.noop,destroy:function(){var e=this;this._destroy(),t.each(this.classesElementLookup,function(t,i){e._removeClass(i,t)}),this.element.off(this.eventNamespace).removeData(this.widgetFullName),this.widget().off(this.eventNamespace).removeAttr("aria-disabled"),this.bindings.off(this.eventNamespace)},_destroy:t.noop,widget:function(){return this.element},option:function(e,i){var s,n,o,a=e;if(0===arguments.length)return t.widget.extend({},this.options);if("string"==typeof e)if(a={},s=e.split("."),e=s.shift(),s.length){for(n=a[e]=t.widget.extend({},this.options[e]),o=0;s.length-1>o;o++)n[s[o]]=n[s[o]]||{},n=n[s[o]];if(e=s.pop(),1===arguments.length)return void 0===n[e]?null:n[e];n[e]=i}else{if(1===arguments.length)return void 0===this.options[e]?null:this.options[e];a[e]=i}return this._setOptions(a),this},_setOptions:function(t){var e;for(e in t)this._setOption(e,t[e]);return this},_setOption:function(t,e){return"classes"===t&&this._setOptionClasses(e),this.options[t]=e,"disabled"===t&&this._setOptionDisabled(e),this},_setOptionClasses:function(e){var i,s,n;for(i in e)n=this.classesElementLookup[i],e[i]!==this.options.classes[i]&&n&&n.length&&(s=t(n.get()),this._removeClass(n,i),s.addClass(this._classes({element:s,keys:i,classes:e,add:!0})))},_setOptionDisabled:function(t){this._toggleClass(this.widget(),this.widgetFullName+"-disabled",null,!!t),t&&(this._removeClass(this.hoverable,null,"ui-state-hover"),this._removeClass(this.focusable,null,"ui-state-focus"))},enable:function(){return this._setOptions({disabled:!1})},disable:function(){return this._setOptions({disabled:!0})},_classes:function(e){function i(i,o){var a,r;for(r=0;i.length>r;r++)a=n.classesElementLookup[i[r]]||t(),a=e.add?t(t.unique(a.get().concat(e.element.get()))):t(a.not(e.element).get()),n.classesElementLookup[i[r]]=a,s.push(i[r]),o&&e.classes[i[r]]&&s.push(e.classes[i[r]])}var s=[],n=this;return e=t.extend({element:this.element,classes:this.options.classes||{}},e),this._on(e.element,{remove:"_untrackClassesElement"}),e.keys&&i(e.keys.match(/\S+/g)||[],!0),e.extra&&i(e.extra.match(/\S+/g)||[]),s.join(" ")},_untrackClassesElement:function(e){var i=this;t.each(i.classesElementLookup,function(s,n){-1!==t.inArray(e.target,n)&&(i.classesElementLookup[s]=t(n.not(e.target).get()))})},_removeClass:function(t,e,i){return this._toggleClass(t,e,i,!1)},_addClass:function(t,e,i){return this._toggleClass(t,e,i,!0)},_toggleClass:function(t,e,i,s){s="boolean"==typeof s?s:i;var n="string"==typeof t||null===t,o={extra:n?e:i,keys:n?t:e,element:n?this.element:t,add:s};return o.element.toggleClass(this._classes(o),s),this},_on:function(e,i,s){var n,o=this;"boolean"!=typeof e&&(s=i,i=e,e=!1),s?(i=n=t(i),this.bindings=this.bindings.add(i)):(s=i,i=this.element,n=this.widget()),t.each(s,function(s,a){function r(){return e||o.options.disabled!==!0&&!t(this).hasClass("ui-state-disabled")?("string"==typeof a?o[a]:a).apply(o,arguments):void 0}"string"!=typeof a&&(r.guid=a.guid=a.guid||r.guid||t.guid++);var h=s.match(/^([\w:-]*)\s*(.*)$/),l=h[1]+o.eventNamespace,c=h[2];c?n.on(l,c,r):i.on(l,r)})},_off:function(e,i){i=(i||"").split(" ").join(this.eventNamespace+" ")+this.eventNamespace,e.off(i).off(i),this.bindings=t(this.bindings.not(e).get()),this.focusable=t(this.focusable.not(e).get()),this.hoverable=t(this.hoverable.not(e).get())},_delay:function(t,e){function i(){return("string"==typeof t?s[t]:t).apply(s,arguments)}var s=this;return setTimeout(i,e||0)},_hoverable:function(e){this.hoverable=this.hoverable.add(e),this._on(e,{mouseenter:function(e){this._addClass(t(e.currentTarget),null,"ui-state-hover")},mouseleave:function(e){this._removeClass(t(e.currentTarget),null,"ui-state-hover")}})},_focusable:function(e){this.focusable=this.focusable.add(e),this._on(e,{focusin:function(e){this._addClass(t(e.currentTarget),null,"ui-state-focus")},focusout:function(e){this._removeClass(t(e.currentTarget),null,"ui-state-focus")}})},_trigger:function(e,i,s){var n,o,a=this.options[e];if(s=s||{},i=t.Event(i),i.type=(e===this.widgetEventPrefix?e:this.widgetEventPrefix+e).toLowerCase(),i.target=this.element[0],o=i.originalEvent)for(n in o)n in i||(i[n]=o[n]);return this.element.trigger(i,s),!(t.isFunction(a)&&a.apply(this.element[0],[i].concat(s))===!1||i.isDefaultPrevented())}},t.each({show:"fadeIn",hide:"fadeOut"},function(e,i){t.Widget.prototype["_"+e]=function(s,n,o){"string"==typeof n&&(n={effect:n});var a,r=n?n===!0||"number"==typeof n?i:n.effect||i:e;n=n||{},"number"==typeof n&&(n={duration:n}),a=!t.isEmptyObject(n),n.complete=o,n.delay&&s.delay(n.delay),a&&t.effects&&t.effects.effect[r]?s[e](n):r!==e&&s[r]?s[r](n.duration,n.easing,o):s.queue(function(i){t(this)[e](),o&&o.call(s[0]),i()})}}),t.widget,function(){function e(t,e,i){return[parseFloat(t[0])*(u.test(t[0])?e/100:1),parseFloat(t[1])*(u.test(t[1])?i/100:1)]}function i(e,i){return parseInt(t.css(e,i),10)||0}function s(e){var i=e[0];return 9===i.nodeType?{width:e.width(),height:e.height(),offset:{top:0,left:0}}:t.isWindow(i)?{width:e.width(),height:e.height(),offset:{top:e.scrollTop(),left:e.scrollLeft()}}:i.preventDefault?{width:0,height:0,offset:{top:i.pageY,left:i.pageX}}:{width:e.outerWidth(),height:e.outerHeight(),offset:e.offset()}}var n,o=Math.max,a=Math.abs,r=/left|center|right/,h=/top|center|bottom/,l=/[\+\-]\d+(\.[\d]+)?%?/,c=/^\w+/,u=/%$/,d=t.fn.position;t.position={scrollbarWidth:function(){if(void 0!==n)return n;var e,i,s=t("<div style='display:block;position:absolute;width:50px;height:50px;overflow:hidden;'><div style='height:100px;width:auto;'></div></div>"),o=s.children()[0];return t("body").append(s),e=o.offsetWidth,s.css("overflow","scroll"),i=o.offsetWidth,e===i&&(i=s[0].clientWidth),s.remove(),n=e-i},getScrollInfo:function(e){var i=e.isWindow||e.isDocument?"":e.element.css("overflow-x"),s=e.isWindow||e.isDocument?"":e.element.css("overflow-y"),n="scroll"===i||"auto"===i&&e.width<e.element[0].scrollWidth,o="scroll"===s||"auto"===s&&e.height<e.element[0].scrollHeight;return{width:o?t.position.scrollbarWidth():0,height:n?t.position.scrollbarWidth():0}},getWithinInfo:function(e){var i=t(e||window),s=t.isWindow(i[0]),n=!!i[0]&&9===i[0].nodeType,o=!s&&!n;return{element:i,isWindow:s,isDocument:n,offset:o?t(e).offset():{left:0,top:0},scrollLeft:i.scrollLeft(),scrollTop:i.scrollTop(),width:i.outerWidth(),height:i.outerHeight()}}},t.fn.position=function(n){if(!n||!n.of)return d.apply(this,arguments);n=t.extend({},n);var u,p,f,m,g,_,v=t(n.of),b=t.position.getWithinInfo(n.within),y=t.position.getScrollInfo(b),w=(n.collision||"flip").split(" "),x={};return _=s(v),v[0].preventDefault&&(n.at="left top"),p=_.width,f=_.height,m=_.offset,g=t.extend({},m),t.each(["my","at"],function(){var t,e,i=(n[this]||"").split(" ");1===i.length&&(i=r.test(i[0])?i.concat(["center"]):h.test(i[0])?["center"].concat(i):["center","center"]),i[0]=r.test(i[0])?i[0]:"center",i[1]=h.test(i[1])?i[1]:"center",t=l.exec(i[0]),e=l.exec(i[1]),x[this]=[t?t[0]:0,e?e[0]:0],n[this]=[c.exec(i[0])[0],c.exec(i[1])[0]]}),1===w.length&&(w[1]=w[0]),"right"===n.at[0]?g.left+=p:"center"===n.at[0]&&(g.left+=p/2),"bottom"===n.at[1]?g.top+=f:"center"===n.at[1]&&(g.top+=f/2),u=e(x.at,p,f),g.left+=u[0],g.top+=u[1],this.each(function(){var s,r,h=t(this),l=h.outerWidth(),c=h.outerHeight(),d=i(this,"marginLeft"),_=i(this,"marginTop"),k=l+d+i(this,"marginRight")+y.width,C=c+_+i(this,"marginBottom")+y.height,D=t.extend({},g),T=e(x.my,h.outerWidth(),h.outerHeight());"right"===n.my[0]?D.left-=l:"center"===n.my[0]&&(D.left-=l/2),"bottom"===n.my[1]?D.top-=c:"center"===n.my[1]&&(D.top-=c/2),D.left+=T[0],D.top+=T[1],s={marginLeft:d,marginTop:_},t.each(["left","top"],function(e,i){t.ui.position[w[e]]&&t.ui.position[w[e]][i](D,{targetWidth:p,targetHeight:f,elemWidth:l,elemHeight:c,collisionPosition:s,collisionWidth:k,collisionHeight:C,offset:[u[0]+T[0],u[1]+T[1]],my:n.my,at:n.at,within:b,elem:h})}),n.using&&(r=function(t){var e=m.left-D.left,i=e+p-l,s=m.top-D.top,r=s+f-c,u={target:{element:v,left:m.left,top:m.top,width:p,height:f},element:{element:h,left:D.left,top:D.top,width:l,height:c},horizontal:0>i?"left":e>0?"right":"center",vertical:0>r?"top":s>0?"bottom":"middle"};l>p&&p>a(e+i)&&(u.horizontal="center"),c>f&&f>a(s+r)&&(u.vertical="middle"),u.important=o(a(e),a(i))>o(a(s),a(r))?"horizontal":"vertical",n.using.call(this,t,u)}),h.offset(t.extend(D,{using:r}))})},t.ui.position={fit:{left:function(t,e){var i,s=e.within,n=s.isWindow?s.scrollLeft:s.offset.left,a=s.width,r=t.left-e.collisionPosition.marginLeft,h=n-r,l=r+e.collisionWidth-a-n;e.collisionWidth>a?h>0&&0>=l?(i=t.left+h+e.collisionWidth-a-n,t.left+=h-i):t.left=l>0&&0>=h?n:h>l?n+a-e.collisionWidth:n:h>0?t.left+=h:l>0?t.left-=l:t.left=o(t.left-r,t.left)},top:function(t,e){var i,s=e.within,n=s.isWindow?s.scrollTop:s.offset.top,a=e.within.height,r=t.top-e.collisionPosition.marginTop,h=n-r,l=r+e.collisionHeight-a-n;e.collisionHeight>a?h>0&&0>=l?(i=t.top+h+e.collisionHeight-a-n,t.top+=h-i):t.top=l>0&&0>=h?n:h>l?n+a-e.collisionHeight:n:h>0?t.top+=h:l>0?t.top-=l:t.top=o(t.top-r,t.top)}},flip:{left:function(t,e){var i,s,n=e.within,o=n.offset.left+n.scrollLeft,r=n.width,h=n.isWindow?n.scrollLeft:n.offset.left,l=t.left-e.collisionPosition.marginLeft,c=l-h,u=l+e.collisionWidth-r-h,d="left"===e.my[0]?-e.elemWidth:"right"===e.my[0]?e.elemWidth:0,p="left"===e.at[0]?e.targetWidth:"right"===e.at[0]?-e.targetWidth:0,f=-2*e.offset[0];0>c?(i=t.left+d+p+f+e.collisionWidth-r-o,(0>i||a(c)>i)&&(t.left+=d+p+f)):u>0&&(s=t.left-e.collisionPosition.marginLeft+d+p+f-h,(s>0||u>a(s))&&(t.left+=d+p+f))},top:function(t,e){var i,s,n=e.within,o=n.offset.top+n.scrollTop,r=n.height,h=n.isWindow?n.scrollTop:n.offset.top,l=t.top-e.collisionPosition.marginTop,c=l-h,u=l+e.collisionHeight-r-h,d="top"===e.my[1],p=d?-e.elemHeight:"bottom"===e.my[1]?e.elemHeight:0,f="top"===e.at[1]?e.targetHeight:"bottom"===e.at[1]?-e.targetHeight:0,m=-2*e.offset[1];0>c?(s=t.top+p+f+m+e.collisionHeight-r-o,(0>s||a(c)>s)&&(t.top+=p+f+m)):u>0&&(i=t.top-e.collisionPosition.marginTop+p+f+m-h,(i>0||u>a(i))&&(t.top+=p+f+m))}},flipfit:{left:function(){t.ui.position.flip.left.apply(this,arguments),t.ui.position.fit.left.apply(this,arguments)},top:function(){t.ui.position.flip.top.apply(this,arguments),t.ui.position.fit.top.apply(this,arguments)}}}}(),t.ui.position,t.extend(t.expr[":"],{data:t.expr.createPseudo?t.expr.createPseudo(function(e){return function(i){return!!t.data(i,e)}}):function(e,i,s){return!!t.data(e,s[3])}}),t.fn.extend({disableSelection:function(){var t="onselectstart"in document.createElement("div")?"selectstart":"mousedown";return function(){return this.on(t+".ui-disableSelection",function(t){t.preventDefault()})}}(),enableSelection:function(){return this.off(".ui-disableSelection")}}),t.ui.focusable=function(i,s){var n,o,a,r,h,l=i.nodeName.toLowerCase();return"area"===l?(n=i.parentNode,o=n.name,i.href&&o&&"map"===n.nodeName.toLowerCase()?(a=t("img[usemap='#"+o+"']"),a.length>0&&a.is(":visible")):!1):(/^(input|select|textarea|button|object)$/.test(l)?(r=!i.disabled,r&&(h=t(i).closest("fieldset")[0],h&&(r=!h.disabled))):r="a"===l?i.href||s:s,r&&t(i).is(":visible")&&e(t(i)))},t.extend(t.expr[":"],{focusable:function(e){return t.ui.focusable(e,null!=t.attr(e,"tabindex"))}}),t.ui.focusable,t.fn.form=function(){return"string"==typeof this[0].form?this.closest("form"):t(this[0].form)},t.ui.formResetMixin={_formResetHandler:function(){var e=t(this);setTimeout(function(){var i=e.data("ui-form-reset-instances");t.each(i,function(){this.refresh()})})},_bindFormResetHandler:function(){if(this.form=this.element.form(),this.form.length){var t=this.form.data("ui-form-reset-instances")||[];t.length||this.form.on("reset.ui-form-reset",this._formResetHandler),t.push(this),this.form.data("ui-form-reset-instances",t)}},_unbindFormResetHandler:function(){if(this.form.length){var e=this.form.data("ui-form-reset-instances");e.splice(t.inArray(this,e),1),e.length?this.form.data("ui-form-reset-instances",e):this.form.removeData("ui-form-reset-instances").off("reset.ui-form-reset")}}},"1.7"===t.fn.jquery.substring(0,3)&&(t.each(["Width","Height"],function(e,i){function s(e,i,s,o){return t.each(n,function(){i-=parseFloat(t.css(e,"padding"+this))||0,s&&(i-=parseFloat(t.css(e,"border"+this+"Width"))||0),o&&(i-=parseFloat(t.css(e,"margin"+this))||0)}),i}var n="Width"===i?["Left","Right"]:["Top","Bottom"],o=i.toLowerCase(),a={innerWidth:t.fn.innerWidth,innerHeight:t.fn.innerHeight,outerWidth:t.fn.outerWidth,outerHeight:t.fn.outerHeight};t.fn["inner"+i]=function(e){return void 0===e?a["inner"+i].call(this):this.each(function(){t(this).css(o,s(this,e)+"px")})},t.fn["outer"+i]=function(e,n){return"number"!=typeof e?a["outer"+i].call(this,e):this.each(function(){t(this).css(o,s(this,e,!0,n)+"px")})}}),t.fn.addBack=function(t){return this.add(null==t?this.prevObject:this.prevObject.filter(t))}),t.ui.keyCode={BACKSPACE:8,COMMA:188,DELETE:46,DOWN:40,END:35,ENTER:13,ESCAPE:27,HOME:36,LEFT:37,PAGE_DOWN:34,PAGE_UP:33,PERIOD:190,RIGHT:39,SPACE:32,TAB:9,UP:38},t.ui.escapeSelector=function(){var t=/([!"#$%&'()*+,./:;<=>?@[\]^`{|}~])/g;return function(e){return e.replace(t,"\\$1")}}(),t.fn.labels=function(){var e,i,s,n,o;return this[0].labels&&this[0].labels.length?this.pushStack(this[0].labels):(n=this.eq(0).parents("label"),s=this.attr("id"),s&&(e=this.eq(0).parents().last(),o=e.add(e.length?e.siblings():this.siblings()),i="label[for='"+t.ui.escapeSelector(s)+"']",n=n.add(o.find(i).addBack(i))),this.pushStack(n))},t.fn.scrollParent=function(e){var i=this.css("position"),s="absolute"===i,n=e?/(auto|scroll|hidden)/:/(auto|scroll)/,o=this.parents().filter(function(){var e=t(this);return s&&"static"===e.css("position")?!1:n.test(e.css("overflow")+e.css("overflow-y")+e.css("overflow-x"))}).eq(0);return"fixed"!==i&&o.length?o:t(this[0].ownerDocument||document)},t.extend(t.expr[":"],{tabbable:function(e){var i=t.attr(e,"tabindex"),s=null!=i;return(!s||i>=0)&&t.ui.focusable(e,s)}}),t.fn.extend({uniqueId:function(){var t=0;return function(){return this.each(function(){this.id||(this.id="ui-id-"+ ++t)})}}(),removeUniqueId:function(){return this.each(function(){/^ui-id-\d+$/.test(this.id)&&t(this).removeAttr("id")})}}),t.ui.ie=!!/msie [\w.]+/.exec(navigator.userAgent.toLowerCase());var n=!1;t(document).on("mouseup",function(){n=!1}),t.widget("ui.mouse",{version:"1.12.1",options:{cancel:"input, textarea, button, select, option",distance:1,delay:0},_mouseInit:function(){var e=this;this.element.on("mousedown."+this.widgetName,function(t){return e._mouseDown(t)}).on("click."+this.widgetName,function(i){return!0===t.data(i.target,e.widgetName+".preventClickEvent")?(t.removeData(i.target,e.widgetName+".preventClickEvent"),i.stopImmediatePropagation(),!1):void 0}),this.started=!1},_mouseDestroy:function(){this.element.off("."+this.widgetName),this._mouseMoveDelegate&&this.document.off("mousemove."+this.widgetName,this._mouseMoveDelegate).off("mouseup."+this.widgetName,this._mouseUpDelegate)},_mouseDown:function(e){if(!n){this._mouseMoved=!1,this._mouseStarted&&this._mouseUp(e),this._mouseDownEvent=e;var i=this,s=1===e.which,o="string"==typeof this.options.cancel&&e.target.nodeName?t(e.target).closest(this.options.cancel).length:!1;return s&&!o&&this._mouseCapture(e)?(this.mouseDelayMet=!this.options.delay,this.mouseDelayMet||(this._mouseDelayTimer=setTimeout(function(){i.mouseDelayMet=!0},this.options.delay)),this._mouseDistanceMet(e)&&this._mouseDelayMet(e)&&(this._mouseStarted=this._mouseStart(e)!==!1,!this._mouseStarted)?(e.preventDefault(),!0):(!0===t.data(e.target,this.widgetName+".preventClickEvent")&&t.removeData(e.target,this.widgetName+".preventClickEvent"),this._mouseMoveDelegate=function(t){return i._mouseMove(t)},this._mouseUpDelegate=function(t){return i._mouseUp(t)},this.document.on("mousemove."+this.widgetName,this._mouseMoveDelegate).on("mouseup."+this.widgetName,this._mouseUpDelegate),e.preventDefault(),n=!0,!0)):!0}},_mouseMove:function(e){if(this._mouseMoved){if(t.ui.ie&&(!document.documentMode||9>document.documentMode)&&!e.button)return this._mouseUp(e);if(!e.which)if(e.originalEvent.altKey||e.originalEvent.ctrlKey||e.originalEvent.metaKey||e.originalEvent.shiftKey)this.ignoreMissingWhich=!0;else if(!this.ignoreMissingWhich)return this._mouseUp(e)}return(e.which||e.button)&&(this._mouseMoved=!0),this._mouseStarted?(this._mouseDrag(e),e.preventDefault()):(this._mouseDistanceMet(e)&&this._mouseDelayMet(e)&&(this._mouseStarted=this._mouseStart(this._mouseDownEvent,e)!==!1,this._mouseStarted?this._mouseDrag(e):this._mouseUp(e)),!this._mouseStarted)},_mouseUp:function(e){this.document.off("mousemove."+this.widgetName,this._mouseMoveDelegate).off("mouseup."+this.widgetName,this._mouseUpDelegate),this._mouseStarted&&(this._mouseStarted=!1,e.target===this._mouseDownEvent.target&&t.data(e.target,this.widgetName+".preventClickEvent",!0),this._mouseStop(e)),this._mouseDelayTimer&&(clearTimeout(this._mouseDelayTimer),delete this._mouseDelayTimer),this.ignoreMissingWhich=!1,n=!1,e.preventDefault()},_mouseDistanceMet:function(t){return Math.max(Math.abs(this._mouseDownEvent.pageX-t.pageX),Math.abs(this._mouseDownEvent.pageY-t.pageY))>=this.options.distance},_mouseDelayMet:function(){return this.mouseDelayMet},_mouseStart:function(){},_mouseDrag:function(){},_mouseStop:function(){},_mouseCapture:function(){return!0}}),t.ui.plugin={add:function(e,i,s){var n,o=t.ui[e].prototype;for(n in s)o.plugins[n]=o.plugins[n]||[],o.plugins[n].push([i,s[n]])},call:function(t,e,i,s){var n,o=t.plugins[e];if(o&&(s||t.element[0].parentNode&&11!==t.element[0].parentNode.nodeType))for(n=0;o.length>n;n++)t.options[o[n][0]]&&o[n][1].apply(t.element,i)}},t.widget("ui.resizable",t.ui.mouse,{version:"1.12.1",widgetEventPrefix:"resize",options:{alsoResize:!1,animate:!1,animateDuration:"slow",animateEasing:"swing",aspectRatio:!1,autoHide:!1,classes:{"ui-resizable-se":"ui-icon ui-icon-gripsmall-diagonal-se"},containment:!1,ghost:!1,grid:!1,handles:"e,s,se",helper:!1,maxHeight:null,maxWidth:null,minHeight:10,minWidth:10,zIndex:90,resize:null,start:null,stop:null},_num:function(t){return parseFloat(t)||0},_isNumber:function(t){return!isNaN(parseFloat(t))},_hasScroll:function(e,i){if("hidden"===t(e).css("overflow"))return!1;var s=i&&"left"===i?"scrollLeft":"scrollTop",n=!1;return e[s]>0?!0:(e[s]=1,n=e[s]>0,e[s]=0,n)},_create:function(){var e,i=this.options,s=this;this._addClass("ui-resizable"),t.extend(this,{_aspectRatio:!!i.aspectRatio,aspectRatio:i.aspectRatio,originalElement:this.element,_proportionallyResizeElements:[],_helper:i.helper||i.ghost||i.animate?i.helper||"ui-resizable-helper":null}),this.element[0].nodeName.match(/^(canvas|textarea|input|select|button|img)$/i)&&(this.element.wrap(t("<div class='ui-wrapper' style='overflow: hidden;'></div>").css({position:this.element.css("position"),width:this.element.outerWidth(),height:this.element.outerHeight(),top:this.element.css("top"),left:this.element.css("left")})),this.element=this.element.parent().data("ui-resizable",this.element.resizable("instance")),this.elementIsWrapper=!0,e={marginTop:this.originalElement.css("marginTop"),marginRight:this.originalElement.css("marginRight"),marginBottom:this.originalElement.css("marginBottom"),marginLeft:this.originalElement.css("marginLeft")},this.element.css(e),this.originalElement.css("margin",0),this.originalResizeStyle=this.originalElement.css("resize"),this.originalElement.css("resize","none"),this._proportionallyResizeElements.push(this.originalElement.css({position:"static",zoom:1,display:"block"})),this.originalElement.css(e),this._proportionallyResize()),this._setupHandles(),i.autoHide&&t(this.element).on("mouseenter",function(){i.disabled||(s._removeClass("ui-resizable-autohide"),s._handles.show())}).on("mouseleave",function(){i.disabled||s.resizing||(s._addClass("ui-resizable-autohide"),s._handles.hide())}),this._mouseInit()},_destroy:function(){this._mouseDestroy();var e,i=function(e){t(e).removeData("resizable").removeData("ui-resizable").off(".resizable").find(".ui-resizable-handle").remove()};return this.elementIsWrapper&&(i(this.element),e=this.element,this.originalElement.css({position:e.css("position"),width:e.outerWidth(),height:e.outerHeight(),top:e.css("top"),left:e.css("left")}).insertAfter(e),e.remove()),this.originalElement.css("resize",this.originalResizeStyle),i(this.originalElement),this},_setOption:function(t,e){switch(this._super(t,e),t){case"handles":this._removeHandles(),this._setupHandles();break;default:}},_setupHandles:function(){var e,i,s,n,o,a=this.options,r=this;if(this.handles=a.handles||(t(".ui-resizable-handle",this.element).length?{n:".ui-resizable-n",e:".ui-resizable-e",s:".ui-resizable-s",w:".ui-resizable-w",se:".ui-resizable-se",sw:".ui-resizable-sw",ne:".ui-resizable-ne",nw:".ui-resizable-nw"}:"e,s,se"),this._handles=t(),this.handles.constructor===String)for("all"===this.handles&&(this.handles="n,e,s,w,se,sw,ne,nw"),s=this.handles.split(","),this.handles={},i=0;s.length>i;i++)e=t.trim(s[i]),n="ui-resizable-"+e,o=t("<div>"),this._addClass(o,"ui-resizable-handle "+n),o.css({zIndex:a.zIndex}),this.handles[e]=".ui-resizable-"+e,this.element.append(o);this._renderAxis=function(e){var i,s,n,o;e=e||this.element;for(i in this.handles)this.handles[i].constructor===String?this.handles[i]=this.element.children(this.handles[i]).first().show():(this.handles[i].jquery||this.handles[i].nodeType)&&(this.handles[i]=t(this.handles[i]),this._on(this.handles[i],{mousedown:r._mouseDown})),this.elementIsWrapper&&this.originalElement[0].nodeName.match(/^(textarea|input|select|button)$/i)&&(s=t(this.handles[i],this.element),o=/sw|ne|nw|se|n|s/.test(i)?s.outerHeight():s.outerWidth(),n=["padding",/ne|nw|n/.test(i)?"Top":/se|sw|s/.test(i)?"Bottom":/^e$/.test(i)?"Right":"Left"].join(""),e.css(n,o),this._proportionallyResize()),this._handles=this._handles.add(this.handles[i])},this._renderAxis(this.element),this._handles=this._handles.add(this.element.find(".ui-resizable-handle")),this._handles.disableSelection(),this._handles.on("mouseover",function(){r.resizing||(this.className&&(o=this.className.match(/ui-resizable-(se|sw|ne|nw|n|e|s|w)/i)),r.axis=o&&o[1]?o[1]:"se")}),a.autoHide&&(this._handles.hide(),this._addClass("ui-resizable-autohide"))},_removeHandles:function(){this._handles.remove()},_mouseCapture:function(e){var i,s,n=!1;for(i in this.handles)s=t(this.handles[i])[0],(s===e.target||t.contains(s,e.target))&&(n=!0);return!this.options.disabled&&n},_mouseStart:function(e){var i,s,n,o=this.options,a=this.element;return this.resizing=!0,this._renderProxy(),i=this._num(this.helper.css("left")),s=this._num(this.helper.css("top")),o.containment&&(i+=t(o.containment).scrollLeft()||0,s+=t(o.containment).scrollTop()||0),this.offset=this.helper.offset(),this.position={left:i,top:s},this.size=this._helper?{width:this.helper.width(),height:this.helper.height()}:{width:a.width(),height:a.height()},this.originalSize=this._helper?{width:a.outerWidth(),height:a.outerHeight()}:{width:a.width(),height:a.height()},this.sizeDiff={width:a.outerWidth()-a.width(),height:a.outerHeight()-a.height()},this.originalPosition={left:i,top:s},this.originalMousePosition={left:e.pageX,top:e.pageY},this.aspectRatio="number"==typeof o.aspectRatio?o.aspectRatio:this.originalSize.width/this.originalSize.height||1,n=t(".ui-resizable-"+this.axis).css("cursor"),t("body").css("cursor","auto"===n?this.axis+"-resize":n),this._addClass("ui-resizable-resizing"),this._propagate("start",e),!0},_mouseDrag:function(e){var i,s,n=this.originalMousePosition,o=this.axis,a=e.pageX-n.left||0,r=e.pageY-n.top||0,h=this._change[o];return this._updatePrevProperties(),h?(i=h.apply(this,[e,a,r]),this._updateVirtualBoundaries(e.shiftKey),(this._aspectRatio||e.shiftKey)&&(i=this._updateRatio(i,e)),i=this._respectSize(i,e),this._updateCache(i),this._propagate("resize",e),s=this._applyChanges(),!this._helper&&this._proportionallyResizeElements.length&&this._proportionallyResize(),t.isEmptyObject(s)||(this._updatePrevProperties(),this._trigger("resize",e,this.ui()),this._applyChanges()),!1):!1},_mouseStop:function(e){this.resizing=!1;var i,s,n,o,a,r,h,l=this.options,c=this;return this._helper&&(i=this._proportionallyResizeElements,s=i.length&&/textarea/i.test(i[0].nodeName),n=s&&this._hasScroll(i[0],"left")?0:c.sizeDiff.height,o=s?0:c.sizeDiff.width,a={width:c.helper.width()-o,height:c.helper.height()-n},r=parseFloat(c.element.css("left"))+(c.position.left-c.originalPosition.left)||null,h=parseFloat(c.element.css("top"))+(c.position.top-c.originalPosition.top)||null,l.animate||this.element.css(t.extend(a,{top:h,left:r})),c.helper.height(c.size.height),c.helper.width(c.size.width),this._helper&&!l.animate&&this._proportionallyResize()),t("body").css("cursor","auto"),this._removeClass("ui-resizable-resizing"),this._propagate("stop",e),this._helper&&this.helper.remove(),!1},_updatePrevProperties:function(){this.prevPosition={top:this.position.top,left:this.position.left},this.prevSize={width:this.size.width,height:this.size.height}},_applyChanges:function(){var t={};return this.position.top!==this.prevPosition.top&&(t.top=this.position.top+"px"),this.position.left!==this.prevPosition.left&&(t.left=this.position.left+"px"),this.size.width!==this.prevSize.width&&(t.width=this.size.width+"px"),this.size.height!==this.prevSize.height&&(t.height=this.size.height+"px"),this.helper.css(t),t},_updateVirtualBoundaries:function(t){var e,i,s,n,o,a=this.options;o={minWidth:this._isNumber(a.minWidth)?a.minWidth:0,maxWidth:this._isNumber(a.maxWidth)?a.maxWidth:1/0,minHeight:this._isNumber(a.minHeight)?a.minHeight:0,maxHeight:this._isNumber(a.maxHeight)?a.maxHeight:1/0},(this._aspectRatio||t)&&(e=o.minHeight*this.aspectRatio,s=o.minWidth/this.aspectRatio,i=o.maxHeight*this.aspectRatio,n=o.maxWidth/this.aspectRatio,e>o.minWidth&&(o.minWidth=e),s>o.minHeight&&(o.minHeight=s),o.maxWidth>i&&(o.maxWidth=i),o.maxHeight>n&&(o.maxHeight=n)),this._vBoundaries=o},_updateCache:function(t){this.offset=this.helper.offset(),this._isNumber(t.left)&&(this.position.left=t.left),this._isNumber(t.top)&&(this.position.top=t.top),this._isNumber(t.height)&&(this.size.height=t.height),this._isNumber(t.width)&&(this.size.width=t.width)},_updateRatio:function(t){var e=this.position,i=this.size,s=this.axis;return this._isNumber(t.height)?t.width=t.height*this.aspectRatio:this._isNumber(t.width)&&(t.height=t.width/this.aspectRatio),"sw"===s&&(t.left=e.left+(i.width-t.width),t.top=null),"nw"===s&&(t.top=e.top+(i.height-t.height),t.left=e.left+(i.width-t.width)),t},_respectSize:function(t){var e=this._vBoundaries,i=this.axis,s=this._isNumber(t.width)&&e.maxWidth&&e.maxWidth<t.width,n=this._isNumber(t.height)&&e.maxHeight&&e.maxHeight<t.height,o=this._isNumber(t.width)&&e.minWidth&&e.minWidth>t.width,a=this._isNumber(t.height)&&e.minHeight&&e.minHeight>t.height,r=this.originalPosition.left+this.originalSize.width,h=this.originalPosition.top+this.originalSize.height,l=/sw|nw|w/.test(i),c=/nw|ne|n/.test(i);return o&&(t.width=e.minWidth),a&&(t.height=e.minHeight),s&&(t.width=e.maxWidth),n&&(t.height=e.maxHeight),o&&l&&(t.left=r-e.minWidth),s&&l&&(t.left=r-e.maxWidth),a&&c&&(t.top=h-e.minHeight),n&&c&&(t.top=h-e.maxHeight),t.width||t.height||t.left||!t.top?t.width||t.height||t.top||!t.left||(t.left=null):t.top=null,t},_getPaddingPlusBorderDimensions:function(t){for(var e=0,i=[],s=[t.css("borderTopWidth"),t.css("borderRightWidth"),t.css("borderBottomWidth"),t.css("borderLeftWidth")],n=[t.css("paddingTop"),t.css("paddingRight"),t.css("paddingBottom"),t.css("paddingLeft")];4>e;e++)i[e]=parseFloat(s[e])||0,i[e]+=parseFloat(n[e])||0;return{height:i[0]+i[2],width:i[1]+i[3]}},_proportionallyResize:function(){if(this._proportionallyResizeElements.length)for(var t,e=0,i=this.helper||this.element;this._proportionallyResizeElements.length>e;e++)t=this._proportionallyResizeElements[e],this.outerDimensions||(this.outerDimensions=this._getPaddingPlusBorderDimensions(t)),t.css({height:i.height()-this.outerDimensions.height||0,width:i.width()-this.outerDimensions.width||0})},_renderProxy:function(){var e=this.element,i=this.options;this.elementOffset=e.offset(),this._helper?(this.helper=this.helper||t("<div style='overflow:hidden;'></div>"),this._addClass(this.helper,this._helper),this.helper.css({width:this.element.outerWidth(),height:this.element.outerHeight(),position:"absolute",left:this.elementOffset.left+"px",top:this.elementOffset.top+"px",zIndex:++i.zIndex}),this.helper.appendTo("body").disableSelection()):this.helper=this.element
+},_change:{e:function(t,e){return{width:this.originalSize.width+e}},w:function(t,e){var i=this.originalSize,s=this.originalPosition;return{left:s.left+e,width:i.width-e}},n:function(t,e,i){var s=this.originalSize,n=this.originalPosition;return{top:n.top+i,height:s.height-i}},s:function(t,e,i){return{height:this.originalSize.height+i}},se:function(e,i,s){return t.extend(this._change.s.apply(this,arguments),this._change.e.apply(this,[e,i,s]))},sw:function(e,i,s){return t.extend(this._change.s.apply(this,arguments),this._change.w.apply(this,[e,i,s]))},ne:function(e,i,s){return t.extend(this._change.n.apply(this,arguments),this._change.e.apply(this,[e,i,s]))},nw:function(e,i,s){return t.extend(this._change.n.apply(this,arguments),this._change.w.apply(this,[e,i,s]))}},_propagate:function(e,i){t.ui.plugin.call(this,e,[i,this.ui()]),"resize"!==e&&this._trigger(e,i,this.ui())},plugins:{},ui:function(){return{originalElement:this.originalElement,element:this.element,helper:this.helper,position:this.position,size:this.size,originalSize:this.originalSize,originalPosition:this.originalPosition}}}),t.ui.plugin.add("resizable","animate",{stop:function(e){var i=t(this).resizable("instance"),s=i.options,n=i._proportionallyResizeElements,o=n.length&&/textarea/i.test(n[0].nodeName),a=o&&i._hasScroll(n[0],"left")?0:i.sizeDiff.height,r=o?0:i.sizeDiff.width,h={width:i.size.width-r,height:i.size.height-a},l=parseFloat(i.element.css("left"))+(i.position.left-i.originalPosition.left)||null,c=parseFloat(i.element.css("top"))+(i.position.top-i.originalPosition.top)||null;i.element.animate(t.extend(h,c&&l?{top:c,left:l}:{}),{duration:s.animateDuration,easing:s.animateEasing,step:function(){var s={width:parseFloat(i.element.css("width")),height:parseFloat(i.element.css("height")),top:parseFloat(i.element.css("top")),left:parseFloat(i.element.css("left"))};n&&n.length&&t(n[0]).css({width:s.width,height:s.height}),i._updateCache(s),i._propagate("resize",e)}})}}),t.ui.plugin.add("resizable","containment",{start:function(){var e,i,s,n,o,a,r,h=t(this).resizable("instance"),l=h.options,c=h.element,u=l.containment,d=u instanceof t?u.get(0):/parent/.test(u)?c.parent().get(0):u;d&&(h.containerElement=t(d),/document/.test(u)||u===document?(h.containerOffset={left:0,top:0},h.containerPosition={left:0,top:0},h.parentData={element:t(document),left:0,top:0,width:t(document).width(),height:t(document).height()||document.body.parentNode.scrollHeight}):(e=t(d),i=[],t(["Top","Right","Left","Bottom"]).each(function(t,s){i[t]=h._num(e.css("padding"+s))}),h.containerOffset=e.offset(),h.containerPosition=e.position(),h.containerSize={height:e.innerHeight()-i[3],width:e.innerWidth()-i[1]},s=h.containerOffset,n=h.containerSize.height,o=h.containerSize.width,a=h._hasScroll(d,"left")?d.scrollWidth:o,r=h._hasScroll(d)?d.scrollHeight:n,h.parentData={element:d,left:s.left,top:s.top,width:a,height:r}))},resize:function(e){var i,s,n,o,a=t(this).resizable("instance"),r=a.options,h=a.containerOffset,l=a.position,c=a._aspectRatio||e.shiftKey,u={top:0,left:0},d=a.containerElement,p=!0;d[0]!==document&&/static/.test(d.css("position"))&&(u=h),l.left<(a._helper?h.left:0)&&(a.size.width=a.size.width+(a._helper?a.position.left-h.left:a.position.left-u.left),c&&(a.size.height=a.size.width/a.aspectRatio,p=!1),a.position.left=r.helper?h.left:0),l.top<(a._helper?h.top:0)&&(a.size.height=a.size.height+(a._helper?a.position.top-h.top:a.position.top),c&&(a.size.width=a.size.height*a.aspectRatio,p=!1),a.position.top=a._helper?h.top:0),n=a.containerElement.get(0)===a.element.parent().get(0),o=/relative|absolute/.test(a.containerElement.css("position")),n&&o?(a.offset.left=a.parentData.left+a.position.left,a.offset.top=a.parentData.top+a.position.top):(a.offset.left=a.element.offset().left,a.offset.top=a.element.offset().top),i=Math.abs(a.sizeDiff.width+(a._helper?a.offset.left-u.left:a.offset.left-h.left)),s=Math.abs(a.sizeDiff.height+(a._helper?a.offset.top-u.top:a.offset.top-h.top)),i+a.size.width>=a.parentData.width&&(a.size.width=a.parentData.width-i,c&&(a.size.height=a.size.width/a.aspectRatio,p=!1)),s+a.size.height>=a.parentData.height&&(a.size.height=a.parentData.height-s,c&&(a.size.width=a.size.height*a.aspectRatio,p=!1)),p||(a.position.left=a.prevPosition.left,a.position.top=a.prevPosition.top,a.size.width=a.prevSize.width,a.size.height=a.prevSize.height)},stop:function(){var e=t(this).resizable("instance"),i=e.options,s=e.containerOffset,n=e.containerPosition,o=e.containerElement,a=t(e.helper),r=a.offset(),h=a.outerWidth()-e.sizeDiff.width,l=a.outerHeight()-e.sizeDiff.height;e._helper&&!i.animate&&/relative/.test(o.css("position"))&&t(this).css({left:r.left-n.left-s.left,width:h,height:l}),e._helper&&!i.animate&&/static/.test(o.css("position"))&&t(this).css({left:r.left-n.left-s.left,width:h,height:l})}}),t.ui.plugin.add("resizable","alsoResize",{start:function(){var e=t(this).resizable("instance"),i=e.options;t(i.alsoResize).each(function(){var e=t(this);e.data("ui-resizable-alsoresize",{width:parseFloat(e.width()),height:parseFloat(e.height()),left:parseFloat(e.css("left")),top:parseFloat(e.css("top"))})})},resize:function(e,i){var s=t(this).resizable("instance"),n=s.options,o=s.originalSize,a=s.originalPosition,r={height:s.size.height-o.height||0,width:s.size.width-o.width||0,top:s.position.top-a.top||0,left:s.position.left-a.left||0};t(n.alsoResize).each(function(){var e=t(this),s=t(this).data("ui-resizable-alsoresize"),n={},o=e.parents(i.originalElement[0]).length?["width","height"]:["width","height","top","left"];t.each(o,function(t,e){var i=(s[e]||0)+(r[e]||0);i&&i>=0&&(n[e]=i||null)}),e.css(n)})},stop:function(){t(this).removeData("ui-resizable-alsoresize")}}),t.ui.plugin.add("resizable","ghost",{start:function(){var e=t(this).resizable("instance"),i=e.size;e.ghost=e.originalElement.clone(),e.ghost.css({opacity:.25,display:"block",position:"relative",height:i.height,width:i.width,margin:0,left:0,top:0}),e._addClass(e.ghost,"ui-resizable-ghost"),t.uiBackCompat!==!1&&"string"==typeof e.options.ghost&&e.ghost.addClass(this.options.ghost),e.ghost.appendTo(e.helper)},resize:function(){var e=t(this).resizable("instance");e.ghost&&e.ghost.css({position:"relative",height:e.size.height,width:e.size.width})},stop:function(){var e=t(this).resizable("instance");e.ghost&&e.helper&&e.helper.get(0).removeChild(e.ghost.get(0))}}),t.ui.plugin.add("resizable","grid",{resize:function(){var e,i=t(this).resizable("instance"),s=i.options,n=i.size,o=i.originalSize,a=i.originalPosition,r=i.axis,h="number"==typeof s.grid?[s.grid,s.grid]:s.grid,l=h[0]||1,c=h[1]||1,u=Math.round((n.width-o.width)/l)*l,d=Math.round((n.height-o.height)/c)*c,p=o.width+u,f=o.height+d,m=s.maxWidth&&p>s.maxWidth,g=s.maxHeight&&f>s.maxHeight,_=s.minWidth&&s.minWidth>p,v=s.minHeight&&s.minHeight>f;s.grid=h,_&&(p+=l),v&&(f+=c),m&&(p-=l),g&&(f-=c),/^(se|s|e)$/.test(r)?(i.size.width=p,i.size.height=f):/^(ne)$/.test(r)?(i.size.width=p,i.size.height=f,i.position.top=a.top-d):/^(sw)$/.test(r)?(i.size.width=p,i.size.height=f,i.position.left=a.left-u):((0>=f-c||0>=p-l)&&(e=i._getPaddingPlusBorderDimensions(this)),f-c>0?(i.size.height=f,i.position.top=a.top-d):(f=c-e.height,i.size.height=f,i.position.top=a.top+o.height-f),p-l>0?(i.size.width=p,i.position.left=a.left-u):(p=l-e.width,i.size.width=p,i.position.left=a.left+o.width-p))}}),t.ui.resizable});/**
+ * Copyright (c) 2007 Ariel Flesler - aflesler ○ gmail • com | https://github.com/flesler
+ * Licensed under MIT
+ * @author Ariel Flesler
+ * @version 2.1.2
+ */
+;(function(f){"use strict";"function"===typeof define&&define.amd?define(["jquery"],f):"undefined"!==typeof module&&module.exports?module.exports=f(require("jquery")):f(jQuery)})(function($){"use strict";function n(a){return!a.nodeName||-1!==$.inArray(a.nodeName.toLowerCase(),["iframe","#document","html","body"])}function h(a){return $.isFunction(a)||$.isPlainObject(a)?a:{top:a,left:a}}var p=$.scrollTo=function(a,d,b){return $(window).scrollTo(a,d,b)};p.defaults={axis:"xy",duration:0,limit:!0};$.fn.scrollTo=function(a,d,b){"object"=== typeof d&&(b=d,d=0);"function"===typeof b&&(b={onAfter:b});"max"===a&&(a=9E9);b=$.extend({},p.defaults,b);d=d||b.duration;var u=b.queue&&1<b.axis.length;u&&(d/=2);b.offset=h(b.offset);b.over=h(b.over);return this.each(function(){function k(a){var k=$.extend({},b,{queue:!0,duration:d,complete:a&&function(){a.call(q,e,b)}});r.animate(f,k)}if(null!==a){var l=n(this),q=l?this.contentWindow||window:this,r=$(q),e=a,f={},t;switch(typeof e){case "number":case "string":if(/^([+-]=?)?\d+(\.\d+)?(px|%)?$/.test(e)){e= h(e);break}e=l?$(e):$(e,q);case "object":if(e.length===0)return;if(e.is||e.style)t=(e=$(e)).offset()}var v=$.isFunction(b.offset)&&b.offset(q,e)||b.offset;$.each(b.axis.split(""),function(a,c){var d="x"===c?"Left":"Top",m=d.toLowerCase(),g="scroll"+d,h=r[g](),n=p.max(q,c);t?(f[g]=t[m]+(l?0:h-r.offset()[m]),b.margin&&(f[g]-=parseInt(e.css("margin"+d),10)||0,f[g]-=parseInt(e.css("border"+d+"Width"),10)||0),f[g]+=v[m]||0,b.over[m]&&(f[g]+=e["x"===c?"width":"height"]()*b.over[m])):(d=e[m],f[g]=d.slice&& "%"===d.slice(-1)?parseFloat(d)/100*n:d);b.limit&&/^\d+$/.test(f[g])&&(f[g]=0>=f[g]?0:Math.min(f[g],n));!a&&1<b.axis.length&&(h===f[g]?f={}:u&&(k(b.onAfterFirst),f={}))});k(b.onAfter)}})};p.max=function(a,d){var b="x"===d?"Width":"Height",h="scroll"+b;if(!n(a))return a[h]-$(a)[b.toLowerCase()]();var b="client"+b,k=a.ownerDocument||a.document,l=k.documentElement,k=k.body;return Math.max(l[h],k[h])-Math.min(l[b],k[b])};$.Tween.propHooks.scrollLeft=$.Tween.propHooks.scrollTop={get:function(a){return $(a.elem)[a.prop]()}, set:function(a){var d=this.get(a);if(a.options.interrupt&&a._last&&a._last!==d)return $(a.elem).stop();var b=Math.round(a.now);d!==b&&($(a.elem)[a.prop](b),a._last=this.get(a))}};return p});
+/*!
+ PowerTip v1.3.1 (2018-04-15)
+ https://stevenbenner.github.io/jquery-powertip/
+ Copyright (c) 2018 Steven Benner (http://stevenbenner.com/).
+ Released under MIT license.
+ https://raw.github.com/stevenbenner/jquery-powertip/master/LICENSE.txt
+*/
+(function(root,factory){if(typeof define==="function"&&define.amd){define(["jquery"],factory)}else if(typeof module==="object"&&module.exports){module.exports=factory(require("jquery"))}else{factory(root.jQuery)}})(this,function($){var $document=$(document),$window=$(window),$body=$("body");var DATA_DISPLAYCONTROLLER="displayController",DATA_HASACTIVEHOVER="hasActiveHover",DATA_FORCEDOPEN="forcedOpen",DATA_HASMOUSEMOVE="hasMouseMove",DATA_MOUSEONTOTIP="mouseOnToPopup",DATA_ORIGINALTITLE="originalTitle",DATA_POWERTIP="powertip",DATA_POWERTIPJQ="powertipjq",DATA_POWERTIPTARGET="powertiptarget",EVENT_NAMESPACE=".powertip",RAD2DEG=180/Math.PI,MOUSE_EVENTS=["click","dblclick","mousedown","mouseup","mousemove","mouseover","mouseout","mouseenter","mouseleave","contextmenu"];var session={tooltips:null,isTipOpen:false,isFixedTipOpen:false,isClosing:false,tipOpenImminent:false,activeHover:null,currentX:0,currentY:0,previousX:0,previousY:0,desyncTimeout:null,closeDelayTimeout:null,mouseTrackingActive:false,delayInProgress:false,windowWidth:0,windowHeight:0,scrollTop:0,scrollLeft:0};var Collision={none:0,top:1,bottom:2,left:4,right:8};$.fn.powerTip=function(opts,arg){var targetElements=this,options,tipController;if(!targetElements.length){return targetElements}if($.type(opts)==="string"&&$.powerTip[opts]){return $.powerTip[opts].call(targetElements,targetElements,arg)}options=$.extend({},$.fn.powerTip.defaults,opts);tipController=new TooltipController(options);initTracking();targetElements.each(function elementSetup(){var $this=$(this),dataPowertip=$this.data(DATA_POWERTIP),dataElem=$this.data(DATA_POWERTIPJQ),dataTarget=$this.data(DATA_POWERTIPTARGET),title=$this.attr("title");if(!dataPowertip&&!dataTarget&&!dataElem&&title){$this.data(DATA_POWERTIP,title);$this.data(DATA_ORIGINALTITLE,title);$this.removeAttr("title")}$this.data(DATA_DISPLAYCONTROLLER,new DisplayController($this,options,tipController))});if(!options.manual){$.each(options.openEvents,function(idx,evt){if($.inArray(evt,options.closeEvents)>-1){targetElements.on(evt+EVENT_NAMESPACE,function elementToggle(event){$.powerTip.toggle(this,event)})}else{targetElements.on(evt+EVENT_NAMESPACE,function elementOpen(event){$.powerTip.show(this,event)})}});$.each(options.closeEvents,function(idx,evt){if($.inArray(evt,options.openEvents)<0){targetElements.on(evt+EVENT_NAMESPACE,function elementClose(event){$.powerTip.hide(this,!isMouseEvent(event))})}});targetElements.on("keydown"+EVENT_NAMESPACE,function elementKeyDown(event){if(event.keyCode===27){$.powerTip.hide(this,true)}})}return targetElements};$.fn.powerTip.defaults={fadeInTime:200,fadeOutTime:100,followMouse:false,popupId:"powerTip",popupClass:null,intentSensitivity:7,intentPollInterval:100,closeDelay:100,placement:"n",smartPlacement:false,offset:10,mouseOnToPopup:false,manual:false,openEvents:["mouseenter","focus"],closeEvents:["mouseleave","blur"]};$.fn.powerTip.smartPlacementLists={n:["n","ne","nw","s"],e:["e","ne","se","w","nw","sw","n","s","e"],s:["s","se","sw","n"],w:["w","nw","sw","e","ne","se","n","s","w"],nw:["nw","w","sw","n","s","se","nw"],ne:["ne","e","se","n","s","sw","ne"],sw:["sw","w","nw","s","n","ne","sw"],se:["se","e","ne","s","n","nw","se"],"nw-alt":["nw-alt","n","ne-alt","sw-alt","s","se-alt","w","e"],"ne-alt":["ne-alt","n","nw-alt","se-alt","s","sw-alt","e","w"],"sw-alt":["sw-alt","s","se-alt","nw-alt","n","ne-alt","w","e"],"se-alt":["se-alt","s","sw-alt","ne-alt","n","nw-alt","e","w"]};$.powerTip={show:function apiShowTip(element,event){if(isMouseEvent(event)){trackMouse(event);session.previousX=event.pageX;session.previousY=event.pageY;$(element).data(DATA_DISPLAYCONTROLLER).show()}else{$(element).first().data(DATA_DISPLAYCONTROLLER).show(true,true)}return element},reposition:function apiResetPosition(element){$(element).first().data(DATA_DISPLAYCONTROLLER).resetPosition();return element},hide:function apiCloseTip(element,immediate){var displayController;immediate=element?immediate:true;if(element){displayController=$(element).first().data(DATA_DISPLAYCONTROLLER)}else if(session.activeHover){displayController=session.activeHover.data(DATA_DISPLAYCONTROLLER)}if(displayController){displayController.hide(immediate)}return element},toggle:function apiToggle(element,event){if(session.activeHover&&session.activeHover.is(element)){$.powerTip.hide(element,!isMouseEvent(event))}else{$.powerTip.show(element,event)}return element}};$.powerTip.showTip=$.powerTip.show;$.powerTip.closeTip=$.powerTip.hide;function CSSCoordinates(){var me=this;me.top="auto";me.left="auto";me.right="auto";me.bottom="auto";me.set=function(property,value){if($.isNumeric(value)){me[property]=Math.round(value)}}}function DisplayController(element,options,tipController){var hoverTimer=null,myCloseDelay=null;function openTooltip(immediate,forceOpen){cancelTimer();if(!element.data(DATA_HASACTIVEHOVER)){if(!immediate){session.tipOpenImminent=true;hoverTimer=setTimeout(function intentDelay(){hoverTimer=null;checkForIntent()},options.intentPollInterval)}else{if(forceOpen){element.data(DATA_FORCEDOPEN,true)}closeAnyDelayed();tipController.showTip(element)}}else{cancelClose()}}function closeTooltip(disableDelay){if(myCloseDelay){myCloseDelay=session.closeDelayTimeout=clearTimeout(myCloseDelay);session.delayInProgress=false}cancelTimer();session.tipOpenImminent=false;if(element.data(DATA_HASACTIVEHOVER)){element.data(DATA_FORCEDOPEN,false);if(!disableDelay){session.delayInProgress=true;session.closeDelayTimeout=setTimeout(function closeDelay(){session.closeDelayTimeout=null;tipController.hideTip(element);session.delayInProgress=false;myCloseDelay=null},options.closeDelay);myCloseDelay=session.closeDelayTimeout}else{tipController.hideTip(element)}}}function checkForIntent(){var xDifference=Math.abs(session.previousX-session.currentX),yDifference=Math.abs(session.previousY-session.currentY),totalDifference=xDifference+yDifference;if(totalDifference<options.intentSensitivity){cancelClose();closeAnyDelayed();tipController.showTip(element)}else{session.previousX=session.currentX;session.previousY=session.currentY;openTooltip()}}function cancelTimer(stopClose){hoverTimer=clearTimeout(hoverTimer);if(session.closeDelayTimeout&&myCloseDelay===session.closeDelayTimeout||stopClose){cancelClose()}}function cancelClose(){session.closeDelayTimeout=clearTimeout(session.closeDelayTimeout);session.delayInProgress=false}function closeAnyDelayed(){if(session.delayInProgress&&session.activeHover&&!session.activeHover.is(element)){session.activeHover.data(DATA_DISPLAYCONTROLLER).hide(true)}}function repositionTooltip(){tipController.resetPosition(element)}this.show=openTooltip;this.hide=closeTooltip;this.cancel=cancelTimer;this.resetPosition=repositionTooltip}function PlacementCalculator(){function computePlacementCoords(element,placement,tipWidth,tipHeight,offset){var placementBase=placement.split("-")[0],coords=new CSSCoordinates,position;if(isSvgElement(element)){position=getSvgPlacement(element,placementBase)}else{position=getHtmlPlacement(element,placementBase)}switch(placement){case"n":coords.set("left",position.left-tipWidth/2);coords.set("bottom",session.windowHeight-position.top+offset);break;case"e":coords.set("left",position.left+offset);coords.set("top",position.top-tipHeight/2);break;case"s":coords.set("left",position.left-tipWidth/2);coords.set("top",position.top+offset);break;case"w":coords.set("top",position.top-tipHeight/2);coords.set("right",session.windowWidth-position.left+offset);break;case"nw":coords.set("bottom",session.windowHeight-position.top+offset);coords.set("right",session.windowWidth-position.left-20);break;case"nw-alt":coords.set("left",position.left);coords.set("bottom",session.windowHeight-position.top+offset);break;case"ne":coords.set("left",position.left-20);coords.set("bottom",session.windowHeight-position.top+offset);break;case"ne-alt":coords.set("bottom",session.windowHeight-position.top+offset);coords.set("right",session.windowWidth-position.left);break;case"sw":coords.set("top",position.top+offset);coords.set("right",session.windowWidth-position.left-20);break;case"sw-alt":coords.set("left",position.left);coords.set("top",position.top+offset);break;case"se":coords.set("left",position.left-20);coords.set("top",position.top+offset);break;case"se-alt":coords.set("top",position.top+offset);coords.set("right",session.windowWidth-position.left);break}return coords}function getHtmlPlacement(element,placement){var objectOffset=element.offset(),objectWidth=element.outerWidth(),objectHeight=element.outerHeight(),left,top;switch(placement){case"n":left=objectOffset.left+objectWidth/2;top=objectOffset.top;break;case"e":left=objectOffset.left+objectWidth;top=objectOffset.top+objectHeight/2;break;case"s":left=objectOffset.left+objectWidth/2;top=objectOffset.top+objectHeight;break;case"w":left=objectOffset.left;top=objectOffset.top+objectHeight/2;break;case"nw":left=objectOffset.left;top=objectOffset.top;break;case"ne":left=objectOffset.left+objectWidth;top=objectOffset.top;break;case"sw":left=objectOffset.left;top=objectOffset.top+objectHeight;break;case"se":left=objectOffset.left+objectWidth;top=objectOffset.top+objectHeight;break}return{top:top,left:left}}function getSvgPlacement(element,placement){var svgElement=element.closest("svg")[0],domElement=element[0],point=svgElement.createSVGPoint(),boundingBox=domElement.getBBox(),matrix=domElement.getScreenCTM(),halfWidth=boundingBox.width/2,halfHeight=boundingBox.height/2,placements=[],placementKeys=["nw","n","ne","e","se","s","sw","w"],coords,rotation,steps,x;function pushPlacement(){placements.push(point.matrixTransform(matrix))}point.x=boundingBox.x;point.y=boundingBox.y;pushPlacement();point.x+=halfWidth;pushPlacement();point.x+=halfWidth;pushPlacement();point.y+=halfHeight;pushPlacement();point.y+=halfHeight;pushPlacement();point.x-=halfWidth;pushPlacement();point.x-=halfWidth;pushPlacement();point.y-=halfHeight;pushPlacement();if(placements[0].y!==placements[1].y||placements[0].x!==placements[7].x){rotation=Math.atan2(matrix.b,matrix.a)*RAD2DEG;steps=Math.ceil((rotation%360-22.5)/45);if(steps<1){steps+=8}while(steps--){placementKeys.push(placementKeys.shift())}}for(x=0;x<placements.length;x++){if(placementKeys[x]===placement){coords=placements[x];break}}return{top:coords.y+session.scrollTop,left:coords.x+session.scrollLeft}}this.compute=computePlacementCoords}function TooltipController(options){var placementCalculator=new PlacementCalculator,tipElement=$("#"+options.popupId);if(tipElement.length===0){tipElement=$("<div/>",{id:options.popupId});if($body.length===0){$body=$("body")}$body.append(tipElement);session.tooltips=session.tooltips?session.tooltips.add(tipElement):tipElement}if(options.followMouse){if(!tipElement.data(DATA_HASMOUSEMOVE)){$document.on("mousemove"+EVENT_NAMESPACE,positionTipOnCursor);$window.on("scroll"+EVENT_NAMESPACE,positionTipOnCursor);tipElement.data(DATA_HASMOUSEMOVE,true)}}function beginShowTip(element){element.data(DATA_HASACTIVEHOVER,true);tipElement.queue(function queueTipInit(next){showTip(element);next()})}function showTip(element){var tipContent;if(!element.data(DATA_HASACTIVEHOVER)){return}if(session.isTipOpen){if(!session.isClosing){hideTip(session.activeHover)}tipElement.delay(100).queue(function queueTipAgain(next){showTip(element);next()});return}element.trigger("powerTipPreRender");tipContent=getTooltipContent(element);if(tipContent){tipElement.empty().append(tipContent)}else{return}element.trigger("powerTipRender");session.activeHover=element;session.isTipOpen=true;tipElement.data(DATA_MOUSEONTOTIP,options.mouseOnToPopup);tipElement.addClass(options.popupClass);if(!options.followMouse||element.data(DATA_FORCEDOPEN)){positionTipOnElement(element);session.isFixedTipOpen=true}else{positionTipOnCursor()}if(!element.data(DATA_FORCEDOPEN)&&!options.followMouse){$document.on("click"+EVENT_NAMESPACE,function documentClick(event){var target=event.target;if(target!==element[0]){if(options.mouseOnToPopup){if(target!==tipElement[0]&&!$.contains(tipElement[0],target)){$.powerTip.hide()}}else{$.powerTip.hide()}}})}if(options.mouseOnToPopup&&!options.manual){tipElement.on("mouseenter"+EVENT_NAMESPACE,function tipMouseEnter(){if(session.activeHover){session.activeHover.data(DATA_DISPLAYCONTROLLER).cancel()}});tipElement.on("mouseleave"+EVENT_NAMESPACE,function tipMouseLeave(){if(session.activeHover){session.activeHover.data(DATA_DISPLAYCONTROLLER).hide()}})}tipElement.fadeIn(options.fadeInTime,function fadeInCallback(){if(!session.desyncTimeout){session.desyncTimeout=setInterval(closeDesyncedTip,500)}element.trigger("powerTipOpen")})}function hideTip(element){session.isClosing=true;session.isTipOpen=false;session.desyncTimeout=clearInterval(session.desyncTimeout);element.data(DATA_HASACTIVEHOVER,false);element.data(DATA_FORCEDOPEN,false);$document.off("click"+EVENT_NAMESPACE);tipElement.off(EVENT_NAMESPACE);tipElement.fadeOut(options.fadeOutTime,function fadeOutCallback(){var coords=new CSSCoordinates;session.activeHover=null;session.isClosing=false;session.isFixedTipOpen=false;tipElement.removeClass();coords.set("top",session.currentY+options.offset);coords.set("left",session.currentX+options.offset);tipElement.css(coords);element.trigger("powerTipClose")})}function positionTipOnCursor(){var tipWidth,tipHeight,coords,collisions,collisionCount;if(!session.isFixedTipOpen&&(session.isTipOpen||session.tipOpenImminent&&tipElement.data(DATA_HASMOUSEMOVE))){tipWidth=tipElement.outerWidth();tipHeight=tipElement.outerHeight();coords=new CSSCoordinates;coords.set("top",session.currentY+options.offset);coords.set("left",session.currentX+options.offset);collisions=getViewportCollisions(coords,tipWidth,tipHeight);if(collisions!==Collision.none){collisionCount=countFlags(collisions);if(collisionCount===1){if(collisions===Collision.right){coords.set("left",session.scrollLeft+session.windowWidth-tipWidth)}else if(collisions===Collision.bottom){coords.set("top",session.scrollTop+session.windowHeight-tipHeight)}}else{coords.set("left",session.currentX-tipWidth-options.offset);coords.set("top",session.currentY-tipHeight-options.offset)}}tipElement.css(coords)}}function positionTipOnElement(element){var priorityList,finalPlacement;if(options.smartPlacement||options.followMouse&&element.data(DATA_FORCEDOPEN)){priorityList=$.fn.powerTip.smartPlacementLists[options.placement];$.each(priorityList,function(idx,pos){var collisions=getViewportCollisions(placeTooltip(element,pos),tipElement.outerWidth(),tipElement.outerHeight());finalPlacement=pos;return collisions!==Collision.none})}else{placeTooltip(element,options.placement);finalPlacement=options.placement}tipElement.removeClass("w nw sw e ne se n s w se-alt sw-alt ne-alt nw-alt");tipElement.addClass(finalPlacement)}function placeTooltip(element,placement){var iterationCount=0,tipWidth,tipHeight,coords=new CSSCoordinates;coords.set("top",0);coords.set("left",0);tipElement.css(coords);do{tipWidth=tipElement.outerWidth();tipHeight=tipElement.outerHeight();coords=placementCalculator.compute(element,placement,tipWidth,tipHeight,options.offset);tipElement.css(coords)}while(++iterationCount<=5&&(tipWidth!==tipElement.outerWidth()||tipHeight!==tipElement.outerHeight()));return coords}function closeDesyncedTip(){var isDesynced=false,hasDesyncableCloseEvent=$.grep(["mouseleave","mouseout","blur","focusout"],function(eventType){return $.inArray(eventType,options.closeEvents)!==-1}).length>0;if(session.isTipOpen&&!session.isClosing&&!session.delayInProgress&&hasDesyncableCloseEvent){if(session.activeHover.data(DATA_HASACTIVEHOVER)===false||session.activeHover.is(":disabled")){isDesynced=true}else if(!isMouseOver(session.activeHover)&&!session.activeHover.is(":focus")&&!session.activeHover.data(DATA_FORCEDOPEN)){if(tipElement.data(DATA_MOUSEONTOTIP)){if(!isMouseOver(tipElement)){isDesynced=true}}else{isDesynced=true}}if(isDesynced){hideTip(session.activeHover)}}}this.showTip=beginShowTip;this.hideTip=hideTip;this.resetPosition=positionTipOnElement}function isSvgElement(element){return Boolean(window.SVGElement&&element[0]instanceof SVGElement)}function isMouseEvent(event){return Boolean(event&&$.inArray(event.type,MOUSE_EVENTS)>-1&&typeof event.pageX==="number")}function initTracking(){if(!session.mouseTrackingActive){session.mouseTrackingActive=true;getViewportDimensions();$(getViewportDimensions);$document.on("mousemove"+EVENT_NAMESPACE,trackMouse);$window.on("resize"+EVENT_NAMESPACE,trackResize);$window.on("scroll"+EVENT_NAMESPACE,trackScroll)}}function getViewportDimensions(){session.scrollLeft=$window.scrollLeft();session.scrollTop=$window.scrollTop();session.windowWidth=$window.width();session.windowHeight=$window.height()}function trackResize(){session.windowWidth=$window.width();session.windowHeight=$window.height()}function trackScroll(){var x=$window.scrollLeft(),y=$window.scrollTop();if(x!==session.scrollLeft){session.currentX+=x-session.scrollLeft;session.scrollLeft=x}if(y!==session.scrollTop){session.currentY+=y-session.scrollTop;session.scrollTop=y}}function trackMouse(event){session.currentX=event.pageX;session.currentY=event.pageY}function isMouseOver(element){var elementPosition=element.offset(),elementBox=element[0].getBoundingClientRect(),elementWidth=elementBox.right-elementBox.left,elementHeight=elementBox.bottom-elementBox.top;return session.currentX>=elementPosition.left&&session.currentX<=elementPosition.left+elementWidth&&session.currentY>=elementPosition.top&&session.currentY<=elementPosition.top+elementHeight}function getTooltipContent(element){var tipText=element.data(DATA_POWERTIP),tipObject=element.data(DATA_POWERTIPJQ),tipTarget=element.data(DATA_POWERTIPTARGET),targetElement,content;if(tipText){if($.isFunction(tipText)){tipText=tipText.call(element[0])}content=tipText}else if(tipObject){if($.isFunction(tipObject)){tipObject=tipObject.call(element[0])}if(tipObject.length>0){content=tipObject.clone(true,true)}}else if(tipTarget){targetElement=$("#"+tipTarget);if(targetElement.length>0){content=targetElement.html()}}return content}function getViewportCollisions(coords,elementWidth,elementHeight){var viewportTop=session.scrollTop,viewportLeft=session.scrollLeft,viewportBottom=viewportTop+session.windowHeight,viewportRight=viewportLeft+session.windowWidth,collisions=Collision.none;if(coords.top<viewportTop||Math.abs(coords.bottom-session.windowHeight)-elementHeight<viewportTop){collisions|=Collision.top}if(coords.top+elementHeight>viewportBottom||Math.abs(coords.bottom-session.windowHeight)>viewportBottom){collisions|=Collision.bottom}if(coords.left<viewportLeft||coords.right+elementWidth>viewportRight){collisions|=Collision.left}if(coords.left+elementWidth>viewportRight||coords.right<viewportLeft){collisions|=Collision.right}return collisions}function countFlags(value){var count=0;while(value){value&=value-1;count++}return count}return $.powerTip});/*!
+ * jQuery UI Touch Punch 0.2.3
+ *
+ * Copyright 2011–2014, Dave Furfero
+ * Dual licensed under the MIT or GPL Version 2 licenses.
+ *
+ * Depends:
+ *  jquery.ui.widget.js
+ *  jquery.ui.mouse.js
+ */
+!function(a){function f(a,b){if(!(a.originalEvent.touches.length>1)){a.preventDefault();var c=a.originalEvent.changedTouches[0],d=document.createEvent("MouseEvents");d.initMouseEvent(b,!0,!0,window,1,c.screenX,c.screenY,c.clientX,c.clientY,!1,!1,!1,!1,0,null),a.target.dispatchEvent(d)}}if(a.support.touch="ontouchend"in document,a.support.touch){var e,b=a.ui.mouse.prototype,c=b._mouseInit,d=b._mouseDestroy;b._touchStart=function(a){var b=this;!e&&b._mouseCapture(a.originalEvent.changedTouches[0])&&(e=!0,b._touchMoved=!1,f(a,"mouseover"),f(a,"mousemove"),f(a,"mousedown"))},b._touchMove=function(a){e&&(this._touchMoved=!0,f(a,"mousemove"))},b._touchEnd=function(a){e&&(f(a,"mouseup"),f(a,"mouseout"),this._touchMoved||f(a,"click"),e=!1)},b._mouseInit=function(){var b=this;b.element.bind({touchstart:a.proxy(b,"_touchStart"),touchmove:a.proxy(b,"_touchMove"),touchend:a.proxy(b,"_touchEnd")}),c.call(b)},b._mouseDestroy=function(){var b=this;b.element.unbind({touchstart:a.proxy(b,"_touchStart"),touchmove:a.proxy(b,"_touchMove"),touchend:a.proxy(b,"_touchEnd")}),d.call(b)}}}(jQuery);/*! SmartMenus jQuery Plugin - v1.1.0 - September 17, 2017
+ * http://www.smartmenus.org/
+ * Copyright Vasil Dinkov, Vadikom Web Ltd. http://vadikom.com; Licensed MIT */(function(t){"function"==typeof define&&define.amd?define(["jquery"],t):"object"==typeof module&&"object"==typeof module.exports?module.exports=t(require("jquery")):t(jQuery)})(function($){function initMouseDetection(t){var e=".smartmenus_mouse";if(mouseDetectionEnabled||t)mouseDetectionEnabled&&t&&($(document).off(e),mouseDetectionEnabled=!1);else{var i=!0,s=null,o={mousemove:function(t){var e={x:t.pageX,y:t.pageY,timeStamp:(new Date).getTime()};if(s){var o=Math.abs(s.x-e.x),a=Math.abs(s.y-e.y);if((o>0||a>0)&&2>=o&&2>=a&&300>=e.timeStamp-s.timeStamp&&(mouse=!0,i)){var n=$(t.target).closest("a");n.is("a")&&$.each(menuTrees,function(){return $.contains(this.$root[0],n[0])?(this.itemEnter({currentTarget:n[0]}),!1):void 0}),i=!1}}s=e}};o[touchEvents?"touchstart":"pointerover pointermove pointerout MSPointerOver MSPointerMove MSPointerOut"]=function(t){isTouchEvent(t.originalEvent)&&(mouse=!1)},$(document).on(getEventsNS(o,e)),mouseDetectionEnabled=!0}}function isTouchEvent(t){return!/^(4|mouse)$/.test(t.pointerType)}function getEventsNS(t,e){e||(e="");var i={};for(var s in t)i[s.split(" ").join(e+" ")+e]=t[s];return i}var menuTrees=[],mouse=!1,touchEvents="ontouchstart"in window,mouseDetectionEnabled=!1,requestAnimationFrame=window.requestAnimationFrame||function(t){return setTimeout(t,1e3/60)},cancelAnimationFrame=window.cancelAnimationFrame||function(t){clearTimeout(t)},canAnimate=!!$.fn.animate;return $.SmartMenus=function(t,e){this.$root=$(t),this.opts=e,this.rootId="",this.accessIdPrefix="",this.$subArrow=null,this.activatedItems=[],this.visibleSubMenus=[],this.showTimeout=0,this.hideTimeout=0,this.scrollTimeout=0,this.clickActivated=!1,this.focusActivated=!1,this.zIndexInc=0,this.idInc=0,this.$firstLink=null,this.$firstSub=null,this.disabled=!1,this.$disableOverlay=null,this.$touchScrollingSub=null,this.cssTransforms3d="perspective"in t.style||"webkitPerspective"in t.style,this.wasCollapsible=!1,this.init()},$.extend($.SmartMenus,{hideAll:function(){$.each(menuTrees,function(){this.menuHideAll()})},destroy:function(){for(;menuTrees.length;)menuTrees[0].destroy();initMouseDetection(!0)},prototype:{init:function(t){var e=this;if(!t){menuTrees.push(this),this.rootId=((new Date).getTime()+Math.random()+"").replace(/\D/g,""),this.accessIdPrefix="sm-"+this.rootId+"-",this.$root.hasClass("sm-rtl")&&(this.opts.rightToLeftSubMenus=!0);var i=".smartmenus";this.$root.data("smartmenus",this).attr("data-smartmenus-id",this.rootId).dataSM("level",1).on(getEventsNS({"mouseover focusin":$.proxy(this.rootOver,this),"mouseout focusout":$.proxy(this.rootOut,this),keydown:$.proxy(this.rootKeyDown,this)},i)).on(getEventsNS({mouseenter:$.proxy(this.itemEnter,this),mouseleave:$.proxy(this.itemLeave,this),mousedown:$.proxy(this.itemDown,this),focus:$.proxy(this.itemFocus,this),blur:$.proxy(this.itemBlur,this),click:$.proxy(this.itemClick,this)},i),"a"),i+=this.rootId,this.opts.hideOnClick&&$(document).on(getEventsNS({touchstart:$.proxy(this.docTouchStart,this),touchmove:$.proxy(this.docTouchMove,this),touchend:$.proxy(this.docTouchEnd,this),click:$.proxy(this.docClick,this)},i)),$(window).on(getEventsNS({"resize orientationchange":$.proxy(this.winResize,this)},i)),this.opts.subIndicators&&(this.$subArrow=$("<span/>").addClass("sub-arrow"),this.opts.subIndicatorsText&&this.$subArrow.html(this.opts.subIndicatorsText)),initMouseDetection()}if(this.$firstSub=this.$root.find("ul").each(function(){e.menuInit($(this))}).eq(0),this.$firstLink=this.$root.find("a").eq(0),this.opts.markCurrentItem){var s=/(index|default)\.[^#\?\/]*/i,o=/#.*/,a=window.location.href.replace(s,""),n=a.replace(o,"");this.$root.find("a").each(function(){var t=this.href.replace(s,""),i=$(this);(t==a||t==n)&&(i.addClass("current"),e.opts.markCurrentTree&&i.parentsUntil("[data-smartmenus-id]","ul").each(function(){$(this).dataSM("parent-a").addClass("current")}))})}this.wasCollapsible=this.isCollapsible()},destroy:function(t){if(!t){var e=".smartmenus";this.$root.removeData("smartmenus").removeAttr("data-smartmenus-id").removeDataSM("level").off(e),e+=this.rootId,$(document).off(e),$(window).off(e),this.opts.subIndicators&&(this.$subArrow=null)}this.menuHideAll();var i=this;this.$root.find("ul").each(function(){var t=$(this);t.dataSM("scroll-arrows")&&t.dataSM("scroll-arrows").remove(),t.dataSM("shown-before")&&((i.opts.subMenusMinWidth||i.opts.subMenusMaxWidth)&&t.css({width:"",minWidth:"",maxWidth:""}).removeClass("sm-nowrap"),t.dataSM("scroll-arrows")&&t.dataSM("scroll-arrows").remove(),t.css({zIndex:"",top:"",left:"",marginLeft:"",marginTop:"",display:""})),0==(t.attr("id")||"").indexOf(i.accessIdPrefix)&&t.removeAttr("id")}).removeDataSM("in-mega").removeDataSM("shown-before").removeDataSM("scroll-arrows").removeDataSM("parent-a").removeDataSM("level").removeDataSM("beforefirstshowfired").removeAttr("role").removeAttr("aria-hidden").removeAttr("aria-labelledby").removeAttr("aria-expanded"),this.$root.find("a.has-submenu").each(function(){var t=$(this);0==t.attr("id").indexOf(i.accessIdPrefix)&&t.removeAttr("id")}).removeClass("has-submenu").removeDataSM("sub").removeAttr("aria-haspopup").removeAttr("aria-controls").removeAttr("aria-expanded").closest("li").removeDataSM("sub"),this.opts.subIndicators&&this.$root.find("span.sub-arrow").remove(),this.opts.markCurrentItem&&this.$root.find("a.current").removeClass("current"),t||(this.$root=null,this.$firstLink=null,this.$firstSub=null,this.$disableOverlay&&(this.$disableOverlay.remove(),this.$disableOverlay=null),menuTrees.splice($.inArray(this,menuTrees),1))},disable:function(t){if(!this.disabled){if(this.menuHideAll(),!t&&!this.opts.isPopup&&this.$root.is(":visible")){var e=this.$root.offset();this.$disableOverlay=$('<div class="sm-jquery-disable-overlay"/>').css({position:"absolute",top:e.top,left:e.left,width:this.$root.outerWidth(),height:this.$root.outerHeight(),zIndex:this.getStartZIndex(!0),opacity:0}).appendTo(document.body)}this.disabled=!0}},docClick:function(t){return this.$touchScrollingSub?(this.$touchScrollingSub=null,void 0):((this.visibleSubMenus.length&&!$.contains(this.$root[0],t.target)||$(t.target).closest("a").length)&&this.menuHideAll(),void 0)},docTouchEnd:function(){if(this.lastTouch){if(!(!this.visibleSubMenus.length||void 0!==this.lastTouch.x2&&this.lastTouch.x1!=this.lastTouch.x2||void 0!==this.lastTouch.y2&&this.lastTouch.y1!=this.lastTouch.y2||this.lastTouch.target&&$.contains(this.$root[0],this.lastTouch.target))){this.hideTimeout&&(clearTimeout(this.hideTimeout),this.hideTimeout=0);var t=this;this.hideTimeout=setTimeout(function(){t.menuHideAll()},350)}this.lastTouch=null}},docTouchMove:function(t){if(this.lastTouch){var e=t.originalEvent.touches[0];this.lastTouch.x2=e.pageX,this.lastTouch.y2=e.pageY}},docTouchStart:function(t){var e=t.originalEvent.touches[0];this.lastTouch={x1:e.pageX,y1:e.pageY,target:e.target}},enable:function(){this.disabled&&(this.$disableOverlay&&(this.$disableOverlay.remove(),this.$disableOverlay=null),this.disabled=!1)},getClosestMenu:function(t){for(var e=$(t).closest("ul");e.dataSM("in-mega");)e=e.parent().closest("ul");return e[0]||null},getHeight:function(t){return this.getOffset(t,!0)},getOffset:function(t,e){var i;"none"==t.css("display")&&(i={position:t[0].style.position,visibility:t[0].style.visibility},t.css({position:"absolute",visibility:"hidden"}).show());var s=t[0].getBoundingClientRect&&t[0].getBoundingClientRect(),o=s&&(e?s.height||s.bottom-s.top:s.width||s.right-s.left);return o||0===o||(o=e?t[0].offsetHeight:t[0].offsetWidth),i&&t.hide().css(i),o},getStartZIndex:function(t){var e=parseInt(this[t?"$root":"$firstSub"].css("z-index"));return!t&&isNaN(e)&&(e=parseInt(this.$root.css("z-index"))),isNaN(e)?1:e},getTouchPoint:function(t){return t.touches&&t.touches[0]||t.changedTouches&&t.changedTouches[0]||t},getViewport:function(t){var e=t?"Height":"Width",i=document.documentElement["client"+e],s=window["inner"+e];return s&&(i=Math.min(i,s)),i},getViewportHeight:function(){return this.getViewport(!0)},getViewportWidth:function(){return this.getViewport()},getWidth:function(t){return this.getOffset(t)},handleEvents:function(){return!this.disabled&&this.isCSSOn()},handleItemEvents:function(t){return this.handleEvents()&&!this.isLinkInMegaMenu(t)},isCollapsible:function(){return"static"==this.$firstSub.css("position")},isCSSOn:function(){return"inline"!=this.$firstLink.css("display")},isFixed:function(){var t="fixed"==this.$root.css("position");return t||this.$root.parentsUntil("body").each(function(){return"fixed"==$(this).css("position")?(t=!0,!1):void 0}),t},isLinkInMegaMenu:function(t){return $(this.getClosestMenu(t[0])).hasClass("mega-menu")},isTouchMode:function(){return!mouse||this.opts.noMouseOver||this.isCollapsible()},itemActivate:function(t,e){var i=t.closest("ul"),s=i.dataSM("level");if(s>1&&(!this.activatedItems[s-2]||this.activatedItems[s-2][0]!=i.dataSM("parent-a")[0])){var o=this;$(i.parentsUntil("[data-smartmenus-id]","ul").get().reverse()).add(i).each(function(){o.itemActivate($(this).dataSM("parent-a"))})}if((!this.isCollapsible()||e)&&this.menuHideSubMenus(this.activatedItems[s-1]&&this.activatedItems[s-1][0]==t[0]?s:s-1),this.activatedItems[s-1]=t,this.$root.triggerHandler("activate.smapi",t[0])!==!1){var a=t.dataSM("sub");a&&(this.isTouchMode()||!this.opts.showOnClick||this.clickActivated)&&this.menuShow(a)}},itemBlur:function(t){var e=$(t.currentTarget);this.handleItemEvents(e)&&this.$root.triggerHandler("blur.smapi",e[0])},itemClick:function(t){var e=$(t.currentTarget);if(this.handleItemEvents(e)){if(this.$touchScrollingSub&&this.$touchScrollingSub[0]==e.closest("ul")[0])return this.$touchScrollingSub=null,t.stopPropagation(),!1;if(this.$root.triggerHandler("click.smapi",e[0])===!1)return!1;var i=$(t.target).is(".sub-arrow"),s=e.dataSM("sub"),o=s?2==s.dataSM("level"):!1,a=this.isCollapsible(),n=/toggle$/.test(this.opts.collapsibleBehavior),r=/link$/.test(this.opts.collapsibleBehavior),h=/^accordion/.test(this.opts.collapsibleBehavior);if(s&&!s.is(":visible")){if((!r||!a||i)&&(this.opts.showOnClick&&o&&(this.clickActivated=!0),this.itemActivate(e,h),s.is(":visible")))return this.focusActivated=!0,!1}else if(a&&(n||i))return this.itemActivate(e,h),this.menuHide(s),n&&(this.focusActivated=!1),!1;return this.opts.showOnClick&&o||e.hasClass("disabled")||this.$root.triggerHandler("select.smapi",e[0])===!1?!1:void 0}},itemDown:function(t){var e=$(t.currentTarget);this.handleItemEvents(e)&&e.dataSM("mousedown",!0)},itemEnter:function(t){var e=$(t.currentTarget);if(this.handleItemEvents(e)){if(!this.isTouchMode()){this.showTimeout&&(clearTimeout(this.showTimeout),this.showTimeout=0);var i=this;this.showTimeout=setTimeout(function(){i.itemActivate(e)},this.opts.showOnClick&&1==e.closest("ul").dataSM("level")?1:this.opts.showTimeout)}this.$root.triggerHandler("mouseenter.smapi",e[0])}},itemFocus:function(t){var e=$(t.currentTarget);this.handleItemEvents(e)&&(!this.focusActivated||this.isTouchMode()&&e.dataSM("mousedown")||this.activatedItems.length&&this.activatedItems[this.activatedItems.length-1][0]==e[0]||this.itemActivate(e,!0),this.$root.triggerHandler("focus.smapi",e[0]))},itemLeave:function(t){var e=$(t.currentTarget);this.handleItemEvents(e)&&(this.isTouchMode()||(e[0].blur(),this.showTimeout&&(clearTimeout(this.showTimeout),this.showTimeout=0)),e.removeDataSM("mousedown"),this.$root.triggerHandler("mouseleave.smapi",e[0]))},menuHide:function(t){if(this.$root.triggerHandler("beforehide.smapi",t[0])!==!1&&(canAnimate&&t.stop(!0,!0),"none"!=t.css("display"))){var e=function(){t.css("z-index","")};this.isCollapsible()?canAnimate&&this.opts.collapsibleHideFunction?this.opts.collapsibleHideFunction.call(this,t,e):t.hide(this.opts.collapsibleHideDuration,e):canAnimate&&this.opts.hideFunction?this.opts.hideFunction.call(this,t,e):t.hide(this.opts.hideDuration,e),t.dataSM("scroll")&&(this.menuScrollStop(t),t.css({"touch-action":"","-ms-touch-action":"","-webkit-transform":"",transform:""}).off(".smartmenus_scroll").removeDataSM("scroll").dataSM("scroll-arrows").hide()),t.dataSM("parent-a").removeClass("highlighted").attr("aria-expanded","false"),t.attr({"aria-expanded":"false","aria-hidden":"true"});var i=t.dataSM("level");this.activatedItems.splice(i-1,1),this.visibleSubMenus.splice($.inArray(t,this.visibleSubMenus),1),this.$root.triggerHandler("hide.smapi",t[0])}},menuHideAll:function(){this.showTimeout&&(clearTimeout(this.showTimeout),this.showTimeout=0);for(var t=this.opts.isPopup?1:0,e=this.visibleSubMenus.length-1;e>=t;e--)this.menuHide(this.visibleSubMenus[e]);this.opts.isPopup&&(canAnimate&&this.$root.stop(!0,!0),this.$root.is(":visible")&&(canAnimate&&this.opts.hideFunction?this.opts.hideFunction.call(this,this.$root):this.$root.hide(this.opts.hideDuration))),this.activatedItems=[],this.visibleSubMenus=[],this.clickActivated=!1,this.focusActivated=!1,this.zIndexInc=0,this.$root.triggerHandler("hideAll.smapi")},menuHideSubMenus:function(t){for(var e=this.activatedItems.length-1;e>=t;e--){var i=this.activatedItems[e].dataSM("sub");i&&this.menuHide(i)}},menuInit:function(t){if(!t.dataSM("in-mega")){t.hasClass("mega-menu")&&t.find("ul").dataSM("in-mega",!0);for(var e=2,i=t[0];(i=i.parentNode.parentNode)!=this.$root[0];)e++;var s=t.prevAll("a").eq(-1);s.length||(s=t.prevAll().find("a").eq(-1)),s.addClass("has-submenu").dataSM("sub",t),t.dataSM("parent-a",s).dataSM("level",e).parent().dataSM("sub",t);var o=s.attr("id")||this.accessIdPrefix+ ++this.idInc,a=t.attr("id")||this.accessIdPrefix+ ++this.idInc;s.attr({id:o,"aria-haspopup":"true","aria-controls":a,"aria-expanded":"false"}),t.attr({id:a,role:"group","aria-hidden":"true","aria-labelledby":o,"aria-expanded":"false"}),this.opts.subIndicators&&s[this.opts.subIndicatorsPos](this.$subArrow.clone())}},menuPosition:function(t){var e,i,s=t.dataSM("parent-a"),o=s.closest("li"),a=o.parent(),n=t.dataSM("level"),r=this.getWidth(t),h=this.getHeight(t),u=s.offset(),l=u.left,c=u.top,d=this.getWidth(s),m=this.getHeight(s),p=$(window),f=p.scrollLeft(),v=p.scrollTop(),b=this.getViewportWidth(),S=this.getViewportHeight(),g=a.parent().is("[data-sm-horizontal-sub]")||2==n&&!a.hasClass("sm-vertical"),M=this.opts.rightToLeftSubMenus&&!o.is("[data-sm-reverse]")||!this.opts.rightToLeftSubMenus&&o.is("[data-sm-reverse]"),w=2==n?this.opts.mainMenuSubOffsetX:this.opts.subMenusSubOffsetX,T=2==n?this.opts.mainMenuSubOffsetY:this.opts.subMenusSubOffsetY;if(g?(e=M?d-r-w:w,i=this.opts.bottomToTopSubMenus?-h-T:m+T):(e=M?w-r:d-w,i=this.opts.bottomToTopSubMenus?m-T-h:T),this.opts.keepInViewport){var y=l+e,I=c+i;if(M&&f>y?e=g?f-y+e:d-w:!M&&y+r>f+b&&(e=g?f+b-r-y+e:w-r),g||(S>h&&I+h>v+S?i+=v+S-h-I:(h>=S||v>I)&&(i+=v-I)),g&&(I+h>v+S+.49||v>I)||!g&&h>S+.49){var x=this;t.dataSM("scroll-arrows")||t.dataSM("scroll-arrows",$([$('<span class="scroll-up"><span class="scroll-up-arrow"></span></span>')[0],$('<span class="scroll-down"><span class="scroll-down-arrow"></span></span>')[0]]).on({mouseenter:function(){t.dataSM("scroll").up=$(this).hasClass("scroll-up"),x.menuScroll(t)},mouseleave:function(e){x.menuScrollStop(t),x.menuScrollOut(t,e)},"mousewheel DOMMouseScroll":function(t){t.preventDefault()}}).insertAfter(t));var A=".smartmenus_scroll";if(t.dataSM("scroll",{y:this.cssTransforms3d?0:i-m,step:1,itemH:m,subH:h,arrowDownH:this.getHeight(t.dataSM("scroll-arrows").eq(1))}).on(getEventsNS({mouseover:function(e){x.menuScrollOver(t,e)},mouseout:function(e){x.menuScrollOut(t,e)},"mousewheel DOMMouseScroll":function(e){x.menuScrollMousewheel(t,e)}},A)).dataSM("scroll-arrows").css({top:"auto",left:"0",marginLeft:e+(parseInt(t.css("border-left-width"))||0),width:r-(parseInt(t.css("border-left-width"))||0)-(parseInt(t.css("border-right-width"))||0),zIndex:t.css("z-index")}).eq(g&&this.opts.bottomToTopSubMenus?0:1).show(),this.isFixed()){var C={};C[touchEvents?"touchstart touchmove touchend":"pointerdown pointermove pointerup MSPointerDown MSPointerMove MSPointerUp"]=function(e){x.menuScrollTouch(t,e)},t.css({"touch-action":"none","-ms-touch-action":"none"}).on(getEventsNS(C,A))}}}t.css({top:"auto",left:"0",marginLeft:e,marginTop:i-m})},menuScroll:function(t,e,i){var s,o=t.dataSM("scroll"),a=t.dataSM("scroll-arrows"),n=o.up?o.upEnd:o.downEnd;if(!e&&o.momentum){if(o.momentum*=.92,s=o.momentum,.5>s)return this.menuScrollStop(t),void 0}else s=i||(e||!this.opts.scrollAccelerate?this.opts.scrollStep:Math.floor(o.step));var r=t.dataSM("level");if(this.activatedItems[r-1]&&this.activatedItems[r-1].dataSM("sub")&&this.activatedItems[r-1].dataSM("sub").is(":visible")&&this.menuHideSubMenus(r-1),o.y=o.up&&o.y>=n||!o.up&&n>=o.y?o.y:Math.abs(n-o.y)>s?o.y+(o.up?s:-s):n,t.css(this.cssTransforms3d?{"-webkit-transform":"translate3d(0, "+o.y+"px, 0)",transform:"translate3d(0, "+o.y+"px, 0)"}:{marginTop:o.y}),mouse&&(o.up&&o.y>o.downEnd||!o.up&&o.y<o.upEnd)&&a.eq(o.up?1:0).show(),o.y==n)mouse&&a.eq(o.up?0:1).hide(),this.menuScrollStop(t);else if(!e){this.opts.scrollAccelerate&&o.step<this.opts.scrollStep&&(o.step+=.2);var h=this;this.scrollTimeout=requestAnimationFrame(function(){h.menuScroll(t)})}},menuScrollMousewheel:function(t,e){if(this.getClosestMenu(e.target)==t[0]){e=e.originalEvent;var i=(e.wheelDelta||-e.detail)>0;t.dataSM("scroll-arrows").eq(i?0:1).is(":visible")&&(t.dataSM("scroll").up=i,this.menuScroll(t,!0))}e.preventDefault()},menuScrollOut:function(t,e){mouse&&(/^scroll-(up|down)/.test((e.relatedTarget||"").className)||(t[0]==e.relatedTarget||$.contains(t[0],e.relatedTarget))&&this.getClosestMenu(e.relatedTarget)==t[0]||t.dataSM("scroll-arrows").css("visibility","hidden"))},menuScrollOver:function(t,e){if(mouse&&!/^scroll-(up|down)/.test(e.target.className)&&this.getClosestMenu(e.target)==t[0]){this.menuScrollRefreshData(t);var i=t.dataSM("scroll"),s=$(window).scrollTop()-t.dataSM("parent-a").offset().top-i.itemH;t.dataSM("scroll-arrows").eq(0).css("margin-top",s).end().eq(1).css("margin-top",s+this.getViewportHeight()-i.arrowDownH).end().css("visibility","visible")}},menuScrollRefreshData:function(t){var e=t.dataSM("scroll"),i=$(window).scrollTop()-t.dataSM("parent-a").offset().top-e.itemH;this.cssTransforms3d&&(i=-(parseFloat(t.css("margin-top"))-i)),$.extend(e,{upEnd:i,downEnd:i+this.getViewportHeight()-e.subH})},menuScrollStop:function(t){return this.scrollTimeout?(cancelAnimationFrame(this.scrollTimeout),this.scrollTimeout=0,t.dataSM("scroll").step=1,!0):void 0},menuScrollTouch:function(t,e){if(e=e.originalEvent,isTouchEvent(e)){var i=this.getTouchPoint(e);if(this.getClosestMenu(i.target)==t[0]){var s=t.dataSM("scroll");if(/(start|down)$/i.test(e.type))this.menuScrollStop(t)?(e.preventDefault(),this.$touchScrollingSub=t):this.$touchScrollingSub=null,this.menuScrollRefreshData(t),$.extend(s,{touchStartY:i.pageY,touchStartTime:e.timeStamp});else if(/move$/i.test(e.type)){var o=void 0!==s.touchY?s.touchY:s.touchStartY;if(void 0!==o&&o!=i.pageY){this.$touchScrollingSub=t;var a=i.pageY>o;void 0!==s.up&&s.up!=a&&$.extend(s,{touchStartY:i.pageY,touchStartTime:e.timeStamp}),$.extend(s,{up:a,touchY:i.pageY}),this.menuScroll(t,!0,Math.abs(i.pageY-o))}e.preventDefault()}else void 0!==s.touchY&&((s.momentum=15*Math.pow(Math.abs(i.pageY-s.touchStartY)/(e.timeStamp-s.touchStartTime),2))&&(this.menuScrollStop(t),this.menuScroll(t),e.preventDefault()),delete s.touchY)}}},menuShow:function(t){if((t.dataSM("beforefirstshowfired")||(t.dataSM("beforefirstshowfired",!0),this.$root.triggerHandler("beforefirstshow.smapi",t[0])!==!1))&&this.$root.triggerHandler("beforeshow.smapi",t[0])!==!1&&(t.dataSM("shown-before",!0),canAnimate&&t.stop(!0,!0),!t.is(":visible"))){var e=t.dataSM("parent-a"),i=this.isCollapsible();if((this.opts.keepHighlighted||i)&&e.addClass("highlighted"),i)t.removeClass("sm-nowrap").css({zIndex:"",width:"auto",minWidth:"",maxWidth:"",top:"",left:"",marginLeft:"",marginTop:""});else{if(t.css("z-index",this.zIndexInc=(this.zIndexInc||this.getStartZIndex())+1),(this.opts.subMenusMinWidth||this.opts.subMenusMaxWidth)&&(t.css({width:"auto",minWidth:"",maxWidth:""}).addClass("sm-nowrap"),this.opts.subMenusMinWidth&&t.css("min-width",this.opts.subMenusMinWidth),this.opts.subMenusMaxWidth)){var s=this.getWidth(t);t.css("max-width",this.opts.subMenusMaxWidth),s>this.getWidth(t)&&t.removeClass("sm-nowrap").css("width",this.opts.subMenusMaxWidth)}this.menuPosition(t)}var o=function(){t.css("overflow","")};i?canAnimate&&this.opts.collapsibleShowFunction?this.opts.collapsibleShowFunction.call(this,t,o):t.show(this.opts.collapsibleShowDuration,o):canAnimate&&this.opts.showFunction?this.opts.showFunction.call(this,t,o):t.show(this.opts.showDuration,o),e.attr("aria-expanded","true"),t.attr({"aria-expanded":"true","aria-hidden":"false"}),this.visibleSubMenus.push(t),this.$root.triggerHandler("show.smapi",t[0])}},popupHide:function(t){this.hideTimeout&&(clearTimeout(this.hideTimeout),this.hideTimeout=0);var e=this;this.hideTimeout=setTimeout(function(){e.menuHideAll()},t?1:this.opts.hideTimeout)},popupShow:function(t,e){if(!this.opts.isPopup)return alert('SmartMenus jQuery Error:\n\nIf you want to show this menu via the "popupShow" method, set the isPopup:true option.'),void 0;if(this.hideTimeout&&(clearTimeout(this.hideTimeout),this.hideTimeout=0),this.$root.dataSM("shown-before",!0),canAnimate&&this.$root.stop(!0,!0),!this.$root.is(":visible")){this.$root.css({left:t,top:e});var i=this,s=function(){i.$root.css("overflow","")};canAnimate&&this.opts.showFunction?this.opts.showFunction.call(this,this.$root,s):this.$root.show(this.opts.showDuration,s),this.visibleSubMenus[0]=this.$root}},refresh:function(){this.destroy(!0),this.init(!0)},rootKeyDown:function(t){if(this.handleEvents())switch(t.keyCode){case 27:var e=this.activatedItems[0];if(e){this.menuHideAll(),e[0].focus();var i=e.dataSM("sub");i&&this.menuHide(i)}break;case 32:var s=$(t.target);if(s.is("a")&&this.handleItemEvents(s)){var i=s.dataSM("sub");i&&!i.is(":visible")&&(this.itemClick({currentTarget:t.target}),t.preventDefault())}}},rootOut:function(t){if(this.handleEvents()&&!this.isTouchMode()&&t.target!=this.$root[0]&&(this.hideTimeout&&(clearTimeout(this.hideTimeout),this.hideTimeout=0),!this.opts.showOnClick||!this.opts.hideOnClick)){var e=this;this.hideTimeout=setTimeout(function(){e.menuHideAll()},this.opts.hideTimeout)}},rootOver:function(t){this.handleEvents()&&!this.isTouchMode()&&t.target!=this.$root[0]&&this.hideTimeout&&(clearTimeout(this.hideTimeout),this.hideTimeout=0)},winResize:function(t){if(this.handleEvents()){if(!("onorientationchange"in window)||"orientationchange"==t.type){var e=this.isCollapsible();this.wasCollapsible&&e||(this.activatedItems.length&&this.activatedItems[this.activatedItems.length-1][0].blur(),this.menuHideAll()),this.wasCollapsible=e}}else if(this.$disableOverlay){var i=this.$root.offset();this.$disableOverlay.css({top:i.top,left:i.left,width:this.$root.outerWidth(),height:this.$root.outerHeight()})}}}}),$.fn.dataSM=function(t,e){return e?this.data(t+"_smartmenus",e):this.data(t+"_smartmenus")},$.fn.removeDataSM=function(t){return this.removeData(t+"_smartmenus")},$.fn.smartmenus=function(options){if("string"==typeof options){var args=arguments,method=options;return Array.prototype.shift.call(args),this.each(function(){var t=$(this).data("smartmenus");t&&t[method]&&t[method].apply(t,args)})}return this.each(function(){var dataOpts=$(this).data("sm-options")||null;if(dataOpts)try{dataOpts=eval("("+dataOpts+")")}catch(e){dataOpts=null,alert('ERROR\n\nSmartMenus jQuery init:\nInvalid "data-sm-options" attribute value syntax.')}new $.SmartMenus(this,$.extend({},$.fn.smartmenus.defaults,options,dataOpts))})},$.fn.smartmenus.defaults={isPopup:!1,mainMenuSubOffsetX:0,mainMenuSubOffsetY:0,subMenusSubOffsetX:0,subMenusSubOffsetY:0,subMenusMinWidth:"10em",subMenusMaxWidth:"20em",subIndicators:!0,subIndicatorsPos:"append",subIndicatorsText:"",scrollStep:30,scrollAccelerate:!0,showTimeout:250,hideTimeout:500,showDuration:0,showFunction:null,hideDuration:0,hideFunction:function(t,e){t.fadeOut(200,e)},collapsibleShowDuration:0,collapsibleShowFunction:function(t,e){t.slideDown(200,e)},collapsibleHideDuration:0,collapsibleHideFunction:function(t,e){t.slideUp(200,e)},showOnClick:!1,hideOnClick:!0,noMouseOver:!1,keepInViewport:!0,keepHighlighted:!0,markCurrentItem:!1,markCurrentTree:!0,rightToLeftSubMenus:!1,bottomToTopSubMenus:!1,collapsibleBehavior:"default"},$});
\ No newline at end of file
diff --git a/3rdparty/libjpeg/src/doc/html/menu.js b/3rdparty/libjpeg/src/doc/html/menu.js
new file mode 100644
index 00000000..2fe2214f
--- /dev/null
+++ b/3rdparty/libjpeg/src/doc/html/menu.js
@@ -0,0 +1,51 @@
+/*
+ @licstart  The following is the entire license notice for the JavaScript code in this file.
+
+ The MIT License (MIT)
+
+ Copyright (C) 1997-2020 by Dimitri van Heesch
+
+ 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.
+
+ @licend  The above is the entire license notice for the JavaScript code in this file
+ */
+function initMenu(relPath,searchEnabled,serverSide,searchPage,search) {
+  function makeTree(data,relPath) {
+    var result='';
+    if ('children' in data) {
+      result+='<ul>';
+      for (var i in data.children) {
+        result+='<li><a href="'+relPath+data.children[i].url+'">'+
+                                data.children[i].text+'</a>'+
+                                makeTree(data.children[i],relPath)+'</li>';
+      }
+      result+='</ul>';
+    }
+    return result;
+  }
+
+  $('#main-nav').append(makeTree(menudata,relPath));
+  $('#main-nav').children(':first').addClass('sm sm-dox').attr('id','main-menu');
+  if (searchEnabled) {
+    if (serverSide) {
+      $('#main-menu').append('<li style="float:right"><div id="MSearchBox" class="MSearchBoxInactive"><div class="left"><form id="FSearchBox" action="'+relPath+searchPage+'" method="get"><img id="MSearchSelect" src="'+relPath+'search/mag.svg" alt=""/><input type="text" id="MSearchField" name="query" value="'+search+'" size="20" accesskey="S" onfocus="searchBox.OnSearchFieldFocus(true)" onblur="searchBox.OnSearchFieldFocus(false)"></form></div><div class="right"></div></div></li>');
+    } else {
+      $('#main-menu').append('<li style="float:right"><div id="MSearchBox" class="MSearchBoxInactive"><span class="left"><img id="MSearchSelect" src="'+relPath+'search/mag_sel.svg" onmouseover="return searchBox.OnSearchSelectShow()" onmouseout="return searchBox.OnSearchSelectHide()" alt=""/><input type="text" id="MSearchField" value="'+search+'" accesskey="S" onfocus="searchBox.OnSearchFieldFocus(true)" onblur="searchBox.OnSearchFieldFocus(false)" onkeyup="searchBox.OnSearchFieldChange(event)"/></span><span class="right"><a id="MSearchClose" href="javascript:searchBox.CloseResultsWindow()"><img id="MSearchCloseImg" border="0" src="'+relPath+'search/close.svg" alt=""/></a></span></div></li>');
+    }
+  }
+  $('#main-menu').smartmenus();
+}
+/* @license-end */
diff --git a/3rdparty/libjpeg/src/doc/html/menudata.js b/3rdparty/libjpeg/src/doc/html/menudata.js
new file mode 100644
index 00000000..fa25d425
--- /dev/null
+++ b/3rdparty/libjpeg/src/doc/html/menudata.js
@@ -0,0 +1,33 @@
+/*
+ @licstart  The following is the entire license notice for the JavaScript code in this file.
+
+ The MIT License (MIT)
+
+ Copyright (C) 1997-2020 by Dimitri van Heesch
+
+ 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.
+
+ @licend  The above is the entire license notice for the JavaScript code in this file
+*/
+var menudata={children:[
+{text:"Main Page",url:"index.html"},
+{text:"Modules",url:"modules.html"},
+{text:"Data Structures",url:"annotated.html",children:[
+{text:"Data Structures",url:"annotated.html"},
+{text:"Data Structure Index",url:"classes.html"},
+{text:"Data Fields",url:"functions.html",children:[
+{text:"All",url:"functions.html"},
+{text:"Variables",url:"functions_vars.html"}]}]}]}
diff --git a/3rdparty/libjpeg/src/doc/html/modules.html b/3rdparty/libjpeg/src/doc/html/modules.html
new file mode 100644
index 00000000..de5be658
--- /dev/null
+++ b/3rdparty/libjpeg/src/doc/html/modules.html
@@ -0,0 +1,81 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.8.20"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>TurboJPEG: Modules</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="search/search.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="search/searchdata.js"></script>
+<script type="text/javascript" src="search/search.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+  <td id="projectalign" style="padding-left: 0.5em;">
+   <div id="projectname">TurboJPEG
+   &#160;<span id="projectnumber">2.0</span>
+   </div>
+  </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.8.20 -->
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+var searchBox = new SearchBox("searchBox", "search",false,'Search');
+/* @license-end */
+</script>
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+  initMenu('',true,false,'search.php','Search');
+  $(document).ready(function() { init_search(); });
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<!-- window showing the filter options -->
+<div id="MSearchSelectWindow"
+     onmouseover="return searchBox.OnSearchSelectShow()"
+     onmouseout="return searchBox.OnSearchSelectHide()"
+     onkeydown="return searchBox.OnSearchSelectKey(event)">
+</div>
+
+<!-- iframe showing the search results (closed by default) -->
+<div id="MSearchResultsWindow">
+<iframe src="javascript:void(0)" frameborder="0" 
+        name="MSearchResults" id="MSearchResults">
+</iframe>
+</div>
+
+<div class="header">
+  <div class="headertitle">
+<div class="title">Modules</div>  </div>
+</div><!--header-->
+<div class="contents">
+<div class="textblock">Here is a list of all modules:</div><div class="directory">
+<table class="directory">
+<tr id="row_0_" class="even"><td class="entry"><span style="width:16px;display:inline-block;">&#160;</span><a class="el" href="group___turbo_j_p_e_g.html" target="_self">TurboJPEG</a></td><td class="desc">TurboJPEG API </td></tr>
+</table>
+</div><!-- directory -->
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated by&#160;<a href="http://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.8.20
+</small></address>
+</body>
+</html>
diff --git a/3rdparty/libjpeg/src/doc/html/nav_f.png b/3rdparty/libjpeg/src/doc/html/nav_f.png
new file mode 100644
index 00000000..72a58a52
Binary files /dev/null and b/3rdparty/libjpeg/src/doc/html/nav_f.png differ
diff --git a/3rdparty/libjpeg/src/doc/html/nav_g.png b/3rdparty/libjpeg/src/doc/html/nav_g.png
new file mode 100644
index 00000000..2093a237
Binary files /dev/null and b/3rdparty/libjpeg/src/doc/html/nav_g.png differ
diff --git a/3rdparty/libjpeg/src/doc/html/nav_h.png b/3rdparty/libjpeg/src/doc/html/nav_h.png
new file mode 100644
index 00000000..33389b10
Binary files /dev/null and b/3rdparty/libjpeg/src/doc/html/nav_h.png differ
diff --git a/3rdparty/libjpeg/src/doc/html/open.png b/3rdparty/libjpeg/src/doc/html/open.png
new file mode 100644
index 00000000..30f75c7e
Binary files /dev/null and b/3rdparty/libjpeg/src/doc/html/open.png differ
diff --git a/3rdparty/libjpeg/src/doc/html/search/all_0.html b/3rdparty/libjpeg/src/doc/html/search/all_0.html
new file mode 100644
index 00000000..a34319f3
--- /dev/null
+++ b/3rdparty/libjpeg/src/doc/html/search/all_0.html
@@ -0,0 +1,36 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html><head><title></title>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta name="generator" content="Doxygen 1.8.20"/>
+<link rel="stylesheet" type="text/css" href="search.css"/>
+<script type="text/javascript" src="all_0.js"></script>
+<script type="text/javascript" src="search.js"></script>
+</head>
+<body class="SRPage">
+<div id="SRIndex">
+<div class="SRStatus" id="Loading">Loading...</div>
+<div id="SRResults"></div>
+<script type="text/javascript"><!--
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+createResults();
+/* @license-end */
+--></script>
+<div class="SRStatus" id="Searching">Searching...</div>
+<div class="SRStatus" id="NoMatches">No Matches</div>
+<script type="text/javascript"><!--
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+document.getElementById("Loading").style.display="none";
+document.getElementById("NoMatches").style.display="none";
+var searchResults = new SearchResults("searchResults");
+searchResults.Search();
+window.addEventListener("message", function(event) {
+  if (event.data == "take_focus") {
+    var elem = searchResults.NavNext(0);
+    if (elem) elem.focus();
+  }
+});
+/* @license-end */
+--></script>
+</div>
+</body>
+</html>
diff --git a/3rdparty/libjpeg/src/doc/html/search/all_0.js b/3rdparty/libjpeg/src/doc/html/search/all_0.js
new file mode 100644
index 00000000..54c73561
--- /dev/null
+++ b/3rdparty/libjpeg/src/doc/html/search/all_0.js
@@ -0,0 +1,4 @@
+var searchData=
+[
+  ['customfilter_0',['customFilter',['../structtjtransform.html#afd7fc262df33f741e120ef4183202ef5',1,'tjtransform']]]
+];
diff --git a/3rdparty/libjpeg/src/doc/html/search/all_1.html b/3rdparty/libjpeg/src/doc/html/search/all_1.html
new file mode 100644
index 00000000..51aff6f6
--- /dev/null
+++ b/3rdparty/libjpeg/src/doc/html/search/all_1.html
@@ -0,0 +1,36 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html><head><title></title>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta name="generator" content="Doxygen 1.8.20"/>
+<link rel="stylesheet" type="text/css" href="search.css"/>
+<script type="text/javascript" src="all_1.js"></script>
+<script type="text/javascript" src="search.js"></script>
+</head>
+<body class="SRPage">
+<div id="SRIndex">
+<div class="SRStatus" id="Loading">Loading...</div>
+<div id="SRResults"></div>
+<script type="text/javascript"><!--
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+createResults();
+/* @license-end */
+--></script>
+<div class="SRStatus" id="Searching">Searching...</div>
+<div class="SRStatus" id="NoMatches">No Matches</div>
+<script type="text/javascript"><!--
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+document.getElementById("Loading").style.display="none";
+document.getElementById("NoMatches").style.display="none";
+var searchResults = new SearchResults("searchResults");
+searchResults.Search();
+window.addEventListener("message", function(event) {
+  if (event.data == "take_focus") {
+    var elem = searchResults.NavNext(0);
+    if (elem) elem.focus();
+  }
+});
+/* @license-end */
+--></script>
+</div>
+</body>
+</html>
diff --git a/3rdparty/libjpeg/src/doc/html/search/all_1.js b/3rdparty/libjpeg/src/doc/html/search/all_1.js
new file mode 100644
index 00000000..73ec5f55
--- /dev/null
+++ b/3rdparty/libjpeg/src/doc/html/search/all_1.js
@@ -0,0 +1,5 @@
+var searchData=
+[
+  ['data_1',['data',['../structtjtransform.html#a688fe8f1a8ecc12a538d9e561cf338e3',1,'tjtransform']]],
+  ['denom_2',['denom',['../structtjscalingfactor.html#aefbcdf3e9e62274b2d312c695f133ce3',1,'tjscalingfactor']]]
+];
diff --git a/3rdparty/libjpeg/src/doc/html/search/all_2.html b/3rdparty/libjpeg/src/doc/html/search/all_2.html
new file mode 100644
index 00000000..1f81f664
--- /dev/null
+++ b/3rdparty/libjpeg/src/doc/html/search/all_2.html
@@ -0,0 +1,36 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html><head><title></title>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta name="generator" content="Doxygen 1.8.20"/>
+<link rel="stylesheet" type="text/css" href="search.css"/>
+<script type="text/javascript" src="all_2.js"></script>
+<script type="text/javascript" src="search.js"></script>
+</head>
+<body class="SRPage">
+<div id="SRIndex">
+<div class="SRStatus" id="Loading">Loading...</div>
+<div id="SRResults"></div>
+<script type="text/javascript"><!--
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+createResults();
+/* @license-end */
+--></script>
+<div class="SRStatus" id="Searching">Searching...</div>
+<div class="SRStatus" id="NoMatches">No Matches</div>
+<script type="text/javascript"><!--
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+document.getElementById("Loading").style.display="none";
+document.getElementById("NoMatches").style.display="none";
+var searchResults = new SearchResults("searchResults");
+searchResults.Search();
+window.addEventListener("message", function(event) {
+  if (event.data == "take_focus") {
+    var elem = searchResults.NavNext(0);
+    if (elem) elem.focus();
+  }
+});
+/* @license-end */
+--></script>
+</div>
+</body>
+</html>
diff --git a/3rdparty/libjpeg/src/doc/html/search/all_2.js b/3rdparty/libjpeg/src/doc/html/search/all_2.js
new file mode 100644
index 00000000..1c5615e3
--- /dev/null
+++ b/3rdparty/libjpeg/src/doc/html/search/all_2.js
@@ -0,0 +1,4 @@
+var searchData=
+[
+  ['h_3',['h',['../structtjregion.html#aecefc45a26f4d8b60dd4d825c1710115',1,'tjregion']]]
+];
diff --git a/3rdparty/libjpeg/src/doc/html/search/all_3.html b/3rdparty/libjpeg/src/doc/html/search/all_3.html
new file mode 100644
index 00000000..2e31ab91
--- /dev/null
+++ b/3rdparty/libjpeg/src/doc/html/search/all_3.html
@@ -0,0 +1,36 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html><head><title></title>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta name="generator" content="Doxygen 1.8.20"/>
+<link rel="stylesheet" type="text/css" href="search.css"/>
+<script type="text/javascript" src="all_3.js"></script>
+<script type="text/javascript" src="search.js"></script>
+</head>
+<body class="SRPage">
+<div id="SRIndex">
+<div class="SRStatus" id="Loading">Loading...</div>
+<div id="SRResults"></div>
+<script type="text/javascript"><!--
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+createResults();
+/* @license-end */
+--></script>
+<div class="SRStatus" id="Searching">Searching...</div>
+<div class="SRStatus" id="NoMatches">No Matches</div>
+<script type="text/javascript"><!--
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+document.getElementById("Loading").style.display="none";
+document.getElementById("NoMatches").style.display="none";
+var searchResults = new SearchResults("searchResults");
+searchResults.Search();
+window.addEventListener("message", function(event) {
+  if (event.data == "take_focus") {
+    var elem = searchResults.NavNext(0);
+    if (elem) elem.focus();
+  }
+});
+/* @license-end */
+--></script>
+</div>
+</body>
+</html>
diff --git a/3rdparty/libjpeg/src/doc/html/search/all_3.js b/3rdparty/libjpeg/src/doc/html/search/all_3.js
new file mode 100644
index 00000000..77d139a0
--- /dev/null
+++ b/3rdparty/libjpeg/src/doc/html/search/all_3.js
@@ -0,0 +1,4 @@
+var searchData=
+[
+  ['num_4',['num',['../structtjscalingfactor.html#a9b011e57f981ee23083e2c1aa5e640ec',1,'tjscalingfactor']]]
+];
diff --git a/3rdparty/libjpeg/src/doc/html/search/all_4.html b/3rdparty/libjpeg/src/doc/html/search/all_4.html
new file mode 100644
index 00000000..0540c163
--- /dev/null
+++ b/3rdparty/libjpeg/src/doc/html/search/all_4.html
@@ -0,0 +1,36 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html><head><title></title>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta name="generator" content="Doxygen 1.8.20"/>
+<link rel="stylesheet" type="text/css" href="search.css"/>
+<script type="text/javascript" src="all_4.js"></script>
+<script type="text/javascript" src="search.js"></script>
+</head>
+<body class="SRPage">
+<div id="SRIndex">
+<div class="SRStatus" id="Loading">Loading...</div>
+<div id="SRResults"></div>
+<script type="text/javascript"><!--
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+createResults();
+/* @license-end */
+--></script>
+<div class="SRStatus" id="Searching">Searching...</div>
+<div class="SRStatus" id="NoMatches">No Matches</div>
+<script type="text/javascript"><!--
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+document.getElementById("Loading").style.display="none";
+document.getElementById("NoMatches").style.display="none";
+var searchResults = new SearchResults("searchResults");
+searchResults.Search();
+window.addEventListener("message", function(event) {
+  if (event.data == "take_focus") {
+    var elem = searchResults.NavNext(0);
+    if (elem) elem.focus();
+  }
+});
+/* @license-end */
+--></script>
+</div>
+</body>
+</html>
diff --git a/3rdparty/libjpeg/src/doc/html/search/all_4.js b/3rdparty/libjpeg/src/doc/html/search/all_4.js
new file mode 100644
index 00000000..f976db4d
--- /dev/null
+++ b/3rdparty/libjpeg/src/doc/html/search/all_4.js
@@ -0,0 +1,5 @@
+var searchData=
+[
+  ['op_5',['op',['../structtjtransform.html#a2525aab4ba6978a1c273f74fef50e498',1,'tjtransform']]],
+  ['options_6',['options',['../structtjtransform.html#ac0e74655baa4402209a21e1ae481c8f6',1,'tjtransform']]]
+];
diff --git a/3rdparty/libjpeg/src/doc/html/search/all_5.html b/3rdparty/libjpeg/src/doc/html/search/all_5.html
new file mode 100644
index 00000000..ebec30bf
--- /dev/null
+++ b/3rdparty/libjpeg/src/doc/html/search/all_5.html
@@ -0,0 +1,36 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html><head><title></title>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta name="generator" content="Doxygen 1.8.20"/>
+<link rel="stylesheet" type="text/css" href="search.css"/>
+<script type="text/javascript" src="all_5.js"></script>
+<script type="text/javascript" src="search.js"></script>
+</head>
+<body class="SRPage">
+<div id="SRIndex">
+<div class="SRStatus" id="Loading">Loading...</div>
+<div id="SRResults"></div>
+<script type="text/javascript"><!--
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+createResults();
+/* @license-end */
+--></script>
+<div class="SRStatus" id="Searching">Searching...</div>
+<div class="SRStatus" id="NoMatches">No Matches</div>
+<script type="text/javascript"><!--
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+document.getElementById("Loading").style.display="none";
+document.getElementById("NoMatches").style.display="none";
+var searchResults = new SearchResults("searchResults");
+searchResults.Search();
+window.addEventListener("message", function(event) {
+  if (event.data == "take_focus") {
+    var elem = searchResults.NavNext(0);
+    if (elem) elem.focus();
+  }
+});
+/* @license-end */
+--></script>
+</div>
+</body>
+</html>
diff --git a/3rdparty/libjpeg/src/doc/html/search/all_5.js b/3rdparty/libjpeg/src/doc/html/search/all_5.js
new file mode 100644
index 00000000..193b9007
--- /dev/null
+++ b/3rdparty/libjpeg/src/doc/html/search/all_5.js
@@ -0,0 +1,4 @@
+var searchData=
+[
+  ['r_7',['r',['../structtjtransform.html#ac324e5e442abec8a961e5bf219db12cf',1,'tjtransform']]]
+];
diff --git a/3rdparty/libjpeg/src/doc/html/search/all_6.html b/3rdparty/libjpeg/src/doc/html/search/all_6.html
new file mode 100644
index 00000000..31cbd052
--- /dev/null
+++ b/3rdparty/libjpeg/src/doc/html/search/all_6.html
@@ -0,0 +1,36 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html><head><title></title>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta name="generator" content="Doxygen 1.8.20"/>
+<link rel="stylesheet" type="text/css" href="search.css"/>
+<script type="text/javascript" src="all_6.js"></script>
+<script type="text/javascript" src="search.js"></script>
+</head>
+<body class="SRPage">
+<div id="SRIndex">
+<div class="SRStatus" id="Loading">Loading...</div>
+<div id="SRResults"></div>
+<script type="text/javascript"><!--
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+createResults();
+/* @license-end */
+--></script>
+<div class="SRStatus" id="Searching">Searching...</div>
+<div class="SRStatus" id="NoMatches">No Matches</div>
+<script type="text/javascript"><!--
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+document.getElementById("Loading").style.display="none";
+document.getElementById("NoMatches").style.display="none";
+var searchResults = new SearchResults("searchResults");
+searchResults.Search();
+window.addEventListener("message", function(event) {
+  if (event.data == "take_focus") {
+    var elem = searchResults.NavNext(0);
+    if (elem) elem.focus();
+  }
+});
+/* @license-end */
+--></script>
+</div>
+</body>
+</html>
diff --git a/3rdparty/libjpeg/src/doc/html/search/all_6.js b/3rdparty/libjpeg/src/doc/html/search/all_6.js
new file mode 100644
index 00000000..5750e1db
--- /dev/null
+++ b/3rdparty/libjpeg/src/doc/html/search/all_6.js
@@ -0,0 +1,102 @@
+var searchData=
+[
+  ['tj_5fnumcs_8',['TJ_NUMCS',['../group___turbo_j_p_e_g.html#ga39f57a6fb02d9cf32e7b6890099b5a71',1,'turbojpeg.h']]],
+  ['tj_5fnumerr_9',['TJ_NUMERR',['../group___turbo_j_p_e_g.html#ga79bde1b4a3e2351e00887e47781b966e',1,'turbojpeg.h']]],
+  ['tj_5fnumpf_10',['TJ_NUMPF',['../group___turbo_j_p_e_g.html#ga7010a4402f54a45ba822ad8675a4655e',1,'turbojpeg.h']]],
+  ['tj_5fnumsamp_11',['TJ_NUMSAMP',['../group___turbo_j_p_e_g.html#ga5ef3d169162ce77ce348e292a0b7477c',1,'turbojpeg.h']]],
+  ['tj_5fnumxop_12',['TJ_NUMXOP',['../group___turbo_j_p_e_g.html#ga0f6dbd18adf38b7d46ac547f0f4d562c',1,'turbojpeg.h']]],
+  ['tjalloc_13',['tjAlloc',['../group___turbo_j_p_e_g.html#gaec627dd4c5f30b7a775a7aea3bec5d83',1,'turbojpeg.h']]],
+  ['tjalphaoffset_14',['tjAlphaOffset',['../group___turbo_j_p_e_g.html#ga5af0ab065feefd526debf1e20c43e837',1,'turbojpeg.h']]],
+  ['tjblueoffset_15',['tjBlueOffset',['../group___turbo_j_p_e_g.html#ga84e2e35d3f08025f976ec1ec53693dea',1,'turbojpeg.h']]],
+  ['tjbufsize_16',['tjBufSize',['../group___turbo_j_p_e_g.html#ga67ac12fee79073242cb216e07c9f1f90',1,'turbojpeg.h']]],
+  ['tjbufsizeyuv2_17',['tjBufSizeYUV2',['../group___turbo_j_p_e_g.html#ga2be2b9969d4df9ecce9b05deed273194',1,'turbojpeg.h']]],
+  ['tjcompress2_18',['tjCompress2',['../group___turbo_j_p_e_g.html#gafbdce0112fd78fd38efae841443a9bcf',1,'turbojpeg.h']]],
+  ['tjcompressfromyuv_19',['tjCompressFromYUV',['../group___turbo_j_p_e_g.html#ga7622a459b79aa1007e005b58783f875b',1,'turbojpeg.h']]],
+  ['tjcompressfromyuvplanes_20',['tjCompressFromYUVPlanes',['../group___turbo_j_p_e_g.html#ga29ec5dfbd2d84b8724e951d6fa0d5d9e',1,'turbojpeg.h']]],
+  ['tjcs_21',['TJCS',['../group___turbo_j_p_e_g.html#ga4f83ad3368e0e29d1957be0efa7c3720',1,'turbojpeg.h']]],
+  ['tjcs_5fcmyk_22',['TJCS_CMYK',['../group___turbo_j_p_e_g.html#gga4f83ad3368e0e29d1957be0efa7c3720a6c8b636152ac8195b869587db315ee53',1,'turbojpeg.h']]],
+  ['tjcs_5fgray_23',['TJCS_GRAY',['../group___turbo_j_p_e_g.html#gga4f83ad3368e0e29d1957be0efa7c3720ab3e7d6a87f695e45b81c1b5262b5a50a',1,'turbojpeg.h']]],
+  ['tjcs_5frgb_24',['TJCS_RGB',['../group___turbo_j_p_e_g.html#gga4f83ad3368e0e29d1957be0efa7c3720a677cb7ccb85c4038ac41964a2e09e555',1,'turbojpeg.h']]],
+  ['tjcs_5fycbcr_25',['TJCS_YCbCr',['../group___turbo_j_p_e_g.html#gga4f83ad3368e0e29d1957be0efa7c3720a7389b8f65bb387ffedce3efd0d78ec75',1,'turbojpeg.h']]],
+  ['tjcs_5fycck_26',['TJCS_YCCK',['../group___turbo_j_p_e_g.html#gga4f83ad3368e0e29d1957be0efa7c3720a53839e0fe867b76b58d16b0a1a7c598e',1,'turbojpeg.h']]],
+  ['tjdecodeyuv_27',['tjDecodeYUV',['../group___turbo_j_p_e_g.html#ga70abbf38f77a26fd6da8813bef96f695',1,'turbojpeg.h']]],
+  ['tjdecodeyuvplanes_28',['tjDecodeYUVPlanes',['../group___turbo_j_p_e_g.html#ga10e837c07fa9d25770565b237d3898d9',1,'turbojpeg.h']]],
+  ['tjdecompress2_29',['tjDecompress2',['../group___turbo_j_p_e_g.html#gae9eccef8b682a48f43a9117c231ed013',1,'turbojpeg.h']]],
+  ['tjdecompressheader3_30',['tjDecompressHeader3',['../group___turbo_j_p_e_g.html#ga0595681096bba7199cc6f3533cb25f77',1,'turbojpeg.h']]],
+  ['tjdecompresstoyuv2_31',['tjDecompressToYUV2',['../group___turbo_j_p_e_g.html#ga04d1e839ff9a0860dd1475cff78d3364',1,'turbojpeg.h']]],
+  ['tjdecompresstoyuvplanes_32',['tjDecompressToYUVPlanes',['../group___turbo_j_p_e_g.html#gaa59f901a5258ada5bd0185ad59368540',1,'turbojpeg.h']]],
+  ['tjdestroy_33',['tjDestroy',['../group___turbo_j_p_e_g.html#ga75f355fa27225ba1a4ee392c852394d2',1,'turbojpeg.h']]],
+  ['tjencodeyuv3_34',['tjEncodeYUV3',['../group___turbo_j_p_e_g.html#gac519b922cdf446e97d0cdcba513636bf',1,'turbojpeg.h']]],
+  ['tjencodeyuvplanes_35',['tjEncodeYUVPlanes',['../group___turbo_j_p_e_g.html#gae2d04c72457fe7f4d60cf78ab1b1feb1',1,'turbojpeg.h']]],
+  ['tjerr_36',['TJERR',['../group___turbo_j_p_e_g.html#gafbc17cfa57d0d5d11fea35ac025950fe',1,'turbojpeg.h']]],
+  ['tjerr_5ffatal_37',['TJERR_FATAL',['../group___turbo_j_p_e_g.html#ggafbc17cfa57d0d5d11fea35ac025950feafc9cceeada13122b09e4851e3788039a',1,'turbojpeg.h']]],
+  ['tjerr_5fwarning_38',['TJERR_WARNING',['../group___turbo_j_p_e_g.html#ggafbc17cfa57d0d5d11fea35ac025950fea342dd6e2aedb47bb257b4e7568329b59',1,'turbojpeg.h']]],
+  ['tjflag_5faccuratedct_39',['TJFLAG_ACCURATEDCT',['../group___turbo_j_p_e_g.html#gacb233cfd722d66d1ccbf48a7de81f0e0',1,'turbojpeg.h']]],
+  ['tjflag_5fbottomup_40',['TJFLAG_BOTTOMUP',['../group___turbo_j_p_e_g.html#ga72ecf4ebe6eb702d3c6f5ca27455e1ec',1,'turbojpeg.h']]],
+  ['tjflag_5ffastdct_41',['TJFLAG_FASTDCT',['../group___turbo_j_p_e_g.html#gaabce235db80d3f698b27f36cbd453da2',1,'turbojpeg.h']]],
+  ['tjflag_5ffastupsample_42',['TJFLAG_FASTUPSAMPLE',['../group___turbo_j_p_e_g.html#ga4ee4506c81177a06f77e2504a22efd2d',1,'turbojpeg.h']]],
+  ['tjflag_5fnorealloc_43',['TJFLAG_NOREALLOC',['../group___turbo_j_p_e_g.html#ga8808d403c68b62aaa58a4c1e58e98963',1,'turbojpeg.h']]],
+  ['tjflag_5fprogressive_44',['TJFLAG_PROGRESSIVE',['../group___turbo_j_p_e_g.html#ga43b426750b46190a25d34a67ef76df1b',1,'turbojpeg.h']]],
+  ['tjflag_5fstoponwarning_45',['TJFLAG_STOPONWARNING',['../group___turbo_j_p_e_g.html#ga519cfa4ef6c18d9e5b455fdf59306a3a',1,'turbojpeg.h']]],
+  ['tjfree_46',['tjFree',['../group___turbo_j_p_e_g.html#gaea863d2da0cdb609563aabdf9196514b',1,'turbojpeg.h']]],
+  ['tjgeterrorcode_47',['tjGetErrorCode',['../group___turbo_j_p_e_g.html#ga414feeffbf860ebd31c745df203de410',1,'turbojpeg.h']]],
+  ['tjgeterrorstr2_48',['tjGetErrorStr2',['../group___turbo_j_p_e_g.html#ga1ead8574f9f39fbafc6b497124e7aafa',1,'turbojpeg.h']]],
+  ['tjgetscalingfactors_49',['tjGetScalingFactors',['../group___turbo_j_p_e_g.html#gac3854476006b10787bd128f7ede48057',1,'turbojpeg.h']]],
+  ['tjgreenoffset_50',['tjGreenOffset',['../group___turbo_j_p_e_g.html#ga82d6e35da441112a411da41923c0ba2f',1,'turbojpeg.h']]],
+  ['tjhandle_51',['tjhandle',['../group___turbo_j_p_e_g.html#ga758d2634ecb4949de7815cba621f5763',1,'turbojpeg.h']]],
+  ['tjinitcompress_52',['tjInitCompress',['../group___turbo_j_p_e_g.html#ga9d63a05fc6d813f4aae06107041a37e8',1,'turbojpeg.h']]],
+  ['tjinitdecompress_53',['tjInitDecompress',['../group___turbo_j_p_e_g.html#ga52300eac3f3d9ef4bab303bc244f62d3',1,'turbojpeg.h']]],
+  ['tjinittransform_54',['tjInitTransform',['../group___turbo_j_p_e_g.html#ga928beff6ac248ceadf01089fc6b41957',1,'turbojpeg.h']]],
+  ['tjloadimage_55',['tjLoadImage',['../group___turbo_j_p_e_g.html#gaffbd83c375e79f5db4b5c5d8ad4466e7',1,'turbojpeg.h']]],
+  ['tjmcuheight_56',['tjMCUHeight',['../group___turbo_j_p_e_g.html#gabd247bb9fecb393eca57366feb8327bf',1,'turbojpeg.h']]],
+  ['tjmcuwidth_57',['tjMCUWidth',['../group___turbo_j_p_e_g.html#ga9e61e7cd47a15a173283ba94e781308c',1,'turbojpeg.h']]],
+  ['tjpad_58',['TJPAD',['../group___turbo_j_p_e_g.html#ga0aba955473315e405295d978f0c16511',1,'turbojpeg.h']]],
+  ['tjpf_59',['TJPF',['../group___turbo_j_p_e_g.html#gac916144e26c3817ac514e64ae5d12e2a',1,'turbojpeg.h']]],
+  ['tjpf_5fabgr_60',['TJPF_ABGR',['../group___turbo_j_p_e_g.html#ggac916144e26c3817ac514e64ae5d12e2aa1ba1a7f1631dbeaa49a0a85fc4a40081',1,'turbojpeg.h']]],
+  ['tjpf_5fargb_61',['TJPF_ARGB',['../group___turbo_j_p_e_g.html#ggac916144e26c3817ac514e64ae5d12e2aae8f846ed9d9de99b6e1dfe448848765c',1,'turbojpeg.h']]],
+  ['tjpf_5fbgr_62',['TJPF_BGR',['../group___turbo_j_p_e_g.html#ggac916144e26c3817ac514e64ae5d12e2aab10624437fb8ef495a0b153e65749839',1,'turbojpeg.h']]],
+  ['tjpf_5fbgra_63',['TJPF_BGRA',['../group___turbo_j_p_e_g.html#ggac916144e26c3817ac514e64ae5d12e2aac037ff1845cf9b74bb81a3659c2b9fb4',1,'turbojpeg.h']]],
+  ['tjpf_5fbgrx_64',['TJPF_BGRX',['../group___turbo_j_p_e_g.html#ggac916144e26c3817ac514e64ae5d12e2aa2a1fbf569ca79897eae886e3376ca4c8',1,'turbojpeg.h']]],
+  ['tjpf_5fcmyk_65',['TJPF_CMYK',['../group___turbo_j_p_e_g.html#ggac916144e26c3817ac514e64ae5d12e2aa7f5100ec44c91994e243f1cf55553f8b',1,'turbojpeg.h']]],
+  ['tjpf_5fgray_66',['TJPF_GRAY',['../group___turbo_j_p_e_g.html#ggac916144e26c3817ac514e64ae5d12e2aa5431b54b015337705f13118073711a1a',1,'turbojpeg.h']]],
+  ['tjpf_5frgb_67',['TJPF_RGB',['../group___turbo_j_p_e_g.html#ggac916144e26c3817ac514e64ae5d12e2aa7ce93230bff449518ce387c17e6ed37c',1,'turbojpeg.h']]],
+  ['tjpf_5frgba_68',['TJPF_RGBA',['../group___turbo_j_p_e_g.html#ggac916144e26c3817ac514e64ae5d12e2aa88d2e88fab67f6503cf972e14851cc12',1,'turbojpeg.h']]],
+  ['tjpf_5frgbx_69',['TJPF_RGBX',['../group___turbo_j_p_e_g.html#ggac916144e26c3817ac514e64ae5d12e2aa83973bebb7e2dc6fa8bae89ff3f42e01',1,'turbojpeg.h']]],
+  ['tjpf_5funknown_70',['TJPF_UNKNOWN',['../group___turbo_j_p_e_g.html#ggac916144e26c3817ac514e64ae5d12e2aa84c1a6cead7952998e2fb895844a21ed',1,'turbojpeg.h']]],
+  ['tjpf_5fxbgr_71',['TJPF_XBGR',['../group___turbo_j_p_e_g.html#ggac916144e26c3817ac514e64ae5d12e2aaf6603b27147de47e212e75dac027b2af',1,'turbojpeg.h']]],
+  ['tjpf_5fxrgb_72',['TJPF_XRGB',['../group___turbo_j_p_e_g.html#ggac916144e26c3817ac514e64ae5d12e2aadae996905efcfa3b42a0bb3bea7f9d84',1,'turbojpeg.h']]],
+  ['tjpixelsize_73',['tjPixelSize',['../group___turbo_j_p_e_g.html#gad77cf8fe5b2bfd3cb3f53098146abb4c',1,'turbojpeg.h']]],
+  ['tjplaneheight_74',['tjPlaneHeight',['../group___turbo_j_p_e_g.html#ga1a209696c6a80748f20e134b3c64789f',1,'turbojpeg.h']]],
+  ['tjplanesizeyuv_75',['tjPlaneSizeYUV',['../group___turbo_j_p_e_g.html#gab4ab7b24f6e797d79abaaa670373961d',1,'turbojpeg.h']]],
+  ['tjplanewidth_76',['tjPlaneWidth',['../group___turbo_j_p_e_g.html#ga63fb66bb1e36c74008c4634360becbb1',1,'turbojpeg.h']]],
+  ['tjredoffset_77',['tjRedOffset',['../group___turbo_j_p_e_g.html#gadd9b446742ac8a3923f7992c7988fea8',1,'turbojpeg.h']]],
+  ['tjregion_78',['tjregion',['../structtjregion.html',1,'']]],
+  ['tjsamp_79',['TJSAMP',['../group___turbo_j_p_e_g.html#ga1d047060ea80bb9820d540bb928e9074',1,'turbojpeg.h']]],
+  ['tjsamp_5f411_80',['TJSAMP_411',['../group___turbo_j_p_e_g.html#gga1d047060ea80bb9820d540bb928e9074a28ec62575e5ea295c3fde3001dc628e2',1,'turbojpeg.h']]],
+  ['tjsamp_5f420_81',['TJSAMP_420',['../group___turbo_j_p_e_g.html#gga1d047060ea80bb9820d540bb928e9074a63085dbf683cfe39e513cdb6343e3737',1,'turbojpeg.h']]],
+  ['tjsamp_5f422_82',['TJSAMP_422',['../group___turbo_j_p_e_g.html#gga1d047060ea80bb9820d540bb928e9074a136130902cc578f11f32429b59368404',1,'turbojpeg.h']]],
+  ['tjsamp_5f440_83',['TJSAMP_440',['../group___turbo_j_p_e_g.html#gga1d047060ea80bb9820d540bb928e9074accf740e6f3aa6ba20ba922cad13cb974',1,'turbojpeg.h']]],
+  ['tjsamp_5f444_84',['TJSAMP_444',['../group___turbo_j_p_e_g.html#gga1d047060ea80bb9820d540bb928e9074afb8da4f44197837bdec0a4f593dacae3',1,'turbojpeg.h']]],
+  ['tjsamp_5fgray_85',['TJSAMP_GRAY',['../group___turbo_j_p_e_g.html#gga1d047060ea80bb9820d540bb928e9074a3f1c9504842ddc7a48d0f690754b6248',1,'turbojpeg.h']]],
+  ['tjsaveimage_86',['tjSaveImage',['../group___turbo_j_p_e_g.html#ga6f445b22d8933ae4815b3370a538d879',1,'turbojpeg.h']]],
+  ['tjscaled_87',['TJSCALED',['../group___turbo_j_p_e_g.html#ga84878bb65404204743aa18cac02781df',1,'turbojpeg.h']]],
+  ['tjscalingfactor_88',['tjscalingfactor',['../structtjscalingfactor.html',1,'']]],
+  ['tjtransform_89',['tjtransform',['../structtjtransform.html',1,'tjtransform'],['../group___turbo_j_p_e_g.html#ga504805ec0161f1b505397ca0118bf8fd',1,'tjtransform():&#160;turbojpeg.h'],['../group___turbo_j_p_e_g.html#ga9cb8abf4cc91881e04a0329b2270be25',1,'tjTransform(tjhandle handle, const unsigned char *jpegBuf, unsigned long jpegSize, int n, unsigned char **dstBufs, unsigned long *dstSizes, tjtransform *transforms, int flags):&#160;turbojpeg.h']]],
+  ['tjxop_90',['TJXOP',['../group___turbo_j_p_e_g.html#ga2de531af4e7e6c4f124908376b354866',1,'turbojpeg.h']]],
+  ['tjxop_5fhflip_91',['TJXOP_HFLIP',['../group___turbo_j_p_e_g.html#gga2de531af4e7e6c4f124908376b354866aa0df69776caa30f0fa28e26332d311ce',1,'turbojpeg.h']]],
+  ['tjxop_5fnone_92',['TJXOP_NONE',['../group___turbo_j_p_e_g.html#gga2de531af4e7e6c4f124908376b354866aad88c0366cd3f7d0eac9d7a3fa1c2c27',1,'turbojpeg.h']]],
+  ['tjxop_5frot180_93',['TJXOP_ROT180',['../group___turbo_j_p_e_g.html#gga2de531af4e7e6c4f124908376b354866a140952eb8dd0300accfcc22726d69692',1,'turbojpeg.h']]],
+  ['tjxop_5frot270_94',['TJXOP_ROT270',['../group___turbo_j_p_e_g.html#gga2de531af4e7e6c4f124908376b354866a3064ee5dfb7f032df332818587567a08',1,'turbojpeg.h']]],
+  ['tjxop_5frot90_95',['TJXOP_ROT90',['../group___turbo_j_p_e_g.html#gga2de531af4e7e6c4f124908376b354866a43b2bbb23bc4bd548422d43fbe9af128',1,'turbojpeg.h']]],
+  ['tjxop_5ftranspose_96',['TJXOP_TRANSPOSE',['../group___turbo_j_p_e_g.html#gga2de531af4e7e6c4f124908376b354866a31060aed199f886afdd417f80499c32d',1,'turbojpeg.h']]],
+  ['tjxop_5ftransverse_97',['TJXOP_TRANSVERSE',['../group___turbo_j_p_e_g.html#gga2de531af4e7e6c4f124908376b354866af3b14d488aea6ece9e5b3df73a74d6a4',1,'turbojpeg.h']]],
+  ['tjxop_5fvflip_98',['TJXOP_VFLIP',['../group___turbo_j_p_e_g.html#gga2de531af4e7e6c4f124908376b354866a324eddfbec53b7e691f61e56929d0d5d',1,'turbojpeg.h']]],
+  ['tjxopt_5fcopynone_99',['TJXOPT_COPYNONE',['../group___turbo_j_p_e_g.html#ga153b468cfb905d0de61706c838986fe8',1,'turbojpeg.h']]],
+  ['tjxopt_5fcrop_100',['TJXOPT_CROP',['../group___turbo_j_p_e_g.html#ga9c771a757fc1294add611906b89ab2d2',1,'turbojpeg.h']]],
+  ['tjxopt_5fgray_101',['TJXOPT_GRAY',['../group___turbo_j_p_e_g.html#ga3acee7b48ade1b99e5588736007c2589',1,'turbojpeg.h']]],
+  ['tjxopt_5fnooutput_102',['TJXOPT_NOOUTPUT',['../group___turbo_j_p_e_g.html#gafbf992bbf6e006705886333703ffab31',1,'turbojpeg.h']]],
+  ['tjxopt_5fperfect_103',['TJXOPT_PERFECT',['../group___turbo_j_p_e_g.html#ga50e03cb5ed115330e212417429600b00',1,'turbojpeg.h']]],
+  ['tjxopt_5fprogressive_104',['TJXOPT_PROGRESSIVE',['../group___turbo_j_p_e_g.html#gad2371c80674584ecc1a7d75e564cf026',1,'turbojpeg.h']]],
+  ['tjxopt_5ftrim_105',['TJXOPT_TRIM',['../group___turbo_j_p_e_g.html#ga319826b7eb1583c0595bbe7b95428709',1,'turbojpeg.h']]],
+  ['turbojpeg_106',['TurboJPEG',['../group___turbo_j_p_e_g.html',1,'']]]
+];
diff --git a/3rdparty/libjpeg/src/doc/html/search/all_7.html b/3rdparty/libjpeg/src/doc/html/search/all_7.html
new file mode 100644
index 00000000..18c555de
--- /dev/null
+++ b/3rdparty/libjpeg/src/doc/html/search/all_7.html
@@ -0,0 +1,36 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html><head><title></title>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta name="generator" content="Doxygen 1.8.20"/>
+<link rel="stylesheet" type="text/css" href="search.css"/>
+<script type="text/javascript" src="all_7.js"></script>
+<script type="text/javascript" src="search.js"></script>
+</head>
+<body class="SRPage">
+<div id="SRIndex">
+<div class="SRStatus" id="Loading">Loading...</div>
+<div id="SRResults"></div>
+<script type="text/javascript"><!--
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+createResults();
+/* @license-end */
+--></script>
+<div class="SRStatus" id="Searching">Searching...</div>
+<div class="SRStatus" id="NoMatches">No Matches</div>
+<script type="text/javascript"><!--
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+document.getElementById("Loading").style.display="none";
+document.getElementById("NoMatches").style.display="none";
+var searchResults = new SearchResults("searchResults");
+searchResults.Search();
+window.addEventListener("message", function(event) {
+  if (event.data == "take_focus") {
+    var elem = searchResults.NavNext(0);
+    if (elem) elem.focus();
+  }
+});
+/* @license-end */
+--></script>
+</div>
+</body>
+</html>
diff --git a/3rdparty/libjpeg/src/doc/html/search/all_7.js b/3rdparty/libjpeg/src/doc/html/search/all_7.js
new file mode 100644
index 00000000..aa89546f
--- /dev/null
+++ b/3rdparty/libjpeg/src/doc/html/search/all_7.js
@@ -0,0 +1,4 @@
+var searchData=
+[
+  ['w_107',['w',['../structtjregion.html#ab6eb73ceef584fc23c8c8097926dce42',1,'tjregion']]]
+];
diff --git a/3rdparty/libjpeg/src/doc/html/search/all_8.html b/3rdparty/libjpeg/src/doc/html/search/all_8.html
new file mode 100644
index 00000000..0f9eb416
--- /dev/null
+++ b/3rdparty/libjpeg/src/doc/html/search/all_8.html
@@ -0,0 +1,36 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html><head><title></title>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta name="generator" content="Doxygen 1.8.20"/>
+<link rel="stylesheet" type="text/css" href="search.css"/>
+<script type="text/javascript" src="all_8.js"></script>
+<script type="text/javascript" src="search.js"></script>
+</head>
+<body class="SRPage">
+<div id="SRIndex">
+<div class="SRStatus" id="Loading">Loading...</div>
+<div id="SRResults"></div>
+<script type="text/javascript"><!--
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+createResults();
+/* @license-end */
+--></script>
+<div class="SRStatus" id="Searching">Searching...</div>
+<div class="SRStatus" id="NoMatches">No Matches</div>
+<script type="text/javascript"><!--
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+document.getElementById("Loading").style.display="none";
+document.getElementById("NoMatches").style.display="none";
+var searchResults = new SearchResults("searchResults");
+searchResults.Search();
+window.addEventListener("message", function(event) {
+  if (event.data == "take_focus") {
+    var elem = searchResults.NavNext(0);
+    if (elem) elem.focus();
+  }
+});
+/* @license-end */
+--></script>
+</div>
+</body>
+</html>
diff --git a/3rdparty/libjpeg/src/doc/html/search/all_8.js b/3rdparty/libjpeg/src/doc/html/search/all_8.js
new file mode 100644
index 00000000..5d73a5a2
--- /dev/null
+++ b/3rdparty/libjpeg/src/doc/html/search/all_8.js
@@ -0,0 +1,4 @@
+var searchData=
+[
+  ['x_108',['x',['../structtjregion.html#a4b6a37a93997091b26a75831fa291ad9',1,'tjregion']]]
+];
diff --git a/3rdparty/libjpeg/src/doc/html/search/all_9.html b/3rdparty/libjpeg/src/doc/html/search/all_9.html
new file mode 100644
index 00000000..d27c0f7c
--- /dev/null
+++ b/3rdparty/libjpeg/src/doc/html/search/all_9.html
@@ -0,0 +1,36 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html><head><title></title>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta name="generator" content="Doxygen 1.8.20"/>
+<link rel="stylesheet" type="text/css" href="search.css"/>
+<script type="text/javascript" src="all_9.js"></script>
+<script type="text/javascript" src="search.js"></script>
+</head>
+<body class="SRPage">
+<div id="SRIndex">
+<div class="SRStatus" id="Loading">Loading...</div>
+<div id="SRResults"></div>
+<script type="text/javascript"><!--
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+createResults();
+/* @license-end */
+--></script>
+<div class="SRStatus" id="Searching">Searching...</div>
+<div class="SRStatus" id="NoMatches">No Matches</div>
+<script type="text/javascript"><!--
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+document.getElementById("Loading").style.display="none";
+document.getElementById("NoMatches").style.display="none";
+var searchResults = new SearchResults("searchResults");
+searchResults.Search();
+window.addEventListener("message", function(event) {
+  if (event.data == "take_focus") {
+    var elem = searchResults.NavNext(0);
+    if (elem) elem.focus();
+  }
+});
+/* @license-end */
+--></script>
+</div>
+</body>
+</html>
diff --git a/3rdparty/libjpeg/src/doc/html/search/all_9.js b/3rdparty/libjpeg/src/doc/html/search/all_9.js
new file mode 100644
index 00000000..72ea5700
--- /dev/null
+++ b/3rdparty/libjpeg/src/doc/html/search/all_9.js
@@ -0,0 +1,4 @@
+var searchData=
+[
+  ['y_109',['y',['../structtjregion.html#a7b3e0c24cfe87acc80e334cafdcf22c2',1,'tjregion']]]
+];
diff --git a/3rdparty/libjpeg/src/doc/html/search/classes_0.html b/3rdparty/libjpeg/src/doc/html/search/classes_0.html
new file mode 100644
index 00000000..7e0afc84
--- /dev/null
+++ b/3rdparty/libjpeg/src/doc/html/search/classes_0.html
@@ -0,0 +1,36 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html><head><title></title>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta name="generator" content="Doxygen 1.8.20"/>
+<link rel="stylesheet" type="text/css" href="search.css"/>
+<script type="text/javascript" src="classes_0.js"></script>
+<script type="text/javascript" src="search.js"></script>
+</head>
+<body class="SRPage">
+<div id="SRIndex">
+<div class="SRStatus" id="Loading">Loading...</div>
+<div id="SRResults"></div>
+<script type="text/javascript"><!--
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+createResults();
+/* @license-end */
+--></script>
+<div class="SRStatus" id="Searching">Searching...</div>
+<div class="SRStatus" id="NoMatches">No Matches</div>
+<script type="text/javascript"><!--
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+document.getElementById("Loading").style.display="none";
+document.getElementById("NoMatches").style.display="none";
+var searchResults = new SearchResults("searchResults");
+searchResults.Search();
+window.addEventListener("message", function(event) {
+  if (event.data == "take_focus") {
+    var elem = searchResults.NavNext(0);
+    if (elem) elem.focus();
+  }
+});
+/* @license-end */
+--></script>
+</div>
+</body>
+</html>
diff --git a/3rdparty/libjpeg/src/doc/html/search/classes_0.js b/3rdparty/libjpeg/src/doc/html/search/classes_0.js
new file mode 100644
index 00000000..ac6518bf
--- /dev/null
+++ b/3rdparty/libjpeg/src/doc/html/search/classes_0.js
@@ -0,0 +1,6 @@
+var searchData=
+[
+  ['tjregion_110',['tjregion',['../structtjregion.html',1,'']]],
+  ['tjscalingfactor_111',['tjscalingfactor',['../structtjscalingfactor.html',1,'']]],
+  ['tjtransform_112',['tjtransform',['../structtjtransform.html',1,'']]]
+];
diff --git a/3rdparty/libjpeg/src/doc/html/search/close.svg b/3rdparty/libjpeg/src/doc/html/search/close.svg
new file mode 100644
index 00000000..a933eea1
--- /dev/null
+++ b/3rdparty/libjpeg/src/doc/html/search/close.svg
@@ -0,0 +1,31 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg
+   xmlns:dc="http://purl.org/dc/elements/1.1/"
+   xmlns:cc="http://creativecommons.org/ns#"
+   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+   xmlns:svg="http://www.w3.org/2000/svg"
+   xmlns="http://www.w3.org/2000/svg"
+   viewBox="0 0 11 11"
+   height="11"
+   width="11"
+   id="svg2"
+   version="1.1">
+  <metadata
+     id="metadata8">
+    <rdf:RDF>
+      <cc:Work
+         rdf:about="">
+        <dc:format>image/svg+xml</dc:format>
+        <dc:type
+           rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
+        <dc:title></dc:title>
+      </cc:Work>
+    </rdf:RDF>
+  </metadata>
+  <defs
+     id="defs6" />
+  <path
+     id="path12"
+     d="M 5.5 0.5 A 5 5 0 0 0 0.5 5.5 A 5 5 0 0 0 5.5 10.5 A 5 5 0 0 0 10.5 5.5 A 5 5 0 0 0 5.5 0.5 z M 3.5820312 3 A 0.58291923 0.58291923 0 0 1 4 3.1757812 L 5.5 4.6757812 L 7 3.1757812 A 0.58291923 0.58291923 0 0 1 7.4003906 3 A 0.58291923 0.58291923 0 0 1 7.8242188 4 L 6.3242188 5.5 L 7.8242188 7 A 0.58291923 0.58291923 0 1 1 7 7.8242188 L 5.5 6.3242188 L 4 7.8242188 A 0.58291923 0.58291923 0 1 1 3.1757812 7 L 4.6757812 5.5 L 3.1757812 4 A 0.58291923 0.58291923 0 0 1 3.5820312 3 z "
+     style="stroke-width:1.09870648;fill:#bababa;fill-opacity:1" />
+</svg>
diff --git a/3rdparty/libjpeg/src/doc/html/search/enums_0.html b/3rdparty/libjpeg/src/doc/html/search/enums_0.html
new file mode 100644
index 00000000..9035e6aa
--- /dev/null
+++ b/3rdparty/libjpeg/src/doc/html/search/enums_0.html
@@ -0,0 +1,36 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html><head><title></title>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta name="generator" content="Doxygen 1.8.20"/>
+<link rel="stylesheet" type="text/css" href="search.css"/>
+<script type="text/javascript" src="enums_0.js"></script>
+<script type="text/javascript" src="search.js"></script>
+</head>
+<body class="SRPage">
+<div id="SRIndex">
+<div class="SRStatus" id="Loading">Loading...</div>
+<div id="SRResults"></div>
+<script type="text/javascript"><!--
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+createResults();
+/* @license-end */
+--></script>
+<div class="SRStatus" id="Searching">Searching...</div>
+<div class="SRStatus" id="NoMatches">No Matches</div>
+<script type="text/javascript"><!--
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+document.getElementById("Loading").style.display="none";
+document.getElementById("NoMatches").style.display="none";
+var searchResults = new SearchResults("searchResults");
+searchResults.Search();
+window.addEventListener("message", function(event) {
+  if (event.data == "take_focus") {
+    var elem = searchResults.NavNext(0);
+    if (elem) elem.focus();
+  }
+});
+/* @license-end */
+--></script>
+</div>
+</body>
+</html>
diff --git a/3rdparty/libjpeg/src/doc/html/search/enums_0.js b/3rdparty/libjpeg/src/doc/html/search/enums_0.js
new file mode 100644
index 00000000..2626d66b
--- /dev/null
+++ b/3rdparty/libjpeg/src/doc/html/search/enums_0.js
@@ -0,0 +1,8 @@
+var searchData=
+[
+  ['tjcs_161',['TJCS',['../group___turbo_j_p_e_g.html#ga4f83ad3368e0e29d1957be0efa7c3720',1,'turbojpeg.h']]],
+  ['tjerr_162',['TJERR',['../group___turbo_j_p_e_g.html#gafbc17cfa57d0d5d11fea35ac025950fe',1,'turbojpeg.h']]],
+  ['tjpf_163',['TJPF',['../group___turbo_j_p_e_g.html#gac916144e26c3817ac514e64ae5d12e2a',1,'turbojpeg.h']]],
+  ['tjsamp_164',['TJSAMP',['../group___turbo_j_p_e_g.html#ga1d047060ea80bb9820d540bb928e9074',1,'turbojpeg.h']]],
+  ['tjxop_165',['TJXOP',['../group___turbo_j_p_e_g.html#ga2de531af4e7e6c4f124908376b354866',1,'turbojpeg.h']]]
+];
diff --git a/3rdparty/libjpeg/src/doc/html/search/enumvalues_0.html b/3rdparty/libjpeg/src/doc/html/search/enumvalues_0.html
new file mode 100644
index 00000000..c2cd472a
--- /dev/null
+++ b/3rdparty/libjpeg/src/doc/html/search/enumvalues_0.html
@@ -0,0 +1,36 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html><head><title></title>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta name="generator" content="Doxygen 1.8.20"/>
+<link rel="stylesheet" type="text/css" href="search.css"/>
+<script type="text/javascript" src="enumvalues_0.js"></script>
+<script type="text/javascript" src="search.js"></script>
+</head>
+<body class="SRPage">
+<div id="SRIndex">
+<div class="SRStatus" id="Loading">Loading...</div>
+<div id="SRResults"></div>
+<script type="text/javascript"><!--
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+createResults();
+/* @license-end */
+--></script>
+<div class="SRStatus" id="Searching">Searching...</div>
+<div class="SRStatus" id="NoMatches">No Matches</div>
+<script type="text/javascript"><!--
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+document.getElementById("Loading").style.display="none";
+document.getElementById("NoMatches").style.display="none";
+var searchResults = new SearchResults("searchResults");
+searchResults.Search();
+window.addEventListener("message", function(event) {
+  if (event.data == "take_focus") {
+    var elem = searchResults.NavNext(0);
+    if (elem) elem.focus();
+  }
+});
+/* @license-end */
+--></script>
+</div>
+</body>
+</html>
diff --git a/3rdparty/libjpeg/src/doc/html/search/enumvalues_0.js b/3rdparty/libjpeg/src/doc/html/search/enumvalues_0.js
new file mode 100644
index 00000000..4612b1f3
--- /dev/null
+++ b/3rdparty/libjpeg/src/doc/html/search/enumvalues_0.js
@@ -0,0 +1,37 @@
+var searchData=
+[
+  ['tjcs_5fcmyk_166',['TJCS_CMYK',['../group___turbo_j_p_e_g.html#gga4f83ad3368e0e29d1957be0efa7c3720a6c8b636152ac8195b869587db315ee53',1,'turbojpeg.h']]],
+  ['tjcs_5fgray_167',['TJCS_GRAY',['../group___turbo_j_p_e_g.html#gga4f83ad3368e0e29d1957be0efa7c3720ab3e7d6a87f695e45b81c1b5262b5a50a',1,'turbojpeg.h']]],
+  ['tjcs_5frgb_168',['TJCS_RGB',['../group___turbo_j_p_e_g.html#gga4f83ad3368e0e29d1957be0efa7c3720a677cb7ccb85c4038ac41964a2e09e555',1,'turbojpeg.h']]],
+  ['tjcs_5fycbcr_169',['TJCS_YCbCr',['../group___turbo_j_p_e_g.html#gga4f83ad3368e0e29d1957be0efa7c3720a7389b8f65bb387ffedce3efd0d78ec75',1,'turbojpeg.h']]],
+  ['tjcs_5fycck_170',['TJCS_YCCK',['../group___turbo_j_p_e_g.html#gga4f83ad3368e0e29d1957be0efa7c3720a53839e0fe867b76b58d16b0a1a7c598e',1,'turbojpeg.h']]],
+  ['tjerr_5ffatal_171',['TJERR_FATAL',['../group___turbo_j_p_e_g.html#ggafbc17cfa57d0d5d11fea35ac025950feafc9cceeada13122b09e4851e3788039a',1,'turbojpeg.h']]],
+  ['tjerr_5fwarning_172',['TJERR_WARNING',['../group___turbo_j_p_e_g.html#ggafbc17cfa57d0d5d11fea35ac025950fea342dd6e2aedb47bb257b4e7568329b59',1,'turbojpeg.h']]],
+  ['tjpf_5fabgr_173',['TJPF_ABGR',['../group___turbo_j_p_e_g.html#ggac916144e26c3817ac514e64ae5d12e2aa1ba1a7f1631dbeaa49a0a85fc4a40081',1,'turbojpeg.h']]],
+  ['tjpf_5fargb_174',['TJPF_ARGB',['../group___turbo_j_p_e_g.html#ggac916144e26c3817ac514e64ae5d12e2aae8f846ed9d9de99b6e1dfe448848765c',1,'turbojpeg.h']]],
+  ['tjpf_5fbgr_175',['TJPF_BGR',['../group___turbo_j_p_e_g.html#ggac916144e26c3817ac514e64ae5d12e2aab10624437fb8ef495a0b153e65749839',1,'turbojpeg.h']]],
+  ['tjpf_5fbgra_176',['TJPF_BGRA',['../group___turbo_j_p_e_g.html#ggac916144e26c3817ac514e64ae5d12e2aac037ff1845cf9b74bb81a3659c2b9fb4',1,'turbojpeg.h']]],
+  ['tjpf_5fbgrx_177',['TJPF_BGRX',['../group___turbo_j_p_e_g.html#ggac916144e26c3817ac514e64ae5d12e2aa2a1fbf569ca79897eae886e3376ca4c8',1,'turbojpeg.h']]],
+  ['tjpf_5fcmyk_178',['TJPF_CMYK',['../group___turbo_j_p_e_g.html#ggac916144e26c3817ac514e64ae5d12e2aa7f5100ec44c91994e243f1cf55553f8b',1,'turbojpeg.h']]],
+  ['tjpf_5fgray_179',['TJPF_GRAY',['../group___turbo_j_p_e_g.html#ggac916144e26c3817ac514e64ae5d12e2aa5431b54b015337705f13118073711a1a',1,'turbojpeg.h']]],
+  ['tjpf_5frgb_180',['TJPF_RGB',['../group___turbo_j_p_e_g.html#ggac916144e26c3817ac514e64ae5d12e2aa7ce93230bff449518ce387c17e6ed37c',1,'turbojpeg.h']]],
+  ['tjpf_5frgba_181',['TJPF_RGBA',['../group___turbo_j_p_e_g.html#ggac916144e26c3817ac514e64ae5d12e2aa88d2e88fab67f6503cf972e14851cc12',1,'turbojpeg.h']]],
+  ['tjpf_5frgbx_182',['TJPF_RGBX',['../group___turbo_j_p_e_g.html#ggac916144e26c3817ac514e64ae5d12e2aa83973bebb7e2dc6fa8bae89ff3f42e01',1,'turbojpeg.h']]],
+  ['tjpf_5funknown_183',['TJPF_UNKNOWN',['../group___turbo_j_p_e_g.html#ggac916144e26c3817ac514e64ae5d12e2aa84c1a6cead7952998e2fb895844a21ed',1,'turbojpeg.h']]],
+  ['tjpf_5fxbgr_184',['TJPF_XBGR',['../group___turbo_j_p_e_g.html#ggac916144e26c3817ac514e64ae5d12e2aaf6603b27147de47e212e75dac027b2af',1,'turbojpeg.h']]],
+  ['tjpf_5fxrgb_185',['TJPF_XRGB',['../group___turbo_j_p_e_g.html#ggac916144e26c3817ac514e64ae5d12e2aadae996905efcfa3b42a0bb3bea7f9d84',1,'turbojpeg.h']]],
+  ['tjsamp_5f411_186',['TJSAMP_411',['../group___turbo_j_p_e_g.html#gga1d047060ea80bb9820d540bb928e9074a28ec62575e5ea295c3fde3001dc628e2',1,'turbojpeg.h']]],
+  ['tjsamp_5f420_187',['TJSAMP_420',['../group___turbo_j_p_e_g.html#gga1d047060ea80bb9820d540bb928e9074a63085dbf683cfe39e513cdb6343e3737',1,'turbojpeg.h']]],
+  ['tjsamp_5f422_188',['TJSAMP_422',['../group___turbo_j_p_e_g.html#gga1d047060ea80bb9820d540bb928e9074a136130902cc578f11f32429b59368404',1,'turbojpeg.h']]],
+  ['tjsamp_5f440_189',['TJSAMP_440',['../group___turbo_j_p_e_g.html#gga1d047060ea80bb9820d540bb928e9074accf740e6f3aa6ba20ba922cad13cb974',1,'turbojpeg.h']]],
+  ['tjsamp_5f444_190',['TJSAMP_444',['../group___turbo_j_p_e_g.html#gga1d047060ea80bb9820d540bb928e9074afb8da4f44197837bdec0a4f593dacae3',1,'turbojpeg.h']]],
+  ['tjsamp_5fgray_191',['TJSAMP_GRAY',['../group___turbo_j_p_e_g.html#gga1d047060ea80bb9820d540bb928e9074a3f1c9504842ddc7a48d0f690754b6248',1,'turbojpeg.h']]],
+  ['tjxop_5fhflip_192',['TJXOP_HFLIP',['../group___turbo_j_p_e_g.html#gga2de531af4e7e6c4f124908376b354866aa0df69776caa30f0fa28e26332d311ce',1,'turbojpeg.h']]],
+  ['tjxop_5fnone_193',['TJXOP_NONE',['../group___turbo_j_p_e_g.html#gga2de531af4e7e6c4f124908376b354866aad88c0366cd3f7d0eac9d7a3fa1c2c27',1,'turbojpeg.h']]],
+  ['tjxop_5frot180_194',['TJXOP_ROT180',['../group___turbo_j_p_e_g.html#gga2de531af4e7e6c4f124908376b354866a140952eb8dd0300accfcc22726d69692',1,'turbojpeg.h']]],
+  ['tjxop_5frot270_195',['TJXOP_ROT270',['../group___turbo_j_p_e_g.html#gga2de531af4e7e6c4f124908376b354866a3064ee5dfb7f032df332818587567a08',1,'turbojpeg.h']]],
+  ['tjxop_5frot90_196',['TJXOP_ROT90',['../group___turbo_j_p_e_g.html#gga2de531af4e7e6c4f124908376b354866a43b2bbb23bc4bd548422d43fbe9af128',1,'turbojpeg.h']]],
+  ['tjxop_5ftranspose_197',['TJXOP_TRANSPOSE',['../group___turbo_j_p_e_g.html#gga2de531af4e7e6c4f124908376b354866a31060aed199f886afdd417f80499c32d',1,'turbojpeg.h']]],
+  ['tjxop_5ftransverse_198',['TJXOP_TRANSVERSE',['../group___turbo_j_p_e_g.html#gga2de531af4e7e6c4f124908376b354866af3b14d488aea6ece9e5b3df73a74d6a4',1,'turbojpeg.h']]],
+  ['tjxop_5fvflip_199',['TJXOP_VFLIP',['../group___turbo_j_p_e_g.html#gga2de531af4e7e6c4f124908376b354866a324eddfbec53b7e691f61e56929d0d5d',1,'turbojpeg.h']]]
+];
diff --git a/3rdparty/libjpeg/src/doc/html/search/functions_0.html b/3rdparty/libjpeg/src/doc/html/search/functions_0.html
new file mode 100644
index 00000000..f04535ae
--- /dev/null
+++ b/3rdparty/libjpeg/src/doc/html/search/functions_0.html
@@ -0,0 +1,36 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html><head><title></title>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta name="generator" content="Doxygen 1.8.20"/>
+<link rel="stylesheet" type="text/css" href="search.css"/>
+<script type="text/javascript" src="functions_0.js"></script>
+<script type="text/javascript" src="search.js"></script>
+</head>
+<body class="SRPage">
+<div id="SRIndex">
+<div class="SRStatus" id="Loading">Loading...</div>
+<div id="SRResults"></div>
+<script type="text/javascript"><!--
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+createResults();
+/* @license-end */
+--></script>
+<div class="SRStatus" id="Searching">Searching...</div>
+<div class="SRStatus" id="NoMatches">No Matches</div>
+<script type="text/javascript"><!--
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+document.getElementById("Loading").style.display="none";
+document.getElementById("NoMatches").style.display="none";
+var searchResults = new SearchResults("searchResults");
+searchResults.Search();
+window.addEventListener("message", function(event) {
+  if (event.data == "take_focus") {
+    var elem = searchResults.NavNext(0);
+    if (elem) elem.focus();
+  }
+});
+/* @license-end */
+--></script>
+</div>
+</body>
+</html>
diff --git a/3rdparty/libjpeg/src/doc/html/search/functions_0.js b/3rdparty/libjpeg/src/doc/html/search/functions_0.js
new file mode 100644
index 00000000..121df92e
--- /dev/null
+++ b/3rdparty/libjpeg/src/doc/html/search/functions_0.js
@@ -0,0 +1,31 @@
+var searchData=
+[
+  ['tjalloc_113',['tjAlloc',['../group___turbo_j_p_e_g.html#gaec627dd4c5f30b7a775a7aea3bec5d83',1,'turbojpeg.h']]],
+  ['tjbufsize_114',['tjBufSize',['../group___turbo_j_p_e_g.html#ga67ac12fee79073242cb216e07c9f1f90',1,'turbojpeg.h']]],
+  ['tjbufsizeyuv2_115',['tjBufSizeYUV2',['../group___turbo_j_p_e_g.html#ga2be2b9969d4df9ecce9b05deed273194',1,'turbojpeg.h']]],
+  ['tjcompress2_116',['tjCompress2',['../group___turbo_j_p_e_g.html#gafbdce0112fd78fd38efae841443a9bcf',1,'turbojpeg.h']]],
+  ['tjcompressfromyuv_117',['tjCompressFromYUV',['../group___turbo_j_p_e_g.html#ga7622a459b79aa1007e005b58783f875b',1,'turbojpeg.h']]],
+  ['tjcompressfromyuvplanes_118',['tjCompressFromYUVPlanes',['../group___turbo_j_p_e_g.html#ga29ec5dfbd2d84b8724e951d6fa0d5d9e',1,'turbojpeg.h']]],
+  ['tjdecodeyuv_119',['tjDecodeYUV',['../group___turbo_j_p_e_g.html#ga70abbf38f77a26fd6da8813bef96f695',1,'turbojpeg.h']]],
+  ['tjdecodeyuvplanes_120',['tjDecodeYUVPlanes',['../group___turbo_j_p_e_g.html#ga10e837c07fa9d25770565b237d3898d9',1,'turbojpeg.h']]],
+  ['tjdecompress2_121',['tjDecompress2',['../group___turbo_j_p_e_g.html#gae9eccef8b682a48f43a9117c231ed013',1,'turbojpeg.h']]],
+  ['tjdecompressheader3_122',['tjDecompressHeader3',['../group___turbo_j_p_e_g.html#ga0595681096bba7199cc6f3533cb25f77',1,'turbojpeg.h']]],
+  ['tjdecompresstoyuv2_123',['tjDecompressToYUV2',['../group___turbo_j_p_e_g.html#ga04d1e839ff9a0860dd1475cff78d3364',1,'turbojpeg.h']]],
+  ['tjdecompresstoyuvplanes_124',['tjDecompressToYUVPlanes',['../group___turbo_j_p_e_g.html#gaa59f901a5258ada5bd0185ad59368540',1,'turbojpeg.h']]],
+  ['tjdestroy_125',['tjDestroy',['../group___turbo_j_p_e_g.html#ga75f355fa27225ba1a4ee392c852394d2',1,'turbojpeg.h']]],
+  ['tjencodeyuv3_126',['tjEncodeYUV3',['../group___turbo_j_p_e_g.html#gac519b922cdf446e97d0cdcba513636bf',1,'turbojpeg.h']]],
+  ['tjencodeyuvplanes_127',['tjEncodeYUVPlanes',['../group___turbo_j_p_e_g.html#gae2d04c72457fe7f4d60cf78ab1b1feb1',1,'turbojpeg.h']]],
+  ['tjfree_128',['tjFree',['../group___turbo_j_p_e_g.html#gaea863d2da0cdb609563aabdf9196514b',1,'turbojpeg.h']]],
+  ['tjgeterrorcode_129',['tjGetErrorCode',['../group___turbo_j_p_e_g.html#ga414feeffbf860ebd31c745df203de410',1,'turbojpeg.h']]],
+  ['tjgeterrorstr2_130',['tjGetErrorStr2',['../group___turbo_j_p_e_g.html#ga1ead8574f9f39fbafc6b497124e7aafa',1,'turbojpeg.h']]],
+  ['tjgetscalingfactors_131',['tjGetScalingFactors',['../group___turbo_j_p_e_g.html#gac3854476006b10787bd128f7ede48057',1,'turbojpeg.h']]],
+  ['tjinitcompress_132',['tjInitCompress',['../group___turbo_j_p_e_g.html#ga9d63a05fc6d813f4aae06107041a37e8',1,'turbojpeg.h']]],
+  ['tjinitdecompress_133',['tjInitDecompress',['../group___turbo_j_p_e_g.html#ga52300eac3f3d9ef4bab303bc244f62d3',1,'turbojpeg.h']]],
+  ['tjinittransform_134',['tjInitTransform',['../group___turbo_j_p_e_g.html#ga928beff6ac248ceadf01089fc6b41957',1,'turbojpeg.h']]],
+  ['tjloadimage_135',['tjLoadImage',['../group___turbo_j_p_e_g.html#gaffbd83c375e79f5db4b5c5d8ad4466e7',1,'turbojpeg.h']]],
+  ['tjplaneheight_136',['tjPlaneHeight',['../group___turbo_j_p_e_g.html#ga1a209696c6a80748f20e134b3c64789f',1,'turbojpeg.h']]],
+  ['tjplanesizeyuv_137',['tjPlaneSizeYUV',['../group___turbo_j_p_e_g.html#gab4ab7b24f6e797d79abaaa670373961d',1,'turbojpeg.h']]],
+  ['tjplanewidth_138',['tjPlaneWidth',['../group___turbo_j_p_e_g.html#ga63fb66bb1e36c74008c4634360becbb1',1,'turbojpeg.h']]],
+  ['tjsaveimage_139',['tjSaveImage',['../group___turbo_j_p_e_g.html#ga6f445b22d8933ae4815b3370a538d879',1,'turbojpeg.h']]],
+  ['tjtransform_140',['tjTransform',['../group___turbo_j_p_e_g.html#ga9cb8abf4cc91881e04a0329b2270be25',1,'turbojpeg.h']]]
+];
diff --git a/3rdparty/libjpeg/src/doc/html/search/groups_0.html b/3rdparty/libjpeg/src/doc/html/search/groups_0.html
new file mode 100644
index 00000000..5c10318c
--- /dev/null
+++ b/3rdparty/libjpeg/src/doc/html/search/groups_0.html
@@ -0,0 +1,36 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html><head><title></title>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta name="generator" content="Doxygen 1.8.20"/>
+<link rel="stylesheet" type="text/css" href="search.css"/>
+<script type="text/javascript" src="groups_0.js"></script>
+<script type="text/javascript" src="search.js"></script>
+</head>
+<body class="SRPage">
+<div id="SRIndex">
+<div class="SRStatus" id="Loading">Loading...</div>
+<div id="SRResults"></div>
+<script type="text/javascript"><!--
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+createResults();
+/* @license-end */
+--></script>
+<div class="SRStatus" id="Searching">Searching...</div>
+<div class="SRStatus" id="NoMatches">No Matches</div>
+<script type="text/javascript"><!--
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+document.getElementById("Loading").style.display="none";
+document.getElementById("NoMatches").style.display="none";
+var searchResults = new SearchResults("searchResults");
+searchResults.Search();
+window.addEventListener("message", function(event) {
+  if (event.data == "take_focus") {
+    var elem = searchResults.NavNext(0);
+    if (elem) elem.focus();
+  }
+});
+/* @license-end */
+--></script>
+</div>
+</body>
+</html>
diff --git a/3rdparty/libjpeg/src/doc/html/search/groups_0.js b/3rdparty/libjpeg/src/doc/html/search/groups_0.js
new file mode 100644
index 00000000..dccb7c5d
--- /dev/null
+++ b/3rdparty/libjpeg/src/doc/html/search/groups_0.js
@@ -0,0 +1,4 @@
+var searchData=
+[
+  ['turbojpeg_200',['TurboJPEG',['../group___turbo_j_p_e_g.html',1,'']]]
+];
diff --git a/3rdparty/libjpeg/src/doc/html/search/mag_sel.svg b/3rdparty/libjpeg/src/doc/html/search/mag_sel.svg
new file mode 100644
index 00000000..03626f64
--- /dev/null
+++ b/3rdparty/libjpeg/src/doc/html/search/mag_sel.svg
@@ -0,0 +1,74 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!-- Created with Inkscape (http://www.inkscape.org/) -->
+
+<svg
+   xmlns:dc="http://purl.org/dc/elements/1.1/"
+   xmlns:cc="http://creativecommons.org/ns#"
+   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+   xmlns:svg="http://www.w3.org/2000/svg"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   version="1.1"
+   id="svg2"
+   width="20"
+   height="19"
+   viewBox="0 0 20 19"
+   sodipodi:docname="mag_sel.svg"
+   inkscape:version="0.92.5 (2060ec1f9f, 2020-04-08)">
+  <metadata
+     id="metadata8">
+    <rdf:RDF>
+      <cc:Work
+         rdf:about="">
+        <dc:format>image/svg+xml</dc:format>
+        <dc:type
+           rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
+        <dc:title></dc:title>
+      </cc:Work>
+    </rdf:RDF>
+  </metadata>
+  <defs
+     id="defs6" />
+  <sodipodi:namedview
+     pagecolor="#ffffff"
+     bordercolor="#666666"
+     borderopacity="1"
+     objecttolerance="10"
+     gridtolerance="10"
+     guidetolerance="10"
+     inkscape:pageopacity="0"
+     inkscape:pageshadow="2"
+     inkscape:window-width="1920"
+     inkscape:window-height="2096"
+     id="namedview4"
+     showgrid="false"
+     fit-margin-top="0"
+     fit-margin-left="0"
+     fit-margin-right="0"
+     fit-margin-bottom="0"
+     inkscape:zoom="32"
+     inkscape:cx="5.9792688"
+     inkscape:cy="1.1436277"
+     inkscape:window-x="1920"
+     inkscape:window-y="27"
+     inkscape:window-maximized="0"
+     inkscape:current-layer="svg2" />
+  <circle
+     style="fill:#000000;fill-opacity:0;stroke:#656565;stroke-width:1.4;stroke-opacity:1;stroke-miterlimit:4;stroke-dasharray:none"
+     id="path4611"
+     cx="5.5"
+     cy="8.5"
+     r="3.5" />
+  <path
+     style="fill:#656565;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
+     d="M 11,7 13.5,10 16,7 Z"
+     id="path4609"
+     inkscape:connector-curvature="0"
+     sodipodi:nodetypes="cccc" />
+  <path
+     style="fill:none;stroke:#656565;stroke-width:1.4;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
+     d="m 8.1085854,11.109059 2.7823556,2.782356"
+     id="path4630"
+     inkscape:connector-curvature="0" />
+</svg>
diff --git a/3rdparty/libjpeg/src/doc/html/search/nomatches.html b/3rdparty/libjpeg/src/doc/html/search/nomatches.html
new file mode 100644
index 00000000..43773208
--- /dev/null
+++ b/3rdparty/libjpeg/src/doc/html/search/nomatches.html
@@ -0,0 +1,12 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html><head><title></title>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<link rel="stylesheet" type="text/css" href="search.css"/>
+<script type="text/javascript" src="search.js"></script>
+</head>
+<body class="SRPage">
+<div id="SRIndex">
+<div class="SRStatus" id="NoMatches">No Matches</div>
+</div>
+</body>
+</html>
diff --git a/3rdparty/libjpeg/src/doc/html/search/search.css b/3rdparty/libjpeg/src/doc/html/search/search.css
new file mode 100644
index 00000000..933cf088
--- /dev/null
+++ b/3rdparty/libjpeg/src/doc/html/search/search.css
@@ -0,0 +1,255 @@
+/*---------------- Search Box */
+
+#MSearchBox {
+    white-space : nowrap;
+    background: white;
+    border-radius: 0.65em;
+    box-shadow: inset 0.5px 0.5px 3px 0px #555;
+    z-index: 102;
+}
+
+#MSearchBox .left {
+    display: inline-block;
+    vertical-align: middle;
+    height: 1.4em;
+}
+
+#MSearchSelect {
+    display: inline-block;
+    vertical-align: middle;
+    height: 1.4em;
+    padding: 0 0 0 0.3em;
+    margin: 0;
+}
+
+#MSearchField {
+    display: inline-block;
+    vertical-align: middle;
+    width: 7.5em;
+    height: 1.1em;
+    margin: 0 0.15em;
+    padding: 0;
+    line-height: 1em;
+    border:none;
+    color: #909090;
+    outline: none;
+    font-family: Arial, Verdana, sans-serif;
+    -webkit-border-radius: 0px;
+    border-radius: 0px;
+    background: none;
+}
+
+
+#MSearchBox .right {
+    display: inline-block;
+    vertical-align: middle;
+    width: 1.4em;
+    height: 1.4em;
+}
+
+#MSearchClose {
+    display: none;
+    font-size: inherit;
+    background : none;
+    border: none;
+    margin: 0;
+    padding: 0;
+    outline: none;
+
+}
+
+#MSearchCloseImg {
+    height: 1.4em;
+    padding: 0.3em;
+    margin: 0;
+}
+
+.MSearchBoxActive #MSearchField {
+    color: #000000;
+}
+
+#main-menu > li:last-child {
+    /* This <li> object is the parent of the search bar */
+    display: flex;
+    justify-content: center;
+    align-items: center;
+    height: 36px;
+    margin-right: 1em;
+}
+
+/*---------------- Search filter selection */
+
+#MSearchSelectWindow {
+    display: none;
+    position: absolute;
+    left: 0; top: 0;
+    border: 1px solid #90A5CE;
+    background-color: #F9FAFC;
+    z-index: 10001;
+    padding-top: 4px;
+    padding-bottom: 4px;
+    -moz-border-radius: 4px;
+    -webkit-border-top-left-radius: 4px;
+    -webkit-border-top-right-radius: 4px;
+    -webkit-border-bottom-left-radius: 4px;
+    -webkit-border-bottom-right-radius: 4px;
+    -webkit-box-shadow: 5px 5px 5px rgba(0, 0, 0, 0.15);
+}
+
+.SelectItem {
+    font: 8pt Arial, Verdana, sans-serif;
+    padding-left:  2px;
+    padding-right: 12px;
+    border: 0px;
+}
+
+span.SelectionMark {
+    margin-right: 4px;
+    font-family: monospace;
+    outline-style: none;
+    text-decoration: none;
+}
+
+a.SelectItem {
+    display: block;
+    outline-style: none;
+    color: #000000; 
+    text-decoration: none;
+    padding-left:   6px;
+    padding-right: 12px;
+}
+
+a.SelectItem:focus,
+a.SelectItem:active {
+    color: #000000; 
+    outline-style: none;
+    text-decoration: none;
+}
+
+a.SelectItem:hover {
+    color: #FFFFFF;
+    background-color: #3D578C;
+    outline-style: none;
+    text-decoration: none;
+    cursor: pointer;
+    display: block;
+}
+
+/*---------------- Search results window */
+
+iframe#MSearchResults {
+    width: 60ex;
+    height: 15em;
+}
+
+#MSearchResultsWindow {
+    display: none;
+    position: absolute;
+    left: 0; top: 0;
+    border: 1px solid #000;
+    background-color: #EEF1F7;
+    z-index:10000;
+}
+
+/* ----------------------------------- */
+
+
+#SRIndex {
+    clear:both; 
+    padding-bottom: 15px;
+}
+
+.SREntry {
+    font-size: 10pt;
+    padding-left: 1ex;
+}
+
+.SRPage .SREntry {
+    font-size: 8pt;
+    padding: 1px 5px;
+}
+
+body.SRPage {
+    margin: 5px 2px;
+}
+
+.SRChildren {
+    padding-left: 3ex; padding-bottom: .5em 
+}
+
+.SRPage .SRChildren {
+    display: none;
+}
+
+.SRSymbol {
+    font-weight: bold; 
+    color: #425E97;
+    font-family: Arial, Verdana, sans-serif;
+    text-decoration: none;
+    outline: none;
+}
+
+a.SRScope {
+    display: block;
+    color: #425E97; 
+    font-family: Arial, Verdana, sans-serif;
+    text-decoration: none;
+    outline: none;
+}
+
+a.SRSymbol:focus, a.SRSymbol:active,
+a.SRScope:focus, a.SRScope:active {
+    text-decoration: underline;
+}
+
+span.SRScope {
+    padding-left: 4px;
+}
+
+.SRPage .SRStatus {
+    padding: 2px 5px;
+    font-size: 8pt;
+    font-style: italic;
+}
+
+.SRResult {
+    display: none;
+}
+
+DIV.searchresults {
+    margin-left: 10px;
+    margin-right: 10px;
+}
+
+/*---------------- External search page results */
+
+.searchresult {
+    background-color: #F0F3F8;
+}
+
+.pages b {
+   color: white;
+   padding: 5px 5px 3px 5px;
+   background-image: url("../tab_a.png");
+   background-repeat: repeat-x;
+   text-shadow: 0 1px 1px #000000;
+}
+
+.pages {
+    line-height: 17px;
+    margin-left: 4px;
+    text-decoration: none;
+}
+
+.hl {
+    font-weight: bold;
+}
+
+#searchresults {
+    margin-bottom: 20px;
+}
+
+.searchpages {
+    margin-top: 10px;
+}
+
diff --git a/3rdparty/libjpeg/src/doc/html/search/search.js b/3rdparty/libjpeg/src/doc/html/search/search.js
new file mode 100644
index 00000000..92b60946
--- /dev/null
+++ b/3rdparty/libjpeg/src/doc/html/search/search.js
@@ -0,0 +1,814 @@
+/*
+ @licstart  The following is the entire license notice for the JavaScript code in this file.
+
+ The MIT License (MIT)
+
+ Copyright (C) 1997-2020 by Dimitri van Heesch
+
+ 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.
+
+ @licend  The above is the entire license notice for the JavaScript code in this file
+ */
+function convertToId(search)
+{
+  var result = '';
+  for (i=0;i<search.length;i++)
+  {
+    var c = search.charAt(i);
+    var cn = c.charCodeAt(0);
+    if (c.match(/[a-z0-9\u0080-\uFFFF]/))
+    {
+      result+=c;
+    }
+    else if (cn<16)
+    {
+      result+="_0"+cn.toString(16);
+    }
+    else
+    {
+      result+="_"+cn.toString(16);
+    }
+  }
+  return result;
+}
+
+function getXPos(item)
+{
+  var x = 0;
+  if (item.offsetWidth)
+  {
+    while (item && item!=document.body)
+    {
+      x   += item.offsetLeft;
+      item = item.offsetParent;
+    }
+  }
+  return x;
+}
+
+function getYPos(item)
+{
+  var y = 0;
+  if (item.offsetWidth)
+  {
+     while (item && item!=document.body)
+     {
+       y   += item.offsetTop;
+       item = item.offsetParent;
+     }
+  }
+  return y;
+}
+
+/* A class handling everything associated with the search panel.
+
+   Parameters:
+   name - The name of the global variable that will be
+          storing this instance.  Is needed to be able to set timeouts.
+   resultPath - path to use for external files
+*/
+function SearchBox(name, resultsPath, inFrame, label)
+{
+  if (!name || !resultsPath) {  alert("Missing parameters to SearchBox."); }
+
+  // ---------- Instance variables
+  this.name                  = name;
+  this.resultsPath           = resultsPath;
+  this.keyTimeout            = 0;
+  this.keyTimeoutLength      = 500;
+  this.closeSelectionTimeout = 300;
+  this.lastSearchValue       = "";
+  this.lastResultsPage       = "";
+  this.hideTimeout           = 0;
+  this.searchIndex           = 0;
+  this.searchActive          = false;
+  this.insideFrame           = inFrame;
+  this.searchLabel           = label;
+
+  // ----------- DOM Elements
+
+  this.DOMSearchField = function()
+  {  return document.getElementById("MSearchField");  }
+
+  this.DOMSearchSelect = function()
+  {  return document.getElementById("MSearchSelect");  }
+
+  this.DOMSearchSelectWindow = function()
+  {  return document.getElementById("MSearchSelectWindow");  }
+
+  this.DOMPopupSearchResults = function()
+  {  return document.getElementById("MSearchResults");  }
+
+  this.DOMPopupSearchResultsWindow = function()
+  {  return document.getElementById("MSearchResultsWindow");  }
+
+  this.DOMSearchClose = function()
+  {  return document.getElementById("MSearchClose"); }
+
+  this.DOMSearchBox = function()
+  {  return document.getElementById("MSearchBox");  }
+
+  // ------------ Event Handlers
+
+  // Called when focus is added or removed from the search field.
+  this.OnSearchFieldFocus = function(isActive)
+  {
+    this.Activate(isActive);
+  }
+
+  this.OnSearchSelectShow = function()
+  {
+    var searchSelectWindow = this.DOMSearchSelectWindow();
+    var searchField        = this.DOMSearchSelect();
+
+    if (this.insideFrame)
+    {
+      var left = getXPos(searchField);
+      var top  = getYPos(searchField);
+      left += searchField.offsetWidth + 6;
+      top += searchField.offsetHeight;
+
+      // show search selection popup
+      searchSelectWindow.style.display='block';
+      left -= searchSelectWindow.offsetWidth;
+      searchSelectWindow.style.left =  left + 'px';
+      searchSelectWindow.style.top  =  top  + 'px';
+    }
+    else
+    {
+      var left = getXPos(searchField);
+      var top  = getYPos(searchField);
+      top += searchField.offsetHeight;
+
+      // show search selection popup
+      searchSelectWindow.style.display='block';
+      searchSelectWindow.style.left =  left + 'px';
+      searchSelectWindow.style.top  =  top  + 'px';
+    }
+
+    // stop selection hide timer
+    if (this.hideTimeout)
+    {
+      clearTimeout(this.hideTimeout);
+      this.hideTimeout=0;
+    }
+    return false; // to avoid "image drag" default event
+  }
+
+  this.OnSearchSelectHide = function()
+  {
+    this.hideTimeout = setTimeout(this.name +".CloseSelectionWindow()",
+                                  this.closeSelectionTimeout);
+  }
+
+  // Called when the content of the search field is changed.
+  this.OnSearchFieldChange = function(evt)
+  {
+    if (this.keyTimeout) // kill running timer
+    {
+      clearTimeout(this.keyTimeout);
+      this.keyTimeout = 0;
+    }
+
+    var e  = (evt) ? evt : window.event; // for IE
+    if (e.keyCode==40 || e.keyCode==13)
+    {
+      if (e.shiftKey==1)
+      {
+        this.OnSearchSelectShow();
+        var win=this.DOMSearchSelectWindow();
+        for (i=0;i<win.childNodes.length;i++)
+        {
+          var child = win.childNodes[i]; // get span within a
+          if (child.className=='SelectItem')
+          {
+            child.focus();
+            return;
+          }
+        }
+        return;
+      }
+      else
+      {
+        window.frames.MSearchResults.postMessage("take_focus", "*");
+      }
+    }
+    else if (e.keyCode==27) // Escape out of the search field
+    {
+      this.DOMSearchField().blur();
+      this.DOMPopupSearchResultsWindow().style.display = 'none';
+      this.DOMSearchClose().style.display = 'none';
+      this.lastSearchValue = '';
+      this.Activate(false);
+      return;
+    }
+
+    // strip whitespaces
+    var searchValue = this.DOMSearchField().value.replace(/ +/g, "");
+
+    if (searchValue != this.lastSearchValue) // search value has changed
+    {
+      if (searchValue != "") // non-empty search
+      {
+        // set timer for search update
+        this.keyTimeout = setTimeout(this.name + '.Search()',
+                                     this.keyTimeoutLength);
+      }
+      else // empty search field
+      {
+        this.DOMPopupSearchResultsWindow().style.display = 'none';
+        this.DOMSearchClose().style.display = 'none';
+        this.lastSearchValue = '';
+      }
+    }
+  }
+
+  this.SelectItemCount = function(id)
+  {
+    var count=0;
+    var win=this.DOMSearchSelectWindow();
+    for (i=0;i<win.childNodes.length;i++)
+    {
+      var child = win.childNodes[i]; // get span within a
+      if (child.className=='SelectItem')
+      {
+        count++;
+      }
+    }
+    return count;
+  }
+
+  this.SelectItemSet = function(id)
+  {
+    var i,j=0;
+    var win=this.DOMSearchSelectWindow();
+    for (i=0;i<win.childNodes.length;i++)
+    {
+      var child = win.childNodes[i]; // get span within a
+      if (child.className=='SelectItem')
+      {
+        var node = child.firstChild;
+        if (j==id)
+        {
+          node.innerHTML='&#8226;';
+        }
+        else
+        {
+          node.innerHTML='&#160;';
+        }
+        j++;
+      }
+    }
+  }
+
+  // Called when an search filter selection is made.
+  // set item with index id as the active item
+  this.OnSelectItem = function(id)
+  {
+    this.searchIndex = id;
+    this.SelectItemSet(id);
+    var searchValue = this.DOMSearchField().value.replace(/ +/g, "");
+    if (searchValue!="" && this.searchActive) // something was found -> do a search
+    {
+      this.Search();
+    }
+  }
+
+  this.OnSearchSelectKey = function(evt)
+  {
+    var e = (evt) ? evt : window.event; // for IE
+    if (e.keyCode==40 && this.searchIndex<this.SelectItemCount()) // Down
+    {
+      this.searchIndex++;
+      this.OnSelectItem(this.searchIndex);
+    }
+    else if (e.keyCode==38 && this.searchIndex>0) // Up
+    {
+      this.searchIndex--;
+      this.OnSelectItem(this.searchIndex);
+    }
+    else if (e.keyCode==13 || e.keyCode==27)
+    {
+      this.OnSelectItem(this.searchIndex);
+      this.CloseSelectionWindow();
+      this.DOMSearchField().focus();
+    }
+    return false;
+  }
+
+  // --------- Actions
+
+  // Closes the results window.
+  this.CloseResultsWindow = function()
+  {
+    this.DOMPopupSearchResultsWindow().style.display = 'none';
+    this.DOMSearchClose().style.display = 'none';
+    this.Activate(false);
+  }
+
+  this.CloseSelectionWindow = function()
+  {
+    this.DOMSearchSelectWindow().style.display = 'none';
+  }
+
+  // Performs a search.
+  this.Search = function()
+  {
+    this.keyTimeout = 0;
+
+    // strip leading whitespace
+    var searchValue = this.DOMSearchField().value.replace(/^ +/, "");
+
+    var code = searchValue.toLowerCase().charCodeAt(0);
+    var idxChar = searchValue.substr(0, 1).toLowerCase();
+    if ( 0xD800 <= code && code <= 0xDBFF && searchValue > 1) // surrogate pair
+    {
+      idxChar = searchValue.substr(0, 2);
+    }
+
+    var resultsPage;
+    var resultsPageWithSearch;
+    var hasResultsPage;
+
+    var idx = indexSectionsWithContent[this.searchIndex].indexOf(idxChar);
+    if (idx!=-1)
+    {
+       var hexCode=idx.toString(16);
+       resultsPage = this.resultsPath + '/' + indexSectionNames[this.searchIndex] + '_' + hexCode + '.html';
+       resultsPageWithSearch = resultsPage+'?'+escape(searchValue);
+       hasResultsPage = true;
+    }
+    else // nothing available for this search term
+    {
+       resultsPage = this.resultsPath + '/nomatches.html';
+       resultsPageWithSearch = resultsPage;
+       hasResultsPage = false;
+    }
+
+    window.frames.MSearchResults.location = resultsPageWithSearch;
+    var domPopupSearchResultsWindow = this.DOMPopupSearchResultsWindow();
+
+    if (domPopupSearchResultsWindow.style.display!='block')
+    {
+       var domSearchBox = this.DOMSearchBox();
+       this.DOMSearchClose().style.display = 'inline-block';
+       if (this.insideFrame)
+       {
+         var domPopupSearchResults = this.DOMPopupSearchResults();
+         domPopupSearchResultsWindow.style.position = 'relative';
+         domPopupSearchResultsWindow.style.display  = 'block';
+         var width = document.body.clientWidth - 8; // the -8 is for IE :-(
+         domPopupSearchResultsWindow.style.width    = width + 'px';
+         domPopupSearchResults.style.width          = width + 'px';
+       }
+       else
+       {
+         var domPopupSearchResults = this.DOMPopupSearchResults();
+         var left = getXPos(domSearchBox) + 150; // domSearchBox.offsetWidth;
+         var top  = getYPos(domSearchBox) + 20;  // domSearchBox.offsetHeight + 1;
+         domPopupSearchResultsWindow.style.display = 'block';
+         left -= domPopupSearchResults.offsetWidth;
+         domPopupSearchResultsWindow.style.top     = top  + 'px';
+         domPopupSearchResultsWindow.style.left    = left + 'px';
+       }
+    }
+
+    this.lastSearchValue = searchValue;
+    this.lastResultsPage = resultsPage;
+  }
+
+  // -------- Activation Functions
+
+  // Activates or deactivates the search panel, resetting things to
+  // their default values if necessary.
+  this.Activate = function(isActive)
+  {
+    if (isActive || // open it
+        this.DOMPopupSearchResultsWindow().style.display == 'block'
+       )
+    {
+      this.DOMSearchBox().className = 'MSearchBoxActive';
+
+      var searchField = this.DOMSearchField();
+
+      if (searchField.value == this.searchLabel) // clear "Search" term upon entry
+      {
+        searchField.value = '';
+        this.searchActive = true;
+      }
+    }
+    else if (!isActive) // directly remove the panel
+    {
+      this.DOMSearchBox().className = 'MSearchBoxInactive';
+      this.DOMSearchField().value   = this.searchLabel;
+      this.searchActive             = false;
+      this.lastSearchValue          = ''
+      this.lastResultsPage          = '';
+    }
+  }
+}
+
+// -----------------------------------------------------------------------
+
+// The class that handles everything on the search results page.
+function SearchResults(name)
+{
+    // The number of matches from the last run of <Search()>.
+    this.lastMatchCount = 0;
+    this.lastKey = 0;
+    this.repeatOn = false;
+
+    // Toggles the visibility of the passed element ID.
+    this.FindChildElement = function(id)
+    {
+      var parentElement = document.getElementById(id);
+      var element = parentElement.firstChild;
+
+      while (element && element!=parentElement)
+      {
+        if (element.nodeName == 'DIV' && element.className == 'SRChildren')
+        {
+          return element;
+        }
+
+        if (element.nodeName == 'DIV' && element.hasChildNodes())
+        {
+           element = element.firstChild;
+        }
+        else if (element.nextSibling)
+        {
+           element = element.nextSibling;
+        }
+        else
+        {
+          do
+          {
+            element = element.parentNode;
+          }
+          while (element && element!=parentElement && !element.nextSibling);
+
+          if (element && element!=parentElement)
+          {
+            element = element.nextSibling;
+          }
+        }
+      }
+    }
+
+    this.Toggle = function(id)
+    {
+      var element = this.FindChildElement(id);
+      if (element)
+      {
+        if (element.style.display == 'block')
+        {
+          element.style.display = 'none';
+        }
+        else
+        {
+          element.style.display = 'block';
+        }
+      }
+    }
+
+    // Searches for the passed string.  If there is no parameter,
+    // it takes it from the URL query.
+    //
+    // Always returns true, since other documents may try to call it
+    // and that may or may not be possible.
+    this.Search = function(search)
+    {
+      if (!search) // get search word from URL
+      {
+        search = window.location.search;
+        search = search.substring(1);  // Remove the leading '?'
+        search = unescape(search);
+      }
+
+      search = search.replace(/^ +/, ""); // strip leading spaces
+      search = search.replace(/ +$/, ""); // strip trailing spaces
+      search = search.toLowerCase();
+      search = convertToId(search);
+
+      var resultRows = document.getElementsByTagName("div");
+      var matches = 0;
+
+      var i = 0;
+      while (i < resultRows.length)
+      {
+        var row = resultRows.item(i);
+        if (row.className == "SRResult")
+        {
+          var rowMatchName = row.id.toLowerCase();
+          rowMatchName = rowMatchName.replace(/^sr\d*_/, ''); // strip 'sr123_'
+
+          if (search.length<=rowMatchName.length &&
+             rowMatchName.substr(0, search.length)==search)
+          {
+            row.style.display = 'block';
+            matches++;
+          }
+          else
+          {
+            row.style.display = 'none';
+          }
+        }
+        i++;
+      }
+      document.getElementById("Searching").style.display='none';
+      if (matches == 0) // no results
+      {
+        document.getElementById("NoMatches").style.display='block';
+      }
+      else // at least one result
+      {
+        document.getElementById("NoMatches").style.display='none';
+      }
+      this.lastMatchCount = matches;
+      return true;
+    }
+
+    // return the first item with index index or higher that is visible
+    this.NavNext = function(index)
+    {
+      var focusItem;
+      while (1)
+      {
+        var focusName = 'Item'+index;
+        focusItem = document.getElementById(focusName);
+        if (focusItem && focusItem.parentNode.parentNode.style.display=='block')
+        {
+          break;
+        }
+        else if (!focusItem) // last element
+        {
+          break;
+        }
+        focusItem=null;
+        index++;
+      }
+      return focusItem;
+    }
+
+    this.NavPrev = function(index)
+    {
+      var focusItem;
+      while (1)
+      {
+        var focusName = 'Item'+index;
+        focusItem = document.getElementById(focusName);
+        if (focusItem && focusItem.parentNode.parentNode.style.display=='block')
+        {
+          break;
+        }
+        else if (!focusItem) // last element
+        {
+          break;
+        }
+        focusItem=null;
+        index--;
+      }
+      return focusItem;
+    }
+
+    this.ProcessKeys = function(e)
+    {
+      if (e.type == "keydown")
+      {
+        this.repeatOn = false;
+        this.lastKey = e.keyCode;
+      }
+      else if (e.type == "keypress")
+      {
+        if (!this.repeatOn)
+        {
+          if (this.lastKey) this.repeatOn = true;
+          return false; // ignore first keypress after keydown
+        }
+      }
+      else if (e.type == "keyup")
+      {
+        this.lastKey = 0;
+        this.repeatOn = false;
+      }
+      return this.lastKey!=0;
+    }
+
+    this.Nav = function(evt,itemIndex)
+    {
+      var e  = (evt) ? evt : window.event; // for IE
+      if (e.keyCode==13) return true;
+      if (!this.ProcessKeys(e)) return false;
+
+      if (this.lastKey==38) // Up
+      {
+        var newIndex = itemIndex-1;
+        var focusItem = this.NavPrev(newIndex);
+        if (focusItem)
+        {
+          var child = this.FindChildElement(focusItem.parentNode.parentNode.id);
+          if (child && child.style.display == 'block') // children visible
+          {
+            var n=0;
+            var tmpElem;
+            while (1) // search for last child
+            {
+              tmpElem = document.getElementById('Item'+newIndex+'_c'+n);
+              if (tmpElem)
+              {
+                focusItem = tmpElem;
+              }
+              else // found it!
+              {
+                break;
+              }
+              n++;
+            }
+          }
+        }
+        if (focusItem)
+        {
+          focusItem.focus();
+        }
+        else // return focus to search field
+        {
+           parent.document.getElementById("MSearchField").focus();
+        }
+      }
+      else if (this.lastKey==40) // Down
+      {
+        var newIndex = itemIndex+1;
+        var focusItem;
+        var item = document.getElementById('Item'+itemIndex);
+        var elem = this.FindChildElement(item.parentNode.parentNode.id);
+        if (elem && elem.style.display == 'block') // children visible
+        {
+          focusItem = document.getElementById('Item'+itemIndex+'_c0');
+        }
+        if (!focusItem) focusItem = this.NavNext(newIndex);
+        if (focusItem)  focusItem.focus();
+      }
+      else if (this.lastKey==39) // Right
+      {
+        var item = document.getElementById('Item'+itemIndex);
+        var elem = this.FindChildElement(item.parentNode.parentNode.id);
+        if (elem) elem.style.display = 'block';
+      }
+      else if (this.lastKey==37) // Left
+      {
+        var item = document.getElementById('Item'+itemIndex);
+        var elem = this.FindChildElement(item.parentNode.parentNode.id);
+        if (elem) elem.style.display = 'none';
+      }
+      else if (this.lastKey==27) // Escape
+      {
+        parent.searchBox.CloseResultsWindow();
+        parent.document.getElementById("MSearchField").focus();
+      }
+      else if (this.lastKey==13) // Enter
+      {
+        return true;
+      }
+      return false;
+    }
+
+    this.NavChild = function(evt,itemIndex,childIndex)
+    {
+      var e  = (evt) ? evt : window.event; // for IE
+      if (e.keyCode==13) return true;
+      if (!this.ProcessKeys(e)) return false;
+
+      if (this.lastKey==38) // Up
+      {
+        if (childIndex>0)
+        {
+          var newIndex = childIndex-1;
+          document.getElementById('Item'+itemIndex+'_c'+newIndex).focus();
+        }
+        else // already at first child, jump to parent
+        {
+          document.getElementById('Item'+itemIndex).focus();
+        }
+      }
+      else if (this.lastKey==40) // Down
+      {
+        var newIndex = childIndex+1;
+        var elem = document.getElementById('Item'+itemIndex+'_c'+newIndex);
+        if (!elem) // last child, jump to parent next parent
+        {
+          elem = this.NavNext(itemIndex+1);
+        }
+        if (elem)
+        {
+          elem.focus();
+        }
+      }
+      else if (this.lastKey==27) // Escape
+      {
+        parent.searchBox.CloseResultsWindow();
+        parent.document.getElementById("MSearchField").focus();
+      }
+      else if (this.lastKey==13) // Enter
+      {
+        return true;
+      }
+      return false;
+    }
+}
+
+function setKeyActions(elem,action)
+{
+  elem.setAttribute('onkeydown',action);
+  elem.setAttribute('onkeypress',action);
+  elem.setAttribute('onkeyup',action);
+}
+
+function setClassAttr(elem,attr)
+{
+  elem.setAttribute('class',attr);
+  elem.setAttribute('className',attr);
+}
+
+function createResults()
+{
+  var results = document.getElementById("SRResults");
+  for (var e=0; e<searchData.length; e++)
+  {
+    var id = searchData[e][0];
+    var srResult = document.createElement('div');
+    srResult.setAttribute('id','SR_'+id);
+    setClassAttr(srResult,'SRResult');
+    var srEntry = document.createElement('div');
+    setClassAttr(srEntry,'SREntry');
+    var srLink = document.createElement('a');
+    srLink.setAttribute('id','Item'+e);
+    setKeyActions(srLink,'return searchResults.Nav(event,'+e+')');
+    setClassAttr(srLink,'SRSymbol');
+    srLink.innerHTML = searchData[e][1][0];
+    srEntry.appendChild(srLink);
+    if (searchData[e][1].length==2) // single result
+    {
+      srLink.setAttribute('href',searchData[e][1][1][0]);
+      if (searchData[e][1][1][1])
+      {
+       srLink.setAttribute('target','_parent');
+      }
+      var srScope = document.createElement('span');
+      setClassAttr(srScope,'SRScope');
+      srScope.innerHTML = searchData[e][1][1][2];
+      srEntry.appendChild(srScope);
+    }
+    else // multiple results
+    {
+      srLink.setAttribute('href','javascript:searchResults.Toggle("SR_'+id+'")');
+      var srChildren = document.createElement('div');
+      setClassAttr(srChildren,'SRChildren');
+      for (var c=0; c<searchData[e][1].length-1; c++)
+      {
+        var srChild = document.createElement('a');
+        srChild.setAttribute('id','Item'+e+'_c'+c);
+        setKeyActions(srChild,'return searchResults.NavChild(event,'+e+','+c+')');
+        setClassAttr(srChild,'SRScope');
+        srChild.setAttribute('href',searchData[e][1][c+1][0]);
+        if (searchData[e][1][c+1][1])
+        {
+         srChild.setAttribute('target','_parent');
+        }
+        srChild.innerHTML = searchData[e][1][c+1][2];
+        srChildren.appendChild(srChild);
+      }
+      srEntry.appendChild(srChildren);
+    }
+    srResult.appendChild(srEntry);
+    results.appendChild(srResult);
+  }
+}
+
+function init_search()
+{
+  var results = document.getElementById("MSearchSelectWindow");
+  for (var key in indexSectionLabels)
+  {
+    var link = document.createElement('a');
+    link.setAttribute('class','SelectItem');
+    link.setAttribute('onclick','searchBox.OnSelectItem('+key+')');
+    link.href='javascript:void(0)';
+    link.innerHTML='<span class="SelectionMark">&#160;</span>'+indexSectionLabels[key];
+    results.appendChild(link);
+  }
+  searchBox.OnSelectItem(0);
+}
+/* @license-end */
diff --git a/3rdparty/libjpeg/src/doc/html/search/search_l.png b/3rdparty/libjpeg/src/doc/html/search/search_l.png
new file mode 100644
index 00000000..fd5f7daa
Binary files /dev/null and b/3rdparty/libjpeg/src/doc/html/search/search_l.png differ
diff --git a/3rdparty/libjpeg/src/doc/html/search/search_m.png b/3rdparty/libjpeg/src/doc/html/search/search_m.png
new file mode 100644
index 00000000..b429a16b
Binary files /dev/null and b/3rdparty/libjpeg/src/doc/html/search/search_m.png differ
diff --git a/3rdparty/libjpeg/src/doc/html/search/search_r.png b/3rdparty/libjpeg/src/doc/html/search/search_r.png
new file mode 100644
index 00000000..1af5d21e
Binary files /dev/null and b/3rdparty/libjpeg/src/doc/html/search/search_r.png differ
diff --git a/3rdparty/libjpeg/src/doc/html/search/searchdata.js b/3rdparty/libjpeg/src/doc/html/search/searchdata.js
new file mode 100644
index 00000000..332a8aa4
--- /dev/null
+++ b/3rdparty/libjpeg/src/doc/html/search/searchdata.js
@@ -0,0 +1,36 @@
+var indexSectionsWithContent =
+{
+  0: "cdhnortwxy",
+  1: "t",
+  2: "t",
+  3: "cdhnortwxy",
+  4: "t",
+  5: "t",
+  6: "t",
+  7: "t"
+};
+
+var indexSectionNames =
+{
+  0: "all",
+  1: "classes",
+  2: "functions",
+  3: "variables",
+  4: "typedefs",
+  5: "enums",
+  6: "enumvalues",
+  7: "groups"
+};
+
+var indexSectionLabels =
+{
+  0: "All",
+  1: "Data Structures",
+  2: "Functions",
+  3: "Variables",
+  4: "Typedefs",
+  5: "Enumerations",
+  6: "Enumerator",
+  7: "Modules"
+};
+
diff --git a/3rdparty/libjpeg/src/doc/html/search/typedefs_0.html b/3rdparty/libjpeg/src/doc/html/search/typedefs_0.html
new file mode 100644
index 00000000..b66f0a7b
--- /dev/null
+++ b/3rdparty/libjpeg/src/doc/html/search/typedefs_0.html
@@ -0,0 +1,36 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html><head><title></title>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta name="generator" content="Doxygen 1.8.20"/>
+<link rel="stylesheet" type="text/css" href="search.css"/>
+<script type="text/javascript" src="typedefs_0.js"></script>
+<script type="text/javascript" src="search.js"></script>
+</head>
+<body class="SRPage">
+<div id="SRIndex">
+<div class="SRStatus" id="Loading">Loading...</div>
+<div id="SRResults"></div>
+<script type="text/javascript"><!--
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+createResults();
+/* @license-end */
+--></script>
+<div class="SRStatus" id="Searching">Searching...</div>
+<div class="SRStatus" id="NoMatches">No Matches</div>
+<script type="text/javascript"><!--
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+document.getElementById("Loading").style.display="none";
+document.getElementById("NoMatches").style.display="none";
+var searchResults = new SearchResults("searchResults");
+searchResults.Search();
+window.addEventListener("message", function(event) {
+  if (event.data == "take_focus") {
+    var elem = searchResults.NavNext(0);
+    if (elem) elem.focus();
+  }
+});
+/* @license-end */
+--></script>
+</div>
+</body>
+</html>
diff --git a/3rdparty/libjpeg/src/doc/html/search/typedefs_0.js b/3rdparty/libjpeg/src/doc/html/search/typedefs_0.js
new file mode 100644
index 00000000..8d3d00fb
--- /dev/null
+++ b/3rdparty/libjpeg/src/doc/html/search/typedefs_0.js
@@ -0,0 +1,5 @@
+var searchData=
+[
+  ['tjhandle_159',['tjhandle',['../group___turbo_j_p_e_g.html#ga758d2634ecb4949de7815cba621f5763',1,'turbojpeg.h']]],
+  ['tjtransform_160',['tjtransform',['../group___turbo_j_p_e_g.html#ga504805ec0161f1b505397ca0118bf8fd',1,'turbojpeg.h']]]
+];
diff --git a/3rdparty/libjpeg/src/doc/html/search/variables_0.html b/3rdparty/libjpeg/src/doc/html/search/variables_0.html
new file mode 100644
index 00000000..2edd1114
--- /dev/null
+++ b/3rdparty/libjpeg/src/doc/html/search/variables_0.html
@@ -0,0 +1,36 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html><head><title></title>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta name="generator" content="Doxygen 1.8.20"/>
+<link rel="stylesheet" type="text/css" href="search.css"/>
+<script type="text/javascript" src="variables_0.js"></script>
+<script type="text/javascript" src="search.js"></script>
+</head>
+<body class="SRPage">
+<div id="SRIndex">
+<div class="SRStatus" id="Loading">Loading...</div>
+<div id="SRResults"></div>
+<script type="text/javascript"><!--
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+createResults();
+/* @license-end */
+--></script>
+<div class="SRStatus" id="Searching">Searching...</div>
+<div class="SRStatus" id="NoMatches">No Matches</div>
+<script type="text/javascript"><!--
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+document.getElementById("Loading").style.display="none";
+document.getElementById("NoMatches").style.display="none";
+var searchResults = new SearchResults("searchResults");
+searchResults.Search();
+window.addEventListener("message", function(event) {
+  if (event.data == "take_focus") {
+    var elem = searchResults.NavNext(0);
+    if (elem) elem.focus();
+  }
+});
+/* @license-end */
+--></script>
+</div>
+</body>
+</html>
diff --git a/3rdparty/libjpeg/src/doc/html/search/variables_0.js b/3rdparty/libjpeg/src/doc/html/search/variables_0.js
new file mode 100644
index 00000000..ba55d234
--- /dev/null
+++ b/3rdparty/libjpeg/src/doc/html/search/variables_0.js
@@ -0,0 +1,4 @@
+var searchData=
+[
+  ['customfilter_141',['customFilter',['../structtjtransform.html#afd7fc262df33f741e120ef4183202ef5',1,'tjtransform']]]
+];
diff --git a/3rdparty/libjpeg/src/doc/html/search/variables_1.html b/3rdparty/libjpeg/src/doc/html/search/variables_1.html
new file mode 100644
index 00000000..98b95a99
--- /dev/null
+++ b/3rdparty/libjpeg/src/doc/html/search/variables_1.html
@@ -0,0 +1,36 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html><head><title></title>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta name="generator" content="Doxygen 1.8.20"/>
+<link rel="stylesheet" type="text/css" href="search.css"/>
+<script type="text/javascript" src="variables_1.js"></script>
+<script type="text/javascript" src="search.js"></script>
+</head>
+<body class="SRPage">
+<div id="SRIndex">
+<div class="SRStatus" id="Loading">Loading...</div>
+<div id="SRResults"></div>
+<script type="text/javascript"><!--
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+createResults();
+/* @license-end */
+--></script>
+<div class="SRStatus" id="Searching">Searching...</div>
+<div class="SRStatus" id="NoMatches">No Matches</div>
+<script type="text/javascript"><!--
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+document.getElementById("Loading").style.display="none";
+document.getElementById("NoMatches").style.display="none";
+var searchResults = new SearchResults("searchResults");
+searchResults.Search();
+window.addEventListener("message", function(event) {
+  if (event.data == "take_focus") {
+    var elem = searchResults.NavNext(0);
+    if (elem) elem.focus();
+  }
+});
+/* @license-end */
+--></script>
+</div>
+</body>
+</html>
diff --git a/3rdparty/libjpeg/src/doc/html/search/variables_1.js b/3rdparty/libjpeg/src/doc/html/search/variables_1.js
new file mode 100644
index 00000000..db6fbeab
--- /dev/null
+++ b/3rdparty/libjpeg/src/doc/html/search/variables_1.js
@@ -0,0 +1,5 @@
+var searchData=
+[
+  ['data_142',['data',['../structtjtransform.html#a688fe8f1a8ecc12a538d9e561cf338e3',1,'tjtransform']]],
+  ['denom_143',['denom',['../structtjscalingfactor.html#aefbcdf3e9e62274b2d312c695f133ce3',1,'tjscalingfactor']]]
+];
diff --git a/3rdparty/libjpeg/src/doc/html/search/variables_2.html b/3rdparty/libjpeg/src/doc/html/search/variables_2.html
new file mode 100644
index 00000000..3e0c5910
--- /dev/null
+++ b/3rdparty/libjpeg/src/doc/html/search/variables_2.html
@@ -0,0 +1,36 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html><head><title></title>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta name="generator" content="Doxygen 1.8.20"/>
+<link rel="stylesheet" type="text/css" href="search.css"/>
+<script type="text/javascript" src="variables_2.js"></script>
+<script type="text/javascript" src="search.js"></script>
+</head>
+<body class="SRPage">
+<div id="SRIndex">
+<div class="SRStatus" id="Loading">Loading...</div>
+<div id="SRResults"></div>
+<script type="text/javascript"><!--
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+createResults();
+/* @license-end */
+--></script>
+<div class="SRStatus" id="Searching">Searching...</div>
+<div class="SRStatus" id="NoMatches">No Matches</div>
+<script type="text/javascript"><!--
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+document.getElementById("Loading").style.display="none";
+document.getElementById("NoMatches").style.display="none";
+var searchResults = new SearchResults("searchResults");
+searchResults.Search();
+window.addEventListener("message", function(event) {
+  if (event.data == "take_focus") {
+    var elem = searchResults.NavNext(0);
+    if (elem) elem.focus();
+  }
+});
+/* @license-end */
+--></script>
+</div>
+</body>
+</html>
diff --git a/3rdparty/libjpeg/src/doc/html/search/variables_2.js b/3rdparty/libjpeg/src/doc/html/search/variables_2.js
new file mode 100644
index 00000000..d9d44197
--- /dev/null
+++ b/3rdparty/libjpeg/src/doc/html/search/variables_2.js
@@ -0,0 +1,4 @@
+var searchData=
+[
+  ['h_144',['h',['../structtjregion.html#aecefc45a26f4d8b60dd4d825c1710115',1,'tjregion']]]
+];
diff --git a/3rdparty/libjpeg/src/doc/html/search/variables_3.html b/3rdparty/libjpeg/src/doc/html/search/variables_3.html
new file mode 100644
index 00000000..7867da33
--- /dev/null
+++ b/3rdparty/libjpeg/src/doc/html/search/variables_3.html
@@ -0,0 +1,36 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html><head><title></title>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta name="generator" content="Doxygen 1.8.20"/>
+<link rel="stylesheet" type="text/css" href="search.css"/>
+<script type="text/javascript" src="variables_3.js"></script>
+<script type="text/javascript" src="search.js"></script>
+</head>
+<body class="SRPage">
+<div id="SRIndex">
+<div class="SRStatus" id="Loading">Loading...</div>
+<div id="SRResults"></div>
+<script type="text/javascript"><!--
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+createResults();
+/* @license-end */
+--></script>
+<div class="SRStatus" id="Searching">Searching...</div>
+<div class="SRStatus" id="NoMatches">No Matches</div>
+<script type="text/javascript"><!--
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+document.getElementById("Loading").style.display="none";
+document.getElementById("NoMatches").style.display="none";
+var searchResults = new SearchResults("searchResults");
+searchResults.Search();
+window.addEventListener("message", function(event) {
+  if (event.data == "take_focus") {
+    var elem = searchResults.NavNext(0);
+    if (elem) elem.focus();
+  }
+});
+/* @license-end */
+--></script>
+</div>
+</body>
+</html>
diff --git a/3rdparty/libjpeg/src/doc/html/search/variables_3.js b/3rdparty/libjpeg/src/doc/html/search/variables_3.js
new file mode 100644
index 00000000..ab99353a
--- /dev/null
+++ b/3rdparty/libjpeg/src/doc/html/search/variables_3.js
@@ -0,0 +1,4 @@
+var searchData=
+[
+  ['num_145',['num',['../structtjscalingfactor.html#a9b011e57f981ee23083e2c1aa5e640ec',1,'tjscalingfactor']]]
+];
diff --git a/3rdparty/libjpeg/src/doc/html/search/variables_4.html b/3rdparty/libjpeg/src/doc/html/search/variables_4.html
new file mode 100644
index 00000000..732dee2e
--- /dev/null
+++ b/3rdparty/libjpeg/src/doc/html/search/variables_4.html
@@ -0,0 +1,36 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html><head><title></title>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta name="generator" content="Doxygen 1.8.20"/>
+<link rel="stylesheet" type="text/css" href="search.css"/>
+<script type="text/javascript" src="variables_4.js"></script>
+<script type="text/javascript" src="search.js"></script>
+</head>
+<body class="SRPage">
+<div id="SRIndex">
+<div class="SRStatus" id="Loading">Loading...</div>
+<div id="SRResults"></div>
+<script type="text/javascript"><!--
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+createResults();
+/* @license-end */
+--></script>
+<div class="SRStatus" id="Searching">Searching...</div>
+<div class="SRStatus" id="NoMatches">No Matches</div>
+<script type="text/javascript"><!--
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+document.getElementById("Loading").style.display="none";
+document.getElementById("NoMatches").style.display="none";
+var searchResults = new SearchResults("searchResults");
+searchResults.Search();
+window.addEventListener("message", function(event) {
+  if (event.data == "take_focus") {
+    var elem = searchResults.NavNext(0);
+    if (elem) elem.focus();
+  }
+});
+/* @license-end */
+--></script>
+</div>
+</body>
+</html>
diff --git a/3rdparty/libjpeg/src/doc/html/search/variables_4.js b/3rdparty/libjpeg/src/doc/html/search/variables_4.js
new file mode 100644
index 00000000..1dd2d188
--- /dev/null
+++ b/3rdparty/libjpeg/src/doc/html/search/variables_4.js
@@ -0,0 +1,5 @@
+var searchData=
+[
+  ['op_146',['op',['../structtjtransform.html#a2525aab4ba6978a1c273f74fef50e498',1,'tjtransform']]],
+  ['options_147',['options',['../structtjtransform.html#ac0e74655baa4402209a21e1ae481c8f6',1,'tjtransform']]]
+];
diff --git a/3rdparty/libjpeg/src/doc/html/search/variables_5.html b/3rdparty/libjpeg/src/doc/html/search/variables_5.html
new file mode 100644
index 00000000..ad9b5456
--- /dev/null
+++ b/3rdparty/libjpeg/src/doc/html/search/variables_5.html
@@ -0,0 +1,36 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html><head><title></title>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta name="generator" content="Doxygen 1.8.20"/>
+<link rel="stylesheet" type="text/css" href="search.css"/>
+<script type="text/javascript" src="variables_5.js"></script>
+<script type="text/javascript" src="search.js"></script>
+</head>
+<body class="SRPage">
+<div id="SRIndex">
+<div class="SRStatus" id="Loading">Loading...</div>
+<div id="SRResults"></div>
+<script type="text/javascript"><!--
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+createResults();
+/* @license-end */
+--></script>
+<div class="SRStatus" id="Searching">Searching...</div>
+<div class="SRStatus" id="NoMatches">No Matches</div>
+<script type="text/javascript"><!--
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+document.getElementById("Loading").style.display="none";
+document.getElementById("NoMatches").style.display="none";
+var searchResults = new SearchResults("searchResults");
+searchResults.Search();
+window.addEventListener("message", function(event) {
+  if (event.data == "take_focus") {
+    var elem = searchResults.NavNext(0);
+    if (elem) elem.focus();
+  }
+});
+/* @license-end */
+--></script>
+</div>
+</body>
+</html>
diff --git a/3rdparty/libjpeg/src/doc/html/search/variables_5.js b/3rdparty/libjpeg/src/doc/html/search/variables_5.js
new file mode 100644
index 00000000..48f81032
--- /dev/null
+++ b/3rdparty/libjpeg/src/doc/html/search/variables_5.js
@@ -0,0 +1,4 @@
+var searchData=
+[
+  ['r_148',['r',['../structtjtransform.html#ac324e5e442abec8a961e5bf219db12cf',1,'tjtransform']]]
+];
diff --git a/3rdparty/libjpeg/src/doc/html/search/variables_6.html b/3rdparty/libjpeg/src/doc/html/search/variables_6.html
new file mode 100644
index 00000000..1cf2da19
--- /dev/null
+++ b/3rdparty/libjpeg/src/doc/html/search/variables_6.html
@@ -0,0 +1,36 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html><head><title></title>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta name="generator" content="Doxygen 1.8.20"/>
+<link rel="stylesheet" type="text/css" href="search.css"/>
+<script type="text/javascript" src="variables_6.js"></script>
+<script type="text/javascript" src="search.js"></script>
+</head>
+<body class="SRPage">
+<div id="SRIndex">
+<div class="SRStatus" id="Loading">Loading...</div>
+<div id="SRResults"></div>
+<script type="text/javascript"><!--
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+createResults();
+/* @license-end */
+--></script>
+<div class="SRStatus" id="Searching">Searching...</div>
+<div class="SRStatus" id="NoMatches">No Matches</div>
+<script type="text/javascript"><!--
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+document.getElementById("Loading").style.display="none";
+document.getElementById("NoMatches").style.display="none";
+var searchResults = new SearchResults("searchResults");
+searchResults.Search();
+window.addEventListener("message", function(event) {
+  if (event.data == "take_focus") {
+    var elem = searchResults.NavNext(0);
+    if (elem) elem.focus();
+  }
+});
+/* @license-end */
+--></script>
+</div>
+</body>
+</html>
diff --git a/3rdparty/libjpeg/src/doc/html/search/variables_6.js b/3rdparty/libjpeg/src/doc/html/search/variables_6.js
new file mode 100644
index 00000000..931d4561
--- /dev/null
+++ b/3rdparty/libjpeg/src/doc/html/search/variables_6.js
@@ -0,0 +1,10 @@
+var searchData=
+[
+  ['tjalphaoffset_149',['tjAlphaOffset',['../group___turbo_j_p_e_g.html#ga5af0ab065feefd526debf1e20c43e837',1,'turbojpeg.h']]],
+  ['tjblueoffset_150',['tjBlueOffset',['../group___turbo_j_p_e_g.html#ga84e2e35d3f08025f976ec1ec53693dea',1,'turbojpeg.h']]],
+  ['tjgreenoffset_151',['tjGreenOffset',['../group___turbo_j_p_e_g.html#ga82d6e35da441112a411da41923c0ba2f',1,'turbojpeg.h']]],
+  ['tjmcuheight_152',['tjMCUHeight',['../group___turbo_j_p_e_g.html#gabd247bb9fecb393eca57366feb8327bf',1,'turbojpeg.h']]],
+  ['tjmcuwidth_153',['tjMCUWidth',['../group___turbo_j_p_e_g.html#ga9e61e7cd47a15a173283ba94e781308c',1,'turbojpeg.h']]],
+  ['tjpixelsize_154',['tjPixelSize',['../group___turbo_j_p_e_g.html#gad77cf8fe5b2bfd3cb3f53098146abb4c',1,'turbojpeg.h']]],
+  ['tjredoffset_155',['tjRedOffset',['../group___turbo_j_p_e_g.html#gadd9b446742ac8a3923f7992c7988fea8',1,'turbojpeg.h']]]
+];
diff --git a/3rdparty/libjpeg/src/doc/html/search/variables_7.html b/3rdparty/libjpeg/src/doc/html/search/variables_7.html
new file mode 100644
index 00000000..ab2db0b8
--- /dev/null
+++ b/3rdparty/libjpeg/src/doc/html/search/variables_7.html
@@ -0,0 +1,36 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html><head><title></title>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta name="generator" content="Doxygen 1.8.20"/>
+<link rel="stylesheet" type="text/css" href="search.css"/>
+<script type="text/javascript" src="variables_7.js"></script>
+<script type="text/javascript" src="search.js"></script>
+</head>
+<body class="SRPage">
+<div id="SRIndex">
+<div class="SRStatus" id="Loading">Loading...</div>
+<div id="SRResults"></div>
+<script type="text/javascript"><!--
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+createResults();
+/* @license-end */
+--></script>
+<div class="SRStatus" id="Searching">Searching...</div>
+<div class="SRStatus" id="NoMatches">No Matches</div>
+<script type="text/javascript"><!--
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+document.getElementById("Loading").style.display="none";
+document.getElementById("NoMatches").style.display="none";
+var searchResults = new SearchResults("searchResults");
+searchResults.Search();
+window.addEventListener("message", function(event) {
+  if (event.data == "take_focus") {
+    var elem = searchResults.NavNext(0);
+    if (elem) elem.focus();
+  }
+});
+/* @license-end */
+--></script>
+</div>
+</body>
+</html>
diff --git a/3rdparty/libjpeg/src/doc/html/search/variables_7.js b/3rdparty/libjpeg/src/doc/html/search/variables_7.js
new file mode 100644
index 00000000..bd954b54
--- /dev/null
+++ b/3rdparty/libjpeg/src/doc/html/search/variables_7.js
@@ -0,0 +1,4 @@
+var searchData=
+[
+  ['w_156',['w',['../structtjregion.html#ab6eb73ceef584fc23c8c8097926dce42',1,'tjregion']]]
+];
diff --git a/3rdparty/libjpeg/src/doc/html/search/variables_8.html b/3rdparty/libjpeg/src/doc/html/search/variables_8.html
new file mode 100644
index 00000000..baec040f
--- /dev/null
+++ b/3rdparty/libjpeg/src/doc/html/search/variables_8.html
@@ -0,0 +1,36 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html><head><title></title>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta name="generator" content="Doxygen 1.8.20"/>
+<link rel="stylesheet" type="text/css" href="search.css"/>
+<script type="text/javascript" src="variables_8.js"></script>
+<script type="text/javascript" src="search.js"></script>
+</head>
+<body class="SRPage">
+<div id="SRIndex">
+<div class="SRStatus" id="Loading">Loading...</div>
+<div id="SRResults"></div>
+<script type="text/javascript"><!--
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+createResults();
+/* @license-end */
+--></script>
+<div class="SRStatus" id="Searching">Searching...</div>
+<div class="SRStatus" id="NoMatches">No Matches</div>
+<script type="text/javascript"><!--
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+document.getElementById("Loading").style.display="none";
+document.getElementById("NoMatches").style.display="none";
+var searchResults = new SearchResults("searchResults");
+searchResults.Search();
+window.addEventListener("message", function(event) {
+  if (event.data == "take_focus") {
+    var elem = searchResults.NavNext(0);
+    if (elem) elem.focus();
+  }
+});
+/* @license-end */
+--></script>
+</div>
+</body>
+</html>
diff --git a/3rdparty/libjpeg/src/doc/html/search/variables_8.js b/3rdparty/libjpeg/src/doc/html/search/variables_8.js
new file mode 100644
index 00000000..5b6b4c86
--- /dev/null
+++ b/3rdparty/libjpeg/src/doc/html/search/variables_8.js
@@ -0,0 +1,4 @@
+var searchData=
+[
+  ['x_157',['x',['../structtjregion.html#a4b6a37a93997091b26a75831fa291ad9',1,'tjregion']]]
+];
diff --git a/3rdparty/libjpeg/src/doc/html/search/variables_9.html b/3rdparty/libjpeg/src/doc/html/search/variables_9.html
new file mode 100644
index 00000000..df2fea0f
--- /dev/null
+++ b/3rdparty/libjpeg/src/doc/html/search/variables_9.html
@@ -0,0 +1,36 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html><head><title></title>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta name="generator" content="Doxygen 1.8.20"/>
+<link rel="stylesheet" type="text/css" href="search.css"/>
+<script type="text/javascript" src="variables_9.js"></script>
+<script type="text/javascript" src="search.js"></script>
+</head>
+<body class="SRPage">
+<div id="SRIndex">
+<div class="SRStatus" id="Loading">Loading...</div>
+<div id="SRResults"></div>
+<script type="text/javascript"><!--
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+createResults();
+/* @license-end */
+--></script>
+<div class="SRStatus" id="Searching">Searching...</div>
+<div class="SRStatus" id="NoMatches">No Matches</div>
+<script type="text/javascript"><!--
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+document.getElementById("Loading").style.display="none";
+document.getElementById("NoMatches").style.display="none";
+var searchResults = new SearchResults("searchResults");
+searchResults.Search();
+window.addEventListener("message", function(event) {
+  if (event.data == "take_focus") {
+    var elem = searchResults.NavNext(0);
+    if (elem) elem.focus();
+  }
+});
+/* @license-end */
+--></script>
+</div>
+</body>
+</html>
diff --git a/3rdparty/libjpeg/src/doc/html/search/variables_9.js b/3rdparty/libjpeg/src/doc/html/search/variables_9.js
new file mode 100644
index 00000000..d0591c58
--- /dev/null
+++ b/3rdparty/libjpeg/src/doc/html/search/variables_9.js
@@ -0,0 +1,4 @@
+var searchData=
+[
+  ['y_158',['y',['../structtjregion.html#a7b3e0c24cfe87acc80e334cafdcf22c2',1,'tjregion']]]
+];
diff --git a/3rdparty/libjpeg/src/doc/html/splitbar.png b/3rdparty/libjpeg/src/doc/html/splitbar.png
new file mode 100644
index 00000000..fe895f2c
Binary files /dev/null and b/3rdparty/libjpeg/src/doc/html/splitbar.png differ
diff --git a/3rdparty/libjpeg/src/doc/html/structtjregion.html b/3rdparty/libjpeg/src/doc/html/structtjregion.html
new file mode 100644
index 00000000..12c7a255
--- /dev/null
+++ b/3rdparty/libjpeg/src/doc/html/structtjregion.html
@@ -0,0 +1,173 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.8.20"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>TurboJPEG: tjregion Struct Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="search/search.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="search/searchdata.js"></script>
+<script type="text/javascript" src="search/search.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+  <td id="projectalign" style="padding-left: 0.5em;">
+   <div id="projectname">TurboJPEG
+   &#160;<span id="projectnumber">2.0</span>
+   </div>
+  </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.8.20 -->
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+var searchBox = new SearchBox("searchBox", "search",false,'Search');
+/* @license-end */
+</script>
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+  initMenu('',true,false,'search.php','Search');
+  $(document).ready(function() { init_search(); });
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<!-- window showing the filter options -->
+<div id="MSearchSelectWindow"
+     onmouseover="return searchBox.OnSearchSelectShow()"
+     onmouseout="return searchBox.OnSearchSelectHide()"
+     onkeydown="return searchBox.OnSearchSelectKey(event)">
+</div>
+
+<!-- iframe showing the search results (closed by default) -->
+<div id="MSearchResultsWindow">
+<iframe src="javascript:void(0)" frameborder="0" 
+        name="MSearchResults" id="MSearchResults">
+</iframe>
+</div>
+
+</div><!-- top -->
+<div class="header">
+  <div class="summary">
+<a href="#pub-attribs">Data Fields</a>  </div>
+  <div class="headertitle">
+<div class="title">tjregion Struct Reference<div class="ingroups"><a class="el" href="group___turbo_j_p_e_g.html">TurboJPEG</a></div></div>  </div>
+</div><!--header-->
+<div class="contents">
+
+<p>Cropping region.  
+ <a href="structtjregion.html#details">More...</a></p>
+
+<p><code>#include &lt;turbojpeg.h&gt;</code></p>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-attribs"></a>
+Data Fields</h2></td></tr>
+<tr class="memitem:a4b6a37a93997091b26a75831fa291ad9"><td class="memItemLeft" align="right" valign="top">int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structtjregion.html#a4b6a37a93997091b26a75831fa291ad9">x</a></td></tr>
+<tr class="memdesc:a4b6a37a93997091b26a75831fa291ad9"><td class="mdescLeft">&#160;</td><td class="mdescRight">The left boundary of the cropping region.  <a href="structtjregion.html#a4b6a37a93997091b26a75831fa291ad9">More...</a><br /></td></tr>
+<tr class="separator:a4b6a37a93997091b26a75831fa291ad9"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a7b3e0c24cfe87acc80e334cafdcf22c2"><td class="memItemLeft" align="right" valign="top">int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structtjregion.html#a7b3e0c24cfe87acc80e334cafdcf22c2">y</a></td></tr>
+<tr class="memdesc:a7b3e0c24cfe87acc80e334cafdcf22c2"><td class="mdescLeft">&#160;</td><td class="mdescRight">The upper boundary of the cropping region.  <a href="structtjregion.html#a7b3e0c24cfe87acc80e334cafdcf22c2">More...</a><br /></td></tr>
+<tr class="separator:a7b3e0c24cfe87acc80e334cafdcf22c2"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:ab6eb73ceef584fc23c8c8097926dce42"><td class="memItemLeft" align="right" valign="top">int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structtjregion.html#ab6eb73ceef584fc23c8c8097926dce42">w</a></td></tr>
+<tr class="memdesc:ab6eb73ceef584fc23c8c8097926dce42"><td class="mdescLeft">&#160;</td><td class="mdescRight">The width of the cropping region.  <a href="structtjregion.html#ab6eb73ceef584fc23c8c8097926dce42">More...</a><br /></td></tr>
+<tr class="separator:ab6eb73ceef584fc23c8c8097926dce42"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:aecefc45a26f4d8b60dd4d825c1710115"><td class="memItemLeft" align="right" valign="top">int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structtjregion.html#aecefc45a26f4d8b60dd4d825c1710115">h</a></td></tr>
+<tr class="memdesc:aecefc45a26f4d8b60dd4d825c1710115"><td class="mdescLeft">&#160;</td><td class="mdescRight">The height of the cropping region.  <a href="structtjregion.html#aecefc45a26f4d8b60dd4d825c1710115">More...</a><br /></td></tr>
+<tr class="separator:aecefc45a26f4d8b60dd4d825c1710115"><td class="memSeparator" colspan="2">&#160;</td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><p>Cropping region. </p>
+</div><h2 class="groupheader">Field Documentation</h2>
+<a id="aecefc45a26f4d8b60dd4d825c1710115"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aecefc45a26f4d8b60dd4d825c1710115">&#9670;&nbsp;</a></span>h</h2>
+
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">int tjregion::h</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+
+<p>The height of the cropping region. </p>
+<p>Setting this to 0 is the equivalent of setting it to the height of the source JPEG image - y. </p>
+
+</div>
+</div>
+<a id="ab6eb73ceef584fc23c8c8097926dce42"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ab6eb73ceef584fc23c8c8097926dce42">&#9670;&nbsp;</a></span>w</h2>
+
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">int tjregion::w</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+
+<p>The width of the cropping region. </p>
+<p>Setting this to 0 is the equivalent of setting it to the width of the source JPEG image - x. </p>
+
+</div>
+</div>
+<a id="a4b6a37a93997091b26a75831fa291ad9"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a4b6a37a93997091b26a75831fa291ad9">&#9670;&nbsp;</a></span>x</h2>
+
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">int tjregion::x</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+
+<p>The left boundary of the cropping region. </p>
+<p>This must be evenly divisible by the MCU block width (see <a class="el" href="group___turbo_j_p_e_g.html#ga9e61e7cd47a15a173283ba94e781308c" title="MCU block width (in pixels) for a given level of chrominance subsampling.">tjMCUWidth</a>.) </p>
+
+</div>
+</div>
+<a id="a7b3e0c24cfe87acc80e334cafdcf22c2"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a7b3e0c24cfe87acc80e334cafdcf22c2">&#9670;&nbsp;</a></span>y</h2>
+
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">int tjregion::y</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+
+<p>The upper boundary of the cropping region. </p>
+<p>This must be evenly divisible by the MCU block height (see <a class="el" href="group___turbo_j_p_e_g.html#gabd247bb9fecb393eca57366feb8327bf" title="MCU block height (in pixels) for a given level of chrominance subsampling.">tjMCUHeight</a>.) </p>
+
+</div>
+</div>
+<hr/>The documentation for this struct was generated from the following file:<ul>
+<li>turbojpeg.h</li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated by&#160;<a href="http://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.8.20
+</small></address>
+</body>
+</html>
diff --git a/3rdparty/libjpeg/src/doc/html/structtjscalingfactor.html b/3rdparty/libjpeg/src/doc/html/structtjscalingfactor.html
new file mode 100644
index 00000000..432aa2cb
--- /dev/null
+++ b/3rdparty/libjpeg/src/doc/html/structtjscalingfactor.html
@@ -0,0 +1,131 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.8.20"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>TurboJPEG: tjscalingfactor Struct Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="search/search.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="search/searchdata.js"></script>
+<script type="text/javascript" src="search/search.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+  <td id="projectalign" style="padding-left: 0.5em;">
+   <div id="projectname">TurboJPEG
+   &#160;<span id="projectnumber">2.0</span>
+   </div>
+  </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.8.20 -->
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+var searchBox = new SearchBox("searchBox", "search",false,'Search');
+/* @license-end */
+</script>
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+  initMenu('',true,false,'search.php','Search');
+  $(document).ready(function() { init_search(); });
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<!-- window showing the filter options -->
+<div id="MSearchSelectWindow"
+     onmouseover="return searchBox.OnSearchSelectShow()"
+     onmouseout="return searchBox.OnSearchSelectHide()"
+     onkeydown="return searchBox.OnSearchSelectKey(event)">
+</div>
+
+<!-- iframe showing the search results (closed by default) -->
+<div id="MSearchResultsWindow">
+<iframe src="javascript:void(0)" frameborder="0" 
+        name="MSearchResults" id="MSearchResults">
+</iframe>
+</div>
+
+</div><!-- top -->
+<div class="header">
+  <div class="summary">
+<a href="#pub-attribs">Data Fields</a>  </div>
+  <div class="headertitle">
+<div class="title">tjscalingfactor Struct Reference<div class="ingroups"><a class="el" href="group___turbo_j_p_e_g.html">TurboJPEG</a></div></div>  </div>
+</div><!--header-->
+<div class="contents">
+
+<p>Scaling factor.  
+ <a href="structtjscalingfactor.html#details">More...</a></p>
+
+<p><code>#include &lt;turbojpeg.h&gt;</code></p>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-attribs"></a>
+Data Fields</h2></td></tr>
+<tr class="memitem:a9b011e57f981ee23083e2c1aa5e640ec"><td class="memItemLeft" align="right" valign="top">int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structtjscalingfactor.html#a9b011e57f981ee23083e2c1aa5e640ec">num</a></td></tr>
+<tr class="memdesc:a9b011e57f981ee23083e2c1aa5e640ec"><td class="mdescLeft">&#160;</td><td class="mdescRight">Numerator.  <a href="structtjscalingfactor.html#a9b011e57f981ee23083e2c1aa5e640ec">More...</a><br /></td></tr>
+<tr class="separator:a9b011e57f981ee23083e2c1aa5e640ec"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:aefbcdf3e9e62274b2d312c695f133ce3"><td class="memItemLeft" align="right" valign="top">int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structtjscalingfactor.html#aefbcdf3e9e62274b2d312c695f133ce3">denom</a></td></tr>
+<tr class="memdesc:aefbcdf3e9e62274b2d312c695f133ce3"><td class="mdescLeft">&#160;</td><td class="mdescRight">Denominator.  <a href="structtjscalingfactor.html#aefbcdf3e9e62274b2d312c695f133ce3">More...</a><br /></td></tr>
+<tr class="separator:aefbcdf3e9e62274b2d312c695f133ce3"><td class="memSeparator" colspan="2">&#160;</td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><p>Scaling factor. </p>
+</div><h2 class="groupheader">Field Documentation</h2>
+<a id="aefbcdf3e9e62274b2d312c695f133ce3"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aefbcdf3e9e62274b2d312c695f133ce3">&#9670;&nbsp;</a></span>denom</h2>
+
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">int tjscalingfactor::denom</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+
+<p>Denominator. </p>
+
+</div>
+</div>
+<a id="a9b011e57f981ee23083e2c1aa5e640ec"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a9b011e57f981ee23083e2c1aa5e640ec">&#9670;&nbsp;</a></span>num</h2>
+
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">int tjscalingfactor::num</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+
+<p>Numerator. </p>
+
+</div>
+</div>
+<hr/>The documentation for this struct was generated from the following file:<ul>
+<li>turbojpeg.h</li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated by&#160;<a href="http://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.8.20
+</small></address>
+</body>
+</html>
diff --git a/3rdparty/libjpeg/src/doc/html/structtjtransform.html b/3rdparty/libjpeg/src/doc/html/structtjtransform.html
new file mode 100644
index 00000000..bdf27028
--- /dev/null
+++ b/3rdparty/libjpeg/src/doc/html/structtjtransform.html
@@ -0,0 +1,201 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.8.20"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>TurboJPEG: tjtransform Struct Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="search/search.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="search/searchdata.js"></script>
+<script type="text/javascript" src="search/search.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+  <td id="projectalign" style="padding-left: 0.5em;">
+   <div id="projectname">TurboJPEG
+   &#160;<span id="projectnumber">2.0</span>
+   </div>
+  </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.8.20 -->
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+var searchBox = new SearchBox("searchBox", "search",false,'Search');
+/* @license-end */
+</script>
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+  initMenu('',true,false,'search.php','Search');
+  $(document).ready(function() { init_search(); });
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<!-- window showing the filter options -->
+<div id="MSearchSelectWindow"
+     onmouseover="return searchBox.OnSearchSelectShow()"
+     onmouseout="return searchBox.OnSearchSelectHide()"
+     onkeydown="return searchBox.OnSearchSelectKey(event)">
+</div>
+
+<!-- iframe showing the search results (closed by default) -->
+<div id="MSearchResultsWindow">
+<iframe src="javascript:void(0)" frameborder="0" 
+        name="MSearchResults" id="MSearchResults">
+</iframe>
+</div>
+
+</div><!-- top -->
+<div class="header">
+  <div class="summary">
+<a href="#pub-attribs">Data Fields</a>  </div>
+  <div class="headertitle">
+<div class="title">tjtransform Struct Reference<div class="ingroups"><a class="el" href="group___turbo_j_p_e_g.html">TurboJPEG</a></div></div>  </div>
+</div><!--header-->
+<div class="contents">
+
+<p>Lossless transform.  
+ <a href="structtjtransform.html#details">More...</a></p>
+
+<p><code>#include &lt;turbojpeg.h&gt;</code></p>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-attribs"></a>
+Data Fields</h2></td></tr>
+<tr class="memitem:ac324e5e442abec8a961e5bf219db12cf"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structtjregion.html">tjregion</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structtjtransform.html#ac324e5e442abec8a961e5bf219db12cf">r</a></td></tr>
+<tr class="memdesc:ac324e5e442abec8a961e5bf219db12cf"><td class="mdescLeft">&#160;</td><td class="mdescRight">Cropping region.  <a href="structtjtransform.html#ac324e5e442abec8a961e5bf219db12cf">More...</a><br /></td></tr>
+<tr class="separator:ac324e5e442abec8a961e5bf219db12cf"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a2525aab4ba6978a1c273f74fef50e498"><td class="memItemLeft" align="right" valign="top">int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structtjtransform.html#a2525aab4ba6978a1c273f74fef50e498">op</a></td></tr>
+<tr class="memdesc:a2525aab4ba6978a1c273f74fef50e498"><td class="mdescLeft">&#160;</td><td class="mdescRight">One of the <a class="el" href="group___turbo_j_p_e_g.html#ga2de531af4e7e6c4f124908376b354866">transform operations</a>.  <a href="structtjtransform.html#a2525aab4ba6978a1c273f74fef50e498">More...</a><br /></td></tr>
+<tr class="separator:a2525aab4ba6978a1c273f74fef50e498"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:ac0e74655baa4402209a21e1ae481c8f6"><td class="memItemLeft" align="right" valign="top">int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structtjtransform.html#ac0e74655baa4402209a21e1ae481c8f6">options</a></td></tr>
+<tr class="memdesc:ac0e74655baa4402209a21e1ae481c8f6"><td class="mdescLeft">&#160;</td><td class="mdescRight">The bitwise OR of one of more of the <a class="el" href="group___turbo_j_p_e_g.html#ga9c771a757fc1294add611906b89ab2d2">transform options</a>.  <a href="structtjtransform.html#ac0e74655baa4402209a21e1ae481c8f6">More...</a><br /></td></tr>
+<tr class="separator:ac0e74655baa4402209a21e1ae481c8f6"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a688fe8f1a8ecc12a538d9e561cf338e3"><td class="memItemLeft" align="right" valign="top">void *&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structtjtransform.html#a688fe8f1a8ecc12a538d9e561cf338e3">data</a></td></tr>
+<tr class="memdesc:a688fe8f1a8ecc12a538d9e561cf338e3"><td class="mdescLeft">&#160;</td><td class="mdescRight">Arbitrary data that can be accessed within the body of the callback function.  <a href="structtjtransform.html#a688fe8f1a8ecc12a538d9e561cf338e3">More...</a><br /></td></tr>
+<tr class="separator:a688fe8f1a8ecc12a538d9e561cf338e3"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:afd7fc262df33f741e120ef4183202ef5"><td class="memItemLeft" align="right" valign="top">int(*&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structtjtransform.html#afd7fc262df33f741e120ef4183202ef5">customFilter</a> )(short *coeffs, <a class="el" href="structtjregion.html">tjregion</a> arrayRegion, <a class="el" href="structtjregion.html">tjregion</a> planeRegion, int componentIndex, int transformIndex, struct <a class="el" href="structtjtransform.html">tjtransform</a> *transform)</td></tr>
+<tr class="memdesc:afd7fc262df33f741e120ef4183202ef5"><td class="mdescLeft">&#160;</td><td class="mdescRight">A callback function that can be used to modify the DCT coefficients after they are losslessly transformed but before they are transcoded to a new JPEG image.  <a href="structtjtransform.html#afd7fc262df33f741e120ef4183202ef5">More...</a><br /></td></tr>
+<tr class="separator:afd7fc262df33f741e120ef4183202ef5"><td class="memSeparator" colspan="2">&#160;</td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><p>Lossless transform. </p>
+</div><h2 class="groupheader">Field Documentation</h2>
+<a id="afd7fc262df33f741e120ef4183202ef5"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#afd7fc262df33f741e120ef4183202ef5">&#9670;&nbsp;</a></span>customFilter</h2>
+
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">int(* tjtransform::customFilter) (short *coeffs, <a class="el" href="structtjregion.html">tjregion</a> arrayRegion, <a class="el" href="structtjregion.html">tjregion</a> planeRegion, int componentIndex, int transformIndex, struct <a class="el" href="structtjtransform.html">tjtransform</a> *transform)</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+
+<p>A callback function that can be used to modify the DCT coefficients after they are losslessly transformed but before they are transcoded to a new JPEG image. </p>
+<p>This allows for custom filters or other transformations to be applied in the frequency domain.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+  <table class="params">
+    <tr><td class="paramname">coeffs</td><td>pointer to an array of transformed DCT coefficients. (NOTE: this pointer is not guaranteed to be valid once the callback returns, so applications wishing to hand off the DCT coefficients to another function or library should make a copy of them within the body of the callback.)</td></tr>
+    <tr><td class="paramname">arrayRegion</td><td><a class="el" href="structtjregion.html" title="Cropping region.">tjregion</a> structure containing the width and height of the array pointed to by <code>coeffs</code> as well as its offset relative to the component plane. TurboJPEG implementations may choose to split each component plane into multiple DCT coefficient arrays and call the callback function once for each array.</td></tr>
+    <tr><td class="paramname">planeRegion</td><td><a class="el" href="structtjregion.html" title="Cropping region.">tjregion</a> structure containing the width and height of the component plane to which <code>coeffs</code> belongs</td></tr>
+    <tr><td class="paramname">componentID</td><td>ID number of the component plane to which <code>coeffs</code> belongs (Y, Cb, and Cr have, respectively, ID's of 0, 1, and 2 in typical JPEG images.)</td></tr>
+    <tr><td class="paramname">transformID</td><td>ID number of the transformed image to which <code>coeffs</code> belongs. This is the same as the index of the transform in the <code>transforms</code> array that was passed to <a class="el" href="group___turbo_j_p_e_g.html#ga9cb8abf4cc91881e04a0329b2270be25" title="Losslessly transform a JPEG image into another JPEG image.">tjTransform()</a>.</td></tr>
+    <tr><td class="paramname">transform</td><td>a pointer to a <a class="el" href="structtjtransform.html" title="Lossless transform.">tjtransform</a> structure that specifies the parameters and/or cropping region for this transform</td></tr>
+  </table>
+  </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>0 if the callback was successful, or -1 if an error occurred. </dd></dl>
+
+</div>
+</div>
+<a id="a688fe8f1a8ecc12a538d9e561cf338e3"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a688fe8f1a8ecc12a538d9e561cf338e3">&#9670;&nbsp;</a></span>data</h2>
+
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">void* tjtransform::data</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+
+<p>Arbitrary data that can be accessed within the body of the callback function. </p>
+
+</div>
+</div>
+<a id="a2525aab4ba6978a1c273f74fef50e498"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a2525aab4ba6978a1c273f74fef50e498">&#9670;&nbsp;</a></span>op</h2>
+
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">int tjtransform::op</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+
+<p>One of the <a class="el" href="group___turbo_j_p_e_g.html#ga2de531af4e7e6c4f124908376b354866">transform operations</a>. </p>
+
+</div>
+</div>
+<a id="ac0e74655baa4402209a21e1ae481c8f6"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ac0e74655baa4402209a21e1ae481c8f6">&#9670;&nbsp;</a></span>options</h2>
+
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">int tjtransform::options</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+
+<p>The bitwise OR of one of more of the <a class="el" href="group___turbo_j_p_e_g.html#ga9c771a757fc1294add611906b89ab2d2">transform options</a>. </p>
+
+</div>
+</div>
+<a id="ac324e5e442abec8a961e5bf219db12cf"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ac324e5e442abec8a961e5bf219db12cf">&#9670;&nbsp;</a></span>r</h2>
+
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname"><a class="el" href="structtjregion.html">tjregion</a> tjtransform::r</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+
+<p>Cropping region. </p>
+
+</div>
+</div>
+<hr/>The documentation for this struct was generated from the following file:<ul>
+<li>turbojpeg.h</li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated by&#160;<a href="http://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.8.20
+</small></address>
+</body>
+</html>
diff --git a/3rdparty/libjpeg/src/doc/html/sync_off.png b/3rdparty/libjpeg/src/doc/html/sync_off.png
new file mode 100644
index 00000000..3b443fc6
Binary files /dev/null and b/3rdparty/libjpeg/src/doc/html/sync_off.png differ
diff --git a/3rdparty/libjpeg/src/doc/html/sync_on.png b/3rdparty/libjpeg/src/doc/html/sync_on.png
new file mode 100644
index 00000000..e08320fb
Binary files /dev/null and b/3rdparty/libjpeg/src/doc/html/sync_on.png differ
diff --git a/3rdparty/libjpeg/src/doc/html/tab_a.png b/3rdparty/libjpeg/src/doc/html/tab_a.png
new file mode 100644
index 00000000..3b725c41
Binary files /dev/null and b/3rdparty/libjpeg/src/doc/html/tab_a.png differ
diff --git a/3rdparty/libjpeg/src/doc/html/tab_b.png b/3rdparty/libjpeg/src/doc/html/tab_b.png
new file mode 100644
index 00000000..e2b4a863
Binary files /dev/null and b/3rdparty/libjpeg/src/doc/html/tab_b.png differ
diff --git a/3rdparty/libjpeg/src/doc/html/tab_h.png b/3rdparty/libjpeg/src/doc/html/tab_h.png
new file mode 100644
index 00000000..fd5cb705
Binary files /dev/null and b/3rdparty/libjpeg/src/doc/html/tab_h.png differ
diff --git a/3rdparty/libjpeg/src/doc/html/tab_s.png b/3rdparty/libjpeg/src/doc/html/tab_s.png
new file mode 100644
index 00000000..ab478c95
Binary files /dev/null and b/3rdparty/libjpeg/src/doc/html/tab_s.png differ
diff --git a/3rdparty/libjpeg/src/doc/html/tabs.css b/3rdparty/libjpeg/src/doc/html/tabs.css
new file mode 100644
index 00000000..85a0cd5b
--- /dev/null
+++ b/3rdparty/libjpeg/src/doc/html/tabs.css
@@ -0,0 +1 @@
+.sm{position:relative;z-index:9999}.sm,.sm ul,.sm li{display:block;list-style:none;margin:0;padding:0;line-height:normal;direction:ltr;text-align:left;-webkit-tap-highlight-color:rgba(0,0,0,0)}.sm-rtl,.sm-rtl ul,.sm-rtl li{direction:rtl;text-align:right}.sm>li>h1,.sm>li>h2,.sm>li>h3,.sm>li>h4,.sm>li>h5,.sm>li>h6{margin:0;padding:0}.sm ul{display:none}.sm li,.sm a{position:relative}.sm a{display:block}.sm a.disabled{cursor:not-allowed}.sm:after{content:"\00a0";display:block;height:0;font:0/0 serif;clear:both;visibility:hidden;overflow:hidden}.sm,.sm *,.sm *:before,.sm *:after{-moz-box-sizing:border-box;-webkit-box-sizing:border-box;box-sizing:border-box}.sm-dox{background-image:url("tab_b.png")}.sm-dox a,.sm-dox a:focus,.sm-dox a:hover,.sm-dox a:active{padding:0 12px;padding-right:43px;font-family:"Lucida Grande","Geneva","Helvetica",Arial,sans-serif;font-size:13px;font-weight:bold;line-height:36px;text-decoration:none;text-shadow:0 1px 1px rgba(255,255,255,0.9);color:#283a5d;outline:0}.sm-dox a:hover{background-image:url("tab_a.png");background-repeat:repeat-x;color:white;text-shadow:0 1px 1px black}.sm-dox a.current{color:#d23600}.sm-dox a.disabled{color:#bbb}.sm-dox a span.sub-arrow{position:absolute;top:50%;margin-top:-14px;left:auto;right:3px;width:28px;height:28px;overflow:hidden;font:bold 12px/28px monospace!important;text-align:center;text-shadow:none;background:rgba(255,255,255,0.5);-moz-border-radius:5px;-webkit-border-radius:5px;border-radius:5px}.sm-dox a.highlighted span.sub-arrow:before{display:block;content:'-'}.sm-dox>li:first-child>a,.sm-dox>li:first-child>:not(ul) a{-moz-border-radius:5px 5px 0 0;-webkit-border-radius:5px;border-radius:5px 5px 0 0}.sm-dox>li:last-child>a,.sm-dox>li:last-child>*:not(ul) a,.sm-dox>li:last-child>ul,.sm-dox>li:last-child>ul>li:last-child>a,.sm-dox>li:last-child>ul>li:last-child>*:not(ul) a,.sm-dox>li:last-child>ul>li:last-child>ul,.sm-dox>li:last-child>ul>li:last-child>ul>li:last-child>a,.sm-dox>li:last-child>ul>li:last-child>ul>li:last-child>*:not(ul) a,.sm-dox>li:last-child>ul>li:last-child>ul>li:last-child>ul,.sm-dox>li:last-child>ul>li:last-child>ul>li:last-child>ul>li:last-child>a,.sm-dox>li:last-child>ul>li:last-child>ul>li:last-child>ul>li:last-child>*:not(ul) a,.sm-dox>li:last-child>ul>li:last-child>ul>li:last-child>ul>li:last-child>ul,.sm-dox>li:last-child>ul>li:last-child>ul>li:last-child>ul>li:last-child>ul>li:last-child>a,.sm-dox>li:last-child>ul>li:last-child>ul>li:last-child>ul>li:last-child>ul>li:last-child>*:not(ul) a,.sm-dox>li:last-child>ul>li:last-child>ul>li:last-child>ul>li:last-child>ul>li:last-child>ul{-moz-border-radius:0 0 5px 5px;-webkit-border-radius:0;border-radius:0 0 5px 5px}.sm-dox>li:last-child>a.highlighted,.sm-dox>li:last-child>*:not(ul) a.highlighted,.sm-dox>li:last-child>ul>li:last-child>a.highlighted,.sm-dox>li:last-child>ul>li:last-child>*:not(ul) a.highlighted,.sm-dox>li:last-child>ul>li:last-child>ul>li:last-child>a.highlighted,.sm-dox>li:last-child>ul>li:last-child>ul>li:last-child>*:not(ul) a.highlighted,.sm-dox>li:last-child>ul>li:last-child>ul>li:last-child>ul>li:last-child>a.highlighted,.sm-dox>li:last-child>ul>li:last-child>ul>li:last-child>ul>li:last-child>*:not(ul) a.highlighted,.sm-dox>li:last-child>ul>li:last-child>ul>li:last-child>ul>li:last-child>ul>li:last-child>a.highlighted,.sm-dox>li:last-child>ul>li:last-child>ul>li:last-child>ul>li:last-child>ul>li:last-child>*:not(ul) a.highlighted{-moz-border-radius:0;-webkit-border-radius:0;border-radius:0}.sm-dox ul{background:rgba(162,162,162,0.1)}.sm-dox ul a,.sm-dox ul a:focus,.sm-dox ul a:hover,.sm-dox ul a:active{font-size:12px;border-left:8px solid transparent;line-height:36px;text-shadow:none;background-color:white;background-image:none}.sm-dox ul a:hover{background-image:url("tab_a.png");background-repeat:repeat-x;color:white;text-shadow:0 1px 1px black}.sm-dox ul ul a,.sm-dox ul ul a:hover,.sm-dox ul ul a:focus,.sm-dox ul ul a:active{border-left:16px solid transparent}.sm-dox ul ul ul a,.sm-dox ul ul ul a:hover,.sm-dox ul ul ul a:focus,.sm-dox ul ul ul a:active{border-left:24px solid transparent}.sm-dox ul ul ul ul a,.sm-dox ul ul ul ul a:hover,.sm-dox ul ul ul ul a:focus,.sm-dox ul ul ul ul a:active{border-left:32px solid transparent}.sm-dox ul ul ul ul ul a,.sm-dox ul ul ul ul ul a:hover,.sm-dox ul ul ul ul ul a:focus,.sm-dox ul ul ul ul ul a:active{border-left:40px solid transparent}@media(min-width:768px){.sm-dox ul{position:absolute;width:12em}.sm-dox li{float:left}.sm-dox.sm-rtl li{float:right}.sm-dox ul li,.sm-dox.sm-rtl ul li,.sm-dox.sm-vertical li{float:none}.sm-dox a{white-space:nowrap}.sm-dox ul a,.sm-dox.sm-vertical a{white-space:normal}.sm-dox .sm-nowrap>li>a,.sm-dox .sm-nowrap>li>:not(ul) a{white-space:nowrap}.sm-dox{padding:0 10px;background-image:url("tab_b.png");line-height:36px}.sm-dox a span.sub-arrow{top:50%;margin-top:-2px;right:12px;width:0;height:0;border-width:4px;border-style:solid dashed dashed dashed;border-color:#283a5d transparent transparent transparent;background:transparent;-moz-border-radius:0;-webkit-border-radius:0;border-radius:0}.sm-dox a,.sm-dox a:focus,.sm-dox a:active,.sm-dox a:hover,.sm-dox a.highlighted{padding:0 12px;background-image:url("tab_s.png");background-repeat:no-repeat;background-position:right;-moz-border-radius:0!important;-webkit-border-radius:0;border-radius:0!important}.sm-dox a:hover{background-image:url("tab_a.png");background-repeat:repeat-x;color:white;text-shadow:0 1px 1px black}.sm-dox a:hover span.sub-arrow{border-color:white transparent transparent transparent}.sm-dox a.has-submenu{padding-right:24px}.sm-dox li{border-top:0}.sm-dox>li>ul:before,.sm-dox>li>ul:after{content:'';position:absolute;top:-18px;left:30px;width:0;height:0;overflow:hidden;border-width:9px;border-style:dashed dashed solid dashed;border-color:transparent transparent #bbb transparent}.sm-dox>li>ul:after{top:-16px;left:31px;border-width:8px;border-color:transparent transparent #fff transparent}.sm-dox ul{border:1px solid #bbb;padding:5px 0;background:#fff;-moz-border-radius:5px!important;-webkit-border-radius:5px;border-radius:5px!important;-moz-box-shadow:0 5px 9px rgba(0,0,0,0.2);-webkit-box-shadow:0 5px 9px rgba(0,0,0,0.2);box-shadow:0 5px 9px rgba(0,0,0,0.2)}.sm-dox ul a span.sub-arrow{right:8px;top:50%;margin-top:-5px;border-width:5px;border-color:transparent transparent transparent #555;border-style:dashed dashed dashed solid}.sm-dox ul a,.sm-dox ul a:hover,.sm-dox ul a:focus,.sm-dox ul a:active,.sm-dox ul a.highlighted{color:#555;background-image:none;border:0!important;color:#555;background-image:none}.sm-dox ul a:hover{background-image:url("tab_a.png");background-repeat:repeat-x;color:white;text-shadow:0 1px 1px black}.sm-dox ul a:hover span.sub-arrow{border-color:transparent transparent transparent white}.sm-dox span.scroll-up,.sm-dox span.scroll-down{position:absolute;display:none;visibility:hidden;overflow:hidden;background:#fff;height:36px}.sm-dox span.scroll-up:hover,.sm-dox span.scroll-down:hover{background:#eee}.sm-dox span.scroll-up:hover span.scroll-up-arrow,.sm-dox span.scroll-up:hover span.scroll-down-arrow{border-color:transparent transparent #d23600 transparent}.sm-dox span.scroll-down:hover span.scroll-down-arrow{border-color:#d23600 transparent transparent transparent}.sm-dox span.scroll-up-arrow,.sm-dox span.scroll-down-arrow{position:absolute;top:0;left:50%;margin-left:-6px;width:0;height:0;overflow:hidden;border-width:6px;border-style:dashed dashed solid dashed;border-color:transparent transparent #555 transparent}.sm-dox span.scroll-down-arrow{top:8px;border-style:solid dashed dashed dashed;border-color:#555 transparent transparent transparent}.sm-dox.sm-rtl a.has-submenu{padding-right:12px;padding-left:24px}.sm-dox.sm-rtl a span.sub-arrow{right:auto;left:12px}.sm-dox.sm-rtl.sm-vertical a.has-submenu{padding:10px 20px}.sm-dox.sm-rtl.sm-vertical a span.sub-arrow{right:auto;left:8px;border-style:dashed solid dashed dashed;border-color:transparent #555 transparent transparent}.sm-dox.sm-rtl>li>ul:before{left:auto;right:30px}.sm-dox.sm-rtl>li>ul:after{left:auto;right:31px}.sm-dox.sm-rtl ul a.has-submenu{padding:10px 20px!important}.sm-dox.sm-rtl ul a span.sub-arrow{right:auto;left:8px;border-style:dashed solid dashed dashed;border-color:transparent #555 transparent transparent}.sm-dox.sm-vertical{padding:10px 0;-moz-border-radius:5px;-webkit-border-radius:5px;border-radius:5px}.sm-dox.sm-vertical a{padding:10px 20px}.sm-dox.sm-vertical a:hover,.sm-dox.sm-vertical a:focus,.sm-dox.sm-vertical a:active,.sm-dox.sm-vertical a.highlighted{background:#fff}.sm-dox.sm-vertical a.disabled{background-image:url("tab_b.png")}.sm-dox.sm-vertical a span.sub-arrow{right:8px;top:50%;margin-top:-5px;border-width:5px;border-style:dashed dashed dashed solid;border-color:transparent transparent transparent #555}.sm-dox.sm-vertical>li>ul:before,.sm-dox.sm-vertical>li>ul:after{display:none}.sm-dox.sm-vertical ul a{padding:10px 20px}.sm-dox.sm-vertical ul a:hover,.sm-dox.sm-vertical ul a:focus,.sm-dox.sm-vertical ul a:active,.sm-dox.sm-vertical ul a.highlighted{background:#eee}.sm-dox.sm-vertical ul a.disabled{background:#fff}}
\ No newline at end of file
diff --git a/3rdparty/libjpeg/src/doxygen-extra.css b/3rdparty/libjpeg/src/doxygen-extra.css
new file mode 100644
index 00000000..f1bd4c26
--- /dev/null
+++ b/3rdparty/libjpeg/src/doxygen-extra.css
@@ -0,0 +1,3 @@
+code {
+	color: #4665A2;
+}
diff --git a/3rdparty/libjpeg/src/doxygen.config b/3rdparty/libjpeg/src/doxygen.config
new file mode 100644
index 00000000..cb884f9d
--- /dev/null
+++ b/3rdparty/libjpeg/src/doxygen.config
@@ -0,0 +1,16 @@
+PROJECT_NAME = TurboJPEG
+PROJECT_NUMBER = 2.0
+OUTPUT_DIRECTORY = doc/
+USE_WINDOWS_ENCODING = NO
+OPTIMIZE_OUTPUT_FOR_C = YES
+WARN_NO_PARAMDOC = YES
+GENERATE_LATEX = NO
+FILE_PATTERNS = turbojpeg.h
+HIDE_UNDOC_MEMBERS = YES
+VERBATIM_HEADERS = NO
+EXTRACT_STATIC = YES
+JAVADOC_AUTOBRIEF = YES
+MAX_INITIALIZER_LINES = 0
+ALWAYS_DETAILED_SEC = YES
+HTML_TIMESTAMP = NO
+HTML_EXTRA_STYLESHEET = doxygen-extra.css
diff --git a/3rdparty/libjpeg/src/example.txt b/3rdparty/libjpeg/src/example.txt
new file mode 100644
index 00000000..bc0ba49d
--- /dev/null
+++ b/3rdparty/libjpeg/src/example.txt
@@ -0,0 +1,464 @@
+/*
+ * example.txt
+ *
+ * This file illustrates how to use the IJG code as a subroutine library
+ * to read or write JPEG image files.  You should look at this code in
+ * conjunction with the documentation file libjpeg.txt.
+ *
+ * This code will not do anything useful as-is, but it may be helpful as a
+ * skeleton for constructing routines that call the JPEG library.
+ *
+ * We present these routines in the same coding style used in the JPEG code
+ * (ANSI function definitions, etc); but you are of course free to code your
+ * routines in a different style if you prefer.
+ */
+
+/* This example was part of the original libjpeg documentation and has been
+ * unchanged since 1994.  It is, as described in libjpeg.txt, "heavily
+ * commented skeleton code for calling the JPEG library."  It is not meant to
+ * be compiled as a standalone program, since it has no main() function and
+ * does not compress from/decompress to a real image buffer (corollary:
+ * put_scanline_someplace() is not a real function.)  First-time users of
+ * libjpeg-turbo would be better served by looking at tjexample.c, which uses
+ * the more straightforward TurboJPEG API, or at cjpeg.c and djpeg.c, which are
+ * examples of libjpeg API usage that can be (and are) compiled into standalone
+ * programs.  Note that this example, as well as the examples in cjpeg.c and
+ * djpeg.c, interleave disk I/O with JPEG compression/decompression, so none of
+ * these examples is suitable for benchmarking purposes.
+ */
+
+#include <stdio.h>
+
+/*
+ * Include file for users of JPEG library.
+ * You will need to have included system headers that define at least
+ * the typedefs FILE and size_t before you can include jpeglib.h.
+ * (stdio.h is sufficient on ANSI-conforming systems.)
+ * You may also wish to include "jerror.h".
+ */
+
+#include "jpeglib.h"
+
+/*
+ * <setjmp.h> is used for the optional error recovery mechanism shown in
+ * the second part of the example.
+ */
+
+#include <setjmp.h>
+
+
+
+/******************** JPEG COMPRESSION SAMPLE INTERFACE *******************/
+
+/* This half of the example shows how to feed data into the JPEG compressor.
+ * We present a minimal version that does not worry about refinements such
+ * as error recovery (the JPEG code will just exit() if it gets an error).
+ */
+
+
+/*
+ * IMAGE DATA FORMATS:
+ *
+ * The standard input image format is a rectangular array of pixels, with
+ * each pixel having the same number of "component" values (color channels).
+ * Each pixel row is an array of JSAMPLEs (which typically are unsigned chars).
+ * If you are working with color data, then the color values for each pixel
+ * must be adjacent in the row; for example, R,G,B,R,G,B,R,G,B,... for 24-bit
+ * RGB color.
+ *
+ * For this example, we'll assume that this data structure matches the way
+ * our application has stored the image in memory, so we can just pass a
+ * pointer to our image buffer.  In particular, let's say that the image is
+ * RGB color and is described by:
+ */
+
+extern JSAMPLE *image_buffer;   /* Points to large array of R,G,B-order data */
+extern int image_height;        /* Number of rows in image */
+extern int image_width;         /* Number of columns in image */
+
+
+/*
+ * Sample routine for JPEG compression.  We assume that the target file name
+ * and a compression quality factor are passed in.
+ */
+
+GLOBAL(void)
+write_JPEG_file(char *filename, int quality)
+{
+  /* This struct contains the JPEG compression parameters and pointers to
+   * working space (which is allocated as needed by the JPEG library).
+   * It is possible to have several such structures, representing multiple
+   * compression/decompression processes, in existence at once.  We refer
+   * to any one struct (and its associated working data) as a "JPEG object".
+   */
+  struct jpeg_compress_struct cinfo;
+  /* This struct represents a JPEG error handler.  It is declared separately
+   * because applications often want to supply a specialized error handler
+   * (see the second half of this file for an example).  But here we just
+   * take the easy way out and use the standard error handler, which will
+   * print a message on stderr and call exit() if compression fails.
+   * Note that this struct must live as long as the main JPEG parameter
+   * struct, to avoid dangling-pointer problems.
+   */
+  struct jpeg_error_mgr jerr;
+  /* More stuff */
+  FILE *outfile;                /* target file */
+  JSAMPROW row_pointer[1];      /* pointer to JSAMPLE row[s] */
+  int row_stride;               /* physical row width in image buffer */
+
+  /* Step 1: allocate and initialize JPEG compression object */
+
+  /* We have to set up the error handler first, in case the initialization
+   * step fails.  (Unlikely, but it could happen if you are out of memory.)
+   * This routine fills in the contents of struct jerr, and returns jerr's
+   * address which we place into the link field in cinfo.
+   */
+  cinfo.err = jpeg_std_error(&jerr);
+  /* Now we can initialize the JPEG compression object. */
+  jpeg_create_compress(&cinfo);
+
+  /* Step 2: specify data destination (eg, a file) */
+  /* Note: steps 2 and 3 can be done in either order. */
+
+  /* Here we use the library-supplied code to send compressed data to a
+   * stdio stream.  You can also write your own code to do something else.
+   * VERY IMPORTANT: use "b" option to fopen() if you are on a machine that
+   * requires it in order to write binary files.
+   */
+  if ((outfile = fopen(filename, "wb")) == NULL) {
+    fprintf(stderr, "can't open %s\n", filename);
+    exit(1);
+  }
+  jpeg_stdio_dest(&cinfo, outfile);
+
+  /* Step 3: set parameters for compression */
+
+  /* First we supply a description of the input image.
+   * Four fields of the cinfo struct must be filled in:
+   */
+  cinfo.image_width = image_width;      /* image width and height, in pixels */
+  cinfo.image_height = image_height;
+  cinfo.input_components = 3;           /* # of color components per pixel */
+  cinfo.in_color_space = JCS_RGB;       /* colorspace of input image */
+  /* Now use the library's routine to set default compression parameters.
+   * (You must set at least cinfo.in_color_space before calling this,
+   * since the defaults depend on the source color space.)
+   */
+  jpeg_set_defaults(&cinfo);
+  /* Now you can set any non-default parameters you wish to.
+   * Here we just illustrate the use of quality (quantization table) scaling:
+   */
+  jpeg_set_quality(&cinfo, quality, TRUE /* limit to baseline-JPEG values */);
+
+  /* Step 4: Start compressor */
+
+  /* TRUE ensures that we will write a complete interchange-JPEG file.
+   * Pass TRUE unless you are very sure of what you're doing.
+   */
+  jpeg_start_compress(&cinfo, TRUE);
+
+  /* Step 5: while (scan lines remain to be written) */
+  /*           jpeg_write_scanlines(...); */
+
+  /* Here we use the library's state variable cinfo.next_scanline as the
+   * loop counter, so that we don't have to keep track ourselves.
+   * To keep things simple, we pass one scanline per call; you can pass
+   * more if you wish, though.
+   */
+  row_stride = image_width * 3; /* JSAMPLEs per row in image_buffer */
+
+  while (cinfo.next_scanline < cinfo.image_height) {
+    /* jpeg_write_scanlines expects an array of pointers to scanlines.
+     * Here the array is only one element long, but you could pass
+     * more than one scanline at a time if that's more convenient.
+     */
+    row_pointer[0] = &image_buffer[cinfo.next_scanline * row_stride];
+    (void)jpeg_write_scanlines(&cinfo, row_pointer, 1);
+  }
+
+  /* Step 6: Finish compression */
+
+  jpeg_finish_compress(&cinfo);
+  /* After finish_compress, we can close the output file. */
+  fclose(outfile);
+
+  /* Step 7: release JPEG compression object */
+
+  /* This is an important step since it will release a good deal of memory. */
+  jpeg_destroy_compress(&cinfo);
+
+  /* And we're done! */
+}
+
+
+/*
+ * SOME FINE POINTS:
+ *
+ * In the above loop, we ignored the return value of jpeg_write_scanlines,
+ * which is the number of scanlines actually written.  We could get away
+ * with this because we were only relying on the value of cinfo.next_scanline,
+ * which will be incremented correctly.  If you maintain additional loop
+ * variables then you should be careful to increment them properly.
+ * Actually, for output to a stdio stream you needn't worry, because
+ * then jpeg_write_scanlines will write all the lines passed (or else exit
+ * with a fatal error).  Partial writes can only occur if you use a data
+ * destination module that can demand suspension of the compressor.
+ * (If you don't know what that's for, you don't need it.)
+ *
+ * If the compressor requires full-image buffers (for entropy-coding
+ * optimization or a multi-scan JPEG file), it will create temporary
+ * files for anything that doesn't fit within the maximum-memory setting.
+ * (Note that temp files are NOT needed if you use the default parameters.)
+ * On some systems you may need to set up a signal handler to ensure that
+ * temporary files are deleted if the program is interrupted.  See libjpeg.txt.
+ *
+ * Scanlines MUST be supplied in top-to-bottom order if you want your JPEG
+ * files to be compatible with everyone else's.  If you cannot readily read
+ * your data in that order, you'll need an intermediate array to hold the
+ * image.  See rdtarga.c or rdbmp.c for examples of handling bottom-to-top
+ * source data using the JPEG code's internal virtual-array mechanisms.
+ */
+
+
+
+/******************** JPEG DECOMPRESSION SAMPLE INTERFACE *******************/
+
+/* This half of the example shows how to read data from the JPEG decompressor.
+ * It's a bit more refined than the above, in that we show:
+ *   (a) how to modify the JPEG library's standard error-reporting behavior;
+ *   (b) how to allocate workspace using the library's memory manager.
+ *
+ * Just to make this example a little different from the first one, we'll
+ * assume that we do not intend to put the whole image into an in-memory
+ * buffer, but to send it line-by-line someplace else.  We need a one-
+ * scanline-high JSAMPLE array as a work buffer, and we will let the JPEG
+ * memory manager allocate it for us.  This approach is actually quite useful
+ * because we don't need to remember to deallocate the buffer separately: it
+ * will go away automatically when the JPEG object is cleaned up.
+ */
+
+
+/*
+ * ERROR HANDLING:
+ *
+ * The JPEG library's standard error handler (jerror.c) is divided into
+ * several "methods" which you can override individually.  This lets you
+ * adjust the behavior without duplicating a lot of code, which you might
+ * have to update with each future release.
+ *
+ * Our example here shows how to override the "error_exit" method so that
+ * control is returned to the library's caller when a fatal error occurs,
+ * rather than calling exit() as the standard error_exit method does.
+ *
+ * We use C's setjmp/longjmp facility to return control.  This means that the
+ * routine which calls the JPEG library must first execute a setjmp() call to
+ * establish the return point.  We want the replacement error_exit to do a
+ * longjmp().  But we need to make the setjmp buffer accessible to the
+ * error_exit routine.  To do this, we make a private extension of the
+ * standard JPEG error handler object.  (If we were using C++, we'd say we
+ * were making a subclass of the regular error handler.)
+ *
+ * Here's the extended error handler struct:
+ */
+
+struct my_error_mgr {
+  struct jpeg_error_mgr pub;    /* "public" fields */
+
+  jmp_buf setjmp_buffer;        /* for return to caller */
+};
+
+typedef struct my_error_mgr *my_error_ptr;
+
+/*
+ * Here's the routine that will replace the standard error_exit method:
+ */
+
+METHODDEF(void)
+my_error_exit(j_common_ptr cinfo)
+{
+  /* cinfo->err really points to a my_error_mgr struct, so coerce pointer */
+  my_error_ptr myerr = (my_error_ptr)cinfo->err;
+
+  /* Always display the message. */
+  /* We could postpone this until after returning, if we chose. */
+  (*cinfo->err->output_message) (cinfo);
+
+  /* Return control to the setjmp point */
+  longjmp(myerr->setjmp_buffer, 1);
+}
+
+
+METHODDEF(int) do_read_JPEG_file(struct jpeg_decompress_struct *cinfo,
+                                 char *filename);
+
+/*
+ * Sample routine for JPEG decompression.  We assume that the source file name
+ * is passed in.  We want to return 1 on success, 0 on error.
+ */
+
+GLOBAL(int)
+read_JPEG_file(char *filename)
+{
+  /* This struct contains the JPEG decompression parameters and pointers to
+   * working space (which is allocated as needed by the JPEG library).
+   */
+  struct jpeg_decompress_struct cinfo;
+
+  return do_read_JPEG_file(&cinfo, filename);
+}
+
+/*
+ * We call the libjpeg API from within a separate function, because modifying
+ * the local non-volatile jpeg_decompress_struct instance below the setjmp()
+ * return point and then accessing the instance after setjmp() returns would
+ * return in undefined behavior that may potentially overwrite all or part of
+ * the structure.
+ */
+
+METHODDEF(int)
+do_read_JPEG_file(struct jpeg_decompress_struct *cinfo, char *filename)
+{
+  /* We use our private extension JPEG error handler.
+   * Note that this struct must live as long as the main JPEG parameter
+   * struct, to avoid dangling-pointer problems.
+   */
+  struct my_error_mgr jerr;
+  /* More stuff */
+  FILE *infile;                 /* source file */
+  JSAMPARRAY buffer;            /* Output row buffer */
+  int row_stride;               /* physical row width in output buffer */
+
+  /* In this example we want to open the input file before doing anything else,
+   * so that the setjmp() error recovery below can assume the file is open.
+   * VERY IMPORTANT: use "b" option to fopen() if you are on a machine that
+   * requires it in order to read binary files.
+   */
+
+  if ((infile = fopen(filename, "rb")) == NULL) {
+    fprintf(stderr, "can't open %s\n", filename);
+    return 0;
+  }
+
+  /* Step 1: allocate and initialize JPEG decompression object */
+
+  /* We set up the normal JPEG error routines, then override error_exit. */
+  cinfo->err = jpeg_std_error(&jerr.pub);
+  jerr.pub.error_exit = my_error_exit;
+  /* Establish the setjmp return context for my_error_exit to use. */
+  if (setjmp(jerr.setjmp_buffer)) {
+    /* If we get here, the JPEG code has signaled an error.
+     * We need to clean up the JPEG object, close the input file, and return.
+     */
+    jpeg_destroy_decompress(cinfo);
+    fclose(infile);
+    return 0;
+  }
+  /* Now we can initialize the JPEG decompression object. */
+  jpeg_create_decompress(cinfo);
+
+  /* Step 2: specify data source (eg, a file) */
+
+  jpeg_stdio_src(cinfo, infile);
+
+  /* Step 3: read file parameters with jpeg_read_header() */
+
+  (void)jpeg_read_header(cinfo, TRUE);
+  /* We can ignore the return value from jpeg_read_header since
+   *   (a) suspension is not possible with the stdio data source, and
+   *   (b) we passed TRUE to reject a tables-only JPEG file as an error.
+   * See libjpeg.txt for more info.
+   */
+
+  /* Step 4: set parameters for decompression */
+
+  /* In this example, we don't need to change any of the defaults set by
+   * jpeg_read_header(), so we do nothing here.
+   */
+
+  /* Step 5: Start decompressor */
+
+  (void)jpeg_start_decompress(cinfo);
+  /* We can ignore the return value since suspension is not possible
+   * with the stdio data source.
+   */
+
+  /* We may need to do some setup of our own at this point before reading
+   * the data.  After jpeg_start_decompress() we have the correct scaled
+   * output image dimensions available, as well as the output colormap
+   * if we asked for color quantization.
+   * In this example, we need to make an output work buffer of the right size.
+   */
+  /* JSAMPLEs per row in output buffer */
+  row_stride = cinfo->output_width * cinfo->output_components;
+  /* Make a one-row-high sample array that will go away when done with image */
+  buffer = (*cinfo->mem->alloc_sarray)
+                ((j_common_ptr)cinfo, JPOOL_IMAGE, row_stride, 1);
+
+  /* Step 6: while (scan lines remain to be read) */
+  /*           jpeg_read_scanlines(...); */
+
+  /* Here we use the library's state variable cinfo->output_scanline as the
+   * loop counter, so that we don't have to keep track ourselves.
+   */
+  while (cinfo->output_scanline < cinfo->output_height) {
+    /* jpeg_read_scanlines expects an array of pointers to scanlines.
+     * Here the array is only one element long, but you could ask for
+     * more than one scanline at a time if that's more convenient.
+     */
+    (void)jpeg_read_scanlines(cinfo, buffer, 1);
+    /* Assume put_scanline_someplace wants a pointer and sample count. */
+    put_scanline_someplace(buffer[0], row_stride);
+  }
+
+  /* Step 7: Finish decompression */
+
+  (void)jpeg_finish_decompress(cinfo);
+  /* We can ignore the return value since suspension is not possible
+   * with the stdio data source.
+   */
+
+  /* Step 8: Release JPEG decompression object */
+
+  /* This is an important step since it will release a good deal of memory. */
+  jpeg_destroy_decompress(cinfo);
+
+  /* After finish_decompress, we can close the input file.
+   * Here we postpone it until after no more JPEG errors are possible,
+   * so as to simplify the setjmp error logic above.  (Actually, I don't
+   * think that jpeg_destroy can do an error exit, but why assume anything...)
+   */
+  fclose(infile);
+
+  /* At this point you may want to check to see whether any corrupt-data
+   * warnings occurred (test whether jerr.pub.num_warnings is nonzero).
+   */
+
+  /* And we're done! */
+  return 1;
+}
+
+
+/*
+ * SOME FINE POINTS:
+ *
+ * In the above code, we ignored the return value of jpeg_read_scanlines,
+ * which is the number of scanlines actually read.  We could get away with
+ * this because we asked for only one line at a time and we weren't using
+ * a suspending data source.  See libjpeg.txt for more info.
+ *
+ * We cheated a bit by calling alloc_sarray() after jpeg_start_decompress();
+ * we should have done it beforehand to ensure that the space would be
+ * counted against the JPEG max_memory setting.  In some systems the above
+ * code would risk an out-of-memory error.  However, in general we don't
+ * know the output image dimensions before jpeg_start_decompress(), unless we
+ * call jpeg_calc_output_dimensions().  See libjpeg.txt for more about this.
+ *
+ * Scanlines are returned in the same order as they appear in the JPEG file,
+ * which is standardly top-to-bottom.  If you must emit data bottom-to-top,
+ * you can use one of the virtual arrays provided by the JPEG memory manager
+ * to invert the data.  See wrbmp.c for an example.
+ *
+ * As with compression, some operating modes may require temporary files.
+ * On some systems you may need to set up a signal handler to ensure that
+ * temporary files are deleted if the program is interrupted.  See libjpeg.txt.
+ */
diff --git a/3rdparty/libjpeg/src/jaricom.c b/3rdparty/libjpeg/src/jaricom.c
new file mode 100644
index 00000000..215640cc
--- /dev/null
+++ b/3rdparty/libjpeg/src/jaricom.c
@@ -0,0 +1,157 @@
+/*
+ * jaricom.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Developed 1997-2009 by Guido Vollbeding.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2015, 2018, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains probability estimation tables for common use in
+ * arithmetic entropy encoding and decoding routines.
+ *
+ * This data represents Table D.2 in
+ * Recommendation ITU-T T.81 (1992) | ISO/IEC 10918-1:1994 and Table 24 in
+ * Recommendation ITU-T T.82 (1993) | ISO/IEC 11544:1993.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+/* The following #define specifies the packing of the four components
+ * into the compact JLONG representation.
+ * Note that this formula must match the actual arithmetic encoder
+ * and decoder implementation.  The implementation has to be changed
+ * if this formula is changed.
+ * The current organization is leaned on Markus Kuhn's JBIG
+ * implementation (jbig_tab.c).
+ */
+
+#define V(i, a, b, c, d) \
+  (((JLONG)a << 16) | ((JLONG)c << 8) | ((JLONG)d << 7) | b)
+
+const JLONG jpeg_aritab[113 + 1] = {
+/*
+ * Index, Qe_Value, Next_Index_LPS, Next_Index_MPS, Switch_MPS
+ */
+  V(   0, 0x5a1d,   1,   1, 1 ),
+  V(   1, 0x2586,  14,   2, 0 ),
+  V(   2, 0x1114,  16,   3, 0 ),
+  V(   3, 0x080b,  18,   4, 0 ),
+  V(   4, 0x03d8,  20,   5, 0 ),
+  V(   5, 0x01da,  23,   6, 0 ),
+  V(   6, 0x00e5,  25,   7, 0 ),
+  V(   7, 0x006f,  28,   8, 0 ),
+  V(   8, 0x0036,  30,   9, 0 ),
+  V(   9, 0x001a,  33,  10, 0 ),
+  V(  10, 0x000d,  35,  11, 0 ),
+  V(  11, 0x0006,   9,  12, 0 ),
+  V(  12, 0x0003,  10,  13, 0 ),
+  V(  13, 0x0001,  12,  13, 0 ),
+  V(  14, 0x5a7f,  15,  15, 1 ),
+  V(  15, 0x3f25,  36,  16, 0 ),
+  V(  16, 0x2cf2,  38,  17, 0 ),
+  V(  17, 0x207c,  39,  18, 0 ),
+  V(  18, 0x17b9,  40,  19, 0 ),
+  V(  19, 0x1182,  42,  20, 0 ),
+  V(  20, 0x0cef,  43,  21, 0 ),
+  V(  21, 0x09a1,  45,  22, 0 ),
+  V(  22, 0x072f,  46,  23, 0 ),
+  V(  23, 0x055c,  48,  24, 0 ),
+  V(  24, 0x0406,  49,  25, 0 ),
+  V(  25, 0x0303,  51,  26, 0 ),
+  V(  26, 0x0240,  52,  27, 0 ),
+  V(  27, 0x01b1,  54,  28, 0 ),
+  V(  28, 0x0144,  56,  29, 0 ),
+  V(  29, 0x00f5,  57,  30, 0 ),
+  V(  30, 0x00b7,  59,  31, 0 ),
+  V(  31, 0x008a,  60,  32, 0 ),
+  V(  32, 0x0068,  62,  33, 0 ),
+  V(  33, 0x004e,  63,  34, 0 ),
+  V(  34, 0x003b,  32,  35, 0 ),
+  V(  35, 0x002c,  33,   9, 0 ),
+  V(  36, 0x5ae1,  37,  37, 1 ),
+  V(  37, 0x484c,  64,  38, 0 ),
+  V(  38, 0x3a0d,  65,  39, 0 ),
+  V(  39, 0x2ef1,  67,  40, 0 ),
+  V(  40, 0x261f,  68,  41, 0 ),
+  V(  41, 0x1f33,  69,  42, 0 ),
+  V(  42, 0x19a8,  70,  43, 0 ),
+  V(  43, 0x1518,  72,  44, 0 ),
+  V(  44, 0x1177,  73,  45, 0 ),
+  V(  45, 0x0e74,  74,  46, 0 ),
+  V(  46, 0x0bfb,  75,  47, 0 ),
+  V(  47, 0x09f8,  77,  48, 0 ),
+  V(  48, 0x0861,  78,  49, 0 ),
+  V(  49, 0x0706,  79,  50, 0 ),
+  V(  50, 0x05cd,  48,  51, 0 ),
+  V(  51, 0x04de,  50,  52, 0 ),
+  V(  52, 0x040f,  50,  53, 0 ),
+  V(  53, 0x0363,  51,  54, 0 ),
+  V(  54, 0x02d4,  52,  55, 0 ),
+  V(  55, 0x025c,  53,  56, 0 ),
+  V(  56, 0x01f8,  54,  57, 0 ),
+  V(  57, 0x01a4,  55,  58, 0 ),
+  V(  58, 0x0160,  56,  59, 0 ),
+  V(  59, 0x0125,  57,  60, 0 ),
+  V(  60, 0x00f6,  58,  61, 0 ),
+  V(  61, 0x00cb,  59,  62, 0 ),
+  V(  62, 0x00ab,  61,  63, 0 ),
+  V(  63, 0x008f,  61,  32, 0 ),
+  V(  64, 0x5b12,  65,  65, 1 ),
+  V(  65, 0x4d04,  80,  66, 0 ),
+  V(  66, 0x412c,  81,  67, 0 ),
+  V(  67, 0x37d8,  82,  68, 0 ),
+  V(  68, 0x2fe8,  83,  69, 0 ),
+  V(  69, 0x293c,  84,  70, 0 ),
+  V(  70, 0x2379,  86,  71, 0 ),
+  V(  71, 0x1edf,  87,  72, 0 ),
+  V(  72, 0x1aa9,  87,  73, 0 ),
+  V(  73, 0x174e,  72,  74, 0 ),
+  V(  74, 0x1424,  72,  75, 0 ),
+  V(  75, 0x119c,  74,  76, 0 ),
+  V(  76, 0x0f6b,  74,  77, 0 ),
+  V(  77, 0x0d51,  75,  78, 0 ),
+  V(  78, 0x0bb6,  77,  79, 0 ),
+  V(  79, 0x0a40,  77,  48, 0 ),
+  V(  80, 0x5832,  80,  81, 1 ),
+  V(  81, 0x4d1c,  88,  82, 0 ),
+  V(  82, 0x438e,  89,  83, 0 ),
+  V(  83, 0x3bdd,  90,  84, 0 ),
+  V(  84, 0x34ee,  91,  85, 0 ),
+  V(  85, 0x2eae,  92,  86, 0 ),
+  V(  86, 0x299a,  93,  87, 0 ),
+  V(  87, 0x2516,  86,  71, 0 ),
+  V(  88, 0x5570,  88,  89, 1 ),
+  V(  89, 0x4ca9,  95,  90, 0 ),
+  V(  90, 0x44d9,  96,  91, 0 ),
+  V(  91, 0x3e22,  97,  92, 0 ),
+  V(  92, 0x3824,  99,  93, 0 ),
+  V(  93, 0x32b4,  99,  94, 0 ),
+  V(  94, 0x2e17,  93,  86, 0 ),
+  V(  95, 0x56a8,  95,  96, 1 ),
+  V(  96, 0x4f46, 101,  97, 0 ),
+  V(  97, 0x47e5, 102,  98, 0 ),
+  V(  98, 0x41cf, 103,  99, 0 ),
+  V(  99, 0x3c3d, 104, 100, 0 ),
+  V( 100, 0x375e,  99,  93, 0 ),
+  V( 101, 0x5231, 105, 102, 0 ),
+  V( 102, 0x4c0f, 106, 103, 0 ),
+  V( 103, 0x4639, 107, 104, 0 ),
+  V( 104, 0x415e, 103,  99, 0 ),
+  V( 105, 0x5627, 105, 106, 1 ),
+  V( 106, 0x50e7, 108, 107, 0 ),
+  V( 107, 0x4b85, 109, 103, 0 ),
+  V( 108, 0x5597, 110, 109, 0 ),
+  V( 109, 0x504f, 111, 107, 0 ),
+  V( 110, 0x5a10, 110, 111, 1 ),
+  V( 111, 0x5522, 112, 109, 0 ),
+  V( 112, 0x59eb, 112, 111, 1 ),
+/*
+ * This last entry is used for fixed probability estimate of 0.5
+ * as recommended in Section 10.3 Table 5 of ITU-T Rec. T.851.
+ */
+  V( 113, 0x5a1d, 113, 113, 0 )
+};
diff --git a/3rdparty/libjpeg/src/java/CMakeLists.txt b/3rdparty/libjpeg/src/java/CMakeLists.txt
new file mode 100644
index 00000000..3d863bdd
--- /dev/null
+++ b/3rdparty/libjpeg/src/java/CMakeLists.txt
@@ -0,0 +1,88 @@
+find_package(Java REQUIRED)
+find_package(JNI REQUIRED)
+
+# Allow the Java compiler flags to be set using an environment variable
+if(NOT DEFINED CMAKE_JAVA_COMPILE_FLAGS AND DEFINED ENV{JAVAFLAGS})
+  set(CMAKE_JAVA_COMPILE_FLAGS $ENV{JAVAFLAGS})
+endif()
+
+include(UseJava)
+
+set(CMAKE_JAVA_COMPILE_FLAGS "${CMAKE_JAVA_COMPILE_FLAGS} -J-Dfile.encoding=UTF8")
+message(STATUS "CMAKE_JAVA_COMPILE_FLAGS = ${CMAKE_JAVA_COMPILE_FLAGS}")
+string(REGEX REPLACE " " ";" CMAKE_JAVA_COMPILE_FLAGS "${CMAKE_JAVA_COMPILE_FLAGS}")
+
+set(JAVAARGS "" CACHE STRING "Additional arguments to pass to java when running unit tests (example: -d32)")
+message(STATUS "JAVAARGS = ${JAVAARGS}")
+
+set(JAVA_SOURCES org/libjpegturbo/turbojpeg/TJ.java
+  org/libjpegturbo/turbojpeg/TJCompressor.java
+  org/libjpegturbo/turbojpeg/TJCustomFilter.java
+  org/libjpegturbo/turbojpeg/TJDecompressor.java
+  org/libjpegturbo/turbojpeg/TJException.java
+  org/libjpegturbo/turbojpeg/TJScalingFactor.java
+  org/libjpegturbo/turbojpeg/TJTransform.java
+  org/libjpegturbo/turbojpeg/TJTransformer.java
+  org/libjpegturbo/turbojpeg/YUVImage.java
+  TJUnitTest.java
+  TJExample.java
+  TJBench.java)
+
+set(TURBOJPEG_DLL_NAME "turbojpeg")
+if(MINGW)
+  set(TURBOJPEG_DLL_NAME "libturbojpeg")
+endif()
+if(WIN32)
+  configure_file(org/libjpegturbo/turbojpeg/TJLoader-win.java.in
+    ${CMAKE_CURRENT_BINARY_DIR}/org/libjpegturbo/turbojpeg/TJLoader.java)
+else()
+  configure_file(org/libjpegturbo/turbojpeg/TJLoader-unix.java.in
+    ${CMAKE_CURRENT_BINARY_DIR}/org/libjpegturbo/turbojpeg/TJLoader.java)
+endif()
+set(JAVA_SOURCES ${JAVA_SOURCES}
+  ${CMAKE_CURRENT_BINARY_DIR}/org/libjpegturbo/turbojpeg/TJLoader.java)
+
+if(MSYS)
+  # UGLY HACK ALERT: If we don't do this, then UseJava.cmake will separate
+  # class path members with a semicolon, which is interpreted as a command
+  # separator by the MSYS shell.
+  set(CMAKE_HOST_SYSTEM_NAME_BAK ${CMAKE_HOST_SYSTEM_NAME})
+  set(CMAKE_HOST_SYSTEM_NAME "MSYS")
+endif()
+add_jar(turbojpeg-java ${JAVA_SOURCES} OUTPUT_NAME turbojpeg
+  ENTRY_POINT TJExample)
+if(MSYS)
+  set(CMAKE_HOST_SYSTEM_NAME ${CMAKE_HOST_SYSTEM_NAME_BAK})
+endif()
+
+add_custom_target(javadoc COMMAND
+  javadoc -notimestamp -d ${CMAKE_CURRENT_SOURCE_DIR}/doc -sourcepath ${CMAKE_CURRENT_SOURCE_DIR} org.libjpegturbo.turbojpeg)
+set(JAVACLASSPATH ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_FILES_DIRECTORY}/turbojpeg-java.dir)
+if(Java_VERSION_MAJOR GREATER 9)
+  add_custom_target(javah
+    COMMAND javac -h ${CMAKE_CURRENT_SOURCE_DIR} -classpath ${JAVACLASSPATH}
+      -d ${CMAKE_CURRENT_BINARY_DIR}/__unused
+      ${CMAKE_CURRENT_SOURCE_DIR}/org/libjpegturbo/turbojpeg/TJ.java
+      ${CMAKE_CURRENT_SOURCE_DIR}/org/libjpegturbo/turbojpeg/TJCompressor.java
+      ${CMAKE_CURRENT_SOURCE_DIR}/org/libjpegturbo/turbojpeg/TJDecompressor.java
+      ${CMAKE_CURRENT_SOURCE_DIR}/org/libjpegturbo/turbojpeg/TJTransformer.java)
+else()
+  add_custom_target(javah
+    COMMAND javah -d ${CMAKE_CURRENT_SOURCE_DIR} -classpath ${JAVACLASSPATH} org.libjpegturbo.turbojpeg.TJ
+    COMMAND javah -d ${CMAKE_CURRENT_SOURCE_DIR} -classpath ${JAVACLASSPATH} org.libjpegturbo.turbojpeg.TJCompressor
+    COMMAND javah -d ${CMAKE_CURRENT_SOURCE_DIR} -classpath ${JAVACLASSPATH} org.libjpegturbo.turbojpeg.TJDecompressor
+    COMMAND javah -d ${CMAKE_CURRENT_SOURCE_DIR} -classpath ${JAVACLASSPATH} org.libjpegturbo.turbojpeg.TJTransformer)
+endif()
+
+if(NOT DEFINED CMAKE_INSTALL_DEFAULT_JAVADIR)
+  set(CMAKE_INSTALL_DEFAULT_JAVADIR "<CMAKE_INSTALL_DATAROOTDIR>/java")
+endif()
+GNUInstallDirs_set_install_dir(JAVADIR
+  "The directory into which Java classes should be installed")
+GNUInstallDirs_get_absolute_install_dir(CMAKE_INSTALL_FULL_JAVADIR
+  CMAKE_INSTALL_JAVADIR)
+set(CMAKE_INSTALL_JAVADIR ${CMAKE_INSTALL_JAVADIR} PARENT_SCOPE)
+set(CMAKE_INSTALL_FULL_JAVADIR ${CMAKE_INSTALL_FULL_JAVADIR} PARENT_SCOPE)
+report_directory(JAVADIR)
+install_jar(turbojpeg-java ${CMAKE_INSTALL_JAVADIR})
+mark_as_advanced(CLEAR CMAKE_INSTALL_JAVADIR)
diff --git a/3rdparty/libjpeg/src/java/MANIFEST.MF b/3rdparty/libjpeg/src/java/MANIFEST.MF
new file mode 100644
index 00000000..723bc51a
--- /dev/null
+++ b/3rdparty/libjpeg/src/java/MANIFEST.MF
@@ -0,0 +1,2 @@
+Manifest-Version: 1.0
+Main-Class: TJExample
diff --git a/3rdparty/libjpeg/src/java/README b/3rdparty/libjpeg/src/java/README
new file mode 100644
index 00000000..5af1e31d
--- /dev/null
+++ b/3rdparty/libjpeg/src/java/README
@@ -0,0 +1,52 @@
+TurboJPEG Java Wrapper
+======================
+
+The TurboJPEG shared library can optionally be built with a Java Native
+Interface wrapper, which allows the library to be loaded and used directly from
+Java applications.  The Java front end for this is defined in several classes
+located under org/libjpegturbo/turbojpeg.  The source code for these Java
+classes is licensed under a BSD-style license, so the files can be incorporated
+directly into both open source and proprietary projects without restriction.  A
+Java archive (JAR) file containing these classes is also shipped with the
+"official" distribution packages of libjpeg-turbo.
+
+TJExample.java, which should also be located in the same directory as this
+README file, demonstrates how to use the TurboJPEG Java API to compress and
+decompress JPEG images in memory.
+
+
+Performance Pitfalls
+--------------------
+
+The TurboJPEG Java API defines several convenience methods that can allocate
+image buffers or instantiate classes to hold the result of compress,
+decompress, or transform operations.  However, if you use these methods, then
+be mindful of the amount of new data you are creating on the heap.  It may be
+necessary to manually invoke the garbage collector to prevent heap exhaustion
+or to prevent performance degradation.  Background garbage collection can kill
+performance, particularly in a multi-threaded environment (Java pauses all
+threads when the GC runs.)
+
+The TurboJPEG Java API always gives you the option of pre-allocating your own
+source and destination buffers, which allows you to re-use those buffers for
+compressing/decompressing multiple images.  If the image sequence you are
+compressing or decompressing consists of images of the same size, then
+pre-allocating the buffers is recommended.
+
+
+Installation Directory
+----------------------
+
+The TurboJPEG Java Wrapper will look for the TurboJPEG JNI library
+(libturbojpeg.so, libturbojpeg.dylib, or turbojpeg.dll) in the system library
+paths or in any paths specified in LD_LIBRARY_PATH (Un*x), DYLD_LIBRARY_PATH
+(Mac), or PATH (Windows.)  Failing this, on Un*x and Mac systems, the wrapper
+will look for the JNI library under the library directory configured when
+libjpeg-turbo was built.  If that library directory is
+/opt/libjpeg-turbo/lib32, then /opt/libjpeg-turbo/lib64 is also searched, and
+vice versa.
+
+If you installed the JNI library into another directory, then you will need
+to pass an argument of -Djava.library.path={path_to_JNI_library} to java, or
+manipulate LD_LIBRARY_PATH, DYLD_LIBRARY_PATH, or PATH to include the directory
+containing the JNI library.
diff --git a/3rdparty/libjpeg/src/java/TJBench.java b/3rdparty/libjpeg/src/java/TJBench.java
new file mode 100644
index 00000000..e43645ea
--- /dev/null
+++ b/3rdparty/libjpeg/src/java/TJBench.java
@@ -0,0 +1,1021 @@
+/*
+ * Copyright (C)2009-2014, 2016-2019 D. R. Commander.  All Rights Reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright notice,
+ *   this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright notice,
+ *   this list of conditions and the following disclaimer in the documentation
+ *   and/or other materials provided with the distribution.
+ * - Neither the name of the libjpeg-turbo Project nor the names of its
+ *   contributors may be used to endorse or promote products derived from this
+ *   software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE 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 HOLDERS 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.
+ */
+
+import java.io.*;
+import java.awt.image.*;
+import javax.imageio.*;
+import java.util.*;
+import org.libjpegturbo.turbojpeg.*;
+
+final class TJBench {
+
+  private TJBench() {}
+
+  private static int flags = 0, quiet = 0, pf = TJ.PF_BGR, yuvPad = 1;
+  private static boolean compOnly, decompOnly, doTile, doYUV, write = true;
+
+  static final String[] PIXFORMATSTR = {
+    "RGB", "BGR", "RGBX", "BGRX", "XBGR", "XRGB", "GRAY"
+  };
+
+  static final String[] SUBNAME_LONG = {
+    "4:4:4", "4:2:2", "4:2:0", "GRAY", "4:4:0", "4:1:1"
+  };
+
+  static final String[] SUBNAME = {
+    "444", "422", "420", "GRAY", "440", "411"
+  };
+
+  static final String[] CSNAME = {
+    "RGB", "YCbCr", "GRAY", "CMYK", "YCCK"
+  };
+
+  private static TJScalingFactor sf;
+  private static int xformOp = TJTransform.OP_NONE, xformOpt = 0;
+  private static double benchTime = 5.0, warmup = 1.0;
+
+
+  static double getTime() {
+    return (double)System.nanoTime() / 1.0e9;
+  }
+
+
+  private static String tjErrorMsg;
+  private static int tjErrorCode = -1;
+
+  static void handleTJException(TJException e) throws TJException {
+    String errorMsg = e.getMessage();
+    int errorCode = e.getErrorCode();
+
+    if ((flags & TJ.FLAG_STOPONWARNING) == 0 &&
+        errorCode == TJ.ERR_WARNING) {
+      if (tjErrorMsg == null || !tjErrorMsg.equals(errorMsg) ||
+          tjErrorCode != errorCode) {
+        tjErrorMsg = errorMsg;
+        tjErrorCode = errorCode;
+        System.out.println("WARNING: " + errorMsg);
+      }
+    } else
+      throw e;
+  }
+
+
+  static String formatName(int subsamp, int cs) {
+    if (cs == TJ.CS_YCbCr)
+      return SUBNAME_LONG[subsamp];
+    else if (cs == TJ.CS_YCCK)
+      return CSNAME[cs] + " " + SUBNAME_LONG[subsamp];
+    else
+      return CSNAME[cs];
+  }
+
+
+  static String sigFig(double val, int figs) {
+    String format;
+    int digitsAfterDecimal = figs - (int)Math.ceil(Math.log10(Math.abs(val)));
+
+    if (digitsAfterDecimal < 1)
+      format = new String("%.0f");
+    else
+      format = new String("%." + digitsAfterDecimal + "f");
+    return String.format(format, val);
+  }
+
+
+  static byte[] loadImage(String fileName, int[] w, int[] h, int pixelFormat)
+                          throws Exception {
+    BufferedImage img = ImageIO.read(new File(fileName));
+
+    if (img == null)
+      throw new Exception("Could not read " + fileName);
+    w[0] = img.getWidth();
+    h[0] = img.getHeight();
+
+    int[] rgb = img.getRGB(0, 0, w[0], h[0], null, 0, w[0]);
+    int ps = TJ.getPixelSize(pixelFormat);
+    int rindex = TJ.getRedOffset(pixelFormat);
+    int gindex = TJ.getGreenOffset(pixelFormat);
+    int bindex = TJ.getBlueOffset(pixelFormat);
+    if ((long)w[0] * (long)h[0] * (long)ps > (long)Integer.MAX_VALUE)
+      throw new Exception("Image is too large");
+    byte[] dstBuf = new byte[w[0] * h[0] * ps];
+    int pixels = w[0] * h[0], dstPtr = 0, rgbPtr = 0;
+
+    while (pixels-- > 0) {
+      dstBuf[dstPtr + rindex] = (byte)((rgb[rgbPtr] >> 16) & 0xff);
+      dstBuf[dstPtr + gindex] = (byte)((rgb[rgbPtr] >> 8) & 0xff);
+      dstBuf[dstPtr + bindex] = (byte)(rgb[rgbPtr] & 0xff);
+      dstPtr += ps;
+      rgbPtr++;
+    }
+    return dstBuf;
+  }
+
+
+  static void saveImage(String fileName, byte[] srcBuf, int w, int h,
+                        int pixelFormat) throws Exception {
+    BufferedImage img = new BufferedImage(w, h, BufferedImage.TYPE_INT_RGB);
+    int pixels = w * h, srcPtr = 0;
+    int ps = TJ.getPixelSize(pixelFormat);
+    int rindex = TJ.getRedOffset(pixelFormat);
+    int gindex = TJ.getGreenOffset(pixelFormat);
+    int bindex = TJ.getBlueOffset(pixelFormat);
+
+    for (int y = 0; y < h; y++) {
+      for (int x = 0; x < w; x++, srcPtr += ps) {
+        int pixel = (srcBuf[srcPtr + rindex] & 0xff) << 16 |
+                    (srcBuf[srcPtr + gindex] & 0xff) << 8 |
+                    (srcBuf[srcPtr + bindex] & 0xff);
+
+        img.setRGB(x, y, pixel);
+      }
+    }
+    ImageIO.write(img, "bmp", new File(fileName));
+  }
+
+
+  /* Decompression test */
+  static void decomp(byte[] srcBuf, byte[][] jpegBuf, int[] jpegSize,
+                     byte[] dstBuf, int w, int h, int subsamp, int jpegQual,
+                     String fileName, int tilew, int tileh) throws Exception {
+    String qualStr = new String(""), sizeStr, tempStr;
+    TJDecompressor tjd;
+    double elapsed, elapsedDecode;
+    int ps = TJ.getPixelSize(pf), i, iter = 0;
+    int scaledw = sf.getScaled(w);
+    int scaledh = sf.getScaled(h);
+    int pitch = scaledw * ps;
+    YUVImage yuvImage = null;
+
+    if (jpegQual > 0)
+      qualStr = new String("_Q" + jpegQual);
+
+    tjd = new TJDecompressor();
+
+    if (dstBuf == null) {
+      if ((long)pitch * (long)scaledh > (long)Integer.MAX_VALUE)
+        throw new Exception("Image is too large");
+      dstBuf = new byte[pitch * scaledh];
+    }
+
+    /* Set the destination buffer to gray so we know whether the decompressor
+       attempted to write to it */
+    Arrays.fill(dstBuf, (byte)127);
+
+    if (doYUV) {
+      int width = doTile ? tilew : scaledw;
+      int height = doTile ? tileh : scaledh;
+
+      yuvImage = new YUVImage(width, yuvPad, height, subsamp);
+      Arrays.fill(yuvImage.getBuf(), (byte)127);
+    }
+
+    /* Benchmark */
+    iter = -1;
+    elapsed = elapsedDecode = 0.0;
+    while (true) {
+      int tile = 0;
+      double start = getTime();
+
+      for (int y = 0; y < h; y += tileh) {
+        for (int x = 0; x < w; x += tilew, tile++) {
+          int width = doTile ? Math.min(tilew, w - x) : scaledw;
+          int height = doTile ? Math.min(tileh, h - y) : scaledh;
+
+          try {
+            tjd.setSourceImage(jpegBuf[tile], jpegSize[tile]);
+          } catch (TJException e) { handleTJException(e); }
+          if (doYUV) {
+            yuvImage.setBuf(yuvImage.getBuf(), width, yuvPad, height, subsamp);
+            try {
+              tjd.decompressToYUV(yuvImage, flags);
+            } catch (TJException e) { handleTJException(e); }
+            double startDecode = getTime();
+            tjd.setSourceImage(yuvImage);
+            try {
+              tjd.decompress(dstBuf, x, y, width, pitch, height, pf, flags);
+            } catch (TJException e) { handleTJException(e); }
+            if (iter >= 0)
+              elapsedDecode += getTime() - startDecode;
+          } else {
+            try {
+              tjd.decompress(dstBuf, x, y, width, pitch, height, pf, flags);
+            } catch (TJException e) { handleTJException(e); }
+          }
+        }
+      }
+      elapsed += getTime() - start;
+      if (iter >= 0) {
+        iter++;
+        if (elapsed >= benchTime)
+          break;
+      } else if (elapsed >= warmup) {
+        iter = 0;
+        elapsed = elapsedDecode = 0.0;
+      }
+    }
+    if (doYUV)
+      elapsed -= elapsedDecode;
+
+    tjd = null;
+    for (i = 0; i < jpegBuf.length; i++)
+      jpegBuf[i] = null;
+    jpegBuf = null;  jpegSize = null;
+    System.gc();
+
+    if (quiet != 0) {
+      System.out.format("%-6s%s",
+                        sigFig((double)(w * h) / 1000000. *
+                               (double)iter / elapsed, 4),
+                        quiet == 2 ? "\n" : "  ");
+      if (doYUV)
+        System.out.format("%s\n",
+                          sigFig((double)(w * h) / 1000000. *
+                                 (double)iter / elapsedDecode, 4));
+      else if (quiet != 2)
+        System.out.print("\n");
+    } else {
+      System.out.format("%s --> Frame rate:         %f fps\n",
+                        (doYUV ? "Decomp to YUV" : "Decompress   "),
+                        (double)iter / elapsed);
+      System.out.format("                  Throughput:         %f Megapixels/sec\n",
+                        (double)(w * h) / 1000000. * (double)iter / elapsed);
+      if (doYUV) {
+        System.out.format("YUV Decode    --> Frame rate:         %f fps\n",
+                          (double)iter / elapsedDecode);
+        System.out.format("                  Throughput:         %f Megapixels/sec\n",
+                          (double)(w * h) / 1000000. *
+                          (double)iter / elapsedDecode);
+      }
+    }
+
+    if (!write) return;
+
+    if (sf.getNum() != 1 || sf.getDenom() != 1)
+      sizeStr = new String(sf.getNum() + "_" + sf.getDenom());
+    else if (tilew != w || tileh != h)
+      sizeStr = new String(tilew + "x" + tileh);
+    else
+      sizeStr = new String("full");
+    if (decompOnly)
+      tempStr = new String(fileName + "_" + sizeStr + ".bmp");
+    else
+      tempStr = new String(fileName + "_" + SUBNAME[subsamp] + qualStr +
+                           "_" + sizeStr + ".bmp");
+
+    saveImage(tempStr, dstBuf, scaledw, scaledh, pf);
+    int ndx = tempStr.lastIndexOf('.');
+    tempStr = new String(tempStr.substring(0, ndx) + "-err.bmp");
+    if (srcBuf != null && sf.getNum() == 1 && sf.getDenom() == 1) {
+      if (quiet == 0)
+        System.out.println("Compression error written to " + tempStr + ".");
+      if (subsamp == TJ.SAMP_GRAY) {
+        for (int y = 0, index = 0; y < h; y++, index += pitch) {
+          for (int x = 0, index2 = index; x < w; x++, index2 += ps) {
+            int rindex = index2 + TJ.getRedOffset(pf);
+            int gindex = index2 + TJ.getGreenOffset(pf);
+            int bindex = index2 + TJ.getBlueOffset(pf);
+            int lum = (int)((double)(srcBuf[rindex] & 0xff) * 0.299 +
+                            (double)(srcBuf[gindex] & 0xff) * 0.587 +
+                            (double)(srcBuf[bindex] & 0xff) * 0.114 + 0.5);
+
+            if (lum > 255) lum = 255;
+            if (lum < 0) lum = 0;
+            dstBuf[rindex] = (byte)Math.abs((dstBuf[rindex] & 0xff) - lum);
+            dstBuf[gindex] = (byte)Math.abs((dstBuf[gindex] & 0xff) - lum);
+            dstBuf[bindex] = (byte)Math.abs((dstBuf[bindex] & 0xff) - lum);
+          }
+        }
+      } else {
+        for (int y = 0; y < h; y++)
+          for (int x = 0; x < w * ps; x++)
+            dstBuf[pitch * y + x] =
+              (byte)Math.abs((dstBuf[pitch * y + x] & 0xff) -
+                             (srcBuf[pitch * y + x] & 0xff));
+      }
+      saveImage(tempStr, dstBuf, w, h, pf);
+    }
+  }
+
+
+  static void fullTest(byte[] srcBuf, int w, int h, int subsamp, int jpegQual,
+                       String fileName) throws Exception {
+    TJCompressor tjc;
+    byte[] tmpBuf;
+    byte[][] jpegBuf;
+    int[] jpegSize;
+    double start, elapsed, elapsedEncode;
+    int totalJpegSize = 0, tilew, tileh, i, iter;
+    int ps = TJ.getPixelSize(pf);
+    int ntilesw = 1, ntilesh = 1, pitch = w * ps;
+    String pfStr = PIXFORMATSTR[pf];
+    YUVImage yuvImage = null;
+
+    if ((long)pitch * (long)h > (long)Integer.MAX_VALUE)
+      throw new Exception("Image is too large");
+    tmpBuf = new byte[pitch * h];
+
+    if (quiet == 0)
+      System.out.format(">>>>>  %s (%s) <--> JPEG %s Q%d  <<<<<\n", pfStr,
+                        (flags & TJ.FLAG_BOTTOMUP) != 0 ?
+                        "Bottom-up" : "Top-down",
+                        SUBNAME_LONG[subsamp], jpegQual);
+
+    tjc = new TJCompressor();
+
+    for (tilew = doTile ? 8 : w, tileh = doTile ? 8 : h; ;
+         tilew *= 2, tileh *= 2) {
+      if (tilew > w)
+        tilew = w;
+      if (tileh > h)
+        tileh = h;
+      ntilesw = (w + tilew - 1) / tilew;
+      ntilesh = (h + tileh - 1) / tileh;
+
+      jpegBuf = new byte[ntilesw * ntilesh][TJ.bufSize(tilew, tileh, subsamp)];
+      jpegSize = new int[ntilesw * ntilesh];
+
+      /* Compression test */
+      if (quiet == 1)
+        System.out.format("%-4s (%s)  %-5s    %-3d   ", pfStr,
+                          (flags & TJ.FLAG_BOTTOMUP) != 0 ? "BU" : "TD",
+                          SUBNAME_LONG[subsamp], jpegQual);
+      for (i = 0; i < h; i++)
+        System.arraycopy(srcBuf, w * ps * i, tmpBuf, pitch * i, w * ps);
+      tjc.setJPEGQuality(jpegQual);
+      tjc.setSubsamp(subsamp);
+
+      if (doYUV) {
+        yuvImage = new YUVImage(tilew, yuvPad, tileh, subsamp);
+        Arrays.fill(yuvImage.getBuf(), (byte)127);
+      }
+
+      /* Benchmark */
+      iter = -1;
+      elapsed = elapsedEncode = 0.0;
+      while (true) {
+        int tile = 0;
+
+        totalJpegSize = 0;
+        start = getTime();
+        for (int y = 0; y < h; y += tileh) {
+          for (int x = 0; x < w; x += tilew, tile++) {
+            int width = Math.min(tilew, w - x);
+            int height = Math.min(tileh, h - y);
+
+            tjc.setSourceImage(srcBuf, x, y, width, pitch, height, pf);
+            if (doYUV) {
+              double startEncode = getTime();
+
+              yuvImage.setBuf(yuvImage.getBuf(), width, yuvPad, height,
+                              subsamp);
+              tjc.encodeYUV(yuvImage, flags);
+              if (iter >= 0)
+                elapsedEncode += getTime() - startEncode;
+              tjc.setSourceImage(yuvImage);
+            }
+            tjc.compress(jpegBuf[tile], flags);
+            jpegSize[tile] = tjc.getCompressedSize();
+            totalJpegSize += jpegSize[tile];
+          }
+        }
+        elapsed += getTime() - start;
+        if (iter >= 0) {
+          iter++;
+          if (elapsed >= benchTime)
+            break;
+        } else if (elapsed >= warmup) {
+          iter = 0;
+          elapsed = elapsedEncode = 0.0;
+        }
+      }
+      if (doYUV)
+        elapsed -= elapsedEncode;
+
+      if (quiet == 1)
+        System.out.format("%-5d  %-5d   ", tilew, tileh);
+      if (quiet != 0) {
+        if (doYUV)
+          System.out.format("%-6s%s",
+                            sigFig((double)(w * h) / 1000000. *
+                                   (double)iter / elapsedEncode, 4),
+                            quiet == 2 ? "\n" : "  ");
+        System.out.format("%-6s%s",
+                          sigFig((double)(w * h) / 1000000. *
+                                 (double)iter / elapsed, 4),
+                          quiet == 2 ? "\n" : "  ");
+        System.out.format("%-6s%s",
+                          sigFig((double)(w * h * ps) / (double)totalJpegSize,
+                                 4),
+                          quiet == 2 ? "\n" : "  ");
+      } else {
+        System.out.format("\n%s size: %d x %d\n", doTile ? "Tile" : "Image",
+                          tilew, tileh);
+        if (doYUV) {
+          System.out.format("Encode YUV    --> Frame rate:         %f fps\n",
+                            (double)iter / elapsedEncode);
+          System.out.format("                  Output image size:  %d bytes\n",
+                            yuvImage.getSize());
+          System.out.format("                  Compression ratio:  %f:1\n",
+                            (double)(w * h * ps) / (double)yuvImage.getSize());
+          System.out.format("                  Throughput:         %f Megapixels/sec\n",
+                            (double)(w * h) / 1000000. *
+                            (double)iter / elapsedEncode);
+          System.out.format("                  Output bit stream:  %f Megabits/sec\n",
+                            (double)yuvImage.getSize() * 8. / 1000000. *
+                            (double)iter / elapsedEncode);
+        }
+        System.out.format("%s --> Frame rate:         %f fps\n",
+                          doYUV ? "Comp from YUV" : "Compress     ",
+                          (double)iter / elapsed);
+        System.out.format("                  Output image size:  %d bytes\n",
+                          totalJpegSize);
+        System.out.format("                  Compression ratio:  %f:1\n",
+                          (double)(w * h * ps) / (double)totalJpegSize);
+        System.out.format("                  Throughput:         %f Megapixels/sec\n",
+                          (double)(w * h) / 1000000. * (double)iter / elapsed);
+        System.out.format("                  Output bit stream:  %f Megabits/sec\n",
+                          (double)totalJpegSize * 8. / 1000000. *
+                          (double)iter / elapsed);
+      }
+      if (tilew == w && tileh == h && write) {
+        String tempStr = fileName + "_" + SUBNAME[subsamp] + "_" + "Q" +
+                         jpegQual + ".jpg";
+        FileOutputStream fos = new FileOutputStream(tempStr);
+
+        fos.write(jpegBuf[0], 0, jpegSize[0]);
+        fos.close();
+        if (quiet == 0)
+          System.out.println("Reference image written to " + tempStr);
+      }
+
+      /* Decompression test */
+      if (!compOnly)
+        decomp(srcBuf, jpegBuf, jpegSize, tmpBuf, w, h, subsamp, jpegQual,
+               fileName, tilew, tileh);
+      else if (quiet == 1)
+        System.out.println("N/A");
+
+      if (tilew == w && tileh == h) break;
+    }
+  }
+
+
+  static void decompTest(String fileName) throws Exception {
+    TJTransformer tjt;
+    byte[][] jpegBuf = null;
+    byte[] srcBuf;
+    int[] jpegSize = null;
+    int totalJpegSize;
+    double start, elapsed;
+    int ps = TJ.getPixelSize(pf), tile, x, y, iter;
+    // Original image
+    int w = 0, h = 0, ntilesw = 1, ntilesh = 1, subsamp = -1, cs = -1;
+    // Transformed image
+    int tw, th, ttilew, ttileh, tntilesw, tntilesh, tsubsamp;
+
+    FileInputStream fis = new FileInputStream(fileName);
+    if (fis.getChannel().size() > (long)Integer.MAX_VALUE)
+      throw new Exception("Image is too large");
+    int srcSize = (int)fis.getChannel().size();
+    srcBuf = new byte[srcSize];
+    fis.read(srcBuf, 0, srcSize);
+    fis.close();
+
+    int index = fileName.lastIndexOf('.');
+    if (index >= 0)
+      fileName = new String(fileName.substring(0, index));
+
+    tjt = new TJTransformer();
+
+    try {
+      tjt.setSourceImage(srcBuf, srcSize);
+    } catch (TJException e) { handleTJException(e); }
+    w = tjt.getWidth();
+    h = tjt.getHeight();
+    subsamp = tjt.getSubsamp();
+    cs = tjt.getColorspace();
+
+    if (quiet == 1) {
+      System.out.println("All performance values in Mpixels/sec\n");
+      System.out.format("Bitmap     JPEG   JPEG     %s  %s   Xform   Comp    Decomp  ",
+                        (doTile ? "Tile " : "Image"),
+                        (doTile ? "Tile " : "Image"));
+      if (doYUV)
+        System.out.print("Decode");
+      System.out.print("\n");
+      System.out.print("Format     CS     Subsamp  Width  Height  Perf    Ratio   Perf    ");
+      if (doYUV)
+        System.out.print("Perf");
+      System.out.println("\n");
+    } else if (quiet == 0)
+      System.out.format(">>>>>  JPEG %s --> %s (%s)  <<<<<\n",
+                        formatName(subsamp, cs), PIXFORMATSTR[pf],
+                        (flags & TJ.FLAG_BOTTOMUP) != 0 ?
+                        "Bottom-up" : "Top-down");
+
+    for (int tilew = doTile ? 16 : w, tileh = doTile ? 16 : h; ;
+         tilew *= 2, tileh *= 2) {
+      if (tilew > w)
+        tilew = w;
+      if (tileh > h)
+        tileh = h;
+      ntilesw = (w + tilew - 1) / tilew;
+      ntilesh = (h + tileh - 1) / tileh;
+
+      tw = w;  th = h;  ttilew = tilew;  ttileh = tileh;
+      if (quiet == 0) {
+        System.out.format("\n%s size: %d x %d", (doTile ? "Tile" : "Image"),
+                          ttilew, ttileh);
+        if (sf.getNum() != 1 || sf.getDenom() != 1)
+          System.out.format(" --> %d x %d", sf.getScaled(tw),
+                            sf.getScaled(th));
+        System.out.println("");
+      } else if (quiet == 1) {
+        System.out.format("%-4s (%s)  %-5s  %-5s    ", PIXFORMATSTR[pf],
+                          (flags & TJ.FLAG_BOTTOMUP) != 0 ? "BU" : "TD",
+                          CSNAME[cs], SUBNAME_LONG[subsamp]);
+        System.out.format("%-5d  %-5d   ", tilew, tileh);
+      }
+
+      tsubsamp = subsamp;
+      if (doTile || xformOp != TJTransform.OP_NONE || xformOpt != 0) {
+        if (xformOp == TJTransform.OP_TRANSPOSE ||
+            xformOp == TJTransform.OP_TRANSVERSE ||
+            xformOp == TJTransform.OP_ROT90 ||
+            xformOp == TJTransform.OP_ROT270) {
+          tw = h;  th = w;  ttilew = tileh;  ttileh = tilew;
+        }
+
+        if ((xformOpt & TJTransform.OPT_GRAY) != 0)
+          tsubsamp = TJ.SAMP_GRAY;
+        if (xformOp == TJTransform.OP_HFLIP ||
+            xformOp == TJTransform.OP_ROT180)
+          tw = tw - (tw % TJ.getMCUWidth(tsubsamp));
+        if (xformOp == TJTransform.OP_VFLIP ||
+            xformOp == TJTransform.OP_ROT180)
+          th = th - (th % TJ.getMCUHeight(tsubsamp));
+        if (xformOp == TJTransform.OP_TRANSVERSE ||
+            xformOp == TJTransform.OP_ROT90)
+          tw = tw - (tw % TJ.getMCUHeight(tsubsamp));
+        if (xformOp == TJTransform.OP_TRANSVERSE ||
+            xformOp == TJTransform.OP_ROT270)
+          th = th - (th % TJ.getMCUWidth(tsubsamp));
+        tntilesw = (tw + ttilew - 1) / ttilew;
+        tntilesh = (th + ttileh - 1) / ttileh;
+
+        if (xformOp == TJTransform.OP_TRANSPOSE ||
+            xformOp == TJTransform.OP_TRANSVERSE ||
+            xformOp == TJTransform.OP_ROT90 ||
+            xformOp == TJTransform.OP_ROT270) {
+          if (tsubsamp == TJ.SAMP_422)
+            tsubsamp = TJ.SAMP_440;
+          else if (tsubsamp == TJ.SAMP_440)
+            tsubsamp = TJ.SAMP_422;
+        }
+
+        TJTransform[] t = new TJTransform[tntilesw * tntilesh];
+        jpegBuf =
+          new byte[tntilesw * tntilesh][TJ.bufSize(ttilew, ttileh, subsamp)];
+
+        for (y = 0, tile = 0; y < th; y += ttileh) {
+          for (x = 0; x < tw; x += ttilew, tile++) {
+            t[tile] = new TJTransform();
+            t[tile].width = Math.min(ttilew, tw - x);
+            t[tile].height = Math.min(ttileh, th - y);
+            t[tile].x = x;
+            t[tile].y = y;
+            t[tile].op = xformOp;
+            t[tile].options = xformOpt | TJTransform.OPT_TRIM;
+            if ((t[tile].options & TJTransform.OPT_NOOUTPUT) != 0 &&
+                jpegBuf[tile] != null)
+              jpegBuf[tile] = null;
+          }
+        }
+
+        iter = -1;
+        elapsed = 0.;
+        while (true) {
+          start = getTime();
+          try {
+            tjt.transform(jpegBuf, t, flags);
+          } catch (TJException e) { handleTJException(e); }
+          jpegSize = tjt.getTransformedSizes();
+          elapsed += getTime() - start;
+          if (iter >= 0) {
+            iter++;
+            if (elapsed >= benchTime)
+              break;
+          } else if (elapsed >= warmup) {
+            iter = 0;
+            elapsed = 0.0;
+          }
+        }
+        t = null;
+
+        for (tile = 0, totalJpegSize = 0; tile < tntilesw * tntilesh; tile++)
+          totalJpegSize += jpegSize[tile];
+
+        if (quiet != 0) {
+          System.out.format("%-6s%s%-6s%s",
+                            sigFig((double)(w * h) / 1000000. / elapsed, 4),
+                            quiet == 2 ? "\n" : "  ",
+                            sigFig((double)(w * h * ps) /
+                                   (double)totalJpegSize, 4),
+                            quiet == 2 ? "\n" : "  ");
+        } else if (quiet == 0) {
+          System.out.format("Transform     --> Frame rate:         %f fps\n",
+                            1.0 / elapsed);
+          System.out.format("                  Output image size:  %d bytes\n",
+                            totalJpegSize);
+          System.out.format("                  Compression ratio:  %f:1\n",
+                            (double)(w * h * ps) / (double)totalJpegSize);
+          System.out.format("                  Throughput:         %f Megapixels/sec\n",
+                            (double)(w * h) / 1000000. / elapsed);
+          System.out.format("                  Output bit stream:  %f Megabits/sec\n",
+                            (double)totalJpegSize * 8. / 1000000. / elapsed);
+        }
+      } else {
+        if (quiet == 1)
+          System.out.print("N/A     N/A     ");
+        jpegBuf = new byte[1][TJ.bufSize(ttilew, ttileh, subsamp)];
+        jpegSize = new int[1];
+        jpegBuf[0] = srcBuf;
+        jpegSize[0] = srcSize;
+      }
+
+      if (w == tilew)
+        ttilew = tw;
+      if (h == tileh)
+        ttileh = th;
+      if ((xformOpt & TJTransform.OPT_NOOUTPUT) == 0)
+        decomp(null, jpegBuf, jpegSize, null, tw, th, tsubsamp, 0,
+               fileName, ttilew, ttileh);
+      else if (quiet == 1)
+        System.out.println("N/A");
+
+      jpegBuf = null;
+      jpegSize = null;
+
+      if (tilew == w && tileh == h) break;
+    }
+  }
+
+
+  static void usage() throws Exception {
+    int i;
+    TJScalingFactor[] scalingFactors = TJ.getScalingFactors();
+    int nsf = scalingFactors.length;
+    String className = new TJBench().getClass().getName();
+
+    System.out.println("\nUSAGE: java " + className);
+    System.out.println("       <Inputfile (BMP)> <Quality> [options]\n");
+    System.out.println("       java " + className);
+    System.out.println("       <Inputfile (JPG)> [options]\n");
+    System.out.println("Options:\n");
+    System.out.println("-alloc = Dynamically allocate JPEG image buffers");
+    System.out.println("-bottomup = Test bottom-up compression/decompression");
+    System.out.println("-tile = Test performance of the codec when the image is encoded as separate");
+    System.out.println("     tiles of varying sizes.");
+    System.out.println("-rgb, -bgr, -rgbx, -bgrx, -xbgr, -xrgb =");
+    System.out.println("     Test the specified color conversion path in the codec (default = BGR)");
+    System.out.println("-fastupsample = Use the fastest chrominance upsampling algorithm available in");
+    System.out.println("     the underlying codec");
+    System.out.println("-fastdct = Use the fastest DCT/IDCT algorithms available in the underlying");
+    System.out.println("     codec");
+    System.out.println("-accuratedct = Use the most accurate DCT/IDCT algorithms available in the");
+    System.out.println("     underlying codec");
+    System.out.println("-progressive = Use progressive entropy coding in JPEG images generated by");
+    System.out.println("     compression and transform operations.");
+    System.out.println("-subsamp <s> = When testing JPEG compression, this option specifies the level");
+    System.out.println("     of chrominance subsampling to use (<s> = 444, 422, 440, 420, 411, or");
+    System.out.println("     GRAY).  The default is to test Grayscale, 4:2:0, 4:2:2, and 4:4:4 in");
+    System.out.println("     sequence.");
+    System.out.println("-quiet = Output results in tabular rather than verbose format");
+    System.out.println("-yuv = Test YUV encoding/decoding functions");
+    System.out.println("-yuvpad <p> = If testing YUV encoding/decoding, this specifies the number of");
+    System.out.println("     bytes to which each row of each plane in the intermediate YUV image is");
+    System.out.println("     padded (default = 1)");
+    System.out.println("-scale M/N = Scale down the width/height of the decompressed JPEG image by a");
+    System.out.print("     factor of M/N (M/N = ");
+    for (i = 0; i < nsf; i++) {
+      System.out.format("%d/%d", scalingFactors[i].getNum(),
+                        scalingFactors[i].getDenom());
+      if (nsf == 2 && i != nsf - 1)
+        System.out.print(" or ");
+      else if (nsf > 2) {
+        if (i != nsf - 1)
+          System.out.print(", ");
+        if (i == nsf - 2)
+          System.out.print("or ");
+      }
+      if (i % 8 == 0 && i != 0)
+        System.out.print("\n     ");
+    }
+    System.out.println(")");
+    System.out.println("-hflip, -vflip, -transpose, -transverse, -rot90, -rot180, -rot270 =");
+    System.out.println("     Perform the corresponding lossless transform prior to");
+    System.out.println("     decompression (these options are mutually exclusive)");
+    System.out.println("-grayscale = Perform lossless grayscale conversion prior to decompression");
+    System.out.println("     test (can be combined with the other transforms above)");
+    System.out.println("-copynone = Do not copy any extra markers (including EXIF and ICC profile data)");
+    System.out.println("     when transforming the image.");
+    System.out.println("-benchtime <t> = Run each benchmark for at least <t> seconds (default = 5.0)");
+    System.out.println("-warmup <t> = Run each benchmark for <t> seconds (default = 1.0) prior to");
+    System.out.println("     starting the timer, in order to prime the caches and thus improve the");
+    System.out.println("     consistency of the results.");
+    System.out.println("-componly = Stop after running compression tests.  Do not test decompression.");
+    System.out.println("-nowrite = Do not write reference or output images (improves consistency");
+    System.out.println("     of performance measurements.)");
+    System.out.println("-stoponwarning = Immediately discontinue the current");
+    System.out.println("     compression/decompression/transform operation if the underlying codec");
+    System.out.println("     throws a warning (non-fatal error)\n");
+    System.out.println("NOTE:  If the quality is specified as a range (e.g. 90-100), a separate");
+    System.out.println("test will be performed for all quality values in the range.\n");
+    System.exit(1);
+  }
+
+
+  public static void main(String[] argv) {
+    byte[] srcBuf = null;
+    int w = 0, h = 0, minQual = -1, maxQual = -1;
+    int minArg = 1, retval = 0;
+    int subsamp = -1;
+
+    try {
+
+      if (argv.length < minArg)
+        usage();
+
+      String tempStr = argv[0].toLowerCase();
+      if (tempStr.endsWith(".jpg") || tempStr.endsWith(".jpeg"))
+        decompOnly = true;
+
+      System.out.println("");
+
+      if (!decompOnly) {
+        minArg = 2;
+        if (argv.length < minArg)
+          usage();
+        try {
+          minQual = Integer.parseInt(argv[1]);
+        } catch (NumberFormatException e) {}
+        if (minQual < 1 || minQual > 100)
+          throw new Exception("Quality must be between 1 and 100.");
+        int dashIndex = argv[1].indexOf('-');
+        if (dashIndex > 0 && argv[1].length() > dashIndex + 1) {
+          try {
+            maxQual = Integer.parseInt(argv[1].substring(dashIndex + 1));
+          } catch (NumberFormatException e) {}
+        }
+        if (maxQual < 1 || maxQual > 100)
+          maxQual = minQual;
+      }
+
+      if (argv.length > minArg) {
+        for (int i = minArg; i < argv.length; i++) {
+          if (argv[i].equalsIgnoreCase("-tile")) {
+            doTile = true;  xformOpt |= TJTransform.OPT_CROP;
+          } else if (argv[i].equalsIgnoreCase("-fastupsample")) {
+            System.out.println("Using fast upsampling code\n");
+            flags |= TJ.FLAG_FASTUPSAMPLE;
+          } else if (argv[i].equalsIgnoreCase("-fastdct")) {
+            System.out.println("Using fastest DCT/IDCT algorithm\n");
+            flags |= TJ.FLAG_FASTDCT;
+          } else if (argv[i].equalsIgnoreCase("-accuratedct")) {
+            System.out.println("Using most accurate DCT/IDCT algorithm\n");
+            flags |= TJ.FLAG_ACCURATEDCT;
+          } else if (argv[i].equalsIgnoreCase("-progressive")) {
+            System.out.println("Using progressive entropy coding\n");
+            flags |= TJ.FLAG_PROGRESSIVE;
+          } else if (argv[i].equalsIgnoreCase("-rgb"))
+            pf = TJ.PF_RGB;
+          else if (argv[i].equalsIgnoreCase("-rgbx"))
+            pf = TJ.PF_RGBX;
+          else if (argv[i].equalsIgnoreCase("-bgr"))
+            pf = TJ.PF_BGR;
+          else if (argv[i].equalsIgnoreCase("-bgrx"))
+            pf = TJ.PF_BGRX;
+          else if (argv[i].equalsIgnoreCase("-xbgr"))
+            pf = TJ.PF_XBGR;
+          else if (argv[i].equalsIgnoreCase("-xrgb"))
+            pf = TJ.PF_XRGB;
+          else if (argv[i].equalsIgnoreCase("-bottomup"))
+            flags |= TJ.FLAG_BOTTOMUP;
+          else if (argv[i].equalsIgnoreCase("-quiet"))
+            quiet = 1;
+          else if (argv[i].equalsIgnoreCase("-qq"))
+            quiet = 2;
+          else if (argv[i].equalsIgnoreCase("-scale") && i < argv.length - 1) {
+            int temp1 = 0, temp2 = 0;
+            boolean match = false, scanned = true;
+            Scanner scanner = new Scanner(argv[++i]).useDelimiter("/");
+
+            try {
+              temp1 = scanner.nextInt();
+              temp2 = scanner.nextInt();
+            } catch (Exception e) {}
+            if (temp2 <= 0) temp2 = 1;
+            if (temp1 > 0) {
+              TJScalingFactor[] scalingFactors = TJ.getScalingFactors();
+
+              for (int j = 0; j < scalingFactors.length; j++) {
+                if ((double)temp1 / (double)temp2 ==
+                    (double)scalingFactors[j].getNum() /
+                    (double)scalingFactors[j].getDenom()) {
+                  sf = scalingFactors[j];
+                  match = true;  break;
+                }
+              }
+              if (!match) usage();
+            } else
+              usage();
+          } else if (argv[i].equalsIgnoreCase("-hflip"))
+            xformOp = TJTransform.OP_HFLIP;
+          else if (argv[i].equalsIgnoreCase("-vflip"))
+            xformOp = TJTransform.OP_VFLIP;
+          else if (argv[i].equalsIgnoreCase("-transpose"))
+            xformOp = TJTransform.OP_TRANSPOSE;
+          else if (argv[i].equalsIgnoreCase("-transverse"))
+            xformOp = TJTransform.OP_TRANSVERSE;
+          else if (argv[i].equalsIgnoreCase("-rot90"))
+            xformOp = TJTransform.OP_ROT90;
+          else if (argv[i].equalsIgnoreCase("-rot180"))
+            xformOp = TJTransform.OP_ROT180;
+          else if (argv[i].equalsIgnoreCase("-rot270"))
+            xformOp = TJTransform.OP_ROT270;
+          else if (argv[i].equalsIgnoreCase("-grayscale"))
+            xformOpt |= TJTransform.OPT_GRAY;
+          else if (argv[i].equalsIgnoreCase("-nooutput"))
+            xformOpt |= TJTransform.OPT_NOOUTPUT;
+          else if (argv[i].equalsIgnoreCase("-copynone"))
+            xformOpt |= TJTransform.OPT_COPYNONE;
+          else if (argv[i].equalsIgnoreCase("-benchtime") &&
+                   i < argv.length - 1) {
+            double temp = -1;
+
+            try {
+              temp = Double.parseDouble(argv[++i]);
+            } catch (NumberFormatException e) {}
+            if (temp > 0.0)
+              benchTime = temp;
+            else
+              usage();
+          } else if (argv[i].equalsIgnoreCase("-warmup") &&
+                     i < argv.length - 1) {
+            double temp = -1;
+
+            try {
+              temp = Double.parseDouble(argv[++i]);
+            } catch (NumberFormatException e) {}
+            if (temp >= 0.0) {
+              warmup = temp;
+              System.out.format("Warmup time = %.1f seconds\n\n", warmup);
+            } else
+              usage();
+          } else if (argv[i].equalsIgnoreCase("-yuv")) {
+            System.out.println("Testing YUV planar encoding/decoding\n");
+            doYUV = true;
+          } else if (argv[i].equalsIgnoreCase("-yuvpad") &&
+                     i < argv.length - 1) {
+            int temp = 0;
+
+            try {
+              temp = Integer.parseInt(argv[++i]);
+            } catch (NumberFormatException e) {}
+            if (temp >= 1)
+              yuvPad = temp;
+          } else if (argv[i].equalsIgnoreCase("-subsamp") &&
+                     i < argv.length - 1) {
+            i++;
+            if (argv[i].toUpperCase().startsWith("G"))
+              subsamp = TJ.SAMP_GRAY;
+            else if (argv[i].equals("444"))
+              subsamp = TJ.SAMP_444;
+            else if (argv[i].equals("422"))
+              subsamp = TJ.SAMP_422;
+            else if (argv[i].equals("440"))
+              subsamp = TJ.SAMP_440;
+            else if (argv[i].equals("420"))
+              subsamp = TJ.SAMP_420;
+            else if (argv[i].equals("411"))
+              subsamp = TJ.SAMP_411;
+          } else if (argv[i].equalsIgnoreCase("-componly"))
+            compOnly = true;
+          else if (argv[i].equalsIgnoreCase("-nowrite"))
+            write = false;
+          else if (argv[i].equalsIgnoreCase("-stoponwarning"))
+            flags |= TJ.FLAG_STOPONWARNING;
+          else usage();
+        }
+      }
+
+      if (sf == null)
+        sf = new TJScalingFactor(1, 1);
+
+      if ((sf.getNum() != 1 || sf.getDenom() != 1) && doTile) {
+        System.out.println("Disabling tiled compression/decompression tests, because those tests do not");
+        System.out.println("work when scaled decompression is enabled.");
+        doTile = false;
+      }
+
+      if (!decompOnly) {
+        int[] width = new int[1], height = new int[1];
+
+        srcBuf = loadImage(argv[0], width, height, pf);
+        w = width[0];  h = height[0];
+        int index = -1;
+        if ((index = argv[0].lastIndexOf('.')) >= 0)
+          argv[0] = argv[0].substring(0, index);
+      }
+
+      if (quiet == 1 && !decompOnly) {
+        System.out.println("All performance values in Mpixels/sec\n");
+        System.out.format("Bitmap     JPEG     JPEG  %s  %s   ",
+                          (doTile ? "Tile " : "Image"),
+                          (doTile ? "Tile " : "Image"));
+        if (doYUV)
+          System.out.print("Encode  ");
+        System.out.print("Comp    Comp    Decomp  ");
+        if (doYUV)
+          System.out.print("Decode");
+        System.out.print("\n");
+        System.out.print("Format     Subsamp  Qual  Width  Height  ");
+        if (doYUV)
+          System.out.print("Perf    ");
+        System.out.print("Perf    Ratio   Perf    ");
+        if (doYUV)
+          System.out.print("Perf");
+        System.out.println("\n");
+      }
+
+      if (decompOnly) {
+        decompTest(argv[0]);
+        System.out.println("");
+        System.exit(retval);
+      }
+
+      System.gc();
+      if (subsamp >= 0 && subsamp < TJ.NUMSAMP) {
+        for (int i = maxQual; i >= minQual; i--)
+          fullTest(srcBuf, w, h, subsamp, i, argv[0]);
+        System.out.println("");
+      } else {
+        for (int i = maxQual; i >= minQual; i--)
+          fullTest(srcBuf, w, h, TJ.SAMP_GRAY, i, argv[0]);
+        System.out.println("");
+        System.gc();
+        for (int i = maxQual; i >= minQual; i--)
+          fullTest(srcBuf, w, h, TJ.SAMP_420, i, argv[0]);
+        System.out.println("");
+        System.gc();
+        for (int i = maxQual; i >= minQual; i--)
+          fullTest(srcBuf, w, h, TJ.SAMP_422, i, argv[0]);
+        System.out.println("");
+        System.gc();
+        for (int i = maxQual; i >= minQual; i--)
+          fullTest(srcBuf, w, h, TJ.SAMP_444, i, argv[0]);
+        System.out.println("");
+      }
+
+    } catch (Exception e) {
+      if (e instanceof TJException) {
+        TJException tje = (TJException)e;
+
+        System.out.println((tje.getErrorCode() == TJ.ERR_WARNING ?
+                            "WARNING: " : "ERROR: ") + tje.getMessage());
+      } else
+        System.out.println("ERROR: " + e.getMessage());
+      e.printStackTrace();
+      retval = -1;
+    }
+
+    System.exit(retval);
+  }
+
+}
diff --git a/3rdparty/libjpeg/src/java/TJExample.java b/3rdparty/libjpeg/src/java/TJExample.java
new file mode 100644
index 00000000..78598869
--- /dev/null
+++ b/3rdparty/libjpeg/src/java/TJExample.java
@@ -0,0 +1,405 @@
+/*
+ * Copyright (C)2011-2012, 2014-2015, 2017-2018 D. R. Commander.
+ *                                              All Rights Reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright notice,
+ *   this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright notice,
+ *   this list of conditions and the following disclaimer in the documentation
+ *   and/or other materials provided with the distribution.
+ * - Neither the name of the libjpeg-turbo Project nor the names of its
+ *   contributors may be used to endorse or promote products derived from this
+ *   software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE 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 HOLDERS 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.
+ */
+
+/*
+ * This program demonstrates how to compress, decompress, and transform JPEG
+ * images using the TurboJPEG Java API
+ */
+
+import java.io.*;
+import java.awt.*;
+import java.awt.image.*;
+import java.nio.*;
+import javax.imageio.*;
+import javax.swing.*;
+import org.libjpegturbo.turbojpeg.*;
+
+
+@SuppressWarnings("checkstyle:JavadocType")
+class TJExample implements TJCustomFilter {
+
+  static final String CLASS_NAME =
+    new TJExample().getClass().getName();
+
+  static final int DEFAULT_SUBSAMP = TJ.SAMP_444;
+  static final int DEFAULT_QUALITY = 95;
+
+
+  static final String[] SUBSAMP_NAME = {
+    "4:4:4", "4:2:2", "4:2:0", "Grayscale", "4:4:0", "4:1:1"
+  };
+
+  static final String[] COLORSPACE_NAME = {
+    "RGB", "YCbCr", "GRAY", "CMYK", "YCCK"
+  };
+
+
+  /* DCT filter example.  This produces a negative of the image. */
+
+  @SuppressWarnings("checkstyle:JavadocMethod")
+  public void customFilter(ShortBuffer coeffBuffer, Rectangle bufferRegion,
+                           Rectangle planeRegion, int componentIndex,
+                           int transformIndex, TJTransform transform)
+                           throws TJException {
+    for (int i = 0; i < bufferRegion.width * bufferRegion.height; i++) {
+      coeffBuffer.put(i, (short)(-coeffBuffer.get(i)));
+    }
+  }
+
+
+  static void usage() throws Exception {
+    System.out.println("\nUSAGE: java [Java options] " + CLASS_NAME +
+                       " <Input image> <Output image> [options]\n");
+
+    System.out.println("Input and output images can be in any image format that the Java Image I/O");
+    System.out.println("extensions understand.  If either filename ends in a .jpg extension, then");
+    System.out.println("the TurboJPEG API will be used to compress or decompress the image.\n");
+
+    System.out.println("Compression Options (used if the output image is a JPEG image)");
+    System.out.println("--------------------------------------------------------------\n");
+
+    System.out.println("-subsamp <444|422|420|gray> = Apply this level of chrominance subsampling when");
+    System.out.println("     compressing the output image.  The default is to use the same level of");
+    System.out.println("     subsampling as in the input image, if the input image is also a JPEG");
+    System.out.println("     image, or to use grayscale if the input image is a grayscale non-JPEG");
+    System.out.println("     image, or to use " +
+                       SUBSAMP_NAME[DEFAULT_SUBSAMP] +
+                       " subsampling otherwise.\n");
+
+    System.out.println("-q <1-100> = Compress the output image with this JPEG quality level");
+    System.out.println("     (default = " + DEFAULT_QUALITY + ").\n");
+
+    System.out.println("Decompression Options (used if the input image is a JPEG image)");
+    System.out.println("---------------------------------------------------------------\n");
+
+    System.out.println("-scale M/N = Scale the input image by a factor of M/N when decompressing it.");
+    System.out.print("(M/N = ");
+    for (int i = 0; i < SCALING_FACTORS.length; i++) {
+      System.out.print(SCALING_FACTORS[i].getNum() + "/" +
+                       SCALING_FACTORS[i].getDenom());
+      if (SCALING_FACTORS.length == 2 && i != SCALING_FACTORS.length - 1)
+        System.out.print(" or ");
+      else if (SCALING_FACTORS.length > 2) {
+        if (i != SCALING_FACTORS.length - 1)
+          System.out.print(", ");
+        if (i == SCALING_FACTORS.length - 2)
+          System.out.print("or ");
+      }
+    }
+    System.out.println(")\n");
+
+    System.out.println("-hflip, -vflip, -transpose, -transverse, -rot90, -rot180, -rot270 =");
+    System.out.println("     Perform one of these lossless transform operations on the input image");
+    System.out.println("     prior to decompressing it (these options are mutually exclusive.)\n");
+
+    System.out.println("-grayscale = Perform lossless grayscale conversion on the input image prior");
+    System.out.println("     to decompressing it (can be combined with the other transform operations");
+    System.out.println("     above.)\n");
+
+    System.out.println("-crop WxH+X+Y = Perform lossless cropping on the input image prior to");
+    System.out.println("     decompressing it.  X and Y specify the upper left corner of the cropping");
+    System.out.println("     region, and W and H specify the width and height of the cropping region.");
+    System.out.println("     X and Y must be evenly divible by the MCU block size (8x8 if the input");
+    System.out.println("     image was compressed using no subsampling or grayscale, 16x8 if it was");
+    System.out.println("     compressed using 4:2:2 subsampling, or 16x16 if it was compressed using");
+    System.out.println("     4:2:0 subsampling.)\n");
+
+    System.out.println("General Options");
+    System.out.println("---------------\n");
+
+    System.out.println("-display = Display output image (Output filename need not be specified in this");
+    System.out.println("     case.)\n");
+
+    System.out.println("-fastupsample = Use the fastest chrominance upsampling algorithm available in");
+    System.out.println("     the underlying codec.\n");
+
+    System.out.println("-fastdct = Use the fastest DCT/IDCT algorithms available in the underlying");
+    System.out.println("     codec.\n");
+
+    System.out.println("-accuratedct = Use the most accurate DCT/IDCT algorithms available in the");
+    System.out.println("     underlying codec.\n");
+
+    System.exit(1);
+  }
+
+
+  public static void main(String[] argv) {
+
+    try {
+
+      TJScalingFactor scalingFactor = new TJScalingFactor(1, 1);
+      int outSubsamp = -1, outQual = -1;
+      TJTransform xform = new TJTransform();
+      boolean display = false;
+      int flags = 0;
+      int width, height;
+      String inFormat = "jpg", outFormat = "jpg";
+      BufferedImage img = null;
+      byte[] imgBuf = null;
+
+      if (argv.length < 2)
+        usage();
+
+      if (argv[1].substring(0, 2).equalsIgnoreCase("-d"))
+        display = true;
+
+      /* Parse arguments. */
+      for (int i = 2; i < argv.length; i++) {
+        if (argv[i].length() < 2)
+          continue;
+        else if (argv[i].length() > 2 &&
+                 argv[i].substring(0, 3).equalsIgnoreCase("-sc") &&
+                 i < argv.length - 1) {
+          int match = 0;
+          String[] scaleArg = argv[++i].split("/");
+          if (scaleArg.length == 2) {
+            TJScalingFactor tempsf =
+              new TJScalingFactor(Integer.parseInt(scaleArg[0]),
+                                  Integer.parseInt(scaleArg[1]));
+            for (int j = 0; j < SCALING_FACTORS.length; j++) {
+              if (tempsf.equals(SCALING_FACTORS[j])) {
+                scalingFactor = SCALING_FACTORS[j];
+                match = 1;
+                break;
+              }
+            }
+          }
+          if (match != 1)
+            usage();
+        } else if (argv[i].length() > 2 &&
+                   argv[i].substring(0, 3).equalsIgnoreCase("-su") &&
+                   i < argv.length - 1) {
+          i++;
+          if (argv[i].substring(0, 1).equalsIgnoreCase("g"))
+            outSubsamp = TJ.SAMP_GRAY;
+          else if (argv[i].equals("444"))
+            outSubsamp = TJ.SAMP_444;
+          else if (argv[i].equals("422"))
+            outSubsamp = TJ.SAMP_422;
+          else if (argv[i].equals("420"))
+            outSubsamp = TJ.SAMP_420;
+          else
+            usage();
+        } else if (argv[i].substring(0, 2).equalsIgnoreCase("-q") &&
+                   i < argv.length - 1) {
+          outQual = Integer.parseInt(argv[++i]);
+          if (outQual < 1 || outQual > 100)
+            usage();
+        } else if (argv[i].substring(0, 2).equalsIgnoreCase("-g"))
+          xform.options |= TJTransform.OPT_GRAY;
+        else if (argv[i].equalsIgnoreCase("-hflip"))
+          xform.op = TJTransform.OP_HFLIP;
+        else if (argv[i].equalsIgnoreCase("-vflip"))
+          xform.op = TJTransform.OP_VFLIP;
+        else if (argv[i].equalsIgnoreCase("-transpose"))
+          xform.op = TJTransform.OP_TRANSPOSE;
+        else if (argv[i].equalsIgnoreCase("-transverse"))
+          xform.op = TJTransform.OP_TRANSVERSE;
+        else if (argv[i].equalsIgnoreCase("-rot90"))
+          xform.op = TJTransform.OP_ROT90;
+        else if (argv[i].equalsIgnoreCase("-rot180"))
+          xform.op = TJTransform.OP_ROT180;
+        else if (argv[i].equalsIgnoreCase("-rot270"))
+          xform.op = TJTransform.OP_ROT270;
+        else if (argv[i].equalsIgnoreCase("-custom"))
+          xform.cf = new TJExample();
+        else if (argv[i].length() > 2 &&
+                 argv[i].substring(0, 2).equalsIgnoreCase("-c") &&
+                 i < argv.length - 1) {
+          String[] cropArg = argv[++i].split("[x\\+]");
+          if (cropArg.length != 4)
+            usage();
+          xform.width = Integer.parseInt(cropArg[0]);
+          xform.height = Integer.parseInt(cropArg[1]);
+          xform.x = Integer.parseInt(cropArg[2]);
+          xform.y = Integer.parseInt(cropArg[3]);
+          if (xform.x < 0 || xform.y < 0 || xform.width < 1 ||
+              xform.height < 1)
+            usage();
+          xform.options |= TJTransform.OPT_CROP;
+        } else if (argv[i].substring(0, 2).equalsIgnoreCase("-d"))
+          display = true;
+        else if (argv[i].equalsIgnoreCase("-fastupsample")) {
+          System.out.println("Using fast upsampling code");
+          flags |= TJ.FLAG_FASTUPSAMPLE;
+        } else if (argv[i].equalsIgnoreCase("-fastdct")) {
+          System.out.println("Using fastest DCT/IDCT algorithm");
+          flags |= TJ.FLAG_FASTDCT;
+        } else if (argv[i].equalsIgnoreCase("-accuratedct")) {
+          System.out.println("Using most accurate DCT/IDCT algorithm");
+          flags |= TJ.FLAG_ACCURATEDCT;
+        } else usage();
+      }
+
+      /* Determine input and output image formats based on file extensions. */
+      String[] inFileTokens = argv[0].split("\\.");
+      if (inFileTokens.length > 1)
+        inFormat = inFileTokens[inFileTokens.length - 1];
+      String[] outFileTokens;
+      if (display)
+        outFormat = "bmp";
+      else {
+        outFileTokens = argv[1].split("\\.");
+        if (outFileTokens.length > 1)
+          outFormat = outFileTokens[outFileTokens.length - 1];
+      }
+
+      if (inFormat.equalsIgnoreCase("jpg")) {
+        /* Input image is a JPEG image.  Decompress and/or transform it. */
+        boolean doTransform = (xform.op != TJTransform.OP_NONE ||
+                               xform.options != 0 || xform.cf != null);
+
+        /* Read the JPEG file into memory. */
+        File jpegFile = new File(argv[0]);
+        FileInputStream fis = new FileInputStream(jpegFile);
+        int jpegSize = fis.available();
+        if (jpegSize < 1) {
+          System.out.println("Input file contains no data");
+          System.exit(1);
+        }
+        byte[] jpegBuf = new byte[jpegSize];
+        fis.read(jpegBuf);
+        fis.close();
+
+        TJDecompressor tjd;
+        if (doTransform) {
+          /* Transform it. */
+          TJTransformer tjt = new TJTransformer(jpegBuf);
+          TJTransform[] xforms = new TJTransform[1];
+          xforms[0] = xform;
+          xforms[0].options |= TJTransform.OPT_TRIM;
+          TJDecompressor[] tjds = tjt.transform(xforms, 0);
+          tjd = tjds[0];
+          tjt.close();
+        } else
+          tjd = new TJDecompressor(jpegBuf);
+
+        width = tjd.getWidth();
+        height = tjd.getHeight();
+        int inSubsamp = tjd.getSubsamp();
+        int inColorspace = tjd.getColorspace();
+
+        System.out.println((doTransform ? "Transformed" : "Input") +
+                           " Image (jpg):  " + width + " x " + height +
+                           " pixels, " + SUBSAMP_NAME[inSubsamp] +
+                           " subsampling, " + COLORSPACE_NAME[inColorspace]);
+
+        if (outFormat.equalsIgnoreCase("jpg") && doTransform &&
+            scalingFactor.isOne() && outSubsamp < 0 && outQual < 0) {
+          /* Input image has been transformed, and no re-compression options
+             have been selected.  Write the transformed image to disk and
+             exit. */
+          File outFile = new File(argv[1]);
+          FileOutputStream fos = new FileOutputStream(outFile);
+          fos.write(tjd.getJPEGBuf(), 0, tjd.getJPEGSize());
+          fos.close();
+          System.exit(0);
+        }
+
+        /* Scaling and/or a non-JPEG output image format and/or compression
+           options have been selected, so we need to decompress the
+           input/transformed image. */
+        width = scalingFactor.getScaled(width);
+        height = scalingFactor.getScaled(height);
+        if (outSubsamp < 0)
+          outSubsamp = inSubsamp;
+
+        if (!outFormat.equalsIgnoreCase("jpg"))
+          img = tjd.decompress(width, height, BufferedImage.TYPE_INT_RGB,
+                               flags);
+        else
+          imgBuf = tjd.decompress(width, 0, height, TJ.PF_BGRX, flags);
+        tjd.close();
+      } else {
+        /* Input image is not a JPEG image.  Load it into memory. */
+        img = ImageIO.read(new File(argv[0]));
+        if (img == null)
+          throw new Exception("Input image type not supported.");
+        width = img.getWidth();
+        height = img.getHeight();
+        if (outSubsamp < 0) {
+          if (img.getType() == BufferedImage.TYPE_BYTE_GRAY)
+            outSubsamp = TJ.SAMP_GRAY;
+          else
+            outSubsamp = DEFAULT_SUBSAMP;
+        }
+        System.out.println("Input Image:  " + width + " x " + height +
+                           " pixels");
+      }
+      System.gc();
+      if (!display)
+        System.out.print("Output Image (" + outFormat + "):  " + width +
+                         " x " + height + " pixels");
+
+      if (display) {
+        /* Display the uncompressed image */
+        ImageIcon icon = new ImageIcon(img);
+        JLabel label = new JLabel(icon, JLabel.CENTER);
+        JOptionPane.showMessageDialog(null, label, "Output Image",
+                                      JOptionPane.PLAIN_MESSAGE);
+      } else if (outFormat.equalsIgnoreCase("jpg")) {
+        /* Output image format is JPEG.  Compress the uncompressed image. */
+        if (outQual < 0)
+          outQual = DEFAULT_QUALITY;
+        System.out.println(", " + SUBSAMP_NAME[outSubsamp] +
+                           " subsampling, quality = " + outQual);
+
+        TJCompressor tjc = new TJCompressor();
+        tjc.setSubsamp(outSubsamp);
+        tjc.setJPEGQuality(outQual);
+        if (img != null)
+          tjc.setSourceImage(img, 0, 0, 0, 0);
+        else
+          tjc.setSourceImage(imgBuf, 0, 0, width, 0, height, TJ.PF_BGRX);
+        byte[] jpegBuf = tjc.compress(flags);
+        int jpegSize = tjc.getCompressedSize();
+        tjc.close();
+
+        /* Write the JPEG image to disk. */
+        File outFile = new File(argv[1]);
+        FileOutputStream fos = new FileOutputStream(outFile);
+        fos.write(jpegBuf, 0, jpegSize);
+        fos.close();
+      } else {
+        /* Output image format is not JPEG.  Save the uncompressed image
+           directly to disk. */
+        System.out.print("\n");
+        File outFile = new File(argv[1]);
+        ImageIO.write(img, outFormat, outFile);
+      }
+
+    } catch (Exception e) {
+      e.printStackTrace();
+      System.exit(-1);
+    }
+  }
+
+  static final TJScalingFactor[] SCALING_FACTORS =
+    TJ.getScalingFactors();
+};
diff --git a/3rdparty/libjpeg/src/java/TJUnitTest.java b/3rdparty/libjpeg/src/java/TJUnitTest.java
new file mode 100644
index 00000000..91ad5fd9
--- /dev/null
+++ b/3rdparty/libjpeg/src/java/TJUnitTest.java
@@ -0,0 +1,960 @@
+/*
+ * Copyright (C)2011-2018 D. R. Commander.  All Rights Reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright notice,
+ *   this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright notice,
+ *   this list of conditions and the following disclaimer in the documentation
+ *   and/or other materials provided with the distribution.
+ * - Neither the name of the libjpeg-turbo Project nor the names of its
+ *   contributors may be used to endorse or promote products derived from this
+ *   software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE 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 HOLDERS 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.
+ */
+
+/*
+ * This program tests the various code paths in the TurboJPEG JNI Wrapper
+ */
+
+import java.io.*;
+import java.util.*;
+import java.awt.image.*;
+import javax.imageio.*;
+import java.nio.*;
+import org.libjpegturbo.turbojpeg.*;
+
+@SuppressWarnings("checkstyle:JavadocType")
+final class TJUnitTest {
+
+  private TJUnitTest() {}
+
+  static final String CLASS_NAME =
+    new TJUnitTest().getClass().getName();
+
+  static void usage() {
+    System.out.println("\nUSAGE: java " + CLASS_NAME + " [options]\n");
+    System.out.println("Options:");
+    System.out.println("-yuv = test YUV encoding/decoding support");
+    System.out.println("-noyuvpad = do not pad each line of each Y, U, and V plane to the nearest");
+    System.out.println("            4-byte boundary");
+    System.out.println("-bi = test BufferedImage support\n");
+    System.exit(1);
+  }
+
+  static final String[] SUBNAME_LONG = {
+    "4:4:4", "4:2:2", "4:2:0", "GRAY", "4:4:0", "4:1:1"
+  };
+  static final String[] SUBNAME = {
+    "444", "422", "420", "GRAY", "440", "411"
+  };
+
+  static final String[] PIXFORMATSTR = {
+    "RGB", "BGR", "RGBX", "BGRX", "XBGR", "XRGB", "Grayscale",
+    "RGBA", "BGRA", "ABGR", "ARGB", "CMYK"
+  };
+
+  static final int[] FORMATS_3BYTE = {
+    TJ.PF_RGB, TJ.PF_BGR
+  };
+  static final int[] FORMATS_3BYTEBI = {
+    BufferedImage.TYPE_3BYTE_BGR
+  };
+  static final int[] FORMATS_4BYTE = {
+    TJ.PF_RGBX, TJ.PF_BGRX, TJ.PF_XBGR, TJ.PF_XRGB, TJ.PF_CMYK
+  };
+  static final int[] FORMATS_4BYTEBI = {
+    BufferedImage.TYPE_INT_BGR, BufferedImage.TYPE_INT_RGB,
+    BufferedImage.TYPE_4BYTE_ABGR, BufferedImage.TYPE_4BYTE_ABGR_PRE,
+    BufferedImage.TYPE_INT_ARGB, BufferedImage.TYPE_INT_ARGB_PRE
+  };
+  static final int[] FORMATS_GRAY = {
+    TJ.PF_GRAY
+  };
+  static final int[] FORMATS_GRAYBI = {
+    BufferedImage.TYPE_BYTE_GRAY
+  };
+  static final int[] FORMATS_RGB = {
+    TJ.PF_RGB
+  };
+
+  private static boolean doYUV = false;
+  private static int pad = 4;
+  private static boolean bi = false;
+
+  private static int exitStatus = 0;
+
+  static int biTypePF(int biType) {
+    ByteOrder byteOrder = ByteOrder.nativeOrder();
+    switch (biType) {
+    case BufferedImage.TYPE_3BYTE_BGR:
+      return TJ.PF_BGR;
+    case BufferedImage.TYPE_4BYTE_ABGR:
+    case BufferedImage.TYPE_4BYTE_ABGR_PRE:
+      return TJ.PF_ABGR;
+    case BufferedImage.TYPE_BYTE_GRAY:
+      return TJ.PF_GRAY;
+    case BufferedImage.TYPE_INT_BGR:
+      return TJ.PF_RGBX;
+    case BufferedImage.TYPE_INT_RGB:
+      return TJ.PF_BGRX;
+    case BufferedImage.TYPE_INT_ARGB:
+    case BufferedImage.TYPE_INT_ARGB_PRE:
+      return TJ.PF_BGRA;
+    default:
+      return 0;
+    }
+  }
+
+  static String biTypeStr(int biType) {
+    switch (biType) {
+    case BufferedImage.TYPE_3BYTE_BGR:
+      return "3BYTE_BGR";
+    case BufferedImage.TYPE_4BYTE_ABGR:
+      return "4BYTE_ABGR";
+    case BufferedImage.TYPE_4BYTE_ABGR_PRE:
+      return "4BYTE_ABGR_PRE";
+    case BufferedImage.TYPE_BYTE_GRAY:
+      return "BYTE_GRAY";
+    case BufferedImage.TYPE_INT_BGR:
+      return "INT_BGR";
+    case BufferedImage.TYPE_INT_RGB:
+      return "INT_RGB";
+    case BufferedImage.TYPE_INT_ARGB:
+      return "INT_ARGB";
+    case BufferedImage.TYPE_INT_ARGB_PRE:
+      return "INT_ARGB_PRE";
+    default:
+      return "Unknown";
+    }
+  }
+
+  static void initBuf(byte[] buf, int w, int pitch, int h, int pf, int flags)
+                      throws Exception {
+    int roffset = TJ.getRedOffset(pf);
+    int goffset = TJ.getGreenOffset(pf);
+    int boffset = TJ.getBlueOffset(pf);
+    int aoffset = TJ.getAlphaOffset(pf);
+    int ps = TJ.getPixelSize(pf);
+    int index, row, col, halfway = 16;
+
+    if (pf == TJ.PF_GRAY) {
+      Arrays.fill(buf, (byte)0);
+      for (row = 0; row < h; row++) {
+        for (col = 0; col < w; col++) {
+          if ((flags & TJ.FLAG_BOTTOMUP) != 0)
+            index = pitch * (h - row - 1) + col;
+          else
+            index = pitch * row + col;
+          if (((row / 8) + (col / 8)) % 2 == 0)
+            buf[index] = (row < halfway) ? (byte)255 : 0;
+          else
+            buf[index] = (row < halfway) ? 76 : (byte)226;
+        }
+      }
+      return;
+    }
+    if (pf == TJ.PF_CMYK) {
+      Arrays.fill(buf, (byte)255);
+      for (row = 0; row < h; row++) {
+        for (col = 0; col < w; col++) {
+          if ((flags & TJ.FLAG_BOTTOMUP) != 0)
+            index = (h - row - 1) * w + col;
+          else
+            index = row * w + col;
+          if (((row / 8) + (col / 8)) % 2 == 0) {
+            if (row >= halfway) buf[index * ps + 3] = 0;
+          } else {
+            buf[index * ps + 2] = 0;
+            if (row < halfway)
+              buf[index * ps + 1] = 0;
+          }
+        }
+      }
+      return;
+    }
+
+    Arrays.fill(buf, (byte)0);
+    for (row = 0; row < h; row++) {
+      for (col = 0; col < w; col++) {
+        if ((flags & TJ.FLAG_BOTTOMUP) != 0)
+          index = pitch * (h - row - 1) + col * ps;
+        else
+          index = pitch * row + col * ps;
+        if (((row / 8) + (col / 8)) % 2 == 0) {
+          if (row < halfway) {
+            buf[index + roffset] = (byte)255;
+            buf[index + goffset] = (byte)255;
+            buf[index + boffset] = (byte)255;
+          }
+        } else {
+          buf[index + roffset] = (byte)255;
+          if (row >= halfway)
+            buf[index + goffset] = (byte)255;
+        }
+        if (aoffset >= 0)
+          buf[index + aoffset] = (byte)255;
+      }
+    }
+  }
+
+  static void initIntBuf(int[] buf, int w, int pitch, int h, int pf, int flags)
+                         throws Exception {
+    int rshift = TJ.getRedOffset(pf) * 8;
+    int gshift = TJ.getGreenOffset(pf) * 8;
+    int bshift = TJ.getBlueOffset(pf) * 8;
+    int ashift = TJ.getAlphaOffset(pf) * 8;
+    int index, row, col, halfway = 16;
+
+    Arrays.fill(buf, 0);
+    for (row = 0; row < h; row++) {
+      for (col = 0; col < w; col++) {
+        if ((flags & TJ.FLAG_BOTTOMUP) != 0)
+          index = pitch * (h - row - 1) + col;
+        else
+          index = pitch * row + col;
+        if (((row / 8) + (col / 8)) % 2 == 0) {
+          if (row < halfway) {
+            buf[index] |= (255 << rshift);
+            buf[index] |= (255 << gshift);
+            buf[index] |= (255 << bshift);
+          }
+        } else {
+          buf[index] |= (255 << rshift);
+          if (row >= halfway)
+            buf[index] |= (255 << gshift);
+        }
+        if (ashift >= 0)
+          buf[index] |= (255 << ashift);
+      }
+    }
+  }
+
+  static void initImg(BufferedImage img, int pf, int flags) throws Exception {
+    WritableRaster wr = img.getRaster();
+    int imgType = img.getType();
+
+    if (imgType == BufferedImage.TYPE_INT_RGB ||
+        imgType == BufferedImage.TYPE_INT_BGR ||
+        imgType == BufferedImage.TYPE_INT_ARGB ||
+        imgType == BufferedImage.TYPE_INT_ARGB_PRE) {
+      SinglePixelPackedSampleModel sm =
+        (SinglePixelPackedSampleModel)img.getSampleModel();
+      int pitch = sm.getScanlineStride();
+      DataBufferInt db = (DataBufferInt)wr.getDataBuffer();
+      int[] buf = db.getData();
+      initIntBuf(buf, img.getWidth(), pitch, img.getHeight(), pf, flags);
+    } else {
+      ComponentSampleModel sm = (ComponentSampleModel)img.getSampleModel();
+      int pitch = sm.getScanlineStride();
+      DataBufferByte db = (DataBufferByte)wr.getDataBuffer();
+      byte[] buf = db.getData();
+      initBuf(buf, img.getWidth(), pitch, img.getHeight(), pf, flags);
+    }
+  }
+
+  static void checkVal(int row, int col, int v, String vname, int cv)
+                       throws Exception {
+    v = (v < 0) ? v + 256 : v;
+    if (v < cv - 1 || v > cv + 1) {
+      throw new Exception("Comp. " + vname + " at " + row + "," + col +
+                          " should be " + cv + ", not " + v);
+    }
+  }
+
+  static void checkVal0(int row, int col, int v, String vname)
+                        throws Exception {
+    v = (v < 0) ? v + 256 : v;
+    if (v > 1) {
+      throw new Exception("Comp. " + vname + " at " + row + "," + col +
+                          " should be 0, not " + v);
+    }
+  }
+
+  static void checkVal255(int row, int col, int v, String vname)
+                          throws Exception {
+    v = (v < 0) ? v + 256 : v;
+    if (v < 254) {
+      throw new Exception("Comp. " + vname + " at " + row + "," + col +
+                          " should be 255, not " + v);
+    }
+  }
+
+  static int checkBuf(byte[] buf, int w, int pitch, int h, int pf, int subsamp,
+                      TJScalingFactor sf, int flags) throws Exception {
+    int roffset = TJ.getRedOffset(pf);
+    int goffset = TJ.getGreenOffset(pf);
+    int boffset = TJ.getBlueOffset(pf);
+    int aoffset = TJ.getAlphaOffset(pf);
+    int ps = TJ.getPixelSize(pf);
+    int index, row, col, retval = 1;
+    int halfway = 16 * sf.getNum() / sf.getDenom();
+    int blockSize = 8 * sf.getNum() / sf.getDenom();
+
+    try {
+
+      if (pf == TJ.PF_GRAY)
+        roffset = goffset = boffset = 0;
+
+      if (pf == TJ.PF_CMYK) {
+        for (row = 0; row < h; row++) {
+          for (col = 0; col < w; col++) {
+            if ((flags & TJ.FLAG_BOTTOMUP) != 0)
+              index = (h - row - 1) * w + col;
+            else
+              index = row * w + col;
+            byte c = buf[index * ps];
+            byte m = buf[index * ps + 1];
+            byte y = buf[index * ps + 2];
+            byte k = buf[index * ps + 3];
+            checkVal255(row, col, c, "C");
+            if (((row / blockSize) + (col / blockSize)) % 2 == 0) {
+              checkVal255(row, col, m, "M");
+              checkVal255(row, col, y, "Y");
+              if (row < halfway)
+                checkVal255(row, col, k, "K");
+              else
+                checkVal0(row, col, k, "K");
+            } else {
+              checkVal0(row, col, y, "Y");
+              checkVal255(row, col, k, "K");
+              if (row < halfway)
+                checkVal0(row, col, m, "M");
+              else
+                checkVal255(row, col, m, "M");
+            }
+          }
+        }
+        return 1;
+      }
+
+      for (row = 0; row < halfway; row++) {
+        for (col = 0; col < w; col++) {
+          if ((flags & TJ.FLAG_BOTTOMUP) != 0)
+            index = pitch * (h - row - 1) + col * ps;
+          else
+            index = pitch * row + col * ps;
+          byte r = buf[index + roffset];
+          byte g = buf[index + goffset];
+          byte b = buf[index + boffset];
+          byte a = aoffset >= 0 ? buf[index + aoffset] : (byte)255;
+          if (((row / blockSize) + (col / blockSize)) % 2 == 0) {
+            if (row < halfway) {
+              checkVal255(row, col, r, "R");
+              checkVal255(row, col, g, "G");
+              checkVal255(row, col, b, "B");
+            } else {
+              checkVal0(row, col, r, "R");
+              checkVal0(row, col, g, "G");
+              checkVal0(row, col, b, "B");
+            }
+          } else {
+            if (subsamp == TJ.SAMP_GRAY) {
+              if (row < halfway) {
+                checkVal(row, col, r, "R", 76);
+                checkVal(row, col, g, "G", 76);
+                checkVal(row, col, b, "B", 76);
+              } else {
+                checkVal(row, col, r, "R", 226);
+                checkVal(row, col, g, "G", 226);
+                checkVal(row, col, b, "B", 226);
+              }
+            } else {
+              checkVal255(row, col, r, "R");
+              if (row < halfway) {
+                checkVal0(row, col, g, "G");
+              } else {
+                checkVal255(row, col, g, "G");
+              }
+              checkVal0(row, col, b, "B");
+            }
+          }
+          checkVal255(row, col, a, "A");
+        }
+      }
+    } catch (Exception e) {
+      System.out.println("\n" + e.getMessage());
+      retval = 0;
+    }
+
+    if (retval == 0) {
+      for (row = 0; row < h; row++) {
+        for (col = 0; col < w; col++) {
+          if (pf == TJ.PF_CMYK) {
+            int c = buf[pitch * row + col * ps];
+            int m = buf[pitch * row + col * ps + 1];
+            int y = buf[pitch * row + col * ps + 2];
+            int k = buf[pitch * row + col * ps + 3];
+            if (c < 0) c += 256;
+            if (m < 0) m += 256;
+            if (y < 0) y += 256;
+            if (k < 0) k += 256;
+            System.out.format("%3d/%3d/%3d/%3d ", c, m, y, k);
+          } else {
+            int r = buf[pitch * row + col * ps + roffset];
+            int g = buf[pitch * row + col * ps + goffset];
+            int b = buf[pitch * row + col * ps + boffset];
+            if (r < 0) r += 256;
+            if (g < 0) g += 256;
+            if (b < 0) b += 256;
+            System.out.format("%3d/%3d/%3d ", r, g, b);
+          }
+        }
+        System.out.print("\n");
+      }
+    }
+    return retval;
+  }
+
+  static int checkIntBuf(int[] buf, int w, int pitch, int h, int pf,
+                         int subsamp, TJScalingFactor sf, int flags)
+                         throws Exception {
+    int rshift = TJ.getRedOffset(pf) * 8;
+    int gshift = TJ.getGreenOffset(pf) * 8;
+    int bshift = TJ.getBlueOffset(pf) * 8;
+    int ashift = TJ.getAlphaOffset(pf) * 8;
+    int index, row, col, retval = 1;
+    int halfway = 16 * sf.getNum() / sf.getDenom();
+    int blockSize = 8 * sf.getNum() / sf.getDenom();
+
+    try {
+      for (row = 0; row < halfway; row++) {
+        for (col = 0; col < w; col++) {
+          if ((flags & TJ.FLAG_BOTTOMUP) != 0)
+            index = pitch * (h - row - 1) + col;
+          else
+            index = pitch * row + col;
+          int r = (buf[index] >> rshift) & 0xFF;
+          int g = (buf[index] >> gshift) & 0xFF;
+          int b = (buf[index] >> bshift) & 0xFF;
+          int a = ashift >= 0 ? (buf[index] >> ashift) & 0xFF : 255;
+          if (((row / blockSize) + (col / blockSize)) % 2 == 0) {
+            if (row < halfway) {
+              checkVal255(row, col, r, "R");
+              checkVal255(row, col, g, "G");
+              checkVal255(row, col, b, "B");
+            } else {
+              checkVal0(row, col, r, "R");
+              checkVal0(row, col, g, "G");
+              checkVal0(row, col, b, "B");
+            }
+          } else {
+            if (subsamp == TJ.SAMP_GRAY) {
+              if (row < halfway) {
+                checkVal(row, col, r, "R", 76);
+                checkVal(row, col, g, "G", 76);
+                checkVal(row, col, b, "B", 76);
+              } else {
+                checkVal(row, col, r, "R", 226);
+                checkVal(row, col, g, "G", 226);
+                checkVal(row, col, b, "B", 226);
+              }
+            } else {
+              checkVal255(row, col, r, "R");
+              if (row < halfway) {
+                checkVal0(row, col, g, "G");
+              } else {
+                checkVal255(row, col, g, "G");
+              }
+              checkVal0(row, col, b, "B");
+            }
+          }
+          checkVal255(row, col, a, "A");
+        }
+      }
+    } catch (Exception e) {
+      System.out.println("\n" + e.getMessage());
+      retval = 0;
+    }
+
+    if (retval == 0) {
+      for (row = 0; row < h; row++) {
+        for (col = 0; col < w; col++) {
+          int r = (buf[pitch * row + col] >> rshift) & 0xFF;
+          int g = (buf[pitch * row + col] >> gshift) & 0xFF;
+          int b = (buf[pitch * row + col] >> bshift) & 0xFF;
+          if (r < 0) r += 256;
+          if (g < 0) g += 256;
+          if (b < 0) b += 256;
+          System.out.format("%3d/%3d/%3d ", r, g, b);
+        }
+        System.out.print("\n");
+      }
+    }
+    return retval;
+  }
+
+  static int checkImg(BufferedImage img, int pf, int subsamp,
+                      TJScalingFactor sf, int flags) throws Exception {
+    WritableRaster wr = img.getRaster();
+    int imgType = img.getType();
+    if (imgType == BufferedImage.TYPE_INT_RGB ||
+        imgType == BufferedImage.TYPE_INT_BGR ||
+        imgType == BufferedImage.TYPE_INT_ARGB ||
+        imgType == BufferedImage.TYPE_INT_ARGB_PRE) {
+      SinglePixelPackedSampleModel sm =
+        (SinglePixelPackedSampleModel)img.getSampleModel();
+      int pitch = sm.getScanlineStride();
+      DataBufferInt db = (DataBufferInt)wr.getDataBuffer();
+      int[] buf = db.getData();
+      return checkIntBuf(buf, img.getWidth(), pitch, img.getHeight(), pf,
+                         subsamp, sf, flags);
+    } else {
+      ComponentSampleModel sm = (ComponentSampleModel)img.getSampleModel();
+      int pitch = sm.getScanlineStride();
+      DataBufferByte db = (DataBufferByte)wr.getDataBuffer();
+      byte[] buf = db.getData();
+      return checkBuf(buf, img.getWidth(), pitch, img.getHeight(), pf, subsamp,
+                      sf, flags);
+    }
+  }
+
+  static int pad(int v, int p) {
+    return ((v + (p) - 1) & (~((p) - 1)));
+  }
+
+  static int checkBufYUV(byte[] buf, int size, int w, int h, int subsamp,
+                         TJScalingFactor sf) throws Exception {
+    int row, col;
+    int hsf = TJ.getMCUWidth(subsamp) / 8, vsf = TJ.getMCUHeight(subsamp) / 8;
+    int pw = pad(w, hsf), ph = pad(h, vsf);
+    int cw = pw / hsf, ch = ph / vsf;
+    int ypitch = pad(pw, pad), uvpitch = pad(cw, pad);
+    int retval = 1;
+    int correctsize = ypitch * ph +
+                      (subsamp == TJ.SAMP_GRAY ? 0 : uvpitch * ch * 2);
+    int halfway = 16 * sf.getNum() / sf.getDenom();
+    int blockSize = 8 * sf.getNum() / sf.getDenom();
+
+    try {
+      if (size != correctsize)
+        throw new Exception("Incorrect size " + size + ".  Should be " +
+                            correctsize);
+
+      for (row = 0; row < ph; row++) {
+        for (col = 0; col < pw; col++) {
+          byte y = buf[ypitch * row + col];
+          if (((row / blockSize) + (col / blockSize)) % 2 == 0) {
+            if (row < halfway)
+              checkVal255(row, col, y, "Y");
+            else
+              checkVal0(row, col, y, "Y");
+          } else {
+            if (row < halfway)
+              checkVal(row, col, y, "Y", 76);
+            else
+              checkVal(row, col, y, "Y", 226);
+          }
+        }
+      }
+      if (subsamp != TJ.SAMP_GRAY) {
+        halfway = 16 / vsf * sf.getNum() / sf.getDenom();
+        for (row = 0; row < ch; row++) {
+          for (col = 0; col < cw; col++) {
+            byte u = buf[ypitch * ph + (uvpitch * row + col)],
+                 v = buf[ypitch * ph + uvpitch * ch + (uvpitch * row + col)];
+            if (((row * vsf / blockSize) + (col * hsf / blockSize)) % 2 == 0) {
+              checkVal(row, col, u, "U", 128);
+              checkVal(row, col, v, "V", 128);
+            } else {
+              if (row < halfway) {
+                checkVal(row, col, u, "U", 85);
+                checkVal255(row, col, v, "V");
+              } else {
+                checkVal0(row, col, u, "U");
+                checkVal(row, col, v, "V", 149);
+              }
+            }
+          }
+        }
+      }
+    } catch (Exception e) {
+      System.out.println("\n" + e.getMessage());
+      retval = 0;
+    }
+
+    if (retval == 0) {
+      for (row = 0; row < ph; row++) {
+        for (col = 0; col < pw; col++) {
+          int y = buf[ypitch * row + col];
+          if (y < 0) y += 256;
+          System.out.format("%3d ", y);
+        }
+        System.out.print("\n");
+      }
+      System.out.print("\n");
+      for (row = 0; row < ch; row++) {
+        for (col = 0; col < cw; col++) {
+          int u = buf[ypitch * ph + (uvpitch * row + col)];
+          if (u < 0) u += 256;
+          System.out.format("%3d ", u);
+        }
+        System.out.print("\n");
+      }
+      System.out.print("\n");
+      for (row = 0; row < ch; row++) {
+        for (col = 0; col < cw; col++) {
+          int v = buf[ypitch * ph + uvpitch * ch + (uvpitch * row + col)];
+          if (v < 0) v += 256;
+          System.out.format("%3d ", v);
+        }
+        System.out.print("\n");
+      }
+    }
+
+    return retval;
+  }
+
+  static void writeJPEG(byte[] jpegBuf, int jpegBufSize, String filename)
+                        throws Exception {
+    File file = new File(filename);
+    FileOutputStream fos = new FileOutputStream(file);
+    fos.write(jpegBuf, 0, jpegBufSize);
+    fos.close();
+  }
+
+  static int compTest(TJCompressor tjc, byte[] dstBuf, int w, int h, int pf,
+                      String baseName, int subsamp, int jpegQual, int flags)
+                      throws Exception {
+    String tempStr;
+    byte[] srcBuf = null;
+    BufferedImage img = null;
+    String pfStr, pfStrLong;
+    String buStr = (flags & TJ.FLAG_BOTTOMUP) != 0 ? "BU" : "TD";
+    String buStrLong = (flags & TJ.FLAG_BOTTOMUP) != 0 ?
+                       "Bottom-Up" : "Top-Down ";
+    int size = 0, ps, imgType = pf;
+
+    if (bi) {
+      pf = biTypePF(imgType);
+      pfStr = biTypeStr(imgType);
+      pfStrLong = pfStr + " (" + PIXFORMATSTR[pf] + ")";
+    } else {
+      pfStr = PIXFORMATSTR[pf];
+      pfStrLong = pfStr;
+    }
+    ps =  TJ.getPixelSize(pf);
+
+    if (bi) {
+      img = new BufferedImage(w, h, imgType);
+      initImg(img, pf, flags);
+      tempStr = baseName + "_enc_" + pfStr + "_" + buStr + "_" +
+                SUBNAME[subsamp] + "_Q" + jpegQual + ".png";
+      File file = new File(tempStr);
+      ImageIO.write(img, "png", file);
+      tjc.setSourceImage(img, 0, 0, 0, 0);
+    } else {
+      srcBuf = new byte[w * h * ps + 1];
+      initBuf(srcBuf, w, w * ps, h, pf, flags);
+      tjc.setSourceImage(srcBuf, 0, 0, w, 0, h, pf);
+    }
+    Arrays.fill(dstBuf, (byte)0);
+
+    tjc.setSubsamp(subsamp);
+    tjc.setJPEGQuality(jpegQual);
+    if (doYUV) {
+      System.out.format("%s %s -> YUV %s ... ", pfStrLong, buStrLong,
+                        SUBNAME_LONG[subsamp]);
+      YUVImage yuvImage = tjc.encodeYUV(pad, flags);
+      if (checkBufYUV(yuvImage.getBuf(), yuvImage.getSize(), w, h, subsamp,
+                      new TJScalingFactor(1, 1)) == 1)
+        System.out.print("Passed.\n");
+      else {
+        System.out.print("FAILED!\n");
+        exitStatus = -1;
+      }
+
+      System.out.format("YUV %s %s -> JPEG Q%d ... ", SUBNAME_LONG[subsamp],
+                        buStrLong, jpegQual);
+      tjc.setSourceImage(yuvImage);
+    } else {
+      System.out.format("%s %s -> %s Q%d ... ", pfStrLong, buStrLong,
+                        SUBNAME_LONG[subsamp], jpegQual);
+    }
+    tjc.compress(dstBuf, flags);
+    size = tjc.getCompressedSize();
+
+    tempStr = baseName + "_enc_" + pfStr + "_" + buStr + "_" +
+              SUBNAME[subsamp] + "_Q" + jpegQual + ".jpg";
+    writeJPEG(dstBuf, size, tempStr);
+    System.out.println("Done.\n  Result in " + tempStr);
+
+    return size;
+  }
+
+  static void decompTest(TJDecompressor tjd, byte[] jpegBuf, int jpegSize,
+                         int w, int h, int pf, String baseName, int subsamp,
+                         int flags, TJScalingFactor sf) throws Exception {
+    String pfStr, pfStrLong, tempStr;
+    String buStrLong = (flags & TJ.FLAG_BOTTOMUP) != 0 ?
+                       "Bottom-Up" : "Top-Down ";
+    int scaledWidth = sf.getScaled(w);
+    int scaledHeight = sf.getScaled(h);
+    int temp1, temp2, imgType = pf;
+    BufferedImage img = null;
+    byte[] dstBuf = null;
+
+    if (bi) {
+      pf = biTypePF(imgType);
+      pfStr = biTypeStr(imgType);
+      pfStrLong = pfStr + " (" + PIXFORMATSTR[pf] + ")";
+    } else {
+      pfStr = PIXFORMATSTR[pf];
+      pfStrLong = pfStr;
+    }
+
+    tjd.setSourceImage(jpegBuf, jpegSize);
+    if (tjd.getWidth() != w || tjd.getHeight() != h ||
+        tjd.getSubsamp() != subsamp)
+      throw new Exception("Incorrect JPEG header");
+
+    temp1 = scaledWidth;
+    temp2 = scaledHeight;
+    temp1 = tjd.getScaledWidth(temp1, temp2);
+    temp2 = tjd.getScaledHeight(temp1, temp2);
+    if (temp1 != scaledWidth || temp2 != scaledHeight)
+      throw new Exception("Scaled size mismatch");
+
+    if (doYUV) {
+      System.out.format("JPEG -> YUV %s ", SUBNAME_LONG[subsamp]);
+      if (!sf.isOne())
+        System.out.format("%d/%d ... ", sf.getNum(), sf.getDenom());
+      else System.out.print("... ");
+      YUVImage yuvImage = tjd.decompressToYUV(scaledWidth, pad, scaledHeight,
+                                              flags);
+      if (checkBufYUV(yuvImage.getBuf(), yuvImage.getSize(), scaledWidth,
+                      scaledHeight, subsamp, sf) == 1)
+        System.out.print("Passed.\n");
+      else {
+        System.out.print("FAILED!\n");  exitStatus = -1;
+      }
+
+      System.out.format("YUV %s -> %s %s ... ", SUBNAME_LONG[subsamp],
+                        pfStrLong, buStrLong);
+      tjd.setSourceImage(yuvImage);
+    } else {
+      System.out.format("JPEG -> %s %s ", pfStrLong, buStrLong);
+      if (!sf.isOne())
+        System.out.format("%d/%d ... ", sf.getNum(), sf.getDenom());
+      else System.out.print("... ");
+    }
+    if (bi)
+      img = tjd.decompress(scaledWidth, scaledHeight, imgType, flags);
+    else
+      dstBuf = tjd.decompress(scaledWidth, 0, scaledHeight, pf, flags);
+
+    if (bi) {
+      tempStr = baseName + "_dec_" + pfStr + "_" +
+                (((flags & TJ.FLAG_BOTTOMUP) != 0) ? "BU" : "TD") + "_" +
+                SUBNAME[subsamp] + "_" +
+                (double)sf.getNum() / (double)sf.getDenom() + "x" + ".png";
+      File file = new File(tempStr);
+      ImageIO.write(img, "png", file);
+    }
+
+    if ((bi && checkImg(img, pf, subsamp, sf, flags) == 1) ||
+        (!bi && checkBuf(dstBuf, scaledWidth,
+                         scaledWidth * TJ.getPixelSize(pf), scaledHeight, pf,
+                         subsamp, sf, flags) == 1))
+      System.out.print("Passed.\n");
+    else {
+      System.out.print("FAILED!\n");
+      exitStatus = -1;
+    }
+  }
+
+  static void decompTest(TJDecompressor tjd, byte[] jpegBuf, int jpegSize,
+                         int w, int h, int pf, String baseName, int subsamp,
+                         int flags) throws Exception {
+    int i;
+    TJScalingFactor[] sf = TJ.getScalingFactors();
+    for (i = 0; i < sf.length; i++) {
+      int num = sf[i].getNum();
+      int denom = sf[i].getDenom();
+      if (subsamp == TJ.SAMP_444 || subsamp == TJ.SAMP_GRAY ||
+          (subsamp == TJ.SAMP_411 && num == 1 &&
+           (denom == 2 || denom == 1)) ||
+          (subsamp != TJ.SAMP_411 && num == 1 &&
+           (denom == 4 || denom == 2 || denom == 1)))
+        decompTest(tjd, jpegBuf, jpegSize, w, h, pf, baseName, subsamp,
+                   flags, sf[i]);
+    }
+  }
+
+  static void doTest(int w, int h, int[] formats, int subsamp, String baseName)
+                     throws Exception {
+    TJCompressor tjc = null;
+    TJDecompressor tjd = null;
+    int size;
+    byte[] dstBuf;
+
+    dstBuf = new byte[TJ.bufSize(w, h, subsamp)];
+
+    try {
+      tjc = new TJCompressor();
+      tjd = new TJDecompressor();
+
+      for (int pf : formats) {
+        if (pf < 0) continue;
+        for (int i = 0; i < 2; i++) {
+          int flags = 0;
+          if (subsamp == TJ.SAMP_422 || subsamp == TJ.SAMP_420 ||
+              subsamp == TJ.SAMP_440 || subsamp == TJ.SAMP_411)
+            flags |= TJ.FLAG_FASTUPSAMPLE;
+          if (i == 1)
+            flags |= TJ.FLAG_BOTTOMUP;
+          size = compTest(tjc, dstBuf, w, h, pf, baseName, subsamp, 100,
+                          flags);
+          decompTest(tjd, dstBuf, size, w, h, pf, baseName, subsamp, flags);
+          if (pf >= TJ.PF_RGBX && pf <= TJ.PF_XRGB && !bi) {
+            System.out.print("\n");
+            decompTest(tjd, dstBuf, size, w, h, pf + (TJ.PF_RGBA - TJ.PF_RGBX),
+                       baseName, subsamp, flags);
+          }
+          System.out.print("\n");
+        }
+      }
+      System.out.print("--------------------\n\n");
+    } catch (Exception e) {
+      if (tjc != null) tjc.close();
+      if (tjd != null) tjd.close();
+      throw e;
+    }
+    if (tjc != null) tjc.close();
+    if (tjd != null) tjd.close();
+  }
+
+  static void bufSizeTest() throws Exception {
+    int w, h, i, subsamp;
+    byte[] srcBuf, dstBuf = null;
+    YUVImage dstImage = null;
+    TJCompressor tjc = null;
+    Random r = new Random();
+
+    try {
+      tjc = new TJCompressor();
+      System.out.println("Buffer size regression test");
+      for (subsamp = 0; subsamp < TJ.NUMSAMP; subsamp++) {
+        for (w = 1; w < 48; w++) {
+          int maxh = (w == 1) ? 2048 : 48;
+          for (h = 1; h < maxh; h++) {
+            if (h % 100 == 0)
+              System.out.format("%04d x %04d\b\b\b\b\b\b\b\b\b\b\b", w, h);
+            srcBuf = new byte[w * h * 4];
+            if (doYUV)
+              dstImage = new YUVImage(w, pad, h, subsamp);
+            else
+              dstBuf = new byte[TJ.bufSize(w, h, subsamp)];
+            for (i = 0; i < w * h * 4; i++) {
+              srcBuf[i] = (byte)(r.nextInt(2) * 255);
+            }
+            tjc.setSourceImage(srcBuf, 0, 0, w, 0, h, TJ.PF_BGRX);
+            tjc.setSubsamp(subsamp);
+            tjc.setJPEGQuality(100);
+            if (doYUV)
+              tjc.encodeYUV(dstImage, 0);
+            else
+              tjc.compress(dstBuf, 0);
+
+            srcBuf = new byte[h * w * 4];
+            if (doYUV)
+              dstImage = new YUVImage(h, pad, w, subsamp);
+            else
+              dstBuf = new byte[TJ.bufSize(h, w, subsamp)];
+            for (i = 0; i < h * w * 4; i++) {
+              srcBuf[i] = (byte)(r.nextInt(2) * 255);
+            }
+            tjc.setSourceImage(srcBuf, 0, 0, h, 0, w, TJ.PF_BGRX);
+            if (doYUV)
+              tjc.encodeYUV(dstImage, 0);
+            else
+              tjc.compress(dstBuf, 0);
+          }
+          dstImage = null;
+          dstBuf = null;
+          System.gc();
+        }
+      }
+      System.out.println("Done.      ");
+    } catch (Exception e) {
+      if (tjc != null) tjc.close();
+      throw e;
+    }
+    if (tjc != null) tjc.close();
+  }
+
+  public static void main(String[] argv) {
+    try {
+      String testName = "javatest";
+      for (int i = 0; i < argv.length; i++) {
+        if (argv[i].equalsIgnoreCase("-yuv"))
+          doYUV = true;
+        else if (argv[i].equalsIgnoreCase("-noyuvpad"))
+          pad = 1;
+        else if (argv[i].equalsIgnoreCase("-bi")) {
+          bi = true;
+          testName = "javabitest";
+        } else
+          usage();
+      }
+      if (doYUV)
+        FORMATS_4BYTE[4] = -1;
+      doTest(35, 39, bi ? FORMATS_3BYTEBI : FORMATS_3BYTE, TJ.SAMP_444,
+             testName);
+      doTest(39, 41, bi ? FORMATS_4BYTEBI : FORMATS_4BYTE, TJ.SAMP_444,
+             testName);
+      doTest(41, 35, bi ? FORMATS_3BYTEBI : FORMATS_3BYTE, TJ.SAMP_422,
+             testName);
+      doTest(35, 39, bi ? FORMATS_4BYTEBI : FORMATS_4BYTE, TJ.SAMP_422,
+             testName);
+      doTest(39, 41, bi ? FORMATS_3BYTEBI : FORMATS_3BYTE, TJ.SAMP_420,
+             testName);
+      doTest(41, 35, bi ? FORMATS_4BYTEBI : FORMATS_4BYTE, TJ.SAMP_420,
+             testName);
+      doTest(35, 39, bi ? FORMATS_3BYTEBI : FORMATS_3BYTE, TJ.SAMP_440,
+             testName);
+      doTest(39, 41, bi ? FORMATS_4BYTEBI : FORMATS_4BYTE, TJ.SAMP_440,
+             testName);
+      doTest(41, 35, bi ? FORMATS_3BYTEBI : FORMATS_3BYTE, TJ.SAMP_411,
+             testName);
+      doTest(35, 39, bi ? FORMATS_4BYTEBI : FORMATS_4BYTE, TJ.SAMP_411,
+             testName);
+      doTest(39, 41, bi ? FORMATS_GRAYBI : FORMATS_GRAY, TJ.SAMP_GRAY,
+             testName);
+      doTest(41, 35, bi ? FORMATS_3BYTEBI : FORMATS_3BYTE, TJ.SAMP_GRAY,
+             testName);
+      FORMATS_4BYTE[4] = -1;
+      doTest(35, 39, bi ? FORMATS_4BYTEBI : FORMATS_4BYTE, TJ.SAMP_GRAY,
+             testName);
+      if (!bi)
+        bufSizeTest();
+      if (doYUV && !bi) {
+        System.out.print("\n--------------------\n\n");
+        doTest(48, 48, FORMATS_RGB, TJ.SAMP_444, "javatest_yuv0");
+        doTest(48, 48, FORMATS_RGB, TJ.SAMP_422, "javatest_yuv0");
+        doTest(48, 48, FORMATS_RGB, TJ.SAMP_420, "javatest_yuv0");
+        doTest(48, 48, FORMATS_RGB, TJ.SAMP_440, "javatest_yuv0");
+        doTest(48, 48, FORMATS_RGB, TJ.SAMP_411, "javatest_yuv0");
+        doTest(48, 48, FORMATS_RGB, TJ.SAMP_GRAY, "javatest_yuv0");
+        doTest(48, 48, FORMATS_GRAY, TJ.SAMP_GRAY, "javatest_yuv0");
+      }
+    } catch (Exception e) {
+      e.printStackTrace();
+      exitStatus = -1;
+    }
+    System.exit(exitStatus);
+  }
+}
diff --git a/3rdparty/libjpeg/src/java/doc/allclasses-frame.html b/3rdparty/libjpeg/src/java/doc/allclasses-frame.html
new file mode 100644
index 00000000..fecac06d
--- /dev/null
+++ b/3rdparty/libjpeg/src/java/doc/allclasses-frame.html
@@ -0,0 +1,24 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!-- NewPage -->
+<html lang="en">
+<head>
+<title>All Classes</title>
+<link rel="stylesheet" type="text/css" href="stylesheet.css" title="Style">
+</head>
+<body>
+<h1 class="bar">All Classes</h1>
+<div class="indexContainer">
+<ul>
+<li><a href="org/libjpegturbo/turbojpeg/TJ.html" title="class in org.libjpegturbo.turbojpeg" target="classFrame">TJ</a></li>
+<li><a href="org/libjpegturbo/turbojpeg/TJCompressor.html" title="class in org.libjpegturbo.turbojpeg" target="classFrame">TJCompressor</a></li>
+<li><a href="org/libjpegturbo/turbojpeg/TJCustomFilter.html" title="interface in org.libjpegturbo.turbojpeg" target="classFrame"><i>TJCustomFilter</i></a></li>
+<li><a href="org/libjpegturbo/turbojpeg/TJDecompressor.html" title="class in org.libjpegturbo.turbojpeg" target="classFrame">TJDecompressor</a></li>
+<li><a href="org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg" target="classFrame">TJException</a></li>
+<li><a href="org/libjpegturbo/turbojpeg/TJScalingFactor.html" title="class in org.libjpegturbo.turbojpeg" target="classFrame">TJScalingFactor</a></li>
+<li><a href="org/libjpegturbo/turbojpeg/TJTransform.html" title="class in org.libjpegturbo.turbojpeg" target="classFrame">TJTransform</a></li>
+<li><a href="org/libjpegturbo/turbojpeg/TJTransformer.html" title="class in org.libjpegturbo.turbojpeg" target="classFrame">TJTransformer</a></li>
+<li><a href="org/libjpegturbo/turbojpeg/YUVImage.html" title="class in org.libjpegturbo.turbojpeg" target="classFrame">YUVImage</a></li>
+</ul>
+</div>
+</body>
+</html>
diff --git a/3rdparty/libjpeg/src/java/doc/allclasses-noframe.html b/3rdparty/libjpeg/src/java/doc/allclasses-noframe.html
new file mode 100644
index 00000000..1f7fd3c6
--- /dev/null
+++ b/3rdparty/libjpeg/src/java/doc/allclasses-noframe.html
@@ -0,0 +1,24 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!-- NewPage -->
+<html lang="en">
+<head>
+<title>All Classes</title>
+<link rel="stylesheet" type="text/css" href="stylesheet.css" title="Style">
+</head>
+<body>
+<h1 class="bar">All Classes</h1>
+<div class="indexContainer">
+<ul>
+<li><a href="org/libjpegturbo/turbojpeg/TJ.html" title="class in org.libjpegturbo.turbojpeg">TJ</a></li>
+<li><a href="org/libjpegturbo/turbojpeg/TJCompressor.html" title="class in org.libjpegturbo.turbojpeg">TJCompressor</a></li>
+<li><a href="org/libjpegturbo/turbojpeg/TJCustomFilter.html" title="interface in org.libjpegturbo.turbojpeg"><i>TJCustomFilter</i></a></li>
+<li><a href="org/libjpegturbo/turbojpeg/TJDecompressor.html" title="class in org.libjpegturbo.turbojpeg">TJDecompressor</a></li>
+<li><a href="org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></li>
+<li><a href="org/libjpegturbo/turbojpeg/TJScalingFactor.html" title="class in org.libjpegturbo.turbojpeg">TJScalingFactor</a></li>
+<li><a href="org/libjpegturbo/turbojpeg/TJTransform.html" title="class in org.libjpegturbo.turbojpeg">TJTransform</a></li>
+<li><a href="org/libjpegturbo/turbojpeg/TJTransformer.html" title="class in org.libjpegturbo.turbojpeg">TJTransformer</a></li>
+<li><a href="org/libjpegturbo/turbojpeg/YUVImage.html" title="class in org.libjpegturbo.turbojpeg">YUVImage</a></li>
+</ul>
+</div>
+</body>
+</html>
diff --git a/3rdparty/libjpeg/src/java/doc/constant-values.html b/3rdparty/libjpeg/src/java/doc/constant-values.html
new file mode 100644
index 00000000..fb33327f
--- /dev/null
+++ b/3rdparty/libjpeg/src/java/doc/constant-values.html
@@ -0,0 +1,532 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!-- NewPage -->
+<html lang="en">
+<head>
+<title>Constant Field Values</title>
+<link rel="stylesheet" type="text/css" href="stylesheet.css" title="Style">
+</head>
+<body>
+<script type="text/javascript"><!--
+    try {
+        if (location.href.indexOf('is-external=true') == -1) {
+            parent.document.title="Constant Field Values";
+        }
+    }
+    catch(err) {
+    }
+//-->
+</script>
+<noscript>
+<div>JavaScript is disabled on your browser.</div>
+</noscript>
+<!-- ========= START OF TOP NAVBAR ======= -->
+<div class="topNav"><a name="navbar_top">
+<!--   -->
+</a><a href="#skip-navbar_top" title="Skip navigation links"></a><a name="navbar_top_firstrow">
+<!--   -->
+</a>
+<ul class="navList" title="Navigation">
+<li><a href="org/libjpegturbo/turbojpeg/package-summary.html">Package</a></li>
+<li>Class</li>
+<li><a href="org/libjpegturbo/turbojpeg/package-tree.html">Tree</a></li>
+<li><a href="deprecated-list.html">Deprecated</a></li>
+<li><a href="index-all.html">Index</a></li>
+<li><a href="help-doc.html">Help</a></li>
+</ul>
+</div>
+<div class="subNav">
+<ul class="navList">
+<li>Prev</li>
+<li>Next</li>
+</ul>
+<ul class="navList">
+<li><a href="index.html?constant-values.html" target="_top">Frames</a></li>
+<li><a href="constant-values.html" target="_top">No Frames</a></li>
+</ul>
+<ul class="navList" id="allclasses_navbar_top">
+<li><a href="allclasses-noframe.html">All Classes</a></li>
+</ul>
+<div>
+<script type="text/javascript"><!--
+  allClassesLink = document.getElementById("allclasses_navbar_top");
+  if(window==top) {
+    allClassesLink.style.display = "block";
+  }
+  else {
+    allClassesLink.style.display = "none";
+  }
+  //-->
+</script>
+</div>
+<a name="skip-navbar_top">
+<!--   -->
+</a></div>
+<!-- ========= END OF TOP NAVBAR ========= -->
+<div class="header">
+<h1 title="Constant Field Values" class="title">Constant Field Values</h1>
+<h2 title="Contents">Contents</h2>
+<ul>
+<li><a href="#org.libjpegturbo">org.libjpegturbo.*</a></li>
+</ul>
+</div>
+<div class="constantValuesContainer"><a name="org.libjpegturbo">
+<!--   -->
+</a>
+<h2 title="org.libjpegturbo">org.libjpegturbo.*</h2>
+<ul class="blockList">
+<li class="blockList">
+<table border="0" cellpadding="3" cellspacing="0" summary="Constant Field Values table, listing constant fields, and values">
+<caption><span>org.libjpegturbo.turbojpeg.<a href="org/libjpegturbo/turbojpeg/TJ.html" title="class in org.libjpegturbo.turbojpeg">TJ</a></span><span class="tabEnd">&nbsp;</span></caption>
+<tr>
+<th class="colFirst" scope="col">Modifier and Type</th>
+<th scope="col">Constant Field</th>
+<th class="colLast" scope="col">Value</th>
+</tr>
+<tbody>
+<tr class="altColor">
+<td class="colFirst"><a name="org.libjpegturbo.turbojpeg.TJ.CS_CMYK">
+<!--   -->
+</a><code>public&nbsp;static&nbsp;final&nbsp;int</code></td>
+<td><code><a href="org/libjpegturbo/turbojpeg/TJ.html#CS_CMYK">CS_CMYK</a></code></td>
+<td class="colLast"><code>3</code></td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><a name="org.libjpegturbo.turbojpeg.TJ.CS_GRAY">
+<!--   -->
+</a><code>public&nbsp;static&nbsp;final&nbsp;int</code></td>
+<td><code><a href="org/libjpegturbo/turbojpeg/TJ.html#CS_GRAY">CS_GRAY</a></code></td>
+<td class="colLast"><code>2</code></td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><a name="org.libjpegturbo.turbojpeg.TJ.CS_RGB">
+<!--   -->
+</a><code>public&nbsp;static&nbsp;final&nbsp;int</code></td>
+<td><code><a href="org/libjpegturbo/turbojpeg/TJ.html#CS_RGB">CS_RGB</a></code></td>
+<td class="colLast"><code>0</code></td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><a name="org.libjpegturbo.turbojpeg.TJ.CS_YCbCr">
+<!--   -->
+</a><code>public&nbsp;static&nbsp;final&nbsp;int</code></td>
+<td><code><a href="org/libjpegturbo/turbojpeg/TJ.html#CS_YCbCr">CS_YCbCr</a></code></td>
+<td class="colLast"><code>1</code></td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><a name="org.libjpegturbo.turbojpeg.TJ.CS_YCCK">
+<!--   -->
+</a><code>public&nbsp;static&nbsp;final&nbsp;int</code></td>
+<td><code><a href="org/libjpegturbo/turbojpeg/TJ.html#CS_YCCK">CS_YCCK</a></code></td>
+<td class="colLast"><code>4</code></td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><a name="org.libjpegturbo.turbojpeg.TJ.ERR_FATAL">
+<!--   -->
+</a><code>public&nbsp;static&nbsp;final&nbsp;int</code></td>
+<td><code><a href="org/libjpegturbo/turbojpeg/TJ.html#ERR_FATAL">ERR_FATAL</a></code></td>
+<td class="colLast"><code>1</code></td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><a name="org.libjpegturbo.turbojpeg.TJ.ERR_WARNING">
+<!--   -->
+</a><code>public&nbsp;static&nbsp;final&nbsp;int</code></td>
+<td><code><a href="org/libjpegturbo/turbojpeg/TJ.html#ERR_WARNING">ERR_WARNING</a></code></td>
+<td class="colLast"><code>0</code></td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><a name="org.libjpegturbo.turbojpeg.TJ.FLAG_ACCURATEDCT">
+<!--   -->
+</a><code>public&nbsp;static&nbsp;final&nbsp;int</code></td>
+<td><code><a href="org/libjpegturbo/turbojpeg/TJ.html#FLAG_ACCURATEDCT">FLAG_ACCURATEDCT</a></code></td>
+<td class="colLast"><code>4096</code></td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><a name="org.libjpegturbo.turbojpeg.TJ.FLAG_BOTTOMUP">
+<!--   -->
+</a><code>public&nbsp;static&nbsp;final&nbsp;int</code></td>
+<td><code><a href="org/libjpegturbo/turbojpeg/TJ.html#FLAG_BOTTOMUP">FLAG_BOTTOMUP</a></code></td>
+<td class="colLast"><code>2</code></td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><a name="org.libjpegturbo.turbojpeg.TJ.FLAG_FASTDCT">
+<!--   -->
+</a><code>public&nbsp;static&nbsp;final&nbsp;int</code></td>
+<td><code><a href="org/libjpegturbo/turbojpeg/TJ.html#FLAG_FASTDCT">FLAG_FASTDCT</a></code></td>
+<td class="colLast"><code>2048</code></td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><a name="org.libjpegturbo.turbojpeg.TJ.FLAG_FASTUPSAMPLE">
+<!--   -->
+</a><code>public&nbsp;static&nbsp;final&nbsp;int</code></td>
+<td><code><a href="org/libjpegturbo/turbojpeg/TJ.html#FLAG_FASTUPSAMPLE">FLAG_FASTUPSAMPLE</a></code></td>
+<td class="colLast"><code>256</code></td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><a name="org.libjpegturbo.turbojpeg.TJ.FLAG_FORCEMMX">
+<!--   -->
+</a><code>public&nbsp;static&nbsp;final&nbsp;int</code></td>
+<td><code><a href="org/libjpegturbo/turbojpeg/TJ.html#FLAG_FORCEMMX">FLAG_FORCEMMX</a></code></td>
+<td class="colLast"><code>8</code></td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><a name="org.libjpegturbo.turbojpeg.TJ.FLAG_FORCESSE">
+<!--   -->
+</a><code>public&nbsp;static&nbsp;final&nbsp;int</code></td>
+<td><code><a href="org/libjpegturbo/turbojpeg/TJ.html#FLAG_FORCESSE">FLAG_FORCESSE</a></code></td>
+<td class="colLast"><code>16</code></td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><a name="org.libjpegturbo.turbojpeg.TJ.FLAG_FORCESSE2">
+<!--   -->
+</a><code>public&nbsp;static&nbsp;final&nbsp;int</code></td>
+<td><code><a href="org/libjpegturbo/turbojpeg/TJ.html#FLAG_FORCESSE2">FLAG_FORCESSE2</a></code></td>
+<td class="colLast"><code>32</code></td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><a name="org.libjpegturbo.turbojpeg.TJ.FLAG_FORCESSE3">
+<!--   -->
+</a><code>public&nbsp;static&nbsp;final&nbsp;int</code></td>
+<td><code><a href="org/libjpegturbo/turbojpeg/TJ.html#FLAG_FORCESSE3">FLAG_FORCESSE3</a></code></td>
+<td class="colLast"><code>128</code></td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><a name="org.libjpegturbo.turbojpeg.TJ.FLAG_PROGRESSIVE">
+<!--   -->
+</a><code>public&nbsp;static&nbsp;final&nbsp;int</code></td>
+<td><code><a href="org/libjpegturbo/turbojpeg/TJ.html#FLAG_PROGRESSIVE">FLAG_PROGRESSIVE</a></code></td>
+<td class="colLast"><code>16384</code></td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><a name="org.libjpegturbo.turbojpeg.TJ.FLAG_STOPONWARNING">
+<!--   -->
+</a><code>public&nbsp;static&nbsp;final&nbsp;int</code></td>
+<td><code><a href="org/libjpegturbo/turbojpeg/TJ.html#FLAG_STOPONWARNING">FLAG_STOPONWARNING</a></code></td>
+<td class="colLast"><code>8192</code></td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><a name="org.libjpegturbo.turbojpeg.TJ.NUMCS">
+<!--   -->
+</a><code>public&nbsp;static&nbsp;final&nbsp;int</code></td>
+<td><code><a href="org/libjpegturbo/turbojpeg/TJ.html#NUMCS">NUMCS</a></code></td>
+<td class="colLast"><code>5</code></td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><a name="org.libjpegturbo.turbojpeg.TJ.NUMERR">
+<!--   -->
+</a><code>public&nbsp;static&nbsp;final&nbsp;int</code></td>
+<td><code><a href="org/libjpegturbo/turbojpeg/TJ.html#NUMERR">NUMERR</a></code></td>
+<td class="colLast"><code>2</code></td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><a name="org.libjpegturbo.turbojpeg.TJ.NUMPF">
+<!--   -->
+</a><code>public&nbsp;static&nbsp;final&nbsp;int</code></td>
+<td><code><a href="org/libjpegturbo/turbojpeg/TJ.html#NUMPF">NUMPF</a></code></td>
+<td class="colLast"><code>12</code></td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><a name="org.libjpegturbo.turbojpeg.TJ.NUMSAMP">
+<!--   -->
+</a><code>public&nbsp;static&nbsp;final&nbsp;int</code></td>
+<td><code><a href="org/libjpegturbo/turbojpeg/TJ.html#NUMSAMP">NUMSAMP</a></code></td>
+<td class="colLast"><code>6</code></td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><a name="org.libjpegturbo.turbojpeg.TJ.PF_ABGR">
+<!--   -->
+</a><code>public&nbsp;static&nbsp;final&nbsp;int</code></td>
+<td><code><a href="org/libjpegturbo/turbojpeg/TJ.html#PF_ABGR">PF_ABGR</a></code></td>
+<td class="colLast"><code>9</code></td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><a name="org.libjpegturbo.turbojpeg.TJ.PF_ARGB">
+<!--   -->
+</a><code>public&nbsp;static&nbsp;final&nbsp;int</code></td>
+<td><code><a href="org/libjpegturbo/turbojpeg/TJ.html#PF_ARGB">PF_ARGB</a></code></td>
+<td class="colLast"><code>10</code></td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><a name="org.libjpegturbo.turbojpeg.TJ.PF_BGR">
+<!--   -->
+</a><code>public&nbsp;static&nbsp;final&nbsp;int</code></td>
+<td><code><a href="org/libjpegturbo/turbojpeg/TJ.html#PF_BGR">PF_BGR</a></code></td>
+<td class="colLast"><code>1</code></td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><a name="org.libjpegturbo.turbojpeg.TJ.PF_BGRA">
+<!--   -->
+</a><code>public&nbsp;static&nbsp;final&nbsp;int</code></td>
+<td><code><a href="org/libjpegturbo/turbojpeg/TJ.html#PF_BGRA">PF_BGRA</a></code></td>
+<td class="colLast"><code>8</code></td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><a name="org.libjpegturbo.turbojpeg.TJ.PF_BGRX">
+<!--   -->
+</a><code>public&nbsp;static&nbsp;final&nbsp;int</code></td>
+<td><code><a href="org/libjpegturbo/turbojpeg/TJ.html#PF_BGRX">PF_BGRX</a></code></td>
+<td class="colLast"><code>3</code></td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><a name="org.libjpegturbo.turbojpeg.TJ.PF_CMYK">
+<!--   -->
+</a><code>public&nbsp;static&nbsp;final&nbsp;int</code></td>
+<td><code><a href="org/libjpegturbo/turbojpeg/TJ.html#PF_CMYK">PF_CMYK</a></code></td>
+<td class="colLast"><code>11</code></td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><a name="org.libjpegturbo.turbojpeg.TJ.PF_GRAY">
+<!--   -->
+</a><code>public&nbsp;static&nbsp;final&nbsp;int</code></td>
+<td><code><a href="org/libjpegturbo/turbojpeg/TJ.html#PF_GRAY">PF_GRAY</a></code></td>
+<td class="colLast"><code>6</code></td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><a name="org.libjpegturbo.turbojpeg.TJ.PF_RGB">
+<!--   -->
+</a><code>public&nbsp;static&nbsp;final&nbsp;int</code></td>
+<td><code><a href="org/libjpegturbo/turbojpeg/TJ.html#PF_RGB">PF_RGB</a></code></td>
+<td class="colLast"><code>0</code></td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><a name="org.libjpegturbo.turbojpeg.TJ.PF_RGBA">
+<!--   -->
+</a><code>public&nbsp;static&nbsp;final&nbsp;int</code></td>
+<td><code><a href="org/libjpegturbo/turbojpeg/TJ.html#PF_RGBA">PF_RGBA</a></code></td>
+<td class="colLast"><code>7</code></td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><a name="org.libjpegturbo.turbojpeg.TJ.PF_RGBX">
+<!--   -->
+</a><code>public&nbsp;static&nbsp;final&nbsp;int</code></td>
+<td><code><a href="org/libjpegturbo/turbojpeg/TJ.html#PF_RGBX">PF_RGBX</a></code></td>
+<td class="colLast"><code>2</code></td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><a name="org.libjpegturbo.turbojpeg.TJ.PF_XBGR">
+<!--   -->
+</a><code>public&nbsp;static&nbsp;final&nbsp;int</code></td>
+<td><code><a href="org/libjpegturbo/turbojpeg/TJ.html#PF_XBGR">PF_XBGR</a></code></td>
+<td class="colLast"><code>4</code></td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><a name="org.libjpegturbo.turbojpeg.TJ.PF_XRGB">
+<!--   -->
+</a><code>public&nbsp;static&nbsp;final&nbsp;int</code></td>
+<td><code><a href="org/libjpegturbo/turbojpeg/TJ.html#PF_XRGB">PF_XRGB</a></code></td>
+<td class="colLast"><code>5</code></td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><a name="org.libjpegturbo.turbojpeg.TJ.SAMP_411">
+<!--   -->
+</a><code>public&nbsp;static&nbsp;final&nbsp;int</code></td>
+<td><code><a href="org/libjpegturbo/turbojpeg/TJ.html#SAMP_411">SAMP_411</a></code></td>
+<td class="colLast"><code>5</code></td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><a name="org.libjpegturbo.turbojpeg.TJ.SAMP_420">
+<!--   -->
+</a><code>public&nbsp;static&nbsp;final&nbsp;int</code></td>
+<td><code><a href="org/libjpegturbo/turbojpeg/TJ.html#SAMP_420">SAMP_420</a></code></td>
+<td class="colLast"><code>2</code></td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><a name="org.libjpegturbo.turbojpeg.TJ.SAMP_422">
+<!--   -->
+</a><code>public&nbsp;static&nbsp;final&nbsp;int</code></td>
+<td><code><a href="org/libjpegturbo/turbojpeg/TJ.html#SAMP_422">SAMP_422</a></code></td>
+<td class="colLast"><code>1</code></td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><a name="org.libjpegturbo.turbojpeg.TJ.SAMP_440">
+<!--   -->
+</a><code>public&nbsp;static&nbsp;final&nbsp;int</code></td>
+<td><code><a href="org/libjpegturbo/turbojpeg/TJ.html#SAMP_440">SAMP_440</a></code></td>
+<td class="colLast"><code>4</code></td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><a name="org.libjpegturbo.turbojpeg.TJ.SAMP_444">
+<!--   -->
+</a><code>public&nbsp;static&nbsp;final&nbsp;int</code></td>
+<td><code><a href="org/libjpegturbo/turbojpeg/TJ.html#SAMP_444">SAMP_444</a></code></td>
+<td class="colLast"><code>0</code></td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><a name="org.libjpegturbo.turbojpeg.TJ.SAMP_GRAY">
+<!--   -->
+</a><code>public&nbsp;static&nbsp;final&nbsp;int</code></td>
+<td><code><a href="org/libjpegturbo/turbojpeg/TJ.html#SAMP_GRAY">SAMP_GRAY</a></code></td>
+<td class="colLast"><code>3</code></td>
+</tr>
+</tbody>
+</table>
+</li>
+<li class="blockList">
+<table border="0" cellpadding="3" cellspacing="0" summary="Constant Field Values table, listing constant fields, and values">
+<caption><span>org.libjpegturbo.turbojpeg.<a href="org/libjpegturbo/turbojpeg/TJTransform.html" title="class in org.libjpegturbo.turbojpeg">TJTransform</a></span><span class="tabEnd">&nbsp;</span></caption>
+<tr>
+<th class="colFirst" scope="col">Modifier and Type</th>
+<th scope="col">Constant Field</th>
+<th class="colLast" scope="col">Value</th>
+</tr>
+<tbody>
+<tr class="altColor">
+<td class="colFirst"><a name="org.libjpegturbo.turbojpeg.TJTransform.NUMOP">
+<!--   -->
+</a><code>public&nbsp;static&nbsp;final&nbsp;int</code></td>
+<td><code><a href="org/libjpegturbo/turbojpeg/TJTransform.html#NUMOP">NUMOP</a></code></td>
+<td class="colLast"><code>8</code></td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><a name="org.libjpegturbo.turbojpeg.TJTransform.OP_HFLIP">
+<!--   -->
+</a><code>public&nbsp;static&nbsp;final&nbsp;int</code></td>
+<td><code><a href="org/libjpegturbo/turbojpeg/TJTransform.html#OP_HFLIP">OP_HFLIP</a></code></td>
+<td class="colLast"><code>1</code></td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><a name="org.libjpegturbo.turbojpeg.TJTransform.OP_NONE">
+<!--   -->
+</a><code>public&nbsp;static&nbsp;final&nbsp;int</code></td>
+<td><code><a href="org/libjpegturbo/turbojpeg/TJTransform.html#OP_NONE">OP_NONE</a></code></td>
+<td class="colLast"><code>0</code></td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><a name="org.libjpegturbo.turbojpeg.TJTransform.OP_ROT180">
+<!--   -->
+</a><code>public&nbsp;static&nbsp;final&nbsp;int</code></td>
+<td><code><a href="org/libjpegturbo/turbojpeg/TJTransform.html#OP_ROT180">OP_ROT180</a></code></td>
+<td class="colLast"><code>6</code></td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><a name="org.libjpegturbo.turbojpeg.TJTransform.OP_ROT270">
+<!--   -->
+</a><code>public&nbsp;static&nbsp;final&nbsp;int</code></td>
+<td><code><a href="org/libjpegturbo/turbojpeg/TJTransform.html#OP_ROT270">OP_ROT270</a></code></td>
+<td class="colLast"><code>7</code></td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><a name="org.libjpegturbo.turbojpeg.TJTransform.OP_ROT90">
+<!--   -->
+</a><code>public&nbsp;static&nbsp;final&nbsp;int</code></td>
+<td><code><a href="org/libjpegturbo/turbojpeg/TJTransform.html#OP_ROT90">OP_ROT90</a></code></td>
+<td class="colLast"><code>5</code></td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><a name="org.libjpegturbo.turbojpeg.TJTransform.OP_TRANSPOSE">
+<!--   -->
+</a><code>public&nbsp;static&nbsp;final&nbsp;int</code></td>
+<td><code><a href="org/libjpegturbo/turbojpeg/TJTransform.html#OP_TRANSPOSE">OP_TRANSPOSE</a></code></td>
+<td class="colLast"><code>3</code></td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><a name="org.libjpegturbo.turbojpeg.TJTransform.OP_TRANSVERSE">
+<!--   -->
+</a><code>public&nbsp;static&nbsp;final&nbsp;int</code></td>
+<td><code><a href="org/libjpegturbo/turbojpeg/TJTransform.html#OP_TRANSVERSE">OP_TRANSVERSE</a></code></td>
+<td class="colLast"><code>4</code></td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><a name="org.libjpegturbo.turbojpeg.TJTransform.OP_VFLIP">
+<!--   -->
+</a><code>public&nbsp;static&nbsp;final&nbsp;int</code></td>
+<td><code><a href="org/libjpegturbo/turbojpeg/TJTransform.html#OP_VFLIP">OP_VFLIP</a></code></td>
+<td class="colLast"><code>2</code></td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><a name="org.libjpegturbo.turbojpeg.TJTransform.OPT_COPYNONE">
+<!--   -->
+</a><code>public&nbsp;static&nbsp;final&nbsp;int</code></td>
+<td><code><a href="org/libjpegturbo/turbojpeg/TJTransform.html#OPT_COPYNONE">OPT_COPYNONE</a></code></td>
+<td class="colLast"><code>64</code></td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><a name="org.libjpegturbo.turbojpeg.TJTransform.OPT_CROP">
+<!--   -->
+</a><code>public&nbsp;static&nbsp;final&nbsp;int</code></td>
+<td><code><a href="org/libjpegturbo/turbojpeg/TJTransform.html#OPT_CROP">OPT_CROP</a></code></td>
+<td class="colLast"><code>4</code></td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><a name="org.libjpegturbo.turbojpeg.TJTransform.OPT_GRAY">
+<!--   -->
+</a><code>public&nbsp;static&nbsp;final&nbsp;int</code></td>
+<td><code><a href="org/libjpegturbo/turbojpeg/TJTransform.html#OPT_GRAY">OPT_GRAY</a></code></td>
+<td class="colLast"><code>8</code></td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><a name="org.libjpegturbo.turbojpeg.TJTransform.OPT_NOOUTPUT">
+<!--   -->
+</a><code>public&nbsp;static&nbsp;final&nbsp;int</code></td>
+<td><code><a href="org/libjpegturbo/turbojpeg/TJTransform.html#OPT_NOOUTPUT">OPT_NOOUTPUT</a></code></td>
+<td class="colLast"><code>16</code></td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><a name="org.libjpegturbo.turbojpeg.TJTransform.OPT_PERFECT">
+<!--   -->
+</a><code>public&nbsp;static&nbsp;final&nbsp;int</code></td>
+<td><code><a href="org/libjpegturbo/turbojpeg/TJTransform.html#OPT_PERFECT">OPT_PERFECT</a></code></td>
+<td class="colLast"><code>1</code></td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><a name="org.libjpegturbo.turbojpeg.TJTransform.OPT_PROGRESSIVE">
+<!--   -->
+</a><code>public&nbsp;static&nbsp;final&nbsp;int</code></td>
+<td><code><a href="org/libjpegturbo/turbojpeg/TJTransform.html#OPT_PROGRESSIVE">OPT_PROGRESSIVE</a></code></td>
+<td class="colLast"><code>32</code></td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><a name="org.libjpegturbo.turbojpeg.TJTransform.OPT_TRIM">
+<!--   -->
+</a><code>public&nbsp;static&nbsp;final&nbsp;int</code></td>
+<td><code><a href="org/libjpegturbo/turbojpeg/TJTransform.html#OPT_TRIM">OPT_TRIM</a></code></td>
+<td class="colLast"><code>2</code></td>
+</tr>
+</tbody>
+</table>
+</li>
+</ul>
+</div>
+<!-- ======= START OF BOTTOM NAVBAR ====== -->
+<div class="bottomNav"><a name="navbar_bottom">
+<!--   -->
+</a><a href="#skip-navbar_bottom" title="Skip navigation links"></a><a name="navbar_bottom_firstrow">
+<!--   -->
+</a>
+<ul class="navList" title="Navigation">
+<li><a href="org/libjpegturbo/turbojpeg/package-summary.html">Package</a></li>
+<li>Class</li>
+<li><a href="org/libjpegturbo/turbojpeg/package-tree.html">Tree</a></li>
+<li><a href="deprecated-list.html">Deprecated</a></li>
+<li><a href="index-all.html">Index</a></li>
+<li><a href="help-doc.html">Help</a></li>
+</ul>
+</div>
+<div class="subNav">
+<ul class="navList">
+<li>Prev</li>
+<li>Next</li>
+</ul>
+<ul class="navList">
+<li><a href="index.html?constant-values.html" target="_top">Frames</a></li>
+<li><a href="constant-values.html" target="_top">No Frames</a></li>
+</ul>
+<ul class="navList" id="allclasses_navbar_bottom">
+<li><a href="allclasses-noframe.html">All Classes</a></li>
+</ul>
+<div>
+<script type="text/javascript"><!--
+  allClassesLink = document.getElementById("allclasses_navbar_bottom");
+  if(window==top) {
+    allClassesLink.style.display = "block";
+  }
+  else {
+    allClassesLink.style.display = "none";
+  }
+  //-->
+</script>
+</div>
+<a name="skip-navbar_bottom">
+<!--   -->
+</a></div>
+<!-- ======== END OF BOTTOM NAVBAR ======= -->
+</body>
+</html>
diff --git a/3rdparty/libjpeg/src/java/doc/deprecated-list.html b/3rdparty/libjpeg/src/java/doc/deprecated-list.html
new file mode 100644
index 00000000..31d4e643
--- /dev/null
+++ b/3rdparty/libjpeg/src/java/doc/deprecated-list.html
@@ -0,0 +1,252 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!-- NewPage -->
+<html lang="en">
+<head>
+<title>Deprecated List</title>
+<link rel="stylesheet" type="text/css" href="stylesheet.css" title="Style">
+</head>
+<body>
+<script type="text/javascript"><!--
+    try {
+        if (location.href.indexOf('is-external=true') == -1) {
+            parent.document.title="Deprecated List";
+        }
+    }
+    catch(err) {
+    }
+//-->
+</script>
+<noscript>
+<div>JavaScript is disabled on your browser.</div>
+</noscript>
+<!-- ========= START OF TOP NAVBAR ======= -->
+<div class="topNav"><a name="navbar_top">
+<!--   -->
+</a><a href="#skip-navbar_top" title="Skip navigation links"></a><a name="navbar_top_firstrow">
+<!--   -->
+</a>
+<ul class="navList" title="Navigation">
+<li><a href="org/libjpegturbo/turbojpeg/package-summary.html">Package</a></li>
+<li>Class</li>
+<li><a href="org/libjpegturbo/turbojpeg/package-tree.html">Tree</a></li>
+<li class="navBarCell1Rev">Deprecated</li>
+<li><a href="index-all.html">Index</a></li>
+<li><a href="help-doc.html">Help</a></li>
+</ul>
+</div>
+<div class="subNav">
+<ul class="navList">
+<li>Prev</li>
+<li>Next</li>
+</ul>
+<ul class="navList">
+<li><a href="index.html?deprecated-list.html" target="_top">Frames</a></li>
+<li><a href="deprecated-list.html" target="_top">No Frames</a></li>
+</ul>
+<ul class="navList" id="allclasses_navbar_top">
+<li><a href="allclasses-noframe.html">All Classes</a></li>
+</ul>
+<div>
+<script type="text/javascript"><!--
+  allClassesLink = document.getElementById("allclasses_navbar_top");
+  if(window==top) {
+    allClassesLink.style.display = "block";
+  }
+  else {
+    allClassesLink.style.display = "none";
+  }
+  //-->
+</script>
+</div>
+<a name="skip-navbar_top">
+<!--   -->
+</a></div>
+<!-- ========= END OF TOP NAVBAR ========= -->
+<div class="header">
+<h1 title="Deprecated API" class="title">Deprecated API</h1>
+<h2 title="Contents">Contents</h2>
+<ul>
+<li><a href="#field">Deprecated Fields</a></li>
+<li><a href="#method">Deprecated Methods</a></li>
+<li><a href="#constructor">Deprecated Constructors</a></li>
+</ul>
+</div>
+<div class="contentContainer"><a name="field">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<table border="0" cellpadding="3" cellspacing="0" summary="Deprecated Fields table, listing deprecated fields, and an explanation">
+<caption><span>Deprecated Fields</span><span class="tabEnd">&nbsp;</span></caption>
+<tr>
+<th class="colOne" scope="col">Field and Description</th>
+</tr>
+<tbody>
+<tr class="altColor">
+<td class="colOne"><a href="org/libjpegturbo/turbojpeg/TJ.html#FLAG_FORCEMMX">org.libjpegturbo.turbojpeg.TJ.FLAG_FORCEMMX</a></td>
+</tr>
+<tr class="rowColor">
+<td class="colOne"><a href="org/libjpegturbo/turbojpeg/TJ.html#FLAG_FORCESSE">org.libjpegturbo.turbojpeg.TJ.FLAG_FORCESSE</a></td>
+</tr>
+<tr class="altColor">
+<td class="colOne"><a href="org/libjpegturbo/turbojpeg/TJ.html#FLAG_FORCESSE2">org.libjpegturbo.turbojpeg.TJ.FLAG_FORCESSE2</a></td>
+</tr>
+<tr class="rowColor">
+<td class="colOne"><a href="org/libjpegturbo/turbojpeg/TJ.html#FLAG_FORCESSE3">org.libjpegturbo.turbojpeg.TJ.FLAG_FORCESSE3</a></td>
+</tr>
+</tbody>
+</table>
+</li>
+</ul>
+<a name="method">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<table border="0" cellpadding="3" cellspacing="0" summary="Deprecated Methods table, listing deprecated methods, and an explanation">
+<caption><span>Deprecated Methods</span><span class="tabEnd">&nbsp;</span></caption>
+<tr>
+<th class="colOne" scope="col">Method and Description</th>
+</tr>
+<tbody>
+<tr class="altColor">
+<td class="colOne"><a href="org/libjpegturbo/turbojpeg/TJ.html#bufSizeYUV(int,%20int,%20int)">org.libjpegturbo.turbojpeg.TJ.bufSizeYUV(int, int, int)</a>
+<div class="block"><i>Use <a href="org/libjpegturbo/turbojpeg/TJ.html#bufSizeYUV(int,%20int,%20int,%20int)"><code>TJ.bufSizeYUV(int, int, int, int)</code></a> instead.</i></div>
+</td>
+</tr>
+<tr class="rowColor">
+<td class="colOne"><a href="org/libjpegturbo/turbojpeg/TJCompressor.html#compress(java.awt.image.BufferedImage,%20byte[],%20int)">org.libjpegturbo.turbojpeg.TJCompressor.compress(BufferedImage, byte[], int)</a>
+<div class="block"><i>Use
+ <a href="org/libjpegturbo/turbojpeg/TJCompressor.html#setSourceImage(java.awt.image.BufferedImage,%20int,%20int,%20int,%20int)"><code>TJCompressor.setSourceImage(BufferedImage, int, int, int, int)</code></a> and
+ <a href="org/libjpegturbo/turbojpeg/TJCompressor.html#compress(byte[],%20int)"><code>TJCompressor.compress(byte[], int)</code></a> instead.</i></div>
+</td>
+</tr>
+<tr class="altColor">
+<td class="colOne"><a href="org/libjpegturbo/turbojpeg/TJCompressor.html#compress(java.awt.image.BufferedImage,%20int)">org.libjpegturbo.turbojpeg.TJCompressor.compress(BufferedImage, int)</a>
+<div class="block"><i>Use
+ <a href="org/libjpegturbo/turbojpeg/TJCompressor.html#setSourceImage(java.awt.image.BufferedImage,%20int,%20int,%20int,%20int)"><code>TJCompressor.setSourceImage(BufferedImage, int, int, int, int)</code></a> and
+ <a href="org/libjpegturbo/turbojpeg/TJCompressor.html#compress(int)"><code>TJCompressor.compress(int)</code></a> instead.</i></div>
+</td>
+</tr>
+<tr class="rowColor">
+<td class="colOne"><a href="org/libjpegturbo/turbojpeg/TJDecompressor.html#decompress(byte[],%20int,%20int,%20int,%20int,%20int)">org.libjpegturbo.turbojpeg.TJDecompressor.decompress(byte[], int, int, int, int, int)</a>
+<div class="block"><i>Use
+ <a href="org/libjpegturbo/turbojpeg/TJDecompressor.html#decompress(byte[],%20int,%20int,%20int,%20int,%20int,%20int,%20int)"><code>TJDecompressor.decompress(byte[], int, int, int, int, int, int, int)</code></a> instead.</i></div>
+</td>
+</tr>
+<tr class="altColor">
+<td class="colOne"><a href="org/libjpegturbo/turbojpeg/TJDecompressor.html#decompressToYUV(byte[],%20int)">org.libjpegturbo.turbojpeg.TJDecompressor.decompressToYUV(byte[], int)</a>
+<div class="block"><i>Use <a href="org/libjpegturbo/turbojpeg/TJDecompressor.html#decompressToYUV(org.libjpegturbo.turbojpeg.YUVImage,%20int)"><code>TJDecompressor.decompressToYUV(YUVImage, int)</code></a> instead.</i></div>
+</td>
+</tr>
+<tr class="rowColor">
+<td class="colOne"><a href="org/libjpegturbo/turbojpeg/TJDecompressor.html#decompressToYUV(int)">org.libjpegturbo.turbojpeg.TJDecompressor.decompressToYUV(int)</a>
+<div class="block"><i>Use <a href="org/libjpegturbo/turbojpeg/TJDecompressor.html#decompressToYUV(int,%20int,%20int,%20int)"><code>TJDecompressor.decompressToYUV(int, int, int, int)</code></a> instead.</i></div>
+</td>
+</tr>
+<tr class="altColor">
+<td class="colOne"><a href="org/libjpegturbo/turbojpeg/TJCompressor.html#encodeYUV(java.awt.image.BufferedImage,%20byte[],%20int)">org.libjpegturbo.turbojpeg.TJCompressor.encodeYUV(BufferedImage, byte[], int)</a>
+<div class="block"><i>Use
+ <a href="org/libjpegturbo/turbojpeg/TJCompressor.html#setSourceImage(java.awt.image.BufferedImage,%20int,%20int,%20int,%20int)"><code>TJCompressor.setSourceImage(BufferedImage, int, int, int, int)</code></a> and
+ <a href="org/libjpegturbo/turbojpeg/TJCompressor.html#encodeYUV(byte[],%20int)"><code>TJCompressor.encodeYUV(byte[], int)</code></a> instead.</i></div>
+</td>
+</tr>
+<tr class="rowColor">
+<td class="colOne"><a href="org/libjpegturbo/turbojpeg/TJCompressor.html#encodeYUV(java.awt.image.BufferedImage,%20int)">org.libjpegturbo.turbojpeg.TJCompressor.encodeYUV(BufferedImage, int)</a>
+<div class="block"><i>Use
+ <a href="org/libjpegturbo/turbojpeg/TJCompressor.html#setSourceImage(java.awt.image.BufferedImage,%20int,%20int,%20int,%20int)"><code>TJCompressor.setSourceImage(BufferedImage, int, int, int, int)</code></a> and
+ <a href="org/libjpegturbo/turbojpeg/TJCompressor.html#encodeYUV(int,%20int)"><code>TJCompressor.encodeYUV(int, int)</code></a> instead.</i></div>
+</td>
+</tr>
+<tr class="altColor">
+<td class="colOne"><a href="org/libjpegturbo/turbojpeg/TJCompressor.html#encodeYUV(byte[],%20int)">org.libjpegturbo.turbojpeg.TJCompressor.encodeYUV(byte[], int)</a>
+<div class="block"><i>Use <a href="org/libjpegturbo/turbojpeg/TJCompressor.html#encodeYUV(org.libjpegturbo.turbojpeg.YUVImage,%20int)"><code>TJCompressor.encodeYUV(YUVImage, int)</code></a> instead.</i></div>
+</td>
+</tr>
+<tr class="rowColor">
+<td class="colOne"><a href="org/libjpegturbo/turbojpeg/TJCompressor.html#encodeYUV(int)">org.libjpegturbo.turbojpeg.TJCompressor.encodeYUV(int)</a>
+<div class="block"><i>Use <a href="org/libjpegturbo/turbojpeg/TJCompressor.html#encodeYUV(int,%20int)"><code>TJCompressor.encodeYUV(int, int)</code></a> instead.</i></div>
+</td>
+</tr>
+<tr class="altColor">
+<td class="colOne"><a href="org/libjpegturbo/turbojpeg/TJDecompressor.html#setJPEGImage(byte[],%20int)">org.libjpegturbo.turbojpeg.TJDecompressor.setJPEGImage(byte[], int)</a>
+<div class="block"><i>Use <a href="org/libjpegturbo/turbojpeg/TJDecompressor.html#setSourceImage(byte[],%20int)"><code>TJDecompressor.setSourceImage(byte[], int)</code></a> instead.</i></div>
+</td>
+</tr>
+<tr class="rowColor">
+<td class="colOne"><a href="org/libjpegturbo/turbojpeg/TJCompressor.html#setSourceImage(byte[],%20int,%20int,%20int,%20int)">org.libjpegturbo.turbojpeg.TJCompressor.setSourceImage(byte[], int, int, int, int)</a>
+<div class="block"><i>Use
+ <a href="org/libjpegturbo/turbojpeg/TJCompressor.html#setSourceImage(byte[],%20int,%20int,%20int,%20int,%20int,%20int)"><code>TJCompressor.setSourceImage(byte[], int, int, int, int, int, int)</code></a> instead.</i></div>
+</td>
+</tr>
+</tbody>
+</table>
+</li>
+</ul>
+<a name="constructor">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<table border="0" cellpadding="3" cellspacing="0" summary="Deprecated Constructors table, listing deprecated constructors, and an explanation">
+<caption><span>Deprecated Constructors</span><span class="tabEnd">&nbsp;</span></caption>
+<tr>
+<th class="colOne" scope="col">Constructor and Description</th>
+</tr>
+<tbody>
+<tr class="altColor">
+<td class="colOne"><a href="org/libjpegturbo/turbojpeg/TJCompressor.html#TJCompressor(byte[],%20int,%20int,%20int,%20int)">org.libjpegturbo.turbojpeg.TJCompressor(byte[], int, int, int, int)</a>
+<div class="block"><i>Use
+ <a href="org/libjpegturbo/turbojpeg/TJCompressor.html#TJCompressor(byte[],%20int,%20int,%20int,%20int,%20int,%20int)"><code>TJCompressor.TJCompressor(byte[], int, int, int, int, int, int)</code></a> instead.</i></div>
+</td>
+</tr>
+</tbody>
+</table>
+</li>
+</ul>
+</div>
+<!-- ======= START OF BOTTOM NAVBAR ====== -->
+<div class="bottomNav"><a name="navbar_bottom">
+<!--   -->
+</a><a href="#skip-navbar_bottom" title="Skip navigation links"></a><a name="navbar_bottom_firstrow">
+<!--   -->
+</a>
+<ul class="navList" title="Navigation">
+<li><a href="org/libjpegturbo/turbojpeg/package-summary.html">Package</a></li>
+<li>Class</li>
+<li><a href="org/libjpegturbo/turbojpeg/package-tree.html">Tree</a></li>
+<li class="navBarCell1Rev">Deprecated</li>
+<li><a href="index-all.html">Index</a></li>
+<li><a href="help-doc.html">Help</a></li>
+</ul>
+</div>
+<div class="subNav">
+<ul class="navList">
+<li>Prev</li>
+<li>Next</li>
+</ul>
+<ul class="navList">
+<li><a href="index.html?deprecated-list.html" target="_top">Frames</a></li>
+<li><a href="deprecated-list.html" target="_top">No Frames</a></li>
+</ul>
+<ul class="navList" id="allclasses_navbar_bottom">
+<li><a href="allclasses-noframe.html">All Classes</a></li>
+</ul>
+<div>
+<script type="text/javascript"><!--
+  allClassesLink = document.getElementById("allclasses_navbar_bottom");
+  if(window==top) {
+    allClassesLink.style.display = "block";
+  }
+  else {
+    allClassesLink.style.display = "none";
+  }
+  //-->
+</script>
+</div>
+<a name="skip-navbar_bottom">
+<!--   -->
+</a></div>
+<!-- ======== END OF BOTTOM NAVBAR ======= -->
+</body>
+</html>
diff --git a/3rdparty/libjpeg/src/java/doc/help-doc.html b/3rdparty/libjpeg/src/java/doc/help-doc.html
new file mode 100644
index 00000000..6645d957
--- /dev/null
+++ b/3rdparty/libjpeg/src/java/doc/help-doc.html
@@ -0,0 +1,210 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!-- NewPage -->
+<html lang="en">
+<head>
+<title>API Help</title>
+<link rel="stylesheet" type="text/css" href="stylesheet.css" title="Style">
+</head>
+<body>
+<script type="text/javascript"><!--
+    try {
+        if (location.href.indexOf('is-external=true') == -1) {
+            parent.document.title="API Help";
+        }
+    }
+    catch(err) {
+    }
+//-->
+</script>
+<noscript>
+<div>JavaScript is disabled on your browser.</div>
+</noscript>
+<!-- ========= START OF TOP NAVBAR ======= -->
+<div class="topNav"><a name="navbar_top">
+<!--   -->
+</a><a href="#skip-navbar_top" title="Skip navigation links"></a><a name="navbar_top_firstrow">
+<!--   -->
+</a>
+<ul class="navList" title="Navigation">
+<li><a href="org/libjpegturbo/turbojpeg/package-summary.html">Package</a></li>
+<li>Class</li>
+<li><a href="org/libjpegturbo/turbojpeg/package-tree.html">Tree</a></li>
+<li><a href="deprecated-list.html">Deprecated</a></li>
+<li><a href="index-all.html">Index</a></li>
+<li class="navBarCell1Rev">Help</li>
+</ul>
+</div>
+<div class="subNav">
+<ul class="navList">
+<li>Prev</li>
+<li>Next</li>
+</ul>
+<ul class="navList">
+<li><a href="index.html?help-doc.html" target="_top">Frames</a></li>
+<li><a href="help-doc.html" target="_top">No Frames</a></li>
+</ul>
+<ul class="navList" id="allclasses_navbar_top">
+<li><a href="allclasses-noframe.html">All Classes</a></li>
+</ul>
+<div>
+<script type="text/javascript"><!--
+  allClassesLink = document.getElementById("allclasses_navbar_top");
+  if(window==top) {
+    allClassesLink.style.display = "block";
+  }
+  else {
+    allClassesLink.style.display = "none";
+  }
+  //-->
+</script>
+</div>
+<a name="skip-navbar_top">
+<!--   -->
+</a></div>
+<!-- ========= END OF TOP NAVBAR ========= -->
+<div class="header">
+<h1 class="title">How This API Document Is Organized</h1>
+<div class="subTitle">This API (Application Programming Interface) document has pages corresponding to the items in the navigation bar, described as follows.</div>
+</div>
+<div class="contentContainer">
+<ul class="blockList">
+<li class="blockList">
+<h2>Package</h2>
+<p>Each package has a page that contains a list of its classes and interfaces, with a summary for each. This page can contain six categories:</p>
+<ul>
+<li>Interfaces (italic)</li>
+<li>Classes</li>
+<li>Enums</li>
+<li>Exceptions</li>
+<li>Errors</li>
+<li>Annotation Types</li>
+</ul>
+</li>
+<li class="blockList">
+<h2>Class/Interface</h2>
+<p>Each class, interface, nested class and nested interface has its own separate page. Each of these pages has three sections consisting of a class/interface description, summary tables, and detailed member descriptions:</p>
+<ul>
+<li>Class inheritance diagram</li>
+<li>Direct Subclasses</li>
+<li>All Known Subinterfaces</li>
+<li>All Known Implementing Classes</li>
+<li>Class/interface declaration</li>
+<li>Class/interface description</li>
+</ul>
+<ul>
+<li>Nested Class Summary</li>
+<li>Field Summary</li>
+<li>Constructor Summary</li>
+<li>Method Summary</li>
+</ul>
+<ul>
+<li>Field Detail</li>
+<li>Constructor Detail</li>
+<li>Method Detail</li>
+</ul>
+<p>Each summary entry contains the first sentence from the detailed description for that item. The summary entries are alphabetical, while the detailed descriptions are in the order they appear in the source code. This preserves the logical groupings established by the programmer.</p>
+</li>
+<li class="blockList">
+<h2>Annotation Type</h2>
+<p>Each annotation type has its own separate page with the following sections:</p>
+<ul>
+<li>Annotation Type declaration</li>
+<li>Annotation Type description</li>
+<li>Required Element Summary</li>
+<li>Optional Element Summary</li>
+<li>Element Detail</li>
+</ul>
+</li>
+<li class="blockList">
+<h2>Enum</h2>
+<p>Each enum has its own separate page with the following sections:</p>
+<ul>
+<li>Enum declaration</li>
+<li>Enum description</li>
+<li>Enum Constant Summary</li>
+<li>Enum Constant Detail</li>
+</ul>
+</li>
+<li class="blockList">
+<h2>Tree (Class Hierarchy)</h2>
+<p>There is a <a href="overview-tree.html">Class Hierarchy</a> page for all packages, plus a hierarchy for each package. Each hierarchy page contains a list of classes and a list of interfaces. The classes are organized by inheritance structure starting with <code>java.lang.Object</code>. The interfaces do not inherit from <code>java.lang.Object</code>.</p>
+<ul>
+<li>When viewing the Overview page, clicking on "Tree" displays the hierarchy for all packages.</li>
+<li>When viewing a particular package, class or interface page, clicking "Tree" displays the hierarchy for only that package.</li>
+</ul>
+</li>
+<li class="blockList">
+<h2>Deprecated API</h2>
+<p>The <a href="deprecated-list.html">Deprecated API</a> page lists all of the API that have been deprecated. A deprecated API is not recommended for use, generally due to improvements, and a replacement API is usually given. Deprecated APIs may be removed in future implementations.</p>
+</li>
+<li class="blockList">
+<h2>Index</h2>
+<p>The <a href="index-all.html">Index</a> contains an alphabetic list of all classes, interfaces, constructors, methods, and fields.</p>
+</li>
+<li class="blockList">
+<h2>Prev/Next</h2>
+<p>These links take you to the next or previous class, interface, package, or related page.</p>
+</li>
+<li class="blockList">
+<h2>Frames/No Frames</h2>
+<p>These links show and hide the HTML frames.  All pages are available with or without frames.</p>
+</li>
+<li class="blockList">
+<h2>All Classes</h2>
+<p>The <a href="allclasses-noframe.html">All Classes</a> link shows all classes and interfaces except non-static nested types.</p>
+</li>
+<li class="blockList">
+<h2>Serialized Form</h2>
+<p>Each serializable or externalizable class has a description of its serialization fields and methods. This information is of interest to re-implementors, not to developers using the API. While there is no link in the navigation bar, you can get to this information by going to any serialized class and clicking "Serialized Form" in the "See also" section of the class description.</p>
+</li>
+<li class="blockList">
+<h2>Constant Field Values</h2>
+<p>The <a href="constant-values.html">Constant Field Values</a> page lists the static final fields and their values.</p>
+</li>
+</ul>
+<em>This help file applies to API documentation generated using the standard doclet.</em></div>
+<!-- ======= START OF BOTTOM NAVBAR ====== -->
+<div class="bottomNav"><a name="navbar_bottom">
+<!--   -->
+</a><a href="#skip-navbar_bottom" title="Skip navigation links"></a><a name="navbar_bottom_firstrow">
+<!--   -->
+</a>
+<ul class="navList" title="Navigation">
+<li><a href="org/libjpegturbo/turbojpeg/package-summary.html">Package</a></li>
+<li>Class</li>
+<li><a href="org/libjpegturbo/turbojpeg/package-tree.html">Tree</a></li>
+<li><a href="deprecated-list.html">Deprecated</a></li>
+<li><a href="index-all.html">Index</a></li>
+<li class="navBarCell1Rev">Help</li>
+</ul>
+</div>
+<div class="subNav">
+<ul class="navList">
+<li>Prev</li>
+<li>Next</li>
+</ul>
+<ul class="navList">
+<li><a href="index.html?help-doc.html" target="_top">Frames</a></li>
+<li><a href="help-doc.html" target="_top">No Frames</a></li>
+</ul>
+<ul class="navList" id="allclasses_navbar_bottom">
+<li><a href="allclasses-noframe.html">All Classes</a></li>
+</ul>
+<div>
+<script type="text/javascript"><!--
+  allClassesLink = document.getElementById("allclasses_navbar_bottom");
+  if(window==top) {
+    allClassesLink.style.display = "block";
+  }
+  else {
+    allClassesLink.style.display = "none";
+  }
+  //-->
+</script>
+</div>
+<a name="skip-navbar_bottom">
+<!--   -->
+</a></div>
+<!-- ======== END OF BOTTOM NAVBAR ======= -->
+</body>
+</html>
diff --git a/3rdparty/libjpeg/src/java/doc/index-all.html b/3rdparty/libjpeg/src/java/doc/index-all.html
new file mode 100644
index 00000000..366c7ea1
--- /dev/null
+++ b/3rdparty/libjpeg/src/java/doc/index-all.html
@@ -0,0 +1,1029 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!-- NewPage -->
+<html lang="en">
+<head>
+<title>Index</title>
+<link rel="stylesheet" type="text/css" href="./stylesheet.css" title="Style">
+</head>
+<body>
+<script type="text/javascript"><!--
+    try {
+        if (location.href.indexOf('is-external=true') == -1) {
+            parent.document.title="Index";
+        }
+    }
+    catch(err) {
+    }
+//-->
+</script>
+<noscript>
+<div>JavaScript is disabled on your browser.</div>
+</noscript>
+<!-- ========= START OF TOP NAVBAR ======= -->
+<div class="topNav"><a name="navbar_top">
+<!--   -->
+</a><a href="#skip-navbar_top" title="Skip navigation links"></a><a name="navbar_top_firstrow">
+<!--   -->
+</a>
+<ul class="navList" title="Navigation">
+<li><a href="./org/libjpegturbo/turbojpeg/package-summary.html">Package</a></li>
+<li>Class</li>
+<li><a href="./org/libjpegturbo/turbojpeg/package-tree.html">Tree</a></li>
+<li><a href="./deprecated-list.html">Deprecated</a></li>
+<li class="navBarCell1Rev">Index</li>
+<li><a href="./help-doc.html">Help</a></li>
+</ul>
+</div>
+<div class="subNav">
+<ul class="navList">
+<li>Prev</li>
+<li>Next</li>
+</ul>
+<ul class="navList">
+<li><a href="./index.html?index-all.html" target="_top">Frames</a></li>
+<li><a href="index-all.html" target="_top">No Frames</a></li>
+</ul>
+<ul class="navList" id="allclasses_navbar_top">
+<li><a href="./allclasses-noframe.html">All Classes</a></li>
+</ul>
+<div>
+<script type="text/javascript"><!--
+  allClassesLink = document.getElementById("allclasses_navbar_top");
+  if(window==top) {
+    allClassesLink.style.display = "block";
+  }
+  else {
+    allClassesLink.style.display = "none";
+  }
+  //-->
+</script>
+</div>
+<a name="skip-navbar_top">
+<!--   -->
+</a></div>
+<!-- ========= END OF TOP NAVBAR ========= -->
+<div class="contentContainer"><a href="#_B_">B</a>&nbsp;<a href="#_C_">C</a>&nbsp;<a href="#_D_">D</a>&nbsp;<a href="#_E_">E</a>&nbsp;<a href="#_F_">F</a>&nbsp;<a href="#_G_">G</a>&nbsp;<a href="#_H_">H</a>&nbsp;<a href="#_I_">I</a>&nbsp;<a href="#_J_">J</a>&nbsp;<a href="#_N_">N</a>&nbsp;<a href="#_O_">O</a>&nbsp;<a href="#_P_">P</a>&nbsp;<a href="#_S_">S</a>&nbsp;<a href="#_T_">T</a>&nbsp;<a href="#_Y_">Y</a>&nbsp;<a name="_B_">
+<!--   -->
+</a>
+<h2 class="title">B</h2>
+<dl>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJ.html#bufSize(int,%20int,%20int)">bufSize(int, int, int)</a></span> - Static method in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJ.html" title="class in org.libjpegturbo.turbojpeg">TJ</a></dt>
+<dd>
+<div class="block">Returns the maximum size of the buffer (in bytes) required to hold a JPEG
+ image with the given width, height, and level of chrominance subsampling.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJ.html#bufSizeYUV(int,%20int,%20int,%20int)">bufSizeYUV(int, int, int, int)</a></span> - Static method in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJ.html" title="class in org.libjpegturbo.turbojpeg">TJ</a></dt>
+<dd>
+<div class="block">Returns the size of the buffer (in bytes) required to hold a YUV planar
+ image with the given width, height, and level of chrominance subsampling.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJ.html#bufSizeYUV(int,%20int,%20int)">bufSizeYUV(int, int, int)</a></span> - Static method in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJ.html" title="class in org.libjpegturbo.turbojpeg">TJ</a></dt>
+<dd>
+<div class="block"><span class="strong">Deprecated.</span>
+<div class="block"><i>Use <a href="./org/libjpegturbo/turbojpeg/TJ.html#bufSizeYUV(int,%20int,%20int,%20int)"><code>TJ.bufSizeYUV(int, int, int, int)</code></a> instead.</i></div>
+</div>
+</dd>
+</dl>
+<a name="_C_">
+<!--   -->
+</a>
+<h2 class="title">C</h2>
+<dl>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJTransform.html#cf">cf</a></span> - Variable in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJTransform.html" title="class in org.libjpegturbo.turbojpeg">TJTransform</a></dt>
+<dd>
+<div class="block">Custom filter instance</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJCompressor.html#close()">close()</a></span> - Method in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJCompressor.html" title="class in org.libjpegturbo.turbojpeg">TJCompressor</a></dt>
+<dd>
+<div class="block">Free the native structures associated with this compressor instance.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJDecompressor.html#close()">close()</a></span> - Method in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJDecompressor.html" title="class in org.libjpegturbo.turbojpeg">TJDecompressor</a></dt>
+<dd>
+<div class="block">Free the native structures associated with this decompressor instance.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJCompressor.html#compress(byte[],%20int)">compress(byte[], int)</a></span> - Method in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJCompressor.html" title="class in org.libjpegturbo.turbojpeg">TJCompressor</a></dt>
+<dd>
+<div class="block">Compress the uncompressed source image associated with this compressor
+ instance and output a JPEG image to the given destination buffer.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJCompressor.html#compress(int)">compress(int)</a></span> - Method in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJCompressor.html" title="class in org.libjpegturbo.turbojpeg">TJCompressor</a></dt>
+<dd>
+<div class="block">Compress the uncompressed source image associated with this compressor
+ instance and return a buffer containing a JPEG image.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJCompressor.html#compress(java.awt.image.BufferedImage,%20byte[],%20int)">compress(BufferedImage, byte[], int)</a></span> - Method in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJCompressor.html" title="class in org.libjpegturbo.turbojpeg">TJCompressor</a></dt>
+<dd>
+<div class="block"><span class="strong">Deprecated.</span>
+<div class="block"><i>Use
+ <a href="./org/libjpegturbo/turbojpeg/TJCompressor.html#setSourceImage(java.awt.image.BufferedImage,%20int,%20int,%20int,%20int)"><code>TJCompressor.setSourceImage(BufferedImage, int, int, int, int)</code></a> and
+ <a href="./org/libjpegturbo/turbojpeg/TJCompressor.html#compress(byte[],%20int)"><code>TJCompressor.compress(byte[], int)</code></a> instead.</i></div>
+</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJCompressor.html#compress(java.awt.image.BufferedImage,%20int)">compress(BufferedImage, int)</a></span> - Method in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJCompressor.html" title="class in org.libjpegturbo.turbojpeg">TJCompressor</a></dt>
+<dd>
+<div class="block"><span class="strong">Deprecated.</span>
+<div class="block"><i>Use
+ <a href="./org/libjpegturbo/turbojpeg/TJCompressor.html#setSourceImage(java.awt.image.BufferedImage,%20int,%20int,%20int,%20int)"><code>TJCompressor.setSourceImage(BufferedImage, int, int, int, int)</code></a> and
+ <a href="./org/libjpegturbo/turbojpeg/TJCompressor.html#compress(int)"><code>TJCompressor.compress(int)</code></a> instead.</i></div>
+</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJ.html#CS_CMYK">CS_CMYK</a></span> - Static variable in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJ.html" title="class in org.libjpegturbo.turbojpeg">TJ</a></dt>
+<dd>
+<div class="block">CMYK colorspace.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJ.html#CS_GRAY">CS_GRAY</a></span> - Static variable in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJ.html" title="class in org.libjpegturbo.turbojpeg">TJ</a></dt>
+<dd>
+<div class="block">Grayscale colorspace.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJ.html#CS_RGB">CS_RGB</a></span> - Static variable in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJ.html" title="class in org.libjpegturbo.turbojpeg">TJ</a></dt>
+<dd>
+<div class="block">RGB colorspace.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJ.html#CS_YCbCr">CS_YCbCr</a></span> - Static variable in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJ.html" title="class in org.libjpegturbo.turbojpeg">TJ</a></dt>
+<dd>
+<div class="block">YCbCr colorspace.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJ.html#CS_YCCK">CS_YCCK</a></span> - Static variable in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJ.html" title="class in org.libjpegturbo.turbojpeg">TJ</a></dt>
+<dd>
+<div class="block">YCCK colorspace.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJCustomFilter.html#customFilter(java.nio.ShortBuffer,%20java.awt.Rectangle,%20java.awt.Rectangle,%20int,%20int,%20org.libjpegturbo.turbojpeg.TJTransform)">customFilter(ShortBuffer, Rectangle, Rectangle, int, int, TJTransform)</a></span> - Method in interface org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJCustomFilter.html" title="interface in org.libjpegturbo.turbojpeg">TJCustomFilter</a></dt>
+<dd>
+<div class="block">A callback function that can be used to modify the DCT coefficients after
+ they are losslessly transformed but before they are transcoded to a new
+ JPEG image.</div>
+</dd>
+</dl>
+<a name="_D_">
+<!--   -->
+</a>
+<h2 class="title">D</h2>
+<dl>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJDecompressor.html#decompress(byte[],%20int,%20int,%20int,%20int,%20int,%20int,%20int)">decompress(byte[], int, int, int, int, int, int, int)</a></span> - Method in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJDecompressor.html" title="class in org.libjpegturbo.turbojpeg">TJDecompressor</a></dt>
+<dd>
+<div class="block">Decompress the JPEG source image or decode the YUV source image associated
+ with this decompressor instance and output a grayscale, RGB, or CMYK image
+ to the given destination buffer.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJDecompressor.html#decompress(byte[],%20int,%20int,%20int,%20int,%20int)">decompress(byte[], int, int, int, int, int)</a></span> - Method in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJDecompressor.html" title="class in org.libjpegturbo.turbojpeg">TJDecompressor</a></dt>
+<dd>
+<div class="block"><span class="strong">Deprecated.</span>
+<div class="block"><i>Use
+ <a href="./org/libjpegturbo/turbojpeg/TJDecompressor.html#decompress(byte[],%20int,%20int,%20int,%20int,%20int,%20int,%20int)"><code>TJDecompressor.decompress(byte[], int, int, int, int, int, int, int)</code></a> instead.</i></div>
+</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJDecompressor.html#decompress(int,%20int,%20int,%20int,%20int)">decompress(int, int, int, int, int)</a></span> - Method in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJDecompressor.html" title="class in org.libjpegturbo.turbojpeg">TJDecompressor</a></dt>
+<dd>
+<div class="block">Decompress the JPEG source image associated with this decompressor
+ instance and return a buffer containing the decompressed image.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJDecompressor.html#decompress(int[],%20int,%20int,%20int,%20int,%20int,%20int,%20int)">decompress(int[], int, int, int, int, int, int, int)</a></span> - Method in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJDecompressor.html" title="class in org.libjpegturbo.turbojpeg">TJDecompressor</a></dt>
+<dd>
+<div class="block">Decompress the JPEG source image or decode the YUV source image associated
+ with this decompressor instance and output a grayscale, RGB, or CMYK image
+ to the given destination buffer.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJDecompressor.html#decompress(java.awt.image.BufferedImage,%20int)">decompress(BufferedImage, int)</a></span> - Method in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJDecompressor.html" title="class in org.libjpegturbo.turbojpeg">TJDecompressor</a></dt>
+<dd>
+<div class="block">Decompress the JPEG source image or decode the YUV source image associated
+ with this decompressor instance and output a decompressed/decoded image to
+ the given <code>BufferedImage</code> instance.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJDecompressor.html#decompress(int,%20int,%20int,%20int)">decompress(int, int, int, int)</a></span> - Method in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJDecompressor.html" title="class in org.libjpegturbo.turbojpeg">TJDecompressor</a></dt>
+<dd>
+<div class="block">Decompress the JPEG source image or decode the YUV source image associated
+ with this decompressor instance and return a <code>BufferedImage</code>
+ instance containing the decompressed/decoded image.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJDecompressor.html#decompressToYUV(org.libjpegturbo.turbojpeg.YUVImage,%20int)">decompressToYUV(YUVImage, int)</a></span> - Method in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJDecompressor.html" title="class in org.libjpegturbo.turbojpeg">TJDecompressor</a></dt>
+<dd>
+<div class="block">Decompress the JPEG source image associated with this decompressor
+ instance into a YUV planar image and store it in the given
+ <code>YUVImage</code> instance.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJDecompressor.html#decompressToYUV(byte[],%20int)">decompressToYUV(byte[], int)</a></span> - Method in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJDecompressor.html" title="class in org.libjpegturbo.turbojpeg">TJDecompressor</a></dt>
+<dd>
+<div class="block"><span class="strong">Deprecated.</span>
+<div class="block"><i>Use <a href="./org/libjpegturbo/turbojpeg/TJDecompressor.html#decompressToYUV(org.libjpegturbo.turbojpeg.YUVImage,%20int)"><code>TJDecompressor.decompressToYUV(YUVImage, int)</code></a> instead.</i></div>
+</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJDecompressor.html#decompressToYUV(int,%20int[],%20int,%20int)">decompressToYUV(int, int[], int, int)</a></span> - Method in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJDecompressor.html" title="class in org.libjpegturbo.turbojpeg">TJDecompressor</a></dt>
+<dd>
+<div class="block">Decompress the JPEG source image associated with this decompressor
+ instance into a set of Y, U (Cb), and V (Cr) image planes and return a
+ <code>YUVImage</code> instance containing the decompressed image planes.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJDecompressor.html#decompressToYUV(int,%20int,%20int,%20int)">decompressToYUV(int, int, int, int)</a></span> - Method in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJDecompressor.html" title="class in org.libjpegturbo.turbojpeg">TJDecompressor</a></dt>
+<dd>
+<div class="block">Decompress the JPEG source image associated with this decompressor
+ instance into a unified YUV planar image buffer and return a
+ <code>YUVImage</code> instance containing the decompressed image.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJDecompressor.html#decompressToYUV(int)">decompressToYUV(int)</a></span> - Method in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJDecompressor.html" title="class in org.libjpegturbo.turbojpeg">TJDecompressor</a></dt>
+<dd>
+<div class="block"><span class="strong">Deprecated.</span>
+<div class="block"><i>Use <a href="./org/libjpegturbo/turbojpeg/TJDecompressor.html#decompressToYUV(int,%20int,%20int,%20int)"><code>TJDecompressor.decompressToYUV(int, int, int, int)</code></a> instead.</i></div>
+</div>
+</dd>
+</dl>
+<a name="_E_">
+<!--   -->
+</a>
+<h2 class="title">E</h2>
+<dl>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJCompressor.html#encodeYUV(org.libjpegturbo.turbojpeg.YUVImage,%20int)">encodeYUV(YUVImage, int)</a></span> - Method in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJCompressor.html" title="class in org.libjpegturbo.turbojpeg">TJCompressor</a></dt>
+<dd>
+<div class="block">Encode the uncompressed source image associated with this compressor
+ instance into a YUV planar image and store it in the given
+ <code>YUVImage</code> instance.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJCompressor.html#encodeYUV(byte[],%20int)">encodeYUV(byte[], int)</a></span> - Method in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJCompressor.html" title="class in org.libjpegturbo.turbojpeg">TJCompressor</a></dt>
+<dd>
+<div class="block"><span class="strong">Deprecated.</span>
+<div class="block"><i>Use <a href="./org/libjpegturbo/turbojpeg/TJCompressor.html#encodeYUV(org.libjpegturbo.turbojpeg.YUVImage,%20int)"><code>TJCompressor.encodeYUV(YUVImage, int)</code></a> instead.</i></div>
+</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJCompressor.html#encodeYUV(int,%20int)">encodeYUV(int, int)</a></span> - Method in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJCompressor.html" title="class in org.libjpegturbo.turbojpeg">TJCompressor</a></dt>
+<dd>
+<div class="block">Encode the uncompressed source image associated with this compressor
+ instance into a unified YUV planar image buffer and return a
+ <code>YUVImage</code> instance containing the encoded image.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJCompressor.html#encodeYUV(int[],%20int)">encodeYUV(int[], int)</a></span> - Method in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJCompressor.html" title="class in org.libjpegturbo.turbojpeg">TJCompressor</a></dt>
+<dd>
+<div class="block">Encode the uncompressed source image associated with this compressor
+ instance into separate Y, U (Cb), and V (Cr) image planes and return a
+ <code>YUVImage</code> instance containing the encoded image planes.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJCompressor.html#encodeYUV(int)">encodeYUV(int)</a></span> - Method in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJCompressor.html" title="class in org.libjpegturbo.turbojpeg">TJCompressor</a></dt>
+<dd>
+<div class="block"><span class="strong">Deprecated.</span>
+<div class="block"><i>Use <a href="./org/libjpegturbo/turbojpeg/TJCompressor.html#encodeYUV(int,%20int)"><code>TJCompressor.encodeYUV(int, int)</code></a> instead.</i></div>
+</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJCompressor.html#encodeYUV(java.awt.image.BufferedImage,%20byte[],%20int)">encodeYUV(BufferedImage, byte[], int)</a></span> - Method in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJCompressor.html" title="class in org.libjpegturbo.turbojpeg">TJCompressor</a></dt>
+<dd>
+<div class="block"><span class="strong">Deprecated.</span>
+<div class="block"><i>Use
+ <a href="./org/libjpegturbo/turbojpeg/TJCompressor.html#setSourceImage(java.awt.image.BufferedImage,%20int,%20int,%20int,%20int)"><code>TJCompressor.setSourceImage(BufferedImage, int, int, int, int)</code></a> and
+ <a href="./org/libjpegturbo/turbojpeg/TJCompressor.html#encodeYUV(byte[],%20int)"><code>TJCompressor.encodeYUV(byte[], int)</code></a> instead.</i></div>
+</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJCompressor.html#encodeYUV(java.awt.image.BufferedImage,%20int)">encodeYUV(BufferedImage, int)</a></span> - Method in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJCompressor.html" title="class in org.libjpegturbo.turbojpeg">TJCompressor</a></dt>
+<dd>
+<div class="block"><span class="strong">Deprecated.</span>
+<div class="block"><i>Use
+ <a href="./org/libjpegturbo/turbojpeg/TJCompressor.html#setSourceImage(java.awt.image.BufferedImage,%20int,%20int,%20int,%20int)"><code>TJCompressor.setSourceImage(BufferedImage, int, int, int, int)</code></a> and
+ <a href="./org/libjpegturbo/turbojpeg/TJCompressor.html#encodeYUV(int,%20int)"><code>TJCompressor.encodeYUV(int, int)</code></a> instead.</i></div>
+</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJScalingFactor.html#equals(org.libjpegturbo.turbojpeg.TJScalingFactor)">equals(TJScalingFactor)</a></span> - Method in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJScalingFactor.html" title="class in org.libjpegturbo.turbojpeg">TJScalingFactor</a></dt>
+<dd>
+<div class="block">Returns true or false, depending on whether this instance and
+ <code>other</code> have the same numerator and denominator.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJ.html#ERR_FATAL">ERR_FATAL</a></span> - Static variable in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJ.html" title="class in org.libjpegturbo.turbojpeg">TJ</a></dt>
+<dd>
+<div class="block">The error was fatal and non-recoverable.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJ.html#ERR_WARNING">ERR_WARNING</a></span> - Static variable in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJ.html" title="class in org.libjpegturbo.turbojpeg">TJ</a></dt>
+<dd>
+<div class="block">The error was non-fatal and recoverable, but the image may still be
+ corrupt.</div>
+</dd>
+</dl>
+<a name="_F_">
+<!--   -->
+</a>
+<h2 class="title">F</h2>
+<dl>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJCompressor.html#finalize()">finalize()</a></span> - Method in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJCompressor.html" title="class in org.libjpegturbo.turbojpeg">TJCompressor</a></dt>
+<dd>&nbsp;</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJDecompressor.html#finalize()">finalize()</a></span> - Method in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJDecompressor.html" title="class in org.libjpegturbo.turbojpeg">TJDecompressor</a></dt>
+<dd>&nbsp;</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJ.html#FLAG_ACCURATEDCT">FLAG_ACCURATEDCT</a></span> - Static variable in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJ.html" title="class in org.libjpegturbo.turbojpeg">TJ</a></dt>
+<dd>
+<div class="block">Use the most accurate DCT/IDCT algorithm available in the underlying
+ codec.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJ.html#FLAG_BOTTOMUP">FLAG_BOTTOMUP</a></span> - Static variable in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJ.html" title="class in org.libjpegturbo.turbojpeg">TJ</a></dt>
+<dd>
+<div class="block">The uncompressed source/destination image is stored in bottom-up (Windows,
+ OpenGL) order, not top-down (X11) order.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJ.html#FLAG_FASTDCT">FLAG_FASTDCT</a></span> - Static variable in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJ.html" title="class in org.libjpegturbo.turbojpeg">TJ</a></dt>
+<dd>
+<div class="block">Use the fastest DCT/IDCT algorithm available in the underlying codec.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJ.html#FLAG_FASTUPSAMPLE">FLAG_FASTUPSAMPLE</a></span> - Static variable in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJ.html" title="class in org.libjpegturbo.turbojpeg">TJ</a></dt>
+<dd>
+<div class="block">When decompressing an image that was compressed using chrominance
+ subsampling, use the fastest chrominance upsampling algorithm available in
+ the underlying codec.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJ.html#FLAG_FORCEMMX">FLAG_FORCEMMX</a></span> - Static variable in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJ.html" title="class in org.libjpegturbo.turbojpeg">TJ</a></dt>
+<dd>
+<div class="block"><span class="strong">Deprecated.</span></div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJ.html#FLAG_FORCESSE">FLAG_FORCESSE</a></span> - Static variable in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJ.html" title="class in org.libjpegturbo.turbojpeg">TJ</a></dt>
+<dd>
+<div class="block"><span class="strong">Deprecated.</span></div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJ.html#FLAG_FORCESSE2">FLAG_FORCESSE2</a></span> - Static variable in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJ.html" title="class in org.libjpegturbo.turbojpeg">TJ</a></dt>
+<dd>
+<div class="block"><span class="strong">Deprecated.</span></div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJ.html#FLAG_FORCESSE3">FLAG_FORCESSE3</a></span> - Static variable in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJ.html" title="class in org.libjpegturbo.turbojpeg">TJ</a></dt>
+<dd>
+<div class="block"><span class="strong">Deprecated.</span></div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJ.html#FLAG_PROGRESSIVE">FLAG_PROGRESSIVE</a></span> - Static variable in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJ.html" title="class in org.libjpegturbo.turbojpeg">TJ</a></dt>
+<dd>
+<div class="block">Use progressive entropy coding in JPEG images generated by compression and
+ transform operations.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJ.html#FLAG_STOPONWARNING">FLAG_STOPONWARNING</a></span> - Static variable in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJ.html" title="class in org.libjpegturbo.turbojpeg">TJ</a></dt>
+<dd>
+<div class="block">Immediately discontinue the current compression/decompression/transform
+ operation if the underlying codec throws a warning (non-fatal error).</div>
+</dd>
+</dl>
+<a name="_G_">
+<!--   -->
+</a>
+<h2 class="title">G</h2>
+<dl>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJ.html#getAlphaOffset(int)">getAlphaOffset(int)</a></span> - Static method in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJ.html" title="class in org.libjpegturbo.turbojpeg">TJ</a></dt>
+<dd>
+<div class="block">For the given pixel format, returns the number of bytes that the alpha
+ component is offset from the start of the pixel.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJ.html#getBlueOffset(int)">getBlueOffset(int)</a></span> - Static method in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJ.html" title="class in org.libjpegturbo.turbojpeg">TJ</a></dt>
+<dd>
+<div class="block">For the given pixel format, returns the number of bytes that the blue
+ component is offset from the start of the pixel.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/YUVImage.html#getBuf()">getBuf()</a></span> - Method in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/YUVImage.html" title="class in org.libjpegturbo.turbojpeg">YUVImage</a></dt>
+<dd>
+<div class="block">Returns the YUV image buffer (if this image is stored in a unified
+ buffer rather than separate image planes.)</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJDecompressor.html#getColorspace()">getColorspace()</a></span> - Method in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJDecompressor.html" title="class in org.libjpegturbo.turbojpeg">TJDecompressor</a></dt>
+<dd>
+<div class="block">Returns the colorspace used in the source image (JPEG or YUV) associated
+ with this decompressor instance.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJCompressor.html#getCompressedSize()">getCompressedSize()</a></span> - Method in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJCompressor.html" title="class in org.libjpegturbo.turbojpeg">TJCompressor</a></dt>
+<dd>
+<div class="block">Returns the size of the image (in bytes) generated by the most recent
+ compress operation.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJScalingFactor.html#getDenom()">getDenom()</a></span> - Method in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJScalingFactor.html" title="class in org.libjpegturbo.turbojpeg">TJScalingFactor</a></dt>
+<dd>
+<div class="block">Returns denominator</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJException.html#getErrorCode()">getErrorCode()</a></span> - Method in exception org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></dt>
+<dd>
+<div class="block">Returns a code (one of <a href="./org/libjpegturbo/turbojpeg/TJ.html" title="class in org.libjpegturbo.turbojpeg"><code>TJ.ERR_*</code></a>) indicating the severity of the
+ last error.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJ.html#getGreenOffset(int)">getGreenOffset(int)</a></span> - Static method in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJ.html" title="class in org.libjpegturbo.turbojpeg">TJ</a></dt>
+<dd>
+<div class="block">For the given pixel format, returns the number of bytes that the green
+ component is offset from the start of the pixel.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJDecompressor.html#getHeight()">getHeight()</a></span> - Method in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJDecompressor.html" title="class in org.libjpegturbo.turbojpeg">TJDecompressor</a></dt>
+<dd>
+<div class="block">Returns the height of the source image (JPEG or YUV) associated with this
+ decompressor instance.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/YUVImage.html#getHeight()">getHeight()</a></span> - Method in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/YUVImage.html" title="class in org.libjpegturbo.turbojpeg">YUVImage</a></dt>
+<dd>
+<div class="block">Returns the height of the YUV image (or subregion.)</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJDecompressor.html#getJPEGBuf()">getJPEGBuf()</a></span> - Method in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJDecompressor.html" title="class in org.libjpegturbo.turbojpeg">TJDecompressor</a></dt>
+<dd>
+<div class="block">Returns the JPEG image buffer associated with this decompressor instance.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJDecompressor.html#getJPEGSize()">getJPEGSize()</a></span> - Method in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJDecompressor.html" title="class in org.libjpegturbo.turbojpeg">TJDecompressor</a></dt>
+<dd>
+<div class="block">Returns the size of the JPEG image (in bytes) associated with this
+ decompressor instance.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJ.html#getMCUHeight(int)">getMCUHeight(int)</a></span> - Static method in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJ.html" title="class in org.libjpegturbo.turbojpeg">TJ</a></dt>
+<dd>
+<div class="block">Returns the MCU block height for the given level of chrominance
+ subsampling.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJ.html#getMCUWidth(int)">getMCUWidth(int)</a></span> - Static method in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJ.html" title="class in org.libjpegturbo.turbojpeg">TJ</a></dt>
+<dd>
+<div class="block">Returns the MCU block width for the given level of chrominance
+ subsampling.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJScalingFactor.html#getNum()">getNum()</a></span> - Method in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJScalingFactor.html" title="class in org.libjpegturbo.turbojpeg">TJScalingFactor</a></dt>
+<dd>
+<div class="block">Returns numerator</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/YUVImage.html#getOffsets()">getOffsets()</a></span> - Method in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/YUVImage.html" title="class in org.libjpegturbo.turbojpeg">YUVImage</a></dt>
+<dd>
+<div class="block">Returns the offsets (in bytes) of each plane within the planes of a larger
+ YUV image.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/YUVImage.html#getPad()">getPad()</a></span> - Method in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/YUVImage.html" title="class in org.libjpegturbo.turbojpeg">YUVImage</a></dt>
+<dd>
+<div class="block">Returns the line padding used in the YUV image buffer (if this image is
+ stored in a unified buffer rather than separate image planes.)</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJ.html#getPixelSize(int)">getPixelSize(int)</a></span> - Static method in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJ.html" title="class in org.libjpegturbo.turbojpeg">TJ</a></dt>
+<dd>
+<div class="block">Returns the pixel size (in bytes) for the given pixel format.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/YUVImage.html#getPlanes()">getPlanes()</a></span> - Method in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/YUVImage.html" title="class in org.libjpegturbo.turbojpeg">YUVImage</a></dt>
+<dd>
+<div class="block">Returns the YUV image planes.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJ.html#getRedOffset(int)">getRedOffset(int)</a></span> - Static method in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJ.html" title="class in org.libjpegturbo.turbojpeg">TJ</a></dt>
+<dd>
+<div class="block">For the given pixel format, returns the number of bytes that the red
+ component is offset from the start of the pixel.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJScalingFactor.html#getScaled(int)">getScaled(int)</a></span> - Method in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJScalingFactor.html" title="class in org.libjpegturbo.turbojpeg">TJScalingFactor</a></dt>
+<dd>
+<div class="block">Returns the scaled value of <code>dimension</code>.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJDecompressor.html#getScaledHeight(int,%20int)">getScaledHeight(int, int)</a></span> - Method in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJDecompressor.html" title="class in org.libjpegturbo.turbojpeg">TJDecompressor</a></dt>
+<dd>
+<div class="block">Returns the height of the largest scaled-down image that the TurboJPEG
+ decompressor can generate without exceeding the desired image width and
+ height.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJDecompressor.html#getScaledWidth(int,%20int)">getScaledWidth(int, int)</a></span> - Method in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJDecompressor.html" title="class in org.libjpegturbo.turbojpeg">TJDecompressor</a></dt>
+<dd>
+<div class="block">Returns the width of the largest scaled-down image that the TurboJPEG
+ decompressor can generate without exceeding the desired image width and
+ height.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJ.html#getScalingFactors()">getScalingFactors()</a></span> - Static method in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJ.html" title="class in org.libjpegturbo.turbojpeg">TJ</a></dt>
+<dd>
+<div class="block">Returns a list of fractional scaling factors that the JPEG decompressor in
+ this implementation of TurboJPEG supports.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/YUVImage.html#getSize()">getSize()</a></span> - Method in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/YUVImage.html" title="class in org.libjpegturbo.turbojpeg">YUVImage</a></dt>
+<dd>
+<div class="block">Returns the size (in bytes) of the YUV image buffer (if this image is
+ stored in a unified buffer rather than separate image planes.)</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/YUVImage.html#getStrides()">getStrides()</a></span> - Method in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/YUVImage.html" title="class in org.libjpegturbo.turbojpeg">YUVImage</a></dt>
+<dd>
+<div class="block">Returns the number of bytes per line of each plane in the YUV image.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJDecompressor.html#getSubsamp()">getSubsamp()</a></span> - Method in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJDecompressor.html" title="class in org.libjpegturbo.turbojpeg">TJDecompressor</a></dt>
+<dd>
+<div class="block">Returns the level of chrominance subsampling used in the source image
+ (JPEG or YUV) associated with this decompressor instance.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/YUVImage.html#getSubsamp()">getSubsamp()</a></span> - Method in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/YUVImage.html" title="class in org.libjpegturbo.turbojpeg">YUVImage</a></dt>
+<dd>
+<div class="block">Returns the level of chrominance subsampling used in the YUV image.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJTransformer.html#getTransformedSizes()">getTransformedSizes()</a></span> - Method in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJTransformer.html" title="class in org.libjpegturbo.turbojpeg">TJTransformer</a></dt>
+<dd>
+<div class="block">Returns an array containing the sizes of the transformed JPEG images
+ generated by the most recent transform operation.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJDecompressor.html#getWidth()">getWidth()</a></span> - Method in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJDecompressor.html" title="class in org.libjpegturbo.turbojpeg">TJDecompressor</a></dt>
+<dd>
+<div class="block">Returns the width of the source image (JPEG or YUV) associated with this
+ decompressor instance.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/YUVImage.html#getWidth()">getWidth()</a></span> - Method in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/YUVImage.html" title="class in org.libjpegturbo.turbojpeg">YUVImage</a></dt>
+<dd>
+<div class="block">Returns the width of the YUV image (or subregion.)</div>
+</dd>
+</dl>
+<a name="_H_">
+<!--   -->
+</a>
+<h2 class="title">H</h2>
+<dl>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJDecompressor.html#handle">handle</a></span> - Variable in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJDecompressor.html" title="class in org.libjpegturbo.turbojpeg">TJDecompressor</a></dt>
+<dd>&nbsp;</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/YUVImage.html#handle">handle</a></span> - Variable in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/YUVImage.html" title="class in org.libjpegturbo.turbojpeg">YUVImage</a></dt>
+<dd>&nbsp;</dd>
+</dl>
+<a name="_I_">
+<!--   -->
+</a>
+<h2 class="title">I</h2>
+<dl>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJScalingFactor.html#isOne()">isOne()</a></span> - Method in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJScalingFactor.html" title="class in org.libjpegturbo.turbojpeg">TJScalingFactor</a></dt>
+<dd>
+<div class="block">Returns true or false, depending on whether this instance is equal to
+ 1/1.</div>
+</dd>
+</dl>
+<a name="_J_">
+<!--   -->
+</a>
+<h2 class="title">J</h2>
+<dl>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJDecompressor.html#jpegBuf">jpegBuf</a></span> - Variable in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJDecompressor.html" title="class in org.libjpegturbo.turbojpeg">TJDecompressor</a></dt>
+<dd>&nbsp;</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJDecompressor.html#jpegBufSize">jpegBufSize</a></span> - Variable in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJDecompressor.html" title="class in org.libjpegturbo.turbojpeg">TJDecompressor</a></dt>
+<dd>&nbsp;</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJDecompressor.html#jpegColorspace">jpegColorspace</a></span> - Variable in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJDecompressor.html" title="class in org.libjpegturbo.turbojpeg">TJDecompressor</a></dt>
+<dd>&nbsp;</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJDecompressor.html#jpegHeight">jpegHeight</a></span> - Variable in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJDecompressor.html" title="class in org.libjpegturbo.turbojpeg">TJDecompressor</a></dt>
+<dd>&nbsp;</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJDecompressor.html#jpegSubsamp">jpegSubsamp</a></span> - Variable in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJDecompressor.html" title="class in org.libjpegturbo.turbojpeg">TJDecompressor</a></dt>
+<dd>&nbsp;</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJDecompressor.html#jpegWidth">jpegWidth</a></span> - Variable in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJDecompressor.html" title="class in org.libjpegturbo.turbojpeg">TJDecompressor</a></dt>
+<dd>&nbsp;</dd>
+</dl>
+<a name="_N_">
+<!--   -->
+</a>
+<h2 class="title">N</h2>
+<dl>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJ.html#NUMCS">NUMCS</a></span> - Static variable in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJ.html" title="class in org.libjpegturbo.turbojpeg">TJ</a></dt>
+<dd>
+<div class="block">The number of JPEG colorspaces</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJ.html#NUMERR">NUMERR</a></span> - Static variable in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJ.html" title="class in org.libjpegturbo.turbojpeg">TJ</a></dt>
+<dd>
+<div class="block">The number of error codes</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJTransform.html#NUMOP">NUMOP</a></span> - Static variable in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJTransform.html" title="class in org.libjpegturbo.turbojpeg">TJTransform</a></dt>
+<dd>
+<div class="block">The number of lossless transform operations</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJ.html#NUMPF">NUMPF</a></span> - Static variable in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJ.html" title="class in org.libjpegturbo.turbojpeg">TJ</a></dt>
+<dd>
+<div class="block">The number of pixel formats</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJ.html#NUMSAMP">NUMSAMP</a></span> - Static variable in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJ.html" title="class in org.libjpegturbo.turbojpeg">TJ</a></dt>
+<dd>
+<div class="block">The number of chrominance subsampling options</div>
+</dd>
+</dl>
+<a name="_O_">
+<!--   -->
+</a>
+<h2 class="title">O</h2>
+<dl>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJTransform.html#op">op</a></span> - Variable in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJTransform.html" title="class in org.libjpegturbo.turbojpeg">TJTransform</a></dt>
+<dd>
+<div class="block">Transform operation (one of <code>OP_*</code>)</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJTransform.html#OP_HFLIP">OP_HFLIP</a></span> - Static variable in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJTransform.html" title="class in org.libjpegturbo.turbojpeg">TJTransform</a></dt>
+<dd>
+<div class="block">Flip (mirror) image horizontally.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJTransform.html#OP_NONE">OP_NONE</a></span> - Static variable in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJTransform.html" title="class in org.libjpegturbo.turbojpeg">TJTransform</a></dt>
+<dd>
+<div class="block">Do not transform the position of the image pixels.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJTransform.html#OP_ROT180">OP_ROT180</a></span> - Static variable in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJTransform.html" title="class in org.libjpegturbo.turbojpeg">TJTransform</a></dt>
+<dd>
+<div class="block">Rotate image 180 degrees.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJTransform.html#OP_ROT270">OP_ROT270</a></span> - Static variable in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJTransform.html" title="class in org.libjpegturbo.turbojpeg">TJTransform</a></dt>
+<dd>
+<div class="block">Rotate image counter-clockwise by 90 degrees.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJTransform.html#OP_ROT90">OP_ROT90</a></span> - Static variable in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJTransform.html" title="class in org.libjpegturbo.turbojpeg">TJTransform</a></dt>
+<dd>
+<div class="block">Rotate image clockwise by 90 degrees.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJTransform.html#OP_TRANSPOSE">OP_TRANSPOSE</a></span> - Static variable in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJTransform.html" title="class in org.libjpegturbo.turbojpeg">TJTransform</a></dt>
+<dd>
+<div class="block">Transpose image (flip/mirror along upper left to lower right axis).</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJTransform.html#OP_TRANSVERSE">OP_TRANSVERSE</a></span> - Static variable in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJTransform.html" title="class in org.libjpegturbo.turbojpeg">TJTransform</a></dt>
+<dd>
+<div class="block">Transverse transpose image (flip/mirror along upper right to lower left
+ axis).</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJTransform.html#OP_VFLIP">OP_VFLIP</a></span> - Static variable in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJTransform.html" title="class in org.libjpegturbo.turbojpeg">TJTransform</a></dt>
+<dd>
+<div class="block">Flip (mirror) image vertically.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJTransform.html#OPT_COPYNONE">OPT_COPYNONE</a></span> - Static variable in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJTransform.html" title="class in org.libjpegturbo.turbojpeg">TJTransform</a></dt>
+<dd>
+<div class="block">This option will prevent <a href="./org/libjpegturbo/turbojpeg/TJTransformer.html#transform(byte[][],%20org.libjpegturbo.turbojpeg.TJTransform[],%20int)"><code>TJTransformer.transform()</code></a> from copying any extra markers (including EXIF
+ and ICC profile data) from the source image to the output image.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJTransform.html#OPT_CROP">OPT_CROP</a></span> - Static variable in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJTransform.html" title="class in org.libjpegturbo.turbojpeg">TJTransform</a></dt>
+<dd>
+<div class="block">This option will enable lossless cropping.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJTransform.html#OPT_GRAY">OPT_GRAY</a></span> - Static variable in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJTransform.html" title="class in org.libjpegturbo.turbojpeg">TJTransform</a></dt>
+<dd>
+<div class="block">This option will discard the color data in the input image and produce
+ a grayscale output image.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJTransform.html#OPT_NOOUTPUT">OPT_NOOUTPUT</a></span> - Static variable in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJTransform.html" title="class in org.libjpegturbo.turbojpeg">TJTransform</a></dt>
+<dd>
+<div class="block">This option will prevent <a href="./org/libjpegturbo/turbojpeg/TJTransformer.html#transform(byte[][],%20org.libjpegturbo.turbojpeg.TJTransform[],%20int)"><code>TJTransformer.transform()</code></a> from outputting a JPEG image for this
+ particular transform.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJTransform.html#OPT_PERFECT">OPT_PERFECT</a></span> - Static variable in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJTransform.html" title="class in org.libjpegturbo.turbojpeg">TJTransform</a></dt>
+<dd>
+<div class="block">This option will cause <a href="./org/libjpegturbo/turbojpeg/TJTransformer.html#transform(byte[][],%20org.libjpegturbo.turbojpeg.TJTransform[],%20int)"><code>TJTransformer.transform()</code></a> to throw an exception if the transform is not
+ perfect.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJTransform.html#OPT_PROGRESSIVE">OPT_PROGRESSIVE</a></span> - Static variable in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJTransform.html" title="class in org.libjpegturbo.turbojpeg">TJTransform</a></dt>
+<dd>
+<div class="block">This option will enable progressive entropy coding in the output image
+ generated by this particular transform.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJTransform.html#OPT_TRIM">OPT_TRIM</a></span> - Static variable in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJTransform.html" title="class in org.libjpegturbo.turbojpeg">TJTransform</a></dt>
+<dd>
+<div class="block">This option will discard any partial MCU blocks that cannot be
+ transformed.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJTransform.html#options">options</a></span> - Variable in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJTransform.html" title="class in org.libjpegturbo.turbojpeg">TJTransform</a></dt>
+<dd>
+<div class="block">Transform options (bitwise OR of one or more of <code>OPT_*</code>)</div>
+</dd>
+<dt><a href="./org/libjpegturbo/turbojpeg/package-summary.html">org.libjpegturbo.turbojpeg</a> - package org.libjpegturbo.turbojpeg</dt>
+<dd>&nbsp;</dd>
+</dl>
+<a name="_P_">
+<!--   -->
+</a>
+<h2 class="title">P</h2>
+<dl>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJ.html#PF_ABGR">PF_ABGR</a></span> - Static variable in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJ.html" title="class in org.libjpegturbo.turbojpeg">TJ</a></dt>
+<dd>
+<div class="block">ABGR pixel format.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJ.html#PF_ARGB">PF_ARGB</a></span> - Static variable in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJ.html" title="class in org.libjpegturbo.turbojpeg">TJ</a></dt>
+<dd>
+<div class="block">ARGB pixel format.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJ.html#PF_BGR">PF_BGR</a></span> - Static variable in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJ.html" title="class in org.libjpegturbo.turbojpeg">TJ</a></dt>
+<dd>
+<div class="block">BGR pixel format.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJ.html#PF_BGRA">PF_BGRA</a></span> - Static variable in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJ.html" title="class in org.libjpegturbo.turbojpeg">TJ</a></dt>
+<dd>
+<div class="block">BGRA pixel format.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJ.html#PF_BGRX">PF_BGRX</a></span> - Static variable in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJ.html" title="class in org.libjpegturbo.turbojpeg">TJ</a></dt>
+<dd>
+<div class="block">BGRX pixel format.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJ.html#PF_CMYK">PF_CMYK</a></span> - Static variable in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJ.html" title="class in org.libjpegturbo.turbojpeg">TJ</a></dt>
+<dd>
+<div class="block">CMYK pixel format.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJ.html#PF_GRAY">PF_GRAY</a></span> - Static variable in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJ.html" title="class in org.libjpegturbo.turbojpeg">TJ</a></dt>
+<dd>
+<div class="block">Grayscale pixel format.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJ.html#PF_RGB">PF_RGB</a></span> - Static variable in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJ.html" title="class in org.libjpegturbo.turbojpeg">TJ</a></dt>
+<dd>
+<div class="block">RGB pixel format.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJ.html#PF_RGBA">PF_RGBA</a></span> - Static variable in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJ.html" title="class in org.libjpegturbo.turbojpeg">TJ</a></dt>
+<dd>
+<div class="block">RGBA pixel format.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJ.html#PF_RGBX">PF_RGBX</a></span> - Static variable in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJ.html" title="class in org.libjpegturbo.turbojpeg">TJ</a></dt>
+<dd>
+<div class="block">RGBX pixel format.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJ.html#PF_XBGR">PF_XBGR</a></span> - Static variable in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJ.html" title="class in org.libjpegturbo.turbojpeg">TJ</a></dt>
+<dd>
+<div class="block">XBGR pixel format.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJ.html#PF_XRGB">PF_XRGB</a></span> - Static variable in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJ.html" title="class in org.libjpegturbo.turbojpeg">TJ</a></dt>
+<dd>
+<div class="block">XRGB pixel format.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJ.html#planeHeight(int,%20int,%20int)">planeHeight(int, int, int)</a></span> - Static method in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJ.html" title="class in org.libjpegturbo.turbojpeg">TJ</a></dt>
+<dd>
+<div class="block">Returns the plane height of a YUV image plane with the given parameters.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJ.html#planeSizeYUV(int,%20int,%20int,%20int,%20int)">planeSizeYUV(int, int, int, int, int)</a></span> - Static method in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJ.html" title="class in org.libjpegturbo.turbojpeg">TJ</a></dt>
+<dd>
+<div class="block">Returns the size of the buffer (in bytes) required to hold a YUV image
+ plane with the given parameters.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJ.html#planeWidth(int,%20int,%20int)">planeWidth(int, int, int)</a></span> - Static method in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJ.html" title="class in org.libjpegturbo.turbojpeg">TJ</a></dt>
+<dd>
+<div class="block">Returns the plane width of a YUV image plane with the given parameters.</div>
+</dd>
+</dl>
+<a name="_S_">
+<!--   -->
+</a>
+<h2 class="title">S</h2>
+<dl>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJ.html#SAMP_411">SAMP_411</a></span> - Static variable in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJ.html" title="class in org.libjpegturbo.turbojpeg">TJ</a></dt>
+<dd>
+<div class="block">4:1:1 chrominance subsampling.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJ.html#SAMP_420">SAMP_420</a></span> - Static variable in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJ.html" title="class in org.libjpegturbo.turbojpeg">TJ</a></dt>
+<dd>
+<div class="block">4:2:0 chrominance subsampling.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJ.html#SAMP_422">SAMP_422</a></span> - Static variable in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJ.html" title="class in org.libjpegturbo.turbojpeg">TJ</a></dt>
+<dd>
+<div class="block">4:2:2 chrominance subsampling.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJ.html#SAMP_440">SAMP_440</a></span> - Static variable in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJ.html" title="class in org.libjpegturbo.turbojpeg">TJ</a></dt>
+<dd>
+<div class="block">4:4:0 chrominance subsampling.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJ.html#SAMP_444">SAMP_444</a></span> - Static variable in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJ.html" title="class in org.libjpegturbo.turbojpeg">TJ</a></dt>
+<dd>
+<div class="block">4:4:4 chrominance subsampling (no chrominance subsampling).</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJ.html#SAMP_GRAY">SAMP_GRAY</a></span> - Static variable in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJ.html" title="class in org.libjpegturbo.turbojpeg">TJ</a></dt>
+<dd>
+<div class="block">Grayscale.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/YUVImage.html#setBuf(byte[][],%20int[],%20int,%20int[],%20int,%20int)">setBuf(byte[][], int[], int, int[], int, int)</a></span> - Method in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/YUVImage.html" title="class in org.libjpegturbo.turbojpeg">YUVImage</a></dt>
+<dd>
+<div class="block">Assign a set of image planes to this <code>YUVImage</code> instance.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/YUVImage.html#setBuf(byte[],%20int,%20int,%20int,%20int)">setBuf(byte[], int, int, int, int)</a></span> - Method in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/YUVImage.html" title="class in org.libjpegturbo.turbojpeg">YUVImage</a></dt>
+<dd>
+<div class="block">Assign a unified image buffer to this <code>YUVImage</code> instance.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJDecompressor.html#setJPEGImage(byte[],%20int)">setJPEGImage(byte[], int)</a></span> - Method in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJDecompressor.html" title="class in org.libjpegturbo.turbojpeg">TJDecompressor</a></dt>
+<dd>
+<div class="block"><span class="strong">Deprecated.</span>
+<div class="block"><i>Use <a href="./org/libjpegturbo/turbojpeg/TJDecompressor.html#setSourceImage(byte[],%20int)"><code>TJDecompressor.setSourceImage(byte[], int)</code></a> instead.</i></div>
+</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJCompressor.html#setJPEGQuality(int)">setJPEGQuality(int)</a></span> - Method in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJCompressor.html" title="class in org.libjpegturbo.turbojpeg">TJCompressor</a></dt>
+<dd>
+<div class="block">Set the JPEG image quality level for subsequent compress operations.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJCompressor.html#setSourceImage(byte[],%20int,%20int,%20int,%20int,%20int,%20int)">setSourceImage(byte[], int, int, int, int, int, int)</a></span> - Method in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJCompressor.html" title="class in org.libjpegturbo.turbojpeg">TJCompressor</a></dt>
+<dd>
+<div class="block">Associate an uncompressed RGB, grayscale, or CMYK source image with this
+ compressor instance.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJCompressor.html#setSourceImage(byte[],%20int,%20int,%20int,%20int)">setSourceImage(byte[], int, int, int, int)</a></span> - Method in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJCompressor.html" title="class in org.libjpegturbo.turbojpeg">TJCompressor</a></dt>
+<dd>
+<div class="block"><span class="strong">Deprecated.</span>
+<div class="block"><i>Use
+ <a href="./org/libjpegturbo/turbojpeg/TJCompressor.html#setSourceImage(byte[],%20int,%20int,%20int,%20int,%20int,%20int)"><code>TJCompressor.setSourceImage(byte[], int, int, int, int, int, int)</code></a> instead.</i></div>
+</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJCompressor.html#setSourceImage(java.awt.image.BufferedImage,%20int,%20int,%20int,%20int)">setSourceImage(BufferedImage, int, int, int, int)</a></span> - Method in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJCompressor.html" title="class in org.libjpegturbo.turbojpeg">TJCompressor</a></dt>
+<dd>
+<div class="block">Associate an uncompressed RGB or grayscale source image with this
+ compressor instance.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJCompressor.html#setSourceImage(org.libjpegturbo.turbojpeg.YUVImage)">setSourceImage(YUVImage)</a></span> - Method in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJCompressor.html" title="class in org.libjpegturbo.turbojpeg">TJCompressor</a></dt>
+<dd>
+<div class="block">Associate an uncompressed YUV planar source image with this compressor
+ instance.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJDecompressor.html#setSourceImage(byte[],%20int)">setSourceImage(byte[], int)</a></span> - Method in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJDecompressor.html" title="class in org.libjpegturbo.turbojpeg">TJDecompressor</a></dt>
+<dd>
+<div class="block">Associate the JPEG image of length <code>imageSize</code> bytes stored in
+ <code>jpegImage</code> with this decompressor instance.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJDecompressor.html#setSourceImage(org.libjpegturbo.turbojpeg.YUVImage)">setSourceImage(YUVImage)</a></span> - Method in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJDecompressor.html" title="class in org.libjpegturbo.turbojpeg">TJDecompressor</a></dt>
+<dd>
+<div class="block">Associate the specified YUV planar source image with this decompressor
+ instance.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJCompressor.html#setSubsamp(int)">setSubsamp(int)</a></span> - Method in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJCompressor.html" title="class in org.libjpegturbo.turbojpeg">TJCompressor</a></dt>
+<dd>
+<div class="block">Set the level of chrominance subsampling for subsequent compress/encode
+ operations.</div>
+</dd>
+</dl>
+<a name="_T_">
+<!--   -->
+</a>
+<h2 class="title">T</h2>
+<dl>
+<dt><a href="./org/libjpegturbo/turbojpeg/TJ.html" title="class in org.libjpegturbo.turbojpeg"><span class="strong">TJ</span></a> - Class in <a href="./org/libjpegturbo/turbojpeg/package-summary.html">org.libjpegturbo.turbojpeg</a></dt>
+<dd>
+<div class="block">TurboJPEG utility class (cannot be instantiated)</div>
+</dd>
+<dt><a href="./org/libjpegturbo/turbojpeg/TJCompressor.html" title="class in org.libjpegturbo.turbojpeg"><span class="strong">TJCompressor</span></a> - Class in <a href="./org/libjpegturbo/turbojpeg/package-summary.html">org.libjpegturbo.turbojpeg</a></dt>
+<dd>
+<div class="block">TurboJPEG compressor</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJCompressor.html#TJCompressor()">TJCompressor()</a></span> - Constructor for class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJCompressor.html" title="class in org.libjpegturbo.turbojpeg">TJCompressor</a></dt>
+<dd>
+<div class="block">Create a TurboJPEG compressor instance.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJCompressor.html#TJCompressor(byte[],%20int,%20int,%20int,%20int,%20int,%20int)">TJCompressor(byte[], int, int, int, int, int, int)</a></span> - Constructor for class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJCompressor.html" title="class in org.libjpegturbo.turbojpeg">TJCompressor</a></dt>
+<dd>
+<div class="block">Create a TurboJPEG compressor instance and associate the uncompressed
+ source image stored in <code>srcImage</code> with the newly created
+ instance.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJCompressor.html#TJCompressor(byte[],%20int,%20int,%20int,%20int)">TJCompressor(byte[], int, int, int, int)</a></span> - Constructor for class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJCompressor.html" title="class in org.libjpegturbo.turbojpeg">TJCompressor</a></dt>
+<dd>
+<div class="block"><span class="strong">Deprecated.</span>
+<div class="block"><i>Use
+ <a href="./org/libjpegturbo/turbojpeg/TJCompressor.html#TJCompressor(byte[],%20int,%20int,%20int,%20int,%20int,%20int)"><code>TJCompressor.TJCompressor(byte[], int, int, int, int, int, int)</code></a> instead.</i></div>
+</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJCompressor.html#TJCompressor(java.awt.image.BufferedImage,%20int,%20int,%20int,%20int)">TJCompressor(BufferedImage, int, int, int, int)</a></span> - Constructor for class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJCompressor.html" title="class in org.libjpegturbo.turbojpeg">TJCompressor</a></dt>
+<dd>
+<div class="block">Create a TurboJPEG compressor instance and associate the uncompressed
+ source image stored in <code>srcImage</code> with the newly created
+ instance.</div>
+</dd>
+<dt><a href="./org/libjpegturbo/turbojpeg/TJCustomFilter.html" title="interface in org.libjpegturbo.turbojpeg"><span class="strong">TJCustomFilter</span></a> - Interface in <a href="./org/libjpegturbo/turbojpeg/package-summary.html">org.libjpegturbo.turbojpeg</a></dt>
+<dd>
+<div class="block">Custom filter callback interface</div>
+</dd>
+<dt><a href="./org/libjpegturbo/turbojpeg/TJDecompressor.html" title="class in org.libjpegturbo.turbojpeg"><span class="strong">TJDecompressor</span></a> - Class in <a href="./org/libjpegturbo/turbojpeg/package-summary.html">org.libjpegturbo.turbojpeg</a></dt>
+<dd>
+<div class="block">TurboJPEG decompressor</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJDecompressor.html#TJDecompressor()">TJDecompressor()</a></span> - Constructor for class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJDecompressor.html" title="class in org.libjpegturbo.turbojpeg">TJDecompressor</a></dt>
+<dd>
+<div class="block">Create a TurboJPEG decompresssor instance.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJDecompressor.html#TJDecompressor(byte[])">TJDecompressor(byte[])</a></span> - Constructor for class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJDecompressor.html" title="class in org.libjpegturbo.turbojpeg">TJDecompressor</a></dt>
+<dd>
+<div class="block">Create a TurboJPEG decompressor instance and associate the JPEG source
+ image stored in <code>jpegImage</code> with the newly created instance.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJDecompressor.html#TJDecompressor(byte[],%20int)">TJDecompressor(byte[], int)</a></span> - Constructor for class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJDecompressor.html" title="class in org.libjpegturbo.turbojpeg">TJDecompressor</a></dt>
+<dd>
+<div class="block">Create a TurboJPEG decompressor instance and associate the JPEG source
+ image of length <code>imageSize</code> bytes stored in
+ <code>jpegImage</code> with the newly created instance.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJDecompressor.html#TJDecompressor(org.libjpegturbo.turbojpeg.YUVImage)">TJDecompressor(YUVImage)</a></span> - Constructor for class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJDecompressor.html" title="class in org.libjpegturbo.turbojpeg">TJDecompressor</a></dt>
+<dd>
+<div class="block">Create a TurboJPEG decompressor instance and associate the YUV planar
+ source image stored in <code>yuvImage</code> with the newly created
+ instance.</div>
+</dd>
+<dt><a href="./org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg"><span class="strong">TJException</span></a> - Exception in <a href="./org/libjpegturbo/turbojpeg/package-summary.html">org.libjpegturbo.turbojpeg</a></dt>
+<dd>&nbsp;</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJException.html#TJException()">TJException()</a></span> - Constructor for exception org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></dt>
+<dd>&nbsp;</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJException.html#TJException(java.lang.String,%20java.lang.Throwable)">TJException(String, Throwable)</a></span> - Constructor for exception org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></dt>
+<dd>&nbsp;</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJException.html#TJException(java.lang.String)">TJException(String)</a></span> - Constructor for exception org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></dt>
+<dd>&nbsp;</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJException.html#TJException(java.lang.String,%20int)">TJException(String, int)</a></span> - Constructor for exception org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></dt>
+<dd>&nbsp;</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJException.html#TJException(java.lang.Throwable)">TJException(Throwable)</a></span> - Constructor for exception org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></dt>
+<dd>&nbsp;</dd>
+<dt><a href="./org/libjpegturbo/turbojpeg/TJScalingFactor.html" title="class in org.libjpegturbo.turbojpeg"><span class="strong">TJScalingFactor</span></a> - Class in <a href="./org/libjpegturbo/turbojpeg/package-summary.html">org.libjpegturbo.turbojpeg</a></dt>
+<dd>
+<div class="block">Fractional scaling factor</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJScalingFactor.html#TJScalingFactor(int,%20int)">TJScalingFactor(int, int)</a></span> - Constructor for class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJScalingFactor.html" title="class in org.libjpegturbo.turbojpeg">TJScalingFactor</a></dt>
+<dd>
+<div class="block">Create a TurboJPEG scaling factor instance.</div>
+</dd>
+<dt><a href="./org/libjpegturbo/turbojpeg/TJTransform.html" title="class in org.libjpegturbo.turbojpeg"><span class="strong">TJTransform</span></a> - Class in <a href="./org/libjpegturbo/turbojpeg/package-summary.html">org.libjpegturbo.turbojpeg</a></dt>
+<dd>
+<div class="block">Lossless transform parameters</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJTransform.html#TJTransform()">TJTransform()</a></span> - Constructor for class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJTransform.html" title="class in org.libjpegturbo.turbojpeg">TJTransform</a></dt>
+<dd>
+<div class="block">Create a new lossless transform instance.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJTransform.html#TJTransform(int,%20int,%20int,%20int,%20int,%20int,%20org.libjpegturbo.turbojpeg.TJCustomFilter)">TJTransform(int, int, int, int, int, int, TJCustomFilter)</a></span> - Constructor for class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJTransform.html" title="class in org.libjpegturbo.turbojpeg">TJTransform</a></dt>
+<dd>
+<div class="block">Create a new lossless transform instance with the given parameters.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJTransform.html#TJTransform(java.awt.Rectangle,%20int,%20int,%20org.libjpegturbo.turbojpeg.TJCustomFilter)">TJTransform(Rectangle, int, int, TJCustomFilter)</a></span> - Constructor for class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJTransform.html" title="class in org.libjpegturbo.turbojpeg">TJTransform</a></dt>
+<dd>
+<div class="block">Create a new lossless transform instance with the given parameters.</div>
+</dd>
+<dt><a href="./org/libjpegturbo/turbojpeg/TJTransformer.html" title="class in org.libjpegturbo.turbojpeg"><span class="strong">TJTransformer</span></a> - Class in <a href="./org/libjpegturbo/turbojpeg/package-summary.html">org.libjpegturbo.turbojpeg</a></dt>
+<dd>
+<div class="block">TurboJPEG lossless transformer</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJTransformer.html#TJTransformer()">TJTransformer()</a></span> - Constructor for class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJTransformer.html" title="class in org.libjpegturbo.turbojpeg">TJTransformer</a></dt>
+<dd>
+<div class="block">Create a TurboJPEG lossless transformer instance.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJTransformer.html#TJTransformer(byte[])">TJTransformer(byte[])</a></span> - Constructor for class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJTransformer.html" title="class in org.libjpegturbo.turbojpeg">TJTransformer</a></dt>
+<dd>
+<div class="block">Create a TurboJPEG lossless transformer instance and associate the JPEG
+ image stored in <code>jpegImage</code> with the newly created instance.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJTransformer.html#TJTransformer(byte[],%20int)">TJTransformer(byte[], int)</a></span> - Constructor for class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJTransformer.html" title="class in org.libjpegturbo.turbojpeg">TJTransformer</a></dt>
+<dd>
+<div class="block">Create a TurboJPEG lossless transformer instance and associate the JPEG
+ image of length <code>imageSize</code> bytes stored in
+ <code>jpegImage</code> with the newly created instance.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJTransformer.html#transform(byte[][],%20org.libjpegturbo.turbojpeg.TJTransform[],%20int)">transform(byte[][], TJTransform[], int)</a></span> - Method in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJTransformer.html" title="class in org.libjpegturbo.turbojpeg">TJTransformer</a></dt>
+<dd>
+<div class="block">Losslessly transform the JPEG image associated with this transformer
+ instance into one or more JPEG images stored in the given destination
+ buffers.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJTransformer.html#transform(org.libjpegturbo.turbojpeg.TJTransform[],%20int)">transform(TJTransform[], int)</a></span> - Method in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJTransformer.html" title="class in org.libjpegturbo.turbojpeg">TJTransformer</a></dt>
+<dd>
+<div class="block">Losslessly transform the JPEG image associated with this transformer
+ instance and return an array of <a href="./org/libjpegturbo/turbojpeg/TJDecompressor.html" title="class in org.libjpegturbo.turbojpeg"><code>TJDecompressor</code></a> instances, each of
+ which has a transformed JPEG image associated with it.</div>
+</dd>
+</dl>
+<a name="_Y_">
+<!--   -->
+</a>
+<h2 class="title">Y</h2>
+<dl>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/YUVImage.html#yuvHeight">yuvHeight</a></span> - Variable in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/YUVImage.html" title="class in org.libjpegturbo.turbojpeg">YUVImage</a></dt>
+<dd>&nbsp;</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/TJDecompressor.html#yuvImage">yuvImage</a></span> - Variable in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/TJDecompressor.html" title="class in org.libjpegturbo.turbojpeg">TJDecompressor</a></dt>
+<dd>&nbsp;</dd>
+<dt><a href="./org/libjpegturbo/turbojpeg/YUVImage.html" title="class in org.libjpegturbo.turbojpeg"><span class="strong">YUVImage</span></a> - Class in <a href="./org/libjpegturbo/turbojpeg/package-summary.html">org.libjpegturbo.turbojpeg</a></dt>
+<dd>
+<div class="block">This class encapsulates a YUV planar image and the metadata
+ associated with it.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/YUVImage.html#YUVImage(int,%20int[],%20int,%20int)">YUVImage(int, int[], int, int)</a></span> - Constructor for class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/YUVImage.html" title="class in org.libjpegturbo.turbojpeg">YUVImage</a></dt>
+<dd>
+<div class="block">Create a new <code>YUVImage</code> instance backed by separate image
+ planes, and allocate memory for the image planes.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/YUVImage.html#YUVImage(int,%20int,%20int,%20int)">YUVImage(int, int, int, int)</a></span> - Constructor for class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/YUVImage.html" title="class in org.libjpegturbo.turbojpeg">YUVImage</a></dt>
+<dd>
+<div class="block">Create a new <code>YUVImage</code> instance backed by a unified image
+ buffer, and allocate memory for the image buffer.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/YUVImage.html#YUVImage(byte[][],%20int[],%20int,%20int[],%20int,%20int)">YUVImage(byte[][], int[], int, int[], int, int)</a></span> - Constructor for class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/YUVImage.html" title="class in org.libjpegturbo.turbojpeg">YUVImage</a></dt>
+<dd>
+<div class="block">Create a new <code>YUVImage</code> instance from a set of existing image
+ planes.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/YUVImage.html#YUVImage(byte[],%20int,%20int,%20int,%20int)">YUVImage(byte[], int, int, int, int)</a></span> - Constructor for class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/YUVImage.html" title="class in org.libjpegturbo.turbojpeg">YUVImage</a></dt>
+<dd>
+<div class="block">Create a new <code>YUVImage</code> instance from an existing unified image
+ buffer.</div>
+</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/YUVImage.html#yuvOffsets">yuvOffsets</a></span> - Variable in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/YUVImage.html" title="class in org.libjpegturbo.turbojpeg">YUVImage</a></dt>
+<dd>&nbsp;</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/YUVImage.html#yuvPad">yuvPad</a></span> - Variable in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/YUVImage.html" title="class in org.libjpegturbo.turbojpeg">YUVImage</a></dt>
+<dd>&nbsp;</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/YUVImage.html#yuvPlanes">yuvPlanes</a></span> - Variable in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/YUVImage.html" title="class in org.libjpegturbo.turbojpeg">YUVImage</a></dt>
+<dd>&nbsp;</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/YUVImage.html#yuvStrides">yuvStrides</a></span> - Variable in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/YUVImage.html" title="class in org.libjpegturbo.turbojpeg">YUVImage</a></dt>
+<dd>&nbsp;</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/YUVImage.html#yuvSubsamp">yuvSubsamp</a></span> - Variable in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/YUVImage.html" title="class in org.libjpegturbo.turbojpeg">YUVImage</a></dt>
+<dd>&nbsp;</dd>
+<dt><span class="strong"><a href="./org/libjpegturbo/turbojpeg/YUVImage.html#yuvWidth">yuvWidth</a></span> - Variable in class org.libjpegturbo.turbojpeg.<a href="./org/libjpegturbo/turbojpeg/YUVImage.html" title="class in org.libjpegturbo.turbojpeg">YUVImage</a></dt>
+<dd>&nbsp;</dd>
+</dl>
+<a href="#_B_">B</a>&nbsp;<a href="#_C_">C</a>&nbsp;<a href="#_D_">D</a>&nbsp;<a href="#_E_">E</a>&nbsp;<a href="#_F_">F</a>&nbsp;<a href="#_G_">G</a>&nbsp;<a href="#_H_">H</a>&nbsp;<a href="#_I_">I</a>&nbsp;<a href="#_J_">J</a>&nbsp;<a href="#_N_">N</a>&nbsp;<a href="#_O_">O</a>&nbsp;<a href="#_P_">P</a>&nbsp;<a href="#_S_">S</a>&nbsp;<a href="#_T_">T</a>&nbsp;<a href="#_Y_">Y</a>&nbsp;</div>
+<!-- ======= START OF BOTTOM NAVBAR ====== -->
+<div class="bottomNav"><a name="navbar_bottom">
+<!--   -->
+</a><a href="#skip-navbar_bottom" title="Skip navigation links"></a><a name="navbar_bottom_firstrow">
+<!--   -->
+</a>
+<ul class="navList" title="Navigation">
+<li><a href="./org/libjpegturbo/turbojpeg/package-summary.html">Package</a></li>
+<li>Class</li>
+<li><a href="./org/libjpegturbo/turbojpeg/package-tree.html">Tree</a></li>
+<li><a href="./deprecated-list.html">Deprecated</a></li>
+<li class="navBarCell1Rev">Index</li>
+<li><a href="./help-doc.html">Help</a></li>
+</ul>
+</div>
+<div class="subNav">
+<ul class="navList">
+<li>Prev</li>
+<li>Next</li>
+</ul>
+<ul class="navList">
+<li><a href="./index.html?index-all.html" target="_top">Frames</a></li>
+<li><a href="index-all.html" target="_top">No Frames</a></li>
+</ul>
+<ul class="navList" id="allclasses_navbar_bottom">
+<li><a href="./allclasses-noframe.html">All Classes</a></li>
+</ul>
+<div>
+<script type="text/javascript"><!--
+  allClassesLink = document.getElementById("allclasses_navbar_bottom");
+  if(window==top) {
+    allClassesLink.style.display = "block";
+  }
+  else {
+    allClassesLink.style.display = "none";
+  }
+  //-->
+</script>
+</div>
+<a name="skip-navbar_bottom">
+<!--   -->
+</a></div>
+<!-- ======== END OF BOTTOM NAVBAR ======= -->
+</body>
+</html>
diff --git a/3rdparty/libjpeg/src/java/doc/index.html b/3rdparty/libjpeg/src/java/doc/index.html
new file mode 100644
index 00000000..4e210754
--- /dev/null
+++ b/3rdparty/libjpeg/src/java/doc/index.html
@@ -0,0 +1,71 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Frameset//EN" "http://www.w3.org/TR/html4/frameset.dtd">
+<!-- NewPage -->
+<html lang="en">
+<head>
+<title>Generated Documentation (Untitled)</title>
+<script type="text/javascript">
+    tmpTargetPage = "" + window.location.search;
+    if (tmpTargetPage != "" && tmpTargetPage != "undefined")
+        tmpTargetPage = tmpTargetPage.substring(1);
+    if (tmpTargetPage.indexOf(":") != -1 || (tmpTargetPage != "" && !validURL(tmpTargetPage)))
+        tmpTargetPage = "undefined";
+    targetPage = tmpTargetPage;
+    function validURL(url) {
+        try {
+            url = decodeURIComponent(url);
+        }
+        catch (error) {
+            return false;
+        }
+        var pos = url.indexOf(".html");
+        if (pos == -1 || pos != url.length - 5)
+            return false;
+        var allowNumber = false;
+        var allowSep = false;
+        var seenDot = false;
+        for (var i = 0; i < url.length - 5; i++) {
+            var ch = url.charAt(i);
+            if ('a' <= ch && ch <= 'z' ||
+                    'A' <= ch && ch <= 'Z' ||
+                    ch == '$' ||
+                    ch == '_' ||
+                    ch.charCodeAt(0) > 127) {
+                allowNumber = true;
+                allowSep = true;
+            } else if ('0' <= ch && ch <= '9'
+                    || ch == '-') {
+                if (!allowNumber)
+                     return false;
+            } else if (ch == '/' || ch == '.') {
+                if (!allowSep)
+                    return false;
+                allowNumber = false;
+                allowSep = false;
+                if (ch == '.')
+                     seenDot = true;
+                if (ch == '/' && seenDot)
+                     return false;
+            } else {
+                return false;
+            }
+        }
+        return true;
+    }
+    function loadFrames() {
+        if (targetPage != "" && targetPage != "undefined")
+             top.classFrame.location = top.targetPage;
+    }
+</script>
+</head>
+<frameset cols="20%,80%" title="Documentation frame" onload="top.loadFrames()">
+<frame src="allclasses-frame.html" name="packageFrame" title="All classes and interfaces (except non-static nested types)">
+<frame src="org/libjpegturbo/turbojpeg/package-summary.html" name="classFrame" title="Package, class and interface descriptions" scrolling="yes">
+<noframes>
+<noscript>
+<div>JavaScript is disabled on your browser.</div>
+</noscript>
+<h2>Frame Alert</h2>
+<p>This document is designed to be viewed using the frames feature. If you see this message, you are using a non-frame-capable web client. Link to <a href="org/libjpegturbo/turbojpeg/package-summary.html">Non-frame version</a>.</p>
+</noframes>
+</frameset>
+</html>
diff --git a/3rdparty/libjpeg/src/java/doc/org/libjpegturbo/turbojpeg/TJ.html b/3rdparty/libjpeg/src/java/doc/org/libjpegturbo/turbojpeg/TJ.html
new file mode 100644
index 00000000..5ca5cc8c
--- /dev/null
+++ b/3rdparty/libjpeg/src/java/doc/org/libjpegturbo/turbojpeg/TJ.html
@@ -0,0 +1,1357 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!-- NewPage -->
+<html lang="en">
+<head>
+<title>TJ</title>
+<link rel="stylesheet" type="text/css" href="../../../stylesheet.css" title="Style">
+</head>
+<body>
+<script type="text/javascript"><!--
+    try {
+        if (location.href.indexOf('is-external=true') == -1) {
+            parent.document.title="TJ";
+        }
+    }
+    catch(err) {
+    }
+//-->
+</script>
+<noscript>
+<div>JavaScript is disabled on your browser.</div>
+</noscript>
+<!-- ========= START OF TOP NAVBAR ======= -->
+<div class="topNav"><a name="navbar_top">
+<!--   -->
+</a><a href="#skip-navbar_top" title="Skip navigation links"></a><a name="navbar_top_firstrow">
+<!--   -->
+</a>
+<ul class="navList" title="Navigation">
+<li><a href="../../../org/libjpegturbo/turbojpeg/package-summary.html">Package</a></li>
+<li class="navBarCell1Rev">Class</li>
+<li><a href="package-tree.html">Tree</a></li>
+<li><a href="../../../deprecated-list.html">Deprecated</a></li>
+<li><a href="../../../index-all.html">Index</a></li>
+<li><a href="../../../help-doc.html">Help</a></li>
+</ul>
+</div>
+<div class="subNav">
+<ul class="navList">
+<li>Prev Class</li>
+<li><a href="../../../org/libjpegturbo/turbojpeg/TJCompressor.html" title="class in org.libjpegturbo.turbojpeg"><span class="strong">Next Class</span></a></li>
+</ul>
+<ul class="navList">
+<li><a href="../../../index.html?org/libjpegturbo/turbojpeg/TJ.html" target="_top">Frames</a></li>
+<li><a href="TJ.html" target="_top">No Frames</a></li>
+</ul>
+<ul class="navList" id="allclasses_navbar_top">
+<li><a href="../../../allclasses-noframe.html">All Classes</a></li>
+</ul>
+<div>
+<script type="text/javascript"><!--
+  allClassesLink = document.getElementById("allclasses_navbar_top");
+  if(window==top) {
+    allClassesLink.style.display = "block";
+  }
+  else {
+    allClassesLink.style.display = "none";
+  }
+  //-->
+</script>
+</div>
+<div>
+<ul class="subNavList">
+<li>Summary:&nbsp;</li>
+<li>Nested&nbsp;|&nbsp;</li>
+<li><a href="#field_summary">Field</a>&nbsp;|&nbsp;</li>
+<li>Constr&nbsp;|&nbsp;</li>
+<li><a href="#method_summary">Method</a></li>
+</ul>
+<ul class="subNavList">
+<li>Detail:&nbsp;</li>
+<li><a href="#field_detail">Field</a>&nbsp;|&nbsp;</li>
+<li>Constr&nbsp;|&nbsp;</li>
+<li><a href="#method_detail">Method</a></li>
+</ul>
+</div>
+<a name="skip-navbar_top">
+<!--   -->
+</a></div>
+<!-- ========= END OF TOP NAVBAR ========= -->
+<!-- ======== START OF CLASS DATA ======== -->
+<div class="header">
+<div class="subTitle">org.libjpegturbo.turbojpeg</div>
+<h2 title="Class TJ" class="title">Class TJ</h2>
+</div>
+<div class="contentContainer">
+<ul class="inheritance">
+<li>java.lang.Object</li>
+<li>
+<ul class="inheritance">
+<li>org.libjpegturbo.turbojpeg.TJ</li>
+</ul>
+</li>
+</ul>
+<div class="description">
+<ul class="blockList">
+<li class="blockList">
+<hr>
+<br>
+<pre>public final class <span class="strong">TJ</span>
+extends java.lang.Object</pre>
+<div class="block">TurboJPEG utility class (cannot be instantiated)</div>
+</li>
+</ul>
+</div>
+<div class="summary">
+<ul class="blockList">
+<li class="blockList">
+<!-- =========== FIELD SUMMARY =========== -->
+<ul class="blockList">
+<li class="blockList"><a name="field_summary">
+<!--   -->
+</a>
+<h3>Field Summary</h3>
+<table class="overviewSummary" border="0" cellpadding="3" cellspacing="0" summary="Field Summary table, listing fields, and an explanation">
+<caption><span>Fields</span><span class="tabEnd">&nbsp;</span></caption>
+<tr>
+<th class="colFirst" scope="col">Modifier and Type</th>
+<th class="colLast" scope="col">Field and Description</th>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>static int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJ.html#CS_CMYK">CS_CMYK</a></strong></code>
+<div class="block">CMYK colorspace.</div>
+</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>static int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJ.html#CS_GRAY">CS_GRAY</a></strong></code>
+<div class="block">Grayscale colorspace.</div>
+</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>static int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJ.html#CS_RGB">CS_RGB</a></strong></code>
+<div class="block">RGB colorspace.</div>
+</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>static int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJ.html#CS_YCbCr">CS_YCbCr</a></strong></code>
+<div class="block">YCbCr colorspace.</div>
+</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>static int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJ.html#CS_YCCK">CS_YCCK</a></strong></code>
+<div class="block">YCCK colorspace.</div>
+</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>static int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJ.html#ERR_FATAL">ERR_FATAL</a></strong></code>
+<div class="block">The error was fatal and non-recoverable.</div>
+</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>static int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJ.html#ERR_WARNING">ERR_WARNING</a></strong></code>
+<div class="block">The error was non-fatal and recoverable, but the image may still be
+ corrupt.</div>
+</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>static int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJ.html#FLAG_ACCURATEDCT">FLAG_ACCURATEDCT</a></strong></code>
+<div class="block">Use the most accurate DCT/IDCT algorithm available in the underlying
+ codec.</div>
+</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>static int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJ.html#FLAG_BOTTOMUP">FLAG_BOTTOMUP</a></strong></code>
+<div class="block">The uncompressed source/destination image is stored in bottom-up (Windows,
+ OpenGL) order, not top-down (X11) order.</div>
+</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>static int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJ.html#FLAG_FASTDCT">FLAG_FASTDCT</a></strong></code>
+<div class="block">Use the fastest DCT/IDCT algorithm available in the underlying codec.</div>
+</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>static int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJ.html#FLAG_FASTUPSAMPLE">FLAG_FASTUPSAMPLE</a></strong></code>
+<div class="block">When decompressing an image that was compressed using chrominance
+ subsampling, use the fastest chrominance upsampling algorithm available in
+ the underlying codec.</div>
+</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>static int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJ.html#FLAG_FORCEMMX">FLAG_FORCEMMX</a></strong></code>
+<div class="block"><strong>Deprecated.</strong>&nbsp;</div>
+</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>static int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJ.html#FLAG_FORCESSE">FLAG_FORCESSE</a></strong></code>
+<div class="block"><strong>Deprecated.</strong>&nbsp;</div>
+</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>static int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJ.html#FLAG_FORCESSE2">FLAG_FORCESSE2</a></strong></code>
+<div class="block"><strong>Deprecated.</strong>&nbsp;</div>
+</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>static int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJ.html#FLAG_FORCESSE3">FLAG_FORCESSE3</a></strong></code>
+<div class="block"><strong>Deprecated.</strong>&nbsp;</div>
+</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>static int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJ.html#FLAG_PROGRESSIVE">FLAG_PROGRESSIVE</a></strong></code>
+<div class="block">Use progressive entropy coding in JPEG images generated by compression and
+ transform operations.</div>
+</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>static int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJ.html#FLAG_STOPONWARNING">FLAG_STOPONWARNING</a></strong></code>
+<div class="block">Immediately discontinue the current compression/decompression/transform
+ operation if the underlying codec throws a warning (non-fatal error).</div>
+</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>static int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJ.html#NUMCS">NUMCS</a></strong></code>
+<div class="block">The number of JPEG colorspaces</div>
+</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>static int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJ.html#NUMERR">NUMERR</a></strong></code>
+<div class="block">The number of error codes</div>
+</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>static int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJ.html#NUMPF">NUMPF</a></strong></code>
+<div class="block">The number of pixel formats</div>
+</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>static int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJ.html#NUMSAMP">NUMSAMP</a></strong></code>
+<div class="block">The number of chrominance subsampling options</div>
+</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>static int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJ.html#PF_ABGR">PF_ABGR</a></strong></code>
+<div class="block">ABGR pixel format.</div>
+</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>static int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJ.html#PF_ARGB">PF_ARGB</a></strong></code>
+<div class="block">ARGB pixel format.</div>
+</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>static int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJ.html#PF_BGR">PF_BGR</a></strong></code>
+<div class="block">BGR pixel format.</div>
+</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>static int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJ.html#PF_BGRA">PF_BGRA</a></strong></code>
+<div class="block">BGRA pixel format.</div>
+</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>static int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJ.html#PF_BGRX">PF_BGRX</a></strong></code>
+<div class="block">BGRX pixel format.</div>
+</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>static int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJ.html#PF_CMYK">PF_CMYK</a></strong></code>
+<div class="block">CMYK pixel format.</div>
+</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>static int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJ.html#PF_GRAY">PF_GRAY</a></strong></code>
+<div class="block">Grayscale pixel format.</div>
+</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>static int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJ.html#PF_RGB">PF_RGB</a></strong></code>
+<div class="block">RGB pixel format.</div>
+</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>static int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJ.html#PF_RGBA">PF_RGBA</a></strong></code>
+<div class="block">RGBA pixel format.</div>
+</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>static int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJ.html#PF_RGBX">PF_RGBX</a></strong></code>
+<div class="block">RGBX pixel format.</div>
+</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>static int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJ.html#PF_XBGR">PF_XBGR</a></strong></code>
+<div class="block">XBGR pixel format.</div>
+</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>static int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJ.html#PF_XRGB">PF_XRGB</a></strong></code>
+<div class="block">XRGB pixel format.</div>
+</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>static int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJ.html#SAMP_411">SAMP_411</a></strong></code>
+<div class="block">4:1:1 chrominance subsampling.</div>
+</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>static int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJ.html#SAMP_420">SAMP_420</a></strong></code>
+<div class="block">4:2:0 chrominance subsampling.</div>
+</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>static int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJ.html#SAMP_422">SAMP_422</a></strong></code>
+<div class="block">4:2:2 chrominance subsampling.</div>
+</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>static int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJ.html#SAMP_440">SAMP_440</a></strong></code>
+<div class="block">4:4:0 chrominance subsampling.</div>
+</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>static int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJ.html#SAMP_444">SAMP_444</a></strong></code>
+<div class="block">4:4:4 chrominance subsampling (no chrominance subsampling).</div>
+</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>static int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJ.html#SAMP_GRAY">SAMP_GRAY</a></strong></code>
+<div class="block">Grayscale.</div>
+</td>
+</tr>
+</table>
+</li>
+</ul>
+<!-- ========== METHOD SUMMARY =========== -->
+<ul class="blockList">
+<li class="blockList"><a name="method_summary">
+<!--   -->
+</a>
+<h3>Method Summary</h3>
+<table class="overviewSummary" border="0" cellpadding="3" cellspacing="0" summary="Method Summary table, listing methods, and an explanation">
+<caption><span>Methods</span><span class="tabEnd">&nbsp;</span></caption>
+<tr>
+<th class="colFirst" scope="col">Modifier and Type</th>
+<th class="colLast" scope="col">Method and Description</th>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>static int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJ.html#bufSize(int,%20int,%20int)">bufSize</a></strong>(int&nbsp;width,
+       int&nbsp;height,
+       int&nbsp;jpegSubsamp)</code>
+<div class="block">Returns the maximum size of the buffer (in bytes) required to hold a JPEG
+ image with the given width, height, and level of chrominance subsampling.</div>
+</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>static int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJ.html#bufSizeYUV(int,%20int,%20int)">bufSizeYUV</a></strong>(int&nbsp;width,
+          int&nbsp;height,
+          int&nbsp;subsamp)</code>
+<div class="block"><strong>Deprecated.</strong>&nbsp;
+<div class="block"><i>Use <a href="../../../org/libjpegturbo/turbojpeg/TJ.html#bufSizeYUV(int,%20int,%20int,%20int)"><code>bufSizeYUV(int, int, int, int)</code></a> instead.</i></div>
+</div>
+</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>static int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJ.html#bufSizeYUV(int,%20int,%20int,%20int)">bufSizeYUV</a></strong>(int&nbsp;width,
+          int&nbsp;pad,
+          int&nbsp;height,
+          int&nbsp;subsamp)</code>
+<div class="block">Returns the size of the buffer (in bytes) required to hold a YUV planar
+ image with the given width, height, and level of chrominance subsampling.</div>
+</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>static int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJ.html#getAlphaOffset(int)">getAlphaOffset</a></strong>(int&nbsp;pixelFormat)</code>
+<div class="block">For the given pixel format, returns the number of bytes that the alpha
+ component is offset from the start of the pixel.</div>
+</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>static int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJ.html#getBlueOffset(int)">getBlueOffset</a></strong>(int&nbsp;pixelFormat)</code>
+<div class="block">For the given pixel format, returns the number of bytes that the blue
+ component is offset from the start of the pixel.</div>
+</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>static int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJ.html#getGreenOffset(int)">getGreenOffset</a></strong>(int&nbsp;pixelFormat)</code>
+<div class="block">For the given pixel format, returns the number of bytes that the green
+ component is offset from the start of the pixel.</div>
+</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>static int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJ.html#getMCUHeight(int)">getMCUHeight</a></strong>(int&nbsp;subsamp)</code>
+<div class="block">Returns the MCU block height for the given level of chrominance
+ subsampling.</div>
+</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>static int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJ.html#getMCUWidth(int)">getMCUWidth</a></strong>(int&nbsp;subsamp)</code>
+<div class="block">Returns the MCU block width for the given level of chrominance
+ subsampling.</div>
+</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>static int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJ.html#getPixelSize(int)">getPixelSize</a></strong>(int&nbsp;pixelFormat)</code>
+<div class="block">Returns the pixel size (in bytes) for the given pixel format.</div>
+</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>static int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJ.html#getRedOffset(int)">getRedOffset</a></strong>(int&nbsp;pixelFormat)</code>
+<div class="block">For the given pixel format, returns the number of bytes that the red
+ component is offset from the start of the pixel.</div>
+</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>static <a href="../../../org/libjpegturbo/turbojpeg/TJScalingFactor.html" title="class in org.libjpegturbo.turbojpeg">TJScalingFactor</a>[]</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJ.html#getScalingFactors()">getScalingFactors</a></strong>()</code>
+<div class="block">Returns a list of fractional scaling factors that the JPEG decompressor in
+ this implementation of TurboJPEG supports.</div>
+</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>static int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJ.html#planeHeight(int,%20int,%20int)">planeHeight</a></strong>(int&nbsp;componentID,
+           int&nbsp;height,
+           int&nbsp;subsamp)</code>
+<div class="block">Returns the plane height of a YUV image plane with the given parameters.</div>
+</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>static int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJ.html#planeSizeYUV(int,%20int,%20int,%20int,%20int)">planeSizeYUV</a></strong>(int&nbsp;componentID,
+            int&nbsp;width,
+            int&nbsp;stride,
+            int&nbsp;height,
+            int&nbsp;subsamp)</code>
+<div class="block">Returns the size of the buffer (in bytes) required to hold a YUV image
+ plane with the given parameters.</div>
+</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>static int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJ.html#planeWidth(int,%20int,%20int)">planeWidth</a></strong>(int&nbsp;componentID,
+          int&nbsp;width,
+          int&nbsp;subsamp)</code>
+<div class="block">Returns the plane width of a YUV image plane with the given parameters.</div>
+</td>
+</tr>
+</table>
+<ul class="blockList">
+<li class="blockList"><a name="methods_inherited_from_class_java.lang.Object">
+<!--   -->
+</a>
+<h3>Methods inherited from class&nbsp;java.lang.Object</h3>
+<code>clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait</code></li>
+</ul>
+</li>
+</ul>
+</li>
+</ul>
+</div>
+<div class="details">
+<ul class="blockList">
+<li class="blockList">
+<!-- ============ FIELD DETAIL =========== -->
+<ul class="blockList">
+<li class="blockList"><a name="field_detail">
+<!--   -->
+</a>
+<h3>Field Detail</h3>
+<a name="NUMSAMP">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>NUMSAMP</h4>
+<pre>public static final&nbsp;int NUMSAMP</pre>
+<div class="block">The number of chrominance subsampling options</div>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../constant-values.html#org.libjpegturbo.turbojpeg.TJ.NUMSAMP">Constant Field Values</a></dd></dl>
+</li>
+</ul>
+<a name="SAMP_444">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>SAMP_444</h4>
+<pre>public static final&nbsp;int SAMP_444</pre>
+<div class="block">4:4:4 chrominance subsampling (no chrominance subsampling).  The JPEG
+ or YUV image will contain one chrominance component for every pixel in the
+ source image.</div>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../constant-values.html#org.libjpegturbo.turbojpeg.TJ.SAMP_444">Constant Field Values</a></dd></dl>
+</li>
+</ul>
+<a name="SAMP_422">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>SAMP_422</h4>
+<pre>public static final&nbsp;int SAMP_422</pre>
+<div class="block">4:2:2 chrominance subsampling.  The JPEG or YUV image will contain one
+ chrominance component for every 2x1 block of pixels in the source image.</div>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../constant-values.html#org.libjpegturbo.turbojpeg.TJ.SAMP_422">Constant Field Values</a></dd></dl>
+</li>
+</ul>
+<a name="SAMP_420">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>SAMP_420</h4>
+<pre>public static final&nbsp;int SAMP_420</pre>
+<div class="block">4:2:0 chrominance subsampling.  The JPEG or YUV image will contain one
+ chrominance component for every 2x2 block of pixels in the source image.</div>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../constant-values.html#org.libjpegturbo.turbojpeg.TJ.SAMP_420">Constant Field Values</a></dd></dl>
+</li>
+</ul>
+<a name="SAMP_GRAY">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>SAMP_GRAY</h4>
+<pre>public static final&nbsp;int SAMP_GRAY</pre>
+<div class="block">Grayscale.  The JPEG or YUV image will contain no chrominance components.</div>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../constant-values.html#org.libjpegturbo.turbojpeg.TJ.SAMP_GRAY">Constant Field Values</a></dd></dl>
+</li>
+</ul>
+<a name="SAMP_440">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>SAMP_440</h4>
+<pre>public static final&nbsp;int SAMP_440</pre>
+<div class="block">4:4:0 chrominance subsampling.  The JPEG or YUV image will contain one
+ chrominance component for every 1x2 block of pixels in the source image.
+ Note that 4:4:0 subsampling is not fully accelerated in libjpeg-turbo.</div>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../constant-values.html#org.libjpegturbo.turbojpeg.TJ.SAMP_440">Constant Field Values</a></dd></dl>
+</li>
+</ul>
+<a name="SAMP_411">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>SAMP_411</h4>
+<pre>public static final&nbsp;int SAMP_411</pre>
+<div class="block">4:1:1 chrominance subsampling.  The JPEG or YUV image will contain one
+ chrominance component for every 4x1 block of pixels in the source image.
+ JPEG images compressed with 4:1:1 subsampling will be almost exactly the
+ same size as those compressed with 4:2:0 subsampling, and in the
+ aggregate, both subsampling methods produce approximately the same
+ perceptual quality.  However, 4:1:1 is better able to reproduce sharp
+ horizontal features.  Note that 4:1:1 subsampling is not fully accelerated
+ in libjpeg-turbo.</div>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../constant-values.html#org.libjpegturbo.turbojpeg.TJ.SAMP_411">Constant Field Values</a></dd></dl>
+</li>
+</ul>
+<a name="NUMPF">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>NUMPF</h4>
+<pre>public static final&nbsp;int NUMPF</pre>
+<div class="block">The number of pixel formats</div>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../constant-values.html#org.libjpegturbo.turbojpeg.TJ.NUMPF">Constant Field Values</a></dd></dl>
+</li>
+</ul>
+<a name="PF_RGB">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>PF_RGB</h4>
+<pre>public static final&nbsp;int PF_RGB</pre>
+<div class="block">RGB pixel format.  The red, green, and blue components in the image are
+ stored in 3-byte pixels in the order R, G, B from lowest to highest byte
+ address within each pixel.</div>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../constant-values.html#org.libjpegturbo.turbojpeg.TJ.PF_RGB">Constant Field Values</a></dd></dl>
+</li>
+</ul>
+<a name="PF_BGR">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>PF_BGR</h4>
+<pre>public static final&nbsp;int PF_BGR</pre>
+<div class="block">BGR pixel format.  The red, green, and blue components in the image are
+ stored in 3-byte pixels in the order B, G, R from lowest to highest byte
+ address within each pixel.</div>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../constant-values.html#org.libjpegturbo.turbojpeg.TJ.PF_BGR">Constant Field Values</a></dd></dl>
+</li>
+</ul>
+<a name="PF_RGBX">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>PF_RGBX</h4>
+<pre>public static final&nbsp;int PF_RGBX</pre>
+<div class="block">RGBX pixel format.  The red, green, and blue components in the image are
+ stored in 4-byte pixels in the order R, G, B from lowest to highest byte
+ address within each pixel.  The X component is ignored when compressing
+ and undefined when decompressing.</div>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../constant-values.html#org.libjpegturbo.turbojpeg.TJ.PF_RGBX">Constant Field Values</a></dd></dl>
+</li>
+</ul>
+<a name="PF_BGRX">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>PF_BGRX</h4>
+<pre>public static final&nbsp;int PF_BGRX</pre>
+<div class="block">BGRX pixel format.  The red, green, and blue components in the image are
+ stored in 4-byte pixels in the order B, G, R from lowest to highest byte
+ address within each pixel.  The X component is ignored when compressing
+ and undefined when decompressing.</div>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../constant-values.html#org.libjpegturbo.turbojpeg.TJ.PF_BGRX">Constant Field Values</a></dd></dl>
+</li>
+</ul>
+<a name="PF_XBGR">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>PF_XBGR</h4>
+<pre>public static final&nbsp;int PF_XBGR</pre>
+<div class="block">XBGR pixel format.  The red, green, and blue components in the image are
+ stored in 4-byte pixels in the order R, G, B from highest to lowest byte
+ address within each pixel.  The X component is ignored when compressing
+ and undefined when decompressing.</div>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../constant-values.html#org.libjpegturbo.turbojpeg.TJ.PF_XBGR">Constant Field Values</a></dd></dl>
+</li>
+</ul>
+<a name="PF_XRGB">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>PF_XRGB</h4>
+<pre>public static final&nbsp;int PF_XRGB</pre>
+<div class="block">XRGB pixel format.  The red, green, and blue components in the image are
+ stored in 4-byte pixels in the order B, G, R from highest to lowest byte
+ address within each pixel.  The X component is ignored when compressing
+ and undefined when decompressing.</div>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../constant-values.html#org.libjpegturbo.turbojpeg.TJ.PF_XRGB">Constant Field Values</a></dd></dl>
+</li>
+</ul>
+<a name="PF_GRAY">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>PF_GRAY</h4>
+<pre>public static final&nbsp;int PF_GRAY</pre>
+<div class="block">Grayscale pixel format.  Each 1-byte pixel represents a luminance
+ (brightness) level from 0 to 255.</div>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../constant-values.html#org.libjpegturbo.turbojpeg.TJ.PF_GRAY">Constant Field Values</a></dd></dl>
+</li>
+</ul>
+<a name="PF_RGBA">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>PF_RGBA</h4>
+<pre>public static final&nbsp;int PF_RGBA</pre>
+<div class="block">RGBA pixel format.  This is the same as <a href="../../../org/libjpegturbo/turbojpeg/TJ.html#PF_RGBX"><code>PF_RGBX</code></a>, except that when
+ decompressing, the X byte is guaranteed to be 0xFF, which can be
+ interpreted as an opaque alpha channel.</div>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../constant-values.html#org.libjpegturbo.turbojpeg.TJ.PF_RGBA">Constant Field Values</a></dd></dl>
+</li>
+</ul>
+<a name="PF_BGRA">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>PF_BGRA</h4>
+<pre>public static final&nbsp;int PF_BGRA</pre>
+<div class="block">BGRA pixel format.  This is the same as <a href="../../../org/libjpegturbo/turbojpeg/TJ.html#PF_BGRX"><code>PF_BGRX</code></a>, except that when
+ decompressing, the X byte is guaranteed to be 0xFF, which can be
+ interpreted as an opaque alpha channel.</div>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../constant-values.html#org.libjpegturbo.turbojpeg.TJ.PF_BGRA">Constant Field Values</a></dd></dl>
+</li>
+</ul>
+<a name="PF_ABGR">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>PF_ABGR</h4>
+<pre>public static final&nbsp;int PF_ABGR</pre>
+<div class="block">ABGR pixel format.  This is the same as <a href="../../../org/libjpegturbo/turbojpeg/TJ.html#PF_XBGR"><code>PF_XBGR</code></a>, except that when
+ decompressing, the X byte is guaranteed to be 0xFF, which can be
+ interpreted as an opaque alpha channel.</div>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../constant-values.html#org.libjpegturbo.turbojpeg.TJ.PF_ABGR">Constant Field Values</a></dd></dl>
+</li>
+</ul>
+<a name="PF_ARGB">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>PF_ARGB</h4>
+<pre>public static final&nbsp;int PF_ARGB</pre>
+<div class="block">ARGB pixel format.  This is the same as <a href="../../../org/libjpegturbo/turbojpeg/TJ.html#PF_XRGB"><code>PF_XRGB</code></a>, except that when
+ decompressing, the X byte is guaranteed to be 0xFF, which can be
+ interpreted as an opaque alpha channel.</div>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../constant-values.html#org.libjpegturbo.turbojpeg.TJ.PF_ARGB">Constant Field Values</a></dd></dl>
+</li>
+</ul>
+<a name="PF_CMYK">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>PF_CMYK</h4>
+<pre>public static final&nbsp;int PF_CMYK</pre>
+<div class="block">CMYK pixel format.  Unlike RGB, which is an additive color model used
+ primarily for display, CMYK (Cyan/Magenta/Yellow/Key) is a subtractive
+ color model used primarily for printing.  In the CMYK color model, the
+ value of each color component typically corresponds to an amount of cyan,
+ magenta, yellow, or black ink that is applied to a white background.  In
+ order to convert between CMYK and RGB, it is necessary to use a color
+ management system (CMS.)  A CMS will attempt to map colors within the
+ printer's gamut to perceptually similar colors in the display's gamut and
+ vice versa, but the mapping is typically not 1:1 or reversible, nor can it
+ be defined with a simple formula.  Thus, such a conversion is out of scope
+ for a codec library.  However, the TurboJPEG API allows for compressing
+ CMYK pixels into a YCCK JPEG image (see <a href="../../../org/libjpegturbo/turbojpeg/TJ.html#CS_YCCK"><code>CS_YCCK</code></a>) and
+ decompressing YCCK JPEG images into CMYK pixels.</div>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../constant-values.html#org.libjpegturbo.turbojpeg.TJ.PF_CMYK">Constant Field Values</a></dd></dl>
+</li>
+</ul>
+<a name="NUMCS">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>NUMCS</h4>
+<pre>public static final&nbsp;int NUMCS</pre>
+<div class="block">The number of JPEG colorspaces</div>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../constant-values.html#org.libjpegturbo.turbojpeg.TJ.NUMCS">Constant Field Values</a></dd></dl>
+</li>
+</ul>
+<a name="CS_RGB">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>CS_RGB</h4>
+<pre>public static final&nbsp;int CS_RGB</pre>
+<div class="block">RGB colorspace.  When compressing the JPEG image, the R, G, and B
+ components in the source image are reordered into image planes, but no
+ colorspace conversion or subsampling is performed.  RGB JPEG images can be
+ decompressed to any of the extended RGB pixel formats or grayscale, but
+ they cannot be decompressed to YUV images.</div>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../constant-values.html#org.libjpegturbo.turbojpeg.TJ.CS_RGB">Constant Field Values</a></dd></dl>
+</li>
+</ul>
+<a name="CS_YCbCr">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>CS_YCbCr</h4>
+<pre>public static final&nbsp;int CS_YCbCr</pre>
+<div class="block">YCbCr colorspace.  YCbCr is not an absolute colorspace but rather a
+ mathematical transformation of RGB designed solely for storage and
+ transmission.  YCbCr images must be converted to RGB before they can
+ actually be displayed.  In the YCbCr colorspace, the Y (luminance)
+ component represents the black &amp; white portion of the original image,
+ and the Cb and Cr (chrominance) components represent the color portion of
+ the original image.  Originally, the analog equivalent of this
+ transformation allowed the same signal to drive both black &amp; white and
+ color televisions, but JPEG images use YCbCr primarily because it allows
+ the color data to be optionally subsampled for the purposes of reducing
+ bandwidth or disk space.  YCbCr is the most common JPEG colorspace, and
+ YCbCr JPEG images can be compressed from and decompressed to any of the
+ extended RGB pixel formats or grayscale, or they can be decompressed to
+ YUV planar images.</div>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../constant-values.html#org.libjpegturbo.turbojpeg.TJ.CS_YCbCr">Constant Field Values</a></dd></dl>
+</li>
+</ul>
+<a name="CS_GRAY">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>CS_GRAY</h4>
+<pre>public static final&nbsp;int CS_GRAY</pre>
+<div class="block">Grayscale colorspace.  The JPEG image retains only the luminance data (Y
+ component), and any color data from the source image is discarded.
+ Grayscale JPEG images can be compressed from and decompressed to any of
+ the extended RGB pixel formats or grayscale, or they can be decompressed
+ to YUV planar images.</div>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../constant-values.html#org.libjpegturbo.turbojpeg.TJ.CS_GRAY">Constant Field Values</a></dd></dl>
+</li>
+</ul>
+<a name="CS_CMYK">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>CS_CMYK</h4>
+<pre>public static final&nbsp;int CS_CMYK</pre>
+<div class="block">CMYK colorspace.  When compressing the JPEG image, the C, M, Y, and K
+ components in the source image are reordered into image planes, but no
+ colorspace conversion or subsampling is performed.  CMYK JPEG images can
+ only be decompressed to CMYK pixels.</div>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../constant-values.html#org.libjpegturbo.turbojpeg.TJ.CS_CMYK">Constant Field Values</a></dd></dl>
+</li>
+</ul>
+<a name="CS_YCCK">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>CS_YCCK</h4>
+<pre>public static final&nbsp;int CS_YCCK</pre>
+<div class="block">YCCK colorspace.  YCCK (AKA "YCbCrK") is not an absolute colorspace but
+ rather a mathematical transformation of CMYK designed solely for storage
+ and transmission.  It is to CMYK as YCbCr is to RGB.  CMYK pixels can be
+ reversibly transformed into YCCK, and as with YCbCr, the chrominance
+ components in the YCCK pixels can be subsampled without incurring major
+ perceptual loss.  YCCK JPEG images can only be compressed from and
+ decompressed to CMYK pixels.</div>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../constant-values.html#org.libjpegturbo.turbojpeg.TJ.CS_YCCK">Constant Field Values</a></dd></dl>
+</li>
+</ul>
+<a name="FLAG_BOTTOMUP">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>FLAG_BOTTOMUP</h4>
+<pre>public static final&nbsp;int FLAG_BOTTOMUP</pre>
+<div class="block">The uncompressed source/destination image is stored in bottom-up (Windows,
+ OpenGL) order, not top-down (X11) order.</div>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../constant-values.html#org.libjpegturbo.turbojpeg.TJ.FLAG_BOTTOMUP">Constant Field Values</a></dd></dl>
+</li>
+</ul>
+<a name="FLAG_FORCEMMX">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>FLAG_FORCEMMX</h4>
+<pre>@Deprecated
+public static final&nbsp;int FLAG_FORCEMMX</pre>
+<div class="block"><span class="strong">Deprecated.</span>&nbsp;</div>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../constant-values.html#org.libjpegturbo.turbojpeg.TJ.FLAG_FORCEMMX">Constant Field Values</a></dd></dl>
+</li>
+</ul>
+<a name="FLAG_FORCESSE">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>FLAG_FORCESSE</h4>
+<pre>@Deprecated
+public static final&nbsp;int FLAG_FORCESSE</pre>
+<div class="block"><span class="strong">Deprecated.</span>&nbsp;</div>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../constant-values.html#org.libjpegturbo.turbojpeg.TJ.FLAG_FORCESSE">Constant Field Values</a></dd></dl>
+</li>
+</ul>
+<a name="FLAG_FORCESSE2">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>FLAG_FORCESSE2</h4>
+<pre>@Deprecated
+public static final&nbsp;int FLAG_FORCESSE2</pre>
+<div class="block"><span class="strong">Deprecated.</span>&nbsp;</div>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../constant-values.html#org.libjpegturbo.turbojpeg.TJ.FLAG_FORCESSE2">Constant Field Values</a></dd></dl>
+</li>
+</ul>
+<a name="FLAG_FORCESSE3">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>FLAG_FORCESSE3</h4>
+<pre>@Deprecated
+public static final&nbsp;int FLAG_FORCESSE3</pre>
+<div class="block"><span class="strong">Deprecated.</span>&nbsp;</div>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../constant-values.html#org.libjpegturbo.turbojpeg.TJ.FLAG_FORCESSE3">Constant Field Values</a></dd></dl>
+</li>
+</ul>
+<a name="FLAG_FASTUPSAMPLE">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>FLAG_FASTUPSAMPLE</h4>
+<pre>public static final&nbsp;int FLAG_FASTUPSAMPLE</pre>
+<div class="block">When decompressing an image that was compressed using chrominance
+ subsampling, use the fastest chrominance upsampling algorithm available in
+ the underlying codec.  The default is to use smooth upsampling, which
+ creates a smooth transition between neighboring chrominance components in
+ order to reduce upsampling artifacts in the decompressed image.</div>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../constant-values.html#org.libjpegturbo.turbojpeg.TJ.FLAG_FASTUPSAMPLE">Constant Field Values</a></dd></dl>
+</li>
+</ul>
+<a name="FLAG_FASTDCT">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>FLAG_FASTDCT</h4>
+<pre>public static final&nbsp;int FLAG_FASTDCT</pre>
+<div class="block">Use the fastest DCT/IDCT algorithm available in the underlying codec.  The
+ default if this flag is not specified is implementation-specific.  For
+ example, the implementation of TurboJPEG for libjpeg[-turbo] uses the fast
+ algorithm by default when compressing, because this has been shown to have
+ only a very slight effect on accuracy, but it uses the accurate algorithm
+ when decompressing, because this has been shown to have a larger effect.</div>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../constant-values.html#org.libjpegturbo.turbojpeg.TJ.FLAG_FASTDCT">Constant Field Values</a></dd></dl>
+</li>
+</ul>
+<a name="FLAG_ACCURATEDCT">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>FLAG_ACCURATEDCT</h4>
+<pre>public static final&nbsp;int FLAG_ACCURATEDCT</pre>
+<div class="block">Use the most accurate DCT/IDCT algorithm available in the underlying
+ codec.  The default if this flag is not specified is
+ implementation-specific.  For example, the implementation of TurboJPEG for
+ libjpeg[-turbo] uses the fast algorithm by default when compressing,
+ because this has been shown to have only a very slight effect on accuracy,
+ but it uses the accurate algorithm when decompressing, because this has
+ been shown to have a larger effect.</div>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../constant-values.html#org.libjpegturbo.turbojpeg.TJ.FLAG_ACCURATEDCT">Constant Field Values</a></dd></dl>
+</li>
+</ul>
+<a name="FLAG_STOPONWARNING">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>FLAG_STOPONWARNING</h4>
+<pre>public static final&nbsp;int FLAG_STOPONWARNING</pre>
+<div class="block">Immediately discontinue the current compression/decompression/transform
+ operation if the underlying codec throws a warning (non-fatal error).  The
+ default behavior is to allow the operation to complete unless a fatal
+ error is encountered.
+ <p>
+ NOTE: due to the design of the TurboJPEG Java API, only certain methods
+ (specifically, <a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html" title="class in org.libjpegturbo.turbojpeg"><code>TJDecompressor.decompress*()</code></a> methods
+ with a void return type) will complete and leave the output image in a
+ fully recoverable state after a non-fatal error occurs.</div>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../constant-values.html#org.libjpegturbo.turbojpeg.TJ.FLAG_STOPONWARNING">Constant Field Values</a></dd></dl>
+</li>
+</ul>
+<a name="FLAG_PROGRESSIVE">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>FLAG_PROGRESSIVE</h4>
+<pre>public static final&nbsp;int FLAG_PROGRESSIVE</pre>
+<div class="block">Use progressive entropy coding in JPEG images generated by compression and
+ transform operations.  Progressive entropy coding will generally improve
+ compression relative to baseline entropy coding (the default), but it will
+ reduce compression and decompression performance considerably.</div>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../constant-values.html#org.libjpegturbo.turbojpeg.TJ.FLAG_PROGRESSIVE">Constant Field Values</a></dd></dl>
+</li>
+</ul>
+<a name="NUMERR">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>NUMERR</h4>
+<pre>public static final&nbsp;int NUMERR</pre>
+<div class="block">The number of error codes</div>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../constant-values.html#org.libjpegturbo.turbojpeg.TJ.NUMERR">Constant Field Values</a></dd></dl>
+</li>
+</ul>
+<a name="ERR_WARNING">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>ERR_WARNING</h4>
+<pre>public static final&nbsp;int ERR_WARNING</pre>
+<div class="block">The error was non-fatal and recoverable, but the image may still be
+ corrupt.
+ <p>
+ NOTE: due to the design of the TurboJPEG Java API, only certain methods
+ (specifically, <a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html" title="class in org.libjpegturbo.turbojpeg"><code>TJDecompressor.decompress*()</code></a> methods
+ with a void return type) will complete and leave the output image in a
+ fully recoverable state after a non-fatal error occurs.</div>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../constant-values.html#org.libjpegturbo.turbojpeg.TJ.ERR_WARNING">Constant Field Values</a></dd></dl>
+</li>
+</ul>
+<a name="ERR_FATAL">
+<!--   -->
+</a>
+<ul class="blockListLast">
+<li class="blockList">
+<h4>ERR_FATAL</h4>
+<pre>public static final&nbsp;int ERR_FATAL</pre>
+<div class="block">The error was fatal and non-recoverable.</div>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../constant-values.html#org.libjpegturbo.turbojpeg.TJ.ERR_FATAL">Constant Field Values</a></dd></dl>
+</li>
+</ul>
+</li>
+</ul>
+<!-- ============ METHOD DETAIL ========== -->
+<ul class="blockList">
+<li class="blockList"><a name="method_detail">
+<!--   -->
+</a>
+<h3>Method Detail</h3>
+<a name="getMCUWidth(int)">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>getMCUWidth</h4>
+<pre>public static&nbsp;int&nbsp;getMCUWidth(int&nbsp;subsamp)</pre>
+<div class="block">Returns the MCU block width for the given level of chrominance
+ subsampling.</div>
+<dl><dt><span class="strong">Parameters:</span></dt><dd><code>subsamp</code> - the level of chrominance subsampling (one of
+ <code>SAMP_*</code>)</dd>
+<dt><span class="strong">Returns:</span></dt><dd>the MCU block width for the given level of chrominance
+ subsampling.</dd></dl>
+</li>
+</ul>
+<a name="getMCUHeight(int)">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>getMCUHeight</h4>
+<pre>public static&nbsp;int&nbsp;getMCUHeight(int&nbsp;subsamp)</pre>
+<div class="block">Returns the MCU block height for the given level of chrominance
+ subsampling.</div>
+<dl><dt><span class="strong">Parameters:</span></dt><dd><code>subsamp</code> - the level of chrominance subsampling (one of
+ <code>SAMP_*</code>)</dd>
+<dt><span class="strong">Returns:</span></dt><dd>the MCU block height for the given level of chrominance
+ subsampling.</dd></dl>
+</li>
+</ul>
+<a name="getPixelSize(int)">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>getPixelSize</h4>
+<pre>public static&nbsp;int&nbsp;getPixelSize(int&nbsp;pixelFormat)</pre>
+<div class="block">Returns the pixel size (in bytes) for the given pixel format.</div>
+<dl><dt><span class="strong">Parameters:</span></dt><dd><code>pixelFormat</code> - the pixel format (one of <code>PF_*</code>)</dd>
+<dt><span class="strong">Returns:</span></dt><dd>the pixel size (in bytes) for the given pixel format.</dd></dl>
+</li>
+</ul>
+<a name="getRedOffset(int)">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>getRedOffset</h4>
+<pre>public static&nbsp;int&nbsp;getRedOffset(int&nbsp;pixelFormat)</pre>
+<div class="block">For the given pixel format, returns the number of bytes that the red
+ component is offset from the start of the pixel.  For instance, if a pixel
+ of format <code>TJ.PF_BGRX</code> is stored in <code>char pixel[]</code>,
+ then the red component will be
+ <code>pixel[TJ.getRedOffset(TJ.PF_BGRX)]</code>.</div>
+<dl><dt><span class="strong">Parameters:</span></dt><dd><code>pixelFormat</code> - the pixel format (one of <code>PF_*</code>)</dd>
+<dt><span class="strong">Returns:</span></dt><dd>the red offset for the given pixel format, or -1 if the pixel
+ format does not have a red component.</dd></dl>
+</li>
+</ul>
+<a name="getGreenOffset(int)">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>getGreenOffset</h4>
+<pre>public static&nbsp;int&nbsp;getGreenOffset(int&nbsp;pixelFormat)</pre>
+<div class="block">For the given pixel format, returns the number of bytes that the green
+ component is offset from the start of the pixel.  For instance, if a pixel
+ of format <code>TJ.PF_BGRX</code> is stored in <code>char pixel[]</code>,
+ then the green component will be
+ <code>pixel[TJ.getGreenOffset(TJ.PF_BGRX)]</code>.</div>
+<dl><dt><span class="strong">Parameters:</span></dt><dd><code>pixelFormat</code> - the pixel format (one of <code>PF_*</code>)</dd>
+<dt><span class="strong">Returns:</span></dt><dd>the green offset for the given pixel format, or -1 if the pixel
+ format does not have a green component.</dd></dl>
+</li>
+</ul>
+<a name="getBlueOffset(int)">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>getBlueOffset</h4>
+<pre>public static&nbsp;int&nbsp;getBlueOffset(int&nbsp;pixelFormat)</pre>
+<div class="block">For the given pixel format, returns the number of bytes that the blue
+ component is offset from the start of the pixel.  For instance, if a pixel
+ of format <code>TJ.PF_BGRX</code> is stored in <code>char pixel[]</code>,
+ then the blue component will be
+ <code>pixel[TJ.getBlueOffset(TJ.PF_BGRX)]</code>.</div>
+<dl><dt><span class="strong">Parameters:</span></dt><dd><code>pixelFormat</code> - the pixel format (one of <code>PF_*</code>)</dd>
+<dt><span class="strong">Returns:</span></dt><dd>the blue offset for the given pixel format, or -1 if the pixel
+ format does not have a blue component.</dd></dl>
+</li>
+</ul>
+<a name="getAlphaOffset(int)">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>getAlphaOffset</h4>
+<pre>public static&nbsp;int&nbsp;getAlphaOffset(int&nbsp;pixelFormat)</pre>
+<div class="block">For the given pixel format, returns the number of bytes that the alpha
+ component is offset from the start of the pixel.  For instance, if a pixel
+ of format <code>TJ.PF_BGRA</code> is stored in <code>char pixel[]</code>,
+ then the alpha component will be
+ <code>pixel[TJ.getAlphaOffset(TJ.PF_BGRA)]</code>.</div>
+<dl><dt><span class="strong">Parameters:</span></dt><dd><code>pixelFormat</code> - the pixel format (one of <code>PF_*</code>)</dd>
+<dt><span class="strong">Returns:</span></dt><dd>the alpha offset for the given pixel format, or -1 if the pixel
+ format does not have a alpha component.</dd></dl>
+</li>
+</ul>
+<a name="bufSize(int, int, int)">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>bufSize</h4>
+<pre>public static&nbsp;int&nbsp;bufSize(int&nbsp;width,
+          int&nbsp;height,
+          int&nbsp;jpegSubsamp)</pre>
+<div class="block">Returns the maximum size of the buffer (in bytes) required to hold a JPEG
+ image with the given width, height, and level of chrominance subsampling.</div>
+<dl><dt><span class="strong">Parameters:</span></dt><dd><code>width</code> - the width (in pixels) of the JPEG image</dd><dd><code>height</code> - the height (in pixels) of the JPEG image</dd><dd><code>jpegSubsamp</code> - the level of chrominance subsampling to be used when
+ generating the JPEG image (one of <a href="../../../org/libjpegturbo/turbojpeg/TJ.html" title="class in org.libjpegturbo.turbojpeg"><code>TJ.SAMP_*</code></a>)</dd>
+<dt><span class="strong">Returns:</span></dt><dd>the maximum size of the buffer (in bytes) required to hold a JPEG
+ image with the given width, height, and level of chrominance subsampling.</dd></dl>
+</li>
+</ul>
+<a name="bufSizeYUV(int, int, int, int)">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>bufSizeYUV</h4>
+<pre>public static&nbsp;int&nbsp;bufSizeYUV(int&nbsp;width,
+             int&nbsp;pad,
+             int&nbsp;height,
+             int&nbsp;subsamp)</pre>
+<div class="block">Returns the size of the buffer (in bytes) required to hold a YUV planar
+ image with the given width, height, and level of chrominance subsampling.</div>
+<dl><dt><span class="strong">Parameters:</span></dt><dd><code>width</code> - the width (in pixels) of the YUV image</dd><dd><code>pad</code> - the width of each line in each plane of the image is padded to
+ the nearest multiple of this number of bytes (must be a power of 2.)</dd><dd><code>height</code> - the height (in pixels) of the YUV image</dd><dd><code>subsamp</code> - the level of chrominance subsampling used in the YUV
+ image (one of <a href="../../../org/libjpegturbo/turbojpeg/TJ.html" title="class in org.libjpegturbo.turbojpeg"><code>TJ.SAMP_*</code></a>)</dd>
+<dt><span class="strong">Returns:</span></dt><dd>the size of the buffer (in bytes) required to hold a YUV planar
+ image with the given width, height, and level of chrominance subsampling.</dd></dl>
+</li>
+</ul>
+<a name="bufSizeYUV(int, int, int)">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>bufSizeYUV</h4>
+<pre>@Deprecated
+public static&nbsp;int&nbsp;bufSizeYUV(int&nbsp;width,
+                        int&nbsp;height,
+                        int&nbsp;subsamp)</pre>
+<div class="block"><span class="strong">Deprecated.</span>&nbsp;<i>Use <a href="../../../org/libjpegturbo/turbojpeg/TJ.html#bufSizeYUV(int,%20int,%20int,%20int)"><code>bufSizeYUV(int, int, int, int)</code></a> instead.</i></div>
+</li>
+</ul>
+<a name="planeSizeYUV(int, int, int, int, int)">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>planeSizeYUV</h4>
+<pre>public static&nbsp;int&nbsp;planeSizeYUV(int&nbsp;componentID,
+               int&nbsp;width,
+               int&nbsp;stride,
+               int&nbsp;height,
+               int&nbsp;subsamp)</pre>
+<div class="block">Returns the size of the buffer (in bytes) required to hold a YUV image
+ plane with the given parameters.</div>
+<dl><dt><span class="strong">Parameters:</span></dt><dd><code>componentID</code> - ID number of the image plane (0 = Y, 1 = U/Cb,
+ 2 = V/Cr)</dd><dd><code>width</code> - width (in pixels) of the YUV image.  NOTE: this is the width
+ of the whole image, not the plane width.</dd><dd><code>stride</code> - bytes per line in the image plane.</dd><dd><code>height</code> - height (in pixels) of the YUV image.  NOTE: this is the
+ height of the whole image, not the plane height.</dd><dd><code>subsamp</code> - the level of chrominance subsampling used in the YUV
+ image (one of <a href="../../../org/libjpegturbo/turbojpeg/TJ.html" title="class in org.libjpegturbo.turbojpeg"><code>TJ.SAMP_*</code></a>)</dd>
+<dt><span class="strong">Returns:</span></dt><dd>the size of the buffer (in bytes) required to hold a YUV planar
+ image with the given parameters.</dd></dl>
+</li>
+</ul>
+<a name="planeWidth(int, int, int)">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>planeWidth</h4>
+<pre>public static&nbsp;int&nbsp;planeWidth(int&nbsp;componentID,
+             int&nbsp;width,
+             int&nbsp;subsamp)</pre>
+<div class="block">Returns the plane width of a YUV image plane with the given parameters.
+ Refer to <a href="../../../org/libjpegturbo/turbojpeg/YUVImage.html" title="class in org.libjpegturbo.turbojpeg"><code>YUVImage</code></a> for a description of plane width.</div>
+<dl><dt><span class="strong">Parameters:</span></dt><dd><code>componentID</code> - ID number of the image plane (0 = Y, 1 = U/Cb,
+ 2 = V/Cr)</dd><dd><code>width</code> - width (in pixels) of the YUV image</dd><dd><code>subsamp</code> - the level of chrominance subsampling used in the YUV image
+ (one of <a href="../../../org/libjpegturbo/turbojpeg/TJ.html" title="class in org.libjpegturbo.turbojpeg"><code>TJ.SAMP_*</code></a>)</dd>
+<dt><span class="strong">Returns:</span></dt><dd>the plane width of a YUV image plane with the given parameters.</dd></dl>
+</li>
+</ul>
+<a name="planeHeight(int, int, int)">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>planeHeight</h4>
+<pre>public static&nbsp;int&nbsp;planeHeight(int&nbsp;componentID,
+              int&nbsp;height,
+              int&nbsp;subsamp)</pre>
+<div class="block">Returns the plane height of a YUV image plane with the given parameters.
+ Refer to <a href="../../../org/libjpegturbo/turbojpeg/YUVImage.html" title="class in org.libjpegturbo.turbojpeg"><code>YUVImage</code></a> for a description of plane height.</div>
+<dl><dt><span class="strong">Parameters:</span></dt><dd><code>componentID</code> - ID number of the image plane (0 = Y, 1 = U/Cb,
+ 2 = V/Cr)</dd><dd><code>height</code> - height (in pixels) of the YUV image</dd><dd><code>subsamp</code> - the level of chrominance subsampling used in the YUV image
+ (one of <a href="../../../org/libjpegturbo/turbojpeg/TJ.html" title="class in org.libjpegturbo.turbojpeg"><code>TJ.SAMP_*</code></a>)</dd>
+<dt><span class="strong">Returns:</span></dt><dd>the plane height of a YUV image plane with the given parameters.</dd></dl>
+</li>
+</ul>
+<a name="getScalingFactors()">
+<!--   -->
+</a>
+<ul class="blockListLast">
+<li class="blockList">
+<h4>getScalingFactors</h4>
+<pre>public static&nbsp;<a href="../../../org/libjpegturbo/turbojpeg/TJScalingFactor.html" title="class in org.libjpegturbo.turbojpeg">TJScalingFactor</a>[]&nbsp;getScalingFactors()</pre>
+<div class="block">Returns a list of fractional scaling factors that the JPEG decompressor in
+ this implementation of TurboJPEG supports.</div>
+<dl><dt><span class="strong">Returns:</span></dt><dd>a list of fractional scaling factors that the JPEG decompressor in
+ this implementation of TurboJPEG supports.</dd></dl>
+</li>
+</ul>
+</li>
+</ul>
+</li>
+</ul>
+</div>
+</div>
+<!-- ========= END OF CLASS DATA ========= -->
+<!-- ======= START OF BOTTOM NAVBAR ====== -->
+<div class="bottomNav"><a name="navbar_bottom">
+<!--   -->
+</a><a href="#skip-navbar_bottom" title="Skip navigation links"></a><a name="navbar_bottom_firstrow">
+<!--   -->
+</a>
+<ul class="navList" title="Navigation">
+<li><a href="../../../org/libjpegturbo/turbojpeg/package-summary.html">Package</a></li>
+<li class="navBarCell1Rev">Class</li>
+<li><a href="package-tree.html">Tree</a></li>
+<li><a href="../../../deprecated-list.html">Deprecated</a></li>
+<li><a href="../../../index-all.html">Index</a></li>
+<li><a href="../../../help-doc.html">Help</a></li>
+</ul>
+</div>
+<div class="subNav">
+<ul class="navList">
+<li>Prev Class</li>
+<li><a href="../../../org/libjpegturbo/turbojpeg/TJCompressor.html" title="class in org.libjpegturbo.turbojpeg"><span class="strong">Next Class</span></a></li>
+</ul>
+<ul class="navList">
+<li><a href="../../../index.html?org/libjpegturbo/turbojpeg/TJ.html" target="_top">Frames</a></li>
+<li><a href="TJ.html" target="_top">No Frames</a></li>
+</ul>
+<ul class="navList" id="allclasses_navbar_bottom">
+<li><a href="../../../allclasses-noframe.html">All Classes</a></li>
+</ul>
+<div>
+<script type="text/javascript"><!--
+  allClassesLink = document.getElementById("allclasses_navbar_bottom");
+  if(window==top) {
+    allClassesLink.style.display = "block";
+  }
+  else {
+    allClassesLink.style.display = "none";
+  }
+  //-->
+</script>
+</div>
+<div>
+<ul class="subNavList">
+<li>Summary:&nbsp;</li>
+<li>Nested&nbsp;|&nbsp;</li>
+<li><a href="#field_summary">Field</a>&nbsp;|&nbsp;</li>
+<li>Constr&nbsp;|&nbsp;</li>
+<li><a href="#method_summary">Method</a></li>
+</ul>
+<ul class="subNavList">
+<li>Detail:&nbsp;</li>
+<li><a href="#field_detail">Field</a>&nbsp;|&nbsp;</li>
+<li>Constr&nbsp;|&nbsp;</li>
+<li><a href="#method_detail">Method</a></li>
+</ul>
+</div>
+<a name="skip-navbar_bottom">
+<!--   -->
+</a></div>
+<!-- ======== END OF BOTTOM NAVBAR ======= -->
+</body>
+</html>
diff --git a/3rdparty/libjpeg/src/java/doc/org/libjpegturbo/turbojpeg/TJCompressor.html b/3rdparty/libjpeg/src/java/doc/org/libjpegturbo/turbojpeg/TJCompressor.html
new file mode 100644
index 00000000..a53f8797
--- /dev/null
+++ b/3rdparty/libjpeg/src/java/doc/org/libjpegturbo/turbojpeg/TJCompressor.html
@@ -0,0 +1,926 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!-- NewPage -->
+<html lang="en">
+<head>
+<title>TJCompressor</title>
+<link rel="stylesheet" type="text/css" href="../../../stylesheet.css" title="Style">
+</head>
+<body>
+<script type="text/javascript"><!--
+    try {
+        if (location.href.indexOf('is-external=true') == -1) {
+            parent.document.title="TJCompressor";
+        }
+    }
+    catch(err) {
+    }
+//-->
+</script>
+<noscript>
+<div>JavaScript is disabled on your browser.</div>
+</noscript>
+<!-- ========= START OF TOP NAVBAR ======= -->
+<div class="topNav"><a name="navbar_top">
+<!--   -->
+</a><a href="#skip-navbar_top" title="Skip navigation links"></a><a name="navbar_top_firstrow">
+<!--   -->
+</a>
+<ul class="navList" title="Navigation">
+<li><a href="../../../org/libjpegturbo/turbojpeg/package-summary.html">Package</a></li>
+<li class="navBarCell1Rev">Class</li>
+<li><a href="package-tree.html">Tree</a></li>
+<li><a href="../../../deprecated-list.html">Deprecated</a></li>
+<li><a href="../../../index-all.html">Index</a></li>
+<li><a href="../../../help-doc.html">Help</a></li>
+</ul>
+</div>
+<div class="subNav">
+<ul class="navList">
+<li><a href="../../../org/libjpegturbo/turbojpeg/TJ.html" title="class in org.libjpegturbo.turbojpeg"><span class="strong">Prev Class</span></a></li>
+<li><a href="../../../org/libjpegturbo/turbojpeg/TJCustomFilter.html" title="interface in org.libjpegturbo.turbojpeg"><span class="strong">Next Class</span></a></li>
+</ul>
+<ul class="navList">
+<li><a href="../../../index.html?org/libjpegturbo/turbojpeg/TJCompressor.html" target="_top">Frames</a></li>
+<li><a href="TJCompressor.html" target="_top">No Frames</a></li>
+</ul>
+<ul class="navList" id="allclasses_navbar_top">
+<li><a href="../../../allclasses-noframe.html">All Classes</a></li>
+</ul>
+<div>
+<script type="text/javascript"><!--
+  allClassesLink = document.getElementById("allclasses_navbar_top");
+  if(window==top) {
+    allClassesLink.style.display = "block";
+  }
+  else {
+    allClassesLink.style.display = "none";
+  }
+  //-->
+</script>
+</div>
+<div>
+<ul class="subNavList">
+<li>Summary:&nbsp;</li>
+<li>Nested&nbsp;|&nbsp;</li>
+<li>Field&nbsp;|&nbsp;</li>
+<li><a href="#constructor_summary">Constr</a>&nbsp;|&nbsp;</li>
+<li><a href="#method_summary">Method</a></li>
+</ul>
+<ul class="subNavList">
+<li>Detail:&nbsp;</li>
+<li>Field&nbsp;|&nbsp;</li>
+<li><a href="#constructor_detail">Constr</a>&nbsp;|&nbsp;</li>
+<li><a href="#method_detail">Method</a></li>
+</ul>
+</div>
+<a name="skip-navbar_top">
+<!--   -->
+</a></div>
+<!-- ========= END OF TOP NAVBAR ========= -->
+<!-- ======== START OF CLASS DATA ======== -->
+<div class="header">
+<div class="subTitle">org.libjpegturbo.turbojpeg</div>
+<h2 title="Class TJCompressor" class="title">Class TJCompressor</h2>
+</div>
+<div class="contentContainer">
+<ul class="inheritance">
+<li>java.lang.Object</li>
+<li>
+<ul class="inheritance">
+<li>org.libjpegturbo.turbojpeg.TJCompressor</li>
+</ul>
+</li>
+</ul>
+<div class="description">
+<ul class="blockList">
+<li class="blockList">
+<dl>
+<dt>All Implemented Interfaces:</dt>
+<dd>java.io.Closeable, java.lang.AutoCloseable</dd>
+</dl>
+<hr>
+<br>
+<pre>public class <span class="strong">TJCompressor</span>
+extends java.lang.Object
+implements java.io.Closeable</pre>
+<div class="block">TurboJPEG compressor</div>
+</li>
+</ul>
+</div>
+<div class="summary">
+<ul class="blockList">
+<li class="blockList">
+<!-- ======== CONSTRUCTOR SUMMARY ======== -->
+<ul class="blockList">
+<li class="blockList"><a name="constructor_summary">
+<!--   -->
+</a>
+<h3>Constructor Summary</h3>
+<table class="overviewSummary" border="0" cellpadding="3" cellspacing="0" summary="Constructor Summary table, listing constructors, and an explanation">
+<caption><span>Constructors</span><span class="tabEnd">&nbsp;</span></caption>
+<tr>
+<th class="colOne" scope="col">Constructor and Description</th>
+</tr>
+<tr class="altColor">
+<td class="colOne"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJCompressor.html#TJCompressor()">TJCompressor</a></strong>()</code>
+<div class="block">Create a TurboJPEG compressor instance.</div>
+</td>
+</tr>
+<tr class="rowColor">
+<td class="colOne"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJCompressor.html#TJCompressor(java.awt.image.BufferedImage,%20int,%20int,%20int,%20int)">TJCompressor</a></strong>(java.awt.image.BufferedImage&nbsp;srcImage,
+            int&nbsp;x,
+            int&nbsp;y,
+            int&nbsp;width,
+            int&nbsp;height)</code>
+<div class="block">Create a TurboJPEG compressor instance and associate the uncompressed
+ source image stored in <code>srcImage</code> with the newly created
+ instance.</div>
+</td>
+</tr>
+<tr class="altColor">
+<td class="colOne"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJCompressor.html#TJCompressor(byte[],%20int,%20int,%20int,%20int)">TJCompressor</a></strong>(byte[]&nbsp;srcImage,
+            int&nbsp;width,
+            int&nbsp;pitch,
+            int&nbsp;height,
+            int&nbsp;pixelFormat)</code>
+<div class="block"><strong>Deprecated.</strong>&nbsp;
+<div class="block"><i>Use
+ <a href="../../../org/libjpegturbo/turbojpeg/TJCompressor.html#TJCompressor(byte[],%20int,%20int,%20int,%20int,%20int,%20int)"><code>TJCompressor(byte[], int, int, int, int, int, int)</code></a> instead.</i></div>
+</div>
+</td>
+</tr>
+<tr class="rowColor">
+<td class="colOne"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJCompressor.html#TJCompressor(byte[],%20int,%20int,%20int,%20int,%20int,%20int)">TJCompressor</a></strong>(byte[]&nbsp;srcImage,
+            int&nbsp;x,
+            int&nbsp;y,
+            int&nbsp;width,
+            int&nbsp;pitch,
+            int&nbsp;height,
+            int&nbsp;pixelFormat)</code>
+<div class="block">Create a TurboJPEG compressor instance and associate the uncompressed
+ source image stored in <code>srcImage</code> with the newly created
+ instance.</div>
+</td>
+</tr>
+</table>
+</li>
+</ul>
+<!-- ========== METHOD SUMMARY =========== -->
+<ul class="blockList">
+<li class="blockList"><a name="method_summary">
+<!--   -->
+</a>
+<h3>Method Summary</h3>
+<table class="overviewSummary" border="0" cellpadding="3" cellspacing="0" summary="Method Summary table, listing methods, and an explanation">
+<caption><span>Methods</span><span class="tabEnd">&nbsp;</span></caption>
+<tr>
+<th class="colFirst" scope="col">Modifier and Type</th>
+<th class="colLast" scope="col">Method and Description</th>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>void</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJCompressor.html#close()">close</a></strong>()</code>
+<div class="block">Free the native structures associated with this compressor instance.</div>
+</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>void</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJCompressor.html#compress(java.awt.image.BufferedImage,%20byte[],%20int)">compress</a></strong>(java.awt.image.BufferedImage&nbsp;srcImage,
+        byte[]&nbsp;dstBuf,
+        int&nbsp;flags)</code>
+<div class="block"><strong>Deprecated.</strong>&nbsp;
+<div class="block"><i>Use
+ <a href="../../../org/libjpegturbo/turbojpeg/TJCompressor.html#setSourceImage(java.awt.image.BufferedImage,%20int,%20int,%20int,%20int)"><code>setSourceImage(BufferedImage, int, int, int, int)</code></a> and
+ <a href="../../../org/libjpegturbo/turbojpeg/TJCompressor.html#compress(byte[],%20int)"><code>compress(byte[], int)</code></a> instead.</i></div>
+</div>
+</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>byte[]</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJCompressor.html#compress(java.awt.image.BufferedImage,%20int)">compress</a></strong>(java.awt.image.BufferedImage&nbsp;srcImage,
+        int&nbsp;flags)</code>
+<div class="block"><strong>Deprecated.</strong>&nbsp;
+<div class="block"><i>Use
+ <a href="../../../org/libjpegturbo/turbojpeg/TJCompressor.html#setSourceImage(java.awt.image.BufferedImage,%20int,%20int,%20int,%20int)"><code>setSourceImage(BufferedImage, int, int, int, int)</code></a> and
+ <a href="../../../org/libjpegturbo/turbojpeg/TJCompressor.html#compress(int)"><code>compress(int)</code></a> instead.</i></div>
+</div>
+</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>void</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJCompressor.html#compress(byte[],%20int)">compress</a></strong>(byte[]&nbsp;dstBuf,
+        int&nbsp;flags)</code>
+<div class="block">Compress the uncompressed source image associated with this compressor
+ instance and output a JPEG image to the given destination buffer.</div>
+</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>byte[]</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJCompressor.html#compress(int)">compress</a></strong>(int&nbsp;flags)</code>
+<div class="block">Compress the uncompressed source image associated with this compressor
+ instance and return a buffer containing a JPEG image.</div>
+</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>void</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJCompressor.html#encodeYUV(java.awt.image.BufferedImage,%20byte[],%20int)">encodeYUV</a></strong>(java.awt.image.BufferedImage&nbsp;srcImage,
+         byte[]&nbsp;dstBuf,
+         int&nbsp;flags)</code>
+<div class="block"><strong>Deprecated.</strong>&nbsp;
+<div class="block"><i>Use
+ <a href="../../../org/libjpegturbo/turbojpeg/TJCompressor.html#setSourceImage(java.awt.image.BufferedImage,%20int,%20int,%20int,%20int)"><code>setSourceImage(BufferedImage, int, int, int, int)</code></a> and
+ <a href="../../../org/libjpegturbo/turbojpeg/TJCompressor.html#encodeYUV(byte[],%20int)"><code>encodeYUV(byte[], int)</code></a> instead.</i></div>
+</div>
+</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>byte[]</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJCompressor.html#encodeYUV(java.awt.image.BufferedImage,%20int)">encodeYUV</a></strong>(java.awt.image.BufferedImage&nbsp;srcImage,
+         int&nbsp;flags)</code>
+<div class="block"><strong>Deprecated.</strong>&nbsp;
+<div class="block"><i>Use
+ <a href="../../../org/libjpegturbo/turbojpeg/TJCompressor.html#setSourceImage(java.awt.image.BufferedImage,%20int,%20int,%20int,%20int)"><code>setSourceImage(BufferedImage, int, int, int, int)</code></a> and
+ <a href="../../../org/libjpegturbo/turbojpeg/TJCompressor.html#encodeYUV(int,%20int)"><code>encodeYUV(int, int)</code></a> instead.</i></div>
+</div>
+</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>void</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJCompressor.html#encodeYUV(byte[],%20int)">encodeYUV</a></strong>(byte[]&nbsp;dstBuf,
+         int&nbsp;flags)</code>
+<div class="block"><strong>Deprecated.</strong>&nbsp;
+<div class="block"><i>Use <a href="../../../org/libjpegturbo/turbojpeg/TJCompressor.html#encodeYUV(org.libjpegturbo.turbojpeg.YUVImage,%20int)"><code>encodeYUV(YUVImage, int)</code></a> instead.</i></div>
+</div>
+</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>byte[]</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJCompressor.html#encodeYUV(int)">encodeYUV</a></strong>(int&nbsp;flags)</code>
+<div class="block"><strong>Deprecated.</strong>&nbsp;
+<div class="block"><i>Use <a href="../../../org/libjpegturbo/turbojpeg/TJCompressor.html#encodeYUV(int,%20int)"><code>encodeYUV(int, int)</code></a> instead.</i></div>
+</div>
+</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code><a href="../../../org/libjpegturbo/turbojpeg/YUVImage.html" title="class in org.libjpegturbo.turbojpeg">YUVImage</a></code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJCompressor.html#encodeYUV(int[],%20int)">encodeYUV</a></strong>(int[]&nbsp;strides,
+         int&nbsp;flags)</code>
+<div class="block">Encode the uncompressed source image associated with this compressor
+ instance into separate Y, U (Cb), and V (Cr) image planes and return a
+ <code>YUVImage</code> instance containing the encoded image planes.</div>
+</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code><a href="../../../org/libjpegturbo/turbojpeg/YUVImage.html" title="class in org.libjpegturbo.turbojpeg">YUVImage</a></code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJCompressor.html#encodeYUV(int,%20int)">encodeYUV</a></strong>(int&nbsp;pad,
+         int&nbsp;flags)</code>
+<div class="block">Encode the uncompressed source image associated with this compressor
+ instance into a unified YUV planar image buffer and return a
+ <code>YUVImage</code> instance containing the encoded image.</div>
+</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>void</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJCompressor.html#encodeYUV(org.libjpegturbo.turbojpeg.YUVImage,%20int)">encodeYUV</a></strong>(<a href="../../../org/libjpegturbo/turbojpeg/YUVImage.html" title="class in org.libjpegturbo.turbojpeg">YUVImage</a>&nbsp;dstImage,
+         int&nbsp;flags)</code>
+<div class="block">Encode the uncompressed source image associated with this compressor
+ instance into a YUV planar image and store it in the given
+ <code>YUVImage</code> instance.</div>
+</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>protected void</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJCompressor.html#finalize()">finalize</a></strong>()</code>&nbsp;</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJCompressor.html#getCompressedSize()">getCompressedSize</a></strong>()</code>
+<div class="block">Returns the size of the image (in bytes) generated by the most recent
+ compress operation.</div>
+</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>void</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJCompressor.html#setJPEGQuality(int)">setJPEGQuality</a></strong>(int&nbsp;quality)</code>
+<div class="block">Set the JPEG image quality level for subsequent compress operations.</div>
+</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>void</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJCompressor.html#setSourceImage(java.awt.image.BufferedImage,%20int,%20int,%20int,%20int)">setSourceImage</a></strong>(java.awt.image.BufferedImage&nbsp;srcImage,
+              int&nbsp;x,
+              int&nbsp;y,
+              int&nbsp;width,
+              int&nbsp;height)</code>
+<div class="block">Associate an uncompressed RGB or grayscale source image with this
+ compressor instance.</div>
+</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>void</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJCompressor.html#setSourceImage(byte[],%20int,%20int,%20int,%20int)">setSourceImage</a></strong>(byte[]&nbsp;srcImage,
+              int&nbsp;width,
+              int&nbsp;pitch,
+              int&nbsp;height,
+              int&nbsp;pixelFormat)</code>
+<div class="block"><strong>Deprecated.</strong>&nbsp;
+<div class="block"><i>Use
+ <a href="../../../org/libjpegturbo/turbojpeg/TJCompressor.html#setSourceImage(byte[],%20int,%20int,%20int,%20int,%20int,%20int)"><code>setSourceImage(byte[], int, int, int, int, int, int)</code></a> instead.</i></div>
+</div>
+</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>void</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJCompressor.html#setSourceImage(byte[],%20int,%20int,%20int,%20int,%20int,%20int)">setSourceImage</a></strong>(byte[]&nbsp;srcImage,
+              int&nbsp;x,
+              int&nbsp;y,
+              int&nbsp;width,
+              int&nbsp;pitch,
+              int&nbsp;height,
+              int&nbsp;pixelFormat)</code>
+<div class="block">Associate an uncompressed RGB, grayscale, or CMYK source image with this
+ compressor instance.</div>
+</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>void</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJCompressor.html#setSourceImage(org.libjpegturbo.turbojpeg.YUVImage)">setSourceImage</a></strong>(<a href="../../../org/libjpegturbo/turbojpeg/YUVImage.html" title="class in org.libjpegturbo.turbojpeg">YUVImage</a>&nbsp;srcImage)</code>
+<div class="block">Associate an uncompressed YUV planar source image with this compressor
+ instance.</div>
+</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>void</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJCompressor.html#setSubsamp(int)">setSubsamp</a></strong>(int&nbsp;newSubsamp)</code>
+<div class="block">Set the level of chrominance subsampling for subsequent compress/encode
+ operations.</div>
+</td>
+</tr>
+</table>
+<ul class="blockList">
+<li class="blockList"><a name="methods_inherited_from_class_java.lang.Object">
+<!--   -->
+</a>
+<h3>Methods inherited from class&nbsp;java.lang.Object</h3>
+<code>clone, equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait</code></li>
+</ul>
+</li>
+</ul>
+</li>
+</ul>
+</div>
+<div class="details">
+<ul class="blockList">
+<li class="blockList">
+<!-- ========= CONSTRUCTOR DETAIL ======== -->
+<ul class="blockList">
+<li class="blockList"><a name="constructor_detail">
+<!--   -->
+</a>
+<h3>Constructor Detail</h3>
+<a name="TJCompressor()">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>TJCompressor</h4>
+<pre>public&nbsp;TJCompressor()
+             throws <a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></pre>
+<div class="block">Create a TurboJPEG compressor instance.</div>
+<dl><dt><span class="strong">Throws:</span></dt>
+<dd><code><a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></code></dd></dl>
+</li>
+</ul>
+<a name="TJCompressor(byte[], int, int, int, int, int, int)">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>TJCompressor</h4>
+<pre>public&nbsp;TJCompressor(byte[]&nbsp;srcImage,
+            int&nbsp;x,
+            int&nbsp;y,
+            int&nbsp;width,
+            int&nbsp;pitch,
+            int&nbsp;height,
+            int&nbsp;pixelFormat)
+             throws <a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></pre>
+<div class="block">Create a TurboJPEG compressor instance and associate the uncompressed
+ source image stored in <code>srcImage</code> with the newly created
+ instance.</div>
+<dl><dt><span class="strong">Parameters:</span></dt><dd><code>srcImage</code> - see <a href="../../../org/libjpegturbo/turbojpeg/TJCompressor.html#setSourceImage(byte[],%20int,%20int,%20int,%20int,%20int,%20int)"><code>setSourceImage(byte[], int, int, int, int, int, int)</code></a> for description</dd><dd><code>x</code> - see <a href="../../../org/libjpegturbo/turbojpeg/TJCompressor.html#setSourceImage(byte[],%20int,%20int,%20int,%20int,%20int,%20int)"><code>setSourceImage(byte[], int, int, int, int, int, int)</code></a> for description</dd><dd><code>y</code> - see <a href="../../../org/libjpegturbo/turbojpeg/TJCompressor.html#setSourceImage(byte[],%20int,%20int,%20int,%20int,%20int,%20int)"><code>setSourceImage(byte[], int, int, int, int, int, int)</code></a> for description</dd><dd><code>width</code> - see <a href="../../../org/libjpegturbo/turbojpeg/TJCompressor.html#setSourceImage(byte[],%20int,%20int,%20int,%20int,%20int,%20int)"><code>setSourceImage(byte[], int, int, int, int, int, int)</code></a> for description</dd><dd><code>pitch</code> - see <a href="../../../org/libjpegturbo/turbojpeg/TJCompressor.html#setSourceImage(byte[],%20int,%20int,%20int,%20int,%20int,%20int)"><code>setSourceImage(byte[], int, int, int, int, int, int)</code></a> for description</dd><dd><code>height</code> - see <a href="../../../org/libjpegturbo/turbojpeg/TJCompressor.html#setSourceImage(byte[],%20int,%20int,%20int,%20int,%20int,%20int)"><code>setSourceImage(byte[], int, int, int, int, int, int)</code></a> for description</dd><dd><code>pixelFormat</code> - pixel format of the source image (one of
+ <a href="../../../org/libjpegturbo/turbojpeg/TJ.html#PF_RGB"><code>TJ.PF_*</code></a>)</dd>
+<dt><span class="strong">Throws:</span></dt>
+<dd><code><a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></code></dd></dl>
+</li>
+</ul>
+<a name="TJCompressor(byte[], int, int, int, int)">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>TJCompressor</h4>
+<pre>@Deprecated
+public&nbsp;TJCompressor(byte[]&nbsp;srcImage,
+                       int&nbsp;width,
+                       int&nbsp;pitch,
+                       int&nbsp;height,
+                       int&nbsp;pixelFormat)
+             throws <a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></pre>
+<div class="block"><span class="strong">Deprecated.</span>&nbsp;<i>Use
+ <a href="../../../org/libjpegturbo/turbojpeg/TJCompressor.html#TJCompressor(byte[],%20int,%20int,%20int,%20int,%20int,%20int)"><code>TJCompressor(byte[], int, int, int, int, int, int)</code></a> instead.</i></div>
+<dl><dt><span class="strong">Throws:</span></dt>
+<dd><code><a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></code></dd></dl>
+</li>
+</ul>
+<a name="TJCompressor(java.awt.image.BufferedImage, int, int, int, int)">
+<!--   -->
+</a>
+<ul class="blockListLast">
+<li class="blockList">
+<h4>TJCompressor</h4>
+<pre>public&nbsp;TJCompressor(java.awt.image.BufferedImage&nbsp;srcImage,
+            int&nbsp;x,
+            int&nbsp;y,
+            int&nbsp;width,
+            int&nbsp;height)
+             throws <a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></pre>
+<div class="block">Create a TurboJPEG compressor instance and associate the uncompressed
+ source image stored in <code>srcImage</code> with the newly created
+ instance.</div>
+<dl><dt><span class="strong">Parameters:</span></dt><dd><code>srcImage</code> - see
+ <a href="../../../org/libjpegturbo/turbojpeg/TJCompressor.html#setSourceImage(java.awt.image.BufferedImage,%20int,%20int,%20int,%20int)"><code>setSourceImage(BufferedImage, int, int, int, int)</code></a> for description</dd><dd><code>x</code> - see
+ <a href="../../../org/libjpegturbo/turbojpeg/TJCompressor.html#setSourceImage(java.awt.image.BufferedImage,%20int,%20int,%20int,%20int)"><code>setSourceImage(BufferedImage, int, int, int, int)</code></a> for description</dd><dd><code>y</code> - see
+ <a href="../../../org/libjpegturbo/turbojpeg/TJCompressor.html#setSourceImage(java.awt.image.BufferedImage,%20int,%20int,%20int,%20int)"><code>setSourceImage(BufferedImage, int, int, int, int)</code></a> for description</dd><dd><code>width</code> - see
+ <a href="../../../org/libjpegturbo/turbojpeg/TJCompressor.html#setSourceImage(java.awt.image.BufferedImage,%20int,%20int,%20int,%20int)"><code>setSourceImage(BufferedImage, int, int, int, int)</code></a> for description</dd><dd><code>height</code> - see
+ <a href="../../../org/libjpegturbo/turbojpeg/TJCompressor.html#setSourceImage(java.awt.image.BufferedImage,%20int,%20int,%20int,%20int)"><code>setSourceImage(BufferedImage, int, int, int, int)</code></a> for description</dd>
+<dt><span class="strong">Throws:</span></dt>
+<dd><code><a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></code></dd></dl>
+</li>
+</ul>
+</li>
+</ul>
+<!-- ============ METHOD DETAIL ========== -->
+<ul class="blockList">
+<li class="blockList"><a name="method_detail">
+<!--   -->
+</a>
+<h3>Method Detail</h3>
+<a name="setSourceImage(byte[], int, int, int, int, int, int)">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>setSourceImage</h4>
+<pre>public&nbsp;void&nbsp;setSourceImage(byte[]&nbsp;srcImage,
+                  int&nbsp;x,
+                  int&nbsp;y,
+                  int&nbsp;width,
+                  int&nbsp;pitch,
+                  int&nbsp;height,
+                  int&nbsp;pixelFormat)
+                    throws <a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></pre>
+<div class="block">Associate an uncompressed RGB, grayscale, or CMYK source image with this
+ compressor instance.</div>
+<dl><dt><span class="strong">Parameters:</span></dt><dd><code>srcImage</code> - image buffer containing RGB, grayscale, or CMYK pixels to
+ be compressed or encoded.  This buffer is not modified.</dd><dd><code>x</code> - x offset (in pixels) of the region in the source image from which
+ the JPEG or YUV image should be compressed/encoded</dd><dd><code>y</code> - y offset (in pixels) of the region in the source image from which
+ the JPEG or YUV image should be compressed/encoded</dd><dd><code>width</code> - width (in pixels) of the region in the source image from
+ which the JPEG or YUV image should be compressed/encoded</dd><dd><code>pitch</code> - bytes per line of the source image.  Normally, this should be
+ <code>width * TJ.pixelSize(pixelFormat)</code> if the source image is
+ unpadded, but you can use this parameter to, for instance, specify that
+ the scanlines in the source image are padded to a 4-byte boundary or to
+ compress/encode a JPEG or YUV image from a region of a larger source
+ image.  You can also be clever and use this parameter to skip lines, etc.
+ Setting this parameter to 0 is the equivalent of setting it to
+ <code>width * TJ.pixelSize(pixelFormat)</code>.</dd><dd><code>height</code> - height (in pixels) of the region in the source image from
+ which the JPEG or YUV image should be compressed/encoded</dd><dd><code>pixelFormat</code> - pixel format of the source image (one of
+ <a href="../../../org/libjpegturbo/turbojpeg/TJ.html#PF_RGB"><code>TJ.PF_*</code></a>)</dd>
+<dt><span class="strong">Throws:</span></dt>
+<dd><code><a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></code></dd></dl>
+</li>
+</ul>
+<a name="setSourceImage(byte[], int, int, int, int)">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>setSourceImage</h4>
+<pre>@Deprecated
+public&nbsp;void&nbsp;setSourceImage(byte[]&nbsp;srcImage,
+                             int&nbsp;width,
+                             int&nbsp;pitch,
+                             int&nbsp;height,
+                             int&nbsp;pixelFormat)
+                    throws <a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></pre>
+<div class="block"><span class="strong">Deprecated.</span>&nbsp;<i>Use
+ <a href="../../../org/libjpegturbo/turbojpeg/TJCompressor.html#setSourceImage(byte[],%20int,%20int,%20int,%20int,%20int,%20int)"><code>setSourceImage(byte[], int, int, int, int, int, int)</code></a> instead.</i></div>
+<dl><dt><span class="strong">Throws:</span></dt>
+<dd><code><a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></code></dd></dl>
+</li>
+</ul>
+<a name="setSourceImage(java.awt.image.BufferedImage, int, int, int, int)">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>setSourceImage</h4>
+<pre>public&nbsp;void&nbsp;setSourceImage(java.awt.image.BufferedImage&nbsp;srcImage,
+                  int&nbsp;x,
+                  int&nbsp;y,
+                  int&nbsp;width,
+                  int&nbsp;height)
+                    throws <a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></pre>
+<div class="block">Associate an uncompressed RGB or grayscale source image with this
+ compressor instance.</div>
+<dl><dt><span class="strong">Parameters:</span></dt><dd><code>srcImage</code> - a <code>BufferedImage</code> instance containing RGB or
+ grayscale pixels to be compressed or encoded.  This image is not modified.</dd><dd><code>x</code> - x offset (in pixels) of the region in the source image from which
+ the JPEG or YUV image should be compressed/encoded</dd><dd><code>y</code> - y offset (in pixels) of the region in the source image from which
+ the JPEG or YUV image should be compressed/encoded</dd><dd><code>width</code> - width (in pixels) of the region in the source image from
+ which the JPEG or YUV image should be compressed/encoded (0 = use the
+ width of the source image)</dd><dd><code>height</code> - height (in pixels) of the region in the source image from
+ which the JPEG or YUV image should be compressed/encoded (0 = use the
+ height of the source image)</dd>
+<dt><span class="strong">Throws:</span></dt>
+<dd><code><a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></code></dd></dl>
+</li>
+</ul>
+<a name="setSourceImage(org.libjpegturbo.turbojpeg.YUVImage)">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>setSourceImage</h4>
+<pre>public&nbsp;void&nbsp;setSourceImage(<a href="../../../org/libjpegturbo/turbojpeg/YUVImage.html" title="class in org.libjpegturbo.turbojpeg">YUVImage</a>&nbsp;srcImage)
+                    throws <a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></pre>
+<div class="block">Associate an uncompressed YUV planar source image with this compressor
+ instance.</div>
+<dl><dt><span class="strong">Parameters:</span></dt><dd><code>srcImage</code> - YUV planar image to be compressed.  This image is not
+ modified.</dd>
+<dt><span class="strong">Throws:</span></dt>
+<dd><code><a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></code></dd></dl>
+</li>
+</ul>
+<a name="setSubsamp(int)">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>setSubsamp</h4>
+<pre>public&nbsp;void&nbsp;setSubsamp(int&nbsp;newSubsamp)</pre>
+<div class="block">Set the level of chrominance subsampling for subsequent compress/encode
+ operations.  When pixels are converted from RGB to YCbCr (see
+ <a href="../../../org/libjpegturbo/turbojpeg/TJ.html#CS_YCbCr"><code>TJ.CS_YCbCr</code></a>) or from CMYK to YCCK (see <a href="../../../org/libjpegturbo/turbojpeg/TJ.html#CS_YCCK"><code>TJ.CS_YCCK</code></a>) as part
+ of the JPEG compression process, some of the Cb and Cr (chrominance)
+ components can be discarded or averaged together to produce a smaller
+ image with little perceptible loss of image clarity (the human eye is more
+ sensitive to small changes in brightness than to small changes in color.)
+ This is called "chrominance subsampling".
+ <p>
+ NOTE: This method has no effect when compressing a JPEG image from a YUV
+ planar source.  In that case, the level of chrominance subsampling in
+ the JPEG image is determined by the source.  Furthermore, this method has
+ no effect when encoding to a pre-allocated <a href="../../../org/libjpegturbo/turbojpeg/YUVImage.html" title="class in org.libjpegturbo.turbojpeg"><code>YUVImage</code></a> instance.  In
+ that case, the level of chrominance subsampling is determined by the
+ destination.</div>
+<dl><dt><span class="strong">Parameters:</span></dt><dd><code>newSubsamp</code> - the level of chrominance subsampling to use in
+ subsequent compress/encode oeprations (one of
+ <a href="../../../org/libjpegturbo/turbojpeg/TJ.html#SAMP_444"><code>TJ.SAMP_*</code></a>)</dd></dl>
+</li>
+</ul>
+<a name="setJPEGQuality(int)">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>setJPEGQuality</h4>
+<pre>public&nbsp;void&nbsp;setJPEGQuality(int&nbsp;quality)</pre>
+<div class="block">Set the JPEG image quality level for subsequent compress operations.</div>
+<dl><dt><span class="strong">Parameters:</span></dt><dd><code>quality</code> - the new JPEG image quality level (1 to 100, 1 = worst,
+ 100 = best)</dd></dl>
+</li>
+</ul>
+<a name="compress(byte[], int)">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>compress</h4>
+<pre>public&nbsp;void&nbsp;compress(byte[]&nbsp;dstBuf,
+            int&nbsp;flags)
+              throws <a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></pre>
+<div class="block">Compress the uncompressed source image associated with this compressor
+ instance and output a JPEG image to the given destination buffer.</div>
+<dl><dt><span class="strong">Parameters:</span></dt><dd><code>dstBuf</code> - buffer that will receive the JPEG image.  Use
+ <a href="../../../org/libjpegturbo/turbojpeg/TJ.html#bufSize(int,%20int,%20int)"><code>TJ.bufSize(int, int, int)</code></a> to determine the maximum size for this buffer based on
+ the source image's width and height and the desired level of chrominance
+ subsampling.</dd><dd><code>flags</code> - the bitwise OR of one or more of
+ <a href="../../../org/libjpegturbo/turbojpeg/TJ.html#FLAG_BOTTOMUP"><code>TJ.FLAG_*</code></a></dd>
+<dt><span class="strong">Throws:</span></dt>
+<dd><code><a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></code></dd></dl>
+</li>
+</ul>
+<a name="compress(int)">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>compress</h4>
+<pre>public&nbsp;byte[]&nbsp;compress(int&nbsp;flags)
+                throws <a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></pre>
+<div class="block">Compress the uncompressed source image associated with this compressor
+ instance and return a buffer containing a JPEG image.</div>
+<dl><dt><span class="strong">Parameters:</span></dt><dd><code>flags</code> - the bitwise OR of one or more of
+ <a href="../../../org/libjpegturbo/turbojpeg/TJ.html#FLAG_BOTTOMUP"><code>TJ.FLAG_*</code></a></dd>
+<dt><span class="strong">Returns:</span></dt><dd>a buffer containing a JPEG image.  The length of this buffer will
+ not be equal to the size of the JPEG image.  Use <a href="../../../org/libjpegturbo/turbojpeg/TJCompressor.html#getCompressedSize()"><code>getCompressedSize()</code></a> to obtain the size of the JPEG image.</dd>
+<dt><span class="strong">Throws:</span></dt>
+<dd><code><a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></code></dd></dl>
+</li>
+</ul>
+<a name="compress(java.awt.image.BufferedImage, byte[], int)">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>compress</h4>
+<pre>@Deprecated
+public&nbsp;void&nbsp;compress(java.awt.image.BufferedImage&nbsp;srcImage,
+                       byte[]&nbsp;dstBuf,
+                       int&nbsp;flags)
+              throws <a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></pre>
+<div class="block"><span class="strong">Deprecated.</span>&nbsp;<i>Use
+ <a href="../../../org/libjpegturbo/turbojpeg/TJCompressor.html#setSourceImage(java.awt.image.BufferedImage,%20int,%20int,%20int,%20int)"><code>setSourceImage(BufferedImage, int, int, int, int)</code></a> and
+ <a href="../../../org/libjpegturbo/turbojpeg/TJCompressor.html#compress(byte[],%20int)"><code>compress(byte[], int)</code></a> instead.</i></div>
+<dl><dt><span class="strong">Throws:</span></dt>
+<dd><code><a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></code></dd></dl>
+</li>
+</ul>
+<a name="compress(java.awt.image.BufferedImage, int)">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>compress</h4>
+<pre>@Deprecated
+public&nbsp;byte[]&nbsp;compress(java.awt.image.BufferedImage&nbsp;srcImage,
+                         int&nbsp;flags)
+                throws <a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></pre>
+<div class="block"><span class="strong">Deprecated.</span>&nbsp;<i>Use
+ <a href="../../../org/libjpegturbo/turbojpeg/TJCompressor.html#setSourceImage(java.awt.image.BufferedImage,%20int,%20int,%20int,%20int)"><code>setSourceImage(BufferedImage, int, int, int, int)</code></a> and
+ <a href="../../../org/libjpegturbo/turbojpeg/TJCompressor.html#compress(int)"><code>compress(int)</code></a> instead.</i></div>
+<dl><dt><span class="strong">Throws:</span></dt>
+<dd><code><a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></code></dd></dl>
+</li>
+</ul>
+<a name="encodeYUV(org.libjpegturbo.turbojpeg.YUVImage, int)">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>encodeYUV</h4>
+<pre>public&nbsp;void&nbsp;encodeYUV(<a href="../../../org/libjpegturbo/turbojpeg/YUVImage.html" title="class in org.libjpegturbo.turbojpeg">YUVImage</a>&nbsp;dstImage,
+             int&nbsp;flags)
+               throws <a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></pre>
+<div class="block">Encode the uncompressed source image associated with this compressor
+ instance into a YUV planar image and store it in the given
+ <code>YUVImage</code> instance.   This method uses the accelerated color
+ conversion routines in TurboJPEG's underlying codec but does not execute
+ any of the other steps in the JPEG compression process.  Encoding
+ CMYK source images to YUV is not supported.</div>
+<dl><dt><span class="strong">Parameters:</span></dt><dd><code>dstImage</code> - <a href="../../../org/libjpegturbo/turbojpeg/YUVImage.html" title="class in org.libjpegturbo.turbojpeg"><code>YUVImage</code></a> instance that will receive the YUV planar
+ image</dd><dd><code>flags</code> - the bitwise OR of one or more of
+ <a href="../../../org/libjpegturbo/turbojpeg/TJ.html#FLAG_BOTTOMUP"><code>TJ.FLAG_*</code></a></dd>
+<dt><span class="strong">Throws:</span></dt>
+<dd><code><a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></code></dd></dl>
+</li>
+</ul>
+<a name="encodeYUV(byte[], int)">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>encodeYUV</h4>
+<pre>@Deprecated
+public&nbsp;void&nbsp;encodeYUV(byte[]&nbsp;dstBuf,
+                        int&nbsp;flags)
+               throws <a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></pre>
+<div class="block"><span class="strong">Deprecated.</span>&nbsp;<i>Use <a href="../../../org/libjpegturbo/turbojpeg/TJCompressor.html#encodeYUV(org.libjpegturbo.turbojpeg.YUVImage,%20int)"><code>encodeYUV(YUVImage, int)</code></a> instead.</i></div>
+<dl><dt><span class="strong">Throws:</span></dt>
+<dd><code><a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></code></dd></dl>
+</li>
+</ul>
+<a name="encodeYUV(int, int)">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>encodeYUV</h4>
+<pre>public&nbsp;<a href="../../../org/libjpegturbo/turbojpeg/YUVImage.html" title="class in org.libjpegturbo.turbojpeg">YUVImage</a>&nbsp;encodeYUV(int&nbsp;pad,
+                 int&nbsp;flags)
+                   throws <a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></pre>
+<div class="block">Encode the uncompressed source image associated with this compressor
+ instance into a unified YUV planar image buffer and return a
+ <code>YUVImage</code> instance containing the encoded image.  This method
+ uses the accelerated color conversion routines in TurboJPEG's underlying
+ codec but does not execute any of the other steps in the JPEG compression
+ process.  Encoding CMYK source images to YUV is not supported.</div>
+<dl><dt><span class="strong">Parameters:</span></dt><dd><code>pad</code> - the width of each line in each plane of the YUV image will be
+ padded to the nearest multiple of this number of bytes (must be a power of
+ 2.)</dd><dd><code>flags</code> - the bitwise OR of one or more of
+ <a href="../../../org/libjpegturbo/turbojpeg/TJ.html#FLAG_BOTTOMUP"><code>TJ.FLAG_*</code></a></dd>
+<dt><span class="strong">Returns:</span></dt><dd>a YUV planar image.</dd>
+<dt><span class="strong">Throws:</span></dt>
+<dd><code><a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></code></dd></dl>
+</li>
+</ul>
+<a name="encodeYUV(int[], int)">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>encodeYUV</h4>
+<pre>public&nbsp;<a href="../../../org/libjpegturbo/turbojpeg/YUVImage.html" title="class in org.libjpegturbo.turbojpeg">YUVImage</a>&nbsp;encodeYUV(int[]&nbsp;strides,
+                 int&nbsp;flags)
+                   throws <a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></pre>
+<div class="block">Encode the uncompressed source image associated with this compressor
+ instance into separate Y, U (Cb), and V (Cr) image planes and return a
+ <code>YUVImage</code> instance containing the encoded image planes.  This
+ method uses the accelerated color conversion routines in TurboJPEG's
+ underlying codec but does not execute any of the other steps in the JPEG
+ compression process.  Encoding CMYK source images to YUV is not supported.</div>
+<dl><dt><span class="strong">Parameters:</span></dt><dd><code>strides</code> - an array of integers, each specifying the number of bytes
+ per line in the corresponding plane of the output image.  Setting the
+ stride for any plane to 0 is the same as setting it to the component width
+ of the plane.  If <code>strides</code> is null, then the strides for all
+ planes will be set to their respective component widths.  You can adjust
+ the strides in order to add an arbitrary amount of line padding to each
+ plane.</dd><dd><code>flags</code> - the bitwise OR of one or more of
+ <a href="../../../org/libjpegturbo/turbojpeg/TJ.html#FLAG_BOTTOMUP"><code>TJ.FLAG_*</code></a></dd>
+<dt><span class="strong">Returns:</span></dt><dd>a YUV planar image.</dd>
+<dt><span class="strong">Throws:</span></dt>
+<dd><code><a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></code></dd></dl>
+</li>
+</ul>
+<a name="encodeYUV(int)">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>encodeYUV</h4>
+<pre>@Deprecated
+public&nbsp;byte[]&nbsp;encodeYUV(int&nbsp;flags)
+                 throws <a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></pre>
+<div class="block"><span class="strong">Deprecated.</span>&nbsp;<i>Use <a href="../../../org/libjpegturbo/turbojpeg/TJCompressor.html#encodeYUV(int,%20int)"><code>encodeYUV(int, int)</code></a> instead.</i></div>
+<dl><dt><span class="strong">Throws:</span></dt>
+<dd><code><a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></code></dd></dl>
+</li>
+</ul>
+<a name="encodeYUV(java.awt.image.BufferedImage, byte[], int)">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>encodeYUV</h4>
+<pre>@Deprecated
+public&nbsp;void&nbsp;encodeYUV(java.awt.image.BufferedImage&nbsp;srcImage,
+                        byte[]&nbsp;dstBuf,
+                        int&nbsp;flags)
+               throws <a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></pre>
+<div class="block"><span class="strong">Deprecated.</span>&nbsp;<i>Use
+ <a href="../../../org/libjpegturbo/turbojpeg/TJCompressor.html#setSourceImage(java.awt.image.BufferedImage,%20int,%20int,%20int,%20int)"><code>setSourceImage(BufferedImage, int, int, int, int)</code></a> and
+ <a href="../../../org/libjpegturbo/turbojpeg/TJCompressor.html#encodeYUV(byte[],%20int)"><code>encodeYUV(byte[], int)</code></a> instead.</i></div>
+<dl><dt><span class="strong">Throws:</span></dt>
+<dd><code><a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></code></dd></dl>
+</li>
+</ul>
+<a name="encodeYUV(java.awt.image.BufferedImage, int)">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>encodeYUV</h4>
+<pre>@Deprecated
+public&nbsp;byte[]&nbsp;encodeYUV(java.awt.image.BufferedImage&nbsp;srcImage,
+                          int&nbsp;flags)
+                 throws <a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></pre>
+<div class="block"><span class="strong">Deprecated.</span>&nbsp;<i>Use
+ <a href="../../../org/libjpegturbo/turbojpeg/TJCompressor.html#setSourceImage(java.awt.image.BufferedImage,%20int,%20int,%20int,%20int)"><code>setSourceImage(BufferedImage, int, int, int, int)</code></a> and
+ <a href="../../../org/libjpegturbo/turbojpeg/TJCompressor.html#encodeYUV(int,%20int)"><code>encodeYUV(int, int)</code></a> instead.</i></div>
+<dl><dt><span class="strong">Throws:</span></dt>
+<dd><code><a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></code></dd></dl>
+</li>
+</ul>
+<a name="getCompressedSize()">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>getCompressedSize</h4>
+<pre>public&nbsp;int&nbsp;getCompressedSize()</pre>
+<div class="block">Returns the size of the image (in bytes) generated by the most recent
+ compress operation.</div>
+<dl><dt><span class="strong">Returns:</span></dt><dd>the size of the image (in bytes) generated by the most recent
+ compress operation.</dd></dl>
+</li>
+</ul>
+<a name="close()">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>close</h4>
+<pre>public&nbsp;void&nbsp;close()
+           throws <a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></pre>
+<div class="block">Free the native structures associated with this compressor instance.</div>
+<dl>
+<dt><strong>Specified by:</strong></dt>
+<dd><code>close</code>&nbsp;in interface&nbsp;<code>java.io.Closeable</code></dd>
+<dt><strong>Specified by:</strong></dt>
+<dd><code>close</code>&nbsp;in interface&nbsp;<code>java.lang.AutoCloseable</code></dd>
+<dt><span class="strong">Throws:</span></dt>
+<dd><code><a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></code></dd></dl>
+</li>
+</ul>
+<a name="finalize()">
+<!--   -->
+</a>
+<ul class="blockListLast">
+<li class="blockList">
+<h4>finalize</h4>
+<pre>protected&nbsp;void&nbsp;finalize()
+                 throws java.lang.Throwable</pre>
+<dl>
+<dt><strong>Overrides:</strong></dt>
+<dd><code>finalize</code>&nbsp;in class&nbsp;<code>java.lang.Object</code></dd>
+<dt><span class="strong">Throws:</span></dt>
+<dd><code>java.lang.Throwable</code></dd></dl>
+</li>
+</ul>
+</li>
+</ul>
+</li>
+</ul>
+</div>
+</div>
+<!-- ========= END OF CLASS DATA ========= -->
+<!-- ======= START OF BOTTOM NAVBAR ====== -->
+<div class="bottomNav"><a name="navbar_bottom">
+<!--   -->
+</a><a href="#skip-navbar_bottom" title="Skip navigation links"></a><a name="navbar_bottom_firstrow">
+<!--   -->
+</a>
+<ul class="navList" title="Navigation">
+<li><a href="../../../org/libjpegturbo/turbojpeg/package-summary.html">Package</a></li>
+<li class="navBarCell1Rev">Class</li>
+<li><a href="package-tree.html">Tree</a></li>
+<li><a href="../../../deprecated-list.html">Deprecated</a></li>
+<li><a href="../../../index-all.html">Index</a></li>
+<li><a href="../../../help-doc.html">Help</a></li>
+</ul>
+</div>
+<div class="subNav">
+<ul class="navList">
+<li><a href="../../../org/libjpegturbo/turbojpeg/TJ.html" title="class in org.libjpegturbo.turbojpeg"><span class="strong">Prev Class</span></a></li>
+<li><a href="../../../org/libjpegturbo/turbojpeg/TJCustomFilter.html" title="interface in org.libjpegturbo.turbojpeg"><span class="strong">Next Class</span></a></li>
+</ul>
+<ul class="navList">
+<li><a href="../../../index.html?org/libjpegturbo/turbojpeg/TJCompressor.html" target="_top">Frames</a></li>
+<li><a href="TJCompressor.html" target="_top">No Frames</a></li>
+</ul>
+<ul class="navList" id="allclasses_navbar_bottom">
+<li><a href="../../../allclasses-noframe.html">All Classes</a></li>
+</ul>
+<div>
+<script type="text/javascript"><!--
+  allClassesLink = document.getElementById("allclasses_navbar_bottom");
+  if(window==top) {
+    allClassesLink.style.display = "block";
+  }
+  else {
+    allClassesLink.style.display = "none";
+  }
+  //-->
+</script>
+</div>
+<div>
+<ul class="subNavList">
+<li>Summary:&nbsp;</li>
+<li>Nested&nbsp;|&nbsp;</li>
+<li>Field&nbsp;|&nbsp;</li>
+<li><a href="#constructor_summary">Constr</a>&nbsp;|&nbsp;</li>
+<li><a href="#method_summary">Method</a></li>
+</ul>
+<ul class="subNavList">
+<li>Detail:&nbsp;</li>
+<li>Field&nbsp;|&nbsp;</li>
+<li><a href="#constructor_detail">Constr</a>&nbsp;|&nbsp;</li>
+<li><a href="#method_detail">Method</a></li>
+</ul>
+</div>
+<a name="skip-navbar_bottom">
+<!--   -->
+</a></div>
+<!-- ======== END OF BOTTOM NAVBAR ======= -->
+</body>
+</html>
diff --git a/3rdparty/libjpeg/src/java/doc/org/libjpegturbo/turbojpeg/TJCustomFilter.html b/3rdparty/libjpeg/src/java/doc/org/libjpegturbo/turbojpeg/TJCustomFilter.html
new file mode 100644
index 00000000..412dcd46
--- /dev/null
+++ b/3rdparty/libjpeg/src/java/doc/org/libjpegturbo/turbojpeg/TJCustomFilter.html
@@ -0,0 +1,241 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!-- NewPage -->
+<html lang="en">
+<head>
+<title>TJCustomFilter</title>
+<link rel="stylesheet" type="text/css" href="../../../stylesheet.css" title="Style">
+</head>
+<body>
+<script type="text/javascript"><!--
+    try {
+        if (location.href.indexOf('is-external=true') == -1) {
+            parent.document.title="TJCustomFilter";
+        }
+    }
+    catch(err) {
+    }
+//-->
+</script>
+<noscript>
+<div>JavaScript is disabled on your browser.</div>
+</noscript>
+<!-- ========= START OF TOP NAVBAR ======= -->
+<div class="topNav"><a name="navbar_top">
+<!--   -->
+</a><a href="#skip-navbar_top" title="Skip navigation links"></a><a name="navbar_top_firstrow">
+<!--   -->
+</a>
+<ul class="navList" title="Navigation">
+<li><a href="../../../org/libjpegturbo/turbojpeg/package-summary.html">Package</a></li>
+<li class="navBarCell1Rev">Class</li>
+<li><a href="package-tree.html">Tree</a></li>
+<li><a href="../../../deprecated-list.html">Deprecated</a></li>
+<li><a href="../../../index-all.html">Index</a></li>
+<li><a href="../../../help-doc.html">Help</a></li>
+</ul>
+</div>
+<div class="subNav">
+<ul class="navList">
+<li><a href="../../../org/libjpegturbo/turbojpeg/TJCompressor.html" title="class in org.libjpegturbo.turbojpeg"><span class="strong">Prev Class</span></a></li>
+<li><a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html" title="class in org.libjpegturbo.turbojpeg"><span class="strong">Next Class</span></a></li>
+</ul>
+<ul class="navList">
+<li><a href="../../../index.html?org/libjpegturbo/turbojpeg/TJCustomFilter.html" target="_top">Frames</a></li>
+<li><a href="TJCustomFilter.html" target="_top">No Frames</a></li>
+</ul>
+<ul class="navList" id="allclasses_navbar_top">
+<li><a href="../../../allclasses-noframe.html">All Classes</a></li>
+</ul>
+<div>
+<script type="text/javascript"><!--
+  allClassesLink = document.getElementById("allclasses_navbar_top");
+  if(window==top) {
+    allClassesLink.style.display = "block";
+  }
+  else {
+    allClassesLink.style.display = "none";
+  }
+  //-->
+</script>
+</div>
+<div>
+<ul class="subNavList">
+<li>Summary:&nbsp;</li>
+<li>Nested&nbsp;|&nbsp;</li>
+<li>Field&nbsp;|&nbsp;</li>
+<li>Constr&nbsp;|&nbsp;</li>
+<li><a href="#method_summary">Method</a></li>
+</ul>
+<ul class="subNavList">
+<li>Detail:&nbsp;</li>
+<li>Field&nbsp;|&nbsp;</li>
+<li>Constr&nbsp;|&nbsp;</li>
+<li><a href="#method_detail">Method</a></li>
+</ul>
+</div>
+<a name="skip-navbar_top">
+<!--   -->
+</a></div>
+<!-- ========= END OF TOP NAVBAR ========= -->
+<!-- ======== START OF CLASS DATA ======== -->
+<div class="header">
+<div class="subTitle">org.libjpegturbo.turbojpeg</div>
+<h2 title="Interface TJCustomFilter" class="title">Interface TJCustomFilter</h2>
+</div>
+<div class="contentContainer">
+<div class="description">
+<ul class="blockList">
+<li class="blockList">
+<hr>
+<br>
+<pre>public interface <span class="strong">TJCustomFilter</span></pre>
+<div class="block">Custom filter callback interface</div>
+</li>
+</ul>
+</div>
+<div class="summary">
+<ul class="blockList">
+<li class="blockList">
+<!-- ========== METHOD SUMMARY =========== -->
+<ul class="blockList">
+<li class="blockList"><a name="method_summary">
+<!--   -->
+</a>
+<h3>Method Summary</h3>
+<table class="overviewSummary" border="0" cellpadding="3" cellspacing="0" summary="Method Summary table, listing methods, and an explanation">
+<caption><span>Methods</span><span class="tabEnd">&nbsp;</span></caption>
+<tr>
+<th class="colFirst" scope="col">Modifier and Type</th>
+<th class="colLast" scope="col">Method and Description</th>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>void</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJCustomFilter.html#customFilter(java.nio.ShortBuffer,%20java.awt.Rectangle,%20java.awt.Rectangle,%20int,%20int,%20org.libjpegturbo.turbojpeg.TJTransform)">customFilter</a></strong>(java.nio.ShortBuffer&nbsp;coeffBuffer,
+            java.awt.Rectangle&nbsp;bufferRegion,
+            java.awt.Rectangle&nbsp;planeRegion,
+            int&nbsp;componentID,
+            int&nbsp;transformID,
+            <a href="../../../org/libjpegturbo/turbojpeg/TJTransform.html" title="class in org.libjpegturbo.turbojpeg">TJTransform</a>&nbsp;transform)</code>
+<div class="block">A callback function that can be used to modify the DCT coefficients after
+ they are losslessly transformed but before they are transcoded to a new
+ JPEG image.</div>
+</td>
+</tr>
+</table>
+</li>
+</ul>
+</li>
+</ul>
+</div>
+<div class="details">
+<ul class="blockList">
+<li class="blockList">
+<!-- ============ METHOD DETAIL ========== -->
+<ul class="blockList">
+<li class="blockList"><a name="method_detail">
+<!--   -->
+</a>
+<h3>Method Detail</h3>
+<a name="customFilter(java.nio.ShortBuffer, java.awt.Rectangle, java.awt.Rectangle, int, int, org.libjpegturbo.turbojpeg.TJTransform)">
+<!--   -->
+</a>
+<ul class="blockListLast">
+<li class="blockList">
+<h4>customFilter</h4>
+<pre>void&nbsp;customFilter(java.nio.ShortBuffer&nbsp;coeffBuffer,
+                java.awt.Rectangle&nbsp;bufferRegion,
+                java.awt.Rectangle&nbsp;planeRegion,
+                int&nbsp;componentID,
+                int&nbsp;transformID,
+                <a href="../../../org/libjpegturbo/turbojpeg/TJTransform.html" title="class in org.libjpegturbo.turbojpeg">TJTransform</a>&nbsp;transform)
+                  throws <a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></pre>
+<div class="block">A callback function that can be used to modify the DCT coefficients after
+ they are losslessly transformed but before they are transcoded to a new
+ JPEG image.  This allows for custom filters or other transformations to be
+ applied in the frequency domain.</div>
+<dl><dt><span class="strong">Parameters:</span></dt><dd><code>coeffBuffer</code> - a buffer containing transformed DCT coefficients.
+ (NOTE: this buffer is not guaranteed to be valid once the callback
+ returns, so applications wishing to hand off the DCT coefficients to
+ another function or library should make a copy of them within the body of
+ the callback.)</dd><dd><code>bufferRegion</code> - rectangle containing the width and height of
+ <code>coeffBuffer</code> as well as its offset relative to the component
+ plane.  TurboJPEG implementations may choose to split each component plane
+ into multiple DCT coefficient buffers and call the callback function once
+ for each buffer.</dd><dd><code>planeRegion</code> - rectangle containing the width and height of the
+ component plane to which <code>coeffBuffer</code> belongs</dd><dd><code>componentID</code> - ID number of the component plane to which
+ <code>coeffBuffer</code> belongs (Y, Cb, and Cr have, respectively, ID's
+ of 0, 1, and 2 in typical JPEG images.)</dd><dd><code>transformID</code> - ID number of the transformed image to which
+ <code>coeffBuffer</code> belongs.  This is the same as the index of the
+ transform in the <code>transforms</code> array that was passed to <a href="../../../org/libjpegturbo/turbojpeg/TJTransformer.html#transform(byte[][],%20org.libjpegturbo.turbojpeg.TJTransform[],%20int)"><code>TJTransformer.transform()</code></a>.</dd><dd><code>transform</code> - a <a href="../../../org/libjpegturbo/turbojpeg/TJTransform.html" title="class in org.libjpegturbo.turbojpeg"><code>TJTransform</code></a> instance that specifies the
+ parameters and/or cropping region for this transform</dd>
+<dt><span class="strong">Throws:</span></dt>
+<dd><code><a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></code></dd></dl>
+</li>
+</ul>
+</li>
+</ul>
+</li>
+</ul>
+</div>
+</div>
+<!-- ========= END OF CLASS DATA ========= -->
+<!-- ======= START OF BOTTOM NAVBAR ====== -->
+<div class="bottomNav"><a name="navbar_bottom">
+<!--   -->
+</a><a href="#skip-navbar_bottom" title="Skip navigation links"></a><a name="navbar_bottom_firstrow">
+<!--   -->
+</a>
+<ul class="navList" title="Navigation">
+<li><a href="../../../org/libjpegturbo/turbojpeg/package-summary.html">Package</a></li>
+<li class="navBarCell1Rev">Class</li>
+<li><a href="package-tree.html">Tree</a></li>
+<li><a href="../../../deprecated-list.html">Deprecated</a></li>
+<li><a href="../../../index-all.html">Index</a></li>
+<li><a href="../../../help-doc.html">Help</a></li>
+</ul>
+</div>
+<div class="subNav">
+<ul class="navList">
+<li><a href="../../../org/libjpegturbo/turbojpeg/TJCompressor.html" title="class in org.libjpegturbo.turbojpeg"><span class="strong">Prev Class</span></a></li>
+<li><a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html" title="class in org.libjpegturbo.turbojpeg"><span class="strong">Next Class</span></a></li>
+</ul>
+<ul class="navList">
+<li><a href="../../../index.html?org/libjpegturbo/turbojpeg/TJCustomFilter.html" target="_top">Frames</a></li>
+<li><a href="TJCustomFilter.html" target="_top">No Frames</a></li>
+</ul>
+<ul class="navList" id="allclasses_navbar_bottom">
+<li><a href="../../../allclasses-noframe.html">All Classes</a></li>
+</ul>
+<div>
+<script type="text/javascript"><!--
+  allClassesLink = document.getElementById("allclasses_navbar_bottom");
+  if(window==top) {
+    allClassesLink.style.display = "block";
+  }
+  else {
+    allClassesLink.style.display = "none";
+  }
+  //-->
+</script>
+</div>
+<div>
+<ul class="subNavList">
+<li>Summary:&nbsp;</li>
+<li>Nested&nbsp;|&nbsp;</li>
+<li>Field&nbsp;|&nbsp;</li>
+<li>Constr&nbsp;|&nbsp;</li>
+<li><a href="#method_summary">Method</a></li>
+</ul>
+<ul class="subNavList">
+<li>Detail:&nbsp;</li>
+<li>Field&nbsp;|&nbsp;</li>
+<li>Constr&nbsp;|&nbsp;</li>
+<li><a href="#method_detail">Method</a></li>
+</ul>
+</div>
+<a name="skip-navbar_bottom">
+<!--   -->
+</a></div>
+<!-- ======== END OF BOTTOM NAVBAR ======= -->
+</body>
+</html>
diff --git a/3rdparty/libjpeg/src/java/doc/org/libjpegturbo/turbojpeg/TJDecompressor.html b/3rdparty/libjpeg/src/java/doc/org/libjpegturbo/turbojpeg/TJDecompressor.html
new file mode 100644
index 00000000..b281e327
--- /dev/null
+++ b/3rdparty/libjpeg/src/java/doc/org/libjpegturbo/turbojpeg/TJDecompressor.html
@@ -0,0 +1,1255 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!-- NewPage -->
+<html lang="en">
+<head>
+<title>TJDecompressor</title>
+<link rel="stylesheet" type="text/css" href="../../../stylesheet.css" title="Style">
+</head>
+<body>
+<script type="text/javascript"><!--
+    try {
+        if (location.href.indexOf('is-external=true') == -1) {
+            parent.document.title="TJDecompressor";
+        }
+    }
+    catch(err) {
+    }
+//-->
+</script>
+<noscript>
+<div>JavaScript is disabled on your browser.</div>
+</noscript>
+<!-- ========= START OF TOP NAVBAR ======= -->
+<div class="topNav"><a name="navbar_top">
+<!--   -->
+</a><a href="#skip-navbar_top" title="Skip navigation links"></a><a name="navbar_top_firstrow">
+<!--   -->
+</a>
+<ul class="navList" title="Navigation">
+<li><a href="../../../org/libjpegturbo/turbojpeg/package-summary.html">Package</a></li>
+<li class="navBarCell1Rev">Class</li>
+<li><a href="package-tree.html">Tree</a></li>
+<li><a href="../../../deprecated-list.html">Deprecated</a></li>
+<li><a href="../../../index-all.html">Index</a></li>
+<li><a href="../../../help-doc.html">Help</a></li>
+</ul>
+</div>
+<div class="subNav">
+<ul class="navList">
+<li><a href="../../../org/libjpegturbo/turbojpeg/TJCustomFilter.html" title="interface in org.libjpegturbo.turbojpeg"><span class="strong">Prev Class</span></a></li>
+<li><a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg"><span class="strong">Next Class</span></a></li>
+</ul>
+<ul class="navList">
+<li><a href="../../../index.html?org/libjpegturbo/turbojpeg/TJDecompressor.html" target="_top">Frames</a></li>
+<li><a href="TJDecompressor.html" target="_top">No Frames</a></li>
+</ul>
+<ul class="navList" id="allclasses_navbar_top">
+<li><a href="../../../allclasses-noframe.html">All Classes</a></li>
+</ul>
+<div>
+<script type="text/javascript"><!--
+  allClassesLink = document.getElementById("allclasses_navbar_top");
+  if(window==top) {
+    allClassesLink.style.display = "block";
+  }
+  else {
+    allClassesLink.style.display = "none";
+  }
+  //-->
+</script>
+</div>
+<div>
+<ul class="subNavList">
+<li>Summary:&nbsp;</li>
+<li>Nested&nbsp;|&nbsp;</li>
+<li><a href="#field_summary">Field</a>&nbsp;|&nbsp;</li>
+<li><a href="#constructor_summary">Constr</a>&nbsp;|&nbsp;</li>
+<li><a href="#method_summary">Method</a></li>
+</ul>
+<ul class="subNavList">
+<li>Detail:&nbsp;</li>
+<li><a href="#field_detail">Field</a>&nbsp;|&nbsp;</li>
+<li><a href="#constructor_detail">Constr</a>&nbsp;|&nbsp;</li>
+<li><a href="#method_detail">Method</a></li>
+</ul>
+</div>
+<a name="skip-navbar_top">
+<!--   -->
+</a></div>
+<!-- ========= END OF TOP NAVBAR ========= -->
+<!-- ======== START OF CLASS DATA ======== -->
+<div class="header">
+<div class="subTitle">org.libjpegturbo.turbojpeg</div>
+<h2 title="Class TJDecompressor" class="title">Class TJDecompressor</h2>
+</div>
+<div class="contentContainer">
+<ul class="inheritance">
+<li>java.lang.Object</li>
+<li>
+<ul class="inheritance">
+<li>org.libjpegturbo.turbojpeg.TJDecompressor</li>
+</ul>
+</li>
+</ul>
+<div class="description">
+<ul class="blockList">
+<li class="blockList">
+<dl>
+<dt>All Implemented Interfaces:</dt>
+<dd>java.io.Closeable, java.lang.AutoCloseable</dd>
+</dl>
+<dl>
+<dt>Direct Known Subclasses:</dt>
+<dd><a href="../../../org/libjpegturbo/turbojpeg/TJTransformer.html" title="class in org.libjpegturbo.turbojpeg">TJTransformer</a></dd>
+</dl>
+<hr>
+<br>
+<pre>public class <span class="strong">TJDecompressor</span>
+extends java.lang.Object
+implements java.io.Closeable</pre>
+<div class="block">TurboJPEG decompressor</div>
+</li>
+</ul>
+</div>
+<div class="summary">
+<ul class="blockList">
+<li class="blockList">
+<!-- =========== FIELD SUMMARY =========== -->
+<ul class="blockList">
+<li class="blockList"><a name="field_summary">
+<!--   -->
+</a>
+<h3>Field Summary</h3>
+<table class="overviewSummary" border="0" cellpadding="3" cellspacing="0" summary="Field Summary table, listing fields, and an explanation">
+<caption><span>Fields</span><span class="tabEnd">&nbsp;</span></caption>
+<tr>
+<th class="colFirst" scope="col">Modifier and Type</th>
+<th class="colLast" scope="col">Field and Description</th>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>protected long</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html#handle">handle</a></strong></code>&nbsp;</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>protected byte[]</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html#jpegBuf">jpegBuf</a></strong></code>&nbsp;</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>protected int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html#jpegBufSize">jpegBufSize</a></strong></code>&nbsp;</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>protected int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html#jpegColorspace">jpegColorspace</a></strong></code>&nbsp;</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>protected int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html#jpegHeight">jpegHeight</a></strong></code>&nbsp;</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>protected int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html#jpegSubsamp">jpegSubsamp</a></strong></code>&nbsp;</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>protected int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html#jpegWidth">jpegWidth</a></strong></code>&nbsp;</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>protected <a href="../../../org/libjpegturbo/turbojpeg/YUVImage.html" title="class in org.libjpegturbo.turbojpeg">YUVImage</a></code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html#yuvImage">yuvImage</a></strong></code>&nbsp;</td>
+</tr>
+</table>
+</li>
+</ul>
+<!-- ======== CONSTRUCTOR SUMMARY ======== -->
+<ul class="blockList">
+<li class="blockList"><a name="constructor_summary">
+<!--   -->
+</a>
+<h3>Constructor Summary</h3>
+<table class="overviewSummary" border="0" cellpadding="3" cellspacing="0" summary="Constructor Summary table, listing constructors, and an explanation">
+<caption><span>Constructors</span><span class="tabEnd">&nbsp;</span></caption>
+<tr>
+<th class="colOne" scope="col">Constructor and Description</th>
+</tr>
+<tr class="altColor">
+<td class="colOne"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html#TJDecompressor()">TJDecompressor</a></strong>()</code>
+<div class="block">Create a TurboJPEG decompresssor instance.</div>
+</td>
+</tr>
+<tr class="rowColor">
+<td class="colOne"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html#TJDecompressor(byte[])">TJDecompressor</a></strong>(byte[]&nbsp;jpegImage)</code>
+<div class="block">Create a TurboJPEG decompressor instance and associate the JPEG source
+ image stored in <code>jpegImage</code> with the newly created instance.</div>
+</td>
+</tr>
+<tr class="altColor">
+<td class="colOne"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html#TJDecompressor(byte[],%20int)">TJDecompressor</a></strong>(byte[]&nbsp;jpegImage,
+              int&nbsp;imageSize)</code>
+<div class="block">Create a TurboJPEG decompressor instance and associate the JPEG source
+ image of length <code>imageSize</code> bytes stored in
+ <code>jpegImage</code> with the newly created instance.</div>
+</td>
+</tr>
+<tr class="rowColor">
+<td class="colOne"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html#TJDecompressor(org.libjpegturbo.turbojpeg.YUVImage)">TJDecompressor</a></strong>(<a href="../../../org/libjpegturbo/turbojpeg/YUVImage.html" title="class in org.libjpegturbo.turbojpeg">YUVImage</a>&nbsp;yuvImage)</code>
+<div class="block">Create a TurboJPEG decompressor instance and associate the YUV planar
+ source image stored in <code>yuvImage</code> with the newly created
+ instance.</div>
+</td>
+</tr>
+</table>
+</li>
+</ul>
+<!-- ========== METHOD SUMMARY =========== -->
+<ul class="blockList">
+<li class="blockList"><a name="method_summary">
+<!--   -->
+</a>
+<h3>Method Summary</h3>
+<table class="overviewSummary" border="0" cellpadding="3" cellspacing="0" summary="Method Summary table, listing methods, and an explanation">
+<caption><span>Methods</span><span class="tabEnd">&nbsp;</span></caption>
+<tr>
+<th class="colFirst" scope="col">Modifier and Type</th>
+<th class="colLast" scope="col">Method and Description</th>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>void</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html#close()">close</a></strong>()</code>
+<div class="block">Free the native structures associated with this decompressor instance.</div>
+</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>void</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html#decompress(java.awt.image.BufferedImage,%20int)">decompress</a></strong>(java.awt.image.BufferedImage&nbsp;dstImage,
+          int&nbsp;flags)</code>
+<div class="block">Decompress the JPEG source image or decode the YUV source image associated
+ with this decompressor instance and output a decompressed/decoded image to
+ the given <code>BufferedImage</code> instance.</div>
+</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>void</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html#decompress(byte[],%20int,%20int,%20int,%20int,%20int)">decompress</a></strong>(byte[]&nbsp;dstBuf,
+          int&nbsp;desiredWidth,
+          int&nbsp;pitch,
+          int&nbsp;desiredHeight,
+          int&nbsp;pixelFormat,
+          int&nbsp;flags)</code>
+<div class="block"><strong>Deprecated.</strong>&nbsp;
+<div class="block"><i>Use
+ <a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html#decompress(byte[],%20int,%20int,%20int,%20int,%20int,%20int,%20int)"><code>decompress(byte[], int, int, int, int, int, int, int)</code></a> instead.</i></div>
+</div>
+</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>void</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html#decompress(byte[],%20int,%20int,%20int,%20int,%20int,%20int,%20int)">decompress</a></strong>(byte[]&nbsp;dstBuf,
+          int&nbsp;x,
+          int&nbsp;y,
+          int&nbsp;desiredWidth,
+          int&nbsp;pitch,
+          int&nbsp;desiredHeight,
+          int&nbsp;pixelFormat,
+          int&nbsp;flags)</code>
+<div class="block">Decompress the JPEG source image or decode the YUV source image associated
+ with this decompressor instance and output a grayscale, RGB, or CMYK image
+ to the given destination buffer.</div>
+</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>void</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html#decompress(int[],%20int,%20int,%20int,%20int,%20int,%20int,%20int)">decompress</a></strong>(int[]&nbsp;dstBuf,
+          int&nbsp;x,
+          int&nbsp;y,
+          int&nbsp;desiredWidth,
+          int&nbsp;stride,
+          int&nbsp;desiredHeight,
+          int&nbsp;pixelFormat,
+          int&nbsp;flags)</code>
+<div class="block">Decompress the JPEG source image or decode the YUV source image associated
+ with this decompressor instance and output a grayscale, RGB, or CMYK image
+ to the given destination buffer.</div>
+</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>java.awt.image.BufferedImage</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html#decompress(int,%20int,%20int,%20int)">decompress</a></strong>(int&nbsp;desiredWidth,
+          int&nbsp;desiredHeight,
+          int&nbsp;bufferedImageType,
+          int&nbsp;flags)</code>
+<div class="block">Decompress the JPEG source image or decode the YUV source image associated
+ with this decompressor instance and return a <code>BufferedImage</code>
+ instance containing the decompressed/decoded image.</div>
+</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>byte[]</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html#decompress(int,%20int,%20int,%20int,%20int)">decompress</a></strong>(int&nbsp;desiredWidth,
+          int&nbsp;pitch,
+          int&nbsp;desiredHeight,
+          int&nbsp;pixelFormat,
+          int&nbsp;flags)</code>
+<div class="block">Decompress the JPEG source image associated with this decompressor
+ instance and return a buffer containing the decompressed image.</div>
+</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>void</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html#decompressToYUV(byte[],%20int)">decompressToYUV</a></strong>(byte[]&nbsp;dstBuf,
+               int&nbsp;flags)</code>
+<div class="block"><strong>Deprecated.</strong>&nbsp;
+<div class="block"><i>Use <a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html#decompressToYUV(org.libjpegturbo.turbojpeg.YUVImage,%20int)"><code>decompressToYUV(YUVImage, int)</code></a> instead.</i></div>
+</div>
+</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>byte[]</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html#decompressToYUV(int)">decompressToYUV</a></strong>(int&nbsp;flags)</code>
+<div class="block"><strong>Deprecated.</strong>&nbsp;
+<div class="block"><i>Use <a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html#decompressToYUV(int,%20int,%20int,%20int)"><code>decompressToYUV(int, int, int, int)</code></a> instead.</i></div>
+</div>
+</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code><a href="../../../org/libjpegturbo/turbojpeg/YUVImage.html" title="class in org.libjpegturbo.turbojpeg">YUVImage</a></code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html#decompressToYUV(int,%20int[],%20int,%20int)">decompressToYUV</a></strong>(int&nbsp;desiredWidth,
+               int[]&nbsp;strides,
+               int&nbsp;desiredHeight,
+               int&nbsp;flags)</code>
+<div class="block">Decompress the JPEG source image associated with this decompressor
+ instance into a set of Y, U (Cb), and V (Cr) image planes and return a
+ <code>YUVImage</code> instance containing the decompressed image planes.</div>
+</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code><a href="../../../org/libjpegturbo/turbojpeg/YUVImage.html" title="class in org.libjpegturbo.turbojpeg">YUVImage</a></code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html#decompressToYUV(int,%20int,%20int,%20int)">decompressToYUV</a></strong>(int&nbsp;desiredWidth,
+               int&nbsp;pad,
+               int&nbsp;desiredHeight,
+               int&nbsp;flags)</code>
+<div class="block">Decompress the JPEG source image associated with this decompressor
+ instance into a unified YUV planar image buffer and return a
+ <code>YUVImage</code> instance containing the decompressed image.</div>
+</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>void</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html#decompressToYUV(org.libjpegturbo.turbojpeg.YUVImage,%20int)">decompressToYUV</a></strong>(<a href="../../../org/libjpegturbo/turbojpeg/YUVImage.html" title="class in org.libjpegturbo.turbojpeg">YUVImage</a>&nbsp;dstImage,
+               int&nbsp;flags)</code>
+<div class="block">Decompress the JPEG source image associated with this decompressor
+ instance into a YUV planar image and store it in the given
+ <code>YUVImage</code> instance.</div>
+</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>protected void</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html#finalize()">finalize</a></strong>()</code>&nbsp;</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html#getColorspace()">getColorspace</a></strong>()</code>
+<div class="block">Returns the colorspace used in the source image (JPEG or YUV) associated
+ with this decompressor instance.</div>
+</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html#getHeight()">getHeight</a></strong>()</code>
+<div class="block">Returns the height of the source image (JPEG or YUV) associated with this
+ decompressor instance.</div>
+</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>byte[]</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html#getJPEGBuf()">getJPEGBuf</a></strong>()</code>
+<div class="block">Returns the JPEG image buffer associated with this decompressor instance.</div>
+</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html#getJPEGSize()">getJPEGSize</a></strong>()</code>
+<div class="block">Returns the size of the JPEG image (in bytes) associated with this
+ decompressor instance.</div>
+</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html#getScaledHeight(int,%20int)">getScaledHeight</a></strong>(int&nbsp;desiredWidth,
+               int&nbsp;desiredHeight)</code>
+<div class="block">Returns the height of the largest scaled-down image that the TurboJPEG
+ decompressor can generate without exceeding the desired image width and
+ height.</div>
+</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html#getScaledWidth(int,%20int)">getScaledWidth</a></strong>(int&nbsp;desiredWidth,
+              int&nbsp;desiredHeight)</code>
+<div class="block">Returns the width of the largest scaled-down image that the TurboJPEG
+ decompressor can generate without exceeding the desired image width and
+ height.</div>
+</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html#getSubsamp()">getSubsamp</a></strong>()</code>
+<div class="block">Returns the level of chrominance subsampling used in the source image
+ (JPEG or YUV) associated with this decompressor instance.</div>
+</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html#getWidth()">getWidth</a></strong>()</code>
+<div class="block">Returns the width of the source image (JPEG or YUV) associated with this
+ decompressor instance.</div>
+</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>void</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html#setJPEGImage(byte[],%20int)">setJPEGImage</a></strong>(byte[]&nbsp;jpegImage,
+            int&nbsp;imageSize)</code>
+<div class="block"><strong>Deprecated.</strong>&nbsp;
+<div class="block"><i>Use <a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html#setSourceImage(byte[],%20int)"><code>setSourceImage(byte[], int)</code></a> instead.</i></div>
+</div>
+</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>void</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html#setSourceImage(byte[],%20int)">setSourceImage</a></strong>(byte[]&nbsp;jpegImage,
+              int&nbsp;imageSize)</code>
+<div class="block">Associate the JPEG image of length <code>imageSize</code> bytes stored in
+ <code>jpegImage</code> with this decompressor instance.</div>
+</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>void</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html#setSourceImage(org.libjpegturbo.turbojpeg.YUVImage)">setSourceImage</a></strong>(<a href="../../../org/libjpegturbo/turbojpeg/YUVImage.html" title="class in org.libjpegturbo.turbojpeg">YUVImage</a>&nbsp;srcImage)</code>
+<div class="block">Associate the specified YUV planar source image with this decompressor
+ instance.</div>
+</td>
+</tr>
+</table>
+<ul class="blockList">
+<li class="blockList"><a name="methods_inherited_from_class_java.lang.Object">
+<!--   -->
+</a>
+<h3>Methods inherited from class&nbsp;java.lang.Object</h3>
+<code>clone, equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait</code></li>
+</ul>
+</li>
+</ul>
+</li>
+</ul>
+</div>
+<div class="details">
+<ul class="blockList">
+<li class="blockList">
+<!-- ============ FIELD DETAIL =========== -->
+<ul class="blockList">
+<li class="blockList"><a name="field_detail">
+<!--   -->
+</a>
+<h3>Field Detail</h3>
+<a name="handle">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>handle</h4>
+<pre>protected&nbsp;long handle</pre>
+</li>
+</ul>
+<a name="jpegBuf">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>jpegBuf</h4>
+<pre>protected&nbsp;byte[] jpegBuf</pre>
+</li>
+</ul>
+<a name="jpegBufSize">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>jpegBufSize</h4>
+<pre>protected&nbsp;int jpegBufSize</pre>
+</li>
+</ul>
+<a name="yuvImage">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>yuvImage</h4>
+<pre>protected&nbsp;<a href="../../../org/libjpegturbo/turbojpeg/YUVImage.html" title="class in org.libjpegturbo.turbojpeg">YUVImage</a> yuvImage</pre>
+</li>
+</ul>
+<a name="jpegWidth">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>jpegWidth</h4>
+<pre>protected&nbsp;int jpegWidth</pre>
+</li>
+</ul>
+<a name="jpegHeight">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>jpegHeight</h4>
+<pre>protected&nbsp;int jpegHeight</pre>
+</li>
+</ul>
+<a name="jpegSubsamp">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>jpegSubsamp</h4>
+<pre>protected&nbsp;int jpegSubsamp</pre>
+</li>
+</ul>
+<a name="jpegColorspace">
+<!--   -->
+</a>
+<ul class="blockListLast">
+<li class="blockList">
+<h4>jpegColorspace</h4>
+<pre>protected&nbsp;int jpegColorspace</pre>
+</li>
+</ul>
+</li>
+</ul>
+<!-- ========= CONSTRUCTOR DETAIL ======== -->
+<ul class="blockList">
+<li class="blockList"><a name="constructor_detail">
+<!--   -->
+</a>
+<h3>Constructor Detail</h3>
+<a name="TJDecompressor()">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>TJDecompressor</h4>
+<pre>public&nbsp;TJDecompressor()
+               throws <a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></pre>
+<div class="block">Create a TurboJPEG decompresssor instance.</div>
+<dl><dt><span class="strong">Throws:</span></dt>
+<dd><code><a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></code></dd></dl>
+</li>
+</ul>
+<a name="TJDecompressor(byte[])">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>TJDecompressor</h4>
+<pre>public&nbsp;TJDecompressor(byte[]&nbsp;jpegImage)
+               throws <a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></pre>
+<div class="block">Create a TurboJPEG decompressor instance and associate the JPEG source
+ image stored in <code>jpegImage</code> with the newly created instance.</div>
+<dl><dt><span class="strong">Parameters:</span></dt><dd><code>jpegImage</code> - JPEG image buffer (size of the JPEG image is assumed to
+ be the length of the array.)  This buffer is not modified.</dd>
+<dt><span class="strong">Throws:</span></dt>
+<dd><code><a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></code></dd></dl>
+</li>
+</ul>
+<a name="TJDecompressor(byte[], int)">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>TJDecompressor</h4>
+<pre>public&nbsp;TJDecompressor(byte[]&nbsp;jpegImage,
+              int&nbsp;imageSize)
+               throws <a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></pre>
+<div class="block">Create a TurboJPEG decompressor instance and associate the JPEG source
+ image of length <code>imageSize</code> bytes stored in
+ <code>jpegImage</code> with the newly created instance.</div>
+<dl><dt><span class="strong">Parameters:</span></dt><dd><code>jpegImage</code> - JPEG image buffer.  This buffer is not modified.</dd><dd><code>imageSize</code> - size of the JPEG image (in bytes)</dd>
+<dt><span class="strong">Throws:</span></dt>
+<dd><code><a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></code></dd></dl>
+</li>
+</ul>
+<a name="TJDecompressor(org.libjpegturbo.turbojpeg.YUVImage)">
+<!--   -->
+</a>
+<ul class="blockListLast">
+<li class="blockList">
+<h4>TJDecompressor</h4>
+<pre>public&nbsp;TJDecompressor(<a href="../../../org/libjpegturbo/turbojpeg/YUVImage.html" title="class in org.libjpegturbo.turbojpeg">YUVImage</a>&nbsp;yuvImage)
+               throws <a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></pre>
+<div class="block">Create a TurboJPEG decompressor instance and associate the YUV planar
+ source image stored in <code>yuvImage</code> with the newly created
+ instance.</div>
+<dl><dt><span class="strong">Parameters:</span></dt><dd><code>yuvImage</code> - <a href="../../../org/libjpegturbo/turbojpeg/YUVImage.html" title="class in org.libjpegturbo.turbojpeg"><code>YUVImage</code></a> instance containing a YUV planar
+ image to be decoded.  This image is not modified.</dd>
+<dt><span class="strong">Throws:</span></dt>
+<dd><code><a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></code></dd></dl>
+</li>
+</ul>
+</li>
+</ul>
+<!-- ============ METHOD DETAIL ========== -->
+<ul class="blockList">
+<li class="blockList"><a name="method_detail">
+<!--   -->
+</a>
+<h3>Method Detail</h3>
+<a name="setSourceImage(byte[], int)">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>setSourceImage</h4>
+<pre>public&nbsp;void&nbsp;setSourceImage(byte[]&nbsp;jpegImage,
+                  int&nbsp;imageSize)
+                    throws <a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></pre>
+<div class="block">Associate the JPEG image of length <code>imageSize</code> bytes stored in
+ <code>jpegImage</code> with this decompressor instance.  This image will
+ be used as the source image for subsequent decompress operations.</div>
+<dl><dt><span class="strong">Parameters:</span></dt><dd><code>jpegImage</code> - JPEG image buffer.  This buffer is not modified.</dd><dd><code>imageSize</code> - size of the JPEG image (in bytes)</dd>
+<dt><span class="strong">Throws:</span></dt>
+<dd><code><a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></code></dd></dl>
+</li>
+</ul>
+<a name="setJPEGImage(byte[], int)">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>setJPEGImage</h4>
+<pre>@Deprecated
+public&nbsp;void&nbsp;setJPEGImage(byte[]&nbsp;jpegImage,
+                           int&nbsp;imageSize)
+                  throws <a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></pre>
+<div class="block"><span class="strong">Deprecated.</span>&nbsp;<i>Use <a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html#setSourceImage(byte[],%20int)"><code>setSourceImage(byte[], int)</code></a> instead.</i></div>
+<dl><dt><span class="strong">Throws:</span></dt>
+<dd><code><a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></code></dd></dl>
+</li>
+</ul>
+<a name="setSourceImage(org.libjpegturbo.turbojpeg.YUVImage)">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>setSourceImage</h4>
+<pre>public&nbsp;void&nbsp;setSourceImage(<a href="../../../org/libjpegturbo/turbojpeg/YUVImage.html" title="class in org.libjpegturbo.turbojpeg">YUVImage</a>&nbsp;srcImage)</pre>
+<div class="block">Associate the specified YUV planar source image with this decompressor
+ instance.  Subsequent decompress operations will decode this image into an
+ RGB or grayscale destination image.</div>
+<dl><dt><span class="strong">Parameters:</span></dt><dd><code>srcImage</code> - <a href="../../../org/libjpegturbo/turbojpeg/YUVImage.html" title="class in org.libjpegturbo.turbojpeg"><code>YUVImage</code></a> instance containing a YUV planar image to
+ be decoded.  This image is not modified.</dd></dl>
+</li>
+</ul>
+<a name="getWidth()">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>getWidth</h4>
+<pre>public&nbsp;int&nbsp;getWidth()</pre>
+<div class="block">Returns the width of the source image (JPEG or YUV) associated with this
+ decompressor instance.</div>
+<dl><dt><span class="strong">Returns:</span></dt><dd>the width of the source image (JPEG or YUV) associated with this
+ decompressor instance.</dd></dl>
+</li>
+</ul>
+<a name="getHeight()">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>getHeight</h4>
+<pre>public&nbsp;int&nbsp;getHeight()</pre>
+<div class="block">Returns the height of the source image (JPEG or YUV) associated with this
+ decompressor instance.</div>
+<dl><dt><span class="strong">Returns:</span></dt><dd>the height of the source image (JPEG or YUV) associated with this
+ decompressor instance.</dd></dl>
+</li>
+</ul>
+<a name="getSubsamp()">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>getSubsamp</h4>
+<pre>public&nbsp;int&nbsp;getSubsamp()</pre>
+<div class="block">Returns the level of chrominance subsampling used in the source image
+ (JPEG or YUV) associated with this decompressor instance.  See
+ <a href="../../../org/libjpegturbo/turbojpeg/TJ.html#SAMP_444"><code>TJ.SAMP_*</code></a>.</div>
+<dl><dt><span class="strong">Returns:</span></dt><dd>the level of chrominance subsampling used in the source image
+ (JPEG or YUV) associated with this decompressor instance.</dd></dl>
+</li>
+</ul>
+<a name="getColorspace()">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>getColorspace</h4>
+<pre>public&nbsp;int&nbsp;getColorspace()</pre>
+<div class="block">Returns the colorspace used in the source image (JPEG or YUV) associated
+ with this decompressor instance.  See <a href="../../../org/libjpegturbo/turbojpeg/TJ.html#CS_RGB"><code>TJ.CS_*</code></a>.  If the
+ source image is YUV, then this always returns <a href="../../../org/libjpegturbo/turbojpeg/TJ.html#CS_YCbCr"><code>TJ.CS_YCbCr</code></a>.</div>
+<dl><dt><span class="strong">Returns:</span></dt><dd>the colorspace used in the source image (JPEG or YUV) associated
+ with this decompressor instance.</dd></dl>
+</li>
+</ul>
+<a name="getJPEGBuf()">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>getJPEGBuf</h4>
+<pre>public&nbsp;byte[]&nbsp;getJPEGBuf()</pre>
+<div class="block">Returns the JPEG image buffer associated with this decompressor instance.</div>
+<dl><dt><span class="strong">Returns:</span></dt><dd>the JPEG image buffer associated with this decompressor instance.</dd></dl>
+</li>
+</ul>
+<a name="getJPEGSize()">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>getJPEGSize</h4>
+<pre>public&nbsp;int&nbsp;getJPEGSize()</pre>
+<div class="block">Returns the size of the JPEG image (in bytes) associated with this
+ decompressor instance.</div>
+<dl><dt><span class="strong">Returns:</span></dt><dd>the size of the JPEG image (in bytes) associated with this
+ decompressor instance.</dd></dl>
+</li>
+</ul>
+<a name="getScaledWidth(int, int)">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>getScaledWidth</h4>
+<pre>public&nbsp;int&nbsp;getScaledWidth(int&nbsp;desiredWidth,
+                 int&nbsp;desiredHeight)</pre>
+<div class="block">Returns the width of the largest scaled-down image that the TurboJPEG
+ decompressor can generate without exceeding the desired image width and
+ height.</div>
+<dl><dt><span class="strong">Parameters:</span></dt><dd><code>desiredWidth</code> - desired width (in pixels) of the decompressed image.
+ Setting this to 0 is the same as setting it to the width of the JPEG image
+ (in other words, the width will not be considered when determining the
+ scaled image size.)</dd><dd><code>desiredHeight</code> - desired height (in pixels) of the decompressed image.
+ Setting this to 0 is the same as setting it to the height of the JPEG
+ image (in other words, the height will not be considered when determining
+ the scaled image size.)</dd>
+<dt><span class="strong">Returns:</span></dt><dd>the width of the largest scaled-down image that the TurboJPEG
+ decompressor can generate without exceeding the desired image width and
+ height.</dd></dl>
+</li>
+</ul>
+<a name="getScaledHeight(int, int)">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>getScaledHeight</h4>
+<pre>public&nbsp;int&nbsp;getScaledHeight(int&nbsp;desiredWidth,
+                  int&nbsp;desiredHeight)</pre>
+<div class="block">Returns the height of the largest scaled-down image that the TurboJPEG
+ decompressor can generate without exceeding the desired image width and
+ height.</div>
+<dl><dt><span class="strong">Parameters:</span></dt><dd><code>desiredWidth</code> - desired width (in pixels) of the decompressed image.
+ Setting this to 0 is the same as setting it to the width of the JPEG image
+ (in other words, the width will not be considered when determining the
+ scaled image size.)</dd><dd><code>desiredHeight</code> - desired height (in pixels) of the decompressed image.
+ Setting this to 0 is the same as setting it to the height of the JPEG
+ image (in other words, the height will not be considered when determining
+ the scaled image size.)</dd>
+<dt><span class="strong">Returns:</span></dt><dd>the height of the largest scaled-down image that the TurboJPEG
+ decompressor can generate without exceeding the desired image width and
+ height.</dd></dl>
+</li>
+</ul>
+<a name="decompress(byte[], int, int, int, int, int, int, int)">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>decompress</h4>
+<pre>public&nbsp;void&nbsp;decompress(byte[]&nbsp;dstBuf,
+              int&nbsp;x,
+              int&nbsp;y,
+              int&nbsp;desiredWidth,
+              int&nbsp;pitch,
+              int&nbsp;desiredHeight,
+              int&nbsp;pixelFormat,
+              int&nbsp;flags)
+                throws <a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></pre>
+<div class="block">Decompress the JPEG source image or decode the YUV source image associated
+ with this decompressor instance and output a grayscale, RGB, or CMYK image
+ to the given destination buffer.
+ <p>
+ NOTE: The output image is fully recoverable if this method throws a
+ non-fatal <a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg"><code>TJException</code></a> (unless
+ <a href="../../../org/libjpegturbo/turbojpeg/TJ.html#FLAG_STOPONWARNING"><code>TJ.FLAG_STOPONWARNING</code></a> is specified.)</div>
+<dl><dt><span class="strong">Parameters:</span></dt><dd><code>dstBuf</code> - buffer that will receive the decompressed/decoded image.
+ If the source image is a JPEG image, then this buffer should normally be
+ <code>pitch * scaledHeight</code> bytes in size, where
+ <code>scaledHeight</code> can be determined by calling <code>
+ scalingFactor.<a href="../../../org/libjpegturbo/turbojpeg/TJScalingFactor.html#getScaled(int)"><code>getScaled</code></a>(jpegHeight)
+ </code> with one of the scaling factors returned from <a href="../../../org/libjpegturbo/turbojpeg/TJ.html#getScalingFactors()"><code>TJ.getScalingFactors()</code></a> or by calling <a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html#getScaledHeight(int,%20int)"><code>getScaledHeight(int, int)</code></a>.  If the
+ source image is a YUV image, then this buffer should normally be
+ <code>pitch * height</code> bytes in size, where <code>height</code> is
+ the height of the YUV image.  However, the buffer may also be larger than
+ the dimensions of the source image, in which case the <code>x</code>,
+ <code>y</code>, and <code>pitch</code> parameters can be used to specify
+ the region into which the source image should be decompressed/decoded.</dd><dd><code>x</code> - x offset (in pixels) of the region in the destination image into
+ which the source image should be decompressed/decoded</dd><dd><code>y</code> - y offset (in pixels) of the region in the destination image into
+ which the source image should be decompressed/decoded</dd><dd><code>desiredWidth</code> - If the source image is a JPEG image, then this
+ specifies the desired width (in pixels) of the decompressed image (or
+ image region.)  If the desired destination image dimensions are different
+ than the source image dimensions, then TurboJPEG will use scaling in the
+ JPEG decompressor to generate the largest possible image that will fit
+ within the desired dimensions.  Setting this to 0 is the same as setting
+ it to the width of the JPEG image (in other words, the width will not be
+ considered when determining the scaled image size.)  This parameter is
+ ignored if the source image is a YUV image.</dd><dd><code>pitch</code> - bytes per line of the destination image.  Normally, this
+ should be set to <code>scaledWidth * TJ.pixelSize(pixelFormat)</code> if
+ the destination image is unpadded, but you can use this to, for instance,
+ pad each line of the destination image to a 4-byte boundary or to
+ decompress/decode the source image into a region of a larger image.  NOTE:
+ if the source image is a JPEG image, then <code>scaledWidth</code> can be
+ determined by calling <code>
+ scalingFactor.<a href="../../../org/libjpegturbo/turbojpeg/TJScalingFactor.html#getScaled(int)"><code>getScaled</code></a>(jpegWidth)
+ </code> or by calling <a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html#getScaledWidth(int,%20int)"><code>getScaledWidth(int, int)</code></a>.  If the source image is a
+ YUV image, then <code>scaledWidth</code> is the width of the YUV image.
+ Setting this parameter to 0 is the equivalent of setting it to
+ <code>scaledWidth * TJ.pixelSize(pixelFormat)</code>.</dd><dd><code>desiredHeight</code> - If the source image is a JPEG image, then this
+ specifies the desired height (in pixels) of the decompressed image (or
+ image region.)  If the desired destination image dimensions are different
+ than the source image dimensions, then TurboJPEG will use scaling in the
+ JPEG decompressor to generate the largest possible image that will fit
+ within the desired dimensions.  Setting this to 0 is the same as setting
+ it to the height of the JPEG image (in other words, the height will not be
+ considered when determining the scaled image size.)  This parameter is
+ ignored if the source image is a YUV image.</dd><dd><code>pixelFormat</code> - pixel format of the decompressed/decoded image (one of
+ <a href="../../../org/libjpegturbo/turbojpeg/TJ.html#PF_RGB"><code>TJ.PF_*</code></a>)</dd><dd><code>flags</code> - the bitwise OR of one or more of
+ <a href="../../../org/libjpegturbo/turbojpeg/TJ.html#FLAG_BOTTOMUP"><code>TJ.FLAG_*</code></a></dd>
+<dt><span class="strong">Throws:</span></dt>
+<dd><code><a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></code></dd></dl>
+</li>
+</ul>
+<a name="decompress(byte[], int, int, int, int, int)">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>decompress</h4>
+<pre>@Deprecated
+public&nbsp;void&nbsp;decompress(byte[]&nbsp;dstBuf,
+                         int&nbsp;desiredWidth,
+                         int&nbsp;pitch,
+                         int&nbsp;desiredHeight,
+                         int&nbsp;pixelFormat,
+                         int&nbsp;flags)
+                throws <a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></pre>
+<div class="block"><span class="strong">Deprecated.</span>&nbsp;<i>Use
+ <a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html#decompress(byte[],%20int,%20int,%20int,%20int,%20int,%20int,%20int)"><code>decompress(byte[], int, int, int, int, int, int, int)</code></a> instead.</i></div>
+<dl><dt><span class="strong">Throws:</span></dt>
+<dd><code><a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></code></dd></dl>
+</li>
+</ul>
+<a name="decompress(int, int, int, int, int)">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>decompress</h4>
+<pre>public&nbsp;byte[]&nbsp;decompress(int&nbsp;desiredWidth,
+                int&nbsp;pitch,
+                int&nbsp;desiredHeight,
+                int&nbsp;pixelFormat,
+                int&nbsp;flags)
+                  throws <a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></pre>
+<div class="block">Decompress the JPEG source image associated with this decompressor
+ instance and return a buffer containing the decompressed image.</div>
+<dl><dt><span class="strong">Parameters:</span></dt><dd><code>desiredWidth</code> - see
+ <a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html#decompress(byte[],%20int,%20int,%20int,%20int,%20int,%20int,%20int)"><code>decompress(byte[], int, int, int, int, int, int, int)</code></a>
+ for description</dd><dd><code>pitch</code> - see
+ <a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html#decompress(byte[],%20int,%20int,%20int,%20int,%20int,%20int,%20int)"><code>decompress(byte[], int, int, int, int, int, int, int)</code></a>
+ for description</dd><dd><code>desiredHeight</code> - see
+ <a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html#decompress(byte[],%20int,%20int,%20int,%20int,%20int,%20int,%20int)"><code>decompress(byte[], int, int, int, int, int, int, int)</code></a>
+ for description</dd><dd><code>pixelFormat</code> - pixel format of the decompressed image (one of
+ <a href="../../../org/libjpegturbo/turbojpeg/TJ.html#PF_RGB"><code>TJ.PF_*</code></a>)</dd><dd><code>flags</code> - the bitwise OR of one or more of
+ <a href="../../../org/libjpegturbo/turbojpeg/TJ.html#FLAG_BOTTOMUP"><code>TJ.FLAG_*</code></a></dd>
+<dt><span class="strong">Returns:</span></dt><dd>a buffer containing the decompressed image.</dd>
+<dt><span class="strong">Throws:</span></dt>
+<dd><code><a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></code></dd></dl>
+</li>
+</ul>
+<a name="decompressToYUV(org.libjpegturbo.turbojpeg.YUVImage, int)">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>decompressToYUV</h4>
+<pre>public&nbsp;void&nbsp;decompressToYUV(<a href="../../../org/libjpegturbo/turbojpeg/YUVImage.html" title="class in org.libjpegturbo.turbojpeg">YUVImage</a>&nbsp;dstImage,
+                   int&nbsp;flags)
+                     throws <a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></pre>
+<div class="block">Decompress the JPEG source image associated with this decompressor
+ instance into a YUV planar image and store it in the given
+ <code>YUVImage</code> instance.  This method performs JPEG decompression
+ but leaves out the color conversion step, so a planar YUV image is
+ generated instead of an RGB or grayscale image.  This method cannot be
+ used to decompress JPEG source images with the CMYK or YCCK colorspace.
+ <p>
+ NOTE: The YUV planar output image is fully recoverable if this method
+ throws a non-fatal <a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg"><code>TJException</code></a> (unless
+ <a href="../../../org/libjpegturbo/turbojpeg/TJ.html#FLAG_STOPONWARNING"><code>TJ.FLAG_STOPONWARNING</code></a> is specified.)</div>
+<dl><dt><span class="strong">Parameters:</span></dt><dd><code>dstImage</code> - <a href="../../../org/libjpegturbo/turbojpeg/YUVImage.html" title="class in org.libjpegturbo.turbojpeg"><code>YUVImage</code></a> instance that will receive the YUV planar
+ image.  The level of subsampling specified in this <code>YUVImage</code>
+ instance must match that of the JPEG image, and the width and height
+ specified in the <code>YUVImage</code> instance must match one of the
+ scaled image sizes that TurboJPEG is capable of generating from the JPEG
+ source image.</dd><dd><code>flags</code> - the bitwise OR of one or more of
+ <a href="../../../org/libjpegturbo/turbojpeg/TJ.html#FLAG_BOTTOMUP"><code>TJ.FLAG_*</code></a></dd>
+<dt><span class="strong">Throws:</span></dt>
+<dd><code><a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></code></dd></dl>
+</li>
+</ul>
+<a name="decompressToYUV(byte[], int)">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>decompressToYUV</h4>
+<pre>@Deprecated
+public&nbsp;void&nbsp;decompressToYUV(byte[]&nbsp;dstBuf,
+                              int&nbsp;flags)
+                     throws <a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></pre>
+<div class="block"><span class="strong">Deprecated.</span>&nbsp;<i>Use <a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html#decompressToYUV(org.libjpegturbo.turbojpeg.YUVImage,%20int)"><code>decompressToYUV(YUVImage, int)</code></a> instead.</i></div>
+<dl><dt><span class="strong">Throws:</span></dt>
+<dd><code><a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></code></dd></dl>
+</li>
+</ul>
+<a name="decompressToYUV(int, int[], int, int)">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>decompressToYUV</h4>
+<pre>public&nbsp;<a href="../../../org/libjpegturbo/turbojpeg/YUVImage.html" title="class in org.libjpegturbo.turbojpeg">YUVImage</a>&nbsp;decompressToYUV(int&nbsp;desiredWidth,
+                       int[]&nbsp;strides,
+                       int&nbsp;desiredHeight,
+                       int&nbsp;flags)
+                         throws <a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></pre>
+<div class="block">Decompress the JPEG source image associated with this decompressor
+ instance into a set of Y, U (Cb), and V (Cr) image planes and return a
+ <code>YUVImage</code> instance containing the decompressed image planes.
+ This method performs JPEG decompression but leaves out the color
+ conversion step, so a planar YUV image is generated instead of an RGB or
+ grayscale image.  This method cannot be used to decompress JPEG source
+ images with the CMYK or YCCK colorspace.</div>
+<dl><dt><span class="strong">Parameters:</span></dt><dd><code>desiredWidth</code> - desired width (in pixels) of the YUV image.  If the
+ desired image dimensions are different than the dimensions of the JPEG
+ image being decompressed, then TurboJPEG will use scaling in the JPEG
+ decompressor to generate the largest possible image that will fit within
+ the desired dimensions.  Setting this to 0 is the same as setting it to
+ the width of the JPEG image (in other words, the width will not be
+ considered when determining the scaled image size.)</dd><dd><code>strides</code> - an array of integers, each specifying the number of bytes
+ per line in the corresponding plane of the output image.  Setting the
+ stride for any plane to 0 is the same as setting it to the scaled
+ component width of the plane.  If <tt>strides</tt> is NULL, then the
+ strides for all planes will be set to their respective scaled component
+ widths.  You can adjust the strides in order to add an arbitrary amount of
+ line padding to each plane.</dd><dd><code>desiredHeight</code> - desired height (in pixels) of the YUV image.  If the
+ desired image dimensions are different than the dimensions of the JPEG
+ image being decompressed, then TurboJPEG will use scaling in the JPEG
+ decompressor to generate the largest possible image that will fit within
+ the desired dimensions.  Setting this to 0 is the same as setting it to
+ the height of the JPEG image (in other words, the height will not be
+ considered when determining the scaled image size.)</dd><dd><code>flags</code> - the bitwise OR of one or more of
+ <a href="../../../org/libjpegturbo/turbojpeg/TJ.html#FLAG_BOTTOMUP"><code>TJ.FLAG_*</code></a></dd>
+<dt><span class="strong">Returns:</span></dt><dd>a YUV planar image.</dd>
+<dt><span class="strong">Throws:</span></dt>
+<dd><code><a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></code></dd></dl>
+</li>
+</ul>
+<a name="decompressToYUV(int, int, int, int)">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>decompressToYUV</h4>
+<pre>public&nbsp;<a href="../../../org/libjpegturbo/turbojpeg/YUVImage.html" title="class in org.libjpegturbo.turbojpeg">YUVImage</a>&nbsp;decompressToYUV(int&nbsp;desiredWidth,
+                       int&nbsp;pad,
+                       int&nbsp;desiredHeight,
+                       int&nbsp;flags)
+                         throws <a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></pre>
+<div class="block">Decompress the JPEG source image associated with this decompressor
+ instance into a unified YUV planar image buffer and return a
+ <code>YUVImage</code> instance containing the decompressed image.  This
+ method performs JPEG decompression but leaves out the color conversion
+ step, so a planar YUV image is generated instead of an RGB or grayscale
+ image.  This method cannot be used to decompress JPEG source images with
+ the CMYK or YCCK colorspace.</div>
+<dl><dt><span class="strong">Parameters:</span></dt><dd><code>desiredWidth</code> - desired width (in pixels) of the YUV image.  If the
+ desired image dimensions are different than the dimensions of the JPEG
+ image being decompressed, then TurboJPEG will use scaling in the JPEG
+ decompressor to generate the largest possible image that will fit within
+ the desired dimensions.  Setting this to 0 is the same as setting it to
+ the width of the JPEG image (in other words, the width will not be
+ considered when determining the scaled image size.)</dd><dd><code>pad</code> - the width of each line in each plane of the YUV image will be
+ padded to the nearest multiple of this number of bytes (must be a power of
+ 2.)</dd><dd><code>desiredHeight</code> - desired height (in pixels) of the YUV image.  If the
+ desired image dimensions are different than the dimensions of the JPEG
+ image being decompressed, then TurboJPEG will use scaling in the JPEG
+ decompressor to generate the largest possible image that will fit within
+ the desired dimensions.  Setting this to 0 is the same as setting it to
+ the height of the JPEG image (in other words, the height will not be
+ considered when determining the scaled image size.)</dd><dd><code>flags</code> - the bitwise OR of one or more of
+ <a href="../../../org/libjpegturbo/turbojpeg/TJ.html#FLAG_BOTTOMUP"><code>TJ.FLAG_*</code></a></dd>
+<dt><span class="strong">Returns:</span></dt><dd>a YUV planar image.</dd>
+<dt><span class="strong">Throws:</span></dt>
+<dd><code><a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></code></dd></dl>
+</li>
+</ul>
+<a name="decompressToYUV(int)">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>decompressToYUV</h4>
+<pre>@Deprecated
+public&nbsp;byte[]&nbsp;decompressToYUV(int&nbsp;flags)
+                       throws <a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></pre>
+<div class="block"><span class="strong">Deprecated.</span>&nbsp;<i>Use <a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html#decompressToYUV(int,%20int,%20int,%20int)"><code>decompressToYUV(int, int, int, int)</code></a> instead.</i></div>
+<dl><dt><span class="strong">Throws:</span></dt>
+<dd><code><a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></code></dd></dl>
+</li>
+</ul>
+<a name="decompress(int[], int, int, int, int, int, int, int)">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>decompress</h4>
+<pre>public&nbsp;void&nbsp;decompress(int[]&nbsp;dstBuf,
+              int&nbsp;x,
+              int&nbsp;y,
+              int&nbsp;desiredWidth,
+              int&nbsp;stride,
+              int&nbsp;desiredHeight,
+              int&nbsp;pixelFormat,
+              int&nbsp;flags)
+                throws <a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></pre>
+<div class="block">Decompress the JPEG source image or decode the YUV source image associated
+ with this decompressor instance and output a grayscale, RGB, or CMYK image
+ to the given destination buffer.
+ <p>
+ NOTE: The output image is fully recoverable if this method throws a
+ non-fatal <a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg"><code>TJException</code></a> (unless
+ <a href="../../../org/libjpegturbo/turbojpeg/TJ.html#FLAG_STOPONWARNING"><code>TJ.FLAG_STOPONWARNING</code></a> is specified.)</div>
+<dl><dt><span class="strong">Parameters:</span></dt><dd><code>dstBuf</code> - buffer that will receive the decompressed/decoded image.
+ If the source image is a JPEG image, then this buffer should normally be
+ <code>stride * scaledHeight</code> pixels in size, where
+ <code>scaledHeight</code> can be determined by calling <code>
+ scalingFactor.<a href="../../../org/libjpegturbo/turbojpeg/TJScalingFactor.html#getScaled(int)"><code>getScaled</code></a>(jpegHeight)
+ </code> with one of the scaling factors returned from <a href="../../../org/libjpegturbo/turbojpeg/TJ.html#getScalingFactors()"><code>TJ.getScalingFactors()</code></a> or by calling <a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html#getScaledHeight(int,%20int)"><code>getScaledHeight(int, int)</code></a>.  If the
+ source image is a YUV image, then this buffer should normally be
+ <code>stride * height</code> pixels in size, where <code>height</code> is
+ the height of the YUV image.  However, the buffer may also be larger than
+ the dimensions of the JPEG image, in which case the <code>x</code>,
+ <code>y</code>, and <code>stride</code> parameters can be used to specify
+ the region into which the source image should be decompressed.</dd><dd><code>x</code> - x offset (in pixels) of the region in the destination image into
+ which the source image should be decompressed/decoded</dd><dd><code>y</code> - y offset (in pixels) of the region in the destination image into
+ which the source image should be decompressed/decoded</dd><dd><code>desiredWidth</code> - If the source image is a JPEG image, then this
+ specifies the desired width (in pixels) of the decompressed image (or
+ image region.)  If the desired destination image dimensions are different
+ than the source image dimensions, then TurboJPEG will use scaling in the
+ JPEG decompressor to generate the largest possible image that will fit
+ within the desired dimensions.  Setting this to 0 is the same as setting
+ it to the width of the JPEG image (in other words, the width will not be
+ considered when determining the scaled image size.)  This parameter is
+ ignored if the source image is a YUV image.</dd><dd><code>stride</code> - pixels per line of the destination image.  Normally, this
+ should be set to <code>scaledWidth</code>, but you can use this to, for
+ instance, decompress the JPEG image into a region of a larger image.
+ NOTE: if the source image is a JPEG image, then <code>scaledWidth</code>
+ can be determined by calling <code>
+ scalingFactor.<a href="../../../org/libjpegturbo/turbojpeg/TJScalingFactor.html#getScaled(int)"><code>getScaled</code></a>(jpegWidth)
+ </code> or by calling <a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html#getScaledWidth(int,%20int)"><code>getScaledWidth(int, int)</code></a>.  If the source image is a
+ YUV image, then <code>scaledWidth</code> is the width of the YUV image.
+ Setting this parameter to 0 is the equivalent of setting it to
+ <code>scaledWidth</code>.</dd><dd><code>desiredHeight</code> - If the source image is a JPEG image, then this
+ specifies the desired height (in pixels) of the decompressed image (or
+ image region.)  If the desired destination image dimensions are different
+ than the source image dimensions, then TurboJPEG will use scaling in the
+ JPEG decompressor to generate the largest possible image that will fit
+ within the desired dimensions.  Setting this to 0 is the same as setting
+ it to the height of the JPEG image (in other words, the height will not be
+ considered when determining the scaled image size.)  This parameter is
+ ignored if the source image is a YUV image.</dd><dd><code>pixelFormat</code> - pixel format of the decompressed image (one of
+ <a href="../../../org/libjpegturbo/turbojpeg/TJ.html#PF_RGB"><code>TJ.PF_*</code></a>)</dd><dd><code>flags</code> - the bitwise OR of one or more of
+ <a href="../../../org/libjpegturbo/turbojpeg/TJ.html#FLAG_BOTTOMUP"><code>TJ.FLAG_*</code></a></dd>
+<dt><span class="strong">Throws:</span></dt>
+<dd><code><a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></code></dd></dl>
+</li>
+</ul>
+<a name="decompress(java.awt.image.BufferedImage, int)">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>decompress</h4>
+<pre>public&nbsp;void&nbsp;decompress(java.awt.image.BufferedImage&nbsp;dstImage,
+              int&nbsp;flags)
+                throws <a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></pre>
+<div class="block">Decompress the JPEG source image or decode the YUV source image associated
+ with this decompressor instance and output a decompressed/decoded image to
+ the given <code>BufferedImage</code> instance.
+ <p>
+ NOTE: The output image is fully recoverable if this method throws a
+ non-fatal <a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg"><code>TJException</code></a> (unless
+ <a href="../../../org/libjpegturbo/turbojpeg/TJ.html#FLAG_STOPONWARNING"><code>TJ.FLAG_STOPONWARNING</code></a> is specified.)</div>
+<dl><dt><span class="strong">Parameters:</span></dt><dd><code>dstImage</code> - a <code>BufferedImage</code> instance that will receive
+ the decompressed/decoded image.  If the source image is a JPEG image, then
+ the width and height of the <code>BufferedImage</code> instance must match
+ one of the scaled image sizes that TurboJPEG is capable of generating from
+ the JPEG image.  If the source image is a YUV image, then the width and
+ height of the <code>BufferedImage</code> instance must match the width and
+ height of the YUV image.</dd><dd><code>flags</code> - the bitwise OR of one or more of
+ <a href="../../../org/libjpegturbo/turbojpeg/TJ.html#FLAG_BOTTOMUP"><code>TJ.FLAG_*</code></a></dd>
+<dt><span class="strong">Throws:</span></dt>
+<dd><code><a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></code></dd></dl>
+</li>
+</ul>
+<a name="decompress(int, int, int, int)">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>decompress</h4>
+<pre>public&nbsp;java.awt.image.BufferedImage&nbsp;decompress(int&nbsp;desiredWidth,
+                                      int&nbsp;desiredHeight,
+                                      int&nbsp;bufferedImageType,
+                                      int&nbsp;flags)
+                                        throws <a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></pre>
+<div class="block">Decompress the JPEG source image or decode the YUV source image associated
+ with this decompressor instance and return a <code>BufferedImage</code>
+ instance containing the decompressed/decoded image.</div>
+<dl><dt><span class="strong">Parameters:</span></dt><dd><code>desiredWidth</code> - see
+ <a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html#decompress(byte[],%20int,%20int,%20int,%20int,%20int,%20int,%20int)"><code>decompress(byte[], int, int, int, int, int, int, int)</code></a> for
+ description</dd><dd><code>desiredHeight</code> - see
+ <a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html#decompress(byte[],%20int,%20int,%20int,%20int,%20int,%20int,%20int)"><code>decompress(byte[], int, int, int, int, int, int, int)</code></a> for
+ description</dd><dd><code>bufferedImageType</code> - the image type of the <code>BufferedImage</code>
+ instance that will be created (for instance,
+ <code>BufferedImage.TYPE_INT_RGB</code>)</dd><dd><code>flags</code> - the bitwise OR of one or more of
+ <a href="../../../org/libjpegturbo/turbojpeg/TJ.html#FLAG_BOTTOMUP"><code>TJ.FLAG_*</code></a></dd>
+<dt><span class="strong">Returns:</span></dt><dd>a <code>BufferedImage</code> instance containing the
+ decompressed/decoded image.</dd>
+<dt><span class="strong">Throws:</span></dt>
+<dd><code><a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></code></dd></dl>
+</li>
+</ul>
+<a name="close()">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>close</h4>
+<pre>public&nbsp;void&nbsp;close()
+           throws <a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></pre>
+<div class="block">Free the native structures associated with this decompressor instance.</div>
+<dl>
+<dt><strong>Specified by:</strong></dt>
+<dd><code>close</code>&nbsp;in interface&nbsp;<code>java.io.Closeable</code></dd>
+<dt><strong>Specified by:</strong></dt>
+<dd><code>close</code>&nbsp;in interface&nbsp;<code>java.lang.AutoCloseable</code></dd>
+<dt><span class="strong">Throws:</span></dt>
+<dd><code><a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></code></dd></dl>
+</li>
+</ul>
+<a name="finalize()">
+<!--   -->
+</a>
+<ul class="blockListLast">
+<li class="blockList">
+<h4>finalize</h4>
+<pre>protected&nbsp;void&nbsp;finalize()
+                 throws java.lang.Throwable</pre>
+<dl>
+<dt><strong>Overrides:</strong></dt>
+<dd><code>finalize</code>&nbsp;in class&nbsp;<code>java.lang.Object</code></dd>
+<dt><span class="strong">Throws:</span></dt>
+<dd><code>java.lang.Throwable</code></dd></dl>
+</li>
+</ul>
+</li>
+</ul>
+</li>
+</ul>
+</div>
+</div>
+<!-- ========= END OF CLASS DATA ========= -->
+<!-- ======= START OF BOTTOM NAVBAR ====== -->
+<div class="bottomNav"><a name="navbar_bottom">
+<!--   -->
+</a><a href="#skip-navbar_bottom" title="Skip navigation links"></a><a name="navbar_bottom_firstrow">
+<!--   -->
+</a>
+<ul class="navList" title="Navigation">
+<li><a href="../../../org/libjpegturbo/turbojpeg/package-summary.html">Package</a></li>
+<li class="navBarCell1Rev">Class</li>
+<li><a href="package-tree.html">Tree</a></li>
+<li><a href="../../../deprecated-list.html">Deprecated</a></li>
+<li><a href="../../../index-all.html">Index</a></li>
+<li><a href="../../../help-doc.html">Help</a></li>
+</ul>
+</div>
+<div class="subNav">
+<ul class="navList">
+<li><a href="../../../org/libjpegturbo/turbojpeg/TJCustomFilter.html" title="interface in org.libjpegturbo.turbojpeg"><span class="strong">Prev Class</span></a></li>
+<li><a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg"><span class="strong">Next Class</span></a></li>
+</ul>
+<ul class="navList">
+<li><a href="../../../index.html?org/libjpegturbo/turbojpeg/TJDecompressor.html" target="_top">Frames</a></li>
+<li><a href="TJDecompressor.html" target="_top">No Frames</a></li>
+</ul>
+<ul class="navList" id="allclasses_navbar_bottom">
+<li><a href="../../../allclasses-noframe.html">All Classes</a></li>
+</ul>
+<div>
+<script type="text/javascript"><!--
+  allClassesLink = document.getElementById("allclasses_navbar_bottom");
+  if(window==top) {
+    allClassesLink.style.display = "block";
+  }
+  else {
+    allClassesLink.style.display = "none";
+  }
+  //-->
+</script>
+</div>
+<div>
+<ul class="subNavList">
+<li>Summary:&nbsp;</li>
+<li>Nested&nbsp;|&nbsp;</li>
+<li><a href="#field_summary">Field</a>&nbsp;|&nbsp;</li>
+<li><a href="#constructor_summary">Constr</a>&nbsp;|&nbsp;</li>
+<li><a href="#method_summary">Method</a></li>
+</ul>
+<ul class="subNavList">
+<li>Detail:&nbsp;</li>
+<li><a href="#field_detail">Field</a>&nbsp;|&nbsp;</li>
+<li><a href="#constructor_detail">Constr</a>&nbsp;|&nbsp;</li>
+<li><a href="#method_detail">Method</a></li>
+</ul>
+</div>
+<a name="skip-navbar_bottom">
+<!--   -->
+</a></div>
+<!-- ======== END OF BOTTOM NAVBAR ======= -->
+</body>
+</html>
diff --git a/3rdparty/libjpeg/src/java/doc/org/libjpegturbo/turbojpeg/TJException.html b/3rdparty/libjpeg/src/java/doc/org/libjpegturbo/turbojpeg/TJException.html
new file mode 100644
index 00000000..66d73e74
--- /dev/null
+++ b/3rdparty/libjpeg/src/java/doc/org/libjpegturbo/turbojpeg/TJException.html
@@ -0,0 +1,340 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!-- NewPage -->
+<html lang="en">
+<head>
+<title>TJException</title>
+<link rel="stylesheet" type="text/css" href="../../../stylesheet.css" title="Style">
+</head>
+<body>
+<script type="text/javascript"><!--
+    try {
+        if (location.href.indexOf('is-external=true') == -1) {
+            parent.document.title="TJException";
+        }
+    }
+    catch(err) {
+    }
+//-->
+</script>
+<noscript>
+<div>JavaScript is disabled on your browser.</div>
+</noscript>
+<!-- ========= START OF TOP NAVBAR ======= -->
+<div class="topNav"><a name="navbar_top">
+<!--   -->
+</a><a href="#skip-navbar_top" title="Skip navigation links"></a><a name="navbar_top_firstrow">
+<!--   -->
+</a>
+<ul class="navList" title="Navigation">
+<li><a href="../../../org/libjpegturbo/turbojpeg/package-summary.html">Package</a></li>
+<li class="navBarCell1Rev">Class</li>
+<li><a href="package-tree.html">Tree</a></li>
+<li><a href="../../../deprecated-list.html">Deprecated</a></li>
+<li><a href="../../../index-all.html">Index</a></li>
+<li><a href="../../../help-doc.html">Help</a></li>
+</ul>
+</div>
+<div class="subNav">
+<ul class="navList">
+<li><a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html" title="class in org.libjpegturbo.turbojpeg"><span class="strong">Prev Class</span></a></li>
+<li><a href="../../../org/libjpegturbo/turbojpeg/TJScalingFactor.html" title="class in org.libjpegturbo.turbojpeg"><span class="strong">Next Class</span></a></li>
+</ul>
+<ul class="navList">
+<li><a href="../../../index.html?org/libjpegturbo/turbojpeg/TJException.html" target="_top">Frames</a></li>
+<li><a href="TJException.html" target="_top">No Frames</a></li>
+</ul>
+<ul class="navList" id="allclasses_navbar_top">
+<li><a href="../../../allclasses-noframe.html">All Classes</a></li>
+</ul>
+<div>
+<script type="text/javascript"><!--
+  allClassesLink = document.getElementById("allclasses_navbar_top");
+  if(window==top) {
+    allClassesLink.style.display = "block";
+  }
+  else {
+    allClassesLink.style.display = "none";
+  }
+  //-->
+</script>
+</div>
+<div>
+<ul class="subNavList">
+<li>Summary:&nbsp;</li>
+<li>Nested&nbsp;|&nbsp;</li>
+<li>Field&nbsp;|&nbsp;</li>
+<li><a href="#constructor_summary">Constr</a>&nbsp;|&nbsp;</li>
+<li><a href="#method_summary">Method</a></li>
+</ul>
+<ul class="subNavList">
+<li>Detail:&nbsp;</li>
+<li>Field&nbsp;|&nbsp;</li>
+<li><a href="#constructor_detail">Constr</a>&nbsp;|&nbsp;</li>
+<li><a href="#method_detail">Method</a></li>
+</ul>
+</div>
+<a name="skip-navbar_top">
+<!--   -->
+</a></div>
+<!-- ========= END OF TOP NAVBAR ========= -->
+<!-- ======== START OF CLASS DATA ======== -->
+<div class="header">
+<div class="subTitle">org.libjpegturbo.turbojpeg</div>
+<h2 title="Class TJException" class="title">Class TJException</h2>
+</div>
+<div class="contentContainer">
+<ul class="inheritance">
+<li>java.lang.Object</li>
+<li>
+<ul class="inheritance">
+<li>java.lang.Throwable</li>
+<li>
+<ul class="inheritance">
+<li>java.lang.Exception</li>
+<li>
+<ul class="inheritance">
+<li>java.io.IOException</li>
+<li>
+<ul class="inheritance">
+<li>org.libjpegturbo.turbojpeg.TJException</li>
+</ul>
+</li>
+</ul>
+</li>
+</ul>
+</li>
+</ul>
+</li>
+</ul>
+<div class="description">
+<ul class="blockList">
+<li class="blockList">
+<dl>
+<dt>All Implemented Interfaces:</dt>
+<dd>java.io.Serializable</dd>
+</dl>
+<hr>
+<br>
+<pre>public class <span class="strong">TJException</span>
+extends java.io.IOException</pre>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../serialized-form.html#org.libjpegturbo.turbojpeg.TJException">Serialized Form</a></dd></dl>
+</li>
+</ul>
+</div>
+<div class="summary">
+<ul class="blockList">
+<li class="blockList">
+<!-- ======== CONSTRUCTOR SUMMARY ======== -->
+<ul class="blockList">
+<li class="blockList"><a name="constructor_summary">
+<!--   -->
+</a>
+<h3>Constructor Summary</h3>
+<table class="overviewSummary" border="0" cellpadding="3" cellspacing="0" summary="Constructor Summary table, listing constructors, and an explanation">
+<caption><span>Constructors</span><span class="tabEnd">&nbsp;</span></caption>
+<tr>
+<th class="colOne" scope="col">Constructor and Description</th>
+</tr>
+<tr class="altColor">
+<td class="colOne"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJException.html#TJException()">TJException</a></strong>()</code>&nbsp;</td>
+</tr>
+<tr class="rowColor">
+<td class="colOne"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJException.html#TJException(java.lang.String)">TJException</a></strong>(java.lang.String&nbsp;message)</code>&nbsp;</td>
+</tr>
+<tr class="altColor">
+<td class="colOne"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJException.html#TJException(java.lang.String,%20int)">TJException</a></strong>(java.lang.String&nbsp;message,
+           int&nbsp;code)</code>&nbsp;</td>
+</tr>
+<tr class="rowColor">
+<td class="colOne"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJException.html#TJException(java.lang.String,%20java.lang.Throwable)">TJException</a></strong>(java.lang.String&nbsp;message,
+           java.lang.Throwable&nbsp;cause)</code>&nbsp;</td>
+</tr>
+<tr class="altColor">
+<td class="colOne"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJException.html#TJException(java.lang.Throwable)">TJException</a></strong>(java.lang.Throwable&nbsp;cause)</code>&nbsp;</td>
+</tr>
+</table>
+</li>
+</ul>
+<!-- ========== METHOD SUMMARY =========== -->
+<ul class="blockList">
+<li class="blockList"><a name="method_summary">
+<!--   -->
+</a>
+<h3>Method Summary</h3>
+<table class="overviewSummary" border="0" cellpadding="3" cellspacing="0" summary="Method Summary table, listing methods, and an explanation">
+<caption><span>Methods</span><span class="tabEnd">&nbsp;</span></caption>
+<tr>
+<th class="colFirst" scope="col">Modifier and Type</th>
+<th class="colLast" scope="col">Method and Description</th>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJException.html#getErrorCode()">getErrorCode</a></strong>()</code>
+<div class="block">Returns a code (one of <a href="../../../org/libjpegturbo/turbojpeg/TJ.html" title="class in org.libjpegturbo.turbojpeg"><code>TJ.ERR_*</code></a>) indicating the severity of the
+ last error.</div>
+</td>
+</tr>
+</table>
+<ul class="blockList">
+<li class="blockList"><a name="methods_inherited_from_class_java.lang.Throwable">
+<!--   -->
+</a>
+<h3>Methods inherited from class&nbsp;java.lang.Throwable</h3>
+<code>addSuppressed, fillInStackTrace, getCause, getLocalizedMessage, getMessage, getStackTrace, getSuppressed, initCause, printStackTrace, printStackTrace, printStackTrace, setStackTrace, toString</code></li>
+</ul>
+<ul class="blockList">
+<li class="blockList"><a name="methods_inherited_from_class_java.lang.Object">
+<!--   -->
+</a>
+<h3>Methods inherited from class&nbsp;java.lang.Object</h3>
+<code>clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait</code></li>
+</ul>
+</li>
+</ul>
+</li>
+</ul>
+</div>
+<div class="details">
+<ul class="blockList">
+<li class="blockList">
+<!-- ========= CONSTRUCTOR DETAIL ======== -->
+<ul class="blockList">
+<li class="blockList"><a name="constructor_detail">
+<!--   -->
+</a>
+<h3>Constructor Detail</h3>
+<a name="TJException()">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>TJException</h4>
+<pre>public&nbsp;TJException()</pre>
+</li>
+</ul>
+<a name="TJException(java.lang.String, java.lang.Throwable)">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>TJException</h4>
+<pre>public&nbsp;TJException(java.lang.String&nbsp;message,
+           java.lang.Throwable&nbsp;cause)</pre>
+</li>
+</ul>
+<a name="TJException(java.lang.String)">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>TJException</h4>
+<pre>public&nbsp;TJException(java.lang.String&nbsp;message)</pre>
+</li>
+</ul>
+<a name="TJException(java.lang.String, int)">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>TJException</h4>
+<pre>public&nbsp;TJException(java.lang.String&nbsp;message,
+           int&nbsp;code)</pre>
+</li>
+</ul>
+<a name="TJException(java.lang.Throwable)">
+<!--   -->
+</a>
+<ul class="blockListLast">
+<li class="blockList">
+<h4>TJException</h4>
+<pre>public&nbsp;TJException(java.lang.Throwable&nbsp;cause)</pre>
+</li>
+</ul>
+</li>
+</ul>
+<!-- ============ METHOD DETAIL ========== -->
+<ul class="blockList">
+<li class="blockList"><a name="method_detail">
+<!--   -->
+</a>
+<h3>Method Detail</h3>
+<a name="getErrorCode()">
+<!--   -->
+</a>
+<ul class="blockListLast">
+<li class="blockList">
+<h4>getErrorCode</h4>
+<pre>public&nbsp;int&nbsp;getErrorCode()</pre>
+<div class="block">Returns a code (one of <a href="../../../org/libjpegturbo/turbojpeg/TJ.html" title="class in org.libjpegturbo.turbojpeg"><code>TJ.ERR_*</code></a>) indicating the severity of the
+ last error.</div>
+<dl><dt><span class="strong">Returns:</span></dt><dd>a code (one of <a href="../../../org/libjpegturbo/turbojpeg/TJ.html" title="class in org.libjpegturbo.turbojpeg"><code>TJ.ERR_*</code></a>) indicating the severity of the
+ last error.</dd></dl>
+</li>
+</ul>
+</li>
+</ul>
+</li>
+</ul>
+</div>
+</div>
+<!-- ========= END OF CLASS DATA ========= -->
+<!-- ======= START OF BOTTOM NAVBAR ====== -->
+<div class="bottomNav"><a name="navbar_bottom">
+<!--   -->
+</a><a href="#skip-navbar_bottom" title="Skip navigation links"></a><a name="navbar_bottom_firstrow">
+<!--   -->
+</a>
+<ul class="navList" title="Navigation">
+<li><a href="../../../org/libjpegturbo/turbojpeg/package-summary.html">Package</a></li>
+<li class="navBarCell1Rev">Class</li>
+<li><a href="package-tree.html">Tree</a></li>
+<li><a href="../../../deprecated-list.html">Deprecated</a></li>
+<li><a href="../../../index-all.html">Index</a></li>
+<li><a href="../../../help-doc.html">Help</a></li>
+</ul>
+</div>
+<div class="subNav">
+<ul class="navList">
+<li><a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html" title="class in org.libjpegturbo.turbojpeg"><span class="strong">Prev Class</span></a></li>
+<li><a href="../../../org/libjpegturbo/turbojpeg/TJScalingFactor.html" title="class in org.libjpegturbo.turbojpeg"><span class="strong">Next Class</span></a></li>
+</ul>
+<ul class="navList">
+<li><a href="../../../index.html?org/libjpegturbo/turbojpeg/TJException.html" target="_top">Frames</a></li>
+<li><a href="TJException.html" target="_top">No Frames</a></li>
+</ul>
+<ul class="navList" id="allclasses_navbar_bottom">
+<li><a href="../../../allclasses-noframe.html">All Classes</a></li>
+</ul>
+<div>
+<script type="text/javascript"><!--
+  allClassesLink = document.getElementById("allclasses_navbar_bottom");
+  if(window==top) {
+    allClassesLink.style.display = "block";
+  }
+  else {
+    allClassesLink.style.display = "none";
+  }
+  //-->
+</script>
+</div>
+<div>
+<ul class="subNavList">
+<li>Summary:&nbsp;</li>
+<li>Nested&nbsp;|&nbsp;</li>
+<li>Field&nbsp;|&nbsp;</li>
+<li><a href="#constructor_summary">Constr</a>&nbsp;|&nbsp;</li>
+<li><a href="#method_summary">Method</a></li>
+</ul>
+<ul class="subNavList">
+<li>Detail:&nbsp;</li>
+<li>Field&nbsp;|&nbsp;</li>
+<li><a href="#constructor_detail">Constr</a>&nbsp;|&nbsp;</li>
+<li><a href="#method_detail">Method</a></li>
+</ul>
+</div>
+<a name="skip-navbar_bottom">
+<!--   -->
+</a></div>
+<!-- ======== END OF BOTTOM NAVBAR ======= -->
+</body>
+</html>
diff --git a/3rdparty/libjpeg/src/java/doc/org/libjpegturbo/turbojpeg/TJScalingFactor.html b/3rdparty/libjpeg/src/java/doc/org/libjpegturbo/turbojpeg/TJScalingFactor.html
new file mode 100644
index 00000000..4006baca
--- /dev/null
+++ b/3rdparty/libjpeg/src/java/doc/org/libjpegturbo/turbojpeg/TJScalingFactor.html
@@ -0,0 +1,343 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!-- NewPage -->
+<html lang="en">
+<head>
+<title>TJScalingFactor</title>
+<link rel="stylesheet" type="text/css" href="../../../stylesheet.css" title="Style">
+</head>
+<body>
+<script type="text/javascript"><!--
+    try {
+        if (location.href.indexOf('is-external=true') == -1) {
+            parent.document.title="TJScalingFactor";
+        }
+    }
+    catch(err) {
+    }
+//-->
+</script>
+<noscript>
+<div>JavaScript is disabled on your browser.</div>
+</noscript>
+<!-- ========= START OF TOP NAVBAR ======= -->
+<div class="topNav"><a name="navbar_top">
+<!--   -->
+</a><a href="#skip-navbar_top" title="Skip navigation links"></a><a name="navbar_top_firstrow">
+<!--   -->
+</a>
+<ul class="navList" title="Navigation">
+<li><a href="../../../org/libjpegturbo/turbojpeg/package-summary.html">Package</a></li>
+<li class="navBarCell1Rev">Class</li>
+<li><a href="package-tree.html">Tree</a></li>
+<li><a href="../../../deprecated-list.html">Deprecated</a></li>
+<li><a href="../../../index-all.html">Index</a></li>
+<li><a href="../../../help-doc.html">Help</a></li>
+</ul>
+</div>
+<div class="subNav">
+<ul class="navList">
+<li><a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg"><span class="strong">Prev Class</span></a></li>
+<li><a href="../../../org/libjpegturbo/turbojpeg/TJTransform.html" title="class in org.libjpegturbo.turbojpeg"><span class="strong">Next Class</span></a></li>
+</ul>
+<ul class="navList">
+<li><a href="../../../index.html?org/libjpegturbo/turbojpeg/TJScalingFactor.html" target="_top">Frames</a></li>
+<li><a href="TJScalingFactor.html" target="_top">No Frames</a></li>
+</ul>
+<ul class="navList" id="allclasses_navbar_top">
+<li><a href="../../../allclasses-noframe.html">All Classes</a></li>
+</ul>
+<div>
+<script type="text/javascript"><!--
+  allClassesLink = document.getElementById("allclasses_navbar_top");
+  if(window==top) {
+    allClassesLink.style.display = "block";
+  }
+  else {
+    allClassesLink.style.display = "none";
+  }
+  //-->
+</script>
+</div>
+<div>
+<ul class="subNavList">
+<li>Summary:&nbsp;</li>
+<li>Nested&nbsp;|&nbsp;</li>
+<li>Field&nbsp;|&nbsp;</li>
+<li><a href="#constructor_summary">Constr</a>&nbsp;|&nbsp;</li>
+<li><a href="#method_summary">Method</a></li>
+</ul>
+<ul class="subNavList">
+<li>Detail:&nbsp;</li>
+<li>Field&nbsp;|&nbsp;</li>
+<li><a href="#constructor_detail">Constr</a>&nbsp;|&nbsp;</li>
+<li><a href="#method_detail">Method</a></li>
+</ul>
+</div>
+<a name="skip-navbar_top">
+<!--   -->
+</a></div>
+<!-- ========= END OF TOP NAVBAR ========= -->
+<!-- ======== START OF CLASS DATA ======== -->
+<div class="header">
+<div class="subTitle">org.libjpegturbo.turbojpeg</div>
+<h2 title="Class TJScalingFactor" class="title">Class TJScalingFactor</h2>
+</div>
+<div class="contentContainer">
+<ul class="inheritance">
+<li>java.lang.Object</li>
+<li>
+<ul class="inheritance">
+<li>org.libjpegturbo.turbojpeg.TJScalingFactor</li>
+</ul>
+</li>
+</ul>
+<div class="description">
+<ul class="blockList">
+<li class="blockList">
+<hr>
+<br>
+<pre>public class <span class="strong">TJScalingFactor</span>
+extends java.lang.Object</pre>
+<div class="block">Fractional scaling factor</div>
+</li>
+</ul>
+</div>
+<div class="summary">
+<ul class="blockList">
+<li class="blockList">
+<!-- ======== CONSTRUCTOR SUMMARY ======== -->
+<ul class="blockList">
+<li class="blockList"><a name="constructor_summary">
+<!--   -->
+</a>
+<h3>Constructor Summary</h3>
+<table class="overviewSummary" border="0" cellpadding="3" cellspacing="0" summary="Constructor Summary table, listing constructors, and an explanation">
+<caption><span>Constructors</span><span class="tabEnd">&nbsp;</span></caption>
+<tr>
+<th class="colOne" scope="col">Constructor and Description</th>
+</tr>
+<tr class="altColor">
+<td class="colOne"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJScalingFactor.html#TJScalingFactor(int,%20int)">TJScalingFactor</a></strong>(int&nbsp;num,
+               int&nbsp;denom)</code>
+<div class="block">Create a TurboJPEG scaling factor instance.</div>
+</td>
+</tr>
+</table>
+</li>
+</ul>
+<!-- ========== METHOD SUMMARY =========== -->
+<ul class="blockList">
+<li class="blockList"><a name="method_summary">
+<!--   -->
+</a>
+<h3>Method Summary</h3>
+<table class="overviewSummary" border="0" cellpadding="3" cellspacing="0" summary="Method Summary table, listing methods, and an explanation">
+<caption><span>Methods</span><span class="tabEnd">&nbsp;</span></caption>
+<tr>
+<th class="colFirst" scope="col">Modifier and Type</th>
+<th class="colLast" scope="col">Method and Description</th>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>boolean</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJScalingFactor.html#equals(org.libjpegturbo.turbojpeg.TJScalingFactor)">equals</a></strong>(<a href="../../../org/libjpegturbo/turbojpeg/TJScalingFactor.html" title="class in org.libjpegturbo.turbojpeg">TJScalingFactor</a>&nbsp;other)</code>
+<div class="block">Returns true or false, depending on whether this instance and
+ <code>other</code> have the same numerator and denominator.</div>
+</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJScalingFactor.html#getDenom()">getDenom</a></strong>()</code>
+<div class="block">Returns denominator</div>
+</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJScalingFactor.html#getNum()">getNum</a></strong>()</code>
+<div class="block">Returns numerator</div>
+</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJScalingFactor.html#getScaled(int)">getScaled</a></strong>(int&nbsp;dimension)</code>
+<div class="block">Returns the scaled value of <code>dimension</code>.</div>
+</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>boolean</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJScalingFactor.html#isOne()">isOne</a></strong>()</code>
+<div class="block">Returns true or false, depending on whether this instance is equal to
+ 1/1.</div>
+</td>
+</tr>
+</table>
+<ul class="blockList">
+<li class="blockList"><a name="methods_inherited_from_class_java.lang.Object">
+<!--   -->
+</a>
+<h3>Methods inherited from class&nbsp;java.lang.Object</h3>
+<code>clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait</code></li>
+</ul>
+</li>
+</ul>
+</li>
+</ul>
+</div>
+<div class="details">
+<ul class="blockList">
+<li class="blockList">
+<!-- ========= CONSTRUCTOR DETAIL ======== -->
+<ul class="blockList">
+<li class="blockList"><a name="constructor_detail">
+<!--   -->
+</a>
+<h3>Constructor Detail</h3>
+<a name="TJScalingFactor(int, int)">
+<!--   -->
+</a>
+<ul class="blockListLast">
+<li class="blockList">
+<h4>TJScalingFactor</h4>
+<pre>public&nbsp;TJScalingFactor(int&nbsp;num,
+               int&nbsp;denom)</pre>
+<div class="block">Create a TurboJPEG scaling factor instance.</div>
+<dl><dt><span class="strong">Parameters:</span></dt><dd><code>num</code> - numerator</dd><dd><code>denom</code> - denominator</dd></dl>
+</li>
+</ul>
+</li>
+</ul>
+<!-- ============ METHOD DETAIL ========== -->
+<ul class="blockList">
+<li class="blockList"><a name="method_detail">
+<!--   -->
+</a>
+<h3>Method Detail</h3>
+<a name="getNum()">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>getNum</h4>
+<pre>public&nbsp;int&nbsp;getNum()</pre>
+<div class="block">Returns numerator</div>
+<dl><dt><span class="strong">Returns:</span></dt><dd>numerator</dd></dl>
+</li>
+</ul>
+<a name="getDenom()">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>getDenom</h4>
+<pre>public&nbsp;int&nbsp;getDenom()</pre>
+<div class="block">Returns denominator</div>
+<dl><dt><span class="strong">Returns:</span></dt><dd>denominator</dd></dl>
+</li>
+</ul>
+<a name="getScaled(int)">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>getScaled</h4>
+<pre>public&nbsp;int&nbsp;getScaled(int&nbsp;dimension)</pre>
+<div class="block">Returns the scaled value of <code>dimension</code>.  This function
+ performs the integer equivalent of
+ <code>ceil(dimension * scalingFactor)</code>.</div>
+<dl><dt><span class="strong">Parameters:</span></dt><dd><code>dimension</code> - width or height to multiply by this scaling factor</dd>
+<dt><span class="strong">Returns:</span></dt><dd>the scaled value of <code>dimension</code>.</dd></dl>
+</li>
+</ul>
+<a name="equals(org.libjpegturbo.turbojpeg.TJScalingFactor)">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>equals</h4>
+<pre>public&nbsp;boolean&nbsp;equals(<a href="../../../org/libjpegturbo/turbojpeg/TJScalingFactor.html" title="class in org.libjpegturbo.turbojpeg">TJScalingFactor</a>&nbsp;other)</pre>
+<div class="block">Returns true or false, depending on whether this instance and
+ <code>other</code> have the same numerator and denominator.</div>
+<dl><dt><span class="strong">Parameters:</span></dt><dd><code>other</code> - the scaling factor against which to compare this one</dd>
+<dt><span class="strong">Returns:</span></dt><dd>true or false, depending on whether this instance and
+ <code>other</code> have the same numerator and denominator.</dd></dl>
+</li>
+</ul>
+<a name="isOne()">
+<!--   -->
+</a>
+<ul class="blockListLast">
+<li class="blockList">
+<h4>isOne</h4>
+<pre>public&nbsp;boolean&nbsp;isOne()</pre>
+<div class="block">Returns true or false, depending on whether this instance is equal to
+ 1/1.</div>
+<dl><dt><span class="strong">Returns:</span></dt><dd>true or false, depending on whether this instance is equal to
+ 1/1.</dd></dl>
+</li>
+</ul>
+</li>
+</ul>
+</li>
+</ul>
+</div>
+</div>
+<!-- ========= END OF CLASS DATA ========= -->
+<!-- ======= START OF BOTTOM NAVBAR ====== -->
+<div class="bottomNav"><a name="navbar_bottom">
+<!--   -->
+</a><a href="#skip-navbar_bottom" title="Skip navigation links"></a><a name="navbar_bottom_firstrow">
+<!--   -->
+</a>
+<ul class="navList" title="Navigation">
+<li><a href="../../../org/libjpegturbo/turbojpeg/package-summary.html">Package</a></li>
+<li class="navBarCell1Rev">Class</li>
+<li><a href="package-tree.html">Tree</a></li>
+<li><a href="../../../deprecated-list.html">Deprecated</a></li>
+<li><a href="../../../index-all.html">Index</a></li>
+<li><a href="../../../help-doc.html">Help</a></li>
+</ul>
+</div>
+<div class="subNav">
+<ul class="navList">
+<li><a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg"><span class="strong">Prev Class</span></a></li>
+<li><a href="../../../org/libjpegturbo/turbojpeg/TJTransform.html" title="class in org.libjpegturbo.turbojpeg"><span class="strong">Next Class</span></a></li>
+</ul>
+<ul class="navList">
+<li><a href="../../../index.html?org/libjpegturbo/turbojpeg/TJScalingFactor.html" target="_top">Frames</a></li>
+<li><a href="TJScalingFactor.html" target="_top">No Frames</a></li>
+</ul>
+<ul class="navList" id="allclasses_navbar_bottom">
+<li><a href="../../../allclasses-noframe.html">All Classes</a></li>
+</ul>
+<div>
+<script type="text/javascript"><!--
+  allClassesLink = document.getElementById("allclasses_navbar_bottom");
+  if(window==top) {
+    allClassesLink.style.display = "block";
+  }
+  else {
+    allClassesLink.style.display = "none";
+  }
+  //-->
+</script>
+</div>
+<div>
+<ul class="subNavList">
+<li>Summary:&nbsp;</li>
+<li>Nested&nbsp;|&nbsp;</li>
+<li>Field&nbsp;|&nbsp;</li>
+<li><a href="#constructor_summary">Constr</a>&nbsp;|&nbsp;</li>
+<li><a href="#method_summary">Method</a></li>
+</ul>
+<ul class="subNavList">
+<li>Detail:&nbsp;</li>
+<li>Field&nbsp;|&nbsp;</li>
+<li><a href="#constructor_detail">Constr</a>&nbsp;|&nbsp;</li>
+<li><a href="#method_detail">Method</a></li>
+</ul>
+</div>
+<a name="skip-navbar_bottom">
+<!--   -->
+</a></div>
+<!-- ======== END OF BOTTOM NAVBAR ======= -->
+</body>
+</html>
diff --git a/3rdparty/libjpeg/src/java/doc/org/libjpegturbo/turbojpeg/TJTransform.html b/3rdparty/libjpeg/src/java/doc/org/libjpegturbo/turbojpeg/TJTransform.html
new file mode 100644
index 00000000..5f22691e
--- /dev/null
+++ b/3rdparty/libjpeg/src/java/doc/org/libjpegturbo/turbojpeg/TJTransform.html
@@ -0,0 +1,751 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!-- NewPage -->
+<html lang="en">
+<head>
+<title>TJTransform</title>
+<link rel="stylesheet" type="text/css" href="../../../stylesheet.css" title="Style">
+</head>
+<body>
+<script type="text/javascript"><!--
+    try {
+        if (location.href.indexOf('is-external=true') == -1) {
+            parent.document.title="TJTransform";
+        }
+    }
+    catch(err) {
+    }
+//-->
+</script>
+<noscript>
+<div>JavaScript is disabled on your browser.</div>
+</noscript>
+<!-- ========= START OF TOP NAVBAR ======= -->
+<div class="topNav"><a name="navbar_top">
+<!--   -->
+</a><a href="#skip-navbar_top" title="Skip navigation links"></a><a name="navbar_top_firstrow">
+<!--   -->
+</a>
+<ul class="navList" title="Navigation">
+<li><a href="../../../org/libjpegturbo/turbojpeg/package-summary.html">Package</a></li>
+<li class="navBarCell1Rev">Class</li>
+<li><a href="package-tree.html">Tree</a></li>
+<li><a href="../../../deprecated-list.html">Deprecated</a></li>
+<li><a href="../../../index-all.html">Index</a></li>
+<li><a href="../../../help-doc.html">Help</a></li>
+</ul>
+</div>
+<div class="subNav">
+<ul class="navList">
+<li><a href="../../../org/libjpegturbo/turbojpeg/TJScalingFactor.html" title="class in org.libjpegturbo.turbojpeg"><span class="strong">Prev Class</span></a></li>
+<li><a href="../../../org/libjpegturbo/turbojpeg/TJTransformer.html" title="class in org.libjpegturbo.turbojpeg"><span class="strong">Next Class</span></a></li>
+</ul>
+<ul class="navList">
+<li><a href="../../../index.html?org/libjpegturbo/turbojpeg/TJTransform.html" target="_top">Frames</a></li>
+<li><a href="TJTransform.html" target="_top">No Frames</a></li>
+</ul>
+<ul class="navList" id="allclasses_navbar_top">
+<li><a href="../../../allclasses-noframe.html">All Classes</a></li>
+</ul>
+<div>
+<script type="text/javascript"><!--
+  allClassesLink = document.getElementById("allclasses_navbar_top");
+  if(window==top) {
+    allClassesLink.style.display = "block";
+  }
+  else {
+    allClassesLink.style.display = "none";
+  }
+  //-->
+</script>
+</div>
+<div>
+<ul class="subNavList">
+<li>Summary:&nbsp;</li>
+<li><a href="#nested_classes_inherited_from_class_java.awt.geom.Rectangle2D">Nested</a>&nbsp;|&nbsp;</li>
+<li><a href="#field_summary">Field</a>&nbsp;|&nbsp;</li>
+<li><a href="#constructor_summary">Constr</a>&nbsp;|&nbsp;</li>
+<li><a href="#methods_inherited_from_class_java.awt.Rectangle">Method</a></li>
+</ul>
+<ul class="subNavList">
+<li>Detail:&nbsp;</li>
+<li><a href="#field_detail">Field</a>&nbsp;|&nbsp;</li>
+<li><a href="#constructor_detail">Constr</a>&nbsp;|&nbsp;</li>
+<li>Method</li>
+</ul>
+</div>
+<a name="skip-navbar_top">
+<!--   -->
+</a></div>
+<!-- ========= END OF TOP NAVBAR ========= -->
+<!-- ======== START OF CLASS DATA ======== -->
+<div class="header">
+<div class="subTitle">org.libjpegturbo.turbojpeg</div>
+<h2 title="Class TJTransform" class="title">Class TJTransform</h2>
+</div>
+<div class="contentContainer">
+<ul class="inheritance">
+<li>java.lang.Object</li>
+<li>
+<ul class="inheritance">
+<li>java.awt.geom.RectangularShape</li>
+<li>
+<ul class="inheritance">
+<li>java.awt.geom.Rectangle2D</li>
+<li>
+<ul class="inheritance">
+<li>java.awt.Rectangle</li>
+<li>
+<ul class="inheritance">
+<li>org.libjpegturbo.turbojpeg.TJTransform</li>
+</ul>
+</li>
+</ul>
+</li>
+</ul>
+</li>
+</ul>
+</li>
+</ul>
+<div class="description">
+<ul class="blockList">
+<li class="blockList">
+<dl>
+<dt>All Implemented Interfaces:</dt>
+<dd>java.awt.Shape, java.io.Serializable, java.lang.Cloneable</dd>
+</dl>
+<hr>
+<br>
+<pre>public class <span class="strong">TJTransform</span>
+extends java.awt.Rectangle</pre>
+<div class="block">Lossless transform parameters</div>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../serialized-form.html#org.libjpegturbo.turbojpeg.TJTransform">Serialized Form</a></dd></dl>
+</li>
+</ul>
+</div>
+<div class="summary">
+<ul class="blockList">
+<li class="blockList">
+<!-- ======== NESTED CLASS SUMMARY ======== -->
+<ul class="blockList">
+<li class="blockList"><a name="nested_class_summary">
+<!--   -->
+</a>
+<h3>Nested Class Summary</h3>
+<ul class="blockList">
+<li class="blockList"><a name="nested_classes_inherited_from_class_java.awt.geom.Rectangle2D">
+<!--   -->
+</a>
+<h3>Nested classes/interfaces inherited from class&nbsp;java.awt.geom.Rectangle2D</h3>
+<code>java.awt.geom.Rectangle2D.Double, java.awt.geom.Rectangle2D.Float</code></li>
+</ul>
+</li>
+</ul>
+<!-- =========== FIELD SUMMARY =========== -->
+<ul class="blockList">
+<li class="blockList"><a name="field_summary">
+<!--   -->
+</a>
+<h3>Field Summary</h3>
+<table class="overviewSummary" border="0" cellpadding="3" cellspacing="0" summary="Field Summary table, listing fields, and an explanation">
+<caption><span>Fields</span><span class="tabEnd">&nbsp;</span></caption>
+<tr>
+<th class="colFirst" scope="col">Modifier and Type</th>
+<th class="colLast" scope="col">Field and Description</th>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code><a href="../../../org/libjpegturbo/turbojpeg/TJCustomFilter.html" title="interface in org.libjpegturbo.turbojpeg">TJCustomFilter</a></code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJTransform.html#cf">cf</a></strong></code>
+<div class="block">Custom filter instance</div>
+</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>static int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJTransform.html#NUMOP">NUMOP</a></strong></code>
+<div class="block">The number of lossless transform operations</div>
+</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJTransform.html#op">op</a></strong></code>
+<div class="block">Transform operation (one of <code>OP_*</code>)</div>
+</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>static int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJTransform.html#OP_HFLIP">OP_HFLIP</a></strong></code>
+<div class="block">Flip (mirror) image horizontally.</div>
+</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>static int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJTransform.html#OP_NONE">OP_NONE</a></strong></code>
+<div class="block">Do not transform the position of the image pixels.</div>
+</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>static int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJTransform.html#OP_ROT180">OP_ROT180</a></strong></code>
+<div class="block">Rotate image 180 degrees.</div>
+</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>static int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJTransform.html#OP_ROT270">OP_ROT270</a></strong></code>
+<div class="block">Rotate image counter-clockwise by 90 degrees.</div>
+</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>static int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJTransform.html#OP_ROT90">OP_ROT90</a></strong></code>
+<div class="block">Rotate image clockwise by 90 degrees.</div>
+</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>static int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJTransform.html#OP_TRANSPOSE">OP_TRANSPOSE</a></strong></code>
+<div class="block">Transpose image (flip/mirror along upper left to lower right axis).</div>
+</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>static int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJTransform.html#OP_TRANSVERSE">OP_TRANSVERSE</a></strong></code>
+<div class="block">Transverse transpose image (flip/mirror along upper right to lower left
+ axis).</div>
+</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>static int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJTransform.html#OP_VFLIP">OP_VFLIP</a></strong></code>
+<div class="block">Flip (mirror) image vertically.</div>
+</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>static int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJTransform.html#OPT_COPYNONE">OPT_COPYNONE</a></strong></code>
+<div class="block">This option will prevent <a href="../../../org/libjpegturbo/turbojpeg/TJTransformer.html#transform(byte[][],%20org.libjpegturbo.turbojpeg.TJTransform[],%20int)"><code>TJTransformer.transform()</code></a> from copying any extra markers (including EXIF
+ and ICC profile data) from the source image to the output image.</div>
+</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>static int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJTransform.html#OPT_CROP">OPT_CROP</a></strong></code>
+<div class="block">This option will enable lossless cropping.</div>
+</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>static int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJTransform.html#OPT_GRAY">OPT_GRAY</a></strong></code>
+<div class="block">This option will discard the color data in the input image and produce
+ a grayscale output image.</div>
+</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>static int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJTransform.html#OPT_NOOUTPUT">OPT_NOOUTPUT</a></strong></code>
+<div class="block">This option will prevent <a href="../../../org/libjpegturbo/turbojpeg/TJTransformer.html#transform(byte[][],%20org.libjpegturbo.turbojpeg.TJTransform[],%20int)"><code>TJTransformer.transform()</code></a> from outputting a JPEG image for this
+ particular transform.</div>
+</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>static int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJTransform.html#OPT_PERFECT">OPT_PERFECT</a></strong></code>
+<div class="block">This option will cause <a href="../../../org/libjpegturbo/turbojpeg/TJTransformer.html#transform(byte[][],%20org.libjpegturbo.turbojpeg.TJTransform[],%20int)"><code>TJTransformer.transform()</code></a> to throw an exception if the transform is not
+ perfect.</div>
+</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>static int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJTransform.html#OPT_PROGRESSIVE">OPT_PROGRESSIVE</a></strong></code>
+<div class="block">This option will enable progressive entropy coding in the output image
+ generated by this particular transform.</div>
+</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>static int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJTransform.html#OPT_TRIM">OPT_TRIM</a></strong></code>
+<div class="block">This option will discard any partial MCU blocks that cannot be
+ transformed.</div>
+</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJTransform.html#options">options</a></strong></code>
+<div class="block">Transform options (bitwise OR of one or more of <code>OPT_*</code>)</div>
+</td>
+</tr>
+</table>
+<ul class="blockList">
+<li class="blockList"><a name="fields_inherited_from_class_java.awt.Rectangle">
+<!--   -->
+</a>
+<h3>Fields inherited from class&nbsp;java.awt.Rectangle</h3>
+<code>height, width, x, y</code></li>
+</ul>
+<ul class="blockList">
+<li class="blockList"><a name="fields_inherited_from_class_java.awt.geom.Rectangle2D">
+<!--   -->
+</a>
+<h3>Fields inherited from class&nbsp;java.awt.geom.Rectangle2D</h3>
+<code>OUT_BOTTOM, OUT_LEFT, OUT_RIGHT, OUT_TOP</code></li>
+</ul>
+</li>
+</ul>
+<!-- ======== CONSTRUCTOR SUMMARY ======== -->
+<ul class="blockList">
+<li class="blockList"><a name="constructor_summary">
+<!--   -->
+</a>
+<h3>Constructor Summary</h3>
+<table class="overviewSummary" border="0" cellpadding="3" cellspacing="0" summary="Constructor Summary table, listing constructors, and an explanation">
+<caption><span>Constructors</span><span class="tabEnd">&nbsp;</span></caption>
+<tr>
+<th class="colOne" scope="col">Constructor and Description</th>
+</tr>
+<tr class="altColor">
+<td class="colOne"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJTransform.html#TJTransform()">TJTransform</a></strong>()</code>
+<div class="block">Create a new lossless transform instance.</div>
+</td>
+</tr>
+<tr class="rowColor">
+<td class="colOne"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJTransform.html#TJTransform(int,%20int,%20int,%20int,%20int,%20int,%20org.libjpegturbo.turbojpeg.TJCustomFilter)">TJTransform</a></strong>(int&nbsp;x,
+           int&nbsp;y,
+           int&nbsp;w,
+           int&nbsp;h,
+           int&nbsp;op,
+           int&nbsp;options,
+           <a href="../../../org/libjpegturbo/turbojpeg/TJCustomFilter.html" title="interface in org.libjpegturbo.turbojpeg">TJCustomFilter</a>&nbsp;cf)</code>
+<div class="block">Create a new lossless transform instance with the given parameters.</div>
+</td>
+</tr>
+<tr class="altColor">
+<td class="colOne"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJTransform.html#TJTransform(java.awt.Rectangle,%20int,%20int,%20org.libjpegturbo.turbojpeg.TJCustomFilter)">TJTransform</a></strong>(java.awt.Rectangle&nbsp;r,
+           int&nbsp;op,
+           int&nbsp;options,
+           <a href="../../../org/libjpegturbo/turbojpeg/TJCustomFilter.html" title="interface in org.libjpegturbo.turbojpeg">TJCustomFilter</a>&nbsp;cf)</code>
+<div class="block">Create a new lossless transform instance with the given parameters.</div>
+</td>
+</tr>
+</table>
+</li>
+</ul>
+<!-- ========== METHOD SUMMARY =========== -->
+<ul class="blockList">
+<li class="blockList"><a name="method_summary">
+<!--   -->
+</a>
+<h3>Method Summary</h3>
+<ul class="blockList">
+<li class="blockList"><a name="methods_inherited_from_class_java.awt.Rectangle">
+<!--   -->
+</a>
+<h3>Methods inherited from class&nbsp;java.awt.Rectangle</h3>
+<code>add, add, add, contains, contains, contains, contains, createIntersection, createUnion, equals, getBounds, getBounds2D, getHeight, getLocation, getSize, getWidth, getX, getY, grow, inside, intersection, intersects, isEmpty, move, outcode, reshape, resize, setBounds, setBounds, setLocation, setLocation, setRect, setSize, setSize, toString, translate, union</code></li>
+</ul>
+<ul class="blockList">
+<li class="blockList"><a name="methods_inherited_from_class_java.awt.geom.Rectangle2D">
+<!--   -->
+</a>
+<h3>Methods inherited from class&nbsp;java.awt.geom.Rectangle2D</h3>
+<code>add, add, add, contains, contains, getPathIterator, getPathIterator, hashCode, intersect, intersects, intersectsLine, intersectsLine, outcode, setFrame, setRect, union</code></li>
+</ul>
+<ul class="blockList">
+<li class="blockList"><a name="methods_inherited_from_class_java.awt.geom.RectangularShape">
+<!--   -->
+</a>
+<h3>Methods inherited from class&nbsp;java.awt.geom.RectangularShape</h3>
+<code>clone, contains, contains, getCenterX, getCenterY, getFrame, getMaxX, getMaxY, getMinX, getMinY, intersects, setFrame, setFrame, setFrameFromCenter, setFrameFromCenter, setFrameFromDiagonal, setFrameFromDiagonal</code></li>
+</ul>
+<ul class="blockList">
+<li class="blockList"><a name="methods_inherited_from_class_java.lang.Object">
+<!--   -->
+</a>
+<h3>Methods inherited from class&nbsp;java.lang.Object</h3>
+<code>finalize, getClass, notify, notifyAll, wait, wait, wait</code></li>
+</ul>
+<ul class="blockList">
+<li class="blockList"><a name="methods_inherited_from_class_java.awt.Shape">
+<!--   -->
+</a>
+<h3>Methods inherited from interface&nbsp;java.awt.Shape</h3>
+<code>contains, contains, contains, contains, getPathIterator, getPathIterator, intersects, intersects</code></li>
+</ul>
+</li>
+</ul>
+</li>
+</ul>
+</div>
+<div class="details">
+<ul class="blockList">
+<li class="blockList">
+<!-- ============ FIELD DETAIL =========== -->
+<ul class="blockList">
+<li class="blockList"><a name="field_detail">
+<!--   -->
+</a>
+<h3>Field Detail</h3>
+<a name="NUMOP">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>NUMOP</h4>
+<pre>public static final&nbsp;int NUMOP</pre>
+<div class="block">The number of lossless transform operations</div>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../constant-values.html#org.libjpegturbo.turbojpeg.TJTransform.NUMOP">Constant Field Values</a></dd></dl>
+</li>
+</ul>
+<a name="OP_NONE">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>OP_NONE</h4>
+<pre>public static final&nbsp;int OP_NONE</pre>
+<div class="block">Do not transform the position of the image pixels.</div>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../constant-values.html#org.libjpegturbo.turbojpeg.TJTransform.OP_NONE">Constant Field Values</a></dd></dl>
+</li>
+</ul>
+<a name="OP_HFLIP">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>OP_HFLIP</h4>
+<pre>public static final&nbsp;int OP_HFLIP</pre>
+<div class="block">Flip (mirror) image horizontally.  This transform is imperfect if there
+ are any partial MCU blocks on the right edge.</div>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../org/libjpegturbo/turbojpeg/TJTransform.html#OPT_PERFECT"><code>OPT_PERFECT</code></a>, 
+<a href="../../../constant-values.html#org.libjpegturbo.turbojpeg.TJTransform.OP_HFLIP">Constant Field Values</a></dd></dl>
+</li>
+</ul>
+<a name="OP_VFLIP">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>OP_VFLIP</h4>
+<pre>public static final&nbsp;int OP_VFLIP</pre>
+<div class="block">Flip (mirror) image vertically.  This transform is imperfect if there are
+ any partial MCU blocks on the bottom edge.</div>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../org/libjpegturbo/turbojpeg/TJTransform.html#OPT_PERFECT"><code>OPT_PERFECT</code></a>, 
+<a href="../../../constant-values.html#org.libjpegturbo.turbojpeg.TJTransform.OP_VFLIP">Constant Field Values</a></dd></dl>
+</li>
+</ul>
+<a name="OP_TRANSPOSE">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>OP_TRANSPOSE</h4>
+<pre>public static final&nbsp;int OP_TRANSPOSE</pre>
+<div class="block">Transpose image (flip/mirror along upper left to lower right axis).  This
+ transform is always perfect.</div>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../org/libjpegturbo/turbojpeg/TJTransform.html#OPT_PERFECT"><code>OPT_PERFECT</code></a>, 
+<a href="../../../constant-values.html#org.libjpegturbo.turbojpeg.TJTransform.OP_TRANSPOSE">Constant Field Values</a></dd></dl>
+</li>
+</ul>
+<a name="OP_TRANSVERSE">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>OP_TRANSVERSE</h4>
+<pre>public static final&nbsp;int OP_TRANSVERSE</pre>
+<div class="block">Transverse transpose image (flip/mirror along upper right to lower left
+ axis).  This transform is imperfect if there are any partial MCU blocks in
+ the image.</div>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../org/libjpegturbo/turbojpeg/TJTransform.html#OPT_PERFECT"><code>OPT_PERFECT</code></a>, 
+<a href="../../../constant-values.html#org.libjpegturbo.turbojpeg.TJTransform.OP_TRANSVERSE">Constant Field Values</a></dd></dl>
+</li>
+</ul>
+<a name="OP_ROT90">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>OP_ROT90</h4>
+<pre>public static final&nbsp;int OP_ROT90</pre>
+<div class="block">Rotate image clockwise by 90 degrees.  This transform is imperfect if
+ there are any partial MCU blocks on the bottom edge.</div>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../org/libjpegturbo/turbojpeg/TJTransform.html#OPT_PERFECT"><code>OPT_PERFECT</code></a>, 
+<a href="../../../constant-values.html#org.libjpegturbo.turbojpeg.TJTransform.OP_ROT90">Constant Field Values</a></dd></dl>
+</li>
+</ul>
+<a name="OP_ROT180">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>OP_ROT180</h4>
+<pre>public static final&nbsp;int OP_ROT180</pre>
+<div class="block">Rotate image 180 degrees.  This transform is imperfect if there are any
+ partial MCU blocks in the image.</div>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../org/libjpegturbo/turbojpeg/TJTransform.html#OPT_PERFECT"><code>OPT_PERFECT</code></a>, 
+<a href="../../../constant-values.html#org.libjpegturbo.turbojpeg.TJTransform.OP_ROT180">Constant Field Values</a></dd></dl>
+</li>
+</ul>
+<a name="OP_ROT270">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>OP_ROT270</h4>
+<pre>public static final&nbsp;int OP_ROT270</pre>
+<div class="block">Rotate image counter-clockwise by 90 degrees.  This transform is imperfect
+ if there are any partial MCU blocks on the right edge.</div>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../org/libjpegturbo/turbojpeg/TJTransform.html#OPT_PERFECT"><code>OPT_PERFECT</code></a>, 
+<a href="../../../constant-values.html#org.libjpegturbo.turbojpeg.TJTransform.OP_ROT270">Constant Field Values</a></dd></dl>
+</li>
+</ul>
+<a name="OPT_PERFECT">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>OPT_PERFECT</h4>
+<pre>public static final&nbsp;int OPT_PERFECT</pre>
+<div class="block">This option will cause <a href="../../../org/libjpegturbo/turbojpeg/TJTransformer.html#transform(byte[][],%20org.libjpegturbo.turbojpeg.TJTransform[],%20int)"><code>TJTransformer.transform()</code></a> to throw an exception if the transform is not
+ perfect.  Lossless transforms operate on MCU blocks, whose size depends on
+ the level of chrominance subsampling used.  If the image's width or height
+ is not evenly divisible by the MCU block size (see <a href="../../../org/libjpegturbo/turbojpeg/TJ.html#getMCUWidth(int)"><code>TJ.getMCUWidth(int)</code></a>
+ and <a href="../../../org/libjpegturbo/turbojpeg/TJ.html#getMCUHeight(int)"><code>TJ.getMCUHeight(int)</code></a>), then there will be partial MCU blocks on the
+ right and/or bottom edges.   It is not possible to move these partial MCU
+ blocks to the top or left of the image, so any transform that would
+ require that is "imperfect."  If this option is not specified, then any
+ partial MCU blocks that cannot be transformed will be left in place, which
+ will create odd-looking strips on the right or bottom edge of the image.</div>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../constant-values.html#org.libjpegturbo.turbojpeg.TJTransform.OPT_PERFECT">Constant Field Values</a></dd></dl>
+</li>
+</ul>
+<a name="OPT_TRIM">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>OPT_TRIM</h4>
+<pre>public static final&nbsp;int OPT_TRIM</pre>
+<div class="block">This option will discard any partial MCU blocks that cannot be
+ transformed.</div>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../constant-values.html#org.libjpegturbo.turbojpeg.TJTransform.OPT_TRIM">Constant Field Values</a></dd></dl>
+</li>
+</ul>
+<a name="OPT_CROP">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>OPT_CROP</h4>
+<pre>public static final&nbsp;int OPT_CROP</pre>
+<div class="block">This option will enable lossless cropping.</div>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../constant-values.html#org.libjpegturbo.turbojpeg.TJTransform.OPT_CROP">Constant Field Values</a></dd></dl>
+</li>
+</ul>
+<a name="OPT_GRAY">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>OPT_GRAY</h4>
+<pre>public static final&nbsp;int OPT_GRAY</pre>
+<div class="block">This option will discard the color data in the input image and produce
+ a grayscale output image.</div>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../constant-values.html#org.libjpegturbo.turbojpeg.TJTransform.OPT_GRAY">Constant Field Values</a></dd></dl>
+</li>
+</ul>
+<a name="OPT_NOOUTPUT">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>OPT_NOOUTPUT</h4>
+<pre>public static final&nbsp;int OPT_NOOUTPUT</pre>
+<div class="block">This option will prevent <a href="../../../org/libjpegturbo/turbojpeg/TJTransformer.html#transform(byte[][],%20org.libjpegturbo.turbojpeg.TJTransform[],%20int)"><code>TJTransformer.transform()</code></a> from outputting a JPEG image for this
+ particular transform.  This can be used in conjunction with a custom
+ filter to capture the transformed DCT coefficients without transcoding
+ them.</div>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../constant-values.html#org.libjpegturbo.turbojpeg.TJTransform.OPT_NOOUTPUT">Constant Field Values</a></dd></dl>
+</li>
+</ul>
+<a name="OPT_PROGRESSIVE">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>OPT_PROGRESSIVE</h4>
+<pre>public static final&nbsp;int OPT_PROGRESSIVE</pre>
+<div class="block">This option will enable progressive entropy coding in the output image
+ generated by this particular transform.  Progressive entropy coding will
+ generally improve compression relative to baseline entropy coding (the
+ default), but it will reduce compression and decompression performance
+ considerably.</div>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../constant-values.html#org.libjpegturbo.turbojpeg.TJTransform.OPT_PROGRESSIVE">Constant Field Values</a></dd></dl>
+</li>
+</ul>
+<a name="OPT_COPYNONE">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>OPT_COPYNONE</h4>
+<pre>public static final&nbsp;int OPT_COPYNONE</pre>
+<div class="block">This option will prevent <a href="../../../org/libjpegturbo/turbojpeg/TJTransformer.html#transform(byte[][],%20org.libjpegturbo.turbojpeg.TJTransform[],%20int)"><code>TJTransformer.transform()</code></a> from copying any extra markers (including EXIF
+ and ICC profile data) from the source image to the output image.</div>
+<dl><dt><span class="strong">See Also:</span></dt><dd><a href="../../../constant-values.html#org.libjpegturbo.turbojpeg.TJTransform.OPT_COPYNONE">Constant Field Values</a></dd></dl>
+</li>
+</ul>
+<a name="op">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>op</h4>
+<pre>public&nbsp;int op</pre>
+<div class="block">Transform operation (one of <code>OP_*</code>)</div>
+</li>
+</ul>
+<a name="options">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>options</h4>
+<pre>public&nbsp;int options</pre>
+<div class="block">Transform options (bitwise OR of one or more of <code>OPT_*</code>)</div>
+</li>
+</ul>
+<a name="cf">
+<!--   -->
+</a>
+<ul class="blockListLast">
+<li class="blockList">
+<h4>cf</h4>
+<pre>public&nbsp;<a href="../../../org/libjpegturbo/turbojpeg/TJCustomFilter.html" title="interface in org.libjpegturbo.turbojpeg">TJCustomFilter</a> cf</pre>
+<div class="block">Custom filter instance</div>
+</li>
+</ul>
+</li>
+</ul>
+<!-- ========= CONSTRUCTOR DETAIL ======== -->
+<ul class="blockList">
+<li class="blockList"><a name="constructor_detail">
+<!--   -->
+</a>
+<h3>Constructor Detail</h3>
+<a name="TJTransform()">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>TJTransform</h4>
+<pre>public&nbsp;TJTransform()</pre>
+<div class="block">Create a new lossless transform instance.</div>
+</li>
+</ul>
+<a name="TJTransform(int, int, int, int, int, int, org.libjpegturbo.turbojpeg.TJCustomFilter)">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>TJTransform</h4>
+<pre>public&nbsp;TJTransform(int&nbsp;x,
+           int&nbsp;y,
+           int&nbsp;w,
+           int&nbsp;h,
+           int&nbsp;op,
+           int&nbsp;options,
+           <a href="../../../org/libjpegturbo/turbojpeg/TJCustomFilter.html" title="interface in org.libjpegturbo.turbojpeg">TJCustomFilter</a>&nbsp;cf)</pre>
+<div class="block">Create a new lossless transform instance with the given parameters.</div>
+<dl><dt><span class="strong">Parameters:</span></dt><dd><code>x</code> - the left boundary of the cropping region.  This must be evenly
+ divisible by the MCU block width (see <a href="../../../org/libjpegturbo/turbojpeg/TJ.html#getMCUWidth(int)"><code>TJ.getMCUWidth(int)</code></a>)</dd><dd><code>y</code> - the upper boundary of the cropping region.  This must be evenly
+ divisible by the MCU block height (see <a href="../../../org/libjpegturbo/turbojpeg/TJ.html#getMCUHeight(int)"><code>TJ.getMCUHeight(int)</code></a>)</dd><dd><code>w</code> - the width of the cropping region.  Setting this to 0 is the
+ equivalent of setting it to (width of the source JPEG image -
+ <code>x</code>).</dd><dd><code>h</code> - the height of the cropping region.  Setting this to 0 is the
+ equivalent of setting it to (height of the source JPEG image -
+ <code>y</code>).</dd><dd><code>op</code> - one of the transform operations (<code>OP_*</code>)</dd><dd><code>options</code> - the bitwise OR of one or more of the transform options
+ (<code>OPT_*</code>)</dd><dd><code>cf</code> - an instance of an object that implements the <a href="../../../org/libjpegturbo/turbojpeg/TJCustomFilter.html" title="interface in org.libjpegturbo.turbojpeg"><code>TJCustomFilter</code></a> interface, or null if no custom filter is needed</dd></dl>
+</li>
+</ul>
+<a name="TJTransform(java.awt.Rectangle, int, int, org.libjpegturbo.turbojpeg.TJCustomFilter)">
+<!--   -->
+</a>
+<ul class="blockListLast">
+<li class="blockList">
+<h4>TJTransform</h4>
+<pre>public&nbsp;TJTransform(java.awt.Rectangle&nbsp;r,
+           int&nbsp;op,
+           int&nbsp;options,
+           <a href="../../../org/libjpegturbo/turbojpeg/TJCustomFilter.html" title="interface in org.libjpegturbo.turbojpeg">TJCustomFilter</a>&nbsp;cf)</pre>
+<div class="block">Create a new lossless transform instance with the given parameters.</div>
+<dl><dt><span class="strong">Parameters:</span></dt><dd><code>r</code> - a <code>Rectangle</code> instance that specifies the cropping
+ region.  See <a href="../../../org/libjpegturbo/turbojpeg/TJTransform.html#TJTransform(int,%20int,%20int,%20int,%20int,%20int,%20org.libjpegturbo.turbojpeg.TJCustomFilter)"><code>TJTransform(int, int, int, int, int, int, TJCustomFilter)</code></a> for more
+ detail.</dd><dd><code>op</code> - one of the transform operations (<code>OP_*</code>)</dd><dd><code>options</code> - the bitwise OR of one or more of the transform options
+ (<code>OPT_*</code>)</dd><dd><code>cf</code> - an instance of an object that implements the <a href="../../../org/libjpegturbo/turbojpeg/TJCustomFilter.html" title="interface in org.libjpegturbo.turbojpeg"><code>TJCustomFilter</code></a> interface, or null if no custom filter is needed</dd></dl>
+</li>
+</ul>
+</li>
+</ul>
+</li>
+</ul>
+</div>
+</div>
+<!-- ========= END OF CLASS DATA ========= -->
+<!-- ======= START OF BOTTOM NAVBAR ====== -->
+<div class="bottomNav"><a name="navbar_bottom">
+<!--   -->
+</a><a href="#skip-navbar_bottom" title="Skip navigation links"></a><a name="navbar_bottom_firstrow">
+<!--   -->
+</a>
+<ul class="navList" title="Navigation">
+<li><a href="../../../org/libjpegturbo/turbojpeg/package-summary.html">Package</a></li>
+<li class="navBarCell1Rev">Class</li>
+<li><a href="package-tree.html">Tree</a></li>
+<li><a href="../../../deprecated-list.html">Deprecated</a></li>
+<li><a href="../../../index-all.html">Index</a></li>
+<li><a href="../../../help-doc.html">Help</a></li>
+</ul>
+</div>
+<div class="subNav">
+<ul class="navList">
+<li><a href="../../../org/libjpegturbo/turbojpeg/TJScalingFactor.html" title="class in org.libjpegturbo.turbojpeg"><span class="strong">Prev Class</span></a></li>
+<li><a href="../../../org/libjpegturbo/turbojpeg/TJTransformer.html" title="class in org.libjpegturbo.turbojpeg"><span class="strong">Next Class</span></a></li>
+</ul>
+<ul class="navList">
+<li><a href="../../../index.html?org/libjpegturbo/turbojpeg/TJTransform.html" target="_top">Frames</a></li>
+<li><a href="TJTransform.html" target="_top">No Frames</a></li>
+</ul>
+<ul class="navList" id="allclasses_navbar_bottom">
+<li><a href="../../../allclasses-noframe.html">All Classes</a></li>
+</ul>
+<div>
+<script type="text/javascript"><!--
+  allClassesLink = document.getElementById("allclasses_navbar_bottom");
+  if(window==top) {
+    allClassesLink.style.display = "block";
+  }
+  else {
+    allClassesLink.style.display = "none";
+  }
+  //-->
+</script>
+</div>
+<div>
+<ul class="subNavList">
+<li>Summary:&nbsp;</li>
+<li><a href="#nested_classes_inherited_from_class_java.awt.geom.Rectangle2D">Nested</a>&nbsp;|&nbsp;</li>
+<li><a href="#field_summary">Field</a>&nbsp;|&nbsp;</li>
+<li><a href="#constructor_summary">Constr</a>&nbsp;|&nbsp;</li>
+<li><a href="#methods_inherited_from_class_java.awt.Rectangle">Method</a></li>
+</ul>
+<ul class="subNavList">
+<li>Detail:&nbsp;</li>
+<li><a href="#field_detail">Field</a>&nbsp;|&nbsp;</li>
+<li><a href="#constructor_detail">Constr</a>&nbsp;|&nbsp;</li>
+<li>Method</li>
+</ul>
+</div>
+<a name="skip-navbar_bottom">
+<!--   -->
+</a></div>
+<!-- ======== END OF BOTTOM NAVBAR ======= -->
+</body>
+</html>
diff --git a/3rdparty/libjpeg/src/java/doc/org/libjpegturbo/turbojpeg/TJTransformer.html b/3rdparty/libjpeg/src/java/doc/org/libjpegturbo/turbojpeg/TJTransformer.html
new file mode 100644
index 00000000..a30fe30c
--- /dev/null
+++ b/3rdparty/libjpeg/src/java/doc/org/libjpegturbo/turbojpeg/TJTransformer.html
@@ -0,0 +1,421 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!-- NewPage -->
+<html lang="en">
+<head>
+<title>TJTransformer</title>
+<link rel="stylesheet" type="text/css" href="../../../stylesheet.css" title="Style">
+</head>
+<body>
+<script type="text/javascript"><!--
+    try {
+        if (location.href.indexOf('is-external=true') == -1) {
+            parent.document.title="TJTransformer";
+        }
+    }
+    catch(err) {
+    }
+//-->
+</script>
+<noscript>
+<div>JavaScript is disabled on your browser.</div>
+</noscript>
+<!-- ========= START OF TOP NAVBAR ======= -->
+<div class="topNav"><a name="navbar_top">
+<!--   -->
+</a><a href="#skip-navbar_top" title="Skip navigation links"></a><a name="navbar_top_firstrow">
+<!--   -->
+</a>
+<ul class="navList" title="Navigation">
+<li><a href="../../../org/libjpegturbo/turbojpeg/package-summary.html">Package</a></li>
+<li class="navBarCell1Rev">Class</li>
+<li><a href="package-tree.html">Tree</a></li>
+<li><a href="../../../deprecated-list.html">Deprecated</a></li>
+<li><a href="../../../index-all.html">Index</a></li>
+<li><a href="../../../help-doc.html">Help</a></li>
+</ul>
+</div>
+<div class="subNav">
+<ul class="navList">
+<li><a href="../../../org/libjpegturbo/turbojpeg/TJTransform.html" title="class in org.libjpegturbo.turbojpeg"><span class="strong">Prev Class</span></a></li>
+<li><a href="../../../org/libjpegturbo/turbojpeg/YUVImage.html" title="class in org.libjpegturbo.turbojpeg"><span class="strong">Next Class</span></a></li>
+</ul>
+<ul class="navList">
+<li><a href="../../../index.html?org/libjpegturbo/turbojpeg/TJTransformer.html" target="_top">Frames</a></li>
+<li><a href="TJTransformer.html" target="_top">No Frames</a></li>
+</ul>
+<ul class="navList" id="allclasses_navbar_top">
+<li><a href="../../../allclasses-noframe.html">All Classes</a></li>
+</ul>
+<div>
+<script type="text/javascript"><!--
+  allClassesLink = document.getElementById("allclasses_navbar_top");
+  if(window==top) {
+    allClassesLink.style.display = "block";
+  }
+  else {
+    allClassesLink.style.display = "none";
+  }
+  //-->
+</script>
+</div>
+<div>
+<ul class="subNavList">
+<li>Summary:&nbsp;</li>
+<li>Nested&nbsp;|&nbsp;</li>
+<li><a href="#fields_inherited_from_class_org.libjpegturbo.turbojpeg.TJDecompressor">Field</a>&nbsp;|&nbsp;</li>
+<li><a href="#constructor_summary">Constr</a>&nbsp;|&nbsp;</li>
+<li><a href="#method_summary">Method</a></li>
+</ul>
+<ul class="subNavList">
+<li>Detail:&nbsp;</li>
+<li>Field&nbsp;|&nbsp;</li>
+<li><a href="#constructor_detail">Constr</a>&nbsp;|&nbsp;</li>
+<li><a href="#method_detail">Method</a></li>
+</ul>
+</div>
+<a name="skip-navbar_top">
+<!--   -->
+</a></div>
+<!-- ========= END OF TOP NAVBAR ========= -->
+<!-- ======== START OF CLASS DATA ======== -->
+<div class="header">
+<div class="subTitle">org.libjpegturbo.turbojpeg</div>
+<h2 title="Class TJTransformer" class="title">Class TJTransformer</h2>
+</div>
+<div class="contentContainer">
+<ul class="inheritance">
+<li>java.lang.Object</li>
+<li>
+<ul class="inheritance">
+<li><a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html" title="class in org.libjpegturbo.turbojpeg">org.libjpegturbo.turbojpeg.TJDecompressor</a></li>
+<li>
+<ul class="inheritance">
+<li>org.libjpegturbo.turbojpeg.TJTransformer</li>
+</ul>
+</li>
+</ul>
+</li>
+</ul>
+<div class="description">
+<ul class="blockList">
+<li class="blockList">
+<dl>
+<dt>All Implemented Interfaces:</dt>
+<dd>java.io.Closeable, java.lang.AutoCloseable</dd>
+</dl>
+<hr>
+<br>
+<pre>public class <span class="strong">TJTransformer</span>
+extends <a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html" title="class in org.libjpegturbo.turbojpeg">TJDecompressor</a></pre>
+<div class="block">TurboJPEG lossless transformer</div>
+</li>
+</ul>
+</div>
+<div class="summary">
+<ul class="blockList">
+<li class="blockList">
+<!-- =========== FIELD SUMMARY =========== -->
+<ul class="blockList">
+<li class="blockList"><a name="field_summary">
+<!--   -->
+</a>
+<h3>Field Summary</h3>
+<ul class="blockList">
+<li class="blockList"><a name="fields_inherited_from_class_org.libjpegturbo.turbojpeg.TJDecompressor">
+<!--   -->
+</a>
+<h3>Fields inherited from class&nbsp;org.libjpegturbo.turbojpeg.<a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html" title="class in org.libjpegturbo.turbojpeg">TJDecompressor</a></h3>
+<code><a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html#handle">handle</a>, <a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html#jpegBuf">jpegBuf</a>, <a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html#jpegBufSize">jpegBufSize</a>, <a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html#jpegColorspace">jpegColorspace</a>, <a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html#jpegHeight">jpegHeight</a>, <a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html#jpegSubsamp">jpegSubsamp</a>, <a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html#jpegWidth">jpegWidth</a>, <a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html#yuvImage">yuvImage</a></code></li>
+</ul>
+</li>
+</ul>
+<!-- ======== CONSTRUCTOR SUMMARY ======== -->
+<ul class="blockList">
+<li class="blockList"><a name="constructor_summary">
+<!--   -->
+</a>
+<h3>Constructor Summary</h3>
+<table class="overviewSummary" border="0" cellpadding="3" cellspacing="0" summary="Constructor Summary table, listing constructors, and an explanation">
+<caption><span>Constructors</span><span class="tabEnd">&nbsp;</span></caption>
+<tr>
+<th class="colOne" scope="col">Constructor and Description</th>
+</tr>
+<tr class="altColor">
+<td class="colOne"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJTransformer.html#TJTransformer()">TJTransformer</a></strong>()</code>
+<div class="block">Create a TurboJPEG lossless transformer instance.</div>
+</td>
+</tr>
+<tr class="rowColor">
+<td class="colOne"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJTransformer.html#TJTransformer(byte[])">TJTransformer</a></strong>(byte[]&nbsp;jpegImage)</code>
+<div class="block">Create a TurboJPEG lossless transformer instance and associate the JPEG
+ image stored in <code>jpegImage</code> with the newly created instance.</div>
+</td>
+</tr>
+<tr class="altColor">
+<td class="colOne"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJTransformer.html#TJTransformer(byte[],%20int)">TJTransformer</a></strong>(byte[]&nbsp;jpegImage,
+             int&nbsp;imageSize)</code>
+<div class="block">Create a TurboJPEG lossless transformer instance and associate the JPEG
+ image of length <code>imageSize</code> bytes stored in
+ <code>jpegImage</code> with the newly created instance.</div>
+</td>
+</tr>
+</table>
+</li>
+</ul>
+<!-- ========== METHOD SUMMARY =========== -->
+<ul class="blockList">
+<li class="blockList"><a name="method_summary">
+<!--   -->
+</a>
+<h3>Method Summary</h3>
+<table class="overviewSummary" border="0" cellpadding="3" cellspacing="0" summary="Method Summary table, listing methods, and an explanation">
+<caption><span>Methods</span><span class="tabEnd">&nbsp;</span></caption>
+<tr>
+<th class="colFirst" scope="col">Modifier and Type</th>
+<th class="colLast" scope="col">Method and Description</th>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>int[]</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJTransformer.html#getTransformedSizes()">getTransformedSizes</a></strong>()</code>
+<div class="block">Returns an array containing the sizes of the transformed JPEG images
+ generated by the most recent transform operation.</div>
+</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>void</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJTransformer.html#transform(byte[][],%20org.libjpegturbo.turbojpeg.TJTransform[],%20int)">transform</a></strong>(byte[][]&nbsp;dstBufs,
+         <a href="../../../org/libjpegturbo/turbojpeg/TJTransform.html" title="class in org.libjpegturbo.turbojpeg">TJTransform</a>[]&nbsp;transforms,
+         int&nbsp;flags)</code>
+<div class="block">Losslessly transform the JPEG image associated with this transformer
+ instance into one or more JPEG images stored in the given destination
+ buffers.</div>
+</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code><a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html" title="class in org.libjpegturbo.turbojpeg">TJDecompressor</a>[]</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/TJTransformer.html#transform(org.libjpegturbo.turbojpeg.TJTransform[],%20int)">transform</a></strong>(<a href="../../../org/libjpegturbo/turbojpeg/TJTransform.html" title="class in org.libjpegturbo.turbojpeg">TJTransform</a>[]&nbsp;transforms,
+         int&nbsp;flags)</code>
+<div class="block">Losslessly transform the JPEG image associated with this transformer
+ instance and return an array of <a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html" title="class in org.libjpegturbo.turbojpeg"><code>TJDecompressor</code></a> instances, each of
+ which has a transformed JPEG image associated with it.</div>
+</td>
+</tr>
+</table>
+<ul class="blockList">
+<li class="blockList"><a name="methods_inherited_from_class_org.libjpegturbo.turbojpeg.TJDecompressor">
+<!--   -->
+</a>
+<h3>Methods inherited from class&nbsp;org.libjpegturbo.turbojpeg.<a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html" title="class in org.libjpegturbo.turbojpeg">TJDecompressor</a></h3>
+<code><a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html#close()">close</a>, <a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html#decompress(java.awt.image.BufferedImage,%20int)">decompress</a>, <a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html#decompress(byte[],%20int,%20int,%20int,%20int,%20int)">decompress</a>, <a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html#decompress(byte[],%20int,%20int,%20int,%20int,%20int,%20int,%20int)">decompress</a>, <a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html#decompress(int[],%20int,%20int,%20int,%20int,%20int,%20int,%20int)">decompress</a>, <a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html#decompress(int,%20int,%20int,%20int)">decompress</a>, <a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html#decompress(int,%20int,%20int,%20int,%20int)">decompress</a>, <a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html#decompressToYUV(byte[],%20int)">decompressToYUV</a>, <a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html#decompressToYUV(int)">decompressToYUV</a>, <a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html#decompressToYUV(int,%20int[],%20int,%20int)">decompressToYUV</a>, <a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html#decompressToYUV(int,%20int,%20int,%20int)">decompressToYUV</a>, <a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html#decompressToYUV(org.libjpegturbo.turbojpeg.YUVImage,%20int)">decompressToYUV</a>, <a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html#finalize()">finalize</a>, <a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html#getColorspace()">getColorspace</a>, <a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html#getHeight()">getHeight</a>, <a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html#getJPEGBuf()">getJPEGBuf</a>, <a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html#getJPEGSize()">getJPEGSize</a>, <a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html#getScaledHeight(int,%20int)">getScaledHeight</a>, <a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html#getScaledWidth(int,%20int)">getScaledWidth</a>, <a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html#getSubsamp()">getSubsamp</a>, <a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html#getWidth()">getWidth</a>, <a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html#setJPEGImage(byte[],%20int)">setJPEGImage</a>, <a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html#setSourceImage(byte[],%20int)">setSourceImage</a>, <a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html#setSourceImage(org.libjpegturbo.turbojpeg.YUVImage)">setSourceImage</a></code></li>
+</ul>
+<ul class="blockList">
+<li class="blockList"><a name="methods_inherited_from_class_java.lang.Object">
+<!--   -->
+</a>
+<h3>Methods inherited from class&nbsp;java.lang.Object</h3>
+<code>clone, equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait</code></li>
+</ul>
+</li>
+</ul>
+</li>
+</ul>
+</div>
+<div class="details">
+<ul class="blockList">
+<li class="blockList">
+<!-- ========= CONSTRUCTOR DETAIL ======== -->
+<ul class="blockList">
+<li class="blockList"><a name="constructor_detail">
+<!--   -->
+</a>
+<h3>Constructor Detail</h3>
+<a name="TJTransformer()">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>TJTransformer</h4>
+<pre>public&nbsp;TJTransformer()
+              throws <a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></pre>
+<div class="block">Create a TurboJPEG lossless transformer instance.</div>
+<dl><dt><span class="strong">Throws:</span></dt>
+<dd><code><a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></code></dd></dl>
+</li>
+</ul>
+<a name="TJTransformer(byte[])">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>TJTransformer</h4>
+<pre>public&nbsp;TJTransformer(byte[]&nbsp;jpegImage)
+              throws <a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></pre>
+<div class="block">Create a TurboJPEG lossless transformer instance and associate the JPEG
+ image stored in <code>jpegImage</code> with the newly created instance.</div>
+<dl><dt><span class="strong">Parameters:</span></dt><dd><code>jpegImage</code> - JPEG image buffer (size of the JPEG image is assumed to
+ be the length of the array.)  This buffer is not modified.</dd>
+<dt><span class="strong">Throws:</span></dt>
+<dd><code><a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></code></dd></dl>
+</li>
+</ul>
+<a name="TJTransformer(byte[], int)">
+<!--   -->
+</a>
+<ul class="blockListLast">
+<li class="blockList">
+<h4>TJTransformer</h4>
+<pre>public&nbsp;TJTransformer(byte[]&nbsp;jpegImage,
+             int&nbsp;imageSize)
+              throws <a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></pre>
+<div class="block">Create a TurboJPEG lossless transformer instance and associate the JPEG
+ image of length <code>imageSize</code> bytes stored in
+ <code>jpegImage</code> with the newly created instance.</div>
+<dl><dt><span class="strong">Parameters:</span></dt><dd><code>jpegImage</code> - JPEG image buffer.  This buffer is not modified.</dd><dd><code>imageSize</code> - size of the JPEG image (in bytes)</dd>
+<dt><span class="strong">Throws:</span></dt>
+<dd><code><a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></code></dd></dl>
+</li>
+</ul>
+</li>
+</ul>
+<!-- ============ METHOD DETAIL ========== -->
+<ul class="blockList">
+<li class="blockList"><a name="method_detail">
+<!--   -->
+</a>
+<h3>Method Detail</h3>
+<a name="transform(byte[][], org.libjpegturbo.turbojpeg.TJTransform[], int)">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>transform</h4>
+<pre>public&nbsp;void&nbsp;transform(byte[][]&nbsp;dstBufs,
+             <a href="../../../org/libjpegturbo/turbojpeg/TJTransform.html" title="class in org.libjpegturbo.turbojpeg">TJTransform</a>[]&nbsp;transforms,
+             int&nbsp;flags)
+               throws <a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></pre>
+<div class="block">Losslessly transform the JPEG image associated with this transformer
+ instance into one or more JPEG images stored in the given destination
+ buffers.  Lossless transforms work by moving the raw coefficients from one
+ JPEG image structure to another without altering the values of the
+ coefficients.  While this is typically faster than decompressing the
+ image, transforming it, and re-compressing it, lossless transforms are not
+ free.  Each lossless transform requires reading and performing Huffman
+ decoding on all of the coefficients in the source image, regardless of the
+ size of the destination image.  Thus, this method provides a means of
+ generating multiple transformed images from the same source or of applying
+ multiple transformations simultaneously, in order to eliminate the need to
+ read the source coefficients multiple times.</div>
+<dl><dt><span class="strong">Parameters:</span></dt><dd><code>dstBufs</code> - an array of image buffers.  <code>dstbufs[i]</code> will
+ receive a JPEG image that has been transformed using the parameters in
+ <code>transforms[i]</code>.  Use <a href="../../../org/libjpegturbo/turbojpeg/TJ.html#bufSize(int,%20int,%20int)"><code>TJ.bufSize(int, int, int)</code></a> to determine the
+ maximum size for each buffer based on the transformed or cropped width and
+ height and the level of subsampling used in the source image.</dd><dd><code>transforms</code> - an array of <a href="../../../org/libjpegturbo/turbojpeg/TJTransform.html" title="class in org.libjpegturbo.turbojpeg"><code>TJTransform</code></a> instances, each of
+ which specifies the transform parameters and/or cropping region for the
+ corresponding transformed output image</dd><dd><code>flags</code> - the bitwise OR of one or more of
+ <a href="../../../org/libjpegturbo/turbojpeg/TJ.html#FLAG_BOTTOMUP"><code>TJ.FLAG_*</code></a></dd>
+<dt><span class="strong">Throws:</span></dt>
+<dd><code><a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></code></dd></dl>
+</li>
+</ul>
+<a name="transform(org.libjpegturbo.turbojpeg.TJTransform[], int)">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>transform</h4>
+<pre>public&nbsp;<a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html" title="class in org.libjpegturbo.turbojpeg">TJDecompressor</a>[]&nbsp;transform(<a href="../../../org/libjpegturbo/turbojpeg/TJTransform.html" title="class in org.libjpegturbo.turbojpeg">TJTransform</a>[]&nbsp;transforms,
+                         int&nbsp;flags)
+                           throws <a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></pre>
+<div class="block">Losslessly transform the JPEG image associated with this transformer
+ instance and return an array of <a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html" title="class in org.libjpegturbo.turbojpeg"><code>TJDecompressor</code></a> instances, each of
+ which has a transformed JPEG image associated with it.</div>
+<dl><dt><span class="strong">Parameters:</span></dt><dd><code>transforms</code> - an array of <a href="../../../org/libjpegturbo/turbojpeg/TJTransform.html" title="class in org.libjpegturbo.turbojpeg"><code>TJTransform</code></a> instances, each of
+ which specifies the transform parameters and/or cropping region for the
+ corresponding transformed output image</dd><dd><code>flags</code> - the bitwise OR of one or more of
+ <a href="../../../org/libjpegturbo/turbojpeg/TJ.html#FLAG_BOTTOMUP"><code>TJ.FLAG_*</code></a></dd>
+<dt><span class="strong">Returns:</span></dt><dd>an array of <a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html" title="class in org.libjpegturbo.turbojpeg"><code>TJDecompressor</code></a> instances, each of
+ which has a transformed JPEG image associated with it.</dd>
+<dt><span class="strong">Throws:</span></dt>
+<dd><code><a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></code></dd></dl>
+</li>
+</ul>
+<a name="getTransformedSizes()">
+<!--   -->
+</a>
+<ul class="blockListLast">
+<li class="blockList">
+<h4>getTransformedSizes</h4>
+<pre>public&nbsp;int[]&nbsp;getTransformedSizes()</pre>
+<div class="block">Returns an array containing the sizes of the transformed JPEG images
+ generated by the most recent transform operation.</div>
+<dl><dt><span class="strong">Returns:</span></dt><dd>an array containing the sizes of the transformed JPEG images
+ generated by the most recent transform operation.</dd></dl>
+</li>
+</ul>
+</li>
+</ul>
+</li>
+</ul>
+</div>
+</div>
+<!-- ========= END OF CLASS DATA ========= -->
+<!-- ======= START OF BOTTOM NAVBAR ====== -->
+<div class="bottomNav"><a name="navbar_bottom">
+<!--   -->
+</a><a href="#skip-navbar_bottom" title="Skip navigation links"></a><a name="navbar_bottom_firstrow">
+<!--   -->
+</a>
+<ul class="navList" title="Navigation">
+<li><a href="../../../org/libjpegturbo/turbojpeg/package-summary.html">Package</a></li>
+<li class="navBarCell1Rev">Class</li>
+<li><a href="package-tree.html">Tree</a></li>
+<li><a href="../../../deprecated-list.html">Deprecated</a></li>
+<li><a href="../../../index-all.html">Index</a></li>
+<li><a href="../../../help-doc.html">Help</a></li>
+</ul>
+</div>
+<div class="subNav">
+<ul class="navList">
+<li><a href="../../../org/libjpegturbo/turbojpeg/TJTransform.html" title="class in org.libjpegturbo.turbojpeg"><span class="strong">Prev Class</span></a></li>
+<li><a href="../../../org/libjpegturbo/turbojpeg/YUVImage.html" title="class in org.libjpegturbo.turbojpeg"><span class="strong">Next Class</span></a></li>
+</ul>
+<ul class="navList">
+<li><a href="../../../index.html?org/libjpegturbo/turbojpeg/TJTransformer.html" target="_top">Frames</a></li>
+<li><a href="TJTransformer.html" target="_top">No Frames</a></li>
+</ul>
+<ul class="navList" id="allclasses_navbar_bottom">
+<li><a href="../../../allclasses-noframe.html">All Classes</a></li>
+</ul>
+<div>
+<script type="text/javascript"><!--
+  allClassesLink = document.getElementById("allclasses_navbar_bottom");
+  if(window==top) {
+    allClassesLink.style.display = "block";
+  }
+  else {
+    allClassesLink.style.display = "none";
+  }
+  //-->
+</script>
+</div>
+<div>
+<ul class="subNavList">
+<li>Summary:&nbsp;</li>
+<li>Nested&nbsp;|&nbsp;</li>
+<li><a href="#fields_inherited_from_class_org.libjpegturbo.turbojpeg.TJDecompressor">Field</a>&nbsp;|&nbsp;</li>
+<li><a href="#constructor_summary">Constr</a>&nbsp;|&nbsp;</li>
+<li><a href="#method_summary">Method</a></li>
+</ul>
+<ul class="subNavList">
+<li>Detail:&nbsp;</li>
+<li>Field&nbsp;|&nbsp;</li>
+<li><a href="#constructor_detail">Constr</a>&nbsp;|&nbsp;</li>
+<li><a href="#method_detail">Method</a></li>
+</ul>
+</div>
+<a name="skip-navbar_bottom">
+<!--   -->
+</a></div>
+<!-- ======== END OF BOTTOM NAVBAR ======= -->
+</body>
+</html>
diff --git a/3rdparty/libjpeg/src/java/doc/org/libjpegturbo/turbojpeg/YUVImage.html b/3rdparty/libjpeg/src/java/doc/org/libjpegturbo/turbojpeg/YUVImage.html
new file mode 100644
index 00000000..d4485ed6
--- /dev/null
+++ b/3rdparty/libjpeg/src/java/doc/org/libjpegturbo/turbojpeg/YUVImage.html
@@ -0,0 +1,765 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!-- NewPage -->
+<html lang="en">
+<head>
+<title>YUVImage</title>
+<link rel="stylesheet" type="text/css" href="../../../stylesheet.css" title="Style">
+</head>
+<body>
+<script type="text/javascript"><!--
+    try {
+        if (location.href.indexOf('is-external=true') == -1) {
+            parent.document.title="YUVImage";
+        }
+    }
+    catch(err) {
+    }
+//-->
+</script>
+<noscript>
+<div>JavaScript is disabled on your browser.</div>
+</noscript>
+<!-- ========= START OF TOP NAVBAR ======= -->
+<div class="topNav"><a name="navbar_top">
+<!--   -->
+</a><a href="#skip-navbar_top" title="Skip navigation links"></a><a name="navbar_top_firstrow">
+<!--   -->
+</a>
+<ul class="navList" title="Navigation">
+<li><a href="../../../org/libjpegturbo/turbojpeg/package-summary.html">Package</a></li>
+<li class="navBarCell1Rev">Class</li>
+<li><a href="package-tree.html">Tree</a></li>
+<li><a href="../../../deprecated-list.html">Deprecated</a></li>
+<li><a href="../../../index-all.html">Index</a></li>
+<li><a href="../../../help-doc.html">Help</a></li>
+</ul>
+</div>
+<div class="subNav">
+<ul class="navList">
+<li><a href="../../../org/libjpegturbo/turbojpeg/TJTransformer.html" title="class in org.libjpegturbo.turbojpeg"><span class="strong">Prev Class</span></a></li>
+<li>Next Class</li>
+</ul>
+<ul class="navList">
+<li><a href="../../../index.html?org/libjpegturbo/turbojpeg/YUVImage.html" target="_top">Frames</a></li>
+<li><a href="YUVImage.html" target="_top">No Frames</a></li>
+</ul>
+<ul class="navList" id="allclasses_navbar_top">
+<li><a href="../../../allclasses-noframe.html">All Classes</a></li>
+</ul>
+<div>
+<script type="text/javascript"><!--
+  allClassesLink = document.getElementById("allclasses_navbar_top");
+  if(window==top) {
+    allClassesLink.style.display = "block";
+  }
+  else {
+    allClassesLink.style.display = "none";
+  }
+  //-->
+</script>
+</div>
+<div>
+<ul class="subNavList">
+<li>Summary:&nbsp;</li>
+<li>Nested&nbsp;|&nbsp;</li>
+<li><a href="#field_summary">Field</a>&nbsp;|&nbsp;</li>
+<li><a href="#constructor_summary">Constr</a>&nbsp;|&nbsp;</li>
+<li><a href="#method_summary">Method</a></li>
+</ul>
+<ul class="subNavList">
+<li>Detail:&nbsp;</li>
+<li><a href="#field_detail">Field</a>&nbsp;|&nbsp;</li>
+<li><a href="#constructor_detail">Constr</a>&nbsp;|&nbsp;</li>
+<li><a href="#method_detail">Method</a></li>
+</ul>
+</div>
+<a name="skip-navbar_top">
+<!--   -->
+</a></div>
+<!-- ========= END OF TOP NAVBAR ========= -->
+<!-- ======== START OF CLASS DATA ======== -->
+<div class="header">
+<div class="subTitle">org.libjpegturbo.turbojpeg</div>
+<h2 title="Class YUVImage" class="title">Class YUVImage</h2>
+</div>
+<div class="contentContainer">
+<ul class="inheritance">
+<li>java.lang.Object</li>
+<li>
+<ul class="inheritance">
+<li>org.libjpegturbo.turbojpeg.YUVImage</li>
+</ul>
+</li>
+</ul>
+<div class="description">
+<ul class="blockList">
+<li class="blockList">
+<hr>
+<br>
+<pre>public class <span class="strong">YUVImage</span>
+extends java.lang.Object</pre>
+<div class="block">This class encapsulates a YUV planar image and the metadata
+ associated with it.  The TurboJPEG API allows both the JPEG compression and
+ decompression pipelines to be split into stages:  YUV encode, compress from
+ YUV, decompress to YUV, and YUV decode.  A <code>YUVImage</code> instance
+ serves as the destination image for YUV encode and decompress-to-YUV
+ operations and as the source image for compress-from-YUV and YUV decode
+ operations.
+ <p>
+ Technically, the JPEG format uses the YCbCr colorspace (which technically is
+ not a "colorspace" but rather a "color transform"), but per the convention
+ of the digital video community, the TurboJPEG API uses "YUV" to refer to an
+ image format consisting of Y, Cb, and Cr image planes.
+ <p>
+ Each plane is simply a 2D array of bytes, each byte representing the value
+ of one of the components (Y, Cb, or Cr) at a particular location in the
+ image.  The width and height of each plane are determined by the image
+ width, height, and level of chrominance subsampling.  The luminance plane
+ width is the image width padded to the nearest multiple of the horizontal
+ subsampling factor (2 in the case of 4:2:0 and 4:2:2, 4 in the case of
+ 4:1:1, 1 in the case of 4:4:4 or grayscale.)  Similarly, the luminance plane
+ height is the image height padded to the nearest multiple of the vertical
+ subsampling factor (2 in the case of 4:2:0 or 4:4:0, 1 in the case of 4:4:4
+ or grayscale.)  The chrominance plane width is equal to the luminance plane
+ width divided by the horizontal subsampling factor, and the chrominance
+ plane height is equal to the luminance plane height divided by the vertical
+ subsampling factor.
+ <p>
+ For example, if the source image is 35 x 35 pixels and 4:2:2 subsampling is
+ used, then the luminance plane would be 36 x 35 bytes, and each of the
+ chrominance planes would be 18 x 35 bytes.  If you specify a line padding of
+ 4 bytes on top of this, then the luminance plane would be 36 x 35 bytes, and
+ each of the chrominance planes would be 20 x 35 bytes.</div>
+</li>
+</ul>
+</div>
+<div class="summary">
+<ul class="blockList">
+<li class="blockList">
+<!-- =========== FIELD SUMMARY =========== -->
+<ul class="blockList">
+<li class="blockList"><a name="field_summary">
+<!--   -->
+</a>
+<h3>Field Summary</h3>
+<table class="overviewSummary" border="0" cellpadding="3" cellspacing="0" summary="Field Summary table, listing fields, and an explanation">
+<caption><span>Fields</span><span class="tabEnd">&nbsp;</span></caption>
+<tr>
+<th class="colFirst" scope="col">Modifier and Type</th>
+<th class="colLast" scope="col">Field and Description</th>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>protected long</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/YUVImage.html#handle">handle</a></strong></code>&nbsp;</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>protected int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/YUVImage.html#yuvHeight">yuvHeight</a></strong></code>&nbsp;</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>protected int[]</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/YUVImage.html#yuvOffsets">yuvOffsets</a></strong></code>&nbsp;</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>protected int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/YUVImage.html#yuvPad">yuvPad</a></strong></code>&nbsp;</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>protected byte[][]</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/YUVImage.html#yuvPlanes">yuvPlanes</a></strong></code>&nbsp;</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>protected int[]</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/YUVImage.html#yuvStrides">yuvStrides</a></strong></code>&nbsp;</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>protected int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/YUVImage.html#yuvSubsamp">yuvSubsamp</a></strong></code>&nbsp;</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>protected int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/YUVImage.html#yuvWidth">yuvWidth</a></strong></code>&nbsp;</td>
+</tr>
+</table>
+</li>
+</ul>
+<!-- ======== CONSTRUCTOR SUMMARY ======== -->
+<ul class="blockList">
+<li class="blockList"><a name="constructor_summary">
+<!--   -->
+</a>
+<h3>Constructor Summary</h3>
+<table class="overviewSummary" border="0" cellpadding="3" cellspacing="0" summary="Constructor Summary table, listing constructors, and an explanation">
+<caption><span>Constructors</span><span class="tabEnd">&nbsp;</span></caption>
+<tr>
+<th class="colOne" scope="col">Constructor and Description</th>
+</tr>
+<tr class="altColor">
+<td class="colOne"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/YUVImage.html#YUVImage(byte[][],%20int[],%20int,%20int[],%20int,%20int)">YUVImage</a></strong>(byte[][]&nbsp;planes,
+        int[]&nbsp;offsets,
+        int&nbsp;width,
+        int[]&nbsp;strides,
+        int&nbsp;height,
+        int&nbsp;subsamp)</code>
+<div class="block">Create a new <code>YUVImage</code> instance from a set of existing image
+ planes.</div>
+</td>
+</tr>
+<tr class="rowColor">
+<td class="colOne"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/YUVImage.html#YUVImage(byte[],%20int,%20int,%20int,%20int)">YUVImage</a></strong>(byte[]&nbsp;yuvImage,
+        int&nbsp;width,
+        int&nbsp;pad,
+        int&nbsp;height,
+        int&nbsp;subsamp)</code>
+<div class="block">Create a new <code>YUVImage</code> instance from an existing unified image
+ buffer.</div>
+</td>
+</tr>
+<tr class="altColor">
+<td class="colOne"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/YUVImage.html#YUVImage(int,%20int[],%20int,%20int)">YUVImage</a></strong>(int&nbsp;width,
+        int[]&nbsp;strides,
+        int&nbsp;height,
+        int&nbsp;subsamp)</code>
+<div class="block">Create a new <code>YUVImage</code> instance backed by separate image
+ planes, and allocate memory for the image planes.</div>
+</td>
+</tr>
+<tr class="rowColor">
+<td class="colOne"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/YUVImage.html#YUVImage(int,%20int,%20int,%20int)">YUVImage</a></strong>(int&nbsp;width,
+        int&nbsp;pad,
+        int&nbsp;height,
+        int&nbsp;subsamp)</code>
+<div class="block">Create a new <code>YUVImage</code> instance backed by a unified image
+ buffer, and allocate memory for the image buffer.</div>
+</td>
+</tr>
+</table>
+</li>
+</ul>
+<!-- ========== METHOD SUMMARY =========== -->
+<ul class="blockList">
+<li class="blockList"><a name="method_summary">
+<!--   -->
+</a>
+<h3>Method Summary</h3>
+<table class="overviewSummary" border="0" cellpadding="3" cellspacing="0" summary="Method Summary table, listing methods, and an explanation">
+<caption><span>Methods</span><span class="tabEnd">&nbsp;</span></caption>
+<tr>
+<th class="colFirst" scope="col">Modifier and Type</th>
+<th class="colLast" scope="col">Method and Description</th>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>byte[]</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/YUVImage.html#getBuf()">getBuf</a></strong>()</code>
+<div class="block">Returns the YUV image buffer (if this image is stored in a unified
+ buffer rather than separate image planes.)</div>
+</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/YUVImage.html#getHeight()">getHeight</a></strong>()</code>
+<div class="block">Returns the height of the YUV image (or subregion.)</div>
+</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>int[]</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/YUVImage.html#getOffsets()">getOffsets</a></strong>()</code>
+<div class="block">Returns the offsets (in bytes) of each plane within the planes of a larger
+ YUV image.</div>
+</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/YUVImage.html#getPad()">getPad</a></strong>()</code>
+<div class="block">Returns the line padding used in the YUV image buffer (if this image is
+ stored in a unified buffer rather than separate image planes.)</div>
+</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>byte[][]</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/YUVImage.html#getPlanes()">getPlanes</a></strong>()</code>
+<div class="block">Returns the YUV image planes.</div>
+</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/YUVImage.html#getSize()">getSize</a></strong>()</code>
+<div class="block">Returns the size (in bytes) of the YUV image buffer (if this image is
+ stored in a unified buffer rather than separate image planes.)</div>
+</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>int[]</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/YUVImage.html#getStrides()">getStrides</a></strong>()</code>
+<div class="block">Returns the number of bytes per line of each plane in the YUV image.</div>
+</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/YUVImage.html#getSubsamp()">getSubsamp</a></strong>()</code>
+<div class="block">Returns the level of chrominance subsampling used in the YUV image.</div>
+</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>int</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/YUVImage.html#getWidth()">getWidth</a></strong>()</code>
+<div class="block">Returns the width of the YUV image (or subregion.)</div>
+</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><code>void</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/YUVImage.html#setBuf(byte[][],%20int[],%20int,%20int[],%20int,%20int)">setBuf</a></strong>(byte[][]&nbsp;planes,
+      int[]&nbsp;offsets,
+      int&nbsp;width,
+      int[]&nbsp;strides,
+      int&nbsp;height,
+      int&nbsp;subsamp)</code>
+<div class="block">Assign a set of image planes to this <code>YUVImage</code> instance.</div>
+</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><code>void</code></td>
+<td class="colLast"><code><strong><a href="../../../org/libjpegturbo/turbojpeg/YUVImage.html#setBuf(byte[],%20int,%20int,%20int,%20int)">setBuf</a></strong>(byte[]&nbsp;yuvImage,
+      int&nbsp;width,
+      int&nbsp;pad,
+      int&nbsp;height,
+      int&nbsp;subsamp)</code>
+<div class="block">Assign a unified image buffer to this <code>YUVImage</code> instance.</div>
+</td>
+</tr>
+</table>
+<ul class="blockList">
+<li class="blockList"><a name="methods_inherited_from_class_java.lang.Object">
+<!--   -->
+</a>
+<h3>Methods inherited from class&nbsp;java.lang.Object</h3>
+<code>clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait</code></li>
+</ul>
+</li>
+</ul>
+</li>
+</ul>
+</div>
+<div class="details">
+<ul class="blockList">
+<li class="blockList">
+<!-- ============ FIELD DETAIL =========== -->
+<ul class="blockList">
+<li class="blockList"><a name="field_detail">
+<!--   -->
+</a>
+<h3>Field Detail</h3>
+<a name="handle">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>handle</h4>
+<pre>protected&nbsp;long handle</pre>
+</li>
+</ul>
+<a name="yuvPlanes">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>yuvPlanes</h4>
+<pre>protected&nbsp;byte[][] yuvPlanes</pre>
+</li>
+</ul>
+<a name="yuvOffsets">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>yuvOffsets</h4>
+<pre>protected&nbsp;int[] yuvOffsets</pre>
+</li>
+</ul>
+<a name="yuvStrides">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>yuvStrides</h4>
+<pre>protected&nbsp;int[] yuvStrides</pre>
+</li>
+</ul>
+<a name="yuvPad">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>yuvPad</h4>
+<pre>protected&nbsp;int yuvPad</pre>
+</li>
+</ul>
+<a name="yuvWidth">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>yuvWidth</h4>
+<pre>protected&nbsp;int yuvWidth</pre>
+</li>
+</ul>
+<a name="yuvHeight">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>yuvHeight</h4>
+<pre>protected&nbsp;int yuvHeight</pre>
+</li>
+</ul>
+<a name="yuvSubsamp">
+<!--   -->
+</a>
+<ul class="blockListLast">
+<li class="blockList">
+<h4>yuvSubsamp</h4>
+<pre>protected&nbsp;int yuvSubsamp</pre>
+</li>
+</ul>
+</li>
+</ul>
+<!-- ========= CONSTRUCTOR DETAIL ======== -->
+<ul class="blockList">
+<li class="blockList"><a name="constructor_detail">
+<!--   -->
+</a>
+<h3>Constructor Detail</h3>
+<a name="YUVImage(int, int[], int, int)">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>YUVImage</h4>
+<pre>public&nbsp;YUVImage(int&nbsp;width,
+        int[]&nbsp;strides,
+        int&nbsp;height,
+        int&nbsp;subsamp)</pre>
+<div class="block">Create a new <code>YUVImage</code> instance backed by separate image
+ planes, and allocate memory for the image planes.</div>
+<dl><dt><span class="strong">Parameters:</span></dt><dd><code>width</code> - width (in pixels) of the YUV image</dd><dd><code>strides</code> - an array of integers, each specifying the number of bytes
+ per line in the corresponding plane of the YUV image.  Setting the stride
+ for any plane to 0 is the same as setting it to the plane width (see
+ <a href="../../../org/libjpegturbo/turbojpeg/YUVImage.html" title="class in org.libjpegturbo.turbojpeg"><code>above</code></a>.)  If <code>strides</code> is null, then the
+ strides for all planes will be set to their respective plane widths.  When
+ using this constructor, the stride for each plane must be equal to or
+ greater than the plane width.</dd><dd><code>height</code> - height (in pixels) of the YUV image</dd><dd><code>subsamp</code> - the level of chrominance subsampling to be used in the YUV
+ image (one of <a href="../../../org/libjpegturbo/turbojpeg/TJ.html#SAMP_444"><code>TJ.SAMP_*</code></a>)</dd></dl>
+</li>
+</ul>
+<a name="YUVImage(int, int, int, int)">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>YUVImage</h4>
+<pre>public&nbsp;YUVImage(int&nbsp;width,
+        int&nbsp;pad,
+        int&nbsp;height,
+        int&nbsp;subsamp)</pre>
+<div class="block">Create a new <code>YUVImage</code> instance backed by a unified image
+ buffer, and allocate memory for the image buffer.</div>
+<dl><dt><span class="strong">Parameters:</span></dt><dd><code>width</code> - width (in pixels) of the YUV image</dd><dd><code>pad</code> - Each line of each plane in the YUV image buffer will be padded
+ to this number of bytes (must be a power of 2.)</dd><dd><code>height</code> - height (in pixels) of the YUV image</dd><dd><code>subsamp</code> - the level of chrominance subsampling to be used in the YUV
+ image (one of <a href="../../../org/libjpegturbo/turbojpeg/TJ.html#SAMP_444"><code>TJ.SAMP_*</code></a>)</dd></dl>
+</li>
+</ul>
+<a name="YUVImage(byte[][], int[], int, int[], int, int)">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>YUVImage</h4>
+<pre>public&nbsp;YUVImage(byte[][]&nbsp;planes,
+        int[]&nbsp;offsets,
+        int&nbsp;width,
+        int[]&nbsp;strides,
+        int&nbsp;height,
+        int&nbsp;subsamp)</pre>
+<div class="block">Create a new <code>YUVImage</code> instance from a set of existing image
+ planes.</div>
+<dl><dt><span class="strong">Parameters:</span></dt><dd><code>planes</code> - an array of buffers representing the Y, U (Cb), and V (Cr)
+ image planes (or just the Y plane, if the image is grayscale.)   These
+ planes can be contiguous or non-contiguous in memory.  Plane
+ <code>i</code> should be at least <code>offsets[i] +
+ <a href="../../../org/libjpegturbo/turbojpeg/TJ.html#planeSizeYUV(int,%20int,%20int,%20int,%20int)"><code>TJ.planeSizeYUV</code></a>(i, width, strides[i], height, subsamp)</code>
+ bytes in size.</dd><dd><code>offsets</code> - If this <code>YUVImage</code> instance represents a
+ subregion of a larger image, then <code>offsets[i]</code> specifies the
+ offset (in bytes) of the subregion within plane <code>i</code> of the
+ larger image.  Setting this to null is the same as setting the offsets for
+ all planes to 0.</dd><dd><code>width</code> - width (in pixels) of the new YUV image (or subregion)</dd><dd><code>strides</code> - an array of integers, each specifying the number of bytes
+ per line in the corresponding plane of the YUV image.  Setting the stride
+ for any plane to 0 is the same as setting it to the plane width (see
+ <a href="../../../org/libjpegturbo/turbojpeg/YUVImage.html" title="class in org.libjpegturbo.turbojpeg"><code>above</code></a>.)  If <code>strides</code> is null, then the
+ strides for all planes will be set to their respective plane widths.  You
+ can adjust the strides in order to add an arbitrary amount of line padding
+ to each plane or to specify that this <code>YUVImage</code> instance is a
+ subregion of a larger image (in which case, <code>strides[i]</code> should
+ be set to the plane width of plane <code>i</code> in the larger image.)</dd><dd><code>height</code> - height (in pixels) of the new YUV image (or subregion)</dd><dd><code>subsamp</code> - the level of chrominance subsampling used in the YUV
+ image (one of <a href="../../../org/libjpegturbo/turbojpeg/TJ.html#SAMP_444"><code>TJ.SAMP_*</code></a>)</dd></dl>
+</li>
+</ul>
+<a name="YUVImage(byte[], int, int, int, int)">
+<!--   -->
+</a>
+<ul class="blockListLast">
+<li class="blockList">
+<h4>YUVImage</h4>
+<pre>public&nbsp;YUVImage(byte[]&nbsp;yuvImage,
+        int&nbsp;width,
+        int&nbsp;pad,
+        int&nbsp;height,
+        int&nbsp;subsamp)</pre>
+<div class="block">Create a new <code>YUVImage</code> instance from an existing unified image
+ buffer.</div>
+<dl><dt><span class="strong">Parameters:</span></dt><dd><code>yuvImage</code> - image buffer that contains or will contain YUV planar
+ image data.  Use <a href="../../../org/libjpegturbo/turbojpeg/TJ.html#bufSizeYUV(int,%20int,%20int,%20int)"><code>TJ.bufSizeYUV(int, int, int, int)</code></a> to determine the minimum size for
+ this buffer.  The Y, U (Cb), and V (Cr) image planes are stored
+ sequentially in the buffer (see <a href="../../../org/libjpegturbo/turbojpeg/YUVImage.html" title="class in org.libjpegturbo.turbojpeg"><code>above</code></a> for a description
+ of the image format.)</dd><dd><code>width</code> - width (in pixels) of the YUV image</dd><dd><code>pad</code> - the line padding used in the YUV image buffer.  For
+ instance, if each line in each plane of the buffer is padded to the
+ nearest multiple of 4 bytes, then <code>pad</code> should be set to 4.</dd><dd><code>height</code> - height (in pixels) of the YUV image</dd><dd><code>subsamp</code> - the level of chrominance subsampling used in the YUV
+ image (one of <a href="../../../org/libjpegturbo/turbojpeg/TJ.html#SAMP_444"><code>TJ.SAMP_*</code></a>)</dd></dl>
+</li>
+</ul>
+</li>
+</ul>
+<!-- ============ METHOD DETAIL ========== -->
+<ul class="blockList">
+<li class="blockList"><a name="method_detail">
+<!--   -->
+</a>
+<h3>Method Detail</h3>
+<a name="setBuf(byte[][], int[], int, int[], int, int)">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>setBuf</h4>
+<pre>public&nbsp;void&nbsp;setBuf(byte[][]&nbsp;planes,
+          int[]&nbsp;offsets,
+          int&nbsp;width,
+          int[]&nbsp;strides,
+          int&nbsp;height,
+          int&nbsp;subsamp)</pre>
+<div class="block">Assign a set of image planes to this <code>YUVImage</code> instance.</div>
+<dl><dt><span class="strong">Parameters:</span></dt><dd><code>planes</code> - an array of buffers representing the Y, U (Cb), and V (Cr)
+ image planes (or just the Y plane, if the image is grayscale.)  These
+ planes can be contiguous or non-contiguous in memory.  Plane
+ <code>i</code> should be at least <code>offsets[i] +
+ <a href="../../../org/libjpegturbo/turbojpeg/TJ.html#planeSizeYUV(int,%20int,%20int,%20int,%20int)"><code>TJ.planeSizeYUV</code></a>(i, width, strides[i], height, subsamp)</code>
+ bytes in size.</dd><dd><code>offsets</code> - If this <code>YUVImage</code> instance represents a
+ subregion of a larger image, then <code>offsets[i]</code> specifies the
+ offset (in bytes) of the subregion within plane <code>i</code> of the
+ larger image.  Setting this to null is the same as setting the offsets for
+ all planes to 0.</dd><dd><code>width</code> - width (in pixels) of the YUV image (or subregion)</dd><dd><code>strides</code> - an array of integers, each specifying the number of bytes
+ per line in the corresponding plane of the YUV image.  Setting the stride
+ for any plane to 0 is the same as setting it to the plane width (see
+ <a href="../../../org/libjpegturbo/turbojpeg/YUVImage.html" title="class in org.libjpegturbo.turbojpeg"><code>above</code></a>.)  If <code>strides</code> is null, then the
+ strides for all planes will be set to their respective plane widths.  You
+ can adjust the strides in order to add an arbitrary amount of line padding
+ to each plane or to specify that this <code>YUVImage</code> image is a
+ subregion of a larger image (in which case, <code>strides[i]</code> should
+ be set to the plane width of plane <code>i</code> in the larger image.)</dd><dd><code>height</code> - height (in pixels) of the YUV image (or subregion)</dd><dd><code>subsamp</code> - the level of chrominance subsampling used in the YUV
+ image (one of <a href="../../../org/libjpegturbo/turbojpeg/TJ.html#SAMP_444"><code>TJ.SAMP_*</code></a>)</dd></dl>
+</li>
+</ul>
+<a name="setBuf(byte[], int, int, int, int)">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>setBuf</h4>
+<pre>public&nbsp;void&nbsp;setBuf(byte[]&nbsp;yuvImage,
+          int&nbsp;width,
+          int&nbsp;pad,
+          int&nbsp;height,
+          int&nbsp;subsamp)</pre>
+<div class="block">Assign a unified image buffer to this <code>YUVImage</code> instance.</div>
+<dl><dt><span class="strong">Parameters:</span></dt><dd><code>yuvImage</code> - image buffer that contains or will contain YUV planar
+ image data.  Use <a href="../../../org/libjpegturbo/turbojpeg/TJ.html#bufSizeYUV(int,%20int,%20int,%20int)"><code>TJ.bufSizeYUV(int, int, int, int)</code></a> to determine the minimum size for
+ this buffer.  The Y, U (Cb), and V (Cr) image planes are stored
+ sequentially in the buffer (see <a href="../../../org/libjpegturbo/turbojpeg/YUVImage.html" title="class in org.libjpegturbo.turbojpeg"><code>above</code></a> for a description
+ of the image format.)</dd><dd><code>width</code> - width (in pixels) of the YUV image</dd><dd><code>pad</code> - the line padding used in the YUV image buffer.  For
+ instance, if each line in each plane of the buffer is padded to the
+ nearest multiple of 4 bytes, then <code>pad</code> should be set to 4.</dd><dd><code>height</code> - height (in pixels) of the YUV image</dd><dd><code>subsamp</code> - the level of chrominance subsampling used in the YUV
+ image (one of <a href="../../../org/libjpegturbo/turbojpeg/TJ.html#SAMP_444"><code>TJ.SAMP_*</code></a>)</dd></dl>
+</li>
+</ul>
+<a name="getWidth()">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>getWidth</h4>
+<pre>public&nbsp;int&nbsp;getWidth()</pre>
+<div class="block">Returns the width of the YUV image (or subregion.)</div>
+<dl><dt><span class="strong">Returns:</span></dt><dd>the width of the YUV image (or subregion)</dd></dl>
+</li>
+</ul>
+<a name="getHeight()">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>getHeight</h4>
+<pre>public&nbsp;int&nbsp;getHeight()</pre>
+<div class="block">Returns the height of the YUV image (or subregion.)</div>
+<dl><dt><span class="strong">Returns:</span></dt><dd>the height of the YUV image (or subregion)</dd></dl>
+</li>
+</ul>
+<a name="getPad()">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>getPad</h4>
+<pre>public&nbsp;int&nbsp;getPad()</pre>
+<div class="block">Returns the line padding used in the YUV image buffer (if this image is
+ stored in a unified buffer rather than separate image planes.)</div>
+<dl><dt><span class="strong">Returns:</span></dt><dd>the line padding used in the YUV image buffer</dd></dl>
+</li>
+</ul>
+<a name="getStrides()">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>getStrides</h4>
+<pre>public&nbsp;int[]&nbsp;getStrides()</pre>
+<div class="block">Returns the number of bytes per line of each plane in the YUV image.</div>
+<dl><dt><span class="strong">Returns:</span></dt><dd>the number of bytes per line of each plane in the YUV image</dd></dl>
+</li>
+</ul>
+<a name="getOffsets()">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>getOffsets</h4>
+<pre>public&nbsp;int[]&nbsp;getOffsets()</pre>
+<div class="block">Returns the offsets (in bytes) of each plane within the planes of a larger
+ YUV image.</div>
+<dl><dt><span class="strong">Returns:</span></dt><dd>the offsets (in bytes) of each plane within the planes of a larger
+ YUV image</dd></dl>
+</li>
+</ul>
+<a name="getSubsamp()">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>getSubsamp</h4>
+<pre>public&nbsp;int&nbsp;getSubsamp()</pre>
+<div class="block">Returns the level of chrominance subsampling used in the YUV image.  See
+ <a href="../../../org/libjpegturbo/turbojpeg/TJ.html#SAMP_444"><code>TJ.SAMP_*</code></a>.</div>
+<dl><dt><span class="strong">Returns:</span></dt><dd>the level of chrominance subsampling used in the YUV image</dd></dl>
+</li>
+</ul>
+<a name="getPlanes()">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>getPlanes</h4>
+<pre>public&nbsp;byte[][]&nbsp;getPlanes()</pre>
+<div class="block">Returns the YUV image planes.  If the image is stored in a unified buffer,
+ then all image planes will point to that buffer.</div>
+<dl><dt><span class="strong">Returns:</span></dt><dd>the YUV image planes</dd></dl>
+</li>
+</ul>
+<a name="getBuf()">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>getBuf</h4>
+<pre>public&nbsp;byte[]&nbsp;getBuf()</pre>
+<div class="block">Returns the YUV image buffer (if this image is stored in a unified
+ buffer rather than separate image planes.)</div>
+<dl><dt><span class="strong">Returns:</span></dt><dd>the YUV image buffer</dd></dl>
+</li>
+</ul>
+<a name="getSize()">
+<!--   -->
+</a>
+<ul class="blockListLast">
+<li class="blockList">
+<h4>getSize</h4>
+<pre>public&nbsp;int&nbsp;getSize()</pre>
+<div class="block">Returns the size (in bytes) of the YUV image buffer (if this image is
+ stored in a unified buffer rather than separate image planes.)</div>
+<dl><dt><span class="strong">Returns:</span></dt><dd>the size (in bytes) of the YUV image buffer</dd></dl>
+</li>
+</ul>
+</li>
+</ul>
+</li>
+</ul>
+</div>
+</div>
+<!-- ========= END OF CLASS DATA ========= -->
+<!-- ======= START OF BOTTOM NAVBAR ====== -->
+<div class="bottomNav"><a name="navbar_bottom">
+<!--   -->
+</a><a href="#skip-navbar_bottom" title="Skip navigation links"></a><a name="navbar_bottom_firstrow">
+<!--   -->
+</a>
+<ul class="navList" title="Navigation">
+<li><a href="../../../org/libjpegturbo/turbojpeg/package-summary.html">Package</a></li>
+<li class="navBarCell1Rev">Class</li>
+<li><a href="package-tree.html">Tree</a></li>
+<li><a href="../../../deprecated-list.html">Deprecated</a></li>
+<li><a href="../../../index-all.html">Index</a></li>
+<li><a href="../../../help-doc.html">Help</a></li>
+</ul>
+</div>
+<div class="subNav">
+<ul class="navList">
+<li><a href="../../../org/libjpegturbo/turbojpeg/TJTransformer.html" title="class in org.libjpegturbo.turbojpeg"><span class="strong">Prev Class</span></a></li>
+<li>Next Class</li>
+</ul>
+<ul class="navList">
+<li><a href="../../../index.html?org/libjpegturbo/turbojpeg/YUVImage.html" target="_top">Frames</a></li>
+<li><a href="YUVImage.html" target="_top">No Frames</a></li>
+</ul>
+<ul class="navList" id="allclasses_navbar_bottom">
+<li><a href="../../../allclasses-noframe.html">All Classes</a></li>
+</ul>
+<div>
+<script type="text/javascript"><!--
+  allClassesLink = document.getElementById("allclasses_navbar_bottom");
+  if(window==top) {
+    allClassesLink.style.display = "block";
+  }
+  else {
+    allClassesLink.style.display = "none";
+  }
+  //-->
+</script>
+</div>
+<div>
+<ul class="subNavList">
+<li>Summary:&nbsp;</li>
+<li>Nested&nbsp;|&nbsp;</li>
+<li><a href="#field_summary">Field</a>&nbsp;|&nbsp;</li>
+<li><a href="#constructor_summary">Constr</a>&nbsp;|&nbsp;</li>
+<li><a href="#method_summary">Method</a></li>
+</ul>
+<ul class="subNavList">
+<li>Detail:&nbsp;</li>
+<li><a href="#field_detail">Field</a>&nbsp;|&nbsp;</li>
+<li><a href="#constructor_detail">Constr</a>&nbsp;|&nbsp;</li>
+<li><a href="#method_detail">Method</a></li>
+</ul>
+</div>
+<a name="skip-navbar_bottom">
+<!--   -->
+</a></div>
+<!-- ======== END OF BOTTOM NAVBAR ======= -->
+</body>
+</html>
diff --git a/3rdparty/libjpeg/src/java/doc/org/libjpegturbo/turbojpeg/package-frame.html b/3rdparty/libjpeg/src/java/doc/org/libjpegturbo/turbojpeg/package-frame.html
new file mode 100644
index 00000000..08a8bf83
--- /dev/null
+++ b/3rdparty/libjpeg/src/java/doc/org/libjpegturbo/turbojpeg/package-frame.html
@@ -0,0 +1,31 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!-- NewPage -->
+<html lang="en">
+<head>
+<title>org.libjpegturbo.turbojpeg</title>
+<link rel="stylesheet" type="text/css" href="../../../stylesheet.css" title="Style">
+</head>
+<body>
+<h1 class="bar"><a href="../../../org/libjpegturbo/turbojpeg/package-summary.html" target="classFrame">org.libjpegturbo.turbojpeg</a></h1>
+<div class="indexContainer">
+<h2 title="Interfaces">Interfaces</h2>
+<ul title="Interfaces">
+<li><a href="TJCustomFilter.html" title="interface in org.libjpegturbo.turbojpeg" target="classFrame"><i>TJCustomFilter</i></a></li>
+</ul>
+<h2 title="Classes">Classes</h2>
+<ul title="Classes">
+<li><a href="TJ.html" title="class in org.libjpegturbo.turbojpeg" target="classFrame">TJ</a></li>
+<li><a href="TJCompressor.html" title="class in org.libjpegturbo.turbojpeg" target="classFrame">TJCompressor</a></li>
+<li><a href="TJDecompressor.html" title="class in org.libjpegturbo.turbojpeg" target="classFrame">TJDecompressor</a></li>
+<li><a href="TJScalingFactor.html" title="class in org.libjpegturbo.turbojpeg" target="classFrame">TJScalingFactor</a></li>
+<li><a href="TJTransform.html" title="class in org.libjpegturbo.turbojpeg" target="classFrame">TJTransform</a></li>
+<li><a href="TJTransformer.html" title="class in org.libjpegturbo.turbojpeg" target="classFrame">TJTransformer</a></li>
+<li><a href="YUVImage.html" title="class in org.libjpegturbo.turbojpeg" target="classFrame">YUVImage</a></li>
+</ul>
+<h2 title="Exceptions">Exceptions</h2>
+<ul title="Exceptions">
+<li><a href="TJException.html" title="class in org.libjpegturbo.turbojpeg" target="classFrame">TJException</a></li>
+</ul>
+</div>
+</body>
+</html>
diff --git a/3rdparty/libjpeg/src/java/doc/org/libjpegturbo/turbojpeg/package-summary.html b/3rdparty/libjpeg/src/java/doc/org/libjpegturbo/turbojpeg/package-summary.html
new file mode 100644
index 00000000..dedcce5c
--- /dev/null
+++ b/3rdparty/libjpeg/src/java/doc/org/libjpegturbo/turbojpeg/package-summary.html
@@ -0,0 +1,202 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!-- NewPage -->
+<html lang="en">
+<head>
+<title>org.libjpegturbo.turbojpeg</title>
+<link rel="stylesheet" type="text/css" href="../../../stylesheet.css" title="Style">
+</head>
+<body>
+<script type="text/javascript"><!--
+    try {
+        if (location.href.indexOf('is-external=true') == -1) {
+            parent.document.title="org.libjpegturbo.turbojpeg";
+        }
+    }
+    catch(err) {
+    }
+//-->
+</script>
+<noscript>
+<div>JavaScript is disabled on your browser.</div>
+</noscript>
+<!-- ========= START OF TOP NAVBAR ======= -->
+<div class="topNav"><a name="navbar_top">
+<!--   -->
+</a><a href="#skip-navbar_top" title="Skip navigation links"></a><a name="navbar_top_firstrow">
+<!--   -->
+</a>
+<ul class="navList" title="Navigation">
+<li><a href="../../../org/libjpegturbo/turbojpeg/package-summary.html">Package</a></li>
+<li>Class</li>
+<li><a href="package-tree.html">Tree</a></li>
+<li><a href="../../../deprecated-list.html">Deprecated</a></li>
+<li><a href="../../../index-all.html">Index</a></li>
+<li><a href="../../../help-doc.html">Help</a></li>
+</ul>
+</div>
+<div class="subNav">
+<ul class="navList">
+<li>Prev Package</li>
+<li>Next Package</li>
+</ul>
+<ul class="navList">
+<li><a href="../../../index.html?org/libjpegturbo/turbojpeg/package-summary.html" target="_top">Frames</a></li>
+<li><a href="package-summary.html" target="_top">No Frames</a></li>
+</ul>
+<ul class="navList" id="allclasses_navbar_top">
+<li><a href="../../../allclasses-noframe.html">All Classes</a></li>
+</ul>
+<div>
+<script type="text/javascript"><!--
+  allClassesLink = document.getElementById("allclasses_navbar_top");
+  if(window==top) {
+    allClassesLink.style.display = "block";
+  }
+  else {
+    allClassesLink.style.display = "none";
+  }
+  //-->
+</script>
+</div>
+<a name="skip-navbar_top">
+<!--   -->
+</a></div>
+<!-- ========= END OF TOP NAVBAR ========= -->
+<div class="header">
+<h1 title="Package" class="title">Package&nbsp;org.libjpegturbo.turbojpeg</h1>
+</div>
+<div class="contentContainer">
+<ul class="blockList">
+<li class="blockList">
+<table class="packageSummary" border="0" cellpadding="3" cellspacing="0" summary="Interface Summary table, listing interfaces, and an explanation">
+<caption><span>Interface Summary</span><span class="tabEnd">&nbsp;</span></caption>
+<tr>
+<th class="colFirst" scope="col">Interface</th>
+<th class="colLast" scope="col">Description</th>
+</tr>
+<tbody>
+<tr class="altColor">
+<td class="colFirst"><a href="../../../org/libjpegturbo/turbojpeg/TJCustomFilter.html" title="interface in org.libjpegturbo.turbojpeg">TJCustomFilter</a></td>
+<td class="colLast">
+<div class="block">Custom filter callback interface</div>
+</td>
+</tr>
+</tbody>
+</table>
+</li>
+<li class="blockList">
+<table class="packageSummary" border="0" cellpadding="3" cellspacing="0" summary="Class Summary table, listing classes, and an explanation">
+<caption><span>Class Summary</span><span class="tabEnd">&nbsp;</span></caption>
+<tr>
+<th class="colFirst" scope="col">Class</th>
+<th class="colLast" scope="col">Description</th>
+</tr>
+<tbody>
+<tr class="altColor">
+<td class="colFirst"><a href="../../../org/libjpegturbo/turbojpeg/TJ.html" title="class in org.libjpegturbo.turbojpeg">TJ</a></td>
+<td class="colLast">
+<div class="block">TurboJPEG utility class (cannot be instantiated)</div>
+</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><a href="../../../org/libjpegturbo/turbojpeg/TJCompressor.html" title="class in org.libjpegturbo.turbojpeg">TJCompressor</a></td>
+<td class="colLast">
+<div class="block">TurboJPEG compressor</div>
+</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html" title="class in org.libjpegturbo.turbojpeg">TJDecompressor</a></td>
+<td class="colLast">
+<div class="block">TurboJPEG decompressor</div>
+</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><a href="../../../org/libjpegturbo/turbojpeg/TJScalingFactor.html" title="class in org.libjpegturbo.turbojpeg">TJScalingFactor</a></td>
+<td class="colLast">
+<div class="block">Fractional scaling factor</div>
+</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><a href="../../../org/libjpegturbo/turbojpeg/TJTransform.html" title="class in org.libjpegturbo.turbojpeg">TJTransform</a></td>
+<td class="colLast">
+<div class="block">Lossless transform parameters</div>
+</td>
+</tr>
+<tr class="rowColor">
+<td class="colFirst"><a href="../../../org/libjpegturbo/turbojpeg/TJTransformer.html" title="class in org.libjpegturbo.turbojpeg">TJTransformer</a></td>
+<td class="colLast">
+<div class="block">TurboJPEG lossless transformer</div>
+</td>
+</tr>
+<tr class="altColor">
+<td class="colFirst"><a href="../../../org/libjpegturbo/turbojpeg/YUVImage.html" title="class in org.libjpegturbo.turbojpeg">YUVImage</a></td>
+<td class="colLast">
+<div class="block">This class encapsulates a YUV planar image and the metadata
+ associated with it.</div>
+</td>
+</tr>
+</tbody>
+</table>
+</li>
+<li class="blockList">
+<table class="packageSummary" border="0" cellpadding="3" cellspacing="0" summary="Exception Summary table, listing exceptions, and an explanation">
+<caption><span>Exception Summary</span><span class="tabEnd">&nbsp;</span></caption>
+<tr>
+<th class="colFirst" scope="col">Exception</th>
+<th class="colLast" scope="col">Description</th>
+</tr>
+<tbody>
+<tr class="altColor">
+<td class="colFirst"><a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">TJException</a></td>
+<td class="colLast">&nbsp;</td>
+</tr>
+</tbody>
+</table>
+</li>
+</ul>
+</div>
+<!-- ======= START OF BOTTOM NAVBAR ====== -->
+<div class="bottomNav"><a name="navbar_bottom">
+<!--   -->
+</a><a href="#skip-navbar_bottom" title="Skip navigation links"></a><a name="navbar_bottom_firstrow">
+<!--   -->
+</a>
+<ul class="navList" title="Navigation">
+<li><a href="../../../org/libjpegturbo/turbojpeg/package-summary.html">Package</a></li>
+<li>Class</li>
+<li><a href="package-tree.html">Tree</a></li>
+<li><a href="../../../deprecated-list.html">Deprecated</a></li>
+<li><a href="../../../index-all.html">Index</a></li>
+<li><a href="../../../help-doc.html">Help</a></li>
+</ul>
+</div>
+<div class="subNav">
+<ul class="navList">
+<li>Prev Package</li>
+<li>Next Package</li>
+</ul>
+<ul class="navList">
+<li><a href="../../../index.html?org/libjpegturbo/turbojpeg/package-summary.html" target="_top">Frames</a></li>
+<li><a href="package-summary.html" target="_top">No Frames</a></li>
+</ul>
+<ul class="navList" id="allclasses_navbar_bottom">
+<li><a href="../../../allclasses-noframe.html">All Classes</a></li>
+</ul>
+<div>
+<script type="text/javascript"><!--
+  allClassesLink = document.getElementById("allclasses_navbar_bottom");
+  if(window==top) {
+    allClassesLink.style.display = "block";
+  }
+  else {
+    allClassesLink.style.display = "none";
+  }
+  //-->
+</script>
+</div>
+<a name="skip-navbar_bottom">
+<!--   -->
+</a></div>
+<!-- ======== END OF BOTTOM NAVBAR ======= -->
+</body>
+</html>
diff --git a/3rdparty/libjpeg/src/java/doc/org/libjpegturbo/turbojpeg/package-tree.html b/3rdparty/libjpeg/src/java/doc/org/libjpegturbo/turbojpeg/package-tree.html
new file mode 100644
index 00000000..5f0f8c3e
--- /dev/null
+++ b/3rdparty/libjpeg/src/java/doc/org/libjpegturbo/turbojpeg/package-tree.html
@@ -0,0 +1,160 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!-- NewPage -->
+<html lang="en">
+<head>
+<title>org.libjpegturbo.turbojpeg Class Hierarchy</title>
+<link rel="stylesheet" type="text/css" href="../../../stylesheet.css" title="Style">
+</head>
+<body>
+<script type="text/javascript"><!--
+    try {
+        if (location.href.indexOf('is-external=true') == -1) {
+            parent.document.title="org.libjpegturbo.turbojpeg Class Hierarchy";
+        }
+    }
+    catch(err) {
+    }
+//-->
+</script>
+<noscript>
+<div>JavaScript is disabled on your browser.</div>
+</noscript>
+<!-- ========= START OF TOP NAVBAR ======= -->
+<div class="topNav"><a name="navbar_top">
+<!--   -->
+</a><a href="#skip-navbar_top" title="Skip navigation links"></a><a name="navbar_top_firstrow">
+<!--   -->
+</a>
+<ul class="navList" title="Navigation">
+<li><a href="../../../org/libjpegturbo/turbojpeg/package-summary.html">Package</a></li>
+<li>Class</li>
+<li class="navBarCell1Rev">Tree</li>
+<li><a href="../../../deprecated-list.html">Deprecated</a></li>
+<li><a href="../../../index-all.html">Index</a></li>
+<li><a href="../../../help-doc.html">Help</a></li>
+</ul>
+</div>
+<div class="subNav">
+<ul class="navList">
+<li>Prev</li>
+<li>Next</li>
+</ul>
+<ul class="navList">
+<li><a href="../../../index.html?org/libjpegturbo/turbojpeg/package-tree.html" target="_top">Frames</a></li>
+<li><a href="package-tree.html" target="_top">No Frames</a></li>
+</ul>
+<ul class="navList" id="allclasses_navbar_top">
+<li><a href="../../../allclasses-noframe.html">All Classes</a></li>
+</ul>
+<div>
+<script type="text/javascript"><!--
+  allClassesLink = document.getElementById("allclasses_navbar_top");
+  if(window==top) {
+    allClassesLink.style.display = "block";
+  }
+  else {
+    allClassesLink.style.display = "none";
+  }
+  //-->
+</script>
+</div>
+<a name="skip-navbar_top">
+<!--   -->
+</a></div>
+<!-- ========= END OF TOP NAVBAR ========= -->
+<div class="header">
+<h1 class="title">Hierarchy For Package org.libjpegturbo.turbojpeg</h1>
+</div>
+<div class="contentContainer">
+<h2 title="Class Hierarchy">Class Hierarchy</h2>
+<ul>
+<li type="circle">java.lang.Object
+<ul>
+<li type="circle">java.awt.geom.RectangularShape (implements java.lang.Cloneable, java.awt.Shape)
+<ul>
+<li type="circle">java.awt.geom.Rectangle2D
+<ul>
+<li type="circle">java.awt.Rectangle (implements java.io.Serializable, java.awt.Shape)
+<ul>
+<li type="circle">org.libjpegturbo.turbojpeg.<a href="../../../org/libjpegturbo/turbojpeg/TJTransform.html" title="class in org.libjpegturbo.turbojpeg"><span class="strong">TJTransform</span></a></li>
+</ul>
+</li>
+</ul>
+</li>
+</ul>
+</li>
+<li type="circle">java.lang.Throwable (implements java.io.Serializable)
+<ul>
+<li type="circle">java.lang.Exception
+<ul>
+<li type="circle">java.io.IOException
+<ul>
+<li type="circle">org.libjpegturbo.turbojpeg.<a href="../../../org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg"><span class="strong">TJException</span></a></li>
+</ul>
+</li>
+</ul>
+</li>
+</ul>
+</li>
+<li type="circle">org.libjpegturbo.turbojpeg.<a href="../../../org/libjpegturbo/turbojpeg/TJ.html" title="class in org.libjpegturbo.turbojpeg"><span class="strong">TJ</span></a></li>
+<li type="circle">org.libjpegturbo.turbojpeg.<a href="../../../org/libjpegturbo/turbojpeg/TJCompressor.html" title="class in org.libjpegturbo.turbojpeg"><span class="strong">TJCompressor</span></a> (implements java.io.Closeable)</li>
+<li type="circle">org.libjpegturbo.turbojpeg.<a href="../../../org/libjpegturbo/turbojpeg/TJDecompressor.html" title="class in org.libjpegturbo.turbojpeg"><span class="strong">TJDecompressor</span></a> (implements java.io.Closeable)
+<ul>
+<li type="circle">org.libjpegturbo.turbojpeg.<a href="../../../org/libjpegturbo/turbojpeg/TJTransformer.html" title="class in org.libjpegturbo.turbojpeg"><span class="strong">TJTransformer</span></a></li>
+</ul>
+</li>
+<li type="circle">org.libjpegturbo.turbojpeg.<a href="../../../org/libjpegturbo/turbojpeg/TJScalingFactor.html" title="class in org.libjpegturbo.turbojpeg"><span class="strong">TJScalingFactor</span></a></li>
+<li type="circle">org.libjpegturbo.turbojpeg.<a href="../../../org/libjpegturbo/turbojpeg/YUVImage.html" title="class in org.libjpegturbo.turbojpeg"><span class="strong">YUVImage</span></a></li>
+</ul>
+</li>
+</ul>
+<h2 title="Interface Hierarchy">Interface Hierarchy</h2>
+<ul>
+<li type="circle">org.libjpegturbo.turbojpeg.<a href="../../../org/libjpegturbo/turbojpeg/TJCustomFilter.html" title="interface in org.libjpegturbo.turbojpeg"><span class="strong">TJCustomFilter</span></a></li>
+</ul>
+</div>
+<!-- ======= START OF BOTTOM NAVBAR ====== -->
+<div class="bottomNav"><a name="navbar_bottom">
+<!--   -->
+</a><a href="#skip-navbar_bottom" title="Skip navigation links"></a><a name="navbar_bottom_firstrow">
+<!--   -->
+</a>
+<ul class="navList" title="Navigation">
+<li><a href="../../../org/libjpegturbo/turbojpeg/package-summary.html">Package</a></li>
+<li>Class</li>
+<li class="navBarCell1Rev">Tree</li>
+<li><a href="../../../deprecated-list.html">Deprecated</a></li>
+<li><a href="../../../index-all.html">Index</a></li>
+<li><a href="../../../help-doc.html">Help</a></li>
+</ul>
+</div>
+<div class="subNav">
+<ul class="navList">
+<li>Prev</li>
+<li>Next</li>
+</ul>
+<ul class="navList">
+<li><a href="../../../index.html?org/libjpegturbo/turbojpeg/package-tree.html" target="_top">Frames</a></li>
+<li><a href="package-tree.html" target="_top">No Frames</a></li>
+</ul>
+<ul class="navList" id="allclasses_navbar_bottom">
+<li><a href="../../../allclasses-noframe.html">All Classes</a></li>
+</ul>
+<div>
+<script type="text/javascript"><!--
+  allClassesLink = document.getElementById("allclasses_navbar_bottom");
+  if(window==top) {
+    allClassesLink.style.display = "block";
+  }
+  else {
+    allClassesLink.style.display = "none";
+  }
+  //-->
+</script>
+</div>
+<a name="skip-navbar_bottom">
+<!--   -->
+</a></div>
+<!-- ======== END OF BOTTOM NAVBAR ======= -->
+</body>
+</html>
diff --git a/3rdparty/libjpeg/src/java/doc/overview-tree.html b/3rdparty/libjpeg/src/java/doc/overview-tree.html
new file mode 100644
index 00000000..b6599954
--- /dev/null
+++ b/3rdparty/libjpeg/src/java/doc/overview-tree.html
@@ -0,0 +1,164 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!-- NewPage -->
+<html lang="en">
+<head>
+<title>Class Hierarchy</title>
+<link rel="stylesheet" type="text/css" href="stylesheet.css" title="Style">
+</head>
+<body>
+<script type="text/javascript"><!--
+    try {
+        if (location.href.indexOf('is-external=true') == -1) {
+            parent.document.title="Class Hierarchy";
+        }
+    }
+    catch(err) {
+    }
+//-->
+</script>
+<noscript>
+<div>JavaScript is disabled on your browser.</div>
+</noscript>
+<!-- ========= START OF TOP NAVBAR ======= -->
+<div class="topNav"><a name="navbar_top">
+<!--   -->
+</a><a href="#skip-navbar_top" title="Skip navigation links"></a><a name="navbar_top_firstrow">
+<!--   -->
+</a>
+<ul class="navList" title="Navigation">
+<li><a href="org/libjpegturbo/turbojpeg/package-summary.html">Package</a></li>
+<li>Class</li>
+<li class="navBarCell1Rev">Tree</li>
+<li><a href="deprecated-list.html">Deprecated</a></li>
+<li><a href="index-all.html">Index</a></li>
+<li><a href="help-doc.html">Help</a></li>
+</ul>
+</div>
+<div class="subNav">
+<ul class="navList">
+<li>Prev</li>
+<li>Next</li>
+</ul>
+<ul class="navList">
+<li><a href="index.html?overview-tree.html" target="_top">Frames</a></li>
+<li><a href="overview-tree.html" target="_top">No Frames</a></li>
+</ul>
+<ul class="navList" id="allclasses_navbar_top">
+<li><a href="allclasses-noframe.html">All Classes</a></li>
+</ul>
+<div>
+<script type="text/javascript"><!--
+  allClassesLink = document.getElementById("allclasses_navbar_top");
+  if(window==top) {
+    allClassesLink.style.display = "block";
+  }
+  else {
+    allClassesLink.style.display = "none";
+  }
+  //-->
+</script>
+</div>
+<a name="skip-navbar_top">
+<!--   -->
+</a></div>
+<!-- ========= END OF TOP NAVBAR ========= -->
+<div class="header">
+<h1 class="title">Hierarchy For All Packages</h1>
+<span class="strong">Package Hierarchies:</span>
+<ul class="horizontal">
+<li><a href="org/libjpegturbo/turbojpeg/package-tree.html">org.libjpegturbo.turbojpeg</a></li>
+</ul>
+</div>
+<div class="contentContainer">
+<h2 title="Class Hierarchy">Class Hierarchy</h2>
+<ul>
+<li type="circle">java.lang.Object
+<ul>
+<li type="circle">java.awt.geom.RectangularShape (implements java.lang.Cloneable, java.awt.Shape)
+<ul>
+<li type="circle">java.awt.geom.Rectangle2D
+<ul>
+<li type="circle">java.awt.Rectangle (implements java.io.Serializable, java.awt.Shape)
+<ul>
+<li type="circle">org.libjpegturbo.turbojpeg.<a href="org/libjpegturbo/turbojpeg/TJTransform.html" title="class in org.libjpegturbo.turbojpeg"><span class="strong">TJTransform</span></a></li>
+</ul>
+</li>
+</ul>
+</li>
+</ul>
+</li>
+<li type="circle">java.lang.Throwable (implements java.io.Serializable)
+<ul>
+<li type="circle">java.lang.Exception
+<ul>
+<li type="circle">java.io.IOException
+<ul>
+<li type="circle">org.libjpegturbo.turbojpeg.<a href="org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg"><span class="strong">TJException</span></a></li>
+</ul>
+</li>
+</ul>
+</li>
+</ul>
+</li>
+<li type="circle">org.libjpegturbo.turbojpeg.<a href="org/libjpegturbo/turbojpeg/TJ.html" title="class in org.libjpegturbo.turbojpeg"><span class="strong">TJ</span></a></li>
+<li type="circle">org.libjpegturbo.turbojpeg.<a href="org/libjpegturbo/turbojpeg/TJCompressor.html" title="class in org.libjpegturbo.turbojpeg"><span class="strong">TJCompressor</span></a> (implements java.io.Closeable)</li>
+<li type="circle">org.libjpegturbo.turbojpeg.<a href="org/libjpegturbo/turbojpeg/TJDecompressor.html" title="class in org.libjpegturbo.turbojpeg"><span class="strong">TJDecompressor</span></a> (implements java.io.Closeable)
+<ul>
+<li type="circle">org.libjpegturbo.turbojpeg.<a href="org/libjpegturbo/turbojpeg/TJTransformer.html" title="class in org.libjpegturbo.turbojpeg"><span class="strong">TJTransformer</span></a></li>
+</ul>
+</li>
+<li type="circle">org.libjpegturbo.turbojpeg.<a href="org/libjpegturbo/turbojpeg/TJScalingFactor.html" title="class in org.libjpegturbo.turbojpeg"><span class="strong">TJScalingFactor</span></a></li>
+<li type="circle">org.libjpegturbo.turbojpeg.<a href="org/libjpegturbo/turbojpeg/YUVImage.html" title="class in org.libjpegturbo.turbojpeg"><span class="strong">YUVImage</span></a></li>
+</ul>
+</li>
+</ul>
+<h2 title="Interface Hierarchy">Interface Hierarchy</h2>
+<ul>
+<li type="circle">org.libjpegturbo.turbojpeg.<a href="org/libjpegturbo/turbojpeg/TJCustomFilter.html" title="interface in org.libjpegturbo.turbojpeg"><span class="strong">TJCustomFilter</span></a></li>
+</ul>
+</div>
+<!-- ======= START OF BOTTOM NAVBAR ====== -->
+<div class="bottomNav"><a name="navbar_bottom">
+<!--   -->
+</a><a href="#skip-navbar_bottom" title="Skip navigation links"></a><a name="navbar_bottom_firstrow">
+<!--   -->
+</a>
+<ul class="navList" title="Navigation">
+<li><a href="org/libjpegturbo/turbojpeg/package-summary.html">Package</a></li>
+<li>Class</li>
+<li class="navBarCell1Rev">Tree</li>
+<li><a href="deprecated-list.html">Deprecated</a></li>
+<li><a href="index-all.html">Index</a></li>
+<li><a href="help-doc.html">Help</a></li>
+</ul>
+</div>
+<div class="subNav">
+<ul class="navList">
+<li>Prev</li>
+<li>Next</li>
+</ul>
+<ul class="navList">
+<li><a href="index.html?overview-tree.html" target="_top">Frames</a></li>
+<li><a href="overview-tree.html" target="_top">No Frames</a></li>
+</ul>
+<ul class="navList" id="allclasses_navbar_bottom">
+<li><a href="allclasses-noframe.html">All Classes</a></li>
+</ul>
+<div>
+<script type="text/javascript"><!--
+  allClassesLink = document.getElementById("allclasses_navbar_bottom");
+  if(window==top) {
+    allClassesLink.style.display = "block";
+  }
+  else {
+    allClassesLink.style.display = "none";
+  }
+  //-->
+</script>
+</div>
+<a name="skip-navbar_bottom">
+<!--   -->
+</a></div>
+<!-- ======== END OF BOTTOM NAVBAR ======= -->
+</body>
+</html>
diff --git a/3rdparty/libjpeg/src/java/doc/package-list b/3rdparty/libjpeg/src/java/doc/package-list
new file mode 100644
index 00000000..918d9368
--- /dev/null
+++ b/3rdparty/libjpeg/src/java/doc/package-list
@@ -0,0 +1 @@
+org.libjpegturbo.turbojpeg
diff --git a/3rdparty/libjpeg/src/java/doc/resources/background.gif b/3rdparty/libjpeg/src/java/doc/resources/background.gif
new file mode 100644
index 00000000..f471940f
Binary files /dev/null and b/3rdparty/libjpeg/src/java/doc/resources/background.gif differ
diff --git a/3rdparty/libjpeg/src/java/doc/resources/tab.gif b/3rdparty/libjpeg/src/java/doc/resources/tab.gif
new file mode 100644
index 00000000..1a73a83b
Binary files /dev/null and b/3rdparty/libjpeg/src/java/doc/resources/tab.gif differ
diff --git a/3rdparty/libjpeg/src/java/doc/resources/titlebar.gif b/3rdparty/libjpeg/src/java/doc/resources/titlebar.gif
new file mode 100644
index 00000000..17443b3e
Binary files /dev/null and b/3rdparty/libjpeg/src/java/doc/resources/titlebar.gif differ
diff --git a/3rdparty/libjpeg/src/java/doc/resources/titlebar_end.gif b/3rdparty/libjpeg/src/java/doc/resources/titlebar_end.gif
new file mode 100644
index 00000000..3ad78d46
Binary files /dev/null and b/3rdparty/libjpeg/src/java/doc/resources/titlebar_end.gif differ
diff --git a/3rdparty/libjpeg/src/java/doc/script.js b/3rdparty/libjpeg/src/java/doc/script.js
new file mode 100644
index 00000000..b3463569
--- /dev/null
+++ b/3rdparty/libjpeg/src/java/doc/script.js
@@ -0,0 +1,30 @@
+function show(type)
+{
+    count = 0;
+    for (var key in methods) {
+        var row = document.getElementById(key);
+        if ((methods[key] &  type) != 0) {
+            row.style.display = '';
+            row.className = (count++ % 2) ? rowColor : altColor;
+        }
+        else
+            row.style.display = 'none';
+    }
+    updateTabs(type);
+}
+
+function updateTabs(type)
+{
+    for (var value in tabs) {
+        var sNode = document.getElementById(tabs[value][0]);
+        var spanNode = sNode.firstChild;
+        if (value == type) {
+            sNode.className = activeTableTab;
+            spanNode.innerHTML = tabs[value][1];
+        }
+        else {
+            sNode.className = tableTab;
+            spanNode.innerHTML = "<a href=\"javascript:show("+ value + ");\">" + tabs[value][1] + "</a>";
+        }
+    }
+}
diff --git a/3rdparty/libjpeg/src/java/doc/serialized-form.html b/3rdparty/libjpeg/src/java/doc/serialized-form.html
new file mode 100644
index 00000000..45bbc862
--- /dev/null
+++ b/3rdparty/libjpeg/src/java/doc/serialized-form.html
@@ -0,0 +1,176 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!-- NewPage -->
+<html lang="en">
+<head>
+<title>Serialized Form</title>
+<link rel="stylesheet" type="text/css" href="stylesheet.css" title="Style">
+</head>
+<body>
+<script type="text/javascript"><!--
+    try {
+        if (location.href.indexOf('is-external=true') == -1) {
+            parent.document.title="Serialized Form";
+        }
+    }
+    catch(err) {
+    }
+//-->
+</script>
+<noscript>
+<div>JavaScript is disabled on your browser.</div>
+</noscript>
+<!-- ========= START OF TOP NAVBAR ======= -->
+<div class="topNav"><a name="navbar_top">
+<!--   -->
+</a><a href="#skip-navbar_top" title="Skip navigation links"></a><a name="navbar_top_firstrow">
+<!--   -->
+</a>
+<ul class="navList" title="Navigation">
+<li><a href="org/libjpegturbo/turbojpeg/package-summary.html">Package</a></li>
+<li>Class</li>
+<li><a href="org/libjpegturbo/turbojpeg/package-tree.html">Tree</a></li>
+<li><a href="deprecated-list.html">Deprecated</a></li>
+<li><a href="index-all.html">Index</a></li>
+<li><a href="help-doc.html">Help</a></li>
+</ul>
+</div>
+<div class="subNav">
+<ul class="navList">
+<li>Prev</li>
+<li>Next</li>
+</ul>
+<ul class="navList">
+<li><a href="index.html?serialized-form.html" target="_top">Frames</a></li>
+<li><a href="serialized-form.html" target="_top">No Frames</a></li>
+</ul>
+<ul class="navList" id="allclasses_navbar_top">
+<li><a href="allclasses-noframe.html">All Classes</a></li>
+</ul>
+<div>
+<script type="text/javascript"><!--
+  allClassesLink = document.getElementById("allclasses_navbar_top");
+  if(window==top) {
+    allClassesLink.style.display = "block";
+  }
+  else {
+    allClassesLink.style.display = "none";
+  }
+  //-->
+</script>
+</div>
+<a name="skip-navbar_top">
+<!--   -->
+</a></div>
+<!-- ========= END OF TOP NAVBAR ========= -->
+<div class="header">
+<h1 title="Serialized Form" class="title">Serialized Form</h1>
+</div>
+<div class="serializedFormContainer">
+<ul class="blockList">
+<li class="blockList">
+<h2 title="Package">Package&nbsp;org.libjpegturbo.turbojpeg</h2>
+<ul class="blockList">
+<li class="blockList"><a name="org.libjpegturbo.turbojpeg.TJException">
+<!--   -->
+</a>
+<h3>Class <a href="org/libjpegturbo/turbojpeg/TJException.html" title="class in org.libjpegturbo.turbojpeg">org.libjpegturbo.turbojpeg.TJException</a> extends java.io.IOException implements Serializable</h3>
+<dl class="nameValue">
+<dt>serialVersionUID:</dt>
+<dd>1L</dd>
+</dl>
+<ul class="blockList">
+<li class="blockList"><a name="serializedForm">
+<!--   -->
+</a>
+<h3>Serialized Fields</h3>
+<ul class="blockList">
+<li class="blockListLast">
+<h4>errorCode</h4>
+<pre>int errorCode</pre>
+</li>
+</ul>
+</li>
+</ul>
+</li>
+<li class="blockList"><a name="org.libjpegturbo.turbojpeg.TJTransform">
+<!--   -->
+</a>
+<h3>Class <a href="org/libjpegturbo/turbojpeg/TJTransform.html" title="class in org.libjpegturbo.turbojpeg">org.libjpegturbo.turbojpeg.TJTransform</a> extends java.awt.Rectangle implements Serializable</h3>
+<dl class="nameValue">
+<dt>serialVersionUID:</dt>
+<dd>-127367705761430371L</dd>
+</dl>
+<ul class="blockList">
+<li class="blockList"><a name="serializedForm">
+<!--   -->
+</a>
+<h3>Serialized Fields</h3>
+<ul class="blockList">
+<li class="blockList">
+<h4>op</h4>
+<pre>int op</pre>
+<div class="block">Transform operation (one of <code>OP_*</code>)</div>
+</li>
+<li class="blockList">
+<h4>options</h4>
+<pre>int options</pre>
+<div class="block">Transform options (bitwise OR of one or more of <code>OPT_*</code>)</div>
+</li>
+<li class="blockListLast">
+<h4>cf</h4>
+<pre><a href="org/libjpegturbo/turbojpeg/TJCustomFilter.html" title="interface in org.libjpegturbo.turbojpeg">TJCustomFilter</a> cf</pre>
+<div class="block">Custom filter instance</div>
+</li>
+</ul>
+</li>
+</ul>
+</li>
+</ul>
+</li>
+</ul>
+</div>
+<!-- ======= START OF BOTTOM NAVBAR ====== -->
+<div class="bottomNav"><a name="navbar_bottom">
+<!--   -->
+</a><a href="#skip-navbar_bottom" title="Skip navigation links"></a><a name="navbar_bottom_firstrow">
+<!--   -->
+</a>
+<ul class="navList" title="Navigation">
+<li><a href="org/libjpegturbo/turbojpeg/package-summary.html">Package</a></li>
+<li>Class</li>
+<li><a href="org/libjpegturbo/turbojpeg/package-tree.html">Tree</a></li>
+<li><a href="deprecated-list.html">Deprecated</a></li>
+<li><a href="index-all.html">Index</a></li>
+<li><a href="help-doc.html">Help</a></li>
+</ul>
+</div>
+<div class="subNav">
+<ul class="navList">
+<li>Prev</li>
+<li>Next</li>
+</ul>
+<ul class="navList">
+<li><a href="index.html?serialized-form.html" target="_top">Frames</a></li>
+<li><a href="serialized-form.html" target="_top">No Frames</a></li>
+</ul>
+<ul class="navList" id="allclasses_navbar_bottom">
+<li><a href="allclasses-noframe.html">All Classes</a></li>
+</ul>
+<div>
+<script type="text/javascript"><!--
+  allClassesLink = document.getElementById("allclasses_navbar_bottom");
+  if(window==top) {
+    allClassesLink.style.display = "block";
+  }
+  else {
+    allClassesLink.style.display = "none";
+  }
+  //-->
+</script>
+</div>
+<a name="skip-navbar_bottom">
+<!--   -->
+</a></div>
+<!-- ======== END OF BOTTOM NAVBAR ======= -->
+</body>
+</html>
diff --git a/3rdparty/libjpeg/src/java/doc/stylesheet.css b/3rdparty/libjpeg/src/java/doc/stylesheet.css
new file mode 100644
index 00000000..0aeaa97f
--- /dev/null
+++ b/3rdparty/libjpeg/src/java/doc/stylesheet.css
@@ -0,0 +1,474 @@
+/* Javadoc style sheet */
+/*
+Overall document style
+*/
+body {
+    background-color:#ffffff;
+    color:#353833;
+    font-family:Arial, Helvetica, sans-serif;
+    font-size:76%;
+    margin:0;
+}
+a:link, a:visited {
+    text-decoration:none;
+    color:#4c6b87;
+}
+a:hover, a:focus {
+    text-decoration:none;
+    color:#bb7a2a;
+}
+a:active {
+    text-decoration:none;
+    color:#4c6b87;
+}
+a[name] {
+    color:#353833;
+}
+a[name]:hover {
+    text-decoration:none;
+    color:#353833;
+}
+pre {
+    font-size:1.3em;
+}
+h1 {
+    font-size:1.8em;
+}
+h2 {
+    font-size:1.5em;
+}
+h3 {
+    font-size:1.4em;
+}
+h4 {
+    font-size:1.3em;
+}
+h5 {
+    font-size:1.2em;
+}
+h6 {
+    font-size:1.1em;
+}
+ul {
+    list-style-type:disc;
+}
+code, tt {
+    font-size:1.2em;
+}
+dt code {
+    font-size:1.2em;
+}
+table tr td dt code {
+    font-size:1.2em;
+    vertical-align:top;
+}
+sup {
+    font-size:.6em;
+}
+/*
+Document title and Copyright styles
+*/
+.clear {
+    clear:both;
+    height:0px;
+    overflow:hidden;
+}
+.aboutLanguage {
+    float:right;
+    padding:0px 21px;
+    font-size:.8em;
+    z-index:200;
+    margin-top:-7px;
+}
+.legalCopy {
+    margin-left:.5em;
+}
+.bar a, .bar a:link, .bar a:visited, .bar a:active {
+    color:#FFFFFF;
+    text-decoration:none;
+}
+.bar a:hover, .bar a:focus {
+    color:#bb7a2a;
+}
+.tab {
+    background-color:#0066FF;
+    background-image:url(resources/titlebar.gif);
+    background-position:left top;
+    background-repeat:no-repeat;
+    color:#ffffff;
+    padding:8px;
+    width:5em;
+    font-weight:bold;
+}
+/*
+Navigation bar styles
+*/
+.bar {
+    background-image:url(resources/background.gif);
+    background-repeat:repeat-x;
+    color:#FFFFFF;
+    padding:.8em .5em .4em .8em;
+    height:auto;/*height:1.8em;*/
+    font-size:1em;
+    margin:0;
+}
+.topNav {
+    background-image:url(resources/background.gif);
+    background-repeat:repeat-x;
+    color:#FFFFFF;
+    float:left;
+    padding:0;
+    width:100%;
+    clear:right;
+    height:2.8em;
+    padding-top:10px;
+    overflow:hidden;
+}
+.bottomNav {
+    margin-top:10px;
+    background-image:url(resources/background.gif);
+    background-repeat:repeat-x;
+    color:#FFFFFF;
+    float:left;
+    padding:0;
+    width:100%;
+    clear:right;
+    height:2.8em;
+    padding-top:10px;
+    overflow:hidden;
+}
+.subNav {
+    background-color:#dee3e9;
+    border-bottom:1px solid #9eadc0;
+    float:left;
+    width:100%;
+    overflow:hidden;
+}
+.subNav div {
+    clear:left;
+    float:left;
+    padding:0 0 5px 6px;
+}
+ul.navList, ul.subNavList {
+    float:left;
+    margin:0 25px 0 0;
+    padding:0;
+}
+ul.navList li{
+    list-style:none;
+    float:left;
+    padding:3px 6px;
+}
+ul.subNavList li{
+    list-style:none;
+    float:left;
+    font-size:90%;
+}
+.topNav a:link, .topNav a:active, .topNav a:visited, .bottomNav a:link, .bottomNav a:active, .bottomNav a:visited {
+    color:#FFFFFF;
+    text-decoration:none;
+}
+.topNav a:hover, .bottomNav a:hover {
+    text-decoration:none;
+    color:#bb7a2a;
+}
+.navBarCell1Rev {
+    background-image:url(resources/tab.gif);
+    background-color:#a88834;
+    color:#FFFFFF;
+    margin: auto 5px;
+    border:1px solid #c9aa44;
+}
+/*
+Page header and footer styles
+*/
+.header, .footer {
+    clear:both;
+    margin:0 20px;
+    padding:5px 0 0 0;
+}
+.indexHeader {
+    margin:10px;
+    position:relative;
+}
+.indexHeader h1 {
+    font-size:1.3em;
+}
+.title {
+    color:#2c4557;
+    margin:10px 0;
+}
+.subTitle {
+    margin:5px 0 0 0;
+}
+.header ul {
+    margin:0 0 25px 0;
+    padding:0;
+}
+.footer ul {
+    margin:20px 0 5px 0;
+}
+.header ul li, .footer ul li {
+    list-style:none;
+    font-size:1.2em;
+}
+/*
+Heading styles
+*/
+div.details ul.blockList ul.blockList ul.blockList li.blockList h4, div.details ul.blockList ul.blockList ul.blockListLast li.blockList h4 {
+    background-color:#dee3e9;
+    border-top:1px solid #9eadc0;
+    border-bottom:1px solid #9eadc0;
+    margin:0 0 6px -8px;
+    padding:2px 5px;
+}
+ul.blockList ul.blockList ul.blockList li.blockList h3 {
+    background-color:#dee3e9;
+    border-top:1px solid #9eadc0;
+    border-bottom:1px solid #9eadc0;
+    margin:0 0 6px -8px;
+    padding:2px 5px;
+}
+ul.blockList ul.blockList li.blockList h3 {
+    padding:0;
+    margin:15px 0;
+}
+ul.blockList li.blockList h2 {
+    padding:0px 0 20px 0;
+}
+/*
+Page layout container styles
+*/
+.contentContainer, .sourceContainer, .classUseContainer, .serializedFormContainer, .constantValuesContainer {
+    clear:both;
+    padding:10px 20px;
+    position:relative;
+}
+.indexContainer {
+    margin:10px;
+    position:relative;
+    font-size:1.0em;
+}
+.indexContainer h2 {
+    font-size:1.1em;
+    padding:0 0 3px 0;
+}
+.indexContainer ul {
+    margin:0;
+    padding:0;
+}
+.indexContainer ul li {
+    list-style:none;
+}
+.contentContainer .description dl dt, .contentContainer .details dl dt, .serializedFormContainer dl dt {
+    font-size:1.1em;
+    font-weight:bold;
+    margin:10px 0 0 0;
+    color:#4E4E4E;
+}
+.contentContainer .description dl dd, .contentContainer .details dl dd, .serializedFormContainer dl dd {
+    margin:10px 0 10px 20px;
+}
+.serializedFormContainer dl.nameValue dt {
+    margin-left:1px;
+    font-size:1.1em;
+    display:inline;
+    font-weight:bold;
+}
+.serializedFormContainer dl.nameValue dd {
+    margin:0 0 0 1px;
+    font-size:1.1em;
+    display:inline;
+}
+/*
+List styles
+*/
+ul.horizontal li {
+    display:inline;
+    font-size:0.9em;
+}
+ul.inheritance {
+    margin:0;
+    padding:0;
+}
+ul.inheritance li {
+    display:inline;
+    list-style:none;
+}
+ul.inheritance li ul.inheritance {
+    margin-left:15px;
+    padding-left:15px;
+    padding-top:1px;
+}
+ul.blockList, ul.blockListLast {
+    margin:10px 0 10px 0;
+    padding:0;
+}
+ul.blockList li.blockList, ul.blockListLast li.blockList {
+    list-style:none;
+    margin-bottom:25px;
+}
+ul.blockList ul.blockList li.blockList, ul.blockList ul.blockListLast li.blockList {
+    padding:0px 20px 5px 10px;
+    border:1px solid #9eadc0;
+    background-color:#f9f9f9;
+}
+ul.blockList ul.blockList ul.blockList li.blockList, ul.blockList ul.blockList ul.blockListLast li.blockList {
+    padding:0 0 5px 8px;
+    background-color:#ffffff;
+    border:1px solid #9eadc0;
+    border-top:none;
+}
+ul.blockList ul.blockList ul.blockList ul.blockList li.blockList {
+    margin-left:0;
+    padding-left:0;
+    padding-bottom:15px;
+    border:none;
+    border-bottom:1px solid #9eadc0;
+}
+ul.blockList ul.blockList ul.blockList ul.blockList li.blockListLast {
+    list-style:none;
+    border-bottom:none;
+    padding-bottom:0;
+}
+table tr td dl, table tr td dl dt, table tr td dl dd {
+    margin-top:0;
+    margin-bottom:1px;
+}
+/*
+Table styles
+*/
+.contentContainer table, .classUseContainer table, .constantValuesContainer table {
+    border-bottom:1px solid #9eadc0;
+    width:100%;
+}
+.contentContainer ul li table, .classUseContainer ul li table, .constantValuesContainer ul li table {
+    width:100%;
+}
+.contentContainer .description table, .contentContainer .details table {
+    border-bottom:none;
+}
+.contentContainer ul li table th.colOne, .contentContainer ul li table th.colFirst, .contentContainer ul li table th.colLast, .classUseContainer ul li table th, .constantValuesContainer ul li table th, .contentContainer ul li table td.colOne, .contentContainer ul li table td.colFirst, .contentContainer ul li table td.colLast, .classUseContainer ul li table td, .constantValuesContainer ul li table td{
+    vertical-align:top;
+    padding-right:20px;
+}
+.contentContainer ul li table th.colLast, .classUseContainer ul li table th.colLast,.constantValuesContainer ul li table th.colLast,
+.contentContainer ul li table td.colLast, .classUseContainer ul li table td.colLast,.constantValuesContainer ul li table td.colLast,
+.contentContainer ul li table th.colOne, .classUseContainer ul li table th.colOne,
+.contentContainer ul li table td.colOne, .classUseContainer ul li table td.colOne {
+    padding-right:3px;
+}
+.overviewSummary caption, .packageSummary caption, .contentContainer ul.blockList li.blockList caption, .summary caption, .classUseContainer caption, .constantValuesContainer caption {
+    position:relative;
+    text-align:left;
+    background-repeat:no-repeat;
+    color:#FFFFFF;
+    font-weight:bold;
+    clear:none;
+    overflow:hidden;
+    padding:0px;
+    margin:0px;
+}
+caption a:link, caption a:hover, caption a:active, caption a:visited {
+    color:#FFFFFF;
+}
+.overviewSummary caption span, .packageSummary caption span, .contentContainer ul.blockList li.blockList caption span, .summary caption span, .classUseContainer caption span, .constantValuesContainer caption span {
+    white-space:nowrap;
+    padding-top:8px;
+    padding-left:8px;
+    display:block;
+    float:left;
+    background-image:url(resources/titlebar.gif);
+    height:18px;
+}
+.overviewSummary .tabEnd, .packageSummary .tabEnd, .contentContainer ul.blockList li.blockList .tabEnd, .summary .tabEnd, .classUseContainer .tabEnd, .constantValuesContainer .tabEnd {
+    width:10px;
+    background-image:url(resources/titlebar_end.gif);
+    background-repeat:no-repeat;
+    background-position:top right;
+    position:relative;
+    float:left;
+}
+ul.blockList ul.blockList li.blockList table {
+    margin:0 0 12px 0px;
+    width:100%;
+}
+.tableSubHeadingColor {
+    background-color: #EEEEFF;
+}
+.altColor {
+    background-color:#eeeeef;
+}
+.rowColor {
+    background-color:#ffffff;
+}
+.overviewSummary td, .packageSummary td, .contentContainer ul.blockList li.blockList td, .summary td, .classUseContainer td, .constantValuesContainer td {
+    text-align:left;
+    padding:3px 3px 3px 7px;
+}
+th.colFirst, th.colLast, th.colOne, .constantValuesContainer th {
+    background:#dee3e9;
+    border-top:1px solid #9eadc0;
+    border-bottom:1px solid #9eadc0;
+    text-align:left;
+    padding:3px 3px 3px 7px;
+}
+td.colOne a:link, td.colOne a:active, td.colOne a:visited, td.colOne a:hover, td.colFirst a:link, td.colFirst a:active, td.colFirst a:visited, td.colFirst a:hover, td.colLast a:link, td.colLast a:active, td.colLast a:visited, td.colLast a:hover, .constantValuesContainer td a:link, .constantValuesContainer td a:active, .constantValuesContainer td a:visited, .constantValuesContainer td a:hover {
+    font-weight:bold;
+}
+td.colFirst, th.colFirst {
+    border-left:1px solid #9eadc0;
+    white-space:nowrap;
+}
+td.colLast, th.colLast {
+    border-right:1px solid #9eadc0;
+}
+td.colOne, th.colOne {
+    border-right:1px solid #9eadc0;
+    border-left:1px solid #9eadc0;
+}
+table.overviewSummary  {
+    padding:0px;
+    margin-left:0px;
+}
+table.overviewSummary td.colFirst, table.overviewSummary th.colFirst,
+table.overviewSummary td.colOne, table.overviewSummary th.colOne {
+    width:25%;
+    vertical-align:middle;
+}
+table.packageSummary td.colFirst, table.overviewSummary th.colFirst {
+    width:25%;
+    vertical-align:middle;
+}
+/*
+Content styles
+*/
+.description pre {
+    margin-top:0;
+}
+.deprecatedContent {
+    margin:0;
+    padding:10px 0;
+}
+.docSummary {
+    padding:0;
+}
+/*
+Formatting effect styles
+*/
+.sourceLineNo {
+    color:green;
+    padding:0 30px 0 0;
+}
+h1.hidden {
+    visibility:hidden;
+    overflow:hidden;
+    font-size:.9em;
+}
+.block {
+    display:block;
+    margin:3px 0 0 0;
+}
+.strong {
+    font-weight:bold;
+}
diff --git a/3rdparty/libjpeg/src/java/org/libjpegturbo/turbojpeg/TJ.java b/3rdparty/libjpeg/src/java/org/libjpegturbo/turbojpeg/TJ.java
new file mode 100644
index 00000000..63e464b8
--- /dev/null
+++ b/3rdparty/libjpeg/src/java/org/libjpegturbo/turbojpeg/TJ.java
@@ -0,0 +1,586 @@
+/*
+ * Copyright (C)2011-2013, 2017-2018, 2020 D. R. Commander.
+ *                                         All Rights Reserved.
+ * Copyright (C)2015 Viktor Szathmáry.  All Rights Reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright notice,
+ *   this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright notice,
+ *   this list of conditions and the following disclaimer in the documentation
+ *   and/or other materials provided with the distribution.
+ * - Neither the name of the libjpeg-turbo Project nor the names of its
+ *   contributors may be used to endorse or promote products derived from this
+ *   software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE 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 HOLDERS 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.
+ */
+
+package org.libjpegturbo.turbojpeg;
+
+/**
+ * TurboJPEG utility class (cannot be instantiated)
+ */
+public final class TJ {
+
+  private TJ() {}
+
+  /**
+   * The number of chrominance subsampling options
+   */
+  public static final int NUMSAMP   = 6;
+  /**
+   * 4:4:4 chrominance subsampling (no chrominance subsampling).  The JPEG
+   * or YUV image will contain one chrominance component for every pixel in the
+   * source image.
+   */
+  public static final int SAMP_444  = 0;
+  /**
+   * 4:2:2 chrominance subsampling.  The JPEG or YUV image will contain one
+   * chrominance component for every 2x1 block of pixels in the source image.
+   */
+  public static final int SAMP_422  = 1;
+  /**
+   * 4:2:0 chrominance subsampling.  The JPEG or YUV image will contain one
+   * chrominance component for every 2x2 block of pixels in the source image.
+   */
+  public static final int SAMP_420  = 2;
+  /**
+   * Grayscale.  The JPEG or YUV image will contain no chrominance components.
+   */
+  public static final int SAMP_GRAY = 3;
+  /**
+   * 4:4:0 chrominance subsampling.  The JPEG or YUV image will contain one
+   * chrominance component for every 1x2 block of pixels in the source image.
+   * Note that 4:4:0 subsampling is not fully accelerated in libjpeg-turbo.
+   */
+  public static final int SAMP_440  = 4;
+  /**
+   * 4:1:1 chrominance subsampling.  The JPEG or YUV image will contain one
+   * chrominance component for every 4x1 block of pixels in the source image.
+   * JPEG images compressed with 4:1:1 subsampling will be almost exactly the
+   * same size as those compressed with 4:2:0 subsampling, and in the
+   * aggregate, both subsampling methods produce approximately the same
+   * perceptual quality.  However, 4:1:1 is better able to reproduce sharp
+   * horizontal features.  Note that 4:1:1 subsampling is not fully accelerated
+   * in libjpeg-turbo.
+   */
+  public static final int SAMP_411  = 5;
+
+
+  /**
+   * Returns the MCU block width for the given level of chrominance
+   * subsampling.
+   *
+   * @param subsamp the level of chrominance subsampling (one of
+   * <code>SAMP_*</code>)
+   *
+   * @return the MCU block width for the given level of chrominance
+   * subsampling.
+   */
+  public static int getMCUWidth(int subsamp) {
+    checkSubsampling(subsamp);
+    return MCU_WIDTH[subsamp];
+  }
+
+  private static final int[] MCU_WIDTH = {
+    8, 16, 16, 8, 8, 32
+  };
+
+
+  /**
+   * Returns the MCU block height for the given level of chrominance
+   * subsampling.
+   *
+   * @param subsamp the level of chrominance subsampling (one of
+   * <code>SAMP_*</code>)
+   *
+   * @return the MCU block height for the given level of chrominance
+   * subsampling.
+   */
+  public static int getMCUHeight(int subsamp) {
+    checkSubsampling(subsamp);
+    return MCU_HEIGHT[subsamp];
+  }
+
+  private static final int[] MCU_HEIGHT = {
+    8, 8, 16, 8, 16, 8
+  };
+
+
+  /**
+   * The number of pixel formats
+   */
+  public static final int NUMPF   = 12;
+  /**
+   * RGB pixel format.  The red, green, and blue components in the image are
+   * stored in 3-byte pixels in the order R, G, B from lowest to highest byte
+   * address within each pixel.
+   */
+  public static final int PF_RGB  = 0;
+  /**
+   * BGR pixel format.  The red, green, and blue components in the image are
+   * stored in 3-byte pixels in the order B, G, R from lowest to highest byte
+   * address within each pixel.
+   */
+  public static final int PF_BGR  = 1;
+  /**
+   * RGBX pixel format.  The red, green, and blue components in the image are
+   * stored in 4-byte pixels in the order R, G, B from lowest to highest byte
+   * address within each pixel.  The X component is ignored when compressing
+   * and undefined when decompressing.
+   */
+  public static final int PF_RGBX = 2;
+  /**
+   * BGRX pixel format.  The red, green, and blue components in the image are
+   * stored in 4-byte pixels in the order B, G, R from lowest to highest byte
+   * address within each pixel.  The X component is ignored when compressing
+   * and undefined when decompressing.
+   */
+  public static final int PF_BGRX = 3;
+  /**
+   * XBGR pixel format.  The red, green, and blue components in the image are
+   * stored in 4-byte pixels in the order R, G, B from highest to lowest byte
+   * address within each pixel.  The X component is ignored when compressing
+   * and undefined when decompressing.
+   */
+  public static final int PF_XBGR = 4;
+  /**
+   * XRGB pixel format.  The red, green, and blue components in the image are
+   * stored in 4-byte pixels in the order B, G, R from highest to lowest byte
+   * address within each pixel.  The X component is ignored when compressing
+   * and undefined when decompressing.
+   */
+  public static final int PF_XRGB = 5;
+  /**
+   * Grayscale pixel format.  Each 1-byte pixel represents a luminance
+   * (brightness) level from 0 to 255.
+   */
+  public static final int PF_GRAY = 6;
+  /**
+   * RGBA pixel format.  This is the same as {@link #PF_RGBX}, except that when
+   * decompressing, the X byte is guaranteed to be 0xFF, which can be
+   * interpreted as an opaque alpha channel.
+   */
+  public static final int PF_RGBA = 7;
+  /**
+   * BGRA pixel format.  This is the same as {@link #PF_BGRX}, except that when
+   * decompressing, the X byte is guaranteed to be 0xFF, which can be
+   * interpreted as an opaque alpha channel.
+   */
+  public static final int PF_BGRA = 8;
+  /**
+   * ABGR pixel format.  This is the same as {@link #PF_XBGR}, except that when
+   * decompressing, the X byte is guaranteed to be 0xFF, which can be
+   * interpreted as an opaque alpha channel.
+   */
+  public static final int PF_ABGR = 9;
+  /**
+   * ARGB pixel format.  This is the same as {@link #PF_XRGB}, except that when
+   * decompressing, the X byte is guaranteed to be 0xFF, which can be
+   * interpreted as an opaque alpha channel.
+   */
+  public static final int PF_ARGB = 10;
+  /**
+   * CMYK pixel format.  Unlike RGB, which is an additive color model used
+   * primarily for display, CMYK (Cyan/Magenta/Yellow/Key) is a subtractive
+   * color model used primarily for printing.  In the CMYK color model, the
+   * value of each color component typically corresponds to an amount of cyan,
+   * magenta, yellow, or black ink that is applied to a white background.  In
+   * order to convert between CMYK and RGB, it is necessary to use a color
+   * management system (CMS.)  A CMS will attempt to map colors within the
+   * printer's gamut to perceptually similar colors in the display's gamut and
+   * vice versa, but the mapping is typically not 1:1 or reversible, nor can it
+   * be defined with a simple formula.  Thus, such a conversion is out of scope
+   * for a codec library.  However, the TurboJPEG API allows for compressing
+   * CMYK pixels into a YCCK JPEG image (see {@link #CS_YCCK}) and
+   * decompressing YCCK JPEG images into CMYK pixels.
+   */
+  public static final int PF_CMYK = 11;
+
+
+  /**
+   * Returns the pixel size (in bytes) for the given pixel format.
+   *
+   * @param pixelFormat the pixel format (one of <code>PF_*</code>)
+   *
+   * @return the pixel size (in bytes) for the given pixel format.
+   */
+  public static int getPixelSize(int pixelFormat) {
+    checkPixelFormat(pixelFormat);
+    return PIXEL_SIZE[pixelFormat];
+  }
+
+  private static final int[] PIXEL_SIZE = {
+    3, 3, 4, 4, 4, 4, 1, 4, 4, 4, 4, 4
+  };
+
+
+  /**
+   * For the given pixel format, returns the number of bytes that the red
+   * component is offset from the start of the pixel.  For instance, if a pixel
+   * of format <code>TJ.PF_BGRX</code> is stored in <code>char pixel[]</code>,
+   * then the red component will be
+   * <code>pixel[TJ.getRedOffset(TJ.PF_BGRX)]</code>.
+   *
+   * @param pixelFormat the pixel format (one of <code>PF_*</code>)
+   *
+   * @return the red offset for the given pixel format, or -1 if the pixel
+   * format does not have a red component.
+   */
+  public static int getRedOffset(int pixelFormat) {
+    checkPixelFormat(pixelFormat);
+    return RED_OFFSET[pixelFormat];
+  }
+
+  private static final int[] RED_OFFSET = {
+    0, 2, 0, 2, 3, 1, -1, 0, 2, 3, 1, -1
+  };
+
+
+  /**
+   * For the given pixel format, returns the number of bytes that the green
+   * component is offset from the start of the pixel.  For instance, if a pixel
+   * of format <code>TJ.PF_BGRX</code> is stored in <code>char pixel[]</code>,
+   * then the green component will be
+   * <code>pixel[TJ.getGreenOffset(TJ.PF_BGRX)]</code>.
+   *
+   * @param pixelFormat the pixel format (one of <code>PF_*</code>)
+   *
+   * @return the green offset for the given pixel format, or -1 if the pixel
+   * format does not have a green component.
+   */
+  public static int getGreenOffset(int pixelFormat) {
+    checkPixelFormat(pixelFormat);
+    return GREEN_OFFSET[pixelFormat];
+  }
+
+  private static final int[] GREEN_OFFSET = {
+    1, 1, 1, 1, 2, 2, -1, 1, 1, 2, 2, -1
+  };
+
+
+  /**
+   * For the given pixel format, returns the number of bytes that the blue
+   * component is offset from the start of the pixel.  For instance, if a pixel
+   * of format <code>TJ.PF_BGRX</code> is stored in <code>char pixel[]</code>,
+   * then the blue component will be
+   * <code>pixel[TJ.getBlueOffset(TJ.PF_BGRX)]</code>.
+   *
+   * @param pixelFormat the pixel format (one of <code>PF_*</code>)
+   *
+   * @return the blue offset for the given pixel format, or -1 if the pixel
+   * format does not have a blue component.
+   */
+  public static int getBlueOffset(int pixelFormat) {
+    checkPixelFormat(pixelFormat);
+    return BLUE_OFFSET[pixelFormat];
+  }
+
+  private static final int[] BLUE_OFFSET = {
+    2, 0, 2, 0, 1, 3, -1, 2, 0, 1, 3, -1
+  };
+
+
+  /**
+   * For the given pixel format, returns the number of bytes that the alpha
+   * component is offset from the start of the pixel.  For instance, if a pixel
+   * of format <code>TJ.PF_BGRA</code> is stored in <code>char pixel[]</code>,
+   * then the alpha component will be
+   * <code>pixel[TJ.getAlphaOffset(TJ.PF_BGRA)]</code>.
+   *
+   * @param pixelFormat the pixel format (one of <code>PF_*</code>)
+   *
+   * @return the alpha offset for the given pixel format, or -1 if the pixel
+   * format does not have a alpha component.
+   */
+  public static int getAlphaOffset(int pixelFormat) {
+    checkPixelFormat(pixelFormat);
+    return ALPHA_OFFSET[pixelFormat];
+  }
+
+  private static final int[] ALPHA_OFFSET = {
+    -1, -1, -1, -1, -1, -1, -1, 3, 3, 0, 0, -1
+  };
+
+
+  /**
+   * The number of JPEG colorspaces
+   */
+  public static final int NUMCS = 5;
+  /**
+   * RGB colorspace.  When compressing the JPEG image, the R, G, and B
+   * components in the source image are reordered into image planes, but no
+   * colorspace conversion or subsampling is performed.  RGB JPEG images can be
+   * decompressed to any of the extended RGB pixel formats or grayscale, but
+   * they cannot be decompressed to YUV images.
+   */
+  public static final int CS_RGB = 0;
+  /**
+   * YCbCr colorspace.  YCbCr is not an absolute colorspace but rather a
+   * mathematical transformation of RGB designed solely for storage and
+   * transmission.  YCbCr images must be converted to RGB before they can
+   * actually be displayed.  In the YCbCr colorspace, the Y (luminance)
+   * component represents the black &amp; white portion of the original image,
+   * and the Cb and Cr (chrominance) components represent the color portion of
+   * the original image.  Originally, the analog equivalent of this
+   * transformation allowed the same signal to drive both black &amp; white and
+   * color televisions, but JPEG images use YCbCr primarily because it allows
+   * the color data to be optionally subsampled for the purposes of reducing
+   * bandwidth or disk space.  YCbCr is the most common JPEG colorspace, and
+   * YCbCr JPEG images can be compressed from and decompressed to any of the
+   * extended RGB pixel formats or grayscale, or they can be decompressed to
+   * YUV planar images.
+   */
+  @SuppressWarnings("checkstyle:ConstantName")
+  public static final int CS_YCbCr = 1;
+  /**
+   * Grayscale colorspace.  The JPEG image retains only the luminance data (Y
+   * component), and any color data from the source image is discarded.
+   * Grayscale JPEG images can be compressed from and decompressed to any of
+   * the extended RGB pixel formats or grayscale, or they can be decompressed
+   * to YUV planar images.
+   */
+  public static final int CS_GRAY = 2;
+  /**
+   * CMYK colorspace.  When compressing the JPEG image, the C, M, Y, and K
+   * components in the source image are reordered into image planes, but no
+   * colorspace conversion or subsampling is performed.  CMYK JPEG images can
+   * only be decompressed to CMYK pixels.
+   */
+  public static final int CS_CMYK = 3;
+  /**
+   * YCCK colorspace.  YCCK (AKA "YCbCrK") is not an absolute colorspace but
+   * rather a mathematical transformation of CMYK designed solely for storage
+   * and transmission.  It is to CMYK as YCbCr is to RGB.  CMYK pixels can be
+   * reversibly transformed into YCCK, and as with YCbCr, the chrominance
+   * components in the YCCK pixels can be subsampled without incurring major
+   * perceptual loss.  YCCK JPEG images can only be compressed from and
+   * decompressed to CMYK pixels.
+   */
+  public static final int CS_YCCK = 4;
+
+
+  /**
+   * The uncompressed source/destination image is stored in bottom-up (Windows,
+   * OpenGL) order, not top-down (X11) order.
+   */
+  public static final int FLAG_BOTTOMUP      = 2;
+
+  @SuppressWarnings("checkstyle:JavadocVariable")
+  @Deprecated
+  public static final int FLAG_FORCEMMX      = 8;
+  @SuppressWarnings("checkstyle:JavadocVariable")
+  @Deprecated
+  public static final int FLAG_FORCESSE      = 16;
+  @SuppressWarnings("checkstyle:JavadocVariable")
+  @Deprecated
+  public static final int FLAG_FORCESSE2     = 32;
+  @SuppressWarnings("checkstyle:JavadocVariable")
+  @Deprecated
+  public static final int FLAG_FORCESSE3     = 128;
+
+  /**
+   * When decompressing an image that was compressed using chrominance
+   * subsampling, use the fastest chrominance upsampling algorithm available in
+   * the underlying codec.  The default is to use smooth upsampling, which
+   * creates a smooth transition between neighboring chrominance components in
+   * order to reduce upsampling artifacts in the decompressed image.
+   */
+  public static final int FLAG_FASTUPSAMPLE  = 256;
+  /**
+   * Use the fastest DCT/IDCT algorithm available in the underlying codec.  The
+   * default if this flag is not specified is implementation-specific.  For
+   * example, the implementation of TurboJPEG for libjpeg[-turbo] uses the fast
+   * algorithm by default when compressing, because this has been shown to have
+   * only a very slight effect on accuracy, but it uses the accurate algorithm
+   * when decompressing, because this has been shown to have a larger effect.
+   */
+  public static final int FLAG_FASTDCT       = 2048;
+  /**
+   * Use the most accurate DCT/IDCT algorithm available in the underlying
+   * codec.  The default if this flag is not specified is
+   * implementation-specific.  For example, the implementation of TurboJPEG for
+   * libjpeg[-turbo] uses the fast algorithm by default when compressing,
+   * because this has been shown to have only a very slight effect on accuracy,
+   * but it uses the accurate algorithm when decompressing, because this has
+   * been shown to have a larger effect.
+   */
+  public static final int FLAG_ACCURATEDCT   = 4096;
+  /**
+   * Immediately discontinue the current compression/decompression/transform
+   * operation if the underlying codec throws a warning (non-fatal error).  The
+   * default behavior is to allow the operation to complete unless a fatal
+   * error is encountered.
+   * <p>
+   * NOTE: due to the design of the TurboJPEG Java API, only certain methods
+   * (specifically, {@link TJDecompressor TJDecompressor.decompress*()} methods
+   * with a void return type) will complete and leave the output image in a
+   * fully recoverable state after a non-fatal error occurs.
+   */
+  public static final int FLAG_STOPONWARNING = 8192;
+  /**
+   * Use progressive entropy coding in JPEG images generated by compression and
+   * transform operations.  Progressive entropy coding will generally improve
+   * compression relative to baseline entropy coding (the default), but it will
+   * reduce compression and decompression performance considerably.
+   */
+  public static final int FLAG_PROGRESSIVE   = 16384;
+
+
+  /**
+   * The number of error codes
+   */
+  public static final int NUMERR = 2;
+  /**
+   * The error was non-fatal and recoverable, but the image may still be
+   * corrupt.
+   * <p>
+   * NOTE: due to the design of the TurboJPEG Java API, only certain methods
+   * (specifically, {@link TJDecompressor TJDecompressor.decompress*()} methods
+   * with a void return type) will complete and leave the output image in a
+   * fully recoverable state after a non-fatal error occurs.
+   */
+  public static final int ERR_WARNING = 0;
+  /**
+   * The error was fatal and non-recoverable.
+   */
+  public static final int ERR_FATAL = 1;
+
+
+  /**
+   * Returns the maximum size of the buffer (in bytes) required to hold a JPEG
+   * image with the given width, height, and level of chrominance subsampling.
+   *
+   * @param width the width (in pixels) of the JPEG image
+   *
+   * @param height the height (in pixels) of the JPEG image
+   *
+   * @param jpegSubsamp the level of chrominance subsampling to be used when
+   * generating the JPEG image (one of {@link TJ TJ.SAMP_*})
+   *
+   * @return the maximum size of the buffer (in bytes) required to hold a JPEG
+   * image with the given width, height, and level of chrominance subsampling.
+   */
+  public static native int bufSize(int width, int height, int jpegSubsamp);
+
+  /**
+   * Returns the size of the buffer (in bytes) required to hold a YUV planar
+   * image with the given width, height, and level of chrominance subsampling.
+   *
+   * @param width the width (in pixels) of the YUV image
+   *
+   * @param pad the width of each line in each plane of the image is padded to
+   * the nearest multiple of this number of bytes (must be a power of 2.)
+   *
+   * @param height the height (in pixels) of the YUV image
+   *
+   * @param subsamp the level of chrominance subsampling used in the YUV
+   * image (one of {@link TJ TJ.SAMP_*})
+   *
+   * @return the size of the buffer (in bytes) required to hold a YUV planar
+   * image with the given width, height, and level of chrominance subsampling.
+   */
+  public static native int bufSizeYUV(int width, int pad, int height,
+                                      int subsamp);
+
+  /**
+   * @deprecated Use {@link #bufSizeYUV(int, int, int, int)} instead.
+   */
+  @SuppressWarnings("checkstyle:JavadocMethod")
+  @Deprecated
+  public static native int bufSizeYUV(int width, int height, int subsamp);
+
+  /**
+   * Returns the size of the buffer (in bytes) required to hold a YUV image
+   * plane with the given parameters.
+   *
+   * @param componentID ID number of the image plane (0 = Y, 1 = U/Cb,
+   * 2 = V/Cr)
+   *
+   * @param width width (in pixels) of the YUV image.  NOTE: this is the width
+   * of the whole image, not the plane width.
+   *
+   * @param stride bytes per line in the image plane.
+   *
+   * @param height height (in pixels) of the YUV image.  NOTE: this is the
+   * height of the whole image, not the plane height.
+   *
+   * @param subsamp the level of chrominance subsampling used in the YUV
+   * image (one of {@link TJ TJ.SAMP_*})
+   *
+   * @return the size of the buffer (in bytes) required to hold a YUV planar
+   * image with the given parameters.
+   */
+  public static native int planeSizeYUV(int componentID, int width, int stride,
+                                        int height, int subsamp);
+
+  /**
+   * Returns the plane width of a YUV image plane with the given parameters.
+   * Refer to {@link YUVImage YUVImage} for a description of plane width.
+   *
+   * @param componentID ID number of the image plane (0 = Y, 1 = U/Cb,
+   * 2 = V/Cr)
+   *
+   * @param width width (in pixels) of the YUV image
+   *
+   * @param subsamp the level of chrominance subsampling used in the YUV image
+   * (one of {@link TJ TJ.SAMP_*})
+   *
+   * @return the plane width of a YUV image plane with the given parameters.
+   */
+  public static native int planeWidth(int componentID, int width, int subsamp);
+
+  /**
+   * Returns the plane height of a YUV image plane with the given parameters.
+   * Refer to {@link YUVImage YUVImage} for a description of plane height.
+   *
+   * @param componentID ID number of the image plane (0 = Y, 1 = U/Cb,
+   * 2 = V/Cr)
+   *
+   * @param height height (in pixels) of the YUV image
+   *
+   * @param subsamp the level of chrominance subsampling used in the YUV image
+   * (one of {@link TJ TJ.SAMP_*})
+   *
+   * @return the plane height of a YUV image plane with the given parameters.
+   */
+  public static native int planeHeight(int componentID, int height,
+                                       int subsamp);
+
+  /**
+   * Returns a list of fractional scaling factors that the JPEG decompressor in
+   * this implementation of TurboJPEG supports.
+   *
+   * @return a list of fractional scaling factors that the JPEG decompressor in
+   * this implementation of TurboJPEG supports.
+   */
+  public static native TJScalingFactor[] getScalingFactors();
+
+  static {
+    TJLoader.load();
+  }
+
+  private static void checkPixelFormat(int pixelFormat) {
+    if (pixelFormat < 0 || pixelFormat >= NUMPF)
+      throw new IllegalArgumentException("Invalid pixel format");
+  }
+
+  private static void checkSubsampling(int subsamp) {
+    if (subsamp < 0 || subsamp >= NUMSAMP)
+      throw new IllegalArgumentException("Invalid subsampling type");
+  }
+
+}
diff --git a/3rdparty/libjpeg/src/java/org/libjpegturbo/turbojpeg/TJCompressor.java b/3rdparty/libjpeg/src/java/org/libjpegturbo/turbojpeg/TJCompressor.java
new file mode 100644
index 00000000..6d4830f5
--- /dev/null
+++ b/3rdparty/libjpeg/src/java/org/libjpegturbo/turbojpeg/TJCompressor.java
@@ -0,0 +1,684 @@
+/*
+ * Copyright (C)2011-2015, 2018, 2020 D. R. Commander.  All Rights Reserved.
+ * Copyright (C)2015 Viktor Szathmáry.  All Rights Reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright notice,
+ *   this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright notice,
+ *   this list of conditions and the following disclaimer in the documentation
+ *   and/or other materials provided with the distribution.
+ * - Neither the name of the libjpeg-turbo Project nor the names of its
+ *   contributors may be used to endorse or promote products derived from this
+ *   software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE 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 HOLDERS 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.
+ */
+
+package org.libjpegturbo.turbojpeg;
+
+import java.awt.image.*;
+import java.nio.*;
+import java.io.*;
+
+/**
+ * TurboJPEG compressor
+ */
+public class TJCompressor implements Closeable {
+
+  private static final String NO_ASSOC_ERROR =
+    "No source image is associated with this instance";
+
+  /**
+   * Create a TurboJPEG compressor instance.
+   */
+  public TJCompressor() throws TJException {
+    init();
+  }
+
+  /**
+   * Create a TurboJPEG compressor instance and associate the uncompressed
+   * source image stored in <code>srcImage</code> with the newly created
+   * instance.
+   *
+   * @param srcImage see {@link #setSourceImage} for description
+   *
+   * @param x see {@link #setSourceImage} for description
+   *
+   * @param y see {@link #setSourceImage} for description
+   *
+   * @param width see {@link #setSourceImage} for description
+   *
+   * @param pitch see {@link #setSourceImage} for description
+   *
+   * @param height see {@link #setSourceImage} for description
+   *
+   * @param pixelFormat pixel format of the source image (one of
+   * {@link TJ#PF_RGB TJ.PF_*})
+   */
+  public TJCompressor(byte[] srcImage, int x, int y, int width, int pitch,
+                      int height, int pixelFormat) throws TJException {
+    setSourceImage(srcImage, x, y, width, pitch, height, pixelFormat);
+  }
+
+  /**
+   * @deprecated Use
+   * {@link #TJCompressor(byte[], int, int, int, int, int, int)} instead.
+   */
+  @SuppressWarnings("checkstyle:JavadocMethod")
+  @Deprecated
+  public TJCompressor(byte[] srcImage, int width, int pitch, int height,
+                      int pixelFormat) throws TJException {
+    setSourceImage(srcImage, width, pitch, height, pixelFormat);
+  }
+
+  /**
+   * Create a TurboJPEG compressor instance and associate the uncompressed
+   * source image stored in <code>srcImage</code> with the newly created
+   * instance.
+   *
+   * @param srcImage see
+   * {@link #setSourceImage(BufferedImage, int, int, int, int)} for description
+   *
+   * @param x see
+   * {@link #setSourceImage(BufferedImage, int, int, int, int)} for description
+   *
+   * @param y see
+   * {@link #setSourceImage(BufferedImage, int, int, int, int)} for description
+   *
+   * @param width see
+   * {@link #setSourceImage(BufferedImage, int, int, int, int)} for description
+   *
+   * @param height see
+   * {@link #setSourceImage(BufferedImage, int, int, int, int)} for description
+   */
+  public TJCompressor(BufferedImage srcImage, int x, int y, int width,
+                      int height) throws TJException {
+    setSourceImage(srcImage, x, y, width, height);
+  }
+
+  /**
+   * Associate an uncompressed RGB, grayscale, or CMYK source image with this
+   * compressor instance.
+   *
+   * @param srcImage image buffer containing RGB, grayscale, or CMYK pixels to
+   * be compressed or encoded.  This buffer is not modified.
+   *
+   * @param x x offset (in pixels) of the region in the source image from which
+   * the JPEG or YUV image should be compressed/encoded
+   *
+   * @param y y offset (in pixels) of the region in the source image from which
+   * the JPEG or YUV image should be compressed/encoded
+   *
+   * @param width width (in pixels) of the region in the source image from
+   * which the JPEG or YUV image should be compressed/encoded
+   *
+   * @param pitch bytes per line of the source image.  Normally, this should be
+   * <code>width * TJ.pixelSize(pixelFormat)</code> if the source image is
+   * unpadded, but you can use this parameter to, for instance, specify that
+   * the scanlines in the source image are padded to a 4-byte boundary or to
+   * compress/encode a JPEG or YUV image from a region of a larger source
+   * image.  You can also be clever and use this parameter to skip lines, etc.
+   * Setting this parameter to 0 is the equivalent of setting it to
+   * <code>width * TJ.pixelSize(pixelFormat)</code>.
+   *
+   * @param height height (in pixels) of the region in the source image from
+   * which the JPEG or YUV image should be compressed/encoded
+   *
+   * @param pixelFormat pixel format of the source image (one of
+   * {@link TJ#PF_RGB TJ.PF_*})
+   */
+  public void setSourceImage(byte[] srcImage, int x, int y, int width,
+                             int pitch, int height, int pixelFormat)
+                             throws TJException {
+    if (handle == 0) init();
+    if (srcImage == null || x < 0 || y < 0 || width < 1 || height < 1 ||
+        pitch < 0 || pixelFormat < 0 || pixelFormat >= TJ.NUMPF)
+      throw new IllegalArgumentException("Invalid argument in setSourceImage()");
+    srcBuf = srcImage;
+    srcWidth = width;
+    if (pitch == 0)
+      srcPitch = width * TJ.getPixelSize(pixelFormat);
+    else
+      srcPitch = pitch;
+    srcHeight = height;
+    srcPixelFormat = pixelFormat;
+    srcX = x;
+    srcY = y;
+    srcBufInt = null;
+    srcYUVImage = null;
+  }
+
+  /**
+   * @deprecated Use
+   * {@link #setSourceImage(byte[], int, int, int, int, int, int)} instead.
+   */
+  @SuppressWarnings("checkstyle:JavadocMethod")
+  @Deprecated
+  public void setSourceImage(byte[] srcImage, int width, int pitch,
+                             int height, int pixelFormat) throws TJException {
+    setSourceImage(srcImage, 0, 0, width, pitch, height, pixelFormat);
+    srcX = srcY = -1;
+  }
+
+  /**
+   * Associate an uncompressed RGB or grayscale source image with this
+   * compressor instance.
+   *
+   * @param srcImage a <code>BufferedImage</code> instance containing RGB or
+   * grayscale pixels to be compressed or encoded.  This image is not modified.
+   *
+   * @param x x offset (in pixels) of the region in the source image from which
+   * the JPEG or YUV image should be compressed/encoded
+   *
+   * @param y y offset (in pixels) of the region in the source image from which
+   * the JPEG or YUV image should be compressed/encoded
+   *
+   * @param width width (in pixels) of the region in the source image from
+   * which the JPEG or YUV image should be compressed/encoded (0 = use the
+   * width of the source image)
+   *
+   * @param height height (in pixels) of the region in the source image from
+   * which the JPEG or YUV image should be compressed/encoded (0 = use the
+   * height of the source image)
+   */
+  public void setSourceImage(BufferedImage srcImage, int x, int y, int width,
+                             int height) throws TJException {
+    if (handle == 0) init();
+    if (srcImage == null || x < 0 || y < 0 || width < 0 || height < 0)
+      throw new IllegalArgumentException("Invalid argument in setSourceImage()");
+    srcX = x;
+    srcY = y;
+    srcWidth = (width == 0) ? srcImage.getWidth() : width;
+    srcHeight = (height == 0) ? srcImage.getHeight() : height;
+    if (x + width > srcImage.getWidth() || y + height > srcImage.getHeight())
+      throw new IllegalArgumentException("Compression region exceeds the bounds of the source image");
+
+    int pixelFormat;
+    boolean intPixels = false;
+    if (byteOrder == null)
+      byteOrder = ByteOrder.nativeOrder();
+    switch (srcImage.getType()) {
+    case BufferedImage.TYPE_3BYTE_BGR:
+      pixelFormat = TJ.PF_BGR;  break;
+    case BufferedImage.TYPE_4BYTE_ABGR:
+    case BufferedImage.TYPE_4BYTE_ABGR_PRE:
+      pixelFormat = TJ.PF_XBGR;  break;
+    case BufferedImage.TYPE_BYTE_GRAY:
+      pixelFormat = TJ.PF_GRAY;  break;
+    case BufferedImage.TYPE_INT_BGR:
+      if (byteOrder == ByteOrder.BIG_ENDIAN)
+        pixelFormat = TJ.PF_XBGR;
+      else
+        pixelFormat = TJ.PF_RGBX;
+      intPixels = true;  break;
+    case BufferedImage.TYPE_INT_RGB:
+    case BufferedImage.TYPE_INT_ARGB:
+    case BufferedImage.TYPE_INT_ARGB_PRE:
+      if (byteOrder == ByteOrder.BIG_ENDIAN)
+        pixelFormat = TJ.PF_XRGB;
+      else
+        pixelFormat = TJ.PF_BGRX;
+      intPixels = true;  break;
+    default:
+      throw new IllegalArgumentException("Unsupported BufferedImage format");
+    }
+    srcPixelFormat = pixelFormat;
+
+    WritableRaster wr = srcImage.getRaster();
+    if (intPixels) {
+      SinglePixelPackedSampleModel sm =
+        (SinglePixelPackedSampleModel)srcImage.getSampleModel();
+      srcStride = sm.getScanlineStride();
+      DataBufferInt db = (DataBufferInt)wr.getDataBuffer();
+      srcBufInt = db.getData();
+      srcBuf = null;
+    } else {
+      ComponentSampleModel sm =
+        (ComponentSampleModel)srcImage.getSampleModel();
+      int pixelSize = sm.getPixelStride();
+      if (pixelSize != TJ.getPixelSize(pixelFormat))
+        throw new IllegalArgumentException("Inconsistency between pixel format and pixel size in BufferedImage");
+      srcPitch = sm.getScanlineStride();
+      DataBufferByte db = (DataBufferByte)wr.getDataBuffer();
+      srcBuf = db.getData();
+      srcBufInt = null;
+    }
+    srcYUVImage = null;
+  }
+
+  /**
+   * Associate an uncompressed YUV planar source image with this compressor
+   * instance.
+   *
+   * @param srcImage YUV planar image to be compressed.  This image is not
+   * modified.
+   */
+  public void setSourceImage(YUVImage srcImage) throws TJException {
+    if (handle == 0) init();
+    if (srcImage == null)
+      throw new IllegalArgumentException("Invalid argument in setSourceImage()");
+    srcYUVImage = srcImage;
+    srcBuf = null;
+    srcBufInt = null;
+  }
+
+  /**
+   * Set the level of chrominance subsampling for subsequent compress/encode
+   * operations.  When pixels are converted from RGB to YCbCr (see
+   * {@link TJ#CS_YCbCr}) or from CMYK to YCCK (see {@link TJ#CS_YCCK}) as part
+   * of the JPEG compression process, some of the Cb and Cr (chrominance)
+   * components can be discarded or averaged together to produce a smaller
+   * image with little perceptible loss of image clarity (the human eye is more
+   * sensitive to small changes in brightness than to small changes in color.)
+   * This is called "chrominance subsampling".
+   * <p>
+   * NOTE: This method has no effect when compressing a JPEG image from a YUV
+   * planar source.  In that case, the level of chrominance subsampling in
+   * the JPEG image is determined by the source.  Furthermore, this method has
+   * no effect when encoding to a pre-allocated {@link YUVImage} instance.  In
+   * that case, the level of chrominance subsampling is determined by the
+   * destination.
+   *
+   * @param newSubsamp the level of chrominance subsampling to use in
+   * subsequent compress/encode oeprations (one of
+   * {@link TJ#SAMP_444 TJ.SAMP_*})
+   */
+  public void setSubsamp(int newSubsamp) {
+    if (newSubsamp < 0 || newSubsamp >= TJ.NUMSAMP)
+      throw new IllegalArgumentException("Invalid argument in setSubsamp()");
+    subsamp = newSubsamp;
+  }
+
+  /**
+   * Set the JPEG image quality level for subsequent compress operations.
+   *
+   * @param quality the new JPEG image quality level (1 to 100, 1 = worst,
+   * 100 = best)
+   */
+  public void setJPEGQuality(int quality) {
+    if (quality < 1 || quality > 100)
+      throw new IllegalArgumentException("Invalid argument in setJPEGQuality()");
+    jpegQuality = quality;
+  }
+
+  /**
+   * Compress the uncompressed source image associated with this compressor
+   * instance and output a JPEG image to the given destination buffer.
+   *
+   * @param dstBuf buffer that will receive the JPEG image.  Use
+   * {@link TJ#bufSize} to determine the maximum size for this buffer based on
+   * the source image's width and height and the desired level of chrominance
+   * subsampling.
+   *
+   * @param flags the bitwise OR of one or more of
+   * {@link TJ#FLAG_BOTTOMUP TJ.FLAG_*}
+   */
+  public void compress(byte[] dstBuf, int flags) throws TJException {
+    if (dstBuf == null || flags < 0)
+      throw new IllegalArgumentException("Invalid argument in compress()");
+    if (srcBuf == null && srcBufInt == null && srcYUVImage == null)
+      throw new IllegalStateException(NO_ASSOC_ERROR);
+    if (jpegQuality < 0)
+      throw new IllegalStateException("JPEG Quality not set");
+    if (subsamp < 0 && srcYUVImage == null)
+      throw new IllegalStateException("Subsampling level not set");
+
+    if (srcYUVImage != null)
+      compressedSize = compressFromYUV(srcYUVImage.getPlanes(),
+                                       srcYUVImage.getOffsets(),
+                                       srcYUVImage.getWidth(),
+                                       srcYUVImage.getStrides(),
+                                       srcYUVImage.getHeight(),
+                                       srcYUVImage.getSubsamp(),
+                                       dstBuf, jpegQuality, flags);
+    else if (srcBuf != null) {
+      if (srcX >= 0 && srcY >= 0)
+        compressedSize = compress(srcBuf, srcX, srcY, srcWidth, srcPitch,
+                                  srcHeight, srcPixelFormat, dstBuf, subsamp,
+                                  jpegQuality, flags);
+      else
+        compressedSize = compress(srcBuf, srcWidth, srcPitch, srcHeight,
+                                  srcPixelFormat, dstBuf, subsamp, jpegQuality,
+                                  flags);
+    } else if (srcBufInt != null) {
+      if (srcX >= 0 && srcY >= 0)
+        compressedSize = compress(srcBufInt, srcX, srcY, srcWidth, srcStride,
+                                  srcHeight, srcPixelFormat, dstBuf, subsamp,
+                                  jpegQuality, flags);
+      else
+        compressedSize = compress(srcBufInt, srcWidth, srcStride, srcHeight,
+                                  srcPixelFormat, dstBuf, subsamp, jpegQuality,
+                                  flags);
+    }
+  }
+
+  /**
+   * Compress the uncompressed source image associated with this compressor
+   * instance and return a buffer containing a JPEG image.
+   *
+   * @param flags the bitwise OR of one or more of
+   * {@link TJ#FLAG_BOTTOMUP TJ.FLAG_*}
+   *
+   * @return a buffer containing a JPEG image.  The length of this buffer will
+   * not be equal to the size of the JPEG image.  Use {@link
+   * #getCompressedSize} to obtain the size of the JPEG image.
+   */
+  public byte[] compress(int flags) throws TJException {
+    byte[] buf;
+    if (srcYUVImage != null) {
+      buf = new byte[TJ.bufSize(srcYUVImage.getWidth(),
+                                srcYUVImage.getHeight(),
+                                srcYUVImage.getSubsamp())];
+    } else {
+      checkSourceImage();
+      buf = new byte[TJ.bufSize(srcWidth, srcHeight, subsamp)];
+    }
+    compress(buf, flags);
+    return buf;
+  }
+
+  /**
+   * @deprecated Use
+   * {@link #setSourceImage(BufferedImage, int, int, int, int)} and
+   * {@link #compress(byte[], int)} instead.
+   */
+  @SuppressWarnings("checkstyle:JavadocMethod")
+  @Deprecated
+  public void compress(BufferedImage srcImage, byte[] dstBuf, int flags)
+                       throws TJException {
+    setSourceImage(srcImage, 0, 0, 0, 0);
+    compress(dstBuf, flags);
+  }
+
+  /**
+   * @deprecated Use
+   * {@link #setSourceImage(BufferedImage, int, int, int, int)} and
+   * {@link #compress(int)} instead.
+   */
+  @SuppressWarnings("checkstyle:JavadocMethod")
+  @Deprecated
+  public byte[] compress(BufferedImage srcImage, int flags)
+                         throws TJException {
+    setSourceImage(srcImage, 0, 0, 0, 0);
+    return compress(flags);
+  }
+
+  /**
+   * Encode the uncompressed source image associated with this compressor
+   * instance into a YUV planar image and store it in the given
+   * <code>YUVImage</code> instance.   This method uses the accelerated color
+   * conversion routines in TurboJPEG's underlying codec but does not execute
+   * any of the other steps in the JPEG compression process.  Encoding
+   * CMYK source images to YUV is not supported.
+   *
+   * @param dstImage {@link YUVImage} instance that will receive the YUV planar
+   * image
+   *
+   * @param flags the bitwise OR of one or more of
+   * {@link TJ#FLAG_BOTTOMUP TJ.FLAG_*}
+   */
+  public void encodeYUV(YUVImage dstImage, int flags) throws TJException {
+    if (dstImage == null || flags < 0)
+      throw new IllegalArgumentException("Invalid argument in encodeYUV()");
+    if (srcBuf == null && srcBufInt == null)
+      throw new IllegalStateException(NO_ASSOC_ERROR);
+    if (srcYUVImage != null)
+      throw new IllegalStateException("Source image is not correct type");
+    checkSubsampling();
+    if (srcWidth != dstImage.getWidth() || srcHeight != dstImage.getHeight())
+      throw new IllegalStateException("Destination image is the wrong size");
+
+    if (srcBufInt != null) {
+      encodeYUV(srcBufInt, srcX, srcY, srcWidth, srcStride, srcHeight,
+                srcPixelFormat, dstImage.getPlanes(), dstImage.getOffsets(),
+                dstImage.getStrides(), dstImage.getSubsamp(), flags);
+    } else {
+      encodeYUV(srcBuf, srcX, srcY, srcWidth, srcPitch, srcHeight,
+                srcPixelFormat, dstImage.getPlanes(), dstImage.getOffsets(),
+                dstImage.getStrides(), dstImage.getSubsamp(), flags);
+    }
+    compressedSize = 0;
+  }
+
+  /**
+   * @deprecated Use {@link #encodeYUV(YUVImage, int)} instead.
+   */
+  @SuppressWarnings("checkstyle:JavadocMethod")
+  @Deprecated
+  public void encodeYUV(byte[] dstBuf, int flags) throws TJException {
+    if (dstBuf == null)
+      throw new IllegalArgumentException("Invalid argument in encodeYUV()");
+    checkSourceImage();
+    checkSubsampling();
+    YUVImage dstYUVImage = new YUVImage(dstBuf, srcWidth, 4, srcHeight,
+                                        subsamp);
+    encodeYUV(dstYUVImage, flags);
+  }
+
+  /**
+   * Encode the uncompressed source image associated with this compressor
+   * instance into a unified YUV planar image buffer and return a
+   * <code>YUVImage</code> instance containing the encoded image.  This method
+   * uses the accelerated color conversion routines in TurboJPEG's underlying
+   * codec but does not execute any of the other steps in the JPEG compression
+   * process.  Encoding CMYK source images to YUV is not supported.
+   *
+   * @param pad the width of each line in each plane of the YUV image will be
+   * padded to the nearest multiple of this number of bytes (must be a power of
+   * 2.)
+   *
+   * @param flags the bitwise OR of one or more of
+   * {@link TJ#FLAG_BOTTOMUP TJ.FLAG_*}
+   *
+   * @return a YUV planar image.
+   */
+  public YUVImage encodeYUV(int pad, int flags) throws TJException {
+    checkSourceImage();
+    checkSubsampling();
+    if (pad < 1 || ((pad & (pad - 1)) != 0))
+      throw new IllegalStateException("Invalid argument in encodeYUV()");
+    YUVImage dstYUVImage = new YUVImage(srcWidth, pad, srcHeight, subsamp);
+    encodeYUV(dstYUVImage, flags);
+    return dstYUVImage;
+  }
+
+  /**
+   * Encode the uncompressed source image associated with this compressor
+   * instance into separate Y, U (Cb), and V (Cr) image planes and return a
+   * <code>YUVImage</code> instance containing the encoded image planes.  This
+   * method uses the accelerated color conversion routines in TurboJPEG's
+   * underlying codec but does not execute any of the other steps in the JPEG
+   * compression process.  Encoding CMYK source images to YUV is not supported.
+   *
+   * @param strides an array of integers, each specifying the number of bytes
+   * per line in the corresponding plane of the output image.  Setting the
+   * stride for any plane to 0 is the same as setting it to the component width
+   * of the plane.  If <code>strides</code> is null, then the strides for all
+   * planes will be set to their respective component widths.  You can adjust
+   * the strides in order to add an arbitrary amount of line padding to each
+   * plane.
+   *
+   * @param flags the bitwise OR of one or more of
+   * {@link TJ#FLAG_BOTTOMUP TJ.FLAG_*}
+   *
+   * @return a YUV planar image.
+   */
+  public YUVImage encodeYUV(int[] strides, int flags) throws TJException {
+    checkSourceImage();
+    checkSubsampling();
+    YUVImage dstYUVImage = new YUVImage(srcWidth, strides, srcHeight, subsamp);
+    encodeYUV(dstYUVImage, flags);
+    return dstYUVImage;
+  }
+
+  /**
+   * @deprecated Use {@link #encodeYUV(int, int)} instead.
+   */
+  @SuppressWarnings("checkstyle:JavadocMethod")
+  @Deprecated
+  public byte[] encodeYUV(int flags) throws TJException {
+    checkSourceImage();
+    checkSubsampling();
+    YUVImage dstYUVImage = new YUVImage(srcWidth, 4, srcHeight, subsamp);
+    encodeYUV(dstYUVImage, flags);
+    return dstYUVImage.getBuf();
+  }
+
+  /**
+   * @deprecated Use
+   * {@link #setSourceImage(BufferedImage, int, int, int, int)} and
+   * {@link #encodeYUV(byte[], int)} instead.
+   */
+  @SuppressWarnings("checkstyle:JavadocMethod")
+  @Deprecated
+  public void encodeYUV(BufferedImage srcImage, byte[] dstBuf, int flags)
+                        throws TJException {
+    setSourceImage(srcImage, 0, 0, 0, 0);
+    encodeYUV(dstBuf, flags);
+  }
+
+  /**
+   * @deprecated Use
+   * {@link #setSourceImage(BufferedImage, int, int, int, int)} and
+   * {@link #encodeYUV(int, int)} instead.
+   */
+  @SuppressWarnings("checkstyle:JavadocMethod")
+  @Deprecated
+  public byte[] encodeYUV(BufferedImage srcImage, int flags)
+                          throws TJException {
+    setSourceImage(srcImage, 0, 0, 0, 0);
+    return encodeYUV(flags);
+  }
+
+  /**
+   * Returns the size of the image (in bytes) generated by the most recent
+   * compress operation.
+   *
+   * @return the size of the image (in bytes) generated by the most recent
+   * compress operation.
+   */
+  public int getCompressedSize() {
+    return compressedSize;
+  }
+
+  /**
+   * Free the native structures associated with this compressor instance.
+   */
+  @Override
+  public void close() throws TJException {
+    if (handle != 0)
+      destroy();
+  }
+
+  @SuppressWarnings("checkstyle:DesignForExtension")
+  @Override
+  protected void finalize() throws Throwable {
+    try {
+      close();
+    } catch (TJException e) {
+    } finally {
+      super.finalize();
+    }
+  };
+
+  private native void init() throws TJException;
+
+  private native void destroy() throws TJException;
+
+  // JPEG size in bytes is returned
+  @SuppressWarnings("checkstyle:HiddenField")
+  @Deprecated
+  private native int compress(byte[] srcBuf, int width, int pitch,
+    int height, int pixelFormat, byte[] jpegBuf, int jpegSubsamp, int jpegQual,
+    int flags) throws TJException;
+
+  @SuppressWarnings("checkstyle:HiddenField")
+  private native int compress(byte[] srcBuf, int x, int y, int width,
+    int pitch, int height, int pixelFormat, byte[] jpegBuf, int jpegSubsamp,
+    int jpegQual, int flags) throws TJException;
+
+  @SuppressWarnings("checkstyle:HiddenField")
+  @Deprecated
+  private native int compress(int[] srcBuf, int width, int stride,
+    int height, int pixelFormat, byte[] jpegBuf, int jpegSubsamp, int jpegQual,
+    int flags) throws TJException;
+
+  @SuppressWarnings("checkstyle:HiddenField")
+  private native int compress(int[] srcBuf, int x, int y, int width,
+    int stride, int height, int pixelFormat, byte[] jpegBuf, int jpegSubsamp,
+    int jpegQual, int flags) throws TJException;
+
+  @SuppressWarnings("checkstyle:HiddenField")
+  private native int compressFromYUV(byte[][] srcPlanes, int[] srcOffsets,
+    int width, int[] srcStrides, int height, int subsamp, byte[] jpegBuf,
+    int jpegQual, int flags)
+    throws TJException;
+
+  @SuppressWarnings("checkstyle:HiddenField")
+  @Deprecated
+  private native void encodeYUV(byte[] srcBuf, int width, int pitch,
+    int height, int pixelFormat, byte[] dstBuf, int subsamp, int flags)
+    throws TJException;
+
+  @SuppressWarnings("checkstyle:HiddenField")
+  private native void encodeYUV(byte[] srcBuf, int x, int y, int width,
+    int pitch, int height, int pixelFormat, byte[][] dstPlanes,
+    int[] dstOffsets, int[] dstStrides, int subsamp, int flags)
+    throws TJException;
+
+  @SuppressWarnings("checkstyle:HiddenField")
+  @Deprecated
+  private native void encodeYUV(int[] srcBuf, int width, int stride,
+    int height, int pixelFormat, byte[] dstBuf, int subsamp, int flags)
+    throws TJException;
+
+  @SuppressWarnings("checkstyle:HiddenField")
+  private native void encodeYUV(int[] srcBuf, int x, int y, int width,
+    int srcStride, int height, int pixelFormat, byte[][] dstPlanes,
+    int[] dstOffsets, int[] dstStrides, int subsamp, int flags)
+    throws TJException;
+
+  static {
+    TJLoader.load();
+  }
+
+  private void checkSourceImage() {
+    if (srcWidth < 1 || srcHeight < 1)
+      throw new IllegalStateException(NO_ASSOC_ERROR);
+  }
+
+  private void checkSubsampling() {
+    if (subsamp < 0)
+      throw new IllegalStateException("Subsampling level not set");
+  }
+
+  private long handle = 0;
+  private byte[] srcBuf = null;
+  private int[] srcBufInt = null;
+  private int srcWidth = 0;
+  private int srcHeight = 0;
+  private int srcX = -1;
+  private int srcY = -1;
+  private int srcPitch = 0;
+  private int srcStride = 0;
+  private int srcPixelFormat = -1;
+  private YUVImage srcYUVImage = null;
+  private int subsamp = -1;
+  private int jpegQuality = -1;
+  private int compressedSize = 0;
+  private int yuvPad = 4;
+  private ByteOrder byteOrder = null;
+}
diff --git a/3rdparty/libjpeg/src/java/org/libjpegturbo/turbojpeg/TJCustomFilter.java b/3rdparty/libjpeg/src/java/org/libjpegturbo/turbojpeg/TJCustomFilter.java
new file mode 100644
index 00000000..9a34587a
--- /dev/null
+++ b/3rdparty/libjpeg/src/java/org/libjpegturbo/turbojpeg/TJCustomFilter.java
@@ -0,0 +1,76 @@
+/*
+ * Copyright (C)2011, 2013 D. R. Commander.  All Rights Reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright notice,
+ *   this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright notice,
+ *   this list of conditions and the following disclaimer in the documentation
+ *   and/or other materials provided with the distribution.
+ * - Neither the name of the libjpeg-turbo Project nor the names of its
+ *   contributors may be used to endorse or promote products derived from this
+ *   software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE 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 HOLDERS 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.
+ */
+
+package org.libjpegturbo.turbojpeg;
+
+import java.awt.*;
+import java.nio.*;
+
+/**
+ * Custom filter callback interface
+ */
+public interface TJCustomFilter {
+
+  /**
+   * A callback function that can be used to modify the DCT coefficients after
+   * they are losslessly transformed but before they are transcoded to a new
+   * JPEG image.  This allows for custom filters or other transformations to be
+   * applied in the frequency domain.
+   *
+   * @param coeffBuffer a buffer containing transformed DCT coefficients.
+   * (NOTE: this buffer is not guaranteed to be valid once the callback
+   * returns, so applications wishing to hand off the DCT coefficients to
+   * another function or library should make a copy of them within the body of
+   * the callback.)
+   *
+   * @param bufferRegion rectangle containing the width and height of
+   * <code>coeffBuffer</code> as well as its offset relative to the component
+   * plane.  TurboJPEG implementations may choose to split each component plane
+   * into multiple DCT coefficient buffers and call the callback function once
+   * for each buffer.
+   *
+   * @param planeRegion rectangle containing the width and height of the
+   * component plane to which <code>coeffBuffer</code> belongs
+   *
+   * @param componentID ID number of the component plane to which
+   * <code>coeffBuffer</code> belongs (Y, Cb, and Cr have, respectively, ID's
+   * of 0, 1, and 2 in typical JPEG images.)
+   *
+   * @param transformID ID number of the transformed image to which
+   * <code>coeffBuffer</code> belongs.  This is the same as the index of the
+   * transform in the <code>transforms</code> array that was passed to {@link
+   * TJTransformer#transform TJTransformer.transform()}.
+   *
+   * @param transform a {@link TJTransform} instance that specifies the
+   * parameters and/or cropping region for this transform
+   */
+  void customFilter(ShortBuffer coeffBuffer, Rectangle bufferRegion,
+                    Rectangle planeRegion, int componentID, int transformID,
+                    TJTransform transform)
+    throws TJException;
+}
diff --git a/3rdparty/libjpeg/src/java/org/libjpegturbo/turbojpeg/TJDecompressor.java b/3rdparty/libjpeg/src/java/org/libjpegturbo/turbojpeg/TJDecompressor.java
new file mode 100644
index 00000000..cba9ff03
--- /dev/null
+++ b/3rdparty/libjpeg/src/java/org/libjpegturbo/turbojpeg/TJDecompressor.java
@@ -0,0 +1,931 @@
+/*
+ * Copyright (C)2011-2015, 2018 D. R. Commander.  All Rights Reserved.
+ * Copyright (C)2015 Viktor Szathmáry.  All Rights Reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright notice,
+ *   this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright notice,
+ *   this list of conditions and the following disclaimer in the documentation
+ *   and/or other materials provided with the distribution.
+ * - Neither the name of the libjpeg-turbo Project nor the names of its
+ *   contributors may be used to endorse or promote products derived from this
+ *   software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE 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 HOLDERS 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.
+ */
+
+package org.libjpegturbo.turbojpeg;
+
+import java.awt.image.*;
+import java.nio.*;
+import java.io.*;
+
+/**
+ * TurboJPEG decompressor
+ */
+public class TJDecompressor implements Closeable {
+
+  private static final String NO_ASSOC_ERROR =
+    "No JPEG image is associated with this instance";
+
+  /**
+   * Create a TurboJPEG decompresssor instance.
+   */
+  public TJDecompressor() throws TJException {
+    init();
+  }
+
+  /**
+   * Create a TurboJPEG decompressor instance and associate the JPEG source
+   * image stored in <code>jpegImage</code> with the newly created instance.
+   *
+   * @param jpegImage JPEG image buffer (size of the JPEG image is assumed to
+   * be the length of the array.)  This buffer is not modified.
+   */
+  public TJDecompressor(byte[] jpegImage) throws TJException {
+    init();
+    setSourceImage(jpegImage, jpegImage.length);
+  }
+
+  /**
+   * Create a TurboJPEG decompressor instance and associate the JPEG source
+   * image of length <code>imageSize</code> bytes stored in
+   * <code>jpegImage</code> with the newly created instance.
+   *
+   * @param jpegImage JPEG image buffer.  This buffer is not modified.
+   *
+   * @param imageSize size of the JPEG image (in bytes)
+   */
+  public TJDecompressor(byte[] jpegImage, int imageSize) throws TJException {
+    init();
+    setSourceImage(jpegImage, imageSize);
+  }
+
+  /**
+   * Create a TurboJPEG decompressor instance and associate the YUV planar
+   * source image stored in <code>yuvImage</code> with the newly created
+   * instance.
+   *
+   * @param yuvImage {@link YUVImage} instance containing a YUV planar
+   * image to be decoded.  This image is not modified.
+   */
+  @SuppressWarnings("checkstyle:HiddenField")
+  public TJDecompressor(YUVImage yuvImage) throws TJException {
+    init();
+    setSourceImage(yuvImage);
+  }
+
+  /**
+   * Associate the JPEG image of length <code>imageSize</code> bytes stored in
+   * <code>jpegImage</code> with this decompressor instance.  This image will
+   * be used as the source image for subsequent decompress operations.
+   *
+   * @param jpegImage JPEG image buffer.  This buffer is not modified.
+   *
+   * @param imageSize size of the JPEG image (in bytes)
+   */
+  public void setSourceImage(byte[] jpegImage, int imageSize)
+                             throws TJException {
+    if (jpegImage == null || imageSize < 1)
+      throw new IllegalArgumentException("Invalid argument in setSourceImage()");
+    jpegBuf = jpegImage;
+    jpegBufSize = imageSize;
+    decompressHeader(jpegBuf, jpegBufSize);
+    yuvImage = null;
+  }
+
+  /**
+   * @deprecated Use {@link #setSourceImage(byte[], int)} instead.
+   */
+  @SuppressWarnings("checkstyle:JavadocMethod")
+  @Deprecated
+  public void setJPEGImage(byte[] jpegImage, int imageSize)
+                           throws TJException {
+    setSourceImage(jpegImage, imageSize);
+  }
+
+  /**
+   * Associate the specified YUV planar source image with this decompressor
+   * instance.  Subsequent decompress operations will decode this image into an
+   * RGB or grayscale destination image.
+   *
+   * @param srcImage {@link YUVImage} instance containing a YUV planar image to
+   * be decoded.  This image is not modified.
+   */
+  public void setSourceImage(YUVImage srcImage) {
+    if (srcImage == null)
+      throw new IllegalArgumentException("Invalid argument in setSourceImage()");
+    yuvImage = srcImage;
+    jpegBuf = null;
+    jpegBufSize = 0;
+  }
+
+
+  /**
+   * Returns the width of the source image (JPEG or YUV) associated with this
+   * decompressor instance.
+   *
+   * @return the width of the source image (JPEG or YUV) associated with this
+   * decompressor instance.
+   */
+  public int getWidth() {
+    if (yuvImage != null)
+      return yuvImage.getWidth();
+    if (jpegWidth < 1)
+      throw new IllegalStateException(NO_ASSOC_ERROR);
+    return jpegWidth;
+  }
+
+  /**
+   * Returns the height of the source image (JPEG or YUV) associated with this
+   * decompressor instance.
+   *
+   * @return the height of the source image (JPEG or YUV) associated with this
+   * decompressor instance.
+   */
+  public int getHeight() {
+    if (yuvImage != null)
+      return yuvImage.getHeight();
+    if (jpegHeight < 1)
+      throw new IllegalStateException(NO_ASSOC_ERROR);
+    return jpegHeight;
+  }
+
+  /**
+   * Returns the level of chrominance subsampling used in the source image
+   * (JPEG or YUV) associated with this decompressor instance.  See
+   * {@link TJ#SAMP_444 TJ.SAMP_*}.
+   *
+   * @return the level of chrominance subsampling used in the source image
+   * (JPEG or YUV) associated with this decompressor instance.
+   */
+  public int getSubsamp() {
+    if (yuvImage != null)
+      return yuvImage.getSubsamp();
+    if (jpegSubsamp < 0)
+      throw new IllegalStateException(NO_ASSOC_ERROR);
+    if (jpegSubsamp >= TJ.NUMSAMP)
+      throw new IllegalStateException("JPEG header information is invalid");
+    return jpegSubsamp;
+  }
+
+  /**
+   * Returns the colorspace used in the source image (JPEG or YUV) associated
+   * with this decompressor instance.  See {@link TJ#CS_RGB TJ.CS_*}.  If the
+   * source image is YUV, then this always returns {@link TJ#CS_YCbCr}.
+   *
+   * @return the colorspace used in the source image (JPEG or YUV) associated
+   * with this decompressor instance.
+   */
+  public int getColorspace() {
+    if (yuvImage != null)
+      return TJ.CS_YCbCr;
+    if (jpegColorspace < 0)
+      throw new IllegalStateException(NO_ASSOC_ERROR);
+    if (jpegColorspace >= TJ.NUMCS)
+      throw new IllegalStateException("JPEG header information is invalid");
+    return jpegColorspace;
+  }
+
+  /**
+   * Returns the JPEG image buffer associated with this decompressor instance.
+   *
+   * @return the JPEG image buffer associated with this decompressor instance.
+   */
+  public byte[] getJPEGBuf() {
+    if (jpegBuf == null)
+      throw new IllegalStateException(NO_ASSOC_ERROR);
+    return jpegBuf;
+  }
+
+  /**
+   * Returns the size of the JPEG image (in bytes) associated with this
+   * decompressor instance.
+   *
+   * @return the size of the JPEG image (in bytes) associated with this
+   * decompressor instance.
+   */
+  public int getJPEGSize() {
+    if (jpegBufSize < 1)
+      throw new IllegalStateException(NO_ASSOC_ERROR);
+    return jpegBufSize;
+  }
+
+  /**
+   * Returns the width of the largest scaled-down image that the TurboJPEG
+   * decompressor can generate without exceeding the desired image width and
+   * height.
+   *
+   * @param desiredWidth desired width (in pixels) of the decompressed image.
+   * Setting this to 0 is the same as setting it to the width of the JPEG image
+   * (in other words, the width will not be considered when determining the
+   * scaled image size.)
+   *
+   * @param desiredHeight desired height (in pixels) of the decompressed image.
+   * Setting this to 0 is the same as setting it to the height of the JPEG
+   * image (in other words, the height will not be considered when determining
+   * the scaled image size.)
+   *
+   * @return the width of the largest scaled-down image that the TurboJPEG
+   * decompressor can generate without exceeding the desired image width and
+   * height.
+   */
+  public int getScaledWidth(int desiredWidth, int desiredHeight) {
+    if (jpegWidth < 1 || jpegHeight < 1)
+      throw new IllegalStateException(NO_ASSOC_ERROR);
+    if (desiredWidth < 0 || desiredHeight < 0)
+      throw new IllegalArgumentException("Invalid argument in getScaledWidth()");
+    TJScalingFactor[] sf = TJ.getScalingFactors();
+    if (desiredWidth == 0)
+      desiredWidth = jpegWidth;
+    if (desiredHeight == 0)
+      desiredHeight = jpegHeight;
+    int scaledWidth = jpegWidth, scaledHeight = jpegHeight;
+    for (int i = 0; i < sf.length; i++) {
+      scaledWidth = sf[i].getScaled(jpegWidth);
+      scaledHeight = sf[i].getScaled(jpegHeight);
+      if (scaledWidth <= desiredWidth && scaledHeight <= desiredHeight)
+        break;
+    }
+    if (scaledWidth > desiredWidth || scaledHeight > desiredHeight)
+      throw new IllegalArgumentException("Could not scale down to desired image dimensions");
+    return scaledWidth;
+  }
+
+  /**
+   * Returns the height of the largest scaled-down image that the TurboJPEG
+   * decompressor can generate without exceeding the desired image width and
+   * height.
+   *
+   * @param desiredWidth desired width (in pixels) of the decompressed image.
+   * Setting this to 0 is the same as setting it to the width of the JPEG image
+   * (in other words, the width will not be considered when determining the
+   * scaled image size.)
+   *
+   * @param desiredHeight desired height (in pixels) of the decompressed image.
+   * Setting this to 0 is the same as setting it to the height of the JPEG
+   * image (in other words, the height will not be considered when determining
+   * the scaled image size.)
+   *
+   * @return the height of the largest scaled-down image that the TurboJPEG
+   * decompressor can generate without exceeding the desired image width and
+   * height.
+   */
+  public int getScaledHeight(int desiredWidth, int desiredHeight) {
+    if (jpegWidth < 1 || jpegHeight < 1)
+      throw new IllegalStateException(NO_ASSOC_ERROR);
+    if (desiredWidth < 0 || desiredHeight < 0)
+      throw new IllegalArgumentException("Invalid argument in getScaledHeight()");
+    TJScalingFactor[] sf = TJ.getScalingFactors();
+    if (desiredWidth == 0)
+      desiredWidth = jpegWidth;
+    if (desiredHeight == 0)
+      desiredHeight = jpegHeight;
+    int scaledWidth = jpegWidth, scaledHeight = jpegHeight;
+    for (int i = 0; i < sf.length; i++) {
+      scaledWidth = sf[i].getScaled(jpegWidth);
+      scaledHeight = sf[i].getScaled(jpegHeight);
+      if (scaledWidth <= desiredWidth && scaledHeight <= desiredHeight)
+        break;
+    }
+    if (scaledWidth > desiredWidth || scaledHeight > desiredHeight)
+      throw new IllegalArgumentException("Could not scale down to desired image dimensions");
+    return scaledHeight;
+  }
+
+  /**
+   * Decompress the JPEG source image or decode the YUV source image associated
+   * with this decompressor instance and output a grayscale, RGB, or CMYK image
+   * to the given destination buffer.
+   * <p>
+   * NOTE: The output image is fully recoverable if this method throws a
+   * non-fatal {@link TJException} (unless
+   * {@link TJ#FLAG_STOPONWARNING TJ.FLAG_STOPONWARNING} is specified.)
+   *
+   * @param dstBuf buffer that will receive the decompressed/decoded image.
+   * If the source image is a JPEG image, then this buffer should normally be
+   * <code>pitch * scaledHeight</code> bytes in size, where
+   * <code>scaledHeight</code> can be determined by calling <code>
+   * scalingFactor.{@link TJScalingFactor#getScaled getScaled}(jpegHeight)
+   * </code> with one of the scaling factors returned from {@link
+   * TJ#getScalingFactors} or by calling {@link #getScaledHeight}.  If the
+   * source image is a YUV image, then this buffer should normally be
+   * <code>pitch * height</code> bytes in size, where <code>height</code> is
+   * the height of the YUV image.  However, the buffer may also be larger than
+   * the dimensions of the source image, in which case the <code>x</code>,
+   * <code>y</code>, and <code>pitch</code> parameters can be used to specify
+   * the region into which the source image should be decompressed/decoded.
+   *
+   * @param x x offset (in pixels) of the region in the destination image into
+   * which the source image should be decompressed/decoded
+   *
+   * @param y y offset (in pixels) of the region in the destination image into
+   * which the source image should be decompressed/decoded
+   *
+   * @param desiredWidth If the source image is a JPEG image, then this
+   * specifies the desired width (in pixels) of the decompressed image (or
+   * image region.)  If the desired destination image dimensions are different
+   * than the source image dimensions, then TurboJPEG will use scaling in the
+   * JPEG decompressor to generate the largest possible image that will fit
+   * within the desired dimensions.  Setting this to 0 is the same as setting
+   * it to the width of the JPEG image (in other words, the width will not be
+   * considered when determining the scaled image size.)  This parameter is
+   * ignored if the source image is a YUV image.
+   *
+   * @param pitch bytes per line of the destination image.  Normally, this
+   * should be set to <code>scaledWidth * TJ.pixelSize(pixelFormat)</code> if
+   * the destination image is unpadded, but you can use this to, for instance,
+   * pad each line of the destination image to a 4-byte boundary or to
+   * decompress/decode the source image into a region of a larger image.  NOTE:
+   * if the source image is a JPEG image, then <code>scaledWidth</code> can be
+   * determined by calling <code>
+   * scalingFactor.{@link TJScalingFactor#getScaled getScaled}(jpegWidth)
+   * </code> or by calling {@link #getScaledWidth}.  If the source image is a
+   * YUV image, then <code>scaledWidth</code> is the width of the YUV image.
+   * Setting this parameter to 0 is the equivalent of setting it to
+   * <code>scaledWidth * TJ.pixelSize(pixelFormat)</code>.
+   *
+   * @param desiredHeight If the source image is a JPEG image, then this
+   * specifies the desired height (in pixels) of the decompressed image (or
+   * image region.)  If the desired destination image dimensions are different
+   * than the source image dimensions, then TurboJPEG will use scaling in the
+   * JPEG decompressor to generate the largest possible image that will fit
+   * within the desired dimensions.  Setting this to 0 is the same as setting
+   * it to the height of the JPEG image (in other words, the height will not be
+   * considered when determining the scaled image size.)  This parameter is
+   * ignored if the source image is a YUV image.
+   *
+   * @param pixelFormat pixel format of the decompressed/decoded image (one of
+   * {@link TJ#PF_RGB TJ.PF_*})
+   *
+   * @param flags the bitwise OR of one or more of
+   * {@link TJ#FLAG_BOTTOMUP TJ.FLAG_*}
+   */
+  public void decompress(byte[] dstBuf, int x, int y, int desiredWidth,
+                         int pitch, int desiredHeight, int pixelFormat,
+                         int flags) throws TJException {
+    if (jpegBuf == null && yuvImage == null)
+      throw new IllegalStateException(NO_ASSOC_ERROR);
+    if (dstBuf == null || x < 0 || y < 0 || pitch < 0 ||
+        (yuvImage != null && (desiredWidth < 0 || desiredHeight < 0)) ||
+        pixelFormat < 0 || pixelFormat >= TJ.NUMPF || flags < 0)
+      throw new IllegalArgumentException("Invalid argument in decompress()");
+    if (yuvImage != null)
+      decodeYUV(yuvImage.getPlanes(), yuvImage.getOffsets(),
+                yuvImage.getStrides(), yuvImage.getSubsamp(), dstBuf, x, y,
+                yuvImage.getWidth(), pitch, yuvImage.getHeight(), pixelFormat,
+                flags);
+    else {
+      if (x > 0 || y > 0)
+        decompress(jpegBuf, jpegBufSize, dstBuf, x, y, desiredWidth, pitch,
+                   desiredHeight, pixelFormat, flags);
+      else
+        decompress(jpegBuf, jpegBufSize, dstBuf, desiredWidth, pitch,
+                   desiredHeight, pixelFormat, flags);
+    }
+  }
+
+  /**
+   * @deprecated Use
+   * {@link #decompress(byte[], int, int, int, int, int, int, int)} instead.
+   */
+  @SuppressWarnings("checkstyle:JavadocMethod")
+  @Deprecated
+  public void decompress(byte[] dstBuf, int desiredWidth, int pitch,
+                         int desiredHeight, int pixelFormat, int flags)
+                         throws TJException {
+    decompress(dstBuf, 0, 0, desiredWidth, pitch, desiredHeight, pixelFormat,
+               flags);
+  }
+
+  /**
+   * Decompress the JPEG source image associated with this decompressor
+   * instance and return a buffer containing the decompressed image.
+   *
+   * @param desiredWidth see
+   * {@link #decompress(byte[], int, int, int, int, int, int, int)}
+   * for description
+   *
+   * @param pitch see
+   * {@link #decompress(byte[], int, int, int, int, int, int, int)}
+   * for description
+   *
+   * @param desiredHeight see
+   * {@link #decompress(byte[], int, int, int, int, int, int, int)}
+   * for description
+   *
+   * @param pixelFormat pixel format of the decompressed image (one of
+   * {@link TJ#PF_RGB TJ.PF_*})
+   *
+   * @param flags the bitwise OR of one or more of
+   * {@link TJ#FLAG_BOTTOMUP TJ.FLAG_*}
+   *
+   * @return a buffer containing the decompressed image.
+   */
+  public byte[] decompress(int desiredWidth, int pitch, int desiredHeight,
+                           int pixelFormat, int flags) throws TJException {
+    if (pitch < 0 ||
+        (yuvImage == null && (desiredWidth < 0 || desiredHeight < 0)) ||
+        pixelFormat < 0 || pixelFormat >= TJ.NUMPF || flags < 0)
+      throw new IllegalArgumentException("Invalid argument in decompress()");
+    int pixelSize = TJ.getPixelSize(pixelFormat);
+    int scaledWidth = getScaledWidth(desiredWidth, desiredHeight);
+    int scaledHeight = getScaledHeight(desiredWidth, desiredHeight);
+    if (pitch == 0)
+      pitch = scaledWidth * pixelSize;
+    byte[] buf = new byte[pitch * scaledHeight];
+    decompress(buf, desiredWidth, pitch, desiredHeight, pixelFormat, flags);
+    return buf;
+  }
+
+  /**
+   * Decompress the JPEG source image associated with this decompressor
+   * instance into a YUV planar image and store it in the given
+   * <code>YUVImage</code> instance.  This method performs JPEG decompression
+   * but leaves out the color conversion step, so a planar YUV image is
+   * generated instead of an RGB or grayscale image.  This method cannot be
+   * used to decompress JPEG source images with the CMYK or YCCK colorspace.
+   * <p>
+   * NOTE: The YUV planar output image is fully recoverable if this method
+   * throws a non-fatal {@link TJException} (unless
+   * {@link TJ#FLAG_STOPONWARNING TJ.FLAG_STOPONWARNING} is specified.)
+   *
+   * @param dstImage {@link YUVImage} instance that will receive the YUV planar
+   * image.  The level of subsampling specified in this <code>YUVImage</code>
+   * instance must match that of the JPEG image, and the width and height
+   * specified in the <code>YUVImage</code> instance must match one of the
+   * scaled image sizes that TurboJPEG is capable of generating from the JPEG
+   * source image.
+   *
+   * @param flags the bitwise OR of one or more of
+   * {@link TJ#FLAG_BOTTOMUP TJ.FLAG_*}
+   */
+  public void decompressToYUV(YUVImage dstImage, int flags)
+                              throws TJException {
+    if (jpegBuf == null)
+      throw new IllegalStateException(NO_ASSOC_ERROR);
+    if (dstImage == null || flags < 0)
+      throw new IllegalArgumentException("Invalid argument in decompressToYUV()");
+    int scaledWidth = getScaledWidth(dstImage.getWidth(),
+                                     dstImage.getHeight());
+    int scaledHeight = getScaledHeight(dstImage.getWidth(),
+                                       dstImage.getHeight());
+    if (scaledWidth != dstImage.getWidth() ||
+        scaledHeight != dstImage.getHeight())
+      throw new IllegalArgumentException("YUVImage dimensions do not match one of the scaled image sizes that TurboJPEG is capable of generating.");
+    if (jpegSubsamp != dstImage.getSubsamp())
+      throw new IllegalArgumentException("YUVImage subsampling level does not match that of the JPEG image");
+
+    decompressToYUV(jpegBuf, jpegBufSize, dstImage.getPlanes(),
+                    dstImage.getOffsets(), dstImage.getWidth(),
+                    dstImage.getStrides(), dstImage.getHeight(), flags);
+  }
+
+  /**
+   * @deprecated Use {@link #decompressToYUV(YUVImage, int)} instead.
+   */
+  @SuppressWarnings("checkstyle:JavadocMethod")
+  @Deprecated
+  public void decompressToYUV(byte[] dstBuf, int flags) throws TJException {
+    YUVImage dstYUVImage = new YUVImage(dstBuf, jpegWidth, 4, jpegHeight,
+                                        jpegSubsamp);
+    decompressToYUV(dstYUVImage, flags);
+  }
+
+  /**
+   * Decompress the JPEG source image associated with this decompressor
+   * instance into a set of Y, U (Cb), and V (Cr) image planes and return a
+   * <code>YUVImage</code> instance containing the decompressed image planes.
+   * This method performs JPEG decompression but leaves out the color
+   * conversion step, so a planar YUV image is generated instead of an RGB or
+   * grayscale image.  This method cannot be used to decompress JPEG source
+   * images with the CMYK or YCCK colorspace.
+   *
+   * @param desiredWidth desired width (in pixels) of the YUV image.  If the
+   * desired image dimensions are different than the dimensions of the JPEG
+   * image being decompressed, then TurboJPEG will use scaling in the JPEG
+   * decompressor to generate the largest possible image that will fit within
+   * the desired dimensions.  Setting this to 0 is the same as setting it to
+   * the width of the JPEG image (in other words, the width will not be
+   * considered when determining the scaled image size.)
+   *
+   * @param strides an array of integers, each specifying the number of bytes
+   * per line in the corresponding plane of the output image.  Setting the
+   * stride for any plane to 0 is the same as setting it to the scaled
+   * component width of the plane.  If <tt>strides</tt> is NULL, then the
+   * strides for all planes will be set to their respective scaled component
+   * widths.  You can adjust the strides in order to add an arbitrary amount of
+   * line padding to each plane.
+   *
+   * @param desiredHeight desired height (in pixels) of the YUV image.  If the
+   * desired image dimensions are different than the dimensions of the JPEG
+   * image being decompressed, then TurboJPEG will use scaling in the JPEG
+   * decompressor to generate the largest possible image that will fit within
+   * the desired dimensions.  Setting this to 0 is the same as setting it to
+   * the height of the JPEG image (in other words, the height will not be
+   * considered when determining the scaled image size.)
+   *
+   * @param flags the bitwise OR of one or more of
+   * {@link TJ#FLAG_BOTTOMUP TJ.FLAG_*}
+   *
+   * @return a YUV planar image.
+   */
+  public YUVImage decompressToYUV(int desiredWidth, int[] strides,
+                                  int desiredHeight,
+                                  int flags) throws TJException {
+    if (flags < 0)
+      throw new IllegalArgumentException("Invalid argument in decompressToYUV()");
+    if (jpegWidth < 1 || jpegHeight < 1 || jpegSubsamp < 0)
+      throw new IllegalStateException(NO_ASSOC_ERROR);
+    if (jpegSubsamp >= TJ.NUMSAMP)
+      throw new IllegalStateException("JPEG header information is invalid");
+    if (yuvImage != null)
+      throw new IllegalStateException("Source image is the wrong type");
+
+    int scaledWidth = getScaledWidth(desiredWidth, desiredHeight);
+    int scaledHeight = getScaledHeight(desiredWidth, desiredHeight);
+    YUVImage dstYUVImage = new YUVImage(scaledWidth, null, scaledHeight,
+                                        jpegSubsamp);
+    decompressToYUV(dstYUVImage, flags);
+    return dstYUVImage;
+  }
+
+  /**
+   * Decompress the JPEG source image associated with this decompressor
+   * instance into a unified YUV planar image buffer and return a
+   * <code>YUVImage</code> instance containing the decompressed image.  This
+   * method performs JPEG decompression but leaves out the color conversion
+   * step, so a planar YUV image is generated instead of an RGB or grayscale
+   * image.  This method cannot be used to decompress JPEG source images with
+   * the CMYK or YCCK colorspace.
+   *
+   * @param desiredWidth desired width (in pixels) of the YUV image.  If the
+   * desired image dimensions are different than the dimensions of the JPEG
+   * image being decompressed, then TurboJPEG will use scaling in the JPEG
+   * decompressor to generate the largest possible image that will fit within
+   * the desired dimensions.  Setting this to 0 is the same as setting it to
+   * the width of the JPEG image (in other words, the width will not be
+   * considered when determining the scaled image size.)
+   *
+   * @param pad the width of each line in each plane of the YUV image will be
+   * padded to the nearest multiple of this number of bytes (must be a power of
+   * 2.)
+   *
+   * @param desiredHeight desired height (in pixels) of the YUV image.  If the
+   * desired image dimensions are different than the dimensions of the JPEG
+   * image being decompressed, then TurboJPEG will use scaling in the JPEG
+   * decompressor to generate the largest possible image that will fit within
+   * the desired dimensions.  Setting this to 0 is the same as setting it to
+   * the height of the JPEG image (in other words, the height will not be
+   * considered when determining the scaled image size.)
+   *
+   * @param flags the bitwise OR of one or more of
+   * {@link TJ#FLAG_BOTTOMUP TJ.FLAG_*}
+   *
+   * @return a YUV planar image.
+   */
+  public YUVImage decompressToYUV(int desiredWidth, int pad, int desiredHeight,
+                                  int flags) throws TJException {
+    if (flags < 0)
+      throw new IllegalArgumentException("Invalid argument in decompressToYUV()");
+    if (jpegWidth < 1 || jpegHeight < 1 || jpegSubsamp < 0)
+      throw new IllegalStateException(NO_ASSOC_ERROR);
+    if (jpegSubsamp >= TJ.NUMSAMP)
+      throw new IllegalStateException("JPEG header information is invalid");
+    if (yuvImage != null)
+      throw new IllegalStateException("Source image is the wrong type");
+
+    int scaledWidth = getScaledWidth(desiredWidth, desiredHeight);
+    int scaledHeight = getScaledHeight(desiredWidth, desiredHeight);
+    YUVImage dstYUVImage = new YUVImage(scaledWidth, pad, scaledHeight,
+                                        jpegSubsamp);
+    decompressToYUV(dstYUVImage, flags);
+    return dstYUVImage;
+  }
+
+  /**
+   * @deprecated Use {@link #decompressToYUV(int, int, int, int)} instead.
+   */
+  @SuppressWarnings("checkstyle:JavadocMethod")
+  @Deprecated
+  public byte[] decompressToYUV(int flags) throws TJException {
+    YUVImage dstYUVImage = new YUVImage(jpegWidth, 4, jpegHeight, jpegSubsamp);
+    decompressToYUV(dstYUVImage, flags);
+    return dstYUVImage.getBuf();
+  }
+
+  /**
+   * Decompress the JPEG source image or decode the YUV source image associated
+   * with this decompressor instance and output a grayscale, RGB, or CMYK image
+   * to the given destination buffer.
+   * <p>
+   * NOTE: The output image is fully recoverable if this method throws a
+   * non-fatal {@link TJException} (unless
+   * {@link TJ#FLAG_STOPONWARNING TJ.FLAG_STOPONWARNING} is specified.)
+   *
+   * @param dstBuf buffer that will receive the decompressed/decoded image.
+   * If the source image is a JPEG image, then this buffer should normally be
+   * <code>stride * scaledHeight</code> pixels in size, where
+   * <code>scaledHeight</code> can be determined by calling <code>
+   * scalingFactor.{@link TJScalingFactor#getScaled getScaled}(jpegHeight)
+   * </code> with one of the scaling factors returned from {@link
+   * TJ#getScalingFactors} or by calling {@link #getScaledHeight}.  If the
+   * source image is a YUV image, then this buffer should normally be
+   * <code>stride * height</code> pixels in size, where <code>height</code> is
+   * the height of the YUV image.  However, the buffer may also be larger than
+   * the dimensions of the JPEG image, in which case the <code>x</code>,
+   * <code>y</code>, and <code>stride</code> parameters can be used to specify
+   * the region into which the source image should be decompressed.
+   *
+   * @param x x offset (in pixels) of the region in the destination image into
+   * which the source image should be decompressed/decoded
+   *
+   * @param y y offset (in pixels) of the region in the destination image into
+   * which the source image should be decompressed/decoded
+   *
+   * @param desiredWidth If the source image is a JPEG image, then this
+   * specifies the desired width (in pixels) of the decompressed image (or
+   * image region.)  If the desired destination image dimensions are different
+   * than the source image dimensions, then TurboJPEG will use scaling in the
+   * JPEG decompressor to generate the largest possible image that will fit
+   * within the desired dimensions.  Setting this to 0 is the same as setting
+   * it to the width of the JPEG image (in other words, the width will not be
+   * considered when determining the scaled image size.)  This parameter is
+   * ignored if the source image is a YUV image.
+   *
+   * @param stride pixels per line of the destination image.  Normally, this
+   * should be set to <code>scaledWidth</code>, but you can use this to, for
+   * instance, decompress the JPEG image into a region of a larger image.
+   * NOTE: if the source image is a JPEG image, then <code>scaledWidth</code>
+   * can be determined by calling <code>
+   * scalingFactor.{@link TJScalingFactor#getScaled getScaled}(jpegWidth)
+   * </code> or by calling {@link #getScaledWidth}.  If the source image is a
+   * YUV image, then <code>scaledWidth</code> is the width of the YUV image.
+   * Setting this parameter to 0 is the equivalent of setting it to
+   * <code>scaledWidth</code>.
+   *
+   * @param desiredHeight If the source image is a JPEG image, then this
+   * specifies the desired height (in pixels) of the decompressed image (or
+   * image region.)  If the desired destination image dimensions are different
+   * than the source image dimensions, then TurboJPEG will use scaling in the
+   * JPEG decompressor to generate the largest possible image that will fit
+   * within the desired dimensions.  Setting this to 0 is the same as setting
+   * it to the height of the JPEG image (in other words, the height will not be
+   * considered when determining the scaled image size.)  This parameter is
+   * ignored if the source image is a YUV image.
+   *
+   * @param pixelFormat pixel format of the decompressed image (one of
+   * {@link TJ#PF_RGB TJ.PF_*})
+   *
+   * @param flags the bitwise OR of one or more of
+   * {@link TJ#FLAG_BOTTOMUP TJ.FLAG_*}
+   */
+  public void decompress(int[] dstBuf, int x, int y, int desiredWidth,
+                         int stride, int desiredHeight, int pixelFormat,
+                         int flags) throws TJException {
+    if (jpegBuf == null && yuvImage == null)
+      throw new IllegalStateException(NO_ASSOC_ERROR);
+    if (dstBuf == null || x < 0 || y < 0 || stride < 0 ||
+        (yuvImage != null && (desiredWidth < 0 || desiredHeight < 0)) ||
+        pixelFormat < 0 || pixelFormat >= TJ.NUMPF || flags < 0)
+      throw new IllegalArgumentException("Invalid argument in decompress()");
+    if (yuvImage != null)
+      decodeYUV(yuvImage.getPlanes(), yuvImage.getOffsets(),
+                yuvImage.getStrides(), yuvImage.getSubsamp(), dstBuf, x, y,
+                yuvImage.getWidth(), stride, yuvImage.getHeight(), pixelFormat,
+                flags);
+    else
+      decompress(jpegBuf, jpegBufSize, dstBuf, x, y, desiredWidth, stride,
+                 desiredHeight, pixelFormat, flags);
+  }
+
+  /**
+   * Decompress the JPEG source image or decode the YUV source image associated
+   * with this decompressor instance and output a decompressed/decoded image to
+   * the given <code>BufferedImage</code> instance.
+   * <p>
+   * NOTE: The output image is fully recoverable if this method throws a
+   * non-fatal {@link TJException} (unless
+   * {@link TJ#FLAG_STOPONWARNING TJ.FLAG_STOPONWARNING} is specified.)
+   *
+   * @param dstImage a <code>BufferedImage</code> instance that will receive
+   * the decompressed/decoded image.  If the source image is a JPEG image, then
+   * the width and height of the <code>BufferedImage</code> instance must match
+   * one of the scaled image sizes that TurboJPEG is capable of generating from
+   * the JPEG image.  If the source image is a YUV image, then the width and
+   * height of the <code>BufferedImage</code> instance must match the width and
+   * height of the YUV image.
+   *
+   * @param flags the bitwise OR of one or more of
+   * {@link TJ#FLAG_BOTTOMUP TJ.FLAG_*}
+   */
+  public void decompress(BufferedImage dstImage, int flags)
+                         throws TJException {
+    if (dstImage == null || flags < 0)
+      throw new IllegalArgumentException("Invalid argument in decompress()");
+    int desiredWidth = dstImage.getWidth();
+    int desiredHeight = dstImage.getHeight();
+    int scaledWidth, scaledHeight;
+
+    if (yuvImage != null) {
+      if (desiredWidth != yuvImage.getWidth() ||
+          desiredHeight != yuvImage.getHeight())
+        throw new IllegalArgumentException("BufferedImage dimensions do not match the dimensions of the source image.");
+      scaledWidth = yuvImage.getWidth();
+      scaledHeight = yuvImage.getHeight();
+    } else {
+      scaledWidth = getScaledWidth(desiredWidth, desiredHeight);
+      scaledHeight = getScaledHeight(desiredWidth, desiredHeight);
+      if (scaledWidth != desiredWidth || scaledHeight != desiredHeight)
+        throw new IllegalArgumentException("BufferedImage dimensions do not match one of the scaled image sizes that TurboJPEG is capable of generating.");
+    }
+    int pixelFormat;  boolean intPixels = false;
+    if (byteOrder == null)
+      byteOrder = ByteOrder.nativeOrder();
+    switch (dstImage.getType()) {
+    case BufferedImage.TYPE_3BYTE_BGR:
+      pixelFormat = TJ.PF_BGR;  break;
+    case BufferedImage.TYPE_4BYTE_ABGR:
+    case BufferedImage.TYPE_4BYTE_ABGR_PRE:
+      pixelFormat = TJ.PF_XBGR;  break;
+    case BufferedImage.TYPE_BYTE_GRAY:
+      pixelFormat = TJ.PF_GRAY;  break;
+    case BufferedImage.TYPE_INT_BGR:
+      if (byteOrder == ByteOrder.BIG_ENDIAN)
+        pixelFormat = TJ.PF_XBGR;
+      else
+        pixelFormat = TJ.PF_RGBX;
+      intPixels = true;  break;
+    case BufferedImage.TYPE_INT_RGB:
+      if (byteOrder == ByteOrder.BIG_ENDIAN)
+        pixelFormat = TJ.PF_XRGB;
+      else
+        pixelFormat = TJ.PF_BGRX;
+      intPixels = true;  break;
+    case BufferedImage.TYPE_INT_ARGB:
+    case BufferedImage.TYPE_INT_ARGB_PRE:
+      if (byteOrder == ByteOrder.BIG_ENDIAN)
+        pixelFormat = TJ.PF_ARGB;
+      else
+        pixelFormat = TJ.PF_BGRA;
+      intPixels = true;  break;
+    default:
+      throw new IllegalArgumentException("Unsupported BufferedImage format");
+    }
+    WritableRaster wr = dstImage.getRaster();
+    if (intPixels) {
+      SinglePixelPackedSampleModel sm =
+        (SinglePixelPackedSampleModel)dstImage.getSampleModel();
+      int stride = sm.getScanlineStride();
+      DataBufferInt db = (DataBufferInt)wr.getDataBuffer();
+      int[] buf = db.getData();
+      if (yuvImage != null)
+        decodeYUV(yuvImage.getPlanes(), yuvImage.getOffsets(),
+                  yuvImage.getStrides(), yuvImage.getSubsamp(), buf, 0, 0,
+                  yuvImage.getWidth(), stride, yuvImage.getHeight(),
+                  pixelFormat, flags);
+      else {
+        if (jpegBuf == null)
+          throw new IllegalStateException(NO_ASSOC_ERROR);
+        decompress(jpegBuf, jpegBufSize, buf, 0, 0, scaledWidth, stride,
+                   scaledHeight, pixelFormat, flags);
+      }
+    } else {
+      ComponentSampleModel sm =
+        (ComponentSampleModel)dstImage.getSampleModel();
+      int pixelSize = sm.getPixelStride();
+      if (pixelSize != TJ.getPixelSize(pixelFormat))
+        throw new IllegalArgumentException("Inconsistency between pixel format and pixel size in BufferedImage");
+      int pitch = sm.getScanlineStride();
+      DataBufferByte db = (DataBufferByte)wr.getDataBuffer();
+      byte[] buf = db.getData();
+      decompress(buf, 0, 0, scaledWidth, pitch, scaledHeight, pixelFormat,
+                 flags);
+    }
+  }
+
+  /**
+   * Decompress the JPEG source image or decode the YUV source image associated
+   * with this decompressor instance and return a <code>BufferedImage</code>
+   * instance containing the decompressed/decoded image.
+   *
+   * @param desiredWidth see
+   * {@link #decompress(byte[], int, int, int, int, int, int, int)} for
+   * description
+   *
+   * @param desiredHeight see
+   * {@link #decompress(byte[], int, int, int, int, int, int, int)} for
+   * description
+   *
+   * @param bufferedImageType the image type of the <code>BufferedImage</code>
+   * instance that will be created (for instance,
+   * <code>BufferedImage.TYPE_INT_RGB</code>)
+   *
+   * @param flags the bitwise OR of one or more of
+   * {@link TJ#FLAG_BOTTOMUP TJ.FLAG_*}
+   *
+   * @return a <code>BufferedImage</code> instance containing the
+   * decompressed/decoded image.
+   */
+  public BufferedImage decompress(int desiredWidth, int desiredHeight,
+                                  int bufferedImageType, int flags)
+                                  throws TJException {
+    if ((yuvImage == null && (desiredWidth < 0 || desiredHeight < 0)) ||
+        flags < 0)
+      throw new IllegalArgumentException("Invalid argument in decompress()");
+    int scaledWidth = getScaledWidth(desiredWidth, desiredHeight);
+    int scaledHeight = getScaledHeight(desiredWidth, desiredHeight);
+    BufferedImage img = new BufferedImage(scaledWidth, scaledHeight,
+                                          bufferedImageType);
+    decompress(img, flags);
+    return img;
+  }
+
+  /**
+   * Free the native structures associated with this decompressor instance.
+   */
+  @Override
+  public void close() throws TJException {
+    if (handle != 0)
+      destroy();
+  }
+
+  @SuppressWarnings("checkstyle:DesignForExtension")
+  @Override
+  protected void finalize() throws Throwable {
+    try {
+      close();
+    } catch (TJException e) {
+    } finally {
+      super.finalize();
+    }
+  };
+
+  private native void init() throws TJException;
+
+  private native void destroy() throws TJException;
+
+  private native void decompressHeader(byte[] srcBuf, int size)
+    throws TJException;
+
+  @Deprecated
+  private native void decompress(byte[] srcBuf, int size, byte[] dstBuf,
+    int desiredWidth, int pitch, int desiredHeight, int pixelFormat, int flags)
+    throws TJException;
+
+  private native void decompress(byte[] srcBuf, int size, byte[] dstBuf, int x,
+    int y, int desiredWidth, int pitch, int desiredHeight, int pixelFormat,
+    int flags) throws TJException;
+
+  @Deprecated
+  private native void decompress(byte[] srcBuf, int size, int[] dstBuf,
+    int desiredWidth, int stride, int desiredHeight, int pixelFormat,
+    int flags) throws TJException;
+
+  private native void decompress(byte[] srcBuf, int size, int[] dstBuf, int x,
+    int y, int desiredWidth, int stride, int desiredHeight, int pixelFormat,
+    int flags) throws TJException;
+
+  @Deprecated
+  private native void decompressToYUV(byte[] srcBuf, int size, byte[] dstBuf,
+    int flags) throws TJException;
+
+  private native void decompressToYUV(byte[] srcBuf, int size,
+    byte[][] dstPlanes, int[] dstOffsets, int desiredWidth, int[] dstStrides,
+    int desiredheight, int flags) throws TJException;
+
+  private native void decodeYUV(byte[][] srcPlanes, int[] srcOffsets,
+    int[] srcStrides, int subsamp, byte[] dstBuf, int x, int y, int width,
+    int pitch, int height, int pixelFormat, int flags) throws TJException;
+
+  private native void decodeYUV(byte[][] srcPlanes, int[] srcOffsets,
+    int[] srcStrides, int subsamp, int[] dstBuf, int x, int y, int width,
+    int stride, int height, int pixelFormat, int flags) throws TJException;
+
+  static {
+    TJLoader.load();
+  }
+
+  protected long handle = 0;
+  protected byte[] jpegBuf = null;
+  protected int jpegBufSize = 0;
+  protected YUVImage yuvImage = null;
+  protected int jpegWidth = 0;
+  protected int jpegHeight = 0;
+  protected int jpegSubsamp = -1;
+  protected int jpegColorspace = -1;
+  private ByteOrder byteOrder = null;
+}
diff --git a/3rdparty/libjpeg/src/java/org/libjpegturbo/turbojpeg/TJException.java b/3rdparty/libjpeg/src/java/org/libjpegturbo/turbojpeg/TJException.java
new file mode 100644
index 00000000..d03a2565
--- /dev/null
+++ b/3rdparty/libjpeg/src/java/org/libjpegturbo/turbojpeg/TJException.java
@@ -0,0 +1,78 @@
+/*
+ * Copyright (C)2015 Viktor Szathmáry.  All Rights Reserved.
+ * Copyright (C)2017-2018 D. R. Commander.  All Rights Reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright notice,
+ *   this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright notice,
+ *   this list of conditions and the following disclaimer in the documentation
+ *   and/or other materials provided with the distribution.
+ * - Neither the name of the libjpeg-turbo Project nor the names of its
+ *   contributors may be used to endorse or promote products derived from this
+ *   software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE 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 HOLDERS 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.
+ */
+
+package org.libjpegturbo.turbojpeg;
+
+import java.io.IOException;
+
+@SuppressWarnings("checkstyle:JavadocType")
+public class TJException extends IOException {
+
+  private static final long serialVersionUID = 1L;
+
+  @SuppressWarnings("checkstyle:JavadocMethod")
+  public TJException() {
+    super();
+  }
+
+  @SuppressWarnings("checkstyle:JavadocMethod")
+  public TJException(String message, Throwable cause) {
+    super(message, cause);
+  }
+
+  @SuppressWarnings("checkstyle:JavadocMethod")
+  public TJException(String message) {
+    super(message);
+  }
+
+  @SuppressWarnings("checkstyle:JavadocMethod")
+  public TJException(String message, int code) {
+    super(message);
+    if (errorCode >= 0 && errorCode < TJ.NUMERR)
+      errorCode = code;
+  }
+
+  @SuppressWarnings("checkstyle:JavadocMethod")
+  public TJException(Throwable cause) {
+    super(cause);
+  }
+
+  /**
+   * Returns a code (one of {@link TJ TJ.ERR_*}) indicating the severity of the
+   * last error.
+   *
+   * @return a code (one of {@link TJ TJ.ERR_*}) indicating the severity of the
+   * last error.
+   */
+  public int getErrorCode() {
+    return errorCode;
+  }
+
+  private int errorCode = TJ.ERR_FATAL;
+}
diff --git a/3rdparty/libjpeg/src/java/org/libjpegturbo/turbojpeg/TJLoader-unix.java.in b/3rdparty/libjpeg/src/java/org/libjpegturbo/turbojpeg/TJLoader-unix.java.in
new file mode 100644
index 00000000..d8cc4950
--- /dev/null
+++ b/3rdparty/libjpeg/src/java/org/libjpegturbo/turbojpeg/TJLoader-unix.java.in
@@ -0,0 +1,59 @@
+/*
+ * Copyright (C)2011-2013, 2016, 2020 D. R. Commander.  All Rights Reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright notice,
+ *   this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright notice,
+ *   this list of conditions and the following disclaimer in the documentation
+ *   and/or other materials provided with the distribution.
+ * - Neither the name of the libjpeg-turbo Project nor the names of its
+ *   contributors may be used to endorse or promote products derived from this
+ *   software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE 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 HOLDERS 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.
+ */
+
+package org.libjpegturbo.turbojpeg;
+
+final class TJLoader {
+  static void load() {
+    try {
+      System.loadLibrary("turbojpeg");
+    } catch (java.lang.UnsatisfiedLinkError e) {
+      String os = System.getProperty("os.name").toLowerCase();
+      if (os.indexOf("mac") >= 0) {
+        try {
+          System.load("@CMAKE_INSTALL_FULL_LIBDIR@/libturbojpeg.dylib");
+        } catch (java.lang.UnsatisfiedLinkError e2) {
+          System.load("/usr/lib/libturbojpeg.dylib");
+        }
+      } else {
+        try {
+          System.load("@CMAKE_INSTALL_FULL_LIBDIR@/libturbojpeg.so");
+        } catch (java.lang.UnsatisfiedLinkError e3) {
+          String libdir = "@CMAKE_INSTALL_FULL_LIBDIR@";
+          if (libdir.equals("@CMAKE_INSTALL_DEFAULT_PREFIX@/lib64")) {
+            System.load("@CMAKE_INSTALL_DEFAULT_PREFIX@/lib32/libturbojpeg.so");
+          } else if (libdir.equals("@CMAKE_INSTALL_DEFAULT_PREFIX@/lib32")) {
+            System.load("@CMAKE_INSTALL_DEFAULT_PREFIX@/lib64/libturbojpeg.so");
+          } else {
+            throw e3;
+          }
+        }
+      }
+    }
+  }
+}
diff --git a/3rdparty/libjpeg/src/java/org/libjpegturbo/turbojpeg/TJLoader-win.java.in b/3rdparty/libjpeg/src/java/org/libjpegturbo/turbojpeg/TJLoader-win.java.in
new file mode 100644
index 00000000..83977806
--- /dev/null
+++ b/3rdparty/libjpeg/src/java/org/libjpegturbo/turbojpeg/TJLoader-win.java.in
@@ -0,0 +1,35 @@
+/*
+ * Copyright (C)2011 D. R. Commander.  All Rights Reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright notice,
+ *   this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright notice,
+ *   this list of conditions and the following disclaimer in the documentation
+ *   and/or other materials provided with the distribution.
+ * - Neither the name of the libjpeg-turbo Project nor the names of its
+ *   contributors may be used to endorse or promote products derived from this
+ *   software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE 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 HOLDERS 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.
+ */
+
+package org.libjpegturbo.turbojpeg;
+
+final class TJLoader {
+  static void load() {
+    System.loadLibrary("@TURBOJPEG_DLL_NAME@");
+  }
+}
diff --git a/3rdparty/libjpeg/src/java/org/libjpegturbo/turbojpeg/TJScalingFactor.java b/3rdparty/libjpeg/src/java/org/libjpegturbo/turbojpeg/TJScalingFactor.java
new file mode 100644
index 00000000..ccf91797
--- /dev/null
+++ b/3rdparty/libjpeg/src/java/org/libjpegturbo/turbojpeg/TJScalingFactor.java
@@ -0,0 +1,115 @@
+/*
+ * Copyright (C)2011, 2018 D. R. Commander.  All Rights Reserved.
+ * Copyright (C)2015 Viktor Szathmáry.  All Rights Reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright notice,
+ *   this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright notice,
+ *   this list of conditions and the following disclaimer in the documentation
+ *   and/or other materials provided with the distribution.
+ * - Neither the name of the libjpeg-turbo Project nor the names of its
+ *   contributors may be used to endorse or promote products derived from this
+ *   software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE 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 HOLDERS 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.
+ */
+
+package org.libjpegturbo.turbojpeg;
+
+/**
+ * Fractional scaling factor
+ */
+public class TJScalingFactor {
+
+  /**
+   * Create a TurboJPEG scaling factor instance.
+   *
+   * @param num numerator
+   * @param denom denominator
+   */
+  @SuppressWarnings("checkstyle:HiddenField")
+  public TJScalingFactor(int num, int denom) {
+    if (num < 1 || denom < 1)
+      throw new IllegalArgumentException("Numerator and denominator must be >= 1");
+    this.num = num;
+    this.denom = denom;
+  }
+
+  /**
+   * Returns numerator
+   *
+   * @return numerator
+   */
+  public int getNum() {
+    return num;
+  }
+
+  /**
+   * Returns denominator
+   *
+   * @return denominator
+   */
+  public int getDenom() {
+    return denom;
+  }
+
+  /**
+   * Returns the scaled value of <code>dimension</code>.  This function
+   * performs the integer equivalent of
+   * <code>ceil(dimension * scalingFactor)</code>.
+   *
+   * @param dimension width or height to multiply by this scaling factor
+   *
+   * @return the scaled value of <code>dimension</code>.
+   */
+  public int getScaled(int dimension) {
+    return (dimension * num + denom - 1) / denom;
+  }
+
+  /**
+   * Returns true or false, depending on whether this instance and
+   * <code>other</code> have the same numerator and denominator.
+   *
+   * @param other the scaling factor against which to compare this one
+   *
+   * @return true or false, depending on whether this instance and
+   * <code>other</code> have the same numerator and denominator.
+   */
+  public boolean equals(TJScalingFactor other) {
+    return this.num == other.num && this.denom == other.denom;
+  }
+
+  /**
+   * Returns true or false, depending on whether this instance is equal to
+   * 1/1.
+   *
+   * @return true or false, depending on whether this instance is equal to
+   * 1/1.
+   */
+  public boolean isOne() {
+    return num == 1 && denom == 1;
+  }
+
+  /**
+   * Numerator
+   */
+  private int num = 1;
+
+  /**
+   * Denominator
+   */
+  private int denom = 1;
+}
diff --git a/3rdparty/libjpeg/src/java/org/libjpegturbo/turbojpeg/TJTransform.java b/3rdparty/libjpeg/src/java/org/libjpegturbo/turbojpeg/TJTransform.java
new file mode 100644
index 00000000..41c4b45e
--- /dev/null
+++ b/3rdparty/libjpeg/src/java/org/libjpegturbo/turbojpeg/TJTransform.java
@@ -0,0 +1,227 @@
+/*
+ * Copyright (C)2011, 2013, 2018 D. R. Commander.  All Rights Reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright notice,
+ *   this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright notice,
+ *   this list of conditions and the following disclaimer in the documentation
+ *   and/or other materials provided with the distribution.
+ * - Neither the name of the libjpeg-turbo Project nor the names of its
+ *   contributors may be used to endorse or promote products derived from this
+ *   software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE 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 HOLDERS 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.
+ */
+
+package org.libjpegturbo.turbojpeg;
+
+import java.awt.*;
+
+/**
+ * Lossless transform parameters
+ */
+public class TJTransform extends Rectangle {
+
+  private static final long serialVersionUID = -127367705761430371L;
+
+  /**
+   * The number of lossless transform operations
+   */
+  public static final int NUMOP         = 8;
+  /**
+   * Do not transform the position of the image pixels.
+   */
+  public static final int OP_NONE       = 0;
+  /**
+   * Flip (mirror) image horizontally.  This transform is imperfect if there
+   * are any partial MCU blocks on the right edge.
+   * @see #OPT_PERFECT
+   */
+  public static final int OP_HFLIP      = 1;
+  /**
+   * Flip (mirror) image vertically.  This transform is imperfect if there are
+   * any partial MCU blocks on the bottom edge.
+   * @see #OPT_PERFECT
+   */
+  public static final int OP_VFLIP      = 2;
+  /**
+   * Transpose image (flip/mirror along upper left to lower right axis).  This
+   * transform is always perfect.
+   * @see #OPT_PERFECT
+   */
+  public static final int OP_TRANSPOSE  = 3;
+  /**
+   * Transverse transpose image (flip/mirror along upper right to lower left
+   * axis).  This transform is imperfect if there are any partial MCU blocks in
+   * the image.
+   * @see #OPT_PERFECT
+   */
+  public static final int OP_TRANSVERSE = 4;
+  /**
+   * Rotate image clockwise by 90 degrees.  This transform is imperfect if
+   * there are any partial MCU blocks on the bottom edge.
+   * @see #OPT_PERFECT
+   */
+  public static final int OP_ROT90      = 5;
+  /**
+   * Rotate image 180 degrees.  This transform is imperfect if there are any
+   * partial MCU blocks in the image.
+   * @see #OPT_PERFECT
+   */
+  public static final int OP_ROT180     = 6;
+  /**
+   * Rotate image counter-clockwise by 90 degrees.  This transform is imperfect
+   * if there are any partial MCU blocks on the right edge.
+   * @see #OPT_PERFECT
+   */
+  public static final int OP_ROT270     = 7;
+
+
+  /**
+   * This option will cause {@link TJTransformer#transform
+   * TJTransformer.transform()} to throw an exception if the transform is not
+   * perfect.  Lossless transforms operate on MCU blocks, whose size depends on
+   * the level of chrominance subsampling used.  If the image's width or height
+   * is not evenly divisible by the MCU block size (see {@link TJ#getMCUWidth}
+   * and {@link TJ#getMCUHeight}), then there will be partial MCU blocks on the
+   * right and/or bottom edges.   It is not possible to move these partial MCU
+   * blocks to the top or left of the image, so any transform that would
+   * require that is "imperfect."  If this option is not specified, then any
+   * partial MCU blocks that cannot be transformed will be left in place, which
+   * will create odd-looking strips on the right or bottom edge of the image.
+   */
+  public static final int OPT_PERFECT     = 1;
+  /**
+   * This option will discard any partial MCU blocks that cannot be
+   * transformed.
+   */
+  public static final int OPT_TRIM        = 2;
+  /**
+   * This option will enable lossless cropping.
+   */
+  public static final int OPT_CROP        = 4;
+  /**
+   * This option will discard the color data in the input image and produce
+   * a grayscale output image.
+   */
+  public static final int OPT_GRAY        = 8;
+  /**
+   * This option will prevent {@link TJTransformer#transform
+   * TJTransformer.transform()} from outputting a JPEG image for this
+   * particular transform.  This can be used in conjunction with a custom
+   * filter to capture the transformed DCT coefficients without transcoding
+   * them.
+   */
+  public static final int OPT_NOOUTPUT    = 16;
+  /**
+   * This option will enable progressive entropy coding in the output image
+   * generated by this particular transform.  Progressive entropy coding will
+   * generally improve compression relative to baseline entropy coding (the
+   * default), but it will reduce compression and decompression performance
+   * considerably.
+   */
+  public static final int OPT_PROGRESSIVE = 32;
+  /**
+   * This option will prevent {@link TJTransformer#transform
+   * TJTransformer.transform()} from copying any extra markers (including EXIF
+   * and ICC profile data) from the source image to the output image.
+   */
+  public static final int OPT_COPYNONE    = 64;
+
+
+  /**
+   * Create a new lossless transform instance.
+   */
+  public TJTransform() {
+  }
+
+  /**
+   * Create a new lossless transform instance with the given parameters.
+   *
+   * @param x the left boundary of the cropping region.  This must be evenly
+   * divisible by the MCU block width (see {@link TJ#getMCUWidth})
+   *
+   * @param y the upper boundary of the cropping region.  This must be evenly
+   * divisible by the MCU block height (see {@link TJ#getMCUHeight})
+   *
+   * @param w the width of the cropping region.  Setting this to 0 is the
+   * equivalent of setting it to (width of the source JPEG image -
+   * <code>x</code>).
+   *
+   * @param h the height of the cropping region.  Setting this to 0 is the
+   * equivalent of setting it to (height of the source JPEG image -
+   * <code>y</code>).
+   *
+   * @param op one of the transform operations (<code>OP_*</code>)
+   *
+   * @param options the bitwise OR of one or more of the transform options
+   * (<code>OPT_*</code>)
+   *
+   * @param cf an instance of an object that implements the {@link
+   * TJCustomFilter} interface, or null if no custom filter is needed
+   */
+  @SuppressWarnings("checkstyle:HiddenField")
+  public TJTransform(int x, int y, int w, int h, int op, int options,
+                     TJCustomFilter cf) {
+    super(x, y, w, h);
+    this.op = op;
+    this.options = options;
+    this.cf = cf;
+  }
+
+  /**
+   * Create a new lossless transform instance with the given parameters.
+   *
+   * @param r a <code>Rectangle</code> instance that specifies the cropping
+   * region.  See {@link
+   * #TJTransform(int, int, int, int, int, int, TJCustomFilter)} for more
+   * detail.
+   *
+   * @param op one of the transform operations (<code>OP_*</code>)
+   *
+   * @param options the bitwise OR of one or more of the transform options
+   * (<code>OPT_*</code>)
+   *
+   * @param cf an instance of an object that implements the {@link
+   * TJCustomFilter} interface, or null if no custom filter is needed
+   */
+  @SuppressWarnings("checkstyle:HiddenField")
+  public TJTransform(Rectangle r, int op, int options,
+                     TJCustomFilter cf) {
+    super(r);
+    this.op = op;
+    this.options = options;
+    this.cf = cf;
+  }
+
+  /**
+   * Transform operation (one of <code>OP_*</code>)
+   */
+  @SuppressWarnings("checkstyle:VisibilityModifier")
+  public int op = 0;
+
+  /**
+   * Transform options (bitwise OR of one or more of <code>OPT_*</code>)
+   */
+  @SuppressWarnings("checkstyle:VisibilityModifier")
+  public int options = 0;
+
+  /**
+   * Custom filter instance
+   */
+  @SuppressWarnings("checkstyle:VisibilityModifier")
+  public TJCustomFilter cf = null;
+}
diff --git a/3rdparty/libjpeg/src/java/org/libjpegturbo/turbojpeg/TJTransformer.java b/3rdparty/libjpeg/src/java/org/libjpegturbo/turbojpeg/TJTransformer.java
new file mode 100644
index 00000000..d7a56f35
--- /dev/null
+++ b/3rdparty/libjpeg/src/java/org/libjpegturbo/turbojpeg/TJTransformer.java
@@ -0,0 +1,163 @@
+/*
+ * Copyright (C)2011, 2013-2015 D. R. Commander.  All Rights Reserved.
+ * Copyright (C)2015 Viktor Szathmáry.  All Rights Reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright notice,
+ *   this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright notice,
+ *   this list of conditions and the following disclaimer in the documentation
+ *   and/or other materials provided with the distribution.
+ * - Neither the name of the libjpeg-turbo Project nor the names of its
+ *   contributors may be used to endorse or promote products derived from this
+ *   software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE 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 HOLDERS 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.
+ */
+
+package org.libjpegturbo.turbojpeg;
+
+/**
+ * TurboJPEG lossless transformer
+ */
+public class TJTransformer extends TJDecompressor {
+
+  /**
+   * Create a TurboJPEG lossless transformer instance.
+   */
+  public TJTransformer() throws TJException {
+    init();
+  }
+
+  /**
+   * Create a TurboJPEG lossless transformer instance and associate the JPEG
+   * image stored in <code>jpegImage</code> with the newly created instance.
+   *
+   * @param jpegImage JPEG image buffer (size of the JPEG image is assumed to
+   * be the length of the array.)  This buffer is not modified.
+   */
+  public TJTransformer(byte[] jpegImage) throws TJException {
+    init();
+    setSourceImage(jpegImage, jpegImage.length);
+  }
+
+  /**
+   * Create a TurboJPEG lossless transformer instance and associate the JPEG
+   * image of length <code>imageSize</code> bytes stored in
+   * <code>jpegImage</code> with the newly created instance.
+   *
+   * @param jpegImage JPEG image buffer.  This buffer is not modified.
+   *
+   * @param imageSize size of the JPEG image (in bytes)
+   */
+  public TJTransformer(byte[] jpegImage, int imageSize) throws TJException {
+    init();
+    setSourceImage(jpegImage, imageSize);
+  }
+
+  /**
+   * Losslessly transform the JPEG image associated with this transformer
+   * instance into one or more JPEG images stored in the given destination
+   * buffers.  Lossless transforms work by moving the raw coefficients from one
+   * JPEG image structure to another without altering the values of the
+   * coefficients.  While this is typically faster than decompressing the
+   * image, transforming it, and re-compressing it, lossless transforms are not
+   * free.  Each lossless transform requires reading and performing Huffman
+   * decoding on all of the coefficients in the source image, regardless of the
+   * size of the destination image.  Thus, this method provides a means of
+   * generating multiple transformed images from the same source or of applying
+   * multiple transformations simultaneously, in order to eliminate the need to
+   * read the source coefficients multiple times.
+   *
+   * @param dstBufs an array of image buffers.  <code>dstbufs[i]</code> will
+   * receive a JPEG image that has been transformed using the parameters in
+   * <code>transforms[i]</code>.  Use {@link TJ#bufSize} to determine the
+   * maximum size for each buffer based on the transformed or cropped width and
+   * height and the level of subsampling used in the source image.
+   *
+   * @param transforms an array of {@link TJTransform} instances, each of
+   * which specifies the transform parameters and/or cropping region for the
+   * corresponding transformed output image
+   *
+   * @param flags the bitwise OR of one or more of
+   * {@link TJ#FLAG_BOTTOMUP TJ.FLAG_*}
+   */
+  public void transform(byte[][] dstBufs, TJTransform[] transforms,
+                        int flags) throws TJException {
+    if (jpegBuf == null)
+      throw new IllegalStateException("JPEG buffer not initialized");
+    transformedSizes = transform(jpegBuf, jpegBufSize, dstBufs, transforms,
+                                 flags);
+  }
+
+  /**
+   * Losslessly transform the JPEG image associated with this transformer
+   * instance and return an array of {@link TJDecompressor} instances, each of
+   * which has a transformed JPEG image associated with it.
+   *
+   * @param transforms an array of {@link TJTransform} instances, each of
+   * which specifies the transform parameters and/or cropping region for the
+   * corresponding transformed output image
+   *
+   * @param flags the bitwise OR of one or more of
+   * {@link TJ#FLAG_BOTTOMUP TJ.FLAG_*}
+   *
+   * @return an array of {@link TJDecompressor} instances, each of
+   * which has a transformed JPEG image associated with it.
+   */
+  public TJDecompressor[] transform(TJTransform[] transforms, int flags)
+                                    throws TJException {
+    byte[][] dstBufs = new byte[transforms.length][];
+    if (jpegWidth < 1 || jpegHeight < 1)
+      throw new IllegalStateException("JPEG buffer not initialized");
+    for (int i = 0; i < transforms.length; i++) {
+      int w = jpegWidth, h = jpegHeight;
+      if ((transforms[i].options & TJTransform.OPT_CROP) != 0) {
+        if (transforms[i].width != 0) w = transforms[i].width;
+        if (transforms[i].height != 0) h = transforms[i].height;
+      }
+      dstBufs[i] = new byte[TJ.bufSize(w, h, jpegSubsamp)];
+    }
+    TJDecompressor[] tjd = new TJDecompressor[transforms.length];
+    transform(dstBufs, transforms, flags);
+    for (int i = 0; i < transforms.length; i++)
+      tjd[i] = new TJDecompressor(dstBufs[i], transformedSizes[i]);
+    return tjd;
+  }
+
+  /**
+   * Returns an array containing the sizes of the transformed JPEG images
+   * generated by the most recent transform operation.
+   *
+   * @return an array containing the sizes of the transformed JPEG images
+   * generated by the most recent transform operation.
+   */
+  public int[] getTransformedSizes() {
+    if (transformedSizes == null)
+      throw new IllegalStateException("No image has been transformed yet");
+    return transformedSizes;
+  }
+
+  private native void init() throws TJException;
+
+  private native int[] transform(byte[] srcBuf, int srcSize, byte[][] dstBufs,
+    TJTransform[] transforms, int flags) throws TJException;
+
+  static {
+    TJLoader.load();
+  }
+
+  private int[] transformedSizes = null;
+}
diff --git a/3rdparty/libjpeg/src/java/org/libjpegturbo/turbojpeg/YUVImage.java b/3rdparty/libjpeg/src/java/org/libjpegturbo/turbojpeg/YUVImage.java
new file mode 100644
index 00000000..4da9843a
--- /dev/null
+++ b/3rdparty/libjpeg/src/java/org/libjpegturbo/turbojpeg/YUVImage.java
@@ -0,0 +1,445 @@
+/*
+ * Copyright (C)2014, 2017 D. R. Commander.  All Rights Reserved.
+ * Copyright (C)2015 Viktor Szathmáry.  All Rights Reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright notice,
+ *   this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright notice,
+ *   this list of conditions and the following disclaimer in the documentation
+ *   and/or other materials provided with the distribution.
+ * - Neither the name of the libjpeg-turbo Project nor the names of its
+ *   contributors may be used to endorse or promote products derived from this
+ *   software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE 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 HOLDERS 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.
+ */
+
+package org.libjpegturbo.turbojpeg;
+
+/**
+ * This class encapsulates a YUV planar image and the metadata
+ * associated with it.  The TurboJPEG API allows both the JPEG compression and
+ * decompression pipelines to be split into stages:  YUV encode, compress from
+ * YUV, decompress to YUV, and YUV decode.  A <code>YUVImage</code> instance
+ * serves as the destination image for YUV encode and decompress-to-YUV
+ * operations and as the source image for compress-from-YUV and YUV decode
+ * operations.
+ * <p>
+ * Technically, the JPEG format uses the YCbCr colorspace (which technically is
+ * not a "colorspace" but rather a "color transform"), but per the convention
+ * of the digital video community, the TurboJPEG API uses "YUV" to refer to an
+ * image format consisting of Y, Cb, and Cr image planes.
+ * <p>
+ * Each plane is simply a 2D array of bytes, each byte representing the value
+ * of one of the components (Y, Cb, or Cr) at a particular location in the
+ * image.  The width and height of each plane are determined by the image
+ * width, height, and level of chrominance subsampling.  The luminance plane
+ * width is the image width padded to the nearest multiple of the horizontal
+ * subsampling factor (2 in the case of 4:2:0 and 4:2:2, 4 in the case of
+ * 4:1:1, 1 in the case of 4:4:4 or grayscale.)  Similarly, the luminance plane
+ * height is the image height padded to the nearest multiple of the vertical
+ * subsampling factor (2 in the case of 4:2:0 or 4:4:0, 1 in the case of 4:4:4
+ * or grayscale.)  The chrominance plane width is equal to the luminance plane
+ * width divided by the horizontal subsampling factor, and the chrominance
+ * plane height is equal to the luminance plane height divided by the vertical
+ * subsampling factor.
+ * <p>
+ * For example, if the source image is 35 x 35 pixels and 4:2:2 subsampling is
+ * used, then the luminance plane would be 36 x 35 bytes, and each of the
+ * chrominance planes would be 18 x 35 bytes.  If you specify a line padding of
+ * 4 bytes on top of this, then the luminance plane would be 36 x 35 bytes, and
+ * each of the chrominance planes would be 20 x 35 bytes.
+ */
+public class YUVImage {
+
+  private static final String NO_ASSOC_ERROR =
+    "No image data is associated with this instance";
+
+  /**
+   * Create a new <code>YUVImage</code> instance backed by separate image
+   * planes, and allocate memory for the image planes.
+   *
+   * @param width width (in pixels) of the YUV image
+   *
+   * @param strides an array of integers, each specifying the number of bytes
+   * per line in the corresponding plane of the YUV image.  Setting the stride
+   * for any plane to 0 is the same as setting it to the plane width (see
+   * {@link YUVImage above}.)  If <code>strides</code> is null, then the
+   * strides for all planes will be set to their respective plane widths.  When
+   * using this constructor, the stride for each plane must be equal to or
+   * greater than the plane width.
+   *
+   * @param height height (in pixels) of the YUV image
+   *
+   * @param subsamp the level of chrominance subsampling to be used in the YUV
+   * image (one of {@link TJ#SAMP_444 TJ.SAMP_*})
+   */
+  public YUVImage(int width, int[] strides, int height, int subsamp) {
+    setBuf(null, null, width, strides, height, subsamp, true);
+  }
+
+  /**
+   * Create a new <code>YUVImage</code> instance backed by a unified image
+   * buffer, and allocate memory for the image buffer.
+   *
+   * @param width width (in pixels) of the YUV image
+   *
+   * @param pad Each line of each plane in the YUV image buffer will be padded
+   * to this number of bytes (must be a power of 2.)
+   *
+   * @param height height (in pixels) of the YUV image
+   *
+   * @param subsamp the level of chrominance subsampling to be used in the YUV
+   * image (one of {@link TJ#SAMP_444 TJ.SAMP_*})
+   */
+  public YUVImage(int width, int pad, int height, int subsamp) {
+    setBuf(new byte[TJ.bufSizeYUV(width, pad, height, subsamp)], width, pad,
+           height, subsamp);
+  }
+
+  /**
+   * Create a new <code>YUVImage</code> instance from a set of existing image
+   * planes.
+   *
+   * @param planes an array of buffers representing the Y, U (Cb), and V (Cr)
+   * image planes (or just the Y plane, if the image is grayscale.)   These
+   * planes can be contiguous or non-contiguous in memory.  Plane
+   * <code>i</code> should be at least <code>offsets[i] +
+   * {@link TJ#planeSizeYUV TJ.planeSizeYUV}(i, width, strides[i], height, subsamp)</code>
+   * bytes in size.
+   *
+   * @param offsets If this <code>YUVImage</code> instance represents a
+   * subregion of a larger image, then <code>offsets[i]</code> specifies the
+   * offset (in bytes) of the subregion within plane <code>i</code> of the
+   * larger image.  Setting this to null is the same as setting the offsets for
+   * all planes to 0.
+   *
+   * @param width width (in pixels) of the new YUV image (or subregion)
+   *
+   * @param strides an array of integers, each specifying the number of bytes
+   * per line in the corresponding plane of the YUV image.  Setting the stride
+   * for any plane to 0 is the same as setting it to the plane width (see
+   * {@link YUVImage above}.)  If <code>strides</code> is null, then the
+   * strides for all planes will be set to their respective plane widths.  You
+   * can adjust the strides in order to add an arbitrary amount of line padding
+   * to each plane or to specify that this <code>YUVImage</code> instance is a
+   * subregion of a larger image (in which case, <code>strides[i]</code> should
+   * be set to the plane width of plane <code>i</code> in the larger image.)
+   *
+   * @param height height (in pixels) of the new YUV image (or subregion)
+   *
+   * @param subsamp the level of chrominance subsampling used in the YUV
+   * image (one of {@link TJ#SAMP_444 TJ.SAMP_*})
+   */
+  public YUVImage(byte[][] planes, int[] offsets, int width, int[] strides,
+                  int height, int subsamp) {
+    setBuf(planes, offsets, width, strides, height, subsamp, false);
+  }
+
+  /**
+   * Create a new <code>YUVImage</code> instance from an existing unified image
+   * buffer.
+   *
+   * @param yuvImage image buffer that contains or will contain YUV planar
+   * image data.  Use {@link TJ#bufSizeYUV} to determine the minimum size for
+   * this buffer.  The Y, U (Cb), and V (Cr) image planes are stored
+   * sequentially in the buffer (see {@link YUVImage above} for a description
+   * of the image format.)
+   *
+   * @param width width (in pixels) of the YUV image
+   *
+   * @param pad the line padding used in the YUV image buffer.  For
+   * instance, if each line in each plane of the buffer is padded to the
+   * nearest multiple of 4 bytes, then <code>pad</code> should be set to 4.
+   *
+   * @param height height (in pixels) of the YUV image
+   *
+   * @param subsamp the level of chrominance subsampling used in the YUV
+   * image (one of {@link TJ#SAMP_444 TJ.SAMP_*})
+   */
+  public YUVImage(byte[] yuvImage, int width, int pad, int height,
+                  int subsamp) {
+    setBuf(yuvImage, width, pad, height, subsamp);
+  }
+
+  /**
+   * Assign a set of image planes to this <code>YUVImage</code> instance.
+   *
+   * @param planes an array of buffers representing the Y, U (Cb), and V (Cr)
+   * image planes (or just the Y plane, if the image is grayscale.)  These
+   * planes can be contiguous or non-contiguous in memory.  Plane
+   * <code>i</code> should be at least <code>offsets[i] +
+   * {@link TJ#planeSizeYUV TJ.planeSizeYUV}(i, width, strides[i], height, subsamp)</code>
+   * bytes in size.
+   *
+   * @param offsets If this <code>YUVImage</code> instance represents a
+   * subregion of a larger image, then <code>offsets[i]</code> specifies the
+   * offset (in bytes) of the subregion within plane <code>i</code> of the
+   * larger image.  Setting this to null is the same as setting the offsets for
+   * all planes to 0.
+   *
+   * @param width width (in pixels) of the YUV image (or subregion)
+   *
+   * @param strides an array of integers, each specifying the number of bytes
+   * per line in the corresponding plane of the YUV image.  Setting the stride
+   * for any plane to 0 is the same as setting it to the plane width (see
+   * {@link YUVImage above}.)  If <code>strides</code> is null, then the
+   * strides for all planes will be set to their respective plane widths.  You
+   * can adjust the strides in order to add an arbitrary amount of line padding
+   * to each plane or to specify that this <code>YUVImage</code> image is a
+   * subregion of a larger image (in which case, <code>strides[i]</code> should
+   * be set to the plane width of plane <code>i</code> in the larger image.)
+   *
+   * @param height height (in pixels) of the YUV image (or subregion)
+   *
+   * @param subsamp the level of chrominance subsampling used in the YUV
+   * image (one of {@link TJ#SAMP_444 TJ.SAMP_*})
+   */
+  public void setBuf(byte[][] planes, int[] offsets, int width, int[] strides,
+                     int height, int subsamp) {
+    setBuf(planes, offsets, width, strides, height, subsamp, false);
+  }
+
+  private void setBuf(byte[][] planes, int[] offsets, int width, int[] strides,
+                     int height, int subsamp, boolean alloc) {
+    if ((planes == null && !alloc) || width < 1 || height < 1 || subsamp < 0 ||
+        subsamp >= TJ.NUMSAMP)
+      throw new IllegalArgumentException("Invalid argument in YUVImage::setBuf()");
+
+    int nc = (subsamp == TJ.SAMP_GRAY ? 1 : 3);
+    if ((planes != null && planes.length != nc) ||
+        (offsets != null && offsets.length != nc) ||
+        (strides != null && strides.length != nc))
+      throw new IllegalArgumentException("YUVImage::setBuf(): planes, offsets, or strides array is the wrong size");
+
+    if (planes == null)
+      planes = new byte[nc][];
+    if (offsets == null)
+      offsets = new int[nc];
+    if (strides == null)
+      strides = new int[nc];
+
+    for (int i = 0; i < nc; i++) {
+      int pw = TJ.planeWidth(i, width, subsamp);
+      int ph = TJ.planeHeight(i, height, subsamp);
+      int planeSize = TJ.planeSizeYUV(i, width, strides[i], height, subsamp);
+
+      if (strides[i] == 0)
+        strides[i] = pw;
+      if (alloc) {
+        if (strides[i] < pw)
+          throw new IllegalArgumentException("Stride must be >= plane width when allocating a new YUV image");
+        planes[i] = new byte[strides[i] * ph];
+      }
+      if (planes[i] == null || offsets[i] < 0)
+        throw new IllegalArgumentException("Invalid argument in YUVImage::setBuf()");
+      if (strides[i] < 0 && offsets[i] - planeSize + pw < 0)
+        throw new IllegalArgumentException("Stride for plane " + i +
+                                           " would cause memory to be accessed below plane boundary");
+      if (planes[i].length < offsets[i] + planeSize)
+        throw new IllegalArgumentException("Image plane " + i +
+                                           " is not large enough");
+    }
+
+    yuvPlanes = planes;
+    yuvOffsets = offsets;
+    yuvWidth = width;
+    yuvStrides = strides;
+    yuvHeight = height;
+    yuvSubsamp = subsamp;
+  }
+
+  /**
+   * Assign a unified image buffer to this <code>YUVImage</code> instance.
+   *
+   * @param yuvImage image buffer that contains or will contain YUV planar
+   * image data.  Use {@link TJ#bufSizeYUV} to determine the minimum size for
+   * this buffer.  The Y, U (Cb), and V (Cr) image planes are stored
+   * sequentially in the buffer (see {@link YUVImage above} for a description
+   * of the image format.)
+   *
+   * @param width width (in pixels) of the YUV image
+   *
+   * @param pad the line padding used in the YUV image buffer.  For
+   * instance, if each line in each plane of the buffer is padded to the
+   * nearest multiple of 4 bytes, then <code>pad</code> should be set to 4.
+   *
+   * @param height height (in pixels) of the YUV image
+   *
+   * @param subsamp the level of chrominance subsampling used in the YUV
+   * image (one of {@link TJ#SAMP_444 TJ.SAMP_*})
+   */
+  public void setBuf(byte[] yuvImage, int width, int pad, int height,
+                     int subsamp) {
+    if (yuvImage == null || width < 1 || pad < 1 || ((pad & (pad - 1)) != 0) ||
+        height < 1 || subsamp < 0 || subsamp >= TJ.NUMSAMP)
+      throw new IllegalArgumentException("Invalid argument in YUVImage::setBuf()");
+    if (yuvImage.length < TJ.bufSizeYUV(width, pad, height, subsamp))
+      throw new IllegalArgumentException("YUV image buffer is not large enough");
+
+    int nc = (subsamp == TJ.SAMP_GRAY ? 1 : 3);
+    byte[][] planes = new byte[nc][];
+    int[] strides = new int[nc];
+    int[] offsets = new int[nc];
+
+    planes[0] = yuvImage;
+    strides[0] = pad(TJ.planeWidth(0, width, subsamp), pad);
+    if (subsamp != TJ.SAMP_GRAY) {
+      strides[1] = strides[2] = pad(TJ.planeWidth(1, width, subsamp), pad);
+      planes[1] = planes[2] = yuvImage;
+      offsets[1] = offsets[0] +
+        strides[0] * TJ.planeHeight(0, height, subsamp);
+      offsets[2] = offsets[1] +
+        strides[1] * TJ.planeHeight(1, height, subsamp);
+    }
+
+    yuvPad = pad;
+    setBuf(planes, offsets, width, strides, height, subsamp);
+  }
+
+  /**
+   * Returns the width of the YUV image (or subregion.)
+   *
+   * @return the width of the YUV image (or subregion)
+   */
+  public int getWidth() {
+    if (yuvWidth < 1)
+      throw new IllegalStateException(NO_ASSOC_ERROR);
+    return yuvWidth;
+  }
+
+  /**
+   * Returns the height of the YUV image (or subregion.)
+   *
+   * @return the height of the YUV image (or subregion)
+   */
+  public int getHeight() {
+    if (yuvHeight < 1)
+      throw new IllegalStateException(NO_ASSOC_ERROR);
+    return yuvHeight;
+  }
+
+  /**
+   * Returns the line padding used in the YUV image buffer (if this image is
+   * stored in a unified buffer rather than separate image planes.)
+   *
+   * @return the line padding used in the YUV image buffer
+   */
+  public int getPad() {
+    if (yuvPlanes == null)
+      throw new IllegalStateException(NO_ASSOC_ERROR);
+    if (yuvPad < 1 || ((yuvPad & (yuvPad - 1)) != 0))
+      throw new IllegalStateException("Image is not stored in a unified buffer");
+    return yuvPad;
+  }
+
+  /**
+   * Returns the number of bytes per line of each plane in the YUV image.
+   *
+   * @return the number of bytes per line of each plane in the YUV image
+   */
+  public int[] getStrides() {
+    if (yuvStrides == null)
+      throw new IllegalStateException(NO_ASSOC_ERROR);
+    return yuvStrides;
+  }
+
+  /**
+   * Returns the offsets (in bytes) of each plane within the planes of a larger
+   * YUV image.
+   *
+   * @return the offsets (in bytes) of each plane within the planes of a larger
+   * YUV image
+   */
+  public int[] getOffsets() {
+    if (yuvOffsets == null)
+      throw new IllegalStateException(NO_ASSOC_ERROR);
+    return yuvOffsets;
+  }
+
+  /**
+   * Returns the level of chrominance subsampling used in the YUV image.  See
+   * {@link TJ#SAMP_444 TJ.SAMP_*}.
+   *
+   * @return the level of chrominance subsampling used in the YUV image
+   */
+  public int getSubsamp() {
+    if (yuvSubsamp < 0 || yuvSubsamp >= TJ.NUMSAMP)
+      throw new IllegalStateException(NO_ASSOC_ERROR);
+    return yuvSubsamp;
+  }
+
+  /**
+   * Returns the YUV image planes.  If the image is stored in a unified buffer,
+   * then all image planes will point to that buffer.
+   *
+   * @return the YUV image planes
+   */
+  public byte[][] getPlanes() {
+    if (yuvPlanes == null)
+      throw new IllegalStateException(NO_ASSOC_ERROR);
+    return yuvPlanes;
+  }
+
+  /**
+   * Returns the YUV image buffer (if this image is stored in a unified
+   * buffer rather than separate image planes.)
+   *
+   * @return the YUV image buffer
+   */
+  public byte[] getBuf() {
+    if (yuvPlanes == null || yuvSubsamp < 0 || yuvSubsamp >= TJ.NUMSAMP)
+      throw new IllegalStateException(NO_ASSOC_ERROR);
+    int nc = (yuvSubsamp == TJ.SAMP_GRAY ? 1 : 3);
+    for (int i = 1; i < nc; i++) {
+      if (yuvPlanes[i] != yuvPlanes[0])
+        throw new IllegalStateException("Image is not stored in a unified buffer");
+    }
+    return yuvPlanes[0];
+  }
+
+  /**
+   * Returns the size (in bytes) of the YUV image buffer (if this image is
+   * stored in a unified buffer rather than separate image planes.)
+   *
+   * @return the size (in bytes) of the YUV image buffer
+   */
+  public int getSize() {
+    if (yuvPlanes == null || yuvSubsamp < 0 || yuvSubsamp >= TJ.NUMSAMP)
+      throw new IllegalStateException(NO_ASSOC_ERROR);
+    int nc = (yuvSubsamp == TJ.SAMP_GRAY ? 1 : 3);
+    if (yuvPad < 1)
+      throw new IllegalStateException("Image is not stored in a unified buffer");
+    for (int i = 1; i < nc; i++) {
+      if (yuvPlanes[i] != yuvPlanes[0])
+        throw new IllegalStateException("Image is not stored in a unified buffer");
+    }
+    return TJ.bufSizeYUV(yuvWidth, yuvPad, yuvHeight, yuvSubsamp);
+  }
+
+  private static int pad(int v, int p) {
+    return (v + p - 1) & (~(p - 1));
+  }
+
+  protected long handle = 0;
+  protected byte[][] yuvPlanes = null;
+  protected int[] yuvOffsets = null;
+  protected int[] yuvStrides = null;
+  protected int yuvPad = 0;
+  protected int yuvWidth = 0;
+  protected int yuvHeight = 0;
+  protected int yuvSubsamp = -1;
+}
diff --git a/3rdparty/libjpeg/src/java/org_libjpegturbo_turbojpeg_TJ.h b/3rdparty/libjpeg/src/java/org_libjpegturbo_turbojpeg_TJ.h
new file mode 100644
index 00000000..84ee8711
--- /dev/null
+++ b/3rdparty/libjpeg/src/java/org_libjpegturbo_turbojpeg_TJ.h
@@ -0,0 +1,129 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class org_libjpegturbo_turbojpeg_TJ */
+
+#ifndef _Included_org_libjpegturbo_turbojpeg_TJ
+#define _Included_org_libjpegturbo_turbojpeg_TJ
+#ifdef __cplusplus
+extern "C" {
+#endif
+#undef org_libjpegturbo_turbojpeg_TJ_NUMSAMP
+#define org_libjpegturbo_turbojpeg_TJ_NUMSAMP 6L
+#undef org_libjpegturbo_turbojpeg_TJ_SAMP_444
+#define org_libjpegturbo_turbojpeg_TJ_SAMP_444 0L
+#undef org_libjpegturbo_turbojpeg_TJ_SAMP_422
+#define org_libjpegturbo_turbojpeg_TJ_SAMP_422 1L
+#undef org_libjpegturbo_turbojpeg_TJ_SAMP_420
+#define org_libjpegturbo_turbojpeg_TJ_SAMP_420 2L
+#undef org_libjpegturbo_turbojpeg_TJ_SAMP_GRAY
+#define org_libjpegturbo_turbojpeg_TJ_SAMP_GRAY 3L
+#undef org_libjpegturbo_turbojpeg_TJ_SAMP_440
+#define org_libjpegturbo_turbojpeg_TJ_SAMP_440 4L
+#undef org_libjpegturbo_turbojpeg_TJ_SAMP_411
+#define org_libjpegturbo_turbojpeg_TJ_SAMP_411 5L
+#undef org_libjpegturbo_turbojpeg_TJ_NUMPF
+#define org_libjpegturbo_turbojpeg_TJ_NUMPF 12L
+#undef org_libjpegturbo_turbojpeg_TJ_PF_RGB
+#define org_libjpegturbo_turbojpeg_TJ_PF_RGB 0L
+#undef org_libjpegturbo_turbojpeg_TJ_PF_BGR
+#define org_libjpegturbo_turbojpeg_TJ_PF_BGR 1L
+#undef org_libjpegturbo_turbojpeg_TJ_PF_RGBX
+#define org_libjpegturbo_turbojpeg_TJ_PF_RGBX 2L
+#undef org_libjpegturbo_turbojpeg_TJ_PF_BGRX
+#define org_libjpegturbo_turbojpeg_TJ_PF_BGRX 3L
+#undef org_libjpegturbo_turbojpeg_TJ_PF_XBGR
+#define org_libjpegturbo_turbojpeg_TJ_PF_XBGR 4L
+#undef org_libjpegturbo_turbojpeg_TJ_PF_XRGB
+#define org_libjpegturbo_turbojpeg_TJ_PF_XRGB 5L
+#undef org_libjpegturbo_turbojpeg_TJ_PF_GRAY
+#define org_libjpegturbo_turbojpeg_TJ_PF_GRAY 6L
+#undef org_libjpegturbo_turbojpeg_TJ_PF_RGBA
+#define org_libjpegturbo_turbojpeg_TJ_PF_RGBA 7L
+#undef org_libjpegturbo_turbojpeg_TJ_PF_BGRA
+#define org_libjpegturbo_turbojpeg_TJ_PF_BGRA 8L
+#undef org_libjpegturbo_turbojpeg_TJ_PF_ABGR
+#define org_libjpegturbo_turbojpeg_TJ_PF_ABGR 9L
+#undef org_libjpegturbo_turbojpeg_TJ_PF_ARGB
+#define org_libjpegturbo_turbojpeg_TJ_PF_ARGB 10L
+#undef org_libjpegturbo_turbojpeg_TJ_PF_CMYK
+#define org_libjpegturbo_turbojpeg_TJ_PF_CMYK 11L
+#undef org_libjpegturbo_turbojpeg_TJ_NUMCS
+#define org_libjpegturbo_turbojpeg_TJ_NUMCS 5L
+#undef org_libjpegturbo_turbojpeg_TJ_CS_RGB
+#define org_libjpegturbo_turbojpeg_TJ_CS_RGB 0L
+#undef org_libjpegturbo_turbojpeg_TJ_CS_YCbCr
+#define org_libjpegturbo_turbojpeg_TJ_CS_YCbCr 1L
+#undef org_libjpegturbo_turbojpeg_TJ_CS_GRAY
+#define org_libjpegturbo_turbojpeg_TJ_CS_GRAY 2L
+#undef org_libjpegturbo_turbojpeg_TJ_CS_CMYK
+#define org_libjpegturbo_turbojpeg_TJ_CS_CMYK 3L
+#undef org_libjpegturbo_turbojpeg_TJ_CS_YCCK
+#define org_libjpegturbo_turbojpeg_TJ_CS_YCCK 4L
+#undef org_libjpegturbo_turbojpeg_TJ_FLAG_BOTTOMUP
+#define org_libjpegturbo_turbojpeg_TJ_FLAG_BOTTOMUP 2L
+#undef org_libjpegturbo_turbojpeg_TJ_FLAG_FASTUPSAMPLE
+#define org_libjpegturbo_turbojpeg_TJ_FLAG_FASTUPSAMPLE 256L
+#undef org_libjpegturbo_turbojpeg_TJ_FLAG_FASTDCT
+#define org_libjpegturbo_turbojpeg_TJ_FLAG_FASTDCT 2048L
+#undef org_libjpegturbo_turbojpeg_TJ_FLAG_ACCURATEDCT
+#define org_libjpegturbo_turbojpeg_TJ_FLAG_ACCURATEDCT 4096L
+/*
+ * Class:     org_libjpegturbo_turbojpeg_TJ
+ * Method:    bufSize
+ * Signature: (III)I
+ */
+JNIEXPORT jint JNICALL Java_org_libjpegturbo_turbojpeg_TJ_bufSize
+  (JNIEnv *, jclass, jint, jint, jint);
+
+/*
+ * Class:     org_libjpegturbo_turbojpeg_TJ
+ * Method:    bufSizeYUV
+ * Signature: (IIII)I
+ */
+JNIEXPORT jint JNICALL Java_org_libjpegturbo_turbojpeg_TJ_bufSizeYUV__IIII
+  (JNIEnv *, jclass, jint, jint, jint, jint);
+
+/*
+ * Class:     org_libjpegturbo_turbojpeg_TJ
+ * Method:    bufSizeYUV
+ * Signature: (III)I
+ */
+JNIEXPORT jint JNICALL Java_org_libjpegturbo_turbojpeg_TJ_bufSizeYUV__III
+  (JNIEnv *, jclass, jint, jint, jint);
+
+/*
+ * Class:     org_libjpegturbo_turbojpeg_TJ
+ * Method:    planeSizeYUV
+ * Signature: (IIIII)I
+ */
+JNIEXPORT jint JNICALL Java_org_libjpegturbo_turbojpeg_TJ_planeSizeYUV__IIIII
+  (JNIEnv *, jclass, jint, jint, jint, jint, jint);
+
+/*
+ * Class:     org_libjpegturbo_turbojpeg_TJ
+ * Method:    planeWidth
+ * Signature: (III)I
+ */
+JNIEXPORT jint JNICALL Java_org_libjpegturbo_turbojpeg_TJ_planeWidth__III
+  (JNIEnv *, jclass, jint, jint, jint);
+
+/*
+ * Class:     org_libjpegturbo_turbojpeg_TJ
+ * Method:    planeHeight
+ * Signature: (III)I
+ */
+JNIEXPORT jint JNICALL Java_org_libjpegturbo_turbojpeg_TJ_planeHeight__III
+  (JNIEnv *, jclass, jint, jint, jint);
+
+/*
+ * Class:     org_libjpegturbo_turbojpeg_TJ
+ * Method:    getScalingFactors
+ * Signature: ()[Lorg/libjpegturbo/turbojpeg/TJScalingFactor;
+ */
+JNIEXPORT jobjectArray JNICALL Java_org_libjpegturbo_turbojpeg_TJ_getScalingFactors
+  (JNIEnv *, jclass);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/3rdparty/libjpeg/src/java/org_libjpegturbo_turbojpeg_TJCompressor.h b/3rdparty/libjpeg/src/java/org_libjpegturbo_turbojpeg_TJCompressor.h
new file mode 100644
index 00000000..e76bd0ef
--- /dev/null
+++ b/3rdparty/libjpeg/src/java/org_libjpegturbo_turbojpeg_TJCompressor.h
@@ -0,0 +1,101 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class org_libjpegturbo_turbojpeg_TJCompressor */
+
+#ifndef _Included_org_libjpegturbo_turbojpeg_TJCompressor
+#define _Included_org_libjpegturbo_turbojpeg_TJCompressor
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ * Class:     org_libjpegturbo_turbojpeg_TJCompressor
+ * Method:    init
+ * Signature: ()V
+ */
+JNIEXPORT void JNICALL Java_org_libjpegturbo_turbojpeg_TJCompressor_init
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     org_libjpegturbo_turbojpeg_TJCompressor
+ * Method:    destroy
+ * Signature: ()V
+ */
+JNIEXPORT void JNICALL Java_org_libjpegturbo_turbojpeg_TJCompressor_destroy
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     org_libjpegturbo_turbojpeg_TJCompressor
+ * Method:    compress
+ * Signature: ([BIIII[BIII)I
+ */
+JNIEXPORT jint JNICALL Java_org_libjpegturbo_turbojpeg_TJCompressor_compress___3BIIII_3BIII
+  (JNIEnv *, jobject, jbyteArray, jint, jint, jint, jint, jbyteArray, jint, jint, jint);
+
+/*
+ * Class:     org_libjpegturbo_turbojpeg_TJCompressor
+ * Method:    compress
+ * Signature: ([BIIIIII[BIII)I
+ */
+JNIEXPORT jint JNICALL Java_org_libjpegturbo_turbojpeg_TJCompressor_compress___3BIIIIII_3BIII
+  (JNIEnv *, jobject, jbyteArray, jint, jint, jint, jint, jint, jint, jbyteArray, jint, jint, jint);
+
+/*
+ * Class:     org_libjpegturbo_turbojpeg_TJCompressor
+ * Method:    compress
+ * Signature: ([IIIII[BIII)I
+ */
+JNIEXPORT jint JNICALL Java_org_libjpegturbo_turbojpeg_TJCompressor_compress___3IIIII_3BIII
+  (JNIEnv *, jobject, jintArray, jint, jint, jint, jint, jbyteArray, jint, jint, jint);
+
+/*
+ * Class:     org_libjpegturbo_turbojpeg_TJCompressor
+ * Method:    compress
+ * Signature: ([IIIIIII[BIII)I
+ */
+JNIEXPORT jint JNICALL Java_org_libjpegturbo_turbojpeg_TJCompressor_compress___3IIIIIII_3BIII
+  (JNIEnv *, jobject, jintArray, jint, jint, jint, jint, jint, jint, jbyteArray, jint, jint, jint);
+
+/*
+ * Class:     org_libjpegturbo_turbojpeg_TJCompressor
+ * Method:    compressFromYUV
+ * Signature: ([[B[II[III[BII)I
+ */
+JNIEXPORT jint JNICALL Java_org_libjpegturbo_turbojpeg_TJCompressor_compressFromYUV___3_3B_3II_3III_3BII
+  (JNIEnv *, jobject, jobjectArray, jintArray, jint, jintArray, jint, jint, jbyteArray, jint, jint);
+
+/*
+ * Class:     org_libjpegturbo_turbojpeg_TJCompressor
+ * Method:    encodeYUV
+ * Signature: ([BIIII[BII)V
+ */
+JNIEXPORT void JNICALL Java_org_libjpegturbo_turbojpeg_TJCompressor_encodeYUV___3BIIII_3BII
+  (JNIEnv *, jobject, jbyteArray, jint, jint, jint, jint, jbyteArray, jint, jint);
+
+/*
+ * Class:     org_libjpegturbo_turbojpeg_TJCompressor
+ * Method:    encodeYUV
+ * Signature: ([BIIIIII[[B[I[III)V
+ */
+JNIEXPORT void JNICALL Java_org_libjpegturbo_turbojpeg_TJCompressor_encodeYUV___3BIIIIII_3_3B_3I_3III
+  (JNIEnv *, jobject, jbyteArray, jint, jint, jint, jint, jint, jint, jobjectArray, jintArray, jintArray, jint, jint);
+
+/*
+ * Class:     org_libjpegturbo_turbojpeg_TJCompressor
+ * Method:    encodeYUV
+ * Signature: ([IIIII[BII)V
+ */
+JNIEXPORT void JNICALL Java_org_libjpegturbo_turbojpeg_TJCompressor_encodeYUV___3IIIII_3BII
+  (JNIEnv *, jobject, jintArray, jint, jint, jint, jint, jbyteArray, jint, jint);
+
+/*
+ * Class:     org_libjpegturbo_turbojpeg_TJCompressor
+ * Method:    encodeYUV
+ * Signature: ([IIIIIII[[B[I[III)V
+ */
+JNIEXPORT void JNICALL Java_org_libjpegturbo_turbojpeg_TJCompressor_encodeYUV___3IIIIIII_3_3B_3I_3III
+  (JNIEnv *, jobject, jintArray, jint, jint, jint, jint, jint, jint, jobjectArray, jintArray, jintArray, jint, jint);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/3rdparty/libjpeg/src/java/org_libjpegturbo_turbojpeg_TJDecompressor.h b/3rdparty/libjpeg/src/java/org_libjpegturbo_turbojpeg_TJDecompressor.h
new file mode 100644
index 00000000..2d58e735
--- /dev/null
+++ b/3rdparty/libjpeg/src/java/org_libjpegturbo_turbojpeg_TJDecompressor.h
@@ -0,0 +1,101 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class org_libjpegturbo_turbojpeg_TJDecompressor */
+
+#ifndef _Included_org_libjpegturbo_turbojpeg_TJDecompressor
+#define _Included_org_libjpegturbo_turbojpeg_TJDecompressor
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ * Class:     org_libjpegturbo_turbojpeg_TJDecompressor
+ * Method:    init
+ * Signature: ()V
+ */
+JNIEXPORT void JNICALL Java_org_libjpegturbo_turbojpeg_TJDecompressor_init
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     org_libjpegturbo_turbojpeg_TJDecompressor
+ * Method:    destroy
+ * Signature: ()V
+ */
+JNIEXPORT void JNICALL Java_org_libjpegturbo_turbojpeg_TJDecompressor_destroy
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     org_libjpegturbo_turbojpeg_TJDecompressor
+ * Method:    decompressHeader
+ * Signature: ([BI)V
+ */
+JNIEXPORT void JNICALL Java_org_libjpegturbo_turbojpeg_TJDecompressor_decompressHeader
+  (JNIEnv *, jobject, jbyteArray, jint);
+
+/*
+ * Class:     org_libjpegturbo_turbojpeg_TJDecompressor
+ * Method:    decompress
+ * Signature: ([BI[BIIIII)V
+ */
+JNIEXPORT void JNICALL Java_org_libjpegturbo_turbojpeg_TJDecompressor_decompress___3BI_3BIIIII
+  (JNIEnv *, jobject, jbyteArray, jint, jbyteArray, jint, jint, jint, jint, jint);
+
+/*
+ * Class:     org_libjpegturbo_turbojpeg_TJDecompressor
+ * Method:    decompress
+ * Signature: ([BI[BIIIIIII)V
+ */
+JNIEXPORT void JNICALL Java_org_libjpegturbo_turbojpeg_TJDecompressor_decompress___3BI_3BIIIIIII
+  (JNIEnv *, jobject, jbyteArray, jint, jbyteArray, jint, jint, jint, jint, jint, jint, jint);
+
+/*
+ * Class:     org_libjpegturbo_turbojpeg_TJDecompressor
+ * Method:    decompress
+ * Signature: ([BI[IIIIII)V
+ */
+JNIEXPORT void JNICALL Java_org_libjpegturbo_turbojpeg_TJDecompressor_decompress___3BI_3IIIIII
+  (JNIEnv *, jobject, jbyteArray, jint, jintArray, jint, jint, jint, jint, jint);
+
+/*
+ * Class:     org_libjpegturbo_turbojpeg_TJDecompressor
+ * Method:    decompress
+ * Signature: ([BI[IIIIIIII)V
+ */
+JNIEXPORT void JNICALL Java_org_libjpegturbo_turbojpeg_TJDecompressor_decompress___3BI_3IIIIIIII
+  (JNIEnv *, jobject, jbyteArray, jint, jintArray, jint, jint, jint, jint, jint, jint, jint);
+
+/*
+ * Class:     org_libjpegturbo_turbojpeg_TJDecompressor
+ * Method:    decompressToYUV
+ * Signature: ([BI[BI)V
+ */
+JNIEXPORT void JNICALL Java_org_libjpegturbo_turbojpeg_TJDecompressor_decompressToYUV___3BI_3BI
+  (JNIEnv *, jobject, jbyteArray, jint, jbyteArray, jint);
+
+/*
+ * Class:     org_libjpegturbo_turbojpeg_TJDecompressor
+ * Method:    decompressToYUV
+ * Signature: ([BI[[B[II[III)V
+ */
+JNIEXPORT void JNICALL Java_org_libjpegturbo_turbojpeg_TJDecompressor_decompressToYUV___3BI_3_3B_3II_3III
+  (JNIEnv *, jobject, jbyteArray, jint, jobjectArray, jintArray, jint, jintArray, jint, jint);
+
+/*
+ * Class:     org_libjpegturbo_turbojpeg_TJDecompressor
+ * Method:    decodeYUV
+ * Signature: ([[B[I[II[BIIIIIII)V
+ */
+JNIEXPORT void JNICALL Java_org_libjpegturbo_turbojpeg_TJDecompressor_decodeYUV___3_3B_3I_3II_3BIIIIIII
+  (JNIEnv *, jobject, jobjectArray, jintArray, jintArray, jint, jbyteArray, jint, jint, jint, jint, jint, jint, jint);
+
+/*
+ * Class:     org_libjpegturbo_turbojpeg_TJDecompressor
+ * Method:    decodeYUV
+ * Signature: ([[B[I[II[IIIIIIII)V
+ */
+JNIEXPORT void JNICALL Java_org_libjpegturbo_turbojpeg_TJDecompressor_decodeYUV___3_3B_3I_3II_3IIIIIIII
+  (JNIEnv *, jobject, jobjectArray, jintArray, jintArray, jint, jintArray, jint, jint, jint, jint, jint, jint, jint);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/3rdparty/libjpeg/src/java/org_libjpegturbo_turbojpeg_TJTransformer.h b/3rdparty/libjpeg/src/java/org_libjpegturbo_turbojpeg_TJTransformer.h
new file mode 100644
index 00000000..a9dad4d6
--- /dev/null
+++ b/3rdparty/libjpeg/src/java/org_libjpegturbo_turbojpeg_TJTransformer.h
@@ -0,0 +1,29 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class org_libjpegturbo_turbojpeg_TJTransformer */
+
+#ifndef _Included_org_libjpegturbo_turbojpeg_TJTransformer
+#define _Included_org_libjpegturbo_turbojpeg_TJTransformer
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ * Class:     org_libjpegturbo_turbojpeg_TJTransformer
+ * Method:    init
+ * Signature: ()V
+ */
+JNIEXPORT void JNICALL Java_org_libjpegturbo_turbojpeg_TJTransformer_init
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     org_libjpegturbo_turbojpeg_TJTransformer
+ * Method:    transform
+ * Signature: ([BI[[B[Lorg/libjpegturbo/turbojpeg/TJTransform;I)[I
+ */
+JNIEXPORT jintArray JNICALL Java_org_libjpegturbo_turbojpeg_TJTransformer_transform
+  (JNIEnv *, jobject, jbyteArray, jint, jobjectArray, jobjectArray, jint);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/3rdparty/libjpeg/src/jcapimin.c b/3rdparty/libjpeg/src/jcapimin.c
new file mode 100644
index 00000000..178c55ba
--- /dev/null
+++ b/3rdparty/libjpeg/src/jcapimin.c
@@ -0,0 +1,295 @@
+/*
+ * jcapimin.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1994-1998, Thomas G. Lane.
+ * Modified 2003-2010 by Guido Vollbeding.
+ * It was modified by The libjpeg-turbo Project to include only code relevant
+ * to libjpeg-turbo.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains application interface code for the compression half
+ * of the JPEG library.  These are the "minimum" API routines that may be
+ * needed in either the normal full-compression case or the transcoding-only
+ * case.
+ *
+ * Most of the routines intended to be called directly by an application
+ * are in this file or in jcapistd.c.  But also see jcparam.c for
+ * parameter-setup helper routines, jcomapi.c for routines shared by
+ * compression and decompression, and jctrans.c for the transcoding case.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/*
+ * Initialization of a JPEG compression object.
+ * The error manager must already be set up (in case memory manager fails).
+ */
+
+GLOBAL(void)
+jpeg_CreateCompress(j_compress_ptr cinfo, int version, size_t structsize)
+{
+  int i;
+
+  /* Guard against version mismatches between library and caller. */
+  cinfo->mem = NULL;            /* so jpeg_destroy knows mem mgr not called */
+  if (version != JPEG_LIB_VERSION)
+    ERREXIT2(cinfo, JERR_BAD_LIB_VERSION, JPEG_LIB_VERSION, version);
+  if (structsize != sizeof(struct jpeg_compress_struct))
+    ERREXIT2(cinfo, JERR_BAD_STRUCT_SIZE,
+             (int)sizeof(struct jpeg_compress_struct), (int)structsize);
+
+  /* For debugging purposes, we zero the whole master structure.
+   * But the application has already set the err pointer, and may have set
+   * client_data, so we have to save and restore those fields.
+   * Note: if application hasn't set client_data, tools like Purify may
+   * complain here.
+   */
+  {
+    struct jpeg_error_mgr *err = cinfo->err;
+    void *client_data = cinfo->client_data; /* ignore Purify complaint here */
+    MEMZERO(cinfo, sizeof(struct jpeg_compress_struct));
+    cinfo->err = err;
+    cinfo->client_data = client_data;
+  }
+  cinfo->is_decompressor = FALSE;
+
+  /* Initialize a memory manager instance for this object */
+  jinit_memory_mgr((j_common_ptr)cinfo);
+
+  /* Zero out pointers to permanent structures. */
+  cinfo->progress = NULL;
+  cinfo->dest = NULL;
+
+  cinfo->comp_info = NULL;
+
+  for (i = 0; i < NUM_QUANT_TBLS; i++) {
+    cinfo->quant_tbl_ptrs[i] = NULL;
+#if JPEG_LIB_VERSION >= 70
+    cinfo->q_scale_factor[i] = 100;
+#endif
+  }
+
+  for (i = 0; i < NUM_HUFF_TBLS; i++) {
+    cinfo->dc_huff_tbl_ptrs[i] = NULL;
+    cinfo->ac_huff_tbl_ptrs[i] = NULL;
+  }
+
+#if JPEG_LIB_VERSION >= 80
+  /* Must do it here for emit_dqt in case jpeg_write_tables is used */
+  cinfo->block_size = DCTSIZE;
+  cinfo->natural_order = jpeg_natural_order;
+  cinfo->lim_Se = DCTSIZE2 - 1;
+#endif
+
+  cinfo->script_space = NULL;
+
+  cinfo->input_gamma = 1.0;     /* in case application forgets */
+
+  /* OK, I'm ready */
+  cinfo->global_state = CSTATE_START;
+}
+
+
+/*
+ * Destruction of a JPEG compression object
+ */
+
+GLOBAL(void)
+jpeg_destroy_compress(j_compress_ptr cinfo)
+{
+  jpeg_destroy((j_common_ptr)cinfo); /* use common routine */
+}
+
+
+/*
+ * Abort processing of a JPEG compression operation,
+ * but don't destroy the object itself.
+ */
+
+GLOBAL(void)
+jpeg_abort_compress(j_compress_ptr cinfo)
+{
+  jpeg_abort((j_common_ptr)cinfo); /* use common routine */
+}
+
+
+/*
+ * Forcibly suppress or un-suppress all quantization and Huffman tables.
+ * Marks all currently defined tables as already written (if suppress)
+ * or not written (if !suppress).  This will control whether they get emitted
+ * by a subsequent jpeg_start_compress call.
+ *
+ * This routine is exported for use by applications that want to produce
+ * abbreviated JPEG datastreams.  It logically belongs in jcparam.c, but
+ * since it is called by jpeg_start_compress, we put it here --- otherwise
+ * jcparam.o would be linked whether the application used it or not.
+ */
+
+GLOBAL(void)
+jpeg_suppress_tables(j_compress_ptr cinfo, boolean suppress)
+{
+  int i;
+  JQUANT_TBL *qtbl;
+  JHUFF_TBL *htbl;
+
+  for (i = 0; i < NUM_QUANT_TBLS; i++) {
+    if ((qtbl = cinfo->quant_tbl_ptrs[i]) != NULL)
+      qtbl->sent_table = suppress;
+  }
+
+  for (i = 0; i < NUM_HUFF_TBLS; i++) {
+    if ((htbl = cinfo->dc_huff_tbl_ptrs[i]) != NULL)
+      htbl->sent_table = suppress;
+    if ((htbl = cinfo->ac_huff_tbl_ptrs[i]) != NULL)
+      htbl->sent_table = suppress;
+  }
+}
+
+
+/*
+ * Finish JPEG compression.
+ *
+ * If a multipass operating mode was selected, this may do a great deal of
+ * work including most of the actual output.
+ */
+
+GLOBAL(void)
+jpeg_finish_compress(j_compress_ptr cinfo)
+{
+  JDIMENSION iMCU_row;
+
+  if (cinfo->global_state == CSTATE_SCANNING ||
+      cinfo->global_state == CSTATE_RAW_OK) {
+    /* Terminate first pass */
+    if (cinfo->next_scanline < cinfo->image_height)
+      ERREXIT(cinfo, JERR_TOO_LITTLE_DATA);
+    (*cinfo->master->finish_pass) (cinfo);
+  } else if (cinfo->global_state != CSTATE_WRCOEFS)
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+  /* Perform any remaining passes */
+  while (!cinfo->master->is_last_pass) {
+    (*cinfo->master->prepare_for_pass) (cinfo);
+    for (iMCU_row = 0; iMCU_row < cinfo->total_iMCU_rows; iMCU_row++) {
+      if (cinfo->progress != NULL) {
+        cinfo->progress->pass_counter = (long)iMCU_row;
+        cinfo->progress->pass_limit = (long)cinfo->total_iMCU_rows;
+        (*cinfo->progress->progress_monitor) ((j_common_ptr)cinfo);
+      }
+      /* We bypass the main controller and invoke coef controller directly;
+       * all work is being done from the coefficient buffer.
+       */
+      if (!(*cinfo->coef->compress_data) (cinfo, (JSAMPIMAGE)NULL))
+        ERREXIT(cinfo, JERR_CANT_SUSPEND);
+    }
+    (*cinfo->master->finish_pass) (cinfo);
+  }
+  /* Write EOI, do final cleanup */
+  (*cinfo->marker->write_file_trailer) (cinfo);
+  (*cinfo->dest->term_destination) (cinfo);
+  /* We can use jpeg_abort to release memory and reset global_state */
+  jpeg_abort((j_common_ptr)cinfo);
+}
+
+
+/*
+ * Write a special marker.
+ * This is only recommended for writing COM or APPn markers.
+ * Must be called after jpeg_start_compress() and before
+ * first call to jpeg_write_scanlines() or jpeg_write_raw_data().
+ */
+
+GLOBAL(void)
+jpeg_write_marker(j_compress_ptr cinfo, int marker, const JOCTET *dataptr,
+                  unsigned int datalen)
+{
+  void (*write_marker_byte) (j_compress_ptr info, int val);
+
+  if (cinfo->next_scanline != 0 ||
+      (cinfo->global_state != CSTATE_SCANNING &&
+       cinfo->global_state != CSTATE_RAW_OK &&
+       cinfo->global_state != CSTATE_WRCOEFS))
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+
+  (*cinfo->marker->write_marker_header) (cinfo, marker, datalen);
+  write_marker_byte = cinfo->marker->write_marker_byte; /* copy for speed */
+  while (datalen--) {
+    (*write_marker_byte) (cinfo, *dataptr);
+    dataptr++;
+  }
+}
+
+/* Same, but piecemeal. */
+
+GLOBAL(void)
+jpeg_write_m_header(j_compress_ptr cinfo, int marker, unsigned int datalen)
+{
+  if (cinfo->next_scanline != 0 ||
+      (cinfo->global_state != CSTATE_SCANNING &&
+       cinfo->global_state != CSTATE_RAW_OK &&
+       cinfo->global_state != CSTATE_WRCOEFS))
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+
+  (*cinfo->marker->write_marker_header) (cinfo, marker, datalen);
+}
+
+GLOBAL(void)
+jpeg_write_m_byte(j_compress_ptr cinfo, int val)
+{
+  (*cinfo->marker->write_marker_byte) (cinfo, val);
+}
+
+
+/*
+ * Alternate compression function: just write an abbreviated table file.
+ * Before calling this, all parameters and a data destination must be set up.
+ *
+ * To produce a pair of files containing abbreviated tables and abbreviated
+ * image data, one would proceed as follows:
+ *
+ *              initialize JPEG object
+ *              set JPEG parameters
+ *              set destination to table file
+ *              jpeg_write_tables(cinfo);
+ *              set destination to image file
+ *              jpeg_start_compress(cinfo, FALSE);
+ *              write data...
+ *              jpeg_finish_compress(cinfo);
+ *
+ * jpeg_write_tables has the side effect of marking all tables written
+ * (same as jpeg_suppress_tables(..., TRUE)).  Thus a subsequent start_compress
+ * will not re-emit the tables unless it is passed write_all_tables=TRUE.
+ */
+
+GLOBAL(void)
+jpeg_write_tables(j_compress_ptr cinfo)
+{
+  if (cinfo->global_state != CSTATE_START)
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+
+  /* (Re)initialize error mgr and destination modules */
+  (*cinfo->err->reset_error_mgr) ((j_common_ptr)cinfo);
+  (*cinfo->dest->init_destination) (cinfo);
+  /* Initialize the marker writer ... bit of a crock to do it here. */
+  jinit_marker_writer(cinfo);
+  /* Write them tables! */
+  (*cinfo->marker->write_tables_only) (cinfo);
+  /* And clean up. */
+  (*cinfo->dest->term_destination) (cinfo);
+  /*
+   * In library releases up through v6a, we called jpeg_abort() here to free
+   * any working memory allocated by the destination manager and marker
+   * writer.  Some applications had a problem with that: they allocated space
+   * of their own from the library memory manager, and didn't want it to go
+   * away during write_tables.  So now we do nothing.  This will cause a
+   * memory leak if an app calls write_tables repeatedly without doing a full
+   * compression cycle or otherwise resetting the JPEG object.  However, that
+   * seems less bad than unexpectedly freeing memory in the normal case.
+   * An app that prefers the old behavior can call jpeg_abort for itself after
+   * each call to jpeg_write_tables().
+   */
+}
diff --git a/3rdparty/libjpeg/src/jcapistd.c b/3rdparty/libjpeg/src/jcapistd.c
new file mode 100644
index 00000000..aa2aad9f
--- /dev/null
+++ b/3rdparty/libjpeg/src/jcapistd.c
@@ -0,0 +1,162 @@
+/*
+ * jcapistd.c
+ *
+ * Copyright (C) 1994-1996, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains application interface code for the compression half
+ * of the JPEG library.  These are the "standard" API routines that are
+ * used in the normal full-compression case.  They are not used by a
+ * transcoding-only application.  Note that if an application links in
+ * jpeg_start_compress, it will end up linking in the entire compressor.
+ * We thus must separate this file from jcapimin.c to avoid linking the
+ * whole compression library into a transcoder.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/*
+ * Compression initialization.
+ * Before calling this, all parameters and a data destination must be set up.
+ *
+ * We require a write_all_tables parameter as a failsafe check when writing
+ * multiple datastreams from the same compression object.  Since prior runs
+ * will have left all the tables marked sent_table=TRUE, a subsequent run
+ * would emit an abbreviated stream (no tables) by default.  This may be what
+ * is wanted, but for safety's sake it should not be the default behavior:
+ * programmers should have to make a deliberate choice to emit abbreviated
+ * images.  Therefore the documentation and examples should encourage people
+ * to pass write_all_tables=TRUE; then it will take active thought to do the
+ * wrong thing.
+ */
+
+GLOBAL(void)
+jpeg_start_compress(j_compress_ptr cinfo, boolean write_all_tables)
+{
+  if (cinfo->global_state != CSTATE_START)
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+
+  if (write_all_tables)
+    jpeg_suppress_tables(cinfo, FALSE); /* mark all tables to be written */
+
+  /* (Re)initialize error mgr and destination modules */
+  (*cinfo->err->reset_error_mgr) ((j_common_ptr)cinfo);
+  (*cinfo->dest->init_destination) (cinfo);
+  /* Perform master selection of active modules */
+  jinit_compress_master(cinfo);
+  /* Set up for the first pass */
+  (*cinfo->master->prepare_for_pass) (cinfo);
+  /* Ready for application to drive first pass through jpeg_write_scanlines
+   * or jpeg_write_raw_data.
+   */
+  cinfo->next_scanline = 0;
+  cinfo->global_state = (cinfo->raw_data_in ? CSTATE_RAW_OK : CSTATE_SCANNING);
+}
+
+
+/*
+ * Write some scanlines of data to the JPEG compressor.
+ *
+ * The return value will be the number of lines actually written.
+ * This should be less than the supplied num_lines only in case that
+ * the data destination module has requested suspension of the compressor,
+ * or if more than image_height scanlines are passed in.
+ *
+ * Note: we warn about excess calls to jpeg_write_scanlines() since
+ * this likely signals an application programmer error.  However,
+ * excess scanlines passed in the last valid call are *silently* ignored,
+ * so that the application need not adjust num_lines for end-of-image
+ * when using a multiple-scanline buffer.
+ */
+
+GLOBAL(JDIMENSION)
+jpeg_write_scanlines(j_compress_ptr cinfo, JSAMPARRAY scanlines,
+                     JDIMENSION num_lines)
+{
+  JDIMENSION row_ctr, rows_left;
+
+  if (cinfo->global_state != CSTATE_SCANNING)
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+  if (cinfo->next_scanline >= cinfo->image_height)
+    WARNMS(cinfo, JWRN_TOO_MUCH_DATA);
+
+  /* Call progress monitor hook if present */
+  if (cinfo->progress != NULL) {
+    cinfo->progress->pass_counter = (long)cinfo->next_scanline;
+    cinfo->progress->pass_limit = (long)cinfo->image_height;
+    (*cinfo->progress->progress_monitor) ((j_common_ptr)cinfo);
+  }
+
+  /* Give master control module another chance if this is first call to
+   * jpeg_write_scanlines.  This lets output of the frame/scan headers be
+   * delayed so that application can write COM, etc, markers between
+   * jpeg_start_compress and jpeg_write_scanlines.
+   */
+  if (cinfo->master->call_pass_startup)
+    (*cinfo->master->pass_startup) (cinfo);
+
+  /* Ignore any extra scanlines at bottom of image. */
+  rows_left = cinfo->image_height - cinfo->next_scanline;
+  if (num_lines > rows_left)
+    num_lines = rows_left;
+
+  row_ctr = 0;
+  (*cinfo->main->process_data) (cinfo, scanlines, &row_ctr, num_lines);
+  cinfo->next_scanline += row_ctr;
+  return row_ctr;
+}
+
+
+/*
+ * Alternate entry point to write raw data.
+ * Processes exactly one iMCU row per call, unless suspended.
+ */
+
+GLOBAL(JDIMENSION)
+jpeg_write_raw_data(j_compress_ptr cinfo, JSAMPIMAGE data,
+                    JDIMENSION num_lines)
+{
+  JDIMENSION lines_per_iMCU_row;
+
+  if (cinfo->global_state != CSTATE_RAW_OK)
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+  if (cinfo->next_scanline >= cinfo->image_height) {
+    WARNMS(cinfo, JWRN_TOO_MUCH_DATA);
+    return 0;
+  }
+
+  /* Call progress monitor hook if present */
+  if (cinfo->progress != NULL) {
+    cinfo->progress->pass_counter = (long)cinfo->next_scanline;
+    cinfo->progress->pass_limit = (long)cinfo->image_height;
+    (*cinfo->progress->progress_monitor) ((j_common_ptr)cinfo);
+  }
+
+  /* Give master control module another chance if this is first call to
+   * jpeg_write_raw_data.  This lets output of the frame/scan headers be
+   * delayed so that application can write COM, etc, markers between
+   * jpeg_start_compress and jpeg_write_raw_data.
+   */
+  if (cinfo->master->call_pass_startup)
+    (*cinfo->master->pass_startup) (cinfo);
+
+  /* Verify that at least one iMCU row has been passed. */
+  lines_per_iMCU_row = cinfo->max_v_samp_factor * DCTSIZE;
+  if (num_lines < lines_per_iMCU_row)
+    ERREXIT(cinfo, JERR_BUFFER_SIZE);
+
+  /* Directly compress the row. */
+  if (!(*cinfo->coef->compress_data) (cinfo, data)) {
+    /* If compressor did not consume the whole row, suspend processing. */
+    return 0;
+  }
+
+  /* OK, we processed one iMCU row. */
+  cinfo->next_scanline += lines_per_iMCU_row;
+  return lines_per_iMCU_row;
+}
diff --git a/3rdparty/libjpeg/src/jcarith.c b/3rdparty/libjpeg/src/jcarith.c
new file mode 100644
index 00000000..b6d093f7
--- /dev/null
+++ b/3rdparty/libjpeg/src/jcarith.c
@@ -0,0 +1,932 @@
+/*
+ * jcarith.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Developed 1997-2009 by Guido Vollbeding.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2015, 2018, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains portable arithmetic entropy encoding routines for JPEG
+ * (implementing Recommendation ITU-T T.81 | ISO/IEC 10918-1).
+ *
+ * Both sequential and progressive modes are supported in this single module.
+ *
+ * Suspension is not currently supported in this module.
+ *
+ * NOTE: All referenced figures are from
+ * Recommendation ITU-T T.81 (1992) | ISO/IEC 10918-1:1994.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/* Expanded entropy encoder object for arithmetic encoding. */
+
+typedef struct {
+  struct jpeg_entropy_encoder pub; /* public fields */
+
+  JLONG c; /* C register, base of coding interval, layout as in sec. D.1.3 */
+  JLONG a;               /* A register, normalized size of coding interval */
+  JLONG sc;        /* counter for stacked 0xFF values which might overflow */
+  JLONG zc;          /* counter for pending 0x00 output values which might *
+                          * be discarded at the end ("Pacman" termination) */
+  int ct;  /* bit shift counter, determines when next byte will be written */
+  int buffer;                /* buffer for most recent output byte != 0xFF */
+
+  int last_dc_val[MAX_COMPS_IN_SCAN]; /* last DC coef for each component */
+  int dc_context[MAX_COMPS_IN_SCAN]; /* context index for DC conditioning */
+
+  unsigned int restarts_to_go;  /* MCUs left in this restart interval */
+  int next_restart_num;         /* next restart number to write (0-7) */
+
+  /* Pointers to statistics areas (these workspaces have image lifespan) */
+  unsigned char *dc_stats[NUM_ARITH_TBLS];
+  unsigned char *ac_stats[NUM_ARITH_TBLS];
+
+  /* Statistics bin for coding with fixed probability 0.5 */
+  unsigned char fixed_bin[4];
+} arith_entropy_encoder;
+
+typedef arith_entropy_encoder *arith_entropy_ptr;
+
+/* The following two definitions specify the allocation chunk size
+ * for the statistics area.
+ * According to sections F.1.4.4.1.3 and F.1.4.4.2, we need at least
+ * 49 statistics bins for DC, and 245 statistics bins for AC coding.
+ *
+ * We use a compact representation with 1 byte per statistics bin,
+ * thus the numbers directly represent byte sizes.
+ * This 1 byte per statistics bin contains the meaning of the MPS
+ * (more probable symbol) in the highest bit (mask 0x80), and the
+ * index into the probability estimation state machine table
+ * in the lower bits (mask 0x7F).
+ */
+
+#define DC_STAT_BINS  64
+#define AC_STAT_BINS  256
+
+/* NOTE: Uncomment the following #define if you want to use the
+ * given formula for calculating the AC conditioning parameter Kx
+ * for spectral selection progressive coding in section G.1.3.2
+ * of the spec (Kx = Kmin + SRL (8 + Se - Kmin) 4).
+ * Although the spec and P&M authors claim that this "has proven
+ * to give good results for 8 bit precision samples", I'm not
+ * convinced yet that this is really beneficial.
+ * Early tests gave only very marginal compression enhancements
+ * (a few - around 5 or so - bytes even for very large files),
+ * which would turn out rather negative if we'd suppress the
+ * DAC (Define Arithmetic Conditioning) marker segments for
+ * the default parameters in the future.
+ * Note that currently the marker writing module emits 12-byte
+ * DAC segments for a full-component scan in a color image.
+ * This is not worth worrying about IMHO. However, since the
+ * spec defines the default values to be used if the tables
+ * are omitted (unlike Huffman tables, which are required
+ * anyway), one might optimize this behaviour in the future,
+ * and then it would be disadvantageous to use custom tables if
+ * they don't provide sufficient gain to exceed the DAC size.
+ *
+ * On the other hand, I'd consider it as a reasonable result
+ * that the conditioning has no significant influence on the
+ * compression performance. This means that the basic
+ * statistical model is already rather stable.
+ *
+ * Thus, at the moment, we use the default conditioning values
+ * anyway, and do not use the custom formula.
+ *
+#define CALCULATE_SPECTRAL_CONDITIONING
+ */
+
+/* IRIGHT_SHIFT is like RIGHT_SHIFT, but works on int rather than JLONG.
+ * We assume that int right shift is unsigned if JLONG right shift is,
+ * which should be safe.
+ */
+
+#ifdef RIGHT_SHIFT_IS_UNSIGNED
+#define ISHIFT_TEMPS    int ishift_temp;
+#define IRIGHT_SHIFT(x, shft) \
+  ((ishift_temp = (x)) < 0 ? \
+   (ishift_temp >> (shft)) | ((~0) << (16 - (shft))) : \
+   (ishift_temp >> (shft)))
+#else
+#define ISHIFT_TEMPS
+#define IRIGHT_SHIFT(x, shft)   ((x) >> (shft))
+#endif
+
+
+LOCAL(void)
+emit_byte(int val, j_compress_ptr cinfo)
+/* Write next output byte; we do not support suspension in this module. */
+{
+  struct jpeg_destination_mgr *dest = cinfo->dest;
+
+  *dest->next_output_byte++ = (JOCTET)val;
+  if (--dest->free_in_buffer == 0)
+    if (!(*dest->empty_output_buffer) (cinfo))
+      ERREXIT(cinfo, JERR_CANT_SUSPEND);
+}
+
+
+/*
+ * Finish up at the end of an arithmetic-compressed scan.
+ */
+
+METHODDEF(void)
+finish_pass(j_compress_ptr cinfo)
+{
+  arith_entropy_ptr e = (arith_entropy_ptr)cinfo->entropy;
+  JLONG temp;
+
+  /* Section D.1.8: Termination of encoding */
+
+  /* Find the e->c in the coding interval with the largest
+   * number of trailing zero bits */
+  if ((temp = (e->a - 1 + e->c) & 0xFFFF0000UL) < e->c)
+    e->c = temp + 0x8000L;
+  else
+    e->c = temp;
+  /* Send remaining bytes to output */
+  e->c <<= e->ct;
+  if (e->c & 0xF8000000UL) {
+    /* One final overflow has to be handled */
+    if (e->buffer >= 0) {
+      if (e->zc)
+        do emit_byte(0x00, cinfo);
+        while (--e->zc);
+      emit_byte(e->buffer + 1, cinfo);
+      if (e->buffer + 1 == 0xFF)
+        emit_byte(0x00, cinfo);
+    }
+    e->zc += e->sc;  /* carry-over converts stacked 0xFF bytes to 0x00 */
+    e->sc = 0;
+  } else {
+    if (e->buffer == 0)
+      ++e->zc;
+    else if (e->buffer >= 0) {
+      if (e->zc)
+        do emit_byte(0x00, cinfo);
+        while (--e->zc);
+      emit_byte(e->buffer, cinfo);
+    }
+    if (e->sc) {
+      if (e->zc)
+        do emit_byte(0x00, cinfo);
+        while (--e->zc);
+      do {
+        emit_byte(0xFF, cinfo);
+        emit_byte(0x00, cinfo);
+      } while (--e->sc);
+    }
+  }
+  /* Output final bytes only if they are not 0x00 */
+  if (e->c & 0x7FFF800L) {
+    if (e->zc)  /* output final pending zero bytes */
+      do emit_byte(0x00, cinfo);
+      while (--e->zc);
+    emit_byte((e->c >> 19) & 0xFF, cinfo);
+    if (((e->c >> 19) & 0xFF) == 0xFF)
+      emit_byte(0x00, cinfo);
+    if (e->c & 0x7F800L) {
+      emit_byte((e->c >> 11) & 0xFF, cinfo);
+      if (((e->c >> 11) & 0xFF) == 0xFF)
+        emit_byte(0x00, cinfo);
+    }
+  }
+}
+
+
+/*
+ * The core arithmetic encoding routine (common in JPEG and JBIG).
+ * This needs to go as fast as possible.
+ * Machine-dependent optimization facilities
+ * are not utilized in this portable implementation.
+ * However, this code should be fairly efficient and
+ * may be a good base for further optimizations anyway.
+ *
+ * Parameter 'val' to be encoded may be 0 or 1 (binary decision).
+ *
+ * Note: I've added full "Pacman" termination support to the
+ * byte output routines, which is equivalent to the optional
+ * Discard_final_zeros procedure (Figure D.15) in the spec.
+ * Thus, we always produce the shortest possible output
+ * stream compliant to the spec (no trailing zero bytes,
+ * except for FF stuffing).
+ *
+ * I've also introduced a new scheme for accessing
+ * the probability estimation state machine table,
+ * derived from Markus Kuhn's JBIG implementation.
+ */
+
+LOCAL(void)
+arith_encode(j_compress_ptr cinfo, unsigned char *st, int val)
+{
+  register arith_entropy_ptr e = (arith_entropy_ptr)cinfo->entropy;
+  register unsigned char nl, nm;
+  register JLONG qe, temp;
+  register int sv;
+
+  /* Fetch values from our compact representation of Table D.2:
+   * Qe values and probability estimation state machine
+   */
+  sv = *st;
+  qe = jpeg_aritab[sv & 0x7F];  /* => Qe_Value */
+  nl = qe & 0xFF;  qe >>= 8;    /* Next_Index_LPS + Switch_MPS */
+  nm = qe & 0xFF;  qe >>= 8;    /* Next_Index_MPS */
+
+  /* Encode & estimation procedures per sections D.1.4 & D.1.5 */
+  e->a -= qe;
+  if (val != (sv >> 7)) {
+    /* Encode the less probable symbol */
+    if (e->a >= qe) {
+      /* If the interval size (qe) for the less probable symbol (LPS)
+       * is larger than the interval size for the MPS, then exchange
+       * the two symbols for coding efficiency, otherwise code the LPS
+       * as usual: */
+      e->c += e->a;
+      e->a = qe;
+    }
+    *st = (sv & 0x80) ^ nl;     /* Estimate_after_LPS */
+  } else {
+    /* Encode the more probable symbol */
+    if (e->a >= 0x8000L)
+      return;  /* A >= 0x8000 -> ready, no renormalization required */
+    if (e->a < qe) {
+      /* If the interval size (qe) for the less probable symbol (LPS)
+       * is larger than the interval size for the MPS, then exchange
+       * the two symbols for coding efficiency: */
+      e->c += e->a;
+      e->a = qe;
+    }
+    *st = (sv & 0x80) ^ nm;     /* Estimate_after_MPS */
+  }
+
+  /* Renormalization & data output per section D.1.6 */
+  do {
+    e->a <<= 1;
+    e->c <<= 1;
+    if (--e->ct == 0) {
+      /* Another byte is ready for output */
+      temp = e->c >> 19;
+      if (temp > 0xFF) {
+        /* Handle overflow over all stacked 0xFF bytes */
+        if (e->buffer >= 0) {
+          if (e->zc)
+            do emit_byte(0x00, cinfo);
+            while (--e->zc);
+          emit_byte(e->buffer + 1, cinfo);
+          if (e->buffer + 1 == 0xFF)
+            emit_byte(0x00, cinfo);
+        }
+        e->zc += e->sc;  /* carry-over converts stacked 0xFF bytes to 0x00 */
+        e->sc = 0;
+        /* Note: The 3 spacer bits in the C register guarantee
+         * that the new buffer byte can't be 0xFF here
+         * (see page 160 in the P&M JPEG book). */
+        e->buffer = temp & 0xFF;  /* new output byte, might overflow later */
+      } else if (temp == 0xFF) {
+        ++e->sc;  /* stack 0xFF byte (which might overflow later) */
+      } else {
+        /* Output all stacked 0xFF bytes, they will not overflow any more */
+        if (e->buffer == 0)
+          ++e->zc;
+        else if (e->buffer >= 0) {
+          if (e->zc)
+            do emit_byte(0x00, cinfo);
+            while (--e->zc);
+          emit_byte(e->buffer, cinfo);
+        }
+        if (e->sc) {
+          if (e->zc)
+            do emit_byte(0x00, cinfo);
+            while (--e->zc);
+          do {
+            emit_byte(0xFF, cinfo);
+            emit_byte(0x00, cinfo);
+          } while (--e->sc);
+        }
+        e->buffer = temp & 0xFF;  /* new output byte (can still overflow) */
+      }
+      e->c &= 0x7FFFFL;
+      e->ct += 8;
+    }
+  } while (e->a < 0x8000L);
+}
+
+
+/*
+ * Emit a restart marker & resynchronize predictions.
+ */
+
+LOCAL(void)
+emit_restart(j_compress_ptr cinfo, int restart_num)
+{
+  arith_entropy_ptr entropy = (arith_entropy_ptr)cinfo->entropy;
+  int ci;
+  jpeg_component_info *compptr;
+
+  finish_pass(cinfo);
+
+  emit_byte(0xFF, cinfo);
+  emit_byte(JPEG_RST0 + restart_num, cinfo);
+
+  /* Re-initialize statistics areas */
+  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+    compptr = cinfo->cur_comp_info[ci];
+    /* DC needs no table for refinement scan */
+    if (cinfo->progressive_mode == 0 || (cinfo->Ss == 0 && cinfo->Ah == 0)) {
+      MEMZERO(entropy->dc_stats[compptr->dc_tbl_no], DC_STAT_BINS);
+      /* Reset DC predictions to 0 */
+      entropy->last_dc_val[ci] = 0;
+      entropy->dc_context[ci] = 0;
+    }
+    /* AC needs no table when not present */
+    if (cinfo->progressive_mode == 0 || cinfo->Se) {
+      MEMZERO(entropy->ac_stats[compptr->ac_tbl_no], AC_STAT_BINS);
+    }
+  }
+
+  /* Reset arithmetic encoding variables */
+  entropy->c = 0;
+  entropy->a = 0x10000L;
+  entropy->sc = 0;
+  entropy->zc = 0;
+  entropy->ct = 11;
+  entropy->buffer = -1;  /* empty */
+}
+
+
+/*
+ * MCU encoding for DC initial scan (either spectral selection,
+ * or first pass of successive approximation).
+ */
+
+METHODDEF(boolean)
+encode_mcu_DC_first(j_compress_ptr cinfo, JBLOCKROW *MCU_data)
+{
+  arith_entropy_ptr entropy = (arith_entropy_ptr)cinfo->entropy;
+  JBLOCKROW block;
+  unsigned char *st;
+  int blkn, ci, tbl;
+  int v, v2, m;
+  ISHIFT_TEMPS
+
+  /* Emit restart marker if needed */
+  if (cinfo->restart_interval) {
+    if (entropy->restarts_to_go == 0) {
+      emit_restart(cinfo, entropy->next_restart_num);
+      entropy->restarts_to_go = cinfo->restart_interval;
+      entropy->next_restart_num++;
+      entropy->next_restart_num &= 7;
+    }
+    entropy->restarts_to_go--;
+  }
+
+  /* Encode the MCU data blocks */
+  for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
+    block = MCU_data[blkn];
+    ci = cinfo->MCU_membership[blkn];
+    tbl = cinfo->cur_comp_info[ci]->dc_tbl_no;
+
+    /* Compute the DC value after the required point transform by Al.
+     * This is simply an arithmetic right shift.
+     */
+    m = IRIGHT_SHIFT((int)((*block)[0]), cinfo->Al);
+
+    /* Sections F.1.4.1 & F.1.4.4.1: Encoding of DC coefficients */
+
+    /* Table F.4: Point to statistics bin S0 for DC coefficient coding */
+    st = entropy->dc_stats[tbl] + entropy->dc_context[ci];
+
+    /* Figure F.4: Encode_DC_DIFF */
+    if ((v = m - entropy->last_dc_val[ci]) == 0) {
+      arith_encode(cinfo, st, 0);
+      entropy->dc_context[ci] = 0;      /* zero diff category */
+    } else {
+      entropy->last_dc_val[ci] = m;
+      arith_encode(cinfo, st, 1);
+      /* Figure F.6: Encoding nonzero value v */
+      /* Figure F.7: Encoding the sign of v */
+      if (v > 0) {
+        arith_encode(cinfo, st + 1, 0); /* Table F.4: SS = S0 + 1 */
+        st += 2;                        /* Table F.4: SP = S0 + 2 */
+        entropy->dc_context[ci] = 4;    /* small positive diff category */
+      } else {
+        v = -v;
+        arith_encode(cinfo, st + 1, 1); /* Table F.4: SS = S0 + 1 */
+        st += 3;                        /* Table F.4: SN = S0 + 3 */
+        entropy->dc_context[ci] = 8;    /* small negative diff category */
+      }
+      /* Figure F.8: Encoding the magnitude category of v */
+      m = 0;
+      if (v -= 1) {
+        arith_encode(cinfo, st, 1);
+        m = 1;
+        v2 = v;
+        st = entropy->dc_stats[tbl] + 20; /* Table F.4: X1 = 20 */
+        while (v2 >>= 1) {
+          arith_encode(cinfo, st, 1);
+          m <<= 1;
+          st += 1;
+        }
+      }
+      arith_encode(cinfo, st, 0);
+      /* Section F.1.4.4.1.2: Establish dc_context conditioning category */
+      if (m < (int)((1L << cinfo->arith_dc_L[tbl]) >> 1))
+        entropy->dc_context[ci] = 0;    /* zero diff category */
+      else if (m > (int)((1L << cinfo->arith_dc_U[tbl]) >> 1))
+        entropy->dc_context[ci] += 8;   /* large diff category */
+      /* Figure F.9: Encoding the magnitude bit pattern of v */
+      st += 14;
+      while (m >>= 1)
+        arith_encode(cinfo, st, (m & v) ? 1 : 0);
+    }
+  }
+
+  return TRUE;
+}
+
+
+/*
+ * MCU encoding for AC initial scan (either spectral selection,
+ * or first pass of successive approximation).
+ */
+
+METHODDEF(boolean)
+encode_mcu_AC_first(j_compress_ptr cinfo, JBLOCKROW *MCU_data)
+{
+  arith_entropy_ptr entropy = (arith_entropy_ptr)cinfo->entropy;
+  JBLOCKROW block;
+  unsigned char *st;
+  int tbl, k, ke;
+  int v, v2, m;
+
+  /* Emit restart marker if needed */
+  if (cinfo->restart_interval) {
+    if (entropy->restarts_to_go == 0) {
+      emit_restart(cinfo, entropy->next_restart_num);
+      entropy->restarts_to_go = cinfo->restart_interval;
+      entropy->next_restart_num++;
+      entropy->next_restart_num &= 7;
+    }
+    entropy->restarts_to_go--;
+  }
+
+  /* Encode the MCU data block */
+  block = MCU_data[0];
+  tbl = cinfo->cur_comp_info[0]->ac_tbl_no;
+
+  /* Sections F.1.4.2 & F.1.4.4.2: Encoding of AC coefficients */
+
+  /* Establish EOB (end-of-block) index */
+  for (ke = cinfo->Se; ke > 0; ke--)
+    /* We must apply the point transform by Al.  For AC coefficients this
+     * is an integer division with rounding towards 0.  To do this portably
+     * in C, we shift after obtaining the absolute value.
+     */
+    if ((v = (*block)[jpeg_natural_order[ke]]) >= 0) {
+      if (v >>= cinfo->Al) break;
+    } else {
+      v = -v;
+      if (v >>= cinfo->Al) break;
+    }
+
+  /* Figure F.5: Encode_AC_Coefficients */
+  for (k = cinfo->Ss; k <= ke; k++) {
+    st = entropy->ac_stats[tbl] + 3 * (k - 1);
+    arith_encode(cinfo, st, 0);         /* EOB decision */
+    for (;;) {
+      if ((v = (*block)[jpeg_natural_order[k]]) >= 0) {
+        if (v >>= cinfo->Al) {
+          arith_encode(cinfo, st + 1, 1);
+          arith_encode(cinfo, entropy->fixed_bin, 0);
+          break;
+        }
+      } else {
+        v = -v;
+        if (v >>= cinfo->Al) {
+          arith_encode(cinfo, st + 1, 1);
+          arith_encode(cinfo, entropy->fixed_bin, 1);
+          break;
+        }
+      }
+      arith_encode(cinfo, st + 1, 0);  st += 3;  k++;
+    }
+    st += 2;
+    /* Figure F.8: Encoding the magnitude category of v */
+    m = 0;
+    if (v -= 1) {
+      arith_encode(cinfo, st, 1);
+      m = 1;
+      v2 = v;
+      if (v2 >>= 1) {
+        arith_encode(cinfo, st, 1);
+        m <<= 1;
+        st = entropy->ac_stats[tbl] +
+             (k <= cinfo->arith_ac_K[tbl] ? 189 : 217);
+        while (v2 >>= 1) {
+          arith_encode(cinfo, st, 1);
+          m <<= 1;
+          st += 1;
+        }
+      }
+    }
+    arith_encode(cinfo, st, 0);
+    /* Figure F.9: Encoding the magnitude bit pattern of v */
+    st += 14;
+    while (m >>= 1)
+      arith_encode(cinfo, st, (m & v) ? 1 : 0);
+  }
+  /* Encode EOB decision only if k <= cinfo->Se */
+  if (k <= cinfo->Se) {
+    st = entropy->ac_stats[tbl] + 3 * (k - 1);
+    arith_encode(cinfo, st, 1);
+  }
+
+  return TRUE;
+}
+
+
+/*
+ * MCU encoding for DC successive approximation refinement scan.
+ */
+
+METHODDEF(boolean)
+encode_mcu_DC_refine(j_compress_ptr cinfo, JBLOCKROW *MCU_data)
+{
+  arith_entropy_ptr entropy = (arith_entropy_ptr)cinfo->entropy;
+  unsigned char *st;
+  int Al, blkn;
+
+  /* Emit restart marker if needed */
+  if (cinfo->restart_interval) {
+    if (entropy->restarts_to_go == 0) {
+      emit_restart(cinfo, entropy->next_restart_num);
+      entropy->restarts_to_go = cinfo->restart_interval;
+      entropy->next_restart_num++;
+      entropy->next_restart_num &= 7;
+    }
+    entropy->restarts_to_go--;
+  }
+
+  st = entropy->fixed_bin;      /* use fixed probability estimation */
+  Al = cinfo->Al;
+
+  /* Encode the MCU data blocks */
+  for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
+    /* We simply emit the Al'th bit of the DC coefficient value. */
+    arith_encode(cinfo, st, (MCU_data[blkn][0][0] >> Al) & 1);
+  }
+
+  return TRUE;
+}
+
+
+/*
+ * MCU encoding for AC successive approximation refinement scan.
+ */
+
+METHODDEF(boolean)
+encode_mcu_AC_refine(j_compress_ptr cinfo, JBLOCKROW *MCU_data)
+{
+  arith_entropy_ptr entropy = (arith_entropy_ptr)cinfo->entropy;
+  JBLOCKROW block;
+  unsigned char *st;
+  int tbl, k, ke, kex;
+  int v;
+
+  /* Emit restart marker if needed */
+  if (cinfo->restart_interval) {
+    if (entropy->restarts_to_go == 0) {
+      emit_restart(cinfo, entropy->next_restart_num);
+      entropy->restarts_to_go = cinfo->restart_interval;
+      entropy->next_restart_num++;
+      entropy->next_restart_num &= 7;
+    }
+    entropy->restarts_to_go--;
+  }
+
+  /* Encode the MCU data block */
+  block = MCU_data[0];
+  tbl = cinfo->cur_comp_info[0]->ac_tbl_no;
+
+  /* Section G.1.3.3: Encoding of AC coefficients */
+
+  /* Establish EOB (end-of-block) index */
+  for (ke = cinfo->Se; ke > 0; ke--)
+    /* We must apply the point transform by Al.  For AC coefficients this
+     * is an integer division with rounding towards 0.  To do this portably
+     * in C, we shift after obtaining the absolute value.
+     */
+    if ((v = (*block)[jpeg_natural_order[ke]]) >= 0) {
+      if (v >>= cinfo->Al) break;
+    } else {
+      v = -v;
+      if (v >>= cinfo->Al) break;
+    }
+
+  /* Establish EOBx (previous stage end-of-block) index */
+  for (kex = ke; kex > 0; kex--)
+    if ((v = (*block)[jpeg_natural_order[kex]]) >= 0) {
+      if (v >>= cinfo->Ah) break;
+    } else {
+      v = -v;
+      if (v >>= cinfo->Ah) break;
+    }
+
+  /* Figure G.10: Encode_AC_Coefficients_SA */
+  for (k = cinfo->Ss; k <= ke; k++) {
+    st = entropy->ac_stats[tbl] + 3 * (k - 1);
+    if (k > kex)
+      arith_encode(cinfo, st, 0);       /* EOB decision */
+    for (;;) {
+      if ((v = (*block)[jpeg_natural_order[k]]) >= 0) {
+        if (v >>= cinfo->Al) {
+          if (v >> 1)                   /* previously nonzero coef */
+            arith_encode(cinfo, st + 2, (v & 1));
+          else {                        /* newly nonzero coef */
+            arith_encode(cinfo, st + 1, 1);
+            arith_encode(cinfo, entropy->fixed_bin, 0);
+          }
+          break;
+        }
+      } else {
+        v = -v;
+        if (v >>= cinfo->Al) {
+          if (v >> 1)                   /* previously nonzero coef */
+            arith_encode(cinfo, st + 2, (v & 1));
+          else {                        /* newly nonzero coef */
+            arith_encode(cinfo, st + 1, 1);
+            arith_encode(cinfo, entropy->fixed_bin, 1);
+          }
+          break;
+        }
+      }
+      arith_encode(cinfo, st + 1, 0);  st += 3;  k++;
+    }
+  }
+  /* Encode EOB decision only if k <= cinfo->Se */
+  if (k <= cinfo->Se) {
+    st = entropy->ac_stats[tbl] + 3 * (k - 1);
+    arith_encode(cinfo, st, 1);
+  }
+
+  return TRUE;
+}
+
+
+/*
+ * Encode and output one MCU's worth of arithmetic-compressed coefficients.
+ */
+
+METHODDEF(boolean)
+encode_mcu(j_compress_ptr cinfo, JBLOCKROW *MCU_data)
+{
+  arith_entropy_ptr entropy = (arith_entropy_ptr)cinfo->entropy;
+  jpeg_component_info *compptr;
+  JBLOCKROW block;
+  unsigned char *st;
+  int blkn, ci, tbl, k, ke;
+  int v, v2, m;
+
+  /* Emit restart marker if needed */
+  if (cinfo->restart_interval) {
+    if (entropy->restarts_to_go == 0) {
+      emit_restart(cinfo, entropy->next_restart_num);
+      entropy->restarts_to_go = cinfo->restart_interval;
+      entropy->next_restart_num++;
+      entropy->next_restart_num &= 7;
+    }
+    entropy->restarts_to_go--;
+  }
+
+  /* Encode the MCU data blocks */
+  for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
+    block = MCU_data[blkn];
+    ci = cinfo->MCU_membership[blkn];
+    compptr = cinfo->cur_comp_info[ci];
+
+    /* Sections F.1.4.1 & F.1.4.4.1: Encoding of DC coefficients */
+
+    tbl = compptr->dc_tbl_no;
+
+    /* Table F.4: Point to statistics bin S0 for DC coefficient coding */
+    st = entropy->dc_stats[tbl] + entropy->dc_context[ci];
+
+    /* Figure F.4: Encode_DC_DIFF */
+    if ((v = (*block)[0] - entropy->last_dc_val[ci]) == 0) {
+      arith_encode(cinfo, st, 0);
+      entropy->dc_context[ci] = 0;      /* zero diff category */
+    } else {
+      entropy->last_dc_val[ci] = (*block)[0];
+      arith_encode(cinfo, st, 1);
+      /* Figure F.6: Encoding nonzero value v */
+      /* Figure F.7: Encoding the sign of v */
+      if (v > 0) {
+        arith_encode(cinfo, st + 1, 0); /* Table F.4: SS = S0 + 1 */
+        st += 2;                        /* Table F.4: SP = S0 + 2 */
+        entropy->dc_context[ci] = 4;    /* small positive diff category */
+      } else {
+        v = -v;
+        arith_encode(cinfo, st + 1, 1); /* Table F.4: SS = S0 + 1 */
+        st += 3;                        /* Table F.4: SN = S0 + 3 */
+        entropy->dc_context[ci] = 8;    /* small negative diff category */
+      }
+      /* Figure F.8: Encoding the magnitude category of v */
+      m = 0;
+      if (v -= 1) {
+        arith_encode(cinfo, st, 1);
+        m = 1;
+        v2 = v;
+        st = entropy->dc_stats[tbl] + 20; /* Table F.4: X1 = 20 */
+        while (v2 >>= 1) {
+          arith_encode(cinfo, st, 1);
+          m <<= 1;
+          st += 1;
+        }
+      }
+      arith_encode(cinfo, st, 0);
+      /* Section F.1.4.4.1.2: Establish dc_context conditioning category */
+      if (m < (int)((1L << cinfo->arith_dc_L[tbl]) >> 1))
+        entropy->dc_context[ci] = 0;    /* zero diff category */
+      else if (m > (int)((1L << cinfo->arith_dc_U[tbl]) >> 1))
+        entropy->dc_context[ci] += 8;   /* large diff category */
+      /* Figure F.9: Encoding the magnitude bit pattern of v */
+      st += 14;
+      while (m >>= 1)
+        arith_encode(cinfo, st, (m & v) ? 1 : 0);
+    }
+
+    /* Sections F.1.4.2 & F.1.4.4.2: Encoding of AC coefficients */
+
+    tbl = compptr->ac_tbl_no;
+
+    /* Establish EOB (end-of-block) index */
+    for (ke = DCTSIZE2 - 1; ke > 0; ke--)
+      if ((*block)[jpeg_natural_order[ke]]) break;
+
+    /* Figure F.5: Encode_AC_Coefficients */
+    for (k = 1; k <= ke; k++) {
+      st = entropy->ac_stats[tbl] + 3 * (k - 1);
+      arith_encode(cinfo, st, 0);       /* EOB decision */
+      while ((v = (*block)[jpeg_natural_order[k]]) == 0) {
+        arith_encode(cinfo, st + 1, 0);  st += 3;  k++;
+      }
+      arith_encode(cinfo, st + 1, 1);
+      /* Figure F.6: Encoding nonzero value v */
+      /* Figure F.7: Encoding the sign of v */
+      if (v > 0) {
+        arith_encode(cinfo, entropy->fixed_bin, 0);
+      } else {
+        v = -v;
+        arith_encode(cinfo, entropy->fixed_bin, 1);
+      }
+      st += 2;
+      /* Figure F.8: Encoding the magnitude category of v */
+      m = 0;
+      if (v -= 1) {
+        arith_encode(cinfo, st, 1);
+        m = 1;
+        v2 = v;
+        if (v2 >>= 1) {
+          arith_encode(cinfo, st, 1);
+          m <<= 1;
+          st = entropy->ac_stats[tbl] +
+               (k <= cinfo->arith_ac_K[tbl] ? 189 : 217);
+          while (v2 >>= 1) {
+            arith_encode(cinfo, st, 1);
+            m <<= 1;
+            st += 1;
+          }
+        }
+      }
+      arith_encode(cinfo, st, 0);
+      /* Figure F.9: Encoding the magnitude bit pattern of v */
+      st += 14;
+      while (m >>= 1)
+        arith_encode(cinfo, st, (m & v) ? 1 : 0);
+    }
+    /* Encode EOB decision only if k <= DCTSIZE2 - 1 */
+    if (k <= DCTSIZE2 - 1) {
+      st = entropy->ac_stats[tbl] + 3 * (k - 1);
+      arith_encode(cinfo, st, 1);
+    }
+  }
+
+  return TRUE;
+}
+
+
+/*
+ * Initialize for an arithmetic-compressed scan.
+ */
+
+METHODDEF(void)
+start_pass(j_compress_ptr cinfo, boolean gather_statistics)
+{
+  arith_entropy_ptr entropy = (arith_entropy_ptr)cinfo->entropy;
+  int ci, tbl;
+  jpeg_component_info *compptr;
+
+  if (gather_statistics)
+    /* Make sure to avoid that in the master control logic!
+     * We are fully adaptive here and need no extra
+     * statistics gathering pass!
+     */
+    ERREXIT(cinfo, JERR_NOT_COMPILED);
+
+  /* We assume jcmaster.c already validated the progressive scan parameters. */
+
+  /* Select execution routines */
+  if (cinfo->progressive_mode) {
+    if (cinfo->Ah == 0) {
+      if (cinfo->Ss == 0)
+        entropy->pub.encode_mcu = encode_mcu_DC_first;
+      else
+        entropy->pub.encode_mcu = encode_mcu_AC_first;
+    } else {
+      if (cinfo->Ss == 0)
+        entropy->pub.encode_mcu = encode_mcu_DC_refine;
+      else
+        entropy->pub.encode_mcu = encode_mcu_AC_refine;
+    }
+  } else
+    entropy->pub.encode_mcu = encode_mcu;
+
+  /* Allocate & initialize requested statistics areas */
+  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+    compptr = cinfo->cur_comp_info[ci];
+    /* DC needs no table for refinement scan */
+    if (cinfo->progressive_mode == 0 || (cinfo->Ss == 0 && cinfo->Ah == 0)) {
+      tbl = compptr->dc_tbl_no;
+      if (tbl < 0 || tbl >= NUM_ARITH_TBLS)
+        ERREXIT1(cinfo, JERR_NO_ARITH_TABLE, tbl);
+      if (entropy->dc_stats[tbl] == NULL)
+        entropy->dc_stats[tbl] = (unsigned char *)(*cinfo->mem->alloc_small)
+          ((j_common_ptr)cinfo, JPOOL_IMAGE, DC_STAT_BINS);
+      MEMZERO(entropy->dc_stats[tbl], DC_STAT_BINS);
+      /* Initialize DC predictions to 0 */
+      entropy->last_dc_val[ci] = 0;
+      entropy->dc_context[ci] = 0;
+    }
+    /* AC needs no table when not present */
+    if (cinfo->progressive_mode == 0 || cinfo->Se) {
+      tbl = compptr->ac_tbl_no;
+      if (tbl < 0 || tbl >= NUM_ARITH_TBLS)
+        ERREXIT1(cinfo, JERR_NO_ARITH_TABLE, tbl);
+      if (entropy->ac_stats[tbl] == NULL)
+        entropy->ac_stats[tbl] = (unsigned char *)(*cinfo->mem->alloc_small)
+          ((j_common_ptr)cinfo, JPOOL_IMAGE, AC_STAT_BINS);
+      MEMZERO(entropy->ac_stats[tbl], AC_STAT_BINS);
+#ifdef CALCULATE_SPECTRAL_CONDITIONING
+      if (cinfo->progressive_mode)
+        /* Section G.1.3.2: Set appropriate arithmetic conditioning value Kx */
+        cinfo->arith_ac_K[tbl] = cinfo->Ss +
+                                 ((8 + cinfo->Se - cinfo->Ss) >> 4);
+#endif
+    }
+  }
+
+  /* Initialize arithmetic encoding variables */
+  entropy->c = 0;
+  entropy->a = 0x10000L;
+  entropy->sc = 0;
+  entropy->zc = 0;
+  entropy->ct = 11;
+  entropy->buffer = -1;  /* empty */
+
+  /* Initialize restart stuff */
+  entropy->restarts_to_go = cinfo->restart_interval;
+  entropy->next_restart_num = 0;
+}
+
+
+/*
+ * Module initialization routine for arithmetic entropy encoding.
+ */
+
+GLOBAL(void)
+jinit_arith_encoder(j_compress_ptr cinfo)
+{
+  arith_entropy_ptr entropy;
+  int i;
+
+  entropy = (arith_entropy_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+                                sizeof(arith_entropy_encoder));
+  cinfo->entropy = (struct jpeg_entropy_encoder *)entropy;
+  entropy->pub.start_pass = start_pass;
+  entropy->pub.finish_pass = finish_pass;
+
+  /* Mark tables unallocated */
+  for (i = 0; i < NUM_ARITH_TBLS; i++) {
+    entropy->dc_stats[i] = NULL;
+    entropy->ac_stats[i] = NULL;
+  }
+
+  /* Initialize index for fixed probability estimation */
+  entropy->fixed_bin[0] = 113;
+}
diff --git a/3rdparty/libjpeg/src/jccoefct.c b/3rdparty/libjpeg/src/jccoefct.c
new file mode 100644
index 00000000..068232a5
--- /dev/null
+++ b/3rdparty/libjpeg/src/jccoefct.c
@@ -0,0 +1,449 @@
+/*
+ * jccoefct.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1994-1997, Thomas G. Lane.
+ * It was modified by The libjpeg-turbo Project to include only code and
+ * information relevant to libjpeg-turbo.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains the coefficient buffer controller for compression.
+ * This controller is the top level of the JPEG compressor proper.
+ * The coefficient buffer lies between forward-DCT and entropy encoding steps.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/* We use a full-image coefficient buffer when doing Huffman optimization,
+ * and also for writing multiple-scan JPEG files.  In all cases, the DCT
+ * step is run during the first pass, and subsequent passes need only read
+ * the buffered coefficients.
+ */
+#ifdef ENTROPY_OPT_SUPPORTED
+#define FULL_COEF_BUFFER_SUPPORTED
+#else
+#ifdef C_MULTISCAN_FILES_SUPPORTED
+#define FULL_COEF_BUFFER_SUPPORTED
+#endif
+#endif
+
+
+/* Private buffer controller object */
+
+typedef struct {
+  struct jpeg_c_coef_controller pub; /* public fields */
+
+  JDIMENSION iMCU_row_num;      /* iMCU row # within image */
+  JDIMENSION mcu_ctr;           /* counts MCUs processed in current row */
+  int MCU_vert_offset;          /* counts MCU rows within iMCU row */
+  int MCU_rows_per_iMCU_row;    /* number of such rows needed */
+
+  /* For single-pass compression, it's sufficient to buffer just one MCU
+   * (although this may prove a bit slow in practice).  We allocate a
+   * workspace of C_MAX_BLOCKS_IN_MCU coefficient blocks, and reuse it for each
+   * MCU constructed and sent.  In multi-pass modes, this array points to the
+   * current MCU's blocks within the virtual arrays.
+   */
+  JBLOCKROW MCU_buffer[C_MAX_BLOCKS_IN_MCU];
+
+  /* In multi-pass modes, we need a virtual block array for each component. */
+  jvirt_barray_ptr whole_image[MAX_COMPONENTS];
+} my_coef_controller;
+
+typedef my_coef_controller *my_coef_ptr;
+
+
+/* Forward declarations */
+METHODDEF(boolean) compress_data(j_compress_ptr cinfo, JSAMPIMAGE input_buf);
+#ifdef FULL_COEF_BUFFER_SUPPORTED
+METHODDEF(boolean) compress_first_pass(j_compress_ptr cinfo,
+                                       JSAMPIMAGE input_buf);
+METHODDEF(boolean) compress_output(j_compress_ptr cinfo, JSAMPIMAGE input_buf);
+#endif
+
+
+LOCAL(void)
+start_iMCU_row(j_compress_ptr cinfo)
+/* Reset within-iMCU-row counters for a new row */
+{
+  my_coef_ptr coef = (my_coef_ptr)cinfo->coef;
+
+  /* In an interleaved scan, an MCU row is the same as an iMCU row.
+   * In a noninterleaved scan, an iMCU row has v_samp_factor MCU rows.
+   * But at the bottom of the image, process only what's left.
+   */
+  if (cinfo->comps_in_scan > 1) {
+    coef->MCU_rows_per_iMCU_row = 1;
+  } else {
+    if (coef->iMCU_row_num < (cinfo->total_iMCU_rows - 1))
+      coef->MCU_rows_per_iMCU_row = cinfo->cur_comp_info[0]->v_samp_factor;
+    else
+      coef->MCU_rows_per_iMCU_row = cinfo->cur_comp_info[0]->last_row_height;
+  }
+
+  coef->mcu_ctr = 0;
+  coef->MCU_vert_offset = 0;
+}
+
+
+/*
+ * Initialize for a processing pass.
+ */
+
+METHODDEF(void)
+start_pass_coef(j_compress_ptr cinfo, J_BUF_MODE pass_mode)
+{
+  my_coef_ptr coef = (my_coef_ptr)cinfo->coef;
+
+  coef->iMCU_row_num = 0;
+  start_iMCU_row(cinfo);
+
+  switch (pass_mode) {
+  case JBUF_PASS_THRU:
+    if (coef->whole_image[0] != NULL)
+      ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+    coef->pub.compress_data = compress_data;
+    break;
+#ifdef FULL_COEF_BUFFER_SUPPORTED
+  case JBUF_SAVE_AND_PASS:
+    if (coef->whole_image[0] == NULL)
+      ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+    coef->pub.compress_data = compress_first_pass;
+    break;
+  case JBUF_CRANK_DEST:
+    if (coef->whole_image[0] == NULL)
+      ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+    coef->pub.compress_data = compress_output;
+    break;
+#endif
+  default:
+    ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+    break;
+  }
+}
+
+
+/*
+ * Process some data in the single-pass case.
+ * We process the equivalent of one fully interleaved MCU row ("iMCU" row)
+ * per call, ie, v_samp_factor block rows for each component in the image.
+ * Returns TRUE if the iMCU row is completed, FALSE if suspended.
+ *
+ * NB: input_buf contains a plane for each component in image,
+ * which we index according to the component's SOF position.
+ */
+
+METHODDEF(boolean)
+compress_data(j_compress_ptr cinfo, JSAMPIMAGE input_buf)
+{
+  my_coef_ptr coef = (my_coef_ptr)cinfo->coef;
+  JDIMENSION MCU_col_num;       /* index of current MCU within row */
+  JDIMENSION last_MCU_col = cinfo->MCUs_per_row - 1;
+  JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1;
+  int blkn, bi, ci, yindex, yoffset, blockcnt;
+  JDIMENSION ypos, xpos;
+  jpeg_component_info *compptr;
+
+  /* Loop to write as much as one whole iMCU row */
+  for (yoffset = coef->MCU_vert_offset; yoffset < coef->MCU_rows_per_iMCU_row;
+       yoffset++) {
+    for (MCU_col_num = coef->mcu_ctr; MCU_col_num <= last_MCU_col;
+         MCU_col_num++) {
+      /* Determine where data comes from in input_buf and do the DCT thing.
+       * Each call on forward_DCT processes a horizontal row of DCT blocks
+       * as wide as an MCU; we rely on having allocated the MCU_buffer[] blocks
+       * sequentially.  Dummy blocks at the right or bottom edge are filled in
+       * specially.  The data in them does not matter for image reconstruction,
+       * so we fill them with values that will encode to the smallest amount of
+       * data, viz: all zeroes in the AC entries, DC entries equal to previous
+       * block's DC value.  (Thanks to Thomas Kinsman for this idea.)
+       */
+      blkn = 0;
+      for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+        compptr = cinfo->cur_comp_info[ci];
+        blockcnt = (MCU_col_num < last_MCU_col) ? compptr->MCU_width :
+                                                  compptr->last_col_width;
+        xpos = MCU_col_num * compptr->MCU_sample_width;
+        ypos = yoffset * DCTSIZE; /* ypos == (yoffset+yindex) * DCTSIZE */
+        for (yindex = 0; yindex < compptr->MCU_height; yindex++) {
+          if (coef->iMCU_row_num < last_iMCU_row ||
+              yoffset + yindex < compptr->last_row_height) {
+            (*cinfo->fdct->forward_DCT) (cinfo, compptr,
+                                         input_buf[compptr->component_index],
+                                         coef->MCU_buffer[blkn],
+                                         ypos, xpos, (JDIMENSION)blockcnt);
+            if (blockcnt < compptr->MCU_width) {
+              /* Create some dummy blocks at the right edge of the image. */
+              jzero_far((void *)coef->MCU_buffer[blkn + blockcnt],
+                        (compptr->MCU_width - blockcnt) * sizeof(JBLOCK));
+              for (bi = blockcnt; bi < compptr->MCU_width; bi++) {
+                coef->MCU_buffer[blkn + bi][0][0] =
+                  coef->MCU_buffer[blkn + bi - 1][0][0];
+              }
+            }
+          } else {
+            /* Create a row of dummy blocks at the bottom of the image. */
+            jzero_far((void *)coef->MCU_buffer[blkn],
+                      compptr->MCU_width * sizeof(JBLOCK));
+            for (bi = 0; bi < compptr->MCU_width; bi++) {
+              coef->MCU_buffer[blkn + bi][0][0] =
+                coef->MCU_buffer[blkn - 1][0][0];
+            }
+          }
+          blkn += compptr->MCU_width;
+          ypos += DCTSIZE;
+        }
+      }
+      /* Try to write the MCU.  In event of a suspension failure, we will
+       * re-DCT the MCU on restart (a bit inefficient, could be fixed...)
+       */
+      if (!(*cinfo->entropy->encode_mcu) (cinfo, coef->MCU_buffer)) {
+        /* Suspension forced; update state counters and exit */
+        coef->MCU_vert_offset = yoffset;
+        coef->mcu_ctr = MCU_col_num;
+        return FALSE;
+      }
+    }
+    /* Completed an MCU row, but perhaps not an iMCU row */
+    coef->mcu_ctr = 0;
+  }
+  /* Completed the iMCU row, advance counters for next one */
+  coef->iMCU_row_num++;
+  start_iMCU_row(cinfo);
+  return TRUE;
+}
+
+
+#ifdef FULL_COEF_BUFFER_SUPPORTED
+
+/*
+ * Process some data in the first pass of a multi-pass case.
+ * We process the equivalent of one fully interleaved MCU row ("iMCU" row)
+ * per call, ie, v_samp_factor block rows for each component in the image.
+ * This amount of data is read from the source buffer, DCT'd and quantized,
+ * and saved into the virtual arrays.  We also generate suitable dummy blocks
+ * as needed at the right and lower edges.  (The dummy blocks are constructed
+ * in the virtual arrays, which have been padded appropriately.)  This makes
+ * it possible for subsequent passes not to worry about real vs. dummy blocks.
+ *
+ * We must also emit the data to the entropy encoder.  This is conveniently
+ * done by calling compress_output() after we've loaded the current strip
+ * of the virtual arrays.
+ *
+ * NB: input_buf contains a plane for each component in image.  All
+ * components are DCT'd and loaded into the virtual arrays in this pass.
+ * However, it may be that only a subset of the components are emitted to
+ * the entropy encoder during this first pass; be careful about looking
+ * at the scan-dependent variables (MCU dimensions, etc).
+ */
+
+METHODDEF(boolean)
+compress_first_pass(j_compress_ptr cinfo, JSAMPIMAGE input_buf)
+{
+  my_coef_ptr coef = (my_coef_ptr)cinfo->coef;
+  JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1;
+  JDIMENSION blocks_across, MCUs_across, MCUindex;
+  int bi, ci, h_samp_factor, block_row, block_rows, ndummy;
+  JCOEF lastDC;
+  jpeg_component_info *compptr;
+  JBLOCKARRAY buffer;
+  JBLOCKROW thisblockrow, lastblockrow;
+
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    /* Align the virtual buffer for this component. */
+    buffer = (*cinfo->mem->access_virt_barray)
+      ((j_common_ptr)cinfo, coef->whole_image[ci],
+       coef->iMCU_row_num * compptr->v_samp_factor,
+       (JDIMENSION)compptr->v_samp_factor, TRUE);
+    /* Count non-dummy DCT block rows in this iMCU row. */
+    if (coef->iMCU_row_num < last_iMCU_row)
+      block_rows = compptr->v_samp_factor;
+    else {
+      /* NB: can't use last_row_height here, since may not be set! */
+      block_rows = (int)(compptr->height_in_blocks % compptr->v_samp_factor);
+      if (block_rows == 0) block_rows = compptr->v_samp_factor;
+    }
+    blocks_across = compptr->width_in_blocks;
+    h_samp_factor = compptr->h_samp_factor;
+    /* Count number of dummy blocks to be added at the right margin. */
+    ndummy = (int)(blocks_across % h_samp_factor);
+    if (ndummy > 0)
+      ndummy = h_samp_factor - ndummy;
+    /* Perform DCT for all non-dummy blocks in this iMCU row.  Each call
+     * on forward_DCT processes a complete horizontal row of DCT blocks.
+     */
+    for (block_row = 0; block_row < block_rows; block_row++) {
+      thisblockrow = buffer[block_row];
+      (*cinfo->fdct->forward_DCT) (cinfo, compptr,
+                                   input_buf[ci], thisblockrow,
+                                   (JDIMENSION)(block_row * DCTSIZE),
+                                   (JDIMENSION)0, blocks_across);
+      if (ndummy > 0) {
+        /* Create dummy blocks at the right edge of the image. */
+        thisblockrow += blocks_across; /* => first dummy block */
+        jzero_far((void *)thisblockrow, ndummy * sizeof(JBLOCK));
+        lastDC = thisblockrow[-1][0];
+        for (bi = 0; bi < ndummy; bi++) {
+          thisblockrow[bi][0] = lastDC;
+        }
+      }
+    }
+    /* If at end of image, create dummy block rows as needed.
+     * The tricky part here is that within each MCU, we want the DC values
+     * of the dummy blocks to match the last real block's DC value.
+     * This squeezes a few more bytes out of the resulting file...
+     */
+    if (coef->iMCU_row_num == last_iMCU_row) {
+      blocks_across += ndummy;  /* include lower right corner */
+      MCUs_across = blocks_across / h_samp_factor;
+      for (block_row = block_rows; block_row < compptr->v_samp_factor;
+           block_row++) {
+        thisblockrow = buffer[block_row];
+        lastblockrow = buffer[block_row - 1];
+        jzero_far((void *)thisblockrow,
+                  (size_t)(blocks_across * sizeof(JBLOCK)));
+        for (MCUindex = 0; MCUindex < MCUs_across; MCUindex++) {
+          lastDC = lastblockrow[h_samp_factor - 1][0];
+          for (bi = 0; bi < h_samp_factor; bi++) {
+            thisblockrow[bi][0] = lastDC;
+          }
+          thisblockrow += h_samp_factor; /* advance to next MCU in row */
+          lastblockrow += h_samp_factor;
+        }
+      }
+    }
+  }
+  /* NB: compress_output will increment iMCU_row_num if successful.
+   * A suspension return will result in redoing all the work above next time.
+   */
+
+  /* Emit data to the entropy encoder, sharing code with subsequent passes */
+  return compress_output(cinfo, input_buf);
+}
+
+
+/*
+ * Process some data in subsequent passes of a multi-pass case.
+ * We process the equivalent of one fully interleaved MCU row ("iMCU" row)
+ * per call, ie, v_samp_factor block rows for each component in the scan.
+ * The data is obtained from the virtual arrays and fed to the entropy coder.
+ * Returns TRUE if the iMCU row is completed, FALSE if suspended.
+ *
+ * NB: input_buf is ignored; it is likely to be a NULL pointer.
+ */
+
+METHODDEF(boolean)
+compress_output(j_compress_ptr cinfo, JSAMPIMAGE input_buf)
+{
+  my_coef_ptr coef = (my_coef_ptr)cinfo->coef;
+  JDIMENSION MCU_col_num;       /* index of current MCU within row */
+  int blkn, ci, xindex, yindex, yoffset;
+  JDIMENSION start_col;
+  JBLOCKARRAY buffer[MAX_COMPS_IN_SCAN];
+  JBLOCKROW buffer_ptr;
+  jpeg_component_info *compptr;
+
+  /* Align the virtual buffers for the components used in this scan.
+   * NB: during first pass, this is safe only because the buffers will
+   * already be aligned properly, so jmemmgr.c won't need to do any I/O.
+   */
+  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+    compptr = cinfo->cur_comp_info[ci];
+    buffer[ci] = (*cinfo->mem->access_virt_barray)
+      ((j_common_ptr)cinfo, coef->whole_image[compptr->component_index],
+       coef->iMCU_row_num * compptr->v_samp_factor,
+       (JDIMENSION)compptr->v_samp_factor, FALSE);
+  }
+
+  /* Loop to process one whole iMCU row */
+  for (yoffset = coef->MCU_vert_offset; yoffset < coef->MCU_rows_per_iMCU_row;
+       yoffset++) {
+    for (MCU_col_num = coef->mcu_ctr; MCU_col_num < cinfo->MCUs_per_row;
+         MCU_col_num++) {
+      /* Construct list of pointers to DCT blocks belonging to this MCU */
+      blkn = 0;                 /* index of current DCT block within MCU */
+      for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+        compptr = cinfo->cur_comp_info[ci];
+        start_col = MCU_col_num * compptr->MCU_width;
+        for (yindex = 0; yindex < compptr->MCU_height; yindex++) {
+          buffer_ptr = buffer[ci][yindex + yoffset] + start_col;
+          for (xindex = 0; xindex < compptr->MCU_width; xindex++) {
+            coef->MCU_buffer[blkn++] = buffer_ptr++;
+          }
+        }
+      }
+      /* Try to write the MCU. */
+      if (!(*cinfo->entropy->encode_mcu) (cinfo, coef->MCU_buffer)) {
+        /* Suspension forced; update state counters and exit */
+        coef->MCU_vert_offset = yoffset;
+        coef->mcu_ctr = MCU_col_num;
+        return FALSE;
+      }
+    }
+    /* Completed an MCU row, but perhaps not an iMCU row */
+    coef->mcu_ctr = 0;
+  }
+  /* Completed the iMCU row, advance counters for next one */
+  coef->iMCU_row_num++;
+  start_iMCU_row(cinfo);
+  return TRUE;
+}
+
+#endif /* FULL_COEF_BUFFER_SUPPORTED */
+
+
+/*
+ * Initialize coefficient buffer controller.
+ */
+
+GLOBAL(void)
+jinit_c_coef_controller(j_compress_ptr cinfo, boolean need_full_buffer)
+{
+  my_coef_ptr coef;
+
+  coef = (my_coef_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+                                sizeof(my_coef_controller));
+  cinfo->coef = (struct jpeg_c_coef_controller *)coef;
+  coef->pub.start_pass = start_pass_coef;
+
+  /* Create the coefficient buffer. */
+  if (need_full_buffer) {
+#ifdef FULL_COEF_BUFFER_SUPPORTED
+    /* Allocate a full-image virtual array for each component, */
+    /* padded to a multiple of samp_factor DCT blocks in each direction. */
+    int ci;
+    jpeg_component_info *compptr;
+
+    for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+         ci++, compptr++) {
+      coef->whole_image[ci] = (*cinfo->mem->request_virt_barray)
+        ((j_common_ptr)cinfo, JPOOL_IMAGE, FALSE,
+         (JDIMENSION)jround_up((long)compptr->width_in_blocks,
+                               (long)compptr->h_samp_factor),
+         (JDIMENSION)jround_up((long)compptr->height_in_blocks,
+                               (long)compptr->v_samp_factor),
+         (JDIMENSION)compptr->v_samp_factor);
+    }
+#else
+    ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+#endif
+  } else {
+    /* We only need a single-MCU buffer. */
+    JBLOCKROW buffer;
+    int i;
+
+    buffer = (JBLOCKROW)
+      (*cinfo->mem->alloc_large) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+                                  C_MAX_BLOCKS_IN_MCU * sizeof(JBLOCK));
+    for (i = 0; i < C_MAX_BLOCKS_IN_MCU; i++) {
+      coef->MCU_buffer[i] = buffer + i;
+    }
+    coef->whole_image[0] = NULL; /* flag for no virtual arrays */
+  }
+}
diff --git a/3rdparty/libjpeg/src/jccolext.c b/3rdparty/libjpeg/src/jccolext.c
new file mode 100644
index 00000000..303b322c
--- /dev/null
+++ b/3rdparty/libjpeg/src/jccolext.c
@@ -0,0 +1,144 @@
+/*
+ * jccolext.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1991-1996, Thomas G. Lane.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2009-2012, 2015, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains input colorspace conversion routines.
+ */
+
+
+/* This file is included by jccolor.c */
+
+
+/*
+ * Convert some rows of samples to the JPEG colorspace.
+ *
+ * Note that we change from the application's interleaved-pixel format
+ * to our internal noninterleaved, one-plane-per-component format.
+ * The input buffer is therefore three times as wide as the output buffer.
+ *
+ * A starting row offset is provided only for the output buffer.  The caller
+ * can easily adjust the passed input_buf value to accommodate any row
+ * offset required on that side.
+ */
+
+INLINE
+LOCAL(void)
+rgb_ycc_convert_internal(j_compress_ptr cinfo, JSAMPARRAY input_buf,
+                         JSAMPIMAGE output_buf, JDIMENSION output_row,
+                         int num_rows)
+{
+  my_cconvert_ptr cconvert = (my_cconvert_ptr)cinfo->cconvert;
+  register int r, g, b;
+  register JLONG *ctab = cconvert->rgb_ycc_tab;
+  register JSAMPROW inptr;
+  register JSAMPROW outptr0, outptr1, outptr2;
+  register JDIMENSION col;
+  JDIMENSION num_cols = cinfo->image_width;
+
+  while (--num_rows >= 0) {
+    inptr = *input_buf++;
+    outptr0 = output_buf[0][output_row];
+    outptr1 = output_buf[1][output_row];
+    outptr2 = output_buf[2][output_row];
+    output_row++;
+    for (col = 0; col < num_cols; col++) {
+      r = inptr[RGB_RED];
+      g = inptr[RGB_GREEN];
+      b = inptr[RGB_BLUE];
+      inptr += RGB_PIXELSIZE;
+      /* If the inputs are 0..MAXJSAMPLE, the outputs of these equations
+       * must be too; we do not need an explicit range-limiting operation.
+       * Hence the value being shifted is never negative, and we don't
+       * need the general RIGHT_SHIFT macro.
+       */
+      /* Y */
+      outptr0[col] = (JSAMPLE)((ctab[r + R_Y_OFF] + ctab[g + G_Y_OFF] +
+                                ctab[b + B_Y_OFF]) >> SCALEBITS);
+      /* Cb */
+      outptr1[col] = (JSAMPLE)((ctab[r + R_CB_OFF] + ctab[g + G_CB_OFF] +
+                                ctab[b + B_CB_OFF]) >> SCALEBITS);
+      /* Cr */
+      outptr2[col] = (JSAMPLE)((ctab[r + R_CR_OFF] + ctab[g + G_CR_OFF] +
+                                ctab[b + B_CR_OFF]) >> SCALEBITS);
+    }
+  }
+}
+
+
+/**************** Cases other than RGB -> YCbCr **************/
+
+
+/*
+ * Convert some rows of samples to the JPEG colorspace.
+ * This version handles RGB->grayscale conversion, which is the same
+ * as the RGB->Y portion of RGB->YCbCr.
+ * We assume rgb_ycc_start has been called (we only use the Y tables).
+ */
+
+INLINE
+LOCAL(void)
+rgb_gray_convert_internal(j_compress_ptr cinfo, JSAMPARRAY input_buf,
+                          JSAMPIMAGE output_buf, JDIMENSION output_row,
+                          int num_rows)
+{
+  my_cconvert_ptr cconvert = (my_cconvert_ptr)cinfo->cconvert;
+  register int r, g, b;
+  register JLONG *ctab = cconvert->rgb_ycc_tab;
+  register JSAMPROW inptr;
+  register JSAMPROW outptr;
+  register JDIMENSION col;
+  JDIMENSION num_cols = cinfo->image_width;
+
+  while (--num_rows >= 0) {
+    inptr = *input_buf++;
+    outptr = output_buf[0][output_row];
+    output_row++;
+    for (col = 0; col < num_cols; col++) {
+      r = inptr[RGB_RED];
+      g = inptr[RGB_GREEN];
+      b = inptr[RGB_BLUE];
+      inptr += RGB_PIXELSIZE;
+      /* Y */
+      outptr[col] = (JSAMPLE)((ctab[r + R_Y_OFF] + ctab[g + G_Y_OFF] +
+                               ctab[b + B_Y_OFF]) >> SCALEBITS);
+    }
+  }
+}
+
+
+/*
+ * Convert some rows of samples to the JPEG colorspace.
+ * This version handles extended RGB->plain RGB conversion
+ */
+
+INLINE
+LOCAL(void)
+rgb_rgb_convert_internal(j_compress_ptr cinfo, JSAMPARRAY input_buf,
+                         JSAMPIMAGE output_buf, JDIMENSION output_row,
+                         int num_rows)
+{
+  register JSAMPROW inptr;
+  register JSAMPROW outptr0, outptr1, outptr2;
+  register JDIMENSION col;
+  JDIMENSION num_cols = cinfo->image_width;
+
+  while (--num_rows >= 0) {
+    inptr = *input_buf++;
+    outptr0 = output_buf[0][output_row];
+    outptr1 = output_buf[1][output_row];
+    outptr2 = output_buf[2][output_row];
+    output_row++;
+    for (col = 0; col < num_cols; col++) {
+      outptr0[col] = inptr[RGB_RED];
+      outptr1[col] = inptr[RGB_GREEN];
+      outptr2[col] = inptr[RGB_BLUE];
+      inptr += RGB_PIXELSIZE;
+    }
+  }
+}
diff --git a/3rdparty/libjpeg/src/jccolor.c b/3rdparty/libjpeg/src/jccolor.c
new file mode 100644
index 00000000..bdc563c7
--- /dev/null
+++ b/3rdparty/libjpeg/src/jccolor.c
@@ -0,0 +1,710 @@
+/*
+ * jccolor.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1991-1996, Thomas G. Lane.
+ * libjpeg-turbo Modifications:
+ * Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+ * Copyright (C) 2009-2012, 2015, D. R. Commander.
+ * Copyright (C) 2014, MIPS Technologies, Inc., California.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains input colorspace conversion routines.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jsimd.h"
+#include "jconfigint.h"
+
+
+/* Private subobject */
+
+typedef struct {
+  struct jpeg_color_converter pub; /* public fields */
+
+  /* Private state for RGB->YCC conversion */
+  JLONG *rgb_ycc_tab;           /* => table for RGB to YCbCr conversion */
+} my_color_converter;
+
+typedef my_color_converter *my_cconvert_ptr;
+
+
+/**************** RGB -> YCbCr conversion: most common case **************/
+
+/*
+ * YCbCr is defined per CCIR 601-1, except that Cb and Cr are
+ * normalized to the range 0..MAXJSAMPLE rather than -0.5 .. 0.5.
+ * The conversion equations to be implemented are therefore
+ *      Y  =  0.29900 * R + 0.58700 * G + 0.11400 * B
+ *      Cb = -0.16874 * R - 0.33126 * G + 0.50000 * B  + CENTERJSAMPLE
+ *      Cr =  0.50000 * R - 0.41869 * G - 0.08131 * B  + CENTERJSAMPLE
+ * (These numbers are derived from TIFF 6.0 section 21, dated 3-June-92.)
+ * Note: older versions of the IJG code used a zero offset of MAXJSAMPLE/2,
+ * rather than CENTERJSAMPLE, for Cb and Cr.  This gave equal positive and
+ * negative swings for Cb/Cr, but meant that grayscale values (Cb=Cr=0)
+ * were not represented exactly.  Now we sacrifice exact representation of
+ * maximum red and maximum blue in order to get exact grayscales.
+ *
+ * To avoid floating-point arithmetic, we represent the fractional constants
+ * as integers scaled up by 2^16 (about 4 digits precision); we have to divide
+ * the products by 2^16, with appropriate rounding, to get the correct answer.
+ *
+ * For even more speed, we avoid doing any multiplications in the inner loop
+ * by precalculating the constants times R,G,B for all possible values.
+ * For 8-bit JSAMPLEs this is very reasonable (only 256 entries per table);
+ * for 12-bit samples it is still acceptable.  It's not very reasonable for
+ * 16-bit samples, but if you want lossless storage you shouldn't be changing
+ * colorspace anyway.
+ * The CENTERJSAMPLE offsets and the rounding fudge-factor of 0.5 are included
+ * in the tables to save adding them separately in the inner loop.
+ */
+
+#define SCALEBITS       16      /* speediest right-shift on some machines */
+#define CBCR_OFFSET     ((JLONG)CENTERJSAMPLE << SCALEBITS)
+#define ONE_HALF        ((JLONG)1 << (SCALEBITS - 1))
+#define FIX(x)          ((JLONG)((x) * (1L << SCALEBITS) + 0.5))
+
+/* We allocate one big table and divide it up into eight parts, instead of
+ * doing eight alloc_small requests.  This lets us use a single table base
+ * address, which can be held in a register in the inner loops on many
+ * machines (more than can hold all eight addresses, anyway).
+ */
+
+#define R_Y_OFF         0                       /* offset to R => Y section */
+#define G_Y_OFF         (1 * (MAXJSAMPLE + 1))  /* offset to G => Y section */
+#define B_Y_OFF         (2 * (MAXJSAMPLE + 1))  /* etc. */
+#define R_CB_OFF        (3 * (MAXJSAMPLE + 1))
+#define G_CB_OFF        (4 * (MAXJSAMPLE + 1))
+#define B_CB_OFF        (5 * (MAXJSAMPLE + 1))
+#define R_CR_OFF        B_CB_OFF                /* B=>Cb, R=>Cr are the same */
+#define G_CR_OFF        (6 * (MAXJSAMPLE + 1))
+#define B_CR_OFF        (7 * (MAXJSAMPLE + 1))
+#define TABLE_SIZE      (8 * (MAXJSAMPLE + 1))
+
+
+/* Include inline routines for colorspace extensions */
+
+#include "jccolext.c"
+#undef RGB_RED
+#undef RGB_GREEN
+#undef RGB_BLUE
+#undef RGB_PIXELSIZE
+
+#define RGB_RED  EXT_RGB_RED
+#define RGB_GREEN  EXT_RGB_GREEN
+#define RGB_BLUE  EXT_RGB_BLUE
+#define RGB_PIXELSIZE  EXT_RGB_PIXELSIZE
+#define rgb_ycc_convert_internal  extrgb_ycc_convert_internal
+#define rgb_gray_convert_internal  extrgb_gray_convert_internal
+#define rgb_rgb_convert_internal  extrgb_rgb_convert_internal
+#include "jccolext.c"
+#undef RGB_RED
+#undef RGB_GREEN
+#undef RGB_BLUE
+#undef RGB_PIXELSIZE
+#undef rgb_ycc_convert_internal
+#undef rgb_gray_convert_internal
+#undef rgb_rgb_convert_internal
+
+#define RGB_RED  EXT_RGBX_RED
+#define RGB_GREEN  EXT_RGBX_GREEN
+#define RGB_BLUE  EXT_RGBX_BLUE
+#define RGB_PIXELSIZE  EXT_RGBX_PIXELSIZE
+#define rgb_ycc_convert_internal  extrgbx_ycc_convert_internal
+#define rgb_gray_convert_internal  extrgbx_gray_convert_internal
+#define rgb_rgb_convert_internal  extrgbx_rgb_convert_internal
+#include "jccolext.c"
+#undef RGB_RED
+#undef RGB_GREEN
+#undef RGB_BLUE
+#undef RGB_PIXELSIZE
+#undef rgb_ycc_convert_internal
+#undef rgb_gray_convert_internal
+#undef rgb_rgb_convert_internal
+
+#define RGB_RED  EXT_BGR_RED
+#define RGB_GREEN  EXT_BGR_GREEN
+#define RGB_BLUE  EXT_BGR_BLUE
+#define RGB_PIXELSIZE  EXT_BGR_PIXELSIZE
+#define rgb_ycc_convert_internal  extbgr_ycc_convert_internal
+#define rgb_gray_convert_internal  extbgr_gray_convert_internal
+#define rgb_rgb_convert_internal  extbgr_rgb_convert_internal
+#include "jccolext.c"
+#undef RGB_RED
+#undef RGB_GREEN
+#undef RGB_BLUE
+#undef RGB_PIXELSIZE
+#undef rgb_ycc_convert_internal
+#undef rgb_gray_convert_internal
+#undef rgb_rgb_convert_internal
+
+#define RGB_RED  EXT_BGRX_RED
+#define RGB_GREEN  EXT_BGRX_GREEN
+#define RGB_BLUE  EXT_BGRX_BLUE
+#define RGB_PIXELSIZE  EXT_BGRX_PIXELSIZE
+#define rgb_ycc_convert_internal  extbgrx_ycc_convert_internal
+#define rgb_gray_convert_internal  extbgrx_gray_convert_internal
+#define rgb_rgb_convert_internal  extbgrx_rgb_convert_internal
+#include "jccolext.c"
+#undef RGB_RED
+#undef RGB_GREEN
+#undef RGB_BLUE
+#undef RGB_PIXELSIZE
+#undef rgb_ycc_convert_internal
+#undef rgb_gray_convert_internal
+#undef rgb_rgb_convert_internal
+
+#define RGB_RED  EXT_XBGR_RED
+#define RGB_GREEN  EXT_XBGR_GREEN
+#define RGB_BLUE  EXT_XBGR_BLUE
+#define RGB_PIXELSIZE  EXT_XBGR_PIXELSIZE
+#define rgb_ycc_convert_internal  extxbgr_ycc_convert_internal
+#define rgb_gray_convert_internal  extxbgr_gray_convert_internal
+#define rgb_rgb_convert_internal  extxbgr_rgb_convert_internal
+#include "jccolext.c"
+#undef RGB_RED
+#undef RGB_GREEN
+#undef RGB_BLUE
+#undef RGB_PIXELSIZE
+#undef rgb_ycc_convert_internal
+#undef rgb_gray_convert_internal
+#undef rgb_rgb_convert_internal
+
+#define RGB_RED  EXT_XRGB_RED
+#define RGB_GREEN  EXT_XRGB_GREEN
+#define RGB_BLUE  EXT_XRGB_BLUE
+#define RGB_PIXELSIZE  EXT_XRGB_PIXELSIZE
+#define rgb_ycc_convert_internal  extxrgb_ycc_convert_internal
+#define rgb_gray_convert_internal  extxrgb_gray_convert_internal
+#define rgb_rgb_convert_internal  extxrgb_rgb_convert_internal
+#include "jccolext.c"
+#undef RGB_RED
+#undef RGB_GREEN
+#undef RGB_BLUE
+#undef RGB_PIXELSIZE
+#undef rgb_ycc_convert_internal
+#undef rgb_gray_convert_internal
+#undef rgb_rgb_convert_internal
+
+
+/*
+ * Initialize for RGB->YCC colorspace conversion.
+ */
+
+METHODDEF(void)
+rgb_ycc_start(j_compress_ptr cinfo)
+{
+  my_cconvert_ptr cconvert = (my_cconvert_ptr)cinfo->cconvert;
+  JLONG *rgb_ycc_tab;
+  JLONG i;
+
+  /* Allocate and fill in the conversion tables. */
+  cconvert->rgb_ycc_tab = rgb_ycc_tab = (JLONG *)
+    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+                                (TABLE_SIZE * sizeof(JLONG)));
+
+  for (i = 0; i <= MAXJSAMPLE; i++) {
+    rgb_ycc_tab[i + R_Y_OFF] = FIX(0.29900) * i;
+    rgb_ycc_tab[i + G_Y_OFF] = FIX(0.58700) * i;
+    rgb_ycc_tab[i + B_Y_OFF] = FIX(0.11400) * i   + ONE_HALF;
+    rgb_ycc_tab[i + R_CB_OFF] = (-FIX(0.16874)) * i;
+    rgb_ycc_tab[i + G_CB_OFF] = (-FIX(0.33126)) * i;
+    /* We use a rounding fudge-factor of 0.5-epsilon for Cb and Cr.
+     * This ensures that the maximum output will round to MAXJSAMPLE
+     * not MAXJSAMPLE+1, and thus that we don't have to range-limit.
+     */
+    rgb_ycc_tab[i + B_CB_OFF] = FIX(0.50000) * i  + CBCR_OFFSET + ONE_HALF - 1;
+/*  B=>Cb and R=>Cr tables are the same
+    rgb_ycc_tab[i + R_CR_OFF] = FIX(0.50000) * i  + CBCR_OFFSET + ONE_HALF - 1;
+*/
+    rgb_ycc_tab[i + G_CR_OFF] = (-FIX(0.41869)) * i;
+    rgb_ycc_tab[i + B_CR_OFF] = (-FIX(0.08131)) * i;
+  }
+}
+
+
+/*
+ * Convert some rows of samples to the JPEG colorspace.
+ */
+
+METHODDEF(void)
+rgb_ycc_convert(j_compress_ptr cinfo, JSAMPARRAY input_buf,
+                JSAMPIMAGE output_buf, JDIMENSION output_row, int num_rows)
+{
+  switch (cinfo->in_color_space) {
+  case JCS_EXT_RGB:
+    extrgb_ycc_convert_internal(cinfo, input_buf, output_buf, output_row,
+                                num_rows);
+    break;
+  case JCS_EXT_RGBX:
+  case JCS_EXT_RGBA:
+    extrgbx_ycc_convert_internal(cinfo, input_buf, output_buf, output_row,
+                                 num_rows);
+    break;
+  case JCS_EXT_BGR:
+    extbgr_ycc_convert_internal(cinfo, input_buf, output_buf, output_row,
+                                num_rows);
+    break;
+  case JCS_EXT_BGRX:
+  case JCS_EXT_BGRA:
+    extbgrx_ycc_convert_internal(cinfo, input_buf, output_buf, output_row,
+                                 num_rows);
+    break;
+  case JCS_EXT_XBGR:
+  case JCS_EXT_ABGR:
+    extxbgr_ycc_convert_internal(cinfo, input_buf, output_buf, output_row,
+                                 num_rows);
+    break;
+  case JCS_EXT_XRGB:
+  case JCS_EXT_ARGB:
+    extxrgb_ycc_convert_internal(cinfo, input_buf, output_buf, output_row,
+                                 num_rows);
+    break;
+  default:
+    rgb_ycc_convert_internal(cinfo, input_buf, output_buf, output_row,
+                             num_rows);
+    break;
+  }
+}
+
+
+/**************** Cases other than RGB -> YCbCr **************/
+
+
+/*
+ * Convert some rows of samples to the JPEG colorspace.
+ */
+
+METHODDEF(void)
+rgb_gray_convert(j_compress_ptr cinfo, JSAMPARRAY input_buf,
+                 JSAMPIMAGE output_buf, JDIMENSION output_row, int num_rows)
+{
+  switch (cinfo->in_color_space) {
+  case JCS_EXT_RGB:
+    extrgb_gray_convert_internal(cinfo, input_buf, output_buf, output_row,
+                                 num_rows);
+    break;
+  case JCS_EXT_RGBX:
+  case JCS_EXT_RGBA:
+    extrgbx_gray_convert_internal(cinfo, input_buf, output_buf, output_row,
+                                  num_rows);
+    break;
+  case JCS_EXT_BGR:
+    extbgr_gray_convert_internal(cinfo, input_buf, output_buf, output_row,
+                                 num_rows);
+    break;
+  case JCS_EXT_BGRX:
+  case JCS_EXT_BGRA:
+    extbgrx_gray_convert_internal(cinfo, input_buf, output_buf, output_row,
+                                  num_rows);
+    break;
+  case JCS_EXT_XBGR:
+  case JCS_EXT_ABGR:
+    extxbgr_gray_convert_internal(cinfo, input_buf, output_buf, output_row,
+                                  num_rows);
+    break;
+  case JCS_EXT_XRGB:
+  case JCS_EXT_ARGB:
+    extxrgb_gray_convert_internal(cinfo, input_buf, output_buf, output_row,
+                                  num_rows);
+    break;
+  default:
+    rgb_gray_convert_internal(cinfo, input_buf, output_buf, output_row,
+                              num_rows);
+    break;
+  }
+}
+
+
+/*
+ * Extended RGB to plain RGB conversion
+ */
+
+METHODDEF(void)
+rgb_rgb_convert(j_compress_ptr cinfo, JSAMPARRAY input_buf,
+                JSAMPIMAGE output_buf, JDIMENSION output_row, int num_rows)
+{
+  switch (cinfo->in_color_space) {
+  case JCS_EXT_RGB:
+    extrgb_rgb_convert_internal(cinfo, input_buf, output_buf, output_row,
+                                num_rows);
+    break;
+  case JCS_EXT_RGBX:
+  case JCS_EXT_RGBA:
+    extrgbx_rgb_convert_internal(cinfo, input_buf, output_buf, output_row,
+                                 num_rows);
+    break;
+  case JCS_EXT_BGR:
+    extbgr_rgb_convert_internal(cinfo, input_buf, output_buf, output_row,
+                                num_rows);
+    break;
+  case JCS_EXT_BGRX:
+  case JCS_EXT_BGRA:
+    extbgrx_rgb_convert_internal(cinfo, input_buf, output_buf, output_row,
+                                 num_rows);
+    break;
+  case JCS_EXT_XBGR:
+  case JCS_EXT_ABGR:
+    extxbgr_rgb_convert_internal(cinfo, input_buf, output_buf, output_row,
+                                 num_rows);
+    break;
+  case JCS_EXT_XRGB:
+  case JCS_EXT_ARGB:
+    extxrgb_rgb_convert_internal(cinfo, input_buf, output_buf, output_row,
+                                 num_rows);
+    break;
+  default:
+    rgb_rgb_convert_internal(cinfo, input_buf, output_buf, output_row,
+                             num_rows);
+    break;
+  }
+}
+
+
+/*
+ * Convert some rows of samples to the JPEG colorspace.
+ * This version handles Adobe-style CMYK->YCCK conversion,
+ * where we convert R=1-C, G=1-M, and B=1-Y to YCbCr using the same
+ * conversion as above, while passing K (black) unchanged.
+ * We assume rgb_ycc_start has been called.
+ */
+
+METHODDEF(void)
+cmyk_ycck_convert(j_compress_ptr cinfo, JSAMPARRAY input_buf,
+                  JSAMPIMAGE output_buf, JDIMENSION output_row, int num_rows)
+{
+  my_cconvert_ptr cconvert = (my_cconvert_ptr)cinfo->cconvert;
+  register int r, g, b;
+  register JLONG *ctab = cconvert->rgb_ycc_tab;
+  register JSAMPROW inptr;
+  register JSAMPROW outptr0, outptr1, outptr2, outptr3;
+  register JDIMENSION col;
+  JDIMENSION num_cols = cinfo->image_width;
+
+  while (--num_rows >= 0) {
+    inptr = *input_buf++;
+    outptr0 = output_buf[0][output_row];
+    outptr1 = output_buf[1][output_row];
+    outptr2 = output_buf[2][output_row];
+    outptr3 = output_buf[3][output_row];
+    output_row++;
+    for (col = 0; col < num_cols; col++) {
+      r = MAXJSAMPLE - inptr[0];
+      g = MAXJSAMPLE - inptr[1];
+      b = MAXJSAMPLE - inptr[2];
+      /* K passes through as-is */
+      outptr3[col] = inptr[3];
+      inptr += 4;
+      /* If the inputs are 0..MAXJSAMPLE, the outputs of these equations
+       * must be too; we do not need an explicit range-limiting operation.
+       * Hence the value being shifted is never negative, and we don't
+       * need the general RIGHT_SHIFT macro.
+       */
+      /* Y */
+      outptr0[col] = (JSAMPLE)((ctab[r + R_Y_OFF] + ctab[g + G_Y_OFF] +
+                                ctab[b + B_Y_OFF]) >> SCALEBITS);
+      /* Cb */
+      outptr1[col] = (JSAMPLE)((ctab[r + R_CB_OFF] + ctab[g + G_CB_OFF] +
+                                ctab[b + B_CB_OFF]) >> SCALEBITS);
+      /* Cr */
+      outptr2[col] = (JSAMPLE)((ctab[r + R_CR_OFF] + ctab[g + G_CR_OFF] +
+                                ctab[b + B_CR_OFF]) >> SCALEBITS);
+    }
+  }
+}
+
+
+/*
+ * Convert some rows of samples to the JPEG colorspace.
+ * This version handles grayscale output with no conversion.
+ * The source can be either plain grayscale or YCbCr (since Y == gray).
+ */
+
+METHODDEF(void)
+grayscale_convert(j_compress_ptr cinfo, JSAMPARRAY input_buf,
+                  JSAMPIMAGE output_buf, JDIMENSION output_row, int num_rows)
+{
+  register JSAMPROW inptr;
+  register JSAMPROW outptr;
+  register JDIMENSION col;
+  JDIMENSION num_cols = cinfo->image_width;
+  int instride = cinfo->input_components;
+
+  while (--num_rows >= 0) {
+    inptr = *input_buf++;
+    outptr = output_buf[0][output_row];
+    output_row++;
+    for (col = 0; col < num_cols; col++) {
+      outptr[col] = inptr[0];
+      inptr += instride;
+    }
+  }
+}
+
+
+/*
+ * Convert some rows of samples to the JPEG colorspace.
+ * This version handles multi-component colorspaces without conversion.
+ * We assume input_components == num_components.
+ */
+
+METHODDEF(void)
+null_convert(j_compress_ptr cinfo, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+             JDIMENSION output_row, int num_rows)
+{
+  register JSAMPROW inptr;
+  register JSAMPROW outptr, outptr0, outptr1, outptr2, outptr3;
+  register JDIMENSION col;
+  register int ci;
+  int nc = cinfo->num_components;
+  JDIMENSION num_cols = cinfo->image_width;
+
+  if (nc == 3) {
+    while (--num_rows >= 0) {
+      inptr = *input_buf++;
+      outptr0 = output_buf[0][output_row];
+      outptr1 = output_buf[1][output_row];
+      outptr2 = output_buf[2][output_row];
+      output_row++;
+      for (col = 0; col < num_cols; col++) {
+        outptr0[col] = *inptr++;
+        outptr1[col] = *inptr++;
+        outptr2[col] = *inptr++;
+      }
+    }
+  } else if (nc == 4) {
+    while (--num_rows >= 0) {
+      inptr = *input_buf++;
+      outptr0 = output_buf[0][output_row];
+      outptr1 = output_buf[1][output_row];
+      outptr2 = output_buf[2][output_row];
+      outptr3 = output_buf[3][output_row];
+      output_row++;
+      for (col = 0; col < num_cols; col++) {
+        outptr0[col] = *inptr++;
+        outptr1[col] = *inptr++;
+        outptr2[col] = *inptr++;
+        outptr3[col] = *inptr++;
+      }
+    }
+  } else {
+    while (--num_rows >= 0) {
+      /* It seems fastest to make a separate pass for each component. */
+      for (ci = 0; ci < nc; ci++) {
+        inptr = *input_buf;
+        outptr = output_buf[ci][output_row];
+        for (col = 0; col < num_cols; col++) {
+          outptr[col] = inptr[ci];
+          inptr += nc;
+        }
+      }
+      input_buf++;
+      output_row++;
+    }
+  }
+}
+
+
+/*
+ * Empty method for start_pass.
+ */
+
+METHODDEF(void)
+null_method(j_compress_ptr cinfo)
+{
+  /* no work needed */
+}
+
+
+/*
+ * Module initialization routine for input colorspace conversion.
+ */
+
+GLOBAL(void)
+jinit_color_converter(j_compress_ptr cinfo)
+{
+  my_cconvert_ptr cconvert;
+
+  cconvert = (my_cconvert_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+                                sizeof(my_color_converter));
+  cinfo->cconvert = (struct jpeg_color_converter *)cconvert;
+  /* set start_pass to null method until we find out differently */
+  cconvert->pub.start_pass = null_method;
+
+  /* Make sure input_components agrees with in_color_space */
+  switch (cinfo->in_color_space) {
+  case JCS_GRAYSCALE:
+    if (cinfo->input_components != 1)
+      ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE);
+    break;
+
+  case JCS_RGB:
+  case JCS_EXT_RGB:
+  case JCS_EXT_RGBX:
+  case JCS_EXT_BGR:
+  case JCS_EXT_BGRX:
+  case JCS_EXT_XBGR:
+  case JCS_EXT_XRGB:
+  case JCS_EXT_RGBA:
+  case JCS_EXT_BGRA:
+  case JCS_EXT_ABGR:
+  case JCS_EXT_ARGB:
+    if (cinfo->input_components != rgb_pixelsize[cinfo->in_color_space])
+      ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE);
+    break;
+
+  case JCS_YCbCr:
+    if (cinfo->input_components != 3)
+      ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE);
+    break;
+
+  case JCS_CMYK:
+  case JCS_YCCK:
+    if (cinfo->input_components != 4)
+      ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE);
+    break;
+
+  default:                      /* JCS_UNKNOWN can be anything */
+    if (cinfo->input_components < 1)
+      ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE);
+    break;
+  }
+
+  /* Check num_components, set conversion method based on requested space */
+  switch (cinfo->jpeg_color_space) {
+  case JCS_GRAYSCALE:
+    if (cinfo->num_components != 1)
+      ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
+    if (cinfo->in_color_space == JCS_GRAYSCALE)
+      cconvert->pub.color_convert = grayscale_convert;
+    else if (cinfo->in_color_space == JCS_RGB ||
+             cinfo->in_color_space == JCS_EXT_RGB ||
+             cinfo->in_color_space == JCS_EXT_RGBX ||
+             cinfo->in_color_space == JCS_EXT_BGR ||
+             cinfo->in_color_space == JCS_EXT_BGRX ||
+             cinfo->in_color_space == JCS_EXT_XBGR ||
+             cinfo->in_color_space == JCS_EXT_XRGB ||
+             cinfo->in_color_space == JCS_EXT_RGBA ||
+             cinfo->in_color_space == JCS_EXT_BGRA ||
+             cinfo->in_color_space == JCS_EXT_ABGR ||
+             cinfo->in_color_space == JCS_EXT_ARGB) {
+      if (jsimd_can_rgb_gray())
+        cconvert->pub.color_convert = jsimd_rgb_gray_convert;
+      else {
+        cconvert->pub.start_pass = rgb_ycc_start;
+        cconvert->pub.color_convert = rgb_gray_convert;
+      }
+    } else if (cinfo->in_color_space == JCS_YCbCr)
+      cconvert->pub.color_convert = grayscale_convert;
+    else
+      ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
+    break;
+
+  case JCS_RGB:
+    if (cinfo->num_components != 3)
+      ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
+    if (rgb_red[cinfo->in_color_space] == 0 &&
+        rgb_green[cinfo->in_color_space] == 1 &&
+        rgb_blue[cinfo->in_color_space] == 2 &&
+        rgb_pixelsize[cinfo->in_color_space] == 3) {
+#if defined(__mips__)
+      if (jsimd_c_can_null_convert())
+        cconvert->pub.color_convert = jsimd_c_null_convert;
+      else
+#endif
+        cconvert->pub.color_convert = null_convert;
+    } else if (cinfo->in_color_space == JCS_RGB ||
+               cinfo->in_color_space == JCS_EXT_RGB ||
+               cinfo->in_color_space == JCS_EXT_RGBX ||
+               cinfo->in_color_space == JCS_EXT_BGR ||
+               cinfo->in_color_space == JCS_EXT_BGRX ||
+               cinfo->in_color_space == JCS_EXT_XBGR ||
+               cinfo->in_color_space == JCS_EXT_XRGB ||
+               cinfo->in_color_space == JCS_EXT_RGBA ||
+               cinfo->in_color_space == JCS_EXT_BGRA ||
+               cinfo->in_color_space == JCS_EXT_ABGR ||
+               cinfo->in_color_space == JCS_EXT_ARGB)
+      cconvert->pub.color_convert = rgb_rgb_convert;
+    else
+      ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
+    break;
+
+  case JCS_YCbCr:
+    if (cinfo->num_components != 3)
+      ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
+    if (cinfo->in_color_space == JCS_RGB ||
+        cinfo->in_color_space == JCS_EXT_RGB ||
+        cinfo->in_color_space == JCS_EXT_RGBX ||
+        cinfo->in_color_space == JCS_EXT_BGR ||
+        cinfo->in_color_space == JCS_EXT_BGRX ||
+        cinfo->in_color_space == JCS_EXT_XBGR ||
+        cinfo->in_color_space == JCS_EXT_XRGB ||
+        cinfo->in_color_space == JCS_EXT_RGBA ||
+        cinfo->in_color_space == JCS_EXT_BGRA ||
+        cinfo->in_color_space == JCS_EXT_ABGR ||
+        cinfo->in_color_space == JCS_EXT_ARGB) {
+      if (jsimd_can_rgb_ycc())
+        cconvert->pub.color_convert = jsimd_rgb_ycc_convert;
+      else {
+        cconvert->pub.start_pass = rgb_ycc_start;
+        cconvert->pub.color_convert = rgb_ycc_convert;
+      }
+    } else if (cinfo->in_color_space == JCS_YCbCr) {
+#if defined(__mips__)
+      if (jsimd_c_can_null_convert())
+        cconvert->pub.color_convert = jsimd_c_null_convert;
+      else
+#endif
+        cconvert->pub.color_convert = null_convert;
+    } else
+      ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
+    break;
+
+  case JCS_CMYK:
+    if (cinfo->num_components != 4)
+      ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
+    if (cinfo->in_color_space == JCS_CMYK) {
+#if defined(__mips__)
+      if (jsimd_c_can_null_convert())
+        cconvert->pub.color_convert = jsimd_c_null_convert;
+      else
+#endif
+        cconvert->pub.color_convert = null_convert;
+    } else
+      ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
+    break;
+
+  case JCS_YCCK:
+    if (cinfo->num_components != 4)
+      ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
+    if (cinfo->in_color_space == JCS_CMYK) {
+      cconvert->pub.start_pass = rgb_ycc_start;
+      cconvert->pub.color_convert = cmyk_ycck_convert;
+    } else if (cinfo->in_color_space == JCS_YCCK) {
+#if defined(__mips__)
+      if (jsimd_c_can_null_convert())
+        cconvert->pub.color_convert = jsimd_c_null_convert;
+      else
+#endif
+        cconvert->pub.color_convert = null_convert;
+    } else
+      ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
+    break;
+
+  default:                      /* allow null conversion of JCS_UNKNOWN */
+    if (cinfo->jpeg_color_space != cinfo->in_color_space ||
+        cinfo->num_components != cinfo->input_components)
+      ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
+#if defined(__mips__)
+    if (jsimd_c_can_null_convert())
+      cconvert->pub.color_convert = jsimd_c_null_convert;
+    else
+#endif
+      cconvert->pub.color_convert = null_convert;
+    break;
+  }
+}
diff --git a/3rdparty/libjpeg/src/jcdctmgr.c b/3rdparty/libjpeg/src/jcdctmgr.c
new file mode 100644
index 00000000..7dae17a6
--- /dev/null
+++ b/3rdparty/libjpeg/src/jcdctmgr.c
@@ -0,0 +1,720 @@
+/*
+ * jcdctmgr.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1994-1996, Thomas G. Lane.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 1999-2006, MIYASAKA Masaru.
+ * Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+ * Copyright (C) 2011, 2014-2015, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains the forward-DCT management logic.
+ * This code selects a particular DCT implementation to be used,
+ * and it performs related housekeeping chores including coefficient
+ * quantization.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jdct.h"               /* Private declarations for DCT subsystem */
+#include "jsimddct.h"
+
+
+/* Private subobject for this module */
+
+typedef void (*forward_DCT_method_ptr) (DCTELEM *data);
+typedef void (*float_DCT_method_ptr) (FAST_FLOAT *data);
+
+typedef void (*convsamp_method_ptr) (JSAMPARRAY sample_data,
+                                     JDIMENSION start_col,
+                                     DCTELEM *workspace);
+typedef void (*float_convsamp_method_ptr) (JSAMPARRAY sample_data,
+                                           JDIMENSION start_col,
+                                           FAST_FLOAT *workspace);
+
+typedef void (*quantize_method_ptr) (JCOEFPTR coef_block, DCTELEM *divisors,
+                                     DCTELEM *workspace);
+typedef void (*float_quantize_method_ptr) (JCOEFPTR coef_block,
+                                           FAST_FLOAT *divisors,
+                                           FAST_FLOAT *workspace);
+
+METHODDEF(void) quantize(JCOEFPTR, DCTELEM *, DCTELEM *);
+
+typedef struct {
+  struct jpeg_forward_dct pub;  /* public fields */
+
+  /* Pointer to the DCT routine actually in use */
+  forward_DCT_method_ptr dct;
+  convsamp_method_ptr convsamp;
+  quantize_method_ptr quantize;
+
+  /* The actual post-DCT divisors --- not identical to the quant table
+   * entries, because of scaling (especially for an unnormalized DCT).
+   * Each table is given in normal array order.
+   */
+  DCTELEM *divisors[NUM_QUANT_TBLS];
+
+  /* work area for FDCT subroutine */
+  DCTELEM *workspace;
+
+#ifdef DCT_FLOAT_SUPPORTED
+  /* Same as above for the floating-point case. */
+  float_DCT_method_ptr float_dct;
+  float_convsamp_method_ptr float_convsamp;
+  float_quantize_method_ptr float_quantize;
+  FAST_FLOAT *float_divisors[NUM_QUANT_TBLS];
+  FAST_FLOAT *float_workspace;
+#endif
+} my_fdct_controller;
+
+typedef my_fdct_controller *my_fdct_ptr;
+
+
+#if BITS_IN_JSAMPLE == 8
+
+/*
+ * Find the highest bit in an integer through binary search.
+ */
+
+LOCAL(int)
+flss(UINT16 val)
+{
+  int bit;
+
+  bit = 16;
+
+  if (!val)
+    return 0;
+
+  if (!(val & 0xff00)) {
+    bit -= 8;
+    val <<= 8;
+  }
+  if (!(val & 0xf000)) {
+    bit -= 4;
+    val <<= 4;
+  }
+  if (!(val & 0xc000)) {
+    bit -= 2;
+    val <<= 2;
+  }
+  if (!(val & 0x8000)) {
+    bit -= 1;
+    val <<= 1;
+  }
+
+  return bit;
+}
+
+
+/*
+ * Compute values to do a division using reciprocal.
+ *
+ * This implementation is based on an algorithm described in
+ *   "How to optimize for the Pentium family of microprocessors"
+ *   (http://www.agner.org/assem/).
+ * More information about the basic algorithm can be found in
+ * the paper "Integer Division Using Reciprocals" by Robert Alverson.
+ *
+ * The basic idea is to replace x/d by x * d^-1. In order to store
+ * d^-1 with enough precision we shift it left a few places. It turns
+ * out that this algoright gives just enough precision, and also fits
+ * into DCTELEM:
+ *
+ *   b = (the number of significant bits in divisor) - 1
+ *   r = (word size) + b
+ *   f = 2^r / divisor
+ *
+ * f will not be an integer for most cases, so we need to compensate
+ * for the rounding error introduced:
+ *
+ *   no fractional part:
+ *
+ *       result = input >> r
+ *
+ *   fractional part of f < 0.5:
+ *
+ *       round f down to nearest integer
+ *       result = ((input + 1) * f) >> r
+ *
+ *   fractional part of f > 0.5:
+ *
+ *       round f up to nearest integer
+ *       result = (input * f) >> r
+ *
+ * This is the original algorithm that gives truncated results. But we
+ * want properly rounded results, so we replace "input" with
+ * "input + divisor/2".
+ *
+ * In order to allow SIMD implementations we also tweak the values to
+ * allow the same calculation to be made at all times:
+ *
+ *   dctbl[0] = f rounded to nearest integer
+ *   dctbl[1] = divisor / 2 (+ 1 if fractional part of f < 0.5)
+ *   dctbl[2] = 1 << ((word size) * 2 - r)
+ *   dctbl[3] = r - (word size)
+ *
+ * dctbl[2] is for stupid instruction sets where the shift operation
+ * isn't member wise (e.g. MMX).
+ *
+ * The reason dctbl[2] and dctbl[3] reduce the shift with (word size)
+ * is that most SIMD implementations have a "multiply and store top
+ * half" operation.
+ *
+ * Lastly, we store each of the values in their own table instead
+ * of in a consecutive manner, yet again in order to allow SIMD
+ * routines.
+ */
+
+LOCAL(int)
+compute_reciprocal(UINT16 divisor, DCTELEM *dtbl)
+{
+  UDCTELEM2 fq, fr;
+  UDCTELEM c;
+  int b, r;
+
+  if (divisor == 1) {
+    /* divisor == 1 means unquantized, so these reciprocal/correction/shift
+     * values will cause the C quantization algorithm to act like the
+     * identity function.  Since only the C quantization algorithm is used in
+     * these cases, the scale value is irrelevant.
+     */
+    dtbl[DCTSIZE2 * 0] = (DCTELEM)1;                        /* reciprocal */
+    dtbl[DCTSIZE2 * 1] = (DCTELEM)0;                        /* correction */
+    dtbl[DCTSIZE2 * 2] = (DCTELEM)1;                        /* scale */
+    dtbl[DCTSIZE2 * 3] = -(DCTELEM)(sizeof(DCTELEM) * 8);   /* shift */
+    return 0;
+  }
+
+  b = flss(divisor) - 1;
+  r  = sizeof(DCTELEM) * 8 + b;
+
+  fq = ((UDCTELEM2)1 << r) / divisor;
+  fr = ((UDCTELEM2)1 << r) % divisor;
+
+  c = divisor / 2;                      /* for rounding */
+
+  if (fr == 0) {                        /* divisor is power of two */
+    /* fq will be one bit too large to fit in DCTELEM, so adjust */
+    fq >>= 1;
+    r--;
+  } else if (fr <= (divisor / 2U)) {    /* fractional part is < 0.5 */
+    c++;
+  } else {                              /* fractional part is > 0.5 */
+    fq++;
+  }
+
+  dtbl[DCTSIZE2 * 0] = (DCTELEM)fq;     /* reciprocal */
+  dtbl[DCTSIZE2 * 1] = (DCTELEM)c;      /* correction + roundfactor */
+#ifdef WITH_SIMD
+  dtbl[DCTSIZE2 * 2] = (DCTELEM)(1 << (sizeof(DCTELEM) * 8 * 2 - r)); /* scale */
+#else
+  dtbl[DCTSIZE2 * 2] = 1;
+#endif
+  dtbl[DCTSIZE2 * 3] = (DCTELEM)r - sizeof(DCTELEM) * 8; /* shift */
+
+  if (r <= 16) return 0;
+  else return 1;
+}
+
+#endif
+
+
+/*
+ * Initialize for a processing pass.
+ * Verify that all referenced Q-tables are present, and set up
+ * the divisor table for each one.
+ * In the current implementation, DCT of all components is done during
+ * the first pass, even if only some components will be output in the
+ * first scan.  Hence all components should be examined here.
+ */
+
+METHODDEF(void)
+start_pass_fdctmgr(j_compress_ptr cinfo)
+{
+  my_fdct_ptr fdct = (my_fdct_ptr)cinfo->fdct;
+  int ci, qtblno, i;
+  jpeg_component_info *compptr;
+  JQUANT_TBL *qtbl;
+  DCTELEM *dtbl;
+
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    qtblno = compptr->quant_tbl_no;
+    /* Make sure specified quantization table is present */
+    if (qtblno < 0 || qtblno >= NUM_QUANT_TBLS ||
+        cinfo->quant_tbl_ptrs[qtblno] == NULL)
+      ERREXIT1(cinfo, JERR_NO_QUANT_TABLE, qtblno);
+    qtbl = cinfo->quant_tbl_ptrs[qtblno];
+    /* Compute divisors for this quant table */
+    /* We may do this more than once for same table, but it's not a big deal */
+    switch (cinfo->dct_method) {
+#ifdef DCT_ISLOW_SUPPORTED
+    case JDCT_ISLOW:
+      /* For LL&M IDCT method, divisors are equal to raw quantization
+       * coefficients multiplied by 8 (to counteract scaling).
+       */
+      if (fdct->divisors[qtblno] == NULL) {
+        fdct->divisors[qtblno] = (DCTELEM *)
+          (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+                                      (DCTSIZE2 * 4) * sizeof(DCTELEM));
+      }
+      dtbl = fdct->divisors[qtblno];
+      for (i = 0; i < DCTSIZE2; i++) {
+#if BITS_IN_JSAMPLE == 8
+        if (!compute_reciprocal(qtbl->quantval[i] << 3, &dtbl[i]) &&
+            fdct->quantize == jsimd_quantize)
+          fdct->quantize = quantize;
+#else
+        dtbl[i] = ((DCTELEM)qtbl->quantval[i]) << 3;
+#endif
+      }
+      break;
+#endif
+#ifdef DCT_IFAST_SUPPORTED
+    case JDCT_IFAST:
+      {
+        /* For AA&N IDCT method, divisors are equal to quantization
+         * coefficients scaled by scalefactor[row]*scalefactor[col], where
+         *   scalefactor[0] = 1
+         *   scalefactor[k] = cos(k*PI/16) * sqrt(2)    for k=1..7
+         * We apply a further scale factor of 8.
+         */
+#define CONST_BITS  14
+        static const INT16 aanscales[DCTSIZE2] = {
+          /* precomputed values scaled up by 14 bits */
+          16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,
+          22725, 31521, 29692, 26722, 22725, 17855, 12299,  6270,
+          21407, 29692, 27969, 25172, 21407, 16819, 11585,  5906,
+          19266, 26722, 25172, 22654, 19266, 15137, 10426,  5315,
+          16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,
+          12873, 17855, 16819, 15137, 12873, 10114,  6967,  3552,
+           8867, 12299, 11585, 10426,  8867,  6967,  4799,  2446,
+           4520,  6270,  5906,  5315,  4520,  3552,  2446,  1247
+        };
+        SHIFT_TEMPS
+
+        if (fdct->divisors[qtblno] == NULL) {
+          fdct->divisors[qtblno] = (DCTELEM *)
+            (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+                                        (DCTSIZE2 * 4) * sizeof(DCTELEM));
+        }
+        dtbl = fdct->divisors[qtblno];
+        for (i = 0; i < DCTSIZE2; i++) {
+#if BITS_IN_JSAMPLE == 8
+          if (!compute_reciprocal(
+                DESCALE(MULTIPLY16V16((JLONG)qtbl->quantval[i],
+                                      (JLONG)aanscales[i]),
+                        CONST_BITS - 3), &dtbl[i]) &&
+              fdct->quantize == jsimd_quantize)
+            fdct->quantize = quantize;
+#else
+          dtbl[i] = (DCTELEM)
+            DESCALE(MULTIPLY16V16((JLONG)qtbl->quantval[i],
+                                  (JLONG)aanscales[i]),
+                    CONST_BITS - 3);
+#endif
+        }
+      }
+      break;
+#endif
+#ifdef DCT_FLOAT_SUPPORTED
+    case JDCT_FLOAT:
+      {
+        /* For float AA&N IDCT method, divisors are equal to quantization
+         * coefficients scaled by scalefactor[row]*scalefactor[col], where
+         *   scalefactor[0] = 1
+         *   scalefactor[k] = cos(k*PI/16) * sqrt(2)    for k=1..7
+         * We apply a further scale factor of 8.
+         * What's actually stored is 1/divisor so that the inner loop can
+         * use a multiplication rather than a division.
+         */
+        FAST_FLOAT *fdtbl;
+        int row, col;
+        static const double aanscalefactor[DCTSIZE] = {
+          1.0, 1.387039845, 1.306562965, 1.175875602,
+          1.0, 0.785694958, 0.541196100, 0.275899379
+        };
+
+        if (fdct->float_divisors[qtblno] == NULL) {
+          fdct->float_divisors[qtblno] = (FAST_FLOAT *)
+            (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+                                        DCTSIZE2 * sizeof(FAST_FLOAT));
+        }
+        fdtbl = fdct->float_divisors[qtblno];
+        i = 0;
+        for (row = 0; row < DCTSIZE; row++) {
+          for (col = 0; col < DCTSIZE; col++) {
+            fdtbl[i] = (FAST_FLOAT)
+              (1.0 / (((double)qtbl->quantval[i] *
+                       aanscalefactor[row] * aanscalefactor[col] * 8.0)));
+            i++;
+          }
+        }
+      }
+      break;
+#endif
+    default:
+      ERREXIT(cinfo, JERR_NOT_COMPILED);
+      break;
+    }
+  }
+}
+
+
+/*
+ * Load data into workspace, applying unsigned->signed conversion.
+ */
+
+METHODDEF(void)
+convsamp(JSAMPARRAY sample_data, JDIMENSION start_col, DCTELEM *workspace)
+{
+  register DCTELEM *workspaceptr;
+  register JSAMPROW elemptr;
+  register int elemr;
+
+  workspaceptr = workspace;
+  for (elemr = 0; elemr < DCTSIZE; elemr++) {
+    elemptr = sample_data[elemr] + start_col;
+
+#if DCTSIZE == 8                /* unroll the inner loop */
+    *workspaceptr++ = (*elemptr++) - CENTERJSAMPLE;
+    *workspaceptr++ = (*elemptr++) - CENTERJSAMPLE;
+    *workspaceptr++ = (*elemptr++) - CENTERJSAMPLE;
+    *workspaceptr++ = (*elemptr++) - CENTERJSAMPLE;
+    *workspaceptr++ = (*elemptr++) - CENTERJSAMPLE;
+    *workspaceptr++ = (*elemptr++) - CENTERJSAMPLE;
+    *workspaceptr++ = (*elemptr++) - CENTERJSAMPLE;
+    *workspaceptr++ = (*elemptr++) - CENTERJSAMPLE;
+#else
+    {
+      register int elemc;
+      for (elemc = DCTSIZE; elemc > 0; elemc--)
+        *workspaceptr++ = (*elemptr++) - CENTERJSAMPLE;
+    }
+#endif
+  }
+}
+
+
+/*
+ * Quantize/descale the coefficients, and store into coef_blocks[].
+ */
+
+METHODDEF(void)
+quantize(JCOEFPTR coef_block, DCTELEM *divisors, DCTELEM *workspace)
+{
+  int i;
+  DCTELEM temp;
+  JCOEFPTR output_ptr = coef_block;
+
+#if BITS_IN_JSAMPLE == 8
+
+  UDCTELEM recip, corr;
+  int shift;
+  UDCTELEM2 product;
+
+  for (i = 0; i < DCTSIZE2; i++) {
+    temp = workspace[i];
+    recip = divisors[i + DCTSIZE2 * 0];
+    corr =  divisors[i + DCTSIZE2 * 1];
+    shift = divisors[i + DCTSIZE2 * 3];
+
+    if (temp < 0) {
+      temp = -temp;
+      product = (UDCTELEM2)(temp + corr) * recip;
+      product >>= shift + sizeof(DCTELEM) * 8;
+      temp = (DCTELEM)product;
+      temp = -temp;
+    } else {
+      product = (UDCTELEM2)(temp + corr) * recip;
+      product >>= shift + sizeof(DCTELEM) * 8;
+      temp = (DCTELEM)product;
+    }
+    output_ptr[i] = (JCOEF)temp;
+  }
+
+#else
+
+  register DCTELEM qval;
+
+  for (i = 0; i < DCTSIZE2; i++) {
+    qval = divisors[i];
+    temp = workspace[i];
+    /* Divide the coefficient value by qval, ensuring proper rounding.
+     * Since C does not specify the direction of rounding for negative
+     * quotients, we have to force the dividend positive for portability.
+     *
+     * In most files, at least half of the output values will be zero
+     * (at default quantization settings, more like three-quarters...)
+     * so we should ensure that this case is fast.  On many machines,
+     * a comparison is enough cheaper than a divide to make a special test
+     * a win.  Since both inputs will be nonnegative, we need only test
+     * for a < b to discover whether a/b is 0.
+     * If your machine's division is fast enough, define FAST_DIVIDE.
+     */
+#ifdef FAST_DIVIDE
+#define DIVIDE_BY(a, b)  a /= b
+#else
+#define DIVIDE_BY(a, b)  if (a >= b) a /= b;  else a = 0
+#endif
+    if (temp < 0) {
+      temp = -temp;
+      temp += qval >> 1;        /* for rounding */
+      DIVIDE_BY(temp, qval);
+      temp = -temp;
+    } else {
+      temp += qval >> 1;        /* for rounding */
+      DIVIDE_BY(temp, qval);
+    }
+    output_ptr[i] = (JCOEF)temp;
+  }
+
+#endif
+
+}
+
+
+/*
+ * Perform forward DCT on one or more blocks of a component.
+ *
+ * The input samples are taken from the sample_data[] array starting at
+ * position start_row/start_col, and moving to the right for any additional
+ * blocks. The quantized coefficients are returned in coef_blocks[].
+ */
+
+METHODDEF(void)
+forward_DCT(j_compress_ptr cinfo, jpeg_component_info *compptr,
+            JSAMPARRAY sample_data, JBLOCKROW coef_blocks,
+            JDIMENSION start_row, JDIMENSION start_col, JDIMENSION num_blocks)
+/* This version is used for integer DCT implementations. */
+{
+  /* This routine is heavily used, so it's worth coding it tightly. */
+  my_fdct_ptr fdct = (my_fdct_ptr)cinfo->fdct;
+  DCTELEM *divisors = fdct->divisors[compptr->quant_tbl_no];
+  DCTELEM *workspace;
+  JDIMENSION bi;
+
+  /* Make sure the compiler doesn't look up these every pass */
+  forward_DCT_method_ptr do_dct = fdct->dct;
+  convsamp_method_ptr do_convsamp = fdct->convsamp;
+  quantize_method_ptr do_quantize = fdct->quantize;
+  workspace = fdct->workspace;
+
+  sample_data += start_row;     /* fold in the vertical offset once */
+
+  for (bi = 0; bi < num_blocks; bi++, start_col += DCTSIZE) {
+    /* Load data into workspace, applying unsigned->signed conversion */
+    (*do_convsamp) (sample_data, start_col, workspace);
+
+    /* Perform the DCT */
+    (*do_dct) (workspace);
+
+    /* Quantize/descale the coefficients, and store into coef_blocks[] */
+    (*do_quantize) (coef_blocks[bi], divisors, workspace);
+  }
+}
+
+
+#ifdef DCT_FLOAT_SUPPORTED
+
+METHODDEF(void)
+convsamp_float(JSAMPARRAY sample_data, JDIMENSION start_col,
+               FAST_FLOAT *workspace)
+{
+  register FAST_FLOAT *workspaceptr;
+  register JSAMPROW elemptr;
+  register int elemr;
+
+  workspaceptr = workspace;
+  for (elemr = 0; elemr < DCTSIZE; elemr++) {
+    elemptr = sample_data[elemr] + start_col;
+#if DCTSIZE == 8                /* unroll the inner loop */
+    *workspaceptr++ = (FAST_FLOAT)((*elemptr++) - CENTERJSAMPLE);
+    *workspaceptr++ = (FAST_FLOAT)((*elemptr++) - CENTERJSAMPLE);
+    *workspaceptr++ = (FAST_FLOAT)((*elemptr++) - CENTERJSAMPLE);
+    *workspaceptr++ = (FAST_FLOAT)((*elemptr++) - CENTERJSAMPLE);
+    *workspaceptr++ = (FAST_FLOAT)((*elemptr++) - CENTERJSAMPLE);
+    *workspaceptr++ = (FAST_FLOAT)((*elemptr++) - CENTERJSAMPLE);
+    *workspaceptr++ = (FAST_FLOAT)((*elemptr++) - CENTERJSAMPLE);
+    *workspaceptr++ = (FAST_FLOAT)((*elemptr++) - CENTERJSAMPLE);
+#else
+    {
+      register int elemc;
+      for (elemc = DCTSIZE; elemc > 0; elemc--)
+        *workspaceptr++ = (FAST_FLOAT)((*elemptr++) - CENTERJSAMPLE);
+    }
+#endif
+  }
+}
+
+
+METHODDEF(void)
+quantize_float(JCOEFPTR coef_block, FAST_FLOAT *divisors,
+               FAST_FLOAT *workspace)
+{
+  register FAST_FLOAT temp;
+  register int i;
+  register JCOEFPTR output_ptr = coef_block;
+
+  for (i = 0; i < DCTSIZE2; i++) {
+    /* Apply the quantization and scaling factor */
+    temp = workspace[i] * divisors[i];
+
+    /* Round to nearest integer.
+     * Since C does not specify the direction of rounding for negative
+     * quotients, we have to force the dividend positive for portability.
+     * The maximum coefficient size is +-16K (for 12-bit data), so this
+     * code should work for either 16-bit or 32-bit ints.
+     */
+    output_ptr[i] = (JCOEF)((int)(temp + (FAST_FLOAT)16384.5) - 16384);
+  }
+}
+
+
+METHODDEF(void)
+forward_DCT_float(j_compress_ptr cinfo, jpeg_component_info *compptr,
+                  JSAMPARRAY sample_data, JBLOCKROW coef_blocks,
+                  JDIMENSION start_row, JDIMENSION start_col,
+                  JDIMENSION num_blocks)
+/* This version is used for floating-point DCT implementations. */
+{
+  /* This routine is heavily used, so it's worth coding it tightly. */
+  my_fdct_ptr fdct = (my_fdct_ptr)cinfo->fdct;
+  FAST_FLOAT *divisors = fdct->float_divisors[compptr->quant_tbl_no];
+  FAST_FLOAT *workspace;
+  JDIMENSION bi;
+
+
+  /* Make sure the compiler doesn't look up these every pass */
+  float_DCT_method_ptr do_dct = fdct->float_dct;
+  float_convsamp_method_ptr do_convsamp = fdct->float_convsamp;
+  float_quantize_method_ptr do_quantize = fdct->float_quantize;
+  workspace = fdct->float_workspace;
+
+  sample_data += start_row;     /* fold in the vertical offset once */
+
+  for (bi = 0; bi < num_blocks; bi++, start_col += DCTSIZE) {
+    /* Load data into workspace, applying unsigned->signed conversion */
+    (*do_convsamp) (sample_data, start_col, workspace);
+
+    /* Perform the DCT */
+    (*do_dct) (workspace);
+
+    /* Quantize/descale the coefficients, and store into coef_blocks[] */
+    (*do_quantize) (coef_blocks[bi], divisors, workspace);
+  }
+}
+
+#endif /* DCT_FLOAT_SUPPORTED */
+
+
+/*
+ * Initialize FDCT manager.
+ */
+
+GLOBAL(void)
+jinit_forward_dct(j_compress_ptr cinfo)
+{
+  my_fdct_ptr fdct;
+  int i;
+
+  fdct = (my_fdct_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+                                sizeof(my_fdct_controller));
+  cinfo->fdct = (struct jpeg_forward_dct *)fdct;
+  fdct->pub.start_pass = start_pass_fdctmgr;
+
+  /* First determine the DCT... */
+  switch (cinfo->dct_method) {
+#ifdef DCT_ISLOW_SUPPORTED
+  case JDCT_ISLOW:
+    fdct->pub.forward_DCT = forward_DCT;
+    if (jsimd_can_fdct_islow())
+      fdct->dct = jsimd_fdct_islow;
+    else
+      fdct->dct = jpeg_fdct_islow;
+    break;
+#endif
+#ifdef DCT_IFAST_SUPPORTED
+  case JDCT_IFAST:
+    fdct->pub.forward_DCT = forward_DCT;
+    if (jsimd_can_fdct_ifast())
+      fdct->dct = jsimd_fdct_ifast;
+    else
+      fdct->dct = jpeg_fdct_ifast;
+    break;
+#endif
+#ifdef DCT_FLOAT_SUPPORTED
+  case JDCT_FLOAT:
+    fdct->pub.forward_DCT = forward_DCT_float;
+    if (jsimd_can_fdct_float())
+      fdct->float_dct = jsimd_fdct_float;
+    else
+      fdct->float_dct = jpeg_fdct_float;
+    break;
+#endif
+  default:
+    ERREXIT(cinfo, JERR_NOT_COMPILED);
+    break;
+  }
+
+  /* ...then the supporting stages. */
+  switch (cinfo->dct_method) {
+#ifdef DCT_ISLOW_SUPPORTED
+  case JDCT_ISLOW:
+#endif
+#ifdef DCT_IFAST_SUPPORTED
+  case JDCT_IFAST:
+#endif
+#if defined(DCT_ISLOW_SUPPORTED) || defined(DCT_IFAST_SUPPORTED)
+    if (jsimd_can_convsamp())
+      fdct->convsamp = jsimd_convsamp;
+    else
+      fdct->convsamp = convsamp;
+    if (jsimd_can_quantize())
+      fdct->quantize = jsimd_quantize;
+    else
+      fdct->quantize = quantize;
+    break;
+#endif
+#ifdef DCT_FLOAT_SUPPORTED
+  case JDCT_FLOAT:
+    if (jsimd_can_convsamp_float())
+      fdct->float_convsamp = jsimd_convsamp_float;
+    else
+      fdct->float_convsamp = convsamp_float;
+    if (jsimd_can_quantize_float())
+      fdct->float_quantize = jsimd_quantize_float;
+    else
+      fdct->float_quantize = quantize_float;
+    break;
+#endif
+  default:
+    ERREXIT(cinfo, JERR_NOT_COMPILED);
+    break;
+  }
+
+  /* Allocate workspace memory */
+#ifdef DCT_FLOAT_SUPPORTED
+  if (cinfo->dct_method == JDCT_FLOAT)
+    fdct->float_workspace = (FAST_FLOAT *)
+      (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+                                  sizeof(FAST_FLOAT) * DCTSIZE2);
+  else
+#endif
+    fdct->workspace = (DCTELEM *)
+      (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+                                  sizeof(DCTELEM) * DCTSIZE2);
+
+  /* Mark divisor tables unallocated */
+  for (i = 0; i < NUM_QUANT_TBLS; i++) {
+    fdct->divisors[i] = NULL;
+#ifdef DCT_FLOAT_SUPPORTED
+    fdct->float_divisors[i] = NULL;
+#endif
+  }
+}
diff --git a/3rdparty/libjpeg/src/jchuff.c b/3rdparty/libjpeg/src/jchuff.c
new file mode 100644
index 00000000..8ea48b80
--- /dev/null
+++ b/3rdparty/libjpeg/src/jchuff.c
@@ -0,0 +1,1131 @@
+/*
+ * jchuff.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1991-1997, Thomas G. Lane.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2009-2011, 2014-2016, 2018-2020, D. R. Commander.
+ * Copyright (C) 2015, Matthieu Darbois.
+ * Copyright (C) 2018, Matthias Räncker.
+ * Copyright (C) 2020, Arm Limited.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains Huffman entropy encoding routines.
+ *
+ * Much of the complexity here has to do with supporting output suspension.
+ * If the data destination module demands suspension, we want to be able to
+ * back up to the start of the current MCU.  To do this, we copy state
+ * variables into local working storage, and update them back to the
+ * permanent JPEG objects only upon successful completion of an MCU.
+ *
+ * NOTE: All referenced figures are from
+ * Recommendation ITU-T T.81 (1992) | ISO/IEC 10918-1:1994.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jsimd.h"
+#include "jconfigint.h"
+#include <limits.h>
+
+/*
+ * NOTE: If USE_CLZ_INTRINSIC is defined, then clz/bsr instructions will be
+ * used for bit counting rather than the lookup table.  This will reduce the
+ * memory footprint by 64k, which is important for some mobile applications
+ * that create many isolated instances of libjpeg-turbo (web browsers, for
+ * instance.)  This may improve performance on some mobile platforms as well.
+ * This feature is enabled by default only on Arm processors, because some x86
+ * chips have a slow implementation of bsr, and the use of clz/bsr cannot be
+ * shown to have a significant performance impact even on the x86 chips that
+ * have a fast implementation of it.  When building for Armv6, you can
+ * explicitly disable the use of clz/bsr by adding -mthumb to the compiler
+ * flags (this defines __thumb__).
+ */
+
+/* NOTE: Both GCC and Clang define __GNUC__ */
+#if defined(__GNUC__) && (defined(__arm__) || defined(__aarch64__))
+#if !defined(__thumb__) || defined(__thumb2__)
+#define USE_CLZ_INTRINSIC
+#endif
+#endif
+
+#ifdef USE_CLZ_INTRINSIC
+#define JPEG_NBITS_NONZERO(x)  (32 - __builtin_clz(x))
+#define JPEG_NBITS(x)          (x ? JPEG_NBITS_NONZERO(x) : 0)
+#else
+#include "jpeg_nbits_table.h"
+#define JPEG_NBITS(x)          (jpeg_nbits_table[x])
+#define JPEG_NBITS_NONZERO(x)  JPEG_NBITS(x)
+#endif
+
+
+/* Expanded entropy encoder object for Huffman encoding.
+ *
+ * The savable_state subrecord contains fields that change within an MCU,
+ * but must not be updated permanently until we complete the MCU.
+ */
+
+#if defined(__x86_64__) && defined(__ILP32__)
+typedef unsigned long long bit_buf_type;
+#else
+typedef size_t bit_buf_type;
+#endif
+
+/* NOTE: The more optimal Huffman encoding algorithm is only used by the
+ * intrinsics implementation of the Arm Neon SIMD extensions, which is why we
+ * retain the old Huffman encoder behavior when using the GAS implementation.
+ */
+#if defined(WITH_SIMD) && !(defined(__arm__) || defined(__aarch64__) || \
+                            defined(_M_ARM) || defined(_M_ARM64))
+typedef unsigned long long simd_bit_buf_type;
+#else
+typedef bit_buf_type simd_bit_buf_type;
+#endif
+
+#if (defined(SIZEOF_SIZE_T) && SIZEOF_SIZE_T == 8) || defined(_WIN64) || \
+    (defined(__x86_64__) && defined(__ILP32__))
+#define BIT_BUF_SIZE  64
+#elif (defined(SIZEOF_SIZE_T) && SIZEOF_SIZE_T == 4) || defined(_WIN32)
+#define BIT_BUF_SIZE  32
+#else
+#error Cannot determine word size
+#endif
+#define SIMD_BIT_BUF_SIZE  (sizeof(simd_bit_buf_type) * 8)
+
+typedef struct {
+  union {
+    bit_buf_type c;
+    simd_bit_buf_type simd;
+  } put_buffer;                         /* current bit accumulation buffer */
+  int free_bits;                        /* # of bits available in it */
+                                        /* (Neon GAS: # of bits now in it) */
+  int last_dc_val[MAX_COMPS_IN_SCAN];   /* last DC coef for each component */
+} savable_state;
+
+typedef struct {
+  struct jpeg_entropy_encoder pub; /* public fields */
+
+  savable_state saved;          /* Bit buffer & DC state at start of MCU */
+
+  /* These fields are NOT loaded into local working state. */
+  unsigned int restarts_to_go;  /* MCUs left in this restart interval */
+  int next_restart_num;         /* next restart number to write (0-7) */
+
+  /* Pointers to derived tables (these workspaces have image lifespan) */
+  c_derived_tbl *dc_derived_tbls[NUM_HUFF_TBLS];
+  c_derived_tbl *ac_derived_tbls[NUM_HUFF_TBLS];
+
+#ifdef ENTROPY_OPT_SUPPORTED    /* Statistics tables for optimization */
+  long *dc_count_ptrs[NUM_HUFF_TBLS];
+  long *ac_count_ptrs[NUM_HUFF_TBLS];
+#endif
+
+  int simd;
+} huff_entropy_encoder;
+
+typedef huff_entropy_encoder *huff_entropy_ptr;
+
+/* Working state while writing an MCU.
+ * This struct contains all the fields that are needed by subroutines.
+ */
+
+typedef struct {
+  JOCTET *next_output_byte;     /* => next byte to write in buffer */
+  size_t free_in_buffer;        /* # of byte spaces remaining in buffer */
+  savable_state cur;            /* Current bit buffer & DC state */
+  j_compress_ptr cinfo;         /* dump_buffer needs access to this */
+  int simd;
+} working_state;
+
+
+/* Forward declarations */
+METHODDEF(boolean) encode_mcu_huff(j_compress_ptr cinfo, JBLOCKROW *MCU_data);
+METHODDEF(void) finish_pass_huff(j_compress_ptr cinfo);
+#ifdef ENTROPY_OPT_SUPPORTED
+METHODDEF(boolean) encode_mcu_gather(j_compress_ptr cinfo,
+                                     JBLOCKROW *MCU_data);
+METHODDEF(void) finish_pass_gather(j_compress_ptr cinfo);
+#endif
+
+
+/*
+ * Initialize for a Huffman-compressed scan.
+ * If gather_statistics is TRUE, we do not output anything during the scan,
+ * just count the Huffman symbols used and generate Huffman code tables.
+ */
+
+METHODDEF(void)
+start_pass_huff(j_compress_ptr cinfo, boolean gather_statistics)
+{
+  huff_entropy_ptr entropy = (huff_entropy_ptr)cinfo->entropy;
+  int ci, dctbl, actbl;
+  jpeg_component_info *compptr;
+
+  if (gather_statistics) {
+#ifdef ENTROPY_OPT_SUPPORTED
+    entropy->pub.encode_mcu = encode_mcu_gather;
+    entropy->pub.finish_pass = finish_pass_gather;
+#else
+    ERREXIT(cinfo, JERR_NOT_COMPILED);
+#endif
+  } else {
+    entropy->pub.encode_mcu = encode_mcu_huff;
+    entropy->pub.finish_pass = finish_pass_huff;
+  }
+
+  entropy->simd = jsimd_can_huff_encode_one_block();
+
+  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+    compptr = cinfo->cur_comp_info[ci];
+    dctbl = compptr->dc_tbl_no;
+    actbl = compptr->ac_tbl_no;
+    if (gather_statistics) {
+#ifdef ENTROPY_OPT_SUPPORTED
+      /* Check for invalid table indexes */
+      /* (make_c_derived_tbl does this in the other path) */
+      if (dctbl < 0 || dctbl >= NUM_HUFF_TBLS)
+        ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, dctbl);
+      if (actbl < 0 || actbl >= NUM_HUFF_TBLS)
+        ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, actbl);
+      /* Allocate and zero the statistics tables */
+      /* Note that jpeg_gen_optimal_table expects 257 entries in each table! */
+      if (entropy->dc_count_ptrs[dctbl] == NULL)
+        entropy->dc_count_ptrs[dctbl] = (long *)
+          (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+                                      257 * sizeof(long));
+      MEMZERO(entropy->dc_count_ptrs[dctbl], 257 * sizeof(long));
+      if (entropy->ac_count_ptrs[actbl] == NULL)
+        entropy->ac_count_ptrs[actbl] = (long *)
+          (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+                                      257 * sizeof(long));
+      MEMZERO(entropy->ac_count_ptrs[actbl], 257 * sizeof(long));
+#endif
+    } else {
+      /* Compute derived values for Huffman tables */
+      /* We may do this more than once for a table, but it's not expensive */
+      jpeg_make_c_derived_tbl(cinfo, TRUE, dctbl,
+                              &entropy->dc_derived_tbls[dctbl]);
+      jpeg_make_c_derived_tbl(cinfo, FALSE, actbl,
+                              &entropy->ac_derived_tbls[actbl]);
+    }
+    /* Initialize DC predictions to 0 */
+    entropy->saved.last_dc_val[ci] = 0;
+  }
+
+  /* Initialize bit buffer to empty */
+  if (entropy->simd) {
+    entropy->saved.put_buffer.simd = 0;
+#if defined(__aarch64__) && !defined(NEON_INTRINSICS)
+    entropy->saved.free_bits = 0;
+#else
+    entropy->saved.free_bits = SIMD_BIT_BUF_SIZE;
+#endif
+  } else {
+    entropy->saved.put_buffer.c = 0;
+    entropy->saved.free_bits = BIT_BUF_SIZE;
+  }
+
+  /* Initialize restart stuff */
+  entropy->restarts_to_go = cinfo->restart_interval;
+  entropy->next_restart_num = 0;
+}
+
+
+/*
+ * Compute the derived values for a Huffman table.
+ * This routine also performs some validation checks on the table.
+ *
+ * Note this is also used by jcphuff.c.
+ */
+
+GLOBAL(void)
+jpeg_make_c_derived_tbl(j_compress_ptr cinfo, boolean isDC, int tblno,
+                        c_derived_tbl **pdtbl)
+{
+  JHUFF_TBL *htbl;
+  c_derived_tbl *dtbl;
+  int p, i, l, lastp, si, maxsymbol;
+  char huffsize[257];
+  unsigned int huffcode[257];
+  unsigned int code;
+
+  /* Note that huffsize[] and huffcode[] are filled in code-length order,
+   * paralleling the order of the symbols themselves in htbl->huffval[].
+   */
+
+  /* Find the input Huffman table */
+  if (tblno < 0 || tblno >= NUM_HUFF_TBLS)
+    ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, tblno);
+  htbl =
+    isDC ? cinfo->dc_huff_tbl_ptrs[tblno] : cinfo->ac_huff_tbl_ptrs[tblno];
+  if (htbl == NULL)
+    ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, tblno);
+
+  /* Allocate a workspace if we haven't already done so. */
+  if (*pdtbl == NULL)
+    *pdtbl = (c_derived_tbl *)
+      (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+                                  sizeof(c_derived_tbl));
+  dtbl = *pdtbl;
+
+  /* Figure C.1: make table of Huffman code length for each symbol */
+
+  p = 0;
+  for (l = 1; l <= 16; l++) {
+    i = (int)htbl->bits[l];
+    if (i < 0 || p + i > 256)   /* protect against table overrun */
+      ERREXIT(cinfo, JERR_BAD_HUFF_TABLE);
+    while (i--)
+      huffsize[p++] = (char)l;
+  }
+  huffsize[p] = 0;
+  lastp = p;
+
+  /* Figure C.2: generate the codes themselves */
+  /* We also validate that the counts represent a legal Huffman code tree. */
+
+  code = 0;
+  si = huffsize[0];
+  p = 0;
+  while (huffsize[p]) {
+    while (((int)huffsize[p]) == si) {
+      huffcode[p++] = code;
+      code++;
+    }
+    /* code is now 1 more than the last code used for codelength si; but
+     * it must still fit in si bits, since no code is allowed to be all ones.
+     */
+    if (((JLONG)code) >= (((JLONG)1) << si))
+      ERREXIT(cinfo, JERR_BAD_HUFF_TABLE);
+    code <<= 1;
+    si++;
+  }
+
+  /* Figure C.3: generate encoding tables */
+  /* These are code and size indexed by symbol value */
+
+  /* Set all codeless symbols to have code length 0;
+   * this lets us detect duplicate VAL entries here, and later
+   * allows emit_bits to detect any attempt to emit such symbols.
+   */
+  MEMZERO(dtbl->ehufsi, sizeof(dtbl->ehufsi));
+
+  /* This is also a convenient place to check for out-of-range
+   * and duplicated VAL entries.  We allow 0..255 for AC symbols
+   * but only 0..15 for DC.  (We could constrain them further
+   * based on data depth and mode, but this seems enough.)
+   */
+  maxsymbol = isDC ? 15 : 255;
+
+  for (p = 0; p < lastp; p++) {
+    i = htbl->huffval[p];
+    if (i < 0 || i > maxsymbol || dtbl->ehufsi[i])
+      ERREXIT(cinfo, JERR_BAD_HUFF_TABLE);
+    dtbl->ehufco[i] = huffcode[p];
+    dtbl->ehufsi[i] = huffsize[p];
+  }
+}
+
+
+/* Outputting bytes to the file */
+
+/* Emit a byte, taking 'action' if must suspend. */
+#define emit_byte(state, val, action) { \
+  *(state)->next_output_byte++ = (JOCTET)(val); \
+  if (--(state)->free_in_buffer == 0) \
+    if (!dump_buffer(state)) \
+      { action; } \
+}
+
+
+LOCAL(boolean)
+dump_buffer(working_state *state)
+/* Empty the output buffer; return TRUE if successful, FALSE if must suspend */
+{
+  struct jpeg_destination_mgr *dest = state->cinfo->dest;
+
+  if (!(*dest->empty_output_buffer) (state->cinfo))
+    return FALSE;
+  /* After a successful buffer dump, must reset buffer pointers */
+  state->next_output_byte = dest->next_output_byte;
+  state->free_in_buffer = dest->free_in_buffer;
+  return TRUE;
+}
+
+
+/* Outputting bits to the file */
+
+/* Output byte b and, speculatively, an additional 0 byte.  0xFF must be
+ * encoded as 0xFF 0x00, so the output buffer pointer is advanced by 2 if the
+ * byte is 0xFF.  Otherwise, the output buffer pointer is advanced by 1, and
+ * the speculative 0 byte will be overwritten by the next byte.
+ */
+#define EMIT_BYTE(b) { \
+  buffer[0] = (JOCTET)(b); \
+  buffer[1] = 0; \
+  buffer -= -2 + ((JOCTET)(b) < 0xFF); \
+}
+
+/* Output the entire bit buffer.  If there are no 0xFF bytes in it, then write
+ * directly to the output buffer.  Otherwise, use the EMIT_BYTE() macro to
+ * encode 0xFF as 0xFF 0x00.
+ */
+#if BIT_BUF_SIZE == 64
+
+#define FLUSH() { \
+  if (put_buffer & 0x8080808080808080 & ~(put_buffer + 0x0101010101010101)) { \
+    EMIT_BYTE(put_buffer >> 56) \
+    EMIT_BYTE(put_buffer >> 48) \
+    EMIT_BYTE(put_buffer >> 40) \
+    EMIT_BYTE(put_buffer >> 32) \
+    EMIT_BYTE(put_buffer >> 24) \
+    EMIT_BYTE(put_buffer >> 16) \
+    EMIT_BYTE(put_buffer >>  8) \
+    EMIT_BYTE(put_buffer      ) \
+  } else { \
+    buffer[0] = (JOCTET)(put_buffer >> 56); \
+    buffer[1] = (JOCTET)(put_buffer >> 48); \
+    buffer[2] = (JOCTET)(put_buffer >> 40); \
+    buffer[3] = (JOCTET)(put_buffer >> 32); \
+    buffer[4] = (JOCTET)(put_buffer >> 24); \
+    buffer[5] = (JOCTET)(put_buffer >> 16); \
+    buffer[6] = (JOCTET)(put_buffer >> 8); \
+    buffer[7] = (JOCTET)(put_buffer); \
+    buffer += 8; \
+  } \
+}
+
+#else
+
+#define FLUSH() { \
+  if (put_buffer & 0x80808080 & ~(put_buffer + 0x01010101)) { \
+    EMIT_BYTE(put_buffer >> 24) \
+    EMIT_BYTE(put_buffer >> 16) \
+    EMIT_BYTE(put_buffer >>  8) \
+    EMIT_BYTE(put_buffer      ) \
+  } else { \
+    buffer[0] = (JOCTET)(put_buffer >> 24); \
+    buffer[1] = (JOCTET)(put_buffer >> 16); \
+    buffer[2] = (JOCTET)(put_buffer >> 8); \
+    buffer[3] = (JOCTET)(put_buffer); \
+    buffer += 4; \
+  } \
+}
+
+#endif
+
+/* Fill the bit buffer to capacity with the leading bits from code, then output
+ * the bit buffer and put the remaining bits from code into the bit buffer.
+ */
+#define PUT_AND_FLUSH(code, size) { \
+  put_buffer = (put_buffer << (size + free_bits)) | (code >> -free_bits); \
+  FLUSH() \
+  free_bits += BIT_BUF_SIZE; \
+  put_buffer = code; \
+}
+
+/* Insert code into the bit buffer and output the bit buffer if needed.
+ * NOTE: We can't flush with free_bits == 0, since the left shift in
+ * PUT_AND_FLUSH() would have undefined behavior.
+ */
+#define PUT_BITS(code, size) { \
+  free_bits -= size; \
+  if (free_bits < 0) \
+    PUT_AND_FLUSH(code, size) \
+  else \
+    put_buffer = (put_buffer << size) | code; \
+}
+
+#define PUT_CODE(code, size) { \
+  temp &= (((JLONG)1) << nbits) - 1; \
+  temp |= code << nbits; \
+  nbits += size; \
+  PUT_BITS(temp, nbits) \
+}
+
+
+/* Although it is exceedingly rare, it is possible for a Huffman-encoded
+ * coefficient block to be larger than the 128-byte unencoded block.  For each
+ * of the 64 coefficients, PUT_BITS is invoked twice, and each invocation can
+ * theoretically store 16 bits (for a maximum of 2048 bits or 256 bytes per
+ * encoded block.)  If, for instance, one artificially sets the AC
+ * coefficients to alternating values of 32767 and -32768 (using the JPEG
+ * scanning order-- 1, 8, 16, etc.), then this will produce an encoded block
+ * larger than 200 bytes.
+ */
+#define BUFSIZE  (DCTSIZE2 * 8)
+
+#define LOAD_BUFFER() { \
+  if (state->free_in_buffer < BUFSIZE) { \
+    localbuf = 1; \
+    buffer = _buffer; \
+  } else \
+    buffer = state->next_output_byte; \
+}
+
+#define STORE_BUFFER() { \
+  if (localbuf) { \
+    size_t bytes, bytestocopy; \
+    bytes = buffer - _buffer; \
+    buffer = _buffer; \
+    while (bytes > 0) { \
+      bytestocopy = MIN(bytes, state->free_in_buffer); \
+      MEMCOPY(state->next_output_byte, buffer, bytestocopy); \
+      state->next_output_byte += bytestocopy; \
+      buffer += bytestocopy; \
+      state->free_in_buffer -= bytestocopy; \
+      if (state->free_in_buffer == 0) \
+        if (!dump_buffer(state)) return FALSE; \
+      bytes -= bytestocopy; \
+    } \
+  } else { \
+    state->free_in_buffer -= (buffer - state->next_output_byte); \
+    state->next_output_byte = buffer; \
+  } \
+}
+
+
+LOCAL(boolean)
+flush_bits(working_state *state)
+{
+  JOCTET _buffer[BUFSIZE], *buffer, temp;
+  simd_bit_buf_type put_buffer;  int put_bits;
+  int localbuf = 0;
+
+  if (state->simd) {
+#if defined(__aarch64__) && !defined(NEON_INTRINSICS)
+    put_bits = state->cur.free_bits;
+#else
+    put_bits = SIMD_BIT_BUF_SIZE - state->cur.free_bits;
+#endif
+    put_buffer = state->cur.put_buffer.simd;
+  } else {
+    put_bits = BIT_BUF_SIZE - state->cur.free_bits;
+    put_buffer = state->cur.put_buffer.c;
+  }
+
+  LOAD_BUFFER()
+
+  while (put_bits >= 8) {
+    put_bits -= 8;
+    temp = (JOCTET)(put_buffer >> put_bits);
+    EMIT_BYTE(temp)
+  }
+  if (put_bits) {
+    /* fill partial byte with ones */
+    temp = (JOCTET)((put_buffer << (8 - put_bits)) | (0xFF >> put_bits));
+    EMIT_BYTE(temp)
+  }
+
+  if (state->simd) {                    /* and reset bit buffer to empty */
+    state->cur.put_buffer.simd = 0;
+#if defined(__aarch64__) && !defined(NEON_INTRINSICS)
+    state->cur.free_bits = 0;
+#else
+    state->cur.free_bits = SIMD_BIT_BUF_SIZE;
+#endif
+  } else {
+    state->cur.put_buffer.c = 0;
+    state->cur.free_bits = BIT_BUF_SIZE;
+  }
+  STORE_BUFFER()
+
+  return TRUE;
+}
+
+
+/* Encode a single block's worth of coefficients */
+
+LOCAL(boolean)
+encode_one_block_simd(working_state *state, JCOEFPTR block, int last_dc_val,
+                      c_derived_tbl *dctbl, c_derived_tbl *actbl)
+{
+  JOCTET _buffer[BUFSIZE], *buffer;
+  int localbuf = 0;
+
+  LOAD_BUFFER()
+
+  buffer = jsimd_huff_encode_one_block(state, buffer, block, last_dc_val,
+                                       dctbl, actbl);
+
+  STORE_BUFFER()
+
+  return TRUE;
+}
+
+LOCAL(boolean)
+encode_one_block(working_state *state, JCOEFPTR block, int last_dc_val,
+                 c_derived_tbl *dctbl, c_derived_tbl *actbl)
+{
+  int temp, nbits, free_bits;
+  bit_buf_type put_buffer;
+  JOCTET _buffer[BUFSIZE], *buffer;
+  int localbuf = 0;
+
+  free_bits = state->cur.free_bits;
+  put_buffer = state->cur.put_buffer.c;
+  LOAD_BUFFER()
+
+  /* Encode the DC coefficient difference per section F.1.2.1 */
+
+  temp = block[0] - last_dc_val;
+
+  /* This is a well-known technique for obtaining the absolute value without a
+   * branch.  It is derived from an assembly language technique presented in
+   * "How to Optimize for the Pentium Processors", Copyright (c) 1996, 1997 by
+   * Agner Fog.  This code assumes we are on a two's complement machine.
+   */
+  nbits = temp >> (CHAR_BIT * sizeof(int) - 1);
+  temp += nbits;
+  nbits ^= temp;
+
+  /* Find the number of bits needed for the magnitude of the coefficient */
+  nbits = JPEG_NBITS(nbits);
+
+  /* Emit the Huffman-coded symbol for the number of bits.
+   * Emit that number of bits of the value, if positive,
+   * or the complement of its magnitude, if negative.
+   */
+  PUT_CODE(dctbl->ehufco[nbits], dctbl->ehufsi[nbits])
+
+  /* Encode the AC coefficients per section F.1.2.2 */
+
+  {
+    int r = 0;                  /* r = run length of zeros */
+
+/* Manually unroll the k loop to eliminate the counter variable.  This
+ * improves performance greatly on systems with a limited number of
+ * registers (such as x86.)
+ */
+#define kloop(jpeg_natural_order_of_k) { \
+  if ((temp = block[jpeg_natural_order_of_k]) == 0) { \
+    r += 16; \
+  } else { \
+    /* Branch-less absolute value, bitwise complement, etc., same as above */ \
+    nbits = temp >> (CHAR_BIT * sizeof(int) - 1); \
+    temp += nbits; \
+    nbits ^= temp; \
+    nbits = JPEG_NBITS_NONZERO(nbits); \
+    /* if run length > 15, must emit special run-length-16 codes (0xF0) */ \
+    while (r >= 16 * 16) { \
+      r -= 16 * 16; \
+      PUT_BITS(actbl->ehufco[0xf0], actbl->ehufsi[0xf0]) \
+    } \
+    /* Emit Huffman symbol for run length / number of bits */ \
+    r += nbits; \
+    PUT_CODE(actbl->ehufco[r], actbl->ehufsi[r]) \
+    r = 0; \
+  } \
+}
+
+    /* One iteration for each value in jpeg_natural_order[] */
+    kloop(1);   kloop(8);   kloop(16);  kloop(9);   kloop(2);   kloop(3);
+    kloop(10);  kloop(17);  kloop(24);  kloop(32);  kloop(25);  kloop(18);
+    kloop(11);  kloop(4);   kloop(5);   kloop(12);  kloop(19);  kloop(26);
+    kloop(33);  kloop(40);  kloop(48);  kloop(41);  kloop(34);  kloop(27);
+    kloop(20);  kloop(13);  kloop(6);   kloop(7);   kloop(14);  kloop(21);
+    kloop(28);  kloop(35);  kloop(42);  kloop(49);  kloop(56);  kloop(57);
+    kloop(50);  kloop(43);  kloop(36);  kloop(29);  kloop(22);  kloop(15);
+    kloop(23);  kloop(30);  kloop(37);  kloop(44);  kloop(51);  kloop(58);
+    kloop(59);  kloop(52);  kloop(45);  kloop(38);  kloop(31);  kloop(39);
+    kloop(46);  kloop(53);  kloop(60);  kloop(61);  kloop(54);  kloop(47);
+    kloop(55);  kloop(62);  kloop(63);
+
+    /* If the last coef(s) were zero, emit an end-of-block code */
+    if (r > 0) {
+      PUT_BITS(actbl->ehufco[0], actbl->ehufsi[0])
+    }
+  }
+
+  state->cur.put_buffer.c = put_buffer;
+  state->cur.free_bits = free_bits;
+  STORE_BUFFER()
+
+  return TRUE;
+}
+
+
+/*
+ * Emit a restart marker & resynchronize predictions.
+ */
+
+LOCAL(boolean)
+emit_restart(working_state *state, int restart_num)
+{
+  int ci;
+
+  if (!flush_bits(state))
+    return FALSE;
+
+  emit_byte(state, 0xFF, return FALSE);
+  emit_byte(state, JPEG_RST0 + restart_num, return FALSE);
+
+  /* Re-initialize DC predictions to 0 */
+  for (ci = 0; ci < state->cinfo->comps_in_scan; ci++)
+    state->cur.last_dc_val[ci] = 0;
+
+  /* The restart counter is not updated until we successfully write the MCU. */
+
+  return TRUE;
+}
+
+
+/*
+ * Encode and output one MCU's worth of Huffman-compressed coefficients.
+ */
+
+METHODDEF(boolean)
+encode_mcu_huff(j_compress_ptr cinfo, JBLOCKROW *MCU_data)
+{
+  huff_entropy_ptr entropy = (huff_entropy_ptr)cinfo->entropy;
+  working_state state;
+  int blkn, ci;
+  jpeg_component_info *compptr;
+
+  /* Load up working state */
+  state.next_output_byte = cinfo->dest->next_output_byte;
+  state.free_in_buffer = cinfo->dest->free_in_buffer;
+  state.cur = entropy->saved;
+  state.cinfo = cinfo;
+  state.simd = entropy->simd;
+
+  /* Emit restart marker if needed */
+  if (cinfo->restart_interval) {
+    if (entropy->restarts_to_go == 0)
+      if (!emit_restart(&state, entropy->next_restart_num))
+        return FALSE;
+  }
+
+  /* Encode the MCU data blocks */
+  if (entropy->simd) {
+    for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
+      ci = cinfo->MCU_membership[blkn];
+      compptr = cinfo->cur_comp_info[ci];
+      if (!encode_one_block_simd(&state,
+                                 MCU_data[blkn][0], state.cur.last_dc_val[ci],
+                                 entropy->dc_derived_tbls[compptr->dc_tbl_no],
+                                 entropy->ac_derived_tbls[compptr->ac_tbl_no]))
+        return FALSE;
+      /* Update last_dc_val */
+      state.cur.last_dc_val[ci] = MCU_data[blkn][0][0];
+    }
+  } else {
+    for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
+      ci = cinfo->MCU_membership[blkn];
+      compptr = cinfo->cur_comp_info[ci];
+      if (!encode_one_block(&state,
+                            MCU_data[blkn][0], state.cur.last_dc_val[ci],
+                            entropy->dc_derived_tbls[compptr->dc_tbl_no],
+                            entropy->ac_derived_tbls[compptr->ac_tbl_no]))
+        return FALSE;
+      /* Update last_dc_val */
+      state.cur.last_dc_val[ci] = MCU_data[blkn][0][0];
+    }
+  }
+
+  /* Completed MCU, so update state */
+  cinfo->dest->next_output_byte = state.next_output_byte;
+  cinfo->dest->free_in_buffer = state.free_in_buffer;
+  entropy->saved = state.cur;
+
+  /* Update restart-interval state too */
+  if (cinfo->restart_interval) {
+    if (entropy->restarts_to_go == 0) {
+      entropy->restarts_to_go = cinfo->restart_interval;
+      entropy->next_restart_num++;
+      entropy->next_restart_num &= 7;
+    }
+    entropy->restarts_to_go--;
+  }
+
+  return TRUE;
+}
+
+
+/*
+ * Finish up at the end of a Huffman-compressed scan.
+ */
+
+METHODDEF(void)
+finish_pass_huff(j_compress_ptr cinfo)
+{
+  huff_entropy_ptr entropy = (huff_entropy_ptr)cinfo->entropy;
+  working_state state;
+
+  /* Load up working state ... flush_bits needs it */
+  state.next_output_byte = cinfo->dest->next_output_byte;
+  state.free_in_buffer = cinfo->dest->free_in_buffer;
+  state.cur = entropy->saved;
+  state.cinfo = cinfo;
+  state.simd = entropy->simd;
+
+  /* Flush out the last data */
+  if (!flush_bits(&state))
+    ERREXIT(cinfo, JERR_CANT_SUSPEND);
+
+  /* Update state */
+  cinfo->dest->next_output_byte = state.next_output_byte;
+  cinfo->dest->free_in_buffer = state.free_in_buffer;
+  entropy->saved = state.cur;
+}
+
+
+/*
+ * Huffman coding optimization.
+ *
+ * We first scan the supplied data and count the number of uses of each symbol
+ * that is to be Huffman-coded. (This process MUST agree with the code above.)
+ * Then we build a Huffman coding tree for the observed counts.
+ * Symbols which are not needed at all for the particular image are not
+ * assigned any code, which saves space in the DHT marker as well as in
+ * the compressed data.
+ */
+
+#ifdef ENTROPY_OPT_SUPPORTED
+
+
+/* Process a single block's worth of coefficients */
+
+LOCAL(void)
+htest_one_block(j_compress_ptr cinfo, JCOEFPTR block, int last_dc_val,
+                long dc_counts[], long ac_counts[])
+{
+  register int temp;
+  register int nbits;
+  register int k, r;
+
+  /* Encode the DC coefficient difference per section F.1.2.1 */
+
+  temp = block[0] - last_dc_val;
+  if (temp < 0)
+    temp = -temp;
+
+  /* Find the number of bits needed for the magnitude of the coefficient */
+  nbits = 0;
+  while (temp) {
+    nbits++;
+    temp >>= 1;
+  }
+  /* Check for out-of-range coefficient values.
+   * Since we're encoding a difference, the range limit is twice as much.
+   */
+  if (nbits > MAX_COEF_BITS + 1)
+    ERREXIT(cinfo, JERR_BAD_DCT_COEF);
+
+  /* Count the Huffman symbol for the number of bits */
+  dc_counts[nbits]++;
+
+  /* Encode the AC coefficients per section F.1.2.2 */
+
+  r = 0;                        /* r = run length of zeros */
+
+  for (k = 1; k < DCTSIZE2; k++) {
+    if ((temp = block[jpeg_natural_order[k]]) == 0) {
+      r++;
+    } else {
+      /* if run length > 15, must emit special run-length-16 codes (0xF0) */
+      while (r > 15) {
+        ac_counts[0xF0]++;
+        r -= 16;
+      }
+
+      /* Find the number of bits needed for the magnitude of the coefficient */
+      if (temp < 0)
+        temp = -temp;
+
+      /* Find the number of bits needed for the magnitude of the coefficient */
+      nbits = 1;                /* there must be at least one 1 bit */
+      while ((temp >>= 1))
+        nbits++;
+      /* Check for out-of-range coefficient values */
+      if (nbits > MAX_COEF_BITS)
+        ERREXIT(cinfo, JERR_BAD_DCT_COEF);
+
+      /* Count Huffman symbol for run length / number of bits */
+      ac_counts[(r << 4) + nbits]++;
+
+      r = 0;
+    }
+  }
+
+  /* If the last coef(s) were zero, emit an end-of-block code */
+  if (r > 0)
+    ac_counts[0]++;
+}
+
+
+/*
+ * Trial-encode one MCU's worth of Huffman-compressed coefficients.
+ * No data is actually output, so no suspension return is possible.
+ */
+
+METHODDEF(boolean)
+encode_mcu_gather(j_compress_ptr cinfo, JBLOCKROW *MCU_data)
+{
+  huff_entropy_ptr entropy = (huff_entropy_ptr)cinfo->entropy;
+  int blkn, ci;
+  jpeg_component_info *compptr;
+
+  /* Take care of restart intervals if needed */
+  if (cinfo->restart_interval) {
+    if (entropy->restarts_to_go == 0) {
+      /* Re-initialize DC predictions to 0 */
+      for (ci = 0; ci < cinfo->comps_in_scan; ci++)
+        entropy->saved.last_dc_val[ci] = 0;
+      /* Update restart state */
+      entropy->restarts_to_go = cinfo->restart_interval;
+    }
+    entropy->restarts_to_go--;
+  }
+
+  for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
+    ci = cinfo->MCU_membership[blkn];
+    compptr = cinfo->cur_comp_info[ci];
+    htest_one_block(cinfo, MCU_data[blkn][0], entropy->saved.last_dc_val[ci],
+                    entropy->dc_count_ptrs[compptr->dc_tbl_no],
+                    entropy->ac_count_ptrs[compptr->ac_tbl_no]);
+    entropy->saved.last_dc_val[ci] = MCU_data[blkn][0][0];
+  }
+
+  return TRUE;
+}
+
+
+/*
+ * Generate the best Huffman code table for the given counts, fill htbl.
+ * Note this is also used by jcphuff.c.
+ *
+ * The JPEG standard requires that no symbol be assigned a codeword of all
+ * one bits (so that padding bits added at the end of a compressed segment
+ * can't look like a valid code).  Because of the canonical ordering of
+ * codewords, this just means that there must be an unused slot in the
+ * longest codeword length category.  Annex K (Clause K.2) of
+ * Rec. ITU-T T.81 (1992) | ISO/IEC 10918-1:1994 suggests reserving such a slot
+ * by pretending that symbol 256 is a valid symbol with count 1.  In theory
+ * that's not optimal; giving it count zero but including it in the symbol set
+ * anyway should give a better Huffman code.  But the theoretically better code
+ * actually seems to come out worse in practice, because it produces more
+ * all-ones bytes (which incur stuffed zero bytes in the final file).  In any
+ * case the difference is tiny.
+ *
+ * The JPEG standard requires Huffman codes to be no more than 16 bits long.
+ * If some symbols have a very small but nonzero probability, the Huffman tree
+ * must be adjusted to meet the code length restriction.  We currently use
+ * the adjustment method suggested in JPEG section K.2.  This method is *not*
+ * optimal; it may not choose the best possible limited-length code.  But
+ * typically only very-low-frequency symbols will be given less-than-optimal
+ * lengths, so the code is almost optimal.  Experimental comparisons against
+ * an optimal limited-length-code algorithm indicate that the difference is
+ * microscopic --- usually less than a hundredth of a percent of total size.
+ * So the extra complexity of an optimal algorithm doesn't seem worthwhile.
+ */
+
+GLOBAL(void)
+jpeg_gen_optimal_table(j_compress_ptr cinfo, JHUFF_TBL *htbl, long freq[])
+{
+#define MAX_CLEN  32            /* assumed maximum initial code length */
+  UINT8 bits[MAX_CLEN + 1];     /* bits[k] = # of symbols with code length k */
+  int codesize[257];            /* codesize[k] = code length of symbol k */
+  int others[257];              /* next symbol in current branch of tree */
+  int c1, c2;
+  int p, i, j;
+  long v;
+
+  /* This algorithm is explained in section K.2 of the JPEG standard */
+
+  MEMZERO(bits, sizeof(bits));
+  MEMZERO(codesize, sizeof(codesize));
+  for (i = 0; i < 257; i++)
+    others[i] = -1;             /* init links to empty */
+
+  freq[256] = 1;                /* make sure 256 has a nonzero count */
+  /* Including the pseudo-symbol 256 in the Huffman procedure guarantees
+   * that no real symbol is given code-value of all ones, because 256
+   * will be placed last in the largest codeword category.
+   */
+
+  /* Huffman's basic algorithm to assign optimal code lengths to symbols */
+
+  for (;;) {
+    /* Find the smallest nonzero frequency, set c1 = its symbol */
+    /* In case of ties, take the larger symbol number */
+    c1 = -1;
+    v = 1000000000L;
+    for (i = 0; i <= 256; i++) {
+      if (freq[i] && freq[i] <= v) {
+        v = freq[i];
+        c1 = i;
+      }
+    }
+
+    /* Find the next smallest nonzero frequency, set c2 = its symbol */
+    /* In case of ties, take the larger symbol number */
+    c2 = -1;
+    v = 1000000000L;
+    for (i = 0; i <= 256; i++) {
+      if (freq[i] && freq[i] <= v && i != c1) {
+        v = freq[i];
+        c2 = i;
+      }
+    }
+
+    /* Done if we've merged everything into one frequency */
+    if (c2 < 0)
+      break;
+
+    /* Else merge the two counts/trees */
+    freq[c1] += freq[c2];
+    freq[c2] = 0;
+
+    /* Increment the codesize of everything in c1's tree branch */
+    codesize[c1]++;
+    while (others[c1] >= 0) {
+      c1 = others[c1];
+      codesize[c1]++;
+    }
+
+    others[c1] = c2;            /* chain c2 onto c1's tree branch */
+
+    /* Increment the codesize of everything in c2's tree branch */
+    codesize[c2]++;
+    while (others[c2] >= 0) {
+      c2 = others[c2];
+      codesize[c2]++;
+    }
+  }
+
+  /* Now count the number of symbols of each code length */
+  for (i = 0; i <= 256; i++) {
+    if (codesize[i]) {
+      /* The JPEG standard seems to think that this can't happen, */
+      /* but I'm paranoid... */
+      if (codesize[i] > MAX_CLEN)
+        ERREXIT(cinfo, JERR_HUFF_CLEN_OVERFLOW);
+
+      bits[codesize[i]]++;
+    }
+  }
+
+  /* JPEG doesn't allow symbols with code lengths over 16 bits, so if the pure
+   * Huffman procedure assigned any such lengths, we must adjust the coding.
+   * Here is what Rec. ITU-T T.81 | ISO/IEC 10918-1 says about how this next
+   * bit works: Since symbols are paired for the longest Huffman code, the
+   * symbols are removed from this length category two at a time.  The prefix
+   * for the pair (which is one bit shorter) is allocated to one of the pair;
+   * then, skipping the BITS entry for that prefix length, a code word from the
+   * next shortest nonzero BITS entry is converted into a prefix for two code
+   * words one bit longer.
+   */
+
+  for (i = MAX_CLEN; i > 16; i--) {
+    while (bits[i] > 0) {
+      j = i - 2;                /* find length of new prefix to be used */
+      while (bits[j] == 0)
+        j--;
+
+      bits[i] -= 2;             /* remove two symbols */
+      bits[i - 1]++;            /* one goes in this length */
+      bits[j + 1] += 2;         /* two new symbols in this length */
+      bits[j]--;                /* symbol of this length is now a prefix */
+    }
+  }
+
+  /* Remove the count for the pseudo-symbol 256 from the largest codelength */
+  while (bits[i] == 0)          /* find largest codelength still in use */
+    i--;
+  bits[i]--;
+
+  /* Return final symbol counts (only for lengths 0..16) */
+  MEMCOPY(htbl->bits, bits, sizeof(htbl->bits));
+
+  /* Return a list of the symbols sorted by code length */
+  /* It's not real clear to me why we don't need to consider the codelength
+   * changes made above, but Rec. ITU-T T.81 | ISO/IEC 10918-1 seems to think
+   * this works.
+   */
+  p = 0;
+  for (i = 1; i <= MAX_CLEN; i++) {
+    for (j = 0; j <= 255; j++) {
+      if (codesize[j] == i) {
+        htbl->huffval[p] = (UINT8)j;
+        p++;
+      }
+    }
+  }
+
+  /* Set sent_table FALSE so updated table will be written to JPEG file. */
+  htbl->sent_table = FALSE;
+}
+
+
+/*
+ * Finish up a statistics-gathering pass and create the new Huffman tables.
+ */
+
+METHODDEF(void)
+finish_pass_gather(j_compress_ptr cinfo)
+{
+  huff_entropy_ptr entropy = (huff_entropy_ptr)cinfo->entropy;
+  int ci, dctbl, actbl;
+  jpeg_component_info *compptr;
+  JHUFF_TBL **htblptr;
+  boolean did_dc[NUM_HUFF_TBLS];
+  boolean did_ac[NUM_HUFF_TBLS];
+
+  /* It's important not to apply jpeg_gen_optimal_table more than once
+   * per table, because it clobbers the input frequency counts!
+   */
+  MEMZERO(did_dc, sizeof(did_dc));
+  MEMZERO(did_ac, sizeof(did_ac));
+
+  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+    compptr = cinfo->cur_comp_info[ci];
+    dctbl = compptr->dc_tbl_no;
+    actbl = compptr->ac_tbl_no;
+    if (!did_dc[dctbl]) {
+      htblptr = &cinfo->dc_huff_tbl_ptrs[dctbl];
+      if (*htblptr == NULL)
+        *htblptr = jpeg_alloc_huff_table((j_common_ptr)cinfo);
+      jpeg_gen_optimal_table(cinfo, *htblptr, entropy->dc_count_ptrs[dctbl]);
+      did_dc[dctbl] = TRUE;
+    }
+    if (!did_ac[actbl]) {
+      htblptr = &cinfo->ac_huff_tbl_ptrs[actbl];
+      if (*htblptr == NULL)
+        *htblptr = jpeg_alloc_huff_table((j_common_ptr)cinfo);
+      jpeg_gen_optimal_table(cinfo, *htblptr, entropy->ac_count_ptrs[actbl]);
+      did_ac[actbl] = TRUE;
+    }
+  }
+}
+
+
+#endif /* ENTROPY_OPT_SUPPORTED */
+
+
+/*
+ * Module initialization routine for Huffman entropy encoding.
+ */
+
+GLOBAL(void)
+jinit_huff_encoder(j_compress_ptr cinfo)
+{
+  huff_entropy_ptr entropy;
+  int i;
+
+  entropy = (huff_entropy_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+                                sizeof(huff_entropy_encoder));
+  cinfo->entropy = (struct jpeg_entropy_encoder *)entropy;
+  entropy->pub.start_pass = start_pass_huff;
+
+  /* Mark tables unallocated */
+  for (i = 0; i < NUM_HUFF_TBLS; i++) {
+    entropy->dc_derived_tbls[i] = entropy->ac_derived_tbls[i] = NULL;
+#ifdef ENTROPY_OPT_SUPPORTED
+    entropy->dc_count_ptrs[i] = entropy->ac_count_ptrs[i] = NULL;
+#endif
+  }
+}
diff --git a/3rdparty/libjpeg/src/jchuff.h b/3rdparty/libjpeg/src/jchuff.h
new file mode 100644
index 00000000..314a2325
--- /dev/null
+++ b/3rdparty/libjpeg/src/jchuff.h
@@ -0,0 +1,42 @@
+/*
+ * jchuff.h
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1991-1997, Thomas G. Lane.
+ * It was modified by The libjpeg-turbo Project to include only code relevant
+ * to libjpeg-turbo.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains declarations for Huffman entropy encoding routines
+ * that are shared between the sequential encoder (jchuff.c) and the
+ * progressive encoder (jcphuff.c).  No other modules need to see these.
+ */
+
+/* The legal range of a DCT coefficient is
+ *  -1024 .. +1023  for 8-bit data;
+ * -16384 .. +16383 for 12-bit data.
+ * Hence the magnitude should always fit in 10 or 14 bits respectively.
+ */
+
+#if BITS_IN_JSAMPLE == 8
+#define MAX_COEF_BITS  10
+#else
+#define MAX_COEF_BITS  14
+#endif
+
+/* Derived data constructed for each Huffman table */
+
+typedef struct {
+  unsigned int ehufco[256];     /* code for each symbol */
+  char ehufsi[256];             /* length of code for each symbol */
+  /* If no code has been allocated for a symbol S, ehufsi[S] contains 0 */
+} c_derived_tbl;
+
+/* Expand a Huffman table definition into the derived format */
+EXTERN(void) jpeg_make_c_derived_tbl(j_compress_ptr cinfo, boolean isDC,
+                                     int tblno, c_derived_tbl **pdtbl);
+
+/* Generate an optimal table definition given the specified counts */
+EXTERN(void) jpeg_gen_optimal_table(j_compress_ptr cinfo, JHUFF_TBL *htbl,
+                                    long freq[]);
diff --git a/3rdparty/libjpeg/src/jcicc.c b/3rdparty/libjpeg/src/jcicc.c
new file mode 100644
index 00000000..11037ff6
--- /dev/null
+++ b/3rdparty/libjpeg/src/jcicc.c
@@ -0,0 +1,105 @@
+/*
+ * jcicc.c
+ *
+ * Copyright (C) 1997-1998, Thomas G. Lane, Todd Newman.
+ * Copyright (C) 2017, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file provides code to write International Color Consortium (ICC) device
+ * profiles embedded in JFIF JPEG image files.  The ICC has defined a standard
+ * for including such data in JPEG "APP2" markers.  The code given here does
+ * not know anything about the internal structure of the ICC profile data; it
+ * just knows how to embed the profile data in a JPEG file while writing it.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jerror.h"
+
+
+/*
+ * Since an ICC profile can be larger than the maximum size of a JPEG marker
+ * (64K), we need provisions to split it into multiple markers.  The format
+ * defined by the ICC specifies one or more APP2 markers containing the
+ * following data:
+ *      Identifying string      ASCII "ICC_PROFILE\0"  (12 bytes)
+ *      Marker sequence number  1 for first APP2, 2 for next, etc (1 byte)
+ *      Number of markers       Total number of APP2's used (1 byte)
+ *      Profile data            (remainder of APP2 data)
+ * Decoders should use the marker sequence numbers to reassemble the profile,
+ * rather than assuming that the APP2 markers appear in the correct sequence.
+ */
+
+#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)
+
+
+/*
+ * This routine writes the given ICC profile data into a JPEG file.  It *must*
+ * be called AFTER calling jpeg_start_compress() and BEFORE the first call to
+ * jpeg_write_scanlines().  (This ordering ensures that the APP2 marker(s) will
+ * appear after the SOI and JFIF or Adobe markers, but before all else.)
+ */
+
+GLOBAL(void)
+jpeg_write_icc_profile(j_compress_ptr cinfo, const JOCTET *icc_data_ptr,
+                       unsigned int icc_data_len)
+{
+  unsigned int num_markers;     /* total number of markers we'll write */
+  int cur_marker = 1;           /* per spec, counting starts at 1 */
+  unsigned int length;          /* number of bytes to write in this marker */
+
+  if (icc_data_ptr == NULL || icc_data_len == 0)
+    ERREXIT(cinfo, JERR_BUFFER_SIZE);
+  if (cinfo->global_state < CSTATE_SCANNING)
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+
+  /* Calculate the number of markers we'll need, rounding up of course */
+  num_markers = icc_data_len / MAX_DATA_BYTES_IN_MARKER;
+  if (num_markers * MAX_DATA_BYTES_IN_MARKER != icc_data_len)
+    num_markers++;
+
+  while (icc_data_len > 0) {
+    /* length of profile to put in this marker */
+    length = icc_data_len;
+    if (length > MAX_DATA_BYTES_IN_MARKER)
+      length = MAX_DATA_BYTES_IN_MARKER;
+    icc_data_len -= length;
+
+    /* Write the JPEG marker header (APP2 code and marker length) */
+    jpeg_write_m_header(cinfo, ICC_MARKER,
+                        (unsigned int)(length + ICC_OVERHEAD_LEN));
+
+    /* Write the marker identifying string "ICC_PROFILE" (null-terminated).  We
+     * code it in this less-than-transparent way so that the code works even if
+     * the local character set is not ASCII.
+     */
+    jpeg_write_m_byte(cinfo, 0x49);
+    jpeg_write_m_byte(cinfo, 0x43);
+    jpeg_write_m_byte(cinfo, 0x43);
+    jpeg_write_m_byte(cinfo, 0x5F);
+    jpeg_write_m_byte(cinfo, 0x50);
+    jpeg_write_m_byte(cinfo, 0x52);
+    jpeg_write_m_byte(cinfo, 0x4F);
+    jpeg_write_m_byte(cinfo, 0x46);
+    jpeg_write_m_byte(cinfo, 0x49);
+    jpeg_write_m_byte(cinfo, 0x4C);
+    jpeg_write_m_byte(cinfo, 0x45);
+    jpeg_write_m_byte(cinfo, 0x0);
+
+    /* Add the sequencing info */
+    jpeg_write_m_byte(cinfo, cur_marker);
+    jpeg_write_m_byte(cinfo, (int)num_markers);
+
+    /* Add the profile data */
+    while (length--) {
+      jpeg_write_m_byte(cinfo, *icc_data_ptr);
+      icc_data_ptr++;
+    }
+    cur_marker++;
+  }
+}
diff --git a/3rdparty/libjpeg/src/jcinit.c b/3rdparty/libjpeg/src/jcinit.c
new file mode 100644
index 00000000..157353a2
--- /dev/null
+++ b/3rdparty/libjpeg/src/jcinit.c
@@ -0,0 +1,80 @@
+/*
+ * jcinit.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1991-1997, Thomas G. Lane.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2020, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains initialization logic for the JPEG compressor.
+ * This routine is in charge of selecting the modules to be executed and
+ * making an initialization call to each one.
+ *
+ * Logically, this code belongs in jcmaster.c.  It's split out because
+ * linking this routine implies linking the entire compression library.
+ * For a transcoding-only application, we want to be able to use jcmaster.c
+ * without linking in the whole library.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jpegcomp.h"
+
+
+/*
+ * Master selection of compression modules.
+ * This is done once at the start of processing an image.  We determine
+ * which modules will be used and give them appropriate initialization calls.
+ */
+
+GLOBAL(void)
+jinit_compress_master(j_compress_ptr cinfo)
+{
+  /* Initialize master control (includes parameter checking/processing) */
+  jinit_c_master_control(cinfo, FALSE /* full compression */);
+
+  /* Preprocessing */
+  if (!cinfo->raw_data_in) {
+    jinit_color_converter(cinfo);
+    jinit_downsampler(cinfo);
+    jinit_c_prep_controller(cinfo, FALSE /* never need full buffer here */);
+  }
+  /* Forward DCT */
+  jinit_forward_dct(cinfo);
+  /* Entropy encoding: either Huffman or arithmetic coding. */
+  if (cinfo->arith_code) {
+#ifdef C_ARITH_CODING_SUPPORTED
+    jinit_arith_encoder(cinfo);
+#else
+    ERREXIT(cinfo, JERR_ARITH_NOTIMPL);
+#endif
+  } else {
+    if (cinfo->progressive_mode) {
+#ifdef C_PROGRESSIVE_SUPPORTED
+      jinit_phuff_encoder(cinfo);
+#else
+      ERREXIT(cinfo, JERR_NOT_COMPILED);
+#endif
+    } else
+      jinit_huff_encoder(cinfo);
+  }
+
+  /* Need a full-image coefficient buffer in any multi-pass mode. */
+  jinit_c_coef_controller(cinfo, (boolean)(cinfo->num_scans > 1 ||
+                                           cinfo->optimize_coding));
+  jinit_c_main_controller(cinfo, FALSE /* never need full buffer here */);
+
+  jinit_marker_writer(cinfo);
+
+  /* We can now tell the memory manager to allocate virtual arrays. */
+  (*cinfo->mem->realize_virt_arrays) ((j_common_ptr)cinfo);
+
+  /* Write the datastream header (SOI) immediately.
+   * Frame and scan headers are postponed till later.
+   * This lets application insert special markers after the SOI.
+   */
+  (*cinfo->marker->write_file_header) (cinfo);
+}
diff --git a/3rdparty/libjpeg/src/jcmainct.c b/3rdparty/libjpeg/src/jcmainct.c
new file mode 100644
index 00000000..3f23028c
--- /dev/null
+++ b/3rdparty/libjpeg/src/jcmainct.c
@@ -0,0 +1,162 @@
+/*
+ * jcmainct.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1994-1996, Thomas G. Lane.
+ * It was modified by The libjpeg-turbo Project to include only code relevant
+ * to libjpeg-turbo.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains the main buffer controller for compression.
+ * The main buffer lies between the pre-processor and the JPEG
+ * compressor proper; it holds downsampled data in the JPEG colorspace.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/* Private buffer controller object */
+
+typedef struct {
+  struct jpeg_c_main_controller pub; /* public fields */
+
+  JDIMENSION cur_iMCU_row;      /* number of current iMCU row */
+  JDIMENSION rowgroup_ctr;      /* counts row groups received in iMCU row */
+  boolean suspended;            /* remember if we suspended output */
+  J_BUF_MODE pass_mode;         /* current operating mode */
+
+  /* If using just a strip buffer, this points to the entire set of buffers
+   * (we allocate one for each component).  In the full-image case, this
+   * points to the currently accessible strips of the virtual arrays.
+   */
+  JSAMPARRAY buffer[MAX_COMPONENTS];
+} my_main_controller;
+
+typedef my_main_controller *my_main_ptr;
+
+
+/* Forward declarations */
+METHODDEF(void) process_data_simple_main(j_compress_ptr cinfo,
+                                         JSAMPARRAY input_buf,
+                                         JDIMENSION *in_row_ctr,
+                                         JDIMENSION in_rows_avail);
+
+
+/*
+ * Initialize for a processing pass.
+ */
+
+METHODDEF(void)
+start_pass_main(j_compress_ptr cinfo, J_BUF_MODE pass_mode)
+{
+  my_main_ptr main_ptr = (my_main_ptr)cinfo->main;
+
+  /* Do nothing in raw-data mode. */
+  if (cinfo->raw_data_in)
+    return;
+
+  if (pass_mode != JBUF_PASS_THRU)
+    ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+
+  main_ptr->cur_iMCU_row = 0;   /* initialize counters */
+  main_ptr->rowgroup_ctr = 0;
+  main_ptr->suspended = FALSE;
+  main_ptr->pass_mode = pass_mode;      /* save mode for use by process_data */
+  main_ptr->pub.process_data = process_data_simple_main;
+}
+
+
+/*
+ * Process some data.
+ * This routine handles the simple pass-through mode,
+ * where we have only a strip buffer.
+ */
+
+METHODDEF(void)
+process_data_simple_main(j_compress_ptr cinfo, JSAMPARRAY input_buf,
+                         JDIMENSION *in_row_ctr, JDIMENSION in_rows_avail)
+{
+  my_main_ptr main_ptr = (my_main_ptr)cinfo->main;
+
+  while (main_ptr->cur_iMCU_row < cinfo->total_iMCU_rows) {
+    /* Read input data if we haven't filled the main buffer yet */
+    if (main_ptr->rowgroup_ctr < DCTSIZE)
+      (*cinfo->prep->pre_process_data) (cinfo, input_buf, in_row_ctr,
+                                        in_rows_avail, main_ptr->buffer,
+                                        &main_ptr->rowgroup_ctr,
+                                        (JDIMENSION)DCTSIZE);
+
+    /* If we don't have a full iMCU row buffered, return to application for
+     * more data.  Note that preprocessor will always pad to fill the iMCU row
+     * at the bottom of the image.
+     */
+    if (main_ptr->rowgroup_ctr != DCTSIZE)
+      return;
+
+    /* Send the completed row to the compressor */
+    if (!(*cinfo->coef->compress_data) (cinfo, main_ptr->buffer)) {
+      /* If compressor did not consume the whole row, then we must need to
+       * suspend processing and return to the application.  In this situation
+       * we pretend we didn't yet consume the last input row; otherwise, if
+       * it happened to be the last row of the image, the application would
+       * think we were done.
+       */
+      if (!main_ptr->suspended) {
+        (*in_row_ctr)--;
+        main_ptr->suspended = TRUE;
+      }
+      return;
+    }
+    /* We did finish the row.  Undo our little suspension hack if a previous
+     * call suspended; then mark the main buffer empty.
+     */
+    if (main_ptr->suspended) {
+      (*in_row_ctr)++;
+      main_ptr->suspended = FALSE;
+    }
+    main_ptr->rowgroup_ctr = 0;
+    main_ptr->cur_iMCU_row++;
+  }
+}
+
+
+/*
+ * Initialize main buffer controller.
+ */
+
+GLOBAL(void)
+jinit_c_main_controller(j_compress_ptr cinfo, boolean need_full_buffer)
+{
+  my_main_ptr main_ptr;
+  int ci;
+  jpeg_component_info *compptr;
+
+  main_ptr = (my_main_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+                                sizeof(my_main_controller));
+  cinfo->main = (struct jpeg_c_main_controller *)main_ptr;
+  main_ptr->pub.start_pass = start_pass_main;
+
+  /* We don't need to create a buffer in raw-data mode. */
+  if (cinfo->raw_data_in)
+    return;
+
+  /* Create the buffer.  It holds downsampled data, so each component
+   * may be of a different size.
+   */
+  if (need_full_buffer) {
+    ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+  } else {
+    /* Allocate a strip buffer for each component */
+    for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+         ci++, compptr++) {
+      main_ptr->buffer[ci] = (*cinfo->mem->alloc_sarray)
+        ((j_common_ptr)cinfo, JPOOL_IMAGE,
+         compptr->width_in_blocks * DCTSIZE,
+         (JDIMENSION)(compptr->v_samp_factor * DCTSIZE));
+    }
+  }
+}
diff --git a/3rdparty/libjpeg/src/jcmarker.c b/3rdparty/libjpeg/src/jcmarker.c
new file mode 100644
index 00000000..801fbab4
--- /dev/null
+++ b/3rdparty/libjpeg/src/jcmarker.c
@@ -0,0 +1,664 @@
+/*
+ * jcmarker.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1991-1998, Thomas G. Lane.
+ * Modified 2003-2010 by Guido Vollbeding.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2010, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains routines to write JPEG datastream markers.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jpegcomp.h"
+
+
+typedef enum {                  /* JPEG marker codes */
+  M_SOF0  = 0xc0,
+  M_SOF1  = 0xc1,
+  M_SOF2  = 0xc2,
+  M_SOF3  = 0xc3,
+
+  M_SOF5  = 0xc5,
+  M_SOF6  = 0xc6,
+  M_SOF7  = 0xc7,
+
+  M_JPG   = 0xc8,
+  M_SOF9  = 0xc9,
+  M_SOF10 = 0xca,
+  M_SOF11 = 0xcb,
+
+  M_SOF13 = 0xcd,
+  M_SOF14 = 0xce,
+  M_SOF15 = 0xcf,
+
+  M_DHT   = 0xc4,
+
+  M_DAC   = 0xcc,
+
+  M_RST0  = 0xd0,
+  M_RST1  = 0xd1,
+  M_RST2  = 0xd2,
+  M_RST3  = 0xd3,
+  M_RST4  = 0xd4,
+  M_RST5  = 0xd5,
+  M_RST6  = 0xd6,
+  M_RST7  = 0xd7,
+
+  M_SOI   = 0xd8,
+  M_EOI   = 0xd9,
+  M_SOS   = 0xda,
+  M_DQT   = 0xdb,
+  M_DNL   = 0xdc,
+  M_DRI   = 0xdd,
+  M_DHP   = 0xde,
+  M_EXP   = 0xdf,
+
+  M_APP0  = 0xe0,
+  M_APP1  = 0xe1,
+  M_APP2  = 0xe2,
+  M_APP3  = 0xe3,
+  M_APP4  = 0xe4,
+  M_APP5  = 0xe5,
+  M_APP6  = 0xe6,
+  M_APP7  = 0xe7,
+  M_APP8  = 0xe8,
+  M_APP9  = 0xe9,
+  M_APP10 = 0xea,
+  M_APP11 = 0xeb,
+  M_APP12 = 0xec,
+  M_APP13 = 0xed,
+  M_APP14 = 0xee,
+  M_APP15 = 0xef,
+
+  M_JPG0  = 0xf0,
+  M_JPG13 = 0xfd,
+  M_COM   = 0xfe,
+
+  M_TEM   = 0x01,
+
+  M_ERROR = 0x100
+} JPEG_MARKER;
+
+
+/* Private state */
+
+typedef struct {
+  struct jpeg_marker_writer pub; /* public fields */
+
+  unsigned int last_restart_interval; /* last DRI value emitted; 0 after SOI */
+} my_marker_writer;
+
+typedef my_marker_writer *my_marker_ptr;
+
+
+/*
+ * Basic output routines.
+ *
+ * Note that we do not support suspension while writing a marker.
+ * Therefore, an application using suspension must ensure that there is
+ * enough buffer space for the initial markers (typ. 600-700 bytes) before
+ * calling jpeg_start_compress, and enough space to write the trailing EOI
+ * (a few bytes) before calling jpeg_finish_compress.  Multipass compression
+ * modes are not supported at all with suspension, so those two are the only
+ * points where markers will be written.
+ */
+
+LOCAL(void)
+emit_byte(j_compress_ptr cinfo, int val)
+/* Emit a byte */
+{
+  struct jpeg_destination_mgr *dest = cinfo->dest;
+
+  *(dest->next_output_byte)++ = (JOCTET)val;
+  if (--dest->free_in_buffer == 0) {
+    if (!(*dest->empty_output_buffer) (cinfo))
+      ERREXIT(cinfo, JERR_CANT_SUSPEND);
+  }
+}
+
+
+LOCAL(void)
+emit_marker(j_compress_ptr cinfo, JPEG_MARKER mark)
+/* Emit a marker code */
+{
+  emit_byte(cinfo, 0xFF);
+  emit_byte(cinfo, (int)mark);
+}
+
+
+LOCAL(void)
+emit_2bytes(j_compress_ptr cinfo, int value)
+/* Emit a 2-byte integer; these are always MSB first in JPEG files */
+{
+  emit_byte(cinfo, (value >> 8) & 0xFF);
+  emit_byte(cinfo, value & 0xFF);
+}
+
+
+/*
+ * Routines to write specific marker types.
+ */
+
+LOCAL(int)
+emit_dqt(j_compress_ptr cinfo, int index)
+/* Emit a DQT marker */
+/* Returns the precision used (0 = 8bits, 1 = 16bits) for baseline checking */
+{
+  JQUANT_TBL *qtbl = cinfo->quant_tbl_ptrs[index];
+  int prec;
+  int i;
+
+  if (qtbl == NULL)
+    ERREXIT1(cinfo, JERR_NO_QUANT_TABLE, index);
+
+  prec = 0;
+  for (i = 0; i < DCTSIZE2; i++) {
+    if (qtbl->quantval[i] > 255)
+      prec = 1;
+  }
+
+  if (!qtbl->sent_table) {
+    emit_marker(cinfo, M_DQT);
+
+    emit_2bytes(cinfo, prec ? DCTSIZE2 * 2 + 1 + 2 : DCTSIZE2 + 1 + 2);
+
+    emit_byte(cinfo, index + (prec << 4));
+
+    for (i = 0; i < DCTSIZE2; i++) {
+      /* The table entries must be emitted in zigzag order. */
+      unsigned int qval = qtbl->quantval[jpeg_natural_order[i]];
+      if (prec)
+        emit_byte(cinfo, (int)(qval >> 8));
+      emit_byte(cinfo, (int)(qval & 0xFF));
+    }
+
+    qtbl->sent_table = TRUE;
+  }
+
+  return prec;
+}
+
+
+LOCAL(void)
+emit_dht(j_compress_ptr cinfo, int index, boolean is_ac)
+/* Emit a DHT marker */
+{
+  JHUFF_TBL *htbl;
+  int length, i;
+
+  if (is_ac) {
+    htbl = cinfo->ac_huff_tbl_ptrs[index];
+    index += 0x10;              /* output index has AC bit set */
+  } else {
+    htbl = cinfo->dc_huff_tbl_ptrs[index];
+  }
+
+  if (htbl == NULL)
+    ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, index);
+
+  if (!htbl->sent_table) {
+    emit_marker(cinfo, M_DHT);
+
+    length = 0;
+    for (i = 1; i <= 16; i++)
+      length += htbl->bits[i];
+
+    emit_2bytes(cinfo, length + 2 + 1 + 16);
+    emit_byte(cinfo, index);
+
+    for (i = 1; i <= 16; i++)
+      emit_byte(cinfo, htbl->bits[i]);
+
+    for (i = 0; i < length; i++)
+      emit_byte(cinfo, htbl->huffval[i]);
+
+    htbl->sent_table = TRUE;
+  }
+}
+
+
+LOCAL(void)
+emit_dac(j_compress_ptr cinfo)
+/* Emit a DAC marker */
+/* Since the useful info is so small, we want to emit all the tables in */
+/* one DAC marker.  Therefore this routine does its own scan of the table. */
+{
+#ifdef C_ARITH_CODING_SUPPORTED
+  char dc_in_use[NUM_ARITH_TBLS];
+  char ac_in_use[NUM_ARITH_TBLS];
+  int length, i;
+  jpeg_component_info *compptr;
+
+  for (i = 0; i < NUM_ARITH_TBLS; i++)
+    dc_in_use[i] = ac_in_use[i] = 0;
+
+  for (i = 0; i < cinfo->comps_in_scan; i++) {
+    compptr = cinfo->cur_comp_info[i];
+    /* DC needs no table for refinement scan */
+    if (cinfo->Ss == 0 && cinfo->Ah == 0)
+      dc_in_use[compptr->dc_tbl_no] = 1;
+    /* AC needs no table when not present */
+    if (cinfo->Se)
+      ac_in_use[compptr->ac_tbl_no] = 1;
+  }
+
+  length = 0;
+  for (i = 0; i < NUM_ARITH_TBLS; i++)
+    length += dc_in_use[i] + ac_in_use[i];
+
+  if (length) {
+    emit_marker(cinfo, M_DAC);
+
+    emit_2bytes(cinfo, length * 2 + 2);
+
+    for (i = 0; i < NUM_ARITH_TBLS; i++) {
+      if (dc_in_use[i]) {
+        emit_byte(cinfo, i);
+        emit_byte(cinfo, cinfo->arith_dc_L[i] + (cinfo->arith_dc_U[i] << 4));
+      }
+      if (ac_in_use[i]) {
+        emit_byte(cinfo, i + 0x10);
+        emit_byte(cinfo, cinfo->arith_ac_K[i]);
+      }
+    }
+  }
+#endif /* C_ARITH_CODING_SUPPORTED */
+}
+
+
+LOCAL(void)
+emit_dri(j_compress_ptr cinfo)
+/* Emit a DRI marker */
+{
+  emit_marker(cinfo, M_DRI);
+
+  emit_2bytes(cinfo, 4);        /* fixed length */
+
+  emit_2bytes(cinfo, (int)cinfo->restart_interval);
+}
+
+
+LOCAL(void)
+emit_sof(j_compress_ptr cinfo, JPEG_MARKER code)
+/* Emit a SOF marker */
+{
+  int ci;
+  jpeg_component_info *compptr;
+
+  emit_marker(cinfo, code);
+
+  emit_2bytes(cinfo, 3 * cinfo->num_components + 2 + 5 + 1); /* length */
+
+  /* Make sure image isn't bigger than SOF field can handle */
+  if ((long)cinfo->_jpeg_height > 65535L || (long)cinfo->_jpeg_width > 65535L)
+    ERREXIT1(cinfo, JERR_IMAGE_TOO_BIG, (unsigned int)65535);
+
+  emit_byte(cinfo, cinfo->data_precision);
+  emit_2bytes(cinfo, (int)cinfo->_jpeg_height);
+  emit_2bytes(cinfo, (int)cinfo->_jpeg_width);
+
+  emit_byte(cinfo, cinfo->num_components);
+
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    emit_byte(cinfo, compptr->component_id);
+    emit_byte(cinfo, (compptr->h_samp_factor << 4) + compptr->v_samp_factor);
+    emit_byte(cinfo, compptr->quant_tbl_no);
+  }
+}
+
+
+LOCAL(void)
+emit_sos(j_compress_ptr cinfo)
+/* Emit a SOS marker */
+{
+  int i, td, ta;
+  jpeg_component_info *compptr;
+
+  emit_marker(cinfo, M_SOS);
+
+  emit_2bytes(cinfo, 2 * cinfo->comps_in_scan + 2 + 1 + 3); /* length */
+
+  emit_byte(cinfo, cinfo->comps_in_scan);
+
+  for (i = 0; i < cinfo->comps_in_scan; i++) {
+    compptr = cinfo->cur_comp_info[i];
+    emit_byte(cinfo, compptr->component_id);
+
+    /* We emit 0 for unused field(s); this is recommended by the P&M text
+     * but does not seem to be specified in the standard.
+     */
+
+    /* DC needs no table for refinement scan */
+    td = cinfo->Ss == 0 && cinfo->Ah == 0 ? compptr->dc_tbl_no : 0;
+    /* AC needs no table when not present */
+    ta = cinfo->Se ? compptr->ac_tbl_no : 0;
+
+    emit_byte(cinfo, (td << 4) + ta);
+  }
+
+  emit_byte(cinfo, cinfo->Ss);
+  emit_byte(cinfo, cinfo->Se);
+  emit_byte(cinfo, (cinfo->Ah << 4) + cinfo->Al);
+}
+
+
+LOCAL(void)
+emit_jfif_app0(j_compress_ptr cinfo)
+/* Emit a JFIF-compliant APP0 marker */
+{
+  /*
+   * Length of APP0 block       (2 bytes)
+   * Block ID                   (4 bytes - ASCII "JFIF")
+   * Zero byte                  (1 byte to terminate the ID string)
+   * Version Major, Minor       (2 bytes - major first)
+   * Units                      (1 byte - 0x00 = none, 0x01 = inch, 0x02 = cm)
+   * Xdpu                       (2 bytes - dots per unit horizontal)
+   * Ydpu                       (2 bytes - dots per unit vertical)
+   * Thumbnail X size           (1 byte)
+   * Thumbnail Y size           (1 byte)
+   */
+
+  emit_marker(cinfo, M_APP0);
+
+  emit_2bytes(cinfo, 2 + 4 + 1 + 2 + 1 + 2 + 2 + 1 + 1); /* length */
+
+  emit_byte(cinfo, 0x4A);       /* Identifier: ASCII "JFIF" */
+  emit_byte(cinfo, 0x46);
+  emit_byte(cinfo, 0x49);
+  emit_byte(cinfo, 0x46);
+  emit_byte(cinfo, 0);
+  emit_byte(cinfo, cinfo->JFIF_major_version); /* Version fields */
+  emit_byte(cinfo, cinfo->JFIF_minor_version);
+  emit_byte(cinfo, cinfo->density_unit); /* Pixel size information */
+  emit_2bytes(cinfo, (int)cinfo->X_density);
+  emit_2bytes(cinfo, (int)cinfo->Y_density);
+  emit_byte(cinfo, 0);          /* No thumbnail image */
+  emit_byte(cinfo, 0);
+}
+
+
+LOCAL(void)
+emit_adobe_app14(j_compress_ptr cinfo)
+/* Emit an Adobe APP14 marker */
+{
+  /*
+   * Length of APP14 block      (2 bytes)
+   * Block ID                   (5 bytes - ASCII "Adobe")
+   * Version Number             (2 bytes - currently 100)
+   * Flags0                     (2 bytes - currently 0)
+   * Flags1                     (2 bytes - currently 0)
+   * Color transform            (1 byte)
+   *
+   * Although Adobe TN 5116 mentions Version = 101, all the Adobe files
+   * now in circulation seem to use Version = 100, so that's what we write.
+   *
+   * We write the color transform byte as 1 if the JPEG color space is
+   * YCbCr, 2 if it's YCCK, 0 otherwise.  Adobe's definition has to do with
+   * whether the encoder performed a transformation, which is pretty useless.
+   */
+
+  emit_marker(cinfo, M_APP14);
+
+  emit_2bytes(cinfo, 2 + 5 + 2 + 2 + 2 + 1); /* length */
+
+  emit_byte(cinfo, 0x41);       /* Identifier: ASCII "Adobe" */
+  emit_byte(cinfo, 0x64);
+  emit_byte(cinfo, 0x6F);
+  emit_byte(cinfo, 0x62);
+  emit_byte(cinfo, 0x65);
+  emit_2bytes(cinfo, 100);      /* Version */
+  emit_2bytes(cinfo, 0);        /* Flags0 */
+  emit_2bytes(cinfo, 0);        /* Flags1 */
+  switch (cinfo->jpeg_color_space) {
+  case JCS_YCbCr:
+    emit_byte(cinfo, 1);        /* Color transform = 1 */
+    break;
+  case JCS_YCCK:
+    emit_byte(cinfo, 2);        /* Color transform = 2 */
+    break;
+  default:
+    emit_byte(cinfo, 0);        /* Color transform = 0 */
+    break;
+  }
+}
+
+
+/*
+ * These routines allow writing an arbitrary marker with parameters.
+ * The only intended use is to emit COM or APPn markers after calling
+ * write_file_header and before calling write_frame_header.
+ * Other uses are not guaranteed to produce desirable results.
+ * Counting the parameter bytes properly is the caller's responsibility.
+ */
+
+METHODDEF(void)
+write_marker_header(j_compress_ptr cinfo, int marker, unsigned int datalen)
+/* Emit an arbitrary marker header */
+{
+  if (datalen > (unsigned int)65533)            /* safety check */
+    ERREXIT(cinfo, JERR_BAD_LENGTH);
+
+  emit_marker(cinfo, (JPEG_MARKER)marker);
+
+  emit_2bytes(cinfo, (int)(datalen + 2));       /* total length */
+}
+
+METHODDEF(void)
+write_marker_byte(j_compress_ptr cinfo, int val)
+/* Emit one byte of marker parameters following write_marker_header */
+{
+  emit_byte(cinfo, val);
+}
+
+
+/*
+ * Write datastream header.
+ * This consists of an SOI and optional APPn markers.
+ * We recommend use of the JFIF marker, but not the Adobe marker,
+ * when using YCbCr or grayscale data.  The JFIF marker should NOT
+ * be used for any other JPEG colorspace.  The Adobe marker is helpful
+ * to distinguish RGB, CMYK, and YCCK colorspaces.
+ * Note that an application can write additional header markers after
+ * jpeg_start_compress returns.
+ */
+
+METHODDEF(void)
+write_file_header(j_compress_ptr cinfo)
+{
+  my_marker_ptr marker = (my_marker_ptr)cinfo->marker;
+
+  emit_marker(cinfo, M_SOI);    /* first the SOI */
+
+  /* SOI is defined to reset restart interval to 0 */
+  marker->last_restart_interval = 0;
+
+  if (cinfo->write_JFIF_header) /* next an optional JFIF APP0 */
+    emit_jfif_app0(cinfo);
+  if (cinfo->write_Adobe_marker) /* next an optional Adobe APP14 */
+    emit_adobe_app14(cinfo);
+}
+
+
+/*
+ * Write frame header.
+ * This consists of DQT and SOFn markers.
+ * Note that we do not emit the SOF until we have emitted the DQT(s).
+ * This avoids compatibility problems with incorrect implementations that
+ * try to error-check the quant table numbers as soon as they see the SOF.
+ */
+
+METHODDEF(void)
+write_frame_header(j_compress_ptr cinfo)
+{
+  int ci, prec;
+  boolean is_baseline;
+  jpeg_component_info *compptr;
+
+  /* Emit DQT for each quantization table.
+   * Note that emit_dqt() suppresses any duplicate tables.
+   */
+  prec = 0;
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    prec += emit_dqt(cinfo, compptr->quant_tbl_no);
+  }
+  /* now prec is nonzero iff there are any 16-bit quant tables. */
+
+  /* Check for a non-baseline specification.
+   * Note we assume that Huffman table numbers won't be changed later.
+   */
+  if (cinfo->arith_code || cinfo->progressive_mode ||
+      cinfo->data_precision != 8) {
+    is_baseline = FALSE;
+  } else {
+    is_baseline = TRUE;
+    for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+         ci++, compptr++) {
+      if (compptr->dc_tbl_no > 1 || compptr->ac_tbl_no > 1)
+        is_baseline = FALSE;
+    }
+    if (prec && is_baseline) {
+      is_baseline = FALSE;
+      /* If it's baseline except for quantizer size, warn the user */
+      TRACEMS(cinfo, 0, JTRC_16BIT_TABLES);
+    }
+  }
+
+  /* Emit the proper SOF marker */
+  if (cinfo->arith_code) {
+    if (cinfo->progressive_mode)
+      emit_sof(cinfo, M_SOF10); /* SOF code for progressive arithmetic */
+    else
+      emit_sof(cinfo, M_SOF9);  /* SOF code for sequential arithmetic */
+  } else {
+    if (cinfo->progressive_mode)
+      emit_sof(cinfo, M_SOF2);  /* SOF code for progressive Huffman */
+    else if (is_baseline)
+      emit_sof(cinfo, M_SOF0);  /* SOF code for baseline implementation */
+    else
+      emit_sof(cinfo, M_SOF1);  /* SOF code for non-baseline Huffman file */
+  }
+}
+
+
+/*
+ * Write scan header.
+ * This consists of DHT or DAC markers, optional DRI, and SOS.
+ * Compressed data will be written following the SOS.
+ */
+
+METHODDEF(void)
+write_scan_header(j_compress_ptr cinfo)
+{
+  my_marker_ptr marker = (my_marker_ptr)cinfo->marker;
+  int i;
+  jpeg_component_info *compptr;
+
+  if (cinfo->arith_code) {
+    /* Emit arith conditioning info.  We may have some duplication
+     * if the file has multiple scans, but it's so small it's hardly
+     * worth worrying about.
+     */
+    emit_dac(cinfo);
+  } else {
+    /* Emit Huffman tables.
+     * Note that emit_dht() suppresses any duplicate tables.
+     */
+    for (i = 0; i < cinfo->comps_in_scan; i++) {
+      compptr = cinfo->cur_comp_info[i];
+      /* DC needs no table for refinement scan */
+      if (cinfo->Ss == 0 && cinfo->Ah == 0)
+        emit_dht(cinfo, compptr->dc_tbl_no, FALSE);
+      /* AC needs no table when not present */
+      if (cinfo->Se)
+        emit_dht(cinfo, compptr->ac_tbl_no, TRUE);
+    }
+  }
+
+  /* Emit DRI if required --- note that DRI value could change for each scan.
+   * We avoid wasting space with unnecessary DRIs, however.
+   */
+  if (cinfo->restart_interval != marker->last_restart_interval) {
+    emit_dri(cinfo);
+    marker->last_restart_interval = cinfo->restart_interval;
+  }
+
+  emit_sos(cinfo);
+}
+
+
+/*
+ * Write datastream trailer.
+ */
+
+METHODDEF(void)
+write_file_trailer(j_compress_ptr cinfo)
+{
+  emit_marker(cinfo, M_EOI);
+}
+
+
+/*
+ * Write an abbreviated table-specification datastream.
+ * This consists of SOI, DQT and DHT tables, and EOI.
+ * Any table that is defined and not marked sent_table = TRUE will be
+ * emitted.  Note that all tables will be marked sent_table = TRUE at exit.
+ */
+
+METHODDEF(void)
+write_tables_only(j_compress_ptr cinfo)
+{
+  int i;
+
+  emit_marker(cinfo, M_SOI);
+
+  for (i = 0; i < NUM_QUANT_TBLS; i++) {
+    if (cinfo->quant_tbl_ptrs[i] != NULL)
+      (void)emit_dqt(cinfo, i);
+  }
+
+  if (!cinfo->arith_code) {
+    for (i = 0; i < NUM_HUFF_TBLS; i++) {
+      if (cinfo->dc_huff_tbl_ptrs[i] != NULL)
+        emit_dht(cinfo, i, FALSE);
+      if (cinfo->ac_huff_tbl_ptrs[i] != NULL)
+        emit_dht(cinfo, i, TRUE);
+    }
+  }
+
+  emit_marker(cinfo, M_EOI);
+}
+
+
+/*
+ * Initialize the marker writer module.
+ */
+
+GLOBAL(void)
+jinit_marker_writer(j_compress_ptr cinfo)
+{
+  my_marker_ptr marker;
+
+  /* Create the subobject */
+  marker = (my_marker_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+                                sizeof(my_marker_writer));
+  cinfo->marker = (struct jpeg_marker_writer *)marker;
+  /* Initialize method pointers */
+  marker->pub.write_file_header = write_file_header;
+  marker->pub.write_frame_header = write_frame_header;
+  marker->pub.write_scan_header = write_scan_header;
+  marker->pub.write_file_trailer = write_file_trailer;
+  marker->pub.write_tables_only = write_tables_only;
+  marker->pub.write_marker_header = write_marker_header;
+  marker->pub.write_marker_byte = write_marker_byte;
+  /* Initialize private state */
+  marker->last_restart_interval = 0;
+}
diff --git a/3rdparty/libjpeg/src/jcmaster.c b/3rdparty/libjpeg/src/jcmaster.c
new file mode 100644
index 00000000..998dc40a
--- /dev/null
+++ b/3rdparty/libjpeg/src/jcmaster.c
@@ -0,0 +1,640 @@
+/*
+ * jcmaster.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1991-1997, Thomas G. Lane.
+ * Modified 2003-2010 by Guido Vollbeding.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2010, 2016, 2018, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains master control logic for the JPEG compressor.
+ * These routines are concerned with parameter validation, initial setup,
+ * and inter-pass control (determining the number of passes and the work
+ * to be done in each pass).
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jpegcomp.h"
+#include "jconfigint.h"
+
+
+/* Private state */
+
+typedef enum {
+  main_pass,                    /* input data, also do first output step */
+  huff_opt_pass,                /* Huffman code optimization pass */
+  output_pass                   /* data output pass */
+} c_pass_type;
+
+typedef struct {
+  struct jpeg_comp_master pub;  /* public fields */
+
+  c_pass_type pass_type;        /* the type of the current pass */
+
+  int pass_number;              /* # of passes completed */
+  int total_passes;             /* total # of passes needed */
+
+  int scan_number;              /* current index in scan_info[] */
+
+  /*
+   * This is here so we can add libjpeg-turbo version/build information to the
+   * global string table without introducing a new global symbol.  Adding this
+   * information to the global string table allows one to examine a binary
+   * object and determine which version of libjpeg-turbo it was built from or
+   * linked against.
+   */
+  const char *jpeg_version;
+
+} my_comp_master;
+
+typedef my_comp_master *my_master_ptr;
+
+
+/*
+ * Support routines that do various essential calculations.
+ */
+
+#if JPEG_LIB_VERSION >= 70
+/*
+ * Compute JPEG image dimensions and related values.
+ * NOTE: this is exported for possible use by application.
+ * Hence it mustn't do anything that can't be done twice.
+ */
+
+GLOBAL(void)
+jpeg_calc_jpeg_dimensions(j_compress_ptr cinfo)
+/* Do computations that are needed before master selection phase */
+{
+  /* Hardwire it to "no scaling" */
+  cinfo->jpeg_width = cinfo->image_width;
+  cinfo->jpeg_height = cinfo->image_height;
+  cinfo->min_DCT_h_scaled_size = DCTSIZE;
+  cinfo->min_DCT_v_scaled_size = DCTSIZE;
+}
+#endif
+
+
+LOCAL(void)
+initial_setup(j_compress_ptr cinfo, boolean transcode_only)
+/* Do computations that are needed before master selection phase */
+{
+  int ci;
+  jpeg_component_info *compptr;
+  long samplesperrow;
+  JDIMENSION jd_samplesperrow;
+
+#if JPEG_LIB_VERSION >= 70
+#if JPEG_LIB_VERSION >= 80
+  if (!transcode_only)
+#endif
+    jpeg_calc_jpeg_dimensions(cinfo);
+#endif
+
+  /* Sanity check on image dimensions */
+  if (cinfo->_jpeg_height <= 0 || cinfo->_jpeg_width <= 0 ||
+      cinfo->num_components <= 0 || cinfo->input_components <= 0)
+    ERREXIT(cinfo, JERR_EMPTY_IMAGE);
+
+  /* Make sure image isn't bigger than I can handle */
+  if ((long)cinfo->_jpeg_height > (long)JPEG_MAX_DIMENSION ||
+      (long)cinfo->_jpeg_width > (long)JPEG_MAX_DIMENSION)
+    ERREXIT1(cinfo, JERR_IMAGE_TOO_BIG, (unsigned int)JPEG_MAX_DIMENSION);
+
+  /* Width of an input scanline must be representable as JDIMENSION. */
+  samplesperrow = (long)cinfo->image_width * (long)cinfo->input_components;
+  jd_samplesperrow = (JDIMENSION)samplesperrow;
+  if ((long)jd_samplesperrow != samplesperrow)
+    ERREXIT(cinfo, JERR_WIDTH_OVERFLOW);
+
+  /* For now, precision must match compiled-in value... */
+  if (cinfo->data_precision != BITS_IN_JSAMPLE)
+    ERREXIT1(cinfo, JERR_BAD_PRECISION, cinfo->data_precision);
+
+  /* Check that number of components won't exceed internal array sizes */
+  if (cinfo->num_components > MAX_COMPONENTS)
+    ERREXIT2(cinfo, JERR_COMPONENT_COUNT, cinfo->num_components,
+             MAX_COMPONENTS);
+
+  /* Compute maximum sampling factors; check factor validity */
+  cinfo->max_h_samp_factor = 1;
+  cinfo->max_v_samp_factor = 1;
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    if (compptr->h_samp_factor <= 0 ||
+        compptr->h_samp_factor > MAX_SAMP_FACTOR ||
+        compptr->v_samp_factor <= 0 ||
+        compptr->v_samp_factor > MAX_SAMP_FACTOR)
+      ERREXIT(cinfo, JERR_BAD_SAMPLING);
+    cinfo->max_h_samp_factor = MAX(cinfo->max_h_samp_factor,
+                                   compptr->h_samp_factor);
+    cinfo->max_v_samp_factor = MAX(cinfo->max_v_samp_factor,
+                                   compptr->v_samp_factor);
+  }
+
+  /* Compute dimensions of components */
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    /* Fill in the correct component_index value; don't rely on application */
+    compptr->component_index = ci;
+    /* For compression, we never do DCT scaling. */
+#if JPEG_LIB_VERSION >= 70
+    compptr->DCT_h_scaled_size = compptr->DCT_v_scaled_size = DCTSIZE;
+#else
+    compptr->DCT_scaled_size = DCTSIZE;
+#endif
+    /* Size in DCT blocks */
+    compptr->width_in_blocks = (JDIMENSION)
+      jdiv_round_up((long)cinfo->_jpeg_width * (long)compptr->h_samp_factor,
+                    (long)(cinfo->max_h_samp_factor * DCTSIZE));
+    compptr->height_in_blocks = (JDIMENSION)
+      jdiv_round_up((long)cinfo->_jpeg_height * (long)compptr->v_samp_factor,
+                    (long)(cinfo->max_v_samp_factor * DCTSIZE));
+    /* Size in samples */
+    compptr->downsampled_width = (JDIMENSION)
+      jdiv_round_up((long)cinfo->_jpeg_width * (long)compptr->h_samp_factor,
+                    (long)cinfo->max_h_samp_factor);
+    compptr->downsampled_height = (JDIMENSION)
+      jdiv_round_up((long)cinfo->_jpeg_height * (long)compptr->v_samp_factor,
+                    (long)cinfo->max_v_samp_factor);
+    /* Mark component needed (this flag isn't actually used for compression) */
+    compptr->component_needed = TRUE;
+  }
+
+  /* Compute number of fully interleaved MCU rows (number of times that
+   * main controller will call coefficient controller).
+   */
+  cinfo->total_iMCU_rows = (JDIMENSION)
+    jdiv_round_up((long)cinfo->_jpeg_height,
+                  (long)(cinfo->max_v_samp_factor * DCTSIZE));
+}
+
+
+#ifdef C_MULTISCAN_FILES_SUPPORTED
+
+LOCAL(void)
+validate_script(j_compress_ptr cinfo)
+/* Verify that the scan script in cinfo->scan_info[] is valid; also
+ * determine whether it uses progressive JPEG, and set cinfo->progressive_mode.
+ */
+{
+  const jpeg_scan_info *scanptr;
+  int scanno, ncomps, ci, coefi, thisi;
+  int Ss, Se, Ah, Al;
+  boolean component_sent[MAX_COMPONENTS];
+#ifdef C_PROGRESSIVE_SUPPORTED
+  int *last_bitpos_ptr;
+  int last_bitpos[MAX_COMPONENTS][DCTSIZE2];
+  /* -1 until that coefficient has been seen; then last Al for it */
+#endif
+
+  if (cinfo->num_scans <= 0)
+    ERREXIT1(cinfo, JERR_BAD_SCAN_SCRIPT, 0);
+
+  /* For sequential JPEG, all scans must have Ss=0, Se=DCTSIZE2-1;
+   * for progressive JPEG, no scan can have this.
+   */
+  scanptr = cinfo->scan_info;
+  if (scanptr->Ss != 0 || scanptr->Se != DCTSIZE2 - 1) {
+#ifdef C_PROGRESSIVE_SUPPORTED
+    cinfo->progressive_mode = TRUE;
+    last_bitpos_ptr = &last_bitpos[0][0];
+    for (ci = 0; ci < cinfo->num_components; ci++)
+      for (coefi = 0; coefi < DCTSIZE2; coefi++)
+        *last_bitpos_ptr++ = -1;
+#else
+    ERREXIT(cinfo, JERR_NOT_COMPILED);
+#endif
+  } else {
+    cinfo->progressive_mode = FALSE;
+    for (ci = 0; ci < cinfo->num_components; ci++)
+      component_sent[ci] = FALSE;
+  }
+
+  for (scanno = 1; scanno <= cinfo->num_scans; scanptr++, scanno++) {
+    /* Validate component indexes */
+    ncomps = scanptr->comps_in_scan;
+    if (ncomps <= 0 || ncomps > MAX_COMPS_IN_SCAN)
+      ERREXIT2(cinfo, JERR_COMPONENT_COUNT, ncomps, MAX_COMPS_IN_SCAN);
+    for (ci = 0; ci < ncomps; ci++) {
+      thisi = scanptr->component_index[ci];
+      if (thisi < 0 || thisi >= cinfo->num_components)
+        ERREXIT1(cinfo, JERR_BAD_SCAN_SCRIPT, scanno);
+      /* Components must appear in SOF order within each scan */
+      if (ci > 0 && thisi <= scanptr->component_index[ci - 1])
+        ERREXIT1(cinfo, JERR_BAD_SCAN_SCRIPT, scanno);
+    }
+    /* Validate progression parameters */
+    Ss = scanptr->Ss;
+    Se = scanptr->Se;
+    Ah = scanptr->Ah;
+    Al = scanptr->Al;
+    if (cinfo->progressive_mode) {
+#ifdef C_PROGRESSIVE_SUPPORTED
+      /* Rec. ITU-T T.81 | ISO/IEC 10918-1 simply gives the ranges 0..13 for Ah
+       * and Al, but that seems wrong: the upper bound ought to depend on data
+       * precision.  Perhaps they really meant 0..N+1 for N-bit precision.
+       * Here we allow 0..10 for 8-bit data; Al larger than 10 results in
+       * out-of-range reconstructed DC values during the first DC scan,
+       * which might cause problems for some decoders.
+       */
+#if BITS_IN_JSAMPLE == 8
+#define MAX_AH_AL  10
+#else
+#define MAX_AH_AL  13
+#endif
+      if (Ss < 0 || Ss >= DCTSIZE2 || Se < Ss || Se >= DCTSIZE2 ||
+          Ah < 0 || Ah > MAX_AH_AL || Al < 0 || Al > MAX_AH_AL)
+        ERREXIT1(cinfo, JERR_BAD_PROG_SCRIPT, scanno);
+      if (Ss == 0) {
+        if (Se != 0)            /* DC and AC together not OK */
+          ERREXIT1(cinfo, JERR_BAD_PROG_SCRIPT, scanno);
+      } else {
+        if (ncomps != 1)        /* AC scans must be for only one component */
+          ERREXIT1(cinfo, JERR_BAD_PROG_SCRIPT, scanno);
+      }
+      for (ci = 0; ci < ncomps; ci++) {
+        last_bitpos_ptr = &last_bitpos[scanptr->component_index[ci]][0];
+        if (Ss != 0 && last_bitpos_ptr[0] < 0) /* AC without prior DC scan */
+          ERREXIT1(cinfo, JERR_BAD_PROG_SCRIPT, scanno);
+        for (coefi = Ss; coefi <= Se; coefi++) {
+          if (last_bitpos_ptr[coefi] < 0) {
+            /* first scan of this coefficient */
+            if (Ah != 0)
+              ERREXIT1(cinfo, JERR_BAD_PROG_SCRIPT, scanno);
+          } else {
+            /* not first scan */
+            if (Ah != last_bitpos_ptr[coefi] || Al != Ah - 1)
+              ERREXIT1(cinfo, JERR_BAD_PROG_SCRIPT, scanno);
+          }
+          last_bitpos_ptr[coefi] = Al;
+        }
+      }
+#endif
+    } else {
+      /* For sequential JPEG, all progression parameters must be these: */
+      if (Ss != 0 || Se != DCTSIZE2 - 1 || Ah != 0 || Al != 0)
+        ERREXIT1(cinfo, JERR_BAD_PROG_SCRIPT, scanno);
+      /* Make sure components are not sent twice */
+      for (ci = 0; ci < ncomps; ci++) {
+        thisi = scanptr->component_index[ci];
+        if (component_sent[thisi])
+          ERREXIT1(cinfo, JERR_BAD_SCAN_SCRIPT, scanno);
+        component_sent[thisi] = TRUE;
+      }
+    }
+  }
+
+  /* Now verify that everything got sent. */
+  if (cinfo->progressive_mode) {
+#ifdef C_PROGRESSIVE_SUPPORTED
+    /* For progressive mode, we only check that at least some DC data
+     * got sent for each component; the spec does not require that all bits
+     * of all coefficients be transmitted.  Would it be wiser to enforce
+     * transmission of all coefficient bits??
+     */
+    for (ci = 0; ci < cinfo->num_components; ci++) {
+      if (last_bitpos[ci][0] < 0)
+        ERREXIT(cinfo, JERR_MISSING_DATA);
+    }
+#endif
+  } else {
+    for (ci = 0; ci < cinfo->num_components; ci++) {
+      if (!component_sent[ci])
+        ERREXIT(cinfo, JERR_MISSING_DATA);
+    }
+  }
+}
+
+#endif /* C_MULTISCAN_FILES_SUPPORTED */
+
+
+LOCAL(void)
+select_scan_parameters(j_compress_ptr cinfo)
+/* Set up the scan parameters for the current scan */
+{
+  int ci;
+
+#ifdef C_MULTISCAN_FILES_SUPPORTED
+  if (cinfo->scan_info != NULL) {
+    /* Prepare for current scan --- the script is already validated */
+    my_master_ptr master = (my_master_ptr)cinfo->master;
+    const jpeg_scan_info *scanptr = cinfo->scan_info + master->scan_number;
+
+    cinfo->comps_in_scan = scanptr->comps_in_scan;
+    for (ci = 0; ci < scanptr->comps_in_scan; ci++) {
+      cinfo->cur_comp_info[ci] =
+        &cinfo->comp_info[scanptr->component_index[ci]];
+    }
+    cinfo->Ss = scanptr->Ss;
+    cinfo->Se = scanptr->Se;
+    cinfo->Ah = scanptr->Ah;
+    cinfo->Al = scanptr->Al;
+  } else
+#endif
+  {
+    /* Prepare for single sequential-JPEG scan containing all components */
+    if (cinfo->num_components > MAX_COMPS_IN_SCAN)
+      ERREXIT2(cinfo, JERR_COMPONENT_COUNT, cinfo->num_components,
+               MAX_COMPS_IN_SCAN);
+    cinfo->comps_in_scan = cinfo->num_components;
+    for (ci = 0; ci < cinfo->num_components; ci++) {
+      cinfo->cur_comp_info[ci] = &cinfo->comp_info[ci];
+    }
+    cinfo->Ss = 0;
+    cinfo->Se = DCTSIZE2 - 1;
+    cinfo->Ah = 0;
+    cinfo->Al = 0;
+  }
+}
+
+
+LOCAL(void)
+per_scan_setup(j_compress_ptr cinfo)
+/* Do computations that are needed before processing a JPEG scan */
+/* cinfo->comps_in_scan and cinfo->cur_comp_info[] are already set */
+{
+  int ci, mcublks, tmp;
+  jpeg_component_info *compptr;
+
+  if (cinfo->comps_in_scan == 1) {
+
+    /* Noninterleaved (single-component) scan */
+    compptr = cinfo->cur_comp_info[0];
+
+    /* Overall image size in MCUs */
+    cinfo->MCUs_per_row = compptr->width_in_blocks;
+    cinfo->MCU_rows_in_scan = compptr->height_in_blocks;
+
+    /* For noninterleaved scan, always one block per MCU */
+    compptr->MCU_width = 1;
+    compptr->MCU_height = 1;
+    compptr->MCU_blocks = 1;
+    compptr->MCU_sample_width = DCTSIZE;
+    compptr->last_col_width = 1;
+    /* For noninterleaved scans, it is convenient to define last_row_height
+     * as the number of block rows present in the last iMCU row.
+     */
+    tmp = (int)(compptr->height_in_blocks % compptr->v_samp_factor);
+    if (tmp == 0) tmp = compptr->v_samp_factor;
+    compptr->last_row_height = tmp;
+
+    /* Prepare array describing MCU composition */
+    cinfo->blocks_in_MCU = 1;
+    cinfo->MCU_membership[0] = 0;
+
+  } else {
+
+    /* Interleaved (multi-component) scan */
+    if (cinfo->comps_in_scan <= 0 || cinfo->comps_in_scan > MAX_COMPS_IN_SCAN)
+      ERREXIT2(cinfo, JERR_COMPONENT_COUNT, cinfo->comps_in_scan,
+               MAX_COMPS_IN_SCAN);
+
+    /* Overall image size in MCUs */
+    cinfo->MCUs_per_row = (JDIMENSION)
+      jdiv_round_up((long)cinfo->_jpeg_width,
+                    (long)(cinfo->max_h_samp_factor * DCTSIZE));
+    cinfo->MCU_rows_in_scan = (JDIMENSION)
+      jdiv_round_up((long)cinfo->_jpeg_height,
+                    (long)(cinfo->max_v_samp_factor * DCTSIZE));
+
+    cinfo->blocks_in_MCU = 0;
+
+    for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+      compptr = cinfo->cur_comp_info[ci];
+      /* Sampling factors give # of blocks of component in each MCU */
+      compptr->MCU_width = compptr->h_samp_factor;
+      compptr->MCU_height = compptr->v_samp_factor;
+      compptr->MCU_blocks = compptr->MCU_width * compptr->MCU_height;
+      compptr->MCU_sample_width = compptr->MCU_width * DCTSIZE;
+      /* Figure number of non-dummy blocks in last MCU column & row */
+      tmp = (int)(compptr->width_in_blocks % compptr->MCU_width);
+      if (tmp == 0) tmp = compptr->MCU_width;
+      compptr->last_col_width = tmp;
+      tmp = (int)(compptr->height_in_blocks % compptr->MCU_height);
+      if (tmp == 0) tmp = compptr->MCU_height;
+      compptr->last_row_height = tmp;
+      /* Prepare array describing MCU composition */
+      mcublks = compptr->MCU_blocks;
+      if (cinfo->blocks_in_MCU + mcublks > C_MAX_BLOCKS_IN_MCU)
+        ERREXIT(cinfo, JERR_BAD_MCU_SIZE);
+      while (mcublks-- > 0) {
+        cinfo->MCU_membership[cinfo->blocks_in_MCU++] = ci;
+      }
+    }
+
+  }
+
+  /* Convert restart specified in rows to actual MCU count. */
+  /* Note that count must fit in 16 bits, so we provide limiting. */
+  if (cinfo->restart_in_rows > 0) {
+    long nominal = (long)cinfo->restart_in_rows * (long)cinfo->MCUs_per_row;
+    cinfo->restart_interval = (unsigned int)MIN(nominal, 65535L);
+  }
+}
+
+
+/*
+ * Per-pass setup.
+ * This is called at the beginning of each pass.  We determine which modules
+ * will be active during this pass and give them appropriate start_pass calls.
+ * We also set is_last_pass to indicate whether any more passes will be
+ * required.
+ */
+
+METHODDEF(void)
+prepare_for_pass(j_compress_ptr cinfo)
+{
+  my_master_ptr master = (my_master_ptr)cinfo->master;
+
+  switch (master->pass_type) {
+  case main_pass:
+    /* Initial pass: will collect input data, and do either Huffman
+     * optimization or data output for the first scan.
+     */
+    select_scan_parameters(cinfo);
+    per_scan_setup(cinfo);
+    if (!cinfo->raw_data_in) {
+      (*cinfo->cconvert->start_pass) (cinfo);
+      (*cinfo->downsample->start_pass) (cinfo);
+      (*cinfo->prep->start_pass) (cinfo, JBUF_PASS_THRU);
+    }
+    (*cinfo->fdct->start_pass) (cinfo);
+    (*cinfo->entropy->start_pass) (cinfo, cinfo->optimize_coding);
+    (*cinfo->coef->start_pass) (cinfo,
+                                (master->total_passes > 1 ?
+                                 JBUF_SAVE_AND_PASS : JBUF_PASS_THRU));
+    (*cinfo->main->start_pass) (cinfo, JBUF_PASS_THRU);
+    if (cinfo->optimize_coding) {
+      /* No immediate data output; postpone writing frame/scan headers */
+      master->pub.call_pass_startup = FALSE;
+    } else {
+      /* Will write frame/scan headers at first jpeg_write_scanlines call */
+      master->pub.call_pass_startup = TRUE;
+    }
+    break;
+#ifdef ENTROPY_OPT_SUPPORTED
+  case huff_opt_pass:
+    /* Do Huffman optimization for a scan after the first one. */
+    select_scan_parameters(cinfo);
+    per_scan_setup(cinfo);
+    if (cinfo->Ss != 0 || cinfo->Ah == 0 || cinfo->arith_code) {
+      (*cinfo->entropy->start_pass) (cinfo, TRUE);
+      (*cinfo->coef->start_pass) (cinfo, JBUF_CRANK_DEST);
+      master->pub.call_pass_startup = FALSE;
+      break;
+    }
+    /* Special case: Huffman DC refinement scans need no Huffman table
+     * and therefore we can skip the optimization pass for them.
+     */
+    master->pass_type = output_pass;
+    master->pass_number++;
+#endif
+    /*FALLTHROUGH*/
+  case output_pass:
+    /* Do a data-output pass. */
+    /* We need not repeat per-scan setup if prior optimization pass did it. */
+    if (!cinfo->optimize_coding) {
+      select_scan_parameters(cinfo);
+      per_scan_setup(cinfo);
+    }
+    (*cinfo->entropy->start_pass) (cinfo, FALSE);
+    (*cinfo->coef->start_pass) (cinfo, JBUF_CRANK_DEST);
+    /* We emit frame/scan headers now */
+    if (master->scan_number == 0)
+      (*cinfo->marker->write_frame_header) (cinfo);
+    (*cinfo->marker->write_scan_header) (cinfo);
+    master->pub.call_pass_startup = FALSE;
+    break;
+  default:
+    ERREXIT(cinfo, JERR_NOT_COMPILED);
+  }
+
+  master->pub.is_last_pass = (master->pass_number == master->total_passes - 1);
+
+  /* Set up progress monitor's pass info if present */
+  if (cinfo->progress != NULL) {
+    cinfo->progress->completed_passes = master->pass_number;
+    cinfo->progress->total_passes = master->total_passes;
+  }
+}
+
+
+/*
+ * Special start-of-pass hook.
+ * This is called by jpeg_write_scanlines if call_pass_startup is TRUE.
+ * In single-pass processing, we need this hook because we don't want to
+ * write frame/scan headers during jpeg_start_compress; we want to let the
+ * application write COM markers etc. between jpeg_start_compress and the
+ * jpeg_write_scanlines loop.
+ * In multi-pass processing, this routine is not used.
+ */
+
+METHODDEF(void)
+pass_startup(j_compress_ptr cinfo)
+{
+  cinfo->master->call_pass_startup = FALSE; /* reset flag so call only once */
+
+  (*cinfo->marker->write_frame_header) (cinfo);
+  (*cinfo->marker->write_scan_header) (cinfo);
+}
+
+
+/*
+ * Finish up at end of pass.
+ */
+
+METHODDEF(void)
+finish_pass_master(j_compress_ptr cinfo)
+{
+  my_master_ptr master = (my_master_ptr)cinfo->master;
+
+  /* The entropy coder always needs an end-of-pass call,
+   * either to analyze statistics or to flush its output buffer.
+   */
+  (*cinfo->entropy->finish_pass) (cinfo);
+
+  /* Update state for next pass */
+  switch (master->pass_type) {
+  case main_pass:
+    /* next pass is either output of scan 0 (after optimization)
+     * or output of scan 1 (if no optimization).
+     */
+    master->pass_type = output_pass;
+    if (!cinfo->optimize_coding)
+      master->scan_number++;
+    break;
+  case huff_opt_pass:
+    /* next pass is always output of current scan */
+    master->pass_type = output_pass;
+    break;
+  case output_pass:
+    /* next pass is either optimization or output of next scan */
+    if (cinfo->optimize_coding)
+      master->pass_type = huff_opt_pass;
+    master->scan_number++;
+    break;
+  }
+
+  master->pass_number++;
+}
+
+
+/*
+ * Initialize master compression control.
+ */
+
+GLOBAL(void)
+jinit_c_master_control(j_compress_ptr cinfo, boolean transcode_only)
+{
+  my_master_ptr master;
+
+  master = (my_master_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+                                sizeof(my_comp_master));
+  cinfo->master = (struct jpeg_comp_master *)master;
+  master->pub.prepare_for_pass = prepare_for_pass;
+  master->pub.pass_startup = pass_startup;
+  master->pub.finish_pass = finish_pass_master;
+  master->pub.is_last_pass = FALSE;
+
+  /* Validate parameters, determine derived values */
+  initial_setup(cinfo, transcode_only);
+
+  if (cinfo->scan_info != NULL) {
+#ifdef C_MULTISCAN_FILES_SUPPORTED
+    validate_script(cinfo);
+#else
+    ERREXIT(cinfo, JERR_NOT_COMPILED);
+#endif
+  } else {
+    cinfo->progressive_mode = FALSE;
+    cinfo->num_scans = 1;
+  }
+
+  if (cinfo->progressive_mode && !cinfo->arith_code)  /*  TEMPORARY HACK ??? */
+    cinfo->optimize_coding = TRUE; /* assume default tables no good for progressive mode */
+
+  /* Initialize my private state */
+  if (transcode_only) {
+    /* no main pass in transcoding */
+    if (cinfo->optimize_coding)
+      master->pass_type = huff_opt_pass;
+    else
+      master->pass_type = output_pass;
+  } else {
+    /* for normal compression, first pass is always this type: */
+    master->pass_type = main_pass;
+  }
+  master->scan_number = 0;
+  master->pass_number = 0;
+  if (cinfo->optimize_coding)
+    master->total_passes = cinfo->num_scans * 2;
+  else
+    master->total_passes = cinfo->num_scans;
+
+  master->jpeg_version = PACKAGE_NAME " version " VERSION " (build " BUILD ")";
+}
diff --git a/3rdparty/libjpeg/src/jcomapi.c b/3rdparty/libjpeg/src/jcomapi.c
new file mode 100644
index 00000000..efbb8357
--- /dev/null
+++ b/3rdparty/libjpeg/src/jcomapi.c
@@ -0,0 +1,109 @@
+/*
+ * jcomapi.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1994-1997, Thomas G. Lane.
+ * It was modified by The libjpeg-turbo Project to include only code relevant
+ * to libjpeg-turbo.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains application interface routines that are used for both
+ * compression and decompression.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/*
+ * Abort processing of a JPEG compression or decompression operation,
+ * but don't destroy the object itself.
+ *
+ * For this, we merely clean up all the nonpermanent memory pools.
+ * Note that temp files (virtual arrays) are not allowed to belong to
+ * the permanent pool, so we will be able to close all temp files here.
+ * Closing a data source or destination, if necessary, is the application's
+ * responsibility.
+ */
+
+GLOBAL(void)
+jpeg_abort(j_common_ptr cinfo)
+{
+  int pool;
+
+  /* Do nothing if called on a not-initialized or destroyed JPEG object. */
+  if (cinfo->mem == NULL)
+    return;
+
+  /* Releasing pools in reverse order might help avoid fragmentation
+   * with some (brain-damaged) malloc libraries.
+   */
+  for (pool = JPOOL_NUMPOOLS - 1; pool > JPOOL_PERMANENT; pool--) {
+    (*cinfo->mem->free_pool) (cinfo, pool);
+  }
+
+  /* Reset overall state for possible reuse of object */
+  if (cinfo->is_decompressor) {
+    cinfo->global_state = DSTATE_START;
+    /* Try to keep application from accessing now-deleted marker list.
+     * A bit kludgy to do it here, but this is the most central place.
+     */
+    ((j_decompress_ptr)cinfo)->marker_list = NULL;
+  } else {
+    cinfo->global_state = CSTATE_START;
+  }
+}
+
+
+/*
+ * Destruction of a JPEG object.
+ *
+ * Everything gets deallocated except the master jpeg_compress_struct itself
+ * and the error manager struct.  Both of these are supplied by the application
+ * and must be freed, if necessary, by the application.  (Often they are on
+ * the stack and so don't need to be freed anyway.)
+ * Closing a data source or destination, if necessary, is the application's
+ * responsibility.
+ */
+
+GLOBAL(void)
+jpeg_destroy(j_common_ptr cinfo)
+{
+  /* We need only tell the memory manager to release everything. */
+  /* NB: mem pointer is NULL if memory mgr failed to initialize. */
+  if (cinfo->mem != NULL)
+    (*cinfo->mem->self_destruct) (cinfo);
+  cinfo->mem = NULL;            /* be safe if jpeg_destroy is called twice */
+  cinfo->global_state = 0;      /* mark it destroyed */
+}
+
+
+/*
+ * Convenience routines for allocating quantization and Huffman tables.
+ * (Would jutils.c be a more reasonable place to put these?)
+ */
+
+GLOBAL(JQUANT_TBL *)
+jpeg_alloc_quant_table(j_common_ptr cinfo)
+{
+  JQUANT_TBL *tbl;
+
+  tbl = (JQUANT_TBL *)
+    (*cinfo->mem->alloc_small) (cinfo, JPOOL_PERMANENT, sizeof(JQUANT_TBL));
+  tbl->sent_table = FALSE;      /* make sure this is false in any new table */
+  return tbl;
+}
+
+
+GLOBAL(JHUFF_TBL *)
+jpeg_alloc_huff_table(j_common_ptr cinfo)
+{
+  JHUFF_TBL *tbl;
+
+  tbl = (JHUFF_TBL *)
+    (*cinfo->mem->alloc_small) (cinfo, JPOOL_PERMANENT, sizeof(JHUFF_TBL));
+  tbl->sent_table = FALSE;      /* make sure this is false in any new table */
+  return tbl;
+}
diff --git a/3rdparty/libjpeg/src/jconfig.h.in b/3rdparty/libjpeg/src/jconfig.h.in
new file mode 100644
index 00000000..d4284d97
--- /dev/null
+++ b/3rdparty/libjpeg/src/jconfig.h.in
@@ -0,0 +1,68 @@
+/* Version ID for the JPEG library.
+ * Might be useful for tests like "#if JPEG_LIB_VERSION >= 60".
+ */
+#define JPEG_LIB_VERSION  @JPEG_LIB_VERSION@
+
+/* libjpeg-turbo version */
+#define LIBJPEG_TURBO_VERSION  @VERSION@
+
+/* libjpeg-turbo version in integer form */
+#define LIBJPEG_TURBO_VERSION_NUMBER  @LIBJPEG_TURBO_VERSION_NUMBER@
+
+/* Support arithmetic encoding */
+#cmakedefine C_ARITH_CODING_SUPPORTED 1
+
+/* Support arithmetic decoding */
+#cmakedefine D_ARITH_CODING_SUPPORTED 1
+
+/* Support in-memory source/destination managers */
+#cmakedefine MEM_SRCDST_SUPPORTED 1
+
+/* Use accelerated SIMD routines. */
+#cmakedefine WITH_SIMD 1
+
+/*
+ * Define BITS_IN_JSAMPLE as either
+ *   8   for 8-bit sample values (the usual setting)
+ *   12  for 12-bit sample values
+ * Only 8 and 12 are legal data precisions for lossy JPEG according to the
+ * JPEG standard, and the IJG code does not support anything else!
+ * We do not support run-time selection of data precision, sorry.
+ */
+
+#define BITS_IN_JSAMPLE  @BITS_IN_JSAMPLE@      /* use 8 or 12 */
+
+/* Define to 1 if you have the <locale.h> header file. */
+#cmakedefine HAVE_LOCALE_H 1
+
+/* Define to 1 if you have the <stddef.h> header file. */
+#cmakedefine HAVE_STDDEF_H 1
+
+/* Define to 1 if you have the <stdlib.h> header file. */
+#cmakedefine HAVE_STDLIB_H 1
+
+/* Define if you need to include <sys/types.h> to get size_t. */
+#cmakedefine NEED_SYS_TYPES_H 1
+
+/* Define if you have BSD-like bzero and bcopy in <strings.h> rather than
+   memset/memcpy in <string.h>. */
+#cmakedefine NEED_BSD_STRINGS 1
+
+/* Define to 1 if the system has the type `unsigned char'. */
+#cmakedefine HAVE_UNSIGNED_CHAR 1
+
+/* Define to 1 if the system has the type `unsigned short'. */
+#cmakedefine HAVE_UNSIGNED_SHORT 1
+
+/* Compiler does not support pointers to undefined structures. */
+#cmakedefine INCOMPLETE_TYPES_BROKEN 1
+
+/* Define if your (broken) compiler shifts signed values as if they were
+   unsigned. */
+#cmakedefine RIGHT_SHIFT_IS_UNSIGNED 1
+
+/* Define to empty if `const' does not conform to ANSI C. */
+/* #undef const */
+
+/* Define to `unsigned int' if <sys/types.h> does not define. */
+/* #undef size_t */
diff --git a/3rdparty/libjpeg/src/jconfig.txt b/3rdparty/libjpeg/src/jconfig.txt
new file mode 100644
index 00000000..21f35c13
--- /dev/null
+++ b/3rdparty/libjpeg/src/jconfig.txt
@@ -0,0 +1,136 @@
+/*
+ * jconfig.txt
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1991-1994, Thomas G. Lane.
+ * It was modified by The libjpeg-turbo Project to include only code relevant
+ * to libjpeg-turbo.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file documents the configuration options that are required to
+ * customize the JPEG software for a particular system.
+ *
+ * The actual configuration options for a particular installation are stored
+ * in jconfig.h.  On many machines, jconfig.h can be generated automatically
+ * or copied from one of the "canned" jconfig files that we supply.  But if
+ * you need to generate a jconfig.h file by hand, this file tells you how.
+ *
+ * DO NOT EDIT THIS FILE --- IT WON'T ACCOMPLISH ANYTHING.
+ * EDIT A COPY NAMED JCONFIG.H.
+ */
+
+
+/*
+ * These symbols indicate the properties of your machine or compiler.
+ * #define the symbol if yes, #undef it if no.
+ */
+
+/* Does your compiler support the declaration "unsigned char" ?
+ * How about "unsigned short" ?
+ */
+#define HAVE_UNSIGNED_CHAR
+#define HAVE_UNSIGNED_SHORT
+
+/* Define "void" as "char" if your compiler doesn't know about type void.
+ * NOTE: be sure to define void such that "void *" represents the most general
+ * pointer type, e.g., that returned by malloc().
+ */
+/* #define void char */
+
+/* Define "const" as empty if your compiler doesn't know the "const" keyword.
+ */
+/* #define const */
+
+/* Define this if your system has an ANSI-conforming <stddef.h> file.
+ */
+#define HAVE_STDDEF_H
+
+/* Define this if your system has an ANSI-conforming <stdlib.h> file.
+ */
+#define HAVE_STDLIB_H
+
+/* Define this if your system does not have an ANSI/SysV <string.h>,
+ * but does have a BSD-style <strings.h>.
+ */
+#undef NEED_BSD_STRINGS
+
+/* Define this if your system does not provide typedef size_t in any of the
+ * ANSI-standard places (stddef.h, stdlib.h, or stdio.h), but places it in
+ * <sys/types.h> instead.
+ */
+#undef NEED_SYS_TYPES_H
+
+/* Although a real ANSI C compiler can deal perfectly well with pointers to
+ * unspecified structures (see "incomplete types" in the spec), a few pre-ANSI
+ * and pseudo-ANSI compilers get confused.  To keep one of these bozos happy,
+ * define INCOMPLETE_TYPES_BROKEN.  This is not recommended unless you
+ * actually get "missing structure definition" warnings or errors while
+ * compiling the JPEG code.
+ */
+#undef INCOMPLETE_TYPES_BROKEN
+
+/* Define "boolean" as unsigned char, not int, on Windows systems.
+ */
+#ifdef _WIN32
+#ifndef __RPCNDR_H__            /* don't conflict if rpcndr.h already read */
+typedef unsigned char boolean;
+#endif
+#define HAVE_BOOLEAN            /* prevent jmorecfg.h from redefining it */
+#endif
+
+
+/*
+ * The following options affect code selection within the JPEG library,
+ * but they don't need to be visible to applications using the library.
+ * To minimize application namespace pollution, the symbols won't be
+ * defined unless JPEG_INTERNALS has been defined.
+ */
+
+#ifdef JPEG_INTERNALS
+
+/* Define this if your compiler implements ">>" on signed values as a logical
+ * (unsigned) shift; leave it undefined if ">>" is a signed (arithmetic) shift,
+ * which is the normal and rational definition.
+ */
+#undef RIGHT_SHIFT_IS_UNSIGNED
+
+
+#endif /* JPEG_INTERNALS */
+
+
+/*
+ * The remaining options do not affect the JPEG library proper,
+ * but only the sample applications cjpeg/djpeg (see cjpeg.c, djpeg.c).
+ * Other applications can ignore these.
+ */
+
+#ifdef JPEG_CJPEG_DJPEG
+
+/* These defines indicate which image (non-JPEG) file formats are allowed. */
+
+#define BMP_SUPPORTED           /* BMP image file format */
+#define GIF_SUPPORTED           /* GIF image file format */
+#define PPM_SUPPORTED           /* PBMPLUS PPM/PGM image file format */
+#define TARGA_SUPPORTED         /* Targa image file format */
+
+/* Define this if you want to name both input and output files on the command
+ * line, rather than using stdout and optionally stdin.  You MUST do this if
+ * your system can't cope with binary I/O to stdin/stdout.  See comments at
+ * head of cjpeg.c or djpeg.c.
+ */
+#undef TWO_FILE_COMMANDLINE
+
+/* By default, we open image files with fopen(..., "rb") or fopen(..., "wb").
+ * This is necessary on systems that distinguish text files from binary files,
+ * and is harmless on most systems that don't.  If you have one of the rare
+ * systems that complains about the "b" spec, define this symbol.
+ */
+#undef DONT_USE_B_MODE
+
+/* Define this if you want percent-done progress reports from cjpeg/djpeg.
+ */
+#undef PROGRESS_REPORT
+
+
+#endif /* JPEG_CJPEG_DJPEG */
diff --git a/3rdparty/libjpeg/src/jconfigint.h.in b/3rdparty/libjpeg/src/jconfigint.h.in
new file mode 100644
index 00000000..68cbc2a5
--- /dev/null
+++ b/3rdparty/libjpeg/src/jconfigint.h.in
@@ -0,0 +1,34 @@
+/* libjpeg-turbo build number */
+#define BUILD  "@BUILD@"
+
+/* Compiler's inline keyword */
+#undef inline
+
+/* How to obtain function inlining. */
+#define INLINE  @INLINE@
+
+/* How to obtain thread-local storage */
+#define THREAD_LOCAL  @THREAD_LOCAL@
+
+/* Define to the full name of this package. */
+#define PACKAGE_NAME  "@CMAKE_PROJECT_NAME@"
+
+/* Version number of package */
+#define VERSION  "@VERSION@"
+
+/* The size of `size_t', as computed by sizeof. */
+#define SIZEOF_SIZE_T  @SIZE_T@
+
+/* Define if your compiler has __builtin_ctzl() and sizeof(unsigned long) == sizeof(size_t). */
+#cmakedefine HAVE_BUILTIN_CTZL
+
+/* Define to 1 if you have the <intrin.h> header file. */
+#cmakedefine HAVE_INTRIN_H
+
+#if defined(_MSC_VER) && defined(HAVE_INTRIN_H)
+#if (SIZEOF_SIZE_T == 8)
+#define HAVE_BITSCANFORWARD64
+#elif (SIZEOF_SIZE_T == 4)
+#define HAVE_BITSCANFORWARD
+#endif
+#endif
diff --git a/3rdparty/libjpeg/src/jcparam.c b/3rdparty/libjpeg/src/jcparam.c
new file mode 100644
index 00000000..5bc7174d
--- /dev/null
+++ b/3rdparty/libjpeg/src/jcparam.c
@@ -0,0 +1,541 @@
+/*
+ * jcparam.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1991-1998, Thomas G. Lane.
+ * Modified 2003-2008 by Guido Vollbeding.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2009-2011, 2018, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains optional default-setting code for the JPEG compressor.
+ * Applications do not have to use this file, but those that don't use it
+ * must know a lot more about the innards of the JPEG code.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jstdhuff.c"
+
+
+/*
+ * Quantization table setup routines
+ */
+
+GLOBAL(void)
+jpeg_add_quant_table(j_compress_ptr cinfo, int which_tbl,
+                     const unsigned int *basic_table, int scale_factor,
+                     boolean force_baseline)
+/* Define a quantization table equal to the basic_table times
+ * a scale factor (given as a percentage).
+ * If force_baseline is TRUE, the computed quantization table entries
+ * are limited to 1..255 for JPEG baseline compatibility.
+ */
+{
+  JQUANT_TBL **qtblptr;
+  int i;
+  long temp;
+
+  /* Safety check to ensure start_compress not called yet. */
+  if (cinfo->global_state != CSTATE_START)
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+
+  if (which_tbl < 0 || which_tbl >= NUM_QUANT_TBLS)
+    ERREXIT1(cinfo, JERR_DQT_INDEX, which_tbl);
+
+  qtblptr = &cinfo->quant_tbl_ptrs[which_tbl];
+
+  if (*qtblptr == NULL)
+    *qtblptr = jpeg_alloc_quant_table((j_common_ptr)cinfo);
+
+  for (i = 0; i < DCTSIZE2; i++) {
+    temp = ((long)basic_table[i] * scale_factor + 50L) / 100L;
+    /* limit the values to the valid range */
+    if (temp <= 0L) temp = 1L;
+    if (temp > 32767L) temp = 32767L; /* max quantizer needed for 12 bits */
+    if (force_baseline && temp > 255L)
+      temp = 255L;              /* limit to baseline range if requested */
+    (*qtblptr)->quantval[i] = (UINT16)temp;
+  }
+
+  /* Initialize sent_table FALSE so table will be written to JPEG file. */
+  (*qtblptr)->sent_table = FALSE;
+}
+
+
+/* These are the sample quantization tables given in Annex K (Clause K.1) of
+ * Recommendation ITU-T T.81 (1992) | ISO/IEC 10918-1:1994.
+ * The spec says that the values given produce "good" quality, and
+ * when divided by 2, "very good" quality.
+ */
+static const unsigned int std_luminance_quant_tbl[DCTSIZE2] = {
+  16,  11,  10,  16,  24,  40,  51,  61,
+  12,  12,  14,  19,  26,  58,  60,  55,
+  14,  13,  16,  24,  40,  57,  69,  56,
+  14,  17,  22,  29,  51,  87,  80,  62,
+  18,  22,  37,  56,  68, 109, 103,  77,
+  24,  35,  55,  64,  81, 104, 113,  92,
+  49,  64,  78,  87, 103, 121, 120, 101,
+  72,  92,  95,  98, 112, 100, 103,  99
+};
+static const unsigned int std_chrominance_quant_tbl[DCTSIZE2] = {
+  17,  18,  24,  47,  99,  99,  99,  99,
+  18,  21,  26,  66,  99,  99,  99,  99,
+  24,  26,  56,  99,  99,  99,  99,  99,
+  47,  66,  99,  99,  99,  99,  99,  99,
+  99,  99,  99,  99,  99,  99,  99,  99,
+  99,  99,  99,  99,  99,  99,  99,  99,
+  99,  99,  99,  99,  99,  99,  99,  99,
+  99,  99,  99,  99,  99,  99,  99,  99
+};
+
+
+#if JPEG_LIB_VERSION >= 70
+GLOBAL(void)
+jpeg_default_qtables(j_compress_ptr cinfo, boolean force_baseline)
+/* Set or change the 'quality' (quantization) setting, using default tables
+ * and straight percentage-scaling quality scales.
+ * This entry point allows different scalings for luminance and chrominance.
+ */
+{
+  /* Set up two quantization tables using the specified scaling */
+  jpeg_add_quant_table(cinfo, 0, std_luminance_quant_tbl,
+                       cinfo->q_scale_factor[0], force_baseline);
+  jpeg_add_quant_table(cinfo, 1, std_chrominance_quant_tbl,
+                       cinfo->q_scale_factor[1], force_baseline);
+}
+#endif
+
+
+GLOBAL(void)
+jpeg_set_linear_quality(j_compress_ptr cinfo, int scale_factor,
+                        boolean force_baseline)
+/* Set or change the 'quality' (quantization) setting, using default tables
+ * and a straight percentage-scaling quality scale.  In most cases it's better
+ * to use jpeg_set_quality (below); this entry point is provided for
+ * applications that insist on a linear percentage scaling.
+ */
+{
+  /* Set up two quantization tables using the specified scaling */
+  jpeg_add_quant_table(cinfo, 0, std_luminance_quant_tbl,
+                       scale_factor, force_baseline);
+  jpeg_add_quant_table(cinfo, 1, std_chrominance_quant_tbl,
+                       scale_factor, force_baseline);
+}
+
+
+GLOBAL(int)
+jpeg_quality_scaling(int quality)
+/* Convert a user-specified quality rating to a percentage scaling factor
+ * for an underlying quantization table, using our recommended scaling curve.
+ * The input 'quality' factor should be 0 (terrible) to 100 (very good).
+ */
+{
+  /* Safety limit on quality factor.  Convert 0 to 1 to avoid zero divide. */
+  if (quality <= 0) quality = 1;
+  if (quality > 100) quality = 100;
+
+  /* The basic table is used as-is (scaling 100) for a quality of 50.
+   * Qualities 50..100 are converted to scaling percentage 200 - 2*Q;
+   * note that at Q=100 the scaling is 0, which will cause jpeg_add_quant_table
+   * to make all the table entries 1 (hence, minimum quantization loss).
+   * Qualities 1..50 are converted to scaling percentage 5000/Q.
+   */
+  if (quality < 50)
+    quality = 5000 / quality;
+  else
+    quality = 200 - quality * 2;
+
+  return quality;
+}
+
+
+GLOBAL(void)
+jpeg_set_quality(j_compress_ptr cinfo, int quality, boolean force_baseline)
+/* Set or change the 'quality' (quantization) setting, using default tables.
+ * This is the standard quality-adjusting entry point for typical user
+ * interfaces; only those who want detailed control over quantization tables
+ * would use the preceding three routines directly.
+ */
+{
+  /* Convert user 0-100 rating to percentage scaling */
+  quality = jpeg_quality_scaling(quality);
+
+  /* Set up standard quality tables */
+  jpeg_set_linear_quality(cinfo, quality, force_baseline);
+}
+
+
+/*
+ * Default parameter setup for compression.
+ *
+ * Applications that don't choose to use this routine must do their
+ * own setup of all these parameters.  Alternately, you can call this
+ * to establish defaults and then alter parameters selectively.  This
+ * is the recommended approach since, if we add any new parameters,
+ * your code will still work (they'll be set to reasonable defaults).
+ */
+
+GLOBAL(void)
+jpeg_set_defaults(j_compress_ptr cinfo)
+{
+  int i;
+
+  /* Safety check to ensure start_compress not called yet. */
+  if (cinfo->global_state != CSTATE_START)
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+
+  /* Allocate comp_info array large enough for maximum component count.
+   * Array is made permanent in case application wants to compress
+   * multiple images at same param settings.
+   */
+  if (cinfo->comp_info == NULL)
+    cinfo->comp_info = (jpeg_component_info *)
+      (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_PERMANENT,
+                                  MAX_COMPONENTS * sizeof(jpeg_component_info));
+
+  /* Initialize everything not dependent on the color space */
+
+#if JPEG_LIB_VERSION >= 70
+  cinfo->scale_num = 1;         /* 1:1 scaling */
+  cinfo->scale_denom = 1;
+#endif
+  cinfo->data_precision = BITS_IN_JSAMPLE;
+  /* Set up two quantization tables using default quality of 75 */
+  jpeg_set_quality(cinfo, 75, TRUE);
+  /* Set up two Huffman tables */
+  std_huff_tables((j_common_ptr)cinfo);
+
+  /* Initialize default arithmetic coding conditioning */
+  for (i = 0; i < NUM_ARITH_TBLS; i++) {
+    cinfo->arith_dc_L[i] = 0;
+    cinfo->arith_dc_U[i] = 1;
+    cinfo->arith_ac_K[i] = 5;
+  }
+
+  /* Default is no multiple-scan output */
+  cinfo->scan_info = NULL;
+  cinfo->num_scans = 0;
+
+  /* Expect normal source image, not raw downsampled data */
+  cinfo->raw_data_in = FALSE;
+
+  /* Use Huffman coding, not arithmetic coding, by default */
+  cinfo->arith_code = FALSE;
+
+  /* By default, don't do extra passes to optimize entropy coding */
+  cinfo->optimize_coding = FALSE;
+  /* The standard Huffman tables are only valid for 8-bit data precision.
+   * If the precision is higher, force optimization on so that usable
+   * tables will be computed.  This test can be removed if default tables
+   * are supplied that are valid for the desired precision.
+   */
+  if (cinfo->data_precision > 8)
+    cinfo->optimize_coding = TRUE;
+
+  /* By default, use the simpler non-cosited sampling alignment */
+  cinfo->CCIR601_sampling = FALSE;
+
+#if JPEG_LIB_VERSION >= 70
+  /* By default, apply fancy downsampling */
+  cinfo->do_fancy_downsampling = TRUE;
+#endif
+
+  /* No input smoothing */
+  cinfo->smoothing_factor = 0;
+
+  /* DCT algorithm preference */
+  cinfo->dct_method = JDCT_DEFAULT;
+
+  /* No restart markers */
+  cinfo->restart_interval = 0;
+  cinfo->restart_in_rows = 0;
+
+  /* Fill in default JFIF marker parameters.  Note that whether the marker
+   * will actually be written is determined by jpeg_set_colorspace.
+   *
+   * By default, the library emits JFIF version code 1.01.
+   * An application that wants to emit JFIF 1.02 extension markers should set
+   * JFIF_minor_version to 2.  We could probably get away with just defaulting
+   * to 1.02, but there may still be some decoders in use that will complain
+   * about that; saying 1.01 should minimize compatibility problems.
+   */
+  cinfo->JFIF_major_version = 1; /* Default JFIF version = 1.01 */
+  cinfo->JFIF_minor_version = 1;
+  cinfo->density_unit = 0;      /* Pixel size is unknown by default */
+  cinfo->X_density = 1;         /* Pixel aspect ratio is square by default */
+  cinfo->Y_density = 1;
+
+  /* Choose JPEG colorspace based on input space, set defaults accordingly */
+
+  jpeg_default_colorspace(cinfo);
+}
+
+
+/*
+ * Select an appropriate JPEG colorspace for in_color_space.
+ */
+
+GLOBAL(void)
+jpeg_default_colorspace(j_compress_ptr cinfo)
+{
+  switch (cinfo->in_color_space) {
+  case JCS_GRAYSCALE:
+    jpeg_set_colorspace(cinfo, JCS_GRAYSCALE);
+    break;
+  case JCS_RGB:
+  case JCS_EXT_RGB:
+  case JCS_EXT_RGBX:
+  case JCS_EXT_BGR:
+  case JCS_EXT_BGRX:
+  case JCS_EXT_XBGR:
+  case JCS_EXT_XRGB:
+  case JCS_EXT_RGBA:
+  case JCS_EXT_BGRA:
+  case JCS_EXT_ABGR:
+  case JCS_EXT_ARGB:
+    jpeg_set_colorspace(cinfo, JCS_YCbCr);
+    break;
+  case JCS_YCbCr:
+    jpeg_set_colorspace(cinfo, JCS_YCbCr);
+    break;
+  case JCS_CMYK:
+    jpeg_set_colorspace(cinfo, JCS_CMYK); /* By default, no translation */
+    break;
+  case JCS_YCCK:
+    jpeg_set_colorspace(cinfo, JCS_YCCK);
+    break;
+  case JCS_UNKNOWN:
+    jpeg_set_colorspace(cinfo, JCS_UNKNOWN);
+    break;
+  default:
+    ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE);
+  }
+}
+
+
+/*
+ * Set the JPEG colorspace, and choose colorspace-dependent default values.
+ */
+
+GLOBAL(void)
+jpeg_set_colorspace(j_compress_ptr cinfo, J_COLOR_SPACE colorspace)
+{
+  jpeg_component_info *compptr;
+  int ci;
+
+#define SET_COMP(index, id, hsamp, vsamp, quant, dctbl, actbl) \
+  (compptr = &cinfo->comp_info[index], \
+   compptr->component_id = (id), \
+   compptr->h_samp_factor = (hsamp), \
+   compptr->v_samp_factor = (vsamp), \
+   compptr->quant_tbl_no = (quant), \
+   compptr->dc_tbl_no = (dctbl), \
+   compptr->ac_tbl_no = (actbl) )
+
+  /* Safety check to ensure start_compress not called yet. */
+  if (cinfo->global_state != CSTATE_START)
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+
+  /* For all colorspaces, we use Q and Huff tables 0 for luminance components,
+   * tables 1 for chrominance components.
+   */
+
+  cinfo->jpeg_color_space = colorspace;
+
+  cinfo->write_JFIF_header = FALSE; /* No marker for non-JFIF colorspaces */
+  cinfo->write_Adobe_marker = FALSE; /* write no Adobe marker by default */
+
+  switch (colorspace) {
+  case JCS_GRAYSCALE:
+    cinfo->write_JFIF_header = TRUE; /* Write a JFIF marker */
+    cinfo->num_components = 1;
+    /* JFIF specifies component ID 1 */
+    SET_COMP(0, 1, 1, 1, 0, 0, 0);
+    break;
+  case JCS_RGB:
+    cinfo->write_Adobe_marker = TRUE; /* write Adobe marker to flag RGB */
+    cinfo->num_components = 3;
+    SET_COMP(0, 0x52 /* 'R' */, 1, 1, 0, 0, 0);
+    SET_COMP(1, 0x47 /* 'G' */, 1, 1, 0, 0, 0);
+    SET_COMP(2, 0x42 /* 'B' */, 1, 1, 0, 0, 0);
+    break;
+  case JCS_YCbCr:
+    cinfo->write_JFIF_header = TRUE; /* Write a JFIF marker */
+    cinfo->num_components = 3;
+    /* JFIF specifies component IDs 1,2,3 */
+    /* We default to 2x2 subsamples of chrominance */
+    SET_COMP(0, 1, 2, 2, 0, 0, 0);
+    SET_COMP(1, 2, 1, 1, 1, 1, 1);
+    SET_COMP(2, 3, 1, 1, 1, 1, 1);
+    break;
+  case JCS_CMYK:
+    cinfo->write_Adobe_marker = TRUE; /* write Adobe marker to flag CMYK */
+    cinfo->num_components = 4;
+    SET_COMP(0, 0x43 /* 'C' */, 1, 1, 0, 0, 0);
+    SET_COMP(1, 0x4D /* 'M' */, 1, 1, 0, 0, 0);
+    SET_COMP(2, 0x59 /* 'Y' */, 1, 1, 0, 0, 0);
+    SET_COMP(3, 0x4B /* 'K' */, 1, 1, 0, 0, 0);
+    break;
+  case JCS_YCCK:
+    cinfo->write_Adobe_marker = TRUE; /* write Adobe marker to flag YCCK */
+    cinfo->num_components = 4;
+    SET_COMP(0, 1, 2, 2, 0, 0, 0);
+    SET_COMP(1, 2, 1, 1, 1, 1, 1);
+    SET_COMP(2, 3, 1, 1, 1, 1, 1);
+    SET_COMP(3, 4, 2, 2, 0, 0, 0);
+    break;
+  case JCS_UNKNOWN:
+    cinfo->num_components = cinfo->input_components;
+    if (cinfo->num_components < 1 || cinfo->num_components > MAX_COMPONENTS)
+      ERREXIT2(cinfo, JERR_COMPONENT_COUNT, cinfo->num_components,
+               MAX_COMPONENTS);
+    for (ci = 0; ci < cinfo->num_components; ci++) {
+      SET_COMP(ci, ci, 1, 1, 0, 0, 0);
+    }
+    break;
+  default:
+    ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
+  }
+}
+
+
+#ifdef C_PROGRESSIVE_SUPPORTED
+
+LOCAL(jpeg_scan_info *)
+fill_a_scan(jpeg_scan_info *scanptr, int ci, int Ss, int Se, int Ah, int Al)
+/* Support routine: generate one scan for specified component */
+{
+  scanptr->comps_in_scan = 1;
+  scanptr->component_index[0] = ci;
+  scanptr->Ss = Ss;
+  scanptr->Se = Se;
+  scanptr->Ah = Ah;
+  scanptr->Al = Al;
+  scanptr++;
+  return scanptr;
+}
+
+LOCAL(jpeg_scan_info *)
+fill_scans(jpeg_scan_info *scanptr, int ncomps, int Ss, int Se, int Ah, int Al)
+/* Support routine: generate one scan for each component */
+{
+  int ci;
+
+  for (ci = 0; ci < ncomps; ci++) {
+    scanptr->comps_in_scan = 1;
+    scanptr->component_index[0] = ci;
+    scanptr->Ss = Ss;
+    scanptr->Se = Se;
+    scanptr->Ah = Ah;
+    scanptr->Al = Al;
+    scanptr++;
+  }
+  return scanptr;
+}
+
+LOCAL(jpeg_scan_info *)
+fill_dc_scans(jpeg_scan_info *scanptr, int ncomps, int Ah, int Al)
+/* Support routine: generate interleaved DC scan if possible, else N scans */
+{
+  int ci;
+
+  if (ncomps <= MAX_COMPS_IN_SCAN) {
+    /* Single interleaved DC scan */
+    scanptr->comps_in_scan = ncomps;
+    for (ci = 0; ci < ncomps; ci++)
+      scanptr->component_index[ci] = ci;
+    scanptr->Ss = scanptr->Se = 0;
+    scanptr->Ah = Ah;
+    scanptr->Al = Al;
+    scanptr++;
+  } else {
+    /* Noninterleaved DC scan for each component */
+    scanptr = fill_scans(scanptr, ncomps, 0, 0, Ah, Al);
+  }
+  return scanptr;
+}
+
+
+/*
+ * Create a recommended progressive-JPEG script.
+ * cinfo->num_components and cinfo->jpeg_color_space must be correct.
+ */
+
+GLOBAL(void)
+jpeg_simple_progression(j_compress_ptr cinfo)
+{
+  int ncomps = cinfo->num_components;
+  int nscans;
+  jpeg_scan_info *scanptr;
+
+  /* Safety check to ensure start_compress not called yet. */
+  if (cinfo->global_state != CSTATE_START)
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+
+  /* Figure space needed for script.  Calculation must match code below! */
+  if (ncomps == 3 && cinfo->jpeg_color_space == JCS_YCbCr) {
+    /* Custom script for YCbCr color images. */
+    nscans = 10;
+  } else {
+    /* All-purpose script for other color spaces. */
+    if (ncomps > MAX_COMPS_IN_SCAN)
+      nscans = 6 * ncomps;      /* 2 DC + 4 AC scans per component */
+    else
+      nscans = 2 + 4 * ncomps;  /* 2 DC scans; 4 AC scans per component */
+  }
+
+  /* Allocate space for script.
+   * We need to put it in the permanent pool in case the application performs
+   * multiple compressions without changing the settings.  To avoid a memory
+   * leak if jpeg_simple_progression is called repeatedly for the same JPEG
+   * object, we try to re-use previously allocated space, and we allocate
+   * enough space to handle YCbCr even if initially asked for grayscale.
+   */
+  if (cinfo->script_space == NULL || cinfo->script_space_size < nscans) {
+    cinfo->script_space_size = MAX(nscans, 10);
+    cinfo->script_space = (jpeg_scan_info *)
+      (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_PERMANENT,
+                        cinfo->script_space_size * sizeof(jpeg_scan_info));
+  }
+  scanptr = cinfo->script_space;
+  cinfo->scan_info = scanptr;
+  cinfo->num_scans = nscans;
+
+  if (ncomps == 3 && cinfo->jpeg_color_space == JCS_YCbCr) {
+    /* Custom script for YCbCr color images. */
+    /* Initial DC scan */
+    scanptr = fill_dc_scans(scanptr, ncomps, 0, 1);
+    /* Initial AC scan: get some luma data out in a hurry */
+    scanptr = fill_a_scan(scanptr, 0, 1, 5, 0, 2);
+    /* Chroma data is too small to be worth expending many scans on */
+    scanptr = fill_a_scan(scanptr, 2, 1, 63, 0, 1);
+    scanptr = fill_a_scan(scanptr, 1, 1, 63, 0, 1);
+    /* Complete spectral selection for luma AC */
+    scanptr = fill_a_scan(scanptr, 0, 6, 63, 0, 2);
+    /* Refine next bit of luma AC */
+    scanptr = fill_a_scan(scanptr, 0, 1, 63, 2, 1);
+    /* Finish DC successive approximation */
+    scanptr = fill_dc_scans(scanptr, ncomps, 1, 0);
+    /* Finish AC successive approximation */
+    scanptr = fill_a_scan(scanptr, 2, 1, 63, 1, 0);
+    scanptr = fill_a_scan(scanptr, 1, 1, 63, 1, 0);
+    /* Luma bottom bit comes last since it's usually largest scan */
+    scanptr = fill_a_scan(scanptr, 0, 1, 63, 1, 0);
+  } else {
+    /* All-purpose script for other color spaces. */
+    /* Successive approximation first pass */
+    scanptr = fill_dc_scans(scanptr, ncomps, 0, 1);
+    scanptr = fill_scans(scanptr, ncomps, 1, 5, 0, 2);
+    scanptr = fill_scans(scanptr, ncomps, 6, 63, 0, 2);
+    /* Successive approximation second pass */
+    scanptr = fill_scans(scanptr, ncomps, 1, 63, 2, 1);
+    /* Successive approximation final pass */
+    scanptr = fill_dc_scans(scanptr, ncomps, 1, 0);
+    scanptr = fill_scans(scanptr, ncomps, 1, 63, 1, 0);
+  }
+}
+
+#endif /* C_PROGRESSIVE_SUPPORTED */
diff --git a/3rdparty/libjpeg/src/jcphuff.c b/3rdparty/libjpeg/src/jcphuff.c
new file mode 100644
index 00000000..a8b94bed
--- /dev/null
+++ b/3rdparty/libjpeg/src/jcphuff.c
@@ -0,0 +1,1105 @@
+/*
+ * jcphuff.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1995-1997, Thomas G. Lane.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2011, 2015, 2018, D. R. Commander.
+ * Copyright (C) 2016, 2018, Matthieu Darbois.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains Huffman entropy encoding routines for progressive JPEG.
+ *
+ * We do not support output suspension in this module, since the library
+ * currently does not allow multiple-scan files to be written with output
+ * suspension.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jsimd.h"
+#include "jconfigint.h"
+#include <limits.h>
+
+#ifdef HAVE_INTRIN_H
+#include <intrin.h>
+#ifdef _MSC_VER
+#ifdef HAVE_BITSCANFORWARD64
+#pragma intrinsic(_BitScanForward64)
+#endif
+#ifdef HAVE_BITSCANFORWARD
+#pragma intrinsic(_BitScanForward)
+#endif
+#endif
+#endif
+
+#ifdef C_PROGRESSIVE_SUPPORTED
+
+/*
+ * NOTE: If USE_CLZ_INTRINSIC is defined, then clz/bsr instructions will be
+ * used for bit counting rather than the lookup table.  This will reduce the
+ * memory footprint by 64k, which is important for some mobile applications
+ * that create many isolated instances of libjpeg-turbo (web browsers, for
+ * instance.)  This may improve performance on some mobile platforms as well.
+ * This feature is enabled by default only on Arm processors, because some x86
+ * chips have a slow implementation of bsr, and the use of clz/bsr cannot be
+ * shown to have a significant performance impact even on the x86 chips that
+ * have a fast implementation of it.  When building for Armv6, you can
+ * explicitly disable the use of clz/bsr by adding -mthumb to the compiler
+ * flags (this defines __thumb__).
+ */
+
+/* NOTE: Both GCC and Clang define __GNUC__ */
+#if defined(__GNUC__) && (defined(__arm__) || defined(__aarch64__))
+#if !defined(__thumb__) || defined(__thumb2__)
+#define USE_CLZ_INTRINSIC
+#endif
+#endif
+
+#ifdef USE_CLZ_INTRINSIC
+#define JPEG_NBITS_NONZERO(x)  (32 - __builtin_clz(x))
+#define JPEG_NBITS(x)          (x ? JPEG_NBITS_NONZERO(x) : 0)
+#else
+#include "jpeg_nbits_table.h"
+#define JPEG_NBITS(x)          (jpeg_nbits_table[x])
+#define JPEG_NBITS_NONZERO(x)  JPEG_NBITS(x)
+#endif
+
+
+/* Expanded entropy encoder object for progressive Huffman encoding. */
+
+typedef struct {
+  struct jpeg_entropy_encoder pub; /* public fields */
+
+  /* Pointer to routine to prepare data for encode_mcu_AC_first() */
+  void (*AC_first_prepare) (const JCOEF *block,
+                            const int *jpeg_natural_order_start, int Sl,
+                            int Al, JCOEF *values, size_t *zerobits);
+  /* Pointer to routine to prepare data for encode_mcu_AC_refine() */
+  int (*AC_refine_prepare) (const JCOEF *block,
+                            const int *jpeg_natural_order_start, int Sl,
+                            int Al, JCOEF *absvalues, size_t *bits);
+
+  /* Mode flag: TRUE for optimization, FALSE for actual data output */
+  boolean gather_statistics;
+
+  /* Bit-level coding status.
+   * next_output_byte/free_in_buffer are local copies of cinfo->dest fields.
+   */
+  JOCTET *next_output_byte;     /* => next byte to write in buffer */
+  size_t free_in_buffer;        /* # of byte spaces remaining in buffer */
+  size_t put_buffer;            /* current bit-accumulation buffer */
+  int put_bits;                 /* # of bits now in it */
+  j_compress_ptr cinfo;         /* link to cinfo (needed for dump_buffer) */
+
+  /* Coding status for DC components */
+  int last_dc_val[MAX_COMPS_IN_SCAN]; /* last DC coef for each component */
+
+  /* Coding status for AC components */
+  int ac_tbl_no;                /* the table number of the single component */
+  unsigned int EOBRUN;          /* run length of EOBs */
+  unsigned int BE;              /* # of buffered correction bits before MCU */
+  char *bit_buffer;             /* buffer for correction bits (1 per char) */
+  /* packing correction bits tightly would save some space but cost time... */
+
+  unsigned int restarts_to_go;  /* MCUs left in this restart interval */
+  int next_restart_num;         /* next restart number to write (0-7) */
+
+  /* Pointers to derived tables (these workspaces have image lifespan).
+   * Since any one scan codes only DC or only AC, we only need one set
+   * of tables, not one for DC and one for AC.
+   */
+  c_derived_tbl *derived_tbls[NUM_HUFF_TBLS];
+
+  /* Statistics tables for optimization; again, one set is enough */
+  long *count_ptrs[NUM_HUFF_TBLS];
+} phuff_entropy_encoder;
+
+typedef phuff_entropy_encoder *phuff_entropy_ptr;
+
+/* MAX_CORR_BITS is the number of bits the AC refinement correction-bit
+ * buffer can hold.  Larger sizes may slightly improve compression, but
+ * 1000 is already well into the realm of overkill.
+ * The minimum safe size is 64 bits.
+ */
+
+#define MAX_CORR_BITS  1000     /* Max # of correction bits I can buffer */
+
+/* IRIGHT_SHIFT is like RIGHT_SHIFT, but works on int rather than JLONG.
+ * We assume that int right shift is unsigned if JLONG right shift is,
+ * which should be safe.
+ */
+
+#ifdef RIGHT_SHIFT_IS_UNSIGNED
+#define ISHIFT_TEMPS    int ishift_temp;
+#define IRIGHT_SHIFT(x, shft) \
+  ((ishift_temp = (x)) < 0 ? \
+   (ishift_temp >> (shft)) | ((~0) << (16 - (shft))) : \
+   (ishift_temp >> (shft)))
+#else
+#define ISHIFT_TEMPS
+#define IRIGHT_SHIFT(x, shft)   ((x) >> (shft))
+#endif
+
+#define PAD(v, p)  ((v + (p) - 1) & (~((p) - 1)))
+
+/* Forward declarations */
+METHODDEF(boolean) encode_mcu_DC_first(j_compress_ptr cinfo,
+                                       JBLOCKROW *MCU_data);
+METHODDEF(void) encode_mcu_AC_first_prepare
+  (const JCOEF *block, const int *jpeg_natural_order_start, int Sl, int Al,
+   JCOEF *values, size_t *zerobits);
+METHODDEF(boolean) encode_mcu_AC_first(j_compress_ptr cinfo,
+                                       JBLOCKROW *MCU_data);
+METHODDEF(boolean) encode_mcu_DC_refine(j_compress_ptr cinfo,
+                                        JBLOCKROW *MCU_data);
+METHODDEF(int) encode_mcu_AC_refine_prepare
+  (const JCOEF *block, const int *jpeg_natural_order_start, int Sl, int Al,
+   JCOEF *absvalues, size_t *bits);
+METHODDEF(boolean) encode_mcu_AC_refine(j_compress_ptr cinfo,
+                                        JBLOCKROW *MCU_data);
+METHODDEF(void) finish_pass_phuff(j_compress_ptr cinfo);
+METHODDEF(void) finish_pass_gather_phuff(j_compress_ptr cinfo);
+
+
+/* Count bit loop zeroes */
+INLINE
+METHODDEF(int)
+count_zeroes(size_t *x)
+{
+  int result;
+#if defined(HAVE_BUILTIN_CTZL)
+  result = __builtin_ctzl(*x);
+  *x >>= result;
+#elif defined(HAVE_BITSCANFORWARD64)
+  _BitScanForward64(&result, *x);
+  *x >>= result;
+#elif defined(HAVE_BITSCANFORWARD)
+  _BitScanForward(&result, *x);
+  *x >>= result;
+#else
+  result = 0;
+  while ((*x & 1) == 0) {
+    ++result;
+    *x >>= 1;
+  }
+#endif
+  return result;
+}
+
+
+/*
+ * Initialize for a Huffman-compressed scan using progressive JPEG.
+ */
+
+METHODDEF(void)
+start_pass_phuff(j_compress_ptr cinfo, boolean gather_statistics)
+{
+  phuff_entropy_ptr entropy = (phuff_entropy_ptr)cinfo->entropy;
+  boolean is_DC_band;
+  int ci, tbl;
+  jpeg_component_info *compptr;
+
+  entropy->cinfo = cinfo;
+  entropy->gather_statistics = gather_statistics;
+
+  is_DC_band = (cinfo->Ss == 0);
+
+  /* We assume jcmaster.c already validated the scan parameters. */
+
+  /* Select execution routines */
+  if (cinfo->Ah == 0) {
+    if (is_DC_band)
+      entropy->pub.encode_mcu = encode_mcu_DC_first;
+    else
+      entropy->pub.encode_mcu = encode_mcu_AC_first;
+    if (jsimd_can_encode_mcu_AC_first_prepare())
+      entropy->AC_first_prepare = jsimd_encode_mcu_AC_first_prepare;
+    else
+      entropy->AC_first_prepare = encode_mcu_AC_first_prepare;
+  } else {
+    if (is_DC_band)
+      entropy->pub.encode_mcu = encode_mcu_DC_refine;
+    else {
+      entropy->pub.encode_mcu = encode_mcu_AC_refine;
+      if (jsimd_can_encode_mcu_AC_refine_prepare())
+        entropy->AC_refine_prepare = jsimd_encode_mcu_AC_refine_prepare;
+      else
+        entropy->AC_refine_prepare = encode_mcu_AC_refine_prepare;
+      /* AC refinement needs a correction bit buffer */
+      if (entropy->bit_buffer == NULL)
+        entropy->bit_buffer = (char *)
+          (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+                                      MAX_CORR_BITS * sizeof(char));
+    }
+  }
+  if (gather_statistics)
+    entropy->pub.finish_pass = finish_pass_gather_phuff;
+  else
+    entropy->pub.finish_pass = finish_pass_phuff;
+
+  /* Only DC coefficients may be interleaved, so cinfo->comps_in_scan = 1
+   * for AC coefficients.
+   */
+  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+    compptr = cinfo->cur_comp_info[ci];
+    /* Initialize DC predictions to 0 */
+    entropy->last_dc_val[ci] = 0;
+    /* Get table index */
+    if (is_DC_band) {
+      if (cinfo->Ah != 0)       /* DC refinement needs no table */
+        continue;
+      tbl = compptr->dc_tbl_no;
+    } else {
+      entropy->ac_tbl_no = tbl = compptr->ac_tbl_no;
+    }
+    if (gather_statistics) {
+      /* Check for invalid table index */
+      /* (make_c_derived_tbl does this in the other path) */
+      if (tbl < 0 || tbl >= NUM_HUFF_TBLS)
+        ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, tbl);
+      /* Allocate and zero the statistics tables */
+      /* Note that jpeg_gen_optimal_table expects 257 entries in each table! */
+      if (entropy->count_ptrs[tbl] == NULL)
+        entropy->count_ptrs[tbl] = (long *)
+          (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+                                      257 * sizeof(long));
+      MEMZERO(entropy->count_ptrs[tbl], 257 * sizeof(long));
+    } else {
+      /* Compute derived values for Huffman table */
+      /* We may do this more than once for a table, but it's not expensive */
+      jpeg_make_c_derived_tbl(cinfo, is_DC_band, tbl,
+                              &entropy->derived_tbls[tbl]);
+    }
+  }
+
+  /* Initialize AC stuff */
+  entropy->EOBRUN = 0;
+  entropy->BE = 0;
+
+  /* Initialize bit buffer to empty */
+  entropy->put_buffer = 0;
+  entropy->put_bits = 0;
+
+  /* Initialize restart stuff */
+  entropy->restarts_to_go = cinfo->restart_interval;
+  entropy->next_restart_num = 0;
+}
+
+
+/* Outputting bytes to the file.
+ * NB: these must be called only when actually outputting,
+ * that is, entropy->gather_statistics == FALSE.
+ */
+
+/* Emit a byte */
+#define emit_byte(entropy, val) { \
+  *(entropy)->next_output_byte++ = (JOCTET)(val); \
+  if (--(entropy)->free_in_buffer == 0) \
+    dump_buffer(entropy); \
+}
+
+
+LOCAL(void)
+dump_buffer(phuff_entropy_ptr entropy)
+/* Empty the output buffer; we do not support suspension in this module. */
+{
+  struct jpeg_destination_mgr *dest = entropy->cinfo->dest;
+
+  if (!(*dest->empty_output_buffer) (entropy->cinfo))
+    ERREXIT(entropy->cinfo, JERR_CANT_SUSPEND);
+  /* After a successful buffer dump, must reset buffer pointers */
+  entropy->next_output_byte = dest->next_output_byte;
+  entropy->free_in_buffer = dest->free_in_buffer;
+}
+
+
+/* Outputting bits to the file */
+
+/* Only the right 24 bits of put_buffer are used; the valid bits are
+ * left-justified in this part.  At most 16 bits can be passed to emit_bits
+ * in one call, and we never retain more than 7 bits in put_buffer
+ * between calls, so 24 bits are sufficient.
+ */
+
+LOCAL(void)
+emit_bits(phuff_entropy_ptr entropy, unsigned int code, int size)
+/* Emit some bits, unless we are in gather mode */
+{
+  /* This routine is heavily used, so it's worth coding tightly. */
+  register size_t put_buffer = (size_t)code;
+  register int put_bits = entropy->put_bits;
+
+  /* if size is 0, caller used an invalid Huffman table entry */
+  if (size == 0)
+    ERREXIT(entropy->cinfo, JERR_HUFF_MISSING_CODE);
+
+  if (entropy->gather_statistics)
+    return;                     /* do nothing if we're only getting stats */
+
+  put_buffer &= (((size_t)1) << size) - 1; /* mask off any extra bits in code */
+
+  put_bits += size;             /* new number of bits in buffer */
+
+  put_buffer <<= 24 - put_bits; /* align incoming bits */
+
+  put_buffer |= entropy->put_buffer; /* and merge with old buffer contents */
+
+  while (put_bits >= 8) {
+    int c = (int)((put_buffer >> 16) & 0xFF);
+
+    emit_byte(entropy, c);
+    if (c == 0xFF) {            /* need to stuff a zero byte? */
+      emit_byte(entropy, 0);
+    }
+    put_buffer <<= 8;
+    put_bits -= 8;
+  }
+
+  entropy->put_buffer = put_buffer; /* update variables */
+  entropy->put_bits = put_bits;
+}
+
+
+LOCAL(void)
+flush_bits(phuff_entropy_ptr entropy)
+{
+  emit_bits(entropy, 0x7F, 7); /* fill any partial byte with ones */
+  entropy->put_buffer = 0;     /* and reset bit-buffer to empty */
+  entropy->put_bits = 0;
+}
+
+
+/*
+ * Emit (or just count) a Huffman symbol.
+ */
+
+LOCAL(void)
+emit_symbol(phuff_entropy_ptr entropy, int tbl_no, int symbol)
+{
+  if (entropy->gather_statistics)
+    entropy->count_ptrs[tbl_no][symbol]++;
+  else {
+    c_derived_tbl *tbl = entropy->derived_tbls[tbl_no];
+    emit_bits(entropy, tbl->ehufco[symbol], tbl->ehufsi[symbol]);
+  }
+}
+
+
+/*
+ * Emit bits from a correction bit buffer.
+ */
+
+LOCAL(void)
+emit_buffered_bits(phuff_entropy_ptr entropy, char *bufstart,
+                   unsigned int nbits)
+{
+  if (entropy->gather_statistics)
+    return;                     /* no real work */
+
+  while (nbits > 0) {
+    emit_bits(entropy, (unsigned int)(*bufstart), 1);
+    bufstart++;
+    nbits--;
+  }
+}
+
+
+/*
+ * Emit any pending EOBRUN symbol.
+ */
+
+LOCAL(void)
+emit_eobrun(phuff_entropy_ptr entropy)
+{
+  register int temp, nbits;
+
+  if (entropy->EOBRUN > 0) {    /* if there is any pending EOBRUN */
+    temp = entropy->EOBRUN;
+    nbits = JPEG_NBITS_NONZERO(temp) - 1;
+    /* safety check: shouldn't happen given limited correction-bit buffer */
+    if (nbits > 14)
+      ERREXIT(entropy->cinfo, JERR_HUFF_MISSING_CODE);
+
+    emit_symbol(entropy, entropy->ac_tbl_no, nbits << 4);
+    if (nbits)
+      emit_bits(entropy, entropy->EOBRUN, nbits);
+
+    entropy->EOBRUN = 0;
+
+    /* Emit any buffered correction bits */
+    emit_buffered_bits(entropy, entropy->bit_buffer, entropy->BE);
+    entropy->BE = 0;
+  }
+}
+
+
+/*
+ * Emit a restart marker & resynchronize predictions.
+ */
+
+LOCAL(void)
+emit_restart(phuff_entropy_ptr entropy, int restart_num)
+{
+  int ci;
+
+  emit_eobrun(entropy);
+
+  if (!entropy->gather_statistics) {
+    flush_bits(entropy);
+    emit_byte(entropy, 0xFF);
+    emit_byte(entropy, JPEG_RST0 + restart_num);
+  }
+
+  if (entropy->cinfo->Ss == 0) {
+    /* Re-initialize DC predictions to 0 */
+    for (ci = 0; ci < entropy->cinfo->comps_in_scan; ci++)
+      entropy->last_dc_val[ci] = 0;
+  } else {
+    /* Re-initialize all AC-related fields to 0 */
+    entropy->EOBRUN = 0;
+    entropy->BE = 0;
+  }
+}
+
+
+/*
+ * MCU encoding for DC initial scan (either spectral selection,
+ * or first pass of successive approximation).
+ */
+
+METHODDEF(boolean)
+encode_mcu_DC_first(j_compress_ptr cinfo, JBLOCKROW *MCU_data)
+{
+  phuff_entropy_ptr entropy = (phuff_entropy_ptr)cinfo->entropy;
+  register int temp, temp2, temp3;
+  register int nbits;
+  int blkn, ci;
+  int Al = cinfo->Al;
+  JBLOCKROW block;
+  jpeg_component_info *compptr;
+  ISHIFT_TEMPS
+
+  entropy->next_output_byte = cinfo->dest->next_output_byte;
+  entropy->free_in_buffer = cinfo->dest->free_in_buffer;
+
+  /* Emit restart marker if needed */
+  if (cinfo->restart_interval)
+    if (entropy->restarts_to_go == 0)
+      emit_restart(entropy, entropy->next_restart_num);
+
+  /* Encode the MCU data blocks */
+  for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
+    block = MCU_data[blkn];
+    ci = cinfo->MCU_membership[blkn];
+    compptr = cinfo->cur_comp_info[ci];
+
+    /* Compute the DC value after the required point transform by Al.
+     * This is simply an arithmetic right shift.
+     */
+    temp2 = IRIGHT_SHIFT((int)((*block)[0]), Al);
+
+    /* DC differences are figured on the point-transformed values. */
+    temp = temp2 - entropy->last_dc_val[ci];
+    entropy->last_dc_val[ci] = temp2;
+
+    /* Encode the DC coefficient difference per section G.1.2.1 */
+
+    /* This is a well-known technique for obtaining the absolute value without
+     * a branch.  It is derived from an assembly language technique presented
+     * in "How to Optimize for the Pentium Processors", Copyright (c) 1996,
+     * 1997 by Agner Fog.
+     */
+    temp3 = temp >> (CHAR_BIT * sizeof(int) - 1);
+    temp ^= temp3;
+    temp -= temp3;              /* temp is abs value of input */
+    /* For a negative input, want temp2 = bitwise complement of abs(input) */
+    temp2 = temp ^ temp3;
+
+    /* Find the number of bits needed for the magnitude of the coefficient */
+    nbits = JPEG_NBITS(temp);
+    /* Check for out-of-range coefficient values.
+     * Since we're encoding a difference, the range limit is twice as much.
+     */
+    if (nbits > MAX_COEF_BITS + 1)
+      ERREXIT(cinfo, JERR_BAD_DCT_COEF);
+
+    /* Count/emit the Huffman-coded symbol for the number of bits */
+    emit_symbol(entropy, compptr->dc_tbl_no, nbits);
+
+    /* Emit that number of bits of the value, if positive, */
+    /* or the complement of its magnitude, if negative. */
+    if (nbits)                  /* emit_bits rejects calls with size 0 */
+      emit_bits(entropy, (unsigned int)temp2, nbits);
+  }
+
+  cinfo->dest->next_output_byte = entropy->next_output_byte;
+  cinfo->dest->free_in_buffer = entropy->free_in_buffer;
+
+  /* Update restart-interval state too */
+  if (cinfo->restart_interval) {
+    if (entropy->restarts_to_go == 0) {
+      entropy->restarts_to_go = cinfo->restart_interval;
+      entropy->next_restart_num++;
+      entropy->next_restart_num &= 7;
+    }
+    entropy->restarts_to_go--;
+  }
+
+  return TRUE;
+}
+
+
+/*
+ * Data preparation for encode_mcu_AC_first().
+ */
+
+#define COMPUTE_ABSVALUES_AC_FIRST(Sl) { \
+  for (k = 0; k < Sl; k++) { \
+    temp = block[jpeg_natural_order_start[k]]; \
+    if (temp == 0) \
+      continue; \
+    /* We must apply the point transform by Al.  For AC coefficients this \
+     * is an integer division with rounding towards 0.  To do this portably \
+     * in C, we shift after obtaining the absolute value; so the code is \
+     * interwoven with finding the abs value (temp) and output bits (temp2). \
+     */ \
+    temp2 = temp >> (CHAR_BIT * sizeof(int) - 1); \
+    temp ^= temp2; \
+    temp -= temp2;              /* temp is abs value of input */ \
+    temp >>= Al;                /* apply the point transform */ \
+    /* Watch out for case that nonzero coef is zero after point transform */ \
+    if (temp == 0) \
+      continue; \
+    /* For a negative coef, want temp2 = bitwise complement of abs(coef) */ \
+    temp2 ^= temp; \
+    values[k] = temp; \
+    values[k + DCTSIZE2] = temp2; \
+    zerobits |= ((size_t)1U) << k; \
+  } \
+}
+
+METHODDEF(void)
+encode_mcu_AC_first_prepare(const JCOEF *block,
+                            const int *jpeg_natural_order_start, int Sl,
+                            int Al, JCOEF *values, size_t *bits)
+{
+  register int k, temp, temp2;
+  size_t zerobits = 0U;
+  int Sl0 = Sl;
+
+#if SIZEOF_SIZE_T == 4
+  if (Sl0 > 32)
+    Sl0 = 32;
+#endif
+
+  COMPUTE_ABSVALUES_AC_FIRST(Sl0);
+
+  bits[0] = zerobits;
+#if SIZEOF_SIZE_T == 4
+  zerobits = 0U;
+
+  if (Sl > 32) {
+    Sl -= 32;
+    jpeg_natural_order_start += 32;
+    values += 32;
+
+    COMPUTE_ABSVALUES_AC_FIRST(Sl);
+  }
+  bits[1] = zerobits;
+#endif
+}
+
+/*
+ * MCU encoding for AC initial scan (either spectral selection,
+ * or first pass of successive approximation).
+ */
+
+#define ENCODE_COEFS_AC_FIRST(label) { \
+  while (zerobits) { \
+    r = count_zeroes(&zerobits); \
+    cvalue += r; \
+label \
+    temp  = cvalue[0]; \
+    temp2 = cvalue[DCTSIZE2]; \
+    \
+    /* if run length > 15, must emit special run-length-16 codes (0xF0) */ \
+    while (r > 15) { \
+      emit_symbol(entropy, entropy->ac_tbl_no, 0xF0); \
+      r -= 16; \
+    } \
+    \
+    /* Find the number of bits needed for the magnitude of the coefficient */ \
+    nbits = JPEG_NBITS_NONZERO(temp);  /* there must be at least one 1 bit */ \
+    /* Check for out-of-range coefficient values */ \
+    if (nbits > MAX_COEF_BITS) \
+      ERREXIT(cinfo, JERR_BAD_DCT_COEF); \
+    \
+    /* Count/emit Huffman symbol for run length / number of bits */ \
+    emit_symbol(entropy, entropy->ac_tbl_no, (r << 4) + nbits); \
+    \
+    /* Emit that number of bits of the value, if positive, */ \
+    /* or the complement of its magnitude, if negative. */ \
+    emit_bits(entropy, (unsigned int)temp2, nbits); \
+    \
+    cvalue++; \
+    zerobits >>= 1; \
+  } \
+}
+
+METHODDEF(boolean)
+encode_mcu_AC_first(j_compress_ptr cinfo, JBLOCKROW *MCU_data)
+{
+  phuff_entropy_ptr entropy = (phuff_entropy_ptr)cinfo->entropy;
+  register int temp, temp2;
+  register int nbits, r;
+  int Sl = cinfo->Se - cinfo->Ss + 1;
+  int Al = cinfo->Al;
+  JCOEF values_unaligned[2 * DCTSIZE2 + 15];
+  JCOEF *values;
+  const JCOEF *cvalue;
+  size_t zerobits;
+  size_t bits[8 / SIZEOF_SIZE_T];
+
+  entropy->next_output_byte = cinfo->dest->next_output_byte;
+  entropy->free_in_buffer = cinfo->dest->free_in_buffer;
+
+  /* Emit restart marker if needed */
+  if (cinfo->restart_interval)
+    if (entropy->restarts_to_go == 0)
+      emit_restart(entropy, entropy->next_restart_num);
+
+#ifdef WITH_SIMD
+  cvalue = values = (JCOEF *)PAD((size_t)values_unaligned, 16);
+#else
+  /* Not using SIMD, so alignment is not needed */
+  cvalue = values = values_unaligned;
+#endif
+
+  /* Prepare data */
+  entropy->AC_first_prepare(MCU_data[0][0], jpeg_natural_order + cinfo->Ss,
+                            Sl, Al, values, bits);
+
+  zerobits = bits[0];
+#if SIZEOF_SIZE_T == 4
+  zerobits |= bits[1];
+#endif
+
+  /* Emit any pending EOBRUN */
+  if (zerobits && (entropy->EOBRUN > 0))
+    emit_eobrun(entropy);
+
+#if SIZEOF_SIZE_T == 4
+  zerobits = bits[0];
+#endif
+
+  /* Encode the AC coefficients per section G.1.2.2, fig. G.3 */
+
+  ENCODE_COEFS_AC_FIRST((void)0;);
+
+#if SIZEOF_SIZE_T == 4
+  zerobits = bits[1];
+  if (zerobits) {
+    int diff = ((values + DCTSIZE2 / 2) - cvalue);
+    r = count_zeroes(&zerobits);
+    r += diff;
+    cvalue += r;
+    goto first_iter_ac_first;
+  }
+
+  ENCODE_COEFS_AC_FIRST(first_iter_ac_first:);
+#endif
+
+  if (cvalue < (values + Sl)) { /* If there are trailing zeroes, */
+    entropy->EOBRUN++;          /* count an EOB */
+    if (entropy->EOBRUN == 0x7FFF)
+      emit_eobrun(entropy);     /* force it out to avoid overflow */
+  }
+
+  cinfo->dest->next_output_byte = entropy->next_output_byte;
+  cinfo->dest->free_in_buffer = entropy->free_in_buffer;
+
+  /* Update restart-interval state too */
+  if (cinfo->restart_interval) {
+    if (entropy->restarts_to_go == 0) {
+      entropy->restarts_to_go = cinfo->restart_interval;
+      entropy->next_restart_num++;
+      entropy->next_restart_num &= 7;
+    }
+    entropy->restarts_to_go--;
+  }
+
+  return TRUE;
+}
+
+
+/*
+ * MCU encoding for DC successive approximation refinement scan.
+ * Note: we assume such scans can be multi-component, although the spec
+ * is not very clear on the point.
+ */
+
+METHODDEF(boolean)
+encode_mcu_DC_refine(j_compress_ptr cinfo, JBLOCKROW *MCU_data)
+{
+  phuff_entropy_ptr entropy = (phuff_entropy_ptr)cinfo->entropy;
+  register int temp;
+  int blkn;
+  int Al = cinfo->Al;
+  JBLOCKROW block;
+
+  entropy->next_output_byte = cinfo->dest->next_output_byte;
+  entropy->free_in_buffer = cinfo->dest->free_in_buffer;
+
+  /* Emit restart marker if needed */
+  if (cinfo->restart_interval)
+    if (entropy->restarts_to_go == 0)
+      emit_restart(entropy, entropy->next_restart_num);
+
+  /* Encode the MCU data blocks */
+  for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
+    block = MCU_data[blkn];
+
+    /* We simply emit the Al'th bit of the DC coefficient value. */
+    temp = (*block)[0];
+    emit_bits(entropy, (unsigned int)(temp >> Al), 1);
+  }
+
+  cinfo->dest->next_output_byte = entropy->next_output_byte;
+  cinfo->dest->free_in_buffer = entropy->free_in_buffer;
+
+  /* Update restart-interval state too */
+  if (cinfo->restart_interval) {
+    if (entropy->restarts_to_go == 0) {
+      entropy->restarts_to_go = cinfo->restart_interval;
+      entropy->next_restart_num++;
+      entropy->next_restart_num &= 7;
+    }
+    entropy->restarts_to_go--;
+  }
+
+  return TRUE;
+}
+
+
+/*
+ * Data preparation for encode_mcu_AC_refine().
+ */
+
+#define COMPUTE_ABSVALUES_AC_REFINE(Sl, koffset) { \
+  /* It is convenient to make a pre-pass to determine the transformed \
+   * coefficients' absolute values and the EOB position. \
+   */ \
+  for (k = 0; k < Sl; k++) { \
+    temp = block[jpeg_natural_order_start[k]]; \
+    /* We must apply the point transform by Al.  For AC coefficients this \
+     * is an integer division with rounding towards 0.  To do this portably \
+     * in C, we shift after obtaining the absolute value. \
+     */ \
+    temp2 = temp >> (CHAR_BIT * sizeof(int) - 1); \
+    temp ^= temp2; \
+    temp -= temp2;              /* temp is abs value of input */ \
+    temp >>= Al;                /* apply the point transform */ \
+    if (temp != 0) { \
+      zerobits |= ((size_t)1U) << k; \
+      signbits |= ((size_t)(temp2 + 1)) << k; \
+    } \
+    absvalues[k] = (JCOEF)temp; /* save abs value for main pass */ \
+    if (temp == 1) \
+      EOB = k + koffset;        /* EOB = index of last newly-nonzero coef */ \
+  } \
+}
+
+METHODDEF(int)
+encode_mcu_AC_refine_prepare(const JCOEF *block,
+                             const int *jpeg_natural_order_start, int Sl,
+                             int Al, JCOEF *absvalues, size_t *bits)
+{
+  register int k, temp, temp2;
+  int EOB = 0;
+  size_t zerobits = 0U, signbits = 0U;
+  int Sl0 = Sl;
+
+#if SIZEOF_SIZE_T == 4
+  if (Sl0 > 32)
+    Sl0 = 32;
+#endif
+
+  COMPUTE_ABSVALUES_AC_REFINE(Sl0, 0);
+
+  bits[0] = zerobits;
+#if SIZEOF_SIZE_T == 8
+  bits[1] = signbits;
+#else
+  bits[2] = signbits;
+
+  zerobits = 0U;
+  signbits = 0U;
+
+  if (Sl > 32) {
+    Sl -= 32;
+    jpeg_natural_order_start += 32;
+    absvalues += 32;
+
+    COMPUTE_ABSVALUES_AC_REFINE(Sl, 32);
+  }
+
+  bits[1] = zerobits;
+  bits[3] = signbits;
+#endif
+
+  return EOB;
+}
+
+
+/*
+ * MCU encoding for AC successive approximation refinement scan.
+ */
+
+#define ENCODE_COEFS_AC_REFINE(label) { \
+  while (zerobits) { \
+    int idx = count_zeroes(&zerobits); \
+    r += idx; \
+    cabsvalue += idx; \
+    signbits >>= idx; \
+label \
+    /* Emit any required ZRLs, but not if they can be folded into EOB */ \
+    while (r > 15 && (cabsvalue <= EOBPTR)) { \
+      /* emit any pending EOBRUN and the BE correction bits */ \
+      emit_eobrun(entropy); \
+      /* Emit ZRL */ \
+      emit_symbol(entropy, entropy->ac_tbl_no, 0xF0); \
+      r -= 16; \
+      /* Emit buffered correction bits that must be associated with ZRL */ \
+      emit_buffered_bits(entropy, BR_buffer, BR); \
+      BR_buffer = entropy->bit_buffer; /* BE bits are gone now */ \
+      BR = 0; \
+    } \
+    \
+    temp = *cabsvalue++; \
+    \
+    /* If the coef was previously nonzero, it only needs a correction bit. \
+     * NOTE: a straight translation of the spec's figure G.7 would suggest \
+     * that we also need to test r > 15.  But if r > 15, we can only get here \
+     * if k > EOB, which implies that this coefficient is not 1. \
+     */ \
+    if (temp > 1) { \
+      /* The correction bit is the next bit of the absolute value. */ \
+      BR_buffer[BR++] = (char)(temp & 1); \
+      signbits >>= 1; \
+      zerobits >>= 1; \
+      continue; \
+    } \
+    \
+    /* Emit any pending EOBRUN and the BE correction bits */ \
+    emit_eobrun(entropy); \
+    \
+    /* Count/emit Huffman symbol for run length / number of bits */ \
+    emit_symbol(entropy, entropy->ac_tbl_no, (r << 4) + 1); \
+    \
+    /* Emit output bit for newly-nonzero coef */ \
+    temp = signbits & 1; /* ((*block)[jpeg_natural_order_start[k]] < 0) ? 0 : 1 */ \
+    emit_bits(entropy, (unsigned int)temp, 1); \
+    \
+    /* Emit buffered correction bits that must be associated with this code */ \
+    emit_buffered_bits(entropy, BR_buffer, BR); \
+    BR_buffer = entropy->bit_buffer; /* BE bits are gone now */ \
+    BR = 0; \
+    r = 0;                      /* reset zero run length */ \
+    signbits >>= 1; \
+    zerobits >>= 1; \
+  } \
+}
+
+METHODDEF(boolean)
+encode_mcu_AC_refine(j_compress_ptr cinfo, JBLOCKROW *MCU_data)
+{
+  phuff_entropy_ptr entropy = (phuff_entropy_ptr)cinfo->entropy;
+  register int temp, r;
+  char *BR_buffer;
+  unsigned int BR;
+  int Sl = cinfo->Se - cinfo->Ss + 1;
+  int Al = cinfo->Al;
+  JCOEF absvalues_unaligned[DCTSIZE2 + 15];
+  JCOEF *absvalues;
+  const JCOEF *cabsvalue, *EOBPTR;
+  size_t zerobits, signbits;
+  size_t bits[16 / SIZEOF_SIZE_T];
+
+  entropy->next_output_byte = cinfo->dest->next_output_byte;
+  entropy->free_in_buffer = cinfo->dest->free_in_buffer;
+
+  /* Emit restart marker if needed */
+  if (cinfo->restart_interval)
+    if (entropy->restarts_to_go == 0)
+      emit_restart(entropy, entropy->next_restart_num);
+
+#ifdef WITH_SIMD
+  cabsvalue = absvalues = (JCOEF *)PAD((size_t)absvalues_unaligned, 16);
+#else
+  /* Not using SIMD, so alignment is not needed */
+  cabsvalue = absvalues = absvalues_unaligned;
+#endif
+
+  /* Prepare data */
+  EOBPTR = absvalues +
+    entropy->AC_refine_prepare(MCU_data[0][0], jpeg_natural_order + cinfo->Ss,
+                               Sl, Al, absvalues, bits);
+
+  /* Encode the AC coefficients per section G.1.2.3, fig. G.7 */
+
+  r = 0;                        /* r = run length of zeros */
+  BR = 0;                       /* BR = count of buffered bits added now */
+  BR_buffer = entropy->bit_buffer + entropy->BE; /* Append bits to buffer */
+
+  zerobits = bits[0];
+#if SIZEOF_SIZE_T == 8
+  signbits = bits[1];
+#else
+  signbits = bits[2];
+#endif
+  ENCODE_COEFS_AC_REFINE((void)0;);
+
+#if SIZEOF_SIZE_T == 4
+  zerobits = bits[1];
+  signbits = bits[3];
+
+  if (zerobits) {
+    int diff = ((absvalues + DCTSIZE2 / 2) - cabsvalue);
+    int idx = count_zeroes(&zerobits);
+    signbits >>= idx;
+    idx += diff;
+    r += idx;
+    cabsvalue += idx;
+    goto first_iter_ac_refine;
+  }
+
+  ENCODE_COEFS_AC_REFINE(first_iter_ac_refine:);
+#endif
+
+  r |= (int)((absvalues + Sl) - cabsvalue);
+
+  if (r > 0 || BR > 0) {        /* If there are trailing zeroes, */
+    entropy->EOBRUN++;          /* count an EOB */
+    entropy->BE += BR;          /* concat my correction bits to older ones */
+    /* We force out the EOB if we risk either:
+     * 1. overflow of the EOB counter;
+     * 2. overflow of the correction bit buffer during the next MCU.
+     */
+    if (entropy->EOBRUN == 0x7FFF ||
+        entropy->BE > (MAX_CORR_BITS - DCTSIZE2 + 1))
+      emit_eobrun(entropy);
+  }
+
+  cinfo->dest->next_output_byte = entropy->next_output_byte;
+  cinfo->dest->free_in_buffer = entropy->free_in_buffer;
+
+  /* Update restart-interval state too */
+  if (cinfo->restart_interval) {
+    if (entropy->restarts_to_go == 0) {
+      entropy->restarts_to_go = cinfo->restart_interval;
+      entropy->next_restart_num++;
+      entropy->next_restart_num &= 7;
+    }
+    entropy->restarts_to_go--;
+  }
+
+  return TRUE;
+}
+
+
+/*
+ * Finish up at the end of a Huffman-compressed progressive scan.
+ */
+
+METHODDEF(void)
+finish_pass_phuff(j_compress_ptr cinfo)
+{
+  phuff_entropy_ptr entropy = (phuff_entropy_ptr)cinfo->entropy;
+
+  entropy->next_output_byte = cinfo->dest->next_output_byte;
+  entropy->free_in_buffer = cinfo->dest->free_in_buffer;
+
+  /* Flush out any buffered data */
+  emit_eobrun(entropy);
+  flush_bits(entropy);
+
+  cinfo->dest->next_output_byte = entropy->next_output_byte;
+  cinfo->dest->free_in_buffer = entropy->free_in_buffer;
+}
+
+
+/*
+ * Finish up a statistics-gathering pass and create the new Huffman tables.
+ */
+
+METHODDEF(void)
+finish_pass_gather_phuff(j_compress_ptr cinfo)
+{
+  phuff_entropy_ptr entropy = (phuff_entropy_ptr)cinfo->entropy;
+  boolean is_DC_band;
+  int ci, tbl;
+  jpeg_component_info *compptr;
+  JHUFF_TBL **htblptr;
+  boolean did[NUM_HUFF_TBLS];
+
+  /* Flush out buffered data (all we care about is counting the EOB symbol) */
+  emit_eobrun(entropy);
+
+  is_DC_band = (cinfo->Ss == 0);
+
+  /* It's important not to apply jpeg_gen_optimal_table more than once
+   * per table, because it clobbers the input frequency counts!
+   */
+  MEMZERO(did, sizeof(did));
+
+  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+    compptr = cinfo->cur_comp_info[ci];
+    if (is_DC_band) {
+      if (cinfo->Ah != 0)       /* DC refinement needs no table */
+        continue;
+      tbl = compptr->dc_tbl_no;
+    } else {
+      tbl = compptr->ac_tbl_no;
+    }
+    if (!did[tbl]) {
+      if (is_DC_band)
+        htblptr = &cinfo->dc_huff_tbl_ptrs[tbl];
+      else
+        htblptr = &cinfo->ac_huff_tbl_ptrs[tbl];
+      if (*htblptr == NULL)
+        *htblptr = jpeg_alloc_huff_table((j_common_ptr)cinfo);
+      jpeg_gen_optimal_table(cinfo, *htblptr, entropy->count_ptrs[tbl]);
+      did[tbl] = TRUE;
+    }
+  }
+}
+
+
+/*
+ * Module initialization routine for progressive Huffman entropy encoding.
+ */
+
+GLOBAL(void)
+jinit_phuff_encoder(j_compress_ptr cinfo)
+{
+  phuff_entropy_ptr entropy;
+  int i;
+
+  entropy = (phuff_entropy_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+                                sizeof(phuff_entropy_encoder));
+  cinfo->entropy = (struct jpeg_entropy_encoder *)entropy;
+  entropy->pub.start_pass = start_pass_phuff;
+
+  /* Mark tables unallocated */
+  for (i = 0; i < NUM_HUFF_TBLS; i++) {
+    entropy->derived_tbls[i] = NULL;
+    entropy->count_ptrs[i] = NULL;
+  }
+  entropy->bit_buffer = NULL;   /* needed only in AC refinement scan */
+}
+
+#endif /* C_PROGRESSIVE_SUPPORTED */
diff --git a/3rdparty/libjpeg/src/jcprepct.c b/3rdparty/libjpeg/src/jcprepct.c
new file mode 100644
index 00000000..d59713ae
--- /dev/null
+++ b/3rdparty/libjpeg/src/jcprepct.c
@@ -0,0 +1,351 @@
+/*
+ * jcprepct.c
+ *
+ * This file is part of the Independent JPEG Group's software:
+ * Copyright (C) 1994-1996, Thomas G. Lane.
+ * It was modified by The libjpeg-turbo Project to include only code relevant
+ * to libjpeg-turbo.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains the compression preprocessing controller.
+ * This controller manages the color conversion, downsampling,
+ * and edge expansion steps.
+ *
+ * Most of the complexity here is associated with buffering input rows
+ * as required by the downsampler.  See the comments at the head of
+ * jcsample.c for the downsampler's needs.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/* At present, jcsample.c can request context rows only for smoothing.
+ * In the future, we might also need context rows for CCIR601 sampling
+ * or other more-complex downsampling procedures.  The code to support
+ * context rows should be compiled only if needed.
+ */
+#ifdef INPUT_SMOOTHING_SUPPORTED
+#define CONTEXT_ROWS_SUPPORTED
+#endif
+
+
+/*
+ * For the simple (no-context-row) case, we just need to buffer one
+ * row group's worth of pixels for the downsampling step.  At the bottom of
+ * the image, we pad to a full row group by replicating the last pixel row.
+ * The downsampler's last output row is then replicated if needed to pad
+ * out to a full iMCU row.
+ *
+ * When providing context rows, we must buffer three row groups' worth of
+ * pixels.  Three row groups are physically allocated, but the row pointer
+ * arrays are made five row groups high, with the extra pointers above and
+ * below "wrapping around" to point to the last and first real row groups.
+ * This allows the downsampler to access the proper context rows.
+ * At the top and bottom of the image, we create dummy context rows by
+ * copying the first or last real pixel row.  This copying could be avoided
+ * by pointer hacking as is done in jdmainct.c, but it doesn't seem worth the
+ * trouble on the compression side.
+ */
+
+
+/* Private buffer controller object */
+
+typedef struct {
+  struct jpeg_c_prep_controller pub; /* public fields */
+
+  /* Downsampling input buffer.  This buffer holds color-converted data
+   * until we have enough to do a downsample step.
+   */
+  JSAMPARRAY color_buf[MAX_COMPONENTS];
+
+  JDIMENSION rows_to_go;        /* counts rows remaining in source image */
+  int next_buf_row;             /* index of next row to store in color_buf */
+
+#ifdef CONTEXT_ROWS_SUPPORTED   /* only needed for context case */
+  int this_row_group;           /* starting row index of group to process */
+  int next_buf_stop;            /* downsample when we reach this index */
+#endif
+} my_prep_controller;
+
+typedef my_prep_controller *my_prep_ptr;
+
+
+/*
+ * Initialize for a processing pass.
+ */
+
+METHODDEF(void)
+start_pass_prep(j_compress_ptr cinfo, J_BUF_MODE pass_mode)
+{
+  my_prep_ptr prep = (my_prep_ptr)cinfo->prep;
+
+  if (pass_mode != JBUF_PASS_THRU)
+    ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+
+  /* Initialize total-height counter for detecting bottom of image */
+  prep->rows_to_go = cinfo->image_height;
+  /* Mark the conversion buffer empty */
+  prep->next_buf_row = 0;
+#ifdef CONTEXT_ROWS_SUPPORTED
+  /* Preset additional state variables for context mode.
+   * These aren't used in non-context mode, so we needn't test which mode.
+   */
+  prep->this_row_group = 0;
+  /* Set next_buf_stop to stop after two row groups have been read in. */
+  prep->next_buf_stop = 2 * cinfo->max_v_samp_factor;
+#endif
+}
+
+
+/*
+ * Expand an image vertically from height input_rows to height output_rows,
+ * by duplicating the bottom row.
+ */
+
+LOCAL(void)
+expand_bottom_edge(JSAMPARRAY image_data, JDIMENSION num_cols, int input_rows,
+                   int output_rows)
+{
+  register int row;
+
+  for (row = input_rows; row < output_rows; row++) {
+    jcopy_sample_rows(image_data, input_rows - 1, image_data, row, 1,
+                      num_cols);
+  }
+}
+
+
+/*
+ * Process some data in the simple no-context case.
+ *
+ * Preprocessor output data is counted in "row groups".  A row group
+ * is defined to be v_samp_factor sample rows of each component.
+ * Downsampling will produce this much data from each max_v_samp_factor
+ * input rows.
+ */
+
+METHODDEF(void)
+pre_process_data(j_compress_ptr cinfo, JSAMPARRAY input_buf,
+                 JDIMENSION *in_row_ctr, JDIMENSION in_rows_avail,
+                 JSAMPIMAGE output_buf, JDIMENSION *out_row_group_ctr,
+                 JDIMENSION out_row_groups_avail)
+{
+  my_prep_ptr prep = (my_prep_ptr)cinfo->prep;
+  int numrows, ci;
+  JDIMENSION inrows;
+  jpeg_component_info *compptr;
+
+  while (*in_row_ctr < in_rows_avail &&
+         *out_row_group_ctr < out_row_groups_avail) {
+    /* Do color conversion to fill the conversion buffer. */
+    inrows = in_rows_avail - *in_row_ctr;
+    numrows = cinfo->max_v_samp_factor - prep->next_buf_row;
+    numrows = (int)MIN((JDIMENSION)numrows, inrows);
+    (*cinfo->cconvert->color_convert) (cinfo, input_buf + *in_row_ctr,
+                                       prep->color_buf,
+                                       (JDIMENSION)prep->next_buf_row,
+                                       numrows);
+    *in_row_ctr += numrows;
+    prep->next_buf_row += numrows;
+    prep->rows_to_go -= numrows;
+    /* If at bottom of image, pad to fill the conversion buffer. */
+    if (prep->rows_to_go == 0 &&
+        prep->next_buf_row < cinfo->max_v_samp_factor) {
+      for (ci = 0; ci < cinfo->num_components; ci++) {
+        expand_bottom_edge(prep->color_buf[ci], cinfo->image_width,
+                           prep->next_buf_row, cinfo->max_v_samp_factor);
+      }
+      prep->next_buf_row = cinfo->max_v_samp_factor;
+    }
+    /* If we've filled the conversion buffer, empty it. */
+    if (prep->next_buf_row == cinfo->max_v_samp_factor) {
+      (*cinfo->downsample->downsample) (cinfo,
+                                        prep->color_buf, (JDIMENSION)0,
+                                        output_buf, *out_row_group_ctr);
+      prep->next_buf_row = 0;
+      (*out_row_group_ctr)++;
+    }
+    /* If at bottom of image, pad the output to a full iMCU height.
+     * Note we assume the caller is providing a one-iMCU-height output buffer!
+     */
+    if (prep->rows_to_go == 0 && *out_row_group_ctr < out_row_groups_avail) {
+      for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+           ci++, compptr++) {
+        expand_bottom_edge(output_buf[ci], compptr->width_in_blocks * DCTSIZE,
+                           (int)(*out_row_group_ctr * compptr->v_samp_factor),
+                           (int)(out_row_groups_avail * compptr->v_samp_factor));
+      }
+      *out_row_group_ctr = out_row_groups_avail;
+      break;                    /* can exit outer loop without test */
+    }
+  }
+}
+
+
+#ifdef CONTEXT_ROWS_SUPPORTED
+
+/*
+ * Process some data in the context case.
+ */
+
+METHODDEF(void)
+pre_process_context(j_compress_ptr cinfo, JSAMPARRAY input_buf,
+                    JDIMENSION *in_row_ctr, JDIMENSION in_rows_avail,
+                    JSAMPIMAGE output_buf, JDIMENSION *out_row_group_ctr,
+                    JDIMENSION out_row_groups_avail)
+{
+  my_prep_ptr prep = (my_prep_ptr)cinfo->prep;
+  int numrows, ci;
+  int buf_height = cinfo->max_v_samp_factor * 3;
+  JDIMENSION inrows;
+
+  while (*out_row_group_ctr < out_row_groups_avail) {
+    if (*in_row_ctr < in_rows_avail) {
+      /* Do color conversion to fill the conversion buffer. */
+      inrows = in_rows_avail - *in_row_ctr;
+      numrows = prep->next_buf_stop - prep->next_buf_row;
+      numrows = (int)MIN((JDIMENSION)numrows, inrows);
+      (*cinfo->cconvert->color_convert) (cinfo, input_buf + *in_row_ctr,
+                                         prep->color_buf,
+                                         (JDIMENSION)prep->next_buf_row,
+                                         numrows);
+      /* Pad at top of image, if first time through */
+      if (prep->rows_to_go == cinfo->image_height) {
+        for (ci = 0; ci < cinfo->num_components; ci++) {
+          int row;
+          for (row = 1; row <= cinfo->max_v_samp_factor; row++) {
+            jcopy_sample_rows(prep->color_buf[ci], 0, prep->color_buf[ci],
+                              -row, 1, cinfo->image_width);
+          }
+        }
+      }
+      *in_row_ctr += numrows;
+      prep->next_buf_row += numrows;
+      prep->rows_to_go -= numrows;
+    } else {
+      /* Return for more data, unless we are at the bottom of the image. */
+      if (prep->rows_to_go != 0)
+        break;
+      /* When at bottom of image, pad to fill the conversion buffer. */
+      if (prep->next_buf_row < prep->next_buf_stop) {
+        for (ci = 0; ci < cinfo->num_components; ci++) {
+          expand_bottom_edge(prep->color_buf[ci], cinfo->image_width,
+                             prep->next_buf_row, prep->next_buf_stop);
+        }
+        prep->next_buf_row = prep->next_buf_stop;
+      }
+    }
+    /* If we've gotten enough data, downsample a row group. */
+    if (prep->next_buf_row == prep->next_buf_stop) {
+      (*cinfo->downsample->downsample) (cinfo, prep->color_buf,
+                                        (JDIMENSION)prep->this_row_group,
+                                        output_buf, *out_row_group_ctr);
+      (*out_row_group_ctr)++;
+      /* Advance pointers with wraparound as necessary. */
+      prep->this_row_group += cinfo->max_v_samp_factor;
+      if (prep->this_row_group >= buf_height)
+        prep->this_row_group = 0;
+      if (prep->next_buf_row >= buf_height)
+        prep->next_buf_row = 0;
+      prep->next_buf_stop = prep->next_buf_row + cinfo->max_v_samp_factor;
+    }
+  }
+}
+
+
+/*
+ * Create the wrapped-around downsampling input buffer needed for context mode.
+ */
+
+LOCAL(void)
+create_context_buffer(j_compress_ptr cinfo)
+{
+  my_prep_ptr prep = (my_prep_ptr)cinfo->prep;
+  int rgroup_height = cinfo->max_v_samp_factor;
+  int ci, i;
+  jpeg_component_info *compptr;
+  JSAMPARRAY true_buffer, fake_buffer;
+
+  /* Grab enough space for fake row pointers for all the components;
+   * we need five row groups' worth of pointers for each component.
+   */
+  fake_buffer = (JSAMPARRAY)
+    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+                                (cinfo->num_components * 5 * rgroup_height) *
+                                sizeof(JSAMPROW));
+
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    /* Allocate the actual buffer space (3 row groups) for this component.
+     * We make the buffer wide enough to allow the downsampler to edge-expand
+     * horizontally within the buffer, if it so chooses.
+     */
+    true_buffer = (*cinfo->mem->alloc_sarray)
+      ((j_common_ptr)cinfo, JPOOL_IMAGE,
+       (JDIMENSION)(((long)compptr->width_in_blocks * DCTSIZE *
+                     cinfo->max_h_samp_factor) / compptr->h_samp_factor),
+       (JDIMENSION)(3 * rgroup_height));
+    /* Copy true buffer row pointers into the middle of the fake row array */
+    MEMCOPY(fake_buffer + rgroup_height, true_buffer,
+            3 * rgroup_height * sizeof(JSAMPROW));
+    /* Fill in the above and below wraparound pointers */
+    for (i = 0; i < rgroup_height; i++) {
+      fake_buffer[i] = true_buffer[2 * rgroup_height + i];
+      fake_buffer[4 * rgroup_height + i] = true_buffer[i];
+    }
+    prep->color_buf[ci] = fake_buffer + rgroup_height;
+    fake_buffer += 5 * rgroup_height; /* point to space for next component */
+  }
+}
+
+#endif /* CONTEXT_ROWS_SUPPORTED */
+
+
+/*
+ * Initialize preprocessing controller.
+ */
+
+GLOBAL(void)
+jinit_c_prep_controller(j_compress_ptr cinfo, boolean need_full_buffer)
+{
+  my_prep_ptr prep;
+  int ci;
+  jpeg_component_info *compptr;
+
+  if (need_full_buffer)         /* safety check */
+    ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+
+  prep = (my_prep_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+                                sizeof(my_prep_controller));
+  cinfo->prep = (struct jpeg_c_prep_controller *)prep;
+  prep->pub.start_pass = start_pass_prep;
+
+  /* Allocate the color conversion buffer.
+   * We make the buffer wide enough to allow the downsampler to edge-expand
+   * horizontally within the buffer, if it so chooses.
+   */
+  if (cinfo->downsample->need_context_rows) {
+    /* Set up to provide context rows */
+#ifdef CONTEXT_ROWS_SUPPORTED
+    prep->pub.pre_process_data = pre_process_context;
+    create_context_buffer(cinfo);
+#else
+    ERREXIT(cinfo, JERR_NOT_COMPILED);
+#endif
+  } else {
+    /* No context, just make it tall enough for one row group */
+    prep->pub.pre_process_data = pre_process_data;
+    for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+         ci++, compptr++) {
+      prep->color_buf[ci] = (*cinfo->mem->alloc_sarray)
+        ((j_common_ptr)cinfo, JPOOL_IMAGE,
+         (JDIMENSION)(((long)compptr->width_in_blocks * DCTSIZE *
+                       cinfo->max_h_samp_factor) / compptr->h_samp_factor),
+         (JDIMENSION)cinfo->max_v_samp_factor);
+    }
+  }
+}
diff --git a/3rdparty/libjpeg/src/jcsample.c b/3rdparty/libjpeg/src/jcsample.c
new file mode 100644
index 00000000..e8515ebf
--- /dev/null
+++ b/3rdparty/libjpeg/src/jcsample.c
@@ -0,0 +1,522 @@
+/*
+ * jcsample.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1991-1996, Thomas G. Lane.
+ * libjpeg-turbo Modifications:
+ * Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+ * Copyright (C) 2014, MIPS Technologies, Inc., California.
+ * Copyright (C) 2015, 2019, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains downsampling routines.
+ *
+ * Downsampling input data is counted in "row groups".  A row group
+ * is defined to be max_v_samp_factor pixel rows of each component,
+ * from which the downsampler produces v_samp_factor sample rows.
+ * A single row group is processed in each call to the downsampler module.
+ *
+ * The downsampler is responsible for edge-expansion of its output data
+ * to fill an integral number of DCT blocks horizontally.  The source buffer
+ * may be modified if it is helpful for this purpose (the source buffer is
+ * allocated wide enough to correspond to the desired output width).
+ * The caller (the prep controller) is responsible for vertical padding.
+ *
+ * The downsampler may request "context rows" by setting need_context_rows
+ * during startup.  In this case, the input arrays will contain at least
+ * one row group's worth of pixels above and below the passed-in data;
+ * the caller will create dummy rows at image top and bottom by replicating
+ * the first or last real pixel row.
+ *
+ * An excellent reference for image resampling is
+ *   Digital Image Warping, George Wolberg, 1990.
+ *   Pub. by IEEE Computer Society Press, Los Alamitos, CA. ISBN 0-8186-8944-7.
+ *
+ * The downsampling algorithm used here is a simple average of the source
+ * pixels covered by the output pixel.  The hi-falutin sampling literature
+ * refers to this as a "box filter".  In general the characteristics of a box
+ * filter are not very good, but for the specific cases we normally use (1:1
+ * and 2:1 ratios) the box is equivalent to a "triangle filter" which is not
+ * nearly so bad.  If you intend to use other sampling ratios, you'd be well
+ * advised to improve this code.
+ *
+ * A simple input-smoothing capability is provided.  This is mainly intended
+ * for cleaning up color-dithered GIF input files (if you find it inadequate,
+ * we suggest using an external filtering program such as pnmconvol).  When
+ * enabled, each input pixel P is replaced by a weighted sum of itself and its
+ * eight neighbors.  P's weight is 1-8*SF and each neighbor's weight is SF,
+ * where SF = (smoothing_factor / 1024).
+ * Currently, smoothing is only supported for 2h2v sampling factors.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jsimd.h"
+
+
+/* Pointer to routine to downsample a single component */
+typedef void (*downsample1_ptr) (j_compress_ptr cinfo,
+                                 jpeg_component_info *compptr,
+                                 JSAMPARRAY input_data,
+                                 JSAMPARRAY output_data);
+
+/* Private subobject */
+
+typedef struct {
+  struct jpeg_downsampler pub;  /* public fields */
+
+  /* Downsampling method pointers, one per component */
+  downsample1_ptr methods[MAX_COMPONENTS];
+} my_downsampler;
+
+typedef my_downsampler *my_downsample_ptr;
+
+
+/*
+ * Initialize for a downsampling pass.
+ */
+
+METHODDEF(void)
+start_pass_downsample(j_compress_ptr cinfo)
+{
+  /* no work for now */
+}
+
+
+/*
+ * Expand a component horizontally from width input_cols to width output_cols,
+ * by duplicating the rightmost samples.
+ */
+
+LOCAL(void)
+expand_right_edge(JSAMPARRAY image_data, int num_rows, JDIMENSION input_cols,
+                  JDIMENSION output_cols)
+{
+  register JSAMPROW ptr;
+  register JSAMPLE pixval;
+  register int count;
+  int row;
+  int numcols = (int)(output_cols - input_cols);
+
+  if (numcols > 0) {
+    for (row = 0; row < num_rows; row++) {
+      ptr = image_data[row] + input_cols;
+      pixval = ptr[-1];
+      for (count = numcols; count > 0; count--)
+        *ptr++ = pixval;
+    }
+  }
+}
+
+
+/*
+ * Do downsampling for a whole row group (all components).
+ *
+ * In this version we simply downsample each component independently.
+ */
+
+METHODDEF(void)
+sep_downsample(j_compress_ptr cinfo, JSAMPIMAGE input_buf,
+               JDIMENSION in_row_index, JSAMPIMAGE output_buf,
+               JDIMENSION out_row_group_index)
+{
+  my_downsample_ptr downsample = (my_downsample_ptr)cinfo->downsample;
+  int ci;
+  jpeg_component_info *compptr;
+  JSAMPARRAY in_ptr, out_ptr;
+
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    in_ptr = input_buf[ci] + in_row_index;
+    out_ptr = output_buf[ci] + (out_row_group_index * compptr->v_samp_factor);
+    (*downsample->methods[ci]) (cinfo, compptr, in_ptr, out_ptr);
+  }
+}
+
+
+/*
+ * Downsample pixel values of a single component.
+ * One row group is processed per call.
+ * This version handles arbitrary integral sampling ratios, without smoothing.
+ * Note that this version is not actually used for customary sampling ratios.
+ */
+
+METHODDEF(void)
+int_downsample(j_compress_ptr cinfo, jpeg_component_info *compptr,
+               JSAMPARRAY input_data, JSAMPARRAY output_data)
+{
+  int inrow, outrow, h_expand, v_expand, numpix, numpix2, h, v;
+  JDIMENSION outcol, outcol_h;  /* outcol_h == outcol*h_expand */
+  JDIMENSION output_cols = compptr->width_in_blocks * DCTSIZE;
+  JSAMPROW inptr, outptr;
+  JLONG outvalue;
+
+  h_expand = cinfo->max_h_samp_factor / compptr->h_samp_factor;
+  v_expand = cinfo->max_v_samp_factor / compptr->v_samp_factor;
+  numpix = h_expand * v_expand;
+  numpix2 = numpix / 2;
+
+  /* Expand input data enough to let all the output samples be generated
+   * by the standard loop.  Special-casing padded output would be more
+   * efficient.
+   */
+  expand_right_edge(input_data, cinfo->max_v_samp_factor, cinfo->image_width,
+                    output_cols * h_expand);
+
+  inrow = 0;
+  for (outrow = 0; outrow < compptr->v_samp_factor; outrow++) {
+    outptr = output_data[outrow];
+    for (outcol = 0, outcol_h = 0; outcol < output_cols;
+         outcol++, outcol_h += h_expand) {
+      outvalue = 0;
+      for (v = 0; v < v_expand; v++) {
+        inptr = input_data[inrow + v] + outcol_h;
+        for (h = 0; h < h_expand; h++) {
+          outvalue += (JLONG)(*inptr++);
+        }
+      }
+      *outptr++ = (JSAMPLE)((outvalue + numpix2) / numpix);
+    }
+    inrow += v_expand;
+  }
+}
+
+
+/*
+ * Downsample pixel values of a single component.
+ * This version handles the special case of a full-size component,
+ * without smoothing.
+ */
+
+METHODDEF(void)
+fullsize_downsample(j_compress_ptr cinfo, jpeg_component_info *compptr,
+                    JSAMPARRAY input_data, JSAMPARRAY output_data)
+{
+  /* Copy the data */
+  jcopy_sample_rows(input_data, 0, output_data, 0, cinfo->max_v_samp_factor,
+                    cinfo->image_width);
+  /* Edge-expand */
+  expand_right_edge(output_data, cinfo->max_v_samp_factor, cinfo->image_width,
+                    compptr->width_in_blocks * DCTSIZE);
+}
+
+
+/*
+ * Downsample pixel values of a single component.
+ * This version handles the common case of 2:1 horizontal and 1:1 vertical,
+ * without smoothing.
+ *
+ * A note about the "bias" calculations: when rounding fractional values to
+ * integer, we do not want to always round 0.5 up to the next integer.
+ * If we did that, we'd introduce a noticeable bias towards larger values.
+ * Instead, this code is arranged so that 0.5 will be rounded up or down at
+ * alternate pixel locations (a simple ordered dither pattern).
+ */
+
+METHODDEF(void)
+h2v1_downsample(j_compress_ptr cinfo, jpeg_component_info *compptr,
+                JSAMPARRAY input_data, JSAMPARRAY output_data)
+{
+  int outrow;
+  JDIMENSION outcol;
+  JDIMENSION output_cols = compptr->width_in_blocks * DCTSIZE;
+  register JSAMPROW inptr, outptr;
+  register int bias;
+
+  /* Expand input data enough to let all the output samples be generated
+   * by the standard loop.  Special-casing padded output would be more
+   * efficient.
+   */
+  expand_right_edge(input_data, cinfo->max_v_samp_factor, cinfo->image_width,
+                    output_cols * 2);
+
+  for (outrow = 0; outrow < compptr->v_samp_factor; outrow++) {
+    outptr = output_data[outrow];
+    inptr = input_data[outrow];
+    bias = 0;                   /* bias = 0,1,0,1,... for successive samples */
+    for (outcol = 0; outcol < output_cols; outcol++) {
+      *outptr++ = (JSAMPLE)((inptr[0] + inptr[1] + bias) >> 1);
+      bias ^= 1;                /* 0=>1, 1=>0 */
+      inptr += 2;
+    }
+  }
+}
+
+
+/*
+ * Downsample pixel values of a single component.
+ * This version handles the standard case of 2:1 horizontal and 2:1 vertical,
+ * without smoothing.
+ */
+
+METHODDEF(void)
+h2v2_downsample(j_compress_ptr cinfo, jpeg_component_info *compptr,
+                JSAMPARRAY input_data, JSAMPARRAY output_data)
+{
+  int inrow, outrow;
+  JDIMENSION outcol;
+  JDIMENSION output_cols = compptr->width_in_blocks * DCTSIZE;
+  register JSAMPROW inptr0, inptr1, outptr;
+  register int bias;
+
+  /* Expand input data enough to let all the output samples be generated
+   * by the standard loop.  Special-casing padded output would be more
+   * efficient.
+   */
+  expand_right_edge(input_data, cinfo->max_v_samp_factor, cinfo->image_width,
+                    output_cols * 2);
+
+  inrow = 0;
+  for (outrow = 0; outrow < compptr->v_samp_factor; outrow++) {
+    outptr = output_data[outrow];
+    inptr0 = input_data[inrow];
+    inptr1 = input_data[inrow + 1];
+    bias = 1;                   /* bias = 1,2,1,2,... for successive samples */
+    for (outcol = 0; outcol < output_cols; outcol++) {
+      *outptr++ =
+        (JSAMPLE)((inptr0[0] + inptr0[1] + inptr1[0] + inptr1[1] + bias) >> 2);
+      bias ^= 3;                /* 1=>2, 2=>1 */
+      inptr0 += 2;  inptr1 += 2;
+    }
+    inrow += 2;
+  }
+}
+
+
+#ifdef INPUT_SMOOTHING_SUPPORTED
+
+/*
+ * Downsample pixel values of a single component.
+ * This version handles the standard case of 2:1 horizontal and 2:1 vertical,
+ * with smoothing.  One row of context is required.
+ */
+
+METHODDEF(void)
+h2v2_smooth_downsample(j_compress_ptr cinfo, jpeg_component_info *compptr,
+                       JSAMPARRAY input_data, JSAMPARRAY output_data)
+{
+  int inrow, outrow;
+  JDIMENSION colctr;
+  JDIMENSION output_cols = compptr->width_in_blocks * DCTSIZE;
+  register JSAMPROW inptr0, inptr1, above_ptr, below_ptr, outptr;
+  JLONG membersum, neighsum, memberscale, neighscale;
+
+  /* Expand input data enough to let all the output samples be generated
+   * by the standard loop.  Special-casing padded output would be more
+   * efficient.
+   */
+  expand_right_edge(input_data - 1, cinfo->max_v_samp_factor + 2,
+                    cinfo->image_width, output_cols * 2);
+
+  /* We don't bother to form the individual "smoothed" input pixel values;
+   * we can directly compute the output which is the average of the four
+   * smoothed values.  Each of the four member pixels contributes a fraction
+   * (1-8*SF) to its own smoothed image and a fraction SF to each of the three
+   * other smoothed pixels, therefore a total fraction (1-5*SF)/4 to the final
+   * output.  The four corner-adjacent neighbor pixels contribute a fraction
+   * SF to just one smoothed pixel, or SF/4 to the final output; while the
+   * eight edge-adjacent neighbors contribute SF to each of two smoothed
+   * pixels, or SF/2 overall.  In order to use integer arithmetic, these
+   * factors are scaled by 2^16 = 65536.
+   * Also recall that SF = smoothing_factor / 1024.
+   */
+
+  memberscale = 16384 - cinfo->smoothing_factor * 80; /* scaled (1-5*SF)/4 */
+  neighscale = cinfo->smoothing_factor * 16; /* scaled SF/4 */
+
+  inrow = 0;
+  for (outrow = 0; outrow < compptr->v_samp_factor; outrow++) {
+    outptr = output_data[outrow];
+    inptr0 = input_data[inrow];
+    inptr1 = input_data[inrow + 1];
+    above_ptr = input_data[inrow - 1];
+    below_ptr = input_data[inrow + 2];
+
+    /* Special case for first column: pretend column -1 is same as column 0 */
+    membersum = inptr0[0] + inptr0[1] + inptr1[0] + inptr1[1];
+    neighsum = above_ptr[0] + above_ptr[1] + below_ptr[0] + below_ptr[1] +
+               inptr0[0] + inptr0[2] + inptr1[0] + inptr1[2];
+    neighsum += neighsum;
+    neighsum += above_ptr[0] + above_ptr[2] + below_ptr[0] + below_ptr[2];
+    membersum = membersum * memberscale + neighsum * neighscale;
+    *outptr++ = (JSAMPLE)((membersum + 32768) >> 16);
+    inptr0 += 2;  inptr1 += 2;  above_ptr += 2;  below_ptr += 2;
+
+    for (colctr = output_cols - 2; colctr > 0; colctr--) {
+      /* sum of pixels directly mapped to this output element */
+      membersum = inptr0[0] + inptr0[1] + inptr1[0] + inptr1[1];
+      /* sum of edge-neighbor pixels */
+      neighsum = above_ptr[0] + above_ptr[1] + below_ptr[0] + below_ptr[1] +
+                 inptr0[-1] + inptr0[2] + inptr1[-1] + inptr1[2];
+      /* The edge-neighbors count twice as much as corner-neighbors */
+      neighsum += neighsum;
+      /* Add in the corner-neighbors */
+      neighsum += above_ptr[-1] + above_ptr[2] + below_ptr[-1] + below_ptr[2];
+      /* form final output scaled up by 2^16 */
+      membersum = membersum * memberscale + neighsum * neighscale;
+      /* round, descale and output it */
+      *outptr++ = (JSAMPLE)((membersum + 32768) >> 16);
+      inptr0 += 2;  inptr1 += 2;  above_ptr += 2;  below_ptr += 2;
+    }
+
+    /* Special case for last column */
+    membersum = inptr0[0] + inptr0[1] + inptr1[0] + inptr1[1];
+    neighsum = above_ptr[0] + above_ptr[1] + below_ptr[0] + below_ptr[1] +
+               inptr0[-1] + inptr0[1] + inptr1[-1] + inptr1[1];
+    neighsum += neighsum;
+    neighsum += above_ptr[-1] + above_ptr[1] + below_ptr[-1] + below_ptr[1];
+    membersum = membersum * memberscale + neighsum * neighscale;
+    *outptr = (JSAMPLE)((membersum + 32768) >> 16);
+
+    inrow += 2;
+  }
+}
+
+
+/*
+ * Downsample pixel values of a single component.
+ * This version handles the special case of a full-size component,
+ * with smoothing.  One row of context is required.
+ */
+
+METHODDEF(void)
+fullsize_smooth_downsample(j_compress_ptr cinfo, jpeg_component_info *compptr,
+                           JSAMPARRAY input_data, JSAMPARRAY output_data)
+{
+  int outrow;
+  JDIMENSION colctr;
+  JDIMENSION output_cols = compptr->width_in_blocks * DCTSIZE;
+  register JSAMPROW inptr, above_ptr, below_ptr, outptr;
+  JLONG membersum, neighsum, memberscale, neighscale;
+  int colsum, lastcolsum, nextcolsum;
+
+  /* Expand input data enough to let all the output samples be generated
+   * by the standard loop.  Special-casing padded output would be more
+   * efficient.
+   */
+  expand_right_edge(input_data - 1, cinfo->max_v_samp_factor + 2,
+                    cinfo->image_width, output_cols);
+
+  /* Each of the eight neighbor pixels contributes a fraction SF to the
+   * smoothed pixel, while the main pixel contributes (1-8*SF).  In order
+   * to use integer arithmetic, these factors are multiplied by 2^16 = 65536.
+   * Also recall that SF = smoothing_factor / 1024.
+   */
+
+  memberscale = 65536L - cinfo->smoothing_factor * 512L; /* scaled 1-8*SF */
+  neighscale = cinfo->smoothing_factor * 64; /* scaled SF */
+
+  for (outrow = 0; outrow < compptr->v_samp_factor; outrow++) {
+    outptr = output_data[outrow];
+    inptr = input_data[outrow];
+    above_ptr = input_data[outrow - 1];
+    below_ptr = input_data[outrow + 1];
+
+    /* Special case for first column */
+    colsum = (*above_ptr++) + (*below_ptr++) + inptr[0];
+    membersum = *inptr++;
+    nextcolsum = above_ptr[0] + below_ptr[0] + inptr[0];
+    neighsum = colsum + (colsum - membersum) + nextcolsum;
+    membersum = membersum * memberscale + neighsum * neighscale;
+    *outptr++ = (JSAMPLE)((membersum + 32768) >> 16);
+    lastcolsum = colsum;  colsum = nextcolsum;
+
+    for (colctr = output_cols - 2; colctr > 0; colctr--) {
+      membersum = *inptr++;
+      above_ptr++;  below_ptr++;
+      nextcolsum = above_ptr[0] + below_ptr[0] + inptr[0];
+      neighsum = lastcolsum + (colsum - membersum) + nextcolsum;
+      membersum = membersum * memberscale + neighsum * neighscale;
+      *outptr++ = (JSAMPLE)((membersum + 32768) >> 16);
+      lastcolsum = colsum;  colsum = nextcolsum;
+    }
+
+    /* Special case for last column */
+    membersum = *inptr;
+    neighsum = lastcolsum + (colsum - membersum) + colsum;
+    membersum = membersum * memberscale + neighsum * neighscale;
+    *outptr = (JSAMPLE)((membersum + 32768) >> 16);
+
+  }
+}
+
+#endif /* INPUT_SMOOTHING_SUPPORTED */
+
+
+/*
+ * Module initialization routine for downsampling.
+ * Note that we must select a routine for each component.
+ */
+
+GLOBAL(void)
+jinit_downsampler(j_compress_ptr cinfo)
+{
+  my_downsample_ptr downsample;
+  int ci;
+  jpeg_component_info *compptr;
+  boolean smoothok = TRUE;
+
+  downsample = (my_downsample_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+                                sizeof(my_downsampler));
+  cinfo->downsample = (struct jpeg_downsampler *)downsample;
+  downsample->pub.start_pass = start_pass_downsample;
+  downsample->pub.downsample = sep_downsample;
+  downsample->pub.need_context_rows = FALSE;
+
+  if (cinfo->CCIR601_sampling)
+    ERREXIT(cinfo, JERR_CCIR601_NOTIMPL);
+
+  /* Verify we can handle the sampling factors, and set up method pointers */
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    if (compptr->h_samp_factor == cinfo->max_h_samp_factor &&
+        compptr->v_samp_factor == cinfo->max_v_samp_factor) {
+#ifdef INPUT_SMOOTHING_SUPPORTED
+      if (cinfo->smoothing_factor) {
+        downsample->methods[ci] = fullsize_smooth_downsample;
+        downsample->pub.need_context_rows = TRUE;
+      } else
+#endif
+        downsample->methods[ci] = fullsize_downsample;
+    } else if (compptr->h_samp_factor * 2 == cinfo->max_h_samp_factor &&
+               compptr->v_samp_factor == cinfo->max_v_samp_factor) {
+      smoothok = FALSE;
+      if (jsimd_can_h2v1_downsample())
+        downsample->methods[ci] = jsimd_h2v1_downsample;
+      else
+        downsample->methods[ci] = h2v1_downsample;
+    } else if (compptr->h_samp_factor * 2 == cinfo->max_h_samp_factor &&
+               compptr->v_samp_factor * 2 == cinfo->max_v_samp_factor) {
+#ifdef INPUT_SMOOTHING_SUPPORTED
+      if (cinfo->smoothing_factor) {
+#if defined(__mips__)
+        if (jsimd_can_h2v2_smooth_downsample())
+          downsample->methods[ci] = jsimd_h2v2_smooth_downsample;
+        else
+#endif
+          downsample->methods[ci] = h2v2_smooth_downsample;
+        downsample->pub.need_context_rows = TRUE;
+      } else
+#endif
+      {
+        if (jsimd_can_h2v2_downsample())
+          downsample->methods[ci] = jsimd_h2v2_downsample;
+        else
+          downsample->methods[ci] = h2v2_downsample;
+      }
+    } else if ((cinfo->max_h_samp_factor % compptr->h_samp_factor) == 0 &&
+               (cinfo->max_v_samp_factor % compptr->v_samp_factor) == 0) {
+      smoothok = FALSE;
+      downsample->methods[ci] = int_downsample;
+    } else
+      ERREXIT(cinfo, JERR_FRACT_SAMPLE_NOTIMPL);
+  }
+
+#ifdef INPUT_SMOOTHING_SUPPORTED
+  if (cinfo->smoothing_factor && !smoothok)
+    TRACEMS(cinfo, 0, JTRC_SMOOTH_NOTIMPL);
+#endif
+}
diff --git a/3rdparty/libjpeg/src/jcstest.c b/3rdparty/libjpeg/src/jcstest.c
new file mode 100644
index 00000000..8b1fe380
--- /dev/null
+++ b/3rdparty/libjpeg/src/jcstest.c
@@ -0,0 +1,126 @@
+/*
+ * Copyright (C)2011 D. R. Commander.  All Rights Reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright notice,
+ *   this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright notice,
+ *   this list of conditions and the following disclaimer in the documentation
+ *   and/or other materials provided with the distribution.
+ * - Neither the name of the libjpeg-turbo Project nor the names of its
+ *   contributors may be used to endorse or promote products derived from this
+ *   software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE 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 HOLDERS 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.
+ */
+
+/* This program demonstrates how to check for the colorspace extension
+   capabilities of libjpeg-turbo at both compile time and run time. */
+
+#include <stdio.h>
+#include <jpeglib.h>
+#include <jerror.h>
+#include <setjmp.h>
+
+#ifndef JCS_EXTENSIONS
+#define JCS_EXT_RGB  6
+#endif
+#if !defined(JCS_EXTENSIONS) || !defined(JCS_ALPHA_EXTENSIONS)
+#define JCS_EXT_RGBA  12
+#endif
+
+static char lasterror[JMSG_LENGTH_MAX] = "No error";
+
+typedef struct _error_mgr {
+  struct jpeg_error_mgr pub;
+  jmp_buf jb;
+} error_mgr;
+
+static void my_error_exit(j_common_ptr cinfo)
+{
+  error_mgr *myerr = (error_mgr *)cinfo->err;
+  (*cinfo->err->output_message) (cinfo);
+  longjmp(myerr->jb, 1);
+}
+
+static void my_output_message(j_common_ptr cinfo)
+{
+  (*cinfo->err->format_message) (cinfo, lasterror);
+}
+
+int main(void)
+{
+  int jcs_valid = -1, jcs_alpha_valid = -1;
+  struct jpeg_compress_struct cinfo;
+  error_mgr jerr;
+
+  printf("libjpeg-turbo colorspace extensions:\n");
+#if JCS_EXTENSIONS
+  printf("  Present at compile time\n");
+#else
+  printf("  Not present at compile time\n");
+#endif
+
+  cinfo.err = jpeg_std_error(&jerr.pub);
+  jerr.pub.error_exit = my_error_exit;
+  jerr.pub.output_message = my_output_message;
+
+  if (setjmp(jerr.jb)) {
+    /* this will execute if libjpeg has an error */
+    jcs_valid = 0;
+    goto done;
+  }
+
+  jpeg_create_compress(&cinfo);
+  cinfo.input_components = 3;
+  jpeg_set_defaults(&cinfo);
+  cinfo.in_color_space = JCS_EXT_RGB;
+  jpeg_default_colorspace(&cinfo);
+  jcs_valid = 1;
+
+done:
+  if (jcs_valid)
+    printf("  Working properly\n");
+  else
+    printf("  Not working properly.  Error returned was:\n    %s\n",
+           lasterror);
+
+  printf("libjpeg-turbo alpha colorspace extensions:\n");
+#if JCS_ALPHA_EXTENSIONS
+  printf("  Present at compile time\n");
+#else
+  printf("  Not present at compile time\n");
+#endif
+
+  if (setjmp(jerr.jb)) {
+    /* this will execute if libjpeg has an error */
+    jcs_alpha_valid = 0;
+    goto done2;
+  }
+
+  cinfo.in_color_space = JCS_EXT_RGBA;
+  jpeg_default_colorspace(&cinfo);
+  jcs_alpha_valid = 1;
+
+done2:
+  if (jcs_alpha_valid)
+    printf("  Working properly\n");
+  else
+    printf("  Not working properly.  Error returned was:\n    %s\n",
+           lasterror);
+
+  jpeg_destroy_compress(&cinfo);
+  return 0;
+}
diff --git a/3rdparty/libjpeg/src/jctrans.c b/3rdparty/libjpeg/src/jctrans.c
new file mode 100644
index 00000000..ab6a2186
--- /dev/null
+++ b/3rdparty/libjpeg/src/jctrans.c
@@ -0,0 +1,401 @@
+/*
+ * jctrans.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1995-1998, Thomas G. Lane.
+ * Modified 2000-2009 by Guido Vollbeding.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2020, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains library routines for transcoding compression,
+ * that is, writing raw DCT coefficient arrays to an output JPEG file.
+ * The routines in jcapimin.c will also be needed by a transcoder.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jpegcomp.h"
+
+
+/* Forward declarations */
+LOCAL(void) transencode_master_selection(j_compress_ptr cinfo,
+                                         jvirt_barray_ptr *coef_arrays);
+LOCAL(void) transencode_coef_controller(j_compress_ptr cinfo,
+                                        jvirt_barray_ptr *coef_arrays);
+
+
+/*
+ * Compression initialization for writing raw-coefficient data.
+ * Before calling this, all parameters and a data destination must be set up.
+ * Call jpeg_finish_compress() to actually write the data.
+ *
+ * The number of passed virtual arrays must match cinfo->num_components.
+ * Note that the virtual arrays need not be filled or even realized at
+ * the time write_coefficients is called; indeed, if the virtual arrays
+ * were requested from this compression object's memory manager, they
+ * typically will be realized during this routine and filled afterwards.
+ */
+
+GLOBAL(void)
+jpeg_write_coefficients(j_compress_ptr cinfo, jvirt_barray_ptr *coef_arrays)
+{
+  if (cinfo->global_state != CSTATE_START)
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+  /* Mark all tables to be written */
+  jpeg_suppress_tables(cinfo, FALSE);
+  /* (Re)initialize error mgr and destination modules */
+  (*cinfo->err->reset_error_mgr) ((j_common_ptr)cinfo);
+  (*cinfo->dest->init_destination) (cinfo);
+  /* Perform master selection of active modules */
+  transencode_master_selection(cinfo, coef_arrays);
+  /* Wait for jpeg_finish_compress() call */
+  cinfo->next_scanline = 0;     /* so jpeg_write_marker works */
+  cinfo->global_state = CSTATE_WRCOEFS;
+}
+
+
+/*
+ * Initialize the compression object with default parameters,
+ * then copy from the source object all parameters needed for lossless
+ * transcoding.  Parameters that can be varied without loss (such as
+ * scan script and Huffman optimization) are left in their default states.
+ */
+
+GLOBAL(void)
+jpeg_copy_critical_parameters(j_decompress_ptr srcinfo, j_compress_ptr dstinfo)
+{
+  JQUANT_TBL **qtblptr;
+  jpeg_component_info *incomp, *outcomp;
+  JQUANT_TBL *c_quant, *slot_quant;
+  int tblno, ci, coefi;
+
+  /* Safety check to ensure start_compress not called yet. */
+  if (dstinfo->global_state != CSTATE_START)
+    ERREXIT1(dstinfo, JERR_BAD_STATE, dstinfo->global_state);
+  /* Copy fundamental image dimensions */
+  dstinfo->image_width = srcinfo->image_width;
+  dstinfo->image_height = srcinfo->image_height;
+  dstinfo->input_components = srcinfo->num_components;
+  dstinfo->in_color_space = srcinfo->jpeg_color_space;
+#if JPEG_LIB_VERSION >= 70
+  dstinfo->jpeg_width = srcinfo->output_width;
+  dstinfo->jpeg_height = srcinfo->output_height;
+  dstinfo->min_DCT_h_scaled_size = srcinfo->min_DCT_h_scaled_size;
+  dstinfo->min_DCT_v_scaled_size = srcinfo->min_DCT_v_scaled_size;
+#endif
+  /* Initialize all parameters to default values */
+  jpeg_set_defaults(dstinfo);
+  /* jpeg_set_defaults may choose wrong colorspace, eg YCbCr if input is RGB.
+   * Fix it to get the right header markers for the image colorspace.
+   */
+  jpeg_set_colorspace(dstinfo, srcinfo->jpeg_color_space);
+  dstinfo->data_precision = srcinfo->data_precision;
+  dstinfo->CCIR601_sampling = srcinfo->CCIR601_sampling;
+  /* Copy the source's quantization tables. */
+  for (tblno = 0; tblno < NUM_QUANT_TBLS; tblno++) {
+    if (srcinfo->quant_tbl_ptrs[tblno] != NULL) {
+      qtblptr = &dstinfo->quant_tbl_ptrs[tblno];
+      if (*qtblptr == NULL)
+        *qtblptr = jpeg_alloc_quant_table((j_common_ptr)dstinfo);
+      MEMCOPY((*qtblptr)->quantval, srcinfo->quant_tbl_ptrs[tblno]->quantval,
+              sizeof((*qtblptr)->quantval));
+      (*qtblptr)->sent_table = FALSE;
+    }
+  }
+  /* Copy the source's per-component info.
+   * Note we assume jpeg_set_defaults has allocated the dest comp_info array.
+   */
+  dstinfo->num_components = srcinfo->num_components;
+  if (dstinfo->num_components < 1 || dstinfo->num_components > MAX_COMPONENTS)
+    ERREXIT2(dstinfo, JERR_COMPONENT_COUNT, dstinfo->num_components,
+             MAX_COMPONENTS);
+  for (ci = 0, incomp = srcinfo->comp_info, outcomp = dstinfo->comp_info;
+       ci < dstinfo->num_components; ci++, incomp++, outcomp++) {
+    outcomp->component_id = incomp->component_id;
+    outcomp->h_samp_factor = incomp->h_samp_factor;
+    outcomp->v_samp_factor = incomp->v_samp_factor;
+    outcomp->quant_tbl_no = incomp->quant_tbl_no;
+    /* Make sure saved quantization table for component matches the qtable
+     * slot.  If not, the input file re-used this qtable slot.
+     * IJG encoder currently cannot duplicate this.
+     */
+    tblno = outcomp->quant_tbl_no;
+    if (tblno < 0 || tblno >= NUM_QUANT_TBLS ||
+        srcinfo->quant_tbl_ptrs[tblno] == NULL)
+      ERREXIT1(dstinfo, JERR_NO_QUANT_TABLE, tblno);
+    slot_quant = srcinfo->quant_tbl_ptrs[tblno];
+    c_quant = incomp->quant_table;
+    if (c_quant != NULL) {
+      for (coefi = 0; coefi < DCTSIZE2; coefi++) {
+        if (c_quant->quantval[coefi] != slot_quant->quantval[coefi])
+          ERREXIT1(dstinfo, JERR_MISMATCHED_QUANT_TABLE, tblno);
+      }
+    }
+    /* Note: we do not copy the source's Huffman table assignments;
+     * instead we rely on jpeg_set_colorspace to have made a suitable choice.
+     */
+  }
+  /* Also copy JFIF version and resolution information, if available.
+   * Strictly speaking this isn't "critical" info, but it's nearly
+   * always appropriate to copy it if available.  In particular,
+   * if the application chooses to copy JFIF 1.02 extension markers from
+   * the source file, we need to copy the version to make sure we don't
+   * emit a file that has 1.02 extensions but a claimed version of 1.01.
+   * We will *not*, however, copy version info from mislabeled "2.01" files.
+   */
+  if (srcinfo->saw_JFIF_marker) {
+    if (srcinfo->JFIF_major_version == 1) {
+      dstinfo->JFIF_major_version = srcinfo->JFIF_major_version;
+      dstinfo->JFIF_minor_version = srcinfo->JFIF_minor_version;
+    }
+    dstinfo->density_unit = srcinfo->density_unit;
+    dstinfo->X_density = srcinfo->X_density;
+    dstinfo->Y_density = srcinfo->Y_density;
+  }
+}
+
+
+/*
+ * Master selection of compression modules for transcoding.
+ * This substitutes for jcinit.c's initialization of the full compressor.
+ */
+
+LOCAL(void)
+transencode_master_selection(j_compress_ptr cinfo,
+                             jvirt_barray_ptr *coef_arrays)
+{
+  /* Although we don't actually use input_components for transcoding,
+   * jcmaster.c's initial_setup will complain if input_components is 0.
+   */
+  cinfo->input_components = 1;
+  /* Initialize master control (includes parameter checking/processing) */
+  jinit_c_master_control(cinfo, TRUE /* transcode only */);
+
+  /* Entropy encoding: either Huffman or arithmetic coding. */
+  if (cinfo->arith_code) {
+#ifdef C_ARITH_CODING_SUPPORTED
+    jinit_arith_encoder(cinfo);
+#else
+    ERREXIT(cinfo, JERR_ARITH_NOTIMPL);
+#endif
+  } else {
+    if (cinfo->progressive_mode) {
+#ifdef C_PROGRESSIVE_SUPPORTED
+      jinit_phuff_encoder(cinfo);
+#else
+      ERREXIT(cinfo, JERR_NOT_COMPILED);
+#endif
+    } else
+      jinit_huff_encoder(cinfo);
+  }
+
+  /* We need a special coefficient buffer controller. */
+  transencode_coef_controller(cinfo, coef_arrays);
+
+  jinit_marker_writer(cinfo);
+
+  /* We can now tell the memory manager to allocate virtual arrays. */
+  (*cinfo->mem->realize_virt_arrays) ((j_common_ptr)cinfo);
+
+  /* Write the datastream header (SOI, JFIF) immediately.
+   * Frame and scan headers are postponed till later.
+   * This lets application insert special markers after the SOI.
+   */
+  (*cinfo->marker->write_file_header) (cinfo);
+}
+
+
+/*
+ * The rest of this file is a special implementation of the coefficient
+ * buffer controller.  This is similar to jccoefct.c, but it handles only
+ * output from presupplied virtual arrays.  Furthermore, we generate any
+ * dummy padding blocks on-the-fly rather than expecting them to be present
+ * in the arrays.
+ */
+
+/* Private buffer controller object */
+
+typedef struct {
+  struct jpeg_c_coef_controller pub; /* public fields */
+
+  JDIMENSION iMCU_row_num;      /* iMCU row # within image */
+  JDIMENSION mcu_ctr;           /* counts MCUs processed in current row */
+  int MCU_vert_offset;          /* counts MCU rows within iMCU row */
+  int MCU_rows_per_iMCU_row;    /* number of such rows needed */
+
+  /* Virtual block array for each component. */
+  jvirt_barray_ptr *whole_image;
+
+  /* Workspace for constructing dummy blocks at right/bottom edges. */
+  JBLOCKROW dummy_buffer[C_MAX_BLOCKS_IN_MCU];
+} my_coef_controller;
+
+typedef my_coef_controller *my_coef_ptr;
+
+
+LOCAL(void)
+start_iMCU_row(j_compress_ptr cinfo)
+/* Reset within-iMCU-row counters for a new row */
+{
+  my_coef_ptr coef = (my_coef_ptr)cinfo->coef;
+
+  /* In an interleaved scan, an MCU row is the same as an iMCU row.
+   * In a noninterleaved scan, an iMCU row has v_samp_factor MCU rows.
+   * But at the bottom of the image, process only what's left.
+   */
+  if (cinfo->comps_in_scan > 1) {
+    coef->MCU_rows_per_iMCU_row = 1;
+  } else {
+    if (coef->iMCU_row_num < (cinfo->total_iMCU_rows - 1))
+      coef->MCU_rows_per_iMCU_row = cinfo->cur_comp_info[0]->v_samp_factor;
+    else
+      coef->MCU_rows_per_iMCU_row = cinfo->cur_comp_info[0]->last_row_height;
+  }
+
+  coef->mcu_ctr = 0;
+  coef->MCU_vert_offset = 0;
+}
+
+
+/*
+ * Initialize for a processing pass.
+ */
+
+METHODDEF(void)
+start_pass_coef(j_compress_ptr cinfo, J_BUF_MODE pass_mode)
+{
+  my_coef_ptr coef = (my_coef_ptr)cinfo->coef;
+
+  if (pass_mode != JBUF_CRANK_DEST)
+    ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+
+  coef->iMCU_row_num = 0;
+  start_iMCU_row(cinfo);
+}
+
+
+/*
+ * Process some data.
+ * We process the equivalent of one fully interleaved MCU row ("iMCU" row)
+ * per call, ie, v_samp_factor block rows for each component in the scan.
+ * The data is obtained from the virtual arrays and fed to the entropy coder.
+ * Returns TRUE if the iMCU row is completed, FALSE if suspended.
+ *
+ * NB: input_buf is ignored; it is likely to be a NULL pointer.
+ */
+
+METHODDEF(boolean)
+compress_output(j_compress_ptr cinfo, JSAMPIMAGE input_buf)
+{
+  my_coef_ptr coef = (my_coef_ptr)cinfo->coef;
+  JDIMENSION MCU_col_num;       /* index of current MCU within row */
+  JDIMENSION last_MCU_col = cinfo->MCUs_per_row - 1;
+  JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1;
+  int blkn, ci, xindex, yindex, yoffset, blockcnt;
+  JDIMENSION start_col;
+  JBLOCKARRAY buffer[MAX_COMPS_IN_SCAN];
+  JBLOCKROW MCU_buffer[C_MAX_BLOCKS_IN_MCU];
+  JBLOCKROW buffer_ptr;
+  jpeg_component_info *compptr;
+
+  /* Align the virtual buffers for the components used in this scan. */
+  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+    compptr = cinfo->cur_comp_info[ci];
+    buffer[ci] = (*cinfo->mem->access_virt_barray)
+      ((j_common_ptr)cinfo, coef->whole_image[compptr->component_index],
+       coef->iMCU_row_num * compptr->v_samp_factor,
+       (JDIMENSION)compptr->v_samp_factor, FALSE);
+  }
+
+  /* Loop to process one whole iMCU row */
+  for (yoffset = coef->MCU_vert_offset; yoffset < coef->MCU_rows_per_iMCU_row;
+       yoffset++) {
+    for (MCU_col_num = coef->mcu_ctr; MCU_col_num < cinfo->MCUs_per_row;
+         MCU_col_num++) {
+      /* Construct list of pointers to DCT blocks belonging to this MCU */
+      blkn = 0;                 /* index of current DCT block within MCU */
+      for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+        compptr = cinfo->cur_comp_info[ci];
+        start_col = MCU_col_num * compptr->MCU_width;
+        blockcnt = (MCU_col_num < last_MCU_col) ? compptr->MCU_width :
+                                                  compptr->last_col_width;
+        for (yindex = 0; yindex < compptr->MCU_height; yindex++) {
+          if (coef->iMCU_row_num < last_iMCU_row ||
+              yindex + yoffset < compptr->last_row_height) {
+            /* Fill in pointers to real blocks in this row */
+            buffer_ptr = buffer[ci][yindex + yoffset] + start_col;
+            for (xindex = 0; xindex < blockcnt; xindex++)
+              MCU_buffer[blkn++] = buffer_ptr++;
+          } else {
+            /* At bottom of image, need a whole row of dummy blocks */
+            xindex = 0;
+          }
+          /* Fill in any dummy blocks needed in this row.
+           * Dummy blocks are filled in the same way as in jccoefct.c:
+           * all zeroes in the AC entries, DC entries equal to previous
+           * block's DC value.  The init routine has already zeroed the
+           * AC entries, so we need only set the DC entries correctly.
+           */
+          for (; xindex < compptr->MCU_width; xindex++) {
+            MCU_buffer[blkn] = coef->dummy_buffer[blkn];
+            MCU_buffer[blkn][0][0] = MCU_buffer[blkn - 1][0][0];
+            blkn++;
+          }
+        }
+      }
+      /* Try to write the MCU. */
+      if (!(*cinfo->entropy->encode_mcu) (cinfo, MCU_buffer)) {
+        /* Suspension forced; update state counters and exit */
+        coef->MCU_vert_offset = yoffset;
+        coef->mcu_ctr = MCU_col_num;
+        return FALSE;
+      }
+    }
+    /* Completed an MCU row, but perhaps not an iMCU row */
+    coef->mcu_ctr = 0;
+  }
+  /* Completed the iMCU row, advance counters for next one */
+  coef->iMCU_row_num++;
+  start_iMCU_row(cinfo);
+  return TRUE;
+}
+
+
+/*
+ * Initialize coefficient buffer controller.
+ *
+ * Each passed coefficient array must be the right size for that
+ * coefficient: width_in_blocks wide and height_in_blocks high,
+ * with unitheight at least v_samp_factor.
+ */
+
+LOCAL(void)
+transencode_coef_controller(j_compress_ptr cinfo,
+                            jvirt_barray_ptr *coef_arrays)
+{
+  my_coef_ptr coef;
+  JBLOCKROW buffer;
+  int i;
+
+  coef = (my_coef_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+                                sizeof(my_coef_controller));
+  cinfo->coef = (struct jpeg_c_coef_controller *)coef;
+  coef->pub.start_pass = start_pass_coef;
+  coef->pub.compress_data = compress_output;
+
+  /* Save pointer to virtual arrays */
+  coef->whole_image = coef_arrays;
+
+  /* Allocate and pre-zero space for dummy DCT blocks. */
+  buffer = (JBLOCKROW)
+    (*cinfo->mem->alloc_large) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+                                C_MAX_BLOCKS_IN_MCU * sizeof(JBLOCK));
+  jzero_far((void *)buffer, C_MAX_BLOCKS_IN_MCU * sizeof(JBLOCK));
+  for (i = 0; i < C_MAX_BLOCKS_IN_MCU; i++) {
+    coef->dummy_buffer[i] = buffer + i;
+  }
+}
diff --git a/3rdparty/libjpeg/src/jdapimin.c b/3rdparty/libjpeg/src/jdapimin.c
new file mode 100644
index 00000000..21a41d2e
--- /dev/null
+++ b/3rdparty/libjpeg/src/jdapimin.c
@@ -0,0 +1,407 @@
+/*
+ * jdapimin.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1994-1998, Thomas G. Lane.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2016, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains application interface code for the decompression half
+ * of the JPEG library.  These are the "minimum" API routines that may be
+ * needed in either the normal full-decompression case or the
+ * transcoding-only case.
+ *
+ * Most of the routines intended to be called directly by an application
+ * are in this file or in jdapistd.c.  But also see jcomapi.c for routines
+ * shared by compression and decompression, and jdtrans.c for the transcoding
+ * case.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jdmaster.h"
+
+
+/*
+ * Initialization of a JPEG decompression object.
+ * The error manager must already be set up (in case memory manager fails).
+ */
+
+GLOBAL(void)
+jpeg_CreateDecompress(j_decompress_ptr cinfo, int version, size_t structsize)
+{
+  int i;
+
+  /* Guard against version mismatches between library and caller. */
+  cinfo->mem = NULL;            /* so jpeg_destroy knows mem mgr not called */
+  if (version != JPEG_LIB_VERSION)
+    ERREXIT2(cinfo, JERR_BAD_LIB_VERSION, JPEG_LIB_VERSION, version);
+  if (structsize != sizeof(struct jpeg_decompress_struct))
+    ERREXIT2(cinfo, JERR_BAD_STRUCT_SIZE,
+             (int)sizeof(struct jpeg_decompress_struct), (int)structsize);
+
+  /* For debugging purposes, we zero the whole master structure.
+   * But the application has already set the err pointer, and may have set
+   * client_data, so we have to save and restore those fields.
+   * Note: if application hasn't set client_data, tools like Purify may
+   * complain here.
+   */
+  {
+    struct jpeg_error_mgr *err = cinfo->err;
+    void *client_data = cinfo->client_data; /* ignore Purify complaint here */
+    MEMZERO(cinfo, sizeof(struct jpeg_decompress_struct));
+    cinfo->err = err;
+    cinfo->client_data = client_data;
+  }
+  cinfo->is_decompressor = TRUE;
+
+  /* Initialize a memory manager instance for this object */
+  jinit_memory_mgr((j_common_ptr)cinfo);
+
+  /* Zero out pointers to permanent structures. */
+  cinfo->progress = NULL;
+  cinfo->src = NULL;
+
+  for (i = 0; i < NUM_QUANT_TBLS; i++)
+    cinfo->quant_tbl_ptrs[i] = NULL;
+
+  for (i = 0; i < NUM_HUFF_TBLS; i++) {
+    cinfo->dc_huff_tbl_ptrs[i] = NULL;
+    cinfo->ac_huff_tbl_ptrs[i] = NULL;
+  }
+
+  /* Initialize marker processor so application can override methods
+   * for COM, APPn markers before calling jpeg_read_header.
+   */
+  cinfo->marker_list = NULL;
+  jinit_marker_reader(cinfo);
+
+  /* And initialize the overall input controller. */
+  jinit_input_controller(cinfo);
+
+  /* OK, I'm ready */
+  cinfo->global_state = DSTATE_START;
+
+  /* The master struct is used to store extension parameters, so we allocate it
+   * here.
+   */
+  cinfo->master = (struct jpeg_decomp_master *)
+    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_PERMANENT,
+                                sizeof(my_decomp_master));
+  MEMZERO(cinfo->master, sizeof(my_decomp_master));
+}
+
+
+/*
+ * Destruction of a JPEG decompression object
+ */
+
+GLOBAL(void)
+jpeg_destroy_decompress(j_decompress_ptr cinfo)
+{
+  jpeg_destroy((j_common_ptr)cinfo); /* use common routine */
+}
+
+
+/*
+ * Abort processing of a JPEG decompression operation,
+ * but don't destroy the object itself.
+ */
+
+GLOBAL(void)
+jpeg_abort_decompress(j_decompress_ptr cinfo)
+{
+  jpeg_abort((j_common_ptr)cinfo); /* use common routine */
+}
+
+
+/*
+ * Set default decompression parameters.
+ */
+
+LOCAL(void)
+default_decompress_parms(j_decompress_ptr cinfo)
+{
+  /* Guess the input colorspace, and set output colorspace accordingly. */
+  /* (Wish JPEG committee had provided a real way to specify this...) */
+  /* Note application may override our guesses. */
+  switch (cinfo->num_components) {
+  case 1:
+    cinfo->jpeg_color_space = JCS_GRAYSCALE;
+    cinfo->out_color_space = JCS_GRAYSCALE;
+    break;
+
+  case 3:
+    if (cinfo->saw_JFIF_marker) {
+      cinfo->jpeg_color_space = JCS_YCbCr; /* JFIF implies YCbCr */
+    } else if (cinfo->saw_Adobe_marker) {
+      switch (cinfo->Adobe_transform) {
+      case 0:
+        cinfo->jpeg_color_space = JCS_RGB;
+        break;
+      case 1:
+        cinfo->jpeg_color_space = JCS_YCbCr;
+        break;
+      default:
+        WARNMS1(cinfo, JWRN_ADOBE_XFORM, cinfo->Adobe_transform);
+        cinfo->jpeg_color_space = JCS_YCbCr; /* assume it's YCbCr */
+        break;
+      }
+    } else {
+      /* Saw no special markers, try to guess from the component IDs */
+      int cid0 = cinfo->comp_info[0].component_id;
+      int cid1 = cinfo->comp_info[1].component_id;
+      int cid2 = cinfo->comp_info[2].component_id;
+
+      if (cid0 == 1 && cid1 == 2 && cid2 == 3)
+        cinfo->jpeg_color_space = JCS_YCbCr; /* assume JFIF w/out marker */
+      else if (cid0 == 82 && cid1 == 71 && cid2 == 66)
+        cinfo->jpeg_color_space = JCS_RGB; /* ASCII 'R', 'G', 'B' */
+      else {
+        TRACEMS3(cinfo, 1, JTRC_UNKNOWN_IDS, cid0, cid1, cid2);
+        cinfo->jpeg_color_space = JCS_YCbCr; /* assume it's YCbCr */
+      }
+    }
+    /* Always guess RGB is proper output colorspace. */
+    cinfo->out_color_space = JCS_RGB;
+    break;
+
+  case 4:
+    if (cinfo->saw_Adobe_marker) {
+      switch (cinfo->Adobe_transform) {
+      case 0:
+        cinfo->jpeg_color_space = JCS_CMYK;
+        break;
+      case 2:
+        cinfo->jpeg_color_space = JCS_YCCK;
+        break;
+      default:
+        WARNMS1(cinfo, JWRN_ADOBE_XFORM, cinfo->Adobe_transform);
+        cinfo->jpeg_color_space = JCS_YCCK; /* assume it's YCCK */
+        break;
+      }
+    } else {
+      /* No special markers, assume straight CMYK. */
+      cinfo->jpeg_color_space = JCS_CMYK;
+    }
+    cinfo->out_color_space = JCS_CMYK;
+    break;
+
+  default:
+    cinfo->jpeg_color_space = JCS_UNKNOWN;
+    cinfo->out_color_space = JCS_UNKNOWN;
+    break;
+  }
+
+  /* Set defaults for other decompression parameters. */
+  cinfo->scale_num = 1;         /* 1:1 scaling */
+  cinfo->scale_denom = 1;
+  cinfo->output_gamma = 1.0;
+  cinfo->buffered_image = FALSE;
+  cinfo->raw_data_out = FALSE;
+  cinfo->dct_method = JDCT_DEFAULT;
+  cinfo->do_fancy_upsampling = TRUE;
+  cinfo->do_block_smoothing = TRUE;
+  cinfo->quantize_colors = FALSE;
+  /* We set these in case application only sets quantize_colors. */
+  cinfo->dither_mode = JDITHER_FS;
+#ifdef QUANT_2PASS_SUPPORTED
+  cinfo->two_pass_quantize = TRUE;
+#else
+  cinfo->two_pass_quantize = FALSE;
+#endif
+  cinfo->desired_number_of_colors = 256;
+  cinfo->colormap = NULL;
+  /* Initialize for no mode change in buffered-image mode. */
+  cinfo->enable_1pass_quant = FALSE;
+  cinfo->enable_external_quant = FALSE;
+  cinfo->enable_2pass_quant = FALSE;
+}
+
+
+/*
+ * Decompression startup: read start of JPEG datastream to see what's there.
+ * Need only initialize JPEG object and supply a data source before calling.
+ *
+ * This routine will read as far as the first SOS marker (ie, actual start of
+ * compressed data), and will save all tables and parameters in the JPEG
+ * object.  It will also initialize the decompression parameters to default
+ * values, and finally return JPEG_HEADER_OK.  On return, the application may
+ * adjust the decompression parameters and then call jpeg_start_decompress.
+ * (Or, if the application only wanted to determine the image parameters,
+ * the data need not be decompressed.  In that case, call jpeg_abort or
+ * jpeg_destroy to release any temporary space.)
+ * If an abbreviated (tables only) datastream is presented, the routine will
+ * return JPEG_HEADER_TABLES_ONLY upon reaching EOI.  The application may then
+ * re-use the JPEG object to read the abbreviated image datastream(s).
+ * It is unnecessary (but OK) to call jpeg_abort in this case.
+ * The JPEG_SUSPENDED return code only occurs if the data source module
+ * requests suspension of the decompressor.  In this case the application
+ * should load more source data and then re-call jpeg_read_header to resume
+ * processing.
+ * If a non-suspending data source is used and require_image is TRUE, then the
+ * return code need not be inspected since only JPEG_HEADER_OK is possible.
+ *
+ * This routine is now just a front end to jpeg_consume_input, with some
+ * extra error checking.
+ */
+
+GLOBAL(int)
+jpeg_read_header(j_decompress_ptr cinfo, boolean require_image)
+{
+  int retcode;
+
+  if (cinfo->global_state != DSTATE_START &&
+      cinfo->global_state != DSTATE_INHEADER)
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+
+  retcode = jpeg_consume_input(cinfo);
+
+  switch (retcode) {
+  case JPEG_REACHED_SOS:
+    retcode = JPEG_HEADER_OK;
+    break;
+  case JPEG_REACHED_EOI:
+    if (require_image)          /* Complain if application wanted an image */
+      ERREXIT(cinfo, JERR_NO_IMAGE);
+    /* Reset to start state; it would be safer to require the application to
+     * call jpeg_abort, but we can't change it now for compatibility reasons.
+     * A side effect is to free any temporary memory (there shouldn't be any).
+     */
+    jpeg_abort((j_common_ptr)cinfo); /* sets state = DSTATE_START */
+    retcode = JPEG_HEADER_TABLES_ONLY;
+    break;
+  case JPEG_SUSPENDED:
+    /* no work */
+    break;
+  }
+
+  return retcode;
+}
+
+
+/*
+ * Consume data in advance of what the decompressor requires.
+ * This can be called at any time once the decompressor object has
+ * been created and a data source has been set up.
+ *
+ * This routine is essentially a state machine that handles a couple
+ * of critical state-transition actions, namely initial setup and
+ * transition from header scanning to ready-for-start_decompress.
+ * All the actual input is done via the input controller's consume_input
+ * method.
+ */
+
+GLOBAL(int)
+jpeg_consume_input(j_decompress_ptr cinfo)
+{
+  int retcode = JPEG_SUSPENDED;
+
+  /* NB: every possible DSTATE value should be listed in this switch */
+  switch (cinfo->global_state) {
+  case DSTATE_START:
+    /* Start-of-datastream actions: reset appropriate modules */
+    (*cinfo->inputctl->reset_input_controller) (cinfo);
+    /* Initialize application's data source module */
+    (*cinfo->src->init_source) (cinfo);
+    cinfo->global_state = DSTATE_INHEADER;
+    /*FALLTHROUGH*/
+  case DSTATE_INHEADER:
+    retcode = (*cinfo->inputctl->consume_input) (cinfo);
+    if (retcode == JPEG_REACHED_SOS) { /* Found SOS, prepare to decompress */
+      /* Set up default parameters based on header data */
+      default_decompress_parms(cinfo);
+      /* Set global state: ready for start_decompress */
+      cinfo->global_state = DSTATE_READY;
+    }
+    break;
+  case DSTATE_READY:
+    /* Can't advance past first SOS until start_decompress is called */
+    retcode = JPEG_REACHED_SOS;
+    break;
+  case DSTATE_PRELOAD:
+  case DSTATE_PRESCAN:
+  case DSTATE_SCANNING:
+  case DSTATE_RAW_OK:
+  case DSTATE_BUFIMAGE:
+  case DSTATE_BUFPOST:
+  case DSTATE_STOPPING:
+    retcode = (*cinfo->inputctl->consume_input) (cinfo);
+    break;
+  default:
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+  }
+  return retcode;
+}
+
+
+/*
+ * Have we finished reading the input file?
+ */
+
+GLOBAL(boolean)
+jpeg_input_complete(j_decompress_ptr cinfo)
+{
+  /* Check for valid jpeg object */
+  if (cinfo->global_state < DSTATE_START ||
+      cinfo->global_state > DSTATE_STOPPING)
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+  return cinfo->inputctl->eoi_reached;
+}
+
+
+/*
+ * Is there more than one scan?
+ */
+
+GLOBAL(boolean)
+jpeg_has_multiple_scans(j_decompress_ptr cinfo)
+{
+  /* Only valid after jpeg_read_header completes */
+  if (cinfo->global_state < DSTATE_READY ||
+      cinfo->global_state > DSTATE_STOPPING)
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+  return cinfo->inputctl->has_multiple_scans;
+}
+
+
+/*
+ * Finish JPEG decompression.
+ *
+ * This will normally just verify the file trailer and release temp storage.
+ *
+ * Returns FALSE if suspended.  The return value need be inspected only if
+ * a suspending data source is used.
+ */
+
+GLOBAL(boolean)
+jpeg_finish_decompress(j_decompress_ptr cinfo)
+{
+  if ((cinfo->global_state == DSTATE_SCANNING ||
+       cinfo->global_state == DSTATE_RAW_OK) && !cinfo->buffered_image) {
+    /* Terminate final pass of non-buffered mode */
+    if (cinfo->output_scanline < cinfo->output_height)
+      ERREXIT(cinfo, JERR_TOO_LITTLE_DATA);
+    (*cinfo->master->finish_output_pass) (cinfo);
+    cinfo->global_state = DSTATE_STOPPING;
+  } else if (cinfo->global_state == DSTATE_BUFIMAGE) {
+    /* Finishing after a buffered-image operation */
+    cinfo->global_state = DSTATE_STOPPING;
+  } else if (cinfo->global_state != DSTATE_STOPPING) {
+    /* STOPPING = repeat call after a suspension, anything else is error */
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+  }
+  /* Read until EOI */
+  while (!cinfo->inputctl->eoi_reached) {
+    if ((*cinfo->inputctl->consume_input) (cinfo) == JPEG_SUSPENDED)
+      return FALSE;             /* Suspend, come back later */
+  }
+  /* Do final cleanup */
+  (*cinfo->src->term_source) (cinfo);
+  /* We can use jpeg_abort to release memory and reset global_state */
+  jpeg_abort((j_common_ptr)cinfo);
+  return TRUE;
+}
diff --git a/3rdparty/libjpeg/src/jdapistd.c b/3rdparty/libjpeg/src/jdapistd.c
new file mode 100644
index 00000000..695a6200
--- /dev/null
+++ b/3rdparty/libjpeg/src/jdapistd.c
@@ -0,0 +1,674 @@
+/*
+ * jdapistd.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1994-1996, Thomas G. Lane.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2010, 2015-2020, D. R. Commander.
+ * Copyright (C) 2015, Google, Inc.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains application interface code for the decompression half
+ * of the JPEG library.  These are the "standard" API routines that are
+ * used in the normal full-decompression case.  They are not used by a
+ * transcoding-only application.  Note that if an application links in
+ * jpeg_start_decompress, it will end up linking in the entire decompressor.
+ * We thus must separate this file from jdapimin.c to avoid linking the
+ * whole decompression library into a transcoder.
+ */
+
+#include "jinclude.h"
+#include "jdmainct.h"
+#include "jdcoefct.h"
+#include "jdmaster.h"
+#include "jdmerge.h"
+#include "jdsample.h"
+#include "jmemsys.h"
+
+/* Forward declarations */
+LOCAL(boolean) output_pass_setup(j_decompress_ptr cinfo);
+
+
+/*
+ * Decompression initialization.
+ * jpeg_read_header must be completed before calling this.
+ *
+ * If a multipass operating mode was selected, this will do all but the
+ * last pass, and thus may take a great deal of time.
+ *
+ * Returns FALSE if suspended.  The return value need be inspected only if
+ * a suspending data source is used.
+ */
+
+GLOBAL(boolean)
+jpeg_start_decompress(j_decompress_ptr cinfo)
+{
+  if (cinfo->global_state == DSTATE_READY) {
+    /* First call: initialize master control, select active modules */
+    jinit_master_decompress(cinfo);
+    if (cinfo->buffered_image) {
+      /* No more work here; expecting jpeg_start_output next */
+      cinfo->global_state = DSTATE_BUFIMAGE;
+      return TRUE;
+    }
+    cinfo->global_state = DSTATE_PRELOAD;
+  }
+  if (cinfo->global_state == DSTATE_PRELOAD) {
+    /* If file has multiple scans, absorb them all into the coef buffer */
+    if (cinfo->inputctl->has_multiple_scans) {
+#ifdef D_MULTISCAN_FILES_SUPPORTED
+      for (;;) {
+        int retcode;
+        /* Call progress monitor hook if present */
+        if (cinfo->progress != NULL)
+          (*cinfo->progress->progress_monitor) ((j_common_ptr)cinfo);
+        /* Absorb some more input */
+        retcode = (*cinfo->inputctl->consume_input) (cinfo);
+        if (retcode == JPEG_SUSPENDED)
+          return FALSE;
+        if (retcode == JPEG_REACHED_EOI)
+          break;
+        /* Advance progress counter if appropriate */
+        if (cinfo->progress != NULL &&
+            (retcode == JPEG_ROW_COMPLETED || retcode == JPEG_REACHED_SOS)) {
+          if (++cinfo->progress->pass_counter >= cinfo->progress->pass_limit) {
+            /* jdmaster underestimated number of scans; ratchet up one scan */
+            cinfo->progress->pass_limit += (long)cinfo->total_iMCU_rows;
+          }
+        }
+      }
+#else
+      ERREXIT(cinfo, JERR_NOT_COMPILED);
+#endif /* D_MULTISCAN_FILES_SUPPORTED */
+    }
+    cinfo->output_scan_number = cinfo->input_scan_number;
+  } else if (cinfo->global_state != DSTATE_PRESCAN)
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+  /* Perform any dummy output passes, and set up for the final pass */
+  return output_pass_setup(cinfo);
+}
+
+
+/*
+ * Set up for an output pass, and perform any dummy pass(es) needed.
+ * Common subroutine for jpeg_start_decompress and jpeg_start_output.
+ * Entry: global_state = DSTATE_PRESCAN only if previously suspended.
+ * Exit: If done, returns TRUE and sets global_state for proper output mode.
+ *       If suspended, returns FALSE and sets global_state = DSTATE_PRESCAN.
+ */
+
+LOCAL(boolean)
+output_pass_setup(j_decompress_ptr cinfo)
+{
+  if (cinfo->global_state != DSTATE_PRESCAN) {
+    /* First call: do pass setup */
+    (*cinfo->master->prepare_for_output_pass) (cinfo);
+    cinfo->output_scanline = 0;
+    cinfo->global_state = DSTATE_PRESCAN;
+  }
+  /* Loop over any required dummy passes */
+  while (cinfo->master->is_dummy_pass) {
+#ifdef QUANT_2PASS_SUPPORTED
+    /* Crank through the dummy pass */
+    while (cinfo->output_scanline < cinfo->output_height) {
+      JDIMENSION last_scanline;
+      /* Call progress monitor hook if present */
+      if (cinfo->progress != NULL) {
+        cinfo->progress->pass_counter = (long)cinfo->output_scanline;
+        cinfo->progress->pass_limit = (long)cinfo->output_height;
+        (*cinfo->progress->progress_monitor) ((j_common_ptr)cinfo);
+      }
+      /* Process some data */
+      last_scanline = cinfo->output_scanline;
+      (*cinfo->main->process_data) (cinfo, (JSAMPARRAY)NULL,
+                                    &cinfo->output_scanline, (JDIMENSION)0);
+      if (cinfo->output_scanline == last_scanline)
+        return FALSE;           /* No progress made, must suspend */
+    }
+    /* Finish up dummy pass, and set up for another one */
+    (*cinfo->master->finish_output_pass) (cinfo);
+    (*cinfo->master->prepare_for_output_pass) (cinfo);
+    cinfo->output_scanline = 0;
+#else
+    ERREXIT(cinfo, JERR_NOT_COMPILED);
+#endif /* QUANT_2PASS_SUPPORTED */
+  }
+  /* Ready for application to drive output pass through
+   * jpeg_read_scanlines or jpeg_read_raw_data.
+   */
+  cinfo->global_state = cinfo->raw_data_out ? DSTATE_RAW_OK : DSTATE_SCANNING;
+  return TRUE;
+}
+
+
+/*
+ * Enable partial scanline decompression
+ *
+ * Must be called after jpeg_start_decompress() and before any calls to
+ * jpeg_read_scanlines() or jpeg_skip_scanlines().
+ *
+ * Refer to libjpeg.txt for more information.
+ */
+
+GLOBAL(void)
+jpeg_crop_scanline(j_decompress_ptr cinfo, JDIMENSION *xoffset,
+                   JDIMENSION *width)
+{
+  int ci, align, orig_downsampled_width;
+  JDIMENSION input_xoffset;
+  boolean reinit_upsampler = FALSE;
+  jpeg_component_info *compptr;
+
+  if (cinfo->global_state != DSTATE_SCANNING || cinfo->output_scanline != 0)
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+
+  if (!xoffset || !width)
+    ERREXIT(cinfo, JERR_BAD_CROP_SPEC);
+
+  /* xoffset and width must fall within the output image dimensions. */
+  if (*width == 0 || *xoffset + *width > cinfo->output_width)
+    ERREXIT(cinfo, JERR_WIDTH_OVERFLOW);
+
+  /* No need to do anything if the caller wants the entire width. */
+  if (*width == cinfo->output_width)
+    return;
+
+  /* Ensuring the proper alignment of xoffset is tricky.  At minimum, it
+   * must align with an MCU boundary, because:
+   *
+   *   (1) The IDCT is performed in blocks, and it is not feasible to modify
+   *       the algorithm so that it can transform partial blocks.
+   *   (2) Because of the SIMD extensions, any input buffer passed to the
+   *       upsampling and color conversion routines must be aligned to the
+   *       SIMD word size (for instance, 128-bit in the case of SSE2.)  The
+   *       easiest way to accomplish this without copying data is to ensure
+   *       that upsampling and color conversion begin at the start of the
+   *       first MCU column that will be inverse transformed.
+   *
+   * In practice, we actually impose a stricter alignment requirement.  We
+   * require that xoffset be a multiple of the maximum MCU column width of all
+   * of the components (the "iMCU column width.")  This is to simplify the
+   * single-pass decompression case, allowing us to use the same MCU column
+   * width for all of the components.
+   */
+  if (cinfo->comps_in_scan == 1 && cinfo->num_components == 1)
+    align = cinfo->_min_DCT_scaled_size;
+  else
+    align = cinfo->_min_DCT_scaled_size * cinfo->max_h_samp_factor;
+
+  /* Adjust xoffset to the nearest iMCU boundary <= the requested value */
+  input_xoffset = *xoffset;
+  *xoffset = (input_xoffset / align) * align;
+
+  /* Adjust the width so that the right edge of the output image is as
+   * requested (only the left edge is altered.)  It is important that calling
+   * programs check this value after this function returns, so that they can
+   * allocate an output buffer with the appropriate size.
+   */
+  *width = *width + input_xoffset - *xoffset;
+  cinfo->output_width = *width;
+
+  /* Set the first and last iMCU columns that we must decompress.  These values
+   * will be used in single-scan decompressions.
+   */
+  cinfo->master->first_iMCU_col = (JDIMENSION)(long)(*xoffset) / (long)align;
+  cinfo->master->last_iMCU_col =
+    (JDIMENSION)jdiv_round_up((long)(*xoffset + cinfo->output_width),
+                              (long)align) - 1;
+
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    int hsf = (cinfo->comps_in_scan == 1 && cinfo->num_components == 1) ?
+              1 : compptr->h_samp_factor;
+
+    /* Set downsampled_width to the new output width. */
+    orig_downsampled_width = compptr->downsampled_width;
+    compptr->downsampled_width =
+      (JDIMENSION)jdiv_round_up((long)(cinfo->output_width *
+                                       compptr->h_samp_factor),
+                                (long)cinfo->max_h_samp_factor);
+    if (compptr->downsampled_width < 2 && orig_downsampled_width >= 2)
+      reinit_upsampler = TRUE;
+
+    /* Set the first and last iMCU columns that we must decompress.  These
+     * values will be used in multi-scan decompressions.
+     */
+    cinfo->master->first_MCU_col[ci] =
+      (JDIMENSION)(long)(*xoffset * hsf) / (long)align;
+    cinfo->master->last_MCU_col[ci] =
+      (JDIMENSION)jdiv_round_up((long)((*xoffset + cinfo->output_width) * hsf),
+                                (long)align) - 1;
+  }
+
+  if (reinit_upsampler) {
+    cinfo->master->jinit_upsampler_no_alloc = TRUE;
+    jinit_upsampler(cinfo);
+    cinfo->master->jinit_upsampler_no_alloc = FALSE;
+  }
+}
+
+
+/*
+ * Read some scanlines of data from the JPEG decompressor.
+ *
+ * The return value will be the number of lines actually read.
+ * This may be less than the number requested in several cases,
+ * including bottom of image, data source suspension, and operating
+ * modes that emit multiple scanlines at a time.
+ *
+ * Note: we warn about excess calls to jpeg_read_scanlines() since
+ * this likely signals an application programmer error.  However,
+ * an oversize buffer (max_lines > scanlines remaining) is not an error.
+ */
+
+GLOBAL(JDIMENSION)
+jpeg_read_scanlines(j_decompress_ptr cinfo, JSAMPARRAY scanlines,
+                    JDIMENSION max_lines)
+{
+  JDIMENSION row_ctr;
+
+  if (cinfo->global_state != DSTATE_SCANNING)
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+  if (cinfo->output_scanline >= cinfo->output_height) {
+    WARNMS(cinfo, JWRN_TOO_MUCH_DATA);
+    return 0;
+  }
+
+  /* Call progress monitor hook if present */
+  if (cinfo->progress != NULL) {
+    cinfo->progress->pass_counter = (long)cinfo->output_scanline;
+    cinfo->progress->pass_limit = (long)cinfo->output_height;
+    (*cinfo->progress->progress_monitor) ((j_common_ptr)cinfo);
+  }
+
+  /* Process some data */
+  row_ctr = 0;
+  (*cinfo->main->process_data) (cinfo, scanlines, &row_ctr, max_lines);
+  cinfo->output_scanline += row_ctr;
+  return row_ctr;
+}
+
+
+/* Dummy color convert function used by jpeg_skip_scanlines() */
+LOCAL(void)
+noop_convert(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
+             JDIMENSION input_row, JSAMPARRAY output_buf, int num_rows)
+{
+}
+
+
+/* Dummy quantize function used by jpeg_skip_scanlines() */
+LOCAL(void)
+noop_quantize(j_decompress_ptr cinfo, JSAMPARRAY input_buf,
+              JSAMPARRAY output_buf, int num_rows)
+{
+}
+
+
+/*
+ * In some cases, it is best to call jpeg_read_scanlines() and discard the
+ * output, rather than skipping the scanlines, because this allows us to
+ * maintain the internal state of the context-based upsampler.  In these cases,
+ * we set up and tear down a dummy color converter in order to avoid valgrind
+ * errors and to achieve the best possible performance.
+ */
+
+LOCAL(void)
+read_and_discard_scanlines(j_decompress_ptr cinfo, JDIMENSION num_lines)
+{
+  JDIMENSION n;
+  my_master_ptr master = (my_master_ptr)cinfo->master;
+  JSAMPLE dummy_sample[1] = { 0 };
+  JSAMPROW dummy_row = dummy_sample;
+  JSAMPARRAY scanlines = NULL;
+  void (*color_convert) (j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
+                         JDIMENSION input_row, JSAMPARRAY output_buf,
+                         int num_rows) = NULL;
+  void (*color_quantize) (j_decompress_ptr cinfo, JSAMPARRAY input_buf,
+                          JSAMPARRAY output_buf, int num_rows) = NULL;
+
+  if (cinfo->cconvert && cinfo->cconvert->color_convert) {
+    color_convert = cinfo->cconvert->color_convert;
+    cinfo->cconvert->color_convert = noop_convert;
+    /* This just prevents UBSan from complaining about adding 0 to a NULL
+     * pointer.  The pointer isn't actually used.
+     */
+    scanlines = &dummy_row;
+  }
+
+  if (cinfo->cquantize && cinfo->cquantize->color_quantize) {
+    color_quantize = cinfo->cquantize->color_quantize;
+    cinfo->cquantize->color_quantize = noop_quantize;
+  }
+
+  if (master->using_merged_upsample && cinfo->max_v_samp_factor == 2) {
+    my_merged_upsample_ptr upsample = (my_merged_upsample_ptr)cinfo->upsample;
+    scanlines = &upsample->spare_row;
+  }
+
+  for (n = 0; n < num_lines; n++)
+    jpeg_read_scanlines(cinfo, scanlines, 1);
+
+  if (color_convert)
+    cinfo->cconvert->color_convert = color_convert;
+
+  if (color_quantize)
+    cinfo->cquantize->color_quantize = color_quantize;
+}
+
+
+/*
+ * Called by jpeg_skip_scanlines().  This partially skips a decompress block by
+ * incrementing the rowgroup counter.
+ */
+
+LOCAL(void)
+increment_simple_rowgroup_ctr(j_decompress_ptr cinfo, JDIMENSION rows)
+{
+  JDIMENSION rows_left;
+  my_main_ptr main_ptr = (my_main_ptr)cinfo->main;
+  my_master_ptr master = (my_master_ptr)cinfo->master;
+
+  if (master->using_merged_upsample && cinfo->max_v_samp_factor == 2) {
+    read_and_discard_scanlines(cinfo, rows);
+    return;
+  }
+
+  /* Increment the counter to the next row group after the skipped rows. */
+  main_ptr->rowgroup_ctr += rows / cinfo->max_v_samp_factor;
+
+  /* Partially skipping a row group would involve modifying the internal state
+   * of the upsampler, so read the remaining rows into a dummy buffer instead.
+   */
+  rows_left = rows % cinfo->max_v_samp_factor;
+  cinfo->output_scanline += rows - rows_left;
+
+  read_and_discard_scanlines(cinfo, rows_left);
+}
+
+/*
+ * Skips some scanlines of data from the JPEG decompressor.
+ *
+ * The return value will be the number of lines actually skipped.  If skipping
+ * num_lines would move beyond the end of the image, then the actual number of
+ * lines remaining in the image is returned.  Otherwise, the return value will
+ * be equal to num_lines.
+ *
+ * Refer to libjpeg.txt for more information.
+ */
+
+GLOBAL(JDIMENSION)
+jpeg_skip_scanlines(j_decompress_ptr cinfo, JDIMENSION num_lines)
+{
+  my_main_ptr main_ptr = (my_main_ptr)cinfo->main;
+  my_coef_ptr coef = (my_coef_ptr)cinfo->coef;
+  my_master_ptr master = (my_master_ptr)cinfo->master;
+  my_upsample_ptr upsample = (my_upsample_ptr)cinfo->upsample;
+  JDIMENSION i, x;
+  int y;
+  JDIMENSION lines_per_iMCU_row, lines_left_in_iMCU_row, lines_after_iMCU_row;
+  JDIMENSION lines_to_skip, lines_to_read;
+
+  /* Two-pass color quantization is not supported. */
+  if (cinfo->quantize_colors && cinfo->two_pass_quantize)
+    ERREXIT(cinfo, JERR_NOTIMPL);
+
+  if (cinfo->global_state != DSTATE_SCANNING)
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+
+  /* Do not skip past the bottom of the image. */
+  if (cinfo->output_scanline + num_lines >= cinfo->output_height) {
+    num_lines = cinfo->output_height - cinfo->output_scanline;
+    cinfo->output_scanline = cinfo->output_height;
+    (*cinfo->inputctl->finish_input_pass) (cinfo);
+    cinfo->inputctl->eoi_reached = TRUE;
+    return num_lines;
+  }
+
+  if (num_lines == 0)
+    return 0;
+
+  lines_per_iMCU_row = cinfo->_min_DCT_scaled_size * cinfo->max_v_samp_factor;
+  lines_left_in_iMCU_row =
+    (lines_per_iMCU_row - (cinfo->output_scanline % lines_per_iMCU_row)) %
+    lines_per_iMCU_row;
+  lines_after_iMCU_row = num_lines - lines_left_in_iMCU_row;
+
+  /* Skip the lines remaining in the current iMCU row.  When upsampling
+   * requires context rows, we need the previous and next rows in order to read
+   * the current row.  This adds some complexity.
+   */
+  if (cinfo->upsample->need_context_rows) {
+    /* If the skipped lines would not move us past the current iMCU row, we
+     * read the lines and ignore them.  There might be a faster way of doing
+     * this, but we are facing increasing complexity for diminishing returns.
+     * The increasing complexity would be a by-product of meddling with the
+     * state machine used to skip context rows.  Near the end of an iMCU row,
+     * the next iMCU row may have already been entropy-decoded.  In this unique
+     * case, we will read the next iMCU row if we cannot skip past it as well.
+     */
+    if ((num_lines < lines_left_in_iMCU_row + 1) ||
+        (lines_left_in_iMCU_row <= 1 && main_ptr->buffer_full &&
+         lines_after_iMCU_row < lines_per_iMCU_row + 1)) {
+      read_and_discard_scanlines(cinfo, num_lines);
+      return num_lines;
+    }
+
+    /* If the next iMCU row has already been entropy-decoded, make sure that
+     * we do not skip too far.
+     */
+    if (lines_left_in_iMCU_row <= 1 && main_ptr->buffer_full) {
+      cinfo->output_scanline += lines_left_in_iMCU_row + lines_per_iMCU_row;
+      lines_after_iMCU_row -= lines_per_iMCU_row;
+    } else {
+      cinfo->output_scanline += lines_left_in_iMCU_row;
+    }
+
+    /* If we have just completed the first block, adjust the buffer pointers */
+    if (main_ptr->iMCU_row_ctr == 0 ||
+        (main_ptr->iMCU_row_ctr == 1 && lines_left_in_iMCU_row > 2))
+      set_wraparound_pointers(cinfo);
+    main_ptr->buffer_full = FALSE;
+    main_ptr->rowgroup_ctr = 0;
+    main_ptr->context_state = CTX_PREPARE_FOR_IMCU;
+    if (!master->using_merged_upsample) {
+      upsample->next_row_out = cinfo->max_v_samp_factor;
+      upsample->rows_to_go = cinfo->output_height - cinfo->output_scanline;
+    }
+  }
+
+  /* Skipping is much simpler when context rows are not required. */
+  else {
+    if (num_lines < lines_left_in_iMCU_row) {
+      increment_simple_rowgroup_ctr(cinfo, num_lines);
+      return num_lines;
+    } else {
+      cinfo->output_scanline += lines_left_in_iMCU_row;
+      main_ptr->buffer_full = FALSE;
+      main_ptr->rowgroup_ctr = 0;
+      if (!master->using_merged_upsample) {
+        upsample->next_row_out = cinfo->max_v_samp_factor;
+        upsample->rows_to_go = cinfo->output_height - cinfo->output_scanline;
+      }
+    }
+  }
+
+  /* Calculate how many full iMCU rows we can skip. */
+  if (cinfo->upsample->need_context_rows)
+    lines_to_skip = ((lines_after_iMCU_row - 1) / lines_per_iMCU_row) *
+                    lines_per_iMCU_row;
+  else
+    lines_to_skip = (lines_after_iMCU_row / lines_per_iMCU_row) *
+                    lines_per_iMCU_row;
+  /* Calculate the number of lines that remain to be skipped after skipping all
+   * of the full iMCU rows that we can.  We will not read these lines unless we
+   * have to.
+   */
+  lines_to_read = lines_after_iMCU_row - lines_to_skip;
+
+  /* For images requiring multiple scans (progressive, non-interleaved, etc.),
+   * all of the entropy decoding occurs in jpeg_start_decompress(), assuming
+   * that the input data source is non-suspending.  This makes skipping easy.
+   */
+  if (cinfo->inputctl->has_multiple_scans) {
+    if (cinfo->upsample->need_context_rows) {
+      cinfo->output_scanline += lines_to_skip;
+      cinfo->output_iMCU_row += lines_to_skip / lines_per_iMCU_row;
+      main_ptr->iMCU_row_ctr += lines_to_skip / lines_per_iMCU_row;
+      /* It is complex to properly move to the middle of a context block, so
+       * read the remaining lines instead of skipping them.
+       */
+      read_and_discard_scanlines(cinfo, lines_to_read);
+    } else {
+      cinfo->output_scanline += lines_to_skip;
+      cinfo->output_iMCU_row += lines_to_skip / lines_per_iMCU_row;
+      increment_simple_rowgroup_ctr(cinfo, lines_to_read);
+    }
+    if (!master->using_merged_upsample)
+      upsample->rows_to_go = cinfo->output_height - cinfo->output_scanline;
+    return num_lines;
+  }
+
+  /* Skip the iMCU rows that we can safely skip. */
+  for (i = 0; i < lines_to_skip; i += lines_per_iMCU_row) {
+    for (y = 0; y < coef->MCU_rows_per_iMCU_row; y++) {
+      for (x = 0; x < cinfo->MCUs_per_row; x++) {
+        /* Calling decode_mcu() with a NULL pointer causes it to discard the
+         * decoded coefficients.  This is ~5% faster for large subsets, but
+         * it's tough to tell a difference for smaller images.
+         */
+        if (!cinfo->entropy->insufficient_data)
+          cinfo->master->last_good_iMCU_row = cinfo->input_iMCU_row;
+        (*cinfo->entropy->decode_mcu) (cinfo, NULL);
+      }
+    }
+    cinfo->input_iMCU_row++;
+    cinfo->output_iMCU_row++;
+    if (cinfo->input_iMCU_row < cinfo->total_iMCU_rows)
+      start_iMCU_row(cinfo);
+    else
+      (*cinfo->inputctl->finish_input_pass) (cinfo);
+  }
+  cinfo->output_scanline += lines_to_skip;
+
+  if (cinfo->upsample->need_context_rows) {
+    /* Context-based upsampling keeps track of iMCU rows. */
+    main_ptr->iMCU_row_ctr += lines_to_skip / lines_per_iMCU_row;
+
+    /* It is complex to properly move to the middle of a context block, so
+     * read the remaining lines instead of skipping them.
+     */
+    read_and_discard_scanlines(cinfo, lines_to_read);
+  } else {
+    increment_simple_rowgroup_ctr(cinfo, lines_to_read);
+  }
+
+  /* Since skipping lines involves skipping the upsampling step, the value of
+   * "rows_to_go" will become invalid unless we set it here.  NOTE: This is a
+   * bit odd, since "rows_to_go" seems to be redundantly keeping track of
+   * output_scanline.
+   */
+  if (!master->using_merged_upsample)
+    upsample->rows_to_go = cinfo->output_height - cinfo->output_scanline;
+
+  /* Always skip the requested number of lines. */
+  return num_lines;
+}
+
+/*
+ * Alternate entry point to read raw data.
+ * Processes exactly one iMCU row per call, unless suspended.
+ */
+
+GLOBAL(JDIMENSION)
+jpeg_read_raw_data(j_decompress_ptr cinfo, JSAMPIMAGE data,
+                   JDIMENSION max_lines)
+{
+  JDIMENSION lines_per_iMCU_row;
+
+  if (cinfo->global_state != DSTATE_RAW_OK)
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+  if (cinfo->output_scanline >= cinfo->output_height) {
+    WARNMS(cinfo, JWRN_TOO_MUCH_DATA);
+    return 0;
+  }
+
+  /* Call progress monitor hook if present */
+  if (cinfo->progress != NULL) {
+    cinfo->progress->pass_counter = (long)cinfo->output_scanline;
+    cinfo->progress->pass_limit = (long)cinfo->output_height;
+    (*cinfo->progress->progress_monitor) ((j_common_ptr)cinfo);
+  }
+
+  /* Verify that at least one iMCU row can be returned. */
+  lines_per_iMCU_row = cinfo->max_v_samp_factor * cinfo->_min_DCT_scaled_size;
+  if (max_lines < lines_per_iMCU_row)
+    ERREXIT(cinfo, JERR_BUFFER_SIZE);
+
+  /* Decompress directly into user's buffer. */
+  if (!(*cinfo->coef->decompress_data) (cinfo, data))
+    return 0;                   /* suspension forced, can do nothing more */
+
+  /* OK, we processed one iMCU row. */
+  cinfo->output_scanline += lines_per_iMCU_row;
+  return lines_per_iMCU_row;
+}
+
+
+/* Additional entry points for buffered-image mode. */
+
+#ifdef D_MULTISCAN_FILES_SUPPORTED
+
+/*
+ * Initialize for an output pass in buffered-image mode.
+ */
+
+GLOBAL(boolean)
+jpeg_start_output(j_decompress_ptr cinfo, int scan_number)
+{
+  if (cinfo->global_state != DSTATE_BUFIMAGE &&
+      cinfo->global_state != DSTATE_PRESCAN)
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+  /* Limit scan number to valid range */
+  if (scan_number <= 0)
+    scan_number = 1;
+  if (cinfo->inputctl->eoi_reached && scan_number > cinfo->input_scan_number)
+    scan_number = cinfo->input_scan_number;
+  cinfo->output_scan_number = scan_number;
+  /* Perform any dummy output passes, and set up for the real pass */
+  return output_pass_setup(cinfo);
+}
+
+
+/*
+ * Finish up after an output pass in buffered-image mode.
+ *
+ * Returns FALSE if suspended.  The return value need be inspected only if
+ * a suspending data source is used.
+ */
+
+GLOBAL(boolean)
+jpeg_finish_output(j_decompress_ptr cinfo)
+{
+  if ((cinfo->global_state == DSTATE_SCANNING ||
+       cinfo->global_state == DSTATE_RAW_OK) && cinfo->buffered_image) {
+    /* Terminate this pass. */
+    /* We do not require the whole pass to have been completed. */
+    (*cinfo->master->finish_output_pass) (cinfo);
+    cinfo->global_state = DSTATE_BUFPOST;
+  } else if (cinfo->global_state != DSTATE_BUFPOST) {
+    /* BUFPOST = repeat call after a suspension, anything else is error */
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+  }
+  /* Read markers looking for SOS or EOI */
+  while (cinfo->input_scan_number <= cinfo->output_scan_number &&
+         !cinfo->inputctl->eoi_reached) {
+    if ((*cinfo->inputctl->consume_input) (cinfo) == JPEG_SUSPENDED)
+      return FALSE;             /* Suspend, come back later */
+  }
+  cinfo->global_state = DSTATE_BUFIMAGE;
+  return TRUE;
+}
+
+#endif /* D_MULTISCAN_FILES_SUPPORTED */
diff --git a/3rdparty/libjpeg/src/jdarith.c b/3rdparty/libjpeg/src/jdarith.c
new file mode 100644
index 00000000..3c7ac576
--- /dev/null
+++ b/3rdparty/libjpeg/src/jdarith.c
@@ -0,0 +1,780 @@
+/*
+ * jdarith.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Developed 1997-2015 by Guido Vollbeding.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2015-2020, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains portable arithmetic entropy encoding routines for JPEG
+ * (implementing Recommendation ITU-T T.81 | ISO/IEC 10918-1).
+ *
+ * Both sequential and progressive modes are supported in this single module.
+ *
+ * Suspension is not currently supported in this module.
+ *
+ * NOTE: All referenced figures are from
+ * Recommendation ITU-T T.81 (1992) | ISO/IEC 10918-1:1994.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+#define NEG_1  ((unsigned int)-1)
+
+
+/* Expanded entropy decoder object for arithmetic decoding. */
+
+typedef struct {
+  struct jpeg_entropy_decoder pub; /* public fields */
+
+  JLONG c;       /* C register, base of coding interval + input bit buffer */
+  JLONG a;               /* A register, normalized size of coding interval */
+  int ct;     /* bit shift counter, # of bits left in bit buffer part of C */
+                                                         /* init: ct = -16 */
+                                                         /* run: ct = 0..7 */
+                                                         /* error: ct = -1 */
+  int last_dc_val[MAX_COMPS_IN_SCAN]; /* last DC coef for each component */
+  int dc_context[MAX_COMPS_IN_SCAN]; /* context index for DC conditioning */
+
+  unsigned int restarts_to_go;  /* MCUs left in this restart interval */
+
+  /* Pointers to statistics areas (these workspaces have image lifespan) */
+  unsigned char *dc_stats[NUM_ARITH_TBLS];
+  unsigned char *ac_stats[NUM_ARITH_TBLS];
+
+  /* Statistics bin for coding with fixed probability 0.5 */
+  unsigned char fixed_bin[4];
+} arith_entropy_decoder;
+
+typedef arith_entropy_decoder *arith_entropy_ptr;
+
+/* The following two definitions specify the allocation chunk size
+ * for the statistics area.
+ * According to sections F.1.4.4.1.3 and F.1.4.4.2, we need at least
+ * 49 statistics bins for DC, and 245 statistics bins for AC coding.
+ *
+ * We use a compact representation with 1 byte per statistics bin,
+ * thus the numbers directly represent byte sizes.
+ * This 1 byte per statistics bin contains the meaning of the MPS
+ * (more probable symbol) in the highest bit (mask 0x80), and the
+ * index into the probability estimation state machine table
+ * in the lower bits (mask 0x7F).
+ */
+
+#define DC_STAT_BINS  64
+#define AC_STAT_BINS  256
+
+
+LOCAL(int)
+get_byte(j_decompress_ptr cinfo)
+/* Read next input byte; we do not support suspension in this module. */
+{
+  struct jpeg_source_mgr *src = cinfo->src;
+
+  if (src->bytes_in_buffer == 0)
+    if (!(*src->fill_input_buffer) (cinfo))
+      ERREXIT(cinfo, JERR_CANT_SUSPEND);
+  src->bytes_in_buffer--;
+  return *src->next_input_byte++;
+}
+
+
+/*
+ * The core arithmetic decoding routine (common in JPEG and JBIG).
+ * This needs to go as fast as possible.
+ * Machine-dependent optimization facilities
+ * are not utilized in this portable implementation.
+ * However, this code should be fairly efficient and
+ * may be a good base for further optimizations anyway.
+ *
+ * Return value is 0 or 1 (binary decision).
+ *
+ * Note: I've changed the handling of the code base & bit
+ * buffer register C compared to other implementations
+ * based on the standards layout & procedures.
+ * While it also contains both the actual base of the
+ * coding interval (16 bits) and the next-bits buffer,
+ * the cut-point between these two parts is floating
+ * (instead of fixed) with the bit shift counter CT.
+ * Thus, we also need only one (variable instead of
+ * fixed size) shift for the LPS/MPS decision, and
+ * we can do away with any renormalization update
+ * of C (except for new data insertion, of course).
+ *
+ * I've also introduced a new scheme for accessing
+ * the probability estimation state machine table,
+ * derived from Markus Kuhn's JBIG implementation.
+ */
+
+LOCAL(int)
+arith_decode(j_decompress_ptr cinfo, unsigned char *st)
+{
+  register arith_entropy_ptr e = (arith_entropy_ptr)cinfo->entropy;
+  register unsigned char nl, nm;
+  register JLONG qe, temp;
+  register int sv, data;
+
+  /* Renormalization & data input per section D.2.6 */
+  while (e->a < 0x8000L) {
+    if (--e->ct < 0) {
+      /* Need to fetch next data byte */
+      if (cinfo->unread_marker)
+        data = 0;               /* stuff zero data */
+      else {
+        data = get_byte(cinfo); /* read next input byte */
+        if (data == 0xFF) {     /* zero stuff or marker code */
+          do data = get_byte(cinfo);
+          while (data == 0xFF); /* swallow extra 0xFF bytes */
+          if (data == 0)
+            data = 0xFF;        /* discard stuffed zero byte */
+          else {
+            /* Note: Different from the Huffman decoder, hitting
+             * a marker while processing the compressed data
+             * segment is legal in arithmetic coding.
+             * The convention is to supply zero data
+             * then until decoding is complete.
+             */
+            cinfo->unread_marker = data;
+            data = 0;
+          }
+        }
+      }
+      e->c = (e->c << 8) | data; /* insert data into C register */
+      if ((e->ct += 8) < 0)      /* update bit shift counter */
+        /* Need more initial bytes */
+        if (++e->ct == 0)
+          /* Got 2 initial bytes -> re-init A and exit loop */
+          e->a = 0x8000L; /* => e->a = 0x10000L after loop exit */
+    }
+    e->a <<= 1;
+  }
+
+  /* Fetch values from our compact representation of Table D.2:
+   * Qe values and probability estimation state machine
+   */
+  sv = *st;
+  qe = jpeg_aritab[sv & 0x7F];  /* => Qe_Value */
+  nl = qe & 0xFF;  qe >>= 8;    /* Next_Index_LPS + Switch_MPS */
+  nm = qe & 0xFF;  qe >>= 8;    /* Next_Index_MPS */
+
+  /* Decode & estimation procedures per sections D.2.4 & D.2.5 */
+  temp = e->a - qe;
+  e->a = temp;
+  temp <<= e->ct;
+  if (e->c >= temp) {
+    e->c -= temp;
+    /* Conditional LPS (less probable symbol) exchange */
+    if (e->a < qe) {
+      e->a = qe;
+      *st = (sv & 0x80) ^ nm;   /* Estimate_after_MPS */
+    } else {
+      e->a = qe;
+      *st = (sv & 0x80) ^ nl;   /* Estimate_after_LPS */
+      sv ^= 0x80;               /* Exchange LPS/MPS */
+    }
+  } else if (e->a < 0x8000L) {
+    /* Conditional MPS (more probable symbol) exchange */
+    if (e->a < qe) {
+      *st = (sv & 0x80) ^ nl;   /* Estimate_after_LPS */
+      sv ^= 0x80;               /* Exchange LPS/MPS */
+    } else {
+      *st = (sv & 0x80) ^ nm;   /* Estimate_after_MPS */
+    }
+  }
+
+  return sv >> 7;
+}
+
+
+/*
+ * Check for a restart marker & resynchronize decoder.
+ */
+
+LOCAL(void)
+process_restart(j_decompress_ptr cinfo)
+{
+  arith_entropy_ptr entropy = (arith_entropy_ptr)cinfo->entropy;
+  int ci;
+  jpeg_component_info *compptr;
+
+  /* Advance past the RSTn marker */
+  if (!(*cinfo->marker->read_restart_marker) (cinfo))
+    ERREXIT(cinfo, JERR_CANT_SUSPEND);
+
+  /* Re-initialize statistics areas */
+  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+    compptr = cinfo->cur_comp_info[ci];
+    if (!cinfo->progressive_mode || (cinfo->Ss == 0 && cinfo->Ah == 0)) {
+      MEMZERO(entropy->dc_stats[compptr->dc_tbl_no], DC_STAT_BINS);
+      /* Reset DC predictions to 0 */
+      entropy->last_dc_val[ci] = 0;
+      entropy->dc_context[ci] = 0;
+    }
+    if (!cinfo->progressive_mode || cinfo->Ss) {
+      MEMZERO(entropy->ac_stats[compptr->ac_tbl_no], AC_STAT_BINS);
+    }
+  }
+
+  /* Reset arithmetic decoding variables */
+  entropy->c = 0;
+  entropy->a = 0;
+  entropy->ct = -16;    /* force reading 2 initial bytes to fill C */
+
+  /* Reset restart counter */
+  entropy->restarts_to_go = cinfo->restart_interval;
+}
+
+
+/*
+ * Arithmetic MCU decoding.
+ * Each of these routines decodes and returns one MCU's worth of
+ * arithmetic-compressed coefficients.
+ * The coefficients are reordered from zigzag order into natural array order,
+ * but are not dequantized.
+ *
+ * The i'th block of the MCU is stored into the block pointed to by
+ * MCU_data[i].  WE ASSUME THIS AREA IS INITIALLY ZEROED BY THE CALLER.
+ */
+
+/*
+ * MCU decoding for DC initial scan (either spectral selection,
+ * or first pass of successive approximation).
+ */
+
+METHODDEF(boolean)
+decode_mcu_DC_first(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
+{
+  arith_entropy_ptr entropy = (arith_entropy_ptr)cinfo->entropy;
+  JBLOCKROW block;
+  unsigned char *st;
+  int blkn, ci, tbl, sign;
+  int v, m;
+
+  /* Process restart marker if needed */
+  if (cinfo->restart_interval) {
+    if (entropy->restarts_to_go == 0)
+      process_restart(cinfo);
+    entropy->restarts_to_go--;
+  }
+
+  if (entropy->ct == -1) return TRUE;   /* if error do nothing */
+
+  /* Outer loop handles each block in the MCU */
+
+  for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
+    block = MCU_data[blkn];
+    ci = cinfo->MCU_membership[blkn];
+    tbl = cinfo->cur_comp_info[ci]->dc_tbl_no;
+
+    /* Sections F.2.4.1 & F.1.4.4.1: Decoding of DC coefficients */
+
+    /* Table F.4: Point to statistics bin S0 for DC coefficient coding */
+    st = entropy->dc_stats[tbl] + entropy->dc_context[ci];
+
+    /* Figure F.19: Decode_DC_DIFF */
+    if (arith_decode(cinfo, st) == 0)
+      entropy->dc_context[ci] = 0;
+    else {
+      /* Figure F.21: Decoding nonzero value v */
+      /* Figure F.22: Decoding the sign of v */
+      sign = arith_decode(cinfo, st + 1);
+      st += 2;  st += sign;
+      /* Figure F.23: Decoding the magnitude category of v */
+      if ((m = arith_decode(cinfo, st)) != 0) {
+        st = entropy->dc_stats[tbl] + 20;       /* Table F.4: X1 = 20 */
+        while (arith_decode(cinfo, st)) {
+          if ((m <<= 1) == 0x8000) {
+            WARNMS(cinfo, JWRN_ARITH_BAD_CODE);
+            entropy->ct = -1;                   /* magnitude overflow */
+            return TRUE;
+          }
+          st += 1;
+        }
+      }
+      /* Section F.1.4.4.1.2: Establish dc_context conditioning category */
+      if (m < (int)((1L << cinfo->arith_dc_L[tbl]) >> 1))
+        entropy->dc_context[ci] = 0;               /* zero diff category */
+      else if (m > (int)((1L << cinfo->arith_dc_U[tbl]) >> 1))
+        entropy->dc_context[ci] = 12 + (sign * 4); /* large diff category */
+      else
+        entropy->dc_context[ci] = 4 + (sign * 4);  /* small diff category */
+      v = m;
+      /* Figure F.24: Decoding the magnitude bit pattern of v */
+      st += 14;
+      while (m >>= 1)
+        if (arith_decode(cinfo, st)) v |= m;
+      v += 1;  if (sign) v = -v;
+      entropy->last_dc_val[ci] = (entropy->last_dc_val[ci] + v) & 0xffff;
+    }
+
+    /* Scale and output the DC coefficient (assumes jpeg_natural_order[0]=0) */
+    (*block)[0] = (JCOEF)LEFT_SHIFT(entropy->last_dc_val[ci], cinfo->Al);
+  }
+
+  return TRUE;
+}
+
+
+/*
+ * MCU decoding for AC initial scan (either spectral selection,
+ * or first pass of successive approximation).
+ */
+
+METHODDEF(boolean)
+decode_mcu_AC_first(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
+{
+  arith_entropy_ptr entropy = (arith_entropy_ptr)cinfo->entropy;
+  JBLOCKROW block;
+  unsigned char *st;
+  int tbl, sign, k;
+  int v, m;
+
+  /* Process restart marker if needed */
+  if (cinfo->restart_interval) {
+    if (entropy->restarts_to_go == 0)
+      process_restart(cinfo);
+    entropy->restarts_to_go--;
+  }
+
+  if (entropy->ct == -1) return TRUE;   /* if error do nothing */
+
+  /* There is always only one block per MCU */
+  block = MCU_data[0];
+  tbl = cinfo->cur_comp_info[0]->ac_tbl_no;
+
+  /* Sections F.2.4.2 & F.1.4.4.2: Decoding of AC coefficients */
+
+  /* Figure F.20: Decode_AC_coefficients */
+  for (k = cinfo->Ss; k <= cinfo->Se; k++) {
+    st = entropy->ac_stats[tbl] + 3 * (k - 1);
+    if (arith_decode(cinfo, st)) break;         /* EOB flag */
+    while (arith_decode(cinfo, st + 1) == 0) {
+      st += 3;  k++;
+      if (k > cinfo->Se) {
+        WARNMS(cinfo, JWRN_ARITH_BAD_CODE);
+        entropy->ct = -1;                       /* spectral overflow */
+        return TRUE;
+      }
+    }
+    /* Figure F.21: Decoding nonzero value v */
+    /* Figure F.22: Decoding the sign of v */
+    sign = arith_decode(cinfo, entropy->fixed_bin);
+    st += 2;
+    /* Figure F.23: Decoding the magnitude category of v */
+    if ((m = arith_decode(cinfo, st)) != 0) {
+      if (arith_decode(cinfo, st)) {
+        m <<= 1;
+        st = entropy->ac_stats[tbl] +
+             (k <= cinfo->arith_ac_K[tbl] ? 189 : 217);
+        while (arith_decode(cinfo, st)) {
+          if ((m <<= 1) == 0x8000) {
+            WARNMS(cinfo, JWRN_ARITH_BAD_CODE);
+            entropy->ct = -1;                   /* magnitude overflow */
+            return TRUE;
+          }
+          st += 1;
+        }
+      }
+    }
+    v = m;
+    /* Figure F.24: Decoding the magnitude bit pattern of v */
+    st += 14;
+    while (m >>= 1)
+      if (arith_decode(cinfo, st)) v |= m;
+    v += 1;  if (sign) v = -v;
+    /* Scale and output coefficient in natural (dezigzagged) order */
+    (*block)[jpeg_natural_order[k]] = (JCOEF)((unsigned)v << cinfo->Al);
+  }
+
+  return TRUE;
+}
+
+
+/*
+ * MCU decoding for DC successive approximation refinement scan.
+ */
+
+METHODDEF(boolean)
+decode_mcu_DC_refine(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
+{
+  arith_entropy_ptr entropy = (arith_entropy_ptr)cinfo->entropy;
+  unsigned char *st;
+  int p1, blkn;
+
+  /* Process restart marker if needed */
+  if (cinfo->restart_interval) {
+    if (entropy->restarts_to_go == 0)
+      process_restart(cinfo);
+    entropy->restarts_to_go--;
+  }
+
+  st = entropy->fixed_bin;      /* use fixed probability estimation */
+  p1 = 1 << cinfo->Al;          /* 1 in the bit position being coded */
+
+  /* Outer loop handles each block in the MCU */
+
+  for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
+    /* Encoded data is simply the next bit of the two's-complement DC value */
+    if (arith_decode(cinfo, st))
+      MCU_data[blkn][0][0] |= p1;
+  }
+
+  return TRUE;
+}
+
+
+/*
+ * MCU decoding for AC successive approximation refinement scan.
+ */
+
+METHODDEF(boolean)
+decode_mcu_AC_refine(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
+{
+  arith_entropy_ptr entropy = (arith_entropy_ptr)cinfo->entropy;
+  JBLOCKROW block;
+  JCOEFPTR thiscoef;
+  unsigned char *st;
+  int tbl, k, kex;
+  int p1, m1;
+
+  /* Process restart marker if needed */
+  if (cinfo->restart_interval) {
+    if (entropy->restarts_to_go == 0)
+      process_restart(cinfo);
+    entropy->restarts_to_go--;
+  }
+
+  if (entropy->ct == -1) return TRUE;   /* if error do nothing */
+
+  /* There is always only one block per MCU */
+  block = MCU_data[0];
+  tbl = cinfo->cur_comp_info[0]->ac_tbl_no;
+
+  p1 = 1 << cinfo->Al;          /* 1 in the bit position being coded */
+  m1 = (NEG_1) << cinfo->Al;    /* -1 in the bit position being coded */
+
+  /* Establish EOBx (previous stage end-of-block) index */
+  for (kex = cinfo->Se; kex > 0; kex--)
+    if ((*block)[jpeg_natural_order[kex]]) break;
+
+  for (k = cinfo->Ss; k <= cinfo->Se; k++) {
+    st = entropy->ac_stats[tbl] + 3 * (k - 1);
+    if (k > kex)
+      if (arith_decode(cinfo, st)) break;       /* EOB flag */
+    for (;;) {
+      thiscoef = *block + jpeg_natural_order[k];
+      if (*thiscoef) {                          /* previously nonzero coef */
+        if (arith_decode(cinfo, st + 2)) {
+          if (*thiscoef < 0)
+            *thiscoef += m1;
+          else
+            *thiscoef += p1;
+        }
+        break;
+      }
+      if (arith_decode(cinfo, st + 1)) {        /* newly nonzero coef */
+        if (arith_decode(cinfo, entropy->fixed_bin))
+          *thiscoef = m1;
+        else
+          *thiscoef = p1;
+        break;
+      }
+      st += 3;  k++;
+      if (k > cinfo->Se) {
+        WARNMS(cinfo, JWRN_ARITH_BAD_CODE);
+        entropy->ct = -1;                       /* spectral overflow */
+        return TRUE;
+      }
+    }
+  }
+
+  return TRUE;
+}
+
+
+/*
+ * Decode one MCU's worth of arithmetic-compressed coefficients.
+ */
+
+METHODDEF(boolean)
+decode_mcu(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
+{
+  arith_entropy_ptr entropy = (arith_entropy_ptr)cinfo->entropy;
+  jpeg_component_info *compptr;
+  JBLOCKROW block;
+  unsigned char *st;
+  int blkn, ci, tbl, sign, k;
+  int v, m;
+
+  /* Process restart marker if needed */
+  if (cinfo->restart_interval) {
+    if (entropy->restarts_to_go == 0)
+      process_restart(cinfo);
+    entropy->restarts_to_go--;
+  }
+
+  if (entropy->ct == -1) return TRUE;   /* if error do nothing */
+
+  /* Outer loop handles each block in the MCU */
+
+  for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
+    block = MCU_data ? MCU_data[blkn] : NULL;
+    ci = cinfo->MCU_membership[blkn];
+    compptr = cinfo->cur_comp_info[ci];
+
+    /* Sections F.2.4.1 & F.1.4.4.1: Decoding of DC coefficients */
+
+    tbl = compptr->dc_tbl_no;
+
+    /* Table F.4: Point to statistics bin S0 for DC coefficient coding */
+    st = entropy->dc_stats[tbl] + entropy->dc_context[ci];
+
+    /* Figure F.19: Decode_DC_DIFF */
+    if (arith_decode(cinfo, st) == 0)
+      entropy->dc_context[ci] = 0;
+    else {
+      /* Figure F.21: Decoding nonzero value v */
+      /* Figure F.22: Decoding the sign of v */
+      sign = arith_decode(cinfo, st + 1);
+      st += 2;  st += sign;
+      /* Figure F.23: Decoding the magnitude category of v */
+      if ((m = arith_decode(cinfo, st)) != 0) {
+        st = entropy->dc_stats[tbl] + 20;       /* Table F.4: X1 = 20 */
+        while (arith_decode(cinfo, st)) {
+          if ((m <<= 1) == 0x8000) {
+            WARNMS(cinfo, JWRN_ARITH_BAD_CODE);
+            entropy->ct = -1;                   /* magnitude overflow */
+            return TRUE;
+          }
+          st += 1;
+        }
+      }
+      /* Section F.1.4.4.1.2: Establish dc_context conditioning category */
+      if (m < (int)((1L << cinfo->arith_dc_L[tbl]) >> 1))
+        entropy->dc_context[ci] = 0;               /* zero diff category */
+      else if (m > (int)((1L << cinfo->arith_dc_U[tbl]) >> 1))
+        entropy->dc_context[ci] = 12 + (sign * 4); /* large diff category */
+      else
+        entropy->dc_context[ci] = 4 + (sign * 4);  /* small diff category */
+      v = m;
+      /* Figure F.24: Decoding the magnitude bit pattern of v */
+      st += 14;
+      while (m >>= 1)
+        if (arith_decode(cinfo, st)) v |= m;
+      v += 1;  if (sign) v = -v;
+      entropy->last_dc_val[ci] = (entropy->last_dc_val[ci] + v) & 0xffff;
+    }
+
+    if (block)
+      (*block)[0] = (JCOEF)entropy->last_dc_val[ci];
+
+    /* Sections F.2.4.2 & F.1.4.4.2: Decoding of AC coefficients */
+
+    tbl = compptr->ac_tbl_no;
+
+    /* Figure F.20: Decode_AC_coefficients */
+    for (k = 1; k <= DCTSIZE2 - 1; k++) {
+      st = entropy->ac_stats[tbl] + 3 * (k - 1);
+      if (arith_decode(cinfo, st)) break;       /* EOB flag */
+      while (arith_decode(cinfo, st + 1) == 0) {
+        st += 3;  k++;
+        if (k > DCTSIZE2 - 1) {
+          WARNMS(cinfo, JWRN_ARITH_BAD_CODE);
+          entropy->ct = -1;                     /* spectral overflow */
+          return TRUE;
+        }
+      }
+      /* Figure F.21: Decoding nonzero value v */
+      /* Figure F.22: Decoding the sign of v */
+      sign = arith_decode(cinfo, entropy->fixed_bin);
+      st += 2;
+      /* Figure F.23: Decoding the magnitude category of v */
+      if ((m = arith_decode(cinfo, st)) != 0) {
+        if (arith_decode(cinfo, st)) {
+          m <<= 1;
+          st = entropy->ac_stats[tbl] +
+               (k <= cinfo->arith_ac_K[tbl] ? 189 : 217);
+          while (arith_decode(cinfo, st)) {
+            if ((m <<= 1) == 0x8000) {
+              WARNMS(cinfo, JWRN_ARITH_BAD_CODE);
+              entropy->ct = -1;                 /* magnitude overflow */
+              return TRUE;
+            }
+            st += 1;
+          }
+        }
+      }
+      v = m;
+      /* Figure F.24: Decoding the magnitude bit pattern of v */
+      st += 14;
+      while (m >>= 1)
+        if (arith_decode(cinfo, st)) v |= m;
+      v += 1;  if (sign) v = -v;
+      if (block)
+        (*block)[jpeg_natural_order[k]] = (JCOEF)v;
+    }
+  }
+
+  return TRUE;
+}
+
+
+/*
+ * Initialize for an arithmetic-compressed scan.
+ */
+
+METHODDEF(void)
+start_pass(j_decompress_ptr cinfo)
+{
+  arith_entropy_ptr entropy = (arith_entropy_ptr)cinfo->entropy;
+  int ci, tbl;
+  jpeg_component_info *compptr;
+
+  if (cinfo->progressive_mode) {
+    /* Validate progressive scan parameters */
+    if (cinfo->Ss == 0) {
+      if (cinfo->Se != 0)
+        goto bad;
+    } else {
+      /* need not check Ss/Se < 0 since they came from unsigned bytes */
+      if (cinfo->Se < cinfo->Ss || cinfo->Se > DCTSIZE2 - 1)
+        goto bad;
+      /* AC scans may have only one component */
+      if (cinfo->comps_in_scan != 1)
+        goto bad;
+    }
+    if (cinfo->Ah != 0) {
+      /* Successive approximation refinement scan: must have Al = Ah-1. */
+      if (cinfo->Ah - 1 != cinfo->Al)
+        goto bad;
+    }
+    if (cinfo->Al > 13) {       /* need not check for < 0 */
+bad:
+      ERREXIT4(cinfo, JERR_BAD_PROGRESSION,
+               cinfo->Ss, cinfo->Se, cinfo->Ah, cinfo->Al);
+    }
+    /* Update progression status, and verify that scan order is legal.
+     * Note that inter-scan inconsistencies are treated as warnings
+     * not fatal errors ... not clear if this is right way to behave.
+     */
+    for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+      int coefi, cindex = cinfo->cur_comp_info[ci]->component_index;
+      int *coef_bit_ptr = &cinfo->coef_bits[cindex][0];
+      int *prev_coef_bit_ptr =
+        &cinfo->coef_bits[cindex + cinfo->num_components][0];
+      if (cinfo->Ss && coef_bit_ptr[0] < 0) /* AC without prior DC scan */
+        WARNMS2(cinfo, JWRN_BOGUS_PROGRESSION, cindex, 0);
+      for (coefi = MIN(cinfo->Ss, 1); coefi <= MAX(cinfo->Se, 9); coefi++) {
+        if (cinfo->input_scan_number > 1)
+          prev_coef_bit_ptr[coefi] = coef_bit_ptr[coefi];
+      }
+      for (coefi = cinfo->Ss; coefi <= cinfo->Se; coefi++) {
+        int expected = (coef_bit_ptr[coefi] < 0) ? 0 : coef_bit_ptr[coefi];
+        if (cinfo->Ah != expected)
+          WARNMS2(cinfo, JWRN_BOGUS_PROGRESSION, cindex, coefi);
+        coef_bit_ptr[coefi] = cinfo->Al;
+      }
+    }
+    /* Select MCU decoding routine */
+    if (cinfo->Ah == 0) {
+      if (cinfo->Ss == 0)
+        entropy->pub.decode_mcu = decode_mcu_DC_first;
+      else
+        entropy->pub.decode_mcu = decode_mcu_AC_first;
+    } else {
+      if (cinfo->Ss == 0)
+        entropy->pub.decode_mcu = decode_mcu_DC_refine;
+      else
+        entropy->pub.decode_mcu = decode_mcu_AC_refine;
+    }
+  } else {
+    /* Check that the scan parameters Ss, Se, Ah/Al are OK for sequential JPEG.
+     * This ought to be an error condition, but we make it a warning.
+     */
+    if (cinfo->Ss != 0 || cinfo->Ah != 0 || cinfo->Al != 0 ||
+        (cinfo->Se < DCTSIZE2 && cinfo->Se != DCTSIZE2 - 1))
+      WARNMS(cinfo, JWRN_NOT_SEQUENTIAL);
+    /* Select MCU decoding routine */
+    entropy->pub.decode_mcu = decode_mcu;
+  }
+
+  /* Allocate & initialize requested statistics areas */
+  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+    compptr = cinfo->cur_comp_info[ci];
+    if (!cinfo->progressive_mode || (cinfo->Ss == 0 && cinfo->Ah == 0)) {
+      tbl = compptr->dc_tbl_no;
+      if (tbl < 0 || tbl >= NUM_ARITH_TBLS)
+        ERREXIT1(cinfo, JERR_NO_ARITH_TABLE, tbl);
+      if (entropy->dc_stats[tbl] == NULL)
+        entropy->dc_stats[tbl] = (unsigned char *)(*cinfo->mem->alloc_small)
+          ((j_common_ptr)cinfo, JPOOL_IMAGE, DC_STAT_BINS);
+      MEMZERO(entropy->dc_stats[tbl], DC_STAT_BINS);
+      /* Initialize DC predictions to 0 */
+      entropy->last_dc_val[ci] = 0;
+      entropy->dc_context[ci] = 0;
+    }
+    if (!cinfo->progressive_mode || cinfo->Ss) {
+      tbl = compptr->ac_tbl_no;
+      if (tbl < 0 || tbl >= NUM_ARITH_TBLS)
+        ERREXIT1(cinfo, JERR_NO_ARITH_TABLE, tbl);
+      if (entropy->ac_stats[tbl] == NULL)
+        entropy->ac_stats[tbl] = (unsigned char *)(*cinfo->mem->alloc_small)
+          ((j_common_ptr)cinfo, JPOOL_IMAGE, AC_STAT_BINS);
+      MEMZERO(entropy->ac_stats[tbl], AC_STAT_BINS);
+    }
+  }
+
+  /* Initialize arithmetic decoding variables */
+  entropy->c = 0;
+  entropy->a = 0;
+  entropy->ct = -16;    /* force reading 2 initial bytes to fill C */
+  entropy->pub.insufficient_data = FALSE;
+
+  /* Initialize restart counter */
+  entropy->restarts_to_go = cinfo->restart_interval;
+}
+
+
+/*
+ * Module initialization routine for arithmetic entropy decoding.
+ */
+
+GLOBAL(void)
+jinit_arith_decoder(j_decompress_ptr cinfo)
+{
+  arith_entropy_ptr entropy;
+  int i;
+
+  entropy = (arith_entropy_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+                                sizeof(arith_entropy_decoder));
+  cinfo->entropy = (struct jpeg_entropy_decoder *)entropy;
+  entropy->pub.start_pass = start_pass;
+
+  /* Mark tables unallocated */
+  for (i = 0; i < NUM_ARITH_TBLS; i++) {
+    entropy->dc_stats[i] = NULL;
+    entropy->ac_stats[i] = NULL;
+  }
+
+  /* Initialize index for fixed probability estimation */
+  entropy->fixed_bin[0] = 113;
+
+  if (cinfo->progressive_mode) {
+    /* Create progression status table */
+    int *coef_bit_ptr, ci;
+    cinfo->coef_bits = (int (*)[DCTSIZE2])
+      (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+                                  cinfo->num_components * 2 * DCTSIZE2 *
+                                  sizeof(int));
+    coef_bit_ptr = &cinfo->coef_bits[0][0];
+    for (ci = 0; ci < cinfo->num_components; ci++)
+      for (i = 0; i < DCTSIZE2; i++)
+        *coef_bit_ptr++ = -1;
+  }
+}
diff --git a/3rdparty/libjpeg/src/jdatadst-tj.c b/3rdparty/libjpeg/src/jdatadst-tj.c
new file mode 100644
index 00000000..fdaa2de1
--- /dev/null
+++ b/3rdparty/libjpeg/src/jdatadst-tj.c
@@ -0,0 +1,202 @@
+/*
+ * jdatadst-tj.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1994-1996, Thomas G. Lane.
+ * Modified 2009-2012 by Guido Vollbeding.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2011, 2014, 2016, 2019, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains compression data destination routines for the case of
+ * emitting JPEG data to memory or to a file (or any stdio stream).
+ * While these routines are sufficient for most applications,
+ * some will want to use a different destination manager.
+ * IMPORTANT: we assume that fwrite() will correctly transcribe an array of
+ * JOCTETs into 8-bit-wide elements on external storage.  If char is wider
+ * than 8 bits on your machine, you may need to do some tweaking.
+ */
+
+/* this is not a core library module, so it doesn't define JPEG_INTERNALS */
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jerror.h"
+
+#ifndef HAVE_STDLIB_H           /* <stdlib.h> should declare malloc(),free() */
+extern void *malloc(size_t size);
+extern void free(void *ptr);
+#endif
+void jpeg_mem_dest_tj(j_compress_ptr cinfo, unsigned char **outbuffer,
+                      unsigned long *outsize, boolean alloc);
+
+
+#define OUTPUT_BUF_SIZE  4096   /* choose an efficiently fwrite'able size */
+
+
+/* Expanded data destination object for memory output */
+
+typedef struct {
+  struct jpeg_destination_mgr pub; /* public fields */
+
+  unsigned char **outbuffer;    /* target buffer */
+  unsigned long *outsize;
+  unsigned char *newbuffer;     /* newly allocated buffer */
+  JOCTET *buffer;               /* start of buffer */
+  size_t bufsize;
+  boolean alloc;
+} my_mem_destination_mgr;
+
+typedef my_mem_destination_mgr *my_mem_dest_ptr;
+
+
+/*
+ * Initialize destination --- called by jpeg_start_compress
+ * before any data is actually written.
+ */
+
+METHODDEF(void)
+init_mem_destination(j_compress_ptr cinfo)
+{
+  /* no work necessary here */
+}
+
+
+/*
+ * Empty the output buffer --- called whenever buffer fills up.
+ *
+ * In typical applications, this should write the entire output buffer
+ * (ignoring the current state of next_output_byte & free_in_buffer),
+ * reset the pointer & count to the start of the buffer, and return TRUE
+ * indicating that the buffer has been dumped.
+ *
+ * In applications that need to be able to suspend compression due to output
+ * overrun, a FALSE return indicates that the buffer cannot be emptied now.
+ * In this situation, the compressor will return to its caller (possibly with
+ * an indication that it has not accepted all the supplied scanlines).  The
+ * application should resume compression after it has made more room in the
+ * output buffer.  Note that there are substantial restrictions on the use of
+ * suspension --- see the documentation.
+ *
+ * When suspending, the compressor will back up to a convenient restart point
+ * (typically the start of the current MCU). next_output_byte & free_in_buffer
+ * indicate where the restart point will be if the current call returns FALSE.
+ * Data beyond this point will be regenerated after resumption, so do not
+ * write it out when emptying the buffer externally.
+ */
+
+METHODDEF(boolean)
+empty_mem_output_buffer(j_compress_ptr cinfo)
+{
+  size_t nextsize;
+  JOCTET *nextbuffer;
+  my_mem_dest_ptr dest = (my_mem_dest_ptr)cinfo->dest;
+
+  if (!dest->alloc) ERREXIT(cinfo, JERR_BUFFER_SIZE);
+
+  /* Try to allocate new buffer with double size */
+  nextsize = dest->bufsize * 2;
+  nextbuffer = (JOCTET *)malloc(nextsize);
+
+  if (nextbuffer == NULL)
+    ERREXIT1(cinfo, JERR_OUT_OF_MEMORY, 10);
+
+  MEMCOPY(nextbuffer, dest->buffer, dest->bufsize);
+
+  free(dest->newbuffer);
+
+  dest->newbuffer = nextbuffer;
+
+  dest->pub.next_output_byte = nextbuffer + dest->bufsize;
+  dest->pub.free_in_buffer = dest->bufsize;
+
+  dest->buffer = nextbuffer;
+  dest->bufsize = nextsize;
+
+  return TRUE;
+}
+
+
+/*
+ * Terminate destination --- called by jpeg_finish_compress
+ * after all data has been written.  Usually needs to flush buffer.
+ *
+ * NB: *not* called by jpeg_abort or jpeg_destroy; surrounding
+ * application must deal with any cleanup that should happen even
+ * for error exit.
+ */
+
+METHODDEF(void)
+term_mem_destination(j_compress_ptr cinfo)
+{
+  my_mem_dest_ptr dest = (my_mem_dest_ptr)cinfo->dest;
+
+  if (dest->alloc) *dest->outbuffer = dest->buffer;
+  *dest->outsize = (unsigned long)(dest->bufsize - dest->pub.free_in_buffer);
+}
+
+
+/*
+ * Prepare for output to a memory buffer.
+ * The caller may supply an own initial buffer with appropriate size.
+ * Otherwise, or when the actual data output exceeds the given size,
+ * the library adapts the buffer size as necessary.
+ * The standard library functions malloc/free are used for allocating
+ * larger memory, so the buffer is available to the application after
+ * finishing compression, and then the application is responsible for
+ * freeing the requested memory.
+ */
+
+GLOBAL(void)
+jpeg_mem_dest_tj(j_compress_ptr cinfo, unsigned char **outbuffer,
+                 unsigned long *outsize, boolean alloc)
+{
+  boolean reused = FALSE;
+  my_mem_dest_ptr dest;
+
+  if (outbuffer == NULL || outsize == NULL)     /* sanity check */
+    ERREXIT(cinfo, JERR_BUFFER_SIZE);
+
+  /* The destination object is made permanent so that multiple JPEG images
+   * can be written to the same buffer without re-executing jpeg_mem_dest.
+   */
+  if (cinfo->dest == NULL) {    /* first time for this JPEG object? */
+    cinfo->dest = (struct jpeg_destination_mgr *)
+      (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_PERMANENT,
+                                  sizeof(my_mem_destination_mgr));
+    dest = (my_mem_dest_ptr)cinfo->dest;
+    dest->newbuffer = NULL;
+    dest->buffer = NULL;
+  } else if (cinfo->dest->init_destination != init_mem_destination) {
+    /* It is unsafe to reuse the existing destination manager unless it was
+     * created by this function.
+     */
+    ERREXIT(cinfo, JERR_BUFFER_SIZE);
+  }
+
+  dest = (my_mem_dest_ptr)cinfo->dest;
+  dest->pub.init_destination = init_mem_destination;
+  dest->pub.empty_output_buffer = empty_mem_output_buffer;
+  dest->pub.term_destination = term_mem_destination;
+  if (dest->buffer == *outbuffer && *outbuffer != NULL && alloc)
+    reused = TRUE;
+  dest->outbuffer = outbuffer;
+  dest->outsize = outsize;
+  dest->alloc = alloc;
+
+  if (*outbuffer == NULL || *outsize == 0) {
+    if (alloc) {
+      /* Allocate initial buffer */
+      dest->newbuffer = *outbuffer = (unsigned char *)malloc(OUTPUT_BUF_SIZE);
+      if (dest->newbuffer == NULL)
+        ERREXIT1(cinfo, JERR_OUT_OF_MEMORY, 10);
+      *outsize = OUTPUT_BUF_SIZE;
+    } else
+      ERREXIT(cinfo, JERR_BUFFER_SIZE);
+  }
+
+  dest->pub.next_output_byte = dest->buffer = *outbuffer;
+  if (!reused)
+    dest->bufsize = *outsize;
+  dest->pub.free_in_buffer = dest->bufsize;
+}
diff --git a/3rdparty/libjpeg/src/jdatadst.c b/3rdparty/libjpeg/src/jdatadst.c
new file mode 100644
index 00000000..246fffb5
--- /dev/null
+++ b/3rdparty/libjpeg/src/jdatadst.c
@@ -0,0 +1,292 @@
+/*
+ * jdatadst.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1994-1996, Thomas G. Lane.
+ * Modified 2009-2012 by Guido Vollbeding.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2013, 2016, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains compression data destination routines for the case of
+ * emitting JPEG data to memory or to a file (or any stdio stream).
+ * While these routines are sufficient for most applications,
+ * some will want to use a different destination manager.
+ * IMPORTANT: we assume that fwrite() will correctly transcribe an array of
+ * JOCTETs into 8-bit-wide elements on external storage.  If char is wider
+ * than 8 bits on your machine, you may need to do some tweaking.
+ */
+
+/* this is not a core library module, so it doesn't define JPEG_INTERNALS */
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jerror.h"
+
+#ifndef HAVE_STDLIB_H           /* <stdlib.h> should declare malloc(),free() */
+extern void *malloc(size_t size);
+extern void free(void *ptr);
+#endif
+
+
+/* Expanded data destination object for stdio output */
+
+typedef struct {
+  struct jpeg_destination_mgr pub; /* public fields */
+
+  FILE *outfile;                /* target stream */
+  JOCTET *buffer;               /* start of buffer */
+} my_destination_mgr;
+
+typedef my_destination_mgr *my_dest_ptr;
+
+#define OUTPUT_BUF_SIZE  4096   /* choose an efficiently fwrite'able size */
+
+
+#if JPEG_LIB_VERSION >= 80 || defined(MEM_SRCDST_SUPPORTED)
+/* Expanded data destination object for memory output */
+
+typedef struct {
+  struct jpeg_destination_mgr pub; /* public fields */
+
+  unsigned char **outbuffer;    /* target buffer */
+  unsigned long *outsize;
+  unsigned char *newbuffer;     /* newly allocated buffer */
+  JOCTET *buffer;               /* start of buffer */
+  size_t bufsize;
+} my_mem_destination_mgr;
+
+typedef my_mem_destination_mgr *my_mem_dest_ptr;
+#endif
+
+
+/*
+ * Initialize destination --- called by jpeg_start_compress
+ * before any data is actually written.
+ */
+
+METHODDEF(void)
+init_destination(j_compress_ptr cinfo)
+{
+  my_dest_ptr dest = (my_dest_ptr)cinfo->dest;
+
+  /* Allocate the output buffer --- it will be released when done with image */
+  dest->buffer = (JOCTET *)
+    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+                                OUTPUT_BUF_SIZE * sizeof(JOCTET));
+
+  dest->pub.next_output_byte = dest->buffer;
+  dest->pub.free_in_buffer = OUTPUT_BUF_SIZE;
+}
+
+#if JPEG_LIB_VERSION >= 80 || defined(MEM_SRCDST_SUPPORTED)
+METHODDEF(void)
+init_mem_destination(j_compress_ptr cinfo)
+{
+  /* no work necessary here */
+}
+#endif
+
+
+/*
+ * Empty the output buffer --- called whenever buffer fills up.
+ *
+ * In typical applications, this should write the entire output buffer
+ * (ignoring the current state of next_output_byte & free_in_buffer),
+ * reset the pointer & count to the start of the buffer, and return TRUE
+ * indicating that the buffer has been dumped.
+ *
+ * In applications that need to be able to suspend compression due to output
+ * overrun, a FALSE return indicates that the buffer cannot be emptied now.
+ * In this situation, the compressor will return to its caller (possibly with
+ * an indication that it has not accepted all the supplied scanlines).  The
+ * application should resume compression after it has made more room in the
+ * output buffer.  Note that there are substantial restrictions on the use of
+ * suspension --- see the documentation.
+ *
+ * When suspending, the compressor will back up to a convenient restart point
+ * (typically the start of the current MCU). next_output_byte & free_in_buffer
+ * indicate where the restart point will be if the current call returns FALSE.
+ * Data beyond this point will be regenerated after resumption, so do not
+ * write it out when emptying the buffer externally.
+ */
+
+METHODDEF(boolean)
+empty_output_buffer(j_compress_ptr cinfo)
+{
+  my_dest_ptr dest = (my_dest_ptr)cinfo->dest;
+
+  if (JFWRITE(dest->outfile, dest->buffer, OUTPUT_BUF_SIZE) !=
+      (size_t)OUTPUT_BUF_SIZE)
+    ERREXIT(cinfo, JERR_FILE_WRITE);
+
+  dest->pub.next_output_byte = dest->buffer;
+  dest->pub.free_in_buffer = OUTPUT_BUF_SIZE;
+
+  return TRUE;
+}
+
+#if JPEG_LIB_VERSION >= 80 || defined(MEM_SRCDST_SUPPORTED)
+METHODDEF(boolean)
+empty_mem_output_buffer(j_compress_ptr cinfo)
+{
+  size_t nextsize;
+  JOCTET *nextbuffer;
+  my_mem_dest_ptr dest = (my_mem_dest_ptr)cinfo->dest;
+
+  /* Try to allocate new buffer with double size */
+  nextsize = dest->bufsize * 2;
+  nextbuffer = (JOCTET *)malloc(nextsize);
+
+  if (nextbuffer == NULL)
+    ERREXIT1(cinfo, JERR_OUT_OF_MEMORY, 10);
+
+  MEMCOPY(nextbuffer, dest->buffer, dest->bufsize);
+
+  free(dest->newbuffer);
+
+  dest->newbuffer = nextbuffer;
+
+  dest->pub.next_output_byte = nextbuffer + dest->bufsize;
+  dest->pub.free_in_buffer = dest->bufsize;
+
+  dest->buffer = nextbuffer;
+  dest->bufsize = nextsize;
+
+  return TRUE;
+}
+#endif
+
+
+/*
+ * Terminate destination --- called by jpeg_finish_compress
+ * after all data has been written.  Usually needs to flush buffer.
+ *
+ * NB: *not* called by jpeg_abort or jpeg_destroy; surrounding
+ * application must deal with any cleanup that should happen even
+ * for error exit.
+ */
+
+METHODDEF(void)
+term_destination(j_compress_ptr cinfo)
+{
+  my_dest_ptr dest = (my_dest_ptr)cinfo->dest;
+  size_t datacount = OUTPUT_BUF_SIZE - dest->pub.free_in_buffer;
+
+  /* Write any data remaining in the buffer */
+  if (datacount > 0) {
+    if (JFWRITE(dest->outfile, dest->buffer, datacount) != datacount)
+      ERREXIT(cinfo, JERR_FILE_WRITE);
+  }
+  fflush(dest->outfile);
+  /* Make sure we wrote the output file OK */
+  if (ferror(dest->outfile))
+    ERREXIT(cinfo, JERR_FILE_WRITE);
+}
+
+#if JPEG_LIB_VERSION >= 80 || defined(MEM_SRCDST_SUPPORTED)
+METHODDEF(void)
+term_mem_destination(j_compress_ptr cinfo)
+{
+  my_mem_dest_ptr dest = (my_mem_dest_ptr)cinfo->dest;
+
+  *dest->outbuffer = dest->buffer;
+  *dest->outsize = (unsigned long)(dest->bufsize - dest->pub.free_in_buffer);
+}
+#endif
+
+
+/*
+ * Prepare for output to a stdio stream.
+ * The caller must have already opened the stream, and is responsible
+ * for closing it after finishing compression.
+ */
+
+GLOBAL(void)
+jpeg_stdio_dest(j_compress_ptr cinfo, FILE *outfile)
+{
+  my_dest_ptr dest;
+
+  /* The destination object is made permanent so that multiple JPEG images
+   * can be written to the same file without re-executing jpeg_stdio_dest.
+   */
+  if (cinfo->dest == NULL) {    /* first time for this JPEG object? */
+    cinfo->dest = (struct jpeg_destination_mgr *)
+      (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_PERMANENT,
+                                  sizeof(my_destination_mgr));
+  } else if (cinfo->dest->init_destination != init_destination) {
+    /* It is unsafe to reuse the existing destination manager unless it was
+     * created by this function.  Otherwise, there is no guarantee that the
+     * opaque structure is the right size.  Note that we could just create a
+     * new structure, but the old structure would not be freed until
+     * jpeg_destroy_compress() was called.
+     */
+    ERREXIT(cinfo, JERR_BUFFER_SIZE);
+  }
+
+  dest = (my_dest_ptr)cinfo->dest;
+  dest->pub.init_destination = init_destination;
+  dest->pub.empty_output_buffer = empty_output_buffer;
+  dest->pub.term_destination = term_destination;
+  dest->outfile = outfile;
+}
+
+
+#if JPEG_LIB_VERSION >= 80 || defined(MEM_SRCDST_SUPPORTED)
+/*
+ * Prepare for output to a memory buffer.
+ * The caller may supply an own initial buffer with appropriate size.
+ * Otherwise, or when the actual data output exceeds the given size,
+ * the library adapts the buffer size as necessary.
+ * The standard library functions malloc/free are used for allocating
+ * larger memory, so the buffer is available to the application after
+ * finishing compression, and then the application is responsible for
+ * freeing the requested memory.
+ * Note:  An initial buffer supplied by the caller is expected to be
+ * managed by the application.  The library does not free such buffer
+ * when allocating a larger buffer.
+ */
+
+GLOBAL(void)
+jpeg_mem_dest(j_compress_ptr cinfo, unsigned char **outbuffer,
+              unsigned long *outsize)
+{
+  my_mem_dest_ptr dest;
+
+  if (outbuffer == NULL || outsize == NULL)     /* sanity check */
+    ERREXIT(cinfo, JERR_BUFFER_SIZE);
+
+  /* The destination object is made permanent so that multiple JPEG images
+   * can be written to the same buffer without re-executing jpeg_mem_dest.
+   */
+  if (cinfo->dest == NULL) {    /* first time for this JPEG object? */
+    cinfo->dest = (struct jpeg_destination_mgr *)
+      (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_PERMANENT,
+                                  sizeof(my_mem_destination_mgr));
+  } else if (cinfo->dest->init_destination != init_mem_destination) {
+    /* It is unsafe to reuse the existing destination manager unless it was
+     * created by this function.
+     */
+    ERREXIT(cinfo, JERR_BUFFER_SIZE);
+  }
+
+  dest = (my_mem_dest_ptr)cinfo->dest;
+  dest->pub.init_destination = init_mem_destination;
+  dest->pub.empty_output_buffer = empty_mem_output_buffer;
+  dest->pub.term_destination = term_mem_destination;
+  dest->outbuffer = outbuffer;
+  dest->outsize = outsize;
+  dest->newbuffer = NULL;
+
+  if (*outbuffer == NULL || *outsize == 0) {
+    /* Allocate initial buffer */
+    dest->newbuffer = *outbuffer = (unsigned char *)malloc(OUTPUT_BUF_SIZE);
+    if (dest->newbuffer == NULL)
+      ERREXIT1(cinfo, JERR_OUT_OF_MEMORY, 10);
+    *outsize = OUTPUT_BUF_SIZE;
+  }
+
+  dest->pub.next_output_byte = dest->buffer = *outbuffer;
+  dest->pub.free_in_buffer = dest->bufsize = *outsize;
+}
+#endif
diff --git a/3rdparty/libjpeg/src/jdatasrc-tj.c b/3rdparty/libjpeg/src/jdatasrc-tj.c
new file mode 100644
index 00000000..69fb5eaa
--- /dev/null
+++ b/3rdparty/libjpeg/src/jdatasrc-tj.c
@@ -0,0 +1,194 @@
+/*
+ * jdatasrc-tj.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1994-1996, Thomas G. Lane.
+ * Modified 2009-2011 by Guido Vollbeding.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2011, 2016, 2019, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains decompression data source routines for the case of
+ * reading JPEG data from memory or from a file (or any stdio stream).
+ * While these routines are sufficient for most applications,
+ * some will want to use a different source manager.
+ * IMPORTANT: we assume that fread() will correctly transcribe an array of
+ * JOCTETs from 8-bit-wide elements on external storage.  If char is wider
+ * than 8 bits on your machine, you may need to do some tweaking.
+ */
+
+/* this is not a core library module, so it doesn't define JPEG_INTERNALS */
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jerror.h"
+
+void jpeg_mem_src_tj(j_decompress_ptr cinfo, const unsigned char *inbuffer,
+                     unsigned long insize);
+
+
+/*
+ * Initialize source --- called by jpeg_read_header
+ * before any data is actually read.
+ */
+
+METHODDEF(void)
+init_mem_source(j_decompress_ptr cinfo)
+{
+  /* no work necessary here */
+}
+
+
+/*
+ * Fill the input buffer --- called whenever buffer is emptied.
+ *
+ * In typical applications, this should read fresh data into the buffer
+ * (ignoring the current state of next_input_byte & bytes_in_buffer),
+ * reset the pointer & count to the start of the buffer, and return TRUE
+ * indicating that the buffer has been reloaded.  It is not necessary to
+ * fill the buffer entirely, only to obtain at least one more byte.
+ *
+ * There is no such thing as an EOF return.  If the end of the file has been
+ * reached, the routine has a choice of ERREXIT() or inserting fake data into
+ * the buffer.  In most cases, generating a warning message and inserting a
+ * fake EOI marker is the best course of action --- this will allow the
+ * decompressor to output however much of the image is there.  However,
+ * the resulting error message is misleading if the real problem is an empty
+ * input file, so we handle that case specially.
+ *
+ * In applications that need to be able to suspend compression due to input
+ * not being available yet, a FALSE return indicates that no more data can be
+ * obtained right now, but more may be forthcoming later.  In this situation,
+ * the decompressor will return to its caller (with an indication of the
+ * number of scanlines it has read, if any).  The application should resume
+ * decompression after it has loaded more data into the input buffer.  Note
+ * that there are substantial restrictions on the use of suspension --- see
+ * the documentation.
+ *
+ * When suspending, the decompressor will back up to a convenient restart point
+ * (typically the start of the current MCU). next_input_byte & bytes_in_buffer
+ * indicate where the restart point will be if the current call returns FALSE.
+ * Data beyond this point must be rescanned after resumption, so move it to
+ * the front of the buffer rather than discarding it.
+ */
+
+METHODDEF(boolean)
+fill_mem_input_buffer(j_decompress_ptr cinfo)
+{
+  static const JOCTET mybuffer[4] = {
+    (JOCTET)0xFF, (JOCTET)JPEG_EOI, 0, 0
+  };
+
+  /* The whole JPEG data is expected to reside in the supplied memory
+   * buffer, so any request for more data beyond the given buffer size
+   * is treated as an error.
+   */
+  WARNMS(cinfo, JWRN_JPEG_EOF);
+
+  /* Insert a fake EOI marker */
+
+  cinfo->src->next_input_byte = mybuffer;
+  cinfo->src->bytes_in_buffer = 2;
+
+  return TRUE;
+}
+
+
+/*
+ * Skip data --- used to skip over a potentially large amount of
+ * uninteresting data (such as an APPn marker).
+ *
+ * Writers of suspendable-input applications must note that skip_input_data
+ * is not granted the right to give a suspension return.  If the skip extends
+ * beyond the data currently in the buffer, the buffer can be marked empty so
+ * that the next read will cause a fill_input_buffer call that can suspend.
+ * Arranging for additional bytes to be discarded before reloading the input
+ * buffer is the application writer's problem.
+ */
+
+METHODDEF(void)
+skip_input_data(j_decompress_ptr cinfo, long num_bytes)
+{
+  struct jpeg_source_mgr *src = cinfo->src;
+
+  /* Just a dumb implementation for now.  Could use fseek() except
+   * it doesn't work on pipes.  Not clear that being smart is worth
+   * any trouble anyway --- large skips are infrequent.
+   */
+  if (num_bytes > 0) {
+    while (num_bytes > (long)src->bytes_in_buffer) {
+      num_bytes -= (long)src->bytes_in_buffer;
+      (void)(*src->fill_input_buffer) (cinfo);
+      /* note we assume that fill_input_buffer will never return FALSE,
+       * so suspension need not be handled.
+       */
+    }
+    src->next_input_byte += (size_t)num_bytes;
+    src->bytes_in_buffer -= (size_t)num_bytes;
+  }
+}
+
+
+/*
+ * An additional method that can be provided by data source modules is the
+ * resync_to_restart method for error recovery in the presence of RST markers.
+ * For the moment, this source module just uses the default resync method
+ * provided by the JPEG library.  That method assumes that no backtracking
+ * is possible.
+ */
+
+
+/*
+ * Terminate source --- called by jpeg_finish_decompress
+ * after all data has been read.  Often a no-op.
+ *
+ * NB: *not* called by jpeg_abort or jpeg_destroy; surrounding
+ * application must deal with any cleanup that should happen even
+ * for error exit.
+ */
+
+METHODDEF(void)
+term_source(j_decompress_ptr cinfo)
+{
+  /* no work necessary here */
+}
+
+
+/*
+ * Prepare for input from a supplied memory buffer.
+ * The buffer must contain the whole JPEG data.
+ */
+
+GLOBAL(void)
+jpeg_mem_src_tj(j_decompress_ptr cinfo, const unsigned char *inbuffer,
+                unsigned long insize)
+{
+  struct jpeg_source_mgr *src;
+
+  if (inbuffer == NULL || insize == 0)  /* Treat empty input as fatal error */
+    ERREXIT(cinfo, JERR_INPUT_EMPTY);
+
+  /* The source object is made permanent so that a series of JPEG images
+   * can be read from the same buffer by calling jpeg_mem_src only before
+   * the first one.
+   */
+  if (cinfo->src == NULL) {     /* first time for this JPEG object? */
+    cinfo->src = (struct jpeg_source_mgr *)
+      (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_PERMANENT,
+                                  sizeof(struct jpeg_source_mgr));
+  } else if (cinfo->src->init_source != init_mem_source) {
+    /* It is unsafe to reuse the existing source manager unless it was created
+     * by this function.
+     */
+    ERREXIT(cinfo, JERR_BUFFER_SIZE);
+  }
+
+  src = cinfo->src;
+  src->init_source = init_mem_source;
+  src->fill_input_buffer = fill_mem_input_buffer;
+  src->skip_input_data = skip_input_data;
+  src->resync_to_restart = jpeg_resync_to_restart; /* use default method */
+  src->term_source = term_source;
+  src->bytes_in_buffer = (size_t)insize;
+  src->next_input_byte = (const JOCTET *)inbuffer;
+}
diff --git a/3rdparty/libjpeg/src/jdatasrc.c b/3rdparty/libjpeg/src/jdatasrc.c
new file mode 100644
index 00000000..eadb4a2c
--- /dev/null
+++ b/3rdparty/libjpeg/src/jdatasrc.c
@@ -0,0 +1,295 @@
+/*
+ * jdatasrc.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1994-1996, Thomas G. Lane.
+ * Modified 2009-2011 by Guido Vollbeding.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2013, 2016, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains decompression data source routines for the case of
+ * reading JPEG data from memory or from a file (or any stdio stream).
+ * While these routines are sufficient for most applications,
+ * some will want to use a different source manager.
+ * IMPORTANT: we assume that fread() will correctly transcribe an array of
+ * JOCTETs from 8-bit-wide elements on external storage.  If char is wider
+ * than 8 bits on your machine, you may need to do some tweaking.
+ */
+
+/* this is not a core library module, so it doesn't define JPEG_INTERNALS */
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jerror.h"
+
+
+/* Expanded data source object for stdio input */
+
+typedef struct {
+  struct jpeg_source_mgr pub;   /* public fields */
+
+  FILE *infile;                 /* source stream */
+  JOCTET *buffer;               /* start of buffer */
+  boolean start_of_file;        /* have we gotten any data yet? */
+} my_source_mgr;
+
+typedef my_source_mgr *my_src_ptr;
+
+#define INPUT_BUF_SIZE  4096    /* choose an efficiently fread'able size */
+
+
+/*
+ * Initialize source --- called by jpeg_read_header
+ * before any data is actually read.
+ */
+
+METHODDEF(void)
+init_source(j_decompress_ptr cinfo)
+{
+  my_src_ptr src = (my_src_ptr)cinfo->src;
+
+  /* We reset the empty-input-file flag for each image,
+   * but we don't clear the input buffer.
+   * This is correct behavior for reading a series of images from one source.
+   */
+  src->start_of_file = TRUE;
+}
+
+#if JPEG_LIB_VERSION >= 80 || defined(MEM_SRCDST_SUPPORTED)
+METHODDEF(void)
+init_mem_source(j_decompress_ptr cinfo)
+{
+  /* no work necessary here */
+}
+#endif
+
+
+/*
+ * Fill the input buffer --- called whenever buffer is emptied.
+ *
+ * In typical applications, this should read fresh data into the buffer
+ * (ignoring the current state of next_input_byte & bytes_in_buffer),
+ * reset the pointer & count to the start of the buffer, and return TRUE
+ * indicating that the buffer has been reloaded.  It is not necessary to
+ * fill the buffer entirely, only to obtain at least one more byte.
+ *
+ * There is no such thing as an EOF return.  If the end of the file has been
+ * reached, the routine has a choice of ERREXIT() or inserting fake data into
+ * the buffer.  In most cases, generating a warning message and inserting a
+ * fake EOI marker is the best course of action --- this will allow the
+ * decompressor to output however much of the image is there.  However,
+ * the resulting error message is misleading if the real problem is an empty
+ * input file, so we handle that case specially.
+ *
+ * In applications that need to be able to suspend compression due to input
+ * not being available yet, a FALSE return indicates that no more data can be
+ * obtained right now, but more may be forthcoming later.  In this situation,
+ * the decompressor will return to its caller (with an indication of the
+ * number of scanlines it has read, if any).  The application should resume
+ * decompression after it has loaded more data into the input buffer.  Note
+ * that there are substantial restrictions on the use of suspension --- see
+ * the documentation.
+ *
+ * When suspending, the decompressor will back up to a convenient restart point
+ * (typically the start of the current MCU). next_input_byte & bytes_in_buffer
+ * indicate where the restart point will be if the current call returns FALSE.
+ * Data beyond this point must be rescanned after resumption, so move it to
+ * the front of the buffer rather than discarding it.
+ */
+
+METHODDEF(boolean)
+fill_input_buffer(j_decompress_ptr cinfo)
+{
+  my_src_ptr src = (my_src_ptr)cinfo->src;
+  size_t nbytes;
+
+  nbytes = JFREAD(src->infile, src->buffer, INPUT_BUF_SIZE);
+
+  if (nbytes <= 0) {
+    if (src->start_of_file)     /* Treat empty input file as fatal error */
+      ERREXIT(cinfo, JERR_INPUT_EMPTY);
+    WARNMS(cinfo, JWRN_JPEG_EOF);
+    /* Insert a fake EOI marker */
+    src->buffer[0] = (JOCTET)0xFF;
+    src->buffer[1] = (JOCTET)JPEG_EOI;
+    nbytes = 2;
+  }
+
+  src->pub.next_input_byte = src->buffer;
+  src->pub.bytes_in_buffer = nbytes;
+  src->start_of_file = FALSE;
+
+  return TRUE;
+}
+
+#if JPEG_LIB_VERSION >= 80 || defined(MEM_SRCDST_SUPPORTED)
+METHODDEF(boolean)
+fill_mem_input_buffer(j_decompress_ptr cinfo)
+{
+  static const JOCTET mybuffer[4] = {
+    (JOCTET)0xFF, (JOCTET)JPEG_EOI, 0, 0
+  };
+
+  /* The whole JPEG data is expected to reside in the supplied memory
+   * buffer, so any request for more data beyond the given buffer size
+   * is treated as an error.
+   */
+  WARNMS(cinfo, JWRN_JPEG_EOF);
+
+  /* Insert a fake EOI marker */
+
+  cinfo->src->next_input_byte = mybuffer;
+  cinfo->src->bytes_in_buffer = 2;
+
+  return TRUE;
+}
+#endif
+
+
+/*
+ * Skip data --- used to skip over a potentially large amount of
+ * uninteresting data (such as an APPn marker).
+ *
+ * Writers of suspendable-input applications must note that skip_input_data
+ * is not granted the right to give a suspension return.  If the skip extends
+ * beyond the data currently in the buffer, the buffer can be marked empty so
+ * that the next read will cause a fill_input_buffer call that can suspend.
+ * Arranging for additional bytes to be discarded before reloading the input
+ * buffer is the application writer's problem.
+ */
+
+METHODDEF(void)
+skip_input_data(j_decompress_ptr cinfo, long num_bytes)
+{
+  struct jpeg_source_mgr *src = cinfo->src;
+
+  /* Just a dumb implementation for now.  Could use fseek() except
+   * it doesn't work on pipes.  Not clear that being smart is worth
+   * any trouble anyway --- large skips are infrequent.
+   */
+  if (num_bytes > 0) {
+    while (num_bytes > (long)src->bytes_in_buffer) {
+      num_bytes -= (long)src->bytes_in_buffer;
+      (void)(*src->fill_input_buffer) (cinfo);
+      /* note we assume that fill_input_buffer will never return FALSE,
+       * so suspension need not be handled.
+       */
+    }
+    src->next_input_byte += (size_t)num_bytes;
+    src->bytes_in_buffer -= (size_t)num_bytes;
+  }
+}
+
+
+/*
+ * An additional method that can be provided by data source modules is the
+ * resync_to_restart method for error recovery in the presence of RST markers.
+ * For the moment, this source module just uses the default resync method
+ * provided by the JPEG library.  That method assumes that no backtracking
+ * is possible.
+ */
+
+
+/*
+ * Terminate source --- called by jpeg_finish_decompress
+ * after all data has been read.  Often a no-op.
+ *
+ * NB: *not* called by jpeg_abort or jpeg_destroy; surrounding
+ * application must deal with any cleanup that should happen even
+ * for error exit.
+ */
+
+METHODDEF(void)
+term_source(j_decompress_ptr cinfo)
+{
+  /* no work necessary here */
+}
+
+
+/*
+ * Prepare for input from a stdio stream.
+ * The caller must have already opened the stream, and is responsible
+ * for closing it after finishing decompression.
+ */
+
+GLOBAL(void)
+jpeg_stdio_src(j_decompress_ptr cinfo, FILE *infile)
+{
+  my_src_ptr src;
+
+  /* The source object and input buffer are made permanent so that a series
+   * of JPEG images can be read from the same file by calling jpeg_stdio_src
+   * only before the first one.  (If we discarded the buffer at the end of
+   * one image, we'd likely lose the start of the next one.)
+   */
+  if (cinfo->src == NULL) {     /* first time for this JPEG object? */
+    cinfo->src = (struct jpeg_source_mgr *)
+      (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_PERMANENT,
+                                  sizeof(my_source_mgr));
+    src = (my_src_ptr)cinfo->src;
+    src->buffer = (JOCTET *)
+      (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_PERMANENT,
+                                  INPUT_BUF_SIZE * sizeof(JOCTET));
+  } else if (cinfo->src->init_source != init_source) {
+    /* It is unsafe to reuse the existing source manager unless it was created
+     * by this function.  Otherwise, there is no guarantee that the opaque
+     * structure is the right size.  Note that we could just create a new
+     * structure, but the old structure would not be freed until
+     * jpeg_destroy_decompress() was called.
+     */
+    ERREXIT(cinfo, JERR_BUFFER_SIZE);
+  }
+
+  src = (my_src_ptr)cinfo->src;
+  src->pub.init_source = init_source;
+  src->pub.fill_input_buffer = fill_input_buffer;
+  src->pub.skip_input_data = skip_input_data;
+  src->pub.resync_to_restart = jpeg_resync_to_restart; /* use default method */
+  src->pub.term_source = term_source;
+  src->infile = infile;
+  src->pub.bytes_in_buffer = 0; /* forces fill_input_buffer on first read */
+  src->pub.next_input_byte = NULL; /* until buffer loaded */
+}
+
+
+#if JPEG_LIB_VERSION >= 80 || defined(MEM_SRCDST_SUPPORTED)
+/*
+ * Prepare for input from a supplied memory buffer.
+ * The buffer must contain the whole JPEG data.
+ */
+
+GLOBAL(void)
+jpeg_mem_src(j_decompress_ptr cinfo, const unsigned char *inbuffer,
+             unsigned long insize)
+{
+  struct jpeg_source_mgr *src;
+
+  if (inbuffer == NULL || insize == 0)  /* Treat empty input as fatal error */
+    ERREXIT(cinfo, JERR_INPUT_EMPTY);
+
+  /* The source object is made permanent so that a series of JPEG images
+   * can be read from the same buffer by calling jpeg_mem_src only before
+   * the first one.
+   */
+  if (cinfo->src == NULL) {     /* first time for this JPEG object? */
+    cinfo->src = (struct jpeg_source_mgr *)
+      (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_PERMANENT,
+                                  sizeof(struct jpeg_source_mgr));
+  } else if (cinfo->src->init_source != init_mem_source) {
+    /* It is unsafe to reuse the existing source manager unless it was created
+     * by this function.
+     */
+    ERREXIT(cinfo, JERR_BUFFER_SIZE);
+  }
+
+  src = cinfo->src;
+  src->init_source = init_mem_source;
+  src->fill_input_buffer = fill_mem_input_buffer;
+  src->skip_input_data = skip_input_data;
+  src->resync_to_restart = jpeg_resync_to_restart; /* use default method */
+  src->term_source = term_source;
+  src->bytes_in_buffer = (size_t)insize;
+  src->next_input_byte = (const JOCTET *)inbuffer;
+}
+#endif
diff --git a/3rdparty/libjpeg/src/jdcoefct.c b/3rdparty/libjpeg/src/jdcoefct.c
new file mode 100644
index 00000000..699a4809
--- /dev/null
+++ b/3rdparty/libjpeg/src/jdcoefct.c
@@ -0,0 +1,876 @@
+/*
+ * jdcoefct.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1994-1997, Thomas G. Lane.
+ * libjpeg-turbo Modifications:
+ * Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+ * Copyright (C) 2010, 2015-2016, 2019-2020, D. R. Commander.
+ * Copyright (C) 2015, 2020, Google, Inc.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains the coefficient buffer controller for decompression.
+ * This controller is the top level of the JPEG decompressor proper.
+ * The coefficient buffer lies between entropy decoding and inverse-DCT steps.
+ *
+ * In buffered-image mode, this controller is the interface between
+ * input-oriented processing and output-oriented processing.
+ * Also, the input side (only) is used when reading a file for transcoding.
+ */
+
+#include "jinclude.h"
+#include "jdcoefct.h"
+#include "jpegcomp.h"
+
+
+/* Forward declarations */
+METHODDEF(int) decompress_onepass(j_decompress_ptr cinfo,
+                                  JSAMPIMAGE output_buf);
+#ifdef D_MULTISCAN_FILES_SUPPORTED
+METHODDEF(int) decompress_data(j_decompress_ptr cinfo, JSAMPIMAGE output_buf);
+#endif
+#ifdef BLOCK_SMOOTHING_SUPPORTED
+LOCAL(boolean) smoothing_ok(j_decompress_ptr cinfo);
+METHODDEF(int) decompress_smooth_data(j_decompress_ptr cinfo,
+                                      JSAMPIMAGE output_buf);
+#endif
+
+
+/*
+ * Initialize for an input processing pass.
+ */
+
+METHODDEF(void)
+start_input_pass(j_decompress_ptr cinfo)
+{
+  cinfo->input_iMCU_row = 0;
+  start_iMCU_row(cinfo);
+}
+
+
+/*
+ * Initialize for an output processing pass.
+ */
+
+METHODDEF(void)
+start_output_pass(j_decompress_ptr cinfo)
+{
+#ifdef BLOCK_SMOOTHING_SUPPORTED
+  my_coef_ptr coef = (my_coef_ptr)cinfo->coef;
+
+  /* If multipass, check to see whether to use block smoothing on this pass */
+  if (coef->pub.coef_arrays != NULL) {
+    if (cinfo->do_block_smoothing && smoothing_ok(cinfo))
+      coef->pub.decompress_data = decompress_smooth_data;
+    else
+      coef->pub.decompress_data = decompress_data;
+  }
+#endif
+  cinfo->output_iMCU_row = 0;
+}
+
+
+/*
+ * Decompress and return some data in the single-pass case.
+ * Always attempts to emit one fully interleaved MCU row ("iMCU" row).
+ * Input and output must run in lockstep since we have only a one-MCU buffer.
+ * Return value is JPEG_ROW_COMPLETED, JPEG_SCAN_COMPLETED, or JPEG_SUSPENDED.
+ *
+ * NB: output_buf contains a plane for each component in image,
+ * which we index according to the component's SOF position.
+ */
+
+METHODDEF(int)
+decompress_onepass(j_decompress_ptr cinfo, JSAMPIMAGE output_buf)
+{
+  my_coef_ptr coef = (my_coef_ptr)cinfo->coef;
+  JDIMENSION MCU_col_num;       /* index of current MCU within row */
+  JDIMENSION last_MCU_col = cinfo->MCUs_per_row - 1;
+  JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1;
+  int blkn, ci, xindex, yindex, yoffset, useful_width;
+  JSAMPARRAY output_ptr;
+  JDIMENSION start_col, output_col;
+  jpeg_component_info *compptr;
+  inverse_DCT_method_ptr inverse_DCT;
+
+  /* Loop to process as much as one whole iMCU row */
+  for (yoffset = coef->MCU_vert_offset; yoffset < coef->MCU_rows_per_iMCU_row;
+       yoffset++) {
+    for (MCU_col_num = coef->MCU_ctr; MCU_col_num <= last_MCU_col;
+         MCU_col_num++) {
+      /* Try to fetch an MCU.  Entropy decoder expects buffer to be zeroed. */
+      jzero_far((void *)coef->MCU_buffer[0],
+                (size_t)(cinfo->blocks_in_MCU * sizeof(JBLOCK)));
+      if (!cinfo->entropy->insufficient_data)
+        cinfo->master->last_good_iMCU_row = cinfo->input_iMCU_row;
+      if (!(*cinfo->entropy->decode_mcu) (cinfo, coef->MCU_buffer)) {
+        /* Suspension forced; update state counters and exit */
+        coef->MCU_vert_offset = yoffset;
+        coef->MCU_ctr = MCU_col_num;
+        return JPEG_SUSPENDED;
+      }
+
+      /* Only perform the IDCT on blocks that are contained within the desired
+       * cropping region.
+       */
+      if (MCU_col_num >= cinfo->master->first_iMCU_col &&
+          MCU_col_num <= cinfo->master->last_iMCU_col) {
+        /* Determine where data should go in output_buf and do the IDCT thing.
+         * We skip dummy blocks at the right and bottom edges (but blkn gets
+         * incremented past them!).  Note the inner loop relies on having
+         * allocated the MCU_buffer[] blocks sequentially.
+         */
+        blkn = 0;               /* index of current DCT block within MCU */
+        for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+          compptr = cinfo->cur_comp_info[ci];
+          /* Don't bother to IDCT an uninteresting component. */
+          if (!compptr->component_needed) {
+            blkn += compptr->MCU_blocks;
+            continue;
+          }
+          inverse_DCT = cinfo->idct->inverse_DCT[compptr->component_index];
+          useful_width = (MCU_col_num < last_MCU_col) ?
+                         compptr->MCU_width : compptr->last_col_width;
+          output_ptr = output_buf[compptr->component_index] +
+                       yoffset * compptr->_DCT_scaled_size;
+          start_col = (MCU_col_num - cinfo->master->first_iMCU_col) *
+                      compptr->MCU_sample_width;
+          for (yindex = 0; yindex < compptr->MCU_height; yindex++) {
+            if (cinfo->input_iMCU_row < last_iMCU_row ||
+                yoffset + yindex < compptr->last_row_height) {
+              output_col = start_col;
+              for (xindex = 0; xindex < useful_width; xindex++) {
+                (*inverse_DCT) (cinfo, compptr,
+                                (JCOEFPTR)coef->MCU_buffer[blkn + xindex],
+                                output_ptr, output_col);
+                output_col += compptr->_DCT_scaled_size;
+              }
+            }
+            blkn += compptr->MCU_width;
+            output_ptr += compptr->_DCT_scaled_size;
+          }
+        }
+      }
+    }
+    /* Completed an MCU row, but perhaps not an iMCU row */
+    coef->MCU_ctr = 0;
+  }
+  /* Completed the iMCU row, advance counters for next one */
+  cinfo->output_iMCU_row++;
+  if (++(cinfo->input_iMCU_row) < cinfo->total_iMCU_rows) {
+    start_iMCU_row(cinfo);
+    return JPEG_ROW_COMPLETED;
+  }
+  /* Completed the scan */
+  (*cinfo->inputctl->finish_input_pass) (cinfo);
+  return JPEG_SCAN_COMPLETED;
+}
+
+
+/*
+ * Dummy consume-input routine for single-pass operation.
+ */
+
+METHODDEF(int)
+dummy_consume_data(j_decompress_ptr cinfo)
+{
+  return JPEG_SUSPENDED;        /* Always indicate nothing was done */
+}
+
+
+#ifdef D_MULTISCAN_FILES_SUPPORTED
+
+/*
+ * Consume input data and store it in the full-image coefficient buffer.
+ * We read as much as one fully interleaved MCU row ("iMCU" row) per call,
+ * ie, v_samp_factor block rows for each component in the scan.
+ * Return value is JPEG_ROW_COMPLETED, JPEG_SCAN_COMPLETED, or JPEG_SUSPENDED.
+ */
+
+METHODDEF(int)
+consume_data(j_decompress_ptr cinfo)
+{
+  my_coef_ptr coef = (my_coef_ptr)cinfo->coef;
+  JDIMENSION MCU_col_num;       /* index of current MCU within row */
+  int blkn, ci, xindex, yindex, yoffset;
+  JDIMENSION start_col;
+  JBLOCKARRAY buffer[MAX_COMPS_IN_SCAN];
+  JBLOCKROW buffer_ptr;
+  jpeg_component_info *compptr;
+
+  /* Align the virtual buffers for the components used in this scan. */
+  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+    compptr = cinfo->cur_comp_info[ci];
+    buffer[ci] = (*cinfo->mem->access_virt_barray)
+      ((j_common_ptr)cinfo, coef->whole_image[compptr->component_index],
+       cinfo->input_iMCU_row * compptr->v_samp_factor,
+       (JDIMENSION)compptr->v_samp_factor, TRUE);
+    /* Note: entropy decoder expects buffer to be zeroed,
+     * but this is handled automatically by the memory manager
+     * because we requested a pre-zeroed array.
+     */
+  }
+
+  /* Loop to process one whole iMCU row */
+  for (yoffset = coef->MCU_vert_offset; yoffset < coef->MCU_rows_per_iMCU_row;
+       yoffset++) {
+    for (MCU_col_num = coef->MCU_ctr; MCU_col_num < cinfo->MCUs_per_row;
+         MCU_col_num++) {
+      /* Construct list of pointers to DCT blocks belonging to this MCU */
+      blkn = 0;                 /* index of current DCT block within MCU */
+      for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+        compptr = cinfo->cur_comp_info[ci];
+        start_col = MCU_col_num * compptr->MCU_width;
+        for (yindex = 0; yindex < compptr->MCU_height; yindex++) {
+          buffer_ptr = buffer[ci][yindex + yoffset] + start_col;
+          for (xindex = 0; xindex < compptr->MCU_width; xindex++) {
+            coef->MCU_buffer[blkn++] = buffer_ptr++;
+          }
+        }
+      }
+      if (!cinfo->entropy->insufficient_data)
+        cinfo->master->last_good_iMCU_row = cinfo->input_iMCU_row;
+      /* Try to fetch the MCU. */
+      if (!(*cinfo->entropy->decode_mcu) (cinfo, coef->MCU_buffer)) {
+        /* Suspension forced; update state counters and exit */
+        coef->MCU_vert_offset = yoffset;
+        coef->MCU_ctr = MCU_col_num;
+        return JPEG_SUSPENDED;
+      }
+    }
+    /* Completed an MCU row, but perhaps not an iMCU row */
+    coef->MCU_ctr = 0;
+  }
+  /* Completed the iMCU row, advance counters for next one */
+  if (++(cinfo->input_iMCU_row) < cinfo->total_iMCU_rows) {
+    start_iMCU_row(cinfo);
+    return JPEG_ROW_COMPLETED;
+  }
+  /* Completed the scan */
+  (*cinfo->inputctl->finish_input_pass) (cinfo);
+  return JPEG_SCAN_COMPLETED;
+}
+
+
+/*
+ * Decompress and return some data in the multi-pass case.
+ * Always attempts to emit one fully interleaved MCU row ("iMCU" row).
+ * Return value is JPEG_ROW_COMPLETED, JPEG_SCAN_COMPLETED, or JPEG_SUSPENDED.
+ *
+ * NB: output_buf contains a plane for each component in image.
+ */
+
+METHODDEF(int)
+decompress_data(j_decompress_ptr cinfo, JSAMPIMAGE output_buf)
+{
+  my_coef_ptr coef = (my_coef_ptr)cinfo->coef;
+  JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1;
+  JDIMENSION block_num;
+  int ci, block_row, block_rows;
+  JBLOCKARRAY buffer;
+  JBLOCKROW buffer_ptr;
+  JSAMPARRAY output_ptr;
+  JDIMENSION output_col;
+  jpeg_component_info *compptr;
+  inverse_DCT_method_ptr inverse_DCT;
+
+  /* Force some input to be done if we are getting ahead of the input. */
+  while (cinfo->input_scan_number < cinfo->output_scan_number ||
+         (cinfo->input_scan_number == cinfo->output_scan_number &&
+          cinfo->input_iMCU_row <= cinfo->output_iMCU_row)) {
+    if ((*cinfo->inputctl->consume_input) (cinfo) == JPEG_SUSPENDED)
+      return JPEG_SUSPENDED;
+  }
+
+  /* OK, output from the virtual arrays. */
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    /* Don't bother to IDCT an uninteresting component. */
+    if (!compptr->component_needed)
+      continue;
+    /* Align the virtual buffer for this component. */
+    buffer = (*cinfo->mem->access_virt_barray)
+      ((j_common_ptr)cinfo, coef->whole_image[ci],
+       cinfo->output_iMCU_row * compptr->v_samp_factor,
+       (JDIMENSION)compptr->v_samp_factor, FALSE);
+    /* Count non-dummy DCT block rows in this iMCU row. */
+    if (cinfo->output_iMCU_row < last_iMCU_row)
+      block_rows = compptr->v_samp_factor;
+    else {
+      /* NB: can't use last_row_height here; it is input-side-dependent! */
+      block_rows = (int)(compptr->height_in_blocks % compptr->v_samp_factor);
+      if (block_rows == 0) block_rows = compptr->v_samp_factor;
+    }
+    inverse_DCT = cinfo->idct->inverse_DCT[ci];
+    output_ptr = output_buf[ci];
+    /* Loop over all DCT blocks to be processed. */
+    for (block_row = 0; block_row < block_rows; block_row++) {
+      buffer_ptr = buffer[block_row] + cinfo->master->first_MCU_col[ci];
+      output_col = 0;
+      for (block_num = cinfo->master->first_MCU_col[ci];
+           block_num <= cinfo->master->last_MCU_col[ci]; block_num++) {
+        (*inverse_DCT) (cinfo, compptr, (JCOEFPTR)buffer_ptr, output_ptr,
+                        output_col);
+        buffer_ptr++;
+        output_col += compptr->_DCT_scaled_size;
+      }
+      output_ptr += compptr->_DCT_scaled_size;
+    }
+  }
+
+  if (++(cinfo->output_iMCU_row) < cinfo->total_iMCU_rows)
+    return JPEG_ROW_COMPLETED;
+  return JPEG_SCAN_COMPLETED;
+}
+
+#endif /* D_MULTISCAN_FILES_SUPPORTED */
+
+
+#ifdef BLOCK_SMOOTHING_SUPPORTED
+
+/*
+ * This code applies interblock smoothing; the first 9 AC coefficients are
+ * estimated from the DC values of a DCT block and its 24 neighboring blocks.
+ * We apply smoothing only for progressive JPEG decoding, and only if
+ * the coefficients it can estimate are not yet known to full precision.
+ */
+
+/* Natural-order array positions of the first 9 zigzag-order coefficients */
+#define Q01_POS  1
+#define Q10_POS  8
+#define Q20_POS  16
+#define Q11_POS  9
+#define Q02_POS  2
+#define Q03_POS  3
+#define Q12_POS  10
+#define Q21_POS  17
+#define Q30_POS  24
+
+/*
+ * Determine whether block smoothing is applicable and safe.
+ * We also latch the current states of the coef_bits[] entries for the
+ * AC coefficients; otherwise, if the input side of the decompressor
+ * advances into a new scan, we might think the coefficients are known
+ * more accurately than they really are.
+ */
+
+LOCAL(boolean)
+smoothing_ok(j_decompress_ptr cinfo)
+{
+  my_coef_ptr coef = (my_coef_ptr)cinfo->coef;
+  boolean smoothing_useful = FALSE;
+  int ci, coefi;
+  jpeg_component_info *compptr;
+  JQUANT_TBL *qtable;
+  int *coef_bits, *prev_coef_bits;
+  int *coef_bits_latch, *prev_coef_bits_latch;
+
+  if (!cinfo->progressive_mode || cinfo->coef_bits == NULL)
+    return FALSE;
+
+  /* Allocate latch area if not already done */
+  if (coef->coef_bits_latch == NULL)
+    coef->coef_bits_latch = (int *)
+      (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+                                  cinfo->num_components * 2 *
+                                  (SAVED_COEFS * sizeof(int)));
+  coef_bits_latch = coef->coef_bits_latch;
+  prev_coef_bits_latch =
+    &coef->coef_bits_latch[cinfo->num_components * SAVED_COEFS];
+
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    /* All components' quantization values must already be latched. */
+    if ((qtable = compptr->quant_table) == NULL)
+      return FALSE;
+    /* Verify DC & first 9 AC quantizers are nonzero to avoid zero-divide. */
+    if (qtable->quantval[0] == 0 ||
+        qtable->quantval[Q01_POS] == 0 ||
+        qtable->quantval[Q10_POS] == 0 ||
+        qtable->quantval[Q20_POS] == 0 ||
+        qtable->quantval[Q11_POS] == 0 ||
+        qtable->quantval[Q02_POS] == 0 ||
+        qtable->quantval[Q03_POS] == 0 ||
+        qtable->quantval[Q12_POS] == 0 ||
+        qtable->quantval[Q21_POS] == 0 ||
+        qtable->quantval[Q30_POS] == 0)
+      return FALSE;
+    /* DC values must be at least partly known for all components. */
+    coef_bits = cinfo->coef_bits[ci];
+    prev_coef_bits = cinfo->coef_bits[ci + cinfo->num_components];
+    if (coef_bits[0] < 0)
+      return FALSE;
+    coef_bits_latch[0] = coef_bits[0];
+    /* Block smoothing is helpful if some AC coefficients remain inaccurate. */
+    for (coefi = 1; coefi < SAVED_COEFS; coefi++) {
+      if (cinfo->input_scan_number > 1)
+        prev_coef_bits_latch[coefi] = prev_coef_bits[coefi];
+      coef_bits_latch[coefi] = coef_bits[coefi];
+      if (coef_bits[coefi] != 0)
+        smoothing_useful = TRUE;
+    }
+    coef_bits_latch += SAVED_COEFS;
+    prev_coef_bits_latch += SAVED_COEFS;
+  }
+
+  return smoothing_useful;
+}
+
+
+/*
+ * Variant of decompress_data for use when doing block smoothing.
+ */
+
+METHODDEF(int)
+decompress_smooth_data(j_decompress_ptr cinfo, JSAMPIMAGE output_buf)
+{
+  my_coef_ptr coef = (my_coef_ptr)cinfo->coef;
+  JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1;
+  JDIMENSION block_num, last_block_column;
+  int ci, block_row, block_rows, access_rows;
+  JBLOCKARRAY buffer;
+  JBLOCKROW buffer_ptr, prev_prev_block_row, prev_block_row;
+  JBLOCKROW next_block_row, next_next_block_row;
+  JSAMPARRAY output_ptr;
+  JDIMENSION output_col;
+  jpeg_component_info *compptr;
+  inverse_DCT_method_ptr inverse_DCT;
+  boolean change_dc;
+  JCOEF *workspace;
+  int *coef_bits;
+  JQUANT_TBL *quanttbl;
+  JLONG Q00, Q01, Q02, Q03 = 0, Q10, Q11, Q12 = 0, Q20, Q21 = 0, Q30 = 0, num;
+  int DC01, DC02, DC03, DC04, DC05, DC06, DC07, DC08, DC09, DC10, DC11, DC12,
+      DC13, DC14, DC15, DC16, DC17, DC18, DC19, DC20, DC21, DC22, DC23, DC24,
+      DC25;
+  int Al, pred;
+
+  /* Keep a local variable to avoid looking it up more than once */
+  workspace = coef->workspace;
+
+  /* Force some input to be done if we are getting ahead of the input. */
+  while (cinfo->input_scan_number <= cinfo->output_scan_number &&
+         !cinfo->inputctl->eoi_reached) {
+    if (cinfo->input_scan_number == cinfo->output_scan_number) {
+      /* If input is working on current scan, we ordinarily want it to
+       * have completed the current row.  But if input scan is DC,
+       * we want it to keep two rows ahead so that next two block rows' DC
+       * values are up to date.
+       */
+      JDIMENSION delta = (cinfo->Ss == 0) ? 2 : 0;
+      if (cinfo->input_iMCU_row > cinfo->output_iMCU_row + delta)
+        break;
+    }
+    if ((*cinfo->inputctl->consume_input) (cinfo) == JPEG_SUSPENDED)
+      return JPEG_SUSPENDED;
+  }
+
+  /* OK, output from the virtual arrays. */
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    /* Don't bother to IDCT an uninteresting component. */
+    if (!compptr->component_needed)
+      continue;
+    /* Count non-dummy DCT block rows in this iMCU row. */
+    if (cinfo->output_iMCU_row < last_iMCU_row - 1) {
+      block_rows = compptr->v_samp_factor;
+      access_rows = block_rows * 3; /* this and next two iMCU rows */
+    } else if (cinfo->output_iMCU_row < last_iMCU_row) {
+      block_rows = compptr->v_samp_factor;
+      access_rows = block_rows * 2; /* this and next iMCU row */
+    } else {
+      /* NB: can't use last_row_height here; it is input-side-dependent! */
+      block_rows = (int)(compptr->height_in_blocks % compptr->v_samp_factor);
+      if (block_rows == 0) block_rows = compptr->v_samp_factor;
+      access_rows = block_rows; /* this iMCU row only */
+    }
+    /* Align the virtual buffer for this component. */
+    if (cinfo->output_iMCU_row > 1) {
+      access_rows += 2 * compptr->v_samp_factor; /* prior two iMCU rows too */
+      buffer = (*cinfo->mem->access_virt_barray)
+        ((j_common_ptr)cinfo, coef->whole_image[ci],
+         (cinfo->output_iMCU_row - 2) * compptr->v_samp_factor,
+         (JDIMENSION)access_rows, FALSE);
+      buffer += 2 * compptr->v_samp_factor; /* point to current iMCU row */
+    } else if (cinfo->output_iMCU_row > 0) {
+      buffer = (*cinfo->mem->access_virt_barray)
+        ((j_common_ptr)cinfo, coef->whole_image[ci],
+         (cinfo->output_iMCU_row - 1) * compptr->v_samp_factor,
+         (JDIMENSION)access_rows, FALSE);
+      buffer += compptr->v_samp_factor; /* point to current iMCU row */
+    } else {
+      buffer = (*cinfo->mem->access_virt_barray)
+        ((j_common_ptr)cinfo, coef->whole_image[ci],
+         (JDIMENSION)0, (JDIMENSION)access_rows, FALSE);
+    }
+    /* Fetch component-dependent info.
+     * If the current scan is incomplete, then we use the component-dependent
+     * info from the previous scan.
+     */
+    if (cinfo->output_iMCU_row > cinfo->master->last_good_iMCU_row)
+      coef_bits =
+        coef->coef_bits_latch + ((ci + cinfo->num_components) * SAVED_COEFS);
+    else
+      coef_bits = coef->coef_bits_latch + (ci * SAVED_COEFS);
+
+    /* We only do DC interpolation if no AC coefficient data is available. */
+    change_dc =
+      coef_bits[1] == -1 && coef_bits[2] == -1 && coef_bits[3] == -1 &&
+      coef_bits[4] == -1 && coef_bits[5] == -1 && coef_bits[6] == -1 &&
+      coef_bits[7] == -1 && coef_bits[8] == -1 && coef_bits[9] == -1;
+
+    quanttbl = compptr->quant_table;
+    Q00 = quanttbl->quantval[0];
+    Q01 = quanttbl->quantval[Q01_POS];
+    Q10 = quanttbl->quantval[Q10_POS];
+    Q20 = quanttbl->quantval[Q20_POS];
+    Q11 = quanttbl->quantval[Q11_POS];
+    Q02 = quanttbl->quantval[Q02_POS];
+    if (change_dc) {
+      Q03 = quanttbl->quantval[Q03_POS];
+      Q12 = quanttbl->quantval[Q12_POS];
+      Q21 = quanttbl->quantval[Q21_POS];
+      Q30 = quanttbl->quantval[Q30_POS];
+    }
+    inverse_DCT = cinfo->idct->inverse_DCT[ci];
+    output_ptr = output_buf[ci];
+    /* Loop over all DCT blocks to be processed. */
+    for (block_row = 0; block_row < block_rows; block_row++) {
+      buffer_ptr = buffer[block_row] + cinfo->master->first_MCU_col[ci];
+
+      if (block_row > 0 || cinfo->output_iMCU_row > 0)
+        prev_block_row =
+          buffer[block_row - 1] + cinfo->master->first_MCU_col[ci];
+      else
+        prev_block_row = buffer_ptr;
+
+      if (block_row > 1 || cinfo->output_iMCU_row > 1)
+        prev_prev_block_row =
+          buffer[block_row - 2] + cinfo->master->first_MCU_col[ci];
+      else
+        prev_prev_block_row = prev_block_row;
+
+      if (block_row < block_rows - 1 || cinfo->output_iMCU_row < last_iMCU_row)
+        next_block_row =
+          buffer[block_row + 1] + cinfo->master->first_MCU_col[ci];
+      else
+        next_block_row = buffer_ptr;
+
+      if (block_row < block_rows - 2 ||
+          cinfo->output_iMCU_row < last_iMCU_row - 1)
+        next_next_block_row =
+          buffer[block_row + 2] + cinfo->master->first_MCU_col[ci];
+      else
+        next_next_block_row = next_block_row;
+
+      /* We fetch the surrounding DC values using a sliding-register approach.
+       * Initialize all 25 here so as to do the right thing on narrow pics.
+       */
+      DC01 = DC02 = DC03 = DC04 = DC05 = (int)prev_prev_block_row[0][0];
+      DC06 = DC07 = DC08 = DC09 = DC10 = (int)prev_block_row[0][0];
+      DC11 = DC12 = DC13 = DC14 = DC15 = (int)buffer_ptr[0][0];
+      DC16 = DC17 = DC18 = DC19 = DC20 = (int)next_block_row[0][0];
+      DC21 = DC22 = DC23 = DC24 = DC25 = (int)next_next_block_row[0][0];
+      output_col = 0;
+      last_block_column = compptr->width_in_blocks - 1;
+      for (block_num = cinfo->master->first_MCU_col[ci];
+           block_num <= cinfo->master->last_MCU_col[ci]; block_num++) {
+        /* Fetch current DCT block into workspace so we can modify it. */
+        jcopy_block_row(buffer_ptr, (JBLOCKROW)workspace, (JDIMENSION)1);
+        /* Update DC values */
+        if (block_num == cinfo->master->first_MCU_col[ci] &&
+            block_num < last_block_column) {
+          DC04 = (int)prev_prev_block_row[1][0];
+          DC09 = (int)prev_block_row[1][0];
+          DC14 = (int)buffer_ptr[1][0];
+          DC19 = (int)next_block_row[1][0];
+          DC24 = (int)next_next_block_row[1][0];
+        }
+        if (block_num < last_block_column - 1) {
+          DC05 = (int)prev_prev_block_row[2][0];
+          DC10 = (int)prev_block_row[2][0];
+          DC15 = (int)buffer_ptr[2][0];
+          DC20 = (int)next_block_row[2][0];
+          DC25 = (int)next_next_block_row[2][0];
+        }
+        /* If DC interpolation is enabled, compute coefficient estimates using
+         * a Gaussian-like kernel, keeping the averages of the DC values.
+         *
+         * If DC interpolation is disabled, compute coefficient estimates using
+         * an algorithm similar to the one described in Section K.8 of the JPEG
+         * standard, except applied to a 5x5 window rather than a 3x3 window.
+         *
+         * An estimate is applied only if the coefficient is still zero and is
+         * not known to be fully accurate.
+         */
+        /* AC01 */
+        if ((Al = coef_bits[1]) != 0 && workspace[1] == 0) {
+          num = Q00 * (change_dc ?
+                (-DC01 - DC02 + DC04 + DC05 - 3 * DC06 + 13 * DC07 -
+                 13 * DC09 + 3 * DC10 - 3 * DC11 + 38 * DC12 - 38 * DC14 +
+                 3 * DC15 - 3 * DC16 + 13 * DC17 - 13 * DC19 + 3 * DC20 -
+                 DC21 - DC22 + DC24 + DC25) :
+                (-7 * DC11 + 50 * DC12 - 50 * DC14 + 7 * DC15));
+          if (num >= 0) {
+            pred = (int)(((Q01 << 7) + num) / (Q01 << 8));
+            if (Al > 0 && pred >= (1 << Al))
+              pred = (1 << Al) - 1;
+          } else {
+            pred = (int)(((Q01 << 7) - num) / (Q01 << 8));
+            if (Al > 0 && pred >= (1 << Al))
+              pred = (1 << Al) - 1;
+            pred = -pred;
+          }
+          workspace[1] = (JCOEF)pred;
+        }
+        /* AC10 */
+        if ((Al = coef_bits[2]) != 0 && workspace[8] == 0) {
+          num = Q00 * (change_dc ?
+                (-DC01 - 3 * DC02 - 3 * DC03 - 3 * DC04 - DC05 - DC06 +
+                 13 * DC07 + 38 * DC08 + 13 * DC09 - DC10 + DC16 -
+                 13 * DC17 - 38 * DC18 - 13 * DC19 + DC20 + DC21 +
+                 3 * DC22 + 3 * DC23 + 3 * DC24 + DC25) :
+                (-7 * DC03 + 50 * DC08 - 50 * DC18 + 7 * DC23));
+          if (num >= 0) {
+            pred = (int)(((Q10 << 7) + num) / (Q10 << 8));
+            if (Al > 0 && pred >= (1 << Al))
+              pred = (1 << Al) - 1;
+          } else {
+            pred = (int)(((Q10 << 7) - num) / (Q10 << 8));
+            if (Al > 0 && pred >= (1 << Al))
+              pred = (1 << Al) - 1;
+            pred = -pred;
+          }
+          workspace[8] = (JCOEF)pred;
+        }
+        /* AC20 */
+        if ((Al = coef_bits[3]) != 0 && workspace[16] == 0) {
+          num = Q00 * (change_dc ?
+                (DC03 + 2 * DC07 + 7 * DC08 + 2 * DC09 - 5 * DC12 - 14 * DC13 -
+                 5 * DC14 + 2 * DC17 + 7 * DC18 + 2 * DC19 + DC23) :
+                (-DC03 + 13 * DC08 - 24 * DC13 + 13 * DC18 - DC23));
+          if (num >= 0) {
+            pred = (int)(((Q20 << 7) + num) / (Q20 << 8));
+            if (Al > 0 && pred >= (1 << Al))
+              pred = (1 << Al) - 1;
+          } else {
+            pred = (int)(((Q20 << 7) - num) / (Q20 << 8));
+            if (Al > 0 && pred >= (1 << Al))
+              pred = (1 << Al) - 1;
+            pred = -pred;
+          }
+          workspace[16] = (JCOEF)pred;
+        }
+        /* AC11 */
+        if ((Al = coef_bits[4]) != 0 && workspace[9] == 0) {
+          num = Q00 * (change_dc ?
+                (-DC01 + DC05 + 9 * DC07 - 9 * DC09 - 9 * DC17 +
+                 9 * DC19 + DC21 - DC25) :
+                (DC10 + DC16 - 10 * DC17 + 10 * DC19 - DC02 - DC20 + DC22 -
+                 DC24 + DC04 - DC06 + 10 * DC07 - 10 * DC09));
+          if (num >= 0) {
+            pred = (int)(((Q11 << 7) + num) / (Q11 << 8));
+            if (Al > 0 && pred >= (1 << Al))
+              pred = (1 << Al) - 1;
+          } else {
+            pred = (int)(((Q11 << 7) - num) / (Q11 << 8));
+            if (Al > 0 && pred >= (1 << Al))
+              pred = (1 << Al) - 1;
+            pred = -pred;
+          }
+          workspace[9] = (JCOEF)pred;
+        }
+        /* AC02 */
+        if ((Al = coef_bits[5]) != 0 && workspace[2] == 0) {
+          num = Q00 * (change_dc ?
+                (2 * DC07 - 5 * DC08 + 2 * DC09 + DC11 + 7 * DC12 - 14 * DC13 +
+                 7 * DC14 + DC15 + 2 * DC17 - 5 * DC18 + 2 * DC19) :
+                (-DC11 + 13 * DC12 - 24 * DC13 + 13 * DC14 - DC15));
+          if (num >= 0) {
+            pred = (int)(((Q02 << 7) + num) / (Q02 << 8));
+            if (Al > 0 && pred >= (1 << Al))
+              pred = (1 << Al) - 1;
+          } else {
+            pred = (int)(((Q02 << 7) - num) / (Q02 << 8));
+            if (Al > 0 && pred >= (1 << Al))
+              pred = (1 << Al) - 1;
+            pred = -pred;
+          }
+          workspace[2] = (JCOEF)pred;
+        }
+        if (change_dc) {
+          /* AC03 */
+          if ((Al = coef_bits[6]) != 0 && workspace[3] == 0) {
+            num = Q00 * (DC07 - DC09 + 2 * DC12 - 2 * DC14 + DC17 - DC19);
+            if (num >= 0) {
+              pred = (int)(((Q03 << 7) + num) / (Q03 << 8));
+              if (Al > 0 && pred >= (1 << Al))
+                pred = (1 << Al) - 1;
+            } else {
+              pred = (int)(((Q03 << 7) - num) / (Q03 << 8));
+              if (Al > 0 && pred >= (1 << Al))
+                pred = (1 << Al) - 1;
+              pred = -pred;
+            }
+            workspace[3] = (JCOEF)pred;
+          }
+          /* AC12 */
+          if ((Al = coef_bits[7]) != 0 && workspace[10] == 0) {
+            num = Q00 * (DC07 - 3 * DC08 + DC09 - DC17 + 3 * DC18 - DC19);
+            if (num >= 0) {
+              pred = (int)(((Q12 << 7) + num) / (Q12 << 8));
+              if (Al > 0 && pred >= (1 << Al))
+                pred = (1 << Al) - 1;
+            } else {
+              pred = (int)(((Q12 << 7) - num) / (Q12 << 8));
+              if (Al > 0 && pred >= (1 << Al))
+                pred = (1 << Al) - 1;
+              pred = -pred;
+            }
+            workspace[10] = (JCOEF)pred;
+          }
+          /* AC21 */
+          if ((Al = coef_bits[8]) != 0 && workspace[17] == 0) {
+            num = Q00 * (DC07 - DC09 - 3 * DC12 + 3 * DC14 + DC17 - DC19);
+            if (num >= 0) {
+              pred = (int)(((Q21 << 7) + num) / (Q21 << 8));
+              if (Al > 0 && pred >= (1 << Al))
+                pred = (1 << Al) - 1;
+            } else {
+              pred = (int)(((Q21 << 7) - num) / (Q21 << 8));
+              if (Al > 0 && pred >= (1 << Al))
+                pred = (1 << Al) - 1;
+              pred = -pred;
+            }
+            workspace[17] = (JCOEF)pred;
+          }
+          /* AC30 */
+          if ((Al = coef_bits[9]) != 0 && workspace[24] == 0) {
+            num = Q00 * (DC07 + 2 * DC08 + DC09 - DC17 - 2 * DC18 - DC19);
+            if (num >= 0) {
+              pred = (int)(((Q30 << 7) + num) / (Q30 << 8));
+              if (Al > 0 && pred >= (1 << Al))
+                pred = (1 << Al) - 1;
+            } else {
+              pred = (int)(((Q30 << 7) - num) / (Q30 << 8));
+              if (Al > 0 && pred >= (1 << Al))
+                pred = (1 << Al) - 1;
+              pred = -pred;
+            }
+            workspace[24] = (JCOEF)pred;
+          }
+          /* coef_bits[0] is non-negative.  Otherwise this function would not
+           * be called.
+           */
+          num = Q00 *
+                (-2 * DC01 - 6 * DC02 - 8 * DC03 - 6 * DC04 - 2 * DC05 -
+                 6 * DC06 + 6 * DC07 + 42 * DC08 + 6 * DC09 - 6 * DC10 -
+                 8 * DC11 + 42 * DC12 + 152 * DC13 + 42 * DC14 - 8 * DC15 -
+                 6 * DC16 + 6 * DC17 + 42 * DC18 + 6 * DC19 - 6 * DC20 -
+                 2 * DC21 - 6 * DC22 - 8 * DC23 - 6 * DC24 - 2 * DC25);
+          if (num >= 0) {
+            pred = (int)(((Q00 << 7) + num) / (Q00 << 8));
+          } else {
+            pred = (int)(((Q00 << 7) - num) / (Q00 << 8));
+            pred = -pred;
+          }
+          workspace[0] = (JCOEF)pred;
+        }  /* change_dc */
+
+        /* OK, do the IDCT */
+        (*inverse_DCT) (cinfo, compptr, (JCOEFPTR)workspace, output_ptr,
+                        output_col);
+        /* Advance for next column */
+        DC01 = DC02;  DC02 = DC03;  DC03 = DC04;  DC04 = DC05;
+        DC06 = DC07;  DC07 = DC08;  DC08 = DC09;  DC09 = DC10;
+        DC11 = DC12;  DC12 = DC13;  DC13 = DC14;  DC14 = DC15;
+        DC16 = DC17;  DC17 = DC18;  DC18 = DC19;  DC19 = DC20;
+        DC21 = DC22;  DC22 = DC23;  DC23 = DC24;  DC24 = DC25;
+        buffer_ptr++, prev_block_row++, next_block_row++,
+          prev_prev_block_row++, next_next_block_row++;
+        output_col += compptr->_DCT_scaled_size;
+      }
+      output_ptr += compptr->_DCT_scaled_size;
+    }
+  }
+
+  if (++(cinfo->output_iMCU_row) < cinfo->total_iMCU_rows)
+    return JPEG_ROW_COMPLETED;
+  return JPEG_SCAN_COMPLETED;
+}
+
+#endif /* BLOCK_SMOOTHING_SUPPORTED */
+
+
+/*
+ * Initialize coefficient buffer controller.
+ */
+
+GLOBAL(void)
+jinit_d_coef_controller(j_decompress_ptr cinfo, boolean need_full_buffer)
+{
+  my_coef_ptr coef;
+
+  coef = (my_coef_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+                                sizeof(my_coef_controller));
+  cinfo->coef = (struct jpeg_d_coef_controller *)coef;
+  coef->pub.start_input_pass = start_input_pass;
+  coef->pub.start_output_pass = start_output_pass;
+#ifdef BLOCK_SMOOTHING_SUPPORTED
+  coef->coef_bits_latch = NULL;
+#endif
+
+  /* Create the coefficient buffer. */
+  if (need_full_buffer) {
+#ifdef D_MULTISCAN_FILES_SUPPORTED
+    /* Allocate a full-image virtual array for each component, */
+    /* padded to a multiple of samp_factor DCT blocks in each direction. */
+    /* Note we ask for a pre-zeroed array. */
+    int ci, access_rows;
+    jpeg_component_info *compptr;
+
+    for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+         ci++, compptr++) {
+      access_rows = compptr->v_samp_factor;
+#ifdef BLOCK_SMOOTHING_SUPPORTED
+      /* If block smoothing could be used, need a bigger window */
+      if (cinfo->progressive_mode)
+        access_rows *= 5;
+#endif
+      coef->whole_image[ci] = (*cinfo->mem->request_virt_barray)
+        ((j_common_ptr)cinfo, JPOOL_IMAGE, TRUE,
+         (JDIMENSION)jround_up((long)compptr->width_in_blocks,
+                               (long)compptr->h_samp_factor),
+         (JDIMENSION)jround_up((long)compptr->height_in_blocks,
+                               (long)compptr->v_samp_factor),
+         (JDIMENSION)access_rows);
+    }
+    coef->pub.consume_data = consume_data;
+    coef->pub.decompress_data = decompress_data;
+    coef->pub.coef_arrays = coef->whole_image; /* link to virtual arrays */
+#else
+    ERREXIT(cinfo, JERR_NOT_COMPILED);
+#endif
+  } else {
+    /* We only need a single-MCU buffer. */
+    JBLOCKROW buffer;
+    int i;
+
+    buffer = (JBLOCKROW)
+      (*cinfo->mem->alloc_large) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+                                  D_MAX_BLOCKS_IN_MCU * sizeof(JBLOCK));
+    for (i = 0; i < D_MAX_BLOCKS_IN_MCU; i++) {
+      coef->MCU_buffer[i] = buffer + i;
+    }
+    coef->pub.consume_data = dummy_consume_data;
+    coef->pub.decompress_data = decompress_onepass;
+    coef->pub.coef_arrays = NULL; /* flag for no virtual arrays */
+  }
+
+  /* Allocate the workspace buffer */
+  coef->workspace = (JCOEF *)
+    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+                                sizeof(JCOEF) * DCTSIZE2);
+}
diff --git a/3rdparty/libjpeg/src/jdcoefct.h b/3rdparty/libjpeg/src/jdcoefct.h
new file mode 100644
index 00000000..9a0e7806
--- /dev/null
+++ b/3rdparty/libjpeg/src/jdcoefct.h
@@ -0,0 +1,83 @@
+/*
+ * jdcoefct.h
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1994-1997, Thomas G. Lane.
+ * libjpeg-turbo Modifications:
+ * Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+ * Copyright (C) 2020, Google, Inc.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ */
+
+#define JPEG_INTERNALS
+#include "jpeglib.h"
+
+
+/* Block smoothing is only applicable for progressive JPEG, so: */
+#ifndef D_PROGRESSIVE_SUPPORTED
+#undef BLOCK_SMOOTHING_SUPPORTED
+#endif
+
+
+/* Private buffer controller object */
+
+typedef struct {
+  struct jpeg_d_coef_controller pub; /* public fields */
+
+  /* These variables keep track of the current location of the input side. */
+  /* cinfo->input_iMCU_row is also used for this. */
+  JDIMENSION MCU_ctr;           /* counts MCUs processed in current row */
+  int MCU_vert_offset;          /* counts MCU rows within iMCU row */
+  int MCU_rows_per_iMCU_row;    /* number of such rows needed */
+
+  /* The output side's location is represented by cinfo->output_iMCU_row. */
+
+  /* In single-pass modes, it's sufficient to buffer just one MCU.
+   * We allocate a workspace of D_MAX_BLOCKS_IN_MCU coefficient blocks,
+   * and let the entropy decoder write into that workspace each time.
+   * In multi-pass modes, this array points to the current MCU's blocks
+   * within the virtual arrays; it is used only by the input side.
+   */
+  JBLOCKROW MCU_buffer[D_MAX_BLOCKS_IN_MCU];
+
+  /* Temporary workspace for one MCU */
+  JCOEF *workspace;
+
+#ifdef D_MULTISCAN_FILES_SUPPORTED
+  /* In multi-pass modes, we need a virtual block array for each component. */
+  jvirt_barray_ptr whole_image[MAX_COMPONENTS];
+#endif
+
+#ifdef BLOCK_SMOOTHING_SUPPORTED
+  /* When doing block smoothing, we latch coefficient Al values here */
+  int *coef_bits_latch;
+#define SAVED_COEFS  10         /* we save coef_bits[0..9] */
+#endif
+} my_coef_controller;
+
+typedef my_coef_controller *my_coef_ptr;
+
+
+LOCAL(void)
+start_iMCU_row(j_decompress_ptr cinfo)
+/* Reset within-iMCU-row counters for a new row (input side) */
+{
+  my_coef_ptr coef = (my_coef_ptr)cinfo->coef;
+
+  /* In an interleaved scan, an MCU row is the same as an iMCU row.
+   * In a noninterleaved scan, an iMCU row has v_samp_factor MCU rows.
+   * But at the bottom of the image, process only what's left.
+   */
+  if (cinfo->comps_in_scan > 1) {
+    coef->MCU_rows_per_iMCU_row = 1;
+  } else {
+    if (cinfo->input_iMCU_row < (cinfo->total_iMCU_rows - 1))
+      coef->MCU_rows_per_iMCU_row = cinfo->cur_comp_info[0]->v_samp_factor;
+    else
+      coef->MCU_rows_per_iMCU_row = cinfo->cur_comp_info[0]->last_row_height;
+  }
+
+  coef->MCU_ctr = 0;
+  coef->MCU_vert_offset = 0;
+}
diff --git a/3rdparty/libjpeg/src/jdcol565.c b/3rdparty/libjpeg/src/jdcol565.c
new file mode 100644
index 00000000..53c7bd91
--- /dev/null
+++ b/3rdparty/libjpeg/src/jdcol565.c
@@ -0,0 +1,384 @@
+/*
+ * jdcol565.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1991-1997, Thomas G. Lane.
+ * Modifications:
+ * Copyright (C) 2013, Linaro Limited.
+ * Copyright (C) 2014-2015, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains output colorspace conversion routines.
+ */
+
+/* This file is included by jdcolor.c */
+
+
+INLINE
+LOCAL(void)
+ycc_rgb565_convert_internal(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
+                            JDIMENSION input_row, JSAMPARRAY output_buf,
+                            int num_rows)
+{
+  my_cconvert_ptr cconvert = (my_cconvert_ptr)cinfo->cconvert;
+  register int y, cb, cr;
+  register JSAMPROW outptr;
+  register JSAMPROW inptr0, inptr1, inptr2;
+  register JDIMENSION col;
+  JDIMENSION num_cols = cinfo->output_width;
+  /* copy these pointers into registers if possible */
+  register JSAMPLE *range_limit = cinfo->sample_range_limit;
+  register int *Crrtab = cconvert->Cr_r_tab;
+  register int *Cbbtab = cconvert->Cb_b_tab;
+  register JLONG *Crgtab = cconvert->Cr_g_tab;
+  register JLONG *Cbgtab = cconvert->Cb_g_tab;
+  SHIFT_TEMPS
+
+  while (--num_rows >= 0) {
+    JLONG rgb;
+    unsigned int r, g, b;
+    inptr0 = input_buf[0][input_row];
+    inptr1 = input_buf[1][input_row];
+    inptr2 = input_buf[2][input_row];
+    input_row++;
+    outptr = *output_buf++;
+
+    if (PACK_NEED_ALIGNMENT(outptr)) {
+      y  = *inptr0++;
+      cb = *inptr1++;
+      cr = *inptr2++;
+      r = range_limit[y + Crrtab[cr]];
+      g = range_limit[y + ((int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],
+                                            SCALEBITS))];
+      b = range_limit[y + Cbbtab[cb]];
+      rgb = PACK_SHORT_565(r, g, b);
+      *(INT16 *)outptr = (INT16)rgb;
+      outptr += 2;
+      num_cols--;
+    }
+    for (col = 0; col < (num_cols >> 1); col++) {
+      y  = *inptr0++;
+      cb = *inptr1++;
+      cr = *inptr2++;
+      r = range_limit[y + Crrtab[cr]];
+      g = range_limit[y + ((int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],
+                                            SCALEBITS))];
+      b = range_limit[y + Cbbtab[cb]];
+      rgb = PACK_SHORT_565(r, g, b);
+
+      y  = *inptr0++;
+      cb = *inptr1++;
+      cr = *inptr2++;
+      r = range_limit[y + Crrtab[cr]];
+      g = range_limit[y + ((int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],
+                                            SCALEBITS))];
+      b = range_limit[y + Cbbtab[cb]];
+      rgb = PACK_TWO_PIXELS(rgb, PACK_SHORT_565(r, g, b));
+
+      WRITE_TWO_ALIGNED_PIXELS(outptr, rgb);
+      outptr += 4;
+    }
+    if (num_cols & 1) {
+      y  = *inptr0;
+      cb = *inptr1;
+      cr = *inptr2;
+      r = range_limit[y + Crrtab[cr]];
+      g = range_limit[y + ((int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],
+                                            SCALEBITS))];
+      b = range_limit[y + Cbbtab[cb]];
+      rgb = PACK_SHORT_565(r, g, b);
+      *(INT16 *)outptr = (INT16)rgb;
+    }
+  }
+}
+
+
+INLINE
+LOCAL(void)
+ycc_rgb565D_convert_internal(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
+                             JDIMENSION input_row, JSAMPARRAY output_buf,
+                             int num_rows)
+{
+  my_cconvert_ptr cconvert = (my_cconvert_ptr)cinfo->cconvert;
+  register int y, cb, cr;
+  register JSAMPROW outptr;
+  register JSAMPROW inptr0, inptr1, inptr2;
+  register JDIMENSION col;
+  JDIMENSION num_cols = cinfo->output_width;
+  /* copy these pointers into registers if possible */
+  register JSAMPLE *range_limit = cinfo->sample_range_limit;
+  register int *Crrtab = cconvert->Cr_r_tab;
+  register int *Cbbtab = cconvert->Cb_b_tab;
+  register JLONG *Crgtab = cconvert->Cr_g_tab;
+  register JLONG *Cbgtab = cconvert->Cb_g_tab;
+  JLONG d0 = dither_matrix[cinfo->output_scanline & DITHER_MASK];
+  SHIFT_TEMPS
+
+  while (--num_rows >= 0) {
+    JLONG rgb;
+    unsigned int r, g, b;
+
+    inptr0 = input_buf[0][input_row];
+    inptr1 = input_buf[1][input_row];
+    inptr2 = input_buf[2][input_row];
+    input_row++;
+    outptr = *output_buf++;
+    if (PACK_NEED_ALIGNMENT(outptr)) {
+      y  = *inptr0++;
+      cb = *inptr1++;
+      cr = *inptr2++;
+      r = range_limit[DITHER_565_R(y + Crrtab[cr], d0)];
+      g = range_limit[DITHER_565_G(y +
+                                   ((int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],
+                                                     SCALEBITS)), d0)];
+      b = range_limit[DITHER_565_B(y + Cbbtab[cb], d0)];
+      rgb = PACK_SHORT_565(r, g, b);
+      *(INT16 *)outptr = (INT16)rgb;
+      outptr += 2;
+      num_cols--;
+    }
+    for (col = 0; col < (num_cols >> 1); col++) {
+      y  = *inptr0++;
+      cb = *inptr1++;
+      cr = *inptr2++;
+      r = range_limit[DITHER_565_R(y + Crrtab[cr], d0)];
+      g = range_limit[DITHER_565_G(y +
+                                   ((int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],
+                                                     SCALEBITS)), d0)];
+      b = range_limit[DITHER_565_B(y + Cbbtab[cb], d0)];
+      d0 = DITHER_ROTATE(d0);
+      rgb = PACK_SHORT_565(r, g, b);
+
+      y  = *inptr0++;
+      cb = *inptr1++;
+      cr = *inptr2++;
+      r = range_limit[DITHER_565_R(y + Crrtab[cr], d0)];
+      g = range_limit[DITHER_565_G(y +
+                                   ((int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],
+                                                     SCALEBITS)), d0)];
+      b = range_limit[DITHER_565_B(y + Cbbtab[cb], d0)];
+      d0 = DITHER_ROTATE(d0);
+      rgb = PACK_TWO_PIXELS(rgb, PACK_SHORT_565(r, g, b));
+
+      WRITE_TWO_ALIGNED_PIXELS(outptr, rgb);
+      outptr += 4;
+    }
+    if (num_cols & 1) {
+      y  = *inptr0;
+      cb = *inptr1;
+      cr = *inptr2;
+      r = range_limit[DITHER_565_R(y + Crrtab[cr], d0)];
+      g = range_limit[DITHER_565_G(y +
+                                   ((int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],
+                                                     SCALEBITS)), d0)];
+      b = range_limit[DITHER_565_B(y + Cbbtab[cb], d0)];
+      rgb = PACK_SHORT_565(r, g, b);
+      *(INT16 *)outptr = (INT16)rgb;
+    }
+  }
+}
+
+
+INLINE
+LOCAL(void)
+rgb_rgb565_convert_internal(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
+                            JDIMENSION input_row, JSAMPARRAY output_buf,
+                            int num_rows)
+{
+  register JSAMPROW outptr;
+  register JSAMPROW inptr0, inptr1, inptr2;
+  register JDIMENSION col;
+  JDIMENSION num_cols = cinfo->output_width;
+  SHIFT_TEMPS
+
+  while (--num_rows >= 0) {
+    JLONG rgb;
+    unsigned int r, g, b;
+
+    inptr0 = input_buf[0][input_row];
+    inptr1 = input_buf[1][input_row];
+    inptr2 = input_buf[2][input_row];
+    input_row++;
+    outptr = *output_buf++;
+    if (PACK_NEED_ALIGNMENT(outptr)) {
+      r = *inptr0++;
+      g = *inptr1++;
+      b = *inptr2++;
+      rgb = PACK_SHORT_565(r, g, b);
+      *(INT16 *)outptr = (INT16)rgb;
+      outptr += 2;
+      num_cols--;
+    }
+    for (col = 0; col < (num_cols >> 1); col++) {
+      r = *inptr0++;
+      g = *inptr1++;
+      b = *inptr2++;
+      rgb = PACK_SHORT_565(r, g, b);
+
+      r = *inptr0++;
+      g = *inptr1++;
+      b = *inptr2++;
+      rgb = PACK_TWO_PIXELS(rgb, PACK_SHORT_565(r, g, b));
+
+      WRITE_TWO_ALIGNED_PIXELS(outptr, rgb);
+      outptr += 4;
+    }
+    if (num_cols & 1) {
+      r = *inptr0;
+      g = *inptr1;
+      b = *inptr2;
+      rgb = PACK_SHORT_565(r, g, b);
+      *(INT16 *)outptr = (INT16)rgb;
+    }
+  }
+}
+
+
+INLINE
+LOCAL(void)
+rgb_rgb565D_convert_internal(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
+                             JDIMENSION input_row, JSAMPARRAY output_buf,
+                             int num_rows)
+{
+  register JSAMPROW outptr;
+  register JSAMPROW inptr0, inptr1, inptr2;
+  register JDIMENSION col;
+  register JSAMPLE *range_limit = cinfo->sample_range_limit;
+  JDIMENSION num_cols = cinfo->output_width;
+  JLONG d0 = dither_matrix[cinfo->output_scanline & DITHER_MASK];
+  SHIFT_TEMPS
+
+  while (--num_rows >= 0) {
+    JLONG rgb;
+    unsigned int r, g, b;
+
+    inptr0 = input_buf[0][input_row];
+    inptr1 = input_buf[1][input_row];
+    inptr2 = input_buf[2][input_row];
+    input_row++;
+    outptr = *output_buf++;
+    if (PACK_NEED_ALIGNMENT(outptr)) {
+      r = range_limit[DITHER_565_R(*inptr0++, d0)];
+      g = range_limit[DITHER_565_G(*inptr1++, d0)];
+      b = range_limit[DITHER_565_B(*inptr2++, d0)];
+      rgb = PACK_SHORT_565(r, g, b);
+      *(INT16 *)outptr = (INT16)rgb;
+      outptr += 2;
+      num_cols--;
+    }
+    for (col = 0; col < (num_cols >> 1); col++) {
+      r = range_limit[DITHER_565_R(*inptr0++, d0)];
+      g = range_limit[DITHER_565_G(*inptr1++, d0)];
+      b = range_limit[DITHER_565_B(*inptr2++, d0)];
+      d0 = DITHER_ROTATE(d0);
+      rgb = PACK_SHORT_565(r, g, b);
+
+      r = range_limit[DITHER_565_R(*inptr0++, d0)];
+      g = range_limit[DITHER_565_G(*inptr1++, d0)];
+      b = range_limit[DITHER_565_B(*inptr2++, d0)];
+      d0 = DITHER_ROTATE(d0);
+      rgb = PACK_TWO_PIXELS(rgb, PACK_SHORT_565(r, g, b));
+
+      WRITE_TWO_ALIGNED_PIXELS(outptr, rgb);
+      outptr += 4;
+    }
+    if (num_cols & 1) {
+      r = range_limit[DITHER_565_R(*inptr0, d0)];
+      g = range_limit[DITHER_565_G(*inptr1, d0)];
+      b = range_limit[DITHER_565_B(*inptr2, d0)];
+      rgb = PACK_SHORT_565(r, g, b);
+      *(INT16 *)outptr = (INT16)rgb;
+    }
+  }
+}
+
+
+INLINE
+LOCAL(void)
+gray_rgb565_convert_internal(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
+                             JDIMENSION input_row, JSAMPARRAY output_buf,
+                             int num_rows)
+{
+  register JSAMPROW inptr, outptr;
+  register JDIMENSION col;
+  JDIMENSION num_cols = cinfo->output_width;
+
+  while (--num_rows >= 0) {
+    JLONG rgb;
+    unsigned int g;
+
+    inptr = input_buf[0][input_row++];
+    outptr = *output_buf++;
+    if (PACK_NEED_ALIGNMENT(outptr)) {
+      g = *inptr++;
+      rgb = PACK_SHORT_565(g, g, g);
+      *(INT16 *)outptr = (INT16)rgb;
+      outptr += 2;
+      num_cols--;
+    }
+    for (col = 0; col < (num_cols >> 1); col++) {
+      g = *inptr++;
+      rgb = PACK_SHORT_565(g, g, g);
+      g = *inptr++;
+      rgb = PACK_TWO_PIXELS(rgb, PACK_SHORT_565(g, g, g));
+      WRITE_TWO_ALIGNED_PIXELS(outptr, rgb);
+      outptr += 4;
+    }
+    if (num_cols & 1) {
+      g = *inptr;
+      rgb = PACK_SHORT_565(g, g, g);
+      *(INT16 *)outptr = (INT16)rgb;
+    }
+  }
+}
+
+
+INLINE
+LOCAL(void)
+gray_rgb565D_convert_internal(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
+                              JDIMENSION input_row, JSAMPARRAY output_buf,
+                              int num_rows)
+{
+  register JSAMPROW inptr, outptr;
+  register JDIMENSION col;
+  register JSAMPLE *range_limit = cinfo->sample_range_limit;
+  JDIMENSION num_cols = cinfo->output_width;
+  JLONG d0 = dither_matrix[cinfo->output_scanline & DITHER_MASK];
+
+  while (--num_rows >= 0) {
+    JLONG rgb;
+    unsigned int g;
+
+    inptr = input_buf[0][input_row++];
+    outptr = *output_buf++;
+    if (PACK_NEED_ALIGNMENT(outptr)) {
+      g = *inptr++;
+      g = range_limit[DITHER_565_R(g, d0)];
+      rgb = PACK_SHORT_565(g, g, g);
+      *(INT16 *)outptr = (INT16)rgb;
+      outptr += 2;
+      num_cols--;
+    }
+    for (col = 0; col < (num_cols >> 1); col++) {
+      g = *inptr++;
+      g = range_limit[DITHER_565_R(g, d0)];
+      rgb = PACK_SHORT_565(g, g, g);
+      d0 = DITHER_ROTATE(d0);
+
+      g = *inptr++;
+      g = range_limit[DITHER_565_R(g, d0)];
+      rgb = PACK_TWO_PIXELS(rgb, PACK_SHORT_565(g, g, g));
+      d0 = DITHER_ROTATE(d0);
+
+      WRITE_TWO_ALIGNED_PIXELS(outptr, rgb);
+      outptr += 4;
+    }
+    if (num_cols & 1) {
+      g = *inptr;
+      g = range_limit[DITHER_565_R(g, d0)];
+      rgb = PACK_SHORT_565(g, g, g);
+      *(INT16 *)outptr = (INT16)rgb;
+    }
+  }
+}
diff --git a/3rdparty/libjpeg/src/jdcolext.c b/3rdparty/libjpeg/src/jdcolext.c
new file mode 100644
index 00000000..863c7a2f
--- /dev/null
+++ b/3rdparty/libjpeg/src/jdcolext.c
@@ -0,0 +1,141 @@
+/*
+ * jdcolext.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1991-1997, Thomas G. Lane.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2009, 2011, 2015, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains output colorspace conversion routines.
+ */
+
+
+/* This file is included by jdcolor.c */
+
+
+/*
+ * Convert some rows of samples to the output colorspace.
+ *
+ * Note that we change from noninterleaved, one-plane-per-component format
+ * to interleaved-pixel format.  The output buffer is therefore three times
+ * as wide as the input buffer.
+ * A starting row offset is provided only for the input buffer.  The caller
+ * can easily adjust the passed output_buf value to accommodate any row
+ * offset required on that side.
+ */
+
+INLINE
+LOCAL(void)
+ycc_rgb_convert_internal(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
+                         JDIMENSION input_row, JSAMPARRAY output_buf,
+                         int num_rows)
+{
+  my_cconvert_ptr cconvert = (my_cconvert_ptr)cinfo->cconvert;
+  register int y, cb, cr;
+  register JSAMPROW outptr;
+  register JSAMPROW inptr0, inptr1, inptr2;
+  register JDIMENSION col;
+  JDIMENSION num_cols = cinfo->output_width;
+  /* copy these pointers into registers if possible */
+  register JSAMPLE *range_limit = cinfo->sample_range_limit;
+  register int *Crrtab = cconvert->Cr_r_tab;
+  register int *Cbbtab = cconvert->Cb_b_tab;
+  register JLONG *Crgtab = cconvert->Cr_g_tab;
+  register JLONG *Cbgtab = cconvert->Cb_g_tab;
+  SHIFT_TEMPS
+
+  while (--num_rows >= 0) {
+    inptr0 = input_buf[0][input_row];
+    inptr1 = input_buf[1][input_row];
+    inptr2 = input_buf[2][input_row];
+    input_row++;
+    outptr = *output_buf++;
+    for (col = 0; col < num_cols; col++) {
+      y  = inptr0[col];
+      cb = inptr1[col];
+      cr = inptr2[col];
+      /* Range-limiting is essential due to noise introduced by DCT losses. */
+      outptr[RGB_RED] =   range_limit[y + Crrtab[cr]];
+      outptr[RGB_GREEN] = range_limit[y +
+                              ((int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],
+                                                SCALEBITS))];
+      outptr[RGB_BLUE] =  range_limit[y + Cbbtab[cb]];
+      /* Set unused byte to 0xFF so it can be interpreted as an opaque */
+      /* alpha channel value */
+#ifdef RGB_ALPHA
+      outptr[RGB_ALPHA] = 0xFF;
+#endif
+      outptr += RGB_PIXELSIZE;
+    }
+  }
+}
+
+
+/*
+ * Convert grayscale to RGB: just duplicate the graylevel three times.
+ * This is provided to support applications that don't want to cope
+ * with grayscale as a separate case.
+ */
+
+INLINE
+LOCAL(void)
+gray_rgb_convert_internal(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
+                          JDIMENSION input_row, JSAMPARRAY output_buf,
+                          int num_rows)
+{
+  register JSAMPROW inptr, outptr;
+  register JDIMENSION col;
+  JDIMENSION num_cols = cinfo->output_width;
+
+  while (--num_rows >= 0) {
+    inptr = input_buf[0][input_row++];
+    outptr = *output_buf++;
+    for (col = 0; col < num_cols; col++) {
+      outptr[RGB_RED] = outptr[RGB_GREEN] = outptr[RGB_BLUE] = inptr[col];
+      /* Set unused byte to 0xFF so it can be interpreted as an opaque */
+      /* alpha channel value */
+#ifdef RGB_ALPHA
+      outptr[RGB_ALPHA] = 0xFF;
+#endif
+      outptr += RGB_PIXELSIZE;
+    }
+  }
+}
+
+
+/*
+ * Convert RGB to extended RGB: just swap the order of source pixels
+ */
+
+INLINE
+LOCAL(void)
+rgb_rgb_convert_internal(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
+                         JDIMENSION input_row, JSAMPARRAY output_buf,
+                         int num_rows)
+{
+  register JSAMPROW inptr0, inptr1, inptr2;
+  register JSAMPROW outptr;
+  register JDIMENSION col;
+  JDIMENSION num_cols = cinfo->output_width;
+
+  while (--num_rows >= 0) {
+    inptr0 = input_buf[0][input_row];
+    inptr1 = input_buf[1][input_row];
+    inptr2 = input_buf[2][input_row];
+    input_row++;
+    outptr = *output_buf++;
+    for (col = 0; col < num_cols; col++) {
+      outptr[RGB_RED] = inptr0[col];
+      outptr[RGB_GREEN] = inptr1[col];
+      outptr[RGB_BLUE] = inptr2[col];
+      /* Set unused byte to 0xFF so it can be interpreted as an opaque */
+      /* alpha channel value */
+#ifdef RGB_ALPHA
+      outptr[RGB_ALPHA] = 0xFF;
+#endif
+      outptr += RGB_PIXELSIZE;
+    }
+  }
+}
diff --git a/3rdparty/libjpeg/src/jdcolor.c b/3rdparty/libjpeg/src/jdcolor.c
new file mode 100644
index 00000000..8da2b4ea
--- /dev/null
+++ b/3rdparty/libjpeg/src/jdcolor.c
@@ -0,0 +1,882 @@
+/*
+ * jdcolor.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1991-1997, Thomas G. Lane.
+ * Modified 2011 by Guido Vollbeding.
+ * libjpeg-turbo Modifications:
+ * Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+ * Copyright (C) 2009, 2011-2012, 2014-2015, D. R. Commander.
+ * Copyright (C) 2013, Linaro Limited.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains output colorspace conversion routines.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jsimd.h"
+#include "jconfigint.h"
+
+
+/* Private subobject */
+
+typedef struct {
+  struct jpeg_color_deconverter pub; /* public fields */
+
+  /* Private state for YCC->RGB conversion */
+  int *Cr_r_tab;                /* => table for Cr to R conversion */
+  int *Cb_b_tab;                /* => table for Cb to B conversion */
+  JLONG *Cr_g_tab;              /* => table for Cr to G conversion */
+  JLONG *Cb_g_tab;              /* => table for Cb to G conversion */
+
+  /* Private state for RGB->Y conversion */
+  JLONG *rgb_y_tab;             /* => table for RGB to Y conversion */
+} my_color_deconverter;
+
+typedef my_color_deconverter *my_cconvert_ptr;
+
+
+/**************** YCbCr -> RGB conversion: most common case **************/
+/****************   RGB -> Y   conversion: less common case **************/
+
+/*
+ * YCbCr is defined per CCIR 601-1, except that Cb and Cr are
+ * normalized to the range 0..MAXJSAMPLE rather than -0.5 .. 0.5.
+ * The conversion equations to be implemented are therefore
+ *
+ *      R = Y                + 1.40200 * Cr
+ *      G = Y - 0.34414 * Cb - 0.71414 * Cr
+ *      B = Y + 1.77200 * Cb
+ *
+ *      Y = 0.29900 * R + 0.58700 * G + 0.11400 * B
+ *
+ * where Cb and Cr represent the incoming values less CENTERJSAMPLE.
+ * (These numbers are derived from TIFF 6.0 section 21, dated 3-June-92.)
+ *
+ * To avoid floating-point arithmetic, we represent the fractional constants
+ * as integers scaled up by 2^16 (about 4 digits precision); we have to divide
+ * the products by 2^16, with appropriate rounding, to get the correct answer.
+ * Notice that Y, being an integral input, does not contribute any fraction
+ * so it need not participate in the rounding.
+ *
+ * For even more speed, we avoid doing any multiplications in the inner loop
+ * by precalculating the constants times Cb and Cr for all possible values.
+ * For 8-bit JSAMPLEs this is very reasonable (only 256 entries per table);
+ * for 12-bit samples it is still acceptable.  It's not very reasonable for
+ * 16-bit samples, but if you want lossless storage you shouldn't be changing
+ * colorspace anyway.
+ * The Cr=>R and Cb=>B values can be rounded to integers in advance; the
+ * values for the G calculation are left scaled up, since we must add them
+ * together before rounding.
+ */
+
+#define SCALEBITS       16      /* speediest right-shift on some machines */
+#define ONE_HALF        ((JLONG)1 << (SCALEBITS - 1))
+#define FIX(x)          ((JLONG)((x) * (1L << SCALEBITS) + 0.5))
+
+/* We allocate one big table for RGB->Y conversion and divide it up into
+ * three parts, instead of doing three alloc_small requests.  This lets us
+ * use a single table base address, which can be held in a register in the
+ * inner loops on many machines (more than can hold all three addresses,
+ * anyway).
+ */
+
+#define R_Y_OFF         0                       /* offset to R => Y section */
+#define G_Y_OFF         (1 * (MAXJSAMPLE + 1))  /* offset to G => Y section */
+#define B_Y_OFF         (2 * (MAXJSAMPLE + 1))  /* etc. */
+#define TABLE_SIZE      (3 * (MAXJSAMPLE + 1))
+
+
+/* Include inline routines for colorspace extensions */
+
+#include "jdcolext.c"
+#undef RGB_RED
+#undef RGB_GREEN
+#undef RGB_BLUE
+#undef RGB_PIXELSIZE
+
+#define RGB_RED  EXT_RGB_RED
+#define RGB_GREEN  EXT_RGB_GREEN
+#define RGB_BLUE  EXT_RGB_BLUE
+#define RGB_PIXELSIZE  EXT_RGB_PIXELSIZE
+#define ycc_rgb_convert_internal  ycc_extrgb_convert_internal
+#define gray_rgb_convert_internal  gray_extrgb_convert_internal
+#define rgb_rgb_convert_internal  rgb_extrgb_convert_internal
+#include "jdcolext.c"
+#undef RGB_RED
+#undef RGB_GREEN
+#undef RGB_BLUE
+#undef RGB_PIXELSIZE
+#undef ycc_rgb_convert_internal
+#undef gray_rgb_convert_internal
+#undef rgb_rgb_convert_internal
+
+#define RGB_RED  EXT_RGBX_RED
+#define RGB_GREEN  EXT_RGBX_GREEN
+#define RGB_BLUE  EXT_RGBX_BLUE
+#define RGB_ALPHA  3
+#define RGB_PIXELSIZE  EXT_RGBX_PIXELSIZE
+#define ycc_rgb_convert_internal  ycc_extrgbx_convert_internal
+#define gray_rgb_convert_internal  gray_extrgbx_convert_internal
+#define rgb_rgb_convert_internal  rgb_extrgbx_convert_internal
+#include "jdcolext.c"
+#undef RGB_RED
+#undef RGB_GREEN
+#undef RGB_BLUE
+#undef RGB_ALPHA
+#undef RGB_PIXELSIZE
+#undef ycc_rgb_convert_internal
+#undef gray_rgb_convert_internal
+#undef rgb_rgb_convert_internal
+
+#define RGB_RED  EXT_BGR_RED
+#define RGB_GREEN  EXT_BGR_GREEN
+#define RGB_BLUE  EXT_BGR_BLUE
+#define RGB_PIXELSIZE  EXT_BGR_PIXELSIZE
+#define ycc_rgb_convert_internal  ycc_extbgr_convert_internal
+#define gray_rgb_convert_internal  gray_extbgr_convert_internal
+#define rgb_rgb_convert_internal  rgb_extbgr_convert_internal
+#include "jdcolext.c"
+#undef RGB_RED
+#undef RGB_GREEN
+#undef RGB_BLUE
+#undef RGB_PIXELSIZE
+#undef ycc_rgb_convert_internal
+#undef gray_rgb_convert_internal
+#undef rgb_rgb_convert_internal
+
+#define RGB_RED  EXT_BGRX_RED
+#define RGB_GREEN  EXT_BGRX_GREEN
+#define RGB_BLUE  EXT_BGRX_BLUE
+#define RGB_ALPHA  3
+#define RGB_PIXELSIZE  EXT_BGRX_PIXELSIZE
+#define ycc_rgb_convert_internal  ycc_extbgrx_convert_internal
+#define gray_rgb_convert_internal  gray_extbgrx_convert_internal
+#define rgb_rgb_convert_internal  rgb_extbgrx_convert_internal
+#include "jdcolext.c"
+#undef RGB_RED
+#undef RGB_GREEN
+#undef RGB_BLUE
+#undef RGB_ALPHA
+#undef RGB_PIXELSIZE
+#undef ycc_rgb_convert_internal
+#undef gray_rgb_convert_internal
+#undef rgb_rgb_convert_internal
+
+#define RGB_RED  EXT_XBGR_RED
+#define RGB_GREEN  EXT_XBGR_GREEN
+#define RGB_BLUE  EXT_XBGR_BLUE
+#define RGB_ALPHA  0
+#define RGB_PIXELSIZE  EXT_XBGR_PIXELSIZE
+#define ycc_rgb_convert_internal  ycc_extxbgr_convert_internal
+#define gray_rgb_convert_internal  gray_extxbgr_convert_internal
+#define rgb_rgb_convert_internal  rgb_extxbgr_convert_internal
+#include "jdcolext.c"
+#undef RGB_RED
+#undef RGB_GREEN
+#undef RGB_BLUE
+#undef RGB_ALPHA
+#undef RGB_PIXELSIZE
+#undef ycc_rgb_convert_internal
+#undef gray_rgb_convert_internal
+#undef rgb_rgb_convert_internal
+
+#define RGB_RED  EXT_XRGB_RED
+#define RGB_GREEN  EXT_XRGB_GREEN
+#define RGB_BLUE  EXT_XRGB_BLUE
+#define RGB_ALPHA  0
+#define RGB_PIXELSIZE  EXT_XRGB_PIXELSIZE
+#define ycc_rgb_convert_internal  ycc_extxrgb_convert_internal
+#define gray_rgb_convert_internal  gray_extxrgb_convert_internal
+#define rgb_rgb_convert_internal  rgb_extxrgb_convert_internal
+#include "jdcolext.c"
+#undef RGB_RED
+#undef RGB_GREEN
+#undef RGB_BLUE
+#undef RGB_ALPHA
+#undef RGB_PIXELSIZE
+#undef ycc_rgb_convert_internal
+#undef gray_rgb_convert_internal
+#undef rgb_rgb_convert_internal
+
+
+/*
+ * Initialize tables for YCC->RGB colorspace conversion.
+ */
+
+LOCAL(void)
+build_ycc_rgb_table(j_decompress_ptr cinfo)
+{
+  my_cconvert_ptr cconvert = (my_cconvert_ptr)cinfo->cconvert;
+  int i;
+  JLONG x;
+  SHIFT_TEMPS
+
+  cconvert->Cr_r_tab = (int *)
+    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+                                (MAXJSAMPLE + 1) * sizeof(int));
+  cconvert->Cb_b_tab = (int *)
+    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+                                (MAXJSAMPLE + 1) * sizeof(int));
+  cconvert->Cr_g_tab = (JLONG *)
+    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+                                (MAXJSAMPLE + 1) * sizeof(JLONG));
+  cconvert->Cb_g_tab = (JLONG *)
+    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+                                (MAXJSAMPLE + 1) * sizeof(JLONG));
+
+  for (i = 0, x = -CENTERJSAMPLE; i <= MAXJSAMPLE; i++, x++) {
+    /* i is the actual input pixel value, in the range 0..MAXJSAMPLE */
+    /* The Cb or Cr value we are thinking of is x = i - CENTERJSAMPLE */
+    /* Cr=>R value is nearest int to 1.40200 * x */
+    cconvert->Cr_r_tab[i] = (int)
+                    RIGHT_SHIFT(FIX(1.40200) * x + ONE_HALF, SCALEBITS);
+    /* Cb=>B value is nearest int to 1.77200 * x */
+    cconvert->Cb_b_tab[i] = (int)
+                    RIGHT_SHIFT(FIX(1.77200) * x + ONE_HALF, SCALEBITS);
+    /* Cr=>G value is scaled-up -0.71414 * x */
+    cconvert->Cr_g_tab[i] = (-FIX(0.71414)) * x;
+    /* Cb=>G value is scaled-up -0.34414 * x */
+    /* We also add in ONE_HALF so that need not do it in inner loop */
+    cconvert->Cb_g_tab[i] = (-FIX(0.34414)) * x + ONE_HALF;
+  }
+}
+
+
+/*
+ * Convert some rows of samples to the output colorspace.
+ */
+
+METHODDEF(void)
+ycc_rgb_convert(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
+                JDIMENSION input_row, JSAMPARRAY output_buf, int num_rows)
+{
+  switch (cinfo->out_color_space) {
+  case JCS_EXT_RGB:
+    ycc_extrgb_convert_internal(cinfo, input_buf, input_row, output_buf,
+                                num_rows);
+    break;
+  case JCS_EXT_RGBX:
+  case JCS_EXT_RGBA:
+    ycc_extrgbx_convert_internal(cinfo, input_buf, input_row, output_buf,
+                                 num_rows);
+    break;
+  case JCS_EXT_BGR:
+    ycc_extbgr_convert_internal(cinfo, input_buf, input_row, output_buf,
+                                num_rows);
+    break;
+  case JCS_EXT_BGRX:
+  case JCS_EXT_BGRA:
+    ycc_extbgrx_convert_internal(cinfo, input_buf, input_row, output_buf,
+                                 num_rows);
+    break;
+  case JCS_EXT_XBGR:
+  case JCS_EXT_ABGR:
+    ycc_extxbgr_convert_internal(cinfo, input_buf, input_row, output_buf,
+                                 num_rows);
+    break;
+  case JCS_EXT_XRGB:
+  case JCS_EXT_ARGB:
+    ycc_extxrgb_convert_internal(cinfo, input_buf, input_row, output_buf,
+                                 num_rows);
+    break;
+  default:
+    ycc_rgb_convert_internal(cinfo, input_buf, input_row, output_buf,
+                             num_rows);
+    break;
+  }
+}
+
+
+/**************** Cases other than YCbCr -> RGB **************/
+
+
+/*
+ * Initialize for RGB->grayscale colorspace conversion.
+ */
+
+LOCAL(void)
+build_rgb_y_table(j_decompress_ptr cinfo)
+{
+  my_cconvert_ptr cconvert = (my_cconvert_ptr)cinfo->cconvert;
+  JLONG *rgb_y_tab;
+  JLONG i;
+
+  /* Allocate and fill in the conversion tables. */
+  cconvert->rgb_y_tab = rgb_y_tab = (JLONG *)
+    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+                                (TABLE_SIZE * sizeof(JLONG)));
+
+  for (i = 0; i <= MAXJSAMPLE; i++) {
+    rgb_y_tab[i + R_Y_OFF] = FIX(0.29900) * i;
+    rgb_y_tab[i + G_Y_OFF] = FIX(0.58700) * i;
+    rgb_y_tab[i + B_Y_OFF] = FIX(0.11400) * i + ONE_HALF;
+  }
+}
+
+
+/*
+ * Convert RGB to grayscale.
+ */
+
+METHODDEF(void)
+rgb_gray_convert(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
+                 JDIMENSION input_row, JSAMPARRAY output_buf, int num_rows)
+{
+  my_cconvert_ptr cconvert = (my_cconvert_ptr)cinfo->cconvert;
+  register int r, g, b;
+  register JLONG *ctab = cconvert->rgb_y_tab;
+  register JSAMPROW outptr;
+  register JSAMPROW inptr0, inptr1, inptr2;
+  register JDIMENSION col;
+  JDIMENSION num_cols = cinfo->output_width;
+
+  while (--num_rows >= 0) {
+    inptr0 = input_buf[0][input_row];
+    inptr1 = input_buf[1][input_row];
+    inptr2 = input_buf[2][input_row];
+    input_row++;
+    outptr = *output_buf++;
+    for (col = 0; col < num_cols; col++) {
+      r = inptr0[col];
+      g = inptr1[col];
+      b = inptr2[col];
+      /* Y */
+      outptr[col] = (JSAMPLE)((ctab[r + R_Y_OFF] + ctab[g + G_Y_OFF] +
+                               ctab[b + B_Y_OFF]) >> SCALEBITS);
+    }
+  }
+}
+
+
+/*
+ * Color conversion for no colorspace change: just copy the data,
+ * converting from separate-planes to interleaved representation.
+ */
+
+METHODDEF(void)
+null_convert(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
+             JDIMENSION input_row, JSAMPARRAY output_buf, int num_rows)
+{
+  register JSAMPROW inptr, inptr0, inptr1, inptr2, inptr3, outptr;
+  register JDIMENSION col;
+  register int num_components = cinfo->num_components;
+  JDIMENSION num_cols = cinfo->output_width;
+  int ci;
+
+  if (num_components == 3) {
+    while (--num_rows >= 0) {
+      inptr0 = input_buf[0][input_row];
+      inptr1 = input_buf[1][input_row];
+      inptr2 = input_buf[2][input_row];
+      input_row++;
+      outptr = *output_buf++;
+      for (col = 0; col < num_cols; col++) {
+        *outptr++ = inptr0[col];
+        *outptr++ = inptr1[col];
+        *outptr++ = inptr2[col];
+      }
+    }
+  } else if (num_components == 4) {
+    while (--num_rows >= 0) {
+      inptr0 = input_buf[0][input_row];
+      inptr1 = input_buf[1][input_row];
+      inptr2 = input_buf[2][input_row];
+      inptr3 = input_buf[3][input_row];
+      input_row++;
+      outptr = *output_buf++;
+      for (col = 0; col < num_cols; col++) {
+        *outptr++ = inptr0[col];
+        *outptr++ = inptr1[col];
+        *outptr++ = inptr2[col];
+        *outptr++ = inptr3[col];
+      }
+    }
+  } else {
+    while (--num_rows >= 0) {
+      for (ci = 0; ci < num_components; ci++) {
+        inptr = input_buf[ci][input_row];
+        outptr = *output_buf;
+        for (col = 0; col < num_cols; col++) {
+          outptr[ci] = inptr[col];
+          outptr += num_components;
+        }
+      }
+      output_buf++;
+      input_row++;
+    }
+  }
+}
+
+
+/*
+ * Color conversion for grayscale: just copy the data.
+ * This also works for YCbCr -> grayscale conversion, in which
+ * we just copy the Y (luminance) component and ignore chrominance.
+ */
+
+METHODDEF(void)
+grayscale_convert(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
+                  JDIMENSION input_row, JSAMPARRAY output_buf, int num_rows)
+{
+  jcopy_sample_rows(input_buf[0], (int)input_row, output_buf, 0, num_rows,
+                    cinfo->output_width);
+}
+
+
+/*
+ * Convert grayscale to RGB
+ */
+
+METHODDEF(void)
+gray_rgb_convert(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
+                 JDIMENSION input_row, JSAMPARRAY output_buf, int num_rows)
+{
+  switch (cinfo->out_color_space) {
+  case JCS_EXT_RGB:
+    gray_extrgb_convert_internal(cinfo, input_buf, input_row, output_buf,
+                                 num_rows);
+    break;
+  case JCS_EXT_RGBX:
+  case JCS_EXT_RGBA:
+    gray_extrgbx_convert_internal(cinfo, input_buf, input_row, output_buf,
+                                  num_rows);
+    break;
+  case JCS_EXT_BGR:
+    gray_extbgr_convert_internal(cinfo, input_buf, input_row, output_buf,
+                                 num_rows);
+    break;
+  case JCS_EXT_BGRX:
+  case JCS_EXT_BGRA:
+    gray_extbgrx_convert_internal(cinfo, input_buf, input_row, output_buf,
+                                  num_rows);
+    break;
+  case JCS_EXT_XBGR:
+  case JCS_EXT_ABGR:
+    gray_extxbgr_convert_internal(cinfo, input_buf, input_row, output_buf,
+                                  num_rows);
+    break;
+  case JCS_EXT_XRGB:
+  case JCS_EXT_ARGB:
+    gray_extxrgb_convert_internal(cinfo, input_buf, input_row, output_buf,
+                                  num_rows);
+    break;
+  default:
+    gray_rgb_convert_internal(cinfo, input_buf, input_row, output_buf,
+                              num_rows);
+    break;
+  }
+}
+
+
+/*
+ * Convert plain RGB to extended RGB
+ */
+
+METHODDEF(void)
+rgb_rgb_convert(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
+                JDIMENSION input_row, JSAMPARRAY output_buf, int num_rows)
+{
+  switch (cinfo->out_color_space) {
+  case JCS_EXT_RGB:
+    rgb_extrgb_convert_internal(cinfo, input_buf, input_row, output_buf,
+                                num_rows);
+    break;
+  case JCS_EXT_RGBX:
+  case JCS_EXT_RGBA:
+    rgb_extrgbx_convert_internal(cinfo, input_buf, input_row, output_buf,
+                                 num_rows);
+    break;
+  case JCS_EXT_BGR:
+    rgb_extbgr_convert_internal(cinfo, input_buf, input_row, output_buf,
+                                num_rows);
+    break;
+  case JCS_EXT_BGRX:
+  case JCS_EXT_BGRA:
+    rgb_extbgrx_convert_internal(cinfo, input_buf, input_row, output_buf,
+                                 num_rows);
+    break;
+  case JCS_EXT_XBGR:
+  case JCS_EXT_ABGR:
+    rgb_extxbgr_convert_internal(cinfo, input_buf, input_row, output_buf,
+                                 num_rows);
+    break;
+  case JCS_EXT_XRGB:
+  case JCS_EXT_ARGB:
+    rgb_extxrgb_convert_internal(cinfo, input_buf, input_row, output_buf,
+                                 num_rows);
+    break;
+  default:
+    rgb_rgb_convert_internal(cinfo, input_buf, input_row, output_buf,
+                             num_rows);
+    break;
+  }
+}
+
+
+/*
+ * Adobe-style YCCK->CMYK conversion.
+ * We convert YCbCr to R=1-C, G=1-M, and B=1-Y using the same
+ * conversion as above, while passing K (black) unchanged.
+ * We assume build_ycc_rgb_table has been called.
+ */
+
+METHODDEF(void)
+ycck_cmyk_convert(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
+                  JDIMENSION input_row, JSAMPARRAY output_buf, int num_rows)
+{
+  my_cconvert_ptr cconvert = (my_cconvert_ptr)cinfo->cconvert;
+  register int y, cb, cr;
+  register JSAMPROW outptr;
+  register JSAMPROW inptr0, inptr1, inptr2, inptr3;
+  register JDIMENSION col;
+  JDIMENSION num_cols = cinfo->output_width;
+  /* copy these pointers into registers if possible */
+  register JSAMPLE *range_limit = cinfo->sample_range_limit;
+  register int *Crrtab = cconvert->Cr_r_tab;
+  register int *Cbbtab = cconvert->Cb_b_tab;
+  register JLONG *Crgtab = cconvert->Cr_g_tab;
+  register JLONG *Cbgtab = cconvert->Cb_g_tab;
+  SHIFT_TEMPS
+
+  while (--num_rows >= 0) {
+    inptr0 = input_buf[0][input_row];
+    inptr1 = input_buf[1][input_row];
+    inptr2 = input_buf[2][input_row];
+    inptr3 = input_buf[3][input_row];
+    input_row++;
+    outptr = *output_buf++;
+    for (col = 0; col < num_cols; col++) {
+      y  = inptr0[col];
+      cb = inptr1[col];
+      cr = inptr2[col];
+      /* Range-limiting is essential due to noise introduced by DCT losses. */
+      outptr[0] = range_limit[MAXJSAMPLE - (y + Crrtab[cr])];   /* red */
+      outptr[1] = range_limit[MAXJSAMPLE - (y +                 /* green */
+                              ((int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],
+                                                 SCALEBITS)))];
+      outptr[2] = range_limit[MAXJSAMPLE - (y + Cbbtab[cb])];   /* blue */
+      /* K passes through unchanged */
+      outptr[3] = inptr3[col];
+      outptr += 4;
+    }
+  }
+}
+
+
+/*
+ * RGB565 conversion
+ */
+
+#define PACK_SHORT_565_LE(r, g, b) \
+  ((((r) << 8) & 0xF800) | (((g) << 3) & 0x7E0) | ((b) >> 3))
+#define PACK_SHORT_565_BE(r, g, b) \
+  (((r) & 0xF8) | ((g) >> 5) | (((g) << 11) & 0xE000) | (((b) << 5) & 0x1F00))
+
+#define PACK_TWO_PIXELS_LE(l, r)    ((r << 16) | l)
+#define PACK_TWO_PIXELS_BE(l, r)    ((l << 16) | r)
+
+#define PACK_NEED_ALIGNMENT(ptr)    (((size_t)(ptr)) & 3)
+
+#define WRITE_TWO_ALIGNED_PIXELS(addr, pixels)  ((*(int *)(addr)) = pixels)
+
+#define DITHER_565_R(r, dither)  ((r) + ((dither) & 0xFF))
+#define DITHER_565_G(g, dither)  ((g) + (((dither) & 0xFF) >> 1))
+#define DITHER_565_B(b, dither)  ((b) + ((dither) & 0xFF))
+
+
+/* Declarations for ordered dithering
+ *
+ * We use a 4x4 ordered dither array packed into 32 bits.  This array is
+ * sufficient for dithering RGB888 to RGB565.
+ */
+
+#define DITHER_MASK       0x3
+#define DITHER_ROTATE(x)  ((((x) & 0xFF) << 24) | (((x) >> 8) & 0x00FFFFFF))
+static const JLONG dither_matrix[4] = {
+  0x0008020A,
+  0x0C040E06,
+  0x030B0109,
+  0x0F070D05
+};
+
+
+static INLINE boolean is_big_endian(void)
+{
+  int test_value = 1;
+  if (*(char *)&test_value != 1)
+    return TRUE;
+  return FALSE;
+}
+
+
+/* Include inline routines for RGB565 conversion */
+
+#define PACK_SHORT_565  PACK_SHORT_565_LE
+#define PACK_TWO_PIXELS  PACK_TWO_PIXELS_LE
+#define ycc_rgb565_convert_internal  ycc_rgb565_convert_le
+#define ycc_rgb565D_convert_internal  ycc_rgb565D_convert_le
+#define rgb_rgb565_convert_internal  rgb_rgb565_convert_le
+#define rgb_rgb565D_convert_internal  rgb_rgb565D_convert_le
+#define gray_rgb565_convert_internal  gray_rgb565_convert_le
+#define gray_rgb565D_convert_internal  gray_rgb565D_convert_le
+#include "jdcol565.c"
+#undef PACK_SHORT_565
+#undef PACK_TWO_PIXELS
+#undef ycc_rgb565_convert_internal
+#undef ycc_rgb565D_convert_internal
+#undef rgb_rgb565_convert_internal
+#undef rgb_rgb565D_convert_internal
+#undef gray_rgb565_convert_internal
+#undef gray_rgb565D_convert_internal
+
+#define PACK_SHORT_565  PACK_SHORT_565_BE
+#define PACK_TWO_PIXELS  PACK_TWO_PIXELS_BE
+#define ycc_rgb565_convert_internal  ycc_rgb565_convert_be
+#define ycc_rgb565D_convert_internal  ycc_rgb565D_convert_be
+#define rgb_rgb565_convert_internal  rgb_rgb565_convert_be
+#define rgb_rgb565D_convert_internal  rgb_rgb565D_convert_be
+#define gray_rgb565_convert_internal  gray_rgb565_convert_be
+#define gray_rgb565D_convert_internal  gray_rgb565D_convert_be
+#include "jdcol565.c"
+#undef PACK_SHORT_565
+#undef PACK_TWO_PIXELS
+#undef ycc_rgb565_convert_internal
+#undef ycc_rgb565D_convert_internal
+#undef rgb_rgb565_convert_internal
+#undef rgb_rgb565D_convert_internal
+#undef gray_rgb565_convert_internal
+#undef gray_rgb565D_convert_internal
+
+
+METHODDEF(void)
+ycc_rgb565_convert(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
+                   JDIMENSION input_row, JSAMPARRAY output_buf, int num_rows)
+{
+  if (is_big_endian())
+    ycc_rgb565_convert_be(cinfo, input_buf, input_row, output_buf, num_rows);
+  else
+    ycc_rgb565_convert_le(cinfo, input_buf, input_row, output_buf, num_rows);
+}
+
+
+METHODDEF(void)
+ycc_rgb565D_convert(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
+                    JDIMENSION input_row, JSAMPARRAY output_buf, int num_rows)
+{
+  if (is_big_endian())
+    ycc_rgb565D_convert_be(cinfo, input_buf, input_row, output_buf, num_rows);
+  else
+    ycc_rgb565D_convert_le(cinfo, input_buf, input_row, output_buf, num_rows);
+}
+
+
+METHODDEF(void)
+rgb_rgb565_convert(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
+                   JDIMENSION input_row, JSAMPARRAY output_buf, int num_rows)
+{
+  if (is_big_endian())
+    rgb_rgb565_convert_be(cinfo, input_buf, input_row, output_buf, num_rows);
+  else
+    rgb_rgb565_convert_le(cinfo, input_buf, input_row, output_buf, num_rows);
+}
+
+
+METHODDEF(void)
+rgb_rgb565D_convert(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
+                    JDIMENSION input_row, JSAMPARRAY output_buf, int num_rows)
+{
+  if (is_big_endian())
+    rgb_rgb565D_convert_be(cinfo, input_buf, input_row, output_buf, num_rows);
+  else
+    rgb_rgb565D_convert_le(cinfo, input_buf, input_row, output_buf, num_rows);
+}
+
+
+METHODDEF(void)
+gray_rgb565_convert(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
+                    JDIMENSION input_row, JSAMPARRAY output_buf, int num_rows)
+{
+  if (is_big_endian())
+    gray_rgb565_convert_be(cinfo, input_buf, input_row, output_buf, num_rows);
+  else
+    gray_rgb565_convert_le(cinfo, input_buf, input_row, output_buf, num_rows);
+}
+
+
+METHODDEF(void)
+gray_rgb565D_convert(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
+                     JDIMENSION input_row, JSAMPARRAY output_buf, int num_rows)
+{
+  if (is_big_endian())
+    gray_rgb565D_convert_be(cinfo, input_buf, input_row, output_buf, num_rows);
+  else
+    gray_rgb565D_convert_le(cinfo, input_buf, input_row, output_buf, num_rows);
+}
+
+
+/*
+ * Empty method for start_pass.
+ */
+
+METHODDEF(void)
+start_pass_dcolor(j_decompress_ptr cinfo)
+{
+  /* no work needed */
+}
+
+
+/*
+ * Module initialization routine for output colorspace conversion.
+ */
+
+GLOBAL(void)
+jinit_color_deconverter(j_decompress_ptr cinfo)
+{
+  my_cconvert_ptr cconvert;
+  int ci;
+
+  cconvert = (my_cconvert_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+                                sizeof(my_color_deconverter));
+  cinfo->cconvert = (struct jpeg_color_deconverter *)cconvert;
+  cconvert->pub.start_pass = start_pass_dcolor;
+
+  /* Make sure num_components agrees with jpeg_color_space */
+  switch (cinfo->jpeg_color_space) {
+  case JCS_GRAYSCALE:
+    if (cinfo->num_components != 1)
+      ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
+    break;
+
+  case JCS_RGB:
+  case JCS_YCbCr:
+    if (cinfo->num_components != 3)
+      ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
+    break;
+
+  case JCS_CMYK:
+  case JCS_YCCK:
+    if (cinfo->num_components != 4)
+      ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
+    break;
+
+  default:                      /* JCS_UNKNOWN can be anything */
+    if (cinfo->num_components < 1)
+      ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
+    break;
+  }
+
+  /* Set out_color_components and conversion method based on requested space.
+   * Also clear the component_needed flags for any unused components,
+   * so that earlier pipeline stages can avoid useless computation.
+   */
+
+  switch (cinfo->out_color_space) {
+  case JCS_GRAYSCALE:
+    cinfo->out_color_components = 1;
+    if (cinfo->jpeg_color_space == JCS_GRAYSCALE ||
+        cinfo->jpeg_color_space == JCS_YCbCr) {
+      cconvert->pub.color_convert = grayscale_convert;
+      /* For color->grayscale conversion, only the Y (0) component is needed */
+      for (ci = 1; ci < cinfo->num_components; ci++)
+        cinfo->comp_info[ci].component_needed = FALSE;
+    } else if (cinfo->jpeg_color_space == JCS_RGB) {
+      cconvert->pub.color_convert = rgb_gray_convert;
+      build_rgb_y_table(cinfo);
+    } else
+      ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
+    break;
+
+  case JCS_RGB:
+  case JCS_EXT_RGB:
+  case JCS_EXT_RGBX:
+  case JCS_EXT_BGR:
+  case JCS_EXT_BGRX:
+  case JCS_EXT_XBGR:
+  case JCS_EXT_XRGB:
+  case JCS_EXT_RGBA:
+  case JCS_EXT_BGRA:
+  case JCS_EXT_ABGR:
+  case JCS_EXT_ARGB:
+    cinfo->out_color_components = rgb_pixelsize[cinfo->out_color_space];
+    if (cinfo->jpeg_color_space == JCS_YCbCr) {
+      if (jsimd_can_ycc_rgb())
+        cconvert->pub.color_convert = jsimd_ycc_rgb_convert;
+      else {
+        cconvert->pub.color_convert = ycc_rgb_convert;
+        build_ycc_rgb_table(cinfo);
+      }
+    } else if (cinfo->jpeg_color_space == JCS_GRAYSCALE) {
+      cconvert->pub.color_convert = gray_rgb_convert;
+    } else if (cinfo->jpeg_color_space == JCS_RGB) {
+      if (rgb_red[cinfo->out_color_space] == 0 &&
+          rgb_green[cinfo->out_color_space] == 1 &&
+          rgb_blue[cinfo->out_color_space] == 2 &&
+          rgb_pixelsize[cinfo->out_color_space] == 3)
+        cconvert->pub.color_convert = null_convert;
+      else
+        cconvert->pub.color_convert = rgb_rgb_convert;
+    } else
+      ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
+    break;
+
+  case JCS_RGB565:
+    cinfo->out_color_components = 3;
+    if (cinfo->dither_mode == JDITHER_NONE) {
+      if (cinfo->jpeg_color_space == JCS_YCbCr) {
+        if (jsimd_can_ycc_rgb565())
+          cconvert->pub.color_convert = jsimd_ycc_rgb565_convert;
+        else {
+          cconvert->pub.color_convert = ycc_rgb565_convert;
+          build_ycc_rgb_table(cinfo);
+        }
+      } else if (cinfo->jpeg_color_space == JCS_GRAYSCALE) {
+        cconvert->pub.color_convert = gray_rgb565_convert;
+      } else if (cinfo->jpeg_color_space == JCS_RGB) {
+        cconvert->pub.color_convert = rgb_rgb565_convert;
+      } else
+        ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
+    } else {
+      /* only ordered dithering is supported */
+      if (cinfo->jpeg_color_space == JCS_YCbCr) {
+        cconvert->pub.color_convert = ycc_rgb565D_convert;
+        build_ycc_rgb_table(cinfo);
+      } else if (cinfo->jpeg_color_space == JCS_GRAYSCALE) {
+        cconvert->pub.color_convert = gray_rgb565D_convert;
+      } else if (cinfo->jpeg_color_space == JCS_RGB) {
+        cconvert->pub.color_convert = rgb_rgb565D_convert;
+      } else
+        ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
+    }
+    break;
+
+  case JCS_CMYK:
+    cinfo->out_color_components = 4;
+    if (cinfo->jpeg_color_space == JCS_YCCK) {
+      cconvert->pub.color_convert = ycck_cmyk_convert;
+      build_ycc_rgb_table(cinfo);
+    } else if (cinfo->jpeg_color_space == JCS_CMYK) {
+      cconvert->pub.color_convert = null_convert;
+    } else
+      ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
+    break;
+
+  default:
+    /* Permit null conversion to same output space */
+    if (cinfo->out_color_space == cinfo->jpeg_color_space) {
+      cinfo->out_color_components = cinfo->num_components;
+      cconvert->pub.color_convert = null_convert;
+    } else                      /* unsupported non-null conversion */
+      ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
+    break;
+  }
+
+  if (cinfo->quantize_colors)
+    cinfo->output_components = 1; /* single colormapped output component */
+  else
+    cinfo->output_components = cinfo->out_color_components;
+}
diff --git a/3rdparty/libjpeg/src/jdct.h b/3rdparty/libjpeg/src/jdct.h
new file mode 100644
index 00000000..66d1718b
--- /dev/null
+++ b/3rdparty/libjpeg/src/jdct.h
@@ -0,0 +1,208 @@
+/*
+ * jdct.h
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1994-1996, Thomas G. Lane.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2015, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This include file contains common declarations for the forward and
+ * inverse DCT modules.  These declarations are private to the DCT managers
+ * (jcdctmgr.c, jddctmgr.c) and the individual DCT algorithms.
+ * The individual DCT algorithms are kept in separate files to ease
+ * machine-dependent tuning (e.g., assembly coding).
+ */
+
+
+/*
+ * A forward DCT routine is given a pointer to a work area of type DCTELEM[];
+ * the DCT is to be performed in-place in that buffer.  Type DCTELEM is int
+ * for 8-bit samples, JLONG for 12-bit samples.  (NOTE: Floating-point DCT
+ * implementations use an array of type FAST_FLOAT, instead.)
+ * The DCT inputs are expected to be signed (range +-CENTERJSAMPLE).
+ * The DCT outputs are returned scaled up by a factor of 8; they therefore
+ * have a range of +-8K for 8-bit data, +-128K for 12-bit data.  This
+ * convention improves accuracy in integer implementations and saves some
+ * work in floating-point ones.
+ * Quantization of the output coefficients is done by jcdctmgr.c. This
+ * step requires an unsigned type and also one with twice the bits.
+ */
+
+#if BITS_IN_JSAMPLE == 8
+#ifndef WITH_SIMD
+typedef int DCTELEM;            /* 16 or 32 bits is fine */
+typedef unsigned int UDCTELEM;
+typedef unsigned long long UDCTELEM2;
+#else
+typedef short DCTELEM;          /* prefer 16 bit with SIMD for parellelism */
+typedef unsigned short UDCTELEM;
+typedef unsigned int UDCTELEM2;
+#endif
+#else
+typedef JLONG DCTELEM;          /* must have 32 bits */
+typedef unsigned long long UDCTELEM2;
+#endif
+
+
+/*
+ * An inverse DCT routine is given a pointer to the input JBLOCK and a pointer
+ * to an output sample array.  The routine must dequantize the input data as
+ * well as perform the IDCT; for dequantization, it uses the multiplier table
+ * pointed to by compptr->dct_table.  The output data is to be placed into the
+ * sample array starting at a specified column.  (Any row offset needed will
+ * be applied to the array pointer before it is passed to the IDCT code.)
+ * Note that the number of samples emitted by the IDCT routine is
+ * DCT_scaled_size * DCT_scaled_size.
+ */
+
+/* typedef inverse_DCT_method_ptr is declared in jpegint.h */
+
+/*
+ * Each IDCT routine has its own ideas about the best dct_table element type.
+ */
+
+typedef MULTIPLIER ISLOW_MULT_TYPE;  /* short or int, whichever is faster */
+#if BITS_IN_JSAMPLE == 8
+typedef MULTIPLIER IFAST_MULT_TYPE;  /* 16 bits is OK, use short if faster */
+#define IFAST_SCALE_BITS  2          /* fractional bits in scale factors */
+#else
+typedef JLONG IFAST_MULT_TYPE;       /* need 32 bits for scaled quantizers */
+#define IFAST_SCALE_BITS  13         /* fractional bits in scale factors */
+#endif
+typedef FAST_FLOAT FLOAT_MULT_TYPE;  /* preferred floating type */
+
+
+/*
+ * Each IDCT routine is responsible for range-limiting its results and
+ * converting them to unsigned form (0..MAXJSAMPLE).  The raw outputs could
+ * be quite far out of range if the input data is corrupt, so a bulletproof
+ * range-limiting step is required.  We use a mask-and-table-lookup method
+ * to do the combined operations quickly.  See the comments with
+ * prepare_range_limit_table (in jdmaster.c) for more info.
+ */
+
+#define IDCT_range_limit(cinfo)  ((cinfo)->sample_range_limit + CENTERJSAMPLE)
+
+#define RANGE_MASK  (MAXJSAMPLE * 4 + 3) /* 2 bits wider than legal samples */
+
+
+/* Extern declarations for the forward and inverse DCT routines. */
+
+EXTERN(void) jpeg_fdct_islow(DCTELEM *data);
+EXTERN(void) jpeg_fdct_ifast(DCTELEM *data);
+EXTERN(void) jpeg_fdct_float(FAST_FLOAT *data);
+
+EXTERN(void) jpeg_idct_islow(j_decompress_ptr cinfo,
+                             jpeg_component_info *compptr, JCOEFPTR coef_block,
+                             JSAMPARRAY output_buf, JDIMENSION output_col);
+EXTERN(void) jpeg_idct_ifast(j_decompress_ptr cinfo,
+                             jpeg_component_info *compptr, JCOEFPTR coef_block,
+                             JSAMPARRAY output_buf, JDIMENSION output_col);
+EXTERN(void) jpeg_idct_float(j_decompress_ptr cinfo,
+                             jpeg_component_info *compptr, JCOEFPTR coef_block,
+                             JSAMPARRAY output_buf, JDIMENSION output_col);
+EXTERN(void) jpeg_idct_7x7(j_decompress_ptr cinfo,
+                           jpeg_component_info *compptr, JCOEFPTR coef_block,
+                           JSAMPARRAY output_buf, JDIMENSION output_col);
+EXTERN(void) jpeg_idct_6x6(j_decompress_ptr cinfo,
+                           jpeg_component_info *compptr, JCOEFPTR coef_block,
+                           JSAMPARRAY output_buf, JDIMENSION output_col);
+EXTERN(void) jpeg_idct_5x5(j_decompress_ptr cinfo,
+                           jpeg_component_info *compptr, JCOEFPTR coef_block,
+                           JSAMPARRAY output_buf, JDIMENSION output_col);
+EXTERN(void) jpeg_idct_4x4(j_decompress_ptr cinfo,
+                           jpeg_component_info *compptr, JCOEFPTR coef_block,
+                           JSAMPARRAY output_buf, JDIMENSION output_col);
+EXTERN(void) jpeg_idct_3x3(j_decompress_ptr cinfo,
+                           jpeg_component_info *compptr, JCOEFPTR coef_block,
+                           JSAMPARRAY output_buf, JDIMENSION output_col);
+EXTERN(void) jpeg_idct_2x2(j_decompress_ptr cinfo,
+                           jpeg_component_info *compptr, JCOEFPTR coef_block,
+                           JSAMPARRAY output_buf, JDIMENSION output_col);
+EXTERN(void) jpeg_idct_1x1(j_decompress_ptr cinfo,
+                           jpeg_component_info *compptr, JCOEFPTR coef_block,
+                           JSAMPARRAY output_buf, JDIMENSION output_col);
+EXTERN(void) jpeg_idct_9x9(j_decompress_ptr cinfo,
+                           jpeg_component_info *compptr, JCOEFPTR coef_block,
+                           JSAMPARRAY output_buf, JDIMENSION output_col);
+EXTERN(void) jpeg_idct_10x10(j_decompress_ptr cinfo,
+                             jpeg_component_info *compptr, JCOEFPTR coef_block,
+                             JSAMPARRAY output_buf, JDIMENSION output_col);
+EXTERN(void) jpeg_idct_11x11(j_decompress_ptr cinfo,
+                             jpeg_component_info *compptr, JCOEFPTR coef_block,
+                             JSAMPARRAY output_buf, JDIMENSION output_col);
+EXTERN(void) jpeg_idct_12x12(j_decompress_ptr cinfo,
+                             jpeg_component_info *compptr, JCOEFPTR coef_block,
+                             JSAMPARRAY output_buf, JDIMENSION output_col);
+EXTERN(void) jpeg_idct_13x13(j_decompress_ptr cinfo,
+                             jpeg_component_info *compptr, JCOEFPTR coef_block,
+                             JSAMPARRAY output_buf, JDIMENSION output_col);
+EXTERN(void) jpeg_idct_14x14(j_decompress_ptr cinfo,
+                             jpeg_component_info *compptr, JCOEFPTR coef_block,
+                             JSAMPARRAY output_buf, JDIMENSION output_col);
+EXTERN(void) jpeg_idct_15x15(j_decompress_ptr cinfo,
+                             jpeg_component_info *compptr, JCOEFPTR coef_block,
+                             JSAMPARRAY output_buf, JDIMENSION output_col);
+EXTERN(void) jpeg_idct_16x16(j_decompress_ptr cinfo,
+                             jpeg_component_info *compptr, JCOEFPTR coef_block,
+                             JSAMPARRAY output_buf, JDIMENSION output_col);
+
+
+/*
+ * Macros for handling fixed-point arithmetic; these are used by many
+ * but not all of the DCT/IDCT modules.
+ *
+ * All values are expected to be of type JLONG.
+ * Fractional constants are scaled left by CONST_BITS bits.
+ * CONST_BITS is defined within each module using these macros,
+ * and may differ from one module to the next.
+ */
+
+#define ONE          ((JLONG)1)
+#define CONST_SCALE  (ONE << CONST_BITS)
+
+/* Convert a positive real constant to an integer scaled by CONST_SCALE.
+ * Caution: some C compilers fail to reduce "FIX(constant)" at compile time,
+ * thus causing a lot of useless floating-point operations at run time.
+ */
+
+#define FIX(x)  ((JLONG)((x) * CONST_SCALE + 0.5))
+
+/* Descale and correctly round a JLONG value that's scaled by N bits.
+ * We assume RIGHT_SHIFT rounds towards minus infinity, so adding
+ * the fudge factor is correct for either sign of X.
+ */
+
+#define DESCALE(x, n)  RIGHT_SHIFT((x) + (ONE << ((n) - 1)), n)
+
+/* Multiply a JLONG variable by a JLONG constant to yield a JLONG result.
+ * This macro is used only when the two inputs will actually be no more than
+ * 16 bits wide, so that a 16x16->32 bit multiply can be used instead of a
+ * full 32x32 multiply.  This provides a useful speedup on many machines.
+ * Unfortunately there is no way to specify a 16x16->32 multiply portably
+ * in C, but some C compilers will do the right thing if you provide the
+ * correct combination of casts.
+ */
+
+#ifdef SHORTxSHORT_32           /* may work if 'int' is 32 bits */
+#define MULTIPLY16C16(var, const)  (((INT16)(var)) * ((INT16)(const)))
+#endif
+#ifdef SHORTxLCONST_32          /* known to work with Microsoft C 6.0 */
+#define MULTIPLY16C16(var, const)  (((INT16)(var)) * ((JLONG)(const)))
+#endif
+
+#ifndef MULTIPLY16C16           /* default definition */
+#define MULTIPLY16C16(var, const)  ((var) * (const))
+#endif
+
+/* Same except both inputs are variables. */
+
+#ifdef SHORTxSHORT_32           /* may work if 'int' is 32 bits */
+#define MULTIPLY16V16(var1, var2)  (((INT16)(var1)) * ((INT16)(var2)))
+#endif
+
+#ifndef MULTIPLY16V16           /* default definition */
+#define MULTIPLY16V16(var1, var2)  ((var1) * (var2))
+#endif
diff --git a/3rdparty/libjpeg/src/jddctmgr.c b/3rdparty/libjpeg/src/jddctmgr.c
new file mode 100644
index 00000000..266f4466
--- /dev/null
+++ b/3rdparty/libjpeg/src/jddctmgr.c
@@ -0,0 +1,352 @@
+/*
+ * jddctmgr.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1994-1996, Thomas G. Lane.
+ * Modified 2002-2010 by Guido Vollbeding.
+ * libjpeg-turbo Modifications:
+ * Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+ * Copyright (C) 2010, 2015, D. R. Commander.
+ * Copyright (C) 2013, MIPS Technologies, Inc., California.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains the inverse-DCT management logic.
+ * This code selects a particular IDCT implementation to be used,
+ * and it performs related housekeeping chores.  No code in this file
+ * is executed per IDCT step, only during output pass setup.
+ *
+ * Note that the IDCT routines are responsible for performing coefficient
+ * dequantization as well as the IDCT proper.  This module sets up the
+ * dequantization multiplier table needed by the IDCT routine.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jdct.h"               /* Private declarations for DCT subsystem */
+#include "jsimddct.h"
+#include "jpegcomp.h"
+
+
+/*
+ * The decompressor input side (jdinput.c) saves away the appropriate
+ * quantization table for each component at the start of the first scan
+ * involving that component.  (This is necessary in order to correctly
+ * decode files that reuse Q-table slots.)
+ * When we are ready to make an output pass, the saved Q-table is converted
+ * to a multiplier table that will actually be used by the IDCT routine.
+ * The multiplier table contents are IDCT-method-dependent.  To support
+ * application changes in IDCT method between scans, we can remake the
+ * multiplier tables if necessary.
+ * In buffered-image mode, the first output pass may occur before any data
+ * has been seen for some components, and thus before their Q-tables have
+ * been saved away.  To handle this case, multiplier tables are preset
+ * to zeroes; the result of the IDCT will be a neutral gray level.
+ */
+
+
+/* Private subobject for this module */
+
+typedef struct {
+  struct jpeg_inverse_dct pub;  /* public fields */
+
+  /* This array contains the IDCT method code that each multiplier table
+   * is currently set up for, or -1 if it's not yet set up.
+   * The actual multiplier tables are pointed to by dct_table in the
+   * per-component comp_info structures.
+   */
+  int cur_method[MAX_COMPONENTS];
+} my_idct_controller;
+
+typedef my_idct_controller *my_idct_ptr;
+
+
+/* Allocated multiplier tables: big enough for any supported variant */
+
+typedef union {
+  ISLOW_MULT_TYPE islow_array[DCTSIZE2];
+#ifdef DCT_IFAST_SUPPORTED
+  IFAST_MULT_TYPE ifast_array[DCTSIZE2];
+#endif
+#ifdef DCT_FLOAT_SUPPORTED
+  FLOAT_MULT_TYPE float_array[DCTSIZE2];
+#endif
+} multiplier_table;
+
+
+/* The current scaled-IDCT routines require ISLOW-style multiplier tables,
+ * so be sure to compile that code if either ISLOW or SCALING is requested.
+ */
+#ifdef DCT_ISLOW_SUPPORTED
+#define PROVIDE_ISLOW_TABLES
+#else
+#ifdef IDCT_SCALING_SUPPORTED
+#define PROVIDE_ISLOW_TABLES
+#endif
+#endif
+
+
+/*
+ * Prepare for an output pass.
+ * Here we select the proper IDCT routine for each component and build
+ * a matching multiplier table.
+ */
+
+METHODDEF(void)
+start_pass(j_decompress_ptr cinfo)
+{
+  my_idct_ptr idct = (my_idct_ptr)cinfo->idct;
+  int ci, i;
+  jpeg_component_info *compptr;
+  int method = 0;
+  inverse_DCT_method_ptr method_ptr = NULL;
+  JQUANT_TBL *qtbl;
+
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    /* Select the proper IDCT routine for this component's scaling */
+    switch (compptr->_DCT_scaled_size) {
+#ifdef IDCT_SCALING_SUPPORTED
+    case 1:
+      method_ptr = jpeg_idct_1x1;
+      method = JDCT_ISLOW;      /* jidctred uses islow-style table */
+      break;
+    case 2:
+      if (jsimd_can_idct_2x2())
+        method_ptr = jsimd_idct_2x2;
+      else
+        method_ptr = jpeg_idct_2x2;
+      method = JDCT_ISLOW;      /* jidctred uses islow-style table */
+      break;
+    case 3:
+      method_ptr = jpeg_idct_3x3;
+      method = JDCT_ISLOW;      /* jidctint uses islow-style table */
+      break;
+    case 4:
+      if (jsimd_can_idct_4x4())
+        method_ptr = jsimd_idct_4x4;
+      else
+        method_ptr = jpeg_idct_4x4;
+      method = JDCT_ISLOW;      /* jidctred uses islow-style table */
+      break;
+    case 5:
+      method_ptr = jpeg_idct_5x5;
+      method = JDCT_ISLOW;      /* jidctint uses islow-style table */
+      break;
+    case 6:
+#if defined(__mips__)
+      if (jsimd_can_idct_6x6())
+        method_ptr = jsimd_idct_6x6;
+      else
+#endif
+      method_ptr = jpeg_idct_6x6;
+      method = JDCT_ISLOW;      /* jidctint uses islow-style table */
+      break;
+    case 7:
+      method_ptr = jpeg_idct_7x7;
+      method = JDCT_ISLOW;      /* jidctint uses islow-style table */
+      break;
+#endif
+    case DCTSIZE:
+      switch (cinfo->dct_method) {
+#ifdef DCT_ISLOW_SUPPORTED
+      case JDCT_ISLOW:
+        if (jsimd_can_idct_islow())
+          method_ptr = jsimd_idct_islow;
+        else
+          method_ptr = jpeg_idct_islow;
+        method = JDCT_ISLOW;
+        break;
+#endif
+#ifdef DCT_IFAST_SUPPORTED
+      case JDCT_IFAST:
+        if (jsimd_can_idct_ifast())
+          method_ptr = jsimd_idct_ifast;
+        else
+          method_ptr = jpeg_idct_ifast;
+        method = JDCT_IFAST;
+        break;
+#endif
+#ifdef DCT_FLOAT_SUPPORTED
+      case JDCT_FLOAT:
+        if (jsimd_can_idct_float())
+          method_ptr = jsimd_idct_float;
+        else
+          method_ptr = jpeg_idct_float;
+        method = JDCT_FLOAT;
+        break;
+#endif
+      default:
+        ERREXIT(cinfo, JERR_NOT_COMPILED);
+        break;
+      }
+      break;
+#ifdef IDCT_SCALING_SUPPORTED
+    case 9:
+      method_ptr = jpeg_idct_9x9;
+      method = JDCT_ISLOW;      /* jidctint uses islow-style table */
+      break;
+    case 10:
+      method_ptr = jpeg_idct_10x10;
+      method = JDCT_ISLOW;      /* jidctint uses islow-style table */
+      break;
+    case 11:
+      method_ptr = jpeg_idct_11x11;
+      method = JDCT_ISLOW;      /* jidctint uses islow-style table */
+      break;
+    case 12:
+#if defined(__mips__)
+      if (jsimd_can_idct_12x12())
+        method_ptr = jsimd_idct_12x12;
+      else
+#endif
+      method_ptr = jpeg_idct_12x12;
+      method = JDCT_ISLOW;      /* jidctint uses islow-style table */
+      break;
+    case 13:
+      method_ptr = jpeg_idct_13x13;
+      method = JDCT_ISLOW;      /* jidctint uses islow-style table */
+      break;
+    case 14:
+      method_ptr = jpeg_idct_14x14;
+      method = JDCT_ISLOW;      /* jidctint uses islow-style table */
+      break;
+    case 15:
+      method_ptr = jpeg_idct_15x15;
+      method = JDCT_ISLOW;      /* jidctint uses islow-style table */
+      break;
+    case 16:
+      method_ptr = jpeg_idct_16x16;
+      method = JDCT_ISLOW;      /* jidctint uses islow-style table */
+      break;
+#endif
+    default:
+      ERREXIT1(cinfo, JERR_BAD_DCTSIZE, compptr->_DCT_scaled_size);
+      break;
+    }
+    idct->pub.inverse_DCT[ci] = method_ptr;
+    /* Create multiplier table from quant table.
+     * However, we can skip this if the component is uninteresting
+     * or if we already built the table.  Also, if no quant table
+     * has yet been saved for the component, we leave the
+     * multiplier table all-zero; we'll be reading zeroes from the
+     * coefficient controller's buffer anyway.
+     */
+    if (!compptr->component_needed || idct->cur_method[ci] == method)
+      continue;
+    qtbl = compptr->quant_table;
+    if (qtbl == NULL)           /* happens if no data yet for component */
+      continue;
+    idct->cur_method[ci] = method;
+    switch (method) {
+#ifdef PROVIDE_ISLOW_TABLES
+    case JDCT_ISLOW:
+      {
+        /* For LL&M IDCT method, multipliers are equal to raw quantization
+         * coefficients, but are stored as ints to ensure access efficiency.
+         */
+        ISLOW_MULT_TYPE *ismtbl = (ISLOW_MULT_TYPE *)compptr->dct_table;
+        for (i = 0; i < DCTSIZE2; i++) {
+          ismtbl[i] = (ISLOW_MULT_TYPE)qtbl->quantval[i];
+        }
+      }
+      break;
+#endif
+#ifdef DCT_IFAST_SUPPORTED
+    case JDCT_IFAST:
+      {
+        /* For AA&N IDCT method, multipliers are equal to quantization
+         * coefficients scaled by scalefactor[row]*scalefactor[col], where
+         *   scalefactor[0] = 1
+         *   scalefactor[k] = cos(k*PI/16) * sqrt(2)    for k=1..7
+         * For integer operation, the multiplier table is to be scaled by
+         * IFAST_SCALE_BITS.
+         */
+        IFAST_MULT_TYPE *ifmtbl = (IFAST_MULT_TYPE *)compptr->dct_table;
+#define CONST_BITS  14
+        static const INT16 aanscales[DCTSIZE2] = {
+          /* precomputed values scaled up by 14 bits */
+          16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,
+          22725, 31521, 29692, 26722, 22725, 17855, 12299,  6270,
+          21407, 29692, 27969, 25172, 21407, 16819, 11585,  5906,
+          19266, 26722, 25172, 22654, 19266, 15137, 10426,  5315,
+          16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,
+          12873, 17855, 16819, 15137, 12873, 10114,  6967,  3552,
+           8867, 12299, 11585, 10426,  8867,  6967,  4799,  2446,
+           4520,  6270,  5906,  5315,  4520,  3552,  2446,  1247
+        };
+        SHIFT_TEMPS
+
+        for (i = 0; i < DCTSIZE2; i++) {
+          ifmtbl[i] = (IFAST_MULT_TYPE)
+            DESCALE(MULTIPLY16V16((JLONG)qtbl->quantval[i],
+                                  (JLONG)aanscales[i]),
+                    CONST_BITS - IFAST_SCALE_BITS);
+        }
+      }
+      break;
+#endif
+#ifdef DCT_FLOAT_SUPPORTED
+    case JDCT_FLOAT:
+      {
+        /* For float AA&N IDCT method, multipliers are equal to quantization
+         * coefficients scaled by scalefactor[row]*scalefactor[col], where
+         *   scalefactor[0] = 1
+         *   scalefactor[k] = cos(k*PI/16) * sqrt(2)    for k=1..7
+         */
+        FLOAT_MULT_TYPE *fmtbl = (FLOAT_MULT_TYPE *)compptr->dct_table;
+        int row, col;
+        static const double aanscalefactor[DCTSIZE] = {
+          1.0, 1.387039845, 1.306562965, 1.175875602,
+          1.0, 0.785694958, 0.541196100, 0.275899379
+        };
+
+        i = 0;
+        for (row = 0; row < DCTSIZE; row++) {
+          for (col = 0; col < DCTSIZE; col++) {
+            fmtbl[i] = (FLOAT_MULT_TYPE)
+              ((double)qtbl->quantval[i] *
+               aanscalefactor[row] * aanscalefactor[col]);
+            i++;
+          }
+        }
+      }
+      break;
+#endif
+    default:
+      ERREXIT(cinfo, JERR_NOT_COMPILED);
+      break;
+    }
+  }
+}
+
+
+/*
+ * Initialize IDCT manager.
+ */
+
+GLOBAL(void)
+jinit_inverse_dct(j_decompress_ptr cinfo)
+{
+  my_idct_ptr idct;
+  int ci;
+  jpeg_component_info *compptr;
+
+  idct = (my_idct_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+                                sizeof(my_idct_controller));
+  cinfo->idct = (struct jpeg_inverse_dct *)idct;
+  idct->pub.start_pass = start_pass;
+
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    /* Allocate and pre-zero a multiplier table for each component */
+    compptr->dct_table =
+      (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+                                  sizeof(multiplier_table));
+    MEMZERO(compptr->dct_table, sizeof(multiplier_table));
+    /* Mark multiplier table not yet set up for any method */
+    idct->cur_method[ci] = -1;
+  }
+}
diff --git a/3rdparty/libjpeg/src/jdhuff.c b/3rdparty/libjpeg/src/jdhuff.c
new file mode 100644
index 00000000..b5665d56
--- /dev/null
+++ b/3rdparty/libjpeg/src/jdhuff.c
@@ -0,0 +1,814 @@
+/*
+ * jdhuff.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1991-1997, Thomas G. Lane.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2009-2011, 2016, 2018-2019, D. R. Commander.
+ * Copyright (C) 2018, Matthias Räncker.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains Huffman entropy decoding routines.
+ *
+ * Much of the complexity here has to do with supporting input suspension.
+ * If the data source module demands suspension, we want to be able to back
+ * up to the start of the current MCU.  To do this, we copy state variables
+ * into local working storage, and update them back to the permanent
+ * storage only upon successful completion of an MCU.
+ *
+ * NOTE: All referenced figures are from
+ * Recommendation ITU-T T.81 (1992) | ISO/IEC 10918-1:1994.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jdhuff.h"             /* Declarations shared with jdphuff.c */
+#include "jpegcomp.h"
+#include "jstdhuff.c"
+
+
+/*
+ * Expanded entropy decoder object for Huffman decoding.
+ *
+ * The savable_state subrecord contains fields that change within an MCU,
+ * but must not be updated permanently until we complete the MCU.
+ */
+
+typedef struct {
+  int last_dc_val[MAX_COMPS_IN_SCAN]; /* last DC coef for each component */
+} savable_state;
+
+typedef struct {
+  struct jpeg_entropy_decoder pub; /* public fields */
+
+  /* These fields are loaded into local variables at start of each MCU.
+   * In case of suspension, we exit WITHOUT updating them.
+   */
+  bitread_perm_state bitstate;  /* Bit buffer at start of MCU */
+  savable_state saved;          /* Other state at start of MCU */
+
+  /* These fields are NOT loaded into local working state. */
+  unsigned int restarts_to_go;  /* MCUs left in this restart interval */
+
+  /* Pointers to derived tables (these workspaces have image lifespan) */
+  d_derived_tbl *dc_derived_tbls[NUM_HUFF_TBLS];
+  d_derived_tbl *ac_derived_tbls[NUM_HUFF_TBLS];
+
+  /* Precalculated info set up by start_pass for use in decode_mcu: */
+
+  /* Pointers to derived tables to be used for each block within an MCU */
+  d_derived_tbl *dc_cur_tbls[D_MAX_BLOCKS_IN_MCU];
+  d_derived_tbl *ac_cur_tbls[D_MAX_BLOCKS_IN_MCU];
+  /* Whether we care about the DC and AC coefficient values for each block */
+  boolean dc_needed[D_MAX_BLOCKS_IN_MCU];
+  boolean ac_needed[D_MAX_BLOCKS_IN_MCU];
+} huff_entropy_decoder;
+
+typedef huff_entropy_decoder *huff_entropy_ptr;
+
+
+/*
+ * Initialize for a Huffman-compressed scan.
+ */
+
+METHODDEF(void)
+start_pass_huff_decoder(j_decompress_ptr cinfo)
+{
+  huff_entropy_ptr entropy = (huff_entropy_ptr)cinfo->entropy;
+  int ci, blkn, dctbl, actbl;
+  d_derived_tbl **pdtbl;
+  jpeg_component_info *compptr;
+
+  /* Check that the scan parameters Ss, Se, Ah/Al are OK for sequential JPEG.
+   * This ought to be an error condition, but we make it a warning because
+   * there are some baseline files out there with all zeroes in these bytes.
+   */
+  if (cinfo->Ss != 0 || cinfo->Se != DCTSIZE2 - 1 ||
+      cinfo->Ah != 0 || cinfo->Al != 0)
+    WARNMS(cinfo, JWRN_NOT_SEQUENTIAL);
+
+  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+    compptr = cinfo->cur_comp_info[ci];
+    dctbl = compptr->dc_tbl_no;
+    actbl = compptr->ac_tbl_no;
+    /* Compute derived values for Huffman tables */
+    /* We may do this more than once for a table, but it's not expensive */
+    pdtbl = (d_derived_tbl **)(entropy->dc_derived_tbls) + dctbl;
+    jpeg_make_d_derived_tbl(cinfo, TRUE, dctbl, pdtbl);
+    pdtbl = (d_derived_tbl **)(entropy->ac_derived_tbls) + actbl;
+    jpeg_make_d_derived_tbl(cinfo, FALSE, actbl, pdtbl);
+    /* Initialize DC predictions to 0 */
+    entropy->saved.last_dc_val[ci] = 0;
+  }
+
+  /* Precalculate decoding info for each block in an MCU of this scan */
+  for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
+    ci = cinfo->MCU_membership[blkn];
+    compptr = cinfo->cur_comp_info[ci];
+    /* Precalculate which table to use for each block */
+    entropy->dc_cur_tbls[blkn] = entropy->dc_derived_tbls[compptr->dc_tbl_no];
+    entropy->ac_cur_tbls[blkn] = entropy->ac_derived_tbls[compptr->ac_tbl_no];
+    /* Decide whether we really care about the coefficient values */
+    if (compptr->component_needed) {
+      entropy->dc_needed[blkn] = TRUE;
+      /* we don't need the ACs if producing a 1/8th-size image */
+      entropy->ac_needed[blkn] = (compptr->_DCT_scaled_size > 1);
+    } else {
+      entropy->dc_needed[blkn] = entropy->ac_needed[blkn] = FALSE;
+    }
+  }
+
+  /* Initialize bitread state variables */
+  entropy->bitstate.bits_left = 0;
+  entropy->bitstate.get_buffer = 0; /* unnecessary, but keeps Purify quiet */
+  entropy->pub.insufficient_data = FALSE;
+
+  /* Initialize restart counter */
+  entropy->restarts_to_go = cinfo->restart_interval;
+}
+
+
+/*
+ * Compute the derived values for a Huffman table.
+ * This routine also performs some validation checks on the table.
+ *
+ * Note this is also used by jdphuff.c.
+ */
+
+GLOBAL(void)
+jpeg_make_d_derived_tbl(j_decompress_ptr cinfo, boolean isDC, int tblno,
+                        d_derived_tbl **pdtbl)
+{
+  JHUFF_TBL *htbl;
+  d_derived_tbl *dtbl;
+  int p, i, l, si, numsymbols;
+  int lookbits, ctr;
+  char huffsize[257];
+  unsigned int huffcode[257];
+  unsigned int code;
+
+  /* Note that huffsize[] and huffcode[] are filled in code-length order,
+   * paralleling the order of the symbols themselves in htbl->huffval[].
+   */
+
+  /* Find the input Huffman table */
+  if (tblno < 0 || tblno >= NUM_HUFF_TBLS)
+    ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, tblno);
+  htbl =
+    isDC ? cinfo->dc_huff_tbl_ptrs[tblno] : cinfo->ac_huff_tbl_ptrs[tblno];
+  if (htbl == NULL)
+    ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, tblno);
+
+  /* Allocate a workspace if we haven't already done so. */
+  if (*pdtbl == NULL)
+    *pdtbl = (d_derived_tbl *)
+      (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+                                  sizeof(d_derived_tbl));
+  dtbl = *pdtbl;
+  dtbl->pub = htbl;             /* fill in back link */
+
+  /* Figure C.1: make table of Huffman code length for each symbol */
+
+  p = 0;
+  for (l = 1; l <= 16; l++) {
+    i = (int)htbl->bits[l];
+    if (i < 0 || p + i > 256)   /* protect against table overrun */
+      ERREXIT(cinfo, JERR_BAD_HUFF_TABLE);
+    while (i--)
+      huffsize[p++] = (char)l;
+  }
+  huffsize[p] = 0;
+  numsymbols = p;
+
+  /* Figure C.2: generate the codes themselves */
+  /* We also validate that the counts represent a legal Huffman code tree. */
+
+  code = 0;
+  si = huffsize[0];
+  p = 0;
+  while (huffsize[p]) {
+    while (((int)huffsize[p]) == si) {
+      huffcode[p++] = code;
+      code++;
+    }
+    /* code is now 1 more than the last code used for codelength si; but
+     * it must still fit in si bits, since no code is allowed to be all ones.
+     */
+    if (((JLONG)code) >= (((JLONG)1) << si))
+      ERREXIT(cinfo, JERR_BAD_HUFF_TABLE);
+    code <<= 1;
+    si++;
+  }
+
+  /* Figure F.15: generate decoding tables for bit-sequential decoding */
+
+  p = 0;
+  for (l = 1; l <= 16; l++) {
+    if (htbl->bits[l]) {
+      /* valoffset[l] = huffval[] index of 1st symbol of code length l,
+       * minus the minimum code of length l
+       */
+      dtbl->valoffset[l] = (JLONG)p - (JLONG)huffcode[p];
+      p += htbl->bits[l];
+      dtbl->maxcode[l] = huffcode[p - 1]; /* maximum code of length l */
+    } else {
+      dtbl->maxcode[l] = -1;    /* -1 if no codes of this length */
+    }
+  }
+  dtbl->valoffset[17] = 0;
+  dtbl->maxcode[17] = 0xFFFFFL; /* ensures jpeg_huff_decode terminates */
+
+  /* Compute lookahead tables to speed up decoding.
+   * First we set all the table entries to 0, indicating "too long";
+   * then we iterate through the Huffman codes that are short enough and
+   * fill in all the entries that correspond to bit sequences starting
+   * with that code.
+   */
+
+  for (i = 0; i < (1 << HUFF_LOOKAHEAD); i++)
+    dtbl->lookup[i] = (HUFF_LOOKAHEAD + 1) << HUFF_LOOKAHEAD;
+
+  p = 0;
+  for (l = 1; l <= HUFF_LOOKAHEAD; l++) {
+    for (i = 1; i <= (int)htbl->bits[l]; i++, p++) {
+      /* l = current code's length, p = its index in huffcode[] & huffval[]. */
+      /* Generate left-justified code followed by all possible bit sequences */
+      lookbits = huffcode[p] << (HUFF_LOOKAHEAD - l);
+      for (ctr = 1 << (HUFF_LOOKAHEAD - l); ctr > 0; ctr--) {
+        dtbl->lookup[lookbits] = (l << HUFF_LOOKAHEAD) | htbl->huffval[p];
+        lookbits++;
+      }
+    }
+  }
+
+  /* Validate symbols as being reasonable.
+   * For AC tables, we make no check, but accept all byte values 0..255.
+   * For DC tables, we require the symbols to be in range 0..15.
+   * (Tighter bounds could be applied depending on the data depth and mode,
+   * but this is sufficient to ensure safe decoding.)
+   */
+  if (isDC) {
+    for (i = 0; i < numsymbols; i++) {
+      int sym = htbl->huffval[i];
+      if (sym < 0 || sym > 15)
+        ERREXIT(cinfo, JERR_BAD_HUFF_TABLE);
+    }
+  }
+}
+
+
+/*
+ * Out-of-line code for bit fetching (shared with jdphuff.c).
+ * See jdhuff.h for info about usage.
+ * Note: current values of get_buffer and bits_left are passed as parameters,
+ * but are returned in the corresponding fields of the state struct.
+ *
+ * On most machines MIN_GET_BITS should be 25 to allow the full 32-bit width
+ * of get_buffer to be used.  (On machines with wider words, an even larger
+ * buffer could be used.)  However, on some machines 32-bit shifts are
+ * quite slow and take time proportional to the number of places shifted.
+ * (This is true with most PC compilers, for instance.)  In this case it may
+ * be a win to set MIN_GET_BITS to the minimum value of 15.  This reduces the
+ * average shift distance at the cost of more calls to jpeg_fill_bit_buffer.
+ */
+
+#ifdef SLOW_SHIFT_32
+#define MIN_GET_BITS  15        /* minimum allowable value */
+#else
+#define MIN_GET_BITS  (BIT_BUF_SIZE - 7)
+#endif
+
+
+GLOBAL(boolean)
+jpeg_fill_bit_buffer(bitread_working_state *state,
+                     register bit_buf_type get_buffer, register int bits_left,
+                     int nbits)
+/* Load up the bit buffer to a depth of at least nbits */
+{
+  /* Copy heavily used state fields into locals (hopefully registers) */
+  register const JOCTET *next_input_byte = state->next_input_byte;
+  register size_t bytes_in_buffer = state->bytes_in_buffer;
+  j_decompress_ptr cinfo = state->cinfo;
+
+  /* Attempt to load at least MIN_GET_BITS bits into get_buffer. */
+  /* (It is assumed that no request will be for more than that many bits.) */
+  /* We fail to do so only if we hit a marker or are forced to suspend. */
+
+  if (cinfo->unread_marker == 0) {      /* cannot advance past a marker */
+    while (bits_left < MIN_GET_BITS) {
+      register int c;
+
+      /* Attempt to read a byte */
+      if (bytes_in_buffer == 0) {
+        if (!(*cinfo->src->fill_input_buffer) (cinfo))
+          return FALSE;
+        next_input_byte = cinfo->src->next_input_byte;
+        bytes_in_buffer = cinfo->src->bytes_in_buffer;
+      }
+      bytes_in_buffer--;
+      c = *next_input_byte++;
+
+      /* If it's 0xFF, check and discard stuffed zero byte */
+      if (c == 0xFF) {
+        /* Loop here to discard any padding FF's on terminating marker,
+         * so that we can save a valid unread_marker value.  NOTE: we will
+         * accept multiple FF's followed by a 0 as meaning a single FF data
+         * byte.  This data pattern is not valid according to the standard.
+         */
+        do {
+          if (bytes_in_buffer == 0) {
+            if (!(*cinfo->src->fill_input_buffer) (cinfo))
+              return FALSE;
+            next_input_byte = cinfo->src->next_input_byte;
+            bytes_in_buffer = cinfo->src->bytes_in_buffer;
+          }
+          bytes_in_buffer--;
+          c = *next_input_byte++;
+        } while (c == 0xFF);
+
+        if (c == 0) {
+          /* Found FF/00, which represents an FF data byte */
+          c = 0xFF;
+        } else {
+          /* Oops, it's actually a marker indicating end of compressed data.
+           * Save the marker code for later use.
+           * Fine point: it might appear that we should save the marker into
+           * bitread working state, not straight into permanent state.  But
+           * once we have hit a marker, we cannot need to suspend within the
+           * current MCU, because we will read no more bytes from the data
+           * source.  So it is OK to update permanent state right away.
+           */
+          cinfo->unread_marker = c;
+          /* See if we need to insert some fake zero bits. */
+          goto no_more_bytes;
+        }
+      }
+
+      /* OK, load c into get_buffer */
+      get_buffer = (get_buffer << 8) | c;
+      bits_left += 8;
+    } /* end while */
+  } else {
+no_more_bytes:
+    /* We get here if we've read the marker that terminates the compressed
+     * data segment.  There should be enough bits in the buffer register
+     * to satisfy the request; if so, no problem.
+     */
+    if (nbits > bits_left) {
+      /* Uh-oh.  Report corrupted data to user and stuff zeroes into
+       * the data stream, so that we can produce some kind of image.
+       * We use a nonvolatile flag to ensure that only one warning message
+       * appears per data segment.
+       */
+      if (!cinfo->entropy->insufficient_data) {
+        WARNMS(cinfo, JWRN_HIT_MARKER);
+        cinfo->entropy->insufficient_data = TRUE;
+      }
+      /* Fill the buffer with zero bits */
+      get_buffer <<= MIN_GET_BITS - bits_left;
+      bits_left = MIN_GET_BITS;
+    }
+  }
+
+  /* Unload the local registers */
+  state->next_input_byte = next_input_byte;
+  state->bytes_in_buffer = bytes_in_buffer;
+  state->get_buffer = get_buffer;
+  state->bits_left = bits_left;
+
+  return TRUE;
+}
+
+
+/* Macro version of the above, which performs much better but does not
+   handle markers.  We have to hand off any blocks with markers to the
+   slower routines. */
+
+#define GET_BYTE { \
+  register int c0, c1; \
+  c0 = *buffer++; \
+  c1 = *buffer; \
+  /* Pre-execute most common case */ \
+  get_buffer = (get_buffer << 8) | c0; \
+  bits_left += 8; \
+  if (c0 == 0xFF) { \
+    /* Pre-execute case of FF/00, which represents an FF data byte */ \
+    buffer++; \
+    if (c1 != 0) { \
+      /* Oops, it's actually a marker indicating end of compressed data. */ \
+      cinfo->unread_marker = c1; \
+      /* Back out pre-execution and fill the buffer with zero bits */ \
+      buffer -= 2; \
+      get_buffer &= ~0xFF; \
+    } \
+  } \
+}
+
+#if SIZEOF_SIZE_T == 8 || defined(_WIN64) || (defined(__x86_64__) && defined(__ILP32__))
+
+/* Pre-fetch 48 bytes, because the holding register is 64-bit */
+#define FILL_BIT_BUFFER_FAST \
+  if (bits_left <= 16) { \
+    GET_BYTE GET_BYTE GET_BYTE GET_BYTE GET_BYTE GET_BYTE \
+  }
+
+#else
+
+/* Pre-fetch 16 bytes, because the holding register is 32-bit */
+#define FILL_BIT_BUFFER_FAST \
+  if (bits_left <= 16) { \
+    GET_BYTE GET_BYTE \
+  }
+
+#endif
+
+
+/*
+ * Out-of-line code for Huffman code decoding.
+ * See jdhuff.h for info about usage.
+ */
+
+GLOBAL(int)
+jpeg_huff_decode(bitread_working_state *state,
+                 register bit_buf_type get_buffer, register int bits_left,
+                 d_derived_tbl *htbl, int min_bits)
+{
+  register int l = min_bits;
+  register JLONG code;
+
+  /* HUFF_DECODE has determined that the code is at least min_bits */
+  /* bits long, so fetch that many bits in one swoop. */
+
+  CHECK_BIT_BUFFER(*state, l, return -1);
+  code = GET_BITS(l);
+
+  /* Collect the rest of the Huffman code one bit at a time. */
+  /* This is per Figure F.16. */
+
+  while (code > htbl->maxcode[l]) {
+    code <<= 1;
+    CHECK_BIT_BUFFER(*state, 1, return -1);
+    code |= GET_BITS(1);
+    l++;
+  }
+
+  /* Unload the local registers */
+  state->get_buffer = get_buffer;
+  state->bits_left = bits_left;
+
+  /* With garbage input we may reach the sentinel value l = 17. */
+
+  if (l > 16) {
+    WARNMS(state->cinfo, JWRN_HUFF_BAD_CODE);
+    return 0;                   /* fake a zero as the safest result */
+  }
+
+  return htbl->pub->huffval[(int)(code + htbl->valoffset[l])];
+}
+
+
+/*
+ * Figure F.12: extend sign bit.
+ * On some machines, a shift and add will be faster than a table lookup.
+ */
+
+#define AVOID_TABLES
+#ifdef AVOID_TABLES
+
+#define NEG_1  ((unsigned int)-1)
+#define HUFF_EXTEND(x, s) \
+  ((x) + ((((x) - (1 << ((s) - 1))) >> 31) & (((NEG_1) << (s)) + 1)))
+
+#else
+
+#define HUFF_EXTEND(x, s) \
+  ((x) < extend_test[s] ? (x) + extend_offset[s] : (x))
+
+static const int extend_test[16] = {   /* entry n is 2**(n-1) */
+  0, 0x0001, 0x0002, 0x0004, 0x0008, 0x0010, 0x0020, 0x0040, 0x0080,
+  0x0100, 0x0200, 0x0400, 0x0800, 0x1000, 0x2000, 0x4000
+};
+
+static const int extend_offset[16] = { /* entry n is (-1 << n) + 1 */
+  0, ((-1) << 1) + 1, ((-1) << 2) + 1, ((-1) << 3) + 1, ((-1) << 4) + 1,
+  ((-1) << 5) + 1, ((-1) << 6) + 1, ((-1) << 7) + 1, ((-1) << 8) + 1,
+  ((-1) << 9) + 1, ((-1) << 10) + 1, ((-1) << 11) + 1, ((-1) << 12) + 1,
+  ((-1) << 13) + 1, ((-1) << 14) + 1, ((-1) << 15) + 1
+};
+
+#endif /* AVOID_TABLES */
+
+
+/*
+ * Check for a restart marker & resynchronize decoder.
+ * Returns FALSE if must suspend.
+ */
+
+LOCAL(boolean)
+process_restart(j_decompress_ptr cinfo)
+{
+  huff_entropy_ptr entropy = (huff_entropy_ptr)cinfo->entropy;
+  int ci;
+
+  /* Throw away any unused bits remaining in bit buffer; */
+  /* include any full bytes in next_marker's count of discarded bytes */
+  cinfo->marker->discarded_bytes += entropy->bitstate.bits_left / 8;
+  entropy->bitstate.bits_left = 0;
+
+  /* Advance past the RSTn marker */
+  if (!(*cinfo->marker->read_restart_marker) (cinfo))
+    return FALSE;
+
+  /* Re-initialize DC predictions to 0 */
+  for (ci = 0; ci < cinfo->comps_in_scan; ci++)
+    entropy->saved.last_dc_val[ci] = 0;
+
+  /* Reset restart counter */
+  entropy->restarts_to_go = cinfo->restart_interval;
+
+  /* Reset out-of-data flag, unless read_restart_marker left us smack up
+   * against a marker.  In that case we will end up treating the next data
+   * segment as empty, and we can avoid producing bogus output pixels by
+   * leaving the flag set.
+   */
+  if (cinfo->unread_marker == 0)
+    entropy->pub.insufficient_data = FALSE;
+
+  return TRUE;
+}
+
+
+LOCAL(boolean)
+decode_mcu_slow(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
+{
+  huff_entropy_ptr entropy = (huff_entropy_ptr)cinfo->entropy;
+  BITREAD_STATE_VARS;
+  int blkn;
+  savable_state state;
+  /* Outer loop handles each block in the MCU */
+
+  /* Load up working state */
+  BITREAD_LOAD_STATE(cinfo, entropy->bitstate);
+  state = entropy->saved;
+
+  for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
+    JBLOCKROW block = MCU_data ? MCU_data[blkn] : NULL;
+    d_derived_tbl *dctbl = entropy->dc_cur_tbls[blkn];
+    d_derived_tbl *actbl = entropy->ac_cur_tbls[blkn];
+    register int s, k, r;
+
+    /* Decode a single block's worth of coefficients */
+
+    /* Section F.2.2.1: decode the DC coefficient difference */
+    HUFF_DECODE(s, br_state, dctbl, return FALSE, label1);
+    if (s) {
+      CHECK_BIT_BUFFER(br_state, s, return FALSE);
+      r = GET_BITS(s);
+      s = HUFF_EXTEND(r, s);
+    }
+
+    if (entropy->dc_needed[blkn]) {
+      /* Convert DC difference to actual value, update last_dc_val */
+      int ci = cinfo->MCU_membership[blkn];
+      /* This is really just
+       *   s += state.last_dc_val[ci];
+       * It is written this way in order to shut up UBSan.
+       */
+      s = (int)((unsigned int)s + (unsigned int)state.last_dc_val[ci]);
+      state.last_dc_val[ci] = s;
+      if (block) {
+        /* Output the DC coefficient (assumes jpeg_natural_order[0] = 0) */
+        (*block)[0] = (JCOEF)s;
+      }
+    }
+
+    if (entropy->ac_needed[blkn] && block) {
+
+      /* Section F.2.2.2: decode the AC coefficients */
+      /* Since zeroes are skipped, output area must be cleared beforehand */
+      for (k = 1; k < DCTSIZE2; k++) {
+        HUFF_DECODE(s, br_state, actbl, return FALSE, label2);
+
+        r = s >> 4;
+        s &= 15;
+
+        if (s) {
+          k += r;
+          CHECK_BIT_BUFFER(br_state, s, return FALSE);
+          r = GET_BITS(s);
+          s = HUFF_EXTEND(r, s);
+          /* Output coefficient in natural (dezigzagged) order.
+           * Note: the extra entries in jpeg_natural_order[] will save us
+           * if k >= DCTSIZE2, which could happen if the data is corrupted.
+           */
+          (*block)[jpeg_natural_order[k]] = (JCOEF)s;
+        } else {
+          if (r != 15)
+            break;
+          k += 15;
+        }
+      }
+
+    } else {
+
+      /* Section F.2.2.2: decode the AC coefficients */
+      /* In this path we just discard the values */
+      for (k = 1; k < DCTSIZE2; k++) {
+        HUFF_DECODE(s, br_state, actbl, return FALSE, label3);
+
+        r = s >> 4;
+        s &= 15;
+
+        if (s) {
+          k += r;
+          CHECK_BIT_BUFFER(br_state, s, return FALSE);
+          DROP_BITS(s);
+        } else {
+          if (r != 15)
+            break;
+          k += 15;
+        }
+      }
+    }
+  }
+
+  /* Completed MCU, so update state */
+  BITREAD_SAVE_STATE(cinfo, entropy->bitstate);
+  entropy->saved = state;
+  return TRUE;
+}
+
+
+LOCAL(boolean)
+decode_mcu_fast(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
+{
+  huff_entropy_ptr entropy = (huff_entropy_ptr)cinfo->entropy;
+  BITREAD_STATE_VARS;
+  JOCTET *buffer;
+  int blkn;
+  savable_state state;
+  /* Outer loop handles each block in the MCU */
+
+  /* Load up working state */
+  BITREAD_LOAD_STATE(cinfo, entropy->bitstate);
+  buffer = (JOCTET *)br_state.next_input_byte;
+  state = entropy->saved;
+
+  for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
+    JBLOCKROW block = MCU_data ? MCU_data[blkn] : NULL;
+    d_derived_tbl *dctbl = entropy->dc_cur_tbls[blkn];
+    d_derived_tbl *actbl = entropy->ac_cur_tbls[blkn];
+    register int s, k, r, l;
+
+    HUFF_DECODE_FAST(s, l, dctbl);
+    if (s) {
+      FILL_BIT_BUFFER_FAST
+      r = GET_BITS(s);
+      s = HUFF_EXTEND(r, s);
+    }
+
+    if (entropy->dc_needed[blkn]) {
+      int ci = cinfo->MCU_membership[blkn];
+      s = (int)((unsigned int)s + (unsigned int)state.last_dc_val[ci]);
+      state.last_dc_val[ci] = s;
+      if (block)
+        (*block)[0] = (JCOEF)s;
+    }
+
+    if (entropy->ac_needed[blkn] && block) {
+
+      for (k = 1; k < DCTSIZE2; k++) {
+        HUFF_DECODE_FAST(s, l, actbl);
+        r = s >> 4;
+        s &= 15;
+
+        if (s) {
+          k += r;
+          FILL_BIT_BUFFER_FAST
+          r = GET_BITS(s);
+          s = HUFF_EXTEND(r, s);
+          (*block)[jpeg_natural_order[k]] = (JCOEF)s;
+        } else {
+          if (r != 15) break;
+          k += 15;
+        }
+      }
+
+    } else {
+
+      for (k = 1; k < DCTSIZE2; k++) {
+        HUFF_DECODE_FAST(s, l, actbl);
+        r = s >> 4;
+        s &= 15;
+
+        if (s) {
+          k += r;
+          FILL_BIT_BUFFER_FAST
+          DROP_BITS(s);
+        } else {
+          if (r != 15) break;
+          k += 15;
+        }
+      }
+    }
+  }
+
+  if (cinfo->unread_marker != 0) {
+    cinfo->unread_marker = 0;
+    return FALSE;
+  }
+
+  br_state.bytes_in_buffer -= (buffer - br_state.next_input_byte);
+  br_state.next_input_byte = buffer;
+  BITREAD_SAVE_STATE(cinfo, entropy->bitstate);
+  entropy->saved = state;
+  return TRUE;
+}
+
+
+/*
+ * Decode and return one MCU's worth of Huffman-compressed coefficients.
+ * The coefficients are reordered from zigzag order into natural array order,
+ * but are not dequantized.
+ *
+ * The i'th block of the MCU is stored into the block pointed to by
+ * MCU_data[i].  WE ASSUME THIS AREA HAS BEEN ZEROED BY THE CALLER.
+ * (Wholesale zeroing is usually a little faster than retail...)
+ *
+ * Returns FALSE if data source requested suspension.  In that case no
+ * changes have been made to permanent state.  (Exception: some output
+ * coefficients may already have been assigned.  This is harmless for
+ * this module, since we'll just re-assign them on the next call.)
+ */
+
+#define BUFSIZE  (DCTSIZE2 * 8)
+
+METHODDEF(boolean)
+decode_mcu(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
+{
+  huff_entropy_ptr entropy = (huff_entropy_ptr)cinfo->entropy;
+  int usefast = 1;
+
+  /* Process restart marker if needed; may have to suspend */
+  if (cinfo->restart_interval) {
+    if (entropy->restarts_to_go == 0)
+      if (!process_restart(cinfo))
+        return FALSE;
+    usefast = 0;
+  }
+
+  if (cinfo->src->bytes_in_buffer < BUFSIZE * (size_t)cinfo->blocks_in_MCU ||
+      cinfo->unread_marker != 0)
+    usefast = 0;
+
+  /* If we've run out of data, just leave the MCU set to zeroes.
+   * This way, we return uniform gray for the remainder of the segment.
+   */
+  if (!entropy->pub.insufficient_data) {
+
+    if (usefast) {
+      if (!decode_mcu_fast(cinfo, MCU_data)) goto use_slow;
+    } else {
+use_slow:
+      if (!decode_mcu_slow(cinfo, MCU_data)) return FALSE;
+    }
+
+  }
+
+  /* Account for restart interval (no-op if not using restarts) */
+  entropy->restarts_to_go--;
+
+  return TRUE;
+}
+
+
+/*
+ * Module initialization routine for Huffman entropy decoding.
+ */
+
+GLOBAL(void)
+jinit_huff_decoder(j_decompress_ptr cinfo)
+{
+  huff_entropy_ptr entropy;
+  int i;
+
+  /* Motion JPEG frames typically do not include the Huffman tables if they
+     are the default tables.  Thus, if the tables are not set by the time
+     the Huffman decoder is initialized (usually within the body of
+     jpeg_start_decompress()), we set them to default values. */
+  std_huff_tables((j_common_ptr)cinfo);
+
+  entropy = (huff_entropy_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+                                sizeof(huff_entropy_decoder));
+  cinfo->entropy = (struct jpeg_entropy_decoder *)entropy;
+  entropy->pub.start_pass = start_pass_huff_decoder;
+  entropy->pub.decode_mcu = decode_mcu;
+
+  /* Mark tables unallocated */
+  for (i = 0; i < NUM_HUFF_TBLS; i++) {
+    entropy->dc_derived_tbls[i] = entropy->ac_derived_tbls[i] = NULL;
+  }
+}
diff --git a/3rdparty/libjpeg/src/jdhuff.h b/3rdparty/libjpeg/src/jdhuff.h
new file mode 100644
index 00000000..ac6e0e58
--- /dev/null
+++ b/3rdparty/libjpeg/src/jdhuff.h
@@ -0,0 +1,244 @@
+/*
+ * jdhuff.h
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1991-1997, Thomas G. Lane.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2010-2011, 2015-2016, D. R. Commander.
+ * Copyright (C) 2018, Matthias Räncker.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains declarations for Huffman entropy decoding routines
+ * that are shared between the sequential decoder (jdhuff.c) and the
+ * progressive decoder (jdphuff.c).  No other modules need to see these.
+ */
+
+#include "jconfigint.h"
+
+
+/* Derived data constructed for each Huffman table */
+
+#define HUFF_LOOKAHEAD  8       /* # of bits of lookahead */
+
+typedef struct {
+  /* Basic tables: (element [0] of each array is unused) */
+  JLONG maxcode[18];            /* largest code of length k (-1 if none) */
+  /* (maxcode[17] is a sentinel to ensure jpeg_huff_decode terminates) */
+  JLONG valoffset[18];          /* huffval[] offset for codes of length k */
+  /* valoffset[k] = huffval[] index of 1st symbol of code length k, less
+   * the smallest code of length k; so given a code of length k, the
+   * corresponding symbol is huffval[code + valoffset[k]]
+   */
+
+  /* Link to public Huffman table (needed only in jpeg_huff_decode) */
+  JHUFF_TBL *pub;
+
+  /* Lookahead table: indexed by the next HUFF_LOOKAHEAD bits of
+   * the input data stream.  If the next Huffman code is no more
+   * than HUFF_LOOKAHEAD bits long, we can obtain its length and
+   * the corresponding symbol directly from this tables.
+   *
+   * The lower 8 bits of each table entry contain the number of
+   * bits in the corresponding Huffman code, or HUFF_LOOKAHEAD + 1
+   * if too long.  The next 8 bits of each entry contain the
+   * symbol.
+   */
+  int lookup[1 << HUFF_LOOKAHEAD];
+} d_derived_tbl;
+
+/* Expand a Huffman table definition into the derived format */
+EXTERN(void) jpeg_make_d_derived_tbl(j_decompress_ptr cinfo, boolean isDC,
+                                     int tblno, d_derived_tbl **pdtbl);
+
+
+/*
+ * Fetching the next N bits from the input stream is a time-critical operation
+ * for the Huffman decoders.  We implement it with a combination of inline
+ * macros and out-of-line subroutines.  Note that N (the number of bits
+ * demanded at one time) never exceeds 15 for JPEG use.
+ *
+ * We read source bytes into get_buffer and dole out bits as needed.
+ * If get_buffer already contains enough bits, they are fetched in-line
+ * by the macros CHECK_BIT_BUFFER and GET_BITS.  When there aren't enough
+ * bits, jpeg_fill_bit_buffer is called; it will attempt to fill get_buffer
+ * as full as possible (not just to the number of bits needed; this
+ * prefetching reduces the overhead cost of calling jpeg_fill_bit_buffer).
+ * Note that jpeg_fill_bit_buffer may return FALSE to indicate suspension.
+ * On TRUE return, jpeg_fill_bit_buffer guarantees that get_buffer contains
+ * at least the requested number of bits --- dummy zeroes are inserted if
+ * necessary.
+ */
+
+#if !defined(_WIN32) && !defined(SIZEOF_SIZE_T)
+#error Cannot determine word size
+#endif
+
+#if SIZEOF_SIZE_T == 8 || defined(_WIN64)
+
+typedef size_t bit_buf_type;            /* type of bit-extraction buffer */
+#define BIT_BUF_SIZE  64                /* size of buffer in bits */
+
+#elif defined(__x86_64__) && defined(__ILP32__)
+
+typedef unsigned long long bit_buf_type; /* type of bit-extraction buffer */
+#define BIT_BUF_SIZE  64                 /* size of buffer in bits */
+
+#else
+
+typedef unsigned long bit_buf_type;     /* type of bit-extraction buffer */
+#define BIT_BUF_SIZE  32                /* size of buffer in bits */
+
+#endif
+
+/* If long is > 32 bits on your machine, and shifting/masking longs is
+ * reasonably fast, making bit_buf_type be long and setting BIT_BUF_SIZE
+ * appropriately should be a win.  Unfortunately we can't define the size
+ * with something like  #define BIT_BUF_SIZE (sizeof(bit_buf_type)*8)
+ * because not all machines measure sizeof in 8-bit bytes.
+ */
+
+typedef struct {                /* Bitreading state saved across MCUs */
+  bit_buf_type get_buffer;      /* current bit-extraction buffer */
+  int bits_left;                /* # of unused bits in it */
+} bitread_perm_state;
+
+typedef struct {                /* Bitreading working state within an MCU */
+  /* Current data source location */
+  /* We need a copy, rather than munging the original, in case of suspension */
+  const JOCTET *next_input_byte; /* => next byte to read from source */
+  size_t bytes_in_buffer;       /* # of bytes remaining in source buffer */
+  /* Bit input buffer --- note these values are kept in register variables,
+   * not in this struct, inside the inner loops.
+   */
+  bit_buf_type get_buffer;      /* current bit-extraction buffer */
+  int bits_left;                /* # of unused bits in it */
+  /* Pointer needed by jpeg_fill_bit_buffer. */
+  j_decompress_ptr cinfo;       /* back link to decompress master record */
+} bitread_working_state;
+
+/* Macros to declare and load/save bitread local variables. */
+#define BITREAD_STATE_VARS \
+  register bit_buf_type get_buffer; \
+  register int bits_left; \
+  bitread_working_state br_state
+
+#define BITREAD_LOAD_STATE(cinfop, permstate) \
+  br_state.cinfo = cinfop; \
+  br_state.next_input_byte = cinfop->src->next_input_byte; \
+  br_state.bytes_in_buffer = cinfop->src->bytes_in_buffer; \
+  get_buffer = permstate.get_buffer; \
+  bits_left = permstate.bits_left;
+
+#define BITREAD_SAVE_STATE(cinfop, permstate) \
+  cinfop->src->next_input_byte = br_state.next_input_byte; \
+  cinfop->src->bytes_in_buffer = br_state.bytes_in_buffer; \
+  permstate.get_buffer = get_buffer; \
+  permstate.bits_left = bits_left
+
+/*
+ * These macros provide the in-line portion of bit fetching.
+ * Use CHECK_BIT_BUFFER to ensure there are N bits in get_buffer
+ * before using GET_BITS, PEEK_BITS, or DROP_BITS.
+ * The variables get_buffer and bits_left are assumed to be locals,
+ * but the state struct might not be (jpeg_huff_decode needs this).
+ *      CHECK_BIT_BUFFER(state, n, action);
+ *              Ensure there are N bits in get_buffer; if suspend, take action.
+ *      val = GET_BITS(n);
+ *              Fetch next N bits.
+ *      val = PEEK_BITS(n);
+ *              Fetch next N bits without removing them from the buffer.
+ *      DROP_BITS(n);
+ *              Discard next N bits.
+ * The value N should be a simple variable, not an expression, because it
+ * is evaluated multiple times.
+ */
+
+#define CHECK_BIT_BUFFER(state, nbits, action) { \
+  if (bits_left < (nbits)) { \
+    if (!jpeg_fill_bit_buffer(&(state), get_buffer, bits_left, nbits)) \
+      { action; } \
+    get_buffer = (state).get_buffer;  bits_left = (state).bits_left; \
+  } \
+}
+
+#define GET_BITS(nbits) \
+  (((int)(get_buffer >> (bits_left -= (nbits)))) & ((1 << (nbits)) - 1))
+
+#define PEEK_BITS(nbits) \
+  (((int)(get_buffer >> (bits_left -  (nbits)))) & ((1 << (nbits)) - 1))
+
+#define DROP_BITS(nbits) \
+  (bits_left -= (nbits))
+
+/* Load up the bit buffer to a depth of at least nbits */
+EXTERN(boolean) jpeg_fill_bit_buffer(bitread_working_state *state,
+                                     register bit_buf_type get_buffer,
+                                     register int bits_left, int nbits);
+
+
+/*
+ * Code for extracting next Huffman-coded symbol from input bit stream.
+ * Again, this is time-critical and we make the main paths be macros.
+ *
+ * We use a lookahead table to process codes of up to HUFF_LOOKAHEAD bits
+ * without looping.  Usually, more than 95% of the Huffman codes will be 8
+ * or fewer bits long.  The few overlength codes are handled with a loop,
+ * which need not be inline code.
+ *
+ * Notes about the HUFF_DECODE macro:
+ * 1. Near the end of the data segment, we may fail to get enough bits
+ *    for a lookahead.  In that case, we do it the hard way.
+ * 2. If the lookahead table contains no entry, the next code must be
+ *    more than HUFF_LOOKAHEAD bits long.
+ * 3. jpeg_huff_decode returns -1 if forced to suspend.
+ */
+
+#define HUFF_DECODE(result, state, htbl, failaction, slowlabel) { \
+  register int nb, look; \
+  if (bits_left < HUFF_LOOKAHEAD) { \
+    if (!jpeg_fill_bit_buffer(&state, get_buffer, bits_left, 0)) \
+      { failaction; } \
+    get_buffer = state.get_buffer;  bits_left = state.bits_left; \
+    if (bits_left < HUFF_LOOKAHEAD) { \
+      nb = 1;  goto slowlabel; \
+    } \
+  } \
+  look = PEEK_BITS(HUFF_LOOKAHEAD); \
+  if ((nb = (htbl->lookup[look] >> HUFF_LOOKAHEAD)) <= HUFF_LOOKAHEAD) { \
+    DROP_BITS(nb); \
+    result = htbl->lookup[look] & ((1 << HUFF_LOOKAHEAD) - 1); \
+  } else { \
+slowlabel: \
+    if ((result = \
+         jpeg_huff_decode(&state, get_buffer, bits_left, htbl, nb)) < 0) \
+      { failaction; } \
+    get_buffer = state.get_buffer;  bits_left = state.bits_left; \
+  } \
+}
+
+#define HUFF_DECODE_FAST(s, nb, htbl) \
+  FILL_BIT_BUFFER_FAST; \
+  s = PEEK_BITS(HUFF_LOOKAHEAD); \
+  s = htbl->lookup[s]; \
+  nb = s >> HUFF_LOOKAHEAD; \
+  /* Pre-execute the common case of nb <= HUFF_LOOKAHEAD */ \
+  DROP_BITS(nb); \
+  s = s & ((1 << HUFF_LOOKAHEAD) - 1); \
+  if (nb > HUFF_LOOKAHEAD) { \
+    /* Equivalent of jpeg_huff_decode() */ \
+    /* Don't use GET_BITS() here because we don't want to modify bits_left */ \
+    s = (get_buffer >> bits_left) & ((1 << (nb)) - 1); \
+    while (s > htbl->maxcode[nb]) { \
+      s <<= 1; \
+      s |= GET_BITS(1); \
+      nb++; \
+    } \
+    s = htbl->pub->huffval[(int)(s + htbl->valoffset[nb]) & 0xFF]; \
+  }
+
+/* Out-of-line case for Huffman code fetching */
+EXTERN(int) jpeg_huff_decode(bitread_working_state *state,
+                             register bit_buf_type get_buffer,
+                             register int bits_left, d_derived_tbl *htbl,
+                             int min_bits);
diff --git a/3rdparty/libjpeg/src/jdicc.c b/3rdparty/libjpeg/src/jdicc.c
new file mode 100644
index 00000000..a1a5b867
--- /dev/null
+++ b/3rdparty/libjpeg/src/jdicc.c
@@ -0,0 +1,171 @@
+/*
+ * jdicc.c
+ *
+ * Copyright (C) 1997-1998, Thomas G. Lane, Todd Newman.
+ * Copyright (C) 2017, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file provides code to read International Color Consortium (ICC) device
+ * profiles embedded in JFIF JPEG image files.  The ICC has defined a standard
+ * for including such data in JPEG "APP2" markers.  The code given here does
+ * not know anything about the internal structure of the ICC profile data; it
+ * just knows how to get the profile data from a JPEG file while reading it.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jerror.h"
+
+#ifndef HAVE_STDLIB_H           /* <stdlib.h> should declare malloc() */
+extern void *malloc(size_t size);
+#endif
+
+
+#define ICC_MARKER  (JPEG_APP0 + 2)     /* JPEG marker code for ICC */
+#define ICC_OVERHEAD_LEN  14            /* size of non-profile data in APP2 */
+
+
+/*
+ * Handy subroutine to test whether a saved marker is an ICC profile marker.
+ */
+
+LOCAL(boolean)
+marker_is_icc(jpeg_saved_marker_ptr marker)
+{
+  return
+    marker->marker == ICC_MARKER &&
+    marker->data_length >= ICC_OVERHEAD_LEN &&
+    /* verify the identifying string */
+    marker->data[0] == 0x49 &&
+    marker->data[1] == 0x43 &&
+    marker->data[2] == 0x43 &&
+    marker->data[3] == 0x5F &&
+    marker->data[4] == 0x50 &&
+    marker->data[5] == 0x52 &&
+    marker->data[6] == 0x4F &&
+    marker->data[7] == 0x46 &&
+    marker->data[8] == 0x49 &&
+    marker->data[9] == 0x4C &&
+    marker->data[10] == 0x45 &&
+    marker->data[11] == 0x0;
+}
+
+
+/*
+ * See if there was an ICC profile in the JPEG file being read; if so,
+ * reassemble and return the profile data.
+ *
+ * TRUE is returned if an ICC profile was found, FALSE if not.  If TRUE is
+ * returned, *icc_data_ptr is set to point to the returned data, and
+ * *icc_data_len is set to its length.
+ *
+ * IMPORTANT: the data at *icc_data_ptr is allocated with malloc() and must be
+ * freed by the caller with free() when the caller no longer needs it.
+ * (Alternatively, we could write this routine to use the IJG library's memory
+ * allocator, so that the data would be freed implicitly when
+ * jpeg_finish_decompress() is called.  But it seems likely that many
+ * applications will prefer to have the data stick around after decompression
+ * finishes.)
+ */
+
+GLOBAL(boolean)
+jpeg_read_icc_profile(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 */
+
+  if (icc_data_ptr == NULL || icc_data_len == NULL)
+    ERREXIT(cinfo, JERR_BUFFER_SIZE);
+  if (cinfo->global_state < DSTATE_READY)
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+
+  *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 (marker_is_icc(marker)) {
+      if (num_markers == 0)
+        num_markers = marker->data[13];
+      else if (num_markers != marker->data[13]) {
+        WARNMS(cinfo, JWRN_BOGUS_ICC);  /* inconsistent num_markers fields */
+        return FALSE;
+      }
+      seq_no = marker->data[12];
+      if (seq_no <= 0 || seq_no > num_markers) {
+        WARNMS(cinfo, JWRN_BOGUS_ICC);  /* bogus sequence number */
+        return FALSE;
+      }
+      if (marker_present[seq_no]) {
+        WARNMS(cinfo, JWRN_BOGUS_ICC);  /* duplicate sequence numbers */
+        return FALSE;
+      }
+      marker_present[seq_no] = 1;
+      data_length[seq_no] = marker->data_length - 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) {
+      WARNMS(cinfo, JWRN_BOGUS_ICC);  /* missing sequence number */
+      return FALSE;
+    }
+    data_offset[seq_no] = total_length;
+    total_length += data_length[seq_no];
+  }
+
+  if (total_length == 0) {
+    WARNMS(cinfo, JWRN_BOGUS_ICC);  /* found only empty markers? */
+    return FALSE;
+  }
+
+  /* Allocate space for assembled data */
+  icc_data = (JOCTET *)malloc(total_length * sizeof(JOCTET));
+  if (icc_data == NULL)
+    ERREXIT1(cinfo, JERR_OUT_OF_MEMORY, 11);  /* oops, out of memory */
+
+  /* and fill it in */
+  for (marker = cinfo->marker_list; marker != NULL; marker = marker->next) {
+    if (marker_is_icc(marker)) {
+      JOCTET FAR *src_ptr;
+      JOCTET *dst_ptr;
+      unsigned int length;
+      seq_no = marker->data[12];
+      dst_ptr = icc_data + data_offset[seq_no];
+      src_ptr = marker->data + 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;
+}
diff --git a/3rdparty/libjpeg/src/jdinput.c b/3rdparty/libjpeg/src/jdinput.c
new file mode 100644
index 00000000..deec618f
--- /dev/null
+++ b/3rdparty/libjpeg/src/jdinput.c
@@ -0,0 +1,408 @@
+/*
+ * jdinput.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1991-1997, Thomas G. Lane.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2010, 2016, 2018, D. R. Commander.
+ * Copyright (C) 2015, Google, Inc.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains input control logic for the JPEG decompressor.
+ * These routines are concerned with controlling the decompressor's input
+ * processing (marker reading and coefficient decoding).  The actual input
+ * reading is done in jdmarker.c, jdhuff.c, and jdphuff.c.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jpegcomp.h"
+
+
+/* Private state */
+
+typedef struct {
+  struct jpeg_input_controller pub; /* public fields */
+
+  boolean inheaders;            /* TRUE until first SOS is reached */
+} my_input_controller;
+
+typedef my_input_controller *my_inputctl_ptr;
+
+
+/* Forward declarations */
+METHODDEF(int) consume_markers(j_decompress_ptr cinfo);
+
+
+/*
+ * Routines to calculate various quantities related to the size of the image.
+ */
+
+LOCAL(void)
+initial_setup(j_decompress_ptr cinfo)
+/* Called once, when first SOS marker is reached */
+{
+  int ci;
+  jpeg_component_info *compptr;
+
+  /* Make sure image isn't bigger than I can handle */
+  if ((long)cinfo->image_height > (long)JPEG_MAX_DIMENSION ||
+      (long)cinfo->image_width > (long)JPEG_MAX_DIMENSION)
+    ERREXIT1(cinfo, JERR_IMAGE_TOO_BIG, (unsigned int)JPEG_MAX_DIMENSION);
+
+  /* For now, precision must match compiled-in value... */
+  if (cinfo->data_precision != BITS_IN_JSAMPLE)
+    ERREXIT1(cinfo, JERR_BAD_PRECISION, cinfo->data_precision);
+
+  /* Check that number of components won't exceed internal array sizes */
+  if (cinfo->num_components > MAX_COMPONENTS)
+    ERREXIT2(cinfo, JERR_COMPONENT_COUNT, cinfo->num_components,
+             MAX_COMPONENTS);
+
+  /* Compute maximum sampling factors; check factor validity */
+  cinfo->max_h_samp_factor = 1;
+  cinfo->max_v_samp_factor = 1;
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    if (compptr->h_samp_factor <= 0 ||
+        compptr->h_samp_factor > MAX_SAMP_FACTOR ||
+        compptr->v_samp_factor <= 0 ||
+        compptr->v_samp_factor > MAX_SAMP_FACTOR)
+      ERREXIT(cinfo, JERR_BAD_SAMPLING);
+    cinfo->max_h_samp_factor = MAX(cinfo->max_h_samp_factor,
+                                   compptr->h_samp_factor);
+    cinfo->max_v_samp_factor = MAX(cinfo->max_v_samp_factor,
+                                   compptr->v_samp_factor);
+  }
+
+#if JPEG_LIB_VERSION >= 80
+  cinfo->block_size = DCTSIZE;
+  cinfo->natural_order = jpeg_natural_order;
+  cinfo->lim_Se = DCTSIZE2 - 1;
+#endif
+
+  /* We initialize DCT_scaled_size and min_DCT_scaled_size to DCTSIZE.
+   * In the full decompressor, this will be overridden by jdmaster.c;
+   * but in the transcoder, jdmaster.c is not used, so we must do it here.
+   */
+#if JPEG_LIB_VERSION >= 70
+  cinfo->min_DCT_h_scaled_size = cinfo->min_DCT_v_scaled_size = DCTSIZE;
+#else
+  cinfo->min_DCT_scaled_size = DCTSIZE;
+#endif
+
+  /* Compute dimensions of components */
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+#if JPEG_LIB_VERSION >= 70
+    compptr->DCT_h_scaled_size = compptr->DCT_v_scaled_size = DCTSIZE;
+#else
+    compptr->DCT_scaled_size = DCTSIZE;
+#endif
+    /* Size in DCT blocks */
+    compptr->width_in_blocks = (JDIMENSION)
+      jdiv_round_up((long)cinfo->image_width * (long)compptr->h_samp_factor,
+                    (long)(cinfo->max_h_samp_factor * DCTSIZE));
+    compptr->height_in_blocks = (JDIMENSION)
+      jdiv_round_up((long)cinfo->image_height * (long)compptr->v_samp_factor,
+                    (long)(cinfo->max_v_samp_factor * DCTSIZE));
+    /* Set the first and last MCU columns to decompress from multi-scan images.
+     * By default, decompress all of the MCU columns.
+     */
+    cinfo->master->first_MCU_col[ci] = 0;
+    cinfo->master->last_MCU_col[ci] = compptr->width_in_blocks - 1;
+    /* downsampled_width and downsampled_height will also be overridden by
+     * jdmaster.c if we are doing full decompression.  The transcoder library
+     * doesn't use these values, but the calling application might.
+     */
+    /* Size in samples */
+    compptr->downsampled_width = (JDIMENSION)
+      jdiv_round_up((long)cinfo->image_width * (long)compptr->h_samp_factor,
+                    (long)cinfo->max_h_samp_factor);
+    compptr->downsampled_height = (JDIMENSION)
+      jdiv_round_up((long)cinfo->image_height * (long)compptr->v_samp_factor,
+                    (long)cinfo->max_v_samp_factor);
+    /* Mark component needed, until color conversion says otherwise */
+    compptr->component_needed = TRUE;
+    /* Mark no quantization table yet saved for component */
+    compptr->quant_table = NULL;
+  }
+
+  /* Compute number of fully interleaved MCU rows. */
+  cinfo->total_iMCU_rows = (JDIMENSION)
+    jdiv_round_up((long)cinfo->image_height,
+                  (long)(cinfo->max_v_samp_factor * DCTSIZE));
+
+  /* Decide whether file contains multiple scans */
+  if (cinfo->comps_in_scan < cinfo->num_components || cinfo->progressive_mode)
+    cinfo->inputctl->has_multiple_scans = TRUE;
+  else
+    cinfo->inputctl->has_multiple_scans = FALSE;
+}
+
+
+LOCAL(void)
+per_scan_setup(j_decompress_ptr cinfo)
+/* Do computations that are needed before processing a JPEG scan */
+/* cinfo->comps_in_scan and cinfo->cur_comp_info[] were set from SOS marker */
+{
+  int ci, mcublks, tmp;
+  jpeg_component_info *compptr;
+
+  if (cinfo->comps_in_scan == 1) {
+
+    /* Noninterleaved (single-component) scan */
+    compptr = cinfo->cur_comp_info[0];
+
+    /* Overall image size in MCUs */
+    cinfo->MCUs_per_row = compptr->width_in_blocks;
+    cinfo->MCU_rows_in_scan = compptr->height_in_blocks;
+
+    /* For noninterleaved scan, always one block per MCU */
+    compptr->MCU_width = 1;
+    compptr->MCU_height = 1;
+    compptr->MCU_blocks = 1;
+    compptr->MCU_sample_width = compptr->_DCT_scaled_size;
+    compptr->last_col_width = 1;
+    /* For noninterleaved scans, it is convenient to define last_row_height
+     * as the number of block rows present in the last iMCU row.
+     */
+    tmp = (int)(compptr->height_in_blocks % compptr->v_samp_factor);
+    if (tmp == 0) tmp = compptr->v_samp_factor;
+    compptr->last_row_height = tmp;
+
+    /* Prepare array describing MCU composition */
+    cinfo->blocks_in_MCU = 1;
+    cinfo->MCU_membership[0] = 0;
+
+  } else {
+
+    /* Interleaved (multi-component) scan */
+    if (cinfo->comps_in_scan <= 0 || cinfo->comps_in_scan > MAX_COMPS_IN_SCAN)
+      ERREXIT2(cinfo, JERR_COMPONENT_COUNT, cinfo->comps_in_scan,
+               MAX_COMPS_IN_SCAN);
+
+    /* Overall image size in MCUs */
+    cinfo->MCUs_per_row = (JDIMENSION)
+      jdiv_round_up((long)cinfo->image_width,
+                    (long)(cinfo->max_h_samp_factor * DCTSIZE));
+    cinfo->MCU_rows_in_scan = (JDIMENSION)
+      jdiv_round_up((long)cinfo->image_height,
+                    (long)(cinfo->max_v_samp_factor * DCTSIZE));
+
+    cinfo->blocks_in_MCU = 0;
+
+    for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+      compptr = cinfo->cur_comp_info[ci];
+      /* Sampling factors give # of blocks of component in each MCU */
+      compptr->MCU_width = compptr->h_samp_factor;
+      compptr->MCU_height = compptr->v_samp_factor;
+      compptr->MCU_blocks = compptr->MCU_width * compptr->MCU_height;
+      compptr->MCU_sample_width = compptr->MCU_width *
+                                  compptr->_DCT_scaled_size;
+      /* Figure number of non-dummy blocks in last MCU column & row */
+      tmp = (int)(compptr->width_in_blocks % compptr->MCU_width);
+      if (tmp == 0) tmp = compptr->MCU_width;
+      compptr->last_col_width = tmp;
+      tmp = (int)(compptr->height_in_blocks % compptr->MCU_height);
+      if (tmp == 0) tmp = compptr->MCU_height;
+      compptr->last_row_height = tmp;
+      /* Prepare array describing MCU composition */
+      mcublks = compptr->MCU_blocks;
+      if (cinfo->blocks_in_MCU + mcublks > D_MAX_BLOCKS_IN_MCU)
+        ERREXIT(cinfo, JERR_BAD_MCU_SIZE);
+      while (mcublks-- > 0) {
+        cinfo->MCU_membership[cinfo->blocks_in_MCU++] = ci;
+      }
+    }
+
+  }
+}
+
+
+/*
+ * Save away a copy of the Q-table referenced by each component present
+ * in the current scan, unless already saved during a prior scan.
+ *
+ * In a multiple-scan JPEG file, the encoder could assign different components
+ * the same Q-table slot number, but change table definitions between scans
+ * so that each component uses a different Q-table.  (The IJG encoder is not
+ * currently capable of doing this, but other encoders might.)  Since we want
+ * to be able to dequantize all the components at the end of the file, this
+ * means that we have to save away the table actually used for each component.
+ * We do this by copying the table at the start of the first scan containing
+ * the component.
+ * Rec. ITU-T T.81 | ISO/IEC 10918-1 prohibits the encoder from changing the
+ * contents of a Q-table slot between scans of a component using that slot.  If
+ * the encoder does so anyway, this decoder will simply use the Q-table values
+ * that were current at the start of the first scan for the component.
+ *
+ * The decompressor output side looks only at the saved quant tables,
+ * not at the current Q-table slots.
+ */
+
+LOCAL(void)
+latch_quant_tables(j_decompress_ptr cinfo)
+{
+  int ci, qtblno;
+  jpeg_component_info *compptr;
+  JQUANT_TBL *qtbl;
+
+  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+    compptr = cinfo->cur_comp_info[ci];
+    /* No work if we already saved Q-table for this component */
+    if (compptr->quant_table != NULL)
+      continue;
+    /* Make sure specified quantization table is present */
+    qtblno = compptr->quant_tbl_no;
+    if (qtblno < 0 || qtblno >= NUM_QUANT_TBLS ||
+        cinfo->quant_tbl_ptrs[qtblno] == NULL)
+      ERREXIT1(cinfo, JERR_NO_QUANT_TABLE, qtblno);
+    /* OK, save away the quantization table */
+    qtbl = (JQUANT_TBL *)
+      (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+                                  sizeof(JQUANT_TBL));
+    MEMCOPY(qtbl, cinfo->quant_tbl_ptrs[qtblno], sizeof(JQUANT_TBL));
+    compptr->quant_table = qtbl;
+  }
+}
+
+
+/*
+ * Initialize the input modules to read a scan of compressed data.
+ * The first call to this is done by jdmaster.c after initializing
+ * the entire decompressor (during jpeg_start_decompress).
+ * Subsequent calls come from consume_markers, below.
+ */
+
+METHODDEF(void)
+start_input_pass(j_decompress_ptr cinfo)
+{
+  per_scan_setup(cinfo);
+  latch_quant_tables(cinfo);
+  (*cinfo->entropy->start_pass) (cinfo);
+  (*cinfo->coef->start_input_pass) (cinfo);
+  cinfo->inputctl->consume_input = cinfo->coef->consume_data;
+}
+
+
+/*
+ * Finish up after inputting a compressed-data scan.
+ * This is called by the coefficient controller after it's read all
+ * the expected data of the scan.
+ */
+
+METHODDEF(void)
+finish_input_pass(j_decompress_ptr cinfo)
+{
+  cinfo->inputctl->consume_input = consume_markers;
+}
+
+
+/*
+ * Read JPEG markers before, between, or after compressed-data scans.
+ * Change state as necessary when a new scan is reached.
+ * Return value is JPEG_SUSPENDED, JPEG_REACHED_SOS, or JPEG_REACHED_EOI.
+ *
+ * The consume_input method pointer points either here or to the
+ * coefficient controller's consume_data routine, depending on whether
+ * we are reading a compressed data segment or inter-segment markers.
+ */
+
+METHODDEF(int)
+consume_markers(j_decompress_ptr cinfo)
+{
+  my_inputctl_ptr inputctl = (my_inputctl_ptr)cinfo->inputctl;
+  int val;
+
+  if (inputctl->pub.eoi_reached) /* After hitting EOI, read no further */
+    return JPEG_REACHED_EOI;
+
+  val = (*cinfo->marker->read_markers) (cinfo);
+
+  switch (val) {
+  case JPEG_REACHED_SOS:        /* Found SOS */
+    if (inputctl->inheaders) {  /* 1st SOS */
+      initial_setup(cinfo);
+      inputctl->inheaders = FALSE;
+      /* Note: start_input_pass must be called by jdmaster.c
+       * before any more input can be consumed.  jdapimin.c is
+       * responsible for enforcing this sequencing.
+       */
+    } else {                    /* 2nd or later SOS marker */
+      if (!inputctl->pub.has_multiple_scans)
+        ERREXIT(cinfo, JERR_EOI_EXPECTED); /* Oops, I wasn't expecting this! */
+      start_input_pass(cinfo);
+    }
+    break;
+  case JPEG_REACHED_EOI:        /* Found EOI */
+    inputctl->pub.eoi_reached = TRUE;
+    if (inputctl->inheaders) {  /* Tables-only datastream, apparently */
+      if (cinfo->marker->saw_SOF)
+        ERREXIT(cinfo, JERR_SOF_NO_SOS);
+    } else {
+      /* Prevent infinite loop in coef ctlr's decompress_data routine
+       * if user set output_scan_number larger than number of scans.
+       */
+      if (cinfo->output_scan_number > cinfo->input_scan_number)
+        cinfo->output_scan_number = cinfo->input_scan_number;
+    }
+    break;
+  case JPEG_SUSPENDED:
+    break;
+  }
+
+  return val;
+}
+
+
+/*
+ * Reset state to begin a fresh datastream.
+ */
+
+METHODDEF(void)
+reset_input_controller(j_decompress_ptr cinfo)
+{
+  my_inputctl_ptr inputctl = (my_inputctl_ptr)cinfo->inputctl;
+
+  inputctl->pub.consume_input = consume_markers;
+  inputctl->pub.has_multiple_scans = FALSE; /* "unknown" would be better */
+  inputctl->pub.eoi_reached = FALSE;
+  inputctl->inheaders = TRUE;
+  /* Reset other modules */
+  (*cinfo->err->reset_error_mgr) ((j_common_ptr)cinfo);
+  (*cinfo->marker->reset_marker_reader) (cinfo);
+  /* Reset progression state -- would be cleaner if entropy decoder did this */
+  cinfo->coef_bits = NULL;
+}
+
+
+/*
+ * Initialize the input controller module.
+ * This is called only once, when the decompression object is created.
+ */
+
+GLOBAL(void)
+jinit_input_controller(j_decompress_ptr cinfo)
+{
+  my_inputctl_ptr inputctl;
+
+  /* Create subobject in permanent pool */
+  inputctl = (my_inputctl_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_PERMANENT,
+                                sizeof(my_input_controller));
+  cinfo->inputctl = (struct jpeg_input_controller *)inputctl;
+  /* Initialize method pointers */
+  inputctl->pub.consume_input = consume_markers;
+  inputctl->pub.reset_input_controller = reset_input_controller;
+  inputctl->pub.start_input_pass = start_input_pass;
+  inputctl->pub.finish_input_pass = finish_input_pass;
+  /* Initialize state: can't use reset_input_controller since we don't
+   * want to try to reset other modules yet.
+   */
+  inputctl->pub.has_multiple_scans = FALSE; /* "unknown" would be better */
+  inputctl->pub.eoi_reached = FALSE;
+  inputctl->inheaders = TRUE;
+}
diff --git a/3rdparty/libjpeg/src/jdmainct.c b/3rdparty/libjpeg/src/jdmainct.c
new file mode 100644
index 00000000..50301d6b
--- /dev/null
+++ b/3rdparty/libjpeg/src/jdmainct.c
@@ -0,0 +1,460 @@
+/*
+ * jdmainct.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1994-1996, Thomas G. Lane.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2010, 2016, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains the main buffer controller for decompression.
+ * The main buffer lies between the JPEG decompressor proper and the
+ * post-processor; it holds downsampled data in the JPEG colorspace.
+ *
+ * Note that this code is bypassed in raw-data mode, since the application
+ * supplies the equivalent of the main buffer in that case.
+ */
+
+#include "jinclude.h"
+#include "jdmainct.h"
+
+
+/*
+ * In the current system design, the main buffer need never be a full-image
+ * buffer; any full-height buffers will be found inside the coefficient or
+ * postprocessing controllers.  Nonetheless, the main controller is not
+ * trivial.  Its responsibility is to provide context rows for upsampling/
+ * rescaling, and doing this in an efficient fashion is a bit tricky.
+ *
+ * Postprocessor input data is counted in "row groups".  A row group
+ * is defined to be (v_samp_factor * DCT_scaled_size / min_DCT_scaled_size)
+ * sample rows of each component.  (We require DCT_scaled_size values to be
+ * chosen such that these numbers are integers.  In practice DCT_scaled_size
+ * values will likely be powers of two, so we actually have the stronger
+ * condition that DCT_scaled_size / min_DCT_scaled_size is an integer.)
+ * Upsampling will typically produce max_v_samp_factor pixel rows from each
+ * row group (times any additional scale factor that the upsampler is
+ * applying).
+ *
+ * The coefficient controller will deliver data to us one iMCU row at a time;
+ * each iMCU row contains v_samp_factor * DCT_scaled_size sample rows, or
+ * exactly min_DCT_scaled_size row groups.  (This amount of data corresponds
+ * to one row of MCUs when the image is fully interleaved.)  Note that the
+ * number of sample rows varies across components, but the number of row
+ * groups does not.  Some garbage sample rows may be included in the last iMCU
+ * row at the bottom of the image.
+ *
+ * Depending on the vertical scaling algorithm used, the upsampler may need
+ * access to the sample row(s) above and below its current input row group.
+ * The upsampler is required to set need_context_rows TRUE at global selection
+ * time if so.  When need_context_rows is FALSE, this controller can simply
+ * obtain one iMCU row at a time from the coefficient controller and dole it
+ * out as row groups to the postprocessor.
+ *
+ * When need_context_rows is TRUE, this controller guarantees that the buffer
+ * passed to postprocessing contains at least one row group's worth of samples
+ * above and below the row group(s) being processed.  Note that the context
+ * rows "above" the first passed row group appear at negative row offsets in
+ * the passed buffer.  At the top and bottom of the image, the required
+ * context rows are manufactured by duplicating the first or last real sample
+ * row; this avoids having special cases in the upsampling inner loops.
+ *
+ * The amount of context is fixed at one row group just because that's a
+ * convenient number for this controller to work with.  The existing
+ * upsamplers really only need one sample row of context.  An upsampler
+ * supporting arbitrary output rescaling might wish for more than one row
+ * group of context when shrinking the image; tough, we don't handle that.
+ * (This is justified by the assumption that downsizing will be handled mostly
+ * by adjusting the DCT_scaled_size values, so that the actual scale factor at
+ * the upsample step needn't be much less than one.)
+ *
+ * To provide the desired context, we have to retain the last two row groups
+ * of one iMCU row while reading in the next iMCU row.  (The last row group
+ * can't be processed until we have another row group for its below-context,
+ * and so we have to save the next-to-last group too for its above-context.)
+ * We could do this most simply by copying data around in our buffer, but
+ * that'd be very slow.  We can avoid copying any data by creating a rather
+ * strange pointer structure.  Here's how it works.  We allocate a workspace
+ * consisting of M+2 row groups (where M = min_DCT_scaled_size is the number
+ * of row groups per iMCU row).  We create two sets of redundant pointers to
+ * the workspace.  Labeling the physical row groups 0 to M+1, the synthesized
+ * pointer lists look like this:
+ *                   M+1                          M-1
+ * master pointer --> 0         master pointer --> 0
+ *                    1                            1
+ *                   ...                          ...
+ *                   M-3                          M-3
+ *                   M-2                           M
+ *                   M-1                          M+1
+ *                    M                           M-2
+ *                   M+1                          M-1
+ *                    0                            0
+ * We read alternate iMCU rows using each master pointer; thus the last two
+ * row groups of the previous iMCU row remain un-overwritten in the workspace.
+ * The pointer lists are set up so that the required context rows appear to
+ * be adjacent to the proper places when we pass the pointer lists to the
+ * upsampler.
+ *
+ * The above pictures describe the normal state of the pointer lists.
+ * At top and bottom of the image, we diddle the pointer lists to duplicate
+ * the first or last sample row as necessary (this is cheaper than copying
+ * sample rows around).
+ *
+ * This scheme breaks down if M < 2, ie, min_DCT_scaled_size is 1.  In that
+ * situation each iMCU row provides only one row group so the buffering logic
+ * must be different (eg, we must read two iMCU rows before we can emit the
+ * first row group).  For now, we simply do not support providing context
+ * rows when min_DCT_scaled_size is 1.  That combination seems unlikely to
+ * be worth providing --- if someone wants a 1/8th-size preview, they probably
+ * want it quick and dirty, so a context-free upsampler is sufficient.
+ */
+
+
+/* Forward declarations */
+METHODDEF(void) process_data_simple_main(j_decompress_ptr cinfo,
+                                         JSAMPARRAY output_buf,
+                                         JDIMENSION *out_row_ctr,
+                                         JDIMENSION out_rows_avail);
+METHODDEF(void) process_data_context_main(j_decompress_ptr cinfo,
+                                          JSAMPARRAY output_buf,
+                                          JDIMENSION *out_row_ctr,
+                                          JDIMENSION out_rows_avail);
+#ifdef QUANT_2PASS_SUPPORTED
+METHODDEF(void) process_data_crank_post(j_decompress_ptr cinfo,
+                                        JSAMPARRAY output_buf,
+                                        JDIMENSION *out_row_ctr,
+                                        JDIMENSION out_rows_avail);
+#endif
+
+
+LOCAL(void)
+alloc_funny_pointers(j_decompress_ptr cinfo)
+/* Allocate space for the funny pointer lists.
+ * This is done only once, not once per pass.
+ */
+{
+  my_main_ptr main_ptr = (my_main_ptr)cinfo->main;
+  int ci, rgroup;
+  int M = cinfo->_min_DCT_scaled_size;
+  jpeg_component_info *compptr;
+  JSAMPARRAY xbuf;
+
+  /* Get top-level space for component array pointers.
+   * We alloc both arrays with one call to save a few cycles.
+   */
+  main_ptr->xbuffer[0] = (JSAMPIMAGE)
+    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+                                cinfo->num_components * 2 * sizeof(JSAMPARRAY));
+  main_ptr->xbuffer[1] = main_ptr->xbuffer[0] + cinfo->num_components;
+
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    rgroup = (compptr->v_samp_factor * compptr->_DCT_scaled_size) /
+      cinfo->_min_DCT_scaled_size; /* height of a row group of component */
+    /* Get space for pointer lists --- M+4 row groups in each list.
+     * We alloc both pointer lists with one call to save a few cycles.
+     */
+    xbuf = (JSAMPARRAY)
+      (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+                                  2 * (rgroup * (M + 4)) * sizeof(JSAMPROW));
+    xbuf += rgroup;             /* want one row group at negative offsets */
+    main_ptr->xbuffer[0][ci] = xbuf;
+    xbuf += rgroup * (M + 4);
+    main_ptr->xbuffer[1][ci] = xbuf;
+  }
+}
+
+
+LOCAL(void)
+make_funny_pointers(j_decompress_ptr cinfo)
+/* Create the funny pointer lists discussed in the comments above.
+ * The actual workspace is already allocated (in main_ptr->buffer),
+ * and the space for the pointer lists is allocated too.
+ * This routine just fills in the curiously ordered lists.
+ * This will be repeated at the beginning of each pass.
+ */
+{
+  my_main_ptr main_ptr = (my_main_ptr)cinfo->main;
+  int ci, i, rgroup;
+  int M = cinfo->_min_DCT_scaled_size;
+  jpeg_component_info *compptr;
+  JSAMPARRAY buf, xbuf0, xbuf1;
+
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    rgroup = (compptr->v_samp_factor * compptr->_DCT_scaled_size) /
+      cinfo->_min_DCT_scaled_size; /* height of a row group of component */
+    xbuf0 = main_ptr->xbuffer[0][ci];
+    xbuf1 = main_ptr->xbuffer[1][ci];
+    /* First copy the workspace pointers as-is */
+    buf = main_ptr->buffer[ci];
+    for (i = 0; i < rgroup * (M + 2); i++) {
+      xbuf0[i] = xbuf1[i] = buf[i];
+    }
+    /* In the second list, put the last four row groups in swapped order */
+    for (i = 0; i < rgroup * 2; i++) {
+      xbuf1[rgroup * (M - 2) + i] = buf[rgroup * M + i];
+      xbuf1[rgroup * M + i] = buf[rgroup * (M - 2) + i];
+    }
+    /* The wraparound pointers at top and bottom will be filled later
+     * (see set_wraparound_pointers, below).  Initially we want the "above"
+     * pointers to duplicate the first actual data line.  This only needs
+     * to happen in xbuffer[0].
+     */
+    for (i = 0; i < rgroup; i++) {
+      xbuf0[i - rgroup] = xbuf0[0];
+    }
+  }
+}
+
+
+LOCAL(void)
+set_bottom_pointers(j_decompress_ptr cinfo)
+/* Change the pointer lists to duplicate the last sample row at the bottom
+ * of the image.  whichptr indicates which xbuffer holds the final iMCU row.
+ * Also sets rowgroups_avail to indicate number of nondummy row groups in row.
+ */
+{
+  my_main_ptr main_ptr = (my_main_ptr)cinfo->main;
+  int ci, i, rgroup, iMCUheight, rows_left;
+  jpeg_component_info *compptr;
+  JSAMPARRAY xbuf;
+
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    /* Count sample rows in one iMCU row and in one row group */
+    iMCUheight = compptr->v_samp_factor * compptr->_DCT_scaled_size;
+    rgroup = iMCUheight / cinfo->_min_DCT_scaled_size;
+    /* Count nondummy sample rows remaining for this component */
+    rows_left = (int)(compptr->downsampled_height % (JDIMENSION)iMCUheight);
+    if (rows_left == 0) rows_left = iMCUheight;
+    /* Count nondummy row groups.  Should get same answer for each component,
+     * so we need only do it once.
+     */
+    if (ci == 0) {
+      main_ptr->rowgroups_avail = (JDIMENSION)((rows_left - 1) / rgroup + 1);
+    }
+    /* Duplicate the last real sample row rgroup*2 times; this pads out the
+     * last partial rowgroup and ensures at least one full rowgroup of context.
+     */
+    xbuf = main_ptr->xbuffer[main_ptr->whichptr][ci];
+    for (i = 0; i < rgroup * 2; i++) {
+      xbuf[rows_left + i] = xbuf[rows_left - 1];
+    }
+  }
+}
+
+
+/*
+ * Initialize for a processing pass.
+ */
+
+METHODDEF(void)
+start_pass_main(j_decompress_ptr cinfo, J_BUF_MODE pass_mode)
+{
+  my_main_ptr main_ptr = (my_main_ptr)cinfo->main;
+
+  switch (pass_mode) {
+  case JBUF_PASS_THRU:
+    if (cinfo->upsample->need_context_rows) {
+      main_ptr->pub.process_data = process_data_context_main;
+      make_funny_pointers(cinfo); /* Create the xbuffer[] lists */
+      main_ptr->whichptr = 0;   /* Read first iMCU row into xbuffer[0] */
+      main_ptr->context_state = CTX_PREPARE_FOR_IMCU;
+      main_ptr->iMCU_row_ctr = 0;
+    } else {
+      /* Simple case with no context needed */
+      main_ptr->pub.process_data = process_data_simple_main;
+    }
+    main_ptr->buffer_full = FALSE;      /* Mark buffer empty */
+    main_ptr->rowgroup_ctr = 0;
+    break;
+#ifdef QUANT_2PASS_SUPPORTED
+  case JBUF_CRANK_DEST:
+    /* For last pass of 2-pass quantization, just crank the postprocessor */
+    main_ptr->pub.process_data = process_data_crank_post;
+    break;
+#endif
+  default:
+    ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+    break;
+  }
+}
+
+
+/*
+ * Process some data.
+ * This handles the simple case where no context is required.
+ */
+
+METHODDEF(void)
+process_data_simple_main(j_decompress_ptr cinfo, JSAMPARRAY output_buf,
+                         JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail)
+{
+  my_main_ptr main_ptr = (my_main_ptr)cinfo->main;
+  JDIMENSION rowgroups_avail;
+
+  /* Read input data if we haven't filled the main buffer yet */
+  if (!main_ptr->buffer_full) {
+    if (!(*cinfo->coef->decompress_data) (cinfo, main_ptr->buffer))
+      return;                   /* suspension forced, can do nothing more */
+    main_ptr->buffer_full = TRUE;       /* OK, we have an iMCU row to work with */
+  }
+
+  /* There are always min_DCT_scaled_size row groups in an iMCU row. */
+  rowgroups_avail = (JDIMENSION)cinfo->_min_DCT_scaled_size;
+  /* Note: at the bottom of the image, we may pass extra garbage row groups
+   * to the postprocessor.  The postprocessor has to check for bottom
+   * of image anyway (at row resolution), so no point in us doing it too.
+   */
+
+  /* Feed the postprocessor */
+  (*cinfo->post->post_process_data) (cinfo, main_ptr->buffer,
+                                     &main_ptr->rowgroup_ctr, rowgroups_avail,
+                                     output_buf, out_row_ctr, out_rows_avail);
+
+  /* Has postprocessor consumed all the data yet? If so, mark buffer empty */
+  if (main_ptr->rowgroup_ctr >= rowgroups_avail) {
+    main_ptr->buffer_full = FALSE;
+    main_ptr->rowgroup_ctr = 0;
+  }
+}
+
+
+/*
+ * Process some data.
+ * This handles the case where context rows must be provided.
+ */
+
+METHODDEF(void)
+process_data_context_main(j_decompress_ptr cinfo, JSAMPARRAY output_buf,
+                          JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail)
+{
+  my_main_ptr main_ptr = (my_main_ptr)cinfo->main;
+
+  /* Read input data if we haven't filled the main buffer yet */
+  if (!main_ptr->buffer_full) {
+    if (!(*cinfo->coef->decompress_data) (cinfo,
+                                          main_ptr->xbuffer[main_ptr->whichptr]))
+      return;                   /* suspension forced, can do nothing more */
+    main_ptr->buffer_full = TRUE;       /* OK, we have an iMCU row to work with */
+    main_ptr->iMCU_row_ctr++;   /* count rows received */
+  }
+
+  /* Postprocessor typically will not swallow all the input data it is handed
+   * in one call (due to filling the output buffer first).  Must be prepared
+   * to exit and restart.  This switch lets us keep track of how far we got.
+   * Note that each case falls through to the next on successful completion.
+   */
+  switch (main_ptr->context_state) {
+  case CTX_POSTPONED_ROW:
+    /* Call postprocessor using previously set pointers for postponed row */
+    (*cinfo->post->post_process_data) (cinfo,
+                                       main_ptr->xbuffer[main_ptr->whichptr],
+                                       &main_ptr->rowgroup_ctr,
+                                       main_ptr->rowgroups_avail, output_buf,
+                                       out_row_ctr, out_rows_avail);
+    if (main_ptr->rowgroup_ctr < main_ptr->rowgroups_avail)
+      return;                   /* Need to suspend */
+    main_ptr->context_state = CTX_PREPARE_FOR_IMCU;
+    if (*out_row_ctr >= out_rows_avail)
+      return;                   /* Postprocessor exactly filled output buf */
+    /*FALLTHROUGH*/
+  case CTX_PREPARE_FOR_IMCU:
+    /* Prepare to process first M-1 row groups of this iMCU row */
+    main_ptr->rowgroup_ctr = 0;
+    main_ptr->rowgroups_avail = (JDIMENSION)(cinfo->_min_DCT_scaled_size - 1);
+    /* Check for bottom of image: if so, tweak pointers to "duplicate"
+     * the last sample row, and adjust rowgroups_avail to ignore padding rows.
+     */
+    if (main_ptr->iMCU_row_ctr == cinfo->total_iMCU_rows)
+      set_bottom_pointers(cinfo);
+    main_ptr->context_state = CTX_PROCESS_IMCU;
+    /*FALLTHROUGH*/
+  case CTX_PROCESS_IMCU:
+    /* Call postprocessor using previously set pointers */
+    (*cinfo->post->post_process_data) (cinfo,
+                                       main_ptr->xbuffer[main_ptr->whichptr],
+                                       &main_ptr->rowgroup_ctr,
+                                       main_ptr->rowgroups_avail, output_buf,
+                                       out_row_ctr, out_rows_avail);
+    if (main_ptr->rowgroup_ctr < main_ptr->rowgroups_avail)
+      return;                   /* Need to suspend */
+    /* After the first iMCU, change wraparound pointers to normal state */
+    if (main_ptr->iMCU_row_ctr == 1)
+      set_wraparound_pointers(cinfo);
+    /* Prepare to load new iMCU row using other xbuffer list */
+    main_ptr->whichptr ^= 1;    /* 0=>1 or 1=>0 */
+    main_ptr->buffer_full = FALSE;
+    /* Still need to process last row group of this iMCU row, */
+    /* which is saved at index M+1 of the other xbuffer */
+    main_ptr->rowgroup_ctr = (JDIMENSION)(cinfo->_min_DCT_scaled_size + 1);
+    main_ptr->rowgroups_avail = (JDIMENSION)(cinfo->_min_DCT_scaled_size + 2);
+    main_ptr->context_state = CTX_POSTPONED_ROW;
+  }
+}
+
+
+/*
+ * Process some data.
+ * Final pass of two-pass quantization: just call the postprocessor.
+ * Source data will be the postprocessor controller's internal buffer.
+ */
+
+#ifdef QUANT_2PASS_SUPPORTED
+
+METHODDEF(void)
+process_data_crank_post(j_decompress_ptr cinfo, JSAMPARRAY output_buf,
+                        JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail)
+{
+  (*cinfo->post->post_process_data) (cinfo, (JSAMPIMAGE)NULL,
+                                     (JDIMENSION *)NULL, (JDIMENSION)0,
+                                     output_buf, out_row_ctr, out_rows_avail);
+}
+
+#endif /* QUANT_2PASS_SUPPORTED */
+
+
+/*
+ * Initialize main buffer controller.
+ */
+
+GLOBAL(void)
+jinit_d_main_controller(j_decompress_ptr cinfo, boolean need_full_buffer)
+{
+  my_main_ptr main_ptr;
+  int ci, rgroup, ngroups;
+  jpeg_component_info *compptr;
+
+  main_ptr = (my_main_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+                                sizeof(my_main_controller));
+  cinfo->main = (struct jpeg_d_main_controller *)main_ptr;
+  main_ptr->pub.start_pass = start_pass_main;
+
+  if (need_full_buffer)         /* shouldn't happen */
+    ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+
+  /* Allocate the workspace.
+   * ngroups is the number of row groups we need.
+   */
+  if (cinfo->upsample->need_context_rows) {
+    if (cinfo->_min_DCT_scaled_size < 2) /* unsupported, see comments above */
+      ERREXIT(cinfo, JERR_NOTIMPL);
+    alloc_funny_pointers(cinfo); /* Alloc space for xbuffer[] lists */
+    ngroups = cinfo->_min_DCT_scaled_size + 2;
+  } else {
+    ngroups = cinfo->_min_DCT_scaled_size;
+  }
+
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    rgroup = (compptr->v_samp_factor * compptr->_DCT_scaled_size) /
+      cinfo->_min_DCT_scaled_size; /* height of a row group of component */
+    main_ptr->buffer[ci] = (*cinfo->mem->alloc_sarray)
+                        ((j_common_ptr)cinfo, JPOOL_IMAGE,
+                         compptr->width_in_blocks * compptr->_DCT_scaled_size,
+                         (JDIMENSION)(rgroup * ngroups));
+  }
+}
diff --git a/3rdparty/libjpeg/src/jdmainct.h b/3rdparty/libjpeg/src/jdmainct.h
new file mode 100644
index 00000000..37b201ca
--- /dev/null
+++ b/3rdparty/libjpeg/src/jdmainct.h
@@ -0,0 +1,71 @@
+/*
+ * jdmainct.h
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1994-1996, Thomas G. Lane.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ */
+
+#define JPEG_INTERNALS
+#include "jpeglib.h"
+#include "jpegcomp.h"
+
+
+/* Private buffer controller object */
+
+typedef struct {
+  struct jpeg_d_main_controller pub; /* public fields */
+
+  /* Pointer to allocated workspace (M or M+2 row groups). */
+  JSAMPARRAY buffer[MAX_COMPONENTS];
+
+  boolean buffer_full;          /* Have we gotten an iMCU row from decoder? */
+  JDIMENSION rowgroup_ctr;      /* counts row groups output to postprocessor */
+
+  /* Remaining fields are only used in the context case. */
+
+  /* These are the master pointers to the funny-order pointer lists. */
+  JSAMPIMAGE xbuffer[2];        /* pointers to weird pointer lists */
+
+  int whichptr;                 /* indicates which pointer set is now in use */
+  int context_state;            /* process_data state machine status */
+  JDIMENSION rowgroups_avail;   /* row groups available to postprocessor */
+  JDIMENSION iMCU_row_ctr;      /* counts iMCU rows to detect image top/bot */
+} my_main_controller;
+
+typedef my_main_controller *my_main_ptr;
+
+
+/* context_state values: */
+#define CTX_PREPARE_FOR_IMCU    0       /* need to prepare for MCU row */
+#define CTX_PROCESS_IMCU        1       /* feeding iMCU to postprocessor */
+#define CTX_POSTPONED_ROW       2       /* feeding postponed row group */
+
+
+LOCAL(void)
+set_wraparound_pointers(j_decompress_ptr cinfo)
+/* Set up the "wraparound" pointers at top and bottom of the pointer lists.
+ * This changes the pointer list state from top-of-image to the normal state.
+ */
+{
+  my_main_ptr main_ptr = (my_main_ptr)cinfo->main;
+  int ci, i, rgroup;
+  int M = cinfo->_min_DCT_scaled_size;
+  jpeg_component_info *compptr;
+  JSAMPARRAY xbuf0, xbuf1;
+
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    rgroup = (compptr->v_samp_factor * compptr->_DCT_scaled_size) /
+      cinfo->_min_DCT_scaled_size; /* height of a row group of component */
+    xbuf0 = main_ptr->xbuffer[0][ci];
+    xbuf1 = main_ptr->xbuffer[1][ci];
+    for (i = 0; i < rgroup; i++) {
+      xbuf0[i - rgroup] = xbuf0[rgroup * (M + 1) + i];
+      xbuf1[i - rgroup] = xbuf1[rgroup * (M + 1) + i];
+      xbuf0[rgroup * (M + 2) + i] = xbuf0[i];
+      xbuf1[rgroup * (M + 2) + i] = xbuf1[i];
+    }
+  }
+}
diff --git a/3rdparty/libjpeg/src/jdmarker.c b/3rdparty/libjpeg/src/jdmarker.c
new file mode 100644
index 00000000..b964c3a1
--- /dev/null
+++ b/3rdparty/libjpeg/src/jdmarker.c
@@ -0,0 +1,1374 @@
+/*
+ * jdmarker.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1991-1998, Thomas G. Lane.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2012, 2015, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains routines to decode JPEG datastream markers.
+ * Most of the complexity arises from our desire to support input
+ * suspension: if not all of the data for a marker is available,
+ * we must exit back to the application.  On resumption, we reprocess
+ * the marker.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+typedef enum {                  /* JPEG marker codes */
+  M_SOF0  = 0xc0,
+  M_SOF1  = 0xc1,
+  M_SOF2  = 0xc2,
+  M_SOF3  = 0xc3,
+
+  M_SOF5  = 0xc5,
+  M_SOF6  = 0xc6,
+  M_SOF7  = 0xc7,
+
+  M_JPG   = 0xc8,
+  M_SOF9  = 0xc9,
+  M_SOF10 = 0xca,
+  M_SOF11 = 0xcb,
+
+  M_SOF13 = 0xcd,
+  M_SOF14 = 0xce,
+  M_SOF15 = 0xcf,
+
+  M_DHT   = 0xc4,
+
+  M_DAC   = 0xcc,
+
+  M_RST0  = 0xd0,
+  M_RST1  = 0xd1,
+  M_RST2  = 0xd2,
+  M_RST3  = 0xd3,
+  M_RST4  = 0xd4,
+  M_RST5  = 0xd5,
+  M_RST6  = 0xd6,
+  M_RST7  = 0xd7,
+
+  M_SOI   = 0xd8,
+  M_EOI   = 0xd9,
+  M_SOS   = 0xda,
+  M_DQT   = 0xdb,
+  M_DNL   = 0xdc,
+  M_DRI   = 0xdd,
+  M_DHP   = 0xde,
+  M_EXP   = 0xdf,
+
+  M_APP0  = 0xe0,
+  M_APP1  = 0xe1,
+  M_APP2  = 0xe2,
+  M_APP3  = 0xe3,
+  M_APP4  = 0xe4,
+  M_APP5  = 0xe5,
+  M_APP6  = 0xe6,
+  M_APP7  = 0xe7,
+  M_APP8  = 0xe8,
+  M_APP9  = 0xe9,
+  M_APP10 = 0xea,
+  M_APP11 = 0xeb,
+  M_APP12 = 0xec,
+  M_APP13 = 0xed,
+  M_APP14 = 0xee,
+  M_APP15 = 0xef,
+
+  M_JPG0  = 0xf0,
+  M_JPG13 = 0xfd,
+  M_COM   = 0xfe,
+
+  M_TEM   = 0x01,
+
+  M_ERROR = 0x100
+} JPEG_MARKER;
+
+
+/* Private state */
+
+typedef struct {
+  struct jpeg_marker_reader pub; /* public fields */
+
+  /* Application-overridable marker processing methods */
+  jpeg_marker_parser_method process_COM;
+  jpeg_marker_parser_method process_APPn[16];
+
+  /* Limit on marker data length to save for each marker type */
+  unsigned int length_limit_COM;
+  unsigned int length_limit_APPn[16];
+
+  /* Status of COM/APPn marker saving */
+  jpeg_saved_marker_ptr cur_marker;     /* NULL if not processing a marker */
+  unsigned int bytes_read;              /* data bytes read so far in marker */
+  /* Note: cur_marker is not linked into marker_list until it's all read. */
+} my_marker_reader;
+
+typedef my_marker_reader *my_marker_ptr;
+
+
+/*
+ * Macros for fetching data from the data source module.
+ *
+ * At all times, cinfo->src->next_input_byte and ->bytes_in_buffer reflect
+ * the current restart point; we update them only when we have reached a
+ * suitable place to restart if a suspension occurs.
+ */
+
+/* Declare and initialize local copies of input pointer/count */
+#define INPUT_VARS(cinfo) \
+  struct jpeg_source_mgr *datasrc = (cinfo)->src; \
+  const JOCTET *next_input_byte = datasrc->next_input_byte; \
+  size_t bytes_in_buffer = datasrc->bytes_in_buffer
+
+/* Unload the local copies --- do this only at a restart boundary */
+#define INPUT_SYNC(cinfo) \
+  ( datasrc->next_input_byte = next_input_byte, \
+    datasrc->bytes_in_buffer = bytes_in_buffer )
+
+/* Reload the local copies --- used only in MAKE_BYTE_AVAIL */
+#define INPUT_RELOAD(cinfo) \
+  ( next_input_byte = datasrc->next_input_byte, \
+    bytes_in_buffer = datasrc->bytes_in_buffer )
+
+/* Internal macro for INPUT_BYTE and INPUT_2BYTES: make a byte available.
+ * Note we do *not* do INPUT_SYNC before calling fill_input_buffer,
+ * but we must reload the local copies after a successful fill.
+ */
+#define MAKE_BYTE_AVAIL(cinfo, action) \
+  if (bytes_in_buffer == 0) { \
+    if (!(*datasrc->fill_input_buffer) (cinfo)) \
+      { action; } \
+    INPUT_RELOAD(cinfo); \
+  }
+
+/* Read a byte into variable V.
+ * If must suspend, take the specified action (typically "return FALSE").
+ */
+#define INPUT_BYTE(cinfo, V, action) \
+  MAKESTMT( MAKE_BYTE_AVAIL(cinfo, action); \
+            bytes_in_buffer--; \
+            V = *next_input_byte++; )
+
+/* As above, but read two bytes interpreted as an unsigned 16-bit integer.
+ * V should be declared unsigned int or perhaps JLONG.
+ */
+#define INPUT_2BYTES(cinfo, V, action) \
+  MAKESTMT( MAKE_BYTE_AVAIL(cinfo, action); \
+            bytes_in_buffer--; \
+            V = ((unsigned int)(*next_input_byte++)) << 8; \
+            MAKE_BYTE_AVAIL(cinfo, action); \
+            bytes_in_buffer--; \
+            V += *next_input_byte++; )
+
+
+/*
+ * Routines to process JPEG markers.
+ *
+ * Entry condition: JPEG marker itself has been read and its code saved
+ *   in cinfo->unread_marker; input restart point is just after the marker.
+ *
+ * Exit: if return TRUE, have read and processed any parameters, and have
+ *   updated the restart point to point after the parameters.
+ *   If return FALSE, was forced to suspend before reaching end of
+ *   marker parameters; restart point has not been moved.  Same routine
+ *   will be called again after application supplies more input data.
+ *
+ * This approach to suspension assumes that all of a marker's parameters
+ * can fit into a single input bufferload.  This should hold for "normal"
+ * markers.  Some COM/APPn markers might have large parameter segments
+ * that might not fit.  If we are simply dropping such a marker, we use
+ * skip_input_data to get past it, and thereby put the problem on the
+ * source manager's shoulders.  If we are saving the marker's contents
+ * into memory, we use a slightly different convention: when forced to
+ * suspend, the marker processor updates the restart point to the end of
+ * what it's consumed (ie, the end of the buffer) before returning FALSE.
+ * On resumption, cinfo->unread_marker still contains the marker code,
+ * but the data source will point to the next chunk of marker data.
+ * The marker processor must retain internal state to deal with this.
+ *
+ * Note that we don't bother to avoid duplicate trace messages if a
+ * suspension occurs within marker parameters.  Other side effects
+ * require more care.
+ */
+
+
+LOCAL(boolean)
+get_soi(j_decompress_ptr cinfo)
+/* Process an SOI marker */
+{
+  int i;
+
+  TRACEMS(cinfo, 1, JTRC_SOI);
+
+  if (cinfo->marker->saw_SOI)
+    ERREXIT(cinfo, JERR_SOI_DUPLICATE);
+
+  /* Reset all parameters that are defined to be reset by SOI */
+
+  for (i = 0; i < NUM_ARITH_TBLS; i++) {
+    cinfo->arith_dc_L[i] = 0;
+    cinfo->arith_dc_U[i] = 1;
+    cinfo->arith_ac_K[i] = 5;
+  }
+  cinfo->restart_interval = 0;
+
+  /* Set initial assumptions for colorspace etc */
+
+  cinfo->jpeg_color_space = JCS_UNKNOWN;
+  cinfo->CCIR601_sampling = FALSE; /* Assume non-CCIR sampling??? */
+
+  cinfo->saw_JFIF_marker = FALSE;
+  cinfo->JFIF_major_version = 1; /* set default JFIF APP0 values */
+  cinfo->JFIF_minor_version = 1;
+  cinfo->density_unit = 0;
+  cinfo->X_density = 1;
+  cinfo->Y_density = 1;
+  cinfo->saw_Adobe_marker = FALSE;
+  cinfo->Adobe_transform = 0;
+
+  cinfo->marker->saw_SOI = TRUE;
+
+  return TRUE;
+}
+
+
+LOCAL(boolean)
+get_sof(j_decompress_ptr cinfo, boolean is_prog, boolean is_arith)
+/* Process a SOFn marker */
+{
+  JLONG length;
+  int c, ci;
+  jpeg_component_info *compptr;
+  INPUT_VARS(cinfo);
+
+  cinfo->progressive_mode = is_prog;
+  cinfo->arith_code = is_arith;
+
+  INPUT_2BYTES(cinfo, length, return FALSE);
+
+  INPUT_BYTE(cinfo, cinfo->data_precision, return FALSE);
+  INPUT_2BYTES(cinfo, cinfo->image_height, return FALSE);
+  INPUT_2BYTES(cinfo, cinfo->image_width, return FALSE);
+  INPUT_BYTE(cinfo, cinfo->num_components, return FALSE);
+
+  length -= 8;
+
+  TRACEMS4(cinfo, 1, JTRC_SOF, cinfo->unread_marker,
+           (int)cinfo->image_width, (int)cinfo->image_height,
+           cinfo->num_components);
+
+  if (cinfo->marker->saw_SOF)
+    ERREXIT(cinfo, JERR_SOF_DUPLICATE);
+
+  /* We don't support files in which the image height is initially specified */
+  /* as 0 and is later redefined by DNL.  As long as we have to check that,  */
+  /* might as well have a general sanity check. */
+  if (cinfo->image_height <= 0 || cinfo->image_width <= 0 ||
+      cinfo->num_components <= 0)
+    ERREXIT(cinfo, JERR_EMPTY_IMAGE);
+
+  if (length != (cinfo->num_components * 3))
+    ERREXIT(cinfo, JERR_BAD_LENGTH);
+
+  if (cinfo->comp_info == NULL) /* do only once, even if suspend */
+    cinfo->comp_info = (jpeg_component_info *)(*cinfo->mem->alloc_small)
+                        ((j_common_ptr)cinfo, JPOOL_IMAGE,
+                         cinfo->num_components * sizeof(jpeg_component_info));
+
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    compptr->component_index = ci;
+    INPUT_BYTE(cinfo, compptr->component_id, return FALSE);
+    INPUT_BYTE(cinfo, c, return FALSE);
+    compptr->h_samp_factor = (c >> 4) & 15;
+    compptr->v_samp_factor = (c     ) & 15;
+    INPUT_BYTE(cinfo, compptr->quant_tbl_no, return FALSE);
+
+    TRACEMS4(cinfo, 1, JTRC_SOF_COMPONENT,
+             compptr->component_id, compptr->h_samp_factor,
+             compptr->v_samp_factor, compptr->quant_tbl_no);
+  }
+
+  cinfo->marker->saw_SOF = TRUE;
+
+  INPUT_SYNC(cinfo);
+  return TRUE;
+}
+
+
+LOCAL(boolean)
+get_sos(j_decompress_ptr cinfo)
+/* Process a SOS marker */
+{
+  JLONG length;
+  int i, ci, n, c, cc, pi;
+  jpeg_component_info *compptr;
+  INPUT_VARS(cinfo);
+
+  if (!cinfo->marker->saw_SOF)
+    ERREXIT(cinfo, JERR_SOS_NO_SOF);
+
+  INPUT_2BYTES(cinfo, length, return FALSE);
+
+  INPUT_BYTE(cinfo, n, return FALSE); /* Number of components */
+
+  TRACEMS1(cinfo, 1, JTRC_SOS, n);
+
+  if (length != (n * 2 + 6) || n < 1 || n > MAX_COMPS_IN_SCAN)
+    ERREXIT(cinfo, JERR_BAD_LENGTH);
+
+  cinfo->comps_in_scan = n;
+
+  /* Collect the component-spec parameters */
+
+  for (i = 0; i < MAX_COMPS_IN_SCAN; i++)
+    cinfo->cur_comp_info[i] = NULL;
+
+  for (i = 0; i < n; i++) {
+    INPUT_BYTE(cinfo, cc, return FALSE);
+    INPUT_BYTE(cinfo, c, return FALSE);
+
+    for (ci = 0, compptr = cinfo->comp_info;
+         ci < cinfo->num_components && ci < MAX_COMPS_IN_SCAN;
+         ci++, compptr++) {
+      if (cc == compptr->component_id && !cinfo->cur_comp_info[ci])
+        goto id_found;
+    }
+
+    ERREXIT1(cinfo, JERR_BAD_COMPONENT_ID, cc);
+
+id_found:
+
+    cinfo->cur_comp_info[i] = compptr;
+    compptr->dc_tbl_no = (c >> 4) & 15;
+    compptr->ac_tbl_no = (c     ) & 15;
+
+    TRACEMS3(cinfo, 1, JTRC_SOS_COMPONENT, cc,
+             compptr->dc_tbl_no, compptr->ac_tbl_no);
+
+    /* This CSi (cc) should differ from the previous CSi */
+    for (pi = 0; pi < i; pi++) {
+      if (cinfo->cur_comp_info[pi] == compptr) {
+        ERREXIT1(cinfo, JERR_BAD_COMPONENT_ID, cc);
+      }
+    }
+  }
+
+  /* Collect the additional scan parameters Ss, Se, Ah/Al. */
+  INPUT_BYTE(cinfo, c, return FALSE);
+  cinfo->Ss = c;
+  INPUT_BYTE(cinfo, c, return FALSE);
+  cinfo->Se = c;
+  INPUT_BYTE(cinfo, c, return FALSE);
+  cinfo->Ah = (c >> 4) & 15;
+  cinfo->Al = (c     ) & 15;
+
+  TRACEMS4(cinfo, 1, JTRC_SOS_PARAMS, cinfo->Ss, cinfo->Se,
+           cinfo->Ah, cinfo->Al);
+
+  /* Prepare to scan data & restart markers */
+  cinfo->marker->next_restart_num = 0;
+
+  /* Count another SOS marker */
+  cinfo->input_scan_number++;
+
+  INPUT_SYNC(cinfo);
+  return TRUE;
+}
+
+
+#ifdef D_ARITH_CODING_SUPPORTED
+
+LOCAL(boolean)
+get_dac(j_decompress_ptr cinfo)
+/* Process a DAC marker */
+{
+  JLONG length;
+  int index, val;
+  INPUT_VARS(cinfo);
+
+  INPUT_2BYTES(cinfo, length, return FALSE);
+  length -= 2;
+
+  while (length > 0) {
+    INPUT_BYTE(cinfo, index, return FALSE);
+    INPUT_BYTE(cinfo, val, return FALSE);
+
+    length -= 2;
+
+    TRACEMS2(cinfo, 1, JTRC_DAC, index, val);
+
+    if (index < 0 || index >= (2 * NUM_ARITH_TBLS))
+      ERREXIT1(cinfo, JERR_DAC_INDEX, index);
+
+    if (index >= NUM_ARITH_TBLS) { /* define AC table */
+      cinfo->arith_ac_K[index - NUM_ARITH_TBLS] = (UINT8)val;
+    } else {                    /* define DC table */
+      cinfo->arith_dc_L[index] = (UINT8)(val & 0x0F);
+      cinfo->arith_dc_U[index] = (UINT8)(val >> 4);
+      if (cinfo->arith_dc_L[index] > cinfo->arith_dc_U[index])
+        ERREXIT1(cinfo, JERR_DAC_VALUE, val);
+    }
+  }
+
+  if (length != 0)
+    ERREXIT(cinfo, JERR_BAD_LENGTH);
+
+  INPUT_SYNC(cinfo);
+  return TRUE;
+}
+
+#else /* !D_ARITH_CODING_SUPPORTED */
+
+#define get_dac(cinfo)  skip_variable(cinfo)
+
+#endif /* D_ARITH_CODING_SUPPORTED */
+
+
+LOCAL(boolean)
+get_dht(j_decompress_ptr cinfo)
+/* Process a DHT marker */
+{
+  JLONG length;
+  UINT8 bits[17];
+  UINT8 huffval[256];
+  int i, index, count;
+  JHUFF_TBL **htblptr;
+  INPUT_VARS(cinfo);
+
+  INPUT_2BYTES(cinfo, length, return FALSE);
+  length -= 2;
+
+  while (length > 16) {
+    INPUT_BYTE(cinfo, index, return FALSE);
+
+    TRACEMS1(cinfo, 1, JTRC_DHT, index);
+
+    bits[0] = 0;
+    count = 0;
+    for (i = 1; i <= 16; i++) {
+      INPUT_BYTE(cinfo, bits[i], return FALSE);
+      count += bits[i];
+    }
+
+    length -= 1 + 16;
+
+    TRACEMS8(cinfo, 2, JTRC_HUFFBITS,
+             bits[1], bits[2], bits[3], bits[4],
+             bits[5], bits[6], bits[7], bits[8]);
+    TRACEMS8(cinfo, 2, JTRC_HUFFBITS,
+             bits[9], bits[10], bits[11], bits[12],
+             bits[13], bits[14], bits[15], bits[16]);
+
+    /* Here we just do minimal validation of the counts to avoid walking
+     * off the end of our table space.  jdhuff.c will check more carefully.
+     */
+    if (count > 256 || ((JLONG)count) > length)
+      ERREXIT(cinfo, JERR_BAD_HUFF_TABLE);
+
+    for (i = 0; i < count; i++)
+      INPUT_BYTE(cinfo, huffval[i], return FALSE);
+
+    MEMZERO(&huffval[count], (256 - count) * sizeof(UINT8));
+
+    length -= count;
+
+    if (index & 0x10) {         /* AC table definition */
+      index -= 0x10;
+      if (index < 0 || index >= NUM_HUFF_TBLS)
+        ERREXIT1(cinfo, JERR_DHT_INDEX, index);
+      htblptr = &cinfo->ac_huff_tbl_ptrs[index];
+    } else {                    /* DC table definition */
+      if (index < 0 || index >= NUM_HUFF_TBLS)
+        ERREXIT1(cinfo, JERR_DHT_INDEX, index);
+      htblptr = &cinfo->dc_huff_tbl_ptrs[index];
+    }
+
+    if (*htblptr == NULL)
+      *htblptr = jpeg_alloc_huff_table((j_common_ptr)cinfo);
+
+    MEMCOPY((*htblptr)->bits, bits, sizeof((*htblptr)->bits));
+    MEMCOPY((*htblptr)->huffval, huffval, sizeof((*htblptr)->huffval));
+  }
+
+  if (length != 0)
+    ERREXIT(cinfo, JERR_BAD_LENGTH);
+
+  INPUT_SYNC(cinfo);
+  return TRUE;
+}
+
+
+LOCAL(boolean)
+get_dqt(j_decompress_ptr cinfo)
+/* Process a DQT marker */
+{
+  JLONG length;
+  int n, i, prec;
+  unsigned int tmp;
+  JQUANT_TBL *quant_ptr;
+  INPUT_VARS(cinfo);
+
+  INPUT_2BYTES(cinfo, length, return FALSE);
+  length -= 2;
+
+  while (length > 0) {
+    INPUT_BYTE(cinfo, n, return FALSE);
+    prec = n >> 4;
+    n &= 0x0F;
+
+    TRACEMS2(cinfo, 1, JTRC_DQT, n, prec);
+
+    if (n >= NUM_QUANT_TBLS)
+      ERREXIT1(cinfo, JERR_DQT_INDEX, n);
+
+    if (cinfo->quant_tbl_ptrs[n] == NULL)
+      cinfo->quant_tbl_ptrs[n] = jpeg_alloc_quant_table((j_common_ptr)cinfo);
+    quant_ptr = cinfo->quant_tbl_ptrs[n];
+
+    for (i = 0; i < DCTSIZE2; i++) {
+      if (prec)
+        INPUT_2BYTES(cinfo, tmp, return FALSE);
+      else
+        INPUT_BYTE(cinfo, tmp, return FALSE);
+      /* We convert the zigzag-order table to natural array order. */
+      quant_ptr->quantval[jpeg_natural_order[i]] = (UINT16)tmp;
+    }
+
+    if (cinfo->err->trace_level >= 2) {
+      for (i = 0; i < DCTSIZE2; i += 8) {
+        TRACEMS8(cinfo, 2, JTRC_QUANTVALS,
+                 quant_ptr->quantval[i],     quant_ptr->quantval[i + 1],
+                 quant_ptr->quantval[i + 2], quant_ptr->quantval[i + 3],
+                 quant_ptr->quantval[i + 4], quant_ptr->quantval[i + 5],
+                 quant_ptr->quantval[i + 6], quant_ptr->quantval[i + 7]);
+      }
+    }
+
+    length -= DCTSIZE2 + 1;
+    if (prec) length -= DCTSIZE2;
+  }
+
+  if (length != 0)
+    ERREXIT(cinfo, JERR_BAD_LENGTH);
+
+  INPUT_SYNC(cinfo);
+  return TRUE;
+}
+
+
+LOCAL(boolean)
+get_dri(j_decompress_ptr cinfo)
+/* Process a DRI marker */
+{
+  JLONG length;
+  unsigned int tmp;
+  INPUT_VARS(cinfo);
+
+  INPUT_2BYTES(cinfo, length, return FALSE);
+
+  if (length != 4)
+    ERREXIT(cinfo, JERR_BAD_LENGTH);
+
+  INPUT_2BYTES(cinfo, tmp, return FALSE);
+
+  TRACEMS1(cinfo, 1, JTRC_DRI, tmp);
+
+  cinfo->restart_interval = tmp;
+
+  INPUT_SYNC(cinfo);
+  return TRUE;
+}
+
+
+/*
+ * Routines for processing APPn and COM markers.
+ * These are either saved in memory or discarded, per application request.
+ * APP0 and APP14 are specially checked to see if they are
+ * JFIF and Adobe markers, respectively.
+ */
+
+#define APP0_DATA_LEN   14      /* Length of interesting data in APP0 */
+#define APP14_DATA_LEN  12      /* Length of interesting data in APP14 */
+#define APPN_DATA_LEN   14      /* Must be the largest of the above!! */
+
+
+LOCAL(void)
+examine_app0(j_decompress_ptr cinfo, JOCTET *data, unsigned int datalen,
+             JLONG remaining)
+/* Examine first few bytes from an APP0.
+ * Take appropriate action if it is a JFIF marker.
+ * datalen is # of bytes at data[], remaining is length of rest of marker data.
+ */
+{
+  JLONG totallen = (JLONG)datalen + remaining;
+
+  if (datalen >= APP0_DATA_LEN &&
+      data[0] == 0x4A &&
+      data[1] == 0x46 &&
+      data[2] == 0x49 &&
+      data[3] == 0x46 &&
+      data[4] == 0) {
+    /* Found JFIF APP0 marker: save info */
+    cinfo->saw_JFIF_marker = TRUE;
+    cinfo->JFIF_major_version = data[5];
+    cinfo->JFIF_minor_version = data[6];
+    cinfo->density_unit = data[7];
+    cinfo->X_density = (data[8] << 8) + data[9];
+    cinfo->Y_density = (data[10] << 8) + data[11];
+    /* Check version.
+     * Major version must be 1, anything else signals an incompatible change.
+     * (We used to treat this as an error, but now it's a nonfatal warning,
+     * because some bozo at Hijaak couldn't read the spec.)
+     * Minor version should be 0..2, but process anyway if newer.
+     */
+    if (cinfo->JFIF_major_version != 1)
+      WARNMS2(cinfo, JWRN_JFIF_MAJOR,
+              cinfo->JFIF_major_version, cinfo->JFIF_minor_version);
+    /* Generate trace messages */
+    TRACEMS5(cinfo, 1, JTRC_JFIF,
+             cinfo->JFIF_major_version, cinfo->JFIF_minor_version,
+             cinfo->X_density, cinfo->Y_density, cinfo->density_unit);
+    /* Validate thumbnail dimensions and issue appropriate messages */
+    if (data[12] | data[13])
+      TRACEMS2(cinfo, 1, JTRC_JFIF_THUMBNAIL, data[12], data[13]);
+    totallen -= APP0_DATA_LEN;
+    if (totallen != ((JLONG)data[12] * (JLONG)data[13] * (JLONG)3))
+      TRACEMS1(cinfo, 1, JTRC_JFIF_BADTHUMBNAILSIZE, (int)totallen);
+  } else if (datalen >= 6 &&
+             data[0] == 0x4A &&
+             data[1] == 0x46 &&
+             data[2] == 0x58 &&
+             data[3] == 0x58 &&
+             data[4] == 0) {
+    /* Found JFIF "JFXX" extension APP0 marker */
+    /* The library doesn't actually do anything with these,
+     * but we try to produce a helpful trace message.
+     */
+    switch (data[5]) {
+    case 0x10:
+      TRACEMS1(cinfo, 1, JTRC_THUMB_JPEG, (int)totallen);
+      break;
+    case 0x11:
+      TRACEMS1(cinfo, 1, JTRC_THUMB_PALETTE, (int)totallen);
+      break;
+    case 0x13:
+      TRACEMS1(cinfo, 1, JTRC_THUMB_RGB, (int)totallen);
+      break;
+    default:
+      TRACEMS2(cinfo, 1, JTRC_JFIF_EXTENSION, data[5], (int)totallen);
+      break;
+    }
+  } else {
+    /* Start of APP0 does not match "JFIF" or "JFXX", or too short */
+    TRACEMS1(cinfo, 1, JTRC_APP0, (int)totallen);
+  }
+}
+
+
+LOCAL(void)
+examine_app14(j_decompress_ptr cinfo, JOCTET *data, unsigned int datalen,
+              JLONG remaining)
+/* Examine first few bytes from an APP14.
+ * Take appropriate action if it is an Adobe marker.
+ * datalen is # of bytes at data[], remaining is length of rest of marker data.
+ */
+{
+  unsigned int version, flags0, flags1, transform;
+
+  if (datalen >= APP14_DATA_LEN &&
+      data[0] == 0x41 &&
+      data[1] == 0x64 &&
+      data[2] == 0x6F &&
+      data[3] == 0x62 &&
+      data[4] == 0x65) {
+    /* Found Adobe APP14 marker */
+    version = (data[5] << 8) + data[6];
+    flags0 = (data[7] << 8) + data[8];
+    flags1 = (data[9] << 8) + data[10];
+    transform = data[11];
+    TRACEMS4(cinfo, 1, JTRC_ADOBE, version, flags0, flags1, transform);
+    cinfo->saw_Adobe_marker = TRUE;
+    cinfo->Adobe_transform = (UINT8)transform;
+  } else {
+    /* Start of APP14 does not match "Adobe", or too short */
+    TRACEMS1(cinfo, 1, JTRC_APP14, (int)(datalen + remaining));
+  }
+}
+
+
+METHODDEF(boolean)
+get_interesting_appn(j_decompress_ptr cinfo)
+/* Process an APP0 or APP14 marker without saving it */
+{
+  JLONG length;
+  JOCTET b[APPN_DATA_LEN];
+  unsigned int i, numtoread;
+  INPUT_VARS(cinfo);
+
+  INPUT_2BYTES(cinfo, length, return FALSE);
+  length -= 2;
+
+  /* get the interesting part of the marker data */
+  if (length >= APPN_DATA_LEN)
+    numtoread = APPN_DATA_LEN;
+  else if (length > 0)
+    numtoread = (unsigned int)length;
+  else
+    numtoread = 0;
+  for (i = 0; i < numtoread; i++)
+    INPUT_BYTE(cinfo, b[i], return FALSE);
+  length -= numtoread;
+
+  /* process it */
+  switch (cinfo->unread_marker) {
+  case M_APP0:
+    examine_app0(cinfo, (JOCTET *)b, numtoread, length);
+    break;
+  case M_APP14:
+    examine_app14(cinfo, (JOCTET *)b, numtoread, length);
+    break;
+  default:
+    /* can't get here unless jpeg_save_markers chooses wrong processor */
+    ERREXIT1(cinfo, JERR_UNKNOWN_MARKER, cinfo->unread_marker);
+    break;
+  }
+
+  /* skip any remaining data -- could be lots */
+  INPUT_SYNC(cinfo);
+  if (length > 0)
+    (*cinfo->src->skip_input_data) (cinfo, (long)length);
+
+  return TRUE;
+}
+
+
+#ifdef SAVE_MARKERS_SUPPORTED
+
+METHODDEF(boolean)
+save_marker(j_decompress_ptr cinfo)
+/* Save an APPn or COM marker into the marker list */
+{
+  my_marker_ptr marker = (my_marker_ptr)cinfo->marker;
+  jpeg_saved_marker_ptr cur_marker = marker->cur_marker;
+  unsigned int bytes_read, data_length;
+  JOCTET *data;
+  JLONG length = 0;
+  INPUT_VARS(cinfo);
+
+  if (cur_marker == NULL) {
+    /* begin reading a marker */
+    INPUT_2BYTES(cinfo, length, return FALSE);
+    length -= 2;
+    if (length >= 0) {          /* watch out for bogus length word */
+      /* figure out how much we want to save */
+      unsigned int limit;
+      if (cinfo->unread_marker == (int)M_COM)
+        limit = marker->length_limit_COM;
+      else
+        limit = marker->length_limit_APPn[cinfo->unread_marker - (int)M_APP0];
+      if ((unsigned int)length < limit)
+        limit = (unsigned int)length;
+      /* allocate and initialize the marker item */
+      cur_marker = (jpeg_saved_marker_ptr)
+        (*cinfo->mem->alloc_large) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+                                    sizeof(struct jpeg_marker_struct) + limit);
+      cur_marker->next = NULL;
+      cur_marker->marker = (UINT8)cinfo->unread_marker;
+      cur_marker->original_length = (unsigned int)length;
+      cur_marker->data_length = limit;
+      /* data area is just beyond the jpeg_marker_struct */
+      data = cur_marker->data = (JOCTET *)(cur_marker + 1);
+      marker->cur_marker = cur_marker;
+      marker->bytes_read = 0;
+      bytes_read = 0;
+      data_length = limit;
+    } else {
+      /* deal with bogus length word */
+      bytes_read = data_length = 0;
+      data = NULL;
+    }
+  } else {
+    /* resume reading a marker */
+    bytes_read = marker->bytes_read;
+    data_length = cur_marker->data_length;
+    data = cur_marker->data + bytes_read;
+  }
+
+  while (bytes_read < data_length) {
+    INPUT_SYNC(cinfo);          /* move the restart point to here */
+    marker->bytes_read = bytes_read;
+    /* If there's not at least one byte in buffer, suspend */
+    MAKE_BYTE_AVAIL(cinfo, return FALSE);
+    /* Copy bytes with reasonable rapidity */
+    while (bytes_read < data_length && bytes_in_buffer > 0) {
+      *data++ = *next_input_byte++;
+      bytes_in_buffer--;
+      bytes_read++;
+    }
+  }
+
+  /* Done reading what we want to read */
+  if (cur_marker != NULL) {     /* will be NULL if bogus length word */
+    /* Add new marker to end of list */
+    if (cinfo->marker_list == NULL) {
+      cinfo->marker_list = cur_marker;
+    } else {
+      jpeg_saved_marker_ptr prev = cinfo->marker_list;
+      while (prev->next != NULL)
+        prev = prev->next;
+      prev->next = cur_marker;
+    }
+    /* Reset pointer & calc remaining data length */
+    data = cur_marker->data;
+    length = cur_marker->original_length - data_length;
+  }
+  /* Reset to initial state for next marker */
+  marker->cur_marker = NULL;
+
+  /* Process the marker if interesting; else just make a generic trace msg */
+  switch (cinfo->unread_marker) {
+  case M_APP0:
+    examine_app0(cinfo, data, data_length, length);
+    break;
+  case M_APP14:
+    examine_app14(cinfo, data, data_length, length);
+    break;
+  default:
+    TRACEMS2(cinfo, 1, JTRC_MISC_MARKER, cinfo->unread_marker,
+             (int)(data_length + length));
+    break;
+  }
+
+  /* skip any remaining data -- could be lots */
+  INPUT_SYNC(cinfo);            /* do before skip_input_data */
+  if (length > 0)
+    (*cinfo->src->skip_input_data) (cinfo, (long)length);
+
+  return TRUE;
+}
+
+#endif /* SAVE_MARKERS_SUPPORTED */
+
+
+METHODDEF(boolean)
+skip_variable(j_decompress_ptr cinfo)
+/* Skip over an unknown or uninteresting variable-length marker */
+{
+  JLONG length;
+  INPUT_VARS(cinfo);
+
+  INPUT_2BYTES(cinfo, length, return FALSE);
+  length -= 2;
+
+  TRACEMS2(cinfo, 1, JTRC_MISC_MARKER, cinfo->unread_marker, (int)length);
+
+  INPUT_SYNC(cinfo);            /* do before skip_input_data */
+  if (length > 0)
+    (*cinfo->src->skip_input_data) (cinfo, (long)length);
+
+  return TRUE;
+}
+
+
+/*
+ * Find the next JPEG marker, save it in cinfo->unread_marker.
+ * Returns FALSE if had to suspend before reaching a marker;
+ * in that case cinfo->unread_marker is unchanged.
+ *
+ * Note that the result might not be a valid marker code,
+ * but it will never be 0 or FF.
+ */
+
+LOCAL(boolean)
+next_marker(j_decompress_ptr cinfo)
+{
+  int c;
+  INPUT_VARS(cinfo);
+
+  for (;;) {
+    INPUT_BYTE(cinfo, c, return FALSE);
+    /* Skip any non-FF bytes.
+     * This may look a bit inefficient, but it will not occur in a valid file.
+     * We sync after each discarded byte so that a suspending data source
+     * can discard the byte from its buffer.
+     */
+    while (c != 0xFF) {
+      cinfo->marker->discarded_bytes++;
+      INPUT_SYNC(cinfo);
+      INPUT_BYTE(cinfo, c, return FALSE);
+    }
+    /* This loop swallows any duplicate FF bytes.  Extra FFs are legal as
+     * pad bytes, so don't count them in discarded_bytes.  We assume there
+     * will not be so many consecutive FF bytes as to overflow a suspending
+     * data source's input buffer.
+     */
+    do {
+      INPUT_BYTE(cinfo, c, return FALSE);
+    } while (c == 0xFF);
+    if (c != 0)
+      break;                    /* found a valid marker, exit loop */
+    /* Reach here if we found a stuffed-zero data sequence (FF/00).
+     * Discard it and loop back to try again.
+     */
+    cinfo->marker->discarded_bytes += 2;
+    INPUT_SYNC(cinfo);
+  }
+
+  if (cinfo->marker->discarded_bytes != 0) {
+    WARNMS2(cinfo, JWRN_EXTRANEOUS_DATA, cinfo->marker->discarded_bytes, c);
+    cinfo->marker->discarded_bytes = 0;
+  }
+
+  cinfo->unread_marker = c;
+
+  INPUT_SYNC(cinfo);
+  return TRUE;
+}
+
+
+LOCAL(boolean)
+first_marker(j_decompress_ptr cinfo)
+/* Like next_marker, but used to obtain the initial SOI marker. */
+/* For this marker, we do not allow preceding garbage or fill; otherwise,
+ * we might well scan an entire input file before realizing it ain't JPEG.
+ * If an application wants to process non-JFIF files, it must seek to the
+ * SOI before calling the JPEG library.
+ */
+{
+  int c, c2;
+  INPUT_VARS(cinfo);
+
+  INPUT_BYTE(cinfo, c, return FALSE);
+  INPUT_BYTE(cinfo, c2, return FALSE);
+  if (c != 0xFF || c2 != (int)M_SOI)
+    ERREXIT2(cinfo, JERR_NO_SOI, c, c2);
+
+  cinfo->unread_marker = c2;
+
+  INPUT_SYNC(cinfo);
+  return TRUE;
+}
+
+
+/*
+ * Read markers until SOS or EOI.
+ *
+ * Returns same codes as are defined for jpeg_consume_input:
+ * JPEG_SUSPENDED, JPEG_REACHED_SOS, or JPEG_REACHED_EOI.
+ */
+
+METHODDEF(int)
+read_markers(j_decompress_ptr cinfo)
+{
+  /* Outer loop repeats once for each marker. */
+  for (;;) {
+    /* Collect the marker proper, unless we already did. */
+    /* NB: first_marker() enforces the requirement that SOI appear first. */
+    if (cinfo->unread_marker == 0) {
+      if (!cinfo->marker->saw_SOI) {
+        if (!first_marker(cinfo))
+          return JPEG_SUSPENDED;
+      } else {
+        if (!next_marker(cinfo))
+          return JPEG_SUSPENDED;
+      }
+    }
+    /* At this point cinfo->unread_marker contains the marker code and the
+     * input point is just past the marker proper, but before any parameters.
+     * A suspension will cause us to return with this state still true.
+     */
+    switch (cinfo->unread_marker) {
+    case M_SOI:
+      if (!get_soi(cinfo))
+        return JPEG_SUSPENDED;
+      break;
+
+    case M_SOF0:                /* Baseline */
+    case M_SOF1:                /* Extended sequential, Huffman */
+      if (!get_sof(cinfo, FALSE, FALSE))
+        return JPEG_SUSPENDED;
+      break;
+
+    case M_SOF2:                /* Progressive, Huffman */
+      if (!get_sof(cinfo, TRUE, FALSE))
+        return JPEG_SUSPENDED;
+      break;
+
+    case M_SOF9:                /* Extended sequential, arithmetic */
+      if (!get_sof(cinfo, FALSE, TRUE))
+        return JPEG_SUSPENDED;
+      break;
+
+    case M_SOF10:               /* Progressive, arithmetic */
+      if (!get_sof(cinfo, TRUE, TRUE))
+        return JPEG_SUSPENDED;
+      break;
+
+    /* Currently unsupported SOFn types */
+    case M_SOF3:                /* Lossless, Huffman */
+    case M_SOF5:                /* Differential sequential, Huffman */
+    case M_SOF6:                /* Differential progressive, Huffman */
+    case M_SOF7:                /* Differential lossless, Huffman */
+    case M_JPG:                 /* Reserved for JPEG extensions */
+    case M_SOF11:               /* Lossless, arithmetic */
+    case M_SOF13:               /* Differential sequential, arithmetic */
+    case M_SOF14:               /* Differential progressive, arithmetic */
+    case M_SOF15:               /* Differential lossless, arithmetic */
+      ERREXIT1(cinfo, JERR_SOF_UNSUPPORTED, cinfo->unread_marker);
+      break;
+
+    case M_SOS:
+      if (!get_sos(cinfo))
+        return JPEG_SUSPENDED;
+      cinfo->unread_marker = 0; /* processed the marker */
+      return JPEG_REACHED_SOS;
+
+    case M_EOI:
+      TRACEMS(cinfo, 1, JTRC_EOI);
+      cinfo->unread_marker = 0; /* processed the marker */
+      return JPEG_REACHED_EOI;
+
+    case M_DAC:
+      if (!get_dac(cinfo))
+        return JPEG_SUSPENDED;
+      break;
+
+    case M_DHT:
+      if (!get_dht(cinfo))
+        return JPEG_SUSPENDED;
+      break;
+
+    case M_DQT:
+      if (!get_dqt(cinfo))
+        return JPEG_SUSPENDED;
+      break;
+
+    case M_DRI:
+      if (!get_dri(cinfo))
+        return JPEG_SUSPENDED;
+      break;
+
+    case M_APP0:
+    case M_APP1:
+    case M_APP2:
+    case M_APP3:
+    case M_APP4:
+    case M_APP5:
+    case M_APP6:
+    case M_APP7:
+    case M_APP8:
+    case M_APP9:
+    case M_APP10:
+    case M_APP11:
+    case M_APP12:
+    case M_APP13:
+    case M_APP14:
+    case M_APP15:
+      if (!(*((my_marker_ptr)cinfo->marker)->process_APPn[
+               cinfo->unread_marker - (int)M_APP0]) (cinfo))
+        return JPEG_SUSPENDED;
+      break;
+
+    case M_COM:
+      if (!(*((my_marker_ptr)cinfo->marker)->process_COM) (cinfo))
+        return JPEG_SUSPENDED;
+      break;
+
+    case M_RST0:                /* these are all parameterless */
+    case M_RST1:
+    case M_RST2:
+    case M_RST3:
+    case M_RST4:
+    case M_RST5:
+    case M_RST6:
+    case M_RST7:
+    case M_TEM:
+      TRACEMS1(cinfo, 1, JTRC_PARMLESS_MARKER, cinfo->unread_marker);
+      break;
+
+    case M_DNL:                 /* Ignore DNL ... perhaps the wrong thing */
+      if (!skip_variable(cinfo))
+        return JPEG_SUSPENDED;
+      break;
+
+    default:                    /* must be DHP, EXP, JPGn, or RESn */
+      /* For now, we treat the reserved markers as fatal errors since they are
+       * likely to be used to signal incompatible JPEG Part 3 extensions.
+       * Once the JPEG 3 version-number marker is well defined, this code
+       * ought to change!
+       */
+      ERREXIT1(cinfo, JERR_UNKNOWN_MARKER, cinfo->unread_marker);
+      break;
+    }
+    /* Successfully processed marker, so reset state variable */
+    cinfo->unread_marker = 0;
+  } /* end loop */
+}
+
+
+/*
+ * Read a restart marker, which is expected to appear next in the datastream;
+ * if the marker is not there, take appropriate recovery action.
+ * Returns FALSE if suspension is required.
+ *
+ * This is called by the entropy decoder after it has read an appropriate
+ * number of MCUs.  cinfo->unread_marker may be nonzero if the entropy decoder
+ * has already read a marker from the data source.  Under normal conditions
+ * cinfo->unread_marker will be reset to 0 before returning; if not reset,
+ * it holds a marker which the decoder will be unable to read past.
+ */
+
+METHODDEF(boolean)
+read_restart_marker(j_decompress_ptr cinfo)
+{
+  /* Obtain a marker unless we already did. */
+  /* Note that next_marker will complain if it skips any data. */
+  if (cinfo->unread_marker == 0) {
+    if (!next_marker(cinfo))
+      return FALSE;
+  }
+
+  if (cinfo->unread_marker ==
+      ((int)M_RST0 + cinfo->marker->next_restart_num)) {
+    /* Normal case --- swallow the marker and let entropy decoder continue */
+    TRACEMS1(cinfo, 3, JTRC_RST, cinfo->marker->next_restart_num);
+    cinfo->unread_marker = 0;
+  } else {
+    /* Uh-oh, the restart markers have been messed up. */
+    /* Let the data source manager determine how to resync. */
+    if (!(*cinfo->src->resync_to_restart) (cinfo,
+                                           cinfo->marker->next_restart_num))
+      return FALSE;
+  }
+
+  /* Update next-restart state */
+  cinfo->marker->next_restart_num = (cinfo->marker->next_restart_num + 1) & 7;
+
+  return TRUE;
+}
+
+
+/*
+ * This is the default resync_to_restart method for data source managers
+ * to use if they don't have any better approach.  Some data source managers
+ * may be able to back up, or may have additional knowledge about the data
+ * which permits a more intelligent recovery strategy; such managers would
+ * presumably supply their own resync method.
+ *
+ * read_restart_marker calls resync_to_restart if it finds a marker other than
+ * the restart marker it was expecting.  (This code is *not* used unless
+ * a nonzero restart interval has been declared.)  cinfo->unread_marker is
+ * the marker code actually found (might be anything, except 0 or FF).
+ * The desired restart marker number (0..7) is passed as a parameter.
+ * This routine is supposed to apply whatever error recovery strategy seems
+ * appropriate in order to position the input stream to the next data segment.
+ * Note that cinfo->unread_marker is treated as a marker appearing before
+ * the current data-source input point; usually it should be reset to zero
+ * before returning.
+ * Returns FALSE if suspension is required.
+ *
+ * This implementation is substantially constrained by wanting to treat the
+ * input as a data stream; this means we can't back up.  Therefore, we have
+ * only the following actions to work with:
+ *   1. Simply discard the marker and let the entropy decoder resume at next
+ *      byte of file.
+ *   2. Read forward until we find another marker, discarding intervening
+ *      data.  (In theory we could look ahead within the current bufferload,
+ *      without having to discard data if we don't find the desired marker.
+ *      This idea is not implemented here, in part because it makes behavior
+ *      dependent on buffer size and chance buffer-boundary positions.)
+ *   3. Leave the marker unread (by failing to zero cinfo->unread_marker).
+ *      This will cause the entropy decoder to process an empty data segment,
+ *      inserting dummy zeroes, and then we will reprocess the marker.
+ *
+ * #2 is appropriate if we think the desired marker lies ahead, while #3 is
+ * appropriate if the found marker is a future restart marker (indicating
+ * that we have missed the desired restart marker, probably because it got
+ * corrupted).
+ * We apply #2 or #3 if the found marker is a restart marker no more than
+ * two counts behind or ahead of the expected one.  We also apply #2 if the
+ * found marker is not a legal JPEG marker code (it's certainly bogus data).
+ * If the found marker is a restart marker more than 2 counts away, we do #1
+ * (too much risk that the marker is erroneous; with luck we will be able to
+ * resync at some future point).
+ * For any valid non-restart JPEG marker, we apply #3.  This keeps us from
+ * overrunning the end of a scan.  An implementation limited to single-scan
+ * files might find it better to apply #2 for markers other than EOI, since
+ * any other marker would have to be bogus data in that case.
+ */
+
+GLOBAL(boolean)
+jpeg_resync_to_restart(j_decompress_ptr cinfo, int desired)
+{
+  int marker = cinfo->unread_marker;
+  int action = 1;
+
+  /* Always put up a warning. */
+  WARNMS2(cinfo, JWRN_MUST_RESYNC, marker, desired);
+
+  /* Outer loop handles repeated decision after scanning forward. */
+  for (;;) {
+    if (marker < (int)M_SOF0)
+      action = 2;               /* invalid marker */
+    else if (marker < (int)M_RST0 || marker > (int)M_RST7)
+      action = 3;               /* valid non-restart marker */
+    else {
+      if (marker == ((int)M_RST0 + ((desired + 1) & 7)) ||
+          marker == ((int)M_RST0 + ((desired + 2) & 7)))
+        action = 3;             /* one of the next two expected restarts */
+      else if (marker == ((int)M_RST0 + ((desired - 1) & 7)) ||
+               marker == ((int)M_RST0 + ((desired - 2) & 7)))
+        action = 2;             /* a prior restart, so advance */
+      else
+        action = 1;             /* desired restart or too far away */
+    }
+    TRACEMS2(cinfo, 4, JTRC_RECOVERY_ACTION, marker, action);
+    switch (action) {
+    case 1:
+      /* Discard marker and let entropy decoder resume processing. */
+      cinfo->unread_marker = 0;
+      return TRUE;
+    case 2:
+      /* Scan to the next marker, and repeat the decision loop. */
+      if (!next_marker(cinfo))
+        return FALSE;
+      marker = cinfo->unread_marker;
+      break;
+    case 3:
+      /* Return without advancing past this marker. */
+      /* Entropy decoder will be forced to process an empty segment. */
+      return TRUE;
+    }
+  } /* end loop */
+}
+
+
+/*
+ * Reset marker processing state to begin a fresh datastream.
+ */
+
+METHODDEF(void)
+reset_marker_reader(j_decompress_ptr cinfo)
+{
+  my_marker_ptr marker = (my_marker_ptr)cinfo->marker;
+
+  cinfo->comp_info = NULL;              /* until allocated by get_sof */
+  cinfo->input_scan_number = 0;         /* no SOS seen yet */
+  cinfo->unread_marker = 0;             /* no pending marker */
+  marker->pub.saw_SOI = FALSE;          /* set internal state too */
+  marker->pub.saw_SOF = FALSE;
+  marker->pub.discarded_bytes = 0;
+  marker->cur_marker = NULL;
+}
+
+
+/*
+ * Initialize the marker reader module.
+ * This is called only once, when the decompression object is created.
+ */
+
+GLOBAL(void)
+jinit_marker_reader(j_decompress_ptr cinfo)
+{
+  my_marker_ptr marker;
+  int i;
+
+  /* Create subobject in permanent pool */
+  marker = (my_marker_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_PERMANENT,
+                                sizeof(my_marker_reader));
+  cinfo->marker = (struct jpeg_marker_reader *)marker;
+  /* Initialize public method pointers */
+  marker->pub.reset_marker_reader = reset_marker_reader;
+  marker->pub.read_markers = read_markers;
+  marker->pub.read_restart_marker = read_restart_marker;
+  /* Initialize COM/APPn processing.
+   * By default, we examine and then discard APP0 and APP14,
+   * but simply discard COM and all other APPn.
+   */
+  marker->process_COM = skip_variable;
+  marker->length_limit_COM = 0;
+  for (i = 0; i < 16; i++) {
+    marker->process_APPn[i] = skip_variable;
+    marker->length_limit_APPn[i] = 0;
+  }
+  marker->process_APPn[0] = get_interesting_appn;
+  marker->process_APPn[14] = get_interesting_appn;
+  /* Reset marker processing state */
+  reset_marker_reader(cinfo);
+}
+
+
+/*
+ * Control saving of COM and APPn markers into marker_list.
+ */
+
+#ifdef SAVE_MARKERS_SUPPORTED
+
+GLOBAL(void)
+jpeg_save_markers(j_decompress_ptr cinfo, int marker_code,
+                  unsigned int length_limit)
+{
+  my_marker_ptr marker = (my_marker_ptr)cinfo->marker;
+  long maxlength;
+  jpeg_marker_parser_method processor;
+
+  /* Length limit mustn't be larger than what we can allocate
+   * (should only be a concern in a 16-bit environment).
+   */
+  maxlength = cinfo->mem->max_alloc_chunk - sizeof(struct jpeg_marker_struct);
+  if (((long)length_limit) > maxlength)
+    length_limit = (unsigned int)maxlength;
+
+  /* Choose processor routine to use.
+   * APP0/APP14 have special requirements.
+   */
+  if (length_limit) {
+    processor = save_marker;
+    /* If saving APP0/APP14, save at least enough for our internal use. */
+    if (marker_code == (int)M_APP0 && length_limit < APP0_DATA_LEN)
+      length_limit = APP0_DATA_LEN;
+    else if (marker_code == (int)M_APP14 && length_limit < APP14_DATA_LEN)
+      length_limit = APP14_DATA_LEN;
+  } else {
+    processor = skip_variable;
+    /* If discarding APP0/APP14, use our regular on-the-fly processor. */
+    if (marker_code == (int)M_APP0 || marker_code == (int)M_APP14)
+      processor = get_interesting_appn;
+  }
+
+  if (marker_code == (int)M_COM) {
+    marker->process_COM = processor;
+    marker->length_limit_COM = length_limit;
+  } else if (marker_code >= (int)M_APP0 && marker_code <= (int)M_APP15) {
+    marker->process_APPn[marker_code - (int)M_APP0] = processor;
+    marker->length_limit_APPn[marker_code - (int)M_APP0] = length_limit;
+  } else
+    ERREXIT1(cinfo, JERR_UNKNOWN_MARKER, marker_code);
+}
+
+#endif /* SAVE_MARKERS_SUPPORTED */
+
+
+/*
+ * Install a special processing method for COM or APPn markers.
+ */
+
+GLOBAL(void)
+jpeg_set_marker_processor(j_decompress_ptr cinfo, int marker_code,
+                          jpeg_marker_parser_method routine)
+{
+  my_marker_ptr marker = (my_marker_ptr)cinfo->marker;
+
+  if (marker_code == (int)M_COM)
+    marker->process_COM = routine;
+  else if (marker_code >= (int)M_APP0 && marker_code <= (int)M_APP15)
+    marker->process_APPn[marker_code - (int)M_APP0] = routine;
+  else
+    ERREXIT1(cinfo, JERR_UNKNOWN_MARKER, marker_code);
+}
diff --git a/3rdparty/libjpeg/src/jdmaster.c b/3rdparty/libjpeg/src/jdmaster.c
new file mode 100644
index 00000000..cbc8774b
--- /dev/null
+++ b/3rdparty/libjpeg/src/jdmaster.c
@@ -0,0 +1,726 @@
+/*
+ * jdmaster.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1991-1997, Thomas G. Lane.
+ * Modified 2002-2009 by Guido Vollbeding.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2009-2011, 2016, 2019, D. R. Commander.
+ * Copyright (C) 2013, Linaro Limited.
+ * Copyright (C) 2015, Google, Inc.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains master control logic for the JPEG decompressor.
+ * These routines are concerned with selecting the modules to be executed
+ * and with determining the number of passes and the work to be done in each
+ * pass.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jpegcomp.h"
+#include "jdmaster.h"
+
+
+/*
+ * Determine whether merged upsample/color conversion should be used.
+ * CRUCIAL: this must match the actual capabilities of jdmerge.c!
+ */
+
+LOCAL(boolean)
+use_merged_upsample(j_decompress_ptr cinfo)
+{
+#ifdef UPSAMPLE_MERGING_SUPPORTED
+  /* Merging is the equivalent of plain box-filter upsampling */
+  if (cinfo->do_fancy_upsampling || cinfo->CCIR601_sampling)
+    return FALSE;
+  /* jdmerge.c only supports YCC=>RGB and YCC=>RGB565 color conversion */
+  if (cinfo->jpeg_color_space != JCS_YCbCr || cinfo->num_components != 3 ||
+      (cinfo->out_color_space != JCS_RGB &&
+       cinfo->out_color_space != JCS_RGB565 &&
+       cinfo->out_color_space != JCS_EXT_RGB &&
+       cinfo->out_color_space != JCS_EXT_RGBX &&
+       cinfo->out_color_space != JCS_EXT_BGR &&
+       cinfo->out_color_space != JCS_EXT_BGRX &&
+       cinfo->out_color_space != JCS_EXT_XBGR &&
+       cinfo->out_color_space != JCS_EXT_XRGB &&
+       cinfo->out_color_space != JCS_EXT_RGBA &&
+       cinfo->out_color_space != JCS_EXT_BGRA &&
+       cinfo->out_color_space != JCS_EXT_ABGR &&
+       cinfo->out_color_space != JCS_EXT_ARGB))
+    return FALSE;
+  if ((cinfo->out_color_space == JCS_RGB565 &&
+       cinfo->out_color_components != 3) ||
+      (cinfo->out_color_space != JCS_RGB565 &&
+       cinfo->out_color_components != rgb_pixelsize[cinfo->out_color_space]))
+    return FALSE;
+  /* and it only handles 2h1v or 2h2v sampling ratios */
+  if (cinfo->comp_info[0].h_samp_factor != 2 ||
+      cinfo->comp_info[1].h_samp_factor != 1 ||
+      cinfo->comp_info[2].h_samp_factor != 1 ||
+      cinfo->comp_info[0].v_samp_factor >  2 ||
+      cinfo->comp_info[1].v_samp_factor != 1 ||
+      cinfo->comp_info[2].v_samp_factor != 1)
+    return FALSE;
+  /* furthermore, it doesn't work if we've scaled the IDCTs differently */
+  if (cinfo->comp_info[0]._DCT_scaled_size != cinfo->_min_DCT_scaled_size ||
+      cinfo->comp_info[1]._DCT_scaled_size != cinfo->_min_DCT_scaled_size ||
+      cinfo->comp_info[2]._DCT_scaled_size != cinfo->_min_DCT_scaled_size)
+    return FALSE;
+  /* ??? also need to test for upsample-time rescaling, when & if supported */
+  return TRUE;                  /* by golly, it'll work... */
+#else
+  return FALSE;
+#endif
+}
+
+
+/*
+ * Compute output image dimensions and related values.
+ * NOTE: this is exported for possible use by application.
+ * Hence it mustn't do anything that can't be done twice.
+ */
+
+#if JPEG_LIB_VERSION >= 80
+GLOBAL(void)
+#else
+LOCAL(void)
+#endif
+jpeg_core_output_dimensions(j_decompress_ptr cinfo)
+/* Do computations that are needed before master selection phase.
+ * This function is used for transcoding and full decompression.
+ */
+{
+#ifdef IDCT_SCALING_SUPPORTED
+  int ci;
+  jpeg_component_info *compptr;
+
+  /* Compute actual output image dimensions and DCT scaling choices. */
+  if (cinfo->scale_num * DCTSIZE <= cinfo->scale_denom) {
+    /* Provide 1/block_size scaling */
+    cinfo->output_width = (JDIMENSION)
+      jdiv_round_up((long)cinfo->image_width, (long)DCTSIZE);
+    cinfo->output_height = (JDIMENSION)
+      jdiv_round_up((long)cinfo->image_height, (long)DCTSIZE);
+    cinfo->_min_DCT_h_scaled_size = 1;
+    cinfo->_min_DCT_v_scaled_size = 1;
+  } else if (cinfo->scale_num * DCTSIZE <= cinfo->scale_denom * 2) {
+    /* Provide 2/block_size scaling */
+    cinfo->output_width = (JDIMENSION)
+      jdiv_round_up((long)cinfo->image_width * 2L, (long)DCTSIZE);
+    cinfo->output_height = (JDIMENSION)
+      jdiv_round_up((long)cinfo->image_height * 2L, (long)DCTSIZE);
+    cinfo->_min_DCT_h_scaled_size = 2;
+    cinfo->_min_DCT_v_scaled_size = 2;
+  } else if (cinfo->scale_num * DCTSIZE <= cinfo->scale_denom * 3) {
+    /* Provide 3/block_size scaling */
+    cinfo->output_width = (JDIMENSION)
+      jdiv_round_up((long)cinfo->image_width * 3L, (long)DCTSIZE);
+    cinfo->output_height = (JDIMENSION)
+      jdiv_round_up((long)cinfo->image_height * 3L, (long)DCTSIZE);
+    cinfo->_min_DCT_h_scaled_size = 3;
+    cinfo->_min_DCT_v_scaled_size = 3;
+  } else if (cinfo->scale_num * DCTSIZE <= cinfo->scale_denom * 4) {
+    /* Provide 4/block_size scaling */
+    cinfo->output_width = (JDIMENSION)
+      jdiv_round_up((long)cinfo->image_width * 4L, (long)DCTSIZE);
+    cinfo->output_height = (JDIMENSION)
+      jdiv_round_up((long)cinfo->image_height * 4L, (long)DCTSIZE);
+    cinfo->_min_DCT_h_scaled_size = 4;
+    cinfo->_min_DCT_v_scaled_size = 4;
+  } else if (cinfo->scale_num * DCTSIZE <= cinfo->scale_denom * 5) {
+    /* Provide 5/block_size scaling */
+    cinfo->output_width = (JDIMENSION)
+      jdiv_round_up((long)cinfo->image_width * 5L, (long)DCTSIZE);
+    cinfo->output_height = (JDIMENSION)
+      jdiv_round_up((long)cinfo->image_height * 5L, (long)DCTSIZE);
+    cinfo->_min_DCT_h_scaled_size = 5;
+    cinfo->_min_DCT_v_scaled_size = 5;
+  } else if (cinfo->scale_num * DCTSIZE <= cinfo->scale_denom * 6) {
+    /* Provide 6/block_size scaling */
+    cinfo->output_width = (JDIMENSION)
+      jdiv_round_up((long)cinfo->image_width * 6L, (long)DCTSIZE);
+    cinfo->output_height = (JDIMENSION)
+      jdiv_round_up((long)cinfo->image_height * 6L, (long)DCTSIZE);
+    cinfo->_min_DCT_h_scaled_size = 6;
+    cinfo->_min_DCT_v_scaled_size = 6;
+  } else if (cinfo->scale_num * DCTSIZE <= cinfo->scale_denom * 7) {
+    /* Provide 7/block_size scaling */
+    cinfo->output_width = (JDIMENSION)
+      jdiv_round_up((long)cinfo->image_width * 7L, (long)DCTSIZE);
+    cinfo->output_height = (JDIMENSION)
+      jdiv_round_up((long)cinfo->image_height * 7L, (long)DCTSIZE);
+    cinfo->_min_DCT_h_scaled_size = 7;
+    cinfo->_min_DCT_v_scaled_size = 7;
+  } else if (cinfo->scale_num * DCTSIZE <= cinfo->scale_denom * 8) {
+    /* Provide 8/block_size scaling */
+    cinfo->output_width = (JDIMENSION)
+      jdiv_round_up((long)cinfo->image_width * 8L, (long)DCTSIZE);
+    cinfo->output_height = (JDIMENSION)
+      jdiv_round_up((long)cinfo->image_height * 8L, (long)DCTSIZE);
+    cinfo->_min_DCT_h_scaled_size = 8;
+    cinfo->_min_DCT_v_scaled_size = 8;
+  } else if (cinfo->scale_num * DCTSIZE <= cinfo->scale_denom * 9) {
+    /* Provide 9/block_size scaling */
+    cinfo->output_width = (JDIMENSION)
+      jdiv_round_up((long)cinfo->image_width * 9L, (long)DCTSIZE);
+    cinfo->output_height = (JDIMENSION)
+      jdiv_round_up((long)cinfo->image_height * 9L, (long)DCTSIZE);
+    cinfo->_min_DCT_h_scaled_size = 9;
+    cinfo->_min_DCT_v_scaled_size = 9;
+  } else if (cinfo->scale_num * DCTSIZE <= cinfo->scale_denom * 10) {
+    /* Provide 10/block_size scaling */
+    cinfo->output_width = (JDIMENSION)
+      jdiv_round_up((long)cinfo->image_width * 10L, (long)DCTSIZE);
+    cinfo->output_height = (JDIMENSION)
+      jdiv_round_up((long)cinfo->image_height * 10L, (long)DCTSIZE);
+    cinfo->_min_DCT_h_scaled_size = 10;
+    cinfo->_min_DCT_v_scaled_size = 10;
+  } else if (cinfo->scale_num * DCTSIZE <= cinfo->scale_denom * 11) {
+    /* Provide 11/block_size scaling */
+    cinfo->output_width = (JDIMENSION)
+      jdiv_round_up((long)cinfo->image_width * 11L, (long)DCTSIZE);
+    cinfo->output_height = (JDIMENSION)
+      jdiv_round_up((long)cinfo->image_height * 11L, (long)DCTSIZE);
+    cinfo->_min_DCT_h_scaled_size = 11;
+    cinfo->_min_DCT_v_scaled_size = 11;
+  } else if (cinfo->scale_num * DCTSIZE <= cinfo->scale_denom * 12) {
+    /* Provide 12/block_size scaling */
+    cinfo->output_width = (JDIMENSION)
+      jdiv_round_up((long)cinfo->image_width * 12L, (long)DCTSIZE);
+    cinfo->output_height = (JDIMENSION)
+      jdiv_round_up((long)cinfo->image_height * 12L, (long)DCTSIZE);
+    cinfo->_min_DCT_h_scaled_size = 12;
+    cinfo->_min_DCT_v_scaled_size = 12;
+  } else if (cinfo->scale_num * DCTSIZE <= cinfo->scale_denom * 13) {
+    /* Provide 13/block_size scaling */
+    cinfo->output_width = (JDIMENSION)
+      jdiv_round_up((long)cinfo->image_width * 13L, (long)DCTSIZE);
+    cinfo->output_height = (JDIMENSION)
+      jdiv_round_up((long)cinfo->image_height * 13L, (long)DCTSIZE);
+    cinfo->_min_DCT_h_scaled_size = 13;
+    cinfo->_min_DCT_v_scaled_size = 13;
+  } else if (cinfo->scale_num * DCTSIZE <= cinfo->scale_denom * 14) {
+    /* Provide 14/block_size scaling */
+    cinfo->output_width = (JDIMENSION)
+      jdiv_round_up((long)cinfo->image_width * 14L, (long)DCTSIZE);
+    cinfo->output_height = (JDIMENSION)
+      jdiv_round_up((long)cinfo->image_height * 14L, (long)DCTSIZE);
+    cinfo->_min_DCT_h_scaled_size = 14;
+    cinfo->_min_DCT_v_scaled_size = 14;
+  } else if (cinfo->scale_num * DCTSIZE <= cinfo->scale_denom * 15) {
+    /* Provide 15/block_size scaling */
+    cinfo->output_width = (JDIMENSION)
+      jdiv_round_up((long)cinfo->image_width * 15L, (long)DCTSIZE);
+    cinfo->output_height = (JDIMENSION)
+      jdiv_round_up((long)cinfo->image_height * 15L, (long)DCTSIZE);
+    cinfo->_min_DCT_h_scaled_size = 15;
+    cinfo->_min_DCT_v_scaled_size = 15;
+  } else {
+    /* Provide 16/block_size scaling */
+    cinfo->output_width = (JDIMENSION)
+      jdiv_round_up((long)cinfo->image_width * 16L, (long)DCTSIZE);
+    cinfo->output_height = (JDIMENSION)
+      jdiv_round_up((long)cinfo->image_height * 16L, (long)DCTSIZE);
+    cinfo->_min_DCT_h_scaled_size = 16;
+    cinfo->_min_DCT_v_scaled_size = 16;
+  }
+
+  /* Recompute dimensions of components */
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    compptr->_DCT_h_scaled_size = cinfo->_min_DCT_h_scaled_size;
+    compptr->_DCT_v_scaled_size = cinfo->_min_DCT_v_scaled_size;
+  }
+
+#else /* !IDCT_SCALING_SUPPORTED */
+
+  /* Hardwire it to "no scaling" */
+  cinfo->output_width = cinfo->image_width;
+  cinfo->output_height = cinfo->image_height;
+  /* jdinput.c has already initialized DCT_scaled_size,
+   * and has computed unscaled downsampled_width and downsampled_height.
+   */
+
+#endif /* IDCT_SCALING_SUPPORTED */
+}
+
+
+/*
+ * Compute output image dimensions and related values.
+ * NOTE: this is exported for possible use by application.
+ * Hence it mustn't do anything that can't be done twice.
+ * Also note that it may be called before the master module is initialized!
+ */
+
+GLOBAL(void)
+jpeg_calc_output_dimensions(j_decompress_ptr cinfo)
+/* Do computations that are needed before master selection phase */
+{
+#ifdef IDCT_SCALING_SUPPORTED
+  int ci;
+  jpeg_component_info *compptr;
+#endif
+
+  /* Prevent application from calling me at wrong times */
+  if (cinfo->global_state != DSTATE_READY)
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+
+  /* Compute core output image dimensions and DCT scaling choices. */
+  jpeg_core_output_dimensions(cinfo);
+
+#ifdef IDCT_SCALING_SUPPORTED
+
+  /* In selecting the actual DCT scaling for each component, we try to
+   * scale up the chroma components via IDCT scaling rather than upsampling.
+   * This saves time if the upsampler gets to use 1:1 scaling.
+   * Note this code adapts subsampling ratios which are powers of 2.
+   */
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    int ssize = cinfo->_min_DCT_scaled_size;
+    while (ssize < DCTSIZE &&
+           ((cinfo->max_h_samp_factor * cinfo->_min_DCT_scaled_size) %
+            (compptr->h_samp_factor * ssize * 2) == 0) &&
+           ((cinfo->max_v_samp_factor * cinfo->_min_DCT_scaled_size) %
+            (compptr->v_samp_factor * ssize * 2) == 0)) {
+      ssize = ssize * 2;
+    }
+#if JPEG_LIB_VERSION >= 70
+    compptr->DCT_h_scaled_size = compptr->DCT_v_scaled_size = ssize;
+#else
+    compptr->DCT_scaled_size = ssize;
+#endif
+  }
+
+  /* Recompute downsampled dimensions of components;
+   * application needs to know these if using raw downsampled data.
+   */
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    /* Size in samples, after IDCT scaling */
+    compptr->downsampled_width = (JDIMENSION)
+      jdiv_round_up((long)cinfo->image_width *
+                    (long)(compptr->h_samp_factor * compptr->_DCT_scaled_size),
+                    (long)(cinfo->max_h_samp_factor * DCTSIZE));
+    compptr->downsampled_height = (JDIMENSION)
+      jdiv_round_up((long)cinfo->image_height *
+                    (long)(compptr->v_samp_factor * compptr->_DCT_scaled_size),
+                    (long)(cinfo->max_v_samp_factor * DCTSIZE));
+  }
+
+#else /* !IDCT_SCALING_SUPPORTED */
+
+  /* Hardwire it to "no scaling" */
+  cinfo->output_width = cinfo->image_width;
+  cinfo->output_height = cinfo->image_height;
+  /* jdinput.c has already initialized DCT_scaled_size to DCTSIZE,
+   * and has computed unscaled downsampled_width and downsampled_height.
+   */
+
+#endif /* IDCT_SCALING_SUPPORTED */
+
+  /* Report number of components in selected colorspace. */
+  /* Probably this should be in the color conversion module... */
+  switch (cinfo->out_color_space) {
+  case JCS_GRAYSCALE:
+    cinfo->out_color_components = 1;
+    break;
+  case JCS_RGB:
+  case JCS_EXT_RGB:
+  case JCS_EXT_RGBX:
+  case JCS_EXT_BGR:
+  case JCS_EXT_BGRX:
+  case JCS_EXT_XBGR:
+  case JCS_EXT_XRGB:
+  case JCS_EXT_RGBA:
+  case JCS_EXT_BGRA:
+  case JCS_EXT_ABGR:
+  case JCS_EXT_ARGB:
+    cinfo->out_color_components = rgb_pixelsize[cinfo->out_color_space];
+    break;
+  case JCS_YCbCr:
+  case JCS_RGB565:
+    cinfo->out_color_components = 3;
+    break;
+  case JCS_CMYK:
+  case JCS_YCCK:
+    cinfo->out_color_components = 4;
+    break;
+  default:                      /* else must be same colorspace as in file */
+    cinfo->out_color_components = cinfo->num_components;
+    break;
+  }
+  cinfo->output_components = (cinfo->quantize_colors ? 1 :
+                              cinfo->out_color_components);
+
+  /* See if upsampler will want to emit more than one row at a time */
+  if (use_merged_upsample(cinfo))
+    cinfo->rec_outbuf_height = cinfo->max_v_samp_factor;
+  else
+    cinfo->rec_outbuf_height = 1;
+}
+
+
+/*
+ * Several decompression processes need to range-limit values to the range
+ * 0..MAXJSAMPLE; the input value may fall somewhat outside this range
+ * due to noise introduced by quantization, roundoff error, etc.  These
+ * processes are inner loops and need to be as fast as possible.  On most
+ * machines, particularly CPUs with pipelines or instruction prefetch,
+ * a (subscript-check-less) C table lookup
+ *              x = sample_range_limit[x];
+ * is faster than explicit tests
+ *              if (x < 0)  x = 0;
+ *              else if (x > MAXJSAMPLE)  x = MAXJSAMPLE;
+ * These processes all use a common table prepared by the routine below.
+ *
+ * For most steps we can mathematically guarantee that the initial value
+ * of x is within MAXJSAMPLE+1 of the legal range, so a table running from
+ * -(MAXJSAMPLE+1) to 2*MAXJSAMPLE+1 is sufficient.  But for the initial
+ * limiting step (just after the IDCT), a wildly out-of-range value is
+ * possible if the input data is corrupt.  To avoid any chance of indexing
+ * off the end of memory and getting a bad-pointer trap, we perform the
+ * post-IDCT limiting thus:
+ *              x = range_limit[x & MASK];
+ * where MASK is 2 bits wider than legal sample data, ie 10 bits for 8-bit
+ * samples.  Under normal circumstances this is more than enough range and
+ * a correct output will be generated; with bogus input data the mask will
+ * cause wraparound, and we will safely generate a bogus-but-in-range output.
+ * For the post-IDCT step, we want to convert the data from signed to unsigned
+ * representation by adding CENTERJSAMPLE at the same time that we limit it.
+ * So the post-IDCT limiting table ends up looking like this:
+ *   CENTERJSAMPLE,CENTERJSAMPLE+1,...,MAXJSAMPLE,
+ *   MAXJSAMPLE (repeat 2*(MAXJSAMPLE+1)-CENTERJSAMPLE times),
+ *   0          (repeat 2*(MAXJSAMPLE+1)-CENTERJSAMPLE times),
+ *   0,1,...,CENTERJSAMPLE-1
+ * Negative inputs select values from the upper half of the table after
+ * masking.
+ *
+ * We can save some space by overlapping the start of the post-IDCT table
+ * with the simpler range limiting table.  The post-IDCT table begins at
+ * sample_range_limit + CENTERJSAMPLE.
+ */
+
+LOCAL(void)
+prepare_range_limit_table(j_decompress_ptr cinfo)
+/* Allocate and fill in the sample_range_limit table */
+{
+  JSAMPLE *table;
+  int i;
+
+  table = (JSAMPLE *)
+    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+                (5 * (MAXJSAMPLE + 1) + CENTERJSAMPLE) * sizeof(JSAMPLE));
+  table += (MAXJSAMPLE + 1);    /* allow negative subscripts of simple table */
+  cinfo->sample_range_limit = table;
+  /* First segment of "simple" table: limit[x] = 0 for x < 0 */
+  MEMZERO(table - (MAXJSAMPLE + 1), (MAXJSAMPLE + 1) * sizeof(JSAMPLE));
+  /* Main part of "simple" table: limit[x] = x */
+  for (i = 0; i <= MAXJSAMPLE; i++)
+    table[i] = (JSAMPLE)i;
+  table += CENTERJSAMPLE;       /* Point to where post-IDCT table starts */
+  /* End of simple table, rest of first half of post-IDCT table */
+  for (i = CENTERJSAMPLE; i < 2 * (MAXJSAMPLE + 1); i++)
+    table[i] = MAXJSAMPLE;
+  /* Second half of post-IDCT table */
+  MEMZERO(table + (2 * (MAXJSAMPLE + 1)),
+          (2 * (MAXJSAMPLE + 1) - CENTERJSAMPLE) * sizeof(JSAMPLE));
+  MEMCOPY(table + (4 * (MAXJSAMPLE + 1) - CENTERJSAMPLE),
+          cinfo->sample_range_limit, CENTERJSAMPLE * sizeof(JSAMPLE));
+}
+
+
+/*
+ * Master selection of decompression modules.
+ * This is done once at jpeg_start_decompress time.  We determine
+ * which modules will be used and give them appropriate initialization calls.
+ * We also initialize the decompressor input side to begin consuming data.
+ *
+ * Since jpeg_read_header has finished, we know what is in the SOF
+ * and (first) SOS markers.  We also have all the application parameter
+ * settings.
+ */
+
+LOCAL(void)
+master_selection(j_decompress_ptr cinfo)
+{
+  my_master_ptr master = (my_master_ptr)cinfo->master;
+  boolean use_c_buffer;
+  long samplesperrow;
+  JDIMENSION jd_samplesperrow;
+
+  /* Initialize dimensions and other stuff */
+  jpeg_calc_output_dimensions(cinfo);
+  prepare_range_limit_table(cinfo);
+
+  /* Width of an output scanline must be representable as JDIMENSION. */
+  samplesperrow = (long)cinfo->output_width *
+                  (long)cinfo->out_color_components;
+  jd_samplesperrow = (JDIMENSION)samplesperrow;
+  if ((long)jd_samplesperrow != samplesperrow)
+    ERREXIT(cinfo, JERR_WIDTH_OVERFLOW);
+
+  /* Initialize my private state */
+  master->pass_number = 0;
+  master->using_merged_upsample = use_merged_upsample(cinfo);
+
+  /* Color quantizer selection */
+  master->quantizer_1pass = NULL;
+  master->quantizer_2pass = NULL;
+  /* No mode changes if not using buffered-image mode. */
+  if (!cinfo->quantize_colors || !cinfo->buffered_image) {
+    cinfo->enable_1pass_quant = FALSE;
+    cinfo->enable_external_quant = FALSE;
+    cinfo->enable_2pass_quant = FALSE;
+  }
+  if (cinfo->quantize_colors) {
+    if (cinfo->raw_data_out)
+      ERREXIT(cinfo, JERR_NOTIMPL);
+    /* 2-pass quantizer only works in 3-component color space. */
+    if (cinfo->out_color_components != 3) {
+      cinfo->enable_1pass_quant = TRUE;
+      cinfo->enable_external_quant = FALSE;
+      cinfo->enable_2pass_quant = FALSE;
+      cinfo->colormap = NULL;
+    } else if (cinfo->colormap != NULL) {
+      cinfo->enable_external_quant = TRUE;
+    } else if (cinfo->two_pass_quantize) {
+      cinfo->enable_2pass_quant = TRUE;
+    } else {
+      cinfo->enable_1pass_quant = TRUE;
+    }
+
+    if (cinfo->enable_1pass_quant) {
+#ifdef QUANT_1PASS_SUPPORTED
+      jinit_1pass_quantizer(cinfo);
+      master->quantizer_1pass = cinfo->cquantize;
+#else
+      ERREXIT(cinfo, JERR_NOT_COMPILED);
+#endif
+    }
+
+    /* We use the 2-pass code to map to external colormaps. */
+    if (cinfo->enable_2pass_quant || cinfo->enable_external_quant) {
+#ifdef QUANT_2PASS_SUPPORTED
+      jinit_2pass_quantizer(cinfo);
+      master->quantizer_2pass = cinfo->cquantize;
+#else
+      ERREXIT(cinfo, JERR_NOT_COMPILED);
+#endif
+    }
+    /* If both quantizers are initialized, the 2-pass one is left active;
+     * this is necessary for starting with quantization to an external map.
+     */
+  }
+
+  /* Post-processing: in particular, color conversion first */
+  if (!cinfo->raw_data_out) {
+    if (master->using_merged_upsample) {
+#ifdef UPSAMPLE_MERGING_SUPPORTED
+      jinit_merged_upsampler(cinfo); /* does color conversion too */
+#else
+      ERREXIT(cinfo, JERR_NOT_COMPILED);
+#endif
+    } else {
+      jinit_color_deconverter(cinfo);
+      jinit_upsampler(cinfo);
+    }
+    jinit_d_post_controller(cinfo, cinfo->enable_2pass_quant);
+  }
+  /* Inverse DCT */
+  jinit_inverse_dct(cinfo);
+  /* Entropy decoding: either Huffman or arithmetic coding. */
+  if (cinfo->arith_code) {
+#ifdef D_ARITH_CODING_SUPPORTED
+    jinit_arith_decoder(cinfo);
+#else
+    ERREXIT(cinfo, JERR_ARITH_NOTIMPL);
+#endif
+  } else {
+    if (cinfo->progressive_mode) {
+#ifdef D_PROGRESSIVE_SUPPORTED
+      jinit_phuff_decoder(cinfo);
+#else
+      ERREXIT(cinfo, JERR_NOT_COMPILED);
+#endif
+    } else
+      jinit_huff_decoder(cinfo);
+  }
+
+  /* Initialize principal buffer controllers. */
+  use_c_buffer = cinfo->inputctl->has_multiple_scans || cinfo->buffered_image;
+  jinit_d_coef_controller(cinfo, use_c_buffer);
+
+  if (!cinfo->raw_data_out)
+    jinit_d_main_controller(cinfo, FALSE /* never need full buffer here */);
+
+  /* We can now tell the memory manager to allocate virtual arrays. */
+  (*cinfo->mem->realize_virt_arrays) ((j_common_ptr)cinfo);
+
+  /* Initialize input side of decompressor to consume first scan. */
+  (*cinfo->inputctl->start_input_pass) (cinfo);
+
+  /* Set the first and last iMCU columns to decompress from single-scan images.
+   * By default, decompress all of the iMCU columns.
+   */
+  cinfo->master->first_iMCU_col = 0;
+  cinfo->master->last_iMCU_col = cinfo->MCUs_per_row - 1;
+  cinfo->master->last_good_iMCU_row = 0;
+
+#ifdef D_MULTISCAN_FILES_SUPPORTED
+  /* If jpeg_start_decompress will read the whole file, initialize
+   * progress monitoring appropriately.  The input step is counted
+   * as one pass.
+   */
+  if (cinfo->progress != NULL && !cinfo->buffered_image &&
+      cinfo->inputctl->has_multiple_scans) {
+    int nscans;
+    /* Estimate number of scans to set pass_limit. */
+    if (cinfo->progressive_mode) {
+      /* Arbitrarily estimate 2 interleaved DC scans + 3 AC scans/component. */
+      nscans = 2 + 3 * cinfo->num_components;
+    } else {
+      /* For a nonprogressive multiscan file, estimate 1 scan per component. */
+      nscans = cinfo->num_components;
+    }
+    cinfo->progress->pass_counter = 0L;
+    cinfo->progress->pass_limit = (long)cinfo->total_iMCU_rows * nscans;
+    cinfo->progress->completed_passes = 0;
+    cinfo->progress->total_passes = (cinfo->enable_2pass_quant ? 3 : 2);
+    /* Count the input pass as done */
+    master->pass_number++;
+  }
+#endif /* D_MULTISCAN_FILES_SUPPORTED */
+}
+
+
+/*
+ * Per-pass setup.
+ * This is called at the beginning of each output pass.  We determine which
+ * modules will be active during this pass and give them appropriate
+ * start_pass calls.  We also set is_dummy_pass to indicate whether this
+ * is a "real" output pass or a dummy pass for color quantization.
+ * (In the latter case, jdapistd.c will crank the pass to completion.)
+ */
+
+METHODDEF(void)
+prepare_for_output_pass(j_decompress_ptr cinfo)
+{
+  my_master_ptr master = (my_master_ptr)cinfo->master;
+
+  if (master->pub.is_dummy_pass) {
+#ifdef QUANT_2PASS_SUPPORTED
+    /* Final pass of 2-pass quantization */
+    master->pub.is_dummy_pass = FALSE;
+    (*cinfo->cquantize->start_pass) (cinfo, FALSE);
+    (*cinfo->post->start_pass) (cinfo, JBUF_CRANK_DEST);
+    (*cinfo->main->start_pass) (cinfo, JBUF_CRANK_DEST);
+#else
+    ERREXIT(cinfo, JERR_NOT_COMPILED);
+#endif /* QUANT_2PASS_SUPPORTED */
+  } else {
+    if (cinfo->quantize_colors && cinfo->colormap == NULL) {
+      /* Select new quantization method */
+      if (cinfo->two_pass_quantize && cinfo->enable_2pass_quant) {
+        cinfo->cquantize = master->quantizer_2pass;
+        master->pub.is_dummy_pass = TRUE;
+      } else if (cinfo->enable_1pass_quant) {
+        cinfo->cquantize = master->quantizer_1pass;
+      } else {
+        ERREXIT(cinfo, JERR_MODE_CHANGE);
+      }
+    }
+    (*cinfo->idct->start_pass) (cinfo);
+    (*cinfo->coef->start_output_pass) (cinfo);
+    if (!cinfo->raw_data_out) {
+      if (!master->using_merged_upsample)
+        (*cinfo->cconvert->start_pass) (cinfo);
+      (*cinfo->upsample->start_pass) (cinfo);
+      if (cinfo->quantize_colors)
+        (*cinfo->cquantize->start_pass) (cinfo, master->pub.is_dummy_pass);
+      (*cinfo->post->start_pass) (cinfo,
+            (master->pub.is_dummy_pass ? JBUF_SAVE_AND_PASS : JBUF_PASS_THRU));
+      (*cinfo->main->start_pass) (cinfo, JBUF_PASS_THRU);
+    }
+  }
+
+  /* Set up progress monitor's pass info if present */
+  if (cinfo->progress != NULL) {
+    cinfo->progress->completed_passes = master->pass_number;
+    cinfo->progress->total_passes = master->pass_number +
+                                    (master->pub.is_dummy_pass ? 2 : 1);
+    /* In buffered-image mode, we assume one more output pass if EOI not
+     * yet reached, but no more passes if EOI has been reached.
+     */
+    if (cinfo->buffered_image && !cinfo->inputctl->eoi_reached) {
+      cinfo->progress->total_passes += (cinfo->enable_2pass_quant ? 2 : 1);
+    }
+  }
+}
+
+
+/*
+ * Finish up at end of an output pass.
+ */
+
+METHODDEF(void)
+finish_output_pass(j_decompress_ptr cinfo)
+{
+  my_master_ptr master = (my_master_ptr)cinfo->master;
+
+  if (cinfo->quantize_colors)
+    (*cinfo->cquantize->finish_pass) (cinfo);
+  master->pass_number++;
+}
+
+
+#ifdef D_MULTISCAN_FILES_SUPPORTED
+
+/*
+ * Switch to a new external colormap between output passes.
+ */
+
+GLOBAL(void)
+jpeg_new_colormap(j_decompress_ptr cinfo)
+{
+  my_master_ptr master = (my_master_ptr)cinfo->master;
+
+  /* Prevent application from calling me at wrong times */
+  if (cinfo->global_state != DSTATE_BUFIMAGE)
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+
+  if (cinfo->quantize_colors && cinfo->enable_external_quant &&
+      cinfo->colormap != NULL) {
+    /* Select 2-pass quantizer for external colormap use */
+    cinfo->cquantize = master->quantizer_2pass;
+    /* Notify quantizer of colormap change */
+    (*cinfo->cquantize->new_color_map) (cinfo);
+    master->pub.is_dummy_pass = FALSE; /* just in case */
+  } else
+    ERREXIT(cinfo, JERR_MODE_CHANGE);
+}
+
+#endif /* D_MULTISCAN_FILES_SUPPORTED */
+
+
+/*
+ * Initialize master decompression control and select active modules.
+ * This is performed at the start of jpeg_start_decompress.
+ */
+
+GLOBAL(void)
+jinit_master_decompress(j_decompress_ptr cinfo)
+{
+  my_master_ptr master = (my_master_ptr)cinfo->master;
+
+  master->pub.prepare_for_output_pass = prepare_for_output_pass;
+  master->pub.finish_output_pass = finish_output_pass;
+
+  master->pub.is_dummy_pass = FALSE;
+  master->pub.jinit_upsampler_no_alloc = FALSE;
+
+  master_selection(cinfo);
+}
diff --git a/3rdparty/libjpeg/src/jdmaster.h b/3rdparty/libjpeg/src/jdmaster.h
new file mode 100644
index 00000000..76897e28
--- /dev/null
+++ b/3rdparty/libjpeg/src/jdmaster.h
@@ -0,0 +1,28 @@
+/*
+ * jdmaster.h
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1991-1995, Thomas G. Lane.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains the master control structure for the JPEG decompressor.
+ */
+
+/* Private state */
+
+typedef struct {
+  struct jpeg_decomp_master pub; /* public fields */
+
+  int pass_number;              /* # of passes completed */
+
+  boolean using_merged_upsample; /* TRUE if using merged upsample/cconvert */
+
+  /* Saved references to initialized quantizer modules,
+   * in case we need to switch modes.
+   */
+  struct jpeg_color_quantizer *quantizer_1pass;
+  struct jpeg_color_quantizer *quantizer_2pass;
+} my_decomp_master;
+
+typedef my_decomp_master *my_master_ptr;
diff --git a/3rdparty/libjpeg/src/jdmerge.c b/3rdparty/libjpeg/src/jdmerge.c
new file mode 100644
index 00000000..3a456d65
--- /dev/null
+++ b/3rdparty/libjpeg/src/jdmerge.c
@@ -0,0 +1,588 @@
+/*
+ * jdmerge.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1994-1996, Thomas G. Lane.
+ * libjpeg-turbo Modifications:
+ * Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+ * Copyright (C) 2009, 2011, 2014-2015, 2020, D. R. Commander.
+ * Copyright (C) 2013, Linaro Limited.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains code for merged upsampling/color conversion.
+ *
+ * This file combines functions from jdsample.c and jdcolor.c;
+ * read those files first to understand what's going on.
+ *
+ * When the chroma components are to be upsampled by simple replication
+ * (ie, box filtering), we can save some work in color conversion by
+ * calculating all the output pixels corresponding to a pair of chroma
+ * samples at one time.  In the conversion equations
+ *      R = Y           + K1 * Cr
+ *      G = Y + K2 * Cb + K3 * Cr
+ *      B = Y + K4 * Cb
+ * only the Y term varies among the group of pixels corresponding to a pair
+ * of chroma samples, so the rest of the terms can be calculated just once.
+ * At typical sampling ratios, this eliminates half or three-quarters of the
+ * multiplications needed for color conversion.
+ *
+ * This file currently provides implementations for the following cases:
+ *      YCbCr => RGB color conversion only.
+ *      Sampling ratios of 2h1v or 2h2v.
+ *      No scaling needed at upsample time.
+ *      Corner-aligned (non-CCIR601) sampling alignment.
+ * Other special cases could be added, but in most applications these are
+ * the only common cases.  (For uncommon cases we fall back on the more
+ * general code in jdsample.c and jdcolor.c.)
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jdmerge.h"
+#include "jsimd.h"
+#include "jconfigint.h"
+
+#ifdef UPSAMPLE_MERGING_SUPPORTED
+
+
+#define SCALEBITS       16      /* speediest right-shift on some machines */
+#define ONE_HALF        ((JLONG)1 << (SCALEBITS - 1))
+#define FIX(x)          ((JLONG)((x) * (1L << SCALEBITS) + 0.5))
+
+
+/* Include inline routines for colorspace extensions */
+
+#include "jdmrgext.c"
+#undef RGB_RED
+#undef RGB_GREEN
+#undef RGB_BLUE
+#undef RGB_PIXELSIZE
+
+#define RGB_RED  EXT_RGB_RED
+#define RGB_GREEN  EXT_RGB_GREEN
+#define RGB_BLUE  EXT_RGB_BLUE
+#define RGB_PIXELSIZE  EXT_RGB_PIXELSIZE
+#define h2v1_merged_upsample_internal  extrgb_h2v1_merged_upsample_internal
+#define h2v2_merged_upsample_internal  extrgb_h2v2_merged_upsample_internal
+#include "jdmrgext.c"
+#undef RGB_RED
+#undef RGB_GREEN
+#undef RGB_BLUE
+#undef RGB_PIXELSIZE
+#undef h2v1_merged_upsample_internal
+#undef h2v2_merged_upsample_internal
+
+#define RGB_RED  EXT_RGBX_RED
+#define RGB_GREEN  EXT_RGBX_GREEN
+#define RGB_BLUE  EXT_RGBX_BLUE
+#define RGB_ALPHA  3
+#define RGB_PIXELSIZE  EXT_RGBX_PIXELSIZE
+#define h2v1_merged_upsample_internal  extrgbx_h2v1_merged_upsample_internal
+#define h2v2_merged_upsample_internal  extrgbx_h2v2_merged_upsample_internal
+#include "jdmrgext.c"
+#undef RGB_RED
+#undef RGB_GREEN
+#undef RGB_BLUE
+#undef RGB_ALPHA
+#undef RGB_PIXELSIZE
+#undef h2v1_merged_upsample_internal
+#undef h2v2_merged_upsample_internal
+
+#define RGB_RED  EXT_BGR_RED
+#define RGB_GREEN  EXT_BGR_GREEN
+#define RGB_BLUE  EXT_BGR_BLUE
+#define RGB_PIXELSIZE  EXT_BGR_PIXELSIZE
+#define h2v1_merged_upsample_internal  extbgr_h2v1_merged_upsample_internal
+#define h2v2_merged_upsample_internal  extbgr_h2v2_merged_upsample_internal
+#include "jdmrgext.c"
+#undef RGB_RED
+#undef RGB_GREEN
+#undef RGB_BLUE
+#undef RGB_PIXELSIZE
+#undef h2v1_merged_upsample_internal
+#undef h2v2_merged_upsample_internal
+
+#define RGB_RED  EXT_BGRX_RED
+#define RGB_GREEN  EXT_BGRX_GREEN
+#define RGB_BLUE  EXT_BGRX_BLUE
+#define RGB_ALPHA  3
+#define RGB_PIXELSIZE  EXT_BGRX_PIXELSIZE
+#define h2v1_merged_upsample_internal  extbgrx_h2v1_merged_upsample_internal
+#define h2v2_merged_upsample_internal  extbgrx_h2v2_merged_upsample_internal
+#include "jdmrgext.c"
+#undef RGB_RED
+#undef RGB_GREEN
+#undef RGB_BLUE
+#undef RGB_ALPHA
+#undef RGB_PIXELSIZE
+#undef h2v1_merged_upsample_internal
+#undef h2v2_merged_upsample_internal
+
+#define RGB_RED  EXT_XBGR_RED
+#define RGB_GREEN  EXT_XBGR_GREEN
+#define RGB_BLUE  EXT_XBGR_BLUE
+#define RGB_ALPHA  0
+#define RGB_PIXELSIZE  EXT_XBGR_PIXELSIZE
+#define h2v1_merged_upsample_internal  extxbgr_h2v1_merged_upsample_internal
+#define h2v2_merged_upsample_internal  extxbgr_h2v2_merged_upsample_internal
+#include "jdmrgext.c"
+#undef RGB_RED
+#undef RGB_GREEN
+#undef RGB_BLUE
+#undef RGB_ALPHA
+#undef RGB_PIXELSIZE
+#undef h2v1_merged_upsample_internal
+#undef h2v2_merged_upsample_internal
+
+#define RGB_RED  EXT_XRGB_RED
+#define RGB_GREEN  EXT_XRGB_GREEN
+#define RGB_BLUE  EXT_XRGB_BLUE
+#define RGB_ALPHA  0
+#define RGB_PIXELSIZE  EXT_XRGB_PIXELSIZE
+#define h2v1_merged_upsample_internal  extxrgb_h2v1_merged_upsample_internal
+#define h2v2_merged_upsample_internal  extxrgb_h2v2_merged_upsample_internal
+#include "jdmrgext.c"
+#undef RGB_RED
+#undef RGB_GREEN
+#undef RGB_BLUE
+#undef RGB_ALPHA
+#undef RGB_PIXELSIZE
+#undef h2v1_merged_upsample_internal
+#undef h2v2_merged_upsample_internal
+
+
+/*
+ * Initialize tables for YCC->RGB colorspace conversion.
+ * This is taken directly from jdcolor.c; see that file for more info.
+ */
+
+LOCAL(void)
+build_ycc_rgb_table(j_decompress_ptr cinfo)
+{
+  my_merged_upsample_ptr upsample = (my_merged_upsample_ptr)cinfo->upsample;
+  int i;
+  JLONG x;
+  SHIFT_TEMPS
+
+  upsample->Cr_r_tab = (int *)
+    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+                                (MAXJSAMPLE + 1) * sizeof(int));
+  upsample->Cb_b_tab = (int *)
+    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+                                (MAXJSAMPLE + 1) * sizeof(int));
+  upsample->Cr_g_tab = (JLONG *)
+    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+                                (MAXJSAMPLE + 1) * sizeof(JLONG));
+  upsample->Cb_g_tab = (JLONG *)
+    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+                                (MAXJSAMPLE + 1) * sizeof(JLONG));
+
+  for (i = 0, x = -CENTERJSAMPLE; i <= MAXJSAMPLE; i++, x++) {
+    /* i is the actual input pixel value, in the range 0..MAXJSAMPLE */
+    /* The Cb or Cr value we are thinking of is x = i - CENTERJSAMPLE */
+    /* Cr=>R value is nearest int to 1.40200 * x */
+    upsample->Cr_r_tab[i] = (int)
+                    RIGHT_SHIFT(FIX(1.40200) * x + ONE_HALF, SCALEBITS);
+    /* Cb=>B value is nearest int to 1.77200 * x */
+    upsample->Cb_b_tab[i] = (int)
+                    RIGHT_SHIFT(FIX(1.77200) * x + ONE_HALF, SCALEBITS);
+    /* Cr=>G value is scaled-up -0.71414 * x */
+    upsample->Cr_g_tab[i] = (-FIX(0.71414)) * x;
+    /* Cb=>G value is scaled-up -0.34414 * x */
+    /* We also add in ONE_HALF so that need not do it in inner loop */
+    upsample->Cb_g_tab[i] = (-FIX(0.34414)) * x + ONE_HALF;
+  }
+}
+
+
+/*
+ * Initialize for an upsampling pass.
+ */
+
+METHODDEF(void)
+start_pass_merged_upsample(j_decompress_ptr cinfo)
+{
+  my_merged_upsample_ptr upsample = (my_merged_upsample_ptr)cinfo->upsample;
+
+  /* Mark the spare buffer empty */
+  upsample->spare_full = FALSE;
+  /* Initialize total-height counter for detecting bottom of image */
+  upsample->rows_to_go = cinfo->output_height;
+}
+
+
+/*
+ * Control routine to do upsampling (and color conversion).
+ *
+ * The control routine just handles the row buffering considerations.
+ */
+
+METHODDEF(void)
+merged_2v_upsample(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
+                   JDIMENSION *in_row_group_ctr,
+                   JDIMENSION in_row_groups_avail, JSAMPARRAY output_buf,
+                   JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail)
+/* 2:1 vertical sampling case: may need a spare row. */
+{
+  my_merged_upsample_ptr upsample = (my_merged_upsample_ptr)cinfo->upsample;
+  JSAMPROW work_ptrs[2];
+  JDIMENSION num_rows;          /* number of rows returned to caller */
+
+  if (upsample->spare_full) {
+    /* If we have a spare row saved from a previous cycle, just return it. */
+    JDIMENSION size = upsample->out_row_width;
+    if (cinfo->out_color_space == JCS_RGB565)
+      size = cinfo->output_width * 2;
+    jcopy_sample_rows(&upsample->spare_row, 0, output_buf + *out_row_ctr, 0, 1,
+                      size);
+    num_rows = 1;
+    upsample->spare_full = FALSE;
+  } else {
+    /* Figure number of rows to return to caller. */
+    num_rows = 2;
+    /* Not more than the distance to the end of the image. */
+    if (num_rows > upsample->rows_to_go)
+      num_rows = upsample->rows_to_go;
+    /* And not more than what the client can accept: */
+    out_rows_avail -= *out_row_ctr;
+    if (num_rows > out_rows_avail)
+      num_rows = out_rows_avail;
+    /* Create output pointer array for upsampler. */
+    work_ptrs[0] = output_buf[*out_row_ctr];
+    if (num_rows > 1) {
+      work_ptrs[1] = output_buf[*out_row_ctr + 1];
+    } else {
+      work_ptrs[1] = upsample->spare_row;
+      upsample->spare_full = TRUE;
+    }
+    /* Now do the upsampling. */
+    (*upsample->upmethod) (cinfo, input_buf, *in_row_group_ctr, work_ptrs);
+  }
+
+  /* Adjust counts */
+  *out_row_ctr += num_rows;
+  upsample->rows_to_go -= num_rows;
+  /* When the buffer is emptied, declare this input row group consumed */
+  if (!upsample->spare_full)
+    (*in_row_group_ctr)++;
+}
+
+
+METHODDEF(void)
+merged_1v_upsample(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
+                   JDIMENSION *in_row_group_ctr,
+                   JDIMENSION in_row_groups_avail, JSAMPARRAY output_buf,
+                   JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail)
+/* 1:1 vertical sampling case: much easier, never need a spare row. */
+{
+  my_merged_upsample_ptr upsample = (my_merged_upsample_ptr)cinfo->upsample;
+
+  /* Just do the upsampling. */
+  (*upsample->upmethod) (cinfo, input_buf, *in_row_group_ctr,
+                         output_buf + *out_row_ctr);
+  /* Adjust counts */
+  (*out_row_ctr)++;
+  (*in_row_group_ctr)++;
+}
+
+
+/*
+ * These are the routines invoked by the control routines to do
+ * the actual upsampling/conversion.  One row group is processed per call.
+ *
+ * Note: since we may be writing directly into application-supplied buffers,
+ * we have to be honest about the output width; we can't assume the buffer
+ * has been rounded up to an even width.
+ */
+
+
+/*
+ * Upsample and color convert for the case of 2:1 horizontal and 1:1 vertical.
+ */
+
+METHODDEF(void)
+h2v1_merged_upsample(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
+                     JDIMENSION in_row_group_ctr, JSAMPARRAY output_buf)
+{
+  switch (cinfo->out_color_space) {
+  case JCS_EXT_RGB:
+    extrgb_h2v1_merged_upsample_internal(cinfo, input_buf, in_row_group_ctr,
+                                         output_buf);
+    break;
+  case JCS_EXT_RGBX:
+  case JCS_EXT_RGBA:
+    extrgbx_h2v1_merged_upsample_internal(cinfo, input_buf, in_row_group_ctr,
+                                          output_buf);
+    break;
+  case JCS_EXT_BGR:
+    extbgr_h2v1_merged_upsample_internal(cinfo, input_buf, in_row_group_ctr,
+                                         output_buf);
+    break;
+  case JCS_EXT_BGRX:
+  case JCS_EXT_BGRA:
+    extbgrx_h2v1_merged_upsample_internal(cinfo, input_buf, in_row_group_ctr,
+                                          output_buf);
+    break;
+  case JCS_EXT_XBGR:
+  case JCS_EXT_ABGR:
+    extxbgr_h2v1_merged_upsample_internal(cinfo, input_buf, in_row_group_ctr,
+                                          output_buf);
+    break;
+  case JCS_EXT_XRGB:
+  case JCS_EXT_ARGB:
+    extxrgb_h2v1_merged_upsample_internal(cinfo, input_buf, in_row_group_ctr,
+                                          output_buf);
+    break;
+  default:
+    h2v1_merged_upsample_internal(cinfo, input_buf, in_row_group_ctr,
+                                  output_buf);
+    break;
+  }
+}
+
+
+/*
+ * Upsample and color convert for the case of 2:1 horizontal and 2:1 vertical.
+ */
+
+METHODDEF(void)
+h2v2_merged_upsample(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
+                     JDIMENSION in_row_group_ctr, JSAMPARRAY output_buf)
+{
+  switch (cinfo->out_color_space) {
+  case JCS_EXT_RGB:
+    extrgb_h2v2_merged_upsample_internal(cinfo, input_buf, in_row_group_ctr,
+                                         output_buf);
+    break;
+  case JCS_EXT_RGBX:
+  case JCS_EXT_RGBA:
+    extrgbx_h2v2_merged_upsample_internal(cinfo, input_buf, in_row_group_ctr,
+                                          output_buf);
+    break;
+  case JCS_EXT_BGR:
+    extbgr_h2v2_merged_upsample_internal(cinfo, input_buf, in_row_group_ctr,
+                                         output_buf);
+    break;
+  case JCS_EXT_BGRX:
+  case JCS_EXT_BGRA:
+    extbgrx_h2v2_merged_upsample_internal(cinfo, input_buf, in_row_group_ctr,
+                                          output_buf);
+    break;
+  case JCS_EXT_XBGR:
+  case JCS_EXT_ABGR:
+    extxbgr_h2v2_merged_upsample_internal(cinfo, input_buf, in_row_group_ctr,
+                                          output_buf);
+    break;
+  case JCS_EXT_XRGB:
+  case JCS_EXT_ARGB:
+    extxrgb_h2v2_merged_upsample_internal(cinfo, input_buf, in_row_group_ctr,
+                                          output_buf);
+    break;
+  default:
+    h2v2_merged_upsample_internal(cinfo, input_buf, in_row_group_ctr,
+                                  output_buf);
+    break;
+  }
+}
+
+
+/*
+ * RGB565 conversion
+ */
+
+#define PACK_SHORT_565_LE(r, g, b) \
+  ((((r) << 8) & 0xF800) | (((g) << 3) & 0x7E0) | ((b) >> 3))
+#define PACK_SHORT_565_BE(r, g, b) \
+  (((r) & 0xF8) | ((g) >> 5) | (((g) << 11) & 0xE000) | (((b) << 5) & 0x1F00))
+
+#define PACK_TWO_PIXELS_LE(l, r)    ((r << 16) | l)
+#define PACK_TWO_PIXELS_BE(l, r)    ((l << 16) | r)
+
+#define WRITE_TWO_PIXELS_LE(addr, pixels) { \
+  ((INT16 *)(addr))[0] = (INT16)(pixels); \
+  ((INT16 *)(addr))[1] = (INT16)((pixels) >> 16); \
+}
+#define WRITE_TWO_PIXELS_BE(addr, pixels) { \
+  ((INT16 *)(addr))[1] = (INT16)(pixels); \
+  ((INT16 *)(addr))[0] = (INT16)((pixels) >> 16); \
+}
+
+#define DITHER_565_R(r, dither)  ((r) + ((dither) & 0xFF))
+#define DITHER_565_G(g, dither)  ((g) + (((dither) & 0xFF) >> 1))
+#define DITHER_565_B(b, dither)  ((b) + ((dither) & 0xFF))
+
+
+/* Declarations for ordered dithering
+ *
+ * We use a 4x4 ordered dither array packed into 32 bits.  This array is
+ * sufficient for dithering RGB888 to RGB565.
+ */
+
+#define DITHER_MASK       0x3
+#define DITHER_ROTATE(x)  ((((x) & 0xFF) << 24) | (((x) >> 8) & 0x00FFFFFF))
+static const JLONG dither_matrix[4] = {
+  0x0008020A,
+  0x0C040E06,
+  0x030B0109,
+  0x0F070D05
+};
+
+
+/* Include inline routines for RGB565 conversion */
+
+#define PACK_SHORT_565  PACK_SHORT_565_LE
+#define PACK_TWO_PIXELS  PACK_TWO_PIXELS_LE
+#define WRITE_TWO_PIXELS  WRITE_TWO_PIXELS_LE
+#define h2v1_merged_upsample_565_internal  h2v1_merged_upsample_565_le
+#define h2v1_merged_upsample_565D_internal  h2v1_merged_upsample_565D_le
+#define h2v2_merged_upsample_565_internal  h2v2_merged_upsample_565_le
+#define h2v2_merged_upsample_565D_internal  h2v2_merged_upsample_565D_le
+#include "jdmrg565.c"
+#undef PACK_SHORT_565
+#undef PACK_TWO_PIXELS
+#undef WRITE_TWO_PIXELS
+#undef h2v1_merged_upsample_565_internal
+#undef h2v1_merged_upsample_565D_internal
+#undef h2v2_merged_upsample_565_internal
+#undef h2v2_merged_upsample_565D_internal
+
+#define PACK_SHORT_565  PACK_SHORT_565_BE
+#define PACK_TWO_PIXELS  PACK_TWO_PIXELS_BE
+#define WRITE_TWO_PIXELS  WRITE_TWO_PIXELS_BE
+#define h2v1_merged_upsample_565_internal  h2v1_merged_upsample_565_be
+#define h2v1_merged_upsample_565D_internal  h2v1_merged_upsample_565D_be
+#define h2v2_merged_upsample_565_internal  h2v2_merged_upsample_565_be
+#define h2v2_merged_upsample_565D_internal  h2v2_merged_upsample_565D_be
+#include "jdmrg565.c"
+#undef PACK_SHORT_565
+#undef PACK_TWO_PIXELS
+#undef WRITE_TWO_PIXELS
+#undef h2v1_merged_upsample_565_internal
+#undef h2v1_merged_upsample_565D_internal
+#undef h2v2_merged_upsample_565_internal
+#undef h2v2_merged_upsample_565D_internal
+
+
+static INLINE boolean is_big_endian(void)
+{
+  int test_value = 1;
+  if (*(char *)&test_value != 1)
+    return TRUE;
+  return FALSE;
+}
+
+
+METHODDEF(void)
+h2v1_merged_upsample_565(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
+                         JDIMENSION in_row_group_ctr, JSAMPARRAY output_buf)
+{
+  if (is_big_endian())
+    h2v1_merged_upsample_565_be(cinfo, input_buf, in_row_group_ctr,
+                                output_buf);
+  else
+    h2v1_merged_upsample_565_le(cinfo, input_buf, in_row_group_ctr,
+                                output_buf);
+}
+
+
+METHODDEF(void)
+h2v1_merged_upsample_565D(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
+                          JDIMENSION in_row_group_ctr, JSAMPARRAY output_buf)
+{
+  if (is_big_endian())
+    h2v1_merged_upsample_565D_be(cinfo, input_buf, in_row_group_ctr,
+                                 output_buf);
+  else
+    h2v1_merged_upsample_565D_le(cinfo, input_buf, in_row_group_ctr,
+                                 output_buf);
+}
+
+
+METHODDEF(void)
+h2v2_merged_upsample_565(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
+                         JDIMENSION in_row_group_ctr, JSAMPARRAY output_buf)
+{
+  if (is_big_endian())
+    h2v2_merged_upsample_565_be(cinfo, input_buf, in_row_group_ctr,
+                                output_buf);
+  else
+    h2v2_merged_upsample_565_le(cinfo, input_buf, in_row_group_ctr,
+                                output_buf);
+}
+
+
+METHODDEF(void)
+h2v2_merged_upsample_565D(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
+                          JDIMENSION in_row_group_ctr, JSAMPARRAY output_buf)
+{
+  if (is_big_endian())
+    h2v2_merged_upsample_565D_be(cinfo, input_buf, in_row_group_ctr,
+                                 output_buf);
+  else
+    h2v2_merged_upsample_565D_le(cinfo, input_buf, in_row_group_ctr,
+                                 output_buf);
+}
+
+
+/*
+ * Module initialization routine for merged upsampling/color conversion.
+ *
+ * NB: this is called under the conditions determined by use_merged_upsample()
+ * in jdmaster.c.  That routine MUST correspond to the actual capabilities
+ * of this module; no safety checks are made here.
+ */
+
+GLOBAL(void)
+jinit_merged_upsampler(j_decompress_ptr cinfo)
+{
+  my_merged_upsample_ptr upsample;
+
+  upsample = (my_merged_upsample_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+                                sizeof(my_merged_upsampler));
+  cinfo->upsample = (struct jpeg_upsampler *)upsample;
+  upsample->pub.start_pass = start_pass_merged_upsample;
+  upsample->pub.need_context_rows = FALSE;
+
+  upsample->out_row_width = cinfo->output_width * cinfo->out_color_components;
+
+  if (cinfo->max_v_samp_factor == 2) {
+    upsample->pub.upsample = merged_2v_upsample;
+    if (jsimd_can_h2v2_merged_upsample())
+      upsample->upmethod = jsimd_h2v2_merged_upsample;
+    else
+      upsample->upmethod = h2v2_merged_upsample;
+    if (cinfo->out_color_space == JCS_RGB565) {
+      if (cinfo->dither_mode != JDITHER_NONE) {
+        upsample->upmethod = h2v2_merged_upsample_565D;
+      } else {
+        upsample->upmethod = h2v2_merged_upsample_565;
+      }
+    }
+    /* Allocate a spare row buffer */
+    upsample->spare_row = (JSAMPROW)
+      (*cinfo->mem->alloc_large) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+                (size_t)(upsample->out_row_width * sizeof(JSAMPLE)));
+  } else {
+    upsample->pub.upsample = merged_1v_upsample;
+    if (jsimd_can_h2v1_merged_upsample())
+      upsample->upmethod = jsimd_h2v1_merged_upsample;
+    else
+      upsample->upmethod = h2v1_merged_upsample;
+    if (cinfo->out_color_space == JCS_RGB565) {
+      if (cinfo->dither_mode != JDITHER_NONE) {
+        upsample->upmethod = h2v1_merged_upsample_565D;
+      } else {
+        upsample->upmethod = h2v1_merged_upsample_565;
+      }
+    }
+    /* No spare row needed */
+    upsample->spare_row = NULL;
+  }
+
+  build_ycc_rgb_table(cinfo);
+}
+
+#endif /* UPSAMPLE_MERGING_SUPPORTED */
diff --git a/3rdparty/libjpeg/src/jdmerge.h b/3rdparty/libjpeg/src/jdmerge.h
new file mode 100644
index 00000000..b583396b
--- /dev/null
+++ b/3rdparty/libjpeg/src/jdmerge.h
@@ -0,0 +1,47 @@
+/*
+ * jdmerge.h
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1994-1996, Thomas G. Lane.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2020, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ */
+
+#define JPEG_INTERNALS
+#include "jpeglib.h"
+
+#ifdef UPSAMPLE_MERGING_SUPPORTED
+
+
+/* Private subobject */
+
+typedef struct {
+  struct jpeg_upsampler pub;    /* public fields */
+
+  /* Pointer to routine to do actual upsampling/conversion of one row group */
+  void (*upmethod) (j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
+                    JDIMENSION in_row_group_ctr, JSAMPARRAY output_buf);
+
+  /* Private state for YCC->RGB conversion */
+  int *Cr_r_tab;                /* => table for Cr to R conversion */
+  int *Cb_b_tab;                /* => table for Cb to B conversion */
+  JLONG *Cr_g_tab;              /* => table for Cr to G conversion */
+  JLONG *Cb_g_tab;              /* => table for Cb to G conversion */
+
+  /* For 2:1 vertical sampling, we produce two output rows at a time.
+   * We need a "spare" row buffer to hold the second output row if the
+   * application provides just a one-row buffer; we also use the spare
+   * to discard the dummy last row if the image height is odd.
+   */
+  JSAMPROW spare_row;
+  boolean spare_full;           /* T if spare buffer is occupied */
+
+  JDIMENSION out_row_width;     /* samples per output row */
+  JDIMENSION rows_to_go;        /* counts rows remaining in image */
+} my_merged_upsampler;
+
+typedef my_merged_upsampler *my_merged_upsample_ptr;
+
+#endif /* UPSAMPLE_MERGING_SUPPORTED */
diff --git a/3rdparty/libjpeg/src/jdmrg565.c b/3rdparty/libjpeg/src/jdmrg565.c
new file mode 100644
index 00000000..980a4e21
--- /dev/null
+++ b/3rdparty/libjpeg/src/jdmrg565.c
@@ -0,0 +1,354 @@
+/*
+ * jdmrg565.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1994-1996, Thomas G. Lane.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2013, Linaro Limited.
+ * Copyright (C) 2014-2015, 2018, 2020, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains code for merged upsampling/color conversion.
+ */
+
+
+INLINE
+LOCAL(void)
+h2v1_merged_upsample_565_internal(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
+                                  JDIMENSION in_row_group_ctr,
+                                  JSAMPARRAY output_buf)
+{
+  my_merged_upsample_ptr upsample = (my_merged_upsample_ptr)cinfo->upsample;
+  register int y, cred, cgreen, cblue;
+  int cb, cr;
+  register JSAMPROW outptr;
+  JSAMPROW inptr0, inptr1, inptr2;
+  JDIMENSION col;
+  /* copy these pointers into registers if possible */
+  register JSAMPLE *range_limit = cinfo->sample_range_limit;
+  int *Crrtab = upsample->Cr_r_tab;
+  int *Cbbtab = upsample->Cb_b_tab;
+  JLONG *Crgtab = upsample->Cr_g_tab;
+  JLONG *Cbgtab = upsample->Cb_g_tab;
+  unsigned int r, g, b;
+  JLONG rgb;
+  SHIFT_TEMPS
+
+  inptr0 = input_buf[0][in_row_group_ctr];
+  inptr1 = input_buf[1][in_row_group_ctr];
+  inptr2 = input_buf[2][in_row_group_ctr];
+  outptr = output_buf[0];
+
+  /* Loop for each pair of output pixels */
+  for (col = cinfo->output_width >> 1; col > 0; col--) {
+    /* Do the chroma part of the calculation */
+    cb = *inptr1++;
+    cr = *inptr2++;
+    cred = Crrtab[cr];
+    cgreen = (int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS);
+    cblue = Cbbtab[cb];
+
+    /* Fetch 2 Y values and emit 2 pixels */
+    y  = *inptr0++;
+    r = range_limit[y + cred];
+    g = range_limit[y + cgreen];
+    b = range_limit[y + cblue];
+    rgb = PACK_SHORT_565(r, g, b);
+
+    y  = *inptr0++;
+    r = range_limit[y + cred];
+    g = range_limit[y + cgreen];
+    b = range_limit[y + cblue];
+    rgb = PACK_TWO_PIXELS(rgb, PACK_SHORT_565(r, g, b));
+
+    WRITE_TWO_PIXELS(outptr, rgb);
+    outptr += 4;
+  }
+
+  /* If image width is odd, do the last output column separately */
+  if (cinfo->output_width & 1) {
+    cb = *inptr1;
+    cr = *inptr2;
+    cred = Crrtab[cr];
+    cgreen = (int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS);
+    cblue = Cbbtab[cb];
+    y  = *inptr0;
+    r = range_limit[y + cred];
+    g = range_limit[y + cgreen];
+    b = range_limit[y + cblue];
+    rgb = PACK_SHORT_565(r, g, b);
+    *(INT16 *)outptr = (INT16)rgb;
+  }
+}
+
+
+INLINE
+LOCAL(void)
+h2v1_merged_upsample_565D_internal(j_decompress_ptr cinfo,
+                                   JSAMPIMAGE input_buf,
+                                   JDIMENSION in_row_group_ctr,
+                                   JSAMPARRAY output_buf)
+{
+  my_merged_upsample_ptr upsample = (my_merged_upsample_ptr)cinfo->upsample;
+  register int y, cred, cgreen, cblue;
+  int cb, cr;
+  register JSAMPROW outptr;
+  JSAMPROW inptr0, inptr1, inptr2;
+  JDIMENSION col;
+  /* copy these pointers into registers if possible */
+  register JSAMPLE *range_limit = cinfo->sample_range_limit;
+  int *Crrtab = upsample->Cr_r_tab;
+  int *Cbbtab = upsample->Cb_b_tab;
+  JLONG *Crgtab = upsample->Cr_g_tab;
+  JLONG *Cbgtab = upsample->Cb_g_tab;
+  JLONG d0 = dither_matrix[cinfo->output_scanline & DITHER_MASK];
+  unsigned int r, g, b;
+  JLONG rgb;
+  SHIFT_TEMPS
+
+  inptr0 = input_buf[0][in_row_group_ctr];
+  inptr1 = input_buf[1][in_row_group_ctr];
+  inptr2 = input_buf[2][in_row_group_ctr];
+  outptr = output_buf[0];
+
+  /* Loop for each pair of output pixels */
+  for (col = cinfo->output_width >> 1; col > 0; col--) {
+    /* Do the chroma part of the calculation */
+    cb = *inptr1++;
+    cr = *inptr2++;
+    cred = Crrtab[cr];
+    cgreen = (int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS);
+    cblue = Cbbtab[cb];
+
+    /* Fetch 2 Y values and emit 2 pixels */
+    y  = *inptr0++;
+    r = range_limit[DITHER_565_R(y + cred, d0)];
+    g = range_limit[DITHER_565_G(y + cgreen, d0)];
+    b = range_limit[DITHER_565_B(y + cblue, d0)];
+    d0 = DITHER_ROTATE(d0);
+    rgb = PACK_SHORT_565(r, g, b);
+
+    y  = *inptr0++;
+    r = range_limit[DITHER_565_R(y + cred, d0)];
+    g = range_limit[DITHER_565_G(y + cgreen, d0)];
+    b = range_limit[DITHER_565_B(y + cblue, d0)];
+    d0 = DITHER_ROTATE(d0);
+    rgb = PACK_TWO_PIXELS(rgb, PACK_SHORT_565(r, g, b));
+
+    WRITE_TWO_PIXELS(outptr, rgb);
+    outptr += 4;
+  }
+
+  /* If image width is odd, do the last output column separately */
+  if (cinfo->output_width & 1) {
+    cb = *inptr1;
+    cr = *inptr2;
+    cred = Crrtab[cr];
+    cgreen = (int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS);
+    cblue = Cbbtab[cb];
+    y  = *inptr0;
+    r = range_limit[DITHER_565_R(y + cred, d0)];
+    g = range_limit[DITHER_565_G(y + cgreen, d0)];
+    b = range_limit[DITHER_565_B(y + cblue, d0)];
+    rgb = PACK_SHORT_565(r, g, b);
+    *(INT16 *)outptr = (INT16)rgb;
+  }
+}
+
+
+INLINE
+LOCAL(void)
+h2v2_merged_upsample_565_internal(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
+                                  JDIMENSION in_row_group_ctr,
+                                  JSAMPARRAY output_buf)
+{
+  my_merged_upsample_ptr upsample = (my_merged_upsample_ptr)cinfo->upsample;
+  register int y, cred, cgreen, cblue;
+  int cb, cr;
+  register JSAMPROW outptr0, outptr1;
+  JSAMPROW inptr00, inptr01, inptr1, inptr2;
+  JDIMENSION col;
+  /* copy these pointers into registers if possible */
+  register JSAMPLE *range_limit = cinfo->sample_range_limit;
+  int *Crrtab = upsample->Cr_r_tab;
+  int *Cbbtab = upsample->Cb_b_tab;
+  JLONG *Crgtab = upsample->Cr_g_tab;
+  JLONG *Cbgtab = upsample->Cb_g_tab;
+  unsigned int r, g, b;
+  JLONG rgb;
+  SHIFT_TEMPS
+
+  inptr00 = input_buf[0][in_row_group_ctr * 2];
+  inptr01 = input_buf[0][in_row_group_ctr * 2 + 1];
+  inptr1 = input_buf[1][in_row_group_ctr];
+  inptr2 = input_buf[2][in_row_group_ctr];
+  outptr0 = output_buf[0];
+  outptr1 = output_buf[1];
+
+  /* Loop for each group of output pixels */
+  for (col = cinfo->output_width >> 1; col > 0; col--) {
+    /* Do the chroma part of the calculation */
+    cb = *inptr1++;
+    cr = *inptr2++;
+    cred = Crrtab[cr];
+    cgreen = (int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS);
+    cblue = Cbbtab[cb];
+
+    /* Fetch 4 Y values and emit 4 pixels */
+    y  = *inptr00++;
+    r = range_limit[y + cred];
+    g = range_limit[y + cgreen];
+    b = range_limit[y + cblue];
+    rgb = PACK_SHORT_565(r, g, b);
+
+    y  = *inptr00++;
+    r = range_limit[y + cred];
+    g = range_limit[y + cgreen];
+    b = range_limit[y + cblue];
+    rgb = PACK_TWO_PIXELS(rgb, PACK_SHORT_565(r, g, b));
+
+    WRITE_TWO_PIXELS(outptr0, rgb);
+    outptr0 += 4;
+
+    y  = *inptr01++;
+    r = range_limit[y + cred];
+    g = range_limit[y + cgreen];
+    b = range_limit[y + cblue];
+    rgb = PACK_SHORT_565(r, g, b);
+
+    y  = *inptr01++;
+    r = range_limit[y + cred];
+    g = range_limit[y + cgreen];
+    b = range_limit[y + cblue];
+    rgb = PACK_TWO_PIXELS(rgb, PACK_SHORT_565(r, g, b));
+
+    WRITE_TWO_PIXELS(outptr1, rgb);
+    outptr1 += 4;
+  }
+
+  /* If image width is odd, do the last output column separately */
+  if (cinfo->output_width & 1) {
+    cb = *inptr1;
+    cr = *inptr2;
+    cred = Crrtab[cr];
+    cgreen = (int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS);
+    cblue = Cbbtab[cb];
+
+    y  = *inptr00;
+    r = range_limit[y + cred];
+    g = range_limit[y + cgreen];
+    b = range_limit[y + cblue];
+    rgb = PACK_SHORT_565(r, g, b);
+    *(INT16 *)outptr0 = (INT16)rgb;
+
+    y  = *inptr01;
+    r = range_limit[y + cred];
+    g = range_limit[y + cgreen];
+    b = range_limit[y + cblue];
+    rgb = PACK_SHORT_565(r, g, b);
+    *(INT16 *)outptr1 = (INT16)rgb;
+  }
+}
+
+
+INLINE
+LOCAL(void)
+h2v2_merged_upsample_565D_internal(j_decompress_ptr cinfo,
+                                   JSAMPIMAGE input_buf,
+                                   JDIMENSION in_row_group_ctr,
+                                   JSAMPARRAY output_buf)
+{
+  my_merged_upsample_ptr upsample = (my_merged_upsample_ptr)cinfo->upsample;
+  register int y, cred, cgreen, cblue;
+  int cb, cr;
+  register JSAMPROW outptr0, outptr1;
+  JSAMPROW inptr00, inptr01, inptr1, inptr2;
+  JDIMENSION col;
+  /* copy these pointers into registers if possible */
+  register JSAMPLE *range_limit = cinfo->sample_range_limit;
+  int *Crrtab = upsample->Cr_r_tab;
+  int *Cbbtab = upsample->Cb_b_tab;
+  JLONG *Crgtab = upsample->Cr_g_tab;
+  JLONG *Cbgtab = upsample->Cb_g_tab;
+  JLONG d0 = dither_matrix[cinfo->output_scanline & DITHER_MASK];
+  JLONG d1 = dither_matrix[(cinfo->output_scanline + 1) & DITHER_MASK];
+  unsigned int r, g, b;
+  JLONG rgb;
+  SHIFT_TEMPS
+
+  inptr00 = input_buf[0][in_row_group_ctr * 2];
+  inptr01 = input_buf[0][in_row_group_ctr * 2 + 1];
+  inptr1 = input_buf[1][in_row_group_ctr];
+  inptr2 = input_buf[2][in_row_group_ctr];
+  outptr0 = output_buf[0];
+  outptr1 = output_buf[1];
+
+  /* Loop for each group of output pixels */
+  for (col = cinfo->output_width >> 1; col > 0; col--) {
+    /* Do the chroma part of the calculation */
+    cb = *inptr1++;
+    cr = *inptr2++;
+    cred = Crrtab[cr];
+    cgreen = (int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS);
+    cblue = Cbbtab[cb];
+
+    /* Fetch 4 Y values and emit 4 pixels */
+    y  = *inptr00++;
+    r = range_limit[DITHER_565_R(y + cred, d0)];
+    g = range_limit[DITHER_565_G(y + cgreen, d0)];
+    b = range_limit[DITHER_565_B(y + cblue, d0)];
+    d0 = DITHER_ROTATE(d0);
+    rgb = PACK_SHORT_565(r, g, b);
+
+    y  = *inptr00++;
+    r = range_limit[DITHER_565_R(y + cred, d0)];
+    g = range_limit[DITHER_565_G(y + cgreen, d0)];
+    b = range_limit[DITHER_565_B(y + cblue, d0)];
+    d0 = DITHER_ROTATE(d0);
+    rgb = PACK_TWO_PIXELS(rgb, PACK_SHORT_565(r, g, b));
+
+    WRITE_TWO_PIXELS(outptr0, rgb);
+    outptr0 += 4;
+
+    y  = *inptr01++;
+    r = range_limit[DITHER_565_R(y + cred, d1)];
+    g = range_limit[DITHER_565_G(y + cgreen, d1)];
+    b = range_limit[DITHER_565_B(y + cblue, d1)];
+    d1 = DITHER_ROTATE(d1);
+    rgb = PACK_SHORT_565(r, g, b);
+
+    y  = *inptr01++;
+    r = range_limit[DITHER_565_R(y + cred, d1)];
+    g = range_limit[DITHER_565_G(y + cgreen, d1)];
+    b = range_limit[DITHER_565_B(y + cblue, d1)];
+    d1 = DITHER_ROTATE(d1);
+    rgb = PACK_TWO_PIXELS(rgb, PACK_SHORT_565(r, g, b));
+
+    WRITE_TWO_PIXELS(outptr1, rgb);
+    outptr1 += 4;
+  }
+
+  /* If image width is odd, do the last output column separately */
+  if (cinfo->output_width & 1) {
+    cb = *inptr1;
+    cr = *inptr2;
+    cred = Crrtab[cr];
+    cgreen = (int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS);
+    cblue = Cbbtab[cb];
+
+    y  = *inptr00;
+    r = range_limit[DITHER_565_R(y + cred, d0)];
+    g = range_limit[DITHER_565_G(y + cgreen, d0)];
+    b = range_limit[DITHER_565_B(y + cblue, d0)];
+    rgb = PACK_SHORT_565(r, g, b);
+    *(INT16 *)outptr0 = (INT16)rgb;
+
+    y  = *inptr01;
+    r = range_limit[DITHER_565_R(y + cred, d1)];
+    g = range_limit[DITHER_565_G(y + cgreen, d1)];
+    b = range_limit[DITHER_565_B(y + cblue, d1)];
+    rgb = PACK_SHORT_565(r, g, b);
+    *(INT16 *)outptr1 = (INT16)rgb;
+  }
+}
diff --git a/3rdparty/libjpeg/src/jdmrgext.c b/3rdparty/libjpeg/src/jdmrgext.c
new file mode 100644
index 00000000..9bf4f1a3
--- /dev/null
+++ b/3rdparty/libjpeg/src/jdmrgext.c
@@ -0,0 +1,184 @@
+/*
+ * jdmrgext.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1994-1996, Thomas G. Lane.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2011, 2015, 2020, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains code for merged upsampling/color conversion.
+ */
+
+
+/* This file is included by jdmerge.c */
+
+
+/*
+ * Upsample and color convert for the case of 2:1 horizontal and 1:1 vertical.
+ */
+
+INLINE
+LOCAL(void)
+h2v1_merged_upsample_internal(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
+                              JDIMENSION in_row_group_ctr,
+                              JSAMPARRAY output_buf)
+{
+  my_merged_upsample_ptr upsample = (my_merged_upsample_ptr)cinfo->upsample;
+  register int y, cred, cgreen, cblue;
+  int cb, cr;
+  register JSAMPROW outptr;
+  JSAMPROW inptr0, inptr1, inptr2;
+  JDIMENSION col;
+  /* copy these pointers into registers if possible */
+  register JSAMPLE *range_limit = cinfo->sample_range_limit;
+  int *Crrtab = upsample->Cr_r_tab;
+  int *Cbbtab = upsample->Cb_b_tab;
+  JLONG *Crgtab = upsample->Cr_g_tab;
+  JLONG *Cbgtab = upsample->Cb_g_tab;
+  SHIFT_TEMPS
+
+  inptr0 = input_buf[0][in_row_group_ctr];
+  inptr1 = input_buf[1][in_row_group_ctr];
+  inptr2 = input_buf[2][in_row_group_ctr];
+  outptr = output_buf[0];
+  /* Loop for each pair of output pixels */
+  for (col = cinfo->output_width >> 1; col > 0; col--) {
+    /* Do the chroma part of the calculation */
+    cb = *inptr1++;
+    cr = *inptr2++;
+    cred = Crrtab[cr];
+    cgreen = (int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS);
+    cblue = Cbbtab[cb];
+    /* Fetch 2 Y values and emit 2 pixels */
+    y  = *inptr0++;
+    outptr[RGB_RED] =   range_limit[y + cred];
+    outptr[RGB_GREEN] = range_limit[y + cgreen];
+    outptr[RGB_BLUE] =  range_limit[y + cblue];
+#ifdef RGB_ALPHA
+    outptr[RGB_ALPHA] = 0xFF;
+#endif
+    outptr += RGB_PIXELSIZE;
+    y  = *inptr0++;
+    outptr[RGB_RED] =   range_limit[y + cred];
+    outptr[RGB_GREEN] = range_limit[y + cgreen];
+    outptr[RGB_BLUE] =  range_limit[y + cblue];
+#ifdef RGB_ALPHA
+    outptr[RGB_ALPHA] = 0xFF;
+#endif
+    outptr += RGB_PIXELSIZE;
+  }
+  /* If image width is odd, do the last output column separately */
+  if (cinfo->output_width & 1) {
+    cb = *inptr1;
+    cr = *inptr2;
+    cred = Crrtab[cr];
+    cgreen = (int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS);
+    cblue = Cbbtab[cb];
+    y  = *inptr0;
+    outptr[RGB_RED] =   range_limit[y + cred];
+    outptr[RGB_GREEN] = range_limit[y + cgreen];
+    outptr[RGB_BLUE] =  range_limit[y + cblue];
+#ifdef RGB_ALPHA
+    outptr[RGB_ALPHA] = 0xFF;
+#endif
+  }
+}
+
+
+/*
+ * Upsample and color convert for the case of 2:1 horizontal and 2:1 vertical.
+ */
+
+INLINE
+LOCAL(void)
+h2v2_merged_upsample_internal(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
+                              JDIMENSION in_row_group_ctr,
+                              JSAMPARRAY output_buf)
+{
+  my_merged_upsample_ptr upsample = (my_merged_upsample_ptr)cinfo->upsample;
+  register int y, cred, cgreen, cblue;
+  int cb, cr;
+  register JSAMPROW outptr0, outptr1;
+  JSAMPROW inptr00, inptr01, inptr1, inptr2;
+  JDIMENSION col;
+  /* copy these pointers into registers if possible */
+  register JSAMPLE *range_limit = cinfo->sample_range_limit;
+  int *Crrtab = upsample->Cr_r_tab;
+  int *Cbbtab = upsample->Cb_b_tab;
+  JLONG *Crgtab = upsample->Cr_g_tab;
+  JLONG *Cbgtab = upsample->Cb_g_tab;
+  SHIFT_TEMPS
+
+  inptr00 = input_buf[0][in_row_group_ctr * 2];
+  inptr01 = input_buf[0][in_row_group_ctr * 2 + 1];
+  inptr1 = input_buf[1][in_row_group_ctr];
+  inptr2 = input_buf[2][in_row_group_ctr];
+  outptr0 = output_buf[0];
+  outptr1 = output_buf[1];
+  /* Loop for each group of output pixels */
+  for (col = cinfo->output_width >> 1; col > 0; col--) {
+    /* Do the chroma part of the calculation */
+    cb = *inptr1++;
+    cr = *inptr2++;
+    cred = Crrtab[cr];
+    cgreen = (int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS);
+    cblue = Cbbtab[cb];
+    /* Fetch 4 Y values and emit 4 pixels */
+    y  = *inptr00++;
+    outptr0[RGB_RED] =   range_limit[y + cred];
+    outptr0[RGB_GREEN] = range_limit[y + cgreen];
+    outptr0[RGB_BLUE] =  range_limit[y + cblue];
+#ifdef RGB_ALPHA
+    outptr0[RGB_ALPHA] = 0xFF;
+#endif
+    outptr0 += RGB_PIXELSIZE;
+    y  = *inptr00++;
+    outptr0[RGB_RED] =   range_limit[y + cred];
+    outptr0[RGB_GREEN] = range_limit[y + cgreen];
+    outptr0[RGB_BLUE] =  range_limit[y + cblue];
+#ifdef RGB_ALPHA
+    outptr0[RGB_ALPHA] = 0xFF;
+#endif
+    outptr0 += RGB_PIXELSIZE;
+    y  = *inptr01++;
+    outptr1[RGB_RED] =   range_limit[y + cred];
+    outptr1[RGB_GREEN] = range_limit[y + cgreen];
+    outptr1[RGB_BLUE] =  range_limit[y + cblue];
+#ifdef RGB_ALPHA
+    outptr1[RGB_ALPHA] = 0xFF;
+#endif
+    outptr1 += RGB_PIXELSIZE;
+    y  = *inptr01++;
+    outptr1[RGB_RED] =   range_limit[y + cred];
+    outptr1[RGB_GREEN] = range_limit[y + cgreen];
+    outptr1[RGB_BLUE] =  range_limit[y + cblue];
+#ifdef RGB_ALPHA
+    outptr1[RGB_ALPHA] = 0xFF;
+#endif
+    outptr1 += RGB_PIXELSIZE;
+  }
+  /* If image width is odd, do the last output column separately */
+  if (cinfo->output_width & 1) {
+    cb = *inptr1;
+    cr = *inptr2;
+    cred = Crrtab[cr];
+    cgreen = (int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS);
+    cblue = Cbbtab[cb];
+    y  = *inptr00;
+    outptr0[RGB_RED] =   range_limit[y + cred];
+    outptr0[RGB_GREEN] = range_limit[y + cgreen];
+    outptr0[RGB_BLUE] =  range_limit[y + cblue];
+#ifdef RGB_ALPHA
+    outptr0[RGB_ALPHA] = 0xFF;
+#endif
+    y  = *inptr01;
+    outptr1[RGB_RED] =   range_limit[y + cred];
+    outptr1[RGB_GREEN] = range_limit[y + cgreen];
+    outptr1[RGB_BLUE] =  range_limit[y + cblue];
+#ifdef RGB_ALPHA
+    outptr1[RGB_ALPHA] = 0xFF;
+#endif
+  }
+}
diff --git a/3rdparty/libjpeg/src/jdphuff.c b/3rdparty/libjpeg/src/jdphuff.c
new file mode 100644
index 00000000..cac45823
--- /dev/null
+++ b/3rdparty/libjpeg/src/jdphuff.c
@@ -0,0 +1,673 @@
+/*
+ * jdphuff.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1995-1997, Thomas G. Lane.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2015-2016, 2018-2020, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains Huffman entropy decoding routines for progressive JPEG.
+ *
+ * Much of the complexity here has to do with supporting input suspension.
+ * If the data source module demands suspension, we want to be able to back
+ * up to the start of the current MCU.  To do this, we copy state variables
+ * into local working storage, and update them back to the permanent
+ * storage only upon successful completion of an MCU.
+ *
+ * NOTE: All referenced figures are from
+ * Recommendation ITU-T T.81 (1992) | ISO/IEC 10918-1:1994.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jdhuff.h"             /* Declarations shared with jdhuff.c */
+#include <limits.h>
+
+
+#ifdef D_PROGRESSIVE_SUPPORTED
+
+/*
+ * Expanded entropy decoder object for progressive Huffman decoding.
+ *
+ * The savable_state subrecord contains fields that change within an MCU,
+ * but must not be updated permanently until we complete the MCU.
+ */
+
+typedef struct {
+  unsigned int EOBRUN;                  /* remaining EOBs in EOBRUN */
+  int last_dc_val[MAX_COMPS_IN_SCAN];   /* last DC coef for each component */
+} savable_state;
+
+typedef struct {
+  struct jpeg_entropy_decoder pub; /* public fields */
+
+  /* These fields are loaded into local variables at start of each MCU.
+   * In case of suspension, we exit WITHOUT updating them.
+   */
+  bitread_perm_state bitstate;  /* Bit buffer at start of MCU */
+  savable_state saved;          /* Other state at start of MCU */
+
+  /* These fields are NOT loaded into local working state. */
+  unsigned int restarts_to_go;  /* MCUs left in this restart interval */
+
+  /* Pointers to derived tables (these workspaces have image lifespan) */
+  d_derived_tbl *derived_tbls[NUM_HUFF_TBLS];
+
+  d_derived_tbl *ac_derived_tbl; /* active table during an AC scan */
+} phuff_entropy_decoder;
+
+typedef phuff_entropy_decoder *phuff_entropy_ptr;
+
+/* Forward declarations */
+METHODDEF(boolean) decode_mcu_DC_first(j_decompress_ptr cinfo,
+                                       JBLOCKROW *MCU_data);
+METHODDEF(boolean) decode_mcu_AC_first(j_decompress_ptr cinfo,
+                                       JBLOCKROW *MCU_data);
+METHODDEF(boolean) decode_mcu_DC_refine(j_decompress_ptr cinfo,
+                                        JBLOCKROW *MCU_data);
+METHODDEF(boolean) decode_mcu_AC_refine(j_decompress_ptr cinfo,
+                                        JBLOCKROW *MCU_data);
+
+
+/*
+ * Initialize for a Huffman-compressed scan.
+ */
+
+METHODDEF(void)
+start_pass_phuff_decoder(j_decompress_ptr cinfo)
+{
+  phuff_entropy_ptr entropy = (phuff_entropy_ptr)cinfo->entropy;
+  boolean is_DC_band, bad;
+  int ci, coefi, tbl;
+  d_derived_tbl **pdtbl;
+  int *coef_bit_ptr, *prev_coef_bit_ptr;
+  jpeg_component_info *compptr;
+
+  is_DC_band = (cinfo->Ss == 0);
+
+  /* Validate scan parameters */
+  bad = FALSE;
+  if (is_DC_band) {
+    if (cinfo->Se != 0)
+      bad = TRUE;
+  } else {
+    /* need not check Ss/Se < 0 since they came from unsigned bytes */
+    if (cinfo->Ss > cinfo->Se || cinfo->Se >= DCTSIZE2)
+      bad = TRUE;
+    /* AC scans may have only one component */
+    if (cinfo->comps_in_scan != 1)
+      bad = TRUE;
+  }
+  if (cinfo->Ah != 0) {
+    /* Successive approximation refinement scan: must have Al = Ah-1. */
+    if (cinfo->Al != cinfo->Ah - 1)
+      bad = TRUE;
+  }
+  if (cinfo->Al > 13)           /* need not check for < 0 */
+    bad = TRUE;
+  /* Arguably the maximum Al value should be less than 13 for 8-bit precision,
+   * but the spec doesn't say so, and we try to be liberal about what we
+   * accept.  Note: large Al values could result in out-of-range DC
+   * coefficients during early scans, leading to bizarre displays due to
+   * overflows in the IDCT math.  But we won't crash.
+   */
+  if (bad)
+    ERREXIT4(cinfo, JERR_BAD_PROGRESSION,
+             cinfo->Ss, cinfo->Se, cinfo->Ah, cinfo->Al);
+  /* Update progression status, and verify that scan order is legal.
+   * Note that inter-scan inconsistencies are treated as warnings
+   * not fatal errors ... not clear if this is right way to behave.
+   */
+  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+    int cindex = cinfo->cur_comp_info[ci]->component_index;
+    coef_bit_ptr = &cinfo->coef_bits[cindex][0];
+    prev_coef_bit_ptr = &cinfo->coef_bits[cindex + cinfo->num_components][0];
+    if (!is_DC_band && coef_bit_ptr[0] < 0) /* AC without prior DC scan */
+      WARNMS2(cinfo, JWRN_BOGUS_PROGRESSION, cindex, 0);
+    for (coefi = MIN(cinfo->Ss, 1); coefi <= MAX(cinfo->Se, 9); coefi++) {
+      if (cinfo->input_scan_number > 1)
+        prev_coef_bit_ptr[coefi] = coef_bit_ptr[coefi];
+    }
+    for (coefi = cinfo->Ss; coefi <= cinfo->Se; coefi++) {
+      int expected = (coef_bit_ptr[coefi] < 0) ? 0 : coef_bit_ptr[coefi];
+      if (cinfo->Ah != expected)
+        WARNMS2(cinfo, JWRN_BOGUS_PROGRESSION, cindex, coefi);
+      coef_bit_ptr[coefi] = cinfo->Al;
+    }
+  }
+
+  /* Select MCU decoding routine */
+  if (cinfo->Ah == 0) {
+    if (is_DC_band)
+      entropy->pub.decode_mcu = decode_mcu_DC_first;
+    else
+      entropy->pub.decode_mcu = decode_mcu_AC_first;
+  } else {
+    if (is_DC_band)
+      entropy->pub.decode_mcu = decode_mcu_DC_refine;
+    else
+      entropy->pub.decode_mcu = decode_mcu_AC_refine;
+  }
+
+  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+    compptr = cinfo->cur_comp_info[ci];
+    /* Make sure requested tables are present, and compute derived tables.
+     * We may build same derived table more than once, but it's not expensive.
+     */
+    if (is_DC_band) {
+      if (cinfo->Ah == 0) {     /* DC refinement needs no table */
+        tbl = compptr->dc_tbl_no;
+        pdtbl = (d_derived_tbl **)(entropy->derived_tbls) + tbl;
+        jpeg_make_d_derived_tbl(cinfo, TRUE, tbl, pdtbl);
+      }
+    } else {
+      tbl = compptr->ac_tbl_no;
+      pdtbl = (d_derived_tbl **)(entropy->derived_tbls) + tbl;
+      jpeg_make_d_derived_tbl(cinfo, FALSE, tbl, pdtbl);
+      /* remember the single active table */
+      entropy->ac_derived_tbl = entropy->derived_tbls[tbl];
+    }
+    /* Initialize DC predictions to 0 */
+    entropy->saved.last_dc_val[ci] = 0;
+  }
+
+  /* Initialize bitread state variables */
+  entropy->bitstate.bits_left = 0;
+  entropy->bitstate.get_buffer = 0; /* unnecessary, but keeps Purify quiet */
+  entropy->pub.insufficient_data = FALSE;
+
+  /* Initialize private state variables */
+  entropy->saved.EOBRUN = 0;
+
+  /* Initialize restart counter */
+  entropy->restarts_to_go = cinfo->restart_interval;
+}
+
+
+/*
+ * Figure F.12: extend sign bit.
+ * On some machines, a shift and add will be faster than a table lookup.
+ */
+
+#define AVOID_TABLES
+#ifdef AVOID_TABLES
+
+#define NEG_1  ((unsigned)-1)
+#define HUFF_EXTEND(x, s) \
+  ((x) < (1 << ((s) - 1)) ? (x) + (((NEG_1) << (s)) + 1) : (x))
+
+#else
+
+#define HUFF_EXTEND(x, s) \
+  ((x) < extend_test[s] ? (x) + extend_offset[s] : (x))
+
+static const int extend_test[16] = {   /* entry n is 2**(n-1) */
+  0, 0x0001, 0x0002, 0x0004, 0x0008, 0x0010, 0x0020, 0x0040, 0x0080,
+  0x0100, 0x0200, 0x0400, 0x0800, 0x1000, 0x2000, 0x4000
+};
+
+static const int extend_offset[16] = { /* entry n is (-1 << n) + 1 */
+  0, ((-1) << 1) + 1, ((-1) << 2) + 1, ((-1) << 3) + 1, ((-1) << 4) + 1,
+  ((-1) << 5) + 1, ((-1) << 6) + 1, ((-1) << 7) + 1, ((-1) << 8) + 1,
+  ((-1) << 9) + 1, ((-1) << 10) + 1, ((-1) << 11) + 1, ((-1) << 12) + 1,
+  ((-1) << 13) + 1, ((-1) << 14) + 1, ((-1) << 15) + 1
+};
+
+#endif /* AVOID_TABLES */
+
+
+/*
+ * Check for a restart marker & resynchronize decoder.
+ * Returns FALSE if must suspend.
+ */
+
+LOCAL(boolean)
+process_restart(j_decompress_ptr cinfo)
+{
+  phuff_entropy_ptr entropy = (phuff_entropy_ptr)cinfo->entropy;
+  int ci;
+
+  /* Throw away any unused bits remaining in bit buffer; */
+  /* include any full bytes in next_marker's count of discarded bytes */
+  cinfo->marker->discarded_bytes += entropy->bitstate.bits_left / 8;
+  entropy->bitstate.bits_left = 0;
+
+  /* Advance past the RSTn marker */
+  if (!(*cinfo->marker->read_restart_marker) (cinfo))
+    return FALSE;
+
+  /* Re-initialize DC predictions to 0 */
+  for (ci = 0; ci < cinfo->comps_in_scan; ci++)
+    entropy->saved.last_dc_val[ci] = 0;
+  /* Re-init EOB run count, too */
+  entropy->saved.EOBRUN = 0;
+
+  /* Reset restart counter */
+  entropy->restarts_to_go = cinfo->restart_interval;
+
+  /* Reset out-of-data flag, unless read_restart_marker left us smack up
+   * against a marker.  In that case we will end up treating the next data
+   * segment as empty, and we can avoid producing bogus output pixels by
+   * leaving the flag set.
+   */
+  if (cinfo->unread_marker == 0)
+    entropy->pub.insufficient_data = FALSE;
+
+  return TRUE;
+}
+
+
+/*
+ * Huffman MCU decoding.
+ * Each of these routines decodes and returns one MCU's worth of
+ * Huffman-compressed coefficients.
+ * The coefficients are reordered from zigzag order into natural array order,
+ * but are not dequantized.
+ *
+ * The i'th block of the MCU is stored into the block pointed to by
+ * MCU_data[i].  WE ASSUME THIS AREA IS INITIALLY ZEROED BY THE CALLER.
+ *
+ * We return FALSE if data source requested suspension.  In that case no
+ * changes have been made to permanent state.  (Exception: some output
+ * coefficients may already have been assigned.  This is harmless for
+ * spectral selection, since we'll just re-assign them on the next call.
+ * Successive approximation AC refinement has to be more careful, however.)
+ */
+
+/*
+ * MCU decoding for DC initial scan (either spectral selection,
+ * or first pass of successive approximation).
+ */
+
+METHODDEF(boolean)
+decode_mcu_DC_first(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
+{
+  phuff_entropy_ptr entropy = (phuff_entropy_ptr)cinfo->entropy;
+  int Al = cinfo->Al;
+  register int s, r;
+  int blkn, ci;
+  JBLOCKROW block;
+  BITREAD_STATE_VARS;
+  savable_state state;
+  d_derived_tbl *tbl;
+  jpeg_component_info *compptr;
+
+  /* Process restart marker if needed; may have to suspend */
+  if (cinfo->restart_interval) {
+    if (entropy->restarts_to_go == 0)
+      if (!process_restart(cinfo))
+        return FALSE;
+  }
+
+  /* If we've run out of data, just leave the MCU set to zeroes.
+   * This way, we return uniform gray for the remainder of the segment.
+   */
+  if (!entropy->pub.insufficient_data) {
+
+    /* Load up working state */
+    BITREAD_LOAD_STATE(cinfo, entropy->bitstate);
+    state = entropy->saved;
+
+    /* Outer loop handles each block in the MCU */
+
+    for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
+      block = MCU_data[blkn];
+      ci = cinfo->MCU_membership[blkn];
+      compptr = cinfo->cur_comp_info[ci];
+      tbl = entropy->derived_tbls[compptr->dc_tbl_no];
+
+      /* Decode a single block's worth of coefficients */
+
+      /* Section F.2.2.1: decode the DC coefficient difference */
+      HUFF_DECODE(s, br_state, tbl, return FALSE, label1);
+      if (s) {
+        CHECK_BIT_BUFFER(br_state, s, return FALSE);
+        r = GET_BITS(s);
+        s = HUFF_EXTEND(r, s);
+      }
+
+      /* Convert DC difference to actual value, update last_dc_val */
+      if ((state.last_dc_val[ci] >= 0 &&
+           s > INT_MAX - state.last_dc_val[ci]) ||
+          (state.last_dc_val[ci] < 0 && s < INT_MIN - state.last_dc_val[ci]))
+        ERREXIT(cinfo, JERR_BAD_DCT_COEF);
+      s += state.last_dc_val[ci];
+      state.last_dc_val[ci] = s;
+      /* Scale and output the coefficient (assumes jpeg_natural_order[0]=0) */
+      (*block)[0] = (JCOEF)LEFT_SHIFT(s, Al);
+    }
+
+    /* Completed MCU, so update state */
+    BITREAD_SAVE_STATE(cinfo, entropy->bitstate);
+    entropy->saved = state;
+  }
+
+  /* Account for restart interval (no-op if not using restarts) */
+  entropy->restarts_to_go--;
+
+  return TRUE;
+}
+
+
+/*
+ * MCU decoding for AC initial scan (either spectral selection,
+ * or first pass of successive approximation).
+ */
+
+METHODDEF(boolean)
+decode_mcu_AC_first(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
+{
+  phuff_entropy_ptr entropy = (phuff_entropy_ptr)cinfo->entropy;
+  int Se = cinfo->Se;
+  int Al = cinfo->Al;
+  register int s, k, r;
+  unsigned int EOBRUN;
+  JBLOCKROW block;
+  BITREAD_STATE_VARS;
+  d_derived_tbl *tbl;
+
+  /* Process restart marker if needed; may have to suspend */
+  if (cinfo->restart_interval) {
+    if (entropy->restarts_to_go == 0)
+      if (!process_restart(cinfo))
+        return FALSE;
+  }
+
+  /* If we've run out of data, just leave the MCU set to zeroes.
+   * This way, we return uniform gray for the remainder of the segment.
+   */
+  if (!entropy->pub.insufficient_data) {
+
+    /* Load up working state.
+     * We can avoid loading/saving bitread state if in an EOB run.
+     */
+    EOBRUN = entropy->saved.EOBRUN;     /* only part of saved state we need */
+
+    /* There is always only one block per MCU */
+
+    if (EOBRUN > 0)             /* if it's a band of zeroes... */
+      EOBRUN--;                 /* ...process it now (we do nothing) */
+    else {
+      BITREAD_LOAD_STATE(cinfo, entropy->bitstate);
+      block = MCU_data[0];
+      tbl = entropy->ac_derived_tbl;
+
+      for (k = cinfo->Ss; k <= Se; k++) {
+        HUFF_DECODE(s, br_state, tbl, return FALSE, label2);
+        r = s >> 4;
+        s &= 15;
+        if (s) {
+          k += r;
+          CHECK_BIT_BUFFER(br_state, s, return FALSE);
+          r = GET_BITS(s);
+          s = HUFF_EXTEND(r, s);
+          /* Scale and output coefficient in natural (dezigzagged) order */
+          (*block)[jpeg_natural_order[k]] = (JCOEF)LEFT_SHIFT(s, Al);
+        } else {
+          if (r == 15) {        /* ZRL */
+            k += 15;            /* skip 15 zeroes in band */
+          } else {              /* EOBr, run length is 2^r + appended bits */
+            EOBRUN = 1 << r;
+            if (r) {            /* EOBr, r > 0 */
+              CHECK_BIT_BUFFER(br_state, r, return FALSE);
+              r = GET_BITS(r);
+              EOBRUN += r;
+            }
+            EOBRUN--;           /* this band is processed at this moment */
+            break;              /* force end-of-band */
+          }
+        }
+      }
+
+      BITREAD_SAVE_STATE(cinfo, entropy->bitstate);
+    }
+
+    /* Completed MCU, so update state */
+    entropy->saved.EOBRUN = EOBRUN;     /* only part of saved state we need */
+  }
+
+  /* Account for restart interval (no-op if not using restarts) */
+  entropy->restarts_to_go--;
+
+  return TRUE;
+}
+
+
+/*
+ * MCU decoding for DC successive approximation refinement scan.
+ * Note: we assume such scans can be multi-component, although the spec
+ * is not very clear on the point.
+ */
+
+METHODDEF(boolean)
+decode_mcu_DC_refine(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
+{
+  phuff_entropy_ptr entropy = (phuff_entropy_ptr)cinfo->entropy;
+  int p1 = 1 << cinfo->Al;      /* 1 in the bit position being coded */
+  int blkn;
+  JBLOCKROW block;
+  BITREAD_STATE_VARS;
+
+  /* Process restart marker if needed; may have to suspend */
+  if (cinfo->restart_interval) {
+    if (entropy->restarts_to_go == 0)
+      if (!process_restart(cinfo))
+        return FALSE;
+  }
+
+  /* Not worth the cycles to check insufficient_data here,
+   * since we will not change the data anyway if we read zeroes.
+   */
+
+  /* Load up working state */
+  BITREAD_LOAD_STATE(cinfo, entropy->bitstate);
+
+  /* Outer loop handles each block in the MCU */
+
+  for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
+    block = MCU_data[blkn];
+
+    /* Encoded data is simply the next bit of the two's-complement DC value */
+    CHECK_BIT_BUFFER(br_state, 1, return FALSE);
+    if (GET_BITS(1))
+      (*block)[0] |= p1;
+    /* Note: since we use |=, repeating the assignment later is safe */
+  }
+
+  /* Completed MCU, so update state */
+  BITREAD_SAVE_STATE(cinfo, entropy->bitstate);
+
+  /* Account for restart interval (no-op if not using restarts) */
+  entropy->restarts_to_go--;
+
+  return TRUE;
+}
+
+
+/*
+ * MCU decoding for AC successive approximation refinement scan.
+ */
+
+METHODDEF(boolean)
+decode_mcu_AC_refine(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
+{
+  phuff_entropy_ptr entropy = (phuff_entropy_ptr)cinfo->entropy;
+  int Se = cinfo->Se;
+  int p1 = 1 << cinfo->Al;        /* 1 in the bit position being coded */
+  int m1 = (NEG_1) << cinfo->Al;  /* -1 in the bit position being coded */
+  register int s, k, r;
+  unsigned int EOBRUN;
+  JBLOCKROW block;
+  JCOEFPTR thiscoef;
+  BITREAD_STATE_VARS;
+  d_derived_tbl *tbl;
+  int num_newnz;
+  int newnz_pos[DCTSIZE2];
+
+  /* Process restart marker if needed; may have to suspend */
+  if (cinfo->restart_interval) {
+    if (entropy->restarts_to_go == 0)
+      if (!process_restart(cinfo))
+        return FALSE;
+  }
+
+  /* If we've run out of data, don't modify the MCU.
+   */
+  if (!entropy->pub.insufficient_data) {
+
+    /* Load up working state */
+    BITREAD_LOAD_STATE(cinfo, entropy->bitstate);
+    EOBRUN = entropy->saved.EOBRUN; /* only part of saved state we need */
+
+    /* There is always only one block per MCU */
+    block = MCU_data[0];
+    tbl = entropy->ac_derived_tbl;
+
+    /* If we are forced to suspend, we must undo the assignments to any newly
+     * nonzero coefficients in the block, because otherwise we'd get confused
+     * next time about which coefficients were already nonzero.
+     * But we need not undo addition of bits to already-nonzero coefficients;
+     * instead, we can test the current bit to see if we already did it.
+     */
+    num_newnz = 0;
+
+    /* initialize coefficient loop counter to start of band */
+    k = cinfo->Ss;
+
+    if (EOBRUN == 0) {
+      for (; k <= Se; k++) {
+        HUFF_DECODE(s, br_state, tbl, goto undoit, label3);
+        r = s >> 4;
+        s &= 15;
+        if (s) {
+          if (s != 1)           /* size of new coef should always be 1 */
+            WARNMS(cinfo, JWRN_HUFF_BAD_CODE);
+          CHECK_BIT_BUFFER(br_state, 1, goto undoit);
+          if (GET_BITS(1))
+            s = p1;             /* newly nonzero coef is positive */
+          else
+            s = m1;             /* newly nonzero coef is negative */
+        } else {
+          if (r != 15) {
+            EOBRUN = 1 << r;    /* EOBr, run length is 2^r + appended bits */
+            if (r) {
+              CHECK_BIT_BUFFER(br_state, r, goto undoit);
+              r = GET_BITS(r);
+              EOBRUN += r;
+            }
+            break;              /* rest of block is handled by EOB logic */
+          }
+          /* note s = 0 for processing ZRL */
+        }
+        /* Advance over already-nonzero coefs and r still-zero coefs,
+         * appending correction bits to the nonzeroes.  A correction bit is 1
+         * if the absolute value of the coefficient must be increased.
+         */
+        do {
+          thiscoef = *block + jpeg_natural_order[k];
+          if (*thiscoef != 0) {
+            CHECK_BIT_BUFFER(br_state, 1, goto undoit);
+            if (GET_BITS(1)) {
+              if ((*thiscoef & p1) == 0) { /* do nothing if already set it */
+                if (*thiscoef >= 0)
+                  *thiscoef += p1;
+                else
+                  *thiscoef += m1;
+              }
+            }
+          } else {
+            if (--r < 0)
+              break;            /* reached target zero coefficient */
+          }
+          k++;
+        } while (k <= Se);
+        if (s) {
+          int pos = jpeg_natural_order[k];
+          /* Output newly nonzero coefficient */
+          (*block)[pos] = (JCOEF)s;
+          /* Remember its position in case we have to suspend */
+          newnz_pos[num_newnz++] = pos;
+        }
+      }
+    }
+
+    if (EOBRUN > 0) {
+      /* Scan any remaining coefficient positions after the end-of-band
+       * (the last newly nonzero coefficient, if any).  Append a correction
+       * bit to each already-nonzero coefficient.  A correction bit is 1
+       * if the absolute value of the coefficient must be increased.
+       */
+      for (; k <= Se; k++) {
+        thiscoef = *block + jpeg_natural_order[k];
+        if (*thiscoef != 0) {
+          CHECK_BIT_BUFFER(br_state, 1, goto undoit);
+          if (GET_BITS(1)) {
+            if ((*thiscoef & p1) == 0) { /* do nothing if already changed it */
+              if (*thiscoef >= 0)
+                *thiscoef += p1;
+              else
+                *thiscoef += m1;
+            }
+          }
+        }
+      }
+      /* Count one block completed in EOB run */
+      EOBRUN--;
+    }
+
+    /* Completed MCU, so update state */
+    BITREAD_SAVE_STATE(cinfo, entropy->bitstate);
+    entropy->saved.EOBRUN = EOBRUN; /* only part of saved state we need */
+  }
+
+  /* Account for restart interval (no-op if not using restarts) */
+  entropy->restarts_to_go--;
+
+  return TRUE;
+
+undoit:
+  /* Re-zero any output coefficients that we made newly nonzero */
+  while (num_newnz > 0)
+    (*block)[newnz_pos[--num_newnz]] = 0;
+
+  return FALSE;
+}
+
+
+/*
+ * Module initialization routine for progressive Huffman entropy decoding.
+ */
+
+GLOBAL(void)
+jinit_phuff_decoder(j_decompress_ptr cinfo)
+{
+  phuff_entropy_ptr entropy;
+  int *coef_bit_ptr;
+  int ci, i;
+
+  entropy = (phuff_entropy_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+                                sizeof(phuff_entropy_decoder));
+  cinfo->entropy = (struct jpeg_entropy_decoder *)entropy;
+  entropy->pub.start_pass = start_pass_phuff_decoder;
+
+  /* Mark derived tables unallocated */
+  for (i = 0; i < NUM_HUFF_TBLS; i++) {
+    entropy->derived_tbls[i] = NULL;
+  }
+
+  /* Create progression status table */
+  cinfo->coef_bits = (int (*)[DCTSIZE2])
+    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+                                cinfo->num_components * 2 * DCTSIZE2 *
+                                sizeof(int));
+  coef_bit_ptr = &cinfo->coef_bits[0][0];
+  for (ci = 0; ci < cinfo->num_components; ci++)
+    for (i = 0; i < DCTSIZE2; i++)
+      *coef_bit_ptr++ = -1;
+}
+
+#endif /* D_PROGRESSIVE_SUPPORTED */
diff --git a/3rdparty/libjpeg/src/jdpostct.c b/3rdparty/libjpeg/src/jdpostct.c
new file mode 100644
index 00000000..6a2cf5c1
--- /dev/null
+++ b/3rdparty/libjpeg/src/jdpostct.c
@@ -0,0 +1,294 @@
+/*
+ * jdpostct.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1994-1996, Thomas G. Lane.
+ * It was modified by The libjpeg-turbo Project to include only code relevant
+ * to libjpeg-turbo.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains the decompression postprocessing controller.
+ * This controller manages the upsampling, color conversion, and color
+ * quantization/reduction steps; specifically, it controls the buffering
+ * between upsample/color conversion and color quantization/reduction.
+ *
+ * If no color quantization/reduction is required, then this module has no
+ * work to do, and it just hands off to the upsample/color conversion code.
+ * An integrated upsample/convert/quantize process would replace this module
+ * entirely.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/* Private buffer controller object */
+
+typedef struct {
+  struct jpeg_d_post_controller pub; /* public fields */
+
+  /* Color quantization source buffer: this holds output data from
+   * the upsample/color conversion step to be passed to the quantizer.
+   * For two-pass color quantization, we need a full-image buffer;
+   * for one-pass operation, a strip buffer is sufficient.
+   */
+  jvirt_sarray_ptr whole_image; /* virtual array, or NULL if one-pass */
+  JSAMPARRAY buffer;            /* strip buffer, or current strip of virtual */
+  JDIMENSION strip_height;      /* buffer size in rows */
+  /* for two-pass mode only: */
+  JDIMENSION starting_row;      /* row # of first row in current strip */
+  JDIMENSION next_row;          /* index of next row to fill/empty in strip */
+} my_post_controller;
+
+typedef my_post_controller *my_post_ptr;
+
+
+/* Forward declarations */
+METHODDEF(void) post_process_1pass(j_decompress_ptr cinfo,
+                                   JSAMPIMAGE input_buf,
+                                   JDIMENSION *in_row_group_ctr,
+                                   JDIMENSION in_row_groups_avail,
+                                   JSAMPARRAY output_buf,
+                                   JDIMENSION *out_row_ctr,
+                                   JDIMENSION out_rows_avail);
+#ifdef QUANT_2PASS_SUPPORTED
+METHODDEF(void) post_process_prepass(j_decompress_ptr cinfo,
+                                     JSAMPIMAGE input_buf,
+                                     JDIMENSION *in_row_group_ctr,
+                                     JDIMENSION in_row_groups_avail,
+                                     JSAMPARRAY output_buf,
+                                     JDIMENSION *out_row_ctr,
+                                     JDIMENSION out_rows_avail);
+METHODDEF(void) post_process_2pass(j_decompress_ptr cinfo,
+                                   JSAMPIMAGE input_buf,
+                                   JDIMENSION *in_row_group_ctr,
+                                   JDIMENSION in_row_groups_avail,
+                                   JSAMPARRAY output_buf,
+                                   JDIMENSION *out_row_ctr,
+                                   JDIMENSION out_rows_avail);
+#endif
+
+
+/*
+ * Initialize for a processing pass.
+ */
+
+METHODDEF(void)
+start_pass_dpost(j_decompress_ptr cinfo, J_BUF_MODE pass_mode)
+{
+  my_post_ptr post = (my_post_ptr)cinfo->post;
+
+  switch (pass_mode) {
+  case JBUF_PASS_THRU:
+    if (cinfo->quantize_colors) {
+      /* Single-pass processing with color quantization. */
+      post->pub.post_process_data = post_process_1pass;
+      /* We could be doing buffered-image output before starting a 2-pass
+       * color quantization; in that case, jinit_d_post_controller did not
+       * allocate a strip buffer.  Use the virtual-array buffer as workspace.
+       */
+      if (post->buffer == NULL) {
+        post->buffer = (*cinfo->mem->access_virt_sarray)
+          ((j_common_ptr)cinfo, post->whole_image,
+           (JDIMENSION)0, post->strip_height, TRUE);
+      }
+    } else {
+      /* For single-pass processing without color quantization,
+       * I have no work to do; just call the upsampler directly.
+       */
+      post->pub.post_process_data = cinfo->upsample->upsample;
+    }
+    break;
+#ifdef QUANT_2PASS_SUPPORTED
+  case JBUF_SAVE_AND_PASS:
+    /* First pass of 2-pass quantization */
+    if (post->whole_image == NULL)
+      ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+    post->pub.post_process_data = post_process_prepass;
+    break;
+  case JBUF_CRANK_DEST:
+    /* Second pass of 2-pass quantization */
+    if (post->whole_image == NULL)
+      ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+    post->pub.post_process_data = post_process_2pass;
+    break;
+#endif /* QUANT_2PASS_SUPPORTED */
+  default:
+    ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+    break;
+  }
+  post->starting_row = post->next_row = 0;
+}
+
+
+/*
+ * Process some data in the one-pass (strip buffer) case.
+ * This is used for color precision reduction as well as one-pass quantization.
+ */
+
+METHODDEF(void)
+post_process_1pass(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
+                   JDIMENSION *in_row_group_ctr,
+                   JDIMENSION in_row_groups_avail, JSAMPARRAY output_buf,
+                   JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail)
+{
+  my_post_ptr post = (my_post_ptr)cinfo->post;
+  JDIMENSION num_rows, max_rows;
+
+  /* Fill the buffer, but not more than what we can dump out in one go. */
+  /* Note we rely on the upsampler to detect bottom of image. */
+  max_rows = out_rows_avail - *out_row_ctr;
+  if (max_rows > post->strip_height)
+    max_rows = post->strip_height;
+  num_rows = 0;
+  (*cinfo->upsample->upsample) (cinfo, input_buf, in_row_group_ctr,
+                                in_row_groups_avail, post->buffer, &num_rows,
+                                max_rows);
+  /* Quantize and emit data. */
+  (*cinfo->cquantize->color_quantize) (cinfo, post->buffer,
+                                       output_buf + *out_row_ctr,
+                                       (int)num_rows);
+  *out_row_ctr += num_rows;
+}
+
+
+#ifdef QUANT_2PASS_SUPPORTED
+
+/*
+ * Process some data in the first pass of 2-pass quantization.
+ */
+
+METHODDEF(void)
+post_process_prepass(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
+                     JDIMENSION *in_row_group_ctr,
+                     JDIMENSION in_row_groups_avail, JSAMPARRAY output_buf,
+                     JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail)
+{
+  my_post_ptr post = (my_post_ptr)cinfo->post;
+  JDIMENSION old_next_row, num_rows;
+
+  /* Reposition virtual buffer if at start of strip. */
+  if (post->next_row == 0) {
+    post->buffer = (*cinfo->mem->access_virt_sarray)
+        ((j_common_ptr)cinfo, post->whole_image,
+         post->starting_row, post->strip_height, TRUE);
+  }
+
+  /* Upsample some data (up to a strip height's worth). */
+  old_next_row = post->next_row;
+  (*cinfo->upsample->upsample) (cinfo, input_buf, in_row_group_ctr,
+                                in_row_groups_avail, post->buffer,
+                                &post->next_row, post->strip_height);
+
+  /* Allow quantizer to scan new data.  No data is emitted, */
+  /* but we advance out_row_ctr so outer loop can tell when we're done. */
+  if (post->next_row > old_next_row) {
+    num_rows = post->next_row - old_next_row;
+    (*cinfo->cquantize->color_quantize) (cinfo, post->buffer + old_next_row,
+                                         (JSAMPARRAY)NULL, (int)num_rows);
+    *out_row_ctr += num_rows;
+  }
+
+  /* Advance if we filled the strip. */
+  if (post->next_row >= post->strip_height) {
+    post->starting_row += post->strip_height;
+    post->next_row = 0;
+  }
+}
+
+
+/*
+ * Process some data in the second pass of 2-pass quantization.
+ */
+
+METHODDEF(void)
+post_process_2pass(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
+                   JDIMENSION *in_row_group_ctr,
+                   JDIMENSION in_row_groups_avail, JSAMPARRAY output_buf,
+                   JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail)
+{
+  my_post_ptr post = (my_post_ptr)cinfo->post;
+  JDIMENSION num_rows, max_rows;
+
+  /* Reposition virtual buffer if at start of strip. */
+  if (post->next_row == 0) {
+    post->buffer = (*cinfo->mem->access_virt_sarray)
+        ((j_common_ptr)cinfo, post->whole_image,
+         post->starting_row, post->strip_height, FALSE);
+  }
+
+  /* Determine number of rows to emit. */
+  num_rows = post->strip_height - post->next_row; /* available in strip */
+  max_rows = out_rows_avail - *out_row_ctr; /* available in output area */
+  if (num_rows > max_rows)
+    num_rows = max_rows;
+  /* We have to check bottom of image here, can't depend on upsampler. */
+  max_rows = cinfo->output_height - post->starting_row;
+  if (num_rows > max_rows)
+    num_rows = max_rows;
+
+  /* Quantize and emit data. */
+  (*cinfo->cquantize->color_quantize) (cinfo, post->buffer + post->next_row,
+                                       output_buf + *out_row_ctr,
+                                       (int)num_rows);
+  *out_row_ctr += num_rows;
+
+  /* Advance if we filled the strip. */
+  post->next_row += num_rows;
+  if (post->next_row >= post->strip_height) {
+    post->starting_row += post->strip_height;
+    post->next_row = 0;
+  }
+}
+
+#endif /* QUANT_2PASS_SUPPORTED */
+
+
+/*
+ * Initialize postprocessing controller.
+ */
+
+GLOBAL(void)
+jinit_d_post_controller(j_decompress_ptr cinfo, boolean need_full_buffer)
+{
+  my_post_ptr post;
+
+  post = (my_post_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+                                sizeof(my_post_controller));
+  cinfo->post = (struct jpeg_d_post_controller *)post;
+  post->pub.start_pass = start_pass_dpost;
+  post->whole_image = NULL;     /* flag for no virtual arrays */
+  post->buffer = NULL;          /* flag for no strip buffer */
+
+  /* Create the quantization buffer, if needed */
+  if (cinfo->quantize_colors) {
+    /* The buffer strip height is max_v_samp_factor, which is typically
+     * an efficient number of rows for upsampling to return.
+     * (In the presence of output rescaling, we might want to be smarter?)
+     */
+    post->strip_height = (JDIMENSION)cinfo->max_v_samp_factor;
+    if (need_full_buffer) {
+      /* Two-pass color quantization: need full-image storage. */
+      /* We round up the number of rows to a multiple of the strip height. */
+#ifdef QUANT_2PASS_SUPPORTED
+      post->whole_image = (*cinfo->mem->request_virt_sarray)
+        ((j_common_ptr)cinfo, JPOOL_IMAGE, FALSE,
+         cinfo->output_width * cinfo->out_color_components,
+         (JDIMENSION)jround_up((long)cinfo->output_height,
+                               (long)post->strip_height),
+         post->strip_height);
+#else
+      ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+#endif /* QUANT_2PASS_SUPPORTED */
+    } else {
+      /* One-pass color quantization: just make a strip buffer. */
+      post->buffer = (*cinfo->mem->alloc_sarray)
+        ((j_common_ptr)cinfo, JPOOL_IMAGE,
+         cinfo->output_width * cinfo->out_color_components,
+         post->strip_height);
+    }
+  }
+}
diff --git a/3rdparty/libjpeg/src/jdsample.c b/3rdparty/libjpeg/src/jdsample.c
new file mode 100644
index 00000000..eaad72a0
--- /dev/null
+++ b/3rdparty/libjpeg/src/jdsample.c
@@ -0,0 +1,524 @@
+/*
+ * jdsample.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1991-1996, Thomas G. Lane.
+ * libjpeg-turbo Modifications:
+ * Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+ * Copyright (C) 2010, 2015-2016, D. R. Commander.
+ * Copyright (C) 2014, MIPS Technologies, Inc., California.
+ * Copyright (C) 2015, Google, Inc.
+ * Copyright (C) 2019-2020, Arm Limited.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains upsampling routines.
+ *
+ * Upsampling input data is counted in "row groups".  A row group
+ * is defined to be (v_samp_factor * DCT_scaled_size / min_DCT_scaled_size)
+ * sample rows of each component.  Upsampling will normally produce
+ * max_v_samp_factor pixel rows from each row group (but this could vary
+ * if the upsampler is applying a scale factor of its own).
+ *
+ * An excellent reference for image resampling is
+ *   Digital Image Warping, George Wolberg, 1990.
+ *   Pub. by IEEE Computer Society Press, Los Alamitos, CA. ISBN 0-8186-8944-7.
+ */
+
+#include "jinclude.h"
+#include "jdsample.h"
+#include "jsimd.h"
+#include "jpegcomp.h"
+
+
+
+/*
+ * Initialize for an upsampling pass.
+ */
+
+METHODDEF(void)
+start_pass_upsample(j_decompress_ptr cinfo)
+{
+  my_upsample_ptr upsample = (my_upsample_ptr)cinfo->upsample;
+
+  /* Mark the conversion buffer empty */
+  upsample->next_row_out = cinfo->max_v_samp_factor;
+  /* Initialize total-height counter for detecting bottom of image */
+  upsample->rows_to_go = cinfo->output_height;
+}
+
+
+/*
+ * Control routine to do upsampling (and color conversion).
+ *
+ * In this version we upsample each component independently.
+ * We upsample one row group into the conversion buffer, then apply
+ * color conversion a row at a time.
+ */
+
+METHODDEF(void)
+sep_upsample(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
+             JDIMENSION *in_row_group_ctr, JDIMENSION in_row_groups_avail,
+             JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
+             JDIMENSION out_rows_avail)
+{
+  my_upsample_ptr upsample = (my_upsample_ptr)cinfo->upsample;
+  int ci;
+  jpeg_component_info *compptr;
+  JDIMENSION num_rows;
+
+  /* Fill the conversion buffer, if it's empty */
+  if (upsample->next_row_out >= cinfo->max_v_samp_factor) {
+    for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+         ci++, compptr++) {
+      /* Invoke per-component upsample method.  Notice we pass a POINTER
+       * to color_buf[ci], so that fullsize_upsample can change it.
+       */
+      (*upsample->methods[ci]) (cinfo, compptr,
+        input_buf[ci] + (*in_row_group_ctr * upsample->rowgroup_height[ci]),
+        upsample->color_buf + ci);
+    }
+    upsample->next_row_out = 0;
+  }
+
+  /* Color-convert and emit rows */
+
+  /* How many we have in the buffer: */
+  num_rows = (JDIMENSION)(cinfo->max_v_samp_factor - upsample->next_row_out);
+  /* Not more than the distance to the end of the image.  Need this test
+   * in case the image height is not a multiple of max_v_samp_factor:
+   */
+  if (num_rows > upsample->rows_to_go)
+    num_rows = upsample->rows_to_go;
+  /* And not more than what the client can accept: */
+  out_rows_avail -= *out_row_ctr;
+  if (num_rows > out_rows_avail)
+    num_rows = out_rows_avail;
+
+  (*cinfo->cconvert->color_convert) (cinfo, upsample->color_buf,
+                                     (JDIMENSION)upsample->next_row_out,
+                                     output_buf + *out_row_ctr, (int)num_rows);
+
+  /* Adjust counts */
+  *out_row_ctr += num_rows;
+  upsample->rows_to_go -= num_rows;
+  upsample->next_row_out += num_rows;
+  /* When the buffer is emptied, declare this input row group consumed */
+  if (upsample->next_row_out >= cinfo->max_v_samp_factor)
+    (*in_row_group_ctr)++;
+}
+
+
+/*
+ * These are the routines invoked by sep_upsample to upsample pixel values
+ * of a single component.  One row group is processed per call.
+ */
+
+
+/*
+ * For full-size components, we just make color_buf[ci] point at the
+ * input buffer, and thus avoid copying any data.  Note that this is
+ * safe only because sep_upsample doesn't declare the input row group
+ * "consumed" until we are done color converting and emitting it.
+ */
+
+METHODDEF(void)
+fullsize_upsample(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+                  JSAMPARRAY input_data, JSAMPARRAY *output_data_ptr)
+{
+  *output_data_ptr = input_data;
+}
+
+
+/*
+ * This is a no-op version used for "uninteresting" components.
+ * These components will not be referenced by color conversion.
+ */
+
+METHODDEF(void)
+noop_upsample(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+              JSAMPARRAY input_data, JSAMPARRAY *output_data_ptr)
+{
+  *output_data_ptr = NULL;      /* safety check */
+}
+
+
+/*
+ * This version handles any integral sampling ratios.
+ * This is not used for typical JPEG files, so it need not be fast.
+ * Nor, for that matter, is it particularly accurate: the algorithm is
+ * simple replication of the input pixel onto the corresponding output
+ * pixels.  The hi-falutin sampling literature refers to this as a
+ * "box filter".  A box filter tends to introduce visible artifacts,
+ * so if you are actually going to use 3:1 or 4:1 sampling ratios
+ * you would be well advised to improve this code.
+ */
+
+METHODDEF(void)
+int_upsample(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+             JSAMPARRAY input_data, JSAMPARRAY *output_data_ptr)
+{
+  my_upsample_ptr upsample = (my_upsample_ptr)cinfo->upsample;
+  JSAMPARRAY output_data = *output_data_ptr;
+  register JSAMPROW inptr, outptr;
+  register JSAMPLE invalue;
+  register int h;
+  JSAMPROW outend;
+  int h_expand, v_expand;
+  int inrow, outrow;
+
+  h_expand = upsample->h_expand[compptr->component_index];
+  v_expand = upsample->v_expand[compptr->component_index];
+
+  inrow = outrow = 0;
+  while (outrow < cinfo->max_v_samp_factor) {
+    /* Generate one output row with proper horizontal expansion */
+    inptr = input_data[inrow];
+    outptr = output_data[outrow];
+    outend = outptr + cinfo->output_width;
+    while (outptr < outend) {
+      invalue = *inptr++;
+      for (h = h_expand; h > 0; h--) {
+        *outptr++ = invalue;
+      }
+    }
+    /* Generate any additional output rows by duplicating the first one */
+    if (v_expand > 1) {
+      jcopy_sample_rows(output_data, outrow, output_data, outrow + 1,
+                        v_expand - 1, cinfo->output_width);
+    }
+    inrow++;
+    outrow += v_expand;
+  }
+}
+
+
+/*
+ * Fast processing for the common case of 2:1 horizontal and 1:1 vertical.
+ * It's still a box filter.
+ */
+
+METHODDEF(void)
+h2v1_upsample(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+              JSAMPARRAY input_data, JSAMPARRAY *output_data_ptr)
+{
+  JSAMPARRAY output_data = *output_data_ptr;
+  register JSAMPROW inptr, outptr;
+  register JSAMPLE invalue;
+  JSAMPROW outend;
+  int inrow;
+
+  for (inrow = 0; inrow < cinfo->max_v_samp_factor; inrow++) {
+    inptr = input_data[inrow];
+    outptr = output_data[inrow];
+    outend = outptr + cinfo->output_width;
+    while (outptr < outend) {
+      invalue = *inptr++;
+      *outptr++ = invalue;
+      *outptr++ = invalue;
+    }
+  }
+}
+
+
+/*
+ * Fast processing for the common case of 2:1 horizontal and 2:1 vertical.
+ * It's still a box filter.
+ */
+
+METHODDEF(void)
+h2v2_upsample(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+              JSAMPARRAY input_data, JSAMPARRAY *output_data_ptr)
+{
+  JSAMPARRAY output_data = *output_data_ptr;
+  register JSAMPROW inptr, outptr;
+  register JSAMPLE invalue;
+  JSAMPROW outend;
+  int inrow, outrow;
+
+  inrow = outrow = 0;
+  while (outrow < cinfo->max_v_samp_factor) {
+    inptr = input_data[inrow];
+    outptr = output_data[outrow];
+    outend = outptr + cinfo->output_width;
+    while (outptr < outend) {
+      invalue = *inptr++;
+      *outptr++ = invalue;
+      *outptr++ = invalue;
+    }
+    jcopy_sample_rows(output_data, outrow, output_data, outrow + 1, 1,
+                      cinfo->output_width);
+    inrow++;
+    outrow += 2;
+  }
+}
+
+
+/*
+ * Fancy processing for the common case of 2:1 horizontal and 1:1 vertical.
+ *
+ * The upsampling algorithm is linear interpolation between pixel centers,
+ * also known as a "triangle filter".  This is a good compromise between
+ * speed and visual quality.  The centers of the output pixels are 1/4 and 3/4
+ * of the way between input pixel centers.
+ *
+ * A note about the "bias" calculations: when rounding fractional values to
+ * integer, we do not want to always round 0.5 up to the next integer.
+ * If we did that, we'd introduce a noticeable bias towards larger values.
+ * Instead, this code is arranged so that 0.5 will be rounded up or down at
+ * alternate pixel locations (a simple ordered dither pattern).
+ */
+
+METHODDEF(void)
+h2v1_fancy_upsample(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+                    JSAMPARRAY input_data, JSAMPARRAY *output_data_ptr)
+{
+  JSAMPARRAY output_data = *output_data_ptr;
+  register JSAMPROW inptr, outptr;
+  register int invalue;
+  register JDIMENSION colctr;
+  int inrow;
+
+  for (inrow = 0; inrow < cinfo->max_v_samp_factor; inrow++) {
+    inptr = input_data[inrow];
+    outptr = output_data[inrow];
+    /* Special case for first column */
+    invalue = *inptr++;
+    *outptr++ = (JSAMPLE)invalue;
+    *outptr++ = (JSAMPLE)((invalue * 3 + inptr[0] + 2) >> 2);
+
+    for (colctr = compptr->downsampled_width - 2; colctr > 0; colctr--) {
+      /* General case: 3/4 * nearer pixel + 1/4 * further pixel */
+      invalue = (*inptr++) * 3;
+      *outptr++ = (JSAMPLE)((invalue + inptr[-2] + 1) >> 2);
+      *outptr++ = (JSAMPLE)((invalue + inptr[0] + 2) >> 2);
+    }
+
+    /* Special case for last column */
+    invalue = *inptr;
+    *outptr++ = (JSAMPLE)((invalue * 3 + inptr[-1] + 1) >> 2);
+    *outptr++ = (JSAMPLE)invalue;
+  }
+}
+
+
+/*
+ * Fancy processing for 1:1 horizontal and 2:1 vertical (4:4:0 subsampling).
+ *
+ * This is a less common case, but it can be encountered when losslessly
+ * rotating/transposing a JPEG file that uses 4:2:2 chroma subsampling.
+ */
+
+METHODDEF(void)
+h1v2_fancy_upsample(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+                    JSAMPARRAY input_data, JSAMPARRAY *output_data_ptr)
+{
+  JSAMPARRAY output_data = *output_data_ptr;
+  JSAMPROW inptr0, inptr1, outptr;
+#if BITS_IN_JSAMPLE == 8
+  int thiscolsum, bias;
+#else
+  JLONG thiscolsum, bias;
+#endif
+  JDIMENSION colctr;
+  int inrow, outrow, v;
+
+  inrow = outrow = 0;
+  while (outrow < cinfo->max_v_samp_factor) {
+    for (v = 0; v < 2; v++) {
+      /* inptr0 points to nearest input row, inptr1 points to next nearest */
+      inptr0 = input_data[inrow];
+      if (v == 0) {             /* next nearest is row above */
+        inptr1 = input_data[inrow - 1];
+        bias = 1;
+      } else {                  /* next nearest is row below */
+        inptr1 = input_data[inrow + 1];
+        bias = 2;
+      }
+      outptr = output_data[outrow++];
+
+      for (colctr = 0; colctr < compptr->downsampled_width; colctr++) {
+        thiscolsum = (*inptr0++) * 3 + (*inptr1++);
+        *outptr++ = (JSAMPLE)((thiscolsum + bias) >> 2);
+      }
+    }
+    inrow++;
+  }
+}
+
+
+/*
+ * Fancy processing for the common case of 2:1 horizontal and 2:1 vertical.
+ * Again a triangle filter; see comments for h2v1 case, above.
+ *
+ * It is OK for us to reference the adjacent input rows because we demanded
+ * context from the main buffer controller (see initialization code).
+ */
+
+METHODDEF(void)
+h2v2_fancy_upsample(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+                    JSAMPARRAY input_data, JSAMPARRAY *output_data_ptr)
+{
+  JSAMPARRAY output_data = *output_data_ptr;
+  register JSAMPROW inptr0, inptr1, outptr;
+#if BITS_IN_JSAMPLE == 8
+  register int thiscolsum, lastcolsum, nextcolsum;
+#else
+  register JLONG thiscolsum, lastcolsum, nextcolsum;
+#endif
+  register JDIMENSION colctr;
+  int inrow, outrow, v;
+
+  inrow = outrow = 0;
+  while (outrow < cinfo->max_v_samp_factor) {
+    for (v = 0; v < 2; v++) {
+      /* inptr0 points to nearest input row, inptr1 points to next nearest */
+      inptr0 = input_data[inrow];
+      if (v == 0)               /* next nearest is row above */
+        inptr1 = input_data[inrow - 1];
+      else                      /* next nearest is row below */
+        inptr1 = input_data[inrow + 1];
+      outptr = output_data[outrow++];
+
+      /* Special case for first column */
+      thiscolsum = (*inptr0++) * 3 + (*inptr1++);
+      nextcolsum = (*inptr0++) * 3 + (*inptr1++);
+      *outptr++ = (JSAMPLE)((thiscolsum * 4 + 8) >> 4);
+      *outptr++ = (JSAMPLE)((thiscolsum * 3 + nextcolsum + 7) >> 4);
+      lastcolsum = thiscolsum;  thiscolsum = nextcolsum;
+
+      for (colctr = compptr->downsampled_width - 2; colctr > 0; colctr--) {
+        /* General case: 3/4 * nearer pixel + 1/4 * further pixel in each */
+        /* dimension, thus 9/16, 3/16, 3/16, 1/16 overall */
+        nextcolsum = (*inptr0++) * 3 + (*inptr1++);
+        *outptr++ = (JSAMPLE)((thiscolsum * 3 + lastcolsum + 8) >> 4);
+        *outptr++ = (JSAMPLE)((thiscolsum * 3 + nextcolsum + 7) >> 4);
+        lastcolsum = thiscolsum;  thiscolsum = nextcolsum;
+      }
+
+      /* Special case for last column */
+      *outptr++ = (JSAMPLE)((thiscolsum * 3 + lastcolsum + 8) >> 4);
+      *outptr++ = (JSAMPLE)((thiscolsum * 4 + 7) >> 4);
+    }
+    inrow++;
+  }
+}
+
+
+/*
+ * Module initialization routine for upsampling.
+ */
+
+GLOBAL(void)
+jinit_upsampler(j_decompress_ptr cinfo)
+{
+  my_upsample_ptr upsample;
+  int ci;
+  jpeg_component_info *compptr;
+  boolean need_buffer, do_fancy;
+  int h_in_group, v_in_group, h_out_group, v_out_group;
+
+  if (!cinfo->master->jinit_upsampler_no_alloc) {
+    upsample = (my_upsample_ptr)
+      (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+                                  sizeof(my_upsampler));
+    cinfo->upsample = (struct jpeg_upsampler *)upsample;
+    upsample->pub.start_pass = start_pass_upsample;
+    upsample->pub.upsample = sep_upsample;
+    upsample->pub.need_context_rows = FALSE; /* until we find out differently */
+  } else
+    upsample = (my_upsample_ptr)cinfo->upsample;
+
+  if (cinfo->CCIR601_sampling)  /* this isn't supported */
+    ERREXIT(cinfo, JERR_CCIR601_NOTIMPL);
+
+  /* jdmainct.c doesn't support context rows when min_DCT_scaled_size = 1,
+   * so don't ask for it.
+   */
+  do_fancy = cinfo->do_fancy_upsampling && cinfo->_min_DCT_scaled_size > 1;
+
+  /* Verify we can handle the sampling factors, select per-component methods,
+   * and create storage as needed.
+   */
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    /* Compute size of an "input group" after IDCT scaling.  This many samples
+     * are to be converted to max_h_samp_factor * max_v_samp_factor pixels.
+     */
+    h_in_group = (compptr->h_samp_factor * compptr->_DCT_scaled_size) /
+                 cinfo->_min_DCT_scaled_size;
+    v_in_group = (compptr->v_samp_factor * compptr->_DCT_scaled_size) /
+                 cinfo->_min_DCT_scaled_size;
+    h_out_group = cinfo->max_h_samp_factor;
+    v_out_group = cinfo->max_v_samp_factor;
+    upsample->rowgroup_height[ci] = v_in_group; /* save for use later */
+    need_buffer = TRUE;
+    if (!compptr->component_needed) {
+      /* Don't bother to upsample an uninteresting component. */
+      upsample->methods[ci] = noop_upsample;
+      need_buffer = FALSE;
+    } else if (h_in_group == h_out_group && v_in_group == v_out_group) {
+      /* Fullsize components can be processed without any work. */
+      upsample->methods[ci] = fullsize_upsample;
+      need_buffer = FALSE;
+    } else if (h_in_group * 2 == h_out_group && v_in_group == v_out_group) {
+      /* Special cases for 2h1v upsampling */
+      if (do_fancy && compptr->downsampled_width > 2) {
+        if (jsimd_can_h2v1_fancy_upsample())
+          upsample->methods[ci] = jsimd_h2v1_fancy_upsample;
+        else
+          upsample->methods[ci] = h2v1_fancy_upsample;
+      } else {
+        if (jsimd_can_h2v1_upsample())
+          upsample->methods[ci] = jsimd_h2v1_upsample;
+        else
+          upsample->methods[ci] = h2v1_upsample;
+      }
+    } else if (h_in_group == h_out_group &&
+               v_in_group * 2 == v_out_group && do_fancy) {
+      /* Non-fancy upsampling is handled by the generic method */
+#if defined(__arm__) || defined(__aarch64__) || \
+    defined(_M_ARM) || defined(_M_ARM64)
+      if (jsimd_can_h1v2_fancy_upsample())
+        upsample->methods[ci] = jsimd_h1v2_fancy_upsample;
+      else
+#endif
+        upsample->methods[ci] = h1v2_fancy_upsample;
+      upsample->pub.need_context_rows = TRUE;
+    } else if (h_in_group * 2 == h_out_group &&
+               v_in_group * 2 == v_out_group) {
+      /* Special cases for 2h2v upsampling */
+      if (do_fancy && compptr->downsampled_width > 2) {
+        if (jsimd_can_h2v2_fancy_upsample())
+          upsample->methods[ci] = jsimd_h2v2_fancy_upsample;
+        else
+          upsample->methods[ci] = h2v2_fancy_upsample;
+        upsample->pub.need_context_rows = TRUE;
+      } else {
+        if (jsimd_can_h2v2_upsample())
+          upsample->methods[ci] = jsimd_h2v2_upsample;
+        else
+          upsample->methods[ci] = h2v2_upsample;
+      }
+    } else if ((h_out_group % h_in_group) == 0 &&
+               (v_out_group % v_in_group) == 0) {
+      /* Generic integral-factors upsampling method */
+#if defined(__mips__)
+      if (jsimd_can_int_upsample())
+        upsample->methods[ci] = jsimd_int_upsample;
+      else
+#endif
+        upsample->methods[ci] = int_upsample;
+      upsample->h_expand[ci] = (UINT8)(h_out_group / h_in_group);
+      upsample->v_expand[ci] = (UINT8)(v_out_group / v_in_group);
+    } else
+      ERREXIT(cinfo, JERR_FRACT_SAMPLE_NOTIMPL);
+    if (need_buffer && !cinfo->master->jinit_upsampler_no_alloc) {
+      upsample->color_buf[ci] = (*cinfo->mem->alloc_sarray)
+        ((j_common_ptr)cinfo, JPOOL_IMAGE,
+         (JDIMENSION)jround_up((long)cinfo->output_width,
+                               (long)cinfo->max_h_samp_factor),
+         (JDIMENSION)cinfo->max_v_samp_factor);
+    }
+  }
+}
diff --git a/3rdparty/libjpeg/src/jdsample.h b/3rdparty/libjpeg/src/jdsample.h
new file mode 100644
index 00000000..a6bf08a0
--- /dev/null
+++ b/3rdparty/libjpeg/src/jdsample.h
@@ -0,0 +1,50 @@
+/*
+ * jdsample.h
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1991-1996, Thomas G. Lane.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ */
+
+#define JPEG_INTERNALS
+#include "jpeglib.h"
+
+
+/* Pointer to routine to upsample a single component */
+typedef void (*upsample1_ptr) (j_decompress_ptr cinfo,
+                               jpeg_component_info *compptr,
+                               JSAMPARRAY input_data,
+                               JSAMPARRAY *output_data_ptr);
+
+/* Private subobject */
+
+typedef struct {
+  struct jpeg_upsampler pub;    /* public fields */
+
+  /* Color conversion buffer.  When using separate upsampling and color
+   * conversion steps, this buffer holds one upsampled row group until it
+   * has been color converted and output.
+   * Note: we do not allocate any storage for component(s) which are full-size,
+   * ie do not need rescaling.  The corresponding entry of color_buf[] is
+   * simply set to point to the input data array, thereby avoiding copying.
+   */
+  JSAMPARRAY color_buf[MAX_COMPONENTS];
+
+  /* Per-component upsampling method pointers */
+  upsample1_ptr methods[MAX_COMPONENTS];
+
+  int next_row_out;             /* counts rows emitted from color_buf */
+  JDIMENSION rows_to_go;        /* counts rows remaining in image */
+
+  /* Height of an input row group for each component. */
+  int rowgroup_height[MAX_COMPONENTS];
+
+  /* These arrays save pixel expansion factors so that int_expand need not
+   * recompute them each time.  They are unused for other upsampling methods.
+   */
+  UINT8 h_expand[MAX_COMPONENTS];
+  UINT8 v_expand[MAX_COMPONENTS];
+} my_upsampler;
+
+typedef my_upsampler *my_upsample_ptr;
diff --git a/3rdparty/libjpeg/src/jdtrans.c b/3rdparty/libjpeg/src/jdtrans.c
new file mode 100644
index 00000000..d7ec4b83
--- /dev/null
+++ b/3rdparty/libjpeg/src/jdtrans.c
@@ -0,0 +1,156 @@
+/*
+ * jdtrans.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1995-1997, Thomas G. Lane.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2020, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains library routines for transcoding decompression,
+ * that is, reading raw DCT coefficient arrays from an input JPEG file.
+ * The routines in jdapimin.c will also be needed by a transcoder.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jpegcomp.h"
+
+
+/* Forward declarations */
+LOCAL(void) transdecode_master_selection(j_decompress_ptr cinfo);
+
+
+/*
+ * Read the coefficient arrays from a JPEG file.
+ * jpeg_read_header must be completed before calling this.
+ *
+ * The entire image is read into a set of virtual coefficient-block arrays,
+ * one per component.  The return value is a pointer to the array of
+ * virtual-array descriptors.  These can be manipulated directly via the
+ * JPEG memory manager, or handed off to jpeg_write_coefficients().
+ * To release the memory occupied by the virtual arrays, call
+ * jpeg_finish_decompress() when done with the data.
+ *
+ * An alternative usage is to simply obtain access to the coefficient arrays
+ * during a buffered-image-mode decompression operation.  This is allowed
+ * after any jpeg_finish_output() call.  The arrays can be accessed until
+ * jpeg_finish_decompress() is called.  (Note that any call to the library
+ * may reposition the arrays, so don't rely on access_virt_barray() results
+ * to stay valid across library calls.)
+ *
+ * Returns NULL if suspended.  This case need be checked only if
+ * a suspending data source is used.
+ */
+
+GLOBAL(jvirt_barray_ptr *)
+jpeg_read_coefficients(j_decompress_ptr cinfo)
+{
+  if (cinfo->global_state == DSTATE_READY) {
+    /* First call: initialize active modules */
+    transdecode_master_selection(cinfo);
+    cinfo->global_state = DSTATE_RDCOEFS;
+  }
+  if (cinfo->global_state == DSTATE_RDCOEFS) {
+    /* Absorb whole file into the coef buffer */
+    for (;;) {
+      int retcode;
+      /* Call progress monitor hook if present */
+      if (cinfo->progress != NULL)
+        (*cinfo->progress->progress_monitor) ((j_common_ptr)cinfo);
+      /* Absorb some more input */
+      retcode = (*cinfo->inputctl->consume_input) (cinfo);
+      if (retcode == JPEG_SUSPENDED)
+        return NULL;
+      if (retcode == JPEG_REACHED_EOI)
+        break;
+      /* Advance progress counter if appropriate */
+      if (cinfo->progress != NULL &&
+          (retcode == JPEG_ROW_COMPLETED || retcode == JPEG_REACHED_SOS)) {
+        if (++cinfo->progress->pass_counter >= cinfo->progress->pass_limit) {
+          /* startup underestimated number of scans; ratchet up one scan */
+          cinfo->progress->pass_limit += (long)cinfo->total_iMCU_rows;
+        }
+      }
+    }
+    /* Set state so that jpeg_finish_decompress does the right thing */
+    cinfo->global_state = DSTATE_STOPPING;
+  }
+  /* At this point we should be in state DSTATE_STOPPING if being used
+   * standalone, or in state DSTATE_BUFIMAGE if being invoked to get access
+   * to the coefficients during a full buffered-image-mode decompression.
+   */
+  if ((cinfo->global_state == DSTATE_STOPPING ||
+       cinfo->global_state == DSTATE_BUFIMAGE) && cinfo->buffered_image) {
+    return cinfo->coef->coef_arrays;
+  }
+  /* Oops, improper usage */
+  ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+  return NULL;                  /* keep compiler happy */
+}
+
+
+/*
+ * Master selection of decompression modules for transcoding.
+ * This substitutes for jdmaster.c's initialization of the full decompressor.
+ */
+
+LOCAL(void)
+transdecode_master_selection(j_decompress_ptr cinfo)
+{
+  /* This is effectively a buffered-image operation. */
+  cinfo->buffered_image = TRUE;
+
+#if JPEG_LIB_VERSION >= 80
+  /* Compute output image dimensions and related values. */
+  jpeg_core_output_dimensions(cinfo);
+#endif
+
+  /* Entropy decoding: either Huffman or arithmetic coding. */
+  if (cinfo->arith_code) {
+#ifdef D_ARITH_CODING_SUPPORTED
+    jinit_arith_decoder(cinfo);
+#else
+    ERREXIT(cinfo, JERR_ARITH_NOTIMPL);
+#endif
+  } else {
+    if (cinfo->progressive_mode) {
+#ifdef D_PROGRESSIVE_SUPPORTED
+      jinit_phuff_decoder(cinfo);
+#else
+      ERREXIT(cinfo, JERR_NOT_COMPILED);
+#endif
+    } else
+      jinit_huff_decoder(cinfo);
+  }
+
+  /* Always get a full-image coefficient buffer. */
+  jinit_d_coef_controller(cinfo, TRUE);
+
+  /* We can now tell the memory manager to allocate virtual arrays. */
+  (*cinfo->mem->realize_virt_arrays) ((j_common_ptr)cinfo);
+
+  /* Initialize input side of decompressor to consume first scan. */
+  (*cinfo->inputctl->start_input_pass) (cinfo);
+
+  /* Initialize progress monitoring. */
+  if (cinfo->progress != NULL) {
+    int nscans;
+    /* Estimate number of scans to set pass_limit. */
+    if (cinfo->progressive_mode) {
+      /* Arbitrarily estimate 2 interleaved DC scans + 3 AC scans/component. */
+      nscans = 2 + 3 * cinfo->num_components;
+    } else if (cinfo->inputctl->has_multiple_scans) {
+      /* For a nonprogressive multiscan file, estimate 1 scan per component. */
+      nscans = cinfo->num_components;
+    } else {
+      nscans = 1;
+    }
+    cinfo->progress->pass_counter = 0L;
+    cinfo->progress->pass_limit = (long)cinfo->total_iMCU_rows * nscans;
+    cinfo->progress->completed_passes = 0;
+    cinfo->progress->total_passes = 1;
+  }
+}
diff --git a/3rdparty/libjpeg/src/jerror.c b/3rdparty/libjpeg/src/jerror.c
new file mode 100644
index 00000000..936c4f5d
--- /dev/null
+++ b/3rdparty/libjpeg/src/jerror.c
@@ -0,0 +1,251 @@
+/*
+ * jerror.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1991-1998, Thomas G. Lane.
+ * It was modified by The libjpeg-turbo Project to include only code relevant
+ * to libjpeg-turbo.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains simple error-reporting and trace-message routines.
+ * These are suitable for Unix-like systems and others where writing to
+ * stderr is the right thing to do.  Many applications will want to replace
+ * some or all of these routines.
+ *
+ * If you define USE_WINDOWS_MESSAGEBOX in jconfig.h or in the makefile,
+ * you get a Windows-specific hack to display error messages in a dialog box.
+ * It ain't much, but it beats dropping error messages into the bit bucket,
+ * which is what happens to output to stderr under most Windows C compilers.
+ *
+ * These routines are used by both the compression and decompression code.
+ */
+
+/* this is not a core library module, so it doesn't define JPEG_INTERNALS */
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jversion.h"
+#include "jerror.h"
+
+#ifdef USE_WINDOWS_MESSAGEBOX
+#include <windows.h>
+#endif
+
+#ifndef EXIT_FAILURE            /* define exit() codes if not provided */
+#define EXIT_FAILURE  1
+#endif
+
+
+/*
+ * Create the message string table.
+ * We do this from the master message list in jerror.h by re-reading
+ * jerror.h with a suitable definition for macro JMESSAGE.
+ * The message table is made an external symbol just in case any applications
+ * want to refer to it directly.
+ */
+
+#define JMESSAGE(code, string)  string,
+
+const char * const jpeg_std_message_table[] = {
+#include "jerror.h"
+  NULL
+};
+
+
+/*
+ * Error exit handler: must not return to caller.
+ *
+ * Applications may override this if they want to get control back after
+ * an error.  Typically one would longjmp somewhere instead of exiting.
+ * The setjmp buffer can be made a private field within an expanded error
+ * handler object.  Note that the info needed to generate an error message
+ * is stored in the error object, so you can generate the message now or
+ * later, at your convenience.
+ * You should make sure that the JPEG object is cleaned up (with jpeg_abort
+ * or jpeg_destroy) at some point.
+ */
+
+METHODDEF(void)
+error_exit(j_common_ptr cinfo)
+{
+  /* Always display the message */
+  (*cinfo->err->output_message) (cinfo);
+
+  /* Let the memory manager delete any temp files before we die */
+  jpeg_destroy(cinfo);
+
+  exit(EXIT_FAILURE);
+}
+
+
+/*
+ * Actual output of an error or trace message.
+ * Applications may override this method to send JPEG messages somewhere
+ * other than stderr.
+ *
+ * On Windows, printing to stderr is generally completely useless,
+ * so we provide optional code to produce an error-dialog popup.
+ * Most Windows applications will still prefer to override this routine,
+ * but if they don't, it'll do something at least marginally useful.
+ *
+ * NOTE: to use the library in an environment that doesn't support the
+ * C stdio library, you may have to delete the call to fprintf() entirely,
+ * not just not use this routine.
+ */
+
+METHODDEF(void)
+output_message(j_common_ptr cinfo)
+{
+  char buffer[JMSG_LENGTH_MAX];
+
+  /* Create the message */
+  (*cinfo->err->format_message) (cinfo, buffer);
+
+#ifdef USE_WINDOWS_MESSAGEBOX
+  /* Display it in a message dialog box */
+  MessageBox(GetActiveWindow(), buffer, "JPEG Library Error",
+             MB_OK | MB_ICONERROR);
+#else
+  /* Send it to stderr, adding a newline */
+  fprintf(stderr, "%s\n", buffer);
+#endif
+}
+
+
+/*
+ * Decide whether to emit a trace or warning message.
+ * msg_level is one of:
+ *   -1: recoverable corrupt-data warning, may want to abort.
+ *    0: important advisory messages (always display to user).
+ *    1: first level of tracing detail.
+ *    2,3,...: successively more detailed tracing messages.
+ * An application might override this method if it wanted to abort on warnings
+ * or change the policy about which messages to display.
+ */
+
+METHODDEF(void)
+emit_message(j_common_ptr cinfo, int msg_level)
+{
+  struct jpeg_error_mgr *err = cinfo->err;
+
+  if (msg_level < 0) {
+    /* It's a warning message.  Since corrupt files may generate many warnings,
+     * the policy implemented here is to show only the first warning,
+     * unless trace_level >= 3.
+     */
+    if (err->num_warnings == 0 || err->trace_level >= 3)
+      (*err->output_message) (cinfo);
+    /* Always count warnings in num_warnings. */
+    err->num_warnings++;
+  } else {
+    /* It's a trace message.  Show it if trace_level >= msg_level. */
+    if (err->trace_level >= msg_level)
+      (*err->output_message) (cinfo);
+  }
+}
+
+
+/*
+ * Format a message string for the most recent JPEG error or message.
+ * The message is stored into buffer, which should be at least JMSG_LENGTH_MAX
+ * characters.  Note that no '\n' character is added to the string.
+ * Few applications should need to override this method.
+ */
+
+METHODDEF(void)
+format_message(j_common_ptr cinfo, char *buffer)
+{
+  struct jpeg_error_mgr *err = cinfo->err;
+  int msg_code = err->msg_code;
+  const char *msgtext = NULL;
+  const char *msgptr;
+  char ch;
+  boolean isstring;
+
+  /* Look up message string in proper table */
+  if (msg_code > 0 && msg_code <= err->last_jpeg_message) {
+    msgtext = err->jpeg_message_table[msg_code];
+  } else if (err->addon_message_table != NULL &&
+             msg_code >= err->first_addon_message &&
+             msg_code <= err->last_addon_message) {
+    msgtext = err->addon_message_table[msg_code - err->first_addon_message];
+  }
+
+  /* Defend against bogus message number */
+  if (msgtext == NULL) {
+    err->msg_parm.i[0] = msg_code;
+    msgtext = err->jpeg_message_table[0];
+  }
+
+  /* Check for string parameter, as indicated by %s in the message text */
+  isstring = FALSE;
+  msgptr = msgtext;
+  while ((ch = *msgptr++) != '\0') {
+    if (ch == '%') {
+      if (*msgptr == 's') isstring = TRUE;
+      break;
+    }
+  }
+
+  /* Format the message into the passed buffer */
+  if (isstring)
+    sprintf(buffer, msgtext, err->msg_parm.s);
+  else
+    sprintf(buffer, msgtext,
+            err->msg_parm.i[0], err->msg_parm.i[1],
+            err->msg_parm.i[2], err->msg_parm.i[3],
+            err->msg_parm.i[4], err->msg_parm.i[5],
+            err->msg_parm.i[6], err->msg_parm.i[7]);
+}
+
+
+/*
+ * Reset error state variables at start of a new image.
+ * This is called during compression startup to reset trace/error
+ * processing to default state, without losing any application-specific
+ * method pointers.  An application might possibly want to override
+ * this method if it has additional error processing state.
+ */
+
+METHODDEF(void)
+reset_error_mgr(j_common_ptr cinfo)
+{
+  cinfo->err->num_warnings = 0;
+  /* trace_level is not reset since it is an application-supplied parameter */
+  cinfo->err->msg_code = 0;     /* may be useful as a flag for "no error" */
+}
+
+
+/*
+ * Fill in the standard error-handling methods in a jpeg_error_mgr object.
+ * Typical call is:
+ *      struct jpeg_compress_struct cinfo;
+ *      struct jpeg_error_mgr err;
+ *
+ *      cinfo.err = jpeg_std_error(&err);
+ * after which the application may override some of the methods.
+ */
+
+GLOBAL(struct jpeg_error_mgr *)
+jpeg_std_error(struct jpeg_error_mgr *err)
+{
+  err->error_exit = error_exit;
+  err->emit_message = emit_message;
+  err->output_message = output_message;
+  err->format_message = format_message;
+  err->reset_error_mgr = reset_error_mgr;
+
+  err->trace_level = 0;         /* default = no tracing */
+  err->num_warnings = 0;        /* no warnings emitted yet */
+  err->msg_code = 0;            /* may be useful as a flag for "no error" */
+
+  /* Initialize message table pointers */
+  err->jpeg_message_table = jpeg_std_message_table;
+  err->last_jpeg_message = (int)JMSG_LASTMSGCODE - 1;
+
+  err->addon_message_table = NULL;
+  err->first_addon_message = 0; /* for safety */
+  err->last_addon_message = 0;
+
+  return err;
+}
diff --git a/3rdparty/libjpeg/src/jerror.h b/3rdparty/libjpeg/src/jerror.h
new file mode 100644
index 00000000..4476df2c
--- /dev/null
+++ b/3rdparty/libjpeg/src/jerror.h
@@ -0,0 +1,329 @@
+/*
+ * jerror.h
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1994-1997, Thomas G. Lane.
+ * Modified 1997-2009 by Guido Vollbeding.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2014, 2017, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file defines the error and message codes for the JPEG library.
+ * Edit this file to add new codes, or to translate the message strings to
+ * some other language.
+ * A set of error-reporting macros are defined too.  Some applications using
+ * the JPEG library may wish to include this file to get the error codes
+ * and/or the macros.
+ */
+
+/*
+ * To define the enum list of message codes, include this file without
+ * defining macro JMESSAGE.  To create a message string table, include it
+ * again with a suitable JMESSAGE definition (see jerror.c for an example).
+ */
+#ifndef JMESSAGE
+#ifndef JERROR_H
+/* First time through, define the enum list */
+#define JMAKE_ENUM_LIST
+#else
+/* Repeated inclusions of this file are no-ops unless JMESSAGE is defined */
+#define JMESSAGE(code, string)
+#endif /* JERROR_H */
+#endif /* JMESSAGE */
+
+#ifdef JMAKE_ENUM_LIST
+
+typedef enum {
+
+#define JMESSAGE(code, string)  code,
+
+#endif /* JMAKE_ENUM_LIST */
+
+JMESSAGE(JMSG_NOMESSAGE, "Bogus message code %d") /* Must be first entry! */
+
+/* For maintenance convenience, list is alphabetical by message code name */
+#if JPEG_LIB_VERSION < 70
+JMESSAGE(JERR_ARITH_NOTIMPL, "Sorry, arithmetic coding is not implemented")
+#endif
+JMESSAGE(JERR_BAD_ALIGN_TYPE, "ALIGN_TYPE is wrong, please fix")
+JMESSAGE(JERR_BAD_ALLOC_CHUNK, "MAX_ALLOC_CHUNK is wrong, please fix")
+JMESSAGE(JERR_BAD_BUFFER_MODE, "Bogus buffer control mode")
+JMESSAGE(JERR_BAD_COMPONENT_ID, "Invalid component ID %d in SOS")
+#if JPEG_LIB_VERSION >= 70
+JMESSAGE(JERR_BAD_CROP_SPEC, "Invalid crop request")
+#endif
+JMESSAGE(JERR_BAD_DCT_COEF, "DCT coefficient out of range")
+JMESSAGE(JERR_BAD_DCTSIZE, "IDCT output block size %d not supported")
+#if JPEG_LIB_VERSION >= 70
+JMESSAGE(JERR_BAD_DROP_SAMPLING,
+         "Component index %d: mismatching sampling ratio %d:%d, %d:%d, %c")
+#endif
+JMESSAGE(JERR_BAD_HUFF_TABLE, "Bogus Huffman table definition")
+JMESSAGE(JERR_BAD_IN_COLORSPACE, "Bogus input colorspace")
+JMESSAGE(JERR_BAD_J_COLORSPACE, "Bogus JPEG colorspace")
+JMESSAGE(JERR_BAD_LENGTH, "Bogus marker length")
+JMESSAGE(JERR_BAD_LIB_VERSION,
+         "Wrong JPEG library version: library is %d, caller expects %d")
+JMESSAGE(JERR_BAD_MCU_SIZE, "Sampling factors too large for interleaved scan")
+JMESSAGE(JERR_BAD_POOL_ID, "Invalid memory pool code %d")
+JMESSAGE(JERR_BAD_PRECISION, "Unsupported JPEG data precision %d")
+JMESSAGE(JERR_BAD_PROGRESSION,
+         "Invalid progressive parameters Ss=%d Se=%d Ah=%d Al=%d")
+JMESSAGE(JERR_BAD_PROG_SCRIPT,
+         "Invalid progressive parameters at scan script entry %d")
+JMESSAGE(JERR_BAD_SAMPLING, "Bogus sampling factors")
+JMESSAGE(JERR_BAD_SCAN_SCRIPT, "Invalid scan script at entry %d")
+JMESSAGE(JERR_BAD_STATE, "Improper call to JPEG library in state %d")
+JMESSAGE(JERR_BAD_STRUCT_SIZE,
+         "JPEG parameter struct mismatch: library thinks size is %u, caller expects %u")
+JMESSAGE(JERR_BAD_VIRTUAL_ACCESS, "Bogus virtual array access")
+JMESSAGE(JERR_BUFFER_SIZE, "Buffer passed to JPEG library is too small")
+JMESSAGE(JERR_CANT_SUSPEND, "Suspension not allowed here")
+JMESSAGE(JERR_CCIR601_NOTIMPL, "CCIR601 sampling not implemented yet")
+JMESSAGE(JERR_COMPONENT_COUNT, "Too many color components: %d, max %d")
+JMESSAGE(JERR_CONVERSION_NOTIMPL, "Unsupported color conversion request")
+JMESSAGE(JERR_DAC_INDEX, "Bogus DAC index %d")
+JMESSAGE(JERR_DAC_VALUE, "Bogus DAC value 0x%x")
+JMESSAGE(JERR_DHT_INDEX, "Bogus DHT index %d")
+JMESSAGE(JERR_DQT_INDEX, "Bogus DQT index %d")
+JMESSAGE(JERR_EMPTY_IMAGE, "Empty JPEG image (DNL not supported)")
+JMESSAGE(JERR_EMS_READ, "Read from EMS failed")
+JMESSAGE(JERR_EMS_WRITE, "Write to EMS failed")
+JMESSAGE(JERR_EOI_EXPECTED, "Didn't expect more than one scan")
+JMESSAGE(JERR_FILE_READ, "Input file read error")
+JMESSAGE(JERR_FILE_WRITE, "Output file write error --- out of disk space?")
+JMESSAGE(JERR_FRACT_SAMPLE_NOTIMPL, "Fractional sampling not implemented yet")
+JMESSAGE(JERR_HUFF_CLEN_OVERFLOW, "Huffman code size table overflow")
+JMESSAGE(JERR_HUFF_MISSING_CODE, "Missing Huffman code table entry")
+JMESSAGE(JERR_IMAGE_TOO_BIG, "Maximum supported image dimension is %u pixels")
+JMESSAGE(JERR_INPUT_EMPTY, "Empty input file")
+JMESSAGE(JERR_INPUT_EOF, "Premature end of input file")
+JMESSAGE(JERR_MISMATCHED_QUANT_TABLE,
+         "Cannot transcode due to multiple use of quantization table %d")
+JMESSAGE(JERR_MISSING_DATA, "Scan script does not transmit all data")
+JMESSAGE(JERR_MODE_CHANGE, "Invalid color quantization mode change")
+JMESSAGE(JERR_NOTIMPL, "Not implemented yet")
+JMESSAGE(JERR_NOT_COMPILED, "Requested feature was omitted at compile time")
+#if JPEG_LIB_VERSION >= 70
+JMESSAGE(JERR_NO_ARITH_TABLE, "Arithmetic table 0x%02x was not defined")
+#endif
+JMESSAGE(JERR_NO_BACKING_STORE, "Backing store not supported")
+JMESSAGE(JERR_NO_HUFF_TABLE, "Huffman table 0x%02x was not defined")
+JMESSAGE(JERR_NO_IMAGE, "JPEG datastream contains no image")
+JMESSAGE(JERR_NO_QUANT_TABLE, "Quantization table 0x%02x was not defined")
+JMESSAGE(JERR_NO_SOI, "Not a JPEG file: starts with 0x%02x 0x%02x")
+JMESSAGE(JERR_OUT_OF_MEMORY, "Insufficient memory (case %d)")
+JMESSAGE(JERR_QUANT_COMPONENTS,
+         "Cannot quantize more than %d color components")
+JMESSAGE(JERR_QUANT_FEW_COLORS, "Cannot quantize to fewer than %d colors")
+JMESSAGE(JERR_QUANT_MANY_COLORS, "Cannot quantize to more than %d colors")
+JMESSAGE(JERR_SOF_DUPLICATE, "Invalid JPEG file structure: two SOF markers")
+JMESSAGE(JERR_SOF_NO_SOS, "Invalid JPEG file structure: missing SOS marker")
+JMESSAGE(JERR_SOF_UNSUPPORTED, "Unsupported JPEG process: SOF type 0x%02x")
+JMESSAGE(JERR_SOI_DUPLICATE, "Invalid JPEG file structure: two SOI markers")
+JMESSAGE(JERR_SOS_NO_SOF, "Invalid JPEG file structure: SOS before SOF")
+JMESSAGE(JERR_TFILE_CREATE, "Failed to create temporary file %s")
+JMESSAGE(JERR_TFILE_READ, "Read failed on temporary file")
+JMESSAGE(JERR_TFILE_SEEK, "Seek failed on temporary file")
+JMESSAGE(JERR_TFILE_WRITE,
+         "Write failed on temporary file --- out of disk space?")
+JMESSAGE(JERR_TOO_LITTLE_DATA, "Application transferred too few scanlines")
+JMESSAGE(JERR_UNKNOWN_MARKER, "Unsupported marker type 0x%02x")
+JMESSAGE(JERR_VIRTUAL_BUG, "Virtual array controller messed up")
+JMESSAGE(JERR_WIDTH_OVERFLOW, "Image too wide for this implementation")
+JMESSAGE(JERR_XMS_READ, "Read from XMS failed")
+JMESSAGE(JERR_XMS_WRITE, "Write to XMS failed")
+JMESSAGE(JMSG_COPYRIGHT, JCOPYRIGHT_SHORT)
+JMESSAGE(JMSG_VERSION, JVERSION)
+JMESSAGE(JTRC_16BIT_TABLES,
+         "Caution: quantization tables are too coarse for baseline JPEG")
+JMESSAGE(JTRC_ADOBE,
+         "Adobe APP14 marker: version %d, flags 0x%04x 0x%04x, transform %d")
+JMESSAGE(JTRC_APP0, "Unknown APP0 marker (not JFIF), length %u")
+JMESSAGE(JTRC_APP14, "Unknown APP14 marker (not Adobe), length %u")
+JMESSAGE(JTRC_DAC, "Define Arithmetic Table 0x%02x: 0x%02x")
+JMESSAGE(JTRC_DHT, "Define Huffman Table 0x%02x")
+JMESSAGE(JTRC_DQT, "Define Quantization Table %d  precision %d")
+JMESSAGE(JTRC_DRI, "Define Restart Interval %u")
+JMESSAGE(JTRC_EMS_CLOSE, "Freed EMS handle %u")
+JMESSAGE(JTRC_EMS_OPEN, "Obtained EMS handle %u")
+JMESSAGE(JTRC_EOI, "End Of Image")
+JMESSAGE(JTRC_HUFFBITS, "        %3d %3d %3d %3d %3d %3d %3d %3d")
+JMESSAGE(JTRC_JFIF, "JFIF APP0 marker: version %d.%02d, density %dx%d  %d")
+JMESSAGE(JTRC_JFIF_BADTHUMBNAILSIZE,
+         "Warning: thumbnail image size does not match data length %u")
+JMESSAGE(JTRC_JFIF_EXTENSION, "JFIF extension marker: type 0x%02x, length %u")
+JMESSAGE(JTRC_JFIF_THUMBNAIL, "    with %d x %d thumbnail image")
+JMESSAGE(JTRC_MISC_MARKER, "Miscellaneous marker 0x%02x, length %u")
+JMESSAGE(JTRC_PARMLESS_MARKER, "Unexpected marker 0x%02x")
+JMESSAGE(JTRC_QUANTVALS, "        %4u %4u %4u %4u %4u %4u %4u %4u")
+JMESSAGE(JTRC_QUANT_3_NCOLORS, "Quantizing to %d = %d*%d*%d colors")
+JMESSAGE(JTRC_QUANT_NCOLORS, "Quantizing to %d colors")
+JMESSAGE(JTRC_QUANT_SELECTED, "Selected %d colors for quantization")
+JMESSAGE(JTRC_RECOVERY_ACTION, "At marker 0x%02x, recovery action %d")
+JMESSAGE(JTRC_RST, "RST%d")
+JMESSAGE(JTRC_SMOOTH_NOTIMPL,
+         "Smoothing not supported with nonstandard sampling ratios")
+JMESSAGE(JTRC_SOF, "Start Of Frame 0x%02x: width=%u, height=%u, components=%d")
+JMESSAGE(JTRC_SOF_COMPONENT, "    Component %d: %dhx%dv q=%d")
+JMESSAGE(JTRC_SOI, "Start of Image")
+JMESSAGE(JTRC_SOS, "Start Of Scan: %d components")
+JMESSAGE(JTRC_SOS_COMPONENT, "    Component %d: dc=%d ac=%d")
+JMESSAGE(JTRC_SOS_PARAMS, "  Ss=%d, Se=%d, Ah=%d, Al=%d")
+JMESSAGE(JTRC_TFILE_CLOSE, "Closed temporary file %s")
+JMESSAGE(JTRC_TFILE_OPEN, "Opened temporary file %s")
+JMESSAGE(JTRC_THUMB_JPEG,
+         "JFIF extension marker: JPEG-compressed thumbnail image, length %u")
+JMESSAGE(JTRC_THUMB_PALETTE,
+         "JFIF extension marker: palette thumbnail image, length %u")
+JMESSAGE(JTRC_THUMB_RGB,
+         "JFIF extension marker: RGB thumbnail image, length %u")
+JMESSAGE(JTRC_UNKNOWN_IDS,
+         "Unrecognized component IDs %d %d %d, assuming YCbCr")
+JMESSAGE(JTRC_XMS_CLOSE, "Freed XMS handle %u")
+JMESSAGE(JTRC_XMS_OPEN, "Obtained XMS handle %u")
+JMESSAGE(JWRN_ADOBE_XFORM, "Unknown Adobe color transform code %d")
+#if JPEG_LIB_VERSION >= 70
+JMESSAGE(JWRN_ARITH_BAD_CODE, "Corrupt JPEG data: bad arithmetic code")
+#endif
+JMESSAGE(JWRN_BOGUS_PROGRESSION,
+         "Inconsistent progression sequence for component %d coefficient %d")
+JMESSAGE(JWRN_EXTRANEOUS_DATA,
+         "Corrupt JPEG data: %u extraneous bytes before marker 0x%02x")
+JMESSAGE(JWRN_HIT_MARKER, "Corrupt JPEG data: premature end of data segment")
+JMESSAGE(JWRN_HUFF_BAD_CODE, "Corrupt JPEG data: bad Huffman code")
+JMESSAGE(JWRN_JFIF_MAJOR, "Warning: unknown JFIF revision number %d.%02d")
+JMESSAGE(JWRN_JPEG_EOF, "Premature end of JPEG file")
+JMESSAGE(JWRN_MUST_RESYNC,
+         "Corrupt JPEG data: found marker 0x%02x instead of RST%d")
+JMESSAGE(JWRN_NOT_SEQUENTIAL, "Invalid SOS parameters for sequential JPEG")
+JMESSAGE(JWRN_TOO_MUCH_DATA, "Application transferred too many scanlines")
+#if JPEG_LIB_VERSION < 70
+JMESSAGE(JERR_BAD_CROP_SPEC, "Invalid crop request")
+#if defined(C_ARITH_CODING_SUPPORTED) || defined(D_ARITH_CODING_SUPPORTED)
+JMESSAGE(JERR_NO_ARITH_TABLE, "Arithmetic table 0x%02x was not defined")
+JMESSAGE(JWRN_ARITH_BAD_CODE, "Corrupt JPEG data: bad arithmetic code")
+#endif
+#endif
+JMESSAGE(JWRN_BOGUS_ICC, "Corrupt JPEG data: bad ICC marker")
+#if JPEG_LIB_VERSION < 70
+JMESSAGE(JERR_BAD_DROP_SAMPLING,
+         "Component index %d: mismatching sampling ratio %d:%d, %d:%d, %c")
+#endif
+
+#ifdef JMAKE_ENUM_LIST
+
+  JMSG_LASTMSGCODE
+} J_MESSAGE_CODE;
+
+#undef JMAKE_ENUM_LIST
+#endif /* JMAKE_ENUM_LIST */
+
+/* Zap JMESSAGE macro so that future re-inclusions do nothing by default */
+#undef JMESSAGE
+
+
+#ifndef JERROR_H
+#define JERROR_H
+
+/* Macros to simplify using the error and trace message stuff */
+/* The first parameter is either type of cinfo pointer */
+
+/* Fatal errors (print message and exit) */
+#define ERREXIT(cinfo, code) \
+  ((cinfo)->err->msg_code = (code), \
+   (*(cinfo)->err->error_exit) ((j_common_ptr)(cinfo)))
+#define ERREXIT1(cinfo, code, p1) \
+  ((cinfo)->err->msg_code = (code), \
+   (cinfo)->err->msg_parm.i[0] = (p1), \
+   (*(cinfo)->err->error_exit) ((j_common_ptr)(cinfo)))
+#define ERREXIT2(cinfo, code, p1, p2) \
+  ((cinfo)->err->msg_code = (code), \
+   (cinfo)->err->msg_parm.i[0] = (p1), \
+   (cinfo)->err->msg_parm.i[1] = (p2), \
+   (*(cinfo)->err->error_exit) ((j_common_ptr)(cinfo)))
+#define ERREXIT3(cinfo, code, p1, p2, p3) \
+  ((cinfo)->err->msg_code = (code), \
+   (cinfo)->err->msg_parm.i[0] = (p1), \
+   (cinfo)->err->msg_parm.i[1] = (p2), \
+   (cinfo)->err->msg_parm.i[2] = (p3), \
+   (*(cinfo)->err->error_exit) ((j_common_ptr)(cinfo)))
+#define ERREXIT4(cinfo, code, p1, p2, p3, p4) \
+  ((cinfo)->err->msg_code = (code), \
+   (cinfo)->err->msg_parm.i[0] = (p1), \
+   (cinfo)->err->msg_parm.i[1] = (p2), \
+   (cinfo)->err->msg_parm.i[2] = (p3), \
+   (cinfo)->err->msg_parm.i[3] = (p4), \
+   (*(cinfo)->err->error_exit) ((j_common_ptr)(cinfo)))
+#define ERREXIT6(cinfo, code, p1, p2, p3, p4, p5, p6) \
+  ((cinfo)->err->msg_code = (code), \
+   (cinfo)->err->msg_parm.i[0] = (p1), \
+   (cinfo)->err->msg_parm.i[1] = (p2), \
+   (cinfo)->err->msg_parm.i[2] = (p3), \
+   (cinfo)->err->msg_parm.i[3] = (p4), \
+   (cinfo)->err->msg_parm.i[4] = (p5), \
+   (cinfo)->err->msg_parm.i[5] = (p6), \
+   (*(cinfo)->err->error_exit) ((j_common_ptr)(cinfo)))
+#define ERREXITS(cinfo, code, str) \
+  ((cinfo)->err->msg_code = (code), \
+   strncpy((cinfo)->err->msg_parm.s, (str), JMSG_STR_PARM_MAX), \
+   (*(cinfo)->err->error_exit) ((j_common_ptr)(cinfo)))
+
+#define MAKESTMT(stuff)         do { stuff } while (0)
+
+/* Nonfatal errors (we can keep going, but the data is probably corrupt) */
+#define WARNMS(cinfo, code) \
+  ((cinfo)->err->msg_code = (code), \
+   (*(cinfo)->err->emit_message) ((j_common_ptr)(cinfo), -1))
+#define WARNMS1(cinfo, code, p1) \
+  ((cinfo)->err->msg_code = (code), \
+   (cinfo)->err->msg_parm.i[0] = (p1), \
+   (*(cinfo)->err->emit_message) ((j_common_ptr)(cinfo), -1))
+#define WARNMS2(cinfo, code, p1, p2) \
+  ((cinfo)->err->msg_code = (code), \
+   (cinfo)->err->msg_parm.i[0] = (p1), \
+   (cinfo)->err->msg_parm.i[1] = (p2), \
+   (*(cinfo)->err->emit_message) ((j_common_ptr)(cinfo), -1))
+
+/* Informational/debugging messages */
+#define TRACEMS(cinfo, lvl, code) \
+  ((cinfo)->err->msg_code = (code), \
+   (*(cinfo)->err->emit_message) ((j_common_ptr)(cinfo), (lvl)))
+#define TRACEMS1(cinfo, lvl, code, p1) \
+  ((cinfo)->err->msg_code = (code), \
+   (cinfo)->err->msg_parm.i[0] = (p1), \
+   (*(cinfo)->err->emit_message) ((j_common_ptr)(cinfo), (lvl)))
+#define TRACEMS2(cinfo, lvl, code, p1, p2) \
+  ((cinfo)->err->msg_code = (code), \
+   (cinfo)->err->msg_parm.i[0] = (p1), \
+   (cinfo)->err->msg_parm.i[1] = (p2), \
+   (*(cinfo)->err->emit_message) ((j_common_ptr)(cinfo), (lvl)))
+#define TRACEMS3(cinfo, lvl, code, p1, p2, p3) \
+  MAKESTMT(int *_mp = (cinfo)->err->msg_parm.i; \
+           _mp[0] = (p1);  _mp[1] = (p2);  _mp[2] = (p3); \
+           (cinfo)->err->msg_code = (code); \
+           (*(cinfo)->err->emit_message) ((j_common_ptr)(cinfo), (lvl)); )
+#define TRACEMS4(cinfo, lvl, code, p1, p2, p3, p4) \
+  MAKESTMT(int *_mp = (cinfo)->err->msg_parm.i; \
+           _mp[0] = (p1);  _mp[1] = (p2);  _mp[2] = (p3);  _mp[3] = (p4); \
+           (cinfo)->err->msg_code = (code); \
+           (*(cinfo)->err->emit_message) ((j_common_ptr)(cinfo), (lvl)); )
+#define TRACEMS5(cinfo, lvl, code, p1, p2, p3, p4, p5) \
+  MAKESTMT(int *_mp = (cinfo)->err->msg_parm.i; \
+           _mp[0] = (p1);  _mp[1] = (p2);  _mp[2] = (p3);  _mp[3] = (p4); \
+           _mp[4] = (p5); \
+           (cinfo)->err->msg_code = (code); \
+           (*(cinfo)->err->emit_message) ((j_common_ptr)(cinfo), (lvl)); )
+#define TRACEMS8(cinfo, lvl, code, p1, p2, p3, p4, p5, p6, p7, p8) \
+  MAKESTMT(int *_mp = (cinfo)->err->msg_parm.i; \
+           _mp[0] = (p1);  _mp[1] = (p2);  _mp[2] = (p3);  _mp[3] = (p4); \
+           _mp[4] = (p5);  _mp[5] = (p6);  _mp[6] = (p7);  _mp[7] = (p8); \
+           (cinfo)->err->msg_code = (code); \
+           (*(cinfo)->err->emit_message) ((j_common_ptr)(cinfo), (lvl)); )
+#define TRACEMSS(cinfo, lvl, code, str) \
+  ((cinfo)->err->msg_code = (code), \
+   strncpy((cinfo)->err->msg_parm.s, (str), JMSG_STR_PARM_MAX), \
+   (*(cinfo)->err->emit_message) ((j_common_ptr)(cinfo), (lvl)))
+
+#endif /* JERROR_H */
diff --git a/3rdparty/libjpeg/src/jfdctflt.c b/3rdparty/libjpeg/src/jfdctflt.c
new file mode 100644
index 00000000..ab6f6d08
--- /dev/null
+++ b/3rdparty/libjpeg/src/jfdctflt.c
@@ -0,0 +1,169 @@
+/*
+ * jfdctflt.c
+ *
+ * Copyright (C) 1994-1996, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains a floating-point implementation of the
+ * forward DCT (Discrete Cosine Transform).
+ *
+ * This implementation should be more accurate than either of the integer
+ * DCT implementations.  However, it may not give the same results on all
+ * machines because of differences in roundoff behavior.  Speed will depend
+ * on the hardware's floating point capacity.
+ *
+ * A 2-D DCT can be done by 1-D DCT on each row followed by 1-D DCT
+ * on each column.  Direct algorithms are also available, but they are
+ * much more complex and seem not to be any faster when reduced to code.
+ *
+ * This implementation is based on Arai, Agui, and Nakajima's algorithm for
+ * scaled DCT.  Their original paper (Trans. IEICE E-71(11):1095) is in
+ * Japanese, but the algorithm is described in the Pennebaker & Mitchell
+ * JPEG textbook (see REFERENCES section in file README.ijg).  The following
+ * code is based directly on figure 4-8 in P&M.
+ * While an 8-point DCT cannot be done in less than 11 multiplies, it is
+ * possible to arrange the computation so that many of the multiplies are
+ * simple scalings of the final outputs.  These multiplies can then be
+ * folded into the multiplications or divisions by the JPEG quantization
+ * table entries.  The AA&N method leaves only 5 multiplies and 29 adds
+ * to be done in the DCT itself.
+ * The primary disadvantage of this method is that with a fixed-point
+ * implementation, accuracy is lost due to imprecise representation of the
+ * scaled quantization values.  However, that problem does not arise if
+ * we use floating point arithmetic.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jdct.h"               /* Private declarations for DCT subsystem */
+
+#ifdef DCT_FLOAT_SUPPORTED
+
+
+/*
+ * This module is specialized to the case DCTSIZE = 8.
+ */
+
+#if DCTSIZE != 8
+  Sorry, this code only copes with 8x8 DCTs. /* deliberate syntax err */
+#endif
+
+
+/*
+ * Perform the forward DCT on one block of samples.
+ */
+
+GLOBAL(void)
+jpeg_fdct_float(FAST_FLOAT *data)
+{
+  FAST_FLOAT tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
+  FAST_FLOAT tmp10, tmp11, tmp12, tmp13;
+  FAST_FLOAT z1, z2, z3, z4, z5, z11, z13;
+  FAST_FLOAT *dataptr;
+  int ctr;
+
+  /* Pass 1: process rows. */
+
+  dataptr = data;
+  for (ctr = DCTSIZE - 1; ctr >= 0; ctr--) {
+    tmp0 = dataptr[0] + dataptr[7];
+    tmp7 = dataptr[0] - dataptr[7];
+    tmp1 = dataptr[1] + dataptr[6];
+    tmp6 = dataptr[1] - dataptr[6];
+    tmp2 = dataptr[2] + dataptr[5];
+    tmp5 = dataptr[2] - dataptr[5];
+    tmp3 = dataptr[3] + dataptr[4];
+    tmp4 = dataptr[3] - dataptr[4];
+
+    /* Even part */
+
+    tmp10 = tmp0 + tmp3;        /* phase 2 */
+    tmp13 = tmp0 - tmp3;
+    tmp11 = tmp1 + tmp2;
+    tmp12 = tmp1 - tmp2;
+
+    dataptr[0] = tmp10 + tmp11; /* phase 3 */
+    dataptr[4] = tmp10 - tmp11;
+
+    z1 = (tmp12 + tmp13) * ((FAST_FLOAT)0.707106781); /* c4 */
+    dataptr[2] = tmp13 + z1;    /* phase 5 */
+    dataptr[6] = tmp13 - z1;
+
+    /* Odd part */
+
+    tmp10 = tmp4 + tmp5;        /* phase 2 */
+    tmp11 = tmp5 + tmp6;
+    tmp12 = tmp6 + tmp7;
+
+    /* The rotator is modified from fig 4-8 to avoid extra negations. */
+    z5 = (tmp10 - tmp12) * ((FAST_FLOAT)0.382683433); /* c6 */
+    z2 = ((FAST_FLOAT)0.541196100) * tmp10 + z5; /* c2-c6 */
+    z4 = ((FAST_FLOAT)1.306562965) * tmp12 + z5; /* c2+c6 */
+    z3 = tmp11 * ((FAST_FLOAT)0.707106781); /* c4 */
+
+    z11 = tmp7 + z3;            /* phase 5 */
+    z13 = tmp7 - z3;
+
+    dataptr[5] = z13 + z2;      /* phase 6 */
+    dataptr[3] = z13 - z2;
+    dataptr[1] = z11 + z4;
+    dataptr[7] = z11 - z4;
+
+    dataptr += DCTSIZE;         /* advance pointer to next row */
+  }
+
+  /* Pass 2: process columns. */
+
+  dataptr = data;
+  for (ctr = DCTSIZE - 1; ctr >= 0; ctr--) {
+    tmp0 = dataptr[DCTSIZE * 0] + dataptr[DCTSIZE * 7];
+    tmp7 = dataptr[DCTSIZE * 0] - dataptr[DCTSIZE * 7];
+    tmp1 = dataptr[DCTSIZE * 1] + dataptr[DCTSIZE * 6];
+    tmp6 = dataptr[DCTSIZE * 1] - dataptr[DCTSIZE * 6];
+    tmp2 = dataptr[DCTSIZE * 2] + dataptr[DCTSIZE * 5];
+    tmp5 = dataptr[DCTSIZE * 2] - dataptr[DCTSIZE * 5];
+    tmp3 = dataptr[DCTSIZE * 3] + dataptr[DCTSIZE * 4];
+    tmp4 = dataptr[DCTSIZE * 3] - dataptr[DCTSIZE * 4];
+
+    /* Even part */
+
+    tmp10 = tmp0 + tmp3;        /* phase 2 */
+    tmp13 = tmp0 - tmp3;
+    tmp11 = tmp1 + tmp2;
+    tmp12 = tmp1 - tmp2;
+
+    dataptr[DCTSIZE * 0] = tmp10 + tmp11; /* phase 3 */
+    dataptr[DCTSIZE * 4] = tmp10 - tmp11;
+
+    z1 = (tmp12 + tmp13) * ((FAST_FLOAT)0.707106781); /* c4 */
+    dataptr[DCTSIZE * 2] = tmp13 + z1; /* phase 5 */
+    dataptr[DCTSIZE * 6] = tmp13 - z1;
+
+    /* Odd part */
+
+    tmp10 = tmp4 + tmp5;        /* phase 2 */
+    tmp11 = tmp5 + tmp6;
+    tmp12 = tmp6 + tmp7;
+
+    /* The rotator is modified from fig 4-8 to avoid extra negations. */
+    z5 = (tmp10 - tmp12) * ((FAST_FLOAT)0.382683433); /* c6 */
+    z2 = ((FAST_FLOAT)0.541196100) * tmp10 + z5; /* c2-c6 */
+    z4 = ((FAST_FLOAT)1.306562965) * tmp12 + z5; /* c2+c6 */
+    z3 = tmp11 * ((FAST_FLOAT)0.707106781); /* c4 */
+
+    z11 = tmp7 + z3;            /* phase 5 */
+    z13 = tmp7 - z3;
+
+    dataptr[DCTSIZE * 5] = z13 + z2; /* phase 6 */
+    dataptr[DCTSIZE * 3] = z13 - z2;
+    dataptr[DCTSIZE * 1] = z11 + z4;
+    dataptr[DCTSIZE * 7] = z11 - z4;
+
+    dataptr++;                  /* advance pointer to next column */
+  }
+}
+
+#endif /* DCT_FLOAT_SUPPORTED */
diff --git a/3rdparty/libjpeg/src/jfdctfst.c b/3rdparty/libjpeg/src/jfdctfst.c
new file mode 100644
index 00000000..4c9ce0de
--- /dev/null
+++ b/3rdparty/libjpeg/src/jfdctfst.c
@@ -0,0 +1,227 @@
+/*
+ * jfdctfst.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1994-1996, Thomas G. Lane.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2015, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains a fast, not so accurate integer implementation of the
+ * forward DCT (Discrete Cosine Transform).
+ *
+ * A 2-D DCT can be done by 1-D DCT on each row followed by 1-D DCT
+ * on each column.  Direct algorithms are also available, but they are
+ * much more complex and seem not to be any faster when reduced to code.
+ *
+ * This implementation is based on Arai, Agui, and Nakajima's algorithm for
+ * scaled DCT.  Their original paper (Trans. IEICE E-71(11):1095) is in
+ * Japanese, but the algorithm is described in the Pennebaker & Mitchell
+ * JPEG textbook (see REFERENCES section in file README.ijg).  The following
+ * code is based directly on figure 4-8 in P&M.
+ * While an 8-point DCT cannot be done in less than 11 multiplies, it is
+ * possible to arrange the computation so that many of the multiplies are
+ * simple scalings of the final outputs.  These multiplies can then be
+ * folded into the multiplications or divisions by the JPEG quantization
+ * table entries.  The AA&N method leaves only 5 multiplies and 29 adds
+ * to be done in the DCT itself.
+ * The primary disadvantage of this method is that with fixed-point math,
+ * accuracy is lost due to imprecise representation of the scaled
+ * quantization values.  The smaller the quantization table entry, the less
+ * precise the scaled value, so this implementation does worse with high-
+ * quality-setting files than with low-quality ones.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jdct.h"               /* Private declarations for DCT subsystem */
+
+#ifdef DCT_IFAST_SUPPORTED
+
+
+/*
+ * This module is specialized to the case DCTSIZE = 8.
+ */
+
+#if DCTSIZE != 8
+  Sorry, this code only copes with 8x8 DCTs. /* deliberate syntax err */
+#endif
+
+
+/* Scaling decisions are generally the same as in the LL&M algorithm;
+ * see jfdctint.c for more details.  However, we choose to descale
+ * (right shift) multiplication products as soon as they are formed,
+ * rather than carrying additional fractional bits into subsequent additions.
+ * This compromises accuracy slightly, but it lets us save a few shifts.
+ * More importantly, 16-bit arithmetic is then adequate (for 8-bit samples)
+ * everywhere except in the multiplications proper; this saves a good deal
+ * of work on 16-bit-int machines.
+ *
+ * Again to save a few shifts, the intermediate results between pass 1 and
+ * pass 2 are not upscaled, but are represented only to integral precision.
+ *
+ * A final compromise is to represent the multiplicative constants to only
+ * 8 fractional bits, rather than 13.  This saves some shifting work on some
+ * machines, and may also reduce the cost of multiplication (since there
+ * are fewer one-bits in the constants).
+ */
+
+#define CONST_BITS  8
+
+
+/* Some C compilers fail to reduce "FIX(constant)" at compile time, thus
+ * causing a lot of useless floating-point operations at run time.
+ * To get around this we use the following pre-calculated constants.
+ * If you change CONST_BITS you may want to add appropriate values.
+ * (With a reasonable C compiler, you can just rely on the FIX() macro...)
+ */
+
+#if CONST_BITS == 8
+#define FIX_0_382683433  ((JLONG)98)            /* FIX(0.382683433) */
+#define FIX_0_541196100  ((JLONG)139)           /* FIX(0.541196100) */
+#define FIX_0_707106781  ((JLONG)181)           /* FIX(0.707106781) */
+#define FIX_1_306562965  ((JLONG)334)           /* FIX(1.306562965) */
+#else
+#define FIX_0_382683433  FIX(0.382683433)
+#define FIX_0_541196100  FIX(0.541196100)
+#define FIX_0_707106781  FIX(0.707106781)
+#define FIX_1_306562965  FIX(1.306562965)
+#endif
+
+
+/* We can gain a little more speed, with a further compromise in accuracy,
+ * by omitting the addition in a descaling shift.  This yields an incorrectly
+ * rounded result half the time...
+ */
+
+#ifndef USE_ACCURATE_ROUNDING
+#undef DESCALE
+#define DESCALE(x, n)  RIGHT_SHIFT(x, n)
+#endif
+
+
+/* Multiply a DCTELEM variable by an JLONG constant, and immediately
+ * descale to yield a DCTELEM result.
+ */
+
+#define MULTIPLY(var, const)  ((DCTELEM)DESCALE((var) * (const), CONST_BITS))
+
+
+/*
+ * Perform the forward DCT on one block of samples.
+ */
+
+GLOBAL(void)
+jpeg_fdct_ifast(DCTELEM *data)
+{
+  DCTELEM tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
+  DCTELEM tmp10, tmp11, tmp12, tmp13;
+  DCTELEM z1, z2, z3, z4, z5, z11, z13;
+  DCTELEM *dataptr;
+  int ctr;
+  SHIFT_TEMPS
+
+  /* Pass 1: process rows. */
+
+  dataptr = data;
+  for (ctr = DCTSIZE - 1; ctr >= 0; ctr--) {
+    tmp0 = dataptr[0] + dataptr[7];
+    tmp7 = dataptr[0] - dataptr[7];
+    tmp1 = dataptr[1] + dataptr[6];
+    tmp6 = dataptr[1] - dataptr[6];
+    tmp2 = dataptr[2] + dataptr[5];
+    tmp5 = dataptr[2] - dataptr[5];
+    tmp3 = dataptr[3] + dataptr[4];
+    tmp4 = dataptr[3] - dataptr[4];
+
+    /* Even part */
+
+    tmp10 = tmp0 + tmp3;        /* phase 2 */
+    tmp13 = tmp0 - tmp3;
+    tmp11 = tmp1 + tmp2;
+    tmp12 = tmp1 - tmp2;
+
+    dataptr[0] = tmp10 + tmp11; /* phase 3 */
+    dataptr[4] = tmp10 - tmp11;
+
+    z1 = MULTIPLY(tmp12 + tmp13, FIX_0_707106781); /* c4 */
+    dataptr[2] = tmp13 + z1;    /* phase 5 */
+    dataptr[6] = tmp13 - z1;
+
+    /* Odd part */
+
+    tmp10 = tmp4 + tmp5;        /* phase 2 */
+    tmp11 = tmp5 + tmp6;
+    tmp12 = tmp6 + tmp7;
+
+    /* The rotator is modified from fig 4-8 to avoid extra negations. */
+    z5 = MULTIPLY(tmp10 - tmp12, FIX_0_382683433); /* c6 */
+    z2 = MULTIPLY(tmp10, FIX_0_541196100) + z5; /* c2-c6 */
+    z4 = MULTIPLY(tmp12, FIX_1_306562965) + z5; /* c2+c6 */
+    z3 = MULTIPLY(tmp11, FIX_0_707106781); /* c4 */
+
+    z11 = tmp7 + z3;            /* phase 5 */
+    z13 = tmp7 - z3;
+
+    dataptr[5] = z13 + z2;      /* phase 6 */
+    dataptr[3] = z13 - z2;
+    dataptr[1] = z11 + z4;
+    dataptr[7] = z11 - z4;
+
+    dataptr += DCTSIZE;         /* advance pointer to next row */
+  }
+
+  /* Pass 2: process columns. */
+
+  dataptr = data;
+  for (ctr = DCTSIZE - 1; ctr >= 0; ctr--) {
+    tmp0 = dataptr[DCTSIZE * 0] + dataptr[DCTSIZE * 7];
+    tmp7 = dataptr[DCTSIZE * 0] - dataptr[DCTSIZE * 7];
+    tmp1 = dataptr[DCTSIZE * 1] + dataptr[DCTSIZE * 6];
+    tmp6 = dataptr[DCTSIZE * 1] - dataptr[DCTSIZE * 6];
+    tmp2 = dataptr[DCTSIZE * 2] + dataptr[DCTSIZE * 5];
+    tmp5 = dataptr[DCTSIZE * 2] - dataptr[DCTSIZE * 5];
+    tmp3 = dataptr[DCTSIZE * 3] + dataptr[DCTSIZE * 4];
+    tmp4 = dataptr[DCTSIZE * 3] - dataptr[DCTSIZE * 4];
+
+    /* Even part */
+
+    tmp10 = tmp0 + tmp3;        /* phase 2 */
+    tmp13 = tmp0 - tmp3;
+    tmp11 = tmp1 + tmp2;
+    tmp12 = tmp1 - tmp2;
+
+    dataptr[DCTSIZE * 0] = tmp10 + tmp11; /* phase 3 */
+    dataptr[DCTSIZE * 4] = tmp10 - tmp11;
+
+    z1 = MULTIPLY(tmp12 + tmp13, FIX_0_707106781); /* c4 */
+    dataptr[DCTSIZE * 2] = tmp13 + z1; /* phase 5 */
+    dataptr[DCTSIZE * 6] = tmp13 - z1;
+
+    /* Odd part */
+
+    tmp10 = tmp4 + tmp5;        /* phase 2 */
+    tmp11 = tmp5 + tmp6;
+    tmp12 = tmp6 + tmp7;
+
+    /* The rotator is modified from fig 4-8 to avoid extra negations. */
+    z5 = MULTIPLY(tmp10 - tmp12, FIX_0_382683433); /* c6 */
+    z2 = MULTIPLY(tmp10, FIX_0_541196100) + z5; /* c2-c6 */
+    z4 = MULTIPLY(tmp12, FIX_1_306562965) + z5; /* c2+c6 */
+    z3 = MULTIPLY(tmp11, FIX_0_707106781); /* c4 */
+
+    z11 = tmp7 + z3;            /* phase 5 */
+    z13 = tmp7 - z3;
+
+    dataptr[DCTSIZE * 5] = z13 + z2; /* phase 6 */
+    dataptr[DCTSIZE * 3] = z13 - z2;
+    dataptr[DCTSIZE * 1] = z11 + z4;
+    dataptr[DCTSIZE * 7] = z11 - z4;
+
+    dataptr++;                  /* advance pointer to next column */
+  }
+}
+
+#endif /* DCT_IFAST_SUPPORTED */
diff --git a/3rdparty/libjpeg/src/jfdctint.c b/3rdparty/libjpeg/src/jfdctint.c
new file mode 100644
index 00000000..c95a3a7f
--- /dev/null
+++ b/3rdparty/libjpeg/src/jfdctint.c
@@ -0,0 +1,288 @@
+/*
+ * jfdctint.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1991-1996, Thomas G. Lane.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2015, 2020, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains a slower but more accurate integer implementation of the
+ * forward DCT (Discrete Cosine Transform).
+ *
+ * A 2-D DCT can be done by 1-D DCT on each row followed by 1-D DCT
+ * on each column.  Direct algorithms are also available, but they are
+ * much more complex and seem not to be any faster when reduced to code.
+ *
+ * This implementation is based on an algorithm described in
+ *   C. Loeffler, A. Ligtenberg and G. Moschytz, "Practical Fast 1-D DCT
+ *   Algorithms with 11 Multiplications", Proc. Int'l. Conf. on Acoustics,
+ *   Speech, and Signal Processing 1989 (ICASSP '89), pp. 988-991.
+ * The primary algorithm described there uses 11 multiplies and 29 adds.
+ * We use their alternate method with 12 multiplies and 32 adds.
+ * The advantage of this method is that no data path contains more than one
+ * multiplication; this allows a very simple and accurate implementation in
+ * scaled fixed-point arithmetic, with a minimal number of shifts.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jdct.h"               /* Private declarations for DCT subsystem */
+
+#ifdef DCT_ISLOW_SUPPORTED
+
+
+/*
+ * This module is specialized to the case DCTSIZE = 8.
+ */
+
+#if DCTSIZE != 8
+  Sorry, this code only copes with 8x8 DCTs. /* deliberate syntax err */
+#endif
+
+
+/*
+ * The poop on this scaling stuff is as follows:
+ *
+ * Each 1-D DCT step produces outputs which are a factor of sqrt(N)
+ * larger than the true DCT outputs.  The final outputs are therefore
+ * a factor of N larger than desired; since N=8 this can be cured by
+ * a simple right shift at the end of the algorithm.  The advantage of
+ * this arrangement is that we save two multiplications per 1-D DCT,
+ * because the y0 and y4 outputs need not be divided by sqrt(N).
+ * In the IJG code, this factor of 8 is removed by the quantization step
+ * (in jcdctmgr.c), NOT in this module.
+ *
+ * We have to do addition and subtraction of the integer inputs, which
+ * is no problem, and multiplication by fractional constants, which is
+ * a problem to do in integer arithmetic.  We multiply all the constants
+ * by CONST_SCALE and convert them to integer constants (thus retaining
+ * CONST_BITS bits of precision in the constants).  After doing a
+ * multiplication we have to divide the product by CONST_SCALE, with proper
+ * rounding, to produce the correct output.  This division can be done
+ * cheaply as a right shift of CONST_BITS bits.  We postpone shifting
+ * as long as possible so that partial sums can be added together with
+ * full fractional precision.
+ *
+ * The outputs of the first pass are scaled up by PASS1_BITS bits so that
+ * they are represented to better-than-integral precision.  These outputs
+ * require BITS_IN_JSAMPLE + PASS1_BITS + 3 bits; this fits in a 16-bit word
+ * with the recommended scaling.  (For 12-bit sample data, the intermediate
+ * array is JLONG anyway.)
+ *
+ * To avoid overflow of the 32-bit intermediate results in pass 2, we must
+ * have BITS_IN_JSAMPLE + CONST_BITS + PASS1_BITS <= 26.  Error analysis
+ * shows that the values given below are the most effective.
+ */
+
+#if BITS_IN_JSAMPLE == 8
+#define CONST_BITS  13
+#define PASS1_BITS  2
+#else
+#define CONST_BITS  13
+#define PASS1_BITS  1           /* lose a little precision to avoid overflow */
+#endif
+
+/* Some C compilers fail to reduce "FIX(constant)" at compile time, thus
+ * causing a lot of useless floating-point operations at run time.
+ * To get around this we use the following pre-calculated constants.
+ * If you change CONST_BITS you may want to add appropriate values.
+ * (With a reasonable C compiler, you can just rely on the FIX() macro...)
+ */
+
+#if CONST_BITS == 13
+#define FIX_0_298631336  ((JLONG)2446)          /* FIX(0.298631336) */
+#define FIX_0_390180644  ((JLONG)3196)          /* FIX(0.390180644) */
+#define FIX_0_541196100  ((JLONG)4433)          /* FIX(0.541196100) */
+#define FIX_0_765366865  ((JLONG)6270)          /* FIX(0.765366865) */
+#define FIX_0_899976223  ((JLONG)7373)          /* FIX(0.899976223) */
+#define FIX_1_175875602  ((JLONG)9633)          /* FIX(1.175875602) */
+#define FIX_1_501321110  ((JLONG)12299)         /* FIX(1.501321110) */
+#define FIX_1_847759065  ((JLONG)15137)         /* FIX(1.847759065) */
+#define FIX_1_961570560  ((JLONG)16069)         /* FIX(1.961570560) */
+#define FIX_2_053119869  ((JLONG)16819)         /* FIX(2.053119869) */
+#define FIX_2_562915447  ((JLONG)20995)         /* FIX(2.562915447) */
+#define FIX_3_072711026  ((JLONG)25172)         /* FIX(3.072711026) */
+#else
+#define FIX_0_298631336  FIX(0.298631336)
+#define FIX_0_390180644  FIX(0.390180644)
+#define FIX_0_541196100  FIX(0.541196100)
+#define FIX_0_765366865  FIX(0.765366865)
+#define FIX_0_899976223  FIX(0.899976223)
+#define FIX_1_175875602  FIX(1.175875602)
+#define FIX_1_501321110  FIX(1.501321110)
+#define FIX_1_847759065  FIX(1.847759065)
+#define FIX_1_961570560  FIX(1.961570560)
+#define FIX_2_053119869  FIX(2.053119869)
+#define FIX_2_562915447  FIX(2.562915447)
+#define FIX_3_072711026  FIX(3.072711026)
+#endif
+
+
+/* Multiply an JLONG variable by an JLONG constant to yield an JLONG result.
+ * For 8-bit samples with the recommended scaling, all the variable
+ * and constant values involved are no more than 16 bits wide, so a
+ * 16x16->32 bit multiply can be used instead of a full 32x32 multiply.
+ * For 12-bit samples, a full 32-bit multiplication will be needed.
+ */
+
+#if BITS_IN_JSAMPLE == 8
+#define MULTIPLY(var, const)  MULTIPLY16C16(var, const)
+#else
+#define MULTIPLY(var, const)  ((var) * (const))
+#endif
+
+
+/*
+ * Perform the forward DCT on one block of samples.
+ */
+
+GLOBAL(void)
+jpeg_fdct_islow(DCTELEM *data)
+{
+  JLONG tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
+  JLONG tmp10, tmp11, tmp12, tmp13;
+  JLONG z1, z2, z3, z4, z5;
+  DCTELEM *dataptr;
+  int ctr;
+  SHIFT_TEMPS
+
+  /* Pass 1: process rows. */
+  /* Note results are scaled up by sqrt(8) compared to a true DCT; */
+  /* furthermore, we scale the results by 2**PASS1_BITS. */
+
+  dataptr = data;
+  for (ctr = DCTSIZE - 1; ctr >= 0; ctr--) {
+    tmp0 = dataptr[0] + dataptr[7];
+    tmp7 = dataptr[0] - dataptr[7];
+    tmp1 = dataptr[1] + dataptr[6];
+    tmp6 = dataptr[1] - dataptr[6];
+    tmp2 = dataptr[2] + dataptr[5];
+    tmp5 = dataptr[2] - dataptr[5];
+    tmp3 = dataptr[3] + dataptr[4];
+    tmp4 = dataptr[3] - dataptr[4];
+
+    /* Even part per LL&M figure 1 --- note that published figure is faulty;
+     * rotator "sqrt(2)*c1" should be "sqrt(2)*c6".
+     */
+
+    tmp10 = tmp0 + tmp3;
+    tmp13 = tmp0 - tmp3;
+    tmp11 = tmp1 + tmp2;
+    tmp12 = tmp1 - tmp2;
+
+    dataptr[0] = (DCTELEM)LEFT_SHIFT(tmp10 + tmp11, PASS1_BITS);
+    dataptr[4] = (DCTELEM)LEFT_SHIFT(tmp10 - tmp11, PASS1_BITS);
+
+    z1 = MULTIPLY(tmp12 + tmp13, FIX_0_541196100);
+    dataptr[2] = (DCTELEM)DESCALE(z1 + MULTIPLY(tmp13, FIX_0_765366865),
+                                  CONST_BITS - PASS1_BITS);
+    dataptr[6] = (DCTELEM)DESCALE(z1 + MULTIPLY(tmp12, -FIX_1_847759065),
+                                  CONST_BITS - PASS1_BITS);
+
+    /* Odd part per figure 8 --- note paper omits factor of sqrt(2).
+     * cK represents cos(K*pi/16).
+     * i0..i3 in the paper are tmp4..tmp7 here.
+     */
+
+    z1 = tmp4 + tmp7;
+    z2 = tmp5 + tmp6;
+    z3 = tmp4 + tmp6;
+    z4 = tmp5 + tmp7;
+    z5 = MULTIPLY(z3 + z4, FIX_1_175875602); /* sqrt(2) * c3 */
+
+    tmp4 = MULTIPLY(tmp4, FIX_0_298631336); /* sqrt(2) * (-c1+c3+c5-c7) */
+    tmp5 = MULTIPLY(tmp5, FIX_2_053119869); /* sqrt(2) * ( c1+c3-c5+c7) */
+    tmp6 = MULTIPLY(tmp6, FIX_3_072711026); /* sqrt(2) * ( c1+c3+c5-c7) */
+    tmp7 = MULTIPLY(tmp7, FIX_1_501321110); /* sqrt(2) * ( c1+c3-c5-c7) */
+    z1 = MULTIPLY(z1, -FIX_0_899976223); /* sqrt(2) * ( c7-c3) */
+    z2 = MULTIPLY(z2, -FIX_2_562915447); /* sqrt(2) * (-c1-c3) */
+    z3 = MULTIPLY(z3, -FIX_1_961570560); /* sqrt(2) * (-c3-c5) */
+    z4 = MULTIPLY(z4, -FIX_0_390180644); /* sqrt(2) * ( c5-c3) */
+
+    z3 += z5;
+    z4 += z5;
+
+    dataptr[7] = (DCTELEM)DESCALE(tmp4 + z1 + z3, CONST_BITS - PASS1_BITS);
+    dataptr[5] = (DCTELEM)DESCALE(tmp5 + z2 + z4, CONST_BITS - PASS1_BITS);
+    dataptr[3] = (DCTELEM)DESCALE(tmp6 + z2 + z3, CONST_BITS - PASS1_BITS);
+    dataptr[1] = (DCTELEM)DESCALE(tmp7 + z1 + z4, CONST_BITS - PASS1_BITS);
+
+    dataptr += DCTSIZE;         /* advance pointer to next row */
+  }
+
+  /* Pass 2: process columns.
+   * We remove the PASS1_BITS scaling, but leave the results scaled up
+   * by an overall factor of 8.
+   */
+
+  dataptr = data;
+  for (ctr = DCTSIZE - 1; ctr >= 0; ctr--) {
+    tmp0 = dataptr[DCTSIZE * 0] + dataptr[DCTSIZE * 7];
+    tmp7 = dataptr[DCTSIZE * 0] - dataptr[DCTSIZE * 7];
+    tmp1 = dataptr[DCTSIZE * 1] + dataptr[DCTSIZE * 6];
+    tmp6 = dataptr[DCTSIZE * 1] - dataptr[DCTSIZE * 6];
+    tmp2 = dataptr[DCTSIZE * 2] + dataptr[DCTSIZE * 5];
+    tmp5 = dataptr[DCTSIZE * 2] - dataptr[DCTSIZE * 5];
+    tmp3 = dataptr[DCTSIZE * 3] + dataptr[DCTSIZE * 4];
+    tmp4 = dataptr[DCTSIZE * 3] - dataptr[DCTSIZE * 4];
+
+    /* Even part per LL&M figure 1 --- note that published figure is faulty;
+     * rotator "sqrt(2)*c1" should be "sqrt(2)*c6".
+     */
+
+    tmp10 = tmp0 + tmp3;
+    tmp13 = tmp0 - tmp3;
+    tmp11 = tmp1 + tmp2;
+    tmp12 = tmp1 - tmp2;
+
+    dataptr[DCTSIZE * 0] = (DCTELEM)DESCALE(tmp10 + tmp11, PASS1_BITS);
+    dataptr[DCTSIZE * 4] = (DCTELEM)DESCALE(tmp10 - tmp11, PASS1_BITS);
+
+    z1 = MULTIPLY(tmp12 + tmp13, FIX_0_541196100);
+    dataptr[DCTSIZE * 2] =
+      (DCTELEM)DESCALE(z1 + MULTIPLY(tmp13, FIX_0_765366865),
+                       CONST_BITS + PASS1_BITS);
+    dataptr[DCTSIZE * 6] =
+      (DCTELEM)DESCALE(z1 + MULTIPLY(tmp12, -FIX_1_847759065),
+                       CONST_BITS + PASS1_BITS);
+
+    /* Odd part per figure 8 --- note paper omits factor of sqrt(2).
+     * cK represents cos(K*pi/16).
+     * i0..i3 in the paper are tmp4..tmp7 here.
+     */
+
+    z1 = tmp4 + tmp7;
+    z2 = tmp5 + tmp6;
+    z3 = tmp4 + tmp6;
+    z4 = tmp5 + tmp7;
+    z5 = MULTIPLY(z3 + z4, FIX_1_175875602); /* sqrt(2) * c3 */
+
+    tmp4 = MULTIPLY(tmp4, FIX_0_298631336); /* sqrt(2) * (-c1+c3+c5-c7) */
+    tmp5 = MULTIPLY(tmp5, FIX_2_053119869); /* sqrt(2) * ( c1+c3-c5+c7) */
+    tmp6 = MULTIPLY(tmp6, FIX_3_072711026); /* sqrt(2) * ( c1+c3+c5-c7) */
+    tmp7 = MULTIPLY(tmp7, FIX_1_501321110); /* sqrt(2) * ( c1+c3-c5-c7) */
+    z1 = MULTIPLY(z1, -FIX_0_899976223); /* sqrt(2) * ( c7-c3) */
+    z2 = MULTIPLY(z2, -FIX_2_562915447); /* sqrt(2) * (-c1-c3) */
+    z3 = MULTIPLY(z3, -FIX_1_961570560); /* sqrt(2) * (-c3-c5) */
+    z4 = MULTIPLY(z4, -FIX_0_390180644); /* sqrt(2) * ( c5-c3) */
+
+    z3 += z5;
+    z4 += z5;
+
+    dataptr[DCTSIZE * 7] = (DCTELEM)DESCALE(tmp4 + z1 + z3,
+                                            CONST_BITS + PASS1_BITS);
+    dataptr[DCTSIZE * 5] = (DCTELEM)DESCALE(tmp5 + z2 + z4,
+                                            CONST_BITS + PASS1_BITS);
+    dataptr[DCTSIZE * 3] = (DCTELEM)DESCALE(tmp6 + z2 + z3,
+                                            CONST_BITS + PASS1_BITS);
+    dataptr[DCTSIZE * 1] = (DCTELEM)DESCALE(tmp7 + z1 + z4,
+                                            CONST_BITS + PASS1_BITS);
+
+    dataptr++;                  /* advance pointer to next column */
+  }
+}
+
+#endif /* DCT_ISLOW_SUPPORTED */
diff --git a/3rdparty/libjpeg/src/jidctflt.c b/3rdparty/libjpeg/src/jidctflt.c
new file mode 100644
index 00000000..5aee74e2
--- /dev/null
+++ b/3rdparty/libjpeg/src/jidctflt.c
@@ -0,0 +1,240 @@
+/*
+ * jidctflt.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1994-1998, Thomas G. Lane.
+ * Modified 2010 by Guido Vollbeding.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2014, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains a floating-point implementation of the
+ * inverse DCT (Discrete Cosine Transform).  In the IJG code, this routine
+ * must also perform dequantization of the input coefficients.
+ *
+ * This implementation should be more accurate than either of the integer
+ * IDCT implementations.  However, it may not give the same results on all
+ * machines because of differences in roundoff behavior.  Speed will depend
+ * on the hardware's floating point capacity.
+ *
+ * A 2-D IDCT can be done by 1-D IDCT on each column followed by 1-D IDCT
+ * on each row (or vice versa, but it's more convenient to emit a row at
+ * a time).  Direct algorithms are also available, but they are much more
+ * complex and seem not to be any faster when reduced to code.
+ *
+ * This implementation is based on Arai, Agui, and Nakajima's algorithm for
+ * scaled DCT.  Their original paper (Trans. IEICE E-71(11):1095) is in
+ * Japanese, but the algorithm is described in the Pennebaker & Mitchell
+ * JPEG textbook (see REFERENCES section in file README.ijg).  The following
+ * code is based directly on figure 4-8 in P&M.
+ * While an 8-point DCT cannot be done in less than 11 multiplies, it is
+ * possible to arrange the computation so that many of the multiplies are
+ * simple scalings of the final outputs.  These multiplies can then be
+ * folded into the multiplications or divisions by the JPEG quantization
+ * table entries.  The AA&N method leaves only 5 multiplies and 29 adds
+ * to be done in the DCT itself.
+ * The primary disadvantage of this method is that with a fixed-point
+ * implementation, accuracy is lost due to imprecise representation of the
+ * scaled quantization values.  However, that problem does not arise if
+ * we use floating point arithmetic.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jdct.h"               /* Private declarations for DCT subsystem */
+
+#ifdef DCT_FLOAT_SUPPORTED
+
+
+/*
+ * This module is specialized to the case DCTSIZE = 8.
+ */
+
+#if DCTSIZE != 8
+  Sorry, this code only copes with 8x8 DCTs. /* deliberate syntax err */
+#endif
+
+
+/* Dequantize a coefficient by multiplying it by the multiplier-table
+ * entry; produce a float result.
+ */
+
+#define DEQUANTIZE(coef, quantval)  (((FAST_FLOAT)(coef)) * (quantval))
+
+
+/*
+ * Perform dequantization and inverse DCT on one block of coefficients.
+ */
+
+GLOBAL(void)
+jpeg_idct_float(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+                JCOEFPTR coef_block, JSAMPARRAY output_buf,
+                JDIMENSION output_col)
+{
+  FAST_FLOAT tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
+  FAST_FLOAT tmp10, tmp11, tmp12, tmp13;
+  FAST_FLOAT z5, z10, z11, z12, z13;
+  JCOEFPTR inptr;
+  FLOAT_MULT_TYPE *quantptr;
+  FAST_FLOAT *wsptr;
+  JSAMPROW outptr;
+  JSAMPLE *range_limit = cinfo->sample_range_limit;
+  int ctr;
+  FAST_FLOAT workspace[DCTSIZE2]; /* buffers data between passes */
+#define _0_125  ((FLOAT_MULT_TYPE)0.125)
+
+  /* Pass 1: process columns from input, store into work array. */
+
+  inptr = coef_block;
+  quantptr = (FLOAT_MULT_TYPE *)compptr->dct_table;
+  wsptr = workspace;
+  for (ctr = DCTSIZE; ctr > 0; ctr--) {
+    /* Due to quantization, we will usually find that many of the input
+     * coefficients are zero, especially the AC terms.  We can exploit this
+     * by short-circuiting the IDCT calculation for any column in which all
+     * the AC terms are zero.  In that case each output is equal to the
+     * DC coefficient (with scale factor as needed).
+     * With typical images and quantization tables, half or more of the
+     * column DCT calculations can be simplified this way.
+     */
+
+    if (inptr[DCTSIZE * 1] == 0 && inptr[DCTSIZE * 2] == 0 &&
+        inptr[DCTSIZE * 3] == 0 && inptr[DCTSIZE * 4] == 0 &&
+        inptr[DCTSIZE * 5] == 0 && inptr[DCTSIZE * 6] == 0 &&
+        inptr[DCTSIZE * 7] == 0) {
+      /* AC terms all zero */
+      FAST_FLOAT dcval = DEQUANTIZE(inptr[DCTSIZE * 0],
+                                    quantptr[DCTSIZE * 0] * _0_125);
+
+      wsptr[DCTSIZE * 0] = dcval;
+      wsptr[DCTSIZE * 1] = dcval;
+      wsptr[DCTSIZE * 2] = dcval;
+      wsptr[DCTSIZE * 3] = dcval;
+      wsptr[DCTSIZE * 4] = dcval;
+      wsptr[DCTSIZE * 5] = dcval;
+      wsptr[DCTSIZE * 6] = dcval;
+      wsptr[DCTSIZE * 7] = dcval;
+
+      inptr++;                  /* advance pointers to next column */
+      quantptr++;
+      wsptr++;
+      continue;
+    }
+
+    /* Even part */
+
+    tmp0 = DEQUANTIZE(inptr[DCTSIZE * 0], quantptr[DCTSIZE * 0] * _0_125);
+    tmp1 = DEQUANTIZE(inptr[DCTSIZE * 2], quantptr[DCTSIZE * 2] * _0_125);
+    tmp2 = DEQUANTIZE(inptr[DCTSIZE * 4], quantptr[DCTSIZE * 4] * _0_125);
+    tmp3 = DEQUANTIZE(inptr[DCTSIZE * 6], quantptr[DCTSIZE * 6] * _0_125);
+
+    tmp10 = tmp0 + tmp2;        /* phase 3 */
+    tmp11 = tmp0 - tmp2;
+
+    tmp13 = tmp1 + tmp3;        /* phases 5-3 */
+    tmp12 = (tmp1 - tmp3) * ((FAST_FLOAT)1.414213562) - tmp13; /* 2*c4 */
+
+    tmp0 = tmp10 + tmp13;       /* phase 2 */
+    tmp3 = tmp10 - tmp13;
+    tmp1 = tmp11 + tmp12;
+    tmp2 = tmp11 - tmp12;
+
+    /* Odd part */
+
+    tmp4 = DEQUANTIZE(inptr[DCTSIZE * 1], quantptr[DCTSIZE * 1] * _0_125);
+    tmp5 = DEQUANTIZE(inptr[DCTSIZE * 3], quantptr[DCTSIZE * 3] * _0_125);
+    tmp6 = DEQUANTIZE(inptr[DCTSIZE * 5], quantptr[DCTSIZE * 5] * _0_125);
+    tmp7 = DEQUANTIZE(inptr[DCTSIZE * 7], quantptr[DCTSIZE * 7] * _0_125);
+
+    z13 = tmp6 + tmp5;          /* phase 6 */
+    z10 = tmp6 - tmp5;
+    z11 = tmp4 + tmp7;
+    z12 = tmp4 - tmp7;
+
+    tmp7 = z11 + z13;           /* phase 5 */
+    tmp11 = (z11 - z13) * ((FAST_FLOAT)1.414213562); /* 2*c4 */
+
+    z5 = (z10 + z12) * ((FAST_FLOAT)1.847759065); /* 2*c2 */
+    tmp10 = z5 - z12 * ((FAST_FLOAT)1.082392200); /* 2*(c2-c6) */
+    tmp12 = z5 - z10 * ((FAST_FLOAT)2.613125930); /* 2*(c2+c6) */
+
+    tmp6 = tmp12 - tmp7;        /* phase 2 */
+    tmp5 = tmp11 - tmp6;
+    tmp4 = tmp10 - tmp5;
+
+    wsptr[DCTSIZE * 0] = tmp0 + tmp7;
+    wsptr[DCTSIZE * 7] = tmp0 - tmp7;
+    wsptr[DCTSIZE * 1] = tmp1 + tmp6;
+    wsptr[DCTSIZE * 6] = tmp1 - tmp6;
+    wsptr[DCTSIZE * 2] = tmp2 + tmp5;
+    wsptr[DCTSIZE * 5] = tmp2 - tmp5;
+    wsptr[DCTSIZE * 3] = tmp3 + tmp4;
+    wsptr[DCTSIZE * 4] = tmp3 - tmp4;
+
+    inptr++;                    /* advance pointers to next column */
+    quantptr++;
+    wsptr++;
+  }
+
+  /* Pass 2: process rows from work array, store into output array. */
+
+  wsptr = workspace;
+  for (ctr = 0; ctr < DCTSIZE; ctr++) {
+    outptr = output_buf[ctr] + output_col;
+    /* Rows of zeroes can be exploited in the same way as we did with columns.
+     * However, the column calculation has created many nonzero AC terms, so
+     * the simplification applies less often (typically 5% to 10% of the time).
+     * And testing floats for zero is relatively expensive, so we don't bother.
+     */
+
+    /* Even part */
+
+    /* Apply signed->unsigned and prepare float->int conversion */
+    z5 = wsptr[0] + ((FAST_FLOAT)CENTERJSAMPLE + (FAST_FLOAT)0.5);
+    tmp10 = z5 + wsptr[4];
+    tmp11 = z5 - wsptr[4];
+
+    tmp13 = wsptr[2] + wsptr[6];
+    tmp12 = (wsptr[2] - wsptr[6]) * ((FAST_FLOAT)1.414213562) - tmp13;
+
+    tmp0 = tmp10 + tmp13;
+    tmp3 = tmp10 - tmp13;
+    tmp1 = tmp11 + tmp12;
+    tmp2 = tmp11 - tmp12;
+
+    /* Odd part */
+
+    z13 = wsptr[5] + wsptr[3];
+    z10 = wsptr[5] - wsptr[3];
+    z11 = wsptr[1] + wsptr[7];
+    z12 = wsptr[1] - wsptr[7];
+
+    tmp7 = z11 + z13;
+    tmp11 = (z11 - z13) * ((FAST_FLOAT)1.414213562);
+
+    z5 = (z10 + z12) * ((FAST_FLOAT)1.847759065); /* 2*c2 */
+    tmp10 = z5 - z12 * ((FAST_FLOAT)1.082392200); /* 2*(c2-c6) */
+    tmp12 = z5 - z10 * ((FAST_FLOAT)2.613125930); /* 2*(c2+c6) */
+
+    tmp6 = tmp12 - tmp7;
+    tmp5 = tmp11 - tmp6;
+    tmp4 = tmp10 - tmp5;
+
+    /* Final output stage: float->int conversion and range-limit */
+
+    outptr[0] = range_limit[((int)(tmp0 + tmp7)) & RANGE_MASK];
+    outptr[7] = range_limit[((int)(tmp0 - tmp7)) & RANGE_MASK];
+    outptr[1] = range_limit[((int)(tmp1 + tmp6)) & RANGE_MASK];
+    outptr[6] = range_limit[((int)(tmp1 - tmp6)) & RANGE_MASK];
+    outptr[2] = range_limit[((int)(tmp2 + tmp5)) & RANGE_MASK];
+    outptr[5] = range_limit[((int)(tmp2 - tmp5)) & RANGE_MASK];
+    outptr[3] = range_limit[((int)(tmp3 + tmp4)) & RANGE_MASK];
+    outptr[4] = range_limit[((int)(tmp3 - tmp4)) & RANGE_MASK];
+
+    wsptr += DCTSIZE;           /* advance pointer to next row */
+  }
+}
+
+#endif /* DCT_FLOAT_SUPPORTED */
diff --git a/3rdparty/libjpeg/src/jidctfst.c b/3rdparty/libjpeg/src/jidctfst.c
new file mode 100644
index 00000000..89a20c93
--- /dev/null
+++ b/3rdparty/libjpeg/src/jidctfst.c
@@ -0,0 +1,371 @@
+/*
+ * jidctfst.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1994-1998, Thomas G. Lane.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2015, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains a fast, not so accurate integer implementation of the
+ * inverse DCT (Discrete Cosine Transform).  In the IJG code, this routine
+ * must also perform dequantization of the input coefficients.
+ *
+ * A 2-D IDCT can be done by 1-D IDCT on each column followed by 1-D IDCT
+ * on each row (or vice versa, but it's more convenient to emit a row at
+ * a time).  Direct algorithms are also available, but they are much more
+ * complex and seem not to be any faster when reduced to code.
+ *
+ * This implementation is based on Arai, Agui, and Nakajima's algorithm for
+ * scaled DCT.  Their original paper (Trans. IEICE E-71(11):1095) is in
+ * Japanese, but the algorithm is described in the Pennebaker & Mitchell
+ * JPEG textbook (see REFERENCES section in file README.ijg).  The following
+ * code is based directly on figure 4-8 in P&M.
+ * While an 8-point DCT cannot be done in less than 11 multiplies, it is
+ * possible to arrange the computation so that many of the multiplies are
+ * simple scalings of the final outputs.  These multiplies can then be
+ * folded into the multiplications or divisions by the JPEG quantization
+ * table entries.  The AA&N method leaves only 5 multiplies and 29 adds
+ * to be done in the DCT itself.
+ * The primary disadvantage of this method is that with fixed-point math,
+ * accuracy is lost due to imprecise representation of the scaled
+ * quantization values.  The smaller the quantization table entry, the less
+ * precise the scaled value, so this implementation does worse with high-
+ * quality-setting files than with low-quality ones.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jdct.h"               /* Private declarations for DCT subsystem */
+
+#ifdef DCT_IFAST_SUPPORTED
+
+
+/*
+ * This module is specialized to the case DCTSIZE = 8.
+ */
+
+#if DCTSIZE != 8
+  Sorry, this code only copes with 8x8 DCTs. /* deliberate syntax err */
+#endif
+
+
+/* Scaling decisions are generally the same as in the LL&M algorithm;
+ * see jidctint.c for more details.  However, we choose to descale
+ * (right shift) multiplication products as soon as they are formed,
+ * rather than carrying additional fractional bits into subsequent additions.
+ * This compromises accuracy slightly, but it lets us save a few shifts.
+ * More importantly, 16-bit arithmetic is then adequate (for 8-bit samples)
+ * everywhere except in the multiplications proper; this saves a good deal
+ * of work on 16-bit-int machines.
+ *
+ * The dequantized coefficients are not integers because the AA&N scaling
+ * factors have been incorporated.  We represent them scaled up by PASS1_BITS,
+ * so that the first and second IDCT rounds have the same input scaling.
+ * For 8-bit JSAMPLEs, we choose IFAST_SCALE_BITS = PASS1_BITS so as to
+ * avoid a descaling shift; this compromises accuracy rather drastically
+ * for small quantization table entries, but it saves a lot of shifts.
+ * For 12-bit JSAMPLEs, there's no hope of using 16x16 multiplies anyway,
+ * so we use a much larger scaling factor to preserve accuracy.
+ *
+ * A final compromise is to represent the multiplicative constants to only
+ * 8 fractional bits, rather than 13.  This saves some shifting work on some
+ * machines, and may also reduce the cost of multiplication (since there
+ * are fewer one-bits in the constants).
+ */
+
+#if BITS_IN_JSAMPLE == 8
+#define CONST_BITS  8
+#define PASS1_BITS  2
+#else
+#define CONST_BITS  8
+#define PASS1_BITS  1           /* lose a little precision to avoid overflow */
+#endif
+
+/* Some C compilers fail to reduce "FIX(constant)" at compile time, thus
+ * causing a lot of useless floating-point operations at run time.
+ * To get around this we use the following pre-calculated constants.
+ * If you change CONST_BITS you may want to add appropriate values.
+ * (With a reasonable C compiler, you can just rely on the FIX() macro...)
+ */
+
+#if CONST_BITS == 8
+#define FIX_1_082392200  ((JLONG)277)           /* FIX(1.082392200) */
+#define FIX_1_414213562  ((JLONG)362)           /* FIX(1.414213562) */
+#define FIX_1_847759065  ((JLONG)473)           /* FIX(1.847759065) */
+#define FIX_2_613125930  ((JLONG)669)           /* FIX(2.613125930) */
+#else
+#define FIX_1_082392200  FIX(1.082392200)
+#define FIX_1_414213562  FIX(1.414213562)
+#define FIX_1_847759065  FIX(1.847759065)
+#define FIX_2_613125930  FIX(2.613125930)
+#endif
+
+
+/* We can gain a little more speed, with a further compromise in accuracy,
+ * by omitting the addition in a descaling shift.  This yields an incorrectly
+ * rounded result half the time...
+ */
+
+#ifndef USE_ACCURATE_ROUNDING
+#undef DESCALE
+#define DESCALE(x, n)  RIGHT_SHIFT(x, n)
+#endif
+
+
+/* Multiply a DCTELEM variable by an JLONG constant, and immediately
+ * descale to yield a DCTELEM result.
+ */
+
+#define MULTIPLY(var, const)  ((DCTELEM)DESCALE((var) * (const), CONST_BITS))
+
+
+/* Dequantize a coefficient by multiplying it by the multiplier-table
+ * entry; produce a DCTELEM result.  For 8-bit data a 16x16->16
+ * multiplication will do.  For 12-bit data, the multiplier table is
+ * declared JLONG, so a 32-bit multiply will be used.
+ */
+
+#if BITS_IN_JSAMPLE == 8
+#define DEQUANTIZE(coef, quantval)  (((IFAST_MULT_TYPE)(coef)) * (quantval))
+#else
+#define DEQUANTIZE(coef, quantval) \
+  DESCALE((coef) * (quantval), IFAST_SCALE_BITS - PASS1_BITS)
+#endif
+
+
+/* Like DESCALE, but applies to a DCTELEM and produces an int.
+ * We assume that int right shift is unsigned if JLONG right shift is.
+ */
+
+#ifdef RIGHT_SHIFT_IS_UNSIGNED
+#define ISHIFT_TEMPS    DCTELEM ishift_temp;
+#if BITS_IN_JSAMPLE == 8
+#define DCTELEMBITS  16         /* DCTELEM may be 16 or 32 bits */
+#else
+#define DCTELEMBITS  32         /* DCTELEM must be 32 bits */
+#endif
+#define IRIGHT_SHIFT(x, shft) \
+  ((ishift_temp = (x)) < 0 ? \
+   (ishift_temp >> (shft)) | ((~((DCTELEM)0)) << (DCTELEMBITS - (shft))) : \
+   (ishift_temp >> (shft)))
+#else
+#define ISHIFT_TEMPS
+#define IRIGHT_SHIFT(x, shft)   ((x) >> (shft))
+#endif
+
+#ifdef USE_ACCURATE_ROUNDING
+#define IDESCALE(x, n)  ((int)IRIGHT_SHIFT((x) + (1 << ((n) - 1)), n))
+#else
+#define IDESCALE(x, n)  ((int)IRIGHT_SHIFT(x, n))
+#endif
+
+
+/*
+ * Perform dequantization and inverse DCT on one block of coefficients.
+ */
+
+GLOBAL(void)
+jpeg_idct_ifast(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+                JCOEFPTR coef_block, JSAMPARRAY output_buf,
+                JDIMENSION output_col)
+{
+  DCTELEM tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
+  DCTELEM tmp10, tmp11, tmp12, tmp13;
+  DCTELEM z5, z10, z11, z12, z13;
+  JCOEFPTR inptr;
+  IFAST_MULT_TYPE *quantptr;
+  int *wsptr;
+  JSAMPROW outptr;
+  JSAMPLE *range_limit = IDCT_range_limit(cinfo);
+  int ctr;
+  int workspace[DCTSIZE2];      /* buffers data between passes */
+  SHIFT_TEMPS                   /* for DESCALE */
+  ISHIFT_TEMPS                  /* for IDESCALE */
+
+  /* Pass 1: process columns from input, store into work array. */
+
+  inptr = coef_block;
+  quantptr = (IFAST_MULT_TYPE *)compptr->dct_table;
+  wsptr = workspace;
+  for (ctr = DCTSIZE; ctr > 0; ctr--) {
+    /* Due to quantization, we will usually find that many of the input
+     * coefficients are zero, especially the AC terms.  We can exploit this
+     * by short-circuiting the IDCT calculation for any column in which all
+     * the AC terms are zero.  In that case each output is equal to the
+     * DC coefficient (with scale factor as needed).
+     * With typical images and quantization tables, half or more of the
+     * column DCT calculations can be simplified this way.
+     */
+
+    if (inptr[DCTSIZE * 1] == 0 && inptr[DCTSIZE * 2] == 0 &&
+        inptr[DCTSIZE * 3] == 0 && inptr[DCTSIZE * 4] == 0 &&
+        inptr[DCTSIZE * 5] == 0 && inptr[DCTSIZE * 6] == 0 &&
+        inptr[DCTSIZE * 7] == 0) {
+      /* AC terms all zero */
+      int dcval = (int)DEQUANTIZE(inptr[DCTSIZE * 0], quantptr[DCTSIZE * 0]);
+
+      wsptr[DCTSIZE * 0] = dcval;
+      wsptr[DCTSIZE * 1] = dcval;
+      wsptr[DCTSIZE * 2] = dcval;
+      wsptr[DCTSIZE * 3] = dcval;
+      wsptr[DCTSIZE * 4] = dcval;
+      wsptr[DCTSIZE * 5] = dcval;
+      wsptr[DCTSIZE * 6] = dcval;
+      wsptr[DCTSIZE * 7] = dcval;
+
+      inptr++;                  /* advance pointers to next column */
+      quantptr++;
+      wsptr++;
+      continue;
+    }
+
+    /* Even part */
+
+    tmp0 = DEQUANTIZE(inptr[DCTSIZE * 0], quantptr[DCTSIZE * 0]);
+    tmp1 = DEQUANTIZE(inptr[DCTSIZE * 2], quantptr[DCTSIZE * 2]);
+    tmp2 = DEQUANTIZE(inptr[DCTSIZE * 4], quantptr[DCTSIZE * 4]);
+    tmp3 = DEQUANTIZE(inptr[DCTSIZE * 6], quantptr[DCTSIZE * 6]);
+
+    tmp10 = tmp0 + tmp2;        /* phase 3 */
+    tmp11 = tmp0 - tmp2;
+
+    tmp13 = tmp1 + tmp3;        /* phases 5-3 */
+    tmp12 = MULTIPLY(tmp1 - tmp3, FIX_1_414213562) - tmp13; /* 2*c4 */
+
+    tmp0 = tmp10 + tmp13;       /* phase 2 */
+    tmp3 = tmp10 - tmp13;
+    tmp1 = tmp11 + tmp12;
+    tmp2 = tmp11 - tmp12;
+
+    /* Odd part */
+
+    tmp4 = DEQUANTIZE(inptr[DCTSIZE * 1], quantptr[DCTSIZE * 1]);
+    tmp5 = DEQUANTIZE(inptr[DCTSIZE * 3], quantptr[DCTSIZE * 3]);
+    tmp6 = DEQUANTIZE(inptr[DCTSIZE * 5], quantptr[DCTSIZE * 5]);
+    tmp7 = DEQUANTIZE(inptr[DCTSIZE * 7], quantptr[DCTSIZE * 7]);
+
+    z13 = tmp6 + tmp5;          /* phase 6 */
+    z10 = tmp6 - tmp5;
+    z11 = tmp4 + tmp7;
+    z12 = tmp4 - tmp7;
+
+    tmp7 = z11 + z13;           /* phase 5 */
+    tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562); /* 2*c4 */
+
+    z5 = MULTIPLY(z10 + z12, FIX_1_847759065); /* 2*c2 */
+    tmp10 = MULTIPLY(z12, FIX_1_082392200) - z5; /* 2*(c2-c6) */
+    tmp12 = MULTIPLY(z10, -FIX_2_613125930) + z5; /* -2*(c2+c6) */
+
+    tmp6 = tmp12 - tmp7;        /* phase 2 */
+    tmp5 = tmp11 - tmp6;
+    tmp4 = tmp10 + tmp5;
+
+    wsptr[DCTSIZE * 0] = (int)(tmp0 + tmp7);
+    wsptr[DCTSIZE * 7] = (int)(tmp0 - tmp7);
+    wsptr[DCTSIZE * 1] = (int)(tmp1 + tmp6);
+    wsptr[DCTSIZE * 6] = (int)(tmp1 - tmp6);
+    wsptr[DCTSIZE * 2] = (int)(tmp2 + tmp5);
+    wsptr[DCTSIZE * 5] = (int)(tmp2 - tmp5);
+    wsptr[DCTSIZE * 4] = (int)(tmp3 + tmp4);
+    wsptr[DCTSIZE * 3] = (int)(tmp3 - tmp4);
+
+    inptr++;                    /* advance pointers to next column */
+    quantptr++;
+    wsptr++;
+  }
+
+  /* Pass 2: process rows from work array, store into output array. */
+  /* Note that we must descale the results by a factor of 8 == 2**3, */
+  /* and also undo the PASS1_BITS scaling. */
+
+  wsptr = workspace;
+  for (ctr = 0; ctr < DCTSIZE; ctr++) {
+    outptr = output_buf[ctr] + output_col;
+    /* Rows of zeroes can be exploited in the same way as we did with columns.
+     * However, the column calculation has created many nonzero AC terms, so
+     * the simplification applies less often (typically 5% to 10% of the time).
+     * On machines with very fast multiplication, it's possible that the
+     * test takes more time than it's worth.  In that case this section
+     * may be commented out.
+     */
+
+#ifndef NO_ZERO_ROW_TEST
+    if (wsptr[1] == 0 && wsptr[2] == 0 && wsptr[3] == 0 && wsptr[4] == 0 &&
+        wsptr[5] == 0 && wsptr[6] == 0 && wsptr[7] == 0) {
+      /* AC terms all zero */
+      JSAMPLE dcval =
+        range_limit[IDESCALE(wsptr[0], PASS1_BITS + 3) & RANGE_MASK];
+
+      outptr[0] = dcval;
+      outptr[1] = dcval;
+      outptr[2] = dcval;
+      outptr[3] = dcval;
+      outptr[4] = dcval;
+      outptr[5] = dcval;
+      outptr[6] = dcval;
+      outptr[7] = dcval;
+
+      wsptr += DCTSIZE;         /* advance pointer to next row */
+      continue;
+    }
+#endif
+
+    /* Even part */
+
+    tmp10 = ((DCTELEM)wsptr[0] + (DCTELEM)wsptr[4]);
+    tmp11 = ((DCTELEM)wsptr[0] - (DCTELEM)wsptr[4]);
+
+    tmp13 = ((DCTELEM)wsptr[2] + (DCTELEM)wsptr[6]);
+    tmp12 =
+      MULTIPLY((DCTELEM)wsptr[2] - (DCTELEM)wsptr[6], FIX_1_414213562) - tmp13;
+
+    tmp0 = tmp10 + tmp13;
+    tmp3 = tmp10 - tmp13;
+    tmp1 = tmp11 + tmp12;
+    tmp2 = tmp11 - tmp12;
+
+    /* Odd part */
+
+    z13 = (DCTELEM)wsptr[5] + (DCTELEM)wsptr[3];
+    z10 = (DCTELEM)wsptr[5] - (DCTELEM)wsptr[3];
+    z11 = (DCTELEM)wsptr[1] + (DCTELEM)wsptr[7];
+    z12 = (DCTELEM)wsptr[1] - (DCTELEM)wsptr[7];
+
+    tmp7 = z11 + z13;           /* phase 5 */
+    tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562); /* 2*c4 */
+
+    z5 = MULTIPLY(z10 + z12, FIX_1_847759065); /* 2*c2 */
+    tmp10 = MULTIPLY(z12, FIX_1_082392200) - z5; /* 2*(c2-c6) */
+    tmp12 = MULTIPLY(z10, -FIX_2_613125930) + z5; /* -2*(c2+c6) */
+
+    tmp6 = tmp12 - tmp7;        /* phase 2 */
+    tmp5 = tmp11 - tmp6;
+    tmp4 = tmp10 + tmp5;
+
+    /* Final output stage: scale down by a factor of 8 and range-limit */
+
+    outptr[0] =
+      range_limit[IDESCALE(tmp0 + tmp7, PASS1_BITS + 3) & RANGE_MASK];
+    outptr[7] =
+      range_limit[IDESCALE(tmp0 - tmp7, PASS1_BITS + 3) & RANGE_MASK];
+    outptr[1] =
+      range_limit[IDESCALE(tmp1 + tmp6, PASS1_BITS + 3) & RANGE_MASK];
+    outptr[6] =
+      range_limit[IDESCALE(tmp1 - tmp6, PASS1_BITS + 3) & RANGE_MASK];
+    outptr[2] =
+      range_limit[IDESCALE(tmp2 + tmp5, PASS1_BITS + 3) & RANGE_MASK];
+    outptr[5] =
+      range_limit[IDESCALE(tmp2 - tmp5, PASS1_BITS + 3) & RANGE_MASK];
+    outptr[4] =
+      range_limit[IDESCALE(tmp3 + tmp4, PASS1_BITS + 3) & RANGE_MASK];
+    outptr[3] =
+      range_limit[IDESCALE(tmp3 - tmp4, PASS1_BITS + 3) & RANGE_MASK];
+
+    wsptr += DCTSIZE;           /* advance pointer to next row */
+  }
+}
+
+#endif /* DCT_IFAST_SUPPORTED */
diff --git a/3rdparty/libjpeg/src/jidctint.c b/3rdparty/libjpeg/src/jidctint.c
new file mode 100644
index 00000000..bb087480
--- /dev/null
+++ b/3rdparty/libjpeg/src/jidctint.c
@@ -0,0 +1,2627 @@
+/*
+ * jidctint.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1991-1998, Thomas G. Lane.
+ * Modification developed 2002-2018 by Guido Vollbeding.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2015, 2020, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains a slower but more accurate integer implementation of the
+ * inverse DCT (Discrete Cosine Transform).  In the IJG code, this routine
+ * must also perform dequantization of the input coefficients.
+ *
+ * A 2-D IDCT can be done by 1-D IDCT on each column followed by 1-D IDCT
+ * on each row (or vice versa, but it's more convenient to emit a row at
+ * a time).  Direct algorithms are also available, but they are much more
+ * complex and seem not to be any faster when reduced to code.
+ *
+ * This implementation is based on an algorithm described in
+ *   C. Loeffler, A. Ligtenberg and G. Moschytz, "Practical Fast 1-D DCT
+ *   Algorithms with 11 Multiplications", Proc. Int'l. Conf. on Acoustics,
+ *   Speech, and Signal Processing 1989 (ICASSP '89), pp. 988-991.
+ * The primary algorithm described there uses 11 multiplies and 29 adds.
+ * We use their alternate method with 12 multiplies and 32 adds.
+ * The advantage of this method is that no data path contains more than one
+ * multiplication; this allows a very simple and accurate implementation in
+ * scaled fixed-point arithmetic, with a minimal number of shifts.
+ *
+ * We also provide IDCT routines with various output sample block sizes for
+ * direct resolution reduction or enlargement without additional resampling:
+ * NxN (N=1...16) pixels for one 8x8 input DCT block.
+ *
+ * For N<8 we simply take the corresponding low-frequency coefficients of
+ * the 8x8 input DCT block and apply an NxN point IDCT on the sub-block
+ * to yield the downscaled outputs.
+ * This can be seen as direct low-pass downsampling from the DCT domain
+ * point of view rather than the usual spatial domain point of view,
+ * yielding significant computational savings and results at least
+ * as good as common bilinear (averaging) spatial downsampling.
+ *
+ * For N>8 we apply a partial NxN IDCT on the 8 input coefficients as
+ * lower frequencies and higher frequencies assumed to be zero.
+ * It turns out that the computational effort is similar to the 8x8 IDCT
+ * regarding the output size.
+ * Furthermore, the scaling and descaling is the same for all IDCT sizes.
+ *
+ * CAUTION: We rely on the FIX() macro except for the N=1,2,4,8 cases
+ * since there would be too many additional constants to pre-calculate.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jdct.h"               /* Private declarations for DCT subsystem */
+
+#ifdef DCT_ISLOW_SUPPORTED
+
+
+/*
+ * This module is specialized to the case DCTSIZE = 8.
+ */
+
+#if DCTSIZE != 8
+  Sorry, this code only copes with 8x8 DCT blocks. /* deliberate syntax err */
+#endif
+
+
+/*
+ * The poop on this scaling stuff is as follows:
+ *
+ * Each 1-D IDCT step produces outputs which are a factor of sqrt(N)
+ * larger than the true IDCT outputs.  The final outputs are therefore
+ * a factor of N larger than desired; since N=8 this can be cured by
+ * a simple right shift at the end of the algorithm.  The advantage of
+ * this arrangement is that we save two multiplications per 1-D IDCT,
+ * because the y0 and y4 inputs need not be divided by sqrt(N).
+ *
+ * We have to do addition and subtraction of the integer inputs, which
+ * is no problem, and multiplication by fractional constants, which is
+ * a problem to do in integer arithmetic.  We multiply all the constants
+ * by CONST_SCALE and convert them to integer constants (thus retaining
+ * CONST_BITS bits of precision in the constants).  After doing a
+ * multiplication we have to divide the product by CONST_SCALE, with proper
+ * rounding, to produce the correct output.  This division can be done
+ * cheaply as a right shift of CONST_BITS bits.  We postpone shifting
+ * as long as possible so that partial sums can be added together with
+ * full fractional precision.
+ *
+ * The outputs of the first pass are scaled up by PASS1_BITS bits so that
+ * they are represented to better-than-integral precision.  These outputs
+ * require BITS_IN_JSAMPLE + PASS1_BITS + 3 bits; this fits in a 16-bit word
+ * with the recommended scaling.  (To scale up 12-bit sample data further, an
+ * intermediate JLONG array would be needed.)
+ *
+ * To avoid overflow of the 32-bit intermediate results in pass 2, we must
+ * have BITS_IN_JSAMPLE + CONST_BITS + PASS1_BITS <= 26.  Error analysis
+ * shows that the values given below are the most effective.
+ */
+
+#if BITS_IN_JSAMPLE == 8
+#define CONST_BITS  13
+#define PASS1_BITS  2
+#else
+#define CONST_BITS  13
+#define PASS1_BITS  1           /* lose a little precision to avoid overflow */
+#endif
+
+/* Some C compilers fail to reduce "FIX(constant)" at compile time, thus
+ * causing a lot of useless floating-point operations at run time.
+ * To get around this we use the following pre-calculated constants.
+ * If you change CONST_BITS you may want to add appropriate values.
+ * (With a reasonable C compiler, you can just rely on the FIX() macro...)
+ */
+
+#if CONST_BITS == 13
+#define FIX_0_298631336  ((JLONG)2446)          /* FIX(0.298631336) */
+#define FIX_0_390180644  ((JLONG)3196)          /* FIX(0.390180644) */
+#define FIX_0_541196100  ((JLONG)4433)          /* FIX(0.541196100) */
+#define FIX_0_765366865  ((JLONG)6270)          /* FIX(0.765366865) */
+#define FIX_0_899976223  ((JLONG)7373)          /* FIX(0.899976223) */
+#define FIX_1_175875602  ((JLONG)9633)          /* FIX(1.175875602) */
+#define FIX_1_501321110  ((JLONG)12299)         /* FIX(1.501321110) */
+#define FIX_1_847759065  ((JLONG)15137)         /* FIX(1.847759065) */
+#define FIX_1_961570560  ((JLONG)16069)         /* FIX(1.961570560) */
+#define FIX_2_053119869  ((JLONG)16819)         /* FIX(2.053119869) */
+#define FIX_2_562915447  ((JLONG)20995)         /* FIX(2.562915447) */
+#define FIX_3_072711026  ((JLONG)25172)         /* FIX(3.072711026) */
+#else
+#define FIX_0_298631336  FIX(0.298631336)
+#define FIX_0_390180644  FIX(0.390180644)
+#define FIX_0_541196100  FIX(0.541196100)
+#define FIX_0_765366865  FIX(0.765366865)
+#define FIX_0_899976223  FIX(0.899976223)
+#define FIX_1_175875602  FIX(1.175875602)
+#define FIX_1_501321110  FIX(1.501321110)
+#define FIX_1_847759065  FIX(1.847759065)
+#define FIX_1_961570560  FIX(1.961570560)
+#define FIX_2_053119869  FIX(2.053119869)
+#define FIX_2_562915447  FIX(2.562915447)
+#define FIX_3_072711026  FIX(3.072711026)
+#endif
+
+
+/* Multiply an JLONG variable by an JLONG constant to yield an JLONG result.
+ * For 8-bit samples with the recommended scaling, all the variable
+ * and constant values involved are no more than 16 bits wide, so a
+ * 16x16->32 bit multiply can be used instead of a full 32x32 multiply.
+ * For 12-bit samples, a full 32-bit multiplication will be needed.
+ */
+
+#if BITS_IN_JSAMPLE == 8
+#define MULTIPLY(var, const)  MULTIPLY16C16(var, const)
+#else
+#define MULTIPLY(var, const)  ((var) * (const))
+#endif
+
+
+/* Dequantize a coefficient by multiplying it by the multiplier-table
+ * entry; produce an int result.  In this module, both inputs and result
+ * are 16 bits or less, so either int or short multiply will work.
+ */
+
+#define DEQUANTIZE(coef, quantval)  (((ISLOW_MULT_TYPE)(coef)) * (quantval))
+
+
+/*
+ * Perform dequantization and inverse DCT on one block of coefficients.
+ */
+
+GLOBAL(void)
+jpeg_idct_islow(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+                JCOEFPTR coef_block, JSAMPARRAY output_buf,
+                JDIMENSION output_col)
+{
+  JLONG tmp0, tmp1, tmp2, tmp3;
+  JLONG tmp10, tmp11, tmp12, tmp13;
+  JLONG z1, z2, z3, z4, z5;
+  JCOEFPTR inptr;
+  ISLOW_MULT_TYPE *quantptr;
+  int *wsptr;
+  JSAMPROW outptr;
+  JSAMPLE *range_limit = IDCT_range_limit(cinfo);
+  int ctr;
+  int workspace[DCTSIZE2];      /* buffers data between passes */
+  SHIFT_TEMPS
+
+  /* Pass 1: process columns from input, store into work array. */
+  /* Note results are scaled up by sqrt(8) compared to a true IDCT; */
+  /* furthermore, we scale the results by 2**PASS1_BITS. */
+
+  inptr = coef_block;
+  quantptr = (ISLOW_MULT_TYPE *)compptr->dct_table;
+  wsptr = workspace;
+  for (ctr = DCTSIZE; ctr > 0; ctr--) {
+    /* Due to quantization, we will usually find that many of the input
+     * coefficients are zero, especially the AC terms.  We can exploit this
+     * by short-circuiting the IDCT calculation for any column in which all
+     * the AC terms are zero.  In that case each output is equal to the
+     * DC coefficient (with scale factor as needed).
+     * With typical images and quantization tables, half or more of the
+     * column DCT calculations can be simplified this way.
+     */
+
+    if (inptr[DCTSIZE * 1] == 0 && inptr[DCTSIZE * 2] == 0 &&
+        inptr[DCTSIZE * 3] == 0 && inptr[DCTSIZE * 4] == 0 &&
+        inptr[DCTSIZE * 5] == 0 && inptr[DCTSIZE * 6] == 0 &&
+        inptr[DCTSIZE * 7] == 0) {
+      /* AC terms all zero */
+      int dcval = LEFT_SHIFT(DEQUANTIZE(inptr[DCTSIZE * 0],
+                             quantptr[DCTSIZE * 0]), PASS1_BITS);
+
+      wsptr[DCTSIZE * 0] = dcval;
+      wsptr[DCTSIZE * 1] = dcval;
+      wsptr[DCTSIZE * 2] = dcval;
+      wsptr[DCTSIZE * 3] = dcval;
+      wsptr[DCTSIZE * 4] = dcval;
+      wsptr[DCTSIZE * 5] = dcval;
+      wsptr[DCTSIZE * 6] = dcval;
+      wsptr[DCTSIZE * 7] = dcval;
+
+      inptr++;                  /* advance pointers to next column */
+      quantptr++;
+      wsptr++;
+      continue;
+    }
+
+    /* Even part: reverse the even part of the forward DCT. */
+    /* The rotator is sqrt(2)*c(-6). */
+
+    z2 = DEQUANTIZE(inptr[DCTSIZE * 2], quantptr[DCTSIZE * 2]);
+    z3 = DEQUANTIZE(inptr[DCTSIZE * 6], quantptr[DCTSIZE * 6]);
+
+    z1 = MULTIPLY(z2 + z3, FIX_0_541196100);
+    tmp2 = z1 + MULTIPLY(z3, -FIX_1_847759065);
+    tmp3 = z1 + MULTIPLY(z2, FIX_0_765366865);
+
+    z2 = DEQUANTIZE(inptr[DCTSIZE * 0], quantptr[DCTSIZE * 0]);
+    z3 = DEQUANTIZE(inptr[DCTSIZE * 4], quantptr[DCTSIZE * 4]);
+
+    tmp0 = LEFT_SHIFT(z2 + z3, CONST_BITS);
+    tmp1 = LEFT_SHIFT(z2 - z3, CONST_BITS);
+
+    tmp10 = tmp0 + tmp3;
+    tmp13 = tmp0 - tmp3;
+    tmp11 = tmp1 + tmp2;
+    tmp12 = tmp1 - tmp2;
+
+    /* Odd part per figure 8; the matrix is unitary and hence its
+     * transpose is its inverse.  i0..i3 are y7,y5,y3,y1 respectively.
+     */
+
+    tmp0 = DEQUANTIZE(inptr[DCTSIZE * 7], quantptr[DCTSIZE * 7]);
+    tmp1 = DEQUANTIZE(inptr[DCTSIZE * 5], quantptr[DCTSIZE * 5]);
+    tmp2 = DEQUANTIZE(inptr[DCTSIZE * 3], quantptr[DCTSIZE * 3]);
+    tmp3 = DEQUANTIZE(inptr[DCTSIZE * 1], quantptr[DCTSIZE * 1]);
+
+    z1 = tmp0 + tmp3;
+    z2 = tmp1 + tmp2;
+    z3 = tmp0 + tmp2;
+    z4 = tmp1 + tmp3;
+    z5 = MULTIPLY(z3 + z4, FIX_1_175875602); /* sqrt(2) * c3 */
+
+    tmp0 = MULTIPLY(tmp0, FIX_0_298631336); /* sqrt(2) * (-c1+c3+c5-c7) */
+    tmp1 = MULTIPLY(tmp1, FIX_2_053119869); /* sqrt(2) * ( c1+c3-c5+c7) */
+    tmp2 = MULTIPLY(tmp2, FIX_3_072711026); /* sqrt(2) * ( c1+c3+c5-c7) */
+    tmp3 = MULTIPLY(tmp3, FIX_1_501321110); /* sqrt(2) * ( c1+c3-c5-c7) */
+    z1 = MULTIPLY(z1, -FIX_0_899976223); /* sqrt(2) * ( c7-c3) */
+    z2 = MULTIPLY(z2, -FIX_2_562915447); /* sqrt(2) * (-c1-c3) */
+    z3 = MULTIPLY(z3, -FIX_1_961570560); /* sqrt(2) * (-c3-c5) */
+    z4 = MULTIPLY(z4, -FIX_0_390180644); /* sqrt(2) * ( c5-c3) */
+
+    z3 += z5;
+    z4 += z5;
+
+    tmp0 += z1 + z3;
+    tmp1 += z2 + z4;
+    tmp2 += z2 + z3;
+    tmp3 += z1 + z4;
+
+    /* Final output stage: inputs are tmp10..tmp13, tmp0..tmp3 */
+
+    wsptr[DCTSIZE * 0] = (int)DESCALE(tmp10 + tmp3, CONST_BITS - PASS1_BITS);
+    wsptr[DCTSIZE * 7] = (int)DESCALE(tmp10 - tmp3, CONST_BITS - PASS1_BITS);
+    wsptr[DCTSIZE * 1] = (int)DESCALE(tmp11 + tmp2, CONST_BITS - PASS1_BITS);
+    wsptr[DCTSIZE * 6] = (int)DESCALE(tmp11 - tmp2, CONST_BITS - PASS1_BITS);
+    wsptr[DCTSIZE * 2] = (int)DESCALE(tmp12 + tmp1, CONST_BITS - PASS1_BITS);
+    wsptr[DCTSIZE * 5] = (int)DESCALE(tmp12 - tmp1, CONST_BITS - PASS1_BITS);
+    wsptr[DCTSIZE * 3] = (int)DESCALE(tmp13 + tmp0, CONST_BITS - PASS1_BITS);
+    wsptr[DCTSIZE * 4] = (int)DESCALE(tmp13 - tmp0, CONST_BITS - PASS1_BITS);
+
+    inptr++;                    /* advance pointers to next column */
+    quantptr++;
+    wsptr++;
+  }
+
+  /* Pass 2: process rows from work array, store into output array. */
+  /* Note that we must descale the results by a factor of 8 == 2**3, */
+  /* and also undo the PASS1_BITS scaling. */
+
+  wsptr = workspace;
+  for (ctr = 0; ctr < DCTSIZE; ctr++) {
+    outptr = output_buf[ctr] + output_col;
+    /* Rows of zeroes can be exploited in the same way as we did with columns.
+     * However, the column calculation has created many nonzero AC terms, so
+     * the simplification applies less often (typically 5% to 10% of the time).
+     * On machines with very fast multiplication, it's possible that the
+     * test takes more time than it's worth.  In that case this section
+     * may be commented out.
+     */
+
+#ifndef NO_ZERO_ROW_TEST
+    if (wsptr[1] == 0 && wsptr[2] == 0 && wsptr[3] == 0 && wsptr[4] == 0 &&
+        wsptr[5] == 0 && wsptr[6] == 0 && wsptr[7] == 0) {
+      /* AC terms all zero */
+      JSAMPLE dcval = range_limit[(int)DESCALE((JLONG)wsptr[0],
+                                               PASS1_BITS + 3) & RANGE_MASK];
+
+      outptr[0] = dcval;
+      outptr[1] = dcval;
+      outptr[2] = dcval;
+      outptr[3] = dcval;
+      outptr[4] = dcval;
+      outptr[5] = dcval;
+      outptr[6] = dcval;
+      outptr[7] = dcval;
+
+      wsptr += DCTSIZE;         /* advance pointer to next row */
+      continue;
+    }
+#endif
+
+    /* Even part: reverse the even part of the forward DCT. */
+    /* The rotator is sqrt(2)*c(-6). */
+
+    z2 = (JLONG)wsptr[2];
+    z3 = (JLONG)wsptr[6];
+
+    z1 = MULTIPLY(z2 + z3, FIX_0_541196100);
+    tmp2 = z1 + MULTIPLY(z3, -FIX_1_847759065);
+    tmp3 = z1 + MULTIPLY(z2, FIX_0_765366865);
+
+    tmp0 = LEFT_SHIFT((JLONG)wsptr[0] + (JLONG)wsptr[4], CONST_BITS);
+    tmp1 = LEFT_SHIFT((JLONG)wsptr[0] - (JLONG)wsptr[4], CONST_BITS);
+
+    tmp10 = tmp0 + tmp3;
+    tmp13 = tmp0 - tmp3;
+    tmp11 = tmp1 + tmp2;
+    tmp12 = tmp1 - tmp2;
+
+    /* Odd part per figure 8; the matrix is unitary and hence its
+     * transpose is its inverse.  i0..i3 are y7,y5,y3,y1 respectively.
+     */
+
+    tmp0 = (JLONG)wsptr[7];
+    tmp1 = (JLONG)wsptr[5];
+    tmp2 = (JLONG)wsptr[3];
+    tmp3 = (JLONG)wsptr[1];
+
+    z1 = tmp0 + tmp3;
+    z2 = tmp1 + tmp2;
+    z3 = tmp0 + tmp2;
+    z4 = tmp1 + tmp3;
+    z5 = MULTIPLY(z3 + z4, FIX_1_175875602); /* sqrt(2) * c3 */
+
+    tmp0 = MULTIPLY(tmp0, FIX_0_298631336); /* sqrt(2) * (-c1+c3+c5-c7) */
+    tmp1 = MULTIPLY(tmp1, FIX_2_053119869); /* sqrt(2) * ( c1+c3-c5+c7) */
+    tmp2 = MULTIPLY(tmp2, FIX_3_072711026); /* sqrt(2) * ( c1+c3+c5-c7) */
+    tmp3 = MULTIPLY(tmp3, FIX_1_501321110); /* sqrt(2) * ( c1+c3-c5-c7) */
+    z1 = MULTIPLY(z1, -FIX_0_899976223); /* sqrt(2) * ( c7-c3) */
+    z2 = MULTIPLY(z2, -FIX_2_562915447); /* sqrt(2) * (-c1-c3) */
+    z3 = MULTIPLY(z3, -FIX_1_961570560); /* sqrt(2) * (-c3-c5) */
+    z4 = MULTIPLY(z4, -FIX_0_390180644); /* sqrt(2) * ( c5-c3) */
+
+    z3 += z5;
+    z4 += z5;
+
+    tmp0 += z1 + z3;
+    tmp1 += z2 + z4;
+    tmp2 += z2 + z3;
+    tmp3 += z1 + z4;
+
+    /* Final output stage: inputs are tmp10..tmp13, tmp0..tmp3 */
+
+    outptr[0] = range_limit[(int)DESCALE(tmp10 + tmp3,
+                                         CONST_BITS + PASS1_BITS + 3) &
+                            RANGE_MASK];
+    outptr[7] = range_limit[(int)DESCALE(tmp10 - tmp3,
+                                         CONST_BITS + PASS1_BITS + 3) &
+                            RANGE_MASK];
+    outptr[1] = range_limit[(int)DESCALE(tmp11 + tmp2,
+                                         CONST_BITS + PASS1_BITS + 3) &
+                            RANGE_MASK];
+    outptr[6] = range_limit[(int)DESCALE(tmp11 - tmp2,
+                                         CONST_BITS + PASS1_BITS + 3) &
+                            RANGE_MASK];
+    outptr[2] = range_limit[(int)DESCALE(tmp12 + tmp1,
+                                         CONST_BITS + PASS1_BITS + 3) &
+                            RANGE_MASK];
+    outptr[5] = range_limit[(int)DESCALE(tmp12 - tmp1,
+                                         CONST_BITS + PASS1_BITS + 3) &
+                            RANGE_MASK];
+    outptr[3] = range_limit[(int)DESCALE(tmp13 + tmp0,
+                                         CONST_BITS + PASS1_BITS + 3) &
+                            RANGE_MASK];
+    outptr[4] = range_limit[(int)DESCALE(tmp13 - tmp0,
+                                         CONST_BITS + PASS1_BITS + 3) &
+                            RANGE_MASK];
+
+    wsptr += DCTSIZE;           /* advance pointer to next row */
+  }
+}
+
+#ifdef IDCT_SCALING_SUPPORTED
+
+
+/*
+ * Perform dequantization and inverse DCT on one block of coefficients,
+ * producing a reduced-size 7x7 output block.
+ *
+ * Optimized algorithm with 12 multiplications in the 1-D kernel.
+ * cK represents sqrt(2) * cos(K*pi/14).
+ */
+
+GLOBAL(void)
+jpeg_idct_7x7(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+              JCOEFPTR coef_block, JSAMPARRAY output_buf,
+              JDIMENSION output_col)
+{
+  JLONG tmp0, tmp1, tmp2, tmp10, tmp11, tmp12, tmp13;
+  JLONG z1, z2, z3;
+  JCOEFPTR inptr;
+  ISLOW_MULT_TYPE *quantptr;
+  int *wsptr;
+  JSAMPROW outptr;
+  JSAMPLE *range_limit = IDCT_range_limit(cinfo);
+  int ctr;
+  int workspace[7 * 7];         /* buffers data between passes */
+  SHIFT_TEMPS
+
+  /* Pass 1: process columns from input, store into work array. */
+
+  inptr = coef_block;
+  quantptr = (ISLOW_MULT_TYPE *)compptr->dct_table;
+  wsptr = workspace;
+  for (ctr = 0; ctr < 7; ctr++, inptr++, quantptr++, wsptr++) {
+    /* Even part */
+
+    tmp13 = DEQUANTIZE(inptr[DCTSIZE * 0], quantptr[DCTSIZE * 0]);
+    tmp13 = LEFT_SHIFT(tmp13, CONST_BITS);
+    /* Add fudge factor here for final descale. */
+    tmp13 += ONE << (CONST_BITS - PASS1_BITS - 1);
+
+    z1 = DEQUANTIZE(inptr[DCTSIZE * 2], quantptr[DCTSIZE * 2]);
+    z2 = DEQUANTIZE(inptr[DCTSIZE * 4], quantptr[DCTSIZE * 4]);
+    z3 = DEQUANTIZE(inptr[DCTSIZE * 6], quantptr[DCTSIZE * 6]);
+
+    tmp10 = MULTIPLY(z2 - z3, FIX(0.881747734));     /* c4 */
+    tmp12 = MULTIPLY(z1 - z2, FIX(0.314692123));     /* c6 */
+    tmp11 = tmp10 + tmp12 + tmp13 - MULTIPLY(z2, FIX(1.841218003)); /* c2+c4-c6 */
+    tmp0 = z1 + z3;
+    z2 -= tmp0;
+    tmp0 = MULTIPLY(tmp0, FIX(1.274162392)) + tmp13; /* c2 */
+    tmp10 += tmp0 - MULTIPLY(z3, FIX(0.077722536));  /* c2-c4-c6 */
+    tmp12 += tmp0 - MULTIPLY(z1, FIX(2.470602249));  /* c2+c4+c6 */
+    tmp13 += MULTIPLY(z2, FIX(1.414213562));         /* c0 */
+
+    /* Odd part */
+
+    z1 = DEQUANTIZE(inptr[DCTSIZE * 1], quantptr[DCTSIZE * 1]);
+    z2 = DEQUANTIZE(inptr[DCTSIZE * 3], quantptr[DCTSIZE * 3]);
+    z3 = DEQUANTIZE(inptr[DCTSIZE * 5], quantptr[DCTSIZE * 5]);
+
+    tmp1 = MULTIPLY(z1 + z2, FIX(0.935414347));      /* (c3+c1-c5)/2 */
+    tmp2 = MULTIPLY(z1 - z2, FIX(0.170262339));      /* (c3+c5-c1)/2 */
+    tmp0 = tmp1 - tmp2;
+    tmp1 += tmp2;
+    tmp2 = MULTIPLY(z2 + z3, -FIX(1.378756276));     /* -c1 */
+    tmp1 += tmp2;
+    z2 = MULTIPLY(z1 + z3, FIX(0.613604268));        /* c5 */
+    tmp0 += z2;
+    tmp2 += z2 + MULTIPLY(z3, FIX(1.870828693));     /* c3+c1-c5 */
+
+    /* Final output stage */
+
+    wsptr[7 * 0] = (int)RIGHT_SHIFT(tmp10 + tmp0, CONST_BITS - PASS1_BITS);
+    wsptr[7 * 6] = (int)RIGHT_SHIFT(tmp10 - tmp0, CONST_BITS - PASS1_BITS);
+    wsptr[7 * 1] = (int)RIGHT_SHIFT(tmp11 + tmp1, CONST_BITS - PASS1_BITS);
+    wsptr[7 * 5] = (int)RIGHT_SHIFT(tmp11 - tmp1, CONST_BITS - PASS1_BITS);
+    wsptr[7 * 2] = (int)RIGHT_SHIFT(tmp12 + tmp2, CONST_BITS - PASS1_BITS);
+    wsptr[7 * 4] = (int)RIGHT_SHIFT(tmp12 - tmp2, CONST_BITS - PASS1_BITS);
+    wsptr[7 * 3] = (int)RIGHT_SHIFT(tmp13, CONST_BITS - PASS1_BITS);
+  }
+
+  /* Pass 2: process 7 rows from work array, store into output array. */
+
+  wsptr = workspace;
+  for (ctr = 0; ctr < 7; ctr++) {
+    outptr = output_buf[ctr] + output_col;
+
+    /* Even part */
+
+    /* Add fudge factor here for final descale. */
+    tmp13 = (JLONG)wsptr[0] + (ONE << (PASS1_BITS + 2));
+    tmp13 = LEFT_SHIFT(tmp13, CONST_BITS);
+
+    z1 = (JLONG)wsptr[2];
+    z2 = (JLONG)wsptr[4];
+    z3 = (JLONG)wsptr[6];
+
+    tmp10 = MULTIPLY(z2 - z3, FIX(0.881747734));     /* c4 */
+    tmp12 = MULTIPLY(z1 - z2, FIX(0.314692123));     /* c6 */
+    tmp11 = tmp10 + tmp12 + tmp13 - MULTIPLY(z2, FIX(1.841218003)); /* c2+c4-c6 */
+    tmp0 = z1 + z3;
+    z2 -= tmp0;
+    tmp0 = MULTIPLY(tmp0, FIX(1.274162392)) + tmp13; /* c2 */
+    tmp10 += tmp0 - MULTIPLY(z3, FIX(0.077722536));  /* c2-c4-c6 */
+    tmp12 += tmp0 - MULTIPLY(z1, FIX(2.470602249));  /* c2+c4+c6 */
+    tmp13 += MULTIPLY(z2, FIX(1.414213562));         /* c0 */
+
+    /* Odd part */
+
+    z1 = (JLONG)wsptr[1];
+    z2 = (JLONG)wsptr[3];
+    z3 = (JLONG)wsptr[5];
+
+    tmp1 = MULTIPLY(z1 + z2, FIX(0.935414347));      /* (c3+c1-c5)/2 */
+    tmp2 = MULTIPLY(z1 - z2, FIX(0.170262339));      /* (c3+c5-c1)/2 */
+    tmp0 = tmp1 - tmp2;
+    tmp1 += tmp2;
+    tmp2 = MULTIPLY(z2 + z3, -FIX(1.378756276));     /* -c1 */
+    tmp1 += tmp2;
+    z2 = MULTIPLY(z1 + z3, FIX(0.613604268));        /* c5 */
+    tmp0 += z2;
+    tmp2 += z2 + MULTIPLY(z3, FIX(1.870828693));     /* c3+c1-c5 */
+
+    /* Final output stage */
+
+    outptr[0] = range_limit[(int)RIGHT_SHIFT(tmp10 + tmp0,
+                                             CONST_BITS + PASS1_BITS + 3) &
+                            RANGE_MASK];
+    outptr[6] = range_limit[(int)RIGHT_SHIFT(tmp10 - tmp0,
+                                             CONST_BITS + PASS1_BITS + 3) &
+                            RANGE_MASK];
+    outptr[1] = range_limit[(int)RIGHT_SHIFT(tmp11 + tmp1,
+                                             CONST_BITS + PASS1_BITS + 3) &
+                            RANGE_MASK];
+    outptr[5] = range_limit[(int)RIGHT_SHIFT(tmp11 - tmp1,
+                                             CONST_BITS + PASS1_BITS + 3) &
+                            RANGE_MASK];
+    outptr[2] = range_limit[(int)RIGHT_SHIFT(tmp12 + tmp2,
+                                             CONST_BITS + PASS1_BITS + 3) &
+                            RANGE_MASK];
+    outptr[4] = range_limit[(int)RIGHT_SHIFT(tmp12 - tmp2,
+                                             CONST_BITS + PASS1_BITS + 3) &
+                            RANGE_MASK];
+    outptr[3] = range_limit[(int)RIGHT_SHIFT(tmp13,
+                                             CONST_BITS + PASS1_BITS + 3) &
+                            RANGE_MASK];
+
+    wsptr += 7;         /* advance pointer to next row */
+  }
+}
+
+
+/*
+ * Perform dequantization and inverse DCT on one block of coefficients,
+ * producing a reduced-size 6x6 output block.
+ *
+ * Optimized algorithm with 3 multiplications in the 1-D kernel.
+ * cK represents sqrt(2) * cos(K*pi/12).
+ */
+
+GLOBAL(void)
+jpeg_idct_6x6(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+              JCOEFPTR coef_block, JSAMPARRAY output_buf,
+              JDIMENSION output_col)
+{
+  JLONG tmp0, tmp1, tmp2, tmp10, tmp11, tmp12;
+  JLONG z1, z2, z3;
+  JCOEFPTR inptr;
+  ISLOW_MULT_TYPE *quantptr;
+  int *wsptr;
+  JSAMPROW outptr;
+  JSAMPLE *range_limit = IDCT_range_limit(cinfo);
+  int ctr;
+  int workspace[6 * 6];         /* buffers data between passes */
+  SHIFT_TEMPS
+
+  /* Pass 1: process columns from input, store into work array. */
+
+  inptr = coef_block;
+  quantptr = (ISLOW_MULT_TYPE *)compptr->dct_table;
+  wsptr = workspace;
+  for (ctr = 0; ctr < 6; ctr++, inptr++, quantptr++, wsptr++) {
+    /* Even part */
+
+    tmp0 = DEQUANTIZE(inptr[DCTSIZE * 0], quantptr[DCTSIZE * 0]);
+    tmp0 = LEFT_SHIFT(tmp0, CONST_BITS);
+    /* Add fudge factor here for final descale. */
+    tmp0 += ONE << (CONST_BITS - PASS1_BITS - 1);
+    tmp2 = DEQUANTIZE(inptr[DCTSIZE * 4], quantptr[DCTSIZE * 4]);
+    tmp10 = MULTIPLY(tmp2, FIX(0.707106781));   /* c4 */
+    tmp1 = tmp0 + tmp10;
+    tmp11 = RIGHT_SHIFT(tmp0 - tmp10 - tmp10, CONST_BITS - PASS1_BITS);
+    tmp10 = DEQUANTIZE(inptr[DCTSIZE * 2], quantptr[DCTSIZE * 2]);
+    tmp0 = MULTIPLY(tmp10, FIX(1.224744871));   /* c2 */
+    tmp10 = tmp1 + tmp0;
+    tmp12 = tmp1 - tmp0;
+
+    /* Odd part */
+
+    z1 = DEQUANTIZE(inptr[DCTSIZE * 1], quantptr[DCTSIZE * 1]);
+    z2 = DEQUANTIZE(inptr[DCTSIZE * 3], quantptr[DCTSIZE * 3]);
+    z3 = DEQUANTIZE(inptr[DCTSIZE * 5], quantptr[DCTSIZE * 5]);
+    tmp1 = MULTIPLY(z1 + z3, FIX(0.366025404)); /* c5 */
+    tmp0 = tmp1 + LEFT_SHIFT(z1 + z2, CONST_BITS);
+    tmp2 = tmp1 + LEFT_SHIFT(z3 - z2, CONST_BITS);
+    tmp1 = LEFT_SHIFT(z1 - z2 - z3, PASS1_BITS);
+
+    /* Final output stage */
+
+    wsptr[6 * 0] = (int)RIGHT_SHIFT(tmp10 + tmp0, CONST_BITS - PASS1_BITS);
+    wsptr[6 * 5] = (int)RIGHT_SHIFT(tmp10 - tmp0, CONST_BITS - PASS1_BITS);
+    wsptr[6 * 1] = (int)(tmp11 + tmp1);
+    wsptr[6 * 4] = (int)(tmp11 - tmp1);
+    wsptr[6 * 2] = (int)RIGHT_SHIFT(tmp12 + tmp2, CONST_BITS - PASS1_BITS);
+    wsptr[6 * 3] = (int)RIGHT_SHIFT(tmp12 - tmp2, CONST_BITS - PASS1_BITS);
+  }
+
+  /* Pass 2: process 6 rows from work array, store into output array. */
+
+  wsptr = workspace;
+  for (ctr = 0; ctr < 6; ctr++) {
+    outptr = output_buf[ctr] + output_col;
+
+    /* Even part */
+
+    /* Add fudge factor here for final descale. */
+    tmp0 = (JLONG)wsptr[0] + (ONE << (PASS1_BITS + 2));
+    tmp0 = LEFT_SHIFT(tmp0, CONST_BITS);
+    tmp2 = (JLONG)wsptr[4];
+    tmp10 = MULTIPLY(tmp2, FIX(0.707106781));   /* c4 */
+    tmp1 = tmp0 + tmp10;
+    tmp11 = tmp0 - tmp10 - tmp10;
+    tmp10 = (JLONG)wsptr[2];
+    tmp0 = MULTIPLY(tmp10, FIX(1.224744871));   /* c2 */
+    tmp10 = tmp1 + tmp0;
+    tmp12 = tmp1 - tmp0;
+
+    /* Odd part */
+
+    z1 = (JLONG)wsptr[1];
+    z2 = (JLONG)wsptr[3];
+    z3 = (JLONG)wsptr[5];
+    tmp1 = MULTIPLY(z1 + z3, FIX(0.366025404)); /* c5 */
+    tmp0 = tmp1 + LEFT_SHIFT(z1 + z2, CONST_BITS);
+    tmp2 = tmp1 + LEFT_SHIFT(z3 - z2, CONST_BITS);
+    tmp1 = LEFT_SHIFT(z1 - z2 - z3, CONST_BITS);
+
+    /* Final output stage */
+
+    outptr[0] = range_limit[(int)RIGHT_SHIFT(tmp10 + tmp0,
+                                             CONST_BITS + PASS1_BITS + 3) &
+                            RANGE_MASK];
+    outptr[5] = range_limit[(int)RIGHT_SHIFT(tmp10 - tmp0,
+                                             CONST_BITS + PASS1_BITS + 3) &
+                            RANGE_MASK];
+    outptr[1] = range_limit[(int)RIGHT_SHIFT(tmp11 + tmp1,
+                                             CONST_BITS + PASS1_BITS + 3) &
+                            RANGE_MASK];
+    outptr[4] = range_limit[(int)RIGHT_SHIFT(tmp11 - tmp1,
+                                             CONST_BITS + PASS1_BITS + 3) &
+                            RANGE_MASK];
+    outptr[2] = range_limit[(int)RIGHT_SHIFT(tmp12 + tmp2,
+                                             CONST_BITS + PASS1_BITS + 3) &
+                            RANGE_MASK];
+    outptr[3] = range_limit[(int)RIGHT_SHIFT(tmp12 - tmp2,
+                                             CONST_BITS + PASS1_BITS + 3) &
+                            RANGE_MASK];
+
+    wsptr += 6;         /* advance pointer to next row */
+  }
+}
+
+
+/*
+ * Perform dequantization and inverse DCT on one block of coefficients,
+ * producing a reduced-size 5x5 output block.
+ *
+ * Optimized algorithm with 5 multiplications in the 1-D kernel.
+ * cK represents sqrt(2) * cos(K*pi/10).
+ */
+
+GLOBAL(void)
+jpeg_idct_5x5(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+              JCOEFPTR coef_block, JSAMPARRAY output_buf,
+              JDIMENSION output_col)
+{
+  JLONG tmp0, tmp1, tmp10, tmp11, tmp12;
+  JLONG z1, z2, z3;
+  JCOEFPTR inptr;
+  ISLOW_MULT_TYPE *quantptr;
+  int *wsptr;
+  JSAMPROW outptr;
+  JSAMPLE *range_limit = IDCT_range_limit(cinfo);
+  int ctr;
+  int workspace[5 * 5];         /* buffers data between passes */
+  SHIFT_TEMPS
+
+  /* Pass 1: process columns from input, store into work array. */
+
+  inptr = coef_block;
+  quantptr = (ISLOW_MULT_TYPE *)compptr->dct_table;
+  wsptr = workspace;
+  for (ctr = 0; ctr < 5; ctr++, inptr++, quantptr++, wsptr++) {
+    /* Even part */
+
+    tmp12 = DEQUANTIZE(inptr[DCTSIZE * 0], quantptr[DCTSIZE * 0]);
+    tmp12 = LEFT_SHIFT(tmp12, CONST_BITS);
+    /* Add fudge factor here for final descale. */
+    tmp12 += ONE << (CONST_BITS - PASS1_BITS - 1);
+    tmp0 = DEQUANTIZE(inptr[DCTSIZE * 2], quantptr[DCTSIZE * 2]);
+    tmp1 = DEQUANTIZE(inptr[DCTSIZE * 4], quantptr[DCTSIZE * 4]);
+    z1 = MULTIPLY(tmp0 + tmp1, FIX(0.790569415)); /* (c2+c4)/2 */
+    z2 = MULTIPLY(tmp0 - tmp1, FIX(0.353553391)); /* (c2-c4)/2 */
+    z3 = tmp12 + z2;
+    tmp10 = z3 + z1;
+    tmp11 = z3 - z1;
+    tmp12 -= LEFT_SHIFT(z2, 2);
+
+    /* Odd part */
+
+    z2 = DEQUANTIZE(inptr[DCTSIZE * 1], quantptr[DCTSIZE * 1]);
+    z3 = DEQUANTIZE(inptr[DCTSIZE * 3], quantptr[DCTSIZE * 3]);
+
+    z1 = MULTIPLY(z2 + z3, FIX(0.831253876));     /* c3 */
+    tmp0 = z1 + MULTIPLY(z2, FIX(0.513743148));   /* c1-c3 */
+    tmp1 = z1 - MULTIPLY(z3, FIX(2.176250899));   /* c1+c3 */
+
+    /* Final output stage */
+
+    wsptr[5 * 0] = (int)RIGHT_SHIFT(tmp10 + tmp0, CONST_BITS - PASS1_BITS);
+    wsptr[5 * 4] = (int)RIGHT_SHIFT(tmp10 - tmp0, CONST_BITS - PASS1_BITS);
+    wsptr[5 * 1] = (int)RIGHT_SHIFT(tmp11 + tmp1, CONST_BITS - PASS1_BITS);
+    wsptr[5 * 3] = (int)RIGHT_SHIFT(tmp11 - tmp1, CONST_BITS - PASS1_BITS);
+    wsptr[5 * 2] = (int)RIGHT_SHIFT(tmp12, CONST_BITS - PASS1_BITS);
+  }
+
+  /* Pass 2: process 5 rows from work array, store into output array. */
+
+  wsptr = workspace;
+  for (ctr = 0; ctr < 5; ctr++) {
+    outptr = output_buf[ctr] + output_col;
+
+    /* Even part */
+
+    /* Add fudge factor here for final descale. */
+    tmp12 = (JLONG)wsptr[0] + (ONE << (PASS1_BITS + 2));
+    tmp12 = LEFT_SHIFT(tmp12, CONST_BITS);
+    tmp0 = (JLONG)wsptr[2];
+    tmp1 = (JLONG)wsptr[4];
+    z1 = MULTIPLY(tmp0 + tmp1, FIX(0.790569415)); /* (c2+c4)/2 */
+    z2 = MULTIPLY(tmp0 - tmp1, FIX(0.353553391)); /* (c2-c4)/2 */
+    z3 = tmp12 + z2;
+    tmp10 = z3 + z1;
+    tmp11 = z3 - z1;
+    tmp12 -= LEFT_SHIFT(z2, 2);
+
+    /* Odd part */
+
+    z2 = (JLONG)wsptr[1];
+    z3 = (JLONG)wsptr[3];
+
+    z1 = MULTIPLY(z2 + z3, FIX(0.831253876));     /* c3 */
+    tmp0 = z1 + MULTIPLY(z2, FIX(0.513743148));   /* c1-c3 */
+    tmp1 = z1 - MULTIPLY(z3, FIX(2.176250899));   /* c1+c3 */
+
+    /* Final output stage */
+
+    outptr[0] = range_limit[(int)RIGHT_SHIFT(tmp10 + tmp0,
+                                             CONST_BITS + PASS1_BITS + 3) &
+                            RANGE_MASK];
+    outptr[4] = range_limit[(int)RIGHT_SHIFT(tmp10 - tmp0,
+                                             CONST_BITS + PASS1_BITS + 3) &
+                            RANGE_MASK];
+    outptr[1] = range_limit[(int)RIGHT_SHIFT(tmp11 + tmp1,
+                                             CONST_BITS + PASS1_BITS + 3) &
+                            RANGE_MASK];
+    outptr[3] = range_limit[(int)RIGHT_SHIFT(tmp11 - tmp1,
+                                             CONST_BITS + PASS1_BITS + 3) &
+                            RANGE_MASK];
+    outptr[2] = range_limit[(int)RIGHT_SHIFT(tmp12,
+                                             CONST_BITS + PASS1_BITS + 3) &
+                            RANGE_MASK];
+
+    wsptr += 5;         /* advance pointer to next row */
+  }
+}
+
+
+/*
+ * Perform dequantization and inverse DCT on one block of coefficients,
+ * producing a reduced-size 3x3 output block.
+ *
+ * Optimized algorithm with 2 multiplications in the 1-D kernel.
+ * cK represents sqrt(2) * cos(K*pi/6).
+ */
+
+GLOBAL(void)
+jpeg_idct_3x3(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+              JCOEFPTR coef_block, JSAMPARRAY output_buf,
+              JDIMENSION output_col)
+{
+  JLONG tmp0, tmp2, tmp10, tmp12;
+  JCOEFPTR inptr;
+  ISLOW_MULT_TYPE *quantptr;
+  int *wsptr;
+  JSAMPROW outptr;
+  JSAMPLE *range_limit = IDCT_range_limit(cinfo);
+  int ctr;
+  int workspace[3 * 3];         /* buffers data between passes */
+  SHIFT_TEMPS
+
+  /* Pass 1: process columns from input, store into work array. */
+
+  inptr = coef_block;
+  quantptr = (ISLOW_MULT_TYPE *)compptr->dct_table;
+  wsptr = workspace;
+  for (ctr = 0; ctr < 3; ctr++, inptr++, quantptr++, wsptr++) {
+    /* Even part */
+
+    tmp0 = DEQUANTIZE(inptr[DCTSIZE * 0], quantptr[DCTSIZE * 0]);
+    tmp0 = LEFT_SHIFT(tmp0, CONST_BITS);
+    /* Add fudge factor here for final descale. */
+    tmp0 += ONE << (CONST_BITS - PASS1_BITS - 1);
+    tmp2 = DEQUANTIZE(inptr[DCTSIZE * 2], quantptr[DCTSIZE * 2]);
+    tmp12 = MULTIPLY(tmp2, FIX(0.707106781)); /* c2 */
+    tmp10 = tmp0 + tmp12;
+    tmp2 = tmp0 - tmp12 - tmp12;
+
+    /* Odd part */
+
+    tmp12 = DEQUANTIZE(inptr[DCTSIZE * 1], quantptr[DCTSIZE * 1]);
+    tmp0 = MULTIPLY(tmp12, FIX(1.224744871)); /* c1 */
+
+    /* Final output stage */
+
+    wsptr[3 * 0] = (int)RIGHT_SHIFT(tmp10 + tmp0, CONST_BITS - PASS1_BITS);
+    wsptr[3 * 2] = (int)RIGHT_SHIFT(tmp10 - tmp0, CONST_BITS - PASS1_BITS);
+    wsptr[3 * 1] = (int)RIGHT_SHIFT(tmp2, CONST_BITS - PASS1_BITS);
+  }
+
+  /* Pass 2: process 3 rows from work array, store into output array. */
+
+  wsptr = workspace;
+  for (ctr = 0; ctr < 3; ctr++) {
+    outptr = output_buf[ctr] + output_col;
+
+    /* Even part */
+
+    /* Add fudge factor here for final descale. */
+    tmp0 = (JLONG)wsptr[0] + (ONE << (PASS1_BITS + 2));
+    tmp0 = LEFT_SHIFT(tmp0, CONST_BITS);
+    tmp2 = (JLONG)wsptr[2];
+    tmp12 = MULTIPLY(tmp2, FIX(0.707106781)); /* c2 */
+    tmp10 = tmp0 + tmp12;
+    tmp2 = tmp0 - tmp12 - tmp12;
+
+    /* Odd part */
+
+    tmp12 = (JLONG)wsptr[1];
+    tmp0 = MULTIPLY(tmp12, FIX(1.224744871)); /* c1 */
+
+    /* Final output stage */
+
+    outptr[0] = range_limit[(int)RIGHT_SHIFT(tmp10 + tmp0,
+                                             CONST_BITS + PASS1_BITS + 3) &
+                            RANGE_MASK];
+    outptr[2] = range_limit[(int)RIGHT_SHIFT(tmp10 - tmp0,
+                                             CONST_BITS + PASS1_BITS + 3) &
+                            RANGE_MASK];
+    outptr[1] = range_limit[(int)RIGHT_SHIFT(tmp2,
+                                             CONST_BITS + PASS1_BITS + 3) &
+                            RANGE_MASK];
+
+    wsptr += 3;         /* advance pointer to next row */
+  }
+}
+
+
+/*
+ * Perform dequantization and inverse DCT on one block of coefficients,
+ * producing a 9x9 output block.
+ *
+ * Optimized algorithm with 10 multiplications in the 1-D kernel.
+ * cK represents sqrt(2) * cos(K*pi/18).
+ */
+
+GLOBAL(void)
+jpeg_idct_9x9(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+              JCOEFPTR coef_block, JSAMPARRAY output_buf,
+              JDIMENSION output_col)
+{
+  JLONG tmp0, tmp1, tmp2, tmp3, tmp10, tmp11, tmp12, tmp13, tmp14;
+  JLONG z1, z2, z3, z4;
+  JCOEFPTR inptr;
+  ISLOW_MULT_TYPE *quantptr;
+  int *wsptr;
+  JSAMPROW outptr;
+  JSAMPLE *range_limit = IDCT_range_limit(cinfo);
+  int ctr;
+  int workspace[8 * 9];         /* buffers data between passes */
+  SHIFT_TEMPS
+
+  /* Pass 1: process columns from input, store into work array. */
+
+  inptr = coef_block;
+  quantptr = (ISLOW_MULT_TYPE *)compptr->dct_table;
+  wsptr = workspace;
+  for (ctr = 0; ctr < 8; ctr++, inptr++, quantptr++, wsptr++) {
+    /* Even part */
+
+    tmp0 = DEQUANTIZE(inptr[DCTSIZE * 0], quantptr[DCTSIZE * 0]);
+    tmp0 = LEFT_SHIFT(tmp0, CONST_BITS);
+    /* Add fudge factor here for final descale. */
+    tmp0 += ONE << (CONST_BITS - PASS1_BITS - 1);
+
+    z1 = DEQUANTIZE(inptr[DCTSIZE * 2], quantptr[DCTSIZE * 2]);
+    z2 = DEQUANTIZE(inptr[DCTSIZE * 4], quantptr[DCTSIZE * 4]);
+    z3 = DEQUANTIZE(inptr[DCTSIZE * 6], quantptr[DCTSIZE * 6]);
+
+    tmp3 = MULTIPLY(z3, FIX(0.707106781));      /* c6 */
+    tmp1 = tmp0 + tmp3;
+    tmp2 = tmp0 - tmp3 - tmp3;
+
+    tmp0 = MULTIPLY(z1 - z2, FIX(0.707106781)); /* c6 */
+    tmp11 = tmp2 + tmp0;
+    tmp14 = tmp2 - tmp0 - tmp0;
+
+    tmp0 = MULTIPLY(z1 + z2, FIX(1.328926049)); /* c2 */
+    tmp2 = MULTIPLY(z1, FIX(1.083350441));      /* c4 */
+    tmp3 = MULTIPLY(z2, FIX(0.245575608));      /* c8 */
+
+    tmp10 = tmp1 + tmp0 - tmp3;
+    tmp12 = tmp1 - tmp0 + tmp2;
+    tmp13 = tmp1 - tmp2 + tmp3;
+
+    /* Odd part */
+
+    z1 = DEQUANTIZE(inptr[DCTSIZE * 1], quantptr[DCTSIZE * 1]);
+    z2 = DEQUANTIZE(inptr[DCTSIZE * 3], quantptr[DCTSIZE * 3]);
+    z3 = DEQUANTIZE(inptr[DCTSIZE * 5], quantptr[DCTSIZE * 5]);
+    z4 = DEQUANTIZE(inptr[DCTSIZE * 7], quantptr[DCTSIZE * 7]);
+
+    z2 = MULTIPLY(z2, -FIX(1.224744871));            /* -c3 */
+
+    tmp2 = MULTIPLY(z1 + z3, FIX(0.909038955));      /* c5 */
+    tmp3 = MULTIPLY(z1 + z4, FIX(0.483689525));      /* c7 */
+    tmp0 = tmp2 + tmp3 - z2;
+    tmp1 = MULTIPLY(z3 - z4, FIX(1.392728481));      /* c1 */
+    tmp2 += z2 - tmp1;
+    tmp3 += z2 + tmp1;
+    tmp1 = MULTIPLY(z1 - z3 - z4, FIX(1.224744871)); /* c3 */
+
+    /* Final output stage */
+
+    wsptr[8 * 0] = (int)RIGHT_SHIFT(tmp10 + tmp0, CONST_BITS - PASS1_BITS);
+    wsptr[8 * 8] = (int)RIGHT_SHIFT(tmp10 - tmp0, CONST_BITS - PASS1_BITS);
+    wsptr[8 * 1] = (int)RIGHT_SHIFT(tmp11 + tmp1, CONST_BITS - PASS1_BITS);
+    wsptr[8 * 7] = (int)RIGHT_SHIFT(tmp11 - tmp1, CONST_BITS - PASS1_BITS);
+    wsptr[8 * 2] = (int)RIGHT_SHIFT(tmp12 + tmp2, CONST_BITS - PASS1_BITS);
+    wsptr[8 * 6] = (int)RIGHT_SHIFT(tmp12 - tmp2, CONST_BITS - PASS1_BITS);
+    wsptr[8 * 3] = (int)RIGHT_SHIFT(tmp13 + tmp3, CONST_BITS - PASS1_BITS);
+    wsptr[8 * 5] = (int)RIGHT_SHIFT(tmp13 - tmp3, CONST_BITS - PASS1_BITS);
+    wsptr[8 * 4] = (int)RIGHT_SHIFT(tmp14, CONST_BITS - PASS1_BITS);
+  }
+
+  /* Pass 2: process 9 rows from work array, store into output array. */
+
+  wsptr = workspace;
+  for (ctr = 0; ctr < 9; ctr++) {
+    outptr = output_buf[ctr] + output_col;
+
+    /* Even part */
+
+    /* Add fudge factor here for final descale. */
+    tmp0 = (JLONG)wsptr[0] + (ONE << (PASS1_BITS + 2));
+    tmp0 = LEFT_SHIFT(tmp0, CONST_BITS);
+
+    z1 = (JLONG)wsptr[2];
+    z2 = (JLONG)wsptr[4];
+    z3 = (JLONG)wsptr[6];
+
+    tmp3 = MULTIPLY(z3, FIX(0.707106781));      /* c6 */
+    tmp1 = tmp0 + tmp3;
+    tmp2 = tmp0 - tmp3 - tmp3;
+
+    tmp0 = MULTIPLY(z1 - z2, FIX(0.707106781)); /* c6 */
+    tmp11 = tmp2 + tmp0;
+    tmp14 = tmp2 - tmp0 - tmp0;
+
+    tmp0 = MULTIPLY(z1 + z2, FIX(1.328926049)); /* c2 */
+    tmp2 = MULTIPLY(z1, FIX(1.083350441));      /* c4 */
+    tmp3 = MULTIPLY(z2, FIX(0.245575608));      /* c8 */
+
+    tmp10 = tmp1 + tmp0 - tmp3;
+    tmp12 = tmp1 - tmp0 + tmp2;
+    tmp13 = tmp1 - tmp2 + tmp3;
+
+    /* Odd part */
+
+    z1 = (JLONG)wsptr[1];
+    z2 = (JLONG)wsptr[3];
+    z3 = (JLONG)wsptr[5];
+    z4 = (JLONG)wsptr[7];
+
+    z2 = MULTIPLY(z2, -FIX(1.224744871));            /* -c3 */
+
+    tmp2 = MULTIPLY(z1 + z3, FIX(0.909038955));      /* c5 */
+    tmp3 = MULTIPLY(z1 + z4, FIX(0.483689525));      /* c7 */
+    tmp0 = tmp2 + tmp3 - z2;
+    tmp1 = MULTIPLY(z3 - z4, FIX(1.392728481));      /* c1 */
+    tmp2 += z2 - tmp1;
+    tmp3 += z2 + tmp1;
+    tmp1 = MULTIPLY(z1 - z3 - z4, FIX(1.224744871)); /* c3 */
+
+    /* Final output stage */
+
+    outptr[0] = range_limit[(int)RIGHT_SHIFT(tmp10 + tmp0,
+                                             CONST_BITS + PASS1_BITS + 3) &
+                            RANGE_MASK];
+    outptr[8] = range_limit[(int)RIGHT_SHIFT(tmp10 - tmp0,
+                                             CONST_BITS + PASS1_BITS + 3) &
+                            RANGE_MASK];
+    outptr[1] = range_limit[(int)RIGHT_SHIFT(tmp11 + tmp1,
+                                             CONST_BITS + PASS1_BITS + 3) &
+                            RANGE_MASK];
+    outptr[7] = range_limit[(int)RIGHT_SHIFT(tmp11 - tmp1,
+                                             CONST_BITS + PASS1_BITS + 3) &
+                            RANGE_MASK];
+    outptr[2] = range_limit[(int)RIGHT_SHIFT(tmp12 + tmp2,
+                                             CONST_BITS + PASS1_BITS + 3) &
+                            RANGE_MASK];
+    outptr[6] = range_limit[(int)RIGHT_SHIFT(tmp12 - tmp2,
+                                             CONST_BITS + PASS1_BITS + 3) &
+                            RANGE_MASK];
+    outptr[3] = range_limit[(int)RIGHT_SHIFT(tmp13 + tmp3,
+                                             CONST_BITS + PASS1_BITS + 3) &
+                            RANGE_MASK];
+    outptr[5] = range_limit[(int)RIGHT_SHIFT(tmp13 - tmp3,
+                                             CONST_BITS + PASS1_BITS + 3) &
+                            RANGE_MASK];
+    outptr[4] = range_limit[(int)RIGHT_SHIFT(tmp14,
+                                             CONST_BITS + PASS1_BITS + 3) &
+                            RANGE_MASK];
+
+    wsptr += 8;         /* advance pointer to next row */
+  }
+}
+
+
+/*
+ * Perform dequantization and inverse DCT on one block of coefficients,
+ * producing a 10x10 output block.
+ *
+ * Optimized algorithm with 12 multiplications in the 1-D kernel.
+ * cK represents sqrt(2) * cos(K*pi/20).
+ */
+
+GLOBAL(void)
+jpeg_idct_10x10(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+                JCOEFPTR coef_block, JSAMPARRAY output_buf,
+                JDIMENSION output_col)
+{
+  JLONG tmp10, tmp11, tmp12, tmp13, tmp14;
+  JLONG tmp20, tmp21, tmp22, tmp23, tmp24;
+  JLONG z1, z2, z3, z4, z5;
+  JCOEFPTR inptr;
+  ISLOW_MULT_TYPE *quantptr;
+  int *wsptr;
+  JSAMPROW outptr;
+  JSAMPLE *range_limit = IDCT_range_limit(cinfo);
+  int ctr;
+  int workspace[8 * 10];        /* buffers data between passes */
+  SHIFT_TEMPS
+
+  /* Pass 1: process columns from input, store into work array. */
+
+  inptr = coef_block;
+  quantptr = (ISLOW_MULT_TYPE *)compptr->dct_table;
+  wsptr = workspace;
+  for (ctr = 0; ctr < 8; ctr++, inptr++, quantptr++, wsptr++) {
+    /* Even part */
+
+    z3 = DEQUANTIZE(inptr[DCTSIZE * 0], quantptr[DCTSIZE * 0]);
+    z3 = LEFT_SHIFT(z3, CONST_BITS);
+    /* Add fudge factor here for final descale. */
+    z3 += ONE << (CONST_BITS - PASS1_BITS - 1);
+    z4 = DEQUANTIZE(inptr[DCTSIZE * 4], quantptr[DCTSIZE * 4]);
+    z1 = MULTIPLY(z4, FIX(1.144122806));         /* c4 */
+    z2 = MULTIPLY(z4, FIX(0.437016024));         /* c8 */
+    tmp10 = z3 + z1;
+    tmp11 = z3 - z2;
+
+    tmp22 = RIGHT_SHIFT(z3 - LEFT_SHIFT(z1 - z2, 1),
+                        CONST_BITS - PASS1_BITS); /* c0 = (c4-c8)*2 */
+
+    z2 = DEQUANTIZE(inptr[DCTSIZE * 2], quantptr[DCTSIZE * 2]);
+    z3 = DEQUANTIZE(inptr[DCTSIZE * 6], quantptr[DCTSIZE * 6]);
+
+    z1 = MULTIPLY(z2 + z3, FIX(0.831253876));    /* c6 */
+    tmp12 = z1 + MULTIPLY(z2, FIX(0.513743148)); /* c2-c6 */
+    tmp13 = z1 - MULTIPLY(z3, FIX(2.176250899)); /* c2+c6 */
+
+    tmp20 = tmp10 + tmp12;
+    tmp24 = tmp10 - tmp12;
+    tmp21 = tmp11 + tmp13;
+    tmp23 = tmp11 - tmp13;
+
+    /* Odd part */
+
+    z1 = DEQUANTIZE(inptr[DCTSIZE * 1], quantptr[DCTSIZE * 1]);
+    z2 = DEQUANTIZE(inptr[DCTSIZE * 3], quantptr[DCTSIZE * 3]);
+    z3 = DEQUANTIZE(inptr[DCTSIZE * 5], quantptr[DCTSIZE * 5]);
+    z4 = DEQUANTIZE(inptr[DCTSIZE * 7], quantptr[DCTSIZE * 7]);
+
+    tmp11 = z2 + z4;
+    tmp13 = z2 - z4;
+
+    tmp12 = MULTIPLY(tmp13, FIX(0.309016994));        /* (c3-c7)/2 */
+    z5 = LEFT_SHIFT(z3, CONST_BITS);
+
+    z2 = MULTIPLY(tmp11, FIX(0.951056516));           /* (c3+c7)/2 */
+    z4 = z5 + tmp12;
+
+    tmp10 = MULTIPLY(z1, FIX(1.396802247)) + z2 + z4; /* c1 */
+    tmp14 = MULTIPLY(z1, FIX(0.221231742)) - z2 + z4; /* c9 */
+
+    z2 = MULTIPLY(tmp11, FIX(0.587785252));           /* (c1-c9)/2 */
+    z4 = z5 - tmp12 - LEFT_SHIFT(tmp13, CONST_BITS - 1);
+
+    tmp12 = LEFT_SHIFT(z1 - tmp13 - z3, PASS1_BITS);
+
+    tmp11 = MULTIPLY(z1, FIX(1.260073511)) - z2 - z4; /* c3 */
+    tmp13 = MULTIPLY(z1, FIX(0.642039522)) - z2 + z4; /* c7 */
+
+    /* Final output stage */
+
+    wsptr[8 * 0] = (int)RIGHT_SHIFT(tmp20 + tmp10, CONST_BITS - PASS1_BITS);
+    wsptr[8 * 9] = (int)RIGHT_SHIFT(tmp20 - tmp10, CONST_BITS - PASS1_BITS);
+    wsptr[8 * 1] = (int)RIGHT_SHIFT(tmp21 + tmp11, CONST_BITS - PASS1_BITS);
+    wsptr[8 * 8] = (int)RIGHT_SHIFT(tmp21 - tmp11, CONST_BITS - PASS1_BITS);
+    wsptr[8 * 2] = (int)(tmp22 + tmp12);
+    wsptr[8 * 7] = (int)(tmp22 - tmp12);
+    wsptr[8 * 3] = (int)RIGHT_SHIFT(tmp23 + tmp13, CONST_BITS - PASS1_BITS);
+    wsptr[8 * 6] = (int)RIGHT_SHIFT(tmp23 - tmp13, CONST_BITS - PASS1_BITS);
+    wsptr[8 * 4] = (int)RIGHT_SHIFT(tmp24 + tmp14, CONST_BITS - PASS1_BITS);
+    wsptr[8 * 5] = (int)RIGHT_SHIFT(tmp24 - tmp14, CONST_BITS - PASS1_BITS);
+  }
+
+  /* Pass 2: process 10 rows from work array, store into output array. */
+
+  wsptr = workspace;
+  for (ctr = 0; ctr < 10; ctr++) {
+    outptr = output_buf[ctr] + output_col;
+
+    /* Even part */
+
+    /* Add fudge factor here for final descale. */
+    z3 = (JLONG)wsptr[0] + (ONE << (PASS1_BITS + 2));
+    z3 = LEFT_SHIFT(z3, CONST_BITS);
+    z4 = (JLONG)wsptr[4];
+    z1 = MULTIPLY(z4, FIX(1.144122806));         /* c4 */
+    z2 = MULTIPLY(z4, FIX(0.437016024));         /* c8 */
+    tmp10 = z3 + z1;
+    tmp11 = z3 - z2;
+
+    tmp22 = z3 - LEFT_SHIFT(z1 - z2, 1);         /* c0 = (c4-c8)*2 */
+
+    z2 = (JLONG)wsptr[2];
+    z3 = (JLONG)wsptr[6];
+
+    z1 = MULTIPLY(z2 + z3, FIX(0.831253876));    /* c6 */
+    tmp12 = z1 + MULTIPLY(z2, FIX(0.513743148)); /* c2-c6 */
+    tmp13 = z1 - MULTIPLY(z3, FIX(2.176250899)); /* c2+c6 */
+
+    tmp20 = tmp10 + tmp12;
+    tmp24 = tmp10 - tmp12;
+    tmp21 = tmp11 + tmp13;
+    tmp23 = tmp11 - tmp13;
+
+    /* Odd part */
+
+    z1 = (JLONG)wsptr[1];
+    z2 = (JLONG)wsptr[3];
+    z3 = (JLONG)wsptr[5];
+    z3 = LEFT_SHIFT(z3, CONST_BITS);
+    z4 = (JLONG)wsptr[7];
+
+    tmp11 = z2 + z4;
+    tmp13 = z2 - z4;
+
+    tmp12 = MULTIPLY(tmp13, FIX(0.309016994));        /* (c3-c7)/2 */
+
+    z2 = MULTIPLY(tmp11, FIX(0.951056516));           /* (c3+c7)/2 */
+    z4 = z3 + tmp12;
+
+    tmp10 = MULTIPLY(z1, FIX(1.396802247)) + z2 + z4; /* c1 */
+    tmp14 = MULTIPLY(z1, FIX(0.221231742)) - z2 + z4; /* c9 */
+
+    z2 = MULTIPLY(tmp11, FIX(0.587785252));           /* (c1-c9)/2 */
+    z4 = z3 - tmp12 - LEFT_SHIFT(tmp13, CONST_BITS - 1);
+
+    tmp12 = LEFT_SHIFT(z1 - tmp13, CONST_BITS) - z3;
+
+    tmp11 = MULTIPLY(z1, FIX(1.260073511)) - z2 - z4; /* c3 */
+    tmp13 = MULTIPLY(z1, FIX(0.642039522)) - z2 + z4; /* c7 */
+
+    /* Final output stage */
+
+    outptr[0] = range_limit[(int)RIGHT_SHIFT(tmp20 + tmp10,
+                                             CONST_BITS + PASS1_BITS + 3) &
+                            RANGE_MASK];
+    outptr[9] = range_limit[(int)RIGHT_SHIFT(tmp20 - tmp10,
+                                             CONST_BITS + PASS1_BITS + 3) &
+                            RANGE_MASK];
+    outptr[1] = range_limit[(int)RIGHT_SHIFT(tmp21 + tmp11,
+                                             CONST_BITS + PASS1_BITS + 3) &
+                            RANGE_MASK];
+    outptr[8] = range_limit[(int)RIGHT_SHIFT(tmp21 - tmp11,
+                                             CONST_BITS + PASS1_BITS + 3) &
+                            RANGE_MASK];
+    outptr[2] = range_limit[(int)RIGHT_SHIFT(tmp22 + tmp12,
+                                             CONST_BITS + PASS1_BITS + 3) &
+                            RANGE_MASK];
+    outptr[7] = range_limit[(int)RIGHT_SHIFT(tmp22 - tmp12,
+                                             CONST_BITS + PASS1_BITS + 3) &
+                            RANGE_MASK];
+    outptr[3] = range_limit[(int)RIGHT_SHIFT(tmp23 + tmp13,
+                                             CONST_BITS + PASS1_BITS + 3) &
+                            RANGE_MASK];
+    outptr[6] = range_limit[(int)RIGHT_SHIFT(tmp23 - tmp13,
+                                             CONST_BITS + PASS1_BITS + 3) &
+                            RANGE_MASK];
+    outptr[4] = range_limit[(int)RIGHT_SHIFT(tmp24 + tmp14,
+                                             CONST_BITS + PASS1_BITS + 3) &
+                            RANGE_MASK];
+    outptr[5] = range_limit[(int)RIGHT_SHIFT(tmp24 - tmp14,
+                                             CONST_BITS + PASS1_BITS + 3) &
+                            RANGE_MASK];
+
+    wsptr += 8;         /* advance pointer to next row */
+  }
+}
+
+
+/*
+ * Perform dequantization and inverse DCT on one block of coefficients,
+ * producing an 11x11 output block.
+ *
+ * Optimized algorithm with 24 multiplications in the 1-D kernel.
+ * cK represents sqrt(2) * cos(K*pi/22).
+ */
+
+GLOBAL(void)
+jpeg_idct_11x11(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+                JCOEFPTR coef_block, JSAMPARRAY output_buf,
+                JDIMENSION output_col)
+{
+  JLONG tmp10, tmp11, tmp12, tmp13, tmp14;
+  JLONG tmp20, tmp21, tmp22, tmp23, tmp24, tmp25;
+  JLONG z1, z2, z3, z4;
+  JCOEFPTR inptr;
+  ISLOW_MULT_TYPE *quantptr;
+  int *wsptr;
+  JSAMPROW outptr;
+  JSAMPLE *range_limit = IDCT_range_limit(cinfo);
+  int ctr;
+  int workspace[8 * 11];        /* buffers data between passes */
+  SHIFT_TEMPS
+
+  /* Pass 1: process columns from input, store into work array. */
+
+  inptr = coef_block;
+  quantptr = (ISLOW_MULT_TYPE *)compptr->dct_table;
+  wsptr = workspace;
+  for (ctr = 0; ctr < 8; ctr++, inptr++, quantptr++, wsptr++) {
+    /* Even part */
+
+    tmp10 = DEQUANTIZE(inptr[DCTSIZE * 0], quantptr[DCTSIZE * 0]);
+    tmp10 = LEFT_SHIFT(tmp10, CONST_BITS);
+    /* Add fudge factor here for final descale. */
+    tmp10 += ONE << (CONST_BITS - PASS1_BITS - 1);
+
+    z1 = DEQUANTIZE(inptr[DCTSIZE * 2], quantptr[DCTSIZE * 2]);
+    z2 = DEQUANTIZE(inptr[DCTSIZE * 4], quantptr[DCTSIZE * 4]);
+    z3 = DEQUANTIZE(inptr[DCTSIZE * 6], quantptr[DCTSIZE * 6]);
+
+    tmp20 = MULTIPLY(z2 - z3, FIX(2.546640132));     /* c2+c4 */
+    tmp23 = MULTIPLY(z2 - z1, FIX(0.430815045));     /* c2-c6 */
+    z4 = z1 + z3;
+    tmp24 = MULTIPLY(z4, -FIX(1.155664402));         /* -(c2-c10) */
+    z4 -= z2;
+    tmp25 = tmp10 + MULTIPLY(z4, FIX(1.356927976));  /* c2 */
+    tmp21 = tmp20 + tmp23 + tmp25 -
+            MULTIPLY(z2, FIX(1.821790775));          /* c2+c4+c10-c6 */
+    tmp20 += tmp25 + MULTIPLY(z3, FIX(2.115825087)); /* c4+c6 */
+    tmp23 += tmp25 - MULTIPLY(z1, FIX(1.513598477)); /* c6+c8 */
+    tmp24 += tmp25;
+    tmp22 = tmp24 - MULTIPLY(z3, FIX(0.788749120));  /* c8+c10 */
+    tmp24 += MULTIPLY(z2, FIX(1.944413522)) -        /* c2+c8 */
+             MULTIPLY(z1, FIX(1.390975730));         /* c4+c10 */
+    tmp25 = tmp10 - MULTIPLY(z4, FIX(1.414213562));  /* c0 */
+
+    /* Odd part */
+
+    z1 = DEQUANTIZE(inptr[DCTSIZE * 1], quantptr[DCTSIZE * 1]);
+    z2 = DEQUANTIZE(inptr[DCTSIZE * 3], quantptr[DCTSIZE * 3]);
+    z3 = DEQUANTIZE(inptr[DCTSIZE * 5], quantptr[DCTSIZE * 5]);
+    z4 = DEQUANTIZE(inptr[DCTSIZE * 7], quantptr[DCTSIZE * 7]);
+
+    tmp11 = z1 + z2;
+    tmp14 = MULTIPLY(tmp11 + z3 + z4, FIX(0.398430003)); /* c9 */
+    tmp11 = MULTIPLY(tmp11, FIX(0.887983902));           /* c3-c9 */
+    tmp12 = MULTIPLY(z1 + z3, FIX(0.670361295));         /* c5-c9 */
+    tmp13 = tmp14 + MULTIPLY(z1 + z4, FIX(0.366151574)); /* c7-c9 */
+    tmp10 = tmp11 + tmp12 + tmp13 -
+            MULTIPLY(z1, FIX(0.923107866));              /* c7+c5+c3-c1-2*c9 */
+    z1    = tmp14 - MULTIPLY(z2 + z3, FIX(1.163011579)); /* c7+c9 */
+    tmp11 += z1 + MULTIPLY(z2, FIX(2.073276588));        /* c1+c7+3*c9-c3 */
+    tmp12 += z1 - MULTIPLY(z3, FIX(1.192193623));        /* c3+c5-c7-c9 */
+    z1    = MULTIPLY(z2 + z4, -FIX(1.798248910));        /* -(c1+c9) */
+    tmp11 += z1;
+    tmp13 += z1 + MULTIPLY(z4, FIX(2.102458632));        /* c1+c5+c9-c7 */
+    tmp14 += MULTIPLY(z2, -FIX(1.467221301)) +           /* -(c5+c9) */
+             MULTIPLY(z3, FIX(1.001388905)) -            /* c1-c9 */
+             MULTIPLY(z4, FIX(1.684843907));             /* c3+c9 */
+
+    /* Final output stage */
+
+    wsptr[8 * 0]  = (int)RIGHT_SHIFT(tmp20 + tmp10, CONST_BITS - PASS1_BITS);
+    wsptr[8 * 10] = (int)RIGHT_SHIFT(tmp20 - tmp10, CONST_BITS - PASS1_BITS);
+    wsptr[8 * 1]  = (int)RIGHT_SHIFT(tmp21 + tmp11, CONST_BITS - PASS1_BITS);
+    wsptr[8 * 9]  = (int)RIGHT_SHIFT(tmp21 - tmp11, CONST_BITS - PASS1_BITS);
+    wsptr[8 * 2]  = (int)RIGHT_SHIFT(tmp22 + tmp12, CONST_BITS - PASS1_BITS);
+    wsptr[8 * 8]  = (int)RIGHT_SHIFT(tmp22 - tmp12, CONST_BITS - PASS1_BITS);
+    wsptr[8 * 3]  = (int)RIGHT_SHIFT(tmp23 + tmp13, CONST_BITS - PASS1_BITS);
+    wsptr[8 * 7]  = (int)RIGHT_SHIFT(tmp23 - tmp13, CONST_BITS - PASS1_BITS);
+    wsptr[8 * 4]  = (int)RIGHT_SHIFT(tmp24 + tmp14, CONST_BITS - PASS1_BITS);
+    wsptr[8 * 6]  = (int)RIGHT_SHIFT(tmp24 - tmp14, CONST_BITS - PASS1_BITS);
+    wsptr[8 * 5]  = (int)RIGHT_SHIFT(tmp25, CONST_BITS - PASS1_BITS);
+  }
+
+  /* Pass 2: process 11 rows from work array, store into output array. */
+
+  wsptr = workspace;
+  for (ctr = 0; ctr < 11; ctr++) {
+    outptr = output_buf[ctr] + output_col;
+
+    /* Even part */
+
+    /* Add fudge factor here for final descale. */
+    tmp10 = (JLONG)wsptr[0] + (ONE << (PASS1_BITS + 2));
+    tmp10 = LEFT_SHIFT(tmp10, CONST_BITS);
+
+    z1 = (JLONG)wsptr[2];
+    z2 = (JLONG)wsptr[4];
+    z3 = (JLONG)wsptr[6];
+
+    tmp20 = MULTIPLY(z2 - z3, FIX(2.546640132));     /* c2+c4 */
+    tmp23 = MULTIPLY(z2 - z1, FIX(0.430815045));     /* c2-c6 */
+    z4 = z1 + z3;
+    tmp24 = MULTIPLY(z4, -FIX(1.155664402));         /* -(c2-c10) */
+    z4 -= z2;
+    tmp25 = tmp10 + MULTIPLY(z4, FIX(1.356927976));  /* c2 */
+    tmp21 = tmp20 + tmp23 + tmp25 -
+            MULTIPLY(z2, FIX(1.821790775));          /* c2+c4+c10-c6 */
+    tmp20 += tmp25 + MULTIPLY(z3, FIX(2.115825087)); /* c4+c6 */
+    tmp23 += tmp25 - MULTIPLY(z1, FIX(1.513598477)); /* c6+c8 */
+    tmp24 += tmp25;
+    tmp22 = tmp24 - MULTIPLY(z3, FIX(0.788749120));  /* c8+c10 */
+    tmp24 += MULTIPLY(z2, FIX(1.944413522)) -        /* c2+c8 */
+             MULTIPLY(z1, FIX(1.390975730));         /* c4+c10 */
+    tmp25 = tmp10 - MULTIPLY(z4, FIX(1.414213562));  /* c0 */
+
+    /* Odd part */
+
+    z1 = (JLONG)wsptr[1];
+    z2 = (JLONG)wsptr[3];
+    z3 = (JLONG)wsptr[5];
+    z4 = (JLONG)wsptr[7];
+
+    tmp11 = z1 + z2;
+    tmp14 = MULTIPLY(tmp11 + z3 + z4, FIX(0.398430003)); /* c9 */
+    tmp11 = MULTIPLY(tmp11, FIX(0.887983902));           /* c3-c9 */
+    tmp12 = MULTIPLY(z1 + z3, FIX(0.670361295));         /* c5-c9 */
+    tmp13 = tmp14 + MULTIPLY(z1 + z4, FIX(0.366151574)); /* c7-c9 */
+    tmp10 = tmp11 + tmp12 + tmp13 -
+            MULTIPLY(z1, FIX(0.923107866));              /* c7+c5+c3-c1-2*c9 */
+    z1    = tmp14 - MULTIPLY(z2 + z3, FIX(1.163011579)); /* c7+c9 */
+    tmp11 += z1 + MULTIPLY(z2, FIX(2.073276588));        /* c1+c7+3*c9-c3 */
+    tmp12 += z1 - MULTIPLY(z3, FIX(1.192193623));        /* c3+c5-c7-c9 */
+    z1    = MULTIPLY(z2 + z4, -FIX(1.798248910));        /* -(c1+c9) */
+    tmp11 += z1;
+    tmp13 += z1 + MULTIPLY(z4, FIX(2.102458632));        /* c1+c5+c9-c7 */
+    tmp14 += MULTIPLY(z2, -FIX(1.467221301)) +           /* -(c5+c9) */
+             MULTIPLY(z3, FIX(1.001388905)) -            /* c1-c9 */
+             MULTIPLY(z4, FIX(1.684843907));             /* c3+c9 */
+
+    /* Final output stage */
+
+    outptr[0]  = range_limit[(int)RIGHT_SHIFT(tmp20 + tmp10,
+                                              CONST_BITS + PASS1_BITS + 3) &
+                             RANGE_MASK];
+    outptr[10] = range_limit[(int)RIGHT_SHIFT(tmp20 - tmp10,
+                                              CONST_BITS + PASS1_BITS + 3) &
+                             RANGE_MASK];
+    outptr[1]  = range_limit[(int)RIGHT_SHIFT(tmp21 + tmp11,
+                                              CONST_BITS + PASS1_BITS + 3) &
+                             RANGE_MASK];
+    outptr[9]  = range_limit[(int)RIGHT_SHIFT(tmp21 - tmp11,
+                                              CONST_BITS + PASS1_BITS + 3) &
+                             RANGE_MASK];
+    outptr[2]  = range_limit[(int)RIGHT_SHIFT(tmp22 + tmp12,
+                                              CONST_BITS + PASS1_BITS + 3) &
+                             RANGE_MASK];
+    outptr[8]  = range_limit[(int)RIGHT_SHIFT(tmp22 - tmp12,
+                                              CONST_BITS + PASS1_BITS + 3) &
+                             RANGE_MASK];
+    outptr[3]  = range_limit[(int)RIGHT_SHIFT(tmp23 + tmp13,
+                                              CONST_BITS + PASS1_BITS + 3) &
+                             RANGE_MASK];
+    outptr[7]  = range_limit[(int)RIGHT_SHIFT(tmp23 - tmp13,
+                                              CONST_BITS + PASS1_BITS + 3) &
+                             RANGE_MASK];
+    outptr[4]  = range_limit[(int)RIGHT_SHIFT(tmp24 + tmp14,
+                                              CONST_BITS + PASS1_BITS + 3) &
+                             RANGE_MASK];
+    outptr[6]  = range_limit[(int)RIGHT_SHIFT(tmp24 - tmp14,
+                                              CONST_BITS + PASS1_BITS + 3) &
+                             RANGE_MASK];
+    outptr[5]  = range_limit[(int)RIGHT_SHIFT(tmp25,
+                                              CONST_BITS + PASS1_BITS + 3) &
+                             RANGE_MASK];
+
+    wsptr += 8;         /* advance pointer to next row */
+  }
+}
+
+
+/*
+ * Perform dequantization and inverse DCT on one block of coefficients,
+ * producing a 12x12 output block.
+ *
+ * Optimized algorithm with 15 multiplications in the 1-D kernel.
+ * cK represents sqrt(2) * cos(K*pi/24).
+ */
+
+GLOBAL(void)
+jpeg_idct_12x12(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+                JCOEFPTR coef_block, JSAMPARRAY output_buf,
+                JDIMENSION output_col)
+{
+  JLONG tmp10, tmp11, tmp12, tmp13, tmp14, tmp15;
+  JLONG tmp20, tmp21, tmp22, tmp23, tmp24, tmp25;
+  JLONG z1, z2, z3, z4;
+  JCOEFPTR inptr;
+  ISLOW_MULT_TYPE *quantptr;
+  int *wsptr;
+  JSAMPROW outptr;
+  JSAMPLE *range_limit = IDCT_range_limit(cinfo);
+  int ctr;
+  int workspace[8 * 12];        /* buffers data between passes */
+  SHIFT_TEMPS
+
+  /* Pass 1: process columns from input, store into work array. */
+
+  inptr = coef_block;
+  quantptr = (ISLOW_MULT_TYPE *)compptr->dct_table;
+  wsptr = workspace;
+  for (ctr = 0; ctr < 8; ctr++, inptr++, quantptr++, wsptr++) {
+    /* Even part */
+
+    z3 = DEQUANTIZE(inptr[DCTSIZE * 0], quantptr[DCTSIZE * 0]);
+    z3 = LEFT_SHIFT(z3, CONST_BITS);
+    /* Add fudge factor here for final descale. */
+    z3 += ONE << (CONST_BITS - PASS1_BITS - 1);
+
+    z4 = DEQUANTIZE(inptr[DCTSIZE * 4], quantptr[DCTSIZE * 4]);
+    z4 = MULTIPLY(z4, FIX(1.224744871)); /* c4 */
+
+    tmp10 = z3 + z4;
+    tmp11 = z3 - z4;
+
+    z1 = DEQUANTIZE(inptr[DCTSIZE * 2], quantptr[DCTSIZE * 2]);
+    z4 = MULTIPLY(z1, FIX(1.366025404)); /* c2 */
+    z1 = LEFT_SHIFT(z1, CONST_BITS);
+    z2 = DEQUANTIZE(inptr[DCTSIZE * 6], quantptr[DCTSIZE * 6]);
+    z2 = LEFT_SHIFT(z2, CONST_BITS);
+
+    tmp12 = z1 - z2;
+
+    tmp21 = z3 + tmp12;
+    tmp24 = z3 - tmp12;
+
+    tmp12 = z4 + z2;
+
+    tmp20 = tmp10 + tmp12;
+    tmp25 = tmp10 - tmp12;
+
+    tmp12 = z4 - z1 - z2;
+
+    tmp22 = tmp11 + tmp12;
+    tmp23 = tmp11 - tmp12;
+
+    /* Odd part */
+
+    z1 = DEQUANTIZE(inptr[DCTSIZE * 1], quantptr[DCTSIZE * 1]);
+    z2 = DEQUANTIZE(inptr[DCTSIZE * 3], quantptr[DCTSIZE * 3]);
+    z3 = DEQUANTIZE(inptr[DCTSIZE * 5], quantptr[DCTSIZE * 5]);
+    z4 = DEQUANTIZE(inptr[DCTSIZE * 7], quantptr[DCTSIZE * 7]);
+
+    tmp11 = MULTIPLY(z2, FIX(1.306562965));                  /* c3 */
+    tmp14 = MULTIPLY(z2, -FIX_0_541196100);                  /* -c9 */
+
+    tmp10 = z1 + z3;
+    tmp15 = MULTIPLY(tmp10 + z4, FIX(0.860918669));          /* c7 */
+    tmp12 = tmp15 + MULTIPLY(tmp10, FIX(0.261052384));       /* c5-c7 */
+    tmp10 = tmp12 + tmp11 + MULTIPLY(z1, FIX(0.280143716));  /* c1-c5 */
+    tmp13 = MULTIPLY(z3 + z4, -FIX(1.045510580));            /* -(c7+c11) */
+    tmp12 += tmp13 + tmp14 - MULTIPLY(z3, FIX(1.478575242)); /* c1+c5-c7-c11 */
+    tmp13 += tmp15 - tmp11 + MULTIPLY(z4, FIX(1.586706681)); /* c1+c11 */
+    tmp15 += tmp14 - MULTIPLY(z1, FIX(0.676326758)) -        /* c7-c11 */
+             MULTIPLY(z4, FIX(1.982889723));                 /* c5+c7 */
+
+    z1 -= z4;
+    z2 -= z3;
+    z3 = MULTIPLY(z1 + z2, FIX_0_541196100);                 /* c9 */
+    tmp11 = z3 + MULTIPLY(z1, FIX_0_765366865);              /* c3-c9 */
+    tmp14 = z3 - MULTIPLY(z2, FIX_1_847759065);              /* c3+c9 */
+
+    /* Final output stage */
+
+    wsptr[8 * 0]  = (int)RIGHT_SHIFT(tmp20 + tmp10, CONST_BITS - PASS1_BITS);
+    wsptr[8 * 11] = (int)RIGHT_SHIFT(tmp20 - tmp10, CONST_BITS - PASS1_BITS);
+    wsptr[8 * 1]  = (int)RIGHT_SHIFT(tmp21 + tmp11, CONST_BITS - PASS1_BITS);
+    wsptr[8 * 10] = (int)RIGHT_SHIFT(tmp21 - tmp11, CONST_BITS - PASS1_BITS);
+    wsptr[8 * 2]  = (int)RIGHT_SHIFT(tmp22 + tmp12, CONST_BITS - PASS1_BITS);
+    wsptr[8 * 9]  = (int)RIGHT_SHIFT(tmp22 - tmp12, CONST_BITS - PASS1_BITS);
+    wsptr[8 * 3]  = (int)RIGHT_SHIFT(tmp23 + tmp13, CONST_BITS - PASS1_BITS);
+    wsptr[8 * 8]  = (int)RIGHT_SHIFT(tmp23 - tmp13, CONST_BITS - PASS1_BITS);
+    wsptr[8 * 4]  = (int)RIGHT_SHIFT(tmp24 + tmp14, CONST_BITS - PASS1_BITS);
+    wsptr[8 * 7]  = (int)RIGHT_SHIFT(tmp24 - tmp14, CONST_BITS - PASS1_BITS);
+    wsptr[8 * 5]  = (int)RIGHT_SHIFT(tmp25 + tmp15, CONST_BITS - PASS1_BITS);
+    wsptr[8 * 6]  = (int)RIGHT_SHIFT(tmp25 - tmp15, CONST_BITS - PASS1_BITS);
+  }
+
+  /* Pass 2: process 12 rows from work array, store into output array. */
+
+  wsptr = workspace;
+  for (ctr = 0; ctr < 12; ctr++) {
+    outptr = output_buf[ctr] + output_col;
+
+    /* Even part */
+
+    /* Add fudge factor here for final descale. */
+    z3 = (JLONG)wsptr[0] + (ONE << (PASS1_BITS + 2));
+    z3 = LEFT_SHIFT(z3, CONST_BITS);
+
+    z4 = (JLONG)wsptr[4];
+    z4 = MULTIPLY(z4, FIX(1.224744871)); /* c4 */
+
+    tmp10 = z3 + z4;
+    tmp11 = z3 - z4;
+
+    z1 = (JLONG)wsptr[2];
+    z4 = MULTIPLY(z1, FIX(1.366025404)); /* c2 */
+    z1 = LEFT_SHIFT(z1, CONST_BITS);
+    z2 = (JLONG)wsptr[6];
+    z2 = LEFT_SHIFT(z2, CONST_BITS);
+
+    tmp12 = z1 - z2;
+
+    tmp21 = z3 + tmp12;
+    tmp24 = z3 - tmp12;
+
+    tmp12 = z4 + z2;
+
+    tmp20 = tmp10 + tmp12;
+    tmp25 = tmp10 - tmp12;
+
+    tmp12 = z4 - z1 - z2;
+
+    tmp22 = tmp11 + tmp12;
+    tmp23 = tmp11 - tmp12;
+
+    /* Odd part */
+
+    z1 = (JLONG)wsptr[1];
+    z2 = (JLONG)wsptr[3];
+    z3 = (JLONG)wsptr[5];
+    z4 = (JLONG)wsptr[7];
+
+    tmp11 = MULTIPLY(z2, FIX(1.306562965));                  /* c3 */
+    tmp14 = MULTIPLY(z2, -FIX_0_541196100);                  /* -c9 */
+
+    tmp10 = z1 + z3;
+    tmp15 = MULTIPLY(tmp10 + z4, FIX(0.860918669));          /* c7 */
+    tmp12 = tmp15 + MULTIPLY(tmp10, FIX(0.261052384));       /* c5-c7 */
+    tmp10 = tmp12 + tmp11 + MULTIPLY(z1, FIX(0.280143716));  /* c1-c5 */
+    tmp13 = MULTIPLY(z3 + z4, -FIX(1.045510580));            /* -(c7+c11) */
+    tmp12 += tmp13 + tmp14 - MULTIPLY(z3, FIX(1.478575242)); /* c1+c5-c7-c11 */
+    tmp13 += tmp15 - tmp11 + MULTIPLY(z4, FIX(1.586706681)); /* c1+c11 */
+    tmp15 += tmp14 - MULTIPLY(z1, FIX(0.676326758)) -        /* c7-c11 */
+             MULTIPLY(z4, FIX(1.982889723));                 /* c5+c7 */
+
+    z1 -= z4;
+    z2 -= z3;
+    z3 = MULTIPLY(z1 + z2, FIX_0_541196100);                 /* c9 */
+    tmp11 = z3 + MULTIPLY(z1, FIX_0_765366865);              /* c3-c9 */
+    tmp14 = z3 - MULTIPLY(z2, FIX_1_847759065);              /* c3+c9 */
+
+    /* Final output stage */
+
+    outptr[0]  = range_limit[(int)RIGHT_SHIFT(tmp20 + tmp10,
+                                              CONST_BITS + PASS1_BITS + 3) &
+                             RANGE_MASK];
+    outptr[11] = range_limit[(int)RIGHT_SHIFT(tmp20 - tmp10,
+                                              CONST_BITS + PASS1_BITS + 3) &
+                             RANGE_MASK];
+    outptr[1]  = range_limit[(int)RIGHT_SHIFT(tmp21 + tmp11,
+                                              CONST_BITS + PASS1_BITS + 3) &
+                             RANGE_MASK];
+    outptr[10] = range_limit[(int)RIGHT_SHIFT(tmp21 - tmp11,
+                                              CONST_BITS + PASS1_BITS + 3) &
+                             RANGE_MASK];
+    outptr[2]  = range_limit[(int)RIGHT_SHIFT(tmp22 + tmp12,
+                                              CONST_BITS + PASS1_BITS + 3) &
+                             RANGE_MASK];
+    outptr[9]  = range_limit[(int)RIGHT_SHIFT(tmp22 - tmp12,
+                                              CONST_BITS + PASS1_BITS + 3) &
+                             RANGE_MASK];
+    outptr[3]  = range_limit[(int)RIGHT_SHIFT(tmp23 + tmp13,
+                                              CONST_BITS + PASS1_BITS + 3) &
+                             RANGE_MASK];
+    outptr[8]  = range_limit[(int)RIGHT_SHIFT(tmp23 - tmp13,
+                                              CONST_BITS + PASS1_BITS + 3) &
+                             RANGE_MASK];
+    outptr[4]  = range_limit[(int)RIGHT_SHIFT(tmp24 + tmp14,
+                                              CONST_BITS + PASS1_BITS + 3) &
+                             RANGE_MASK];
+    outptr[7]  = range_limit[(int)RIGHT_SHIFT(tmp24 - tmp14,
+                                              CONST_BITS + PASS1_BITS + 3) &
+                             RANGE_MASK];
+    outptr[5]  = range_limit[(int)RIGHT_SHIFT(tmp25 + tmp15,
+                                              CONST_BITS + PASS1_BITS + 3) &
+                             RANGE_MASK];
+    outptr[6]  = range_limit[(int)RIGHT_SHIFT(tmp25 - tmp15,
+                                              CONST_BITS + PASS1_BITS + 3) &
+                             RANGE_MASK];
+
+    wsptr += 8;         /* advance pointer to next row */
+  }
+}
+
+
+/*
+ * Perform dequantization and inverse DCT on one block of coefficients,
+ * producing a 13x13 output block.
+ *
+ * Optimized algorithm with 29 multiplications in the 1-D kernel.
+ * cK represents sqrt(2) * cos(K*pi/26).
+ */
+
+GLOBAL(void)
+jpeg_idct_13x13(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+                JCOEFPTR coef_block, JSAMPARRAY output_buf,
+                JDIMENSION output_col)
+{
+  JLONG tmp10, tmp11, tmp12, tmp13, tmp14, tmp15;
+  JLONG tmp20, tmp21, tmp22, tmp23, tmp24, tmp25, tmp26;
+  JLONG z1, z2, z3, z4;
+  JCOEFPTR inptr;
+  ISLOW_MULT_TYPE *quantptr;
+  int *wsptr;
+  JSAMPROW outptr;
+  JSAMPLE *range_limit = IDCT_range_limit(cinfo);
+  int ctr;
+  int workspace[8 * 13];        /* buffers data between passes */
+  SHIFT_TEMPS
+
+  /* Pass 1: process columns from input, store into work array. */
+
+  inptr = coef_block;
+  quantptr = (ISLOW_MULT_TYPE *)compptr->dct_table;
+  wsptr = workspace;
+  for (ctr = 0; ctr < 8; ctr++, inptr++, quantptr++, wsptr++) {
+    /* Even part */
+
+    z1 = DEQUANTIZE(inptr[DCTSIZE * 0], quantptr[DCTSIZE * 0]);
+    z1 = LEFT_SHIFT(z1, CONST_BITS);
+    /* Add fudge factor here for final descale. */
+    z1 += ONE << (CONST_BITS - PASS1_BITS - 1);
+
+    z2 = DEQUANTIZE(inptr[DCTSIZE * 2], quantptr[DCTSIZE * 2]);
+    z3 = DEQUANTIZE(inptr[DCTSIZE * 4], quantptr[DCTSIZE * 4]);
+    z4 = DEQUANTIZE(inptr[DCTSIZE * 6], quantptr[DCTSIZE * 6]);
+
+    tmp10 = z3 + z4;
+    tmp11 = z3 - z4;
+
+    tmp12 = MULTIPLY(tmp10, FIX(1.155388986));                /* (c4+c6)/2 */
+    tmp13 = MULTIPLY(tmp11, FIX(0.096834934)) + z1;           /* (c4-c6)/2 */
+
+    tmp20 = MULTIPLY(z2, FIX(1.373119086)) + tmp12 + tmp13;   /* c2 */
+    tmp22 = MULTIPLY(z2, FIX(0.501487041)) - tmp12 + tmp13;   /* c10 */
+
+    tmp12 = MULTIPLY(tmp10, FIX(0.316450131));                /* (c8-c12)/2 */
+    tmp13 = MULTIPLY(tmp11, FIX(0.486914739)) + z1;           /* (c8+c12)/2 */
+
+    tmp21 = MULTIPLY(z2, FIX(1.058554052)) - tmp12 + tmp13;   /* c6 */
+    tmp25 = MULTIPLY(z2, -FIX(1.252223920)) + tmp12 + tmp13;  /* c4 */
+
+    tmp12 = MULTIPLY(tmp10, FIX(0.435816023));                /* (c2-c10)/2 */
+    tmp13 = MULTIPLY(tmp11, FIX(0.937303064)) - z1;           /* (c2+c10)/2 */
+
+    tmp23 = MULTIPLY(z2, -FIX(0.170464608)) - tmp12 - tmp13;  /* c12 */
+    tmp24 = MULTIPLY(z2, -FIX(0.803364869)) + tmp12 - tmp13;  /* c8 */
+
+    tmp26 = MULTIPLY(tmp11 - z2, FIX(1.414213562)) + z1;      /* c0 */
+
+    /* Odd part */
+
+    z1 = DEQUANTIZE(inptr[DCTSIZE * 1], quantptr[DCTSIZE * 1]);
+    z2 = DEQUANTIZE(inptr[DCTSIZE * 3], quantptr[DCTSIZE * 3]);
+    z3 = DEQUANTIZE(inptr[DCTSIZE * 5], quantptr[DCTSIZE * 5]);
+    z4 = DEQUANTIZE(inptr[DCTSIZE * 7], quantptr[DCTSIZE * 7]);
+
+    tmp11 = MULTIPLY(z1 + z2, FIX(1.322312651));     /* c3 */
+    tmp12 = MULTIPLY(z1 + z3, FIX(1.163874945));     /* c5 */
+    tmp15 = z1 + z4;
+    tmp13 = MULTIPLY(tmp15, FIX(0.937797057));       /* c7 */
+    tmp10 = tmp11 + tmp12 + tmp13 -
+            MULTIPLY(z1, FIX(2.020082300));          /* c7+c5+c3-c1 */
+    tmp14 = MULTIPLY(z2 + z3, -FIX(0.338443458));    /* -c11 */
+    tmp11 += tmp14 + MULTIPLY(z2, FIX(0.837223564)); /* c5+c9+c11-c3 */
+    tmp12 += tmp14 - MULTIPLY(z3, FIX(1.572116027)); /* c1+c5-c9-c11 */
+    tmp14 = MULTIPLY(z2 + z4, -FIX(1.163874945));    /* -c5 */
+    tmp11 += tmp14;
+    tmp13 += tmp14 + MULTIPLY(z4, FIX(2.205608352)); /* c3+c5+c9-c7 */
+    tmp14 = MULTIPLY(z3 + z4, -FIX(0.657217813));    /* -c9 */
+    tmp12 += tmp14;
+    tmp13 += tmp14;
+    tmp15 = MULTIPLY(tmp15, FIX(0.338443458));       /* c11 */
+    tmp14 = tmp15 + MULTIPLY(z1, FIX(0.318774355)) - /* c9-c11 */
+            MULTIPLY(z2, FIX(0.466105296));          /* c1-c7 */
+    z1    = MULTIPLY(z3 - z2, FIX(0.937797057));     /* c7 */
+    tmp14 += z1;
+    tmp15 += z1 + MULTIPLY(z3, FIX(0.384515595)) -   /* c3-c7 */
+             MULTIPLY(z4, FIX(1.742345811));         /* c1+c11 */
+
+    /* Final output stage */
+
+    wsptr[8 * 0]  = (int)RIGHT_SHIFT(tmp20 + tmp10, CONST_BITS - PASS1_BITS);
+    wsptr[8 * 12] = (int)RIGHT_SHIFT(tmp20 - tmp10, CONST_BITS - PASS1_BITS);
+    wsptr[8 * 1]  = (int)RIGHT_SHIFT(tmp21 + tmp11, CONST_BITS - PASS1_BITS);
+    wsptr[8 * 11] = (int)RIGHT_SHIFT(tmp21 - tmp11, CONST_BITS - PASS1_BITS);
+    wsptr[8 * 2]  = (int)RIGHT_SHIFT(tmp22 + tmp12, CONST_BITS - PASS1_BITS);
+    wsptr[8 * 10] = (int)RIGHT_SHIFT(tmp22 - tmp12, CONST_BITS - PASS1_BITS);
+    wsptr[8 * 3]  = (int)RIGHT_SHIFT(tmp23 + tmp13, CONST_BITS - PASS1_BITS);
+    wsptr[8 * 9]  = (int)RIGHT_SHIFT(tmp23 - tmp13, CONST_BITS - PASS1_BITS);
+    wsptr[8 * 4]  = (int)RIGHT_SHIFT(tmp24 + tmp14, CONST_BITS - PASS1_BITS);
+    wsptr[8 * 8]  = (int)RIGHT_SHIFT(tmp24 - tmp14, CONST_BITS - PASS1_BITS);
+    wsptr[8 * 5]  = (int)RIGHT_SHIFT(tmp25 + tmp15, CONST_BITS - PASS1_BITS);
+    wsptr[8 * 7]  = (int)RIGHT_SHIFT(tmp25 - tmp15, CONST_BITS - PASS1_BITS);
+    wsptr[8 * 6]  = (int)RIGHT_SHIFT(tmp26, CONST_BITS - PASS1_BITS);
+  }
+
+  /* Pass 2: process 13 rows from work array, store into output array. */
+
+  wsptr = workspace;
+  for (ctr = 0; ctr < 13; ctr++) {
+    outptr = output_buf[ctr] + output_col;
+
+    /* Even part */
+
+    /* Add fudge factor here for final descale. */
+    z1 = (JLONG)wsptr[0] + (ONE << (PASS1_BITS + 2));
+    z1 = LEFT_SHIFT(z1, CONST_BITS);
+
+    z2 = (JLONG)wsptr[2];
+    z3 = (JLONG)wsptr[4];
+    z4 = (JLONG)wsptr[6];
+
+    tmp10 = z3 + z4;
+    tmp11 = z3 - z4;
+
+    tmp12 = MULTIPLY(tmp10, FIX(1.155388986));                /* (c4+c6)/2 */
+    tmp13 = MULTIPLY(tmp11, FIX(0.096834934)) + z1;           /* (c4-c6)/2 */
+
+    tmp20 = MULTIPLY(z2, FIX(1.373119086)) + tmp12 + tmp13;   /* c2 */
+    tmp22 = MULTIPLY(z2, FIX(0.501487041)) - tmp12 + tmp13;   /* c10 */
+
+    tmp12 = MULTIPLY(tmp10, FIX(0.316450131));                /* (c8-c12)/2 */
+    tmp13 = MULTIPLY(tmp11, FIX(0.486914739)) + z1;           /* (c8+c12)/2 */
+
+    tmp21 = MULTIPLY(z2, FIX(1.058554052)) - tmp12 + tmp13;   /* c6 */
+    tmp25 = MULTIPLY(z2, -FIX(1.252223920)) + tmp12 + tmp13;  /* c4 */
+
+    tmp12 = MULTIPLY(tmp10, FIX(0.435816023));                /* (c2-c10)/2 */
+    tmp13 = MULTIPLY(tmp11, FIX(0.937303064)) - z1;           /* (c2+c10)/2 */
+
+    tmp23 = MULTIPLY(z2, -FIX(0.170464608)) - tmp12 - tmp13;  /* c12 */
+    tmp24 = MULTIPLY(z2, -FIX(0.803364869)) + tmp12 - tmp13;  /* c8 */
+
+    tmp26 = MULTIPLY(tmp11 - z2, FIX(1.414213562)) + z1;      /* c0 */
+
+    /* Odd part */
+
+    z1 = (JLONG)wsptr[1];
+    z2 = (JLONG)wsptr[3];
+    z3 = (JLONG)wsptr[5];
+    z4 = (JLONG)wsptr[7];
+
+    tmp11 = MULTIPLY(z1 + z2, FIX(1.322312651));     /* c3 */
+    tmp12 = MULTIPLY(z1 + z3, FIX(1.163874945));     /* c5 */
+    tmp15 = z1 + z4;
+    tmp13 = MULTIPLY(tmp15, FIX(0.937797057));       /* c7 */
+    tmp10 = tmp11 + tmp12 + tmp13 -
+            MULTIPLY(z1, FIX(2.020082300));          /* c7+c5+c3-c1 */
+    tmp14 = MULTIPLY(z2 + z3, -FIX(0.338443458));    /* -c11 */
+    tmp11 += tmp14 + MULTIPLY(z2, FIX(0.837223564)); /* c5+c9+c11-c3 */
+    tmp12 += tmp14 - MULTIPLY(z3, FIX(1.572116027)); /* c1+c5-c9-c11 */
+    tmp14 = MULTIPLY(z2 + z4, -FIX(1.163874945));    /* -c5 */
+    tmp11 += tmp14;
+    tmp13 += tmp14 + MULTIPLY(z4, FIX(2.205608352)); /* c3+c5+c9-c7 */
+    tmp14 = MULTIPLY(z3 + z4, -FIX(0.657217813));    /* -c9 */
+    tmp12 += tmp14;
+    tmp13 += tmp14;
+    tmp15 = MULTIPLY(tmp15, FIX(0.338443458));       /* c11 */
+    tmp14 = tmp15 + MULTIPLY(z1, FIX(0.318774355)) - /* c9-c11 */
+            MULTIPLY(z2, FIX(0.466105296));          /* c1-c7 */
+    z1    = MULTIPLY(z3 - z2, FIX(0.937797057));     /* c7 */
+    tmp14 += z1;
+    tmp15 += z1 + MULTIPLY(z3, FIX(0.384515595)) -   /* c3-c7 */
+             MULTIPLY(z4, FIX(1.742345811));         /* c1+c11 */
+
+    /* Final output stage */
+
+    outptr[0]  = range_limit[(int)RIGHT_SHIFT(tmp20 + tmp10,
+                                              CONST_BITS + PASS1_BITS + 3) &
+                             RANGE_MASK];
+    outptr[12] = range_limit[(int)RIGHT_SHIFT(tmp20 - tmp10,
+                                              CONST_BITS + PASS1_BITS + 3) &
+                             RANGE_MASK];
+    outptr[1]  = range_limit[(int)RIGHT_SHIFT(tmp21 + tmp11,
+                                              CONST_BITS + PASS1_BITS + 3) &
+                             RANGE_MASK];
+    outptr[11] = range_limit[(int)RIGHT_SHIFT(tmp21 - tmp11,
+                                              CONST_BITS + PASS1_BITS + 3) &
+                             RANGE_MASK];
+    outptr[2]  = range_limit[(int)RIGHT_SHIFT(tmp22 + tmp12,
+                                              CONST_BITS + PASS1_BITS + 3) &
+                             RANGE_MASK];
+    outptr[10] = range_limit[(int)RIGHT_SHIFT(tmp22 - tmp12,
+                                              CONST_BITS + PASS1_BITS + 3) &
+                             RANGE_MASK];
+    outptr[3]  = range_limit[(int)RIGHT_SHIFT(tmp23 + tmp13,
+                                              CONST_BITS + PASS1_BITS + 3) &
+                             RANGE_MASK];
+    outptr[9]  = range_limit[(int)RIGHT_SHIFT(tmp23 - tmp13,
+                                              CONST_BITS + PASS1_BITS + 3) &
+                             RANGE_MASK];
+    outptr[4]  = range_limit[(int)RIGHT_SHIFT(tmp24 + tmp14,
+                                              CONST_BITS + PASS1_BITS + 3) &
+                             RANGE_MASK];
+    outptr[8]  = range_limit[(int)RIGHT_SHIFT(tmp24 - tmp14,
+                                              CONST_BITS + PASS1_BITS + 3) &
+                             RANGE_MASK];
+    outptr[5]  = range_limit[(int)RIGHT_SHIFT(tmp25 + tmp15,
+                                              CONST_BITS + PASS1_BITS + 3) &
+                             RANGE_MASK];
+    outptr[7]  = range_limit[(int)RIGHT_SHIFT(tmp25 - tmp15,
+                                              CONST_BITS + PASS1_BITS + 3) &
+                             RANGE_MASK];
+    outptr[6]  = range_limit[(int)RIGHT_SHIFT(tmp26,
+                                              CONST_BITS + PASS1_BITS + 3) &
+                             RANGE_MASK];
+
+    wsptr += 8;         /* advance pointer to next row */
+  }
+}
+
+
+/*
+ * Perform dequantization and inverse DCT on one block of coefficients,
+ * producing a 14x14 output block.
+ *
+ * Optimized algorithm with 20 multiplications in the 1-D kernel.
+ * cK represents sqrt(2) * cos(K*pi/28).
+ */
+
+GLOBAL(void)
+jpeg_idct_14x14(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+                JCOEFPTR coef_block, JSAMPARRAY output_buf,
+                JDIMENSION output_col)
+{
+  JLONG tmp10, tmp11, tmp12, tmp13, tmp14, tmp15, tmp16;
+  JLONG tmp20, tmp21, tmp22, tmp23, tmp24, tmp25, tmp26;
+  JLONG z1, z2, z3, z4;
+  JCOEFPTR inptr;
+  ISLOW_MULT_TYPE *quantptr;
+  int *wsptr;
+  JSAMPROW outptr;
+  JSAMPLE *range_limit = IDCT_range_limit(cinfo);
+  int ctr;
+  int workspace[8 * 14];        /* buffers data between passes */
+  SHIFT_TEMPS
+
+  /* Pass 1: process columns from input, store into work array. */
+
+  inptr = coef_block;
+  quantptr = (ISLOW_MULT_TYPE *)compptr->dct_table;
+  wsptr = workspace;
+  for (ctr = 0; ctr < 8; ctr++, inptr++, quantptr++, wsptr++) {
+    /* Even part */
+
+    z1 = DEQUANTIZE(inptr[DCTSIZE * 0], quantptr[DCTSIZE * 0]);
+    z1 = LEFT_SHIFT(z1, CONST_BITS);
+    /* Add fudge factor here for final descale. */
+    z1 += ONE << (CONST_BITS - PASS1_BITS - 1);
+    z4 = DEQUANTIZE(inptr[DCTSIZE * 4], quantptr[DCTSIZE * 4]);
+    z2 = MULTIPLY(z4, FIX(1.274162392));         /* c4 */
+    z3 = MULTIPLY(z4, FIX(0.314692123));         /* c12 */
+    z4 = MULTIPLY(z4, FIX(0.881747734));         /* c8 */
+
+    tmp10 = z1 + z2;
+    tmp11 = z1 + z3;
+    tmp12 = z1 - z4;
+
+    tmp23 = RIGHT_SHIFT(z1 - LEFT_SHIFT(z2 + z3 - z4, 1),
+                        CONST_BITS - PASS1_BITS); /* c0 = (c4+c12-c8)*2 */
+
+    z1 = DEQUANTIZE(inptr[DCTSIZE * 2], quantptr[DCTSIZE * 2]);
+    z2 = DEQUANTIZE(inptr[DCTSIZE * 6], quantptr[DCTSIZE * 6]);
+
+    z3 = MULTIPLY(z1 + z2, FIX(1.105676686));    /* c6 */
+
+    tmp13 = z3 + MULTIPLY(z1, FIX(0.273079590)); /* c2-c6 */
+    tmp14 = z3 - MULTIPLY(z2, FIX(1.719280954)); /* c6+c10 */
+    tmp15 = MULTIPLY(z1, FIX(0.613604268)) -     /* c10 */
+            MULTIPLY(z2, FIX(1.378756276));      /* c2 */
+
+    tmp20 = tmp10 + tmp13;
+    tmp26 = tmp10 - tmp13;
+    tmp21 = tmp11 + tmp14;
+    tmp25 = tmp11 - tmp14;
+    tmp22 = tmp12 + tmp15;
+    tmp24 = tmp12 - tmp15;
+
+    /* Odd part */
+
+    z1 = DEQUANTIZE(inptr[DCTSIZE * 1], quantptr[DCTSIZE * 1]);
+    z2 = DEQUANTIZE(inptr[DCTSIZE * 3], quantptr[DCTSIZE * 3]);
+    z3 = DEQUANTIZE(inptr[DCTSIZE * 5], quantptr[DCTSIZE * 5]);
+    z4 = DEQUANTIZE(inptr[DCTSIZE * 7], quantptr[DCTSIZE * 7]);
+    tmp13 = LEFT_SHIFT(z4, CONST_BITS);
+
+    tmp14 = z1 + z3;
+    tmp11 = MULTIPLY(z1 + z2, FIX(1.334852607));           /* c3 */
+    tmp12 = MULTIPLY(tmp14, FIX(1.197448846));             /* c5 */
+    tmp10 = tmp11 + tmp12 + tmp13 - MULTIPLY(z1, FIX(1.126980169)); /* c3+c5-c1 */
+    tmp14 = MULTIPLY(tmp14, FIX(0.752406978));             /* c9 */
+    tmp16 = tmp14 - MULTIPLY(z1, FIX(1.061150426));        /* c9+c11-c13 */
+    z1    -= z2;
+    tmp15 = MULTIPLY(z1, FIX(0.467085129)) - tmp13;        /* c11 */
+    tmp16 += tmp15;
+    z1    += z4;
+    z4    = MULTIPLY(z2 + z3, -FIX(0.158341681)) - tmp13;  /* -c13 */
+    tmp11 += z4 - MULTIPLY(z2, FIX(0.424103948));          /* c3-c9-c13 */
+    tmp12 += z4 - MULTIPLY(z3, FIX(2.373959773));          /* c3+c5-c13 */
+    z4    = MULTIPLY(z3 - z2, FIX(1.405321284));           /* c1 */
+    tmp14 += z4 + tmp13 - MULTIPLY(z3, FIX(1.6906431334)); /* c1+c9-c11 */
+    tmp15 += z4 + MULTIPLY(z2, FIX(0.674957567));          /* c1+c11-c5 */
+
+    tmp13 = LEFT_SHIFT(z1 - z3, PASS1_BITS);
+
+    /* Final output stage */
+
+    wsptr[8 * 0]  = (int)RIGHT_SHIFT(tmp20 + tmp10, CONST_BITS - PASS1_BITS);
+    wsptr[8 * 13] = (int)RIGHT_SHIFT(tmp20 - tmp10, CONST_BITS - PASS1_BITS);
+    wsptr[8 * 1]  = (int)RIGHT_SHIFT(tmp21 + tmp11, CONST_BITS - PASS1_BITS);
+    wsptr[8 * 12] = (int)RIGHT_SHIFT(tmp21 - tmp11, CONST_BITS - PASS1_BITS);
+    wsptr[8 * 2]  = (int)RIGHT_SHIFT(tmp22 + tmp12, CONST_BITS - PASS1_BITS);
+    wsptr[8 * 11] = (int)RIGHT_SHIFT(tmp22 - tmp12, CONST_BITS - PASS1_BITS);
+    wsptr[8 * 3]  = (int)(tmp23 + tmp13);
+    wsptr[8 * 10] = (int)(tmp23 - tmp13);
+    wsptr[8 * 4]  = (int)RIGHT_SHIFT(tmp24 + tmp14, CONST_BITS - PASS1_BITS);
+    wsptr[8 * 9]  = (int)RIGHT_SHIFT(tmp24 - tmp14, CONST_BITS - PASS1_BITS);
+    wsptr[8 * 5]  = (int)RIGHT_SHIFT(tmp25 + tmp15, CONST_BITS - PASS1_BITS);
+    wsptr[8 * 8]  = (int)RIGHT_SHIFT(tmp25 - tmp15, CONST_BITS - PASS1_BITS);
+    wsptr[8 * 6]  = (int)RIGHT_SHIFT(tmp26 + tmp16, CONST_BITS - PASS1_BITS);
+    wsptr[8 * 7]  = (int)RIGHT_SHIFT(tmp26 - tmp16, CONST_BITS - PASS1_BITS);
+  }
+
+  /* Pass 2: process 14 rows from work array, store into output array. */
+
+  wsptr = workspace;
+  for (ctr = 0; ctr < 14; ctr++) {
+    outptr = output_buf[ctr] + output_col;
+
+    /* Even part */
+
+    /* Add fudge factor here for final descale. */
+    z1 = (JLONG)wsptr[0] + (ONE << (PASS1_BITS + 2));
+    z1 = LEFT_SHIFT(z1, CONST_BITS);
+    z4 = (JLONG)wsptr[4];
+    z2 = MULTIPLY(z4, FIX(1.274162392));         /* c4 */
+    z3 = MULTIPLY(z4, FIX(0.314692123));         /* c12 */
+    z4 = MULTIPLY(z4, FIX(0.881747734));         /* c8 */
+
+    tmp10 = z1 + z2;
+    tmp11 = z1 + z3;
+    tmp12 = z1 - z4;
+
+    tmp23 = z1 - LEFT_SHIFT(z2 + z3 - z4, 1);    /* c0 = (c4+c12-c8)*2 */
+
+    z1 = (JLONG)wsptr[2];
+    z2 = (JLONG)wsptr[6];
+
+    z3 = MULTIPLY(z1 + z2, FIX(1.105676686));    /* c6 */
+
+    tmp13 = z3 + MULTIPLY(z1, FIX(0.273079590)); /* c2-c6 */
+    tmp14 = z3 - MULTIPLY(z2, FIX(1.719280954)); /* c6+c10 */
+    tmp15 = MULTIPLY(z1, FIX(0.613604268)) -     /* c10 */
+            MULTIPLY(z2, FIX(1.378756276));      /* c2 */
+
+    tmp20 = tmp10 + tmp13;
+    tmp26 = tmp10 - tmp13;
+    tmp21 = tmp11 + tmp14;
+    tmp25 = tmp11 - tmp14;
+    tmp22 = tmp12 + tmp15;
+    tmp24 = tmp12 - tmp15;
+
+    /* Odd part */
+
+    z1 = (JLONG)wsptr[1];
+    z2 = (JLONG)wsptr[3];
+    z3 = (JLONG)wsptr[5];
+    z4 = (JLONG)wsptr[7];
+    z4 = LEFT_SHIFT(z4, CONST_BITS);
+
+    tmp14 = z1 + z3;
+    tmp11 = MULTIPLY(z1 + z2, FIX(1.334852607));           /* c3 */
+    tmp12 = MULTIPLY(tmp14, FIX(1.197448846));             /* c5 */
+    tmp10 = tmp11 + tmp12 + z4 - MULTIPLY(z1, FIX(1.126980169)); /* c3+c5-c1 */
+    tmp14 = MULTIPLY(tmp14, FIX(0.752406978));             /* c9 */
+    tmp16 = tmp14 - MULTIPLY(z1, FIX(1.061150426));        /* c9+c11-c13 */
+    z1    -= z2;
+    tmp15 = MULTIPLY(z1, FIX(0.467085129)) - z4;           /* c11 */
+    tmp16 += tmp15;
+    tmp13 = MULTIPLY(z2 + z3, -FIX(0.158341681)) - z4;     /* -c13 */
+    tmp11 += tmp13 - MULTIPLY(z2, FIX(0.424103948));       /* c3-c9-c13 */
+    tmp12 += tmp13 - MULTIPLY(z3, FIX(2.373959773));       /* c3+c5-c13 */
+    tmp13 = MULTIPLY(z3 - z2, FIX(1.405321284));           /* c1 */
+    tmp14 += tmp13 + z4 - MULTIPLY(z3, FIX(1.6906431334)); /* c1+c9-c11 */
+    tmp15 += tmp13 + MULTIPLY(z2, FIX(0.674957567));       /* c1+c11-c5 */
+
+    tmp13 = LEFT_SHIFT(z1 - z3, CONST_BITS) + z4;
+
+    /* Final output stage */
+
+    outptr[0]  = range_limit[(int)RIGHT_SHIFT(tmp20 + tmp10,
+                                              CONST_BITS + PASS1_BITS + 3) &
+                             RANGE_MASK];
+    outptr[13] = range_limit[(int)RIGHT_SHIFT(tmp20 - tmp10,
+                                              CONST_BITS + PASS1_BITS + 3) &
+                             RANGE_MASK];
+    outptr[1]  = range_limit[(int)RIGHT_SHIFT(tmp21 + tmp11,
+                                              CONST_BITS + PASS1_BITS + 3) &
+                             RANGE_MASK];
+    outptr[12] = range_limit[(int)RIGHT_SHIFT(tmp21 - tmp11,
+                                              CONST_BITS + PASS1_BITS + 3) &
+                             RANGE_MASK];
+    outptr[2]  = range_limit[(int)RIGHT_SHIFT(tmp22 + tmp12,
+                                              CONST_BITS + PASS1_BITS + 3) &
+                             RANGE_MASK];
+    outptr[11] = range_limit[(int)RIGHT_SHIFT(tmp22 - tmp12,
+                                              CONST_BITS + PASS1_BITS + 3) &
+                             RANGE_MASK];
+    outptr[3]  = range_limit[(int)RIGHT_SHIFT(tmp23 + tmp13,
+                                              CONST_BITS + PASS1_BITS + 3) &
+                             RANGE_MASK];
+    outptr[10] = range_limit[(int)RIGHT_SHIFT(tmp23 - tmp13,
+                                              CONST_BITS + PASS1_BITS + 3) &
+                             RANGE_MASK];
+    outptr[4]  = range_limit[(int)RIGHT_SHIFT(tmp24 + tmp14,
+                                              CONST_BITS + PASS1_BITS + 3) &
+                             RANGE_MASK];
+    outptr[9]  = range_limit[(int)RIGHT_SHIFT(tmp24 - tmp14,
+                                              CONST_BITS + PASS1_BITS + 3) &
+                             RANGE_MASK];
+    outptr[5]  = range_limit[(int)RIGHT_SHIFT(tmp25 + tmp15,
+                                              CONST_BITS + PASS1_BITS + 3) &
+                             RANGE_MASK];
+    outptr[8]  = range_limit[(int)RIGHT_SHIFT(tmp25 - tmp15,
+                                              CONST_BITS + PASS1_BITS + 3) &
+                             RANGE_MASK];
+    outptr[6]  = range_limit[(int)RIGHT_SHIFT(tmp26 + tmp16,
+                                              CONST_BITS + PASS1_BITS + 3) &
+                             RANGE_MASK];
+    outptr[7]  = range_limit[(int)RIGHT_SHIFT(tmp26 - tmp16,
+                                              CONST_BITS + PASS1_BITS + 3) &
+                             RANGE_MASK];
+
+    wsptr += 8;         /* advance pointer to next row */
+  }
+}
+
+
+/*
+ * Perform dequantization and inverse DCT on one block of coefficients,
+ * producing a 15x15 output block.
+ *
+ * Optimized algorithm with 22 multiplications in the 1-D kernel.
+ * cK represents sqrt(2) * cos(K*pi/30).
+ */
+
+GLOBAL(void)
+jpeg_idct_15x15(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+                JCOEFPTR coef_block, JSAMPARRAY output_buf,
+                JDIMENSION output_col)
+{
+  JLONG tmp10, tmp11, tmp12, tmp13, tmp14, tmp15, tmp16;
+  JLONG tmp20, tmp21, tmp22, tmp23, tmp24, tmp25, tmp26, tmp27;
+  JLONG z1, z2, z3, z4;
+  JCOEFPTR inptr;
+  ISLOW_MULT_TYPE *quantptr;
+  int *wsptr;
+  JSAMPROW outptr;
+  JSAMPLE *range_limit = IDCT_range_limit(cinfo);
+  int ctr;
+  int workspace[8 * 15];        /* buffers data between passes */
+  SHIFT_TEMPS
+
+  /* Pass 1: process columns from input, store into work array. */
+
+  inptr = coef_block;
+  quantptr = (ISLOW_MULT_TYPE *)compptr->dct_table;
+  wsptr = workspace;
+  for (ctr = 0; ctr < 8; ctr++, inptr++, quantptr++, wsptr++) {
+    /* Even part */
+
+    z1 = DEQUANTIZE(inptr[DCTSIZE * 0], quantptr[DCTSIZE * 0]);
+    z1 = LEFT_SHIFT(z1, CONST_BITS);
+    /* Add fudge factor here for final descale. */
+    z1 += ONE << (CONST_BITS - PASS1_BITS - 1);
+
+    z2 = DEQUANTIZE(inptr[DCTSIZE * 2], quantptr[DCTSIZE * 2]);
+    z3 = DEQUANTIZE(inptr[DCTSIZE * 4], quantptr[DCTSIZE * 4]);
+    z4 = DEQUANTIZE(inptr[DCTSIZE * 6], quantptr[DCTSIZE * 6]);
+
+    tmp10 = MULTIPLY(z4, FIX(0.437016024)); /* c12 */
+    tmp11 = MULTIPLY(z4, FIX(1.144122806)); /* c6 */
+
+    tmp12 = z1 - tmp10;
+    tmp13 = z1 + tmp11;
+    z1 -= LEFT_SHIFT(tmp11 - tmp10, 1);     /* c0 = (c6-c12)*2 */
+
+    z4 = z2 - z3;
+    z3 += z2;
+    tmp10 = MULTIPLY(z3, FIX(1.337628990)); /* (c2+c4)/2 */
+    tmp11 = MULTIPLY(z4, FIX(0.045680613)); /* (c2-c4)/2 */
+    z2 = MULTIPLY(z2, FIX(1.439773946));    /* c4+c14 */
+
+    tmp20 = tmp13 + tmp10 + tmp11;
+    tmp23 = tmp12 - tmp10 + tmp11 + z2;
+
+    tmp10 = MULTIPLY(z3, FIX(0.547059574)); /* (c8+c14)/2 */
+    tmp11 = MULTIPLY(z4, FIX(0.399234004)); /* (c8-c14)/2 */
+
+    tmp25 = tmp13 - tmp10 - tmp11;
+    tmp26 = tmp12 + tmp10 - tmp11 - z2;
+
+    tmp10 = MULTIPLY(z3, FIX(0.790569415)); /* (c6+c12)/2 */
+    tmp11 = MULTIPLY(z4, FIX(0.353553391)); /* (c6-c12)/2 */
+
+    tmp21 = tmp12 + tmp10 + tmp11;
+    tmp24 = tmp13 - tmp10 + tmp11;
+    tmp11 += tmp11;
+    tmp22 = z1 + tmp11;                     /* c10 = c6-c12 */
+    tmp27 = z1 - tmp11 - tmp11;             /* c0 = (c6-c12)*2 */
+
+    /* Odd part */
+
+    z1 = DEQUANTIZE(inptr[DCTSIZE * 1], quantptr[DCTSIZE * 1]);
+    z2 = DEQUANTIZE(inptr[DCTSIZE * 3], quantptr[DCTSIZE * 3]);
+    z4 = DEQUANTIZE(inptr[DCTSIZE * 5], quantptr[DCTSIZE * 5]);
+    z3 = MULTIPLY(z4, FIX(1.224744871));                    /* c5 */
+    z4 = DEQUANTIZE(inptr[DCTSIZE * 7], quantptr[DCTSIZE * 7]);
+
+    tmp13 = z2 - z4;
+    tmp15 = MULTIPLY(z1 + tmp13, FIX(0.831253876));         /* c9 */
+    tmp11 = tmp15 + MULTIPLY(z1, FIX(0.513743148));         /* c3-c9 */
+    tmp14 = tmp15 - MULTIPLY(tmp13, FIX(2.176250899));      /* c3+c9 */
+
+    tmp13 = MULTIPLY(z2, -FIX(0.831253876));                /* -c9 */
+    tmp15 = MULTIPLY(z2, -FIX(1.344997024));                /* -c3 */
+    z2 = z1 - z4;
+    tmp12 = z3 + MULTIPLY(z2, FIX(1.406466353));            /* c1 */
+
+    tmp10 = tmp12 + MULTIPLY(z4, FIX(2.457431844)) - tmp15; /* c1+c7 */
+    tmp16 = tmp12 - MULTIPLY(z1, FIX(1.112434820)) + tmp13; /* c1-c13 */
+    tmp12 = MULTIPLY(z2, FIX(1.224744871)) - z3;            /* c5 */
+    z2 = MULTIPLY(z1 + z4, FIX(0.575212477));               /* c11 */
+    tmp13 += z2 + MULTIPLY(z1, FIX(0.475753014)) - z3;      /* c7-c11 */
+    tmp15 += z2 - MULTIPLY(z4, FIX(0.869244010)) + z3;      /* c11+c13 */
+
+    /* Final output stage */
+
+    wsptr[8 * 0]  = (int)RIGHT_SHIFT(tmp20 + tmp10, CONST_BITS - PASS1_BITS);
+    wsptr[8 * 14] = (int)RIGHT_SHIFT(tmp20 - tmp10, CONST_BITS - PASS1_BITS);
+    wsptr[8 * 1]  = (int)RIGHT_SHIFT(tmp21 + tmp11, CONST_BITS - PASS1_BITS);
+    wsptr[8 * 13] = (int)RIGHT_SHIFT(tmp21 - tmp11, CONST_BITS - PASS1_BITS);
+    wsptr[8 * 2]  = (int)RIGHT_SHIFT(tmp22 + tmp12, CONST_BITS - PASS1_BITS);
+    wsptr[8 * 12] = (int)RIGHT_SHIFT(tmp22 - tmp12, CONST_BITS - PASS1_BITS);
+    wsptr[8 * 3]  = (int)RIGHT_SHIFT(tmp23 + tmp13, CONST_BITS - PASS1_BITS);
+    wsptr[8 * 11] = (int)RIGHT_SHIFT(tmp23 - tmp13, CONST_BITS - PASS1_BITS);
+    wsptr[8 * 4]  = (int)RIGHT_SHIFT(tmp24 + tmp14, CONST_BITS - PASS1_BITS);
+    wsptr[8 * 10] = (int)RIGHT_SHIFT(tmp24 - tmp14, CONST_BITS - PASS1_BITS);
+    wsptr[8 * 5]  = (int)RIGHT_SHIFT(tmp25 + tmp15, CONST_BITS - PASS1_BITS);
+    wsptr[8 * 9]  = (int)RIGHT_SHIFT(tmp25 - tmp15, CONST_BITS - PASS1_BITS);
+    wsptr[8 * 6]  = (int)RIGHT_SHIFT(tmp26 + tmp16, CONST_BITS - PASS1_BITS);
+    wsptr[8 * 8]  = (int)RIGHT_SHIFT(tmp26 - tmp16, CONST_BITS - PASS1_BITS);
+    wsptr[8 * 7]  = (int)RIGHT_SHIFT(tmp27, CONST_BITS - PASS1_BITS);
+  }
+
+  /* Pass 2: process 15 rows from work array, store into output array. */
+
+  wsptr = workspace;
+  for (ctr = 0; ctr < 15; ctr++) {
+    outptr = output_buf[ctr] + output_col;
+
+    /* Even part */
+
+    /* Add fudge factor here for final descale. */
+    z1 = (JLONG)wsptr[0] + (ONE << (PASS1_BITS + 2));
+    z1 = LEFT_SHIFT(z1, CONST_BITS);
+
+    z2 = (JLONG)wsptr[2];
+    z3 = (JLONG)wsptr[4];
+    z4 = (JLONG)wsptr[6];
+
+    tmp10 = MULTIPLY(z4, FIX(0.437016024)); /* c12 */
+    tmp11 = MULTIPLY(z4, FIX(1.144122806)); /* c6 */
+
+    tmp12 = z1 - tmp10;
+    tmp13 = z1 + tmp11;
+    z1 -= LEFT_SHIFT(tmp11 - tmp10, 1);     /* c0 = (c6-c12)*2 */
+
+    z4 = z2 - z3;
+    z3 += z2;
+    tmp10 = MULTIPLY(z3, FIX(1.337628990)); /* (c2+c4)/2 */
+    tmp11 = MULTIPLY(z4, FIX(0.045680613)); /* (c2-c4)/2 */
+    z2 = MULTIPLY(z2, FIX(1.439773946));    /* c4+c14 */
+
+    tmp20 = tmp13 + tmp10 + tmp11;
+    tmp23 = tmp12 - tmp10 + tmp11 + z2;
+
+    tmp10 = MULTIPLY(z3, FIX(0.547059574)); /* (c8+c14)/2 */
+    tmp11 = MULTIPLY(z4, FIX(0.399234004)); /* (c8-c14)/2 */
+
+    tmp25 = tmp13 - tmp10 - tmp11;
+    tmp26 = tmp12 + tmp10 - tmp11 - z2;
+
+    tmp10 = MULTIPLY(z3, FIX(0.790569415)); /* (c6+c12)/2 */
+    tmp11 = MULTIPLY(z4, FIX(0.353553391)); /* (c6-c12)/2 */
+
+    tmp21 = tmp12 + tmp10 + tmp11;
+    tmp24 = tmp13 - tmp10 + tmp11;
+    tmp11 += tmp11;
+    tmp22 = z1 + tmp11;                     /* c10 = c6-c12 */
+    tmp27 = z1 - tmp11 - tmp11;             /* c0 = (c6-c12)*2 */
+
+    /* Odd part */
+
+    z1 = (JLONG)wsptr[1];
+    z2 = (JLONG)wsptr[3];
+    z4 = (JLONG)wsptr[5];
+    z3 = MULTIPLY(z4, FIX(1.224744871));                    /* c5 */
+    z4 = (JLONG)wsptr[7];
+
+    tmp13 = z2 - z4;
+    tmp15 = MULTIPLY(z1 + tmp13, FIX(0.831253876));         /* c9 */
+    tmp11 = tmp15 + MULTIPLY(z1, FIX(0.513743148));         /* c3-c9 */
+    tmp14 = tmp15 - MULTIPLY(tmp13, FIX(2.176250899));      /* c3+c9 */
+
+    tmp13 = MULTIPLY(z2, -FIX(0.831253876));                /* -c9 */
+    tmp15 = MULTIPLY(z2, -FIX(1.344997024));                /* -c3 */
+    z2 = z1 - z4;
+    tmp12 = z3 + MULTIPLY(z2, FIX(1.406466353));            /* c1 */
+
+    tmp10 = tmp12 + MULTIPLY(z4, FIX(2.457431844)) - tmp15; /* c1+c7 */
+    tmp16 = tmp12 - MULTIPLY(z1, FIX(1.112434820)) + tmp13; /* c1-c13 */
+    tmp12 = MULTIPLY(z2, FIX(1.224744871)) - z3;            /* c5 */
+    z2 = MULTIPLY(z1 + z4, FIX(0.575212477));               /* c11 */
+    tmp13 += z2 + MULTIPLY(z1, FIX(0.475753014)) - z3;      /* c7-c11 */
+    tmp15 += z2 - MULTIPLY(z4, FIX(0.869244010)) + z3;      /* c11+c13 */
+
+    /* Final output stage */
+
+    outptr[0]  = range_limit[(int)RIGHT_SHIFT(tmp20 + tmp10,
+                                              CONST_BITS + PASS1_BITS + 3) &
+                             RANGE_MASK];
+    outptr[14] = range_limit[(int)RIGHT_SHIFT(tmp20 - tmp10,
+                                              CONST_BITS + PASS1_BITS + 3) &
+                             RANGE_MASK];
+    outptr[1]  = range_limit[(int)RIGHT_SHIFT(tmp21 + tmp11,
+                                              CONST_BITS + PASS1_BITS + 3) &
+                             RANGE_MASK];
+    outptr[13] = range_limit[(int)RIGHT_SHIFT(tmp21 - tmp11,
+                                              CONST_BITS + PASS1_BITS + 3) &
+                             RANGE_MASK];
+    outptr[2]  = range_limit[(int)RIGHT_SHIFT(tmp22 + tmp12,
+                                              CONST_BITS + PASS1_BITS + 3) &
+                             RANGE_MASK];
+    outptr[12] = range_limit[(int)RIGHT_SHIFT(tmp22 - tmp12,
+                                              CONST_BITS + PASS1_BITS + 3) &
+                             RANGE_MASK];
+    outptr[3]  = range_limit[(int)RIGHT_SHIFT(tmp23 + tmp13,
+                                              CONST_BITS + PASS1_BITS + 3) &
+                             RANGE_MASK];
+    outptr[11] = range_limit[(int)RIGHT_SHIFT(tmp23 - tmp13,
+                                              CONST_BITS + PASS1_BITS + 3) &
+                             RANGE_MASK];
+    outptr[4]  = range_limit[(int)RIGHT_SHIFT(tmp24 + tmp14,
+                                              CONST_BITS + PASS1_BITS + 3) &
+                             RANGE_MASK];
+    outptr[10] = range_limit[(int)RIGHT_SHIFT(tmp24 - tmp14,
+                                              CONST_BITS + PASS1_BITS + 3) &
+                             RANGE_MASK];
+    outptr[5]  = range_limit[(int)RIGHT_SHIFT(tmp25 + tmp15,
+                                              CONST_BITS + PASS1_BITS + 3) &
+                             RANGE_MASK];
+    outptr[9]  = range_limit[(int)RIGHT_SHIFT(tmp25 - tmp15,
+                                              CONST_BITS + PASS1_BITS + 3) &
+                             RANGE_MASK];
+    outptr[6]  = range_limit[(int)RIGHT_SHIFT(tmp26 + tmp16,
+                                              CONST_BITS + PASS1_BITS + 3) &
+                             RANGE_MASK];
+    outptr[8]  = range_limit[(int)RIGHT_SHIFT(tmp26 - tmp16,
+                                              CONST_BITS + PASS1_BITS + 3) &
+                             RANGE_MASK];
+    outptr[7]  = range_limit[(int)RIGHT_SHIFT(tmp27,
+                                              CONST_BITS + PASS1_BITS + 3) &
+                             RANGE_MASK];
+
+    wsptr += 8;         /* advance pointer to next row */
+  }
+}
+
+
+/*
+ * Perform dequantization and inverse DCT on one block of coefficients,
+ * producing a 16x16 output block.
+ *
+ * Optimized algorithm with 28 multiplications in the 1-D kernel.
+ * cK represents sqrt(2) * cos(K*pi/32).
+ */
+
+GLOBAL(void)
+jpeg_idct_16x16(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+                JCOEFPTR coef_block, JSAMPARRAY output_buf,
+                JDIMENSION output_col)
+{
+  JLONG tmp0, tmp1, tmp2, tmp3, tmp10, tmp11, tmp12, tmp13;
+  JLONG tmp20, tmp21, tmp22, tmp23, tmp24, tmp25, tmp26, tmp27;
+  JLONG z1, z2, z3, z4;
+  JCOEFPTR inptr;
+  ISLOW_MULT_TYPE *quantptr;
+  int *wsptr;
+  JSAMPROW outptr;
+  JSAMPLE *range_limit = IDCT_range_limit(cinfo);
+  int ctr;
+  int workspace[8 * 16];        /* buffers data between passes */
+  SHIFT_TEMPS
+
+  /* Pass 1: process columns from input, store into work array. */
+
+  inptr = coef_block;
+  quantptr = (ISLOW_MULT_TYPE *)compptr->dct_table;
+  wsptr = workspace;
+  for (ctr = 0; ctr < 8; ctr++, inptr++, quantptr++, wsptr++) {
+    /* Even part */
+
+    tmp0 = DEQUANTIZE(inptr[DCTSIZE * 0], quantptr[DCTSIZE * 0]);
+    tmp0 = LEFT_SHIFT(tmp0, CONST_BITS);
+    /* Add fudge factor here for final descale. */
+    tmp0 += ONE << (CONST_BITS - PASS1_BITS - 1);
+
+    z1 = DEQUANTIZE(inptr[DCTSIZE * 4], quantptr[DCTSIZE * 4]);
+    tmp1 = MULTIPLY(z1, FIX(1.306562965));      /* c4[16] = c2[8] */
+    tmp2 = MULTIPLY(z1, FIX_0_541196100);       /* c12[16] = c6[8] */
+
+    tmp10 = tmp0 + tmp1;
+    tmp11 = tmp0 - tmp1;
+    tmp12 = tmp0 + tmp2;
+    tmp13 = tmp0 - tmp2;
+
+    z1 = DEQUANTIZE(inptr[DCTSIZE * 2], quantptr[DCTSIZE * 2]);
+    z2 = DEQUANTIZE(inptr[DCTSIZE * 6], quantptr[DCTSIZE * 6]);
+    z3 = z1 - z2;
+    z4 = MULTIPLY(z3, FIX(0.275899379));        /* c14[16] = c7[8] */
+    z3 = MULTIPLY(z3, FIX(1.387039845));        /* c2[16] = c1[8] */
+
+    tmp0 = z3 + MULTIPLY(z2, FIX_2_562915447);  /* (c6+c2)[16] = (c3+c1)[8] */
+    tmp1 = z4 + MULTIPLY(z1, FIX_0_899976223);  /* (c6-c14)[16] = (c3-c7)[8] */
+    tmp2 = z3 - MULTIPLY(z1, FIX(0.601344887)); /* (c2-c10)[16] = (c1-c5)[8] */
+    tmp3 = z4 - MULTIPLY(z2, FIX(0.509795579)); /* (c10-c14)[16] = (c5-c7)[8] */
+
+    tmp20 = tmp10 + tmp0;
+    tmp27 = tmp10 - tmp0;
+    tmp21 = tmp12 + tmp1;
+    tmp26 = tmp12 - tmp1;
+    tmp22 = tmp13 + tmp2;
+    tmp25 = tmp13 - tmp2;
+    tmp23 = tmp11 + tmp3;
+    tmp24 = tmp11 - tmp3;
+
+    /* Odd part */
+
+    z1 = DEQUANTIZE(inptr[DCTSIZE * 1], quantptr[DCTSIZE * 1]);
+    z2 = DEQUANTIZE(inptr[DCTSIZE * 3], quantptr[DCTSIZE * 3]);
+    z3 = DEQUANTIZE(inptr[DCTSIZE * 5], quantptr[DCTSIZE * 5]);
+    z4 = DEQUANTIZE(inptr[DCTSIZE * 7], quantptr[DCTSIZE * 7]);
+
+    tmp11 = z1 + z3;
+
+    tmp1  = MULTIPLY(z1 + z2, FIX(1.353318001));   /* c3 */
+    tmp2  = MULTIPLY(tmp11,   FIX(1.247225013));   /* c5 */
+    tmp3  = MULTIPLY(z1 + z4, FIX(1.093201867));   /* c7 */
+    tmp10 = MULTIPLY(z1 - z4, FIX(0.897167586));   /* c9 */
+    tmp11 = MULTIPLY(tmp11,   FIX(0.666655658));   /* c11 */
+    tmp12 = MULTIPLY(z1 - z2, FIX(0.410524528));   /* c13 */
+    tmp0  = tmp1 + tmp2 + tmp3 -
+            MULTIPLY(z1, FIX(2.286341144));        /* c7+c5+c3-c1 */
+    tmp13 = tmp10 + tmp11 + tmp12 -
+            MULTIPLY(z1, FIX(1.835730603));        /* c9+c11+c13-c15 */
+    z1    = MULTIPLY(z2 + z3, FIX(0.138617169));   /* c15 */
+    tmp1  += z1 + MULTIPLY(z2, FIX(0.071888074));  /* c9+c11-c3-c15 */
+    tmp2  += z1 - MULTIPLY(z3, FIX(1.125726048));  /* c5+c7+c15-c3 */
+    z1    = MULTIPLY(z3 - z2, FIX(1.407403738));   /* c1 */
+    tmp11 += z1 - MULTIPLY(z3, FIX(0.766367282));  /* c1+c11-c9-c13 */
+    tmp12 += z1 + MULTIPLY(z2, FIX(1.971951411));  /* c1+c5+c13-c7 */
+    z2    += z4;
+    z1    = MULTIPLY(z2, -FIX(0.666655658));       /* -c11 */
+    tmp1  += z1;
+    tmp3  += z1 + MULTIPLY(z4, FIX(1.065388962));  /* c3+c11+c15-c7 */
+    z2    = MULTIPLY(z2, -FIX(1.247225013));       /* -c5 */
+    tmp10 += z2 + MULTIPLY(z4, FIX(3.141271809));  /* c1+c5+c9-c13 */
+    tmp12 += z2;
+    z2    = MULTIPLY(z3 + z4, -FIX(1.353318001));  /* -c3 */
+    tmp2  += z2;
+    tmp3  += z2;
+    z2    = MULTIPLY(z4 - z3, FIX(0.410524528));   /* c13 */
+    tmp10 += z2;
+    tmp11 += z2;
+
+    /* Final output stage */
+
+    wsptr[8 * 0]  = (int)RIGHT_SHIFT(tmp20 + tmp0,  CONST_BITS - PASS1_BITS);
+    wsptr[8 * 15] = (int)RIGHT_SHIFT(tmp20 - tmp0,  CONST_BITS - PASS1_BITS);
+    wsptr[8 * 1]  = (int)RIGHT_SHIFT(tmp21 + tmp1,  CONST_BITS - PASS1_BITS);
+    wsptr[8 * 14] = (int)RIGHT_SHIFT(tmp21 - tmp1,  CONST_BITS - PASS1_BITS);
+    wsptr[8 * 2]  = (int)RIGHT_SHIFT(tmp22 + tmp2,  CONST_BITS - PASS1_BITS);
+    wsptr[8 * 13] = (int)RIGHT_SHIFT(tmp22 - tmp2,  CONST_BITS - PASS1_BITS);
+    wsptr[8 * 3]  = (int)RIGHT_SHIFT(tmp23 + tmp3,  CONST_BITS - PASS1_BITS);
+    wsptr[8 * 12] = (int)RIGHT_SHIFT(tmp23 - tmp3,  CONST_BITS - PASS1_BITS);
+    wsptr[8 * 4]  = (int)RIGHT_SHIFT(tmp24 + tmp10, CONST_BITS - PASS1_BITS);
+    wsptr[8 * 11] = (int)RIGHT_SHIFT(tmp24 - tmp10, CONST_BITS - PASS1_BITS);
+    wsptr[8 * 5]  = (int)RIGHT_SHIFT(tmp25 + tmp11, CONST_BITS - PASS1_BITS);
+    wsptr[8 * 10] = (int)RIGHT_SHIFT(tmp25 - tmp11, CONST_BITS - PASS1_BITS);
+    wsptr[8 * 6]  = (int)RIGHT_SHIFT(tmp26 + tmp12, CONST_BITS - PASS1_BITS);
+    wsptr[8 * 9]  = (int)RIGHT_SHIFT(tmp26 - tmp12, CONST_BITS - PASS1_BITS);
+    wsptr[8 * 7]  = (int)RIGHT_SHIFT(tmp27 + tmp13, CONST_BITS - PASS1_BITS);
+    wsptr[8 * 8]  = (int)RIGHT_SHIFT(tmp27 - tmp13, CONST_BITS - PASS1_BITS);
+  }
+
+  /* Pass 2: process 16 rows from work array, store into output array. */
+
+  wsptr = workspace;
+  for (ctr = 0; ctr < 16; ctr++) {
+    outptr = output_buf[ctr] + output_col;
+
+    /* Even part */
+
+    /* Add fudge factor here for final descale. */
+    tmp0 = (JLONG)wsptr[0] + (ONE << (PASS1_BITS + 2));
+    tmp0 = LEFT_SHIFT(tmp0, CONST_BITS);
+
+    z1 = (JLONG)wsptr[4];
+    tmp1 = MULTIPLY(z1, FIX(1.306562965));      /* c4[16] = c2[8] */
+    tmp2 = MULTIPLY(z1, FIX_0_541196100);       /* c12[16] = c6[8] */
+
+    tmp10 = tmp0 + tmp1;
+    tmp11 = tmp0 - tmp1;
+    tmp12 = tmp0 + tmp2;
+    tmp13 = tmp0 - tmp2;
+
+    z1 = (JLONG)wsptr[2];
+    z2 = (JLONG)wsptr[6];
+    z3 = z1 - z2;
+    z4 = MULTIPLY(z3, FIX(0.275899379));        /* c14[16] = c7[8] */
+    z3 = MULTIPLY(z3, FIX(1.387039845));        /* c2[16] = c1[8] */
+
+    tmp0 = z3 + MULTIPLY(z2, FIX_2_562915447);  /* (c6+c2)[16] = (c3+c1)[8] */
+    tmp1 = z4 + MULTIPLY(z1, FIX_0_899976223);  /* (c6-c14)[16] = (c3-c7)[8] */
+    tmp2 = z3 - MULTIPLY(z1, FIX(0.601344887)); /* (c2-c10)[16] = (c1-c5)[8] */
+    tmp3 = z4 - MULTIPLY(z2, FIX(0.509795579)); /* (c10-c14)[16] = (c5-c7)[8] */
+
+    tmp20 = tmp10 + tmp0;
+    tmp27 = tmp10 - tmp0;
+    tmp21 = tmp12 + tmp1;
+    tmp26 = tmp12 - tmp1;
+    tmp22 = tmp13 + tmp2;
+    tmp25 = tmp13 - tmp2;
+    tmp23 = tmp11 + tmp3;
+    tmp24 = tmp11 - tmp3;
+
+    /* Odd part */
+
+    z1 = (JLONG)wsptr[1];
+    z2 = (JLONG)wsptr[3];
+    z3 = (JLONG)wsptr[5];
+    z4 = (JLONG)wsptr[7];
+
+    tmp11 = z1 + z3;
+
+    tmp1  = MULTIPLY(z1 + z2, FIX(1.353318001));   /* c3 */
+    tmp2  = MULTIPLY(tmp11,   FIX(1.247225013));   /* c5 */
+    tmp3  = MULTIPLY(z1 + z4, FIX(1.093201867));   /* c7 */
+    tmp10 = MULTIPLY(z1 - z4, FIX(0.897167586));   /* c9 */
+    tmp11 = MULTIPLY(tmp11,   FIX(0.666655658));   /* c11 */
+    tmp12 = MULTIPLY(z1 - z2, FIX(0.410524528));   /* c13 */
+    tmp0  = tmp1 + tmp2 + tmp3 -
+            MULTIPLY(z1, FIX(2.286341144));        /* c7+c5+c3-c1 */
+    tmp13 = tmp10 + tmp11 + tmp12 -
+            MULTIPLY(z1, FIX(1.835730603));        /* c9+c11+c13-c15 */
+    z1    = MULTIPLY(z2 + z3, FIX(0.138617169));   /* c15 */
+    tmp1  += z1 + MULTIPLY(z2, FIX(0.071888074));  /* c9+c11-c3-c15 */
+    tmp2  += z1 - MULTIPLY(z3, FIX(1.125726048));  /* c5+c7+c15-c3 */
+    z1    = MULTIPLY(z3 - z2, FIX(1.407403738));   /* c1 */
+    tmp11 += z1 - MULTIPLY(z3, FIX(0.766367282));  /* c1+c11-c9-c13 */
+    tmp12 += z1 + MULTIPLY(z2, FIX(1.971951411));  /* c1+c5+c13-c7 */
+    z2    += z4;
+    z1    = MULTIPLY(z2, -FIX(0.666655658));       /* -c11 */
+    tmp1  += z1;
+    tmp3  += z1 + MULTIPLY(z4, FIX(1.065388962));  /* c3+c11+c15-c7 */
+    z2    = MULTIPLY(z2, -FIX(1.247225013));       /* -c5 */
+    tmp10 += z2 + MULTIPLY(z4, FIX(3.141271809));  /* c1+c5+c9-c13 */
+    tmp12 += z2;
+    z2    = MULTIPLY(z3 + z4, -FIX(1.353318001));  /* -c3 */
+    tmp2  += z2;
+    tmp3  += z2;
+    z2    = MULTIPLY(z4 - z3, FIX(0.410524528));   /* c13 */
+    tmp10 += z2;
+    tmp11 += z2;
+
+    /* Final output stage */
+
+    outptr[0]  = range_limit[(int)RIGHT_SHIFT(tmp20 + tmp0,
+                                              CONST_BITS + PASS1_BITS + 3) &
+                             RANGE_MASK];
+    outptr[15] = range_limit[(int)RIGHT_SHIFT(tmp20 - tmp0,
+                                              CONST_BITS + PASS1_BITS + 3) &
+                             RANGE_MASK];
+    outptr[1]  = range_limit[(int)RIGHT_SHIFT(tmp21 + tmp1,
+                                              CONST_BITS + PASS1_BITS + 3) &
+                             RANGE_MASK];
+    outptr[14] = range_limit[(int)RIGHT_SHIFT(tmp21 - tmp1,
+                                              CONST_BITS + PASS1_BITS + 3) &
+                             RANGE_MASK];
+    outptr[2]  = range_limit[(int)RIGHT_SHIFT(tmp22 + tmp2,
+                                              CONST_BITS + PASS1_BITS + 3) &
+                             RANGE_MASK];
+    outptr[13] = range_limit[(int)RIGHT_SHIFT(tmp22 - tmp2,
+                                              CONST_BITS + PASS1_BITS + 3) &
+                             RANGE_MASK];
+    outptr[3]  = range_limit[(int)RIGHT_SHIFT(tmp23 + tmp3,
+                                              CONST_BITS + PASS1_BITS + 3) &
+                             RANGE_MASK];
+    outptr[12] = range_limit[(int)RIGHT_SHIFT(tmp23 - tmp3,
+                                              CONST_BITS + PASS1_BITS + 3) &
+                             RANGE_MASK];
+    outptr[4]  = range_limit[(int)RIGHT_SHIFT(tmp24 + tmp10,
+                                              CONST_BITS + PASS1_BITS + 3) &
+                             RANGE_MASK];
+    outptr[11] = range_limit[(int)RIGHT_SHIFT(tmp24 - tmp10,
+                                              CONST_BITS + PASS1_BITS + 3) &
+                             RANGE_MASK];
+    outptr[5]  = range_limit[(int)RIGHT_SHIFT(tmp25 + tmp11,
+                                              CONST_BITS + PASS1_BITS + 3) &
+                             RANGE_MASK];
+    outptr[10] = range_limit[(int)RIGHT_SHIFT(tmp25 - tmp11,
+                                              CONST_BITS + PASS1_BITS + 3) &
+                             RANGE_MASK];
+    outptr[6]  = range_limit[(int)RIGHT_SHIFT(tmp26 + tmp12,
+                                              CONST_BITS + PASS1_BITS + 3) &
+                             RANGE_MASK];
+    outptr[9]  = range_limit[(int)RIGHT_SHIFT(tmp26 - tmp12,
+                                              CONST_BITS + PASS1_BITS + 3) &
+                             RANGE_MASK];
+    outptr[7]  = range_limit[(int)RIGHT_SHIFT(tmp27 + tmp13,
+                                              CONST_BITS + PASS1_BITS + 3) &
+                             RANGE_MASK];
+    outptr[8]  = range_limit[(int)RIGHT_SHIFT(tmp27 - tmp13,
+                                              CONST_BITS + PASS1_BITS + 3) &
+                             RANGE_MASK];
+
+    wsptr += 8;         /* advance pointer to next row */
+  }
+}
+
+#endif /* IDCT_SCALING_SUPPORTED */
+#endif /* DCT_ISLOW_SUPPORTED */
diff --git a/3rdparty/libjpeg/src/jidctred.c b/3rdparty/libjpeg/src/jidctred.c
new file mode 100644
index 00000000..1dd65a94
--- /dev/null
+++ b/3rdparty/libjpeg/src/jidctred.c
@@ -0,0 +1,409 @@
+/*
+ * jidctred.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1994-1998, Thomas G. Lane.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2015, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains inverse-DCT routines that produce reduced-size output:
+ * either 4x4, 2x2, or 1x1 pixels from an 8x8 DCT block.
+ *
+ * The implementation is based on the Loeffler, Ligtenberg and Moschytz (LL&M)
+ * algorithm used in jidctint.c.  We simply replace each 8-to-8 1-D IDCT step
+ * with an 8-to-4 step that produces the four averages of two adjacent outputs
+ * (or an 8-to-2 step producing two averages of four outputs, for 2x2 output).
+ * These steps were derived by computing the corresponding values at the end
+ * of the normal LL&M code, then simplifying as much as possible.
+ *
+ * 1x1 is trivial: just take the DC coefficient divided by 8.
+ *
+ * See jidctint.c for additional comments.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jdct.h"               /* Private declarations for DCT subsystem */
+
+#ifdef IDCT_SCALING_SUPPORTED
+
+
+/*
+ * This module is specialized to the case DCTSIZE = 8.
+ */
+
+#if DCTSIZE != 8
+  Sorry, this code only copes with 8x8 DCTs. /* deliberate syntax err */
+#endif
+
+
+/* Scaling is the same as in jidctint.c. */
+
+#if BITS_IN_JSAMPLE == 8
+#define CONST_BITS  13
+#define PASS1_BITS  2
+#else
+#define CONST_BITS  13
+#define PASS1_BITS  1           /* lose a little precision to avoid overflow */
+#endif
+
+/* Some C compilers fail to reduce "FIX(constant)" at compile time, thus
+ * causing a lot of useless floating-point operations at run time.
+ * To get around this we use the following pre-calculated constants.
+ * If you change CONST_BITS you may want to add appropriate values.
+ * (With a reasonable C compiler, you can just rely on the FIX() macro...)
+ */
+
+#if CONST_BITS == 13
+#define FIX_0_211164243  ((JLONG)1730)          /* FIX(0.211164243) */
+#define FIX_0_509795579  ((JLONG)4176)          /* FIX(0.509795579) */
+#define FIX_0_601344887  ((JLONG)4926)          /* FIX(0.601344887) */
+#define FIX_0_720959822  ((JLONG)5906)          /* FIX(0.720959822) */
+#define FIX_0_765366865  ((JLONG)6270)          /* FIX(0.765366865) */
+#define FIX_0_850430095  ((JLONG)6967)          /* FIX(0.850430095) */
+#define FIX_0_899976223  ((JLONG)7373)          /* FIX(0.899976223) */
+#define FIX_1_061594337  ((JLONG)8697)          /* FIX(1.061594337) */
+#define FIX_1_272758580  ((JLONG)10426)         /* FIX(1.272758580) */
+#define FIX_1_451774981  ((JLONG)11893)         /* FIX(1.451774981) */
+#define FIX_1_847759065  ((JLONG)15137)         /* FIX(1.847759065) */
+#define FIX_2_172734803  ((JLONG)17799)         /* FIX(2.172734803) */
+#define FIX_2_562915447  ((JLONG)20995)         /* FIX(2.562915447) */
+#define FIX_3_624509785  ((JLONG)29692)         /* FIX(3.624509785) */
+#else
+#define FIX_0_211164243  FIX(0.211164243)
+#define FIX_0_509795579  FIX(0.509795579)
+#define FIX_0_601344887  FIX(0.601344887)
+#define FIX_0_720959822  FIX(0.720959822)
+#define FIX_0_765366865  FIX(0.765366865)
+#define FIX_0_850430095  FIX(0.850430095)
+#define FIX_0_899976223  FIX(0.899976223)
+#define FIX_1_061594337  FIX(1.061594337)
+#define FIX_1_272758580  FIX(1.272758580)
+#define FIX_1_451774981  FIX(1.451774981)
+#define FIX_1_847759065  FIX(1.847759065)
+#define FIX_2_172734803  FIX(2.172734803)
+#define FIX_2_562915447  FIX(2.562915447)
+#define FIX_3_624509785  FIX(3.624509785)
+#endif
+
+
+/* Multiply a JLONG variable by a JLONG constant to yield a JLONG result.
+ * For 8-bit samples with the recommended scaling, all the variable
+ * and constant values involved are no more than 16 bits wide, so a
+ * 16x16->32 bit multiply can be used instead of a full 32x32 multiply.
+ * For 12-bit samples, a full 32-bit multiplication will be needed.
+ */
+
+#if BITS_IN_JSAMPLE == 8
+#define MULTIPLY(var, const)  MULTIPLY16C16(var, const)
+#else
+#define MULTIPLY(var, const)  ((var) * (const))
+#endif
+
+
+/* Dequantize a coefficient by multiplying it by the multiplier-table
+ * entry; produce an int result.  In this module, both inputs and result
+ * are 16 bits or less, so either int or short multiply will work.
+ */
+
+#define DEQUANTIZE(coef, quantval)  (((ISLOW_MULT_TYPE)(coef)) * (quantval))
+
+
+/*
+ * Perform dequantization and inverse DCT on one block of coefficients,
+ * producing a reduced-size 4x4 output block.
+ */
+
+GLOBAL(void)
+jpeg_idct_4x4(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+              JCOEFPTR coef_block, JSAMPARRAY output_buf,
+              JDIMENSION output_col)
+{
+  JLONG tmp0, tmp2, tmp10, tmp12;
+  JLONG z1, z2, z3, z4;
+  JCOEFPTR inptr;
+  ISLOW_MULT_TYPE *quantptr;
+  int *wsptr;
+  JSAMPROW outptr;
+  JSAMPLE *range_limit = IDCT_range_limit(cinfo);
+  int ctr;
+  int workspace[DCTSIZE * 4];   /* buffers data between passes */
+  SHIFT_TEMPS
+
+  /* Pass 1: process columns from input, store into work array. */
+
+  inptr = coef_block;
+  quantptr = (ISLOW_MULT_TYPE *)compptr->dct_table;
+  wsptr = workspace;
+  for (ctr = DCTSIZE; ctr > 0; inptr++, quantptr++, wsptr++, ctr--) {
+    /* Don't bother to process column 4, because second pass won't use it */
+    if (ctr == DCTSIZE - 4)
+      continue;
+    if (inptr[DCTSIZE * 1] == 0 && inptr[DCTSIZE * 2] == 0 &&
+        inptr[DCTSIZE * 3] == 0 && inptr[DCTSIZE * 5] == 0 &&
+        inptr[DCTSIZE * 6] == 0 && inptr[DCTSIZE * 7] == 0) {
+      /* AC terms all zero; we need not examine term 4 for 4x4 output */
+      int dcval = LEFT_SHIFT(DEQUANTIZE(inptr[DCTSIZE * 0],
+                                        quantptr[DCTSIZE * 0]), PASS1_BITS);
+
+      wsptr[DCTSIZE * 0] = dcval;
+      wsptr[DCTSIZE * 1] = dcval;
+      wsptr[DCTSIZE * 2] = dcval;
+      wsptr[DCTSIZE * 3] = dcval;
+
+      continue;
+    }
+
+    /* Even part */
+
+    tmp0 = DEQUANTIZE(inptr[DCTSIZE * 0], quantptr[DCTSIZE * 0]);
+    tmp0 = LEFT_SHIFT(tmp0, CONST_BITS + 1);
+
+    z2 = DEQUANTIZE(inptr[DCTSIZE * 2], quantptr[DCTSIZE * 2]);
+    z3 = DEQUANTIZE(inptr[DCTSIZE * 6], quantptr[DCTSIZE * 6]);
+
+    tmp2 = MULTIPLY(z2, FIX_1_847759065) + MULTIPLY(z3, -FIX_0_765366865);
+
+    tmp10 = tmp0 + tmp2;
+    tmp12 = tmp0 - tmp2;
+
+    /* Odd part */
+
+    z1 = DEQUANTIZE(inptr[DCTSIZE * 7], quantptr[DCTSIZE * 7]);
+    z2 = DEQUANTIZE(inptr[DCTSIZE * 5], quantptr[DCTSIZE * 5]);
+    z3 = DEQUANTIZE(inptr[DCTSIZE * 3], quantptr[DCTSIZE * 3]);
+    z4 = DEQUANTIZE(inptr[DCTSIZE * 1], quantptr[DCTSIZE * 1]);
+
+    tmp0 = MULTIPLY(z1, -FIX_0_211164243) + /* sqrt(2) * ( c3-c1) */
+           MULTIPLY(z2,  FIX_1_451774981) + /* sqrt(2) * ( c3+c7) */
+           MULTIPLY(z3, -FIX_2_172734803) + /* sqrt(2) * (-c1-c5) */
+           MULTIPLY(z4,  FIX_1_061594337);  /* sqrt(2) * ( c5+c7) */
+
+    tmp2 = MULTIPLY(z1, -FIX_0_509795579) + /* sqrt(2) * (c7-c5) */
+           MULTIPLY(z2, -FIX_0_601344887) + /* sqrt(2) * (c5-c1) */
+           MULTIPLY(z3,  FIX_0_899976223) + /* sqrt(2) * (c3-c7) */
+           MULTIPLY(z4,  FIX_2_562915447);  /* sqrt(2) * (c1+c3) */
+
+    /* Final output stage */
+
+    wsptr[DCTSIZE * 0] =
+      (int)DESCALE(tmp10 + tmp2, CONST_BITS - PASS1_BITS + 1);
+    wsptr[DCTSIZE * 3] =
+      (int)DESCALE(tmp10 - tmp2, CONST_BITS - PASS1_BITS + 1);
+    wsptr[DCTSIZE * 1] =
+      (int)DESCALE(tmp12 + tmp0, CONST_BITS - PASS1_BITS + 1);
+    wsptr[DCTSIZE * 2] =
+      (int)DESCALE(tmp12 - tmp0, CONST_BITS - PASS1_BITS + 1);
+  }
+
+  /* Pass 2: process 4 rows from work array, store into output array. */
+
+  wsptr = workspace;
+  for (ctr = 0; ctr < 4; ctr++) {
+    outptr = output_buf[ctr] + output_col;
+    /* It's not clear whether a zero row test is worthwhile here ... */
+
+#ifndef NO_ZERO_ROW_TEST
+    if (wsptr[1] == 0 && wsptr[2] == 0 && wsptr[3] == 0 &&
+        wsptr[5] == 0 && wsptr[6] == 0 && wsptr[7] == 0) {
+      /* AC terms all zero */
+      JSAMPLE dcval = range_limit[(int)DESCALE((JLONG)wsptr[0],
+                                               PASS1_BITS + 3) & RANGE_MASK];
+
+      outptr[0] = dcval;
+      outptr[1] = dcval;
+      outptr[2] = dcval;
+      outptr[3] = dcval;
+
+      wsptr += DCTSIZE;         /* advance pointer to next row */
+      continue;
+    }
+#endif
+
+    /* Even part */
+
+    tmp0 = LEFT_SHIFT((JLONG)wsptr[0], CONST_BITS + 1);
+
+    tmp2 = MULTIPLY((JLONG)wsptr[2],  FIX_1_847759065) +
+           MULTIPLY((JLONG)wsptr[6], -FIX_0_765366865);
+
+    tmp10 = tmp0 + tmp2;
+    tmp12 = tmp0 - tmp2;
+
+    /* Odd part */
+
+    z1 = (JLONG)wsptr[7];
+    z2 = (JLONG)wsptr[5];
+    z3 = (JLONG)wsptr[3];
+    z4 = (JLONG)wsptr[1];
+
+    tmp0 = MULTIPLY(z1, -FIX_0_211164243) + /* sqrt(2) * ( c3-c1) */
+           MULTIPLY(z2,  FIX_1_451774981) + /* sqrt(2) * ( c3+c7) */
+           MULTIPLY(z3, -FIX_2_172734803) + /* sqrt(2) * (-c1-c5) */
+           MULTIPLY(z4,  FIX_1_061594337);  /* sqrt(2) * ( c5+c7) */
+
+    tmp2 = MULTIPLY(z1, -FIX_0_509795579) + /* sqrt(2) * (c7-c5) */
+           MULTIPLY(z2, -FIX_0_601344887) + /* sqrt(2) * (c5-c1) */
+           MULTIPLY(z3, FIX_0_899976223) +  /* sqrt(2) * (c3-c7) */
+           MULTIPLY(z4, FIX_2_562915447);   /* sqrt(2) * (c1+c3) */
+
+    /* Final output stage */
+
+    outptr[0] = range_limit[(int)DESCALE(tmp10 + tmp2,
+                                         CONST_BITS + PASS1_BITS + 3 + 1) &
+                            RANGE_MASK];
+    outptr[3] = range_limit[(int)DESCALE(tmp10 - tmp2,
+                                         CONST_BITS + PASS1_BITS + 3 + 1) &
+                            RANGE_MASK];
+    outptr[1] = range_limit[(int)DESCALE(tmp12 + tmp0,
+                                         CONST_BITS + PASS1_BITS + 3 + 1) &
+                            RANGE_MASK];
+    outptr[2] = range_limit[(int)DESCALE(tmp12 - tmp0,
+                                         CONST_BITS + PASS1_BITS + 3 + 1) &
+                            RANGE_MASK];
+
+    wsptr += DCTSIZE;           /* advance pointer to next row */
+  }
+}
+
+
+/*
+ * Perform dequantization and inverse DCT on one block of coefficients,
+ * producing a reduced-size 2x2 output block.
+ */
+
+GLOBAL(void)
+jpeg_idct_2x2(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+              JCOEFPTR coef_block, JSAMPARRAY output_buf,
+              JDIMENSION output_col)
+{
+  JLONG tmp0, tmp10, z1;
+  JCOEFPTR inptr;
+  ISLOW_MULT_TYPE *quantptr;
+  int *wsptr;
+  JSAMPROW outptr;
+  JSAMPLE *range_limit = IDCT_range_limit(cinfo);
+  int ctr;
+  int workspace[DCTSIZE * 2];   /* buffers data between passes */
+  SHIFT_TEMPS
+
+  /* Pass 1: process columns from input, store into work array. */
+
+  inptr = coef_block;
+  quantptr = (ISLOW_MULT_TYPE *)compptr->dct_table;
+  wsptr = workspace;
+  for (ctr = DCTSIZE; ctr > 0; inptr++, quantptr++, wsptr++, ctr--) {
+    /* Don't bother to process columns 2,4,6 */
+    if (ctr == DCTSIZE - 2 || ctr == DCTSIZE - 4 || ctr == DCTSIZE - 6)
+      continue;
+    if (inptr[DCTSIZE * 1] == 0 && inptr[DCTSIZE * 3] == 0 &&
+        inptr[DCTSIZE * 5] == 0 && inptr[DCTSIZE * 7] == 0) {
+      /* AC terms all zero; we need not examine terms 2,4,6 for 2x2 output */
+      int dcval = LEFT_SHIFT(DEQUANTIZE(inptr[DCTSIZE * 0],
+                             quantptr[DCTSIZE * 0]), PASS1_BITS);
+
+      wsptr[DCTSIZE * 0] = dcval;
+      wsptr[DCTSIZE * 1] = dcval;
+
+      continue;
+    }
+
+    /* Even part */
+
+    z1 = DEQUANTIZE(inptr[DCTSIZE * 0], quantptr[DCTSIZE * 0]);
+    tmp10 = LEFT_SHIFT(z1, CONST_BITS + 2);
+
+    /* Odd part */
+
+    z1 = DEQUANTIZE(inptr[DCTSIZE * 7], quantptr[DCTSIZE * 7]);
+    tmp0 = MULTIPLY(z1, -FIX_0_720959822);  /* sqrt(2) * ( c7-c5+c3-c1) */
+    z1 = DEQUANTIZE(inptr[DCTSIZE * 5], quantptr[DCTSIZE * 5]);
+    tmp0 += MULTIPLY(z1, FIX_0_850430095);  /* sqrt(2) * (-c1+c3+c5+c7) */
+    z1 = DEQUANTIZE(inptr[DCTSIZE * 3], quantptr[DCTSIZE * 3]);
+    tmp0 += MULTIPLY(z1, -FIX_1_272758580); /* sqrt(2) * (-c1+c3-c5-c7) */
+    z1 = DEQUANTIZE(inptr[DCTSIZE * 1], quantptr[DCTSIZE * 1]);
+    tmp0 += MULTIPLY(z1, FIX_3_624509785);  /* sqrt(2) * ( c1+c3+c5+c7) */
+
+    /* Final output stage */
+
+    wsptr[DCTSIZE * 0] =
+      (int)DESCALE(tmp10 + tmp0, CONST_BITS - PASS1_BITS + 2);
+    wsptr[DCTSIZE * 1] =
+      (int)DESCALE(tmp10 - tmp0, CONST_BITS - PASS1_BITS + 2);
+  }
+
+  /* Pass 2: process 2 rows from work array, store into output array. */
+
+  wsptr = workspace;
+  for (ctr = 0; ctr < 2; ctr++) {
+    outptr = output_buf[ctr] + output_col;
+    /* It's not clear whether a zero row test is worthwhile here ... */
+
+#ifndef NO_ZERO_ROW_TEST
+    if (wsptr[1] == 0 && wsptr[3] == 0 && wsptr[5] == 0 && wsptr[7] == 0) {
+      /* AC terms all zero */
+      JSAMPLE dcval = range_limit[(int)DESCALE((JLONG)wsptr[0],
+                                               PASS1_BITS + 3) & RANGE_MASK];
+
+      outptr[0] = dcval;
+      outptr[1] = dcval;
+
+      wsptr += DCTSIZE;         /* advance pointer to next row */
+      continue;
+    }
+#endif
+
+    /* Even part */
+
+    tmp10 = LEFT_SHIFT((JLONG)wsptr[0], CONST_BITS + 2);
+
+    /* Odd part */
+
+    tmp0 = MULTIPLY((JLONG)wsptr[7], -FIX_0_720959822) + /* sqrt(2) * ( c7-c5+c3-c1) */
+           MULTIPLY((JLONG)wsptr[5],  FIX_0_850430095) + /* sqrt(2) * (-c1+c3+c5+c7) */
+           MULTIPLY((JLONG)wsptr[3], -FIX_1_272758580) + /* sqrt(2) * (-c1+c3-c5-c7) */
+           MULTIPLY((JLONG)wsptr[1],  FIX_3_624509785);  /* sqrt(2) * ( c1+c3+c5+c7) */
+
+    /* Final output stage */
+
+    outptr[0] = range_limit[(int)DESCALE(tmp10 + tmp0,
+                                         CONST_BITS + PASS1_BITS + 3 + 2) &
+                            RANGE_MASK];
+    outptr[1] = range_limit[(int)DESCALE(tmp10 - tmp0,
+                                         CONST_BITS + PASS1_BITS + 3 + 2) &
+                            RANGE_MASK];
+
+    wsptr += DCTSIZE;           /* advance pointer to next row */
+  }
+}
+
+
+/*
+ * Perform dequantization and inverse DCT on one block of coefficients,
+ * producing a reduced-size 1x1 output block.
+ */
+
+GLOBAL(void)
+jpeg_idct_1x1(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+              JCOEFPTR coef_block, JSAMPARRAY output_buf,
+              JDIMENSION output_col)
+{
+  int dcval;
+  ISLOW_MULT_TYPE *quantptr;
+  JSAMPLE *range_limit = IDCT_range_limit(cinfo);
+  SHIFT_TEMPS
+
+  /* We hardly need an inverse DCT routine for this: just take the
+   * average pixel value, which is one-eighth of the DC coefficient.
+   */
+  quantptr = (ISLOW_MULT_TYPE *)compptr->dct_table;
+  dcval = DEQUANTIZE(coef_block[0], quantptr[0]);
+  dcval = (int)DESCALE((JLONG)dcval, 3);
+
+  output_buf[0][output_col] = range_limit[dcval & RANGE_MASK];
+}
+
+#endif /* IDCT_SCALING_SUPPORTED */
diff --git a/3rdparty/libjpeg/src/jinclude.h b/3rdparty/libjpeg/src/jinclude.h
new file mode 100644
index 00000000..c1bcf7d9
--- /dev/null
+++ b/3rdparty/libjpeg/src/jinclude.h
@@ -0,0 +1,88 @@
+/*
+ * jinclude.h
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1991-1994, Thomas G. Lane.
+ * It was modified by The libjpeg-turbo Project to include only code relevant
+ * to libjpeg-turbo.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file exists to provide a single place to fix any problems with
+ * including the wrong system include files.  (Common problems are taken
+ * care of by the standard jconfig symbols, but on really weird systems
+ * you may have to edit this file.)
+ *
+ * NOTE: this file is NOT intended to be included by applications using the
+ * JPEG library.  Most applications need only include jpeglib.h.
+ */
+
+
+/* Include auto-config file to find out which system include files we need. */
+
+#include "jconfig.h"            /* auto configuration options */
+#define JCONFIG_INCLUDED        /* so that jpeglib.h doesn't do it again */
+
+/*
+ * We need the NULL macro and size_t typedef.
+ * On an ANSI-conforming system it is sufficient to include <stddef.h>.
+ * Otherwise, we get them from <stdlib.h> or <stdio.h>; we may have to
+ * pull in <sys/types.h> as well.
+ * Note that the core JPEG library does not require <stdio.h>;
+ * only the default error handler and data source/destination modules do.
+ * But we must pull it in because of the references to FILE in jpeglib.h.
+ * You can remove those references if you want to compile without <stdio.h>.
+ */
+
+#ifdef HAVE_STDDEF_H
+#include <stddef.h>
+#endif
+
+#ifdef HAVE_STDLIB_H
+#include <stdlib.h>
+#endif
+
+#ifdef NEED_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+
+#include <stdio.h>
+
+/*
+ * We need memory copying and zeroing functions, plus strncpy().
+ * ANSI and System V implementations declare these in <string.h>.
+ * BSD doesn't have the mem() functions, but it does have bcopy()/bzero().
+ * Some systems may declare memset and memcpy in <memory.h>.
+ *
+ * NOTE: we assume the size parameters to these functions are of type size_t.
+ * Change the casts in these macros if not!
+ */
+
+#ifdef NEED_BSD_STRINGS
+
+#include <strings.h>
+#define MEMZERO(target, size) \
+  bzero((void *)(target), (size_t)(size))
+#define MEMCOPY(dest, src, size) \
+  bcopy((const void *)(src), (void *)(dest), (size_t)(size))
+
+#else /* not BSD, assume ANSI/SysV string lib */
+
+#include <string.h>
+#define MEMZERO(target, size) \
+  memset((void *)(target), 0, (size_t)(size))
+#define MEMCOPY(dest, src, size) \
+  memcpy((void *)(dest), (const void *)(src), (size_t)(size))
+
+#endif
+
+/*
+ * The modules that use fread() and fwrite() always invoke them through
+ * these macros.  On some systems you may need to twiddle the argument casts.
+ * CAUTION: argument order is different from underlying functions!
+ */
+
+#define JFREAD(file, buf, sizeofbuf) \
+  ((size_t)fread((void *)(buf), (size_t)1, (size_t)(sizeofbuf), (file)))
+#define JFWRITE(file, buf, sizeofbuf) \
+  ((size_t)fwrite((const void *)(buf), (size_t)1, (size_t)(sizeofbuf), (file)))
diff --git a/3rdparty/libjpeg/src/jmemmgr.c b/3rdparty/libjpeg/src/jmemmgr.c
new file mode 100644
index 00000000..508ca742
--- /dev/null
+++ b/3rdparty/libjpeg/src/jmemmgr.c
@@ -0,0 +1,1179 @@
+/*
+ * jmemmgr.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1991-1997, Thomas G. Lane.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2016, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains the JPEG system-independent memory management
+ * routines.  This code is usable across a wide variety of machines; most
+ * of the system dependencies have been isolated in a separate file.
+ * The major functions provided here are:
+ *   * pool-based allocation and freeing of memory;
+ *   * policy decisions about how to divide available memory among the
+ *     virtual arrays;
+ *   * control logic for swapping virtual arrays between main memory and
+ *     backing storage.
+ * The separate system-dependent file provides the actual backing-storage
+ * access code, and it contains the policy decision about how much total
+ * main memory to use.
+ * This file is system-dependent in the sense that some of its functions
+ * are unnecessary in some systems.  For example, if there is enough virtual
+ * memory so that backing storage will never be used, much of the virtual
+ * array control logic could be removed.  (Of course, if you have that much
+ * memory then you shouldn't care about a little bit of unused code...)
+ */
+
+#define JPEG_INTERNALS
+#define AM_MEMORY_MANAGER       /* we define jvirt_Xarray_control structs */
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jmemsys.h"            /* import the system-dependent declarations */
+#if !defined(_MSC_VER) || _MSC_VER > 1600
+#include <stdint.h>
+#endif
+#include <limits.h>
+
+#ifndef NO_GETENV
+#ifndef HAVE_STDLIB_H           /* <stdlib.h> should declare getenv() */
+extern char *getenv(const char *name);
+#endif
+#endif
+
+
+LOCAL(size_t)
+round_up_pow2(size_t a, size_t b)
+/* a rounded up to the next multiple of b, i.e. ceil(a/b)*b */
+/* Assumes a >= 0, b > 0, and b is a power of 2 */
+{
+  return ((a + b - 1) & (~(b - 1)));
+}
+
+
+/*
+ * Some important notes:
+ *   The allocation routines provided here must never return NULL.
+ *   They should exit to error_exit if unsuccessful.
+ *
+ *   It's not a good idea to try to merge the sarray and barray routines,
+ *   even though they are textually almost the same, because samples are
+ *   usually stored as bytes while coefficients are shorts or ints.  Thus,
+ *   in machines where byte pointers have a different representation from
+ *   word pointers, the resulting machine code could not be the same.
+ */
+
+
+/*
+ * Many machines require storage alignment: longs must start on 4-byte
+ * boundaries, doubles on 8-byte boundaries, etc.  On such machines, malloc()
+ * always returns pointers that are multiples of the worst-case alignment
+ * requirement, and we had better do so too.
+ * There isn't any really portable way to determine the worst-case alignment
+ * requirement.  This module assumes that the alignment requirement is
+ * multiples of ALIGN_SIZE.
+ * By default, we define ALIGN_SIZE as sizeof(double).  This is necessary on
+ * some workstations (where doubles really do need 8-byte alignment) and will
+ * work fine on nearly everything.  If your machine has lesser alignment needs,
+ * you can save a few bytes by making ALIGN_SIZE smaller.
+ * The only place I know of where this will NOT work is certain Macintosh
+ * 680x0 compilers that define double as a 10-byte IEEE extended float.
+ * Doing 10-byte alignment is counterproductive because longwords won't be
+ * aligned well.  Put "#define ALIGN_SIZE 4" in jconfig.h if you have
+ * such a compiler.
+ */
+
+#ifndef ALIGN_SIZE              /* so can override from jconfig.h */
+#ifndef WITH_SIMD
+#define ALIGN_SIZE  sizeof(double)
+#else
+#define ALIGN_SIZE  32 /* Most of the SIMD instructions we support require
+                          16-byte (128-bit) alignment, but AVX2 requires
+                          32-byte alignment. */
+#endif
+#endif
+
+/*
+ * We allocate objects from "pools", where each pool is gotten with a single
+ * request to jpeg_get_small() or jpeg_get_large().  There is no per-object
+ * overhead within a pool, except for alignment padding.  Each pool has a
+ * header with a link to the next pool of the same class.
+ * Small and large pool headers are identical.
+ */
+
+typedef struct small_pool_struct *small_pool_ptr;
+
+typedef struct small_pool_struct {
+  small_pool_ptr next;          /* next in list of pools */
+  size_t bytes_used;            /* how many bytes already used within pool */
+  size_t bytes_left;            /* bytes still available in this pool */
+} small_pool_hdr;
+
+typedef struct large_pool_struct *large_pool_ptr;
+
+typedef struct large_pool_struct {
+  large_pool_ptr next;          /* next in list of pools */
+  size_t bytes_used;            /* how many bytes already used within pool */
+  size_t bytes_left;            /* bytes still available in this pool */
+} large_pool_hdr;
+
+/*
+ * Here is the full definition of a memory manager object.
+ */
+
+typedef struct {
+  struct jpeg_memory_mgr pub;   /* public fields */
+
+  /* Each pool identifier (lifetime class) names a linked list of pools. */
+  small_pool_ptr small_list[JPOOL_NUMPOOLS];
+  large_pool_ptr large_list[JPOOL_NUMPOOLS];
+
+  /* Since we only have one lifetime class of virtual arrays, only one
+   * linked list is necessary (for each datatype).  Note that the virtual
+   * array control blocks being linked together are actually stored somewhere
+   * in the small-pool list.
+   */
+  jvirt_sarray_ptr virt_sarray_list;
+  jvirt_barray_ptr virt_barray_list;
+
+  /* This counts total space obtained from jpeg_get_small/large */
+  size_t total_space_allocated;
+
+  /* alloc_sarray and alloc_barray set this value for use by virtual
+   * array routines.
+   */
+  JDIMENSION last_rowsperchunk; /* from most recent alloc_sarray/barray */
+} my_memory_mgr;
+
+typedef my_memory_mgr *my_mem_ptr;
+
+
+/*
+ * The control blocks for virtual arrays.
+ * Note that these blocks are allocated in the "small" pool area.
+ * System-dependent info for the associated backing store (if any) is hidden
+ * inside the backing_store_info struct.
+ */
+
+struct jvirt_sarray_control {
+  JSAMPARRAY mem_buffer;        /* => the in-memory buffer */
+  JDIMENSION rows_in_array;     /* total virtual array height */
+  JDIMENSION samplesperrow;     /* width of array (and of memory buffer) */
+  JDIMENSION maxaccess;         /* max rows accessed by access_virt_sarray */
+  JDIMENSION rows_in_mem;       /* height of memory buffer */
+  JDIMENSION rowsperchunk;      /* allocation chunk size in mem_buffer */
+  JDIMENSION cur_start_row;     /* first logical row # in the buffer */
+  JDIMENSION first_undef_row;   /* row # of first uninitialized row */
+  boolean pre_zero;             /* pre-zero mode requested? */
+  boolean dirty;                /* do current buffer contents need written? */
+  boolean b_s_open;             /* is backing-store data valid? */
+  jvirt_sarray_ptr next;        /* link to next virtual sarray control block */
+  backing_store_info b_s_info;  /* System-dependent control info */
+};
+
+struct jvirt_barray_control {
+  JBLOCKARRAY mem_buffer;       /* => the in-memory buffer */
+  JDIMENSION rows_in_array;     /* total virtual array height */
+  JDIMENSION blocksperrow;      /* width of array (and of memory buffer) */
+  JDIMENSION maxaccess;         /* max rows accessed by access_virt_barray */
+  JDIMENSION rows_in_mem;       /* height of memory buffer */
+  JDIMENSION rowsperchunk;      /* allocation chunk size in mem_buffer */
+  JDIMENSION cur_start_row;     /* first logical row # in the buffer */
+  JDIMENSION first_undef_row;   /* row # of first uninitialized row */
+  boolean pre_zero;             /* pre-zero mode requested? */
+  boolean dirty;                /* do current buffer contents need written? */
+  boolean b_s_open;             /* is backing-store data valid? */
+  jvirt_barray_ptr next;        /* link to next virtual barray control block */
+  backing_store_info b_s_info;  /* System-dependent control info */
+};
+
+
+#ifdef MEM_STATS                /* optional extra stuff for statistics */
+
+LOCAL(void)
+print_mem_stats(j_common_ptr cinfo, int pool_id)
+{
+  my_mem_ptr mem = (my_mem_ptr)cinfo->mem;
+  small_pool_ptr shdr_ptr;
+  large_pool_ptr lhdr_ptr;
+
+  /* Since this is only a debugging stub, we can cheat a little by using
+   * fprintf directly rather than going through the trace message code.
+   * This is helpful because message parm array can't handle longs.
+   */
+  fprintf(stderr, "Freeing pool %d, total space = %ld\n",
+          pool_id, mem->total_space_allocated);
+
+  for (lhdr_ptr = mem->large_list[pool_id]; lhdr_ptr != NULL;
+       lhdr_ptr = lhdr_ptr->next) {
+    fprintf(stderr, "  Large chunk used %ld\n", (long)lhdr_ptr->bytes_used);
+  }
+
+  for (shdr_ptr = mem->small_list[pool_id]; shdr_ptr != NULL;
+       shdr_ptr = shdr_ptr->next) {
+    fprintf(stderr, "  Small chunk used %ld free %ld\n",
+            (long)shdr_ptr->bytes_used, (long)shdr_ptr->bytes_left);
+  }
+}
+
+#endif /* MEM_STATS */
+
+
+LOCAL(void)
+out_of_memory(j_common_ptr cinfo, int which)
+/* Report an out-of-memory error and stop execution */
+/* If we compiled MEM_STATS support, report alloc requests before dying */
+{
+#ifdef MEM_STATS
+  cinfo->err->trace_level = 2;  /* force self_destruct to report stats */
+#endif
+  ERREXIT1(cinfo, JERR_OUT_OF_MEMORY, which);
+}
+
+
+/*
+ * Allocation of "small" objects.
+ *
+ * For these, we use pooled storage.  When a new pool must be created,
+ * we try to get enough space for the current request plus a "slop" factor,
+ * where the slop will be the amount of leftover space in the new pool.
+ * The speed vs. space tradeoff is largely determined by the slop values.
+ * A different slop value is provided for each pool class (lifetime),
+ * and we also distinguish the first pool of a class from later ones.
+ * NOTE: the values given work fairly well on both 16- and 32-bit-int
+ * machines, but may be too small if longs are 64 bits or more.
+ *
+ * Since we do not know what alignment malloc() gives us, we have to
+ * allocate ALIGN_SIZE-1 extra space per pool to have room for alignment
+ * adjustment.
+ */
+
+static const size_t first_pool_slop[JPOOL_NUMPOOLS] = {
+  1600,                         /* first PERMANENT pool */
+  16000                         /* first IMAGE pool */
+};
+
+static const size_t extra_pool_slop[JPOOL_NUMPOOLS] = {
+  0,                            /* additional PERMANENT pools */
+  5000                          /* additional IMAGE pools */
+};
+
+#define MIN_SLOP  50            /* greater than 0 to avoid futile looping */
+
+
+METHODDEF(void *)
+alloc_small(j_common_ptr cinfo, int pool_id, size_t sizeofobject)
+/* Allocate a "small" object */
+{
+  my_mem_ptr mem = (my_mem_ptr)cinfo->mem;
+  small_pool_ptr hdr_ptr, prev_hdr_ptr;
+  char *data_ptr;
+  size_t min_request, slop;
+
+  /*
+   * Round up the requested size to a multiple of ALIGN_SIZE in order
+   * to assure alignment for the next object allocated in the same pool
+   * and so that algorithms can straddle outside the proper area up
+   * to the next alignment.
+   */
+  if (sizeofobject > MAX_ALLOC_CHUNK) {
+    /* This prevents overflow/wrap-around in round_up_pow2() if sizeofobject
+       is close to SIZE_MAX. */
+    out_of_memory(cinfo, 7);
+  }
+  sizeofobject = round_up_pow2(sizeofobject, ALIGN_SIZE);
+
+  /* Check for unsatisfiable request (do now to ensure no overflow below) */
+  if ((sizeof(small_pool_hdr) + sizeofobject + ALIGN_SIZE - 1) >
+      MAX_ALLOC_CHUNK)
+    out_of_memory(cinfo, 1);    /* request exceeds malloc's ability */
+
+  /* See if space is available in any existing pool */
+  if (pool_id < 0 || pool_id >= JPOOL_NUMPOOLS)
+    ERREXIT1(cinfo, JERR_BAD_POOL_ID, pool_id); /* safety check */
+  prev_hdr_ptr = NULL;
+  hdr_ptr = mem->small_list[pool_id];
+  while (hdr_ptr != NULL) {
+    if (hdr_ptr->bytes_left >= sizeofobject)
+      break;                    /* found pool with enough space */
+    prev_hdr_ptr = hdr_ptr;
+    hdr_ptr = hdr_ptr->next;
+  }
+
+  /* Time to make a new pool? */
+  if (hdr_ptr == NULL) {
+    /* min_request is what we need now, slop is what will be leftover */
+    min_request = sizeof(small_pool_hdr) + sizeofobject + ALIGN_SIZE - 1;
+    if (prev_hdr_ptr == NULL)   /* first pool in class? */
+      slop = first_pool_slop[pool_id];
+    else
+      slop = extra_pool_slop[pool_id];
+    /* Don't ask for more than MAX_ALLOC_CHUNK */
+    if (slop > (size_t)(MAX_ALLOC_CHUNK - min_request))
+      slop = (size_t)(MAX_ALLOC_CHUNK - min_request);
+    /* Try to get space, if fail reduce slop and try again */
+    for (;;) {
+      hdr_ptr = (small_pool_ptr)jpeg_get_small(cinfo, min_request + slop);
+      if (hdr_ptr != NULL)
+        break;
+      slop /= 2;
+      if (slop < MIN_SLOP)      /* give up when it gets real small */
+        out_of_memory(cinfo, 2); /* jpeg_get_small failed */
+    }
+    mem->total_space_allocated += min_request + slop;
+    /* Success, initialize the new pool header and add to end of list */
+    hdr_ptr->next = NULL;
+    hdr_ptr->bytes_used = 0;
+    hdr_ptr->bytes_left = sizeofobject + slop;
+    if (prev_hdr_ptr == NULL)   /* first pool in class? */
+      mem->small_list[pool_id] = hdr_ptr;
+    else
+      prev_hdr_ptr->next = hdr_ptr;
+  }
+
+  /* OK, allocate the object from the current pool */
+  data_ptr = (char *)hdr_ptr; /* point to first data byte in pool... */
+  data_ptr += sizeof(small_pool_hdr); /* ...by skipping the header... */
+  if ((size_t)data_ptr % ALIGN_SIZE) /* ...and adjust for alignment */
+    data_ptr += ALIGN_SIZE - (size_t)data_ptr % ALIGN_SIZE;
+  data_ptr += hdr_ptr->bytes_used; /* point to place for object */
+  hdr_ptr->bytes_used += sizeofobject;
+  hdr_ptr->bytes_left -= sizeofobject;
+
+  return (void *)data_ptr;
+}
+
+
+/*
+ * Allocation of "large" objects.
+ *
+ * The external semantics of these are the same as "small" objects.  However,
+ * the pool management heuristics are quite different.  We assume that each
+ * request is large enough that it may as well be passed directly to
+ * jpeg_get_large; the pool management just links everything together
+ * so that we can free it all on demand.
+ * Note: the major use of "large" objects is in JSAMPARRAY and JBLOCKARRAY
+ * structures.  The routines that create these structures (see below)
+ * deliberately bunch rows together to ensure a large request size.
+ */
+
+METHODDEF(void *)
+alloc_large(j_common_ptr cinfo, int pool_id, size_t sizeofobject)
+/* Allocate a "large" object */
+{
+  my_mem_ptr mem = (my_mem_ptr)cinfo->mem;
+  large_pool_ptr hdr_ptr;
+  char *data_ptr;
+
+  /*
+   * Round up the requested size to a multiple of ALIGN_SIZE so that
+   * algorithms can straddle outside the proper area up to the next
+   * alignment.
+   */
+  if (sizeofobject > MAX_ALLOC_CHUNK) {
+    /* This prevents overflow/wrap-around in round_up_pow2() if sizeofobject
+       is close to SIZE_MAX. */
+    out_of_memory(cinfo, 8);
+  }
+  sizeofobject = round_up_pow2(sizeofobject, ALIGN_SIZE);
+
+  /* Check for unsatisfiable request (do now to ensure no overflow below) */
+  if ((sizeof(large_pool_hdr) + sizeofobject + ALIGN_SIZE - 1) >
+      MAX_ALLOC_CHUNK)
+    out_of_memory(cinfo, 3);    /* request exceeds malloc's ability */
+
+  /* Always make a new pool */
+  if (pool_id < 0 || pool_id >= JPOOL_NUMPOOLS)
+    ERREXIT1(cinfo, JERR_BAD_POOL_ID, pool_id); /* safety check */
+
+  hdr_ptr = (large_pool_ptr)jpeg_get_large(cinfo, sizeofobject +
+                                           sizeof(large_pool_hdr) +
+                                           ALIGN_SIZE - 1);
+  if (hdr_ptr == NULL)
+    out_of_memory(cinfo, 4);    /* jpeg_get_large failed */
+  mem->total_space_allocated += sizeofobject + sizeof(large_pool_hdr) +
+                                ALIGN_SIZE - 1;
+
+  /* Success, initialize the new pool header and add to list */
+  hdr_ptr->next = mem->large_list[pool_id];
+  /* We maintain space counts in each pool header for statistical purposes,
+   * even though they are not needed for allocation.
+   */
+  hdr_ptr->bytes_used = sizeofobject;
+  hdr_ptr->bytes_left = 0;
+  mem->large_list[pool_id] = hdr_ptr;
+
+  data_ptr = (char *)hdr_ptr; /* point to first data byte in pool... */
+  data_ptr += sizeof(small_pool_hdr); /* ...by skipping the header... */
+  if ((size_t)data_ptr % ALIGN_SIZE) /* ...and adjust for alignment */
+    data_ptr += ALIGN_SIZE - (size_t)data_ptr % ALIGN_SIZE;
+
+  return (void *)data_ptr;
+}
+
+
+/*
+ * Creation of 2-D sample arrays.
+ *
+ * To minimize allocation overhead and to allow I/O of large contiguous
+ * blocks, we allocate the sample rows in groups of as many rows as possible
+ * without exceeding MAX_ALLOC_CHUNK total bytes per allocation request.
+ * NB: the virtual array control routines, later in this file, know about
+ * this chunking of rows.  The rowsperchunk value is left in the mem manager
+ * object so that it can be saved away if this sarray is the workspace for
+ * a virtual array.
+ *
+ * Since we are often upsampling with a factor 2, we align the size (not
+ * the start) to 2 * ALIGN_SIZE so that the upsampling routines don't have
+ * to be as careful about size.
+ */
+
+METHODDEF(JSAMPARRAY)
+alloc_sarray(j_common_ptr cinfo, int pool_id, JDIMENSION samplesperrow,
+             JDIMENSION numrows)
+/* Allocate a 2-D sample array */
+{
+  my_mem_ptr mem = (my_mem_ptr)cinfo->mem;
+  JSAMPARRAY result;
+  JSAMPROW workspace;
+  JDIMENSION rowsperchunk, currow, i;
+  long ltemp;
+
+  /* Make sure each row is properly aligned */
+  if ((ALIGN_SIZE % sizeof(JSAMPLE)) != 0)
+    out_of_memory(cinfo, 5);    /* safety check */
+
+  if (samplesperrow > MAX_ALLOC_CHUNK) {
+    /* This prevents overflow/wrap-around in round_up_pow2() if sizeofobject
+       is close to SIZE_MAX. */
+    out_of_memory(cinfo, 9);
+  }
+  samplesperrow = (JDIMENSION)round_up_pow2(samplesperrow, (2 * ALIGN_SIZE) /
+                                                           sizeof(JSAMPLE));
+
+  /* Calculate max # of rows allowed in one allocation chunk */
+  ltemp = (MAX_ALLOC_CHUNK - sizeof(large_pool_hdr)) /
+          ((long)samplesperrow * sizeof(JSAMPLE));
+  if (ltemp <= 0)
+    ERREXIT(cinfo, JERR_WIDTH_OVERFLOW);
+  if (ltemp < (long)numrows)
+    rowsperchunk = (JDIMENSION)ltemp;
+  else
+    rowsperchunk = numrows;
+  mem->last_rowsperchunk = rowsperchunk;
+
+  /* Get space for row pointers (small object) */
+  result = (JSAMPARRAY)alloc_small(cinfo, pool_id,
+                                   (size_t)(numrows * sizeof(JSAMPROW)));
+
+  /* Get the rows themselves (large objects) */
+  currow = 0;
+  while (currow < numrows) {
+    rowsperchunk = MIN(rowsperchunk, numrows - currow);
+    workspace = (JSAMPROW)alloc_large(cinfo, pool_id,
+      (size_t)((size_t)rowsperchunk * (size_t)samplesperrow *
+               sizeof(JSAMPLE)));
+    for (i = rowsperchunk; i > 0; i--) {
+      result[currow++] = workspace;
+      workspace += samplesperrow;
+    }
+  }
+
+  return result;
+}
+
+
+/*
+ * Creation of 2-D coefficient-block arrays.
+ * This is essentially the same as the code for sample arrays, above.
+ */
+
+METHODDEF(JBLOCKARRAY)
+alloc_barray(j_common_ptr cinfo, int pool_id, JDIMENSION blocksperrow,
+             JDIMENSION numrows)
+/* Allocate a 2-D coefficient-block array */
+{
+  my_mem_ptr mem = (my_mem_ptr)cinfo->mem;
+  JBLOCKARRAY result;
+  JBLOCKROW workspace;
+  JDIMENSION rowsperchunk, currow, i;
+  long ltemp;
+
+  /* Make sure each row is properly aligned */
+  if ((sizeof(JBLOCK) % ALIGN_SIZE) != 0)
+    out_of_memory(cinfo, 6);    /* safety check */
+
+  /* Calculate max # of rows allowed in one allocation chunk */
+  ltemp = (MAX_ALLOC_CHUNK - sizeof(large_pool_hdr)) /
+          ((long)blocksperrow * sizeof(JBLOCK));
+  if (ltemp <= 0)
+    ERREXIT(cinfo, JERR_WIDTH_OVERFLOW);
+  if (ltemp < (long)numrows)
+    rowsperchunk = (JDIMENSION)ltemp;
+  else
+    rowsperchunk = numrows;
+  mem->last_rowsperchunk = rowsperchunk;
+
+  /* Get space for row pointers (small object) */
+  result = (JBLOCKARRAY)alloc_small(cinfo, pool_id,
+                                    (size_t)(numrows * sizeof(JBLOCKROW)));
+
+  /* Get the rows themselves (large objects) */
+  currow = 0;
+  while (currow < numrows) {
+    rowsperchunk = MIN(rowsperchunk, numrows - currow);
+    workspace = (JBLOCKROW)alloc_large(cinfo, pool_id,
+        (size_t)((size_t)rowsperchunk * (size_t)blocksperrow *
+                  sizeof(JBLOCK)));
+    for (i = rowsperchunk; i > 0; i--) {
+      result[currow++] = workspace;
+      workspace += blocksperrow;
+    }
+  }
+
+  return result;
+}
+
+
+/*
+ * About virtual array management:
+ *
+ * The above "normal" array routines are only used to allocate strip buffers
+ * (as wide as the image, but just a few rows high).  Full-image-sized buffers
+ * are handled as "virtual" arrays.  The array is still accessed a strip at a
+ * time, but the memory manager must save the whole array for repeated
+ * accesses.  The intended implementation is that there is a strip buffer in
+ * memory (as high as is possible given the desired memory limit), plus a
+ * backing file that holds the rest of the array.
+ *
+ * The request_virt_array routines are told the total size of the image and
+ * the maximum number of rows that will be accessed at once.  The in-memory
+ * buffer must be at least as large as the maxaccess value.
+ *
+ * The request routines create control blocks but not the in-memory buffers.
+ * That is postponed until realize_virt_arrays is called.  At that time the
+ * total amount of space needed is known (approximately, anyway), so free
+ * memory can be divided up fairly.
+ *
+ * The access_virt_array routines are responsible for making a specific strip
+ * area accessible (after reading or writing the backing file, if necessary).
+ * Note that the access routines are told whether the caller intends to modify
+ * the accessed strip; during a read-only pass this saves having to rewrite
+ * data to disk.  The access routines are also responsible for pre-zeroing
+ * any newly accessed rows, if pre-zeroing was requested.
+ *
+ * In current usage, the access requests are usually for nonoverlapping
+ * strips; that is, successive access start_row numbers differ by exactly
+ * num_rows = maxaccess.  This means we can get good performance with simple
+ * buffer dump/reload logic, by making the in-memory buffer be a multiple
+ * of the access height; then there will never be accesses across bufferload
+ * boundaries.  The code will still work with overlapping access requests,
+ * but it doesn't handle bufferload overlaps very efficiently.
+ */
+
+
+METHODDEF(jvirt_sarray_ptr)
+request_virt_sarray(j_common_ptr cinfo, int pool_id, boolean pre_zero,
+                    JDIMENSION samplesperrow, JDIMENSION numrows,
+                    JDIMENSION maxaccess)
+/* Request a virtual 2-D sample array */
+{
+  my_mem_ptr mem = (my_mem_ptr)cinfo->mem;
+  jvirt_sarray_ptr result;
+
+  /* Only IMAGE-lifetime virtual arrays are currently supported */
+  if (pool_id != JPOOL_IMAGE)
+    ERREXIT1(cinfo, JERR_BAD_POOL_ID, pool_id); /* safety check */
+
+  /* get control block */
+  result = (jvirt_sarray_ptr)alloc_small(cinfo, pool_id,
+                                         sizeof(struct jvirt_sarray_control));
+
+  result->mem_buffer = NULL;    /* marks array not yet realized */
+  result->rows_in_array = numrows;
+  result->samplesperrow = samplesperrow;
+  result->maxaccess = maxaccess;
+  result->pre_zero = pre_zero;
+  result->b_s_open = FALSE;     /* no associated backing-store object */
+  result->next = mem->virt_sarray_list; /* add to list of virtual arrays */
+  mem->virt_sarray_list = result;
+
+  return result;
+}
+
+
+METHODDEF(jvirt_barray_ptr)
+request_virt_barray(j_common_ptr cinfo, int pool_id, boolean pre_zero,
+                    JDIMENSION blocksperrow, JDIMENSION numrows,
+                    JDIMENSION maxaccess)
+/* Request a virtual 2-D coefficient-block array */
+{
+  my_mem_ptr mem = (my_mem_ptr)cinfo->mem;
+  jvirt_barray_ptr result;
+
+  /* Only IMAGE-lifetime virtual arrays are currently supported */
+  if (pool_id != JPOOL_IMAGE)
+    ERREXIT1(cinfo, JERR_BAD_POOL_ID, pool_id); /* safety check */
+
+  /* get control block */
+  result = (jvirt_barray_ptr)alloc_small(cinfo, pool_id,
+                                         sizeof(struct jvirt_barray_control));
+
+  result->mem_buffer = NULL;    /* marks array not yet realized */
+  result->rows_in_array = numrows;
+  result->blocksperrow = blocksperrow;
+  result->maxaccess = maxaccess;
+  result->pre_zero = pre_zero;
+  result->b_s_open = FALSE;     /* no associated backing-store object */
+  result->next = mem->virt_barray_list; /* add to list of virtual arrays */
+  mem->virt_barray_list = result;
+
+  return result;
+}
+
+
+METHODDEF(void)
+realize_virt_arrays(j_common_ptr cinfo)
+/* Allocate the in-memory buffers for any unrealized virtual arrays */
+{
+  my_mem_ptr mem = (my_mem_ptr)cinfo->mem;
+  size_t space_per_minheight, maximum_space, avail_mem;
+  size_t minheights, max_minheights;
+  jvirt_sarray_ptr sptr;
+  jvirt_barray_ptr bptr;
+
+  /* Compute the minimum space needed (maxaccess rows in each buffer)
+   * and the maximum space needed (full image height in each buffer).
+   * These may be of use to the system-dependent jpeg_mem_available routine.
+   */
+  space_per_minheight = 0;
+  maximum_space = 0;
+  for (sptr = mem->virt_sarray_list; sptr != NULL; sptr = sptr->next) {
+    if (sptr->mem_buffer == NULL) { /* if not realized yet */
+      size_t new_space = (long)sptr->rows_in_array *
+                         (long)sptr->samplesperrow * sizeof(JSAMPLE);
+
+      space_per_minheight += (long)sptr->maxaccess *
+                             (long)sptr->samplesperrow * sizeof(JSAMPLE);
+      if (SIZE_MAX - maximum_space < new_space)
+        out_of_memory(cinfo, 10);
+      maximum_space += new_space;
+    }
+  }
+  for (bptr = mem->virt_barray_list; bptr != NULL; bptr = bptr->next) {
+    if (bptr->mem_buffer == NULL) { /* if not realized yet */
+      size_t new_space = (long)bptr->rows_in_array *
+                         (long)bptr->blocksperrow * sizeof(JBLOCK);
+
+      space_per_minheight += (long)bptr->maxaccess *
+                             (long)bptr->blocksperrow * sizeof(JBLOCK);
+      if (SIZE_MAX - maximum_space < new_space)
+        out_of_memory(cinfo, 11);
+      maximum_space += new_space;
+    }
+  }
+
+  if (space_per_minheight <= 0)
+    return;                     /* no unrealized arrays, no work */
+
+  /* Determine amount of memory to actually use; this is system-dependent. */
+  avail_mem = jpeg_mem_available(cinfo, space_per_minheight, maximum_space,
+                                 mem->total_space_allocated);
+
+  /* If the maximum space needed is available, make all the buffers full
+   * height; otherwise parcel it out with the same number of minheights
+   * in each buffer.
+   */
+  if (avail_mem >= maximum_space)
+    max_minheights = 1000000000L;
+  else {
+    max_minheights = avail_mem / space_per_minheight;
+    /* If there doesn't seem to be enough space, try to get the minimum
+     * anyway.  This allows a "stub" implementation of jpeg_mem_available().
+     */
+    if (max_minheights <= 0)
+      max_minheights = 1;
+  }
+
+  /* Allocate the in-memory buffers and initialize backing store as needed. */
+
+  for (sptr = mem->virt_sarray_list; sptr != NULL; sptr = sptr->next) {
+    if (sptr->mem_buffer == NULL) { /* if not realized yet */
+      minheights = ((long)sptr->rows_in_array - 1L) / sptr->maxaccess + 1L;
+      if (minheights <= max_minheights) {
+        /* This buffer fits in memory */
+        sptr->rows_in_mem = sptr->rows_in_array;
+      } else {
+        /* It doesn't fit in memory, create backing store. */
+        sptr->rows_in_mem = (JDIMENSION)(max_minheights * sptr->maxaccess);
+        jpeg_open_backing_store(cinfo, &sptr->b_s_info,
+                                (long)sptr->rows_in_array *
+                                (long)sptr->samplesperrow *
+                                (long)sizeof(JSAMPLE));
+        sptr->b_s_open = TRUE;
+      }
+      sptr->mem_buffer = alloc_sarray(cinfo, JPOOL_IMAGE,
+                                      sptr->samplesperrow, sptr->rows_in_mem);
+      sptr->rowsperchunk = mem->last_rowsperchunk;
+      sptr->cur_start_row = 0;
+      sptr->first_undef_row = 0;
+      sptr->dirty = FALSE;
+    }
+  }
+
+  for (bptr = mem->virt_barray_list; bptr != NULL; bptr = bptr->next) {
+    if (bptr->mem_buffer == NULL) { /* if not realized yet */
+      minheights = ((long)bptr->rows_in_array - 1L) / bptr->maxaccess + 1L;
+      if (minheights <= max_minheights) {
+        /* This buffer fits in memory */
+        bptr->rows_in_mem = bptr->rows_in_array;
+      } else {
+        /* It doesn't fit in memory, create backing store. */
+        bptr->rows_in_mem = (JDIMENSION)(max_minheights * bptr->maxaccess);
+        jpeg_open_backing_store(cinfo, &bptr->b_s_info,
+                                (long)bptr->rows_in_array *
+                                (long)bptr->blocksperrow *
+                                (long)sizeof(JBLOCK));
+        bptr->b_s_open = TRUE;
+      }
+      bptr->mem_buffer = alloc_barray(cinfo, JPOOL_IMAGE,
+                                      bptr->blocksperrow, bptr->rows_in_mem);
+      bptr->rowsperchunk = mem->last_rowsperchunk;
+      bptr->cur_start_row = 0;
+      bptr->first_undef_row = 0;
+      bptr->dirty = FALSE;
+    }
+  }
+}
+
+
+LOCAL(void)
+do_sarray_io(j_common_ptr cinfo, jvirt_sarray_ptr ptr, boolean writing)
+/* Do backing store read or write of a virtual sample array */
+{
+  long bytesperrow, file_offset, byte_count, rows, thisrow, i;
+
+  bytesperrow = (long)ptr->samplesperrow * sizeof(JSAMPLE);
+  file_offset = ptr->cur_start_row * bytesperrow;
+  /* Loop to read or write each allocation chunk in mem_buffer */
+  for (i = 0; i < (long)ptr->rows_in_mem; i += ptr->rowsperchunk) {
+    /* One chunk, but check for short chunk at end of buffer */
+    rows = MIN((long)ptr->rowsperchunk, (long)ptr->rows_in_mem - i);
+    /* Transfer no more than is currently defined */
+    thisrow = (long)ptr->cur_start_row + i;
+    rows = MIN(rows, (long)ptr->first_undef_row - thisrow);
+    /* Transfer no more than fits in file */
+    rows = MIN(rows, (long)ptr->rows_in_array - thisrow);
+    if (rows <= 0)              /* this chunk might be past end of file! */
+      break;
+    byte_count = rows * bytesperrow;
+    if (writing)
+      (*ptr->b_s_info.write_backing_store) (cinfo, &ptr->b_s_info,
+                                            (void *)ptr->mem_buffer[i],
+                                            file_offset, byte_count);
+    else
+      (*ptr->b_s_info.read_backing_store) (cinfo, &ptr->b_s_info,
+                                           (void *)ptr->mem_buffer[i],
+                                           file_offset, byte_count);
+    file_offset += byte_count;
+  }
+}
+
+
+LOCAL(void)
+do_barray_io(j_common_ptr cinfo, jvirt_barray_ptr ptr, boolean writing)
+/* Do backing store read or write of a virtual coefficient-block array */
+{
+  long bytesperrow, file_offset, byte_count, rows, thisrow, i;
+
+  bytesperrow = (long)ptr->blocksperrow * sizeof(JBLOCK);
+  file_offset = ptr->cur_start_row * bytesperrow;
+  /* Loop to read or write each allocation chunk in mem_buffer */
+  for (i = 0; i < (long)ptr->rows_in_mem; i += ptr->rowsperchunk) {
+    /* One chunk, but check for short chunk at end of buffer */
+    rows = MIN((long)ptr->rowsperchunk, (long)ptr->rows_in_mem - i);
+    /* Transfer no more than is currently defined */
+    thisrow = (long)ptr->cur_start_row + i;
+    rows = MIN(rows, (long)ptr->first_undef_row - thisrow);
+    /* Transfer no more than fits in file */
+    rows = MIN(rows, (long)ptr->rows_in_array - thisrow);
+    if (rows <= 0)              /* this chunk might be past end of file! */
+      break;
+    byte_count = rows * bytesperrow;
+    if (writing)
+      (*ptr->b_s_info.write_backing_store) (cinfo, &ptr->b_s_info,
+                                            (void *)ptr->mem_buffer[i],
+                                            file_offset, byte_count);
+    else
+      (*ptr->b_s_info.read_backing_store) (cinfo, &ptr->b_s_info,
+                                           (void *)ptr->mem_buffer[i],
+                                           file_offset, byte_count);
+    file_offset += byte_count;
+  }
+}
+
+
+METHODDEF(JSAMPARRAY)
+access_virt_sarray(j_common_ptr cinfo, jvirt_sarray_ptr ptr,
+                   JDIMENSION start_row, JDIMENSION num_rows, boolean writable)
+/* Access the part of a virtual sample array starting at start_row */
+/* and extending for num_rows rows.  writable is true if  */
+/* caller intends to modify the accessed area. */
+{
+  JDIMENSION end_row = start_row + num_rows;
+  JDIMENSION undef_row;
+
+  /* debugging check */
+  if (end_row > ptr->rows_in_array || num_rows > ptr->maxaccess ||
+      ptr->mem_buffer == NULL)
+    ERREXIT(cinfo, JERR_BAD_VIRTUAL_ACCESS);
+
+  /* Make the desired part of the virtual array accessible */
+  if (start_row < ptr->cur_start_row ||
+      end_row > ptr->cur_start_row + ptr->rows_in_mem) {
+    if (!ptr->b_s_open)
+      ERREXIT(cinfo, JERR_VIRTUAL_BUG);
+    /* Flush old buffer contents if necessary */
+    if (ptr->dirty) {
+      do_sarray_io(cinfo, ptr, TRUE);
+      ptr->dirty = FALSE;
+    }
+    /* Decide what part of virtual array to access.
+     * Algorithm: if target address > current window, assume forward scan,
+     * load starting at target address.  If target address < current window,
+     * assume backward scan, load so that target area is top of window.
+     * Note that when switching from forward write to forward read, will have
+     * start_row = 0, so the limiting case applies and we load from 0 anyway.
+     */
+    if (start_row > ptr->cur_start_row) {
+      ptr->cur_start_row = start_row;
+    } else {
+      /* use long arithmetic here to avoid overflow & unsigned problems */
+      long ltemp;
+
+      ltemp = (long)end_row - (long)ptr->rows_in_mem;
+      if (ltemp < 0)
+        ltemp = 0;              /* don't fall off front end of file */
+      ptr->cur_start_row = (JDIMENSION)ltemp;
+    }
+    /* Read in the selected part of the array.
+     * During the initial write pass, we will do no actual read
+     * because the selected part is all undefined.
+     */
+    do_sarray_io(cinfo, ptr, FALSE);
+  }
+  /* Ensure the accessed part of the array is defined; prezero if needed.
+   * To improve locality of access, we only prezero the part of the array
+   * that the caller is about to access, not the entire in-memory array.
+   */
+  if (ptr->first_undef_row < end_row) {
+    if (ptr->first_undef_row < start_row) {
+      if (writable)             /* writer skipped over a section of array */
+        ERREXIT(cinfo, JERR_BAD_VIRTUAL_ACCESS);
+      undef_row = start_row;    /* but reader is allowed to read ahead */
+    } else {
+      undef_row = ptr->first_undef_row;
+    }
+    if (writable)
+      ptr->first_undef_row = end_row;
+    if (ptr->pre_zero) {
+      size_t bytesperrow = (size_t)ptr->samplesperrow * sizeof(JSAMPLE);
+      undef_row -= ptr->cur_start_row; /* make indexes relative to buffer */
+      end_row -= ptr->cur_start_row;
+      while (undef_row < end_row) {
+        jzero_far((void *)ptr->mem_buffer[undef_row], bytesperrow);
+        undef_row++;
+      }
+    } else {
+      if (!writable)            /* reader looking at undefined data */
+        ERREXIT(cinfo, JERR_BAD_VIRTUAL_ACCESS);
+    }
+  }
+  /* Flag the buffer dirty if caller will write in it */
+  if (writable)
+    ptr->dirty = TRUE;
+  /* Return address of proper part of the buffer */
+  return ptr->mem_buffer + (start_row - ptr->cur_start_row);
+}
+
+
+METHODDEF(JBLOCKARRAY)
+access_virt_barray(j_common_ptr cinfo, jvirt_barray_ptr ptr,
+                   JDIMENSION start_row, JDIMENSION num_rows, boolean writable)
+/* Access the part of a virtual block array starting at start_row */
+/* and extending for num_rows rows.  writable is true if  */
+/* caller intends to modify the accessed area. */
+{
+  JDIMENSION end_row = start_row + num_rows;
+  JDIMENSION undef_row;
+
+  /* debugging check */
+  if (end_row > ptr->rows_in_array || num_rows > ptr->maxaccess ||
+      ptr->mem_buffer == NULL)
+    ERREXIT(cinfo, JERR_BAD_VIRTUAL_ACCESS);
+
+  /* Make the desired part of the virtual array accessible */
+  if (start_row < ptr->cur_start_row ||
+      end_row > ptr->cur_start_row + ptr->rows_in_mem) {
+    if (!ptr->b_s_open)
+      ERREXIT(cinfo, JERR_VIRTUAL_BUG);
+    /* Flush old buffer contents if necessary */
+    if (ptr->dirty) {
+      do_barray_io(cinfo, ptr, TRUE);
+      ptr->dirty = FALSE;
+    }
+    /* Decide what part of virtual array to access.
+     * Algorithm: if target address > current window, assume forward scan,
+     * load starting at target address.  If target address < current window,
+     * assume backward scan, load so that target area is top of window.
+     * Note that when switching from forward write to forward read, will have
+     * start_row = 0, so the limiting case applies and we load from 0 anyway.
+     */
+    if (start_row > ptr->cur_start_row) {
+      ptr->cur_start_row = start_row;
+    } else {
+      /* use long arithmetic here to avoid overflow & unsigned problems */
+      long ltemp;
+
+      ltemp = (long)end_row - (long)ptr->rows_in_mem;
+      if (ltemp < 0)
+        ltemp = 0;              /* don't fall off front end of file */
+      ptr->cur_start_row = (JDIMENSION)ltemp;
+    }
+    /* Read in the selected part of the array.
+     * During the initial write pass, we will do no actual read
+     * because the selected part is all undefined.
+     */
+    do_barray_io(cinfo, ptr, FALSE);
+  }
+  /* Ensure the accessed part of the array is defined; prezero if needed.
+   * To improve locality of access, we only prezero the part of the array
+   * that the caller is about to access, not the entire in-memory array.
+   */
+  if (ptr->first_undef_row < end_row) {
+    if (ptr->first_undef_row < start_row) {
+      if (writable)             /* writer skipped over a section of array */
+        ERREXIT(cinfo, JERR_BAD_VIRTUAL_ACCESS);
+      undef_row = start_row;    /* but reader is allowed to read ahead */
+    } else {
+      undef_row = ptr->first_undef_row;
+    }
+    if (writable)
+      ptr->first_undef_row = end_row;
+    if (ptr->pre_zero) {
+      size_t bytesperrow = (size_t)ptr->blocksperrow * sizeof(JBLOCK);
+      undef_row -= ptr->cur_start_row; /* make indexes relative to buffer */
+      end_row -= ptr->cur_start_row;
+      while (undef_row < end_row) {
+        jzero_far((void *)ptr->mem_buffer[undef_row], bytesperrow);
+        undef_row++;
+      }
+    } else {
+      if (!writable)            /* reader looking at undefined data */
+        ERREXIT(cinfo, JERR_BAD_VIRTUAL_ACCESS);
+    }
+  }
+  /* Flag the buffer dirty if caller will write in it */
+  if (writable)
+    ptr->dirty = TRUE;
+  /* Return address of proper part of the buffer */
+  return ptr->mem_buffer + (start_row - ptr->cur_start_row);
+}
+
+
+/*
+ * Release all objects belonging to a specified pool.
+ */
+
+METHODDEF(void)
+free_pool(j_common_ptr cinfo, int pool_id)
+{
+  my_mem_ptr mem = (my_mem_ptr)cinfo->mem;
+  small_pool_ptr shdr_ptr;
+  large_pool_ptr lhdr_ptr;
+  size_t space_freed;
+
+  if (pool_id < 0 || pool_id >= JPOOL_NUMPOOLS)
+    ERREXIT1(cinfo, JERR_BAD_POOL_ID, pool_id); /* safety check */
+
+#ifdef MEM_STATS
+  if (cinfo->err->trace_level > 1)
+    print_mem_stats(cinfo, pool_id); /* print pool's memory usage statistics */
+#endif
+
+  /* If freeing IMAGE pool, close any virtual arrays first */
+  if (pool_id == JPOOL_IMAGE) {
+    jvirt_sarray_ptr sptr;
+    jvirt_barray_ptr bptr;
+
+    for (sptr = mem->virt_sarray_list; sptr != NULL; sptr = sptr->next) {
+      if (sptr->b_s_open) {     /* there may be no backing store */
+        sptr->b_s_open = FALSE; /* prevent recursive close if error */
+        (*sptr->b_s_info.close_backing_store) (cinfo, &sptr->b_s_info);
+      }
+    }
+    mem->virt_sarray_list = NULL;
+    for (bptr = mem->virt_barray_list; bptr != NULL; bptr = bptr->next) {
+      if (bptr->b_s_open) {     /* there may be no backing store */
+        bptr->b_s_open = FALSE; /* prevent recursive close if error */
+        (*bptr->b_s_info.close_backing_store) (cinfo, &bptr->b_s_info);
+      }
+    }
+    mem->virt_barray_list = NULL;
+  }
+
+  /* Release large objects */
+  lhdr_ptr = mem->large_list[pool_id];
+  mem->large_list[pool_id] = NULL;
+
+  while (lhdr_ptr != NULL) {
+    large_pool_ptr next_lhdr_ptr = lhdr_ptr->next;
+    space_freed = lhdr_ptr->bytes_used +
+                  lhdr_ptr->bytes_left +
+                  sizeof(large_pool_hdr);
+    jpeg_free_large(cinfo, (void *)lhdr_ptr, space_freed);
+    mem->total_space_allocated -= space_freed;
+    lhdr_ptr = next_lhdr_ptr;
+  }
+
+  /* Release small objects */
+  shdr_ptr = mem->small_list[pool_id];
+  mem->small_list[pool_id] = NULL;
+
+  while (shdr_ptr != NULL) {
+    small_pool_ptr next_shdr_ptr = shdr_ptr->next;
+    space_freed = shdr_ptr->bytes_used + shdr_ptr->bytes_left +
+                  sizeof(small_pool_hdr);
+    jpeg_free_small(cinfo, (void *)shdr_ptr, space_freed);
+    mem->total_space_allocated -= space_freed;
+    shdr_ptr = next_shdr_ptr;
+  }
+}
+
+
+/*
+ * Close up shop entirely.
+ * Note that this cannot be called unless cinfo->mem is non-NULL.
+ */
+
+METHODDEF(void)
+self_destruct(j_common_ptr cinfo)
+{
+  int pool;
+
+  /* Close all backing store, release all memory.
+   * Releasing pools in reverse order might help avoid fragmentation
+   * with some (brain-damaged) malloc libraries.
+   */
+  for (pool = JPOOL_NUMPOOLS - 1; pool >= JPOOL_PERMANENT; pool--) {
+    free_pool(cinfo, pool);
+  }
+
+  /* Release the memory manager control block too. */
+  jpeg_free_small(cinfo, (void *)cinfo->mem, sizeof(my_memory_mgr));
+  cinfo->mem = NULL;            /* ensures I will be called only once */
+
+  jpeg_mem_term(cinfo);         /* system-dependent cleanup */
+}
+
+
+/*
+ * Memory manager initialization.
+ * When this is called, only the error manager pointer is valid in cinfo!
+ */
+
+GLOBAL(void)
+jinit_memory_mgr(j_common_ptr cinfo)
+{
+  my_mem_ptr mem;
+  long max_to_use;
+  int pool;
+  size_t test_mac;
+
+  cinfo->mem = NULL;            /* for safety if init fails */
+
+  /* Check for configuration errors.
+   * sizeof(ALIGN_TYPE) should be a power of 2; otherwise, it probably
+   * doesn't reflect any real hardware alignment requirement.
+   * The test is a little tricky: for X>0, X and X-1 have no one-bits
+   * in common if and only if X is a power of 2, ie has only one one-bit.
+   * Some compilers may give an "unreachable code" warning here; ignore it.
+   */
+  if ((ALIGN_SIZE & (ALIGN_SIZE - 1)) != 0)
+    ERREXIT(cinfo, JERR_BAD_ALIGN_TYPE);
+  /* MAX_ALLOC_CHUNK must be representable as type size_t, and must be
+   * a multiple of ALIGN_SIZE.
+   * Again, an "unreachable code" warning may be ignored here.
+   * But a "constant too large" warning means you need to fix MAX_ALLOC_CHUNK.
+   */
+  test_mac = (size_t)MAX_ALLOC_CHUNK;
+  if ((long)test_mac != MAX_ALLOC_CHUNK ||
+      (MAX_ALLOC_CHUNK % ALIGN_SIZE) != 0)
+    ERREXIT(cinfo, JERR_BAD_ALLOC_CHUNK);
+
+  max_to_use = jpeg_mem_init(cinfo); /* system-dependent initialization */
+
+  /* Attempt to allocate memory manager's control block */
+  mem = (my_mem_ptr)jpeg_get_small(cinfo, sizeof(my_memory_mgr));
+
+  if (mem == NULL) {
+    jpeg_mem_term(cinfo);       /* system-dependent cleanup */
+    ERREXIT1(cinfo, JERR_OUT_OF_MEMORY, 0);
+  }
+
+  /* OK, fill in the method pointers */
+  mem->pub.alloc_small = alloc_small;
+  mem->pub.alloc_large = alloc_large;
+  mem->pub.alloc_sarray = alloc_sarray;
+  mem->pub.alloc_barray = alloc_barray;
+  mem->pub.request_virt_sarray = request_virt_sarray;
+  mem->pub.request_virt_barray = request_virt_barray;
+  mem->pub.realize_virt_arrays = realize_virt_arrays;
+  mem->pub.access_virt_sarray = access_virt_sarray;
+  mem->pub.access_virt_barray = access_virt_barray;
+  mem->pub.free_pool = free_pool;
+  mem->pub.self_destruct = self_destruct;
+
+  /* Make MAX_ALLOC_CHUNK accessible to other modules */
+  mem->pub.max_alloc_chunk = MAX_ALLOC_CHUNK;
+
+  /* Initialize working state */
+  mem->pub.max_memory_to_use = max_to_use;
+
+  for (pool = JPOOL_NUMPOOLS - 1; pool >= JPOOL_PERMANENT; pool--) {
+    mem->small_list[pool] = NULL;
+    mem->large_list[pool] = NULL;
+  }
+  mem->virt_sarray_list = NULL;
+  mem->virt_barray_list = NULL;
+
+  mem->total_space_allocated = sizeof(my_memory_mgr);
+
+  /* Declare ourselves open for business */
+  cinfo->mem = &mem->pub;
+
+  /* Check for an environment variable JPEGMEM; if found, override the
+   * default max_memory setting from jpeg_mem_init.  Note that the
+   * surrounding application may again override this value.
+   * If your system doesn't support getenv(), define NO_GETENV to disable
+   * this feature.
+   */
+#ifndef NO_GETENV
+  {
+    char *memenv;
+
+    if ((memenv = getenv("JPEGMEM")) != NULL) {
+      char ch = 'x';
+
+      if (sscanf(memenv, "%ld%c", &max_to_use, &ch) > 0) {
+        if (ch == 'm' || ch == 'M')
+          max_to_use *= 1000L;
+        mem->pub.max_memory_to_use = max_to_use * 1000L;
+      }
+    }
+  }
+#endif
+
+}
diff --git a/3rdparty/libjpeg/src/jmemnobs.c b/3rdparty/libjpeg/src/jmemnobs.c
new file mode 100644
index 00000000..089be8f5
--- /dev/null
+++ b/3rdparty/libjpeg/src/jmemnobs.c
@@ -0,0 +1,115 @@
+/*
+ * jmemnobs.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1992-1996, Thomas G. Lane.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2017-2018, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file provides a really simple implementation of the system-
+ * dependent portion of the JPEG memory manager.  This implementation
+ * assumes that no backing-store files are needed: all required space
+ * can be obtained from malloc().
+ * This is very portable in the sense that it'll compile on almost anything,
+ * but you'd better have lots of main memory (or virtual memory) if you want
+ * to process big images.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jmemsys.h"            /* import the system-dependent declarations */
+
+#ifndef HAVE_STDLIB_H           /* <stdlib.h> should declare malloc(),free() */
+extern void *malloc(size_t size);
+extern void free(void *ptr);
+#endif
+
+
+/*
+ * Memory allocation and freeing are controlled by the regular library
+ * routines malloc() and free().
+ */
+
+GLOBAL(void *)
+jpeg_get_small(j_common_ptr cinfo, size_t sizeofobject)
+{
+  return (void *)malloc(sizeofobject);
+}
+
+GLOBAL(void)
+jpeg_free_small(j_common_ptr cinfo, void *object, size_t sizeofobject)
+{
+  free(object);
+}
+
+
+/*
+ * "Large" objects are treated the same as "small" ones.
+ */
+
+GLOBAL(void *)
+jpeg_get_large(j_common_ptr cinfo, size_t sizeofobject)
+{
+  return (void *)malloc(sizeofobject);
+}
+
+GLOBAL(void)
+jpeg_free_large(j_common_ptr cinfo, void *object, size_t sizeofobject)
+{
+  free(object);
+}
+
+
+/*
+ * This routine computes the total memory space available for allocation.
+ */
+
+GLOBAL(size_t)
+jpeg_mem_available(j_common_ptr cinfo, size_t min_bytes_needed,
+                   size_t max_bytes_needed, size_t already_allocated)
+{
+  if (cinfo->mem->max_memory_to_use) {
+    if ((size_t)cinfo->mem->max_memory_to_use > already_allocated)
+      return cinfo->mem->max_memory_to_use - already_allocated;
+    else
+      return 0;
+  } else {
+    /* Here we always say, "we got all you want bud!" */
+    return max_bytes_needed;
+  }
+}
+
+
+/*
+ * Backing store (temporary file) management.
+ * Since jpeg_mem_available always promised the moon,
+ * this should never be called and we can just error out.
+ */
+
+GLOBAL(void)
+jpeg_open_backing_store(j_common_ptr cinfo, backing_store_ptr info,
+                        long total_bytes_needed)
+{
+  ERREXIT(cinfo, JERR_NO_BACKING_STORE);
+}
+
+
+/*
+ * These routines take care of any system-dependent initialization and
+ * cleanup required.  Here, there isn't any.
+ */
+
+GLOBAL(long)
+jpeg_mem_init(j_common_ptr cinfo)
+{
+  return 0;                     /* just set max_memory_to_use to 0 */
+}
+
+GLOBAL(void)
+jpeg_mem_term(j_common_ptr cinfo)
+{
+  /* no work */
+}
diff --git a/3rdparty/libjpeg/src/jmemsys.h b/3rdparty/libjpeg/src/jmemsys.h
new file mode 100644
index 00000000..9229550a
--- /dev/null
+++ b/3rdparty/libjpeg/src/jmemsys.h
@@ -0,0 +1,178 @@
+/*
+ * jmemsys.h
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1992-1997, Thomas G. Lane.
+ * It was modified by The libjpeg-turbo Project to include only code and
+ * information relevant to libjpeg-turbo.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This include file defines the interface between the system-independent
+ * and system-dependent portions of the JPEG memory manager.  No other
+ * modules need include it.  (The system-independent portion is jmemmgr.c;
+ * there are several different versions of the system-dependent portion.)
+ *
+ * This file works as-is for the system-dependent memory managers supplied
+ * in the IJG distribution.  You may need to modify it if you write a
+ * custom memory manager.  If system-dependent changes are needed in
+ * this file, the best method is to #ifdef them based on a configuration
+ * symbol supplied in jconfig.h.
+ */
+
+
+/*
+ * These two functions are used to allocate and release small chunks of
+ * memory.  (Typically the total amount requested through jpeg_get_small is
+ * no more than 20K or so; this will be requested in chunks of a few K each.)
+ * Behavior should be the same as for the standard library functions malloc
+ * and free; in particular, jpeg_get_small must return NULL on failure.
+ * On most systems, these ARE malloc and free.  jpeg_free_small is passed the
+ * size of the object being freed, just in case it's needed.
+ */
+
+EXTERN(void *) jpeg_get_small(j_common_ptr cinfo, size_t sizeofobject);
+EXTERN(void) jpeg_free_small(j_common_ptr cinfo, void *object,
+                             size_t sizeofobject);
+
+/*
+ * These two functions are used to allocate and release large chunks of
+ * memory (up to the total free space designated by jpeg_mem_available).
+ * These are identical to the jpeg_get/free_small routines; but we keep them
+ * separate anyway, in case a different allocation strategy is desirable for
+ * large chunks.
+ */
+
+EXTERN(void *) jpeg_get_large(j_common_ptr cinfo, size_t sizeofobject);
+EXTERN(void) jpeg_free_large(j_common_ptr cinfo, void *object,
+                             size_t sizeofobject);
+
+/*
+ * The macro MAX_ALLOC_CHUNK designates the maximum number of bytes that may
+ * be requested in a single call to jpeg_get_large (and jpeg_get_small for that
+ * matter, but that case should never come into play).  This macro was needed
+ * to model the 64Kb-segment-size limit of far addressing on 80x86 machines.
+ * On machines with flat address spaces, any large constant may be used.
+ *
+ * NB: jmemmgr.c expects that MAX_ALLOC_CHUNK will be representable as type
+ * size_t and will be a multiple of sizeof(align_type).
+ */
+
+#ifndef MAX_ALLOC_CHUNK         /* may be overridden in jconfig.h */
+#define MAX_ALLOC_CHUNK  1000000000L
+#endif
+
+/*
+ * This routine computes the total space still available for allocation by
+ * jpeg_get_large.  If more space than this is needed, backing store will be
+ * used.  NOTE: any memory already allocated must not be counted.
+ *
+ * There is a minimum space requirement, corresponding to the minimum
+ * feasible buffer sizes; jmemmgr.c will request that much space even if
+ * jpeg_mem_available returns zero.  The maximum space needed, enough to hold
+ * all working storage in memory, is also passed in case it is useful.
+ * Finally, the total space already allocated is passed.  If no better
+ * method is available, cinfo->mem->max_memory_to_use - already_allocated
+ * is often a suitable calculation.
+ *
+ * It is OK for jpeg_mem_available to underestimate the space available
+ * (that'll just lead to more backing-store access than is really necessary).
+ * However, an overestimate will lead to failure.  Hence it's wise to subtract
+ * a slop factor from the true available space.  5% should be enough.
+ *
+ * On machines with lots of virtual memory, any large constant may be returned.
+ * Conversely, zero may be returned to always use the minimum amount of memory.
+ */
+
+EXTERN(size_t) jpeg_mem_available(j_common_ptr cinfo, size_t min_bytes_needed,
+                                  size_t max_bytes_needed,
+                                  size_t already_allocated);
+
+
+/*
+ * This structure holds whatever state is needed to access a single
+ * backing-store object.  The read/write/close method pointers are called
+ * by jmemmgr.c to manipulate the backing-store object; all other fields
+ * are private to the system-dependent backing store routines.
+ */
+
+#define TEMP_NAME_LENGTH   64   /* max length of a temporary file's name */
+
+
+#ifdef USE_MSDOS_MEMMGR         /* DOS-specific junk */
+
+typedef unsigned short XMSH;    /* type of extended-memory handles */
+typedef unsigned short EMSH;    /* type of expanded-memory handles */
+
+typedef union {
+  short file_handle;            /* DOS file handle if it's a temp file */
+  XMSH xms_handle;              /* handle if it's a chunk of XMS */
+  EMSH ems_handle;              /* handle if it's a chunk of EMS */
+} handle_union;
+
+#endif /* USE_MSDOS_MEMMGR */
+
+#ifdef USE_MAC_MEMMGR           /* Mac-specific junk */
+#include <Files.h>
+#endif /* USE_MAC_MEMMGR */
+
+
+typedef struct backing_store_struct *backing_store_ptr;
+
+typedef struct backing_store_struct {
+  /* Methods for reading/writing/closing this backing-store object */
+  void (*read_backing_store) (j_common_ptr cinfo, backing_store_ptr info,
+                              void *buffer_address, long file_offset,
+                              long byte_count);
+  void (*write_backing_store) (j_common_ptr cinfo, backing_store_ptr info,
+                               void *buffer_address, long file_offset,
+                               long byte_count);
+  void (*close_backing_store) (j_common_ptr cinfo, backing_store_ptr info);
+
+  /* Private fields for system-dependent backing-store management */
+#ifdef USE_MSDOS_MEMMGR
+  /* For the MS-DOS manager (jmemdos.c), we need: */
+  handle_union handle;          /* reference to backing-store storage object */
+  char temp_name[TEMP_NAME_LENGTH]; /* name if it's a file */
+#else
+#ifdef USE_MAC_MEMMGR
+  /* For the Mac manager (jmemmac.c), we need: */
+  short temp_file;              /* file reference number to temp file */
+  FSSpec tempSpec;              /* the FSSpec for the temp file */
+  char temp_name[TEMP_NAME_LENGTH]; /* name if it's a file */
+#else
+  /* For a typical implementation with temp files, we need: */
+  FILE *temp_file;              /* stdio reference to temp file */
+  char temp_name[TEMP_NAME_LENGTH]; /* name of temp file */
+#endif
+#endif
+} backing_store_info;
+
+
+/*
+ * Initial opening of a backing-store object.  This must fill in the
+ * read/write/close pointers in the object.  The read/write routines
+ * may take an error exit if the specified maximum file size is exceeded.
+ * (If jpeg_mem_available always returns a large value, this routine can
+ * just take an error exit.)
+ */
+
+EXTERN(void) jpeg_open_backing_store(j_common_ptr cinfo,
+                                     backing_store_ptr info,
+                                     long total_bytes_needed);
+
+
+/*
+ * These routines take care of any system-dependent initialization and
+ * cleanup required.  jpeg_mem_init will be called before anything is
+ * allocated (and, therefore, nothing in cinfo is of use except the error
+ * manager pointer).  It should return a suitable default value for
+ * max_memory_to_use; this may subsequently be overridden by the surrounding
+ * application.  (Note that max_memory_to_use is only important if
+ * jpeg_mem_available chooses to consult it ... no one else will.)
+ * jpeg_mem_term may assume that all requested memory has been freed and that
+ * all opened backing-store objects have been closed.
+ */
+
+EXTERN(long) jpeg_mem_init(j_common_ptr cinfo);
+EXTERN(void) jpeg_mem_term(j_common_ptr cinfo);
diff --git a/3rdparty/libjpeg/src/jmorecfg.h b/3rdparty/libjpeg/src/jmorecfg.h
new file mode 100644
index 00000000..fb3a9cf4
--- /dev/null
+++ b/3rdparty/libjpeg/src/jmorecfg.h
@@ -0,0 +1,386 @@
+/*
+ * jmorecfg.h
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1991-1997, Thomas G. Lane.
+ * Modified 1997-2009 by Guido Vollbeding.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2009, 2011, 2014-2015, 2018, 2020, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains additional configuration options that customize the
+ * JPEG software for special applications or support machine-dependent
+ * optimizations.  Most users will not need to touch this file.
+ */
+
+
+/*
+ * Maximum number of components (color channels) allowed in JPEG image.
+ * To meet the letter of Rec. ITU-T T.81 | ISO/IEC 10918-1, set this to 255.
+ * However, darn few applications need more than 4 channels (maybe 5 for CMYK +
+ * alpha mask).  We recommend 10 as a reasonable compromise; use 4 if you are
+ * really short on memory.  (Each allowed component costs a hundred or so
+ * bytes of storage, whether actually used in an image or not.)
+ */
+
+#define MAX_COMPONENTS  10      /* maximum number of image components */
+
+
+/*
+ * Basic data types.
+ * You may need to change these if you have a machine with unusual data
+ * type sizes; for example, "char" not 8 bits, "short" not 16 bits,
+ * or "long" not 32 bits.  We don't care whether "int" is 16 or 32 bits,
+ * but it had better be at least 16.
+ */
+
+/* Representation of a single sample (pixel element value).
+ * We frequently allocate large arrays of these, so it's important to keep
+ * them small.  But if you have memory to burn and access to char or short
+ * arrays is very slow on your hardware, you might want to change these.
+ */
+
+#if BITS_IN_JSAMPLE == 8
+/* JSAMPLE should be the smallest type that will hold the values 0..255.
+ */
+
+typedef unsigned char JSAMPLE;
+#define GETJSAMPLE(value)  ((int)(value))
+
+#define MAXJSAMPLE      255
+#define CENTERJSAMPLE   128
+
+#endif /* BITS_IN_JSAMPLE == 8 */
+
+
+#if BITS_IN_JSAMPLE == 12
+/* JSAMPLE should be the smallest type that will hold the values 0..4095.
+ * On nearly all machines "short" will do nicely.
+ */
+
+typedef short JSAMPLE;
+#define GETJSAMPLE(value)  ((int)(value))
+
+#define MAXJSAMPLE      4095
+#define CENTERJSAMPLE   2048
+
+#endif /* BITS_IN_JSAMPLE == 12 */
+
+
+/* Representation of a DCT frequency coefficient.
+ * This should be a signed value of at least 16 bits; "short" is usually OK.
+ * Again, we allocate large arrays of these, but you can change to int
+ * if you have memory to burn and "short" is really slow.
+ */
+
+typedef short JCOEF;
+
+
+/* Compressed datastreams are represented as arrays of JOCTET.
+ * These must be EXACTLY 8 bits wide, at least once they are written to
+ * external storage.  Note that when using the stdio data source/destination
+ * managers, this is also the data type passed to fread/fwrite.
+ */
+
+typedef unsigned char JOCTET;
+#define GETJOCTET(value)  (value)
+
+
+/* These typedefs are used for various table entries and so forth.
+ * They must be at least as wide as specified; but making them too big
+ * won't cost a huge amount of memory, so we don't provide special
+ * extraction code like we did for JSAMPLE.  (In other words, these
+ * typedefs live at a different point on the speed/space tradeoff curve.)
+ */
+
+/* UINT8 must hold at least the values 0..255. */
+
+typedef unsigned char UINT8;
+
+/* UINT16 must hold at least the values 0..65535. */
+
+#ifdef HAVE_UNSIGNED_SHORT
+typedef unsigned short UINT16;
+#else /* not HAVE_UNSIGNED_SHORT */
+typedef unsigned int UINT16;
+#endif /* HAVE_UNSIGNED_SHORT */
+
+/* INT16 must hold at least the values -32768..32767. */
+
+#ifndef XMD_H                   /* X11/xmd.h correctly defines INT16 */
+typedef short INT16;
+#endif
+
+/* INT32 must hold at least signed 32-bit values.
+ *
+ * NOTE: The INT32 typedef dates back to libjpeg v5 (1994.)  Integers were
+ * sometimes 16-bit back then (MS-DOS), which is why INT32 is typedef'd to
+ * long.  It also wasn't common (or at least as common) in 1994 for INT32 to be
+ * defined by platform headers.  Since then, however, INT32 is defined in
+ * several other common places:
+ *
+ * Xmd.h (X11 header) typedefs INT32 to int on 64-bit platforms and long on
+ * 32-bit platforms (i.e always a 32-bit signed type.)
+ *
+ * basetsd.h (Win32 header) typedefs INT32 to int (always a 32-bit signed type
+ * on modern platforms.)
+ *
+ * qglobal.h (Qt header) typedefs INT32 to int (always a 32-bit signed type on
+ * modern platforms.)
+ *
+ * This is a recipe for conflict, since "long" and "int" aren't always
+ * compatible types.  Since the definition of INT32 has technically been part
+ * of the libjpeg API for more than 20 years, we can't remove it, but we do not
+ * use it internally any longer.  We instead define a separate type (JLONG)
+ * for internal use, which ensures that internal behavior will always be the
+ * same regardless of any external headers that may be included.
+ */
+
+#ifndef XMD_H                   /* X11/xmd.h correctly defines INT32 */
+#ifndef _BASETSD_H_             /* Microsoft defines it in basetsd.h */
+#ifndef _BASETSD_H              /* MinGW is slightly different */
+#ifndef QGLOBAL_H               /* Qt defines it in qglobal.h */
+typedef long INT32;
+#endif
+#endif
+#endif
+#endif
+
+/* Datatype used for image dimensions.  The JPEG standard only supports
+ * images up to 64K*64K due to 16-bit fields in SOF markers.  Therefore
+ * "unsigned int" is sufficient on all machines.  However, if you need to
+ * handle larger images and you don't mind deviating from the spec, you
+ * can change this datatype.  (Note that changing this datatype will
+ * potentially require modifying the SIMD code.  The x86-64 SIMD extensions,
+ * in particular, assume a 32-bit JDIMENSION.)
+ */
+
+typedef unsigned int JDIMENSION;
+
+#define JPEG_MAX_DIMENSION  65500L  /* a tad under 64K to prevent overflows */
+
+
+/* These macros are used in all function definitions and extern declarations.
+ * You could modify them if you need to change function linkage conventions;
+ * in particular, you'll need to do that to make the library a Windows DLL.
+ * Another application is to make all functions global for use with debuggers
+ * or code profilers that require it.
+ */
+
+/* a function called through method pointers: */
+#define METHODDEF(type)         static type
+/* a function used only in its module: */
+#define LOCAL(type)             static type
+/* a function referenced thru EXTERNs: */
+#define GLOBAL(type)            type
+/* a reference to a GLOBAL function: */
+#define EXTERN(type)            extern type
+
+
+/* Originally, this macro was used as a way of defining function prototypes
+ * for both modern compilers as well as older compilers that did not support
+ * prototype parameters.  libjpeg-turbo has never supported these older,
+ * non-ANSI compilers, but the macro is still included because there is some
+ * software out there that uses it.
+ */
+
+#define JMETHOD(type, methodname, arglist)  type (*methodname) arglist
+
+
+/* libjpeg-turbo no longer supports platforms that have far symbols (MS-DOS),
+ * but again, some software relies on this macro.
+ */
+
+#undef FAR
+#define FAR
+
+
+/*
+ * On a few systems, type boolean and/or its values FALSE, TRUE may appear
+ * in standard header files.  Or you may have conflicts with application-
+ * specific header files that you want to include together with these files.
+ * Defining HAVE_BOOLEAN before including jpeglib.h should make it work.
+ */
+
+#ifndef HAVE_BOOLEAN
+typedef int boolean;
+#endif
+#ifndef FALSE                   /* in case these macros already exist */
+#define FALSE   0               /* values of boolean */
+#endif
+#ifndef TRUE
+#define TRUE    1
+#endif
+
+
+/*
+ * The remaining options affect code selection within the JPEG library,
+ * but they don't need to be visible to most applications using the library.
+ * To minimize application namespace pollution, the symbols won't be
+ * defined unless JPEG_INTERNALS or JPEG_INTERNAL_OPTIONS has been defined.
+ */
+
+#ifdef JPEG_INTERNALS
+#define JPEG_INTERNAL_OPTIONS
+#endif
+
+#ifdef JPEG_INTERNAL_OPTIONS
+
+
+/*
+ * These defines indicate whether to include various optional functions.
+ * Undefining some of these symbols will produce a smaller but less capable
+ * library.  Note that you can leave certain source files out of the
+ * compilation/linking process if you've #undef'd the corresponding symbols.
+ * (You may HAVE to do that if your compiler doesn't like null source files.)
+ */
+
+/* Capability options common to encoder and decoder: */
+
+#define DCT_ISLOW_SUPPORTED     /* accurate integer method */
+#define DCT_IFAST_SUPPORTED     /* less accurate int method [legacy feature] */
+#define DCT_FLOAT_SUPPORTED     /* floating-point method [legacy feature] */
+
+/* Encoder capability options: */
+
+#define C_MULTISCAN_FILES_SUPPORTED /* Multiple-scan JPEG files? */
+#define C_PROGRESSIVE_SUPPORTED     /* Progressive JPEG? (Requires MULTISCAN)*/
+#define ENTROPY_OPT_SUPPORTED       /* Optimization of entropy coding parms? */
+/* Note: if you selected 12-bit data precision, it is dangerous to turn off
+ * ENTROPY_OPT_SUPPORTED.  The standard Huffman tables are only good for 8-bit
+ * precision, so jchuff.c normally uses entropy optimization to compute
+ * usable tables for higher precision.  If you don't want to do optimization,
+ * you'll have to supply different default Huffman tables.
+ * The exact same statements apply for progressive JPEG: the default tables
+ * don't work for progressive mode.  (This may get fixed, however.)
+ */
+#define INPUT_SMOOTHING_SUPPORTED   /* Input image smoothing option? */
+
+/* Decoder capability options: */
+
+#define D_MULTISCAN_FILES_SUPPORTED /* Multiple-scan JPEG files? */
+#define D_PROGRESSIVE_SUPPORTED     /* Progressive JPEG? (Requires MULTISCAN)*/
+#define SAVE_MARKERS_SUPPORTED      /* jpeg_save_markers() needed? */
+#define BLOCK_SMOOTHING_SUPPORTED   /* Block smoothing? (Progressive only) */
+#define IDCT_SCALING_SUPPORTED      /* Output rescaling via IDCT? */
+#undef  UPSAMPLE_SCALING_SUPPORTED  /* Output rescaling at upsample stage? */
+#define UPSAMPLE_MERGING_SUPPORTED  /* Fast path for sloppy upsampling? */
+#define QUANT_1PASS_SUPPORTED       /* 1-pass color quantization? */
+#define QUANT_2PASS_SUPPORTED       /* 2-pass color quantization? */
+
+/* more capability options later, no doubt */
+
+
+/*
+ * The RGB_RED, RGB_GREEN, RGB_BLUE, and RGB_PIXELSIZE macros are a vestigial
+ * feature of libjpeg.  The idea was that, if an application developer needed
+ * to compress from/decompress to a BGR/BGRX/RGBX/XBGR/XRGB buffer, they could
+ * change these macros, rebuild libjpeg, and link their application statically
+ * with it.  In reality, few people ever did this, because there were some
+ * severe restrictions involved (cjpeg and djpeg no longer worked properly,
+ * compressing/decompressing RGB JPEGs no longer worked properly, and the color
+ * quantizer wouldn't work with pixel sizes other than 3.)  Furthermore, since
+ * all of the O/S-supplied versions of libjpeg were built with the default
+ * values of RGB_RED, RGB_GREEN, RGB_BLUE, and RGB_PIXELSIZE, many applications
+ * have come to regard these values as immutable.
+ *
+ * The libjpeg-turbo colorspace extensions provide a much cleaner way of
+ * compressing from/decompressing to buffers with arbitrary component orders
+ * and pixel sizes.  Thus, we do not support changing the values of RGB_RED,
+ * RGB_GREEN, RGB_BLUE, or RGB_PIXELSIZE.  In addition to the restrictions
+ * listed above, changing these values will also break the SIMD extensions and
+ * the regression tests.
+ */
+
+#define RGB_RED         0       /* Offset of Red in an RGB scanline element */
+#define RGB_GREEN       1       /* Offset of Green */
+#define RGB_BLUE        2       /* Offset of Blue */
+#define RGB_PIXELSIZE   3       /* JSAMPLEs per RGB scanline element */
+
+#define JPEG_NUMCS  17
+
+#define EXT_RGB_RED         0
+#define EXT_RGB_GREEN       1
+#define EXT_RGB_BLUE        2
+#define EXT_RGB_PIXELSIZE   3
+
+#define EXT_RGBX_RED        0
+#define EXT_RGBX_GREEN      1
+#define EXT_RGBX_BLUE       2
+#define EXT_RGBX_PIXELSIZE  4
+
+#define EXT_BGR_RED         2
+#define EXT_BGR_GREEN       1
+#define EXT_BGR_BLUE        0
+#define EXT_BGR_PIXELSIZE   3
+
+#define EXT_BGRX_RED        2
+#define EXT_BGRX_GREEN      1
+#define EXT_BGRX_BLUE       0
+#define EXT_BGRX_PIXELSIZE  4
+
+#define EXT_XBGR_RED        3
+#define EXT_XBGR_GREEN      2
+#define EXT_XBGR_BLUE       1
+#define EXT_XBGR_PIXELSIZE  4
+
+#define EXT_XRGB_RED        1
+#define EXT_XRGB_GREEN      2
+#define EXT_XRGB_BLUE       3
+#define EXT_XRGB_PIXELSIZE  4
+
+static const int rgb_red[JPEG_NUMCS] = {
+  -1, -1, RGB_RED, -1, -1, -1, EXT_RGB_RED, EXT_RGBX_RED,
+  EXT_BGR_RED, EXT_BGRX_RED, EXT_XBGR_RED, EXT_XRGB_RED,
+  EXT_RGBX_RED, EXT_BGRX_RED, EXT_XBGR_RED, EXT_XRGB_RED,
+  -1
+};
+
+static const int rgb_green[JPEG_NUMCS] = {
+  -1, -1, RGB_GREEN, -1, -1, -1, EXT_RGB_GREEN, EXT_RGBX_GREEN,
+  EXT_BGR_GREEN, EXT_BGRX_GREEN, EXT_XBGR_GREEN, EXT_XRGB_GREEN,
+  EXT_RGBX_GREEN, EXT_BGRX_GREEN, EXT_XBGR_GREEN, EXT_XRGB_GREEN,
+  -1
+};
+
+static const int rgb_blue[JPEG_NUMCS] = {
+  -1, -1, RGB_BLUE, -1, -1, -1, EXT_RGB_BLUE, EXT_RGBX_BLUE,
+  EXT_BGR_BLUE, EXT_BGRX_BLUE, EXT_XBGR_BLUE, EXT_XRGB_BLUE,
+  EXT_RGBX_BLUE, EXT_BGRX_BLUE, EXT_XBGR_BLUE, EXT_XRGB_BLUE,
+  -1
+};
+
+static const int rgb_pixelsize[JPEG_NUMCS] = {
+  -1, -1, RGB_PIXELSIZE, -1, -1, -1, EXT_RGB_PIXELSIZE, EXT_RGBX_PIXELSIZE,
+  EXT_BGR_PIXELSIZE, EXT_BGRX_PIXELSIZE, EXT_XBGR_PIXELSIZE, EXT_XRGB_PIXELSIZE,
+  EXT_RGBX_PIXELSIZE, EXT_BGRX_PIXELSIZE, EXT_XBGR_PIXELSIZE, EXT_XRGB_PIXELSIZE,
+  -1
+};
+
+/* Definitions for speed-related optimizations. */
+
+/* On some machines (notably 68000 series) "int" is 32 bits, but multiplying
+ * two 16-bit shorts is faster than multiplying two ints.  Define MULTIPLIER
+ * as short on such a machine.  MULTIPLIER must be at least 16 bits wide.
+ */
+
+#ifndef MULTIPLIER
+#ifndef WITH_SIMD
+#define MULTIPLIER  int         /* type for fastest integer multiply */
+#else
+#define MULTIPLIER  short       /* prefer 16-bit with SIMD for parellelism */
+#endif
+#endif
+
+
+/* FAST_FLOAT should be either float or double, whichever is done faster
+ * by your compiler.  (Note that this type is only used in the floating point
+ * DCT routines, so it only matters if you've defined DCT_FLOAT_SUPPORTED.)
+ */
+
+#ifndef FAST_FLOAT
+#define FAST_FLOAT  float
+#endif
+
+#endif /* JPEG_INTERNAL_OPTIONS */
diff --git a/3rdparty/libjpeg/src/jpeg_nbits_table.h b/3rdparty/libjpeg/src/jpeg_nbits_table.h
new file mode 100644
index 00000000..fcf73878
--- /dev/null
+++ b/3rdparty/libjpeg/src/jpeg_nbits_table.h
@@ -0,0 +1,4098 @@
+static const unsigned char jpeg_nbits_table[65536] = {
+   0,  1,  2,  2,  3,  3,  3,  3,  4,  4,  4,  4,  4,  4,  4,  4,
+   5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,
+   6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,
+   6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,
+   7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
+   7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
+   7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
+   7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
+   8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,
+   8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,
+   8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,
+   8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,
+   8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,
+   8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,
+   8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,
+   8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,
+   9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
+   9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
+   9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
+   9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
+   9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
+   9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
+   9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
+   9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
+   9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
+   9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
+   9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
+   9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
+   9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
+   9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
+   9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
+   9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
+  10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
+  10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
+  10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
+  10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
+  10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
+  10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
+  10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
+  10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
+  10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
+  10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
+  10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
+  10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
+  10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
+  10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
+  10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
+  10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
+  10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
+  10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
+  10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
+  10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
+  10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
+  10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
+  10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
+  10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
+  10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
+  10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
+  10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
+  10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
+  10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
+  10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
+  10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
+  10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
+  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+  16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16
+};
diff --git a/3rdparty/libjpeg/src/jpegcomp.h b/3rdparty/libjpeg/src/jpegcomp.h
new file mode 100644
index 00000000..c4834ac0
--- /dev/null
+++ b/3rdparty/libjpeg/src/jpegcomp.h
@@ -0,0 +1,32 @@
+/*
+ * jpegcomp.h
+ *
+ * Copyright (C) 2010, 2020, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * JPEG compatibility macros
+ * These declarations are considered internal to the JPEG library; most
+ * applications using the library shouldn't need to include this file.
+ */
+
+#if JPEG_LIB_VERSION >= 70
+#define _DCT_scaled_size  DCT_h_scaled_size
+#define _DCT_h_scaled_size  DCT_h_scaled_size
+#define _DCT_v_scaled_size  DCT_v_scaled_size
+#define _min_DCT_scaled_size  min_DCT_h_scaled_size
+#define _min_DCT_h_scaled_size  min_DCT_h_scaled_size
+#define _min_DCT_v_scaled_size  min_DCT_v_scaled_size
+#define _jpeg_width  jpeg_width
+#define _jpeg_height  jpeg_height
+#define JERR_ARITH_NOTIMPL  JERR_NOT_COMPILED
+#else
+#define _DCT_scaled_size  DCT_scaled_size
+#define _DCT_h_scaled_size  DCT_scaled_size
+#define _DCT_v_scaled_size  DCT_scaled_size
+#define _min_DCT_scaled_size  min_DCT_scaled_size
+#define _min_DCT_h_scaled_size  min_DCT_scaled_size
+#define _min_DCT_v_scaled_size  min_DCT_scaled_size
+#define _jpeg_width  image_width
+#define _jpeg_height  image_height
+#endif
diff --git a/3rdparty/libjpeg/src/jpegint.h b/3rdparty/libjpeg/src/jpegint.h
new file mode 100644
index 00000000..195fbcb9
--- /dev/null
+++ b/3rdparty/libjpeg/src/jpegint.h
@@ -0,0 +1,371 @@
+/*
+ * jpegint.h
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1991-1997, Thomas G. Lane.
+ * Modified 1997-2009 by Guido Vollbeding.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2015-2016, 2019, D. R. Commander.
+ * Copyright (C) 2015, Google, Inc.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file provides common declarations for the various JPEG modules.
+ * These declarations are considered internal to the JPEG library; most
+ * applications using the library shouldn't need to include this file.
+ */
+
+
+/* Declarations for both compression & decompression */
+
+typedef enum {            /* Operating modes for buffer controllers */
+  JBUF_PASS_THRU,         /* Plain stripwise operation */
+  /* Remaining modes require a full-image buffer to have been created */
+  JBUF_SAVE_SOURCE,       /* Run source subobject only, save output */
+  JBUF_CRANK_DEST,        /* Run dest subobject only, using saved data */
+  JBUF_SAVE_AND_PASS      /* Run both subobjects, save output */
+} J_BUF_MODE;
+
+/* Values of global_state field (jdapi.c has some dependencies on ordering!) */
+#define CSTATE_START     100    /* after create_compress */
+#define CSTATE_SCANNING  101    /* start_compress done, write_scanlines OK */
+#define CSTATE_RAW_OK    102    /* start_compress done, write_raw_data OK */
+#define CSTATE_WRCOEFS   103    /* jpeg_write_coefficients done */
+#define DSTATE_START     200    /* after create_decompress */
+#define DSTATE_INHEADER  201    /* reading header markers, no SOS yet */
+#define DSTATE_READY     202    /* found SOS, ready for start_decompress */
+#define DSTATE_PRELOAD   203    /* reading multiscan file in start_decompress*/
+#define DSTATE_PRESCAN   204    /* performing dummy pass for 2-pass quant */
+#define DSTATE_SCANNING  205    /* start_decompress done, read_scanlines OK */
+#define DSTATE_RAW_OK    206    /* start_decompress done, read_raw_data OK */
+#define DSTATE_BUFIMAGE  207    /* expecting jpeg_start_output */
+#define DSTATE_BUFPOST   208    /* looking for SOS/EOI in jpeg_finish_output */
+#define DSTATE_RDCOEFS   209    /* reading file in jpeg_read_coefficients */
+#define DSTATE_STOPPING  210    /* looking for EOI in jpeg_finish_decompress */
+
+
+/* JLONG must hold at least signed 32-bit values. */
+typedef long JLONG;
+
+
+/*
+ * Left shift macro that handles a negative operand without causing any
+ * sanitizer warnings
+ */
+
+#define LEFT_SHIFT(a, b)  ((JLONG)((unsigned long)(a) << (b)))
+
+
+/* Declarations for compression modules */
+
+/* Master control module */
+struct jpeg_comp_master {
+  void (*prepare_for_pass) (j_compress_ptr cinfo);
+  void (*pass_startup) (j_compress_ptr cinfo);
+  void (*finish_pass) (j_compress_ptr cinfo);
+
+  /* State variables made visible to other modules */
+  boolean call_pass_startup;    /* True if pass_startup must be called */
+  boolean is_last_pass;         /* True during last pass */
+};
+
+/* Main buffer control (downsampled-data buffer) */
+struct jpeg_c_main_controller {
+  void (*start_pass) (j_compress_ptr cinfo, J_BUF_MODE pass_mode);
+  void (*process_data) (j_compress_ptr cinfo, JSAMPARRAY input_buf,
+                        JDIMENSION *in_row_ctr, JDIMENSION in_rows_avail);
+};
+
+/* Compression preprocessing (downsampling input buffer control) */
+struct jpeg_c_prep_controller {
+  void (*start_pass) (j_compress_ptr cinfo, J_BUF_MODE pass_mode);
+  void (*pre_process_data) (j_compress_ptr cinfo, JSAMPARRAY input_buf,
+                            JDIMENSION *in_row_ctr, JDIMENSION in_rows_avail,
+                            JSAMPIMAGE output_buf,
+                            JDIMENSION *out_row_group_ctr,
+                            JDIMENSION out_row_groups_avail);
+};
+
+/* Coefficient buffer control */
+struct jpeg_c_coef_controller {
+  void (*start_pass) (j_compress_ptr cinfo, J_BUF_MODE pass_mode);
+  boolean (*compress_data) (j_compress_ptr cinfo, JSAMPIMAGE input_buf);
+};
+
+/* Colorspace conversion */
+struct jpeg_color_converter {
+  void (*start_pass) (j_compress_ptr cinfo);
+  void (*color_convert) (j_compress_ptr cinfo, JSAMPARRAY input_buf,
+                         JSAMPIMAGE output_buf, JDIMENSION output_row,
+                         int num_rows);
+};
+
+/* Downsampling */
+struct jpeg_downsampler {
+  void (*start_pass) (j_compress_ptr cinfo);
+  void (*downsample) (j_compress_ptr cinfo, JSAMPIMAGE input_buf,
+                      JDIMENSION in_row_index, JSAMPIMAGE output_buf,
+                      JDIMENSION out_row_group_index);
+
+  boolean need_context_rows;    /* TRUE if need rows above & below */
+};
+
+/* Forward DCT (also controls coefficient quantization) */
+struct jpeg_forward_dct {
+  void (*start_pass) (j_compress_ptr cinfo);
+  /* perhaps this should be an array??? */
+  void (*forward_DCT) (j_compress_ptr cinfo, jpeg_component_info *compptr,
+                       JSAMPARRAY sample_data, JBLOCKROW coef_blocks,
+                       JDIMENSION start_row, JDIMENSION start_col,
+                       JDIMENSION num_blocks);
+};
+
+/* Entropy encoding */
+struct jpeg_entropy_encoder {
+  void (*start_pass) (j_compress_ptr cinfo, boolean gather_statistics);
+  boolean (*encode_mcu) (j_compress_ptr cinfo, JBLOCKROW *MCU_data);
+  void (*finish_pass) (j_compress_ptr cinfo);
+};
+
+/* Marker writing */
+struct jpeg_marker_writer {
+  void (*write_file_header) (j_compress_ptr cinfo);
+  void (*write_frame_header) (j_compress_ptr cinfo);
+  void (*write_scan_header) (j_compress_ptr cinfo);
+  void (*write_file_trailer) (j_compress_ptr cinfo);
+  void (*write_tables_only) (j_compress_ptr cinfo);
+  /* These routines are exported to allow insertion of extra markers */
+  /* Probably only COM and APPn markers should be written this way */
+  void (*write_marker_header) (j_compress_ptr cinfo, int marker,
+                               unsigned int datalen);
+  void (*write_marker_byte) (j_compress_ptr cinfo, int val);
+};
+
+
+/* Declarations for decompression modules */
+
+/* Master control module */
+struct jpeg_decomp_master {
+  void (*prepare_for_output_pass) (j_decompress_ptr cinfo);
+  void (*finish_output_pass) (j_decompress_ptr cinfo);
+
+  /* State variables made visible to other modules */
+  boolean is_dummy_pass;        /* True during 1st pass for 2-pass quant */
+
+  /* Partial decompression variables */
+  JDIMENSION first_iMCU_col;
+  JDIMENSION last_iMCU_col;
+  JDIMENSION first_MCU_col[MAX_COMPONENTS];
+  JDIMENSION last_MCU_col[MAX_COMPONENTS];
+  boolean jinit_upsampler_no_alloc;
+
+  /* Last iMCU row that was successfully decoded */
+  JDIMENSION last_good_iMCU_row;
+};
+
+/* Input control module */
+struct jpeg_input_controller {
+  int (*consume_input) (j_decompress_ptr cinfo);
+  void (*reset_input_controller) (j_decompress_ptr cinfo);
+  void (*start_input_pass) (j_decompress_ptr cinfo);
+  void (*finish_input_pass) (j_decompress_ptr cinfo);
+
+  /* State variables made visible to other modules */
+  boolean has_multiple_scans;   /* True if file has multiple scans */
+  boolean eoi_reached;          /* True when EOI has been consumed */
+};
+
+/* Main buffer control (downsampled-data buffer) */
+struct jpeg_d_main_controller {
+  void (*start_pass) (j_decompress_ptr cinfo, J_BUF_MODE pass_mode);
+  void (*process_data) (j_decompress_ptr cinfo, JSAMPARRAY output_buf,
+                        JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail);
+};
+
+/* Coefficient buffer control */
+struct jpeg_d_coef_controller {
+  void (*start_input_pass) (j_decompress_ptr cinfo);
+  int (*consume_data) (j_decompress_ptr cinfo);
+  void (*start_output_pass) (j_decompress_ptr cinfo);
+  int (*decompress_data) (j_decompress_ptr cinfo, JSAMPIMAGE output_buf);
+  /* Pointer to array of coefficient virtual arrays, or NULL if none */
+  jvirt_barray_ptr *coef_arrays;
+};
+
+/* Decompression postprocessing (color quantization buffer control) */
+struct jpeg_d_post_controller {
+  void (*start_pass) (j_decompress_ptr cinfo, J_BUF_MODE pass_mode);
+  void (*post_process_data) (j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
+                             JDIMENSION *in_row_group_ctr,
+                             JDIMENSION in_row_groups_avail,
+                             JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
+                             JDIMENSION out_rows_avail);
+};
+
+/* Marker reading & parsing */
+struct jpeg_marker_reader {
+  void (*reset_marker_reader) (j_decompress_ptr cinfo);
+  /* Read markers until SOS or EOI.
+   * Returns same codes as are defined for jpeg_consume_input:
+   * JPEG_SUSPENDED, JPEG_REACHED_SOS, or JPEG_REACHED_EOI.
+   */
+  int (*read_markers) (j_decompress_ptr cinfo);
+  /* Read a restart marker --- exported for use by entropy decoder only */
+  jpeg_marker_parser_method read_restart_marker;
+
+  /* State of marker reader --- nominally internal, but applications
+   * supplying COM or APPn handlers might like to know the state.
+   */
+  boolean saw_SOI;              /* found SOI? */
+  boolean saw_SOF;              /* found SOF? */
+  int next_restart_num;         /* next restart number expected (0-7) */
+  unsigned int discarded_bytes; /* # of bytes skipped looking for a marker */
+};
+
+/* Entropy decoding */
+struct jpeg_entropy_decoder {
+  void (*start_pass) (j_decompress_ptr cinfo);
+  boolean (*decode_mcu) (j_decompress_ptr cinfo, JBLOCKROW *MCU_data);
+
+  /* This is here to share code between baseline and progressive decoders; */
+  /* other modules probably should not use it */
+  boolean insufficient_data;    /* set TRUE after emitting warning */
+};
+
+/* Inverse DCT (also performs dequantization) */
+typedef void (*inverse_DCT_method_ptr) (j_decompress_ptr cinfo,
+                                        jpeg_component_info *compptr,
+                                        JCOEFPTR coef_block,
+                                        JSAMPARRAY output_buf,
+                                        JDIMENSION output_col);
+
+struct jpeg_inverse_dct {
+  void (*start_pass) (j_decompress_ptr cinfo);
+  /* It is useful to allow each component to have a separate IDCT method. */
+  inverse_DCT_method_ptr inverse_DCT[MAX_COMPONENTS];
+};
+
+/* Upsampling (note that upsampler must also call color converter) */
+struct jpeg_upsampler {
+  void (*start_pass) (j_decompress_ptr cinfo);
+  void (*upsample) (j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
+                    JDIMENSION *in_row_group_ctr,
+                    JDIMENSION in_row_groups_avail, JSAMPARRAY output_buf,
+                    JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail);
+
+  boolean need_context_rows;    /* TRUE if need rows above & below */
+};
+
+/* Colorspace conversion */
+struct jpeg_color_deconverter {
+  void (*start_pass) (j_decompress_ptr cinfo);
+  void (*color_convert) (j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
+                         JDIMENSION input_row, JSAMPARRAY output_buf,
+                         int num_rows);
+};
+
+/* Color quantization or color precision reduction */
+struct jpeg_color_quantizer {
+  void (*start_pass) (j_decompress_ptr cinfo, boolean is_pre_scan);
+  void (*color_quantize) (j_decompress_ptr cinfo, JSAMPARRAY input_buf,
+                          JSAMPARRAY output_buf, int num_rows);
+  void (*finish_pass) (j_decompress_ptr cinfo);
+  void (*new_color_map) (j_decompress_ptr cinfo);
+};
+
+
+/* Miscellaneous useful macros */
+
+#undef MAX
+#define MAX(a, b)       ((a) > (b) ? (a) : (b))
+#undef MIN
+#define MIN(a, b)       ((a) < (b) ? (a) : (b))
+
+
+/* We assume that right shift corresponds to signed division by 2 with
+ * rounding towards minus infinity.  This is correct for typical "arithmetic
+ * shift" instructions that shift in copies of the sign bit.  But some
+ * C compilers implement >> with an unsigned shift.  For these machines you
+ * must define RIGHT_SHIFT_IS_UNSIGNED.
+ * RIGHT_SHIFT provides a proper signed right shift of a JLONG quantity.
+ * It is only applied with constant shift counts.  SHIFT_TEMPS must be
+ * included in the variables of any routine using RIGHT_SHIFT.
+ */
+
+#ifdef RIGHT_SHIFT_IS_UNSIGNED
+#define SHIFT_TEMPS     JLONG shift_temp;
+#define RIGHT_SHIFT(x, shft) \
+  ((shift_temp = (x)) < 0 ? \
+   (shift_temp >> (shft)) | ((~((JLONG)0)) << (32 - (shft))) : \
+   (shift_temp >> (shft)))
+#else
+#define SHIFT_TEMPS
+#define RIGHT_SHIFT(x, shft)    ((x) >> (shft))
+#endif
+
+
+/* Compression module initialization routines */
+EXTERN(void) jinit_compress_master(j_compress_ptr cinfo);
+EXTERN(void) jinit_c_master_control(j_compress_ptr cinfo,
+                                    boolean transcode_only);
+EXTERN(void) jinit_c_main_controller(j_compress_ptr cinfo,
+                                     boolean need_full_buffer);
+EXTERN(void) jinit_c_prep_controller(j_compress_ptr cinfo,
+                                     boolean need_full_buffer);
+EXTERN(void) jinit_c_coef_controller(j_compress_ptr cinfo,
+                                     boolean need_full_buffer);
+EXTERN(void) jinit_color_converter(j_compress_ptr cinfo);
+EXTERN(void) jinit_downsampler(j_compress_ptr cinfo);
+EXTERN(void) jinit_forward_dct(j_compress_ptr cinfo);
+EXTERN(void) jinit_huff_encoder(j_compress_ptr cinfo);
+EXTERN(void) jinit_phuff_encoder(j_compress_ptr cinfo);
+EXTERN(void) jinit_arith_encoder(j_compress_ptr cinfo);
+EXTERN(void) jinit_marker_writer(j_compress_ptr cinfo);
+/* Decompression module initialization routines */
+EXTERN(void) jinit_master_decompress(j_decompress_ptr cinfo);
+EXTERN(void) jinit_d_main_controller(j_decompress_ptr cinfo,
+                                     boolean need_full_buffer);
+EXTERN(void) jinit_d_coef_controller(j_decompress_ptr cinfo,
+                                     boolean need_full_buffer);
+EXTERN(void) jinit_d_post_controller(j_decompress_ptr cinfo,
+                                     boolean need_full_buffer);
+EXTERN(void) jinit_input_controller(j_decompress_ptr cinfo);
+EXTERN(void) jinit_marker_reader(j_decompress_ptr cinfo);
+EXTERN(void) jinit_huff_decoder(j_decompress_ptr cinfo);
+EXTERN(void) jinit_phuff_decoder(j_decompress_ptr cinfo);
+EXTERN(void) jinit_arith_decoder(j_decompress_ptr cinfo);
+EXTERN(void) jinit_inverse_dct(j_decompress_ptr cinfo);
+EXTERN(void) jinit_upsampler(j_decompress_ptr cinfo);
+EXTERN(void) jinit_color_deconverter(j_decompress_ptr cinfo);
+EXTERN(void) jinit_1pass_quantizer(j_decompress_ptr cinfo);
+EXTERN(void) jinit_2pass_quantizer(j_decompress_ptr cinfo);
+EXTERN(void) jinit_merged_upsampler(j_decompress_ptr cinfo);
+/* Memory manager initialization */
+EXTERN(void) jinit_memory_mgr(j_common_ptr cinfo);
+
+/* Utility routines in jutils.c */
+EXTERN(long) jdiv_round_up(long a, long b);
+EXTERN(long) jround_up(long a, long b);
+EXTERN(void) jcopy_sample_rows(JSAMPARRAY input_array, int source_row,
+                               JSAMPARRAY output_array, int dest_row,
+                               int num_rows, JDIMENSION num_cols);
+EXTERN(void) jcopy_block_row(JBLOCKROW input_row, JBLOCKROW output_row,
+                             JDIMENSION num_blocks);
+EXTERN(void) jzero_far(void *target, size_t bytestozero);
+/* Constant tables in jutils.c */
+#if 0                           /* This table is not actually needed in v6a */
+extern const int jpeg_zigzag_order[]; /* natural coef order to zigzag order */
+#endif
+extern const int jpeg_natural_order[]; /* zigzag coef order to natural order */
+
+/* Arithmetic coding probability estimation tables in jaricom.c */
+extern const JLONG jpeg_aritab[];
+
+/* Suppress undefined-structure complaints if necessary. */
+
+#ifdef INCOMPLETE_TYPES_BROKEN
+#ifndef AM_MEMORY_MANAGER       /* only jmemmgr.c defines these */
+struct jvirt_sarray_control { long dummy; };
+struct jvirt_barray_control { long dummy; };
+#endif
+#endif /* INCOMPLETE_TYPES_BROKEN */
diff --git a/3rdparty/libjpeg/src/jpeglib.h b/3rdparty/libjpeg/src/jpeglib.h
new file mode 100644
index 00000000..d7664f06
--- /dev/null
+++ b/3rdparty/libjpeg/src/jpeglib.h
@@ -0,0 +1,1132 @@
+/*
+ * jpeglib.h
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1991-1998, Thomas G. Lane.
+ * Modified 2002-2009 by Guido Vollbeding.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2009-2011, 2013-2014, 2016-2017, 2020, D. R. Commander.
+ * Copyright (C) 2015, Google, Inc.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file defines the application interface for the JPEG library.
+ * Most applications using the library need only include this file,
+ * and perhaps jerror.h if they want to know the exact error codes.
+ */
+
+#ifndef JPEGLIB_H
+#define JPEGLIB_H
+
+/*
+ * First we include the configuration files that record how this
+ * installation of the JPEG library is set up.  jconfig.h can be
+ * generated automatically for many systems.  jmorecfg.h contains
+ * manual configuration options that most people need not worry about.
+ */
+
+#ifndef JCONFIG_INCLUDED        /* in case jinclude.h already did */
+#include "jconfig.h"            /* widely used configuration options */
+#endif
+#include "jmorecfg.h"           /* seldom changed options */
+
+
+#ifdef __cplusplus
+#ifndef DONT_USE_EXTERN_C
+extern "C" {
+#endif
+#endif
+
+
+/* Various constants determining the sizes of things.
+ * All of these are specified by the JPEG standard, so don't change them
+ * if you want to be compatible.
+ */
+
+#define DCTSIZE             8   /* The basic DCT block is 8x8 samples */
+#define DCTSIZE2            64  /* DCTSIZE squared; # of elements in a block */
+#define NUM_QUANT_TBLS      4   /* Quantization tables are numbered 0..3 */
+#define NUM_HUFF_TBLS       4   /* Huffman tables are numbered 0..3 */
+#define NUM_ARITH_TBLS      16  /* Arith-coding tables are numbered 0..15 */
+#define MAX_COMPS_IN_SCAN   4   /* JPEG limit on # of components in one scan */
+#define MAX_SAMP_FACTOR     4   /* JPEG limit on sampling factors */
+/* Unfortunately, some bozo at Adobe saw no reason to be bound by the standard;
+ * the PostScript DCT filter can emit files with many more than 10 blocks/MCU.
+ * If you happen to run across such a file, you can up D_MAX_BLOCKS_IN_MCU
+ * to handle it.  We even let you do this from the jconfig.h file.  However,
+ * we strongly discourage changing C_MAX_BLOCKS_IN_MCU; just because Adobe
+ * sometimes emits noncompliant files doesn't mean you should too.
+ */
+#define C_MAX_BLOCKS_IN_MCU   10 /* compressor's limit on blocks per MCU */
+#ifndef D_MAX_BLOCKS_IN_MCU
+#define D_MAX_BLOCKS_IN_MCU   10 /* decompressor's limit on blocks per MCU */
+#endif
+
+
+/* Data structures for images (arrays of samples and of DCT coefficients).
+ */
+
+typedef JSAMPLE *JSAMPROW;      /* ptr to one image row of pixel samples. */
+typedef JSAMPROW *JSAMPARRAY;   /* ptr to some rows (a 2-D sample array) */
+typedef JSAMPARRAY *JSAMPIMAGE; /* a 3-D sample array: top index is color */
+
+typedef JCOEF JBLOCK[DCTSIZE2]; /* one block of coefficients */
+typedef JBLOCK *JBLOCKROW;      /* pointer to one row of coefficient blocks */
+typedef JBLOCKROW *JBLOCKARRAY;         /* a 2-D array of coefficient blocks */
+typedef JBLOCKARRAY *JBLOCKIMAGE;       /* a 3-D array of coefficient blocks */
+
+typedef JCOEF *JCOEFPTR;        /* useful in a couple of places */
+
+
+/* Types for JPEG compression parameters and working tables. */
+
+
+/* DCT coefficient quantization tables. */
+
+typedef struct {
+  /* This array gives the coefficient quantizers in natural array order
+   * (not the zigzag order in which they are stored in a JPEG DQT marker).
+   * CAUTION: IJG versions prior to v6a kept this array in zigzag order.
+   */
+  UINT16 quantval[DCTSIZE2];    /* quantization step for each coefficient */
+  /* This field is used only during compression.  It's initialized FALSE when
+   * the table is created, and set TRUE when it's been output to the file.
+   * You could suppress output of a table by setting this to TRUE.
+   * (See jpeg_suppress_tables for an example.)
+   */
+  boolean sent_table;           /* TRUE when table has been output */
+} JQUANT_TBL;
+
+
+/* Huffman coding tables. */
+
+typedef struct {
+  /* These two fields directly represent the contents of a JPEG DHT marker */
+  UINT8 bits[17];               /* bits[k] = # of symbols with codes of */
+                                /* length k bits; bits[0] is unused */
+  UINT8 huffval[256];           /* The symbols, in order of incr code length */
+  /* This field is used only during compression.  It's initialized FALSE when
+   * the table is created, and set TRUE when it's been output to the file.
+   * You could suppress output of a table by setting this to TRUE.
+   * (See jpeg_suppress_tables for an example.)
+   */
+  boolean sent_table;           /* TRUE when table has been output */
+} JHUFF_TBL;
+
+
+/* Basic info about one component (color channel). */
+
+typedef struct {
+  /* These values are fixed over the whole image. */
+  /* For compression, they must be supplied by parameter setup; */
+  /* for decompression, they are read from the SOF marker. */
+  int component_id;             /* identifier for this component (0..255) */
+  int component_index;          /* its index in SOF or cinfo->comp_info[] */
+  int h_samp_factor;            /* horizontal sampling factor (1..4) */
+  int v_samp_factor;            /* vertical sampling factor (1..4) */
+  int quant_tbl_no;             /* quantization table selector (0..3) */
+  /* These values may vary between scans. */
+  /* For compression, they must be supplied by parameter setup; */
+  /* for decompression, they are read from the SOS marker. */
+  /* The decompressor output side may not use these variables. */
+  int dc_tbl_no;                /* DC entropy table selector (0..3) */
+  int ac_tbl_no;                /* AC entropy table selector (0..3) */
+
+  /* Remaining fields should be treated as private by applications. */
+
+  /* These values are computed during compression or decompression startup: */
+  /* Component's size in DCT blocks.
+   * Any dummy blocks added to complete an MCU are not counted; therefore
+   * these values do not depend on whether a scan is interleaved or not.
+   */
+  JDIMENSION width_in_blocks;
+  JDIMENSION height_in_blocks;
+  /* Size of a DCT block in samples.  Always DCTSIZE for compression.
+   * For decompression this is the size of the output from one DCT block,
+   * reflecting any scaling we choose to apply during the IDCT step.
+   * Values from 1 to 16 are supported.
+   * Note that different components may receive different IDCT scalings.
+   */
+#if JPEG_LIB_VERSION >= 70
+  int DCT_h_scaled_size;
+  int DCT_v_scaled_size;
+#else
+  int DCT_scaled_size;
+#endif
+  /* The downsampled dimensions are the component's actual, unpadded number
+   * of samples at the main buffer (preprocessing/compression interface), thus
+   * downsampled_width = ceil(image_width * Hi/Hmax)
+   * and similarly for height.  For decompression, IDCT scaling is included, so
+   * downsampled_width = ceil(image_width * Hi/Hmax * DCT_[h_]scaled_size/DCTSIZE)
+   */
+  JDIMENSION downsampled_width;  /* actual width in samples */
+  JDIMENSION downsampled_height; /* actual height in samples */
+  /* This flag is used only for decompression.  In cases where some of the
+   * components will be ignored (eg grayscale output from YCbCr image),
+   * we can skip most computations for the unused components.
+   */
+  boolean component_needed;     /* do we need the value of this component? */
+
+  /* These values are computed before starting a scan of the component. */
+  /* The decompressor output side may not use these variables. */
+  int MCU_width;                /* number of blocks per MCU, horizontally */
+  int MCU_height;               /* number of blocks per MCU, vertically */
+  int MCU_blocks;               /* MCU_width * MCU_height */
+  int MCU_sample_width;         /* MCU width in samples, MCU_width*DCT_[h_]scaled_size */
+  int last_col_width;           /* # of non-dummy blocks across in last MCU */
+  int last_row_height;          /* # of non-dummy blocks down in last MCU */
+
+  /* Saved quantization table for component; NULL if none yet saved.
+   * See jdinput.c comments about the need for this information.
+   * This field is currently used only for decompression.
+   */
+  JQUANT_TBL *quant_table;
+
+  /* Private per-component storage for DCT or IDCT subsystem. */
+  void *dct_table;
+} jpeg_component_info;
+
+
+/* The script for encoding a multiple-scan file is an array of these: */
+
+typedef struct {
+  int comps_in_scan;            /* number of components encoded in this scan */
+  int component_index[MAX_COMPS_IN_SCAN]; /* their SOF/comp_info[] indexes */
+  int Ss, Se;                   /* progressive JPEG spectral selection parms */
+  int Ah, Al;                   /* progressive JPEG successive approx. parms */
+} jpeg_scan_info;
+
+/* The decompressor can save APPn and COM markers in a list of these: */
+
+typedef struct jpeg_marker_struct *jpeg_saved_marker_ptr;
+
+struct jpeg_marker_struct {
+  jpeg_saved_marker_ptr next;   /* next in list, or NULL */
+  UINT8 marker;                 /* marker code: JPEG_COM, or JPEG_APP0+n */
+  unsigned int original_length; /* # bytes of data in the file */
+  unsigned int data_length;     /* # bytes of data saved at data[] */
+  JOCTET *data;                 /* the data contained in the marker */
+  /* the marker length word is not counted in data_length or original_length */
+};
+
+/* Known color spaces. */
+
+#define JCS_EXTENSIONS  1
+#define JCS_ALPHA_EXTENSIONS  1
+
+typedef enum {
+  JCS_UNKNOWN,            /* error/unspecified */
+  JCS_GRAYSCALE,          /* monochrome */
+  JCS_RGB,                /* red/green/blue as specified by the RGB_RED,
+                             RGB_GREEN, RGB_BLUE, and RGB_PIXELSIZE macros */
+  JCS_YCbCr,              /* Y/Cb/Cr (also known as YUV) */
+  JCS_CMYK,               /* C/M/Y/K */
+  JCS_YCCK,               /* Y/Cb/Cr/K */
+  JCS_EXT_RGB,            /* red/green/blue */
+  JCS_EXT_RGBX,           /* red/green/blue/x */
+  JCS_EXT_BGR,            /* blue/green/red */
+  JCS_EXT_BGRX,           /* blue/green/red/x */
+  JCS_EXT_XBGR,           /* x/blue/green/red */
+  JCS_EXT_XRGB,           /* x/red/green/blue */
+  /* When out_color_space it set to JCS_EXT_RGBX, JCS_EXT_BGRX, JCS_EXT_XBGR,
+     or JCS_EXT_XRGB during decompression, the X byte is undefined, and in
+     order to ensure the best performance, libjpeg-turbo can set that byte to
+     whatever value it wishes.  Use the following colorspace constants to
+     ensure that the X byte is set to 0xFF, so that it can be interpreted as an
+     opaque alpha channel. */
+  JCS_EXT_RGBA,           /* red/green/blue/alpha */
+  JCS_EXT_BGRA,           /* blue/green/red/alpha */
+  JCS_EXT_ABGR,           /* alpha/blue/green/red */
+  JCS_EXT_ARGB,           /* alpha/red/green/blue */
+  JCS_RGB565              /* 5-bit red/6-bit green/5-bit blue */
+} J_COLOR_SPACE;
+
+/* DCT/IDCT algorithm options. */
+
+typedef enum {
+  JDCT_ISLOW,             /* accurate integer method */
+  JDCT_IFAST,             /* less accurate integer method [legacy feature] */
+  JDCT_FLOAT              /* floating-point method [legacy feature] */
+} J_DCT_METHOD;
+
+#ifndef JDCT_DEFAULT            /* may be overridden in jconfig.h */
+#define JDCT_DEFAULT  JDCT_ISLOW
+#endif
+#ifndef JDCT_FASTEST            /* may be overridden in jconfig.h */
+#define JDCT_FASTEST  JDCT_IFAST
+#endif
+
+/* Dithering options for decompression. */
+
+typedef enum {
+  JDITHER_NONE,           /* no dithering */
+  JDITHER_ORDERED,        /* simple ordered dither */
+  JDITHER_FS              /* Floyd-Steinberg error diffusion dither */
+} J_DITHER_MODE;
+
+
+/* Common fields between JPEG compression and decompression master structs. */
+
+#define jpeg_common_fields \
+  struct jpeg_error_mgr *err;   /* Error handler module */ \
+  struct jpeg_memory_mgr *mem;  /* Memory manager module */ \
+  struct jpeg_progress_mgr *progress; /* Progress monitor, or NULL if none */ \
+  void *client_data;            /* Available for use by application */ \
+  boolean is_decompressor;      /* So common code can tell which is which */ \
+  int global_state              /* For checking call sequence validity */
+
+/* Routines that are to be used by both halves of the library are declared
+ * to receive a pointer to this structure.  There are no actual instances of
+ * jpeg_common_struct, only of jpeg_compress_struct and jpeg_decompress_struct.
+ */
+struct jpeg_common_struct {
+  jpeg_common_fields;           /* Fields common to both master struct types */
+  /* Additional fields follow in an actual jpeg_compress_struct or
+   * jpeg_decompress_struct.  All three structs must agree on these
+   * initial fields!  (This would be a lot cleaner in C++.)
+   */
+};
+
+typedef struct jpeg_common_struct *j_common_ptr;
+typedef struct jpeg_compress_struct *j_compress_ptr;
+typedef struct jpeg_decompress_struct *j_decompress_ptr;
+
+
+/* Master record for a compression instance */
+
+struct jpeg_compress_struct {
+  jpeg_common_fields;           /* Fields shared with jpeg_decompress_struct */
+
+  /* Destination for compressed data */
+  struct jpeg_destination_mgr *dest;
+
+  /* Description of source image --- these fields must be filled in by
+   * outer application before starting compression.  in_color_space must
+   * be correct before you can even call jpeg_set_defaults().
+   */
+
+  JDIMENSION image_width;       /* input image width */
+  JDIMENSION image_height;      /* input image height */
+  int input_components;         /* # of color components in input image */
+  J_COLOR_SPACE in_color_space; /* colorspace of input image */
+
+  double input_gamma;           /* image gamma of input image */
+
+  /* Compression parameters --- these fields must be set before calling
+   * jpeg_start_compress().  We recommend calling jpeg_set_defaults() to
+   * initialize everything to reasonable defaults, then changing anything
+   * the application specifically wants to change.  That way you won't get
+   * burnt when new parameters are added.  Also note that there are several
+   * helper routines to simplify changing parameters.
+   */
+
+#if JPEG_LIB_VERSION >= 70
+  unsigned int scale_num, scale_denom; /* fraction by which to scale image */
+
+  JDIMENSION jpeg_width;        /* scaled JPEG image width */
+  JDIMENSION jpeg_height;       /* scaled JPEG image height */
+  /* Dimensions of actual JPEG image that will be written to file,
+   * derived from input dimensions by scaling factors above.
+   * These fields are computed by jpeg_start_compress().
+   * You can also use jpeg_calc_jpeg_dimensions() to determine these values
+   * in advance of calling jpeg_start_compress().
+   */
+#endif
+
+  int data_precision;           /* bits of precision in image data */
+
+  int num_components;           /* # of color components in JPEG image */
+  J_COLOR_SPACE jpeg_color_space; /* colorspace of JPEG image */
+
+  jpeg_component_info *comp_info;
+  /* comp_info[i] describes component that appears i'th in SOF */
+
+  JQUANT_TBL *quant_tbl_ptrs[NUM_QUANT_TBLS];
+#if JPEG_LIB_VERSION >= 70
+  int q_scale_factor[NUM_QUANT_TBLS];
+#endif
+  /* ptrs to coefficient quantization tables, or NULL if not defined,
+   * and corresponding scale factors (percentage, initialized 100).
+   */
+
+  JHUFF_TBL *dc_huff_tbl_ptrs[NUM_HUFF_TBLS];
+  JHUFF_TBL *ac_huff_tbl_ptrs[NUM_HUFF_TBLS];
+  /* ptrs to Huffman coding tables, or NULL if not defined */
+
+  UINT8 arith_dc_L[NUM_ARITH_TBLS]; /* L values for DC arith-coding tables */
+  UINT8 arith_dc_U[NUM_ARITH_TBLS]; /* U values for DC arith-coding tables */
+  UINT8 arith_ac_K[NUM_ARITH_TBLS]; /* Kx values for AC arith-coding tables */
+
+  int num_scans;                /* # of entries in scan_info array */
+  const jpeg_scan_info *scan_info; /* script for multi-scan file, or NULL */
+  /* The default value of scan_info is NULL, which causes a single-scan
+   * sequential JPEG file to be emitted.  To create a multi-scan file,
+   * set num_scans and scan_info to point to an array of scan definitions.
+   */
+
+  boolean raw_data_in;          /* TRUE=caller supplies downsampled data */
+  boolean arith_code;           /* TRUE=arithmetic coding, FALSE=Huffman */
+  boolean optimize_coding;      /* TRUE=optimize entropy encoding parms */
+  boolean CCIR601_sampling;     /* TRUE=first samples are cosited */
+#if JPEG_LIB_VERSION >= 70
+  boolean do_fancy_downsampling; /* TRUE=apply fancy downsampling */
+#endif
+  int smoothing_factor;         /* 1..100, or 0 for no input smoothing */
+  J_DCT_METHOD dct_method;      /* DCT algorithm selector */
+
+  /* The restart interval can be specified in absolute MCUs by setting
+   * restart_interval, or in MCU rows by setting restart_in_rows
+   * (in which case the correct restart_interval will be figured
+   * for each scan).
+   */
+  unsigned int restart_interval; /* MCUs per restart, or 0 for no restart */
+  int restart_in_rows;          /* if > 0, MCU rows per restart interval */
+
+  /* Parameters controlling emission of special markers. */
+
+  boolean write_JFIF_header;    /* should a JFIF marker be written? */
+  UINT8 JFIF_major_version;     /* What to write for the JFIF version number */
+  UINT8 JFIF_minor_version;
+  /* These three values are not used by the JPEG code, merely copied */
+  /* into the JFIF APP0 marker.  density_unit can be 0 for unknown, */
+  /* 1 for dots/inch, or 2 for dots/cm.  Note that the pixel aspect */
+  /* ratio is defined by X_density/Y_density even when density_unit=0. */
+  UINT8 density_unit;           /* JFIF code for pixel size units */
+  UINT16 X_density;             /* Horizontal pixel density */
+  UINT16 Y_density;             /* Vertical pixel density */
+  boolean write_Adobe_marker;   /* should an Adobe marker be written? */
+
+  /* State variable: index of next scanline to be written to
+   * jpeg_write_scanlines().  Application may use this to control its
+   * processing loop, e.g., "while (next_scanline < image_height)".
+   */
+
+  JDIMENSION next_scanline;     /* 0 .. image_height-1  */
+
+  /* Remaining fields are known throughout compressor, but generally
+   * should not be touched by a surrounding application.
+   */
+
+  /*
+   * These fields are computed during compression startup
+   */
+  boolean progressive_mode;     /* TRUE if scan script uses progressive mode */
+  int max_h_samp_factor;        /* largest h_samp_factor */
+  int max_v_samp_factor;        /* largest v_samp_factor */
+
+#if JPEG_LIB_VERSION >= 70
+  int min_DCT_h_scaled_size;    /* smallest DCT_h_scaled_size of any component */
+  int min_DCT_v_scaled_size;    /* smallest DCT_v_scaled_size of any component */
+#endif
+
+  JDIMENSION total_iMCU_rows;   /* # of iMCU rows to be input to coef ctlr */
+  /* The coefficient controller receives data in units of MCU rows as defined
+   * for fully interleaved scans (whether the JPEG file is interleaved or not).
+   * There are v_samp_factor * DCTSIZE sample rows of each component in an
+   * "iMCU" (interleaved MCU) row.
+   */
+
+  /*
+   * These fields are valid during any one scan.
+   * They describe the components and MCUs actually appearing in the scan.
+   */
+  int comps_in_scan;            /* # of JPEG components in this scan */
+  jpeg_component_info *cur_comp_info[MAX_COMPS_IN_SCAN];
+  /* *cur_comp_info[i] describes component that appears i'th in SOS */
+
+  JDIMENSION MCUs_per_row;      /* # of MCUs across the image */
+  JDIMENSION MCU_rows_in_scan;  /* # of MCU rows in the image */
+
+  int blocks_in_MCU;            /* # of DCT blocks per MCU */
+  int MCU_membership[C_MAX_BLOCKS_IN_MCU];
+  /* MCU_membership[i] is index in cur_comp_info of component owning */
+  /* i'th block in an MCU */
+
+  int Ss, Se, Ah, Al;           /* progressive JPEG parameters for scan */
+
+#if JPEG_LIB_VERSION >= 80
+  int block_size;               /* the basic DCT block size: 1..16 */
+  const int *natural_order;     /* natural-order position array */
+  int lim_Se;                   /* min( Se, DCTSIZE2-1 ) */
+#endif
+
+  /*
+   * Links to compression subobjects (methods and private variables of modules)
+   */
+  struct jpeg_comp_master *master;
+  struct jpeg_c_main_controller *main;
+  struct jpeg_c_prep_controller *prep;
+  struct jpeg_c_coef_controller *coef;
+  struct jpeg_marker_writer *marker;
+  struct jpeg_color_converter *cconvert;
+  struct jpeg_downsampler *downsample;
+  struct jpeg_forward_dct *fdct;
+  struct jpeg_entropy_encoder *entropy;
+  jpeg_scan_info *script_space; /* workspace for jpeg_simple_progression */
+  int script_space_size;
+};
+
+
+/* Master record for a decompression instance */
+
+struct jpeg_decompress_struct {
+  jpeg_common_fields;           /* Fields shared with jpeg_compress_struct */
+
+  /* Source of compressed data */
+  struct jpeg_source_mgr *src;
+
+  /* Basic description of image --- filled in by jpeg_read_header(). */
+  /* Application may inspect these values to decide how to process image. */
+
+  JDIMENSION image_width;       /* nominal image width (from SOF marker) */
+  JDIMENSION image_height;      /* nominal image height */
+  int num_components;           /* # of color components in JPEG image */
+  J_COLOR_SPACE jpeg_color_space; /* colorspace of JPEG image */
+
+  /* Decompression processing parameters --- these fields must be set before
+   * calling jpeg_start_decompress().  Note that jpeg_read_header() initializes
+   * them to default values.
+   */
+
+  J_COLOR_SPACE out_color_space; /* colorspace for output */
+
+  unsigned int scale_num, scale_denom; /* fraction by which to scale image */
+
+  double output_gamma;          /* image gamma wanted in output */
+
+  boolean buffered_image;       /* TRUE=multiple output passes */
+  boolean raw_data_out;         /* TRUE=downsampled data wanted */
+
+  J_DCT_METHOD dct_method;      /* IDCT algorithm selector */
+  boolean do_fancy_upsampling;  /* TRUE=apply fancy upsampling */
+  boolean do_block_smoothing;   /* TRUE=apply interblock smoothing */
+
+  boolean quantize_colors;      /* TRUE=colormapped output wanted */
+  /* the following are ignored if not quantize_colors: */
+  J_DITHER_MODE dither_mode;    /* type of color dithering to use */
+  boolean two_pass_quantize;    /* TRUE=use two-pass color quantization */
+  int desired_number_of_colors; /* max # colors to use in created colormap */
+  /* these are significant only in buffered-image mode: */
+  boolean enable_1pass_quant;   /* enable future use of 1-pass quantizer */
+  boolean enable_external_quant;/* enable future use of external colormap */
+  boolean enable_2pass_quant;   /* enable future use of 2-pass quantizer */
+
+  /* Description of actual output image that will be returned to application.
+   * These fields are computed by jpeg_start_decompress().
+   * You can also use jpeg_calc_output_dimensions() to determine these values
+   * in advance of calling jpeg_start_decompress().
+   */
+
+  JDIMENSION output_width;      /* scaled image width */
+  JDIMENSION output_height;     /* scaled image height */
+  int out_color_components;     /* # of color components in out_color_space */
+  int output_components;        /* # of color components returned */
+  /* output_components is 1 (a colormap index) when quantizing colors;
+   * otherwise it equals out_color_components.
+   */
+  int rec_outbuf_height;        /* min recommended height of scanline buffer */
+  /* If the buffer passed to jpeg_read_scanlines() is less than this many rows
+   * high, space and time will be wasted due to unnecessary data copying.
+   * Usually rec_outbuf_height will be 1 or 2, at most 4.
+   */
+
+  /* When quantizing colors, the output colormap is described by these fields.
+   * The application can supply a colormap by setting colormap non-NULL before
+   * calling jpeg_start_decompress; otherwise a colormap is created during
+   * jpeg_start_decompress or jpeg_start_output.
+   * The map has out_color_components rows and actual_number_of_colors columns.
+   */
+  int actual_number_of_colors;  /* number of entries in use */
+  JSAMPARRAY colormap;          /* The color map as a 2-D pixel array */
+
+  /* State variables: these variables indicate the progress of decompression.
+   * The application may examine these but must not modify them.
+   */
+
+  /* Row index of next scanline to be read from jpeg_read_scanlines().
+   * Application may use this to control its processing loop, e.g.,
+   * "while (output_scanline < output_height)".
+   */
+  JDIMENSION output_scanline;   /* 0 .. output_height-1  */
+
+  /* Current input scan number and number of iMCU rows completed in scan.
+   * These indicate the progress of the decompressor input side.
+   */
+  int input_scan_number;        /* Number of SOS markers seen so far */
+  JDIMENSION input_iMCU_row;    /* Number of iMCU rows completed */
+
+  /* The "output scan number" is the notional scan being displayed by the
+   * output side.  The decompressor will not allow output scan/row number
+   * to get ahead of input scan/row, but it can fall arbitrarily far behind.
+   */
+  int output_scan_number;       /* Nominal scan number being displayed */
+  JDIMENSION output_iMCU_row;   /* Number of iMCU rows read */
+
+  /* Current progression status.  coef_bits[c][i] indicates the precision
+   * with which component c's DCT coefficient i (in zigzag order) is known.
+   * It is -1 when no data has yet been received, otherwise it is the point
+   * transform (shift) value for the most recent scan of the coefficient
+   * (thus, 0 at completion of the progression).
+   * This pointer is NULL when reading a non-progressive file.
+   */
+  int (*coef_bits)[DCTSIZE2];   /* -1 or current Al value for each coef */
+
+  /* Internal JPEG parameters --- the application usually need not look at
+   * these fields.  Note that the decompressor output side may not use
+   * any parameters that can change between scans.
+   */
+
+  /* Quantization and Huffman tables are carried forward across input
+   * datastreams when processing abbreviated JPEG datastreams.
+   */
+
+  JQUANT_TBL *quant_tbl_ptrs[NUM_QUANT_TBLS];
+  /* ptrs to coefficient quantization tables, or NULL if not defined */
+
+  JHUFF_TBL *dc_huff_tbl_ptrs[NUM_HUFF_TBLS];
+  JHUFF_TBL *ac_huff_tbl_ptrs[NUM_HUFF_TBLS];
+  /* ptrs to Huffman coding tables, or NULL if not defined */
+
+  /* These parameters are never carried across datastreams, since they
+   * are given in SOF/SOS markers or defined to be reset by SOI.
+   */
+
+  int data_precision;           /* bits of precision in image data */
+
+  jpeg_component_info *comp_info;
+  /* comp_info[i] describes component that appears i'th in SOF */
+
+#if JPEG_LIB_VERSION >= 80
+  boolean is_baseline;          /* TRUE if Baseline SOF0 encountered */
+#endif
+  boolean progressive_mode;     /* TRUE if SOFn specifies progressive mode */
+  boolean arith_code;           /* TRUE=arithmetic coding, FALSE=Huffman */
+
+  UINT8 arith_dc_L[NUM_ARITH_TBLS]; /* L values for DC arith-coding tables */
+  UINT8 arith_dc_U[NUM_ARITH_TBLS]; /* U values for DC arith-coding tables */
+  UINT8 arith_ac_K[NUM_ARITH_TBLS]; /* Kx values for AC arith-coding tables */
+
+  unsigned int restart_interval; /* MCUs per restart interval, or 0 for no restart */
+
+  /* These fields record data obtained from optional markers recognized by
+   * the JPEG library.
+   */
+  boolean saw_JFIF_marker;      /* TRUE iff a JFIF APP0 marker was found */
+  /* Data copied from JFIF marker; only valid if saw_JFIF_marker is TRUE: */
+  UINT8 JFIF_major_version;     /* JFIF version number */
+  UINT8 JFIF_minor_version;
+  UINT8 density_unit;           /* JFIF code for pixel size units */
+  UINT16 X_density;             /* Horizontal pixel density */
+  UINT16 Y_density;             /* Vertical pixel density */
+  boolean saw_Adobe_marker;     /* TRUE iff an Adobe APP14 marker was found */
+  UINT8 Adobe_transform;        /* Color transform code from Adobe marker */
+
+  boolean CCIR601_sampling;     /* TRUE=first samples are cosited */
+
+  /* Aside from the specific data retained from APPn markers known to the
+   * library, the uninterpreted contents of any or all APPn and COM markers
+   * can be saved in a list for examination by the application.
+   */
+  jpeg_saved_marker_ptr marker_list; /* Head of list of saved markers */
+
+  /* Remaining fields are known throughout decompressor, but generally
+   * should not be touched by a surrounding application.
+   */
+
+  /*
+   * These fields are computed during decompression startup
+   */
+  int max_h_samp_factor;        /* largest h_samp_factor */
+  int max_v_samp_factor;        /* largest v_samp_factor */
+
+#if JPEG_LIB_VERSION >= 70
+  int min_DCT_h_scaled_size;    /* smallest DCT_h_scaled_size of any component */
+  int min_DCT_v_scaled_size;    /* smallest DCT_v_scaled_size of any component */
+#else
+  int min_DCT_scaled_size;      /* smallest DCT_scaled_size of any component */
+#endif
+
+  JDIMENSION total_iMCU_rows;   /* # of iMCU rows in image */
+  /* The coefficient controller's input and output progress is measured in
+   * units of "iMCU" (interleaved MCU) rows.  These are the same as MCU rows
+   * in fully interleaved JPEG scans, but are used whether the scan is
+   * interleaved or not.  We define an iMCU row as v_samp_factor DCT block
+   * rows of each component.  Therefore, the IDCT output contains
+   * v_samp_factor*DCT_[v_]scaled_size sample rows of a component per iMCU row.
+   */
+
+  JSAMPLE *sample_range_limit;  /* table for fast range-limiting */
+
+  /*
+   * These fields are valid during any one scan.
+   * They describe the components and MCUs actually appearing in the scan.
+   * Note that the decompressor output side must not use these fields.
+   */
+  int comps_in_scan;            /* # of JPEG components in this scan */
+  jpeg_component_info *cur_comp_info[MAX_COMPS_IN_SCAN];
+  /* *cur_comp_info[i] describes component that appears i'th in SOS */
+
+  JDIMENSION MCUs_per_row;      /* # of MCUs across the image */
+  JDIMENSION MCU_rows_in_scan;  /* # of MCU rows in the image */
+
+  int blocks_in_MCU;            /* # of DCT blocks per MCU */
+  int MCU_membership[D_MAX_BLOCKS_IN_MCU];
+  /* MCU_membership[i] is index in cur_comp_info of component owning */
+  /* i'th block in an MCU */
+
+  int Ss, Se, Ah, Al;           /* progressive JPEG parameters for scan */
+
+#if JPEG_LIB_VERSION >= 80
+  /* These fields are derived from Se of first SOS marker.
+   */
+  int block_size;               /* the basic DCT block size: 1..16 */
+  const int *natural_order; /* natural-order position array for entropy decode */
+  int lim_Se;                   /* min( Se, DCTSIZE2-1 ) for entropy decode */
+#endif
+
+  /* This field is shared between entropy decoder and marker parser.
+   * It is either zero or the code of a JPEG marker that has been
+   * read from the data source, but has not yet been processed.
+   */
+  int unread_marker;
+
+  /*
+   * Links to decompression subobjects (methods, private variables of modules)
+   */
+  struct jpeg_decomp_master *master;
+  struct jpeg_d_main_controller *main;
+  struct jpeg_d_coef_controller *coef;
+  struct jpeg_d_post_controller *post;
+  struct jpeg_input_controller *inputctl;
+  struct jpeg_marker_reader *marker;
+  struct jpeg_entropy_decoder *entropy;
+  struct jpeg_inverse_dct *idct;
+  struct jpeg_upsampler *upsample;
+  struct jpeg_color_deconverter *cconvert;
+  struct jpeg_color_quantizer *cquantize;
+};
+
+
+/* "Object" declarations for JPEG modules that may be supplied or called
+ * directly by the surrounding application.
+ * As with all objects in the JPEG library, these structs only define the
+ * publicly visible methods and state variables of a module.  Additional
+ * private fields may exist after the public ones.
+ */
+
+
+/* Error handler object */
+
+struct jpeg_error_mgr {
+  /* Error exit handler: does not return to caller */
+  void (*error_exit) (j_common_ptr cinfo);
+  /* Conditionally emit a trace or warning message */
+  void (*emit_message) (j_common_ptr cinfo, int msg_level);
+  /* Routine that actually outputs a trace or error message */
+  void (*output_message) (j_common_ptr cinfo);
+  /* Format a message string for the most recent JPEG error or message */
+  void (*format_message) (j_common_ptr cinfo, char *buffer);
+#define JMSG_LENGTH_MAX  200    /* recommended size of format_message buffer */
+  /* Reset error state variables at start of a new image */
+  void (*reset_error_mgr) (j_common_ptr cinfo);
+
+  /* The message ID code and any parameters are saved here.
+   * A message can have one string parameter or up to 8 int parameters.
+   */
+  int msg_code;
+#define JMSG_STR_PARM_MAX  80
+  union {
+    int i[8];
+    char s[JMSG_STR_PARM_MAX];
+  } msg_parm;
+
+  /* Standard state variables for error facility */
+
+  int trace_level;              /* max msg_level that will be displayed */
+
+  /* For recoverable corrupt-data errors, we emit a warning message,
+   * but keep going unless emit_message chooses to abort.  emit_message
+   * should count warnings in num_warnings.  The surrounding application
+   * can check for bad data by seeing if num_warnings is nonzero at the
+   * end of processing.
+   */
+  long num_warnings;            /* number of corrupt-data warnings */
+
+  /* These fields point to the table(s) of error message strings.
+   * An application can change the table pointer to switch to a different
+   * message list (typically, to change the language in which errors are
+   * reported).  Some applications may wish to add additional error codes
+   * that will be handled by the JPEG library error mechanism; the second
+   * table pointer is used for this purpose.
+   *
+   * First table includes all errors generated by JPEG library itself.
+   * Error code 0 is reserved for a "no such error string" message.
+   */
+  const char * const *jpeg_message_table; /* Library errors */
+  int last_jpeg_message;    /* Table contains strings 0..last_jpeg_message */
+  /* Second table can be added by application (see cjpeg/djpeg for example).
+   * It contains strings numbered first_addon_message..last_addon_message.
+   */
+  const char * const *addon_message_table; /* Non-library errors */
+  int first_addon_message;      /* code for first string in addon table */
+  int last_addon_message;       /* code for last string in addon table */
+};
+
+
+/* Progress monitor object */
+
+struct jpeg_progress_mgr {
+  void (*progress_monitor) (j_common_ptr cinfo);
+
+  long pass_counter;            /* work units completed in this pass */
+  long pass_limit;              /* total number of work units in this pass */
+  int completed_passes;         /* passes completed so far */
+  int total_passes;             /* total number of passes expected */
+};
+
+
+/* Data destination object for compression */
+
+struct jpeg_destination_mgr {
+  JOCTET *next_output_byte;     /* => next byte to write in buffer */
+  size_t free_in_buffer;        /* # of byte spaces remaining in buffer */
+
+  void (*init_destination) (j_compress_ptr cinfo);
+  boolean (*empty_output_buffer) (j_compress_ptr cinfo);
+  void (*term_destination) (j_compress_ptr cinfo);
+};
+
+
+/* Data source object for decompression */
+
+struct jpeg_source_mgr {
+  const JOCTET *next_input_byte; /* => next byte to read from buffer */
+  size_t bytes_in_buffer;       /* # of bytes remaining in buffer */
+
+  void (*init_source) (j_decompress_ptr cinfo);
+  boolean (*fill_input_buffer) (j_decompress_ptr cinfo);
+  void (*skip_input_data) (j_decompress_ptr cinfo, long num_bytes);
+  boolean (*resync_to_restart) (j_decompress_ptr cinfo, int desired);
+  void (*term_source) (j_decompress_ptr cinfo);
+};
+
+
+/* Memory manager object.
+ * Allocates "small" objects (a few K total), "large" objects (tens of K),
+ * and "really big" objects (virtual arrays with backing store if needed).
+ * The memory manager does not allow individual objects to be freed; rather,
+ * each created object is assigned to a pool, and whole pools can be freed
+ * at once.  This is faster and more convenient than remembering exactly what
+ * to free, especially where malloc()/free() are not too speedy.
+ * NB: alloc routines never return NULL.  They exit to error_exit if not
+ * successful.
+ */
+
+#define JPOOL_PERMANENT  0      /* lasts until master record is destroyed */
+#define JPOOL_IMAGE      1      /* lasts until done with image/datastream */
+#define JPOOL_NUMPOOLS   2
+
+typedef struct jvirt_sarray_control *jvirt_sarray_ptr;
+typedef struct jvirt_barray_control *jvirt_barray_ptr;
+
+
+struct jpeg_memory_mgr {
+  /* Method pointers */
+  void *(*alloc_small) (j_common_ptr cinfo, int pool_id, size_t sizeofobject);
+  void *(*alloc_large) (j_common_ptr cinfo, int pool_id,
+                        size_t sizeofobject);
+  JSAMPARRAY (*alloc_sarray) (j_common_ptr cinfo, int pool_id,
+                              JDIMENSION samplesperrow, JDIMENSION numrows);
+  JBLOCKARRAY (*alloc_barray) (j_common_ptr cinfo, int pool_id,
+                               JDIMENSION blocksperrow, JDIMENSION numrows);
+  jvirt_sarray_ptr (*request_virt_sarray) (j_common_ptr cinfo, int pool_id,
+                                           boolean pre_zero,
+                                           JDIMENSION samplesperrow,
+                                           JDIMENSION numrows,
+                                           JDIMENSION maxaccess);
+  jvirt_barray_ptr (*request_virt_barray) (j_common_ptr cinfo, int pool_id,
+                                           boolean pre_zero,
+                                           JDIMENSION blocksperrow,
+                                           JDIMENSION numrows,
+                                           JDIMENSION maxaccess);
+  void (*realize_virt_arrays) (j_common_ptr cinfo);
+  JSAMPARRAY (*access_virt_sarray) (j_common_ptr cinfo, jvirt_sarray_ptr ptr,
+                                    JDIMENSION start_row, JDIMENSION num_rows,
+                                    boolean writable);
+  JBLOCKARRAY (*access_virt_barray) (j_common_ptr cinfo, jvirt_barray_ptr ptr,
+                                     JDIMENSION start_row, JDIMENSION num_rows,
+                                     boolean writable);
+  void (*free_pool) (j_common_ptr cinfo, int pool_id);
+  void (*self_destruct) (j_common_ptr cinfo);
+
+  /* Limit on memory allocation for this JPEG object.  (Note that this is
+   * merely advisory, not a guaranteed maximum; it only affects the space
+   * used for virtual-array buffers.)  May be changed by outer application
+   * after creating the JPEG object.
+   */
+  long max_memory_to_use;
+
+  /* Maximum allocation request accepted by alloc_large. */
+  long max_alloc_chunk;
+};
+
+
+/* Routine signature for application-supplied marker processing methods.
+ * Need not pass marker code since it is stored in cinfo->unread_marker.
+ */
+typedef boolean (*jpeg_marker_parser_method) (j_decompress_ptr cinfo);
+
+
+/* Originally, this macro was used as a way of defining function prototypes
+ * for both modern compilers as well as older compilers that did not support
+ * prototype parameters.  libjpeg-turbo has never supported these older,
+ * non-ANSI compilers, but the macro is still included because there is some
+ * software out there that uses it.
+ */
+
+#define JPP(arglist)    arglist
+
+
+/* Default error-management setup */
+EXTERN(struct jpeg_error_mgr *) jpeg_std_error(struct jpeg_error_mgr *err);
+
+/* Initialization of JPEG compression objects.
+ * jpeg_create_compress() and jpeg_create_decompress() are the exported
+ * names that applications should call.  These expand to calls on
+ * jpeg_CreateCompress and jpeg_CreateDecompress with additional information
+ * passed for version mismatch checking.
+ * NB: you must set up the error-manager BEFORE calling jpeg_create_xxx.
+ */
+#define jpeg_create_compress(cinfo) \
+  jpeg_CreateCompress((cinfo), JPEG_LIB_VERSION, \
+                      (size_t)sizeof(struct jpeg_compress_struct))
+#define jpeg_create_decompress(cinfo) \
+  jpeg_CreateDecompress((cinfo), JPEG_LIB_VERSION, \
+                        (size_t)sizeof(struct jpeg_decompress_struct))
+EXTERN(void) jpeg_CreateCompress(j_compress_ptr cinfo, int version,
+                                 size_t structsize);
+EXTERN(void) jpeg_CreateDecompress(j_decompress_ptr cinfo, int version,
+                                   size_t structsize);
+/* Destruction of JPEG compression objects */
+EXTERN(void) jpeg_destroy_compress(j_compress_ptr cinfo);
+EXTERN(void) jpeg_destroy_decompress(j_decompress_ptr cinfo);
+
+/* Standard data source and destination managers: stdio streams. */
+/* Caller is responsible for opening the file before and closing after. */
+EXTERN(void) jpeg_stdio_dest(j_compress_ptr cinfo, FILE *outfile);
+EXTERN(void) jpeg_stdio_src(j_decompress_ptr cinfo, FILE *infile);
+
+#if JPEG_LIB_VERSION >= 80 || defined(MEM_SRCDST_SUPPORTED)
+/* Data source and destination managers: memory buffers. */
+EXTERN(void) jpeg_mem_dest(j_compress_ptr cinfo, unsigned char **outbuffer,
+                           unsigned long *outsize);
+EXTERN(void) jpeg_mem_src(j_decompress_ptr cinfo,
+                          const unsigned char *inbuffer, unsigned long insize);
+#endif
+
+/* Default parameter setup for compression */
+EXTERN(void) jpeg_set_defaults(j_compress_ptr cinfo);
+/* Compression parameter setup aids */
+EXTERN(void) jpeg_set_colorspace(j_compress_ptr cinfo,
+                                 J_COLOR_SPACE colorspace);
+EXTERN(void) jpeg_default_colorspace(j_compress_ptr cinfo);
+EXTERN(void) jpeg_set_quality(j_compress_ptr cinfo, int quality,
+                              boolean force_baseline);
+EXTERN(void) jpeg_set_linear_quality(j_compress_ptr cinfo, int scale_factor,
+                                     boolean force_baseline);
+#if JPEG_LIB_VERSION >= 70
+EXTERN(void) jpeg_default_qtables(j_compress_ptr cinfo,
+                                  boolean force_baseline);
+#endif
+EXTERN(void) jpeg_add_quant_table(j_compress_ptr cinfo, int which_tbl,
+                                  const unsigned int *basic_table,
+                                  int scale_factor, boolean force_baseline);
+EXTERN(int) jpeg_quality_scaling(int quality);
+EXTERN(void) jpeg_simple_progression(j_compress_ptr cinfo);
+EXTERN(void) jpeg_suppress_tables(j_compress_ptr cinfo, boolean suppress);
+EXTERN(JQUANT_TBL *) jpeg_alloc_quant_table(j_common_ptr cinfo);
+EXTERN(JHUFF_TBL *) jpeg_alloc_huff_table(j_common_ptr cinfo);
+
+/* Main entry points for compression */
+EXTERN(void) jpeg_start_compress(j_compress_ptr cinfo,
+                                 boolean write_all_tables);
+EXTERN(JDIMENSION) jpeg_write_scanlines(j_compress_ptr cinfo,
+                                        JSAMPARRAY scanlines,
+                                        JDIMENSION num_lines);
+EXTERN(void) jpeg_finish_compress(j_compress_ptr cinfo);
+
+#if JPEG_LIB_VERSION >= 70
+/* Precalculate JPEG dimensions for current compression parameters. */
+EXTERN(void) jpeg_calc_jpeg_dimensions(j_compress_ptr cinfo);
+#endif
+
+/* Replaces jpeg_write_scanlines when writing raw downsampled data. */
+EXTERN(JDIMENSION) jpeg_write_raw_data(j_compress_ptr cinfo, JSAMPIMAGE data,
+                                       JDIMENSION num_lines);
+
+/* Write a special marker.  See libjpeg.txt concerning safe usage. */
+EXTERN(void) jpeg_write_marker(j_compress_ptr cinfo, int marker,
+                               const JOCTET *dataptr, unsigned int datalen);
+/* Same, but piecemeal. */
+EXTERN(void) jpeg_write_m_header(j_compress_ptr cinfo, int marker,
+                                 unsigned int datalen);
+EXTERN(void) jpeg_write_m_byte(j_compress_ptr cinfo, int val);
+
+/* Alternate compression function: just write an abbreviated table file */
+EXTERN(void) jpeg_write_tables(j_compress_ptr cinfo);
+
+/* Write ICC profile.  See libjpeg.txt for usage information. */
+EXTERN(void) jpeg_write_icc_profile(j_compress_ptr cinfo,
+                                    const JOCTET *icc_data_ptr,
+                                    unsigned int icc_data_len);
+
+
+/* Decompression startup: read start of JPEG datastream to see what's there */
+EXTERN(int) jpeg_read_header(j_decompress_ptr cinfo, boolean require_image);
+/* Return value is one of: */
+#define JPEG_SUSPENDED           0 /* Suspended due to lack of input data */
+#define JPEG_HEADER_OK           1 /* Found valid image datastream */
+#define JPEG_HEADER_TABLES_ONLY  2 /* Found valid table-specs-only datastream */
+/* If you pass require_image = TRUE (normal case), you need not check for
+ * a TABLES_ONLY return code; an abbreviated file will cause an error exit.
+ * JPEG_SUSPENDED is only possible if you use a data source module that can
+ * give a suspension return (the stdio source module doesn't).
+ */
+
+/* Main entry points for decompression */
+EXTERN(boolean) jpeg_start_decompress(j_decompress_ptr cinfo);
+EXTERN(JDIMENSION) jpeg_read_scanlines(j_decompress_ptr cinfo,
+                                       JSAMPARRAY scanlines,
+                                       JDIMENSION max_lines);
+EXTERN(JDIMENSION) jpeg_skip_scanlines(j_decompress_ptr cinfo,
+                                       JDIMENSION num_lines);
+EXTERN(void) jpeg_crop_scanline(j_decompress_ptr cinfo, JDIMENSION *xoffset,
+                                JDIMENSION *width);
+EXTERN(boolean) jpeg_finish_decompress(j_decompress_ptr cinfo);
+
+/* Replaces jpeg_read_scanlines when reading raw downsampled data. */
+EXTERN(JDIMENSION) jpeg_read_raw_data(j_decompress_ptr cinfo, JSAMPIMAGE data,
+                                      JDIMENSION max_lines);
+
+/* Additional entry points for buffered-image mode. */
+EXTERN(boolean) jpeg_has_multiple_scans(j_decompress_ptr cinfo);
+EXTERN(boolean) jpeg_start_output(j_decompress_ptr cinfo, int scan_number);
+EXTERN(boolean) jpeg_finish_output(j_decompress_ptr cinfo);
+EXTERN(boolean) jpeg_input_complete(j_decompress_ptr cinfo);
+EXTERN(void) jpeg_new_colormap(j_decompress_ptr cinfo);
+EXTERN(int) jpeg_consume_input(j_decompress_ptr cinfo);
+/* Return value is one of: */
+/* #define JPEG_SUSPENDED       0    Suspended due to lack of input data */
+#define JPEG_REACHED_SOS        1 /* Reached start of new scan */
+#define JPEG_REACHED_EOI        2 /* Reached end of image */
+#define JPEG_ROW_COMPLETED      3 /* Completed one iMCU row */
+#define JPEG_SCAN_COMPLETED     4 /* Completed last iMCU row of a scan */
+
+/* Precalculate output dimensions for current decompression parameters. */
+#if JPEG_LIB_VERSION >= 80
+EXTERN(void) jpeg_core_output_dimensions(j_decompress_ptr cinfo);
+#endif
+EXTERN(void) jpeg_calc_output_dimensions(j_decompress_ptr cinfo);
+
+/* Control saving of COM and APPn markers into marker_list. */
+EXTERN(void) jpeg_save_markers(j_decompress_ptr cinfo, int marker_code,
+                               unsigned int length_limit);
+
+/* Install a special processing method for COM or APPn markers. */
+EXTERN(void) jpeg_set_marker_processor(j_decompress_ptr cinfo,
+                                       int marker_code,
+                                       jpeg_marker_parser_method routine);
+
+/* Read or write raw DCT coefficients --- useful for lossless transcoding. */
+EXTERN(jvirt_barray_ptr *) jpeg_read_coefficients(j_decompress_ptr cinfo);
+EXTERN(void) jpeg_write_coefficients(j_compress_ptr cinfo,
+                                     jvirt_barray_ptr *coef_arrays);
+EXTERN(void) jpeg_copy_critical_parameters(j_decompress_ptr srcinfo,
+                                           j_compress_ptr dstinfo);
+
+/* If you choose to abort compression or decompression before completing
+ * jpeg_finish_(de)compress, then you need to clean up to release memory,
+ * temporary files, etc.  You can just call jpeg_destroy_(de)compress
+ * if you're done with the JPEG object, but if you want to clean it up and
+ * reuse it, call this:
+ */
+EXTERN(void) jpeg_abort_compress(j_compress_ptr cinfo);
+EXTERN(void) jpeg_abort_decompress(j_decompress_ptr cinfo);
+
+/* Generic versions of jpeg_abort and jpeg_destroy that work on either
+ * flavor of JPEG object.  These may be more convenient in some places.
+ */
+EXTERN(void) jpeg_abort(j_common_ptr cinfo);
+EXTERN(void) jpeg_destroy(j_common_ptr cinfo);
+
+/* Default restart-marker-resync procedure for use by data source modules */
+EXTERN(boolean) jpeg_resync_to_restart(j_decompress_ptr cinfo, int desired);
+
+/* Read ICC profile.  See libjpeg.txt for usage information. */
+EXTERN(boolean) jpeg_read_icc_profile(j_decompress_ptr cinfo,
+                                      JOCTET **icc_data_ptr,
+                                      unsigned int *icc_data_len);
+
+
+/* These marker codes are exported since applications and data source modules
+ * are likely to want to use them.
+ */
+
+#define JPEG_RST0       0xD0    /* RST0 marker code */
+#define JPEG_EOI        0xD9    /* EOI marker code */
+#define JPEG_APP0       0xE0    /* APP0 marker code */
+#define JPEG_COM        0xFE    /* COM marker code */
+
+
+/* If we have a brain-damaged compiler that emits warnings (or worse, errors)
+ * for structure definitions that are never filled in, keep it quiet by
+ * supplying dummy definitions for the various substructures.
+ */
+
+#ifdef INCOMPLETE_TYPES_BROKEN
+#ifndef JPEG_INTERNALS          /* will be defined in jpegint.h */
+struct jvirt_sarray_control { long dummy; };
+struct jvirt_barray_control { long dummy; };
+struct jpeg_comp_master { long dummy; };
+struct jpeg_c_main_controller { long dummy; };
+struct jpeg_c_prep_controller { long dummy; };
+struct jpeg_c_coef_controller { long dummy; };
+struct jpeg_marker_writer { long dummy; };
+struct jpeg_color_converter { long dummy; };
+struct jpeg_downsampler { long dummy; };
+struct jpeg_forward_dct { long dummy; };
+struct jpeg_entropy_encoder { long dummy; };
+struct jpeg_decomp_master { long dummy; };
+struct jpeg_d_main_controller { long dummy; };
+struct jpeg_d_coef_controller { long dummy; };
+struct jpeg_d_post_controller { long dummy; };
+struct jpeg_input_controller { long dummy; };
+struct jpeg_marker_reader { long dummy; };
+struct jpeg_entropy_decoder { long dummy; };
+struct jpeg_inverse_dct { long dummy; };
+struct jpeg_upsampler { long dummy; };
+struct jpeg_color_deconverter { long dummy; };
+struct jpeg_color_quantizer { long dummy; };
+#endif /* JPEG_INTERNALS */
+#endif /* INCOMPLETE_TYPES_BROKEN */
+
+
+/*
+ * The JPEG library modules define JPEG_INTERNALS before including this file.
+ * The internal structure declarations are read only when that is true.
+ * Applications using the library should not include jpegint.h, but may wish
+ * to include jerror.h.
+ */
+
+#ifdef JPEG_INTERNALS
+#include "jpegint.h"            /* fetch private declarations */
+#include "jerror.h"             /* fetch error codes too */
+#endif
+
+#ifdef __cplusplus
+#ifndef DONT_USE_EXTERN_C
+}
+#endif
+#endif
+
+#endif /* JPEGLIB_H */
diff --git a/3rdparty/libjpeg/src/jpegtran.1 b/3rdparty/libjpeg/src/jpegtran.1
new file mode 100644
index 00000000..da7a2669
--- /dev/null
+++ b/3rdparty/libjpeg/src/jpegtran.1
@@ -0,0 +1,358 @@
+.TH JPEGTRAN 1 "26 October 2020"
+.SH NAME
+jpegtran \- lossless transformation of JPEG files
+.SH SYNOPSIS
+.B jpegtran
+[
+.I options
+]
+[
+.I filename
+]
+.LP
+.SH DESCRIPTION
+.LP
+.B jpegtran
+performs various useful transformations of JPEG files.
+It can translate the coded representation from one variant of JPEG to another,
+for example from baseline JPEG to progressive JPEG or vice versa.  It can also
+perform some rearrangements of the image data, for example turning an image
+from landscape to portrait format by rotation.
+.PP
+For EXIF files and JPEG files containing Exif data, you may prefer to use
+.B exiftran
+instead.
+.PP
+.B jpegtran
+works by rearranging the compressed data (DCT coefficients), without
+ever fully decoding the image.  Therefore, its transformations are lossless:
+there is no image degradation at all, which would not be true if you used
+.B djpeg
+followed by
+.B cjpeg
+to accomplish the same conversion.  But by the same token,
+.B jpegtran
+cannot perform lossy operations such as changing the image quality.  However,
+while the image data is losslessly transformed, metadata can be removed.  See
+the
+.B \-copy
+option for specifics.
+.PP
+.B jpegtran
+reads the named JPEG/JFIF file, or the standard input if no file is
+named, and produces a JPEG/JFIF file on the standard output.
+.SH OPTIONS
+All switch names may be abbreviated; for example,
+.B \-optimize
+may be written
+.B \-opt
+or
+.BR \-o .
+Upper and lower case are equivalent.
+British spellings are also accepted (e.g.,
+.BR \-optimise ),
+though for brevity these are not mentioned below.
+.PP
+To specify the coded JPEG representation used in the output file,
+.B jpegtran
+accepts a subset of the switches recognized by
+.BR cjpeg :
+.TP
+.B \-optimize
+Perform optimization of entropy encoding parameters.
+.TP
+.B \-progressive
+Create progressive JPEG file.
+.TP
+.BI \-restart " N"
+Emit a JPEG restart marker every N MCU rows, or every N MCU blocks if "B" is
+attached to the number.
+.TP
+.B \-arithmetic
+Use arithmetic coding.
+.TP
+.BI \-scans " file"
+Use the scan script given in the specified text file.
+.PP
+See
+.BR cjpeg (1)
+for more details about these switches.
+If you specify none of these switches, you get a plain baseline-JPEG output
+file.  The quality setting and so forth are determined by the input file.
+.PP
+The image can be losslessly transformed by giving one of these switches:
+.TP
+.B \-flip horizontal
+Mirror image horizontally (left-right).
+.TP
+.B \-flip vertical
+Mirror image vertically (top-bottom).
+.TP
+.B \-rotate 90
+Rotate image 90 degrees clockwise.
+.TP
+.B \-rotate 180
+Rotate image 180 degrees.
+.TP
+.B \-rotate 270
+Rotate image 270 degrees clockwise (or 90 ccw).
+.TP
+.B \-transpose
+Transpose image (across UL-to-LR axis).
+.TP
+.B \-transverse
+Transverse transpose (across UR-to-LL axis).
+.PP
+The transpose transformation has no restrictions regarding image dimensions.
+The other transformations operate rather oddly if the image dimensions are not
+a multiple of the iMCU size (usually 8 or 16 pixels), because they can only
+transform complete blocks of DCT coefficient data in the desired way.
+.PP
+.BR jpegtran 's
+default behavior when transforming an odd-size image is designed
+to preserve exact reversibility and mathematical consistency of the
+transformation set.  As stated, transpose is able to flip the entire image
+area.  Horizontal mirroring leaves any partial iMCU column at the right edge
+untouched, but is able to flip all rows of the image.  Similarly, vertical
+mirroring leaves any partial iMCU row at the bottom edge untouched, but is
+able to flip all columns.  The other transforms can be built up as sequences
+of transpose and flip operations; for consistency, their actions on edge
+pixels are defined to be the same as the end result of the corresponding
+transpose-and-flip sequence.
+.PP
+For practical use, you may prefer to discard any untransformable edge pixels
+rather than having a strange-looking strip along the right and/or bottom edges
+of a transformed image.  To do this, add the
+.B \-trim
+switch:
+.TP
+.B \-trim
+Drop non-transformable edge blocks.
+.IP
+Obviously, a transformation with
+.B \-trim
+is not reversible, so strictly speaking
+.B jpegtran
+with this switch is not lossless.  Also, the expected mathematical
+equivalences between the transformations no longer hold.  For example,
+.B \-rot 270 -trim
+trims only the bottom edge, but
+.B \-rot 90 -trim
+followed by
+.B \-rot 180 -trim
+trims both edges.
+.TP
+.B \-perfect
+If you are only interested in perfect transformations, add the
+.B \-perfect
+switch.  This causes
+.B jpegtran
+to fail with an error if the transformation is not perfect.
+.IP
+For example, you may want to do
+.IP
+.B (jpegtran \-rot 90 -perfect
+.I foo.jpg
+.B || djpeg
+.I foo.jpg
+.B | pnmflip \-r90 | cjpeg)
+.IP
+to do a perfect rotation, if available, or an approximated one if not.
+.PP
+This version of \fBjpegtran\fR also offers a lossless crop option, which
+discards data outside of a given image region but losslessly preserves what is
+inside.  Like the rotate and flip transforms, lossless crop is restricted by
+the current JPEG format; the upper left corner of the selected region must fall
+on an iMCU boundary.  If it doesn't, then it is silently moved up and/or left
+to the nearest iMCU boundary (the lower right corner is unchanged.)  Thus, the
+output image covers at least the requested region, but it may cover more.  The
+adjustment of the region dimensions may be optionally disabled by attaching an
+'f' character ("force") to the width or height number.
+
+The image can be losslessly cropped by giving the switch:
+.TP
+.B \-crop WxH+X+Y
+Crop the image to a rectangular region of width W and height H, starting at
+point X,Y.  The lossless crop feature discards data outside of a given image
+region but losslessly preserves what is inside.  Like the rotate and flip
+transforms, lossless crop is restricted by the current JPEG format; the upper
+left corner of the selected region must fall on an iMCU boundary.  If it
+doesn't, then it is silently moved up and/or left to the nearest iMCU boundary
+(the lower right corner is unchanged.)
+.PP
+If W or H is larger than the width/height of the input image, then the output
+image is expanded in size, and the expanded region is filled in with zeros
+(neutral gray).  Attaching an 'f' character ("flatten") to the width number
+will cause each block in the expanded region to be filled in with the DC
+coefficient of the nearest block in the input image rather than grayed out.
+Attaching an 'r' character ("reflect") to the width number will cause the
+expanded region to be filled in with repeated reflections of the input image
+rather than grayed out.
+.PP
+A complementary lossless wipe option is provided to discard (gray out) data
+inside a given image region while losslessly preserving what is outside:
+.TP
+.B \-wipe WxH+X+Y
+Wipe (gray out) a rectangular region of width W and height H from the input
+image, starting at point X,Y.
+.PP
+Attaching an 'f' character ("flatten") to the width number will cause the
+region to be filled with the average of adjacent blocks rather than grayed out.
+If the wipe region and the region outside the wipe region, when adjusted to the
+nearest iMCU boundary, form two horizontally adjacent rectangles, then
+attaching an 'r' character ("reflect") to the width number will cause the wipe
+region to be filled with repeated reflections of the outside region rather than
+grayed out.
+.PP
+A lossless drop option is also provided, which allows another JPEG image to be
+inserted ("dropped") into the input image data at a given position, replacing
+the existing image data at that position:
+.TP
+.B \-drop +X+Y filename
+Drop (insert) another image at point X,Y
+.PP
+Both the input image and the drop image must have the same subsampling level.
+It is best if they also have the same quantization (quality.)  Otherwise, the
+quantization of the output image will be adapted to accommodate the higher of
+the input image quality and the drop image quality.  The trim option can be
+used with the drop option to requantize the drop image to match the input
+image.  Note that a grayscale image can be dropped into a full-color image or
+vice versa, as long as the full-color image has no vertical subsampling.  If
+the input image is grayscale and the drop image is full-color, then the
+chrominance channels from the drop image will be discarded.
+.PP
+Other not-strictly-lossless transformation switches are:
+.TP
+.B \-grayscale
+Force grayscale output.
+.IP
+This option discards the chrominance channels if the input image is YCbCr
+(ie, a standard color JPEG), resulting in a grayscale JPEG file.  The
+luminance channel is preserved exactly, so this is a better method of reducing
+to grayscale than decompression, conversion, and recompression.  This switch
+is particularly handy for fixing a monochrome picture that was mistakenly
+encoded as a color JPEG.  (In such a case, the space savings from getting rid
+of the near-empty chroma channels won't be large; but the decoding time for
+a grayscale JPEG is substantially less than that for a color JPEG.)
+.PP
+.B jpegtran
+also recognizes these switches that control what to do with "extra" markers,
+such as comment blocks:
+.TP
+.B \-copy none
+Copy no extra markers from source file.  This setting suppresses all
+comments and other metadata in the source file.
+.TP
+.B \-copy comments
+Copy only comment markers.  This setting copies comments from the source file
+but discards any other metadata.
+.TP
+.B \-copy all
+Copy all extra markers.  This setting preserves miscellaneous markers
+found in the source file, such as JFIF thumbnails, Exif data, and Photoshop
+settings.  In some files, these extra markers can be sizable.  Note that this
+option will copy thumbnails as-is; they will not be transformed.
+.PP
+The default behavior is \fB-copy comments\fR.  (Note: in IJG releases v6 and
+v6a, \fBjpegtran\fR always did the equivalent of \fB-copy none\fR.)
+.PP
+Additional switches recognized by jpegtran are:
+.TP
+.BI \-icc " file"
+Embed ICC color management profile contained in the specified file.  Note that
+this will cause \fBjpegtran\fR to ignore any APP2 markers in the input file,
+even if \fB-copy all\fR is specified.
+.TP
+.BI \-maxmemory " N"
+Set limit for amount of memory to use in processing large images.  Value is
+in thousands of bytes, or millions of bytes if "M" is attached to the
+number.  For example,
+.B \-max 4m
+selects 4000000 bytes.  If more space is needed, an error will occur.
+.TP
+.BI \-maxscans " N"
+Abort if the input image contains more than
+.I N
+scans.  This feature demonstrates a method by which applications can guard
+against denial-of-service attacks instigated by specially-crafted malformed
+JPEG images containing numerous scans with missing image data or image data
+consisting only of "EOB runs" (a feature of progressive JPEG images that allows
+potentially hundreds of thousands of adjoining zero-value pixels to be
+represented using only a few bytes.)  Attempting to transform such malformed
+JPEG images can cause excessive CPU activity, since the decompressor must fully
+process each scan (even if the scan is corrupt) before it can proceed to the
+next scan.
+.TP
+.BI \-outfile " name"
+Send output image to the named file, not to standard output.
+.TP
+.BI \-report
+Report transformation progress.
+.TP
+.BI \-strict
+Treat all warnings as fatal.  This feature also demonstrates a method by which
+applications can guard against attacks instigated by specially-crafted
+malformed JPEG images.  Enabling this option will cause the decompressor to
+abort if the input image contains incomplete or corrupt image data.
+.TP
+.B \-verbose
+Enable debug printout.  More
+.BR \-v 's
+give more output.  Also, version information is printed at startup.
+.TP
+.B \-debug
+Same as
+.BR \-verbose .
+.TP
+.B \-version
+Print version information and exit.
+.SH EXAMPLES
+.LP
+This example converts a baseline JPEG file to progressive form:
+.IP
+.B jpegtran \-progressive
+.I foo.jpg
+.B >
+.I fooprog.jpg
+.PP
+This example rotates an image 90 degrees clockwise, discarding any
+unrotatable edge pixels:
+.IP
+.B jpegtran \-rot 90 -trim
+.I foo.jpg
+.B >
+.I foo90.jpg
+.SH ENVIRONMENT
+.TP
+.B JPEGMEM
+If this environment variable is set, its value is the default memory limit.
+The value is specified as described for the
+.B \-maxmemory
+switch.
+.B JPEGMEM
+overrides the default value specified when the program was compiled, and
+itself is overridden by an explicit
+.BR \-maxmemory .
+.SH SEE ALSO
+.BR cjpeg (1),
+.BR djpeg (1),
+.BR rdjpgcom (1),
+.BR wrjpgcom (1)
+.br
+Wallace, Gregory K.  "The JPEG Still Picture Compression Standard",
+Communications of the ACM, April 1991 (vol. 34, no. 4), pp. 30-44.
+.SH AUTHOR
+Independent JPEG Group
+.PP
+This file was modified by The libjpeg-turbo Project to include only information
+relevant to libjpeg-turbo and to wordsmith certain sections.
+.SH BUGS
+The transform options can't transform odd-size images perfectly.  Use
+.B \-trim
+or
+.B \-perfect
+if you don't like the results.
+.PP
+The entire image is read into memory and then written out again, even in
+cases where this isn't really necessary.  Expect swapping on large images,
+especially when using the more complex transform options.
diff --git a/3rdparty/libjpeg/src/jpegtran.c b/3rdparty/libjpeg/src/jpegtran.c
new file mode 100644
index 00000000..244996dd
--- /dev/null
+++ b/3rdparty/libjpeg/src/jpegtran.c
@@ -0,0 +1,734 @@
+/*
+ * jpegtran.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1995-2019, Thomas G. Lane, Guido Vollbeding.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2010, 2014, 2017, 2019-2020, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains a command-line user interface for JPEG transcoding.
+ * It is very similar to cjpeg.c, and partly to djpeg.c, but provides
+ * lossless transcoding between different JPEG file formats.  It also
+ * provides some lossless and sort-of-lossless transformations of JPEG data.
+ */
+
+#include "cdjpeg.h"             /* Common decls for cjpeg/djpeg applications */
+#include "transupp.h"           /* Support routines for jpegtran */
+#include "jversion.h"           /* for version message */
+#include "jconfigint.h"
+
+#ifdef USE_CCOMMAND             /* command-line reader for Macintosh */
+#ifdef __MWERKS__
+#include <SIOUX.h>              /* Metrowerks needs this */
+#include <console.h>            /* ... and this */
+#endif
+#ifdef THINK_C
+#include <console.h>            /* Think declares it here */
+#endif
+#endif
+
+
+/*
+ * Argument-parsing code.
+ * The switch parser is designed to be useful with DOS-style command line
+ * syntax, ie, intermixed switches and file names, where only the switches
+ * to the left of a given file name affect processing of that file.
+ * The main program in this file doesn't actually use this capability...
+ */
+
+
+static const char *progname;    /* program name for error messages */
+static char *icc_filename;      /* for -icc switch */
+JDIMENSION max_scans;           /* for -maxscans switch */
+static char *outfilename;       /* for -outfile switch */
+static char *dropfilename;      /* for -drop switch */
+boolean report;                 /* for -report switch */
+boolean strict;                 /* for -strict switch */
+static JCOPY_OPTION copyoption; /* -copy switch */
+static jpeg_transform_info transformoption; /* image transformation options */
+
+
+LOCAL(void)
+usage(void)
+/* complain about bad command line */
+{
+  fprintf(stderr, "usage: %s [switches] ", progname);
+#ifdef TWO_FILE_COMMANDLINE
+  fprintf(stderr, "inputfile outputfile\n");
+#else
+  fprintf(stderr, "[inputfile]\n");
+#endif
+
+  fprintf(stderr, "Switches (names may be abbreviated):\n");
+  fprintf(stderr, "  -copy none     Copy no extra markers from source file\n");
+  fprintf(stderr, "  -copy comments Copy only comment markers (default)\n");
+  fprintf(stderr, "  -copy all      Copy all extra markers\n");
+#ifdef ENTROPY_OPT_SUPPORTED
+  fprintf(stderr, "  -optimize      Optimize Huffman table (smaller file, but slow compression)\n");
+#endif
+#ifdef C_PROGRESSIVE_SUPPORTED
+  fprintf(stderr, "  -progressive   Create progressive JPEG file\n");
+#endif
+  fprintf(stderr, "Switches for modifying the image:\n");
+#if TRANSFORMS_SUPPORTED
+  fprintf(stderr, "  -crop WxH+X+Y  Crop to a rectangular region\n");
+  fprintf(stderr, "  -drop +X+Y filename          Drop (insert) another image\n");
+  fprintf(stderr, "  -flip [horizontal|vertical]  Mirror image (left-right or top-bottom)\n");
+  fprintf(stderr, "  -grayscale     Reduce to grayscale (omit color data)\n");
+  fprintf(stderr, "  -perfect       Fail if there is non-transformable edge blocks\n");
+  fprintf(stderr, "  -rotate [90|180|270]         Rotate image (degrees clockwise)\n");
+#endif
+#if TRANSFORMS_SUPPORTED
+  fprintf(stderr, "  -transpose     Transpose image\n");
+  fprintf(stderr, "  -transverse    Transverse transpose image\n");
+  fprintf(stderr, "  -trim          Drop non-transformable edge blocks\n");
+  fprintf(stderr, "                 with -drop: Requantize drop file to match source file\n");
+  fprintf(stderr, "  -wipe WxH+X+Y  Wipe (gray out) a rectangular region\n");
+#endif
+  fprintf(stderr, "Switches for advanced users:\n");
+#ifdef C_ARITH_CODING_SUPPORTED
+  fprintf(stderr, "  -arithmetic    Use arithmetic coding\n");
+#endif
+  fprintf(stderr, "  -icc FILE      Embed ICC profile contained in FILE\n");
+  fprintf(stderr, "  -restart N     Set restart interval in rows, or in blocks with B\n");
+  fprintf(stderr, "  -maxmemory N   Maximum memory to use (in kbytes)\n");
+  fprintf(stderr, "  -maxscans N    Maximum number of scans to allow in input file\n");
+  fprintf(stderr, "  -outfile name  Specify name for output file\n");
+  fprintf(stderr, "  -report        Report transformation progress\n");
+  fprintf(stderr, "  -strict        Treat all warnings as fatal\n");
+  fprintf(stderr, "  -verbose  or  -debug   Emit debug output\n");
+  fprintf(stderr, "  -version       Print version information and exit\n");
+  fprintf(stderr, "Switches for wizards:\n");
+#ifdef C_MULTISCAN_FILES_SUPPORTED
+  fprintf(stderr, "  -scans FILE    Create multi-scan JPEG per script FILE\n");
+#endif
+  exit(EXIT_FAILURE);
+}
+
+
+LOCAL(void)
+select_transform(JXFORM_CODE transform)
+/* Silly little routine to detect multiple transform options,
+ * which we can't handle.
+ */
+{
+#if TRANSFORMS_SUPPORTED
+  if (transformoption.transform == JXFORM_NONE ||
+      transformoption.transform == transform) {
+    transformoption.transform = transform;
+  } else {
+    fprintf(stderr, "%s: can only do one image transformation at a time\n",
+            progname);
+    usage();
+  }
+#else
+  fprintf(stderr, "%s: sorry, image transformation was not compiled\n",
+          progname);
+  exit(EXIT_FAILURE);
+#endif
+}
+
+
+LOCAL(int)
+parse_switches(j_compress_ptr cinfo, int argc, char **argv,
+               int last_file_arg_seen, boolean for_real)
+/* Parse optional switches.
+ * Returns argv[] index of first file-name argument (== argc if none).
+ * Any file names with indexes <= last_file_arg_seen are ignored;
+ * they have presumably been processed in a previous iteration.
+ * (Pass 0 for last_file_arg_seen on the first or only iteration.)
+ * for_real is FALSE on the first (dummy) pass; we may skip any expensive
+ * processing.
+ */
+{
+  int argn;
+  char *arg;
+  boolean simple_progressive;
+  char *scansarg = NULL;        /* saves -scans parm if any */
+
+  /* Set up default JPEG parameters. */
+  simple_progressive = FALSE;
+  icc_filename = NULL;
+  max_scans = 0;
+  outfilename = NULL;
+  report = FALSE;
+  strict = FALSE;
+  copyoption = JCOPYOPT_DEFAULT;
+  transformoption.transform = JXFORM_NONE;
+  transformoption.perfect = FALSE;
+  transformoption.trim = FALSE;
+  transformoption.force_grayscale = FALSE;
+  transformoption.crop = FALSE;
+  transformoption.slow_hflip = FALSE;
+  cinfo->err->trace_level = 0;
+
+  /* Scan command line options, adjust parameters */
+
+  for (argn = 1; argn < argc; argn++) {
+    arg = argv[argn];
+    if (*arg != '-') {
+      /* Not a switch, must be a file name argument */
+      if (argn <= last_file_arg_seen) {
+        outfilename = NULL;     /* -outfile applies to just one input file */
+        continue;               /* ignore this name if previously processed */
+      }
+      break;                    /* else done parsing switches */
+    }
+    arg++;                      /* advance past switch marker character */
+
+    if (keymatch(arg, "arithmetic", 1)) {
+      /* Use arithmetic coding. */
+#ifdef C_ARITH_CODING_SUPPORTED
+      cinfo->arith_code = TRUE;
+#else
+      fprintf(stderr, "%s: sorry, arithmetic coding not supported\n",
+              progname);
+      exit(EXIT_FAILURE);
+#endif
+
+    } else if (keymatch(arg, "copy", 2)) {
+      /* Select which extra markers to copy. */
+      if (++argn >= argc)       /* advance to next argument */
+        usage();
+      if (keymatch(argv[argn], "none", 1)) {
+        copyoption = JCOPYOPT_NONE;
+      } else if (keymatch(argv[argn], "comments", 1)) {
+        copyoption = JCOPYOPT_COMMENTS;
+      } else if (keymatch(argv[argn], "all", 1)) {
+        copyoption = JCOPYOPT_ALL;
+      } else
+        usage();
+
+    } else if (keymatch(arg, "crop", 2)) {
+      /* Perform lossless cropping. */
+#if TRANSFORMS_SUPPORTED
+      if (++argn >= argc)       /* advance to next argument */
+        usage();
+      if (transformoption.crop /* reject multiple crop/drop/wipe requests */ ||
+          !jtransform_parse_crop_spec(&transformoption, argv[argn])) {
+        fprintf(stderr, "%s: bogus -crop argument '%s'\n",
+                progname, argv[argn]);
+        exit(EXIT_FAILURE);
+      }
+#else
+      select_transform(JXFORM_NONE);    /* force an error */
+#endif
+
+    } else if (keymatch(arg, "drop", 2)) {
+#if TRANSFORMS_SUPPORTED
+      if (++argn >= argc)       /* advance to next argument */
+        usage();
+      if (transformoption.crop /* reject multiple crop/drop/wipe requests */ ||
+          !jtransform_parse_crop_spec(&transformoption, argv[argn]) ||
+          transformoption.crop_width_set != JCROP_UNSET ||
+          transformoption.crop_height_set != JCROP_UNSET) {
+        fprintf(stderr, "%s: bogus -drop argument '%s'\n",
+                progname, argv[argn]);
+        exit(EXIT_FAILURE);
+      }
+      if (++argn >= argc)       /* advance to next argument */
+        usage();
+      dropfilename = argv[argn];
+      select_transform(JXFORM_DROP);
+#else
+      select_transform(JXFORM_NONE);    /* force an error */
+#endif
+
+    } else if (keymatch(arg, "debug", 1) || keymatch(arg, "verbose", 1)) {
+      /* Enable debug printouts. */
+      /* On first -d, print version identification */
+      static boolean printed_version = FALSE;
+
+      if (!printed_version) {
+        fprintf(stderr, "%s version %s (build %s)\n",
+                PACKAGE_NAME, VERSION, BUILD);
+        fprintf(stderr, "%s\n\n", JCOPYRIGHT);
+        fprintf(stderr, "Emulating The Independent JPEG Group's software, version %s\n\n",
+                JVERSION);
+        printed_version = TRUE;
+      }
+      cinfo->err->trace_level++;
+
+    } else if (keymatch(arg, "version", 4)) {
+      fprintf(stderr, "%s version %s (build %s)\n",
+              PACKAGE_NAME, VERSION, BUILD);
+      exit(EXIT_SUCCESS);
+
+    } else if (keymatch(arg, "flip", 1)) {
+      /* Mirror left-right or top-bottom. */
+      if (++argn >= argc)       /* advance to next argument */
+        usage();
+      if (keymatch(argv[argn], "horizontal", 1))
+        select_transform(JXFORM_FLIP_H);
+      else if (keymatch(argv[argn], "vertical", 1))
+        select_transform(JXFORM_FLIP_V);
+      else
+        usage();
+
+    } else if (keymatch(arg, "grayscale", 1) ||
+               keymatch(arg, "greyscale", 1)) {
+      /* Force to grayscale. */
+#if TRANSFORMS_SUPPORTED
+      transformoption.force_grayscale = TRUE;
+#else
+      select_transform(JXFORM_NONE);    /* force an error */
+#endif
+
+    } else if (keymatch(arg, "icc", 1)) {
+      /* Set ICC filename. */
+      if (++argn >= argc)       /* advance to next argument */
+        usage();
+      icc_filename = argv[argn];
+
+    } else if (keymatch(arg, "maxmemory", 3)) {
+      /* Maximum memory in Kb (or Mb with 'm'). */
+      long lval;
+      char ch = 'x';
+
+      if (++argn >= argc)       /* advance to next argument */
+        usage();
+      if (sscanf(argv[argn], "%ld%c", &lval, &ch) < 1)
+        usage();
+      if (ch == 'm' || ch == 'M')
+        lval *= 1000L;
+      cinfo->mem->max_memory_to_use = lval * 1000L;
+
+    } else if (keymatch(arg, "maxscans", 4)) {
+      if (++argn >= argc)       /* advance to next argument */
+        usage();
+      if (sscanf(argv[argn], "%u", &max_scans) != 1)
+        usage();
+
+    } else if (keymatch(arg, "optimize", 1) || keymatch(arg, "optimise", 1)) {
+      /* Enable entropy parm optimization. */
+#ifdef ENTROPY_OPT_SUPPORTED
+      cinfo->optimize_coding = TRUE;
+#else
+      fprintf(stderr, "%s: sorry, entropy optimization was not compiled\n",
+              progname);
+      exit(EXIT_FAILURE);
+#endif
+
+    } else if (keymatch(arg, "outfile", 4)) {
+      /* Set output file name. */
+      if (++argn >= argc)       /* advance to next argument */
+        usage();
+      outfilename = argv[argn]; /* save it away for later use */
+
+    } else if (keymatch(arg, "perfect", 2)) {
+      /* Fail if there is any partial edge MCUs that the transform can't
+       * handle. */
+      transformoption.perfect = TRUE;
+
+    } else if (keymatch(arg, "progressive", 2)) {
+      /* Select simple progressive mode. */
+#ifdef C_PROGRESSIVE_SUPPORTED
+      simple_progressive = TRUE;
+      /* We must postpone execution until num_components is known. */
+#else
+      fprintf(stderr, "%s: sorry, progressive output was not compiled\n",
+              progname);
+      exit(EXIT_FAILURE);
+#endif
+
+    } else if (keymatch(arg, "report", 3)) {
+      report = TRUE;
+
+    } else if (keymatch(arg, "restart", 1)) {
+      /* Restart interval in MCU rows (or in MCUs with 'b'). */
+      long lval;
+      char ch = 'x';
+
+      if (++argn >= argc)       /* advance to next argument */
+        usage();
+      if (sscanf(argv[argn], "%ld%c", &lval, &ch) < 1)
+        usage();
+      if (lval < 0 || lval > 65535L)
+        usage();
+      if (ch == 'b' || ch == 'B') {
+        cinfo->restart_interval = (unsigned int)lval;
+        cinfo->restart_in_rows = 0; /* else prior '-restart n' overrides me */
+      } else {
+        cinfo->restart_in_rows = (int)lval;
+        /* restart_interval will be computed during startup */
+      }
+
+    } else if (keymatch(arg, "rotate", 2)) {
+      /* Rotate 90, 180, or 270 degrees (measured clockwise). */
+      if (++argn >= argc)       /* advance to next argument */
+        usage();
+      if (keymatch(argv[argn], "90", 2))
+        select_transform(JXFORM_ROT_90);
+      else if (keymatch(argv[argn], "180", 3))
+        select_transform(JXFORM_ROT_180);
+      else if (keymatch(argv[argn], "270", 3))
+        select_transform(JXFORM_ROT_270);
+      else
+        usage();
+
+    } else if (keymatch(arg, "scans", 1)) {
+      /* Set scan script. */
+#ifdef C_MULTISCAN_FILES_SUPPORTED
+      if (++argn >= argc)       /* advance to next argument */
+        usage();
+      scansarg = argv[argn];
+      /* We must postpone reading the file in case -progressive appears. */
+#else
+      fprintf(stderr, "%s: sorry, multi-scan output was not compiled\n",
+              progname);
+      exit(EXIT_FAILURE);
+#endif
+
+    } else if (keymatch(arg, "strict", 2)) {
+      strict = TRUE;
+
+    } else if (keymatch(arg, "transpose", 1)) {
+      /* Transpose (across UL-to-LR axis). */
+      select_transform(JXFORM_TRANSPOSE);
+
+    } else if (keymatch(arg, "transverse", 6)) {
+      /* Transverse transpose (across UR-to-LL axis). */
+      select_transform(JXFORM_TRANSVERSE);
+
+    } else if (keymatch(arg, "trim", 3)) {
+      /* Trim off any partial edge MCUs that the transform can't handle. */
+      transformoption.trim = TRUE;
+
+    } else if (keymatch(arg, "wipe", 1)) {
+#if TRANSFORMS_SUPPORTED
+      if (++argn >= argc)       /* advance to next argument */
+        usage();
+      if (transformoption.crop /* reject multiple crop/drop/wipe requests */ ||
+          !jtransform_parse_crop_spec(&transformoption, argv[argn])) {
+        fprintf(stderr, "%s: bogus -wipe argument '%s'\n",
+                progname, argv[argn]);
+        exit(EXIT_FAILURE);
+      }
+      select_transform(JXFORM_WIPE);
+#else
+      select_transform(JXFORM_NONE);    /* force an error */
+#endif
+
+    } else {
+      usage();                  /* bogus switch */
+    }
+  }
+
+  /* Post-switch-scanning cleanup */
+
+  if (for_real) {
+
+#ifdef C_PROGRESSIVE_SUPPORTED
+    if (simple_progressive)     /* process -progressive; -scans can override */
+      jpeg_simple_progression(cinfo);
+#endif
+
+#ifdef C_MULTISCAN_FILES_SUPPORTED
+    if (scansarg != NULL)       /* process -scans if it was present */
+      if (!read_scan_script(cinfo, scansarg))
+        usage();
+#endif
+  }
+
+  return argn;                  /* return index of next arg (file name) */
+}
+
+
+METHODDEF(void)
+my_emit_message(j_common_ptr cinfo, int msg_level)
+{
+  if (msg_level < 0) {
+    /* Treat warning as fatal */
+    cinfo->err->error_exit(cinfo);
+  } else {
+    if (cinfo->err->trace_level >= msg_level)
+      cinfo->err->output_message(cinfo);
+  }
+}
+
+
+/*
+ * The main program.
+ */
+
+int
+main(int argc, char **argv)
+{
+  struct jpeg_decompress_struct srcinfo;
+#if TRANSFORMS_SUPPORTED
+  struct jpeg_decompress_struct dropinfo;
+  struct jpeg_error_mgr jdroperr;
+  FILE *drop_file;
+#endif
+  struct jpeg_compress_struct dstinfo;
+  struct jpeg_error_mgr jsrcerr, jdsterr;
+  struct cdjpeg_progress_mgr src_progress, dst_progress;
+  jvirt_barray_ptr *src_coef_arrays;
+  jvirt_barray_ptr *dst_coef_arrays;
+  int file_index;
+  /* We assume all-in-memory processing and can therefore use only a
+   * single file pointer for sequential input and output operation.
+   */
+  FILE *fp;
+  FILE *icc_file;
+  JOCTET *icc_profile = NULL;
+  long icc_len = 0;
+
+  /* On Mac, fetch a command line. */
+#ifdef USE_CCOMMAND
+  argc = ccommand(&argv);
+#endif
+
+  progname = argv[0];
+  if (progname == NULL || progname[0] == 0)
+    progname = "jpegtran";      /* in case C library doesn't provide it */
+
+  /* Initialize the JPEG decompression object with default error handling. */
+  srcinfo.err = jpeg_std_error(&jsrcerr);
+  jpeg_create_decompress(&srcinfo);
+  /* Initialize the JPEG compression object with default error handling. */
+  dstinfo.err = jpeg_std_error(&jdsterr);
+  jpeg_create_compress(&dstinfo);
+
+  /* Scan command line to find file names.
+   * It is convenient to use just one switch-parsing routine, but the switch
+   * values read here are mostly ignored; we will rescan the switches after
+   * opening the input file.  Also note that most of the switches affect the
+   * destination JPEG object, so we parse into that and then copy over what
+   * needs to affect the source too.
+   */
+
+  file_index = parse_switches(&dstinfo, argc, argv, 0, FALSE);
+  jsrcerr.trace_level = jdsterr.trace_level;
+  srcinfo.mem->max_memory_to_use = dstinfo.mem->max_memory_to_use;
+
+  if (strict)
+    jsrcerr.emit_message = my_emit_message;
+
+#ifdef TWO_FILE_COMMANDLINE
+  /* Must have either -outfile switch or explicit output file name */
+  if (outfilename == NULL) {
+    if (file_index != argc - 2) {
+      fprintf(stderr, "%s: must name one input and one output file\n",
+              progname);
+      usage();
+    }
+    outfilename = argv[file_index + 1];
+  } else {
+    if (file_index != argc - 1) {
+      fprintf(stderr, "%s: must name one input and one output file\n",
+              progname);
+      usage();
+    }
+  }
+#else
+  /* Unix style: expect zero or one file name */
+  if (file_index < argc - 1) {
+    fprintf(stderr, "%s: only one input file\n", progname);
+    usage();
+  }
+#endif /* TWO_FILE_COMMANDLINE */
+
+  /* Open the input file. */
+  if (file_index < argc) {
+    if ((fp = fopen(argv[file_index], READ_BINARY)) == NULL) {
+      fprintf(stderr, "%s: can't open %s for reading\n", progname,
+              argv[file_index]);
+      exit(EXIT_FAILURE);
+    }
+  } else {
+    /* default input file is stdin */
+    fp = read_stdin();
+  }
+
+  if (icc_filename != NULL) {
+    if ((icc_file = fopen(icc_filename, READ_BINARY)) == NULL) {
+      fprintf(stderr, "%s: can't open %s\n", progname, icc_filename);
+      exit(EXIT_FAILURE);
+    }
+    if (fseek(icc_file, 0, SEEK_END) < 0 ||
+        (icc_len = ftell(icc_file)) < 1 ||
+        fseek(icc_file, 0, SEEK_SET) < 0) {
+      fprintf(stderr, "%s: can't determine size of %s\n", progname,
+              icc_filename);
+      exit(EXIT_FAILURE);
+    }
+    if ((icc_profile = (JOCTET *)malloc(icc_len)) == NULL) {
+      fprintf(stderr, "%s: can't allocate memory for ICC profile\n", progname);
+      fclose(icc_file);
+      exit(EXIT_FAILURE);
+    }
+    if (fread(icc_profile, icc_len, 1, icc_file) < 1) {
+      fprintf(stderr, "%s: can't read ICC profile from %s\n", progname,
+              icc_filename);
+      free(icc_profile);
+      fclose(icc_file);
+      exit(EXIT_FAILURE);
+    }
+    fclose(icc_file);
+    if (copyoption == JCOPYOPT_ALL)
+      copyoption = JCOPYOPT_ALL_EXCEPT_ICC;
+  }
+
+  if (report) {
+    start_progress_monitor((j_common_ptr)&dstinfo, &dst_progress);
+    dst_progress.report = report;
+  }
+  if (report || max_scans != 0) {
+    start_progress_monitor((j_common_ptr)&srcinfo, &src_progress);
+    src_progress.report = report;
+    src_progress.max_scans = max_scans;
+  }
+#if TRANSFORMS_SUPPORTED
+  /* Open the drop file. */
+  if (dropfilename != NULL) {
+    if ((drop_file = fopen(dropfilename, READ_BINARY)) == NULL) {
+      fprintf(stderr, "%s: can't open %s for reading\n", progname,
+              dropfilename);
+      exit(EXIT_FAILURE);
+    }
+    dropinfo.err = jpeg_std_error(&jdroperr);
+    jpeg_create_decompress(&dropinfo);
+    jpeg_stdio_src(&dropinfo, drop_file);
+  } else {
+    drop_file = NULL;
+  }
+#endif
+
+  /* Specify data source for decompression */
+  jpeg_stdio_src(&srcinfo, fp);
+
+  /* Enable saving of extra markers that we want to copy */
+  jcopy_markers_setup(&srcinfo, copyoption);
+
+  /* Read file header */
+  (void)jpeg_read_header(&srcinfo, TRUE);
+
+#if TRANSFORMS_SUPPORTED
+  if (dropfilename != NULL) {
+    (void)jpeg_read_header(&dropinfo, TRUE);
+    transformoption.crop_width = dropinfo.image_width;
+    transformoption.crop_width_set = JCROP_POS;
+    transformoption.crop_height = dropinfo.image_height;
+    transformoption.crop_height_set = JCROP_POS;
+    transformoption.drop_ptr = &dropinfo;
+  }
+#endif
+
+  /* Any space needed by a transform option must be requested before
+   * jpeg_read_coefficients so that memory allocation will be done right.
+   */
+#if TRANSFORMS_SUPPORTED
+  /* Fail right away if -perfect is given and transformation is not perfect.
+   */
+  if (!jtransform_request_workspace(&srcinfo, &transformoption)) {
+    fprintf(stderr, "%s: transformation is not perfect\n", progname);
+    exit(EXIT_FAILURE);
+  }
+#endif
+
+  /* Read source file as DCT coefficients */
+  src_coef_arrays = jpeg_read_coefficients(&srcinfo);
+
+#if TRANSFORMS_SUPPORTED
+  if (dropfilename != NULL) {
+    transformoption.drop_coef_arrays = jpeg_read_coefficients(&dropinfo);
+  }
+#endif
+
+  /* Initialize destination compression parameters from source values */
+  jpeg_copy_critical_parameters(&srcinfo, &dstinfo);
+
+  /* Adjust destination parameters if required by transform options;
+   * also find out which set of coefficient arrays will hold the output.
+   */
+#if TRANSFORMS_SUPPORTED
+  dst_coef_arrays = jtransform_adjust_parameters(&srcinfo, &dstinfo,
+                                                 src_coef_arrays,
+                                                 &transformoption);
+#else
+  dst_coef_arrays = src_coef_arrays;
+#endif
+
+  /* Close input file, if we opened it.
+   * Note: we assume that jpeg_read_coefficients consumed all input
+   * until JPEG_REACHED_EOI, and that jpeg_finish_decompress will
+   * only consume more while (!cinfo->inputctl->eoi_reached).
+   * We cannot call jpeg_finish_decompress here since we still need the
+   * virtual arrays allocated from the source object for processing.
+   */
+  if (fp != stdin)
+    fclose(fp);
+
+  /* Open the output file. */
+  if (outfilename != NULL) {
+    if ((fp = fopen(outfilename, WRITE_BINARY)) == NULL) {
+      fprintf(stderr, "%s: can't open %s for writing\n", progname,
+              outfilename);
+      exit(EXIT_FAILURE);
+    }
+  } else {
+    /* default output file is stdout */
+    fp = write_stdout();
+  }
+
+  /* Adjust default compression parameters by re-parsing the options */
+  file_index = parse_switches(&dstinfo, argc, argv, 0, TRUE);
+
+  /* Specify data destination for compression */
+  jpeg_stdio_dest(&dstinfo, fp);
+
+  /* Start compressor (note no image data is actually written here) */
+  jpeg_write_coefficients(&dstinfo, dst_coef_arrays);
+
+  /* Copy to the output file any extra markers that we want to preserve */
+  jcopy_markers_execute(&srcinfo, &dstinfo, copyoption);
+
+  if (icc_profile != NULL)
+    jpeg_write_icc_profile(&dstinfo, icc_profile, (unsigned int)icc_len);
+
+  /* Execute image transformation, if any */
+#if TRANSFORMS_SUPPORTED
+  jtransform_execute_transformation(&srcinfo, &dstinfo, src_coef_arrays,
+                                    &transformoption);
+#endif
+
+  /* Finish compression and release memory */
+  jpeg_finish_compress(&dstinfo);
+  jpeg_destroy_compress(&dstinfo);
+#if TRANSFORMS_SUPPORTED
+  if (dropfilename != NULL) {
+    (void)jpeg_finish_decompress(&dropinfo);
+    jpeg_destroy_decompress(&dropinfo);
+  }
+#endif
+  (void)jpeg_finish_decompress(&srcinfo);
+  jpeg_destroy_decompress(&srcinfo);
+
+  /* Close output file, if we opened it */
+  if (fp != stdout)
+    fclose(fp);
+#if TRANSFORMS_SUPPORTED
+  if (drop_file != NULL)
+    fclose(drop_file);
+#endif
+
+  if (report)
+    end_progress_monitor((j_common_ptr)&dstinfo);
+  if (report || max_scans != 0)
+    end_progress_monitor((j_common_ptr)&srcinfo);
+
+  free(icc_profile);
+
+  /* All done. */
+#if TRANSFORMS_SUPPORTED
+  if (dropfilename != NULL)
+    exit(jsrcerr.num_warnings + jdroperr.num_warnings +
+         jdsterr.num_warnings ? EXIT_WARNING : EXIT_SUCCESS);
+#endif
+  exit(jsrcerr.num_warnings + jdsterr.num_warnings ?
+       EXIT_WARNING : EXIT_SUCCESS);
+  return 0;                     /* suppress no-return-value warnings */
+}
diff --git a/3rdparty/libjpeg/src/jquant1.c b/3rdparty/libjpeg/src/jquant1.c
new file mode 100644
index 00000000..73b83e16
--- /dev/null
+++ b/3rdparty/libjpeg/src/jquant1.c
@@ -0,0 +1,856 @@
+/*
+ * jquant1.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1991-1996, Thomas G. Lane.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2009, 2015, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains 1-pass color quantization (color mapping) routines.
+ * These routines provide mapping to a fixed color map using equally spaced
+ * color values.  Optional Floyd-Steinberg or ordered dithering is available.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+#ifdef QUANT_1PASS_SUPPORTED
+
+
+/*
+ * The main purpose of 1-pass quantization is to provide a fast, if not very
+ * high quality, colormapped output capability.  A 2-pass quantizer usually
+ * gives better visual quality; however, for quantized grayscale output this
+ * quantizer is perfectly adequate.  Dithering is highly recommended with this
+ * quantizer, though you can turn it off if you really want to.
+ *
+ * In 1-pass quantization the colormap must be chosen in advance of seeing the
+ * image.  We use a map consisting of all combinations of Ncolors[i] color
+ * values for the i'th component.  The Ncolors[] values are chosen so that
+ * their product, the total number of colors, is no more than that requested.
+ * (In most cases, the product will be somewhat less.)
+ *
+ * Since the colormap is orthogonal, the representative value for each color
+ * component can be determined without considering the other components;
+ * then these indexes can be combined into a colormap index by a standard
+ * N-dimensional-array-subscript calculation.  Most of the arithmetic involved
+ * can be precalculated and stored in the lookup table colorindex[].
+ * colorindex[i][j] maps pixel value j in component i to the nearest
+ * representative value (grid plane) for that component; this index is
+ * multiplied by the array stride for component i, so that the
+ * index of the colormap entry closest to a given pixel value is just
+ *    sum( colorindex[component-number][pixel-component-value] )
+ * Aside from being fast, this scheme allows for variable spacing between
+ * representative values with no additional lookup cost.
+ *
+ * If gamma correction has been applied in color conversion, it might be wise
+ * to adjust the color grid spacing so that the representative colors are
+ * equidistant in linear space.  At this writing, gamma correction is not
+ * implemented by jdcolor, so nothing is done here.
+ */
+
+
+/* Declarations for ordered dithering.
+ *
+ * We use a standard 16x16 ordered dither array.  The basic concept of ordered
+ * dithering is described in many references, for instance Dale Schumacher's
+ * chapter II.2 of Graphics Gems II (James Arvo, ed. Academic Press, 1991).
+ * In place of Schumacher's comparisons against a "threshold" value, we add a
+ * "dither" value to the input pixel and then round the result to the nearest
+ * output value.  The dither value is equivalent to (0.5 - threshold) times
+ * the distance between output values.  For ordered dithering, we assume that
+ * the output colors are equally spaced; if not, results will probably be
+ * worse, since the dither may be too much or too little at a given point.
+ *
+ * The normal calculation would be to form pixel value + dither, range-limit
+ * this to 0..MAXJSAMPLE, and then index into the colorindex table as usual.
+ * We can skip the separate range-limiting step by extending the colorindex
+ * table in both directions.
+ */
+
+#define ODITHER_SIZE  16        /* dimension of dither matrix */
+/* NB: if ODITHER_SIZE is not a power of 2, ODITHER_MASK uses will break */
+#define ODITHER_CELLS  (ODITHER_SIZE * ODITHER_SIZE) /* # cells in matrix */
+#define ODITHER_MASK  (ODITHER_SIZE - 1) /* mask for wrapping around
+                                            counters */
+
+typedef int ODITHER_MATRIX[ODITHER_SIZE][ODITHER_SIZE];
+typedef int (*ODITHER_MATRIX_PTR)[ODITHER_SIZE];
+
+static const UINT8 base_dither_matrix[ODITHER_SIZE][ODITHER_SIZE] = {
+  /* Bayer's order-4 dither array.  Generated by the code given in
+   * Stephen Hawley's article "Ordered Dithering" in Graphics Gems I.
+   * The values in this array must range from 0 to ODITHER_CELLS-1.
+   */
+  {   0,192, 48,240, 12,204, 60,252,  3,195, 51,243, 15,207, 63,255 },
+  { 128, 64,176,112,140, 76,188,124,131, 67,179,115,143, 79,191,127 },
+  {  32,224, 16,208, 44,236, 28,220, 35,227, 19,211, 47,239, 31,223 },
+  { 160, 96,144, 80,172,108,156, 92,163, 99,147, 83,175,111,159, 95 },
+  {   8,200, 56,248,  4,196, 52,244, 11,203, 59,251,  7,199, 55,247 },
+  { 136, 72,184,120,132, 68,180,116,139, 75,187,123,135, 71,183,119 },
+  {  40,232, 24,216, 36,228, 20,212, 43,235, 27,219, 39,231, 23,215 },
+  { 168,104,152, 88,164,100,148, 84,171,107,155, 91,167,103,151, 87 },
+  {   2,194, 50,242, 14,206, 62,254,  1,193, 49,241, 13,205, 61,253 },
+  { 130, 66,178,114,142, 78,190,126,129, 65,177,113,141, 77,189,125 },
+  {  34,226, 18,210, 46,238, 30,222, 33,225, 17,209, 45,237, 29,221 },
+  { 162, 98,146, 82,174,110,158, 94,161, 97,145, 81,173,109,157, 93 },
+  {  10,202, 58,250,  6,198, 54,246,  9,201, 57,249,  5,197, 53,245 },
+  { 138, 74,186,122,134, 70,182,118,137, 73,185,121,133, 69,181,117 },
+  {  42,234, 26,218, 38,230, 22,214, 41,233, 25,217, 37,229, 21,213 },
+  { 170,106,154, 90,166,102,150, 86,169,105,153, 89,165,101,149, 85 }
+};
+
+
+/* Declarations for Floyd-Steinberg dithering.
+ *
+ * Errors are accumulated into the array fserrors[], at a resolution of
+ * 1/16th of a pixel count.  The error at a given pixel is propagated
+ * to its not-yet-processed neighbors using the standard F-S fractions,
+ *              ...     (here)  7/16
+ *              3/16    5/16    1/16
+ * We work left-to-right on even rows, right-to-left on odd rows.
+ *
+ * We can get away with a single array (holding one row's worth of errors)
+ * by using it to store the current row's errors at pixel columns not yet
+ * processed, but the next row's errors at columns already processed.  We
+ * need only a few extra variables to hold the errors immediately around the
+ * current column.  (If we are lucky, those variables are in registers, but
+ * even if not, they're probably cheaper to access than array elements are.)
+ *
+ * The fserrors[] array is indexed [component#][position].
+ * We provide (#columns + 2) entries per component; the extra entry at each
+ * end saves us from special-casing the first and last pixels.
+ */
+
+#if BITS_IN_JSAMPLE == 8
+typedef INT16 FSERROR;          /* 16 bits should be enough */
+typedef int LOCFSERROR;         /* use 'int' for calculation temps */
+#else
+typedef JLONG FSERROR;          /* may need more than 16 bits */
+typedef JLONG LOCFSERROR;       /* be sure calculation temps are big enough */
+#endif
+
+typedef FSERROR *FSERRPTR;      /* pointer to error array */
+
+
+/* Private subobject */
+
+#define MAX_Q_COMPS  4          /* max components I can handle */
+
+typedef struct {
+  struct jpeg_color_quantizer pub; /* public fields */
+
+  /* Initially allocated colormap is saved here */
+  JSAMPARRAY sv_colormap;       /* The color map as a 2-D pixel array */
+  int sv_actual;                /* number of entries in use */
+
+  JSAMPARRAY colorindex;        /* Precomputed mapping for speed */
+  /* colorindex[i][j] = index of color closest to pixel value j in component i,
+   * premultiplied as described above.  Since colormap indexes must fit into
+   * JSAMPLEs, the entries of this array will too.
+   */
+  boolean is_padded;            /* is the colorindex padded for odither? */
+
+  int Ncolors[MAX_Q_COMPS];     /* # of values allocated to each component */
+
+  /* Variables for ordered dithering */
+  int row_index;                /* cur row's vertical index in dither matrix */
+  ODITHER_MATRIX_PTR odither[MAX_Q_COMPS]; /* one dither array per component */
+
+  /* Variables for Floyd-Steinberg dithering */
+  FSERRPTR fserrors[MAX_Q_COMPS]; /* accumulated errors */
+  boolean on_odd_row;           /* flag to remember which row we are on */
+} my_cquantizer;
+
+typedef my_cquantizer *my_cquantize_ptr;
+
+
+/*
+ * Policy-making subroutines for create_colormap and create_colorindex.
+ * These routines determine the colormap to be used.  The rest of the module
+ * only assumes that the colormap is orthogonal.
+ *
+ *  * select_ncolors decides how to divvy up the available colors
+ *    among the components.
+ *  * output_value defines the set of representative values for a component.
+ *  * largest_input_value defines the mapping from input values to
+ *    representative values for a component.
+ * Note that the latter two routines may impose different policies for
+ * different components, though this is not currently done.
+ */
+
+
+LOCAL(int)
+select_ncolors(j_decompress_ptr cinfo, int Ncolors[])
+/* Determine allocation of desired colors to components, */
+/* and fill in Ncolors[] array to indicate choice. */
+/* Return value is total number of colors (product of Ncolors[] values). */
+{
+  int nc = cinfo->out_color_components; /* number of color components */
+  int max_colors = cinfo->desired_number_of_colors;
+  int total_colors, iroot, i, j;
+  boolean changed;
+  long temp;
+  int RGB_order[3] = { RGB_GREEN, RGB_RED, RGB_BLUE };
+  RGB_order[0] = rgb_green[cinfo->out_color_space];
+  RGB_order[1] = rgb_red[cinfo->out_color_space];
+  RGB_order[2] = rgb_blue[cinfo->out_color_space];
+
+  /* We can allocate at least the nc'th root of max_colors per component. */
+  /* Compute floor(nc'th root of max_colors). */
+  iroot = 1;
+  do {
+    iroot++;
+    temp = iroot;               /* set temp = iroot ** nc */
+    for (i = 1; i < nc; i++)
+      temp *= iroot;
+  } while (temp <= (long)max_colors); /* repeat till iroot exceeds root */
+  iroot--;                      /* now iroot = floor(root) */
+
+  /* Must have at least 2 color values per component */
+  if (iroot < 2)
+    ERREXIT1(cinfo, JERR_QUANT_FEW_COLORS, (int)temp);
+
+  /* Initialize to iroot color values for each component */
+  total_colors = 1;
+  for (i = 0; i < nc; i++) {
+    Ncolors[i] = iroot;
+    total_colors *= iroot;
+  }
+  /* We may be able to increment the count for one or more components without
+   * exceeding max_colors, though we know not all can be incremented.
+   * Sometimes, the first component can be incremented more than once!
+   * (Example: for 16 colors, we start at 2*2*2, go to 3*2*2, then 4*2*2.)
+   * In RGB colorspace, try to increment G first, then R, then B.
+   */
+  do {
+    changed = FALSE;
+    for (i = 0; i < nc; i++) {
+      j = (cinfo->out_color_space == JCS_RGB ? RGB_order[i] : i);
+      /* calculate new total_colors if Ncolors[j] is incremented */
+      temp = total_colors / Ncolors[j];
+      temp *= Ncolors[j] + 1;   /* done in long arith to avoid oflo */
+      if (temp > (long)max_colors)
+        break;                  /* won't fit, done with this pass */
+      Ncolors[j]++;             /* OK, apply the increment */
+      total_colors = (int)temp;
+      changed = TRUE;
+    }
+  } while (changed);
+
+  return total_colors;
+}
+
+
+LOCAL(int)
+output_value(j_decompress_ptr cinfo, int ci, int j, int maxj)
+/* Return j'th output value, where j will range from 0 to maxj */
+/* The output values must fall in 0..MAXJSAMPLE in increasing order */
+{
+  /* We always provide values 0 and MAXJSAMPLE for each component;
+   * any additional values are equally spaced between these limits.
+   * (Forcing the upper and lower values to the limits ensures that
+   * dithering can't produce a color outside the selected gamut.)
+   */
+  return (int)(((JLONG)j * MAXJSAMPLE + maxj / 2) / maxj);
+}
+
+
+LOCAL(int)
+largest_input_value(j_decompress_ptr cinfo, int ci, int j, int maxj)
+/* Return largest input value that should map to j'th output value */
+/* Must have largest(j=0) >= 0, and largest(j=maxj) >= MAXJSAMPLE */
+{
+  /* Breakpoints are halfway between values returned by output_value */
+  return (int)(((JLONG)(2 * j + 1) * MAXJSAMPLE + maxj) / (2 * maxj));
+}
+
+
+/*
+ * Create the colormap.
+ */
+
+LOCAL(void)
+create_colormap(j_decompress_ptr cinfo)
+{
+  my_cquantize_ptr cquantize = (my_cquantize_ptr)cinfo->cquantize;
+  JSAMPARRAY colormap;          /* Created colormap */
+  int total_colors;             /* Number of distinct output colors */
+  int i, j, k, nci, blksize, blkdist, ptr, val;
+
+  /* Select number of colors for each component */
+  total_colors = select_ncolors(cinfo, cquantize->Ncolors);
+
+  /* Report selected color counts */
+  if (cinfo->out_color_components == 3)
+    TRACEMS4(cinfo, 1, JTRC_QUANT_3_NCOLORS, total_colors,
+             cquantize->Ncolors[0], cquantize->Ncolors[1],
+             cquantize->Ncolors[2]);
+  else
+    TRACEMS1(cinfo, 1, JTRC_QUANT_NCOLORS, total_colors);
+
+  /* Allocate and fill in the colormap. */
+  /* The colors are ordered in the map in standard row-major order, */
+  /* i.e. rightmost (highest-indexed) color changes most rapidly. */
+
+  colormap = (*cinfo->mem->alloc_sarray)
+    ((j_common_ptr)cinfo, JPOOL_IMAGE,
+     (JDIMENSION)total_colors, (JDIMENSION)cinfo->out_color_components);
+
+  /* blksize is number of adjacent repeated entries for a component */
+  /* blkdist is distance between groups of identical entries for a component */
+  blkdist = total_colors;
+
+  for (i = 0; i < cinfo->out_color_components; i++) {
+    /* fill in colormap entries for i'th color component */
+    nci = cquantize->Ncolors[i]; /* # of distinct values for this color */
+    blksize = blkdist / nci;
+    for (j = 0; j < nci; j++) {
+      /* Compute j'th output value (out of nci) for component */
+      val = output_value(cinfo, i, j, nci - 1);
+      /* Fill in all colormap entries that have this value of this component */
+      for (ptr = j * blksize; ptr < total_colors; ptr += blkdist) {
+        /* fill in blksize entries beginning at ptr */
+        for (k = 0; k < blksize; k++)
+          colormap[i][ptr + k] = (JSAMPLE)val;
+      }
+    }
+    blkdist = blksize;          /* blksize of this color is blkdist of next */
+  }
+
+  /* Save the colormap in private storage,
+   * where it will survive color quantization mode changes.
+   */
+  cquantize->sv_colormap = colormap;
+  cquantize->sv_actual = total_colors;
+}
+
+
+/*
+ * Create the color index table.
+ */
+
+LOCAL(void)
+create_colorindex(j_decompress_ptr cinfo)
+{
+  my_cquantize_ptr cquantize = (my_cquantize_ptr)cinfo->cquantize;
+  JSAMPROW indexptr;
+  int i, j, k, nci, blksize, val, pad;
+
+  /* For ordered dither, we pad the color index tables by MAXJSAMPLE in
+   * each direction (input index values can be -MAXJSAMPLE .. 2*MAXJSAMPLE).
+   * This is not necessary in the other dithering modes.  However, we
+   * flag whether it was done in case user changes dithering mode.
+   */
+  if (cinfo->dither_mode == JDITHER_ORDERED) {
+    pad = MAXJSAMPLE * 2;
+    cquantize->is_padded = TRUE;
+  } else {
+    pad = 0;
+    cquantize->is_padded = FALSE;
+  }
+
+  cquantize->colorindex = (*cinfo->mem->alloc_sarray)
+    ((j_common_ptr)cinfo, JPOOL_IMAGE,
+     (JDIMENSION)(MAXJSAMPLE + 1 + pad),
+     (JDIMENSION)cinfo->out_color_components);
+
+  /* blksize is number of adjacent repeated entries for a component */
+  blksize = cquantize->sv_actual;
+
+  for (i = 0; i < cinfo->out_color_components; i++) {
+    /* fill in colorindex entries for i'th color component */
+    nci = cquantize->Ncolors[i]; /* # of distinct values for this color */
+    blksize = blksize / nci;
+
+    /* adjust colorindex pointers to provide padding at negative indexes. */
+    if (pad)
+      cquantize->colorindex[i] += MAXJSAMPLE;
+
+    /* in loop, val = index of current output value, */
+    /* and k = largest j that maps to current val */
+    indexptr = cquantize->colorindex[i];
+    val = 0;
+    k = largest_input_value(cinfo, i, 0, nci - 1);
+    for (j = 0; j <= MAXJSAMPLE; j++) {
+      while (j > k)             /* advance val if past boundary */
+        k = largest_input_value(cinfo, i, ++val, nci - 1);
+      /* premultiply so that no multiplication needed in main processing */
+      indexptr[j] = (JSAMPLE)(val * blksize);
+    }
+    /* Pad at both ends if necessary */
+    if (pad)
+      for (j = 1; j <= MAXJSAMPLE; j++) {
+        indexptr[-j] = indexptr[0];
+        indexptr[MAXJSAMPLE + j] = indexptr[MAXJSAMPLE];
+      }
+  }
+}
+
+
+/*
+ * Create an ordered-dither array for a component having ncolors
+ * distinct output values.
+ */
+
+LOCAL(ODITHER_MATRIX_PTR)
+make_odither_array(j_decompress_ptr cinfo, int ncolors)
+{
+  ODITHER_MATRIX_PTR odither;
+  int j, k;
+  JLONG num, den;
+
+  odither = (ODITHER_MATRIX_PTR)
+    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+                                sizeof(ODITHER_MATRIX));
+  /* The inter-value distance for this color is MAXJSAMPLE/(ncolors-1).
+   * Hence the dither value for the matrix cell with fill order f
+   * (f=0..N-1) should be (N-1-2*f)/(2*N) * MAXJSAMPLE/(ncolors-1).
+   * On 16-bit-int machine, be careful to avoid overflow.
+   */
+  den = 2 * ODITHER_CELLS * ((JLONG)(ncolors - 1));
+  for (j = 0; j < ODITHER_SIZE; j++) {
+    for (k = 0; k < ODITHER_SIZE; k++) {
+      num = ((JLONG)(ODITHER_CELLS - 1 -
+                     2 * ((int)base_dither_matrix[j][k]))) * MAXJSAMPLE;
+      /* Ensure round towards zero despite C's lack of consistency
+       * about rounding negative values in integer division...
+       */
+      odither[j][k] = (int)(num < 0 ? -((-num) / den) : num / den);
+    }
+  }
+  return odither;
+}
+
+
+/*
+ * Create the ordered-dither tables.
+ * Components having the same number of representative colors may
+ * share a dither table.
+ */
+
+LOCAL(void)
+create_odither_tables(j_decompress_ptr cinfo)
+{
+  my_cquantize_ptr cquantize = (my_cquantize_ptr)cinfo->cquantize;
+  ODITHER_MATRIX_PTR odither;
+  int i, j, nci;
+
+  for (i = 0; i < cinfo->out_color_components; i++) {
+    nci = cquantize->Ncolors[i]; /* # of distinct values for this color */
+    odither = NULL;             /* search for matching prior component */
+    for (j = 0; j < i; j++) {
+      if (nci == cquantize->Ncolors[j]) {
+        odither = cquantize->odither[j];
+        break;
+      }
+    }
+    if (odither == NULL)        /* need a new table? */
+      odither = make_odither_array(cinfo, nci);
+    cquantize->odither[i] = odither;
+  }
+}
+
+
+/*
+ * Map some rows of pixels to the output colormapped representation.
+ */
+
+METHODDEF(void)
+color_quantize(j_decompress_ptr cinfo, JSAMPARRAY input_buf,
+               JSAMPARRAY output_buf, int num_rows)
+/* General case, no dithering */
+{
+  my_cquantize_ptr cquantize = (my_cquantize_ptr)cinfo->cquantize;
+  JSAMPARRAY colorindex = cquantize->colorindex;
+  register int pixcode, ci;
+  register JSAMPROW ptrin, ptrout;
+  int row;
+  JDIMENSION col;
+  JDIMENSION width = cinfo->output_width;
+  register int nc = cinfo->out_color_components;
+
+  for (row = 0; row < num_rows; row++) {
+    ptrin = input_buf[row];
+    ptrout = output_buf[row];
+    for (col = width; col > 0; col--) {
+      pixcode = 0;
+      for (ci = 0; ci < nc; ci++) {
+        pixcode += colorindex[ci][*ptrin++];
+      }
+      *ptrout++ = (JSAMPLE)pixcode;
+    }
+  }
+}
+
+
+METHODDEF(void)
+color_quantize3(j_decompress_ptr cinfo, JSAMPARRAY input_buf,
+                JSAMPARRAY output_buf, int num_rows)
+/* Fast path for out_color_components==3, no dithering */
+{
+  my_cquantize_ptr cquantize = (my_cquantize_ptr)cinfo->cquantize;
+  register int pixcode;
+  register JSAMPROW ptrin, ptrout;
+  JSAMPROW colorindex0 = cquantize->colorindex[0];
+  JSAMPROW colorindex1 = cquantize->colorindex[1];
+  JSAMPROW colorindex2 = cquantize->colorindex[2];
+  int row;
+  JDIMENSION col;
+  JDIMENSION width = cinfo->output_width;
+
+  for (row = 0; row < num_rows; row++) {
+    ptrin = input_buf[row];
+    ptrout = output_buf[row];
+    for (col = width; col > 0; col--) {
+      pixcode  = colorindex0[*ptrin++];
+      pixcode += colorindex1[*ptrin++];
+      pixcode += colorindex2[*ptrin++];
+      *ptrout++ = (JSAMPLE)pixcode;
+    }
+  }
+}
+
+
+METHODDEF(void)
+quantize_ord_dither(j_decompress_ptr cinfo, JSAMPARRAY input_buf,
+                    JSAMPARRAY output_buf, int num_rows)
+/* General case, with ordered dithering */
+{
+  my_cquantize_ptr cquantize = (my_cquantize_ptr)cinfo->cquantize;
+  register JSAMPROW input_ptr;
+  register JSAMPROW output_ptr;
+  JSAMPROW colorindex_ci;
+  int *dither;                  /* points to active row of dither matrix */
+  int row_index, col_index;     /* current indexes into dither matrix */
+  int nc = cinfo->out_color_components;
+  int ci;
+  int row;
+  JDIMENSION col;
+  JDIMENSION width = cinfo->output_width;
+
+  for (row = 0; row < num_rows; row++) {
+    /* Initialize output values to 0 so can process components separately */
+    jzero_far((void *)output_buf[row], (size_t)(width * sizeof(JSAMPLE)));
+    row_index = cquantize->row_index;
+    for (ci = 0; ci < nc; ci++) {
+      input_ptr = input_buf[row] + ci;
+      output_ptr = output_buf[row];
+      colorindex_ci = cquantize->colorindex[ci];
+      dither = cquantize->odither[ci][row_index];
+      col_index = 0;
+
+      for (col = width; col > 0; col--) {
+        /* Form pixel value + dither, range-limit to 0..MAXJSAMPLE,
+         * select output value, accumulate into output code for this pixel.
+         * Range-limiting need not be done explicitly, as we have extended
+         * the colorindex table to produce the right answers for out-of-range
+         * inputs.  The maximum dither is +- MAXJSAMPLE; this sets the
+         * required amount of padding.
+         */
+        *output_ptr +=
+          colorindex_ci[*input_ptr + dither[col_index]];
+        input_ptr += nc;
+        output_ptr++;
+        col_index = (col_index + 1) & ODITHER_MASK;
+      }
+    }
+    /* Advance row index for next row */
+    row_index = (row_index + 1) & ODITHER_MASK;
+    cquantize->row_index = row_index;
+  }
+}
+
+
+METHODDEF(void)
+quantize3_ord_dither(j_decompress_ptr cinfo, JSAMPARRAY input_buf,
+                     JSAMPARRAY output_buf, int num_rows)
+/* Fast path for out_color_components==3, with ordered dithering */
+{
+  my_cquantize_ptr cquantize = (my_cquantize_ptr)cinfo->cquantize;
+  register int pixcode;
+  register JSAMPROW input_ptr;
+  register JSAMPROW output_ptr;
+  JSAMPROW colorindex0 = cquantize->colorindex[0];
+  JSAMPROW colorindex1 = cquantize->colorindex[1];
+  JSAMPROW colorindex2 = cquantize->colorindex[2];
+  int *dither0;                 /* points to active row of dither matrix */
+  int *dither1;
+  int *dither2;
+  int row_index, col_index;     /* current indexes into dither matrix */
+  int row;
+  JDIMENSION col;
+  JDIMENSION width = cinfo->output_width;
+
+  for (row = 0; row < num_rows; row++) {
+    row_index = cquantize->row_index;
+    input_ptr = input_buf[row];
+    output_ptr = output_buf[row];
+    dither0 = cquantize->odither[0][row_index];
+    dither1 = cquantize->odither[1][row_index];
+    dither2 = cquantize->odither[2][row_index];
+    col_index = 0;
+
+    for (col = width; col > 0; col--) {
+      pixcode  = colorindex0[(*input_ptr++) + dither0[col_index]];
+      pixcode += colorindex1[(*input_ptr++) + dither1[col_index]];
+      pixcode += colorindex2[(*input_ptr++) + dither2[col_index]];
+      *output_ptr++ = (JSAMPLE)pixcode;
+      col_index = (col_index + 1) & ODITHER_MASK;
+    }
+    row_index = (row_index + 1) & ODITHER_MASK;
+    cquantize->row_index = row_index;
+  }
+}
+
+
+METHODDEF(void)
+quantize_fs_dither(j_decompress_ptr cinfo, JSAMPARRAY input_buf,
+                   JSAMPARRAY output_buf, int num_rows)
+/* General case, with Floyd-Steinberg dithering */
+{
+  my_cquantize_ptr cquantize = (my_cquantize_ptr)cinfo->cquantize;
+  register LOCFSERROR cur;      /* current error or pixel value */
+  LOCFSERROR belowerr;          /* error for pixel below cur */
+  LOCFSERROR bpreverr;          /* error for below/prev col */
+  LOCFSERROR bnexterr;          /* error for below/next col */
+  LOCFSERROR delta;
+  register FSERRPTR errorptr;   /* => fserrors[] at column before current */
+  register JSAMPROW input_ptr;
+  register JSAMPROW output_ptr;
+  JSAMPROW colorindex_ci;
+  JSAMPROW colormap_ci;
+  int pixcode;
+  int nc = cinfo->out_color_components;
+  int dir;                      /* 1 for left-to-right, -1 for right-to-left */
+  int dirnc;                    /* dir * nc */
+  int ci;
+  int row;
+  JDIMENSION col;
+  JDIMENSION width = cinfo->output_width;
+  JSAMPLE *range_limit = cinfo->sample_range_limit;
+  SHIFT_TEMPS
+
+  for (row = 0; row < num_rows; row++) {
+    /* Initialize output values to 0 so can process components separately */
+    jzero_far((void *)output_buf[row], (size_t)(width * sizeof(JSAMPLE)));
+    for (ci = 0; ci < nc; ci++) {
+      input_ptr = input_buf[row] + ci;
+      output_ptr = output_buf[row];
+      if (cquantize->on_odd_row) {
+        /* work right to left in this row */
+        input_ptr += (width - 1) * nc; /* so point to rightmost pixel */
+        output_ptr += width - 1;
+        dir = -1;
+        dirnc = -nc;
+        errorptr = cquantize->fserrors[ci] + (width + 1); /* => entry after last column */
+      } else {
+        /* work left to right in this row */
+        dir = 1;
+        dirnc = nc;
+        errorptr = cquantize->fserrors[ci]; /* => entry before first column */
+      }
+      colorindex_ci = cquantize->colorindex[ci];
+      colormap_ci = cquantize->sv_colormap[ci];
+      /* Preset error values: no error propagated to first pixel from left */
+      cur = 0;
+      /* and no error propagated to row below yet */
+      belowerr = bpreverr = 0;
+
+      for (col = width; col > 0; col--) {
+        /* cur holds the error propagated from the previous pixel on the
+         * current line.  Add the error propagated from the previous line
+         * to form the complete error correction term for this pixel, and
+         * round the error term (which is expressed * 16) to an integer.
+         * RIGHT_SHIFT rounds towards minus infinity, so adding 8 is correct
+         * for either sign of the error value.
+         * Note: errorptr points to *previous* column's array entry.
+         */
+        cur = RIGHT_SHIFT(cur + errorptr[dir] + 8, 4);
+        /* Form pixel value + error, and range-limit to 0..MAXJSAMPLE.
+         * The maximum error is +- MAXJSAMPLE; this sets the required size
+         * of the range_limit array.
+         */
+        cur += *input_ptr;
+        cur = range_limit[cur];
+        /* Select output value, accumulate into output code for this pixel */
+        pixcode = colorindex_ci[cur];
+        *output_ptr += (JSAMPLE)pixcode;
+        /* Compute actual representation error at this pixel */
+        /* Note: we can do this even though we don't have the final */
+        /* pixel code, because the colormap is orthogonal. */
+        cur -= colormap_ci[pixcode];
+        /* Compute error fractions to be propagated to adjacent pixels.
+         * Add these into the running sums, and simultaneously shift the
+         * next-line error sums left by 1 column.
+         */
+        bnexterr = cur;
+        delta = cur * 2;
+        cur += delta;           /* form error * 3 */
+        errorptr[0] = (FSERROR)(bpreverr + cur);
+        cur += delta;           /* form error * 5 */
+        bpreverr = belowerr + cur;
+        belowerr = bnexterr;
+        cur += delta;           /* form error * 7 */
+        /* At this point cur contains the 7/16 error value to be propagated
+         * to the next pixel on the current line, and all the errors for the
+         * next line have been shifted over. We are therefore ready to move on.
+         */
+        input_ptr += dirnc;     /* advance input ptr to next column */
+        output_ptr += dir;      /* advance output ptr to next column */
+        errorptr += dir;        /* advance errorptr to current column */
+      }
+      /* Post-loop cleanup: we must unload the final error value into the
+       * final fserrors[] entry.  Note we need not unload belowerr because
+       * it is for the dummy column before or after the actual array.
+       */
+      errorptr[0] = (FSERROR)bpreverr; /* unload prev err into array */
+    }
+    cquantize->on_odd_row = (cquantize->on_odd_row ? FALSE : TRUE);
+  }
+}
+
+
+/*
+ * Allocate workspace for Floyd-Steinberg errors.
+ */
+
+LOCAL(void)
+alloc_fs_workspace(j_decompress_ptr cinfo)
+{
+  my_cquantize_ptr cquantize = (my_cquantize_ptr)cinfo->cquantize;
+  size_t arraysize;
+  int i;
+
+  arraysize = (size_t)((cinfo->output_width + 2) * sizeof(FSERROR));
+  for (i = 0; i < cinfo->out_color_components; i++) {
+    cquantize->fserrors[i] = (FSERRPTR)
+      (*cinfo->mem->alloc_large) ((j_common_ptr)cinfo, JPOOL_IMAGE, arraysize);
+  }
+}
+
+
+/*
+ * Initialize for one-pass color quantization.
+ */
+
+METHODDEF(void)
+start_pass_1_quant(j_decompress_ptr cinfo, boolean is_pre_scan)
+{
+  my_cquantize_ptr cquantize = (my_cquantize_ptr)cinfo->cquantize;
+  size_t arraysize;
+  int i;
+
+  /* Install my colormap. */
+  cinfo->colormap = cquantize->sv_colormap;
+  cinfo->actual_number_of_colors = cquantize->sv_actual;
+
+  /* Initialize for desired dithering mode. */
+  switch (cinfo->dither_mode) {
+  case JDITHER_NONE:
+    if (cinfo->out_color_components == 3)
+      cquantize->pub.color_quantize = color_quantize3;
+    else
+      cquantize->pub.color_quantize = color_quantize;
+    break;
+  case JDITHER_ORDERED:
+    if (cinfo->out_color_components == 3)
+      cquantize->pub.color_quantize = quantize3_ord_dither;
+    else
+      cquantize->pub.color_quantize = quantize_ord_dither;
+    cquantize->row_index = 0;   /* initialize state for ordered dither */
+    /* If user changed to ordered dither from another mode,
+     * we must recreate the color index table with padding.
+     * This will cost extra space, but probably isn't very likely.
+     */
+    if (!cquantize->is_padded)
+      create_colorindex(cinfo);
+    /* Create ordered-dither tables if we didn't already. */
+    if (cquantize->odither[0] == NULL)
+      create_odither_tables(cinfo);
+    break;
+  case JDITHER_FS:
+    cquantize->pub.color_quantize = quantize_fs_dither;
+    cquantize->on_odd_row = FALSE; /* initialize state for F-S dither */
+    /* Allocate Floyd-Steinberg workspace if didn't already. */
+    if (cquantize->fserrors[0] == NULL)
+      alloc_fs_workspace(cinfo);
+    /* Initialize the propagated errors to zero. */
+    arraysize = (size_t)((cinfo->output_width + 2) * sizeof(FSERROR));
+    for (i = 0; i < cinfo->out_color_components; i++)
+      jzero_far((void *)cquantize->fserrors[i], arraysize);
+    break;
+  default:
+    ERREXIT(cinfo, JERR_NOT_COMPILED);
+    break;
+  }
+}
+
+
+/*
+ * Finish up at the end of the pass.
+ */
+
+METHODDEF(void)
+finish_pass_1_quant(j_decompress_ptr cinfo)
+{
+  /* no work in 1-pass case */
+}
+
+
+/*
+ * Switch to a new external colormap between output passes.
+ * Shouldn't get to this module!
+ */
+
+METHODDEF(void)
+new_color_map_1_quant(j_decompress_ptr cinfo)
+{
+  ERREXIT(cinfo, JERR_MODE_CHANGE);
+}
+
+
+/*
+ * Module initialization routine for 1-pass color quantization.
+ */
+
+GLOBAL(void)
+jinit_1pass_quantizer(j_decompress_ptr cinfo)
+{
+  my_cquantize_ptr cquantize;
+
+  cquantize = (my_cquantize_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+                                sizeof(my_cquantizer));
+  cinfo->cquantize = (struct jpeg_color_quantizer *)cquantize;
+  cquantize->pub.start_pass = start_pass_1_quant;
+  cquantize->pub.finish_pass = finish_pass_1_quant;
+  cquantize->pub.new_color_map = new_color_map_1_quant;
+  cquantize->fserrors[0] = NULL; /* Flag FS workspace not allocated */
+  cquantize->odither[0] = NULL; /* Also flag odither arrays not allocated */
+
+  /* Make sure my internal arrays won't overflow */
+  if (cinfo->out_color_components > MAX_Q_COMPS)
+    ERREXIT1(cinfo, JERR_QUANT_COMPONENTS, MAX_Q_COMPS);
+  /* Make sure colormap indexes can be represented by JSAMPLEs */
+  if (cinfo->desired_number_of_colors > (MAXJSAMPLE + 1))
+    ERREXIT1(cinfo, JERR_QUANT_MANY_COLORS, MAXJSAMPLE + 1);
+
+  /* Create the colormap and color index table. */
+  create_colormap(cinfo);
+  create_colorindex(cinfo);
+
+  /* Allocate Floyd-Steinberg workspace now if requested.
+   * We do this now since it may affect the memory manager's space
+   * calculations.  If the user changes to FS dither mode in a later pass, we
+   * will allocate the space then, and will possibly overrun the
+   * max_memory_to_use setting.
+   */
+  if (cinfo->dither_mode == JDITHER_FS)
+    alloc_fs_workspace(cinfo);
+}
+
+#endif /* QUANT_1PASS_SUPPORTED */
diff --git a/3rdparty/libjpeg/src/jquant2.c b/3rdparty/libjpeg/src/jquant2.c
new file mode 100644
index 00000000..44efb18c
--- /dev/null
+++ b/3rdparty/libjpeg/src/jquant2.c
@@ -0,0 +1,1285 @@
+/*
+ * jquant2.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1991-1996, Thomas G. Lane.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2009, 2014-2015, 2020, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains 2-pass color quantization (color mapping) routines.
+ * These routines provide selection of a custom color map for an image,
+ * followed by mapping of the image to that color map, with optional
+ * Floyd-Steinberg dithering.
+ * It is also possible to use just the second pass to map to an arbitrary
+ * externally-given color map.
+ *
+ * Note: ordered dithering is not supported, since there isn't any fast
+ * way to compute intercolor distances; it's unclear that ordered dither's
+ * fundamental assumptions even hold with an irregularly spaced color map.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+#ifdef QUANT_2PASS_SUPPORTED
+
+
+/*
+ * This module implements the well-known Heckbert paradigm for color
+ * quantization.  Most of the ideas used here can be traced back to
+ * Heckbert's seminal paper
+ *   Heckbert, Paul.  "Color Image Quantization for Frame Buffer Display",
+ *   Proc. SIGGRAPH '82, Computer Graphics v.16 #3 (July 1982), pp 297-304.
+ *
+ * In the first pass over the image, we accumulate a histogram showing the
+ * usage count of each possible color.  To keep the histogram to a reasonable
+ * size, we reduce the precision of the input; typical practice is to retain
+ * 5 or 6 bits per color, so that 8 or 4 different input values are counted
+ * in the same histogram cell.
+ *
+ * Next, the color-selection step begins with a box representing the whole
+ * color space, and repeatedly splits the "largest" remaining box until we
+ * have as many boxes as desired colors.  Then the mean color in each
+ * remaining box becomes one of the possible output colors.
+ *
+ * The second pass over the image maps each input pixel to the closest output
+ * color (optionally after applying a Floyd-Steinberg dithering correction).
+ * This mapping is logically trivial, but making it go fast enough requires
+ * considerable care.
+ *
+ * Heckbert-style quantizers vary a good deal in their policies for choosing
+ * the "largest" box and deciding where to cut it.  The particular policies
+ * used here have proved out well in experimental comparisons, but better ones
+ * may yet be found.
+ *
+ * In earlier versions of the IJG code, this module quantized in YCbCr color
+ * space, processing the raw upsampled data without a color conversion step.
+ * This allowed the color conversion math to be done only once per colormap
+ * entry, not once per pixel.  However, that optimization precluded other
+ * useful optimizations (such as merging color conversion with upsampling)
+ * and it also interfered with desired capabilities such as quantizing to an
+ * externally-supplied colormap.  We have therefore abandoned that approach.
+ * The present code works in the post-conversion color space, typically RGB.
+ *
+ * To improve the visual quality of the results, we actually work in scaled
+ * RGB space, giving G distances more weight than R, and R in turn more than
+ * B.  To do everything in integer math, we must use integer scale factors.
+ * The 2/3/1 scale factors used here correspond loosely to the relative
+ * weights of the colors in the NTSC grayscale equation.
+ * If you want to use this code to quantize a non-RGB color space, you'll
+ * probably need to change these scale factors.
+ */
+
+#define R_SCALE  2              /* scale R distances by this much */
+#define G_SCALE  3              /* scale G distances by this much */
+#define B_SCALE  1              /* and B by this much */
+
+static const int c_scales[3] = { R_SCALE, G_SCALE, B_SCALE };
+#define C0_SCALE  c_scales[rgb_red[cinfo->out_color_space]]
+#define C1_SCALE  c_scales[rgb_green[cinfo->out_color_space]]
+#define C2_SCALE  c_scales[rgb_blue[cinfo->out_color_space]]
+
+/*
+ * First we have the histogram data structure and routines for creating it.
+ *
+ * The number of bits of precision can be adjusted by changing these symbols.
+ * We recommend keeping 6 bits for G and 5 each for R and B.
+ * If you have plenty of memory and cycles, 6 bits all around gives marginally
+ * better results; if you are short of memory, 5 bits all around will save
+ * some space but degrade the results.
+ * To maintain a fully accurate histogram, we'd need to allocate a "long"
+ * (preferably unsigned long) for each cell.  In practice this is overkill;
+ * we can get by with 16 bits per cell.  Few of the cell counts will overflow,
+ * and clamping those that do overflow to the maximum value will give close-
+ * enough results.  This reduces the recommended histogram size from 256Kb
+ * to 128Kb, which is a useful savings on PC-class machines.
+ * (In the second pass the histogram space is re-used for pixel mapping data;
+ * in that capacity, each cell must be able to store zero to the number of
+ * desired colors.  16 bits/cell is plenty for that too.)
+ * Since the JPEG code is intended to run in small memory model on 80x86
+ * machines, we can't just allocate the histogram in one chunk.  Instead
+ * of a true 3-D array, we use a row of pointers to 2-D arrays.  Each
+ * pointer corresponds to a C0 value (typically 2^5 = 32 pointers) and
+ * each 2-D array has 2^6*2^5 = 2048 or 2^6*2^6 = 4096 entries.
+ */
+
+#define MAXNUMCOLORS  (MAXJSAMPLE + 1) /* maximum size of colormap */
+
+/* These will do the right thing for either R,G,B or B,G,R color order,
+ * but you may not like the results for other color orders.
+ */
+#define HIST_C0_BITS  5         /* bits of precision in R/B histogram */
+#define HIST_C1_BITS  6         /* bits of precision in G histogram */
+#define HIST_C2_BITS  5         /* bits of precision in B/R histogram */
+
+/* Number of elements along histogram axes. */
+#define HIST_C0_ELEMS  (1 << HIST_C0_BITS)
+#define HIST_C1_ELEMS  (1 << HIST_C1_BITS)
+#define HIST_C2_ELEMS  (1 << HIST_C2_BITS)
+
+/* These are the amounts to shift an input value to get a histogram index. */
+#define C0_SHIFT  (BITS_IN_JSAMPLE - HIST_C0_BITS)
+#define C1_SHIFT  (BITS_IN_JSAMPLE - HIST_C1_BITS)
+#define C2_SHIFT  (BITS_IN_JSAMPLE - HIST_C2_BITS)
+
+
+typedef UINT16 histcell;        /* histogram cell; prefer an unsigned type */
+
+typedef histcell *histptr;      /* for pointers to histogram cells */
+
+typedef histcell hist1d[HIST_C2_ELEMS]; /* typedefs for the array */
+typedef hist1d *hist2d;         /* type for the 2nd-level pointers */
+typedef hist2d *hist3d;         /* type for top-level pointer */
+
+
+/* Declarations for Floyd-Steinberg dithering.
+ *
+ * Errors are accumulated into the array fserrors[], at a resolution of
+ * 1/16th of a pixel count.  The error at a given pixel is propagated
+ * to its not-yet-processed neighbors using the standard F-S fractions,
+ *              ...     (here)  7/16
+ *              3/16    5/16    1/16
+ * We work left-to-right on even rows, right-to-left on odd rows.
+ *
+ * We can get away with a single array (holding one row's worth of errors)
+ * by using it to store the current row's errors at pixel columns not yet
+ * processed, but the next row's errors at columns already processed.  We
+ * need only a few extra variables to hold the errors immediately around the
+ * current column.  (If we are lucky, those variables are in registers, but
+ * even if not, they're probably cheaper to access than array elements are.)
+ *
+ * The fserrors[] array has (#columns + 2) entries; the extra entry at
+ * each end saves us from special-casing the first and last pixels.
+ * Each entry is three values long, one value for each color component.
+ */
+
+#if BITS_IN_JSAMPLE == 8
+typedef INT16 FSERROR;          /* 16 bits should be enough */
+typedef int LOCFSERROR;         /* use 'int' for calculation temps */
+#else
+typedef JLONG FSERROR;          /* may need more than 16 bits */
+typedef JLONG LOCFSERROR;       /* be sure calculation temps are big enough */
+#endif
+
+typedef FSERROR *FSERRPTR;      /* pointer to error array */
+
+
+/* Private subobject */
+
+typedef struct {
+  struct jpeg_color_quantizer pub; /* public fields */
+
+  /* Space for the eventually created colormap is stashed here */
+  JSAMPARRAY sv_colormap;       /* colormap allocated at init time */
+  int desired;                  /* desired # of colors = size of colormap */
+
+  /* Variables for accumulating image statistics */
+  hist3d histogram;             /* pointer to the histogram */
+
+  boolean needs_zeroed;         /* TRUE if next pass must zero histogram */
+
+  /* Variables for Floyd-Steinberg dithering */
+  FSERRPTR fserrors;            /* accumulated errors */
+  boolean on_odd_row;           /* flag to remember which row we are on */
+  int *error_limiter;           /* table for clamping the applied error */
+} my_cquantizer;
+
+typedef my_cquantizer *my_cquantize_ptr;
+
+
+/*
+ * Prescan some rows of pixels.
+ * In this module the prescan simply updates the histogram, which has been
+ * initialized to zeroes by start_pass.
+ * An output_buf parameter is required by the method signature, but no data
+ * is actually output (in fact the buffer controller is probably passing a
+ * NULL pointer).
+ */
+
+METHODDEF(void)
+prescan_quantize(j_decompress_ptr cinfo, JSAMPARRAY input_buf,
+                 JSAMPARRAY output_buf, int num_rows)
+{
+  my_cquantize_ptr cquantize = (my_cquantize_ptr)cinfo->cquantize;
+  register JSAMPROW ptr;
+  register histptr histp;
+  register hist3d histogram = cquantize->histogram;
+  int row;
+  JDIMENSION col;
+  JDIMENSION width = cinfo->output_width;
+
+  for (row = 0; row < num_rows; row++) {
+    ptr = input_buf[row];
+    for (col = width; col > 0; col--) {
+      /* get pixel value and index into the histogram */
+      histp = &histogram[ptr[0] >> C0_SHIFT]
+                        [ptr[1] >> C1_SHIFT]
+                        [ptr[2] >> C2_SHIFT];
+      /* increment, check for overflow and undo increment if so. */
+      if (++(*histp) <= 0)
+        (*histp)--;
+      ptr += 3;
+    }
+  }
+}
+
+
+/*
+ * Next we have the really interesting routines: selection of a colormap
+ * given the completed histogram.
+ * These routines work with a list of "boxes", each representing a rectangular
+ * subset of the input color space (to histogram precision).
+ */
+
+typedef struct {
+  /* The bounds of the box (inclusive); expressed as histogram indexes */
+  int c0min, c0max;
+  int c1min, c1max;
+  int c2min, c2max;
+  /* The volume (actually 2-norm) of the box */
+  JLONG volume;
+  /* The number of nonzero histogram cells within this box */
+  long colorcount;
+} box;
+
+typedef box *boxptr;
+
+
+LOCAL(boxptr)
+find_biggest_color_pop(boxptr boxlist, int numboxes)
+/* Find the splittable box with the largest color population */
+/* Returns NULL if no splittable boxes remain */
+{
+  register boxptr boxp;
+  register int i;
+  register long maxc = 0;
+  boxptr which = NULL;
+
+  for (i = 0, boxp = boxlist; i < numboxes; i++, boxp++) {
+    if (boxp->colorcount > maxc && boxp->volume > 0) {
+      which = boxp;
+      maxc = boxp->colorcount;
+    }
+  }
+  return which;
+}
+
+
+LOCAL(boxptr)
+find_biggest_volume(boxptr boxlist, int numboxes)
+/* Find the splittable box with the largest (scaled) volume */
+/* Returns NULL if no splittable boxes remain */
+{
+  register boxptr boxp;
+  register int i;
+  register JLONG maxv = 0;
+  boxptr which = NULL;
+
+  for (i = 0, boxp = boxlist; i < numboxes; i++, boxp++) {
+    if (boxp->volume > maxv) {
+      which = boxp;
+      maxv = boxp->volume;
+    }
+  }
+  return which;
+}
+
+
+LOCAL(void)
+update_box(j_decompress_ptr cinfo, boxptr boxp)
+/* Shrink the min/max bounds of a box to enclose only nonzero elements, */
+/* and recompute its volume and population */
+{
+  my_cquantize_ptr cquantize = (my_cquantize_ptr)cinfo->cquantize;
+  hist3d histogram = cquantize->histogram;
+  histptr histp;
+  int c0, c1, c2;
+  int c0min, c0max, c1min, c1max, c2min, c2max;
+  JLONG dist0, dist1, dist2;
+  long ccount;
+
+  c0min = boxp->c0min;  c0max = boxp->c0max;
+  c1min = boxp->c1min;  c1max = boxp->c1max;
+  c2min = boxp->c2min;  c2max = boxp->c2max;
+
+  if (c0max > c0min)
+    for (c0 = c0min; c0 <= c0max; c0++)
+      for (c1 = c1min; c1 <= c1max; c1++) {
+        histp = &histogram[c0][c1][c2min];
+        for (c2 = c2min; c2 <= c2max; c2++)
+          if (*histp++ != 0) {
+            boxp->c0min = c0min = c0;
+            goto have_c0min;
+          }
+      }
+have_c0min:
+  if (c0max > c0min)
+    for (c0 = c0max; c0 >= c0min; c0--)
+      for (c1 = c1min; c1 <= c1max; c1++) {
+        histp = &histogram[c0][c1][c2min];
+        for (c2 = c2min; c2 <= c2max; c2++)
+          if (*histp++ != 0) {
+            boxp->c0max = c0max = c0;
+            goto have_c0max;
+          }
+      }
+have_c0max:
+  if (c1max > c1min)
+    for (c1 = c1min; c1 <= c1max; c1++)
+      for (c0 = c0min; c0 <= c0max; c0++) {
+        histp = &histogram[c0][c1][c2min];
+        for (c2 = c2min; c2 <= c2max; c2++)
+          if (*histp++ != 0) {
+            boxp->c1min = c1min = c1;
+            goto have_c1min;
+          }
+      }
+have_c1min:
+  if (c1max > c1min)
+    for (c1 = c1max; c1 >= c1min; c1--)
+      for (c0 = c0min; c0 <= c0max; c0++) {
+        histp = &histogram[c0][c1][c2min];
+        for (c2 = c2min; c2 <= c2max; c2++)
+          if (*histp++ != 0) {
+            boxp->c1max = c1max = c1;
+            goto have_c1max;
+          }
+      }
+have_c1max:
+  if (c2max > c2min)
+    for (c2 = c2min; c2 <= c2max; c2++)
+      for (c0 = c0min; c0 <= c0max; c0++) {
+        histp = &histogram[c0][c1min][c2];
+        for (c1 = c1min; c1 <= c1max; c1++, histp += HIST_C2_ELEMS)
+          if (*histp != 0) {
+            boxp->c2min = c2min = c2;
+            goto have_c2min;
+          }
+      }
+have_c2min:
+  if (c2max > c2min)
+    for (c2 = c2max; c2 >= c2min; c2--)
+      for (c0 = c0min; c0 <= c0max; c0++) {
+        histp = &histogram[c0][c1min][c2];
+        for (c1 = c1min; c1 <= c1max; c1++, histp += HIST_C2_ELEMS)
+          if (*histp != 0) {
+            boxp->c2max = c2max = c2;
+            goto have_c2max;
+          }
+      }
+have_c2max:
+
+  /* Update box volume.
+   * We use 2-norm rather than real volume here; this biases the method
+   * against making long narrow boxes, and it has the side benefit that
+   * a box is splittable iff norm > 0.
+   * Since the differences are expressed in histogram-cell units,
+   * we have to shift back to JSAMPLE units to get consistent distances;
+   * after which, we scale according to the selected distance scale factors.
+   */
+  dist0 = ((c0max - c0min) << C0_SHIFT) * C0_SCALE;
+  dist1 = ((c1max - c1min) << C1_SHIFT) * C1_SCALE;
+  dist2 = ((c2max - c2min) << C2_SHIFT) * C2_SCALE;
+  boxp->volume = dist0 * dist0 + dist1 * dist1 + dist2 * dist2;
+
+  /* Now scan remaining volume of box and compute population */
+  ccount = 0;
+  for (c0 = c0min; c0 <= c0max; c0++)
+    for (c1 = c1min; c1 <= c1max; c1++) {
+      histp = &histogram[c0][c1][c2min];
+      for (c2 = c2min; c2 <= c2max; c2++, histp++)
+        if (*histp != 0) {
+          ccount++;
+        }
+    }
+  boxp->colorcount = ccount;
+}
+
+
+LOCAL(int)
+median_cut(j_decompress_ptr cinfo, boxptr boxlist, int numboxes,
+           int desired_colors)
+/* Repeatedly select and split the largest box until we have enough boxes */
+{
+  int n, lb;
+  int c0, c1, c2, cmax;
+  register boxptr b1, b2;
+
+  while (numboxes < desired_colors) {
+    /* Select box to split.
+     * Current algorithm: by population for first half, then by volume.
+     */
+    if (numboxes * 2 <= desired_colors) {
+      b1 = find_biggest_color_pop(boxlist, numboxes);
+    } else {
+      b1 = find_biggest_volume(boxlist, numboxes);
+    }
+    if (b1 == NULL)             /* no splittable boxes left! */
+      break;
+    b2 = &boxlist[numboxes];    /* where new box will go */
+    /* Copy the color bounds to the new box. */
+    b2->c0max = b1->c0max;  b2->c1max = b1->c1max;  b2->c2max = b1->c2max;
+    b2->c0min = b1->c0min;  b2->c1min = b1->c1min;  b2->c2min = b1->c2min;
+    /* Choose which axis to split the box on.
+     * Current algorithm: longest scaled axis.
+     * See notes in update_box about scaling distances.
+     */
+    c0 = ((b1->c0max - b1->c0min) << C0_SHIFT) * C0_SCALE;
+    c1 = ((b1->c1max - b1->c1min) << C1_SHIFT) * C1_SCALE;
+    c2 = ((b1->c2max - b1->c2min) << C2_SHIFT) * C2_SCALE;
+    /* We want to break any ties in favor of green, then red, blue last.
+     * This code does the right thing for R,G,B or B,G,R color orders only.
+     */
+    if (rgb_red[cinfo->out_color_space] == 0) {
+      cmax = c1;  n = 1;
+      if (c0 > cmax) { cmax = c0;  n = 0; }
+      if (c2 > cmax) { n = 2; }
+    } else {
+      cmax = c1;  n = 1;
+      if (c2 > cmax) { cmax = c2;  n = 2; }
+      if (c0 > cmax) { n = 0; }
+    }
+    /* Choose split point along selected axis, and update box bounds.
+     * Current algorithm: split at halfway point.
+     * (Since the box has been shrunk to minimum volume,
+     * any split will produce two nonempty subboxes.)
+     * Note that lb value is max for lower box, so must be < old max.
+     */
+    switch (n) {
+    case 0:
+      lb = (b1->c0max + b1->c0min) / 2;
+      b1->c0max = lb;
+      b2->c0min = lb + 1;
+      break;
+    case 1:
+      lb = (b1->c1max + b1->c1min) / 2;
+      b1->c1max = lb;
+      b2->c1min = lb + 1;
+      break;
+    case 2:
+      lb = (b1->c2max + b1->c2min) / 2;
+      b1->c2max = lb;
+      b2->c2min = lb + 1;
+      break;
+    }
+    /* Update stats for boxes */
+    update_box(cinfo, b1);
+    update_box(cinfo, b2);
+    numboxes++;
+  }
+  return numboxes;
+}
+
+
+LOCAL(void)
+compute_color(j_decompress_ptr cinfo, boxptr boxp, int icolor)
+/* Compute representative color for a box, put it in colormap[icolor] */
+{
+  /* Current algorithm: mean weighted by pixels (not colors) */
+  /* Note it is important to get the rounding correct! */
+  my_cquantize_ptr cquantize = (my_cquantize_ptr)cinfo->cquantize;
+  hist3d histogram = cquantize->histogram;
+  histptr histp;
+  int c0, c1, c2;
+  int c0min, c0max, c1min, c1max, c2min, c2max;
+  long count;
+  long total = 0;
+  long c0total = 0;
+  long c1total = 0;
+  long c2total = 0;
+
+  c0min = boxp->c0min;  c0max = boxp->c0max;
+  c1min = boxp->c1min;  c1max = boxp->c1max;
+  c2min = boxp->c2min;  c2max = boxp->c2max;
+
+  for (c0 = c0min; c0 <= c0max; c0++)
+    for (c1 = c1min; c1 <= c1max; c1++) {
+      histp = &histogram[c0][c1][c2min];
+      for (c2 = c2min; c2 <= c2max; c2++) {
+        if ((count = *histp++) != 0) {
+          total += count;
+          c0total += ((c0 << C0_SHIFT) + ((1 << C0_SHIFT) >> 1)) * count;
+          c1total += ((c1 << C1_SHIFT) + ((1 << C1_SHIFT) >> 1)) * count;
+          c2total += ((c2 << C2_SHIFT) + ((1 << C2_SHIFT) >> 1)) * count;
+        }
+      }
+    }
+
+  cinfo->colormap[0][icolor] = (JSAMPLE)((c0total + (total >> 1)) / total);
+  cinfo->colormap[1][icolor] = (JSAMPLE)((c1total + (total >> 1)) / total);
+  cinfo->colormap[2][icolor] = (JSAMPLE)((c2total + (total >> 1)) / total);
+}
+
+
+LOCAL(void)
+select_colors(j_decompress_ptr cinfo, int desired_colors)
+/* Master routine for color selection */
+{
+  boxptr boxlist;
+  int numboxes;
+  int i;
+
+  /* Allocate workspace for box list */
+  boxlist = (boxptr)(*cinfo->mem->alloc_small)
+    ((j_common_ptr)cinfo, JPOOL_IMAGE, desired_colors * sizeof(box));
+  /* Initialize one box containing whole space */
+  numboxes = 1;
+  boxlist[0].c0min = 0;
+  boxlist[0].c0max = MAXJSAMPLE >> C0_SHIFT;
+  boxlist[0].c1min = 0;
+  boxlist[0].c1max = MAXJSAMPLE >> C1_SHIFT;
+  boxlist[0].c2min = 0;
+  boxlist[0].c2max = MAXJSAMPLE >> C2_SHIFT;
+  /* Shrink it to actually-used volume and set its statistics */
+  update_box(cinfo, &boxlist[0]);
+  /* Perform median-cut to produce final box list */
+  numboxes = median_cut(cinfo, boxlist, numboxes, desired_colors);
+  /* Compute the representative color for each box, fill colormap */
+  for (i = 0; i < numboxes; i++)
+    compute_color(cinfo, &boxlist[i], i);
+  cinfo->actual_number_of_colors = numboxes;
+  TRACEMS1(cinfo, 1, JTRC_QUANT_SELECTED, numboxes);
+}
+
+
+/*
+ * These routines are concerned with the time-critical task of mapping input
+ * colors to the nearest color in the selected colormap.
+ *
+ * We re-use the histogram space as an "inverse color map", essentially a
+ * cache for the results of nearest-color searches.  All colors within a
+ * histogram cell will be mapped to the same colormap entry, namely the one
+ * closest to the cell's center.  This may not be quite the closest entry to
+ * the actual input color, but it's almost as good.  A zero in the cache
+ * indicates we haven't found the nearest color for that cell yet; the array
+ * is cleared to zeroes before starting the mapping pass.  When we find the
+ * nearest color for a cell, its colormap index plus one is recorded in the
+ * cache for future use.  The pass2 scanning routines call fill_inverse_cmap
+ * when they need to use an unfilled entry in the cache.
+ *
+ * Our method of efficiently finding nearest colors is based on the "locally
+ * sorted search" idea described by Heckbert and on the incremental distance
+ * calculation described by Spencer W. Thomas in chapter III.1 of Graphics
+ * Gems II (James Arvo, ed.  Academic Press, 1991).  Thomas points out that
+ * the distances from a given colormap entry to each cell of the histogram can
+ * be computed quickly using an incremental method: the differences between
+ * distances to adjacent cells themselves differ by a constant.  This allows a
+ * fairly fast implementation of the "brute force" approach of computing the
+ * distance from every colormap entry to every histogram cell.  Unfortunately,
+ * it needs a work array to hold the best-distance-so-far for each histogram
+ * cell (because the inner loop has to be over cells, not colormap entries).
+ * The work array elements have to be JLONGs, so the work array would need
+ * 256Kb at our recommended precision.  This is not feasible in DOS machines.
+ *
+ * To get around these problems, we apply Thomas' method to compute the
+ * nearest colors for only the cells within a small subbox of the histogram.
+ * The work array need be only as big as the subbox, so the memory usage
+ * problem is solved.  Furthermore, we need not fill subboxes that are never
+ * referenced in pass2; many images use only part of the color gamut, so a
+ * fair amount of work is saved.  An additional advantage of this
+ * approach is that we can apply Heckbert's locality criterion to quickly
+ * eliminate colormap entries that are far away from the subbox; typically
+ * three-fourths of the colormap entries are rejected by Heckbert's criterion,
+ * and we need not compute their distances to individual cells in the subbox.
+ * The speed of this approach is heavily influenced by the subbox size: too
+ * small means too much overhead, too big loses because Heckbert's criterion
+ * can't eliminate as many colormap entries.  Empirically the best subbox
+ * size seems to be about 1/512th of the histogram (1/8th in each direction).
+ *
+ * Thomas' article also describes a refined method which is asymptotically
+ * faster than the brute-force method, but it is also far more complex and
+ * cannot efficiently be applied to small subboxes.  It is therefore not
+ * useful for programs intended to be portable to DOS machines.  On machines
+ * with plenty of memory, filling the whole histogram in one shot with Thomas'
+ * refined method might be faster than the present code --- but then again,
+ * it might not be any faster, and it's certainly more complicated.
+ */
+
+
+/* log2(histogram cells in update box) for each axis; this can be adjusted */
+#define BOX_C0_LOG  (HIST_C0_BITS - 3)
+#define BOX_C1_LOG  (HIST_C1_BITS - 3)
+#define BOX_C2_LOG  (HIST_C2_BITS - 3)
+
+#define BOX_C0_ELEMS  (1 << BOX_C0_LOG) /* # of hist cells in update box */
+#define BOX_C1_ELEMS  (1 << BOX_C1_LOG)
+#define BOX_C2_ELEMS  (1 << BOX_C2_LOG)
+
+#define BOX_C0_SHIFT  (C0_SHIFT + BOX_C0_LOG)
+#define BOX_C1_SHIFT  (C1_SHIFT + BOX_C1_LOG)
+#define BOX_C2_SHIFT  (C2_SHIFT + BOX_C2_LOG)
+
+
+/*
+ * The next three routines implement inverse colormap filling.  They could
+ * all be folded into one big routine, but splitting them up this way saves
+ * some stack space (the mindist[] and bestdist[] arrays need not coexist)
+ * and may allow some compilers to produce better code by registerizing more
+ * inner-loop variables.
+ */
+
+LOCAL(int)
+find_nearby_colors(j_decompress_ptr cinfo, int minc0, int minc1, int minc2,
+                   JSAMPLE colorlist[])
+/* Locate the colormap entries close enough to an update box to be candidates
+ * for the nearest entry to some cell(s) in the update box.  The update box
+ * is specified by the center coordinates of its first cell.  The number of
+ * candidate colormap entries is returned, and their colormap indexes are
+ * placed in colorlist[].
+ * This routine uses Heckbert's "locally sorted search" criterion to select
+ * the colors that need further consideration.
+ */
+{
+  int numcolors = cinfo->actual_number_of_colors;
+  int maxc0, maxc1, maxc2;
+  int centerc0, centerc1, centerc2;
+  int i, x, ncolors;
+  JLONG minmaxdist, min_dist, max_dist, tdist;
+  JLONG mindist[MAXNUMCOLORS];  /* min distance to colormap entry i */
+
+  /* Compute true coordinates of update box's upper corner and center.
+   * Actually we compute the coordinates of the center of the upper-corner
+   * histogram cell, which are the upper bounds of the volume we care about.
+   * Note that since ">>" rounds down, the "center" values may be closer to
+   * min than to max; hence comparisons to them must be "<=", not "<".
+   */
+  maxc0 = minc0 + ((1 << BOX_C0_SHIFT) - (1 << C0_SHIFT));
+  centerc0 = (minc0 + maxc0) >> 1;
+  maxc1 = minc1 + ((1 << BOX_C1_SHIFT) - (1 << C1_SHIFT));
+  centerc1 = (minc1 + maxc1) >> 1;
+  maxc2 = minc2 + ((1 << BOX_C2_SHIFT) - (1 << C2_SHIFT));
+  centerc2 = (minc2 + maxc2) >> 1;
+
+  /* For each color in colormap, find:
+   *  1. its minimum squared-distance to any point in the update box
+   *     (zero if color is within update box);
+   *  2. its maximum squared-distance to any point in the update box.
+   * Both of these can be found by considering only the corners of the box.
+   * We save the minimum distance for each color in mindist[];
+   * only the smallest maximum distance is of interest.
+   */
+  minmaxdist = 0x7FFFFFFFL;
+
+  for (i = 0; i < numcolors; i++) {
+    /* We compute the squared-c0-distance term, then add in the other two. */
+    x = cinfo->colormap[0][i];
+    if (x < minc0) {
+      tdist = (x - minc0) * C0_SCALE;
+      min_dist = tdist * tdist;
+      tdist = (x - maxc0) * C0_SCALE;
+      max_dist = tdist * tdist;
+    } else if (x > maxc0) {
+      tdist = (x - maxc0) * C0_SCALE;
+      min_dist = tdist * tdist;
+      tdist = (x - minc0) * C0_SCALE;
+      max_dist = tdist * tdist;
+    } else {
+      /* within cell range so no contribution to min_dist */
+      min_dist = 0;
+      if (x <= centerc0) {
+        tdist = (x - maxc0) * C0_SCALE;
+        max_dist = tdist * tdist;
+      } else {
+        tdist = (x - minc0) * C0_SCALE;
+        max_dist = tdist * tdist;
+      }
+    }
+
+    x = cinfo->colormap[1][i];
+    if (x < minc1) {
+      tdist = (x - minc1) * C1_SCALE;
+      min_dist += tdist * tdist;
+      tdist = (x - maxc1) * C1_SCALE;
+      max_dist += tdist * tdist;
+    } else if (x > maxc1) {
+      tdist = (x - maxc1) * C1_SCALE;
+      min_dist += tdist * tdist;
+      tdist = (x - minc1) * C1_SCALE;
+      max_dist += tdist * tdist;
+    } else {
+      /* within cell range so no contribution to min_dist */
+      if (x <= centerc1) {
+        tdist = (x - maxc1) * C1_SCALE;
+        max_dist += tdist * tdist;
+      } else {
+        tdist = (x - minc1) * C1_SCALE;
+        max_dist += tdist * tdist;
+      }
+    }
+
+    x = cinfo->colormap[2][i];
+    if (x < minc2) {
+      tdist = (x - minc2) * C2_SCALE;
+      min_dist += tdist * tdist;
+      tdist = (x - maxc2) * C2_SCALE;
+      max_dist += tdist * tdist;
+    } else if (x > maxc2) {
+      tdist = (x - maxc2) * C2_SCALE;
+      min_dist += tdist * tdist;
+      tdist = (x - minc2) * C2_SCALE;
+      max_dist += tdist * tdist;
+    } else {
+      /* within cell range so no contribution to min_dist */
+      if (x <= centerc2) {
+        tdist = (x - maxc2) * C2_SCALE;
+        max_dist += tdist * tdist;
+      } else {
+        tdist = (x - minc2) * C2_SCALE;
+        max_dist += tdist * tdist;
+      }
+    }
+
+    mindist[i] = min_dist;      /* save away the results */
+    if (max_dist < minmaxdist)
+      minmaxdist = max_dist;
+  }
+
+  /* Now we know that no cell in the update box is more than minmaxdist
+   * away from some colormap entry.  Therefore, only colors that are
+   * within minmaxdist of some part of the box need be considered.
+   */
+  ncolors = 0;
+  for (i = 0; i < numcolors; i++) {
+    if (mindist[i] <= minmaxdist)
+      colorlist[ncolors++] = (JSAMPLE)i;
+  }
+  return ncolors;
+}
+
+
+LOCAL(void)
+find_best_colors(j_decompress_ptr cinfo, int minc0, int minc1, int minc2,
+                 int numcolors, JSAMPLE colorlist[], JSAMPLE bestcolor[])
+/* Find the closest colormap entry for each cell in the update box,
+ * given the list of candidate colors prepared by find_nearby_colors.
+ * Return the indexes of the closest entries in the bestcolor[] array.
+ * This routine uses Thomas' incremental distance calculation method to
+ * find the distance from a colormap entry to successive cells in the box.
+ */
+{
+  int ic0, ic1, ic2;
+  int i, icolor;
+  register JLONG *bptr;         /* pointer into bestdist[] array */
+  JSAMPLE *cptr;                /* pointer into bestcolor[] array */
+  JLONG dist0, dist1;           /* initial distance values */
+  register JLONG dist2;         /* current distance in inner loop */
+  JLONG xx0, xx1;               /* distance increments */
+  register JLONG xx2;
+  JLONG inc0, inc1, inc2;       /* initial values for increments */
+  /* This array holds the distance to the nearest-so-far color for each cell */
+  JLONG bestdist[BOX_C0_ELEMS * BOX_C1_ELEMS * BOX_C2_ELEMS];
+
+  /* Initialize best-distance for each cell of the update box */
+  bptr = bestdist;
+  for (i = BOX_C0_ELEMS * BOX_C1_ELEMS * BOX_C2_ELEMS - 1; i >= 0; i--)
+    *bptr++ = 0x7FFFFFFFL;
+
+  /* For each color selected by find_nearby_colors,
+   * compute its distance to the center of each cell in the box.
+   * If that's less than best-so-far, update best distance and color number.
+   */
+
+  /* Nominal steps between cell centers ("x" in Thomas article) */
+#define STEP_C0  ((1 << C0_SHIFT) * C0_SCALE)
+#define STEP_C1  ((1 << C1_SHIFT) * C1_SCALE)
+#define STEP_C2  ((1 << C2_SHIFT) * C2_SCALE)
+
+  for (i = 0; i < numcolors; i++) {
+    icolor = colorlist[i];
+    /* Compute (square of) distance from minc0/c1/c2 to this color */
+    inc0 = (minc0 - cinfo->colormap[0][icolor]) * C0_SCALE;
+    dist0 = inc0 * inc0;
+    inc1 = (minc1 - cinfo->colormap[1][icolor]) * C1_SCALE;
+    dist0 += inc1 * inc1;
+    inc2 = (minc2 - cinfo->colormap[2][icolor]) * C2_SCALE;
+    dist0 += inc2 * inc2;
+    /* Form the initial difference increments */
+    inc0 = inc0 * (2 * STEP_C0) + STEP_C0 * STEP_C0;
+    inc1 = inc1 * (2 * STEP_C1) + STEP_C1 * STEP_C1;
+    inc2 = inc2 * (2 * STEP_C2) + STEP_C2 * STEP_C2;
+    /* Now loop over all cells in box, updating distance per Thomas method */
+    bptr = bestdist;
+    cptr = bestcolor;
+    xx0 = inc0;
+    for (ic0 = BOX_C0_ELEMS - 1; ic0 >= 0; ic0--) {
+      dist1 = dist0;
+      xx1 = inc1;
+      for (ic1 = BOX_C1_ELEMS - 1; ic1 >= 0; ic1--) {
+        dist2 = dist1;
+        xx2 = inc2;
+        for (ic2 = BOX_C2_ELEMS - 1; ic2 >= 0; ic2--) {
+          if (dist2 < *bptr) {
+            *bptr = dist2;
+            *cptr = (JSAMPLE)icolor;
+          }
+          dist2 += xx2;
+          xx2 += 2 * STEP_C2 * STEP_C2;
+          bptr++;
+          cptr++;
+        }
+        dist1 += xx1;
+        xx1 += 2 * STEP_C1 * STEP_C1;
+      }
+      dist0 += xx0;
+      xx0 += 2 * STEP_C0 * STEP_C0;
+    }
+  }
+}
+
+
+LOCAL(void)
+fill_inverse_cmap(j_decompress_ptr cinfo, int c0, int c1, int c2)
+/* Fill the inverse-colormap entries in the update box that contains */
+/* histogram cell c0/c1/c2.  (Only that one cell MUST be filled, but */
+/* we can fill as many others as we wish.) */
+{
+  my_cquantize_ptr cquantize = (my_cquantize_ptr)cinfo->cquantize;
+  hist3d histogram = cquantize->histogram;
+  int minc0, minc1, minc2;      /* lower left corner of update box */
+  int ic0, ic1, ic2;
+  register JSAMPLE *cptr;       /* pointer into bestcolor[] array */
+  register histptr cachep;      /* pointer into main cache array */
+  /* This array lists the candidate colormap indexes. */
+  JSAMPLE colorlist[MAXNUMCOLORS];
+  int numcolors;                /* number of candidate colors */
+  /* This array holds the actually closest colormap index for each cell. */
+  JSAMPLE bestcolor[BOX_C0_ELEMS * BOX_C1_ELEMS * BOX_C2_ELEMS];
+
+  /* Convert cell coordinates to update box ID */
+  c0 >>= BOX_C0_LOG;
+  c1 >>= BOX_C1_LOG;
+  c2 >>= BOX_C2_LOG;
+
+  /* Compute true coordinates of update box's origin corner.
+   * Actually we compute the coordinates of the center of the corner
+   * histogram cell, which are the lower bounds of the volume we care about.
+   */
+  minc0 = (c0 << BOX_C0_SHIFT) + ((1 << C0_SHIFT) >> 1);
+  minc1 = (c1 << BOX_C1_SHIFT) + ((1 << C1_SHIFT) >> 1);
+  minc2 = (c2 << BOX_C2_SHIFT) + ((1 << C2_SHIFT) >> 1);
+
+  /* Determine which colormap entries are close enough to be candidates
+   * for the nearest entry to some cell in the update box.
+   */
+  numcolors = find_nearby_colors(cinfo, minc0, minc1, minc2, colorlist);
+
+  /* Determine the actually nearest colors. */
+  find_best_colors(cinfo, minc0, minc1, minc2, numcolors, colorlist,
+                   bestcolor);
+
+  /* Save the best color numbers (plus 1) in the main cache array */
+  c0 <<= BOX_C0_LOG;            /* convert ID back to base cell indexes */
+  c1 <<= BOX_C1_LOG;
+  c2 <<= BOX_C2_LOG;
+  cptr = bestcolor;
+  for (ic0 = 0; ic0 < BOX_C0_ELEMS; ic0++) {
+    for (ic1 = 0; ic1 < BOX_C1_ELEMS; ic1++) {
+      cachep = &histogram[c0 + ic0][c1 + ic1][c2];
+      for (ic2 = 0; ic2 < BOX_C2_ELEMS; ic2++) {
+        *cachep++ = (histcell)((*cptr++) + 1);
+      }
+    }
+  }
+}
+
+
+/*
+ * Map some rows of pixels to the output colormapped representation.
+ */
+
+METHODDEF(void)
+pass2_no_dither(j_decompress_ptr cinfo, JSAMPARRAY input_buf,
+                JSAMPARRAY output_buf, int num_rows)
+/* This version performs no dithering */
+{
+  my_cquantize_ptr cquantize = (my_cquantize_ptr)cinfo->cquantize;
+  hist3d histogram = cquantize->histogram;
+  register JSAMPROW inptr, outptr;
+  register histptr cachep;
+  register int c0, c1, c2;
+  int row;
+  JDIMENSION col;
+  JDIMENSION width = cinfo->output_width;
+
+  for (row = 0; row < num_rows; row++) {
+    inptr = input_buf[row];
+    outptr = output_buf[row];
+    for (col = width; col > 0; col--) {
+      /* get pixel value and index into the cache */
+      c0 = (*inptr++) >> C0_SHIFT;
+      c1 = (*inptr++) >> C1_SHIFT;
+      c2 = (*inptr++) >> C2_SHIFT;
+      cachep = &histogram[c0][c1][c2];
+      /* If we have not seen this color before, find nearest colormap entry */
+      /* and update the cache */
+      if (*cachep == 0)
+        fill_inverse_cmap(cinfo, c0, c1, c2);
+      /* Now emit the colormap index for this cell */
+      *outptr++ = (JSAMPLE)(*cachep - 1);
+    }
+  }
+}
+
+
+METHODDEF(void)
+pass2_fs_dither(j_decompress_ptr cinfo, JSAMPARRAY input_buf,
+                JSAMPARRAY output_buf, int num_rows)
+/* This version performs Floyd-Steinberg dithering */
+{
+  my_cquantize_ptr cquantize = (my_cquantize_ptr)cinfo->cquantize;
+  hist3d histogram = cquantize->histogram;
+  register LOCFSERROR cur0, cur1, cur2; /* current error or pixel value */
+  LOCFSERROR belowerr0, belowerr1, belowerr2; /* error for pixel below cur */
+  LOCFSERROR bpreverr0, bpreverr1, bpreverr2; /* error for below/prev col */
+  register FSERRPTR errorptr;   /* => fserrors[] at column before current */
+  JSAMPROW inptr;               /* => current input pixel */
+  JSAMPROW outptr;              /* => current output pixel */
+  histptr cachep;
+  int dir;                      /* +1 or -1 depending on direction */
+  int dir3;                     /* 3*dir, for advancing inptr & errorptr */
+  int row;
+  JDIMENSION col;
+  JDIMENSION width = cinfo->output_width;
+  JSAMPLE *range_limit = cinfo->sample_range_limit;
+  int *error_limit = cquantize->error_limiter;
+  JSAMPROW colormap0 = cinfo->colormap[0];
+  JSAMPROW colormap1 = cinfo->colormap[1];
+  JSAMPROW colormap2 = cinfo->colormap[2];
+  SHIFT_TEMPS
+
+  for (row = 0; row < num_rows; row++) {
+    inptr = input_buf[row];
+    outptr = output_buf[row];
+    if (cquantize->on_odd_row) {
+      /* work right to left in this row */
+      inptr += (width - 1) * 3; /* so point to rightmost pixel */
+      outptr += width - 1;
+      dir = -1;
+      dir3 = -3;
+      errorptr = cquantize->fserrors + (width + 1) * 3; /* => entry after last column */
+      cquantize->on_odd_row = FALSE; /* flip for next time */
+    } else {
+      /* work left to right in this row */
+      dir = 1;
+      dir3 = 3;
+      errorptr = cquantize->fserrors; /* => entry before first real column */
+      cquantize->on_odd_row = TRUE; /* flip for next time */
+    }
+    /* Preset error values: no error propagated to first pixel from left */
+    cur0 = cur1 = cur2 = 0;
+    /* and no error propagated to row below yet */
+    belowerr0 = belowerr1 = belowerr2 = 0;
+    bpreverr0 = bpreverr1 = bpreverr2 = 0;
+
+    for (col = width; col > 0; col--) {
+      /* curN holds the error propagated from the previous pixel on the
+       * current line.  Add the error propagated from the previous line
+       * to form the complete error correction term for this pixel, and
+       * round the error term (which is expressed * 16) to an integer.
+       * RIGHT_SHIFT rounds towards minus infinity, so adding 8 is correct
+       * for either sign of the error value.
+       * Note: errorptr points to *previous* column's array entry.
+       */
+      cur0 = RIGHT_SHIFT(cur0 + errorptr[dir3 + 0] + 8, 4);
+      cur1 = RIGHT_SHIFT(cur1 + errorptr[dir3 + 1] + 8, 4);
+      cur2 = RIGHT_SHIFT(cur2 + errorptr[dir3 + 2] + 8, 4);
+      /* Limit the error using transfer function set by init_error_limit.
+       * See comments with init_error_limit for rationale.
+       */
+      cur0 = error_limit[cur0];
+      cur1 = error_limit[cur1];
+      cur2 = error_limit[cur2];
+      /* Form pixel value + error, and range-limit to 0..MAXJSAMPLE.
+       * The maximum error is +- MAXJSAMPLE (or less with error limiting);
+       * this sets the required size of the range_limit array.
+       */
+      cur0 += inptr[0];
+      cur1 += inptr[1];
+      cur2 += inptr[2];
+      cur0 = range_limit[cur0];
+      cur1 = range_limit[cur1];
+      cur2 = range_limit[cur2];
+      /* Index into the cache with adjusted pixel value */
+      cachep =
+        &histogram[cur0 >> C0_SHIFT][cur1 >> C1_SHIFT][cur2 >> C2_SHIFT];
+      /* If we have not seen this color before, find nearest colormap */
+      /* entry and update the cache */
+      if (*cachep == 0)
+        fill_inverse_cmap(cinfo, cur0 >> C0_SHIFT, cur1 >> C1_SHIFT,
+                          cur2 >> C2_SHIFT);
+      /* Now emit the colormap index for this cell */
+      {
+        register int pixcode = *cachep - 1;
+        *outptr = (JSAMPLE)pixcode;
+        /* Compute representation error for this pixel */
+        cur0 -= colormap0[pixcode];
+        cur1 -= colormap1[pixcode];
+        cur2 -= colormap2[pixcode];
+      }
+      /* Compute error fractions to be propagated to adjacent pixels.
+       * Add these into the running sums, and simultaneously shift the
+       * next-line error sums left by 1 column.
+       */
+      {
+        register LOCFSERROR bnexterr;
+
+        bnexterr = cur0;        /* Process component 0 */
+        errorptr[0] = (FSERROR)(bpreverr0 + cur0 * 3);
+        bpreverr0 = belowerr0 + cur0 * 5;
+        belowerr0 = bnexterr;
+        cur0 *= 7;
+        bnexterr = cur1;        /* Process component 1 */
+        errorptr[1] = (FSERROR)(bpreverr1 + cur1 * 3);
+        bpreverr1 = belowerr1 + cur1 * 5;
+        belowerr1 = bnexterr;
+        cur1 *= 7;
+        bnexterr = cur2;        /* Process component 2 */
+        errorptr[2] = (FSERROR)(bpreverr2 + cur2 * 3);
+        bpreverr2 = belowerr2 + cur2 * 5;
+        belowerr2 = bnexterr;
+        cur2 *= 7;
+      }
+      /* At this point curN contains the 7/16 error value to be propagated
+       * to the next pixel on the current line, and all the errors for the
+       * next line have been shifted over.  We are therefore ready to move on.
+       */
+      inptr += dir3;            /* Advance pixel pointers to next column */
+      outptr += dir;
+      errorptr += dir3;         /* advance errorptr to current column */
+    }
+    /* Post-loop cleanup: we must unload the final error values into the
+     * final fserrors[] entry.  Note we need not unload belowerrN because
+     * it is for the dummy column before or after the actual array.
+     */
+    errorptr[0] = (FSERROR)bpreverr0; /* unload prev errs into array */
+    errorptr[1] = (FSERROR)bpreverr1;
+    errorptr[2] = (FSERROR)bpreverr2;
+  }
+}
+
+
+/*
+ * Initialize the error-limiting transfer function (lookup table).
+ * The raw F-S error computation can potentially compute error values of up to
+ * +- MAXJSAMPLE.  But we want the maximum correction applied to a pixel to be
+ * much less, otherwise obviously wrong pixels will be created.  (Typical
+ * effects include weird fringes at color-area boundaries, isolated bright
+ * pixels in a dark area, etc.)  The standard advice for avoiding this problem
+ * is to ensure that the "corners" of the color cube are allocated as output
+ * colors; then repeated errors in the same direction cannot cause cascading
+ * error buildup.  However, that only prevents the error from getting
+ * completely out of hand; Aaron Giles reports that error limiting improves
+ * the results even with corner colors allocated.
+ * A simple clamping of the error values to about +- MAXJSAMPLE/8 works pretty
+ * well, but the smoother transfer function used below is even better.  Thanks
+ * to Aaron Giles for this idea.
+ */
+
+LOCAL(void)
+init_error_limit(j_decompress_ptr cinfo)
+/* Allocate and fill in the error_limiter table */
+{
+  my_cquantize_ptr cquantize = (my_cquantize_ptr)cinfo->cquantize;
+  int *table;
+  int in, out;
+
+  table = (int *)(*cinfo->mem->alloc_small)
+    ((j_common_ptr)cinfo, JPOOL_IMAGE, (MAXJSAMPLE * 2 + 1) * sizeof(int));
+  table += MAXJSAMPLE;          /* so can index -MAXJSAMPLE .. +MAXJSAMPLE */
+  cquantize->error_limiter = table;
+
+#define STEPSIZE  ((MAXJSAMPLE + 1) / 16)
+  /* Map errors 1:1 up to +- MAXJSAMPLE/16 */
+  out = 0;
+  for (in = 0; in < STEPSIZE; in++, out++) {
+    table[in] = out;  table[-in] = -out;
+  }
+  /* Map errors 1:2 up to +- 3*MAXJSAMPLE/16 */
+  for (; in < STEPSIZE * 3; in++, out += (in & 1) ? 0 : 1) {
+    table[in] = out;  table[-in] = -out;
+  }
+  /* Clamp the rest to final out value (which is (MAXJSAMPLE+1)/8) */
+  for (; in <= MAXJSAMPLE; in++) {
+    table[in] = out;  table[-in] = -out;
+  }
+#undef STEPSIZE
+}
+
+
+/*
+ * Finish up at the end of each pass.
+ */
+
+METHODDEF(void)
+finish_pass1(j_decompress_ptr cinfo)
+{
+  my_cquantize_ptr cquantize = (my_cquantize_ptr)cinfo->cquantize;
+
+  /* Select the representative colors and fill in cinfo->colormap */
+  cinfo->colormap = cquantize->sv_colormap;
+  select_colors(cinfo, cquantize->desired);
+  /* Force next pass to zero the color index table */
+  cquantize->needs_zeroed = TRUE;
+}
+
+
+METHODDEF(void)
+finish_pass2(j_decompress_ptr cinfo)
+{
+  /* no work */
+}
+
+
+/*
+ * Initialize for each processing pass.
+ */
+
+METHODDEF(void)
+start_pass_2_quant(j_decompress_ptr cinfo, boolean is_pre_scan)
+{
+  my_cquantize_ptr cquantize = (my_cquantize_ptr)cinfo->cquantize;
+  hist3d histogram = cquantize->histogram;
+  int i;
+
+  /* Only F-S dithering or no dithering is supported. */
+  /* If user asks for ordered dither, give them F-S. */
+  if (cinfo->dither_mode != JDITHER_NONE)
+    cinfo->dither_mode = JDITHER_FS;
+
+  if (is_pre_scan) {
+    /* Set up method pointers */
+    cquantize->pub.color_quantize = prescan_quantize;
+    cquantize->pub.finish_pass = finish_pass1;
+    cquantize->needs_zeroed = TRUE; /* Always zero histogram */
+  } else {
+    /* Set up method pointers */
+    if (cinfo->dither_mode == JDITHER_FS)
+      cquantize->pub.color_quantize = pass2_fs_dither;
+    else
+      cquantize->pub.color_quantize = pass2_no_dither;
+    cquantize->pub.finish_pass = finish_pass2;
+
+    /* Make sure color count is acceptable */
+    i = cinfo->actual_number_of_colors;
+    if (i < 1)
+      ERREXIT1(cinfo, JERR_QUANT_FEW_COLORS, 1);
+    if (i > MAXNUMCOLORS)
+      ERREXIT1(cinfo, JERR_QUANT_MANY_COLORS, MAXNUMCOLORS);
+
+    if (cinfo->dither_mode == JDITHER_FS) {
+      size_t arraysize =
+        (size_t)((cinfo->output_width + 2) * (3 * sizeof(FSERROR)));
+      /* Allocate Floyd-Steinberg workspace if we didn't already. */
+      if (cquantize->fserrors == NULL)
+        cquantize->fserrors = (FSERRPTR)(*cinfo->mem->alloc_large)
+          ((j_common_ptr)cinfo, JPOOL_IMAGE, arraysize);
+      /* Initialize the propagated errors to zero. */
+      jzero_far((void *)cquantize->fserrors, arraysize);
+      /* Make the error-limit table if we didn't already. */
+      if (cquantize->error_limiter == NULL)
+        init_error_limit(cinfo);
+      cquantize->on_odd_row = FALSE;
+    }
+
+  }
+  /* Zero the histogram or inverse color map, if necessary */
+  if (cquantize->needs_zeroed) {
+    for (i = 0; i < HIST_C0_ELEMS; i++) {
+      jzero_far((void *)histogram[i],
+                HIST_C1_ELEMS * HIST_C2_ELEMS * sizeof(histcell));
+    }
+    cquantize->needs_zeroed = FALSE;
+  }
+}
+
+
+/*
+ * Switch to a new external colormap between output passes.
+ */
+
+METHODDEF(void)
+new_color_map_2_quant(j_decompress_ptr cinfo)
+{
+  my_cquantize_ptr cquantize = (my_cquantize_ptr)cinfo->cquantize;
+
+  /* Reset the inverse color map */
+  cquantize->needs_zeroed = TRUE;
+}
+
+
+/*
+ * Module initialization routine for 2-pass color quantization.
+ */
+
+GLOBAL(void)
+jinit_2pass_quantizer(j_decompress_ptr cinfo)
+{
+  my_cquantize_ptr cquantize;
+  int i;
+
+  cquantize = (my_cquantize_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+                                sizeof(my_cquantizer));
+  cinfo->cquantize = (struct jpeg_color_quantizer *)cquantize;
+  cquantize->pub.start_pass = start_pass_2_quant;
+  cquantize->pub.new_color_map = new_color_map_2_quant;
+  cquantize->fserrors = NULL;   /* flag optional arrays not allocated */
+  cquantize->error_limiter = NULL;
+
+  /* Make sure jdmaster didn't give me a case I can't handle */
+  if (cinfo->out_color_components != 3)
+    ERREXIT(cinfo, JERR_NOTIMPL);
+
+  /* Allocate the histogram/inverse colormap storage */
+  cquantize->histogram = (hist3d)(*cinfo->mem->alloc_small)
+    ((j_common_ptr)cinfo, JPOOL_IMAGE, HIST_C0_ELEMS * sizeof(hist2d));
+  for (i = 0; i < HIST_C0_ELEMS; i++) {
+    cquantize->histogram[i] = (hist2d)(*cinfo->mem->alloc_large)
+      ((j_common_ptr)cinfo, JPOOL_IMAGE,
+       HIST_C1_ELEMS * HIST_C2_ELEMS * sizeof(histcell));
+  }
+  cquantize->needs_zeroed = TRUE; /* histogram is garbage now */
+
+  /* Allocate storage for the completed colormap, if required.
+   * We do this now since it may affect the memory manager's space
+   * calculations.
+   */
+  if (cinfo->enable_2pass_quant) {
+    /* Make sure color count is acceptable */
+    int desired = cinfo->desired_number_of_colors;
+    /* Lower bound on # of colors ... somewhat arbitrary as long as > 0 */
+    if (desired < 8)
+      ERREXIT1(cinfo, JERR_QUANT_FEW_COLORS, 8);
+    /* Make sure colormap indexes can be represented by JSAMPLEs */
+    if (desired > MAXNUMCOLORS)
+      ERREXIT1(cinfo, JERR_QUANT_MANY_COLORS, MAXNUMCOLORS);
+    cquantize->sv_colormap = (*cinfo->mem->alloc_sarray)
+      ((j_common_ptr)cinfo, JPOOL_IMAGE, (JDIMENSION)desired, (JDIMENSION)3);
+    cquantize->desired = desired;
+  } else
+    cquantize->sv_colormap = NULL;
+
+  /* Only F-S dithering or no dithering is supported. */
+  /* If user asks for ordered dither, give them F-S. */
+  if (cinfo->dither_mode != JDITHER_NONE)
+    cinfo->dither_mode = JDITHER_FS;
+
+  /* Allocate Floyd-Steinberg workspace if necessary.
+   * This isn't really needed until pass 2, but again it may affect the memory
+   * manager's space calculations.  Although we will cope with a later change
+   * in dither_mode, we do not promise to honor max_memory_to_use if
+   * dither_mode changes.
+   */
+  if (cinfo->dither_mode == JDITHER_FS) {
+    cquantize->fserrors = (FSERRPTR)(*cinfo->mem->alloc_large)
+      ((j_common_ptr)cinfo, JPOOL_IMAGE,
+       (size_t)((cinfo->output_width + 2) * (3 * sizeof(FSERROR))));
+    /* Might as well create the error-limiting table too. */
+    init_error_limit(cinfo);
+  }
+}
+
+#endif /* QUANT_2PASS_SUPPORTED */
diff --git a/3rdparty/libjpeg/src/jsimd.h b/3rdparty/libjpeg/src/jsimd.h
new file mode 100644
index 00000000..6c203655
--- /dev/null
+++ b/3rdparty/libjpeg/src/jsimd.h
@@ -0,0 +1,123 @@
+/*
+ * jsimd.h
+ *
+ * Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+ * Copyright (C) 2011, 2014, D. R. Commander.
+ * Copyright (C) 2015-2016, 2018, Matthieu Darbois.
+ * Copyright (C) 2020, Arm Limited.
+ *
+ * Based on the x86 SIMD extension for IJG JPEG library,
+ * Copyright (C) 1999-2006, MIYASAKA Masaru.
+ * For conditions of distribution and use, see copyright notice in jsimdext.inc
+ *
+ */
+
+#include "jchuff.h"             /* Declarations shared with jcphuff.c */
+
+EXTERN(int) jsimd_can_rgb_ycc(void);
+EXTERN(int) jsimd_can_rgb_gray(void);
+EXTERN(int) jsimd_can_ycc_rgb(void);
+EXTERN(int) jsimd_can_ycc_rgb565(void);
+EXTERN(int) jsimd_c_can_null_convert(void);
+
+EXTERN(void) jsimd_rgb_ycc_convert(j_compress_ptr cinfo, JSAMPARRAY input_buf,
+                                   JSAMPIMAGE output_buf,
+                                   JDIMENSION output_row, int num_rows);
+EXTERN(void) jsimd_rgb_gray_convert(j_compress_ptr cinfo, JSAMPARRAY input_buf,
+                                    JSAMPIMAGE output_buf,
+                                    JDIMENSION output_row, int num_rows);
+EXTERN(void) jsimd_ycc_rgb_convert(j_decompress_ptr cinfo,
+                                   JSAMPIMAGE input_buf, JDIMENSION input_row,
+                                   JSAMPARRAY output_buf, int num_rows);
+EXTERN(void) jsimd_ycc_rgb565_convert(j_decompress_ptr cinfo,
+                                      JSAMPIMAGE input_buf,
+                                      JDIMENSION input_row,
+                                      JSAMPARRAY output_buf, int num_rows);
+EXTERN(void) jsimd_c_null_convert(j_compress_ptr cinfo, JSAMPARRAY input_buf,
+                                  JSAMPIMAGE output_buf, JDIMENSION output_row,
+                                  int num_rows);
+
+EXTERN(int) jsimd_can_h2v2_downsample(void);
+EXTERN(int) jsimd_can_h2v1_downsample(void);
+
+EXTERN(void) jsimd_h2v2_downsample(j_compress_ptr cinfo,
+                                   jpeg_component_info *compptr,
+                                   JSAMPARRAY input_data,
+                                   JSAMPARRAY output_data);
+
+EXTERN(int) jsimd_can_h2v2_smooth_downsample(void);
+
+EXTERN(void) jsimd_h2v2_smooth_downsample(j_compress_ptr cinfo,
+                                          jpeg_component_info *compptr,
+                                          JSAMPARRAY input_data,
+                                          JSAMPARRAY output_data);
+
+EXTERN(void) jsimd_h2v1_downsample(j_compress_ptr cinfo,
+                                   jpeg_component_info *compptr,
+                                   JSAMPARRAY input_data,
+                                   JSAMPARRAY output_data);
+
+EXTERN(int) jsimd_can_h2v2_upsample(void);
+EXTERN(int) jsimd_can_h2v1_upsample(void);
+EXTERN(int) jsimd_can_int_upsample(void);
+
+EXTERN(void) jsimd_h2v2_upsample(j_decompress_ptr cinfo,
+                                 jpeg_component_info *compptr,
+                                 JSAMPARRAY input_data,
+                                 JSAMPARRAY *output_data_ptr);
+EXTERN(void) jsimd_h2v1_upsample(j_decompress_ptr cinfo,
+                                 jpeg_component_info *compptr,
+                                 JSAMPARRAY input_data,
+                                 JSAMPARRAY *output_data_ptr);
+EXTERN(void) jsimd_int_upsample(j_decompress_ptr cinfo,
+                                jpeg_component_info *compptr,
+                                JSAMPARRAY input_data,
+                                JSAMPARRAY *output_data_ptr);
+
+EXTERN(int) jsimd_can_h2v2_fancy_upsample(void);
+EXTERN(int) jsimd_can_h2v1_fancy_upsample(void);
+EXTERN(int) jsimd_can_h1v2_fancy_upsample(void);
+
+EXTERN(void) jsimd_h2v2_fancy_upsample(j_decompress_ptr cinfo,
+                                       jpeg_component_info *compptr,
+                                       JSAMPARRAY input_data,
+                                       JSAMPARRAY *output_data_ptr);
+EXTERN(void) jsimd_h2v1_fancy_upsample(j_decompress_ptr cinfo,
+                                       jpeg_component_info *compptr,
+                                       JSAMPARRAY input_data,
+                                       JSAMPARRAY *output_data_ptr);
+EXTERN(void) jsimd_h1v2_fancy_upsample(j_decompress_ptr cinfo,
+                                       jpeg_component_info *compptr,
+                                       JSAMPARRAY input_data,
+                                       JSAMPARRAY *output_data_ptr);
+
+EXTERN(int) jsimd_can_h2v2_merged_upsample(void);
+EXTERN(int) jsimd_can_h2v1_merged_upsample(void);
+
+EXTERN(void) jsimd_h2v2_merged_upsample(j_decompress_ptr cinfo,
+                                        JSAMPIMAGE input_buf,
+                                        JDIMENSION in_row_group_ctr,
+                                        JSAMPARRAY output_buf);
+EXTERN(void) jsimd_h2v1_merged_upsample(j_decompress_ptr cinfo,
+                                        JSAMPIMAGE input_buf,
+                                        JDIMENSION in_row_group_ctr,
+                                        JSAMPARRAY output_buf);
+
+EXTERN(int) jsimd_can_huff_encode_one_block(void);
+
+EXTERN(JOCTET *) jsimd_huff_encode_one_block(void *state, JOCTET *buffer,
+                                             JCOEFPTR block, int last_dc_val,
+                                             c_derived_tbl *dctbl,
+                                             c_derived_tbl *actbl);
+
+EXTERN(int) jsimd_can_encode_mcu_AC_first_prepare(void);
+
+EXTERN(void) jsimd_encode_mcu_AC_first_prepare
+  (const JCOEF *block, const int *jpeg_natural_order_start, int Sl, int Al,
+   JCOEF *values, size_t *zerobits);
+
+EXTERN(int) jsimd_can_encode_mcu_AC_refine_prepare(void);
+
+EXTERN(int) jsimd_encode_mcu_AC_refine_prepare
+  (const JCOEF *block, const int *jpeg_natural_order_start, int Sl, int Al,
+   JCOEF *absvalues, size_t *bits);
diff --git a/3rdparty/libjpeg/src/jsimd_none.c b/3rdparty/libjpeg/src/jsimd_none.c
new file mode 100644
index 00000000..5b38a9fb
--- /dev/null
+++ b/3rdparty/libjpeg/src/jsimd_none.c
@@ -0,0 +1,431 @@
+/*
+ * jsimd_none.c
+ *
+ * Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+ * Copyright (C) 2009-2011, 2014, D. R. Commander.
+ * Copyright (C) 2015-2016, 2018, Matthieu Darbois.
+ * Copyright (C) 2020, Arm Limited.
+ *
+ * Based on the x86 SIMD extension for IJG JPEG library,
+ * Copyright (C) 1999-2006, MIYASAKA Masaru.
+ * For conditions of distribution and use, see copyright notice in jsimdext.inc
+ *
+ * This file contains stubs for when there is no SIMD support available.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jsimd.h"
+#include "jdct.h"
+#include "jsimddct.h"
+
+GLOBAL(int)
+jsimd_can_rgb_ycc(void)
+{
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_rgb_gray(void)
+{
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_ycc_rgb(void)
+{
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_ycc_rgb565(void)
+{
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_c_can_null_convert(void)
+{
+  return 0;
+}
+
+GLOBAL(void)
+jsimd_rgb_ycc_convert(j_compress_ptr cinfo, JSAMPARRAY input_buf,
+                      JSAMPIMAGE output_buf, JDIMENSION output_row,
+                      int num_rows)
+{
+}
+
+GLOBAL(void)
+jsimd_rgb_gray_convert(j_compress_ptr cinfo, JSAMPARRAY input_buf,
+                       JSAMPIMAGE output_buf, JDIMENSION output_row,
+                       int num_rows)
+{
+}
+
+GLOBAL(void)
+jsimd_ycc_rgb_convert(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
+                      JDIMENSION input_row, JSAMPARRAY output_buf,
+                      int num_rows)
+{
+}
+
+GLOBAL(void)
+jsimd_ycc_rgb565_convert(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
+                         JDIMENSION input_row, JSAMPARRAY output_buf,
+                         int num_rows)
+{
+}
+
+GLOBAL(void)
+jsimd_c_null_convert(j_compress_ptr cinfo, JSAMPARRAY input_buf,
+                     JSAMPIMAGE output_buf, JDIMENSION output_row,
+                     int num_rows)
+{
+}
+
+GLOBAL(int)
+jsimd_can_h2v2_downsample(void)
+{
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_h2v1_downsample(void)
+{
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_h2v2_smooth_downsample(void)
+{
+  return 0;
+}
+
+GLOBAL(void)
+jsimd_h2v2_downsample(j_compress_ptr cinfo, jpeg_component_info *compptr,
+                      JSAMPARRAY input_data, JSAMPARRAY output_data)
+{
+}
+
+GLOBAL(void)
+jsimd_h2v2_smooth_downsample(j_compress_ptr cinfo,
+                             jpeg_component_info *compptr,
+                             JSAMPARRAY input_data, JSAMPARRAY output_data)
+{
+}
+
+GLOBAL(void)
+jsimd_h2v1_downsample(j_compress_ptr cinfo, jpeg_component_info *compptr,
+                      JSAMPARRAY input_data, JSAMPARRAY output_data)
+{
+}
+
+GLOBAL(int)
+jsimd_can_h2v2_upsample(void)
+{
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_h2v1_upsample(void)
+{
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_int_upsample(void)
+{
+  return 0;
+}
+
+GLOBAL(void)
+jsimd_int_upsample(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+                   JSAMPARRAY input_data, JSAMPARRAY *output_data_ptr)
+{
+}
+
+GLOBAL(void)
+jsimd_h2v2_upsample(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+                    JSAMPARRAY input_data, JSAMPARRAY *output_data_ptr)
+{
+}
+
+GLOBAL(void)
+jsimd_h2v1_upsample(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+                    JSAMPARRAY input_data, JSAMPARRAY *output_data_ptr)
+{
+}
+
+GLOBAL(int)
+jsimd_can_h2v2_fancy_upsample(void)
+{
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_h2v1_fancy_upsample(void)
+{
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_h1v2_fancy_upsample(void)
+{
+  return 0;
+}
+
+GLOBAL(void)
+jsimd_h2v2_fancy_upsample(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+                          JSAMPARRAY input_data, JSAMPARRAY *output_data_ptr)
+{
+}
+
+GLOBAL(void)
+jsimd_h2v1_fancy_upsample(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+                          JSAMPARRAY input_data, JSAMPARRAY *output_data_ptr)
+{
+}
+
+GLOBAL(void)
+jsimd_h1v2_fancy_upsample(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+                          JSAMPARRAY input_data, JSAMPARRAY *output_data_ptr)
+{
+}
+
+GLOBAL(int)
+jsimd_can_h2v2_merged_upsample(void)
+{
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_h2v1_merged_upsample(void)
+{
+  return 0;
+}
+
+GLOBAL(void)
+jsimd_h2v2_merged_upsample(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
+                           JDIMENSION in_row_group_ctr, JSAMPARRAY output_buf)
+{
+}
+
+GLOBAL(void)
+jsimd_h2v1_merged_upsample(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
+                           JDIMENSION in_row_group_ctr, JSAMPARRAY output_buf)
+{
+}
+
+GLOBAL(int)
+jsimd_can_convsamp(void)
+{
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_convsamp_float(void)
+{
+  return 0;
+}
+
+GLOBAL(void)
+jsimd_convsamp(JSAMPARRAY sample_data, JDIMENSION start_col,
+               DCTELEM *workspace)
+{
+}
+
+GLOBAL(void)
+jsimd_convsamp_float(JSAMPARRAY sample_data, JDIMENSION start_col,
+                     FAST_FLOAT *workspace)
+{
+}
+
+GLOBAL(int)
+jsimd_can_fdct_islow(void)
+{
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_fdct_ifast(void)
+{
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_fdct_float(void)
+{
+  return 0;
+}
+
+GLOBAL(void)
+jsimd_fdct_islow(DCTELEM *data)
+{
+}
+
+GLOBAL(void)
+jsimd_fdct_ifast(DCTELEM *data)
+{
+}
+
+GLOBAL(void)
+jsimd_fdct_float(FAST_FLOAT *data)
+{
+}
+
+GLOBAL(int)
+jsimd_can_quantize(void)
+{
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_quantize_float(void)
+{
+  return 0;
+}
+
+GLOBAL(void)
+jsimd_quantize(JCOEFPTR coef_block, DCTELEM *divisors, DCTELEM *workspace)
+{
+}
+
+GLOBAL(void)
+jsimd_quantize_float(JCOEFPTR coef_block, FAST_FLOAT *divisors,
+                     FAST_FLOAT *workspace)
+{
+}
+
+GLOBAL(int)
+jsimd_can_idct_2x2(void)
+{
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_idct_4x4(void)
+{
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_idct_6x6(void)
+{
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_idct_12x12(void)
+{
+  return 0;
+}
+
+GLOBAL(void)
+jsimd_idct_2x2(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+               JCOEFPTR coef_block, JSAMPARRAY output_buf,
+               JDIMENSION output_col)
+{
+}
+
+GLOBAL(void)
+jsimd_idct_4x4(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+               JCOEFPTR coef_block, JSAMPARRAY output_buf,
+               JDIMENSION output_col)
+{
+}
+
+GLOBAL(void)
+jsimd_idct_6x6(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+               JCOEFPTR coef_block, JSAMPARRAY output_buf,
+               JDIMENSION output_col)
+{
+}
+
+GLOBAL(void)
+jsimd_idct_12x12(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+                 JCOEFPTR coef_block, JSAMPARRAY output_buf,
+                 JDIMENSION output_col)
+{
+}
+
+GLOBAL(int)
+jsimd_can_idct_islow(void)
+{
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_idct_ifast(void)
+{
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_idct_float(void)
+{
+  return 0;
+}
+
+GLOBAL(void)
+jsimd_idct_islow(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+                 JCOEFPTR coef_block, JSAMPARRAY output_buf,
+                 JDIMENSION output_col)
+{
+}
+
+GLOBAL(void)
+jsimd_idct_ifast(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+                 JCOEFPTR coef_block, JSAMPARRAY output_buf,
+                 JDIMENSION output_col)
+{
+}
+
+GLOBAL(void)
+jsimd_idct_float(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+                 JCOEFPTR coef_block, JSAMPARRAY output_buf,
+                 JDIMENSION output_col)
+{
+}
+
+GLOBAL(int)
+jsimd_can_huff_encode_one_block(void)
+{
+  return 0;
+}
+
+GLOBAL(JOCTET *)
+jsimd_huff_encode_one_block(void *state, JOCTET *buffer, JCOEFPTR block,
+                            int last_dc_val, c_derived_tbl *dctbl,
+                            c_derived_tbl *actbl)
+{
+  return NULL;
+}
+
+GLOBAL(int)
+jsimd_can_encode_mcu_AC_first_prepare(void)
+{
+  return 0;
+}
+
+GLOBAL(void)
+jsimd_encode_mcu_AC_first_prepare(const JCOEF *block,
+                                  const int *jpeg_natural_order_start, int Sl,
+                                  int Al, JCOEF *values, size_t *zerobits)
+{
+}
+
+GLOBAL(int)
+jsimd_can_encode_mcu_AC_refine_prepare(void)
+{
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_encode_mcu_AC_refine_prepare(const JCOEF *block,
+                                   const int *jpeg_natural_order_start, int Sl,
+                                   int Al, JCOEF *absvalues, size_t *bits)
+{
+  return 0;
+}
diff --git a/3rdparty/libjpeg/src/jsimddct.h b/3rdparty/libjpeg/src/jsimddct.h
new file mode 100644
index 00000000..55ee8cf6
--- /dev/null
+++ b/3rdparty/libjpeg/src/jsimddct.h
@@ -0,0 +1,70 @@
+/*
+ * jsimddct.h
+ *
+ * Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+ *
+ * Based on the x86 SIMD extension for IJG JPEG library,
+ * Copyright (C) 1999-2006, MIYASAKA Masaru.
+ * For conditions of distribution and use, see copyright notice in jsimdext.inc
+ *
+ */
+
+EXTERN(int) jsimd_can_convsamp(void);
+EXTERN(int) jsimd_can_convsamp_float(void);
+
+EXTERN(void) jsimd_convsamp(JSAMPARRAY sample_data, JDIMENSION start_col,
+                            DCTELEM *workspace);
+EXTERN(void) jsimd_convsamp_float(JSAMPARRAY sample_data, JDIMENSION start_col,
+                                  FAST_FLOAT *workspace);
+
+EXTERN(int) jsimd_can_fdct_islow(void);
+EXTERN(int) jsimd_can_fdct_ifast(void);
+EXTERN(int) jsimd_can_fdct_float(void);
+
+EXTERN(void) jsimd_fdct_islow(DCTELEM *data);
+EXTERN(void) jsimd_fdct_ifast(DCTELEM *data);
+EXTERN(void) jsimd_fdct_float(FAST_FLOAT *data);
+
+EXTERN(int) jsimd_can_quantize(void);
+EXTERN(int) jsimd_can_quantize_float(void);
+
+EXTERN(void) jsimd_quantize(JCOEFPTR coef_block, DCTELEM *divisors,
+                            DCTELEM *workspace);
+EXTERN(void) jsimd_quantize_float(JCOEFPTR coef_block, FAST_FLOAT *divisors,
+                                  FAST_FLOAT *workspace);
+
+EXTERN(int) jsimd_can_idct_2x2(void);
+EXTERN(int) jsimd_can_idct_4x4(void);
+EXTERN(int) jsimd_can_idct_6x6(void);
+EXTERN(int) jsimd_can_idct_12x12(void);
+
+EXTERN(void) jsimd_idct_2x2(j_decompress_ptr cinfo,
+                            jpeg_component_info *compptr, JCOEFPTR coef_block,
+                            JSAMPARRAY output_buf, JDIMENSION output_col);
+EXTERN(void) jsimd_idct_4x4(j_decompress_ptr cinfo,
+                            jpeg_component_info *compptr, JCOEFPTR coef_block,
+                            JSAMPARRAY output_buf, JDIMENSION output_col);
+EXTERN(void) jsimd_idct_6x6(j_decompress_ptr cinfo,
+                            jpeg_component_info *compptr, JCOEFPTR coef_block,
+                            JSAMPARRAY output_buf, JDIMENSION output_col);
+EXTERN(void) jsimd_idct_12x12(j_decompress_ptr cinfo,
+                              jpeg_component_info *compptr,
+                              JCOEFPTR coef_block, JSAMPARRAY output_buf,
+                              JDIMENSION output_col);
+
+EXTERN(int) jsimd_can_idct_islow(void);
+EXTERN(int) jsimd_can_idct_ifast(void);
+EXTERN(int) jsimd_can_idct_float(void);
+
+EXTERN(void) jsimd_idct_islow(j_decompress_ptr cinfo,
+                              jpeg_component_info *compptr,
+                              JCOEFPTR coef_block, JSAMPARRAY output_buf,
+                              JDIMENSION output_col);
+EXTERN(void) jsimd_idct_ifast(j_decompress_ptr cinfo,
+                              jpeg_component_info *compptr,
+                              JCOEFPTR coef_block, JSAMPARRAY output_buf,
+                              JDIMENSION output_col);
+EXTERN(void) jsimd_idct_float(j_decompress_ptr cinfo,
+                              jpeg_component_info *compptr,
+                              JCOEFPTR coef_block, JSAMPARRAY output_buf,
+                              JDIMENSION output_col);
diff --git a/3rdparty/libjpeg/src/jstdhuff.c b/3rdparty/libjpeg/src/jstdhuff.c
new file mode 100644
index 00000000..036d6495
--- /dev/null
+++ b/3rdparty/libjpeg/src/jstdhuff.c
@@ -0,0 +1,143 @@
+/*
+ * jstdhuff.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1991-1998, Thomas G. Lane.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2013, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains routines to set the default Huffman tables, if they are
+ * not already set.
+ */
+
+/*
+ * Huffman table setup routines
+ */
+
+LOCAL(void)
+add_huff_table(j_common_ptr cinfo, JHUFF_TBL **htblptr, const UINT8 *bits,
+               const UINT8 *val)
+/* Define a Huffman table */
+{
+  int nsymbols, len;
+
+  if (*htblptr == NULL)
+    *htblptr = jpeg_alloc_huff_table(cinfo);
+  else
+    return;
+
+  /* Copy the number-of-symbols-of-each-code-length counts */
+  MEMCOPY((*htblptr)->bits, bits, sizeof((*htblptr)->bits));
+
+  /* Validate the counts.  We do this here mainly so we can copy the right
+   * number of symbols from the val[] array, without risking marching off
+   * the end of memory.  jchuff.c will do a more thorough test later.
+   */
+  nsymbols = 0;
+  for (len = 1; len <= 16; len++)
+    nsymbols += bits[len];
+  if (nsymbols < 1 || nsymbols > 256)
+    ERREXIT(cinfo, JERR_BAD_HUFF_TABLE);
+
+  MEMCOPY((*htblptr)->huffval, val, nsymbols * sizeof(UINT8));
+  MEMZERO(&((*htblptr)->huffval[nsymbols]), (256 - nsymbols) * sizeof(UINT8));
+
+  /* Initialize sent_table FALSE so table will be written to JPEG file. */
+  (*htblptr)->sent_table = FALSE;
+}
+
+
+LOCAL(void)
+std_huff_tables(j_common_ptr cinfo)
+/* Set up the standard Huffman tables (cf. JPEG standard section K.3) */
+/* IMPORTANT: these are only valid for 8-bit data precision! */
+{
+  JHUFF_TBL **dc_huff_tbl_ptrs, **ac_huff_tbl_ptrs;
+
+  static const UINT8 bits_dc_luminance[17] = {
+    /* 0-base */ 0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0
+  };
+  static const UINT8 val_dc_luminance[] = {
+    0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11
+  };
+
+  static const UINT8 bits_dc_chrominance[17] = {
+    /* 0-base */ 0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0
+  };
+  static const UINT8 val_dc_chrominance[] = {
+    0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11
+  };
+
+  static const UINT8 bits_ac_luminance[17] = {
+    /* 0-base */ 0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d
+  };
+  static const UINT8 val_ac_luminance[] = {
+    0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,
+    0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
+    0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08,
+    0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0,
+    0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16,
+    0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28,
+    0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
+    0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
+    0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
+    0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
+    0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
+    0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
+    0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
+    0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
+    0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6,
+    0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5,
+    0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4,
+    0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,
+    0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea,
+    0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
+    0xf9, 0xfa
+  };
+
+  static const UINT8 bits_ac_chrominance[17] = {
+    /* 0-base */ 0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77
+  };
+  static const UINT8 val_ac_chrominance[] = {
+    0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,
+    0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
+    0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,
+    0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0,
+    0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34,
+    0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26,
+    0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38,
+    0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
+    0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
+    0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
+    0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
+    0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
+    0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96,
+    0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5,
+    0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4,
+    0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3,
+    0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2,
+    0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda,
+    0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
+    0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
+    0xf9, 0xfa
+  };
+
+  if (cinfo->is_decompressor) {
+    dc_huff_tbl_ptrs = ((j_decompress_ptr)cinfo)->dc_huff_tbl_ptrs;
+    ac_huff_tbl_ptrs = ((j_decompress_ptr)cinfo)->ac_huff_tbl_ptrs;
+  } else {
+    dc_huff_tbl_ptrs = ((j_compress_ptr)cinfo)->dc_huff_tbl_ptrs;
+    ac_huff_tbl_ptrs = ((j_compress_ptr)cinfo)->ac_huff_tbl_ptrs;
+  }
+
+  add_huff_table(cinfo, &dc_huff_tbl_ptrs[0], bits_dc_luminance,
+                 val_dc_luminance);
+  add_huff_table(cinfo, &ac_huff_tbl_ptrs[0], bits_ac_luminance,
+                 val_ac_luminance);
+  add_huff_table(cinfo, &dc_huff_tbl_ptrs[1], bits_dc_chrominance,
+                 val_dc_chrominance);
+  add_huff_table(cinfo, &ac_huff_tbl_ptrs[1], bits_ac_chrominance,
+                 val_ac_chrominance);
+}
diff --git a/3rdparty/libjpeg/src/jutils.c b/3rdparty/libjpeg/src/jutils.c
new file mode 100644
index 00000000..5c5bb17d
--- /dev/null
+++ b/3rdparty/libjpeg/src/jutils.c
@@ -0,0 +1,133 @@
+/*
+ * jutils.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1991-1996, Thomas G. Lane.
+ * It was modified by The libjpeg-turbo Project to include only code
+ * relevant to libjpeg-turbo.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains tables and miscellaneous utility routines needed
+ * for both compression and decompression.
+ * Note we prefix all global names with "j" to minimize conflicts with
+ * a surrounding application.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/*
+ * jpeg_zigzag_order[i] is the zigzag-order position of the i'th element
+ * of a DCT block read in natural order (left to right, top to bottom).
+ */
+
+#if 0                           /* This table is not actually needed in v6a */
+
+const int jpeg_zigzag_order[DCTSIZE2] = {
+   0,  1,  5,  6, 14, 15, 27, 28,
+   2,  4,  7, 13, 16, 26, 29, 42,
+   3,  8, 12, 17, 25, 30, 41, 43,
+   9, 11, 18, 24, 31, 40, 44, 53,
+  10, 19, 23, 32, 39, 45, 52, 54,
+  20, 22, 33, 38, 46, 51, 55, 60,
+  21, 34, 37, 47, 50, 56, 59, 61,
+  35, 36, 48, 49, 57, 58, 62, 63
+};
+
+#endif
+
+/*
+ * jpeg_natural_order[i] is the natural-order position of the i'th element
+ * of zigzag order.
+ *
+ * When reading corrupted data, the Huffman decoders could attempt
+ * to reference an entry beyond the end of this array (if the decoded
+ * zero run length reaches past the end of the block).  To prevent
+ * wild stores without adding an inner-loop test, we put some extra
+ * "63"s after the real entries.  This will cause the extra coefficient
+ * to be stored in location 63 of the block, not somewhere random.
+ * The worst case would be a run-length of 15, which means we need 16
+ * fake entries.
+ */
+
+const int jpeg_natural_order[DCTSIZE2 + 16] = {
+  0,  1,  8, 16,  9,  2,  3, 10,
+ 17, 24, 32, 25, 18, 11,  4,  5,
+ 12, 19, 26, 33, 40, 48, 41, 34,
+ 27, 20, 13,  6,  7, 14, 21, 28,
+ 35, 42, 49, 56, 57, 50, 43, 36,
+ 29, 22, 15, 23, 30, 37, 44, 51,
+ 58, 59, 52, 45, 38, 31, 39, 46,
+ 53, 60, 61, 54, 47, 55, 62, 63,
+ 63, 63, 63, 63, 63, 63, 63, 63, /* extra entries for safety in decoder */
+ 63, 63, 63, 63, 63, 63, 63, 63
+};
+
+
+/*
+ * Arithmetic utilities
+ */
+
+GLOBAL(long)
+jdiv_round_up(long a, long b)
+/* Compute a/b rounded up to next integer, ie, ceil(a/b) */
+/* Assumes a >= 0, b > 0 */
+{
+  return (a + b - 1L) / b;
+}
+
+
+GLOBAL(long)
+jround_up(long a, long b)
+/* Compute a rounded up to next multiple of b, ie, ceil(a/b)*b */
+/* Assumes a >= 0, b > 0 */
+{
+  a += b - 1L;
+  return a - (a % b);
+}
+
+
+GLOBAL(void)
+jcopy_sample_rows(JSAMPARRAY input_array, int source_row,
+                  JSAMPARRAY output_array, int dest_row, int num_rows,
+                  JDIMENSION num_cols)
+/* Copy some rows of samples from one place to another.
+ * num_rows rows are copied from input_array[source_row++]
+ * to output_array[dest_row++]; these areas may overlap for duplication.
+ * The source and destination arrays must be at least as wide as num_cols.
+ */
+{
+  register JSAMPROW inptr, outptr;
+  register size_t count = (size_t)(num_cols * sizeof(JSAMPLE));
+  register int row;
+
+  input_array += source_row;
+  output_array += dest_row;
+
+  for (row = num_rows; row > 0; row--) {
+    inptr = *input_array++;
+    outptr = *output_array++;
+    MEMCOPY(outptr, inptr, count);
+  }
+}
+
+
+GLOBAL(void)
+jcopy_block_row(JBLOCKROW input_row, JBLOCKROW output_row,
+                JDIMENSION num_blocks)
+/* Copy a row of coefficient blocks from one place to another. */
+{
+  MEMCOPY(output_row, input_row, num_blocks * (DCTSIZE2 * sizeof(JCOEF)));
+}
+
+
+GLOBAL(void)
+jzero_far(void *target, size_t bytestozero)
+/* Zero out a chunk of memory. */
+/* This might be sample-array data, block-array data, or alloc_large data. */
+{
+  MEMZERO(target, bytestozero);
+}
diff --git a/3rdparty/libjpeg/src/jversion.h b/3rdparty/libjpeg/src/jversion.h
new file mode 100644
index 00000000..d1d94f5b
--- /dev/null
+++ b/3rdparty/libjpeg/src/jversion.h
@@ -0,0 +1,54 @@
+/*
+ * jversion.h
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1991-2020, Thomas G. Lane, Guido Vollbeding.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2010, 2012-2020, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains software version identification.
+ */
+
+
+#if JPEG_LIB_VERSION >= 80
+
+#define JVERSION        "8d  15-Jan-2012"
+
+#elif JPEG_LIB_VERSION >= 70
+
+#define JVERSION        "7  27-Jun-2009"
+
+#else
+
+#define JVERSION        "6b  27-Mar-1998"
+
+#endif
+
+/*
+ * NOTE: It is our convention to place the authors in the following order:
+ * - libjpeg-turbo authors (2009-) in descending order of the date of their
+ *   most recent contribution to the project, then in ascending order of the
+ *   date of their first contribution to the project, then in alphabetical
+ *   order
+ * - Upstream authors in descending order of the date of the first inclusion of
+ *   their code
+ */
+
+#define JCOPYRIGHT \
+  "Copyright (C) 2009-2020 D. R. Commander\n" \
+  "Copyright (C) 2015, 2020 Google, Inc.\n" \
+  "Copyright (C) 2019-2020 Arm Limited\n" \
+  "Copyright (C) 2015-2016, 2018 Matthieu Darbois\n" \
+  "Copyright (C) 2011-2016 Siarhei Siamashka\n" \
+  "Copyright (C) 2015 Intel Corporation\n" \
+  "Copyright (C) 2013-2014 Linaro Limited\n" \
+  "Copyright (C) 2013-2014 MIPS Technologies, Inc.\n" \
+  "Copyright (C) 2009, 2012 Pierre Ossman for Cendio AB\n" \
+  "Copyright (C) 2009-2011 Nokia Corporation and/or its subsidiary(-ies)\n" \
+  "Copyright (C) 1999-2006 MIYASAKA Masaru\n" \
+  "Copyright (C) 1991-2020 Thomas G. Lane, Guido Vollbeding"
+
+#define JCOPYRIGHT_SHORT \
+  "Copyright (C) 1991-2020 The libjpeg-turbo Project and many others"
diff --git a/3rdparty/libjpeg/src/libjpeg.map b/3rdparty/libjpeg/src/libjpeg.map
new file mode 100644
index 00000000..c3e716d9
--- /dev/null
+++ b/3rdparty/libjpeg/src/libjpeg.map
@@ -0,0 +1,11 @@
+LIBJPEGTURBO_8.0 {
+  
+  local:
+    jsimd_*;
+    jconst_*;
+};
+
+LIBJPEG_8.0 {
+  global:
+    *;
+};
diff --git a/3rdparty/libjpeg/src/libjpeg.map.in b/3rdparty/libjpeg/src/libjpeg.map.in
new file mode 100644
index 00000000..b4480d83
--- /dev/null
+++ b/3rdparty/libjpeg/src/libjpeg.map.in
@@ -0,0 +1,11 @@
+LIBJPEGTURBO_@JPEG_LIB_VERSION_DECIMAL@ {
+  @MEM_SRCDST_FUNCTIONS@
+  local:
+    jsimd_*;
+    jconst_*;
+};
+
+LIBJPEG_@JPEG_LIB_VERSION_DECIMAL@ {
+  global:
+    *;
+};
diff --git a/3rdparty/libjpeg/src/libjpeg.txt b/3rdparty/libjpeg/src/libjpeg.txt
new file mode 100644
index 00000000..3c680b5f
--- /dev/null
+++ b/3rdparty/libjpeg/src/libjpeg.txt
@@ -0,0 +1,3162 @@
+USING THE IJG JPEG LIBRARY
+
+This file was part of the Independent JPEG Group's software:
+Copyright (C) 1994-2013, Thomas G. Lane, Guido Vollbeding.
+libjpeg-turbo Modifications:
+Copyright (C) 2010, 2014-2018, 2020, D. R. Commander.
+Copyright (C) 2015, Google, Inc.
+For conditions of distribution and use, see the accompanying README.ijg file.
+
+
+This file describes how to use the IJG JPEG library within an application
+program.  Read it if you want to write a program that uses the library.
+
+The file example.txt provides heavily commented skeleton code for calling the
+JPEG library.  Also see jpeglib.h (the include file to be used by application
+programs) for full details about data structures and function parameter lists.
+The library source code, of course, is the ultimate reference.
+
+Note that there have been *major* changes from the application interface
+presented by IJG version 4 and earlier versions.  The old design had several
+inherent limitations, and it had accumulated a lot of cruft as we added
+features while trying to minimize application-interface changes.  We have
+sacrificed backward compatibility in the version 5 rewrite, but we think the
+improvements justify this.
+
+
+TABLE OF CONTENTS
+-----------------
+
+Overview:
+        Functions provided by the library
+        Outline of typical usage
+Basic library usage:
+        Data formats
+        Compression details
+        Decompression details
+        Partial image decompression
+        Mechanics of usage: include files, linking, etc
+Advanced features:
+        Compression parameter selection
+        Decompression parameter selection
+        Special color spaces
+        Error handling
+        Compressed data handling (source and destination managers)
+        I/O suspension
+        Progressive JPEG support
+        Buffered-image mode
+        Abbreviated datastreams and multiple images
+        Special markers
+        ICC profiles
+        Raw (downsampled) image data
+        Really raw data: DCT coefficients
+        Progress monitoring
+        Memory management
+        Memory usage
+        Library compile-time options
+        Portability considerations
+
+You should read at least the overview and basic usage sections before trying
+to program with the library.  The sections on advanced features can be read
+if and when you need them.
+
+
+OVERVIEW
+========
+
+Functions provided by the library
+---------------------------------
+
+The IJG JPEG library provides C code to read and write JPEG-compressed image
+files.  The surrounding application program receives or supplies image data a
+scanline at a time, using a straightforward uncompressed image format.  All
+details of color conversion and other preprocessing/postprocessing can be
+handled by the library.
+
+The library includes a substantial amount of code that is not covered by the
+JPEG standard but is necessary for typical applications of JPEG.  These
+functions preprocess the image before JPEG compression or postprocess it after
+decompression.  They include colorspace conversion, downsampling/upsampling,
+and color quantization.  The application indirectly selects use of this code
+by specifying the format in which it wishes to supply or receive image data.
+For example, if colormapped output is requested, then the decompression
+library automatically invokes color quantization.
+
+A wide range of quality vs. speed tradeoffs are possible in JPEG processing,
+and even more so in decompression postprocessing.  The decompression library
+provides multiple implementations that cover most of the useful tradeoffs,
+ranging from very-high-quality down to fast-preview operation.  On the
+compression side we have generally not provided low-quality choices, since
+compression is normally less time-critical.  It should be understood that the
+low-quality modes may not meet the JPEG standard's accuracy requirements;
+nonetheless, they are useful for viewers.
+
+A word about functions *not* provided by the library.  We handle a subset of
+the ISO JPEG standard; most baseline, extended-sequential, and progressive
+JPEG processes are supported.  (Our subset includes all features now in common
+use.)  Unsupported ISO options include:
+        * Hierarchical storage
+        * Lossless JPEG
+        * DNL marker
+        * Nonintegral subsampling ratios
+We support both 8- and 12-bit data precision, but this is a compile-time
+choice rather than a run-time choice; hence it is difficult to use both
+precisions in a single application.
+
+By itself, the library handles only interchange JPEG datastreams --- in
+particular the widely used JFIF file format.  The library can be used by
+surrounding code to process interchange or abbreviated JPEG datastreams that
+are embedded in more complex file formats.  (For example, this library is
+used by the free LIBTIFF library to support JPEG compression in TIFF.)
+
+
+Outline of typical usage
+------------------------
+
+The rough outline of a JPEG compression operation is:
+
+        Allocate and initialize a JPEG compression object
+        Specify the destination for the compressed data (eg, a file)
+        Set parameters for compression, including image size & colorspace
+        jpeg_start_compress(...);
+        while (scan lines remain to be written)
+                jpeg_write_scanlines(...);
+        jpeg_finish_compress(...);
+        Release the JPEG compression object
+
+A JPEG compression object holds parameters and working state for the JPEG
+library.  We make creation/destruction of the object separate from starting
+or finishing compression of an image; the same object can be re-used for a
+series of image compression operations.  This makes it easy to re-use the
+same parameter settings for a sequence of images.  Re-use of a JPEG object
+also has important implications for processing abbreviated JPEG datastreams,
+as discussed later.
+
+The image data to be compressed is supplied to jpeg_write_scanlines() from
+in-memory buffers.  If the application is doing file-to-file compression,
+reading image data from the source file is the application's responsibility.
+The library emits compressed data by calling a "data destination manager",
+which typically will write the data into a file; but the application can
+provide its own destination manager to do something else.
+
+Similarly, the rough outline of a JPEG decompression operation is:
+
+        Allocate and initialize a JPEG decompression object
+        Specify the source of the compressed data (eg, a file)
+        Call jpeg_read_header() to obtain image info
+        Set parameters for decompression
+        jpeg_start_decompress(...);
+        while (scan lines remain to be read)
+                jpeg_read_scanlines(...);
+        jpeg_finish_decompress(...);
+        Release the JPEG decompression object
+
+This is comparable to the compression outline except that reading the
+datastream header is a separate step.  This is helpful because information
+about the image's size, colorspace, etc is available when the application
+selects decompression parameters.  For example, the application can choose an
+output scaling ratio that will fit the image into the available screen size.
+
+The decompression library obtains compressed data by calling a data source
+manager, which typically will read the data from a file; but other behaviors
+can be obtained with a custom source manager.  Decompressed data is delivered
+into in-memory buffers passed to jpeg_read_scanlines().
+
+It is possible to abort an incomplete compression or decompression operation
+by calling jpeg_abort(); or, if you do not need to retain the JPEG object,
+simply release it by calling jpeg_destroy().
+
+JPEG compression and decompression objects are two separate struct types.
+However, they share some common fields, and certain routines such as
+jpeg_destroy() can work on either type of object.
+
+The JPEG library has no static variables: all state is in the compression
+or decompression object.  Therefore it is possible to process multiple
+compression and decompression operations concurrently, using multiple JPEG
+objects.
+
+Both compression and decompression can be done in an incremental memory-to-
+memory fashion, if suitable source/destination managers are used.  See the
+section on "I/O suspension" for more details.
+
+
+BASIC LIBRARY USAGE
+===================
+
+Data formats
+------------
+
+Before diving into procedural details, it is helpful to understand the
+image data format that the JPEG library expects or returns.
+
+The standard input image format is a rectangular array of pixels, with each
+pixel having the same number of "component" or "sample" values (color
+channels).  You must specify how many components there are and the colorspace
+interpretation of the components.  Most applications will use RGB data
+(three components per pixel) or grayscale data (one component per pixel).
+PLEASE NOTE THAT RGB DATA IS THREE SAMPLES PER PIXEL, GRAYSCALE ONLY ONE.
+A remarkable number of people manage to miss this, only to find that their
+programs don't work with grayscale JPEG files.
+
+There is no provision for colormapped input.  JPEG files are always full-color
+or full grayscale (or sometimes another colorspace such as CMYK).  You can
+feed in a colormapped image by expanding it to full-color format.  However
+JPEG often doesn't work very well with source data that has been colormapped,
+because of dithering noise.  This is discussed in more detail in the JPEG FAQ
+and the other references mentioned in the README.ijg file.
+
+Pixels are stored by scanlines, with each scanline running from left to
+right.  The component values for each pixel are adjacent in the row; for
+example, R,G,B,R,G,B,R,G,B,... for 24-bit RGB color.  Each scanline is an
+array of data type JSAMPLE --- which is typically "unsigned char", unless
+you've changed jmorecfg.h.  (You can also change the RGB pixel layout, say
+to B,G,R order, by modifying jmorecfg.h.  But see the restrictions listed in
+that file before doing so.)
+
+A 2-D array of pixels is formed by making a list of pointers to the starts of
+scanlines; so the scanlines need not be physically adjacent in memory.  Even
+if you process just one scanline at a time, you must make a one-element
+pointer array to conform to this structure.  Pointers to JSAMPLE rows are of
+type JSAMPROW, and the pointer to the pointer array is of type JSAMPARRAY.
+
+The library accepts or supplies one or more complete scanlines per call.
+It is not possible to process part of a row at a time.  Scanlines are always
+processed top-to-bottom.  You can process an entire image in one call if you
+have it all in memory, but usually it's simplest to process one scanline at
+a time.
+
+For best results, source data values should have the precision specified by
+BITS_IN_JSAMPLE (normally 8 bits).  For instance, if you choose to compress
+data that's only 6 bits/channel, you should left-justify each value in a
+byte before passing it to the compressor.  If you need to compress data
+that has more than 8 bits/channel, compile with BITS_IN_JSAMPLE = 12.
+(See "Library compile-time options", later.)
+
+
+The data format returned by the decompressor is the same in all details,
+except that colormapped output is supported.  (Again, a JPEG file is never
+colormapped.  But you can ask the decompressor to perform on-the-fly color
+quantization to deliver colormapped output.)  If you request colormapped
+output then the returned data array contains a single JSAMPLE per pixel;
+its value is an index into a color map.  The color map is represented as
+a 2-D JSAMPARRAY in which each row holds the values of one color component,
+that is, colormap[i][j] is the value of the i'th color component for pixel
+value (map index) j.  Note that since the colormap indexes are stored in
+JSAMPLEs, the maximum number of colors is limited by the size of JSAMPLE
+(ie, at most 256 colors for an 8-bit JPEG library).
+
+
+Compression details
+-------------------
+
+Here we revisit the JPEG compression outline given in the overview.
+
+1. Allocate and initialize a JPEG compression object.
+
+A JPEG compression object is a "struct jpeg_compress_struct".  (It also has
+a bunch of subsidiary structures which are allocated via malloc(), but the
+application doesn't control those directly.)  This struct can be just a local
+variable in the calling routine, if a single routine is going to execute the
+whole JPEG compression sequence.  Otherwise it can be static or allocated
+from malloc().
+
+You will also need a structure representing a JPEG error handler.  The part
+of this that the library cares about is a "struct jpeg_error_mgr".  If you
+are providing your own error handler, you'll typically want to embed the
+jpeg_error_mgr struct in a larger structure; this is discussed later under
+"Error handling".  For now we'll assume you are just using the default error
+handler.  The default error handler will print JPEG error/warning messages
+on stderr, and it will call exit() if a fatal error occurs.
+
+You must initialize the error handler structure, store a pointer to it into
+the JPEG object's "err" field, and then call jpeg_create_compress() to
+initialize the rest of the JPEG object.
+
+Typical code for this step, if you are using the default error handler, is
+
+        struct jpeg_compress_struct cinfo;
+        struct jpeg_error_mgr jerr;
+        ...
+        cinfo.err = jpeg_std_error(&jerr);
+        jpeg_create_compress(&cinfo);
+
+jpeg_create_compress allocates a small amount of memory, so it could fail
+if you are out of memory.  In that case it will exit via the error handler;
+that's why the error handler must be initialized first.
+
+
+2. Specify the destination for the compressed data (eg, a file).
+
+As previously mentioned, the JPEG library delivers compressed data to a
+"data destination" module.  The library includes one data destination
+module which knows how to write to a stdio stream.  You can use your own
+destination module if you want to do something else, as discussed later.
+
+If you use the standard destination module, you must open the target stdio
+stream beforehand.  Typical code for this step looks like:
+
+        FILE *outfile;
+        ...
+        if ((outfile = fopen(filename, "wb")) == NULL) {
+            fprintf(stderr, "can't open %s\n", filename);
+            exit(1);
+        }
+        jpeg_stdio_dest(&cinfo, outfile);
+
+where the last line invokes the standard destination module.
+
+WARNING: it is critical that the binary compressed data be delivered to the
+output file unchanged.  On non-Unix systems the stdio library may perform
+newline translation or otherwise corrupt binary data.  To suppress this
+behavior, you may need to use a "b" option to fopen (as shown above), or use
+setmode() or another routine to put the stdio stream in binary mode.  See
+cjpeg.c and djpeg.c for code that has been found to work on many systems.
+
+You can select the data destination after setting other parameters (step 3),
+if that's more convenient.  You may not change the destination between
+calling jpeg_start_compress() and jpeg_finish_compress().
+
+
+3. Set parameters for compression, including image size & colorspace.
+
+You must supply information about the source image by setting the following
+fields in the JPEG object (cinfo structure):
+
+        image_width             Width of image, in pixels
+        image_height            Height of image, in pixels
+        input_components        Number of color channels (samples per pixel)
+        in_color_space          Color space of source image
+
+The image dimensions are, hopefully, obvious.  JPEG supports image dimensions
+of 1 to 64K pixels in either direction.  The input color space is typically
+RGB or grayscale, and input_components is 3 or 1 accordingly.  (See "Special
+color spaces", later, for more info.)  The in_color_space field must be
+assigned one of the J_COLOR_SPACE enum constants, typically JCS_RGB or
+JCS_GRAYSCALE.
+
+JPEG has a large number of compression parameters that determine how the
+image is encoded.  Most applications don't need or want to know about all
+these parameters.  You can set all the parameters to reasonable defaults by
+calling jpeg_set_defaults(); then, if there are particular values you want
+to change, you can do so after that.  The "Compression parameter selection"
+section tells about all the parameters.
+
+You must set in_color_space correctly before calling jpeg_set_defaults(),
+because the defaults depend on the source image colorspace.  However the
+other three source image parameters need not be valid until you call
+jpeg_start_compress().  There's no harm in calling jpeg_set_defaults() more
+than once, if that happens to be convenient.
+
+Typical code for a 24-bit RGB source image is
+
+        cinfo.image_width = Width;      /* image width and height, in pixels */
+        cinfo.image_height = Height;
+        cinfo.input_components = 3;     /* # of color components per pixel */
+        cinfo.in_color_space = JCS_RGB; /* colorspace of input image */
+
+        jpeg_set_defaults(&cinfo);
+        /* Make optional parameter settings here */
+
+
+4. jpeg_start_compress(...);
+
+After you have established the data destination and set all the necessary
+source image info and other parameters, call jpeg_start_compress() to begin
+a compression cycle.  This will initialize internal state, allocate working
+storage, and emit the first few bytes of the JPEG datastream header.
+
+Typical code:
+
+        jpeg_start_compress(&cinfo, TRUE);
+
+The "TRUE" parameter ensures that a complete JPEG interchange datastream
+will be written.  This is appropriate in most cases.  If you think you might
+want to use an abbreviated datastream, read the section on abbreviated
+datastreams, below.
+
+Once you have called jpeg_start_compress(), you may not alter any JPEG
+parameters or other fields of the JPEG object until you have completed
+the compression cycle.
+
+
+5. while (scan lines remain to be written)
+        jpeg_write_scanlines(...);
+
+Now write all the required image data by calling jpeg_write_scanlines()
+one or more times.  You can pass one or more scanlines in each call, up
+to the total image height.  In most applications it is convenient to pass
+just one or a few scanlines at a time.  The expected format for the passed
+data is discussed under "Data formats", above.
+
+Image data should be written in top-to-bottom scanline order.
+Rec. ITU-T T.81 | ISO/IEC 10918-1 says, "Applications determine which edges of
+a source image are defined as top, bottom, left, and right."  However, if you
+want your files to be compatible with everyone else's, then top-to-bottom order
+must be used.  If the source data must be read in bottom-to-top order, then you
+can use the JPEG library's virtual array mechanism to invert the data
+efficiently.  Examples of this can be found in the sample application cjpeg.
+
+The library maintains a count of the number of scanlines written so far
+in the next_scanline field of the JPEG object.  Usually you can just use
+this variable as the loop counter, so that the loop test looks like
+"while (cinfo.next_scanline < cinfo.image_height)".
+
+Code for this step depends heavily on the way that you store the source data.
+example.txt shows the following code for the case of a full-size 2-D source
+array containing 3-byte RGB pixels:
+
+        JSAMPROW row_pointer[1];        /* pointer to a single row */
+        int row_stride;                 /* physical row width in buffer */
+
+        row_stride = image_width * 3;   /* JSAMPLEs per row in image_buffer */
+
+        while (cinfo.next_scanline < cinfo.image_height) {
+            row_pointer[0] = &image_buffer[cinfo.next_scanline * row_stride];
+            jpeg_write_scanlines(&cinfo, row_pointer, 1);
+        }
+
+jpeg_write_scanlines() returns the number of scanlines actually written.
+This will normally be equal to the number passed in, so you can usually
+ignore the return value.  It is different in just two cases:
+  * If you try to write more scanlines than the declared image height,
+    the additional scanlines are ignored.
+  * If you use a suspending data destination manager, output buffer overrun
+    will cause the compressor to return before accepting all the passed lines.
+    This feature is discussed under "I/O suspension", below.  The normal
+    stdio destination manager will NOT cause this to happen.
+In any case, the return value is the same as the change in the value of
+next_scanline.
+
+
+6. jpeg_finish_compress(...);
+
+After all the image data has been written, call jpeg_finish_compress() to
+complete the compression cycle.  This step is ESSENTIAL to ensure that the
+last bufferload of data is written to the data destination.
+jpeg_finish_compress() also releases working memory associated with the JPEG
+object.
+
+Typical code:
+
+        jpeg_finish_compress(&cinfo);
+
+If using the stdio destination manager, don't forget to close the output
+stdio stream (if necessary) afterwards.
+
+If you have requested a multi-pass operating mode, such as Huffman code
+optimization, jpeg_finish_compress() will perform the additional passes using
+data buffered by the first pass.  In this case jpeg_finish_compress() may take
+quite a while to complete.  With the default compression parameters, this will
+not happen.
+
+It is an error to call jpeg_finish_compress() before writing the necessary
+total number of scanlines.  If you wish to abort compression, call
+jpeg_abort() as discussed below.
+
+After completing a compression cycle, you may dispose of the JPEG object
+as discussed next, or you may use it to compress another image.  In that case
+return to step 2, 3, or 4 as appropriate.  If you do not change the
+destination manager, the new datastream will be written to the same target.
+If you do not change any JPEG parameters, the new datastream will be written
+with the same parameters as before.  Note that you can change the input image
+dimensions freely between cycles, but if you change the input colorspace, you
+should call jpeg_set_defaults() to adjust for the new colorspace; and then
+you'll need to repeat all of step 3.
+
+
+7. Release the JPEG compression object.
+
+When you are done with a JPEG compression object, destroy it by calling
+jpeg_destroy_compress().  This will free all subsidiary memory (regardless of
+the previous state of the object).  Or you can call jpeg_destroy(), which
+works for either compression or decompression objects --- this may be more
+convenient if you are sharing code between compression and decompression
+cases.  (Actually, these routines are equivalent except for the declared type
+of the passed pointer.  To avoid gripes from ANSI C compilers, jpeg_destroy()
+should be passed a j_common_ptr.)
+
+If you allocated the jpeg_compress_struct structure from malloc(), freeing
+it is your responsibility --- jpeg_destroy() won't.  Ditto for the error
+handler structure.
+
+Typical code:
+
+        jpeg_destroy_compress(&cinfo);
+
+
+8. Aborting.
+
+If you decide to abort a compression cycle before finishing, you can clean up
+in either of two ways:
+
+* If you don't need the JPEG object any more, just call
+  jpeg_destroy_compress() or jpeg_destroy() to release memory.  This is
+  legitimate at any point after calling jpeg_create_compress() --- in fact,
+  it's safe even if jpeg_create_compress() fails.
+
+* If you want to re-use the JPEG object, call jpeg_abort_compress(), or call
+  jpeg_abort() which works on both compression and decompression objects.
+  This will return the object to an idle state, releasing any working memory.
+  jpeg_abort() is allowed at any time after successful object creation.
+
+Note that cleaning up the data destination, if required, is your
+responsibility; neither of these routines will call term_destination().
+(See "Compressed data handling", below, for more about that.)
+
+jpeg_destroy() and jpeg_abort() are the only safe calls to make on a JPEG
+object that has reported an error by calling error_exit (see "Error handling"
+for more info).  The internal state of such an object is likely to be out of
+whack.  Either of these two routines will return the object to a known state.
+
+
+Decompression details
+---------------------
+
+Here we revisit the JPEG decompression outline given in the overview.
+
+1. Allocate and initialize a JPEG decompression object.
+
+This is just like initialization for compression, as discussed above,
+except that the object is a "struct jpeg_decompress_struct" and you
+call jpeg_create_decompress().  Error handling is exactly the same.
+
+Typical code:
+
+        struct jpeg_decompress_struct cinfo;
+        struct jpeg_error_mgr jerr;
+        ...
+        cinfo.err = jpeg_std_error(&jerr);
+        jpeg_create_decompress(&cinfo);
+
+(Both here and in the IJG code, we usually use variable name "cinfo" for
+both compression and decompression objects.)
+
+
+2. Specify the source of the compressed data (eg, a file).
+
+As previously mentioned, the JPEG library reads compressed data from a "data
+source" module.  The library includes one data source module which knows how
+to read from a stdio stream.  You can use your own source module if you want
+to do something else, as discussed later.
+
+If you use the standard source module, you must open the source stdio stream
+beforehand.  Typical code for this step looks like:
+
+        FILE *infile;
+        ...
+        if ((infile = fopen(filename, "rb")) == NULL) {
+            fprintf(stderr, "can't open %s\n", filename);
+            exit(1);
+        }
+        jpeg_stdio_src(&cinfo, infile);
+
+where the last line invokes the standard source module.
+
+WARNING: it is critical that the binary compressed data be read unchanged.
+On non-Unix systems the stdio library may perform newline translation or
+otherwise corrupt binary data.  To suppress this behavior, you may need to use
+a "b" option to fopen (as shown above), or use setmode() or another routine to
+put the stdio stream in binary mode.  See cjpeg.c and djpeg.c for code that
+has been found to work on many systems.
+
+You may not change the data source between calling jpeg_read_header() and
+jpeg_finish_decompress().  If you wish to read a series of JPEG images from
+a single source file, you should repeat the jpeg_read_header() to
+jpeg_finish_decompress() sequence without reinitializing either the JPEG
+object or the data source module; this prevents buffered input data from
+being discarded.
+
+
+3. Call jpeg_read_header() to obtain image info.
+
+Typical code for this step is just
+
+        jpeg_read_header(&cinfo, TRUE);
+
+This will read the source datastream header markers, up to the beginning
+of the compressed data proper.  On return, the image dimensions and other
+info have been stored in the JPEG object.  The application may wish to
+consult this information before selecting decompression parameters.
+
+More complex code is necessary if
+  * A suspending data source is used --- in that case jpeg_read_header()
+    may return before it has read all the header data.  See "I/O suspension",
+    below.  The normal stdio source manager will NOT cause this to happen.
+  * Abbreviated JPEG files are to be processed --- see the section on
+    abbreviated datastreams.  Standard applications that deal only in
+    interchange JPEG files need not be concerned with this case either.
+
+It is permissible to stop at this point if you just wanted to find out the
+image dimensions and other header info for a JPEG file.  In that case,
+call jpeg_destroy() when you are done with the JPEG object, or call
+jpeg_abort() to return it to an idle state before selecting a new data
+source and reading another header.
+
+
+4. Set parameters for decompression.
+
+jpeg_read_header() sets appropriate default decompression parameters based on
+the properties of the image (in particular, its colorspace).  However, you
+may well want to alter these defaults before beginning the decompression.
+For example, the default is to produce full color output from a color file.
+If you want colormapped output you must ask for it.  Other options allow the
+returned image to be scaled and allow various speed/quality tradeoffs to be
+selected.  "Decompression parameter selection", below, gives details.
+
+If the defaults are appropriate, nothing need be done at this step.
+
+Note that all default values are set by each call to jpeg_read_header().
+If you reuse a decompression object, you cannot expect your parameter
+settings to be preserved across cycles, as you can for compression.
+You must set desired parameter values each time.
+
+
+5. jpeg_start_decompress(...);
+
+Once the parameter values are satisfactory, call jpeg_start_decompress() to
+begin decompression.  This will initialize internal state, allocate working
+memory, and prepare for returning data.
+
+Typical code is just
+
+        jpeg_start_decompress(&cinfo);
+
+If you have requested a multi-pass operating mode, such as 2-pass color
+quantization, jpeg_start_decompress() will do everything needed before data
+output can begin.  In this case jpeg_start_decompress() may take quite a while
+to complete.  With a single-scan (non progressive) JPEG file and default
+decompression parameters, this will not happen; jpeg_start_decompress() will
+return quickly.
+
+After this call, the final output image dimensions, including any requested
+scaling, are available in the JPEG object; so is the selected colormap, if
+colormapped output has been requested.  Useful fields include
+
+        output_width            image width and height, as scaled
+        output_height
+        out_color_components    # of color components in out_color_space
+        output_components       # of color components returned per pixel
+        colormap                the selected colormap, if any
+        actual_number_of_colors         number of entries in colormap
+
+output_components is 1 (a colormap index) when quantizing colors; otherwise it
+equals out_color_components.  It is the number of JSAMPLE values that will be
+emitted per pixel in the output arrays.
+
+Typically you will need to allocate data buffers to hold the incoming image.
+You will need output_width * output_components JSAMPLEs per scanline in your
+output buffer, and a total of output_height scanlines will be returned.
+
+Note: if you are using the JPEG library's internal memory manager to allocate
+data buffers (as djpeg does), then the manager's protocol requires that you
+request large buffers *before* calling jpeg_start_decompress().  This is a
+little tricky since the output_XXX fields are not normally valid then.  You
+can make them valid by calling jpeg_calc_output_dimensions() after setting the
+relevant parameters (scaling, output color space, and quantization flag).
+
+
+6. while (scan lines remain to be read)
+        jpeg_read_scanlines(...);
+
+Now you can read the decompressed image data by calling jpeg_read_scanlines()
+one or more times.  At each call, you pass in the maximum number of scanlines
+to be read (ie, the height of your working buffer); jpeg_read_scanlines()
+will return up to that many lines.  The return value is the number of lines
+actually read.  The format of the returned data is discussed under "Data
+formats", above.  Don't forget that grayscale and color JPEGs will return
+different data formats!
+
+Image data is returned in top-to-bottom scanline order.  If you must write
+out the image in bottom-to-top order, you can use the JPEG library's virtual
+array mechanism to invert the data efficiently.  Examples of this can be
+found in the sample application djpeg.
+
+The library maintains a count of the number of scanlines returned so far
+in the output_scanline field of the JPEG object.  Usually you can just use
+this variable as the loop counter, so that the loop test looks like
+"while (cinfo.output_scanline < cinfo.output_height)".  (Note that the test
+should NOT be against image_height, unless you never use scaling.  The
+image_height field is the height of the original unscaled image.)
+The return value always equals the change in the value of output_scanline.
+
+If you don't use a suspending data source, it is safe to assume that
+jpeg_read_scanlines() reads at least one scanline per call, until the
+bottom of the image has been reached.
+
+If you use a buffer larger than one scanline, it is NOT safe to assume that
+jpeg_read_scanlines() fills it.  (The current implementation returns only a
+few scanlines per call, no matter how large a buffer you pass.)  So you must
+always provide a loop that calls jpeg_read_scanlines() repeatedly until the
+whole image has been read.
+
+
+7. jpeg_finish_decompress(...);
+
+After all the image data has been read, call jpeg_finish_decompress() to
+complete the decompression cycle.  This causes working memory associated
+with the JPEG object to be released.
+
+Typical code:
+
+        jpeg_finish_decompress(&cinfo);
+
+If using the stdio source manager, don't forget to close the source stdio
+stream if necessary.
+
+It is an error to call jpeg_finish_decompress() before reading the correct
+total number of scanlines.  If you wish to abort decompression, call
+jpeg_abort() as discussed below.
+
+After completing a decompression cycle, you may dispose of the JPEG object as
+discussed next, or you may use it to decompress another image.  In that case
+return to step 2 or 3 as appropriate.  If you do not change the source
+manager, the next image will be read from the same source.
+
+
+8. Release the JPEG decompression object.
+
+When you are done with a JPEG decompression object, destroy it by calling
+jpeg_destroy_decompress() or jpeg_destroy().  The previous discussion of
+destroying compression objects applies here too.
+
+Typical code:
+
+        jpeg_destroy_decompress(&cinfo);
+
+
+9. Aborting.
+
+You can abort a decompression cycle by calling jpeg_destroy_decompress() or
+jpeg_destroy() if you don't need the JPEG object any more, or
+jpeg_abort_decompress() or jpeg_abort() if you want to reuse the object.
+The previous discussion of aborting compression cycles applies here too.
+
+
+Partial image decompression
+---------------------------
+
+Partial image decompression is convenient for performance-critical applications
+that wish to view only a portion of a large JPEG image without decompressing
+the whole thing.  It it also useful in memory-constrained environments (such as
+on mobile devices.)  This library provides the following functions to support
+partial image decompression:
+
+1. Skipping rows when decompressing
+
+        jpeg_skip_scanlines(j_decompress_ptr cinfo, JDIMENSION num_lines);
+
+This function provides application programmers with the ability to skip over
+multiple rows in the JPEG image.
+
+Suspending data sources are not supported by this function.  Calling
+jpeg_skip_scanlines() with a suspending data source will result in undefined
+behavior.  Two-pass color quantization is also not supported by this function.
+Calling jpeg_skip_scanlines() with two-pass color quantization enabled will
+result in an error.
+
+jpeg_skip_scanlines() will not allow skipping past the bottom of the image.  If
+the value of num_lines is large enough to skip past the bottom of the image,
+then the function will skip to the end of the image instead.
+
+If the value of num_lines is valid, then jpeg_skip_scanlines() will always
+skip all of the input rows requested.  There is no need to inspect the return
+value of the function in that case.
+
+Best results will be achieved by calling jpeg_skip_scanlines() for large chunks
+of rows.  The function should be viewed as a way to quickly jump to a
+particular vertical offset in the JPEG image in order to decode a subset of the
+image.  Used in this manner, it will provide significant performance
+improvements.
+
+Calling jpeg_skip_scanlines() for small values of num_lines has several
+potential drawbacks:
+    1) JPEG decompression occurs in blocks, so if jpeg_skip_scanlines() is
+       called from the middle of a decompression block, then it is likely that
+       much of the decompression work has already been done for the first
+       couple of rows that need to be skipped.
+    2) When this function returns, it must leave the decompressor in a state
+       such that it is ready to read the next line.  This may involve
+       decompressing a block that must be partially skipped.
+These issues are especially tricky for cases in which upsampling requires
+context rows.  In the worst case, jpeg_skip_scanlines() will perform similarly
+to jpeg_read_scanlines() (since it will actually call jpeg_read_scanlines().)
+
+2. Decompressing partial scanlines
+
+        jpeg_crop_scanline (j_decompress_ptr cinfo, JDIMENSION *xoffset,
+                            JDIMENSION *width)
+
+This function provides application programmers with the ability to decompress
+only a portion of each row in the JPEG image.  It must be called after
+jpeg_start_decompress() and before any calls to jpeg_read_scanlines() or
+jpeg_skip_scanlines().
+
+If xoffset and width do not form a valid subset of the image row, then this
+function will generate an error.  Note that if the output image is scaled, then
+xoffset and width are relative to the scaled image dimensions.
+
+xoffset and width are passed by reference because xoffset must fall on an iMCU
+boundary.  If it doesn't, then it will be moved left to the nearest iMCU
+boundary, and width will be increased accordingly.  If the calling program does
+not like the adjusted values of xoffset and width, then it can call
+jpeg_crop_scanline() again with new values (for instance, if it wants to move
+xoffset to the nearest iMCU boundary to the right instead of to the left.)
+
+After calling this function, cinfo->output_width will be set to the adjusted
+width.  This value should be used when allocating an output buffer to pass to
+jpeg_read_scanlines().
+
+The output image from a partial-width decompression will be identical to the
+corresponding image region from a full decode, with one exception:  The "fancy"
+(smooth) h2v2 (4:2:0) and h2v1 (4:2:2) upsampling algorithms fill in the
+missing chroma components by averaging the chroma components from neighboring
+pixels, except on the right and left edges of the image (where there are no
+neighboring pixels.)  When performing a partial-width decompression, these
+"fancy" upsampling algorithms may treat the left and right edges of the partial
+image region as if they are the left and right edges of the image, meaning that
+the upsampling algorithm may be simplified.  The result is that the pixels on
+the left or right edge of the partial image may not be exactly identical to the
+corresponding pixels in the original image.
+
+
+Mechanics of usage: include files, linking, etc
+-----------------------------------------------
+
+Applications using the JPEG library should include the header file jpeglib.h
+to obtain declarations of data types and routines.  Before including
+jpeglib.h, include system headers that define at least the typedefs FILE and
+size_t.  On ANSI-conforming systems, including <stdio.h> is sufficient; on
+older Unix systems, you may need <sys/types.h> to define size_t.
+
+If the application needs to refer to individual JPEG library error codes, also
+include jerror.h to define those symbols.
+
+jpeglib.h indirectly includes the files jconfig.h and jmorecfg.h.  If you are
+installing the JPEG header files in a system directory, you will want to
+install all four files: jpeglib.h, jerror.h, jconfig.h, jmorecfg.h.
+
+The most convenient way to include the JPEG code into your executable program
+is to prepare a library file ("libjpeg.a", or a corresponding name on non-Unix
+machines) and reference it at your link step.  If you use only half of the
+library (only compression or only decompression), only that much code will be
+included from the library, unless your linker is hopelessly brain-damaged.
+The supplied makefiles build libjpeg.a automatically (see install.txt).
+
+While you can build the JPEG library as a shared library if the whim strikes
+you, we don't really recommend it.  The trouble with shared libraries is that
+at some point you'll probably try to substitute a new version of the library
+without recompiling the calling applications.  That generally doesn't work
+because the parameter struct declarations usually change with each new
+version.  In other words, the library's API is *not* guaranteed binary
+compatible across versions; we only try to ensure source-code compatibility.
+(In hindsight, it might have been smarter to hide the parameter structs from
+applications and introduce a ton of access functions instead.  Too late now,
+however.)
+
+It may be worth pointing out that the core JPEG library does not actually
+require the stdio library: only the default source/destination managers and
+error handler need it.  You can use the library in a stdio-less environment
+if you replace those modules and use jmemnobs.c (or another memory manager of
+your own devising).  More info about the minimum system library requirements
+may be found in jinclude.h.
+
+
+ADVANCED FEATURES
+=================
+
+Compression parameter selection
+-------------------------------
+
+This section describes all the optional parameters you can set for JPEG
+compression, as well as the "helper" routines provided to assist in this
+task.  Proper setting of some parameters requires detailed understanding
+of the JPEG standard; if you don't know what a parameter is for, it's best
+not to mess with it!  See REFERENCES in the README.ijg file for pointers to
+more info about JPEG.
+
+It's a good idea to call jpeg_set_defaults() first, even if you plan to set
+all the parameters; that way your code is more likely to work with future JPEG
+libraries that have additional parameters.  For the same reason, we recommend
+you use a helper routine where one is provided, in preference to twiddling
+cinfo fields directly.
+
+The helper routines are:
+
+jpeg_set_defaults (j_compress_ptr cinfo)
+        This routine sets all JPEG parameters to reasonable defaults, using
+        only the input image's color space (field in_color_space, which must
+        already be set in cinfo).  Many applications will only need to use
+        this routine and perhaps jpeg_set_quality().
+
+jpeg_set_colorspace (j_compress_ptr cinfo, J_COLOR_SPACE colorspace)
+        Sets the JPEG file's colorspace (field jpeg_color_space) as specified,
+        and sets other color-space-dependent parameters appropriately.  See
+        "Special color spaces", below, before using this.  A large number of
+        parameters, including all per-component parameters, are set by this
+        routine; if you want to twiddle individual parameters you should call
+        jpeg_set_colorspace() before rather than after.
+
+jpeg_default_colorspace (j_compress_ptr cinfo)
+        Selects an appropriate JPEG colorspace based on cinfo->in_color_space,
+        and calls jpeg_set_colorspace().  This is actually a subroutine of
+        jpeg_set_defaults().  It's broken out in case you want to change
+        just the colorspace-dependent JPEG parameters.
+
+jpeg_set_quality (j_compress_ptr cinfo, int quality, boolean force_baseline)
+        Constructs JPEG quantization tables appropriate for the indicated
+        quality setting.  The quality value is expressed on the 0..100 scale
+        recommended by IJG (cjpeg's "-quality" switch uses this routine).
+        Note that the exact mapping from quality values to tables may change
+        in future IJG releases as more is learned about DCT quantization.
+        If the force_baseline parameter is TRUE, then the quantization table
+        entries are constrained to the range 1..255 for full JPEG baseline
+        compatibility.  In the current implementation, this only makes a
+        difference for quality settings below 25, and it effectively prevents
+        very small/low quality files from being generated.  The IJG decoder
+        is capable of reading the non-baseline files generated at low quality
+        settings when force_baseline is FALSE, but other decoders may not be.
+
+jpeg_set_linear_quality (j_compress_ptr cinfo, int scale_factor,
+                         boolean force_baseline)
+        Same as jpeg_set_quality() except that the generated tables are the
+        sample tables given in Annex K (Clause K.1) of
+        Rec. ITU-T T.81 (1992) | ISO/IEC 10918-1:1994, multiplied by the
+        specified scale factor (which is expressed as a percentage; thus
+        scale_factor = 100 reproduces the spec's tables).  Note that larger
+        scale factors give lower quality.  This entry point is useful for
+        conforming to the Adobe PostScript DCT conventions, but we do not
+        recommend linear scaling as a user-visible quality scale otherwise.
+        force_baseline again constrains the computed table entries to 1..255.
+
+int jpeg_quality_scaling (int quality)
+        Converts a value on the IJG-recommended quality scale to a linear
+        scaling percentage.  Note that this routine may change or go away
+        in future releases --- IJG may choose to adopt a scaling method that
+        can't be expressed as a simple scalar multiplier, in which case the
+        premise of this routine collapses.  Caveat user.
+
+jpeg_default_qtables (j_compress_ptr cinfo, boolean force_baseline)
+        [libjpeg v7+ API/ABI emulation only]
+        Set default quantization tables with linear q_scale_factor[] values
+        (see below).
+
+jpeg_add_quant_table (j_compress_ptr cinfo, int which_tbl,
+                      const unsigned int *basic_table,
+                      int scale_factor, boolean force_baseline)
+        Allows an arbitrary quantization table to be created.  which_tbl
+        indicates which table slot to fill.  basic_table points to an array
+        of 64 unsigned ints given in normal array order.  These values are
+        multiplied by scale_factor/100 and then clamped to the range 1..65535
+        (or to 1..255 if force_baseline is TRUE).
+        CAUTION: prior to library version 6a, jpeg_add_quant_table expected
+        the basic table to be given in JPEG zigzag order.  If you need to
+        write code that works with either older or newer versions of this
+        routine, you must check the library version number.  Something like
+        "#if JPEG_LIB_VERSION >= 61" is the right test.
+
+jpeg_simple_progression (j_compress_ptr cinfo)
+        Generates a default scan script for writing a progressive-JPEG file.
+        This is the recommended method of creating a progressive file,
+        unless you want to make a custom scan sequence.  You must ensure that
+        the JPEG color space is set correctly before calling this routine.
+
+
+Compression parameters (cinfo fields) include:
+
+boolean arith_code
+        If TRUE, use arithmetic coding.
+        If FALSE, use Huffman coding.
+
+J_DCT_METHOD dct_method
+        Selects the algorithm used for the DCT step.  Choices are:
+                JDCT_ISLOW: accurate integer method
+                JDCT_IFAST: less accurate integer method [legacy feature]
+                JDCT_FLOAT: floating-point method [legacy feature]
+                JDCT_DEFAULT: default method (normally JDCT_ISLOW)
+                JDCT_FASTEST: fastest method (normally JDCT_IFAST)
+        When the Independent JPEG Group's software was first released in 1991,
+        the compression time for a 1-megapixel JPEG image on a mainstream PC
+        was measured in minutes.  Thus, JDCT_IFAST provided noticeable
+        performance benefits.  On modern CPUs running libjpeg-turbo, however,
+        the compression time for a 1-megapixel JPEG image is measured in
+        milliseconds, and thus the performance benefits of JDCT_IFAST are much
+        less noticeable.  On modern x86/x86-64 CPUs that support AVX2
+        instructions, JDCT_IFAST and JDCT_ISLOW have similar performance.  On
+        other types of CPUs, JDCT_IFAST is generally about 5-15% faster than
+        JDCT_ISLOW.
+
+        For quality levels of 90 and below, there should be little or no
+        perceptible quality difference between the two algorithms.  For quality
+        levels above 90, however, the difference between JDCT_IFAST and
+        JDCT_ISLOW becomes more pronounced.  With quality=97, for instance,
+        JDCT_IFAST incurs generally about a 1-3 dB loss in PSNR relative to
+        JDCT_ISLOW, but this can be larger for some images.  Do not use
+        JDCT_IFAST with quality levels above 97.  The algorithm often
+        degenerates at quality=98 and above and can actually produce a more
+        lossy image than if lower quality levels had been used.  Also, in
+        libjpeg-turbo, JDCT_IFAST is not fully accelerated for quality levels
+        above 97, so it will be slower than JDCT_ISLOW.
+
+        JDCT_FLOAT does not produce significantly more accurate results than
+        JDCT_ISLOW, and it is much slower.  JDCT_FLOAT may also give different
+        results on different machines due to varying roundoff behavior, whereas
+        the integer methods should give the same results on all machines.
+
+J_COLOR_SPACE jpeg_color_space
+int num_components
+        The JPEG color space and corresponding number of components; see
+        "Special color spaces", below, for more info.  We recommend using
+        jpeg_set_color_space() if you want to change these.
+
+boolean optimize_coding
+        TRUE causes the compressor to compute optimal Huffman coding tables
+        for the image.  This requires an extra pass over the data and
+        therefore costs a good deal of space and time.  The default is
+        FALSE, which tells the compressor to use the supplied or default
+        Huffman tables.  In most cases optimal tables save only a few percent
+        of file size compared to the default tables.  Note that when this is
+        TRUE, you need not supply Huffman tables at all, and any you do
+        supply will be overwritten.
+
+unsigned int restart_interval
+int restart_in_rows
+        To emit restart markers in the JPEG file, set one of these nonzero.
+        Set restart_interval to specify the exact interval in MCU blocks.
+        Set restart_in_rows to specify the interval in MCU rows.  (If
+        restart_in_rows is not 0, then restart_interval is set after the
+        image width in MCUs is computed.)  Defaults are zero (no restarts).
+        One restart marker per MCU row is often a good choice.
+        NOTE: the overhead of restart markers is higher in grayscale JPEG
+        files than in color files, and MUCH higher in progressive JPEGs.
+        If you use restarts, you may want to use larger intervals in those
+        cases.
+
+const jpeg_scan_info *scan_info
+int num_scans
+        By default, scan_info is NULL; this causes the compressor to write a
+        single-scan sequential JPEG file.  If not NULL, scan_info points to
+        an array of scan definition records of length num_scans.  The
+        compressor will then write a JPEG file having one scan for each scan
+        definition record.  This is used to generate noninterleaved or
+        progressive JPEG files.  The library checks that the scan array
+        defines a valid JPEG scan sequence.  (jpeg_simple_progression creates
+        a suitable scan definition array for progressive JPEG.)  This is
+        discussed further under "Progressive JPEG support".
+
+int smoothing_factor
+        If non-zero, the input image is smoothed; the value should be 1 for
+        minimal smoothing to 100 for maximum smoothing.  Consult jcsample.c
+        for details of the smoothing algorithm.  The default is zero.
+
+boolean write_JFIF_header
+        If TRUE, a JFIF APP0 marker is emitted.  jpeg_set_defaults() and
+        jpeg_set_colorspace() set this TRUE if a JFIF-legal JPEG color space
+        (ie, YCbCr or grayscale) is selected, otherwise FALSE.
+
+UINT8 JFIF_major_version
+UINT8 JFIF_minor_version
+        The version number to be written into the JFIF marker.
+        jpeg_set_defaults() initializes the version to 1.01 (major=minor=1).
+        You should set it to 1.02 (major=1, minor=2) if you plan to write
+        any JFIF 1.02 extension markers.
+
+UINT8 density_unit
+UINT16 X_density
+UINT16 Y_density
+        The resolution information to be written into the JFIF marker;
+        not used otherwise.  density_unit may be 0 for unknown,
+        1 for dots/inch, or 2 for dots/cm.  The default values are 0,1,1
+        indicating square pixels of unknown size.
+
+boolean write_Adobe_marker
+        If TRUE, an Adobe APP14 marker is emitted.  jpeg_set_defaults() and
+        jpeg_set_colorspace() set this TRUE if JPEG color space RGB, CMYK,
+        or YCCK is selected, otherwise FALSE.  It is generally a bad idea
+        to set both write_JFIF_header and write_Adobe_marker.  In fact,
+        you probably shouldn't change the default settings at all --- the
+        default behavior ensures that the JPEG file's color space can be
+        recognized by the decoder.
+
+JQUANT_TBL *quant_tbl_ptrs[NUM_QUANT_TBLS]
+        Pointers to coefficient quantization tables, one per table slot,
+        or NULL if no table is defined for a slot.  Usually these should
+        be set via one of the above helper routines; jpeg_add_quant_table()
+        is general enough to define any quantization table.  The other
+        routines will set up table slot 0 for luminance quality and table
+        slot 1 for chrominance.
+
+int q_scale_factor[NUM_QUANT_TBLS]
+        [libjpeg v7+ API/ABI emulation only]
+        Linear quantization scaling factors (0-100, default 100)
+        for use with jpeg_default_qtables().
+        See rdswitch.c and cjpeg.c for an example of usage.
+        Note that the q_scale_factor[] values use "linear" scales, so JPEG
+        quality levels chosen by the user must be converted to these scales
+        using jpeg_quality_scaling().  Here is an example that corresponds to
+        cjpeg -quality 90,70:
+
+                jpeg_set_defaults(cinfo);
+
+                /* Set luminance quality 90. */
+                cinfo->q_scale_factor[0] = jpeg_quality_scaling(90);
+                /* Set chrominance quality 70. */
+                cinfo->q_scale_factor[1] = jpeg_quality_scaling(70);
+
+                jpeg_default_qtables(cinfo, force_baseline);
+
+        CAUTION: Setting separate quality levels for chrominance and luminance
+        is mainly only useful if chrominance subsampling is disabled.  2x2
+        chrominance subsampling (AKA "4:2:0") is the default, but you can
+        explicitly disable subsampling as follows:
+
+                cinfo->comp_info[0].v_samp_factor = 1;
+                cinfo->comp_info[0].h_samp_factor = 1;
+
+JHUFF_TBL *dc_huff_tbl_ptrs[NUM_HUFF_TBLS]
+JHUFF_TBL *ac_huff_tbl_ptrs[NUM_HUFF_TBLS]
+        Pointers to Huffman coding tables, one per table slot, or NULL if
+        no table is defined for a slot.  Slots 0 and 1 are filled with the
+        JPEG sample tables by jpeg_set_defaults().  If you need to allocate
+        more table structures, jpeg_alloc_huff_table() may be used.
+        Note that optimal Huffman tables can be computed for an image
+        by setting optimize_coding, as discussed above; there's seldom
+        any need to mess with providing your own Huffman tables.
+
+
+[libjpeg v7+ API/ABI emulation only]
+The actual dimensions of the JPEG image that will be written to the file are
+given by the following fields.  These are computed from the input image
+dimensions and the compression parameters by jpeg_start_compress().  You can
+also call jpeg_calc_jpeg_dimensions() to obtain the values that will result
+from the current parameter settings.  This can be useful if you are trying
+to pick a scaling ratio that will get close to a desired target size.
+
+JDIMENSION jpeg_width           Actual dimensions of output image.
+JDIMENSION jpeg_height
+
+
+Per-component parameters are stored in the struct cinfo.comp_info[i] for
+component number i.  Note that components here refer to components of the
+JPEG color space, *not* the source image color space.  A suitably large
+comp_info[] array is allocated by jpeg_set_defaults(); if you choose not
+to use that routine, it's up to you to allocate the array.
+
+int component_id
+        The one-byte identifier code to be recorded in the JPEG file for
+        this component.  For the standard color spaces, we recommend you
+        leave the default values alone.
+
+int h_samp_factor
+int v_samp_factor
+        Horizontal and vertical sampling factors for the component; must
+        be 1..4 according to the JPEG standard.  Note that larger sampling
+        factors indicate a higher-resolution component; many people find
+        this behavior quite unintuitive.  The default values are 2,2 for
+        luminance components and 1,1 for chrominance components, except
+        for grayscale where 1,1 is used.
+
+int quant_tbl_no
+        Quantization table number for component.  The default value is
+        0 for luminance components and 1 for chrominance components.
+
+int dc_tbl_no
+int ac_tbl_no
+        DC and AC entropy coding table numbers.  The default values are
+        0 for luminance components and 1 for chrominance components.
+
+int component_index
+        Must equal the component's index in comp_info[].  (Beginning in
+        release v6, the compressor library will fill this in automatically;
+        you don't have to.)
+
+
+Decompression parameter selection
+---------------------------------
+
+Decompression parameter selection is somewhat simpler than compression
+parameter selection, since all of the JPEG internal parameters are
+recorded in the source file and need not be supplied by the application.
+(Unless you are working with abbreviated files, in which case see
+"Abbreviated datastreams", below.)  Decompression parameters control
+the postprocessing done on the image to deliver it in a format suitable
+for the application's use.  Many of the parameters control speed/quality
+tradeoffs, in which faster decompression may be obtained at the price of
+a poorer-quality image.  The defaults select the highest quality (slowest)
+processing.
+
+The following fields in the JPEG object are set by jpeg_read_header() and
+may be useful to the application in choosing decompression parameters:
+
+JDIMENSION image_width                  Width and height of image
+JDIMENSION image_height
+int num_components                      Number of color components
+J_COLOR_SPACE jpeg_color_space          Colorspace of image
+boolean saw_JFIF_marker                 TRUE if a JFIF APP0 marker was seen
+  UINT8 JFIF_major_version              Version information from JFIF marker
+  UINT8 JFIF_minor_version
+  UINT8 density_unit                    Resolution data from JFIF marker
+  UINT16 X_density
+  UINT16 Y_density
+boolean saw_Adobe_marker                TRUE if an Adobe APP14 marker was seen
+  UINT8 Adobe_transform                 Color transform code from Adobe marker
+
+The JPEG color space, unfortunately, is something of a guess since the JPEG
+standard proper does not provide a way to record it.  In practice most files
+adhere to the JFIF or Adobe conventions, and the decoder will recognize these
+correctly.  See "Special color spaces", below, for more info.
+
+
+The decompression parameters that determine the basic properties of the
+returned image are:
+
+J_COLOR_SPACE out_color_space
+        Output color space.  jpeg_read_header() sets an appropriate default
+        based on jpeg_color_space; typically it will be RGB or grayscale.
+        The application can change this field to request output in a different
+        colorspace.  For example, set it to JCS_GRAYSCALE to get grayscale
+        output from a color file.  (This is useful for previewing: grayscale
+        output is faster than full color since the color components need not
+        be processed.)  Note that not all possible color space transforms are
+        currently implemented; you may need to extend jdcolor.c if you want an
+        unusual conversion.
+
+unsigned int scale_num, scale_denom
+        Scale the image by the fraction scale_num/scale_denom.  Default is
+        1/1, or no scaling.  Currently, the only supported scaling ratios
+        are M/8 with all M from 1 to 16, or any reduced fraction thereof (such
+        as 1/2, 3/4, etc.)  (The library design allows for arbitrary
+        scaling ratios but this is not likely to be implemented any time soon.)
+        Smaller scaling ratios permit significantly faster decoding since
+        fewer pixels need be processed and a simpler IDCT method can be used.
+
+boolean quantize_colors
+        If set TRUE, colormapped output will be delivered.  Default is FALSE,
+        meaning that full-color output will be delivered.
+
+The next three parameters are relevant only if quantize_colors is TRUE.
+
+int desired_number_of_colors
+        Maximum number of colors to use in generating a library-supplied color
+        map (the actual number of colors is returned in a different field).
+        Default 256.  Ignored when the application supplies its own color map.
+
+boolean two_pass_quantize
+        If TRUE, an extra pass over the image is made to select a custom color
+        map for the image.  This usually looks a lot better than the one-size-
+        fits-all colormap that is used otherwise.  Default is TRUE.  Ignored
+        when the application supplies its own color map.
+
+J_DITHER_MODE dither_mode
+        Selects color dithering method.  Supported values are:
+                JDITHER_NONE    no dithering: fast, very low quality
+                JDITHER_ORDERED ordered dither: moderate speed and quality
+                JDITHER_FS      Floyd-Steinberg dither: slow, high quality
+        Default is JDITHER_FS.  (At present, ordered dither is implemented
+        only in the single-pass, standard-colormap case.  If you ask for
+        ordered dither when two_pass_quantize is TRUE or when you supply
+        an external color map, you'll get F-S dithering.)
+
+When quantize_colors is TRUE, the target color map is described by the next
+two fields.  colormap is set to NULL by jpeg_read_header().  The application
+can supply a color map by setting colormap non-NULL and setting
+actual_number_of_colors to the map size.  Otherwise, jpeg_start_decompress()
+selects a suitable color map and sets these two fields itself.
+[Implementation restriction: at present, an externally supplied colormap is
+only accepted for 3-component output color spaces.]
+
+JSAMPARRAY colormap
+        The color map, represented as a 2-D pixel array of out_color_components
+        rows and actual_number_of_colors columns.  Ignored if not quantizing.
+        CAUTION: if the JPEG library creates its own colormap, the storage
+        pointed to by this field is released by jpeg_finish_decompress().
+        Copy the colormap somewhere else first, if you want to save it.
+
+int actual_number_of_colors
+        The number of colors in the color map.
+
+Additional decompression parameters that the application may set include:
+
+J_DCT_METHOD dct_method
+        Selects the algorithm used for the DCT step.  Choices are:
+                JDCT_ISLOW: accurate integer method
+                JDCT_IFAST: less accurate integer method [legacy feature]
+                JDCT_FLOAT: floating-point method [legacy feature]
+                JDCT_DEFAULT: default method (normally JDCT_ISLOW)
+                JDCT_FASTEST: fastest method (normally JDCT_IFAST)
+        When the Independent JPEG Group's software was first released in 1991,
+        the decompression time for a 1-megapixel JPEG image on a mainstream PC
+        was measured in minutes.  Thus, JDCT_IFAST provided noticeable
+        performance benefits.  On modern CPUs running libjpeg-turbo, however,
+        the decompression time for a 1-megapixel JPEG image is measured in
+        milliseconds, and thus the performance benefits of JDCT_IFAST are much
+        less noticeable.  On modern x86/x86-64 CPUs that support AVX2
+        instructions, JDCT_IFAST and JDCT_ISLOW have similar performance.  On
+        other types of CPUs, JDCT_IFAST is generally about 5-15% faster than
+        JDCT_ISLOW.
+
+        If the JPEG image was compressed using a quality level of 85 or below,
+        then there should be little or no perceptible quality difference
+        between the two algorithms.  When decompressing images that were
+        compressed using quality levels above 85, however, the difference
+        between JDCT_IFAST and JDCT_ISLOW becomes more pronounced.  With images
+        compressed using quality=97, for instance, JDCT_IFAST incurs generally
+        about a 4-6 dB loss in PSNR relative to JDCT_ISLOW, but this can be
+        larger for some images.  If you can avoid it, do not use JDCT_IFAST
+        when decompressing images that were compressed using quality levels
+        above 97.  The algorithm often degenerates for such images and can
+        actually produce a more lossy output image than if the JPEG image had
+        been compressed using lower quality levels.
+
+        JDCT_FLOAT does not produce significantly more accurate results than
+        JDCT_ISLOW, and it is much slower.  JDCT_FLOAT may also give different
+        results on different machines due to varying roundoff behavior, whereas
+        the integer methods should give the same results on all machines.
+
+boolean do_fancy_upsampling
+        If TRUE, do careful upsampling of chroma components.  If FALSE,
+        a faster but sloppier method is used.  Default is TRUE.  The visual
+        impact of the sloppier method is often very small.
+
+boolean do_block_smoothing
+        If TRUE, interblock smoothing is applied in early stages of decoding
+        progressive JPEG files; if FALSE, not.  Default is TRUE.  Early
+        progression stages look "fuzzy" with smoothing, "blocky" without.
+        In any case, block smoothing ceases to be applied after the first few
+        AC coefficients are known to full accuracy, so it is relevant only
+        when using buffered-image mode for progressive images.
+
+boolean enable_1pass_quant
+boolean enable_external_quant
+boolean enable_2pass_quant
+        These are significant only in buffered-image mode, which is
+        described in its own section below.
+
+
+The output image dimensions are given by the following fields.  These are
+computed from the source image dimensions and the decompression parameters
+by jpeg_start_decompress().  You can also call jpeg_calc_output_dimensions()
+to obtain the values that will result from the current parameter settings.
+This can be useful if you are trying to pick a scaling ratio that will get
+close to a desired target size.  It's also important if you are using the
+JPEG library's memory manager to allocate output buffer space, because you
+are supposed to request such buffers *before* jpeg_start_decompress().
+
+JDIMENSION output_width         Actual dimensions of output image.
+JDIMENSION output_height
+int out_color_components        Number of color components in out_color_space.
+int output_components           Number of color components returned.
+int rec_outbuf_height           Recommended height of scanline buffer.
+
+When quantizing colors, output_components is 1, indicating a single color map
+index per pixel.  Otherwise it equals out_color_components.  The output arrays
+are required to be output_width * output_components JSAMPLEs wide.
+
+rec_outbuf_height is the recommended minimum height (in scanlines) of the
+buffer passed to jpeg_read_scanlines().  If the buffer is smaller, the
+library will still work, but time will be wasted due to unnecessary data
+copying.  In high-quality modes, rec_outbuf_height is always 1, but some
+faster, lower-quality modes set it to larger values (typically 2 to 4).
+If you are going to ask for a high-speed processing mode, you may as well
+go to the trouble of honoring rec_outbuf_height so as to avoid data copying.
+(An output buffer larger than rec_outbuf_height lines is OK, but won't
+provide any material speed improvement over that height.)
+
+
+Special color spaces
+--------------------
+
+The JPEG standard itself is "color blind" and doesn't specify any particular
+color space.  It is customary to convert color data to a luminance/chrominance
+color space before compressing, since this permits greater compression.  The
+existing de-facto JPEG file format standards specify YCbCr or grayscale data
+(JFIF), or grayscale, RGB, YCbCr, CMYK, or YCCK (Adobe).  For special
+applications such as multispectral images, other color spaces can be used,
+but it must be understood that such files will be unportable.
+
+The JPEG library can handle the most common colorspace conversions (namely
+RGB <=> YCbCr and CMYK <=> YCCK).  It can also deal with data of an unknown
+color space, passing it through without conversion.  If you deal extensively
+with an unusual color space, you can easily extend the library to understand
+additional color spaces and perform appropriate conversions.
+
+For compression, the source data's color space is specified by field
+in_color_space.  This is transformed to the JPEG file's color space given
+by jpeg_color_space.  jpeg_set_defaults() chooses a reasonable JPEG color
+space depending on in_color_space, but you can override this by calling
+jpeg_set_colorspace().  Of course you must select a supported transformation.
+jccolor.c currently supports the following transformations:
+        RGB => YCbCr
+        RGB => GRAYSCALE
+        YCbCr => GRAYSCALE
+        CMYK => YCCK
+plus the null transforms: GRAYSCALE => GRAYSCALE, RGB => RGB,
+YCbCr => YCbCr, CMYK => CMYK, YCCK => YCCK, and UNKNOWN => UNKNOWN.
+
+The de-facto file format standards (JFIF and Adobe) specify APPn markers that
+indicate the color space of the JPEG file.  It is important to ensure that
+these are written correctly, or omitted if the JPEG file's color space is not
+one of the ones supported by the de-facto standards.  jpeg_set_colorspace()
+will set the compression parameters to include or omit the APPn markers
+properly, so long as it is told the truth about the JPEG color space.
+For example, if you are writing some random 3-component color space without
+conversion, don't try to fake out the library by setting in_color_space and
+jpeg_color_space to JCS_YCbCr; use JCS_UNKNOWN.  You may want to write an
+APPn marker of your own devising to identify the colorspace --- see "Special
+markers", below.
+
+When told that the color space is UNKNOWN, the library will default to using
+luminance-quality compression parameters for all color components.  You may
+well want to change these parameters.  See the source code for
+jpeg_set_colorspace(), in jcparam.c, for details.
+
+For decompression, the JPEG file's color space is given in jpeg_color_space,
+and this is transformed to the output color space out_color_space.
+jpeg_read_header's setting of jpeg_color_space can be relied on if the file
+conforms to JFIF or Adobe conventions, but otherwise it is no better than a
+guess.  If you know the JPEG file's color space for certain, you can override
+jpeg_read_header's guess by setting jpeg_color_space.  jpeg_read_header also
+selects a default output color space based on (its guess of) jpeg_color_space;
+set out_color_space to override this.  Again, you must select a supported
+transformation.  jdcolor.c currently supports
+        YCbCr => RGB
+        YCbCr => GRAYSCALE
+        RGB => GRAYSCALE
+        GRAYSCALE => RGB
+        YCCK => CMYK
+as well as the null transforms.  (Since GRAYSCALE=>RGB is provided, an
+application can force grayscale JPEGs to look like color JPEGs if it only
+wants to handle one case.)
+
+The two-pass color quantizer, jquant2.c, is specialized to handle RGB data
+(it weights distances appropriately for RGB colors).  You'll need to modify
+the code if you want to use it for non-RGB output color spaces.  Note that
+jquant2.c is used to map to an application-supplied colormap as well as for
+the normal two-pass colormap selection process.
+
+CAUTION: it appears that Adobe Photoshop writes inverted data in CMYK JPEG
+files: 0 represents 100% ink coverage, rather than 0% ink as you'd expect.
+This is arguably a bug in Photoshop, but if you need to work with Photoshop
+CMYK files, you will have to deal with it in your application.  We cannot
+"fix" this in the library by inverting the data during the CMYK<=>YCCK
+transform, because that would break other applications, notably Ghostscript.
+Photoshop versions prior to 3.0 write EPS files containing JPEG-encoded CMYK
+data in the same inverted-YCCK representation used in bare JPEG files, but
+the surrounding PostScript code performs an inversion using the PS image
+operator.  I am told that Photoshop 3.0 will write uninverted YCCK in
+EPS/JPEG files, and will omit the PS-level inversion.  (But the data
+polarity used in bare JPEG files will not change in 3.0.)  In either case,
+the JPEG library must not invert the data itself, or else Ghostscript would
+read these EPS files incorrectly.
+
+
+Error handling
+--------------
+
+When the default error handler is used, any error detected inside the JPEG
+routines will cause a message to be printed on stderr, followed by exit().
+You can supply your own error handling routines to override this behavior
+and to control the treatment of nonfatal warnings and trace/debug messages.
+The file example.txt illustrates the most common case, which is to have the
+application regain control after an error rather than exiting.
+
+The JPEG library never writes any message directly; it always goes through
+the error handling routines.  Three classes of messages are recognized:
+  * Fatal errors: the library cannot continue.
+  * Warnings: the library can continue, but the data is corrupt, and a
+    damaged output image is likely to result.
+  * Trace/informational messages.  These come with a trace level indicating
+    the importance of the message; you can control the verbosity of the
+    program by adjusting the maximum trace level that will be displayed.
+
+You may, if you wish, simply replace the entire JPEG error handling module
+(jerror.c) with your own code.  However, you can avoid code duplication by
+only replacing some of the routines depending on the behavior you need.
+This is accomplished by calling jpeg_std_error() as usual, but then overriding
+some of the method pointers in the jpeg_error_mgr struct, as illustrated by
+example.txt.
+
+All of the error handling routines will receive a pointer to the JPEG object
+(a j_common_ptr which points to either a jpeg_compress_struct or a
+jpeg_decompress_struct; if you need to tell which, test the is_decompressor
+field).  This struct includes a pointer to the error manager struct in its
+"err" field.  Frequently, custom error handler routines will need to access
+additional data which is not known to the JPEG library or the standard error
+handler.  The most convenient way to do this is to embed either the JPEG
+object or the jpeg_error_mgr struct in a larger structure that contains
+additional fields; then casting the passed pointer provides access to the
+additional fields.  Again, see example.txt for one way to do it.  (Beginning
+with IJG version 6b, there is also a void pointer "client_data" in each
+JPEG object, which the application can also use to find related data.
+The library does not touch client_data at all.)
+
+The individual methods that you might wish to override are:
+
+error_exit (j_common_ptr cinfo)
+        Receives control for a fatal error.  Information sufficient to
+        generate the error message has been stored in cinfo->err; call
+        output_message to display it.  Control must NOT return to the caller;
+        generally this routine will exit() or longjmp() somewhere.
+        Typically you would override this routine to get rid of the exit()
+        default behavior.  Note that if you continue processing, you should
+        clean up the JPEG object with jpeg_abort() or jpeg_destroy().
+
+output_message (j_common_ptr cinfo)
+        Actual output of any JPEG message.  Override this to send messages
+        somewhere other than stderr.  Note that this method does not know
+        how to generate a message, only where to send it.
+
+format_message (j_common_ptr cinfo, char *buffer)
+        Constructs a readable error message string based on the error info
+        stored in cinfo->err.  This method is called by output_message.  Few
+        applications should need to override this method.  One possible
+        reason for doing so is to implement dynamic switching of error message
+        language.
+
+emit_message (j_common_ptr cinfo, int msg_level)
+        Decide whether or not to emit a warning or trace message; if so,
+        calls output_message.  The main reason for overriding this method
+        would be to abort on warnings.  msg_level is -1 for warnings,
+        0 and up for trace messages.
+
+Only error_exit() and emit_message() are called from the rest of the JPEG
+library; the other two are internal to the error handler.
+
+The actual message texts are stored in an array of strings which is pointed to
+by the field err->jpeg_message_table.  The messages are numbered from 0 to
+err->last_jpeg_message, and it is these code numbers that are used in the
+JPEG library code.  You could replace the message texts (for instance, with
+messages in French or German) by changing the message table pointer.  See
+jerror.h for the default texts.  CAUTION: this table will almost certainly
+change or grow from one library version to the next.
+
+It may be useful for an application to add its own message texts that are
+handled by the same mechanism.  The error handler supports a second "add-on"
+message table for this purpose.  To define an addon table, set the pointer
+err->addon_message_table and the message numbers err->first_addon_message and
+err->last_addon_message.  If you number the addon messages beginning at 1000
+or so, you won't have to worry about conflicts with the library's built-in
+messages.  See the sample applications cjpeg/djpeg for an example of using
+addon messages (the addon messages are defined in cderror.h).
+
+Actual invocation of the error handler is done via macros defined in jerror.h:
+        ERREXITn(...)   for fatal errors
+        WARNMSn(...)    for corrupt-data warnings
+        TRACEMSn(...)   for trace and informational messages.
+These macros store the message code and any additional parameters into the
+error handler struct, then invoke the error_exit() or emit_message() method.
+The variants of each macro are for varying numbers of additional parameters.
+The additional parameters are inserted into the generated message using
+standard printf() format codes.
+
+See jerror.h and jerror.c for further details.
+
+
+Compressed data handling (source and destination managers)
+----------------------------------------------------------
+
+The JPEG compression library sends its compressed data to a "destination
+manager" module.  The default destination manager just writes the data to a
+memory buffer or to a stdio stream, but you can provide your own manager to
+do something else.  Similarly, the decompression library calls a "source
+manager" to obtain the compressed data; you can provide your own source
+manager if you want the data to come from somewhere other than a memory
+buffer or a stdio stream.
+
+In both cases, compressed data is processed a bufferload at a time: the
+destination or source manager provides a work buffer, and the library invokes
+the manager only when the buffer is filled or emptied.  (You could define a
+one-character buffer to force the manager to be invoked for each byte, but
+that would be rather inefficient.)  The buffer's size and location are
+controlled by the manager, not by the library.  For example, the memory
+source manager just makes the buffer pointer and length point to the original
+data in memory.  In this case the buffer-reload procedure will be invoked
+only if the decompressor ran off the end of the datastream, which would
+indicate an erroneous datastream.
+
+The work buffer is defined as an array of datatype JOCTET, which is generally
+"char" or "unsigned char".  On a machine where char is not exactly 8 bits
+wide, you must define JOCTET as a wider data type and then modify the data
+source and destination modules to transcribe the work arrays into 8-bit units
+on external storage.
+
+A data destination manager struct contains a pointer and count defining the
+next byte to write in the work buffer and the remaining free space:
+
+        JOCTET *next_output_byte;   /* => next byte to write in buffer */
+        size_t free_in_buffer;      /* # of byte spaces remaining in buffer */
+
+The library increments the pointer and decrements the count until the buffer
+is filled.  The manager's empty_output_buffer method must reset the pointer
+and count.  The manager is expected to remember the buffer's starting address
+and total size in private fields not visible to the library.
+
+A data destination manager provides three methods:
+
+init_destination (j_compress_ptr cinfo)
+        Initialize destination.  This is called by jpeg_start_compress()
+        before any data is actually written.  It must initialize
+        next_output_byte and free_in_buffer.  free_in_buffer must be
+        initialized to a positive value.
+
+empty_output_buffer (j_compress_ptr cinfo)
+        This is called whenever the buffer has filled (free_in_buffer
+        reaches zero).  In typical applications, it should write out the
+        *entire* buffer (use the saved start address and buffer length;
+        ignore the current state of next_output_byte and free_in_buffer).
+        Then reset the pointer & count to the start of the buffer, and
+        return TRUE indicating that the buffer has been dumped.
+        free_in_buffer must be set to a positive value when TRUE is
+        returned.  A FALSE return should only be used when I/O suspension is
+        desired (this operating mode is discussed in the next section).
+
+term_destination (j_compress_ptr cinfo)
+        Terminate destination --- called by jpeg_finish_compress() after all
+        data has been written.  In most applications, this must flush any
+        data remaining in the buffer.  Use either next_output_byte or
+        free_in_buffer to determine how much data is in the buffer.
+
+term_destination() is NOT called by jpeg_abort() or jpeg_destroy().  If you
+want the destination manager to be cleaned up during an abort, you must do it
+yourself.
+
+You will also need code to create a jpeg_destination_mgr struct, fill in its
+method pointers, and insert a pointer to the struct into the "dest" field of
+the JPEG compression object.  This can be done in-line in your setup code if
+you like, but it's probably cleaner to provide a separate routine similar to
+the jpeg_stdio_dest() or jpeg_mem_dest() routines of the supplied destination
+managers.
+
+Decompression source managers follow a parallel design, but with some
+additional frammishes.  The source manager struct contains a pointer and count
+defining the next byte to read from the work buffer and the number of bytes
+remaining:
+
+        const JOCTET *next_input_byte;  /* => next byte to read from buffer */
+        size_t bytes_in_buffer;         /* # of bytes remaining in buffer */
+
+The library increments the pointer and decrements the count until the buffer
+is emptied.  The manager's fill_input_buffer method must reset the pointer and
+count.  In most applications, the manager must remember the buffer's starting
+address and total size in private fields not visible to the library.
+
+A data source manager provides five methods:
+
+init_source (j_decompress_ptr cinfo)
+        Initialize source.  This is called by jpeg_read_header() before any
+        data is actually read.  Unlike init_destination(), it may leave
+        bytes_in_buffer set to 0 (in which case a fill_input_buffer() call
+        will occur immediately).
+
+fill_input_buffer (j_decompress_ptr cinfo)
+        This is called whenever bytes_in_buffer has reached zero and more
+        data is wanted.  In typical applications, it should read fresh data
+        into the buffer (ignoring the current state of next_input_byte and
+        bytes_in_buffer), reset the pointer & count to the start of the
+        buffer, and return TRUE indicating that the buffer has been reloaded.
+        It is not necessary to fill the buffer entirely, only to obtain at
+        least one more byte.  bytes_in_buffer MUST be set to a positive value
+        if TRUE is returned.  A FALSE return should only be used when I/O
+        suspension is desired (this mode is discussed in the next section).
+
+skip_input_data (j_decompress_ptr cinfo, long num_bytes)
+        Skip num_bytes worth of data.  The buffer pointer and count should
+        be advanced over num_bytes input bytes, refilling the buffer as
+        needed.  This is used to skip over a potentially large amount of
+        uninteresting data (such as an APPn marker).  In some applications
+        it may be possible to optimize away the reading of the skipped data,
+        but it's not clear that being smart is worth much trouble; large
+        skips are uncommon.  bytes_in_buffer may be zero on return.
+        A zero or negative skip count should be treated as a no-op.
+
+resync_to_restart (j_decompress_ptr cinfo, int desired)
+        This routine is called only when the decompressor has failed to find
+        a restart (RSTn) marker where one is expected.  Its mission is to
+        find a suitable point for resuming decompression.  For most
+        applications, we recommend that you just use the default resync
+        procedure, jpeg_resync_to_restart().  However, if you are able to back
+        up in the input data stream, or if you have a-priori knowledge about
+        the likely location of restart markers, you may be able to do better.
+        Read the read_restart_marker() and jpeg_resync_to_restart() routines
+        in jdmarker.c if you think you'd like to implement your own resync
+        procedure.
+
+term_source (j_decompress_ptr cinfo)
+        Terminate source --- called by jpeg_finish_decompress() after all
+        data has been read.  Often a no-op.
+
+For both fill_input_buffer() and skip_input_data(), there is no such thing
+as an EOF return.  If the end of the file has been reached, the routine has
+a choice of exiting via ERREXIT() or inserting fake data into the buffer.
+In most cases, generating a warning message and inserting a fake EOI marker
+is the best course of action --- this will allow the decompressor to output
+however much of the image is there.  In pathological cases, the decompressor
+may swallow the EOI and again demand data ... just keep feeding it fake EOIs.
+jdatasrc.c illustrates the recommended error recovery behavior.
+
+term_source() is NOT called by jpeg_abort() or jpeg_destroy().  If you want
+the source manager to be cleaned up during an abort, you must do it yourself.
+
+You will also need code to create a jpeg_source_mgr struct, fill in its method
+pointers, and insert a pointer to the struct into the "src" field of the JPEG
+decompression object.  This can be done in-line in your setup code if you
+like, but it's probably cleaner to provide a separate routine similar to the
+jpeg_stdio_src() or jpeg_mem_src() routines of the supplied source managers.
+
+For more information, consult the memory and stdio source and destination
+managers in jdatasrc.c and jdatadst.c.
+
+
+I/O suspension
+--------------
+
+Some applications need to use the JPEG library as an incremental memory-to-
+memory filter: when the compressed data buffer is filled or emptied, they want
+control to return to the outer loop, rather than expecting that the buffer can
+be emptied or reloaded within the data source/destination manager subroutine.
+The library supports this need by providing an "I/O suspension" mode, which we
+describe in this section.
+
+The I/O suspension mode is not a panacea: nothing is guaranteed about the
+maximum amount of time spent in any one call to the library, so it will not
+eliminate response-time problems in single-threaded applications.  If you
+need guaranteed response time, we suggest you "bite the bullet" and implement
+a real multi-tasking capability.
+
+To use I/O suspension, cooperation is needed between the calling application
+and the data source or destination manager; you will always need a custom
+source/destination manager.  (Please read the previous section if you haven't
+already.)  The basic idea is that the empty_output_buffer() or
+fill_input_buffer() routine is a no-op, merely returning FALSE to indicate
+that it has done nothing.  Upon seeing this, the JPEG library suspends
+operation and returns to its caller.  The surrounding application is
+responsible for emptying or refilling the work buffer before calling the
+JPEG library again.
+
+Compression suspension:
+
+For compression suspension, use an empty_output_buffer() routine that returns
+FALSE; typically it will not do anything else.  This will cause the
+compressor to return to the caller of jpeg_write_scanlines(), with the return
+value indicating that not all the supplied scanlines have been accepted.
+The application must make more room in the output buffer, adjust the output
+buffer pointer/count appropriately, and then call jpeg_write_scanlines()
+again, pointing to the first unconsumed scanline.
+
+When forced to suspend, the compressor will backtrack to a convenient stopping
+point (usually the start of the current MCU); it will regenerate some output
+data when restarted.  Therefore, although empty_output_buffer() is only
+called when the buffer is filled, you should NOT write out the entire buffer
+after a suspension.  Write only the data up to the current position of
+next_output_byte/free_in_buffer.  The data beyond that point will be
+regenerated after resumption.
+
+Because of the backtracking behavior, a good-size output buffer is essential
+for efficiency; you don't want the compressor to suspend often.  (In fact, an
+overly small buffer could lead to infinite looping, if a single MCU required
+more data than would fit in the buffer.)  We recommend a buffer of at least
+several Kbytes.  You may want to insert explicit code to ensure that you don't
+call jpeg_write_scanlines() unless there is a reasonable amount of space in
+the output buffer; in other words, flush the buffer before trying to compress
+more data.
+
+The compressor does not allow suspension while it is trying to write JPEG
+markers at the beginning and end of the file.  This means that:
+  * At the beginning of a compression operation, there must be enough free
+    space in the output buffer to hold the header markers (typically 600 or
+    so bytes).  The recommended buffer size is bigger than this anyway, so
+    this is not a problem as long as you start with an empty buffer.  However,
+    this restriction might catch you if you insert large special markers, such
+    as a JFIF thumbnail image, without flushing the buffer afterwards.
+  * When you call jpeg_finish_compress(), there must be enough space in the
+    output buffer to emit any buffered data and the final EOI marker.  In the
+    current implementation, half a dozen bytes should suffice for this, but
+    for safety's sake we recommend ensuring that at least 100 bytes are free
+    before calling jpeg_finish_compress().
+
+A more significant restriction is that jpeg_finish_compress() cannot suspend.
+This means you cannot use suspension with multi-pass operating modes, namely
+Huffman code optimization and multiple-scan output.  Those modes write the
+whole file during jpeg_finish_compress(), which will certainly result in
+buffer overrun.  (Note that this restriction applies only to compression,
+not decompression.  The decompressor supports input suspension in all of its
+operating modes.)
+
+Decompression suspension:
+
+For decompression suspension, use a fill_input_buffer() routine that simply
+returns FALSE (except perhaps during error recovery, as discussed below).
+This will cause the decompressor to return to its caller with an indication
+that suspension has occurred.  This can happen at four places:
+  * jpeg_read_header(): will return JPEG_SUSPENDED.
+  * jpeg_start_decompress(): will return FALSE, rather than its usual TRUE.
+  * jpeg_read_scanlines(): will return the number of scanlines already
+        completed (possibly 0).
+  * jpeg_finish_decompress(): will return FALSE, rather than its usual TRUE.
+The surrounding application must recognize these cases, load more data into
+the input buffer, and repeat the call.  In the case of jpeg_read_scanlines(),
+increment the passed pointers past any scanlines successfully read.
+
+Just as with compression, the decompressor will typically backtrack to a
+convenient restart point before suspending.  When fill_input_buffer() is
+called, next_input_byte/bytes_in_buffer point to the current restart point,
+which is where the decompressor will backtrack to if FALSE is returned.
+The data beyond that position must NOT be discarded if you suspend; it needs
+to be re-read upon resumption.  In most implementations, you'll need to shift
+this data down to the start of your work buffer and then load more data after
+it.  Again, this behavior means that a several-Kbyte work buffer is essential
+for decent performance; furthermore, you should load a reasonable amount of
+new data before resuming decompression.  (If you loaded, say, only one new
+byte each time around, you could waste a LOT of cycles.)
+
+The skip_input_data() source manager routine requires special care in a
+suspension scenario.  This routine is NOT granted the ability to suspend the
+decompressor; it can decrement bytes_in_buffer to zero, but no more.  If the
+requested skip distance exceeds the amount of data currently in the input
+buffer, then skip_input_data() must set bytes_in_buffer to zero and record the
+additional skip distance somewhere else.  The decompressor will immediately
+call fill_input_buffer(), which should return FALSE, which will cause a
+suspension return.  The surrounding application must then arrange to discard
+the recorded number of bytes before it resumes loading the input buffer.
+(Yes, this design is rather baroque, but it avoids complexity in the far more
+common case where a non-suspending source manager is used.)
+
+If the input data has been exhausted, we recommend that you emit a warning
+and insert dummy EOI markers just as a non-suspending data source manager
+would do.  This can be handled either in the surrounding application logic or
+within fill_input_buffer(); the latter is probably more efficient.  If
+fill_input_buffer() knows that no more data is available, it can set the
+pointer/count to point to a dummy EOI marker and then return TRUE just as
+though it had read more data in a non-suspending situation.
+
+The decompressor does not attempt to suspend within standard JPEG markers;
+instead it will backtrack to the start of the marker and reprocess the whole
+marker next time.  Hence the input buffer must be large enough to hold the
+longest standard marker in the file.  Standard JPEG markers should normally
+not exceed a few hundred bytes each (DHT tables are typically the longest).
+We recommend at least a 2K buffer for performance reasons, which is much
+larger than any correct marker is likely to be.  For robustness against
+damaged marker length counts, you may wish to insert a test in your
+application for the case that the input buffer is completely full and yet
+the decoder has suspended without consuming any data --- otherwise, if this
+situation did occur, it would lead to an endless loop.  (The library can't
+provide this test since it has no idea whether "the buffer is full", or
+even whether there is a fixed-size input buffer.)
+
+The input buffer would need to be 64K to allow for arbitrary COM or APPn
+markers, but these are handled specially: they are either saved into allocated
+memory, or skipped over by calling skip_input_data().  In the former case,
+suspension is handled correctly, and in the latter case, the problem of
+buffer overrun is placed on skip_input_data's shoulders, as explained above.
+Note that if you provide your own marker handling routine for large markers,
+you should consider how to deal with buffer overflow.
+
+Multiple-buffer management:
+
+In some applications it is desirable to store the compressed data in a linked
+list of buffer areas, so as to avoid data copying.  This can be handled by
+having empty_output_buffer() or fill_input_buffer() set the pointer and count
+to reference the next available buffer; FALSE is returned only if no more
+buffers are available.  Although seemingly straightforward, there is a
+pitfall in this approach: the backtrack that occurs when FALSE is returned
+could back up into an earlier buffer.  For example, when fill_input_buffer()
+is called, the current pointer & count indicate the backtrack restart point.
+Since fill_input_buffer() will set the pointer and count to refer to a new
+buffer, the restart position must be saved somewhere else.  Suppose a second
+call to fill_input_buffer() occurs in the same library call, and no
+additional input data is available, so fill_input_buffer must return FALSE.
+If the JPEG library has not moved the pointer/count forward in the current
+buffer, then *the correct restart point is the saved position in the prior
+buffer*.  Prior buffers may be discarded only after the library establishes
+a restart point within a later buffer.  Similar remarks apply for output into
+a chain of buffers.
+
+The library will never attempt to backtrack over a skip_input_data() call,
+so any skipped data can be permanently discarded.  You still have to deal
+with the case of skipping not-yet-received data, however.
+
+It's much simpler to use only a single buffer; when fill_input_buffer() is
+called, move any unconsumed data (beyond the current pointer/count) down to
+the beginning of this buffer and then load new data into the remaining buffer
+space.  This approach requires a little more data copying but is far easier
+to get right.
+
+
+Progressive JPEG support
+------------------------
+
+Progressive JPEG rearranges the stored data into a series of scans of
+increasing quality.  In situations where a JPEG file is transmitted across a
+slow communications link, a decoder can generate a low-quality image very
+quickly from the first scan, then gradually improve the displayed quality as
+more scans are received.  The final image after all scans are complete is
+identical to that of a regular (sequential) JPEG file of the same quality
+setting.  Progressive JPEG files are often slightly smaller than equivalent
+sequential JPEG files, but the possibility of incremental display is the main
+reason for using progressive JPEG.
+
+The IJG encoder library generates progressive JPEG files when given a
+suitable "scan script" defining how to divide the data into scans.
+Creation of progressive JPEG files is otherwise transparent to the encoder.
+Progressive JPEG files can also be read transparently by the decoder library.
+If the decoding application simply uses the library as defined above, it
+will receive a final decoded image without any indication that the file was
+progressive.  Of course, this approach does not allow incremental display.
+To perform incremental display, an application needs to use the decoder
+library's "buffered-image" mode, in which it receives a decoded image
+multiple times.
+
+Each displayed scan requires about as much work to decode as a full JPEG
+image of the same size, so the decoder must be fairly fast in relation to the
+data transmission rate in order to make incremental display useful.  However,
+it is possible to skip displaying the image and simply add the incoming bits
+to the decoder's coefficient buffer.  This is fast because only Huffman
+decoding need be done, not IDCT, upsampling, colorspace conversion, etc.
+The IJG decoder library allows the application to switch dynamically between
+displaying the image and simply absorbing the incoming bits.  A properly
+coded application can automatically adapt the number of display passes to
+suit the time available as the image is received.  Also, a final
+higher-quality display cycle can be performed from the buffered data after
+the end of the file is reached.
+
+Progressive compression:
+
+To create a progressive JPEG file (or a multiple-scan sequential JPEG file),
+set the scan_info cinfo field to point to an array of scan descriptors, and
+perform compression as usual.  Instead of constructing your own scan list,
+you can call the jpeg_simple_progression() helper routine to create a
+recommended progression sequence; this method should be used by all
+applications that don't want to get involved in the nitty-gritty of
+progressive scan sequence design.  (If you want to provide user control of
+scan sequences, you may wish to borrow the scan script reading code found
+in rdswitch.c, so that you can read scan script files just like cjpeg's.)
+When scan_info is not NULL, the compression library will store DCT'd data
+into a buffer array as jpeg_write_scanlines() is called, and will emit all
+the requested scans during jpeg_finish_compress().  This implies that
+multiple-scan output cannot be created with a suspending data destination
+manager, since jpeg_finish_compress() does not support suspension.  We
+should also note that the compressor currently forces Huffman optimization
+mode when creating a progressive JPEG file, because the default Huffman
+tables are unsuitable for progressive files.
+
+Progressive decompression:
+
+When buffered-image mode is not used, the decoder library will read all of
+a multi-scan file during jpeg_start_decompress(), so that it can provide a
+final decoded image.  (Here "multi-scan" means either progressive or
+multi-scan sequential.)  This makes multi-scan files transparent to the
+decoding application.  However, existing applications that used suspending
+input with version 5 of the IJG library will need to be modified to check
+for a suspension return from jpeg_start_decompress().
+
+To perform incremental display, an application must use the library's
+buffered-image mode.  This is described in the next section.
+
+
+Buffered-image mode
+-------------------
+
+In buffered-image mode, the library stores the partially decoded image in a
+coefficient buffer, from which it can be read out as many times as desired.
+This mode is typically used for incremental display of progressive JPEG files,
+but it can be used with any JPEG file.  Each scan of a progressive JPEG file
+adds more data (more detail) to the buffered image.  The application can
+display in lockstep with the source file (one display pass per input scan),
+or it can allow input processing to outrun display processing.  By making
+input and display processing run independently, it is possible for the
+application to adapt progressive display to a wide range of data transmission
+rates.
+
+The basic control flow for buffered-image decoding is
+
+        jpeg_create_decompress()
+        set data source
+        jpeg_read_header()
+        set overall decompression parameters
+        cinfo.buffered_image = TRUE;    /* select buffered-image mode */
+        jpeg_start_decompress()
+        for (each output pass) {
+            adjust output decompression parameters if required
+            jpeg_start_output()         /* start a new output pass */
+            for (all scanlines in image) {
+                jpeg_read_scanlines()
+                display scanlines
+            }
+            jpeg_finish_output()        /* terminate output pass */
+        }
+        jpeg_finish_decompress()
+        jpeg_destroy_decompress()
+
+This differs from ordinary unbuffered decoding in that there is an additional
+level of looping.  The application can choose how many output passes to make
+and how to display each pass.
+
+The simplest approach to displaying progressive images is to do one display
+pass for each scan appearing in the input file.  In this case the outer loop
+condition is typically
+        while (!jpeg_input_complete(&cinfo))
+and the start-output call should read
+        jpeg_start_output(&cinfo, cinfo.input_scan_number);
+The second parameter to jpeg_start_output() indicates which scan of the input
+file is to be displayed; the scans are numbered starting at 1 for this
+purpose.  (You can use a loop counter starting at 1 if you like, but using
+the library's input scan counter is easier.)  The library automatically reads
+data as necessary to complete each requested scan, and jpeg_finish_output()
+advances to the next scan or end-of-image marker (hence input_scan_number
+will be incremented by the time control arrives back at jpeg_start_output()).
+With this technique, data is read from the input file only as needed, and
+input and output processing run in lockstep.
+
+After reading the final scan and reaching the end of the input file, the
+buffered image remains available; it can be read additional times by
+repeating the jpeg_start_output()/jpeg_read_scanlines()/jpeg_finish_output()
+sequence.  For example, a useful technique is to use fast one-pass color
+quantization for display passes made while the image is arriving, followed by
+a final display pass using two-pass quantization for highest quality.  This
+is done by changing the library parameters before the final output pass.
+Changing parameters between passes is discussed in detail below.
+
+In general the last scan of a progressive file cannot be recognized as such
+until after it is read, so a post-input display pass is the best approach if
+you want special processing in the final pass.
+
+When done with the image, be sure to call jpeg_finish_decompress() to release
+the buffered image (or just use jpeg_destroy_decompress()).
+
+If input data arrives faster than it can be displayed, the application can
+cause the library to decode input data in advance of what's needed to produce
+output.  This is done by calling the routine jpeg_consume_input().
+The return value is one of the following:
+        JPEG_REACHED_SOS:    reached an SOS marker (the start of a new scan)
+        JPEG_REACHED_EOI:    reached the EOI marker (end of image)
+        JPEG_ROW_COMPLETED:  completed reading one MCU row of compressed data
+        JPEG_SCAN_COMPLETED: completed reading last MCU row of current scan
+        JPEG_SUSPENDED:      suspended before completing any of the above
+(JPEG_SUSPENDED can occur only if a suspending data source is used.)  This
+routine can be called at any time after initializing the JPEG object.  It
+reads some additional data and returns when one of the indicated significant
+events occurs.  (If called after the EOI marker is reached, it will
+immediately return JPEG_REACHED_EOI without attempting to read more data.)
+
+The library's output processing will automatically call jpeg_consume_input()
+whenever the output processing overtakes the input; thus, simple lockstep
+display requires no direct calls to jpeg_consume_input().  But by adding
+calls to jpeg_consume_input(), you can absorb data in advance of what is
+being displayed.  This has two benefits:
+  * You can limit buildup of unprocessed data in your input buffer.
+  * You can eliminate extra display passes by paying attention to the
+    state of the library's input processing.
+
+The first of these benefits only requires interspersing calls to
+jpeg_consume_input() with your display operations and any other processing
+you may be doing.  To avoid wasting cycles due to backtracking, it's best to
+call jpeg_consume_input() only after a hundred or so new bytes have arrived.
+This is discussed further under "I/O suspension", above.  (Note: the JPEG
+library currently is not thread-safe.  You must not call jpeg_consume_input()
+from one thread of control if a different library routine is working on the
+same JPEG object in another thread.)
+
+When input arrives fast enough that more than one new scan is available
+before you start a new output pass, you may as well skip the output pass
+corresponding to the completed scan.  This occurs for free if you pass
+cinfo.input_scan_number as the target scan number to jpeg_start_output().
+The input_scan_number field is simply the index of the scan currently being
+consumed by the input processor.  You can ensure that this is up-to-date by
+emptying the input buffer just before calling jpeg_start_output(): call
+jpeg_consume_input() repeatedly until it returns JPEG_SUSPENDED or
+JPEG_REACHED_EOI.
+
+The target scan number passed to jpeg_start_output() is saved in the
+cinfo.output_scan_number field.  The library's output processing calls
+jpeg_consume_input() whenever the current input scan number and row within
+that scan is less than or equal to the current output scan number and row.
+Thus, input processing can "get ahead" of the output processing but is not
+allowed to "fall behind".  You can achieve several different effects by
+manipulating this interlock rule.  For example, if you pass a target scan
+number greater than the current input scan number, the output processor will
+wait until that scan starts to arrive before producing any output.  (To avoid
+an infinite loop, the target scan number is automatically reset to the last
+scan number when the end of image is reached.  Thus, if you specify a large
+target scan number, the library will just absorb the entire input file and
+then perform an output pass.  This is effectively the same as what
+jpeg_start_decompress() does when you don't select buffered-image mode.)
+When you pass a target scan number equal to the current input scan number,
+the image is displayed no faster than the current input scan arrives.  The
+final possibility is to pass a target scan number less than the current input
+scan number; this disables the input/output interlock and causes the output
+processor to simply display whatever it finds in the image buffer, without
+waiting for input.  (However, the library will not accept a target scan
+number less than one, so you can't avoid waiting for the first scan.)
+
+When data is arriving faster than the output display processing can advance
+through the image, jpeg_consume_input() will store data into the buffered
+image beyond the point at which the output processing is reading data out
+again.  If the input arrives fast enough, it may "wrap around" the buffer to
+the point where the input is more than one whole scan ahead of the output.
+If the output processing simply proceeds through its display pass without
+paying attention to the input, the effect seen on-screen is that the lower
+part of the image is one or more scans better in quality than the upper part.
+Then, when the next output scan is started, you have a choice of what target
+scan number to use.  The recommended choice is to use the current input scan
+number at that time, which implies that you've skipped the output scans
+corresponding to the input scans that were completed while you processed the
+previous output scan.  In this way, the decoder automatically adapts its
+speed to the arriving data, by skipping output scans as necessary to keep up
+with the arriving data.
+
+When using this strategy, you'll want to be sure that you perform a final
+output pass after receiving all the data; otherwise your last display may not
+be full quality across the whole screen.  So the right outer loop logic is
+something like this:
+        do {
+            absorb any waiting input by calling jpeg_consume_input()
+            final_pass = jpeg_input_complete(&cinfo);
+            adjust output decompression parameters if required
+            jpeg_start_output(&cinfo, cinfo.input_scan_number);
+            ...
+            jpeg_finish_output()
+        } while (!final_pass);
+rather than quitting as soon as jpeg_input_complete() returns TRUE.  This
+arrangement makes it simple to use higher-quality decoding parameters
+for the final pass.  But if you don't want to use special parameters for
+the final pass, the right loop logic is like this:
+        for (;;) {
+            absorb any waiting input by calling jpeg_consume_input()
+            jpeg_start_output(&cinfo, cinfo.input_scan_number);
+            ...
+            jpeg_finish_output()
+            if (jpeg_input_complete(&cinfo) &&
+                cinfo.input_scan_number == cinfo.output_scan_number)
+              break;
+        }
+In this case you don't need to know in advance whether an output pass is to
+be the last one, so it's not necessary to have reached EOF before starting
+the final output pass; rather, what you want to test is whether the output
+pass was performed in sync with the final input scan.  This form of the loop
+will avoid an extra output pass whenever the decoder is able (or nearly able)
+to keep up with the incoming data.
+
+When the data transmission speed is high, you might begin a display pass,
+then find that much or all of the file has arrived before you can complete
+the pass.  (You can detect this by noting the JPEG_REACHED_EOI return code
+from jpeg_consume_input(), or equivalently by testing jpeg_input_complete().)
+In this situation you may wish to abort the current display pass and start a
+new one using the newly arrived information.  To do so, just call
+jpeg_finish_output() and then start a new pass with jpeg_start_output().
+
+A variant strategy is to abort and restart display if more than one complete
+scan arrives during an output pass; this can be detected by noting
+JPEG_REACHED_SOS returns and/or examining cinfo.input_scan_number.  This
+idea should be employed with caution, however, since the display process
+might never get to the bottom of the image before being aborted, resulting
+in the lower part of the screen being several passes worse than the upper.
+In most cases it's probably best to abort an output pass only if the whole
+file has arrived and you want to begin the final output pass immediately.
+
+When receiving data across a communication link, we recommend always using
+the current input scan number for the output target scan number; if a
+higher-quality final pass is to be done, it should be started (aborting any
+incomplete output pass) as soon as the end of file is received.  However,
+many other strategies are possible.  For example, the application can examine
+the parameters of the current input scan and decide whether to display it or
+not.  If the scan contains only chroma data, one might choose not to use it
+as the target scan, expecting that the scan will be small and will arrive
+quickly.  To skip to the next scan, call jpeg_consume_input() until it
+returns JPEG_REACHED_SOS or JPEG_REACHED_EOI.  Or just use the next higher
+number as the target scan for jpeg_start_output(); but that method doesn't
+let you inspect the next scan's parameters before deciding to display it.
+
+
+In buffered-image mode, jpeg_start_decompress() never performs input and
+thus never suspends.  An application that uses input suspension with
+buffered-image mode must be prepared for suspension returns from these
+routines:
+* jpeg_start_output() performs input only if you request 2-pass quantization
+  and the target scan isn't fully read yet.  (This is discussed below.)
+* jpeg_read_scanlines(), as always, returns the number of scanlines that it
+  was able to produce before suspending.
+* jpeg_finish_output() will read any markers following the target scan,
+  up to the end of the file or the SOS marker that begins another scan.
+  (But it reads no input if jpeg_consume_input() has already reached the
+  end of the file or a SOS marker beyond the target output scan.)
+* jpeg_finish_decompress() will read until the end of file, and thus can
+  suspend if the end hasn't already been reached (as can be tested by
+  calling jpeg_input_complete()).
+jpeg_start_output(), jpeg_finish_output(), and jpeg_finish_decompress()
+all return TRUE if they completed their tasks, FALSE if they had to suspend.
+In the event of a FALSE return, the application must load more input data
+and repeat the call.  Applications that use non-suspending data sources need
+not check the return values of these three routines.
+
+
+It is possible to change decoding parameters between output passes in the
+buffered-image mode.  The decoder library currently supports only very
+limited changes of parameters.  ONLY THE FOLLOWING parameter changes are
+allowed after jpeg_start_decompress() is called:
+* dct_method can be changed before each call to jpeg_start_output().
+  For example, one could use a fast DCT method for early scans, changing
+  to a higher quality method for the final scan.
+* dither_mode can be changed before each call to jpeg_start_output();
+  of course this has no impact if not using color quantization.  Typically
+  one would use ordered dither for initial passes, then switch to
+  Floyd-Steinberg dither for the final pass.  Caution: changing dither mode
+  can cause more memory to be allocated by the library.  Although the amount
+  of memory involved is not large (a scanline or so), it may cause the
+  initial max_memory_to_use specification to be exceeded, which in the worst
+  case would result in an out-of-memory failure.
+* do_block_smoothing can be changed before each call to jpeg_start_output().
+  This setting is relevant only when decoding a progressive JPEG image.
+  During the first DC-only scan, block smoothing provides a very "fuzzy" look
+  instead of the very "blocky" look seen without it; which is better seems a
+  matter of personal taste.  But block smoothing is nearly always a win
+  during later stages, especially when decoding a successive-approximation
+  image: smoothing helps to hide the slight blockiness that otherwise shows
+  up on smooth gradients until the lowest coefficient bits are sent.
+* Color quantization mode can be changed under the rules described below.
+  You *cannot* change between full-color and quantized output (because that
+  would alter the required I/O buffer sizes), but you can change which
+  quantization method is used.
+
+When generating color-quantized output, changing quantization method is a
+very useful way of switching between high-speed and high-quality display.
+The library allows you to change among its three quantization methods:
+1. Single-pass quantization to a fixed color cube.
+   Selected by cinfo.two_pass_quantize = FALSE and cinfo.colormap = NULL.
+2. Single-pass quantization to an application-supplied colormap.
+   Selected by setting cinfo.colormap to point to the colormap (the value of
+   two_pass_quantize is ignored); also set cinfo.actual_number_of_colors.
+3. Two-pass quantization to a colormap chosen specifically for the image.
+   Selected by cinfo.two_pass_quantize = TRUE and cinfo.colormap = NULL.
+   (This is the default setting selected by jpeg_read_header, but it is
+   probably NOT what you want for the first pass of progressive display!)
+These methods offer successively better quality and lesser speed.  However,
+only the first method is available for quantizing in non-RGB color spaces.
+
+IMPORTANT: because the different quantizer methods have very different
+working-storage requirements, the library requires you to indicate which
+one(s) you intend to use before you call jpeg_start_decompress().  (If we did
+not require this, the max_memory_to_use setting would be a complete fiction.)
+You do this by setting one or more of these three cinfo fields to TRUE:
+        enable_1pass_quant              Fixed color cube colormap
+        enable_external_quant           Externally-supplied colormap
+        enable_2pass_quant              Two-pass custom colormap
+All three are initialized FALSE by jpeg_read_header().  But
+jpeg_start_decompress() automatically sets TRUE the one selected by the
+current two_pass_quantize and colormap settings, so you only need to set the
+enable flags for any other quantization methods you plan to change to later.
+
+After setting the enable flags correctly at jpeg_start_decompress() time, you
+can change to any enabled quantization method by setting two_pass_quantize
+and colormap properly just before calling jpeg_start_output().  The following
+special rules apply:
+1. You must explicitly set cinfo.colormap to NULL when switching to 1-pass
+   or 2-pass mode from a different mode, or when you want the 2-pass
+   quantizer to be re-run to generate a new colormap.
+2. To switch to an external colormap, or to change to a different external
+   colormap than was used on the prior pass, you must call
+   jpeg_new_colormap() after setting cinfo.colormap.
+NOTE: if you want to use the same colormap as was used in the prior pass,
+you should not do either of these things.  This will save some nontrivial
+switchover costs.
+(These requirements exist because cinfo.colormap will always be non-NULL
+after completing a prior output pass, since both the 1-pass and 2-pass
+quantizers set it to point to their output colormaps.  Thus you have to
+do one of these two things to notify the library that something has changed.
+Yup, it's a bit klugy, but it's necessary to do it this way for backwards
+compatibility.)
+
+Note that in buffered-image mode, the library generates any requested colormap
+during jpeg_start_output(), not during jpeg_start_decompress().
+
+When using two-pass quantization, jpeg_start_output() makes a pass over the
+buffered image to determine the optimum color map; it therefore may take a
+significant amount of time, whereas ordinarily it does little work.  The
+progress monitor hook is called during this pass, if defined.  It is also
+important to realize that if the specified target scan number is greater than
+or equal to the current input scan number, jpeg_start_output() will attempt
+to consume input as it makes this pass.  If you use a suspending data source,
+you need to check for a FALSE return from jpeg_start_output() under these
+conditions.  The combination of 2-pass quantization and a not-yet-fully-read
+target scan is the only case in which jpeg_start_output() will consume input.
+
+
+Application authors who support buffered-image mode may be tempted to use it
+for all JPEG images, even single-scan ones.  This will work, but it is
+inefficient: there is no need to create an image-sized coefficient buffer for
+single-scan images.  Requesting buffered-image mode for such an image wastes
+memory.  Worse, it can cost time on large images, since the buffered data has
+to be swapped out or written to a temporary file.  If you are concerned about
+maximum performance on baseline JPEG files, you should use buffered-image
+mode only when the incoming file actually has multiple scans.  This can be
+tested by calling jpeg_has_multiple_scans(), which will return a correct
+result at any time after jpeg_read_header() completes.
+
+It is also worth noting that when you use jpeg_consume_input() to let input
+processing get ahead of output processing, the resulting pattern of access to
+the coefficient buffer is quite nonsequential.  It's best to use the memory
+manager jmemnobs.c if you can (ie, if you have enough real or virtual main
+memory).  If not, at least make sure that max_memory_to_use is set as high as
+possible.  If the JPEG memory manager has to use a temporary file, you will
+probably see a lot of disk traffic and poor performance.  (This could be
+improved with additional work on the memory manager, but we haven't gotten
+around to it yet.)
+
+In some applications it may be convenient to use jpeg_consume_input() for all
+input processing, including reading the initial markers; that is, you may
+wish to call jpeg_consume_input() instead of jpeg_read_header() during
+startup.  This works, but note that you must check for JPEG_REACHED_SOS and
+JPEG_REACHED_EOI return codes as the equivalent of jpeg_read_header's codes.
+Once the first SOS marker has been reached, you must call
+jpeg_start_decompress() before jpeg_consume_input() will consume more input;
+it'll just keep returning JPEG_REACHED_SOS until you do.  If you read a
+tables-only file this way, jpeg_consume_input() will return JPEG_REACHED_EOI
+without ever returning JPEG_REACHED_SOS; be sure to check for this case.
+If this happens, the decompressor will not read any more input until you call
+jpeg_abort() to reset it.  It is OK to call jpeg_consume_input() even when not
+using buffered-image mode, but in that case it's basically a no-op after the
+initial markers have been read: it will just return JPEG_SUSPENDED.
+
+
+Abbreviated datastreams and multiple images
+-------------------------------------------
+
+A JPEG compression or decompression object can be reused to process multiple
+images.  This saves a small amount of time per image by eliminating the
+"create" and "destroy" operations, but that isn't the real purpose of the
+feature.  Rather, reuse of an object provides support for abbreviated JPEG
+datastreams.  Object reuse can also simplify processing a series of images in
+a single input or output file.  This section explains these features.
+
+A JPEG file normally contains several hundred bytes worth of quantization
+and Huffman tables.  In a situation where many images will be stored or
+transmitted with identical tables, this may represent an annoying overhead.
+The JPEG standard therefore permits tables to be omitted.  The standard
+defines three classes of JPEG datastreams:
+  * "Interchange" datastreams contain an image and all tables needed to decode
+     the image.  These are the usual kind of JPEG file.
+  * "Abbreviated image" datastreams contain an image, but are missing some or
+    all of the tables needed to decode that image.
+  * "Abbreviated table specification" (henceforth "tables-only") datastreams
+    contain only table specifications.
+To decode an abbreviated image, it is necessary to load the missing table(s)
+into the decoder beforehand.  This can be accomplished by reading a separate
+tables-only file.  A variant scheme uses a series of images in which the first
+image is an interchange (complete) datastream, while subsequent ones are
+abbreviated and rely on the tables loaded by the first image.  It is assumed
+that once the decoder has read a table, it will remember that table until a
+new definition for the same table number is encountered.
+
+It is the application designer's responsibility to figure out how to associate
+the correct tables with an abbreviated image.  While abbreviated datastreams
+can be useful in a closed environment, their use is strongly discouraged in
+any situation where data exchange with other applications might be needed.
+Caveat designer.
+
+The JPEG library provides support for reading and writing any combination of
+tables-only datastreams and abbreviated images.  In both compression and
+decompression objects, a quantization or Huffman table will be retained for
+the lifetime of the object, unless it is overwritten by a new table definition.
+
+
+To create abbreviated image datastreams, it is only necessary to tell the
+compressor not to emit some or all of the tables it is using.  Each
+quantization and Huffman table struct contains a boolean field "sent_table",
+which normally is initialized to FALSE.  For each table used by the image, the
+header-writing process emits the table and sets sent_table = TRUE unless it is
+already TRUE.  (In normal usage, this prevents outputting the same table
+definition multiple times, as would otherwise occur because the chroma
+components typically share tables.)  Thus, setting this field to TRUE before
+calling jpeg_start_compress() will prevent the table from being written at
+all.
+
+If you want to create a "pure" abbreviated image file containing no tables,
+just call "jpeg_suppress_tables(&cinfo, TRUE)" after constructing all the
+tables.  If you want to emit some but not all tables, you'll need to set the
+individual sent_table fields directly.
+
+To create an abbreviated image, you must also call jpeg_start_compress()
+with a second parameter of FALSE, not TRUE.  Otherwise jpeg_start_compress()
+will force all the sent_table fields to FALSE.  (This is a safety feature to
+prevent abbreviated images from being created accidentally.)
+
+To create a tables-only file, perform the same parameter setup that you
+normally would, but instead of calling jpeg_start_compress() and so on, call
+jpeg_write_tables(&cinfo).  This will write an abbreviated datastream
+containing only SOI, DQT and/or DHT markers, and EOI.  All the quantization
+and Huffman tables that are currently defined in the compression object will
+be emitted unless their sent_tables flag is already TRUE, and then all the
+sent_tables flags will be set TRUE.
+
+A sure-fire way to create matching tables-only and abbreviated image files
+is to proceed as follows:
+
+        create JPEG compression object
+        set JPEG parameters
+        set destination to tables-only file
+        jpeg_write_tables(&cinfo);
+        set destination to image file
+        jpeg_start_compress(&cinfo, FALSE);
+        write data...
+        jpeg_finish_compress(&cinfo);
+
+Since the JPEG parameters are not altered between writing the table file and
+the abbreviated image file, the same tables are sure to be used.  Of course,
+you can repeat the jpeg_start_compress() ... jpeg_finish_compress() sequence
+many times to produce many abbreviated image files matching the table file.
+
+You cannot suppress output of the computed Huffman tables when Huffman
+optimization is selected.  (If you could, there'd be no way to decode the
+image...)  Generally, you don't want to set optimize_coding = TRUE when
+you are trying to produce abbreviated files.
+
+In some cases you might want to compress an image using tables which are
+not stored in the application, but are defined in an interchange or
+tables-only file readable by the application.  This can be done by setting up
+a JPEG decompression object to read the specification file, then copying the
+tables into your compression object.  See jpeg_copy_critical_parameters()
+for an example of copying quantization tables.
+
+
+To read abbreviated image files, you simply need to load the proper tables
+into the decompression object before trying to read the abbreviated image.
+If the proper tables are stored in the application program, you can just
+allocate the table structs and fill in their contents directly.  For example,
+to load a fixed quantization table into table slot "n":
+
+    if (cinfo.quant_tbl_ptrs[n] == NULL)
+      cinfo.quant_tbl_ptrs[n] = jpeg_alloc_quant_table((j_common_ptr) &cinfo);
+    quant_ptr = cinfo.quant_tbl_ptrs[n];        /* quant_ptr is JQUANT_TBL* */
+    for (i = 0; i < 64; i++) {
+      /* Qtable[] is desired quantization table, in natural array order */
+      quant_ptr->quantval[i] = Qtable[i];
+    }
+
+Code to load a fixed Huffman table is typically (for AC table "n"):
+
+    if (cinfo.ac_huff_tbl_ptrs[n] == NULL)
+      cinfo.ac_huff_tbl_ptrs[n] = jpeg_alloc_huff_table((j_common_ptr) &cinfo);
+    huff_ptr = cinfo.ac_huff_tbl_ptrs[n];       /* huff_ptr is JHUFF_TBL* */
+    for (i = 1; i <= 16; i++) {
+      /* counts[i] is number of Huffman codes of length i bits, i=1..16 */
+      huff_ptr->bits[i] = counts[i];
+    }
+    for (i = 0; i < 256; i++) {
+      /* symbols[] is the list of Huffman symbols, in code-length order */
+      huff_ptr->huffval[i] = symbols[i];
+    }
+
+(Note that trying to set cinfo.quant_tbl_ptrs[n] to point directly at a
+constant JQUANT_TBL object is not safe.  If the incoming file happened to
+contain a quantization table definition, your master table would get
+overwritten!  Instead allocate a working table copy and copy the master table
+into it, as illustrated above.  Ditto for Huffman tables, of course.)
+
+You might want to read the tables from a tables-only file, rather than
+hard-wiring them into your application.  The jpeg_read_header() call is
+sufficient to read a tables-only file.  You must pass a second parameter of
+FALSE to indicate that you do not require an image to be present.  Thus, the
+typical scenario is
+
+        create JPEG decompression object
+        set source to tables-only file
+        jpeg_read_header(&cinfo, FALSE);
+        set source to abbreviated image file
+        jpeg_read_header(&cinfo, TRUE);
+        set decompression parameters
+        jpeg_start_decompress(&cinfo);
+        read data...
+        jpeg_finish_decompress(&cinfo);
+
+In some cases, you may want to read a file without knowing whether it contains
+an image or just tables.  In that case, pass FALSE and check the return value
+from jpeg_read_header(): it will be JPEG_HEADER_OK if an image was found,
+JPEG_HEADER_TABLES_ONLY if only tables were found.  (A third return value,
+JPEG_SUSPENDED, is possible when using a suspending data source manager.)
+Note that jpeg_read_header() will not complain if you read an abbreviated
+image for which you haven't loaded the missing tables; the missing-table check
+occurs later, in jpeg_start_decompress().
+
+
+It is possible to read a series of images from a single source file by
+repeating the jpeg_read_header() ... jpeg_finish_decompress() sequence,
+without releasing/recreating the JPEG object or the data source module.
+(If you did reinitialize, any partial bufferload left in the data source
+buffer at the end of one image would be discarded, causing you to lose the
+start of the next image.)  When you use this method, stored tables are
+automatically carried forward, so some of the images can be abbreviated images
+that depend on tables from earlier images.
+
+If you intend to write a series of images into a single destination file,
+you might want to make a specialized data destination module that doesn't
+flush the output buffer at term_destination() time.  This would speed things
+up by some trifling amount.  Of course, you'd need to remember to flush the
+buffer after the last image.  You can make the later images be abbreviated
+ones by passing FALSE to jpeg_start_compress().
+
+
+Special markers
+---------------
+
+Some applications may need to insert or extract special data in the JPEG
+datastream.  The JPEG standard provides marker types "COM" (comment) and
+"APP0" through "APP15" (application) to hold application-specific data.
+Unfortunately, the use of these markers is not specified by the standard.
+COM markers are fairly widely used to hold user-supplied text.  The JFIF file
+format spec uses APP0 markers with specified initial strings to hold certain
+data.  Adobe applications use APP14 markers beginning with the string "Adobe"
+for miscellaneous data.  Other APPn markers are rarely seen, but might
+contain almost anything.
+
+If you wish to store user-supplied text, we recommend you use COM markers
+and place readable 7-bit ASCII text in them.  Newline conventions are not
+standardized --- expect to find LF (Unix style), CR/LF (DOS style), or CR
+(Mac style).  A robust COM reader should be able to cope with random binary
+garbage, including nulls, since some applications generate COM markers
+containing non-ASCII junk.  (But yours should not be one of them.)
+
+For program-supplied data, use an APPn marker, and be sure to begin it with an
+identifying string so that you can tell whether the marker is actually yours.
+It's probably best to avoid using APP0 or APP14 for any private markers.
+(NOTE: the upcoming SPIFF standard will use APP8 markers; we recommend you
+not use APP8 markers for any private purposes, either.)
+
+Keep in mind that at most 65533 bytes can be put into one marker, but you
+can have as many markers as you like.
+
+By default, the IJG compression library will write a JFIF APP0 marker if the
+selected JPEG colorspace is grayscale or YCbCr, or an Adobe APP14 marker if
+the selected colorspace is RGB, CMYK, or YCCK.  You can disable this, but
+we don't recommend it.  The decompression library will recognize JFIF and
+Adobe markers and will set the JPEG colorspace properly when one is found.
+
+
+You can write special markers immediately following the datastream header by
+calling jpeg_write_marker() after jpeg_start_compress() and before the first
+call to jpeg_write_scanlines().  When you do this, the markers appear after
+the SOI and the JFIF APP0 and Adobe APP14 markers (if written), but before
+all else.  Specify the marker type parameter as "JPEG_COM" for COM or
+"JPEG_APP0 + n" for APPn.  (Actually, jpeg_write_marker will let you write
+any marker type, but we don't recommend writing any other kinds of marker.)
+For example, to write a user comment string pointed to by comment_text:
+        jpeg_write_marker(cinfo, JPEG_COM, comment_text, strlen(comment_text));
+
+If it's not convenient to store all the marker data in memory at once,
+you can instead call jpeg_write_m_header() followed by multiple calls to
+jpeg_write_m_byte().  If you do it this way, it's your responsibility to
+call jpeg_write_m_byte() exactly the number of times given in the length
+parameter to jpeg_write_m_header().  (This method lets you empty the
+output buffer partway through a marker, which might be important when
+using a suspending data destination module.  In any case, if you are using
+a suspending destination, you should flush its buffer after inserting
+any special markers.  See "I/O suspension".)
+
+Or, if you prefer to synthesize the marker byte sequence yourself,
+you can just cram it straight into the data destination module.
+
+If you are writing JFIF 1.02 extension markers (thumbnail images), don't
+forget to set cinfo.JFIF_minor_version = 2 so that the encoder will write the
+correct JFIF version number in the JFIF header marker.  The library's default
+is to write version 1.01, but that's wrong if you insert any 1.02 extension
+markers.  (We could probably get away with just defaulting to 1.02, but there
+used to be broken decoders that would complain about unknown minor version
+numbers.  To reduce compatibility risks it's safest not to write 1.02 unless
+you are actually using 1.02 extensions.)
+
+
+When reading, two methods of handling special markers are available:
+1. You can ask the library to save the contents of COM and/or APPn markers
+into memory, and then examine them at your leisure afterwards.
+2. You can supply your own routine to process COM and/or APPn markers
+on-the-fly as they are read.
+The first method is simpler to use, especially if you are using a suspending
+data source; writing a marker processor that copes with input suspension is
+not easy (consider what happens if the marker is longer than your available
+input buffer).  However, the second method conserves memory since the marker
+data need not be kept around after it's been processed.
+
+For either method, you'd normally set up marker handling after creating a
+decompression object and before calling jpeg_read_header(), because the
+markers of interest will typically be near the head of the file and so will
+be scanned by jpeg_read_header.  Once you've established a marker handling
+method, it will be used for the life of that decompression object
+(potentially many datastreams), unless you change it.  Marker handling is
+determined separately for COM markers and for each APPn marker code.
+
+
+To save the contents of special markers in memory, call
+        jpeg_save_markers(cinfo, marker_code, length_limit)
+where marker_code is the marker type to save, JPEG_COM or JPEG_APP0+n.
+(To arrange to save all the special marker types, you need to call this
+routine 17 times, for COM and APP0-APP15.)  If the incoming marker is longer
+than length_limit data bytes, only length_limit bytes will be saved; this
+parameter allows you to avoid chewing up memory when you only need to see the
+first few bytes of a potentially large marker.  If you want to save all the
+data, set length_limit to 0xFFFF; that is enough since marker lengths are only
+16 bits.  As a special case, setting length_limit to 0 prevents that marker
+type from being saved at all.  (That is the default behavior, in fact.)
+
+After jpeg_read_header() completes, you can examine the special markers by
+following the cinfo->marker_list pointer chain.  All the special markers in
+the file appear in this list, in order of their occurrence in the file (but
+omitting any markers of types you didn't ask for).  Both the original data
+length and the saved data length are recorded for each list entry; the latter
+will not exceed length_limit for the particular marker type.  Note that these
+lengths exclude the marker length word, whereas the stored representation
+within the JPEG file includes it.  (Hence the maximum data length is really
+only 65533.)
+
+It is possible that additional special markers appear in the file beyond the
+SOS marker at which jpeg_read_header stops; if so, the marker list will be
+extended during reading of the rest of the file.  This is not expected to be
+common, however.  If you are short on memory you may want to reset the length
+limit to zero for all marker types after finishing jpeg_read_header, to
+ensure that the max_memory_to_use setting cannot be exceeded due to addition
+of later markers.
+
+The marker list remains stored until you call jpeg_finish_decompress or
+jpeg_abort, at which point the memory is freed and the list is set to empty.
+(jpeg_destroy also releases the storage, of course.)
+
+Note that the library is internally interested in APP0 and APP14 markers;
+if you try to set a small nonzero length limit on these types, the library
+will silently force the length up to the minimum it wants.  (But you can set
+a zero length limit to prevent them from being saved at all.)  Also, in a
+16-bit environment, the maximum length limit may be constrained to less than
+65533 by malloc() limitations.  It is therefore best not to assume that the
+effective length limit is exactly what you set it to be.
+
+
+If you want to supply your own marker-reading routine, you do it by calling
+jpeg_set_marker_processor().  A marker processor routine must have the
+signature
+        boolean jpeg_marker_parser_method (j_decompress_ptr cinfo)
+Although the marker code is not explicitly passed, the routine can find it
+in cinfo->unread_marker.  At the time of call, the marker proper has been
+read from the data source module.  The processor routine is responsible for
+reading the marker length word and the remaining parameter bytes, if any.
+Return TRUE to indicate success.  (FALSE should be returned only if you are
+using a suspending data source and it tells you to suspend.  See the standard
+marker processors in jdmarker.c for appropriate coding methods if you need to
+use a suspending data source.)
+
+If you override the default APP0 or APP14 processors, it is up to you to
+recognize JFIF and Adobe markers if you want colorspace recognition to occur
+properly.  We recommend copying and extending the default processors if you
+want to do that.  (A better idea is to save these marker types for later
+examination by calling jpeg_save_markers(); that method doesn't interfere
+with the library's own processing of these markers.)
+
+jpeg_set_marker_processor() and jpeg_save_markers() are mutually exclusive
+--- if you call one it overrides any previous call to the other, for the
+particular marker type specified.
+
+A simple example of an external COM processor can be found in djpeg.c.
+Also, see jpegtran.c for an example of using jpeg_save_markers.
+
+
+ICC profiles
+------------
+
+Two functions are provided for writing and reading International Color
+Consortium (ICC) device profiles embedded in JFIF JPEG image files:
+
+        void jpeg_write_icc_profile (j_compress_ptr cinfo,
+                                     const JOCTET *icc_data_ptr,
+                                     unsigned int icc_data_len);
+        boolean jpeg_read_icc_profile (j_decompress_ptr cinfo,
+                                       JOCTET **icc_data_ptr,
+                                       unsigned int *icc_data_len);
+
+The ICC has defined a standard for including such data in JPEG "APP2" markers.
+The aforementioned functions do not know anything about the internal structure
+of the ICC profile data; they just know how to embed the profile data into a
+JPEG file while writing it, or to extract the profile data from a JPEG file
+while reading it.
+
+jpeg_write_icc_profile() must be called after calling jpeg_start_compress() and
+before the first call to jpeg_write_scanlines() or jpeg_write_raw_data().  This
+ordering ensures that the APP2 marker(s) will appear after the SOI and JFIF or
+Adobe markers, but before all other data.
+
+jpeg_read_icc_profile() returns TRUE if an ICC profile was found and FALSE
+otherwise.  If an ICC profile was found, then the function will allocate a
+memory region containing the profile and will return a pointer to that memory
+region in *icc_data_ptr, as well as the length of the region in *icc_data_len.
+This memory region is allocated by the library using malloc() and must be freed
+by the caller using free() when the memory region is no longer needed.  Callers
+wishing to use jpeg_read_icc_profile() must call
+
+        jpeg_save_markers(cinfo, JPEG_APP0 + 2, 0xFFFF);
+
+prior to calling jpeg_read_header().  jpeg_read_icc_profile() can be called at
+any point between jpeg_read_header() and jpeg_finish_decompress().
+
+
+Raw (downsampled) image data
+----------------------------
+
+Some applications need to supply already-downsampled image data to the JPEG
+compressor, or to receive raw downsampled data from the decompressor.  The
+library supports this requirement by allowing the application to write or
+read raw data, bypassing the normal preprocessing or postprocessing steps.
+The interface is different from the standard one and is somewhat harder to
+use.  If your interest is merely in bypassing color conversion, we recommend
+that you use the standard interface and simply set jpeg_color_space =
+in_color_space (or jpeg_color_space = out_color_space for decompression).
+The mechanism described in this section is necessary only to supply or
+receive downsampled image data, in which not all components have the same
+dimensions.
+
+
+To compress raw data, you must supply the data in the colorspace to be used
+in the JPEG file (please read the earlier section on Special color spaces)
+and downsampled to the sampling factors specified in the JPEG parameters.
+You must supply the data in the format used internally by the JPEG library,
+namely a JSAMPIMAGE array.  This is an array of pointers to two-dimensional
+arrays, each of type JSAMPARRAY.  Each 2-D array holds the values for one
+color component.  This structure is necessary since the components are of
+different sizes.  If the image dimensions are not a multiple of the MCU size,
+you must also pad the data correctly (usually, this is done by replicating
+the last column and/or row).  The data must be padded to a multiple of a DCT
+block in each component: that is, each downsampled row must contain a
+multiple of 8 valid samples, and there must be a multiple of 8 sample rows
+for each component.  (For applications such as conversion of digital TV
+images, the standard image size is usually a multiple of the DCT block size,
+so that no padding need actually be done.)
+
+The procedure for compression of raw data is basically the same as normal
+compression, except that you call jpeg_write_raw_data() in place of
+jpeg_write_scanlines().  Before calling jpeg_start_compress(), you must do
+the following:
+  * Set cinfo->raw_data_in to TRUE.  (It is set FALSE by jpeg_set_defaults().)
+    This notifies the library that you will be supplying raw data.
+  * Ensure jpeg_color_space is correct --- an explicit jpeg_set_colorspace()
+    call is a good idea.  Note that since color conversion is bypassed,
+    in_color_space is ignored, except that jpeg_set_defaults() uses it to
+    choose the default jpeg_color_space setting.
+  * Ensure the sampling factors, cinfo->comp_info[i].h_samp_factor and
+    cinfo->comp_info[i].v_samp_factor, are correct.  Since these indicate the
+    dimensions of the data you are supplying, it's wise to set them
+    explicitly, rather than assuming the library's defaults are what you want.
+
+To pass raw data to the library, call jpeg_write_raw_data() in place of
+jpeg_write_scanlines().  The two routines work similarly except that
+jpeg_write_raw_data takes a JSAMPIMAGE data array rather than JSAMPARRAY.
+The scanlines count passed to and returned from jpeg_write_raw_data is
+measured in terms of the component with the largest v_samp_factor.
+
+jpeg_write_raw_data() processes one MCU row per call, which is to say
+v_samp_factor*DCTSIZE sample rows of each component.  The passed num_lines
+value must be at least max_v_samp_factor*DCTSIZE, and the return value will
+be exactly that amount (or possibly some multiple of that amount, in future
+library versions).  This is true even on the last call at the bottom of the
+image; don't forget to pad your data as necessary.
+
+The required dimensions of the supplied data can be computed for each
+component as
+        cinfo->comp_info[i].width_in_blocks*DCTSIZE  samples per row
+        cinfo->comp_info[i].height_in_blocks*DCTSIZE rows in image
+after jpeg_start_compress() has initialized those fields.  If the valid data
+is smaller than this, it must be padded appropriately.  For some sampling
+factors and image sizes, additional dummy DCT blocks are inserted to make
+the image a multiple of the MCU dimensions.  The library creates such dummy
+blocks itself; it does not read them from your supplied data.  Therefore you
+need never pad by more than DCTSIZE samples.  An example may help here.
+Assume 2h2v downsampling of YCbCr data, that is
+        cinfo->comp_info[0].h_samp_factor = 2           for Y
+        cinfo->comp_info[0].v_samp_factor = 2
+        cinfo->comp_info[1].h_samp_factor = 1           for Cb
+        cinfo->comp_info[1].v_samp_factor = 1
+        cinfo->comp_info[2].h_samp_factor = 1           for Cr
+        cinfo->comp_info[2].v_samp_factor = 1
+and suppose that the nominal image dimensions (cinfo->image_width and
+cinfo->image_height) are 101x101 pixels.  Then jpeg_start_compress() will
+compute downsampled_width = 101 and width_in_blocks = 13 for Y,
+downsampled_width = 51 and width_in_blocks = 7 for Cb and Cr (and the same
+for the height fields).  You must pad the Y data to at least 13*8 = 104
+columns and rows, the Cb/Cr data to at least 7*8 = 56 columns and rows.  The
+MCU height is max_v_samp_factor = 2 DCT rows so you must pass at least 16
+scanlines on each call to jpeg_write_raw_data(), which is to say 16 actual
+sample rows of Y and 8 each of Cb and Cr.  A total of 7 MCU rows are needed,
+so you must pass a total of 7*16 = 112 "scanlines".  The last DCT block row
+of Y data is dummy, so it doesn't matter what you pass for it in the data
+arrays, but the scanlines count must total up to 112 so that all of the Cb
+and Cr data gets passed.
+
+Output suspension is supported with raw-data compression: if the data
+destination module suspends, jpeg_write_raw_data() will return 0.
+In this case the same data rows must be passed again on the next call.
+
+
+Decompression with raw data output implies bypassing all postprocessing:
+you cannot ask for rescaling or color quantization, for instance.  More
+seriously, you must deal with the color space and sampling factors present in
+the incoming file.  If your application only handles, say, 2h1v YCbCr data,
+you must check for and fail on other color spaces or other sampling factors.
+The library will not convert to a different color space for you.
+
+To obtain raw data output, set cinfo->raw_data_out = TRUE before
+jpeg_start_decompress() (it is set FALSE by jpeg_read_header()).  Be sure to
+verify that the color space and sampling factors are ones you can handle.
+Then call jpeg_read_raw_data() in place of jpeg_read_scanlines().  The
+decompression process is otherwise the same as usual.
+
+jpeg_read_raw_data() returns one MCU row per call, and thus you must pass a
+buffer of at least max_v_samp_factor*DCTSIZE scanlines (scanline counting is
+the same as for raw-data compression).  The buffer you pass must be large
+enough to hold the actual data plus padding to DCT-block boundaries.  As with
+compression, any entirely dummy DCT blocks are not processed so you need not
+allocate space for them, but the total scanline count includes them.  The
+above example of computing buffer dimensions for raw-data compression is
+equally valid for decompression.
+
+Input suspension is supported with raw-data decompression: if the data source
+module suspends, jpeg_read_raw_data() will return 0.  You can also use
+buffered-image mode to read raw data in multiple passes.
+
+
+Really raw data: DCT coefficients
+---------------------------------
+
+It is possible to read or write the contents of a JPEG file as raw DCT
+coefficients.  This facility is mainly intended for use in lossless
+transcoding between different JPEG file formats.  Other possible applications
+include lossless cropping of a JPEG image, lossless reassembly of a
+multi-strip or multi-tile TIFF/JPEG file into a single JPEG datastream, etc.
+
+To read the contents of a JPEG file as DCT coefficients, open the file and do
+jpeg_read_header() as usual.  But instead of calling jpeg_start_decompress()
+and jpeg_read_scanlines(), call jpeg_read_coefficients().  This will read the
+entire image into a set of virtual coefficient-block arrays, one array per
+component.  The return value is a pointer to an array of virtual-array
+descriptors.  Each virtual array can be accessed directly using the JPEG
+memory manager's access_virt_barray method (see Memory management, below,
+and also read structure.txt's discussion of virtual array handling).  Or,
+for simple transcoding to a different JPEG file format, the array list can
+just be handed directly to jpeg_write_coefficients().
+
+Each block in the block arrays contains quantized coefficient values in
+normal array order (not JPEG zigzag order).  The block arrays contain only
+DCT blocks containing real data; any entirely-dummy blocks added to fill out
+interleaved MCUs at the right or bottom edges of the image are discarded
+during reading and are not stored in the block arrays.  (The size of each
+block array can be determined from the width_in_blocks and height_in_blocks
+fields of the component's comp_info entry.)  This is also the data format
+expected by jpeg_write_coefficients().
+
+When you are done using the virtual arrays, call jpeg_finish_decompress()
+to release the array storage and return the decompression object to an idle
+state; or just call jpeg_destroy() if you don't need to reuse the object.
+
+If you use a suspending data source, jpeg_read_coefficients() will return
+NULL if it is forced to suspend; a non-NULL return value indicates successful
+completion.  You need not test for a NULL return value when using a
+non-suspending data source.
+
+It is also possible to call jpeg_read_coefficients() to obtain access to the
+decoder's coefficient arrays during a normal decode cycle in buffered-image
+mode.  This frammish might be useful for progressively displaying an incoming
+image and then re-encoding it without loss.  To do this, decode in buffered-
+image mode as discussed previously, then call jpeg_read_coefficients() after
+the last jpeg_finish_output() call.  The arrays will be available for your use
+until you call jpeg_finish_decompress().
+
+
+To write the contents of a JPEG file as DCT coefficients, you must provide
+the DCT coefficients stored in virtual block arrays.  You can either pass
+block arrays read from an input JPEG file by jpeg_read_coefficients(), or
+allocate virtual arrays from the JPEG compression object and fill them
+yourself.  In either case, jpeg_write_coefficients() is substituted for
+jpeg_start_compress() and jpeg_write_scanlines().  Thus the sequence is
+  * Create compression object
+  * Set all compression parameters as necessary
+  * Request virtual arrays if needed
+  * jpeg_write_coefficients()
+  * jpeg_finish_compress()
+  * Destroy or re-use compression object
+jpeg_write_coefficients() is passed a pointer to an array of virtual block
+array descriptors; the number of arrays is equal to cinfo.num_components.
+
+The virtual arrays need only have been requested, not realized, before
+jpeg_write_coefficients() is called.  A side-effect of
+jpeg_write_coefficients() is to realize any virtual arrays that have been
+requested from the compression object's memory manager.  Thus, when obtaining
+the virtual arrays from the compression object, you should fill the arrays
+after calling jpeg_write_coefficients().  The data is actually written out
+when you call jpeg_finish_compress(); jpeg_write_coefficients() only writes
+the file header.
+
+When writing raw DCT coefficients, it is crucial that the JPEG quantization
+tables and sampling factors match the way the data was encoded, or the
+resulting file will be invalid.  For transcoding from an existing JPEG file,
+we recommend using jpeg_copy_critical_parameters().  This routine initializes
+all the compression parameters to default values (like jpeg_set_defaults()),
+then copies the critical information from a source decompression object.
+The decompression object should have just been used to read the entire
+JPEG input file --- that is, it should be awaiting jpeg_finish_decompress().
+
+jpeg_write_coefficients() marks all tables stored in the compression object
+as needing to be written to the output file (thus, it acts like
+jpeg_start_compress(cinfo, TRUE)).  This is for safety's sake, to avoid
+emitting abbreviated JPEG files by accident.  If you really want to emit an
+abbreviated JPEG file, call jpeg_suppress_tables(), or set the tables'
+individual sent_table flags, between calling jpeg_write_coefficients() and
+jpeg_finish_compress().
+
+
+Progress monitoring
+-------------------
+
+Some applications may need to regain control from the JPEG library every so
+often.  The typical use of this feature is to produce a percent-done bar or
+other progress display.  (For a simple example, see cjpeg.c or djpeg.c.)
+Although you do get control back frequently during the data-transferring pass
+(the jpeg_read_scanlines or jpeg_write_scanlines loop), any additional passes
+will occur inside jpeg_finish_compress or jpeg_start_decompress; those
+routines may take a long time to execute, and you don't get control back
+until they are done.
+
+You can define a progress-monitor routine which will be called periodically
+by the library.  No guarantees are made about how often this call will occur,
+so we don't recommend you use it for mouse tracking or anything like that.
+At present, a call will occur once per MCU row, scanline, or sample row
+group, whichever unit is convenient for the current processing mode; so the
+wider the image, the longer the time between calls.  During the data
+transferring pass, only one call occurs per call of jpeg_read_scanlines or
+jpeg_write_scanlines, so don't pass a large number of scanlines at once if
+you want fine resolution in the progress count.  (If you really need to use
+the callback mechanism for time-critical tasks like mouse tracking, you could
+insert additional calls inside some of the library's inner loops.)
+
+To establish a progress-monitor callback, create a struct jpeg_progress_mgr,
+fill in its progress_monitor field with a pointer to your callback routine,
+and set cinfo->progress to point to the struct.  The callback will be called
+whenever cinfo->progress is non-NULL.  (This pointer is set to NULL by
+jpeg_create_compress or jpeg_create_decompress; the library will not change
+it thereafter.  So if you allocate dynamic storage for the progress struct,
+make sure it will live as long as the JPEG object does.  Allocating from the
+JPEG memory manager with lifetime JPOOL_PERMANENT will work nicely.)  You
+can use the same callback routine for both compression and decompression.
+
+The jpeg_progress_mgr struct contains four fields which are set by the library:
+        long pass_counter;      /* work units completed in this pass */
+        long pass_limit;        /* total number of work units in this pass */
+        int completed_passes;   /* passes completed so far */
+        int total_passes;       /* total number of passes expected */
+During any one pass, pass_counter increases from 0 up to (not including)
+pass_limit; the step size is usually but not necessarily 1.  The pass_limit
+value may change from one pass to another.  The expected total number of
+passes is in total_passes, and the number of passes already completed is in
+completed_passes.  Thus the fraction of work completed may be estimated as
+                completed_passes + (pass_counter/pass_limit)
+                --------------------------------------------
+                                total_passes
+ignoring the fact that the passes may not be equal amounts of work.
+
+When decompressing, pass_limit can even change within a pass, because it
+depends on the number of scans in the JPEG file, which isn't always known in
+advance.  The computed fraction-of-work-done may jump suddenly (if the library
+discovers it has overestimated the number of scans) or even decrease (in the
+opposite case).  It is not wise to put great faith in the work estimate.
+
+When using the decompressor's buffered-image mode, the progress monitor work
+estimate is likely to be completely unhelpful, because the library has no way
+to know how many output passes will be demanded of it.  Currently, the library
+sets total_passes based on the assumption that there will be one more output
+pass if the input file end hasn't yet been read (jpeg_input_complete() isn't
+TRUE), but no more output passes if the file end has been reached when the
+output pass is started.  This means that total_passes will rise as additional
+output passes are requested.  If you have a way of determining the input file
+size, estimating progress based on the fraction of the file that's been read
+will probably be more useful than using the library's value.
+
+
+Memory management
+-----------------
+
+This section covers some key facts about the JPEG library's built-in memory
+manager.  For more info, please read structure.txt's section about the memory
+manager, and consult the source code if necessary.
+
+All memory and temporary file allocation within the library is done via the
+memory manager.  If necessary, you can replace the "back end" of the memory
+manager to control allocation yourself (for example, if you don't want the
+library to use malloc() and free() for some reason).
+
+Some data is allocated "permanently" and will not be freed until the JPEG
+object is destroyed.  Most data is allocated "per image" and is freed by
+jpeg_finish_compress, jpeg_finish_decompress, or jpeg_abort.  You can call the
+memory manager yourself to allocate structures that will automatically be
+freed at these times.  Typical code for this is
+  ptr = (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE, size);
+Use JPOOL_PERMANENT to get storage that lasts as long as the JPEG object.
+Use alloc_large instead of alloc_small for anything bigger than a few Kbytes.
+There are also alloc_sarray and alloc_barray routines that automatically
+build 2-D sample or block arrays.
+
+The library's minimum space requirements to process an image depend on the
+image's width, but not on its height, because the library ordinarily works
+with "strip" buffers that are as wide as the image but just a few rows high.
+Some operating modes (eg, two-pass color quantization) require full-image
+buffers.  Such buffers are treated as "virtual arrays": only the current strip
+need be in memory, and the rest can be swapped out to a temporary file.
+
+When using temporary files, the library will make the in-memory buffers for
+its virtual arrays just big enough to stay within a "maximum memory" setting.
+Your application can set this limit by setting cinfo->mem->max_memory_to_use
+after creating the JPEG object.  (Of course, there is still a minimum size for
+the buffers, so the max-memory setting is effective only if it is bigger than
+the minimum space needed.)  If you allocate any large structures yourself, you
+must allocate them before jpeg_start_compress() or jpeg_start_decompress() in
+order to have them counted against the max memory limit.  Also keep in mind
+that space allocated with alloc_small() is ignored, on the assumption that
+it's too small to be worth worrying about; so a reasonable safety margin
+should be left when setting max_memory_to_use.
+
+NOTE: Unless you develop your own memory manager back end, then temporary files
+will never be used.  The back end provided in libjpeg-turbo (jmemnobs.c) simply
+malloc()s and free()s virtual arrays, and an error occurs if the required
+memory exceeds the limit specified in cinfo->mem->max_memory_to_use.
+
+
+Memory usage
+------------
+
+Working memory requirements while performing compression or decompression
+depend on image dimensions, image characteristics (such as colorspace and
+JPEG process), and operating mode (application-selected options).
+
+As of v6b, the decompressor requires:
+ 1. About 24K in more-or-less-fixed-size data.  This varies a bit depending
+    on operating mode and image characteristics (particularly color vs.
+    grayscale), but it doesn't depend on image dimensions.
+ 2. Strip buffers (of size proportional to the image width) for IDCT and
+    upsampling results.  The worst case for commonly used sampling factors
+    is about 34 bytes * width in pixels for a color image.  A grayscale image
+    only needs about 8 bytes per pixel column.
+ 3. A full-image DCT coefficient buffer is needed to decode a multi-scan JPEG
+    file (including progressive JPEGs), or whenever you select buffered-image
+    mode.  This takes 2 bytes/coefficient.  At typical 2x2 sampling, that's
+    3 bytes per pixel for a color image.  Worst case (1x1 sampling) requires
+    6 bytes/pixel.  For grayscale, figure 2 bytes/pixel.
+ 4. To perform 2-pass color quantization, the decompressor also needs a
+    128K color lookup table and a full-image pixel buffer (3 bytes/pixel).
+This does not count any memory allocated by the application, such as a
+buffer to hold the final output image.
+
+The above figures are valid for 8-bit JPEG data precision and a machine with
+32-bit ints.  For 12-bit JPEG data, double the size of the strip buffers and
+quantization pixel buffer.  The "fixed-size" data will be somewhat smaller
+with 16-bit ints, larger with 64-bit ints.  Also, CMYK or other unusual
+color spaces will require different amounts of space.
+
+The full-image coefficient and pixel buffers, if needed at all, do not
+have to be fully RAM resident; you can have the library use temporary
+files instead when the total memory usage would exceed a limit you set.
+(But if your OS supports virtual memory, it's probably better to just use
+jmemnobs and let the OS do the swapping.)
+
+The compressor's memory requirements are similar, except that it has no need
+for color quantization.  Also, it needs a full-image DCT coefficient buffer
+if Huffman-table optimization is asked for, even if progressive mode is not
+requested.
+
+If you need more detailed information about memory usage in a particular
+situation, you can enable the MEM_STATS code in jmemmgr.c.
+
+
+Library compile-time options
+----------------------------
+
+A number of compile-time options are available by modifying jmorecfg.h.
+
+The JPEG standard provides for both the baseline 8-bit DCT process and
+a 12-bit DCT process.  The IJG code supports 12-bit lossy JPEG if you define
+BITS_IN_JSAMPLE as 12 rather than 8.  Note that this causes JSAMPLE to be
+larger than a char, so it affects the surrounding application's image data.
+The sample applications cjpeg and djpeg can support 12-bit mode only for PPM
+and GIF file formats; you must disable the other file formats to compile a
+12-bit cjpeg or djpeg.  (install.txt has more information about that.)
+At present, a 12-bit library can handle *only* 12-bit images, not both
+precisions.
+
+Note that a 12-bit library always compresses in Huffman optimization mode,
+in order to generate valid Huffman tables.  This is necessary because our
+default Huffman tables only cover 8-bit data.  If you need to output 12-bit
+files in one pass, you'll have to supply suitable default Huffman tables.
+You may also want to supply your own DCT quantization tables; the existing
+quality-scaling code has been developed for 8-bit use, and probably doesn't
+generate especially good tables for 12-bit.
+
+The maximum number of components (color channels) in the image is determined
+by MAX_COMPONENTS.  The JPEG standard allows up to 255 components, but we
+expect that few applications will need more than four or so.
+
+On machines with unusual data type sizes, you may be able to improve
+performance or reduce memory space by tweaking the various typedefs in
+jmorecfg.h.  In particular, on some RISC CPUs, access to arrays of "short"s
+is quite slow; consider trading memory for speed by making JCOEF, INT16, and
+UINT16 be "int" or "unsigned int".  UINT8 is also a candidate to become int.
+You probably don't want to make JSAMPLE be int unless you have lots of memory
+to burn.
+
+You can reduce the size of the library by compiling out various optional
+functions.  To do this, undefine xxx_SUPPORTED symbols as necessary.
+
+You can also save a few K by not having text error messages in the library;
+the standard error message table occupies about 5Kb.  This is particularly
+reasonable for embedded applications where there's no good way to display
+a message anyway.  To do this, remove the creation of the message table
+(jpeg_std_message_table[]) from jerror.c, and alter format_message to do
+something reasonable without it.  You could output the numeric value of the
+message code number, for example.  If you do this, you can also save a couple
+more K by modifying the TRACEMSn() macros in jerror.h to expand to nothing;
+you don't need trace capability anyway, right?
+
+
+Portability considerations
+--------------------------
+
+The JPEG library has been written to be extremely portable; the sample
+applications cjpeg and djpeg are slightly less so.  This section summarizes
+the design goals in this area.  (If you encounter any bugs that cause the
+library to be less portable than is claimed here, we'd appreciate hearing
+about them.)
+
+The code works fine on ANSI C and C++ compilers, using any of the popular
+system include file setups, and some not-so-popular ones too.
+
+The code is not dependent on the exact sizes of the C data types.  As
+distributed, we make the assumptions that
+        char    is at least 8 bits wide
+        short   is at least 16 bits wide
+        int     is at least 16 bits wide
+        long    is at least 32 bits wide
+(These are the minimum requirements of the ANSI C standard.)  Wider types will
+work fine, although memory may be used inefficiently if char is much larger
+than 8 bits or short is much bigger than 16 bits.  The code should work
+equally well with 16- or 32-bit ints.
+
+In a system where these assumptions are not met, you may be able to make the
+code work by modifying the typedefs in jmorecfg.h.  However, you will probably
+have difficulty if int is less than 16 bits wide, since references to plain
+int abound in the code.
+
+char can be either signed or unsigned, although the code runs faster if an
+unsigned char type is available.  If char is wider than 8 bits, you will need
+to redefine JOCTET and/or provide custom data source/destination managers so
+that JOCTET represents exactly 8 bits of data on external storage.
+
+The JPEG library proper does not assume ASCII representation of characters.
+But some of the image file I/O modules in cjpeg/djpeg do have ASCII
+dependencies in file-header manipulation; so does cjpeg's select_file_type()
+routine.
+
+The JPEG library does not rely heavily on the C library.  In particular, C
+stdio is used only by the data source/destination modules and the error
+handler, all of which are application-replaceable.  (cjpeg/djpeg are more
+heavily dependent on stdio.)  malloc and free are called only from the memory
+manager "back end" module, so you can use a different memory allocator by
+replacing that one file.
+
+More info about porting the code may be gleaned by reading jconfig.txt,
+jmorecfg.h, and jinclude.h.
diff --git a/3rdparty/libjpeg/src/md5/CMakeLists.txt b/3rdparty/libjpeg/src/md5/CMakeLists.txt
new file mode 100644
index 00000000..3dd5c649
--- /dev/null
+++ b/3rdparty/libjpeg/src/md5/CMakeLists.txt
@@ -0,0 +1 @@
+#add_executable(md5cmp md5cmp.c md5.c md5hl.c)
diff --git a/3rdparty/libjpeg/src/md5/md5.c b/3rdparty/libjpeg/src/md5/md5.c
new file mode 100644
index 00000000..9ef5daaf
--- /dev/null
+++ b/3rdparty/libjpeg/src/md5/md5.c
@@ -0,0 +1,275 @@
+/*
+ * This code implements the MD5 message-digest algorithm.
+ * The algorithm is due to Ron Rivest.  This code was
+ * written by Colin Plumb in 1993, no copyright is claimed.
+ * This code is in the public domain; do with it what you wish.
+ *
+ * Equivalent code is available from RSA Data Security, Inc.
+ * This code has been tested against that, and is equivalent,
+ * except that you don't need to include two pages of legalese
+ * with every copy.
+ *
+ * To compute the message digest of a chunk of bytes, declare an
+ * MD5Context structure, pass it to MD5Init, call MD5Update as
+ * needed on buffers full of bytes, and then call MD5Final, which
+ * will fill a supplied 16-byte array with the digest.
+ * ----------------------------------------------------------------------------
+ * libjpeg-turbo Modifications:
+ * Copyright (C)2018, D. R. Commander.  All Rights Reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright notice,
+ *   this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright notice,
+ *   this list of conditions and the following disclaimer in the documentation
+ *   and/or other materials provided with the distribution.
+ * - Neither the name of the libjpeg-turbo Project nor the names of its
+ *   contributors may be used to endorse or promote products derived from this
+ *   software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE 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 HOLDERS 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 <string.h>             /* for memcpy() */
+#include "md5.h"
+
+#if (BYTE_ORDER == LITTLE_ENDIAN)
+#define byteReverse(buf, len)   /* Nothing */
+#else
+/*
+ * Note: this code is harmless on little-endian machines.
+ */
+static void byteReverse(unsigned char *buf, unsigned int longs)
+{
+  uint32 t;
+  do {
+    t = (uint32)((unsigned int)buf[3] << 8 | buf[2]) << 16 |
+        ((unsigned int)buf[1] << 8 | buf[0]);
+    *(uint32 *)buf = t;
+    buf += 4;
+  } while (--longs);
+}
+#endif
+
+/*
+ * Start MD5 accumulation.  Set bit count to 0 and buffer to mysterious
+ * initialization constants.
+ */
+void MD5Init(struct MD5Context *ctx)
+{
+  ctx->buf[0] = 0x67452301;
+  ctx->buf[1] = 0xefcdab89;
+  ctx->buf[2] = 0x98badcfe;
+  ctx->buf[3] = 0x10325476;
+
+  ctx->bits[0] = 0;
+  ctx->bits[1] = 0;
+}
+
+/*
+ * Update context to reflect the concatenation of another buffer full
+ * of bytes.
+ */
+void MD5Update(struct MD5Context *ctx, unsigned char *buf, unsigned int len)
+{
+  uint32 t;
+
+  /* Update bitcount */
+
+  t = ctx->bits[0];
+  if ((ctx->bits[0] = t + ((uint32)len << 3)) < t)
+    ctx->bits[1]++;             /* Carry from low to high */
+  ctx->bits[1] += len >> 29;
+
+  t = (t >> 3) & 0x3f;          /* Bytes already in shsInfo->data */
+
+  /* Handle any leading odd-sized chunks */
+
+  if (t) {
+    unsigned char *p = (unsigned char *)ctx->in + t;
+
+    t = 64 - t;
+    if (len < t) {
+      memcpy(p, buf, len);
+      return;
+    }
+    memcpy(p, buf, t);
+    byteReverse(ctx->in, 16);
+    MD5Transform(ctx->buf, (uint32 *)ctx->in);
+    buf += t;
+    len -= t;
+  }
+  /* Process data in 64-byte chunks */
+
+  while (len >= 64) {
+    memcpy(ctx->in, buf, 64);
+    byteReverse(ctx->in, 16);
+    MD5Transform(ctx->buf, (uint32 *)ctx->in);
+    buf += 64;
+    len -= 64;
+  }
+
+  /* Handle any remaining bytes of data. */
+
+  memcpy(ctx->in, buf, len);
+}
+
+/*
+ * Final wrapup - pad to 64-byte boundary with the bit pattern
+ * 1 0* (64-bit count of bits processed, MSB-first)
+ */
+void MD5Final(unsigned char digest[16], struct MD5Context *ctx)
+{
+  unsigned int count;
+  unsigned char *p;
+  uint32 *in32 = (uint32 *)ctx->in;
+
+  /* Compute number of bytes mod 64 */
+  count = (ctx->bits[0] >> 3) & 0x3F;
+
+  /* Set the first char of padding to 0x80.  This is safe since there is
+     always at least one byte free */
+  p = ctx->in + count;
+  *p++ = 0x80;
+
+  /* Bytes of padding needed to make 64 bytes */
+  count = 64 - 1 - count;
+
+  /* Pad out to 56 mod 64 */
+  if (count < 8) {
+    /* Two lots of padding:  Pad the first block to 64 bytes */
+    memset(p, 0, count);
+    byteReverse(ctx->in, 16);
+    MD5Transform(ctx->buf, (uint32 *)ctx->in);
+
+    /* Now fill the next block with 56 bytes */
+    memset(ctx->in, 0, 56);
+  } else {
+    /* Pad block to 56 bytes */
+    memset(p, 0, count - 8);
+  }
+  byteReverse(ctx->in, 14);
+
+  /* Append length in bits and transform */
+  in32[14] = ctx->bits[0];
+  in32[15] = ctx->bits[1];
+
+  MD5Transform(ctx->buf, (uint32 *)ctx->in);
+  byteReverse((unsigned char *)ctx->buf, 4);
+  memcpy(digest, ctx->buf, 16);
+  memset(ctx, 0, sizeof(struct MD5Context));     /* In case it's sensitive */
+}
+
+
+/* The four core functions - F1 is optimized somewhat */
+
+/* #define F1(x, y, z) (x & y | ~x & z) */
+#define F1(x, y, z)  (z ^ (x & (y ^ z)))
+#define F2(x, y, z)  F1(z, x, y)
+#define F3(x, y, z)  (x ^ y ^ z)
+#define F4(x, y, z)  (y ^ (x | ~z))
+
+/* This is the central step in the MD5 algorithm. */
+#define MD5STEP(f, w, x, y, z, data, s) \
+  ( w += f(x, y, z) + data,  w = w << s | w >> (32 - s),  w += x )
+
+/*
+ * The core of the MD5 algorithm, this alters an existing MD5 hash to
+ * reflect the addition of 16 longwords of new data.  MD5Update blocks
+ * the data and converts bytes into longwords for this routine.
+ */
+void MD5Transform(uint32 buf[4], uint32 in[16])
+{
+  register uint32 a, b, c, d;
+
+  a = buf[0];
+  b = buf[1];
+  c = buf[2];
+  d = buf[3];
+
+  MD5STEP(F1, a, b, c, d, in[0] + 0xd76aa478, 7);
+  MD5STEP(F1, d, a, b, c, in[1] + 0xe8c7b756, 12);
+  MD5STEP(F1, c, d, a, b, in[2] + 0x242070db, 17);
+  MD5STEP(F1, b, c, d, a, in[3] + 0xc1bdceee, 22);
+  MD5STEP(F1, a, b, c, d, in[4] + 0xf57c0faf, 7);
+  MD5STEP(F1, d, a, b, c, in[5] + 0x4787c62a, 12);
+  MD5STEP(F1, c, d, a, b, in[6] + 0xa8304613, 17);
+  MD5STEP(F1, b, c, d, a, in[7] + 0xfd469501, 22);
+  MD5STEP(F1, a, b, c, d, in[8] + 0x698098d8, 7);
+  MD5STEP(F1, d, a, b, c, in[9] + 0x8b44f7af, 12);
+  MD5STEP(F1, c, d, a, b, in[10] + 0xffff5bb1, 17);
+  MD5STEP(F1, b, c, d, a, in[11] + 0x895cd7be, 22);
+  MD5STEP(F1, a, b, c, d, in[12] + 0x6b901122, 7);
+  MD5STEP(F1, d, a, b, c, in[13] + 0xfd987193, 12);
+  MD5STEP(F1, c, d, a, b, in[14] + 0xa679438e, 17);
+  MD5STEP(F1, b, c, d, a, in[15] + 0x49b40821, 22);
+
+  MD5STEP(F2, a, b, c, d, in[1] + 0xf61e2562, 5);
+  MD5STEP(F2, d, a, b, c, in[6] + 0xc040b340, 9);
+  MD5STEP(F2, c, d, a, b, in[11] + 0x265e5a51, 14);
+  MD5STEP(F2, b, c, d, a, in[0] + 0xe9b6c7aa, 20);
+  MD5STEP(F2, a, b, c, d, in[5] + 0xd62f105d, 5);
+  MD5STEP(F2, d, a, b, c, in[10] + 0x02441453, 9);
+  MD5STEP(F2, c, d, a, b, in[15] + 0xd8a1e681, 14);
+  MD5STEP(F2, b, c, d, a, in[4] + 0xe7d3fbc8, 20);
+  MD5STEP(F2, a, b, c, d, in[9] + 0x21e1cde6, 5);
+  MD5STEP(F2, d, a, b, c, in[14] + 0xc33707d6, 9);
+  MD5STEP(F2, c, d, a, b, in[3] + 0xf4d50d87, 14);
+  MD5STEP(F2, b, c, d, a, in[8] + 0x455a14ed, 20);
+  MD5STEP(F2, a, b, c, d, in[13] + 0xa9e3e905, 5);
+  MD5STEP(F2, d, a, b, c, in[2] + 0xfcefa3f8, 9);
+  MD5STEP(F2, c, d, a, b, in[7] + 0x676f02d9, 14);
+  MD5STEP(F2, b, c, d, a, in[12] + 0x8d2a4c8a, 20);
+
+  MD5STEP(F3, a, b, c, d, in[5] + 0xfffa3942, 4);
+  MD5STEP(F3, d, a, b, c, in[8] + 0x8771f681, 11);
+  MD5STEP(F3, c, d, a, b, in[11] + 0x6d9d6122, 16);
+  MD5STEP(F3, b, c, d, a, in[14] + 0xfde5380c, 23);
+  MD5STEP(F3, a, b, c, d, in[1] + 0xa4beea44, 4);
+  MD5STEP(F3, d, a, b, c, in[4] + 0x4bdecfa9, 11);
+  MD5STEP(F3, c, d, a, b, in[7] + 0xf6bb4b60, 16);
+  MD5STEP(F3, b, c, d, a, in[10] + 0xbebfbc70, 23);
+  MD5STEP(F3, a, b, c, d, in[13] + 0x289b7ec6, 4);
+  MD5STEP(F3, d, a, b, c, in[0] + 0xeaa127fa, 11);
+  MD5STEP(F3, c, d, a, b, in[3] + 0xd4ef3085, 16);
+  MD5STEP(F3, b, c, d, a, in[6] + 0x04881d05, 23);
+  MD5STEP(F3, a, b, c, d, in[9] + 0xd9d4d039, 4);
+  MD5STEP(F3, d, a, b, c, in[12] + 0xe6db99e5, 11);
+  MD5STEP(F3, c, d, a, b, in[15] + 0x1fa27cf8, 16);
+  MD5STEP(F3, b, c, d, a, in[2] + 0xc4ac5665, 23);
+
+  MD5STEP(F4, a, b, c, d, in[0] + 0xf4292244, 6);
+  MD5STEP(F4, d, a, b, c, in[7] + 0x432aff97, 10);
+  MD5STEP(F4, c, d, a, b, in[14] + 0xab9423a7, 15);
+  MD5STEP(F4, b, c, d, a, in[5] + 0xfc93a039, 21);
+  MD5STEP(F4, a, b, c, d, in[12] + 0x655b59c3, 6);
+  MD5STEP(F4, d, a, b, c, in[3] + 0x8f0ccc92, 10);
+  MD5STEP(F4, c, d, a, b, in[10] + 0xffeff47d, 15);
+  MD5STEP(F4, b, c, d, a, in[1] + 0x85845dd1, 21);
+  MD5STEP(F4, a, b, c, d, in[8] + 0x6fa87e4f, 6);
+  MD5STEP(F4, d, a, b, c, in[15] + 0xfe2ce6e0, 10);
+  MD5STEP(F4, c, d, a, b, in[6] + 0xa3014314, 15);
+  MD5STEP(F4, b, c, d, a, in[13] + 0x4e0811a1, 21);
+  MD5STEP(F4, a, b, c, d, in[4] + 0xf7537e82, 6);
+  MD5STEP(F4, d, a, b, c, in[11] + 0xbd3af235, 10);
+  MD5STEP(F4, c, d, a, b, in[2] + 0x2ad7d2bb, 15);
+  MD5STEP(F4, b, c, d, a, in[9] + 0xeb86d391, 21);
+
+  buf[0] += a;
+  buf[1] += b;
+  buf[2] += c;
+  buf[3] += d;
+}
diff --git a/3rdparty/libjpeg/src/md5/md5.h b/3rdparty/libjpeg/src/md5/md5.h
new file mode 100644
index 00000000..6d745e9c
--- /dev/null
+++ b/3rdparty/libjpeg/src/md5/md5.h
@@ -0,0 +1,57 @@
+/*
+ * libjpeg-turbo Modifications:
+ * Copyright (C)2018 D. R. Commander.  All Rights Reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright notice,
+ *   this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright notice,
+ *   this list of conditions and the following disclaimer in the documentation
+ *   and/or other materials provided with the distribution.
+ * - Neither the name of the libjpeg-turbo Project nor the names of its
+ *   contributors may be used to endorse or promote products derived from this
+ *   software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE 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 HOLDERS 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.
+ */
+
+#ifndef MD5_H
+#define MD5_H
+
+#include <sys/types.h>
+#ifdef __amigaos4__
+#include <machine/endian.h>
+#endif
+
+/*  On machines where "long" is 64 bits, we need to declare
+    uint32 as something guaranteed to be 32 bits.  */
+
+typedef unsigned int uint32;
+
+typedef struct MD5Context {
+  uint32 buf[4];
+  uint32 bits[2];
+  unsigned char in[64];
+} MD5_CTX;
+
+extern void MD5Init(struct MD5Context *ctx);
+extern void MD5Update(struct MD5Context *ctx, unsigned char *buf,
+                      unsigned int len);
+extern void MD5Final(unsigned char digest[16], struct MD5Context *ctx);
+extern void MD5Transform(uint32 buf[4], uint32 in[16]);
+extern char *MD5File(const char *, char *);
+extern char *MD5FileChunk(const char *, char *, off_t, off_t);
+
+#endif /* !MD5_H */
diff --git a/3rdparty/libjpeg/src/md5/md5cmp.c b/3rdparty/libjpeg/src/md5/md5cmp.c
new file mode 100644
index 00000000..42b94ce2
--- /dev/null
+++ b/3rdparty/libjpeg/src/md5/md5cmp.c
@@ -0,0 +1,59 @@
+/*
+ * Copyright (C)2013, 2016 D. R. Commander.  All Rights Reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright notice,
+ *   this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright notice,
+ *   this list of conditions and the following disclaimer in the documentation
+ *   and/or other materials provided with the distribution.
+ * - Neither the name of the libjpeg-turbo Project nor the names of its
+ *   contributors may be used to endorse or promote products derived from this
+ *   software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE 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 HOLDERS 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 <stdio.h>
+#include <string.h>
+#include "./md5.h"
+#include "../tjutil.h"
+
+int main(int argc, char *argv[])
+{
+  char *md5sum = NULL, buf[65];
+
+  if (argc < 3) {
+    fprintf(stderr, "USAGE: %s <correct MD5 sum> <file>\n", argv[0]);
+    return -1;
+  }
+
+  if (strlen(argv[1]) != 32)
+    fprintf(stderr, "WARNING: MD5 hash size is wrong.\n");
+
+  md5sum = MD5File(argv[2], buf);
+  if (!md5sum) {
+    perror("Could not obtain MD5 sum");
+    return -1;
+  }
+
+  if (!strcasecmp(md5sum, argv[1])) {
+    fprintf(stderr, "%s: OK\n", argv[2]);
+    return 0;
+  } else {
+    fprintf(stderr, "%s: FAILED.  Checksum is %s\n", argv[2], md5sum);
+    return -1;
+  }
+}
diff --git a/3rdparty/libjpeg/src/md5/md5hl.c b/3rdparty/libjpeg/src/md5/md5hl.c
new file mode 100644
index 00000000..8a4a762f
--- /dev/null
+++ b/3rdparty/libjpeg/src/md5/md5hl.c
@@ -0,0 +1,125 @@
+/* mdXhl.c
+ * ----------------------------------------------------------------------------
+ * "THE BEER-WARE LICENSE" (Revision 42):
+ * <phk@FreeBSD.org> wrote this file.  As long as you retain this notice you
+ * can do whatever you want with this stuff. If we meet some day, and you think
+ * this stuff is worth it, you can buy me a beer in return.   Poul-Henning Kamp
+ * ----------------------------------------------------------------------------
+ * libjpeg-turbo Modifications:
+ * Copyright (C)2016, 2018-2019 D. R. Commander.  All Rights Reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright notice,
+ *   this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright notice,
+ *   this list of conditions and the following disclaimer in the documentation
+ *   and/or other materials provided with the distribution.
+ * - Neither the name of the libjpeg-turbo Project nor the names of its
+ *   contributors may be used to endorse or promote products derived from this
+ *   software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE 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 HOLDERS 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 <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#ifdef _WIN32
+#include <io.h>
+#define close  _close
+#define fstat  _fstat
+#define lseek  _lseek
+#define read  _read
+#define stat  _stat
+#else
+#include <unistd.h>
+#endif
+
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#define LENGTH  16
+
+#include "./md5.h"
+
+static char *MD5End(MD5_CTX *ctx, char *buf)
+{
+  int i;
+  unsigned char digest[LENGTH];
+  static const char hex[] = "0123456789abcdef";
+
+  if (!buf)
+    buf = malloc(2 * LENGTH + 1);
+  if (!buf)
+    return 0;
+  MD5Final(digest, ctx);
+  for (i = 0; i < LENGTH; i++) {
+    buf[i + i] = hex[digest[i] >> 4];
+    buf[i + i + 1] = hex[digest[i] & 0x0f];
+  }
+  buf[i + i] = '\0';
+  return buf;
+}
+
+char *MD5File(const char *filename, char *buf)
+{
+  return (MD5FileChunk(filename, buf, 0, 0));
+}
+
+char *MD5FileChunk(const char *filename, char *buf, off_t ofs, off_t len)
+{
+  unsigned char buffer[BUFSIZ];
+  MD5_CTX ctx;
+  struct stat stbuf;
+  int f, i, e;
+  off_t n;
+
+  MD5Init(&ctx);
+#ifdef _WIN32
+  f = _open(filename, O_RDONLY | O_BINARY);
+#else
+  f = open(filename, O_RDONLY);
+#endif
+  if (f < 0)
+    return 0;
+  if (fstat(f, &stbuf) < 0)
+    return 0;
+  if (ofs > stbuf.st_size)
+    ofs = stbuf.st_size;
+  if ((len == 0) || (len > stbuf.st_size - ofs))
+    len = stbuf.st_size - ofs;
+  if (lseek(f, ofs, SEEK_SET) < 0)
+    return 0;
+  n = len;
+  i = 0;
+  while (n > 0) {
+    if (n > sizeof(buffer))
+      i = read(f, buffer, sizeof(buffer));
+    else
+      i = read(f, buffer, n);
+    if (i < 0)
+      break;
+    MD5Update(&ctx, buffer, i);
+    n -= i;
+  }
+  e = errno;
+  close(f);
+  errno = e;
+  if (i < 0)
+    return 0;
+  return (MD5End(&ctx, buf));
+}
diff --git a/3rdparty/libjpeg/src/rdbmp.c b/3rdparty/libjpeg/src/rdbmp.c
new file mode 100644
index 00000000..6ba584af
--- /dev/null
+++ b/3rdparty/libjpeg/src/rdbmp.c
@@ -0,0 +1,677 @@
+/*
+ * rdbmp.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1994-1996, Thomas G. Lane.
+ * Modified 2009-2017 by Guido Vollbeding.
+ * libjpeg-turbo Modifications:
+ * Modified 2011 by Siarhei Siamashka.
+ * Copyright (C) 2015, 2017-2018, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains routines to read input images in Microsoft "BMP"
+ * format (MS Windows 3.x, OS/2 1.x, and OS/2 2.x flavors).
+ * Currently, only 8-, 24-, and 32-bit images are supported, not 1-bit or
+ * 4-bit (feeding such low-depth images into JPEG would be silly anyway).
+ * Also, we don't support RLE-compressed files.
+ *
+ * These routines may need modification for non-Unix environments or
+ * specialized applications.  As they stand, they assume input from
+ * an ordinary stdio stream.  They further assume that reading begins
+ * at the start of the file; start_input may need work if the
+ * user interface has already read some data (e.g., to determine that
+ * the file is indeed BMP format).
+ *
+ * This code contributed by James Arthur Boucher.
+ */
+
+#include "cmyk.h"
+#include "cdjpeg.h"             /* Common decls for cjpeg/djpeg applications */
+
+#ifdef BMP_SUPPORTED
+
+
+/* Macros to deal with unsigned chars as efficiently as compiler allows */
+
+typedef unsigned char U_CHAR;
+#define UCH(x)  ((int)(x))
+
+
+#define ReadOK(file, buffer, len) \
+  (JFREAD(file, buffer, len) == ((size_t)(len)))
+
+static int alpha_index[JPEG_NUMCS] = {
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 3, 3, 0, 0, -1
+};
+
+
+/* Private version of data source object */
+
+typedef struct _bmp_source_struct *bmp_source_ptr;
+
+typedef struct _bmp_source_struct {
+  struct cjpeg_source_struct pub; /* public fields */
+
+  j_compress_ptr cinfo;         /* back link saves passing separate parm */
+
+  JSAMPARRAY colormap;          /* BMP colormap (converted to my format) */
+
+  jvirt_sarray_ptr whole_image; /* Needed to reverse row order */
+  JDIMENSION source_row;        /* Current source row number */
+  JDIMENSION row_width;         /* Physical width of scanlines in file */
+
+  int bits_per_pixel;           /* remembers 8-, 24-, or 32-bit format */
+  int cmap_length;              /* colormap length */
+
+  boolean use_inversion_array;  /* TRUE = preload the whole image, which is
+                                   stored in bottom-up order, and feed it to
+                                   the calling program in top-down order
+
+                                   FALSE = the calling program will maintain
+                                   its own image buffer and read the rows in
+                                   bottom-up order */
+
+  U_CHAR *iobuffer;             /* I/O buffer (used to buffer a single row from
+                                   disk if use_inversion_array == FALSE) */
+} bmp_source_struct;
+
+
+LOCAL(int)
+read_byte(bmp_source_ptr sinfo)
+/* Read next byte from BMP file */
+{
+  register FILE *infile = sinfo->pub.input_file;
+  register int c;
+
+  if ((c = getc(infile)) == EOF)
+    ERREXIT(sinfo->cinfo, JERR_INPUT_EOF);
+  return c;
+}
+
+
+LOCAL(void)
+read_colormap(bmp_source_ptr sinfo, int cmaplen, int mapentrysize)
+/* Read the colormap from a BMP file */
+{
+  int i, gray = 1;
+
+  switch (mapentrysize) {
+  case 3:
+    /* BGR format (occurs in OS/2 files) */
+    for (i = 0; i < cmaplen; i++) {
+      sinfo->colormap[2][i] = (JSAMPLE)read_byte(sinfo);
+      sinfo->colormap[1][i] = (JSAMPLE)read_byte(sinfo);
+      sinfo->colormap[0][i] = (JSAMPLE)read_byte(sinfo);
+      if (sinfo->colormap[2][i] != sinfo->colormap[1][i] ||
+          sinfo->colormap[1][i] != sinfo->colormap[0][i])
+        gray = 0;
+    }
+    break;
+  case 4:
+    /* BGR0 format (occurs in MS Windows files) */
+    for (i = 0; i < cmaplen; i++) {
+      sinfo->colormap[2][i] = (JSAMPLE)read_byte(sinfo);
+      sinfo->colormap[1][i] = (JSAMPLE)read_byte(sinfo);
+      sinfo->colormap[0][i] = (JSAMPLE)read_byte(sinfo);
+      (void)read_byte(sinfo);
+      if (sinfo->colormap[2][i] != sinfo->colormap[1][i] ||
+          sinfo->colormap[1][i] != sinfo->colormap[0][i])
+        gray = 0;
+    }
+    break;
+  default:
+    ERREXIT(sinfo->cinfo, JERR_BMP_BADCMAP);
+    break;
+  }
+
+  if (sinfo->cinfo->in_color_space == JCS_UNKNOWN && gray)
+    sinfo->cinfo->in_color_space = JCS_GRAYSCALE;
+
+  if (sinfo->cinfo->in_color_space == JCS_GRAYSCALE && !gray)
+    ERREXIT(sinfo->cinfo, JERR_BAD_IN_COLORSPACE);
+}
+
+
+/*
+ * Read one row of pixels.
+ * The image has been read into the whole_image array, but is otherwise
+ * unprocessed.  We must read it out in top-to-bottom row order, and if
+ * it is an 8-bit image, we must expand colormapped pixels to 24bit format.
+ */
+
+METHODDEF(JDIMENSION)
+get_8bit_row(j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
+/* This version is for reading 8-bit colormap indexes */
+{
+  bmp_source_ptr source = (bmp_source_ptr)sinfo;
+  register JSAMPARRAY colormap = source->colormap;
+  int cmaplen = source->cmap_length;
+  JSAMPARRAY image_ptr;
+  register int t;
+  register JSAMPROW inptr, outptr;
+  register JDIMENSION col;
+
+  if (source->use_inversion_array) {
+    /* Fetch next row from virtual array */
+    source->source_row--;
+    image_ptr = (*cinfo->mem->access_virt_sarray)
+      ((j_common_ptr)cinfo, source->whole_image,
+       source->source_row, (JDIMENSION)1, FALSE);
+    inptr = image_ptr[0];
+  } else {
+    if (!ReadOK(source->pub.input_file, source->iobuffer, source->row_width))
+      ERREXIT(cinfo, JERR_INPUT_EOF);
+    inptr = source->iobuffer;
+  }
+
+  /* Expand the colormap indexes to real data */
+  outptr = source->pub.buffer[0];
+  if (cinfo->in_color_space == JCS_GRAYSCALE) {
+    for (col = cinfo->image_width; col > 0; col--) {
+      t = *inptr++;
+      if (t >= cmaplen)
+        ERREXIT(cinfo, JERR_BMP_OUTOFRANGE);
+      *outptr++ = colormap[0][t];
+    }
+  } else if (cinfo->in_color_space == JCS_CMYK) {
+    for (col = cinfo->image_width; col > 0; col--) {
+      t = *inptr++;
+      if (t >= cmaplen)
+        ERREXIT(cinfo, JERR_BMP_OUTOFRANGE);
+      rgb_to_cmyk(colormap[0][t], colormap[1][t], colormap[2][t], outptr,
+                  outptr + 1, outptr + 2, outptr + 3);
+      outptr += 4;
+    }
+  } else {
+    register int rindex = rgb_red[cinfo->in_color_space];
+    register int gindex = rgb_green[cinfo->in_color_space];
+    register int bindex = rgb_blue[cinfo->in_color_space];
+    register int aindex = alpha_index[cinfo->in_color_space];
+    register int ps = rgb_pixelsize[cinfo->in_color_space];
+
+    if (aindex >= 0) {
+      for (col = cinfo->image_width; col > 0; col--) {
+        t = *inptr++;
+        if (t >= cmaplen)
+          ERREXIT(cinfo, JERR_BMP_OUTOFRANGE);
+        outptr[rindex] = colormap[0][t];
+        outptr[gindex] = colormap[1][t];
+        outptr[bindex] = colormap[2][t];
+        outptr[aindex] = 0xFF;
+        outptr += ps;
+      }
+    } else {
+      for (col = cinfo->image_width; col > 0; col--) {
+        t = *inptr++;
+        if (t >= cmaplen)
+          ERREXIT(cinfo, JERR_BMP_OUTOFRANGE);
+        outptr[rindex] = colormap[0][t];
+        outptr[gindex] = colormap[1][t];
+        outptr[bindex] = colormap[2][t];
+        outptr += ps;
+      }
+    }
+  }
+
+  return 1;
+}
+
+
+METHODDEF(JDIMENSION)
+get_24bit_row(j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
+/* This version is for reading 24-bit pixels */
+{
+  bmp_source_ptr source = (bmp_source_ptr)sinfo;
+  JSAMPARRAY image_ptr;
+  register JSAMPROW inptr, outptr;
+  register JDIMENSION col;
+
+  if (source->use_inversion_array) {
+    /* Fetch next row from virtual array */
+    source->source_row--;
+    image_ptr = (*cinfo->mem->access_virt_sarray)
+      ((j_common_ptr)cinfo, source->whole_image,
+       source->source_row, (JDIMENSION)1, FALSE);
+    inptr = image_ptr[0];
+  } else {
+    if (!ReadOK(source->pub.input_file, source->iobuffer, source->row_width))
+      ERREXIT(cinfo, JERR_INPUT_EOF);
+    inptr = source->iobuffer;
+  }
+
+  /* Transfer data.  Note source values are in BGR order
+   * (even though Microsoft's own documents say the opposite).
+   */
+  outptr = source->pub.buffer[0];
+  if (cinfo->in_color_space == JCS_EXT_BGR) {
+    MEMCOPY(outptr, inptr, source->row_width);
+  } else if (cinfo->in_color_space == JCS_CMYK) {
+    for (col = cinfo->image_width; col > 0; col--) {
+      JSAMPLE b = *inptr++, g = *inptr++, r = *inptr++;
+      rgb_to_cmyk(r, g, b, outptr, outptr + 1, outptr + 2, outptr + 3);
+      outptr += 4;
+    }
+  } else {
+    register int rindex = rgb_red[cinfo->in_color_space];
+    register int gindex = rgb_green[cinfo->in_color_space];
+    register int bindex = rgb_blue[cinfo->in_color_space];
+    register int aindex = alpha_index[cinfo->in_color_space];
+    register int ps = rgb_pixelsize[cinfo->in_color_space];
+
+    if (aindex >= 0) {
+      for (col = cinfo->image_width; col > 0; col--) {
+        outptr[bindex] = *inptr++;
+        outptr[gindex] = *inptr++;
+        outptr[rindex] = *inptr++;
+        outptr[aindex] = 0xFF;
+        outptr += ps;
+      }
+    } else {
+      for (col = cinfo->image_width; col > 0; col--) {
+        outptr[bindex] = *inptr++;
+        outptr[gindex] = *inptr++;
+        outptr[rindex] = *inptr++;
+        outptr += ps;
+      }
+    }
+  }
+
+  return 1;
+}
+
+
+METHODDEF(JDIMENSION)
+get_32bit_row(j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
+/* This version is for reading 32-bit pixels */
+{
+  bmp_source_ptr source = (bmp_source_ptr)sinfo;
+  JSAMPARRAY image_ptr;
+  register JSAMPROW inptr, outptr;
+  register JDIMENSION col;
+
+  if (source->use_inversion_array) {
+    /* Fetch next row from virtual array */
+    source->source_row--;
+    image_ptr = (*cinfo->mem->access_virt_sarray)
+      ((j_common_ptr)cinfo, source->whole_image,
+       source->source_row, (JDIMENSION)1, FALSE);
+    inptr = image_ptr[0];
+  } else {
+    if (!ReadOK(source->pub.input_file, source->iobuffer, source->row_width))
+      ERREXIT(cinfo, JERR_INPUT_EOF);
+    inptr = source->iobuffer;
+  }
+
+  /* Transfer data.  Note source values are in BGR order
+   * (even though Microsoft's own documents say the opposite).
+   */
+  outptr = source->pub.buffer[0];
+  if (cinfo->in_color_space == JCS_EXT_BGRX ||
+      cinfo->in_color_space == JCS_EXT_BGRA) {
+    MEMCOPY(outptr, inptr, source->row_width);
+  } else if (cinfo->in_color_space == JCS_CMYK) {
+    for (col = cinfo->image_width; col > 0; col--) {
+      JSAMPLE b = *inptr++, g = *inptr++, r = *inptr++;
+      rgb_to_cmyk(r, g, b, outptr, outptr + 1, outptr + 2, outptr + 3);
+      inptr++;                          /* skip the 4th byte (Alpha channel) */
+      outptr += 4;
+    }
+  } else {
+    register int rindex = rgb_red[cinfo->in_color_space];
+    register int gindex = rgb_green[cinfo->in_color_space];
+    register int bindex = rgb_blue[cinfo->in_color_space];
+    register int aindex = alpha_index[cinfo->in_color_space];
+    register int ps = rgb_pixelsize[cinfo->in_color_space];
+
+    if (aindex >= 0) {
+      for (col = cinfo->image_width; col > 0; col--) {
+        outptr[bindex] = *inptr++;
+        outptr[gindex] = *inptr++;
+        outptr[rindex] = *inptr++;
+        outptr[aindex] = *inptr++;
+        outptr += ps;
+      }
+    } else {
+      for (col = cinfo->image_width; col > 0; col--) {
+        outptr[bindex] = *inptr++;
+        outptr[gindex] = *inptr++;
+        outptr[rindex] = *inptr++;
+        inptr++;                        /* skip the 4th byte (Alpha channel) */
+        outptr += ps;
+      }
+    }
+  }
+
+  return 1;
+}
+
+
+/*
+ * This method loads the image into whole_image during the first call on
+ * get_pixel_rows.  The get_pixel_rows pointer is then adjusted to call
+ * get_8bit_row, get_24bit_row, or get_32bit_row on subsequent calls.
+ */
+
+METHODDEF(JDIMENSION)
+preload_image(j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
+{
+  bmp_source_ptr source = (bmp_source_ptr)sinfo;
+  register FILE *infile = source->pub.input_file;
+  register JSAMPROW out_ptr;
+  JSAMPARRAY image_ptr;
+  JDIMENSION row;
+  cd_progress_ptr progress = (cd_progress_ptr)cinfo->progress;
+
+  /* Read the data into a virtual array in input-file row order. */
+  for (row = 0; row < cinfo->image_height; row++) {
+    if (progress != NULL) {
+      progress->pub.pass_counter = (long)row;
+      progress->pub.pass_limit = (long)cinfo->image_height;
+      (*progress->pub.progress_monitor) ((j_common_ptr)cinfo);
+    }
+    image_ptr = (*cinfo->mem->access_virt_sarray)
+      ((j_common_ptr)cinfo, source->whole_image, row, (JDIMENSION)1, TRUE);
+    out_ptr = image_ptr[0];
+    if (fread(out_ptr, 1, source->row_width, infile) != source->row_width) {
+      if (feof(infile))
+        ERREXIT(cinfo, JERR_INPUT_EOF);
+      else
+        ERREXIT(cinfo, JERR_FILE_READ);
+    }
+  }
+  if (progress != NULL)
+    progress->completed_extra_passes++;
+
+  /* Set up to read from the virtual array in top-to-bottom order */
+  switch (source->bits_per_pixel) {
+  case 8:
+    source->pub.get_pixel_rows = get_8bit_row;
+    break;
+  case 24:
+    source->pub.get_pixel_rows = get_24bit_row;
+    break;
+  case 32:
+    source->pub.get_pixel_rows = get_32bit_row;
+    break;
+  default:
+    ERREXIT(cinfo, JERR_BMP_BADDEPTH);
+  }
+  source->source_row = cinfo->image_height;
+
+  /* And read the first row */
+  return (*source->pub.get_pixel_rows) (cinfo, sinfo);
+}
+
+
+/*
+ * Read the file header; return image size and component count.
+ */
+
+METHODDEF(void)
+start_input_bmp(j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
+{
+  bmp_source_ptr source = (bmp_source_ptr)sinfo;
+  U_CHAR bmpfileheader[14];
+  U_CHAR bmpinfoheader[64];
+
+#define GET_2B(array, offset) \
+  ((unsigned short)UCH(array[offset]) + \
+   (((unsigned short)UCH(array[offset + 1])) << 8))
+#define GET_4B(array, offset) \
+  ((unsigned int)UCH(array[offset]) + \
+   (((unsigned int)UCH(array[offset + 1])) << 8) + \
+   (((unsigned int)UCH(array[offset + 2])) << 16) + \
+   (((unsigned int)UCH(array[offset + 3])) << 24))
+
+  unsigned int bfOffBits;
+  unsigned int headerSize;
+  int biWidth;
+  int biHeight;
+  unsigned short biPlanes;
+  unsigned int biCompression;
+  int biXPelsPerMeter, biYPelsPerMeter;
+  unsigned int biClrUsed = 0;
+  int mapentrysize = 0;         /* 0 indicates no colormap */
+  int bPad;
+  JDIMENSION row_width = 0;
+
+  /* Read and verify the bitmap file header */
+  if (!ReadOK(source->pub.input_file, bmpfileheader, 14))
+    ERREXIT(cinfo, JERR_INPUT_EOF);
+  if (GET_2B(bmpfileheader, 0) != 0x4D42) /* 'BM' */
+    ERREXIT(cinfo, JERR_BMP_NOT);
+  bfOffBits = GET_4B(bmpfileheader, 10);
+  /* We ignore the remaining fileheader fields */
+
+  /* The infoheader might be 12 bytes (OS/2 1.x), 40 bytes (Windows),
+   * or 64 bytes (OS/2 2.x).  Check the first 4 bytes to find out which.
+   */
+  if (!ReadOK(source->pub.input_file, bmpinfoheader, 4))
+    ERREXIT(cinfo, JERR_INPUT_EOF);
+  headerSize = GET_4B(bmpinfoheader, 0);
+  if (headerSize < 12 || headerSize > 64)
+    ERREXIT(cinfo, JERR_BMP_BADHEADER);
+  if (!ReadOK(source->pub.input_file, bmpinfoheader + 4, headerSize - 4))
+    ERREXIT(cinfo, JERR_INPUT_EOF);
+
+  switch (headerSize) {
+  case 12:
+    /* Decode OS/2 1.x header (Microsoft calls this a BITMAPCOREHEADER) */
+    biWidth = (int)GET_2B(bmpinfoheader, 4);
+    biHeight = (int)GET_2B(bmpinfoheader, 6);
+    biPlanes = GET_2B(bmpinfoheader, 8);
+    source->bits_per_pixel = (int)GET_2B(bmpinfoheader, 10);
+
+    switch (source->bits_per_pixel) {
+    case 8:                     /* colormapped image */
+      mapentrysize = 3;         /* OS/2 uses RGBTRIPLE colormap */
+      TRACEMS2(cinfo, 1, JTRC_BMP_OS2_MAPPED, biWidth, biHeight);
+      break;
+    case 24:                    /* RGB image */
+    case 32:                    /* RGB image + Alpha channel */
+      TRACEMS3(cinfo, 1, JTRC_BMP_OS2, biWidth, biHeight,
+               source->bits_per_pixel);
+      break;
+    default:
+      ERREXIT(cinfo, JERR_BMP_BADDEPTH);
+      break;
+    }
+    break;
+  case 40:
+  case 64:
+    /* Decode Windows 3.x header (Microsoft calls this a BITMAPINFOHEADER) */
+    /* or OS/2 2.x header, which has additional fields that we ignore */
+    biWidth = (int)GET_4B(bmpinfoheader, 4);
+    biHeight = (int)GET_4B(bmpinfoheader, 8);
+    biPlanes = GET_2B(bmpinfoheader, 12);
+    source->bits_per_pixel = (int)GET_2B(bmpinfoheader, 14);
+    biCompression = GET_4B(bmpinfoheader, 16);
+    biXPelsPerMeter = (int)GET_4B(bmpinfoheader, 24);
+    biYPelsPerMeter = (int)GET_4B(bmpinfoheader, 28);
+    biClrUsed = GET_4B(bmpinfoheader, 32);
+    /* biSizeImage, biClrImportant fields are ignored */
+
+    switch (source->bits_per_pixel) {
+    case 8:                     /* colormapped image */
+      mapentrysize = 4;         /* Windows uses RGBQUAD colormap */
+      TRACEMS2(cinfo, 1, JTRC_BMP_MAPPED, biWidth, biHeight);
+      break;
+    case 24:                    /* RGB image */
+    case 32:                    /* RGB image + Alpha channel */
+      TRACEMS3(cinfo, 1, JTRC_BMP, biWidth, biHeight, source->bits_per_pixel);
+      break;
+    default:
+      ERREXIT(cinfo, JERR_BMP_BADDEPTH);
+      break;
+    }
+    if (biCompression != 0)
+      ERREXIT(cinfo, JERR_BMP_COMPRESSED);
+
+    if (biXPelsPerMeter > 0 && biYPelsPerMeter > 0) {
+      /* Set JFIF density parameters from the BMP data */
+      cinfo->X_density = (UINT16)(biXPelsPerMeter / 100); /* 100 cm per meter */
+      cinfo->Y_density = (UINT16)(biYPelsPerMeter / 100);
+      cinfo->density_unit = 2;  /* dots/cm */
+    }
+    break;
+  default:
+    ERREXIT(cinfo, JERR_BMP_BADHEADER);
+    return;
+  }
+
+  if (biWidth <= 0 || biHeight <= 0)
+    ERREXIT(cinfo, JERR_BMP_EMPTY);
+  if (biPlanes != 1)
+    ERREXIT(cinfo, JERR_BMP_BADPLANES);
+
+  /* Compute distance to bitmap data --- will adjust for colormap below */
+  bPad = bfOffBits - (headerSize + 14);
+
+  /* Read the colormap, if any */
+  if (mapentrysize > 0) {
+    if (biClrUsed <= 0)
+      biClrUsed = 256;          /* assume it's 256 */
+    else if (biClrUsed > 256)
+      ERREXIT(cinfo, JERR_BMP_BADCMAP);
+    /* Allocate space to store the colormap */
+    source->colormap = (*cinfo->mem->alloc_sarray)
+      ((j_common_ptr)cinfo, JPOOL_IMAGE, (JDIMENSION)biClrUsed, (JDIMENSION)3);
+    source->cmap_length = (int)biClrUsed;
+    /* and read it from the file */
+    read_colormap(source, (int)biClrUsed, mapentrysize);
+    /* account for size of colormap */
+    bPad -= biClrUsed * mapentrysize;
+  }
+
+  /* Skip any remaining pad bytes */
+  if (bPad < 0)                 /* incorrect bfOffBits value? */
+    ERREXIT(cinfo, JERR_BMP_BADHEADER);
+  while (--bPad >= 0) {
+    (void)read_byte(source);
+  }
+
+  /* Compute row width in file, including padding to 4-byte boundary */
+  switch (source->bits_per_pixel) {
+  case 8:
+    if (cinfo->in_color_space == JCS_UNKNOWN)
+      cinfo->in_color_space = JCS_EXT_RGB;
+    if (IsExtRGB(cinfo->in_color_space))
+      cinfo->input_components = rgb_pixelsize[cinfo->in_color_space];
+    else if (cinfo->in_color_space == JCS_GRAYSCALE)
+      cinfo->input_components = 1;
+    else if (cinfo->in_color_space == JCS_CMYK)
+      cinfo->input_components = 4;
+    else
+      ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE);
+    row_width = (JDIMENSION)biWidth;
+    break;
+  case 24:
+    if (cinfo->in_color_space == JCS_UNKNOWN)
+      cinfo->in_color_space = JCS_EXT_BGR;
+    if (IsExtRGB(cinfo->in_color_space))
+      cinfo->input_components = rgb_pixelsize[cinfo->in_color_space];
+    else if (cinfo->in_color_space == JCS_CMYK)
+      cinfo->input_components = 4;
+    else
+      ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE);
+    row_width = (JDIMENSION)(biWidth * 3);
+    break;
+  case 32:
+    if (cinfo->in_color_space == JCS_UNKNOWN)
+      cinfo->in_color_space = JCS_EXT_BGRA;
+    if (IsExtRGB(cinfo->in_color_space))
+      cinfo->input_components = rgb_pixelsize[cinfo->in_color_space];
+    else if (cinfo->in_color_space == JCS_CMYK)
+      cinfo->input_components = 4;
+    else
+      ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE);
+    row_width = (JDIMENSION)(biWidth * 4);
+    break;
+  default:
+    ERREXIT(cinfo, JERR_BMP_BADDEPTH);
+  }
+  while ((row_width & 3) != 0) row_width++;
+  source->row_width = row_width;
+
+  if (source->use_inversion_array) {
+    /* Allocate space for inversion array, prepare for preload pass */
+    source->whole_image = (*cinfo->mem->request_virt_sarray)
+      ((j_common_ptr)cinfo, JPOOL_IMAGE, FALSE,
+       row_width, (JDIMENSION)biHeight, (JDIMENSION)1);
+    source->pub.get_pixel_rows = preload_image;
+    if (cinfo->progress != NULL) {
+      cd_progress_ptr progress = (cd_progress_ptr)cinfo->progress;
+      progress->total_extra_passes++; /* count file input as separate pass */
+    }
+  } else {
+    source->iobuffer = (U_CHAR *)
+      (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE, row_width);
+    switch (source->bits_per_pixel) {
+    case 8:
+      source->pub.get_pixel_rows = get_8bit_row;
+      break;
+    case 24:
+      source->pub.get_pixel_rows = get_24bit_row;
+      break;
+    case 32:
+      source->pub.get_pixel_rows = get_32bit_row;
+      break;
+    default:
+      ERREXIT(cinfo, JERR_BMP_BADDEPTH);
+    }
+  }
+
+  /* Ensure that biWidth * cinfo->input_components doesn't exceed the maximum
+     value of the JDIMENSION type.  This is only a danger with BMP files, since
+     their width and height fields are 32-bit integers. */
+  if ((unsigned long long)biWidth *
+      (unsigned long long)cinfo->input_components > 0xFFFFFFFFULL)
+    ERREXIT(cinfo, JERR_WIDTH_OVERFLOW);
+  /* Allocate one-row buffer for returned data */
+  source->pub.buffer = (*cinfo->mem->alloc_sarray)
+    ((j_common_ptr)cinfo, JPOOL_IMAGE,
+     (JDIMENSION)(biWidth * cinfo->input_components), (JDIMENSION)1);
+  source->pub.buffer_height = 1;
+
+  cinfo->data_precision = 8;
+  cinfo->image_width = (JDIMENSION)biWidth;
+  cinfo->image_height = (JDIMENSION)biHeight;
+}
+
+
+/*
+ * Finish up at the end of the file.
+ */
+
+METHODDEF(void)
+finish_input_bmp(j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
+{
+  /* no work */
+}
+
+
+/*
+ * The module selection routine for BMP format input.
+ */
+
+GLOBAL(cjpeg_source_ptr)
+jinit_read_bmp(j_compress_ptr cinfo, boolean use_inversion_array)
+{
+  bmp_source_ptr source;
+
+  /* Create module interface object */
+  source = (bmp_source_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+                                sizeof(bmp_source_struct));
+  source->cinfo = cinfo;        /* make back link for subroutines */
+  /* Fill in method ptrs, except get_pixel_rows which start_input sets */
+  source->pub.start_input = start_input_bmp;
+  source->pub.finish_input = finish_input_bmp;
+
+  source->use_inversion_array = use_inversion_array;
+
+  return (cjpeg_source_ptr)source;
+}
+
+#endif /* BMP_SUPPORTED */
diff --git a/3rdparty/libjpeg/src/rdcolmap.c b/3rdparty/libjpeg/src/rdcolmap.c
new file mode 100644
index 00000000..d2ed95cf
--- /dev/null
+++ b/3rdparty/libjpeg/src/rdcolmap.c
@@ -0,0 +1,253 @@
+/*
+ * rdcolmap.c
+ *
+ * Copyright (C) 1994-1996, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file implements djpeg's "-map file" switch.  It reads a source image
+ * and constructs a colormap to be supplied to the JPEG decompressor.
+ *
+ * Currently, these file formats are supported for the map file:
+ *   GIF: the contents of the GIF's global colormap are used.
+ *   PPM (either text or raw flavor): the entire file is read and
+ *      each unique pixel value is entered in the map.
+ * Note that reading a large PPM file will be horrendously slow.
+ * Typically, a PPM-format map file should contain just one pixel
+ * of each desired color.  Such a file can be extracted from an
+ * ordinary image PPM file with ppmtomap(1).
+ *
+ * Rescaling a PPM that has a maxval unequal to MAXJSAMPLE is not
+ * currently implemented.
+ */
+
+#include "cdjpeg.h"             /* Common decls for cjpeg/djpeg applications */
+
+#ifdef QUANT_2PASS_SUPPORTED    /* otherwise can't quantize to supplied map */
+
+/* Portions of this code are based on the PBMPLUS library, which is:
+**
+** Copyright (C) 1988 by Jef Poskanzer.
+**
+** Permission to use, copy, modify, and distribute this software and its
+** documentation for any purpose and without fee is hereby granted, provided
+** that the above copyright notice appear in all copies and that both that
+** copyright notice and this permission notice appear in supporting
+** documentation.  This software is provided "as is" without express or
+** implied warranty.
+*/
+
+
+/*
+ * Add a (potentially) new color to the color map.
+ */
+
+LOCAL(void)
+add_map_entry(j_decompress_ptr cinfo, int R, int G, int B)
+{
+  JSAMPROW colormap0 = cinfo->colormap[0];
+  JSAMPROW colormap1 = cinfo->colormap[1];
+  JSAMPROW colormap2 = cinfo->colormap[2];
+  int ncolors = cinfo->actual_number_of_colors;
+  int index;
+
+  /* Check for duplicate color. */
+  for (index = 0; index < ncolors; index++) {
+    if (colormap0[index] == R && colormap1[index] == G &&
+        colormap2[index] == B)
+      return;                   /* color is already in map */
+  }
+
+  /* Check for map overflow. */
+  if (ncolors >= (MAXJSAMPLE + 1))
+    ERREXIT1(cinfo, JERR_QUANT_MANY_COLORS, (MAXJSAMPLE + 1));
+
+  /* OK, add color to map. */
+  colormap0[ncolors] = (JSAMPLE)R;
+  colormap1[ncolors] = (JSAMPLE)G;
+  colormap2[ncolors] = (JSAMPLE)B;
+  cinfo->actual_number_of_colors++;
+}
+
+
+/*
+ * Extract color map from a GIF file.
+ */
+
+LOCAL(void)
+read_gif_map(j_decompress_ptr cinfo, FILE *infile)
+{
+  int header[13];
+  int i, colormaplen;
+  int R, G, B;
+
+  /* Initial 'G' has already been read by read_color_map */
+  /* Read the rest of the GIF header and logical screen descriptor */
+  for (i = 1; i < 13; i++) {
+    if ((header[i] = getc(infile)) == EOF)
+      ERREXIT(cinfo, JERR_BAD_CMAP_FILE);
+  }
+
+  /* Verify GIF Header */
+  if (header[1] != 'I' || header[2] != 'F')
+    ERREXIT(cinfo, JERR_BAD_CMAP_FILE);
+
+  /* There must be a global color map. */
+  if ((header[10] & 0x80) == 0)
+    ERREXIT(cinfo, JERR_BAD_CMAP_FILE);
+
+  /* OK, fetch it. */
+  colormaplen = 2 << (header[10] & 0x07);
+
+  for (i = 0; i < colormaplen; i++) {
+    R = getc(infile);
+    G = getc(infile);
+    B = getc(infile);
+    if (R == EOF || G == EOF || B == EOF)
+      ERREXIT(cinfo, JERR_BAD_CMAP_FILE);
+    add_map_entry(cinfo,
+                  R << (BITS_IN_JSAMPLE - 8),
+                  G << (BITS_IN_JSAMPLE - 8),
+                  B << (BITS_IN_JSAMPLE - 8));
+  }
+}
+
+
+/* Support routines for reading PPM */
+
+
+LOCAL(int)
+pbm_getc(FILE *infile)
+/* Read next char, skipping over any comments */
+/* A comment/newline sequence is returned as a newline */
+{
+  register int ch;
+
+  ch = getc(infile);
+  if (ch == '#') {
+    do {
+      ch = getc(infile);
+    } while (ch != '\n' && ch != EOF);
+  }
+  return ch;
+}
+
+
+LOCAL(unsigned int)
+read_pbm_integer(j_decompress_ptr cinfo, FILE *infile)
+/* Read an unsigned decimal integer from the PPM file */
+/* Swallows one trailing character after the integer */
+/* Note that on a 16-bit-int machine, only values up to 64k can be read. */
+/* This should not be a problem in practice. */
+{
+  register int ch;
+  register unsigned int val;
+
+  /* Skip any leading whitespace */
+  do {
+    ch = pbm_getc(infile);
+    if (ch == EOF)
+      ERREXIT(cinfo, JERR_BAD_CMAP_FILE);
+  } while (ch == ' ' || ch == '\t' || ch == '\n' || ch == '\r');
+
+  if (ch < '0' || ch > '9')
+    ERREXIT(cinfo, JERR_BAD_CMAP_FILE);
+
+  val = ch - '0';
+  while ((ch = pbm_getc(infile)) >= '0' && ch <= '9') {
+    val *= 10;
+    val += ch - '0';
+  }
+  return val;
+}
+
+
+/*
+ * Extract color map from a PPM file.
+ */
+
+LOCAL(void)
+read_ppm_map(j_decompress_ptr cinfo, FILE *infile)
+{
+  int c;
+  unsigned int w, h, maxval, row, col;
+  int R, G, B;
+
+  /* Initial 'P' has already been read by read_color_map */
+  c = getc(infile);             /* save format discriminator for a sec */
+
+  /* while we fetch the remaining header info */
+  w = read_pbm_integer(cinfo, infile);
+  h = read_pbm_integer(cinfo, infile);
+  maxval = read_pbm_integer(cinfo, infile);
+
+  if (w <= 0 || h <= 0 || maxval <= 0) /* error check */
+    ERREXIT(cinfo, JERR_BAD_CMAP_FILE);
+
+  /* For now, we don't support rescaling from an unusual maxval. */
+  if (maxval != (unsigned int)MAXJSAMPLE)
+    ERREXIT(cinfo, JERR_BAD_CMAP_FILE);
+
+  switch (c) {
+  case '3':                     /* it's a text-format PPM file */
+    for (row = 0; row < h; row++) {
+      for (col = 0; col < w; col++) {
+        R = read_pbm_integer(cinfo, infile);
+        G = read_pbm_integer(cinfo, infile);
+        B = read_pbm_integer(cinfo, infile);
+        add_map_entry(cinfo, R, G, B);
+      }
+    }
+    break;
+
+  case '6':                     /* it's a raw-format PPM file */
+    for (row = 0; row < h; row++) {
+      for (col = 0; col < w; col++) {
+        R = getc(infile);
+        G = getc(infile);
+        B = getc(infile);
+        if (R == EOF || G == EOF || B == EOF)
+          ERREXIT(cinfo, JERR_BAD_CMAP_FILE);
+        add_map_entry(cinfo, R, G, B);
+      }
+    }
+    break;
+
+  default:
+    ERREXIT(cinfo, JERR_BAD_CMAP_FILE);
+    break;
+  }
+}
+
+
+/*
+ * Main entry point from djpeg.c.
+ *  Input: opened input file (from file name argument on command line).
+ *  Output: colormap and actual_number_of_colors fields are set in cinfo.
+ */
+
+GLOBAL(void)
+read_color_map(j_decompress_ptr cinfo, FILE *infile)
+{
+  /* Allocate space for a color map of maximum supported size. */
+  cinfo->colormap = (*cinfo->mem->alloc_sarray)
+    ((j_common_ptr)cinfo, JPOOL_IMAGE,
+     (JDIMENSION)(MAXJSAMPLE + 1), (JDIMENSION)3);
+  cinfo->actual_number_of_colors = 0; /* initialize map to empty */
+
+  /* Read first byte to determine file format */
+  switch (getc(infile)) {
+  case 'G':
+    read_gif_map(cinfo, infile);
+    break;
+  case 'P':
+    read_ppm_map(cinfo, infile);
+    break;
+  default:
+    ERREXIT(cinfo, JERR_BAD_CMAP_FILE);
+    break;
+  }
+}
+
+#endif /* QUANT_2PASS_SUPPORTED */
diff --git a/3rdparty/libjpeg/src/rdgif.c b/3rdparty/libjpeg/src/rdgif.c
new file mode 100644
index 00000000..e1ea56cd
--- /dev/null
+++ b/3rdparty/libjpeg/src/rdgif.c
@@ -0,0 +1,676 @@
+/*
+ * rdgif.c
+ *
+ * Copyright (C) 1991-1997, Thomas G. Lane.
+ * Modified 2019 by Guido Vollbeding.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains routines to read input images in GIF format.
+ *
+ * These routines may need modification for non-Unix environments or
+ * specialized applications.  As they stand, they assume input from
+ * an ordinary stdio stream.  They further assume that reading begins
+ * at the start of the file; start_input may need work if the
+ * user interface has already read some data (e.g., to determine that
+ * the file is indeed GIF format).
+ */
+
+/*
+ * This code is loosely based on giftoppm from the PBMPLUS distribution
+ * of Feb. 1991.  That file contains the following copyright notice:
+ * +-------------------------------------------------------------------+
+ * | Copyright 1990, David Koblas.                                     |
+ * |   Permission to use, copy, modify, and distribute this software   |
+ * |   and its documentation for any purpose and without fee is hereby |
+ * |   granted, provided that the above copyright notice appear in all |
+ * |   copies and that both that copyright notice and this permission  |
+ * |   notice appear in supporting documentation.  This software is    |
+ * |   provided "as is" without express or implied warranty.           |
+ * +-------------------------------------------------------------------+
+ */
+
+#include "cdjpeg.h"             /* Common decls for cjpeg/djpeg applications */
+
+#ifdef GIF_SUPPORTED
+
+
+/* Macros to deal with unsigned chars as efficiently as compiler allows */
+
+typedef unsigned char U_CHAR;
+#define UCH(x)  ((int)(x))
+
+
+#define ReadOK(file, buffer, len) \
+  (JFREAD(file, buffer, len) == ((size_t)(len)))
+
+
+#define MAXCOLORMAPSIZE  256    /* max # of colors in a GIF colormap */
+#define NUMCOLORS        3      /* # of colors */
+#define CM_RED           0      /* color component numbers */
+#define CM_GREEN         1
+#define CM_BLUE          2
+
+#define MAX_LZW_BITS     12     /* maximum LZW code size */
+#define LZW_TABLE_SIZE   (1 << MAX_LZW_BITS) /* # of possible LZW symbols */
+
+/* Macros for extracting header data --- note we assume chars may be signed */
+
+#define LM_to_uint(array, offset) \
+  ((unsigned int)UCH(array[offset]) + \
+   (((unsigned int)UCH(array[offset + 1])) << 8))
+
+#define BitSet(byte, bit)       ((byte) & (bit))
+#define INTERLACE       0x40    /* mask for bit signifying interlaced image */
+#define COLORMAPFLAG    0x80    /* mask for bit signifying colormap presence */
+
+
+/*
+ * LZW decompression tables look like this:
+ *   symbol_head[K] = prefix symbol of any LZW symbol K (0..LZW_TABLE_SIZE-1)
+ *   symbol_tail[K] = suffix byte   of any LZW symbol K (0..LZW_TABLE_SIZE-1)
+ * Note that entries 0..end_code of the above tables are not used,
+ * since those symbols represent raw bytes or special codes.
+ *
+ * The stack represents the not-yet-used expansion of the last LZW symbol.
+ * In the worst case, a symbol could expand to as many bytes as there are
+ * LZW symbols, so we allocate LZW_TABLE_SIZE bytes for the stack.
+ * (This is conservative since that number includes the raw-byte symbols.)
+ */
+
+
+/* Private version of data source object */
+
+typedef struct {
+  struct cjpeg_source_struct pub; /* public fields */
+
+  j_compress_ptr cinfo;         /* back link saves passing separate parm */
+
+  JSAMPARRAY colormap;          /* GIF colormap (converted to my format) */
+
+  /* State for GetCode and LZWReadByte */
+  U_CHAR code_buf[256 + 4];     /* current input data block */
+  int last_byte;                /* # of bytes in code_buf */
+  int last_bit;                 /* # of bits in code_buf */
+  int cur_bit;                  /* next bit index to read */
+  boolean first_time;           /* flags first call to GetCode */
+  boolean out_of_blocks;        /* TRUE if hit terminator data block */
+
+  int input_code_size;          /* codesize given in GIF file */
+  int clear_code, end_code;     /* values for Clear and End codes */
+
+  int code_size;                /* current actual code size */
+  int limit_code;               /* 2^code_size */
+  int max_code;                 /* first unused code value */
+
+  /* Private state for LZWReadByte */
+  int oldcode;                  /* previous LZW symbol */
+  int firstcode;                /* first byte of oldcode's expansion */
+
+  /* LZW symbol table and expansion stack */
+  UINT16 *symbol_head;          /* => table of prefix symbols */
+  UINT8  *symbol_tail;          /* => table of suffix bytes */
+  UINT8  *symbol_stack;         /* => stack for symbol expansions */
+  UINT8  *sp;                   /* stack pointer */
+
+  /* State for interlaced image processing */
+  boolean is_interlaced;        /* TRUE if have interlaced image */
+  jvirt_sarray_ptr interlaced_image; /* full image in interlaced order */
+  JDIMENSION cur_row_number;    /* need to know actual row number */
+  JDIMENSION pass2_offset;      /* # of pixel rows in pass 1 */
+  JDIMENSION pass3_offset;      /* # of pixel rows in passes 1&2 */
+  JDIMENSION pass4_offset;      /* # of pixel rows in passes 1,2,3 */
+} gif_source_struct;
+
+typedef gif_source_struct *gif_source_ptr;
+
+
+/* Forward declarations */
+METHODDEF(JDIMENSION) get_pixel_rows(j_compress_ptr cinfo,
+                                     cjpeg_source_ptr sinfo);
+METHODDEF(JDIMENSION) load_interlaced_image(j_compress_ptr cinfo,
+                                            cjpeg_source_ptr sinfo);
+METHODDEF(JDIMENSION) get_interlaced_row(j_compress_ptr cinfo,
+                                         cjpeg_source_ptr sinfo);
+
+
+LOCAL(int)
+ReadByte(gif_source_ptr sinfo)
+/* Read next byte from GIF file */
+{
+  register FILE *infile = sinfo->pub.input_file;
+  register int c;
+
+  if ((c = getc(infile)) == EOF)
+    ERREXIT(sinfo->cinfo, JERR_INPUT_EOF);
+  return c;
+}
+
+
+LOCAL(int)
+GetDataBlock(gif_source_ptr sinfo, U_CHAR *buf)
+/* Read a GIF data block, which has a leading count byte */
+/* A zero-length block marks the end of a data block sequence */
+{
+  int count;
+
+  count = ReadByte(sinfo);
+  if (count > 0) {
+    if (!ReadOK(sinfo->pub.input_file, buf, count))
+      ERREXIT(sinfo->cinfo, JERR_INPUT_EOF);
+  }
+  return count;
+}
+
+
+LOCAL(void)
+SkipDataBlocks(gif_source_ptr sinfo)
+/* Skip a series of data blocks, until a block terminator is found */
+{
+  U_CHAR buf[256];
+
+  while (GetDataBlock(sinfo, buf) > 0)
+    /* skip */;
+}
+
+
+LOCAL(void)
+ReInitLZW(gif_source_ptr sinfo)
+/* (Re)initialize LZW state; shared code for startup and Clear processing */
+{
+  sinfo->code_size = sinfo->input_code_size + 1;
+  sinfo->limit_code = sinfo->clear_code << 1;   /* 2^code_size */
+  sinfo->max_code = sinfo->clear_code + 2;      /* first unused code value */
+  sinfo->sp = sinfo->symbol_stack;              /* init stack to empty */
+}
+
+
+LOCAL(void)
+InitLZWCode(gif_source_ptr sinfo)
+/* Initialize for a series of LZWReadByte (and hence GetCode) calls */
+{
+  /* GetCode initialization */
+  sinfo->last_byte = 2;         /* make safe to "recopy last two bytes" */
+  sinfo->code_buf[0] = 0;
+  sinfo->code_buf[1] = 0;
+  sinfo->last_bit = 0;          /* nothing in the buffer */
+  sinfo->cur_bit = 0;           /* force buffer load on first call */
+  sinfo->first_time = TRUE;
+  sinfo->out_of_blocks = FALSE;
+
+  /* LZWReadByte initialization: */
+  /* compute special code values (note that these do not change later) */
+  sinfo->clear_code = 1 << sinfo->input_code_size;
+  sinfo->end_code = sinfo->clear_code + 1;
+  ReInitLZW(sinfo);
+}
+
+
+LOCAL(int)
+GetCode(gif_source_ptr sinfo)
+/* Fetch the next code_size bits from the GIF data */
+/* We assume code_size is less than 16 */
+{
+  register int accum;
+  int offs, count;
+
+  while (sinfo->cur_bit + sinfo->code_size > sinfo->last_bit) {
+    /* Time to reload the buffer */
+    /* First time, share code with Clear case */
+    if (sinfo->first_time) {
+      sinfo->first_time = FALSE;
+      return sinfo->clear_code;
+    }
+    if (sinfo->out_of_blocks) {
+      WARNMS(sinfo->cinfo, JWRN_GIF_NOMOREDATA);
+      return sinfo->end_code;   /* fake something useful */
+    }
+    /* preserve last two bytes of what we have -- assume code_size <= 16 */
+    sinfo->code_buf[0] = sinfo->code_buf[sinfo->last_byte-2];
+    sinfo->code_buf[1] = sinfo->code_buf[sinfo->last_byte-1];
+    /* Load more bytes; set flag if we reach the terminator block */
+    if ((count = GetDataBlock(sinfo, &sinfo->code_buf[2])) == 0) {
+      sinfo->out_of_blocks = TRUE;
+      WARNMS(sinfo->cinfo, JWRN_GIF_NOMOREDATA);
+      return sinfo->end_code;   /* fake something useful */
+    }
+    /* Reset counters */
+    sinfo->cur_bit = (sinfo->cur_bit - sinfo->last_bit) + 16;
+    sinfo->last_byte = 2 + count;
+    sinfo->last_bit = sinfo->last_byte * 8;
+  }
+
+  /* Form up next 24 bits in accum */
+  offs = sinfo->cur_bit >> 3;   /* byte containing cur_bit */
+  accum = UCH(sinfo->code_buf[offs + 2]);
+  accum <<= 8;
+  accum |= UCH(sinfo->code_buf[offs + 1]);
+  accum <<= 8;
+  accum |= UCH(sinfo->code_buf[offs]);
+
+  /* Right-align cur_bit in accum, then mask off desired number of bits */
+  accum >>= (sinfo->cur_bit & 7);
+  sinfo->cur_bit += sinfo->code_size;
+  return accum & ((1 << sinfo->code_size) - 1);
+}
+
+
+LOCAL(int)
+LZWReadByte(gif_source_ptr sinfo)
+/* Read an LZW-compressed byte */
+{
+  register int code;            /* current working code */
+  int incode;                   /* saves actual input code */
+
+  /* If any codes are stacked from a previously read symbol, return them */
+  if (sinfo->sp > sinfo->symbol_stack)
+    return (int)(*(--sinfo->sp));
+
+  /* Time to read a new symbol */
+  code = GetCode(sinfo);
+
+  if (code == sinfo->clear_code) {
+    /* Reinit state, swallow any extra Clear codes, and */
+    /* return next code, which is expected to be a raw byte. */
+    ReInitLZW(sinfo);
+    do {
+      code = GetCode(sinfo);
+    } while (code == sinfo->clear_code);
+    if (code > sinfo->clear_code) { /* make sure it is a raw byte */
+      WARNMS(sinfo->cinfo, JWRN_GIF_BADDATA);
+      code = 0;                 /* use something valid */
+    }
+    /* make firstcode, oldcode valid! */
+    sinfo->firstcode = sinfo->oldcode = code;
+    return code;
+  }
+
+  if (code == sinfo->end_code) {
+    /* Skip the rest of the image, unless GetCode already read terminator */
+    if (!sinfo->out_of_blocks) {
+      SkipDataBlocks(sinfo);
+      sinfo->out_of_blocks = TRUE;
+    }
+    /* Complain that there's not enough data */
+    WARNMS(sinfo->cinfo, JWRN_GIF_ENDCODE);
+    /* Pad data with 0's */
+    return 0;                   /* fake something usable */
+  }
+
+  /* Got normal raw byte or LZW symbol */
+  incode = code;                /* save for a moment */
+
+  if (code >= sinfo->max_code) { /* special case for not-yet-defined symbol */
+    /* code == max_code is OK; anything bigger is bad data */
+    if (code > sinfo->max_code) {
+      WARNMS(sinfo->cinfo, JWRN_GIF_BADDATA);
+      incode = 0;               /* prevent creation of loops in symbol table */
+    }
+    /* this symbol will be defined as oldcode/firstcode */
+    *(sinfo->sp++) = (UINT8)sinfo->firstcode;
+    code = sinfo->oldcode;
+  }
+
+  /* If it's a symbol, expand it into the stack */
+  while (code >= sinfo->clear_code) {
+    *(sinfo->sp++) = sinfo->symbol_tail[code]; /* tail is a byte value */
+    code = sinfo->symbol_head[code]; /* head is another LZW symbol */
+  }
+  /* At this point code just represents a raw byte */
+  sinfo->firstcode = code;      /* save for possible future use */
+
+  /* If there's room in table... */
+  if ((code = sinfo->max_code) < LZW_TABLE_SIZE) {
+    /* Define a new symbol = prev sym + head of this sym's expansion */
+    sinfo->symbol_head[code] = (UINT16)sinfo->oldcode;
+    sinfo->symbol_tail[code] = (UINT8)sinfo->firstcode;
+    sinfo->max_code++;
+    /* Is it time to increase code_size? */
+    if (sinfo->max_code >= sinfo->limit_code &&
+        sinfo->code_size < MAX_LZW_BITS) {
+      sinfo->code_size++;
+      sinfo->limit_code <<= 1;  /* keep equal to 2^code_size */
+    }
+  }
+
+  sinfo->oldcode = incode;      /* save last input symbol for future use */
+  return sinfo->firstcode;      /* return first byte of symbol's expansion */
+}
+
+
+LOCAL(void)
+ReadColorMap(gif_source_ptr sinfo, int cmaplen, JSAMPARRAY cmap)
+/* Read a GIF colormap */
+{
+  int i;
+
+  for (i = 0; i < cmaplen; i++) {
+#if BITS_IN_JSAMPLE == 8
+#define UPSCALE(x)  (x)
+#else
+#define UPSCALE(x)  ((x) << (BITS_IN_JSAMPLE - 8))
+#endif
+    cmap[CM_RED][i]   = (JSAMPLE)UPSCALE(ReadByte(sinfo));
+    cmap[CM_GREEN][i] = (JSAMPLE)UPSCALE(ReadByte(sinfo));
+    cmap[CM_BLUE][i]  = (JSAMPLE)UPSCALE(ReadByte(sinfo));
+  }
+}
+
+
+LOCAL(void)
+DoExtension(gif_source_ptr sinfo)
+/* Process an extension block */
+/* Currently we ignore 'em all */
+{
+  int extlabel;
+
+  /* Read extension label byte */
+  extlabel = ReadByte(sinfo);
+  TRACEMS1(sinfo->cinfo, 1, JTRC_GIF_EXTENSION, extlabel);
+  /* Skip the data block(s) associated with the extension */
+  SkipDataBlocks(sinfo);
+}
+
+
+/*
+ * Read the file header; return image size and component count.
+ */
+
+METHODDEF(void)
+start_input_gif(j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
+{
+  gif_source_ptr source = (gif_source_ptr)sinfo;
+  U_CHAR hdrbuf[10];            /* workspace for reading control blocks */
+  unsigned int width, height;   /* image dimensions */
+  int colormaplen, aspectRatio;
+  int c;
+
+  /* Read and verify GIF Header */
+  if (!ReadOK(source->pub.input_file, hdrbuf, 6))
+    ERREXIT(cinfo, JERR_GIF_NOT);
+  if (hdrbuf[0] != 'G' || hdrbuf[1] != 'I' || hdrbuf[2] != 'F')
+    ERREXIT(cinfo, JERR_GIF_NOT);
+  /* Check for expected version numbers.
+   * If unknown version, give warning and try to process anyway;
+   * this is per recommendation in GIF89a standard.
+   */
+  if ((hdrbuf[3] != '8' || hdrbuf[4] != '7' || hdrbuf[5] != 'a') &&
+      (hdrbuf[3] != '8' || hdrbuf[4] != '9' || hdrbuf[5] != 'a'))
+    TRACEMS3(cinfo, 1, JTRC_GIF_BADVERSION, hdrbuf[3], hdrbuf[4], hdrbuf[5]);
+
+  /* Read and decipher Logical Screen Descriptor */
+  if (!ReadOK(source->pub.input_file, hdrbuf, 7))
+    ERREXIT(cinfo, JERR_INPUT_EOF);
+  width = LM_to_uint(hdrbuf, 0);
+  height = LM_to_uint(hdrbuf, 2);
+  /* we ignore the color resolution, sort flag, and background color index */
+  aspectRatio = UCH(hdrbuf[6]);
+  if (aspectRatio != 0 && aspectRatio != 49)
+    TRACEMS(cinfo, 1, JTRC_GIF_NONSQUARE);
+
+  /* Allocate space to store the colormap */
+  source->colormap = (*cinfo->mem->alloc_sarray)
+    ((j_common_ptr)cinfo, JPOOL_IMAGE, (JDIMENSION)MAXCOLORMAPSIZE,
+     (JDIMENSION)NUMCOLORS);
+  colormaplen = 0;              /* indicate initialization */
+
+  /* Read global colormap if header indicates it is present */
+  if (BitSet(hdrbuf[4], COLORMAPFLAG)) {
+    colormaplen = 2 << (hdrbuf[4] & 0x07);
+    ReadColorMap(source, colormaplen, source->colormap);
+  }
+
+  /* Scan until we reach start of desired image.
+   * We don't currently support skipping images, but could add it easily.
+   */
+  for (;;) {
+    c = ReadByte(source);
+
+    if (c == ';')               /* GIF terminator?? */
+      ERREXIT(cinfo, JERR_GIF_IMAGENOTFOUND);
+
+    if (c == '!') {             /* Extension */
+      DoExtension(source);
+      continue;
+    }
+
+    if (c != ',') {             /* Not an image separator? */
+      WARNMS1(cinfo, JWRN_GIF_CHAR, c);
+      continue;
+    }
+
+    /* Read and decipher Local Image Descriptor */
+    if (!ReadOK(source->pub.input_file, hdrbuf, 9))
+      ERREXIT(cinfo, JERR_INPUT_EOF);
+    /* we ignore top/left position info, also sort flag */
+    width = LM_to_uint(hdrbuf, 4);
+    height = LM_to_uint(hdrbuf, 6);
+    source->is_interlaced = (BitSet(hdrbuf[8], INTERLACE) != 0);
+
+    /* Read local colormap if header indicates it is present */
+    /* Note: if we wanted to support skipping images, */
+    /* we'd need to skip rather than read colormap for ignored images */
+    if (BitSet(hdrbuf[8], COLORMAPFLAG)) {
+      colormaplen = 2 << (hdrbuf[8] & 0x07);
+      ReadColorMap(source, colormaplen, source->colormap);
+    }
+
+    source->input_code_size = ReadByte(source); /* get min-code-size byte */
+    if (source->input_code_size < 2 || source->input_code_size > 8)
+      ERREXIT1(cinfo, JERR_GIF_CODESIZE, source->input_code_size);
+
+    /* Reached desired image, so break out of loop */
+    /* If we wanted to skip this image, */
+    /* we'd call SkipDataBlocks and then continue the loop */
+    break;
+  }
+
+  /* Prepare to read selected image: first initialize LZW decompressor */
+  source->symbol_head = (UINT16 *)
+    (*cinfo->mem->alloc_large) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+                                LZW_TABLE_SIZE * sizeof(UINT16));
+  source->symbol_tail = (UINT8 *)
+    (*cinfo->mem->alloc_large) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+                                LZW_TABLE_SIZE * sizeof(UINT8));
+  source->symbol_stack = (UINT8 *)
+    (*cinfo->mem->alloc_large) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+                                LZW_TABLE_SIZE * sizeof(UINT8));
+  InitLZWCode(source);
+
+  /*
+   * If image is interlaced, we read it into a full-size sample array,
+   * decompressing as we go; then get_interlaced_row selects rows from the
+   * sample array in the proper order.
+   */
+  if (source->is_interlaced) {
+    /* We request the virtual array now, but can't access it until virtual
+     * arrays have been allocated.  Hence, the actual work of reading the
+     * image is postponed until the first call to get_pixel_rows.
+     */
+    source->interlaced_image = (*cinfo->mem->request_virt_sarray)
+      ((j_common_ptr)cinfo, JPOOL_IMAGE, FALSE,
+       (JDIMENSION)width, (JDIMENSION)height, (JDIMENSION)1);
+    if (cinfo->progress != NULL) {
+      cd_progress_ptr progress = (cd_progress_ptr)cinfo->progress;
+      progress->total_extra_passes++; /* count file input as separate pass */
+    }
+    source->pub.get_pixel_rows = load_interlaced_image;
+  } else {
+    source->pub.get_pixel_rows = get_pixel_rows;
+  }
+
+  /* Create compressor input buffer. */
+  source->pub.buffer = (*cinfo->mem->alloc_sarray)
+    ((j_common_ptr)cinfo, JPOOL_IMAGE, (JDIMENSION)width * NUMCOLORS,
+     (JDIMENSION)1);
+  source->pub.buffer_height = 1;
+
+  /* Pad colormap for safety. */
+  for (c = colormaplen; c < source->clear_code; c++) {
+    source->colormap[CM_RED][c]   =
+    source->colormap[CM_GREEN][c] =
+    source->colormap[CM_BLUE][c]  = CENTERJSAMPLE;
+  }
+
+  /* Return info about the image. */
+  cinfo->in_color_space = JCS_RGB;
+  cinfo->input_components = NUMCOLORS;
+  cinfo->data_precision = BITS_IN_JSAMPLE; /* we always rescale data to this */
+  cinfo->image_width = width;
+  cinfo->image_height = height;
+
+  TRACEMS3(cinfo, 1, JTRC_GIF, width, height, colormaplen);
+}
+
+
+/*
+ * Read one row of pixels.
+ * This version is used for noninterlaced GIF images:
+ * we read directly from the GIF file.
+ */
+
+METHODDEF(JDIMENSION)
+get_pixel_rows(j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
+{
+  gif_source_ptr source = (gif_source_ptr)sinfo;
+  register int c;
+  register JSAMPROW ptr;
+  register JDIMENSION col;
+  register JSAMPARRAY colormap = source->colormap;
+
+  ptr = source->pub.buffer[0];
+  for (col = cinfo->image_width; col > 0; col--) {
+    c = LZWReadByte(source);
+    *ptr++ = colormap[CM_RED][c];
+    *ptr++ = colormap[CM_GREEN][c];
+    *ptr++ = colormap[CM_BLUE][c];
+  }
+  return 1;
+}
+
+
+/*
+ * Read one row of pixels.
+ * This version is used for the first call on get_pixel_rows when
+ * reading an interlaced GIF file: we read the whole image into memory.
+ */
+
+METHODDEF(JDIMENSION)
+load_interlaced_image(j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
+{
+  gif_source_ptr source = (gif_source_ptr)sinfo;
+  register JSAMPROW sptr;
+  register JDIMENSION col;
+  JDIMENSION row;
+  cd_progress_ptr progress = (cd_progress_ptr)cinfo->progress;
+
+  /* Read the interlaced image into the virtual array we've created. */
+  for (row = 0; row < cinfo->image_height; row++) {
+    if (progress != NULL) {
+      progress->pub.pass_counter = (long)row;
+      progress->pub.pass_limit = (long)cinfo->image_height;
+      (*progress->pub.progress_monitor) ((j_common_ptr)cinfo);
+    }
+    sptr = *(*cinfo->mem->access_virt_sarray)
+      ((j_common_ptr)cinfo, source->interlaced_image, row, (JDIMENSION)1,
+       TRUE);
+    for (col = cinfo->image_width; col > 0; col--) {
+      *sptr++ = (JSAMPLE)LZWReadByte(source);
+    }
+  }
+  if (progress != NULL)
+    progress->completed_extra_passes++;
+
+  /* Replace method pointer so subsequent calls don't come here. */
+  source->pub.get_pixel_rows = get_interlaced_row;
+  /* Initialize for get_interlaced_row, and perform first call on it. */
+  source->cur_row_number = 0;
+  source->pass2_offset = (cinfo->image_height + 7) / 8;
+  source->pass3_offset = source->pass2_offset + (cinfo->image_height + 3) / 8;
+  source->pass4_offset = source->pass3_offset + (cinfo->image_height + 1) / 4;
+
+  return get_interlaced_row(cinfo, sinfo);
+}
+
+
+/*
+ * Read one row of pixels.
+ * This version is used for interlaced GIF images:
+ * we read from the virtual array.
+ */
+
+METHODDEF(JDIMENSION)
+get_interlaced_row(j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
+{
+  gif_source_ptr source = (gif_source_ptr)sinfo;
+  register int c;
+  register JSAMPROW sptr, ptr;
+  register JDIMENSION col;
+  register JSAMPARRAY colormap = source->colormap;
+  JDIMENSION irow;
+
+  /* Figure out which row of interlaced image is needed, and access it. */
+  switch ((int)(source->cur_row_number & 7)) {
+  case 0:                       /* first-pass row */
+    irow = source->cur_row_number >> 3;
+    break;
+  case 4:                       /* second-pass row */
+    irow = (source->cur_row_number >> 3) + source->pass2_offset;
+    break;
+  case 2:                       /* third-pass row */
+  case 6:
+    irow = (source->cur_row_number >> 2) + source->pass3_offset;
+    break;
+  default:                      /* fourth-pass row */
+    irow = (source->cur_row_number >> 1) + source->pass4_offset;
+  }
+  sptr = *(*cinfo->mem->access_virt_sarray)
+    ((j_common_ptr)cinfo, source->interlaced_image, irow, (JDIMENSION)1,
+     FALSE);
+  /* Scan the row, expand colormap, and output */
+  ptr = source->pub.buffer[0];
+  for (col = cinfo->image_width; col > 0; col--) {
+    c = *sptr++;
+    *ptr++ = colormap[CM_RED][c];
+    *ptr++ = colormap[CM_GREEN][c];
+    *ptr++ = colormap[CM_BLUE][c];
+  }
+  source->cur_row_number++;     /* for next time */
+  return 1;
+}
+
+
+/*
+ * Finish up at the end of the file.
+ */
+
+METHODDEF(void)
+finish_input_gif(j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
+{
+  /* no work */
+}
+
+
+/*
+ * The module selection routine for GIF format input.
+ */
+
+GLOBAL(cjpeg_source_ptr)
+jinit_read_gif(j_compress_ptr cinfo)
+{
+  gif_source_ptr source;
+
+  /* Create module interface object */
+  source = (gif_source_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+                                sizeof(gif_source_struct));
+  source->cinfo = cinfo;        /* make back link for subroutines */
+  /* Fill in method ptrs, except get_pixel_rows which start_input sets */
+  source->pub.start_input = start_input_gif;
+  source->pub.finish_input = finish_input_gif;
+
+  return (cjpeg_source_ptr)source;
+}
+
+#endif /* GIF_SUPPORTED */
diff --git a/3rdparty/libjpeg/src/rdjpgcom.1 b/3rdparty/libjpeg/src/rdjpgcom.1
new file mode 100644
index 00000000..97611df8
--- /dev/null
+++ b/3rdparty/libjpeg/src/rdjpgcom.1
@@ -0,0 +1,63 @@
+.TH RDJPGCOM 1 "02 April 2009"
+.SH NAME
+rdjpgcom \- display text comments from a JPEG file
+.SH SYNOPSIS
+.B rdjpgcom
+[
+.B \-raw
+]
+[
+.B \-verbose
+]
+[
+.I filename
+]
+.LP
+.SH DESCRIPTION
+.LP
+.B rdjpgcom
+reads the named JPEG/JFIF file, or the standard input if no file is named,
+and prints any text comments found in the file on the standard output.
+.PP
+The JPEG standard allows "comment" (COM) blocks to occur within a JPEG file.
+Although the standard doesn't actually define what COM blocks are for, they
+are widely used to hold user-supplied text strings.  This lets you add
+annotations, titles, index terms, etc to your JPEG files, and later retrieve
+them as text.  COM blocks do not interfere with the image stored in the JPEG
+file.  The maximum size of a COM block is 64K, but you can have as many of
+them as you like in one JPEG file.
+.SH OPTIONS
+.TP
+.B \-raw
+Normally
+.B rdjpgcom
+escapes non-printable characters in comments, for security reasons.
+This option avoids that.
+.PP
+.B \-verbose
+Causes
+.B rdjpgcom
+to also display the JPEG image dimensions.
+.PP
+Switch names may be abbreviated, and are not case sensitive.
+.SH HINTS
+.B rdjpgcom
+does not depend on the IJG JPEG library.  Its source code is intended as an
+illustration of the minimum amount of code required to parse a JPEG file
+header correctly.
+.PP
+In
+.B \-verbose
+mode,
+.B rdjpgcom
+will also attempt to print the contents of any "APP12" markers as text.
+Some digital cameras produce APP12 markers containing useful textual
+information.  If you like, you can modify the source code to print
+other APPn marker types as well.
+.SH SEE ALSO
+.BR cjpeg (1),
+.BR djpeg (1),
+.BR jpegtran (1),
+.BR wrjpgcom (1)
+.SH AUTHOR
+Independent JPEG Group
diff --git a/3rdparty/libjpeg/src/rdjpgcom.c b/3rdparty/libjpeg/src/rdjpgcom.c
new file mode 100644
index 00000000..620270e1
--- /dev/null
+++ b/3rdparty/libjpeg/src/rdjpgcom.c
@@ -0,0 +1,510 @@
+/*
+ * rdjpgcom.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1994-1997, Thomas G. Lane.
+ * Modified 2009 by Bill Allombert, Guido Vollbeding.
+ * It was modified by The libjpeg-turbo Project to include only code relevant
+ * to libjpeg-turbo.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains a very simple stand-alone application that displays
+ * the text in COM (comment) markers in a JFIF file.
+ * This may be useful as an example of the minimum logic needed to parse
+ * JPEG markers.
+ */
+
+#define JPEG_CJPEG_DJPEG        /* to get the command-line config symbols */
+#include "jinclude.h"           /* get auto-config symbols, <stdio.h> */
+
+#ifdef HAVE_LOCALE_H
+#include <locale.h>             /* Bill Allombert: use locale for isprint */
+#endif
+#include <ctype.h>              /* to declare isupper(), tolower() */
+#ifdef USE_SETMODE
+#include <fcntl.h>              /* to declare setmode()'s parameter macros */
+/* If you have setmode() but not <io.h>, just delete this line: */
+#include <io.h>                 /* to declare setmode() */
+#endif
+
+#ifdef USE_CCOMMAND             /* command-line reader for Macintosh */
+#ifdef __MWERKS__
+#include <SIOUX.h>              /* Metrowerks needs this */
+#include <console.h>            /* ... and this */
+#endif
+#ifdef THINK_C
+#include <console.h>            /* Think declares it here */
+#endif
+#endif
+
+#ifdef DONT_USE_B_MODE          /* define mode parameters for fopen() */
+#define READ_BINARY     "r"
+#else
+#define READ_BINARY     "rb"
+#endif
+
+#ifndef EXIT_FAILURE            /* define exit() codes if not provided */
+#define EXIT_FAILURE  1
+#endif
+#ifndef EXIT_SUCCESS
+#define EXIT_SUCCESS  0
+#endif
+
+
+/*
+ * These macros are used to read the input file.
+ * To reuse this code in another application, you might need to change these.
+ */
+
+static FILE *infile;            /* input JPEG file */
+
+/* Return next input byte, or EOF if no more */
+#define NEXTBYTE()  getc(infile)
+
+
+/* Error exit handler */
+#define ERREXIT(msg)  (fprintf(stderr, "%s\n", msg), exit(EXIT_FAILURE))
+
+
+/* Read one byte, testing for EOF */
+static int
+read_1_byte(void)
+{
+  int c;
+
+  c = NEXTBYTE();
+  if (c == EOF)
+    ERREXIT("Premature EOF in JPEG file");
+  return c;
+}
+
+/* Read 2 bytes, convert to unsigned int */
+/* All 2-byte quantities in JPEG markers are MSB first */
+static unsigned int
+read_2_bytes(void)
+{
+  int c1, c2;
+
+  c1 = NEXTBYTE();
+  if (c1 == EOF)
+    ERREXIT("Premature EOF in JPEG file");
+  c2 = NEXTBYTE();
+  if (c2 == EOF)
+    ERREXIT("Premature EOF in JPEG file");
+  return (((unsigned int)c1) << 8) + ((unsigned int)c2);
+}
+
+
+/*
+ * JPEG markers consist of one or more 0xFF bytes, followed by a marker
+ * code byte (which is not an FF).  Here are the marker codes of interest
+ * in this program.  (See jdmarker.c for a more complete list.)
+ */
+
+#define M_SOF0   0xC0           /* Start Of Frame N */
+#define M_SOF1   0xC1           /* N indicates which compression process */
+#define M_SOF2   0xC2           /* Only SOF0-SOF2 are now in common use */
+#define M_SOF3   0xC3
+#define M_SOF5   0xC5           /* NB: codes C4 and CC are NOT SOF markers */
+#define M_SOF6   0xC6
+#define M_SOF7   0xC7
+#define M_SOF9   0xC9
+#define M_SOF10  0xCA
+#define M_SOF11  0xCB
+#define M_SOF13  0xCD
+#define M_SOF14  0xCE
+#define M_SOF15  0xCF
+#define M_SOI    0xD8           /* Start Of Image (beginning of datastream) */
+#define M_EOI    0xD9           /* End Of Image (end of datastream) */
+#define M_SOS    0xDA           /* Start Of Scan (begins compressed data) */
+#define M_APP12  0xEC           /* (we don't bother to list all 16 APPn's) */
+#define M_COM    0xFE           /* COMment */
+
+
+/*
+ * Find the next JPEG marker and return its marker code.
+ * We expect at least one FF byte, possibly more if the compressor used FFs
+ * to pad the file.
+ * There could also be non-FF garbage between markers.  The treatment of such
+ * garbage is unspecified; we choose to skip over it but emit a warning msg.
+ * NB: this routine must not be used after seeing SOS marker, since it will
+ * not deal correctly with FF/00 sequences in the compressed image data...
+ */
+
+static int
+next_marker(void)
+{
+  int c;
+  int discarded_bytes = 0;
+
+  /* Find 0xFF byte; count and skip any non-FFs. */
+  c = read_1_byte();
+  while (c != 0xFF) {
+    discarded_bytes++;
+    c = read_1_byte();
+  }
+  /* Get marker code byte, swallowing any duplicate FF bytes.  Extra FFs
+   * are legal as pad bytes, so don't count them in discarded_bytes.
+   */
+  do {
+    c = read_1_byte();
+  } while (c == 0xFF);
+
+  if (discarded_bytes != 0) {
+    fprintf(stderr, "Warning: garbage data found in JPEG file\n");
+  }
+
+  return c;
+}
+
+
+/*
+ * Read the initial marker, which should be SOI.
+ * For a JFIF file, the first two bytes of the file should be literally
+ * 0xFF M_SOI.  To be more general, we could use next_marker, but if the
+ * input file weren't actually JPEG at all, next_marker might read the whole
+ * file and then return a misleading error message...
+ */
+
+static int
+first_marker(void)
+{
+  int c1, c2;
+
+  c1 = NEXTBYTE();
+  c2 = NEXTBYTE();
+  if (c1 != 0xFF || c2 != M_SOI)
+    ERREXIT("Not a JPEG file");
+  return c2;
+}
+
+
+/*
+ * Most types of marker are followed by a variable-length parameter segment.
+ * This routine skips over the parameters for any marker we don't otherwise
+ * want to process.
+ * Note that we MUST skip the parameter segment explicitly in order not to
+ * be fooled by 0xFF bytes that might appear within the parameter segment;
+ * such bytes do NOT introduce new markers.
+ */
+
+static void
+skip_variable(void)
+/* Skip over an unknown or uninteresting variable-length marker */
+{
+  unsigned int length;
+
+  /* Get the marker parameter length count */
+  length = read_2_bytes();
+  /* Length includes itself, so must be at least 2 */
+  if (length < 2)
+    ERREXIT("Erroneous JPEG marker length");
+  length -= 2;
+  /* Skip over the remaining bytes */
+  while (length > 0) {
+    (void)read_1_byte();
+    length--;
+  }
+}
+
+
+/*
+ * Process a COM marker.
+ * We want to print out the marker contents as legible text;
+ * we must guard against non-text junk and varying newline representations.
+ */
+
+static void
+process_COM(int raw)
+{
+  unsigned int length;
+  int ch;
+  int lastch = 0;
+
+  /* Bill Allombert: set locale properly for isprint */
+#ifdef HAVE_LOCALE_H
+  setlocale(LC_CTYPE, "");
+#endif
+
+  /* Get the marker parameter length count */
+  length = read_2_bytes();
+  /* Length includes itself, so must be at least 2 */
+  if (length < 2)
+    ERREXIT("Erroneous JPEG marker length");
+  length -= 2;
+
+  while (length > 0) {
+    ch = read_1_byte();
+    if (raw) {
+      putc(ch, stdout);
+    /* Emit the character in a readable form.
+     * Nonprintables are converted to \nnn form,
+     * while \ is converted to \\.
+     * Newlines in CR, CR/LF, or LF form will be printed as one newline.
+     */
+    } else if (ch == '\r') {
+      printf("\n");
+    } else if (ch == '\n') {
+      if (lastch != '\r')
+        printf("\n");
+    } else if (ch == '\\') {
+      printf("\\\\");
+    } else if (isprint(ch)) {
+      putc(ch, stdout);
+    } else {
+      printf("\\%03o", ch);
+    }
+    lastch = ch;
+    length--;
+  }
+  printf("\n");
+
+  /* Bill Allombert: revert to C locale */
+#ifdef HAVE_LOCALE_H
+  setlocale(LC_CTYPE, "C");
+#endif
+}
+
+
+/*
+ * Process a SOFn marker.
+ * This code is only needed if you want to know the image dimensions...
+ */
+
+static void
+process_SOFn(int marker)
+{
+  unsigned int length;
+  unsigned int image_height, image_width;
+  int data_precision, num_components;
+  const char *process;
+  int ci;
+
+  length = read_2_bytes();      /* usual parameter length count */
+
+  data_precision = read_1_byte();
+  image_height = read_2_bytes();
+  image_width = read_2_bytes();
+  num_components = read_1_byte();
+
+  switch (marker) {
+  case M_SOF0:  process = "Baseline";  break;
+  case M_SOF1:  process = "Extended sequential";  break;
+  case M_SOF2:  process = "Progressive";  break;
+  case M_SOF3:  process = "Lossless";  break;
+  case M_SOF5:  process = "Differential sequential";  break;
+  case M_SOF6:  process = "Differential progressive";  break;
+  case M_SOF7:  process = "Differential lossless";  break;
+  case M_SOF9:  process = "Extended sequential, arithmetic coding";  break;
+  case M_SOF10: process = "Progressive, arithmetic coding";  break;
+  case M_SOF11: process = "Lossless, arithmetic coding";  break;
+  case M_SOF13: process = "Differential sequential, arithmetic coding";  break;
+  case M_SOF14:
+    process = "Differential progressive, arithmetic coding";  break;
+  case M_SOF15: process = "Differential lossless, arithmetic coding";  break;
+  default:      process = "Unknown";  break;
+  }
+
+  printf("JPEG image is %uw * %uh, %d color components, %d bits per sample\n",
+         image_width, image_height, num_components, data_precision);
+  printf("JPEG process: %s\n", process);
+
+  if (length != (unsigned int)(8 + num_components * 3))
+    ERREXIT("Bogus SOF marker length");
+
+  for (ci = 0; ci < num_components; ci++) {
+    (void)read_1_byte();        /* Component ID code */
+    (void)read_1_byte();        /* H, V sampling factors */
+    (void)read_1_byte();        /* Quantization table number */
+  }
+}
+
+
+/*
+ * Parse the marker stream until SOS or EOI is seen;
+ * display any COM markers.
+ * While the companion program wrjpgcom will always insert COM markers before
+ * SOFn, other implementations might not, so we scan to SOS before stopping.
+ * If we were only interested in the image dimensions, we would stop at SOFn.
+ * (Conversely, if we only cared about COM markers, there would be no need
+ * for special code to handle SOFn; we could treat it like other markers.)
+ */
+
+static int
+scan_JPEG_header(int verbose, int raw)
+{
+  int marker;
+
+  /* Expect SOI at start of file */
+  if (first_marker() != M_SOI)
+    ERREXIT("Expected SOI marker first");
+
+  /* Scan miscellaneous markers until we reach SOS. */
+  for (;;) {
+    marker = next_marker();
+    switch (marker) {
+      /* Note that marker codes 0xC4, 0xC8, 0xCC are not, and must not be,
+       * treated as SOFn.  C4 in particular is actually DHT.
+       */
+    case M_SOF0:                /* Baseline */
+    case M_SOF1:                /* Extended sequential, Huffman */
+    case M_SOF2:                /* Progressive, Huffman */
+    case M_SOF3:                /* Lossless, Huffman */
+    case M_SOF5:                /* Differential sequential, Huffman */
+    case M_SOF6:                /* Differential progressive, Huffman */
+    case M_SOF7:                /* Differential lossless, Huffman */
+    case M_SOF9:                /* Extended sequential, arithmetic */
+    case M_SOF10:               /* Progressive, arithmetic */
+    case M_SOF11:               /* Lossless, arithmetic */
+    case M_SOF13:               /* Differential sequential, arithmetic */
+    case M_SOF14:               /* Differential progressive, arithmetic */
+    case M_SOF15:               /* Differential lossless, arithmetic */
+      if (verbose)
+        process_SOFn(marker);
+      else
+        skip_variable();
+      break;
+
+    case M_SOS:                 /* stop before hitting compressed data */
+      return marker;
+
+    case M_EOI:                 /* in case it's a tables-only JPEG stream */
+      return marker;
+
+    case M_COM:
+      process_COM(raw);
+      break;
+
+    case M_APP12:
+      /* Some digital camera makers put useful textual information into
+       * APP12 markers, so we print those out too when in -verbose mode.
+       */
+      if (verbose) {
+        printf("APP12 contains:\n");
+        process_COM(raw);
+      } else
+        skip_variable();
+      break;
+
+    default:                    /* Anything else just gets skipped */
+      skip_variable();          /* we assume it has a parameter count... */
+      break;
+    }
+  } /* end loop */
+}
+
+
+/* Command line parsing code */
+
+static const char *progname;    /* program name for error messages */
+
+
+static void
+usage(void)
+/* complain about bad command line */
+{
+  fprintf(stderr, "rdjpgcom displays any textual comments in a JPEG file.\n");
+
+  fprintf(stderr, "Usage: %s [switches] [inputfile]\n", progname);
+
+  fprintf(stderr, "Switches (names may be abbreviated):\n");
+  fprintf(stderr, "  -raw        Display non-printable characters in comments (unsafe)\n");
+  fprintf(stderr, "  -verbose    Also display dimensions of JPEG image\n");
+
+  exit(EXIT_FAILURE);
+}
+
+
+static int
+keymatch(char *arg, const char *keyword, int minchars)
+/* Case-insensitive matching of (possibly abbreviated) keyword switches. */
+/* keyword is the constant keyword (must be lower case already), */
+/* minchars is length of minimum legal abbreviation. */
+{
+  register int ca, ck;
+  register int nmatched = 0;
+
+  while ((ca = *arg++) != '\0') {
+    if ((ck = *keyword++) == '\0')
+      return 0;                 /* arg longer than keyword, no good */
+    if (isupper(ca))            /* force arg to lcase (assume ck is already) */
+      ca = tolower(ca);
+    if (ca != ck)
+      return 0;                 /* no good */
+    nmatched++;                 /* count matched characters */
+  }
+  /* reached end of argument; fail if it's too short for unique abbrev */
+  if (nmatched < minchars)
+    return 0;
+  return 1;                     /* A-OK */
+}
+
+
+/*
+ * The main program.
+ */
+
+int
+main(int argc, char **argv)
+{
+  int argn;
+  char *arg;
+  int verbose = 0, raw = 0;
+
+  /* On Mac, fetch a command line. */
+#ifdef USE_CCOMMAND
+  argc = ccommand(&argv);
+#endif
+
+  progname = argv[0];
+  if (progname == NULL || progname[0] == 0)
+    progname = "rdjpgcom";      /* in case C library doesn't provide it */
+
+  /* Parse switches, if any */
+  for (argn = 1; argn < argc; argn++) {
+    arg = argv[argn];
+    if (arg[0] != '-')
+      break;                    /* not switch, must be file name */
+    arg++;                      /* advance over '-' */
+    if (keymatch(arg, "verbose", 1)) {
+      verbose++;
+    } else if (keymatch(arg, "raw", 1)) {
+      raw = 1;
+    } else
+      usage();
+  }
+
+  /* Open the input file. */
+  /* Unix style: expect zero or one file name */
+  if (argn < argc - 1) {
+    fprintf(stderr, "%s: only one input file\n", progname);
+    usage();
+  }
+  if (argn < argc) {
+    if ((infile = fopen(argv[argn], READ_BINARY)) == NULL) {
+      fprintf(stderr, "%s: can't open %s\n", progname, argv[argn]);
+      exit(EXIT_FAILURE);
+    }
+  } else {
+    /* default input file is stdin */
+#ifdef USE_SETMODE              /* need to hack file mode? */
+    setmode(fileno(stdin), O_BINARY);
+#endif
+#ifdef USE_FDOPEN               /* need to re-open in binary mode? */
+    if ((infile = fdopen(fileno(stdin), READ_BINARY)) == NULL) {
+      fprintf(stderr, "%s: can't open stdin\n", progname);
+      exit(EXIT_FAILURE);
+    }
+#else
+    infile = stdin;
+#endif
+  }
+
+  /* Scan the JPEG headers. */
+  (void)scan_JPEG_header(verbose, raw);
+
+  /* All done. */
+  exit(EXIT_SUCCESS);
+  return 0;                     /* suppress no-return-value warnings */
+}
diff --git a/3rdparty/libjpeg/src/rdppm.c b/3rdparty/libjpeg/src/rdppm.c
new file mode 100644
index 00000000..c4c937e8
--- /dev/null
+++ b/3rdparty/libjpeg/src/rdppm.c
@@ -0,0 +1,757 @@
+/*
+ * rdppm.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1991-1997, Thomas G. Lane.
+ * Modified 2009 by Bill Allombert, Guido Vollbeding.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2015-2017, 2020, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains routines to read input images in PPM/PGM format.
+ * The extended 2-byte-per-sample raw PPM/PGM formats are supported.
+ * The PBMPLUS library is NOT required to compile this software
+ * (but it is highly useful as a set of PPM image manipulation programs).
+ *
+ * These routines may need modification for non-Unix environments or
+ * specialized applications.  As they stand, they assume input from
+ * an ordinary stdio stream.  They further assume that reading begins
+ * at the start of the file; start_input may need work if the
+ * user interface has already read some data (e.g., to determine that
+ * the file is indeed PPM format).
+ */
+
+#include "cmyk.h"
+#include "cdjpeg.h"             /* Common decls for cjpeg/djpeg applications */
+
+#ifdef PPM_SUPPORTED
+
+
+/* Portions of this code are based on the PBMPLUS library, which is:
+**
+** Copyright (C) 1988 by Jef Poskanzer.
+**
+** Permission to use, copy, modify, and distribute this software and its
+** documentation for any purpose and without fee is hereby granted, provided
+** that the above copyright notice appear in all copies and that both that
+** copyright notice and this permission notice appear in supporting
+** documentation.  This software is provided "as is" without express or
+** implied warranty.
+*/
+
+
+/* Macros to deal with unsigned chars as efficiently as compiler allows */
+
+typedef unsigned char U_CHAR;
+#define UCH(x)  ((int)(x))
+
+
+#define ReadOK(file, buffer, len) \
+  (JFREAD(file, buffer, len) == ((size_t)(len)))
+
+static int alpha_index[JPEG_NUMCS] = {
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 3, 3, 0, 0, -1
+};
+
+
+/* Private version of data source object */
+
+typedef struct {
+  struct cjpeg_source_struct pub; /* public fields */
+
+  /* Usually these two pointers point to the same place: */
+  U_CHAR *iobuffer;             /* fread's I/O buffer */
+  JSAMPROW pixrow;              /* compressor input buffer */
+  size_t buffer_width;          /* width of I/O buffer */
+  JSAMPLE *rescale;             /* => maxval-remapping array, or NULL */
+  unsigned int maxval;
+} ppm_source_struct;
+
+typedef ppm_source_struct *ppm_source_ptr;
+
+
+LOCAL(int)
+pbm_getc(FILE *infile)
+/* Read next char, skipping over any comments */
+/* A comment/newline sequence is returned as a newline */
+{
+  register int ch;
+
+  ch = getc(infile);
+  if (ch == '#') {
+    do {
+      ch = getc(infile);
+    } while (ch != '\n' && ch != EOF);
+  }
+  return ch;
+}
+
+
+LOCAL(unsigned int)
+read_pbm_integer(j_compress_ptr cinfo, FILE *infile, unsigned int maxval)
+/* Read an unsigned decimal integer from the PPM file */
+/* Swallows one trailing character after the integer */
+/* Note that on a 16-bit-int machine, only values up to 64k can be read. */
+/* This should not be a problem in practice. */
+{
+  register int ch;
+  register unsigned int val;
+
+  /* Skip any leading whitespace */
+  do {
+    ch = pbm_getc(infile);
+    if (ch == EOF)
+      ERREXIT(cinfo, JERR_INPUT_EOF);
+  } while (ch == ' ' || ch == '\t' || ch == '\n' || ch == '\r');
+
+  if (ch < '0' || ch > '9')
+    ERREXIT(cinfo, JERR_PPM_NONNUMERIC);
+
+  val = ch - '0';
+  while ((ch = pbm_getc(infile)) >= '0' && ch <= '9') {
+    val *= 10;
+    val += ch - '0';
+  }
+
+  if (val > maxval)
+    ERREXIT(cinfo, JERR_PPM_OUTOFRANGE);
+
+  return val;
+}
+
+
+/*
+ * Read one row of pixels.
+ *
+ * We provide several different versions depending on input file format.
+ * In all cases, input is scaled to the size of JSAMPLE.
+ *
+ * A really fast path is provided for reading byte/sample raw files with
+ * maxval = MAXJSAMPLE, which is the normal case for 8-bit data.
+ */
+
+
+METHODDEF(JDIMENSION)
+get_text_gray_row(j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
+/* This version is for reading text-format PGM files with any maxval */
+{
+  ppm_source_ptr source = (ppm_source_ptr)sinfo;
+  FILE *infile = source->pub.input_file;
+  register JSAMPROW ptr;
+  register JSAMPLE *rescale = source->rescale;
+  JDIMENSION col;
+  unsigned int maxval = source->maxval;
+
+  ptr = source->pub.buffer[0];
+  for (col = cinfo->image_width; col > 0; col--) {
+    *ptr++ = rescale[read_pbm_integer(cinfo, infile, maxval)];
+  }
+  return 1;
+}
+
+
+#define GRAY_RGB_READ_LOOP(read_op, alpha_set_op) { \
+  for (col = cinfo->image_width; col > 0; col--) { \
+    ptr[rindex] = ptr[gindex] = ptr[bindex] = read_op; \
+    alpha_set_op \
+    ptr += ps; \
+  } \
+}
+
+METHODDEF(JDIMENSION)
+get_text_gray_rgb_row(j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
+/* This version is for reading text-format PGM files with any maxval and
+   converting to extended RGB */
+{
+  ppm_source_ptr source = (ppm_source_ptr)sinfo;
+  FILE *infile = source->pub.input_file;
+  register JSAMPROW ptr;
+  register JSAMPLE *rescale = source->rescale;
+  JDIMENSION col;
+  unsigned int maxval = source->maxval;
+  register int rindex = rgb_red[cinfo->in_color_space];
+  register int gindex = rgb_green[cinfo->in_color_space];
+  register int bindex = rgb_blue[cinfo->in_color_space];
+  register int aindex = alpha_index[cinfo->in_color_space];
+  register int ps = rgb_pixelsize[cinfo->in_color_space];
+
+  ptr = source->pub.buffer[0];
+  if (maxval == MAXJSAMPLE) {
+    if (aindex >= 0)
+      GRAY_RGB_READ_LOOP(read_pbm_integer(cinfo, infile, maxval),
+                         ptr[aindex] = 0xFF;)
+    else
+      GRAY_RGB_READ_LOOP(read_pbm_integer(cinfo, infile, maxval),)
+  } else {
+    if (aindex >= 0)
+      GRAY_RGB_READ_LOOP(rescale[read_pbm_integer(cinfo, infile, maxval)],
+                         ptr[aindex] = 0xFF;)
+    else
+      GRAY_RGB_READ_LOOP(rescale[read_pbm_integer(cinfo, infile, maxval)],)
+  }
+  return 1;
+}
+
+
+METHODDEF(JDIMENSION)
+get_text_gray_cmyk_row(j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
+/* This version is for reading text-format PGM files with any maxval and
+   converting to CMYK */
+{
+  ppm_source_ptr source = (ppm_source_ptr)sinfo;
+  FILE *infile = source->pub.input_file;
+  register JSAMPROW ptr;
+  register JSAMPLE *rescale = source->rescale;
+  JDIMENSION col;
+  unsigned int maxval = source->maxval;
+
+  ptr = source->pub.buffer[0];
+  if (maxval == MAXJSAMPLE) {
+    for (col = cinfo->image_width; col > 0; col--) {
+      JSAMPLE gray = read_pbm_integer(cinfo, infile, maxval);
+      rgb_to_cmyk(gray, gray, gray, ptr, ptr + 1, ptr + 2, ptr + 3);
+      ptr += 4;
+    }
+  } else {
+    for (col = cinfo->image_width; col > 0; col--) {
+      JSAMPLE gray = rescale[read_pbm_integer(cinfo, infile, maxval)];
+      rgb_to_cmyk(gray, gray, gray, ptr, ptr + 1, ptr + 2, ptr + 3);
+      ptr += 4;
+    }
+  }
+  return 1;
+}
+
+
+#define RGB_READ_LOOP(read_op, alpha_set_op) { \
+  for (col = cinfo->image_width; col > 0; col--) { \
+    ptr[rindex] = read_op; \
+    ptr[gindex] = read_op; \
+    ptr[bindex] = read_op; \
+    alpha_set_op \
+    ptr += ps; \
+  } \
+}
+
+METHODDEF(JDIMENSION)
+get_text_rgb_row(j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
+/* This version is for reading text-format PPM files with any maxval */
+{
+  ppm_source_ptr source = (ppm_source_ptr)sinfo;
+  FILE *infile = source->pub.input_file;
+  register JSAMPROW ptr;
+  register JSAMPLE *rescale = source->rescale;
+  JDIMENSION col;
+  unsigned int maxval = source->maxval;
+  register int rindex = rgb_red[cinfo->in_color_space];
+  register int gindex = rgb_green[cinfo->in_color_space];
+  register int bindex = rgb_blue[cinfo->in_color_space];
+  register int aindex = alpha_index[cinfo->in_color_space];
+  register int ps = rgb_pixelsize[cinfo->in_color_space];
+
+  ptr = source->pub.buffer[0];
+  if (maxval == MAXJSAMPLE) {
+    if (aindex >= 0)
+      RGB_READ_LOOP(read_pbm_integer(cinfo, infile, maxval),
+                    ptr[aindex] = 0xFF;)
+    else
+      RGB_READ_LOOP(read_pbm_integer(cinfo, infile, maxval),)
+  } else {
+    if (aindex >= 0)
+      RGB_READ_LOOP(rescale[read_pbm_integer(cinfo, infile, maxval)],
+                    ptr[aindex] = 0xFF;)
+    else
+      RGB_READ_LOOP(rescale[read_pbm_integer(cinfo, infile, maxval)],)
+  }
+  return 1;
+}
+
+
+METHODDEF(JDIMENSION)
+get_text_rgb_cmyk_row(j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
+/* This version is for reading text-format PPM files with any maxval and
+   converting to CMYK */
+{
+  ppm_source_ptr source = (ppm_source_ptr)sinfo;
+  FILE *infile = source->pub.input_file;
+  register JSAMPROW ptr;
+  register JSAMPLE *rescale = source->rescale;
+  JDIMENSION col;
+  unsigned int maxval = source->maxval;
+
+  ptr = source->pub.buffer[0];
+  if (maxval == MAXJSAMPLE) {
+    for (col = cinfo->image_width; col > 0; col--) {
+      JSAMPLE r = read_pbm_integer(cinfo, infile, maxval);
+      JSAMPLE g = read_pbm_integer(cinfo, infile, maxval);
+      JSAMPLE b = read_pbm_integer(cinfo, infile, maxval);
+      rgb_to_cmyk(r, g, b, ptr, ptr + 1, ptr + 2, ptr + 3);
+      ptr += 4;
+    }
+  } else {
+    for (col = cinfo->image_width; col > 0; col--) {
+      JSAMPLE r = rescale[read_pbm_integer(cinfo, infile, maxval)];
+      JSAMPLE g = rescale[read_pbm_integer(cinfo, infile, maxval)];
+      JSAMPLE b = rescale[read_pbm_integer(cinfo, infile, maxval)];
+      rgb_to_cmyk(r, g, b, ptr, ptr + 1, ptr + 2, ptr + 3);
+      ptr += 4;
+    }
+  }
+  return 1;
+}
+
+
+METHODDEF(JDIMENSION)
+get_scaled_gray_row(j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
+/* This version is for reading raw-byte-format PGM files with any maxval */
+{
+  ppm_source_ptr source = (ppm_source_ptr)sinfo;
+  register JSAMPROW ptr;
+  register U_CHAR *bufferptr;
+  register JSAMPLE *rescale = source->rescale;
+  JDIMENSION col;
+
+  if (!ReadOK(source->pub.input_file, source->iobuffer, source->buffer_width))
+    ERREXIT(cinfo, JERR_INPUT_EOF);
+  ptr = source->pub.buffer[0];
+  bufferptr = source->iobuffer;
+  for (col = cinfo->image_width; col > 0; col--) {
+    *ptr++ = rescale[UCH(*bufferptr++)];
+  }
+  return 1;
+}
+
+
+METHODDEF(JDIMENSION)
+get_gray_rgb_row(j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
+/* This version is for reading raw-byte-format PGM files with any maxval
+   and converting to extended RGB */
+{
+  ppm_source_ptr source = (ppm_source_ptr)sinfo;
+  register JSAMPROW ptr;
+  register U_CHAR *bufferptr;
+  register JSAMPLE *rescale = source->rescale;
+  JDIMENSION col;
+  unsigned int maxval = source->maxval;
+  register int rindex = rgb_red[cinfo->in_color_space];
+  register int gindex = rgb_green[cinfo->in_color_space];
+  register int bindex = rgb_blue[cinfo->in_color_space];
+  register int aindex = alpha_index[cinfo->in_color_space];
+  register int ps = rgb_pixelsize[cinfo->in_color_space];
+
+  if (!ReadOK(source->pub.input_file, source->iobuffer, source->buffer_width))
+    ERREXIT(cinfo, JERR_INPUT_EOF);
+  ptr = source->pub.buffer[0];
+  bufferptr = source->iobuffer;
+  if (maxval == MAXJSAMPLE) {
+    if (aindex >= 0)
+      GRAY_RGB_READ_LOOP(*bufferptr++, ptr[aindex] = 0xFF;)
+    else
+      GRAY_RGB_READ_LOOP(*bufferptr++,)
+  } else {
+    if (aindex >= 0)
+      GRAY_RGB_READ_LOOP(rescale[UCH(*bufferptr++)], ptr[aindex] = 0xFF;)
+    else
+      GRAY_RGB_READ_LOOP(rescale[UCH(*bufferptr++)],)
+  }
+  return 1;
+}
+
+
+METHODDEF(JDIMENSION)
+get_gray_cmyk_row(j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
+/* This version is for reading raw-byte-format PGM files with any maxval
+   and converting to CMYK */
+{
+  ppm_source_ptr source = (ppm_source_ptr)sinfo;
+  register JSAMPROW ptr;
+  register U_CHAR *bufferptr;
+  register JSAMPLE *rescale = source->rescale;
+  JDIMENSION col;
+  unsigned int maxval = source->maxval;
+
+  if (!ReadOK(source->pub.input_file, source->iobuffer, source->buffer_width))
+    ERREXIT(cinfo, JERR_INPUT_EOF);
+  ptr = source->pub.buffer[0];
+  bufferptr = source->iobuffer;
+  if (maxval == MAXJSAMPLE) {
+    for (col = cinfo->image_width; col > 0; col--) {
+      JSAMPLE gray = *bufferptr++;
+      rgb_to_cmyk(gray, gray, gray, ptr, ptr + 1, ptr + 2, ptr + 3);
+      ptr += 4;
+    }
+  } else {
+    for (col = cinfo->image_width; col > 0; col--) {
+      JSAMPLE gray = rescale[UCH(*bufferptr++)];
+      rgb_to_cmyk(gray, gray, gray, ptr, ptr + 1, ptr + 2, ptr + 3);
+      ptr += 4;
+    }
+  }
+  return 1;
+}
+
+
+METHODDEF(JDIMENSION)
+get_rgb_row(j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
+/* This version is for reading raw-byte-format PPM files with any maxval */
+{
+  ppm_source_ptr source = (ppm_source_ptr)sinfo;
+  register JSAMPROW ptr;
+  register U_CHAR *bufferptr;
+  register JSAMPLE *rescale = source->rescale;
+  JDIMENSION col;
+  unsigned int maxval = source->maxval;
+  register int rindex = rgb_red[cinfo->in_color_space];
+  register int gindex = rgb_green[cinfo->in_color_space];
+  register int bindex = rgb_blue[cinfo->in_color_space];
+  register int aindex = alpha_index[cinfo->in_color_space];
+  register int ps = rgb_pixelsize[cinfo->in_color_space];
+
+  if (!ReadOK(source->pub.input_file, source->iobuffer, source->buffer_width))
+    ERREXIT(cinfo, JERR_INPUT_EOF);
+  ptr = source->pub.buffer[0];
+  bufferptr = source->iobuffer;
+  if (maxval == MAXJSAMPLE) {
+    if (aindex >= 0)
+      RGB_READ_LOOP(*bufferptr++, ptr[aindex] = 0xFF;)
+    else
+      RGB_READ_LOOP(*bufferptr++,)
+  } else {
+    if (aindex >= 0)
+      RGB_READ_LOOP(rescale[UCH(*bufferptr++)], ptr[aindex] = 0xFF;)
+    else
+      RGB_READ_LOOP(rescale[UCH(*bufferptr++)],)
+  }
+  return 1;
+}
+
+
+METHODDEF(JDIMENSION)
+get_rgb_cmyk_row(j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
+/* This version is for reading raw-byte-format PPM files with any maxval and
+   converting to CMYK */
+{
+  ppm_source_ptr source = (ppm_source_ptr)sinfo;
+  register JSAMPROW ptr;
+  register U_CHAR *bufferptr;
+  register JSAMPLE *rescale = source->rescale;
+  JDIMENSION col;
+  unsigned int maxval = source->maxval;
+
+  if (!ReadOK(source->pub.input_file, source->iobuffer, source->buffer_width))
+    ERREXIT(cinfo, JERR_INPUT_EOF);
+  ptr = source->pub.buffer[0];
+  bufferptr = source->iobuffer;
+  if (maxval == MAXJSAMPLE) {
+    for (col = cinfo->image_width; col > 0; col--) {
+      JSAMPLE r = *bufferptr++;
+      JSAMPLE g = *bufferptr++;
+      JSAMPLE b = *bufferptr++;
+      rgb_to_cmyk(r, g, b, ptr, ptr + 1, ptr + 2, ptr + 3);
+      ptr += 4;
+    }
+  } else {
+    for (col = cinfo->image_width; col > 0; col--) {
+      JSAMPLE r = rescale[UCH(*bufferptr++)];
+      JSAMPLE g = rescale[UCH(*bufferptr++)];
+      JSAMPLE b = rescale[UCH(*bufferptr++)];
+      rgb_to_cmyk(r, g, b, ptr, ptr + 1, ptr + 2, ptr + 3);
+      ptr += 4;
+    }
+  }
+  return 1;
+}
+
+
+METHODDEF(JDIMENSION)
+get_raw_row(j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
+/* This version is for reading raw-byte-format files with maxval = MAXJSAMPLE.
+ * In this case we just read right into the JSAMPLE buffer!
+ * Note that same code works for PPM and PGM files.
+ */
+{
+  ppm_source_ptr source = (ppm_source_ptr)sinfo;
+
+  if (!ReadOK(source->pub.input_file, source->iobuffer, source->buffer_width))
+    ERREXIT(cinfo, JERR_INPUT_EOF);
+  return 1;
+}
+
+
+METHODDEF(JDIMENSION)
+get_word_gray_row(j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
+/* This version is for reading raw-word-format PGM files with any maxval */
+{
+  ppm_source_ptr source = (ppm_source_ptr)sinfo;
+  register JSAMPROW ptr;
+  register U_CHAR *bufferptr;
+  register JSAMPLE *rescale = source->rescale;
+  JDIMENSION col;
+  unsigned int maxval = source->maxval;
+
+  if (!ReadOK(source->pub.input_file, source->iobuffer, source->buffer_width))
+    ERREXIT(cinfo, JERR_INPUT_EOF);
+  ptr = source->pub.buffer[0];
+  bufferptr = source->iobuffer;
+  for (col = cinfo->image_width; col > 0; col--) {
+    register unsigned int temp;
+    temp  = UCH(*bufferptr++) << 8;
+    temp |= UCH(*bufferptr++);
+    if (temp > maxval)
+      ERREXIT(cinfo, JERR_PPM_OUTOFRANGE);
+    *ptr++ = rescale[temp];
+  }
+  return 1;
+}
+
+
+METHODDEF(JDIMENSION)
+get_word_rgb_row(j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
+/* This version is for reading raw-word-format PPM files with any maxval */
+{
+  ppm_source_ptr source = (ppm_source_ptr)sinfo;
+  register JSAMPROW ptr;
+  register U_CHAR *bufferptr;
+  register JSAMPLE *rescale = source->rescale;
+  JDIMENSION col;
+  unsigned int maxval = source->maxval;
+
+  if (!ReadOK(source->pub.input_file, source->iobuffer, source->buffer_width))
+    ERREXIT(cinfo, JERR_INPUT_EOF);
+  ptr = source->pub.buffer[0];
+  bufferptr = source->iobuffer;
+  for (col = cinfo->image_width; col > 0; col--) {
+    register unsigned int temp;
+    temp  = UCH(*bufferptr++) << 8;
+    temp |= UCH(*bufferptr++);
+    if (temp > maxval)
+      ERREXIT(cinfo, JERR_PPM_OUTOFRANGE);
+    *ptr++ = rescale[temp];
+    temp  = UCH(*bufferptr++) << 8;
+    temp |= UCH(*bufferptr++);
+    if (temp > maxval)
+      ERREXIT(cinfo, JERR_PPM_OUTOFRANGE);
+    *ptr++ = rescale[temp];
+    temp  = UCH(*bufferptr++) << 8;
+    temp |= UCH(*bufferptr++);
+    if (temp > maxval)
+      ERREXIT(cinfo, JERR_PPM_OUTOFRANGE);
+    *ptr++ = rescale[temp];
+  }
+  return 1;
+}
+
+
+/*
+ * Read the file header; return image size and component count.
+ */
+
+METHODDEF(void)
+start_input_ppm(j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
+{
+  ppm_source_ptr source = (ppm_source_ptr)sinfo;
+  int c;
+  unsigned int w, h, maxval;
+  boolean need_iobuffer, use_raw_buffer, need_rescale;
+
+  if (getc(source->pub.input_file) != 'P')
+    ERREXIT(cinfo, JERR_PPM_NOT);
+
+  c = getc(source->pub.input_file); /* subformat discriminator character */
+
+  /* detect unsupported variants (ie, PBM) before trying to read header */
+  switch (c) {
+  case '2':                     /* it's a text-format PGM file */
+  case '3':                     /* it's a text-format PPM file */
+  case '5':                     /* it's a raw-format PGM file */
+  case '6':                     /* it's a raw-format PPM file */
+    break;
+  default:
+    ERREXIT(cinfo, JERR_PPM_NOT);
+    break;
+  }
+
+  /* fetch the remaining header info */
+  w = read_pbm_integer(cinfo, source->pub.input_file, 65535);
+  h = read_pbm_integer(cinfo, source->pub.input_file, 65535);
+  maxval = read_pbm_integer(cinfo, source->pub.input_file, 65535);
+
+  if (w <= 0 || h <= 0 || maxval <= 0) /* error check */
+    ERREXIT(cinfo, JERR_PPM_NOT);
+
+  cinfo->data_precision = BITS_IN_JSAMPLE; /* we always rescale data to this */
+  cinfo->image_width = (JDIMENSION)w;
+  cinfo->image_height = (JDIMENSION)h;
+  source->maxval = maxval;
+
+  /* initialize flags to most common settings */
+  need_iobuffer = TRUE;         /* do we need an I/O buffer? */
+  use_raw_buffer = FALSE;       /* do we map input buffer onto I/O buffer? */
+  need_rescale = TRUE;          /* do we need a rescale array? */
+
+  switch (c) {
+  case '2':                     /* it's a text-format PGM file */
+    if (cinfo->in_color_space == JCS_UNKNOWN)
+      cinfo->in_color_space = JCS_GRAYSCALE;
+    TRACEMS2(cinfo, 1, JTRC_PGM_TEXT, w, h);
+    if (cinfo->in_color_space == JCS_GRAYSCALE)
+      source->pub.get_pixel_rows = get_text_gray_row;
+    else if (IsExtRGB(cinfo->in_color_space))
+      source->pub.get_pixel_rows = get_text_gray_rgb_row;
+    else if (cinfo->in_color_space == JCS_CMYK)
+      source->pub.get_pixel_rows = get_text_gray_cmyk_row;
+    else
+      ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE);
+    need_iobuffer = FALSE;
+    break;
+
+  case '3':                     /* it's a text-format PPM file */
+    if (cinfo->in_color_space == JCS_UNKNOWN)
+      cinfo->in_color_space = JCS_EXT_RGB;
+    TRACEMS2(cinfo, 1, JTRC_PPM_TEXT, w, h);
+    if (IsExtRGB(cinfo->in_color_space))
+      source->pub.get_pixel_rows = get_text_rgb_row;
+    else if (cinfo->in_color_space == JCS_CMYK)
+      source->pub.get_pixel_rows = get_text_rgb_cmyk_row;
+    else
+      ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE);
+    need_iobuffer = FALSE;
+    break;
+
+  case '5':                     /* it's a raw-format PGM file */
+    if (cinfo->in_color_space == JCS_UNKNOWN)
+      cinfo->in_color_space = JCS_GRAYSCALE;
+    TRACEMS2(cinfo, 1, JTRC_PGM, w, h);
+    if (maxval > 255) {
+      source->pub.get_pixel_rows = get_word_gray_row;
+    } else if (maxval == MAXJSAMPLE && sizeof(JSAMPLE) == sizeof(U_CHAR) &&
+               cinfo->in_color_space == JCS_GRAYSCALE) {
+      source->pub.get_pixel_rows = get_raw_row;
+      use_raw_buffer = TRUE;
+      need_rescale = FALSE;
+    } else {
+      if (cinfo->in_color_space == JCS_GRAYSCALE)
+        source->pub.get_pixel_rows = get_scaled_gray_row;
+      else if (IsExtRGB(cinfo->in_color_space))
+        source->pub.get_pixel_rows = get_gray_rgb_row;
+      else if (cinfo->in_color_space == JCS_CMYK)
+        source->pub.get_pixel_rows = get_gray_cmyk_row;
+      else
+        ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE);
+    }
+    break;
+
+  case '6':                     /* it's a raw-format PPM file */
+    if (cinfo->in_color_space == JCS_UNKNOWN)
+      cinfo->in_color_space = JCS_EXT_RGB;
+    TRACEMS2(cinfo, 1, JTRC_PPM, w, h);
+    if (maxval > 255) {
+      source->pub.get_pixel_rows = get_word_rgb_row;
+    } else if (maxval == MAXJSAMPLE && sizeof(JSAMPLE) == sizeof(U_CHAR) &&
+#if RGB_RED == 0 && RGB_GREEN == 1 && RGB_BLUE == 2 && RGB_PIXELSIZE == 3
+               (cinfo->in_color_space == JCS_EXT_RGB ||
+                cinfo->in_color_space == JCS_RGB)) {
+#else
+               cinfo->in_color_space == JCS_EXT_RGB) {
+#endif
+      source->pub.get_pixel_rows = get_raw_row;
+      use_raw_buffer = TRUE;
+      need_rescale = FALSE;
+    } else {
+      if (IsExtRGB(cinfo->in_color_space))
+        source->pub.get_pixel_rows = get_rgb_row;
+      else if (cinfo->in_color_space == JCS_CMYK)
+        source->pub.get_pixel_rows = get_rgb_cmyk_row;
+      else
+        ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE);
+    }
+    break;
+  }
+
+  if (IsExtRGB(cinfo->in_color_space))
+    cinfo->input_components = rgb_pixelsize[cinfo->in_color_space];
+  else if (cinfo->in_color_space == JCS_GRAYSCALE)
+    cinfo->input_components = 1;
+  else if (cinfo->in_color_space == JCS_CMYK)
+    cinfo->input_components = 4;
+
+  /* Allocate space for I/O buffer: 1 or 3 bytes or words/pixel. */
+  if (need_iobuffer) {
+    if (c == '6')
+      source->buffer_width = (size_t)w * 3 *
+        ((maxval <= 255) ? sizeof(U_CHAR) : (2 * sizeof(U_CHAR)));
+    else
+      source->buffer_width = (size_t)w *
+        ((maxval <= 255) ? sizeof(U_CHAR) : (2 * sizeof(U_CHAR)));
+    source->iobuffer = (U_CHAR *)
+      (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+                                  source->buffer_width);
+  }
+
+  /* Create compressor input buffer. */
+  if (use_raw_buffer) {
+    /* For unscaled raw-input case, we can just map it onto the I/O buffer. */
+    /* Synthesize a JSAMPARRAY pointer structure */
+    source->pixrow = (JSAMPROW)source->iobuffer;
+    source->pub.buffer = &source->pixrow;
+    source->pub.buffer_height = 1;
+  } else {
+    /* Need to translate anyway, so make a separate sample buffer. */
+    source->pub.buffer = (*cinfo->mem->alloc_sarray)
+      ((j_common_ptr)cinfo, JPOOL_IMAGE,
+       (JDIMENSION)w * cinfo->input_components, (JDIMENSION)1);
+    source->pub.buffer_height = 1;
+  }
+
+  /* Compute the rescaling array if required. */
+  if (need_rescale) {
+    long val, half_maxval;
+
+    /* On 16-bit-int machines we have to be careful of maxval = 65535 */
+    source->rescale = (JSAMPLE *)
+      (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+                                  (size_t)(((long)MAX(maxval, 255) + 1L) *
+                                           sizeof(JSAMPLE)));
+    half_maxval = maxval / 2;
+    for (val = 0; val <= (long)maxval; val++) {
+      /* The multiplication here must be done in 32 bits to avoid overflow */
+      source->rescale[val] = (JSAMPLE)((val * MAXJSAMPLE + half_maxval) /
+                                        maxval);
+    }
+  }
+}
+
+
+/*
+ * Finish up at the end of the file.
+ */
+
+METHODDEF(void)
+finish_input_ppm(j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
+{
+  /* no work */
+}
+
+
+/*
+ * The module selection routine for PPM format input.
+ */
+
+GLOBAL(cjpeg_source_ptr)
+jinit_read_ppm(j_compress_ptr cinfo)
+{
+  ppm_source_ptr source;
+
+  /* Create module interface object */
+  source = (ppm_source_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+                                sizeof(ppm_source_struct));
+  /* Fill in method ptrs, except get_pixel_rows which start_input sets */
+  source->pub.start_input = start_input_ppm;
+  source->pub.finish_input = finish_input_ppm;
+
+  return (cjpeg_source_ptr)source;
+}
+
+#endif /* PPM_SUPPORTED */
diff --git a/3rdparty/libjpeg/src/rdswitch.c b/3rdparty/libjpeg/src/rdswitch.c
new file mode 100644
index 00000000..886fec39
--- /dev/null
+++ b/3rdparty/libjpeg/src/rdswitch.c
@@ -0,0 +1,424 @@
+/*
+ * rdswitch.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1991-1996, Thomas G. Lane.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2010, 2018, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains routines to process some of cjpeg's more complicated
+ * command-line switches.  Switches processed here are:
+ *      -qtables file           Read quantization tables from text file
+ *      -scans file             Read scan script from text file
+ *      -quality N[,N,...]      Set quality ratings
+ *      -qslots N[,N,...]       Set component quantization table selectors
+ *      -sample HxV[,HxV,...]   Set component sampling factors
+ */
+
+#include "cdjpeg.h"             /* Common decls for cjpeg/djpeg applications */
+#include <ctype.h>              /* to declare isdigit(), isspace() */
+
+
+LOCAL(int)
+text_getc(FILE *file)
+/* Read next char, skipping over any comments (# to end of line) */
+/* A comment/newline sequence is returned as a newline */
+{
+  register int ch;
+
+  ch = getc(file);
+  if (ch == '#') {
+    do {
+      ch = getc(file);
+    } while (ch != '\n' && ch != EOF);
+  }
+  return ch;
+}
+
+
+LOCAL(boolean)
+read_text_integer(FILE *file, long *result, int *termchar)
+/* Read an unsigned decimal integer from a file, store it in result */
+/* Reads one trailing character after the integer; returns it in termchar */
+{
+  register int ch;
+  register long val;
+
+  /* Skip any leading whitespace, detect EOF */
+  do {
+    ch = text_getc(file);
+    if (ch == EOF) {
+      *termchar = ch;
+      return FALSE;
+    }
+  } while (isspace(ch));
+
+  if (!isdigit(ch)) {
+    *termchar = ch;
+    return FALSE;
+  }
+
+  val = ch - '0';
+  while ((ch = text_getc(file)) != EOF) {
+    if (!isdigit(ch))
+      break;
+    val *= 10;
+    val += ch - '0';
+  }
+  *result = val;
+  *termchar = ch;
+  return TRUE;
+}
+
+
+#if JPEG_LIB_VERSION < 70
+static int q_scale_factor[NUM_QUANT_TBLS] = { 100, 100, 100, 100 };
+#endif
+
+GLOBAL(boolean)
+read_quant_tables(j_compress_ptr cinfo, char *filename, boolean force_baseline)
+/* Read a set of quantization tables from the specified file.
+ * The file is plain ASCII text: decimal numbers with whitespace between.
+ * Comments preceded by '#' may be included in the file.
+ * There may be one to NUM_QUANT_TBLS tables in the file, each of 64 values.
+ * The tables are implicitly numbered 0,1,etc.
+ * NOTE: does not affect the qslots mapping, which will default to selecting
+ * table 0 for luminance (or primary) components, 1 for chrominance components.
+ * You must use -qslots if you want a different component->table mapping.
+ */
+{
+  FILE *fp;
+  int tblno, i, termchar;
+  long val;
+  unsigned int table[DCTSIZE2];
+
+  if ((fp = fopen(filename, "r")) == NULL) {
+    fprintf(stderr, "Can't open table file %s\n", filename);
+    return FALSE;
+  }
+  tblno = 0;
+
+  while (read_text_integer(fp, &val, &termchar)) { /* read 1st element of table */
+    if (tblno >= NUM_QUANT_TBLS) {
+      fprintf(stderr, "Too many tables in file %s\n", filename);
+      fclose(fp);
+      return FALSE;
+    }
+    table[0] = (unsigned int)val;
+    for (i = 1; i < DCTSIZE2; i++) {
+      if (!read_text_integer(fp, &val, &termchar)) {
+        fprintf(stderr, "Invalid table data in file %s\n", filename);
+        fclose(fp);
+        return FALSE;
+      }
+      table[i] = (unsigned int)val;
+    }
+#if JPEG_LIB_VERSION >= 70
+    jpeg_add_quant_table(cinfo, tblno, table, cinfo->q_scale_factor[tblno],
+                         force_baseline);
+#else
+    jpeg_add_quant_table(cinfo, tblno, table, q_scale_factor[tblno],
+                         force_baseline);
+#endif
+    tblno++;
+  }
+
+  if (termchar != EOF) {
+    fprintf(stderr, "Non-numeric data in file %s\n", filename);
+    fclose(fp);
+    return FALSE;
+  }
+
+  fclose(fp);
+  return TRUE;
+}
+
+
+#ifdef C_MULTISCAN_FILES_SUPPORTED
+
+LOCAL(boolean)
+read_scan_integer(FILE *file, long *result, int *termchar)
+/* Variant of read_text_integer that always looks for a non-space termchar;
+ * this simplifies parsing of punctuation in scan scripts.
+ */
+{
+  register int ch;
+
+  if (!read_text_integer(file, result, termchar))
+    return FALSE;
+  ch = *termchar;
+  while (ch != EOF && isspace(ch))
+    ch = text_getc(file);
+  if (isdigit(ch)) {            /* oops, put it back */
+    if (ungetc(ch, file) == EOF)
+      return FALSE;
+    ch = ' ';
+  } else {
+    /* Any separators other than ';' and ':' are ignored;
+     * this allows user to insert commas, etc, if desired.
+     */
+    if (ch != EOF && ch != ';' && ch != ':')
+      ch = ' ';
+  }
+  *termchar = ch;
+  return TRUE;
+}
+
+
+GLOBAL(boolean)
+read_scan_script(j_compress_ptr cinfo, char *filename)
+/* Read a scan script from the specified text file.
+ * Each entry in the file defines one scan to be emitted.
+ * Entries are separated by semicolons ';'.
+ * An entry contains one to four component indexes,
+ * optionally followed by a colon ':' and four progressive-JPEG parameters.
+ * The component indexes denote which component(s) are to be transmitted
+ * in the current scan.  The first component has index 0.
+ * Sequential JPEG is used if the progressive-JPEG parameters are omitted.
+ * The file is free format text: any whitespace may appear between numbers
+ * and the ':' and ';' punctuation marks.  Also, other punctuation (such
+ * as commas or dashes) can be placed between numbers if desired.
+ * Comments preceded by '#' may be included in the file.
+ * Note: we do very little validity checking here;
+ * jcmaster.c will validate the script parameters.
+ */
+{
+  FILE *fp;
+  int scanno, ncomps, termchar;
+  long val;
+  jpeg_scan_info *scanptr;
+#define MAX_SCANS  100          /* quite arbitrary limit */
+  jpeg_scan_info scans[MAX_SCANS];
+
+  if ((fp = fopen(filename, "r")) == NULL) {
+    fprintf(stderr, "Can't open scan definition file %s\n", filename);
+    return FALSE;
+  }
+  scanptr = scans;
+  scanno = 0;
+
+  while (read_scan_integer(fp, &val, &termchar)) {
+    if (scanno >= MAX_SCANS) {
+      fprintf(stderr, "Too many scans defined in file %s\n", filename);
+      fclose(fp);
+      return FALSE;
+    }
+    scanptr->component_index[0] = (int)val;
+    ncomps = 1;
+    while (termchar == ' ') {
+      if (ncomps >= MAX_COMPS_IN_SCAN) {
+        fprintf(stderr, "Too many components in one scan in file %s\n",
+                filename);
+        fclose(fp);
+        return FALSE;
+      }
+      if (!read_scan_integer(fp, &val, &termchar))
+        goto bogus;
+      scanptr->component_index[ncomps] = (int)val;
+      ncomps++;
+    }
+    scanptr->comps_in_scan = ncomps;
+    if (termchar == ':') {
+      if (!read_scan_integer(fp, &val, &termchar) || termchar != ' ')
+        goto bogus;
+      scanptr->Ss = (int)val;
+      if (!read_scan_integer(fp, &val, &termchar) || termchar != ' ')
+        goto bogus;
+      scanptr->Se = (int)val;
+      if (!read_scan_integer(fp, &val, &termchar) || termchar != ' ')
+        goto bogus;
+      scanptr->Ah = (int)val;
+      if (!read_scan_integer(fp, &val, &termchar))
+        goto bogus;
+      scanptr->Al = (int)val;
+    } else {
+      /* set non-progressive parameters */
+      scanptr->Ss = 0;
+      scanptr->Se = DCTSIZE2 - 1;
+      scanptr->Ah = 0;
+      scanptr->Al = 0;
+    }
+    if (termchar != ';' && termchar != EOF) {
+bogus:
+      fprintf(stderr, "Invalid scan entry format in file %s\n", filename);
+      fclose(fp);
+      return FALSE;
+    }
+    scanptr++, scanno++;
+  }
+
+  if (termchar != EOF) {
+    fprintf(stderr, "Non-numeric data in file %s\n", filename);
+    fclose(fp);
+    return FALSE;
+  }
+
+  if (scanno > 0) {
+    /* Stash completed scan list in cinfo structure.
+     * NOTE: for cjpeg's use, JPOOL_IMAGE is the right lifetime for this data,
+     * but if you want to compress multiple images you'd want JPOOL_PERMANENT.
+     */
+    scanptr = (jpeg_scan_info *)
+      (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+                                  scanno * sizeof(jpeg_scan_info));
+    MEMCOPY(scanptr, scans, scanno * sizeof(jpeg_scan_info));
+    cinfo->scan_info = scanptr;
+    cinfo->num_scans = scanno;
+  }
+
+  fclose(fp);
+  return TRUE;
+}
+
+#endif /* C_MULTISCAN_FILES_SUPPORTED */
+
+
+#if JPEG_LIB_VERSION < 70
+/* These are the sample quantization tables given in Annex K (Clause K.1) of
+ * Recommendation ITU-T T.81 (1992) | ISO/IEC 10918-1:1994.
+ * The spec says that the values given produce "good" quality, and
+ * when divided by 2, "very good" quality.
+ */
+static const unsigned int std_luminance_quant_tbl[DCTSIZE2] = {
+  16,  11,  10,  16,  24,  40,  51,  61,
+  12,  12,  14,  19,  26,  58,  60,  55,
+  14,  13,  16,  24,  40,  57,  69,  56,
+  14,  17,  22,  29,  51,  87,  80,  62,
+  18,  22,  37,  56,  68, 109, 103,  77,
+  24,  35,  55,  64,  81, 104, 113,  92,
+  49,  64,  78,  87, 103, 121, 120, 101,
+  72,  92,  95,  98, 112, 100, 103,  99
+};
+static const unsigned int std_chrominance_quant_tbl[DCTSIZE2] = {
+  17,  18,  24,  47,  99,  99,  99,  99,
+  18,  21,  26,  66,  99,  99,  99,  99,
+  24,  26,  56,  99,  99,  99,  99,  99,
+  47,  66,  99,  99,  99,  99,  99,  99,
+  99,  99,  99,  99,  99,  99,  99,  99,
+  99,  99,  99,  99,  99,  99,  99,  99,
+  99,  99,  99,  99,  99,  99,  99,  99,
+  99,  99,  99,  99,  99,  99,  99,  99
+};
+
+
+LOCAL(void)
+jpeg_default_qtables(j_compress_ptr cinfo, boolean force_baseline)
+{
+  jpeg_add_quant_table(cinfo, 0, std_luminance_quant_tbl, q_scale_factor[0],
+                       force_baseline);
+  jpeg_add_quant_table(cinfo, 1, std_chrominance_quant_tbl, q_scale_factor[1],
+                       force_baseline);
+}
+#endif
+
+
+GLOBAL(boolean)
+set_quality_ratings(j_compress_ptr cinfo, char *arg, boolean force_baseline)
+/* Process a quality-ratings parameter string, of the form
+ *     N[,N,...]
+ * If there are more q-table slots than parameters, the last value is replicated.
+ */
+{
+  int val = 75;                 /* default value */
+  int tblno;
+  char ch;
+
+  for (tblno = 0; tblno < NUM_QUANT_TBLS; tblno++) {
+    if (*arg) {
+      ch = ',';                 /* if not set by sscanf, will be ',' */
+      if (sscanf(arg, "%d%c", &val, &ch) < 1)
+        return FALSE;
+      if (ch != ',')            /* syntax check */
+        return FALSE;
+      /* Convert user 0-100 rating to percentage scaling */
+#if JPEG_LIB_VERSION >= 70
+      cinfo->q_scale_factor[tblno] = jpeg_quality_scaling(val);
+#else
+      q_scale_factor[tblno] = jpeg_quality_scaling(val);
+#endif
+      while (*arg && *arg++ != ','); /* advance to next segment of arg
+                                        string */
+    } else {
+      /* reached end of parameter, set remaining factors to last value */
+#if JPEG_LIB_VERSION >= 70
+      cinfo->q_scale_factor[tblno] = jpeg_quality_scaling(val);
+#else
+      q_scale_factor[tblno] = jpeg_quality_scaling(val);
+#endif
+    }
+  }
+  jpeg_default_qtables(cinfo, force_baseline);
+  return TRUE;
+}
+
+
+GLOBAL(boolean)
+set_quant_slots(j_compress_ptr cinfo, char *arg)
+/* Process a quantization-table-selectors parameter string, of the form
+ *     N[,N,...]
+ * If there are more components than parameters, the last value is replicated.
+ */
+{
+  int val = 0;                  /* default table # */
+  int ci;
+  char ch;
+
+  for (ci = 0; ci < MAX_COMPONENTS; ci++) {
+    if (*arg) {
+      ch = ',';                 /* if not set by sscanf, will be ',' */
+      if (sscanf(arg, "%d%c", &val, &ch) < 1)
+        return FALSE;
+      if (ch != ',')            /* syntax check */
+        return FALSE;
+      if (val < 0 || val >= NUM_QUANT_TBLS) {
+        fprintf(stderr, "JPEG quantization tables are numbered 0..%d\n",
+                NUM_QUANT_TBLS - 1);
+        return FALSE;
+      }
+      cinfo->comp_info[ci].quant_tbl_no = val;
+      while (*arg && *arg++ != ','); /* advance to next segment of arg
+                                        string */
+    } else {
+      /* reached end of parameter, set remaining components to last table */
+      cinfo->comp_info[ci].quant_tbl_no = val;
+    }
+  }
+  return TRUE;
+}
+
+
+GLOBAL(boolean)
+set_sample_factors(j_compress_ptr cinfo, char *arg)
+/* Process a sample-factors parameter string, of the form
+ *     HxV[,HxV,...]
+ * If there are more components than parameters, "1x1" is assumed for the rest.
+ */
+{
+  int ci, val1, val2;
+  char ch1, ch2;
+
+  for (ci = 0; ci < MAX_COMPONENTS; ci++) {
+    if (*arg) {
+      ch2 = ',';                /* if not set by sscanf, will be ',' */
+      if (sscanf(arg, "%d%c%d%c", &val1, &ch1, &val2, &ch2) < 3)
+        return FALSE;
+      if ((ch1 != 'x' && ch1 != 'X') || ch2 != ',') /* syntax check */
+        return FALSE;
+      if (val1 <= 0 || val1 > 4 || val2 <= 0 || val2 > 4) {
+        fprintf(stderr, "JPEG sampling factors must be 1..4\n");
+        return FALSE;
+      }
+      cinfo->comp_info[ci].h_samp_factor = val1;
+      cinfo->comp_info[ci].v_samp_factor = val2;
+      while (*arg && *arg++ != ',');  /* advance to next segment of arg
+                                         string */
+    } else {
+      /* reached end of parameter, set remaining components to 1x1 sampling */
+      cinfo->comp_info[ci].h_samp_factor = 1;
+      cinfo->comp_info[ci].v_samp_factor = 1;
+    }
+  }
+  return TRUE;
+}
diff --git a/3rdparty/libjpeg/src/rdtarga.c b/3rdparty/libjpeg/src/rdtarga.c
new file mode 100644
index 00000000..c17073f5
--- /dev/null
+++ b/3rdparty/libjpeg/src/rdtarga.c
@@ -0,0 +1,500 @@
+/*
+ * rdtarga.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1991-1996, Thomas G. Lane.
+ * Modified 2017 by Guido Vollbeding.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2018, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains routines to read input images in Targa format.
+ *
+ * These routines may need modification for non-Unix environments or
+ * specialized applications.  As they stand, they assume input from
+ * an ordinary stdio stream.  They further assume that reading begins
+ * at the start of the file; start_input may need work if the
+ * user interface has already read some data (e.g., to determine that
+ * the file is indeed Targa format).
+ *
+ * Based on code contributed by Lee Daniel Crocker.
+ */
+
+#include "cdjpeg.h"             /* Common decls for cjpeg/djpeg applications */
+
+#ifdef TARGA_SUPPORTED
+
+
+/* Macros to deal with unsigned chars as efficiently as compiler allows */
+
+typedef unsigned char U_CHAR;
+#define UCH(x)  ((int)(x))
+
+
+#define ReadOK(file, buffer, len) \
+  (JFREAD(file, buffer, len) == ((size_t)(len)))
+
+
+/* Private version of data source object */
+
+typedef struct _tga_source_struct *tga_source_ptr;
+
+typedef struct _tga_source_struct {
+  struct cjpeg_source_struct pub; /* public fields */
+
+  j_compress_ptr cinfo;         /* back link saves passing separate parm */
+
+  JSAMPARRAY colormap;          /* Targa colormap (converted to my format) */
+
+  jvirt_sarray_ptr whole_image; /* Needed if funny input row order */
+  JDIMENSION current_row;       /* Current logical row number to read */
+
+  /* Pointer to routine to extract next Targa pixel from input file */
+  void (*read_pixel) (tga_source_ptr sinfo);
+
+  /* Result of read_pixel is delivered here: */
+  U_CHAR tga_pixel[4];
+
+  int pixel_size;               /* Bytes per Targa pixel (1 to 4) */
+  int cmap_length;              /* colormap length */
+
+  /* State info for reading RLE-coded pixels; both counts must be init to 0 */
+  int block_count;              /* # of pixels remaining in RLE block */
+  int dup_pixel_count;          /* # of times to duplicate previous pixel */
+
+  /* This saves the correct pixel-row-expansion method for preload_image */
+  JDIMENSION (*get_pixel_rows) (j_compress_ptr cinfo, cjpeg_source_ptr sinfo);
+} tga_source_struct;
+
+
+/* For expanding 5-bit pixel values to 8-bit with best rounding */
+
+static const UINT8 c5to8bits[32] = {
+    0,   8,  16,  25,  33,  41,  49,  58,
+   66,  74,  82,  90,  99, 107, 115, 123,
+  132, 140, 148, 156, 165, 173, 181, 189,
+  197, 206, 214, 222, 230, 239, 247, 255
+};
+
+
+
+LOCAL(int)
+read_byte(tga_source_ptr sinfo)
+/* Read next byte from Targa file */
+{
+  register FILE *infile = sinfo->pub.input_file;
+  register int c;
+
+  if ((c = getc(infile)) == EOF)
+    ERREXIT(sinfo->cinfo, JERR_INPUT_EOF);
+  return c;
+}
+
+
+LOCAL(void)
+read_colormap(tga_source_ptr sinfo, int cmaplen, int mapentrysize)
+/* Read the colormap from a Targa file */
+{
+  int i;
+
+  /* Presently only handles 24-bit BGR format */
+  if (mapentrysize != 24)
+    ERREXIT(sinfo->cinfo, JERR_TGA_BADCMAP);
+
+  for (i = 0; i < cmaplen; i++) {
+    sinfo->colormap[2][i] = (JSAMPLE)read_byte(sinfo);
+    sinfo->colormap[1][i] = (JSAMPLE)read_byte(sinfo);
+    sinfo->colormap[0][i] = (JSAMPLE)read_byte(sinfo);
+  }
+}
+
+
+/*
+ * read_pixel methods: get a single pixel from Targa file into tga_pixel[]
+ */
+
+METHODDEF(void)
+read_non_rle_pixel(tga_source_ptr sinfo)
+/* Read one Targa pixel from the input file; no RLE expansion */
+{
+  register int i;
+
+  for (i = 0; i < sinfo->pixel_size; i++) {
+    sinfo->tga_pixel[i] = (U_CHAR)read_byte(sinfo);
+  }
+}
+
+
+METHODDEF(void)
+read_rle_pixel(tga_source_ptr sinfo)
+/* Read one Targa pixel from the input file, expanding RLE data as needed */
+{
+  register int i;
+
+  /* Duplicate previously read pixel? */
+  if (sinfo->dup_pixel_count > 0) {
+    sinfo->dup_pixel_count--;
+    return;
+  }
+
+  /* Time to read RLE block header? */
+  if (--sinfo->block_count < 0) { /* decrement pixels remaining in block */
+    i = read_byte(sinfo);
+    if (i & 0x80) {             /* Start of duplicate-pixel block? */
+      sinfo->dup_pixel_count = i & 0x7F; /* number of dups after this one */
+      sinfo->block_count = 0;   /* then read new block header */
+    } else {
+      sinfo->block_count = i & 0x7F; /* number of pixels after this one */
+    }
+  }
+
+  /* Read next pixel */
+  for (i = 0; i < sinfo->pixel_size; i++) {
+    sinfo->tga_pixel[i] = (U_CHAR)read_byte(sinfo);
+  }
+}
+
+
+/*
+ * Read one row of pixels.
+ *
+ * We provide several different versions depending on input file format.
+ */
+
+
+METHODDEF(JDIMENSION)
+get_8bit_gray_row(j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
+/* This version is for reading 8-bit grayscale pixels */
+{
+  tga_source_ptr source = (tga_source_ptr)sinfo;
+  register JSAMPROW ptr;
+  register JDIMENSION col;
+
+  ptr = source->pub.buffer[0];
+  for (col = cinfo->image_width; col > 0; col--) {
+    (*source->read_pixel) (source); /* Load next pixel into tga_pixel */
+    *ptr++ = (JSAMPLE)UCH(source->tga_pixel[0]);
+  }
+  return 1;
+}
+
+METHODDEF(JDIMENSION)
+get_8bit_row(j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
+/* This version is for reading 8-bit colormap indexes */
+{
+  tga_source_ptr source = (tga_source_ptr)sinfo;
+  register int t;
+  register JSAMPROW ptr;
+  register JDIMENSION col;
+  register JSAMPARRAY colormap = source->colormap;
+  int cmaplen = source->cmap_length;
+
+  ptr = source->pub.buffer[0];
+  for (col = cinfo->image_width; col > 0; col--) {
+    (*source->read_pixel) (source); /* Load next pixel into tga_pixel */
+    t = UCH(source->tga_pixel[0]);
+    if (t >= cmaplen)
+      ERREXIT(cinfo, JERR_TGA_BADPARMS);
+    *ptr++ = colormap[0][t];
+    *ptr++ = colormap[1][t];
+    *ptr++ = colormap[2][t];
+  }
+  return 1;
+}
+
+METHODDEF(JDIMENSION)
+get_16bit_row(j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
+/* This version is for reading 16-bit pixels */
+{
+  tga_source_ptr source = (tga_source_ptr)sinfo;
+  register int t;
+  register JSAMPROW ptr;
+  register JDIMENSION col;
+
+  ptr = source->pub.buffer[0];
+  for (col = cinfo->image_width; col > 0; col--) {
+    (*source->read_pixel) (source); /* Load next pixel into tga_pixel */
+    t = UCH(source->tga_pixel[0]);
+    t += UCH(source->tga_pixel[1]) << 8;
+    /* We expand 5 bit data to 8 bit sample width.
+     * The format of the 16-bit (LSB first) input word is
+     *     xRRRRRGGGGGBBBBB
+     */
+    ptr[2] = (JSAMPLE)c5to8bits[t & 0x1F];
+    t >>= 5;
+    ptr[1] = (JSAMPLE)c5to8bits[t & 0x1F];
+    t >>= 5;
+    ptr[0] = (JSAMPLE)c5to8bits[t & 0x1F];
+    ptr += 3;
+  }
+  return 1;
+}
+
+METHODDEF(JDIMENSION)
+get_24bit_row(j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
+/* This version is for reading 24-bit pixels */
+{
+  tga_source_ptr source = (tga_source_ptr)sinfo;
+  register JSAMPROW ptr;
+  register JDIMENSION col;
+
+  ptr = source->pub.buffer[0];
+  for (col = cinfo->image_width; col > 0; col--) {
+    (*source->read_pixel) (source); /* Load next pixel into tga_pixel */
+    *ptr++ = (JSAMPLE)UCH(source->tga_pixel[2]); /* change BGR to RGB order */
+    *ptr++ = (JSAMPLE)UCH(source->tga_pixel[1]);
+    *ptr++ = (JSAMPLE)UCH(source->tga_pixel[0]);
+  }
+  return 1;
+}
+
+/*
+ * Targa also defines a 32-bit pixel format with order B,G,R,A.
+ * We presently ignore the attribute byte, so the code for reading
+ * these pixels is identical to the 24-bit routine above.
+ * This works because the actual pixel length is only known to read_pixel.
+ */
+
+#define get_32bit_row  get_24bit_row
+
+
+/*
+ * This method is for re-reading the input data in standard top-down
+ * row order.  The entire image has already been read into whole_image
+ * with proper conversion of pixel format, but it's in a funny row order.
+ */
+
+METHODDEF(JDIMENSION)
+get_memory_row(j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
+{
+  tga_source_ptr source = (tga_source_ptr)sinfo;
+  JDIMENSION source_row;
+
+  /* Compute row of source that maps to current_row of normal order */
+  /* For now, assume image is bottom-up and not interlaced. */
+  /* NEEDS WORK to support interlaced images! */
+  source_row = cinfo->image_height - source->current_row - 1;
+
+  /* Fetch that row from virtual array */
+  source->pub.buffer = (*cinfo->mem->access_virt_sarray)
+    ((j_common_ptr)cinfo, source->whole_image,
+     source_row, (JDIMENSION)1, FALSE);
+
+  source->current_row++;
+  return 1;
+}
+
+
+/*
+ * This method loads the image into whole_image during the first call on
+ * get_pixel_rows.  The get_pixel_rows pointer is then adjusted to call
+ * get_memory_row on subsequent calls.
+ */
+
+METHODDEF(JDIMENSION)
+preload_image(j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
+{
+  tga_source_ptr source = (tga_source_ptr)sinfo;
+  JDIMENSION row;
+  cd_progress_ptr progress = (cd_progress_ptr)cinfo->progress;
+
+  /* Read the data into a virtual array in input-file row order. */
+  for (row = 0; row < cinfo->image_height; row++) {
+    if (progress != NULL) {
+      progress->pub.pass_counter = (long)row;
+      progress->pub.pass_limit = (long)cinfo->image_height;
+      (*progress->pub.progress_monitor) ((j_common_ptr)cinfo);
+    }
+    source->pub.buffer = (*cinfo->mem->access_virt_sarray)
+      ((j_common_ptr)cinfo, source->whole_image, row, (JDIMENSION)1, TRUE);
+    (*source->get_pixel_rows) (cinfo, sinfo);
+  }
+  if (progress != NULL)
+    progress->completed_extra_passes++;
+
+  /* Set up to read from the virtual array in unscrambled order */
+  source->pub.get_pixel_rows = get_memory_row;
+  source->current_row = 0;
+  /* And read the first row */
+  return get_memory_row(cinfo, sinfo);
+}
+
+
+/*
+ * Read the file header; return image size and component count.
+ */
+
+METHODDEF(void)
+start_input_tga(j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
+{
+  tga_source_ptr source = (tga_source_ptr)sinfo;
+  U_CHAR targaheader[18];
+  int idlen, cmaptype, subtype, flags, interlace_type, components;
+  unsigned int width, height, maplen;
+  boolean is_bottom_up;
+
+#define GET_2B(offset) \
+  ((unsigned int)UCH(targaheader[offset]) + \
+   (((unsigned int)UCH(targaheader[offset + 1])) << 8))
+
+  if (!ReadOK(source->pub.input_file, targaheader, 18))
+    ERREXIT(cinfo, JERR_INPUT_EOF);
+
+  /* Pretend "15-bit" pixels are 16-bit --- we ignore attribute bit anyway */
+  if (targaheader[16] == 15)
+    targaheader[16] = 16;
+
+  idlen = UCH(targaheader[0]);
+  cmaptype = UCH(targaheader[1]);
+  subtype = UCH(targaheader[2]);
+  maplen = GET_2B(5);
+  width = GET_2B(12);
+  height = GET_2B(14);
+  source->pixel_size = UCH(targaheader[16]) >> 3;
+  flags = UCH(targaheader[17]); /* Image Descriptor byte */
+
+  is_bottom_up = ((flags & 0x20) == 0); /* bit 5 set => top-down */
+  interlace_type = flags >> 6;  /* bits 6/7 are interlace code */
+
+  if (cmaptype > 1 ||           /* cmaptype must be 0 or 1 */
+      source->pixel_size < 1 || source->pixel_size > 4 ||
+      (UCH(targaheader[16]) & 7) != 0 || /* bits/pixel must be multiple of 8 */
+      interlace_type != 0 ||      /* currently don't allow interlaced image */
+      width == 0 || height == 0)  /* image width/height must be non-zero */
+    ERREXIT(cinfo, JERR_TGA_BADPARMS);
+
+  if (subtype > 8) {
+    /* It's an RLE-coded file */
+    source->read_pixel = read_rle_pixel;
+    source->block_count = source->dup_pixel_count = 0;
+    subtype -= 8;
+  } else {
+    /* Non-RLE file */
+    source->read_pixel = read_non_rle_pixel;
+  }
+
+  /* Now should have subtype 1, 2, or 3 */
+  components = 3;               /* until proven different */
+  cinfo->in_color_space = JCS_RGB;
+
+  switch (subtype) {
+  case 1:                       /* Colormapped image */
+    if (source->pixel_size == 1 && cmaptype == 1)
+      source->get_pixel_rows = get_8bit_row;
+    else
+      ERREXIT(cinfo, JERR_TGA_BADPARMS);
+    TRACEMS2(cinfo, 1, JTRC_TGA_MAPPED, width, height);
+    break;
+  case 2:                       /* RGB image */
+    switch (source->pixel_size) {
+    case 2:
+      source->get_pixel_rows = get_16bit_row;
+      break;
+    case 3:
+      source->get_pixel_rows = get_24bit_row;
+      break;
+    case 4:
+      source->get_pixel_rows = get_32bit_row;
+      break;
+    default:
+      ERREXIT(cinfo, JERR_TGA_BADPARMS);
+      break;
+    }
+    TRACEMS2(cinfo, 1, JTRC_TGA, width, height);
+    break;
+  case 3:                       /* Grayscale image */
+    components = 1;
+    cinfo->in_color_space = JCS_GRAYSCALE;
+    if (source->pixel_size == 1)
+      source->get_pixel_rows = get_8bit_gray_row;
+    else
+      ERREXIT(cinfo, JERR_TGA_BADPARMS);
+    TRACEMS2(cinfo, 1, JTRC_TGA_GRAY, width, height);
+    break;
+  default:
+    ERREXIT(cinfo, JERR_TGA_BADPARMS);
+    break;
+  }
+
+  if (is_bottom_up) {
+    /* Create a virtual array to buffer the upside-down image. */
+    source->whole_image = (*cinfo->mem->request_virt_sarray)
+      ((j_common_ptr)cinfo, JPOOL_IMAGE, FALSE,
+       (JDIMENSION)width * components, (JDIMENSION)height, (JDIMENSION)1);
+    if (cinfo->progress != NULL) {
+      cd_progress_ptr progress = (cd_progress_ptr)cinfo->progress;
+      progress->total_extra_passes++; /* count file input as separate pass */
+    }
+    /* source->pub.buffer will point to the virtual array. */
+    source->pub.buffer_height = 1; /* in case anyone looks at it */
+    source->pub.get_pixel_rows = preload_image;
+  } else {
+    /* Don't need a virtual array, but do need a one-row input buffer. */
+    source->whole_image = NULL;
+    source->pub.buffer = (*cinfo->mem->alloc_sarray)
+      ((j_common_ptr)cinfo, JPOOL_IMAGE,
+       (JDIMENSION)width * components, (JDIMENSION)1);
+    source->pub.buffer_height = 1;
+    source->pub.get_pixel_rows = source->get_pixel_rows;
+  }
+
+  while (idlen--)               /* Throw away ID field */
+    (void)read_byte(source);
+
+  if (maplen > 0) {
+    if (maplen > 256 || GET_2B(3) != 0)
+      ERREXIT(cinfo, JERR_TGA_BADCMAP);
+    /* Allocate space to store the colormap */
+    source->colormap = (*cinfo->mem->alloc_sarray)
+      ((j_common_ptr)cinfo, JPOOL_IMAGE, (JDIMENSION)maplen, (JDIMENSION)3);
+    source->cmap_length = (int)maplen;
+    /* and read it from the file */
+    read_colormap(source, (int)maplen, UCH(targaheader[7]));
+  } else {
+    if (cmaptype)               /* but you promised a cmap! */
+      ERREXIT(cinfo, JERR_TGA_BADPARMS);
+    source->colormap = NULL;
+    source->cmap_length = 0;
+  }
+
+  cinfo->input_components = components;
+  cinfo->data_precision = 8;
+  cinfo->image_width = width;
+  cinfo->image_height = height;
+}
+
+
+/*
+ * Finish up at the end of the file.
+ */
+
+METHODDEF(void)
+finish_input_tga(j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
+{
+  /* no work */
+}
+
+
+/*
+ * The module selection routine for Targa format input.
+ */
+
+GLOBAL(cjpeg_source_ptr)
+jinit_read_targa(j_compress_ptr cinfo)
+{
+  tga_source_ptr source;
+
+  /* Create module interface object */
+  source = (tga_source_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+                                sizeof(tga_source_struct));
+  source->cinfo = cinfo;        /* make back link for subroutines */
+  /* Fill in method ptrs, except get_pixel_rows which start_input sets */
+  source->pub.start_input = start_input_tga;
+  source->pub.finish_input = finish_input_tga;
+
+  return (cjpeg_source_ptr)source;
+}
+
+#endif /* TARGA_SUPPORTED */
diff --git a/3rdparty/libjpeg/src/release/Config.cmake.in b/3rdparty/libjpeg/src/release/Config.cmake.in
new file mode 100644
index 00000000..0c1ba8aa
--- /dev/null
+++ b/3rdparty/libjpeg/src/release/Config.cmake.in
@@ -0,0 +1,4 @@
+@PACKAGE_INIT@
+
+include("${CMAKE_CURRENT_LIST_DIR}/@CMAKE_PROJECT_NAME@Targets.cmake")
+check_required_components("@CMAKE_PROJECT_NAME@")
diff --git a/3rdparty/libjpeg/src/release/Distribution.xml.in b/3rdparty/libjpeg/src/release/Distribution.xml.in
new file mode 100644
index 00000000..e1f79eee
--- /dev/null
+++ b/3rdparty/libjpeg/src/release/Distribution.xml.in
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="utf-8"?>
+<installer-gui-script minSpecVersion="1">
+	<title>@CMAKE_PROJECT_NAME@</title>
+	<welcome file="Welcome.rtf" />
+	<readme file="ReadMe.txt" />
+	<license file="License.rtf" />
+	<domains
+		enable_anywhere="false"
+		enable_currentUserHome="false"
+		enable_localSystem="true"
+	/>
+	<options customize="never" />
+	<choices-outline>
+		<line choice="default">
+			<line choice="@PKGID@"/>
+		</line>
+	</choices-outline>
+	<choice id="default"/>
+	<choice id="@PKGID@" visible="false">
+		<pkg-ref id="@PKGID@"/>
+	</choice>
+	<pkg-ref auth="root"
+		id="@PKGID@">@PKGNAME@.pkg</pkg-ref>
+</installer-gui-script>
diff --git a/3rdparty/libjpeg/src/release/License.rtf b/3rdparty/libjpeg/src/release/License.rtf
new file mode 100644
index 00000000..5073a27f
--- /dev/null
+++ b/3rdparty/libjpeg/src/release/License.rtf
@@ -0,0 +1,20 @@
+{\rtf1\ansi\ansicpg1252\cocoartf1038\cocoasubrtf350
+{\fonttbl\f0\fswiss\fcharset0 Helvetica;}
+{\colortbl;\red255\green255\blue255;}
+{\*\listtable{\list\listtemplateid1\listhybrid{\listlevel\levelnfc23\levelnfcn23\leveljc0\leveljcn0\levelfollow0\levelstartat1\levelspace360\levelindent0{\*\levelmarker \{disc\}}{\leveltext\leveltemplateid1\'01\uc0\u8226 ;}{\levelnumbers;}\fi-360\li720\lin720 }{\listname ;}\listid1}}
+{\*\listoverridetable{\listoverride\listid1\listoverridecount0\ls1}}
+\margl1440\margr1440\vieww9820\viewh8480\viewkind0
+\deftab720
+\pard\pardeftab720
+
+\f0\fs24 \cf0 Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:\
+\
+\pard\tx220\tx720\pardeftab720\li720\fi-720
+\ls1\ilvl0\cf0 {\listtext	\'95	}Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.\
+{\listtext	\'95	}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.\
+{\listtext	\'95	}Neither the name of the libjpeg-turbo Project nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.\
+\pard\pardeftab720\qc
+\cf0 \
+\pard\pardeftab720
+\cf0 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 HOLDERS 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.\
+}
\ No newline at end of file
diff --git a/3rdparty/libjpeg/src/release/ReadMe.txt b/3rdparty/libjpeg/src/release/ReadMe.txt
new file mode 100644
index 00000000..446ce46c
--- /dev/null
+++ b/3rdparty/libjpeg/src/release/ReadMe.txt
@@ -0,0 +1,5 @@
+libjpeg-turbo is a JPEG image codec that uses SIMD instructions to accelerate baseline JPEG compression and decompression on x86, x86-64, Arm, PowerPC, and MIPS systems, as well as progressive JPEG compression on x86, x86-64, and Arm systems.  On such systems, libjpeg-turbo is generally 2-6x as fast as libjpeg, all else being equal.  On other types of systems, libjpeg-turbo can still outperform libjpeg by a significant amount, by virtue of its highly-optimized Huffman coding routines.  In many cases, the performance of libjpeg-turbo rivals that of proprietary high-speed JPEG codecs.
+
+libjpeg-turbo implements both the traditional libjpeg API as well as the less powerful but more straightforward TurboJPEG API.  libjpeg-turbo also features colorspace extensions that allow it to compress from/decompress to 32-bit and big-endian pixel buffers (RGBX, XBGR, etc.), as well as a full-featured Java interface.
+
+libjpeg-turbo was originally based on libjpeg/SIMD, an MMX-accelerated derivative of libjpeg v6b developed by Miyasaka Masaru.  The TigerVNC and VirtualGL projects made numerous enhancements to the codec in 2009, and in early 2010, libjpeg-turbo spun off into an independent project, with the goal of making high-speed JPEG compression/decompression technology available to a broader range of users and developers.
diff --git a/3rdparty/libjpeg/src/release/Welcome.rtf.in b/3rdparty/libjpeg/src/release/Welcome.rtf.in
new file mode 100644
index 00000000..6bec24d9
--- /dev/null
+++ b/3rdparty/libjpeg/src/release/Welcome.rtf.in
@@ -0,0 +1,17 @@
+{\rtf1\ansi\ansicpg1252\cocoartf1038\cocoasubrtf360
+{\fonttbl\f0\fswiss\fcharset0 Helvetica;\f1\fmodern\fcharset0 CourierNewPSMT;}
+{\colortbl;\red255\green255\blue255;}
+\margl1440\margr1440\vieww9000\viewh8400\viewkind0
+\deftab720
+\pard\pardeftab720\ql\qnatural
+
+\f0\fs24 \cf0 This installer will install the libjpeg-turbo SDK and run-time libraries onto your computer so that you can use libjpeg-turbo to build new applications or accelerate existing ones.  To remove the libjpeg-turbo package, run\
+\
+\pard\pardeftab720\ql\qnatural
+
+\f1 \cf0   @CMAKE_INSTALL_FULL_BINDIR@/uninstall\
+\pard\pardeftab720\ql\qnatural
+
+\f0 \cf0 \
+from the command line.\
+}
diff --git a/3rdparty/libjpeg/src/release/deb-control.in b/3rdparty/libjpeg/src/release/deb-control.in
new file mode 100644
index 00000000..72bceec4
--- /dev/null
+++ b/3rdparty/libjpeg/src/release/deb-control.in
@@ -0,0 +1,31 @@
+Package: {__PKGNAME}
+Version: @VERSION@-@BUILD@
+Section: misc
+Priority: optional
+Architecture: {__ARCH}
+Essential: no
+Maintainer: @PKGVENDOR@ <@PKGEMAIL@>
+Homepage: @PKGURL@
+Installed-Size: {__SIZE}
+Description: A SIMD-accelerated JPEG codec that provides both the libjpeg and TurboJPEG APIs
+ libjpeg-turbo is a JPEG image codec that uses SIMD instructions to accelerate
+ baseline JPEG compression and decompression on x86, x86-64, Arm, PowerPC, and
+ MIPS systems, as well as progressive JPEG compression on x86, x86-64, and
+ Arm systems.  On such systems, libjpeg-turbo is generally 2-6x as fast as
+ libjpeg, all else being equal.  On other types of systems, libjpeg-turbo can
+ still outperform libjpeg by a significant amount, by virtue of its
+ highly-optimized Huffman coding routines.  In many cases, the performance of
+ libjpeg-turbo rivals that of proprietary high-speed JPEG codecs.
+ .
+ libjpeg-turbo implements both the traditional libjpeg API as well as the less
+ powerful but more straightforward TurboJPEG API.  libjpeg-turbo also features
+ colorspace extensions that allow it to compress from/decompress to 32-bit and
+ big-endian pixel buffers (RGBX, XBGR, etc.), as well as a full-featured Java
+ interface.
+ .
+ libjpeg-turbo was originally based on libjpeg/SIMD, an MMX-accelerated
+ derivative of libjpeg v6b developed by Miyasaka Masaru.  The TigerVNC and
+ VirtualGL projects made numerous enhancements to the codec in 2009, and in
+ early 2010, libjpeg-turbo spun off into an independent project, with the goal
+ of making high-speed JPEG compression/decompression technology available to a
+ broader range of users and developers.
diff --git a/3rdparty/libjpeg/src/release/installer.nsi.in b/3rdparty/libjpeg/src/release/installer.nsi.in
new file mode 100644
index 00000000..65db63da
--- /dev/null
+++ b/3rdparty/libjpeg/src/release/installer.nsi.in
@@ -0,0 +1,202 @@
+!include x64.nsh
+Name "@CMAKE_PROJECT_NAME@ SDK for @INST_PLATFORM@"
+OutFile "@CMAKE_CURRENT_BINARY_DIR@\${BUILDDIR}@INST_NAME@.exe"
+InstallDir "@INST_DIR@"
+
+SetCompressor bzip2
+
+Page directory
+Page instfiles
+
+UninstPage uninstConfirm
+UninstPage instfiles
+
+Section "@CMAKE_PROJECT_NAME@ SDK for @INST_PLATFORM@ (required)"
+!ifdef WIN64
+	${If} ${RunningX64}
+	${DisableX64FSRedirection}
+	${Endif}
+!endif
+	SectionIn RO
+!ifdef GCC
+	IfFileExists $SYSDIR/libturbojpeg.dll exists 0
+!else
+	IfFileExists $SYSDIR/turbojpeg.dll exists 0
+!endif
+	goto notexists
+	exists:
+!ifdef GCC
+	MessageBox MB_OK "An existing version of the @CMAKE_PROJECT_NAME@ SDK for @INST_PLATFORM@ is already installed.  Please uninstall it first."
+!else
+	MessageBox MB_OK "An existing version of the @CMAKE_PROJECT_NAME@ SDK for @INST_PLATFORM@ or the TurboJPEG SDK is already installed.  Please uninstall it first."
+!endif
+	quit
+
+	notexists:
+	SetOutPath $SYSDIR
+!ifdef GCC
+	File "@CMAKE_CURRENT_BINARY_DIR@\libturbojpeg.dll"
+!else
+	File "@CMAKE_CURRENT_BINARY_DIR@\${BUILDDIR}turbojpeg.dll"
+!endif
+	SetOutPath $INSTDIR\bin
+!ifdef GCC
+	File "@CMAKE_CURRENT_BINARY_DIR@\libturbojpeg.dll"
+!else
+	File "@CMAKE_CURRENT_BINARY_DIR@\${BUILDDIR}turbojpeg.dll"
+!endif
+!ifdef GCC
+	File "@CMAKE_CURRENT_BINARY_DIR@\libjpeg-@SO_MAJOR_VERSION@.dll"
+!else
+	File "@CMAKE_CURRENT_BINARY_DIR@\${BUILDDIR}jpeg@SO_MAJOR_VERSION@.dll"
+!endif
+	File "@CMAKE_CURRENT_BINARY_DIR@\${BUILDDIR}cjpeg.exe"
+	File "@CMAKE_CURRENT_BINARY_DIR@\${BUILDDIR}djpeg.exe"
+	File "@CMAKE_CURRENT_BINARY_DIR@\${BUILDDIR}jpegtran.exe"
+	File "@CMAKE_CURRENT_BINARY_DIR@\${BUILDDIR}tjbench.exe"
+	File "@CMAKE_CURRENT_BINARY_DIR@\${BUILDDIR}rdjpgcom.exe"
+	File "@CMAKE_CURRENT_BINARY_DIR@\${BUILDDIR}wrjpgcom.exe"
+	SetOutPath $INSTDIR\lib
+!ifdef GCC
+	File "@CMAKE_CURRENT_BINARY_DIR@\libturbojpeg.dll.a"
+	File "@CMAKE_CURRENT_BINARY_DIR@\libturbojpeg.a"
+	File "@CMAKE_CURRENT_BINARY_DIR@\libjpeg.dll.a"
+	File "@CMAKE_CURRENT_BINARY_DIR@\libjpeg.a"
+!else
+	File "@CMAKE_CURRENT_BINARY_DIR@\${BUILDDIR}turbojpeg.lib"
+	File "@CMAKE_CURRENT_BINARY_DIR@\${BUILDDIR}turbojpeg-static.lib"
+	File "@CMAKE_CURRENT_BINARY_DIR@\${BUILDDIR}jpeg.lib"
+	File "@CMAKE_CURRENT_BINARY_DIR@\${BUILDDIR}jpeg-static.lib"
+!endif
+	SetOutPath $INSTDIR\lib\pkgconfig
+	File "@CMAKE_CURRENT_BINARY_DIR@\pkgscripts\libjpeg.pc"
+	File "@CMAKE_CURRENT_BINARY_DIR@\pkgscripts\libturbojpeg.pc"
+	SetOutPath $INSTDIR\lib\cmake\@CMAKE_PROJECT_NAME@
+	File "@CMAKE_CURRENT_BINARY_DIR@\pkgscripts\@CMAKE_PROJECT_NAME@Config.cmake"
+	File "@CMAKE_CURRENT_BINARY_DIR@\pkgscripts\@CMAKE_PROJECT_NAME@ConfigVersion.cmake"
+	File "@CMAKE_CURRENT_BINARY_DIR@\win\@CMAKE_PROJECT_NAME@Targets.cmake"
+	File "@CMAKE_CURRENT_BINARY_DIR@\win\@CMAKE_PROJECT_NAME@Targets-release.cmake"
+!ifdef JAVA
+	SetOutPath $INSTDIR\classes
+	File "@CMAKE_CURRENT_BINARY_DIR@\java\turbojpeg.jar"
+!endif
+	SetOutPath $INSTDIR\include
+	File "@CMAKE_CURRENT_BINARY_DIR@\jconfig.h"
+	File "@CMAKE_CURRENT_SOURCE_DIR@\jerror.h"
+	File "@CMAKE_CURRENT_SOURCE_DIR@\jmorecfg.h"
+	File "@CMAKE_CURRENT_SOURCE_DIR@\jpeglib.h"
+	File "@CMAKE_CURRENT_SOURCE_DIR@\turbojpeg.h"
+	SetOutPath $INSTDIR\doc
+	File "@CMAKE_CURRENT_SOURCE_DIR@\README.ijg"
+	File "@CMAKE_CURRENT_SOURCE_DIR@\README.md"
+	File "@CMAKE_CURRENT_SOURCE_DIR@\LICENSE.md"
+	File "@CMAKE_CURRENT_SOURCE_DIR@\example.txt"
+	File "@CMAKE_CURRENT_SOURCE_DIR@\libjpeg.txt"
+	File "@CMAKE_CURRENT_SOURCE_DIR@\structure.txt"
+	File "@CMAKE_CURRENT_SOURCE_DIR@\usage.txt"
+	File "@CMAKE_CURRENT_SOURCE_DIR@\wizard.txt"
+	File "@CMAKE_CURRENT_SOURCE_DIR@\tjexample.c"
+	File "@CMAKE_CURRENT_SOURCE_DIR@\java\TJExample.java"
+!ifdef GCC
+	SetOutPath $INSTDIR\man\man1
+	File "@CMAKE_CURRENT_SOURCE_DIR@\cjpeg.1"
+	File "@CMAKE_CURRENT_SOURCE_DIR@\djpeg.1"
+	File "@CMAKE_CURRENT_SOURCE_DIR@\jpegtran.1"
+	File "@CMAKE_CURRENT_SOURCE_DIR@\rdjpgcom.1"
+	File "@CMAKE_CURRENT_SOURCE_DIR@\wrjpgcom.1"
+!endif
+
+	WriteRegStr HKLM "SOFTWARE\@INST_REG_NAME@ @VERSION@" "Install_Dir" "$INSTDIR"
+
+	WriteRegStr HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\@INST_REG_NAME@ @VERSION@" "DisplayName" "@CMAKE_PROJECT_NAME@ SDK v@VERSION@ for @INST_PLATFORM@"
+	WriteRegStr HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\@INST_REG_NAME@ @VERSION@" "UninstallString" '"$INSTDIR\uninstall_@VERSION@.exe"'
+	WriteRegDWORD HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\@INST_REG_NAME@ @VERSION@" "NoModify" 1
+	WriteRegDWORD HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\@INST_REG_NAME@ @VERSION@" "NoRepair" 1
+	WriteUninstaller "uninstall_@VERSION@.exe"
+SectionEnd
+
+Section "Uninstall"
+!ifdef WIN64
+	${If} ${RunningX64}
+	${DisableX64FSRedirection}
+	${Endif}
+!endif
+
+	SetShellVarContext all
+
+	DeleteRegKey HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\@INST_REG_NAME@ @VERSION@"
+	DeleteRegKey HKLM "SOFTWARE\@INST_REG_NAME@ @VERSION@"
+
+!ifdef GCC
+	Delete $INSTDIR\bin\libjpeg-@SO_MAJOR_VERSION@.dll
+	Delete $INSTDIR\bin\libturbojpeg.dll
+	Delete $SYSDIR\libturbojpeg.dll
+	Delete $INSTDIR\lib\libturbojpeg.dll.a
+	Delete $INSTDIR\lib\libturbojpeg.a
+	Delete $INSTDIR\lib\libjpeg.dll.a
+	Delete $INSTDIR\lib\libjpeg.a
+!else
+	Delete $INSTDIR\bin\jpeg@SO_MAJOR_VERSION@.dll
+	Delete $INSTDIR\bin\turbojpeg.dll
+	Delete $SYSDIR\turbojpeg.dll
+	Delete $INSTDIR\lib\jpeg.lib
+	Delete $INSTDIR\lib\jpeg-static.lib
+	Delete $INSTDIR\lib\turbojpeg.lib
+	Delete $INSTDIR\lib\turbojpeg-static.lib
+!endif
+	Delete $INSTDIR\lib\pkgconfig\libjpeg.pc
+	Delete $INSTDIR\lib\pkgconfig\libturbojpeg.pc
+	Delete $INSTDIR\lib\cmake\@CMAKE_PROJECT_NAME@\@CMAKE_PROJECT_NAME@Config.cmake
+	Delete $INSTDIR\lib\cmake\@CMAKE_PROJECT_NAME@\@CMAKE_PROJECT_NAME@ConfigVersion.cmake
+	Delete $INSTDIR\lib\cmake\@CMAKE_PROJECT_NAME@\@CMAKE_PROJECT_NAME@Targets.cmake
+	Delete $INSTDIR\lib\cmake\@CMAKE_PROJECT_NAME@\@CMAKE_PROJECT_NAME@Targets-release.cmake
+!ifdef JAVA
+	Delete $INSTDIR\classes\turbojpeg.jar
+!endif
+	Delete $INSTDIR\bin\cjpeg.exe
+	Delete $INSTDIR\bin\djpeg.exe
+	Delete $INSTDIR\bin\jpegtran.exe
+	Delete $INSTDIR\bin\tjbench.exe
+	Delete $INSTDIR\bin\rdjpgcom.exe
+	Delete $INSTDIR\bin\wrjpgcom.exe
+	Delete $INSTDIR\include\jconfig.h
+	Delete $INSTDIR\include\jerror.h
+	Delete $INSTDIR\include\jmorecfg.h
+	Delete $INSTDIR\include\jpeglib.h
+	Delete $INSTDIR\include\turbojpeg.h
+	Delete $INSTDIR\uninstall_@VERSION@.exe
+	Delete $INSTDIR\doc\README.ijg
+	Delete $INSTDIR\doc\README.md
+	Delete $INSTDIR\doc\LICENSE.md
+	Delete $INSTDIR\doc\example.txt
+	Delete $INSTDIR\doc\libjpeg.txt
+	Delete $INSTDIR\doc\structure.txt
+	Delete $INSTDIR\doc\usage.txt
+	Delete $INSTDIR\doc\wizard.txt
+	Delete $INSTDIR\doc\tjexample.c
+	Delete $INSTDIR\doc\TJExample.java
+!ifdef GCC
+	Delete $INSTDIR\man\man1\cjpeg.1
+	Delete $INSTDIR\man\man1\djpeg.1
+	Delete $INSTDIR\man\man1\jpegtran.1
+	Delete $INSTDIR\man\man1\rdjpgcom.1
+	Delete $INSTDIR\man\man1\wrjpgcom.1
+!endif
+
+	RMDir "$INSTDIR\include"
+	RMDir "$INSTDIR\lib\pkgconfig"
+	RMDir "$INSTDIR\lib\cmake\@CMAKE_PROJECT_NAME@"
+	RMDir "$INSTDIR\lib\cmake"
+	RMDir "$INSTDIR\lib"
+	RMDir "$INSTDIR\doc"
+!ifdef GCC
+	RMDir "$INSTDIR\man\man1"
+	RMDir "$INSTDIR\man"
+!endif
+!ifdef JAVA
+	RMDir "$INSTDIR\classes"
+!endif
+	RMDir "$INSTDIR\bin"
+	RMDir "$INSTDIR"
+
+SectionEnd
diff --git a/3rdparty/libjpeg/src/release/libjpeg.pc.in b/3rdparty/libjpeg/src/release/libjpeg.pc.in
new file mode 100644
index 00000000..74fb7fc6
--- /dev/null
+++ b/3rdparty/libjpeg/src/release/libjpeg.pc.in
@@ -0,0 +1,10 @@
+prefix=@CMAKE_INSTALL_PREFIX@
+exec_prefix=@CMAKE_INSTALL_PREFIX@
+libdir=@CMAKE_INSTALL_FULL_LIBDIR@
+includedir=@CMAKE_INSTALL_FULL_INCLUDEDIR@
+
+Name: libjpeg
+Description: A SIMD-accelerated JPEG codec that provides the libjpeg API
+Version: @VERSION@
+Libs: -L${libdir} -ljpeg
+Cflags: -I${includedir}
diff --git a/3rdparty/libjpeg/src/release/libturbojpeg.pc.in b/3rdparty/libjpeg/src/release/libturbojpeg.pc.in
new file mode 100644
index 00000000..81a00632
--- /dev/null
+++ b/3rdparty/libjpeg/src/release/libturbojpeg.pc.in
@@ -0,0 +1,10 @@
+prefix=@CMAKE_INSTALL_PREFIX@
+exec_prefix=@CMAKE_INSTALL_PREFIX@
+libdir=@CMAKE_INSTALL_FULL_LIBDIR@
+includedir=@CMAKE_INSTALL_FULL_INCLUDEDIR@
+
+Name: libturbojpeg
+Description: A SIMD-accelerated JPEG codec that provides the TurboJPEG API
+Version: @VERSION@
+Libs: -L${libdir} -lturbojpeg
+Cflags: -I${includedir}
diff --git a/3rdparty/libjpeg/src/release/makedpkg.in b/3rdparty/libjpeg/src/release/makedpkg.in
new file mode 100644
index 00000000..a7ff7c20
--- /dev/null
+++ b/3rdparty/libjpeg/src/release/makedpkg.in
@@ -0,0 +1,121 @@
+#!/bin/sh
+
+set -u
+set -e
+trap onexit INT
+trap onexit TERM
+trap onexit EXIT
+
+TMPDIR=
+SUDO=
+
+onexit()
+{
+	if [ ! "$TMPDIR" = "" ]; then
+		$SUDO rm -rf $TMPDIR
+	fi
+}
+
+uid()
+{
+	id | cut -f2 -d = | cut -f1 -d \(;
+}
+
+safedirmove ()
+{
+	if [ "$1" = "$2" ]; then
+		return 0
+	fi
+	if [ "$1" = "" -o ! -d "$1" ]; then
+		echo safedirmove: source dir $1 is not valid
+		return 1
+	fi
+	if [ "$2" = "" -o -e "$2" ]; then
+		echo safedirmove: dest dir $2 is not valid
+		return 1
+	fi
+	if [ "$3" = "" -o -e "$3" ]; then
+		echo safedirmove: tmp dir $3 is not valid
+		return 1
+	fi
+	mkdir -p $3
+	mv $1/* $3/
+	rmdir $1
+	mkdir -p $2
+	mv $3/* $2/
+	rmdir $3
+	return 0
+}
+
+makedeb()
+{
+	SUPPLEMENT=$1
+	DIRNAME=$PKGNAME
+
+	if [ $SUPPLEMENT = 1 ]; then
+		PKGNAME=$PKGNAME\32
+		if [ "$DEBARCH" = "i386" ]; then
+			DEBARCH=amd64
+		else
+			DEBARCH=arm64
+		fi
+	fi
+
+	umask 022
+	rm -f $PKGNAME\_$VERSION\_$DEBARCH.deb
+	TMPDIR=`mktemp -d /tmp/$PKGNAME-build.XXXXXX`
+	mkdir $TMPDIR/DEBIAN
+
+	if [ $SUPPLEMENT = 1 ]; then
+		make install DESTDIR=$TMPDIR
+		rm -rf $TMPDIR$BINDIR
+		if [ "$DATAROOTDIR" != "$PREFIX" ]; then
+			rm -rf $TMPDIR$DATAROOTDIR
+		fi
+		if [ "$JAVADIR" != "" ]; then
+			rm -rf $TMPDIR$JAVADIR
+		fi
+		rm -rf $TMPDIR$DOCDIR
+		rm -rf $TMPDIR$INCLUDEDIR
+		rm -rf $TMPDIR$MANDIR
+	else
+		make install DESTDIR=$TMPDIR
+		if [ "$PREFIX" = "@CMAKE_INSTALL_DEFAULT_PREFIX@" -a "$DOCDIR" = "@CMAKE_INSTALL_DEFAULT_PREFIX@/doc" ]; then
+			safedirmove $TMPDIR/$DOCDIR $TMPDIR/usr/share/doc/$PKGNAME-$VERSION $TMPDIR/__tmpdoc
+			ln -fs /usr/share/doc/$DIRNAME-$VERSION $TMPDIR$DOCDIR
+		fi
+	fi
+
+	SIZE=`du -s $TMPDIR | cut -f1`
+	(cat pkgscripts/deb-control | sed s/{__PKGNAME}/$PKGNAME/g \
+		| sed s/{__ARCH}/$DEBARCH/g | sed s/{__SIZE}/$SIZE/g \
+		> $TMPDIR/DEBIAN/control)
+
+	/sbin/ldconfig -n $TMPDIR$LIBDIR
+
+	$SUDO chown -Rh root:root $TMPDIR/*
+	dpkg -b $TMPDIR $PKGNAME\_$VERSION\_$DEBARCH.deb
+}
+
+PKGNAME=@PKGNAME@
+VERSION=@VERSION@
+DEBARCH=@DEBARCH@
+PREFIX=@CMAKE_INSTALL_PREFIX@
+BINDIR=@CMAKE_INSTALL_FULL_BINDIR@
+DATAROOTDIR=@CMAKE_INSTALL_FULL_DATAROOTDIR@
+DOCDIR=@CMAKE_INSTALL_FULL_DOCDIR@
+INCLUDEDIR=@CMAKE_INSTALL_FULL_INCLUDEDIR@
+JAVADIR=@CMAKE_INSTALL_FULL_JAVADIR@
+LIBDIR=@CMAKE_INSTALL_FULL_LIBDIR@
+MANDIR=@CMAKE_INSTALL_FULL_MANDIR@
+
+if [ ! `uid` -eq 0 ]; then
+	SUDO=sudo
+fi
+
+makedeb 0
+if [ "$DEBARCH" = "i386" -o "$DEBARCH" = "armel" -o "$DEBARCH" = "armhf" ]; then
+	makedeb 1
+fi
+
+exit
diff --git a/3rdparty/libjpeg/src/release/makemacpkg.in b/3rdparty/libjpeg/src/release/makemacpkg.in
new file mode 100644
index 00000000..36505b91
--- /dev/null
+++ b/3rdparty/libjpeg/src/release/makemacpkg.in
@@ -0,0 +1,207 @@
+#!/bin/sh
+
+set -u
+set -e
+trap onexit INT
+trap onexit TERM
+trap onexit EXIT
+
+TMPDIR=
+
+onexit()
+{
+	if [ ! "$TMPDIR" = "" ]; then
+		rm -rf $TMPDIR
+	fi
+}
+
+safedirmove ()
+{
+	if [ "$1" = "$2" ]; then
+		return 0
+	fi
+	if [ "$1" = "" -o ! -d "$1" ]; then
+		echo safedirmove: source dir $1 is not valid
+		return 1
+	fi
+	if [ "$2" = "" -o -e "$2" ]; then
+		echo safedirmove: dest dir $2 is not valid
+		return 1
+	fi
+	if [ "$3" = "" -o -e "$3" ]; then
+		echo safedirmove: tmp dir $3 is not valid
+		return 1
+	fi
+	mkdir -p $3
+	mv $1/* $3/
+	rmdir $1
+	mkdir -p $2
+	mv $3/* $2/
+	rmdir $3
+	return 0
+}
+
+usage()
+{
+	echo "$0 [-lipo [path to lipo]]"
+	exit 1
+}
+
+PKGNAME=@PKGNAME@
+VERSION=@VERSION@
+BUILD=@BUILD@
+SRCDIR=@CMAKE_CURRENT_SOURCE_DIR@
+BUILDDIRARMV8=@ARMV8_BUILD@
+WITH_JAVA=@WITH_JAVA@
+MACOS_APP_CERT_NAME="@MACOS_APP_CERT_NAME@"
+MACOS_INST_CERT_NAME="@MACOS_INST_CERT_NAME@"
+LIPO=lipo
+
+PREFIX=@CMAKE_INSTALL_PREFIX@
+BINDIR=@CMAKE_INSTALL_FULL_BINDIR@
+DOCDIR=@CMAKE_INSTALL_FULL_DOCDIR@
+LIBDIR=@CMAKE_INSTALL_FULL_LIBDIR@
+
+LIBJPEG_DSO_NAME=libjpeg.@SO_MAJOR_VERSION@.@SO_AGE@.@SO_MINOR_VERSION@.dylib
+TURBOJPEG_DSO_NAME=libturbojpeg.@TURBOJPEG_SO_VERSION@.dylib
+
+while [ $# -gt 0 ]; do
+	case $1 in
+	-h*)
+		usage 0
+		;;
+	-lipo)
+		if [ $# -gt 1 ]; then
+			if [[ ! "$2" =~ -.* ]]; then
+				LIPO=$2;  shift
+			fi
+		fi
+		;;
+	esac
+	shift
+done
+
+if [ -f $PKGNAME-$VERSION.dmg ]; then
+	rm -f $PKGNAME-$VERSION.dmg
+fi
+
+umask 022
+TMPDIR=`mktemp -d /tmp/$PKGNAME-build.XXXXXX`
+PKGROOT=$TMPDIR/pkg/Package_Root
+mkdir -p $PKGROOT
+
+make install DESTDIR=$PKGROOT
+
+if [ "$PREFIX" = "@CMAKE_INSTALL_DEFAULT_PREFIX@" -a "$DOCDIR" = "@CMAKE_INSTALL_DEFAULT_PREFIX@/doc" ]; then
+	mkdir -p $PKGROOT/Library/Documentation
+	safedirmove $PKGROOT$DOCDIR $PKGROOT/Library/Documentation/$PKGNAME $TMPDIR/__tmpdoc
+	ln -fs /Library/Documentation/$PKGNAME $PKGROOT$DOCDIR
+fi
+
+install_subbuild()
+{
+	BUILDDIR=$1
+	ARCHNAME=$2
+	DIRNAME=$3
+	LIPOARCH=$4
+
+	if [ ! -d $BUILDDIR ]; then
+		echo ERROR: $ARCHNAME build directory $BUILDDIR does not exist
+		exit 1
+	fi
+	if [ ! -f $BUILDDIR/Makefile ]; then
+		echo ERROR: $ARCHNAME build directory $BUILDDIR is not configured
+		exit 1
+	fi
+	mkdir -p $TMPDIR/dist.$DIRNAME
+	pushd $BUILDDIR
+	make install DESTDIR=$TMPDIR/dist.$DIRNAME
+	popd
+	$LIPO -create \
+		$PKGROOT/$LIBDIR/$LIBJPEG_DSO_NAME \
+		-arch $LIPOARCH $TMPDIR/dist.$DIRNAME/$LIBDIR/$LIBJPEG_DSO_NAME \
+		-output $PKGROOT/$LIBDIR/$LIBJPEG_DSO_NAME
+	$LIPO -create \
+		$PKGROOT/$LIBDIR/libjpeg.a \
+		-arch $LIPOARCH $TMPDIR/dist.$DIRNAME/$LIBDIR/libjpeg.a \
+		-output $PKGROOT/$LIBDIR/libjpeg.a
+	$LIPO -create \
+		$PKGROOT/$LIBDIR/$TURBOJPEG_DSO_NAME \
+		-arch $LIPOARCH $TMPDIR/dist.$DIRNAME/$LIBDIR/$TURBOJPEG_DSO_NAME \
+		-output $PKGROOT/$LIBDIR/$TURBOJPEG_DSO_NAME
+	$LIPO -create \
+		$PKGROOT/$LIBDIR/libturbojpeg.a \
+		-arch $LIPOARCH $TMPDIR/dist.$DIRNAME/$LIBDIR/libturbojpeg.a \
+		-output $PKGROOT/$LIBDIR/libturbojpeg.a
+	$LIPO -create \
+		$PKGROOT/$BINDIR/cjpeg \
+		-arch $LIPOARCH $TMPDIR/dist.$DIRNAME/$BINDIR/cjpeg \
+		-output $PKGROOT/$BINDIR/cjpeg
+	$LIPO -create \
+		$PKGROOT/$BINDIR/djpeg \
+		-arch $LIPOARCH $TMPDIR/dist.$DIRNAME/$BINDIR/djpeg \
+		-output $PKGROOT/$BINDIR/djpeg
+	$LIPO -create \
+		$PKGROOT/$BINDIR/jpegtran \
+		-arch $LIPOARCH $TMPDIR/dist.$DIRNAME/$BINDIR/jpegtran \
+		-output $PKGROOT/$BINDIR/jpegtran
+	$LIPO -create \
+		$PKGROOT/$BINDIR/tjbench \
+		-arch $LIPOARCH $TMPDIR/dist.$DIRNAME/$BINDIR/tjbench \
+		-output $PKGROOT/$BINDIR/tjbench
+	$LIPO -create \
+		$PKGROOT/$BINDIR/rdjpgcom \
+		-arch $LIPOARCH $TMPDIR/dist.$DIRNAME/$BINDIR/rdjpgcom \
+		-output $PKGROOT/$BINDIR/rdjpgcom
+	$LIPO -create \
+		$PKGROOT/$BINDIR/wrjpgcom \
+		-arch $LIPOARCH $TMPDIR/dist.$DIRNAME/$BINDIR/wrjpgcom \
+		-output $PKGROOT/$BINDIR/wrjpgcom
+}
+
+if [ "$BUILDDIRARMV8" != "" ]; then
+	install_subbuild $BUILDDIRARMV8 Armv8 armv8 arm64
+fi
+
+install_name_tool -id $LIBDIR/$LIBJPEG_DSO_NAME $PKGROOT/$LIBDIR/$LIBJPEG_DSO_NAME
+install_name_tool -id $LIBDIR/$TURBOJPEG_DSO_NAME $PKGROOT/$LIBDIR/$TURBOJPEG_DSO_NAME
+
+if [ "$PREFIX" = "@CMAKE_INSTALL_DEFAULT_PREFIX@" -a "$LIBDIR" = "@CMAKE_INSTALL_DEFAULT_PREFIX@/lib" ]; then
+	if [ ! -h $PKGROOT/$PREFIX/lib64 ]; then
+		ln -fs lib $PKGROOT/$PREFIX/lib64
+	fi
+fi
+
+mkdir -p $TMPDIR/pkg
+
+install -m 755 pkgscripts/uninstall $PKGROOT/$BINDIR/
+
+find $PKGROOT -type f | while read file; do xattr -c $file; done
+
+cp $SRCDIR/release/License.rtf pkgscripts/Welcome.rtf $SRCDIR/release/ReadMe.txt $TMPDIR/pkg/
+
+mkdir $TMPDIR/dmg
+pkgbuild --root $PKGROOT --version $VERSION.$BUILD --identifier @PKGID@ \
+	$TMPDIR/pkg/$PKGNAME.pkg
+SUFFIX=
+if [ "$MACOS_INST_CERT_NAME" != "" ]; then
+	SUFFIX=-unsigned
+fi
+productbuild --distribution pkgscripts/Distribution.xml \
+	--package-path $TMPDIR/pkg/ --resources $TMPDIR/pkg/ \
+	$TMPDIR/dmg/$PKGNAME$SUFFIX.pkg
+if [ "$MACOS_INST_CERT_NAME" != "" ]; then
+	productsign --sign "$MACOS_INST_CERT_NAME" --timestamp \
+		$TMPDIR/dmg/$PKGNAME$SUFFIX.pkg $TMPDIR/dmg/$PKGNAME.pkg
+	rm -r $TMPDIR/dmg/$PKGNAME$SUFFIX.pkg
+	pkgutil --check-signature $TMPDIR/dmg/$PKGNAME.pkg
+fi
+hdiutil create -fs HFS+ -volname $PKGNAME-$VERSION \
+	-srcfolder "$TMPDIR/dmg" $TMPDIR/$PKGNAME-$VERSION.dmg
+if [ "$MACOS_APP_CERT_NAME" != "" ]; then
+	codesign -s "$MACOS_APP_CERT_NAME" --timestamp $TMPDIR/$PKGNAME-$VERSION.dmg
+	codesign -vv $TMPDIR/$PKGNAME-$VERSION.dmg
+fi
+cp $TMPDIR/$PKGNAME-$VERSION.dmg .
+
+exit
diff --git a/3rdparty/libjpeg/src/release/makerpm.in b/3rdparty/libjpeg/src/release/makerpm.in
new file mode 100644
index 00000000..fc3b1d49
--- /dev/null
+++ b/3rdparty/libjpeg/src/release/makerpm.in
@@ -0,0 +1,30 @@
+#!/bin/sh
+
+set -u
+set -e
+trap onexit INT
+trap onexit TERM
+trap onexit EXIT
+
+TMPDIR=
+
+onexit()
+{
+	if [ ! "$TMPDIR" = "" ]; then
+		rm -rf $TMPDIR
+	fi
+}
+
+if [ -f @PKGNAME@-@VERSION@.@RPMARCH@.rpm ]; then
+	rm -f @PKGNAME@-@VERSION@.@RPMARCH@.rpm
+fi
+
+umask 022
+TMPDIR=`mktemp -d /tmp/@CMAKE_PROJECT_NAME@-build.XXXXXX`
+
+mkdir -p $TMPDIR/RPMS
+ln -fs `pwd` $TMPDIR/BUILD
+rpmbuild -bb --define "_blddir $TMPDIR/buildroot" --define "_topdir $TMPDIR" \
+	--target @RPMARCH@ pkgscripts/rpm.spec; \
+cp $TMPDIR/RPMS/@RPMARCH@/@PKGNAME@-@VERSION@-@BUILD@.@RPMARCH@.rpm \
+	@PKGNAME@-@VERSION@.@RPMARCH@.rpm
diff --git a/3rdparty/libjpeg/src/release/makesrpm.in b/3rdparty/libjpeg/src/release/makesrpm.in
new file mode 100644
index 00000000..84c39d4e
--- /dev/null
+++ b/3rdparty/libjpeg/src/release/makesrpm.in
@@ -0,0 +1,48 @@
+#!/bin/sh
+
+set -u
+set -e
+trap onexit INT
+trap onexit TERM
+trap onexit EXIT
+
+TMPDIR=
+
+onexit()
+{
+	if [ ! "$TMPDIR" = "" ]; then
+		rm -rf $TMPDIR
+	fi
+}
+
+PKGNAME=@PKGNAME@
+PROJECT=@CMAKE_PROJECT_NAME@
+VERSION=@VERSION@
+BUILD=@BUILD@
+
+if [ -f $PKGNAME-$VERSION.src.rpm ]; then
+	rm -f $PKGNAME-$VERSION.src.rpm
+fi
+
+umask 022
+TMPDIR=`mktemp -d /tmp/$PKGNAME-build.XXXXXX`
+
+mkdir -p $TMPDIR/RPMS
+mkdir -p $TMPDIR/SRPMS
+mkdir -p $TMPDIR/BUILD
+mkdir -p $TMPDIR/SOURCES
+mkdir -p $TMPDIR/SPECS
+
+if [ ! -f $PROJECT-$VERSION.tar.gz ]; then
+	echo "ERROR: $PROJECT-$VERSION.tar.gz does not exist."
+fi
+
+cp $PROJECT-$VERSION.tar.gz $TMPDIR/SOURCES/$PROJECT-$VERSION.tar.gz
+
+cat pkgscripts/rpm.spec | sed s/%{_blddir}/%{_tmppath}/g \
+	| sed s/#--\>//g > $TMPDIR/SPECS/$PKGNAME.spec
+
+rpmbuild -bs --define "_topdir $TMPDIR" $TMPDIR/SPECS/$PKGNAME.spec
+mv $TMPDIR/SRPMS/$PKGNAME-$VERSION-$BUILD.src.rpm $PKGNAME-$VERSION.src.rpm
+
+exit
diff --git a/3rdparty/libjpeg/src/release/maketarball.in b/3rdparty/libjpeg/src/release/maketarball.in
new file mode 100644
index 00000000..00a9c7e3
--- /dev/null
+++ b/3rdparty/libjpeg/src/release/maketarball.in
@@ -0,0 +1,51 @@
+#!/bin/sh
+
+set -u
+set -e
+trap onexit INT
+trap onexit TERM
+trap onexit EXIT
+
+TMPDIR=
+SUDO=
+
+onexit()
+{
+	if [ ! "$TMPDIR" = "" ]; then
+		rm -rf $TMPDIR
+	fi
+}
+
+uid()
+{
+	id | cut -f2 -d = | cut -f1 -d \(;
+}
+
+PKGNAME=@PKGNAME@
+VERSION=@VERSION@
+ARCH=@CPU_TYPE@
+OS=@CMAKE_SYSTEM_NAME@
+PREFIX=@CMAKE_INSTALL_PREFIX@
+
+umask 022
+rm -f $PKGNAME-$VERSION-$OS-$ARCH.tar.bz2
+TMPDIR=`mktemp -d /tmp/$PKGNAME-build.XXXXXX`
+mkdir -p $TMPDIR/install
+
+make install DESTDIR=$TMPDIR/install
+echo tartest >$TMPDIR/tartest
+GNUTAR=0
+BSDTAR=0
+tar cf $TMPDIR/tartest.tar --owner=root --group=root -C $TMPDIR tartest >/dev/null 2>&1 && GNUTAR=1
+if [ "$GNUTAR" = "1" ]; then
+	tar cf - --owner=root --group=root -C $TMPDIR/install .$PREFIX | bzip2 -c >$PKGNAME-$VERSION-$OS-$ARCH.tar.bz2
+else
+	tar cf $TMPDIR/tartest.tar --uid 0 --gid 0 -C $TMPDIR tartest >/dev/null 2>&1 && BSDTAR=1
+	if [ "$BSDTAR" = "1" ]; then
+		tar cf - --uid=0 --gid=0 -C $TMPDIR/install .$PREFIX | bzip2 -c >$PKGNAME-$VERSION-$OS-$ARCH.tar.bz2
+	else
+		tar cf - -C $TMPDIR/install .$PREFIX | bzip2 -c >$PKGNAME-$VERSION-$OS-$ARCH.tar.bz2
+	fi
+fi
+
+exit
diff --git a/3rdparty/libjpeg/src/release/rpm.spec.in b/3rdparty/libjpeg/src/release/rpm.spec.in
new file mode 100644
index 00000000..05410a6e
--- /dev/null
+++ b/3rdparty/libjpeg/src/release/rpm.spec.in
@@ -0,0 +1,224 @@
+%global _docdir %{_defaultdocdir}/%{name}-%{version}
+%define _prefix  @CMAKE_INSTALL_PREFIX@
+%define _bindir  @CMAKE_INSTALL_FULL_BINDIR@
+%define _datarootdir  @CMAKE_INSTALL_FULL_DATAROOTDIR@
+%define _includedir  @CMAKE_INSTALL_FULL_INCLUDEDIR@
+%define _javadir  @CMAKE_INSTALL_FULL_JAVADIR@
+%define _mandir  @CMAKE_INSTALL_FULL_MANDIR@
+%define _enable_static  @ENABLE_STATIC@
+%define _enable_shared  @ENABLE_SHARED@
+%define _with_turbojpeg  @WITH_TURBOJPEG@
+%define _with_java  @WITH_JAVA@
+
+%if "%{?__isa_bits:1}" == "1"
+%define _bits  %{__isa_bits}
+%else
+# RPM < 4.6
+%if "%{_lib}" == "lib64"
+%define _bits  64
+%else
+%define _bits  32
+%endif
+%endif
+
+#-->%if 1
+%if "%{_bits}" == "64"
+%define _libdir  %{_exec_prefix}/lib64
+%else
+%if "%{_prefix}" == "/opt/libjpeg-turbo"
+%define _libdir  %{_exec_prefix}/lib32
+%endif
+%endif
+#-->%else
+%define _libdir  @CMAKE_INSTALL_FULL_LIBDIR@
+#-->%endif
+
+Summary: A SIMD-accelerated JPEG codec that provides both the libjpeg and TurboJPEG APIs
+Name: @PKGNAME@
+Version: @VERSION@
+Vendor: @PKGVENDOR@
+URL: @PKGURL@
+Group: System Environment/Libraries
+#-->Source0: http://prdownloads.sourceforge.net/@CMAKE_PROJECT_NAME@/@CMAKE_PROJECT_NAME@-%{version}.tar.gz
+Release: @BUILD@
+License: BSD-style
+BuildRoot: %{_blddir}/%{name}-buildroot-%{version}-%{release}
+Requires: /sbin/ldconfig
+%if "%{_bits}" == "64"
+Provides: %{name} = %{version}-%{release}, @CMAKE_PROJECT_NAME@ = %{version}-%{release}, libturbojpeg.so()(64bit)
+%else
+Provides: %{name} = %{version}-%{release}, @CMAKE_PROJECT_NAME@ = %{version}-%{release}, libturbojpeg.so
+%endif
+
+%description
+libjpeg-turbo is a JPEG image codec that uses SIMD instructions to accelerate
+baseline JPEG compression and decompression on x86, x86-64, Arm, PowerPC, and
+MIPS systems, as well as progressive JPEG compression on x86, x86-64, and Arm
+systems.  On such systems, libjpeg-turbo is generally 2-6x as fast as libjpeg,
+all else being equal.  On other types of systems, libjpeg-turbo can still
+outperform libjpeg by a significant amount, by virtue of its highly-optimized
+Huffman coding routines.  In many cases, the performance of libjpeg-turbo
+rivals that of proprietary high-speed JPEG codecs.
+
+libjpeg-turbo implements both the traditional libjpeg API as well as the less
+powerful but more straightforward TurboJPEG API.  libjpeg-turbo also features
+colorspace extensions that allow it to compress from/decompress to 32-bit and
+big-endian pixel buffers (RGBX, XBGR, etc.), as well as a full-featured Java
+interface.
+
+libjpeg-turbo was originally based on libjpeg/SIMD, an MMX-accelerated
+derivative of libjpeg v6b developed by Miyasaka Masaru.  The TigerVNC and
+VirtualGL projects made numerous enhancements to the codec in 2009, and in
+early 2010, libjpeg-turbo spun off into an independent project, with the goal
+of making high-speed JPEG compression/decompression technology available to a
+broader range of users and developers.
+
+#-->%prep
+#-->%setup -q -n @CMAKE_PROJECT_NAME@-%{version}
+
+#-->%build
+#-->cmake -G"Unix Makefiles" -DCMAKE_BUILD_TYPE=@CMAKE_BUILD_TYPE@ \
+#-->  -DBUILD=%{release} \
+#-->  -DCMAKE_INSTALL_BINDIR=%{_bindir} \
+#-->  -DCMAKE_INSTALL_DATAROOTDIR=%{_datarootdir} \
+#-->  -DCMAKE_INSTALL_DOCDIR=%{_docdir} \
+#-->  -DCMAKE_INSTALL_INCLUDEDIR=%{_includedir} \
+#-->  -DCMAKE_INSTALL_JAVADIR=%{_javadir} \
+#-->  -DCMAKE_INSTALL_LIBDIR=%{_libdir} \
+#-->  -DCMAKE_INSTALL_MANDIR=%{_mandir} \
+#-->  -DCMAKE_INSTALL_PREFIX=%{_prefix} \
+#-->  -DCMAKE_POSITION_INDEPENDENT_CODE=@CMAKE_POSITION_INDEPENDENT_CODE@ \
+#-->  -DENABLE_SHARED=@ENABLE_SHARED@ -DENABLE_STATIC=@ENABLE_STATIC@ \
+#-->  -DSO_MAJOR_VERSION=@SO_MAJOR_VERSION@ \
+#-->  -DSO_MINOR_VERSION=@SO_MINOR_VERSION@ \
+#-->  -DJPEG_LIB_VERSION=@JPEG_LIB_VERSION@ \
+#-->  -DREQUIRE_SIMD=@REQUIRE_SIMD@ \
+#-->  -DWITH_12BIT=@WITH_12BIT@ -DWITH_ARITH_DEC=@WITH_ARITH_DEC@ \
+#-->  -DWITH_ARITH_ENC=@WITH_ARITH_ENC@ -DWITH_JAVA=@WITH_JAVA@ \
+#-->  -DWITH_JPEG7=@WITH_JPEG7@ -DWITH_JPEG8=@WITH_JPEG8@ \
+#-->  -DWITH_MEM_SRCDST=@WITH_MEM_SRCDST@ -DWITH_SIMD=@WITH_SIMD@ \
+#-->  -DWITH_TURBOJPEG=@WITH_TURBOJPEG@ .
+#-->make DESTDIR=$RPM_BUILD_ROOT
+
+%install
+rm -rf $RPM_BUILD_ROOT
+make install DESTDIR=$RPM_BUILD_ROOT
+/sbin/ldconfig -n $RPM_BUILD_ROOT%{_libdir}
+
+#-->%if 0
+
+# This is only needed to support in-tree RPM generation via 'make rpm'.  When
+# building from a SRPM, we control where things are installed via CMake
+# variables.
+
+safedirmove ()
+{
+	if [ "$1" = "$2" ]; then
+		return 0
+	fi
+	if [ "$1" = "" -o ! -d "$1" ]; then
+		echo safedirmove: source dir $1 is not valid
+		return 1
+	fi
+	if [ "$2" = "" -o -e "$2" ]; then
+		echo safedirmove: dest dir $2 is not valid
+		return 1
+	fi
+	if [ "$3" = "" -o -e "$3" ]; then
+		echo safedirmove: tmp dir $3 is not valid
+		return 1
+	fi
+	mkdir -p $3
+	mv $1/* $3/
+	rmdir $1
+	mkdir -p $2
+	mv $3/* $2/
+	rmdir $3
+	return 0
+}
+
+LJT_DOCDIR=@CMAKE_INSTALL_FULL_DOCDIR@
+if [ ! "$LJT_DOCDIR" = "%{_docdir}" ]; then
+	safedirmove $RPM_BUILD_ROOT/$LJT_DOCDIR $RPM_BUILD_ROOT/%{_docdir} $RPM_BUILD_ROOT/__tmpdoc
+fi
+
+#-->%endif
+
+LJT_DOCDIR=@CMAKE_INSTALL_FULL_DOCDIR@
+if [ "%{_prefix}" = "@CMAKE_INSTALL_DEFAULT_PREFIX@" -a "$LJT_DOCDIR" = "@CMAKE_INSTALL_DEFAULT_PREFIX@/doc" ]; then
+	ln -fs %{_docdir} $RPM_BUILD_ROOT/$LJT_DOCDIR
+fi
+
+%post -p /sbin/ldconfig
+
+%postun -p /sbin/ldconfig
+
+%clean
+rm -rf $RPM_BUILD_ROOT
+
+%files
+%defattr(-,root,root)
+%dir %{_docdir}
+%doc %{_docdir}/*
+%dir %{_prefix}
+%if "%{_prefix}" == "@CMAKE_INSTALL_DEFAULT_PREFIX@" && "%{_docdir}" != "%{_prefix}/doc"
+	%{_prefix}/doc
+%endif
+%dir %{_bindir}
+%{_bindir}/cjpeg
+%{_bindir}/djpeg
+%{_bindir}/jpegtran
+%if "%{_with_turbojpeg}" == "1"
+	%{_bindir}/tjbench
+%endif
+%{_bindir}/rdjpgcom
+%{_bindir}/wrjpgcom
+%dir %{_libdir}
+%if "%{_enable_shared}" == "1"
+	%{_libdir}/libjpeg.so.@SO_MAJOR_VERSION@.@SO_AGE@.@SO_MINOR_VERSION@
+	%{_libdir}/libjpeg.so.@SO_MAJOR_VERSION@
+	%{_libdir}/libjpeg.so
+%endif
+%if "%{_enable_static}" == "1"
+	%{_libdir}/libjpeg.a
+%endif
+%dir %{_libdir}/pkgconfig
+%{_libdir}/pkgconfig/libjpeg.pc
+%dir %{_libdir}/cmake
+%dir %{_libdir}/cmake/@CMAKE_PROJECT_NAME@
+%{_libdir}/cmake/@CMAKE_PROJECT_NAME@
+%if "%{_with_turbojpeg}" == "1"
+	%if "%{_enable_shared}" == "1" || "%{_with_java}" == "1"
+		%{_libdir}/libturbojpeg.so.@TURBOJPEG_SO_VERSION@
+		%{_libdir}/libturbojpeg.so.@TURBOJPEG_SO_MAJOR_VERSION@
+		%{_libdir}/libturbojpeg.so
+	%endif
+	%if "%{_enable_static}" == "1"
+		%{_libdir}/libturbojpeg.a
+	%endif
+	%{_libdir}/pkgconfig/libturbojpeg.pc
+%endif
+%dir %{_includedir}
+%{_includedir}/jconfig.h
+%{_includedir}/jerror.h
+%{_includedir}/jmorecfg.h
+%{_includedir}/jpeglib.h
+%if "%{_with_turbojpeg}" == "1"
+	%{_includedir}/turbojpeg.h
+%endif
+%dir %{_mandir}
+%dir %{_mandir}/man1
+%{_mandir}/man1/cjpeg.1*
+%{_mandir}/man1/djpeg.1*
+%{_mandir}/man1/jpegtran.1*
+%{_mandir}/man1/rdjpgcom.1*
+%{_mandir}/man1/wrjpgcom.1*
+%if "%{_prefix}" != "%{_datarootdir}"
+	%dir %{_datarootdir}
+%endif
+%if "%{_with_java}" == "1"
+	%dir %{_javadir}
+	%{_javadir}/turbojpeg.jar
+%endif
+
+%changelog
diff --git a/3rdparty/libjpeg/src/release/uninstall.in b/3rdparty/libjpeg/src/release/uninstall.in
new file mode 100644
index 00000000..34757b0c
--- /dev/null
+++ b/3rdparty/libjpeg/src/release/uninstall.in
@@ -0,0 +1,120 @@
+# Copyright (C)2009-2011, 2013, 2016, 2020 D. R. Commander.
+#                                          All Rights Reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# - Redistributions of source code must retain the above copyright notice,
+#   this list of conditions and the following disclaimer.
+# - Redistributions in binary form must reproduce the above copyright notice,
+#   this list of conditions and the following disclaimer in the documentation
+#   and/or other materials provided with the distribution.
+# - Neither the name of the libjpeg-turbo Project nor the names of its
+#   contributors may be used to endorse or promote products derived from this
+#   software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE 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 HOLDERS 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.
+
+#!/bin/sh
+
+if [ ! "`id -u`" = "0" ]; then
+	echo "ERROR: This script must be executed as root"
+	exit -1
+fi
+
+PKGNAME=@PKGNAME@
+PKGID=@PKGID@
+RECEIPT=/Library/Receipts/$PKGNAME.pkg
+
+LSBOM=
+if [ -d $RECEIPT ]; then
+	LSBOM='lsbom -s -f -l '$RECEIPT'/Contents/Archive.bom'
+else
+	LSBOM='pkgutil --files '$PKGID
+fi
+
+mylsbom()
+{
+	$LSBOM || (echo "ERROR: Could not list package contents"; exit -1)
+}
+
+echo Removing package files ...
+EXITSTATUS=0
+pushd /
+mylsbom | while read file; do
+	if [ ! -d "$file" ]; then rm "$file" 2>&1 || EXITSTATUS=-1; fi
+done
+popd
+
+echo Removing package directories ...
+PREFIX=@CMAKE_INSTALL_PREFIX@
+BINDIR=@CMAKE_INSTALL_FULL_BINDIR@
+DATAROOTDIR=@CMAKE_INSTALL_FULL_DATAROOTDIR@
+INCLUDEDIR=@CMAKE_INSTALL_FULL_INCLUDEDIR@
+JAVADIR=@CMAKE_INSTALL_FULL_JAVADIR@
+LIBDIR=@CMAKE_INSTALL_FULL_LIBDIR@
+MANDIR=@CMAKE_INSTALL_FULL_MANDIR@
+
+if [ -d $BINDIR ]; then
+	rmdir $BINDIR 2>&1 || EXITSTATUS=-1
+fi
+if [ -d $LIBDIR/pkgconfig ]; then
+	rmdir $LIBDIR/pkgconfig 2>&1 || EXITSTATUS=-1
+fi
+if [ -d $LIBDIR/cmake/@CMAKE_PROJECT_NAME@ ]; then
+	rmdir $LIBDIR/cmake/@CMAKE_PROJECT_NAME@ || EXITSTATUS=-1
+fi
+if [ -d $LIBDIR/cmake ]; then
+	rmdir $LIBDIR/cmake || EXITSTATUS=-1
+fi
+if [ -d $LIBDIR ]; then
+	rmdir $LIBDIR 2>&1 || EXITSTATUS=-1
+fi
+if [ -d $INCLUDEDIR ]; then
+	rmdir $INCLUDEDIR 2>&1 || EXITSTATUS=-1
+fi
+if [ "$PREFIX" = "@CMAKE_INSTALL_DEFAULT_PREFIX@" -a "$LIBDIR" = "@CMAKE_INSTALL_DEFAULT_PREFIX@/lib" ]; then
+	if [ -h $LIBDIR\32 ]; then
+		rm $LIBDIR\32 2>&1 || EXITSTATUS=-1
+	fi
+	if [ -h $LIBDIR\64 ]; then
+		rm $LIBDIR\64 2>&1 || EXITSTATUS=-1
+	fi
+fi
+if [ -d $MANDIR/man1 ]; then
+	rmdir $MANDIR/man1 2>&1 || EXITSTATUS=-1
+fi
+if [ -d $MANDIR ]; then
+	rmdir $MANDIR 2>&1 || EXITSTATUS=-1
+fi
+if [ -d "$JAVADIR" ]; then
+	rmdir $JAVADIR 2>&1 || EXITSTATUS=-1
+fi
+if [ -d $DATAROOTDIR -a "$DATAROOTDIR" != "$PREFIX" ]; then
+	rmdir $DATAROOTDIR 2>&1 || EXITSTATUS=-1
+fi
+if [ "$PREFIX" = "@CMAKE_INSTALL_DEFAULT_PREFIX@" -a -h "$PREFIX/doc" ]; then
+	rm $PREFIX/doc 2>&1 || EXITSTATUS=-1
+fi
+rmdir $PREFIX 2>&1 || EXITSTATUS=-1
+rmdir /Library/Documentation/$PKGNAME 2>&1 || EXITSTATUS=-1
+
+if [ -d $RECEIPT ]; then
+	echo Removing package receipt ...
+	rm -r $RECEIPT 2>&1 || EXITSTATUS=-1
+else
+	echo Forgetting package $PKGID ...
+	pkgutil --forget $PKGID
+fi
+
+exit $EXITSTATUS
diff --git a/3rdparty/libjpeg/src/sharedlib/CMakeLists.txt b/3rdparty/libjpeg/src/sharedlib/CMakeLists.txt
new file mode 100644
index 00000000..78a2f28b
--- /dev/null
+++ b/3rdparty/libjpeg/src/sharedlib/CMakeLists.txt
@@ -0,0 +1,102 @@
+# Anything that must be linked against the shared C library on Windows must
+# be built in this subdirectory, because CMake doesn't allow us to override
+# the compiler flags for each build type except at directory scope.  Note
+# to CMake developers:  Add a COMPILE_FLAGS_<CONFIG> target property, or
+# better yet, provide a friendly way of configuring a Windows target to use the
+# static C library.
+
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/..)
+set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/..)
+set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/..)
+
+if(MSVC)
+  # Build all configurations against shared C library
+  foreach(var CMAKE_C_FLAGS CMAKE_C_FLAGS_DEBUG CMAKE_C_FLAGS_RELEASE
+    CMAKE_C_FLAGS_MINSIZEREL CMAKE_C_FLAGS_RELWITHDEBINFO)
+    if(${var} MATCHES "/MT")
+      string(REGEX REPLACE "/MT" "/MD" ${var} "${${var}}")
+    endif()
+  endforeach()
+endif()
+
+foreach(src ${JPEG_SOURCES})
+  set(JPEG_SRCS ${JPEG_SRCS} ../${src})
+endforeach()
+
+if(WITH_SIMD AND (MSVC_IDE OR XCODE))
+  # This tells CMake that the "source" files haven't been generated yet
+  set_source_files_properties(${SIMD_OBJS} PROPERTIES GENERATED 1)
+endif()
+
+if(WIN32)
+  if(WITH_MEM_SRCDST)
+    set(DEFFILE ../win/jpeg${SO_MAJOR_VERSION}-memsrcdst.def)
+  else()
+    set(DEFFILE ../win/jpeg${SO_MAJOR_VERSION}.def)
+  endif()
+endif()
+add_library(jpeg SHARED ${JPEG_SRCS} ${DEFFILE} $<TARGET_OBJECTS:simd>
+  ${SIMD_OBJS})
+
+set_target_properties(jpeg PROPERTIES SOVERSION ${SO_MAJOR_VERSION}
+  VERSION ${SO_MAJOR_VERSION}.${SO_AGE}.${SO_MINOR_VERSION})
+if(APPLE AND (NOT CMAKE_OSX_DEPLOYMENT_TARGET OR
+              CMAKE_OSX_DEPLOYMENT_TARGET VERSION_GREATER 10.4))
+  if(NOT CMAKE_SHARED_LIBRARY_RUNTIME_C_FLAG)
+    set(CMAKE_SHARED_LIBRARY_RUNTIME_C_FLAG "-Wl,-rpath,")
+  endif()
+  set_target_properties(jpeg PROPERTIES MACOSX_RPATH 1)
+endif()
+if(MAPFLAG)
+  set_target_properties(jpeg PROPERTIES
+    LINK_FLAGS "${MAPFLAG}${CMAKE_CURRENT_BINARY_DIR}/../libjpeg.map")
+endif()
+if(MSVC)
+  set_target_properties(jpeg PROPERTIES
+    RUNTIME_OUTPUT_NAME jpeg${SO_MAJOR_VERSION})
+  # The jsimd_*.c file is built using /MT, so this prevents a linker warning.
+  set_target_properties(jpeg PROPERTIES LINK_FLAGS "/NODEFAULTLIB:LIBCMT /NODEFAULTLIB:LIBCMTD")
+elseif(MINGW)
+  set_target_properties(jpeg PROPERTIES SUFFIX -${SO_MAJOR_VERSION}.dll)
+endif()
+
+if(WIN32)
+  set(USE_SETMODE "-DUSE_SETMODE")
+endif()
+if(WITH_12BIT)
+  set(COMPILE_FLAGS "-DGIF_SUPPORTED -DPPM_SUPPORTED ${USE_SETMODE}")
+else()
+  set(COMPILE_FLAGS "-DBMP_SUPPORTED -DGIF_SUPPORTED -DPPM_SUPPORTED -DTARGA_SUPPORTED ${USE_SETMODE}")
+  set(CJPEG_BMP_SOURCES ../rdbmp.c ../rdtarga.c)
+  set(DJPEG_BMP_SOURCES ../wrbmp.c ../wrtarga.c)
+endif()
+
+add_executable(cjpeg ../cjpeg.c ../cdjpeg.c ../rdgif.c ../rdppm.c
+  ../rdswitch.c ${CJPEG_BMP_SOURCES})
+set_property(TARGET cjpeg PROPERTY COMPILE_FLAGS ${COMPILE_FLAGS})
+target_link_libraries(cjpeg jpeg)
+
+add_executable(djpeg ../djpeg.c ../cdjpeg.c ../rdcolmap.c ../rdswitch.c
+  ../wrgif.c ../wrppm.c ${DJPEG_BMP_SOURCES})
+set_property(TARGET djpeg PROPERTY COMPILE_FLAGS ${COMPILE_FLAGS})
+target_link_libraries(djpeg jpeg)
+
+add_executable(jpegtran ../jpegtran.c ../cdjpeg.c ../rdswitch.c ../transupp.c)
+target_link_libraries(jpegtran jpeg)
+set_property(TARGET jpegtran PROPERTY COMPILE_FLAGS "${USE_SETMODE}")
+
+add_executable(jcstest ../jcstest.c)
+target_link_libraries(jcstest jpeg)
+
+install(TARGETS jpeg EXPORT ${CMAKE_PROJECT_NAME}Targets
+  INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
+  ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+  LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+  RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
+install(TARGETS cjpeg djpeg jpegtran
+  RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
+if(NOT CMAKE_VERSION VERSION_LESS "3.1" AND MSVC AND
+  CMAKE_C_LINKER_SUPPORTS_PDB)
+  install(FILES "$<TARGET_PDB_FILE:jpeg>"
+    DESTINATION ${CMAKE_INSTALL_BINDIR} OPTIONAL)
+endif()
diff --git a/3rdparty/libjpeg/src/simd/CMakeLists.txt b/3rdparty/libjpeg/src/simd/CMakeLists.txt
new file mode 100644
index 00000000..1fec085c
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/CMakeLists.txt
@@ -0,0 +1,433 @@
+macro(simd_fail message)
+  if(REQUIRE_SIMD)
+    message(FATAL_ERROR "${message}.")
+  else()
+    message(WARNING "${message}.  Performance will suffer.")
+    set(WITH_SIMD 0 PARENT_SCOPE)
+  endif()
+endmacro()
+
+
+###############################################################################
+# x86[-64] (NASM)
+###############################################################################
+
+if(CPU_TYPE STREQUAL "x86_64" OR CPU_TYPE STREQUAL "i386")
+
+set(CMAKE_ASM_NASM_FLAGS_DEBUG_INIT "-g")
+set(CMAKE_ASM_NASM_FLAGS_RELWITHDEBINFO_INIT "-g")
+
+# Allow the location of the NASM executable to be specified using the ASM_NASM
+# environment variable.  This should happen automatically, but unfortunately
+# enable_language(ASM_NASM) doesn't parse the ASM_NASM environment variable
+# until after CMAKE_ASM_NASM_COMPILER has been populated with the results of
+# searching for NASM or YASM in the PATH.
+if(NOT DEFINED CMAKE_ASM_NASM_COMPILER AND DEFINED ENV{ASM_NASM})
+  set(CMAKE_ASM_NASM_COMPILER $ENV{ASM_NASM})
+endif()
+
+if(CPU_TYPE STREQUAL "x86_64")
+  if(CYGWIN)
+    set(CMAKE_ASM_NASM_OBJECT_FORMAT win64)
+  endif()
+  if(CMAKE_C_COMPILER_ABI MATCHES "ELF X32")
+    set(CMAKE_ASM_NASM_OBJECT_FORMAT elfx32)
+  endif()
+elseif(CPU_TYPE STREQUAL "i386")
+  if(BORLAND)
+    set(CMAKE_ASM_NASM_OBJECT_FORMAT obj)
+  elseif(CYGWIN)
+    set(CMAKE_ASM_NASM_OBJECT_FORMAT win32)
+  endif()
+endif()
+
+if(NOT REQUIRE_SIMD)
+  include(CheckLanguage)
+  check_language(ASM_NASM)
+  if(NOT CMAKE_ASM_NASM_COMPILER)
+    simd_fail("SIMD extensions disabled: could not find NASM compiler")
+    set(SIMD_SOURCES_ALL jsimd_none.c PARENT_SCOPE) 
+    message("SIMD_SOURCES_ALL ="${SIMD_SOURCES_ALL} )
+    return()
+  endif()
+endif()
+enable_language(ASM_NASM)
+message(STATUS "CMAKE_ASM_NASM_COMPILER = ${CMAKE_ASM_NASM_COMPILER}")
+
+if(CMAKE_ASM_NASM_OBJECT_FORMAT MATCHES "macho*")
+  set(CMAKE_ASM_NASM_FLAGS "${CMAKE_ASM_NASM_FLAGS} -DMACHO")
+elseif(CMAKE_ASM_NASM_OBJECT_FORMAT MATCHES "elf*")
+  set(CMAKE_ASM_NASM_FLAGS "${CMAKE_ASM_NASM_FLAGS} -DELF")
+  set(CMAKE_ASM_NASM_DEBUG_FORMAT "dwarf2")
+endif()
+if(CPU_TYPE STREQUAL "x86_64")
+  if(WIN32 OR CYGWIN)
+    set(CMAKE_ASM_NASM_FLAGS "${CMAKE_ASM_NASM_FLAGS} -DWIN64")
+  endif()
+  set(CMAKE_ASM_NASM_FLAGS "${CMAKE_ASM_NASM_FLAGS} -D__x86_64__")
+elseif(CPU_TYPE STREQUAL "i386")
+  if(BORLAND)
+    set(CMAKE_ASM_NASM_FLAGS "${CMAKE_ASM_NASM_FLAGS} -DOBJ32")
+  elseif(WIN32 OR CYGWIN)
+    set(CMAKE_ASM_NASM_FLAGS "${CMAKE_ASM_NASM_FLAGS} -DWIN32")
+  endif()
+endif()
+
+message(STATUS "CMAKE_ASM_NASM_OBJECT_FORMAT = ${CMAKE_ASM_NASM_OBJECT_FORMAT}")
+
+if(NOT CMAKE_ASM_NASM_OBJECT_FORMAT)
+  simd_fail("SIMD extensions disabled: could not determine NASM object format")
+  return()
+endif()
+
+get_filename_component(CMAKE_ASM_NASM_COMPILER_TYPE
+  "${CMAKE_ASM_NASM_COMPILER}" NAME_WE)
+if(CMAKE_ASM_NASM_COMPILER_TYPE MATCHES "yasm")
+  foreach(var CMAKE_ASM_NASM_FLAGS_DEBUG CMAKE_ASM_NASM_FLAGS_RELWITHDEBINFO)
+    if(${var} STREQUAL "-g")
+      if(CMAKE_ASM_NASM_DEBUG_FORMAT)
+        set_property(CACHE ${var} PROPERTY VALUE "-g ${CMAKE_ASM_NASM_DEBUG_FORMAT}")
+      else()
+        set_property(CACHE ${var} PROPERTY VALUE "")
+      endif()
+    endif()
+  endforeach()
+endif()
+
+if(NOT WIN32 AND (CMAKE_POSITION_INDEPENDENT_CODE OR ENABLE_SHARED))
+  set(CMAKE_ASM_NASM_FLAGS "${CMAKE_ASM_NASM_FLAGS} -DPIC")
+endif()
+
+string(TOUPPER ${CMAKE_BUILD_TYPE} CMAKE_BUILD_TYPE_UC)
+set(EFFECTIVE_ASM_NASM_FLAGS "${CMAKE_ASM_NASM_FLAGS} ${CMAKE_ASM_NASM_FLAGS_${CMAKE_BUILD_TYPE_UC}}")
+message(STATUS "CMAKE_ASM_NASM_FLAGS = ${EFFECTIVE_ASM_NASM_FLAGS}")
+
+set(CMAKE_ASM_NASM_FLAGS "${CMAKE_ASM_NASM_FLAGS} -I\"${CMAKE_CURRENT_SOURCE_DIR}/nasm/\" -I\"${CMAKE_CURRENT_SOURCE_DIR}/${CPU_TYPE}/\"")
+
+set(GREP grep)
+if(CMAKE_SYSTEM_NAME STREQUAL "SunOS")
+  set(GREP ggrep)
+endif()
+add_custom_target(jsimdcfg COMMAND
+  ${CMAKE_C_COMPILER} -E -I${CMAKE_BINARY_DIR} -I${CMAKE_CURRENT_BINARY_DIR}
+    -I${CMAKE_CURRENT_SOURCE_DIR}
+    ${CMAKE_CURRENT_SOURCE_DIR}/nasm/jsimdcfg.inc.h |
+  ${GREP} -E '^[\;%]|^\ %' | sed 's%_cpp_protection_%%' |
+  sed 's@% define@%define@g' >${CMAKE_CURRENT_SOURCE_DIR}/nasm/jsimdcfg.inc)
+
+if(CPU_TYPE STREQUAL "x86_64")
+  set(SIMD_SOURCES simd/x86_64/jsimdcpu.asm simd/x86_64/jfdctflt-sse.asm
+    simd/x86_64/jccolor-sse2.asm simd/x86_64/jcgray-sse2.asm simd/x86_64/jchuff-sse2.asm
+    simd/x86_64/jcphuff-sse2.asm simd/x86_64/jcsample-sse2.asm simd/x86_64/jdcolor-sse2.asm
+    simd/x86_64/jdmerge-sse2.asm simd/x86_64/jdsample-sse2.asm simd/x86_64/jfdctfst-sse2.asm
+    simd/x86_64/jfdctint-sse2.asm simd/x86_64/jidctflt-sse2.asm simd/x86_64/jidctfst-sse2.asm
+    simd/x86_64/jidctint-sse2.asm simd/x86_64/jidctred-sse2.asm simd/x86_64/jquantf-sse2.asm
+    simd/x86_64/jquanti-sse2.asm
+    simd/x86_64/jccolor-avx2.asm simd/x86_64/jcgray-avx2.asm simd/x86_64/jcsample-avx2.asm
+    simd/x86_64/jdcolor-avx2.asm simd/x86_64/jdmerge-avx2.asm simd/x86_64/jdsample-avx2.asm
+    simd/x86_64/jfdctint-avx2.asm simd/x86_64/jidctint-avx2.asm simd/x86_64/jquanti-avx2.asm  )
+else()
+  set(SIMD_SOURCES simd/i386/jsimdcpu.asm simd/i386/jfdctflt-3dn.asm
+    simd/i386/jidctflt-3dn.asm simd/i386/jquant-3dn.asm
+    simd/i386/jccolor-mmx.asm simd/i386/jcgray-mmx.asm simd/i386/jcsample-mmx.asm
+    simd/i386/jdcolor-mmx.asm simd/i386/jdmerge-mmx.asm simd/i386/jdsample-mmx.asm
+    simd/i386/jfdctfst-mmx.asm simd/i386/jfdctint-mmx.asm simd/i386/jidctfst-mmx.asm
+    simd/i386/jidctint-mmx.asm simd/i386/jidctred-mmx.asm simd/i386/jquant-mmx.asm
+    simd/i386/jfdctflt-sse.asm simd/i386/jidctflt-sse.asm simd/i386/jquant-sse.asm
+    simd/i386/jccolor-sse2.asm simd/i386/jcgray-sse2.asm simd/i386/jchuff-sse2.asm
+    simd/i386/jcphuff-sse2.asm simd/i386/jcsample-sse2.asm simd/i386/jdcolor-sse2.asm
+    simd/i386/jdmerge-sse2.asm simd/i386/jdsample-sse2.asm simd/i386/jfdctfst-sse2.asm
+    simd/i386/jfdctint-sse2.asm simd/i386/jidctflt-sse2.asm simd/i386/jidctfst-sse2.asm
+    simd/i386/jidctint-sse2.asm simd/i386/jidctred-sse2.asm simd/i386/jquantf-sse2.asm
+    simd/i386/jquanti-sse2.asm
+    simd/i386/jccolor-avx2.asm simd/i386/jcgray-avx2.asm simd/i386/jcsample-avx2.asm
+    simd/i386/jdcolor-avx2.asm simd/i386/jdmerge-avx2.asm simd/i386/jdsample-avx2.asm
+    simd/i386/jfdctint-avx2.asm simd/i386/jidctint-avx2.asm simd/i386/jquanti-avx2.asm )
+endif()
+
+if(MSVC_IDE)
+  set(OBJDIR "${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}")
+  string(REGEX REPLACE " " ";" CMAKE_ASM_NASM_FLAGS "${CMAKE_ASM_NASM_FLAGS}")
+elseif(XCODE)
+  set(OBJDIR "${CMAKE_CURRENT_BINARY_DIR}")
+  string(REGEX REPLACE " " ";" CMAKE_ASM_NASM_FLAGS "${CMAKE_ASM_NASM_FLAGS}")
+endif()
+
+file(GLOB INC_FILES nasm/*.inc)
+
+foreach(file ${SIMD_SOURCES})
+  set(OBJECT_DEPENDS "")
+  if(${file} MATCHES jccolor)
+    string(REGEX REPLACE "jccolor" "jccolext" DEPFILE ${file})
+    set(OBJECT_DEPENDS ${OBJECT_DEPENDS}
+      ${CMAKE_CURRENT_SOURCE_DIR}/${DEPFILE})
+  endif()
+  if(${file} MATCHES jcgray)
+    string(REGEX REPLACE "jcgray" "jcgryext" DEPFILE ${file})
+    set(OBJECT_DEPENDS ${OBJECT_DEPENDS}
+      ${CMAKE_CURRENT_SOURCE_DIR}/${DEPFILE})
+  endif()
+  if(${file} MATCHES jdcolor)
+    string(REGEX REPLACE "jdcolor" "jdcolext" DEPFILE ${file})
+    set(OBJECT_DEPENDS ${OBJECT_DEPENDS}
+      ${CMAKE_CURRENT_SOURCE_DIR}/${DEPFILE})
+  endif()
+  if(${file} MATCHES jdmerge)
+    string(REGEX REPLACE "jdmerge" "jdmrgext" DEPFILE ${file})
+    set(OBJECT_DEPENDS ${OBJECT_DEPENDS}
+      ${CMAKE_CURRENT_SOURCE_DIR}/${DEPFILE})
+  endif()
+  set(OBJECT_DEPENDS ${OBJECT_DEPENDS} ${INC_FILES})
+  if(MSVC_IDE OR XCODE)
+    # The CMake Visual Studio generators do not work properly with the ASM_NASM
+    # language, so we have to go rogue here and use a custom command like we
+    # did in prior versions of libjpeg-turbo.  (This is why we can't have nice
+    # things.)
+    string(REGEX REPLACE "${CPU_TYPE}/" "" filename ${file})
+    set(SIMD_OBJ ${OBJDIR}/${filename}${CMAKE_C_OUTPUT_EXTENSION})
+    add_custom_command(OUTPUT ${SIMD_OBJ} DEPENDS ${file} ${OBJECT_DEPENDS}
+      COMMAND ${CMAKE_ASM_NASM_COMPILER} -f${CMAKE_ASM_NASM_OBJECT_FORMAT}
+        ${CMAKE_ASM_NASM_FLAGS} ${CMAKE_CURRENT_SOURCE_DIR}/${file}
+        -o${SIMD_OBJ})
+    set(SIMD_OBJS ${SIMD_OBJS} ${SIMD_OBJ})
+  else()
+    set_source_files_properties(${file} PROPERTIES OBJECT_DEPENDS
+      "${OBJECT_DEPENDS}")
+  endif()
+endforeach()
+
+if(MSVC_IDE OR XCODE)
+  set(SIMD_OBJS ${SIMD_OBJS} PARENT_SCOPE)
+#  add_library(simd OBJECT ${CPU_TYPE}/jsimd.c)
+#  add_custom_target(simd-objs DEPENDS ${SIMD_OBJS})
+#  add_dependencies(simd simd-objs)
+set(SIMD_SOURCES ${SIMD_SOURCES} a${CPU_TYPE}/jsimd.c PARENT_SCOPE)
+message("SIMD_SOURCES ="${SIMD_SOURCES} )
+else()
+#  add_library(simd OBJECT ${SIMD_SOURCES} ${CPU_TYPE}/jsimd.c)
+set(SIMD_SOURCES ${SIMD_SOURCES} a${CPU_TYPE}/jsimd.c PARENT_SCOPE)
+message("SIMD_SOURCES ="${SIMD_SOURCES} )
+endif()
+if(NOT WIN32 AND (CMAKE_POSITION_INDEPENDENT_CODE OR ENABLE_SHARED))
+  set_target_properties(simd PROPERTIES POSITION_INDEPENDENT_CODE 1)
+endif()
+set(SIMD_SOURCES_ALL ${SIMD_SOURCES} PARENT_SCOPE) 
+
+###############################################################################
+# Arm (Intrinsics or GAS)
+###############################################################################
+
+elseif(CPU_TYPE STREQUAL "arm64" OR CPU_TYPE STREQUAL "arm")
+
+include(CheckSymbolExists)
+if(BITS EQUAL 32)
+  set(CMAKE_REQUIRED_FLAGS -mfpu=neon)
+endif()
+check_symbol_exists(vld1_s16_x3 arm_neon.h HAVE_VLD1_S16_X3)
+check_symbol_exists(vld1_u16_x2 arm_neon.h HAVE_VLD1_U16_X2)
+check_symbol_exists(vld1q_u8_x4 arm_neon.h HAVE_VLD1Q_U8_X4)
+if(BITS EQUAL 32)
+  unset(CMAKE_REQUIRED_FLAGS)
+endif()
+configure_file(arm/neon-compat.h.in arm/neon-compat.h @ONLY)
+include_directories(${CMAKE_CURRENT_BINARY_DIR}/arm)
+
+# GCC (as of this writing) and some older versions of Clang do not have a full
+# or optimal set of Neon intrinsics, so for performance reasons, when using
+# those compilers, we default to using the older GAS implementation of the Neon
+# SIMD extensions for certain algorithms.  The presence or absence of the three
+# intrinsics we tested above is a reasonable proxy for this.  We always default
+# to using the full Neon intrinsics implementation when building for macOS or
+# iOS, to avoid the need for gas-preprocessor.
+if((HAVE_VLD1_S16_X3 AND HAVE_VLD1_U16_X2 AND HAVE_VLD1Q_U8_X4) OR APPLE)
+  set(DEFAULT_NEON_INTRINSICS 1)
+else()
+  set(DEFAULT_NEON_INTRINSICS 0)
+endif()
+option(NEON_INTRINSICS
+  "Because GCC (as of this writing) and some older versions of Clang do not have a full or optimal set of Neon intrinsics, for performance reasons, the default when building libjpeg-turbo with those compilers is to continue using the older GAS implementation of the Neon SIMD extensions for certain algorithms.  Setting this option forces the full Neon intrinsics implementation to be used with all compilers.  Unsetting this option forces the hybrid GAS/intrinsics implementation to be used with all compilers."
+  ${DEFAULT_NEON_INTRINSICS})
+boolean_number(NEON_INTRINSICS PARENT_SCOPE)
+if(NEON_INTRINSICS)
+  add_definitions(-DNEON_INTRINSICS)
+  message(STATUS "Use full Neon SIMD intrinsics implementation (NEON_INTRINSICS = ${NEON_INTRINSICS})")
+else()
+  message(STATUS "Use partial Neon SIMD intrinsics implementation (NEON_INTRINSICS = ${NEON_INTRINSICS})")
+endif()
+
+set(SIMD_SOURCES simd/arm/jcphuff-neon.c simd/arm/jcgray-neon.c  simd/arm/jcsample-neon.c
+  simd/arm/jdmerge-neon.c simd/arm/jdsample-neon.c simd/arm/jfdctfst-neon.c
+  simd/arm/jidctred-neon.c simd/arm/jquanti-neon.c )
+
+if(NEON_INTRINSICS)
+  set(SIMD_SOURCES ${SIMD_SOURCES} simd/arm/jccolor-neon.c simd/arm/jidctint-neon.c )
+endif()
+if(NEON_INTRINSICS OR BITS EQUAL 64)
+  set(SIMD_SOURCES ${SIMD_SOURCES} simd/arm/jidctfst-neon.c )
+  message("SIMD_SOURCES 64 ="${SIMD_SOURCES} )
+endif()
+if(NEON_INTRINSICS OR BITS EQUAL 32)
+  set(SIMD_SOURCES ${SIMD_SOURCES} simd/arm/aarch${BITS}/jchuff-neon.c
+    simd/arm/jdcolor-neon.c simd/arm/jfdctint-neon.c )
+endif()
+if(BITS EQUAL 32)
+  set_source_files_properties(${SIMD_SOURCES} COMPILE_FLAGS -mfpu=neon)
+endif()
+if(NOT NEON_INTRINSICS)
+  enable_language(ASM)
+
+  set(CMAKE_ASM_FLAGS "${CMAKE_C_FLAGS} ${CMAKE_ASM_FLAGS}")
+
+  string(TOUPPER ${CMAKE_BUILD_TYPE} CMAKE_BUILD_TYPE_UC)
+  set(EFFECTIVE_ASM_FLAGS "${CMAKE_ASM_FLAGS} ${CMAKE_ASM_FLAGS_${CMAKE_BUILD_TYPE_UC}}")
+  message(STATUS "CMAKE_ASM_FLAGS = ${EFFECTIVE_ASM_FLAGS}")
+
+  set(SIMD_SOURCES ${SIMD_SOURCES} simd/arm/aarch${BITS}/jsimd_neon.S )
+endif()
+set(SIMD_SOURCES ${SIMD_SOURCES} simd/arm/aarch${BITS}/jsimd.c )
+message("SIMD_SOURCES ="${SIMD_SOURCES} )
+#add_library(simd OBJECT ${SIMD_SOURCES} arm/aarch${BITS}/jsimd.c)
+
+#if(CMAKE_POSITION_INDEPENDENT_CODE OR ENABLE_SHARED)
+#  set_target_properties(simd PROPERTIES POSITION_INDEPENDENT_CODE 1)
+#endif()
+
+set(SIMD_SOURCES_ALL ${SIMD_SOURCES} PARENT_SCOPE) 
+###############################################################################
+# MIPS (GAS)
+###############################################################################
+
+elseif(CPU_TYPE STREQUAL "mips" OR CPU_TYPE STREQUAL "mipsel")
+
+enable_language(ASM)
+
+string(TOUPPER ${CMAKE_BUILD_TYPE} CMAKE_BUILD_TYPE_UC)
+set(EFFECTIVE_ASM_FLAGS "${CMAKE_ASM_FLAGS} ${CMAKE_ASM_FLAGS_${CMAKE_BUILD_TYPE_UC}}")
+message(STATUS "CMAKE_ASM_FLAGS = ${EFFECTIVE_ASM_FLAGS}")
+
+set(CMAKE_REQUIRED_FLAGS -mdspr2)
+
+check_c_source_compiles("
+  #if !(defined(__mips__) && __mips_isa_rev >= 2)
+  #error MIPS DSPr2 is currently only available on MIPS32r2 platforms.
+  #endif
+  int main(void) {
+    int c = 0, a = 0, b = 0;
+    __asm__ __volatile__ (
+      \"precr.qb.ph %[c], %[a], %[b]\"
+      : [c] \"=r\" (c)
+      : [a] \"r\" (a), [b] \"r\" (b)
+    );
+    return c;
+  }" HAVE_DSPR2)
+
+unset(CMAKE_REQUIRED_FLAGS)
+
+if(NOT HAVE_DSPR2)
+  simd_fail("SIMD extensions not available for this CPU")
+  return()
+endif()
+
+#add_library(simd OBJECT mips/jsimd_dspr2.S mips/jsimd.c)
+
+if(CMAKE_POSITION_INDEPENDENT_CODE OR ENABLE_SHARED)
+  set_target_properties(simd PROPERTIES POSITION_INDEPENDENT_CODE 1)
+endif()
+
+###############################################################################
+# MIPS64 (Intrinsics)
+###############################################################################
+
+elseif(CPU_TYPE STREQUAL "loongson" OR CPU_TYPE MATCHES "mips64*")
+
+set(CMAKE_REQUIRED_FLAGS -Wa,-mloongson-mmi,-mloongson-ext)
+
+check_c_source_compiles("
+  int main(void) {
+    int c = 0, a = 0, b = 0;
+    asm (
+      \"paddb %0, %1, %2\"
+      : \"=f\" (c)
+      : \"f\" (a), \"f\" (b)
+    );
+    return c;
+  }" HAVE_MMI)
+
+unset(CMAKE_REQUIRED_FLAGS)
+
+if(NOT HAVE_MMI)
+  simd_fail("SIMD extensions not available for this CPU")
+  return()
+endif()
+
+set(SIMD_SOURCES simd/mips64/jccolor-mmi.c simd/mips64/jcgray-mmi.c simd/mips64/jcsample-mmi.c
+  simd/mips64/jdcolor-mmi.c simd/mips64/jdmerge-mmi.c simd/mips64/jdsample-mmi.c
+  simd/mips64/jfdctfst-mmi.c simd/mips64/jfdctint-mmi.c simd/mips64/jidctfst-mmi.c
+  simd/mips64/jidctint-mmi.c simd/mips64/jquanti-mmi.c )
+
+if(CMAKE_COMPILER_IS_GNUCC)
+  foreach(file ${SIMD_SOURCES})
+    set_property(SOURCE ${file} APPEND_STRING PROPERTY COMPILE_FLAGS
+      " -fno-strict-aliasing")
+  endforeach()
+endif()
+foreach(file ${SIMD_SOURCES})
+  set_property(SOURCE ${file} APPEND_STRING PROPERTY COMPILE_FLAGS
+    " -Wa,-mloongson-mmi,-mloongson-ext")
+endforeach()
+
+#add_library(simd OBJECT ${SIMD_SOURCES} mips64/jsimd.c)
+
+if(CMAKE_POSITION_INDEPENDENT_CODE OR ENABLE_SHARED)
+  set_target_properties(simd PROPERTIES POSITION_INDEPENDENT_CODE 1)
+endif()
+set(SIMD_SOURCES_ALL ${SIMD_SOURCES} PARENT_SCOPE) 
+###############################################################################
+# PowerPC (Intrinsics)
+###############################################################################
+
+elseif(CPU_TYPE STREQUAL "powerpc")
+
+set(CMAKE_REQUIRED_FLAGS -maltivec)
+
+check_c_source_compiles("
+  #include <altivec.h>
+  int main(void) {
+    __vector int vi = { 0, 0, 0, 0 };
+    int i[4];
+    vec_st(vi, 0, i);
+    return i[0];
+  }" HAVE_ALTIVEC)
+
+unset(CMAKE_REQUIRED_FLAGS)
+
+if(NOT HAVE_ALTIVEC)
+  simd_fail("SIMD extensions not available for this CPU (PowerPC SPE)")
+  return()
+endif()
+
+set(SIMD_SOURCES powerpc/jccolor-altivec.c powerpc/jcgray-altivec.c
+  powerpc/jcsample-altivec.c powerpc/jdcolor-altivec.c
+  powerpc/jdmerge-altivec.c powerpc/jdsample-altivec.c
+  powerpc/jfdctfst-altivec.c powerpc/jfdctint-altivec.c
+  powerpc/jidctfst-altivec.c powerpc/jidctint-altivec.c
+  powerpc/jquanti-altivec.c )
+set_source_files_properties(${SIMD_SOURCES} PROPERTIES
+  COMPILE_FLAGS -maltivec)
+
+#add_library(simd OBJECT ${SIMD_SOURCES} powerpc/jsimd.c)
+
+if(CMAKE_POSITION_INDEPENDENT_CODE OR ENABLE_SHARED)
+  set_target_properties(simd PROPERTIES POSITION_INDEPENDENT_CODE 1)
+endif()
+set(SIMD_SOURCES_ALL ${SIMD_SOURCES} PARENT_SCOPE) 
+
+###############################################################################
+# None
+###############################################################################
+
+else()
+
+simd_fail("SIMD extensions not available for this CPU (${CMAKE_SYSTEM_PROCESSOR})")
+
+endif() # CPU_TYPE
diff --git a/3rdparty/libjpeg/src/simd/arm/aarch32/jccolext-neon.c b/3rdparty/libjpeg/src/simd/arm/aarch32/jccolext-neon.c
new file mode 100644
index 00000000..362102d2
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/arm/aarch32/jccolext-neon.c
@@ -0,0 +1,148 @@
+/*
+ * jccolext-neon.c - colorspace conversion (32-bit Arm Neon)
+ *
+ * Copyright (C) 2020, Arm Limited.  All Rights Reserved.
+ * Copyright (C) 2020, D. R. Commander.  All Rights Reserved.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+/* This file is included by jccolor-neon.c */
+
+
+/* RGB -> YCbCr conversion is defined by the following equations:
+ *    Y  =  0.29900 * R + 0.58700 * G + 0.11400 * B
+ *    Cb = -0.16874 * R - 0.33126 * G + 0.50000 * B  + 128
+ *    Cr =  0.50000 * R - 0.41869 * G - 0.08131 * B  + 128
+ *
+ * Avoid floating point arithmetic by using shifted integer constants:
+ *    0.29899597 = 19595 * 2^-16
+ *    0.58700561 = 38470 * 2^-16
+ *    0.11399841 =  7471 * 2^-16
+ *    0.16874695 = 11059 * 2^-16
+ *    0.33125305 = 21709 * 2^-16
+ *    0.50000000 = 32768 * 2^-16
+ *    0.41868592 = 27439 * 2^-16
+ *    0.08131409 =  5329 * 2^-16
+ * These constants are defined in jccolor-neon.c
+ *
+ * We add the fixed-point equivalent of 0.5 to Cb and Cr, which effectively
+ * rounds up or down the result via integer truncation.
+ */
+
+void jsimd_rgb_ycc_convert_neon(JDIMENSION image_width, JSAMPARRAY input_buf,
+                                JSAMPIMAGE output_buf, JDIMENSION output_row,
+                                int num_rows)
+{
+  /* Pointer to RGB(X/A) input data */
+  JSAMPROW inptr;
+  /* Pointers to Y, Cb, and Cr output data */
+  JSAMPROW outptr0, outptr1, outptr2;
+  /* Allocate temporary buffer for final (image_width % 8) pixels in row. */
+  ALIGN(16) uint8_t tmp_buf[8 * RGB_PIXELSIZE];
+
+  /* Set up conversion constants. */
+#ifdef HAVE_VLD1_U16_X2
+  const uint16x4x2_t consts = vld1_u16_x2(jsimd_rgb_ycc_neon_consts);
+#else
+  /* GCC does not currently support the intrinsic vld1_<type>_x2(). */
+  const uint16x4_t consts1 = vld1_u16(jsimd_rgb_ycc_neon_consts);
+  const uint16x4_t consts2 = vld1_u16(jsimd_rgb_ycc_neon_consts + 4);
+  const uint16x4x2_t consts = { { consts1, consts2 } };
+#endif
+  const uint32x4_t scaled_128_5 = vdupq_n_u32((128 << 16) + 32767);
+
+  while (--num_rows >= 0) {
+    inptr = *input_buf++;
+    outptr0 = output_buf[0][output_row];
+    outptr1 = output_buf[1][output_row];
+    outptr2 = output_buf[2][output_row];
+    output_row++;
+
+    int cols_remaining = image_width;
+    for (; cols_remaining > 0; cols_remaining -= 8) {
+
+      /* To prevent buffer overread by the vector load instructions, the last
+       * (image_width % 8) columns of data are first memcopied to a temporary
+       * buffer large enough to accommodate the vector load.
+       */
+      if (cols_remaining < 8) {
+        memcpy(tmp_buf, inptr, cols_remaining * RGB_PIXELSIZE);
+        inptr = tmp_buf;
+      }
+
+#if RGB_PIXELSIZE == 4
+      uint8x8x4_t input_pixels = vld4_u8(inptr);
+#else
+      uint8x8x3_t input_pixels = vld3_u8(inptr);
+#endif
+      uint16x8_t r = vmovl_u8(input_pixels.val[RGB_RED]);
+      uint16x8_t g = vmovl_u8(input_pixels.val[RGB_GREEN]);
+      uint16x8_t b = vmovl_u8(input_pixels.val[RGB_BLUE]);
+
+      /* Compute Y = 0.29900 * R + 0.58700 * G + 0.11400 * B */
+      uint32x4_t y_low = vmull_lane_u16(vget_low_u16(r), consts.val[0], 0);
+      y_low = vmlal_lane_u16(y_low, vget_low_u16(g), consts.val[0], 1);
+      y_low = vmlal_lane_u16(y_low, vget_low_u16(b), consts.val[0], 2);
+      uint32x4_t y_high = vmull_lane_u16(vget_high_u16(r), consts.val[0], 0);
+      y_high = vmlal_lane_u16(y_high, vget_high_u16(g), consts.val[0], 1);
+      y_high = vmlal_lane_u16(y_high, vget_high_u16(b), consts.val[0], 2);
+
+      /* Compute Cb = -0.16874 * R - 0.33126 * G + 0.50000 * B  + 128 */
+      uint32x4_t cb_low = scaled_128_5;
+      cb_low = vmlsl_lane_u16(cb_low, vget_low_u16(r), consts.val[0], 3);
+      cb_low = vmlsl_lane_u16(cb_low, vget_low_u16(g), consts.val[1], 0);
+      cb_low = vmlal_lane_u16(cb_low, vget_low_u16(b), consts.val[1], 1);
+      uint32x4_t cb_high = scaled_128_5;
+      cb_high = vmlsl_lane_u16(cb_high, vget_high_u16(r), consts.val[0], 3);
+      cb_high = vmlsl_lane_u16(cb_high, vget_high_u16(g), consts.val[1], 0);
+      cb_high = vmlal_lane_u16(cb_high, vget_high_u16(b), consts.val[1], 1);
+
+      /* Compute Cr = 0.50000 * R - 0.41869 * G - 0.08131 * B  + 128 */
+      uint32x4_t cr_low = scaled_128_5;
+      cr_low = vmlal_lane_u16(cr_low, vget_low_u16(r), consts.val[1], 1);
+      cr_low = vmlsl_lane_u16(cr_low, vget_low_u16(g), consts.val[1], 2);
+      cr_low = vmlsl_lane_u16(cr_low, vget_low_u16(b), consts.val[1], 3);
+      uint32x4_t cr_high = scaled_128_5;
+      cr_high = vmlal_lane_u16(cr_high, vget_high_u16(r), consts.val[1], 1);
+      cr_high = vmlsl_lane_u16(cr_high, vget_high_u16(g), consts.val[1], 2);
+      cr_high = vmlsl_lane_u16(cr_high, vget_high_u16(b), consts.val[1], 3);
+
+      /* Descale Y values (rounding right shift) and narrow to 16-bit. */
+      uint16x8_t y_u16 = vcombine_u16(vrshrn_n_u32(y_low, 16),
+                                      vrshrn_n_u32(y_high, 16));
+      /* Descale Cb values (right shift) and narrow to 16-bit. */
+      uint16x8_t cb_u16 = vcombine_u16(vshrn_n_u32(cb_low, 16),
+                                       vshrn_n_u32(cb_high, 16));
+      /* Descale Cr values (right shift) and narrow to 16-bit. */
+      uint16x8_t cr_u16 = vcombine_u16(vshrn_n_u32(cr_low, 16),
+                                       vshrn_n_u32(cr_high, 16));
+      /* Narrow Y, Cb, and Cr values to 8-bit and store to memory.  Buffer
+       * overwrite is permitted up to the next multiple of ALIGN_SIZE bytes.
+       */
+      vst1_u8(outptr0, vmovn_u16(y_u16));
+      vst1_u8(outptr1, vmovn_u16(cb_u16));
+      vst1_u8(outptr2, vmovn_u16(cr_u16));
+
+      /* Increment pointers. */
+      inptr += (8 * RGB_PIXELSIZE);
+      outptr0 += 8;
+      outptr1 += 8;
+      outptr2 += 8;
+    }
+  }
+}
diff --git a/3rdparty/libjpeg/src/simd/arm/aarch32/jchuff-neon.c b/3rdparty/libjpeg/src/simd/arm/aarch32/jchuff-neon.c
new file mode 100644
index 00000000..19d94f72
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/arm/aarch32/jchuff-neon.c
@@ -0,0 +1,334 @@
+/*
+ * jchuff-neon.c - Huffman entropy encoding (32-bit Arm Neon)
+ *
+ * Copyright (C) 2020, Arm Limited.  All Rights Reserved.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ *
+ * NOTE: All referenced figures are from
+ * Recommendation ITU-T T.81 (1992) | ISO/IEC 10918-1:1994.
+ */
+
+#define JPEG_INTERNALS
+#include "../../../jinclude.h"
+#include "../../../jpeglib.h"
+#include "../../../jsimd.h"
+#include "../../../jdct.h"
+#include "../../../jsimddct.h"
+#include "../../jsimd.h"
+#include "../jchuff.h"
+#include "neon-compat.h"
+
+#include <limits.h>
+
+#include <arm_neon.h>
+
+
+JOCTET *jsimd_huff_encode_one_block_neon(void *state, JOCTET *buffer,
+                                         JCOEFPTR block, int last_dc_val,
+                                         c_derived_tbl *dctbl,
+                                         c_derived_tbl *actbl)
+{
+  uint8_t block_nbits[DCTSIZE2];
+  uint16_t block_diff[DCTSIZE2];
+
+  /* Load rows of coefficients from DCT block in zig-zag order. */
+
+  /* Compute DC coefficient difference value. (F.1.1.5.1) */
+  int16x8_t row0 = vdupq_n_s16(block[0] - last_dc_val);
+  row0 = vld1q_lane_s16(block +  1, row0, 1);
+  row0 = vld1q_lane_s16(block +  8, row0, 2);
+  row0 = vld1q_lane_s16(block + 16, row0, 3);
+  row0 = vld1q_lane_s16(block +  9, row0, 4);
+  row0 = vld1q_lane_s16(block +  2, row0, 5);
+  row0 = vld1q_lane_s16(block +  3, row0, 6);
+  row0 = vld1q_lane_s16(block + 10, row0, 7);
+
+  int16x8_t row1 = vld1q_dup_s16(block + 17);
+  row1 = vld1q_lane_s16(block + 24, row1, 1);
+  row1 = vld1q_lane_s16(block + 32, row1, 2);
+  row1 = vld1q_lane_s16(block + 25, row1, 3);
+  row1 = vld1q_lane_s16(block + 18, row1, 4);
+  row1 = vld1q_lane_s16(block + 11, row1, 5);
+  row1 = vld1q_lane_s16(block +  4, row1, 6);
+  row1 = vld1q_lane_s16(block +  5, row1, 7);
+
+  int16x8_t row2 = vld1q_dup_s16(block + 12);
+  row2 = vld1q_lane_s16(block + 19, row2, 1);
+  row2 = vld1q_lane_s16(block + 26, row2, 2);
+  row2 = vld1q_lane_s16(block + 33, row2, 3);
+  row2 = vld1q_lane_s16(block + 40, row2, 4);
+  row2 = vld1q_lane_s16(block + 48, row2, 5);
+  row2 = vld1q_lane_s16(block + 41, row2, 6);
+  row2 = vld1q_lane_s16(block + 34, row2, 7);
+
+  int16x8_t row3 = vld1q_dup_s16(block + 27);
+  row3 = vld1q_lane_s16(block + 20, row3, 1);
+  row3 = vld1q_lane_s16(block + 13, row3, 2);
+  row3 = vld1q_lane_s16(block +  6, row3, 3);
+  row3 = vld1q_lane_s16(block +  7, row3, 4);
+  row3 = vld1q_lane_s16(block + 14, row3, 5);
+  row3 = vld1q_lane_s16(block + 21, row3, 6);
+  row3 = vld1q_lane_s16(block + 28, row3, 7);
+
+  int16x8_t abs_row0 = vabsq_s16(row0);
+  int16x8_t abs_row1 = vabsq_s16(row1);
+  int16x8_t abs_row2 = vabsq_s16(row2);
+  int16x8_t abs_row3 = vabsq_s16(row3);
+
+  int16x8_t row0_lz = vclzq_s16(abs_row0);
+  int16x8_t row1_lz = vclzq_s16(abs_row1);
+  int16x8_t row2_lz = vclzq_s16(abs_row2);
+  int16x8_t row3_lz = vclzq_s16(abs_row3);
+
+  /* Compute number of bits required to represent each coefficient. */
+  uint8x8_t row0_nbits = vsub_u8(vdup_n_u8(16),
+                                 vmovn_u16(vreinterpretq_u16_s16(row0_lz)));
+  uint8x8_t row1_nbits = vsub_u8(vdup_n_u8(16),
+                                 vmovn_u16(vreinterpretq_u16_s16(row1_lz)));
+  uint8x8_t row2_nbits = vsub_u8(vdup_n_u8(16),
+                                 vmovn_u16(vreinterpretq_u16_s16(row2_lz)));
+  uint8x8_t row3_nbits = vsub_u8(vdup_n_u8(16),
+                                 vmovn_u16(vreinterpretq_u16_s16(row3_lz)));
+
+  vst1_u8(block_nbits + 0 * DCTSIZE, row0_nbits);
+  vst1_u8(block_nbits + 1 * DCTSIZE, row1_nbits);
+  vst1_u8(block_nbits + 2 * DCTSIZE, row2_nbits);
+  vst1_u8(block_nbits + 3 * DCTSIZE, row3_nbits);
+
+  uint16x8_t row0_mask =
+    vshlq_u16(vreinterpretq_u16_s16(vshrq_n_s16(row0, 15)),
+              vnegq_s16(row0_lz));
+  uint16x8_t row1_mask =
+    vshlq_u16(vreinterpretq_u16_s16(vshrq_n_s16(row1, 15)),
+              vnegq_s16(row1_lz));
+  uint16x8_t row2_mask =
+    vshlq_u16(vreinterpretq_u16_s16(vshrq_n_s16(row2, 15)),
+              vnegq_s16(row2_lz));
+  uint16x8_t row3_mask =
+    vshlq_u16(vreinterpretq_u16_s16(vshrq_n_s16(row3, 15)),
+              vnegq_s16(row3_lz));
+
+  uint16x8_t row0_diff = veorq_u16(vreinterpretq_u16_s16(abs_row0), row0_mask);
+  uint16x8_t row1_diff = veorq_u16(vreinterpretq_u16_s16(abs_row1), row1_mask);
+  uint16x8_t row2_diff = veorq_u16(vreinterpretq_u16_s16(abs_row2), row2_mask);
+  uint16x8_t row3_diff = veorq_u16(vreinterpretq_u16_s16(abs_row3), row3_mask);
+
+  /* Store diff values for rows 0, 1, 2, and 3. */
+  vst1q_u16(block_diff + 0 * DCTSIZE, row0_diff);
+  vst1q_u16(block_diff + 1 * DCTSIZE, row1_diff);
+  vst1q_u16(block_diff + 2 * DCTSIZE, row2_diff);
+  vst1q_u16(block_diff + 3 * DCTSIZE, row3_diff);
+
+  /* Load last four rows of coefficients from DCT block in zig-zag order. */
+  int16x8_t row4 = vld1q_dup_s16(block + 35);
+  row4 = vld1q_lane_s16(block + 42, row4, 1);
+  row4 = vld1q_lane_s16(block + 49, row4, 2);
+  row4 = vld1q_lane_s16(block + 56, row4, 3);
+  row4 = vld1q_lane_s16(block + 57, row4, 4);
+  row4 = vld1q_lane_s16(block + 50, row4, 5);
+  row4 = vld1q_lane_s16(block + 43, row4, 6);
+  row4 = vld1q_lane_s16(block + 36, row4, 7);
+
+  int16x8_t row5 = vld1q_dup_s16(block + 29);
+  row5 = vld1q_lane_s16(block + 22, row5, 1);
+  row5 = vld1q_lane_s16(block + 15, row5, 2);
+  row5 = vld1q_lane_s16(block + 23, row5, 3);
+  row5 = vld1q_lane_s16(block + 30, row5, 4);
+  row5 = vld1q_lane_s16(block + 37, row5, 5);
+  row5 = vld1q_lane_s16(block + 44, row5, 6);
+  row5 = vld1q_lane_s16(block + 51, row5, 7);
+
+  int16x8_t row6 = vld1q_dup_s16(block + 58);
+  row6 = vld1q_lane_s16(block + 59, row6, 1);
+  row6 = vld1q_lane_s16(block + 52, row6, 2);
+  row6 = vld1q_lane_s16(block + 45, row6, 3);
+  row6 = vld1q_lane_s16(block + 38, row6, 4);
+  row6 = vld1q_lane_s16(block + 31, row6, 5);
+  row6 = vld1q_lane_s16(block + 39, row6, 6);
+  row6 = vld1q_lane_s16(block + 46, row6, 7);
+
+  int16x8_t row7 = vld1q_dup_s16(block + 53);
+  row7 = vld1q_lane_s16(block + 60, row7, 1);
+  row7 = vld1q_lane_s16(block + 61, row7, 2);
+  row7 = vld1q_lane_s16(block + 54, row7, 3);
+  row7 = vld1q_lane_s16(block + 47, row7, 4);
+  row7 = vld1q_lane_s16(block + 55, row7, 5);
+  row7 = vld1q_lane_s16(block + 62, row7, 6);
+  row7 = vld1q_lane_s16(block + 63, row7, 7);
+
+  int16x8_t abs_row4 = vabsq_s16(row4);
+  int16x8_t abs_row5 = vabsq_s16(row5);
+  int16x8_t abs_row6 = vabsq_s16(row6);
+  int16x8_t abs_row7 = vabsq_s16(row7);
+
+  int16x8_t row4_lz = vclzq_s16(abs_row4);
+  int16x8_t row5_lz = vclzq_s16(abs_row5);
+  int16x8_t row6_lz = vclzq_s16(abs_row6);
+  int16x8_t row7_lz = vclzq_s16(abs_row7);
+
+  /* Compute number of bits required to represent each coefficient. */
+  uint8x8_t row4_nbits = vsub_u8(vdup_n_u8(16),
+                                 vmovn_u16(vreinterpretq_u16_s16(row4_lz)));
+  uint8x8_t row5_nbits = vsub_u8(vdup_n_u8(16),
+                                 vmovn_u16(vreinterpretq_u16_s16(row5_lz)));
+  uint8x8_t row6_nbits = vsub_u8(vdup_n_u8(16),
+                                 vmovn_u16(vreinterpretq_u16_s16(row6_lz)));
+  uint8x8_t row7_nbits = vsub_u8(vdup_n_u8(16),
+                                 vmovn_u16(vreinterpretq_u16_s16(row7_lz)));
+
+  vst1_u8(block_nbits + 4 * DCTSIZE, row4_nbits);
+  vst1_u8(block_nbits + 5 * DCTSIZE, row5_nbits);
+  vst1_u8(block_nbits + 6 * DCTSIZE, row6_nbits);
+  vst1_u8(block_nbits + 7 * DCTSIZE, row7_nbits);
+
+  uint16x8_t row4_mask =
+    vshlq_u16(vreinterpretq_u16_s16(vshrq_n_s16(row4, 15)),
+              vnegq_s16(row4_lz));
+  uint16x8_t row5_mask =
+    vshlq_u16(vreinterpretq_u16_s16(vshrq_n_s16(row5, 15)),
+              vnegq_s16(row5_lz));
+  uint16x8_t row6_mask =
+    vshlq_u16(vreinterpretq_u16_s16(vshrq_n_s16(row6, 15)),
+              vnegq_s16(row6_lz));
+  uint16x8_t row7_mask =
+    vshlq_u16(vreinterpretq_u16_s16(vshrq_n_s16(row7, 15)),
+              vnegq_s16(row7_lz));
+
+  uint16x8_t row4_diff = veorq_u16(vreinterpretq_u16_s16(abs_row4), row4_mask);
+  uint16x8_t row5_diff = veorq_u16(vreinterpretq_u16_s16(abs_row5), row5_mask);
+  uint16x8_t row6_diff = veorq_u16(vreinterpretq_u16_s16(abs_row6), row6_mask);
+  uint16x8_t row7_diff = veorq_u16(vreinterpretq_u16_s16(abs_row7), row7_mask);
+
+  /* Store diff values for rows 4, 5, 6, and 7. */
+  vst1q_u16(block_diff + 4 * DCTSIZE, row4_diff);
+  vst1q_u16(block_diff + 5 * DCTSIZE, row5_diff);
+  vst1q_u16(block_diff + 6 * DCTSIZE, row6_diff);
+  vst1q_u16(block_diff + 7 * DCTSIZE, row7_diff);
+
+  /* Construct bitmap to accelerate encoding of AC coefficients.  A set bit
+   * means that the corresponding coefficient != 0.
+   */
+  uint8x8_t row0_nbits_gt0 = vcgt_u8(row0_nbits, vdup_n_u8(0));
+  uint8x8_t row1_nbits_gt0 = vcgt_u8(row1_nbits, vdup_n_u8(0));
+  uint8x8_t row2_nbits_gt0 = vcgt_u8(row2_nbits, vdup_n_u8(0));
+  uint8x8_t row3_nbits_gt0 = vcgt_u8(row3_nbits, vdup_n_u8(0));
+  uint8x8_t row4_nbits_gt0 = vcgt_u8(row4_nbits, vdup_n_u8(0));
+  uint8x8_t row5_nbits_gt0 = vcgt_u8(row5_nbits, vdup_n_u8(0));
+  uint8x8_t row6_nbits_gt0 = vcgt_u8(row6_nbits, vdup_n_u8(0));
+  uint8x8_t row7_nbits_gt0 = vcgt_u8(row7_nbits, vdup_n_u8(0));
+
+  /* { 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01 } */
+  const uint8x8_t bitmap_mask =
+    vreinterpret_u8_u64(vmov_n_u64(0x0102040810204080));
+
+  row0_nbits_gt0 = vand_u8(row0_nbits_gt0, bitmap_mask);
+  row1_nbits_gt0 = vand_u8(row1_nbits_gt0, bitmap_mask);
+  row2_nbits_gt0 = vand_u8(row2_nbits_gt0, bitmap_mask);
+  row3_nbits_gt0 = vand_u8(row3_nbits_gt0, bitmap_mask);
+  row4_nbits_gt0 = vand_u8(row4_nbits_gt0, bitmap_mask);
+  row5_nbits_gt0 = vand_u8(row5_nbits_gt0, bitmap_mask);
+  row6_nbits_gt0 = vand_u8(row6_nbits_gt0, bitmap_mask);
+  row7_nbits_gt0 = vand_u8(row7_nbits_gt0, bitmap_mask);
+
+  uint8x8_t bitmap_rows_10 = vpadd_u8(row1_nbits_gt0, row0_nbits_gt0);
+  uint8x8_t bitmap_rows_32 = vpadd_u8(row3_nbits_gt0, row2_nbits_gt0);
+  uint8x8_t bitmap_rows_54 = vpadd_u8(row5_nbits_gt0, row4_nbits_gt0);
+  uint8x8_t bitmap_rows_76 = vpadd_u8(row7_nbits_gt0, row6_nbits_gt0);
+  uint8x8_t bitmap_rows_3210 = vpadd_u8(bitmap_rows_32, bitmap_rows_10);
+  uint8x8_t bitmap_rows_7654 = vpadd_u8(bitmap_rows_76, bitmap_rows_54);
+  uint8x8_t bitmap = vpadd_u8(bitmap_rows_7654, bitmap_rows_3210);
+
+  /* Shift left to remove DC bit. */
+  bitmap = vreinterpret_u8_u64(vshl_n_u64(vreinterpret_u64_u8(bitmap), 1));
+  /* Move bitmap to 32-bit scalar registers. */
+  uint32_t bitmap_1_32 = vget_lane_u32(vreinterpret_u32_u8(bitmap), 1);
+  uint32_t bitmap_33_63 = vget_lane_u32(vreinterpret_u32_u8(bitmap), 0);
+
+  /* Set up state and bit buffer for output bitstream. */
+  working_state *state_ptr = (working_state *)state;
+  int free_bits = state_ptr->cur.free_bits;
+  size_t put_buffer = state_ptr->cur.put_buffer;
+
+  /* Encode DC coefficient. */
+
+  unsigned int nbits = block_nbits[0];
+  /* Emit Huffman-coded symbol and additional diff bits. */
+  unsigned int diff = block_diff[0];
+  PUT_CODE(dctbl->ehufco[nbits], dctbl->ehufsi[nbits], diff)
+
+  /* Encode AC coefficients. */
+
+  unsigned int r = 0;  /* r = run length of zeros */
+  unsigned int i = 1;  /* i = number of coefficients encoded */
+  /* Code and size information for a run length of 16 zero coefficients */
+  const unsigned int code_0xf0 = actbl->ehufco[0xf0];
+  const unsigned int size_0xf0 = actbl->ehufsi[0xf0];
+
+  while (bitmap_1_32 != 0) {
+    r = BUILTIN_CLZ(bitmap_1_32);
+    i += r;
+    bitmap_1_32 <<= r;
+    nbits = block_nbits[i];
+    diff = block_diff[i];
+    while (r > 15) {
+      /* If run length > 15, emit special run-length-16 codes. */
+      PUT_BITS(code_0xf0, size_0xf0)
+      r -= 16;
+    }
+    /* Emit Huffman symbol for run length / number of bits. (F.1.2.2.1) */
+    unsigned int rs = (r << 4) + nbits;
+    PUT_CODE(actbl->ehufco[rs], actbl->ehufsi[rs], diff)
+    i++;
+    bitmap_1_32 <<= 1;
+  }
+
+  r = 33 - i;
+  i = 33;
+
+  while (bitmap_33_63 != 0) {
+    unsigned int leading_zeros = BUILTIN_CLZ(bitmap_33_63);
+    r += leading_zeros;
+    i += leading_zeros;
+    bitmap_33_63 <<= leading_zeros;
+    nbits = block_nbits[i];
+    diff = block_diff[i];
+    while (r > 15) {
+      /* If run length > 15, emit special run-length-16 codes. */
+      PUT_BITS(code_0xf0, size_0xf0)
+      r -= 16;
+    }
+    /* Emit Huffman symbol for run length / number of bits. (F.1.2.2.1) */
+    unsigned int rs = (r << 4) + nbits;
+    PUT_CODE(actbl->ehufco[rs], actbl->ehufsi[rs], diff)
+    r = 0;
+    i++;
+    bitmap_33_63 <<= 1;
+  }
+
+  /* If the last coefficient(s) were zero, emit an end-of-block (EOB) code.
+   * The value of RS for the EOB code is 0.
+   */
+  if (i != 64) {
+    PUT_BITS(actbl->ehufco[0], actbl->ehufsi[0])
+  }
+
+  state_ptr->cur.put_buffer = put_buffer;
+  state_ptr->cur.free_bits = free_bits;
+
+  return buffer;
+}
diff --git a/3rdparty/libjpeg/src/simd/arm/aarch32/jsimd.c b/3rdparty/libjpeg/src/simd/arm/aarch32/jsimd.c
new file mode 100644
index 00000000..fac55dfb
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/arm/aarch32/jsimd.c
@@ -0,0 +1,983 @@
+/*
+ * jsimd_arm.c
+ *
+ * Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+ * Copyright (C) 2011, Nokia Corporation and/or its subsidiary(-ies).
+ * Copyright (C) 2009-2011, 2013-2014, 2016, 2018, D. R. Commander.
+ * Copyright (C) 2015-2016, 2018, Matthieu Darbois.
+ * Copyright (C) 2019, Google LLC.
+ * Copyright (C) 2020, Arm Limited.
+ *
+ * Based on the x86 SIMD extension for IJG JPEG library,
+ * Copyright (C) 1999-2006, MIYASAKA Masaru.
+ * For conditions of distribution and use, see copyright notice in jsimdext.inc
+ *
+ * This file contains the interface between the "normal" portions
+ * of the library and the SIMD implementations when running on a
+ * 32-bit Arm architecture.
+ */
+
+#define JPEG_INTERNALS
+#include "../../../jinclude.h"
+#include "../../../jpeglib.h"
+#include "../../../jsimd.h"
+#include "../../../jdct.h"
+#include "../../../jsimddct.h"
+#include "../../jsimd.h"
+
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+
+static unsigned int simd_support = ~0;
+static unsigned int simd_huffman = 1;
+
+#if !defined(__ARM_NEON__) && (defined(__linux__) || defined(ANDROID) || defined(__ANDROID__))
+
+#define SOMEWHAT_SANE_PROC_CPUINFO_SIZE_LIMIT  (1024 * 1024)
+
+LOCAL(int)
+check_feature(char *buffer, char *feature)
+{
+  char *p;
+
+  if (*feature == 0)
+    return 0;
+  if (strncmp(buffer, "Features", 8) != 0)
+    return 0;
+  buffer += 8;
+  while (isspace(*buffer))
+    buffer++;
+
+  /* Check if 'feature' is present in the buffer as a separate word */
+  while ((p = strstr(buffer, feature))) {
+    if (p > buffer && !isspace(*(p - 1))) {
+      buffer++;
+      continue;
+    }
+    p += strlen(feature);
+    if (*p != 0 && !isspace(*p)) {
+      buffer++;
+      continue;
+    }
+    return 1;
+  }
+  return 0;
+}
+
+LOCAL(int)
+parse_proc_cpuinfo(int bufsize)
+{
+  char *buffer = (char *)malloc(bufsize);
+  FILE *fd;
+
+  simd_support = 0;
+
+  if (!buffer)
+    return 0;
+
+  fd = fopen("/proc/cpuinfo", "r");
+  if (fd) {
+    while (fgets(buffer, bufsize, fd)) {
+      if (!strchr(buffer, '\n') && !feof(fd)) {
+        /* "impossible" happened - insufficient size of the buffer! */
+        fclose(fd);
+        free(buffer);
+        return 0;
+      }
+      if (check_feature(buffer, "neon"))
+        simd_support |= JSIMD_NEON;
+    }
+    fclose(fd);
+  }
+  free(buffer);
+  return 1;
+}
+
+#endif
+
+/*
+ * Check what SIMD accelerations are supported.
+ *
+ * FIXME: This code is racy under a multi-threaded environment.
+ */
+LOCAL(void)
+init_simd(void)
+{
+#ifndef NO_GETENV
+  char *env = NULL;
+#endif
+#if !defined(__ARM_NEON__) && (defined(__linux__) || defined(ANDROID) || defined(__ANDROID__))
+  int bufsize = 1024; /* an initial guess for the line buffer size limit */
+#endif
+
+  if (simd_support != ~0U)
+    return;
+
+  simd_support = 0;
+
+#if defined(__ARM_NEON__)
+  simd_support |= JSIMD_NEON;
+#elif defined(__linux__) || defined(ANDROID) || defined(__ANDROID__)
+  /* We still have a chance to use Neon regardless of globally used
+   * -mcpu/-mfpu options passed to gcc by performing runtime detection via
+   * /proc/cpuinfo parsing on linux/android */
+  while (!parse_proc_cpuinfo(bufsize)) {
+    bufsize *= 2;
+    if (bufsize > SOMEWHAT_SANE_PROC_CPUINFO_SIZE_LIMIT)
+      break;
+  }
+#endif
+
+#ifndef NO_GETENV
+  /* Force different settings through environment variables */
+  env = getenv("JSIMD_FORCENEON");
+  if ((env != NULL) && (strcmp(env, "1") == 0))
+    simd_support = JSIMD_NEON;
+  env = getenv("JSIMD_FORCENONE");
+  if ((env != NULL) && (strcmp(env, "1") == 0))
+    simd_support = 0;
+  env = getenv("JSIMD_NOHUFFENC");
+  if ((env != NULL) && (strcmp(env, "1") == 0))
+    simd_huffman = 0;
+#endif
+}
+
+GLOBAL(int)
+jsimd_can_rgb_ycc(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+  if ((RGB_PIXELSIZE != 3) && (RGB_PIXELSIZE != 4))
+    return 0;
+
+  if (simd_support & JSIMD_NEON)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_rgb_gray(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+  if ((RGB_PIXELSIZE != 3) && (RGB_PIXELSIZE != 4))
+    return 0;
+
+  if (simd_support & JSIMD_NEON)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_ycc_rgb(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+  if ((RGB_PIXELSIZE != 3) && (RGB_PIXELSIZE != 4))
+    return 0;
+
+  if (simd_support & JSIMD_NEON)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_ycc_rgb565(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+
+  if (simd_support & JSIMD_NEON)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(void)
+jsimd_rgb_ycc_convert(j_compress_ptr cinfo, JSAMPARRAY input_buf,
+                      JSAMPIMAGE output_buf, JDIMENSION output_row,
+                      int num_rows)
+{
+  void (*neonfct) (JDIMENSION, JSAMPARRAY, JSAMPIMAGE, JDIMENSION, int);
+
+  switch (cinfo->in_color_space) {
+  case JCS_EXT_RGB:
+    neonfct = jsimd_extrgb_ycc_convert_neon;
+    break;
+  case JCS_EXT_RGBX:
+  case JCS_EXT_RGBA:
+    neonfct = jsimd_extrgbx_ycc_convert_neon;
+    break;
+  case JCS_EXT_BGR:
+    neonfct = jsimd_extbgr_ycc_convert_neon;
+    break;
+  case JCS_EXT_BGRX:
+  case JCS_EXT_BGRA:
+    neonfct = jsimd_extbgrx_ycc_convert_neon;
+    break;
+  case JCS_EXT_XBGR:
+  case JCS_EXT_ABGR:
+    neonfct = jsimd_extxbgr_ycc_convert_neon;
+    break;
+  case JCS_EXT_XRGB:
+  case JCS_EXT_ARGB:
+    neonfct = jsimd_extxrgb_ycc_convert_neon;
+    break;
+  default:
+    neonfct = jsimd_extrgb_ycc_convert_neon;
+    break;
+  }
+
+  neonfct(cinfo->image_width, input_buf, output_buf, output_row, num_rows);
+}
+
+GLOBAL(void)
+jsimd_rgb_gray_convert(j_compress_ptr cinfo, JSAMPARRAY input_buf,
+                       JSAMPIMAGE output_buf, JDIMENSION output_row,
+                       int num_rows)
+{
+  void (*neonfct) (JDIMENSION, JSAMPARRAY, JSAMPIMAGE, JDIMENSION, int);
+
+  switch (cinfo->in_color_space) {
+  case JCS_EXT_RGB:
+    neonfct = jsimd_extrgb_gray_convert_neon;
+    break;
+  case JCS_EXT_RGBX:
+  case JCS_EXT_RGBA:
+    neonfct = jsimd_extrgbx_gray_convert_neon;
+    break;
+  case JCS_EXT_BGR:
+    neonfct = jsimd_extbgr_gray_convert_neon;
+    break;
+  case JCS_EXT_BGRX:
+  case JCS_EXT_BGRA:
+    neonfct = jsimd_extbgrx_gray_convert_neon;
+    break;
+  case JCS_EXT_XBGR:
+  case JCS_EXT_ABGR:
+    neonfct = jsimd_extxbgr_gray_convert_neon;
+    break;
+  case JCS_EXT_XRGB:
+  case JCS_EXT_ARGB:
+    neonfct = jsimd_extxrgb_gray_convert_neon;
+    break;
+  default:
+    neonfct = jsimd_extrgb_gray_convert_neon;
+    break;
+  }
+
+  neonfct(cinfo->image_width, input_buf, output_buf, output_row, num_rows);
+}
+
+GLOBAL(void)
+jsimd_ycc_rgb_convert(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
+                      JDIMENSION input_row, JSAMPARRAY output_buf,
+                      int num_rows)
+{
+  void (*neonfct) (JDIMENSION, JSAMPIMAGE, JDIMENSION, JSAMPARRAY, int);
+
+  switch (cinfo->out_color_space) {
+  case JCS_EXT_RGB:
+    neonfct = jsimd_ycc_extrgb_convert_neon;
+    break;
+  case JCS_EXT_RGBX:
+  case JCS_EXT_RGBA:
+    neonfct = jsimd_ycc_extrgbx_convert_neon;
+    break;
+  case JCS_EXT_BGR:
+    neonfct = jsimd_ycc_extbgr_convert_neon;
+    break;
+  case JCS_EXT_BGRX:
+  case JCS_EXT_BGRA:
+    neonfct = jsimd_ycc_extbgrx_convert_neon;
+    break;
+  case JCS_EXT_XBGR:
+  case JCS_EXT_ABGR:
+    neonfct = jsimd_ycc_extxbgr_convert_neon;
+    break;
+  case JCS_EXT_XRGB:
+  case JCS_EXT_ARGB:
+    neonfct = jsimd_ycc_extxrgb_convert_neon;
+    break;
+  default:
+    neonfct = jsimd_ycc_extrgb_convert_neon;
+    break;
+  }
+
+  neonfct(cinfo->output_width, input_buf, input_row, output_buf, num_rows);
+}
+
+GLOBAL(void)
+jsimd_ycc_rgb565_convert(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
+                         JDIMENSION input_row, JSAMPARRAY output_buf,
+                         int num_rows)
+{
+  jsimd_ycc_rgb565_convert_neon(cinfo->output_width, input_buf, input_row,
+                                output_buf, num_rows);
+}
+
+GLOBAL(int)
+jsimd_can_h2v2_downsample(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (DCTSIZE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+
+  if (simd_support & JSIMD_NEON)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_h2v1_downsample(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (DCTSIZE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+
+  if (simd_support & JSIMD_NEON)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(void)
+jsimd_h2v2_downsample(j_compress_ptr cinfo, jpeg_component_info *compptr,
+                      JSAMPARRAY input_data, JSAMPARRAY output_data)
+{
+  jsimd_h2v2_downsample_neon(cinfo->image_width, cinfo->max_v_samp_factor,
+                             compptr->v_samp_factor, compptr->width_in_blocks,
+                             input_data, output_data);
+}
+
+GLOBAL(void)
+jsimd_h2v1_downsample(j_compress_ptr cinfo, jpeg_component_info *compptr,
+                      JSAMPARRAY input_data, JSAMPARRAY output_data)
+{
+  jsimd_h2v1_downsample_neon(cinfo->image_width, cinfo->max_v_samp_factor,
+                             compptr->v_samp_factor, compptr->width_in_blocks,
+                             input_data, output_data);
+}
+
+GLOBAL(int)
+jsimd_can_h2v2_upsample(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+
+  if (simd_support & JSIMD_NEON)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_h2v1_upsample(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+  if (simd_support & JSIMD_NEON)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(void)
+jsimd_h2v2_upsample(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+                    JSAMPARRAY input_data, JSAMPARRAY *output_data_ptr)
+{
+  jsimd_h2v2_upsample_neon(cinfo->max_v_samp_factor, cinfo->output_width,
+                           input_data, output_data_ptr);
+}
+
+GLOBAL(void)
+jsimd_h2v1_upsample(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+                    JSAMPARRAY input_data, JSAMPARRAY *output_data_ptr)
+{
+  jsimd_h2v1_upsample_neon(cinfo->max_v_samp_factor, cinfo->output_width,
+                           input_data, output_data_ptr);
+}
+
+GLOBAL(int)
+jsimd_can_h2v2_fancy_upsample(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+
+  if (simd_support & JSIMD_NEON)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_h2v1_fancy_upsample(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+
+  if (simd_support & JSIMD_NEON)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_h1v2_fancy_upsample(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+
+  if (simd_support & JSIMD_NEON)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(void)
+jsimd_h2v2_fancy_upsample(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+                          JSAMPARRAY input_data, JSAMPARRAY *output_data_ptr)
+{
+  jsimd_h2v2_fancy_upsample_neon(cinfo->max_v_samp_factor,
+                                 compptr->downsampled_width, input_data,
+                                 output_data_ptr);
+}
+
+GLOBAL(void)
+jsimd_h2v1_fancy_upsample(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+                          JSAMPARRAY input_data, JSAMPARRAY *output_data_ptr)
+{
+  jsimd_h2v1_fancy_upsample_neon(cinfo->max_v_samp_factor,
+                                 compptr->downsampled_width, input_data,
+                                 output_data_ptr);
+}
+
+GLOBAL(void)
+jsimd_h1v2_fancy_upsample(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+                          JSAMPARRAY input_data, JSAMPARRAY *output_data_ptr)
+{
+  jsimd_h1v2_fancy_upsample_neon(cinfo->max_v_samp_factor,
+                                 compptr->downsampled_width, input_data,
+                                 output_data_ptr);
+}
+
+GLOBAL(int)
+jsimd_can_h2v2_merged_upsample(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+
+  if (simd_support & JSIMD_NEON)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_h2v1_merged_upsample(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+
+  if (simd_support & JSIMD_NEON)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(void)
+jsimd_h2v2_merged_upsample(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
+                           JDIMENSION in_row_group_ctr, JSAMPARRAY output_buf)
+{
+  void (*neonfct) (JDIMENSION, JSAMPIMAGE, JDIMENSION, JSAMPARRAY);
+
+  switch (cinfo->out_color_space) {
+    case JCS_EXT_RGB:
+      neonfct = jsimd_h2v2_extrgb_merged_upsample_neon;
+      break;
+    case JCS_EXT_RGBX:
+    case JCS_EXT_RGBA:
+      neonfct = jsimd_h2v2_extrgbx_merged_upsample_neon;
+      break;
+    case JCS_EXT_BGR:
+      neonfct = jsimd_h2v2_extbgr_merged_upsample_neon;
+      break;
+    case JCS_EXT_BGRX:
+    case JCS_EXT_BGRA:
+      neonfct = jsimd_h2v2_extbgrx_merged_upsample_neon;
+      break;
+    case JCS_EXT_XBGR:
+    case JCS_EXT_ABGR:
+      neonfct = jsimd_h2v2_extxbgr_merged_upsample_neon;
+      break;
+    case JCS_EXT_XRGB:
+    case JCS_EXT_ARGB:
+      neonfct = jsimd_h2v2_extxrgb_merged_upsample_neon;
+      break;
+    default:
+      neonfct = jsimd_h2v2_extrgb_merged_upsample_neon;
+      break;
+  }
+
+  neonfct(cinfo->output_width, input_buf, in_row_group_ctr, output_buf);
+}
+
+GLOBAL(void)
+jsimd_h2v1_merged_upsample(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
+                           JDIMENSION in_row_group_ctr, JSAMPARRAY output_buf)
+{
+  void (*neonfct) (JDIMENSION, JSAMPIMAGE, JDIMENSION, JSAMPARRAY);
+
+  switch (cinfo->out_color_space) {
+    case JCS_EXT_RGB:
+      neonfct = jsimd_h2v1_extrgb_merged_upsample_neon;
+      break;
+    case JCS_EXT_RGBX:
+    case JCS_EXT_RGBA:
+      neonfct = jsimd_h2v1_extrgbx_merged_upsample_neon;
+      break;
+    case JCS_EXT_BGR:
+      neonfct = jsimd_h2v1_extbgr_merged_upsample_neon;
+      break;
+    case JCS_EXT_BGRX:
+    case JCS_EXT_BGRA:
+      neonfct = jsimd_h2v1_extbgrx_merged_upsample_neon;
+      break;
+    case JCS_EXT_XBGR:
+    case JCS_EXT_ABGR:
+      neonfct = jsimd_h2v1_extxbgr_merged_upsample_neon;
+      break;
+    case JCS_EXT_XRGB:
+    case JCS_EXT_ARGB:
+      neonfct = jsimd_h2v1_extxrgb_merged_upsample_neon;
+      break;
+    default:
+      neonfct = jsimd_h2v1_extrgb_merged_upsample_neon;
+      break;
+  }
+
+  neonfct(cinfo->output_width, input_buf, in_row_group_ctr, output_buf);
+}
+
+GLOBAL(int)
+jsimd_can_convsamp(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (DCTSIZE != 8)
+    return 0;
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+  if (sizeof(DCTELEM) != 2)
+    return 0;
+
+  if (simd_support & JSIMD_NEON)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_convsamp_float(void)
+{
+  return 0;
+}
+
+GLOBAL(void)
+jsimd_convsamp(JSAMPARRAY sample_data, JDIMENSION start_col,
+               DCTELEM *workspace)
+{
+  jsimd_convsamp_neon(sample_data, start_col, workspace);
+}
+
+GLOBAL(void)
+jsimd_convsamp_float(JSAMPARRAY sample_data, JDIMENSION start_col,
+                     FAST_FLOAT *workspace)
+{
+}
+
+GLOBAL(int)
+jsimd_can_fdct_islow(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (DCTSIZE != 8)
+    return 0;
+  if (sizeof(DCTELEM) != 2)
+    return 0;
+
+  if (simd_support & JSIMD_NEON)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_fdct_ifast(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (DCTSIZE != 8)
+    return 0;
+  if (sizeof(DCTELEM) != 2)
+    return 0;
+
+  if (simd_support & JSIMD_NEON)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_fdct_float(void)
+{
+  return 0;
+}
+
+GLOBAL(void)
+jsimd_fdct_islow(DCTELEM *data)
+{
+  jsimd_fdct_islow_neon(data);
+}
+
+GLOBAL(void)
+jsimd_fdct_ifast(DCTELEM *data)
+{
+  jsimd_fdct_ifast_neon(data);
+}
+
+GLOBAL(void)
+jsimd_fdct_float(FAST_FLOAT *data)
+{
+}
+
+GLOBAL(int)
+jsimd_can_quantize(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (DCTSIZE != 8)
+    return 0;
+  if (sizeof(JCOEF) != 2)
+    return 0;
+  if (sizeof(DCTELEM) != 2)
+    return 0;
+
+  if (simd_support & JSIMD_NEON)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_quantize_float(void)
+{
+  return 0;
+}
+
+GLOBAL(void)
+jsimd_quantize(JCOEFPTR coef_block, DCTELEM *divisors, DCTELEM *workspace)
+{
+  jsimd_quantize_neon(coef_block, divisors, workspace);
+}
+
+GLOBAL(void)
+jsimd_quantize_float(JCOEFPTR coef_block, FAST_FLOAT *divisors,
+                     FAST_FLOAT *workspace)
+{
+}
+
+GLOBAL(int)
+jsimd_can_idct_2x2(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (DCTSIZE != 8)
+    return 0;
+  if (sizeof(JCOEF) != 2)
+    return 0;
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+  if (sizeof(ISLOW_MULT_TYPE) != 2)
+    return 0;
+
+  if (simd_support & JSIMD_NEON)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_idct_4x4(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (DCTSIZE != 8)
+    return 0;
+  if (sizeof(JCOEF) != 2)
+    return 0;
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+  if (sizeof(ISLOW_MULT_TYPE) != 2)
+    return 0;
+
+  if (simd_support & JSIMD_NEON)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(void)
+jsimd_idct_2x2(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+               JCOEFPTR coef_block, JSAMPARRAY output_buf,
+               JDIMENSION output_col)
+{
+  jsimd_idct_2x2_neon(compptr->dct_table, coef_block, output_buf, output_col);
+}
+
+GLOBAL(void)
+jsimd_idct_4x4(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+               JCOEFPTR coef_block, JSAMPARRAY output_buf,
+               JDIMENSION output_col)
+{
+  jsimd_idct_4x4_neon(compptr->dct_table, coef_block, output_buf, output_col);
+}
+
+GLOBAL(int)
+jsimd_can_idct_islow(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (DCTSIZE != 8)
+    return 0;
+  if (sizeof(JCOEF) != 2)
+    return 0;
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+  if (sizeof(ISLOW_MULT_TYPE) != 2)
+    return 0;
+
+  if (simd_support & JSIMD_NEON)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_idct_ifast(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (DCTSIZE != 8)
+    return 0;
+  if (sizeof(JCOEF) != 2)
+    return 0;
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+  if (sizeof(IFAST_MULT_TYPE) != 2)
+    return 0;
+  if (IFAST_SCALE_BITS != 2)
+    return 0;
+
+  if (simd_support & JSIMD_NEON)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_idct_float(void)
+{
+  return 0;
+}
+
+GLOBAL(void)
+jsimd_idct_islow(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+                 JCOEFPTR coef_block, JSAMPARRAY output_buf,
+                 JDIMENSION output_col)
+{
+  jsimd_idct_islow_neon(compptr->dct_table, coef_block, output_buf,
+                        output_col);
+}
+
+GLOBAL(void)
+jsimd_idct_ifast(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+                 JCOEFPTR coef_block, JSAMPARRAY output_buf,
+                 JDIMENSION output_col)
+{
+  jsimd_idct_ifast_neon(compptr->dct_table, coef_block, output_buf,
+                        output_col);
+}
+
+GLOBAL(void)
+jsimd_idct_float(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+                 JCOEFPTR coef_block, JSAMPARRAY output_buf,
+                 JDIMENSION output_col)
+{
+}
+
+GLOBAL(int)
+jsimd_can_huff_encode_one_block(void)
+{
+  init_simd();
+
+  if (DCTSIZE != 8)
+    return 0;
+  if (sizeof(JCOEF) != 2)
+    return 0;
+
+  if (simd_support & JSIMD_NEON && simd_huffman)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(JOCTET *)
+jsimd_huff_encode_one_block(void *state, JOCTET *buffer, JCOEFPTR block,
+                            int last_dc_val, c_derived_tbl *dctbl,
+                            c_derived_tbl *actbl)
+{
+  return jsimd_huff_encode_one_block_neon(state, buffer, block, last_dc_val,
+                                          dctbl, actbl);
+}
+
+GLOBAL(int)
+jsimd_can_encode_mcu_AC_first_prepare(void)
+{
+  init_simd();
+
+  if (DCTSIZE != 8)
+    return 0;
+  if (sizeof(JCOEF) != 2)
+    return 0;
+
+  if (simd_support & JSIMD_NEON)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(void)
+jsimd_encode_mcu_AC_first_prepare(const JCOEF *block,
+                                  const int *jpeg_natural_order_start, int Sl,
+                                  int Al, JCOEF *values, size_t *zerobits)
+{
+  jsimd_encode_mcu_AC_first_prepare_neon(block, jpeg_natural_order_start,
+                                         Sl, Al, values, zerobits);
+}
+
+GLOBAL(int)
+jsimd_can_encode_mcu_AC_refine_prepare(void)
+{
+  init_simd();
+
+  if (DCTSIZE != 8)
+    return 0;
+  if (sizeof(JCOEF) != 2)
+    return 0;
+
+  if (simd_support & JSIMD_NEON)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_encode_mcu_AC_refine_prepare(const JCOEF *block,
+                                   const int *jpeg_natural_order_start, int Sl,
+                                   int Al, JCOEF *absvalues, size_t *bits)
+{
+  return jsimd_encode_mcu_AC_refine_prepare_neon(block,
+                                                 jpeg_natural_order_start, Sl,
+                                                 Al, absvalues, bits);
+}
diff --git a/3rdparty/libjpeg/src/simd/arm/aarch32/jsimd_neon.S b/3rdparty/libjpeg/src/simd/arm/aarch32/jsimd_neon.S
new file mode 100644
index 00000000..7e1e2b14
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/arm/aarch32/jsimd_neon.S
@@ -0,0 +1,1200 @@
+/*
+ * Armv7 Neon optimizations for libjpeg-turbo
+ *
+ * Copyright (C) 2009-2011, Nokia Corporation and/or its subsidiary(-ies).
+ *                          All Rights Reserved.
+ * Author:  Siarhei Siamashka <siarhei.siamashka@nokia.com>
+ * Copyright (C) 2014, Siarhei Siamashka.  All Rights Reserved.
+ * Copyright (C) 2014, Linaro Limited.  All Rights Reserved.
+ * Copyright (C) 2015, D. R. Commander.  All Rights Reserved.
+ * Copyright (C) 2015-2016, 2018, Matthieu Darbois.  All Rights Reserved.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+#if defined(__linux__) && defined(__ELF__)
+.section .note.GNU-stack, "", %progbits  /* mark stack as non-executable */
+#endif
+
+.text
+.fpu neon
+.arch armv7a
+.object_arch armv4
+.arm
+.syntax unified
+
+
+/*****************************************************************************/
+
+/* Supplementary macro for setting function attributes */
+.macro asm_function fname
+#ifdef __APPLE__
+    .private_extern _\fname
+    .globl _\fname
+_\fname:
+#else
+    .global \fname
+#ifdef __ELF__
+    .hidden \fname
+    .type \fname, %function
+#endif
+\fname:
+#endif
+.endm
+
+
+#define CENTERJSAMPLE  128
+
+/*****************************************************************************/
+
+/*
+ * Perform dequantization and inverse DCT on one block of coefficients.
+ *
+ * GLOBAL(void)
+ * jsimd_idct_islow_neon(void *dct_table, JCOEFPTR coef_block,
+ *                       JSAMPARRAY output_buf, JDIMENSION output_col)
+ */
+
+#define FIX_0_298631336  (2446)
+#define FIX_0_390180644  (3196)
+#define FIX_0_541196100  (4433)
+#define FIX_0_765366865  (6270)
+#define FIX_0_899976223  (7373)
+#define FIX_1_175875602  (9633)
+#define FIX_1_501321110  (12299)
+#define FIX_1_847759065  (15137)
+#define FIX_1_961570560  (16069)
+#define FIX_2_053119869  (16819)
+#define FIX_2_562915447  (20995)
+#define FIX_3_072711026  (25172)
+
+#define FIX_1_175875602_MINUS_1_961570560  (FIX_1_175875602 - FIX_1_961570560)
+#define FIX_1_175875602_MINUS_0_390180644  (FIX_1_175875602 - FIX_0_390180644)
+#define FIX_0_541196100_MINUS_1_847759065  (FIX_0_541196100 - FIX_1_847759065)
+#define FIX_3_072711026_MINUS_2_562915447  (FIX_3_072711026 - FIX_2_562915447)
+#define FIX_0_298631336_MINUS_0_899976223  (FIX_0_298631336 - FIX_0_899976223)
+#define FIX_1_501321110_MINUS_0_899976223  (FIX_1_501321110 - FIX_0_899976223)
+#define FIX_2_053119869_MINUS_2_562915447  (FIX_2_053119869 - FIX_2_562915447)
+#define FIX_0_541196100_PLUS_0_765366865   (FIX_0_541196100 + FIX_0_765366865)
+
+/*
+ * Reference SIMD-friendly 1-D ISLOW iDCT C implementation.
+ * Uses some ideas from the comments in 'simd/jiss2int-64.asm'
+ */
+#define REF_1D_IDCT(xrow0, xrow1, xrow2, xrow3, xrow4, xrow5, xrow6, xrow7) { \
+  DCTELEM row0, row1, row2, row3, row4, row5, row6, row7; \
+  JLONG   q1, q2, q3, q4, q5, q6, q7; \
+  JLONG   tmp11_plus_tmp2, tmp11_minus_tmp2; \
+  \
+  /* 1-D iDCT input data */ \
+  row0 = xrow0; \
+  row1 = xrow1; \
+  row2 = xrow2; \
+  row3 = xrow3; \
+  row4 = xrow4; \
+  row5 = xrow5; \
+  row6 = xrow6; \
+  row7 = xrow7; \
+  \
+  q5 = row7 + row3; \
+  q4 = row5 + row1; \
+  q6 = MULTIPLY(q5, FIX_1_175875602_MINUS_1_961570560) + \
+       MULTIPLY(q4, FIX_1_175875602); \
+  q7 = MULTIPLY(q5, FIX_1_175875602) + \
+       MULTIPLY(q4, FIX_1_175875602_MINUS_0_390180644); \
+  q2 = MULTIPLY(row2, FIX_0_541196100) + \
+       MULTIPLY(row6, FIX_0_541196100_MINUS_1_847759065); \
+  q4 = q6; \
+  q3 = ((JLONG)row0 - (JLONG)row4) << 13; \
+  q6 += MULTIPLY(row5, -FIX_2_562915447) + \
+        MULTIPLY(row3, FIX_3_072711026_MINUS_2_562915447); \
+  /* now we can use q1 (reloadable constants have been used up) */ \
+  q1 = q3 + q2; \
+  q4 += MULTIPLY(row7, FIX_0_298631336_MINUS_0_899976223) + \
+        MULTIPLY(row1, -FIX_0_899976223); \
+  q5 = q7; \
+  q1 = q1 + q6; \
+  q7 += MULTIPLY(row7, -FIX_0_899976223) + \
+        MULTIPLY(row1, FIX_1_501321110_MINUS_0_899976223); \
+  \
+  /* (tmp11 + tmp2) has been calculated (out_row1 before descale) */ \
+  tmp11_plus_tmp2 = q1; \
+  row1 = 0; \
+  \
+  q1 = q1 - q6; \
+  q5 += MULTIPLY(row5, FIX_2_053119869_MINUS_2_562915447) + \
+        MULTIPLY(row3, -FIX_2_562915447); \
+  q1 = q1 - q6; \
+  q6 = MULTIPLY(row2, FIX_0_541196100_PLUS_0_765366865) + \
+       MULTIPLY(row6, FIX_0_541196100); \
+  q3 = q3 - q2; \
+  \
+  /* (tmp11 - tmp2) has been calculated (out_row6 before descale) */ \
+  tmp11_minus_tmp2 = q1; \
+  \
+  q1 = ((JLONG)row0 + (JLONG)row4) << 13; \
+  q2 = q1 + q6; \
+  q1 = q1 - q6; \
+  \
+  /* pick up the results */ \
+  tmp0  = q4; \
+  tmp1  = q5; \
+  tmp2  = (tmp11_plus_tmp2 - tmp11_minus_tmp2) / 2; \
+  tmp3  = q7; \
+  tmp10 = q2; \
+  tmp11 = (tmp11_plus_tmp2 + tmp11_minus_tmp2) / 2; \
+  tmp12 = q3; \
+  tmp13 = q1; \
+}
+
+#define XFIX_0_899976223                    d0[0]
+#define XFIX_0_541196100                    d0[1]
+#define XFIX_2_562915447                    d0[2]
+#define XFIX_0_298631336_MINUS_0_899976223  d0[3]
+#define XFIX_1_501321110_MINUS_0_899976223  d1[0]
+#define XFIX_2_053119869_MINUS_2_562915447  d1[1]
+#define XFIX_0_541196100_PLUS_0_765366865   d1[2]
+#define XFIX_1_175875602                    d1[3]
+#define XFIX_1_175875602_MINUS_0_390180644  d2[0]
+#define XFIX_0_541196100_MINUS_1_847759065  d2[1]
+#define XFIX_3_072711026_MINUS_2_562915447  d2[2]
+#define XFIX_1_175875602_MINUS_1_961570560  d2[3]
+
+.balign 16
+jsimd_idct_islow_neon_consts:
+  .short FIX_0_899976223                    /* d0[0] */
+  .short FIX_0_541196100                    /* d0[1] */
+  .short FIX_2_562915447                    /* d0[2] */
+  .short FIX_0_298631336_MINUS_0_899976223  /* d0[3] */
+  .short FIX_1_501321110_MINUS_0_899976223  /* d1[0] */
+  .short FIX_2_053119869_MINUS_2_562915447  /* d1[1] */
+  .short FIX_0_541196100_PLUS_0_765366865   /* d1[2] */
+  .short FIX_1_175875602                    /* d1[3] */
+  /* reloadable constants */
+  .short FIX_1_175875602_MINUS_0_390180644  /* d2[0] */
+  .short FIX_0_541196100_MINUS_1_847759065  /* d2[1] */
+  .short FIX_3_072711026_MINUS_2_562915447  /* d2[2] */
+  .short FIX_1_175875602_MINUS_1_961570560  /* d2[3] */
+
+asm_function jsimd_idct_islow_neon
+
+    DCT_TABLE       .req r0
+    COEF_BLOCK      .req r1
+    OUTPUT_BUF      .req r2
+    OUTPUT_COL      .req r3
+    TMP1            .req r0
+    TMP2            .req r1
+    TMP3            .req r2
+    TMP4            .req ip
+
+    ROW0L           .req d16
+    ROW0R           .req d17
+    ROW1L           .req d18
+    ROW1R           .req d19
+    ROW2L           .req d20
+    ROW2R           .req d21
+    ROW3L           .req d22
+    ROW3R           .req d23
+    ROW4L           .req d24
+    ROW4R           .req d25
+    ROW5L           .req d26
+    ROW5R           .req d27
+    ROW6L           .req d28
+    ROW6R           .req d29
+    ROW7L           .req d30
+    ROW7R           .req d31
+
+    /* Load and dequantize coefficients into Neon registers
+     * with the following allocation:
+     *       0 1 2 3 | 4 5 6 7
+     *      ---------+--------
+     *   0 | d16     | d17     ( q8  )
+     *   1 | d18     | d19     ( q9  )
+     *   2 | d20     | d21     ( q10 )
+     *   3 | d22     | d23     ( q11 )
+     *   4 | d24     | d25     ( q12 )
+     *   5 | d26     | d27     ( q13 )
+     *   6 | d28     | d29     ( q14 )
+     *   7 | d30     | d31     ( q15 )
+     */
+    adr             ip, jsimd_idct_islow_neon_consts
+    vld1.16         {d16, d17, d18, d19}, [COEF_BLOCK, :128]!
+    vld1.16         {d0, d1, d2, d3}, [DCT_TABLE, :128]!
+    vld1.16         {d20, d21, d22, d23}, [COEF_BLOCK, :128]!
+    vmul.s16        q8, q8, q0
+    vld1.16         {d4, d5, d6, d7}, [DCT_TABLE, :128]!
+    vmul.s16        q9, q9, q1
+    vld1.16         {d24, d25, d26, d27}, [COEF_BLOCK, :128]!
+    vmul.s16        q10, q10, q2
+    vld1.16         {d0, d1, d2, d3}, [DCT_TABLE, :128]!
+    vmul.s16        q11, q11, q3
+    vld1.16         {d28, d29, d30, d31}, [COEF_BLOCK, :128]
+    vmul.s16        q12, q12, q0
+    vld1.16         {d4, d5, d6, d7}, [DCT_TABLE, :128]!
+    vmul.s16        q14, q14, q2
+    vmul.s16        q13, q13, q1
+    vld1.16         {d0, d1, d2, d3}, [ip, :128]  /* load constants */
+    add             ip, ip, #16
+    vmul.s16        q15, q15, q3
+    vpush           {d8 - d15}                    /* save Neon registers */
+    /* 1-D IDCT, pass 1, left 4x8 half */
+    vadd.s16        d4, ROW7L, ROW3L
+    vadd.s16        d5, ROW5L, ROW1L
+    vmull.s16       q6, d4, XFIX_1_175875602_MINUS_1_961570560
+    vmlal.s16       q6, d5, XFIX_1_175875602
+    vmull.s16       q7, d4, XFIX_1_175875602
+      /* Check for the zero coefficients in the right 4x8 half */
+      push            {r4, r5}
+    vmlal.s16       q7, d5, XFIX_1_175875602_MINUS_0_390180644
+    vsubl.s16       q3, ROW0L, ROW4L
+      ldrd            r4, [COEF_BLOCK, #(-96 + 2 * (4 + 1 * 8))]
+    vmull.s16       q2, ROW2L, XFIX_0_541196100
+    vmlal.s16       q2, ROW6L, XFIX_0_541196100_MINUS_1_847759065
+      orr             r0, r4, r5
+    vmov            q4, q6
+    vmlsl.s16       q6, ROW5L, XFIX_2_562915447
+      ldrd            r4, [COEF_BLOCK, #(-96 + 2 * (4 + 2 * 8))]
+    vmlal.s16       q6, ROW3L, XFIX_3_072711026_MINUS_2_562915447
+    vshl.s32        q3, q3, #13
+      orr             r0, r0, r4
+    vmlsl.s16       q4, ROW1L, XFIX_0_899976223
+      orr             r0, r0, r5
+    vadd.s32        q1, q3, q2
+      ldrd            r4, [COEF_BLOCK, #(-96 + 2 * (4 + 3 * 8))]
+    vmov            q5, q7
+    vadd.s32        q1, q1, q6
+      orr             r0, r0, r4
+    vmlsl.s16       q7, ROW7L, XFIX_0_899976223
+      orr             r0, r0, r5
+    vmlal.s16       q7, ROW1L, XFIX_1_501321110_MINUS_0_899976223
+    vrshrn.s32      ROW1L, q1, #11
+      ldrd            r4, [COEF_BLOCK, #(-96 + 2 * (4 + 4 * 8))]
+    vsub.s32        q1, q1, q6
+    vmlal.s16       q5, ROW5L, XFIX_2_053119869_MINUS_2_562915447
+      orr             r0, r0, r4
+    vmlsl.s16       q5, ROW3L, XFIX_2_562915447
+      orr             r0, r0, r5
+    vsub.s32        q1, q1, q6
+    vmull.s16       q6, ROW2L, XFIX_0_541196100_PLUS_0_765366865
+      ldrd            r4, [COEF_BLOCK, #(-96 + 2 * (4 + 5 * 8))]
+    vmlal.s16       q6, ROW6L, XFIX_0_541196100
+    vsub.s32        q3, q3, q2
+      orr             r0, r0, r4
+    vrshrn.s32      ROW6L, q1, #11
+      orr             r0, r0, r5
+    vadd.s32        q1, q3, q5
+      ldrd            r4, [COEF_BLOCK, #(-96 + 2 * (4 + 6 * 8))]
+    vsub.s32        q3, q3, q5
+    vaddl.s16       q5, ROW0L, ROW4L
+      orr             r0, r0, r4
+    vrshrn.s32      ROW2L, q1, #11
+      orr             r0, r0, r5
+    vrshrn.s32      ROW5L, q3, #11
+      ldrd            r4, [COEF_BLOCK, #(-96 + 2 * (4 + 7 * 8))]
+    vshl.s32        q5, q5, #13
+    vmlal.s16       q4, ROW7L, XFIX_0_298631336_MINUS_0_899976223
+      orr             r0, r0, r4
+    vadd.s32        q2, q5, q6
+      orrs            r0, r0, r5
+    vsub.s32        q1, q5, q6
+    vadd.s32        q6, q2, q7
+      ldrd            r4, [COEF_BLOCK, #(-96 + 2 * (4 + 0 * 8))]
+    vsub.s32        q2, q2, q7
+    vadd.s32        q5, q1, q4
+      orr             r0, r4, r5
+    vsub.s32        q3, q1, q4
+      pop             {r4, r5}
+    vrshrn.s32      ROW7L, q2, #11
+    vrshrn.s32      ROW3L, q5, #11
+    vrshrn.s32      ROW0L, q6, #11
+    vrshrn.s32      ROW4L, q3, #11
+
+      beq             3f  /* Go to do some special handling for the sparse
+                             right 4x8 half */
+
+    /* 1-D IDCT, pass 1, right 4x8 half */
+    vld1.s16        {d2}, [ip, :64]  /* reload constants */
+    vadd.s16        d10, ROW7R, ROW3R
+    vadd.s16        d8, ROW5R, ROW1R
+      /* Transpose left 4x8 half */
+      vtrn.16         ROW6L, ROW7L
+    vmull.s16       q6, d10, XFIX_1_175875602_MINUS_1_961570560
+    vmlal.s16       q6, d8, XFIX_1_175875602
+      vtrn.16         ROW2L, ROW3L
+    vmull.s16       q7, d10, XFIX_1_175875602
+    vmlal.s16       q7, d8, XFIX_1_175875602_MINUS_0_390180644
+      vtrn.16         ROW0L, ROW1L
+    vsubl.s16       q3, ROW0R, ROW4R
+    vmull.s16       q2, ROW2R, XFIX_0_541196100
+    vmlal.s16       q2, ROW6R, XFIX_0_541196100_MINUS_1_847759065
+      vtrn.16         ROW4L, ROW5L
+    vmov            q4, q6
+    vmlsl.s16       q6, ROW5R, XFIX_2_562915447
+    vmlal.s16       q6, ROW3R, XFIX_3_072711026_MINUS_2_562915447
+      vtrn.32         ROW1L, ROW3L
+    vshl.s32        q3, q3, #13
+    vmlsl.s16       q4, ROW1R, XFIX_0_899976223
+      vtrn.32         ROW4L, ROW6L
+    vadd.s32        q1, q3, q2
+    vmov            q5, q7
+    vadd.s32        q1, q1, q6
+      vtrn.32         ROW0L, ROW2L
+    vmlsl.s16       q7, ROW7R, XFIX_0_899976223
+    vmlal.s16       q7, ROW1R, XFIX_1_501321110_MINUS_0_899976223
+    vrshrn.s32      ROW1R, q1, #11
+      vtrn.32         ROW5L, ROW7L
+    vsub.s32        q1, q1, q6
+    vmlal.s16       q5, ROW5R, XFIX_2_053119869_MINUS_2_562915447
+    vmlsl.s16       q5, ROW3R, XFIX_2_562915447
+    vsub.s32        q1, q1, q6
+    vmull.s16       q6, ROW2R, XFIX_0_541196100_PLUS_0_765366865
+    vmlal.s16       q6, ROW6R, XFIX_0_541196100
+    vsub.s32        q3, q3, q2
+    vrshrn.s32      ROW6R, q1, #11
+    vadd.s32        q1, q3, q5
+    vsub.s32        q3, q3, q5
+    vaddl.s16       q5, ROW0R, ROW4R
+    vrshrn.s32      ROW2R, q1, #11
+    vrshrn.s32      ROW5R, q3, #11
+    vshl.s32        q5, q5, #13
+    vmlal.s16       q4, ROW7R, XFIX_0_298631336_MINUS_0_899976223
+    vadd.s32        q2, q5, q6
+    vsub.s32        q1, q5, q6
+    vadd.s32        q6, q2, q7
+    vsub.s32        q2, q2, q7
+    vadd.s32        q5, q1, q4
+    vsub.s32        q3, q1, q4
+    vrshrn.s32      ROW7R, q2, #11
+    vrshrn.s32      ROW3R, q5, #11
+    vrshrn.s32      ROW0R, q6, #11
+    vrshrn.s32      ROW4R, q3, #11
+    /* Transpose right 4x8 half */
+    vtrn.16         ROW6R, ROW7R
+    vtrn.16         ROW2R, ROW3R
+    vtrn.16         ROW0R, ROW1R
+    vtrn.16         ROW4R, ROW5R
+    vtrn.32         ROW1R, ROW3R
+    vtrn.32         ROW4R, ROW6R
+    vtrn.32         ROW0R, ROW2R
+    vtrn.32         ROW5R, ROW7R
+
+1:  /* 1-D IDCT, pass 2 (normal variant), left 4x8 half */
+    vld1.s16        {d2}, [ip, :64]               /* reload constants */
+    vmull.s16       q6, ROW1R, XFIX_1_175875602   /* ROW5L <-> ROW1R */
+    vmlal.s16       q6, ROW1L, XFIX_1_175875602
+    vmlal.s16       q6, ROW3R, XFIX_1_175875602_MINUS_1_961570560  /* ROW7L <-> ROW3R */
+    vmlal.s16       q6, ROW3L, XFIX_1_175875602_MINUS_1_961570560
+    vmull.s16       q7, ROW3R, XFIX_1_175875602   /* ROW7L <-> ROW3R */
+    vmlal.s16       q7, ROW3L, XFIX_1_175875602
+    vmlal.s16       q7, ROW1R, XFIX_1_175875602_MINUS_0_390180644  /* ROW5L <-> ROW1R */
+    vmlal.s16       q7, ROW1L, XFIX_1_175875602_MINUS_0_390180644
+    vsubl.s16       q3, ROW0L, ROW0R              /* ROW4L <-> ROW0R */
+    vmull.s16       q2, ROW2L, XFIX_0_541196100
+    vmlal.s16       q2, ROW2R, XFIX_0_541196100_MINUS_1_847759065  /* ROW6L <-> ROW2R */
+    vmov            q4, q6
+    vmlsl.s16       q6, ROW1R, XFIX_2_562915447   /* ROW5L <-> ROW1R */
+    vmlal.s16       q6, ROW3L, XFIX_3_072711026_MINUS_2_562915447
+    vshl.s32        q3, q3, #13
+    vmlsl.s16       q4, ROW1L, XFIX_0_899976223
+    vadd.s32        q1, q3, q2
+    vmov            q5, q7
+    vadd.s32        q1, q1, q6
+    vmlsl.s16       q7, ROW3R, XFIX_0_899976223   /* ROW7L <-> ROW3R */
+    vmlal.s16       q7, ROW1L, XFIX_1_501321110_MINUS_0_899976223
+    vshrn.s32       ROW1L, q1, #16
+    vsub.s32        q1, q1, q6
+    vmlal.s16       q5, ROW1R, XFIX_2_053119869_MINUS_2_562915447  /* ROW5L <-> ROW1R */
+    vmlsl.s16       q5, ROW3L, XFIX_2_562915447
+    vsub.s32        q1, q1, q6
+    vmull.s16       q6, ROW2L, XFIX_0_541196100_PLUS_0_765366865
+    vmlal.s16       q6, ROW2R, XFIX_0_541196100   /* ROW6L <-> ROW2R */
+    vsub.s32        q3, q3, q2
+    vshrn.s32       ROW2R, q1, #16                /* ROW6L <-> ROW2R */
+    vadd.s32        q1, q3, q5
+    vsub.s32        q3, q3, q5
+    vaddl.s16       q5, ROW0L, ROW0R              /* ROW4L <-> ROW0R */
+    vshrn.s32       ROW2L, q1, #16
+    vshrn.s32       ROW1R, q3, #16                /* ROW5L <-> ROW1R */
+    vshl.s32        q5, q5, #13
+    vmlal.s16       q4, ROW3R, XFIX_0_298631336_MINUS_0_899976223  /* ROW7L <-> ROW3R */
+    vadd.s32        q2, q5, q6
+    vsub.s32        q1, q5, q6
+    vadd.s32        q6, q2, q7
+    vsub.s32        q2, q2, q7
+    vadd.s32        q5, q1, q4
+    vsub.s32        q3, q1, q4
+    vshrn.s32       ROW3R, q2, #16                /* ROW7L <-> ROW3R */
+    vshrn.s32       ROW3L, q5, #16
+    vshrn.s32       ROW0L, q6, #16
+    vshrn.s32       ROW0R, q3, #16                /* ROW4L <-> ROW0R */
+    /* 1-D IDCT, pass 2, right 4x8 half */
+    vld1.s16        {d2}, [ip, :64]               /* reload constants */
+    vmull.s16       q6, ROW5R, XFIX_1_175875602
+    vmlal.s16       q6, ROW5L, XFIX_1_175875602   /* ROW5L <-> ROW1R */
+    vmlal.s16       q6, ROW7R, XFIX_1_175875602_MINUS_1_961570560
+    vmlal.s16       q6, ROW7L, XFIX_1_175875602_MINUS_1_961570560  /* ROW7L <-> ROW3R */
+    vmull.s16       q7, ROW7R, XFIX_1_175875602
+    vmlal.s16       q7, ROW7L, XFIX_1_175875602   /* ROW7L <-> ROW3R */
+    vmlal.s16       q7, ROW5R, XFIX_1_175875602_MINUS_0_390180644
+    vmlal.s16       q7, ROW5L, XFIX_1_175875602_MINUS_0_390180644  /* ROW5L <-> ROW1R */
+    vsubl.s16       q3, ROW4L, ROW4R              /* ROW4L <-> ROW0R */
+    vmull.s16       q2, ROW6L, XFIX_0_541196100   /* ROW6L <-> ROW2R */
+    vmlal.s16       q2, ROW6R, XFIX_0_541196100_MINUS_1_847759065
+    vmov            q4, q6
+    vmlsl.s16       q6, ROW5R, XFIX_2_562915447
+    vmlal.s16       q6, ROW7L, XFIX_3_072711026_MINUS_2_562915447  /* ROW7L <-> ROW3R */
+    vshl.s32        q3, q3, #13
+    vmlsl.s16       q4, ROW5L, XFIX_0_899976223   /* ROW5L <-> ROW1R */
+    vadd.s32        q1, q3, q2
+    vmov            q5, q7
+    vadd.s32        q1, q1, q6
+    vmlsl.s16       q7, ROW7R, XFIX_0_899976223
+    vmlal.s16       q7, ROW5L, XFIX_1_501321110_MINUS_0_899976223  /* ROW5L <-> ROW1R */
+    vshrn.s32       ROW5L, q1, #16                /* ROW5L <-> ROW1R */
+    vsub.s32        q1, q1, q6
+    vmlal.s16       q5, ROW5R, XFIX_2_053119869_MINUS_2_562915447
+    vmlsl.s16       q5, ROW7L, XFIX_2_562915447   /* ROW7L <-> ROW3R */
+    vsub.s32        q1, q1, q6
+    vmull.s16       q6, ROW6L, XFIX_0_541196100_PLUS_0_765366865  /* ROW6L <-> ROW2R */
+    vmlal.s16       q6, ROW6R, XFIX_0_541196100
+    vsub.s32        q3, q3, q2
+    vshrn.s32       ROW6R, q1, #16
+    vadd.s32        q1, q3, q5
+    vsub.s32        q3, q3, q5
+    vaddl.s16       q5, ROW4L, ROW4R              /* ROW4L <-> ROW0R */
+    vshrn.s32       ROW6L, q1, #16                /* ROW6L <-> ROW2R */
+    vshrn.s32       ROW5R, q3, #16
+    vshl.s32        q5, q5, #13
+    vmlal.s16       q4, ROW7R, XFIX_0_298631336_MINUS_0_899976223
+    vadd.s32        q2, q5, q6
+    vsub.s32        q1, q5, q6
+    vadd.s32        q6, q2, q7
+    vsub.s32        q2, q2, q7
+    vadd.s32        q5, q1, q4
+    vsub.s32        q3, q1, q4
+    vshrn.s32       ROW7R, q2, #16
+    vshrn.s32       ROW7L, q5, #16                /* ROW7L <-> ROW3R */
+    vshrn.s32       ROW4L, q6, #16                /* ROW4L <-> ROW0R */
+    vshrn.s32       ROW4R, q3, #16
+
+2:  /* Descale to 8-bit and range limit */
+    vqrshrn.s16     d16, q8, #2
+    vqrshrn.s16     d17, q9, #2
+    vqrshrn.s16     d18, q10, #2
+    vqrshrn.s16     d19, q11, #2
+    vpop            {d8 - d15}                    /* restore Neon registers */
+    vqrshrn.s16     d20, q12, #2
+      /* Transpose the final 8-bit samples and do signed->unsigned conversion */
+      vtrn.16         q8, q9
+    vqrshrn.s16     d21, q13, #2
+    vqrshrn.s16     d22, q14, #2
+      vmov.u8         q0, #(CENTERJSAMPLE)
+    vqrshrn.s16     d23, q15, #2
+      vtrn.8          d16, d17
+      vtrn.8          d18, d19
+      vadd.u8         q8, q8, q0
+      vadd.u8         q9, q9, q0
+      vtrn.16         q10, q11
+        /* Store results to the output buffer */
+        ldmia           OUTPUT_BUF!, {TMP1, TMP2}
+        add             TMP1, TMP1, OUTPUT_COL
+        add             TMP2, TMP2, OUTPUT_COL
+        vst1.8          {d16}, [TMP1]
+      vtrn.8          d20, d21
+        vst1.8          {d17}, [TMP2]
+        ldmia           OUTPUT_BUF!, {TMP1, TMP2}
+        add             TMP1, TMP1, OUTPUT_COL
+        add             TMP2, TMP2, OUTPUT_COL
+        vst1.8          {d18}, [TMP1]
+      vadd.u8         q10, q10, q0
+        vst1.8          {d19}, [TMP2]
+        ldmia           OUTPUT_BUF, {TMP1, TMP2, TMP3, TMP4}
+        add             TMP1, TMP1, OUTPUT_COL
+        add             TMP2, TMP2, OUTPUT_COL
+        add             TMP3, TMP3, OUTPUT_COL
+        add             TMP4, TMP4, OUTPUT_COL
+      vtrn.8          d22, d23
+        vst1.8          {d20}, [TMP1]
+      vadd.u8         q11, q11, q0
+        vst1.8          {d21}, [TMP2]
+        vst1.8          {d22}, [TMP3]
+        vst1.8          {d23}, [TMP4]
+    bx              lr
+
+3:  /* Left 4x8 half is done, right 4x8 half contains mostly zeros */
+
+    /* Transpose left 4x8 half */
+    vtrn.16         ROW6L, ROW7L
+    vtrn.16         ROW2L, ROW3L
+    vtrn.16         ROW0L, ROW1L
+    vtrn.16         ROW4L, ROW5L
+    vshl.s16        ROW0R, ROW0R, #2  /* PASS1_BITS */
+    vtrn.32         ROW1L, ROW3L
+    vtrn.32         ROW4L, ROW6L
+    vtrn.32         ROW0L, ROW2L
+    vtrn.32         ROW5L, ROW7L
+
+    cmp             r0, #0
+    beq             4f  /* Right 4x8 half has all zeros, go to 'sparse' second
+                           pass */
+
+    /* Only row 0 is non-zero for the right 4x8 half  */
+    vdup.s16        ROW1R, ROW0R[1]
+    vdup.s16        ROW2R, ROW0R[2]
+    vdup.s16        ROW3R, ROW0R[3]
+    vdup.s16        ROW4R, ROW0R[0]
+    vdup.s16        ROW5R, ROW0R[1]
+    vdup.s16        ROW6R, ROW0R[2]
+    vdup.s16        ROW7R, ROW0R[3]
+    vdup.s16        ROW0R, ROW0R[0]
+    b               1b  /* Go to 'normal' second pass */
+
+4:  /* 1-D IDCT, pass 2 (sparse variant with zero rows 4-7), left 4x8 half */
+    vld1.s16        {d2}, [ip, :64]               /* reload constants */
+    vmull.s16       q6, ROW1L, XFIX_1_175875602
+    vmlal.s16       q6, ROW3L, XFIX_1_175875602_MINUS_1_961570560
+    vmull.s16       q7, ROW3L, XFIX_1_175875602
+    vmlal.s16       q7, ROW1L, XFIX_1_175875602_MINUS_0_390180644
+    vmull.s16       q2, ROW2L, XFIX_0_541196100
+    vshll.s16       q3, ROW0L, #13
+    vmov            q4, q6
+    vmlal.s16       q6, ROW3L, XFIX_3_072711026_MINUS_2_562915447
+    vmlsl.s16       q4, ROW1L, XFIX_0_899976223
+    vadd.s32        q1, q3, q2
+    vmov            q5, q7
+    vmlal.s16       q7, ROW1L, XFIX_1_501321110_MINUS_0_899976223
+    vadd.s32        q1, q1, q6
+    vadd.s32        q6, q6, q6
+    vmlsl.s16       q5, ROW3L, XFIX_2_562915447
+    vshrn.s32       ROW1L, q1, #16
+    vsub.s32        q1, q1, q6
+    vmull.s16       q6, ROW2L, XFIX_0_541196100_PLUS_0_765366865
+    vsub.s32        q3, q3, q2
+    vshrn.s32       ROW2R, q1, #16                /* ROW6L <-> ROW2R */
+    vadd.s32        q1, q3, q5
+    vsub.s32        q3, q3, q5
+    vshll.s16       q5, ROW0L, #13
+    vshrn.s32       ROW2L, q1, #16
+    vshrn.s32       ROW1R, q3, #16                /* ROW5L <-> ROW1R */
+    vadd.s32        q2, q5, q6
+    vsub.s32        q1, q5, q6
+    vadd.s32        q6, q2, q7
+    vsub.s32        q2, q2, q7
+    vadd.s32        q5, q1, q4
+    vsub.s32        q3, q1, q4
+    vshrn.s32       ROW3R, q2, #16                /* ROW7L <-> ROW3R */
+    vshrn.s32       ROW3L, q5, #16
+    vshrn.s32       ROW0L, q6, #16
+    vshrn.s32       ROW0R, q3, #16                /* ROW4L <-> ROW0R */
+    /* 1-D IDCT, pass 2 (sparse variant with zero rows 4-7), right 4x8 half */
+    vld1.s16        {d2}, [ip, :64]               /* reload constants */
+    vmull.s16       q6, ROW5L, XFIX_1_175875602
+    vmlal.s16       q6, ROW7L, XFIX_1_175875602_MINUS_1_961570560
+    vmull.s16       q7, ROW7L, XFIX_1_175875602
+    vmlal.s16       q7, ROW5L, XFIX_1_175875602_MINUS_0_390180644
+    vmull.s16       q2, ROW6L, XFIX_0_541196100
+    vshll.s16       q3, ROW4L, #13
+    vmov            q4, q6
+    vmlal.s16       q6, ROW7L, XFIX_3_072711026_MINUS_2_562915447
+    vmlsl.s16       q4, ROW5L, XFIX_0_899976223
+    vadd.s32        q1, q3, q2
+    vmov            q5, q7
+    vmlal.s16       q7, ROW5L, XFIX_1_501321110_MINUS_0_899976223
+    vadd.s32        q1, q1, q6
+    vadd.s32        q6, q6, q6
+    vmlsl.s16       q5, ROW7L, XFIX_2_562915447
+    vshrn.s32       ROW5L, q1, #16                /* ROW5L <-> ROW1R */
+    vsub.s32        q1, q1, q6
+    vmull.s16       q6, ROW6L, XFIX_0_541196100_PLUS_0_765366865
+    vsub.s32        q3, q3, q2
+    vshrn.s32       ROW6R, q1, #16
+    vadd.s32        q1, q3, q5
+    vsub.s32        q3, q3, q5
+    vshll.s16       q5, ROW4L, #13
+    vshrn.s32       ROW6L, q1, #16                /* ROW6L <-> ROW2R */
+    vshrn.s32       ROW5R, q3, #16
+    vadd.s32        q2, q5, q6
+    vsub.s32        q1, q5, q6
+    vadd.s32        q6, q2, q7
+    vsub.s32        q2, q2, q7
+    vadd.s32        q5, q1, q4
+    vsub.s32        q3, q1, q4
+    vshrn.s32       ROW7R, q2, #16
+    vshrn.s32       ROW7L, q5, #16                /* ROW7L <-> ROW3R */
+    vshrn.s32       ROW4L, q6, #16                /* ROW4L <-> ROW0R */
+    vshrn.s32       ROW4R, q3, #16
+    b               2b                            /* Go to epilogue */
+
+    .unreq          DCT_TABLE
+    .unreq          COEF_BLOCK
+    .unreq          OUTPUT_BUF
+    .unreq          OUTPUT_COL
+    .unreq          TMP1
+    .unreq          TMP2
+    .unreq          TMP3
+    .unreq          TMP4
+
+    .unreq          ROW0L
+    .unreq          ROW0R
+    .unreq          ROW1L
+    .unreq          ROW1R
+    .unreq          ROW2L
+    .unreq          ROW2R
+    .unreq          ROW3L
+    .unreq          ROW3R
+    .unreq          ROW4L
+    .unreq          ROW4R
+    .unreq          ROW5L
+    .unreq          ROW5R
+    .unreq          ROW6L
+    .unreq          ROW6R
+    .unreq          ROW7L
+    .unreq          ROW7R
+
+
+/*****************************************************************************/
+
+/*
+ * jsimd_idct_ifast_neon
+ *
+ * This function contains a fast, not so accurate integer implementation of
+ * the inverse DCT (Discrete Cosine Transform). It uses the same calculations
+ * and produces exactly the same output as IJG's original 'jpeg_idct_ifast'
+ * function from jidctfst.c
+ *
+ * Normally 1-D AAN DCT needs 5 multiplications and 29 additions.
+ * But in Arm Neon case some extra additions are required because VQDMULH
+ * instruction can't handle the constants larger than 1. So the expressions
+ * like "x * 1.082392200" have to be converted to "x * 0.082392200 + x",
+ * which introduces an extra addition. Overall, there are 6 extra additions
+ * per 1-D IDCT pass, totalling to 5 VQDMULH and 35 VADD/VSUB instructions.
+ */
+
+#define XFIX_1_082392200  d0[0]
+#define XFIX_1_414213562  d0[1]
+#define XFIX_1_847759065  d0[2]
+#define XFIX_2_613125930  d0[3]
+
+.balign 16
+jsimd_idct_ifast_neon_consts:
+  .short (277 * 128 - 256 * 128)  /* XFIX_1_082392200 */
+  .short (362 * 128 - 256 * 128)  /* XFIX_1_414213562 */
+  .short (473 * 128 - 256 * 128)  /* XFIX_1_847759065 */
+  .short (669 * 128 - 512 * 128)  /* XFIX_2_613125930 */
+
+asm_function jsimd_idct_ifast_neon
+
+    DCT_TABLE       .req r0
+    COEF_BLOCK      .req r1
+    OUTPUT_BUF      .req r2
+    OUTPUT_COL      .req r3
+    TMP1            .req r0
+    TMP2            .req r1
+    TMP3            .req r2
+    TMP4            .req ip
+
+    /* Load and dequantize coefficients into Neon registers
+     * with the following allocation:
+     *       0 1 2 3 | 4 5 6 7
+     *      ---------+--------
+     *   0 | d16     | d17     ( q8  )
+     *   1 | d18     | d19     ( q9  )
+     *   2 | d20     | d21     ( q10 )
+     *   3 | d22     | d23     ( q11 )
+     *   4 | d24     | d25     ( q12 )
+     *   5 | d26     | d27     ( q13 )
+     *   6 | d28     | d29     ( q14 )
+     *   7 | d30     | d31     ( q15 )
+     */
+    adr             ip, jsimd_idct_ifast_neon_consts
+    vld1.16         {d16, d17, d18, d19}, [COEF_BLOCK, :128]!
+    vld1.16         {d0, d1, d2, d3}, [DCT_TABLE, :128]!
+    vld1.16         {d20, d21, d22, d23}, [COEF_BLOCK, :128]!
+    vmul.s16        q8, q8, q0
+    vld1.16         {d4, d5, d6, d7}, [DCT_TABLE, :128]!
+    vmul.s16        q9, q9, q1
+    vld1.16         {d24, d25, d26, d27}, [COEF_BLOCK, :128]!
+    vmul.s16        q10, q10, q2
+    vld1.16         {d0, d1, d2, d3}, [DCT_TABLE, :128]!
+    vmul.s16        q11, q11, q3
+    vld1.16         {d28, d29, d30, d31}, [COEF_BLOCK, :128]
+    vmul.s16        q12, q12, q0
+    vld1.16         {d4, d5, d6, d7}, [DCT_TABLE, :128]!
+    vmul.s16        q14, q14, q2
+    vmul.s16        q13, q13, q1
+    vld1.16         {d0}, [ip, :64]  /* load constants */
+    vmul.s16        q15, q15, q3
+    vpush           {d8 - d13}       /* save Neon registers */
+    /* 1-D IDCT, pass 1 */
+    vsub.s16        q2, q10, q14
+    vadd.s16        q14, q10, q14
+    vsub.s16        q1, q11, q13
+    vadd.s16        q13, q11, q13
+    vsub.s16        q5, q9, q15
+    vadd.s16        q15, q9, q15
+    vqdmulh.s16     q4, q2, XFIX_1_414213562
+    vqdmulh.s16     q6, q1, XFIX_2_613125930
+    vadd.s16        q3, q1, q1
+    vsub.s16        q1, q5, q1
+    vadd.s16        q10, q2, q4
+    vqdmulh.s16     q4, q1, XFIX_1_847759065
+    vsub.s16        q2, q15, q13
+    vadd.s16        q3, q3, q6
+    vqdmulh.s16     q6, q2, XFIX_1_414213562
+    vadd.s16        q1, q1, q4
+    vqdmulh.s16     q4, q5, XFIX_1_082392200
+    vsub.s16        q10, q10, q14
+    vadd.s16        q2, q2, q6
+    vsub.s16        q6, q8, q12
+    vadd.s16        q12, q8, q12
+    vadd.s16        q9, q5, q4
+    vadd.s16        q5, q6, q10
+    vsub.s16        q10, q6, q10
+    vadd.s16        q6, q15, q13
+    vadd.s16        q8, q12, q14
+    vsub.s16        q3, q6, q3
+    vsub.s16        q12, q12, q14
+    vsub.s16        q3, q3, q1
+    vsub.s16        q1, q9, q1
+    vadd.s16        q2, q3, q2
+    vsub.s16        q15, q8, q6
+    vadd.s16        q1, q1, q2
+    vadd.s16        q8, q8, q6
+    vadd.s16        q14, q5, q3
+    vsub.s16        q9, q5, q3
+    vsub.s16        q13, q10, q2
+    vadd.s16        q10, q10, q2
+      /* Transpose */
+      vtrn.16         q8, q9
+    vsub.s16        q11, q12, q1
+      vtrn.16         q14, q15
+    vadd.s16        q12, q12, q1
+      vtrn.16         q10, q11
+      vtrn.16         q12, q13
+      vtrn.32         q9, q11
+      vtrn.32         q12, q14
+      vtrn.32         q8, q10
+      vtrn.32         q13, q15
+      vswp            d28, d21
+      vswp            d26, d19
+    /* 1-D IDCT, pass 2 */
+    vsub.s16        q2, q10, q14
+      vswp            d30, d23
+    vadd.s16        q14, q10, q14
+      vswp            d24, d17
+    vsub.s16        q1, q11, q13
+    vadd.s16        q13, q11, q13
+    vsub.s16        q5, q9, q15
+    vadd.s16        q15, q9, q15
+    vqdmulh.s16     q4, q2, XFIX_1_414213562
+    vqdmulh.s16     q6, q1, XFIX_2_613125930
+    vadd.s16        q3, q1, q1
+    vsub.s16        q1, q5, q1
+    vadd.s16        q10, q2, q4
+    vqdmulh.s16     q4, q1, XFIX_1_847759065
+    vsub.s16        q2, q15, q13
+    vadd.s16        q3, q3, q6
+    vqdmulh.s16     q6, q2, XFIX_1_414213562
+    vadd.s16        q1, q1, q4
+    vqdmulh.s16     q4, q5, XFIX_1_082392200
+    vsub.s16        q10, q10, q14
+    vadd.s16        q2, q2, q6
+    vsub.s16        q6, q8, q12
+    vadd.s16        q12, q8, q12
+    vadd.s16        q9, q5, q4
+    vadd.s16        q5, q6, q10
+    vsub.s16        q10, q6, q10
+    vadd.s16        q6, q15, q13
+    vadd.s16        q8, q12, q14
+    vsub.s16        q3, q6, q3
+    vsub.s16        q12, q12, q14
+    vsub.s16        q3, q3, q1
+    vsub.s16        q1, q9, q1
+    vadd.s16        q2, q3, q2
+    vsub.s16        q15, q8, q6
+    vadd.s16        q1, q1, q2
+    vadd.s16        q8, q8, q6
+    vadd.s16        q14, q5, q3
+    vsub.s16        q9, q5, q3
+    vsub.s16        q13, q10, q2
+    vpop            {d8 - d13}    /* restore Neon registers */
+    vadd.s16        q10, q10, q2
+    vsub.s16        q11, q12, q1
+    vadd.s16        q12, q12, q1
+    /* Descale to 8-bit and range limit */
+    vmov.u8         q0, #0x80
+    vqshrn.s16      d16, q8, #5
+    vqshrn.s16      d17, q9, #5
+    vqshrn.s16      d18, q10, #5
+    vqshrn.s16      d19, q11, #5
+    vqshrn.s16      d20, q12, #5
+    vqshrn.s16      d21, q13, #5
+    vqshrn.s16      d22, q14, #5
+    vqshrn.s16      d23, q15, #5
+    vadd.u8         q8, q8, q0
+    vadd.u8         q9, q9, q0
+    vadd.u8         q10, q10, q0
+    vadd.u8         q11, q11, q0
+    /* Transpose the final 8-bit samples */
+    vtrn.16         q8, q9
+    vtrn.16         q10, q11
+    vtrn.32         q8, q10
+    vtrn.32         q9, q11
+    vtrn.8          d16, d17
+    vtrn.8          d18, d19
+      /* Store results to the output buffer */
+      ldmia           OUTPUT_BUF!, {TMP1, TMP2}
+      add             TMP1, TMP1, OUTPUT_COL
+      add             TMP2, TMP2, OUTPUT_COL
+      vst1.8          {d16}, [TMP1]
+      vst1.8          {d17}, [TMP2]
+      ldmia           OUTPUT_BUF!, {TMP1, TMP2}
+      add             TMP1, TMP1, OUTPUT_COL
+      add             TMP2, TMP2, OUTPUT_COL
+      vst1.8          {d18}, [TMP1]
+    vtrn.8          d20, d21
+      vst1.8          {d19}, [TMP2]
+      ldmia           OUTPUT_BUF, {TMP1, TMP2, TMP3, TMP4}
+      add             TMP1, TMP1, OUTPUT_COL
+      add             TMP2, TMP2, OUTPUT_COL
+      add             TMP3, TMP3, OUTPUT_COL
+      add             TMP4, TMP4, OUTPUT_COL
+      vst1.8          {d20}, [TMP1]
+    vtrn.8          d22, d23
+      vst1.8          {d21}, [TMP2]
+      vst1.8          {d22}, [TMP3]
+      vst1.8          {d23}, [TMP4]
+    bx              lr
+
+    .unreq          DCT_TABLE
+    .unreq          COEF_BLOCK
+    .unreq          OUTPUT_BUF
+    .unreq          OUTPUT_COL
+    .unreq          TMP1
+    .unreq          TMP2
+    .unreq          TMP3
+    .unreq          TMP4
+
+
+/*****************************************************************************/
+
+/*
+ * jsimd_extrgb_ycc_convert_neon
+ * jsimd_extbgr_ycc_convert_neon
+ * jsimd_extrgbx_ycc_convert_neon
+ * jsimd_extbgrx_ycc_convert_neon
+ * jsimd_extxbgr_ycc_convert_neon
+ * jsimd_extxrgb_ycc_convert_neon
+ *
+ * Colorspace conversion RGB -> YCbCr
+ */
+
+.macro do_store size
+  .if \size == 8
+    vst1.8          {d20}, [Y]!
+    vst1.8          {d21}, [U]!
+    vst1.8          {d22}, [V]!
+  .elseif \size == 4
+    vst1.8          {d20[0]}, [Y]!
+    vst1.8          {d20[1]}, [Y]!
+    vst1.8          {d20[2]}, [Y]!
+    vst1.8          {d20[3]}, [Y]!
+    vst1.8          {d21[0]}, [U]!
+    vst1.8          {d21[1]}, [U]!
+    vst1.8          {d21[2]}, [U]!
+    vst1.8          {d21[3]}, [U]!
+    vst1.8          {d22[0]}, [V]!
+    vst1.8          {d22[1]}, [V]!
+    vst1.8          {d22[2]}, [V]!
+    vst1.8          {d22[3]}, [V]!
+  .elseif \size == 2
+    vst1.8          {d20[4]}, [Y]!
+    vst1.8          {d20[5]}, [Y]!
+    vst1.8          {d21[4]}, [U]!
+    vst1.8          {d21[5]}, [U]!
+    vst1.8          {d22[4]}, [V]!
+    vst1.8          {d22[5]}, [V]!
+  .elseif \size == 1
+    vst1.8          {d20[6]}, [Y]!
+    vst1.8          {d21[6]}, [U]!
+    vst1.8          {d22[6]}, [V]!
+  .else
+    .error unsupported macroblock size
+  .endif
+.endm
+
+.macro do_load bpp, size
+  .if \bpp == 24
+    .if \size == 8
+      vld3.8        {d10, d11, d12}, [RGB]!
+      pld           [RGB, #128]
+    .elseif \size == 4
+      vld3.8        {d10[0], d11[0], d12[0]}, [RGB]!
+      vld3.8        {d10[1], d11[1], d12[1]}, [RGB]!
+      vld3.8        {d10[2], d11[2], d12[2]}, [RGB]!
+      vld3.8        {d10[3], d11[3], d12[3]}, [RGB]!
+    .elseif \size == 2
+      vld3.8        {d10[4], d11[4], d12[4]}, [RGB]!
+      vld3.8        {d10[5], d11[5], d12[5]}, [RGB]!
+    .elseif \size == 1
+      vld3.8        {d10[6], d11[6], d12[6]}, [RGB]!
+    .else
+      .error unsupported macroblock size
+    .endif
+  .elseif \bpp == 32
+    .if \size == 8
+      vld4.8        {d10, d11, d12, d13}, [RGB]!
+      pld           [RGB, #128]
+    .elseif \size == 4
+      vld4.8        {d10[0], d11[0], d12[0], d13[0]}, [RGB]!
+      vld4.8        {d10[1], d11[1], d12[1], d13[1]}, [RGB]!
+      vld4.8        {d10[2], d11[2], d12[2], d13[2]}, [RGB]!
+      vld4.8        {d10[3], d11[3], d12[3], d13[3]}, [RGB]!
+    .elseif \size == 2
+      vld4.8        {d10[4], d11[4], d12[4], d13[4]}, [RGB]!
+      vld4.8        {d10[5], d11[5], d12[5], d13[5]}, [RGB]!
+    .elseif \size == 1
+      vld4.8        {d10[6], d11[6], d12[6], d13[6]}, [RGB]!
+    .else
+      .error unsupported macroblock size
+    .endif
+  .else
+    .error unsupported bpp
+  .endif
+.endm
+
+.macro generate_jsimd_rgb_ycc_convert_neon colorid, bpp, r_offs, g_offs, b_offs
+
+/*
+ * 2-stage pipelined RGB->YCbCr conversion
+ */
+
+.macro do_rgb_to_yuv_stage1
+    vmovl.u8        q2, d1\r_offs  /* r = { d4, d5 } */
+    vmovl.u8        q3, d1\g_offs  /* g = { d6, d7 } */
+    vmovl.u8        q4, d1\b_offs  /* b = { d8, d9 } */
+    vmull.u16       q7, d4, d0[0]
+    vmlal.u16       q7, d6, d0[1]
+    vmlal.u16       q7, d8, d0[2]
+    vmull.u16       q8, d5, d0[0]
+    vmlal.u16       q8, d7, d0[1]
+    vmlal.u16       q8, d9, d0[2]
+    vrev64.32       q9, q1
+    vrev64.32       q13, q1
+    vmlsl.u16       q9, d4, d0[3]
+    vmlsl.u16       q9, d6, d1[0]
+    vmlal.u16       q9, d8, d1[1]
+    vmlsl.u16       q13, d5, d0[3]
+    vmlsl.u16       q13, d7, d1[0]
+    vmlal.u16       q13, d9, d1[1]
+    vrev64.32       q14, q1
+    vrev64.32       q15, q1
+    vmlal.u16       q14, d4, d1[1]
+    vmlsl.u16       q14, d6, d1[2]
+    vmlsl.u16       q14, d8, d1[3]
+    vmlal.u16       q15, d5, d1[1]
+    vmlsl.u16       q15, d7, d1[2]
+    vmlsl.u16       q15, d9, d1[3]
+.endm
+
+.macro do_rgb_to_yuv_stage2
+    vrshrn.u32      d20, q7, #16
+    vrshrn.u32      d21, q8, #16
+    vshrn.u32       d22, q9, #16
+    vshrn.u32       d23, q13, #16
+    vshrn.u32       d24, q14, #16
+    vshrn.u32       d25, q15, #16
+    vmovn.u16       d20, q10       /* d20 = y */
+    vmovn.u16       d21, q11       /* d21 = u */
+    vmovn.u16       d22, q12       /* d22 = v */
+.endm
+
+.macro do_rgb_to_yuv
+    do_rgb_to_yuv_stage1
+    do_rgb_to_yuv_stage2
+.endm
+
+.macro do_rgb_to_yuv_stage2_store_load_stage1
+      vrshrn.u32      d20, q7, #16
+      vrshrn.u32      d21, q8, #16
+      vshrn.u32       d22, q9, #16
+    vrev64.32       q9, q1
+      vshrn.u32       d23, q13, #16
+    vrev64.32       q13, q1
+      vshrn.u32       d24, q14, #16
+      vshrn.u32       d25, q15, #16
+    do_load         \bpp, 8
+      vmovn.u16       d20, q10     /* d20 = y */
+    vmovl.u8        q2, d1\r_offs  /* r = { d4, d5 } */
+      vmovn.u16       d21, q11     /* d21 = u */
+    vmovl.u8        q3, d1\g_offs  /* g = { d6, d7 } */
+      vmovn.u16       d22, q12     /* d22 = v */
+    vmovl.u8        q4, d1\b_offs  /* b = { d8, d9 } */
+    vmull.u16       q7, d4, d0[0]
+    vmlal.u16       q7, d6, d0[1]
+    vmlal.u16       q7, d8, d0[2]
+      vst1.8          {d20}, [Y]!
+    vmull.u16       q8, d5, d0[0]
+    vmlal.u16       q8, d7, d0[1]
+    vmlal.u16       q8, d9, d0[2]
+    vmlsl.u16       q9, d4, d0[3]
+    vmlsl.u16       q9, d6, d1[0]
+    vmlal.u16       q9, d8, d1[1]
+      vst1.8          {d21}, [U]!
+    vmlsl.u16       q13, d5, d0[3]
+    vmlsl.u16       q13, d7, d1[0]
+    vmlal.u16       q13, d9, d1[1]
+    vrev64.32       q14, q1
+    vrev64.32       q15, q1
+    vmlal.u16       q14, d4, d1[1]
+    vmlsl.u16       q14, d6, d1[2]
+    vmlsl.u16       q14, d8, d1[3]
+      vst1.8          {d22}, [V]!
+    vmlal.u16       q15, d5, d1[1]
+    vmlsl.u16       q15, d7, d1[2]
+    vmlsl.u16       q15, d9, d1[3]
+.endm
+
+.balign 16
+jsimd_\colorid\()_ycc_neon_consts:
+  .short 19595, 38470, 7471,  11059
+  .short 21709, 32768, 27439, 5329
+  .short 32767, 128,   32767, 128
+  .short 32767, 128,   32767, 128
+
+asm_function jsimd_\colorid\()_ycc_convert_neon
+    OUTPUT_WIDTH    .req r0
+    INPUT_BUF       .req r1
+    OUTPUT_BUF      .req r2
+    OUTPUT_ROW      .req r3
+    NUM_ROWS        .req r4
+
+    OUTPUT_BUF0     .req r5
+    OUTPUT_BUF1     .req r6
+    OUTPUT_BUF2     .req OUTPUT_BUF
+
+    RGB             .req r7
+    Y               .req r8
+    U               .req r9
+    V               .req r10
+    N               .req ip
+
+    /* Load constants to d0, d1, d2, d3 */
+    adr             ip, jsimd_\colorid\()_ycc_neon_consts
+    vld1.16         {d0, d1, d2, d3}, [ip, :128]
+
+    /* Save Arm registers and handle input arguments */
+    push            {r4, r5, r6, r7, r8, r9, r10, lr}
+    ldr             NUM_ROWS, [sp, #(4 * 8)]
+    ldr             OUTPUT_BUF0, [OUTPUT_BUF]
+    ldr             OUTPUT_BUF1, [OUTPUT_BUF, #4]
+    ldr             OUTPUT_BUF2, [OUTPUT_BUF, #8]
+    .unreq          OUTPUT_BUF
+
+    /* Save Neon registers */
+    vpush           {d8 - d15}
+
+    /* Outer loop over scanlines */
+    cmp             NUM_ROWS, #1
+    blt             9f
+0:
+    ldr             Y, [OUTPUT_BUF0, OUTPUT_ROW, lsl #2]
+    ldr             U, [OUTPUT_BUF1, OUTPUT_ROW, lsl #2]
+    mov             N, OUTPUT_WIDTH
+    ldr             V, [OUTPUT_BUF2, OUTPUT_ROW, lsl #2]
+    add             OUTPUT_ROW, OUTPUT_ROW, #1
+    ldr             RGB, [INPUT_BUF], #4
+
+    /* Inner loop over pixels */
+    subs            N, N, #8
+    blt             3f
+    do_load         \bpp, 8
+    do_rgb_to_yuv_stage1
+    subs            N, N, #8
+    blt             2f
+1:
+    do_rgb_to_yuv_stage2_store_load_stage1
+    subs            N, N, #8
+    bge             1b
+2:
+    do_rgb_to_yuv_stage2
+    do_store        8
+    tst             N, #7
+    beq             8f
+3:
+    tst             N, #4
+    beq             3f
+    do_load         \bpp, 4
+3:
+    tst             N, #2
+    beq             4f
+    do_load         \bpp, 2
+4:
+    tst             N, #1
+    beq             5f
+    do_load         \bpp, 1
+5:
+    do_rgb_to_yuv
+    tst             N, #4
+    beq             6f
+    do_store        4
+6:
+    tst             N, #2
+    beq             7f
+    do_store        2
+7:
+    tst             N, #1
+    beq             8f
+    do_store        1
+8:
+    subs            NUM_ROWS, NUM_ROWS, #1
+    bgt             0b
+9:
+    /* Restore all registers and return */
+    vpop            {d8 - d15}
+    pop             {r4, r5, r6, r7, r8, r9, r10, pc}
+
+    .unreq          OUTPUT_WIDTH
+    .unreq          OUTPUT_ROW
+    .unreq          INPUT_BUF
+    .unreq          NUM_ROWS
+    .unreq          OUTPUT_BUF0
+    .unreq          OUTPUT_BUF1
+    .unreq          OUTPUT_BUF2
+    .unreq          RGB
+    .unreq          Y
+    .unreq          U
+    .unreq          V
+    .unreq          N
+
+.purgem do_rgb_to_yuv
+.purgem do_rgb_to_yuv_stage1
+.purgem do_rgb_to_yuv_stage2
+.purgem do_rgb_to_yuv_stage2_store_load_stage1
+
+.endm
+
+/*--------------------------------- id ----- bpp R  G  B */
+generate_jsimd_rgb_ycc_convert_neon extrgb,  24, 0, 1, 2
+generate_jsimd_rgb_ycc_convert_neon extbgr,  24, 2, 1, 0
+generate_jsimd_rgb_ycc_convert_neon extrgbx, 32, 0, 1, 2
+generate_jsimd_rgb_ycc_convert_neon extbgrx, 32, 2, 1, 0
+generate_jsimd_rgb_ycc_convert_neon extxbgr, 32, 3, 2, 1
+generate_jsimd_rgb_ycc_convert_neon extxrgb, 32, 1, 2, 3
+
+.purgem do_load
+.purgem do_store
diff --git a/3rdparty/libjpeg/src/simd/arm/aarch64/jccolext-neon.c b/3rdparty/libjpeg/src/simd/arm/aarch64/jccolext-neon.c
new file mode 100644
index 00000000..37130c22
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/arm/aarch64/jccolext-neon.c
@@ -0,0 +1,316 @@
+/*
+ * jccolext-neon.c - colorspace conversion (64-bit Arm Neon)
+ *
+ * Copyright (C) 2020, Arm Limited.  All Rights Reserved.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+/* This file is included by jccolor-neon.c */
+
+
+/* RGB -> YCbCr conversion is defined by the following equations:
+ *    Y  =  0.29900 * R + 0.58700 * G + 0.11400 * B
+ *    Cb = -0.16874 * R - 0.33126 * G + 0.50000 * B  + 128
+ *    Cr =  0.50000 * R - 0.41869 * G - 0.08131 * B  + 128
+ *
+ * Avoid floating point arithmetic by using shifted integer constants:
+ *    0.29899597 = 19595 * 2^-16
+ *    0.58700561 = 38470 * 2^-16
+ *    0.11399841 =  7471 * 2^-16
+ *    0.16874695 = 11059 * 2^-16
+ *    0.33125305 = 21709 * 2^-16
+ *    0.50000000 = 32768 * 2^-16
+ *    0.41868592 = 27439 * 2^-16
+ *    0.08131409 =  5329 * 2^-16
+ * These constants are defined in jccolor-neon.c
+ *
+ * We add the fixed-point equivalent of 0.5 to Cb and Cr, which effectively
+ * rounds up or down the result via integer truncation.
+ */
+
+void jsimd_rgb_ycc_convert_neon(JDIMENSION image_width, JSAMPARRAY input_buf,
+                                JSAMPIMAGE output_buf, JDIMENSION output_row,
+                                int num_rows)
+{
+  /* Pointer to RGB(X/A) input data */
+  JSAMPROW inptr;
+  /* Pointers to Y, Cb, and Cr output data */
+  JSAMPROW outptr0, outptr1, outptr2;
+  /* Allocate temporary buffer for final (image_width % 16) pixels in row. */
+  ALIGN(16) uint8_t tmp_buf[16 * RGB_PIXELSIZE];
+
+  /* Set up conversion constants. */
+  const uint16x8_t consts = vld1q_u16(jsimd_rgb_ycc_neon_consts);
+  const uint32x4_t scaled_128_5 = vdupq_n_u32((128 << 16) + 32767);
+
+  while (--num_rows >= 0) {
+    inptr = *input_buf++;
+    outptr0 = output_buf[0][output_row];
+    outptr1 = output_buf[1][output_row];
+    outptr2 = output_buf[2][output_row];
+    output_row++;
+
+    int cols_remaining = image_width;
+    for (; cols_remaining >= 16; cols_remaining -= 16) {
+
+#if RGB_PIXELSIZE == 4
+      uint8x16x4_t input_pixels = vld4q_u8(inptr);
+#else
+      uint8x16x3_t input_pixels = vld3q_u8(inptr);
+#endif
+      uint16x8_t r_l = vmovl_u8(vget_low_u8(input_pixels.val[RGB_RED]));
+      uint16x8_t g_l = vmovl_u8(vget_low_u8(input_pixels.val[RGB_GREEN]));
+      uint16x8_t b_l = vmovl_u8(vget_low_u8(input_pixels.val[RGB_BLUE]));
+      uint16x8_t r_h = vmovl_u8(vget_high_u8(input_pixels.val[RGB_RED]));
+      uint16x8_t g_h = vmovl_u8(vget_high_u8(input_pixels.val[RGB_GREEN]));
+      uint16x8_t b_h = vmovl_u8(vget_high_u8(input_pixels.val[RGB_BLUE]));
+
+      /* Compute Y = 0.29900 * R + 0.58700 * G + 0.11400 * B */
+      uint32x4_t y_ll = vmull_laneq_u16(vget_low_u16(r_l), consts, 0);
+      y_ll = vmlal_laneq_u16(y_ll, vget_low_u16(g_l), consts, 1);
+      y_ll = vmlal_laneq_u16(y_ll, vget_low_u16(b_l), consts, 2);
+      uint32x4_t y_lh = vmull_laneq_u16(vget_high_u16(r_l), consts, 0);
+      y_lh = vmlal_laneq_u16(y_lh, vget_high_u16(g_l), consts, 1);
+      y_lh = vmlal_laneq_u16(y_lh, vget_high_u16(b_l), consts, 2);
+      uint32x4_t y_hl = vmull_laneq_u16(vget_low_u16(r_h), consts, 0);
+      y_hl = vmlal_laneq_u16(y_hl, vget_low_u16(g_h), consts, 1);
+      y_hl = vmlal_laneq_u16(y_hl, vget_low_u16(b_h), consts, 2);
+      uint32x4_t y_hh = vmull_laneq_u16(vget_high_u16(r_h), consts, 0);
+      y_hh = vmlal_laneq_u16(y_hh, vget_high_u16(g_h), consts, 1);
+      y_hh = vmlal_laneq_u16(y_hh, vget_high_u16(b_h), consts, 2);
+
+      /* Compute Cb = -0.16874 * R - 0.33126 * G + 0.50000 * B  + 128 */
+      uint32x4_t cb_ll = scaled_128_5;
+      cb_ll = vmlsl_laneq_u16(cb_ll, vget_low_u16(r_l), consts, 3);
+      cb_ll = vmlsl_laneq_u16(cb_ll, vget_low_u16(g_l), consts, 4);
+      cb_ll = vmlal_laneq_u16(cb_ll, vget_low_u16(b_l), consts, 5);
+      uint32x4_t cb_lh = scaled_128_5;
+      cb_lh = vmlsl_laneq_u16(cb_lh, vget_high_u16(r_l), consts, 3);
+      cb_lh = vmlsl_laneq_u16(cb_lh, vget_high_u16(g_l), consts, 4);
+      cb_lh = vmlal_laneq_u16(cb_lh, vget_high_u16(b_l), consts, 5);
+      uint32x4_t cb_hl = scaled_128_5;
+      cb_hl = vmlsl_laneq_u16(cb_hl, vget_low_u16(r_h), consts, 3);
+      cb_hl = vmlsl_laneq_u16(cb_hl, vget_low_u16(g_h), consts, 4);
+      cb_hl = vmlal_laneq_u16(cb_hl, vget_low_u16(b_h), consts, 5);
+      uint32x4_t cb_hh = scaled_128_5;
+      cb_hh = vmlsl_laneq_u16(cb_hh, vget_high_u16(r_h), consts, 3);
+      cb_hh = vmlsl_laneq_u16(cb_hh, vget_high_u16(g_h), consts, 4);
+      cb_hh = vmlal_laneq_u16(cb_hh, vget_high_u16(b_h), consts, 5);
+
+      /* Compute Cr = 0.50000 * R - 0.41869 * G - 0.08131 * B  + 128 */
+      uint32x4_t cr_ll = scaled_128_5;
+      cr_ll = vmlal_laneq_u16(cr_ll, vget_low_u16(r_l), consts, 5);
+      cr_ll = vmlsl_laneq_u16(cr_ll, vget_low_u16(g_l), consts, 6);
+      cr_ll = vmlsl_laneq_u16(cr_ll, vget_low_u16(b_l), consts, 7);
+      uint32x4_t cr_lh = scaled_128_5;
+      cr_lh = vmlal_laneq_u16(cr_lh, vget_high_u16(r_l), consts, 5);
+      cr_lh = vmlsl_laneq_u16(cr_lh, vget_high_u16(g_l), consts, 6);
+      cr_lh = vmlsl_laneq_u16(cr_lh, vget_high_u16(b_l), consts, 7);
+      uint32x4_t cr_hl = scaled_128_5;
+      cr_hl = vmlal_laneq_u16(cr_hl, vget_low_u16(r_h), consts, 5);
+      cr_hl = vmlsl_laneq_u16(cr_hl, vget_low_u16(g_h), consts, 6);
+      cr_hl = vmlsl_laneq_u16(cr_hl, vget_low_u16(b_h), consts, 7);
+      uint32x4_t cr_hh = scaled_128_5;
+      cr_hh = vmlal_laneq_u16(cr_hh, vget_high_u16(r_h), consts, 5);
+      cr_hh = vmlsl_laneq_u16(cr_hh, vget_high_u16(g_h), consts, 6);
+      cr_hh = vmlsl_laneq_u16(cr_hh, vget_high_u16(b_h), consts, 7);
+
+      /* Descale Y values (rounding right shift) and narrow to 16-bit. */
+      uint16x8_t y_l = vcombine_u16(vrshrn_n_u32(y_ll, 16),
+                                    vrshrn_n_u32(y_lh, 16));
+      uint16x8_t y_h = vcombine_u16(vrshrn_n_u32(y_hl, 16),
+                                    vrshrn_n_u32(y_hh, 16));
+      /* Descale Cb values (right shift) and narrow to 16-bit. */
+      uint16x8_t cb_l = vcombine_u16(vshrn_n_u32(cb_ll, 16),
+                                     vshrn_n_u32(cb_lh, 16));
+      uint16x8_t cb_h = vcombine_u16(vshrn_n_u32(cb_hl, 16),
+                                     vshrn_n_u32(cb_hh, 16));
+      /* Descale Cr values (right shift) and narrow to 16-bit. */
+      uint16x8_t cr_l = vcombine_u16(vshrn_n_u32(cr_ll, 16),
+                                     vshrn_n_u32(cr_lh, 16));
+      uint16x8_t cr_h = vcombine_u16(vshrn_n_u32(cr_hl, 16),
+                                     vshrn_n_u32(cr_hh, 16));
+      /* Narrow Y, Cb, and Cr values to 8-bit and store to memory.  Buffer
+       * overwrite is permitted up to the next multiple of ALIGN_SIZE bytes.
+       */
+      vst1q_u8(outptr0, vcombine_u8(vmovn_u16(y_l), vmovn_u16(y_h)));
+      vst1q_u8(outptr1, vcombine_u8(vmovn_u16(cb_l), vmovn_u16(cb_h)));
+      vst1q_u8(outptr2, vcombine_u8(vmovn_u16(cr_l), vmovn_u16(cr_h)));
+
+      /* Increment pointers. */
+      inptr += (16 * RGB_PIXELSIZE);
+      outptr0 += 16;
+      outptr1 += 16;
+      outptr2 += 16;
+    }
+
+    if (cols_remaining > 8) {
+      /* To prevent buffer overread by the vector load instructions, the last
+       * (image_width % 16) columns of data are first memcopied to a temporary
+       * buffer large enough to accommodate the vector load.
+       */
+      memcpy(tmp_buf, inptr, cols_remaining * RGB_PIXELSIZE);
+      inptr = tmp_buf;
+
+#if RGB_PIXELSIZE == 4
+      uint8x16x4_t input_pixels = vld4q_u8(inptr);
+#else
+      uint8x16x3_t input_pixels = vld3q_u8(inptr);
+#endif
+      uint16x8_t r_l = vmovl_u8(vget_low_u8(input_pixels.val[RGB_RED]));
+      uint16x8_t g_l = vmovl_u8(vget_low_u8(input_pixels.val[RGB_GREEN]));
+      uint16x8_t b_l = vmovl_u8(vget_low_u8(input_pixels.val[RGB_BLUE]));
+      uint16x8_t r_h = vmovl_u8(vget_high_u8(input_pixels.val[RGB_RED]));
+      uint16x8_t g_h = vmovl_u8(vget_high_u8(input_pixels.val[RGB_GREEN]));
+      uint16x8_t b_h = vmovl_u8(vget_high_u8(input_pixels.val[RGB_BLUE]));
+
+      /* Compute Y = 0.29900 * R + 0.58700 * G + 0.11400 * B */
+      uint32x4_t y_ll = vmull_laneq_u16(vget_low_u16(r_l), consts, 0);
+      y_ll = vmlal_laneq_u16(y_ll, vget_low_u16(g_l), consts, 1);
+      y_ll = vmlal_laneq_u16(y_ll, vget_low_u16(b_l), consts, 2);
+      uint32x4_t y_lh = vmull_laneq_u16(vget_high_u16(r_l), consts, 0);
+      y_lh = vmlal_laneq_u16(y_lh, vget_high_u16(g_l), consts, 1);
+      y_lh = vmlal_laneq_u16(y_lh, vget_high_u16(b_l), consts, 2);
+      uint32x4_t y_hl = vmull_laneq_u16(vget_low_u16(r_h), consts, 0);
+      y_hl = vmlal_laneq_u16(y_hl, vget_low_u16(g_h), consts, 1);
+      y_hl = vmlal_laneq_u16(y_hl, vget_low_u16(b_h), consts, 2);
+      uint32x4_t y_hh = vmull_laneq_u16(vget_high_u16(r_h), consts, 0);
+      y_hh = vmlal_laneq_u16(y_hh, vget_high_u16(g_h), consts, 1);
+      y_hh = vmlal_laneq_u16(y_hh, vget_high_u16(b_h), consts, 2);
+
+      /* Compute Cb = -0.16874 * R - 0.33126 * G + 0.50000 * B  + 128 */
+      uint32x4_t cb_ll = scaled_128_5;
+      cb_ll = vmlsl_laneq_u16(cb_ll, vget_low_u16(r_l), consts, 3);
+      cb_ll = vmlsl_laneq_u16(cb_ll, vget_low_u16(g_l), consts, 4);
+      cb_ll = vmlal_laneq_u16(cb_ll, vget_low_u16(b_l), consts, 5);
+      uint32x4_t cb_lh = scaled_128_5;
+      cb_lh = vmlsl_laneq_u16(cb_lh, vget_high_u16(r_l), consts, 3);
+      cb_lh = vmlsl_laneq_u16(cb_lh, vget_high_u16(g_l), consts, 4);
+      cb_lh = vmlal_laneq_u16(cb_lh, vget_high_u16(b_l), consts, 5);
+      uint32x4_t cb_hl = scaled_128_5;
+      cb_hl = vmlsl_laneq_u16(cb_hl, vget_low_u16(r_h), consts, 3);
+      cb_hl = vmlsl_laneq_u16(cb_hl, vget_low_u16(g_h), consts, 4);
+      cb_hl = vmlal_laneq_u16(cb_hl, vget_low_u16(b_h), consts, 5);
+      uint32x4_t cb_hh = scaled_128_5;
+      cb_hh = vmlsl_laneq_u16(cb_hh, vget_high_u16(r_h), consts, 3);
+      cb_hh = vmlsl_laneq_u16(cb_hh, vget_high_u16(g_h), consts, 4);
+      cb_hh = vmlal_laneq_u16(cb_hh, vget_high_u16(b_h), consts, 5);
+
+      /* Compute Cr = 0.50000 * R - 0.41869 * G - 0.08131 * B  + 128 */
+      uint32x4_t cr_ll = scaled_128_5;
+      cr_ll = vmlal_laneq_u16(cr_ll, vget_low_u16(r_l), consts, 5);
+      cr_ll = vmlsl_laneq_u16(cr_ll, vget_low_u16(g_l), consts, 6);
+      cr_ll = vmlsl_laneq_u16(cr_ll, vget_low_u16(b_l), consts, 7);
+      uint32x4_t cr_lh = scaled_128_5;
+      cr_lh = vmlal_laneq_u16(cr_lh, vget_high_u16(r_l), consts, 5);
+      cr_lh = vmlsl_laneq_u16(cr_lh, vget_high_u16(g_l), consts, 6);
+      cr_lh = vmlsl_laneq_u16(cr_lh, vget_high_u16(b_l), consts, 7);
+      uint32x4_t cr_hl = scaled_128_5;
+      cr_hl = vmlal_laneq_u16(cr_hl, vget_low_u16(r_h), consts, 5);
+      cr_hl = vmlsl_laneq_u16(cr_hl, vget_low_u16(g_h), consts, 6);
+      cr_hl = vmlsl_laneq_u16(cr_hl, vget_low_u16(b_h), consts, 7);
+      uint32x4_t cr_hh = scaled_128_5;
+      cr_hh = vmlal_laneq_u16(cr_hh, vget_high_u16(r_h), consts, 5);
+      cr_hh = vmlsl_laneq_u16(cr_hh, vget_high_u16(g_h), consts, 6);
+      cr_hh = vmlsl_laneq_u16(cr_hh, vget_high_u16(b_h), consts, 7);
+
+      /* Descale Y values (rounding right shift) and narrow to 16-bit. */
+      uint16x8_t y_l = vcombine_u16(vrshrn_n_u32(y_ll, 16),
+                                    vrshrn_n_u32(y_lh, 16));
+      uint16x8_t y_h = vcombine_u16(vrshrn_n_u32(y_hl, 16),
+                                    vrshrn_n_u32(y_hh, 16));
+      /* Descale Cb values (right shift) and narrow to 16-bit. */
+      uint16x8_t cb_l = vcombine_u16(vshrn_n_u32(cb_ll, 16),
+                                     vshrn_n_u32(cb_lh, 16));
+      uint16x8_t cb_h = vcombine_u16(vshrn_n_u32(cb_hl, 16),
+                                     vshrn_n_u32(cb_hh, 16));
+      /* Descale Cr values (right shift) and narrow to 16-bit. */
+      uint16x8_t cr_l = vcombine_u16(vshrn_n_u32(cr_ll, 16),
+                                     vshrn_n_u32(cr_lh, 16));
+      uint16x8_t cr_h = vcombine_u16(vshrn_n_u32(cr_hl, 16),
+                                     vshrn_n_u32(cr_hh, 16));
+      /* Narrow Y, Cb, and Cr values to 8-bit and store to memory.  Buffer
+       * overwrite is permitted up to the next multiple of ALIGN_SIZE bytes.
+       */
+      vst1q_u8(outptr0, vcombine_u8(vmovn_u16(y_l), vmovn_u16(y_h)));
+      vst1q_u8(outptr1, vcombine_u8(vmovn_u16(cb_l), vmovn_u16(cb_h)));
+      vst1q_u8(outptr2, vcombine_u8(vmovn_u16(cr_l), vmovn_u16(cr_h)));
+
+    } else if (cols_remaining > 0) {
+      /* To prevent buffer overread by the vector load instructions, the last
+       * (image_width % 8) columns of data are first memcopied to a temporary
+       * buffer large enough to accommodate the vector load.
+       */
+      memcpy(tmp_buf, inptr, cols_remaining * RGB_PIXELSIZE);
+      inptr = tmp_buf;
+
+#if RGB_PIXELSIZE == 4
+      uint8x8x4_t input_pixels = vld4_u8(inptr);
+#else
+      uint8x8x3_t input_pixels = vld3_u8(inptr);
+#endif
+      uint16x8_t r = vmovl_u8(input_pixels.val[RGB_RED]);
+      uint16x8_t g = vmovl_u8(input_pixels.val[RGB_GREEN]);
+      uint16x8_t b = vmovl_u8(input_pixels.val[RGB_BLUE]);
+
+      /* Compute Y = 0.29900 * R + 0.58700 * G + 0.11400 * B */
+      uint32x4_t y_l = vmull_laneq_u16(vget_low_u16(r), consts, 0);
+      y_l = vmlal_laneq_u16(y_l, vget_low_u16(g), consts, 1);
+      y_l = vmlal_laneq_u16(y_l, vget_low_u16(b), consts, 2);
+      uint32x4_t y_h = vmull_laneq_u16(vget_high_u16(r), consts, 0);
+      y_h = vmlal_laneq_u16(y_h, vget_high_u16(g), consts, 1);
+      y_h = vmlal_laneq_u16(y_h, vget_high_u16(b), consts, 2);
+
+      /* Compute Cb = -0.16874 * R - 0.33126 * G + 0.50000 * B  + 128 */
+      uint32x4_t cb_l = scaled_128_5;
+      cb_l = vmlsl_laneq_u16(cb_l, vget_low_u16(r), consts, 3);
+      cb_l = vmlsl_laneq_u16(cb_l, vget_low_u16(g), consts, 4);
+      cb_l = vmlal_laneq_u16(cb_l, vget_low_u16(b), consts, 5);
+      uint32x4_t cb_h = scaled_128_5;
+      cb_h = vmlsl_laneq_u16(cb_h, vget_high_u16(r), consts, 3);
+      cb_h = vmlsl_laneq_u16(cb_h, vget_high_u16(g), consts, 4);
+      cb_h = vmlal_laneq_u16(cb_h, vget_high_u16(b), consts, 5);
+
+      /* Compute Cr = 0.50000 * R - 0.41869 * G - 0.08131 * B  + 128 */
+      uint32x4_t cr_l = scaled_128_5;
+      cr_l = vmlal_laneq_u16(cr_l, vget_low_u16(r), consts, 5);
+      cr_l = vmlsl_laneq_u16(cr_l, vget_low_u16(g), consts, 6);
+      cr_l = vmlsl_laneq_u16(cr_l, vget_low_u16(b), consts, 7);
+      uint32x4_t cr_h = scaled_128_5;
+      cr_h = vmlal_laneq_u16(cr_h, vget_high_u16(r), consts, 5);
+      cr_h = vmlsl_laneq_u16(cr_h, vget_high_u16(g), consts, 6);
+      cr_h = vmlsl_laneq_u16(cr_h, vget_high_u16(b), consts, 7);
+
+      /* Descale Y values (rounding right shift) and narrow to 16-bit. */
+      uint16x8_t y_u16 = vcombine_u16(vrshrn_n_u32(y_l, 16),
+                                      vrshrn_n_u32(y_h, 16));
+      /* Descale Cb values (right shift) and narrow to 16-bit. */
+      uint16x8_t cb_u16 = vcombine_u16(vshrn_n_u32(cb_l, 16),
+                                       vshrn_n_u32(cb_h, 16));
+      /* Descale Cr values (right shift) and narrow to 16-bit. */
+      uint16x8_t cr_u16 = vcombine_u16(vshrn_n_u32(cr_l, 16),
+                                       vshrn_n_u32(cr_h, 16));
+      /* Narrow Y, Cb, and Cr values to 8-bit and store to memory.  Buffer
+       * overwrite is permitted up to the next multiple of ALIGN_SIZE bytes.
+       */
+      vst1_u8(outptr0, vmovn_u16(y_u16));
+      vst1_u8(outptr1, vmovn_u16(cb_u16));
+      vst1_u8(outptr2, vmovn_u16(cr_u16));
+    }
+  }
+}
diff --git a/3rdparty/libjpeg/src/simd/arm/aarch64/jchuff-neon.c b/3rdparty/libjpeg/src/simd/arm/aarch64/jchuff-neon.c
new file mode 100644
index 00000000..a0a57a66
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/arm/aarch64/jchuff-neon.c
@@ -0,0 +1,403 @@
+/*
+ * jchuff-neon.c - Huffman entropy encoding (64-bit Arm Neon)
+ *
+ * Copyright (C) 2020, Arm Limited.  All Rights Reserved.
+ * Copyright (C) 2020, D. R. Commander.  All Rights Reserved.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ *
+ * NOTE: All referenced figures are from
+ * Recommendation ITU-T T.81 (1992) | ISO/IEC 10918-1:1994.
+ */
+
+#define JPEG_INTERNALS
+#include "../../../jinclude.h"
+#include "../../../jpeglib.h"
+#include "../../../jsimd.h"
+#include "../../../jdct.h"
+#include "../../../jsimddct.h"
+#include "../../jsimd.h"
+#include "../align.h"
+#include "../jchuff.h"
+#include "neon-compat.h"
+
+#include <limits.h>
+
+#include <arm_neon.h>
+
+
+ALIGN(16) static const uint8_t jsimd_huff_encode_one_block_consts[] = {
+    0,   1,   2,   3,  16,  17,  32,  33,
+   18,  19,   4,   5,   6,   7,  20,  21,
+   34,  35,  48,  49, 255, 255,  50,  51,
+   36,  37,  22,  23,   8,   9,  10,  11,
+  255, 255,   6,   7,  20,  21,  34,  35,
+   48,  49, 255, 255,  50,  51,  36,  37,
+   54,  55,  40,  41,  26,  27,  12,  13,
+   14,  15,  28,  29,  42,  43,  56,  57,
+    6,   7,  20,  21,  34,  35,  48,  49,
+   50,  51,  36,  37,  22,  23,   8,   9,
+   26,  27,  12,  13, 255, 255,  14,  15,
+   28,  29,  42,  43,  56,  57, 255, 255,
+   52,  53,  54,  55,  40,  41,  26,  27,
+   12,  13, 255, 255,  14,  15,  28,  29,
+   26,  27,  40,  41,  42,  43,  28,  29,
+   14,  15,  30,  31,  44,  45,  46,  47
+};
+
+JOCTET *jsimd_huff_encode_one_block_neon(void *state, JOCTET *buffer,
+                                         JCOEFPTR block, int last_dc_val,
+                                         c_derived_tbl *dctbl,
+                                         c_derived_tbl *actbl)
+{
+  uint16_t block_diff[DCTSIZE2];
+
+  /* Load lookup table indices for rows of zig-zag ordering. */
+#ifdef HAVE_VLD1Q_U8_X4
+  const uint8x16x4_t idx_rows_0123 =
+    vld1q_u8_x4(jsimd_huff_encode_one_block_consts + 0 * DCTSIZE);
+  const uint8x16x4_t idx_rows_4567 =
+    vld1q_u8_x4(jsimd_huff_encode_one_block_consts + 8 * DCTSIZE);
+#else
+  /* GCC does not currently support intrinsics vl1dq_<type>_x4(). */
+  const uint8x16x4_t idx_rows_0123 = { {
+    vld1q_u8(jsimd_huff_encode_one_block_consts + 0 * DCTSIZE),
+    vld1q_u8(jsimd_huff_encode_one_block_consts + 2 * DCTSIZE),
+    vld1q_u8(jsimd_huff_encode_one_block_consts + 4 * DCTSIZE),
+    vld1q_u8(jsimd_huff_encode_one_block_consts + 6 * DCTSIZE)
+  } };
+  const uint8x16x4_t idx_rows_4567 = { {
+    vld1q_u8(jsimd_huff_encode_one_block_consts + 8 * DCTSIZE),
+    vld1q_u8(jsimd_huff_encode_one_block_consts + 10 * DCTSIZE),
+    vld1q_u8(jsimd_huff_encode_one_block_consts + 12 * DCTSIZE),
+    vld1q_u8(jsimd_huff_encode_one_block_consts + 14 * DCTSIZE)
+  } };
+#endif
+
+  /* Load 8x8 block of DCT coefficients. */
+#ifdef HAVE_VLD1Q_U8_X4
+  const int8x16x4_t tbl_rows_0123 =
+    vld1q_s8_x4((int8_t *)(block + 0 * DCTSIZE));
+  const int8x16x4_t tbl_rows_4567 =
+    vld1q_s8_x4((int8_t *)(block + 4 * DCTSIZE));
+#else
+  const int8x16x4_t tbl_rows_0123 = { {
+    vld1q_s8((int8_t *)(block + 0 * DCTSIZE)),
+    vld1q_s8((int8_t *)(block + 1 * DCTSIZE)),
+    vld1q_s8((int8_t *)(block + 2 * DCTSIZE)),
+    vld1q_s8((int8_t *)(block + 3 * DCTSIZE))
+  } };
+  const int8x16x4_t tbl_rows_4567 = { {
+    vld1q_s8((int8_t *)(block + 4 * DCTSIZE)),
+    vld1q_s8((int8_t *)(block + 5 * DCTSIZE)),
+    vld1q_s8((int8_t *)(block + 6 * DCTSIZE)),
+    vld1q_s8((int8_t *)(block + 7 * DCTSIZE))
+  } };
+#endif
+
+  /* Initialise extra lookup tables. */
+  const int8x16x4_t tbl_rows_2345 = { {
+    tbl_rows_0123.val[2], tbl_rows_0123.val[3],
+    tbl_rows_4567.val[0], tbl_rows_4567.val[1]
+  } };
+  const int8x16x3_t tbl_rows_567 =
+    { { tbl_rows_4567.val[1], tbl_rows_4567.val[2], tbl_rows_4567.val[3] } };
+
+  /* Shuffle coefficients into zig-zag order. */
+  int16x8_t row0 =
+    vreinterpretq_s16_s8(vqtbl4q_s8(tbl_rows_0123, idx_rows_0123.val[0]));
+  int16x8_t row1 =
+    vreinterpretq_s16_s8(vqtbl4q_s8(tbl_rows_0123, idx_rows_0123.val[1]));
+  int16x8_t row2 =
+    vreinterpretq_s16_s8(vqtbl4q_s8(tbl_rows_2345, idx_rows_0123.val[2]));
+  int16x8_t row3 =
+    vreinterpretq_s16_s8(vqtbl4q_s8(tbl_rows_0123, idx_rows_0123.val[3]));
+  int16x8_t row4 =
+    vreinterpretq_s16_s8(vqtbl4q_s8(tbl_rows_4567, idx_rows_4567.val[0]));
+  int16x8_t row5 =
+    vreinterpretq_s16_s8(vqtbl4q_s8(tbl_rows_2345, idx_rows_4567.val[1]));
+  int16x8_t row6 =
+    vreinterpretq_s16_s8(vqtbl4q_s8(tbl_rows_4567, idx_rows_4567.val[2]));
+  int16x8_t row7 =
+    vreinterpretq_s16_s8(vqtbl3q_s8(tbl_rows_567, idx_rows_4567.val[3]));
+
+  /* Compute DC coefficient difference value (F.1.1.5.1). */
+  row0 = vsetq_lane_s16(block[0] - last_dc_val, row0, 0);
+  /* Initialize AC coefficient lanes not reachable by lookup tables. */
+  row1 =
+    vsetq_lane_s16(vgetq_lane_s16(vreinterpretq_s16_s8(tbl_rows_4567.val[0]),
+                                  0), row1, 2);
+  row2 =
+    vsetq_lane_s16(vgetq_lane_s16(vreinterpretq_s16_s8(tbl_rows_0123.val[1]),
+                                  4), row2, 0);
+  row2 =
+    vsetq_lane_s16(vgetq_lane_s16(vreinterpretq_s16_s8(tbl_rows_4567.val[2]),
+                                  0), row2, 5);
+  row5 =
+    vsetq_lane_s16(vgetq_lane_s16(vreinterpretq_s16_s8(tbl_rows_0123.val[1]),
+                                  7), row5, 2);
+  row5 =
+    vsetq_lane_s16(vgetq_lane_s16(vreinterpretq_s16_s8(tbl_rows_4567.val[2]),
+                                  3), row5, 7);
+  row6 =
+    vsetq_lane_s16(vgetq_lane_s16(vreinterpretq_s16_s8(tbl_rows_0123.val[3]),
+                                  7), row6, 5);
+
+  /* DCT block is now in zig-zag order; start Huffman encoding process. */
+  int16x8_t abs_row0 = vabsq_s16(row0);
+  int16x8_t abs_row1 = vabsq_s16(row1);
+  int16x8_t abs_row2 = vabsq_s16(row2);
+  int16x8_t abs_row3 = vabsq_s16(row3);
+  int16x8_t abs_row4 = vabsq_s16(row4);
+  int16x8_t abs_row5 = vabsq_s16(row5);
+  int16x8_t abs_row6 = vabsq_s16(row6);
+  int16x8_t abs_row7 = vabsq_s16(row7);
+
+  /* For negative coeffs: diff = abs(coeff) -1 = ~abs(coeff) */
+  uint16x8_t row0_diff =
+    vreinterpretq_u16_s16(veorq_s16(abs_row0, vshrq_n_s16(row0, 15)));
+  uint16x8_t row1_diff =
+    vreinterpretq_u16_s16(veorq_s16(abs_row1, vshrq_n_s16(row1, 15)));
+  uint16x8_t row2_diff =
+    vreinterpretq_u16_s16(veorq_s16(abs_row2, vshrq_n_s16(row2, 15)));
+  uint16x8_t row3_diff =
+    vreinterpretq_u16_s16(veorq_s16(abs_row3, vshrq_n_s16(row3, 15)));
+  uint16x8_t row4_diff =
+    vreinterpretq_u16_s16(veorq_s16(abs_row4, vshrq_n_s16(row4, 15)));
+  uint16x8_t row5_diff =
+    vreinterpretq_u16_s16(veorq_s16(abs_row5, vshrq_n_s16(row5, 15)));
+  uint16x8_t row6_diff =
+    vreinterpretq_u16_s16(veorq_s16(abs_row6, vshrq_n_s16(row6, 15)));
+  uint16x8_t row7_diff =
+    vreinterpretq_u16_s16(veorq_s16(abs_row7, vshrq_n_s16(row7, 15)));
+
+  /* Construct bitmap to accelerate encoding of AC coefficients.  A set bit
+   * means that the corresponding coefficient != 0.
+   */
+  uint8x8_t abs_row0_gt0 = vmovn_u16(vcgtq_u16(vreinterpretq_u16_s16(abs_row0),
+                                               vdupq_n_u16(0)));
+  uint8x8_t abs_row1_gt0 = vmovn_u16(vcgtq_u16(vreinterpretq_u16_s16(abs_row1),
+                                               vdupq_n_u16(0)));
+  uint8x8_t abs_row2_gt0 = vmovn_u16(vcgtq_u16(vreinterpretq_u16_s16(abs_row2),
+                                               vdupq_n_u16(0)));
+  uint8x8_t abs_row3_gt0 = vmovn_u16(vcgtq_u16(vreinterpretq_u16_s16(abs_row3),
+                                               vdupq_n_u16(0)));
+  uint8x8_t abs_row4_gt0 = vmovn_u16(vcgtq_u16(vreinterpretq_u16_s16(abs_row4),
+                                               vdupq_n_u16(0)));
+  uint8x8_t abs_row5_gt0 = vmovn_u16(vcgtq_u16(vreinterpretq_u16_s16(abs_row5),
+                                               vdupq_n_u16(0)));
+  uint8x8_t abs_row6_gt0 = vmovn_u16(vcgtq_u16(vreinterpretq_u16_s16(abs_row6),
+                                               vdupq_n_u16(0)));
+  uint8x8_t abs_row7_gt0 = vmovn_u16(vcgtq_u16(vreinterpretq_u16_s16(abs_row7),
+                                               vdupq_n_u16(0)));
+
+  /* { 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01 } */
+  const uint8x8_t bitmap_mask =
+    vreinterpret_u8_u64(vmov_n_u64(0x0102040810204080));
+
+  abs_row0_gt0 = vand_u8(abs_row0_gt0, bitmap_mask);
+  abs_row1_gt0 = vand_u8(abs_row1_gt0, bitmap_mask);
+  abs_row2_gt0 = vand_u8(abs_row2_gt0, bitmap_mask);
+  abs_row3_gt0 = vand_u8(abs_row3_gt0, bitmap_mask);
+  abs_row4_gt0 = vand_u8(abs_row4_gt0, bitmap_mask);
+  abs_row5_gt0 = vand_u8(abs_row5_gt0, bitmap_mask);
+  abs_row6_gt0 = vand_u8(abs_row6_gt0, bitmap_mask);
+  abs_row7_gt0 = vand_u8(abs_row7_gt0, bitmap_mask);
+
+  uint8x8_t bitmap_rows_10 = vpadd_u8(abs_row1_gt0, abs_row0_gt0);
+  uint8x8_t bitmap_rows_32 = vpadd_u8(abs_row3_gt0, abs_row2_gt0);
+  uint8x8_t bitmap_rows_54 = vpadd_u8(abs_row5_gt0, abs_row4_gt0);
+  uint8x8_t bitmap_rows_76 = vpadd_u8(abs_row7_gt0, abs_row6_gt0);
+  uint8x8_t bitmap_rows_3210 = vpadd_u8(bitmap_rows_32, bitmap_rows_10);
+  uint8x8_t bitmap_rows_7654 = vpadd_u8(bitmap_rows_76, bitmap_rows_54);
+  uint8x8_t bitmap_all = vpadd_u8(bitmap_rows_7654, bitmap_rows_3210);
+
+  /* Shift left to remove DC bit. */
+  bitmap_all =
+    vreinterpret_u8_u64(vshl_n_u64(vreinterpret_u64_u8(bitmap_all), 1));
+  /* Count bits set (number of non-zero coefficients) in bitmap. */
+  unsigned int non_zero_coefficients = vaddv_u8(vcnt_u8(bitmap_all));
+  /* Move bitmap to 64-bit scalar register. */
+  uint64_t bitmap = vget_lane_u64(vreinterpret_u64_u8(bitmap_all), 0);
+
+  /* Set up state and bit buffer for output bitstream. */
+  working_state *state_ptr = (working_state *)state;
+  int free_bits = state_ptr->cur.free_bits;
+  size_t put_buffer = state_ptr->cur.put_buffer;
+
+  /* Encode DC coefficient. */
+
+  /* Find nbits required to specify sign and amplitude of coefficient. */
+#if defined(_MSC_VER) && !defined(__clang__)
+  unsigned int lz = BUILTIN_CLZ(vgetq_lane_s16(abs_row0, 0));
+#else
+  unsigned int lz;
+  __asm__("clz %w0, %w1" : "=r"(lz) : "r"(vgetq_lane_s16(abs_row0, 0)));
+#endif
+  unsigned int nbits = 32 - lz;
+  /* Emit Huffman-coded symbol and additional diff bits. */
+  unsigned int diff = (unsigned int)(vgetq_lane_u16(row0_diff, 0) << lz) >> lz;
+  PUT_CODE(dctbl->ehufco[nbits], dctbl->ehufsi[nbits], diff)
+
+  /* Encode AC coefficients. */
+
+  unsigned int r = 0;  /* r = run length of zeros */
+  unsigned int i = 1;  /* i = number of coefficients encoded */
+  /* Code and size information for a run length of 16 zero coefficients */
+  const unsigned int code_0xf0 = actbl->ehufco[0xf0];
+  const unsigned int size_0xf0 = actbl->ehufsi[0xf0];
+
+  /* The most efficient method of computing nbits and diff depends on the
+   * number of non-zero coefficients.  If the bitmap is not too sparse (> 8
+   * non-zero AC coefficients), it is beneficial to use Neon; else we compute
+   * nbits and diff on demand using scalar code.
+   */
+  if (non_zero_coefficients > 8) {
+    uint8_t block_nbits[DCTSIZE2];
+
+    int16x8_t row0_lz = vclzq_s16(abs_row0);
+    int16x8_t row1_lz = vclzq_s16(abs_row1);
+    int16x8_t row2_lz = vclzq_s16(abs_row2);
+    int16x8_t row3_lz = vclzq_s16(abs_row3);
+    int16x8_t row4_lz = vclzq_s16(abs_row4);
+    int16x8_t row5_lz = vclzq_s16(abs_row5);
+    int16x8_t row6_lz = vclzq_s16(abs_row6);
+    int16x8_t row7_lz = vclzq_s16(abs_row7);
+    /* Compute nbits needed to specify magnitude of each coefficient. */
+    uint8x8_t row0_nbits = vsub_u8(vdup_n_u8(16),
+                                   vmovn_u16(vreinterpretq_u16_s16(row0_lz)));
+    uint8x8_t row1_nbits = vsub_u8(vdup_n_u8(16),
+                                   vmovn_u16(vreinterpretq_u16_s16(row1_lz)));
+    uint8x8_t row2_nbits = vsub_u8(vdup_n_u8(16),
+                                   vmovn_u16(vreinterpretq_u16_s16(row2_lz)));
+    uint8x8_t row3_nbits = vsub_u8(vdup_n_u8(16),
+                                   vmovn_u16(vreinterpretq_u16_s16(row3_lz)));
+    uint8x8_t row4_nbits = vsub_u8(vdup_n_u8(16),
+                                   vmovn_u16(vreinterpretq_u16_s16(row4_lz)));
+    uint8x8_t row5_nbits = vsub_u8(vdup_n_u8(16),
+                                   vmovn_u16(vreinterpretq_u16_s16(row5_lz)));
+    uint8x8_t row6_nbits = vsub_u8(vdup_n_u8(16),
+                                   vmovn_u16(vreinterpretq_u16_s16(row6_lz)));
+    uint8x8_t row7_nbits = vsub_u8(vdup_n_u8(16),
+                                   vmovn_u16(vreinterpretq_u16_s16(row7_lz)));
+    /* Store nbits. */
+    vst1_u8(block_nbits + 0 * DCTSIZE, row0_nbits);
+    vst1_u8(block_nbits + 1 * DCTSIZE, row1_nbits);
+    vst1_u8(block_nbits + 2 * DCTSIZE, row2_nbits);
+    vst1_u8(block_nbits + 3 * DCTSIZE, row3_nbits);
+    vst1_u8(block_nbits + 4 * DCTSIZE, row4_nbits);
+    vst1_u8(block_nbits + 5 * DCTSIZE, row5_nbits);
+    vst1_u8(block_nbits + 6 * DCTSIZE, row6_nbits);
+    vst1_u8(block_nbits + 7 * DCTSIZE, row7_nbits);
+    /* Mask bits not required to specify sign and amplitude of diff. */
+    row0_diff = vshlq_u16(row0_diff, row0_lz);
+    row1_diff = vshlq_u16(row1_diff, row1_lz);
+    row2_diff = vshlq_u16(row2_diff, row2_lz);
+    row3_diff = vshlq_u16(row3_diff, row3_lz);
+    row4_diff = vshlq_u16(row4_diff, row4_lz);
+    row5_diff = vshlq_u16(row5_diff, row5_lz);
+    row6_diff = vshlq_u16(row6_diff, row6_lz);
+    row7_diff = vshlq_u16(row7_diff, row7_lz);
+    row0_diff = vshlq_u16(row0_diff, vnegq_s16(row0_lz));
+    row1_diff = vshlq_u16(row1_diff, vnegq_s16(row1_lz));
+    row2_diff = vshlq_u16(row2_diff, vnegq_s16(row2_lz));
+    row3_diff = vshlq_u16(row3_diff, vnegq_s16(row3_lz));
+    row4_diff = vshlq_u16(row4_diff, vnegq_s16(row4_lz));
+    row5_diff = vshlq_u16(row5_diff, vnegq_s16(row5_lz));
+    row6_diff = vshlq_u16(row6_diff, vnegq_s16(row6_lz));
+    row7_diff = vshlq_u16(row7_diff, vnegq_s16(row7_lz));
+    /* Store diff bits. */
+    vst1q_u16(block_diff + 0 * DCTSIZE, row0_diff);
+    vst1q_u16(block_diff + 1 * DCTSIZE, row1_diff);
+    vst1q_u16(block_diff + 2 * DCTSIZE, row2_diff);
+    vst1q_u16(block_diff + 3 * DCTSIZE, row3_diff);
+    vst1q_u16(block_diff + 4 * DCTSIZE, row4_diff);
+    vst1q_u16(block_diff + 5 * DCTSIZE, row5_diff);
+    vst1q_u16(block_diff + 6 * DCTSIZE, row6_diff);
+    vst1q_u16(block_diff + 7 * DCTSIZE, row7_diff);
+
+    while (bitmap != 0) {
+      r = BUILTIN_CLZL(bitmap);
+      i += r;
+      bitmap <<= r;
+      nbits = block_nbits[i];
+      diff = block_diff[i];
+      while (r > 15) {
+        /* If run length > 15, emit special run-length-16 codes. */
+        PUT_BITS(code_0xf0, size_0xf0)
+        r -= 16;
+      }
+      /* Emit Huffman symbol for run length / number of bits. (F.1.2.2.1) */
+      unsigned int rs = (r << 4) + nbits;
+      PUT_CODE(actbl->ehufco[rs], actbl->ehufsi[rs], diff)
+      i++;
+      bitmap <<= 1;
+    }
+  } else if (bitmap != 0) {
+    uint16_t block_abs[DCTSIZE2];
+    /* Store absolute value of coefficients. */
+    vst1q_u16(block_abs + 0 * DCTSIZE, vreinterpretq_u16_s16(abs_row0));
+    vst1q_u16(block_abs + 1 * DCTSIZE, vreinterpretq_u16_s16(abs_row1));
+    vst1q_u16(block_abs + 2 * DCTSIZE, vreinterpretq_u16_s16(abs_row2));
+    vst1q_u16(block_abs + 3 * DCTSIZE, vreinterpretq_u16_s16(abs_row3));
+    vst1q_u16(block_abs + 4 * DCTSIZE, vreinterpretq_u16_s16(abs_row4));
+    vst1q_u16(block_abs + 5 * DCTSIZE, vreinterpretq_u16_s16(abs_row5));
+    vst1q_u16(block_abs + 6 * DCTSIZE, vreinterpretq_u16_s16(abs_row6));
+    vst1q_u16(block_abs + 7 * DCTSIZE, vreinterpretq_u16_s16(abs_row7));
+    /* Store diff bits. */
+    vst1q_u16(block_diff + 0 * DCTSIZE, row0_diff);
+    vst1q_u16(block_diff + 1 * DCTSIZE, row1_diff);
+    vst1q_u16(block_diff + 2 * DCTSIZE, row2_diff);
+    vst1q_u16(block_diff + 3 * DCTSIZE, row3_diff);
+    vst1q_u16(block_diff + 4 * DCTSIZE, row4_diff);
+    vst1q_u16(block_diff + 5 * DCTSIZE, row5_diff);
+    vst1q_u16(block_diff + 6 * DCTSIZE, row6_diff);
+    vst1q_u16(block_diff + 7 * DCTSIZE, row7_diff);
+
+    /* Same as above but must mask diff bits and compute nbits on demand. */
+    while (bitmap != 0) {
+      r = BUILTIN_CLZL(bitmap);
+      i += r;
+      bitmap <<= r;
+      lz = BUILTIN_CLZ(block_abs[i]);
+      nbits = 32 - lz;
+      diff = (unsigned int)(block_diff[i] << lz) >> lz;
+      while (r > 15) {
+        /* If run length > 15, emit special run-length-16 codes. */
+        PUT_BITS(code_0xf0, size_0xf0)
+        r -= 16;
+      }
+      /* Emit Huffman symbol for run length / number of bits. (F.1.2.2.1) */
+      unsigned int rs = (r << 4) + nbits;
+      PUT_CODE(actbl->ehufco[rs], actbl->ehufsi[rs], diff)
+      i++;
+      bitmap <<= 1;
+    }
+  }
+
+  /* If the last coefficient(s) were zero, emit an end-of-block (EOB) code.
+   * The value of RS for the EOB code is 0.
+   */
+  if (i != 64) {
+    PUT_BITS(actbl->ehufco[0], actbl->ehufsi[0])
+  }
+
+  state_ptr->cur.put_buffer = put_buffer;
+  state_ptr->cur.free_bits = free_bits;
+
+  return buffer;
+}
diff --git a/3rdparty/libjpeg/src/simd/arm/aarch64/jsimd.c b/3rdparty/libjpeg/src/simd/arm/aarch64/jsimd.c
new file mode 100644
index 00000000..8570b82c
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/arm/aarch64/jsimd.c
@@ -0,0 +1,1063 @@
+/*
+ * jsimd_arm64.c
+ *
+ * Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+ * Copyright (C) 2011, Nokia Corporation and/or its subsidiary(-ies).
+ * Copyright (C) 2009-2011, 2013-2014, 2016, 2018, 2020, D. R. Commander.
+ * Copyright (C) 2015-2016, 2018, Matthieu Darbois.
+ * Copyright (C) 2020, Arm Limited.
+ *
+ * Based on the x86 SIMD extension for IJG JPEG library,
+ * Copyright (C) 1999-2006, MIYASAKA Masaru.
+ * For conditions of distribution and use, see copyright notice in jsimdext.inc
+ *
+ * This file contains the interface between the "normal" portions
+ * of the library and the SIMD implementations when running on a
+ * 64-bit Arm architecture.
+ */
+
+#define JPEG_INTERNALS
+#include "../../../jinclude.h"
+#include "../../../jpeglib.h"
+#include "../../../jsimd.h"
+#include "../../../jdct.h"
+#include "../../../jsimddct.h"
+#include "../../jsimd.h"
+#include "jconfigint.h"
+
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+
+#define JSIMD_FASTLD3  1
+#define JSIMD_FASTST3  2
+#define JSIMD_FASTTBL  4
+
+static unsigned int simd_support = ~0;
+static unsigned int simd_huffman = 1;
+static unsigned int simd_features = JSIMD_FASTLD3 | JSIMD_FASTST3 |
+                                    JSIMD_FASTTBL;
+
+#if defined(__linux__) || defined(ANDROID) || defined(__ANDROID__)
+
+#define SOMEWHAT_SANE_PROC_CPUINFO_SIZE_LIMIT  (1024 * 1024)
+
+LOCAL(int)
+check_cpuinfo(char *buffer, const char *field, char *value)
+{
+  char *p;
+
+  if (*value == 0)
+    return 0;
+  if (strncmp(buffer, field, strlen(field)) != 0)
+    return 0;
+  buffer += strlen(field);
+  while (isspace(*buffer))
+    buffer++;
+
+  /* Check if 'value' is present in the buffer as a separate word */
+  while ((p = strstr(buffer, value))) {
+    if (p > buffer && !isspace(*(p - 1))) {
+      buffer++;
+      continue;
+    }
+    p += strlen(value);
+    if (*p != 0 && !isspace(*p)) {
+      buffer++;
+      continue;
+    }
+    return 1;
+  }
+  return 0;
+}
+
+LOCAL(int)
+parse_proc_cpuinfo(int bufsize)
+{
+  char *buffer = (char *)malloc(bufsize);
+  FILE *fd;
+
+  if (!buffer)
+    return 0;
+
+  fd = fopen("/proc/cpuinfo", "r");
+  if (fd) {
+    while (fgets(buffer, bufsize, fd)) {
+      if (!strchr(buffer, '\n') && !feof(fd)) {
+        /* "impossible" happened - insufficient size of the buffer! */
+        fclose(fd);
+        free(buffer);
+        return 0;
+      }
+      if (check_cpuinfo(buffer, "CPU part", "0xd03") ||
+          check_cpuinfo(buffer, "CPU part", "0xd07"))
+        /* The Cortex-A53 has a slow tbl implementation.  We can gain a few
+           percent speedup by disabling the use of that instruction.  The
+           speedup on Cortex-A57 is more subtle but still measurable. */
+        simd_features &= ~JSIMD_FASTTBL;
+      else if (check_cpuinfo(buffer, "CPU part", "0x0a1"))
+        /* The SIMD version of Huffman encoding is slower than the C version on
+           Cavium ThunderX.  Also, ld3 and st3 are abyssmally slow on that
+           CPU. */
+        simd_huffman = simd_features = 0;
+    }
+    fclose(fd);
+  }
+  free(buffer);
+  return 1;
+}
+
+#endif
+
+/*
+ * Check what SIMD accelerations are supported.
+ *
+ * FIXME: This code is racy under a multi-threaded environment.
+ */
+
+/*
+ * Armv8 architectures support Neon extensions by default.
+ * It is no longer optional as it was with Armv7.
+ */
+
+
+LOCAL(void)
+init_simd(void)
+{
+#ifndef NO_GETENV
+  char *env = NULL;
+#endif
+#if defined(__linux__) || defined(ANDROID) || defined(__ANDROID__)
+  int bufsize = 1024; /* an initial guess for the line buffer size limit */
+#endif
+
+  if (simd_support != ~0U)
+    return;
+
+  simd_support = 0;
+
+  simd_support |= JSIMD_NEON;
+#if defined(__linux__) || defined(ANDROID) || defined(__ANDROID__)
+  while (!parse_proc_cpuinfo(bufsize)) {
+    bufsize *= 2;
+    if (bufsize > SOMEWHAT_SANE_PROC_CPUINFO_SIZE_LIMIT)
+      break;
+  }
+#endif
+
+#ifndef NO_GETENV
+  /* Force different settings through environment variables */
+  env = getenv("JSIMD_FORCENEON");
+  if ((env != NULL) && (strcmp(env, "1") == 0))
+    simd_support = JSIMD_NEON;
+  env = getenv("JSIMD_FORCENONE");
+  if ((env != NULL) && (strcmp(env, "1") == 0))
+    simd_support = 0;
+  env = getenv("JSIMD_NOHUFFENC");
+  if ((env != NULL) && (strcmp(env, "1") == 0))
+    simd_huffman = 0;
+  env = getenv("JSIMD_FASTLD3");
+  if ((env != NULL) && (strcmp(env, "1") == 0))
+    simd_features |= JSIMD_FASTLD3;
+  if ((env != NULL) && (strcmp(env, "0") == 0))
+    simd_features &= ~JSIMD_FASTLD3;
+  env = getenv("JSIMD_FASTST3");
+  if ((env != NULL) && (strcmp(env, "1") == 0))
+    simd_features |= JSIMD_FASTST3;
+  if ((env != NULL) && (strcmp(env, "0") == 0))
+    simd_features &= ~JSIMD_FASTST3;
+#endif
+}
+
+GLOBAL(int)
+jsimd_can_rgb_ycc(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+  if ((RGB_PIXELSIZE != 3) && (RGB_PIXELSIZE != 4))
+    return 0;
+
+  if (simd_support & JSIMD_NEON)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_rgb_gray(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+  if ((RGB_PIXELSIZE != 3) && (RGB_PIXELSIZE != 4))
+    return 0;
+
+  if (simd_support & JSIMD_NEON)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_ycc_rgb(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+  if ((RGB_PIXELSIZE != 3) && (RGB_PIXELSIZE != 4))
+    return 0;
+
+  if (simd_support & JSIMD_NEON)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_ycc_rgb565(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+
+  if (simd_support & JSIMD_NEON)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(void)
+jsimd_rgb_ycc_convert(j_compress_ptr cinfo, JSAMPARRAY input_buf,
+                      JSAMPIMAGE output_buf, JDIMENSION output_row,
+                      int num_rows)
+{
+  void (*neonfct) (JDIMENSION, JSAMPARRAY, JSAMPIMAGE, JDIMENSION, int);
+
+  switch (cinfo->in_color_space) {
+  case JCS_EXT_RGB:
+#ifndef NEON_INTRINSICS
+    if (simd_features & JSIMD_FASTLD3)
+#endif
+      neonfct = jsimd_extrgb_ycc_convert_neon;
+#ifndef NEON_INTRINSICS
+    else
+      neonfct = jsimd_extrgb_ycc_convert_neon_slowld3;
+#endif
+    break;
+  case JCS_EXT_RGBX:
+  case JCS_EXT_RGBA:
+    neonfct = jsimd_extrgbx_ycc_convert_neon;
+    break;
+  case JCS_EXT_BGR:
+#ifndef NEON_INTRINSICS
+    if (simd_features & JSIMD_FASTLD3)
+#endif
+      neonfct = jsimd_extbgr_ycc_convert_neon;
+#ifndef NEON_INTRINSICS
+    else
+      neonfct = jsimd_extbgr_ycc_convert_neon_slowld3;
+#endif
+    break;
+  case JCS_EXT_BGRX:
+  case JCS_EXT_BGRA:
+    neonfct = jsimd_extbgrx_ycc_convert_neon;
+    break;
+  case JCS_EXT_XBGR:
+  case JCS_EXT_ABGR:
+    neonfct = jsimd_extxbgr_ycc_convert_neon;
+    break;
+  case JCS_EXT_XRGB:
+  case JCS_EXT_ARGB:
+    neonfct = jsimd_extxrgb_ycc_convert_neon;
+    break;
+  default:
+#ifndef NEON_INTRINSICS
+    if (simd_features & JSIMD_FASTLD3)
+#endif
+      neonfct = jsimd_extrgb_ycc_convert_neon;
+#ifndef NEON_INTRINSICS
+    else
+      neonfct = jsimd_extrgb_ycc_convert_neon_slowld3;
+#endif
+    break;
+  }
+
+  neonfct(cinfo->image_width, input_buf, output_buf, output_row, num_rows);
+}
+
+GLOBAL(void)
+jsimd_rgb_gray_convert(j_compress_ptr cinfo, JSAMPARRAY input_buf,
+                       JSAMPIMAGE output_buf, JDIMENSION output_row,
+                       int num_rows)
+{
+  void (*neonfct) (JDIMENSION, JSAMPARRAY, JSAMPIMAGE, JDIMENSION, int);
+
+  switch (cinfo->in_color_space) {
+  case JCS_EXT_RGB:
+    neonfct = jsimd_extrgb_gray_convert_neon;
+    break;
+  case JCS_EXT_RGBX:
+  case JCS_EXT_RGBA:
+    neonfct = jsimd_extrgbx_gray_convert_neon;
+    break;
+  case JCS_EXT_BGR:
+    neonfct = jsimd_extbgr_gray_convert_neon;
+    break;
+  case JCS_EXT_BGRX:
+  case JCS_EXT_BGRA:
+    neonfct = jsimd_extbgrx_gray_convert_neon;
+    break;
+  case JCS_EXT_XBGR:
+  case JCS_EXT_ABGR:
+    neonfct = jsimd_extxbgr_gray_convert_neon;
+    break;
+  case JCS_EXT_XRGB:
+  case JCS_EXT_ARGB:
+    neonfct = jsimd_extxrgb_gray_convert_neon;
+    break;
+  default:
+    neonfct = jsimd_extrgb_gray_convert_neon;
+    break;
+  }
+
+  neonfct(cinfo->image_width, input_buf, output_buf, output_row, num_rows);
+}
+
+GLOBAL(void)
+jsimd_ycc_rgb_convert(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
+                      JDIMENSION input_row, JSAMPARRAY output_buf,
+                      int num_rows)
+{
+  void (*neonfct) (JDIMENSION, JSAMPIMAGE, JDIMENSION, JSAMPARRAY, int);
+
+  switch (cinfo->out_color_space) {
+  case JCS_EXT_RGB:
+#ifndef NEON_INTRINSICS
+    if (simd_features & JSIMD_FASTST3)
+#endif
+      neonfct = jsimd_ycc_extrgb_convert_neon;
+#ifndef NEON_INTRINSICS
+    else
+      neonfct = jsimd_ycc_extrgb_convert_neon_slowst3;
+#endif
+    break;
+  case JCS_EXT_RGBX:
+  case JCS_EXT_RGBA:
+    neonfct = jsimd_ycc_extrgbx_convert_neon;
+    break;
+  case JCS_EXT_BGR:
+#ifndef NEON_INTRINSICS
+    if (simd_features & JSIMD_FASTST3)
+#endif
+      neonfct = jsimd_ycc_extbgr_convert_neon;
+#ifndef NEON_INTRINSICS
+    else
+      neonfct = jsimd_ycc_extbgr_convert_neon_slowst3;
+#endif
+    break;
+  case JCS_EXT_BGRX:
+  case JCS_EXT_BGRA:
+    neonfct = jsimd_ycc_extbgrx_convert_neon;
+    break;
+  case JCS_EXT_XBGR:
+  case JCS_EXT_ABGR:
+    neonfct = jsimd_ycc_extxbgr_convert_neon;
+    break;
+  case JCS_EXT_XRGB:
+  case JCS_EXT_ARGB:
+    neonfct = jsimd_ycc_extxrgb_convert_neon;
+    break;
+  default:
+#ifndef NEON_INTRINSICS
+    if (simd_features & JSIMD_FASTST3)
+#endif
+      neonfct = jsimd_ycc_extrgb_convert_neon;
+#ifndef NEON_INTRINSICS
+    else
+      neonfct = jsimd_ycc_extrgb_convert_neon_slowst3;
+#endif
+    break;
+  }
+
+  neonfct(cinfo->output_width, input_buf, input_row, output_buf, num_rows);
+}
+
+GLOBAL(void)
+jsimd_ycc_rgb565_convert(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
+                         JDIMENSION input_row, JSAMPARRAY output_buf,
+                         int num_rows)
+{
+  jsimd_ycc_rgb565_convert_neon(cinfo->output_width, input_buf, input_row,
+                                output_buf, num_rows);
+}
+
+GLOBAL(int)
+jsimd_can_h2v2_downsample(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (DCTSIZE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+
+  if (simd_support & JSIMD_NEON)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_h2v1_downsample(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (DCTSIZE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+
+  if (simd_support & JSIMD_NEON)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(void)
+jsimd_h2v2_downsample(j_compress_ptr cinfo, jpeg_component_info *compptr,
+                      JSAMPARRAY input_data, JSAMPARRAY output_data)
+{
+  jsimd_h2v2_downsample_neon(cinfo->image_width, cinfo->max_v_samp_factor,
+                             compptr->v_samp_factor, compptr->width_in_blocks,
+                             input_data, output_data);
+}
+
+GLOBAL(void)
+jsimd_h2v1_downsample(j_compress_ptr cinfo, jpeg_component_info *compptr,
+                      JSAMPARRAY input_data, JSAMPARRAY output_data)
+{
+  jsimd_h2v1_downsample_neon(cinfo->image_width, cinfo->max_v_samp_factor,
+                             compptr->v_samp_factor, compptr->width_in_blocks,
+                             input_data, output_data);
+}
+
+GLOBAL(int)
+jsimd_can_h2v2_upsample(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+
+  if (simd_support & JSIMD_NEON)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_h2v1_upsample(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+  if (simd_support & JSIMD_NEON)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(void)
+jsimd_h2v2_upsample(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+                    JSAMPARRAY input_data, JSAMPARRAY *output_data_ptr)
+{
+  jsimd_h2v2_upsample_neon(cinfo->max_v_samp_factor, cinfo->output_width,
+                           input_data, output_data_ptr);
+}
+
+GLOBAL(void)
+jsimd_h2v1_upsample(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+                    JSAMPARRAY input_data, JSAMPARRAY *output_data_ptr)
+{
+  jsimd_h2v1_upsample_neon(cinfo->max_v_samp_factor, cinfo->output_width,
+                           input_data, output_data_ptr);
+}
+
+GLOBAL(int)
+jsimd_can_h2v2_fancy_upsample(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+
+  if (simd_support & JSIMD_NEON)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_h2v1_fancy_upsample(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+
+  if (simd_support & JSIMD_NEON)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_h1v2_fancy_upsample(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+
+  if (simd_support & JSIMD_NEON)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(void)
+jsimd_h2v2_fancy_upsample(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+                          JSAMPARRAY input_data, JSAMPARRAY *output_data_ptr)
+{
+  jsimd_h2v2_fancy_upsample_neon(cinfo->max_v_samp_factor,
+                                 compptr->downsampled_width, input_data,
+                                 output_data_ptr);
+}
+
+GLOBAL(void)
+jsimd_h2v1_fancy_upsample(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+                          JSAMPARRAY input_data, JSAMPARRAY *output_data_ptr)
+{
+  jsimd_h2v1_fancy_upsample_neon(cinfo->max_v_samp_factor,
+                                 compptr->downsampled_width, input_data,
+                                 output_data_ptr);
+}
+
+GLOBAL(void)
+jsimd_h1v2_fancy_upsample(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+                          JSAMPARRAY input_data, JSAMPARRAY *output_data_ptr)
+{
+  jsimd_h1v2_fancy_upsample_neon(cinfo->max_v_samp_factor,
+                                 compptr->downsampled_width, input_data,
+                                 output_data_ptr);
+}
+
+GLOBAL(int)
+jsimd_can_h2v2_merged_upsample(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+
+  if (simd_support & JSIMD_NEON)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_h2v1_merged_upsample(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+
+  if (simd_support & JSIMD_NEON)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(void)
+jsimd_h2v2_merged_upsample(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
+                           JDIMENSION in_row_group_ctr, JSAMPARRAY output_buf)
+{
+  void (*neonfct) (JDIMENSION, JSAMPIMAGE, JDIMENSION, JSAMPARRAY);
+
+  switch (cinfo->out_color_space) {
+    case JCS_EXT_RGB:
+      neonfct = jsimd_h2v2_extrgb_merged_upsample_neon;
+      break;
+    case JCS_EXT_RGBX:
+    case JCS_EXT_RGBA:
+      neonfct = jsimd_h2v2_extrgbx_merged_upsample_neon;
+      break;
+    case JCS_EXT_BGR:
+      neonfct = jsimd_h2v2_extbgr_merged_upsample_neon;
+      break;
+    case JCS_EXT_BGRX:
+    case JCS_EXT_BGRA:
+      neonfct = jsimd_h2v2_extbgrx_merged_upsample_neon;
+      break;
+    case JCS_EXT_XBGR:
+    case JCS_EXT_ABGR:
+      neonfct = jsimd_h2v2_extxbgr_merged_upsample_neon;
+      break;
+    case JCS_EXT_XRGB:
+    case JCS_EXT_ARGB:
+      neonfct = jsimd_h2v2_extxrgb_merged_upsample_neon;
+      break;
+    default:
+      neonfct = jsimd_h2v2_extrgb_merged_upsample_neon;
+      break;
+  }
+
+  neonfct(cinfo->output_width, input_buf, in_row_group_ctr, output_buf);
+}
+
+GLOBAL(void)
+jsimd_h2v1_merged_upsample(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
+                           JDIMENSION in_row_group_ctr, JSAMPARRAY output_buf)
+{
+  void (*neonfct) (JDIMENSION, JSAMPIMAGE, JDIMENSION, JSAMPARRAY);
+
+  switch (cinfo->out_color_space) {
+    case JCS_EXT_RGB:
+      neonfct = jsimd_h2v1_extrgb_merged_upsample_neon;
+      break;
+    case JCS_EXT_RGBX:
+    case JCS_EXT_RGBA:
+      neonfct = jsimd_h2v1_extrgbx_merged_upsample_neon;
+      break;
+    case JCS_EXT_BGR:
+      neonfct = jsimd_h2v1_extbgr_merged_upsample_neon;
+      break;
+    case JCS_EXT_BGRX:
+    case JCS_EXT_BGRA:
+      neonfct = jsimd_h2v1_extbgrx_merged_upsample_neon;
+      break;
+    case JCS_EXT_XBGR:
+    case JCS_EXT_ABGR:
+      neonfct = jsimd_h2v1_extxbgr_merged_upsample_neon;
+      break;
+    case JCS_EXT_XRGB:
+    case JCS_EXT_ARGB:
+      neonfct = jsimd_h2v1_extxrgb_merged_upsample_neon;
+      break;
+    default:
+      neonfct = jsimd_h2v1_extrgb_merged_upsample_neon;
+      break;
+  }
+
+  neonfct(cinfo->output_width, input_buf, in_row_group_ctr, output_buf);
+}
+
+GLOBAL(int)
+jsimd_can_convsamp(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (DCTSIZE != 8)
+    return 0;
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+  if (sizeof(DCTELEM) != 2)
+    return 0;
+
+  if (simd_support & JSIMD_NEON)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_convsamp_float(void)
+{
+  return 0;
+}
+
+GLOBAL(void)
+jsimd_convsamp(JSAMPARRAY sample_data, JDIMENSION start_col,
+               DCTELEM *workspace)
+{
+  jsimd_convsamp_neon(sample_data, start_col, workspace);
+}
+
+GLOBAL(void)
+jsimd_convsamp_float(JSAMPARRAY sample_data, JDIMENSION start_col,
+                     FAST_FLOAT *workspace)
+{
+}
+
+GLOBAL(int)
+jsimd_can_fdct_islow(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (DCTSIZE != 8)
+    return 0;
+  if (sizeof(DCTELEM) != 2)
+    return 0;
+
+  if (simd_support & JSIMD_NEON)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_fdct_ifast(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (DCTSIZE != 8)
+    return 0;
+  if (sizeof(DCTELEM) != 2)
+    return 0;
+
+  if (simd_support & JSIMD_NEON)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_fdct_float(void)
+{
+  return 0;
+}
+
+GLOBAL(void)
+jsimd_fdct_islow(DCTELEM *data)
+{
+  jsimd_fdct_islow_neon(data);
+}
+
+GLOBAL(void)
+jsimd_fdct_ifast(DCTELEM *data)
+{
+  jsimd_fdct_ifast_neon(data);
+}
+
+GLOBAL(void)
+jsimd_fdct_float(FAST_FLOAT *data)
+{
+}
+
+GLOBAL(int)
+jsimd_can_quantize(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (DCTSIZE != 8)
+    return 0;
+  if (sizeof(JCOEF) != 2)
+    return 0;
+  if (sizeof(DCTELEM) != 2)
+    return 0;
+
+  if (simd_support & JSIMD_NEON)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_quantize_float(void)
+{
+  return 0;
+}
+
+GLOBAL(void)
+jsimd_quantize(JCOEFPTR coef_block, DCTELEM *divisors, DCTELEM *workspace)
+{
+  jsimd_quantize_neon(coef_block, divisors, workspace);
+}
+
+GLOBAL(void)
+jsimd_quantize_float(JCOEFPTR coef_block, FAST_FLOAT *divisors,
+                     FAST_FLOAT *workspace)
+{
+}
+
+GLOBAL(int)
+jsimd_can_idct_2x2(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (DCTSIZE != 8)
+    return 0;
+  if (sizeof(JCOEF) != 2)
+    return 0;
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+  if (sizeof(ISLOW_MULT_TYPE) != 2)
+    return 0;
+
+  if (simd_support & JSIMD_NEON)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_idct_4x4(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (DCTSIZE != 8)
+    return 0;
+  if (sizeof(JCOEF) != 2)
+    return 0;
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+  if (sizeof(ISLOW_MULT_TYPE) != 2)
+    return 0;
+
+  if (simd_support & JSIMD_NEON)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(void)
+jsimd_idct_2x2(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+               JCOEFPTR coef_block, JSAMPARRAY output_buf,
+               JDIMENSION output_col)
+{
+  jsimd_idct_2x2_neon(compptr->dct_table, coef_block, output_buf, output_col);
+}
+
+GLOBAL(void)
+jsimd_idct_4x4(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+               JCOEFPTR coef_block, JSAMPARRAY output_buf,
+               JDIMENSION output_col)
+{
+  jsimd_idct_4x4_neon(compptr->dct_table, coef_block, output_buf, output_col);
+}
+
+GLOBAL(int)
+jsimd_can_idct_islow(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (DCTSIZE != 8)
+    return 0;
+  if (sizeof(JCOEF) != 2)
+    return 0;
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+  if (sizeof(ISLOW_MULT_TYPE) != 2)
+    return 0;
+
+  if (simd_support & JSIMD_NEON)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_idct_ifast(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (DCTSIZE != 8)
+    return 0;
+  if (sizeof(JCOEF) != 2)
+    return 0;
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+  if (sizeof(IFAST_MULT_TYPE) != 2)
+    return 0;
+  if (IFAST_SCALE_BITS != 2)
+    return 0;
+
+  if (simd_support & JSIMD_NEON)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_idct_float(void)
+{
+  return 0;
+}
+
+GLOBAL(void)
+jsimd_idct_islow(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+                 JCOEFPTR coef_block, JSAMPARRAY output_buf,
+                 JDIMENSION output_col)
+{
+  jsimd_idct_islow_neon(compptr->dct_table, coef_block, output_buf,
+                        output_col);
+}
+
+GLOBAL(void)
+jsimd_idct_ifast(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+                 JCOEFPTR coef_block, JSAMPARRAY output_buf,
+                 JDIMENSION output_col)
+{
+  jsimd_idct_ifast_neon(compptr->dct_table, coef_block, output_buf,
+                        output_col);
+}
+
+GLOBAL(void)
+jsimd_idct_float(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+                 JCOEFPTR coef_block, JSAMPARRAY output_buf,
+                 JDIMENSION output_col)
+{
+}
+
+GLOBAL(int)
+jsimd_can_huff_encode_one_block(void)
+{
+  init_simd();
+
+  if (DCTSIZE != 8)
+    return 0;
+  if (sizeof(JCOEF) != 2)
+    return 0;
+
+  if (simd_support & JSIMD_NEON && simd_huffman)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(JOCTET *)
+jsimd_huff_encode_one_block(void *state, JOCTET *buffer, JCOEFPTR block,
+                            int last_dc_val, c_derived_tbl *dctbl,
+                            c_derived_tbl *actbl)
+{
+#ifndef NEON_INTRINSICS
+  if (simd_features & JSIMD_FASTTBL)
+#endif
+    return jsimd_huff_encode_one_block_neon(state, buffer, block, last_dc_val,
+                                            dctbl, actbl);
+#ifndef NEON_INTRINSICS
+  else
+    return jsimd_huff_encode_one_block_neon_slowtbl(state, buffer, block,
+                                                    last_dc_val, dctbl, actbl);
+#endif
+}
+
+GLOBAL(int)
+jsimd_can_encode_mcu_AC_first_prepare(void)
+{
+  init_simd();
+
+  if (DCTSIZE != 8)
+    return 0;
+  if (sizeof(JCOEF) != 2)
+    return 0;
+  if (SIZEOF_SIZE_T != 8)
+    return 0;
+
+  if (simd_support & JSIMD_NEON)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(void)
+jsimd_encode_mcu_AC_first_prepare(const JCOEF *block,
+                                  const int *jpeg_natural_order_start, int Sl,
+                                  int Al, JCOEF *values, size_t *zerobits)
+{
+  jsimd_encode_mcu_AC_first_prepare_neon(block, jpeg_natural_order_start,
+                                         Sl, Al, values, zerobits);
+}
+
+GLOBAL(int)
+jsimd_can_encode_mcu_AC_refine_prepare(void)
+{
+  init_simd();
+
+  if (DCTSIZE != 8)
+    return 0;
+  if (sizeof(JCOEF) != 2)
+    return 0;
+  if (SIZEOF_SIZE_T != 8)
+    return 0;
+
+  if (simd_support & JSIMD_NEON)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_encode_mcu_AC_refine_prepare(const JCOEF *block,
+                                   const int *jpeg_natural_order_start, int Sl,
+                                   int Al, JCOEF *absvalues, size_t *bits)
+{
+  return jsimd_encode_mcu_AC_refine_prepare_neon(block,
+                                                 jpeg_natural_order_start,
+                                                 Sl, Al, absvalues, bits);
+}
diff --git a/3rdparty/libjpeg/src/simd/arm/aarch64/jsimd_neon.S b/3rdparty/libjpeg/src/simd/arm/aarch64/jsimd_neon.S
new file mode 100644
index 00000000..31aa8e25
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/arm/aarch64/jsimd_neon.S
@@ -0,0 +1,2252 @@
+/*
+ * Armv8 Neon optimizations for libjpeg-turbo
+ *
+ * Copyright (C) 2009-2011, Nokia Corporation and/or its subsidiary(-ies).
+ *                          All Rights Reserved.
+ * Author:  Siarhei Siamashka <siarhei.siamashka@nokia.com>
+ * Copyright (C) 2013-2014, Linaro Limited.  All Rights Reserved.
+ * Author:  Ragesh Radhakrishnan <ragesh.r@linaro.org>
+ * Copyright (C) 2014-2016, 2020, D. R. Commander.  All Rights Reserved.
+ * Copyright (C) 2015-2016, 2018, Matthieu Darbois.  All Rights Reserved.
+ * Copyright (C) 2016, Siarhei Siamashka.  All Rights Reserved.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+#if defined(__linux__) && defined(__ELF__)
+.section .note.GNU-stack, "", %progbits  /* mark stack as non-executable */
+#endif
+
+#if defined(__APPLE__)
+.section __DATA, __const
+#elif defined(_WIN32)
+.section .rdata
+#else
+.section .rodata, "a", %progbits
+#endif
+
+/* Constants for jsimd_idct_islow_neon() */
+
+#define F_0_298   2446  /* FIX(0.298631336) */
+#define F_0_390   3196  /* FIX(0.390180644) */
+#define F_0_541   4433  /* FIX(0.541196100) */
+#define F_0_765   6270  /* FIX(0.765366865) */
+#define F_0_899   7373  /* FIX(0.899976223) */
+#define F_1_175   9633  /* FIX(1.175875602) */
+#define F_1_501  12299  /* FIX(1.501321110) */
+#define F_1_847  15137  /* FIX(1.847759065) */
+#define F_1_961  16069  /* FIX(1.961570560) */
+#define F_2_053  16819  /* FIX(2.053119869) */
+#define F_2_562  20995  /* FIX(2.562915447) */
+#define F_3_072  25172  /* FIX(3.072711026) */
+
+.balign 16
+Ljsimd_idct_islow_neon_consts:
+  .short F_0_298
+  .short -F_0_390
+  .short F_0_541
+  .short F_0_765
+  .short - F_0_899
+  .short F_1_175
+  .short F_1_501
+  .short - F_1_847
+  .short - F_1_961
+  .short F_2_053
+  .short - F_2_562
+  .short F_3_072
+  .short 0          /* padding */
+  .short 0
+  .short 0
+  .short 0
+
+#undef F_0_298
+#undef F_0_390
+#undef F_0_541
+#undef F_0_765
+#undef F_0_899
+#undef F_1_175
+#undef F_1_501
+#undef F_1_847
+#undef F_1_961
+#undef F_2_053
+#undef F_2_562
+#undef F_3_072
+
+/* Constants for jsimd_ycc_*_neon() */
+
+.balign 16
+Ljsimd_ycc_rgb_neon_consts:
+  .short 0,      0,     0,      0
+  .short 22971, -11277, -23401, 29033
+  .short -128,  -128,   -128,   -128
+  .short -128,  -128,   -128,   -128
+
+/* Constants for jsimd_*_ycc_neon() */
+
+.balign 16
+Ljsimd_rgb_ycc_neon_consts:
+  .short 19595, 38470, 7471, 11059
+  .short 21709, 32768, 27439, 5329
+  .short 32767, 128, 32767, 128
+  .short 32767, 128, 32767, 128
+
+/* Constants for jsimd_fdct_islow_neon() */
+
+#define F_0_298   2446  /* FIX(0.298631336) */
+#define F_0_390   3196  /* FIX(0.390180644) */
+#define F_0_541   4433  /* FIX(0.541196100) */
+#define F_0_765   6270  /* FIX(0.765366865) */
+#define F_0_899   7373  /* FIX(0.899976223) */
+#define F_1_175   9633  /* FIX(1.175875602) */
+#define F_1_501  12299  /* FIX(1.501321110) */
+#define F_1_847  15137  /* FIX(1.847759065) */
+#define F_1_961  16069  /* FIX(1.961570560) */
+#define F_2_053  16819  /* FIX(2.053119869) */
+#define F_2_562  20995  /* FIX(2.562915447) */
+#define F_3_072  25172  /* FIX(3.072711026) */
+
+.balign 16
+Ljsimd_fdct_islow_neon_consts:
+  .short F_0_298
+  .short -F_0_390
+  .short F_0_541
+  .short F_0_765
+  .short - F_0_899
+  .short F_1_175
+  .short F_1_501
+  .short - F_1_847
+  .short - F_1_961
+  .short F_2_053
+  .short - F_2_562
+  .short F_3_072
+  .short 0          /* padding */
+  .short 0
+  .short 0
+  .short 0
+
+#undef F_0_298
+#undef F_0_390
+#undef F_0_541
+#undef F_0_765
+#undef F_0_899
+#undef F_1_175
+#undef F_1_501
+#undef F_1_847
+#undef F_1_961
+#undef F_2_053
+#undef F_2_562
+#undef F_3_072
+
+/* Constants for jsimd_huff_encode_one_block_neon() */
+
+.balign 16
+Ljsimd_huff_encode_one_block_neon_consts:
+    .byte 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, \
+          0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80
+    .byte    0,   1,   2,   3,  16,  17,  32,  33, \
+            18,  19,   4,   5,   6,   7,  20,  21  /* L0 => L3 : 4 lines OK */
+    .byte   34,  35,  48,  49, 255, 255,  50,  51, \
+            36,  37,  22,  23,   8,   9,  10,  11  /* L0 => L3 : 4 lines OK */
+    .byte    8,   9,  22,  23,  36,  37,  50,  51, \
+           255, 255, 255, 255, 255, 255,  52,  53  /* L1 => L4 : 4 lines OK */
+    .byte   54,  55,  40,  41,  26,  27,  12,  13, \
+            14,  15,  28,  29,  42,  43,  56,  57  /* L0 => L3 : 4 lines OK */
+    .byte    6,   7,  20,  21,  34,  35,  48,  49, \
+            50,  51,  36,  37,  22,  23,   8,   9  /* L4 => L7 : 4 lines OK */
+    .byte   42,  43,  28,  29,  14,  15,  30,  31, \
+            44,  45,  58,  59, 255, 255, 255, 255  /* L1 => L4 : 4 lines OK */
+    .byte  255, 255, 255, 255,  56,  57,  42,  43, \
+            28,  29,  14,  15,  30,  31,  44,  45  /* L3 => L6 : 4 lines OK */
+    .byte   26,  27,  40,  41,  42,  43,  28,  29, \
+            14,  15,  30,  31,  44,  45,  46,  47  /* L5 => L7 : 3 lines OK */
+    .byte  255, 255, 255, 255,   0,   1, 255, 255, \
+           255, 255, 255, 255, 255, 255, 255, 255  /* L4 : 1 lines OK */
+    .byte  255, 255, 255, 255, 255, 255, 255, 255, \
+             0,   1,  16,  17,   2,   3, 255, 255  /* L5 => L6 : 2 lines OK */
+    .byte  255, 255, 255, 255, 255, 255, 255, 255, \
+           255, 255, 255, 255,   8,   9,  22,  23  /* L5 => L6 : 2 lines OK */
+    .byte    4,   5,   6,   7, 255, 255, 255, 255, \
+           255, 255, 255, 255, 255, 255, 255, 255  /* L7 : 1 line OK */
+
+
+/*****************************************************************************/
+
+/* Supplementary macro for setting function attributes */
+.macro asm_function fname
+#ifdef __APPLE__
+    .private_extern _\fname
+    .globl _\fname
+_\fname:
+#else
+    .global \fname
+#ifdef __ELF__
+    .hidden \fname
+    .type \fname, %function
+#endif
+\fname:
+#endif
+.endm
+
+/* Get symbol location */
+.macro get_symbol_loc reg, symbol
+#ifdef __APPLE__
+    adrp            \reg, \symbol@PAGE
+    add             \reg, \reg, \symbol@PAGEOFF
+#else
+    adrp            \reg, \symbol
+    add             \reg, \reg, :lo12:\symbol
+#endif
+.endm
+
+.macro transpose_8x8 l0, l1, l2, l3, l4, l5, l6, l7, t0, t1, t2, t3
+    trn1            \t0\().8h, \l0\().8h, \l1\().8h
+    trn1            \t1\().8h, \l2\().8h, \l3\().8h
+    trn1            \t2\().8h, \l4\().8h, \l5\().8h
+    trn1            \t3\().8h, \l6\().8h, \l7\().8h
+    trn2            \l1\().8h, \l0\().8h, \l1\().8h
+    trn2            \l3\().8h, \l2\().8h, \l3\().8h
+    trn2            \l5\().8h, \l4\().8h, \l5\().8h
+    trn2            \l7\().8h, \l6\().8h, \l7\().8h
+
+    trn1            \l4\().4s, \t2\().4s, \t3\().4s
+    trn2            \t3\().4s, \t2\().4s, \t3\().4s
+    trn1            \t2\().4s, \t0\().4s, \t1\().4s
+    trn2            \l2\().4s, \t0\().4s, \t1\().4s
+    trn1            \t0\().4s, \l1\().4s, \l3\().4s
+    trn2            \l3\().4s, \l1\().4s, \l3\().4s
+    trn2            \t1\().4s, \l5\().4s, \l7\().4s
+    trn1            \l5\().4s, \l5\().4s, \l7\().4s
+
+    trn2            \l6\().2d, \l2\().2d, \t3\().2d
+    trn1            \l0\().2d, \t2\().2d, \l4\().2d
+    trn1            \l1\().2d, \t0\().2d, \l5\().2d
+    trn2            \l7\().2d, \l3\().2d, \t1\().2d
+    trn1            \l2\().2d, \l2\().2d, \t3\().2d
+    trn2            \l4\().2d, \t2\().2d, \l4\().2d
+    trn1            \l3\().2d, \l3\().2d, \t1\().2d
+    trn2            \l5\().2d, \t0\().2d, \l5\().2d
+.endm
+
+
+#define CENTERJSAMPLE  128
+
+/*****************************************************************************/
+
+/*
+ * Perform dequantization and inverse DCT on one block of coefficients.
+ *
+ * GLOBAL(void)
+ * jsimd_idct_islow_neon(void *dct_table, JCOEFPTR coef_block,
+ *                       JSAMPARRAY output_buf, JDIMENSION output_col)
+ */
+
+#define CONST_BITS  13
+#define PASS1_BITS  2
+
+#define XFIX_P_0_298  v0.h[0]
+#define XFIX_N_0_390  v0.h[1]
+#define XFIX_P_0_541  v0.h[2]
+#define XFIX_P_0_765  v0.h[3]
+#define XFIX_N_0_899  v0.h[4]
+#define XFIX_P_1_175  v0.h[5]
+#define XFIX_P_1_501  v0.h[6]
+#define XFIX_N_1_847  v0.h[7]
+#define XFIX_N_1_961  v1.h[0]
+#define XFIX_P_2_053  v1.h[1]
+#define XFIX_N_2_562  v1.h[2]
+#define XFIX_P_3_072  v1.h[3]
+
+asm_function jsimd_idct_islow_neon
+    DCT_TABLE       .req x0
+    COEF_BLOCK      .req x1
+    OUTPUT_BUF      .req x2
+    OUTPUT_COL      .req x3
+    TMP1            .req x0
+    TMP2            .req x1
+    TMP3            .req x9
+    TMP4            .req x10
+    TMP5            .req x11
+    TMP6            .req x12
+    TMP7            .req x13
+    TMP8            .req x14
+
+    /* OUTPUT_COL is a JDIMENSION (unsigned int) argument, so the ABI doesn't
+       guarantee that the upper (unused) 32 bits of x3 are valid.  This
+       instruction ensures that those bits are set to zero. */
+    uxtw x3, w3
+
+    sub             sp, sp, #64
+    get_symbol_loc  x15, Ljsimd_idct_islow_neon_consts
+    mov             x10, sp
+    st1             {v8.8b, v9.8b, v10.8b, v11.8b}, [x10], #32
+    st1             {v12.8b, v13.8b, v14.8b, v15.8b}, [x10], #32
+    ld1             {v0.8h, v1.8h}, [x15]
+    ld1             {v2.8h, v3.8h, v4.8h, v5.8h}, [COEF_BLOCK], #64
+    ld1             {v18.8h, v19.8h, v20.8h, v21.8h}, [DCT_TABLE], #64
+    ld1             {v6.8h, v7.8h, v8.8h, v9.8h}, [COEF_BLOCK], #64
+    ld1             {v22.8h, v23.8h, v24.8h, v25.8h}, [DCT_TABLE], #64
+
+    cmeq            v16.8h, v3.8h, #0
+    cmeq            v26.8h, v4.8h, #0
+    cmeq            v27.8h, v5.8h, #0
+    cmeq            v28.8h, v6.8h, #0
+    cmeq            v29.8h, v7.8h, #0
+    cmeq            v30.8h, v8.8h, #0
+    cmeq            v31.8h, v9.8h, #0
+
+    and             v10.16b, v16.16b, v26.16b
+    and             v11.16b, v27.16b, v28.16b
+    and             v12.16b, v29.16b, v30.16b
+    and             v13.16b, v31.16b, v10.16b
+    and             v14.16b, v11.16b, v12.16b
+    mul             v2.8h, v2.8h, v18.8h
+    and             v15.16b, v13.16b, v14.16b
+    shl             v10.8h, v2.8h, #(PASS1_BITS)
+    sqxtn           v16.8b, v15.8h
+    mov             TMP1, v16.d[0]
+    mvn             TMP2, TMP1
+
+    cbnz            TMP2, 2f
+    /* case all AC coeffs are zeros */
+    dup             v2.2d, v10.d[0]
+    dup             v6.2d, v10.d[1]
+    mov             v3.16b, v2.16b
+    mov             v7.16b, v6.16b
+    mov             v4.16b, v2.16b
+    mov             v8.16b, v6.16b
+    mov             v5.16b, v2.16b
+    mov             v9.16b, v6.16b
+1:
+    /* for this transpose, we should organise data like this:
+     * 00, 01, 02, 03, 40, 41, 42, 43
+     * 10, 11, 12, 13, 50, 51, 52, 53
+     * 20, 21, 22, 23, 60, 61, 62, 63
+     * 30, 31, 32, 33, 70, 71, 72, 73
+     * 04, 05, 06, 07, 44, 45, 46, 47
+     * 14, 15, 16, 17, 54, 55, 56, 57
+     * 24, 25, 26, 27, 64, 65, 66, 67
+     * 34, 35, 36, 37, 74, 75, 76, 77
+     */
+    trn1            v28.8h, v2.8h, v3.8h
+    trn1            v29.8h, v4.8h, v5.8h
+    trn1            v30.8h, v6.8h, v7.8h
+    trn1            v31.8h, v8.8h, v9.8h
+    trn2            v16.8h, v2.8h, v3.8h
+    trn2            v17.8h, v4.8h, v5.8h
+    trn2            v18.8h, v6.8h, v7.8h
+    trn2            v19.8h, v8.8h, v9.8h
+    trn1            v2.4s, v28.4s, v29.4s
+    trn1            v6.4s, v30.4s, v31.4s
+    trn1            v3.4s, v16.4s, v17.4s
+    trn1            v7.4s, v18.4s, v19.4s
+    trn2            v4.4s, v28.4s, v29.4s
+    trn2            v8.4s, v30.4s, v31.4s
+    trn2            v5.4s, v16.4s, v17.4s
+    trn2            v9.4s, v18.4s, v19.4s
+    /* Even part: reverse the even part of the forward DCT. */
+    add             v18.8h, v4.8h, v8.8h           /* z2 + z3 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]) + DEQUANTIZE(inptr[DCTSIZE*6], quantptr[DCTSIZE*6]) */
+    add             v22.8h, v2.8h, v6.8h           /* z2 + z3 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]) + DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]) */
+    smull2          v19.4s, v18.8h, XFIX_P_0_541   /* z1h z1 = MULTIPLY(z2 + z3, FIX_0_541196100); */
+    sub             v26.8h, v2.8h, v6.8h           /* z2 - z3 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]) - DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]) */
+    smull           v18.4s, v18.4h, XFIX_P_0_541   /* z1l z1 = MULTIPLY(z2 + z3, FIX_0_541196100); */
+    sshll2          v23.4s, v22.8h, #(CONST_BITS)  /* tmp0h tmp0 = LEFT_SHIFT(z2 + z3, CONST_BITS); */
+    mov             v21.16b, v19.16b               /* tmp3 = z1 */
+    mov             v20.16b, v18.16b               /* tmp3 = z1 */
+    smlal2          v19.4s, v8.8h, XFIX_N_1_847    /* tmp2h tmp2 = z1 + MULTIPLY(z3, -FIX_1_847759065); */
+    smlal           v18.4s, v8.4h, XFIX_N_1_847    /* tmp2l tmp2 = z1 + MULTIPLY(z3, -FIX_1_847759065); */
+    sshll2          v27.4s, v26.8h, #(CONST_BITS)  /* tmp1h tmp1 = LEFT_SHIFT(z2 - z3, CONST_BITS); */
+    smlal2          v21.4s, v4.8h, XFIX_P_0_765    /* tmp3h tmp3 = z1 + MULTIPLY(z2, FIX_0_765366865); */
+    smlal           v20.4s, v4.4h, XFIX_P_0_765    /* tmp3l tmp3 = z1 + MULTIPLY(z2, FIX_0_765366865); */
+    sshll           v22.4s, v22.4h, #(CONST_BITS)  /* tmp0l tmp0 = LEFT_SHIFT(z2 + z3, CONST_BITS); */
+    sshll           v26.4s, v26.4h, #(CONST_BITS)  /* tmp1l tmp1 = LEFT_SHIFT(z2 - z3, CONST_BITS); */
+    add             v2.4s, v22.4s, v20.4s          /* tmp10l tmp10 = tmp0 + tmp3; */
+    sub             v6.4s, v22.4s, v20.4s          /* tmp13l tmp13 = tmp0 - tmp3; */
+    add             v8.4s, v26.4s, v18.4s          /* tmp11l tmp11 = tmp1 + tmp2; */
+    sub             v4.4s, v26.4s, v18.4s          /* tmp12l tmp12 = tmp1 - tmp2; */
+    add             v28.4s, v23.4s, v21.4s         /* tmp10h tmp10 = tmp0 + tmp3; */
+    sub             v31.4s, v23.4s, v21.4s         /* tmp13h tmp13 = tmp0 - tmp3; */
+    add             v29.4s, v27.4s, v19.4s         /* tmp11h tmp11 = tmp1 + tmp2; */
+    sub             v30.4s, v27.4s, v19.4s         /* tmp12h tmp12 = tmp1 - tmp2; */
+
+    /* Odd part per figure 8; the matrix is unitary and hence its
+     * transpose is its inverse.  i0..i3 are y7,y5,y3,y1 respectively.
+     */
+
+    add             v22.8h, v9.8h, v5.8h    /* z3 = tmp0 + tmp2 = DEQUANTIZE(inptr[DCTSIZE*7], quantptr[DCTSIZE*7]) + DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]) */
+    add             v24.8h, v7.8h, v3.8h    /* z4 = tmp1 + tmp3 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]) + DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]) */
+    add             v18.8h, v9.8h, v3.8h    /* z1 = tmp0 + tmp3 = DEQUANTIZE(inptr[DCTSIZE*7], quantptr[DCTSIZE*7]) + DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]) */
+    add             v20.8h, v7.8h, v5.8h    /* z2 = tmp1 + tmp2 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]) + DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]) */
+    add             v26.8h, v22.8h, v24.8h  /* z5 = z3 + z4 */
+
+    smull2          v11.4s, v9.8h, XFIX_P_0_298   /* tmp0 = MULTIPLY(tmp0, FIX_0_298631336) */
+    smull2          v13.4s, v7.8h, XFIX_P_2_053   /* tmp1 = MULTIPLY(tmp1, FIX_2_053119869) */
+    smull2          v15.4s, v5.8h, XFIX_P_3_072   /* tmp2 = MULTIPLY(tmp2, FIX_3_072711026) */
+    smull2          v17.4s, v3.8h, XFIX_P_1_501   /* tmp3 = MULTIPLY(tmp3, FIX_1_501321110) */
+    smull2          v27.4s, v26.8h, XFIX_P_1_175  /* z5h z5 = MULTIPLY(z3 + z4, FIX_1_175875602) */
+    smull2          v23.4s, v22.8h, XFIX_N_1_961  /* z3 = MULTIPLY(z3, -FIX_1_961570560) */
+    smull2          v25.4s, v24.8h, XFIX_N_0_390  /* z4 = MULTIPLY(z4, -FIX_0_390180644) */
+    smull2          v19.4s, v18.8h, XFIX_N_0_899  /* z1 = MULTIPLY(z1, -FIX_0_899976223) */
+    smull2          v21.4s, v20.8h, XFIX_N_2_562  /* z2 = MULTIPLY(z2, -FIX_2_562915447) */
+
+    smull           v10.4s, v9.4h, XFIX_P_0_298   /* tmp0 = MULTIPLY(tmp0, FIX_0_298631336) */
+    smull           v12.4s, v7.4h, XFIX_P_2_053   /* tmp1 = MULTIPLY(tmp1, FIX_2_053119869) */
+    smull           v14.4s, v5.4h, XFIX_P_3_072   /* tmp2 = MULTIPLY(tmp2, FIX_3_072711026) */
+    smull           v16.4s, v3.4h, XFIX_P_1_501   /* tmp3 = MULTIPLY(tmp3, FIX_1_501321110) */
+    smull           v26.4s, v26.4h, XFIX_P_1_175  /* z5l z5 = MULTIPLY(z3 + z4, FIX_1_175875602) */
+    smull           v22.4s, v22.4h, XFIX_N_1_961  /* z3 = MULTIPLY(z3, -FIX_1_961570560) */
+    smull           v24.4s, v24.4h, XFIX_N_0_390  /* z4 = MULTIPLY(z4, -FIX_0_390180644) */
+    smull           v18.4s, v18.4h, XFIX_N_0_899  /* z1 = MULTIPLY(z1, -FIX_0_899976223) */
+    smull           v20.4s, v20.4h, XFIX_N_2_562  /* z2 = MULTIPLY(z2, -FIX_2_562915447) */
+
+    add             v23.4s, v23.4s, v27.4s  /* z3 += z5 */
+    add             v22.4s, v22.4s, v26.4s  /* z3 += z5 */
+    add             v25.4s, v25.4s, v27.4s  /* z4 += z5 */
+    add             v24.4s, v24.4s, v26.4s  /* z4 += z5 */
+
+    add             v11.4s, v11.4s, v19.4s  /* tmp0 += z1 */
+    add             v10.4s, v10.4s, v18.4s  /* tmp0 += z1 */
+    add             v13.4s, v13.4s, v21.4s  /* tmp1 += z2 */
+    add             v12.4s, v12.4s, v20.4s  /* tmp1 += z2 */
+    add             v15.4s, v15.4s, v21.4s  /* tmp2 += z2 */
+    add             v14.4s, v14.4s, v20.4s  /* tmp2 += z2 */
+    add             v17.4s, v17.4s, v19.4s  /* tmp3 += z1 */
+    add             v16.4s, v16.4s, v18.4s  /* tmp3 += z1 */
+
+    add             v11.4s, v11.4s, v23.4s  /* tmp0 += z3 */
+    add             v10.4s, v10.4s, v22.4s  /* tmp0 += z3 */
+    add             v13.4s, v13.4s, v25.4s  /* tmp1 += z4 */
+    add             v12.4s, v12.4s, v24.4s  /* tmp1 += z4 */
+    add             v17.4s, v17.4s, v25.4s  /* tmp3 += z4 */
+    add             v16.4s, v16.4s, v24.4s  /* tmp3 += z4 */
+    add             v15.4s, v15.4s, v23.4s  /* tmp2 += z3 */
+    add             v14.4s, v14.4s, v22.4s  /* tmp2 += z3 */
+
+    /* Final output stage: inputs are tmp10..tmp13, tmp0..tmp3 */
+
+    add             v18.4s, v2.4s, v16.4s   /* tmp10 + tmp3 */
+    add             v19.4s, v28.4s, v17.4s  /* tmp10 + tmp3 */
+    sub             v20.4s, v2.4s, v16.4s   /* tmp10 - tmp3 */
+    sub             v21.4s, v28.4s, v17.4s  /* tmp10 - tmp3 */
+    add             v22.4s, v8.4s, v14.4s   /* tmp11 + tmp2 */
+    add             v23.4s, v29.4s, v15.4s  /* tmp11 + tmp2 */
+    sub             v24.4s, v8.4s, v14.4s   /* tmp11 - tmp2 */
+    sub             v25.4s, v29.4s, v15.4s  /* tmp11 - tmp2 */
+    add             v26.4s, v4.4s, v12.4s   /* tmp12 + tmp1 */
+    add             v27.4s, v30.4s, v13.4s  /* tmp12 + tmp1 */
+    sub             v28.4s, v4.4s, v12.4s   /* tmp12 - tmp1 */
+    sub             v29.4s, v30.4s, v13.4s  /* tmp12 - tmp1 */
+    add             v14.4s, v6.4s, v10.4s   /* tmp13 + tmp0 */
+    add             v15.4s, v31.4s, v11.4s  /* tmp13 + tmp0 */
+    sub             v16.4s, v6.4s, v10.4s   /* tmp13 - tmp0 */
+    sub             v17.4s, v31.4s, v11.4s  /* tmp13 - tmp0 */
+
+    shrn            v2.4h, v18.4s, #16  /* wsptr[DCTSIZE*0] = (int)DESCALE(tmp10 + tmp3, CONST_BITS+PASS1_BITS+3) */
+    shrn            v9.4h, v20.4s, #16  /* wsptr[DCTSIZE*7] = (int)DESCALE(tmp10 - tmp3, CONST_BITS+PASS1_BITS+3) */
+    shrn            v3.4h, v22.4s, #16  /* wsptr[DCTSIZE*1] = (int)DESCALE(tmp11 + tmp2, CONST_BITS+PASS1_BITS+3) */
+    shrn            v8.4h, v24.4s, #16  /* wsptr[DCTSIZE*6] = (int)DESCALE(tmp11 - tmp2, CONST_BITS+PASS1_BITS+3) */
+    shrn            v4.4h, v26.4s, #16  /* wsptr[DCTSIZE*2] = (int)DESCALE(tmp12 + tmp1, CONST_BITS+PASS1_BITS+3) */
+    shrn            v7.4h, v28.4s, #16  /* wsptr[DCTSIZE*5] = (int)DESCALE(tmp12 - tmp1, CONST_BITS+PASS1_BITS+3) */
+    shrn            v5.4h, v14.4s, #16  /* wsptr[DCTSIZE*3] = (int)DESCALE(tmp13 + tmp0, CONST_BITS+PASS1_BITS+3) */
+    shrn            v6.4h, v16.4s, #16  /* wsptr[DCTSIZE*4] = (int)DESCALE(tmp13 - tmp0, CONST_BITS+PASS1_BITS+3) */
+    shrn2           v2.8h, v19.4s, #16  /* wsptr[DCTSIZE*0] = (int)DESCALE(tmp10 + tmp3, CONST_BITS+PASS1_BITS+3) */
+    shrn2           v9.8h, v21.4s, #16  /* wsptr[DCTSIZE*7] = (int)DESCALE(tmp10 - tmp3, CONST_BITS+PASS1_BITS+3) */
+    shrn2           v3.8h, v23.4s, #16  /* wsptr[DCTSIZE*1] = (int)DESCALE(tmp11 + tmp2, CONST_BITS+PASS1_BITS+3) */
+    shrn2           v8.8h, v25.4s, #16  /* wsptr[DCTSIZE*6] = (int)DESCALE(tmp11 - tmp2, CONST_BITS+PASS1_BITS+3) */
+    shrn2           v4.8h, v27.4s, #16  /* wsptr[DCTSIZE*2] = (int)DESCALE(tmp12 + tmp1, CONST_BITS+PASS1_BITS+3) */
+    shrn2           v7.8h, v29.4s, #16  /* wsptr[DCTSIZE*5] = (int)DESCALE(tmp12 - tmp1, CONST_BITS+PASS1_BITS+3) */
+    shrn2           v5.8h, v15.4s, #16  /* wsptr[DCTSIZE*3] = (int)DESCALE(tmp13 + tmp0, CONST_BITS+PASS1_BITS+3) */
+    shrn2           v6.8h, v17.4s, #16  /* wsptr[DCTSIZE*4] = (int)DESCALE(tmp13 - tmp0, CONST_BITS+PASS1_BITS+3) */
+    movi            v0.16b, #(CENTERJSAMPLE)
+    /* Prepare pointers (dual-issue with Neon instructions) */
+      ldp             TMP1, TMP2, [OUTPUT_BUF], 16
+    sqrshrn         v28.8b, v2.8h, #(CONST_BITS + PASS1_BITS + 3 - 16)
+      ldp             TMP3, TMP4, [OUTPUT_BUF], 16
+    sqrshrn         v29.8b, v3.8h, #(CONST_BITS + PASS1_BITS + 3 - 16)
+      add             TMP1, TMP1, OUTPUT_COL
+    sqrshrn         v30.8b, v4.8h, #(CONST_BITS + PASS1_BITS + 3 - 16)
+      add             TMP2, TMP2, OUTPUT_COL
+    sqrshrn         v31.8b, v5.8h, #(CONST_BITS + PASS1_BITS + 3 - 16)
+      add             TMP3, TMP3, OUTPUT_COL
+    sqrshrn2        v28.16b, v6.8h, #(CONST_BITS + PASS1_BITS + 3 - 16)
+      add             TMP4, TMP4, OUTPUT_COL
+    sqrshrn2        v29.16b, v7.8h, #(CONST_BITS + PASS1_BITS + 3 - 16)
+      ldp             TMP5, TMP6, [OUTPUT_BUF], 16
+    sqrshrn2        v30.16b, v8.8h, #(CONST_BITS + PASS1_BITS + 3 - 16)
+      ldp             TMP7, TMP8, [OUTPUT_BUF], 16
+    sqrshrn2        v31.16b, v9.8h, #(CONST_BITS + PASS1_BITS + 3 - 16)
+      add             TMP5, TMP5, OUTPUT_COL
+    add             v16.16b, v28.16b, v0.16b
+      add             TMP6, TMP6, OUTPUT_COL
+    add             v18.16b, v29.16b, v0.16b
+      add             TMP7, TMP7, OUTPUT_COL
+    add             v20.16b, v30.16b, v0.16b
+      add             TMP8, TMP8, OUTPUT_COL
+    add             v22.16b, v31.16b, v0.16b
+
+    /* Transpose the final 8-bit samples */
+    trn1            v28.16b, v16.16b, v18.16b
+    trn1            v30.16b, v20.16b, v22.16b
+    trn2            v29.16b, v16.16b, v18.16b
+    trn2            v31.16b, v20.16b, v22.16b
+
+    trn1            v16.8h, v28.8h, v30.8h
+    trn2            v18.8h, v28.8h, v30.8h
+    trn1            v20.8h, v29.8h, v31.8h
+    trn2            v22.8h, v29.8h, v31.8h
+
+    uzp1            v28.4s, v16.4s, v18.4s
+    uzp2            v30.4s, v16.4s, v18.4s
+    uzp1            v29.4s, v20.4s, v22.4s
+    uzp2            v31.4s, v20.4s, v22.4s
+
+    /* Store results to the output buffer */
+    st1             {v28.d}[0], [TMP1]
+    st1             {v29.d}[0], [TMP2]
+    st1             {v28.d}[1], [TMP3]
+    st1             {v29.d}[1], [TMP4]
+    st1             {v30.d}[0], [TMP5]
+    st1             {v31.d}[0], [TMP6]
+    st1             {v30.d}[1], [TMP7]
+    st1             {v31.d}[1], [TMP8]
+    ld1             {v8.8b, v9.8b, v10.8b, v11.8b}, [sp], #32
+    ld1             {v12.8b, v13.8b, v14.8b, v15.8b}, [sp], #32
+    blr             x30
+
+.balign 16
+2:
+    mul             v3.8h, v3.8h, v19.8h
+    mul             v4.8h, v4.8h, v20.8h
+    mul             v5.8h, v5.8h, v21.8h
+    add             TMP4, xzr, TMP2, LSL #32
+    mul             v6.8h, v6.8h, v22.8h
+    mul             v7.8h, v7.8h, v23.8h
+    adds            TMP3, xzr, TMP2, LSR #32
+    mul             v8.8h, v8.8h, v24.8h
+    mul             v9.8h, v9.8h, v25.8h
+    b.ne            3f
+    /* Right AC coef is zero */
+    dup             v15.2d, v10.d[1]
+    /* Even part: reverse the even part of the forward DCT. */
+    add             v18.4h, v4.4h, v8.4h           /* z2 + z3 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]) + DEQUANTIZE(inptr[DCTSIZE*6], quantptr[DCTSIZE*6]) */
+    add             v22.4h, v2.4h, v6.4h           /* z2 + z3 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]) + DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]) */
+    sub             v26.4h, v2.4h, v6.4h           /* z2 - z3 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]) - DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]) */
+    smull           v18.4s, v18.4h, XFIX_P_0_541   /* z1l z1 = MULTIPLY(z2 + z3, FIX_0_541196100); */
+    sshll           v22.4s, v22.4h, #(CONST_BITS)  /* tmp0l tmp0 = LEFT_SHIFT(z2 + z3, CONST_BITS); */
+    mov             v20.16b, v18.16b               /* tmp3 = z1 */
+    sshll           v26.4s, v26.4h, #(CONST_BITS)  /* tmp1l tmp1 = LEFT_SHIFT(z2 - z3, CONST_BITS); */
+    smlal           v18.4s, v8.4h, XFIX_N_1_847    /* tmp2l tmp2 = z1 + MULTIPLY(z3, -FIX_1_847759065); */
+    smlal           v20.4s, v4.4h, XFIX_P_0_765    /* tmp3l tmp3 = z1 + MULTIPLY(z2, FIX_0_765366865); */
+    add             v2.4s, v22.4s, v20.4s          /* tmp10l tmp10 = tmp0 + tmp3; */
+    sub             v6.4s, v22.4s, v20.4s          /* tmp13l tmp13 = tmp0 - tmp3; */
+    add             v8.4s, v26.4s, v18.4s          /* tmp11l tmp11 = tmp1 + tmp2; */
+    sub             v4.4s, v26.4s, v18.4s          /* tmp12l tmp12 = tmp1 - tmp2; */
+
+    /* Odd part per figure 8; the matrix is unitary and hence its
+     * transpose is its inverse.  i0..i3 are y7,y5,y3,y1 respectively.
+     */
+
+    add             v22.4h, v9.4h, v5.4h    /* z3 = tmp0 + tmp2 = DEQUANTIZE(inptr[DCTSIZE*7], quantptr[DCTSIZE*7]) + DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]) */
+    add             v24.4h, v7.4h, v3.4h    /* z4 = tmp1 + tmp3 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]) + DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]) */
+    add             v18.4h, v9.4h, v3.4h    /* z1 = tmp0 + tmp3 = DEQUANTIZE(inptr[DCTSIZE*7], quantptr[DCTSIZE*7]) + DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]) */
+    add             v20.4h, v7.4h, v5.4h    /* z2 = tmp1 + tmp2 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]) + DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]) */
+    add             v26.4h, v22.4h, v24.4h  /* z5 = z3 + z4 */
+
+    smull           v10.4s, v9.4h, XFIX_P_0_298   /* tmp0 = MULTIPLY(tmp0, FIX_0_298631336) */
+    smull           v12.4s, v7.4h, XFIX_P_2_053   /* tmp1 = MULTIPLY(tmp1, FIX_2_053119869) */
+    smull           v14.4s, v5.4h, XFIX_P_3_072   /* tmp2 = MULTIPLY(tmp2, FIX_3_072711026) */
+    smull           v16.4s, v3.4h, XFIX_P_1_501   /* tmp3 = MULTIPLY(tmp3, FIX_1_501321110) */
+    smull           v26.4s, v26.4h, XFIX_P_1_175  /* z5l z5 = MULTIPLY(z3 + z4, FIX_1_175875602) */
+    smull           v22.4s, v22.4h, XFIX_N_1_961  /* z3 = MULTIPLY(z3, -FIX_1_961570560) */
+    smull           v24.4s, v24.4h, XFIX_N_0_390  /* z4 = MULTIPLY(z4, -FIX_0_390180644) */
+    smull           v18.4s, v18.4h, XFIX_N_0_899  /* z1 = MULTIPLY(z1, -FIX_0_899976223) */
+    smull           v20.4s, v20.4h, XFIX_N_2_562  /* z2 = MULTIPLY(z2, -FIX_2_562915447) */
+
+    add             v22.4s, v22.4s, v26.4s  /* z3 += z5 */
+    add             v24.4s, v24.4s, v26.4s  /* z4 += z5 */
+
+    add             v10.4s, v10.4s, v18.4s  /* tmp0 += z1 */
+    add             v12.4s, v12.4s, v20.4s  /* tmp1 += z2 */
+    add             v14.4s, v14.4s, v20.4s  /* tmp2 += z2 */
+    add             v16.4s, v16.4s, v18.4s  /* tmp3 += z1 */
+
+    add             v10.4s, v10.4s, v22.4s  /* tmp0 += z3 */
+    add             v12.4s, v12.4s, v24.4s  /* tmp1 += z4 */
+    add             v16.4s, v16.4s, v24.4s  /* tmp3 += z4 */
+    add             v14.4s, v14.4s, v22.4s  /* tmp2 += z3 */
+
+    /* Final output stage: inputs are tmp10..tmp13, tmp0..tmp3 */
+
+    add             v18.4s, v2.4s, v16.4s  /* tmp10 + tmp3 */
+    sub             v20.4s, v2.4s, v16.4s  /* tmp10 - tmp3 */
+    add             v22.4s, v8.4s, v14.4s  /* tmp11 + tmp2 */
+    sub             v24.4s, v8.4s, v14.4s  /* tmp11 - tmp2 */
+    add             v26.4s, v4.4s, v12.4s  /* tmp12 + tmp1 */
+    sub             v28.4s, v4.4s, v12.4s  /* tmp12 - tmp1 */
+    add             v14.4s, v6.4s, v10.4s  /* tmp13 + tmp0 */
+    sub             v16.4s, v6.4s, v10.4s  /* tmp13 - tmp0 */
+
+    rshrn           v2.4h, v18.4s, #(CONST_BITS - PASS1_BITS)  /* wsptr[DCTSIZE*0] = (int)DESCALE(tmp10 + tmp3, CONST_BITS-PASS1_BITS) */
+    rshrn           v3.4h, v22.4s, #(CONST_BITS - PASS1_BITS)  /* wsptr[DCTSIZE*1] = (int)DESCALE(tmp11 + tmp2, CONST_BITS-PASS1_BITS) */
+    rshrn           v4.4h, v26.4s, #(CONST_BITS - PASS1_BITS)  /* wsptr[DCTSIZE*2] = (int)DESCALE(tmp12 + tmp1, CONST_BITS-PASS1_BITS) */
+    rshrn           v5.4h, v14.4s, #(CONST_BITS - PASS1_BITS)  /* wsptr[DCTSIZE*3] = (int)DESCALE(tmp13 + tmp0, CONST_BITS-PASS1_BITS) */
+    rshrn2          v2.8h, v16.4s, #(CONST_BITS - PASS1_BITS)  /* wsptr[DCTSIZE*4] = (int)DESCALE(tmp13 - tmp0, CONST_BITS-PASS1_BITS) */
+    rshrn2          v3.8h, v28.4s, #(CONST_BITS - PASS1_BITS)  /* wsptr[DCTSIZE*5] = (int)DESCALE(tmp12 - tmp1, CONST_BITS-PASS1_BITS) */
+    rshrn2          v4.8h, v24.4s, #(CONST_BITS - PASS1_BITS)  /* wsptr[DCTSIZE*6] = (int)DESCALE(tmp11 - tmp2, CONST_BITS-PASS1_BITS) */
+    rshrn2          v5.8h, v20.4s, #(CONST_BITS - PASS1_BITS)  /* wsptr[DCTSIZE*7] = (int)DESCALE(tmp10 - tmp3, CONST_BITS-PASS1_BITS) */
+    mov             v6.16b, v15.16b
+    mov             v7.16b, v15.16b
+    mov             v8.16b, v15.16b
+    mov             v9.16b, v15.16b
+    b               1b
+
+.balign 16
+3:
+    cbnz            TMP4, 4f
+    /* Left AC coef is zero */
+    dup             v14.2d, v10.d[0]
+    /* Even part: reverse the even part of the forward DCT. */
+    add             v18.8h, v4.8h, v8.8h           /* z2 + z3 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]) + DEQUANTIZE(inptr[DCTSIZE*6], quantptr[DCTSIZE*6]) */
+    add             v22.8h, v2.8h, v6.8h           /* z2 + z3 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]) + DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]) */
+    smull2          v19.4s, v18.8h, XFIX_P_0_541   /* z1h z1 = MULTIPLY(z2 + z3, FIX_0_541196100); */
+    sub             v26.8h, v2.8h, v6.8h           /* z2 - z3 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]) - DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]) */
+    sshll2          v23.4s, v22.8h, #(CONST_BITS)  /* tmp0h tmp0 = LEFT_SHIFT(z2 + z3, CONST_BITS); */
+    mov             v21.16b, v19.16b               /* tmp3 = z1 */
+    smlal2          v19.4s, v8.8h, XFIX_N_1_847    /* tmp2h tmp2 = z1 + MULTIPLY(z3, -FIX_1_847759065); */
+    sshll2          v27.4s, v26.8h, #(CONST_BITS)  /* tmp1h tmp1 = LEFT_SHIFT(z2 - z3, CONST_BITS); */
+    smlal2          v21.4s, v4.8h, XFIX_P_0_765    /* tmp3h tmp3 = z1 + MULTIPLY(z2, FIX_0_765366865); */
+    add             v28.4s, v23.4s, v21.4s         /* tmp10h tmp10 = tmp0 + tmp3; */
+    sub             v31.4s, v23.4s, v21.4s         /* tmp13h tmp13 = tmp0 - tmp3; */
+    add             v29.4s, v27.4s, v19.4s         /* tmp11h tmp11 = tmp1 + tmp2; */
+    sub             v30.4s, v27.4s, v19.4s         /* tmp12h tmp12 = tmp1 - tmp2; */
+
+    /* Odd part per figure 8; the matrix is unitary and hence its
+     * transpose is its inverse.  i0..i3 are y7,y5,y3,y1 respectively.
+     */
+
+    add             v22.8h, v9.8h, v5.8h    /* z3 = tmp0 + tmp2 = DEQUANTIZE(inptr[DCTSIZE*7], quantptr[DCTSIZE*7]) + DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]) */
+    add             v24.8h, v7.8h, v3.8h    /* z4 = tmp1 + tmp3 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]) + DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]) */
+    add             v18.8h, v9.8h, v3.8h    /* z1 = tmp0 + tmp3 = DEQUANTIZE(inptr[DCTSIZE*7], quantptr[DCTSIZE*7]) + DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]) */
+    add             v20.8h, v7.8h, v5.8h    /* z2 = tmp1 + tmp2 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]) + DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]) */
+    add             v26.8h, v22.8h, v24.8h  /* z5 = z3 + z4 */
+
+    smull2          v11.4s, v9.8h, XFIX_P_0_298   /* tmp0 = MULTIPLY(tmp0, FIX_0_298631336) */
+    smull2          v13.4s, v7.8h, XFIX_P_2_053   /* tmp1 = MULTIPLY(tmp1, FIX_2_053119869) */
+    smull2          v15.4s, v5.8h, XFIX_P_3_072   /* tmp2 = MULTIPLY(tmp2, FIX_3_072711026) */
+    smull2          v17.4s, v3.8h, XFIX_P_1_501   /* tmp3 = MULTIPLY(tmp3, FIX_1_501321110) */
+    smull2          v27.4s, v26.8h, XFIX_P_1_175  /* z5h z5 = MULTIPLY(z3 + z4, FIX_1_175875602) */
+    smull2          v23.4s, v22.8h, XFIX_N_1_961  /* z3 = MULTIPLY(z3, -FIX_1_961570560) */
+    smull2          v25.4s, v24.8h, XFIX_N_0_390  /* z4 = MULTIPLY(z4, -FIX_0_390180644) */
+    smull2          v19.4s, v18.8h, XFIX_N_0_899  /* z1 = MULTIPLY(z1, -FIX_0_899976223) */
+    smull2          v21.4s, v20.8h, XFIX_N_2_562  /* z2 = MULTIPLY(z2, -FIX_2_562915447) */
+
+    add             v23.4s, v23.4s, v27.4s  /* z3 += z5 */
+    add             v22.4s, v22.4s, v26.4s  /* z3 += z5 */
+    add             v25.4s, v25.4s, v27.4s  /* z4 += z5 */
+    add             v24.4s, v24.4s, v26.4s  /* z4 += z5 */
+
+    add             v11.4s, v11.4s, v19.4s  /* tmp0 += z1 */
+    add             v13.4s, v13.4s, v21.4s  /* tmp1 += z2 */
+    add             v15.4s, v15.4s, v21.4s  /* tmp2 += z2 */
+    add             v17.4s, v17.4s, v19.4s  /* tmp3 += z1 */
+
+    add             v11.4s, v11.4s, v23.4s  /* tmp0 += z3 */
+    add             v13.4s, v13.4s, v25.4s  /* tmp1 += z4 */
+    add             v17.4s, v17.4s, v25.4s  /* tmp3 += z4 */
+    add             v15.4s, v15.4s, v23.4s  /* tmp2 += z3 */
+
+    /* Final output stage: inputs are tmp10..tmp13, tmp0..tmp3 */
+
+    add             v19.4s, v28.4s, v17.4s  /* tmp10 + tmp3 */
+    sub             v21.4s, v28.4s, v17.4s  /* tmp10 - tmp3 */
+    add             v23.4s, v29.4s, v15.4s  /* tmp11 + tmp2 */
+    sub             v25.4s, v29.4s, v15.4s  /* tmp11 - tmp2 */
+    add             v27.4s, v30.4s, v13.4s  /* tmp12 + tmp1 */
+    sub             v29.4s, v30.4s, v13.4s  /* tmp12 - tmp1 */
+    add             v15.4s, v31.4s, v11.4s  /* tmp13 + tmp0 */
+    sub             v17.4s, v31.4s, v11.4s  /* tmp13 - tmp0 */
+
+    mov             v2.16b, v14.16b
+    mov             v3.16b, v14.16b
+    mov             v4.16b, v14.16b
+    mov             v5.16b, v14.16b
+    rshrn           v6.4h, v19.4s, #(CONST_BITS - PASS1_BITS)  /* wsptr[DCTSIZE*0] = (int)DESCALE(tmp10 + tmp3, CONST_BITS-PASS1_BITS) */
+    rshrn           v7.4h, v23.4s, #(CONST_BITS - PASS1_BITS)  /* wsptr[DCTSIZE*1] = (int)DESCALE(tmp11 + tmp2, CONST_BITS-PASS1_BITS) */
+    rshrn           v8.4h, v27.4s, #(CONST_BITS - PASS1_BITS)  /* wsptr[DCTSIZE*2] = (int)DESCALE(tmp12 + tmp1, CONST_BITS-PASS1_BITS) */
+    rshrn           v9.4h, v15.4s, #(CONST_BITS - PASS1_BITS)  /* wsptr[DCTSIZE*3] = (int)DESCALE(tmp13 + tmp0, CONST_BITS-PASS1_BITS) */
+    rshrn2          v6.8h, v17.4s, #(CONST_BITS - PASS1_BITS)  /* wsptr[DCTSIZE*4] = (int)DESCALE(tmp13 - tmp0, CONST_BITS-PASS1_BITS) */
+    rshrn2          v7.8h, v29.4s, #(CONST_BITS - PASS1_BITS)  /* wsptr[DCTSIZE*5] = (int)DESCALE(tmp12 - tmp1, CONST_BITS-PASS1_BITS) */
+    rshrn2          v8.8h, v25.4s, #(CONST_BITS - PASS1_BITS)  /* wsptr[DCTSIZE*6] = (int)DESCALE(tmp11 - tmp2, CONST_BITS-PASS1_BITS) */
+    rshrn2          v9.8h, v21.4s, #(CONST_BITS - PASS1_BITS)  /* wsptr[DCTSIZE*7] = (int)DESCALE(tmp10 - tmp3, CONST_BITS-PASS1_BITS) */
+    b               1b
+
+.balign 16
+4:
+    /* "No" AC coef is zero */
+    /* Even part: reverse the even part of the forward DCT. */
+    add             v18.8h, v4.8h, v8.8h           /* z2 + z3 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]) + DEQUANTIZE(inptr[DCTSIZE*6], quantptr[DCTSIZE*6]) */
+    add             v22.8h, v2.8h, v6.8h           /* z2 + z3 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]) + DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]) */
+    smull2          v19.4s, v18.8h, XFIX_P_0_541   /* z1h z1 = MULTIPLY(z2 + z3, FIX_0_541196100); */
+    sub             v26.8h, v2.8h, v6.8h           /* z2 - z3 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]) - DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]) */
+    smull           v18.4s, v18.4h, XFIX_P_0_541   /* z1l z1 = MULTIPLY(z2 + z3, FIX_0_541196100); */
+    sshll2          v23.4s, v22.8h, #(CONST_BITS)  /* tmp0h tmp0 = LEFT_SHIFT(z2 + z3, CONST_BITS); */
+    mov             v21.16b, v19.16b               /* tmp3 = z1 */
+    mov             v20.16b, v18.16b               /* tmp3 = z1 */
+    smlal2          v19.4s, v8.8h, XFIX_N_1_847    /* tmp2h tmp2 = z1 + MULTIPLY(z3, -FIX_1_847759065); */
+    smlal           v18.4s, v8.4h, XFIX_N_1_847    /* tmp2l tmp2 = z1 + MULTIPLY(z3, -FIX_1_847759065); */
+    sshll2          v27.4s, v26.8h, #(CONST_BITS)  /* tmp1h tmp1 = LEFT_SHIFT(z2 - z3, CONST_BITS); */
+    smlal2          v21.4s, v4.8h, XFIX_P_0_765    /* tmp3h tmp3 = z1 + MULTIPLY(z2, FIX_0_765366865); */
+    smlal           v20.4s, v4.4h, XFIX_P_0_765    /* tmp3l tmp3 = z1 + MULTIPLY(z2, FIX_0_765366865); */
+    sshll           v22.4s, v22.4h, #(CONST_BITS)  /* tmp0l tmp0 = LEFT_SHIFT(z2 + z3, CONST_BITS); */
+    sshll           v26.4s, v26.4h, #(CONST_BITS)  /* tmp1l tmp1 = LEFT_SHIFT(z2 - z3, CONST_BITS); */
+    add             v2.4s, v22.4s, v20.4s          /* tmp10l tmp10 = tmp0 + tmp3; */
+    sub             v6.4s, v22.4s, v20.4s          /* tmp13l tmp13 = tmp0 - tmp3; */
+    add             v8.4s, v26.4s, v18.4s          /* tmp11l tmp11 = tmp1 + tmp2; */
+    sub             v4.4s, v26.4s, v18.4s          /* tmp12l tmp12 = tmp1 - tmp2; */
+    add             v28.4s, v23.4s, v21.4s         /* tmp10h tmp10 = tmp0 + tmp3; */
+    sub             v31.4s, v23.4s, v21.4s         /* tmp13h tmp13 = tmp0 - tmp3; */
+    add             v29.4s, v27.4s, v19.4s         /* tmp11h tmp11 = tmp1 + tmp2; */
+    sub             v30.4s, v27.4s, v19.4s         /* tmp12h tmp12 = tmp1 - tmp2; */
+
+    /* Odd part per figure 8; the matrix is unitary and hence its
+     * transpose is its inverse.  i0..i3 are y7,y5,y3,y1 respectively.
+     */
+
+    add             v22.8h, v9.8h, v5.8h    /* z3 = tmp0 + tmp2 = DEQUANTIZE(inptr[DCTSIZE*7], quantptr[DCTSIZE*7]) + DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]) */
+    add             v24.8h, v7.8h, v3.8h    /* z4 = tmp1 + tmp3 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]) + DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]) */
+    add             v18.8h, v9.8h, v3.8h    /* z1 = tmp0 + tmp3 = DEQUANTIZE(inptr[DCTSIZE*7], quantptr[DCTSIZE*7]) + DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]) */
+    add             v20.8h, v7.8h, v5.8h    /* z2 = tmp1 + tmp2 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]) + DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]) */
+    add             v26.8h, v22.8h, v24.8h  /* z5 = z3 + z4 */
+
+    smull2          v11.4s, v9.8h, XFIX_P_0_298   /* tmp0 = MULTIPLY(tmp0, FIX_0_298631336) */
+    smull2          v13.4s, v7.8h, XFIX_P_2_053   /* tmp1 = MULTIPLY(tmp1, FIX_2_053119869) */
+    smull2          v15.4s, v5.8h, XFIX_P_3_072   /* tmp2 = MULTIPLY(tmp2, FIX_3_072711026) */
+    smull2          v17.4s, v3.8h, XFIX_P_1_501   /* tmp3 = MULTIPLY(tmp3, FIX_1_501321110) */
+    smull2          v27.4s, v26.8h, XFIX_P_1_175  /* z5h z5 = MULTIPLY(z3 + z4, FIX_1_175875602) */
+    smull2          v23.4s, v22.8h, XFIX_N_1_961  /* z3 = MULTIPLY(z3, -FIX_1_961570560) */
+    smull2          v25.4s, v24.8h, XFIX_N_0_390  /* z4 = MULTIPLY(z4, -FIX_0_390180644) */
+    smull2          v19.4s, v18.8h, XFIX_N_0_899  /* z1 = MULTIPLY(z1, -FIX_0_899976223) */
+    smull2          v21.4s, v20.8h, XFIX_N_2_562  /* z2 = MULTIPLY(z2, -FIX_2_562915447) */
+
+    smull           v10.4s, v9.4h, XFIX_P_0_298   /* tmp0 = MULTIPLY(tmp0, FIX_0_298631336) */
+    smull           v12.4s, v7.4h, XFIX_P_2_053   /* tmp1 = MULTIPLY(tmp1, FIX_2_053119869) */
+    smull           v14.4s, v5.4h, XFIX_P_3_072   /* tmp2 = MULTIPLY(tmp2, FIX_3_072711026) */
+    smull           v16.4s, v3.4h, XFIX_P_1_501   /* tmp3 = MULTIPLY(tmp3, FIX_1_501321110) */
+    smull           v26.4s, v26.4h, XFIX_P_1_175  /* z5l z5 = MULTIPLY(z3 + z4, FIX_1_175875602) */
+    smull           v22.4s, v22.4h, XFIX_N_1_961  /* z3 = MULTIPLY(z3, -FIX_1_961570560) */
+    smull           v24.4s, v24.4h, XFIX_N_0_390  /* z4 = MULTIPLY(z4, -FIX_0_390180644) */
+    smull           v18.4s, v18.4h, XFIX_N_0_899  /* z1 = MULTIPLY(z1, -FIX_0_899976223) */
+    smull           v20.4s, v20.4h, XFIX_N_2_562  /* z2 = MULTIPLY(z2, -FIX_2_562915447) */
+
+    add             v23.4s, v23.4s, v27.4s  /* z3 += z5 */
+    add             v22.4s, v22.4s, v26.4s  /* z3 += z5 */
+    add             v25.4s, v25.4s, v27.4s  /* z4 += z5 */
+    add             v24.4s, v24.4s, v26.4s  /* z4 += z5 */
+
+    add             v11.4s, v11.4s, v19.4s  /* tmp0 += z1 */
+    add             v10.4s, v10.4s, v18.4s  /* tmp0 += z1 */
+    add             v13.4s, v13.4s, v21.4s  /* tmp1 += z2 */
+    add             v12.4s, v12.4s, v20.4s  /* tmp1 += z2 */
+    add             v15.4s, v15.4s, v21.4s  /* tmp2 += z2 */
+    add             v14.4s, v14.4s, v20.4s  /* tmp2 += z2 */
+    add             v17.4s, v17.4s, v19.4s  /* tmp3 += z1 */
+    add             v16.4s, v16.4s, v18.4s  /* tmp3 += z1 */
+
+    add             v11.4s, v11.4s, v23.4s  /* tmp0 += z3 */
+    add             v10.4s, v10.4s, v22.4s  /* tmp0 += z3 */
+    add             v13.4s, v13.4s, v25.4s  /* tmp1 += z4 */
+    add             v12.4s, v12.4s, v24.4s  /* tmp1 += z4 */
+    add             v17.4s, v17.4s, v25.4s  /* tmp3 += z4 */
+    add             v16.4s, v16.4s, v24.4s  /* tmp3 += z4 */
+    add             v15.4s, v15.4s, v23.4s  /* tmp2 += z3 */
+    add             v14.4s, v14.4s, v22.4s  /* tmp2 += z3 */
+
+    /* Final output stage: inputs are tmp10..tmp13, tmp0..tmp3 */
+
+    add             v18.4s, v2.4s, v16.4s   /* tmp10 + tmp3 */
+    add             v19.4s, v28.4s, v17.4s  /* tmp10 + tmp3 */
+    sub             v20.4s, v2.4s, v16.4s   /* tmp10 - tmp3 */
+    sub             v21.4s, v28.4s, v17.4s  /* tmp10 - tmp3 */
+    add             v22.4s, v8.4s, v14.4s   /* tmp11 + tmp2 */
+    add             v23.4s, v29.4s, v15.4s  /* tmp11 + tmp2 */
+    sub             v24.4s, v8.4s, v14.4s   /* tmp11 - tmp2 */
+    sub             v25.4s, v29.4s, v15.4s  /* tmp11 - tmp2 */
+    add             v26.4s, v4.4s, v12.4s   /* tmp12 + tmp1 */
+    add             v27.4s, v30.4s, v13.4s  /* tmp12 + tmp1 */
+    sub             v28.4s, v4.4s, v12.4s   /* tmp12 - tmp1 */
+    sub             v29.4s, v30.4s, v13.4s  /* tmp12 - tmp1 */
+    add             v14.4s, v6.4s, v10.4s   /* tmp13 + tmp0 */
+    add             v15.4s, v31.4s, v11.4s  /* tmp13 + tmp0 */
+    sub             v16.4s, v6.4s, v10.4s   /* tmp13 - tmp0 */
+    sub             v17.4s, v31.4s, v11.4s  /* tmp13 - tmp0 */
+
+    rshrn           v2.4h, v18.4s, #(CONST_BITS - PASS1_BITS)  /* wsptr[DCTSIZE*0] = (int)DESCALE(tmp10 + tmp3, CONST_BITS-PASS1_BITS) */
+    rshrn           v3.4h, v22.4s, #(CONST_BITS - PASS1_BITS)  /* wsptr[DCTSIZE*1] = (int)DESCALE(tmp11 + tmp2, CONST_BITS-PASS1_BITS) */
+    rshrn           v4.4h, v26.4s, #(CONST_BITS - PASS1_BITS)  /* wsptr[DCTSIZE*2] = (int)DESCALE(tmp12 + tmp1, CONST_BITS-PASS1_BITS) */
+    rshrn           v5.4h, v14.4s, #(CONST_BITS - PASS1_BITS)  /* wsptr[DCTSIZE*3] = (int)DESCALE(tmp13 + tmp0, CONST_BITS-PASS1_BITS) */
+    rshrn           v6.4h, v19.4s, #(CONST_BITS - PASS1_BITS)  /* wsptr[DCTSIZE*0] = (int)DESCALE(tmp10 + tmp3, CONST_BITS-PASS1_BITS) */
+    rshrn           v7.4h, v23.4s, #(CONST_BITS - PASS1_BITS)  /* wsptr[DCTSIZE*1] = (int)DESCALE(tmp11 + tmp2, CONST_BITS-PASS1_BITS) */
+    rshrn           v8.4h, v27.4s, #(CONST_BITS - PASS1_BITS)  /* wsptr[DCTSIZE*2] = (int)DESCALE(tmp12 + tmp1, CONST_BITS-PASS1_BITS) */
+    rshrn           v9.4h, v15.4s, #(CONST_BITS - PASS1_BITS)  /* wsptr[DCTSIZE*3] = (int)DESCALE(tmp13 + tmp0, CONST_BITS-PASS1_BITS) */
+    rshrn2          v2.8h, v16.4s, #(CONST_BITS - PASS1_BITS)  /* wsptr[DCTSIZE*4] = (int)DESCALE(tmp13 - tmp0, CONST_BITS-PASS1_BITS) */
+    rshrn2          v3.8h, v28.4s, #(CONST_BITS - PASS1_BITS)  /* wsptr[DCTSIZE*5] = (int)DESCALE(tmp12 - tmp1, CONST_BITS-PASS1_BITS) */
+    rshrn2          v4.8h, v24.4s, #(CONST_BITS - PASS1_BITS)  /* wsptr[DCTSIZE*6] = (int)DESCALE(tmp11 - tmp2, CONST_BITS-PASS1_BITS) */
+    rshrn2          v5.8h, v20.4s, #(CONST_BITS - PASS1_BITS)  /* wsptr[DCTSIZE*7] = (int)DESCALE(tmp10 - tmp3, CONST_BITS-PASS1_BITS) */
+    rshrn2          v6.8h, v17.4s, #(CONST_BITS - PASS1_BITS)  /* wsptr[DCTSIZE*4] = (int)DESCALE(tmp13 - tmp0, CONST_BITS-PASS1_BITS) */
+    rshrn2          v7.8h, v29.4s, #(CONST_BITS - PASS1_BITS)  /* wsptr[DCTSIZE*5] = (int)DESCALE(tmp12 - tmp1, CONST_BITS-PASS1_BITS) */
+    rshrn2          v8.8h, v25.4s, #(CONST_BITS - PASS1_BITS)  /* wsptr[DCTSIZE*6] = (int)DESCALE(tmp11 - tmp2, CONST_BITS-PASS1_BITS) */
+    rshrn2          v9.8h, v21.4s, #(CONST_BITS - PASS1_BITS)  /* wsptr[DCTSIZE*7] = (int)DESCALE(tmp10 - tmp3, CONST_BITS-PASS1_BITS) */
+    b               1b
+
+    .unreq          DCT_TABLE
+    .unreq          COEF_BLOCK
+    .unreq          OUTPUT_BUF
+    .unreq          OUTPUT_COL
+    .unreq          TMP1
+    .unreq          TMP2
+    .unreq          TMP3
+    .unreq          TMP4
+    .unreq          TMP5
+    .unreq          TMP6
+    .unreq          TMP7
+    .unreq          TMP8
+
+#undef CENTERJSAMPLE
+#undef CONST_BITS
+#undef PASS1_BITS
+#undef XFIX_P_0_298
+#undef XFIX_N_0_390
+#undef XFIX_P_0_541
+#undef XFIX_P_0_765
+#undef XFIX_N_0_899
+#undef XFIX_P_1_175
+#undef XFIX_P_1_501
+#undef XFIX_N_1_847
+#undef XFIX_N_1_961
+#undef XFIX_P_2_053
+#undef XFIX_N_2_562
+#undef XFIX_P_3_072
+
+
+/*****************************************************************************/
+
+/*
+ * jsimd_ycc_extrgb_convert_neon
+ * jsimd_ycc_extbgr_convert_neon
+ * jsimd_ycc_extrgbx_convert_neon
+ * jsimd_ycc_extbgrx_convert_neon
+ * jsimd_ycc_extxbgr_convert_neon
+ * jsimd_ycc_extxrgb_convert_neon
+ *
+ * Colorspace conversion YCbCr -> RGB
+ */
+
+.macro do_load size
+  .if \size == 8
+    ld1             {v4.8b}, [U], 8
+    ld1             {v5.8b}, [V], 8
+    ld1             {v0.8b}, [Y], 8
+    prfm            pldl1keep, [U, #64]
+    prfm            pldl1keep, [V, #64]
+    prfm            pldl1keep, [Y, #64]
+  .elseif \size == 4
+    ld1             {v4.b}[0], [U], 1
+    ld1             {v4.b}[1], [U], 1
+    ld1             {v4.b}[2], [U], 1
+    ld1             {v4.b}[3], [U], 1
+    ld1             {v5.b}[0], [V], 1
+    ld1             {v5.b}[1], [V], 1
+    ld1             {v5.b}[2], [V], 1
+    ld1             {v5.b}[3], [V], 1
+    ld1             {v0.b}[0], [Y], 1
+    ld1             {v0.b}[1], [Y], 1
+    ld1             {v0.b}[2], [Y], 1
+    ld1             {v0.b}[3], [Y], 1
+  .elseif \size == 2
+    ld1             {v4.b}[4], [U], 1
+    ld1             {v4.b}[5], [U], 1
+    ld1             {v5.b}[4], [V], 1
+    ld1             {v5.b}[5], [V], 1
+    ld1             {v0.b}[4], [Y], 1
+    ld1             {v0.b}[5], [Y], 1
+  .elseif \size == 1
+    ld1             {v4.b}[6], [U], 1
+    ld1             {v5.b}[6], [V], 1
+    ld1             {v0.b}[6], [Y], 1
+  .else
+    .error unsupported macroblock size
+  .endif
+.endm
+
+.macro do_store bpp, size, fast_st3
+  .if \bpp == 24
+    .if \size == 8
+      .if \fast_st3 == 1
+        st3         {v10.8b, v11.8b, v12.8b}, [RGB], 24
+      .else
+        st1         {v10.b}[0], [RGB], #1
+        st1         {v11.b}[0], [RGB], #1
+        st1         {v12.b}[0], [RGB], #1
+
+        st1         {v10.b}[1], [RGB], #1
+        st1         {v11.b}[1], [RGB], #1
+        st1         {v12.b}[1], [RGB], #1
+
+        st1         {v10.b}[2], [RGB], #1
+        st1         {v11.b}[2], [RGB], #1
+        st1         {v12.b}[2], [RGB], #1
+
+        st1         {v10.b}[3], [RGB], #1
+        st1         {v11.b}[3], [RGB], #1
+        st1         {v12.b}[3], [RGB], #1
+
+        st1         {v10.b}[4], [RGB], #1
+        st1         {v11.b}[4], [RGB], #1
+        st1         {v12.b}[4], [RGB], #1
+
+        st1         {v10.b}[5], [RGB], #1
+        st1         {v11.b}[5], [RGB], #1
+        st1         {v12.b}[5], [RGB], #1
+
+        st1         {v10.b}[6], [RGB], #1
+        st1         {v11.b}[6], [RGB], #1
+        st1         {v12.b}[6], [RGB], #1
+
+        st1         {v10.b}[7], [RGB], #1
+        st1         {v11.b}[7], [RGB], #1
+        st1         {v12.b}[7], [RGB], #1
+      .endif
+    .elseif \size == 4
+      st3           {v10.b, v11.b, v12.b}[0], [RGB], 3
+      st3           {v10.b, v11.b, v12.b}[1], [RGB], 3
+      st3           {v10.b, v11.b, v12.b}[2], [RGB], 3
+      st3           {v10.b, v11.b, v12.b}[3], [RGB], 3
+    .elseif \size == 2
+      st3           {v10.b, v11.b, v12.b}[4], [RGB], 3
+      st3           {v10.b, v11.b, v12.b}[5], [RGB], 3
+    .elseif \size == 1
+      st3           {v10.b, v11.b, v12.b}[6], [RGB], 3
+    .else
+     .error unsupported macroblock size
+    .endif
+  .elseif \bpp == 32
+    .if \size == 8
+      st4           {v10.8b, v11.8b, v12.8b, v13.8b}, [RGB], 32
+    .elseif \size == 4
+      st4           {v10.b, v11.b, v12.b, v13.b}[0], [RGB], 4
+      st4           {v10.b, v11.b, v12.b, v13.b}[1], [RGB], 4
+      st4           {v10.b, v11.b, v12.b, v13.b}[2], [RGB], 4
+      st4           {v10.b, v11.b, v12.b, v13.b}[3], [RGB], 4
+    .elseif \size == 2
+      st4           {v10.b, v11.b, v12.b, v13.b}[4], [RGB], 4
+      st4           {v10.b, v11.b, v12.b, v13.b}[5], [RGB], 4
+    .elseif \size == 1
+      st4           {v10.b, v11.b, v12.b, v13.b}[6], [RGB], 4
+    .else
+      .error unsupported macroblock size
+    .endif
+  .elseif \bpp == 16
+    .if \size == 8
+      st1           {v25.8h}, [RGB], 16
+    .elseif \size == 4
+      st1           {v25.4h}, [RGB], 8
+    .elseif \size == 2
+      st1           {v25.h}[4], [RGB], 2
+      st1           {v25.h}[5], [RGB], 2
+    .elseif \size == 1
+      st1           {v25.h}[6], [RGB], 2
+    .else
+      .error unsupported macroblock size
+    .endif
+  .else
+    .error unsupported bpp
+  .endif
+.endm
+
+.macro generate_jsimd_ycc_rgb_convert_neon colorid, bpp, r_offs, rsize, \
+                                           g_offs, gsize, b_offs, bsize, \
+                                           defsize, fast_st3
+
+/*
+ * 2-stage pipelined YCbCr->RGB conversion
+ */
+
+.macro do_yuv_to_rgb_stage1
+    uaddw           v6.8h, v2.8h, v4.8b     /* q3 = u - 128 */
+    uaddw           v8.8h, v2.8h, v5.8b     /* q2 = v - 128 */
+    smull           v20.4s, v6.4h, v1.h[1]  /* multiply by -11277 */
+    smlal           v20.4s, v8.4h, v1.h[2]  /* multiply by -23401 */
+    smull2          v22.4s, v6.8h, v1.h[1]  /* multiply by -11277 */
+    smlal2          v22.4s, v8.8h, v1.h[2]  /* multiply by -23401 */
+    smull           v24.4s, v8.4h, v1.h[0]  /* multiply by 22971 */
+    smull2          v26.4s, v8.8h, v1.h[0]  /* multiply by 22971 */
+    smull           v28.4s, v6.4h, v1.h[3]  /* multiply by 29033 */
+    smull2          v30.4s, v6.8h, v1.h[3]  /* multiply by 29033 */
+.endm
+
+.macro do_yuv_to_rgb_stage2
+    rshrn           v20.4h, v20.4s, #15
+    rshrn2          v20.8h, v22.4s, #15
+    rshrn           v24.4h, v24.4s, #14
+    rshrn2          v24.8h, v26.4s, #14
+    rshrn           v28.4h, v28.4s, #14
+    rshrn2          v28.8h, v30.4s, #14
+    uaddw           v20.8h, v20.8h, v0.8b
+    uaddw           v24.8h, v24.8h, v0.8b
+    uaddw           v28.8h, v28.8h, v0.8b
+  .if \bpp != 16
+    sqxtun          v1\g_offs\defsize, v20.8h
+    sqxtun          v1\r_offs\defsize, v24.8h
+    sqxtun          v1\b_offs\defsize, v28.8h
+  .else
+    sqshlu          v21.8h, v20.8h, #8
+    sqshlu          v25.8h, v24.8h, #8
+    sqshlu          v29.8h, v28.8h, #8
+    sri             v25.8h, v21.8h, #5
+    sri             v25.8h, v29.8h, #11
+  .endif
+.endm
+
+.macro do_yuv_to_rgb_stage2_store_load_stage1 fast_st3
+    rshrn           v20.4h, v20.4s, #15
+    rshrn           v24.4h, v24.4s, #14
+    rshrn           v28.4h, v28.4s, #14
+    ld1             {v4.8b}, [U], 8
+    rshrn2          v20.8h, v22.4s, #15
+    rshrn2          v24.8h, v26.4s, #14
+    rshrn2          v28.8h, v30.4s, #14
+    ld1             {v5.8b}, [V], 8
+    uaddw           v20.8h, v20.8h, v0.8b
+    uaddw           v24.8h, v24.8h, v0.8b
+    uaddw           v28.8h, v28.8h, v0.8b
+  .if \bpp != 16  /**************** rgb24/rgb32 ******************************/
+    sqxtun          v1\g_offs\defsize, v20.8h
+    ld1             {v0.8b}, [Y], 8
+    sqxtun          v1\r_offs\defsize, v24.8h
+    prfm            pldl1keep, [U, #64]
+    prfm            pldl1keep, [V, #64]
+    prfm            pldl1keep, [Y, #64]
+    sqxtun          v1\b_offs\defsize, v28.8h
+    uaddw           v6.8h, v2.8h, v4.8b     /* v6.16b = u - 128 */
+    uaddw           v8.8h, v2.8h, v5.8b     /* q2 = v - 128 */
+    smull           v20.4s, v6.4h, v1.h[1]  /* multiply by -11277 */
+    smlal           v20.4s, v8.4h, v1.h[2]  /* multiply by -23401 */
+    smull2          v22.4s, v6.8h, v1.h[1]  /* multiply by -11277 */
+    smlal2          v22.4s, v8.8h, v1.h[2]  /* multiply by -23401 */
+    smull           v24.4s, v8.4h, v1.h[0]  /* multiply by 22971 */
+    smull2          v26.4s, v8.8h, v1.h[0]  /* multiply by 22971 */
+  .else  /**************************** rgb565 ********************************/
+    sqshlu          v21.8h, v20.8h, #8
+    sqshlu          v25.8h, v24.8h, #8
+    sqshlu          v29.8h, v28.8h, #8
+    uaddw           v6.8h, v2.8h, v4.8b     /* v6.16b = u - 128 */
+    uaddw           v8.8h, v2.8h, v5.8b     /* q2 = v - 128 */
+    ld1             {v0.8b}, [Y], 8
+    smull           v20.4s, v6.4h, v1.h[1]  /* multiply by -11277 */
+    smlal           v20.4s, v8.4h, v1.h[2]  /* multiply by -23401 */
+    smull2          v22.4s, v6.8h, v1.h[1]  /* multiply by -11277 */
+    smlal2          v22.4s, v8.8h, v1.h[2]  /* multiply by -23401 */
+    sri             v25.8h, v21.8h, #5
+    smull           v24.4s, v8.4h, v1.h[0]  /* multiply by 22971 */
+    smull2          v26.4s, v8.8h, v1.h[0]  /* multiply by 22971 */
+    prfm            pldl1keep, [U, #64]
+    prfm            pldl1keep, [V, #64]
+    prfm            pldl1keep, [Y, #64]
+    sri             v25.8h, v29.8h, #11
+  .endif
+    do_store        \bpp, 8, \fast_st3
+    smull           v28.4s, v6.4h, v1.h[3]  /* multiply by 29033 */
+    smull2          v30.4s, v6.8h, v1.h[3]  /* multiply by 29033 */
+.endm
+
+.macro do_yuv_to_rgb
+    do_yuv_to_rgb_stage1
+    do_yuv_to_rgb_stage2
+.endm
+
+.if \fast_st3 == 1
+asm_function jsimd_ycc_\colorid\()_convert_neon
+.else
+asm_function jsimd_ycc_\colorid\()_convert_neon_slowst3
+.endif
+    OUTPUT_WIDTH    .req w0
+    INPUT_BUF       .req x1
+    INPUT_ROW       .req w2
+    OUTPUT_BUF      .req x3
+    NUM_ROWS        .req w4
+
+    INPUT_BUF0      .req x5
+    INPUT_BUF1      .req x6
+    INPUT_BUF2      .req x1
+
+    RGB             .req x7
+    Y               .req x9
+    U               .req x10
+    V               .req x11
+    N               .req w15
+
+    sub             sp, sp, 64
+    mov             x9, sp
+
+    /* Load constants to d1, d2, d3 (v0.4h is just used for padding) */
+    get_symbol_loc  x15, Ljsimd_ycc_rgb_neon_consts
+
+    /* Save Neon registers */
+    st1             {v8.8b, v9.8b, v10.8b, v11.8b}, [x9], 32
+    st1             {v12.8b, v13.8b, v14.8b, v15.8b}, [x9], 32
+    ld1             {v0.4h, v1.4h}, [x15], 16
+    ld1             {v2.8h}, [x15]
+
+    ldr             INPUT_BUF0, [INPUT_BUF]
+    ldr             INPUT_BUF1, [INPUT_BUF, #8]
+    ldr             INPUT_BUF2, [INPUT_BUF, #16]
+    .unreq          INPUT_BUF
+
+    /* Initially set v10, v11.4h, v12.8b, d13 to 0xFF */
+    movi            v10.16b, #255
+    movi            v13.16b, #255
+
+    /* Outer loop over scanlines */
+    cmp             NUM_ROWS, #1
+    b.lt            9f
+0:
+    ldr             Y, [INPUT_BUF0, INPUT_ROW, uxtw #3]
+    ldr             U, [INPUT_BUF1, INPUT_ROW, uxtw #3]
+    mov             N, OUTPUT_WIDTH
+    ldr             V, [INPUT_BUF2, INPUT_ROW, uxtw #3]
+    add             INPUT_ROW, INPUT_ROW, #1
+    ldr             RGB, [OUTPUT_BUF], #8
+
+    /* Inner loop over pixels */
+    subs            N, N, #8
+    b.lt            3f
+    do_load         8
+    do_yuv_to_rgb_stage1
+    subs            N, N, #8
+    b.lt            2f
+1:
+    do_yuv_to_rgb_stage2_store_load_stage1 \fast_st3
+    subs            N, N, #8
+    b.ge            1b
+2:
+    do_yuv_to_rgb_stage2
+    do_store        \bpp, 8, \fast_st3
+    tst             N, #7
+    b.eq            8f
+3:
+    tst             N, #4
+    b.eq            3f
+    do_load         4
+3:
+    tst             N, #2
+    b.eq            4f
+    do_load         2
+4:
+    tst             N, #1
+    b.eq            5f
+    do_load         1
+5:
+    do_yuv_to_rgb
+    tst             N, #4
+    b.eq            6f
+    do_store        \bpp, 4, \fast_st3
+6:
+    tst             N, #2
+    b.eq            7f
+    do_store        \bpp, 2, \fast_st3
+7:
+    tst             N, #1
+    b.eq            8f
+    do_store        \bpp, 1, \fast_st3
+8:
+    subs            NUM_ROWS, NUM_ROWS, #1
+    b.gt            0b
+9:
+    /* Restore all registers and return */
+    ld1             {v8.8b, v9.8b, v10.8b, v11.8b}, [sp], 32
+    ld1             {v12.8b, v13.8b, v14.8b, v15.8b}, [sp], 32
+    br              x30
+    .unreq          OUTPUT_WIDTH
+    .unreq          INPUT_ROW
+    .unreq          OUTPUT_BUF
+    .unreq          NUM_ROWS
+    .unreq          INPUT_BUF0
+    .unreq          INPUT_BUF1
+    .unreq          INPUT_BUF2
+    .unreq          RGB
+    .unreq          Y
+    .unreq          U
+    .unreq          V
+    .unreq          N
+
+.purgem do_yuv_to_rgb
+.purgem do_yuv_to_rgb_stage1
+.purgem do_yuv_to_rgb_stage2
+.purgem do_yuv_to_rgb_stage2_store_load_stage1
+
+.endm
+
+/*--------------------------------- id ----- bpp R  rsize G  gsize B  bsize defsize fast_st3*/
+generate_jsimd_ycc_rgb_convert_neon extrgb,  24, 0, .4h,  1, .4h,  2, .4h,  .8b,    1
+generate_jsimd_ycc_rgb_convert_neon extbgr,  24, 2, .4h,  1, .4h,  0, .4h,  .8b,    1
+generate_jsimd_ycc_rgb_convert_neon extrgbx, 32, 0, .4h,  1, .4h,  2, .4h,  .8b,    1
+generate_jsimd_ycc_rgb_convert_neon extbgrx, 32, 2, .4h,  1, .4h,  0, .4h,  .8b,    1
+generate_jsimd_ycc_rgb_convert_neon extxbgr, 32, 3, .4h,  2, .4h,  1, .4h,  .8b,    1
+generate_jsimd_ycc_rgb_convert_neon extxrgb, 32, 1, .4h,  2, .4h,  3, .4h,  .8b,    1
+generate_jsimd_ycc_rgb_convert_neon rgb565,  16, 0, .4h,  0, .4h,  0, .4h,  .8b,    1
+
+generate_jsimd_ycc_rgb_convert_neon extrgb,  24, 0, .4h,  1, .4h,  2, .4h,  .8b,    0
+generate_jsimd_ycc_rgb_convert_neon extbgr,  24, 2, .4h,  1, .4h,  0, .4h,  .8b,    0
+
+.purgem do_load
+.purgem do_store
+
+
+/*****************************************************************************/
+
+/*
+ * jsimd_extrgb_ycc_convert_neon
+ * jsimd_extbgr_ycc_convert_neon
+ * jsimd_extrgbx_ycc_convert_neon
+ * jsimd_extbgrx_ycc_convert_neon
+ * jsimd_extxbgr_ycc_convert_neon
+ * jsimd_extxrgb_ycc_convert_neon
+ *
+ * Colorspace conversion RGB -> YCbCr
+ */
+
+.macro do_store size
+  .if \size == 8
+    st1             {v20.8b}, [Y], #8
+    st1             {v21.8b}, [U], #8
+    st1             {v22.8b}, [V], #8
+  .elseif \size == 4
+    st1             {v20.b}[0], [Y], #1
+    st1             {v20.b}[1], [Y], #1
+    st1             {v20.b}[2], [Y], #1
+    st1             {v20.b}[3], [Y], #1
+    st1             {v21.b}[0], [U], #1
+    st1             {v21.b}[1], [U], #1
+    st1             {v21.b}[2], [U], #1
+    st1             {v21.b}[3], [U], #1
+    st1             {v22.b}[0], [V], #1
+    st1             {v22.b}[1], [V], #1
+    st1             {v22.b}[2], [V], #1
+    st1             {v22.b}[3], [V], #1
+  .elseif \size == 2
+    st1             {v20.b}[4], [Y], #1
+    st1             {v20.b}[5], [Y], #1
+    st1             {v21.b}[4], [U], #1
+    st1             {v21.b}[5], [U], #1
+    st1             {v22.b}[4], [V], #1
+    st1             {v22.b}[5], [V], #1
+  .elseif \size == 1
+    st1             {v20.b}[6], [Y], #1
+    st1             {v21.b}[6], [U], #1
+    st1             {v22.b}[6], [V], #1
+  .else
+    .error unsupported macroblock size
+  .endif
+.endm
+
+.macro do_load bpp, size, fast_ld3
+  .if \bpp == 24
+    .if \size == 8
+      .if \fast_ld3 == 1
+        ld3         {v10.8b, v11.8b, v12.8b}, [RGB], #24
+      .else
+        ld1         {v10.b}[0], [RGB], #1
+        ld1         {v11.b}[0], [RGB], #1
+        ld1         {v12.b}[0], [RGB], #1
+
+        ld1         {v10.b}[1], [RGB], #1
+        ld1         {v11.b}[1], [RGB], #1
+        ld1         {v12.b}[1], [RGB], #1
+
+        ld1         {v10.b}[2], [RGB], #1
+        ld1         {v11.b}[2], [RGB], #1
+        ld1         {v12.b}[2], [RGB], #1
+
+        ld1         {v10.b}[3], [RGB], #1
+        ld1         {v11.b}[3], [RGB], #1
+        ld1         {v12.b}[3], [RGB], #1
+
+        ld1         {v10.b}[4], [RGB], #1
+        ld1         {v11.b}[4], [RGB], #1
+        ld1         {v12.b}[4], [RGB], #1
+
+        ld1         {v10.b}[5], [RGB], #1
+        ld1         {v11.b}[5], [RGB], #1
+        ld1         {v12.b}[5], [RGB], #1
+
+        ld1         {v10.b}[6], [RGB], #1
+        ld1         {v11.b}[6], [RGB], #1
+        ld1         {v12.b}[6], [RGB], #1
+
+        ld1         {v10.b}[7], [RGB], #1
+        ld1         {v11.b}[7], [RGB], #1
+        ld1         {v12.b}[7], [RGB], #1
+      .endif
+      prfm          pldl1keep, [RGB, #128]
+    .elseif \size == 4
+      ld3           {v10.b, v11.b, v12.b}[0], [RGB], #3
+      ld3           {v10.b, v11.b, v12.b}[1], [RGB], #3
+      ld3           {v10.b, v11.b, v12.b}[2], [RGB], #3
+      ld3           {v10.b, v11.b, v12.b}[3], [RGB], #3
+    .elseif \size == 2
+      ld3           {v10.b, v11.b, v12.b}[4], [RGB], #3
+      ld3           {v10.b, v11.b, v12.b}[5], [RGB], #3
+    .elseif \size == 1
+      ld3           {v10.b, v11.b, v12.b}[6], [RGB], #3
+    .else
+      .error unsupported macroblock size
+    .endif
+  .elseif \bpp == 32
+    .if \size == 8
+      ld4           {v10.8b, v11.8b, v12.8b, v13.8b}, [RGB], #32
+      prfm          pldl1keep, [RGB, #128]
+    .elseif \size == 4
+      ld4           {v10.b, v11.b, v12.b, v13.b}[0], [RGB], #4
+      ld4           {v10.b, v11.b, v12.b, v13.b}[1], [RGB], #4
+      ld4           {v10.b, v11.b, v12.b, v13.b}[2], [RGB], #4
+      ld4           {v10.b, v11.b, v12.b, v13.b}[3], [RGB], #4
+    .elseif \size == 2
+      ld4           {v10.b, v11.b, v12.b, v13.b}[4], [RGB], #4
+      ld4           {v10.b, v11.b, v12.b, v13.b}[5], [RGB], #4
+    .elseif \size == 1
+      ld4           {v10.b, v11.b, v12.b, v13.b}[6], [RGB], #4
+    .else
+      .error unsupported macroblock size
+    .endif
+  .else
+    .error unsupported bpp
+  .endif
+.endm
+
+.macro generate_jsimd_rgb_ycc_convert_neon colorid, bpp, r_offs, g_offs, \
+                                           b_offs, fast_ld3
+
+/*
+ * 2-stage pipelined RGB->YCbCr conversion
+ */
+
+.macro do_rgb_to_yuv_stage1
+    ushll           v4.8h, v1\r_offs\().8b, #0  /* r = v4 */
+    ushll           v6.8h, v1\g_offs\().8b, #0  /* g = v6 */
+    ushll           v8.8h, v1\b_offs\().8b, #0  /* b = v8 */
+    rev64           v18.4s, v1.4s
+    rev64           v26.4s, v1.4s
+    rev64           v28.4s, v1.4s
+    rev64           v30.4s, v1.4s
+    umull           v14.4s, v4.4h, v0.h[0]
+    umull2          v16.4s, v4.8h, v0.h[0]
+    umlsl           v18.4s, v4.4h, v0.h[3]
+    umlsl2          v26.4s, v4.8h, v0.h[3]
+    umlal           v28.4s, v4.4h, v0.h[5]
+    umlal2          v30.4s, v4.8h, v0.h[5]
+    umlal           v14.4s, v6.4h, v0.h[1]
+    umlal2          v16.4s, v6.8h, v0.h[1]
+    umlsl           v18.4s, v6.4h, v0.h[4]
+    umlsl2          v26.4s, v6.8h, v0.h[4]
+    umlsl           v28.4s, v6.4h, v0.h[6]
+    umlsl2          v30.4s, v6.8h, v0.h[6]
+    umlal           v14.4s, v8.4h, v0.h[2]
+    umlal2          v16.4s, v8.8h, v0.h[2]
+    umlal           v18.4s, v8.4h, v0.h[5]
+    umlal2          v26.4s, v8.8h, v0.h[5]
+    umlsl           v28.4s, v8.4h, v0.h[7]
+    umlsl2          v30.4s, v8.8h, v0.h[7]
+.endm
+
+.macro do_rgb_to_yuv_stage2
+    rshrn           v20.4h, v14.4s, #16
+    shrn            v22.4h, v18.4s, #16
+    shrn            v24.4h, v28.4s, #16
+    rshrn2          v20.8h, v16.4s, #16
+    shrn2           v22.8h, v26.4s, #16
+    shrn2           v24.8h, v30.4s, #16
+    xtn             v20.8b, v20.8h       /* v20 = y */
+    xtn             v21.8b, v22.8h       /* v21 = u */
+    xtn             v22.8b, v24.8h       /* v22 = v */
+.endm
+
+.macro do_rgb_to_yuv
+    do_rgb_to_yuv_stage1
+    do_rgb_to_yuv_stage2
+.endm
+
+/* TODO: expand macros and interleave instructions if some in-order
+ *       AArch64 processor actually can dual-issue LOAD/STORE with ALU */
+.macro do_rgb_to_yuv_stage2_store_load_stage1 fast_ld3
+    do_rgb_to_yuv_stage2
+    do_load         \bpp, 8, \fast_ld3
+    st1             {v20.8b}, [Y], #8
+    st1             {v21.8b}, [U], #8
+    st1             {v22.8b}, [V], #8
+    do_rgb_to_yuv_stage1
+.endm
+
+.if \fast_ld3 == 1
+asm_function jsimd_\colorid\()_ycc_convert_neon
+.else
+asm_function jsimd_\colorid\()_ycc_convert_neon_slowld3
+.endif
+    OUTPUT_WIDTH    .req w0
+    INPUT_BUF       .req x1
+    OUTPUT_BUF      .req x2
+    OUTPUT_ROW      .req w3
+    NUM_ROWS        .req w4
+
+    OUTPUT_BUF0     .req x5
+    OUTPUT_BUF1     .req x6
+    OUTPUT_BUF2     .req x2  /* OUTPUT_BUF */
+
+    RGB             .req x7
+    Y               .req x9
+    U               .req x10
+    V               .req x11
+    N               .req w12
+
+    /* Load constants to d0, d1, d2, d3 */
+    get_symbol_loc  x13, Ljsimd_rgb_ycc_neon_consts
+    ld1             {v0.8h, v1.8h}, [x13]
+
+    ldr             OUTPUT_BUF0, [OUTPUT_BUF]
+    ldr             OUTPUT_BUF1, [OUTPUT_BUF, #8]
+    ldr             OUTPUT_BUF2, [OUTPUT_BUF, #16]
+    .unreq          OUTPUT_BUF
+
+    /* Save Neon registers */
+    sub             sp, sp, #64
+    mov             x9, sp
+    st1             {v8.8b, v9.8b, v10.8b, v11.8b}, [x9], 32
+    st1             {v12.8b, v13.8b, v14.8b, v15.8b}, [x9], 32
+
+    /* Outer loop over scanlines */
+    cmp             NUM_ROWS, #1
+    b.lt            9f
+0:
+    ldr             Y, [OUTPUT_BUF0, OUTPUT_ROW, uxtw #3]
+    ldr             U, [OUTPUT_BUF1, OUTPUT_ROW, uxtw #3]
+    mov             N, OUTPUT_WIDTH
+    ldr             V, [OUTPUT_BUF2, OUTPUT_ROW, uxtw #3]
+    add             OUTPUT_ROW, OUTPUT_ROW, #1
+    ldr             RGB, [INPUT_BUF], #8
+
+    /* Inner loop over pixels */
+    subs            N, N, #8
+    b.lt            3f
+    do_load         \bpp, 8, \fast_ld3
+    do_rgb_to_yuv_stage1
+    subs            N, N, #8
+    b.lt            2f
+1:
+    do_rgb_to_yuv_stage2_store_load_stage1 \fast_ld3
+    subs            N, N, #8
+    b.ge            1b
+2:
+    do_rgb_to_yuv_stage2
+    do_store        8
+    tst             N, #7
+    b.eq            8f
+3:
+    tbz             N, #2, 3f
+    do_load         \bpp, 4, \fast_ld3
+3:
+    tbz             N, #1, 4f
+    do_load         \bpp, 2, \fast_ld3
+4:
+    tbz             N, #0, 5f
+    do_load         \bpp, 1, \fast_ld3
+5:
+    do_rgb_to_yuv
+    tbz             N, #2, 6f
+    do_store        4
+6:
+    tbz             N, #1, 7f
+    do_store        2
+7:
+    tbz             N, #0, 8f
+    do_store        1
+8:
+    subs            NUM_ROWS, NUM_ROWS, #1
+    b.gt            0b
+9:
+    /* Restore all registers and return */
+    ld1             {v8.8b, v9.8b, v10.8b, v11.8b}, [sp], 32
+    ld1             {v12.8b, v13.8b, v14.8b, v15.8b}, [sp], 32
+    br              x30
+
+    .unreq          OUTPUT_WIDTH
+    .unreq          OUTPUT_ROW
+    .unreq          INPUT_BUF
+    .unreq          NUM_ROWS
+    .unreq          OUTPUT_BUF0
+    .unreq          OUTPUT_BUF1
+    .unreq          OUTPUT_BUF2
+    .unreq          RGB
+    .unreq          Y
+    .unreq          U
+    .unreq          V
+    .unreq          N
+
+.purgem do_rgb_to_yuv
+.purgem do_rgb_to_yuv_stage1
+.purgem do_rgb_to_yuv_stage2
+.purgem do_rgb_to_yuv_stage2_store_load_stage1
+
+.endm
+
+/*--------------------------------- id ----- bpp R  G  B  Fast LD3 */
+generate_jsimd_rgb_ycc_convert_neon extrgb,  24, 0, 1, 2, 1
+generate_jsimd_rgb_ycc_convert_neon extbgr,  24, 2, 1, 0, 1
+generate_jsimd_rgb_ycc_convert_neon extrgbx, 32, 0, 1, 2, 1
+generate_jsimd_rgb_ycc_convert_neon extbgrx, 32, 2, 1, 0, 1
+generate_jsimd_rgb_ycc_convert_neon extxbgr, 32, 3, 2, 1, 1
+generate_jsimd_rgb_ycc_convert_neon extxrgb, 32, 1, 2, 3, 1
+
+generate_jsimd_rgb_ycc_convert_neon extrgb,  24, 0, 1, 2, 0
+generate_jsimd_rgb_ycc_convert_neon extbgr,  24, 2, 1, 0, 0
+
+.purgem do_load
+.purgem do_store
+
+
+/*****************************************************************************/
+
+/*
+ * jsimd_fdct_islow_neon
+ *
+ * This file contains a slower but more accurate integer implementation of the
+ * forward DCT (Discrete Cosine Transform). The following code is based
+ * directly on the IJG''s original jfdctint.c; see the jfdctint.c for
+ * more details.
+ *
+ * TODO: can be combined with 'jsimd_convsamp_neon' to get
+ *       rid of a bunch of VLD1.16 instructions
+ */
+
+#define CONST_BITS  13
+#define PASS1_BITS  2
+
+#define DESCALE_P1  (CONST_BITS - PASS1_BITS)
+#define DESCALE_P2  (CONST_BITS + PASS1_BITS)
+
+#define XFIX_P_0_298  v0.h[0]
+#define XFIX_N_0_390  v0.h[1]
+#define XFIX_P_0_541  v0.h[2]
+#define XFIX_P_0_765  v0.h[3]
+#define XFIX_N_0_899  v0.h[4]
+#define XFIX_P_1_175  v0.h[5]
+#define XFIX_P_1_501  v0.h[6]
+#define XFIX_N_1_847  v0.h[7]
+#define XFIX_N_1_961  v1.h[0]
+#define XFIX_P_2_053  v1.h[1]
+#define XFIX_N_2_562  v1.h[2]
+#define XFIX_P_3_072  v1.h[3]
+
+asm_function jsimd_fdct_islow_neon
+
+    DATA            .req x0
+    TMP             .req x9
+
+    /* Load constants */
+    get_symbol_loc  TMP, Ljsimd_fdct_islow_neon_consts
+    ld1             {v0.8h, v1.8h}, [TMP]
+
+    /* Save Neon registers */
+    sub             sp, sp, #64
+    mov             x10, sp
+    st1             {v8.8b, v9.8b, v10.8b, v11.8b}, [x10], 32
+    st1             {v12.8b, v13.8b, v14.8b, v15.8b}, [x10], 32
+
+    /* Load all DATA into Neon registers with the following allocation:
+     *       0 1 2 3 | 4 5 6 7
+     *      ---------+--------
+     *   0 | d16     | d17    | v16.8h
+     *   1 | d18     | d19    | v17.8h
+     *   2 | d20     | d21    | v18.8h
+     *   3 | d22     | d23    | v19.8h
+     *   4 | d24     | d25    | v20.8h
+     *   5 | d26     | d27    | v21.8h
+     *   6 | d28     | d29    | v22.8h
+     *   7 | d30     | d31    | v23.8h
+     */
+
+    ld1             {v16.8h, v17.8h, v18.8h, v19.8h}, [DATA], 64
+    ld1             {v20.8h, v21.8h, v22.8h, v23.8h}, [DATA]
+    sub             DATA, DATA, #64
+
+    /* Transpose */
+    transpose_8x8   v16, v17, v18, v19, v20, v21, v22, v23, v31, v2, v3, v4
+    /* 1-D FDCT */
+    add             v24.8h, v16.8h, v23.8h  /* tmp0 = dataptr[0] + dataptr[7]; */
+    sub             v31.8h, v16.8h, v23.8h  /* tmp7 = dataptr[0] - dataptr[7]; */
+    add             v25.8h, v17.8h, v22.8h  /* tmp1 = dataptr[1] + dataptr[6]; */
+    sub             v30.8h, v17.8h, v22.8h  /* tmp6 = dataptr[1] - dataptr[6]; */
+    add             v26.8h, v18.8h, v21.8h  /* tmp2 = dataptr[2] + dataptr[5]; */
+    sub             v29.8h, v18.8h, v21.8h  /* tmp5 = dataptr[2] - dataptr[5]; */
+    add             v27.8h, v19.8h, v20.8h  /* tmp3 = dataptr[3] + dataptr[4]; */
+    sub             v28.8h, v19.8h, v20.8h  /* tmp4 = dataptr[3] - dataptr[4]; */
+
+    /* even part */
+
+    add             v8.8h, v24.8h, v27.8h   /* tmp10 = tmp0 + tmp3; */
+    sub             v9.8h, v24.8h, v27.8h   /* tmp13 = tmp0 - tmp3; */
+    add             v10.8h, v25.8h, v26.8h  /* tmp11 = tmp1 + tmp2; */
+    sub             v11.8h, v25.8h, v26.8h  /* tmp12 = tmp1 - tmp2; */
+
+    add             v16.8h, v8.8h, v10.8h  /* tmp10 + tmp11 */
+    sub             v20.8h, v8.8h, v10.8h  /* tmp10 - tmp11 */
+
+    add             v18.8h, v11.8h, v9.8h  /* tmp12 + tmp13 */
+
+    shl             v16.8h, v16.8h, #PASS1_BITS  /* dataptr[0] = (DCTELEM)LEFT_SHIFT(tmp10 + tmp11, PASS1_BITS); */
+    shl             v20.8h, v20.8h, #PASS1_BITS  /* dataptr[4] = (DCTELEM)LEFT_SHIFT(tmp10 - tmp11, PASS1_BITS); */
+
+    smull2          v24.4s, v18.8h, XFIX_P_0_541  /* z1 hi = MULTIPLY(tmp12 + tmp13, XFIX_P_0_541); */
+    smull           v18.4s, v18.4h, XFIX_P_0_541  /* z1 lo = MULTIPLY(tmp12 + tmp13, XFIX_P_0_541); */
+    mov             v22.16b, v18.16b
+    mov             v25.16b, v24.16b
+
+    smlal           v18.4s, v9.4h, XFIX_P_0_765   /* lo z1 + MULTIPLY(tmp13, XFIX_P_0_765) */
+    smlal2          v24.4s, v9.8h, XFIX_P_0_765   /* hi z1 + MULTIPLY(tmp13, XFIX_P_0_765) */
+    smlal           v22.4s, v11.4h, XFIX_N_1_847  /* lo z1 + MULTIPLY(tmp12, XFIX_N_1_847) */
+    smlal2          v25.4s, v11.8h, XFIX_N_1_847  /* hi z1 + MULTIPLY(tmp12, XFIX_N_1_847) */
+
+    rshrn           v18.4h, v18.4s, #DESCALE_P1
+    rshrn           v22.4h, v22.4s, #DESCALE_P1
+    rshrn2          v18.8h, v24.4s, #DESCALE_P1  /* dataptr[2] = (DCTELEM)DESCALE(z1 + MULTIPLY(tmp13, XFIX_P_0_765), CONST_BITS-PASS1_BITS); */
+    rshrn2          v22.8h, v25.4s, #DESCALE_P1  /* dataptr[6] = (DCTELEM)DESCALE(z1 + MULTIPLY(tmp12, XFIX_N_1_847), CONST_BITS-PASS1_BITS); */
+
+    /* Odd part */
+
+    add             v8.8h, v28.8h, v31.8h        /* z1 = tmp4 + tmp7; */
+    add             v9.8h, v29.8h, v30.8h        /* z2 = tmp5 + tmp6; */
+    add             v10.8h, v28.8h, v30.8h       /* z3 = tmp4 + tmp6; */
+    add             v11.8h, v29.8h, v31.8h       /* z4 = tmp5 + tmp7; */
+    smull           v4.4s, v10.4h, XFIX_P_1_175  /* z5 lo = z3 lo * XFIX_P_1_175 */
+    smull2          v5.4s, v10.8h, XFIX_P_1_175
+    smlal           v4.4s, v11.4h, XFIX_P_1_175  /* z5 = MULTIPLY(z3 + z4, FIX_1_175875602); */
+    smlal2          v5.4s, v11.8h, XFIX_P_1_175
+
+    smull2          v24.4s, v28.8h, XFIX_P_0_298
+    smull2          v25.4s, v29.8h, XFIX_P_2_053
+    smull2          v26.4s, v30.8h, XFIX_P_3_072
+    smull2          v27.4s, v31.8h, XFIX_P_1_501
+    smull           v28.4s, v28.4h, XFIX_P_0_298  /* tmp4 = MULTIPLY(tmp4, FIX_0_298631336); */
+    smull           v29.4s, v29.4h, XFIX_P_2_053  /* tmp5 = MULTIPLY(tmp5, FIX_2_053119869); */
+    smull           v30.4s, v30.4h, XFIX_P_3_072  /* tmp6 = MULTIPLY(tmp6, FIX_3_072711026); */
+    smull           v31.4s, v31.4h, XFIX_P_1_501  /* tmp7 = MULTIPLY(tmp7, FIX_1_501321110); */
+
+    smull2          v12.4s, v8.8h, XFIX_N_0_899
+    smull2          v13.4s, v9.8h, XFIX_N_2_562
+    smull2          v14.4s, v10.8h, XFIX_N_1_961
+    smull2          v15.4s, v11.8h, XFIX_N_0_390
+    smull           v8.4s, v8.4h, XFIX_N_0_899    /* z1 = MULTIPLY(z1, -FIX_0_899976223); */
+    smull           v9.4s, v9.4h, XFIX_N_2_562    /* z2 = MULTIPLY(z2, -FIX_2_562915447); */
+    smull           v10.4s, v10.4h, XFIX_N_1_961  /* z3 = MULTIPLY(z3, -FIX_1_961570560); */
+    smull           v11.4s, v11.4h, XFIX_N_0_390  /* z4 = MULTIPLY(z4, -FIX_0_390180644); */
+
+    add             v10.4s, v10.4s, v4.4s  /* z3 += z5 */
+    add             v14.4s, v14.4s, v5.4s
+    add             v11.4s, v11.4s, v4.4s  /* z4 += z5 */
+    add             v15.4s, v15.4s, v5.4s
+
+    add             v28.4s, v28.4s, v8.4s   /* tmp4 += z1 */
+    add             v24.4s, v24.4s, v12.4s
+    add             v29.4s, v29.4s, v9.4s   /* tmp5 += z2 */
+    add             v25.4s, v25.4s, v13.4s
+    add             v30.4s, v30.4s, v10.4s  /* tmp6 += z3 */
+    add             v26.4s, v26.4s, v14.4s
+    add             v31.4s, v31.4s, v11.4s  /* tmp7 += z4 */
+    add             v27.4s, v27.4s, v15.4s
+
+    add             v28.4s, v28.4s, v10.4s  /* tmp4 += z3 */
+    add             v24.4s, v24.4s, v14.4s
+    add             v29.4s, v29.4s, v11.4s  /* tmp5 += z4 */
+    add             v25.4s, v25.4s, v15.4s
+    add             v30.4s, v30.4s, v9.4s   /* tmp6 += z2 */
+    add             v26.4s, v26.4s, v13.4s
+    add             v31.4s, v31.4s, v8.4s   /* tmp7 += z1 */
+    add             v27.4s, v27.4s, v12.4s
+
+    rshrn           v23.4h, v28.4s, #DESCALE_P1
+    rshrn           v21.4h, v29.4s, #DESCALE_P1
+    rshrn           v19.4h, v30.4s, #DESCALE_P1
+    rshrn           v17.4h, v31.4s, #DESCALE_P1
+    rshrn2          v23.8h, v24.4s, #DESCALE_P1  /* dataptr[7] = (DCTELEM)DESCALE(tmp4 + z1 + z3, CONST_BITS-PASS1_BITS); */
+    rshrn2          v21.8h, v25.4s, #DESCALE_P1  /* dataptr[5] = (DCTELEM)DESCALE(tmp5 + z2 + z4, CONST_BITS-PASS1_BITS); */
+    rshrn2          v19.8h, v26.4s, #DESCALE_P1  /* dataptr[3] = (DCTELEM)DESCALE(tmp6 + z2 + z3, CONST_BITS-PASS1_BITS); */
+    rshrn2          v17.8h, v27.4s, #DESCALE_P1  /* dataptr[1] = (DCTELEM)DESCALE(tmp7 + z1 + z4, CONST_BITS-PASS1_BITS); */
+
+    /* Transpose */
+    transpose_8x8   v16, v17, v18, v19, v20, v21, v22, v23, v31, v2, v3, v4
+
+    /* 1-D FDCT */
+    add             v24.8h, v16.8h, v23.8h  /* tmp0 = dataptr[0] + dataptr[7]; */
+    sub             v31.8h, v16.8h, v23.8h  /* tmp7 = dataptr[0] - dataptr[7]; */
+    add             v25.8h, v17.8h, v22.8h  /* tmp1 = dataptr[1] + dataptr[6]; */
+    sub             v30.8h, v17.8h, v22.8h  /* tmp6 = dataptr[1] - dataptr[6]; */
+    add             v26.8h, v18.8h, v21.8h  /* tmp2 = dataptr[2] + dataptr[5]; */
+    sub             v29.8h, v18.8h, v21.8h  /* tmp5 = dataptr[2] - dataptr[5]; */
+    add             v27.8h, v19.8h, v20.8h  /* tmp3 = dataptr[3] + dataptr[4]; */
+    sub             v28.8h, v19.8h, v20.8h  /* tmp4 = dataptr[3] - dataptr[4]; */
+
+    /* even part */
+    add             v8.8h, v24.8h, v27.8h   /* tmp10 = tmp0 + tmp3; */
+    sub             v9.8h, v24.8h, v27.8h   /* tmp13 = tmp0 - tmp3; */
+    add             v10.8h, v25.8h, v26.8h  /* tmp11 = tmp1 + tmp2; */
+    sub             v11.8h, v25.8h, v26.8h  /* tmp12 = tmp1 - tmp2; */
+
+    add             v16.8h, v8.8h, v10.8h  /* tmp10 + tmp11 */
+    sub             v20.8h, v8.8h, v10.8h  /* tmp10 - tmp11 */
+
+    add             v18.8h, v11.8h, v9.8h  /* tmp12 + tmp13 */
+
+    srshr           v16.8h, v16.8h, #PASS1_BITS  /* dataptr[0] = (DCTELEM)DESCALE(tmp10 + tmp11, PASS1_BITS); */
+    srshr           v20.8h, v20.8h, #PASS1_BITS  /* dataptr[4] = (DCTELEM)DESCALE(tmp10 - tmp11, PASS1_BITS); */
+
+    smull2          v24.4s, v18.8h, XFIX_P_0_541  /* z1 hi = MULTIPLY(tmp12 + tmp13, XFIX_P_0_541); */
+    smull           v18.4s, v18.4h, XFIX_P_0_541  /* z1 lo = MULTIPLY(tmp12 + tmp13, XFIX_P_0_541); */
+    mov             v22.16b, v18.16b
+    mov             v25.16b, v24.16b
+
+    smlal           v18.4s, v9.4h, XFIX_P_0_765   /* lo z1 + MULTIPLY(tmp13, XFIX_P_0_765) */
+    smlal2          v24.4s, v9.8h, XFIX_P_0_765   /* hi z1 + MULTIPLY(tmp13, XFIX_P_0_765) */
+    smlal           v22.4s, v11.4h, XFIX_N_1_847  /* lo z1 + MULTIPLY(tmp12, XFIX_N_1_847) */
+    smlal2          v25.4s, v11.8h, XFIX_N_1_847  /* hi z1 + MULTIPLY(tmp12, XFIX_N_1_847) */
+
+    rshrn           v18.4h, v18.4s, #DESCALE_P2
+    rshrn           v22.4h, v22.4s, #DESCALE_P2
+    rshrn2          v18.8h, v24.4s, #DESCALE_P2  /* dataptr[2] = (DCTELEM)DESCALE(z1 + MULTIPLY(tmp13, XFIX_P_0_765), CONST_BITS-PASS1_BITS); */
+    rshrn2          v22.8h, v25.4s, #DESCALE_P2  /* dataptr[6] = (DCTELEM)DESCALE(z1 + MULTIPLY(tmp12, XFIX_N_1_847), CONST_BITS-PASS1_BITS); */
+
+    /* Odd part */
+    add             v8.8h, v28.8h, v31.8h   /* z1 = tmp4 + tmp7; */
+    add             v9.8h, v29.8h, v30.8h   /* z2 = tmp5 + tmp6; */
+    add             v10.8h, v28.8h, v30.8h  /* z3 = tmp4 + tmp6; */
+    add             v11.8h, v29.8h, v31.8h  /* z4 = tmp5 + tmp7; */
+
+    smull           v4.4s, v10.4h, XFIX_P_1_175  /* z5 lo = z3 lo * XFIX_P_1_175 */
+    smull2          v5.4s, v10.8h, XFIX_P_1_175
+    smlal           v4.4s, v11.4h, XFIX_P_1_175  /* z5 = MULTIPLY(z3 + z4, FIX_1_175875602); */
+    smlal2          v5.4s, v11.8h, XFIX_P_1_175
+
+    smull2          v24.4s, v28.8h, XFIX_P_0_298
+    smull2          v25.4s, v29.8h, XFIX_P_2_053
+    smull2          v26.4s, v30.8h, XFIX_P_3_072
+    smull2          v27.4s, v31.8h, XFIX_P_1_501
+    smull           v28.4s, v28.4h, XFIX_P_0_298  /* tmp4 = MULTIPLY(tmp4, FIX_0_298631336); */
+    smull           v29.4s, v29.4h, XFIX_P_2_053  /* tmp5 = MULTIPLY(tmp5, FIX_2_053119869); */
+    smull           v30.4s, v30.4h, XFIX_P_3_072  /* tmp6 = MULTIPLY(tmp6, FIX_3_072711026); */
+    smull           v31.4s, v31.4h, XFIX_P_1_501  /* tmp7 = MULTIPLY(tmp7, FIX_1_501321110); */
+
+    smull2          v12.4s, v8.8h, XFIX_N_0_899
+    smull2          v13.4s, v9.8h, XFIX_N_2_562
+    smull2          v14.4s, v10.8h, XFIX_N_1_961
+    smull2          v15.4s, v11.8h, XFIX_N_0_390
+    smull           v8.4s, v8.4h, XFIX_N_0_899    /* z1 = MULTIPLY(z1, -FIX_0_899976223); */
+    smull           v9.4s, v9.4h, XFIX_N_2_562    /* z2 = MULTIPLY(z2, -FIX_2_562915447); */
+    smull           v10.4s, v10.4h, XFIX_N_1_961  /* z3 = MULTIPLY(z3, -FIX_1_961570560); */
+    smull           v11.4s, v11.4h, XFIX_N_0_390  /* z4 = MULTIPLY(z4, -FIX_0_390180644); */
+
+    add             v10.4s, v10.4s, v4.4s
+    add             v14.4s, v14.4s, v5.4s
+    add             v11.4s, v11.4s, v4.4s
+    add             v15.4s, v15.4s, v5.4s
+
+    add             v28.4s, v28.4s, v8.4s   /* tmp4 += z1 */
+    add             v24.4s, v24.4s, v12.4s
+    add             v29.4s, v29.4s, v9.4s   /* tmp5 += z2 */
+    add             v25.4s, v25.4s, v13.4s
+    add             v30.4s, v30.4s, v10.4s  /* tmp6 += z3 */
+    add             v26.4s, v26.4s, v14.4s
+    add             v31.4s, v31.4s, v11.4s  /* tmp7 += z4 */
+    add             v27.4s, v27.4s, v15.4s
+
+    add             v28.4s, v28.4s, v10.4s  /* tmp4 += z3 */
+    add             v24.4s, v24.4s, v14.4s
+    add             v29.4s, v29.4s, v11.4s  /* tmp5 += z4 */
+    add             v25.4s, v25.4s, v15.4s
+    add             v30.4s, v30.4s, v9.4s   /* tmp6 += z2 */
+    add             v26.4s, v26.4s, v13.4s
+    add             v31.4s, v31.4s, v8.4s   /* tmp7 += z1 */
+    add             v27.4s, v27.4s, v12.4s
+
+    rshrn           v23.4h, v28.4s, #DESCALE_P2
+    rshrn           v21.4h, v29.4s, #DESCALE_P2
+    rshrn           v19.4h, v30.4s, #DESCALE_P2
+    rshrn           v17.4h, v31.4s, #DESCALE_P2
+    rshrn2          v23.8h, v24.4s, #DESCALE_P2  /* dataptr[7] = (DCTELEM)DESCALE(tmp4 + z1 + z3, CONST_BITS-PASS1_BITS); */
+    rshrn2          v21.8h, v25.4s, #DESCALE_P2  /* dataptr[5] = (DCTELEM)DESCALE(tmp5 + z2 + z4, CONST_BITS-PASS1_BITS); */
+    rshrn2          v19.8h, v26.4s, #DESCALE_P2  /* dataptr[3] = (DCTELEM)DESCALE(tmp6 + z2 + z3, CONST_BITS-PASS1_BITS); */
+    rshrn2          v17.8h, v27.4s, #DESCALE_P2  /* dataptr[1] = (DCTELEM)DESCALE(tmp7 + z1 + z4, CONST_BITS-PASS1_BITS); */
+
+    /* store results */
+    st1             {v16.8h, v17.8h, v18.8h, v19.8h}, [DATA], 64
+    st1             {v20.8h, v21.8h, v22.8h, v23.8h}, [DATA]
+
+    /* Restore Neon registers */
+    ld1             {v8.8b, v9.8b, v10.8b, v11.8b}, [sp], 32
+    ld1             {v12.8b, v13.8b, v14.8b, v15.8b}, [sp], 32
+
+    br              x30
+
+    .unreq          DATA
+    .unreq          TMP
+
+#undef XFIX_P_0_298
+#undef XFIX_N_0_390
+#undef XFIX_P_0_541
+#undef XFIX_P_0_765
+#undef XFIX_N_0_899
+#undef XFIX_P_1_175
+#undef XFIX_P_1_501
+#undef XFIX_N_1_847
+#undef XFIX_N_1_961
+#undef XFIX_P_2_053
+#undef XFIX_N_2_562
+#undef XFIX_P_3_072
+
+
+/*****************************************************************************/
+
+/*
+ * GLOBAL(JOCTET *)
+ * jsimd_huff_encode_one_block(working_state *state, JOCTET *buffer,
+ *                             JCOEFPTR block, int last_dc_val,
+ *                             c_derived_tbl *dctbl, c_derived_tbl *actbl)
+ *
+ */
+
+    BUFFER          .req x1
+    PUT_BUFFER      .req x6
+    PUT_BITS        .req x7
+    PUT_BITSw       .req w7
+
+.macro emit_byte
+    sub             PUT_BITS, PUT_BITS, #0x8
+    lsr             x19, PUT_BUFFER, PUT_BITS
+    uxtb            w19, w19
+    strb            w19, [BUFFER, #1]!
+    cmp             w19, #0xff
+    b.ne            14f
+    strb            wzr, [BUFFER, #1]!
+14:
+.endm
+.macro put_bits CODE, SIZE
+    lsl             PUT_BUFFER, PUT_BUFFER, \SIZE
+    add             PUT_BITS, PUT_BITS, \SIZE
+    orr             PUT_BUFFER, PUT_BUFFER, \CODE
+.endm
+.macro checkbuf31
+    cmp             PUT_BITS, #0x20
+    b.lt            31f
+    emit_byte
+    emit_byte
+    emit_byte
+    emit_byte
+31:
+.endm
+.macro checkbuf47
+    cmp             PUT_BITS, #0x30
+    b.lt            47f
+    emit_byte
+    emit_byte
+    emit_byte
+    emit_byte
+    emit_byte
+    emit_byte
+47:
+.endm
+
+.macro generate_jsimd_huff_encode_one_block fast_tbl
+
+.if \fast_tbl == 1
+asm_function jsimd_huff_encode_one_block_neon
+.else
+asm_function jsimd_huff_encode_one_block_neon_slowtbl
+.endif
+    sub             sp, sp, 272
+    sub             BUFFER, BUFFER, #0x1    /* BUFFER=buffer-- */
+    /* Save Arm registers */
+    stp             x19, x20, [sp]
+    get_symbol_loc  x15, Ljsimd_huff_encode_one_block_neon_consts
+    ldr             PUT_BUFFER, [x0, #0x10]
+    ldr             PUT_BITSw, [x0, #0x18]
+    ldrsh           w12, [x2]               /* load DC coeff in w12 */
+    /* prepare data */
+.if \fast_tbl == 1
+    ld1             {v23.16b}, [x15], #16
+    ld1             {v0.16b, v1.16b, v2.16b, v3.16b}, [x15], #64
+    ld1             {v4.16b, v5.16b, v6.16b, v7.16b}, [x15], #64
+    ld1             {v16.16b, v17.16b, v18.16b, v19.16b}, [x15], #64
+    ld1             {v24.16b, v25.16b, v26.16b, v27.16b}, [x2], #64
+    ld1             {v28.16b, v29.16b, v30.16b, v31.16b}, [x2], #64
+    sub             w12, w12, w3      /* last_dc_val, not used afterwards */
+    /* ZigZag 8x8 */
+    tbl             v0.16b, {v24.16b, v25.16b, v26.16b, v27.16b}, v0.16b
+    tbl             v1.16b, {v24.16b, v25.16b, v26.16b, v27.16b}, v1.16b
+    tbl             v2.16b, {v25.16b, v26.16b, v27.16b, v28.16b}, v2.16b
+    tbl             v3.16b, {v24.16b, v25.16b, v26.16b, v27.16b}, v3.16b
+    tbl             v4.16b, {v28.16b, v29.16b, v30.16b, v31.16b}, v4.16b
+    tbl             v5.16b, {v25.16b, v26.16b, v27.16b, v28.16b}, v5.16b
+    tbl             v6.16b, {v27.16b, v28.16b, v29.16b, v30.16b}, v6.16b
+    tbl             v7.16b, {v29.16b, v30.16b, v31.16b}, v7.16b
+    ins             v0.h[0], w12
+    tbx             v1.16b, {v28.16b}, v16.16b
+    tbx             v2.16b, {v29.16b, v30.16b}, v17.16b
+    tbx             v5.16b, {v29.16b, v30.16b}, v18.16b
+    tbx             v6.16b, {v31.16b}, v19.16b
+.else
+      add             x13, x2, #0x22
+      sub             w12, w12, w3    /* last_dc_val, not used afterwards */
+    ld1             {v23.16b}, [x15]
+      add             x14, x2, #0x18
+      add             x3, x2, #0x36
+    ins             v0.h[0], w12
+      add             x9, x2, #0x2
+    ld1             {v1.h}[0], [x13]
+      add             x15, x2, #0x30
+    ld1             {v2.h}[0], [x14]
+      add             x19, x2, #0x26
+    ld1             {v3.h}[0], [x3]
+      add             x20, x2, #0x28
+    ld1             {v0.h}[1], [x9]
+      add             x12, x2, #0x10
+    ld1             {v1.h}[1], [x15]
+      add             x13, x2, #0x40
+    ld1             {v2.h}[1], [x19]
+      add             x14, x2, #0x34
+    ld1             {v3.h}[1], [x20]
+      add             x3, x2, #0x1a
+    ld1             {v0.h}[2], [x12]
+      add             x9, x2, #0x20
+    ld1             {v1.h}[2], [x13]
+      add             x15, x2, #0x32
+    ld1             {v2.h}[2], [x14]
+      add             x19, x2, #0x42
+    ld1             {v3.h}[2], [x3]
+      add             x20, x2, #0xc
+    ld1             {v0.h}[3], [x9]
+      add             x12, x2, #0x12
+    ld1             {v1.h}[3], [x15]
+      add             x13, x2, #0x24
+    ld1             {v2.h}[3], [x19]
+      add             x14, x2, #0x50
+    ld1             {v3.h}[3], [x20]
+      add             x3, x2, #0xe
+    ld1             {v0.h}[4], [x12]
+      add             x9, x2, #0x4
+    ld1             {v1.h}[4], [x13]
+      add             x15, x2, #0x16
+    ld1             {v2.h}[4], [x14]
+      add             x19, x2, #0x60
+    ld1             {v3.h}[4], [x3]
+      add             x20, x2, #0x1c
+    ld1             {v0.h}[5], [x9]
+      add             x12, x2, #0x6
+    ld1             {v1.h}[5], [x15]
+      add             x13, x2, #0x8
+    ld1             {v2.h}[5], [x19]
+      add             x14, x2, #0x52
+    ld1             {v3.h}[5], [x20]
+      add             x3, x2, #0x2a
+    ld1             {v0.h}[6], [x12]
+      add             x9, x2, #0x14
+    ld1             {v1.h}[6], [x13]
+      add             x15, x2, #0xa
+    ld1             {v2.h}[6], [x14]
+      add             x19, x2, #0x44
+    ld1             {v3.h}[6], [x3]
+      add             x20, x2, #0x38
+    ld1             {v0.h}[7], [x9]
+      add             x12, x2, #0x46
+    ld1             {v1.h}[7], [x15]
+      add             x13, x2, #0x3a
+    ld1             {v2.h}[7], [x19]
+      add             x14, x2, #0x74
+    ld1             {v3.h}[7], [x20]
+      add             x3, x2, #0x6a
+    ld1             {v4.h}[0], [x12]
+      add             x9, x2, #0x54
+    ld1             {v5.h}[0], [x13]
+      add             x15, x2, #0x2c
+    ld1             {v6.h}[0], [x14]
+      add             x19, x2, #0x76
+    ld1             {v7.h}[0], [x3]
+      add             x20, x2, #0x78
+    ld1             {v4.h}[1], [x9]
+      add             x12, x2, #0x62
+    ld1             {v5.h}[1], [x15]
+      add             x13, x2, #0x1e
+    ld1             {v6.h}[1], [x19]
+      add             x14, x2, #0x68
+    ld1             {v7.h}[1], [x20]
+      add             x3, x2, #0x7a
+    ld1             {v4.h}[2], [x12]
+      add             x9, x2, #0x70
+    ld1             {v5.h}[2], [x13]
+      add             x15, x2, #0x2e
+    ld1             {v6.h}[2], [x14]
+      add             x19, x2, #0x5a
+    ld1             {v7.h}[2], [x3]
+      add             x20, x2, #0x6c
+    ld1             {v4.h}[3], [x9]
+      add             x12, x2, #0x72
+    ld1             {v5.h}[3], [x15]
+      add             x13, x2, #0x3c
+    ld1             {v6.h}[3], [x19]
+      add             x14, x2, #0x4c
+    ld1             {v7.h}[3], [x20]
+      add             x3, x2, #0x5e
+    ld1             {v4.h}[4], [x12]
+      add             x9, x2, #0x64
+    ld1             {v5.h}[4], [x13]
+      add             x15, x2, #0x4a
+    ld1             {v6.h}[4], [x14]
+      add             x19, x2, #0x3e
+    ld1             {v7.h}[4], [x3]
+      add             x20, x2, #0x6e
+    ld1             {v4.h}[5], [x9]
+      add             x12, x2, #0x56
+    ld1             {v5.h}[5], [x15]
+      add             x13, x2, #0x58
+    ld1             {v6.h}[5], [x19]
+      add             x14, x2, #0x4e
+    ld1             {v7.h}[5], [x20]
+      add             x3, x2, #0x7c
+    ld1             {v4.h}[6], [x12]
+      add             x9, x2, #0x48
+    ld1             {v5.h}[6], [x13]
+      add             x15, x2, #0x66
+    ld1             {v6.h}[6], [x14]
+      add             x19, x2, #0x5c
+    ld1             {v7.h}[6], [x3]
+      add             x20, x2, #0x7e
+    ld1             {v4.h}[7], [x9]
+    ld1             {v5.h}[7], [x15]
+    ld1             {v6.h}[7], [x19]
+    ld1             {v7.h}[7], [x20]
+.endif
+    cmlt            v24.8h, v0.8h, #0
+    cmlt            v25.8h, v1.8h, #0
+    cmlt            v26.8h, v2.8h, #0
+    cmlt            v27.8h, v3.8h, #0
+    cmlt            v28.8h, v4.8h, #0
+    cmlt            v29.8h, v5.8h, #0
+    cmlt            v30.8h, v6.8h, #0
+    cmlt            v31.8h, v7.8h, #0
+    abs             v0.8h, v0.8h
+    abs             v1.8h, v1.8h
+    abs             v2.8h, v2.8h
+    abs             v3.8h, v3.8h
+    abs             v4.8h, v4.8h
+    abs             v5.8h, v5.8h
+    abs             v6.8h, v6.8h
+    abs             v7.8h, v7.8h
+    eor             v24.16b, v24.16b, v0.16b
+    eor             v25.16b, v25.16b, v1.16b
+    eor             v26.16b, v26.16b, v2.16b
+    eor             v27.16b, v27.16b, v3.16b
+    eor             v28.16b, v28.16b, v4.16b
+    eor             v29.16b, v29.16b, v5.16b
+    eor             v30.16b, v30.16b, v6.16b
+    eor             v31.16b, v31.16b, v7.16b
+    cmeq            v16.8h, v0.8h, #0
+    cmeq            v17.8h, v1.8h, #0
+    cmeq            v18.8h, v2.8h, #0
+    cmeq            v19.8h, v3.8h, #0
+    cmeq            v20.8h, v4.8h, #0
+    cmeq            v21.8h, v5.8h, #0
+    cmeq            v22.8h, v6.8h, #0
+    xtn             v16.8b, v16.8h
+    xtn             v18.8b, v18.8h
+    xtn             v20.8b, v20.8h
+    xtn             v22.8b, v22.8h
+      umov            w14, v0.h[0]
+    xtn2            v16.16b, v17.8h
+      umov            w13, v24.h[0]
+    xtn2            v18.16b, v19.8h
+      clz             w14, w14
+    xtn2            v20.16b, v21.8h
+      lsl             w13, w13, w14
+    cmeq            v17.8h, v7.8h, #0
+      sub             w12, w14, #32
+    xtn2            v22.16b, v17.8h
+      lsr             w13, w13, w14
+    and             v16.16b, v16.16b, v23.16b
+      neg             w12, w12
+    and             v18.16b, v18.16b, v23.16b
+      add             x3, x4, #0x400           /* r1 = dctbl->ehufsi */
+    and             v20.16b, v20.16b, v23.16b
+      add             x15, sp, #0x90           /* x15 = t2 */
+    and             v22.16b, v22.16b, v23.16b
+      ldr             w10, [x4, x12, lsl #2]
+    addp            v16.16b, v16.16b, v18.16b
+      ldrb            w11, [x3, x12]
+    addp            v20.16b, v20.16b, v22.16b
+      checkbuf47
+    addp            v16.16b, v16.16b, v20.16b
+      put_bits        x10, x11
+    addp            v16.16b, v16.16b, v18.16b
+      checkbuf47
+    umov            x9, v16.D[0]
+      put_bits        x13, x12
+    cnt             v17.8b, v16.8b
+      mvn             x9, x9
+    addv            B18, v17.8b
+      add             x4, x5, #0x400   /* x4 = actbl->ehufsi */
+    umov            w12, v18.b[0]
+      lsr             x9, x9, #0x1     /* clear AC coeff */
+    ldr             w13, [x5, #0x3c0]  /* x13 = actbl->ehufco[0xf0] */
+    rbit            x9, x9             /* x9 = index0 */
+    ldrb            w14, [x4, #0xf0]   /* x14 = actbl->ehufsi[0xf0] */
+    cmp             w12, #(64-8)
+    add             x11, sp, #16
+    b.lt            4f
+    cbz             x9, 6f
+    st1             {v0.8h, v1.8h, v2.8h, v3.8h}, [x11], #64
+    st1             {v4.8h, v5.8h, v6.8h, v7.8h}, [x11], #64
+    st1             {v24.8h, v25.8h, v26.8h, v27.8h}, [x11], #64
+    st1             {v28.8h, v29.8h, v30.8h, v31.8h}, [x11], #64
+1:
+    clz             x2, x9
+    add             x15, x15, x2, lsl #1
+    lsl             x9, x9, x2
+    ldrh            w20, [x15, #-126]
+2:
+    cmp             x2, #0x10
+    b.lt            3f
+    sub             x2, x2, #0x10
+    checkbuf47
+    put_bits        x13, x14
+    b               2b
+3:
+    clz             w20, w20
+    ldrh            w3, [x15, #2]!
+    sub             w11, w20, #32
+    lsl             w3, w3, w20
+    neg             w11, w11
+    lsr             w3, w3, w20
+    add             x2, x11, x2, lsl #4
+    lsl             x9, x9, #0x1
+    ldr             w12, [x5, x2, lsl #2]
+    ldrb            w10, [x4, x2]
+    checkbuf31
+    put_bits        x12, x10
+    put_bits        x3, x11
+    cbnz            x9, 1b
+    b               6f
+4:
+    movi            v21.8h, #0x0010
+    clz             v0.8h, v0.8h
+    clz             v1.8h, v1.8h
+    clz             v2.8h, v2.8h
+    clz             v3.8h, v3.8h
+    clz             v4.8h, v4.8h
+    clz             v5.8h, v5.8h
+    clz             v6.8h, v6.8h
+    clz             v7.8h, v7.8h
+    ushl            v24.8h, v24.8h, v0.8h
+    ushl            v25.8h, v25.8h, v1.8h
+    ushl            v26.8h, v26.8h, v2.8h
+    ushl            v27.8h, v27.8h, v3.8h
+    ushl            v28.8h, v28.8h, v4.8h
+    ushl            v29.8h, v29.8h, v5.8h
+    ushl            v30.8h, v30.8h, v6.8h
+    ushl            v31.8h, v31.8h, v7.8h
+    neg             v0.8h, v0.8h
+    neg             v1.8h, v1.8h
+    neg             v2.8h, v2.8h
+    neg             v3.8h, v3.8h
+    neg             v4.8h, v4.8h
+    neg             v5.8h, v5.8h
+    neg             v6.8h, v6.8h
+    neg             v7.8h, v7.8h
+    ushl            v24.8h, v24.8h, v0.8h
+    ushl            v25.8h, v25.8h, v1.8h
+    ushl            v26.8h, v26.8h, v2.8h
+    ushl            v27.8h, v27.8h, v3.8h
+    ushl            v28.8h, v28.8h, v4.8h
+    ushl            v29.8h, v29.8h, v5.8h
+    ushl            v30.8h, v30.8h, v6.8h
+    ushl            v31.8h, v31.8h, v7.8h
+    add             v0.8h, v21.8h, v0.8h
+    add             v1.8h, v21.8h, v1.8h
+    add             v2.8h, v21.8h, v2.8h
+    add             v3.8h, v21.8h, v3.8h
+    add             v4.8h, v21.8h, v4.8h
+    add             v5.8h, v21.8h, v5.8h
+    add             v6.8h, v21.8h, v6.8h
+    add             v7.8h, v21.8h, v7.8h
+    st1             {v0.8h, v1.8h, v2.8h, v3.8h}, [x11], #64
+    st1             {v4.8h, v5.8h, v6.8h, v7.8h}, [x11], #64
+    st1             {v24.8h, v25.8h, v26.8h, v27.8h}, [x11], #64
+    st1             {v28.8h, v29.8h, v30.8h, v31.8h}, [x11], #64
+1:
+    clz             x2, x9
+    add             x15, x15, x2, lsl #1
+    lsl             x9, x9, x2
+    ldrh            w11, [x15, #-126]
+2:
+    cmp             x2, #0x10
+    b.lt            3f
+    sub             x2, x2, #0x10
+    checkbuf47
+    put_bits        x13, x14
+    b               2b
+3:
+    ldrh            w3, [x15, #2]!
+    add             x2, x11, x2, lsl #4
+    lsl             x9, x9, #0x1
+    ldr             w12, [x5, x2, lsl #2]
+    ldrb            w10, [x4, x2]
+    checkbuf31
+    put_bits        x12, x10
+    put_bits        x3, x11
+    cbnz            x9, 1b
+6:
+    add             x13, sp, #0x10e
+    cmp             x15, x13
+    b.hs            1f
+    ldr             w12, [x5]
+    ldrb            w14, [x4]
+    checkbuf47
+    put_bits        x12, x14
+1:
+    str             PUT_BUFFER, [x0, #0x10]
+    str             PUT_BITSw, [x0, #0x18]
+    ldp             x19, x20, [sp], 16
+    add             x0, BUFFER, #0x1
+    add             sp, sp, 256
+    br              x30
+
+.endm
+
+generate_jsimd_huff_encode_one_block 1
+generate_jsimd_huff_encode_one_block 0
+
+    .unreq          BUFFER
+    .unreq          PUT_BUFFER
+    .unreq          PUT_BITS
+    .unreq          PUT_BITSw
+
+.purgem emit_byte
+.purgem put_bits
+.purgem checkbuf31
+.purgem checkbuf47
diff --git a/3rdparty/libjpeg/src/simd/arm/align.h b/3rdparty/libjpeg/src/simd/arm/align.h
new file mode 100644
index 00000000..cff4241e
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/arm/align.h
@@ -0,0 +1,28 @@
+/*
+ * Copyright (C) 2020, Arm Limited.  All Rights Reserved.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+/* How to obtain memory alignment for structures and variables */
+#if defined(_MSC_VER)
+#define ALIGN(alignment)  __declspec(align(alignment))
+#elif defined(__clang__) || defined(__GNUC__)
+#define ALIGN(alignment)  __attribute__((aligned(alignment)))
+#else
+#error "Unknown compiler"
+#endif
diff --git a/3rdparty/libjpeg/src/simd/arm/jccolor-neon.c b/3rdparty/libjpeg/src/simd/arm/jccolor-neon.c
new file mode 100644
index 00000000..9fcc62dd
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/arm/jccolor-neon.c
@@ -0,0 +1,160 @@
+/*
+ * jccolor-neon.c - colorspace conversion (Arm Neon)
+ *
+ * Copyright (C) 2020, Arm Limited.  All Rights Reserved.
+ * Copyright (C) 2020, D. R. Commander.  All Rights Reserved.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+#define JPEG_INTERNALS
+#include "../../jinclude.h"
+#include "../../jpeglib.h"
+#include "../../jsimd.h"
+#include "../../jdct.h"
+#include "../../jsimddct.h"
+#include "../jsimd.h"
+#include "align.h"
+#include "neon-compat.h"
+
+#include <arm_neon.h>
+
+
+/* RGB -> YCbCr conversion constants */
+
+#define F_0_298  19595
+#define F_0_587  38470
+#define F_0_113  7471
+#define F_0_168  11059
+#define F_0_331  21709
+#define F_0_500  32768
+#define F_0_418  27439
+#define F_0_081  5329
+
+ALIGN(16) static const uint16_t jsimd_rgb_ycc_neon_consts[] = {
+  F_0_298, F_0_587, F_0_113, F_0_168,
+  F_0_331, F_0_500, F_0_418, F_0_081
+};
+
+
+/* Include inline routines for colorspace extensions. */
+
+#if defined(__aarch64__) || defined(_M_ARM64)
+#include "aarch64/jccolext-neon.c"
+#else
+#include "aarch32/jccolext-neon.c"
+#endif
+#undef RGB_RED
+#undef RGB_GREEN
+#undef RGB_BLUE
+#undef RGB_PIXELSIZE
+
+#define RGB_RED  EXT_RGB_RED
+#define RGB_GREEN  EXT_RGB_GREEN
+#define RGB_BLUE  EXT_RGB_BLUE
+#define RGB_PIXELSIZE  EXT_RGB_PIXELSIZE
+#define jsimd_rgb_ycc_convert_neon  jsimd_extrgb_ycc_convert_neon
+#if defined(__aarch64__) || defined(_M_ARM64)
+#include "aarch64/jccolext-neon.c"
+#else
+#include "aarch32/jccolext-neon.c"
+#endif
+#undef RGB_RED
+#undef RGB_GREEN
+#undef RGB_BLUE
+#undef RGB_PIXELSIZE
+#undef jsimd_rgb_ycc_convert_neon
+
+#define RGB_RED  EXT_RGBX_RED
+#define RGB_GREEN  EXT_RGBX_GREEN
+#define RGB_BLUE  EXT_RGBX_BLUE
+#define RGB_PIXELSIZE  EXT_RGBX_PIXELSIZE
+#define jsimd_rgb_ycc_convert_neon  jsimd_extrgbx_ycc_convert_neon
+#if defined(__aarch64__) || defined(_M_ARM64)
+#include "aarch64/jccolext-neon.c"
+#else
+#include "aarch32/jccolext-neon.c"
+#endif
+#undef RGB_RED
+#undef RGB_GREEN
+#undef RGB_BLUE
+#undef RGB_PIXELSIZE
+#undef jsimd_rgb_ycc_convert_neon
+
+#define RGB_RED  EXT_BGR_RED
+#define RGB_GREEN  EXT_BGR_GREEN
+#define RGB_BLUE  EXT_BGR_BLUE
+#define RGB_PIXELSIZE  EXT_BGR_PIXELSIZE
+#define jsimd_rgb_ycc_convert_neon  jsimd_extbgr_ycc_convert_neon
+#if defined(__aarch64__) || defined(_M_ARM64)
+#include "aarch64/jccolext-neon.c"
+#else
+#include "aarch32/jccolext-neon.c"
+#endif
+#undef RGB_RED
+#undef RGB_GREEN
+#undef RGB_BLUE
+#undef RGB_PIXELSIZE
+#undef jsimd_rgb_ycc_convert_neon
+
+#define RGB_RED  EXT_BGRX_RED
+#define RGB_GREEN  EXT_BGRX_GREEN
+#define RGB_BLUE  EXT_BGRX_BLUE
+#define RGB_PIXELSIZE  EXT_BGRX_PIXELSIZE
+#define jsimd_rgb_ycc_convert_neon  jsimd_extbgrx_ycc_convert_neon
+#if defined(__aarch64__) || defined(_M_ARM64)
+#include "aarch64/jccolext-neon.c"
+#else
+#include "aarch32/jccolext-neon.c"
+#endif
+#undef RGB_RED
+#undef RGB_GREEN
+#undef RGB_BLUE
+#undef RGB_PIXELSIZE
+#undef jsimd_rgb_ycc_convert_neon
+
+#define RGB_RED  EXT_XBGR_RED
+#define RGB_GREEN  EXT_XBGR_GREEN
+#define RGB_BLUE  EXT_XBGR_BLUE
+#define RGB_PIXELSIZE  EXT_XBGR_PIXELSIZE
+#define jsimd_rgb_ycc_convert_neon  jsimd_extxbgr_ycc_convert_neon
+#if defined(__aarch64__) || defined(_M_ARM64)
+#include "aarch64/jccolext-neon.c"
+#else
+#include "aarch32/jccolext-neon.c"
+#endif
+#undef RGB_RED
+#undef RGB_GREEN
+#undef RGB_BLUE
+#undef RGB_PIXELSIZE
+#undef jsimd_rgb_ycc_convert_neon
+
+#define RGB_RED  EXT_XRGB_RED
+#define RGB_GREEN  EXT_XRGB_GREEN
+#define RGB_BLUE  EXT_XRGB_BLUE
+#define RGB_PIXELSIZE  EXT_XRGB_PIXELSIZE
+#define jsimd_rgb_ycc_convert_neon  jsimd_extxrgb_ycc_convert_neon
+#if defined(__aarch64__) || defined(_M_ARM64)
+#include "aarch64/jccolext-neon.c"
+#else
+#include "aarch32/jccolext-neon.c"
+#endif
+#undef RGB_RED
+#undef RGB_GREEN
+#undef RGB_BLUE
+#undef RGB_PIXELSIZE
+#undef jsimd_rgb_ycc_convert_neon
diff --git a/3rdparty/libjpeg/src/simd/arm/jcgray-neon.c b/3rdparty/libjpeg/src/simd/arm/jcgray-neon.c
new file mode 100644
index 00000000..71c7b2de
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/arm/jcgray-neon.c
@@ -0,0 +1,120 @@
+/*
+ * jcgray-neon.c - grayscale colorspace conversion (Arm Neon)
+ *
+ * Copyright (C) 2020, Arm Limited.  All Rights Reserved.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+#define JPEG_INTERNALS
+#include "../../jinclude.h"
+#include "../../jpeglib.h"
+#include "../../jsimd.h"
+#include "../../jdct.h"
+#include "../../jsimddct.h"
+#include "../jsimd.h"
+#include "align.h"
+
+#include <arm_neon.h>
+
+
+/* RGB -> Grayscale conversion constants */
+
+#define F_0_298  19595
+#define F_0_587  38470
+#define F_0_113  7471
+
+
+/* Include inline routines for colorspace extensions. */
+
+#include "jcgryext-neon.c"
+#undef RGB_RED
+#undef RGB_GREEN
+#undef RGB_BLUE
+#undef RGB_PIXELSIZE
+
+#define RGB_RED  EXT_RGB_RED
+#define RGB_GREEN  EXT_RGB_GREEN
+#define RGB_BLUE  EXT_RGB_BLUE
+#define RGB_PIXELSIZE  EXT_RGB_PIXELSIZE
+#define jsimd_rgb_gray_convert_neon  jsimd_extrgb_gray_convert_neon
+#include "jcgryext-neon.c"
+#undef RGB_RED
+#undef RGB_GREEN
+#undef RGB_BLUE
+#undef RGB_PIXELSIZE
+#undef jsimd_rgb_gray_convert_neon
+
+#define RGB_RED  EXT_RGBX_RED
+#define RGB_GREEN  EXT_RGBX_GREEN
+#define RGB_BLUE  EXT_RGBX_BLUE
+#define RGB_PIXELSIZE  EXT_RGBX_PIXELSIZE
+#define jsimd_rgb_gray_convert_neon  jsimd_extrgbx_gray_convert_neon
+#include "jcgryext-neon.c"
+#undef RGB_RED
+#undef RGB_GREEN
+#undef RGB_BLUE
+#undef RGB_PIXELSIZE
+#undef jsimd_rgb_gray_convert_neon
+
+#define RGB_RED  EXT_BGR_RED
+#define RGB_GREEN  EXT_BGR_GREEN
+#define RGB_BLUE  EXT_BGR_BLUE
+#define RGB_PIXELSIZE  EXT_BGR_PIXELSIZE
+#define jsimd_rgb_gray_convert_neon  jsimd_extbgr_gray_convert_neon
+#include "jcgryext-neon.c"
+#undef RGB_RED
+#undef RGB_GREEN
+#undef RGB_BLUE
+#undef RGB_PIXELSIZE
+#undef jsimd_rgb_gray_convert_neon
+
+#define RGB_RED  EXT_BGRX_RED
+#define RGB_GREEN  EXT_BGRX_GREEN
+#define RGB_BLUE  EXT_BGRX_BLUE
+#define RGB_PIXELSIZE  EXT_BGRX_PIXELSIZE
+#define jsimd_rgb_gray_convert_neon  jsimd_extbgrx_gray_convert_neon
+#include "jcgryext-neon.c"
+#undef RGB_RED
+#undef RGB_GREEN
+#undef RGB_BLUE
+#undef RGB_PIXELSIZE
+#undef jsimd_rgb_gray_convert_neon
+
+#define RGB_RED  EXT_XBGR_RED
+#define RGB_GREEN  EXT_XBGR_GREEN
+#define RGB_BLUE  EXT_XBGR_BLUE
+#define RGB_PIXELSIZE  EXT_XBGR_PIXELSIZE
+#define jsimd_rgb_gray_convert_neon  jsimd_extxbgr_gray_convert_neon
+#include "jcgryext-neon.c"
+#undef RGB_RED
+#undef RGB_GREEN
+#undef RGB_BLUE
+#undef RGB_PIXELSIZE
+#undef jsimd_rgb_gray_convert_neon
+
+#define RGB_RED  EXT_XRGB_RED
+#define RGB_GREEN  EXT_XRGB_GREEN
+#define RGB_BLUE  EXT_XRGB_BLUE
+#define RGB_PIXELSIZE  EXT_XRGB_PIXELSIZE
+#define jsimd_rgb_gray_convert_neon  jsimd_extxrgb_gray_convert_neon
+#include "jcgryext-neon.c"
+#undef RGB_RED
+#undef RGB_GREEN
+#undef RGB_BLUE
+#undef RGB_PIXELSIZE
+#undef jsimd_rgb_gray_convert_neon
diff --git a/3rdparty/libjpeg/src/simd/arm/jcgryext-neon.c b/3rdparty/libjpeg/src/simd/arm/jcgryext-neon.c
new file mode 100644
index 00000000..416a7385
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/arm/jcgryext-neon.c
@@ -0,0 +1,106 @@
+/*
+ * jcgryext-neon.c - grayscale colorspace conversion (Arm Neon)
+ *
+ * Copyright (C) 2020, Arm Limited.  All Rights Reserved.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+/* This file is included by jcgray-neon.c */
+
+
+/* RGB -> Grayscale conversion is defined by the following equation:
+ *    Y  =  0.29900 * R + 0.58700 * G + 0.11400 * B
+ *
+ * Avoid floating point arithmetic by using shifted integer constants:
+ *    0.29899597 = 19595 * 2^-16
+ *    0.58700561 = 38470 * 2^-16
+ *    0.11399841 =  7471 * 2^-16
+ * These constants are defined in jcgray-neon.c
+ *
+ * This is the same computation as the RGB -> Y portion of RGB -> YCbCr.
+ */
+
+void jsimd_rgb_gray_convert_neon(JDIMENSION image_width, JSAMPARRAY input_buf,
+                                 JSAMPIMAGE output_buf, JDIMENSION output_row,
+                                 int num_rows)
+{
+  JSAMPROW inptr;
+  JSAMPROW outptr;
+  /* Allocate temporary buffer for final (image_width % 16) pixels in row. */
+  ALIGN(16) uint8_t tmp_buf[16 * RGB_PIXELSIZE];
+
+  while (--num_rows >= 0) {
+    inptr = *input_buf++;
+    outptr = output_buf[0][output_row];
+    output_row++;
+
+    int cols_remaining = image_width;
+    for (; cols_remaining > 0; cols_remaining -= 16) {
+
+      /* To prevent buffer overread by the vector load instructions, the last
+       * (image_width % 16) columns of data are first memcopied to a temporary
+       * buffer large enough to accommodate the vector load.
+       */
+      if (cols_remaining < 16) {
+        memcpy(tmp_buf, inptr, cols_remaining * RGB_PIXELSIZE);
+        inptr = tmp_buf;
+      }
+
+#if RGB_PIXELSIZE == 4
+      uint8x16x4_t input_pixels = vld4q_u8(inptr);
+#else
+      uint8x16x3_t input_pixels = vld3q_u8(inptr);
+#endif
+      uint16x8_t r_l = vmovl_u8(vget_low_u8(input_pixels.val[RGB_RED]));
+      uint16x8_t r_h = vmovl_u8(vget_high_u8(input_pixels.val[RGB_RED]));
+      uint16x8_t g_l = vmovl_u8(vget_low_u8(input_pixels.val[RGB_GREEN]));
+      uint16x8_t g_h = vmovl_u8(vget_high_u8(input_pixels.val[RGB_GREEN]));
+      uint16x8_t b_l = vmovl_u8(vget_low_u8(input_pixels.val[RGB_BLUE]));
+      uint16x8_t b_h = vmovl_u8(vget_high_u8(input_pixels.val[RGB_BLUE]));
+
+      /* Compute Y = 0.29900 * R + 0.58700 * G + 0.11400 * B */
+      uint32x4_t y_ll = vmull_n_u16(vget_low_u16(r_l), F_0_298);
+      uint32x4_t y_lh = vmull_n_u16(vget_high_u16(r_l), F_0_298);
+      uint32x4_t y_hl = vmull_n_u16(vget_low_u16(r_h), F_0_298);
+      uint32x4_t y_hh = vmull_n_u16(vget_high_u16(r_h), F_0_298);
+      y_ll = vmlal_n_u16(y_ll, vget_low_u16(g_l), F_0_587);
+      y_lh = vmlal_n_u16(y_lh, vget_high_u16(g_l), F_0_587);
+      y_hl = vmlal_n_u16(y_hl, vget_low_u16(g_h), F_0_587);
+      y_hh = vmlal_n_u16(y_hh, vget_high_u16(g_h), F_0_587);
+      y_ll = vmlal_n_u16(y_ll, vget_low_u16(b_l), F_0_113);
+      y_lh = vmlal_n_u16(y_lh, vget_high_u16(b_l), F_0_113);
+      y_hl = vmlal_n_u16(y_hl, vget_low_u16(b_h), F_0_113);
+      y_hh = vmlal_n_u16(y_hh, vget_high_u16(b_h), F_0_113);
+
+      /* Descale Y values (rounding right shift) and narrow to 16-bit. */
+      uint16x8_t y_l = vcombine_u16(vrshrn_n_u32(y_ll, 16),
+                                    vrshrn_n_u32(y_lh, 16));
+      uint16x8_t y_h = vcombine_u16(vrshrn_n_u32(y_hl, 16),
+                                    vrshrn_n_u32(y_hh, 16));
+
+      /* Narrow Y values to 8-bit and store to memory.  Buffer overwrite is
+       * permitted up to the next multiple of ALIGN_SIZE bytes.
+       */
+      vst1q_u8(outptr, vcombine_u8(vmovn_u16(y_l), vmovn_u16(y_h)));
+
+      /* Increment pointers. */
+      inptr += (16 * RGB_PIXELSIZE);
+      outptr += 16;
+    }
+  }
+}
diff --git a/3rdparty/libjpeg/src/simd/arm/jchuff.h b/3rdparty/libjpeg/src/simd/arm/jchuff.h
new file mode 100644
index 00000000..d30759f5
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/arm/jchuff.h
@@ -0,0 +1,149 @@
+/*
+ * jchuff.h
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1991-1997, Thomas G. Lane.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2009, 2018, D. R. Commander.
+ * Copyright (C) 2018, Matthias Räncker.
+ * Copyright (C) 2020, Arm Limited.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ */
+
+/* Expanded entropy encoder object for Huffman encoding.
+ *
+ * The savable_state subrecord contains fields that change within an MCU,
+ * but must not be updated permanently until we complete the MCU.
+ */
+
+#if defined(__aarch64__) || defined(_M_ARM64)
+#define BIT_BUF_SIZE  64
+#else
+#define BIT_BUF_SIZE  32
+#endif
+
+typedef struct {
+  size_t put_buffer;                    /* current bit accumulation buffer */
+  int free_bits;                        /* # of bits available in it */
+  int last_dc_val[MAX_COMPS_IN_SCAN];   /* last DC coef for each component */
+} savable_state;
+
+typedef struct {
+  JOCTET *next_output_byte;     /* => next byte to write in buffer */
+  size_t free_in_buffer;        /* # of byte spaces remaining in buffer */
+  savable_state cur;            /* Current bit buffer & DC state */
+  j_compress_ptr cinfo;         /* dump_buffer needs access to this */
+  int simd;
+} working_state;
+
+/* Outputting bits to the file */
+
+/* Output byte b and, speculatively, an additional 0 byte. 0xFF must be encoded
+ * as 0xFF 0x00, so the output buffer pointer is advanced by 2 if the byte is
+ * 0xFF.  Otherwise, the output buffer pointer is advanced by 1, and the
+ * speculative 0 byte will be overwritten by the next byte.
+ */
+#define EMIT_BYTE(b) { \
+  buffer[0] = (JOCTET)(b); \
+  buffer[1] = 0; \
+  buffer -= -2 + ((JOCTET)(b) < 0xFF); \
+}
+
+/* Output the entire bit buffer.  If there are no 0xFF bytes in it, then write
+ * directly to the output buffer.  Otherwise, use the EMIT_BYTE() macro to
+ * encode 0xFF as 0xFF 0x00.
+ */
+#if defined(__aarch64__) || defined(_M_ARM64)
+
+#if defined(_MSC_VER) && !defined(__clang__)
+#define SPLAT() { \
+  buffer[0] = (JOCTET)(put_buffer >> 56); \
+  buffer[1] = (JOCTET)(put_buffer >> 48); \
+  buffer[2] = (JOCTET)(put_buffer >> 40); \
+  buffer[3] = (JOCTET)(put_buffer >> 32); \
+  buffer[4] = (JOCTET)(put_buffer >> 24); \
+  buffer[5] = (JOCTET)(put_buffer >> 16); \
+  buffer[6] = (JOCTET)(put_buffer >>  8); \
+  buffer[7] = (JOCTET)(put_buffer      ); \
+}
+#else
+#define SPLAT() { \
+  __asm__("rev %x0, %x1" : "=r"(put_buffer) : "r"(put_buffer)); \
+  *((uint64_t *)buffer) = put_buffer; \
+}
+#endif
+
+#define FLUSH() { \
+  if (put_buffer & 0x8080808080808080 & ~(put_buffer + 0x0101010101010101)) { \
+    EMIT_BYTE(put_buffer >> 56) \
+    EMIT_BYTE(put_buffer >> 48) \
+    EMIT_BYTE(put_buffer >> 40) \
+    EMIT_BYTE(put_buffer >> 32) \
+    EMIT_BYTE(put_buffer >> 24) \
+    EMIT_BYTE(put_buffer >> 16) \
+    EMIT_BYTE(put_buffer >>  8) \
+    EMIT_BYTE(put_buffer      ) \
+  } else { \
+    SPLAT() \
+    buffer += 8; \
+  } \
+}
+
+#else
+
+#if defined(_MSC_VER) && !defined(__clang__)
+#define SPLAT() { \
+  buffer[0] = (JOCTET)(put_buffer >> 24); \
+  buffer[1] = (JOCTET)(put_buffer >> 16); \
+  buffer[2] = (JOCTET)(put_buffer >>  8); \
+  buffer[3] = (JOCTET)(put_buffer      ); \
+}
+#else
+#define SPLAT() { \
+  __asm__("rev %0, %1" : "=r"(put_buffer) : "r"(put_buffer)); \
+  *((uint32_t *)buffer) = put_buffer; \
+}
+#endif
+
+#define FLUSH() { \
+  if (put_buffer & 0x80808080 & ~(put_buffer + 0x01010101)) { \
+    EMIT_BYTE(put_buffer >> 24) \
+    EMIT_BYTE(put_buffer >> 16) \
+    EMIT_BYTE(put_buffer >>  8) \
+    EMIT_BYTE(put_buffer      ) \
+  } else { \
+    SPLAT() \
+    buffer += 4; \
+  } \
+}
+
+#endif
+
+/* Fill the bit buffer to capacity with the leading bits from code, then output
+ * the bit buffer and put the remaining bits from code into the bit buffer.
+ */
+#define PUT_AND_FLUSH(code, size) { \
+  put_buffer = (put_buffer << (size + free_bits)) | (code >> -free_bits); \
+  FLUSH() \
+  free_bits += BIT_BUF_SIZE; \
+  put_buffer = code; \
+}
+
+/* Insert code into the bit buffer and output the bit buffer if needed.
+ * NOTE: We can't flush with free_bits == 0, since the left shift in
+ * PUT_AND_FLUSH() would have undefined behavior.
+ */
+#define PUT_BITS(code, size) { \
+  free_bits -= size; \
+  if (free_bits < 0) \
+    PUT_AND_FLUSH(code, size) \
+  else \
+    put_buffer = (put_buffer << size) | code; \
+}
+
+#define PUT_CODE(code, size, diff) { \
+  diff |= code << nbits; \
+  nbits += size; \
+  PUT_BITS(diff, nbits) \
+}
diff --git a/3rdparty/libjpeg/src/simd/arm/jcphuff-neon.c b/3rdparty/libjpeg/src/simd/arm/jcphuff-neon.c
new file mode 100644
index 00000000..8b6d53be
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/arm/jcphuff-neon.c
@@ -0,0 +1,591 @@
+/*
+ * jcphuff-neon.c - prepare data for progressive Huffman encoding (Arm Neon)
+ *
+ * Copyright (C) 2020, Arm Limited.  All Rights Reserved.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+#define JPEG_INTERNALS
+#include "../../jinclude.h"
+#include "../../jpeglib.h"
+#include "../../jsimd.h"
+#include "../../jdct.h"
+#include "../../jsimddct.h"
+#include "../jsimd.h"
+#include "neon-compat.h"
+
+#include <arm_neon.h>
+
+
+/* Data preparation for encode_mcu_AC_first().
+ *
+ * The equivalent scalar C function (encode_mcu_AC_first_prepare()) can be
+ * found in jcphuff.c.
+ */
+
+void jsimd_encode_mcu_AC_first_prepare_neon
+  (const JCOEF *block, const int *jpeg_natural_order_start, int Sl, int Al,
+   JCOEF *values, size_t *zerobits)
+{
+  JCOEF *values_ptr = values;
+  JCOEF *diff_values_ptr = values + DCTSIZE2;
+
+  /* Rows of coefficients to zero (since they haven't been processed) */
+  int i, rows_to_zero = 8;
+
+  for (i = 0; i < Sl / 16; i++) {
+    int16x8_t coefs1 = vld1q_dup_s16(block + jpeg_natural_order_start[0]);
+    coefs1 = vld1q_lane_s16(block + jpeg_natural_order_start[1], coefs1, 1);
+    coefs1 = vld1q_lane_s16(block + jpeg_natural_order_start[2], coefs1, 2);
+    coefs1 = vld1q_lane_s16(block + jpeg_natural_order_start[3], coefs1, 3);
+    coefs1 = vld1q_lane_s16(block + jpeg_natural_order_start[4], coefs1, 4);
+    coefs1 = vld1q_lane_s16(block + jpeg_natural_order_start[5], coefs1, 5);
+    coefs1 = vld1q_lane_s16(block + jpeg_natural_order_start[6], coefs1, 6);
+    coefs1 = vld1q_lane_s16(block + jpeg_natural_order_start[7], coefs1, 7);
+    int16x8_t coefs2 = vld1q_dup_s16(block + jpeg_natural_order_start[8]);
+    coefs2 = vld1q_lane_s16(block + jpeg_natural_order_start[9], coefs2, 1);
+    coefs2 = vld1q_lane_s16(block + jpeg_natural_order_start[10], coefs2, 2);
+    coefs2 = vld1q_lane_s16(block + jpeg_natural_order_start[11], coefs2, 3);
+    coefs2 = vld1q_lane_s16(block + jpeg_natural_order_start[12], coefs2, 4);
+    coefs2 = vld1q_lane_s16(block + jpeg_natural_order_start[13], coefs2, 5);
+    coefs2 = vld1q_lane_s16(block + jpeg_natural_order_start[14], coefs2, 6);
+    coefs2 = vld1q_lane_s16(block + jpeg_natural_order_start[15], coefs2, 7);
+
+    /* Isolate sign of coefficients. */
+    int16x8_t sign_coefs1 = vshrq_n_s16(coefs1, 15);
+    int16x8_t sign_coefs2 = vshrq_n_s16(coefs2, 15);
+    /* Compute absolute value of coefficients and apply point transform Al. */
+    int16x8_t abs_coefs1 = vabsq_s16(coefs1);
+    int16x8_t abs_coefs2 = vabsq_s16(coefs2);
+    coefs1 = vshlq_s16(abs_coefs1, vdupq_n_s16(-Al));
+    coefs2 = vshlq_s16(abs_coefs2, vdupq_n_s16(-Al));
+
+    /* Compute diff values. */
+    int16x8_t diff1 = veorq_s16(coefs1, sign_coefs1);
+    int16x8_t diff2 = veorq_s16(coefs2, sign_coefs2);
+
+    /* Store transformed coefficients and diff values. */
+    vst1q_s16(values_ptr, coefs1);
+    vst1q_s16(values_ptr + DCTSIZE, coefs2);
+    vst1q_s16(diff_values_ptr, diff1);
+    vst1q_s16(diff_values_ptr + DCTSIZE, diff2);
+    values_ptr += 16;
+    diff_values_ptr += 16;
+    jpeg_natural_order_start += 16;
+    rows_to_zero -= 2;
+  }
+
+  /* Same operation but for remaining partial vector */
+  int remaining_coefs = Sl % 16;
+  if (remaining_coefs > 8) {
+    int16x8_t coefs1 = vld1q_dup_s16(block + jpeg_natural_order_start[0]);
+    coefs1 = vld1q_lane_s16(block + jpeg_natural_order_start[1], coefs1, 1);
+    coefs1 = vld1q_lane_s16(block + jpeg_natural_order_start[2], coefs1, 2);
+    coefs1 = vld1q_lane_s16(block + jpeg_natural_order_start[3], coefs1, 3);
+    coefs1 = vld1q_lane_s16(block + jpeg_natural_order_start[4], coefs1, 4);
+    coefs1 = vld1q_lane_s16(block + jpeg_natural_order_start[5], coefs1, 5);
+    coefs1 = vld1q_lane_s16(block + jpeg_natural_order_start[6], coefs1, 6);
+    coefs1 = vld1q_lane_s16(block + jpeg_natural_order_start[7], coefs1, 7);
+    int16x8_t coefs2 = vdupq_n_s16(0);
+    switch (remaining_coefs) {
+    case 15:
+      coefs2 = vld1q_lane_s16(block + jpeg_natural_order_start[14], coefs2, 6);
+    case 14:
+      coefs2 = vld1q_lane_s16(block + jpeg_natural_order_start[13], coefs2, 5);
+    case 13:
+      coefs2 = vld1q_lane_s16(block + jpeg_natural_order_start[12], coefs2, 4);
+    case 12:
+      coefs2 = vld1q_lane_s16(block + jpeg_natural_order_start[11], coefs2, 3);
+    case 11:
+      coefs2 = vld1q_lane_s16(block + jpeg_natural_order_start[10], coefs2, 2);
+    case 10:
+      coefs2 = vld1q_lane_s16(block + jpeg_natural_order_start[9], coefs2, 1);
+    case 9:
+      coefs2 = vld1q_lane_s16(block + jpeg_natural_order_start[8], coefs2, 0);
+    default:
+      break;
+    }
+
+    /* Isolate sign of coefficients. */
+    int16x8_t sign_coefs1 = vshrq_n_s16(coefs1, 15);
+    int16x8_t sign_coefs2 = vshrq_n_s16(coefs2, 15);
+    /* Compute absolute value of coefficients and apply point transform Al. */
+    int16x8_t abs_coefs1 = vabsq_s16(coefs1);
+    int16x8_t abs_coefs2 = vabsq_s16(coefs2);
+    coefs1 = vshlq_s16(abs_coefs1, vdupq_n_s16(-Al));
+    coefs2 = vshlq_s16(abs_coefs2, vdupq_n_s16(-Al));
+
+    /* Compute diff values. */
+    int16x8_t diff1 = veorq_s16(coefs1, sign_coefs1);
+    int16x8_t diff2 = veorq_s16(coefs2, sign_coefs2);
+
+    /* Store transformed coefficients and diff values. */
+    vst1q_s16(values_ptr, coefs1);
+    vst1q_s16(values_ptr + DCTSIZE, coefs2);
+    vst1q_s16(diff_values_ptr, diff1);
+    vst1q_s16(diff_values_ptr + DCTSIZE, diff2);
+    values_ptr += 16;
+    diff_values_ptr += 16;
+    rows_to_zero -= 2;
+
+  } else if (remaining_coefs > 0) {
+    int16x8_t coefs = vdupq_n_s16(0);
+
+    switch (remaining_coefs) {
+    case 8:
+      coefs = vld1q_lane_s16(block + jpeg_natural_order_start[7], coefs, 7);
+    case 7:
+      coefs = vld1q_lane_s16(block + jpeg_natural_order_start[6], coefs, 6);
+    case 6:
+      coefs = vld1q_lane_s16(block + jpeg_natural_order_start[5], coefs, 5);
+    case 5:
+      coefs = vld1q_lane_s16(block + jpeg_natural_order_start[4], coefs, 4);
+    case 4:
+      coefs = vld1q_lane_s16(block + jpeg_natural_order_start[3], coefs, 3);
+    case 3:
+      coefs = vld1q_lane_s16(block + jpeg_natural_order_start[2], coefs, 2);
+    case 2:
+      coefs = vld1q_lane_s16(block + jpeg_natural_order_start[1], coefs, 1);
+    case 1:
+      coefs = vld1q_lane_s16(block + jpeg_natural_order_start[0], coefs, 0);
+    default:
+      break;
+    }
+
+    /* Isolate sign of coefficients. */
+    int16x8_t sign_coefs = vshrq_n_s16(coefs, 15);
+    /* Compute absolute value of coefficients and apply point transform Al. */
+    int16x8_t abs_coefs = vabsq_s16(coefs);
+    coefs = vshlq_s16(abs_coefs, vdupq_n_s16(-Al));
+
+    /* Compute diff values. */
+    int16x8_t diff = veorq_s16(coefs, sign_coefs);
+
+    /* Store transformed coefficients and diff values. */
+    vst1q_s16(values_ptr, coefs);
+    vst1q_s16(diff_values_ptr, diff);
+    values_ptr += 8;
+    diff_values_ptr += 8;
+    rows_to_zero--;
+  }
+
+  /* Zero remaining memory in the values and diff_values blocks. */
+  for (i = 0; i < rows_to_zero; i++) {
+    vst1q_s16(values_ptr, vdupq_n_s16(0));
+    vst1q_s16(diff_values_ptr, vdupq_n_s16(0));
+    values_ptr += 8;
+    diff_values_ptr += 8;
+  }
+
+  /* Construct zerobits bitmap.  A set bit means that the corresponding
+   * coefficient != 0.
+   */
+  int16x8_t row0 = vld1q_s16(values + 0 * DCTSIZE);
+  int16x8_t row1 = vld1q_s16(values + 1 * DCTSIZE);
+  int16x8_t row2 = vld1q_s16(values + 2 * DCTSIZE);
+  int16x8_t row3 = vld1q_s16(values + 3 * DCTSIZE);
+  int16x8_t row4 = vld1q_s16(values + 4 * DCTSIZE);
+  int16x8_t row5 = vld1q_s16(values + 5 * DCTSIZE);
+  int16x8_t row6 = vld1q_s16(values + 6 * DCTSIZE);
+  int16x8_t row7 = vld1q_s16(values + 7 * DCTSIZE);
+
+  uint8x8_t row0_eq0 = vmovn_u16(vceqq_s16(row0, vdupq_n_s16(0)));
+  uint8x8_t row1_eq0 = vmovn_u16(vceqq_s16(row1, vdupq_n_s16(0)));
+  uint8x8_t row2_eq0 = vmovn_u16(vceqq_s16(row2, vdupq_n_s16(0)));
+  uint8x8_t row3_eq0 = vmovn_u16(vceqq_s16(row3, vdupq_n_s16(0)));
+  uint8x8_t row4_eq0 = vmovn_u16(vceqq_s16(row4, vdupq_n_s16(0)));
+  uint8x8_t row5_eq0 = vmovn_u16(vceqq_s16(row5, vdupq_n_s16(0)));
+  uint8x8_t row6_eq0 = vmovn_u16(vceqq_s16(row6, vdupq_n_s16(0)));
+  uint8x8_t row7_eq0 = vmovn_u16(vceqq_s16(row7, vdupq_n_s16(0)));
+
+  /* { 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80 } */
+  const uint8x8_t bitmap_mask =
+    vreinterpret_u8_u64(vmov_n_u64(0x8040201008040201));
+
+  row0_eq0 = vand_u8(row0_eq0, bitmap_mask);
+  row1_eq0 = vand_u8(row1_eq0, bitmap_mask);
+  row2_eq0 = vand_u8(row2_eq0, bitmap_mask);
+  row3_eq0 = vand_u8(row3_eq0, bitmap_mask);
+  row4_eq0 = vand_u8(row4_eq0, bitmap_mask);
+  row5_eq0 = vand_u8(row5_eq0, bitmap_mask);
+  row6_eq0 = vand_u8(row6_eq0, bitmap_mask);
+  row7_eq0 = vand_u8(row7_eq0, bitmap_mask);
+
+  uint8x8_t bitmap_rows_01 = vpadd_u8(row0_eq0, row1_eq0);
+  uint8x8_t bitmap_rows_23 = vpadd_u8(row2_eq0, row3_eq0);
+  uint8x8_t bitmap_rows_45 = vpadd_u8(row4_eq0, row5_eq0);
+  uint8x8_t bitmap_rows_67 = vpadd_u8(row6_eq0, row7_eq0);
+  uint8x8_t bitmap_rows_0123 = vpadd_u8(bitmap_rows_01, bitmap_rows_23);
+  uint8x8_t bitmap_rows_4567 = vpadd_u8(bitmap_rows_45, bitmap_rows_67);
+  uint8x8_t bitmap_all = vpadd_u8(bitmap_rows_0123, bitmap_rows_4567);
+
+#if defined(__aarch64__) || defined(_M_ARM64)
+  /* Move bitmap to a 64-bit scalar register. */
+  uint64_t bitmap = vget_lane_u64(vreinterpret_u64_u8(bitmap_all), 0);
+  /* Store zerobits bitmap. */
+  *zerobits = ~bitmap;
+#else
+  /* Move bitmap to two 32-bit scalar registers. */
+  uint32_t bitmap0 = vget_lane_u32(vreinterpret_u32_u8(bitmap_all), 0);
+  uint32_t bitmap1 = vget_lane_u32(vreinterpret_u32_u8(bitmap_all), 1);
+  /* Store zerobits bitmap. */
+  zerobits[0] = ~bitmap0;
+  zerobits[1] = ~bitmap1;
+#endif
+}
+
+
+/* Data preparation for encode_mcu_AC_refine().
+ *
+ * The equivalent scalar C function (encode_mcu_AC_refine_prepare()) can be
+ * found in jcphuff.c.
+ */
+
+int jsimd_encode_mcu_AC_refine_prepare_neon
+  (const JCOEF *block, const int *jpeg_natural_order_start, int Sl, int Al,
+   JCOEF *absvalues, size_t *bits)
+{
+  /* Temporary storage buffers for data used to compute the signbits bitmap and
+   * the end-of-block (EOB) position
+   */
+  uint8_t coef_sign_bits[64];
+  uint8_t coef_eq1_bits[64];
+
+  JCOEF *absvalues_ptr = absvalues;
+  uint8_t *coef_sign_bits_ptr = coef_sign_bits;
+  uint8_t *eq1_bits_ptr = coef_eq1_bits;
+
+  /* Rows of coefficients to zero (since they haven't been processed) */
+  int i, rows_to_zero = 8;
+
+  for (i = 0; i < Sl / 16; i++) {
+    int16x8_t coefs1 = vld1q_dup_s16(block + jpeg_natural_order_start[0]);
+    coefs1 = vld1q_lane_s16(block + jpeg_natural_order_start[1], coefs1, 1);
+    coefs1 = vld1q_lane_s16(block + jpeg_natural_order_start[2], coefs1, 2);
+    coefs1 = vld1q_lane_s16(block + jpeg_natural_order_start[3], coefs1, 3);
+    coefs1 = vld1q_lane_s16(block + jpeg_natural_order_start[4], coefs1, 4);
+    coefs1 = vld1q_lane_s16(block + jpeg_natural_order_start[5], coefs1, 5);
+    coefs1 = vld1q_lane_s16(block + jpeg_natural_order_start[6], coefs1, 6);
+    coefs1 = vld1q_lane_s16(block + jpeg_natural_order_start[7], coefs1, 7);
+    int16x8_t coefs2 = vld1q_dup_s16(block + jpeg_natural_order_start[8]);
+    coefs2 = vld1q_lane_s16(block + jpeg_natural_order_start[9], coefs2, 1);
+    coefs2 = vld1q_lane_s16(block + jpeg_natural_order_start[10], coefs2, 2);
+    coefs2 = vld1q_lane_s16(block + jpeg_natural_order_start[11], coefs2, 3);
+    coefs2 = vld1q_lane_s16(block + jpeg_natural_order_start[12], coefs2, 4);
+    coefs2 = vld1q_lane_s16(block + jpeg_natural_order_start[13], coefs2, 5);
+    coefs2 = vld1q_lane_s16(block + jpeg_natural_order_start[14], coefs2, 6);
+    coefs2 = vld1q_lane_s16(block + jpeg_natural_order_start[15], coefs2, 7);
+
+    /* Compute and store data for signbits bitmap. */
+    uint8x8_t sign_coefs1 =
+      vmovn_u16(vreinterpretq_u16_s16(vshrq_n_s16(coefs1, 15)));
+    uint8x8_t sign_coefs2 =
+      vmovn_u16(vreinterpretq_u16_s16(vshrq_n_s16(coefs2, 15)));
+    vst1_u8(coef_sign_bits_ptr, sign_coefs1);
+    vst1_u8(coef_sign_bits_ptr + DCTSIZE, sign_coefs2);
+
+    /* Compute absolute value of coefficients and apply point transform Al. */
+    int16x8_t abs_coefs1 = vabsq_s16(coefs1);
+    int16x8_t abs_coefs2 = vabsq_s16(coefs2);
+    coefs1 = vshlq_s16(abs_coefs1, vdupq_n_s16(-Al));
+    coefs2 = vshlq_s16(abs_coefs2, vdupq_n_s16(-Al));
+    vst1q_s16(absvalues_ptr, coefs1);
+    vst1q_s16(absvalues_ptr + DCTSIZE, coefs2);
+
+    /* Test whether transformed coefficient values == 1 (used to find EOB
+     * position.)
+     */
+    uint8x8_t coefs_eq11 = vmovn_u16(vceqq_s16(coefs1, vdupq_n_s16(1)));
+    uint8x8_t coefs_eq12 = vmovn_u16(vceqq_s16(coefs2, vdupq_n_s16(1)));
+    vst1_u8(eq1_bits_ptr, coefs_eq11);
+    vst1_u8(eq1_bits_ptr + DCTSIZE, coefs_eq12);
+
+    absvalues_ptr += 16;
+    coef_sign_bits_ptr += 16;
+    eq1_bits_ptr += 16;
+    jpeg_natural_order_start += 16;
+    rows_to_zero -= 2;
+  }
+
+  /* Same operation but for remaining partial vector */
+  int remaining_coefs = Sl % 16;
+  if (remaining_coefs > 8) {
+    int16x8_t coefs1 = vld1q_dup_s16(block + jpeg_natural_order_start[0]);
+    coefs1 = vld1q_lane_s16(block + jpeg_natural_order_start[1], coefs1, 1);
+    coefs1 = vld1q_lane_s16(block + jpeg_natural_order_start[2], coefs1, 2);
+    coefs1 = vld1q_lane_s16(block + jpeg_natural_order_start[3], coefs1, 3);
+    coefs1 = vld1q_lane_s16(block + jpeg_natural_order_start[4], coefs1, 4);
+    coefs1 = vld1q_lane_s16(block + jpeg_natural_order_start[5], coefs1, 5);
+    coefs1 = vld1q_lane_s16(block + jpeg_natural_order_start[6], coefs1, 6);
+    coefs1 = vld1q_lane_s16(block + jpeg_natural_order_start[7], coefs1, 7);
+    int16x8_t coefs2 = vdupq_n_s16(0);
+    switch (remaining_coefs) {
+    case 15:
+      coefs2 = vld1q_lane_s16(block + jpeg_natural_order_start[14], coefs2, 6);
+    case 14:
+      coefs2 = vld1q_lane_s16(block + jpeg_natural_order_start[13], coefs2, 5);
+    case 13:
+      coefs2 = vld1q_lane_s16(block + jpeg_natural_order_start[12], coefs2, 4);
+    case 12:
+      coefs2 = vld1q_lane_s16(block + jpeg_natural_order_start[11], coefs2, 3);
+    case 11:
+      coefs2 = vld1q_lane_s16(block + jpeg_natural_order_start[10], coefs2, 2);
+    case 10:
+      coefs2 = vld1q_lane_s16(block + jpeg_natural_order_start[9], coefs2, 1);
+    case 9:
+      coefs2 = vld1q_lane_s16(block + jpeg_natural_order_start[8], coefs2, 0);
+    default:
+      break;
+    }
+
+    /* Compute and store data for signbits bitmap. */
+    uint8x8_t sign_coefs1 =
+      vmovn_u16(vreinterpretq_u16_s16(vshrq_n_s16(coefs1, 15)));
+    uint8x8_t sign_coefs2 =
+      vmovn_u16(vreinterpretq_u16_s16(vshrq_n_s16(coefs2, 15)));
+    vst1_u8(coef_sign_bits_ptr, sign_coefs1);
+    vst1_u8(coef_sign_bits_ptr + DCTSIZE, sign_coefs2);
+
+    /* Compute absolute value of coefficients and apply point transform Al. */
+    int16x8_t abs_coefs1 = vabsq_s16(coefs1);
+    int16x8_t abs_coefs2 = vabsq_s16(coefs2);
+    coefs1 = vshlq_s16(abs_coefs1, vdupq_n_s16(-Al));
+    coefs2 = vshlq_s16(abs_coefs2, vdupq_n_s16(-Al));
+    vst1q_s16(absvalues_ptr, coefs1);
+    vst1q_s16(absvalues_ptr + DCTSIZE, coefs2);
+
+    /* Test whether transformed coefficient values == 1 (used to find EOB
+     * position.)
+     */
+    uint8x8_t coefs_eq11 = vmovn_u16(vceqq_s16(coefs1, vdupq_n_s16(1)));
+    uint8x8_t coefs_eq12 = vmovn_u16(vceqq_s16(coefs2, vdupq_n_s16(1)));
+    vst1_u8(eq1_bits_ptr, coefs_eq11);
+    vst1_u8(eq1_bits_ptr + DCTSIZE, coefs_eq12);
+
+    absvalues_ptr += 16;
+    coef_sign_bits_ptr += 16;
+    eq1_bits_ptr += 16;
+    jpeg_natural_order_start += 16;
+    rows_to_zero -= 2;
+
+  } else if (remaining_coefs > 0) {
+    int16x8_t coefs = vdupq_n_s16(0);
+
+    switch (remaining_coefs) {
+    case 8:
+      coefs = vld1q_lane_s16(block + jpeg_natural_order_start[7], coefs, 7);
+    case 7:
+      coefs = vld1q_lane_s16(block + jpeg_natural_order_start[6], coefs, 6);
+    case 6:
+      coefs = vld1q_lane_s16(block + jpeg_natural_order_start[5], coefs, 5);
+    case 5:
+      coefs = vld1q_lane_s16(block + jpeg_natural_order_start[4], coefs, 4);
+    case 4:
+      coefs = vld1q_lane_s16(block + jpeg_natural_order_start[3], coefs, 3);
+    case 3:
+      coefs = vld1q_lane_s16(block + jpeg_natural_order_start[2], coefs, 2);
+    case 2:
+      coefs = vld1q_lane_s16(block + jpeg_natural_order_start[1], coefs, 1);
+    case 1:
+      coefs = vld1q_lane_s16(block + jpeg_natural_order_start[0], coefs, 0);
+    default:
+      break;
+    }
+
+    /* Compute and store data for signbits bitmap. */
+    uint8x8_t sign_coefs =
+      vmovn_u16(vreinterpretq_u16_s16(vshrq_n_s16(coefs, 15)));
+    vst1_u8(coef_sign_bits_ptr, sign_coefs);
+
+    /* Compute absolute value of coefficients and apply point transform Al. */
+    int16x8_t abs_coefs = vabsq_s16(coefs);
+    coefs = vshlq_s16(abs_coefs, vdupq_n_s16(-Al));
+    vst1q_s16(absvalues_ptr, coefs);
+
+    /* Test whether transformed coefficient values == 1 (used to find EOB
+     * position.)
+     */
+    uint8x8_t coefs_eq1 = vmovn_u16(vceqq_s16(coefs, vdupq_n_s16(1)));
+    vst1_u8(eq1_bits_ptr, coefs_eq1);
+
+    absvalues_ptr += 8;
+    coef_sign_bits_ptr += 8;
+    eq1_bits_ptr += 8;
+    rows_to_zero--;
+  }
+
+  /* Zero remaining memory in blocks. */
+  for (i = 0; i < rows_to_zero; i++) {
+    vst1q_s16(absvalues_ptr, vdupq_n_s16(0));
+    vst1_u8(coef_sign_bits_ptr, vdup_n_u8(0));
+    vst1_u8(eq1_bits_ptr, vdup_n_u8(0));
+    absvalues_ptr += 8;
+    coef_sign_bits_ptr += 8;
+    eq1_bits_ptr += 8;
+  }
+
+  /* Construct zerobits bitmap. */
+  int16x8_t abs_row0 = vld1q_s16(absvalues + 0 * DCTSIZE);
+  int16x8_t abs_row1 = vld1q_s16(absvalues + 1 * DCTSIZE);
+  int16x8_t abs_row2 = vld1q_s16(absvalues + 2 * DCTSIZE);
+  int16x8_t abs_row3 = vld1q_s16(absvalues + 3 * DCTSIZE);
+  int16x8_t abs_row4 = vld1q_s16(absvalues + 4 * DCTSIZE);
+  int16x8_t abs_row5 = vld1q_s16(absvalues + 5 * DCTSIZE);
+  int16x8_t abs_row6 = vld1q_s16(absvalues + 6 * DCTSIZE);
+  int16x8_t abs_row7 = vld1q_s16(absvalues + 7 * DCTSIZE);
+
+  uint8x8_t abs_row0_eq0 = vmovn_u16(vceqq_s16(abs_row0, vdupq_n_s16(0)));
+  uint8x8_t abs_row1_eq0 = vmovn_u16(vceqq_s16(abs_row1, vdupq_n_s16(0)));
+  uint8x8_t abs_row2_eq0 = vmovn_u16(vceqq_s16(abs_row2, vdupq_n_s16(0)));
+  uint8x8_t abs_row3_eq0 = vmovn_u16(vceqq_s16(abs_row3, vdupq_n_s16(0)));
+  uint8x8_t abs_row4_eq0 = vmovn_u16(vceqq_s16(abs_row4, vdupq_n_s16(0)));
+  uint8x8_t abs_row5_eq0 = vmovn_u16(vceqq_s16(abs_row5, vdupq_n_s16(0)));
+  uint8x8_t abs_row6_eq0 = vmovn_u16(vceqq_s16(abs_row6, vdupq_n_s16(0)));
+  uint8x8_t abs_row7_eq0 = vmovn_u16(vceqq_s16(abs_row7, vdupq_n_s16(0)));
+
+  /* { 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80 } */
+  const uint8x8_t bitmap_mask =
+    vreinterpret_u8_u64(vmov_n_u64(0x8040201008040201));
+
+  abs_row0_eq0 = vand_u8(abs_row0_eq0, bitmap_mask);
+  abs_row1_eq0 = vand_u8(abs_row1_eq0, bitmap_mask);
+  abs_row2_eq0 = vand_u8(abs_row2_eq0, bitmap_mask);
+  abs_row3_eq0 = vand_u8(abs_row3_eq0, bitmap_mask);
+  abs_row4_eq0 = vand_u8(abs_row4_eq0, bitmap_mask);
+  abs_row5_eq0 = vand_u8(abs_row5_eq0, bitmap_mask);
+  abs_row6_eq0 = vand_u8(abs_row6_eq0, bitmap_mask);
+  abs_row7_eq0 = vand_u8(abs_row7_eq0, bitmap_mask);
+
+  uint8x8_t bitmap_rows_01 = vpadd_u8(abs_row0_eq0, abs_row1_eq0);
+  uint8x8_t bitmap_rows_23 = vpadd_u8(abs_row2_eq0, abs_row3_eq0);
+  uint8x8_t bitmap_rows_45 = vpadd_u8(abs_row4_eq0, abs_row5_eq0);
+  uint8x8_t bitmap_rows_67 = vpadd_u8(abs_row6_eq0, abs_row7_eq0);
+  uint8x8_t bitmap_rows_0123 = vpadd_u8(bitmap_rows_01, bitmap_rows_23);
+  uint8x8_t bitmap_rows_4567 = vpadd_u8(bitmap_rows_45, bitmap_rows_67);
+  uint8x8_t bitmap_all = vpadd_u8(bitmap_rows_0123, bitmap_rows_4567);
+
+#if defined(__aarch64__) || defined(_M_ARM64)
+  /* Move bitmap to a 64-bit scalar register. */
+  uint64_t bitmap = vget_lane_u64(vreinterpret_u64_u8(bitmap_all), 0);
+  /* Store zerobits bitmap. */
+  bits[0] = ~bitmap;
+#else
+  /* Move bitmap to two 32-bit scalar registers. */
+  uint32_t bitmap0 = vget_lane_u32(vreinterpret_u32_u8(bitmap_all), 0);
+  uint32_t bitmap1 = vget_lane_u32(vreinterpret_u32_u8(bitmap_all), 1);
+  /* Store zerobits bitmap. */
+  bits[0] = ~bitmap0;
+  bits[1] = ~bitmap1;
+#endif
+
+  /* Construct signbits bitmap. */
+  uint8x8_t signbits_row0 = vld1_u8(coef_sign_bits + 0 * DCTSIZE);
+  uint8x8_t signbits_row1 = vld1_u8(coef_sign_bits + 1 * DCTSIZE);
+  uint8x8_t signbits_row2 = vld1_u8(coef_sign_bits + 2 * DCTSIZE);
+  uint8x8_t signbits_row3 = vld1_u8(coef_sign_bits + 3 * DCTSIZE);
+  uint8x8_t signbits_row4 = vld1_u8(coef_sign_bits + 4 * DCTSIZE);
+  uint8x8_t signbits_row5 = vld1_u8(coef_sign_bits + 5 * DCTSIZE);
+  uint8x8_t signbits_row6 = vld1_u8(coef_sign_bits + 6 * DCTSIZE);
+  uint8x8_t signbits_row7 = vld1_u8(coef_sign_bits + 7 * DCTSIZE);
+
+  signbits_row0 = vand_u8(signbits_row0, bitmap_mask);
+  signbits_row1 = vand_u8(signbits_row1, bitmap_mask);
+  signbits_row2 = vand_u8(signbits_row2, bitmap_mask);
+  signbits_row3 = vand_u8(signbits_row3, bitmap_mask);
+  signbits_row4 = vand_u8(signbits_row4, bitmap_mask);
+  signbits_row5 = vand_u8(signbits_row5, bitmap_mask);
+  signbits_row6 = vand_u8(signbits_row6, bitmap_mask);
+  signbits_row7 = vand_u8(signbits_row7, bitmap_mask);
+
+  bitmap_rows_01 = vpadd_u8(signbits_row0, signbits_row1);
+  bitmap_rows_23 = vpadd_u8(signbits_row2, signbits_row3);
+  bitmap_rows_45 = vpadd_u8(signbits_row4, signbits_row5);
+  bitmap_rows_67 = vpadd_u8(signbits_row6, signbits_row7);
+  bitmap_rows_0123 = vpadd_u8(bitmap_rows_01, bitmap_rows_23);
+  bitmap_rows_4567 = vpadd_u8(bitmap_rows_45, bitmap_rows_67);
+  bitmap_all = vpadd_u8(bitmap_rows_0123, bitmap_rows_4567);
+
+#if defined(__aarch64__) || defined(_M_ARM64)
+  /* Move bitmap to a 64-bit scalar register. */
+  bitmap = vget_lane_u64(vreinterpret_u64_u8(bitmap_all), 0);
+  /* Store signbits bitmap. */
+  bits[1] = ~bitmap;
+#else
+  /* Move bitmap to two 32-bit scalar registers. */
+  bitmap0 = vget_lane_u32(vreinterpret_u32_u8(bitmap_all), 0);
+  bitmap1 = vget_lane_u32(vreinterpret_u32_u8(bitmap_all), 1);
+  /* Store signbits bitmap. */
+  bits[2] = ~bitmap0;
+  bits[3] = ~bitmap1;
+#endif
+
+  /* Construct bitmap to find EOB position (the index of the last coefficient
+   * equal to 1.)
+   */
+  uint8x8_t row0_eq1 = vld1_u8(coef_eq1_bits + 0 * DCTSIZE);
+  uint8x8_t row1_eq1 = vld1_u8(coef_eq1_bits + 1 * DCTSIZE);
+  uint8x8_t row2_eq1 = vld1_u8(coef_eq1_bits + 2 * DCTSIZE);
+  uint8x8_t row3_eq1 = vld1_u8(coef_eq1_bits + 3 * DCTSIZE);
+  uint8x8_t row4_eq1 = vld1_u8(coef_eq1_bits + 4 * DCTSIZE);
+  uint8x8_t row5_eq1 = vld1_u8(coef_eq1_bits + 5 * DCTSIZE);
+  uint8x8_t row6_eq1 = vld1_u8(coef_eq1_bits + 6 * DCTSIZE);
+  uint8x8_t row7_eq1 = vld1_u8(coef_eq1_bits + 7 * DCTSIZE);
+
+  row0_eq1 = vand_u8(row0_eq1, bitmap_mask);
+  row1_eq1 = vand_u8(row1_eq1, bitmap_mask);
+  row2_eq1 = vand_u8(row2_eq1, bitmap_mask);
+  row3_eq1 = vand_u8(row3_eq1, bitmap_mask);
+  row4_eq1 = vand_u8(row4_eq1, bitmap_mask);
+  row5_eq1 = vand_u8(row5_eq1, bitmap_mask);
+  row6_eq1 = vand_u8(row6_eq1, bitmap_mask);
+  row7_eq1 = vand_u8(row7_eq1, bitmap_mask);
+
+  bitmap_rows_01 = vpadd_u8(row0_eq1, row1_eq1);
+  bitmap_rows_23 = vpadd_u8(row2_eq1, row3_eq1);
+  bitmap_rows_45 = vpadd_u8(row4_eq1, row5_eq1);
+  bitmap_rows_67 = vpadd_u8(row6_eq1, row7_eq1);
+  bitmap_rows_0123 = vpadd_u8(bitmap_rows_01, bitmap_rows_23);
+  bitmap_rows_4567 = vpadd_u8(bitmap_rows_45, bitmap_rows_67);
+  bitmap_all = vpadd_u8(bitmap_rows_0123, bitmap_rows_4567);
+
+#if defined(__aarch64__) || defined(_M_ARM64)
+  /* Move bitmap to a 64-bit scalar register. */
+  bitmap = vget_lane_u64(vreinterpret_u64_u8(bitmap_all), 0);
+
+  /* Return EOB position. */
+  if (bitmap == 0) {
+    /* EOB position is defined to be 0 if all coefficients != 1. */
+    return 0;
+  } else {
+    return 63 - BUILTIN_CLZL(bitmap);
+  }
+#else
+  /* Move bitmap to two 32-bit scalar registers. */
+  bitmap0 = vget_lane_u32(vreinterpret_u32_u8(bitmap_all), 0);
+  bitmap1 = vget_lane_u32(vreinterpret_u32_u8(bitmap_all), 1);
+
+  /* Return EOB position. */
+  if (bitmap0 == 0 && bitmap1 == 0) {
+    return 0;
+  } else if (bitmap1 != 0) {
+    return 63 - BUILTIN_CLZ(bitmap1);
+  } else {
+    return 31 - BUILTIN_CLZ(bitmap0);
+  }
+#endif
+}
diff --git a/3rdparty/libjpeg/src/simd/arm/jcsample-neon.c b/3rdparty/libjpeg/src/simd/arm/jcsample-neon.c
new file mode 100644
index 00000000..8a3e2378
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/arm/jcsample-neon.c
@@ -0,0 +1,192 @@
+/*
+ * jcsample-neon.c - downsampling (Arm Neon)
+ *
+ * Copyright (C) 2020, Arm Limited.  All Rights Reserved.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+#define JPEG_INTERNALS
+#include "../../jinclude.h"
+#include "../../jpeglib.h"
+#include "../../jsimd.h"
+#include "../../jdct.h"
+#include "../../jsimddct.h"
+#include "../jsimd.h"
+#include "align.h"
+
+#include <arm_neon.h>
+
+
+ALIGN(16) static const uint8_t jsimd_h2_downsample_consts[] = {
+  0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,   /* Pad 0 */
+  0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
+  0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,   /* Pad 1 */
+  0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0E,
+  0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,   /* Pad 2 */
+  0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0D, 0x0D,
+  0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,   /* Pad 3 */
+  0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0C, 0x0C, 0x0C,
+  0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,   /* Pad 4 */
+  0x08, 0x09, 0x0A, 0x0B, 0x0B, 0x0B, 0x0B, 0x0B,
+  0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,   /* Pad 5 */
+  0x08, 0x09, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A,
+  0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,   /* Pad 6 */
+  0x08, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
+  0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,   /* Pad 7 */
+  0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
+  0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,   /* Pad 8 */
+  0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
+  0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x06,   /* Pad 9 */
+  0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+  0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x05, 0x05,   /* Pad 10 */
+  0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
+  0x00, 0x01, 0x02, 0x03, 0x04, 0x04, 0x04, 0x04,   /* Pad 11 */
+  0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
+  0x00, 0x01, 0x02, 0x03, 0x03, 0x03, 0x03, 0x03,   /* Pad 12 */
+  0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
+  0x00, 0x01, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,   /* Pad 13 */
+  0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
+  0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,   /* Pad 14 */
+  0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,   /* Pad 15 */
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+};
+
+
+/* Downsample pixel values of a single component.
+ * This version handles the common case of 2:1 horizontal and 1:1 vertical,
+ * without smoothing.
+ */
+
+void jsimd_h2v1_downsample_neon(JDIMENSION image_width, int max_v_samp_factor,
+                                JDIMENSION v_samp_factor,
+                                JDIMENSION width_in_blocks,
+                                JSAMPARRAY input_data, JSAMPARRAY output_data)
+{
+  JSAMPROW inptr, outptr;
+  /* Load expansion mask to pad remaining elements of last DCT block. */
+  const int mask_offset = 16 * ((width_in_blocks * 2 * DCTSIZE) - image_width);
+  const uint8x16_t expand_mask =
+    vld1q_u8(&jsimd_h2_downsample_consts[mask_offset]);
+  /* Load bias pattern (alternating every pixel.) */
+  /* { 0, 1, 0, 1, 0, 1, 0, 1 } */
+  const uint16x8_t bias = vreinterpretq_u16_u32(vdupq_n_u32(0x00010000));
+  unsigned i, outrow;
+
+  for (outrow = 0; outrow < v_samp_factor; outrow++) {
+    outptr = output_data[outrow];
+    inptr = input_data[outrow];
+
+    /* Downsample all but the last DCT block of pixels. */
+    for (i = 0; i < width_in_blocks - 1; i++) {
+      uint8x16_t pixels = vld1q_u8(inptr + i * 2 * DCTSIZE);
+      /* Add adjacent pixel values, widen to 16-bit, and add bias. */
+      uint16x8_t samples_u16 = vpadalq_u8(bias, pixels);
+      /* Divide total by 2 and narrow to 8-bit. */
+      uint8x8_t samples_u8 = vshrn_n_u16(samples_u16, 1);
+      /* Store samples to memory. */
+      vst1_u8(outptr + i * DCTSIZE, samples_u8);
+    }
+
+    /* Load pixels in last DCT block into a table. */
+    uint8x16_t pixels = vld1q_u8(inptr + (width_in_blocks - 1) * 2 * DCTSIZE);
+#if defined(__aarch64__) || defined(_M_ARM64)
+    /* Pad the empty elements with the value of the last pixel. */
+    pixels = vqtbl1q_u8(pixels, expand_mask);
+#else
+    uint8x8x2_t table = { { vget_low_u8(pixels), vget_high_u8(pixels) } };
+    pixels = vcombine_u8(vtbl2_u8(table, vget_low_u8(expand_mask)),
+                         vtbl2_u8(table, vget_high_u8(expand_mask)));
+#endif
+    /* Add adjacent pixel values, widen to 16-bit, and add bias. */
+    uint16x8_t samples_u16 = vpadalq_u8(bias, pixels);
+    /* Divide total by 2, narrow to 8-bit, and store. */
+    uint8x8_t samples_u8 = vshrn_n_u16(samples_u16, 1);
+    vst1_u8(outptr + (width_in_blocks - 1) * DCTSIZE, samples_u8);
+  }
+}
+
+
+/* Downsample pixel values of a single component.
+ * This version handles the standard case of 2:1 horizontal and 2:1 vertical,
+ * without smoothing.
+ */
+
+void jsimd_h2v2_downsample_neon(JDIMENSION image_width, int max_v_samp_factor,
+                                JDIMENSION v_samp_factor,
+                                JDIMENSION width_in_blocks,
+                                JSAMPARRAY input_data, JSAMPARRAY output_data)
+{
+  JSAMPROW inptr0, inptr1, outptr;
+  /* Load expansion mask to pad remaining elements of last DCT block. */
+  const int mask_offset = 16 * ((width_in_blocks * 2 * DCTSIZE) - image_width);
+  const uint8x16_t expand_mask =
+    vld1q_u8(&jsimd_h2_downsample_consts[mask_offset]);
+  /* Load bias pattern (alternating every pixel.) */
+  /* { 1, 2, 1, 2, 1, 2, 1, 2 } */
+  const uint16x8_t bias = vreinterpretq_u16_u32(vdupq_n_u32(0x00020001));
+  unsigned i, outrow;
+
+  for (outrow = 0; outrow < v_samp_factor; outrow++) {
+    outptr = output_data[outrow];
+    inptr0 = input_data[outrow];
+    inptr1 = input_data[outrow + 1];
+
+    /* Downsample all but the last DCT block of pixels. */
+    for (i = 0; i < width_in_blocks - 1; i++) {
+      uint8x16_t pixels_r0 = vld1q_u8(inptr0 + i * 2 * DCTSIZE);
+      uint8x16_t pixels_r1 = vld1q_u8(inptr1 + i * 2 * DCTSIZE);
+      /* Add adjacent pixel values in row 0, widen to 16-bit, and add bias. */
+      uint16x8_t samples_u16 = vpadalq_u8(bias, pixels_r0);
+      /* Add adjacent pixel values in row 1, widen to 16-bit, and accumulate.
+       */
+      samples_u16 = vpadalq_u8(samples_u16, pixels_r1);
+      /* Divide total by 4 and narrow to 8-bit. */
+      uint8x8_t samples_u8 = vshrn_n_u16(samples_u16, 2);
+      /* Store samples to memory and increment pointers. */
+      vst1_u8(outptr + i * DCTSIZE, samples_u8);
+    }
+
+    /* Load pixels in last DCT block into a table. */
+    uint8x16_t pixels_r0 =
+      vld1q_u8(inptr0 + (width_in_blocks - 1) * 2 * DCTSIZE);
+    uint8x16_t pixels_r1 =
+      vld1q_u8(inptr1 + (width_in_blocks - 1) * 2 * DCTSIZE);
+#if defined(__aarch64__) || defined(_M_ARM64)
+    /* Pad the empty elements with the value of the last pixel. */
+    pixels_r0 = vqtbl1q_u8(pixels_r0, expand_mask);
+    pixels_r1 = vqtbl1q_u8(pixels_r1, expand_mask);
+#else
+    uint8x8x2_t table_r0 =
+      { { vget_low_u8(pixels_r0), vget_high_u8(pixels_r0) } };
+    uint8x8x2_t table_r1 =
+      { { vget_low_u8(pixels_r1), vget_high_u8(pixels_r1) } };
+    pixels_r0 = vcombine_u8(vtbl2_u8(table_r0, vget_low_u8(expand_mask)),
+                            vtbl2_u8(table_r0, vget_high_u8(expand_mask)));
+    pixels_r1 = vcombine_u8(vtbl2_u8(table_r1, vget_low_u8(expand_mask)),
+                            vtbl2_u8(table_r1, vget_high_u8(expand_mask)));
+#endif
+    /* Add adjacent pixel values in row 0, widen to 16-bit, and add bias. */
+    uint16x8_t samples_u16 = vpadalq_u8(bias, pixels_r0);
+    /* Add adjacent pixel values in row 1, widen to 16-bit, and accumulate. */
+    samples_u16 = vpadalq_u8(samples_u16, pixels_r1);
+    /* Divide total by 4, narrow to 8-bit, and store. */
+    uint8x8_t samples_u8 = vshrn_n_u16(samples_u16, 2);
+    vst1_u8(outptr + (width_in_blocks - 1) * DCTSIZE, samples_u8);
+  }
+}
diff --git a/3rdparty/libjpeg/src/simd/arm/jdcolext-neon.c b/3rdparty/libjpeg/src/simd/arm/jdcolext-neon.c
new file mode 100644
index 00000000..ae440f45
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/arm/jdcolext-neon.c
@@ -0,0 +1,353 @@
+/*
+ * jdcolext-neon.c - colorspace conversion (Arm Neon)
+ *
+ * Copyright (C) 2020, Arm Limited.  All Rights Reserved.
+ * Copyright (C) 2020, D. R. Commander.  All Rights Reserved.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+/* This file is included by jdcolor-neon.c. */
+
+
+/* YCbCr -> RGB conversion is defined by the following equations:
+ *    R = Y                        + 1.40200 * (Cr - 128)
+ *    G = Y - 0.34414 * (Cb - 128) - 0.71414 * (Cr - 128)
+ *    B = Y + 1.77200 * (Cb - 128)
+ *
+ * Scaled integer constants are used to avoid floating-point arithmetic:
+ *    0.3441467 = 11277 * 2^-15
+ *    0.7141418 = 23401 * 2^-15
+ *    1.4020386 = 22971 * 2^-14
+ *    1.7720337 = 29033 * 2^-14
+ * These constants are defined in jdcolor-neon.c.
+ *
+ * To ensure correct results, rounding is used when descaling.
+ */
+
+/* Notes on safe memory access for YCbCr -> RGB conversion routines:
+ *
+ * Input memory buffers can be safely overread up to the next multiple of
+ * ALIGN_SIZE bytes, since they are always allocated by alloc_sarray() in
+ * jmemmgr.c.
+ *
+ * The output buffer cannot safely be written beyond output_width, since
+ * output_buf points to a possibly unpadded row in the decompressed image
+ * buffer allocated by the calling program.
+ */
+
+void jsimd_ycc_rgb_convert_neon(JDIMENSION output_width, JSAMPIMAGE input_buf,
+                                JDIMENSION input_row, JSAMPARRAY output_buf,
+                                int num_rows)
+{
+  JSAMPROW outptr;
+  /* Pointers to Y, Cb, and Cr data */
+  JSAMPROW inptr0, inptr1, inptr2;
+
+  const int16x4_t consts = vld1_s16(jsimd_ycc_rgb_convert_neon_consts);
+  const int16x8_t neg_128 = vdupq_n_s16(-128);
+
+  while (--num_rows >= 0) {
+    inptr0 = input_buf[0][input_row];
+    inptr1 = input_buf[1][input_row];
+    inptr2 = input_buf[2][input_row];
+    input_row++;
+    outptr = *output_buf++;
+    int cols_remaining = output_width;
+    for (; cols_remaining >= 16; cols_remaining -= 16) {
+      uint8x16_t y  = vld1q_u8(inptr0);
+      uint8x16_t cb = vld1q_u8(inptr1);
+      uint8x16_t cr = vld1q_u8(inptr2);
+      /* Subtract 128 from Cb and Cr. */
+      int16x8_t cr_128_l =
+        vreinterpretq_s16_u16(vaddw_u8(vreinterpretq_u16_s16(neg_128),
+                                       vget_low_u8(cr)));
+      int16x8_t cr_128_h =
+        vreinterpretq_s16_u16(vaddw_u8(vreinterpretq_u16_s16(neg_128),
+                                       vget_high_u8(cr)));
+      int16x8_t cb_128_l =
+        vreinterpretq_s16_u16(vaddw_u8(vreinterpretq_u16_s16(neg_128),
+                                       vget_low_u8(cb)));
+      int16x8_t cb_128_h =
+        vreinterpretq_s16_u16(vaddw_u8(vreinterpretq_u16_s16(neg_128),
+                                       vget_high_u8(cb)));
+      /* Compute G-Y: - 0.34414 * (Cb - 128) - 0.71414 * (Cr - 128) */
+      int32x4_t g_sub_y_ll = vmull_lane_s16(vget_low_s16(cb_128_l), consts, 0);
+      int32x4_t g_sub_y_lh = vmull_lane_s16(vget_high_s16(cb_128_l),
+                                            consts, 0);
+      int32x4_t g_sub_y_hl = vmull_lane_s16(vget_low_s16(cb_128_h), consts, 0);
+      int32x4_t g_sub_y_hh = vmull_lane_s16(vget_high_s16(cb_128_h),
+                                            consts, 0);
+      g_sub_y_ll = vmlsl_lane_s16(g_sub_y_ll, vget_low_s16(cr_128_l),
+                                  consts, 1);
+      g_sub_y_lh = vmlsl_lane_s16(g_sub_y_lh, vget_high_s16(cr_128_l),
+                                  consts, 1);
+      g_sub_y_hl = vmlsl_lane_s16(g_sub_y_hl, vget_low_s16(cr_128_h),
+                                  consts, 1);
+      g_sub_y_hh = vmlsl_lane_s16(g_sub_y_hh, vget_high_s16(cr_128_h),
+                                  consts, 1);
+      /* Descale G components: shift right 15, round, and narrow to 16-bit. */
+      int16x8_t g_sub_y_l = vcombine_s16(vrshrn_n_s32(g_sub_y_ll, 15),
+                                         vrshrn_n_s32(g_sub_y_lh, 15));
+      int16x8_t g_sub_y_h = vcombine_s16(vrshrn_n_s32(g_sub_y_hl, 15),
+                                         vrshrn_n_s32(g_sub_y_hh, 15));
+      /* Compute R-Y: 1.40200 * (Cr - 128) */
+      int16x8_t r_sub_y_l = vqrdmulhq_lane_s16(vshlq_n_s16(cr_128_l, 1),
+                                               consts, 2);
+      int16x8_t r_sub_y_h = vqrdmulhq_lane_s16(vshlq_n_s16(cr_128_h, 1),
+                                               consts, 2);
+      /* Compute B-Y: 1.77200 * (Cb - 128) */
+      int16x8_t b_sub_y_l = vqrdmulhq_lane_s16(vshlq_n_s16(cb_128_l, 1),
+                                               consts, 3);
+      int16x8_t b_sub_y_h = vqrdmulhq_lane_s16(vshlq_n_s16(cb_128_h, 1),
+                                               consts, 3);
+      /* Add Y. */
+      int16x8_t r_l =
+        vreinterpretq_s16_u16(vaddw_u8(vreinterpretq_u16_s16(r_sub_y_l),
+                                       vget_low_u8(y)));
+      int16x8_t r_h =
+        vreinterpretq_s16_u16(vaddw_u8(vreinterpretq_u16_s16(r_sub_y_h),
+                                       vget_high_u8(y)));
+      int16x8_t b_l =
+        vreinterpretq_s16_u16(vaddw_u8(vreinterpretq_u16_s16(b_sub_y_l),
+                                       vget_low_u8(y)));
+      int16x8_t b_h =
+        vreinterpretq_s16_u16(vaddw_u8(vreinterpretq_u16_s16(b_sub_y_h),
+                                       vget_high_u8(y)));
+      int16x8_t g_l =
+        vreinterpretq_s16_u16(vaddw_u8(vreinterpretq_u16_s16(g_sub_y_l),
+                                       vget_low_u8(y)));
+      int16x8_t g_h =
+        vreinterpretq_s16_u16(vaddw_u8(vreinterpretq_u16_s16(g_sub_y_h),
+                                       vget_high_u8(y)));
+
+#if RGB_PIXELSIZE == 4
+      uint8x16x4_t rgba;
+      /* Convert each component to unsigned and narrow, clamping to [0-255]. */
+      rgba.val[RGB_RED] = vcombine_u8(vqmovun_s16(r_l), vqmovun_s16(r_h));
+      rgba.val[RGB_GREEN] = vcombine_u8(vqmovun_s16(g_l), vqmovun_s16(g_h));
+      rgba.val[RGB_BLUE] = vcombine_u8(vqmovun_s16(b_l), vqmovun_s16(b_h));
+      /* Set alpha channel to opaque (0xFF). */
+      rgba.val[RGB_ALPHA] = vdupq_n_u8(0xFF);
+      /* Store RGBA pixel data to memory. */
+      vst4q_u8(outptr, rgba);
+#elif RGB_PIXELSIZE == 3
+      uint8x16x3_t rgb;
+      /* Convert each component to unsigned and narrow, clamping to [0-255]. */
+      rgb.val[RGB_RED] = vcombine_u8(vqmovun_s16(r_l), vqmovun_s16(r_h));
+      rgb.val[RGB_GREEN] = vcombine_u8(vqmovun_s16(g_l), vqmovun_s16(g_h));
+      rgb.val[RGB_BLUE] = vcombine_u8(vqmovun_s16(b_l), vqmovun_s16(b_h));
+      /* Store RGB pixel data to memory. */
+      vst3q_u8(outptr, rgb);
+#else
+      /* Pack R, G, and B values in ratio 5:6:5. */
+      uint16x8_t rgb565_l = vqshluq_n_s16(r_l, 8);
+      rgb565_l = vsriq_n_u16(rgb565_l, vqshluq_n_s16(g_l, 8), 5);
+      rgb565_l = vsriq_n_u16(rgb565_l, vqshluq_n_s16(b_l, 8), 11);
+      uint16x8_t rgb565_h = vqshluq_n_s16(r_h, 8);
+      rgb565_h = vsriq_n_u16(rgb565_h, vqshluq_n_s16(g_h, 8), 5);
+      rgb565_h = vsriq_n_u16(rgb565_h, vqshluq_n_s16(b_h, 8), 11);
+      /* Store RGB pixel data to memory. */
+      vst1q_u16((uint16_t *)outptr, rgb565_l);
+      vst1q_u16(((uint16_t *)outptr) + 8, rgb565_h);
+#endif
+
+      /* Increment pointers. */
+      inptr0 += 16;
+      inptr1 += 16;
+      inptr2 += 16;
+      outptr += (RGB_PIXELSIZE * 16);
+    }
+
+    if (cols_remaining >= 8) {
+      uint8x8_t y  = vld1_u8(inptr0);
+      uint8x8_t cb = vld1_u8(inptr1);
+      uint8x8_t cr = vld1_u8(inptr2);
+      /* Subtract 128 from Cb and Cr. */
+      int16x8_t cr_128 =
+        vreinterpretq_s16_u16(vaddw_u8(vreinterpretq_u16_s16(neg_128), cr));
+      int16x8_t cb_128 =
+        vreinterpretq_s16_u16(vaddw_u8(vreinterpretq_u16_s16(neg_128), cb));
+      /* Compute G-Y: - 0.34414 * (Cb - 128) - 0.71414 * (Cr - 128) */
+      int32x4_t g_sub_y_l = vmull_lane_s16(vget_low_s16(cb_128), consts, 0);
+      int32x4_t g_sub_y_h = vmull_lane_s16(vget_high_s16(cb_128), consts, 0);
+      g_sub_y_l = vmlsl_lane_s16(g_sub_y_l, vget_low_s16(cr_128), consts, 1);
+      g_sub_y_h = vmlsl_lane_s16(g_sub_y_h, vget_high_s16(cr_128), consts, 1);
+      /* Descale G components: shift right 15, round, and narrow to 16-bit. */
+      int16x8_t g_sub_y = vcombine_s16(vrshrn_n_s32(g_sub_y_l, 15),
+                                       vrshrn_n_s32(g_sub_y_h, 15));
+      /* Compute R-Y: 1.40200 * (Cr - 128) */
+      int16x8_t r_sub_y = vqrdmulhq_lane_s16(vshlq_n_s16(cr_128, 1),
+                                             consts, 2);
+      /* Compute B-Y: 1.77200 * (Cb - 128) */
+      int16x8_t b_sub_y = vqrdmulhq_lane_s16(vshlq_n_s16(cb_128, 1),
+                                             consts, 3);
+      /* Add Y. */
+      int16x8_t r =
+        vreinterpretq_s16_u16(vaddw_u8(vreinterpretq_u16_s16(r_sub_y), y));
+      int16x8_t b =
+        vreinterpretq_s16_u16(vaddw_u8(vreinterpretq_u16_s16(b_sub_y), y));
+      int16x8_t g =
+        vreinterpretq_s16_u16(vaddw_u8(vreinterpretq_u16_s16(g_sub_y), y));
+
+#if RGB_PIXELSIZE == 4
+      uint8x8x4_t rgba;
+      /* Convert each component to unsigned and narrow, clamping to [0-255]. */
+      rgba.val[RGB_RED] = vqmovun_s16(r);
+      rgba.val[RGB_GREEN] = vqmovun_s16(g);
+      rgba.val[RGB_BLUE] = vqmovun_s16(b);
+      /* Set alpha channel to opaque (0xFF). */
+      rgba.val[RGB_ALPHA] = vdup_n_u8(0xFF);
+      /* Store RGBA pixel data to memory. */
+      vst4_u8(outptr, rgba);
+#elif RGB_PIXELSIZE == 3
+      uint8x8x3_t rgb;
+      /* Convert each component to unsigned and narrow, clamping to [0-255]. */
+      rgb.val[RGB_RED] = vqmovun_s16(r);
+      rgb.val[RGB_GREEN] = vqmovun_s16(g);
+      rgb.val[RGB_BLUE] = vqmovun_s16(b);
+      /* Store RGB pixel data to memory. */
+      vst3_u8(outptr, rgb);
+#else
+      /* Pack R, G, and B values in ratio 5:6:5. */
+      uint16x8_t rgb565 = vqshluq_n_s16(r, 8);
+      rgb565 = vsriq_n_u16(rgb565, vqshluq_n_s16(g, 8), 5);
+      rgb565 = vsriq_n_u16(rgb565, vqshluq_n_s16(b, 8), 11);
+      /* Store RGB pixel data to memory. */
+      vst1q_u16((uint16_t *)outptr, rgb565);
+#endif
+
+      /* Increment pointers. */
+      inptr0 += 8;
+      inptr1 += 8;
+      inptr2 += 8;
+      outptr += (RGB_PIXELSIZE * 8);
+      cols_remaining -= 8;
+    }
+
+    /* Handle the tail elements. */
+    if (cols_remaining > 0) {
+      uint8x8_t y  = vld1_u8(inptr0);
+      uint8x8_t cb = vld1_u8(inptr1);
+      uint8x8_t cr = vld1_u8(inptr2);
+      /* Subtract 128 from Cb and Cr. */
+      int16x8_t cr_128 =
+        vreinterpretq_s16_u16(vaddw_u8(vreinterpretq_u16_s16(neg_128), cr));
+      int16x8_t cb_128 =
+        vreinterpretq_s16_u16(vaddw_u8(vreinterpretq_u16_s16(neg_128), cb));
+      /* Compute G-Y: - 0.34414 * (Cb - 128) - 0.71414 * (Cr - 128) */
+      int32x4_t g_sub_y_l = vmull_lane_s16(vget_low_s16(cb_128), consts, 0);
+      int32x4_t g_sub_y_h = vmull_lane_s16(vget_high_s16(cb_128), consts, 0);
+      g_sub_y_l = vmlsl_lane_s16(g_sub_y_l, vget_low_s16(cr_128), consts, 1);
+      g_sub_y_h = vmlsl_lane_s16(g_sub_y_h, vget_high_s16(cr_128), consts, 1);
+      /* Descale G components: shift right 15, round, and narrow to 16-bit. */
+      int16x8_t g_sub_y = vcombine_s16(vrshrn_n_s32(g_sub_y_l, 15),
+                                       vrshrn_n_s32(g_sub_y_h, 15));
+      /* Compute R-Y: 1.40200 * (Cr - 128) */
+      int16x8_t r_sub_y = vqrdmulhq_lane_s16(vshlq_n_s16(cr_128, 1),
+                                             consts, 2);
+      /* Compute B-Y: 1.77200 * (Cb - 128) */
+      int16x8_t b_sub_y = vqrdmulhq_lane_s16(vshlq_n_s16(cb_128, 1),
+                                             consts, 3);
+      /* Add Y. */
+      int16x8_t r =
+        vreinterpretq_s16_u16(vaddw_u8(vreinterpretq_u16_s16(r_sub_y), y));
+      int16x8_t b =
+        vreinterpretq_s16_u16(vaddw_u8(vreinterpretq_u16_s16(b_sub_y), y));
+      int16x8_t g =
+        vreinterpretq_s16_u16(vaddw_u8(vreinterpretq_u16_s16(g_sub_y), y));
+
+#if RGB_PIXELSIZE == 4
+      uint8x8x4_t rgba;
+      /* Convert each component to unsigned and narrow, clamping to [0-255]. */
+      rgba.val[RGB_RED] = vqmovun_s16(r);
+      rgba.val[RGB_GREEN] = vqmovun_s16(g);
+      rgba.val[RGB_BLUE] = vqmovun_s16(b);
+      /* Set alpha channel to opaque (0xFF). */
+      rgba.val[RGB_ALPHA] = vdup_n_u8(0xFF);
+      /* Store RGBA pixel data to memory. */
+      switch (cols_remaining) {
+      case 7:
+        vst4_lane_u8(outptr + 6 * RGB_PIXELSIZE, rgba, 6);
+      case 6:
+        vst4_lane_u8(outptr + 5 * RGB_PIXELSIZE, rgba, 5);
+      case 5:
+        vst4_lane_u8(outptr + 4 * RGB_PIXELSIZE, rgba, 4);
+      case 4:
+        vst4_lane_u8(outptr + 3 * RGB_PIXELSIZE, rgba, 3);
+      case 3:
+        vst4_lane_u8(outptr + 2 * RGB_PIXELSIZE, rgba, 2);
+      case 2:
+        vst4_lane_u8(outptr + RGB_PIXELSIZE, rgba, 1);
+      case 1:
+        vst4_lane_u8(outptr, rgba, 0);
+      default:
+        break;
+      }
+#elif RGB_PIXELSIZE == 3
+      uint8x8x3_t rgb;
+      /* Convert each component to unsigned and narrow, clamping to [0-255]. */
+      rgb.val[RGB_RED] = vqmovun_s16(r);
+      rgb.val[RGB_GREEN] = vqmovun_s16(g);
+      rgb.val[RGB_BLUE] = vqmovun_s16(b);
+      /* Store RGB pixel data to memory. */
+      switch (cols_remaining) {
+      case 7:
+        vst3_lane_u8(outptr + 6 * RGB_PIXELSIZE, rgb, 6);
+      case 6:
+        vst3_lane_u8(outptr + 5 * RGB_PIXELSIZE, rgb, 5);
+      case 5:
+        vst3_lane_u8(outptr + 4 * RGB_PIXELSIZE, rgb, 4);
+      case 4:
+        vst3_lane_u8(outptr + 3 * RGB_PIXELSIZE, rgb, 3);
+      case 3:
+        vst3_lane_u8(outptr + 2 * RGB_PIXELSIZE, rgb, 2);
+      case 2:
+        vst3_lane_u8(outptr + RGB_PIXELSIZE, rgb, 1);
+      case 1:
+        vst3_lane_u8(outptr, rgb, 0);
+      default:
+        break;
+      }
+#else
+      /* Pack R, G, and B values in ratio 5:6:5. */
+      uint16x8_t rgb565 = vqshluq_n_s16(r, 8);
+      rgb565 = vsriq_n_u16(rgb565, vqshluq_n_s16(g, 8), 5);
+      rgb565 = vsriq_n_u16(rgb565, vqshluq_n_s16(b, 8), 11);
+      /* Store RGB565 pixel data to memory. */
+      switch (cols_remaining) {
+      case 7:
+        vst1q_lane_u16((uint16_t *)(outptr + 6 * RGB_PIXELSIZE), rgb565, 6);
+      case 6:
+        vst1q_lane_u16((uint16_t *)(outptr + 5 * RGB_PIXELSIZE), rgb565, 5);
+      case 5:
+        vst1q_lane_u16((uint16_t *)(outptr + 4 * RGB_PIXELSIZE), rgb565, 4);
+      case 4:
+        vst1q_lane_u16((uint16_t *)(outptr + 3 * RGB_PIXELSIZE), rgb565, 3);
+      case 3:
+        vst1q_lane_u16((uint16_t *)(outptr + 2 * RGB_PIXELSIZE), rgb565, 2);
+      case 2:
+        vst1q_lane_u16((uint16_t *)(outptr + RGB_PIXELSIZE), rgb565, 1);
+      case 1:
+        vst1q_lane_u16((uint16_t *)outptr, rgb565, 0);
+      default:
+        break;
+      }
+#endif
+    }
+  }
+}
diff --git a/3rdparty/libjpeg/src/simd/arm/jdcolor-neon.c b/3rdparty/libjpeg/src/simd/arm/jdcolor-neon.c
new file mode 100644
index 00000000..28dbc572
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/arm/jdcolor-neon.c
@@ -0,0 +1,141 @@
+/*
+ * jdcolor-neon.c - colorspace conversion (Arm Neon)
+ *
+ * Copyright (C) 2020, Arm Limited.  All Rights Reserved.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+#define JPEG_INTERNALS
+#include "../../jinclude.h"
+#include "../../jpeglib.h"
+#include "../../jsimd.h"
+#include "../../jdct.h"
+#include "../../jsimddct.h"
+#include "../jsimd.h"
+#include "align.h"
+
+#include <arm_neon.h>
+
+
+/* YCbCr -> RGB conversion constants */
+
+#define F_0_344  11277  /* 0.3441467 = 11277 * 2^-15 */
+#define F_0_714  23401  /* 0.7141418 = 23401 * 2^-15 */
+#define F_1_402  22971  /* 1.4020386 = 22971 * 2^-14 */
+#define F_1_772  29033  /* 1.7720337 = 29033 * 2^-14 */
+
+ALIGN(16) static const int16_t jsimd_ycc_rgb_convert_neon_consts[] = {
+  -F_0_344, F_0_714, F_1_402, F_1_772
+};
+
+
+/* Include inline routines for colorspace extensions. */
+
+#include "jdcolext-neon.c"
+#undef RGB_RED
+#undef RGB_GREEN
+#undef RGB_BLUE
+#undef RGB_PIXELSIZE
+
+#define RGB_RED  EXT_RGB_RED
+#define RGB_GREEN  EXT_RGB_GREEN
+#define RGB_BLUE  EXT_RGB_BLUE
+#define RGB_PIXELSIZE  EXT_RGB_PIXELSIZE
+#define jsimd_ycc_rgb_convert_neon  jsimd_ycc_extrgb_convert_neon
+#include "jdcolext-neon.c"
+#undef RGB_RED
+#undef RGB_GREEN
+#undef RGB_BLUE
+#undef RGB_PIXELSIZE
+#undef jsimd_ycc_rgb_convert_neon
+
+#define RGB_RED  EXT_RGBX_RED
+#define RGB_GREEN  EXT_RGBX_GREEN
+#define RGB_BLUE  EXT_RGBX_BLUE
+#define RGB_ALPHA  3
+#define RGB_PIXELSIZE  EXT_RGBX_PIXELSIZE
+#define jsimd_ycc_rgb_convert_neon  jsimd_ycc_extrgbx_convert_neon
+#include "jdcolext-neon.c"
+#undef RGB_RED
+#undef RGB_GREEN
+#undef RGB_BLUE
+#undef RGB_ALPHA
+#undef RGB_PIXELSIZE
+#undef jsimd_ycc_rgb_convert_neon
+
+#define RGB_RED  EXT_BGR_RED
+#define RGB_GREEN  EXT_BGR_GREEN
+#define RGB_BLUE  EXT_BGR_BLUE
+#define RGB_PIXELSIZE  EXT_BGR_PIXELSIZE
+#define jsimd_ycc_rgb_convert_neon  jsimd_ycc_extbgr_convert_neon
+#include "jdcolext-neon.c"
+#undef RGB_RED
+#undef RGB_GREEN
+#undef RGB_BLUE
+#undef RGB_PIXELSIZE
+#undef jsimd_ycc_rgb_convert_neon
+
+#define RGB_RED  EXT_BGRX_RED
+#define RGB_GREEN  EXT_BGRX_GREEN
+#define RGB_BLUE  EXT_BGRX_BLUE
+#define RGB_ALPHA  3
+#define RGB_PIXELSIZE  EXT_BGRX_PIXELSIZE
+#define jsimd_ycc_rgb_convert_neon  jsimd_ycc_extbgrx_convert_neon
+#include "jdcolext-neon.c"
+#undef RGB_RED
+#undef RGB_GREEN
+#undef RGB_BLUE
+#undef RGB_ALPHA
+#undef RGB_PIXELSIZE
+#undef jsimd_ycc_rgb_convert_neon
+
+#define RGB_RED  EXT_XBGR_RED
+#define RGB_GREEN  EXT_XBGR_GREEN
+#define RGB_BLUE  EXT_XBGR_BLUE
+#define RGB_ALPHA  0
+#define RGB_PIXELSIZE  EXT_XBGR_PIXELSIZE
+#define jsimd_ycc_rgb_convert_neon  jsimd_ycc_extxbgr_convert_neon
+#include "jdcolext-neon.c"
+#undef RGB_RED
+#undef RGB_GREEN
+#undef RGB_BLUE
+#undef RGB_ALPHA
+#undef RGB_PIXELSIZE
+#undef jsimd_ycc_rgb_convert_neon
+
+#define RGB_RED  EXT_XRGB_RED
+#define RGB_GREEN  EXT_XRGB_GREEN
+#define RGB_BLUE  EXT_XRGB_BLUE
+#define RGB_ALPHA  0
+#define RGB_PIXELSIZE  EXT_XRGB_PIXELSIZE
+#define jsimd_ycc_rgb_convert_neon  jsimd_ycc_extxrgb_convert_neon
+#include "jdcolext-neon.c"
+#undef RGB_RED
+#undef RGB_GREEN
+#undef RGB_BLUE
+#undef RGB_ALPHA
+#undef RGB_PIXELSIZE
+#undef jsimd_ycc_rgb_convert_neon
+
+/* YCbCr -> RGB565 Conversion */
+
+#define RGB_PIXELSIZE  2
+#define jsimd_ycc_rgb_convert_neon  jsimd_ycc_rgb565_convert_neon
+#include "jdcolext-neon.c"
+#undef RGB_PIXELSIZE
+#undef jsimd_ycc_rgb_convert_neon
diff --git a/3rdparty/libjpeg/src/simd/arm/jdmerge-neon.c b/3rdparty/libjpeg/src/simd/arm/jdmerge-neon.c
new file mode 100644
index 00000000..18fb9d8a
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/arm/jdmerge-neon.c
@@ -0,0 +1,144 @@
+/*
+ * jdmerge-neon.c - merged upsampling/color conversion (Arm Neon)
+ *
+ * Copyright (C) 2020, Arm Limited.  All Rights Reserved.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+#define JPEG_INTERNALS
+#include "../../jinclude.h"
+#include "../../jpeglib.h"
+#include "../../jsimd.h"
+#include "../../jdct.h"
+#include "../../jsimddct.h"
+#include "../jsimd.h"
+#include "align.h"
+
+#include <arm_neon.h>
+
+
+/* YCbCr -> RGB conversion constants */
+
+#define F_0_344  11277  /* 0.3441467 = 11277 * 2^-15 */
+#define F_0_714  23401  /* 0.7141418 = 23401 * 2^-15 */
+#define F_1_402  22971  /* 1.4020386 = 22971 * 2^-14 */
+#define F_1_772  29033  /* 1.7720337 = 29033 * 2^-14 */
+
+ALIGN(16) static const int16_t jsimd_ycc_rgb_convert_neon_consts[] = {
+  -F_0_344, F_0_714, F_1_402, F_1_772
+};
+
+
+/* Include inline routines for colorspace extensions. */
+
+#include "jdmrgext-neon.c"
+#undef RGB_RED
+#undef RGB_GREEN
+#undef RGB_BLUE
+#undef RGB_PIXELSIZE
+
+#define RGB_RED  EXT_RGB_RED
+#define RGB_GREEN  EXT_RGB_GREEN
+#define RGB_BLUE  EXT_RGB_BLUE
+#define RGB_PIXELSIZE  EXT_RGB_PIXELSIZE
+#define jsimd_h2v1_merged_upsample_neon  jsimd_h2v1_extrgb_merged_upsample_neon
+#define jsimd_h2v2_merged_upsample_neon  jsimd_h2v2_extrgb_merged_upsample_neon
+#include "jdmrgext-neon.c"
+#undef RGB_RED
+#undef RGB_GREEN
+#undef RGB_BLUE
+#undef RGB_PIXELSIZE
+#undef jsimd_h2v1_merged_upsample_neon
+#undef jsimd_h2v2_merged_upsample_neon
+
+#define RGB_RED  EXT_RGBX_RED
+#define RGB_GREEN  EXT_RGBX_GREEN
+#define RGB_BLUE  EXT_RGBX_BLUE
+#define RGB_ALPHA  3
+#define RGB_PIXELSIZE  EXT_RGBX_PIXELSIZE
+#define jsimd_h2v1_merged_upsample_neon  jsimd_h2v1_extrgbx_merged_upsample_neon
+#define jsimd_h2v2_merged_upsample_neon  jsimd_h2v2_extrgbx_merged_upsample_neon
+#include "jdmrgext-neon.c"
+#undef RGB_RED
+#undef RGB_GREEN
+#undef RGB_BLUE
+#undef RGB_ALPHA
+#undef RGB_PIXELSIZE
+#undef jsimd_h2v1_merged_upsample_neon
+#undef jsimd_h2v2_merged_upsample_neon
+
+#define RGB_RED  EXT_BGR_RED
+#define RGB_GREEN  EXT_BGR_GREEN
+#define RGB_BLUE  EXT_BGR_BLUE
+#define RGB_PIXELSIZE  EXT_BGR_PIXELSIZE
+#define jsimd_h2v1_merged_upsample_neon  jsimd_h2v1_extbgr_merged_upsample_neon
+#define jsimd_h2v2_merged_upsample_neon  jsimd_h2v2_extbgr_merged_upsample_neon
+#include "jdmrgext-neon.c"
+#undef RGB_RED
+#undef RGB_GREEN
+#undef RGB_BLUE
+#undef RGB_PIXELSIZE
+#undef jsimd_h2v1_merged_upsample_neon
+#undef jsimd_h2v2_merged_upsample_neon
+
+#define RGB_RED  EXT_BGRX_RED
+#define RGB_GREEN  EXT_BGRX_GREEN
+#define RGB_BLUE  EXT_BGRX_BLUE
+#define RGB_ALPHA  3
+#define RGB_PIXELSIZE  EXT_BGRX_PIXELSIZE
+#define jsimd_h2v1_merged_upsample_neon  jsimd_h2v1_extbgrx_merged_upsample_neon
+#define jsimd_h2v2_merged_upsample_neon  jsimd_h2v2_extbgrx_merged_upsample_neon
+#include "jdmrgext-neon.c"
+#undef RGB_RED
+#undef RGB_GREEN
+#undef RGB_BLUE
+#undef RGB_ALPHA
+#undef RGB_PIXELSIZE
+#undef jsimd_h2v1_merged_upsample_neon
+#undef jsimd_h2v2_merged_upsample_neon
+
+#define RGB_RED  EXT_XBGR_RED
+#define RGB_GREEN  EXT_XBGR_GREEN
+#define RGB_BLUE  EXT_XBGR_BLUE
+#define RGB_ALPHA  0
+#define RGB_PIXELSIZE  EXT_XBGR_PIXELSIZE
+#define jsimd_h2v1_merged_upsample_neon  jsimd_h2v1_extxbgr_merged_upsample_neon
+#define jsimd_h2v2_merged_upsample_neon  jsimd_h2v2_extxbgr_merged_upsample_neon
+#include "jdmrgext-neon.c"
+#undef RGB_RED
+#undef RGB_GREEN
+#undef RGB_BLUE
+#undef RGB_ALPHA
+#undef RGB_PIXELSIZE
+#undef jsimd_h2v1_merged_upsample_neon
+#undef jsimd_h2v2_merged_upsample_neon
+
+#define RGB_RED  EXT_XRGB_RED
+#define RGB_GREEN  EXT_XRGB_GREEN
+#define RGB_BLUE  EXT_XRGB_BLUE
+#define RGB_ALPHA  0
+#define RGB_PIXELSIZE  EXT_XRGB_PIXELSIZE
+#define jsimd_h2v1_merged_upsample_neon  jsimd_h2v1_extxrgb_merged_upsample_neon
+#define jsimd_h2v2_merged_upsample_neon  jsimd_h2v2_extxrgb_merged_upsample_neon
+#include "jdmrgext-neon.c"
+#undef RGB_RED
+#undef RGB_GREEN
+#undef RGB_BLUE
+#undef RGB_ALPHA
+#undef RGB_PIXELSIZE
+#undef jsimd_h2v1_merged_upsample_neon
diff --git a/3rdparty/libjpeg/src/simd/arm/jdmrgext-neon.c b/3rdparty/libjpeg/src/simd/arm/jdmrgext-neon.c
new file mode 100644
index 00000000..fa2ec056
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/arm/jdmrgext-neon.c
@@ -0,0 +1,667 @@
+/*
+ * jdmrgext-neon.c - merged upsampling/color conversion (Arm Neon)
+ *
+ * Copyright (C) 2020, Arm Limited.  All Rights Reserved.
+ * Copyright (C) 2020, D. R. Commander.  All Rights Reserved.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+/* This file is included by jdmerge-neon.c. */
+
+
+/* These routines combine simple (non-fancy, i.e. non-smooth) h2v1 or h2v2
+ * chroma upsampling and YCbCr -> RGB color conversion into a single function.
+ *
+ * As with the standalone functions, YCbCr -> RGB conversion is defined by the
+ * following equations:
+ *    R = Y                        + 1.40200 * (Cr - 128)
+ *    G = Y - 0.34414 * (Cb - 128) - 0.71414 * (Cr - 128)
+ *    B = Y + 1.77200 * (Cb - 128)
+ *
+ * Scaled integer constants are used to avoid floating-point arithmetic:
+ *    0.3441467 = 11277 * 2^-15
+ *    0.7141418 = 23401 * 2^-15
+ *    1.4020386 = 22971 * 2^-14
+ *    1.7720337 = 29033 * 2^-14
+ * These constants are defined in jdmerge-neon.c.
+ *
+ * To ensure correct results, rounding is used when descaling.
+ */
+
+/* Notes on safe memory access for merged upsampling/YCbCr -> RGB conversion
+ * routines:
+ *
+ * Input memory buffers can be safely overread up to the next multiple of
+ * ALIGN_SIZE bytes, since they are always allocated by alloc_sarray() in
+ * jmemmgr.c.
+ *
+ * The output buffer cannot safely be written beyond output_width, since
+ * output_buf points to a possibly unpadded row in the decompressed image
+ * buffer allocated by the calling program.
+ */
+
+/* Upsample and color convert for the case of 2:1 horizontal and 1:1 vertical.
+ */
+
+void jsimd_h2v1_merged_upsample_neon(JDIMENSION output_width,
+                                     JSAMPIMAGE input_buf,
+                                     JDIMENSION in_row_group_ctr,
+                                     JSAMPARRAY output_buf)
+{
+  JSAMPROW outptr;
+  /* Pointers to Y, Cb, and Cr data */
+  JSAMPROW inptr0, inptr1, inptr2;
+
+  const int16x4_t consts = vld1_s16(jsimd_ycc_rgb_convert_neon_consts);
+  const int16x8_t neg_128 = vdupq_n_s16(-128);
+
+  inptr0 = input_buf[0][in_row_group_ctr];
+  inptr1 = input_buf[1][in_row_group_ctr];
+  inptr2 = input_buf[2][in_row_group_ctr];
+  outptr = output_buf[0];
+
+  int cols_remaining = output_width;
+  for (; cols_remaining >= 16; cols_remaining -= 16) {
+    /* De-interleave Y component values into two separate vectors, one
+     * containing the component values with even-numbered indices and one
+     * containing the component values with odd-numbered indices.
+     */
+    uint8x8x2_t y = vld2_u8(inptr0);
+    uint8x8_t cb = vld1_u8(inptr1);
+    uint8x8_t cr = vld1_u8(inptr2);
+    /* Subtract 128 from Cb and Cr. */
+    int16x8_t cr_128 =
+      vreinterpretq_s16_u16(vaddw_u8(vreinterpretq_u16_s16(neg_128), cr));
+    int16x8_t cb_128 =
+      vreinterpretq_s16_u16(vaddw_u8(vreinterpretq_u16_s16(neg_128), cb));
+    /* Compute G-Y: - 0.34414 * (Cb - 128) - 0.71414 * (Cr - 128) */
+    int32x4_t g_sub_y_l = vmull_lane_s16(vget_low_s16(cb_128), consts, 0);
+    int32x4_t g_sub_y_h = vmull_lane_s16(vget_high_s16(cb_128), consts, 0);
+    g_sub_y_l = vmlsl_lane_s16(g_sub_y_l, vget_low_s16(cr_128), consts, 1);
+    g_sub_y_h = vmlsl_lane_s16(g_sub_y_h, vget_high_s16(cr_128), consts, 1);
+    /* Descale G components: shift right 15, round, and narrow to 16-bit. */
+    int16x8_t g_sub_y = vcombine_s16(vrshrn_n_s32(g_sub_y_l, 15),
+                                     vrshrn_n_s32(g_sub_y_h, 15));
+    /* Compute R-Y: 1.40200 * (Cr - 128) */
+    int16x8_t r_sub_y = vqrdmulhq_lane_s16(vshlq_n_s16(cr_128, 1), consts, 2);
+    /* Compute B-Y: 1.77200 * (Cb - 128) */
+    int16x8_t b_sub_y = vqrdmulhq_lane_s16(vshlq_n_s16(cb_128, 1), consts, 3);
+    /* Add the chroma-derived values (G-Y, R-Y, and B-Y) to both the "even" and
+     * "odd" Y component values.  This effectively upsamples the chroma
+     * components horizontally.
+     */
+    int16x8_t g_even =
+      vreinterpretq_s16_u16(vaddw_u8(vreinterpretq_u16_s16(g_sub_y),
+                                     y.val[0]));
+    int16x8_t r_even =
+      vreinterpretq_s16_u16(vaddw_u8(vreinterpretq_u16_s16(r_sub_y),
+                                     y.val[0]));
+    int16x8_t b_even =
+      vreinterpretq_s16_u16(vaddw_u8(vreinterpretq_u16_s16(b_sub_y),
+                                     y.val[0]));
+    int16x8_t g_odd =
+      vreinterpretq_s16_u16(vaddw_u8(vreinterpretq_u16_s16(g_sub_y),
+                                     y.val[1]));
+    int16x8_t r_odd =
+      vreinterpretq_s16_u16(vaddw_u8(vreinterpretq_u16_s16(r_sub_y),
+                                     y.val[1]));
+    int16x8_t b_odd =
+      vreinterpretq_s16_u16(vaddw_u8(vreinterpretq_u16_s16(b_sub_y),
+                                     y.val[1]));
+    /* Convert each component to unsigned and narrow, clamping to [0-255].
+     * Re-interleave the "even" and "odd" component values.
+     */
+    uint8x8x2_t r = vzip_u8(vqmovun_s16(r_even), vqmovun_s16(r_odd));
+    uint8x8x2_t g = vzip_u8(vqmovun_s16(g_even), vqmovun_s16(g_odd));
+    uint8x8x2_t b = vzip_u8(vqmovun_s16(b_even), vqmovun_s16(b_odd));
+
+#ifdef RGB_ALPHA
+    uint8x16x4_t rgba;
+    rgba.val[RGB_RED] = vcombine_u8(r.val[0], r.val[1]);
+    rgba.val[RGB_GREEN] = vcombine_u8(g.val[0], g.val[1]);
+    rgba.val[RGB_BLUE] = vcombine_u8(b.val[0], b.val[1]);
+    /* Set alpha channel to opaque (0xFF). */
+    rgba.val[RGB_ALPHA] = vdupq_n_u8(0xFF);
+    /* Store RGBA pixel data to memory. */
+    vst4q_u8(outptr, rgba);
+#else
+    uint8x16x3_t rgb;
+    rgb.val[RGB_RED] = vcombine_u8(r.val[0], r.val[1]);
+    rgb.val[RGB_GREEN] = vcombine_u8(g.val[0], g.val[1]);
+    rgb.val[RGB_BLUE] = vcombine_u8(b.val[0], b.val[1]);
+    /* Store RGB pixel data to memory. */
+    vst3q_u8(outptr, rgb);
+#endif
+
+    /* Increment pointers. */
+    inptr0 += 16;
+    inptr1 += 8;
+    inptr2 += 8;
+    outptr += (RGB_PIXELSIZE * 16);
+  }
+
+  if (cols_remaining > 0) {
+    /* De-interleave Y component values into two separate vectors, one
+     * containing the component values with even-numbered indices and one
+     * containing the component values with odd-numbered indices.
+     */
+    uint8x8x2_t y = vld2_u8(inptr0);
+    uint8x8_t cb = vld1_u8(inptr1);
+    uint8x8_t cr = vld1_u8(inptr2);
+    /* Subtract 128 from Cb and Cr. */
+    int16x8_t cr_128 =
+      vreinterpretq_s16_u16(vaddw_u8(vreinterpretq_u16_s16(neg_128), cr));
+    int16x8_t cb_128 =
+      vreinterpretq_s16_u16(vaddw_u8(vreinterpretq_u16_s16(neg_128), cb));
+    /* Compute G-Y: - 0.34414 * (Cb - 128) - 0.71414 * (Cr - 128) */
+    int32x4_t g_sub_y_l = vmull_lane_s16(vget_low_s16(cb_128), consts, 0);
+    int32x4_t g_sub_y_h = vmull_lane_s16(vget_high_s16(cb_128), consts, 0);
+    g_sub_y_l = vmlsl_lane_s16(g_sub_y_l, vget_low_s16(cr_128), consts, 1);
+    g_sub_y_h = vmlsl_lane_s16(g_sub_y_h, vget_high_s16(cr_128), consts, 1);
+    /* Descale G components: shift right 15, round, and narrow to 16-bit. */
+    int16x8_t g_sub_y = vcombine_s16(vrshrn_n_s32(g_sub_y_l, 15),
+                                     vrshrn_n_s32(g_sub_y_h, 15));
+    /* Compute R-Y: 1.40200 * (Cr - 128) */
+    int16x8_t r_sub_y = vqrdmulhq_lane_s16(vshlq_n_s16(cr_128, 1), consts, 2);
+    /* Compute B-Y: 1.77200 * (Cb - 128) */
+    int16x8_t b_sub_y = vqrdmulhq_lane_s16(vshlq_n_s16(cb_128, 1), consts, 3);
+    /* Add the chroma-derived values (G-Y, R-Y, and B-Y) to both the "even" and
+     * "odd" Y component values.  This effectively upsamples the chroma
+     * components horizontally.
+     */
+    int16x8_t g_even =
+      vreinterpretq_s16_u16(vaddw_u8(vreinterpretq_u16_s16(g_sub_y),
+                                     y.val[0]));
+    int16x8_t r_even =
+      vreinterpretq_s16_u16(vaddw_u8(vreinterpretq_u16_s16(r_sub_y),
+                                     y.val[0]));
+    int16x8_t b_even =
+      vreinterpretq_s16_u16(vaddw_u8(vreinterpretq_u16_s16(b_sub_y),
+                                     y.val[0]));
+    int16x8_t g_odd =
+      vreinterpretq_s16_u16(vaddw_u8(vreinterpretq_u16_s16(g_sub_y),
+                                     y.val[1]));
+    int16x8_t r_odd =
+      vreinterpretq_s16_u16(vaddw_u8(vreinterpretq_u16_s16(r_sub_y),
+                                     y.val[1]));
+    int16x8_t b_odd =
+      vreinterpretq_s16_u16(vaddw_u8(vreinterpretq_u16_s16(b_sub_y),
+                                     y.val[1]));
+    /* Convert each component to unsigned and narrow, clamping to [0-255].
+     * Re-interleave the "even" and "odd" component values.
+     */
+    uint8x8x2_t r = vzip_u8(vqmovun_s16(r_even), vqmovun_s16(r_odd));
+    uint8x8x2_t g = vzip_u8(vqmovun_s16(g_even), vqmovun_s16(g_odd));
+    uint8x8x2_t b = vzip_u8(vqmovun_s16(b_even), vqmovun_s16(b_odd));
+
+#ifdef RGB_ALPHA
+    uint8x8x4_t rgba_h;
+    rgba_h.val[RGB_RED] = r.val[1];
+    rgba_h.val[RGB_GREEN] = g.val[1];
+    rgba_h.val[RGB_BLUE] = b.val[1];
+    /* Set alpha channel to opaque (0xFF). */
+    rgba_h.val[RGB_ALPHA] = vdup_n_u8(0xFF);
+    uint8x8x4_t rgba_l;
+    rgba_l.val[RGB_RED] = r.val[0];
+    rgba_l.val[RGB_GREEN] = g.val[0];
+    rgba_l.val[RGB_BLUE] = b.val[0];
+    /* Set alpha channel to opaque (0xFF). */
+    rgba_l.val[RGB_ALPHA] = vdup_n_u8(0xFF);
+    /* Store RGBA pixel data to memory. */
+    switch (cols_remaining) {
+    case 15:
+      vst4_lane_u8(outptr + 14 * RGB_PIXELSIZE, rgba_h, 6);
+    case 14:
+      vst4_lane_u8(outptr + 13 * RGB_PIXELSIZE, rgba_h, 5);
+    case 13:
+      vst4_lane_u8(outptr + 12 * RGB_PIXELSIZE, rgba_h, 4);
+    case 12:
+      vst4_lane_u8(outptr + 11 * RGB_PIXELSIZE, rgba_h, 3);
+    case 11:
+      vst4_lane_u8(outptr + 10 * RGB_PIXELSIZE, rgba_h, 2);
+    case 10:
+      vst4_lane_u8(outptr + 9 * RGB_PIXELSIZE, rgba_h, 1);
+    case 9:
+      vst4_lane_u8(outptr + 8 * RGB_PIXELSIZE, rgba_h, 0);
+    case 8:
+      vst4_u8(outptr, rgba_l);
+      break;
+    case 7:
+      vst4_lane_u8(outptr + 6 * RGB_PIXELSIZE, rgba_l, 6);
+    case 6:
+      vst4_lane_u8(outptr + 5 * RGB_PIXELSIZE, rgba_l, 5);
+    case 5:
+      vst4_lane_u8(outptr + 4 * RGB_PIXELSIZE, rgba_l, 4);
+    case 4:
+      vst4_lane_u8(outptr + 3 * RGB_PIXELSIZE, rgba_l, 3);
+    case 3:
+      vst4_lane_u8(outptr + 2 * RGB_PIXELSIZE, rgba_l, 2);
+    case 2:
+      vst4_lane_u8(outptr + RGB_PIXELSIZE, rgba_l, 1);
+    case 1:
+      vst4_lane_u8(outptr, rgba_l, 0);
+    default:
+      break;
+    }
+#else
+    uint8x8x3_t rgb_h;
+    rgb_h.val[RGB_RED] = r.val[1];
+    rgb_h.val[RGB_GREEN] = g.val[1];
+    rgb_h.val[RGB_BLUE] = b.val[1];
+    uint8x8x3_t rgb_l;
+    rgb_l.val[RGB_RED] = r.val[0];
+    rgb_l.val[RGB_GREEN] = g.val[0];
+    rgb_l.val[RGB_BLUE] = b.val[0];
+    /* Store RGB pixel data to memory. */
+    switch (cols_remaining) {
+    case 15:
+      vst3_lane_u8(outptr + 14 * RGB_PIXELSIZE, rgb_h, 6);
+    case 14:
+      vst3_lane_u8(outptr + 13 * RGB_PIXELSIZE, rgb_h, 5);
+    case 13:
+      vst3_lane_u8(outptr + 12 * RGB_PIXELSIZE, rgb_h, 4);
+    case 12:
+      vst3_lane_u8(outptr + 11 * RGB_PIXELSIZE, rgb_h, 3);
+    case 11:
+      vst3_lane_u8(outptr + 10 * RGB_PIXELSIZE, rgb_h, 2);
+    case 10:
+      vst3_lane_u8(outptr + 9 * RGB_PIXELSIZE, rgb_h, 1);
+    case 9:
+      vst3_lane_u8(outptr + 8 * RGB_PIXELSIZE, rgb_h, 0);
+    case 8:
+      vst3_u8(outptr, rgb_l);
+      break;
+    case 7:
+      vst3_lane_u8(outptr + 6 * RGB_PIXELSIZE, rgb_l, 6);
+    case 6:
+      vst3_lane_u8(outptr + 5 * RGB_PIXELSIZE, rgb_l, 5);
+    case 5:
+      vst3_lane_u8(outptr + 4 * RGB_PIXELSIZE, rgb_l, 4);
+    case 4:
+      vst3_lane_u8(outptr + 3 * RGB_PIXELSIZE, rgb_l, 3);
+    case 3:
+      vst3_lane_u8(outptr + 2 * RGB_PIXELSIZE, rgb_l, 2);
+    case 2:
+      vst3_lane_u8(outptr + RGB_PIXELSIZE, rgb_l, 1);
+    case 1:
+      vst3_lane_u8(outptr, rgb_l, 0);
+    default:
+      break;
+    }
+#endif
+  }
+}
+
+
+/* Upsample and color convert for the case of 2:1 horizontal and 2:1 vertical.
+ *
+ * See comments above for details regarding color conversion and safe memory
+ * access.
+ */
+
+void jsimd_h2v2_merged_upsample_neon(JDIMENSION output_width,
+                                     JSAMPIMAGE input_buf,
+                                     JDIMENSION in_row_group_ctr,
+                                     JSAMPARRAY output_buf)
+{
+  JSAMPROW outptr0, outptr1;
+  /* Pointers to Y (both rows), Cb, and Cr data */
+  JSAMPROW inptr0_0, inptr0_1, inptr1, inptr2;
+
+  const int16x4_t consts = vld1_s16(jsimd_ycc_rgb_convert_neon_consts);
+  const int16x8_t neg_128 = vdupq_n_s16(-128);
+
+  inptr0_0 = input_buf[0][in_row_group_ctr * 2];
+  inptr0_1 = input_buf[0][in_row_group_ctr * 2 + 1];
+  inptr1 = input_buf[1][in_row_group_ctr];
+  inptr2 = input_buf[2][in_row_group_ctr];
+  outptr0 = output_buf[0];
+  outptr1 = output_buf[1];
+
+  int cols_remaining = output_width;
+  for (; cols_remaining >= 16; cols_remaining -= 16) {
+    /* For each row, de-interleave Y component values into two separate
+     * vectors, one containing the component values with even-numbered indices
+     * and one containing the component values with odd-numbered indices.
+     */
+    uint8x8x2_t y0 = vld2_u8(inptr0_0);
+    uint8x8x2_t y1 = vld2_u8(inptr0_1);
+    uint8x8_t cb = vld1_u8(inptr1);
+    uint8x8_t cr = vld1_u8(inptr2);
+    /* Subtract 128 from Cb and Cr. */
+    int16x8_t cr_128 =
+      vreinterpretq_s16_u16(vaddw_u8(vreinterpretq_u16_s16(neg_128), cr));
+    int16x8_t cb_128 =
+      vreinterpretq_s16_u16(vaddw_u8(vreinterpretq_u16_s16(neg_128), cb));
+    /* Compute G-Y: - 0.34414 * (Cb - 128) - 0.71414 * (Cr - 128) */
+    int32x4_t g_sub_y_l = vmull_lane_s16(vget_low_s16(cb_128), consts, 0);
+    int32x4_t g_sub_y_h = vmull_lane_s16(vget_high_s16(cb_128), consts, 0);
+    g_sub_y_l = vmlsl_lane_s16(g_sub_y_l, vget_low_s16(cr_128), consts, 1);
+    g_sub_y_h = vmlsl_lane_s16(g_sub_y_h, vget_high_s16(cr_128), consts, 1);
+    /* Descale G components: shift right 15, round, and narrow to 16-bit. */
+    int16x8_t g_sub_y = vcombine_s16(vrshrn_n_s32(g_sub_y_l, 15),
+                                     vrshrn_n_s32(g_sub_y_h, 15));
+    /* Compute R-Y: 1.40200 * (Cr - 128) */
+    int16x8_t r_sub_y = vqrdmulhq_lane_s16(vshlq_n_s16(cr_128, 1), consts, 2);
+    /* Compute B-Y: 1.77200 * (Cb - 128) */
+    int16x8_t b_sub_y = vqrdmulhq_lane_s16(vshlq_n_s16(cb_128, 1), consts, 3);
+    /* For each row, add the chroma-derived values (G-Y, R-Y, and B-Y) to both
+     * the "even" and "odd" Y component values.  This effectively upsamples the
+     * chroma components both horizontally and vertically.
+     */
+    int16x8_t g0_even =
+      vreinterpretq_s16_u16(vaddw_u8(vreinterpretq_u16_s16(g_sub_y),
+                                     y0.val[0]));
+    int16x8_t r0_even =
+      vreinterpretq_s16_u16(vaddw_u8(vreinterpretq_u16_s16(r_sub_y),
+                                     y0.val[0]));
+    int16x8_t b0_even =
+      vreinterpretq_s16_u16(vaddw_u8(vreinterpretq_u16_s16(b_sub_y),
+                                     y0.val[0]));
+    int16x8_t g0_odd =
+      vreinterpretq_s16_u16(vaddw_u8(vreinterpretq_u16_s16(g_sub_y),
+                                     y0.val[1]));
+    int16x8_t r0_odd =
+      vreinterpretq_s16_u16(vaddw_u8(vreinterpretq_u16_s16(r_sub_y),
+                                     y0.val[1]));
+    int16x8_t b0_odd =
+      vreinterpretq_s16_u16(vaddw_u8(vreinterpretq_u16_s16(b_sub_y),
+                                     y0.val[1]));
+    int16x8_t g1_even =
+      vreinterpretq_s16_u16(vaddw_u8(vreinterpretq_u16_s16(g_sub_y),
+                                     y1.val[0]));
+    int16x8_t r1_even =
+      vreinterpretq_s16_u16(vaddw_u8(vreinterpretq_u16_s16(r_sub_y),
+                                     y1.val[0]));
+    int16x8_t b1_even =
+      vreinterpretq_s16_u16(vaddw_u8(vreinterpretq_u16_s16(b_sub_y),
+                                     y1.val[0]));
+    int16x8_t g1_odd =
+      vreinterpretq_s16_u16(vaddw_u8(vreinterpretq_u16_s16(g_sub_y),
+                                     y1.val[1]));
+    int16x8_t r1_odd =
+      vreinterpretq_s16_u16(vaddw_u8(vreinterpretq_u16_s16(r_sub_y),
+                                     y1.val[1]));
+    int16x8_t b1_odd =
+      vreinterpretq_s16_u16(vaddw_u8(vreinterpretq_u16_s16(b_sub_y),
+                                     y1.val[1]));
+    /* Convert each component to unsigned and narrow, clamping to [0-255].
+     * Re-interleave the "even" and "odd" component values.
+     */
+    uint8x8x2_t r0 = vzip_u8(vqmovun_s16(r0_even), vqmovun_s16(r0_odd));
+    uint8x8x2_t r1 = vzip_u8(vqmovun_s16(r1_even), vqmovun_s16(r1_odd));
+    uint8x8x2_t g0 = vzip_u8(vqmovun_s16(g0_even), vqmovun_s16(g0_odd));
+    uint8x8x2_t g1 = vzip_u8(vqmovun_s16(g1_even), vqmovun_s16(g1_odd));
+    uint8x8x2_t b0 = vzip_u8(vqmovun_s16(b0_even), vqmovun_s16(b0_odd));
+    uint8x8x2_t b1 = vzip_u8(vqmovun_s16(b1_even), vqmovun_s16(b1_odd));
+
+#ifdef RGB_ALPHA
+    uint8x16x4_t rgba0, rgba1;
+    rgba0.val[RGB_RED] = vcombine_u8(r0.val[0], r0.val[1]);
+    rgba1.val[RGB_RED] = vcombine_u8(r1.val[0], r1.val[1]);
+    rgba0.val[RGB_GREEN] = vcombine_u8(g0.val[0], g0.val[1]);
+    rgba1.val[RGB_GREEN] = vcombine_u8(g1.val[0], g1.val[1]);
+    rgba0.val[RGB_BLUE] = vcombine_u8(b0.val[0], b0.val[1]);
+    rgba1.val[RGB_BLUE] = vcombine_u8(b1.val[0], b1.val[1]);
+    /* Set alpha channel to opaque (0xFF). */
+    rgba0.val[RGB_ALPHA] = vdupq_n_u8(0xFF);
+    rgba1.val[RGB_ALPHA] = vdupq_n_u8(0xFF);
+    /* Store RGBA pixel data to memory. */
+    vst4q_u8(outptr0, rgba0);
+    vst4q_u8(outptr1, rgba1);
+#else
+    uint8x16x3_t rgb0, rgb1;
+    rgb0.val[RGB_RED] = vcombine_u8(r0.val[0], r0.val[1]);
+    rgb1.val[RGB_RED] = vcombine_u8(r1.val[0], r1.val[1]);
+    rgb0.val[RGB_GREEN] = vcombine_u8(g0.val[0], g0.val[1]);
+    rgb1.val[RGB_GREEN] = vcombine_u8(g1.val[0], g1.val[1]);
+    rgb0.val[RGB_BLUE] = vcombine_u8(b0.val[0], b0.val[1]);
+    rgb1.val[RGB_BLUE] = vcombine_u8(b1.val[0], b1.val[1]);
+    /* Store RGB pixel data to memory. */
+    vst3q_u8(outptr0, rgb0);
+    vst3q_u8(outptr1, rgb1);
+#endif
+
+    /* Increment pointers. */
+    inptr0_0 += 16;
+    inptr0_1 += 16;
+    inptr1 += 8;
+    inptr2 += 8;
+    outptr0 += (RGB_PIXELSIZE * 16);
+    outptr1 += (RGB_PIXELSIZE * 16);
+  }
+
+  if (cols_remaining > 0) {
+    /* For each row, de-interleave Y component values into two separate
+     * vectors, one containing the component values with even-numbered indices
+     * and one containing the component values with odd-numbered indices.
+     */
+    uint8x8x2_t y0 = vld2_u8(inptr0_0);
+    uint8x8x2_t y1 = vld2_u8(inptr0_1);
+    uint8x8_t cb = vld1_u8(inptr1);
+    uint8x8_t cr = vld1_u8(inptr2);
+    /* Subtract 128 from Cb and Cr. */
+    int16x8_t cr_128 =
+      vreinterpretq_s16_u16(vaddw_u8(vreinterpretq_u16_s16(neg_128), cr));
+    int16x8_t cb_128 =
+      vreinterpretq_s16_u16(vaddw_u8(vreinterpretq_u16_s16(neg_128), cb));
+    /* Compute G-Y: - 0.34414 * (Cb - 128) - 0.71414 * (Cr - 128) */
+    int32x4_t g_sub_y_l = vmull_lane_s16(vget_low_s16(cb_128), consts, 0);
+    int32x4_t g_sub_y_h = vmull_lane_s16(vget_high_s16(cb_128), consts, 0);
+    g_sub_y_l = vmlsl_lane_s16(g_sub_y_l, vget_low_s16(cr_128), consts, 1);
+    g_sub_y_h = vmlsl_lane_s16(g_sub_y_h, vget_high_s16(cr_128), consts, 1);
+    /* Descale G components: shift right 15, round, and narrow to 16-bit. */
+    int16x8_t g_sub_y = vcombine_s16(vrshrn_n_s32(g_sub_y_l, 15),
+                                     vrshrn_n_s32(g_sub_y_h, 15));
+    /* Compute R-Y: 1.40200 * (Cr - 128) */
+    int16x8_t r_sub_y = vqrdmulhq_lane_s16(vshlq_n_s16(cr_128, 1), consts, 2);
+    /* Compute B-Y: 1.77200 * (Cb - 128) */
+    int16x8_t b_sub_y = vqrdmulhq_lane_s16(vshlq_n_s16(cb_128, 1), consts, 3);
+    /* For each row, add the chroma-derived values (G-Y, R-Y, and B-Y) to both
+     * the "even" and "odd" Y component values.  This effectively upsamples the
+     * chroma components both horizontally and vertically.
+     */
+    int16x8_t g0_even =
+      vreinterpretq_s16_u16(vaddw_u8(vreinterpretq_u16_s16(g_sub_y),
+                                     y0.val[0]));
+    int16x8_t r0_even =
+      vreinterpretq_s16_u16(vaddw_u8(vreinterpretq_u16_s16(r_sub_y),
+                                     y0.val[0]));
+    int16x8_t b0_even =
+      vreinterpretq_s16_u16(vaddw_u8(vreinterpretq_u16_s16(b_sub_y),
+                                     y0.val[0]));
+    int16x8_t g0_odd =
+      vreinterpretq_s16_u16(vaddw_u8(vreinterpretq_u16_s16(g_sub_y),
+                                     y0.val[1]));
+    int16x8_t r0_odd =
+      vreinterpretq_s16_u16(vaddw_u8(vreinterpretq_u16_s16(r_sub_y),
+                                     y0.val[1]));
+    int16x8_t b0_odd =
+      vreinterpretq_s16_u16(vaddw_u8(vreinterpretq_u16_s16(b_sub_y),
+                                     y0.val[1]));
+    int16x8_t g1_even =
+      vreinterpretq_s16_u16(vaddw_u8(vreinterpretq_u16_s16(g_sub_y),
+                                     y1.val[0]));
+    int16x8_t r1_even =
+      vreinterpretq_s16_u16(vaddw_u8(vreinterpretq_u16_s16(r_sub_y),
+                                     y1.val[0]));
+    int16x8_t b1_even =
+      vreinterpretq_s16_u16(vaddw_u8(vreinterpretq_u16_s16(b_sub_y),
+                                     y1.val[0]));
+    int16x8_t g1_odd =
+      vreinterpretq_s16_u16(vaddw_u8(vreinterpretq_u16_s16(g_sub_y),
+                                     y1.val[1]));
+    int16x8_t r1_odd =
+      vreinterpretq_s16_u16(vaddw_u8(vreinterpretq_u16_s16(r_sub_y),
+                                     y1.val[1]));
+    int16x8_t b1_odd =
+      vreinterpretq_s16_u16(vaddw_u8(vreinterpretq_u16_s16(b_sub_y),
+                                     y1.val[1]));
+    /* Convert each component to unsigned and narrow, clamping to [0-255].
+     * Re-interleave the "even" and "odd" component values.
+     */
+    uint8x8x2_t r0 = vzip_u8(vqmovun_s16(r0_even), vqmovun_s16(r0_odd));
+    uint8x8x2_t r1 = vzip_u8(vqmovun_s16(r1_even), vqmovun_s16(r1_odd));
+    uint8x8x2_t g0 = vzip_u8(vqmovun_s16(g0_even), vqmovun_s16(g0_odd));
+    uint8x8x2_t g1 = vzip_u8(vqmovun_s16(g1_even), vqmovun_s16(g1_odd));
+    uint8x8x2_t b0 = vzip_u8(vqmovun_s16(b0_even), vqmovun_s16(b0_odd));
+    uint8x8x2_t b1 = vzip_u8(vqmovun_s16(b1_even), vqmovun_s16(b1_odd));
+
+#ifdef RGB_ALPHA
+    uint8x8x4_t rgba0_h, rgba1_h;
+    rgba0_h.val[RGB_RED] = r0.val[1];
+    rgba1_h.val[RGB_RED] = r1.val[1];
+    rgba0_h.val[RGB_GREEN] = g0.val[1];
+    rgba1_h.val[RGB_GREEN] = g1.val[1];
+    rgba0_h.val[RGB_BLUE] = b0.val[1];
+    rgba1_h.val[RGB_BLUE] = b1.val[1];
+    /* Set alpha channel to opaque (0xFF). */
+    rgba0_h.val[RGB_ALPHA] = vdup_n_u8(0xFF);
+    rgba1_h.val[RGB_ALPHA] = vdup_n_u8(0xFF);
+
+    uint8x8x4_t rgba0_l, rgba1_l;
+    rgba0_l.val[RGB_RED] = r0.val[0];
+    rgba1_l.val[RGB_RED] = r1.val[0];
+    rgba0_l.val[RGB_GREEN] = g0.val[0];
+    rgba1_l.val[RGB_GREEN] = g1.val[0];
+    rgba0_l.val[RGB_BLUE] = b0.val[0];
+    rgba1_l.val[RGB_BLUE] = b1.val[0];
+    /* Set alpha channel to opaque (0xFF). */
+    rgba0_l.val[RGB_ALPHA] = vdup_n_u8(0xFF);
+    rgba1_l.val[RGB_ALPHA] = vdup_n_u8(0xFF);
+    /* Store RGBA pixel data to memory. */
+    switch (cols_remaining) {
+    case 15:
+      vst4_lane_u8(outptr0 + 14 * RGB_PIXELSIZE, rgba0_h, 6);
+      vst4_lane_u8(outptr1 + 14 * RGB_PIXELSIZE, rgba1_h, 6);
+    case 14:
+      vst4_lane_u8(outptr0 + 13 * RGB_PIXELSIZE, rgba0_h, 5);
+      vst4_lane_u8(outptr1 + 13 * RGB_PIXELSIZE, rgba1_h, 5);
+    case 13:
+      vst4_lane_u8(outptr0 + 12 * RGB_PIXELSIZE, rgba0_h, 4);
+      vst4_lane_u8(outptr1 + 12 * RGB_PIXELSIZE, rgba1_h, 4);
+    case 12:
+      vst4_lane_u8(outptr0 + 11 * RGB_PIXELSIZE, rgba0_h, 3);
+      vst4_lane_u8(outptr1 + 11 * RGB_PIXELSIZE, rgba1_h, 3);
+    case 11:
+      vst4_lane_u8(outptr0 + 10 * RGB_PIXELSIZE, rgba0_h, 2);
+      vst4_lane_u8(outptr1 + 10 * RGB_PIXELSIZE, rgba1_h, 2);
+    case 10:
+      vst4_lane_u8(outptr0 + 9 * RGB_PIXELSIZE, rgba0_h, 1);
+      vst4_lane_u8(outptr1 + 9 * RGB_PIXELSIZE, rgba1_h, 1);
+    case 9:
+      vst4_lane_u8(outptr0 + 8 * RGB_PIXELSIZE, rgba0_h, 0);
+      vst4_lane_u8(outptr1 + 8 * RGB_PIXELSIZE, rgba1_h, 0);
+    case 8:
+      vst4_u8(outptr0, rgba0_l);
+      vst4_u8(outptr1, rgba1_l);
+      break;
+    case 7:
+      vst4_lane_u8(outptr0 + 6 * RGB_PIXELSIZE, rgba0_l, 6);
+      vst4_lane_u8(outptr1 + 6 * RGB_PIXELSIZE, rgba1_l, 6);
+    case 6:
+      vst4_lane_u8(outptr0 + 5 * RGB_PIXELSIZE, rgba0_l, 5);
+      vst4_lane_u8(outptr1 + 5 * RGB_PIXELSIZE, rgba1_l, 5);
+    case 5:
+      vst4_lane_u8(outptr0 + 4 * RGB_PIXELSIZE, rgba0_l, 4);
+      vst4_lane_u8(outptr1 + 4 * RGB_PIXELSIZE, rgba1_l, 4);
+    case 4:
+      vst4_lane_u8(outptr0 + 3 * RGB_PIXELSIZE, rgba0_l, 3);
+      vst4_lane_u8(outptr1 + 3 * RGB_PIXELSIZE, rgba1_l, 3);
+    case 3:
+      vst4_lane_u8(outptr0 + 2 * RGB_PIXELSIZE, rgba0_l, 2);
+      vst4_lane_u8(outptr1 + 2 * RGB_PIXELSIZE, rgba1_l, 2);
+    case 2:
+      vst4_lane_u8(outptr0 + 1 * RGB_PIXELSIZE, rgba0_l, 1);
+      vst4_lane_u8(outptr1 + 1 * RGB_PIXELSIZE, rgba1_l, 1);
+    case 1:
+      vst4_lane_u8(outptr0, rgba0_l, 0);
+      vst4_lane_u8(outptr1, rgba1_l, 0);
+    default:
+      break;
+    }
+#else
+    uint8x8x3_t rgb0_h, rgb1_h;
+    rgb0_h.val[RGB_RED] = r0.val[1];
+    rgb1_h.val[RGB_RED] = r1.val[1];
+    rgb0_h.val[RGB_GREEN] = g0.val[1];
+    rgb1_h.val[RGB_GREEN] = g1.val[1];
+    rgb0_h.val[RGB_BLUE] = b0.val[1];
+    rgb1_h.val[RGB_BLUE] = b1.val[1];
+
+    uint8x8x3_t rgb0_l, rgb1_l;
+    rgb0_l.val[RGB_RED] = r0.val[0];
+    rgb1_l.val[RGB_RED] = r1.val[0];
+    rgb0_l.val[RGB_GREEN] = g0.val[0];
+    rgb1_l.val[RGB_GREEN] = g1.val[0];
+    rgb0_l.val[RGB_BLUE] = b0.val[0];
+    rgb1_l.val[RGB_BLUE] = b1.val[0];
+    /* Store RGB pixel data to memory. */
+    switch (cols_remaining) {
+    case 15:
+      vst3_lane_u8(outptr0 + 14 * RGB_PIXELSIZE, rgb0_h, 6);
+      vst3_lane_u8(outptr1 + 14 * RGB_PIXELSIZE, rgb1_h, 6);
+    case 14:
+      vst3_lane_u8(outptr0 + 13 * RGB_PIXELSIZE, rgb0_h, 5);
+      vst3_lane_u8(outptr1 + 13 * RGB_PIXELSIZE, rgb1_h, 5);
+    case 13:
+      vst3_lane_u8(outptr0 + 12 * RGB_PIXELSIZE, rgb0_h, 4);
+      vst3_lane_u8(outptr1 + 12 * RGB_PIXELSIZE, rgb1_h, 4);
+    case 12:
+      vst3_lane_u8(outptr0 + 11 * RGB_PIXELSIZE, rgb0_h, 3);
+      vst3_lane_u8(outptr1 + 11 * RGB_PIXELSIZE, rgb1_h, 3);
+    case 11:
+      vst3_lane_u8(outptr0 + 10 * RGB_PIXELSIZE, rgb0_h, 2);
+      vst3_lane_u8(outptr1 + 10 * RGB_PIXELSIZE, rgb1_h, 2);
+    case 10:
+      vst3_lane_u8(outptr0 + 9 * RGB_PIXELSIZE, rgb0_h, 1);
+      vst3_lane_u8(outptr1 + 9 * RGB_PIXELSIZE, rgb1_h, 1);
+    case 9:
+      vst3_lane_u8(outptr0 + 8 * RGB_PIXELSIZE, rgb0_h, 0);
+      vst3_lane_u8(outptr1 + 8 * RGB_PIXELSIZE, rgb1_h, 0);
+    case 8:
+      vst3_u8(outptr0, rgb0_l);
+      vst3_u8(outptr1, rgb1_l);
+      break;
+    case 7:
+      vst3_lane_u8(outptr0 + 6 * RGB_PIXELSIZE, rgb0_l, 6);
+      vst3_lane_u8(outptr1 + 6 * RGB_PIXELSIZE, rgb1_l, 6);
+    case 6:
+      vst3_lane_u8(outptr0 + 5 * RGB_PIXELSIZE, rgb0_l, 5);
+      vst3_lane_u8(outptr1 + 5 * RGB_PIXELSIZE, rgb1_l, 5);
+    case 5:
+      vst3_lane_u8(outptr0 + 4 * RGB_PIXELSIZE, rgb0_l, 4);
+      vst3_lane_u8(outptr1 + 4 * RGB_PIXELSIZE, rgb1_l, 4);
+    case 4:
+      vst3_lane_u8(outptr0 + 3 * RGB_PIXELSIZE, rgb0_l, 3);
+      vst3_lane_u8(outptr1 + 3 * RGB_PIXELSIZE, rgb1_l, 3);
+    case 3:
+      vst3_lane_u8(outptr0 + 2 * RGB_PIXELSIZE, rgb0_l, 2);
+      vst3_lane_u8(outptr1 + 2 * RGB_PIXELSIZE, rgb1_l, 2);
+    case 2:
+      vst3_lane_u8(outptr0 + 1 * RGB_PIXELSIZE, rgb0_l, 1);
+      vst3_lane_u8(outptr1 + 1 * RGB_PIXELSIZE, rgb1_l, 1);
+    case 1:
+      vst3_lane_u8(outptr0, rgb0_l, 0);
+      vst3_lane_u8(outptr1, rgb1_l, 0);
+    default:
+      break;
+    }
+#endif
+  }
+}
diff --git a/3rdparty/libjpeg/src/simd/arm/jdsample-neon.c b/3rdparty/libjpeg/src/simd/arm/jdsample-neon.c
new file mode 100644
index 00000000..90ec6782
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/arm/jdsample-neon.c
@@ -0,0 +1,569 @@
+/*
+ * jdsample-neon.c - upsampling (Arm Neon)
+ *
+ * Copyright (C) 2020, Arm Limited.  All Rights Reserved.
+ * Copyright (C) 2020, D. R. Commander.  All Rights Reserved.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+#define JPEG_INTERNALS
+#include "../../jinclude.h"
+#include "../../jpeglib.h"
+#include "../../jsimd.h"
+#include "../../jdct.h"
+#include "../../jsimddct.h"
+#include "../jsimd.h"
+
+#include <arm_neon.h>
+
+
+/* The diagram below shows a row of samples produced by h2v1 downsampling.
+ *
+ *                s0        s1        s2
+ *            +---------+---------+---------+
+ *            |         |         |         |
+ *            | p0   p1 | p2   p3 | p4   p5 |
+ *            |         |         |         |
+ *            +---------+---------+---------+
+ *
+ * Samples s0-s2 were created by averaging the original pixel component values
+ * centered at positions p0-p5 above.  To approximate those original pixel
+ * component values, we proportionally blend the adjacent samples in each row.
+ *
+ * An upsampled pixel component value is computed by blending the sample
+ * containing the pixel center with the nearest neighboring sample, in the
+ * ratio 3:1.  For example:
+ *     p1(upsampled) = 3/4 * s0 + 1/4 * s1
+ *     p2(upsampled) = 3/4 * s1 + 1/4 * s0
+ * When computing the first and last pixel component values in the row, there
+ * is no adjacent sample to blend, so:
+ *     p0(upsampled) = s0
+ *     p5(upsampled) = s2
+ */
+
+void jsimd_h2v1_fancy_upsample_neon(int max_v_samp_factor,
+                                    JDIMENSION downsampled_width,
+                                    JSAMPARRAY input_data,
+                                    JSAMPARRAY *output_data_ptr)
+{
+  JSAMPARRAY output_data = *output_data_ptr;
+  JSAMPROW inptr, outptr;
+  int inrow;
+  unsigned colctr;
+  /* Set up constants. */
+  const uint16x8_t one_u16 = vdupq_n_u16(1);
+  const uint8x8_t three_u8 = vdup_n_u8(3);
+
+  for (inrow = 0; inrow < max_v_samp_factor; inrow++) {
+    inptr = input_data[inrow];
+    outptr = output_data[inrow];
+    /* First pixel component value in this row of the original image */
+    *outptr = (JSAMPLE)GETJSAMPLE(*inptr);
+
+    /*    3/4 * containing sample + 1/4 * nearest neighboring sample
+     * For p1: containing sample = s0, nearest neighboring sample = s1
+     * For p2: containing sample = s1, nearest neighboring sample = s0
+     */
+    uint8x16_t s0 = vld1q_u8(inptr);
+    uint8x16_t s1 = vld1q_u8(inptr + 1);
+    /* Multiplication makes vectors twice as wide.  '_l' and '_h' suffixes
+     * denote low half and high half respectively.
+     */
+    uint16x8_t s1_add_3s0_l =
+      vmlal_u8(vmovl_u8(vget_low_u8(s1)), vget_low_u8(s0), three_u8);
+    uint16x8_t s1_add_3s0_h =
+      vmlal_u8(vmovl_u8(vget_high_u8(s1)), vget_high_u8(s0), three_u8);
+    uint16x8_t s0_add_3s1_l =
+      vmlal_u8(vmovl_u8(vget_low_u8(s0)), vget_low_u8(s1), three_u8);
+    uint16x8_t s0_add_3s1_h =
+      vmlal_u8(vmovl_u8(vget_high_u8(s0)), vget_high_u8(s1), three_u8);
+    /* Add ordered dithering bias to odd pixel values. */
+    s0_add_3s1_l = vaddq_u16(s0_add_3s1_l, one_u16);
+    s0_add_3s1_h = vaddq_u16(s0_add_3s1_h, one_u16);
+
+    /* The offset is initially 1, because the first pixel component has already
+     * been stored.  However, in subsequent iterations of the SIMD loop, this
+     * offset is (2 * colctr - 1) to stay within the bounds of the sample
+     * buffers without having to resort to a slow scalar tail case for the last
+     * (downsampled_width % 16) samples.  See "Creation of 2-D sample arrays"
+     * in jmemmgr.c for more details.
+     */
+    unsigned outptr_offset = 1;
+    uint8x16x2_t output_pixels;
+
+    /* We use software pipelining to maximise performance.  The code indented
+     * an extra two spaces begins the next iteration of the loop.
+     */
+    for (colctr = 16; colctr < downsampled_width; colctr += 16) {
+
+        s0 = vld1q_u8(inptr + colctr - 1);
+        s1 = vld1q_u8(inptr + colctr);
+
+      /* Right-shift by 2 (divide by 4), narrow to 8-bit, and combine. */
+      output_pixels.val[0] = vcombine_u8(vrshrn_n_u16(s1_add_3s0_l, 2),
+                                         vrshrn_n_u16(s1_add_3s0_h, 2));
+      output_pixels.val[1] = vcombine_u8(vshrn_n_u16(s0_add_3s1_l, 2),
+                                         vshrn_n_u16(s0_add_3s1_h, 2));
+
+        /* Multiplication makes vectors twice as wide.  '_l' and '_h' suffixes
+         * denote low half and high half respectively.
+         */
+        s1_add_3s0_l =
+          vmlal_u8(vmovl_u8(vget_low_u8(s1)), vget_low_u8(s0), three_u8);
+        s1_add_3s0_h =
+          vmlal_u8(vmovl_u8(vget_high_u8(s1)), vget_high_u8(s0), three_u8);
+        s0_add_3s1_l =
+          vmlal_u8(vmovl_u8(vget_low_u8(s0)), vget_low_u8(s1), three_u8);
+        s0_add_3s1_h =
+          vmlal_u8(vmovl_u8(vget_high_u8(s0)), vget_high_u8(s1), three_u8);
+        /* Add ordered dithering bias to odd pixel values. */
+        s0_add_3s1_l = vaddq_u16(s0_add_3s1_l, one_u16);
+        s0_add_3s1_h = vaddq_u16(s0_add_3s1_h, one_u16);
+
+      /* Store pixel component values to memory. */
+      vst2q_u8(outptr + outptr_offset, output_pixels);
+      outptr_offset = 2 * colctr - 1;
+    }
+
+    /* Complete the last iteration of the loop. */
+
+    /* Right-shift by 2 (divide by 4), narrow to 8-bit, and combine. */
+    output_pixels.val[0] = vcombine_u8(vrshrn_n_u16(s1_add_3s0_l, 2),
+                                       vrshrn_n_u16(s1_add_3s0_h, 2));
+    output_pixels.val[1] = vcombine_u8(vshrn_n_u16(s0_add_3s1_l, 2),
+                                       vshrn_n_u16(s0_add_3s1_h, 2));
+    /* Store pixel component values to memory. */
+    vst2q_u8(outptr + outptr_offset, output_pixels);
+
+    /* Last pixel component value in this row of the original image */
+    outptr[2 * downsampled_width - 1] =
+      GETJSAMPLE(inptr[downsampled_width - 1]);
+  }
+}
+
+
+/* The diagram below shows an array of samples produced by h2v2 downsampling.
+ *
+ *                s0        s1        s2
+ *            +---------+---------+---------+
+ *            | p0   p1 | p2   p3 | p4   p5 |
+ *       sA   |         |         |         |
+ *            | p6   p7 | p8   p9 | p10  p11|
+ *            +---------+---------+---------+
+ *            | p12  p13| p14  p15| p16  p17|
+ *       sB   |         |         |         |
+ *            | p18  p19| p20  p21| p22  p23|
+ *            +---------+---------+---------+
+ *            | p24  p25| p26  p27| p28  p29|
+ *       sC   |         |         |         |
+ *            | p30  p31| p32  p33| p34  p35|
+ *            +---------+---------+---------+
+ *
+ * Samples s0A-s2C were created by averaging the original pixel component
+ * values centered at positions p0-p35 above.  To approximate one of those
+ * original pixel component values, we proportionally blend the sample
+ * containing the pixel center with the nearest neighboring samples in each
+ * row, column, and diagonal.
+ *
+ * An upsampled pixel component value is computed by first blending the sample
+ * containing the pixel center with the nearest neighboring samples in the
+ * same column, in the ratio 3:1, and then blending each column sum with the
+ * nearest neighboring column sum, in the ratio 3:1.  For example:
+ *     p14(upsampled) = 3/4 * (3/4 * s1B + 1/4 * s1A) +
+ *                      1/4 * (3/4 * s0B + 1/4 * s0A)
+ *                    = 9/16 * s1B + 3/16 * s1A + 3/16 * s0B + 1/16 * s0A
+ * When computing the first and last pixel component values in the row, there
+ * is no horizontally adjacent sample to blend, so:
+ *     p12(upsampled) = 3/4 * s0B + 1/4 * s0A
+ *     p23(upsampled) = 3/4 * s2B + 1/4 * s2C
+ * When computing the first and last pixel component values in the column,
+ * there is no vertically adjacent sample to blend, so:
+ *     p2(upsampled) = 3/4 * s1A + 1/4 * s0A
+ *     p33(upsampled) = 3/4 * s1C + 1/4 * s2C
+ * When computing the corner pixel component values, there is no adjacent
+ * sample to blend, so:
+ *     p0(upsampled) = s0A
+ *     p35(upsampled) = s2C
+ */
+
+void jsimd_h2v2_fancy_upsample_neon(int max_v_samp_factor,
+                                    JDIMENSION downsampled_width,
+                                    JSAMPARRAY input_data,
+                                    JSAMPARRAY *output_data_ptr)
+{
+  JSAMPARRAY output_data = *output_data_ptr;
+  JSAMPROW inptr0, inptr1, inptr2, outptr0, outptr1;
+  int inrow, outrow;
+  unsigned colctr;
+  /* Set up constants. */
+  const uint16x8_t seven_u16 = vdupq_n_u16(7);
+  const uint8x8_t three_u8 = vdup_n_u8(3);
+  const uint16x8_t three_u16 = vdupq_n_u16(3);
+
+  inrow = outrow = 0;
+  while (outrow < max_v_samp_factor) {
+    inptr0 = input_data[inrow - 1];
+    inptr1 = input_data[inrow];
+    inptr2 = input_data[inrow + 1];
+    /* Suffixes 0 and 1 denote the upper and lower rows of output pixels,
+     * respectively.
+     */
+    outptr0 = output_data[outrow++];
+    outptr1 = output_data[outrow++];
+
+    /* First pixel component value in this row of the original image */
+    int s0colsum0 = GETJSAMPLE(*inptr1) * 3 + GETJSAMPLE(*inptr0);
+    *outptr0 = (JSAMPLE)((s0colsum0 * 4 + 8) >> 4);
+    int s0colsum1 = GETJSAMPLE(*inptr1) * 3 + GETJSAMPLE(*inptr2);
+    *outptr1 = (JSAMPLE)((s0colsum1 * 4 + 8) >> 4);
+
+    /* Step 1: Blend samples vertically in columns s0 and s1.
+     * Leave the divide by 4 until the end, when it can be done for both
+     * dimensions at once, right-shifting by 4.
+     */
+
+    /* Load and compute s0colsum0 and s0colsum1. */
+    uint8x16_t s0A = vld1q_u8(inptr0);
+    uint8x16_t s0B = vld1q_u8(inptr1);
+    uint8x16_t s0C = vld1q_u8(inptr2);
+    /* Multiplication makes vectors twice as wide.  '_l' and '_h' suffixes
+     * denote low half and high half respectively.
+     */
+    uint16x8_t s0colsum0_l = vmlal_u8(vmovl_u8(vget_low_u8(s0A)),
+                                      vget_low_u8(s0B), three_u8);
+    uint16x8_t s0colsum0_h = vmlal_u8(vmovl_u8(vget_high_u8(s0A)),
+                                      vget_high_u8(s0B), three_u8);
+    uint16x8_t s0colsum1_l = vmlal_u8(vmovl_u8(vget_low_u8(s0C)),
+                                      vget_low_u8(s0B), three_u8);
+    uint16x8_t s0colsum1_h = vmlal_u8(vmovl_u8(vget_high_u8(s0C)),
+                                      vget_high_u8(s0B), three_u8);
+    /* Load and compute s1colsum0 and s1colsum1. */
+    uint8x16_t s1A = vld1q_u8(inptr0 + 1);
+    uint8x16_t s1B = vld1q_u8(inptr1 + 1);
+    uint8x16_t s1C = vld1q_u8(inptr2 + 1);
+    uint16x8_t s1colsum0_l = vmlal_u8(vmovl_u8(vget_low_u8(s1A)),
+                                      vget_low_u8(s1B), three_u8);
+    uint16x8_t s1colsum0_h = vmlal_u8(vmovl_u8(vget_high_u8(s1A)),
+                                      vget_high_u8(s1B), three_u8);
+    uint16x8_t s1colsum1_l = vmlal_u8(vmovl_u8(vget_low_u8(s1C)),
+                                      vget_low_u8(s1B), three_u8);
+    uint16x8_t s1colsum1_h = vmlal_u8(vmovl_u8(vget_high_u8(s1C)),
+                                      vget_high_u8(s1B), three_u8);
+
+    /* Step 2: Blend the already-blended columns. */
+
+    uint16x8_t output0_p1_l = vmlaq_u16(s1colsum0_l, s0colsum0_l, three_u16);
+    uint16x8_t output0_p1_h = vmlaq_u16(s1colsum0_h, s0colsum0_h, three_u16);
+    uint16x8_t output0_p2_l = vmlaq_u16(s0colsum0_l, s1colsum0_l, three_u16);
+    uint16x8_t output0_p2_h = vmlaq_u16(s0colsum0_h, s1colsum0_h, three_u16);
+    uint16x8_t output1_p1_l = vmlaq_u16(s1colsum1_l, s0colsum1_l, three_u16);
+    uint16x8_t output1_p1_h = vmlaq_u16(s1colsum1_h, s0colsum1_h, three_u16);
+    uint16x8_t output1_p2_l = vmlaq_u16(s0colsum1_l, s1colsum1_l, three_u16);
+    uint16x8_t output1_p2_h = vmlaq_u16(s0colsum1_h, s1colsum1_h, three_u16);
+    /* Add ordered dithering bias to odd pixel values. */
+    output0_p1_l = vaddq_u16(output0_p1_l, seven_u16);
+    output0_p1_h = vaddq_u16(output0_p1_h, seven_u16);
+    output1_p1_l = vaddq_u16(output1_p1_l, seven_u16);
+    output1_p1_h = vaddq_u16(output1_p1_h, seven_u16);
+    /* Right-shift by 4 (divide by 16), narrow to 8-bit, and combine. */
+    uint8x16x2_t output_pixels0 = { {
+      vcombine_u8(vshrn_n_u16(output0_p1_l, 4), vshrn_n_u16(output0_p1_h, 4)),
+      vcombine_u8(vrshrn_n_u16(output0_p2_l, 4), vrshrn_n_u16(output0_p2_h, 4))
+    } };
+    uint8x16x2_t output_pixels1 = { {
+      vcombine_u8(vshrn_n_u16(output1_p1_l, 4), vshrn_n_u16(output1_p1_h, 4)),
+      vcombine_u8(vrshrn_n_u16(output1_p2_l, 4), vrshrn_n_u16(output1_p2_h, 4))
+    } };
+
+    /* Store pixel component values to memory.
+     * The minimum size of the output buffer for each row is 64 bytes => no
+     * need to worry about buffer overflow here.  See "Creation of 2-D sample
+     * arrays" in jmemmgr.c for more details.
+     */
+    vst2q_u8(outptr0 + 1, output_pixels0);
+    vst2q_u8(outptr1 + 1, output_pixels1);
+
+    /* The first pixel of the image shifted our loads and stores by one byte.
+     * We have to re-align on a 32-byte boundary at some point before the end
+     * of the row (we do it now on the 32/33 pixel boundary) to stay within the
+     * bounds of the sample buffers without having to resort to a slow scalar
+     * tail case for the last (downsampled_width % 16) samples.  See "Creation
+     * of 2-D sample arrays" in jmemmgr.c for more details.
+     */
+    for (colctr = 16; colctr < downsampled_width; colctr += 16) {
+      /* Step 1: Blend samples vertically in columns s0 and s1. */
+
+      /* Load and compute s0colsum0 and s0colsum1. */
+      s0A = vld1q_u8(inptr0 + colctr - 1);
+      s0B = vld1q_u8(inptr1 + colctr - 1);
+      s0C = vld1q_u8(inptr2 + colctr - 1);
+      s0colsum0_l = vmlal_u8(vmovl_u8(vget_low_u8(s0A)), vget_low_u8(s0B),
+                             three_u8);
+      s0colsum0_h = vmlal_u8(vmovl_u8(vget_high_u8(s0A)), vget_high_u8(s0B),
+                             three_u8);
+      s0colsum1_l = vmlal_u8(vmovl_u8(vget_low_u8(s0C)), vget_low_u8(s0B),
+                             three_u8);
+      s0colsum1_h = vmlal_u8(vmovl_u8(vget_high_u8(s0C)), vget_high_u8(s0B),
+                             three_u8);
+      /* Load and compute s1colsum0 and s1colsum1. */
+      s1A = vld1q_u8(inptr0 + colctr);
+      s1B = vld1q_u8(inptr1 + colctr);
+      s1C = vld1q_u8(inptr2 + colctr);
+      s1colsum0_l = vmlal_u8(vmovl_u8(vget_low_u8(s1A)), vget_low_u8(s1B),
+                             three_u8);
+      s1colsum0_h = vmlal_u8(vmovl_u8(vget_high_u8(s1A)), vget_high_u8(s1B),
+                             three_u8);
+      s1colsum1_l = vmlal_u8(vmovl_u8(vget_low_u8(s1C)), vget_low_u8(s1B),
+                             three_u8);
+      s1colsum1_h = vmlal_u8(vmovl_u8(vget_high_u8(s1C)), vget_high_u8(s1B),
+                             three_u8);
+
+      /* Step 2: Blend the already-blended columns. */
+
+      output0_p1_l = vmlaq_u16(s1colsum0_l, s0colsum0_l, three_u16);
+      output0_p1_h = vmlaq_u16(s1colsum0_h, s0colsum0_h, three_u16);
+      output0_p2_l = vmlaq_u16(s0colsum0_l, s1colsum0_l, three_u16);
+      output0_p2_h = vmlaq_u16(s0colsum0_h, s1colsum0_h, three_u16);
+      output1_p1_l = vmlaq_u16(s1colsum1_l, s0colsum1_l, three_u16);
+      output1_p1_h = vmlaq_u16(s1colsum1_h, s0colsum1_h, three_u16);
+      output1_p2_l = vmlaq_u16(s0colsum1_l, s1colsum1_l, three_u16);
+      output1_p2_h = vmlaq_u16(s0colsum1_h, s1colsum1_h, three_u16);
+      /* Add ordered dithering bias to odd pixel values. */
+      output0_p1_l = vaddq_u16(output0_p1_l, seven_u16);
+      output0_p1_h = vaddq_u16(output0_p1_h, seven_u16);
+      output1_p1_l = vaddq_u16(output1_p1_l, seven_u16);
+      output1_p1_h = vaddq_u16(output1_p1_h, seven_u16);
+      /* Right-shift by 4 (divide by 16), narrow to 8-bit, and combine. */
+      output_pixels0.val[0] = vcombine_u8(vshrn_n_u16(output0_p1_l, 4),
+                                          vshrn_n_u16(output0_p1_h, 4));
+      output_pixels0.val[1] = vcombine_u8(vrshrn_n_u16(output0_p2_l, 4),
+                                          vrshrn_n_u16(output0_p2_h, 4));
+      output_pixels1.val[0] = vcombine_u8(vshrn_n_u16(output1_p1_l, 4),
+                                          vshrn_n_u16(output1_p1_h, 4));
+      output_pixels1.val[1] = vcombine_u8(vrshrn_n_u16(output1_p2_l, 4),
+                                          vrshrn_n_u16(output1_p2_h, 4));
+      /* Store pixel component values to memory. */
+      vst2q_u8(outptr0 + 2 * colctr - 1, output_pixels0);
+      vst2q_u8(outptr1 + 2 * colctr - 1, output_pixels1);
+    }
+
+    /* Last pixel component value in this row of the original image */
+    int s1colsum0 = GETJSAMPLE(inptr1[downsampled_width - 1]) * 3 +
+                    GETJSAMPLE(inptr0[downsampled_width - 1]);
+    outptr0[2 * downsampled_width - 1] = (JSAMPLE)((s1colsum0 * 4 + 7) >> 4);
+    int s1colsum1 = GETJSAMPLE(inptr1[downsampled_width - 1]) * 3 +
+                    GETJSAMPLE(inptr2[downsampled_width - 1]);
+    outptr1[2 * downsampled_width - 1] = (JSAMPLE)((s1colsum1 * 4 + 7) >> 4);
+    inrow++;
+  }
+}
+
+
+/* The diagram below shows a column of samples produced by h1v2 downsampling
+ * (or by losslessly rotating or transposing an h2v1-downsampled image.)
+ *
+ *            +---------+
+ *            |   p0    |
+ *     sA     |         |
+ *            |   p1    |
+ *            +---------+
+ *            |   p2    |
+ *     sB     |         |
+ *            |   p3    |
+ *            +---------+
+ *            |   p4    |
+ *     sC     |         |
+ *            |   p5    |
+ *            +---------+
+ *
+ * Samples sA-sC were created by averaging the original pixel component values
+ * centered at positions p0-p5 above.  To approximate those original pixel
+ * component values, we proportionally blend the adjacent samples in each
+ * column.
+ *
+ * An upsampled pixel component value is computed by blending the sample
+ * containing the pixel center with the nearest neighboring sample, in the
+ * ratio 3:1.  For example:
+ *     p1(upsampled) = 3/4 * sA + 1/4 * sB
+ *     p2(upsampled) = 3/4 * sB + 1/4 * sA
+ * When computing the first and last pixel component values in the column,
+ * there is no adjacent sample to blend, so:
+ *     p0(upsampled) = sA
+ *     p5(upsampled) = sC
+ */
+
+void jsimd_h1v2_fancy_upsample_neon(int max_v_samp_factor,
+                                    JDIMENSION downsampled_width,
+                                    JSAMPARRAY input_data,
+                                    JSAMPARRAY *output_data_ptr)
+{
+  JSAMPARRAY output_data = *output_data_ptr;
+  JSAMPROW inptr0, inptr1, inptr2, outptr0, outptr1;
+  int inrow, outrow;
+  unsigned colctr;
+  /* Set up constants. */
+  const uint16x8_t one_u16 = vdupq_n_u16(1);
+  const uint8x8_t three_u8 = vdup_n_u8(3);
+
+  inrow = outrow = 0;
+  while (outrow < max_v_samp_factor) {
+    inptr0 = input_data[inrow - 1];
+    inptr1 = input_data[inrow];
+    inptr2 = input_data[inrow + 1];
+    /* Suffixes 0 and 1 denote the upper and lower rows of output pixels,
+     * respectively.
+     */
+    outptr0 = output_data[outrow++];
+    outptr1 = output_data[outrow++];
+    inrow++;
+
+    /* The size of the input and output buffers is always a multiple of 32
+     * bytes => no need to worry about buffer overflow when reading/writing
+     * memory.  See "Creation of 2-D sample arrays" in jmemmgr.c for more
+     * details.
+     */
+    for (colctr = 0; colctr < downsampled_width; colctr += 16) {
+      /* Load samples. */
+      uint8x16_t sA = vld1q_u8(inptr0 + colctr);
+      uint8x16_t sB = vld1q_u8(inptr1 + colctr);
+      uint8x16_t sC = vld1q_u8(inptr2 + colctr);
+      /* Blend samples vertically. */
+      uint16x8_t colsum0_l = vmlal_u8(vmovl_u8(vget_low_u8(sA)),
+                                      vget_low_u8(sB), three_u8);
+      uint16x8_t colsum0_h = vmlal_u8(vmovl_u8(vget_high_u8(sA)),
+                                      vget_high_u8(sB), three_u8);
+      uint16x8_t colsum1_l = vmlal_u8(vmovl_u8(vget_low_u8(sC)),
+                                      vget_low_u8(sB), three_u8);
+      uint16x8_t colsum1_h = vmlal_u8(vmovl_u8(vget_high_u8(sC)),
+                                      vget_high_u8(sB), three_u8);
+      /* Add ordered dithering bias to pixel values in even output rows. */
+      colsum0_l = vaddq_u16(colsum0_l, one_u16);
+      colsum0_h = vaddq_u16(colsum0_h, one_u16);
+      /* Right-shift by 2 (divide by 4), narrow to 8-bit, and combine. */
+      uint8x16_t output_pixels0 = vcombine_u8(vshrn_n_u16(colsum0_l, 2),
+                                              vshrn_n_u16(colsum0_h, 2));
+      uint8x16_t output_pixels1 = vcombine_u8(vrshrn_n_u16(colsum1_l, 2),
+                                              vrshrn_n_u16(colsum1_h, 2));
+      /* Store pixel component values to memory. */
+      vst1q_u8(outptr0 + colctr, output_pixels0);
+      vst1q_u8(outptr1 + colctr, output_pixels1);
+    }
+  }
+}
+
+
+/* The diagram below shows a row of samples produced by h2v1 downsampling.
+ *
+ *                s0        s1
+ *            +---------+---------+
+ *            |         |         |
+ *            | p0   p1 | p2   p3 |
+ *            |         |         |
+ *            +---------+---------+
+ *
+ * Samples s0 and s1 were created by averaging the original pixel component
+ * values centered at positions p0-p3 above.  To approximate those original
+ * pixel component values, we duplicate the samples horizontally:
+ *     p0(upsampled) = p1(upsampled) = s0
+ *     p2(upsampled) = p3(upsampled) = s1
+ */
+
+void jsimd_h2v1_upsample_neon(int max_v_samp_factor, JDIMENSION output_width,
+                              JSAMPARRAY input_data,
+                              JSAMPARRAY *output_data_ptr)
+{
+  JSAMPARRAY output_data = *output_data_ptr;
+  JSAMPROW inptr, outptr;
+  int inrow;
+  unsigned colctr;
+
+  for (inrow = 0; inrow < max_v_samp_factor; inrow++) {
+    inptr = input_data[inrow];
+    outptr = output_data[inrow];
+    for (colctr = 0; 2 * colctr < output_width; colctr += 16) {
+      uint8x16_t samples = vld1q_u8(inptr + colctr);
+      /* Duplicate the samples.  The store operation below interleaves them so
+       * that adjacent pixel component values take on the same sample value,
+       * per above.
+       */
+      uint8x16x2_t output_pixels = { { samples, samples } };
+      /* Store pixel component values to memory.
+       * Due to the way sample buffers are allocated, we don't need to worry
+       * about tail cases when output_width is not a multiple of 32.  See
+       * "Creation of 2-D sample arrays" in jmemmgr.c for details.
+       */
+      vst2q_u8(outptr + 2 * colctr, output_pixels);
+    }
+  }
+}
+
+
+/* The diagram below shows an array of samples produced by h2v2 downsampling.
+ *
+ *                s0        s1
+ *            +---------+---------+
+ *            | p0   p1 | p2   p3 |
+ *       sA   |         |         |
+ *            | p4   p5 | p6   p7 |
+ *            +---------+---------+
+ *            | p8   p9 | p10  p11|
+ *       sB   |         |         |
+ *            | p12  p13| p14  p15|
+ *            +---------+---------+
+ *
+ * Samples s0A-s1B were created by averaging the original pixel component
+ * values centered at positions p0-p15 above.  To approximate those original
+ * pixel component values, we duplicate the samples both horizontally and
+ * vertically:
+ *     p0(upsampled) = p1(upsampled) = p4(upsampled) = p5(upsampled) = s0A
+ *     p2(upsampled) = p3(upsampled) = p6(upsampled) = p7(upsampled) = s1A
+ *     p8(upsampled) = p9(upsampled) = p12(upsampled) = p13(upsampled) = s0B
+ *     p10(upsampled) = p11(upsampled) = p14(upsampled) = p15(upsampled) = s1B
+ */
+
+void jsimd_h2v2_upsample_neon(int max_v_samp_factor, JDIMENSION output_width,
+                              JSAMPARRAY input_data,
+                              JSAMPARRAY *output_data_ptr)
+{
+  JSAMPARRAY output_data = *output_data_ptr;
+  JSAMPROW inptr, outptr0, outptr1;
+  int inrow, outrow;
+  unsigned colctr;
+
+  for (inrow = 0, outrow = 0; outrow < max_v_samp_factor; inrow++) {
+    inptr = input_data[inrow];
+    outptr0 = output_data[outrow++];
+    outptr1 = output_data[outrow++];
+
+    for (colctr = 0; 2 * colctr < output_width; colctr += 16) {
+      uint8x16_t samples = vld1q_u8(inptr + colctr);
+      /* Duplicate the samples.  The store operation below interleaves them so
+       * that adjacent pixel component values take on the same sample value,
+       * per above.
+       */
+      uint8x16x2_t output_pixels = { { samples, samples } };
+      /* Store pixel component values for both output rows to memory.
+       * Due to the way sample buffers are allocated, we don't need to worry
+       * about tail cases when output_width is not a multiple of 32.  See
+       * "Creation of 2-D sample arrays" in jmemmgr.c for details.
+       */
+      vst2q_u8(outptr0 + 2 * colctr, output_pixels);
+      vst2q_u8(outptr1 + 2 * colctr, output_pixels);
+    }
+  }
+}
diff --git a/3rdparty/libjpeg/src/simd/arm/jfdctfst-neon.c b/3rdparty/libjpeg/src/simd/arm/jfdctfst-neon.c
new file mode 100644
index 00000000..bb371be3
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/arm/jfdctfst-neon.c
@@ -0,0 +1,214 @@
+/*
+ * jfdctfst-neon.c - fast integer FDCT (Arm Neon)
+ *
+ * Copyright (C) 2020, Arm Limited.  All Rights Reserved.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+#define JPEG_INTERNALS
+#include "../../jinclude.h"
+#include "../../jpeglib.h"
+#include "../../jsimd.h"
+#include "../../jdct.h"
+#include "../../jsimddct.h"
+#include "../jsimd.h"
+#include "align.h"
+
+#include <arm_neon.h>
+
+
+/* jsimd_fdct_ifast_neon() performs a fast, not so accurate forward DCT
+ * (Discrete Cosine Transform) on one block of samples.  It uses the same
+ * calculations and produces exactly the same output as IJG's original
+ * jpeg_fdct_ifast() function, which can be found in jfdctfst.c.
+ *
+ * Scaled integer constants are used to avoid floating-point arithmetic:
+ *    0.382683433 = 12544 * 2^-15
+ *    0.541196100 = 17795 * 2^-15
+ *    0.707106781 = 23168 * 2^-15
+ *    0.306562965 =  9984 * 2^-15
+ *
+ * See jfdctfst.c for further details of the DCT algorithm.  Where possible,
+ * the variable names and comments here in jsimd_fdct_ifast_neon() match up
+ * with those in jpeg_fdct_ifast().
+ */
+
+#define F_0_382  12544
+#define F_0_541  17792
+#define F_0_707  23168
+#define F_0_306  9984
+
+
+ALIGN(16) static const int16_t jsimd_fdct_ifast_neon_consts[] = {
+  F_0_382, F_0_541, F_0_707, F_0_306
+};
+
+void jsimd_fdct_ifast_neon(DCTELEM *data)
+{
+  /* Load an 8x8 block of samples into Neon registers.  De-interleaving loads
+   * are used, followed by vuzp to transpose the block such that we have a
+   * column of samples per vector - allowing all rows to be processed at once.
+   */
+  int16x8x4_t data1 = vld4q_s16(data);
+  int16x8x4_t data2 = vld4q_s16(data + 4 * DCTSIZE);
+
+  int16x8x2_t cols_04 = vuzpq_s16(data1.val[0], data2.val[0]);
+  int16x8x2_t cols_15 = vuzpq_s16(data1.val[1], data2.val[1]);
+  int16x8x2_t cols_26 = vuzpq_s16(data1.val[2], data2.val[2]);
+  int16x8x2_t cols_37 = vuzpq_s16(data1.val[3], data2.val[3]);
+
+  int16x8_t col0 = cols_04.val[0];
+  int16x8_t col1 = cols_15.val[0];
+  int16x8_t col2 = cols_26.val[0];
+  int16x8_t col3 = cols_37.val[0];
+  int16x8_t col4 = cols_04.val[1];
+  int16x8_t col5 = cols_15.val[1];
+  int16x8_t col6 = cols_26.val[1];
+  int16x8_t col7 = cols_37.val[1];
+
+  /* Pass 1: process rows. */
+
+  /* Load DCT conversion constants. */
+  const int16x4_t consts = vld1_s16(jsimd_fdct_ifast_neon_consts);
+
+  int16x8_t tmp0 = vaddq_s16(col0, col7);
+  int16x8_t tmp7 = vsubq_s16(col0, col7);
+  int16x8_t tmp1 = vaddq_s16(col1, col6);
+  int16x8_t tmp6 = vsubq_s16(col1, col6);
+  int16x8_t tmp2 = vaddq_s16(col2, col5);
+  int16x8_t tmp5 = vsubq_s16(col2, col5);
+  int16x8_t tmp3 = vaddq_s16(col3, col4);
+  int16x8_t tmp4 = vsubq_s16(col3, col4);
+
+  /* Even part */
+  int16x8_t tmp10 = vaddq_s16(tmp0, tmp3);    /* phase 2 */
+  int16x8_t tmp13 = vsubq_s16(tmp0, tmp3);
+  int16x8_t tmp11 = vaddq_s16(tmp1, tmp2);
+  int16x8_t tmp12 = vsubq_s16(tmp1, tmp2);
+
+  col0 = vaddq_s16(tmp10, tmp11);             /* phase 3 */
+  col4 = vsubq_s16(tmp10, tmp11);
+
+  int16x8_t z1 = vqdmulhq_lane_s16(vaddq_s16(tmp12, tmp13), consts, 2);
+  col2 = vaddq_s16(tmp13, z1);                /* phase 5 */
+  col6 = vsubq_s16(tmp13, z1);
+
+  /* Odd part */
+  tmp10 = vaddq_s16(tmp4, tmp5);              /* phase 2 */
+  tmp11 = vaddq_s16(tmp5, tmp6);
+  tmp12 = vaddq_s16(tmp6, tmp7);
+
+  int16x8_t z5 = vqdmulhq_lane_s16(vsubq_s16(tmp10, tmp12), consts, 0);
+  int16x8_t z2 = vqdmulhq_lane_s16(tmp10, consts, 1);
+  z2 = vaddq_s16(z2, z5);
+  int16x8_t z4 = vqdmulhq_lane_s16(tmp12, consts, 3);
+  z5 = vaddq_s16(tmp12, z5);
+  z4 = vaddq_s16(z4, z5);
+  int16x8_t z3 = vqdmulhq_lane_s16(tmp11, consts, 2);
+
+  int16x8_t z11 = vaddq_s16(tmp7, z3);        /* phase 5 */
+  int16x8_t z13 = vsubq_s16(tmp7, z3);
+
+  col5 = vaddq_s16(z13, z2);                  /* phase 6 */
+  col3 = vsubq_s16(z13, z2);
+  col1 = vaddq_s16(z11, z4);
+  col7 = vsubq_s16(z11, z4);
+
+  /* Transpose to work on columns in pass 2. */
+  int16x8x2_t cols_01 = vtrnq_s16(col0, col1);
+  int16x8x2_t cols_23 = vtrnq_s16(col2, col3);
+  int16x8x2_t cols_45 = vtrnq_s16(col4, col5);
+  int16x8x2_t cols_67 = vtrnq_s16(col6, col7);
+
+  int32x4x2_t cols_0145_l = vtrnq_s32(vreinterpretq_s32_s16(cols_01.val[0]),
+                                      vreinterpretq_s32_s16(cols_45.val[0]));
+  int32x4x2_t cols_0145_h = vtrnq_s32(vreinterpretq_s32_s16(cols_01.val[1]),
+                                      vreinterpretq_s32_s16(cols_45.val[1]));
+  int32x4x2_t cols_2367_l = vtrnq_s32(vreinterpretq_s32_s16(cols_23.val[0]),
+                                      vreinterpretq_s32_s16(cols_67.val[0]));
+  int32x4x2_t cols_2367_h = vtrnq_s32(vreinterpretq_s32_s16(cols_23.val[1]),
+                                      vreinterpretq_s32_s16(cols_67.val[1]));
+
+  int32x4x2_t rows_04 = vzipq_s32(cols_0145_l.val[0], cols_2367_l.val[0]);
+  int32x4x2_t rows_15 = vzipq_s32(cols_0145_h.val[0], cols_2367_h.val[0]);
+  int32x4x2_t rows_26 = vzipq_s32(cols_0145_l.val[1], cols_2367_l.val[1]);
+  int32x4x2_t rows_37 = vzipq_s32(cols_0145_h.val[1], cols_2367_h.val[1]);
+
+  int16x8_t row0 = vreinterpretq_s16_s32(rows_04.val[0]);
+  int16x8_t row1 = vreinterpretq_s16_s32(rows_15.val[0]);
+  int16x8_t row2 = vreinterpretq_s16_s32(rows_26.val[0]);
+  int16x8_t row3 = vreinterpretq_s16_s32(rows_37.val[0]);
+  int16x8_t row4 = vreinterpretq_s16_s32(rows_04.val[1]);
+  int16x8_t row5 = vreinterpretq_s16_s32(rows_15.val[1]);
+  int16x8_t row6 = vreinterpretq_s16_s32(rows_26.val[1]);
+  int16x8_t row7 = vreinterpretq_s16_s32(rows_37.val[1]);
+
+  /* Pass 2: process columns. */
+
+  tmp0 = vaddq_s16(row0, row7);
+  tmp7 = vsubq_s16(row0, row7);
+  tmp1 = vaddq_s16(row1, row6);
+  tmp6 = vsubq_s16(row1, row6);
+  tmp2 = vaddq_s16(row2, row5);
+  tmp5 = vsubq_s16(row2, row5);
+  tmp3 = vaddq_s16(row3, row4);
+  tmp4 = vsubq_s16(row3, row4);
+
+  /* Even part */
+  tmp10 = vaddq_s16(tmp0, tmp3);              /* phase 2 */
+  tmp13 = vsubq_s16(tmp0, tmp3);
+  tmp11 = vaddq_s16(tmp1, tmp2);
+  tmp12 = vsubq_s16(tmp1, tmp2);
+
+  row0 = vaddq_s16(tmp10, tmp11);             /* phase 3 */
+  row4 = vsubq_s16(tmp10, tmp11);
+
+  z1 = vqdmulhq_lane_s16(vaddq_s16(tmp12, tmp13), consts, 2);
+  row2 = vaddq_s16(tmp13, z1);                /* phase 5 */
+  row6 = vsubq_s16(tmp13, z1);
+
+  /* Odd part */
+  tmp10 = vaddq_s16(tmp4, tmp5);              /* phase 2 */
+  tmp11 = vaddq_s16(tmp5, tmp6);
+  tmp12 = vaddq_s16(tmp6, tmp7);
+
+  z5 = vqdmulhq_lane_s16(vsubq_s16(tmp10, tmp12), consts, 0);
+  z2 = vqdmulhq_lane_s16(tmp10, consts, 1);
+  z2 = vaddq_s16(z2, z5);
+  z4 = vqdmulhq_lane_s16(tmp12, consts, 3);
+  z5 = vaddq_s16(tmp12, z5);
+  z4 = vaddq_s16(z4, z5);
+  z3 = vqdmulhq_lane_s16(tmp11, consts, 2);
+
+  z11 = vaddq_s16(tmp7, z3);                  /* phase 5 */
+  z13 = vsubq_s16(tmp7, z3);
+
+  row5 = vaddq_s16(z13, z2);                  /* phase 6 */
+  row3 = vsubq_s16(z13, z2);
+  row1 = vaddq_s16(z11, z4);
+  row7 = vsubq_s16(z11, z4);
+
+  vst1q_s16(data + 0 * DCTSIZE, row0);
+  vst1q_s16(data + 1 * DCTSIZE, row1);
+  vst1q_s16(data + 2 * DCTSIZE, row2);
+  vst1q_s16(data + 3 * DCTSIZE, row3);
+  vst1q_s16(data + 4 * DCTSIZE, row4);
+  vst1q_s16(data + 5 * DCTSIZE, row5);
+  vst1q_s16(data + 6 * DCTSIZE, row6);
+  vst1q_s16(data + 7 * DCTSIZE, row7);
+}
diff --git a/3rdparty/libjpeg/src/simd/arm/jfdctint-neon.c b/3rdparty/libjpeg/src/simd/arm/jfdctint-neon.c
new file mode 100644
index 00000000..ccfc07b1
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/arm/jfdctint-neon.c
@@ -0,0 +1,376 @@
+/*
+ * jfdctint-neon.c - accurate integer FDCT (Arm Neon)
+ *
+ * Copyright (C) 2020, Arm Limited.  All Rights Reserved.
+ * Copyright (C) 2020, D. R. Commander.  All Rights Reserved.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+#define JPEG_INTERNALS
+#include "../../jinclude.h"
+#include "../../jpeglib.h"
+#include "../../jsimd.h"
+#include "../../jdct.h"
+#include "../../jsimddct.h"
+#include "../jsimd.h"
+#include "align.h"
+#include "neon-compat.h"
+
+#include <arm_neon.h>
+
+
+/* jsimd_fdct_islow_neon() performs a slower but more accurate forward DCT
+ * (Discrete Cosine Transform) on one block of samples.  It uses the same
+ * calculations and produces exactly the same output as IJG's original
+ * jpeg_fdct_islow() function, which can be found in jfdctint.c.
+ *
+ * Scaled integer constants are used to avoid floating-point arithmetic:
+ *    0.298631336 =  2446 * 2^-13
+ *    0.390180644 =  3196 * 2^-13
+ *    0.541196100 =  4433 * 2^-13
+ *    0.765366865 =  6270 * 2^-13
+ *    0.899976223 =  7373 * 2^-13
+ *    1.175875602 =  9633 * 2^-13
+ *    1.501321110 = 12299 * 2^-13
+ *    1.847759065 = 15137 * 2^-13
+ *    1.961570560 = 16069 * 2^-13
+ *    2.053119869 = 16819 * 2^-13
+ *    2.562915447 = 20995 * 2^-13
+ *    3.072711026 = 25172 * 2^-13
+ *
+ * See jfdctint.c for further details of the DCT algorithm.  Where possible,
+ * the variable names and comments here in jsimd_fdct_islow_neon() match up
+ * with those in jpeg_fdct_islow().
+ */
+
+#define CONST_BITS  13
+#define PASS1_BITS  2
+
+#define DESCALE_P1  (CONST_BITS - PASS1_BITS)
+#define DESCALE_P2  (CONST_BITS + PASS1_BITS)
+
+#define F_0_298  2446
+#define F_0_390  3196
+#define F_0_541  4433
+#define F_0_765  6270
+#define F_0_899  7373
+#define F_1_175  9633
+#define F_1_501  12299
+#define F_1_847  15137
+#define F_1_961  16069
+#define F_2_053  16819
+#define F_2_562  20995
+#define F_3_072  25172
+
+
+ALIGN(16) static const int16_t jsimd_fdct_islow_neon_consts[] = {
+  F_0_298, -F_0_390,  F_0_541,  F_0_765,
+ -F_0_899,  F_1_175,  F_1_501, -F_1_847,
+ -F_1_961,  F_2_053, -F_2_562,  F_3_072
+};
+
+void jsimd_fdct_islow_neon(DCTELEM *data)
+{
+  /* Load DCT constants. */
+#ifdef HAVE_VLD1_S16_X3
+  const int16x4x3_t consts = vld1_s16_x3(jsimd_fdct_islow_neon_consts);
+#else
+  /* GCC does not currently support the intrinsic vld1_<type>_x3(). */
+  const int16x4_t consts1 = vld1_s16(jsimd_fdct_islow_neon_consts);
+  const int16x4_t consts2 = vld1_s16(jsimd_fdct_islow_neon_consts + 4);
+  const int16x4_t consts3 = vld1_s16(jsimd_fdct_islow_neon_consts + 8);
+  const int16x4x3_t consts = { { consts1, consts2, consts3 } };
+#endif
+
+  /* Load an 8x8 block of samples into Neon registers.  De-interleaving loads
+   * are used, followed by vuzp to transpose the block such that we have a
+   * column of samples per vector - allowing all rows to be processed at once.
+   */
+  int16x8x4_t s_rows_0123 = vld4q_s16(data);
+  int16x8x4_t s_rows_4567 = vld4q_s16(data + 4 * DCTSIZE);
+
+  int16x8x2_t cols_04 = vuzpq_s16(s_rows_0123.val[0], s_rows_4567.val[0]);
+  int16x8x2_t cols_15 = vuzpq_s16(s_rows_0123.val[1], s_rows_4567.val[1]);
+  int16x8x2_t cols_26 = vuzpq_s16(s_rows_0123.val[2], s_rows_4567.val[2]);
+  int16x8x2_t cols_37 = vuzpq_s16(s_rows_0123.val[3], s_rows_4567.val[3]);
+
+  int16x8_t col0 = cols_04.val[0];
+  int16x8_t col1 = cols_15.val[0];
+  int16x8_t col2 = cols_26.val[0];
+  int16x8_t col3 = cols_37.val[0];
+  int16x8_t col4 = cols_04.val[1];
+  int16x8_t col5 = cols_15.val[1];
+  int16x8_t col6 = cols_26.val[1];
+  int16x8_t col7 = cols_37.val[1];
+
+  /* Pass 1: process rows. */
+
+  int16x8_t tmp0 = vaddq_s16(col0, col7);
+  int16x8_t tmp7 = vsubq_s16(col0, col7);
+  int16x8_t tmp1 = vaddq_s16(col1, col6);
+  int16x8_t tmp6 = vsubq_s16(col1, col6);
+  int16x8_t tmp2 = vaddq_s16(col2, col5);
+  int16x8_t tmp5 = vsubq_s16(col2, col5);
+  int16x8_t tmp3 = vaddq_s16(col3, col4);
+  int16x8_t tmp4 = vsubq_s16(col3, col4);
+
+  /* Even part */
+  int16x8_t tmp10 = vaddq_s16(tmp0, tmp3);
+  int16x8_t tmp13 = vsubq_s16(tmp0, tmp3);
+  int16x8_t tmp11 = vaddq_s16(tmp1, tmp2);
+  int16x8_t tmp12 = vsubq_s16(tmp1, tmp2);
+
+  col0 = vshlq_n_s16(vaddq_s16(tmp10, tmp11), PASS1_BITS);
+  col4 = vshlq_n_s16(vsubq_s16(tmp10, tmp11), PASS1_BITS);
+
+  int16x8_t tmp12_add_tmp13 = vaddq_s16(tmp12, tmp13);
+  int32x4_t z1_l =
+    vmull_lane_s16(vget_low_s16(tmp12_add_tmp13), consts.val[0], 2);
+  int32x4_t z1_h =
+    vmull_lane_s16(vget_high_s16(tmp12_add_tmp13), consts.val[0], 2);
+
+  int32x4_t col2_scaled_l =
+    vmlal_lane_s16(z1_l, vget_low_s16(tmp13), consts.val[0], 3);
+  int32x4_t col2_scaled_h =
+    vmlal_lane_s16(z1_h, vget_high_s16(tmp13), consts.val[0], 3);
+  col2 = vcombine_s16(vrshrn_n_s32(col2_scaled_l, DESCALE_P1),
+                      vrshrn_n_s32(col2_scaled_h, DESCALE_P1));
+
+  int32x4_t col6_scaled_l =
+    vmlal_lane_s16(z1_l, vget_low_s16(tmp12), consts.val[1], 3);
+  int32x4_t col6_scaled_h =
+    vmlal_lane_s16(z1_h, vget_high_s16(tmp12), consts.val[1], 3);
+  col6 = vcombine_s16(vrshrn_n_s32(col6_scaled_l, DESCALE_P1),
+                      vrshrn_n_s32(col6_scaled_h, DESCALE_P1));
+
+  /* Odd part */
+  int16x8_t z1 = vaddq_s16(tmp4, tmp7);
+  int16x8_t z2 = vaddq_s16(tmp5, tmp6);
+  int16x8_t z3 = vaddq_s16(tmp4, tmp6);
+  int16x8_t z4 = vaddq_s16(tmp5, tmp7);
+  /* sqrt(2) * c3 */
+  int32x4_t z5_l = vmull_lane_s16(vget_low_s16(z3), consts.val[1], 1);
+  int32x4_t z5_h = vmull_lane_s16(vget_high_s16(z3), consts.val[1], 1);
+  z5_l = vmlal_lane_s16(z5_l, vget_low_s16(z4), consts.val[1], 1);
+  z5_h = vmlal_lane_s16(z5_h, vget_high_s16(z4), consts.val[1], 1);
+
+  /* sqrt(2) * (-c1+c3+c5-c7) */
+  int32x4_t tmp4_l = vmull_lane_s16(vget_low_s16(tmp4), consts.val[0], 0);
+  int32x4_t tmp4_h = vmull_lane_s16(vget_high_s16(tmp4), consts.val[0], 0);
+  /* sqrt(2) * ( c1+c3-c5+c7) */
+  int32x4_t tmp5_l = vmull_lane_s16(vget_low_s16(tmp5), consts.val[2], 1);
+  int32x4_t tmp5_h = vmull_lane_s16(vget_high_s16(tmp5), consts.val[2], 1);
+  /* sqrt(2) * ( c1+c3+c5-c7) */
+  int32x4_t tmp6_l = vmull_lane_s16(vget_low_s16(tmp6), consts.val[2], 3);
+  int32x4_t tmp6_h = vmull_lane_s16(vget_high_s16(tmp6), consts.val[2], 3);
+  /* sqrt(2) * ( c1+c3-c5-c7) */
+  int32x4_t tmp7_l = vmull_lane_s16(vget_low_s16(tmp7), consts.val[1], 2);
+  int32x4_t tmp7_h = vmull_lane_s16(vget_high_s16(tmp7), consts.val[1], 2);
+
+  /* sqrt(2) * (c7-c3) */
+  z1_l = vmull_lane_s16(vget_low_s16(z1), consts.val[1], 0);
+  z1_h = vmull_lane_s16(vget_high_s16(z1), consts.val[1], 0);
+  /* sqrt(2) * (-c1-c3) */
+  int32x4_t z2_l = vmull_lane_s16(vget_low_s16(z2), consts.val[2], 2);
+  int32x4_t z2_h = vmull_lane_s16(vget_high_s16(z2), consts.val[2], 2);
+  /* sqrt(2) * (-c3-c5) */
+  int32x4_t z3_l = vmull_lane_s16(vget_low_s16(z3), consts.val[2], 0);
+  int32x4_t z3_h = vmull_lane_s16(vget_high_s16(z3), consts.val[2], 0);
+  /* sqrt(2) * (c5-c3) */
+  int32x4_t z4_l = vmull_lane_s16(vget_low_s16(z4), consts.val[0], 1);
+  int32x4_t z4_h = vmull_lane_s16(vget_high_s16(z4), consts.val[0], 1);
+
+  z3_l = vaddq_s32(z3_l, z5_l);
+  z3_h = vaddq_s32(z3_h, z5_h);
+  z4_l = vaddq_s32(z4_l, z5_l);
+  z4_h = vaddq_s32(z4_h, z5_h);
+
+  tmp4_l = vaddq_s32(tmp4_l, z1_l);
+  tmp4_h = vaddq_s32(tmp4_h, z1_h);
+  tmp4_l = vaddq_s32(tmp4_l, z3_l);
+  tmp4_h = vaddq_s32(tmp4_h, z3_h);
+  col7 = vcombine_s16(vrshrn_n_s32(tmp4_l, DESCALE_P1),
+                      vrshrn_n_s32(tmp4_h, DESCALE_P1));
+
+  tmp5_l = vaddq_s32(tmp5_l, z2_l);
+  tmp5_h = vaddq_s32(tmp5_h, z2_h);
+  tmp5_l = vaddq_s32(tmp5_l, z4_l);
+  tmp5_h = vaddq_s32(tmp5_h, z4_h);
+  col5 = vcombine_s16(vrshrn_n_s32(tmp5_l, DESCALE_P1),
+                      vrshrn_n_s32(tmp5_h, DESCALE_P1));
+
+  tmp6_l = vaddq_s32(tmp6_l, z2_l);
+  tmp6_h = vaddq_s32(tmp6_h, z2_h);
+  tmp6_l = vaddq_s32(tmp6_l, z3_l);
+  tmp6_h = vaddq_s32(tmp6_h, z3_h);
+  col3 = vcombine_s16(vrshrn_n_s32(tmp6_l, DESCALE_P1),
+                      vrshrn_n_s32(tmp6_h, DESCALE_P1));
+
+  tmp7_l = vaddq_s32(tmp7_l, z1_l);
+  tmp7_h = vaddq_s32(tmp7_h, z1_h);
+  tmp7_l = vaddq_s32(tmp7_l, z4_l);
+  tmp7_h = vaddq_s32(tmp7_h, z4_h);
+  col1 = vcombine_s16(vrshrn_n_s32(tmp7_l, DESCALE_P1),
+                      vrshrn_n_s32(tmp7_h, DESCALE_P1));
+
+  /* Transpose to work on columns in pass 2. */
+  int16x8x2_t cols_01 = vtrnq_s16(col0, col1);
+  int16x8x2_t cols_23 = vtrnq_s16(col2, col3);
+  int16x8x2_t cols_45 = vtrnq_s16(col4, col5);
+  int16x8x2_t cols_67 = vtrnq_s16(col6, col7);
+
+  int32x4x2_t cols_0145_l = vtrnq_s32(vreinterpretq_s32_s16(cols_01.val[0]),
+                                      vreinterpretq_s32_s16(cols_45.val[0]));
+  int32x4x2_t cols_0145_h = vtrnq_s32(vreinterpretq_s32_s16(cols_01.val[1]),
+                                      vreinterpretq_s32_s16(cols_45.val[1]));
+  int32x4x2_t cols_2367_l = vtrnq_s32(vreinterpretq_s32_s16(cols_23.val[0]),
+                                      vreinterpretq_s32_s16(cols_67.val[0]));
+  int32x4x2_t cols_2367_h = vtrnq_s32(vreinterpretq_s32_s16(cols_23.val[1]),
+                                      vreinterpretq_s32_s16(cols_67.val[1]));
+
+  int32x4x2_t rows_04 = vzipq_s32(cols_0145_l.val[0], cols_2367_l.val[0]);
+  int32x4x2_t rows_15 = vzipq_s32(cols_0145_h.val[0], cols_2367_h.val[0]);
+  int32x4x2_t rows_26 = vzipq_s32(cols_0145_l.val[1], cols_2367_l.val[1]);
+  int32x4x2_t rows_37 = vzipq_s32(cols_0145_h.val[1], cols_2367_h.val[1]);
+
+  int16x8_t row0 = vreinterpretq_s16_s32(rows_04.val[0]);
+  int16x8_t row1 = vreinterpretq_s16_s32(rows_15.val[0]);
+  int16x8_t row2 = vreinterpretq_s16_s32(rows_26.val[0]);
+  int16x8_t row3 = vreinterpretq_s16_s32(rows_37.val[0]);
+  int16x8_t row4 = vreinterpretq_s16_s32(rows_04.val[1]);
+  int16x8_t row5 = vreinterpretq_s16_s32(rows_15.val[1]);
+  int16x8_t row6 = vreinterpretq_s16_s32(rows_26.val[1]);
+  int16x8_t row7 = vreinterpretq_s16_s32(rows_37.val[1]);
+
+  /* Pass 2: process columns. */
+
+  tmp0 = vaddq_s16(row0, row7);
+  tmp7 = vsubq_s16(row0, row7);
+  tmp1 = vaddq_s16(row1, row6);
+  tmp6 = vsubq_s16(row1, row6);
+  tmp2 = vaddq_s16(row2, row5);
+  tmp5 = vsubq_s16(row2, row5);
+  tmp3 = vaddq_s16(row3, row4);
+  tmp4 = vsubq_s16(row3, row4);
+
+  /* Even part */
+  tmp10 = vaddq_s16(tmp0, tmp3);
+  tmp13 = vsubq_s16(tmp0, tmp3);
+  tmp11 = vaddq_s16(tmp1, tmp2);
+  tmp12 = vsubq_s16(tmp1, tmp2);
+
+  row0 = vrshrq_n_s16(vaddq_s16(tmp10, tmp11), PASS1_BITS);
+  row4 = vrshrq_n_s16(vsubq_s16(tmp10, tmp11), PASS1_BITS);
+
+  tmp12_add_tmp13 = vaddq_s16(tmp12, tmp13);
+  z1_l = vmull_lane_s16(vget_low_s16(tmp12_add_tmp13), consts.val[0], 2);
+  z1_h = vmull_lane_s16(vget_high_s16(tmp12_add_tmp13), consts.val[0], 2);
+
+  int32x4_t row2_scaled_l =
+    vmlal_lane_s16(z1_l, vget_low_s16(tmp13), consts.val[0], 3);
+  int32x4_t row2_scaled_h =
+    vmlal_lane_s16(z1_h, vget_high_s16(tmp13), consts.val[0], 3);
+  row2 = vcombine_s16(vrshrn_n_s32(row2_scaled_l, DESCALE_P2),
+                      vrshrn_n_s32(row2_scaled_h, DESCALE_P2));
+
+  int32x4_t row6_scaled_l =
+    vmlal_lane_s16(z1_l, vget_low_s16(tmp12), consts.val[1], 3);
+  int32x4_t row6_scaled_h =
+    vmlal_lane_s16(z1_h, vget_high_s16(tmp12), consts.val[1], 3);
+  row6 = vcombine_s16(vrshrn_n_s32(row6_scaled_l, DESCALE_P2),
+                      vrshrn_n_s32(row6_scaled_h, DESCALE_P2));
+
+  /* Odd part */
+  z1 = vaddq_s16(tmp4, tmp7);
+  z2 = vaddq_s16(tmp5, tmp6);
+  z3 = vaddq_s16(tmp4, tmp6);
+  z4 = vaddq_s16(tmp5, tmp7);
+  /* sqrt(2) * c3 */
+  z5_l = vmull_lane_s16(vget_low_s16(z3), consts.val[1], 1);
+  z5_h = vmull_lane_s16(vget_high_s16(z3), consts.val[1], 1);
+  z5_l = vmlal_lane_s16(z5_l, vget_low_s16(z4), consts.val[1], 1);
+  z5_h = vmlal_lane_s16(z5_h, vget_high_s16(z4), consts.val[1], 1);
+
+  /* sqrt(2) * (-c1+c3+c5-c7) */
+  tmp4_l = vmull_lane_s16(vget_low_s16(tmp4), consts.val[0], 0);
+  tmp4_h = vmull_lane_s16(vget_high_s16(tmp4), consts.val[0], 0);
+  /* sqrt(2) * ( c1+c3-c5+c7) */
+  tmp5_l = vmull_lane_s16(vget_low_s16(tmp5), consts.val[2], 1);
+  tmp5_h = vmull_lane_s16(vget_high_s16(tmp5), consts.val[2], 1);
+  /* sqrt(2) * ( c1+c3+c5-c7) */
+  tmp6_l = vmull_lane_s16(vget_low_s16(tmp6), consts.val[2], 3);
+  tmp6_h = vmull_lane_s16(vget_high_s16(tmp6), consts.val[2], 3);
+  /* sqrt(2) * ( c1+c3-c5-c7) */
+  tmp7_l = vmull_lane_s16(vget_low_s16(tmp7), consts.val[1], 2);
+  tmp7_h = vmull_lane_s16(vget_high_s16(tmp7), consts.val[1], 2);
+
+  /* sqrt(2) * (c7-c3) */
+  z1_l = vmull_lane_s16(vget_low_s16(z1), consts.val[1], 0);
+  z1_h = vmull_lane_s16(vget_high_s16(z1), consts.val[1], 0);
+  /* sqrt(2) * (-c1-c3) */
+  z2_l = vmull_lane_s16(vget_low_s16(z2), consts.val[2], 2);
+  z2_h = vmull_lane_s16(vget_high_s16(z2), consts.val[2], 2);
+  /* sqrt(2) * (-c3-c5) */
+  z3_l = vmull_lane_s16(vget_low_s16(z3), consts.val[2], 0);
+  z3_h = vmull_lane_s16(vget_high_s16(z3), consts.val[2], 0);
+  /* sqrt(2) * (c5-c3) */
+  z4_l = vmull_lane_s16(vget_low_s16(z4), consts.val[0], 1);
+  z4_h = vmull_lane_s16(vget_high_s16(z4), consts.val[0], 1);
+
+  z3_l = vaddq_s32(z3_l, z5_l);
+  z3_h = vaddq_s32(z3_h, z5_h);
+  z4_l = vaddq_s32(z4_l, z5_l);
+  z4_h = vaddq_s32(z4_h, z5_h);
+
+  tmp4_l = vaddq_s32(tmp4_l, z1_l);
+  tmp4_h = vaddq_s32(tmp4_h, z1_h);
+  tmp4_l = vaddq_s32(tmp4_l, z3_l);
+  tmp4_h = vaddq_s32(tmp4_h, z3_h);
+  row7 = vcombine_s16(vrshrn_n_s32(tmp4_l, DESCALE_P2),
+                      vrshrn_n_s32(tmp4_h, DESCALE_P2));
+
+  tmp5_l = vaddq_s32(tmp5_l, z2_l);
+  tmp5_h = vaddq_s32(tmp5_h, z2_h);
+  tmp5_l = vaddq_s32(tmp5_l, z4_l);
+  tmp5_h = vaddq_s32(tmp5_h, z4_h);
+  row5 = vcombine_s16(vrshrn_n_s32(tmp5_l, DESCALE_P2),
+                      vrshrn_n_s32(tmp5_h, DESCALE_P2));
+
+  tmp6_l = vaddq_s32(tmp6_l, z2_l);
+  tmp6_h = vaddq_s32(tmp6_h, z2_h);
+  tmp6_l = vaddq_s32(tmp6_l, z3_l);
+  tmp6_h = vaddq_s32(tmp6_h, z3_h);
+  row3 = vcombine_s16(vrshrn_n_s32(tmp6_l, DESCALE_P2),
+                      vrshrn_n_s32(tmp6_h, DESCALE_P2));
+
+  tmp7_l = vaddq_s32(tmp7_l, z1_l);
+  tmp7_h = vaddq_s32(tmp7_h, z1_h);
+  tmp7_l = vaddq_s32(tmp7_l, z4_l);
+  tmp7_h = vaddq_s32(tmp7_h, z4_h);
+  row1 = vcombine_s16(vrshrn_n_s32(tmp7_l, DESCALE_P2),
+                      vrshrn_n_s32(tmp7_h, DESCALE_P2));
+
+  vst1q_s16(data + 0 * DCTSIZE, row0);
+  vst1q_s16(data + 1 * DCTSIZE, row1);
+  vst1q_s16(data + 2 * DCTSIZE, row2);
+  vst1q_s16(data + 3 * DCTSIZE, row3);
+  vst1q_s16(data + 4 * DCTSIZE, row4);
+  vst1q_s16(data + 5 * DCTSIZE, row5);
+  vst1q_s16(data + 6 * DCTSIZE, row6);
+  vst1q_s16(data + 7 * DCTSIZE, row7);
+}
diff --git a/3rdparty/libjpeg/src/simd/arm/jidctfst-neon.c b/3rdparty/libjpeg/src/simd/arm/jidctfst-neon.c
new file mode 100644
index 00000000..a91be536
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/arm/jidctfst-neon.c
@@ -0,0 +1,472 @@
+/*
+ * jidctfst-neon.c - fast integer IDCT (Arm Neon)
+ *
+ * Copyright (C) 2020, Arm Limited.  All Rights Reserved.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+#define JPEG_INTERNALS
+#include "../../jinclude.h"
+#include "../../jpeglib.h"
+#include "../../jsimd.h"
+#include "../../jdct.h"
+#include "../../jsimddct.h"
+#include "../jsimd.h"
+#include "align.h"
+
+#include <arm_neon.h>
+
+
+/* jsimd_idct_ifast_neon() performs dequantization and a fast, not so accurate
+ * inverse DCT (Discrete Cosine Transform) on one block of coefficients.  It
+ * uses the same calculations and produces exactly the same output as IJG's
+ * original jpeg_idct_ifast() function, which can be found in jidctfst.c.
+ *
+ * Scaled integer constants are used to avoid floating-point arithmetic:
+ *    0.082392200 =  2688 * 2^-15
+ *    0.414213562 = 13568 * 2^-15
+ *    0.847759065 = 27776 * 2^-15
+ *    0.613125930 = 20096 * 2^-15
+ *
+ * See jidctfst.c for further details of the IDCT algorithm.  Where possible,
+ * the variable names and comments here in jsimd_idct_ifast_neon() match up
+ * with those in jpeg_idct_ifast().
+ */
+
+#define PASS1_BITS  2
+
+#define F_0_082  2688
+#define F_0_414  13568
+#define F_0_847  27776
+#define F_0_613  20096
+
+
+ALIGN(16) static const int16_t jsimd_idct_ifast_neon_consts[] = {
+  F_0_082, F_0_414, F_0_847, F_0_613
+};
+
+void jsimd_idct_ifast_neon(void *dct_table, JCOEFPTR coef_block,
+                           JSAMPARRAY output_buf, JDIMENSION output_col)
+{
+  IFAST_MULT_TYPE *quantptr = dct_table;
+
+  /* Load DCT coefficients. */
+  int16x8_t row0 = vld1q_s16(coef_block + 0 * DCTSIZE);
+  int16x8_t row1 = vld1q_s16(coef_block + 1 * DCTSIZE);
+  int16x8_t row2 = vld1q_s16(coef_block + 2 * DCTSIZE);
+  int16x8_t row3 = vld1q_s16(coef_block + 3 * DCTSIZE);
+  int16x8_t row4 = vld1q_s16(coef_block + 4 * DCTSIZE);
+  int16x8_t row5 = vld1q_s16(coef_block + 5 * DCTSIZE);
+  int16x8_t row6 = vld1q_s16(coef_block + 6 * DCTSIZE);
+  int16x8_t row7 = vld1q_s16(coef_block + 7 * DCTSIZE);
+
+  /* Load quantization table values for DC coefficients. */
+  int16x8_t quant_row0 = vld1q_s16(quantptr + 0 * DCTSIZE);
+  /* Dequantize DC coefficients. */
+  row0 = vmulq_s16(row0, quant_row0);
+
+  /* Construct bitmap to test if all AC coefficients are 0. */
+  int16x8_t bitmap = vorrq_s16(row1, row2);
+  bitmap = vorrq_s16(bitmap, row3);
+  bitmap = vorrq_s16(bitmap, row4);
+  bitmap = vorrq_s16(bitmap, row5);
+  bitmap = vorrq_s16(bitmap, row6);
+  bitmap = vorrq_s16(bitmap, row7);
+
+  int64_t left_ac_bitmap = vgetq_lane_s64(vreinterpretq_s64_s16(bitmap), 0);
+  int64_t right_ac_bitmap = vgetq_lane_s64(vreinterpretq_s64_s16(bitmap), 1);
+
+  /* Load IDCT conversion constants. */
+  const int16x4_t consts = vld1_s16(jsimd_idct_ifast_neon_consts);
+
+  if (left_ac_bitmap == 0 && right_ac_bitmap == 0) {
+    /* All AC coefficients are zero.
+     * Compute DC values and duplicate into vectors.
+     */
+    int16x8_t dcval = row0;
+    row1 = dcval;
+    row2 = dcval;
+    row3 = dcval;
+    row4 = dcval;
+    row5 = dcval;
+    row6 = dcval;
+    row7 = dcval;
+  } else if (left_ac_bitmap == 0) {
+    /* AC coefficients are zero for columns 0, 1, 2, and 3.
+     * Use DC values for these columns.
+     */
+    int16x4_t dcval = vget_low_s16(row0);
+
+    /* Commence regular fast IDCT computation for columns 4, 5, 6, and 7. */
+
+    /* Load quantization table. */
+    int16x4_t quant_row1 = vld1_s16(quantptr + 1 * DCTSIZE + 4);
+    int16x4_t quant_row2 = vld1_s16(quantptr + 2 * DCTSIZE + 4);
+    int16x4_t quant_row3 = vld1_s16(quantptr + 3 * DCTSIZE + 4);
+    int16x4_t quant_row4 = vld1_s16(quantptr + 4 * DCTSIZE + 4);
+    int16x4_t quant_row5 = vld1_s16(quantptr + 5 * DCTSIZE + 4);
+    int16x4_t quant_row6 = vld1_s16(quantptr + 6 * DCTSIZE + 4);
+    int16x4_t quant_row7 = vld1_s16(quantptr + 7 * DCTSIZE + 4);
+
+    /* Even part: dequantize DCT coefficients. */
+    int16x4_t tmp0 = vget_high_s16(row0);
+    int16x4_t tmp1 = vmul_s16(vget_high_s16(row2), quant_row2);
+    int16x4_t tmp2 = vmul_s16(vget_high_s16(row4), quant_row4);
+    int16x4_t tmp3 = vmul_s16(vget_high_s16(row6), quant_row6);
+
+    int16x4_t tmp10 = vadd_s16(tmp0, tmp2);   /* phase 3 */
+    int16x4_t tmp11 = vsub_s16(tmp0, tmp2);
+
+    int16x4_t tmp13 = vadd_s16(tmp1, tmp3);   /* phases 5-3 */
+    int16x4_t tmp1_sub_tmp3 = vsub_s16(tmp1, tmp3);
+    int16x4_t tmp12 = vqdmulh_lane_s16(tmp1_sub_tmp3, consts, 1);
+    tmp12 = vadd_s16(tmp12, tmp1_sub_tmp3);
+    tmp12 = vsub_s16(tmp12, tmp13);
+
+    tmp0 = vadd_s16(tmp10, tmp13);            /* phase 2 */
+    tmp3 = vsub_s16(tmp10, tmp13);
+    tmp1 = vadd_s16(tmp11, tmp12);
+    tmp2 = vsub_s16(tmp11, tmp12);
+
+    /* Odd part: dequantize DCT coefficients. */
+    int16x4_t tmp4 = vmul_s16(vget_high_s16(row1), quant_row1);
+    int16x4_t tmp5 = vmul_s16(vget_high_s16(row3), quant_row3);
+    int16x4_t tmp6 = vmul_s16(vget_high_s16(row5), quant_row5);
+    int16x4_t tmp7 = vmul_s16(vget_high_s16(row7), quant_row7);
+
+    int16x4_t z13 = vadd_s16(tmp6, tmp5);     /* phase 6 */
+    int16x4_t neg_z10 = vsub_s16(tmp5, tmp6);
+    int16x4_t z11 = vadd_s16(tmp4, tmp7);
+    int16x4_t z12 = vsub_s16(tmp4, tmp7);
+
+    tmp7 = vadd_s16(z11, z13);                /* phase 5 */
+    int16x4_t z11_sub_z13 = vsub_s16(z11, z13);
+    tmp11 = vqdmulh_lane_s16(z11_sub_z13, consts, 1);
+    tmp11 = vadd_s16(tmp11, z11_sub_z13);
+
+    int16x4_t z10_add_z12 = vsub_s16(z12, neg_z10);
+    int16x4_t z5 = vqdmulh_lane_s16(z10_add_z12, consts, 2);
+    z5 = vadd_s16(z5, z10_add_z12);
+    tmp10 = vqdmulh_lane_s16(z12, consts, 0);
+    tmp10 = vadd_s16(tmp10, z12);
+    tmp10 = vsub_s16(tmp10, z5);
+    tmp12 = vqdmulh_lane_s16(neg_z10, consts, 3);
+    tmp12 = vadd_s16(tmp12, vadd_s16(neg_z10, neg_z10));
+    tmp12 = vadd_s16(tmp12, z5);
+
+    tmp6 = vsub_s16(tmp12, tmp7);             /* phase 2 */
+    tmp5 = vsub_s16(tmp11, tmp6);
+    tmp4 = vadd_s16(tmp10, tmp5);
+
+    row0 = vcombine_s16(dcval, vadd_s16(tmp0, tmp7));
+    row7 = vcombine_s16(dcval, vsub_s16(tmp0, tmp7));
+    row1 = vcombine_s16(dcval, vadd_s16(tmp1, tmp6));
+    row6 = vcombine_s16(dcval, vsub_s16(tmp1, tmp6));
+    row2 = vcombine_s16(dcval, vadd_s16(tmp2, tmp5));
+    row5 = vcombine_s16(dcval, vsub_s16(tmp2, tmp5));
+    row4 = vcombine_s16(dcval, vadd_s16(tmp3, tmp4));
+    row3 = vcombine_s16(dcval, vsub_s16(tmp3, tmp4));
+  } else if (right_ac_bitmap == 0) {
+    /* AC coefficients are zero for columns 4, 5, 6, and 7.
+     * Use DC values for these columns.
+     */
+    int16x4_t dcval = vget_high_s16(row0);
+
+    /* Commence regular fast IDCT computation for columns 0, 1, 2, and 3. */
+
+    /* Load quantization table. */
+    int16x4_t quant_row1 = vld1_s16(quantptr + 1 * DCTSIZE);
+    int16x4_t quant_row2 = vld1_s16(quantptr + 2 * DCTSIZE);
+    int16x4_t quant_row3 = vld1_s16(quantptr + 3 * DCTSIZE);
+    int16x4_t quant_row4 = vld1_s16(quantptr + 4 * DCTSIZE);
+    int16x4_t quant_row5 = vld1_s16(quantptr + 5 * DCTSIZE);
+    int16x4_t quant_row6 = vld1_s16(quantptr + 6 * DCTSIZE);
+    int16x4_t quant_row7 = vld1_s16(quantptr + 7 * DCTSIZE);
+
+    /* Even part: dequantize DCT coefficients. */
+    int16x4_t tmp0 = vget_low_s16(row0);
+    int16x4_t tmp1 = vmul_s16(vget_low_s16(row2), quant_row2);
+    int16x4_t tmp2 = vmul_s16(vget_low_s16(row4), quant_row4);
+    int16x4_t tmp3 = vmul_s16(vget_low_s16(row6), quant_row6);
+
+    int16x4_t tmp10 = vadd_s16(tmp0, tmp2);   /* phase 3 */
+    int16x4_t tmp11 = vsub_s16(tmp0, tmp2);
+
+    int16x4_t tmp13 = vadd_s16(tmp1, tmp3);   /* phases 5-3 */
+    int16x4_t tmp1_sub_tmp3 = vsub_s16(tmp1, tmp3);
+    int16x4_t tmp12 = vqdmulh_lane_s16(tmp1_sub_tmp3, consts, 1);
+    tmp12 = vadd_s16(tmp12, tmp1_sub_tmp3);
+    tmp12 = vsub_s16(tmp12, tmp13);
+
+    tmp0 = vadd_s16(tmp10, tmp13);            /* phase 2 */
+    tmp3 = vsub_s16(tmp10, tmp13);
+    tmp1 = vadd_s16(tmp11, tmp12);
+    tmp2 = vsub_s16(tmp11, tmp12);
+
+    /* Odd part: dequantize DCT coefficients. */
+    int16x4_t tmp4 = vmul_s16(vget_low_s16(row1), quant_row1);
+    int16x4_t tmp5 = vmul_s16(vget_low_s16(row3), quant_row3);
+    int16x4_t tmp6 = vmul_s16(vget_low_s16(row5), quant_row5);
+    int16x4_t tmp7 = vmul_s16(vget_low_s16(row7), quant_row7);
+
+    int16x4_t z13 = vadd_s16(tmp6, tmp5);     /* phase 6 */
+    int16x4_t neg_z10 = vsub_s16(tmp5, tmp6);
+    int16x4_t z11 = vadd_s16(tmp4, tmp7);
+    int16x4_t z12 = vsub_s16(tmp4, tmp7);
+
+    tmp7 = vadd_s16(z11, z13);                /* phase 5 */
+    int16x4_t z11_sub_z13 = vsub_s16(z11, z13);
+    tmp11 = vqdmulh_lane_s16(z11_sub_z13, consts, 1);
+    tmp11 = vadd_s16(tmp11, z11_sub_z13);
+
+    int16x4_t z10_add_z12 = vsub_s16(z12, neg_z10);
+    int16x4_t z5 = vqdmulh_lane_s16(z10_add_z12, consts, 2);
+    z5 = vadd_s16(z5, z10_add_z12);
+    tmp10 = vqdmulh_lane_s16(z12, consts, 0);
+    tmp10 = vadd_s16(tmp10, z12);
+    tmp10 = vsub_s16(tmp10, z5);
+    tmp12 = vqdmulh_lane_s16(neg_z10, consts, 3);
+    tmp12 = vadd_s16(tmp12, vadd_s16(neg_z10, neg_z10));
+    tmp12 = vadd_s16(tmp12, z5);
+
+    tmp6 = vsub_s16(tmp12, tmp7);             /* phase 2 */
+    tmp5 = vsub_s16(tmp11, tmp6);
+    tmp4 = vadd_s16(tmp10, tmp5);
+
+    row0 = vcombine_s16(vadd_s16(tmp0, tmp7), dcval);
+    row7 = vcombine_s16(vsub_s16(tmp0, tmp7), dcval);
+    row1 = vcombine_s16(vadd_s16(tmp1, tmp6), dcval);
+    row6 = vcombine_s16(vsub_s16(tmp1, tmp6), dcval);
+    row2 = vcombine_s16(vadd_s16(tmp2, tmp5), dcval);
+    row5 = vcombine_s16(vsub_s16(tmp2, tmp5), dcval);
+    row4 = vcombine_s16(vadd_s16(tmp3, tmp4), dcval);
+    row3 = vcombine_s16(vsub_s16(tmp3, tmp4), dcval);
+  } else {
+    /* Some AC coefficients are non-zero; full IDCT calculation required. */
+
+    /* Load quantization table. */
+    int16x8_t quant_row1 = vld1q_s16(quantptr + 1 * DCTSIZE);
+    int16x8_t quant_row2 = vld1q_s16(quantptr + 2 * DCTSIZE);
+    int16x8_t quant_row3 = vld1q_s16(quantptr + 3 * DCTSIZE);
+    int16x8_t quant_row4 = vld1q_s16(quantptr + 4 * DCTSIZE);
+    int16x8_t quant_row5 = vld1q_s16(quantptr + 5 * DCTSIZE);
+    int16x8_t quant_row6 = vld1q_s16(quantptr + 6 * DCTSIZE);
+    int16x8_t quant_row7 = vld1q_s16(quantptr + 7 * DCTSIZE);
+
+    /* Even part: dequantize DCT coefficients. */
+    int16x8_t tmp0 = row0;
+    int16x8_t tmp1 = vmulq_s16(row2, quant_row2);
+    int16x8_t tmp2 = vmulq_s16(row4, quant_row4);
+    int16x8_t tmp3 = vmulq_s16(row6, quant_row6);
+
+    int16x8_t tmp10 = vaddq_s16(tmp0, tmp2);   /* phase 3 */
+    int16x8_t tmp11 = vsubq_s16(tmp0, tmp2);
+
+    int16x8_t tmp13 = vaddq_s16(tmp1, tmp3);   /* phases 5-3 */
+    int16x8_t tmp1_sub_tmp3 = vsubq_s16(tmp1, tmp3);
+    int16x8_t tmp12 = vqdmulhq_lane_s16(tmp1_sub_tmp3, consts, 1);
+    tmp12 = vaddq_s16(tmp12, tmp1_sub_tmp3);
+    tmp12 = vsubq_s16(tmp12, tmp13);
+
+    tmp0 = vaddq_s16(tmp10, tmp13);            /* phase 2 */
+    tmp3 = vsubq_s16(tmp10, tmp13);
+    tmp1 = vaddq_s16(tmp11, tmp12);
+    tmp2 = vsubq_s16(tmp11, tmp12);
+
+    /* Odd part: dequantize DCT coefficients. */
+    int16x8_t tmp4 = vmulq_s16(row1, quant_row1);
+    int16x8_t tmp5 = vmulq_s16(row3, quant_row3);
+    int16x8_t tmp6 = vmulq_s16(row5, quant_row5);
+    int16x8_t tmp7 = vmulq_s16(row7, quant_row7);
+
+    int16x8_t z13 = vaddq_s16(tmp6, tmp5);     /* phase 6 */
+    int16x8_t neg_z10 = vsubq_s16(tmp5, tmp6);
+    int16x8_t z11 = vaddq_s16(tmp4, tmp7);
+    int16x8_t z12 = vsubq_s16(tmp4, tmp7);
+
+    tmp7 = vaddq_s16(z11, z13);                /* phase 5 */
+    int16x8_t z11_sub_z13 = vsubq_s16(z11, z13);
+    tmp11 = vqdmulhq_lane_s16(z11_sub_z13, consts, 1);
+    tmp11 = vaddq_s16(tmp11, z11_sub_z13);
+
+    int16x8_t z10_add_z12 = vsubq_s16(z12, neg_z10);
+    int16x8_t z5 = vqdmulhq_lane_s16(z10_add_z12, consts, 2);
+    z5 = vaddq_s16(z5, z10_add_z12);
+    tmp10 = vqdmulhq_lane_s16(z12, consts, 0);
+    tmp10 = vaddq_s16(tmp10, z12);
+    tmp10 = vsubq_s16(tmp10, z5);
+    tmp12 = vqdmulhq_lane_s16(neg_z10, consts, 3);
+    tmp12 = vaddq_s16(tmp12, vaddq_s16(neg_z10, neg_z10));
+    tmp12 = vaddq_s16(tmp12, z5);
+
+    tmp6 = vsubq_s16(tmp12, tmp7);             /* phase 2 */
+    tmp5 = vsubq_s16(tmp11, tmp6);
+    tmp4 = vaddq_s16(tmp10, tmp5);
+
+    row0 = vaddq_s16(tmp0, tmp7);
+    row7 = vsubq_s16(tmp0, tmp7);
+    row1 = vaddq_s16(tmp1, tmp6);
+    row6 = vsubq_s16(tmp1, tmp6);
+    row2 = vaddq_s16(tmp2, tmp5);
+    row5 = vsubq_s16(tmp2, tmp5);
+    row4 = vaddq_s16(tmp3, tmp4);
+    row3 = vsubq_s16(tmp3, tmp4);
+  }
+
+  /* Transpose rows to work on columns in pass 2. */
+  int16x8x2_t rows_01 = vtrnq_s16(row0, row1);
+  int16x8x2_t rows_23 = vtrnq_s16(row2, row3);
+  int16x8x2_t rows_45 = vtrnq_s16(row4, row5);
+  int16x8x2_t rows_67 = vtrnq_s16(row6, row7);
+
+  int32x4x2_t rows_0145_l = vtrnq_s32(vreinterpretq_s32_s16(rows_01.val[0]),
+                                      vreinterpretq_s32_s16(rows_45.val[0]));
+  int32x4x2_t rows_0145_h = vtrnq_s32(vreinterpretq_s32_s16(rows_01.val[1]),
+                                      vreinterpretq_s32_s16(rows_45.val[1]));
+  int32x4x2_t rows_2367_l = vtrnq_s32(vreinterpretq_s32_s16(rows_23.val[0]),
+                                      vreinterpretq_s32_s16(rows_67.val[0]));
+  int32x4x2_t rows_2367_h = vtrnq_s32(vreinterpretq_s32_s16(rows_23.val[1]),
+                                      vreinterpretq_s32_s16(rows_67.val[1]));
+
+  int32x4x2_t cols_04 = vzipq_s32(rows_0145_l.val[0], rows_2367_l.val[0]);
+  int32x4x2_t cols_15 = vzipq_s32(rows_0145_h.val[0], rows_2367_h.val[0]);
+  int32x4x2_t cols_26 = vzipq_s32(rows_0145_l.val[1], rows_2367_l.val[1]);
+  int32x4x2_t cols_37 = vzipq_s32(rows_0145_h.val[1], rows_2367_h.val[1]);
+
+  int16x8_t col0 = vreinterpretq_s16_s32(cols_04.val[0]);
+  int16x8_t col1 = vreinterpretq_s16_s32(cols_15.val[0]);
+  int16x8_t col2 = vreinterpretq_s16_s32(cols_26.val[0]);
+  int16x8_t col3 = vreinterpretq_s16_s32(cols_37.val[0]);
+  int16x8_t col4 = vreinterpretq_s16_s32(cols_04.val[1]);
+  int16x8_t col5 = vreinterpretq_s16_s32(cols_15.val[1]);
+  int16x8_t col6 = vreinterpretq_s16_s32(cols_26.val[1]);
+  int16x8_t col7 = vreinterpretq_s16_s32(cols_37.val[1]);
+
+  /* 1-D IDCT, pass 2 */
+
+  /* Even part */
+  int16x8_t tmp10 = vaddq_s16(col0, col4);
+  int16x8_t tmp11 = vsubq_s16(col0, col4);
+
+  int16x8_t tmp13 = vaddq_s16(col2, col6);
+  int16x8_t col2_sub_col6 = vsubq_s16(col2, col6);
+  int16x8_t tmp12 = vqdmulhq_lane_s16(col2_sub_col6, consts, 1);
+  tmp12 = vaddq_s16(tmp12, col2_sub_col6);
+  tmp12 = vsubq_s16(tmp12, tmp13);
+
+  int16x8_t tmp0 = vaddq_s16(tmp10, tmp13);
+  int16x8_t tmp3 = vsubq_s16(tmp10, tmp13);
+  int16x8_t tmp1 = vaddq_s16(tmp11, tmp12);
+  int16x8_t tmp2 = vsubq_s16(tmp11, tmp12);
+
+  /* Odd part */
+  int16x8_t z13 = vaddq_s16(col5, col3);
+  int16x8_t neg_z10 = vsubq_s16(col3, col5);
+  int16x8_t z11 = vaddq_s16(col1, col7);
+  int16x8_t z12 = vsubq_s16(col1, col7);
+
+  int16x8_t tmp7 = vaddq_s16(z11, z13);      /* phase 5 */
+  int16x8_t z11_sub_z13 = vsubq_s16(z11, z13);
+  tmp11 = vqdmulhq_lane_s16(z11_sub_z13, consts, 1);
+  tmp11 = vaddq_s16(tmp11, z11_sub_z13);
+
+  int16x8_t z10_add_z12 = vsubq_s16(z12, neg_z10);
+  int16x8_t z5 = vqdmulhq_lane_s16(z10_add_z12, consts, 2);
+  z5 = vaddq_s16(z5, z10_add_z12);
+  tmp10 = vqdmulhq_lane_s16(z12, consts, 0);
+  tmp10 = vaddq_s16(tmp10, z12);
+  tmp10 = vsubq_s16(tmp10, z5);
+  tmp12 = vqdmulhq_lane_s16(neg_z10, consts, 3);
+  tmp12 = vaddq_s16(tmp12, vaddq_s16(neg_z10, neg_z10));
+  tmp12 = vaddq_s16(tmp12, z5);
+
+  int16x8_t tmp6 = vsubq_s16(tmp12, tmp7);   /* phase 2 */
+  int16x8_t tmp5 = vsubq_s16(tmp11, tmp6);
+  int16x8_t tmp4 = vaddq_s16(tmp10, tmp5);
+
+  col0 = vaddq_s16(tmp0, tmp7);
+  col7 = vsubq_s16(tmp0, tmp7);
+  col1 = vaddq_s16(tmp1, tmp6);
+  col6 = vsubq_s16(tmp1, tmp6);
+  col2 = vaddq_s16(tmp2, tmp5);
+  col5 = vsubq_s16(tmp2, tmp5);
+  col4 = vaddq_s16(tmp3, tmp4);
+  col3 = vsubq_s16(tmp3, tmp4);
+
+  /* Scale down by a factor of 8, narrowing to 8-bit. */
+  int8x16_t cols_01_s8 = vcombine_s8(vqshrn_n_s16(col0, PASS1_BITS + 3),
+                                     vqshrn_n_s16(col1, PASS1_BITS + 3));
+  int8x16_t cols_45_s8 = vcombine_s8(vqshrn_n_s16(col4, PASS1_BITS + 3),
+                                     vqshrn_n_s16(col5, PASS1_BITS + 3));
+  int8x16_t cols_23_s8 = vcombine_s8(vqshrn_n_s16(col2, PASS1_BITS + 3),
+                                     vqshrn_n_s16(col3, PASS1_BITS + 3));
+  int8x16_t cols_67_s8 = vcombine_s8(vqshrn_n_s16(col6, PASS1_BITS + 3),
+                                     vqshrn_n_s16(col7, PASS1_BITS + 3));
+  /* Clamp to range [0-255]. */
+  uint8x16_t cols_01 =
+    vreinterpretq_u8_s8
+      (vaddq_s8(cols_01_s8, vreinterpretq_s8_u8(vdupq_n_u8(CENTERJSAMPLE))));
+  uint8x16_t cols_45 =
+    vreinterpretq_u8_s8
+      (vaddq_s8(cols_45_s8, vreinterpretq_s8_u8(vdupq_n_u8(CENTERJSAMPLE))));
+  uint8x16_t cols_23 =
+    vreinterpretq_u8_s8
+      (vaddq_s8(cols_23_s8, vreinterpretq_s8_u8(vdupq_n_u8(CENTERJSAMPLE))));
+  uint8x16_t cols_67 =
+    vreinterpretq_u8_s8
+      (vaddq_s8(cols_67_s8, vreinterpretq_s8_u8(vdupq_n_u8(CENTERJSAMPLE))));
+
+  /* Transpose block to prepare for store. */
+  uint32x4x2_t cols_0415 = vzipq_u32(vreinterpretq_u32_u8(cols_01),
+                                     vreinterpretq_u32_u8(cols_45));
+  uint32x4x2_t cols_2637 = vzipq_u32(vreinterpretq_u32_u8(cols_23),
+                                     vreinterpretq_u32_u8(cols_67));
+
+  uint8x16x2_t cols_0145 = vtrnq_u8(vreinterpretq_u8_u32(cols_0415.val[0]),
+                                    vreinterpretq_u8_u32(cols_0415.val[1]));
+  uint8x16x2_t cols_2367 = vtrnq_u8(vreinterpretq_u8_u32(cols_2637.val[0]),
+                                    vreinterpretq_u8_u32(cols_2637.val[1]));
+  uint16x8x2_t rows_0426 = vtrnq_u16(vreinterpretq_u16_u8(cols_0145.val[0]),
+                                     vreinterpretq_u16_u8(cols_2367.val[0]));
+  uint16x8x2_t rows_1537 = vtrnq_u16(vreinterpretq_u16_u8(cols_0145.val[1]),
+                                     vreinterpretq_u16_u8(cols_2367.val[1]));
+
+  uint8x16_t rows_04 = vreinterpretq_u8_u16(rows_0426.val[0]);
+  uint8x16_t rows_15 = vreinterpretq_u8_u16(rows_1537.val[0]);
+  uint8x16_t rows_26 = vreinterpretq_u8_u16(rows_0426.val[1]);
+  uint8x16_t rows_37 = vreinterpretq_u8_u16(rows_1537.val[1]);
+
+  JSAMPROW outptr0 = output_buf[0] + output_col;
+  JSAMPROW outptr1 = output_buf[1] + output_col;
+  JSAMPROW outptr2 = output_buf[2] + output_col;
+  JSAMPROW outptr3 = output_buf[3] + output_col;
+  JSAMPROW outptr4 = output_buf[4] + output_col;
+  JSAMPROW outptr5 = output_buf[5] + output_col;
+  JSAMPROW outptr6 = output_buf[6] + output_col;
+  JSAMPROW outptr7 = output_buf[7] + output_col;
+
+  /* Store DCT block to memory. */
+  vst1q_lane_u64((uint64_t *)outptr0, vreinterpretq_u64_u8(rows_04), 0);
+  vst1q_lane_u64((uint64_t *)outptr1, vreinterpretq_u64_u8(rows_15), 0);
+  vst1q_lane_u64((uint64_t *)outptr2, vreinterpretq_u64_u8(rows_26), 0);
+  vst1q_lane_u64((uint64_t *)outptr3, vreinterpretq_u64_u8(rows_37), 0);
+  vst1q_lane_u64((uint64_t *)outptr4, vreinterpretq_u64_u8(rows_04), 1);
+  vst1q_lane_u64((uint64_t *)outptr5, vreinterpretq_u64_u8(rows_15), 1);
+  vst1q_lane_u64((uint64_t *)outptr6, vreinterpretq_u64_u8(rows_26), 1);
+  vst1q_lane_u64((uint64_t *)outptr7, vreinterpretq_u64_u8(rows_37), 1);
+}
diff --git a/3rdparty/libjpeg/src/simd/arm/jidctint-neon.c b/3rdparty/libjpeg/src/simd/arm/jidctint-neon.c
new file mode 100644
index 00000000..043b652e
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/arm/jidctint-neon.c
@@ -0,0 +1,802 @@
+/*
+ * jidctint-neon.c - accurate integer IDCT (Arm Neon)
+ *
+ * Copyright (C) 2020, Arm Limited.  All Rights Reserved.
+ * Copyright (C) 2020, D. R. Commander.  All Rights Reserved.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+#define JPEG_INTERNALS
+#include "jconfigint.h"
+#include "../../jinclude.h"
+#include "../../jpeglib.h"
+#include "../../jsimd.h"
+#include "../../jdct.h"
+#include "../../jsimddct.h"
+#include "../jsimd.h"
+#include "align.h"
+#include "neon-compat.h"
+
+#include <arm_neon.h>
+
+
+#define CONST_BITS  13
+#define PASS1_BITS  2
+
+#define DESCALE_P1  (CONST_BITS - PASS1_BITS)
+#define DESCALE_P2  (CONST_BITS + PASS1_BITS + 3)
+
+/* The computation of the inverse DCT requires the use of constants known at
+ * compile time.  Scaled integer constants are used to avoid floating-point
+ * arithmetic:
+ *    0.298631336 =  2446 * 2^-13
+ *    0.390180644 =  3196 * 2^-13
+ *    0.541196100 =  4433 * 2^-13
+ *    0.765366865 =  6270 * 2^-13
+ *    0.899976223 =  7373 * 2^-13
+ *    1.175875602 =  9633 * 2^-13
+ *    1.501321110 = 12299 * 2^-13
+ *    1.847759065 = 15137 * 2^-13
+ *    1.961570560 = 16069 * 2^-13
+ *    2.053119869 = 16819 * 2^-13
+ *    2.562915447 = 20995 * 2^-13
+ *    3.072711026 = 25172 * 2^-13
+ */
+
+#define F_0_298  2446
+#define F_0_390  3196
+#define F_0_541  4433
+#define F_0_765  6270
+#define F_0_899  7373
+#define F_1_175  9633
+#define F_1_501  12299
+#define F_1_847  15137
+#define F_1_961  16069
+#define F_2_053  16819
+#define F_2_562  20995
+#define F_3_072  25172
+
+#define F_1_175_MINUS_1_961  (F_1_175 - F_1_961)
+#define F_1_175_MINUS_0_390  (F_1_175 - F_0_390)
+#define F_0_541_MINUS_1_847  (F_0_541 - F_1_847)
+#define F_3_072_MINUS_2_562  (F_3_072 - F_2_562)
+#define F_0_298_MINUS_0_899  (F_0_298 - F_0_899)
+#define F_1_501_MINUS_0_899  (F_1_501 - F_0_899)
+#define F_2_053_MINUS_2_562  (F_2_053 - F_2_562)
+#define F_0_541_PLUS_0_765   (F_0_541 + F_0_765)
+
+
+ALIGN(16) static const int16_t jsimd_idct_islow_neon_consts[] = {
+  F_0_899,             F_0_541,
+  F_2_562,             F_0_298_MINUS_0_899,
+  F_1_501_MINUS_0_899, F_2_053_MINUS_2_562,
+  F_0_541_PLUS_0_765,  F_1_175,
+  F_1_175_MINUS_0_390, F_0_541_MINUS_1_847,
+  F_3_072_MINUS_2_562, F_1_175_MINUS_1_961,
+  0, 0, 0, 0
+};
+
+
+/* Forward declaration of regular and sparse IDCT helper functions */
+
+static INLINE void jsimd_idct_islow_pass1_regular(int16x4_t row0,
+                                                  int16x4_t row1,
+                                                  int16x4_t row2,
+                                                  int16x4_t row3,
+                                                  int16x4_t row4,
+                                                  int16x4_t row5,
+                                                  int16x4_t row6,
+                                                  int16x4_t row7,
+                                                  int16x4_t quant_row0,
+                                                  int16x4_t quant_row1,
+                                                  int16x4_t quant_row2,
+                                                  int16x4_t quant_row3,
+                                                  int16x4_t quant_row4,
+                                                  int16x4_t quant_row5,
+                                                  int16x4_t quant_row6,
+                                                  int16x4_t quant_row7,
+                                                  int16_t *workspace_1,
+                                                  int16_t *workspace_2);
+
+static INLINE void jsimd_idct_islow_pass1_sparse(int16x4_t row0,
+                                                 int16x4_t row1,
+                                                 int16x4_t row2,
+                                                 int16x4_t row3,
+                                                 int16x4_t quant_row0,
+                                                 int16x4_t quant_row1,
+                                                 int16x4_t quant_row2,
+                                                 int16x4_t quant_row3,
+                                                 int16_t *workspace_1,
+                                                 int16_t *workspace_2);
+
+static INLINE void jsimd_idct_islow_pass2_regular(int16_t *workspace,
+                                                  JSAMPARRAY output_buf,
+                                                  JDIMENSION output_col,
+                                                  unsigned buf_offset);
+
+static INLINE void jsimd_idct_islow_pass2_sparse(int16_t *workspace,
+                                                 JSAMPARRAY output_buf,
+                                                 JDIMENSION output_col,
+                                                 unsigned buf_offset);
+
+
+/* Perform dequantization and inverse DCT on one block of coefficients.  For
+ * reference, the C implementation (jpeg_idct_slow()) can be found in
+ * jidctint.c.
+ *
+ * Optimization techniques used for fast data access:
+ *
+ * In each pass, the inverse DCT is computed for the left and right 4x8 halves
+ * of the DCT block.  This avoids spilling due to register pressure, and the
+ * increased granularity allows for an optimized calculation depending on the
+ * values of the DCT coefficients.  Between passes, intermediate data is stored
+ * in 4x8 workspace buffers.
+ *
+ * Transposing the 8x8 DCT block after each pass can be achieved by transposing
+ * each of the four 4x4 quadrants and swapping quadrants 1 and 2 (refer to the
+ * diagram below.)  Swapping quadrants is cheap, since the second pass can just
+ * swap the workspace buffer pointers.
+ *
+ *      +-------+-------+                   +-------+-------+
+ *      |       |       |                   |       |       |
+ *      |   0   |   1   |                   |   0   |   2   |
+ *      |       |       |    transpose      |       |       |
+ *      +-------+-------+     ------>       +-------+-------+
+ *      |       |       |                   |       |       |
+ *      |   2   |   3   |                   |   1   |   3   |
+ *      |       |       |                   |       |       |
+ *      +-------+-------+                   +-------+-------+
+ *
+ * Optimization techniques used to accelerate the inverse DCT calculation:
+ *
+ * In a DCT coefficient block, the coefficients are increasingly likely to be 0
+ * as you move diagonally from top left to bottom right.  If whole rows of
+ * coefficients are 0, then the inverse DCT calculation can be simplified.  On
+ * the first pass of the inverse DCT, we test for three special cases before
+ * defaulting to a full "regular" inverse DCT:
+ *
+ * 1) Coefficients in rows 4-7 are all zero.  In this case, we perform a
+ *    "sparse" simplified inverse DCT on rows 0-3.
+ * 2) AC coefficients (rows 1-7) are all zero.  In this case, the inverse DCT
+ *    result is equal to the dequantized DC coefficients.
+ * 3) AC and DC coefficients are all zero.  In this case, the inverse DCT
+ *    result is all zero.  For the left 4x8 half, this is handled identically
+ *    to Case 2 above.  For the right 4x8 half, we do no work and signal that
+ *    the "sparse" algorithm is required for the second pass.
+ *
+ * In the second pass, only a single special case is tested: whether the AC and
+ * DC coefficients were all zero in the right 4x8 block during the first pass
+ * (refer to Case 3 above.)  If this is the case, then a "sparse" variant of
+ * the second pass is performed for both the left and right halves of the DCT
+ * block.  (The transposition after the first pass means that the right 4x8
+ * block during the first pass becomes rows 4-7 during the second pass.)
+ */
+
+void jsimd_idct_islow_neon(void *dct_table, JCOEFPTR coef_block,
+                           JSAMPARRAY output_buf, JDIMENSION output_col)
+{
+  ISLOW_MULT_TYPE *quantptr = dct_table;
+
+  int16_t workspace_l[8 * DCTSIZE / 2];
+  int16_t workspace_r[8 * DCTSIZE / 2];
+
+  /* Compute IDCT first pass on left 4x8 coefficient block. */
+
+  /* Load DCT coefficients in left 4x8 block. */
+  int16x4_t row0 = vld1_s16(coef_block + 0 * DCTSIZE);
+  int16x4_t row1 = vld1_s16(coef_block + 1 * DCTSIZE);
+  int16x4_t row2 = vld1_s16(coef_block + 2 * DCTSIZE);
+  int16x4_t row3 = vld1_s16(coef_block + 3 * DCTSIZE);
+  int16x4_t row4 = vld1_s16(coef_block + 4 * DCTSIZE);
+  int16x4_t row5 = vld1_s16(coef_block + 5 * DCTSIZE);
+  int16x4_t row6 = vld1_s16(coef_block + 6 * DCTSIZE);
+  int16x4_t row7 = vld1_s16(coef_block + 7 * DCTSIZE);
+
+  /* Load quantization table for left 4x8 block. */
+  int16x4_t quant_row0 = vld1_s16(quantptr + 0 * DCTSIZE);
+  int16x4_t quant_row1 = vld1_s16(quantptr + 1 * DCTSIZE);
+  int16x4_t quant_row2 = vld1_s16(quantptr + 2 * DCTSIZE);
+  int16x4_t quant_row3 = vld1_s16(quantptr + 3 * DCTSIZE);
+  int16x4_t quant_row4 = vld1_s16(quantptr + 4 * DCTSIZE);
+  int16x4_t quant_row5 = vld1_s16(quantptr + 5 * DCTSIZE);
+  int16x4_t quant_row6 = vld1_s16(quantptr + 6 * DCTSIZE);
+  int16x4_t quant_row7 = vld1_s16(quantptr + 7 * DCTSIZE);
+
+  /* Construct bitmap to test if DCT coefficients in left 4x8 block are 0. */
+  int16x4_t bitmap = vorr_s16(row7, row6);
+  bitmap = vorr_s16(bitmap, row5);
+  bitmap = vorr_s16(bitmap, row4);
+  int64_t bitmap_rows_4567 = vget_lane_s64(vreinterpret_s64_s16(bitmap), 0);
+
+  if (bitmap_rows_4567 == 0) {
+    bitmap = vorr_s16(bitmap, row3);
+    bitmap = vorr_s16(bitmap, row2);
+    bitmap = vorr_s16(bitmap, row1);
+    int64_t left_ac_bitmap = vget_lane_s64(vreinterpret_s64_s16(bitmap), 0);
+
+    if (left_ac_bitmap == 0) {
+      int16x4_t dcval = vshl_n_s16(vmul_s16(row0, quant_row0), PASS1_BITS);
+      int16x4x4_t quadrant = { { dcval, dcval, dcval, dcval } };
+      /* Store 4x4 blocks to workspace, transposing in the process. */
+      vst4_s16(workspace_l, quadrant);
+      vst4_s16(workspace_r, quadrant);
+    } else {
+      jsimd_idct_islow_pass1_sparse(row0, row1, row2, row3, quant_row0,
+                                    quant_row1, quant_row2, quant_row3,
+                                    workspace_l, workspace_r);
+    }
+  } else {
+    jsimd_idct_islow_pass1_regular(row0, row1, row2, row3, row4, row5,
+                                   row6, row7, quant_row0, quant_row1,
+                                   quant_row2, quant_row3, quant_row4,
+                                   quant_row5, quant_row6, quant_row7,
+                                   workspace_l, workspace_r);
+  }
+
+  /* Compute IDCT first pass on right 4x8 coefficient block. */
+
+  /* Load DCT coefficients in right 4x8 block. */
+  row0 = vld1_s16(coef_block + 0 * DCTSIZE + 4);
+  row1 = vld1_s16(coef_block + 1 * DCTSIZE + 4);
+  row2 = vld1_s16(coef_block + 2 * DCTSIZE + 4);
+  row3 = vld1_s16(coef_block + 3 * DCTSIZE + 4);
+  row4 = vld1_s16(coef_block + 4 * DCTSIZE + 4);
+  row5 = vld1_s16(coef_block + 5 * DCTSIZE + 4);
+  row6 = vld1_s16(coef_block + 6 * DCTSIZE + 4);
+  row7 = vld1_s16(coef_block + 7 * DCTSIZE + 4);
+
+  /* Load quantization table for right 4x8 block. */
+  quant_row0 = vld1_s16(quantptr + 0 * DCTSIZE + 4);
+  quant_row1 = vld1_s16(quantptr + 1 * DCTSIZE + 4);
+  quant_row2 = vld1_s16(quantptr + 2 * DCTSIZE + 4);
+  quant_row3 = vld1_s16(quantptr + 3 * DCTSIZE + 4);
+  quant_row4 = vld1_s16(quantptr + 4 * DCTSIZE + 4);
+  quant_row5 = vld1_s16(quantptr + 5 * DCTSIZE + 4);
+  quant_row6 = vld1_s16(quantptr + 6 * DCTSIZE + 4);
+  quant_row7 = vld1_s16(quantptr + 7 * DCTSIZE + 4);
+
+  /* Construct bitmap to test if DCT coefficients in right 4x8 block are 0. */
+  bitmap = vorr_s16(row7, row6);
+  bitmap = vorr_s16(bitmap, row5);
+  bitmap = vorr_s16(bitmap, row4);
+  bitmap_rows_4567 = vget_lane_s64(vreinterpret_s64_s16(bitmap), 0);
+  bitmap = vorr_s16(bitmap, row3);
+  bitmap = vorr_s16(bitmap, row2);
+  bitmap = vorr_s16(bitmap, row1);
+  int64_t right_ac_bitmap = vget_lane_s64(vreinterpret_s64_s16(bitmap), 0);
+
+  /* If this remains non-zero, a "regular" second pass will be performed. */
+  int64_t right_ac_dc_bitmap = 1;
+
+  if (right_ac_bitmap == 0) {
+    bitmap = vorr_s16(bitmap, row0);
+    right_ac_dc_bitmap = vget_lane_s64(vreinterpret_s64_s16(bitmap), 0);
+
+    if (right_ac_dc_bitmap != 0) {
+      int16x4_t dcval = vshl_n_s16(vmul_s16(row0, quant_row0), PASS1_BITS);
+      int16x4x4_t quadrant = { { dcval, dcval, dcval, dcval } };
+      /* Store 4x4 blocks to workspace, transposing in the process. */
+      vst4_s16(workspace_l + 4 * DCTSIZE / 2, quadrant);
+      vst4_s16(workspace_r + 4 * DCTSIZE / 2, quadrant);
+    }
+  } else {
+    if (bitmap_rows_4567 == 0) {
+      jsimd_idct_islow_pass1_sparse(row0, row1, row2, row3, quant_row0,
+                                    quant_row1, quant_row2, quant_row3,
+                                    workspace_l + 4 * DCTSIZE / 2,
+                                    workspace_r + 4 * DCTSIZE / 2);
+    } else {
+      jsimd_idct_islow_pass1_regular(row0, row1, row2, row3, row4, row5,
+                                     row6, row7, quant_row0, quant_row1,
+                                     quant_row2, quant_row3, quant_row4,
+                                     quant_row5, quant_row6, quant_row7,
+                                     workspace_l + 4 * DCTSIZE / 2,
+                                     workspace_r + 4 * DCTSIZE / 2);
+    }
+  }
+
+  /* Second pass: compute IDCT on rows in workspace. */
+
+  /* If all coefficients in right 4x8 block are 0, use "sparse" second pass. */
+  if (right_ac_dc_bitmap == 0) {
+    jsimd_idct_islow_pass2_sparse(workspace_l, output_buf, output_col, 0);
+    jsimd_idct_islow_pass2_sparse(workspace_r, output_buf, output_col, 4);
+  } else {
+    jsimd_idct_islow_pass2_regular(workspace_l, output_buf, output_col, 0);
+    jsimd_idct_islow_pass2_regular(workspace_r, output_buf, output_col, 4);
+  }
+}
+
+
+/* Perform dequantization and the first pass of the accurate inverse DCT on a
+ * 4x8 block of coefficients.  (To process the full 8x8 DCT block, this
+ * function-- or some other optimized variant-- needs to be called for both the
+ * left and right 4x8 blocks.)
+ *
+ * This "regular" version assumes that no optimization can be made to the IDCT
+ * calculation, since no useful set of AC coefficients is all 0.
+ *
+ * The original C implementation of the accurate IDCT (jpeg_idct_slow()) can be
+ * found in jidctint.c.  Algorithmic changes made here are documented inline.
+ */
+
+static INLINE void jsimd_idct_islow_pass1_regular(int16x4_t row0,
+                                                  int16x4_t row1,
+                                                  int16x4_t row2,
+                                                  int16x4_t row3,
+                                                  int16x4_t row4,
+                                                  int16x4_t row5,
+                                                  int16x4_t row6,
+                                                  int16x4_t row7,
+                                                  int16x4_t quant_row0,
+                                                  int16x4_t quant_row1,
+                                                  int16x4_t quant_row2,
+                                                  int16x4_t quant_row3,
+                                                  int16x4_t quant_row4,
+                                                  int16x4_t quant_row5,
+                                                  int16x4_t quant_row6,
+                                                  int16x4_t quant_row7,
+                                                  int16_t *workspace_1,
+                                                  int16_t *workspace_2)
+{
+  /* Load constants for IDCT computation. */
+#ifdef HAVE_VLD1_S16_X3
+  const int16x4x3_t consts = vld1_s16_x3(jsimd_idct_islow_neon_consts);
+#else
+  const int16x4_t consts1 = vld1_s16(jsimd_idct_islow_neon_consts);
+  const int16x4_t consts2 = vld1_s16(jsimd_idct_islow_neon_consts + 4);
+  const int16x4_t consts3 = vld1_s16(jsimd_idct_islow_neon_consts + 8);
+  const int16x4x3_t consts = { { consts1, consts2, consts3 } };
+#endif
+
+  /* Even part */
+  int16x4_t z2_s16 = vmul_s16(row2, quant_row2);
+  int16x4_t z3_s16 = vmul_s16(row6, quant_row6);
+
+  int32x4_t tmp2 = vmull_lane_s16(z2_s16, consts.val[0], 1);
+  int32x4_t tmp3 = vmull_lane_s16(z2_s16, consts.val[1], 2);
+  tmp2 = vmlal_lane_s16(tmp2, z3_s16, consts.val[2], 1);
+  tmp3 = vmlal_lane_s16(tmp3, z3_s16, consts.val[0], 1);
+
+  z2_s16 = vmul_s16(row0, quant_row0);
+  z3_s16 = vmul_s16(row4, quant_row4);
+
+  int32x4_t tmp0 = vshll_n_s16(vadd_s16(z2_s16, z3_s16), CONST_BITS);
+  int32x4_t tmp1 = vshll_n_s16(vsub_s16(z2_s16, z3_s16), CONST_BITS);
+
+  int32x4_t tmp10 = vaddq_s32(tmp0, tmp3);
+  int32x4_t tmp13 = vsubq_s32(tmp0, tmp3);
+  int32x4_t tmp11 = vaddq_s32(tmp1, tmp2);
+  int32x4_t tmp12 = vsubq_s32(tmp1, tmp2);
+
+  /* Odd part */
+  int16x4_t tmp0_s16 = vmul_s16(row7, quant_row7);
+  int16x4_t tmp1_s16 = vmul_s16(row5, quant_row5);
+  int16x4_t tmp2_s16 = vmul_s16(row3, quant_row3);
+  int16x4_t tmp3_s16 = vmul_s16(row1, quant_row1);
+
+  z3_s16 = vadd_s16(tmp0_s16, tmp2_s16);
+  int16x4_t z4_s16 = vadd_s16(tmp1_s16, tmp3_s16);
+
+  /* Implementation as per jpeg_idct_islow() in jidctint.c:
+   *   z5 = (z3 + z4) * 1.175875602;
+   *   z3 = z3 * -1.961570560;  z4 = z4 * -0.390180644;
+   *   z3 += z5;  z4 += z5;
+   *
+   * This implementation:
+   *   z3 = z3 * (1.175875602 - 1.961570560) + z4 * 1.175875602;
+   *   z4 = z3 * 1.175875602 + z4 * (1.175875602 - 0.390180644);
+   */
+
+  int32x4_t z3 = vmull_lane_s16(z3_s16, consts.val[2], 3);
+  int32x4_t z4 = vmull_lane_s16(z3_s16, consts.val[1], 3);
+  z3 = vmlal_lane_s16(z3, z4_s16, consts.val[1], 3);
+  z4 = vmlal_lane_s16(z4, z4_s16, consts.val[2], 0);
+
+  /* Implementation as per jpeg_idct_islow() in jidctint.c:
+   *   z1 = tmp0 + tmp3;  z2 = tmp1 + tmp2;
+   *   tmp0 = tmp0 * 0.298631336;  tmp1 = tmp1 * 2.053119869;
+   *   tmp2 = tmp2 * 3.072711026;  tmp3 = tmp3 * 1.501321110;
+   *   z1 = z1 * -0.899976223;  z2 = z2 * -2.562915447;
+   *   tmp0 += z1 + z3;  tmp1 += z2 + z4;
+   *   tmp2 += z2 + z3;  tmp3 += z1 + z4;
+   *
+   * This implementation:
+   *   tmp0 = tmp0 * (0.298631336 - 0.899976223) + tmp3 * -0.899976223;
+   *   tmp1 = tmp1 * (2.053119869 - 2.562915447) + tmp2 * -2.562915447;
+   *   tmp2 = tmp1 * -2.562915447 + tmp2 * (3.072711026 - 2.562915447);
+   *   tmp3 = tmp0 * -0.899976223 + tmp3 * (1.501321110 - 0.899976223);
+   *   tmp0 += z3;  tmp1 += z4;
+   *   tmp2 += z3;  tmp3 += z4;
+   */
+
+  tmp0 = vmull_lane_s16(tmp0_s16, consts.val[0], 3);
+  tmp1 = vmull_lane_s16(tmp1_s16, consts.val[1], 1);
+  tmp2 = vmull_lane_s16(tmp2_s16, consts.val[2], 2);
+  tmp3 = vmull_lane_s16(tmp3_s16, consts.val[1], 0);
+
+  tmp0 = vmlsl_lane_s16(tmp0, tmp3_s16, consts.val[0], 0);
+  tmp1 = vmlsl_lane_s16(tmp1, tmp2_s16, consts.val[0], 2);
+  tmp2 = vmlsl_lane_s16(tmp2, tmp1_s16, consts.val[0], 2);
+  tmp3 = vmlsl_lane_s16(tmp3, tmp0_s16, consts.val[0], 0);
+
+  tmp0 = vaddq_s32(tmp0, z3);
+  tmp1 = vaddq_s32(tmp1, z4);
+  tmp2 = vaddq_s32(tmp2, z3);
+  tmp3 = vaddq_s32(tmp3, z4);
+
+  /* Final output stage: descale and narrow to 16-bit. */
+  int16x4x4_t rows_0123 = { {
+    vrshrn_n_s32(vaddq_s32(tmp10, tmp3), DESCALE_P1),
+    vrshrn_n_s32(vaddq_s32(tmp11, tmp2), DESCALE_P1),
+    vrshrn_n_s32(vaddq_s32(tmp12, tmp1), DESCALE_P1),
+    vrshrn_n_s32(vaddq_s32(tmp13, tmp0), DESCALE_P1)
+  } };
+  int16x4x4_t rows_4567 = { {
+    vrshrn_n_s32(vsubq_s32(tmp13, tmp0), DESCALE_P1),
+    vrshrn_n_s32(vsubq_s32(tmp12, tmp1), DESCALE_P1),
+    vrshrn_n_s32(vsubq_s32(tmp11, tmp2), DESCALE_P1),
+    vrshrn_n_s32(vsubq_s32(tmp10, tmp3), DESCALE_P1)
+  } };
+
+  /* Store 4x4 blocks to the intermediate workspace, ready for the second pass.
+   * (VST4 transposes the blocks.  We need to operate on rows in the next
+   * pass.)
+   */
+  vst4_s16(workspace_1, rows_0123);
+  vst4_s16(workspace_2, rows_4567);
+}
+
+
+/* Perform dequantization and the first pass of the accurate inverse DCT on a
+ * 4x8 block of coefficients.
+ *
+ * This "sparse" version assumes that the AC coefficients in rows 4-7 are all
+ * 0.  This simplifies the IDCT calculation, accelerating overall performance.
+ */
+
+static INLINE void jsimd_idct_islow_pass1_sparse(int16x4_t row0,
+                                                 int16x4_t row1,
+                                                 int16x4_t row2,
+                                                 int16x4_t row3,
+                                                 int16x4_t quant_row0,
+                                                 int16x4_t quant_row1,
+                                                 int16x4_t quant_row2,
+                                                 int16x4_t quant_row3,
+                                                 int16_t *workspace_1,
+                                                 int16_t *workspace_2)
+{
+  /* Load constants for IDCT computation. */
+#ifdef HAVE_VLD1_S16_X3
+  const int16x4x3_t consts = vld1_s16_x3(jsimd_idct_islow_neon_consts);
+#else
+  const int16x4_t consts1 = vld1_s16(jsimd_idct_islow_neon_consts);
+  const int16x4_t consts2 = vld1_s16(jsimd_idct_islow_neon_consts + 4);
+  const int16x4_t consts3 = vld1_s16(jsimd_idct_islow_neon_consts + 8);
+  const int16x4x3_t consts = { { consts1, consts2, consts3 } };
+#endif
+
+  /* Even part (z3 is all 0) */
+  int16x4_t z2_s16 = vmul_s16(row2, quant_row2);
+
+  int32x4_t tmp2 = vmull_lane_s16(z2_s16, consts.val[0], 1);
+  int32x4_t tmp3 = vmull_lane_s16(z2_s16, consts.val[1], 2);
+
+  z2_s16 = vmul_s16(row0, quant_row0);
+  int32x4_t tmp0 = vshll_n_s16(z2_s16, CONST_BITS);
+  int32x4_t tmp1 = vshll_n_s16(z2_s16, CONST_BITS);
+
+  int32x4_t tmp10 = vaddq_s32(tmp0, tmp3);
+  int32x4_t tmp13 = vsubq_s32(tmp0, tmp3);
+  int32x4_t tmp11 = vaddq_s32(tmp1, tmp2);
+  int32x4_t tmp12 = vsubq_s32(tmp1, tmp2);
+
+  /* Odd part (tmp0 and tmp1 are both all 0) */
+  int16x4_t tmp2_s16 = vmul_s16(row3, quant_row3);
+  int16x4_t tmp3_s16 = vmul_s16(row1, quant_row1);
+
+  int16x4_t z3_s16 = tmp2_s16;
+  int16x4_t z4_s16 = tmp3_s16;
+
+  int32x4_t z3 = vmull_lane_s16(z3_s16, consts.val[2], 3);
+  int32x4_t z4 = vmull_lane_s16(z3_s16, consts.val[1], 3);
+  z3 = vmlal_lane_s16(z3, z4_s16, consts.val[1], 3);
+  z4 = vmlal_lane_s16(z4, z4_s16, consts.val[2], 0);
+
+  tmp0 = vmlsl_lane_s16(z3, tmp3_s16, consts.val[0], 0);
+  tmp1 = vmlsl_lane_s16(z4, tmp2_s16, consts.val[0], 2);
+  tmp2 = vmlal_lane_s16(z3, tmp2_s16, consts.val[2], 2);
+  tmp3 = vmlal_lane_s16(z4, tmp3_s16, consts.val[1], 0);
+
+  /* Final output stage: descale and narrow to 16-bit. */
+  int16x4x4_t rows_0123 = { {
+    vrshrn_n_s32(vaddq_s32(tmp10, tmp3), DESCALE_P1),
+    vrshrn_n_s32(vaddq_s32(tmp11, tmp2), DESCALE_P1),
+    vrshrn_n_s32(vaddq_s32(tmp12, tmp1), DESCALE_P1),
+    vrshrn_n_s32(vaddq_s32(tmp13, tmp0), DESCALE_P1)
+  } };
+  int16x4x4_t rows_4567 = { {
+    vrshrn_n_s32(vsubq_s32(tmp13, tmp0), DESCALE_P1),
+    vrshrn_n_s32(vsubq_s32(tmp12, tmp1), DESCALE_P1),
+    vrshrn_n_s32(vsubq_s32(tmp11, tmp2), DESCALE_P1),
+    vrshrn_n_s32(vsubq_s32(tmp10, tmp3), DESCALE_P1)
+  } };
+
+  /* Store 4x4 blocks to the intermediate workspace, ready for the second pass.
+   * (VST4 transposes the blocks.  We need to operate on rows in the next
+   * pass.)
+   */
+  vst4_s16(workspace_1, rows_0123);
+  vst4_s16(workspace_2, rows_4567);
+}
+
+
+/* Perform the second pass of the accurate inverse DCT on a 4x8 block of
+ * coefficients.  (To process the full 8x8 DCT block, this function-- or some
+ * other optimized variant-- needs to be called for both the right and left 4x8
+ * blocks.)
+ *
+ * This "regular" version assumes that no optimization can be made to the IDCT
+ * calculation, since no useful set of coefficient values are all 0 after the
+ * first pass.
+ *
+ * Again, the original C implementation of the accurate IDCT (jpeg_idct_slow())
+ * can be found in jidctint.c.  Algorithmic changes made here are documented
+ * inline.
+ */
+
+static INLINE void jsimd_idct_islow_pass2_regular(int16_t *workspace,
+                                                  JSAMPARRAY output_buf,
+                                                  JDIMENSION output_col,
+                                                  unsigned buf_offset)
+{
+  /* Load constants for IDCT computation. */
+#ifdef HAVE_VLD1_S16_X3
+  const int16x4x3_t consts = vld1_s16_x3(jsimd_idct_islow_neon_consts);
+#else
+  const int16x4_t consts1 = vld1_s16(jsimd_idct_islow_neon_consts);
+  const int16x4_t consts2 = vld1_s16(jsimd_idct_islow_neon_consts + 4);
+  const int16x4_t consts3 = vld1_s16(jsimd_idct_islow_neon_consts + 8);
+  const int16x4x3_t consts = { { consts1, consts2, consts3 } };
+#endif
+
+  /* Even part */
+  int16x4_t z2_s16 = vld1_s16(workspace + 2 * DCTSIZE / 2);
+  int16x4_t z3_s16 = vld1_s16(workspace + 6 * DCTSIZE / 2);
+
+  int32x4_t tmp2 = vmull_lane_s16(z2_s16, consts.val[0], 1);
+  int32x4_t tmp3 = vmull_lane_s16(z2_s16, consts.val[1], 2);
+  tmp2 = vmlal_lane_s16(tmp2, z3_s16, consts.val[2], 1);
+  tmp3 = vmlal_lane_s16(tmp3, z3_s16, consts.val[0], 1);
+
+  z2_s16 = vld1_s16(workspace + 0 * DCTSIZE / 2);
+  z3_s16 = vld1_s16(workspace + 4 * DCTSIZE / 2);
+
+  int32x4_t tmp0 = vshll_n_s16(vadd_s16(z2_s16, z3_s16), CONST_BITS);
+  int32x4_t tmp1 = vshll_n_s16(vsub_s16(z2_s16, z3_s16), CONST_BITS);
+
+  int32x4_t tmp10 = vaddq_s32(tmp0, tmp3);
+  int32x4_t tmp13 = vsubq_s32(tmp0, tmp3);
+  int32x4_t tmp11 = vaddq_s32(tmp1, tmp2);
+  int32x4_t tmp12 = vsubq_s32(tmp1, tmp2);
+
+  /* Odd part */
+  int16x4_t tmp0_s16 = vld1_s16(workspace + 7 * DCTSIZE / 2);
+  int16x4_t tmp1_s16 = vld1_s16(workspace + 5 * DCTSIZE / 2);
+  int16x4_t tmp2_s16 = vld1_s16(workspace + 3 * DCTSIZE / 2);
+  int16x4_t tmp3_s16 = vld1_s16(workspace + 1 * DCTSIZE / 2);
+
+  z3_s16 = vadd_s16(tmp0_s16, tmp2_s16);
+  int16x4_t z4_s16 = vadd_s16(tmp1_s16, tmp3_s16);
+
+  /* Implementation as per jpeg_idct_islow() in jidctint.c:
+   *   z5 = (z3 + z4) * 1.175875602;
+   *   z3 = z3 * -1.961570560;  z4 = z4 * -0.390180644;
+   *   z3 += z5;  z4 += z5;
+   *
+   * This implementation:
+   *   z3 = z3 * (1.175875602 - 1.961570560) + z4 * 1.175875602;
+   *   z4 = z3 * 1.175875602 + z4 * (1.175875602 - 0.390180644);
+   */
+
+  int32x4_t z3 = vmull_lane_s16(z3_s16, consts.val[2], 3);
+  int32x4_t z4 = vmull_lane_s16(z3_s16, consts.val[1], 3);
+  z3 = vmlal_lane_s16(z3, z4_s16, consts.val[1], 3);
+  z4 = vmlal_lane_s16(z4, z4_s16, consts.val[2], 0);
+
+  /* Implementation as per jpeg_idct_islow() in jidctint.c:
+   *   z1 = tmp0 + tmp3;  z2 = tmp1 + tmp2;
+   *   tmp0 = tmp0 * 0.298631336;  tmp1 = tmp1 * 2.053119869;
+   *   tmp2 = tmp2 * 3.072711026;  tmp3 = tmp3 * 1.501321110;
+   *   z1 = z1 * -0.899976223;  z2 = z2 * -2.562915447;
+   *   tmp0 += z1 + z3;  tmp1 += z2 + z4;
+   *   tmp2 += z2 + z3;  tmp3 += z1 + z4;
+   *
+   * This implementation:
+   *   tmp0 = tmp0 * (0.298631336 - 0.899976223) + tmp3 * -0.899976223;
+   *   tmp1 = tmp1 * (2.053119869 - 2.562915447) + tmp2 * -2.562915447;
+   *   tmp2 = tmp1 * -2.562915447 + tmp2 * (3.072711026 - 2.562915447);
+   *   tmp3 = tmp0 * -0.899976223 + tmp3 * (1.501321110 - 0.899976223);
+   *   tmp0 += z3;  tmp1 += z4;
+   *   tmp2 += z3;  tmp3 += z4;
+   */
+
+  tmp0 = vmull_lane_s16(tmp0_s16, consts.val[0], 3);
+  tmp1 = vmull_lane_s16(tmp1_s16, consts.val[1], 1);
+  tmp2 = vmull_lane_s16(tmp2_s16, consts.val[2], 2);
+  tmp3 = vmull_lane_s16(tmp3_s16, consts.val[1], 0);
+
+  tmp0 = vmlsl_lane_s16(tmp0, tmp3_s16, consts.val[0], 0);
+  tmp1 = vmlsl_lane_s16(tmp1, tmp2_s16, consts.val[0], 2);
+  tmp2 = vmlsl_lane_s16(tmp2, tmp1_s16, consts.val[0], 2);
+  tmp3 = vmlsl_lane_s16(tmp3, tmp0_s16, consts.val[0], 0);
+
+  tmp0 = vaddq_s32(tmp0, z3);
+  tmp1 = vaddq_s32(tmp1, z4);
+  tmp2 = vaddq_s32(tmp2, z3);
+  tmp3 = vaddq_s32(tmp3, z4);
+
+  /* Final output stage: descale and narrow to 16-bit. */
+  int16x8_t cols_02_s16 = vcombine_s16(vaddhn_s32(tmp10, tmp3),
+                                       vaddhn_s32(tmp12, tmp1));
+  int16x8_t cols_13_s16 = vcombine_s16(vaddhn_s32(tmp11, tmp2),
+                                       vaddhn_s32(tmp13, tmp0));
+  int16x8_t cols_46_s16 = vcombine_s16(vsubhn_s32(tmp13, tmp0),
+                                       vsubhn_s32(tmp11, tmp2));
+  int16x8_t cols_57_s16 = vcombine_s16(vsubhn_s32(tmp12, tmp1),
+                                       vsubhn_s32(tmp10, tmp3));
+  /* Descale and narrow to 8-bit. */
+  int8x8_t cols_02_s8 = vqrshrn_n_s16(cols_02_s16, DESCALE_P2 - 16);
+  int8x8_t cols_13_s8 = vqrshrn_n_s16(cols_13_s16, DESCALE_P2 - 16);
+  int8x8_t cols_46_s8 = vqrshrn_n_s16(cols_46_s16, DESCALE_P2 - 16);
+  int8x8_t cols_57_s8 = vqrshrn_n_s16(cols_57_s16, DESCALE_P2 - 16);
+  /* Clamp to range [0-255]. */
+  uint8x8_t cols_02_u8 = vadd_u8(vreinterpret_u8_s8(cols_02_s8),
+                                 vdup_n_u8(CENTERJSAMPLE));
+  uint8x8_t cols_13_u8 = vadd_u8(vreinterpret_u8_s8(cols_13_s8),
+                                 vdup_n_u8(CENTERJSAMPLE));
+  uint8x8_t cols_46_u8 = vadd_u8(vreinterpret_u8_s8(cols_46_s8),
+                                 vdup_n_u8(CENTERJSAMPLE));
+  uint8x8_t cols_57_u8 = vadd_u8(vreinterpret_u8_s8(cols_57_s8),
+                                 vdup_n_u8(CENTERJSAMPLE));
+
+  /* Transpose 4x8 block and store to memory.  (Zipping adjacent columns
+   * together allows us to store 16-bit elements.)
+   */
+  uint8x8x2_t cols_01_23 = vzip_u8(cols_02_u8, cols_13_u8);
+  uint8x8x2_t cols_45_67 = vzip_u8(cols_46_u8, cols_57_u8);
+  uint16x4x4_t cols_01_23_45_67 = { {
+    vreinterpret_u16_u8(cols_01_23.val[0]),
+    vreinterpret_u16_u8(cols_01_23.val[1]),
+    vreinterpret_u16_u8(cols_45_67.val[0]),
+    vreinterpret_u16_u8(cols_45_67.val[1])
+  } };
+
+  JSAMPROW outptr0 = output_buf[buf_offset + 0] + output_col;
+  JSAMPROW outptr1 = output_buf[buf_offset + 1] + output_col;
+  JSAMPROW outptr2 = output_buf[buf_offset + 2] + output_col;
+  JSAMPROW outptr3 = output_buf[buf_offset + 3] + output_col;
+  /* VST4 of 16-bit elements completes the transpose. */
+  vst4_lane_u16((uint16_t *)outptr0, cols_01_23_45_67, 0);
+  vst4_lane_u16((uint16_t *)outptr1, cols_01_23_45_67, 1);
+  vst4_lane_u16((uint16_t *)outptr2, cols_01_23_45_67, 2);
+  vst4_lane_u16((uint16_t *)outptr3, cols_01_23_45_67, 3);
+}
+
+
+/* Performs the second pass of the accurate inverse DCT on a 4x8 block
+ * of coefficients.
+ *
+ * This "sparse" version assumes that the coefficient values (after the first
+ * pass) in rows 4-7 are all 0.  This simplifies the IDCT calculation,
+ * accelerating overall performance.
+ */
+
+static INLINE void jsimd_idct_islow_pass2_sparse(int16_t *workspace,
+                                                 JSAMPARRAY output_buf,
+                                                 JDIMENSION output_col,
+                                                 unsigned buf_offset)
+{
+  /* Load constants for IDCT computation. */
+#ifdef HAVE_VLD1_S16_X3
+  const int16x4x3_t consts = vld1_s16_x3(jsimd_idct_islow_neon_consts);
+#else
+  const int16x4_t consts1 = vld1_s16(jsimd_idct_islow_neon_consts);
+  const int16x4_t consts2 = vld1_s16(jsimd_idct_islow_neon_consts + 4);
+  const int16x4_t consts3 = vld1_s16(jsimd_idct_islow_neon_consts + 8);
+  const int16x4x3_t consts = { { consts1, consts2, consts3 } };
+#endif
+
+  /* Even part (z3 is all 0) */
+  int16x4_t z2_s16 = vld1_s16(workspace + 2 * DCTSIZE / 2);
+
+  int32x4_t tmp2 = vmull_lane_s16(z2_s16, consts.val[0], 1);
+  int32x4_t tmp3 = vmull_lane_s16(z2_s16, consts.val[1], 2);
+
+  z2_s16 = vld1_s16(workspace + 0 * DCTSIZE / 2);
+  int32x4_t tmp0 = vshll_n_s16(z2_s16, CONST_BITS);
+  int32x4_t tmp1 = vshll_n_s16(z2_s16, CONST_BITS);
+
+  int32x4_t tmp10 = vaddq_s32(tmp0, tmp3);
+  int32x4_t tmp13 = vsubq_s32(tmp0, tmp3);
+  int32x4_t tmp11 = vaddq_s32(tmp1, tmp2);
+  int32x4_t tmp12 = vsubq_s32(tmp1, tmp2);
+
+  /* Odd part (tmp0 and tmp1 are both all 0) */
+  int16x4_t tmp2_s16 = vld1_s16(workspace + 3 * DCTSIZE / 2);
+  int16x4_t tmp3_s16 = vld1_s16(workspace + 1 * DCTSIZE / 2);
+
+  int16x4_t z3_s16 = tmp2_s16;
+  int16x4_t z4_s16 = tmp3_s16;
+
+  int32x4_t z3 = vmull_lane_s16(z3_s16, consts.val[2], 3);
+  z3 = vmlal_lane_s16(z3, z4_s16, consts.val[1], 3);
+  int32x4_t z4 = vmull_lane_s16(z3_s16, consts.val[1], 3);
+  z4 = vmlal_lane_s16(z4, z4_s16, consts.val[2], 0);
+
+  tmp0 = vmlsl_lane_s16(z3, tmp3_s16, consts.val[0], 0);
+  tmp1 = vmlsl_lane_s16(z4, tmp2_s16, consts.val[0], 2);
+  tmp2 = vmlal_lane_s16(z3, tmp2_s16, consts.val[2], 2);
+  tmp3 = vmlal_lane_s16(z4, tmp3_s16, consts.val[1], 0);
+
+  /* Final output stage: descale and narrow to 16-bit. */
+  int16x8_t cols_02_s16 = vcombine_s16(vaddhn_s32(tmp10, tmp3),
+                                       vaddhn_s32(tmp12, tmp1));
+  int16x8_t cols_13_s16 = vcombine_s16(vaddhn_s32(tmp11, tmp2),
+                                       vaddhn_s32(tmp13, tmp0));
+  int16x8_t cols_46_s16 = vcombine_s16(vsubhn_s32(tmp13, tmp0),
+                                       vsubhn_s32(tmp11, tmp2));
+  int16x8_t cols_57_s16 = vcombine_s16(vsubhn_s32(tmp12, tmp1),
+                                       vsubhn_s32(tmp10, tmp3));
+  /* Descale and narrow to 8-bit. */
+  int8x8_t cols_02_s8 = vqrshrn_n_s16(cols_02_s16, DESCALE_P2 - 16);
+  int8x8_t cols_13_s8 = vqrshrn_n_s16(cols_13_s16, DESCALE_P2 - 16);
+  int8x8_t cols_46_s8 = vqrshrn_n_s16(cols_46_s16, DESCALE_P2 - 16);
+  int8x8_t cols_57_s8 = vqrshrn_n_s16(cols_57_s16, DESCALE_P2 - 16);
+  /* Clamp to range [0-255]. */
+  uint8x8_t cols_02_u8 = vadd_u8(vreinterpret_u8_s8(cols_02_s8),
+                                 vdup_n_u8(CENTERJSAMPLE));
+  uint8x8_t cols_13_u8 = vadd_u8(vreinterpret_u8_s8(cols_13_s8),
+                                 vdup_n_u8(CENTERJSAMPLE));
+  uint8x8_t cols_46_u8 = vadd_u8(vreinterpret_u8_s8(cols_46_s8),
+                                 vdup_n_u8(CENTERJSAMPLE));
+  uint8x8_t cols_57_u8 = vadd_u8(vreinterpret_u8_s8(cols_57_s8),
+                                 vdup_n_u8(CENTERJSAMPLE));
+
+  /* Transpose 4x8 block and store to memory.  (Zipping adjacent columns
+   * together allows us to store 16-bit elements.)
+   */
+  uint8x8x2_t cols_01_23 = vzip_u8(cols_02_u8, cols_13_u8);
+  uint8x8x2_t cols_45_67 = vzip_u8(cols_46_u8, cols_57_u8);
+  uint16x4x4_t cols_01_23_45_67 = { {
+    vreinterpret_u16_u8(cols_01_23.val[0]),
+    vreinterpret_u16_u8(cols_01_23.val[1]),
+    vreinterpret_u16_u8(cols_45_67.val[0]),
+    vreinterpret_u16_u8(cols_45_67.val[1])
+  } };
+
+  JSAMPROW outptr0 = output_buf[buf_offset + 0] + output_col;
+  JSAMPROW outptr1 = output_buf[buf_offset + 1] + output_col;
+  JSAMPROW outptr2 = output_buf[buf_offset + 2] + output_col;
+  JSAMPROW outptr3 = output_buf[buf_offset + 3] + output_col;
+  /* VST4 of 16-bit elements completes the transpose. */
+  vst4_lane_u16((uint16_t *)outptr0, cols_01_23_45_67, 0);
+  vst4_lane_u16((uint16_t *)outptr1, cols_01_23_45_67, 1);
+  vst4_lane_u16((uint16_t *)outptr2, cols_01_23_45_67, 2);
+  vst4_lane_u16((uint16_t *)outptr3, cols_01_23_45_67, 3);
+}
diff --git a/3rdparty/libjpeg/src/simd/arm/jidctred-neon.c b/3rdparty/libjpeg/src/simd/arm/jidctred-neon.c
new file mode 100644
index 00000000..be9627e6
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/arm/jidctred-neon.c
@@ -0,0 +1,486 @@
+/*
+ * jidctred-neon.c - reduced-size IDCT (Arm Neon)
+ *
+ * Copyright (C) 2020, Arm Limited.  All Rights Reserved.
+ * Copyright (C) 2020, D. R. Commander.  All Rights Reserved.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+#define JPEG_INTERNALS
+#include "../../jinclude.h"
+#include "../../jpeglib.h"
+#include "../../jsimd.h"
+#include "../../jdct.h"
+#include "../../jsimddct.h"
+#include "../jsimd.h"
+#include "align.h"
+#include "neon-compat.h"
+
+#include <arm_neon.h>
+
+
+#define CONST_BITS  13
+#define PASS1_BITS  2
+
+#define F_0_211  1730
+#define F_0_509  4176
+#define F_0_601  4926
+#define F_0_720  5906
+#define F_0_765  6270
+#define F_0_850  6967
+#define F_0_899  7373
+#define F_1_061  8697
+#define F_1_272  10426
+#define F_1_451  11893
+#define F_1_847  15137
+#define F_2_172  17799
+#define F_2_562  20995
+#define F_3_624  29692
+
+
+/* jsimd_idct_2x2_neon() is an inverse DCT function that produces reduced-size
+ * 2x2 output from an 8x8 DCT block.  It uses the same calculations and
+ * produces exactly the same output as IJG's original jpeg_idct_2x2() function
+ * from jpeg-6b, which can be found in jidctred.c.
+ *
+ * Scaled integer constants are used to avoid floating-point arithmetic:
+ *    0.720959822 =  5906 * 2^-13
+ *    0.850430095 =  6967 * 2^-13
+ *    1.272758580 = 10426 * 2^-13
+ *    3.624509785 = 29692 * 2^-13
+ *
+ * See jidctred.c for further details of the 2x2 IDCT algorithm.  Where
+ * possible, the variable names and comments here in jsimd_idct_2x2_neon()
+ * match up with those in jpeg_idct_2x2().
+ */
+
+ALIGN(16) static const int16_t jsimd_idct_2x2_neon_consts[] = {
+  -F_0_720, F_0_850, -F_1_272, F_3_624
+};
+
+void jsimd_idct_2x2_neon(void *dct_table, JCOEFPTR coef_block,
+                         JSAMPARRAY output_buf, JDIMENSION output_col)
+{
+  ISLOW_MULT_TYPE *quantptr = dct_table;
+
+  /* Load DCT coefficients. */
+  int16x8_t row0 = vld1q_s16(coef_block + 0 * DCTSIZE);
+  int16x8_t row1 = vld1q_s16(coef_block + 1 * DCTSIZE);
+  int16x8_t row3 = vld1q_s16(coef_block + 3 * DCTSIZE);
+  int16x8_t row5 = vld1q_s16(coef_block + 5 * DCTSIZE);
+  int16x8_t row7 = vld1q_s16(coef_block + 7 * DCTSIZE);
+
+  /* Load quantization table values. */
+  int16x8_t quant_row0 = vld1q_s16(quantptr + 0 * DCTSIZE);
+  int16x8_t quant_row1 = vld1q_s16(quantptr + 1 * DCTSIZE);
+  int16x8_t quant_row3 = vld1q_s16(quantptr + 3 * DCTSIZE);
+  int16x8_t quant_row5 = vld1q_s16(quantptr + 5 * DCTSIZE);
+  int16x8_t quant_row7 = vld1q_s16(quantptr + 7 * DCTSIZE);
+
+  /* Dequantize DCT coefficients. */
+  row0 = vmulq_s16(row0, quant_row0);
+  row1 = vmulq_s16(row1, quant_row1);
+  row3 = vmulq_s16(row3, quant_row3);
+  row5 = vmulq_s16(row5, quant_row5);
+  row7 = vmulq_s16(row7, quant_row7);
+
+  /* Load IDCT conversion constants. */
+  const int16x4_t consts = vld1_s16(jsimd_idct_2x2_neon_consts);
+
+  /* Pass 1: process columns from input, put results in vectors row0 and
+   * row1.
+   */
+
+  /* Even part */
+  int32x4_t tmp10_l = vshll_n_s16(vget_low_s16(row0), CONST_BITS + 2);
+  int32x4_t tmp10_h = vshll_n_s16(vget_high_s16(row0), CONST_BITS + 2);
+
+  /* Odd part */
+  int32x4_t tmp0_l = vmull_lane_s16(vget_low_s16(row1), consts, 3);
+  tmp0_l = vmlal_lane_s16(tmp0_l, vget_low_s16(row3), consts, 2);
+  tmp0_l = vmlal_lane_s16(tmp0_l, vget_low_s16(row5), consts, 1);
+  tmp0_l = vmlal_lane_s16(tmp0_l, vget_low_s16(row7), consts, 0);
+  int32x4_t tmp0_h = vmull_lane_s16(vget_high_s16(row1), consts, 3);
+  tmp0_h = vmlal_lane_s16(tmp0_h, vget_high_s16(row3), consts, 2);
+  tmp0_h = vmlal_lane_s16(tmp0_h, vget_high_s16(row5), consts, 1);
+  tmp0_h = vmlal_lane_s16(tmp0_h, vget_high_s16(row7), consts, 0);
+
+  /* Final output stage: descale and narrow to 16-bit. */
+  row0 = vcombine_s16(vrshrn_n_s32(vaddq_s32(tmp10_l, tmp0_l), CONST_BITS),
+                      vrshrn_n_s32(vaddq_s32(tmp10_h, tmp0_h), CONST_BITS));
+  row1 = vcombine_s16(vrshrn_n_s32(vsubq_s32(tmp10_l, tmp0_l), CONST_BITS),
+                      vrshrn_n_s32(vsubq_s32(tmp10_h, tmp0_h), CONST_BITS));
+
+  /* Transpose two rows, ready for second pass. */
+  int16x8x2_t cols_0246_1357 = vtrnq_s16(row0, row1);
+  int16x8_t cols_0246 = cols_0246_1357.val[0];
+  int16x8_t cols_1357 = cols_0246_1357.val[1];
+  /* Duplicate columns such that each is accessible in its own vector. */
+  int32x4x2_t cols_1155_3377 = vtrnq_s32(vreinterpretq_s32_s16(cols_1357),
+                                         vreinterpretq_s32_s16(cols_1357));
+  int16x8_t cols_1155 = vreinterpretq_s16_s32(cols_1155_3377.val[0]);
+  int16x8_t cols_3377 = vreinterpretq_s16_s32(cols_1155_3377.val[1]);
+
+  /* Pass 2: process two rows, store to output array. */
+
+  /* Even part: we're only interested in col0; the top half of tmp10 is "don't
+   * care."
+   */
+  int32x4_t tmp10 = vshll_n_s16(vget_low_s16(cols_0246), CONST_BITS + 2);
+
+  /* Odd part: we're only interested in the bottom half of tmp0. */
+  int32x4_t tmp0 = vmull_lane_s16(vget_low_s16(cols_1155), consts, 3);
+  tmp0 = vmlal_lane_s16(tmp0, vget_low_s16(cols_3377), consts, 2);
+  tmp0 = vmlal_lane_s16(tmp0, vget_high_s16(cols_1155), consts, 1);
+  tmp0 = vmlal_lane_s16(tmp0, vget_high_s16(cols_3377), consts, 0);
+
+  /* Final output stage: descale and clamp to range [0-255]. */
+  int16x8_t output_s16 = vcombine_s16(vaddhn_s32(tmp10, tmp0),
+                                      vsubhn_s32(tmp10, tmp0));
+  output_s16 = vrsraq_n_s16(vdupq_n_s16(CENTERJSAMPLE), output_s16,
+                            CONST_BITS + PASS1_BITS + 3 + 2 - 16);
+  /* Narrow to 8-bit and convert to unsigned. */
+  uint8x8_t output_u8 = vqmovun_s16(output_s16);
+
+  /* Store 2x2 block to memory. */
+  vst1_lane_u8(output_buf[0] + output_col, output_u8, 0);
+  vst1_lane_u8(output_buf[1] + output_col, output_u8, 1);
+  vst1_lane_u8(output_buf[0] + output_col + 1, output_u8, 4);
+  vst1_lane_u8(output_buf[1] + output_col + 1, output_u8, 5);
+}
+
+
+/* jsimd_idct_4x4_neon() is an inverse DCT function that produces reduced-size
+ * 4x4 output from an 8x8 DCT block.  It uses the same calculations and
+ * produces exactly the same output as IJG's original jpeg_idct_4x4() function
+ * from jpeg-6b, which can be found in jidctred.c.
+ *
+ * Scaled integer constants are used to avoid floating-point arithmetic:
+ *    0.211164243 =  1730 * 2^-13
+ *    0.509795579 =  4176 * 2^-13
+ *    0.601344887 =  4926 * 2^-13
+ *    0.765366865 =  6270 * 2^-13
+ *    0.899976223 =  7373 * 2^-13
+ *    1.061594337 =  8697 * 2^-13
+ *    1.451774981 = 11893 * 2^-13
+ *    1.847759065 = 15137 * 2^-13
+ *    2.172734803 = 17799 * 2^-13
+ *    2.562915447 = 20995 * 2^-13
+ *
+ * See jidctred.c for further details of the 4x4 IDCT algorithm.  Where
+ * possible, the variable names and comments here in jsimd_idct_4x4_neon()
+ * match up with those in jpeg_idct_4x4().
+ */
+
+ALIGN(16) static const int16_t jsimd_idct_4x4_neon_consts[] = {
+  F_1_847, -F_0_765, -F_0_211,  F_1_451,
+ -F_2_172,  F_1_061, -F_0_509, -F_0_601,
+  F_0_899,  F_2_562,        0,        0
+};
+
+void jsimd_idct_4x4_neon(void *dct_table, JCOEFPTR coef_block,
+                         JSAMPARRAY output_buf, JDIMENSION output_col)
+{
+  ISLOW_MULT_TYPE *quantptr = dct_table;
+
+  /* Load DCT coefficients. */
+  int16x8_t row0  = vld1q_s16(coef_block + 0 * DCTSIZE);
+  int16x8_t row1  = vld1q_s16(coef_block + 1 * DCTSIZE);
+  int16x8_t row2  = vld1q_s16(coef_block + 2 * DCTSIZE);
+  int16x8_t row3  = vld1q_s16(coef_block + 3 * DCTSIZE);
+  int16x8_t row5  = vld1q_s16(coef_block + 5 * DCTSIZE);
+  int16x8_t row6  = vld1q_s16(coef_block + 6 * DCTSIZE);
+  int16x8_t row7  = vld1q_s16(coef_block + 7 * DCTSIZE);
+
+  /* Load quantization table values for DC coefficients. */
+  int16x8_t quant_row0 = vld1q_s16(quantptr + 0 * DCTSIZE);
+  /* Dequantize DC coefficients. */
+  row0 = vmulq_s16(row0, quant_row0);
+
+  /* Construct bitmap to test if all AC coefficients are 0. */
+  int16x8_t bitmap = vorrq_s16(row1, row2);
+  bitmap = vorrq_s16(bitmap, row3);
+  bitmap = vorrq_s16(bitmap, row5);
+  bitmap = vorrq_s16(bitmap, row6);
+  bitmap = vorrq_s16(bitmap, row7);
+
+  int64_t left_ac_bitmap = vgetq_lane_s64(vreinterpretq_s64_s16(bitmap), 0);
+  int64_t right_ac_bitmap = vgetq_lane_s64(vreinterpretq_s64_s16(bitmap), 1);
+
+  /* Load constants for IDCT computation. */
+#ifdef HAVE_VLD1_S16_X3
+  const int16x4x3_t consts = vld1_s16_x3(jsimd_idct_4x4_neon_consts);
+#else
+  /* GCC does not currently support the intrinsic vld1_<type>_x3(). */
+  const int16x4_t consts1 = vld1_s16(jsimd_idct_4x4_neon_consts);
+  const int16x4_t consts2 = vld1_s16(jsimd_idct_4x4_neon_consts + 4);
+  const int16x4_t consts3 = vld1_s16(jsimd_idct_4x4_neon_consts + 8);
+  const int16x4x3_t consts = { { consts1, consts2, consts3 } };
+#endif
+
+  if (left_ac_bitmap == 0 && right_ac_bitmap == 0) {
+    /* All AC coefficients are zero.
+     * Compute DC values and duplicate into row vectors 0, 1, 2, and 3.
+     */
+    int16x8_t dcval = vshlq_n_s16(row0, PASS1_BITS);
+    row0 = dcval;
+    row1 = dcval;
+    row2 = dcval;
+    row3 = dcval;
+  } else if (left_ac_bitmap == 0) {
+    /* AC coefficients are zero for columns 0, 1, 2, and 3.
+     * Compute DC values for these columns.
+     */
+    int16x4_t dcval = vshl_n_s16(vget_low_s16(row0), PASS1_BITS);
+
+    /* Commence regular IDCT computation for columns 4, 5, 6, and 7. */
+
+    /* Load quantization table. */
+    int16x4_t quant_row1 = vld1_s16(quantptr + 1 * DCTSIZE + 4);
+    int16x4_t quant_row2 = vld1_s16(quantptr + 2 * DCTSIZE + 4);
+    int16x4_t quant_row3 = vld1_s16(quantptr + 3 * DCTSIZE + 4);
+    int16x4_t quant_row5 = vld1_s16(quantptr + 5 * DCTSIZE + 4);
+    int16x4_t quant_row6 = vld1_s16(quantptr + 6 * DCTSIZE + 4);
+    int16x4_t quant_row7 = vld1_s16(quantptr + 7 * DCTSIZE + 4);
+
+    /* Even part */
+    int32x4_t tmp0 = vshll_n_s16(vget_high_s16(row0), CONST_BITS + 1);
+
+    int16x4_t z2 = vmul_s16(vget_high_s16(row2), quant_row2);
+    int16x4_t z3 = vmul_s16(vget_high_s16(row6), quant_row6);
+
+    int32x4_t tmp2 = vmull_lane_s16(z2, consts.val[0], 0);
+    tmp2 = vmlal_lane_s16(tmp2, z3, consts.val[0], 1);
+
+    int32x4_t tmp10 = vaddq_s32(tmp0, tmp2);
+    int32x4_t tmp12 = vsubq_s32(tmp0, tmp2);
+
+    /* Odd part */
+    int16x4_t z1 = vmul_s16(vget_high_s16(row7), quant_row7);
+    z2 = vmul_s16(vget_high_s16(row5), quant_row5);
+    z3 = vmul_s16(vget_high_s16(row3), quant_row3);
+    int16x4_t z4 = vmul_s16(vget_high_s16(row1), quant_row1);
+
+    tmp0 = vmull_lane_s16(z1, consts.val[0], 2);
+    tmp0 = vmlal_lane_s16(tmp0, z2, consts.val[0], 3);
+    tmp0 = vmlal_lane_s16(tmp0, z3, consts.val[1], 0);
+    tmp0 = vmlal_lane_s16(tmp0, z4, consts.val[1], 1);
+
+    tmp2 = vmull_lane_s16(z1, consts.val[1], 2);
+    tmp2 = vmlal_lane_s16(tmp2, z2, consts.val[1], 3);
+    tmp2 = vmlal_lane_s16(tmp2, z3, consts.val[2], 0);
+    tmp2 = vmlal_lane_s16(tmp2, z4, consts.val[2], 1);
+
+    /* Final output stage: descale and narrow to 16-bit. */
+    row0 = vcombine_s16(dcval, vrshrn_n_s32(vaddq_s32(tmp10, tmp2),
+                                            CONST_BITS - PASS1_BITS + 1));
+    row3 = vcombine_s16(dcval, vrshrn_n_s32(vsubq_s32(tmp10, tmp2),
+                                            CONST_BITS - PASS1_BITS + 1));
+    row1 = vcombine_s16(dcval, vrshrn_n_s32(vaddq_s32(tmp12, tmp0),
+                                            CONST_BITS - PASS1_BITS + 1));
+    row2 = vcombine_s16(dcval, vrshrn_n_s32(vsubq_s32(tmp12, tmp0),
+                                            CONST_BITS - PASS1_BITS + 1));
+  } else if (right_ac_bitmap == 0) {
+    /* AC coefficients are zero for columns 4, 5, 6, and 7.
+     * Compute DC values for these columns.
+     */
+    int16x4_t dcval = vshl_n_s16(vget_high_s16(row0), PASS1_BITS);
+
+    /* Commence regular IDCT computation for columns 0, 1, 2, and 3. */
+
+    /* Load quantization table. */
+    int16x4_t quant_row1 = vld1_s16(quantptr + 1 * DCTSIZE);
+    int16x4_t quant_row2 = vld1_s16(quantptr + 2 * DCTSIZE);
+    int16x4_t quant_row3 = vld1_s16(quantptr + 3 * DCTSIZE);
+    int16x4_t quant_row5 = vld1_s16(quantptr + 5 * DCTSIZE);
+    int16x4_t quant_row6 = vld1_s16(quantptr + 6 * DCTSIZE);
+    int16x4_t quant_row7 = vld1_s16(quantptr + 7 * DCTSIZE);
+
+    /* Even part */
+    int32x4_t tmp0 = vshll_n_s16(vget_low_s16(row0), CONST_BITS + 1);
+
+    int16x4_t z2 = vmul_s16(vget_low_s16(row2), quant_row2);
+    int16x4_t z3 = vmul_s16(vget_low_s16(row6), quant_row6);
+
+    int32x4_t tmp2 = vmull_lane_s16(z2, consts.val[0], 0);
+    tmp2 = vmlal_lane_s16(tmp2, z3, consts.val[0], 1);
+
+    int32x4_t tmp10 = vaddq_s32(tmp0, tmp2);
+    int32x4_t tmp12 = vsubq_s32(tmp0, tmp2);
+
+    /* Odd part */
+    int16x4_t z1 = vmul_s16(vget_low_s16(row7), quant_row7);
+    z2 = vmul_s16(vget_low_s16(row5), quant_row5);
+    z3 = vmul_s16(vget_low_s16(row3), quant_row3);
+    int16x4_t z4 = vmul_s16(vget_low_s16(row1), quant_row1);
+
+    tmp0 = vmull_lane_s16(z1, consts.val[0], 2);
+    tmp0 = vmlal_lane_s16(tmp0, z2, consts.val[0], 3);
+    tmp0 = vmlal_lane_s16(tmp0, z3, consts.val[1], 0);
+    tmp0 = vmlal_lane_s16(tmp0, z4, consts.val[1], 1);
+
+    tmp2 = vmull_lane_s16(z1, consts.val[1], 2);
+    tmp2 = vmlal_lane_s16(tmp2, z2, consts.val[1], 3);
+    tmp2 = vmlal_lane_s16(tmp2, z3, consts.val[2], 0);
+    tmp2 = vmlal_lane_s16(tmp2, z4, consts.val[2], 1);
+
+    /* Final output stage: descale and narrow to 16-bit. */
+    row0 = vcombine_s16(vrshrn_n_s32(vaddq_s32(tmp10, tmp2),
+                                     CONST_BITS - PASS1_BITS + 1), dcval);
+    row3 = vcombine_s16(vrshrn_n_s32(vsubq_s32(tmp10, tmp2),
+                                     CONST_BITS - PASS1_BITS + 1), dcval);
+    row1 = vcombine_s16(vrshrn_n_s32(vaddq_s32(tmp12, tmp0),
+                                     CONST_BITS - PASS1_BITS + 1), dcval);
+    row2 = vcombine_s16(vrshrn_n_s32(vsubq_s32(tmp12, tmp0),
+                                     CONST_BITS - PASS1_BITS + 1), dcval);
+  } else {
+    /* All AC coefficients are non-zero; full IDCT calculation required. */
+    int16x8_t quant_row1 = vld1q_s16(quantptr + 1 * DCTSIZE);
+    int16x8_t quant_row2 = vld1q_s16(quantptr + 2 * DCTSIZE);
+    int16x8_t quant_row3 = vld1q_s16(quantptr + 3 * DCTSIZE);
+    int16x8_t quant_row5 = vld1q_s16(quantptr + 5 * DCTSIZE);
+    int16x8_t quant_row6 = vld1q_s16(quantptr + 6 * DCTSIZE);
+    int16x8_t quant_row7 = vld1q_s16(quantptr + 7 * DCTSIZE);
+
+    /* Even part */
+    int32x4_t tmp0_l = vshll_n_s16(vget_low_s16(row0), CONST_BITS + 1);
+    int32x4_t tmp0_h = vshll_n_s16(vget_high_s16(row0), CONST_BITS + 1);
+
+    int16x8_t z2 = vmulq_s16(row2, quant_row2);
+    int16x8_t z3 = vmulq_s16(row6, quant_row6);
+
+    int32x4_t tmp2_l = vmull_lane_s16(vget_low_s16(z2), consts.val[0], 0);
+    int32x4_t tmp2_h = vmull_lane_s16(vget_high_s16(z2), consts.val[0], 0);
+    tmp2_l = vmlal_lane_s16(tmp2_l, vget_low_s16(z3), consts.val[0], 1);
+    tmp2_h = vmlal_lane_s16(tmp2_h, vget_high_s16(z3), consts.val[0], 1);
+
+    int32x4_t tmp10_l = vaddq_s32(tmp0_l, tmp2_l);
+    int32x4_t tmp10_h = vaddq_s32(tmp0_h, tmp2_h);
+    int32x4_t tmp12_l = vsubq_s32(tmp0_l, tmp2_l);
+    int32x4_t tmp12_h = vsubq_s32(tmp0_h, tmp2_h);
+
+    /* Odd part */
+    int16x8_t z1 = vmulq_s16(row7, quant_row7);
+    z2 = vmulq_s16(row5, quant_row5);
+    z3 = vmulq_s16(row3, quant_row3);
+    int16x8_t z4 = vmulq_s16(row1, quant_row1);
+
+    tmp0_l = vmull_lane_s16(vget_low_s16(z1), consts.val[0], 2);
+    tmp0_l = vmlal_lane_s16(tmp0_l, vget_low_s16(z2), consts.val[0], 3);
+    tmp0_l = vmlal_lane_s16(tmp0_l, vget_low_s16(z3), consts.val[1], 0);
+    tmp0_l = vmlal_lane_s16(tmp0_l, vget_low_s16(z4), consts.val[1], 1);
+    tmp0_h = vmull_lane_s16(vget_high_s16(z1), consts.val[0], 2);
+    tmp0_h = vmlal_lane_s16(tmp0_h, vget_high_s16(z2), consts.val[0], 3);
+    tmp0_h = vmlal_lane_s16(tmp0_h, vget_high_s16(z3), consts.val[1], 0);
+    tmp0_h = vmlal_lane_s16(tmp0_h, vget_high_s16(z4), consts.val[1], 1);
+
+    tmp2_l = vmull_lane_s16(vget_low_s16(z1), consts.val[1], 2);
+    tmp2_l = vmlal_lane_s16(tmp2_l, vget_low_s16(z2), consts.val[1], 3);
+    tmp2_l = vmlal_lane_s16(tmp2_l, vget_low_s16(z3), consts.val[2], 0);
+    tmp2_l = vmlal_lane_s16(tmp2_l, vget_low_s16(z4), consts.val[2], 1);
+    tmp2_h = vmull_lane_s16(vget_high_s16(z1), consts.val[1], 2);
+    tmp2_h = vmlal_lane_s16(tmp2_h, vget_high_s16(z2), consts.val[1], 3);
+    tmp2_h = vmlal_lane_s16(tmp2_h, vget_high_s16(z3), consts.val[2], 0);
+    tmp2_h = vmlal_lane_s16(tmp2_h, vget_high_s16(z4), consts.val[2], 1);
+
+    /* Final output stage: descale and narrow to 16-bit. */
+    row0 = vcombine_s16(vrshrn_n_s32(vaddq_s32(tmp10_l, tmp2_l),
+                                     CONST_BITS - PASS1_BITS + 1),
+                        vrshrn_n_s32(vaddq_s32(tmp10_h, tmp2_h),
+                                     CONST_BITS - PASS1_BITS + 1));
+    row3 = vcombine_s16(vrshrn_n_s32(vsubq_s32(tmp10_l, tmp2_l),
+                                     CONST_BITS - PASS1_BITS + 1),
+                        vrshrn_n_s32(vsubq_s32(tmp10_h, tmp2_h),
+                                     CONST_BITS - PASS1_BITS + 1));
+    row1 = vcombine_s16(vrshrn_n_s32(vaddq_s32(tmp12_l, tmp0_l),
+                                     CONST_BITS - PASS1_BITS + 1),
+                        vrshrn_n_s32(vaddq_s32(tmp12_h, tmp0_h),
+                                     CONST_BITS - PASS1_BITS + 1));
+    row2 = vcombine_s16(vrshrn_n_s32(vsubq_s32(tmp12_l, tmp0_l),
+                                     CONST_BITS - PASS1_BITS + 1),
+                        vrshrn_n_s32(vsubq_s32(tmp12_h, tmp0_h),
+                                     CONST_BITS - PASS1_BITS + 1));
+  }
+
+  /* Transpose 8x4 block to perform IDCT on rows in second pass. */
+  int16x8x2_t row_01 = vtrnq_s16(row0, row1);
+  int16x8x2_t row_23 = vtrnq_s16(row2, row3);
+
+  int32x4x2_t cols_0426 = vtrnq_s32(vreinterpretq_s32_s16(row_01.val[0]),
+                                    vreinterpretq_s32_s16(row_23.val[0]));
+  int32x4x2_t cols_1537 = vtrnq_s32(vreinterpretq_s32_s16(row_01.val[1]),
+                                    vreinterpretq_s32_s16(row_23.val[1]));
+
+  int16x4_t col0 = vreinterpret_s16_s32(vget_low_s32(cols_0426.val[0]));
+  int16x4_t col1 = vreinterpret_s16_s32(vget_low_s32(cols_1537.val[0]));
+  int16x4_t col2 = vreinterpret_s16_s32(vget_low_s32(cols_0426.val[1]));
+  int16x4_t col3 = vreinterpret_s16_s32(vget_low_s32(cols_1537.val[1]));
+  int16x4_t col5 = vreinterpret_s16_s32(vget_high_s32(cols_1537.val[0]));
+  int16x4_t col6 = vreinterpret_s16_s32(vget_high_s32(cols_0426.val[1]));
+  int16x4_t col7 = vreinterpret_s16_s32(vget_high_s32(cols_1537.val[1]));
+
+  /* Commence second pass of IDCT. */
+
+  /* Even part */
+  int32x4_t tmp0 = vshll_n_s16(col0, CONST_BITS + 1);
+  int32x4_t tmp2 = vmull_lane_s16(col2, consts.val[0], 0);
+  tmp2 = vmlal_lane_s16(tmp2, col6, consts.val[0], 1);
+
+  int32x4_t tmp10 = vaddq_s32(tmp0, tmp2);
+  int32x4_t tmp12 = vsubq_s32(tmp0, tmp2);
+
+  /* Odd part */
+  tmp0 = vmull_lane_s16(col7, consts.val[0], 2);
+  tmp0 = vmlal_lane_s16(tmp0, col5, consts.val[0], 3);
+  tmp0 = vmlal_lane_s16(tmp0, col3, consts.val[1], 0);
+  tmp0 = vmlal_lane_s16(tmp0, col1, consts.val[1], 1);
+
+  tmp2 = vmull_lane_s16(col7, consts.val[1], 2);
+  tmp2 = vmlal_lane_s16(tmp2, col5, consts.val[1], 3);
+  tmp2 = vmlal_lane_s16(tmp2, col3, consts.val[2], 0);
+  tmp2 = vmlal_lane_s16(tmp2, col1, consts.val[2], 1);
+
+  /* Final output stage: descale and clamp to range [0-255]. */
+  int16x8_t output_cols_02 = vcombine_s16(vaddhn_s32(tmp10, tmp2),
+                                          vsubhn_s32(tmp12, tmp0));
+  int16x8_t output_cols_13 = vcombine_s16(vaddhn_s32(tmp12, tmp0),
+                                          vsubhn_s32(tmp10, tmp2));
+  output_cols_02 = vrsraq_n_s16(vdupq_n_s16(CENTERJSAMPLE), output_cols_02,
+                                CONST_BITS + PASS1_BITS + 3 + 1 - 16);
+  output_cols_13 = vrsraq_n_s16(vdupq_n_s16(CENTERJSAMPLE), output_cols_13,
+                                CONST_BITS + PASS1_BITS + 3 + 1 - 16);
+  /* Narrow to 8-bit and convert to unsigned while zipping 8-bit elements.
+   * An interleaving store completes the transpose.
+   */
+  uint8x8x2_t output_0123 = vzip_u8(vqmovun_s16(output_cols_02),
+                                    vqmovun_s16(output_cols_13));
+  uint16x4x2_t output_01_23 = { {
+    vreinterpret_u16_u8(output_0123.val[0]),
+    vreinterpret_u16_u8(output_0123.val[1])
+  } };
+
+  /* Store 4x4 block to memory. */
+  JSAMPROW outptr0 = output_buf[0] + output_col;
+  JSAMPROW outptr1 = output_buf[1] + output_col;
+  JSAMPROW outptr2 = output_buf[2] + output_col;
+  JSAMPROW outptr3 = output_buf[3] + output_col;
+  vst2_lane_u16((uint16_t *)outptr0, output_01_23, 0);
+  vst2_lane_u16((uint16_t *)outptr1, output_01_23, 1);
+  vst2_lane_u16((uint16_t *)outptr2, output_01_23, 2);
+  vst2_lane_u16((uint16_t *)outptr3, output_01_23, 3);
+}
diff --git a/3rdparty/libjpeg/src/simd/arm/jquanti-neon.c b/3rdparty/libjpeg/src/simd/arm/jquanti-neon.c
new file mode 100644
index 00000000..a7eb6f19
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/arm/jquanti-neon.c
@@ -0,0 +1,190 @@
+/*
+ * jquanti-neon.c - sample data conversion and quantization (Arm Neon)
+ *
+ * Copyright (C) 2020, Arm Limited.  All Rights Reserved.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+#define JPEG_INTERNALS
+#include "../../jinclude.h"
+#include "../../jpeglib.h"
+#include "../../jsimd.h"
+#include "../../jdct.h"
+#include "../../jsimddct.h"
+#include "../jsimd.h"
+
+#include <arm_neon.h>
+
+
+/* After downsampling, the resulting sample values are in the range [0, 255],
+ * but the Discrete Cosine Transform (DCT) operates on values centered around
+ * 0.
+ *
+ * To prepare sample values for the DCT, load samples into a DCT workspace,
+ * subtracting CENTERJSAMPLE (128).  The samples, now in the range [-128, 127],
+ * are also widened from 8- to 16-bit.
+ *
+ * The equivalent scalar C function convsamp() can be found in jcdctmgr.c.
+ */
+
+void jsimd_convsamp_neon(JSAMPARRAY sample_data, JDIMENSION start_col,
+                         DCTELEM *workspace)
+{
+  uint8x8_t samp_row0 = vld1_u8(sample_data[0] + start_col);
+  uint8x8_t samp_row1 = vld1_u8(sample_data[1] + start_col);
+  uint8x8_t samp_row2 = vld1_u8(sample_data[2] + start_col);
+  uint8x8_t samp_row3 = vld1_u8(sample_data[3] + start_col);
+  uint8x8_t samp_row4 = vld1_u8(sample_data[4] + start_col);
+  uint8x8_t samp_row5 = vld1_u8(sample_data[5] + start_col);
+  uint8x8_t samp_row6 = vld1_u8(sample_data[6] + start_col);
+  uint8x8_t samp_row7 = vld1_u8(sample_data[7] + start_col);
+
+  int16x8_t row0 =
+    vreinterpretq_s16_u16(vsubl_u8(samp_row0, vdup_n_u8(CENTERJSAMPLE)));
+  int16x8_t row1 =
+    vreinterpretq_s16_u16(vsubl_u8(samp_row1, vdup_n_u8(CENTERJSAMPLE)));
+  int16x8_t row2 =
+    vreinterpretq_s16_u16(vsubl_u8(samp_row2, vdup_n_u8(CENTERJSAMPLE)));
+  int16x8_t row3 =
+    vreinterpretq_s16_u16(vsubl_u8(samp_row3, vdup_n_u8(CENTERJSAMPLE)));
+  int16x8_t row4 =
+    vreinterpretq_s16_u16(vsubl_u8(samp_row4, vdup_n_u8(CENTERJSAMPLE)));
+  int16x8_t row5 =
+    vreinterpretq_s16_u16(vsubl_u8(samp_row5, vdup_n_u8(CENTERJSAMPLE)));
+  int16x8_t row6 =
+    vreinterpretq_s16_u16(vsubl_u8(samp_row6, vdup_n_u8(CENTERJSAMPLE)));
+  int16x8_t row7 =
+    vreinterpretq_s16_u16(vsubl_u8(samp_row7, vdup_n_u8(CENTERJSAMPLE)));
+
+  vst1q_s16(workspace + 0 * DCTSIZE, row0);
+  vst1q_s16(workspace + 1 * DCTSIZE, row1);
+  vst1q_s16(workspace + 2 * DCTSIZE, row2);
+  vst1q_s16(workspace + 3 * DCTSIZE, row3);
+  vst1q_s16(workspace + 4 * DCTSIZE, row4);
+  vst1q_s16(workspace + 5 * DCTSIZE, row5);
+  vst1q_s16(workspace + 6 * DCTSIZE, row6);
+  vst1q_s16(workspace + 7 * DCTSIZE, row7);
+}
+
+
+/* After the DCT, the resulting array of coefficient values needs to be divided
+ * by an array of quantization values.
+ *
+ * To avoid a slow division operation, the DCT coefficients are multiplied by
+ * the (scaled) reciprocals of the quantization values and then right-shifted.
+ *
+ * The equivalent scalar C function quantize() can be found in jcdctmgr.c.
+ */
+
+void jsimd_quantize_neon(JCOEFPTR coef_block, DCTELEM *divisors,
+                         DCTELEM *workspace)
+{
+  JCOEFPTR out_ptr = coef_block;
+  UDCTELEM *recip_ptr = (UDCTELEM *)divisors;
+  UDCTELEM *corr_ptr = (UDCTELEM *)divisors + DCTSIZE2;
+  DCTELEM *shift_ptr = divisors + 3 * DCTSIZE2;
+  int i;
+
+  for (i = 0; i < DCTSIZE; i += DCTSIZE / 2) {
+    /* Load DCT coefficients. */
+    int16x8_t row0 = vld1q_s16(workspace + (i + 0) * DCTSIZE);
+    int16x8_t row1 = vld1q_s16(workspace + (i + 1) * DCTSIZE);
+    int16x8_t row2 = vld1q_s16(workspace + (i + 2) * DCTSIZE);
+    int16x8_t row3 = vld1q_s16(workspace + (i + 3) * DCTSIZE);
+    /* Load reciprocals of quantization values. */
+    uint16x8_t recip0 = vld1q_u16(recip_ptr + (i + 0) * DCTSIZE);
+    uint16x8_t recip1 = vld1q_u16(recip_ptr + (i + 1) * DCTSIZE);
+    uint16x8_t recip2 = vld1q_u16(recip_ptr + (i + 2) * DCTSIZE);
+    uint16x8_t recip3 = vld1q_u16(recip_ptr + (i + 3) * DCTSIZE);
+    uint16x8_t corr0 = vld1q_u16(corr_ptr + (i + 0) * DCTSIZE);
+    uint16x8_t corr1 = vld1q_u16(corr_ptr + (i + 1) * DCTSIZE);
+    uint16x8_t corr2 = vld1q_u16(corr_ptr + (i + 2) * DCTSIZE);
+    uint16x8_t corr3 = vld1q_u16(corr_ptr + (i + 3) * DCTSIZE);
+    int16x8_t shift0 = vld1q_s16(shift_ptr + (i + 0) * DCTSIZE);
+    int16x8_t shift1 = vld1q_s16(shift_ptr + (i + 1) * DCTSIZE);
+    int16x8_t shift2 = vld1q_s16(shift_ptr + (i + 2) * DCTSIZE);
+    int16x8_t shift3 = vld1q_s16(shift_ptr + (i + 3) * DCTSIZE);
+
+    /* Extract sign from coefficients. */
+    int16x8_t sign_row0 = vshrq_n_s16(row0, 15);
+    int16x8_t sign_row1 = vshrq_n_s16(row1, 15);
+    int16x8_t sign_row2 = vshrq_n_s16(row2, 15);
+    int16x8_t sign_row3 = vshrq_n_s16(row3, 15);
+    /* Get absolute value of DCT coefficients. */
+    uint16x8_t abs_row0 = vreinterpretq_u16_s16(vabsq_s16(row0));
+    uint16x8_t abs_row1 = vreinterpretq_u16_s16(vabsq_s16(row1));
+    uint16x8_t abs_row2 = vreinterpretq_u16_s16(vabsq_s16(row2));
+    uint16x8_t abs_row3 = vreinterpretq_u16_s16(vabsq_s16(row3));
+    /* Add correction. */
+    abs_row0 = vaddq_u16(abs_row0, corr0);
+    abs_row1 = vaddq_u16(abs_row1, corr1);
+    abs_row2 = vaddq_u16(abs_row2, corr2);
+    abs_row3 = vaddq_u16(abs_row3, corr3);
+
+    /* Multiply DCT coefficients by quantization reciprocals. */
+    int32x4_t row0_l = vreinterpretq_s32_u32(vmull_u16(vget_low_u16(abs_row0),
+                                                       vget_low_u16(recip0)));
+    int32x4_t row0_h = vreinterpretq_s32_u32(vmull_u16(vget_high_u16(abs_row0),
+                                                       vget_high_u16(recip0)));
+    int32x4_t row1_l = vreinterpretq_s32_u32(vmull_u16(vget_low_u16(abs_row1),
+                                                       vget_low_u16(recip1)));
+    int32x4_t row1_h = vreinterpretq_s32_u32(vmull_u16(vget_high_u16(abs_row1),
+                                                       vget_high_u16(recip1)));
+    int32x4_t row2_l = vreinterpretq_s32_u32(vmull_u16(vget_low_u16(abs_row2),
+                                                       vget_low_u16(recip2)));
+    int32x4_t row2_h = vreinterpretq_s32_u32(vmull_u16(vget_high_u16(abs_row2),
+                                                       vget_high_u16(recip2)));
+    int32x4_t row3_l = vreinterpretq_s32_u32(vmull_u16(vget_low_u16(abs_row3),
+                                                       vget_low_u16(recip3)));
+    int32x4_t row3_h = vreinterpretq_s32_u32(vmull_u16(vget_high_u16(abs_row3),
+                                                       vget_high_u16(recip3)));
+    /* Narrow back to 16-bit. */
+    row0 = vcombine_s16(vshrn_n_s32(row0_l, 16), vshrn_n_s32(row0_h, 16));
+    row1 = vcombine_s16(vshrn_n_s32(row1_l, 16), vshrn_n_s32(row1_h, 16));
+    row2 = vcombine_s16(vshrn_n_s32(row2_l, 16), vshrn_n_s32(row2_h, 16));
+    row3 = vcombine_s16(vshrn_n_s32(row3_l, 16), vshrn_n_s32(row3_h, 16));
+
+    /* Since VSHR only supports an immediate as its second argument, negate the
+     * shift value and shift left.
+     */
+    row0 = vreinterpretq_s16_u16(vshlq_u16(vreinterpretq_u16_s16(row0),
+                                           vnegq_s16(shift0)));
+    row1 = vreinterpretq_s16_u16(vshlq_u16(vreinterpretq_u16_s16(row1),
+                                           vnegq_s16(shift1)));
+    row2 = vreinterpretq_s16_u16(vshlq_u16(vreinterpretq_u16_s16(row2),
+                                           vnegq_s16(shift2)));
+    row3 = vreinterpretq_s16_u16(vshlq_u16(vreinterpretq_u16_s16(row3),
+                                           vnegq_s16(shift3)));
+
+    /* Restore sign to original product. */
+    row0 = veorq_s16(row0, sign_row0);
+    row0 = vsubq_s16(row0, sign_row0);
+    row1 = veorq_s16(row1, sign_row1);
+    row1 = vsubq_s16(row1, sign_row1);
+    row2 = veorq_s16(row2, sign_row2);
+    row2 = vsubq_s16(row2, sign_row2);
+    row3 = veorq_s16(row3, sign_row3);
+    row3 = vsubq_s16(row3, sign_row3);
+
+    /* Store quantized coefficients to memory. */
+    vst1q_s16(out_ptr + (i + 0) * DCTSIZE, row0);
+    vst1q_s16(out_ptr + (i + 1) * DCTSIZE, row1);
+    vst1q_s16(out_ptr + (i + 2) * DCTSIZE, row2);
+    vst1q_s16(out_ptr + (i + 3) * DCTSIZE, row3);
+  }
+}
diff --git a/3rdparty/libjpeg/src/simd/arm/neon-compat.h.in b/3rdparty/libjpeg/src/simd/arm/neon-compat.h.in
new file mode 100644
index 00000000..e2347b9b
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/arm/neon-compat.h.in
@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) 2020, D. R. Commander.  All Rights Reserved.
+ * Copyright (C) 2020, Arm Limited.  All Rights Reserved.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+#cmakedefine HAVE_VLD1_S16_X3
+#cmakedefine HAVE_VLD1_U16_X2
+#cmakedefine HAVE_VLD1Q_U8_X4
+
+/* Define compiler-independent count-leading-zeros macros */
+#if defined(_MSC_VER) && !defined(__clang__)
+#define BUILTIN_CLZ(x)  _CountLeadingZeros(x)
+#define BUILTIN_CLZL(x)  _CountLeadingZeros64(x)
+#elif defined(__clang__) || defined(__GNUC__)
+#define BUILTIN_CLZ(x)  __builtin_clz(x)
+#define BUILTIN_CLZL(x)  __builtin_clzl(x)
+#else
+#error "Unknown compiler"
+#endif
diff --git a/3rdparty/libjpeg/src/simd/i386/jccolext-avx2.asm b/3rdparty/libjpeg/src/simd/i386/jccolext-avx2.asm
new file mode 100644
index 00000000..c46d6844
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/i386/jccolext-avx2.asm
@@ -0,0 +1,578 @@
+;
+; jccolext.asm - colorspace conversion (AVX2)
+;
+; Copyright (C) 2015, Intel Corporation.
+; Copyright (C) 2016, D. R. Commander.
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+;
+; This file should be assembled with NASM (Netwide Assembler),
+; can *not* be assembled with Microsoft's MASM or any compatible
+; assembler (including Borland's Turbo Assembler).
+; NASM is available from http://nasm.sourceforge.net/ or
+; http://sourceforge.net/project/showfiles.php?group_id=6208
+
+%include "jcolsamp.inc"
+
+; --------------------------------------------------------------------------
+;
+; Convert some rows of samples to the output colorspace.
+;
+; GLOBAL(void)
+; jsimd_rgb_ycc_convert_avx2(JDIMENSION img_width, JSAMPARRAY input_buf,
+;                            JSAMPIMAGE output_buf, JDIMENSION output_row,
+;                            int num_rows);
+;
+
+%define img_width(b)   (b) + 8          ; JDIMENSION img_width
+%define input_buf(b)   (b) + 12         ; JSAMPARRAY input_buf
+%define output_buf(b)  (b) + 16         ; JSAMPIMAGE output_buf
+%define output_row(b)  (b) + 20         ; JDIMENSION output_row
+%define num_rows(b)    (b) + 24         ; int num_rows
+
+%define original_ebp   ebp + 0
+%define wk(i)          ebp - (WK_NUM - (i)) * SIZEOF_YMMWORD
+                                        ; ymmword wk[WK_NUM]
+%define WK_NUM         8
+%define gotptr         wk(0) - SIZEOF_POINTER  ; void * gotptr
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_rgb_ycc_convert_avx2)
+
+EXTN(jsimd_rgb_ycc_convert_avx2):
+    push        ebp
+    mov         eax, esp                     ; eax = original ebp
+    sub         esp, byte 4
+    and         esp, byte (-SIZEOF_YMMWORD)  ; align to 256 bits
+    mov         [esp], eax
+    mov         ebp, esp                     ; ebp = aligned ebp
+    lea         esp, [wk(0)]
+    pushpic     eax                     ; make a room for GOT address
+    push        ebx
+;   push        ecx                     ; need not be preserved
+;   push        edx                     ; need not be preserved
+    push        esi
+    push        edi
+
+    get_GOT     ebx                     ; get GOT address
+    movpic      POINTER [gotptr], ebx   ; save GOT address
+
+    mov         ecx, JDIMENSION [img_width(eax)]
+    test        ecx, ecx
+    jz          near .return
+
+    push        ecx
+
+    mov         esi, JSAMPIMAGE [output_buf(eax)]
+    mov         ecx, JDIMENSION [output_row(eax)]
+    mov         edi, JSAMPARRAY [esi+0*SIZEOF_JSAMPARRAY]
+    mov         ebx, JSAMPARRAY [esi+1*SIZEOF_JSAMPARRAY]
+    mov         edx, JSAMPARRAY [esi+2*SIZEOF_JSAMPARRAY]
+    lea         edi, [edi+ecx*SIZEOF_JSAMPROW]
+    lea         ebx, [ebx+ecx*SIZEOF_JSAMPROW]
+    lea         edx, [edx+ecx*SIZEOF_JSAMPROW]
+
+    pop         ecx
+
+    mov         esi, JSAMPARRAY [input_buf(eax)]
+    mov         eax, INT [num_rows(eax)]
+    test        eax, eax
+    jle         near .return
+    alignx      16, 7
+.rowloop:
+    pushpic     eax
+    push        edx
+    push        ebx
+    push        edi
+    push        esi
+    push        ecx                     ; col
+
+    mov         esi, JSAMPROW [esi]     ; inptr
+    mov         edi, JSAMPROW [edi]     ; outptr0
+    mov         ebx, JSAMPROW [ebx]     ; outptr1
+    mov         edx, JSAMPROW [edx]     ; outptr2
+    movpic      eax, POINTER [gotptr]   ; load GOT address (eax)
+
+    cmp         ecx, byte SIZEOF_YMMWORD
+    jae         near .columnloop
+    alignx      16, 7
+
+%if RGB_PIXELSIZE == 3  ; ---------------
+
+.column_ld1:
+    push        eax
+    push        edx
+    lea         ecx, [ecx+ecx*2]        ; imul ecx,RGB_PIXELSIZE
+    test        cl, SIZEOF_BYTE
+    jz          short .column_ld2
+    sub         ecx, byte SIZEOF_BYTE
+    movzx       eax, byte [esi+ecx]
+.column_ld2:
+    test        cl, SIZEOF_WORD
+    jz          short .column_ld4
+    sub         ecx, byte SIZEOF_WORD
+    movzx       edx, word [esi+ecx]
+    shl         eax, WORD_BIT
+    or          eax, edx
+.column_ld4:
+    vmovd       xmmA, eax
+    pop         edx
+    pop         eax
+    test        cl, SIZEOF_DWORD
+    jz          short .column_ld8
+    sub         ecx, byte SIZEOF_DWORD
+    vmovd       xmmF, XMM_DWORD [esi+ecx]
+    vpslldq     xmmA, xmmA, SIZEOF_DWORD
+    vpor        xmmA, xmmA, xmmF
+.column_ld8:
+    test        cl, SIZEOF_MMWORD
+    jz          short .column_ld16
+    sub         ecx, byte SIZEOF_MMWORD
+    vmovq       xmmB, XMM_MMWORD [esi+ecx]
+    vpslldq     xmmA, xmmA, SIZEOF_MMWORD
+    vpor        xmmA, xmmA, xmmB
+.column_ld16:
+    test        cl, SIZEOF_XMMWORD
+    jz          short .column_ld32
+    sub         ecx, byte SIZEOF_XMMWORD
+    vmovdqu     xmmB, XMM_MMWORD [esi+ecx]
+    vperm2i128  ymmA, ymmA, ymmA, 1
+    vpor        ymmA, ymmB
+.column_ld32:
+    test        cl, SIZEOF_YMMWORD
+    jz          short .column_ld64
+    sub         ecx, byte SIZEOF_YMMWORD
+    vmovdqa     ymmF, ymmA
+    vmovdqu     ymmA, YMMWORD [esi+0*SIZEOF_YMMWORD]
+.column_ld64:
+    test        cl, 2*SIZEOF_YMMWORD
+    mov         ecx, SIZEOF_YMMWORD
+    jz          short .rgb_ycc_cnv
+    vmovdqa     ymmB, ymmA
+    vmovdqu     ymmA, YMMWORD [esi+0*SIZEOF_YMMWORD]
+    vmovdqu     ymmF, YMMWORD [esi+1*SIZEOF_YMMWORD]
+    jmp         short .rgb_ycc_cnv
+    alignx      16, 7
+
+.columnloop:
+    vmovdqu     ymmA, YMMWORD [esi+0*SIZEOF_YMMWORD]
+    vmovdqu     ymmF, YMMWORD [esi+1*SIZEOF_YMMWORD]
+    vmovdqu     ymmB, YMMWORD [esi+2*SIZEOF_YMMWORD]
+
+.rgb_ycc_cnv:
+    ; ymmA=(00 10 20 01 11 21 02 12 22 03 13 23 04 14 24 05
+    ;       15 25 06 16 26 07 17 27 08 18 28 09 19 29 0A 1A)
+    ; ymmF=(2A 0B 1B 2B 0C 1C 2C 0D 1D 2D 0E 1E 2E 0F 1F 2F
+    ;       0G 1G 2G 0H 1H 2H 0I 1I 2I 0J 1J 2J 0K 1K 2K 0L)
+    ; ymmB=(1L 2L 0M 1M 2M 0N 1N 2N 0O 1O 2O 0P 1P 2P 0Q 1Q
+    ;       2Q 0R 1R 2R 0S 1S 2S 0T 1T 2T 0U 1U 2U 0V 1V 2V)
+
+    vmovdqu     ymmC, ymmA
+    vinserti128 ymmA, ymmF, xmmA, 0  ; ymmA=(00 10 20 01 11 21 02 12 22 03 13 23 04 14 24 05
+                                     ;       0G 1G 2G 0H 1H 2H 0I 1I 2I 0J 1J 2J 0K 1K 2K 0L)
+    vinserti128 ymmC, ymmC, xmmB, 0  ; ymmC=(1L 2L 0M 1M 2M 0N 1N 2N 0O 1O 2O 0P 1P 2P 0Q 1Q
+                                     ;       15 25 06 16 26 07 17 27 08 18 28 09 19 29 0A 1A)
+    vinserti128 ymmB, ymmB, xmmF, 0  ; ymmB=(2A 0B 1B 2B 0C 1C 2C 0D 1D 2D 0E 1E 2E 0F 1F 2F
+                                     ;       2Q 0R 1R 2R 0S 1S 2S 0T 1T 2T 0U 1U 2U 0V 1V 2V)
+    vperm2i128  ymmF, ymmC, ymmC, 1  ; ymmF=(15 25 06 16 26 07 17 27 08 18 28 09 19 29 0A 1A
+                                     ;       1L 2L 0M 1M 2M 0N 1N 2N 0O 1O 2O 0P 1P 2P 0Q 1Q)
+
+    vmovdqa     ymmG, ymmA
+    vpslldq     ymmA, ymmA, 8     ; ymmA=(-- -- -- -- -- -- -- -- 00 10 20 01 11 21 02 12
+                                  ;       22 03 13 23 04 14 24 05 0G 1G 2G 0H 1H 2H 0I 1I)
+    vpsrldq     ymmG, ymmG, 8     ; ymmG=(22 03 13 23 04 14 24 05 0G 1G 2G 0H 1H 2H 0I 1I
+                                  ;       2I 0J 1J 2J 0K 1K 2K 0L -- -- -- -- -- -- -- --)
+
+    vpunpckhbw  ymmA, ymmA, ymmF  ; ymmA=(00 08 10 18 20 28 01 09 11 19 21 29 02 0A 12 1A
+                                  ;       0G 0O 1G 1O 2G 2O 0H 0P 1H 1P 2H 2P 0I 0Q 1I 1Q)
+    vpslldq     ymmF, ymmF, 8     ; ymmF=(-- -- -- -- -- -- -- -- 15 25 06 16 26 07 17 27
+                                  ;       08 18 28 09 19 29 0A 1A 1L 2L 0M 1M 2M 0N 1N 2N)
+
+    vpunpcklbw  ymmG, ymmG, ymmB  ; ymmG=(22 2A 03 0B 13 1B 23 2B 04 0C 14 1C 24 2C 05 0D
+                                  ;       2I 2Q 0J 0R 1J 1R 2J 2R 0K 0S 1K 1S 2K 2S 0L 0T)
+    vpunpckhbw  ymmF, ymmF, ymmB  ; ymmF=(15 1D 25 2D 06 0E 16 1E 26 2E 07 0F 17 1F 27 2F
+                                  ;       1L 1T 2L 2T 0M 0U 1M 1U 2M 2U 0N 0V 1N 1V 2N 2V)
+
+    vmovdqa     ymmD, ymmA
+    vpslldq     ymmA, ymmA, 8     ; ymmA=(-- -- -- -- -- -- -- -- 00 08 10 18 20 28 01 09
+                                  ;       11 19 21 29 02 0A 12 1A 0G 0O 1G 1O 2G 2O 0H 0P)
+    vpsrldq     ymmD, ymmD, 8     ; ymmD=(11 19 21 29 02 0A 12 1A 0G 0O 1G 1O 2G 2O 0H 0P
+                                  ;       1H 1P 2H 2P 0I 0Q 1I 1Q -- -- -- -- -- -- -- --)
+
+    vpunpckhbw  ymmA, ymmA, ymmG  ; ymmA=(00 04 08 0C 10 14 18 1C 20 24 28 2C 01 05 09 0D
+                                  ;       0G 0K 0O 0S 1G 1K 1O 1S 2G 2K 2O 2S 0H 0L 0P 0T)
+    vpslldq     ymmG, ymmG, 8     ; ymmG=(-- -- -- -- -- -- -- -- 22 2A 03 0B 13 1B 23 2B
+                                  ;       04 0C 14 1C 24 2C 05 0D 2I 2Q 0J 0R 1J 1R 2J 2R)
+
+    vpunpcklbw  ymmD, ymmD, ymmF  ; ymmD=(11 15 19 1D 21 25 29 2D 02 06 0A 0E 12 16 1A 1E
+                                  ;       1H 1L 1P 1T 2H 2L 2P 2T 0I 0M 0Q 0U 1I 1M 1Q 1U)
+    vpunpckhbw  ymmG, ymmG, ymmF  ; ymmG=(22 26 2A 2E 03 07 0B 0F 13 17 1B 1F 23 27 2B 2F
+                                  ;       2I 2M 2Q 2U 0J 0N 0R 0V 1J 1N 1R 1V 2J 2N 2R 2V)
+
+    vmovdqa     ymmE, ymmA
+    vpslldq     ymmA, ymmA, 8     ; ymmA=(-- -- -- -- -- -- -- -- 00 04 08 0C 10 14 18 1C
+                                  ;       20 24 28 2C 01 05 09 0D 0G 0K 0O 0S 1G 1K 1O 1S)
+    vpsrldq     ymmE, ymmE, 8     ; ymmE=(20 24 28 2C 01 05 09 0D 0G 0K 0O 0S 1G 1K 1O 1S
+                                  ;       2G 2K 2O 2S 0H 0L 0P 0T -- -- -- -- -- -- -- --)
+
+    vpunpckhbw  ymmA, ymmA, ymmD  ; ymmA=(00 02 04 06 08 0A 0C 0E 10 12 14 16 18 1A 1C 1E
+                                  ;       0G 0I 0K 0M 0O 0Q 0S 0U 1G 1I 1K 1M 1O 1Q 1S 1U)
+    vpslldq     ymmD, ymmD, 8     ; ymmD=(-- -- -- -- -- -- -- -- 11 15 19 1D 21 25 29 2D
+                                  ;       02 06 0A 0E 12 16 1A 1E 1H 1L 1P 1T 2H 2L 2P 2T)
+
+    vpunpcklbw  ymmE, ymmE, ymmG  ; ymmE=(20 22 24 26 28 2A 2C 2E 01 03 05 07 09 0B 0D 0F
+                                  ;       2G 2I 2K 2M 2O 2Q 2S 2U 0H 0J 0L 0N 0P 0R 0T 0V)
+    vpunpckhbw  ymmD, ymmD, ymmG  ; ymmD=(11 13 15 17 19 1B 1D 1F 21 23 25 27 29 2B 2D 2F
+                                  ;       1H 1J 1L 1N 1P 1R 1T 1V 2H 2J 2L 2N 2P 2R 2T 2V)
+
+    vpxor       ymmH, ymmH, ymmH
+
+    vmovdqa     ymmC, ymmA
+    vpunpcklbw  ymmA, ymmA, ymmH  ; ymmA=(00 02 04 06 08 0A 0C 0E 0G 0I 0K 0M 0O 0Q 0S 0U)
+    vpunpckhbw  ymmC, ymmC, ymmH  ; ymmC=(10 12 14 16 18 1A 1C 1E 1G 1I 1K 1M 1O 1Q 1S 1U)
+
+    vmovdqa     ymmB, ymmE
+    vpunpcklbw  ymmE, ymmE, ymmH  ; ymmE=(20 22 24 26 28 2A 2C 2E 2G 2I 2K 2M 2O 2Q 2S 2U)
+    vpunpckhbw  ymmB, ymmB, ymmH  ; ymmB=(01 03 05 07 09 0B 0D 0F 0H 0J 0L 0N 0P 0R 0T 0V)
+
+    vmovdqa     ymmF, ymmD
+    vpunpcklbw  ymmD, ymmD, ymmH  ; ymmD=(11 13 15 17 19 1B 1D 1F 1H 1J 1L 1N 1P 1R 1T 1V)
+    vpunpckhbw  ymmF, ymmF, ymmH  ; ymmF=(21 23 25 27 29 2B 2D 2F 2H 2J 2L 2N 2P 2R 2T 2V)
+
+%else  ; RGB_PIXELSIZE == 4 ; -----------
+
+.column_ld1:
+    test        cl, SIZEOF_XMMWORD/16
+    jz          short .column_ld2
+    sub         ecx, byte SIZEOF_XMMWORD/16
+    vmovd       xmmA, XMM_DWORD [esi+ecx*RGB_PIXELSIZE]
+.column_ld2:
+    test        cl, SIZEOF_XMMWORD/8
+    jz          short .column_ld4
+    sub         ecx, byte SIZEOF_XMMWORD/8
+    vmovq       xmmF, XMM_MMWORD [esi+ecx*RGB_PIXELSIZE]
+    vpslldq     xmmA, xmmA, SIZEOF_MMWORD
+    vpor        xmmA, xmmA, xmmF
+.column_ld4:
+    test        cl, SIZEOF_XMMWORD/4
+    jz          short .column_ld8
+    sub         ecx, byte SIZEOF_XMMWORD/4
+    vmovdqa     xmmF, xmmA
+    vperm2i128  ymmF, ymmF, ymmF, 1
+    vmovdqu     xmmA, XMMWORD [esi+ecx*RGB_PIXELSIZE]
+    vpor        ymmA, ymmA, ymmF
+.column_ld8:
+    test        cl, SIZEOF_XMMWORD/2
+    jz          short .column_ld16
+    sub         ecx, byte SIZEOF_XMMWORD/2
+    vmovdqa     ymmF, ymmA
+    vmovdqu     ymmA, YMMWORD [esi+ecx*RGB_PIXELSIZE]
+.column_ld16:
+    test        cl, SIZEOF_XMMWORD
+    mov         ecx, SIZEOF_YMMWORD
+    jz          short .rgb_ycc_cnv
+    vmovdqa     ymmE, ymmA
+    vmovdqa     ymmH, ymmF
+    vmovdqu     ymmA, YMMWORD [esi+0*SIZEOF_YMMWORD]
+    vmovdqu     ymmF, YMMWORD [esi+1*SIZEOF_YMMWORD]
+    jmp         short .rgb_ycc_cnv
+    alignx      16, 7
+
+.columnloop:
+    vmovdqu     ymmA, YMMWORD [esi+0*SIZEOF_YMMWORD]
+    vmovdqu     ymmF, YMMWORD [esi+1*SIZEOF_YMMWORD]
+    vmovdqu     ymmE, YMMWORD [esi+2*SIZEOF_YMMWORD]
+    vmovdqu     ymmH, YMMWORD [esi+3*SIZEOF_YMMWORD]
+
+.rgb_ycc_cnv:
+    ; ymmA=(00 10 20 30 01 11 21 31 02 12 22 32 03 13 23 33
+    ;       04 14 24 34 05 15 25 35 06 16 26 36 07 17 27 37)
+    ; ymmF=(08 18 28 38 09 19 29 39 0A 1A 2A 3A 0B 1B 2B 3B
+    ;       0C 1C 2C 3C 0D 1D 2D 3D 0E 1E 2E 3E 0F 1F 2F 3F)
+    ; ymmE=(0G 1G 2G 3G 0H 1H 2H 3H 0I 1I 2I 3I 0J 1J 2J 3J
+    ;       0K 1K 2K 3K 0L 1L 2L 3L 0M 1M 2M 3M 0N 1N 2N 3N)
+    ; ymmH=(0O 1O 2O 3O 0P 1P 2P 3P 0Q 1Q 2Q 3Q 0R 1R 2R 3R
+    ;       0S 1S 2S 3S 0T 1T 2T 3T 0U 1U 2U 3U 0V 1V 2V 3V)
+
+    vmovdqa     ymmB, ymmA
+    vinserti128 ymmA, ymmA, xmmE, 1     ; ymmA=(00 10 20 30 01 11 21 31 02 12 22 32 03 13 23 33
+                                        ;       0G 1G 2G 3G 0H 1H 2H 3H 0I 1I 2I 3I 0J 1J 2J 3J)
+    vperm2i128  ymmE, ymmB, ymmE, 0x31  ; ymmE=(04 14 24 34 05 15 25 35 06 16 26 36 07 17 27 37
+                                        ;       0K 1K 2K 3K 0L 1L 2L 3L 0M 1M 2M 3M 0N 1N 2N 3N)
+
+    vmovdqa     ymmB, ymmF
+    vinserti128 ymmF, ymmF, xmmH, 1     ; ymmF=(08 18 28 38 09 19 29 39 0A 1A 2A 3A 0B 1B 2B 3B
+                                        ;       0O 1O 2O 3O 0P 1P 2P 3P 0Q 1Q 2Q 3Q 0R 1R 2R 3R)
+    vperm2i128  ymmH, ymmB, ymmH, 0x31  ; ymmH=(0C 1C 2C 3C 0D 1D 2D 3D 0E 1E 2E 3E 0F 1F 2F 3F
+                                        ;       0S 1S 2S 3S 0T 1T 2T 3T 0U 1U 2U 3U 0V 1V 2V 3V)
+
+    vmovdqa     ymmD, ymmA
+    vpunpcklbw  ymmA, ymmA, ymmE      ; ymmA=(00 04 10 14 20 24 30 34 01 05 11 15 21 25 31 35
+                                      ;       0G 0K 1G 1K 2G 2K 3G 3K 0H 0L 1H 1L 2H 2L 3H 3L)
+    vpunpckhbw  ymmD, ymmD, ymmE      ; ymmD=(02 06 12 16 22 26 32 36 03 07 13 17 23 27 33 37
+                                      ;       0I 0M 1I 1M 2I 2M 3I 3M 0J 0N 1J 1N 2J 2N 3J 3N)
+
+    vmovdqa     ymmC, ymmF
+    vpunpcklbw  ymmF, ymmF, ymmH      ; ymmF=(08 0C 18 1C 28 2C 38 3C 09 0D 19 1D 29 2D 39 3D
+                                      ;       0O 0S 1O 1S 2O 2S 3O 3S 0P 0T 1P 1T 2P 2T 3P 3T)
+    vpunpckhbw  ymmC, ymmC, ymmH      ; ymmC=(0A 0E 1A 1E 2A 2E 3A 3E 0B 0F 1B 1F 2B 2F 3B 3F
+                                      ;       0Q 0U 1Q 1U 2Q 2U 3Q 3U 0R 0V 1R 1V 2R 2V 3R 3V)
+
+    vmovdqa     ymmB, ymmA
+    vpunpcklwd  ymmA, ymmA, ymmF      ; ymmA=(00 04 08 0C 10 14 18 1C 20 24 28 2C 30 34 38 3C
+                                      ;       0G 0K 0O 0S 1G 1K 1O 1S 2G 2K 2O 2S 3G 3K 3O 3S)
+    vpunpckhwd  ymmB, ymmB, ymmF      ; ymmB=(01 05 09 0D 11 15 19 1D 21 25 29 2D 31 35 39 3D
+                                      ;       0H 0L 0P 0T 1H 1L 1P 1T 2H 2L 2P 2T 3H 3L 3P 3T)
+
+    vmovdqa     ymmG, ymmD
+    vpunpcklwd  ymmD, ymmD, ymmC      ; ymmD=(02 06 0A 0E 12 16 1A 1E 22 26 2A 2E 32 36 3A 3E
+                                      ;       0I 0M 0Q 0U 1I 1M 1Q 1U 2I 2M 2Q 2U 3I 3M 3Q 3U)
+    vpunpckhwd  ymmG, ymmG, ymmC      ; ymmG=(03 07 0B 0F 13 17 1B 1F 23 27 2B 2F 33 37 3B 3F
+                                      ;       0J 0N 0R 0V 1J 1N 1R 1V 2J 2N 2R 2V 3J 3N 3R 3V)
+
+    vmovdqa     ymmE, ymmA
+    vpunpcklbw  ymmA, ymmA, ymmD      ; ymmA=(00 02 04 06 08 0A 0C 0E 10 12 14 16 18 1A 1C 1E
+                                      ;       0G 0I 0K 0M 0O 0Q 0S 0U 1G 1I 1K 1M 1O 1Q 1S 1U)
+    vpunpckhbw  ymmE, ymmE, ymmD      ; ymmE=(20 22 24 26 28 2A 2C 2E 30 32 34 36 38 3A 3C 3E
+                                      ;       2G 2I 2K 2M 2O 2Q 2S 2U 3G 3I 3K 3M 3O 3Q 3S 3U)
+
+    vmovdqa     ymmH, ymmB
+    vpunpcklbw  ymmB, ymmB, ymmG      ; ymmB=(01 03 05 07 09 0B 0D 0F 11 13 15 17 19 1B 1D 1F
+                                      ;       0H 0J 0L 0N 0P 0R 0T 0V 1H 1J 1L 1N 1P 1R 1T 1V)
+    vpunpckhbw  ymmH, ymmH, ymmG      ; ymmH=(21 23 25 27 29 2B 2D 2F 31 33 35 37 39 3B 3D 3F
+                                      ;       2H 2J 2L 2N 2P 2R 2T 2V 3H 3J 3L 3N 3P 3R 3T 3V)
+
+    vpxor       ymmF, ymmF, ymmF
+
+    vmovdqa     ymmC, ymmA
+    vpunpcklbw  ymmA, ymmA, ymmF      ; ymmA=(00 02 04 06 08 0A 0C 0E 0G 0I 0K 0M 0O 0Q 0S 0U)
+    vpunpckhbw  ymmC, ymmC, ymmF      ; ymmC=(10 12 14 16 18 1A 1C 1E 1G 1I 1K 1M 1O 1Q 1S 1U)
+
+    vmovdqa     ymmD, ymmB
+    vpunpcklbw  ymmB, ymmB, ymmF      ; ymmB=(01 03 05 07 09 0B 0D 0F 0H 0J 0L 0N 0P 0R 0T 0V)
+    vpunpckhbw  ymmD, ymmD, ymmF      ; ymmD=(11 13 15 17 19 1B 1D 1F 1H 1J 1L 1N 1P 1R 1T 1V)
+
+    vmovdqa     ymmG, ymmE
+    vpunpcklbw  ymmE, ymmE, ymmF      ; ymmE=(20 22 24 26 28 2A 2C 2E 2G 2I 2K 2M 2O 2Q 2S 2U)
+    vpunpckhbw  ymmG, ymmG, ymmF      ; ymmG=(30 32 34 36 38 3A 3C 3E 3G 3I 3K 3M 3O 3Q 3S 3U)
+
+    vpunpcklbw  ymmF, ymmF, ymmH
+    vpunpckhbw  ymmH, ymmH, ymmH
+    vpsrlw      ymmF, ymmF, BYTE_BIT  ; ymmF=(21 23 25 27 29 2B 2D 2F 2H 2J 2L 2N 2P 2R 2T 2V)
+    vpsrlw      ymmH, ymmH, BYTE_BIT  ; ymmH=(31 33 35 37 39 3B 3D 3F 3H 3J 3L 3N 3P 3R 3T 3V)
+
+%endif  ; RGB_PIXELSIZE ; ---------------
+
+    ; ymm0=R(02468ACEGIKMOQSU)=RE, ymm2=G(02468ACEGIKMOQSU)=GE, ymm4=B(02468ACEGIKMOQSU)=BE
+    ; ymm1=R(13579BDFHJLNPRTV)=RO, ymm3=G(13579BDFHJLNPRTV)=GO, ymm5=B(13579BDFHJLNPRTV)=BO
+
+    ; (Original)
+    ; Y  =  0.29900 * R + 0.58700 * G + 0.11400 * B
+    ; Cb = -0.16874 * R - 0.33126 * G + 0.50000 * B + CENTERJSAMPLE
+    ; Cr =  0.50000 * R - 0.41869 * G - 0.08131 * B + CENTERJSAMPLE
+    ;
+    ; (This implementation)
+    ; Y  =  0.29900 * R + 0.33700 * G + 0.11400 * B + 0.25000 * G
+    ; Cb = -0.16874 * R - 0.33126 * G + 0.50000 * B + CENTERJSAMPLE
+    ; Cr =  0.50000 * R - 0.41869 * G - 0.08131 * B + CENTERJSAMPLE
+
+    vmovdqa     YMMWORD [wk(0)], ymm0   ; wk(0)=RE
+    vmovdqa     YMMWORD [wk(1)], ymm1   ; wk(1)=RO
+    vmovdqa     YMMWORD [wk(2)], ymm4   ; wk(2)=BE
+    vmovdqa     YMMWORD [wk(3)], ymm5   ; wk(3)=BO
+
+    vmovdqa     ymm6, ymm1
+    vpunpcklwd  ymm1, ymm1, ymm3
+    vpunpckhwd  ymm6, ymm6, ymm3
+    vmovdqa     ymm7, ymm1
+    vmovdqa     ymm4, ymm6
+    vpmaddwd    ymm1, ymm1, [GOTOFF(eax,PW_F0299_F0337)]  ; ymm1=ROL*FIX(0.299)+GOL*FIX(0.337)
+    vpmaddwd    ymm6, ymm6, [GOTOFF(eax,PW_F0299_F0337)]  ; ymm6=ROH*FIX(0.299)+GOH*FIX(0.337)
+    vpmaddwd    ymm7, ymm7, [GOTOFF(eax,PW_MF016_MF033)]  ; ymm7=ROL*-FIX(0.168)+GOL*-FIX(0.331)
+    vpmaddwd    ymm4, ymm4, [GOTOFF(eax,PW_MF016_MF033)]  ; ymm4=ROH*-FIX(0.168)+GOH*-FIX(0.331)
+
+    vmovdqa     YMMWORD [wk(4)], ymm1   ; wk(4)=ROL*FIX(0.299)+GOL*FIX(0.337)
+    vmovdqa     YMMWORD [wk(5)], ymm6   ; wk(5)=ROH*FIX(0.299)+GOH*FIX(0.337)
+
+    vpxor       ymm1, ymm1, ymm1
+    vpxor       ymm6, ymm6, ymm6
+    vpunpcklwd  ymm1, ymm1, ymm5        ; ymm1=BOL
+    vpunpckhwd  ymm6, ymm6, ymm5        ; ymm6=BOH
+    vpsrld      ymm1, ymm1, 1           ; ymm1=BOL*FIX(0.500)
+    vpsrld      ymm6, ymm6, 1           ; ymm6=BOH*FIX(0.500)
+
+    vmovdqa     ymm5, [GOTOFF(eax,PD_ONEHALFM1_CJ)]  ; ymm5=[PD_ONEHALFM1_CJ]
+
+    vpaddd      ymm7, ymm7, ymm1
+    vpaddd      ymm4, ymm4, ymm6
+    vpaddd      ymm7, ymm7, ymm5
+    vpaddd      ymm4, ymm4, ymm5
+    vpsrld      ymm7, ymm7, SCALEBITS   ; ymm7=CbOL
+    vpsrld      ymm4, ymm4, SCALEBITS   ; ymm4=CbOH
+    vpackssdw   ymm7, ymm7, ymm4        ; ymm7=CbO
+
+    vmovdqa     ymm1, YMMWORD [wk(2)]   ; ymm1=BE
+
+    vmovdqa     ymm6, ymm0
+    vpunpcklwd  ymm0, ymm0, ymm2
+    vpunpckhwd  ymm6, ymm6, ymm2
+    vmovdqa     ymm5, ymm0
+    vmovdqa     ymm4, ymm6
+    vpmaddwd    ymm0, ymm0, [GOTOFF(eax,PW_F0299_F0337)]  ; ymm0=REL*FIX(0.299)+GEL*FIX(0.337)
+    vpmaddwd    ymm6, ymm6, [GOTOFF(eax,PW_F0299_F0337)]  ; ymm6=REH*FIX(0.299)+GEH*FIX(0.337)
+    vpmaddwd    ymm5, ymm5, [GOTOFF(eax,PW_MF016_MF033)]  ; ymm5=REL*-FIX(0.168)+GEL*-FIX(0.331)
+    vpmaddwd    ymm4, ymm4, [GOTOFF(eax,PW_MF016_MF033)]  ; ymm4=REH*-FIX(0.168)+GEH*-FIX(0.331)
+
+    vmovdqa     YMMWORD [wk(6)], ymm0   ; wk(6)=REL*FIX(0.299)+GEL*FIX(0.337)
+    vmovdqa     YMMWORD [wk(7)], ymm6   ; wk(7)=REH*FIX(0.299)+GEH*FIX(0.337)
+
+    vpxor       ymm0, ymm0, ymm0
+    vpxor       ymm6, ymm6, ymm6
+    vpunpcklwd  ymm0, ymm0, ymm1        ; ymm0=BEL
+    vpunpckhwd  ymm6, ymm6, ymm1        ; ymm6=BEH
+    vpsrld      ymm0, ymm0, 1           ; ymm0=BEL*FIX(0.500)
+    vpsrld      ymm6, ymm6, 1           ; ymm6=BEH*FIX(0.500)
+
+    vmovdqa     ymm1, [GOTOFF(eax,PD_ONEHALFM1_CJ)]  ; ymm1=[PD_ONEHALFM1_CJ]
+
+    vpaddd      ymm5, ymm5, ymm0
+    vpaddd      ymm4, ymm4, ymm6
+    vpaddd      ymm5, ymm5, ymm1
+    vpaddd      ymm4, ymm4, ymm1
+    vpsrld      ymm5, ymm5, SCALEBITS   ; ymm5=CbEL
+    vpsrld      ymm4, ymm4, SCALEBITS   ; ymm4=CbEH
+    vpackssdw   ymm5, ymm5, ymm4        ; ymm5=CbE
+
+    vpsllw      ymm7, ymm7, BYTE_BIT
+    vpor        ymm5, ymm5, ymm7        ; ymm5=Cb
+    vmovdqu     YMMWORD [ebx], ymm5     ; Save Cb
+
+    vmovdqa     ymm0, YMMWORD [wk(3)]   ; ymm0=BO
+    vmovdqa     ymm6, YMMWORD [wk(2)]   ; ymm6=BE
+    vmovdqa     ymm1, YMMWORD [wk(1)]   ; ymm1=RO
+
+    vmovdqa     ymm4, ymm0
+    vpunpcklwd  ymm0, ymm0, ymm3
+    vpunpckhwd  ymm4, ymm4, ymm3
+    vmovdqa     ymm7, ymm0
+    vmovdqa     ymm5, ymm4
+    vpmaddwd    ymm0, ymm0, [GOTOFF(eax,PW_F0114_F0250)]  ; ymm0=BOL*FIX(0.114)+GOL*FIX(0.250)
+    vpmaddwd    ymm4, ymm4, [GOTOFF(eax,PW_F0114_F0250)]  ; ymm4=BOH*FIX(0.114)+GOH*FIX(0.250)
+    vpmaddwd    ymm7, ymm7, [GOTOFF(eax,PW_MF008_MF041)]  ; ymm7=BOL*-FIX(0.081)+GOL*-FIX(0.418)
+    vpmaddwd    ymm5, ymm5, [GOTOFF(eax,PW_MF008_MF041)]  ; ymm5=BOH*-FIX(0.081)+GOH*-FIX(0.418)
+
+    vmovdqa     ymm3, [GOTOFF(eax,PD_ONEHALF)]            ; ymm3=[PD_ONEHALF]
+
+    vpaddd      ymm0, ymm0, YMMWORD [wk(4)]
+    vpaddd      ymm4, ymm4, YMMWORD [wk(5)]
+    vpaddd      ymm0, ymm0, ymm3
+    vpaddd      ymm4, ymm4, ymm3
+    vpsrld      ymm0, ymm0, SCALEBITS   ; ymm0=YOL
+    vpsrld      ymm4, ymm4, SCALEBITS   ; ymm4=YOH
+    vpackssdw   ymm0, ymm0, ymm4        ; ymm0=YO
+
+    vpxor       ymm3, ymm3, ymm3
+    vpxor       ymm4, ymm4, ymm4
+    vpunpcklwd  ymm3, ymm3, ymm1        ; ymm3=ROL
+    vpunpckhwd  ymm4, ymm4, ymm1        ; ymm4=ROH
+    vpsrld      ymm3, ymm3, 1           ; ymm3=ROL*FIX(0.500)
+    vpsrld      ymm4, ymm4, 1           ; ymm4=ROH*FIX(0.500)
+
+    vmovdqa     ymm1, [GOTOFF(eax,PD_ONEHALFM1_CJ)]  ; ymm1=[PD_ONEHALFM1_CJ]
+
+    vpaddd      ymm7, ymm7, ymm3
+    vpaddd      ymm5, ymm5, ymm4
+    vpaddd      ymm7, ymm7, ymm1
+    vpaddd      ymm5, ymm5, ymm1
+    vpsrld      ymm7, ymm7, SCALEBITS   ; ymm7=CrOL
+    vpsrld      ymm5, ymm5, SCALEBITS   ; ymm5=CrOH
+    vpackssdw   ymm7, ymm7, ymm5        ; ymm7=CrO
+
+    vmovdqa     ymm3, YMMWORD [wk(0)]   ; ymm3=RE
+
+    vmovdqa     ymm4, ymm6
+    vpunpcklwd  ymm6, ymm6, ymm2
+    vpunpckhwd  ymm4, ymm4, ymm2
+    vmovdqa     ymm1, ymm6
+    vmovdqa     ymm5, ymm4
+    vpmaddwd    ymm6, ymm6, [GOTOFF(eax,PW_F0114_F0250)]  ; ymm6=BEL*FIX(0.114)+GEL*FIX(0.250)
+    vpmaddwd    ymm4, ymm4, [GOTOFF(eax,PW_F0114_F0250)]  ; ymm4=BEH*FIX(0.114)+GEH*FIX(0.250)
+    vpmaddwd    ymm1, ymm1, [GOTOFF(eax,PW_MF008_MF041)]  ; ymm1=BEL*-FIX(0.081)+GEL*-FIX(0.418)
+    vpmaddwd    ymm5, ymm5, [GOTOFF(eax,PW_MF008_MF041)]  ; ymm5=BEH*-FIX(0.081)+GEH*-FIX(0.418)
+
+    vmovdqa     ymm2, [GOTOFF(eax,PD_ONEHALF)]            ; ymm2=[PD_ONEHALF]
+
+    vpaddd      ymm6, ymm6, YMMWORD [wk(6)]
+    vpaddd      ymm4, ymm4, YMMWORD [wk(7)]
+    vpaddd      ymm6, ymm6, ymm2
+    vpaddd      ymm4, ymm4, ymm2
+    vpsrld      ymm6, ymm6, SCALEBITS   ; ymm6=YEL
+    vpsrld      ymm4, ymm4, SCALEBITS   ; ymm4=YEH
+    vpackssdw   ymm6, ymm6, ymm4        ; ymm6=YE
+
+    vpsllw      ymm0, ymm0, BYTE_BIT
+    vpor        ymm6, ymm6, ymm0        ; ymm6=Y
+    vmovdqu     YMMWORD [edi], ymm6     ; Save Y
+
+    vpxor       ymm2, ymm2, ymm2
+    vpxor       ymm4, ymm4, ymm4
+    vpunpcklwd  ymm2, ymm2, ymm3        ; ymm2=REL
+    vpunpckhwd  ymm4, ymm4, ymm3        ; ymm4=REH
+    vpsrld      ymm2, ymm2, 1           ; ymm2=REL*FIX(0.500)
+    vpsrld      ymm4, ymm4, 1           ; ymm4=REH*FIX(0.500)
+
+    vmovdqa     ymm0, [GOTOFF(eax,PD_ONEHALFM1_CJ)]  ; ymm0=[PD_ONEHALFM1_CJ]
+
+    vpaddd      ymm1, ymm1, ymm2
+    vpaddd      ymm5, ymm5, ymm4
+    vpaddd      ymm1, ymm1, ymm0
+    vpaddd      ymm5, ymm5, ymm0
+    vpsrld      ymm1, ymm1, SCALEBITS   ; ymm1=CrEL
+    vpsrld      ymm5, ymm5, SCALEBITS   ; ymm5=CrEH
+    vpackssdw   ymm1, ymm1, ymm5        ; ymm1=CrE
+
+    vpsllw      ymm7, ymm7, BYTE_BIT
+    vpor        ymm1, ymm1, ymm7        ; ymm1=Cr
+    vmovdqu     YMMWORD [edx], ymm1     ; Save Cr
+
+    sub         ecx, byte SIZEOF_YMMWORD
+    add         esi, RGB_PIXELSIZE*SIZEOF_YMMWORD  ; inptr
+    add         edi, byte SIZEOF_YMMWORD           ; outptr0
+    add         ebx, byte SIZEOF_YMMWORD           ; outptr1
+    add         edx, byte SIZEOF_YMMWORD           ; outptr2
+    cmp         ecx, byte SIZEOF_YMMWORD
+    jae         near .columnloop
+    test        ecx, ecx
+    jnz         near .column_ld1
+
+    pop         ecx                     ; col
+    pop         esi
+    pop         edi
+    pop         ebx
+    pop         edx
+    poppic      eax
+
+    add         esi, byte SIZEOF_JSAMPROW  ; input_buf
+    add         edi, byte SIZEOF_JSAMPROW
+    add         ebx, byte SIZEOF_JSAMPROW
+    add         edx, byte SIZEOF_JSAMPROW
+    dec         eax                        ; num_rows
+    jg          near .rowloop
+
+.return:
+    vzeroupper
+    pop         edi
+    pop         esi
+;   pop         edx                     ; need not be preserved
+;   pop         ecx                     ; need not be preserved
+    pop         ebx
+    mov         esp, ebp                ; esp <- aligned ebp
+    pop         esp                     ; esp <- original ebp
+    pop         ebp
+    ret
+
+; For some reason, the OS X linker does not honor the request to align the
+; segment unless we do this.
+    align       32
diff --git a/3rdparty/libjpeg/src/simd/i386/jccolext-mmx.asm b/3rdparty/libjpeg/src/simd/i386/jccolext-mmx.asm
new file mode 100644
index 00000000..6357a42b
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/i386/jccolext-mmx.asm
@@ -0,0 +1,476 @@
+;
+; jccolext.asm - colorspace conversion (MMX)
+;
+; Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+; Copyright (C) 2016, D. R. Commander.
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+;
+; This file should be assembled with NASM (Netwide Assembler),
+; can *not* be assembled with Microsoft's MASM or any compatible
+; assembler (including Borland's Turbo Assembler).
+; NASM is available from http://nasm.sourceforge.net/ or
+; http://sourceforge.net/project/showfiles.php?group_id=6208
+
+%include "jcolsamp.inc"
+
+; --------------------------------------------------------------------------
+;
+; Convert some rows of samples to the output colorspace.
+;
+; GLOBAL(void)
+; jsimd_rgb_ycc_convert_mmx(JDIMENSION img_width, JSAMPARRAY input_buf,
+;                           JSAMPIMAGE output_buf, JDIMENSION output_row,
+;                           int num_rows);
+;
+
+%define img_width(b)   (b) + 8          ; JDIMENSION img_width
+%define input_buf(b)   (b) + 12         ; JSAMPARRAY input_buf
+%define output_buf(b)  (b) + 16         ; JSAMPIMAGE output_buf
+%define output_row(b)  (b) + 20         ; JDIMENSION output_row
+%define num_rows(b)    (b) + 24         ; int num_rows
+
+%define original_ebp   ebp + 0
+%define wk(i)          ebp - (WK_NUM - (i)) * SIZEOF_MMWORD
+                                        ; mmword wk[WK_NUM]
+%define WK_NUM         8
+%define gotptr         wk(0) - SIZEOF_POINTER  ; void * gotptr
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_rgb_ycc_convert_mmx)
+
+EXTN(jsimd_rgb_ycc_convert_mmx):
+    push        ebp
+    mov         eax, esp                    ; eax = original ebp
+    sub         esp, byte 4
+    and         esp, byte (-SIZEOF_MMWORD)  ; align to 64 bits
+    mov         [esp], eax
+    mov         ebp, esp                    ; ebp = aligned ebp
+    lea         esp, [wk(0)]
+    pushpic     eax                     ; make a room for GOT address
+    push        ebx
+;   push        ecx                     ; need not be preserved
+;   push        edx                     ; need not be preserved
+    push        esi
+    push        edi
+
+    get_GOT     ebx                     ; get GOT address
+    movpic      POINTER [gotptr], ebx   ; save GOT address
+
+    mov         ecx, JDIMENSION [img_width(eax)]  ; num_cols
+    test        ecx, ecx
+    jz          near .return
+
+    push        ecx
+
+    mov         esi, JSAMPIMAGE [output_buf(eax)]
+    mov         ecx, JDIMENSION [output_row(eax)]
+    mov         edi, JSAMPARRAY [esi+0*SIZEOF_JSAMPARRAY]
+    mov         ebx, JSAMPARRAY [esi+1*SIZEOF_JSAMPARRAY]
+    mov         edx, JSAMPARRAY [esi+2*SIZEOF_JSAMPARRAY]
+    lea         edi, [edi+ecx*SIZEOF_JSAMPROW]
+    lea         ebx, [ebx+ecx*SIZEOF_JSAMPROW]
+    lea         edx, [edx+ecx*SIZEOF_JSAMPROW]
+
+    pop         ecx
+
+    mov         esi, JSAMPARRAY [input_buf(eax)]
+    mov         eax, INT [num_rows(eax)]
+    test        eax, eax
+    jle         near .return
+    alignx      16, 7
+.rowloop:
+    pushpic     eax
+    push        edx
+    push        ebx
+    push        edi
+    push        esi
+    push        ecx                     ; col
+
+    mov         esi, JSAMPROW [esi]     ; inptr
+    mov         edi, JSAMPROW [edi]     ; outptr0
+    mov         ebx, JSAMPROW [ebx]     ; outptr1
+    mov         edx, JSAMPROW [edx]     ; outptr2
+    movpic      eax, POINTER [gotptr]   ; load GOT address (eax)
+
+    cmp         ecx, byte SIZEOF_MMWORD
+    jae         short .columnloop
+    alignx      16, 7
+
+%if RGB_PIXELSIZE == 3  ; ---------------
+
+.column_ld1:
+    push        eax
+    push        edx
+    lea         ecx, [ecx+ecx*2]        ; imul ecx,RGB_PIXELSIZE
+    test        cl, SIZEOF_BYTE
+    jz          short .column_ld2
+    sub         ecx, byte SIZEOF_BYTE
+    xor         eax, eax
+    mov         al, byte [esi+ecx]
+.column_ld2:
+    test        cl, SIZEOF_WORD
+    jz          short .column_ld4
+    sub         ecx, byte SIZEOF_WORD
+    xor         edx, edx
+    mov         dx, word [esi+ecx]
+    shl         eax, WORD_BIT
+    or          eax, edx
+.column_ld4:
+    movd        mmA, eax
+    pop         edx
+    pop         eax
+    test        cl, SIZEOF_DWORD
+    jz          short .column_ld8
+    sub         ecx, byte SIZEOF_DWORD
+    movd        mmG, dword [esi+ecx]
+    psllq       mmA, DWORD_BIT
+    por         mmA, mmG
+.column_ld8:
+    test        cl, SIZEOF_MMWORD
+    jz          short .column_ld16
+    movq        mmG, mmA
+    movq        mmA, MMWORD [esi+0*SIZEOF_MMWORD]
+    mov         ecx, SIZEOF_MMWORD
+    jmp         short .rgb_ycc_cnv
+.column_ld16:
+    test        cl, 2*SIZEOF_MMWORD
+    mov         ecx, SIZEOF_MMWORD
+    jz          short .rgb_ycc_cnv
+    movq        mmF, mmA
+    movq        mmA, MMWORD [esi+0*SIZEOF_MMWORD]
+    movq        mmG, MMWORD [esi+1*SIZEOF_MMWORD]
+    jmp         short .rgb_ycc_cnv
+    alignx      16, 7
+
+.columnloop:
+    movq        mmA, MMWORD [esi+0*SIZEOF_MMWORD]
+    movq        mmG, MMWORD [esi+1*SIZEOF_MMWORD]
+    movq        mmF, MMWORD [esi+2*SIZEOF_MMWORD]
+
+.rgb_ycc_cnv:
+    ; mmA=(00 10 20 01 11 21 02 12)
+    ; mmG=(22 03 13 23 04 14 24 05)
+    ; mmF=(15 25 06 16 26 07 17 27)
+
+    movq        mmD, mmA
+    psllq       mmA, 4*BYTE_BIT         ; mmA=(-- -- -- -- 00 10 20 01)
+    psrlq       mmD, 4*BYTE_BIT         ; mmD=(11 21 02 12 -- -- -- --)
+
+    punpckhbw   mmA, mmG                ; mmA=(00 04 10 14 20 24 01 05)
+    psllq       mmG, 4*BYTE_BIT         ; mmG=(-- -- -- -- 22 03 13 23)
+
+    punpcklbw   mmD, mmF                ; mmD=(11 15 21 25 02 06 12 16)
+    punpckhbw   mmG, mmF                ; mmG=(22 26 03 07 13 17 23 27)
+
+    movq        mmE, mmA
+    psllq       mmA, 4*BYTE_BIT         ; mmA=(-- -- -- -- 00 04 10 14)
+    psrlq       mmE, 4*BYTE_BIT         ; mmE=(20 24 01 05 -- -- -- --)
+
+    punpckhbw   mmA, mmD                ; mmA=(00 02 04 06 10 12 14 16)
+    psllq       mmD, 4*BYTE_BIT         ; mmD=(-- -- -- -- 11 15 21 25)
+
+    punpcklbw   mmE, mmG                ; mmE=(20 22 24 26 01 03 05 07)
+    punpckhbw   mmD, mmG                ; mmD=(11 13 15 17 21 23 25 27)
+
+    pxor        mmH, mmH
+
+    movq        mmC, mmA
+    punpcklbw   mmA, mmH                ; mmA=(00 02 04 06)
+    punpckhbw   mmC, mmH                ; mmC=(10 12 14 16)
+
+    movq        mmB, mmE
+    punpcklbw   mmE, mmH                ; mmE=(20 22 24 26)
+    punpckhbw   mmB, mmH                ; mmB=(01 03 05 07)
+
+    movq        mmF, mmD
+    punpcklbw   mmD, mmH                ; mmD=(11 13 15 17)
+    punpckhbw   mmF, mmH                ; mmF=(21 23 25 27)
+
+%else  ; RGB_PIXELSIZE == 4 ; -----------
+
+.column_ld1:
+    test        cl, SIZEOF_MMWORD/8
+    jz          short .column_ld2
+    sub         ecx, byte SIZEOF_MMWORD/8
+    movd        mmA, dword [esi+ecx*RGB_PIXELSIZE]
+.column_ld2:
+    test        cl, SIZEOF_MMWORD/4
+    jz          short .column_ld4
+    sub         ecx, byte SIZEOF_MMWORD/4
+    movq        mmF, mmA
+    movq        mmA, MMWORD [esi+ecx*RGB_PIXELSIZE]
+.column_ld4:
+    test        cl, SIZEOF_MMWORD/2
+    mov         ecx, SIZEOF_MMWORD
+    jz          short .rgb_ycc_cnv
+    movq        mmD, mmA
+    movq        mmC, mmF
+    movq        mmA, MMWORD [esi+0*SIZEOF_MMWORD]
+    movq        mmF, MMWORD [esi+1*SIZEOF_MMWORD]
+    jmp         short .rgb_ycc_cnv
+    alignx      16, 7
+
+.columnloop:
+    movq        mmA, MMWORD [esi+0*SIZEOF_MMWORD]
+    movq        mmF, MMWORD [esi+1*SIZEOF_MMWORD]
+    movq        mmD, MMWORD [esi+2*SIZEOF_MMWORD]
+    movq        mmC, MMWORD [esi+3*SIZEOF_MMWORD]
+
+.rgb_ycc_cnv:
+    ; mmA=(00 10 20 30 01 11 21 31)
+    ; mmF=(02 12 22 32 03 13 23 33)
+    ; mmD=(04 14 24 34 05 15 25 35)
+    ; mmC=(06 16 26 36 07 17 27 37)
+
+    movq        mmB, mmA
+    punpcklbw   mmA, mmF                ; mmA=(00 02 10 12 20 22 30 32)
+    punpckhbw   mmB, mmF                ; mmB=(01 03 11 13 21 23 31 33)
+
+    movq        mmG, mmD
+    punpcklbw   mmD, mmC                ; mmD=(04 06 14 16 24 26 34 36)
+    punpckhbw   mmG, mmC                ; mmG=(05 07 15 17 25 27 35 37)
+
+    movq        mmE, mmA
+    punpcklwd   mmA, mmD                ; mmA=(00 02 04 06 10 12 14 16)
+    punpckhwd   mmE, mmD                ; mmE=(20 22 24 26 30 32 34 36)
+
+    movq        mmH, mmB
+    punpcklwd   mmB, mmG                ; mmB=(01 03 05 07 11 13 15 17)
+    punpckhwd   mmH, mmG                ; mmH=(21 23 25 27 31 33 35 37)
+
+    pxor        mmF, mmF
+
+    movq        mmC, mmA
+    punpcklbw   mmA, mmF                ; mmA=(00 02 04 06)
+    punpckhbw   mmC, mmF                ; mmC=(10 12 14 16)
+
+    movq        mmD, mmB
+    punpcklbw   mmB, mmF                ; mmB=(01 03 05 07)
+    punpckhbw   mmD, mmF                ; mmD=(11 13 15 17)
+
+    movq        mmG, mmE
+    punpcklbw   mmE, mmF                ; mmE=(20 22 24 26)
+    punpckhbw   mmG, mmF                ; mmG=(30 32 34 36)
+
+    punpcklbw   mmF, mmH
+    punpckhbw   mmH, mmH
+    psrlw       mmF, BYTE_BIT           ; mmF=(21 23 25 27)
+    psrlw       mmH, BYTE_BIT           ; mmH=(31 33 35 37)
+
+%endif  ; RGB_PIXELSIZE ; ---------------
+
+    ; mm0=(R0 R2 R4 R6)=RE, mm2=(G0 G2 G4 G6)=GE, mm4=(B0 B2 B4 B6)=BE
+    ; mm1=(R1 R3 R5 R7)=RO, mm3=(G1 G3 G5 G7)=GO, mm5=(B1 B3 B5 B7)=BO
+
+    ; (Original)
+    ; Y  =  0.29900 * R + 0.58700 * G + 0.11400 * B
+    ; Cb = -0.16874 * R - 0.33126 * G + 0.50000 * B + CENTERJSAMPLE
+    ; Cr =  0.50000 * R - 0.41869 * G - 0.08131 * B + CENTERJSAMPLE
+    ;
+    ; (This implementation)
+    ; Y  =  0.29900 * R + 0.33700 * G + 0.11400 * B + 0.25000 * G
+    ; Cb = -0.16874 * R - 0.33126 * G + 0.50000 * B + CENTERJSAMPLE
+    ; Cr =  0.50000 * R - 0.41869 * G - 0.08131 * B + CENTERJSAMPLE
+
+    movq        MMWORD [wk(0)], mm0     ; wk(0)=RE
+    movq        MMWORD [wk(1)], mm1     ; wk(1)=RO
+    movq        MMWORD [wk(2)], mm4     ; wk(2)=BE
+    movq        MMWORD [wk(3)], mm5     ; wk(3)=BO
+
+    movq        mm6, mm1
+    punpcklwd   mm1, mm3
+    punpckhwd   mm6, mm3
+    movq        mm7, mm1
+    movq        mm4, mm6
+    pmaddwd     mm1, [GOTOFF(eax,PW_F0299_F0337)]  ; mm1=ROL*FIX(0.299)+GOL*FIX(0.337)
+    pmaddwd     mm6, [GOTOFF(eax,PW_F0299_F0337)]  ; mm6=ROH*FIX(0.299)+GOH*FIX(0.337)
+    pmaddwd     mm7, [GOTOFF(eax,PW_MF016_MF033)]  ; mm7=ROL*-FIX(0.168)+GOL*-FIX(0.331)
+    pmaddwd     mm4, [GOTOFF(eax,PW_MF016_MF033)]  ; mm4=ROH*-FIX(0.168)+GOH*-FIX(0.331)
+
+    movq        MMWORD [wk(4)], mm1     ; wk(4)=ROL*FIX(0.299)+GOL*FIX(0.337)
+    movq        MMWORD [wk(5)], mm6     ; wk(5)=ROH*FIX(0.299)+GOH*FIX(0.337)
+
+    pxor        mm1, mm1
+    pxor        mm6, mm6
+    punpcklwd   mm1, mm5                ; mm1=BOL
+    punpckhwd   mm6, mm5                ; mm6=BOH
+    psrld       mm1, 1                  ; mm1=BOL*FIX(0.500)
+    psrld       mm6, 1                  ; mm6=BOH*FIX(0.500)
+
+    movq        mm5, [GOTOFF(eax,PD_ONEHALFM1_CJ)]  ; mm5=[PD_ONEHALFM1_CJ]
+
+    paddd       mm7, mm1
+    paddd       mm4, mm6
+    paddd       mm7, mm5
+    paddd       mm4, mm5
+    psrld       mm7, SCALEBITS          ; mm7=CbOL
+    psrld       mm4, SCALEBITS          ; mm4=CbOH
+    packssdw    mm7, mm4                ; mm7=CbO
+
+    movq        mm1, MMWORD [wk(2)]     ; mm1=BE
+
+    movq        mm6, mm0
+    punpcklwd   mm0, mm2
+    punpckhwd   mm6, mm2
+    movq        mm5, mm0
+    movq        mm4, mm6
+    pmaddwd     mm0, [GOTOFF(eax,PW_F0299_F0337)]  ; mm0=REL*FIX(0.299)+GEL*FIX(0.337)
+    pmaddwd     mm6, [GOTOFF(eax,PW_F0299_F0337)]  ; mm6=REH*FIX(0.299)+GEH*FIX(0.337)
+    pmaddwd     mm5, [GOTOFF(eax,PW_MF016_MF033)]  ; mm5=REL*-FIX(0.168)+GEL*-FIX(0.331)
+    pmaddwd     mm4, [GOTOFF(eax,PW_MF016_MF033)]  ; mm4=REH*-FIX(0.168)+GEH*-FIX(0.331)
+
+    movq        MMWORD [wk(6)], mm0     ; wk(6)=REL*FIX(0.299)+GEL*FIX(0.337)
+    movq        MMWORD [wk(7)], mm6     ; wk(7)=REH*FIX(0.299)+GEH*FIX(0.337)
+
+    pxor        mm0, mm0
+    pxor        mm6, mm6
+    punpcklwd   mm0, mm1                ; mm0=BEL
+    punpckhwd   mm6, mm1                ; mm6=BEH
+    psrld       mm0, 1                  ; mm0=BEL*FIX(0.500)
+    psrld       mm6, 1                  ; mm6=BEH*FIX(0.500)
+
+    movq        mm1, [GOTOFF(eax,PD_ONEHALFM1_CJ)]  ; mm1=[PD_ONEHALFM1_CJ]
+
+    paddd       mm5, mm0
+    paddd       mm4, mm6
+    paddd       mm5, mm1
+    paddd       mm4, mm1
+    psrld       mm5, SCALEBITS          ; mm5=CbEL
+    psrld       mm4, SCALEBITS          ; mm4=CbEH
+    packssdw    mm5, mm4                ; mm5=CbE
+
+    psllw       mm7, BYTE_BIT
+    por         mm5, mm7                ; mm5=Cb
+    movq        MMWORD [ebx], mm5       ; Save Cb
+
+    movq        mm0, MMWORD [wk(3)]     ; mm0=BO
+    movq        mm6, MMWORD [wk(2)]     ; mm6=BE
+    movq        mm1, MMWORD [wk(1)]     ; mm1=RO
+
+    movq        mm4, mm0
+    punpcklwd   mm0, mm3
+    punpckhwd   mm4, mm3
+    movq        mm7, mm0
+    movq        mm5, mm4
+    pmaddwd     mm0, [GOTOFF(eax,PW_F0114_F0250)]  ; mm0=BOL*FIX(0.114)+GOL*FIX(0.250)
+    pmaddwd     mm4, [GOTOFF(eax,PW_F0114_F0250)]  ; mm4=BOH*FIX(0.114)+GOH*FIX(0.250)
+    pmaddwd     mm7, [GOTOFF(eax,PW_MF008_MF041)]  ; mm7=BOL*-FIX(0.081)+GOL*-FIX(0.418)
+    pmaddwd     mm5, [GOTOFF(eax,PW_MF008_MF041)]  ; mm5=BOH*-FIX(0.081)+GOH*-FIX(0.418)
+
+    movq        mm3, [GOTOFF(eax,PD_ONEHALF)]  ; mm3=[PD_ONEHALF]
+
+    paddd       mm0, MMWORD [wk(4)]
+    paddd       mm4, MMWORD [wk(5)]
+    paddd       mm0, mm3
+    paddd       mm4, mm3
+    psrld       mm0, SCALEBITS          ; mm0=YOL
+    psrld       mm4, SCALEBITS          ; mm4=YOH
+    packssdw    mm0, mm4                ; mm0=YO
+
+    pxor        mm3, mm3
+    pxor        mm4, mm4
+    punpcklwd   mm3, mm1                ; mm3=ROL
+    punpckhwd   mm4, mm1                ; mm4=ROH
+    psrld       mm3, 1                  ; mm3=ROL*FIX(0.500)
+    psrld       mm4, 1                  ; mm4=ROH*FIX(0.500)
+
+    movq        mm1, [GOTOFF(eax,PD_ONEHALFM1_CJ)]  ; mm1=[PD_ONEHALFM1_CJ]
+
+    paddd       mm7, mm3
+    paddd       mm5, mm4
+    paddd       mm7, mm1
+    paddd       mm5, mm1
+    psrld       mm7, SCALEBITS          ; mm7=CrOL
+    psrld       mm5, SCALEBITS          ; mm5=CrOH
+    packssdw    mm7, mm5                ; mm7=CrO
+
+    movq        mm3, MMWORD [wk(0)]     ; mm3=RE
+
+    movq        mm4, mm6
+    punpcklwd   mm6, mm2
+    punpckhwd   mm4, mm2
+    movq        mm1, mm6
+    movq        mm5, mm4
+    pmaddwd     mm6, [GOTOFF(eax,PW_F0114_F0250)]  ; mm6=BEL*FIX(0.114)+GEL*FIX(0.250)
+    pmaddwd     mm4, [GOTOFF(eax,PW_F0114_F0250)]  ; mm4=BEH*FIX(0.114)+GEH*FIX(0.250)
+    pmaddwd     mm1, [GOTOFF(eax,PW_MF008_MF041)]  ; mm1=BEL*-FIX(0.081)+GEL*-FIX(0.418)
+    pmaddwd     mm5, [GOTOFF(eax,PW_MF008_MF041)]  ; mm5=BEH*-FIX(0.081)+GEH*-FIX(0.418)
+
+    movq        mm2, [GOTOFF(eax,PD_ONEHALF)]      ; mm2=[PD_ONEHALF]
+
+    paddd       mm6, MMWORD [wk(6)]
+    paddd       mm4, MMWORD [wk(7)]
+    paddd       mm6, mm2
+    paddd       mm4, mm2
+    psrld       mm6, SCALEBITS          ; mm6=YEL
+    psrld       mm4, SCALEBITS          ; mm4=YEH
+    packssdw    mm6, mm4                ; mm6=YE
+
+    psllw       mm0, BYTE_BIT
+    por         mm6, mm0                ; mm6=Y
+    movq        MMWORD [edi], mm6       ; Save Y
+
+    pxor        mm2, mm2
+    pxor        mm4, mm4
+    punpcklwd   mm2, mm3                ; mm2=REL
+    punpckhwd   mm4, mm3                ; mm4=REH
+    psrld       mm2, 1                  ; mm2=REL*FIX(0.500)
+    psrld       mm4, 1                  ; mm4=REH*FIX(0.500)
+
+    movq        mm0, [GOTOFF(eax,PD_ONEHALFM1_CJ)]  ; mm0=[PD_ONEHALFM1_CJ]
+
+    paddd       mm1, mm2
+    paddd       mm5, mm4
+    paddd       mm1, mm0
+    paddd       mm5, mm0
+    psrld       mm1, SCALEBITS          ; mm1=CrEL
+    psrld       mm5, SCALEBITS          ; mm5=CrEH
+    packssdw    mm1, mm5                ; mm1=CrE
+
+    psllw       mm7, BYTE_BIT
+    por         mm1, mm7                ; mm1=Cr
+    movq        MMWORD [edx], mm1       ; Save Cr
+
+    sub         ecx, byte SIZEOF_MMWORD
+    add         esi, byte RGB_PIXELSIZE*SIZEOF_MMWORD  ; inptr
+    add         edi, byte SIZEOF_MMWORD                ; outptr0
+    add         ebx, byte SIZEOF_MMWORD                ; outptr1
+    add         edx, byte SIZEOF_MMWORD                ; outptr2
+    cmp         ecx, byte SIZEOF_MMWORD
+    jae         near .columnloop
+    test        ecx, ecx
+    jnz         near .column_ld1
+
+    pop         ecx                     ; col
+    pop         esi
+    pop         edi
+    pop         ebx
+    pop         edx
+    poppic      eax
+
+    add         esi, byte SIZEOF_JSAMPROW  ; input_buf
+    add         edi, byte SIZEOF_JSAMPROW
+    add         ebx, byte SIZEOF_JSAMPROW
+    add         edx, byte SIZEOF_JSAMPROW
+    dec         eax                        ; num_rows
+    jg          near .rowloop
+
+    emms                                ; empty MMX state
+
+.return:
+    pop         edi
+    pop         esi
+;   pop         edx                     ; need not be preserved
+;   pop         ecx                     ; need not be preserved
+    pop         ebx
+    mov         esp, ebp                ; esp <- aligned ebp
+    pop         esp                     ; esp <- original ebp
+    pop         ebp
+    ret
+
+; For some reason, the OS X linker does not honor the request to align the
+; segment unless we do this.
+    align       32
diff --git a/3rdparty/libjpeg/src/simd/i386/jccolext-sse2.asm b/3rdparty/libjpeg/src/simd/i386/jccolext-sse2.asm
new file mode 100644
index 00000000..c6c80852
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/i386/jccolext-sse2.asm
@@ -0,0 +1,503 @@
+;
+; jccolext.asm - colorspace conversion (SSE2)
+;
+; Copyright (C) 2016, D. R. Commander.
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+;
+; This file should be assembled with NASM (Netwide Assembler),
+; can *not* be assembled with Microsoft's MASM or any compatible
+; assembler (including Borland's Turbo Assembler).
+; NASM is available from http://nasm.sourceforge.net/ or
+; http://sourceforge.net/project/showfiles.php?group_id=6208
+
+%include "jcolsamp.inc"
+
+; --------------------------------------------------------------------------
+;
+; Convert some rows of samples to the output colorspace.
+;
+; GLOBAL(void)
+; jsimd_rgb_ycc_convert_sse2(JDIMENSION img_width, JSAMPARRAY input_buf,
+;                            JSAMPIMAGE output_buf, JDIMENSION output_row,
+;                            int num_rows);
+;
+
+%define img_width(b)   (b) + 8          ; JDIMENSION img_width
+%define input_buf(b)   (b) + 12         ; JSAMPARRAY input_buf
+%define output_buf(b)  (b) + 16         ; JSAMPIMAGE output_buf
+%define output_row(b)  (b) + 20         ; JDIMENSION output_row
+%define num_rows(b)    (b) + 24         ; int num_rows
+
+%define original_ebp   ebp + 0
+%define wk(i)          ebp - (WK_NUM - (i)) * SIZEOF_XMMWORD
+                                        ; xmmword wk[WK_NUM]
+%define WK_NUM         8
+%define gotptr         wk(0) - SIZEOF_POINTER  ; void * gotptr
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_rgb_ycc_convert_sse2)
+
+EXTN(jsimd_rgb_ycc_convert_sse2):
+    push        ebp
+    mov         eax, esp                     ; eax = original ebp
+    sub         esp, byte 4
+    and         esp, byte (-SIZEOF_XMMWORD)  ; align to 128 bits
+    mov         [esp], eax
+    mov         ebp, esp                     ; ebp = aligned ebp
+    lea         esp, [wk(0)]
+    pushpic     eax                     ; make a room for GOT address
+    push        ebx
+;   push        ecx                     ; need not be preserved
+;   push        edx                     ; need not be preserved
+    push        esi
+    push        edi
+
+    get_GOT     ebx                     ; get GOT address
+    movpic      POINTER [gotptr], ebx   ; save GOT address
+
+    mov         ecx, JDIMENSION [img_width(eax)]
+    test        ecx, ecx
+    jz          near .return
+
+    push        ecx
+
+    mov         esi, JSAMPIMAGE [output_buf(eax)]
+    mov         ecx, JDIMENSION [output_row(eax)]
+    mov         edi, JSAMPARRAY [esi+0*SIZEOF_JSAMPARRAY]
+    mov         ebx, JSAMPARRAY [esi+1*SIZEOF_JSAMPARRAY]
+    mov         edx, JSAMPARRAY [esi+2*SIZEOF_JSAMPARRAY]
+    lea         edi, [edi+ecx*SIZEOF_JSAMPROW]
+    lea         ebx, [ebx+ecx*SIZEOF_JSAMPROW]
+    lea         edx, [edx+ecx*SIZEOF_JSAMPROW]
+
+    pop         ecx
+
+    mov         esi, JSAMPARRAY [input_buf(eax)]
+    mov         eax, INT [num_rows(eax)]
+    test        eax, eax
+    jle         near .return
+    alignx      16, 7
+.rowloop:
+    pushpic     eax
+    push        edx
+    push        ebx
+    push        edi
+    push        esi
+    push        ecx                     ; col
+
+    mov         esi, JSAMPROW [esi]     ; inptr
+    mov         edi, JSAMPROW [edi]     ; outptr0
+    mov         ebx, JSAMPROW [ebx]     ; outptr1
+    mov         edx, JSAMPROW [edx]     ; outptr2
+    movpic      eax, POINTER [gotptr]   ; load GOT address (eax)
+
+    cmp         ecx, byte SIZEOF_XMMWORD
+    jae         near .columnloop
+    alignx      16, 7
+
+%if RGB_PIXELSIZE == 3  ; ---------------
+
+.column_ld1:
+    push        eax
+    push        edx
+    lea         ecx, [ecx+ecx*2]        ; imul ecx,RGB_PIXELSIZE
+    test        cl, SIZEOF_BYTE
+    jz          short .column_ld2
+    sub         ecx, byte SIZEOF_BYTE
+    movzx       eax, byte [esi+ecx]
+.column_ld2:
+    test        cl, SIZEOF_WORD
+    jz          short .column_ld4
+    sub         ecx, byte SIZEOF_WORD
+    movzx       edx, word [esi+ecx]
+    shl         eax, WORD_BIT
+    or          eax, edx
+.column_ld4:
+    movd        xmmA, eax
+    pop         edx
+    pop         eax
+    test        cl, SIZEOF_DWORD
+    jz          short .column_ld8
+    sub         ecx, byte SIZEOF_DWORD
+    movd        xmmF, XMM_DWORD [esi+ecx]
+    pslldq      xmmA, SIZEOF_DWORD
+    por         xmmA, xmmF
+.column_ld8:
+    test        cl, SIZEOF_MMWORD
+    jz          short .column_ld16
+    sub         ecx, byte SIZEOF_MMWORD
+    movq        xmmB, XMM_MMWORD [esi+ecx]
+    pslldq      xmmA, SIZEOF_MMWORD
+    por         xmmA, xmmB
+.column_ld16:
+    test        cl, SIZEOF_XMMWORD
+    jz          short .column_ld32
+    movdqa      xmmF, xmmA
+    movdqu      xmmA, XMMWORD [esi+0*SIZEOF_XMMWORD]
+    mov         ecx, SIZEOF_XMMWORD
+    jmp         short .rgb_ycc_cnv
+.column_ld32:
+    test        cl, 2*SIZEOF_XMMWORD
+    mov         ecx, SIZEOF_XMMWORD
+    jz          short .rgb_ycc_cnv
+    movdqa      xmmB, xmmA
+    movdqu      xmmA, XMMWORD [esi+0*SIZEOF_XMMWORD]
+    movdqu      xmmF, XMMWORD [esi+1*SIZEOF_XMMWORD]
+    jmp         short .rgb_ycc_cnv
+    alignx      16, 7
+
+.columnloop:
+    movdqu      xmmA, XMMWORD [esi+0*SIZEOF_XMMWORD]
+    movdqu      xmmF, XMMWORD [esi+1*SIZEOF_XMMWORD]
+    movdqu      xmmB, XMMWORD [esi+2*SIZEOF_XMMWORD]
+
+.rgb_ycc_cnv:
+    ; xmmA=(00 10 20 01 11 21 02 12 22 03 13 23 04 14 24 05)
+    ; xmmF=(15 25 06 16 26 07 17 27 08 18 28 09 19 29 0A 1A)
+    ; xmmB=(2A 0B 1B 2B 0C 1C 2C 0D 1D 2D 0E 1E 2E 0F 1F 2F)
+
+    movdqa      xmmG, xmmA
+    pslldq      xmmA, 8     ; xmmA=(-- -- -- -- -- -- -- -- 00 10 20 01 11 21 02 12)
+    psrldq      xmmG, 8     ; xmmG=(22 03 13 23 04 14 24 05 -- -- -- -- -- -- -- --)
+
+    punpckhbw   xmmA, xmmF  ; xmmA=(00 08 10 18 20 28 01 09 11 19 21 29 02 0A 12 1A)
+    pslldq      xmmF, 8     ; xmmF=(-- -- -- -- -- -- -- -- 15 25 06 16 26 07 17 27)
+
+    punpcklbw   xmmG, xmmB  ; xmmG=(22 2A 03 0B 13 1B 23 2B 04 0C 14 1C 24 2C 05 0D)
+    punpckhbw   xmmF, xmmB  ; xmmF=(15 1D 25 2D 06 0E 16 1E 26 2E 07 0F 17 1F 27 2F)
+
+    movdqa      xmmD, xmmA
+    pslldq      xmmA, 8     ; xmmA=(-- -- -- -- -- -- -- -- 00 08 10 18 20 28 01 09)
+    psrldq      xmmD, 8     ; xmmD=(11 19 21 29 02 0A 12 1A -- -- -- -- -- -- -- --)
+
+    punpckhbw   xmmA, xmmG  ; xmmA=(00 04 08 0C 10 14 18 1C 20 24 28 2C 01 05 09 0D)
+    pslldq      xmmG, 8     ; xmmG=(-- -- -- -- -- -- -- -- 22 2A 03 0B 13 1B 23 2B)
+
+    punpcklbw   xmmD, xmmF  ; xmmD=(11 15 19 1D 21 25 29 2D 02 06 0A 0E 12 16 1A 1E)
+    punpckhbw   xmmG, xmmF  ; xmmG=(22 26 2A 2E 03 07 0B 0F 13 17 1B 1F 23 27 2B 2F)
+
+    movdqa      xmmE, xmmA
+    pslldq      xmmA, 8     ; xmmA=(-- -- -- -- -- -- -- -- 00 04 08 0C 10 14 18 1C)
+    psrldq      xmmE, 8     ; xmmE=(20 24 28 2C 01 05 09 0D -- -- -- -- -- -- -- --)
+
+    punpckhbw   xmmA, xmmD  ; xmmA=(00 02 04 06 08 0A 0C 0E 10 12 14 16 18 1A 1C 1E)
+    pslldq      xmmD, 8     ; xmmD=(-- -- -- -- -- -- -- -- 11 15 19 1D 21 25 29 2D)
+
+    punpcklbw   xmmE, xmmG  ; xmmE=(20 22 24 26 28 2A 2C 2E 01 03 05 07 09 0B 0D 0F)
+    punpckhbw   xmmD, xmmG  ; xmmD=(11 13 15 17 19 1B 1D 1F 21 23 25 27 29 2B 2D 2F)
+
+    pxor        xmmH, xmmH
+
+    movdqa      xmmC, xmmA
+    punpcklbw   xmmA, xmmH  ; xmmA=(00 02 04 06 08 0A 0C 0E)
+    punpckhbw   xmmC, xmmH  ; xmmC=(10 12 14 16 18 1A 1C 1E)
+
+    movdqa      xmmB, xmmE
+    punpcklbw   xmmE, xmmH  ; xmmE=(20 22 24 26 28 2A 2C 2E)
+    punpckhbw   xmmB, xmmH  ; xmmB=(01 03 05 07 09 0B 0D 0F)
+
+    movdqa      xmmF, xmmD
+    punpcklbw   xmmD, xmmH  ; xmmD=(11 13 15 17 19 1B 1D 1F)
+    punpckhbw   xmmF, xmmH  ; xmmF=(21 23 25 27 29 2B 2D 2F)
+
+%else  ; RGB_PIXELSIZE == 4 ; -----------
+
+.column_ld1:
+    test        cl, SIZEOF_XMMWORD/16
+    jz          short .column_ld2
+    sub         ecx, byte SIZEOF_XMMWORD/16
+    movd        xmmA, XMM_DWORD [esi+ecx*RGB_PIXELSIZE]
+.column_ld2:
+    test        cl, SIZEOF_XMMWORD/8
+    jz          short .column_ld4
+    sub         ecx, byte SIZEOF_XMMWORD/8
+    movq        xmmE, XMM_MMWORD [esi+ecx*RGB_PIXELSIZE]
+    pslldq      xmmA, SIZEOF_MMWORD
+    por         xmmA, xmmE
+.column_ld4:
+    test        cl, SIZEOF_XMMWORD/4
+    jz          short .column_ld8
+    sub         ecx, byte SIZEOF_XMMWORD/4
+    movdqa      xmmE, xmmA
+    movdqu      xmmA, XMMWORD [esi+ecx*RGB_PIXELSIZE]
+.column_ld8:
+    test        cl, SIZEOF_XMMWORD/2
+    mov         ecx, SIZEOF_XMMWORD
+    jz          short .rgb_ycc_cnv
+    movdqa      xmmF, xmmA
+    movdqa      xmmH, xmmE
+    movdqu      xmmA, XMMWORD [esi+0*SIZEOF_XMMWORD]
+    movdqu      xmmE, XMMWORD [esi+1*SIZEOF_XMMWORD]
+    jmp         short .rgb_ycc_cnv
+    alignx      16, 7
+
+.columnloop:
+    movdqu      xmmA, XMMWORD [esi+0*SIZEOF_XMMWORD]
+    movdqu      xmmE, XMMWORD [esi+1*SIZEOF_XMMWORD]
+    movdqu      xmmF, XMMWORD [esi+2*SIZEOF_XMMWORD]
+    movdqu      xmmH, XMMWORD [esi+3*SIZEOF_XMMWORD]
+
+.rgb_ycc_cnv:
+    ; xmmA=(00 10 20 30 01 11 21 31 02 12 22 32 03 13 23 33)
+    ; xmmE=(04 14 24 34 05 15 25 35 06 16 26 36 07 17 27 37)
+    ; xmmF=(08 18 28 38 09 19 29 39 0A 1A 2A 3A 0B 1B 2B 3B)
+    ; xmmH=(0C 1C 2C 3C 0D 1D 2D 3D 0E 1E 2E 3E 0F 1F 2F 3F)
+
+    movdqa      xmmD, xmmA
+    punpcklbw   xmmA, xmmE      ; xmmA=(00 04 10 14 20 24 30 34 01 05 11 15 21 25 31 35)
+    punpckhbw   xmmD, xmmE      ; xmmD=(02 06 12 16 22 26 32 36 03 07 13 17 23 27 33 37)
+
+    movdqa      xmmC, xmmF
+    punpcklbw   xmmF, xmmH      ; xmmF=(08 0C 18 1C 28 2C 38 3C 09 0D 19 1D 29 2D 39 3D)
+    punpckhbw   xmmC, xmmH      ; xmmC=(0A 0E 1A 1E 2A 2E 3A 3E 0B 0F 1B 1F 2B 2F 3B 3F)
+
+    movdqa      xmmB, xmmA
+    punpcklwd   xmmA, xmmF      ; xmmA=(00 04 08 0C 10 14 18 1C 20 24 28 2C 30 34 38 3C)
+    punpckhwd   xmmB, xmmF      ; xmmB=(01 05 09 0D 11 15 19 1D 21 25 29 2D 31 35 39 3D)
+
+    movdqa      xmmG, xmmD
+    punpcklwd   xmmD, xmmC      ; xmmD=(02 06 0A 0E 12 16 1A 1E 22 26 2A 2E 32 36 3A 3E)
+    punpckhwd   xmmG, xmmC      ; xmmG=(03 07 0B 0F 13 17 1B 1F 23 27 2B 2F 33 37 3B 3F)
+
+    movdqa      xmmE, xmmA
+    punpcklbw   xmmA, xmmD      ; xmmA=(00 02 04 06 08 0A 0C 0E 10 12 14 16 18 1A 1C 1E)
+    punpckhbw   xmmE, xmmD      ; xmmE=(20 22 24 26 28 2A 2C 2E 30 32 34 36 38 3A 3C 3E)
+
+    movdqa      xmmH, xmmB
+    punpcklbw   xmmB, xmmG      ; xmmB=(01 03 05 07 09 0B 0D 0F 11 13 15 17 19 1B 1D 1F)
+    punpckhbw   xmmH, xmmG      ; xmmH=(21 23 25 27 29 2B 2D 2F 31 33 35 37 39 3B 3D 3F)
+
+    pxor        xmmF, xmmF
+
+    movdqa      xmmC, xmmA
+    punpcklbw   xmmA, xmmF      ; xmmA=(00 02 04 06 08 0A 0C 0E)
+    punpckhbw   xmmC, xmmF      ; xmmC=(10 12 14 16 18 1A 1C 1E)
+
+    movdqa      xmmD, xmmB
+    punpcklbw   xmmB, xmmF      ; xmmB=(01 03 05 07 09 0B 0D 0F)
+    punpckhbw   xmmD, xmmF      ; xmmD=(11 13 15 17 19 1B 1D 1F)
+
+    movdqa      xmmG, xmmE
+    punpcklbw   xmmE, xmmF      ; xmmE=(20 22 24 26 28 2A 2C 2E)
+    punpckhbw   xmmG, xmmF      ; xmmG=(30 32 34 36 38 3A 3C 3E)
+
+    punpcklbw   xmmF, xmmH
+    punpckhbw   xmmH, xmmH
+    psrlw       xmmF, BYTE_BIT  ; xmmF=(21 23 25 27 29 2B 2D 2F)
+    psrlw       xmmH, BYTE_BIT  ; xmmH=(31 33 35 37 39 3B 3D 3F)
+
+%endif  ; RGB_PIXELSIZE ; ---------------
+
+    ; xmm0=R(02468ACE)=RE, xmm2=G(02468ACE)=GE, xmm4=B(02468ACE)=BE
+    ; xmm1=R(13579BDF)=RO, xmm3=G(13579BDF)=GO, xmm5=B(13579BDF)=BO
+
+    ; (Original)
+    ; Y  =  0.29900 * R + 0.58700 * G + 0.11400 * B
+    ; Cb = -0.16874 * R - 0.33126 * G + 0.50000 * B + CENTERJSAMPLE
+    ; Cr =  0.50000 * R - 0.41869 * G - 0.08131 * B + CENTERJSAMPLE
+    ;
+    ; (This implementation)
+    ; Y  =  0.29900 * R + 0.33700 * G + 0.11400 * B + 0.25000 * G
+    ; Cb = -0.16874 * R - 0.33126 * G + 0.50000 * B + CENTERJSAMPLE
+    ; Cr =  0.50000 * R - 0.41869 * G - 0.08131 * B + CENTERJSAMPLE
+
+    movdqa      XMMWORD [wk(0)], xmm0   ; wk(0)=RE
+    movdqa      XMMWORD [wk(1)], xmm1   ; wk(1)=RO
+    movdqa      XMMWORD [wk(2)], xmm4   ; wk(2)=BE
+    movdqa      XMMWORD [wk(3)], xmm5   ; wk(3)=BO
+
+    movdqa      xmm6, xmm1
+    punpcklwd   xmm1, xmm3
+    punpckhwd   xmm6, xmm3
+    movdqa      xmm7, xmm1
+    movdqa      xmm4, xmm6
+    pmaddwd     xmm1, [GOTOFF(eax,PW_F0299_F0337)]  ; xmm1=ROL*FIX(0.299)+GOL*FIX(0.337)
+    pmaddwd     xmm6, [GOTOFF(eax,PW_F0299_F0337)]  ; xmm6=ROH*FIX(0.299)+GOH*FIX(0.337)
+    pmaddwd     xmm7, [GOTOFF(eax,PW_MF016_MF033)]  ; xmm7=ROL*-FIX(0.168)+GOL*-FIX(0.331)
+    pmaddwd     xmm4, [GOTOFF(eax,PW_MF016_MF033)]  ; xmm4=ROH*-FIX(0.168)+GOH*-FIX(0.331)
+
+    movdqa      XMMWORD [wk(4)], xmm1   ; wk(4)=ROL*FIX(0.299)+GOL*FIX(0.337)
+    movdqa      XMMWORD [wk(5)], xmm6   ; wk(5)=ROH*FIX(0.299)+GOH*FIX(0.337)
+
+    pxor        xmm1, xmm1
+    pxor        xmm6, xmm6
+    punpcklwd   xmm1, xmm5              ; xmm1=BOL
+    punpckhwd   xmm6, xmm5              ; xmm6=BOH
+    psrld       xmm1, 1                 ; xmm1=BOL*FIX(0.500)
+    psrld       xmm6, 1                 ; xmm6=BOH*FIX(0.500)
+
+    movdqa      xmm5, [GOTOFF(eax,PD_ONEHALFM1_CJ)]  ; xmm5=[PD_ONEHALFM1_CJ]
+
+    paddd       xmm7, xmm1
+    paddd       xmm4, xmm6
+    paddd       xmm7, xmm5
+    paddd       xmm4, xmm5
+    psrld       xmm7, SCALEBITS         ; xmm7=CbOL
+    psrld       xmm4, SCALEBITS         ; xmm4=CbOH
+    packssdw    xmm7, xmm4              ; xmm7=CbO
+
+    movdqa      xmm1, XMMWORD [wk(2)]   ; xmm1=BE
+
+    movdqa      xmm6, xmm0
+    punpcklwd   xmm0, xmm2
+    punpckhwd   xmm6, xmm2
+    movdqa      xmm5, xmm0
+    movdqa      xmm4, xmm6
+    pmaddwd     xmm0, [GOTOFF(eax,PW_F0299_F0337)]  ; xmm0=REL*FIX(0.299)+GEL*FIX(0.337)
+    pmaddwd     xmm6, [GOTOFF(eax,PW_F0299_F0337)]  ; xmm6=REH*FIX(0.299)+GEH*FIX(0.337)
+    pmaddwd     xmm5, [GOTOFF(eax,PW_MF016_MF033)]  ; xmm5=REL*-FIX(0.168)+GEL*-FIX(0.331)
+    pmaddwd     xmm4, [GOTOFF(eax,PW_MF016_MF033)]  ; xmm4=REH*-FIX(0.168)+GEH*-FIX(0.331)
+
+    movdqa      XMMWORD [wk(6)], xmm0   ; wk(6)=REL*FIX(0.299)+GEL*FIX(0.337)
+    movdqa      XMMWORD [wk(7)], xmm6   ; wk(7)=REH*FIX(0.299)+GEH*FIX(0.337)
+
+    pxor        xmm0, xmm0
+    pxor        xmm6, xmm6
+    punpcklwd   xmm0, xmm1              ; xmm0=BEL
+    punpckhwd   xmm6, xmm1              ; xmm6=BEH
+    psrld       xmm0, 1                 ; xmm0=BEL*FIX(0.500)
+    psrld       xmm6, 1                 ; xmm6=BEH*FIX(0.500)
+
+    movdqa      xmm1, [GOTOFF(eax,PD_ONEHALFM1_CJ)]  ; xmm1=[PD_ONEHALFM1_CJ]
+
+    paddd       xmm5, xmm0
+    paddd       xmm4, xmm6
+    paddd       xmm5, xmm1
+    paddd       xmm4, xmm1
+    psrld       xmm5, SCALEBITS         ; xmm5=CbEL
+    psrld       xmm4, SCALEBITS         ; xmm4=CbEH
+    packssdw    xmm5, xmm4              ; xmm5=CbE
+
+    psllw       xmm7, BYTE_BIT
+    por         xmm5, xmm7              ; xmm5=Cb
+    movdqa      XMMWORD [ebx], xmm5     ; Save Cb
+
+    movdqa      xmm0, XMMWORD [wk(3)]   ; xmm0=BO
+    movdqa      xmm6, XMMWORD [wk(2)]   ; xmm6=BE
+    movdqa      xmm1, XMMWORD [wk(1)]   ; xmm1=RO
+
+    movdqa      xmm4, xmm0
+    punpcklwd   xmm0, xmm3
+    punpckhwd   xmm4, xmm3
+    movdqa      xmm7, xmm0
+    movdqa      xmm5, xmm4
+    pmaddwd     xmm0, [GOTOFF(eax,PW_F0114_F0250)]  ; xmm0=BOL*FIX(0.114)+GOL*FIX(0.250)
+    pmaddwd     xmm4, [GOTOFF(eax,PW_F0114_F0250)]  ; xmm4=BOH*FIX(0.114)+GOH*FIX(0.250)
+    pmaddwd     xmm7, [GOTOFF(eax,PW_MF008_MF041)]  ; xmm7=BOL*-FIX(0.081)+GOL*-FIX(0.418)
+    pmaddwd     xmm5, [GOTOFF(eax,PW_MF008_MF041)]  ; xmm5=BOH*-FIX(0.081)+GOH*-FIX(0.418)
+
+    movdqa      xmm3, [GOTOFF(eax,PD_ONEHALF)]  ; xmm3=[PD_ONEHALF]
+
+    paddd       xmm0, XMMWORD [wk(4)]
+    paddd       xmm4, XMMWORD [wk(5)]
+    paddd       xmm0, xmm3
+    paddd       xmm4, xmm3
+    psrld       xmm0, SCALEBITS         ; xmm0=YOL
+    psrld       xmm4, SCALEBITS         ; xmm4=YOH
+    packssdw    xmm0, xmm4              ; xmm0=YO
+
+    pxor        xmm3, xmm3
+    pxor        xmm4, xmm4
+    punpcklwd   xmm3, xmm1              ; xmm3=ROL
+    punpckhwd   xmm4, xmm1              ; xmm4=ROH
+    psrld       xmm3, 1                 ; xmm3=ROL*FIX(0.500)
+    psrld       xmm4, 1                 ; xmm4=ROH*FIX(0.500)
+
+    movdqa      xmm1, [GOTOFF(eax,PD_ONEHALFM1_CJ)]  ; xmm1=[PD_ONEHALFM1_CJ]
+
+    paddd       xmm7, xmm3
+    paddd       xmm5, xmm4
+    paddd       xmm7, xmm1
+    paddd       xmm5, xmm1
+    psrld       xmm7, SCALEBITS         ; xmm7=CrOL
+    psrld       xmm5, SCALEBITS         ; xmm5=CrOH
+    packssdw    xmm7, xmm5              ; xmm7=CrO
+
+    movdqa      xmm3, XMMWORD [wk(0)]   ; xmm3=RE
+
+    movdqa      xmm4, xmm6
+    punpcklwd   xmm6, xmm2
+    punpckhwd   xmm4, xmm2
+    movdqa      xmm1, xmm6
+    movdqa      xmm5, xmm4
+    pmaddwd     xmm6, [GOTOFF(eax,PW_F0114_F0250)]  ; xmm6=BEL*FIX(0.114)+GEL*FIX(0.250)
+    pmaddwd     xmm4, [GOTOFF(eax,PW_F0114_F0250)]  ; xmm4=BEH*FIX(0.114)+GEH*FIX(0.250)
+    pmaddwd     xmm1, [GOTOFF(eax,PW_MF008_MF041)]  ; xmm1=BEL*-FIX(0.081)+GEL*-FIX(0.418)
+    pmaddwd     xmm5, [GOTOFF(eax,PW_MF008_MF041)]  ; xmm5=BEH*-FIX(0.081)+GEH*-FIX(0.418)
+
+    movdqa      xmm2, [GOTOFF(eax,PD_ONEHALF)]      ; xmm2=[PD_ONEHALF]
+
+    paddd       xmm6, XMMWORD [wk(6)]
+    paddd       xmm4, XMMWORD [wk(7)]
+    paddd       xmm6, xmm2
+    paddd       xmm4, xmm2
+    psrld       xmm6, SCALEBITS         ; xmm6=YEL
+    psrld       xmm4, SCALEBITS         ; xmm4=YEH
+    packssdw    xmm6, xmm4              ; xmm6=YE
+
+    psllw       xmm0, BYTE_BIT
+    por         xmm6, xmm0              ; xmm6=Y
+    movdqa      XMMWORD [edi], xmm6     ; Save Y
+
+    pxor        xmm2, xmm2
+    pxor        xmm4, xmm4
+    punpcklwd   xmm2, xmm3              ; xmm2=REL
+    punpckhwd   xmm4, xmm3              ; xmm4=REH
+    psrld       xmm2, 1                 ; xmm2=REL*FIX(0.500)
+    psrld       xmm4, 1                 ; xmm4=REH*FIX(0.500)
+
+    movdqa      xmm0, [GOTOFF(eax,PD_ONEHALFM1_CJ)]  ; xmm0=[PD_ONEHALFM1_CJ]
+
+    paddd       xmm1, xmm2
+    paddd       xmm5, xmm4
+    paddd       xmm1, xmm0
+    paddd       xmm5, xmm0
+    psrld       xmm1, SCALEBITS         ; xmm1=CrEL
+    psrld       xmm5, SCALEBITS         ; xmm5=CrEH
+    packssdw    xmm1, xmm5              ; xmm1=CrE
+
+    psllw       xmm7, BYTE_BIT
+    por         xmm1, xmm7              ; xmm1=Cr
+    movdqa      XMMWORD [edx], xmm1     ; Save Cr
+
+    sub         ecx, byte SIZEOF_XMMWORD
+    add         esi, byte RGB_PIXELSIZE*SIZEOF_XMMWORD  ; inptr
+    add         edi, byte SIZEOF_XMMWORD                ; outptr0
+    add         ebx, byte SIZEOF_XMMWORD                ; outptr1
+    add         edx, byte SIZEOF_XMMWORD                ; outptr2
+    cmp         ecx, byte SIZEOF_XMMWORD
+    jae         near .columnloop
+    test        ecx, ecx
+    jnz         near .column_ld1
+
+    pop         ecx                     ; col
+    pop         esi
+    pop         edi
+    pop         ebx
+    pop         edx
+    poppic      eax
+
+    add         esi, byte SIZEOF_JSAMPROW  ; input_buf
+    add         edi, byte SIZEOF_JSAMPROW
+    add         ebx, byte SIZEOF_JSAMPROW
+    add         edx, byte SIZEOF_JSAMPROW
+    dec         eax                        ; num_rows
+    jg          near .rowloop
+
+.return:
+    pop         edi
+    pop         esi
+;   pop         edx                     ; need not be preserved
+;   pop         ecx                     ; need not be preserved
+    pop         ebx
+    mov         esp, ebp                ; esp <- aligned ebp
+    pop         esp                     ; esp <- original ebp
+    pop         ebp
+    ret
+
+; For some reason, the OS X linker does not honor the request to align the
+; segment unless we do this.
+    align       32
diff --git a/3rdparty/libjpeg/src/simd/i386/jccolor-avx2.asm b/3rdparty/libjpeg/src/simd/i386/jccolor-avx2.asm
new file mode 100644
index 00000000..14944e95
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/i386/jccolor-avx2.asm
@@ -0,0 +1,121 @@
+;
+; jccolor.asm - colorspace conversion (AVX2)
+;
+; Copyright (C) 2009, 2016, D. R. Commander.
+; Copyright (C) 2015, Intel Corporation.
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+;
+; This file should be assembled with NASM (Netwide Assembler),
+; can *not* be assembled with Microsoft's MASM or any compatible
+; assembler (including Borland's Turbo Assembler).
+; NASM is available from http://nasm.sourceforge.net/ or
+; http://sourceforge.net/project/showfiles.php?group_id=6208
+
+%include "jsimdext.inc"
+
+; --------------------------------------------------------------------------
+
+%define SCALEBITS  16
+
+F_0_081 equ  5329                ; FIX(0.08131)
+F_0_114 equ  7471                ; FIX(0.11400)
+F_0_168 equ 11059                ; FIX(0.16874)
+F_0_250 equ 16384                ; FIX(0.25000)
+F_0_299 equ 19595                ; FIX(0.29900)
+F_0_331 equ 21709                ; FIX(0.33126)
+F_0_418 equ 27439                ; FIX(0.41869)
+F_0_587 equ 38470                ; FIX(0.58700)
+F_0_337 equ (F_0_587 - F_0_250)  ; FIX(0.58700) - FIX(0.25000)
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_CONST
+
+    alignz      32
+    GLOBAL_DATA(jconst_rgb_ycc_convert_avx2)
+
+EXTN(jconst_rgb_ycc_convert_avx2):
+
+PW_F0299_F0337  times 8 dw  F_0_299,  F_0_337
+PW_F0114_F0250  times 8 dw  F_0_114,  F_0_250
+PW_MF016_MF033  times 8 dw -F_0_168, -F_0_331
+PW_MF008_MF041  times 8 dw -F_0_081, -F_0_418
+PD_ONEHALFM1_CJ times 8 dd  (1 << (SCALEBITS - 1)) - 1 + \
+                            (CENTERJSAMPLE << SCALEBITS)
+PD_ONEHALF      times 8 dd  (1 << (SCALEBITS - 1))
+
+    alignz      32
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_TEXT
+    BITS        32
+
+%include "jccolext-avx2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_RGB_RED
+%define RGB_GREEN  EXT_RGB_GREEN
+%define RGB_BLUE  EXT_RGB_BLUE
+%define RGB_PIXELSIZE  EXT_RGB_PIXELSIZE
+%define jsimd_rgb_ycc_convert_avx2  jsimd_extrgb_ycc_convert_avx2
+%include "jccolext-avx2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_RGBX_RED
+%define RGB_GREEN  EXT_RGBX_GREEN
+%define RGB_BLUE  EXT_RGBX_BLUE
+%define RGB_PIXELSIZE  EXT_RGBX_PIXELSIZE
+%define jsimd_rgb_ycc_convert_avx2  jsimd_extrgbx_ycc_convert_avx2
+%include "jccolext-avx2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_BGR_RED
+%define RGB_GREEN  EXT_BGR_GREEN
+%define RGB_BLUE  EXT_BGR_BLUE
+%define RGB_PIXELSIZE  EXT_BGR_PIXELSIZE
+%define jsimd_rgb_ycc_convert_avx2  jsimd_extbgr_ycc_convert_avx2
+%include "jccolext-avx2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_BGRX_RED
+%define RGB_GREEN  EXT_BGRX_GREEN
+%define RGB_BLUE  EXT_BGRX_BLUE
+%define RGB_PIXELSIZE  EXT_BGRX_PIXELSIZE
+%define jsimd_rgb_ycc_convert_avx2  jsimd_extbgrx_ycc_convert_avx2
+%include "jccolext-avx2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_XBGR_RED
+%define RGB_GREEN  EXT_XBGR_GREEN
+%define RGB_BLUE  EXT_XBGR_BLUE
+%define RGB_PIXELSIZE  EXT_XBGR_PIXELSIZE
+%define jsimd_rgb_ycc_convert_avx2  jsimd_extxbgr_ycc_convert_avx2
+%include "jccolext-avx2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_XRGB_RED
+%define RGB_GREEN  EXT_XRGB_GREEN
+%define RGB_BLUE  EXT_XRGB_BLUE
+%define RGB_PIXELSIZE  EXT_XRGB_PIXELSIZE
+%define jsimd_rgb_ycc_convert_avx2  jsimd_extxrgb_ycc_convert_avx2
+%include "jccolext-avx2.asm"
diff --git a/3rdparty/libjpeg/src/simd/i386/jccolor-mmx.asm b/3rdparty/libjpeg/src/simd/i386/jccolor-mmx.asm
new file mode 100644
index 00000000..8cb399bd
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/i386/jccolor-mmx.asm
@@ -0,0 +1,121 @@
+;
+; jccolor.asm - colorspace conversion (MMX)
+;
+; Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+; Copyright (C) 2009, 2016, D. R. Commander.
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+;
+; This file should be assembled with NASM (Netwide Assembler),
+; can *not* be assembled with Microsoft's MASM or any compatible
+; assembler (including Borland's Turbo Assembler).
+; NASM is available from http://nasm.sourceforge.net/ or
+; http://sourceforge.net/project/showfiles.php?group_id=6208
+
+%include "jsimdext.inc"
+
+; --------------------------------------------------------------------------
+
+%define SCALEBITS  16
+
+F_0_081 equ  5329                ; FIX(0.08131)
+F_0_114 equ  7471                ; FIX(0.11400)
+F_0_168 equ 11059                ; FIX(0.16874)
+F_0_250 equ 16384                ; FIX(0.25000)
+F_0_299 equ 19595                ; FIX(0.29900)
+F_0_331 equ 21709                ; FIX(0.33126)
+F_0_418 equ 27439                ; FIX(0.41869)
+F_0_587 equ 38470                ; FIX(0.58700)
+F_0_337 equ (F_0_587 - F_0_250)  ; FIX(0.58700) - FIX(0.25000)
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_CONST
+
+    alignz      32
+    GLOBAL_DATA(jconst_rgb_ycc_convert_mmx)
+
+EXTN(jconst_rgb_ycc_convert_mmx):
+
+PW_F0299_F0337  times 2 dw  F_0_299,  F_0_337
+PW_F0114_F0250  times 2 dw  F_0_114,  F_0_250
+PW_MF016_MF033  times 2 dw -F_0_168, -F_0_331
+PW_MF008_MF041  times 2 dw -F_0_081, -F_0_418
+PD_ONEHALFM1_CJ times 2 dd  (1 << (SCALEBITS - 1)) - 1 + \
+                            (CENTERJSAMPLE << SCALEBITS)
+PD_ONEHALF      times 2 dd  (1 << (SCALEBITS - 1))
+
+    alignz      32
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_TEXT
+    BITS        32
+
+%include "jccolext-mmx.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_RGB_RED
+%define RGB_GREEN  EXT_RGB_GREEN
+%define RGB_BLUE  EXT_RGB_BLUE
+%define RGB_PIXELSIZE  EXT_RGB_PIXELSIZE
+%define jsimd_rgb_ycc_convert_mmx  jsimd_extrgb_ycc_convert_mmx
+%include "jccolext-mmx.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_RGBX_RED
+%define RGB_GREEN  EXT_RGBX_GREEN
+%define RGB_BLUE  EXT_RGBX_BLUE
+%define RGB_PIXELSIZE  EXT_RGBX_PIXELSIZE
+%define jsimd_rgb_ycc_convert_mmx  jsimd_extrgbx_ycc_convert_mmx
+%include "jccolext-mmx.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_BGR_RED
+%define RGB_GREEN  EXT_BGR_GREEN
+%define RGB_BLUE  EXT_BGR_BLUE
+%define RGB_PIXELSIZE  EXT_BGR_PIXELSIZE
+%define jsimd_rgb_ycc_convert_mmx  jsimd_extbgr_ycc_convert_mmx
+%include "jccolext-mmx.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_BGRX_RED
+%define RGB_GREEN  EXT_BGRX_GREEN
+%define RGB_BLUE  EXT_BGRX_BLUE
+%define RGB_PIXELSIZE  EXT_BGRX_PIXELSIZE
+%define jsimd_rgb_ycc_convert_mmx  jsimd_extbgrx_ycc_convert_mmx
+%include "jccolext-mmx.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_XBGR_RED
+%define RGB_GREEN  EXT_XBGR_GREEN
+%define RGB_BLUE  EXT_XBGR_BLUE
+%define RGB_PIXELSIZE  EXT_XBGR_PIXELSIZE
+%define jsimd_rgb_ycc_convert_mmx  jsimd_extxbgr_ycc_convert_mmx
+%include "jccolext-mmx.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_XRGB_RED
+%define RGB_GREEN  EXT_XRGB_GREEN
+%define RGB_BLUE  EXT_XRGB_BLUE
+%define RGB_PIXELSIZE  EXT_XRGB_PIXELSIZE
+%define jsimd_rgb_ycc_convert_mmx  jsimd_extxrgb_ycc_convert_mmx
+%include "jccolext-mmx.asm"
diff --git a/3rdparty/libjpeg/src/simd/i386/jccolor-sse2.asm b/3rdparty/libjpeg/src/simd/i386/jccolor-sse2.asm
new file mode 100644
index 00000000..686d222f
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/i386/jccolor-sse2.asm
@@ -0,0 +1,120 @@
+;
+; jccolor.asm - colorspace conversion (SSE2)
+;
+; Copyright (C) 2009, 2016, D. R. Commander.
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+;
+; This file should be assembled with NASM (Netwide Assembler),
+; can *not* be assembled with Microsoft's MASM or any compatible
+; assembler (including Borland's Turbo Assembler).
+; NASM is available from http://nasm.sourceforge.net/ or
+; http://sourceforge.net/project/showfiles.php?group_id=6208
+
+%include "jsimdext.inc"
+
+; --------------------------------------------------------------------------
+
+%define SCALEBITS  16
+
+F_0_081 equ  5329                ; FIX(0.08131)
+F_0_114 equ  7471                ; FIX(0.11400)
+F_0_168 equ 11059                ; FIX(0.16874)
+F_0_250 equ 16384                ; FIX(0.25000)
+F_0_299 equ 19595                ; FIX(0.29900)
+F_0_331 equ 21709                ; FIX(0.33126)
+F_0_418 equ 27439                ; FIX(0.41869)
+F_0_587 equ 38470                ; FIX(0.58700)
+F_0_337 equ (F_0_587 - F_0_250)  ; FIX(0.58700) - FIX(0.25000)
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_CONST
+
+    alignz      32
+    GLOBAL_DATA(jconst_rgb_ycc_convert_sse2)
+
+EXTN(jconst_rgb_ycc_convert_sse2):
+
+PW_F0299_F0337  times 4 dw  F_0_299,  F_0_337
+PW_F0114_F0250  times 4 dw  F_0_114,  F_0_250
+PW_MF016_MF033  times 4 dw -F_0_168, -F_0_331
+PW_MF008_MF041  times 4 dw -F_0_081, -F_0_418
+PD_ONEHALFM1_CJ times 4 dd  (1 << (SCALEBITS - 1)) - 1 + \
+                            (CENTERJSAMPLE << SCALEBITS)
+PD_ONEHALF      times 4 dd  (1 << (SCALEBITS - 1))
+
+    alignz      32
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_TEXT
+    BITS        32
+
+%include "jccolext-sse2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_RGB_RED
+%define RGB_GREEN  EXT_RGB_GREEN
+%define RGB_BLUE  EXT_RGB_BLUE
+%define RGB_PIXELSIZE  EXT_RGB_PIXELSIZE
+%define jsimd_rgb_ycc_convert_sse2  jsimd_extrgb_ycc_convert_sse2
+%include "jccolext-sse2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_RGBX_RED
+%define RGB_GREEN  EXT_RGBX_GREEN
+%define RGB_BLUE  EXT_RGBX_BLUE
+%define RGB_PIXELSIZE  EXT_RGBX_PIXELSIZE
+%define jsimd_rgb_ycc_convert_sse2  jsimd_extrgbx_ycc_convert_sse2
+%include "jccolext-sse2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_BGR_RED
+%define RGB_GREEN  EXT_BGR_GREEN
+%define RGB_BLUE  EXT_BGR_BLUE
+%define RGB_PIXELSIZE  EXT_BGR_PIXELSIZE
+%define jsimd_rgb_ycc_convert_sse2  jsimd_extbgr_ycc_convert_sse2
+%include "jccolext-sse2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_BGRX_RED
+%define RGB_GREEN  EXT_BGRX_GREEN
+%define RGB_BLUE  EXT_BGRX_BLUE
+%define RGB_PIXELSIZE  EXT_BGRX_PIXELSIZE
+%define jsimd_rgb_ycc_convert_sse2  jsimd_extbgrx_ycc_convert_sse2
+%include "jccolext-sse2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_XBGR_RED
+%define RGB_GREEN  EXT_XBGR_GREEN
+%define RGB_BLUE  EXT_XBGR_BLUE
+%define RGB_PIXELSIZE  EXT_XBGR_PIXELSIZE
+%define jsimd_rgb_ycc_convert_sse2  jsimd_extxbgr_ycc_convert_sse2
+%include "jccolext-sse2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_XRGB_RED
+%define RGB_GREEN  EXT_XRGB_GREEN
+%define RGB_BLUE  EXT_XRGB_BLUE
+%define RGB_PIXELSIZE  EXT_XRGB_PIXELSIZE
+%define jsimd_rgb_ycc_convert_sse2  jsimd_extxrgb_ycc_convert_sse2
+%include "jccolext-sse2.asm"
diff --git a/3rdparty/libjpeg/src/simd/i386/jcgray-avx2.asm b/3rdparty/libjpeg/src/simd/i386/jcgray-avx2.asm
new file mode 100644
index 00000000..560ee0c7
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/i386/jcgray-avx2.asm
@@ -0,0 +1,113 @@
+;
+; jcgray.asm - grayscale colorspace conversion (AVX2)
+;
+; Copyright (C) 2011, 2016, D. R. Commander.
+; Copyright (C) 2015, Intel Corporation.
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+;
+; This file should be assembled with NASM (Netwide Assembler),
+; can *not* be assembled with Microsoft's MASM or any compatible
+; assembler (including Borland's Turbo Assembler).
+; NASM is available from http://nasm.sourceforge.net/ or
+; http://sourceforge.net/project/showfiles.php?group_id=6208
+
+%include "jsimdext.inc"
+
+; --------------------------------------------------------------------------
+
+%define SCALEBITS  16
+
+F_0_114 equ  7471                ; FIX(0.11400)
+F_0_250 equ 16384                ; FIX(0.25000)
+F_0_299 equ 19595                ; FIX(0.29900)
+F_0_587 equ 38470                ; FIX(0.58700)
+F_0_337 equ (F_0_587 - F_0_250)  ; FIX(0.58700) - FIX(0.25000)
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_CONST
+
+    alignz      32
+    GLOBAL_DATA(jconst_rgb_gray_convert_avx2)
+
+EXTN(jconst_rgb_gray_convert_avx2):
+
+PW_F0299_F0337 times 8 dw F_0_299, F_0_337
+PW_F0114_F0250 times 8 dw F_0_114, F_0_250
+PD_ONEHALF     times 8 dd (1 << (SCALEBITS - 1))
+
+    alignz      32
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_TEXT
+    BITS        32
+
+%include "jcgryext-avx2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_RGB_RED
+%define RGB_GREEN  EXT_RGB_GREEN
+%define RGB_BLUE  EXT_RGB_BLUE
+%define RGB_PIXELSIZE  EXT_RGB_PIXELSIZE
+%define jsimd_rgb_gray_convert_avx2  jsimd_extrgb_gray_convert_avx2
+%include "jcgryext-avx2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_RGBX_RED
+%define RGB_GREEN  EXT_RGBX_GREEN
+%define RGB_BLUE  EXT_RGBX_BLUE
+%define RGB_PIXELSIZE  EXT_RGBX_PIXELSIZE
+%define jsimd_rgb_gray_convert_avx2  jsimd_extrgbx_gray_convert_avx2
+%include "jcgryext-avx2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_BGR_RED
+%define RGB_GREEN  EXT_BGR_GREEN
+%define RGB_BLUE  EXT_BGR_BLUE
+%define RGB_PIXELSIZE  EXT_BGR_PIXELSIZE
+%define jsimd_rgb_gray_convert_avx2  jsimd_extbgr_gray_convert_avx2
+%include "jcgryext-avx2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_BGRX_RED
+%define RGB_GREEN  EXT_BGRX_GREEN
+%define RGB_BLUE  EXT_BGRX_BLUE
+%define RGB_PIXELSIZE  EXT_BGRX_PIXELSIZE
+%define jsimd_rgb_gray_convert_avx2  jsimd_extbgrx_gray_convert_avx2
+%include "jcgryext-avx2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_XBGR_RED
+%define RGB_GREEN  EXT_XBGR_GREEN
+%define RGB_BLUE  EXT_XBGR_BLUE
+%define RGB_PIXELSIZE  EXT_XBGR_PIXELSIZE
+%define jsimd_rgb_gray_convert_avx2  jsimd_extxbgr_gray_convert_avx2
+%include "jcgryext-avx2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_XRGB_RED
+%define RGB_GREEN  EXT_XRGB_GREEN
+%define RGB_BLUE  EXT_XRGB_BLUE
+%define RGB_PIXELSIZE  EXT_XRGB_PIXELSIZE
+%define jsimd_rgb_gray_convert_avx2  jsimd_extxrgb_gray_convert_avx2
+%include "jcgryext-avx2.asm"
diff --git a/3rdparty/libjpeg/src/simd/i386/jcgray-mmx.asm b/3rdparty/libjpeg/src/simd/i386/jcgray-mmx.asm
new file mode 100644
index 00000000..79fdf082
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/i386/jcgray-mmx.asm
@@ -0,0 +1,113 @@
+;
+; jcgray.asm - grayscale colorspace conversion (MMX)
+;
+; Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+; Copyright (C) 2011, 2016, D. R. Commander.
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+;
+; This file should be assembled with NASM (Netwide Assembler),
+; can *not* be assembled with Microsoft's MASM or any compatible
+; assembler (including Borland's Turbo Assembler).
+; NASM is available from http://nasm.sourceforge.net/ or
+; http://sourceforge.net/project/showfiles.php?group_id=6208
+
+%include "jsimdext.inc"
+
+; --------------------------------------------------------------------------
+
+%define SCALEBITS  16
+
+F_0_114 equ  7471                ; FIX(0.11400)
+F_0_250 equ 16384                ; FIX(0.25000)
+F_0_299 equ 19595                ; FIX(0.29900)
+F_0_587 equ 38470                ; FIX(0.58700)
+F_0_337 equ (F_0_587 - F_0_250)  ; FIX(0.58700) - FIX(0.25000)
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_CONST
+
+    alignz      32
+    GLOBAL_DATA(jconst_rgb_gray_convert_mmx)
+
+EXTN(jconst_rgb_gray_convert_mmx):
+
+PW_F0299_F0337 times 2 dw F_0_299, F_0_337
+PW_F0114_F0250 times 2 dw F_0_114, F_0_250
+PD_ONEHALF     times 2 dd (1 << (SCALEBITS - 1))
+
+    alignz      32
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_TEXT
+    BITS        32
+
+%include "jcgryext-mmx.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_RGB_RED
+%define RGB_GREEN  EXT_RGB_GREEN
+%define RGB_BLUE  EXT_RGB_BLUE
+%define RGB_PIXELSIZE  EXT_RGB_PIXELSIZE
+%define jsimd_rgb_gray_convert_mmx  jsimd_extrgb_gray_convert_mmx
+%include "jcgryext-mmx.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_RGBX_RED
+%define RGB_GREEN  EXT_RGBX_GREEN
+%define RGB_BLUE  EXT_RGBX_BLUE
+%define RGB_PIXELSIZE  EXT_RGBX_PIXELSIZE
+%define jsimd_rgb_gray_convert_mmx  jsimd_extrgbx_gray_convert_mmx
+%include "jcgryext-mmx.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_BGR_RED
+%define RGB_GREEN  EXT_BGR_GREEN
+%define RGB_BLUE  EXT_BGR_BLUE
+%define RGB_PIXELSIZE  EXT_BGR_PIXELSIZE
+%define jsimd_rgb_gray_convert_mmx  jsimd_extbgr_gray_convert_mmx
+%include "jcgryext-mmx.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_BGRX_RED
+%define RGB_GREEN  EXT_BGRX_GREEN
+%define RGB_BLUE  EXT_BGRX_BLUE
+%define RGB_PIXELSIZE  EXT_BGRX_PIXELSIZE
+%define jsimd_rgb_gray_convert_mmx  jsimd_extbgrx_gray_convert_mmx
+%include "jcgryext-mmx.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_XBGR_RED
+%define RGB_GREEN  EXT_XBGR_GREEN
+%define RGB_BLUE  EXT_XBGR_BLUE
+%define RGB_PIXELSIZE  EXT_XBGR_PIXELSIZE
+%define jsimd_rgb_gray_convert_mmx  jsimd_extxbgr_gray_convert_mmx
+%include "jcgryext-mmx.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_XRGB_RED
+%define RGB_GREEN  EXT_XRGB_GREEN
+%define RGB_BLUE  EXT_XRGB_BLUE
+%define RGB_PIXELSIZE  EXT_XRGB_PIXELSIZE
+%define jsimd_rgb_gray_convert_mmx  jsimd_extxrgb_gray_convert_mmx
+%include "jcgryext-mmx.asm"
diff --git a/3rdparty/libjpeg/src/simd/i386/jcgray-sse2.asm b/3rdparty/libjpeg/src/simd/i386/jcgray-sse2.asm
new file mode 100644
index 00000000..cb4b28e8
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/i386/jcgray-sse2.asm
@@ -0,0 +1,112 @@
+;
+; jcgray.asm - grayscale colorspace conversion (SSE2)
+;
+; Copyright (C) 2011, 2016, D. R. Commander.
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+;
+; This file should be assembled with NASM (Netwide Assembler),
+; can *not* be assembled with Microsoft's MASM or any compatible
+; assembler (including Borland's Turbo Assembler).
+; NASM is available from http://nasm.sourceforge.net/ or
+; http://sourceforge.net/project/showfiles.php?group_id=6208
+
+%include "jsimdext.inc"
+
+; --------------------------------------------------------------------------
+
+%define SCALEBITS  16
+
+F_0_114 equ  7471                ; FIX(0.11400)
+F_0_250 equ 16384                ; FIX(0.25000)
+F_0_299 equ 19595                ; FIX(0.29900)
+F_0_587 equ 38470                ; FIX(0.58700)
+F_0_337 equ (F_0_587 - F_0_250)  ; FIX(0.58700) - FIX(0.25000)
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_CONST
+
+    alignz      32
+    GLOBAL_DATA(jconst_rgb_gray_convert_sse2)
+
+EXTN(jconst_rgb_gray_convert_sse2):
+
+PW_F0299_F0337 times 4 dw F_0_299, F_0_337
+PW_F0114_F0250 times 4 dw F_0_114, F_0_250
+PD_ONEHALF     times 4 dd (1 << (SCALEBITS - 1))
+
+    alignz      32
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_TEXT
+    BITS        32
+
+%include "jcgryext-sse2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_RGB_RED
+%define RGB_GREEN  EXT_RGB_GREEN
+%define RGB_BLUE  EXT_RGB_BLUE
+%define RGB_PIXELSIZE  EXT_RGB_PIXELSIZE
+%define jsimd_rgb_gray_convert_sse2  jsimd_extrgb_gray_convert_sse2
+%include "jcgryext-sse2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_RGBX_RED
+%define RGB_GREEN  EXT_RGBX_GREEN
+%define RGB_BLUE  EXT_RGBX_BLUE
+%define RGB_PIXELSIZE  EXT_RGBX_PIXELSIZE
+%define jsimd_rgb_gray_convert_sse2  jsimd_extrgbx_gray_convert_sse2
+%include "jcgryext-sse2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_BGR_RED
+%define RGB_GREEN  EXT_BGR_GREEN
+%define RGB_BLUE  EXT_BGR_BLUE
+%define RGB_PIXELSIZE  EXT_BGR_PIXELSIZE
+%define jsimd_rgb_gray_convert_sse2  jsimd_extbgr_gray_convert_sse2
+%include "jcgryext-sse2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_BGRX_RED
+%define RGB_GREEN  EXT_BGRX_GREEN
+%define RGB_BLUE  EXT_BGRX_BLUE
+%define RGB_PIXELSIZE  EXT_BGRX_PIXELSIZE
+%define jsimd_rgb_gray_convert_sse2  jsimd_extbgrx_gray_convert_sse2
+%include "jcgryext-sse2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_XBGR_RED
+%define RGB_GREEN  EXT_XBGR_GREEN
+%define RGB_BLUE  EXT_XBGR_BLUE
+%define RGB_PIXELSIZE  EXT_XBGR_PIXELSIZE
+%define jsimd_rgb_gray_convert_sse2  jsimd_extxbgr_gray_convert_sse2
+%include "jcgryext-sse2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_XRGB_RED
+%define RGB_GREEN  EXT_XRGB_GREEN
+%define RGB_BLUE  EXT_XRGB_BLUE
+%define RGB_PIXELSIZE  EXT_XRGB_PIXELSIZE
+%define jsimd_rgb_gray_convert_sse2  jsimd_extxrgb_gray_convert_sse2
+%include "jcgryext-sse2.asm"
diff --git a/3rdparty/libjpeg/src/simd/i386/jcgryext-avx2.asm b/3rdparty/libjpeg/src/simd/i386/jcgryext-avx2.asm
new file mode 100644
index 00000000..3fa7973d
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/i386/jcgryext-avx2.asm
@@ -0,0 +1,457 @@
+;
+; jcgryext.asm - grayscale colorspace conversion (AVX2)
+;
+; Copyright (C) 2011, 2016, D. R. Commander.
+; Copyright (C) 2015, Intel Corporation.
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+;
+; This file should be assembled with NASM (Netwide Assembler),
+; can *not* be assembled with Microsoft's MASM or any compatible
+; assembler (including Borland's Turbo Assembler).
+; NASM is available from http://nasm.sourceforge.net/ or
+; http://sourceforge.net/project/showfiles.php?group_id=6208
+
+%include "jcolsamp.inc"
+
+; --------------------------------------------------------------------------
+;
+; Convert some rows of samples to the output colorspace.
+;
+; GLOBAL(void)
+; jsimd_rgb_gray_convert_avx2(JDIMENSION img_width, JSAMPARRAY input_buf,
+;                             JSAMPIMAGE output_buf, JDIMENSION output_row,
+;                             int num_rows);
+;
+
+%define img_width(b)   (b) + 8          ; JDIMENSION img_width
+%define input_buf(b)   (b) + 12         ; JSAMPARRAY input_buf
+%define output_buf(b)  (b) + 16         ; JSAMPIMAGE output_buf
+%define output_row(b)  (b) + 20         ; JDIMENSION output_row
+%define num_rows(b)    (b) + 24         ; int num_rows
+
+%define original_ebp   ebp + 0
+%define wk(i)          ebp - (WK_NUM - (i)) * SIZEOF_YMMWORD
+                                        ; ymmword wk[WK_NUM]
+%define WK_NUM         2
+%define gotptr         wk(0) - SIZEOF_POINTER  ; void * gotptr
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_rgb_gray_convert_avx2)
+
+EXTN(jsimd_rgb_gray_convert_avx2):
+    push        ebp
+    mov         eax, esp                     ; eax = original ebp
+    sub         esp, byte 4
+    and         esp, byte (-SIZEOF_YMMWORD)  ; align to 256 bits
+    mov         [esp], eax
+    mov         ebp, esp                     ; ebp = aligned ebp
+    lea         esp, [wk(0)]
+    pushpic     eax                     ; make a room for GOT address
+    push        ebx
+;   push        ecx                     ; need not be preserved
+;   push        edx                     ; need not be preserved
+    push        esi
+    push        edi
+
+    get_GOT     ebx                     ; get GOT address
+    movpic      POINTER [gotptr], ebx   ; save GOT address
+
+    mov         ecx, JDIMENSION [img_width(eax)]
+    test        ecx, ecx
+    jz          near .return
+
+    push        ecx
+
+    mov         esi, JSAMPIMAGE [output_buf(eax)]
+    mov         ecx, JDIMENSION [output_row(eax)]
+    mov         edi, JSAMPARRAY [esi+0*SIZEOF_JSAMPARRAY]
+    lea         edi, [edi+ecx*SIZEOF_JSAMPROW]
+
+    pop         ecx
+
+    mov         esi, JSAMPARRAY [input_buf(eax)]
+    mov         eax, INT [num_rows(eax)]
+    test        eax, eax
+    jle         near .return
+    alignx      16, 7
+.rowloop:
+    pushpic     eax
+    push        edi
+    push        esi
+    push        ecx                     ; col
+
+    mov         esi, JSAMPROW [esi]     ; inptr
+    mov         edi, JSAMPROW [edi]     ; outptr0
+    movpic      eax, POINTER [gotptr]   ; load GOT address (eax)
+
+    cmp         ecx, byte SIZEOF_YMMWORD
+    jae         near .columnloop
+    alignx      16, 7
+
+%if RGB_PIXELSIZE == 3  ; ---------------
+
+.column_ld1:
+    push        eax
+    push        edx
+    lea         ecx, [ecx+ecx*2]        ; imul ecx,RGB_PIXELSIZE
+    test        cl, SIZEOF_BYTE
+    jz          short .column_ld2
+    sub         ecx, byte SIZEOF_BYTE
+    movzx       eax, byte [esi+ecx]
+.column_ld2:
+    test        cl, SIZEOF_WORD
+    jz          short .column_ld4
+    sub         ecx, byte SIZEOF_WORD
+    movzx       edx, word [esi+ecx]
+    shl         eax, WORD_BIT
+    or          eax, edx
+.column_ld4:
+    vmovd       xmmA, eax
+    pop         edx
+    pop         eax
+    test        cl, SIZEOF_DWORD
+    jz          short .column_ld8
+    sub         ecx, byte SIZEOF_DWORD
+    vmovd       xmmF, XMM_DWORD [esi+ecx]
+    vpslldq     xmmA, xmmA, SIZEOF_DWORD
+    vpor        xmmA, xmmA, xmmF
+.column_ld8:
+    test        cl, SIZEOF_MMWORD
+    jz          short .column_ld16
+    sub         ecx, byte SIZEOF_MMWORD
+    vmovq       xmmB, XMM_MMWORD [esi+ecx]
+    vpslldq     xmmA, xmmA, SIZEOF_MMWORD
+    vpor        xmmA, xmmA, xmmB
+.column_ld16:
+    test        cl, SIZEOF_XMMWORD
+    jz          short .column_ld32
+    sub         ecx, byte SIZEOF_XMMWORD
+    vmovdqu     xmmB, XMM_MMWORD [esi+ecx]
+    vperm2i128  ymmA, ymmA, ymmA, 1
+    vpor        ymmA, ymmB
+.column_ld32:
+    test        cl, SIZEOF_YMMWORD
+    jz          short .column_ld64
+    sub         ecx, byte SIZEOF_YMMWORD
+    vmovdqa     ymmF, ymmA
+    vmovdqu     ymmA, YMMWORD [esi+0*SIZEOF_YMMWORD]
+.column_ld64:
+    test        cl, 2*SIZEOF_YMMWORD
+    mov         ecx, SIZEOF_YMMWORD
+    jz          short .rgb_gray_cnv
+    vmovdqa     ymmB, ymmA
+    vmovdqu     ymmA, YMMWORD [esi+0*SIZEOF_YMMWORD]
+    vmovdqu     ymmF, YMMWORD [esi+1*SIZEOF_YMMWORD]
+    jmp         short .rgb_gray_cnv
+    alignx      16, 7
+
+.columnloop:
+    vmovdqu     ymmA, YMMWORD [esi+0*SIZEOF_YMMWORD]
+    vmovdqu     ymmF, YMMWORD [esi+1*SIZEOF_YMMWORD]
+    vmovdqu     ymmB, YMMWORD [esi+2*SIZEOF_YMMWORD]
+
+.rgb_gray_cnv:
+    ; ymmA=(00 10 20 01 11 21 02 12 22 03 13 23 04 14 24 05
+    ;       15 25 06 16 26 07 17 27 08 18 28 09 19 29 0A 1A)
+    ; ymmF=(2A 0B 1B 2B 0C 1C 2C 0D 1D 2D 0E 1E 2E 0F 1F 2F
+    ;       0G 1G 2G 0H 1H 2H 0I 1I 2I 0J 1J 2J 0K 1K 2K 0L)
+    ; ymmB=(1L 2L 0M 1M 2M 0N 1N 2N 0O 1O 2O 0P 1P 2P 0Q 1Q
+    ;       2Q 0R 1R 2R 0S 1S 2S 0T 1T 2T 0U 1U 2U 0V 1V 2V)
+
+    vmovdqu     ymmC, ymmA
+    vinserti128 ymmA, ymmF, xmmA, 0  ; ymmA=(00 10 20 01 11 21 02 12 22 03 13 23 04 14 24 05
+                                     ;       0G 1G 2G 0H 1H 2H 0I 1I 2I 0J 1J 2J 0K 1K 2K 0L)
+    vinserti128 ymmC, ymmC, xmmB, 0  ; ymmC=(1L 2L 0M 1M 2M 0N 1N 2N 0O 1O 2O 0P 1P 2P 0Q 1Q
+                                     ;       15 25 06 16 26 07 17 27 08 18 28 09 19 29 0A 1A)
+    vinserti128 ymmB, ymmB, xmmF, 0  ; ymmB=(2A 0B 1B 2B 0C 1C 2C 0D 1D 2D 0E 1E 2E 0F 1F 2F
+                                     ;       2Q 0R 1R 2R 0S 1S 2S 0T 1T 2T 0U 1U 2U 0V 1V 2V)
+    vperm2i128  ymmF, ymmC, ymmC, 1  ; ymmF=(15 25 06 16 26 07 17 27 08 18 28 09 19 29 0A 1A
+                                     ;       1L 2L 0M 1M 2M 0N 1N 2N 0O 1O 2O 0P 1P 2P 0Q 1Q)
+
+    vmovdqa     ymmG, ymmA
+    vpslldq     ymmA, ymmA, 8     ; ymmA=(-- -- -- -- -- -- -- -- 00 10 20 01 11 21 02 12
+                                  ;       22 03 13 23 04 14 24 05 0G 1G 2G 0H 1H 2H 0I 1I)
+    vpsrldq     ymmG, ymmG, 8     ; ymmG=(22 03 13 23 04 14 24 05 0G 1G 2G 0H 1H 2H 0I 1I
+                                  ;       2I 0J 1J 2J 0K 1K 2K 0L -- -- -- -- -- -- -- --)
+
+    vpunpckhbw  ymmA, ymmA, ymmF  ; ymmA=(00 08 10 18 20 28 01 09 11 19 21 29 02 0A 12 1A
+                                  ;       0G 0O 1G 1O 2G 2O 0H 0P 1H 1P 2H 2P 0I 0Q 1I 1Q)
+    vpslldq     ymmF, ymmF, 8     ; ymmF=(-- -- -- -- -- -- -- -- 15 25 06 16 26 07 17 27
+                                  ;       08 18 28 09 19 29 0A 1A 1L 2L 0M 1M 2M 0N 1N 2N)
+
+    vpunpcklbw  ymmG, ymmG, ymmB  ; ymmG=(22 2A 03 0B 13 1B 23 2B 04 0C 14 1C 24 2C 05 0D
+                                  ;       2I 2Q 0J 0R 1J 1R 2J 2R 0K 0S 1K 1S 2K 2S 0L 0T)
+    vpunpckhbw  ymmF, ymmF, ymmB  ; ymmF=(15 1D 25 2D 06 0E 16 1E 26 2E 07 0F 17 1F 27 2F
+                                  ;       1L 1T 2L 2T 0M 0U 1M 1U 2M 2U 0N 0V 1N 1V 2N 2V)
+
+    vmovdqa     ymmD, ymmA
+    vpslldq     ymmA, ymmA, 8     ; ymmA=(-- -- -- -- -- -- -- -- 00 08 10 18 20 28 01 09
+                                  ;       11 19 21 29 02 0A 12 1A 0G 0O 1G 1O 2G 2O 0H 0P)
+    vpsrldq     ymmD, ymmD, 8     ; ymmD=(11 19 21 29 02 0A 12 1A 0G 0O 1G 1O 2G 2O 0H 0P
+                                  ;       1H 1P 2H 2P 0I 0Q 1I 1Q -- -- -- -- -- -- -- --)
+
+    vpunpckhbw  ymmA, ymmA, ymmG  ; ymmA=(00 04 08 0C 10 14 18 1C 20 24 28 2C 01 05 09 0D
+                                  ;       0G 0K 0O 0S 1G 1K 1O 1S 2G 2K 2O 2S 0H 0L 0P 0T)
+    vpslldq     ymmG, ymmG, 8     ; ymmG=(-- -- -- -- -- -- -- -- 22 2A 03 0B 13 1B 23 2B
+                                  ;       04 0C 14 1C 24 2C 05 0D 2I 2Q 0J 0R 1J 1R 2J 2R)
+
+    vpunpcklbw  ymmD, ymmD, ymmF  ; ymmD=(11 15 19 1D 21 25 29 2D 02 06 0A 0E 12 16 1A 1E
+                                  ;       1H 1L 1P 1T 2H 2L 2P 2T 0I 0M 0Q 0U 1I 1M 1Q 1U)
+    vpunpckhbw  ymmG, ymmG, ymmF  ; ymmG=(22 26 2A 2E 03 07 0B 0F 13 17 1B 1F 23 27 2B 2F
+                                  ;       2I 2M 2Q 2U 0J 0N 0R 0V 1J 1N 1R 1V 2J 2N 2R 2V)
+
+    vmovdqa     ymmE, ymmA
+    vpslldq     ymmA, ymmA, 8     ; ymmA=(-- -- -- -- -- -- -- -- 00 04 08 0C 10 14 18 1C
+                                  ;       20 24 28 2C 01 05 09 0D 0G 0K 0O 0S 1G 1K 1O 1S)
+    vpsrldq     ymmE, ymmE, 8     ; ymmE=(20 24 28 2C 01 05 09 0D 0G 0K 0O 0S 1G 1K 1O 1S
+                                  ;       2G 2K 2O 2S 0H 0L 0P 0T -- -- -- -- -- -- -- --)
+
+    vpunpckhbw  ymmA, ymmA, ymmD  ; ymmA=(00 02 04 06 08 0A 0C 0E 10 12 14 16 18 1A 1C 1E
+                                  ;       0G 0I 0K 0M 0O 0Q 0S 0U 1G 1I 1K 1M 1O 1Q 1S 1U)
+    vpslldq     ymmD, ymmD, 8     ; ymmD=(-- -- -- -- -- -- -- -- 11 15 19 1D 21 25 29 2D
+                                  ;       02 06 0A 0E 12 16 1A 1E 1H 1L 1P 1T 2H 2L 2P 2T)
+
+    vpunpcklbw  ymmE, ymmE, ymmG  ; ymmE=(20 22 24 26 28 2A 2C 2E 01 03 05 07 09 0B 0D 0F
+                                  ;       2G 2I 2K 2M 2O 2Q 2S 2U 0H 0J 0L 0N 0P 0R 0T 0V)
+    vpunpckhbw  ymmD, ymmD, ymmG  ; ymmD=(11 13 15 17 19 1B 1D 1F 21 23 25 27 29 2B 2D 2F
+                                  ;       1H 1J 1L 1N 1P 1R 1T 1V 2H 2J 2L 2N 2P 2R 2T 2V)
+
+    vpxor       ymmH, ymmH, ymmH
+
+    vmovdqa     ymmC, ymmA
+    vpunpcklbw  ymmA, ymmA, ymmH  ; ymmA=(00 02 04 06 08 0A 0C 0E 0G 0I 0K 0M 0O 0Q 0S 0U)
+    vpunpckhbw  ymmC, ymmC, ymmH  ; ymmC=(10 12 14 16 18 1A 1C 1E 1G 1I 1K 1M 1O 1Q 1S 1U)
+
+    vmovdqa     ymmB, ymmE
+    vpunpcklbw  ymmE, ymmE, ymmH  ; ymmE=(20 22 24 26 28 2A 2C 2E 2G 2I 2K 2M 2O 2Q 2S 2U)
+    vpunpckhbw  ymmB, ymmB, ymmH  ; ymmB=(01 03 05 07 09 0B 0D 0F 0H 0J 0L 0N 0P 0R 0T 0V)
+
+    vmovdqa     ymmF, ymmD
+    vpunpcklbw  ymmD, ymmD, ymmH  ; ymmD=(11 13 15 17 19 1B 1D 1F 1H 1J 1L 1N 1P 1R 1T 1V)
+    vpunpckhbw  ymmF, ymmF, ymmH  ; ymmF=(21 23 25 27 29 2B 2D 2F 2H 2J 2L 2N 2P 2R 2T 2V)
+
+%else  ; RGB_PIXELSIZE == 4 ; -----------
+
+.column_ld1:
+    test        cl, SIZEOF_XMMWORD/16
+    jz          short .column_ld2
+    sub         ecx, byte SIZEOF_XMMWORD/16
+    vmovd       xmmA, XMM_DWORD [esi+ecx*RGB_PIXELSIZE]
+.column_ld2:
+    test        cl, SIZEOF_XMMWORD/8
+    jz          short .column_ld4
+    sub         ecx, byte SIZEOF_XMMWORD/8
+    vmovq       xmmF, XMM_MMWORD [esi+ecx*RGB_PIXELSIZE]
+    vpslldq     xmmA, xmmA, SIZEOF_MMWORD
+    vpor        xmmA, xmmA, xmmF
+.column_ld4:
+    test        cl, SIZEOF_XMMWORD/4
+    jz          short .column_ld8
+    sub         ecx, byte SIZEOF_XMMWORD/4
+    vmovdqa     xmmF, xmmA
+    vperm2i128  ymmF, ymmF, ymmF, 1
+    vmovdqu     xmmA, XMMWORD [esi+ecx*RGB_PIXELSIZE]
+    vpor        ymmA, ymmA, ymmF
+.column_ld8:
+    test        cl, SIZEOF_XMMWORD/2
+    jz          short .column_ld16
+    sub         ecx, byte SIZEOF_XMMWORD/2
+    vmovdqa     ymmF, ymmA
+    vmovdqu     ymmA, YMMWORD [esi+ecx*RGB_PIXELSIZE]
+.column_ld16:
+    test        cl, SIZEOF_XMMWORD
+    mov         ecx, SIZEOF_YMMWORD
+    jz          short .rgb_gray_cnv
+    vmovdqa     ymmE, ymmA
+    vmovdqa     ymmH, ymmF
+    vmovdqu     ymmA, YMMWORD [esi+0*SIZEOF_YMMWORD]
+    vmovdqu     ymmF, YMMWORD [esi+1*SIZEOF_YMMWORD]
+    jmp         short .rgb_gray_cnv
+    alignx      16, 7
+
+.columnloop:
+    vmovdqu     ymmA, YMMWORD [esi+0*SIZEOF_YMMWORD]
+    vmovdqu     ymmF, YMMWORD [esi+1*SIZEOF_YMMWORD]
+    vmovdqu     ymmE, YMMWORD [esi+2*SIZEOF_YMMWORD]
+    vmovdqu     ymmH, YMMWORD [esi+3*SIZEOF_YMMWORD]
+
+.rgb_gray_cnv:
+    ; ymmA=(00 10 20 30 01 11 21 31 02 12 22 32 03 13 23 33
+    ;       04 14 24 34 05 15 25 35 06 16 26 36 07 17 27 37)
+    ; ymmF=(08 18 28 38 09 19 29 39 0A 1A 2A 3A 0B 1B 2B 3B
+    ;       0C 1C 2C 3C 0D 1D 2D 3D 0E 1E 2E 3E 0F 1F 2F 3F)
+    ; ymmE=(0G 1G 2G 3G 0H 1H 2H 3H 0I 1I 2I 3I 0J 1J 2J 3J
+    ;       0K 1K 2K 3K 0L 1L 2L 3L 0M 1M 2M 3M 0N 1N 2N 3N)
+    ; ymmH=(0O 1O 2O 3O 0P 1P 2P 3P 0Q 1Q 2Q 3Q 0R 1R 2R 3R
+    ;       0S 1S 2S 3S 0T 1T 2T 3T 0U 1U 2U 3U 0V 1V 2V 3V)
+
+    vmovdqa     ymmB, ymmA
+    vinserti128 ymmA, ymmA, xmmE, 1     ; ymmA=(00 10 20 30 01 11 21 31 02 12 22 32 03 13 23 33
+                                        ;       0G 1G 2G 3G 0H 1H 2H 3H 0I 1I 2I 3I 0J 1J 2J 3J)
+    vperm2i128  ymmE, ymmB, ymmE, 0x31  ; ymmE=(04 14 24 34 05 15 25 35 06 16 26 36 07 17 27 37
+                                        ;       0K 1K 2K 3K 0L 1L 2L 3L 0M 1M 2M 3M 0N 1N 2N 3N)
+
+    vmovdqa     ymmB, ymmF
+    vinserti128 ymmF, ymmF, xmmH, 1     ; ymmF=(08 18 28 38 09 19 29 39 0A 1A 2A 3A 0B 1B 2B 3B
+                                        ;       0O 1O 2O 3O 0P 1P 2P 3P 0Q 1Q 2Q 3Q 0R 1R 2R 3R)
+    vperm2i128  ymmH, ymmB, ymmH, 0x31  ; ymmH=(0C 1C 2C 3C 0D 1D 2D 3D 0E 1E 2E 3E 0F 1F 2F 3F
+                                        ;       0S 1S 2S 3S 0T 1T 2T 3T 0U 1U 2U 3U 0V 1V 2V 3V)
+
+    vmovdqa     ymmD, ymmA
+    vpunpcklbw  ymmA, ymmA, ymmE      ; ymmA=(00 04 10 14 20 24 30 34 01 05 11 15 21 25 31 35
+                                      ;       0G 0K 1G 1K 2G 2K 3G 3K 0H 0L 1H 1L 2H 2L 3H 3L)
+    vpunpckhbw  ymmD, ymmD, ymmE      ; ymmD=(02 06 12 16 22 26 32 36 03 07 13 17 23 27 33 37
+                                      ;       0I 0M 1I 1M 2I 2M 3I 3M 0J 0N 1J 1N 2J 2N 3J 3N)
+
+    vmovdqa     ymmC, ymmF
+    vpunpcklbw  ymmF, ymmF, ymmH      ; ymmF=(08 0C 18 1C 28 2C 38 3C 09 0D 19 1D 29 2D 39 3D
+                                      ;       0O 0S 1O 1S 2O 2S 3O 3S 0P 0T 1P 1T 2P 2T 3P 3T)
+    vpunpckhbw  ymmC, ymmC, ymmH      ; ymmC=(0A 0E 1A 1E 2A 2E 3A 3E 0B 0F 1B 1F 2B 2F 3B 3F
+                                      ;       0Q 0U 1Q 1U 2Q 2U 3Q 3U 0R 0V 1R 1V 2R 2V 3R 3V)
+
+    vmovdqa     ymmB, ymmA
+    vpunpcklwd  ymmA, ymmA, ymmF      ; ymmA=(00 04 08 0C 10 14 18 1C 20 24 28 2C 30 34 38 3C
+                                      ;       0G 0K 0O 0S 1G 1K 1O 1S 2G 2K 2O 2S 3G 3K 3O 3S)
+    vpunpckhwd  ymmB, ymmB, ymmF      ; ymmB=(01 05 09 0D 11 15 19 1D 21 25 29 2D 31 35 39 3D
+                                      ;       0H 0L 0P 0T 1H 1L 1P 1T 2H 2L 2P 2T 3H 3L 3P 3T)
+
+    vmovdqa     ymmG, ymmD
+    vpunpcklwd  ymmD, ymmD, ymmC      ; ymmD=(02 06 0A 0E 12 16 1A 1E 22 26 2A 2E 32 36 3A 3E
+                                      ;       0I 0M 0Q 0U 1I 1M 1Q 1U 2I 2M 2Q 2U 3I 3M 3Q 3U)
+    vpunpckhwd  ymmG, ymmG, ymmC      ; ymmG=(03 07 0B 0F 13 17 1B 1F 23 27 2B 2F 33 37 3B 3F
+                                      ;       0J 0N 0R 0V 1J 1N 1R 1V 2J 2N 2R 2V 3J 3N 3R 3V)
+
+    vmovdqa     ymmE, ymmA
+    vpunpcklbw  ymmA, ymmA, ymmD      ; ymmA=(00 02 04 06 08 0A 0C 0E 10 12 14 16 18 1A 1C 1E
+                                      ;       0G 0I 0K 0M 0O 0Q 0S 0U 1G 1I 1K 1M 1O 1Q 1S 1U)
+    vpunpckhbw  ymmE, ymmE, ymmD      ; ymmE=(20 22 24 26 28 2A 2C 2E 30 32 34 36 38 3A 3C 3E
+                                      ;       2G 2I 2K 2M 2O 2Q 2S 2U 3G 3I 3K 3M 3O 3Q 3S 3U)
+
+    vmovdqa     ymmH, ymmB
+    vpunpcklbw  ymmB, ymmB, ymmG      ; ymmB=(01 03 05 07 09 0B 0D 0F 11 13 15 17 19 1B 1D 1F
+                                      ;       0H 0J 0L 0N 0P 0R 0T 0V 1H 1J 1L 1N 1P 1R 1T 1V)
+    vpunpckhbw  ymmH, ymmH, ymmG      ; ymmH=(21 23 25 27 29 2B 2D 2F 31 33 35 37 39 3B 3D 3F
+                                      ;       2H 2J 2L 2N 2P 2R 2T 2V 3H 3J 3L 3N 3P 3R 3T 3V)
+
+    vpxor       ymmF, ymmF, ymmF
+
+    vmovdqa     ymmC, ymmA
+    vpunpcklbw  ymmA, ymmA, ymmF      ; ymmA=(00 02 04 06 08 0A 0C 0E 0G 0I 0K 0M 0O 0Q 0S 0U)
+    vpunpckhbw  ymmC, ymmC, ymmF      ; ymmC=(10 12 14 16 18 1A 1C 1E 1G 1I 1K 1M 1O 1Q 1S 1U)
+
+    vmovdqa     ymmD, ymmB
+    vpunpcklbw  ymmB, ymmB, ymmF      ; ymmB=(01 03 05 07 09 0B 0D 0F 0H 0J 0L 0N 0P 0R 0T 0V)
+    vpunpckhbw  ymmD, ymmD, ymmF      ; ymmD=(11 13 15 17 19 1B 1D 1F 1H 1J 1L 1N 1P 1R 1T 1V)
+
+    vmovdqa     ymmG, ymmE
+    vpunpcklbw  ymmE, ymmE, ymmF      ; ymmE=(20 22 24 26 28 2A 2C 2E 2G 2I 2K 2M 2O 2Q 2S 2U)
+    vpunpckhbw  ymmG, ymmG, ymmF      ; ymmG=(30 32 34 36 38 3A 3C 3E 3G 3I 3K 3M 3O 3Q 3S 3U)
+
+    vpunpcklbw  ymmF, ymmF, ymmH
+    vpunpckhbw  ymmH, ymmH, ymmH
+    vpsrlw      ymmF, ymmF, BYTE_BIT  ; ymmF=(21 23 25 27 29 2B 2D 2F 2H 2J 2L 2N 2P 2R 2T 2V)
+    vpsrlw      ymmH, ymmH, BYTE_BIT  ; ymmH=(31 33 35 37 39 3B 3D 3F 3H 3J 3L 3N 3P 3R 3T 3V)
+
+%endif  ; RGB_PIXELSIZE ; ---------------
+
+    ; ymm0=R(02468ACEGIKMOQSU)=RE, ymm2=G(02468ACEGIKMOQSU)=GE, ymm4=B(02468ACEGIKMOQSU)=BE
+    ; ymm1=R(13579BDFHJLNPRTV)=RO, ymm3=G(13579BDFHJLNPRTV)=GO, ymm5=B(13579BDFHJLNPRTV)=BO
+
+    ; (Original)
+    ; Y  =  0.29900 * R + 0.58700 * G + 0.11400 * B
+    ;
+    ; (This implementation)
+    ; Y  =  0.29900 * R + 0.33700 * G + 0.11400 * B + 0.25000 * G
+
+    vmovdqa     ymm6, ymm1
+    vpunpcklwd  ymm1, ymm1, ymm3
+    vpunpckhwd  ymm6, ymm6, ymm3
+    vpmaddwd    ymm1, ymm1, [GOTOFF(eax,PW_F0299_F0337)]  ; ymm1=ROL*FIX(0.299)+GOL*FIX(0.337)
+    vpmaddwd    ymm6, ymm6, [GOTOFF(eax,PW_F0299_F0337)]  ; ymm6=ROH*FIX(0.299)+GOH*FIX(0.337)
+
+    vmovdqa     ymm7, ymm6              ; ymm7=ROH*FIX(0.299)+GOH*FIX(0.337)
+
+    vmovdqa     ymm6, ymm0
+    vpunpcklwd  ymm0, ymm0, ymm2
+    vpunpckhwd  ymm6, ymm6, ymm2
+    vpmaddwd    ymm0, ymm0, [GOTOFF(eax,PW_F0299_F0337)]  ; ymm0=REL*FIX(0.299)+GEL*FIX(0.337)
+    vpmaddwd    ymm6, ymm6, [GOTOFF(eax,PW_F0299_F0337)]  ; ymm6=REH*FIX(0.299)+GEH*FIX(0.337)
+
+    vmovdqa     YMMWORD [wk(0)], ymm0   ; wk(0)=REL*FIX(0.299)+GEL*FIX(0.337)
+    vmovdqa     YMMWORD [wk(1)], ymm6   ; wk(1)=REH*FIX(0.299)+GEH*FIX(0.337)
+
+    vmovdqa     ymm0, ymm5              ; ymm0=BO
+    vmovdqa     ymm6, ymm4              ; ymm6=BE
+
+    vmovdqa     ymm4, ymm0
+    vpunpcklwd  ymm0, ymm0, ymm3
+    vpunpckhwd  ymm4, ymm4, ymm3
+    vpmaddwd    ymm0, ymm0, [GOTOFF(eax,PW_F0114_F0250)]  ; ymm0=BOL*FIX(0.114)+GOL*FIX(0.250)
+    vpmaddwd    ymm4, ymm4, [GOTOFF(eax,PW_F0114_F0250)]  ; ymm4=BOH*FIX(0.114)+GOH*FIX(0.250)
+
+    vmovdqa     ymm3, [GOTOFF(eax,PD_ONEHALF)]            ; ymm3=[PD_ONEHALF]
+
+    vpaddd      ymm0, ymm0, ymm1
+    vpaddd      ymm4, ymm4, ymm7
+    vpaddd      ymm0, ymm0, ymm3
+    vpaddd      ymm4, ymm4, ymm3
+    vpsrld      ymm0, ymm0, SCALEBITS   ; ymm0=YOL
+    vpsrld      ymm4, ymm4, SCALEBITS   ; ymm4=YOH
+    vpackssdw   ymm0, ymm0, ymm4        ; ymm0=YO
+
+    vmovdqa     ymm4, ymm6
+    vpunpcklwd  ymm6, ymm6, ymm2
+    vpunpckhwd  ymm4, ymm4, ymm2
+    vpmaddwd    ymm6, ymm6, [GOTOFF(eax,PW_F0114_F0250)]  ; ymm6=BEL*FIX(0.114)+GEL*FIX(0.250)
+    vpmaddwd    ymm4, ymm4, [GOTOFF(eax,PW_F0114_F0250)]  ; ymm4=BEH*FIX(0.114)+GEH*FIX(0.250)
+
+    vmovdqa     ymm2, [GOTOFF(eax,PD_ONEHALF)]            ; ymm2=[PD_ONEHALF]
+
+    vpaddd      ymm6, ymm6, YMMWORD [wk(0)]
+    vpaddd      ymm4, ymm4, YMMWORD [wk(1)]
+    vpaddd      ymm6, ymm6, ymm2
+    vpaddd      ymm4, ymm4, ymm2
+    vpsrld      ymm6, ymm6, SCALEBITS   ; ymm6=YEL
+    vpsrld      ymm4, ymm4, SCALEBITS   ; ymm4=YEH
+    vpackssdw   ymm6, ymm6, ymm4        ; ymm6=YE
+
+    vpsllw      ymm0, ymm0, BYTE_BIT
+    vpor        ymm6, ymm6, ymm0        ; ymm6=Y
+    vmovdqu     YMMWORD [edi], ymm6     ; Save Y
+
+    sub         ecx, byte SIZEOF_YMMWORD
+    add         esi, RGB_PIXELSIZE*SIZEOF_YMMWORD  ; inptr
+    add         edi, byte SIZEOF_YMMWORD           ; outptr0
+    cmp         ecx, byte SIZEOF_YMMWORD
+    jae         near .columnloop
+    test        ecx, ecx
+    jnz         near .column_ld1
+
+    pop         ecx                     ; col
+    pop         esi
+    pop         edi
+    poppic      eax
+
+    add         esi, byte SIZEOF_JSAMPROW  ; input_buf
+    add         edi, byte SIZEOF_JSAMPROW
+    dec         eax                        ; num_rows
+    jg          near .rowloop
+
+.return:
+    vzeroupper
+    pop         edi
+    pop         esi
+;   pop         edx                     ; need not be preserved
+;   pop         ecx                     ; need not be preserved
+    pop         ebx
+    mov         esp, ebp                ; esp <- aligned ebp
+    pop         esp                     ; esp <- original ebp
+    pop         ebp
+    ret
+
+; For some reason, the OS X linker does not honor the request to align the
+; segment unless we do this.
+    align       32
diff --git a/3rdparty/libjpeg/src/simd/i386/jcgryext-mmx.asm b/3rdparty/libjpeg/src/simd/i386/jcgryext-mmx.asm
new file mode 100644
index 00000000..8af42e5a
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/i386/jcgryext-mmx.asm
@@ -0,0 +1,355 @@
+;
+; jcgryext.asm - grayscale colorspace conversion (MMX)
+;
+; Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+; Copyright (C) 2011, 2016, D. R. Commander.
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+;
+; This file should be assembled with NASM (Netwide Assembler),
+; can *not* be assembled with Microsoft's MASM or any compatible
+; assembler (including Borland's Turbo Assembler).
+; NASM is available from http://nasm.sourceforge.net/ or
+; http://sourceforge.net/project/showfiles.php?group_id=6208
+
+%include "jcolsamp.inc"
+
+; --------------------------------------------------------------------------
+;
+; Convert some rows of samples to the output colorspace.
+;
+; GLOBAL(void)
+; jsimd_rgb_gray_convert_mmx(JDIMENSION img_width, JSAMPARRAY input_buf,
+;                            JSAMPIMAGE output_buf, JDIMENSION output_row,
+;                            int num_rows);
+;
+
+%define img_width(b)   (b) + 8          ; JDIMENSION img_width
+%define input_buf(b)   (b) + 12         ; JSAMPARRAY input_buf
+%define output_buf(b)  (b) + 16         ; JSAMPIMAGE output_buf
+%define output_row(b)  (b) + 20         ; JDIMENSION output_row
+%define num_rows(b)    (b) + 24         ; int num_rows
+
+%define original_ebp   ebp + 0
+%define wk(i)          ebp - (WK_NUM - (i)) * SIZEOF_MMWORD
+                                        ; mmword wk[WK_NUM]
+%define WK_NUM         2
+%define gotptr         wk(0) - SIZEOF_POINTER  ; void * gotptr
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_rgb_gray_convert_mmx)
+
+EXTN(jsimd_rgb_gray_convert_mmx):
+    push        ebp
+    mov         eax, esp                    ; eax = original ebp
+    sub         esp, byte 4
+    and         esp, byte (-SIZEOF_MMWORD)  ; align to 64 bits
+    mov         [esp], eax
+    mov         ebp, esp                    ; ebp = aligned ebp
+    lea         esp, [wk(0)]
+    pushpic     eax                     ; make a room for GOT address
+    push        ebx
+;   push        ecx                     ; need not be preserved
+;   push        edx                     ; need not be preserved
+    push        esi
+    push        edi
+
+    get_GOT     ebx                     ; get GOT address
+    movpic      POINTER [gotptr], ebx   ; save GOT address
+
+    mov         ecx, JDIMENSION [img_width(eax)]  ; num_cols
+    test        ecx, ecx
+    jz          near .return
+
+    push        ecx
+
+    mov         esi, JSAMPIMAGE [output_buf(eax)]
+    mov         ecx, JDIMENSION [output_row(eax)]
+    mov         edi, JSAMPARRAY [esi+0*SIZEOF_JSAMPARRAY]
+    lea         edi, [edi+ecx*SIZEOF_JSAMPROW]
+
+    pop         ecx
+
+    mov         esi, JSAMPARRAY [input_buf(eax)]
+    mov         eax, INT [num_rows(eax)]
+    test        eax, eax
+    jle         near .return
+    alignx      16, 7
+.rowloop:
+    pushpic     eax
+    push        edi
+    push        esi
+    push        ecx                     ; col
+
+    mov         esi, JSAMPROW [esi]     ; inptr
+    mov         edi, JSAMPROW [edi]     ; outptr0
+    movpic      eax, POINTER [gotptr]   ; load GOT address (eax)
+
+    cmp         ecx, byte SIZEOF_MMWORD
+    jae         short .columnloop
+    alignx      16, 7
+
+%if RGB_PIXELSIZE == 3  ; ---------------
+
+.column_ld1:
+    push        eax
+    push        edx
+    lea         ecx, [ecx+ecx*2]        ; imul ecx,RGB_PIXELSIZE
+    test        cl, SIZEOF_BYTE
+    jz          short .column_ld2
+    sub         ecx, byte SIZEOF_BYTE
+    xor         eax, eax
+    mov         al, byte [esi+ecx]
+.column_ld2:
+    test        cl, SIZEOF_WORD
+    jz          short .column_ld4
+    sub         ecx, byte SIZEOF_WORD
+    xor         edx, edx
+    mov         dx, word [esi+ecx]
+    shl         eax, WORD_BIT
+    or          eax, edx
+.column_ld4:
+    movd        mmA, eax
+    pop         edx
+    pop         eax
+    test        cl, SIZEOF_DWORD
+    jz          short .column_ld8
+    sub         ecx, byte SIZEOF_DWORD
+    movd        mmG, dword [esi+ecx]
+    psllq       mmA, DWORD_BIT
+    por         mmA, mmG
+.column_ld8:
+    test        cl, SIZEOF_MMWORD
+    jz          short .column_ld16
+    movq        mmG, mmA
+    movq        mmA, MMWORD [esi+0*SIZEOF_MMWORD]
+    mov         ecx, SIZEOF_MMWORD
+    jmp         short .rgb_gray_cnv
+.column_ld16:
+    test        cl, 2*SIZEOF_MMWORD
+    mov         ecx, SIZEOF_MMWORD
+    jz          short .rgb_gray_cnv
+    movq        mmF, mmA
+    movq        mmA, MMWORD [esi+0*SIZEOF_MMWORD]
+    movq        mmG, MMWORD [esi+1*SIZEOF_MMWORD]
+    jmp         short .rgb_gray_cnv
+    alignx      16, 7
+
+.columnloop:
+    movq        mmA, MMWORD [esi+0*SIZEOF_MMWORD]
+    movq        mmG, MMWORD [esi+1*SIZEOF_MMWORD]
+    movq        mmF, MMWORD [esi+2*SIZEOF_MMWORD]
+
+.rgb_gray_cnv:
+    ; mmA=(00 10 20 01 11 21 02 12)
+    ; mmG=(22 03 13 23 04 14 24 05)
+    ; mmF=(15 25 06 16 26 07 17 27)
+
+    movq        mmD, mmA
+    psllq       mmA, 4*BYTE_BIT         ; mmA=(-- -- -- -- 00 10 20 01)
+    psrlq       mmD, 4*BYTE_BIT         ; mmD=(11 21 02 12 -- -- -- --)
+
+    punpckhbw   mmA, mmG                ; mmA=(00 04 10 14 20 24 01 05)
+    psllq       mmG, 4*BYTE_BIT         ; mmG=(-- -- -- -- 22 03 13 23)
+
+    punpcklbw   mmD, mmF                ; mmD=(11 15 21 25 02 06 12 16)
+    punpckhbw   mmG, mmF                ; mmG=(22 26 03 07 13 17 23 27)
+
+    movq        mmE, mmA
+    psllq       mmA, 4*BYTE_BIT         ; mmA=(-- -- -- -- 00 04 10 14)
+    psrlq       mmE, 4*BYTE_BIT         ; mmE=(20 24 01 05 -- -- -- --)
+
+    punpckhbw   mmA, mmD                ; mmA=(00 02 04 06 10 12 14 16)
+    psllq       mmD, 4*BYTE_BIT         ; mmD=(-- -- -- -- 11 15 21 25)
+
+    punpcklbw   mmE, mmG                ; mmE=(20 22 24 26 01 03 05 07)
+    punpckhbw   mmD, mmG                ; mmD=(11 13 15 17 21 23 25 27)
+
+    pxor        mmH, mmH
+
+    movq        mmC, mmA
+    punpcklbw   mmA, mmH                ; mmA=(00 02 04 06)
+    punpckhbw   mmC, mmH                ; mmC=(10 12 14 16)
+
+    movq        mmB, mmE
+    punpcklbw   mmE, mmH                ; mmE=(20 22 24 26)
+    punpckhbw   mmB, mmH                ; mmB=(01 03 05 07)
+
+    movq        mmF, mmD
+    punpcklbw   mmD, mmH                ; mmD=(11 13 15 17)
+    punpckhbw   mmF, mmH                ; mmF=(21 23 25 27)
+
+%else  ; RGB_PIXELSIZE == 4 ; -----------
+
+.column_ld1:
+    test        cl, SIZEOF_MMWORD/8
+    jz          short .column_ld2
+    sub         ecx, byte SIZEOF_MMWORD/8
+    movd        mmA, dword [esi+ecx*RGB_PIXELSIZE]
+.column_ld2:
+    test        cl, SIZEOF_MMWORD/4
+    jz          short .column_ld4
+    sub         ecx, byte SIZEOF_MMWORD/4
+    movq        mmF, mmA
+    movq        mmA, MMWORD [esi+ecx*RGB_PIXELSIZE]
+.column_ld4:
+    test        cl, SIZEOF_MMWORD/2
+    mov         ecx, SIZEOF_MMWORD
+    jz          short .rgb_gray_cnv
+    movq        mmD, mmA
+    movq        mmC, mmF
+    movq        mmA, MMWORD [esi+0*SIZEOF_MMWORD]
+    movq        mmF, MMWORD [esi+1*SIZEOF_MMWORD]
+    jmp         short .rgb_gray_cnv
+    alignx      16, 7
+
+.columnloop:
+    movq        mmA, MMWORD [esi+0*SIZEOF_MMWORD]
+    movq        mmF, MMWORD [esi+1*SIZEOF_MMWORD]
+    movq        mmD, MMWORD [esi+2*SIZEOF_MMWORD]
+    movq        mmC, MMWORD [esi+3*SIZEOF_MMWORD]
+
+.rgb_gray_cnv:
+    ; mmA=(00 10 20 30 01 11 21 31)
+    ; mmF=(02 12 22 32 03 13 23 33)
+    ; mmD=(04 14 24 34 05 15 25 35)
+    ; mmC=(06 16 26 36 07 17 27 37)
+
+    movq        mmB, mmA
+    punpcklbw   mmA, mmF                ; mmA=(00 02 10 12 20 22 30 32)
+    punpckhbw   mmB, mmF                ; mmB=(01 03 11 13 21 23 31 33)
+
+    movq        mmG, mmD
+    punpcklbw   mmD, mmC                ; mmD=(04 06 14 16 24 26 34 36)
+    punpckhbw   mmG, mmC                ; mmG=(05 07 15 17 25 27 35 37)
+
+    movq        mmE, mmA
+    punpcklwd   mmA, mmD                ; mmA=(00 02 04 06 10 12 14 16)
+    punpckhwd   mmE, mmD                ; mmE=(20 22 24 26 30 32 34 36)
+
+    movq        mmH, mmB
+    punpcklwd   mmB, mmG                ; mmB=(01 03 05 07 11 13 15 17)
+    punpckhwd   mmH, mmG                ; mmH=(21 23 25 27 31 33 35 37)
+
+    pxor        mmF, mmF
+
+    movq        mmC, mmA
+    punpcklbw   mmA, mmF                ; mmA=(00 02 04 06)
+    punpckhbw   mmC, mmF                ; mmC=(10 12 14 16)
+
+    movq        mmD, mmB
+    punpcklbw   mmB, mmF                ; mmB=(01 03 05 07)
+    punpckhbw   mmD, mmF                ; mmD=(11 13 15 17)
+
+    movq        mmG, mmE
+    punpcklbw   mmE, mmF                ; mmE=(20 22 24 26)
+    punpckhbw   mmG, mmF                ; mmG=(30 32 34 36)
+
+    punpcklbw   mmF, mmH
+    punpckhbw   mmH, mmH
+    psrlw       mmF, BYTE_BIT           ; mmF=(21 23 25 27)
+    psrlw       mmH, BYTE_BIT           ; mmH=(31 33 35 37)
+
+%endif  ; RGB_PIXELSIZE ; ---------------
+
+    ; mm0=(R0 R2 R4 R6)=RE, mm2=(G0 G2 G4 G6)=GE, mm4=(B0 B2 B4 B6)=BE
+    ; mm1=(R1 R3 R5 R7)=RO, mm3=(G1 G3 G5 G7)=GO, mm5=(B1 B3 B5 B7)=BO
+
+    ; (Original)
+    ; Y  =  0.29900 * R + 0.58700 * G + 0.11400 * B
+    ;
+    ; (This implementation)
+    ; Y  =  0.29900 * R + 0.33700 * G + 0.11400 * B + 0.25000 * G
+
+    movq        mm6, mm1
+    punpcklwd   mm1, mm3
+    punpckhwd   mm6, mm3
+    pmaddwd     mm1, [GOTOFF(eax,PW_F0299_F0337)]  ; mm1=ROL*FIX(0.299)+GOL*FIX(0.337)
+    pmaddwd     mm6, [GOTOFF(eax,PW_F0299_F0337)]  ; mm6=ROH*FIX(0.299)+GOH*FIX(0.337)
+
+    movq        mm7,  mm6               ; mm7=ROH*FIX(0.299)+GOH*FIX(0.337)
+
+    movq        mm6, mm0
+    punpcklwd   mm0, mm2
+    punpckhwd   mm6, mm2
+    pmaddwd     mm0, [GOTOFF(eax,PW_F0299_F0337)]  ; mm0=REL*FIX(0.299)+GEL*FIX(0.337)
+    pmaddwd     mm6, [GOTOFF(eax,PW_F0299_F0337)]  ; mm6=REH*FIX(0.299)+GEH*FIX(0.337)
+
+    movq        MMWORD [wk(0)], mm0     ; wk(0)=REL*FIX(0.299)+GEL*FIX(0.337)
+    movq        MMWORD [wk(1)], mm6     ; wk(1)=REH*FIX(0.299)+GEH*FIX(0.337)
+
+    movq        mm0, mm5                ; mm0=BO
+    movq        mm6, mm4                ; mm6=BE
+
+    movq        mm4, mm0
+    punpcklwd   mm0, mm3
+    punpckhwd   mm4, mm3
+    pmaddwd     mm0, [GOTOFF(eax,PW_F0114_F0250)]  ; mm0=BOL*FIX(0.114)+GOL*FIX(0.250)
+    pmaddwd     mm4, [GOTOFF(eax,PW_F0114_F0250)]  ; mm4=BOH*FIX(0.114)+GOH*FIX(0.250)
+
+    movq        mm3, [GOTOFF(eax,PD_ONEHALF)]  ; mm3=[PD_ONEHALF]
+
+    paddd       mm0, mm1
+    paddd       mm4, mm7
+    paddd       mm0, mm3
+    paddd       mm4, mm3
+    psrld       mm0, SCALEBITS          ; mm0=YOL
+    psrld       mm4, SCALEBITS          ; mm4=YOH
+    packssdw    mm0, mm4                ; mm0=YO
+
+    movq        mm4, mm6
+    punpcklwd   mm6, mm2
+    punpckhwd   mm4, mm2
+    pmaddwd     mm6, [GOTOFF(eax,PW_F0114_F0250)]  ; mm6=BEL*FIX(0.114)+GEL*FIX(0.250)
+    pmaddwd     mm4, [GOTOFF(eax,PW_F0114_F0250)]  ; mm4=BEH*FIX(0.114)+GEH*FIX(0.250)
+
+    movq        mm2, [GOTOFF(eax,PD_ONEHALF)]      ; mm2=[PD_ONEHALF]
+
+    paddd       mm6, MMWORD [wk(0)]
+    paddd       mm4, MMWORD [wk(1)]
+    paddd       mm6, mm2
+    paddd       mm4, mm2
+    psrld       mm6, SCALEBITS          ; mm6=YEL
+    psrld       mm4, SCALEBITS          ; mm4=YEH
+    packssdw    mm6, mm4                ; mm6=YE
+
+    psllw       mm0, BYTE_BIT
+    por         mm6, mm0                ; mm6=Y
+    movq        MMWORD [edi], mm6       ; Save Y
+
+    sub         ecx, byte SIZEOF_MMWORD
+    add         esi, byte RGB_PIXELSIZE*SIZEOF_MMWORD  ; inptr
+    add         edi, byte SIZEOF_MMWORD                ; outptr0
+    cmp         ecx, byte SIZEOF_MMWORD
+    jae         near .columnloop
+    test        ecx, ecx
+    jnz         near .column_ld1
+
+    pop         ecx                     ; col
+    pop         esi
+    pop         edi
+    poppic      eax
+
+    add         esi, byte SIZEOF_JSAMPROW  ; input_buf
+    add         edi, byte SIZEOF_JSAMPROW
+    dec         eax                        ; num_rows
+    jg          near .rowloop
+
+    emms                                ; empty MMX state
+
+.return:
+    pop         edi
+    pop         esi
+;   pop         edx                     ; need not be preserved
+;   pop         ecx                     ; need not be preserved
+    pop         ebx
+    mov         esp, ebp                ; esp <- aligned ebp
+    pop         esp                     ; esp <- original ebp
+    pop         ebp
+    ret
+
+; For some reason, the OS X linker does not honor the request to align the
+; segment unless we do this.
+    align       32
diff --git a/3rdparty/libjpeg/src/simd/i386/jcgryext-sse2.asm b/3rdparty/libjpeg/src/simd/i386/jcgryext-sse2.asm
new file mode 100644
index 00000000..c9d6ff1e
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/i386/jcgryext-sse2.asm
@@ -0,0 +1,382 @@
+;
+; jcgryext.asm - grayscale colorspace conversion (SSE2)
+;
+; Copyright (C) 2011, 2016, D. R. Commander.
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+;
+; This file should be assembled with NASM (Netwide Assembler),
+; can *not* be assembled with Microsoft's MASM or any compatible
+; assembler (including Borland's Turbo Assembler).
+; NASM is available from http://nasm.sourceforge.net/ or
+; http://sourceforge.net/project/showfiles.php?group_id=6208
+
+%include "jcolsamp.inc"
+
+; --------------------------------------------------------------------------
+;
+; Convert some rows of samples to the output colorspace.
+;
+; GLOBAL(void)
+; jsimd_rgb_gray_convert_sse2(JDIMENSION img_width, JSAMPARRAY input_buf,
+;                             JSAMPIMAGE output_buf, JDIMENSION output_row,
+;                             int num_rows);
+;
+
+%define img_width(b)   (b) + 8          ; JDIMENSION img_width
+%define input_buf(b)   (b) + 12         ; JSAMPARRAY input_buf
+%define output_buf(b)  (b) + 16         ; JSAMPIMAGE output_buf
+%define output_row(b)  (b) + 20         ; JDIMENSION output_row
+%define num_rows(b)    (b) + 24         ; int num_rows
+
+%define original_ebp   ebp + 0
+%define wk(i)          ebp - (WK_NUM - (i)) * SIZEOF_XMMWORD
+                                        ; xmmword wk[WK_NUM]
+%define WK_NUM         2
+%define gotptr         wk(0) - SIZEOF_POINTER  ; void * gotptr
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_rgb_gray_convert_sse2)
+
+EXTN(jsimd_rgb_gray_convert_sse2):
+    push        ebp
+    mov         eax, esp                     ; eax = original ebp
+    sub         esp, byte 4
+    and         esp, byte (-SIZEOF_XMMWORD)  ; align to 128 bits
+    mov         [esp], eax
+    mov         ebp, esp                     ; ebp = aligned ebp
+    lea         esp, [wk(0)]
+    pushpic     eax                     ; make a room for GOT address
+    push        ebx
+;   push        ecx                     ; need not be preserved
+;   push        edx                     ; need not be preserved
+    push        esi
+    push        edi
+
+    get_GOT     ebx                     ; get GOT address
+    movpic      POINTER [gotptr], ebx   ; save GOT address
+
+    mov         ecx, JDIMENSION [img_width(eax)]
+    test        ecx, ecx
+    jz          near .return
+
+    push        ecx
+
+    mov         esi, JSAMPIMAGE [output_buf(eax)]
+    mov         ecx, JDIMENSION [output_row(eax)]
+    mov         edi, JSAMPARRAY [esi+0*SIZEOF_JSAMPARRAY]
+    lea         edi, [edi+ecx*SIZEOF_JSAMPROW]
+
+    pop         ecx
+
+    mov         esi, JSAMPARRAY [input_buf(eax)]
+    mov         eax, INT [num_rows(eax)]
+    test        eax, eax
+    jle         near .return
+    alignx      16, 7
+.rowloop:
+    pushpic     eax
+    push        edi
+    push        esi
+    push        ecx                     ; col
+
+    mov         esi, JSAMPROW [esi]     ; inptr
+    mov         edi, JSAMPROW [edi]     ; outptr0
+    movpic      eax, POINTER [gotptr]   ; load GOT address (eax)
+
+    cmp         ecx, byte SIZEOF_XMMWORD
+    jae         near .columnloop
+    alignx      16, 7
+
+%if RGB_PIXELSIZE == 3  ; ---------------
+
+.column_ld1:
+    push        eax
+    push        edx
+    lea         ecx, [ecx+ecx*2]        ; imul ecx,RGB_PIXELSIZE
+    test        cl, SIZEOF_BYTE
+    jz          short .column_ld2
+    sub         ecx, byte SIZEOF_BYTE
+    movzx       eax, byte [esi+ecx]
+.column_ld2:
+    test        cl, SIZEOF_WORD
+    jz          short .column_ld4
+    sub         ecx, byte SIZEOF_WORD
+    movzx       edx, word [esi+ecx]
+    shl         eax, WORD_BIT
+    or          eax, edx
+.column_ld4:
+    movd        xmmA, eax
+    pop         edx
+    pop         eax
+    test        cl, SIZEOF_DWORD
+    jz          short .column_ld8
+    sub         ecx, byte SIZEOF_DWORD
+    movd        xmmF, XMM_DWORD [esi+ecx]
+    pslldq      xmmA, SIZEOF_DWORD
+    por         xmmA, xmmF
+.column_ld8:
+    test        cl, SIZEOF_MMWORD
+    jz          short .column_ld16
+    sub         ecx, byte SIZEOF_MMWORD
+    movq        xmmB, XMM_MMWORD [esi+ecx]
+    pslldq      xmmA, SIZEOF_MMWORD
+    por         xmmA, xmmB
+.column_ld16:
+    test        cl, SIZEOF_XMMWORD
+    jz          short .column_ld32
+    movdqa      xmmF, xmmA
+    movdqu      xmmA, XMMWORD [esi+0*SIZEOF_XMMWORD]
+    mov         ecx, SIZEOF_XMMWORD
+    jmp         short .rgb_gray_cnv
+.column_ld32:
+    test        cl, 2*SIZEOF_XMMWORD
+    mov         ecx, SIZEOF_XMMWORD
+    jz          short .rgb_gray_cnv
+    movdqa      xmmB, xmmA
+    movdqu      xmmA, XMMWORD [esi+0*SIZEOF_XMMWORD]
+    movdqu      xmmF, XMMWORD [esi+1*SIZEOF_XMMWORD]
+    jmp         short .rgb_gray_cnv
+    alignx      16, 7
+
+.columnloop:
+    movdqu      xmmA, XMMWORD [esi+0*SIZEOF_XMMWORD]
+    movdqu      xmmF, XMMWORD [esi+1*SIZEOF_XMMWORD]
+    movdqu      xmmB, XMMWORD [esi+2*SIZEOF_XMMWORD]
+
+.rgb_gray_cnv:
+    ; xmmA=(00 10 20 01 11 21 02 12 22 03 13 23 04 14 24 05)
+    ; xmmF=(15 25 06 16 26 07 17 27 08 18 28 09 19 29 0A 1A)
+    ; xmmB=(2A 0B 1B 2B 0C 1C 2C 0D 1D 2D 0E 1E 2E 0F 1F 2F)
+
+    movdqa      xmmG, xmmA
+    pslldq      xmmA, 8     ; xmmA=(-- -- -- -- -- -- -- -- 00 10 20 01 11 21 02 12)
+    psrldq      xmmG, 8     ; xmmG=(22 03 13 23 04 14 24 05 -- -- -- -- -- -- -- --)
+
+    punpckhbw   xmmA, xmmF  ; xmmA=(00 08 10 18 20 28 01 09 11 19 21 29 02 0A 12 1A)
+    pslldq      xmmF, 8     ; xmmF=(-- -- -- -- -- -- -- -- 15 25 06 16 26 07 17 27)
+
+    punpcklbw   xmmG, xmmB  ; xmmG=(22 2A 03 0B 13 1B 23 2B 04 0C 14 1C 24 2C 05 0D)
+    punpckhbw   xmmF, xmmB  ; xmmF=(15 1D 25 2D 06 0E 16 1E 26 2E 07 0F 17 1F 27 2F)
+
+    movdqa      xmmD, xmmA
+    pslldq      xmmA, 8     ; xmmA=(-- -- -- -- -- -- -- -- 00 08 10 18 20 28 01 09)
+    psrldq      xmmD, 8     ; xmmD=(11 19 21 29 02 0A 12 1A -- -- -- -- -- -- -- --)
+
+    punpckhbw   xmmA, xmmG  ; xmmA=(00 04 08 0C 10 14 18 1C 20 24 28 2C 01 05 09 0D)
+    pslldq      xmmG, 8     ; xmmG=(-- -- -- -- -- -- -- -- 22 2A 03 0B 13 1B 23 2B)
+
+    punpcklbw   xmmD, xmmF  ; xmmD=(11 15 19 1D 21 25 29 2D 02 06 0A 0E 12 16 1A 1E)
+    punpckhbw   xmmG, xmmF  ; xmmG=(22 26 2A 2E 03 07 0B 0F 13 17 1B 1F 23 27 2B 2F)
+
+    movdqa      xmmE, xmmA
+    pslldq      xmmA, 8     ; xmmA=(-- -- -- -- -- -- -- -- 00 04 08 0C 10 14 18 1C)
+    psrldq      xmmE, 8     ; xmmE=(20 24 28 2C 01 05 09 0D -- -- -- -- -- -- -- --)
+
+    punpckhbw   xmmA, xmmD  ; xmmA=(00 02 04 06 08 0A 0C 0E 10 12 14 16 18 1A 1C 1E)
+    pslldq      xmmD, 8     ; xmmD=(-- -- -- -- -- -- -- -- 11 15 19 1D 21 25 29 2D)
+
+    punpcklbw   xmmE, xmmG  ; xmmE=(20 22 24 26 28 2A 2C 2E 01 03 05 07 09 0B 0D 0F)
+    punpckhbw   xmmD, xmmG  ; xmmD=(11 13 15 17 19 1B 1D 1F 21 23 25 27 29 2B 2D 2F)
+
+    pxor        xmmH, xmmH
+
+    movdqa      xmmC, xmmA
+    punpcklbw   xmmA, xmmH  ; xmmA=(00 02 04 06 08 0A 0C 0E)
+    punpckhbw   xmmC, xmmH  ; xmmC=(10 12 14 16 18 1A 1C 1E)
+
+    movdqa      xmmB, xmmE
+    punpcklbw   xmmE, xmmH  ; xmmE=(20 22 24 26 28 2A 2C 2E)
+    punpckhbw   xmmB, xmmH  ; xmmB=(01 03 05 07 09 0B 0D 0F)
+
+    movdqa      xmmF, xmmD
+    punpcklbw   xmmD, xmmH  ; xmmD=(11 13 15 17 19 1B 1D 1F)
+    punpckhbw   xmmF, xmmH  ; xmmF=(21 23 25 27 29 2B 2D 2F)
+
+%else  ; RGB_PIXELSIZE == 4 ; -----------
+
+.column_ld1:
+    test        cl, SIZEOF_XMMWORD/16
+    jz          short .column_ld2
+    sub         ecx, byte SIZEOF_XMMWORD/16
+    movd        xmmA, XMM_DWORD [esi+ecx*RGB_PIXELSIZE]
+.column_ld2:
+    test        cl, SIZEOF_XMMWORD/8
+    jz          short .column_ld4
+    sub         ecx, byte SIZEOF_XMMWORD/8
+    movq        xmmE, XMM_MMWORD [esi+ecx*RGB_PIXELSIZE]
+    pslldq      xmmA, SIZEOF_MMWORD
+    por         xmmA, xmmE
+.column_ld4:
+    test        cl, SIZEOF_XMMWORD/4
+    jz          short .column_ld8
+    sub         ecx, byte SIZEOF_XMMWORD/4
+    movdqa      xmmE, xmmA
+    movdqu      xmmA, XMMWORD [esi+ecx*RGB_PIXELSIZE]
+.column_ld8:
+    test        cl, SIZEOF_XMMWORD/2
+    mov         ecx, SIZEOF_XMMWORD
+    jz          short .rgb_gray_cnv
+    movdqa      xmmF, xmmA
+    movdqa      xmmH, xmmE
+    movdqu      xmmA, XMMWORD [esi+0*SIZEOF_XMMWORD]
+    movdqu      xmmE, XMMWORD [esi+1*SIZEOF_XMMWORD]
+    jmp         short .rgb_gray_cnv
+    alignx      16, 7
+
+.columnloop:
+    movdqu      xmmA, XMMWORD [esi+0*SIZEOF_XMMWORD]
+    movdqu      xmmE, XMMWORD [esi+1*SIZEOF_XMMWORD]
+    movdqu      xmmF, XMMWORD [esi+2*SIZEOF_XMMWORD]
+    movdqu      xmmH, XMMWORD [esi+3*SIZEOF_XMMWORD]
+
+.rgb_gray_cnv:
+    ; xmmA=(00 10 20 30 01 11 21 31 02 12 22 32 03 13 23 33)
+    ; xmmE=(04 14 24 34 05 15 25 35 06 16 26 36 07 17 27 37)
+    ; xmmF=(08 18 28 38 09 19 29 39 0A 1A 2A 3A 0B 1B 2B 3B)
+    ; xmmH=(0C 1C 2C 3C 0D 1D 2D 3D 0E 1E 2E 3E 0F 1F 2F 3F)
+
+    movdqa      xmmD, xmmA
+    punpcklbw   xmmA, xmmE      ; xmmA=(00 04 10 14 20 24 30 34 01 05 11 15 21 25 31 35)
+    punpckhbw   xmmD, xmmE      ; xmmD=(02 06 12 16 22 26 32 36 03 07 13 17 23 27 33 37)
+
+    movdqa      xmmC, xmmF
+    punpcklbw   xmmF, xmmH      ; xmmF=(08 0C 18 1C 28 2C 38 3C 09 0D 19 1D 29 2D 39 3D)
+    punpckhbw   xmmC, xmmH      ; xmmC=(0A 0E 1A 1E 2A 2E 3A 3E 0B 0F 1B 1F 2B 2F 3B 3F)
+
+    movdqa      xmmB, xmmA
+    punpcklwd   xmmA, xmmF      ; xmmA=(00 04 08 0C 10 14 18 1C 20 24 28 2C 30 34 38 3C)
+    punpckhwd   xmmB, xmmF      ; xmmB=(01 05 09 0D 11 15 19 1D 21 25 29 2D 31 35 39 3D)
+
+    movdqa      xmmG, xmmD
+    punpcklwd   xmmD, xmmC      ; xmmD=(02 06 0A 0E 12 16 1A 1E 22 26 2A 2E 32 36 3A 3E)
+    punpckhwd   xmmG, xmmC      ; xmmG=(03 07 0B 0F 13 17 1B 1F 23 27 2B 2F 33 37 3B 3F)
+
+    movdqa      xmmE, xmmA
+    punpcklbw   xmmA, xmmD      ; xmmA=(00 02 04 06 08 0A 0C 0E 10 12 14 16 18 1A 1C 1E)
+    punpckhbw   xmmE, xmmD      ; xmmE=(20 22 24 26 28 2A 2C 2E 30 32 34 36 38 3A 3C 3E)
+
+    movdqa      xmmH, xmmB
+    punpcklbw   xmmB, xmmG      ; xmmB=(01 03 05 07 09 0B 0D 0F 11 13 15 17 19 1B 1D 1F)
+    punpckhbw   xmmH, xmmG      ; xmmH=(21 23 25 27 29 2B 2D 2F 31 33 35 37 39 3B 3D 3F)
+
+    pxor        xmmF, xmmF
+
+    movdqa      xmmC, xmmA
+    punpcklbw   xmmA, xmmF      ; xmmA=(00 02 04 06 08 0A 0C 0E)
+    punpckhbw   xmmC, xmmF      ; xmmC=(10 12 14 16 18 1A 1C 1E)
+
+    movdqa      xmmD, xmmB
+    punpcklbw   xmmB, xmmF      ; xmmB=(01 03 05 07 09 0B 0D 0F)
+    punpckhbw   xmmD, xmmF      ; xmmD=(11 13 15 17 19 1B 1D 1F)
+
+    movdqa      xmmG, xmmE
+    punpcklbw   xmmE, xmmF      ; xmmE=(20 22 24 26 28 2A 2C 2E)
+    punpckhbw   xmmG, xmmF      ; xmmG=(30 32 34 36 38 3A 3C 3E)
+
+    punpcklbw   xmmF, xmmH
+    punpckhbw   xmmH, xmmH
+    psrlw       xmmF, BYTE_BIT  ; xmmF=(21 23 25 27 29 2B 2D 2F)
+    psrlw       xmmH, BYTE_BIT  ; xmmH=(31 33 35 37 39 3B 3D 3F)
+
+%endif  ; RGB_PIXELSIZE ; ---------------
+
+    ; xmm0=R(02468ACE)=RE, xmm2=G(02468ACE)=GE, xmm4=B(02468ACE)=BE
+    ; xmm1=R(13579BDF)=RO, xmm3=G(13579BDF)=GO, xmm5=B(13579BDF)=BO
+
+    ; (Original)
+    ; Y  =  0.29900 * R + 0.58700 * G + 0.11400 * B
+    ;
+    ; (This implementation)
+    ; Y  =  0.29900 * R + 0.33700 * G + 0.11400 * B + 0.25000 * G
+
+    movdqa      xmm6, xmm1
+    punpcklwd   xmm1, xmm3
+    punpckhwd   xmm6, xmm3
+    pmaddwd     xmm1, [GOTOFF(eax,PW_F0299_F0337)]  ; xmm1=ROL*FIX(0.299)+GOL*FIX(0.337)
+    pmaddwd     xmm6, [GOTOFF(eax,PW_F0299_F0337)]  ; xmm6=ROH*FIX(0.299)+GOH*FIX(0.337)
+
+    movdqa      xmm7, xmm6              ; xmm7=ROH*FIX(0.299)+GOH*FIX(0.337)
+
+    movdqa      xmm6, xmm0
+    punpcklwd   xmm0, xmm2
+    punpckhwd   xmm6, xmm2
+    pmaddwd     xmm0, [GOTOFF(eax,PW_F0299_F0337)]  ; xmm0=REL*FIX(0.299)+GEL*FIX(0.337)
+    pmaddwd     xmm6, [GOTOFF(eax,PW_F0299_F0337)]  ; xmm6=REH*FIX(0.299)+GEH*FIX(0.337)
+
+    movdqa      XMMWORD [wk(0)], xmm0   ; wk(0)=REL*FIX(0.299)+GEL*FIX(0.337)
+    movdqa      XMMWORD [wk(1)], xmm6   ; wk(1)=REH*FIX(0.299)+GEH*FIX(0.337)
+
+    movdqa      xmm0, xmm5              ; xmm0=BO
+    movdqa      xmm6, xmm4              ; xmm6=BE
+
+    movdqa      xmm4, xmm0
+    punpcklwd   xmm0, xmm3
+    punpckhwd   xmm4, xmm3
+    pmaddwd     xmm0, [GOTOFF(eax,PW_F0114_F0250)]  ; xmm0=BOL*FIX(0.114)+GOL*FIX(0.250)
+    pmaddwd     xmm4, [GOTOFF(eax,PW_F0114_F0250)]  ; xmm4=BOH*FIX(0.114)+GOH*FIX(0.250)
+
+    movdqa      xmm3, [GOTOFF(eax,PD_ONEHALF)]      ; xmm3=[PD_ONEHALF]
+
+    paddd       xmm0, xmm1
+    paddd       xmm4, xmm7
+    paddd       xmm0, xmm3
+    paddd       xmm4, xmm3
+    psrld       xmm0, SCALEBITS         ; xmm0=YOL
+    psrld       xmm4, SCALEBITS         ; xmm4=YOH
+    packssdw    xmm0, xmm4              ; xmm0=YO
+
+    movdqa      xmm4, xmm6
+    punpcklwd   xmm6, xmm2
+    punpckhwd   xmm4, xmm2
+    pmaddwd     xmm6, [GOTOFF(eax,PW_F0114_F0250)]  ; xmm6=BEL*FIX(0.114)+GEL*FIX(0.250)
+    pmaddwd     xmm4, [GOTOFF(eax,PW_F0114_F0250)]  ; xmm4=BEH*FIX(0.114)+GEH*FIX(0.250)
+
+    movdqa      xmm2, [GOTOFF(eax,PD_ONEHALF)]      ; xmm2=[PD_ONEHALF]
+
+    paddd       xmm6, XMMWORD [wk(0)]
+    paddd       xmm4, XMMWORD [wk(1)]
+    paddd       xmm6, xmm2
+    paddd       xmm4, xmm2
+    psrld       xmm6, SCALEBITS         ; xmm6=YEL
+    psrld       xmm4, SCALEBITS         ; xmm4=YEH
+    packssdw    xmm6, xmm4              ; xmm6=YE
+
+    psllw       xmm0, BYTE_BIT
+    por         xmm6, xmm0              ; xmm6=Y
+    movdqa      XMMWORD [edi], xmm6     ; Save Y
+
+    sub         ecx, byte SIZEOF_XMMWORD
+    add         esi, byte RGB_PIXELSIZE*SIZEOF_XMMWORD  ; inptr
+    add         edi, byte SIZEOF_XMMWORD                ; outptr0
+    cmp         ecx, byte SIZEOF_XMMWORD
+    jae         near .columnloop
+    test        ecx, ecx
+    jnz         near .column_ld1
+
+    pop         ecx                     ; col
+    pop         esi
+    pop         edi
+    poppic      eax
+
+    add         esi, byte SIZEOF_JSAMPROW  ; input_buf
+    add         edi, byte SIZEOF_JSAMPROW
+    dec         eax                        ; num_rows
+    jg          near .rowloop
+
+.return:
+    pop         edi
+    pop         esi
+;   pop         edx                     ; need not be preserved
+;   pop         ecx                     ; need not be preserved
+    pop         ebx
+    mov         esp, ebp                ; esp <- aligned ebp
+    pop         esp                     ; esp <- original ebp
+    pop         ebp
+    ret
+
+; For some reason, the OS X linker does not honor the request to align the
+; segment unless we do this.
+    align       32
diff --git a/3rdparty/libjpeg/src/simd/i386/jchuff-sse2.asm b/3rdparty/libjpeg/src/simd/i386/jchuff-sse2.asm
new file mode 100644
index 00000000..278cf5e8
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/i386/jchuff-sse2.asm
@@ -0,0 +1,761 @@
+;
+; jchuff-sse2.asm - Huffman entropy encoding (SSE2)
+;
+; Copyright (C) 2009-2011, 2014-2017, 2019, D. R. Commander.
+; Copyright (C) 2015, Matthieu Darbois.
+; Copyright (C) 2018, Matthias Räncker.
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+;
+; This file should be assembled with NASM (Netwide Assembler),
+; can *not* be assembled with Microsoft's MASM or any compatible
+; assembler (including Borland's Turbo Assembler).
+; NASM is available from http://nasm.sourceforge.net/ or
+; http://sourceforge.net/project/showfiles.php?group_id=6208
+;
+; This file contains an SSE2 implementation for Huffman coding of one block.
+; The following code is based on jchuff.c; see jchuff.c for more details.
+
+%include "jsimdext.inc"
+
+struc working_state
+.next_output_byte:   resp 1     ; => next byte to write in buffer
+.free_in_buffer:     resp 1     ; # of byte spaces remaining in buffer
+.cur.put_buffer.simd resq 1     ; current bit accumulation buffer
+.cur.free_bits       resd 1     ; # of bits available in it
+.cur.last_dc_val     resd 4     ; last DC coef for each component
+.cinfo:              resp 1     ; dump_buffer needs access to this
+endstruc
+
+struc c_derived_tbl
+.ehufco:             resd 256   ; code for each symbol
+.ehufsi:             resb 256   ; length of code for each symbol
+; If no code has been allocated for a symbol S, ehufsi[S] contains 0
+endstruc
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_CONST
+
+    GLOBAL_DATA(jconst_huff_encode_one_block)
+
+EXTN(jconst_huff_encode_one_block):
+
+    alignz      32
+
+jpeg_mask_bits dq 0x0000, 0x0001, 0x0003, 0x0007
+               dq 0x000f, 0x001f, 0x003f, 0x007f
+               dq 0x00ff, 0x01ff, 0x03ff, 0x07ff
+               dq 0x0fff, 0x1fff, 0x3fff, 0x7fff
+
+times 1 << 14 db 15
+times 1 << 13 db 14
+times 1 << 12 db 13
+times 1 << 11 db 12
+times 1 << 10 db 11
+times 1 <<  9 db 10
+times 1 <<  8 db  9
+times 1 <<  7 db  8
+times 1 <<  6 db  7
+times 1 <<  5 db  6
+times 1 <<  4 db  5
+times 1 <<  3 db  4
+times 1 <<  2 db  3
+times 1 <<  1 db  2
+times 1 <<  0 db  1
+times 1       db  0
+jpeg_nbits_table:
+times 1       db  0
+times 1 <<  0 db  1
+times 1 <<  1 db  2
+times 1 <<  2 db  3
+times 1 <<  3 db  4
+times 1 <<  4 db  5
+times 1 <<  5 db  6
+times 1 <<  6 db  7
+times 1 <<  7 db  8
+times 1 <<  8 db  9
+times 1 <<  9 db 10
+times 1 << 10 db 11
+times 1 << 11 db 12
+times 1 << 12 db 13
+times 1 << 13 db 14
+times 1 << 14 db 15
+
+    alignz      32
+
+%ifdef PIC
+%define NBITS(x)      nbits_base + x
+%else
+%define NBITS(x)      jpeg_nbits_table + x
+%endif
+%define MASK_BITS(x)  NBITS((x) * 8) + (jpeg_mask_bits - jpeg_nbits_table)
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_TEXT
+    BITS        32
+
+%define mm_put_buffer     mm0
+%define mm_all_0xff       mm1
+%define mm_temp           mm2
+%define mm_nbits          mm3
+%define mm_code_bits      mm3
+%define mm_code           mm4
+%define mm_overflow_bits  mm5
+%define mm_save_nbits     mm6
+
+; Shorthand used to describe SIMD operations:
+; wN:  xmmN treated as eight signed 16-bit values
+; wN[i]:  perform the same operation on all eight signed 16-bit values, i=0..7
+; bN:  xmmN treated as 16 unsigned 8-bit values, or
+;      mmN treated as eight unsigned 8-bit values
+; bN[i]:  perform the same operation on all unsigned 8-bit values,
+;         i=0..15 (SSE register) or i=0..7 (MMX register)
+; Contents of SIMD registers are shown in memory order.
+
+; Fill the bit buffer to capacity with the leading bits from code, then output
+; the bit buffer and put the remaining bits from code into the bit buffer.
+;
+; Usage:
+; code - contains the bits to shift into the bit buffer (LSB-aligned)
+; %1 - temp register
+; %2 - low byte of temp register
+; %3 - second byte of temp register
+; %4-%8 (optional) - extra instructions to execute before the macro completes
+; %9 - the label to which to jump when the macro completes
+;
+; Upon completion, free_bits will be set to the number of remaining bits from
+; code, and put_buffer will contain those remaining bits.  temp and code will
+; be clobbered.
+;
+; This macro encodes any 0xFF bytes as 0xFF 0x00, as does the EMIT_BYTE()
+; macro in jchuff.c.
+
+%macro EMIT_QWORD 9
+%define %%temp   %1
+%define %%tempb  %2
+%define %%temph  %3
+    add         nbits, free_bits             ; nbits += free_bits;
+    neg         free_bits                    ; free_bits = -free_bits;
+    movq        mm_temp, mm_code             ; temp = code;
+    movd        mm_nbits, nbits              ; nbits --> MMX register
+    movd        mm_overflow_bits, free_bits  ; overflow_bits (temp register) = free_bits;
+    neg         free_bits                    ; free_bits = -free_bits;
+    psllq       mm_put_buffer, mm_nbits      ; put_buffer <<= nbits;
+    psrlq       mm_temp, mm_overflow_bits    ; temp >>= overflow_bits;
+    add         free_bits, 64                ; free_bits += 64;
+    por         mm_temp, mm_put_buffer       ; temp |= put_buffer;
+%ifidn %%temp, nbits_base
+    movd        mm_save_nbits, nbits_base    ; save nbits_base
+%endif
+    movq        mm_code_bits, mm_temp        ; code_bits (temp register) = temp;
+    movq        mm_put_buffer, mm_code       ; put_buffer = code;
+    pcmpeqb     mm_temp, mm_all_0xff         ; b_temp[i] = (b_temp[i] == 0xFF ? 0xFF : 0);
+    movq        mm_code, mm_code_bits        ; code = code_bits;
+    psrlq       mm_code_bits, 32             ; code_bits >>= 32;
+    pmovmskb    nbits, mm_temp               ; nbits = 0;  nbits |= ((b_temp[i] >> 7) << i);
+    movd        %%temp, mm_code_bits         ; temp = code_bits;
+    bswap       %%temp                       ; temp = htonl(temp);
+    test        nbits, nbits                 ; if (nbits != 0)  /* Some 0xFF bytes */
+    jnz         %%.SLOW                      ;   goto %%.SLOW
+    mov         dword [buffer], %%temp       ; *(uint32_t)buffer = temp;
+%ifidn %%temp, nbits_base
+    movd        nbits_base, mm_save_nbits    ; restore nbits_base
+%endif
+    %4
+    movd        nbits, mm_code               ; nbits = (uint32_t)(code);
+    %5
+    bswap       nbits                        ; nbits = htonl(nbits);
+    mov         dword [buffer + 4], nbits    ; *(uint32_t)(buffer + 4) = nbits;
+    lea         buffer, [buffer + 8]         ; buffer += 8;
+    %6
+    %7
+    %8
+    jmp %9                                   ; return
+%%.SLOW:
+    ; Execute the equivalent of the EMIT_BYTE() macro in jchuff.c for all 8
+    ; bytes in the qword.
+    mov         byte [buffer], %%tempb     ; buffer[0] = temp[0];
+    cmp         %%tempb, 0xFF              ; Set CF if temp[0] < 0xFF
+    mov         byte [buffer+1], 0         ; buffer[1] = 0;
+    sbb         buffer, -2                 ; buffer -= (-2 + (temp[0] < 0xFF ? 1 : 0));
+    mov         byte [buffer], %%temph     ; buffer[0] = temp[1];
+    cmp         %%temph, 0xFF              ; Set CF if temp[1] < 0xFF
+    mov         byte [buffer+1], 0         ; buffer[1] = 0;
+    sbb         buffer, -2                 ; buffer -= (-2 + (temp[1] < 0xFF ? 1 : 0));
+    shr         %%temp, 16                 ; temp >>= 16;
+    mov         byte [buffer], %%tempb     ; buffer[0] = temp[0];
+    cmp         %%tempb, 0xFF              ; Set CF if temp[0] < 0xFF
+    mov         byte [buffer+1], 0         ; buffer[1] = 0;
+    sbb         buffer, -2                 ; buffer -= (-2 + (temp[0] < 0xFF ? 1 : 0));
+    mov         byte [buffer], %%temph     ; buffer[0] = temp[1];
+    cmp         %%temph, 0xFF              ; Set CF if temp[1] < 0xFF
+    mov         byte [buffer+1], 0         ; buffer[1] = 0;
+    sbb         buffer, -2                 ; buffer -= (-2 + (temp[1] < 0xFF ? 1 : 0));
+    movd        nbits, mm_code             ; nbits (temp register) = (uint32_t)(code)
+%ifidn %%temp, nbits_base
+    movd        nbits_base, mm_save_nbits  ; restore nbits_base
+%endif
+    bswap       nbits                      ; nbits = htonl(nbits)
+    mov         byte [buffer], nbitsb      ; buffer[0] = nbits[0];
+    cmp         nbitsb, 0xFF               ; Set CF if nbits[0] < 0xFF
+    mov         byte [buffer+1], 0         ; buffer[1] = 0;
+    sbb         buffer, -2                 ; buffer -= (-2 + (nbits[0] < 0xFF ? 1 : 0));
+    mov         byte [buffer], nbitsh      ; buffer[0] = nbits[1];
+    cmp         nbitsh, 0xFF               ; Set CF if nbits[1] < 0xFF
+    mov         byte [buffer+1], 0         ; buffer[1] = 0;
+    sbb         buffer, -2                 ; buffer -= (-2 + (nbits[1] < 0xFF ? 1 : 0));
+    shr         nbits, 16                  ; nbits >>= 16;
+    mov         byte [buffer], nbitsb      ; buffer[0] = nbits[0];
+    cmp         nbitsb, 0xFF               ; Set CF if nbits[0] < 0xFF
+    mov         byte [buffer+1], 0         ; buffer[1] = 0;
+    sbb         buffer, -2                 ; buffer -= (-2 + (nbits[0] < 0xFF ? 1 : 0));
+    mov         byte [buffer], nbitsh      ; buffer[0] = nbits[1];
+    %4
+    cmp         nbitsh, 0xFF               ; Set CF if nbits[1] < 0xFF
+    mov         byte [buffer+1], 0         ; buffer[1] = 0;
+    sbb         buffer, -2                 ; buffer -= (-2 + (nbits[1] < 0xFF ? 1 : 0));
+    %5
+    %6
+    %7
+    %8
+    jmp %9                                 ; return;
+%endmacro
+
+%macro PUSH 1
+    push        %1
+%assign stack_offset  stack_offset + 4
+%endmacro
+
+%macro POP 1
+    pop         %1
+%assign stack_offset  stack_offset - 4
+%endmacro
+
+; If PIC is defined, load the address of a symbol defined in this file into a
+; register.  Equivalent to
+;   get_GOT     %1
+;   lea         %1, [GOTOFF(%1, %2)]
+; without using the GOT.
+;
+; Usage:
+; %1 - register into which to load the address of the symbol
+; %2 - symbol whose address should be loaded
+; %3 - optional multi-line macro to execute before the symbol address is loaded
+; %4 - optional multi-line macro to execute after the symbol address is loaded
+;
+; If PIC is not defined, then %3 and %4 are executed in order.
+
+%macro GET_SYM 2-4
+%ifdef PIC
+    call        %%.geteip
+%%.ref:
+    %4
+    add         %1, %2 - %%.ref
+    jmp         short %%.done
+    align       32
+%%.geteip:
+    %3          4               ; must adjust stack pointer because of call
+    mov         %1, POINTER [esp]
+    ret
+    align       32
+%%.done:
+%else
+    %3          0
+    %4
+%endif
+%endmacro
+
+;
+; Encode a single block's worth of coefficients.
+;
+; GLOBAL(JOCTET *)
+; jsimd_huff_encode_one_block_sse2(working_state *state, JOCTET *buffer,
+;                                  JCOEFPTR block, int last_dc_val,
+;                                  c_derived_tbl *dctbl, c_derived_tbl *actbl)
+;
+; Stack layout:
+; Function args
+; Return address
+; Saved ebx
+; Saved ebp
+; Saved esi
+; Saved edi <-- esp_save
+; ...
+; esp_save
+; t_ 64*2 bytes (aligned to 128 bytes)
+;
+; esp is used (as t) to point into t_ (data in lower indices is not used once
+; esp passes over them, so this is signal-safe.)  Aligning to 128 bytes allows
+; us to find the rest of the data again.
+;
+; NOTES:
+; When shuffling data, we try to avoid pinsrw as much as possible, since it is
+; slow on many CPUs.  Its reciprocal throughput (issue latency) is 1 even on
+; modern CPUs, so chains of pinsrw instructions (even with different outputs)
+; can limit performance.  pinsrw is a VectorPath instruction on AMD K8 and
+; requires 2 µops (with memory operand) on Intel.  In either case, only one
+; pinsrw instruction can be decoded per cycle (and nothing else if they are
+; back-to-back), so out-of-order execution cannot be used to work around long
+; pinsrw chains (though for Sandy Bridge and later, this may be less of a
+; problem if the code runs from the µop cache.)
+;
+; We use tzcnt instead of bsf without checking for support.  The instruction is
+; executed as bsf on CPUs that don't support tzcnt (encoding is equivalent to
+; rep bsf.)  The destination (first) operand of bsf (and tzcnt on some CPUs) is
+; an input dependency (although the behavior is not formally defined, Intel
+; CPUs usually leave the destination unmodified if the source is zero.)  This
+; can prevent out-of-order execution, so we clear the destination before
+; invoking tzcnt.
+;
+; Initial register allocation
+; eax - frame --> buffer
+; ebx - nbits_base (PIC) / emit_temp
+; ecx - dctbl --> size --> state
+; edx - block --> nbits
+; esi - code_temp --> state --> actbl
+; edi - index_temp --> free_bits
+; esp - t
+; ebp - index
+
+%define frame       eax
+%ifdef PIC
+%define nbits_base  ebx
+%endif
+%define emit_temp   ebx
+%define emit_tempb  bl
+%define emit_temph  bh
+%define dctbl       ecx
+%define block       edx
+%define code_temp   esi
+%define index_temp  edi
+%define t           esp
+%define index       ebp
+
+%assign save_frame  DCTSIZE2 * SIZEOF_WORD
+
+; Step 1: Re-arrange input data according to jpeg_natural_order
+; xx 01 02 03 04 05 06 07      xx 01 08 16 09 02 03 10
+; 08 09 10 11 12 13 14 15      17 24 32 25 18 11 04 05
+; 16 17 18 19 20 21 22 23      12 19 26 33 40 48 41 34
+; 24 25 26 27 28 29 30 31 ==>  27 20 13 06 07 14 21 28
+; 32 33 34 35 36 37 38 39      35 42 49 56 57 50 43 36
+; 40 41 42 43 44 45 46 47      29 22 15 23 30 37 44 51
+; 48 49 50 51 52 53 54 55      58 59 52 45 38 31 39 46
+; 56 57 58 59 60 61 62 63      53 60 61 54 47 55 62 63
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_huff_encode_one_block_sse2)
+
+EXTN(jsimd_huff_encode_one_block_sse2):
+
+%assign stack_offset      0
+%define arg_state         4 + stack_offset
+%define arg_buffer        8 + stack_offset
+%define arg_block        12 + stack_offset
+%define arg_last_dc_val  16 + stack_offset
+%define arg_dctbl        20 + stack_offset
+%define arg_actbl        24 + stack_offset
+
+                                                          ;X: X = code stream
+    mov         block, [esp + arg_block]
+    PUSH        ebx
+    PUSH        ebp
+    movups      xmm3, XMMWORD [block + 0 * SIZEOF_WORD]   ;D: w3 = xx 01 02 03 04 05 06 07
+    PUSH        esi
+    PUSH        edi
+    movdqa      xmm0, xmm3                                ;A: w0 = xx 01 02 03 04 05 06 07
+    mov         frame, esp
+    lea         t, [frame - (save_frame + 4)]
+    movups      xmm1, XMMWORD [block + 8 * SIZEOF_WORD]   ;B: w1 = 08 09 10 11 12 13 14 15
+    and         t, -DCTSIZE2 * SIZEOF_WORD                                             ; t = &t_[0]
+    mov         [t + save_frame], frame
+    pxor        xmm4, xmm4                                ;A: w4[i] = 0;
+    punpckldq   xmm0, xmm1                                ;A: w0 = xx 01 08 09 02 03 10 11
+    pshuflw     xmm0, xmm0, 11001001b                     ;A: w0 = 01 08 xx 09 02 03 10 11
+    pinsrw      xmm0, word [block + 16 * SIZEOF_WORD], 2  ;A: w0 = 01 08 16 09 02 03 10 11
+    punpckhdq   xmm3, xmm1                                ;D: w3 = 04 05 12 13 06 07 14 15
+    punpcklqdq  xmm1, xmm3                                ;B: w1 = 08 09 10 11 04 05 12 13
+    pinsrw      xmm0, word [block + 17 * SIZEOF_WORD], 7  ;A: w0 = 01 08 16 09 02 03 10 17
+                                                          ;A:      (Row 0, offset 1)
+    pcmpgtw     xmm4, xmm0                                ;A: w4[i] = (w0[i] < 0 ? -1 : 0);
+    paddw       xmm0, xmm4                                ;A: w0[i] += w4[i];
+    movaps      XMMWORD [t + 0 * SIZEOF_WORD], xmm0       ;A: t[i] = w0[i];
+
+    movq        xmm2, qword [block + 24 * SIZEOF_WORD]    ;B: w2 = 24 25 26 27 -- -- -- --
+    pshuflw     xmm2, xmm2, 11011000b                     ;B: w2 = 24 26 25 27 -- -- -- --
+    pslldq      xmm1, 1 * SIZEOF_WORD                     ;B: w1 = -- 08 09 10 11 04 05 12
+    movups      xmm5, XMMWORD [block + 48 * SIZEOF_WORD]  ;H: w5 = 48 49 50 51 52 53 54 55
+    movsd       xmm1, xmm2                                ;B: w1 = 24 26 25 27 11 04 05 12
+    punpcklqdq  xmm2, xmm5                                ;C: w2 = 24 26 25 27 48 49 50 51
+    pinsrw      xmm1, word [block + 32 * SIZEOF_WORD], 1  ;B: w1 = 24 32 25 27 11 04 05 12
+    pxor        xmm4, xmm4                                ;A: w4[i] = 0;
+    psrldq      xmm3, 2 * SIZEOF_WORD                     ;D: w3 = 12 13 06 07 14 15 -- --
+    pcmpeqw     xmm0, xmm4                                ;A: w0[i] = (w0[i] == 0 ? -1 : 0);
+    pinsrw      xmm1, word [block + 18 * SIZEOF_WORD], 3  ;B: w1 = 24 32 25 18 11 04 05 12
+                                                          ;        (Row 1, offset 1)
+    pcmpgtw     xmm4, xmm1                                ;B: w4[i] = (w1[i] < 0 ? -1 : 0);
+    paddw       xmm1, xmm4                                ;B: w1[i] += w4[i];
+    movaps      XMMWORD [t + 8 * SIZEOF_WORD], xmm1       ;B: t[i+8] = w1[i];
+    pxor        xmm4, xmm4                                ;B: w4[i] = 0;
+    pcmpeqw     xmm1, xmm4                                ;B: w1[i] = (w1[i] == 0 ? -1 : 0);
+
+    packsswb    xmm0, xmm1                                ;AB: b0[i] = w0[i], b0[i+8] = w1[i]
+                                                          ;    w/ signed saturation
+
+    pinsrw      xmm3, word [block + 20 * SIZEOF_WORD], 0  ;D: w3 = 20 13 06 07 14 15 -- --
+    pinsrw      xmm3, word [block + 21 * SIZEOF_WORD], 5  ;D: w3 = 20 13 06 07 14 21 -- --
+    pinsrw      xmm3, word [block + 28 * SIZEOF_WORD], 6  ;D: w3 = 20 13 06 07 14 21 28 --
+    pinsrw      xmm3, word [block + 35 * SIZEOF_WORD], 7  ;D: w3 = 20 13 06 07 14 21 28 35
+                                                          ;        (Row 3, offset 1)
+    pcmpgtw     xmm4, xmm3                                ;D: w4[i] = (w3[i] < 0 ? -1 : 0);
+    paddw       xmm3, xmm4                                ;D: w3[i] += w4[i];
+    movaps      XMMWORD [t + 24 * SIZEOF_WORD], xmm3      ;D: t[i+24] = w3[i];
+    pxor        xmm4, xmm4                                ;D: w4[i] = 0;
+    pcmpeqw     xmm3, xmm4                                ;D: w3[i] = (w3[i] == 0 ? -1 : 0);
+
+    pinsrw      xmm2, word [block + 19 * SIZEOF_WORD], 0  ;C: w2 = 19 26 25 27 48 49 50 51
+    pinsrw      xmm2, word [block + 33 * SIZEOF_WORD], 2  ;C: w2 = 19 26 33 27 48 49 50 51
+    pinsrw      xmm2, word [block + 40 * SIZEOF_WORD], 3  ;C: w2 = 19 26 33 40 48 49 50 51
+    pinsrw      xmm2, word [block + 41 * SIZEOF_WORD], 5  ;C: w2 = 19 26 33 40 48 41 50 51
+    pinsrw      xmm2, word [block + 34 * SIZEOF_WORD], 6  ;C: w2 = 19 26 33 40 48 41 34 51
+    pinsrw      xmm2, word [block + 27 * SIZEOF_WORD], 7  ;C: w2 = 19 26 33 40 48 41 34 27
+                                                          ;        (Row 2, offset 1)
+    pcmpgtw     xmm4, xmm2                                ;C: w4[i] = (w2[i] < 0 ? -1 : 0);
+    paddw       xmm2, xmm4                                ;C: w2[i] += w4[i];
+    movsx       code_temp, word [block]                   ;Z:     code_temp = block[0];
+
+; %1 - stack pointer adjustment
+%macro GET_SYM_BEFORE 1
+    movaps      XMMWORD [t + 16 * SIZEOF_WORD + %1], xmm2
+                                                          ;C: t[i+16] = w2[i];
+    pxor        xmm4, xmm4                                ;C: w4[i] = 0;
+    pcmpeqw     xmm2, xmm4                                ;C: w2[i] = (w2[i] == 0 ? -1 : 0);
+    sub         code_temp, [frame + arg_last_dc_val]      ;Z:     code_temp -= last_dc_val;
+
+    packsswb    xmm2, xmm3                                ;CD: b2[i] = w2[i], b2[i+8] = w3[i]
+                                                          ;    w/ signed saturation
+
+    movdqa      xmm3, xmm5                                ;H: w3 = 48 49 50 51 52 53 54 55
+    pmovmskb    index_temp, xmm2                          ;Z:     index_temp = 0;  index_temp |= ((b2[i] >> 7) << i);
+    pmovmskb    index, xmm0                               ;Z:     index = 0;  index |= ((b0[i] >> 7) << i);
+    movups      xmm0, XMMWORD [block + 56 * SIZEOF_WORD]  ;H: w0 = 56 57 58 59 60 61 62 63
+    punpckhdq   xmm3, xmm0                                ;H: w3 = 52 53 60 61 54 55 62 63
+    shl         index_temp, 16                            ;Z:     index_temp <<= 16;
+    psrldq      xmm3, 1 * SIZEOF_WORD                     ;H: w3 = 53 60 61 54 55 62 63 --
+    pxor        xmm2, xmm2                                ;H: w2[i] = 0;
+    pshuflw     xmm3, xmm3, 00111001b                     ;H: w3 = 60 61 54 53 55 62 63 --
+    or          index, index_temp                         ;Z:     index |= index_temp;
+%undef index_temp
+%define free_bits  edi
+%endmacro
+
+%macro GET_SYM_AFTER 0
+    movq        xmm1, qword [block + 44 * SIZEOF_WORD]    ;G: w1 = 44 45 46 47 -- -- -- --
+    unpcklps    xmm5, xmm0                                ;E: w5 = 48 49 56 57 50 51 58 59
+    pxor        xmm0, xmm0                                ;H: w0[i] = 0;
+    not         index                                     ;Z:     index = ~index;
+    pinsrw      xmm3, word [block + 47 * SIZEOF_WORD], 3  ;H: w3 = 60 61 54 47 55 62 63 --
+                                                          ;        (Row 7, offset 1)
+    pcmpgtw     xmm2, xmm3                                ;H: w2[i] = (w3[i] < 0 ? -1 : 0);
+    mov         dctbl, [frame + arg_dctbl]
+    paddw       xmm3, xmm2                                ;H: w3[i] += w2[i];
+    movaps      XMMWORD [t + 56 * SIZEOF_WORD], xmm3      ;H: t[i+56] = w3[i];
+    movq        xmm4, qword [block + 36 * SIZEOF_WORD]    ;G: w4 = 36 37 38 39 -- -- -- --
+    pcmpeqw     xmm3, xmm0                                ;H: w3[i] = (w3[i] == 0 ? -1 : 0);
+    punpckldq   xmm4, xmm1                                ;G: w4 = 36 37 44 45 38 39 46 47
+    movdqa      xmm1, xmm4                                ;F: w1 = 36 37 44 45 38 39 46 47
+    pcmpeqw     mm_all_0xff, mm_all_0xff                  ;Z:     all_0xff[i] = 0xFF;
+%endmacro
+
+    GET_SYM     nbits_base, jpeg_nbits_table, GET_SYM_BEFORE, GET_SYM_AFTER
+
+    psrldq      xmm4, 1 * SIZEOF_WORD                     ;G: w4 = 37 44 45 38 39 46 47 --
+    shufpd      xmm1, xmm5, 10b                           ;F: w1 = 36 37 44 45 50 51 58 59
+    pshufhw     xmm4, xmm4, 11010011b                     ;G: w4 = 37 44 45 38 -- 39 46 --
+    pslldq      xmm1, 1 * SIZEOF_WORD                     ;F: w1 = -- 36 37 44 45 50 51 58
+    pinsrw      xmm4, word [block + 59 * SIZEOF_WORD], 0  ;G: w4 = 59 44 45 38 -- 39 46 --
+    pshufd      xmm1, xmm1, 11011000b                     ;F: w1 = -- 36 45 50 37 44 51 58
+    cmp         code_temp, 1 << 31                        ;Z:     Set CF if code_temp < 0x80000000,
+                                                          ;Z:     i.e. if code_temp is positive
+    pinsrw      xmm4, word [block + 52 * SIZEOF_WORD], 1  ;G: w4 = 59 52 45 38 -- 39 46 --
+    movlps      xmm1, qword [block + 20 * SIZEOF_WORD]    ;F: w1 = 20 21 22 23 37 44 51 58
+    pinsrw      xmm4, word [block + 31 * SIZEOF_WORD], 4  ;G: w4 = 59 52 45 38 31 39 46 --
+    pshuflw     xmm1, xmm1, 01110010b                     ;F: w1 = 22 20 23 21 37 44 51 58
+    pinsrw      xmm4, word [block + 53 * SIZEOF_WORD], 7  ;G: w4 = 59 52 45 38 31 39 46 53
+                                                          ;        (Row 6, offset 1)
+    adc         code_temp, -1                             ;Z:     code_temp += -1 + (code_temp >= 0 ? 1 : 0);
+    pxor        xmm2, xmm2                                ;G: w2[i] = 0;
+    pcmpgtw     xmm0, xmm4                                ;G: w0[i] = (w4[i] < 0 ? -1 : 0);
+    pinsrw      xmm1, word [block + 15 * SIZEOF_WORD], 1  ;F: w1 = 22 15 23 21 37 44 51 58
+    paddw       xmm4, xmm0                                ;G: w4[i] += w0[i];
+    movaps      XMMWORD [t + 48 * SIZEOF_WORD], xmm4      ;G: t[48+i] = w4[i];
+    movd        mm_temp, code_temp                        ;Z:     temp = code_temp
+    pinsrw      xmm1, word [block + 30 * SIZEOF_WORD], 3  ;F: w1 = 22 15 23 30 37 44 51 58
+                                                          ;        (Row 5, offset 1)
+    pcmpeqw     xmm4, xmm2                                ;G: w4[i] = (w4[i] == 0 ? -1 : 0);
+
+    packsswb    xmm4, xmm3                                ;GH: b4[i] = w4[i], b4[i+8] = w3[i]
+                                                          ;    w/ signed saturation
+
+    lea         t, [t - SIZEOF_WORD]                      ;Z:     t = &t[-1]
+    pxor        xmm0, xmm0                                ;F: w0[i] = 0;
+    pcmpgtw     xmm2, xmm1                                ;F: w2[i] = (w1[i] < 0 ? -1 : 0);
+    paddw       xmm1, xmm2                                ;F: w1[i] += w2[i];
+    movaps      XMMWORD [t + (40+1) * SIZEOF_WORD], xmm1  ;F: t[40+i] = w1[i];
+    pcmpeqw     xmm1, xmm0                                ;F: w1[i] = (w1[i] == 0 ? -1 : 0);
+    pinsrw      xmm5, word [block + 42 * SIZEOF_WORD], 0  ;E: w5 = 42 49 56 57 50 51 58 59
+    pinsrw      xmm5, word [block + 43 * SIZEOF_WORD], 5  ;E: w5 = 42 49 56 57 50 43 58 59
+    pinsrw      xmm5, word [block + 36 * SIZEOF_WORD], 6  ;E: w5 = 42 49 56 57 50 43 36 59
+    pinsrw      xmm5, word [block + 29 * SIZEOF_WORD], 7  ;E: w5 = 42 49 56 57 50 43 36 29
+                                                          ;        (Row 4, offset 1)
+%undef block
+%define nbits  edx
+%define nbitsb  dl
+%define nbitsh  dh
+    movzx       nbits, byte [NBITS(code_temp)]            ;Z:     nbits = JPEG_NBITS(code_temp);
+%undef code_temp
+%define state  esi
+    pxor        xmm2, xmm2                                ;E: w2[i] = 0;
+    mov         state, [frame + arg_state]
+    movd        mm_nbits, nbits                           ;Z:     nbits --> MMX register
+    pcmpgtw     xmm0, xmm5                                ;E: w0[i] = (w5[i] < 0 ? -1 : 0);
+    movd        mm_code, dword [dctbl + c_derived_tbl.ehufco + nbits * 4]
+                                                          ;Z:     code = dctbl->ehufco[nbits];
+%define size  ecx
+%define sizeb  cl
+%define sizeh  ch
+    paddw       xmm5, xmm0                                ;E: w5[i] += w0[i];
+    movaps      XMMWORD [t + (32+1) * SIZEOF_WORD], xmm5  ;E: t[32+i] = w5[i];
+    movzx       size, byte [dctbl + c_derived_tbl.ehufsi + nbits]
+                                                          ;Z:     size = dctbl->ehufsi[nbits];
+%undef dctbl
+    pcmpeqw     xmm5, xmm2                                ;E: w5[i] = (w5[i] == 0 ? -1 : 0);
+
+    packsswb    xmm5, xmm1                                ;EF: b5[i] = w5[i], b5[i+8] = w1[i]
+                                                          ;    w/ signed saturation
+
+    movq        mm_put_buffer, [state + working_state.cur.put_buffer.simd]
+                                                          ;Z:     put_buffer = state->cur.put_buffer.simd;
+    mov         free_bits, [state + working_state.cur.free_bits]
+                                                          ;Z:     free_bits = state->cur.free_bits;
+%undef state
+%define actbl  esi
+    mov         actbl, [frame + arg_actbl]
+%define buffer  eax
+    mov         buffer, [frame + arg_buffer]
+%undef frame
+    jmp        .BEGIN
+
+; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    align       16
+; size <= 32, so this is not really a loop
+.BRLOOP1:                                                 ; .BRLOOP1:
+    movzx       nbits, byte [actbl + c_derived_tbl.ehufsi + 0xf0]
+                                                          ; nbits = actbl->ehufsi[0xf0];
+    movd        mm_code, dword [actbl + c_derived_tbl.ehufco + 0xf0 * 4]
+                                                          ; code = actbl->ehufco[0xf0];
+    and         index, 0x7ffffff                          ; clear index if size == 32
+    sub         size, 16                                  ; size -= 16;
+    sub         free_bits, nbits                          ; if ((free_bits -= nbits) <= 0)
+    jle         .EMIT_BRLOOP1                             ;   goto .EMIT_BRLOOP1;
+    movd        mm_nbits, nbits                           ; nbits --> MMX register
+    psllq       mm_put_buffer, mm_nbits                   ; put_buffer <<= nbits;
+    por         mm_put_buffer, mm_code                    ; put_buffer |= code;
+    jmp         .ERLOOP1                                  ; goto .ERLOOP1;
+
+; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    align       16
+%ifdef PIC
+    times 6     nop
+%else
+    times 2     nop
+%endif
+.BLOOP1:                                                  ; do {  /* size = # of zero bits/elements to skip */
+; if size == 32, index remains unchanged.  Correct in .BRLOOP.
+    shr         index, sizeb                              ;   index >>= size;
+    lea         t, [t + size * SIZEOF_WORD]               ;   t += size;
+    cmp         size, 16                                  ;   if (size > 16)
+    jg          .BRLOOP1                                  ;     goto .BRLOOP1;
+.ERLOOP1:                                                 ; .ERLOOP1:
+    movsx       nbits, word [t]                           ;   nbits = *t;
+%ifdef PIC
+    add         size, size                                ;   size += size;
+%else
+    lea         size, [size * 2]                          ;   size += size;
+%endif
+    movd        mm_temp, nbits                            ;   temp = nbits;
+    movzx       nbits, byte [NBITS(nbits)]                ;   nbits = JPEG_NBITS(nbits);
+    lea         size, [size * 8 + nbits]                  ;   size = size * 8 + nbits;
+    movd        mm_nbits, nbits                           ;   nbits --> MMX register
+    movd        mm_code, dword [actbl + c_derived_tbl.ehufco + (size - 16) * 4]
+                                                          ;   code = actbl->ehufco[size-16];
+    movzx       size, byte [actbl + c_derived_tbl.ehufsi + (size - 16)]
+                                                          ;   size = actbl->ehufsi[size-16];
+.BEGIN:                                                   ; .BEGIN:
+    pand        mm_temp, [MASK_BITS(nbits)]               ;   temp &= (1 << nbits) - 1;
+    psllq       mm_code, mm_nbits                         ;   code <<= nbits;
+    add         nbits, size                               ;   nbits += size;
+    por         mm_code, mm_temp                          ;   code |= temp;
+    sub         free_bits, nbits                          ;   if ((free_bits -= nbits) <= 0)
+    jle         .EMIT_ERLOOP1                             ;     insert code, flush buffer, init size, goto .BLOOP1
+    xor         size, size                                ;   size = 0;  /* kill tzcnt input dependency */
+    tzcnt       size, index                               ;   size = # of trailing 0 bits in index
+    movd        mm_nbits, nbits                           ;   nbits --> MMX register
+    psllq       mm_put_buffer, mm_nbits                   ;   put_buffer <<= nbits;
+    inc         size                                      ;   ++size;
+    por         mm_put_buffer, mm_code                    ;   put_buffer |= code;
+    test        index, index
+    jnz         .BLOOP1                                   ; } while (index != 0);
+; Round 2
+; t points to the last used word, possibly below t_ if the previous index had 32 zero bits.
+.ELOOP1:                                                  ; .ELOOP1:
+    pmovmskb    size, xmm4                                ; size = 0;  size |= ((b4[i] >> 7) << i);
+    pmovmskb    index, xmm5                               ; index = 0;  index |= ((b5[i] >> 7) << i);
+    shl         size, 16                                  ; size <<= 16;
+    or          index, size                               ; index |= size;
+    not         index                                     ; index = ~index;
+    lea         nbits, [t + (1 + DCTSIZE2) * SIZEOF_WORD]
+                                                          ; nbits = t + 1 + 64;
+    and         nbits, -DCTSIZE2 * SIZEOF_WORD            ; nbits &= -128;  /* now points to &t_[64] */
+    sub         nbits, t                                  ; nbits -= t;
+    shr         nbits, 1                                  ; nbits >>= 1;  /* # of leading 0 bits in old index + 33 */
+    tzcnt       size, index                               ; size = # of trailing 0 bits in index
+    inc         size                                      ; ++size;
+    test        index, index                              ; if (index == 0)
+    jz          .ELOOP2                                   ;   goto .ELOOP2;
+; NOTE: size == 32 cannot happen, since the last element is always 0.
+    shr         index, sizeb                              ; index >>= size;
+    lea         size, [size + nbits - 33]                 ; size = size + nbits - 33;
+    lea         t, [t + size * SIZEOF_WORD]               ; t += size;
+    cmp         size, 16                                  ; if (size <= 16)
+    jle         .ERLOOP2                                  ;   goto .ERLOOP2;
+.BRLOOP2:                                                 ; do {
+    movzx       nbits, byte [actbl + c_derived_tbl.ehufsi + 0xf0]
+                                                          ;   nbits = actbl->ehufsi[0xf0];
+    sub         size, 16                                  ;   size -= 16;
+    movd        mm_code, dword [actbl + c_derived_tbl.ehufco + 0xf0 * 4]
+                                                          ;   code = actbl->ehufco[0xf0];
+    sub         free_bits, nbits                          ;   if ((free_bits -= nbits) <= 0)
+    jle         .EMIT_BRLOOP2                             ;     insert code and flush put_buffer
+    movd        mm_nbits, nbits                           ;   else { nbits --> MMX register
+    psllq       mm_put_buffer, mm_nbits                   ;     put_buffer <<= nbits;
+    por         mm_put_buffer, mm_code                    ;     put_buffer |= code;
+    cmp         size, 16                                  ;     if (size <= 16)
+    jle        .ERLOOP2                                   ;       goto .ERLOOP2;
+    jmp        .BRLOOP2                                   ; } while (1);
+
+; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    align      16
+.BLOOP2:                                                  ; do {  /* size = # of zero bits/elements to skip */
+    shr         index, sizeb                              ;   index >>= size;
+    lea         t, [t + size * SIZEOF_WORD]               ;   t += size;
+    cmp         size, 16                                  ;   if (size > 16)
+    jg          .BRLOOP2                                  ;     goto .BRLOOP2;
+.ERLOOP2:                                                 ; .ERLOOP2:
+    movsx       nbits, word [t]                           ;   nbits = *t;
+    add         size, size                                ;   size += size;
+    movd        mm_temp, nbits                            ;   temp = nbits;
+    movzx       nbits, byte [NBITS(nbits)]                ;   nbits = JPEG_NBITS(nbits);
+    movd        mm_nbits, nbits                           ;   nbits --> MMX register
+    lea         size, [size * 8 + nbits]                  ;   size = size * 8 + nbits;
+    movd        mm_code, dword [actbl + c_derived_tbl.ehufco + (size - 16) * 4]
+                                                          ;   code = actbl->ehufco[size-16];
+    movzx       size, byte [actbl + c_derived_tbl.ehufsi + (size - 16)]
+                                                          ;   size = actbl->ehufsi[size-16];
+    psllq       mm_code, mm_nbits                         ;   code <<= nbits;
+    pand        mm_temp, [MASK_BITS(nbits)]               ;   temp &= (1 << nbits) - 1;
+    lea         nbits, [nbits + size]                     ;   nbits += size;
+    por         mm_code, mm_temp                          ;   code |= temp;
+    xor         size, size                                ;   size = 0;  /* kill tzcnt input dependency */
+    sub         free_bits, nbits                          ;   if ((free_bits -= nbits) <= 0)
+    jle         .EMIT_ERLOOP2                             ;     insert code, flush buffer, init size, goto .BLOOP2
+    tzcnt       size, index                               ;   size = # of trailing 0 bits in index
+    movd        mm_nbits, nbits                           ;   nbits --> MMX register
+    psllq       mm_put_buffer, mm_nbits                   ;   put_buffer <<= nbits;
+    inc         size                                      ;   ++size;
+    por         mm_put_buffer, mm_code                    ;   put_buffer |= code;
+    test        index, index
+    jnz         .BLOOP2                                   ; } while (index != 0);
+.ELOOP2:                                                  ; .ELOOP2:
+    mov         nbits, t                                  ; nbits = t;
+    lea         t, [t + SIZEOF_WORD]                      ; t = &t[1];
+    and         nbits, DCTSIZE2 * SIZEOF_WORD - 1         ; nbits &= 127;
+    and         t, -DCTSIZE2 * SIZEOF_WORD                ; t &= -128;  /* t = &t_[0]; */
+    cmp         nbits, (DCTSIZE2 - 2) * SIZEOF_WORD       ; if (nbits != 62 * 2)
+    je          .EFN                                      ; {
+    movd        mm_code, dword [actbl + c_derived_tbl.ehufco + 0]
+                                                          ;   code = actbl->ehufco[0];
+    movzx       nbits, byte [actbl + c_derived_tbl.ehufsi + 0]
+                                                          ;   nbits = actbl->ehufsi[0];
+    sub         free_bits, nbits                          ;   if ((free_bits -= nbits) <= 0)
+    jg          .EFN_SKIP_EMIT_CODE                       ;   {
+    EMIT_QWORD  size, sizeb, sizeh, , , , , , .EFN        ;     insert code, flush put_buffer
+    align       16
+.EFN_SKIP_EMIT_CODE:                                      ;   } else {
+    movd        mm_nbits, nbits                           ;     nbits --> MMX register
+    psllq       mm_put_buffer, mm_nbits                   ;     put_buffer <<= nbits;
+    por         mm_put_buffer, mm_code                    ;     put_buffer |= code;
+.EFN:                                                     ; } }
+%define frame  esp
+    mov         frame, [t + save_frame]
+%define state  ecx
+    mov         state, [frame + arg_state]
+    movq        [state + working_state.cur.put_buffer.simd], mm_put_buffer
+                                                          ; state->cur.put_buffer.simd = put_buffer;
+    emms
+    mov         [state + working_state.cur.free_bits], free_bits
+                                                          ; state->cur.free_bits = free_bits;
+    POP         edi
+    POP         esi
+    POP         ebp
+    POP         ebx
+    ret
+
+; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    align       16
+.EMIT_BRLOOP1:
+    EMIT_QWORD  emit_temp, emit_tempb, emit_temph, , , , , , \
+      .ERLOOP1
+
+; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    align       16
+.EMIT_ERLOOP1:
+    EMIT_QWORD  size, sizeb, sizeh, \
+      { xor     size, size }, \
+      { tzcnt   size, index }, \
+      { inc     size }, \
+      { test    index, index }, \
+      { jnz     .BLOOP1 }, \
+      .ELOOP1
+
+; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    align       16
+.EMIT_BRLOOP2:
+    EMIT_QWORD  emit_temp, emit_tempb, emit_temph, , , , \
+      { cmp     size, 16 }, \
+      { jle     .ERLOOP2 }, \
+      .BRLOOP2
+
+; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    align       16
+.EMIT_ERLOOP2:
+    EMIT_QWORD  size, sizeb, sizeh, \
+      { xor     size, size }, \
+      { tzcnt   size, index }, \
+      { inc     size }, \
+      { test    index, index }, \
+      { jnz     .BLOOP2 }, \
+      .ELOOP2
+
+; For some reason, the OS X linker does not honor the request to align the
+; segment unless we do this.
+    align       32
diff --git a/3rdparty/libjpeg/src/simd/i386/jcphuff-sse2.asm b/3rdparty/libjpeg/src/simd/i386/jcphuff-sse2.asm
new file mode 100644
index 00000000..8b731783
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/i386/jcphuff-sse2.asm
@@ -0,0 +1,660 @@
+;
+; jcphuff-sse2.asm - prepare data for progressive Huffman encoding (SSE2)
+;
+; Copyright (C) 2016, 2018, Matthieu Darbois
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+;
+; This file should be assembled with NASM (Netwide Assembler),
+; can *not* be assembled with Microsoft's MASM or any compatible
+; assembler (including Borland's Turbo Assembler).
+; NASM is available from http://nasm.sourceforge.net/ or
+; http://sourceforge.net/project/showfiles.php?group_id=6208
+;
+; This file contains an SSE2 implementation of data preparation for progressive
+; Huffman encoding.  See jcphuff.c for more details.
+
+%include "jsimdext.inc"
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_TEXT
+    BITS        32
+
+; --------------------------------------------------------------------------
+; Macros to load data for jsimd_encode_mcu_AC_first_prepare_sse2() and
+; jsimd_encode_mcu_AC_refine_prepare_sse2()
+
+%macro LOAD16 0
+    pxor        N0, N0
+    pxor        N1, N1
+
+    mov         T0, INT [LUT +  0*SIZEOF_INT]
+    mov         T1, INT [LUT +  8*SIZEOF_INT]
+    pinsrw      X0, word [BLOCK + T0 * 2], 0
+    pinsrw      X1, word [BLOCK + T1 * 2], 0
+
+    mov         T0, INT [LUT +  1*SIZEOF_INT]
+    mov         T1, INT [LUT +  9*SIZEOF_INT]
+    pinsrw      X0, word [BLOCK + T0 * 2], 1
+    pinsrw      X1, word [BLOCK + T1 * 2], 1
+
+    mov         T0, INT [LUT +  2*SIZEOF_INT]
+    mov         T1, INT [LUT + 10*SIZEOF_INT]
+    pinsrw      X0, word [BLOCK + T0 * 2], 2
+    pinsrw      X1, word [BLOCK + T1 * 2], 2
+
+    mov         T0, INT [LUT +  3*SIZEOF_INT]
+    mov         T1, INT [LUT + 11*SIZEOF_INT]
+    pinsrw      X0, word [BLOCK + T0 * 2], 3
+    pinsrw      X1, word [BLOCK + T1 * 2], 3
+
+    mov         T0, INT [LUT +  4*SIZEOF_INT]
+    mov         T1, INT [LUT + 12*SIZEOF_INT]
+    pinsrw      X0, word [BLOCK + T0 * 2], 4
+    pinsrw      X1, word [BLOCK + T1 * 2], 4
+
+    mov         T0, INT [LUT +  5*SIZEOF_INT]
+    mov         T1, INT [LUT + 13*SIZEOF_INT]
+    pinsrw      X0, word [BLOCK + T0 * 2], 5
+    pinsrw      X1, word [BLOCK + T1 * 2], 5
+
+    mov         T0, INT [LUT +  6*SIZEOF_INT]
+    mov         T1, INT [LUT + 14*SIZEOF_INT]
+    pinsrw      X0, word [BLOCK + T0 * 2], 6
+    pinsrw      X1, word [BLOCK + T1 * 2], 6
+
+    mov         T0, INT [LUT +  7*SIZEOF_INT]
+    mov         T1, INT [LUT + 15*SIZEOF_INT]
+    pinsrw      X0, word [BLOCK + T0 * 2], 7
+    pinsrw      X1, word [BLOCK + T1 * 2], 7
+%endmacro
+
+%macro LOAD15 0
+    pxor        N0, N0
+    pxor        N1, N1
+    pxor        X1, X1
+
+    mov         T0, INT [LUT +  0*SIZEOF_INT]
+    mov         T1, INT [LUT +  8*SIZEOF_INT]
+    pinsrw      X0, word [BLOCK + T0 * 2], 0
+    pinsrw      X1, word [BLOCK + T1 * 2], 0
+
+    mov         T0, INT [LUT +  1*SIZEOF_INT]
+    pinsrw      X0, word [BLOCK + T0 * 2], 1
+
+    mov         T0, INT [LUT +  2*SIZEOF_INT]
+    pinsrw      X0, word [BLOCK + T0 * 2], 2
+
+    mov         T0, INT [LUT +  3*SIZEOF_INT]
+    pinsrw      X0, word [BLOCK + T0 * 2], 3
+
+    mov         T0, INT [LUT +  4*SIZEOF_INT]
+    pinsrw      X0, word [BLOCK + T0 * 2], 4
+
+    mov         T0, INT [LUT +  5*SIZEOF_INT]
+    pinsrw      X0, word [BLOCK + T0 * 2], 5
+
+    mov         T0, INT [LUT +  6*SIZEOF_INT]
+    pinsrw      X0, word [BLOCK + T0 * 2], 6
+
+    mov         T0, INT [LUT +  7*SIZEOF_INT]
+    pinsrw      X0, word [BLOCK + T0 * 2], 7
+
+    cmp         LENEND, 2
+    jl          %%.ELOAD15
+    mov         T1, INT [LUT +  9*SIZEOF_INT]
+    pinsrw      X1, word [BLOCK + T1 * 2], 1
+
+    cmp         LENEND, 3
+    jl          %%.ELOAD15
+    mov         T1, INT [LUT + 10*SIZEOF_INT]
+    pinsrw      X1, word [BLOCK + T1 * 2], 2
+
+    cmp         LENEND, 4
+    jl          %%.ELOAD15
+    mov         T1, INT [LUT + 11*SIZEOF_INT]
+    pinsrw      X1, word [BLOCK + T1 * 2], 3
+
+    cmp         LENEND, 5
+    jl          %%.ELOAD15
+    mov         T1, INT [LUT + 12*SIZEOF_INT]
+    pinsrw      X1, word [BLOCK + T1 * 2], 4
+
+    cmp         LENEND, 6
+    jl          %%.ELOAD15
+    mov         T1, INT [LUT + 13*SIZEOF_INT]
+    pinsrw      X1, word [BLOCK + T1 * 2], 5
+
+    cmp         LENEND, 7
+    jl          %%.ELOAD15
+    mov         T1, INT [LUT + 14*SIZEOF_INT]
+    pinsrw      X1, word [BLOCK + T1 * 2], 6
+%%.ELOAD15:
+%endmacro
+
+%macro LOAD8 0
+    pxor        N0, N0
+
+    mov         T0, INT [LUT +  0*SIZEOF_INT]
+    pinsrw      X0, word [BLOCK + T0 * 2], 0
+
+    mov         T0, INT [LUT +  1*SIZEOF_INT]
+    pinsrw      X0, word [BLOCK + T0 * 2], 1
+
+    mov         T0, INT [LUT +  2*SIZEOF_INT]
+    pinsrw      X0, word [BLOCK + T0 * 2], 2
+
+    mov         T0, INT [LUT +  3*SIZEOF_INT]
+    pinsrw      X0, word [BLOCK + T0 * 2], 3
+
+    mov         T0, INT [LUT +  4*SIZEOF_INT]
+    pinsrw      X0, word [BLOCK + T0 * 2], 4
+
+    mov         T0, INT [LUT +  5*SIZEOF_INT]
+    pinsrw      X0, word [BLOCK + T0 * 2], 5
+
+    mov         T0, INT [LUT +  6*SIZEOF_INT]
+    pinsrw      X0, word [BLOCK + T0 * 2], 6
+
+    mov         T0, INT [LUT +  7*SIZEOF_INT]
+    pinsrw      X0, word [BLOCK + T0 * 2], 7
+%endmacro
+
+%macro LOAD7 0
+    pxor        N0, N0
+    pxor        X0, X0
+
+    mov         T1, INT [LUT +  0*SIZEOF_INT]
+    pinsrw      X0, word [BLOCK + T1 * 2], 0
+
+    cmp         LENEND, 2
+    jl          %%.ELOAD7
+    mov         T1, INT [LUT +  1*SIZEOF_INT]
+    pinsrw      X0, word [BLOCK + T1 * 2], 1
+
+    cmp         LENEND, 3
+    jl          %%.ELOAD7
+    mov         T1, INT [LUT +  2*SIZEOF_INT]
+    pinsrw      X0, word [BLOCK + T1 * 2], 2
+
+    cmp         LENEND, 4
+    jl          %%.ELOAD7
+    mov         T1, INT [LUT +  3*SIZEOF_INT]
+    pinsrw      X0, word [BLOCK + T1 * 2], 3
+
+    cmp         LENEND, 5
+    jl          %%.ELOAD7
+    mov         T1, INT [LUT +  4*SIZEOF_INT]
+    pinsrw      X0, word [BLOCK + T1 * 2], 4
+
+    cmp         LENEND, 6
+    jl          %%.ELOAD7
+    mov         T1, INT [LUT +  5*SIZEOF_INT]
+    pinsrw      X0, word [BLOCK + T1 * 2], 5
+
+    cmp         LENEND, 7
+    jl          %%.ELOAD7
+    mov         T1, INT [LUT +  6*SIZEOF_INT]
+    pinsrw      X0, word [BLOCK + T1 * 2], 6
+%%.ELOAD7:
+%endmacro
+
+%macro REDUCE0 0
+    movdqa      xmm0, XMMWORD [VALUES + ( 0*2)]
+    movdqa      xmm1, XMMWORD [VALUES + ( 8*2)]
+    movdqa      xmm2, XMMWORD [VALUES + (16*2)]
+    movdqa      xmm3, XMMWORD [VALUES + (24*2)]
+    movdqa      xmm4, XMMWORD [VALUES + (32*2)]
+    movdqa      xmm5, XMMWORD [VALUES + (40*2)]
+    movdqa      xmm6, XMMWORD [VALUES + (48*2)]
+
+    pcmpeqw     xmm0, ZERO
+    pcmpeqw     xmm1, ZERO
+    pcmpeqw     xmm2, ZERO
+    pcmpeqw     xmm3, ZERO
+    pcmpeqw     xmm4, ZERO
+    pcmpeqw     xmm5, ZERO
+    pcmpeqw     xmm6, ZERO
+    pcmpeqw     xmm7, XMMWORD [VALUES + (56*2)]
+
+    packsswb    xmm0, xmm1
+    packsswb    xmm2, xmm3
+    packsswb    xmm4, xmm5
+    packsswb    xmm6, xmm7
+
+    pmovmskb    eax, xmm0
+    pmovmskb    ecx, xmm2
+    pmovmskb    edx, xmm4
+    pmovmskb    esi, xmm6
+
+    shl         ecx, 16
+    shl         esi, 16
+
+    or          eax, ecx
+    or          edx, esi
+
+    not         eax
+    not         edx
+
+    mov         edi, ZEROBITS
+
+    mov         INT [edi], eax
+    mov         INT [edi+SIZEOF_INT], edx
+%endmacro
+
+;
+; Prepare data for jsimd_encode_mcu_AC_first().
+;
+; GLOBAL(void)
+; jsimd_encode_mcu_AC_first_prepare_sse2(const JCOEF *block,
+;                                        const int *jpeg_natural_order_start,
+;                                        int Sl, int Al, JCOEF *values,
+;                                        size_t *zerobits)
+;
+; eax + 8 = const JCOEF *block
+; eax + 12 = const int *jpeg_natural_order_start
+; eax + 16 = int Sl
+; eax + 20 = int Al
+; eax + 24 = JCOEF *values
+; eax + 28 = size_t *zerobits
+
+%define ZERO    xmm7
+%define X0      xmm0
+%define X1      xmm1
+%define N0      xmm2
+%define N1      xmm3
+%define AL      xmm4
+%define K       eax
+%define LENEND  eax
+%define LUT     ebx
+%define T0      ecx
+%define T1      edx
+%define BLOCK   esi
+%define VALUES  edi
+%define LEN     ebp
+
+%define ZEROBITS  INT [esp + 5 * 4]
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_encode_mcu_AC_first_prepare_sse2)
+
+EXTN(jsimd_encode_mcu_AC_first_prepare_sse2):
+    push        ebp
+    mov         eax, esp                     ; eax = original ebp
+    sub         esp, byte 4
+    and         esp, byte (-SIZEOF_XMMWORD)  ; align to 128 bits
+    mov         [esp], eax
+    mov         ebp, esp                     ; ebp = aligned ebp
+    sub         esp, 4
+    push        ebx
+    push        ecx
+;   push        edx                     ; need not be preserved
+    push        esi
+    push        edi
+    push        ebp
+
+    mov         BLOCK, INT [eax + 8]
+    mov         LUT, INT [eax + 12]
+    mov         VALUES, INT [eax + 24]
+    movd        AL, INT [eax + 20]
+    mov         T0, INT [eax + 28]
+    mov         ZEROBITS, T0
+    mov         LEN, INT [eax + 16]
+    pxor        ZERO, ZERO
+    mov         K, LEN
+    and         K, -16
+    shr         K, 4
+    jz          .ELOOP16
+.BLOOP16:
+    LOAD16
+    pcmpgtw     N0, X0
+    pcmpgtw     N1, X1
+    paddw       X0, N0
+    paddw       X1, N1
+    pxor        X0, N0
+    pxor        X1, N1
+    psrlw       X0, AL
+    psrlw       X1, AL
+    pxor        N0, X0
+    pxor        N1, X1
+    movdqa      XMMWORD [VALUES + (0) * 2], X0
+    movdqa      XMMWORD [VALUES + (8) * 2], X1
+    movdqa      XMMWORD [VALUES + (0 + DCTSIZE2) * 2], N0
+    movdqa      XMMWORD [VALUES + (8 + DCTSIZE2) * 2], N1
+    add         VALUES, 16*2
+    add         LUT, 16*SIZEOF_INT
+    dec         K
+    jnz         .BLOOP16
+    test        LEN, 15
+    je          .PADDING
+.ELOOP16:
+    mov         LENEND, LEN
+    and         LENEND, 7
+
+    test        LEN, 8
+    jz          .TRY7
+    test        LEN, 7
+    jz          .TRY8
+
+    LOAD15
+    pcmpgtw     N0, X0
+    pcmpgtw     N1, X1
+    paddw       X0, N0
+    paddw       X1, N1
+    pxor        X0, N0
+    pxor        X1, N1
+    psrlw       X0, AL
+    psrlw       X1, AL
+    pxor        N0, X0
+    pxor        N1, X1
+    movdqa      XMMWORD [VALUES + (0) * 2], X0
+    movdqa      XMMWORD [VALUES + (8) * 2], X1
+    movdqa      XMMWORD [VALUES + (0 + DCTSIZE2) * 2], N0
+    movdqa      XMMWORD [VALUES + (8 + DCTSIZE2) * 2], N1
+    add         VALUES, 16*2
+    jmp         .PADDING
+.TRY8:
+    LOAD8
+    pcmpgtw     N0, X0
+    paddw       X0, N0
+    pxor        X0, N0
+    psrlw       X0, AL
+    pxor        N0, X0
+    movdqa      XMMWORD [VALUES + (0) * 2], X0
+    movdqa      XMMWORD [VALUES + (0 + DCTSIZE2) * 2], N0
+    add         VALUES, 8*2
+    jmp         .PADDING
+.TRY7:
+    LOAD7
+    pcmpgtw     N0, X0
+    paddw       X0, N0
+    pxor        X0, N0
+    psrlw       X0, AL
+    pxor        N0, X0
+    movdqa      XMMWORD [VALUES + (0) * 2], X0
+    movdqa      XMMWORD [VALUES + (0 + DCTSIZE2) * 2], N0
+    add         VALUES, 8*2
+.PADDING:
+    mov         K, LEN
+    add         K, 7
+    and         K, -8
+    shr         K, 3
+    sub         K, DCTSIZE2/8
+    jz          .EPADDING
+    align       16
+.ZEROLOOP:
+    movdqa      XMMWORD [VALUES + 0], ZERO
+    add         VALUES, 8*2
+    inc         K
+    jnz         .ZEROLOOP
+.EPADDING:
+    sub         VALUES, DCTSIZE2*2
+
+    REDUCE0
+
+    pop         ebp
+    pop         edi
+    pop         esi
+;   pop         edx                     ; need not be preserved
+    pop         ecx
+    pop         ebx
+    mov         esp, ebp                ; esp <- aligned ebp
+    pop         esp                     ; esp <- original ebp
+    pop         ebp
+    ret
+
+%undef ZERO
+%undef X0
+%undef X1
+%undef N0
+%undef N1
+%undef AL
+%undef K
+%undef LUT
+%undef T0
+%undef T1
+%undef BLOCK
+%undef VALUES
+%undef LEN
+
+;
+; Prepare data for jsimd_encode_mcu_AC_refine().
+;
+; GLOBAL(int)
+; jsimd_encode_mcu_AC_refine_prepare_sse2(const JCOEF *block,
+;                                         const int *jpeg_natural_order_start,
+;                                         int Sl, int Al, JCOEF *absvalues,
+;                                         size_t *bits)
+;
+; eax + 8 = const JCOEF *block
+; eax + 12 = const int *jpeg_natural_order_start
+; eax + 16 = int Sl
+; eax + 20 = int Al
+; eax + 24 = JCOEF *values
+; eax + 28 = size_t *bits
+
+%define ZERO    xmm7
+%define ONE     xmm5
+%define X0      xmm0
+%define X1      xmm1
+%define N0      xmm2
+%define N1      xmm3
+%define AL      xmm4
+%define K       eax
+%define LENEND  eax
+%define LUT     ebx
+%define T0      ecx
+%define T0w      cx
+%define T1      edx
+%define BLOCK   esi
+%define VALUES  edi
+%define KK      ebp
+
+%define ZEROBITS  INT [esp + 5 * 4]
+%define EOB       INT [esp + 5 * 4 + 4]
+%define LEN       INT [esp + 5 * 4 + 8]
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_encode_mcu_AC_refine_prepare_sse2)
+
+EXTN(jsimd_encode_mcu_AC_refine_prepare_sse2):
+    push        ebp
+    mov         eax, esp                     ; eax = original ebp
+    sub         esp, byte 4
+    and         esp, byte (-SIZEOF_XMMWORD)  ; align to 128 bits
+    mov         [esp], eax
+    mov         ebp, esp                     ; ebp = aligned ebp
+    sub         esp, 16
+    push        ebx
+    push        ecx
+;   push        edx                     ; need not be preserved
+    push        esi
+    push        edi
+    push        ebp
+
+    pcmpeqw     ONE, ONE
+    psrlw       ONE, 15
+    mov         BLOCK, INT [eax + 8]
+    mov         LUT, INT [eax + 12]
+    mov         VALUES, INT [eax + 24]
+    movd        AL, INT [eax + 20]
+    mov         T0, INT [eax + 28]
+    mov         K,  INT [eax + 16]
+    mov         INT [T0 + 2 * SIZEOF_INT], -1
+    mov         INT [T0 + 3 * SIZEOF_INT], -1
+    mov         ZEROBITS, T0
+    mov         LEN, K
+    pxor        ZERO, ZERO
+    and         K, -16
+    mov         EOB, 0
+    xor         KK, KK
+    shr         K, 4
+    jz          .ELOOPR16
+.BLOOPR16:
+    LOAD16
+    pcmpgtw     N0, X0
+    pcmpgtw     N1, X1
+    paddw       X0, N0
+    paddw       X1, N1
+    pxor        X0, N0
+    pxor        X1, N1
+    psrlw       X0, AL
+    psrlw       X1, AL
+    movdqa      XMMWORD [VALUES + (0) * 2], X0
+    movdqa      XMMWORD [VALUES + (8) * 2], X1
+    pcmpeqw     X0, ONE
+    pcmpeqw     X1, ONE
+    packsswb    N0, N1
+    packsswb    X0, X1
+    pmovmskb    T0, N0                  ; lsignbits.val16u[k>>4] = _mm_movemask_epi8(neg);
+    mov         T1, ZEROBITS
+    not         T0
+    mov         word [T1 + 2 * SIZEOF_INT + KK], T0w
+    pmovmskb    T1, X0                  ; idx = _mm_movemask_epi8(x1);
+    bsr         T1, T1                  ;  idx = 16 - (__builtin_clz(idx)>>1);
+    jz          .CONTINUER16            ; if (idx) {
+    lea         T1, [T1+KK*8]
+    mov         EOB, T1                 ; EOB = k + idx;
+.CONTINUER16:
+    add         VALUES, 16*2
+    add         LUT, 16*SIZEOF_INT
+    add         KK, 2
+    dec         K
+    jnz         .BLOOPR16
+.ELOOPR16:
+    mov         LENEND, LEN
+
+    test        LENEND, 8
+    jz          .TRYR7
+    test        LENEND, 7
+    jz          .TRYR8
+
+    and         LENEND, 7
+    LOAD15
+    pcmpgtw     N0, X0
+    pcmpgtw     N1, X1
+    paddw       X0, N0
+    paddw       X1, N1
+    pxor        X0, N0
+    pxor        X1, N1
+    psrlw       X0, AL
+    psrlw       X1, AL
+    movdqa      XMMWORD [VALUES + (0) * 2], X0
+    movdqa      XMMWORD [VALUES + (8) * 2], X1
+    pcmpeqw     X0, ONE
+    pcmpeqw     X1, ONE
+    packsswb    N0, N1
+    packsswb    X0, X1
+    pmovmskb    T0, N0                  ; lsignbits.val16u[k>>4] = _mm_movemask_epi8(neg);
+    mov         T1, ZEROBITS
+    not         T0
+    mov         word [T1 + 2 * SIZEOF_INT + KK], T0w
+    pmovmskb    T1, X0                  ; idx = _mm_movemask_epi8(x1);
+    bsr         T1, T1                  ;  idx = 16 - (__builtin_clz(idx)>>1);
+    jz          .CONTINUER15            ; if (idx) {
+    lea         T1, [T1+KK*8]
+    mov         EOB, T1                 ; EOB = k + idx;
+.CONTINUER15:
+    add         VALUES, 16*2
+    jmp         .PADDINGR
+.TRYR8:
+    LOAD8
+
+    pcmpgtw     N0, X0
+    paddw       X0, N0
+    pxor        X0, N0
+    psrlw       X0, AL
+    movdqa      XMMWORD [VALUES + (0) * 2], X0
+    pcmpeqw     X0, ONE
+    packsswb    N0, ZERO
+    packsswb    X0, ZERO
+    pmovmskb    T0, N0                  ; lsignbits.val16u[k>>4] = _mm_movemask_epi8(neg);
+    mov         T1, ZEROBITS
+    not         T0
+    mov         word [T1 + 2 * SIZEOF_INT + KK], T0w
+    pmovmskb    T1, X0                  ; idx = _mm_movemask_epi8(x1);
+    bsr         T1, T1                  ;  idx = 16 - (__builtin_clz(idx)>>1);
+    jz          .CONTINUER8             ; if (idx) {
+    lea         T1, [T1+KK*8]
+    mov         EOB, T1                 ; EOB = k + idx;
+.CONTINUER8:
+    add         VALUES, 8*2
+    jmp         .PADDINGR
+.TRYR7:
+    and         LENEND, 7
+    LOAD7
+
+    pcmpgtw     N0, X0
+    paddw       X0, N0
+    pxor        X0, N0
+    psrlw       X0, AL
+    movdqa      XMMWORD [VALUES + (0) * 2], X0
+    pcmpeqw     X0, ONE
+    packsswb    N0, ZERO
+    packsswb    X0, ZERO
+    pmovmskb    T0, N0                  ; lsignbits.val16u[k>>4] = _mm_movemask_epi8(neg);
+    mov         T1, ZEROBITS
+    not         T0
+    mov         word [T1 + 2 * SIZEOF_INT + KK], T0w
+    pmovmskb    T1, X0                  ; idx = _mm_movemask_epi8(x1);
+    bsr         T1, T1                  ;  idx = 16 - (__builtin_clz(idx)>>1);
+    jz          .CONTINUER7             ; if (idx) {
+    lea         T1, [T1+KK*8]
+    mov         EOB, T1                 ; EOB = k + idx;
+.CONTINUER7:
+    add         VALUES, 8*2
+.PADDINGR:
+    mov         K, LEN
+    add         K, 7
+    and         K, -8
+    shr         K, 3
+    sub         K, DCTSIZE2/8
+    jz          .EPADDINGR
+    align       16
+.ZEROLOOPR:
+    movdqa      XMMWORD [VALUES + 0], ZERO
+    add         VALUES, 8*2
+    inc         K
+    jnz         .ZEROLOOPR
+.EPADDINGR:
+    sub         VALUES, DCTSIZE2*2
+
+    REDUCE0
+
+    mov         eax, EOB
+
+    pop         ebp
+    pop         edi
+    pop         esi
+;   pop         edx                     ; need not be preserved
+    pop         ecx
+    pop         ebx
+    mov         esp, ebp                ; esp <- aligned ebp
+    pop         esp                     ; esp <- original ebp
+    pop         ebp
+    ret
+
+%undef ZERO
+%undef ONE
+%undef X0
+%undef X1
+%undef N0
+%undef N1
+%undef AL
+%undef K
+%undef KK
+%undef EOB
+%undef SIGN
+%undef LUT
+%undef T0
+%undef T1
+%undef BLOCK
+%undef VALUES
+%undef LEN
+%undef LENEND
+
+; For some reason, the OS X linker does not honor the request to align the
+; segment unless we do this.
+    align       32
diff --git a/3rdparty/libjpeg/src/simd/i386/jcsample-avx2.asm b/3rdparty/libjpeg/src/simd/i386/jcsample-avx2.asm
new file mode 100644
index 00000000..0a20802d
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/i386/jcsample-avx2.asm
@@ -0,0 +1,388 @@
+;
+; jcsample.asm - downsampling (AVX2)
+;
+; Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+; Copyright (C) 2015, Intel Corporation.
+; Copyright (C) 2016, D. R. Commander.
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+;
+; This file should be assembled with NASM (Netwide Assembler),
+; can *not* be assembled with Microsoft's MASM or any compatible
+; assembler (including Borland's Turbo Assembler).
+; NASM is available from http://nasm.sourceforge.net/ or
+; http://sourceforge.net/project/showfiles.php?group_id=6208
+
+%include "jsimdext.inc"
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_TEXT
+    BITS        32
+;
+; Downsample pixel values of a single component.
+; This version handles the common case of 2:1 horizontal and 1:1 vertical,
+; without smoothing.
+;
+; GLOBAL(void)
+; jsimd_h2v1_downsample_avx2(JDIMENSION image_width, int max_v_samp_factor,
+;                            JDIMENSION v_samp_factor,
+;                            JDIMENSION width_in_blocks, JSAMPARRAY input_data,
+;                            JSAMPARRAY output_data);
+;
+
+%define img_width(b)    (b) + 8         ; JDIMENSION image_width
+%define max_v_samp(b)   (b) + 12        ; int max_v_samp_factor
+%define v_samp(b)       (b) + 16        ; JDIMENSION v_samp_factor
+%define width_blks(b)   (b) + 20        ; JDIMENSION width_in_blocks
+%define input_data(b)   (b) + 24        ; JSAMPARRAY input_data
+%define output_data(b)  (b) + 28        ; JSAMPARRAY output_data
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_h2v1_downsample_avx2)
+
+EXTN(jsimd_h2v1_downsample_avx2):
+    push        ebp
+    mov         ebp, esp
+;   push        ebx                     ; unused
+;   push        ecx                     ; need not be preserved
+;   push        edx                     ; need not be preserved
+    push        esi
+    push        edi
+
+    mov         ecx, JDIMENSION [width_blks(ebp)]
+    shl         ecx, 3                  ; imul ecx,DCTSIZE (ecx = output_cols)
+    jz          near .return
+
+    mov         edx, JDIMENSION [img_width(ebp)]
+
+    ; -- expand_right_edge
+
+    push        ecx
+    shl         ecx, 1                  ; output_cols * 2
+    sub         ecx, edx
+    jle         short .expand_end
+
+    mov         eax, INT [max_v_samp(ebp)]
+    test        eax, eax
+    jle         short .expand_end
+
+    cld
+    mov         esi, JSAMPARRAY [input_data(ebp)]  ; input_data
+    alignx      16, 7
+.expandloop:
+    push        eax
+    push        ecx
+
+    mov         edi, JSAMPROW [esi]
+    add         edi, edx
+    mov         al, JSAMPLE [edi-1]
+
+    rep stosb
+
+    pop         ecx
+    pop         eax
+
+    add         esi, byte SIZEOF_JSAMPROW
+    dec         eax
+    jg          short .expandloop
+
+.expand_end:
+    pop         ecx                     ; output_cols
+
+    ; -- h2v1_downsample
+
+    mov         eax, JDIMENSION [v_samp(ebp)]  ; rowctr
+    test        eax, eax
+    jle         near .return
+
+    mov         edx, 0x00010000         ; bias pattern
+    vmovd       xmm7, edx
+    vpshufd     xmm7, xmm7, 0x00        ; xmm7={0, 1, 0, 1, 0, 1, 0, 1}
+    vperm2i128  ymm7, ymm7, ymm7, 0     ; ymm7={xmm7, xmm7}
+    vpcmpeqw    ymm6, ymm6, ymm6
+    vpsrlw      ymm6, ymm6, BYTE_BIT    ; ymm6={0xFF 0x00 0xFF 0x00 ..}
+
+    mov         esi, JSAMPARRAY [input_data(ebp)]   ; input_data
+    mov         edi, JSAMPARRAY [output_data(ebp)]  ; output_data
+    alignx      16, 7
+.rowloop:
+    push        ecx
+    push        edi
+    push        esi
+
+    mov         esi, JSAMPROW [esi]     ; inptr
+    mov         edi, JSAMPROW [edi]     ; outptr
+
+    cmp         ecx, byte SIZEOF_YMMWORD
+    jae         short .columnloop
+    alignx      16, 7
+
+.columnloop_r24:
+    ; ecx can possibly be 8, 16, 24
+    cmp         ecx, 24
+    jne         .columnloop_r16
+    vmovdqu     ymm0, YMMWORD [esi+0*SIZEOF_YMMWORD]
+    vmovdqu     xmm1, XMMWORD [esi+1*SIZEOF_YMMWORD]
+    mov         ecx, SIZEOF_YMMWORD
+    jmp         short .downsample
+
+.columnloop_r16:
+    cmp         ecx, 16
+    jne         .columnloop_r8
+    vmovdqu     ymm0, YMMWORD [esi+0*SIZEOF_YMMWORD]
+    vpxor       ymm1, ymm1, ymm1
+    mov         ecx, SIZEOF_YMMWORD
+    jmp         short .downsample
+
+.columnloop_r8:
+    vmovdqu     xmm0, XMMWORD[esi+0*SIZEOF_YMMWORD]
+    vpxor       ymm1, ymm1, ymm1
+    mov         ecx, SIZEOF_YMMWORD
+    jmp         short .downsample
+    alignx      16, 7
+
+.columnloop:
+    vmovdqu     ymm0, YMMWORD [esi+0*SIZEOF_YMMWORD]
+    vmovdqu     ymm1, YMMWORD [esi+1*SIZEOF_YMMWORD]
+
+.downsample:
+    vpsrlw      ymm2, ymm0, BYTE_BIT
+    vpand       ymm0, ymm0, ymm6
+    vpsrlw      ymm3, ymm1, BYTE_BIT
+    vpand       ymm1, ymm1, ymm6
+
+    vpaddw      ymm0, ymm0, ymm2
+    vpaddw      ymm1, ymm1, ymm3
+    vpaddw      ymm0, ymm0, ymm7
+    vpaddw      ymm1, ymm1, ymm7
+    vpsrlw      ymm0, ymm0, 1
+    vpsrlw      ymm1, ymm1, 1
+
+    vpackuswb   ymm0, ymm0, ymm1
+    vpermq      ymm0, ymm0, 0xd8
+
+    vmovdqu     YMMWORD [edi+0*SIZEOF_YMMWORD], ymm0
+
+    sub         ecx, byte SIZEOF_YMMWORD    ; outcol
+    add         esi, byte 2*SIZEOF_YMMWORD  ; inptr
+    add         edi, byte 1*SIZEOF_YMMWORD  ; outptr
+    cmp         ecx, byte SIZEOF_YMMWORD
+    jae         short .columnloop
+    test        ecx, ecx
+    jnz         near .columnloop_r24
+
+    pop         esi
+    pop         edi
+    pop         ecx
+
+    add         esi, byte SIZEOF_JSAMPROW  ; input_data
+    add         edi, byte SIZEOF_JSAMPROW  ; output_data
+    dec         eax                        ; rowctr
+    jg          near .rowloop
+
+.return:
+    vzeroupper
+    pop         edi
+    pop         esi
+;   pop         edx                     ; need not be preserved
+;   pop         ecx                     ; need not be preserved
+;   pop         ebx                     ; unused
+    pop         ebp
+    ret
+
+; --------------------------------------------------------------------------
+;
+; Downsample pixel values of a single component.
+; This version handles the standard case of 2:1 horizontal and 2:1 vertical,
+; without smoothing.
+;
+; GLOBAL(void)
+; jsimd_h2v2_downsample_avx2(JDIMENSION image_width, int max_v_samp_factor,
+;                            JDIMENSION v_samp_factor,
+;                            JDIMENSION width_in_blocks, JSAMPARRAY input_data,
+;                            JSAMPARRAY output_data);
+;
+
+%define img_width(b)    (b) + 8         ; JDIMENSION image_width
+%define max_v_samp(b)   (b) + 12        ; int max_v_samp_factor
+%define v_samp(b)       (b) + 16        ; JDIMENSION v_samp_factor
+%define width_blks(b)   (b) + 20        ; JDIMENSION width_in_blocks
+%define input_data(b)   (b) + 24        ; JSAMPARRAY input_data
+%define output_data(b)  (b) + 28        ; JSAMPARRAY output_data
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_h2v2_downsample_avx2)
+
+EXTN(jsimd_h2v2_downsample_avx2):
+    push        ebp
+    mov         ebp, esp
+;   push        ebx                     ; unused
+;   push        ecx                     ; need not be preserved
+;   push        edx                     ; need not be preserved
+    push        esi
+    push        edi
+
+    mov         ecx, JDIMENSION [width_blks(ebp)]
+    shl         ecx, 3                  ; imul ecx,DCTSIZE (ecx = output_cols)
+    jz          near .return
+
+    mov         edx, JDIMENSION [img_width(ebp)]
+
+    ; -- expand_right_edge
+
+    push        ecx
+    shl         ecx, 1                  ; output_cols * 2
+    sub         ecx, edx
+    jle         short .expand_end
+
+    mov         eax, INT [max_v_samp(ebp)]
+    test        eax, eax
+    jle         short .expand_end
+
+    cld
+    mov         esi, JSAMPARRAY [input_data(ebp)]  ; input_data
+    alignx      16, 7
+.expandloop:
+    push        eax
+    push        ecx
+
+    mov         edi, JSAMPROW [esi]
+    add         edi, edx
+    mov         al, JSAMPLE [edi-1]
+
+    rep stosb
+
+    pop         ecx
+    pop         eax
+
+    add         esi, byte SIZEOF_JSAMPROW
+    dec         eax
+    jg          short .expandloop
+
+.expand_end:
+    pop         ecx                     ; output_cols
+
+    ; -- h2v2_downsample
+
+    mov         eax, JDIMENSION [v_samp(ebp)]  ; rowctr
+    test        eax, eax
+    jle         near .return
+
+    mov         edx, 0x00020001         ; bias pattern
+    vmovd       xmm7, edx
+    vpcmpeqw    ymm6, ymm6, ymm6
+    vpshufd     xmm7, xmm7, 0x00        ; ymm7={1, 2, 1, 2, 1, 2, 1, 2}
+    vperm2i128  ymm7, ymm7, ymm7, 0
+    vpsrlw      ymm6, ymm6, BYTE_BIT    ; ymm6={0xFF 0x00 0xFF 0x00 ..}
+
+    mov         esi, JSAMPARRAY [input_data(ebp)]   ; input_data
+    mov         edi, JSAMPARRAY [output_data(ebp)]  ; output_data
+    alignx      16, 7
+.rowloop:
+    push        ecx
+    push        edi
+    push        esi
+
+    mov         edx, JSAMPROW [esi+0*SIZEOF_JSAMPROW]  ; inptr0
+    mov         esi, JSAMPROW [esi+1*SIZEOF_JSAMPROW]  ; inptr1
+    mov         edi, JSAMPROW [edi]                    ; outptr
+
+    cmp         ecx, byte SIZEOF_YMMWORD
+    jae         short .columnloop
+    alignx      16, 7
+
+.columnloop_r24:
+    cmp         ecx, 24
+    jne         .columnloop_r16
+    vmovdqu     ymm0, YMMWORD [edx+0*SIZEOF_YMMWORD]
+    vmovdqu     ymm1, YMMWORD [esi+0*SIZEOF_YMMWORD]
+    vmovdqu     xmm2, XMMWORD [edx+1*SIZEOF_YMMWORD]
+    vmovdqu     xmm3, XMMWORD [esi+1*SIZEOF_YMMWORD]
+    mov         ecx, SIZEOF_YMMWORD
+    jmp         short .downsample
+
+.columnloop_r16:
+    cmp         ecx, 16
+    jne         .columnloop_r8
+    vmovdqu     ymm0, YMMWORD [edx+0*SIZEOF_YMMWORD]
+    vmovdqu     ymm1, YMMWORD [esi+0*SIZEOF_YMMWORD]
+    vpxor       ymm2, ymm2, ymm2
+    vpxor       ymm3, ymm3, ymm3
+    mov         ecx, SIZEOF_YMMWORD
+    jmp         short .downsample
+
+.columnloop_r8:
+    vmovdqu     xmm0, XMMWORD [edx+0*SIZEOF_XMMWORD]
+    vmovdqu     xmm1, XMMWORD [esi+0*SIZEOF_XMMWORD]
+    vpxor       ymm2, ymm2, ymm2
+    vpxor       ymm3, ymm3, ymm3
+    mov         ecx, SIZEOF_YMMWORD
+    jmp         short .downsample
+    alignx      16, 7
+
+.columnloop:
+    vmovdqu     ymm0, YMMWORD [edx+0*SIZEOF_YMMWORD]
+    vmovdqu     ymm1, YMMWORD [esi+0*SIZEOF_YMMWORD]
+    vmovdqu     ymm2, YMMWORD [edx+1*SIZEOF_YMMWORD]
+    vmovdqu     ymm3, YMMWORD [esi+1*SIZEOF_YMMWORD]
+
+.downsample:
+    vpand       ymm4, ymm0, ymm6
+    vpsrlw      ymm0, ymm0, BYTE_BIT
+    vpand       ymm5, ymm1, ymm6
+    vpsrlw      ymm1, ymm1, BYTE_BIT
+    vpaddw      ymm0, ymm0, ymm4
+    vpaddw      ymm1, ymm1, ymm5
+
+    vpand       ymm4, ymm2, ymm6
+    vpsrlw      ymm2, ymm2, BYTE_BIT
+    vpand       ymm5, ymm3, ymm6
+    vpsrlw      ymm3, ymm3, BYTE_BIT
+    vpaddw      ymm2, ymm2, ymm4
+    vpaddw      ymm3, ymm3, ymm5
+
+    vpaddw      ymm0, ymm0, ymm1
+    vpaddw      ymm2, ymm2, ymm3
+    vpaddw      ymm0, ymm0, ymm7
+    vpaddw      ymm2, ymm2, ymm7
+    vpsrlw      ymm0, ymm0, 2
+    vpsrlw      ymm2, ymm2, 2
+
+    vpackuswb   ymm0, ymm0, ymm2
+    vpermq      ymm0, ymm0, 0xd8
+
+    vmovdqu     YMMWORD [edi+0*SIZEOF_YMMWORD], ymm0
+
+    sub         ecx, byte SIZEOF_YMMWORD    ; outcol
+    add         edx, byte 2*SIZEOF_YMMWORD  ; inptr0
+    add         esi, byte 2*SIZEOF_YMMWORD  ; inptr1
+    add         edi, byte 1*SIZEOF_YMMWORD  ; outptr
+    cmp         ecx, byte SIZEOF_YMMWORD
+    jae         near .columnloop
+    test        ecx, ecx
+    jnz         near .columnloop_r24
+
+    pop         esi
+    pop         edi
+    pop         ecx
+
+    add         esi, byte 2*SIZEOF_JSAMPROW  ; input_data
+    add         edi, byte 1*SIZEOF_JSAMPROW  ; output_data
+    dec         eax                          ; rowctr
+    jg          near .rowloop
+
+.return:
+    vzeroupper
+    pop         edi
+    pop         esi
+;   pop         edx                     ; need not be preserved
+;   pop         ecx                     ; need not be preserved
+;   pop         ebx                     ; unused
+    pop         ebp
+    ret
+
+; For some reason, the OS X linker does not honor the request to align the
+; segment unless we do this.
+    align       32
diff --git a/3rdparty/libjpeg/src/simd/i386/jcsample-mmx.asm b/3rdparty/libjpeg/src/simd/i386/jcsample-mmx.asm
new file mode 100644
index 00000000..2c223eeb
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/i386/jcsample-mmx.asm
@@ -0,0 +1,324 @@
+;
+; jcsample.asm - downsampling (MMX)
+;
+; Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+; Copyright (C) 2016, D. R. Commander.
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+;
+; This file should be assembled with NASM (Netwide Assembler),
+; can *not* be assembled with Microsoft's MASM or any compatible
+; assembler (including Borland's Turbo Assembler).
+; NASM is available from http://nasm.sourceforge.net/ or
+; http://sourceforge.net/project/showfiles.php?group_id=6208
+
+%include "jsimdext.inc"
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_TEXT
+    BITS        32
+;
+; Downsample pixel values of a single component.
+; This version handles the common case of 2:1 horizontal and 1:1 vertical,
+; without smoothing.
+;
+; GLOBAL(void)
+; jsimd_h2v1_downsample_mmx(JDIMENSION image_width, int max_v_samp_factor,
+;                           JDIMENSION v_samp_factor,
+;                           JDIMENSION width_in_blocks, JSAMPARRAY input_data,
+;                           JSAMPARRAY output_data);
+;
+
+%define img_width(b)    (b) + 8         ; JDIMENSION image_width
+%define max_v_samp(b)   (b) + 12        ; int max_v_samp_factor
+%define v_samp(b)       (b) + 16        ; JDIMENSION v_samp_factor
+%define width_blks(b)   (b) + 20        ; JDIMENSION width_in_blocks
+%define input_data(b)   (b) + 24        ; JSAMPARRAY input_data
+%define output_data(b)  (b) + 28        ; JSAMPARRAY output_data
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_h2v1_downsample_mmx)
+
+EXTN(jsimd_h2v1_downsample_mmx):
+    push        ebp
+    mov         ebp, esp
+;   push        ebx                     ; unused
+;   push        ecx                     ; need not be preserved
+;   push        edx                     ; need not be preserved
+    push        esi
+    push        edi
+
+    mov         ecx, JDIMENSION [width_blks(ebp)]
+    shl         ecx, 3                  ; imul ecx,DCTSIZE (ecx = output_cols)
+    jz          near .return
+
+    mov         edx, JDIMENSION [img_width(ebp)]
+
+    ; -- expand_right_edge
+
+    push        ecx
+    shl         ecx, 1                  ; output_cols * 2
+    sub         ecx, edx
+    jle         short .expand_end
+
+    mov         eax, INT [max_v_samp(ebp)]
+    test        eax, eax
+    jle         short .expand_end
+
+    cld
+    mov         esi, JSAMPARRAY [input_data(ebp)]  ; input_data
+    alignx      16, 7
+.expandloop:
+    push        eax
+    push        ecx
+
+    mov         edi, JSAMPROW [esi]
+    add         edi, edx
+    mov         al, JSAMPLE [edi-1]
+
+    rep stosb
+
+    pop         ecx
+    pop         eax
+
+    add         esi, byte SIZEOF_JSAMPROW
+    dec         eax
+    jg          short .expandloop
+
+.expand_end:
+    pop         ecx                     ; output_cols
+
+    ; -- h2v1_downsample
+
+    mov         eax, JDIMENSION [v_samp(ebp)]  ; rowctr
+    test        eax, eax
+    jle         near .return
+
+    mov         edx, 0x00010000         ; bias pattern
+    movd        mm7, edx
+    pcmpeqw     mm6, mm6
+    punpckldq   mm7, mm7                ; mm7={0, 1, 0, 1}
+    psrlw       mm6, BYTE_BIT           ; mm6={0xFF 0x00 0xFF 0x00 ..}
+
+    mov         esi, JSAMPARRAY [input_data(ebp)]   ; input_data
+    mov         edi, JSAMPARRAY [output_data(ebp)]  ; output_data
+    alignx      16, 7
+.rowloop:
+    push        ecx
+    push        edi
+    push        esi
+
+    mov         esi, JSAMPROW [esi]     ; inptr
+    mov         edi, JSAMPROW [edi]     ; outptr
+    alignx      16, 7
+.columnloop:
+
+    movq        mm0, MMWORD [esi+0*SIZEOF_MMWORD]
+    movq        mm1, MMWORD [esi+1*SIZEOF_MMWORD]
+    movq        mm2, mm0
+    movq        mm3, mm1
+
+    pand        mm0, mm6
+    psrlw       mm2, BYTE_BIT
+    pand        mm1, mm6
+    psrlw       mm3, BYTE_BIT
+
+    paddw       mm0, mm2
+    paddw       mm1, mm3
+    paddw       mm0, mm7
+    paddw       mm1, mm7
+    psrlw       mm0, 1
+    psrlw       mm1, 1
+
+    packuswb    mm0, mm1
+
+    movq        MMWORD [edi+0*SIZEOF_MMWORD], mm0
+
+    add         esi, byte 2*SIZEOF_MMWORD  ; inptr
+    add         edi, byte 1*SIZEOF_MMWORD  ; outptr
+    sub         ecx, byte SIZEOF_MMWORD    ; outcol
+    jnz         short .columnloop
+
+    pop         esi
+    pop         edi
+    pop         ecx
+
+    add         esi, byte SIZEOF_JSAMPROW  ; input_data
+    add         edi, byte SIZEOF_JSAMPROW  ; output_data
+    dec         eax                        ; rowctr
+    jg          short .rowloop
+
+    emms                                ; empty MMX state
+
+.return:
+    pop         edi
+    pop         esi
+;   pop         edx                     ; need not be preserved
+;   pop         ecx                     ; need not be preserved
+;   pop         ebx                     ; unused
+    pop         ebp
+    ret
+
+; --------------------------------------------------------------------------
+;
+; Downsample pixel values of a single component.
+; This version handles the standard case of 2:1 horizontal and 2:1 vertical,
+; without smoothing.
+;
+; GLOBAL(void)
+; jsimd_h2v2_downsample_mmx(JDIMENSION image_width, int max_v_samp_factor,
+;                           JDIMENSION v_samp_factor,
+;                           JDIMENSION width_in_blocks, JSAMPARRAY input_data,
+;                           JSAMPARRAY output_data);
+;
+
+%define img_width(b)    (b) + 8         ; JDIMENSION image_width
+%define max_v_samp(b)   (b) + 12        ; int max_v_samp_factor
+%define v_samp(b)       (b) + 16        ; JDIMENSION v_samp_factor
+%define width_blks(b)   (b) + 20        ; JDIMENSION width_in_blocks
+%define input_data(b)   (b) + 24        ; JSAMPARRAY input_data
+%define output_data(b)  (b) + 28        ; JSAMPARRAY output_data
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_h2v2_downsample_mmx)
+
+EXTN(jsimd_h2v2_downsample_mmx):
+    push        ebp
+    mov         ebp, esp
+;   push        ebx                     ; unused
+;   push        ecx                     ; need not be preserved
+;   push        edx                     ; need not be preserved
+    push        esi
+    push        edi
+
+    mov         ecx, JDIMENSION [width_blks(ebp)]
+    shl         ecx, 3                  ; imul ecx,DCTSIZE (ecx = output_cols)
+    jz          near .return
+
+    mov         edx, JDIMENSION [img_width(ebp)]
+
+    ; -- expand_right_edge
+
+    push        ecx
+    shl         ecx, 1                  ; output_cols * 2
+    sub         ecx, edx
+    jle         short .expand_end
+
+    mov         eax, INT [max_v_samp(ebp)]
+    test        eax, eax
+    jle         short .expand_end
+
+    cld
+    mov         esi, JSAMPARRAY [input_data(ebp)]  ; input_data
+    alignx      16, 7
+.expandloop:
+    push        eax
+    push        ecx
+
+    mov         edi, JSAMPROW [esi]
+    add         edi, edx
+    mov         al, JSAMPLE [edi-1]
+
+    rep stosb
+
+    pop         ecx
+    pop         eax
+
+    add         esi, byte SIZEOF_JSAMPROW
+    dec         eax
+    jg          short .expandloop
+
+.expand_end:
+    pop         ecx                     ; output_cols
+
+    ; -- h2v2_downsample
+
+    mov         eax, JDIMENSION [v_samp(ebp)]  ; rowctr
+    test        eax, eax
+    jle         near .return
+
+    mov         edx, 0x00020001         ; bias pattern
+    movd        mm7, edx
+    pcmpeqw     mm6, mm6
+    punpckldq   mm7, mm7                ; mm7={1, 2, 1, 2}
+    psrlw       mm6, BYTE_BIT           ; mm6={0xFF 0x00 0xFF 0x00 ..}
+
+    mov         esi, JSAMPARRAY [input_data(ebp)]   ; input_data
+    mov         edi, JSAMPARRAY [output_data(ebp)]  ; output_data
+    alignx      16, 7
+.rowloop:
+    push        ecx
+    push        edi
+    push        esi
+
+    mov         edx, JSAMPROW [esi+0*SIZEOF_JSAMPROW]  ; inptr0
+    mov         esi, JSAMPROW [esi+1*SIZEOF_JSAMPROW]  ; inptr1
+    mov         edi, JSAMPROW [edi]                    ; outptr
+    alignx      16, 7
+.columnloop:
+
+    movq        mm0, MMWORD [edx+0*SIZEOF_MMWORD]
+    movq        mm1, MMWORD [esi+0*SIZEOF_MMWORD]
+    movq        mm2, MMWORD [edx+1*SIZEOF_MMWORD]
+    movq        mm3, MMWORD [esi+1*SIZEOF_MMWORD]
+
+    movq        mm4, mm0
+    movq        mm5, mm1
+    pand        mm0, mm6
+    psrlw       mm4, BYTE_BIT
+    pand        mm1, mm6
+    psrlw       mm5, BYTE_BIT
+    paddw       mm0, mm4
+    paddw       mm1, mm5
+
+    movq        mm4, mm2
+    movq        mm5, mm3
+    pand        mm2, mm6
+    psrlw       mm4, BYTE_BIT
+    pand        mm3, mm6
+    psrlw       mm5, BYTE_BIT
+    paddw       mm2, mm4
+    paddw       mm3, mm5
+
+    paddw       mm0, mm1
+    paddw       mm2, mm3
+    paddw       mm0, mm7
+    paddw       mm2, mm7
+    psrlw       mm0, 2
+    psrlw       mm2, 2
+
+    packuswb    mm0, mm2
+
+    movq        MMWORD [edi+0*SIZEOF_MMWORD], mm0
+
+    add         edx, byte 2*SIZEOF_MMWORD  ; inptr0
+    add         esi, byte 2*SIZEOF_MMWORD  ; inptr1
+    add         edi, byte 1*SIZEOF_MMWORD  ; outptr
+    sub         ecx, byte SIZEOF_MMWORD    ; outcol
+    jnz         near .columnloop
+
+    pop         esi
+    pop         edi
+    pop         ecx
+
+    add         esi, byte 2*SIZEOF_JSAMPROW  ; input_data
+    add         edi, byte 1*SIZEOF_JSAMPROW  ; output_data
+    dec         eax                          ; rowctr
+    jg          near .rowloop
+
+    emms                                ; empty MMX state
+
+.return:
+    pop         edi
+    pop         esi
+;   pop         edx                     ; need not be preserved
+;   pop         ecx                     ; need not be preserved
+;   pop         ebx                     ; unused
+    pop         ebp
+    ret
+
+; For some reason, the OS X linker does not honor the request to align the
+; segment unless we do this.
+    align       32
diff --git a/3rdparty/libjpeg/src/simd/i386/jcsample-sse2.asm b/3rdparty/libjpeg/src/simd/i386/jcsample-sse2.asm
new file mode 100644
index 00000000..4fea60d2
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/i386/jcsample-sse2.asm
@@ -0,0 +1,351 @@
+;
+; jcsample.asm - downsampling (SSE2)
+;
+; Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+; Copyright (C) 2016, D. R. Commander.
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+;
+; This file should be assembled with NASM (Netwide Assembler),
+; can *not* be assembled with Microsoft's MASM or any compatible
+; assembler (including Borland's Turbo Assembler).
+; NASM is available from http://nasm.sourceforge.net/ or
+; http://sourceforge.net/project/showfiles.php?group_id=6208
+
+%include "jsimdext.inc"
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_TEXT
+    BITS        32
+;
+; Downsample pixel values of a single component.
+; This version handles the common case of 2:1 horizontal and 1:1 vertical,
+; without smoothing.
+;
+; GLOBAL(void)
+; jsimd_h2v1_downsample_sse2(JDIMENSION image_width, int max_v_samp_factor,
+;                            JDIMENSION v_samp_factor,
+;                            JDIMENSION width_in_blocks, JSAMPARRAY input_data,
+;                            JSAMPARRAY output_data);
+;
+
+%define img_width(b)    (b) + 8         ; JDIMENSION image_width
+%define max_v_samp(b)   (b) + 12        ; int max_v_samp_factor
+%define v_samp(b)       (b) + 16        ; JDIMENSION v_samp_factor
+%define width_blks(b)   (b) + 20        ; JDIMENSION width_in_blocks
+%define input_data(b)   (b) + 24        ; JSAMPARRAY input_data
+%define output_data(b)  (b) + 28        ; JSAMPARRAY output_data
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_h2v1_downsample_sse2)
+
+EXTN(jsimd_h2v1_downsample_sse2):
+    push        ebp
+    mov         ebp, esp
+;   push        ebx                     ; unused
+;   push        ecx                     ; need not be preserved
+;   push        edx                     ; need not be preserved
+    push        esi
+    push        edi
+
+    mov         ecx, JDIMENSION [width_blks(ebp)]
+    shl         ecx, 3                  ; imul ecx,DCTSIZE (ecx = output_cols)
+    jz          near .return
+
+    mov         edx, JDIMENSION [img_width(ebp)]
+
+    ; -- expand_right_edge
+
+    push        ecx
+    shl         ecx, 1                  ; output_cols * 2
+    sub         ecx, edx
+    jle         short .expand_end
+
+    mov         eax, INT [max_v_samp(ebp)]
+    test        eax, eax
+    jle         short .expand_end
+
+    cld
+    mov         esi, JSAMPARRAY [input_data(ebp)]  ; input_data
+    alignx      16, 7
+.expandloop:
+    push        eax
+    push        ecx
+
+    mov         edi, JSAMPROW [esi]
+    add         edi, edx
+    mov         al, JSAMPLE [edi-1]
+
+    rep stosb
+
+    pop         ecx
+    pop         eax
+
+    add         esi, byte SIZEOF_JSAMPROW
+    dec         eax
+    jg          short .expandloop
+
+.expand_end:
+    pop         ecx                     ; output_cols
+
+    ; -- h2v1_downsample
+
+    mov         eax, JDIMENSION [v_samp(ebp)]  ; rowctr
+    test        eax, eax
+    jle         near .return
+
+    mov         edx, 0x00010000         ; bias pattern
+    movd        xmm7, edx
+    pcmpeqw     xmm6, xmm6
+    pshufd      xmm7, xmm7, 0x00        ; xmm7={0, 1, 0, 1, 0, 1, 0, 1}
+    psrlw       xmm6, BYTE_BIT          ; xmm6={0xFF 0x00 0xFF 0x00 ..}
+
+    mov         esi, JSAMPARRAY [input_data(ebp)]   ; input_data
+    mov         edi, JSAMPARRAY [output_data(ebp)]  ; output_data
+    alignx      16, 7
+.rowloop:
+    push        ecx
+    push        edi
+    push        esi
+
+    mov         esi, JSAMPROW [esi]     ; inptr
+    mov         edi, JSAMPROW [edi]     ; outptr
+
+    cmp         ecx, byte SIZEOF_XMMWORD
+    jae         short .columnloop
+    alignx      16, 7
+
+.columnloop_r8:
+    movdqa      xmm0, XMMWORD [esi+0*SIZEOF_XMMWORD]
+    pxor        xmm1, xmm1
+    mov         ecx, SIZEOF_XMMWORD
+    jmp         short .downsample
+    alignx      16, 7
+
+.columnloop:
+    movdqa      xmm0, XMMWORD [esi+0*SIZEOF_XMMWORD]
+    movdqa      xmm1, XMMWORD [esi+1*SIZEOF_XMMWORD]
+
+.downsample:
+    movdqa      xmm2, xmm0
+    movdqa      xmm3, xmm1
+
+    pand        xmm0, xmm6
+    psrlw       xmm2, BYTE_BIT
+    pand        xmm1, xmm6
+    psrlw       xmm3, BYTE_BIT
+
+    paddw       xmm0, xmm2
+    paddw       xmm1, xmm3
+    paddw       xmm0, xmm7
+    paddw       xmm1, xmm7
+    psrlw       xmm0, 1
+    psrlw       xmm1, 1
+
+    packuswb    xmm0, xmm1
+
+    movdqa      XMMWORD [edi+0*SIZEOF_XMMWORD], xmm0
+
+    sub         ecx, byte SIZEOF_XMMWORD    ; outcol
+    add         esi, byte 2*SIZEOF_XMMWORD  ; inptr
+    add         edi, byte 1*SIZEOF_XMMWORD  ; outptr
+    cmp         ecx, byte SIZEOF_XMMWORD
+    jae         short .columnloop
+    test        ecx, ecx
+    jnz         short .columnloop_r8
+
+    pop         esi
+    pop         edi
+    pop         ecx
+
+    add         esi, byte SIZEOF_JSAMPROW  ; input_data
+    add         edi, byte SIZEOF_JSAMPROW  ; output_data
+    dec         eax                        ; rowctr
+    jg          near .rowloop
+
+.return:
+    pop         edi
+    pop         esi
+;   pop         edx                     ; need not be preserved
+;   pop         ecx                     ; need not be preserved
+;   pop         ebx                     ; unused
+    pop         ebp
+    ret
+
+; --------------------------------------------------------------------------
+;
+; Downsample pixel values of a single component.
+; This version handles the standard case of 2:1 horizontal and 2:1 vertical,
+; without smoothing.
+;
+; GLOBAL(void)
+; jsimd_h2v2_downsample_sse2(JDIMENSION image_width, int max_v_samp_factor,
+;                            JDIMENSION v_samp_factor,
+;                            JDIMENSION width_in_blocks, JSAMPARRAY input_data,
+;                            JSAMPARRAY output_data);
+;
+
+%define img_width(b)    (b) + 8         ; JDIMENSION image_width
+%define max_v_samp(b)   (b) + 12        ; int max_v_samp_factor
+%define v_samp(b)       (b) + 16        ; JDIMENSION v_samp_factor
+%define width_blks(b)   (b) + 20        ; JDIMENSION width_in_blocks
+%define input_data(b)   (b) + 24        ; JSAMPARRAY input_data
+%define output_data(b)  (b) + 28        ; JSAMPARRAY output_data
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_h2v2_downsample_sse2)
+
+EXTN(jsimd_h2v2_downsample_sse2):
+    push        ebp
+    mov         ebp, esp
+;   push        ebx                     ; unused
+;   push        ecx                     ; need not be preserved
+;   push        edx                     ; need not be preserved
+    push        esi
+    push        edi
+
+    mov         ecx, JDIMENSION [width_blks(ebp)]
+    shl         ecx, 3                  ; imul ecx,DCTSIZE (ecx = output_cols)
+    jz          near .return
+
+    mov         edx, JDIMENSION [img_width(ebp)]
+
+    ; -- expand_right_edge
+
+    push        ecx
+    shl         ecx, 1                  ; output_cols * 2
+    sub         ecx, edx
+    jle         short .expand_end
+
+    mov         eax, INT [max_v_samp(ebp)]
+    test        eax, eax
+    jle         short .expand_end
+
+    cld
+    mov         esi, JSAMPARRAY [input_data(ebp)]  ; input_data
+    alignx      16, 7
+.expandloop:
+    push        eax
+    push        ecx
+
+    mov         edi, JSAMPROW [esi]
+    add         edi, edx
+    mov         al, JSAMPLE [edi-1]
+
+    rep stosb
+
+    pop         ecx
+    pop         eax
+
+    add         esi, byte SIZEOF_JSAMPROW
+    dec         eax
+    jg          short .expandloop
+
+.expand_end:
+    pop         ecx                     ; output_cols
+
+    ; -- h2v2_downsample
+
+    mov         eax, JDIMENSION [v_samp(ebp)]  ; rowctr
+    test        eax, eax
+    jle         near .return
+
+    mov         edx, 0x00020001         ; bias pattern
+    movd        xmm7, edx
+    pcmpeqw     xmm6, xmm6
+    pshufd      xmm7, xmm7, 0x00        ; xmm7={1, 2, 1, 2, 1, 2, 1, 2}
+    psrlw       xmm6, BYTE_BIT          ; xmm6={0xFF 0x00 0xFF 0x00 ..}
+
+    mov         esi, JSAMPARRAY [input_data(ebp)]   ; input_data
+    mov         edi, JSAMPARRAY [output_data(ebp)]  ; output_data
+    alignx      16, 7
+.rowloop:
+    push        ecx
+    push        edi
+    push        esi
+
+    mov         edx, JSAMPROW [esi+0*SIZEOF_JSAMPROW]  ; inptr0
+    mov         esi, JSAMPROW [esi+1*SIZEOF_JSAMPROW]  ; inptr1
+    mov         edi, JSAMPROW [edi]                    ; outptr
+
+    cmp         ecx, byte SIZEOF_XMMWORD
+    jae         short .columnloop
+    alignx      16, 7
+
+.columnloop_r8:
+    movdqa      xmm0, XMMWORD [edx+0*SIZEOF_XMMWORD]
+    movdqa      xmm1, XMMWORD [esi+0*SIZEOF_XMMWORD]
+    pxor        xmm2, xmm2
+    pxor        xmm3, xmm3
+    mov         ecx, SIZEOF_XMMWORD
+    jmp         short .downsample
+    alignx      16, 7
+
+.columnloop:
+    movdqa      xmm0, XMMWORD [edx+0*SIZEOF_XMMWORD]
+    movdqa      xmm1, XMMWORD [esi+0*SIZEOF_XMMWORD]
+    movdqa      xmm2, XMMWORD [edx+1*SIZEOF_XMMWORD]
+    movdqa      xmm3, XMMWORD [esi+1*SIZEOF_XMMWORD]
+
+.downsample:
+    movdqa      xmm4, xmm0
+    movdqa      xmm5, xmm1
+    pand        xmm0, xmm6
+    psrlw       xmm4, BYTE_BIT
+    pand        xmm1, xmm6
+    psrlw       xmm5, BYTE_BIT
+    paddw       xmm0, xmm4
+    paddw       xmm1, xmm5
+
+    movdqa      xmm4, xmm2
+    movdqa      xmm5, xmm3
+    pand        xmm2, xmm6
+    psrlw       xmm4, BYTE_BIT
+    pand        xmm3, xmm6
+    psrlw       xmm5, BYTE_BIT
+    paddw       xmm2, xmm4
+    paddw       xmm3, xmm5
+
+    paddw       xmm0, xmm1
+    paddw       xmm2, xmm3
+    paddw       xmm0, xmm7
+    paddw       xmm2, xmm7
+    psrlw       xmm0, 2
+    psrlw       xmm2, 2
+
+    packuswb    xmm0, xmm2
+
+    movdqa      XMMWORD [edi+0*SIZEOF_XMMWORD], xmm0
+
+    sub         ecx, byte SIZEOF_XMMWORD    ; outcol
+    add         edx, byte 2*SIZEOF_XMMWORD  ; inptr0
+    add         esi, byte 2*SIZEOF_XMMWORD  ; inptr1
+    add         edi, byte 1*SIZEOF_XMMWORD  ; outptr
+    cmp         ecx, byte SIZEOF_XMMWORD
+    jae         near .columnloop
+    test        ecx, ecx
+    jnz         near .columnloop_r8
+
+    pop         esi
+    pop         edi
+    pop         ecx
+
+    add         esi, byte 2*SIZEOF_JSAMPROW  ; input_data
+    add         edi, byte 1*SIZEOF_JSAMPROW  ; output_data
+    dec         eax                          ; rowctr
+    jg          near .rowloop
+
+.return:
+    pop         edi
+    pop         esi
+;   pop         edx                     ; need not be preserved
+;   pop         ecx                     ; need not be preserved
+;   pop         ebx                     ; unused
+    pop         ebp
+    ret
+
+; For some reason, the OS X linker does not honor the request to align the
+; segment unless we do this.
+    align       32
diff --git a/3rdparty/libjpeg/src/simd/i386/jdcolext-avx2.asm b/3rdparty/libjpeg/src/simd/i386/jdcolext-avx2.asm
new file mode 100644
index 00000000..015be041
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/i386/jdcolext-avx2.asm
@@ -0,0 +1,515 @@
+;
+; jdcolext.asm - colorspace conversion (AVX2)
+;
+; Copyright 2009, 2012 Pierre Ossman <ossman@cendio.se> for Cendio AB
+; Copyright (C) 2012, 2016, D. R. Commander.
+; Copyright (C) 2015, Intel Corporation.
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+;
+; This file should be assembled with NASM (Netwide Assembler),
+; can *not* be assembled with Microsoft's MASM or any compatible
+; assembler (including Borland's Turbo Assembler).
+; NASM is available from http://nasm.sourceforge.net/ or
+; http://sourceforge.net/project/showfiles.php?group_id=6208
+
+%include "jcolsamp.inc"
+
+; --------------------------------------------------------------------------
+;
+; Convert some rows of samples to the output colorspace.
+;
+; GLOBAL(void)
+; jsimd_ycc_rgb_convert_avx2(JDIMENSION out_width, JSAMPIMAGE input_buf,
+;                            JDIMENSION input_row, JSAMPARRAY output_buf,
+;                            int num_rows)
+;
+
+%define out_width(b)   (b) + 8          ; JDIMENSION out_width
+%define input_buf(b)   (b) + 12         ; JSAMPIMAGE input_buf
+%define input_row(b)   (b) + 16         ; JDIMENSION input_row
+%define output_buf(b)  (b) + 20         ; JSAMPARRAY output_buf
+%define num_rows(b)    (b) + 24         ; int num_rows
+
+%define original_ebp   ebp + 0
+%define wk(i)          ebp - (WK_NUM - (i)) * SIZEOF_YMMWORD
+                                        ; ymmword wk[WK_NUM]
+%define WK_NUM         2
+%define gotptr         wk(0) - SIZEOF_POINTER  ; void * gotptr
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_ycc_rgb_convert_avx2)
+
+EXTN(jsimd_ycc_rgb_convert_avx2):
+    push        ebp
+    mov         eax, esp                     ; eax = original ebp
+    sub         esp, byte 4
+    and         esp, byte (-SIZEOF_YMMWORD)  ; align to 256 bits
+    mov         [esp], eax
+    mov         ebp, esp                     ; ebp = aligned ebp
+    lea         esp, [wk(0)]
+    pushpic     eax                     ; make a room for GOT address
+    push        ebx
+;   push        ecx                     ; need not be preserved
+;   push        edx                     ; need not be preserved
+    push        esi
+    push        edi
+
+    get_GOT     ebx                     ; get GOT address
+    movpic      POINTER [gotptr], ebx   ; save GOT address
+
+    mov         ecx, JDIMENSION [out_width(eax)]  ; num_cols
+    test        ecx, ecx
+    jz          near .return
+
+    push        ecx
+
+    mov         edi, JSAMPIMAGE [input_buf(eax)]
+    mov         ecx, JDIMENSION [input_row(eax)]
+    mov         esi, JSAMPARRAY [edi+0*SIZEOF_JSAMPARRAY]
+    mov         ebx, JSAMPARRAY [edi+1*SIZEOF_JSAMPARRAY]
+    mov         edx, JSAMPARRAY [edi+2*SIZEOF_JSAMPARRAY]
+    lea         esi, [esi+ecx*SIZEOF_JSAMPROW]
+    lea         ebx, [ebx+ecx*SIZEOF_JSAMPROW]
+    lea         edx, [edx+ecx*SIZEOF_JSAMPROW]
+
+    pop         ecx
+
+    mov         edi, JSAMPARRAY [output_buf(eax)]
+    mov         eax, INT [num_rows(eax)]
+    test        eax, eax
+    jle         near .return
+    alignx      16, 7
+.rowloop:
+    push        eax
+    push        edi
+    push        edx
+    push        ebx
+    push        esi
+    push        ecx                     ; col
+
+    mov         esi, JSAMPROW [esi]     ; inptr0
+    mov         ebx, JSAMPROW [ebx]     ; inptr1
+    mov         edx, JSAMPROW [edx]     ; inptr2
+    mov         edi, JSAMPROW [edi]     ; outptr
+    movpic      eax, POINTER [gotptr]   ; load GOT address (eax)
+    alignx      16, 7
+.columnloop:
+
+    vmovdqu     ymm5, YMMWORD [ebx]     ; ymm5=Cb(0123456789ABCDEFGHIJKLMNOPQRSTUV)
+    vmovdqu     ymm1, YMMWORD [edx]     ; ymm1=Cr(0123456789ABCDEFGHIJKLMNOPQRSTUV)
+
+    vpcmpeqw    ymm0, ymm0, ymm0
+    vpcmpeqw    ymm7, ymm7, ymm7
+    vpsrlw      ymm0, ymm0, BYTE_BIT    ; ymm0={0xFF 0x00 0xFF 0x00 ..}
+    vpsllw      ymm7, ymm7, 7           ; ymm7={0xFF80 0xFF80 0xFF80 0xFF80 ..}
+
+    vpand       ymm4, ymm0, ymm5        ; ymm4=Cb(02468ACEGIKMOQSU)=CbE
+    vpsrlw      ymm5, ymm5, BYTE_BIT    ; ymm5=Cb(13579BDFHJLNPRTV)=CbO
+    vpand       ymm0, ymm0, ymm1        ; ymm0=Cr(02468ACEGIKMOQSU)=CrE
+    vpsrlw      ymm1, ymm1, BYTE_BIT    ; ymm1=Cr(13579BDFHJLNPRTV)=CrO
+
+    vpaddw      ymm2, ymm4, ymm7
+    vpaddw      ymm3, ymm5, ymm7
+    vpaddw      ymm6, ymm0, ymm7
+    vpaddw      ymm7, ymm1, ymm7
+
+    ; (Original)
+    ; R = Y                + 1.40200 * Cr
+    ; G = Y - 0.34414 * Cb - 0.71414 * Cr
+    ; B = Y + 1.77200 * Cb
+    ;
+    ; (This implementation)
+    ; R = Y                + 0.40200 * Cr + Cr
+    ; G = Y - 0.34414 * Cb + 0.28586 * Cr - Cr
+    ; B = Y - 0.22800 * Cb + Cb + Cb
+
+    vpaddw      ymm4, ymm2, ymm2                     ; ymm4=2*CbE
+    vpaddw      ymm5, ymm3, ymm3                     ; ymm5=2*CbO
+    vpaddw      ymm0, ymm6, ymm6                     ; ymm0=2*CrE
+    vpaddw      ymm1, ymm7, ymm7                     ; ymm1=2*CrO
+
+    vpmulhw     ymm4, ymm4, [GOTOFF(eax,PW_MF0228)]  ; ymm4=(2*CbE * -FIX(0.22800))
+    vpmulhw     ymm5, ymm5, [GOTOFF(eax,PW_MF0228)]  ; ymm5=(2*CbO * -FIX(0.22800))
+    vpmulhw     ymm0, ymm0, [GOTOFF(eax,PW_F0402)]   ; ymm0=(2*CrE * FIX(0.40200))
+    vpmulhw     ymm1, ymm1, [GOTOFF(eax,PW_F0402)]   ; ymm1=(2*CrO * FIX(0.40200))
+
+    vpaddw      ymm4, ymm4, [GOTOFF(eax,PW_ONE)]
+    vpaddw      ymm5, ymm5, [GOTOFF(eax,PW_ONE)]
+    vpsraw      ymm4, ymm4, 1                        ; ymm4=(CbE * -FIX(0.22800))
+    vpsraw      ymm5, ymm5, 1                        ; ymm5=(CbO * -FIX(0.22800))
+    vpaddw      ymm0, ymm0, [GOTOFF(eax,PW_ONE)]
+    vpaddw      ymm1, ymm1, [GOTOFF(eax,PW_ONE)]
+    vpsraw      ymm0, ymm0, 1                        ; ymm0=(CrE * FIX(0.40200))
+    vpsraw      ymm1, ymm1, 1                        ; ymm1=(CrO * FIX(0.40200))
+
+    vpaddw      ymm4, ymm4, ymm2
+    vpaddw      ymm5, ymm5, ymm3
+    vpaddw      ymm4, ymm4, ymm2                     ; ymm4=(CbE * FIX(1.77200))=(B-Y)E
+    vpaddw      ymm5, ymm5, ymm3                     ; ymm5=(CbO * FIX(1.77200))=(B-Y)O
+    vpaddw      ymm0, ymm0, ymm6                     ; ymm0=(CrE * FIX(1.40200))=(R-Y)E
+    vpaddw      ymm1, ymm1, ymm7                     ; ymm1=(CrO * FIX(1.40200))=(R-Y)O
+
+    vmovdqa     YMMWORD [wk(0)], ymm4                ; wk(0)=(B-Y)E
+    vmovdqa     YMMWORD [wk(1)], ymm5                ; wk(1)=(B-Y)O
+
+    vpunpckhwd  ymm4, ymm2, ymm6
+    vpunpcklwd  ymm2, ymm2, ymm6
+    vpmaddwd    ymm2, ymm2, [GOTOFF(eax,PW_MF0344_F0285)]
+    vpmaddwd    ymm4, ymm4, [GOTOFF(eax,PW_MF0344_F0285)]
+    vpunpckhwd  ymm5, ymm3, ymm7
+    vpunpcklwd  ymm3, ymm3, ymm7
+    vpmaddwd    ymm3, ymm3, [GOTOFF(eax,PW_MF0344_F0285)]
+    vpmaddwd    ymm5, ymm5, [GOTOFF(eax,PW_MF0344_F0285)]
+
+    vpaddd      ymm2, ymm2, [GOTOFF(eax,PD_ONEHALF)]
+    vpaddd      ymm4, ymm4, [GOTOFF(eax,PD_ONEHALF)]
+    vpsrad      ymm2, ymm2, SCALEBITS
+    vpsrad      ymm4, ymm4, SCALEBITS
+    vpaddd      ymm3, ymm3, [GOTOFF(eax,PD_ONEHALF)]
+    vpaddd      ymm5, ymm5, [GOTOFF(eax,PD_ONEHALF)]
+    vpsrad      ymm3, ymm3, SCALEBITS
+    vpsrad      ymm5, ymm5, SCALEBITS
+
+    vpackssdw   ymm2, ymm2, ymm4             ; ymm2=CbE*-FIX(0.344)+CrE*FIX(0.285)
+    vpackssdw   ymm3, ymm3, ymm5             ; ymm3=CbO*-FIX(0.344)+CrO*FIX(0.285)
+    vpsubw      ymm2, ymm2, ymm6             ; ymm2=CbE*-FIX(0.344)+CrE*-FIX(0.714)=(G-Y)E
+    vpsubw      ymm3, ymm3, ymm7             ; ymm3=CbO*-FIX(0.344)+CrO*-FIX(0.714)=(G-Y)O
+
+    vmovdqu     ymm5, YMMWORD [esi]          ; ymm5=Y(0123456789ABCDEFGHIJKLMNOPQRSTUV)
+
+    vpcmpeqw    ymm4, ymm4, ymm4
+    vpsrlw      ymm4, ymm4, BYTE_BIT         ; ymm4={0xFF 0x00 0xFF 0x00 ..}
+    vpand       ymm4, ymm4, ymm5             ; ymm4=Y(02468ACEGIKMOQSU)=YE
+    vpsrlw      ymm5, ymm5, BYTE_BIT         ; ymm5=Y(13579BDFHJLNPRTV)=YO
+
+    vpaddw      ymm0, ymm0, ymm4             ; ymm0=((R-Y)E+YE)=RE=R(02468ACEGIKMOQSU)
+    vpaddw      ymm1, ymm1, ymm5             ; ymm1=((R-Y)O+YO)=RO=R(13579BDFHJLNPRTV)
+    vpackuswb   ymm0, ymm0, ymm0             ; ymm0=R(02468ACE********GIKMOQSU********)
+    vpackuswb   ymm1, ymm1, ymm1             ; ymm1=R(13579BDF********HJLNPRTV********)
+
+    vpaddw      ymm2, ymm2, ymm4             ; ymm2=((G-Y)E+YE)=GE=G(02468ACEGIKMOQSU)
+    vpaddw      ymm3, ymm3, ymm5             ; ymm3=((G-Y)O+YO)=GO=G(13579BDFHJLNPRTV)
+    vpackuswb   ymm2, ymm2, ymm2             ; ymm2=G(02468ACE********GIKMOQSU********)
+    vpackuswb   ymm3, ymm3, ymm3             ; ymm3=G(13579BDF********HJLNPRTV********)
+
+    vpaddw      ymm4, ymm4, YMMWORD [wk(0)]  ; ymm4=(YE+(B-Y)E)=BE=B(02468ACEGIKMOQSU)
+    vpaddw      ymm5, ymm5, YMMWORD [wk(1)]  ; ymm5=(YO+(B-Y)O)=BO=B(13579BDFHJLNPRTV)
+    vpackuswb   ymm4, ymm4, ymm4             ; ymm4=B(02468ACE********GIKMOQSU********)
+    vpackuswb   ymm5, ymm5, ymm5             ; ymm5=B(13579BDF********HJLNPRTV********)
+
+%if RGB_PIXELSIZE == 3  ; ---------------
+
+    ; ymmA=(00 02 04 06 08 0A 0C 0E ** 0G 0I 0K 0M 0O 0Q 0S 0U **)
+    ; ymmB=(01 03 05 07 09 0B 0D 0F ** 0H 0J 0L 0N 0P 0R 0T 0V **)
+    ; ymmC=(10 12 14 16 18 1A 1C 1E ** 1G 1I 1K 1M 1O 1Q 1S 1U **)
+    ; ymmD=(11 13 15 17 19 1B 1D 1F ** 1H 1J 1L 1N 1P 1R 1T 1V **)
+    ; ymmE=(20 22 24 26 28 2A 2C 2E ** 2G 2I 2K 2M 2O 2Q 2S 2U **)
+    ; ymmF=(21 23 25 27 29 2B 2D 2F ** 2H 2J 2L 2N 2P 2R 2T 2V **)
+    ; ymmG=(** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** **)
+    ; ymmH=(** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** **)
+
+    vpunpcklbw  ymmA, ymmA, ymmC        ; ymmA=(00 10 02 12 04 14 06 16 08 18 0A 1A 0C 1C 0E 1E
+                                        ;       0G 1G 0I 1I 0K 1K 0M 1M 0O 1O 0Q 1Q 0S 1S 0U 1U)
+    vpunpcklbw  ymmE, ymmE, ymmB        ; ymmE=(20 01 22 03 24 05 26 07 28 09 2A 0B 2C 0D 2E 0F
+                                        ;       2G 0H 2I 0J 2K 0L 2M 0N 2O 0P 2Q 0R 2S 0T 2U 0V)
+    vpunpcklbw  ymmD, ymmD, ymmF        ; ymmD=(11 21 13 23 15 25 17 27 19 29 1B 2B 1D 2D 1F 2F
+                                        ;       1H 2H 1J 2J 1L 2L 1N 2N 1P 2P 1R 2R 1T 2T 1V 2V)
+
+    vpsrldq     ymmH, ymmA, 2           ; ymmH=(02 12 04 14 06 16 08 18 0A 1A 0C 1C 0E 1E 0G 1G
+                                        ;       0I 1I 0K 1K 0M 1M 0O 1O 0Q 1Q 0S 1S 0U 1U -- --)
+    vpunpckhwd  ymmG, ymmA, ymmE        ; ymmG=(08 18 28 09 0A 1A 2A 0B 0C 1C 2C 0D 0E 1E 2E 0F
+                                        ;       0O 1O 2O 0P 0Q 1Q 2Q 0R 0S 1S 2S 0T 0U 1U 2U 0V)
+    vpunpcklwd  ymmA, ymmA, ymmE        ; ymmA=(00 10 20 01 02 12 22 03 04 14 24 05 06 16 26 07
+                                        ;       0G 1G 2G 0H 0I 1I 2I 0J 0K 1K 2K 0L 0M 1M 2M 0N)
+
+    vpsrldq     ymmE, ymmE, 2           ; ymmE=(22 03 24 05 26 07 28 09 2A 0B 2C 0D 2E 0F 2G 0H
+                                        ;       2I 0J 2K 0L 2M 0N 2O 0P 2Q 0R 2S 0T 2U 0V -- --)
+
+    vpsrldq     ymmB, ymmD, 2           ; ymmB=(13 23 15 25 17 27 19 29 1B 2B 1D 2D 1F 2F 1H 2H
+                                        ;       1J 2J 1L 2L 1N 2N 1P 2P 1R 2R 1T 2T 1V 2V -- --)
+    vpunpckhwd  ymmC, ymmD, ymmH        ; ymmC=(19 29 0A 1A 1B 2B 0C 1C 1D 2D 0E 1E 1F 2F 0G 1G
+                                        ;       1P 2P 0Q 1Q 1R 2R 0S 1S 1T 2T 0U 1U 1V 2V -- --)
+    vpunpcklwd  ymmD, ymmD, ymmH        ; ymmD=(11 21 02 12 13 23 04 14 15 25 06 16 17 27 08 18
+                                        ;       1H 2H 0I 1I 1J 2J 0K 1K 1L 2L 0M 1M 1N 2N 0O 1O)
+
+    vpunpckhwd  ymmF, ymmE, ymmB        ; ymmF=(2A 0B 1B 2B 2C 0D 1D 2D 2E 0F 1F 2F 2G 0H 1H 2H
+                                        ;       2Q 0R 1R 2R 2S 0T 1T 2T 2U 0V 1V 2V -- -- -- --)
+    vpunpcklwd  ymmE, ymmE, ymmB        ; ymmE=(22 03 13 23 24 05 15 25 26 07 17 27 28 09 19 29
+                                        ;       2I 0J 1J 2J 2K 0L 1L 2L 2M 0N 1N 2N 2O 0P 1P 2P)
+
+    vpshufd     ymmH, ymmA, 0x4E        ; ymmH=(04 14 24 05 06 16 26 07 00 10 20 01 02 12 22 03
+                                        ;       0K 1K 2K 0L 0M 1M 2M 0N 0G 1G 2G 0H 0I 1I 2I 0J)
+    vpunpckldq  ymmA, ymmA, ymmD        ; ymmA=(00 10 20 01 11 21 02 12 02 12 22 03 13 23 04 14
+                                        ;       0G 1G 2G 0H 1H 2H 0I 1I 0I 1I 2I 0J 1J 2J 0K 1K)
+    vpunpckhdq  ymmD, ymmD, ymmE        ; ymmD=(15 25 06 16 26 07 17 27 17 27 08 18 28 09 19 29
+                                        ;       1L 2L 0M 1M 2M 0N 1N 2N 1N 2N 0O 1O 2O 0P 1P 2P)
+    vpunpckldq  ymmE, ymmE, ymmH        ; ymmE=(22 03 13 23 04 14 24 05 24 05 15 25 06 16 26 07
+                                        ;       2I 0J 1J 2J 0K 1K 2K 0L 2K 0L 1L 2L 0M 1M 2M 0N)
+
+    vpshufd     ymmH, ymmG, 0x4E        ; ymmH=(0C 1C 2C 0D 0E 1E 2E 0F 08 18 28 09 0A 1A 2A 0B
+                                        ;       0S 1S 2S 0T 0U 1U 2U 0V 0O 1O 2O 0P 0Q 1Q 2Q 0R)
+    vpunpckldq  ymmG, ymmG, ymmC        ; ymmG=(08 18 28 09 19 29 0A 1A 0A 1A 2A 0B 1B 2B 0C 1C
+                                        ;       0O 1O 2O 0P 1P 2P 0Q 1Q 0Q 1Q 2Q 0R 1R 2R 0S 1S)
+    vpunpckhdq  ymmC, ymmC, ymmF        ; ymmC=(1D 2D 0E 1E 2E 0F 1F 2F 1F 2F 0G 1G 2G 0H 1H 2H
+                                        ;       1T 2T 0U 1U 2U 0V 1V 2V 1V 2V -- -- -- -- -- --)
+    vpunpckldq  ymmF, ymmF, ymmH        ; ymmF=(2A 0B 1B 2B 0C 1C 2C 0D 2C 0D 1D 2D 0E 1E 2E 0F
+                                        ;       2Q 0R 1R 2R 0S 1S 2S 0T 2S 0T 1T 2T 0U 1U 2U 0V)
+
+    vpunpcklqdq ymmH, ymmA, ymmE        ; ymmH=(00 10 20 01 11 21 02 12 22 03 13 23 04 14 24 05
+                                        ;       0G 1G 2G 0H 1H 2H 0I 1I 2I 0J 1J 2J 0K 1K 2K 0L)
+    vpunpcklqdq ymmG, ymmD, ymmG        ; ymmG=(15 25 06 16 26 07 17 27 08 18 28 09 19 29 0A 1A
+                                        ;       1L 2L 0M 1M 2M 0N 1N 2N 0O 1O 2O 0P 1P 2P 0Q 1Q)
+    vpunpcklqdq ymmC, ymmF, ymmC        ; ymmC=(2A 0B 1B 2B 0C 1C 2C 0D 1D 2D 0E 1E 2E 0F 1F 2F
+                                        ;       2Q 0R 1R 2R 0S 1S 2S 0T 1T 2T 0U 1U 2U 0V 1V 2V)
+
+    vperm2i128  ymmA, ymmH, ymmG, 0x20  ; ymmA=(00 10 20 01 11 21 02 12 22 03 13 23 04 14 24 05
+                                        ;       15 25 06 16 26 07 17 27 08 18 28 09 19 29 0A 1A)
+    vperm2i128  ymmD, ymmC, ymmH, 0x30  ; ymmD=(2A 0B 1B 2B 0C 1C 2C 0D 1D 2D 0E 1E 2E 0F 1F 2F
+                                        ;       0G 1G 2G 0H 1H 2H 0I 1I 2I 0J 1J 2J 0K 1K 2K 0L)
+    vperm2i128  ymmF, ymmG, ymmC, 0x31  ; ymmF=(1L 2L 0M 1M 2M 0N 1N 2N 0O 1O 2O 0P 1P 2P 0Q 1Q
+                                        ;       2Q 0R 1R 2R 0S 1S 2S 0T 1T 2T 0U 1U 2U 0V 1V 2V)
+
+    cmp         ecx, byte SIZEOF_YMMWORD
+    jb          short .column_st64
+
+    test        edi, SIZEOF_YMMWORD-1
+    jnz         short .out1
+    ; --(aligned)-------------------
+    vmovntdq    YMMWORD [edi+0*SIZEOF_YMMWORD], ymmA
+    vmovntdq    YMMWORD [edi+1*SIZEOF_YMMWORD], ymmD
+    vmovntdq    YMMWORD [edi+2*SIZEOF_YMMWORD], ymmF
+    jmp         short .out0
+.out1:  ; --(unaligned)-----------------
+    vmovdqu     YMMWORD [edi+0*SIZEOF_YMMWORD], ymmA
+    vmovdqu     YMMWORD [edi+1*SIZEOF_YMMWORD], ymmD
+    vmovdqu     YMMWORD [edi+2*SIZEOF_YMMWORD], ymmF
+.out0:
+    add         edi, byte RGB_PIXELSIZE*SIZEOF_YMMWORD  ; outptr
+    sub         ecx, byte SIZEOF_YMMWORD
+    jz          near .nextrow
+
+    add         esi, byte SIZEOF_YMMWORD  ; inptr0
+    add         ebx, byte SIZEOF_YMMWORD  ; inptr1
+    add         edx, byte SIZEOF_YMMWORD  ; inptr2
+    jmp         near .columnloop
+    alignx      16, 7
+
+.column_st64:
+    lea         ecx, [ecx+ecx*2]            ; imul ecx, RGB_PIXELSIZE
+    cmp         ecx, byte 2*SIZEOF_YMMWORD
+    jb          short .column_st32
+    vmovdqu     YMMWORD [edi+0*SIZEOF_YMMWORD], ymmA
+    vmovdqu     YMMWORD [edi+1*SIZEOF_YMMWORD], ymmD
+    add         edi, byte 2*SIZEOF_YMMWORD  ; outptr
+    vmovdqa     ymmA, ymmF
+    sub         ecx, byte 2*SIZEOF_YMMWORD
+    jmp         short .column_st31
+.column_st32:
+    cmp         ecx, byte SIZEOF_YMMWORD
+    jb          short .column_st31
+    vmovdqu     YMMWORD [edi+0*SIZEOF_YMMWORD], ymmA
+    add         edi, byte SIZEOF_YMMWORD    ; outptr
+    vmovdqa     ymmA, ymmD
+    sub         ecx, byte SIZEOF_YMMWORD
+    jmp         short .column_st31
+.column_st31:
+    cmp         ecx, byte SIZEOF_XMMWORD
+    jb          short .column_st15
+    vmovdqu     XMMWORD [edi+0*SIZEOF_XMMWORD], xmmA
+    add         edi, byte SIZEOF_XMMWORD    ; outptr
+    vperm2i128  ymmA, ymmA, ymmA, 1
+    sub         ecx, byte SIZEOF_XMMWORD
+.column_st15:
+    ; Store the lower 8 bytes of xmmA to the output when it has enough
+    ; space.
+    cmp         ecx, byte SIZEOF_MMWORD
+    jb          short .column_st7
+    vmovq       XMM_MMWORD [edi], xmmA
+    add         edi, byte SIZEOF_MMWORD
+    sub         ecx, byte SIZEOF_MMWORD
+    vpsrldq     xmmA, xmmA, SIZEOF_MMWORD
+.column_st7:
+    ; Store the lower 4 bytes of xmmA to the output when it has enough
+    ; space.
+    cmp         ecx, byte SIZEOF_DWORD
+    jb          short .column_st3
+    vmovd       XMM_DWORD [edi], xmmA
+    add         edi, byte SIZEOF_DWORD
+    sub         ecx, byte SIZEOF_DWORD
+    vpsrldq     xmmA, xmmA, SIZEOF_DWORD
+.column_st3:
+    ; Store the lower 2 bytes of eax to the output when it has enough
+    ; space.
+    vmovd       eax, xmmA
+    cmp         ecx, byte SIZEOF_WORD
+    jb          short .column_st1
+    mov         word [edi], ax
+    add         edi, byte SIZEOF_WORD
+    sub         ecx, byte SIZEOF_WORD
+    shr         eax, 16
+.column_st1:
+    ; Store the lower 1 byte of eax to the output when it has enough
+    ; space.
+    test        ecx, ecx
+    jz          short .nextrow
+    mov         byte [edi], al
+
+%else  ; RGB_PIXELSIZE == 4 ; -----------
+
+%ifdef RGBX_FILLER_0XFF
+    vpcmpeqb    ymm6, ymm6, ymm6        ; ymm6=XE=X(02468ACE********GIKMOQSU********)
+    vpcmpeqb    ymm7, ymm7, ymm7        ; ymm7=XO=X(13579BDF********HJLNPRTV********)
+%else
+    vpxor       ymm6, ymm6, ymm6        ; ymm6=XE=X(02468ACE********GIKMOQSU********)
+    vpxor       ymm7, ymm7, ymm7        ; ymm7=XO=X(13579BDF********HJLNPRTV********)
+%endif
+    ; ymmA=(00 02 04 06 08 0A 0C 0E ** 0G 0I 0K 0M 0O 0Q 0S 0U **)
+    ; ymmB=(01 03 05 07 09 0B 0D 0F ** 0H 0J 0L 0N 0P 0R 0T 0V **)
+    ; ymmC=(10 12 14 16 18 1A 1C 1E ** 1G 1I 1K 1M 1O 1Q 1S 1U **)
+    ; ymmD=(11 13 15 17 19 1B 1D 1F ** 1H 1J 1L 1N 1P 1R 1T 1V **)
+    ; ymmE=(20 22 24 26 28 2A 2C 2E ** 2G 2I 2K 2M 2O 2Q 2S 2U **)
+    ; ymmF=(21 23 25 27 29 2B 2D 2F ** 2H 2J 2L 2N 2P 2R 2T 2V **)
+    ; ymmG=(30 32 34 36 38 3A 3C 3E ** 3G 3I 3K 3M 3O 3Q 3S 3U **)
+    ; ymmH=(31 33 35 37 39 3B 3D 3F ** 3H 3J 3L 3N 3P 3R 3T 3V **)
+
+    vpunpcklbw  ymmA, ymmA, ymmC        ; ymmA=(00 10 02 12 04 14 06 16 08 18 0A 1A 0C 1C 0E 1E
+                                        ;       0G 1G 0I 1I 0K 1K 0M 1M 0O 1O 0Q 1Q 0S 1S 0U 1U)
+    vpunpcklbw  ymmE, ymmE, ymmG        ; ymmE=(20 30 22 32 24 34 26 36 28 38 2A 3A 2C 3C 2E 3E
+                                        ;       2G 3G 2I 3I 2K 3K 2M 3M 2O 3O 2Q 3Q 2S 3S 2U 3U)
+    vpunpcklbw  ymmB, ymmB, ymmD        ; ymmB=(01 11 03 13 05 15 07 17 09 19 0B 1B 0D 1D 0F 1F
+                                        ;       0H 1H 0J 1J 0L 1L 0N 1N 0P 1P 0R 1R 0T 1T 0V 1V)
+    vpunpcklbw  ymmF, ymmF, ymmH        ; ymmF=(21 31 23 33 25 35 27 37 29 39 2B 3B 2D 3D 2F 3F
+                                        ;       2H 3H 2J 3J 2L 3L 2N 3N 2P 3P 2R 3R 2T 3T 2V 3V)
+
+    vpunpckhwd  ymmC, ymmA, ymmE        ; ymmC=(08 18 28 38 0A 1A 2A 3A 0C 1C 2C 3C 0E 1E 2E 3E
+                                        ;       0O 1O 2O 3O 0Q 1Q 2Q 3Q 0S 1S 2S 3S 0U 1U 2U 3U)
+    vpunpcklwd  ymmA, ymmA, ymmE        ; ymmA=(00 10 20 30 02 12 22 32 04 14 24 34 06 16 26 36
+                                        ;       0G 1G 2G 3G 0I 1I 2I 3I 0K 1K 2K 3K 0M 1M 2M 3M)
+    vpunpckhwd  ymmG, ymmB, ymmF        ; ymmG=(09 19 29 39 0B 1B 2B 3B 0D 1D 2D 3D 0F 1F 2F 3F
+                                        ;       0P 1P 2P 3P 0R 1R 2R 3R 0T 1T 2T 3T 0V 1V 2V 3V)
+    vpunpcklwd  ymmB, ymmB, ymmF        ; ymmB=(01 11 21 31 03 13 23 33 05 15 25 35 07 17 27 37
+                                        ;       0H 1H 2H 3H 0J 1J 2J 3J 0L 1L 2L 3L 0N 1N 2N 3N)
+
+    vpunpckhdq  ymmE, ymmA, ymmB        ; ymmE=(04 14 24 34 05 15 25 35 06 16 26 36 07 17 27 37
+                                        ;       0K 1K 2K 3K 0L 1L 2L 3L 0M 1M 2M 3M 0N 1N 2N 3N)
+    vpunpckldq  ymmB, ymmA, ymmB        ; ymmB=(00 10 20 30 01 11 21 31 02 12 22 32 03 13 23 33
+                                        ;       0G 1G 2G 3G 0H 1H 2H 3H 0I 1I 2I 3I 0J 1J 2J 3J)
+    vpunpckhdq  ymmF, ymmC, ymmG        ; ymmF=(0C 1C 2C 3C 0D 1D 2D 3D 0E 1E 2E 3E 0F 1F 2F 3F
+                                        ;       0S 1S 2S 3S 0T 1T 2T 3T 0U 1U 2U 3U 0V 1V 2V 3V)
+    vpunpckldq  ymmG, ymmC, ymmG        ; ymmG=(08 18 28 38 09 19 29 39 0A 1A 2A 3A 0B 1B 2B 3B
+                                        ;       0O 1O 2O 3O 0P 1P 2P 3P 0Q 1Q 2Q 3Q 0R 1R 2R 3R)
+
+    vperm2i128  ymmA, ymmB, ymmE, 0x20  ; ymmA=(00 10 20 30 01 11 21 31 02 12 22 32 03 13 23 33
+                                        ;       04 14 24 34 05 15 25 35 06 16 26 36 07 17 27 37)
+    vperm2i128  ymmD, ymmG, ymmF, 0x20  ; ymmD=(08 18 28 38 09 19 29 39 0A 1A 2A 3A 0B 1B 2B 3B
+                                        ;       0C 1C 2C 3C 0D 1D 2D 3D 0E 1E 2E 3E 0F 1F 2F 3F)
+    vperm2i128  ymmC, ymmB, ymmE, 0x31  ; ymmC=(0G 1G 2G 3G 0H 1H 2H 3H 0I 1I 2I 3I 0J 1J 2J 3J
+                                        ;       0K 1K 2K 3K 0L 1L 2L 3L 0M 1M 2M 3M 0N 1N 2N 3N)
+    vperm2i128  ymmH, ymmG, ymmF, 0x31  ; ymmH=(0O 1O 2O 3O 0P 1P 2P 3P 0Q 1Q 2Q 3Q 0R 1R 2R 3R
+                                        ;       0S 1S 2S 3S 0T 1T 2T 3T 0U 1U 2U 3U 0V 1V 2V 3V)
+
+    cmp         ecx, byte SIZEOF_YMMWORD
+    jb          short .column_st64
+
+    test        edi, SIZEOF_YMMWORD-1
+    jnz         short .out1
+    ; --(aligned)-------------------
+    vmovntdq    YMMWORD [edi+0*SIZEOF_YMMWORD], ymmA
+    vmovntdq    YMMWORD [edi+1*SIZEOF_YMMWORD], ymmD
+    vmovntdq    YMMWORD [edi+2*SIZEOF_YMMWORD], ymmC
+    vmovntdq    YMMWORD [edi+3*SIZEOF_YMMWORD], ymmH
+    jmp         short .out0
+.out1:  ; --(unaligned)-----------------
+    vmovdqu     YMMWORD [edi+0*SIZEOF_YMMWORD], ymmA
+    vmovdqu     YMMWORD [edi+1*SIZEOF_YMMWORD], ymmD
+    vmovdqu     YMMWORD [edi+2*SIZEOF_YMMWORD], ymmC
+    vmovdqu     YMMWORD [edi+3*SIZEOF_YMMWORD], ymmH
+.out0:
+    add         edi, RGB_PIXELSIZE*SIZEOF_YMMWORD  ; outptr
+    sub         ecx, byte SIZEOF_YMMWORD
+    jz          near .nextrow
+
+    add         esi, byte SIZEOF_YMMWORD  ; inptr0
+    add         ebx, byte SIZEOF_YMMWORD  ; inptr1
+    add         edx, byte SIZEOF_YMMWORD  ; inptr2
+    jmp         near .columnloop
+    alignx      16, 7
+
+.column_st64:
+    cmp         ecx, byte SIZEOF_YMMWORD/2
+    jb          short .column_st32
+    vmovdqu     YMMWORD [edi+0*SIZEOF_YMMWORD], ymmA
+    vmovdqu     YMMWORD [edi+1*SIZEOF_YMMWORD], ymmD
+    add         edi, byte 2*SIZEOF_YMMWORD  ; outptr
+    vmovdqa     ymmA, ymmC
+    vmovdqa     ymmD, ymmH
+    sub         ecx, byte SIZEOF_YMMWORD/2
+.column_st32:
+    cmp         ecx, byte SIZEOF_YMMWORD/4
+    jb          short .column_st16
+    vmovdqu     YMMWORD [edi+0*SIZEOF_YMMWORD], ymmA
+    add         edi, byte SIZEOF_YMMWORD    ; outptr
+    vmovdqa     ymmA, ymmD
+    sub         ecx, byte SIZEOF_YMMWORD/4
+.column_st16:
+    cmp         ecx, byte SIZEOF_YMMWORD/8
+    jb          short .column_st15
+    vmovdqu     XMMWORD [edi+0*SIZEOF_XMMWORD], xmmA
+    vperm2i128  ymmA, ymmA, ymmA, 1
+    add         edi, byte SIZEOF_XMMWORD    ; outptr
+    sub         ecx, byte SIZEOF_YMMWORD/8
+.column_st15:
+    ; Store two pixels (8 bytes) of ymmA to the output when it has enough
+    ; space.
+    cmp         ecx, byte SIZEOF_YMMWORD/16
+    jb          short .column_st7
+    vmovq       MMWORD [edi], xmmA
+    add         edi, byte SIZEOF_YMMWORD/16*4
+    sub         ecx, byte SIZEOF_YMMWORD/16
+    vpsrldq     xmmA, SIZEOF_YMMWORD/16*4
+.column_st7:
+    ; Store one pixel (4 bytes) of ymmA to the output when it has enough
+    ; space.
+    test        ecx, ecx
+    jz          short .nextrow
+    vmovd       XMM_DWORD [edi], xmmA
+
+%endif  ; RGB_PIXELSIZE ; ---------------
+
+    alignx      16, 7
+
+.nextrow:
+    pop         ecx
+    pop         esi
+    pop         ebx
+    pop         edx
+    pop         edi
+    pop         eax
+
+    add         esi, byte SIZEOF_JSAMPROW
+    add         ebx, byte SIZEOF_JSAMPROW
+    add         edx, byte SIZEOF_JSAMPROW
+    add         edi, byte SIZEOF_JSAMPROW  ; output_buf
+    dec         eax                        ; num_rows
+    jg          near .rowloop
+
+    sfence                              ; flush the write buffer
+
+.return:
+    vzeroupper
+    pop         edi
+    pop         esi
+;   pop         edx                     ; need not be preserved
+;   pop         ecx                     ; need not be preserved
+    pop         ebx
+    mov         esp, ebp                ; esp <- aligned ebp
+    pop         esp                     ; esp <- original ebp
+    pop         ebp
+    ret
+
+; For some reason, the OS X linker does not honor the request to align the
+; segment unless we do this.
+    align       32
diff --git a/3rdparty/libjpeg/src/simd/i386/jdcolext-mmx.asm b/3rdparty/libjpeg/src/simd/i386/jdcolext-mmx.asm
new file mode 100644
index 00000000..5813cfcb
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/i386/jdcolext-mmx.asm
@@ -0,0 +1,404 @@
+;
+; jdcolext.asm - colorspace conversion (MMX)
+;
+; Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+; Copyright (C) 2016, D. R. Commander.
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+;
+; This file should be assembled with NASM (Netwide Assembler),
+; can *not* be assembled with Microsoft's MASM or any compatible
+; assembler (including Borland's Turbo Assembler).
+; NASM is available from http://nasm.sourceforge.net/ or
+; http://sourceforge.net/project/showfiles.php?group_id=6208
+
+%include "jcolsamp.inc"
+
+; --------------------------------------------------------------------------
+;
+; Convert some rows of samples to the output colorspace.
+;
+; GLOBAL(void)
+; jsimd_ycc_rgb_convert_mmx(JDIMENSION out_width, JSAMPIMAGE input_buf,
+;                           JDIMENSION input_row, JSAMPARRAY output_buf,
+;                           int num_rows)
+;
+
+%define out_width(b)   (b) + 8          ; JDIMENSION out_width
+%define input_buf(b)   (b) + 12         ; JSAMPIMAGE input_buf
+%define input_row(b)   (b) + 16         ; JDIMENSION input_row
+%define output_buf(b)  (b) + 20         ; JSAMPARRAY output_buf
+%define num_rows(b)    (b) + 24         ; int num_rows
+
+%define original_ebp   ebp + 0
+%define wk(i)          ebp - (WK_NUM - (i)) * SIZEOF_MMWORD
+                                        ; mmword wk[WK_NUM]
+%define WK_NUM         2
+%define gotptr         wk(0) - SIZEOF_POINTER  ; void * gotptr
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_ycc_rgb_convert_mmx)
+
+EXTN(jsimd_ycc_rgb_convert_mmx):
+    push        ebp
+    mov         eax, esp                    ; eax = original ebp
+    sub         esp, byte 4
+    and         esp, byte (-SIZEOF_MMWORD)  ; align to 64 bits
+    mov         [esp], eax
+    mov         ebp, esp                    ; ebp = aligned ebp
+    lea         esp, [wk(0)]
+    pushpic     eax                     ; make a room for GOT address
+    push        ebx
+;   push        ecx                     ; need not be preserved
+;   push        edx                     ; need not be preserved
+    push        esi
+    push        edi
+
+    get_GOT     ebx                     ; get GOT address
+    movpic      POINTER [gotptr], ebx   ; save GOT address
+
+    mov         ecx, JDIMENSION [out_width(eax)]  ; num_cols
+    test        ecx, ecx
+    jz          near .return
+
+    push        ecx
+
+    mov         edi, JSAMPIMAGE [input_buf(eax)]
+    mov         ecx, JDIMENSION [input_row(eax)]
+    mov         esi, JSAMPARRAY [edi+0*SIZEOF_JSAMPARRAY]
+    mov         ebx, JSAMPARRAY [edi+1*SIZEOF_JSAMPARRAY]
+    mov         edx, JSAMPARRAY [edi+2*SIZEOF_JSAMPARRAY]
+    lea         esi, [esi+ecx*SIZEOF_JSAMPROW]
+    lea         ebx, [ebx+ecx*SIZEOF_JSAMPROW]
+    lea         edx, [edx+ecx*SIZEOF_JSAMPROW]
+
+    pop         ecx
+
+    mov         edi, JSAMPARRAY [output_buf(eax)]
+    mov         eax, INT [num_rows(eax)]
+    test        eax, eax
+    jle         near .return
+    alignx      16, 7
+.rowloop:
+    push        eax
+    push        edi
+    push        edx
+    push        ebx
+    push        esi
+    push        ecx                     ; col
+
+    mov         esi, JSAMPROW [esi]     ; inptr0
+    mov         ebx, JSAMPROW [ebx]     ; inptr1
+    mov         edx, JSAMPROW [edx]     ; inptr2
+    mov         edi, JSAMPROW [edi]     ; outptr
+    movpic      eax, POINTER [gotptr]   ; load GOT address (eax)
+    alignx      16, 7
+.columnloop:
+
+    movq        mm5, MMWORD [ebx]       ; mm5=Cb(01234567)
+    movq        mm1, MMWORD [edx]       ; mm1=Cr(01234567)
+
+    pcmpeqw     mm4, mm4
+    pcmpeqw     mm7, mm7
+    psrlw       mm4, BYTE_BIT
+    psllw       mm7, 7                  ; mm7={0xFF80 0xFF80 0xFF80 0xFF80}
+    movq        mm0, mm4                ; mm0=mm4={0xFF 0x00 0xFF 0x00 ..}
+
+    pand        mm4, mm5                ; mm4=Cb(0246)=CbE
+    psrlw       mm5, BYTE_BIT           ; mm5=Cb(1357)=CbO
+    pand        mm0, mm1                ; mm0=Cr(0246)=CrE
+    psrlw       mm1, BYTE_BIT           ; mm1=Cr(1357)=CrO
+
+    paddw       mm4, mm7
+    paddw       mm5, mm7
+    paddw       mm0, mm7
+    paddw       mm1, mm7
+
+    ; (Original)
+    ; R = Y                + 1.40200 * Cr
+    ; G = Y - 0.34414 * Cb - 0.71414 * Cr
+    ; B = Y + 1.77200 * Cb
+    ;
+    ; (This implementation)
+    ; R = Y                + 0.40200 * Cr + Cr
+    ; G = Y - 0.34414 * Cb + 0.28586 * Cr - Cr
+    ; B = Y - 0.22800 * Cb + Cb + Cb
+
+    movq        mm2, mm4                ; mm2=CbE
+    movq        mm3, mm5                ; mm3=CbO
+    paddw       mm4, mm4                ; mm4=2*CbE
+    paddw       mm5, mm5                ; mm5=2*CbO
+    movq        mm6, mm0                ; mm6=CrE
+    movq        mm7, mm1                ; mm7=CrO
+    paddw       mm0, mm0                ; mm0=2*CrE
+    paddw       mm1, mm1                ; mm1=2*CrO
+
+    pmulhw      mm4, [GOTOFF(eax,PW_MF0228)]  ; mm4=(2*CbE * -FIX(0.22800))
+    pmulhw      mm5, [GOTOFF(eax,PW_MF0228)]  ; mm5=(2*CbO * -FIX(0.22800))
+    pmulhw      mm0, [GOTOFF(eax,PW_F0402)]   ; mm0=(2*CrE * FIX(0.40200))
+    pmulhw      mm1, [GOTOFF(eax,PW_F0402)]   ; mm1=(2*CrO * FIX(0.40200))
+
+    paddw       mm4, [GOTOFF(eax,PW_ONE)]
+    paddw       mm5, [GOTOFF(eax,PW_ONE)]
+    psraw       mm4, 1                  ; mm4=(CbE * -FIX(0.22800))
+    psraw       mm5, 1                  ; mm5=(CbO * -FIX(0.22800))
+    paddw       mm0, [GOTOFF(eax,PW_ONE)]
+    paddw       mm1, [GOTOFF(eax,PW_ONE)]
+    psraw       mm0, 1                  ; mm0=(CrE * FIX(0.40200))
+    psraw       mm1, 1                  ; mm1=(CrO * FIX(0.40200))
+
+    paddw       mm4, mm2
+    paddw       mm5, mm3
+    paddw       mm4, mm2                ; mm4=(CbE * FIX(1.77200))=(B-Y)E
+    paddw       mm5, mm3                ; mm5=(CbO * FIX(1.77200))=(B-Y)O
+    paddw       mm0, mm6                ; mm0=(CrE * FIX(1.40200))=(R-Y)E
+    paddw       mm1, mm7                ; mm1=(CrO * FIX(1.40200))=(R-Y)O
+
+    movq        MMWORD [wk(0)], mm4     ; wk(0)=(B-Y)E
+    movq        MMWORD [wk(1)], mm5     ; wk(1)=(B-Y)O
+
+    movq        mm4, mm2
+    movq        mm5, mm3
+    punpcklwd   mm2, mm6
+    punpckhwd   mm4, mm6
+    pmaddwd     mm2, [GOTOFF(eax,PW_MF0344_F0285)]
+    pmaddwd     mm4, [GOTOFF(eax,PW_MF0344_F0285)]
+    punpcklwd   mm3, mm7
+    punpckhwd   mm5, mm7
+    pmaddwd     mm3, [GOTOFF(eax,PW_MF0344_F0285)]
+    pmaddwd     mm5, [GOTOFF(eax,PW_MF0344_F0285)]
+
+    paddd       mm2, [GOTOFF(eax,PD_ONEHALF)]
+    paddd       mm4, [GOTOFF(eax,PD_ONEHALF)]
+    psrad       mm2, SCALEBITS
+    psrad       mm4, SCALEBITS
+    paddd       mm3, [GOTOFF(eax,PD_ONEHALF)]
+    paddd       mm5, [GOTOFF(eax,PD_ONEHALF)]
+    psrad       mm3, SCALEBITS
+    psrad       mm5, SCALEBITS
+
+    packssdw    mm2, mm4                ; mm2=CbE*-FIX(0.344)+CrE*FIX(0.285)
+    packssdw    mm3, mm5                ; mm3=CbO*-FIX(0.344)+CrO*FIX(0.285)
+    psubw       mm2, mm6                ; mm2=CbE*-FIX(0.344)+CrE*-FIX(0.714)=(G-Y)E
+    psubw       mm3, mm7                ; mm3=CbO*-FIX(0.344)+CrO*-FIX(0.714)=(G-Y)O
+
+    movq        mm5, MMWORD [esi]       ; mm5=Y(01234567)
+
+    pcmpeqw     mm4, mm4
+    psrlw       mm4, BYTE_BIT           ; mm4={0xFF 0x00 0xFF 0x00 ..}
+    pand        mm4, mm5                ; mm4=Y(0246)=YE
+    psrlw       mm5, BYTE_BIT           ; mm5=Y(1357)=YO
+
+    paddw       mm0, mm4                ; mm0=((R-Y)E+YE)=RE=(R0 R2 R4 R6)
+    paddw       mm1, mm5                ; mm1=((R-Y)O+YO)=RO=(R1 R3 R5 R7)
+    packuswb    mm0, mm0                ; mm0=(R0 R2 R4 R6 ** ** ** **)
+    packuswb    mm1, mm1                ; mm1=(R1 R3 R5 R7 ** ** ** **)
+
+    paddw       mm2, mm4                ; mm2=((G-Y)E+YE)=GE=(G0 G2 G4 G6)
+    paddw       mm3, mm5                ; mm3=((G-Y)O+YO)=GO=(G1 G3 G5 G7)
+    packuswb    mm2, mm2                ; mm2=(G0 G2 G4 G6 ** ** ** **)
+    packuswb    mm3, mm3                ; mm3=(G1 G3 G5 G7 ** ** ** **)
+
+    paddw       mm4,  MMWORD [wk(0)]    ; mm4=(YE+(B-Y)E)=BE=(B0 B2 B4 B6)
+    paddw       mm5,  MMWORD [wk(1)]    ; mm5=(YO+(B-Y)O)=BO=(B1 B3 B5 B7)
+    packuswb    mm4, mm4                ; mm4=(B0 B2 B4 B6 ** ** ** **)
+    packuswb    mm5, mm5                ; mm5=(B1 B3 B5 B7 ** ** ** **)
+
+%if RGB_PIXELSIZE == 3  ; ---------------
+
+    ; mmA=(00 02 04 06 ** ** ** **), mmB=(01 03 05 07 ** ** ** **)
+    ; mmC=(10 12 14 16 ** ** ** **), mmD=(11 13 15 17 ** ** ** **)
+    ; mmE=(20 22 24 26 ** ** ** **), mmF=(21 23 25 27 ** ** ** **)
+    ; mmG=(** ** ** ** ** ** ** **), mmH=(** ** ** ** ** ** ** **)
+
+    punpcklbw   mmA, mmC                ; mmA=(00 10 02 12 04 14 06 16)
+    punpcklbw   mmE, mmB                ; mmE=(20 01 22 03 24 05 26 07)
+    punpcklbw   mmD, mmF                ; mmD=(11 21 13 23 15 25 17 27)
+
+    movq        mmG, mmA
+    movq        mmH, mmA
+    punpcklwd   mmA, mmE                ; mmA=(00 10 20 01 02 12 22 03)
+    punpckhwd   mmG, mmE                ; mmG=(04 14 24 05 06 16 26 07)
+
+    psrlq       mmH, 2*BYTE_BIT         ; mmH=(02 12 04 14 06 16 -- --)
+    psrlq       mmE, 2*BYTE_BIT         ; mmE=(22 03 24 05 26 07 -- --)
+
+    movq        mmC, mmD
+    movq        mmB, mmD
+    punpcklwd   mmD, mmH                ; mmD=(11 21 02 12 13 23 04 14)
+    punpckhwd   mmC, mmH                ; mmC=(15 25 06 16 17 27 -- --)
+
+    psrlq       mmB, 2*BYTE_BIT         ; mmB=(13 23 15 25 17 27 -- --)
+
+    movq        mmF, mmE
+    punpcklwd   mmE, mmB                ; mmE=(22 03 13 23 24 05 15 25)
+    punpckhwd   mmF, mmB                ; mmF=(26 07 17 27 -- -- -- --)
+
+    punpckldq   mmA, mmD                ; mmA=(00 10 20 01 11 21 02 12)
+    punpckldq   mmE, mmG                ; mmE=(22 03 13 23 04 14 24 05)
+    punpckldq   mmC, mmF                ; mmC=(15 25 06 16 26 07 17 27)
+
+    cmp         ecx, byte SIZEOF_MMWORD
+    jb          short .column_st16
+
+    movq        MMWORD [edi+0*SIZEOF_MMWORD], mmA
+    movq        MMWORD [edi+1*SIZEOF_MMWORD], mmE
+    movq        MMWORD [edi+2*SIZEOF_MMWORD], mmC
+
+    sub         ecx, byte SIZEOF_MMWORD
+    jz          short .nextrow
+
+    add         esi, byte SIZEOF_MMWORD                ; inptr0
+    add         ebx, byte SIZEOF_MMWORD                ; inptr1
+    add         edx, byte SIZEOF_MMWORD                ; inptr2
+    add         edi, byte RGB_PIXELSIZE*SIZEOF_MMWORD  ; outptr
+    jmp         near .columnloop
+    alignx      16, 7
+
+.column_st16:
+    lea         ecx, [ecx+ecx*2]        ; imul ecx, RGB_PIXELSIZE
+    cmp         ecx, byte 2*SIZEOF_MMWORD
+    jb          short .column_st8
+    movq        MMWORD [edi+0*SIZEOF_MMWORD], mmA
+    movq        MMWORD [edi+1*SIZEOF_MMWORD], mmE
+    movq        mmA, mmC
+    sub         ecx, byte 2*SIZEOF_MMWORD
+    add         edi, byte 2*SIZEOF_MMWORD
+    jmp         short .column_st4
+.column_st8:
+    cmp         ecx, byte SIZEOF_MMWORD
+    jb          short .column_st4
+    movq        MMWORD [edi+0*SIZEOF_MMWORD], mmA
+    movq        mmA, mmE
+    sub         ecx, byte SIZEOF_MMWORD
+    add         edi, byte SIZEOF_MMWORD
+.column_st4:
+    movd        eax, mmA
+    cmp         ecx, byte SIZEOF_DWORD
+    jb          short .column_st2
+    mov         dword [edi+0*SIZEOF_DWORD], eax
+    psrlq       mmA, DWORD_BIT
+    movd        eax, mmA
+    sub         ecx, byte SIZEOF_DWORD
+    add         edi, byte SIZEOF_DWORD
+.column_st2:
+    cmp         ecx, byte SIZEOF_WORD
+    jb          short .column_st1
+    mov         word [edi+0*SIZEOF_WORD], ax
+    shr         eax, WORD_BIT
+    sub         ecx, byte SIZEOF_WORD
+    add         edi, byte SIZEOF_WORD
+.column_st1:
+    cmp         ecx, byte SIZEOF_BYTE
+    jb          short .nextrow
+    mov         byte [edi+0*SIZEOF_BYTE], al
+
+%else  ; RGB_PIXELSIZE == 4 ; -----------
+
+%ifdef RGBX_FILLER_0XFF
+    pcmpeqb     mm6, mm6                ; mm6=(X0 X2 X4 X6 ** ** ** **)
+    pcmpeqb     mm7, mm7                ; mm7=(X1 X3 X5 X7 ** ** ** **)
+%else
+    pxor        mm6, mm6                ; mm6=(X0 X2 X4 X6 ** ** ** **)
+    pxor        mm7, mm7                ; mm7=(X1 X3 X5 X7 ** ** ** **)
+%endif
+    ; mmA=(00 02 04 06 ** ** ** **), mmB=(01 03 05 07 ** ** ** **)
+    ; mmC=(10 12 14 16 ** ** ** **), mmD=(11 13 15 17 ** ** ** **)
+    ; mmE=(20 22 24 26 ** ** ** **), mmF=(21 23 25 27 ** ** ** **)
+    ; mmG=(30 32 34 36 ** ** ** **), mmH=(31 33 35 37 ** ** ** **)
+
+    punpcklbw   mmA, mmC                ; mmA=(00 10 02 12 04 14 06 16)
+    punpcklbw   mmE, mmG                ; mmE=(20 30 22 32 24 34 26 36)
+    punpcklbw   mmB, mmD                ; mmB=(01 11 03 13 05 15 07 17)
+    punpcklbw   mmF, mmH                ; mmF=(21 31 23 33 25 35 27 37)
+
+    movq        mmC, mmA
+    punpcklwd   mmA, mmE                ; mmA=(00 10 20 30 02 12 22 32)
+    punpckhwd   mmC, mmE                ; mmC=(04 14 24 34 06 16 26 36)
+    movq        mmG, mmB
+    punpcklwd   mmB, mmF                ; mmB=(01 11 21 31 03 13 23 33)
+    punpckhwd   mmG, mmF                ; mmG=(05 15 25 35 07 17 27 37)
+
+    movq        mmD, mmA
+    punpckldq   mmA, mmB                ; mmA=(00 10 20 30 01 11 21 31)
+    punpckhdq   mmD, mmB                ; mmD=(02 12 22 32 03 13 23 33)
+    movq        mmH, mmC
+    punpckldq   mmC, mmG                ; mmC=(04 14 24 34 05 15 25 35)
+    punpckhdq   mmH, mmG                ; mmH=(06 16 26 36 07 17 27 37)
+
+    cmp         ecx, byte SIZEOF_MMWORD
+    jb          short .column_st16
+
+    movq        MMWORD [edi+0*SIZEOF_MMWORD], mmA
+    movq        MMWORD [edi+1*SIZEOF_MMWORD], mmD
+    movq        MMWORD [edi+2*SIZEOF_MMWORD], mmC
+    movq        MMWORD [edi+3*SIZEOF_MMWORD], mmH
+
+    sub         ecx, byte SIZEOF_MMWORD
+    jz          short .nextrow
+
+    add         esi, byte SIZEOF_MMWORD                ; inptr0
+    add         ebx, byte SIZEOF_MMWORD                ; inptr1
+    add         edx, byte SIZEOF_MMWORD                ; inptr2
+    add         edi, byte RGB_PIXELSIZE*SIZEOF_MMWORD  ; outptr
+    jmp         near .columnloop
+    alignx      16, 7
+
+.column_st16:
+    cmp         ecx, byte SIZEOF_MMWORD/2
+    jb          short .column_st8
+    movq        MMWORD [edi+0*SIZEOF_MMWORD], mmA
+    movq        MMWORD [edi+1*SIZEOF_MMWORD], mmD
+    movq        mmA, mmC
+    movq        mmD, mmH
+    sub         ecx, byte SIZEOF_MMWORD/2
+    add         edi, byte 2*SIZEOF_MMWORD
+.column_st8:
+    cmp         ecx, byte SIZEOF_MMWORD/4
+    jb          short .column_st4
+    movq        MMWORD [edi+0*SIZEOF_MMWORD], mmA
+    movq        mmA, mmD
+    sub         ecx, byte SIZEOF_MMWORD/4
+    add         edi, byte 1*SIZEOF_MMWORD
+.column_st4:
+    cmp         ecx, byte SIZEOF_MMWORD/8
+    jb          short .nextrow
+    movd        dword [edi+0*SIZEOF_DWORD], mmA
+
+%endif  ; RGB_PIXELSIZE ; ---------------
+
+    alignx      16, 7
+
+.nextrow:
+    pop         ecx
+    pop         esi
+    pop         ebx
+    pop         edx
+    pop         edi
+    pop         eax
+
+    add         esi, byte SIZEOF_JSAMPROW
+    add         ebx, byte SIZEOF_JSAMPROW
+    add         edx, byte SIZEOF_JSAMPROW
+    add         edi, byte SIZEOF_JSAMPROW  ; output_buf
+    dec         eax                        ; num_rows
+    jg          near .rowloop
+
+    emms                                ; empty MMX state
+
+.return:
+    pop         edi
+    pop         esi
+;   pop         edx                     ; need not be preserved
+;   pop         ecx                     ; need not be preserved
+    pop         ebx
+    mov         esp, ebp                ; esp <- aligned ebp
+    pop         esp                     ; esp <- original ebp
+    pop         ebp
+    ret
+
+; For some reason, the OS X linker does not honor the request to align the
+; segment unless we do this.
+    align       32
diff --git a/3rdparty/libjpeg/src/simd/i386/jdcolext-sse2.asm b/3rdparty/libjpeg/src/simd/i386/jdcolext-sse2.asm
new file mode 100644
index 00000000..d5572b32
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/i386/jdcolext-sse2.asm
@@ -0,0 +1,458 @@
+;
+; jdcolext.asm - colorspace conversion (SSE2)
+;
+; Copyright 2009, 2012 Pierre Ossman <ossman@cendio.se> for Cendio AB
+; Copyright (C) 2012, 2016, D. R. Commander.
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+;
+; This file should be assembled with NASM (Netwide Assembler),
+; can *not* be assembled with Microsoft's MASM or any compatible
+; assembler (including Borland's Turbo Assembler).
+; NASM is available from http://nasm.sourceforge.net/ or
+; http://sourceforge.net/project/showfiles.php?group_id=6208
+
+%include "jcolsamp.inc"
+
+; --------------------------------------------------------------------------
+;
+; Convert some rows of samples to the output colorspace.
+;
+; GLOBAL(void)
+; jsimd_ycc_rgb_convert_sse2(JDIMENSION out_width, JSAMPIMAGE input_buf,
+;                            JDIMENSION input_row, JSAMPARRAY output_buf,
+;                            int num_rows)
+;
+
+%define out_width(b)   (b) + 8          ; JDIMENSION out_width
+%define input_buf(b)   (b) + 12         ; JSAMPIMAGE input_buf
+%define input_row(b)   (b) + 16         ; JDIMENSION input_row
+%define output_buf(b)  (b) + 20         ; JSAMPARRAY output_buf
+%define num_rows(b)    (b) + 24         ; int num_rows
+
+%define original_ebp   ebp + 0
+%define wk(i)          ebp - (WK_NUM - (i)) * SIZEOF_XMMWORD
+                                        ; xmmword wk[WK_NUM]
+%define WK_NUM         2
+%define gotptr         wk(0) - SIZEOF_POINTER  ; void * gotptr
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_ycc_rgb_convert_sse2)
+
+EXTN(jsimd_ycc_rgb_convert_sse2):
+    push        ebp
+    mov         eax, esp                     ; eax = original ebp
+    sub         esp, byte 4
+    and         esp, byte (-SIZEOF_XMMWORD)  ; align to 128 bits
+    mov         [esp], eax
+    mov         ebp, esp                     ; ebp = aligned ebp
+    lea         esp, [wk(0)]
+    pushpic     eax                     ; make a room for GOT address
+    push        ebx
+;   push        ecx                     ; need not be preserved
+;   push        edx                     ; need not be preserved
+    push        esi
+    push        edi
+
+    get_GOT     ebx                     ; get GOT address
+    movpic      POINTER [gotptr], ebx   ; save GOT address
+
+    mov         ecx, JDIMENSION [out_width(eax)]  ; num_cols
+    test        ecx, ecx
+    jz          near .return
+
+    push        ecx
+
+    mov         edi, JSAMPIMAGE [input_buf(eax)]
+    mov         ecx, JDIMENSION [input_row(eax)]
+    mov         esi, JSAMPARRAY [edi+0*SIZEOF_JSAMPARRAY]
+    mov         ebx, JSAMPARRAY [edi+1*SIZEOF_JSAMPARRAY]
+    mov         edx, JSAMPARRAY [edi+2*SIZEOF_JSAMPARRAY]
+    lea         esi, [esi+ecx*SIZEOF_JSAMPROW]
+    lea         ebx, [ebx+ecx*SIZEOF_JSAMPROW]
+    lea         edx, [edx+ecx*SIZEOF_JSAMPROW]
+
+    pop         ecx
+
+    mov         edi, JSAMPARRAY [output_buf(eax)]
+    mov         eax, INT [num_rows(eax)]
+    test        eax, eax
+    jle         near .return
+    alignx      16, 7
+.rowloop:
+    push        eax
+    push        edi
+    push        edx
+    push        ebx
+    push        esi
+    push        ecx                     ; col
+
+    mov         esi, JSAMPROW [esi]     ; inptr0
+    mov         ebx, JSAMPROW [ebx]     ; inptr1
+    mov         edx, JSAMPROW [edx]     ; inptr2
+    mov         edi, JSAMPROW [edi]     ; outptr
+    movpic      eax, POINTER [gotptr]   ; load GOT address (eax)
+    alignx      16, 7
+.columnloop:
+
+    movdqa      xmm5, XMMWORD [ebx]     ; xmm5=Cb(0123456789ABCDEF)
+    movdqa      xmm1, XMMWORD [edx]     ; xmm1=Cr(0123456789ABCDEF)
+
+    pcmpeqw     xmm4, xmm4
+    pcmpeqw     xmm7, xmm7
+    psrlw       xmm4, BYTE_BIT
+    psllw       xmm7, 7                 ; xmm7={0xFF80 0xFF80 0xFF80 0xFF80 ..}
+    movdqa      xmm0, xmm4              ; xmm0=xmm4={0xFF 0x00 0xFF 0x00 ..}
+
+    pand        xmm4, xmm5              ; xmm4=Cb(02468ACE)=CbE
+    psrlw       xmm5, BYTE_BIT          ; xmm5=Cb(13579BDF)=CbO
+    pand        xmm0, xmm1              ; xmm0=Cr(02468ACE)=CrE
+    psrlw       xmm1, BYTE_BIT          ; xmm1=Cr(13579BDF)=CrO
+
+    paddw       xmm4, xmm7
+    paddw       xmm5, xmm7
+    paddw       xmm0, xmm7
+    paddw       xmm1, xmm7
+
+    ; (Original)
+    ; R = Y                + 1.40200 * Cr
+    ; G = Y - 0.34414 * Cb - 0.71414 * Cr
+    ; B = Y + 1.77200 * Cb
+    ;
+    ; (This implementation)
+    ; R = Y                + 0.40200 * Cr + Cr
+    ; G = Y - 0.34414 * Cb + 0.28586 * Cr - Cr
+    ; B = Y - 0.22800 * Cb + Cb + Cb
+
+    movdqa      xmm2, xmm4              ; xmm2=CbE
+    movdqa      xmm3, xmm5              ; xmm3=CbO
+    paddw       xmm4, xmm4              ; xmm4=2*CbE
+    paddw       xmm5, xmm5              ; xmm5=2*CbO
+    movdqa      xmm6, xmm0              ; xmm6=CrE
+    movdqa      xmm7, xmm1              ; xmm7=CrO
+    paddw       xmm0, xmm0              ; xmm0=2*CrE
+    paddw       xmm1, xmm1              ; xmm1=2*CrO
+
+    pmulhw      xmm4, [GOTOFF(eax,PW_MF0228)]  ; xmm4=(2*CbE * -FIX(0.22800))
+    pmulhw      xmm5, [GOTOFF(eax,PW_MF0228)]  ; xmm5=(2*CbO * -FIX(0.22800))
+    pmulhw      xmm0, [GOTOFF(eax,PW_F0402)]   ; xmm0=(2*CrE * FIX(0.40200))
+    pmulhw      xmm1, [GOTOFF(eax,PW_F0402)]   ; xmm1=(2*CrO * FIX(0.40200))
+
+    paddw       xmm4, [GOTOFF(eax,PW_ONE)]
+    paddw       xmm5, [GOTOFF(eax,PW_ONE)]
+    psraw       xmm4, 1                 ; xmm4=(CbE * -FIX(0.22800))
+    psraw       xmm5, 1                 ; xmm5=(CbO * -FIX(0.22800))
+    paddw       xmm0, [GOTOFF(eax,PW_ONE)]
+    paddw       xmm1, [GOTOFF(eax,PW_ONE)]
+    psraw       xmm0, 1                 ; xmm0=(CrE * FIX(0.40200))
+    psraw       xmm1, 1                 ; xmm1=(CrO * FIX(0.40200))
+
+    paddw       xmm4, xmm2
+    paddw       xmm5, xmm3
+    paddw       xmm4, xmm2              ; xmm4=(CbE * FIX(1.77200))=(B-Y)E
+    paddw       xmm5, xmm3              ; xmm5=(CbO * FIX(1.77200))=(B-Y)O
+    paddw       xmm0, xmm6              ; xmm0=(CrE * FIX(1.40200))=(R-Y)E
+    paddw       xmm1, xmm7              ; xmm1=(CrO * FIX(1.40200))=(R-Y)O
+
+    movdqa      XMMWORD [wk(0)], xmm4   ; wk(0)=(B-Y)E
+    movdqa      XMMWORD [wk(1)], xmm5   ; wk(1)=(B-Y)O
+
+    movdqa      xmm4, xmm2
+    movdqa      xmm5, xmm3
+    punpcklwd   xmm2, xmm6
+    punpckhwd   xmm4, xmm6
+    pmaddwd     xmm2, [GOTOFF(eax,PW_MF0344_F0285)]
+    pmaddwd     xmm4, [GOTOFF(eax,PW_MF0344_F0285)]
+    punpcklwd   xmm3, xmm7
+    punpckhwd   xmm5, xmm7
+    pmaddwd     xmm3, [GOTOFF(eax,PW_MF0344_F0285)]
+    pmaddwd     xmm5, [GOTOFF(eax,PW_MF0344_F0285)]
+
+    paddd       xmm2, [GOTOFF(eax,PD_ONEHALF)]
+    paddd       xmm4, [GOTOFF(eax,PD_ONEHALF)]
+    psrad       xmm2, SCALEBITS
+    psrad       xmm4, SCALEBITS
+    paddd       xmm3, [GOTOFF(eax,PD_ONEHALF)]
+    paddd       xmm5, [GOTOFF(eax,PD_ONEHALF)]
+    psrad       xmm3, SCALEBITS
+    psrad       xmm5, SCALEBITS
+
+    packssdw    xmm2, xmm4              ; xmm2=CbE*-FIX(0.344)+CrE*FIX(0.285)
+    packssdw    xmm3, xmm5              ; xmm3=CbO*-FIX(0.344)+CrO*FIX(0.285)
+    psubw       xmm2, xmm6              ; xmm2=CbE*-FIX(0.344)+CrE*-FIX(0.714)=(G-Y)E
+    psubw       xmm3, xmm7              ; xmm3=CbO*-FIX(0.344)+CrO*-FIX(0.714)=(G-Y)O
+
+    movdqa      xmm5, XMMWORD [esi]     ; xmm5=Y(0123456789ABCDEF)
+
+    pcmpeqw     xmm4, xmm4
+    psrlw       xmm4, BYTE_BIT          ; xmm4={0xFF 0x00 0xFF 0x00 ..}
+    pand        xmm4, xmm5              ; xmm4=Y(02468ACE)=YE
+    psrlw       xmm5, BYTE_BIT          ; xmm5=Y(13579BDF)=YO
+
+    paddw       xmm0, xmm4              ; xmm0=((R-Y)E+YE)=RE=R(02468ACE)
+    paddw       xmm1, xmm5              ; xmm1=((R-Y)O+YO)=RO=R(13579BDF)
+    packuswb    xmm0, xmm0              ; xmm0=R(02468ACE********)
+    packuswb    xmm1, xmm1              ; xmm1=R(13579BDF********)
+
+    paddw       xmm2, xmm4              ; xmm2=((G-Y)E+YE)=GE=G(02468ACE)
+    paddw       xmm3, xmm5              ; xmm3=((G-Y)O+YO)=GO=G(13579BDF)
+    packuswb    xmm2, xmm2              ; xmm2=G(02468ACE********)
+    packuswb    xmm3, xmm3              ; xmm3=G(13579BDF********)
+
+    paddw       xmm4, XMMWORD [wk(0)]   ; xmm4=(YE+(B-Y)E)=BE=B(02468ACE)
+    paddw       xmm5, XMMWORD [wk(1)]   ; xmm5=(YO+(B-Y)O)=BO=B(13579BDF)
+    packuswb    xmm4, xmm4              ; xmm4=B(02468ACE********)
+    packuswb    xmm5, xmm5              ; xmm5=B(13579BDF********)
+
+%if RGB_PIXELSIZE == 3  ; ---------------
+
+    ; xmmA=(00 02 04 06 08 0A 0C 0E **), xmmB=(01 03 05 07 09 0B 0D 0F **)
+    ; xmmC=(10 12 14 16 18 1A 1C 1E **), xmmD=(11 13 15 17 19 1B 1D 1F **)
+    ; xmmE=(20 22 24 26 28 2A 2C 2E **), xmmF=(21 23 25 27 29 2B 2D 2F **)
+    ; xmmG=(** ** ** ** ** ** ** ** **), xmmH=(** ** ** ** ** ** ** ** **)
+
+    punpcklbw   xmmA, xmmC        ; xmmA=(00 10 02 12 04 14 06 16 08 18 0A 1A 0C 1C 0E 1E)
+    punpcklbw   xmmE, xmmB        ; xmmE=(20 01 22 03 24 05 26 07 28 09 2A 0B 2C 0D 2E 0F)
+    punpcklbw   xmmD, xmmF        ; xmmD=(11 21 13 23 15 25 17 27 19 29 1B 2B 1D 2D 1F 2F)
+
+    movdqa      xmmG, xmmA
+    movdqa      xmmH, xmmA
+    punpcklwd   xmmA, xmmE        ; xmmA=(00 10 20 01 02 12 22 03 04 14 24 05 06 16 26 07)
+    punpckhwd   xmmG, xmmE        ; xmmG=(08 18 28 09 0A 1A 2A 0B 0C 1C 2C 0D 0E 1E 2E 0F)
+
+    psrldq      xmmH, 2           ; xmmH=(02 12 04 14 06 16 08 18 0A 1A 0C 1C 0E 1E -- --)
+    psrldq      xmmE, 2           ; xmmE=(22 03 24 05 26 07 28 09 2A 0B 2C 0D 2E 0F -- --)
+
+    movdqa      xmmC, xmmD
+    movdqa      xmmB, xmmD
+    punpcklwd   xmmD, xmmH        ; xmmD=(11 21 02 12 13 23 04 14 15 25 06 16 17 27 08 18)
+    punpckhwd   xmmC, xmmH        ; xmmC=(19 29 0A 1A 1B 2B 0C 1C 1D 2D 0E 1E 1F 2F -- --)
+
+    psrldq      xmmB, 2           ; xmmB=(13 23 15 25 17 27 19 29 1B 2B 1D 2D 1F 2F -- --)
+
+    movdqa      xmmF, xmmE
+    punpcklwd   xmmE, xmmB        ; xmmE=(22 03 13 23 24 05 15 25 26 07 17 27 28 09 19 29)
+    punpckhwd   xmmF, xmmB        ; xmmF=(2A 0B 1B 2B 2C 0D 1D 2D 2E 0F 1F 2F -- -- -- --)
+
+    pshufd      xmmH, xmmA, 0x4E  ; xmmH=(04 14 24 05 06 16 26 07 00 10 20 01 02 12 22 03)
+    movdqa      xmmB, xmmE
+    punpckldq   xmmA, xmmD        ; xmmA=(00 10 20 01 11 21 02 12 02 12 22 03 13 23 04 14)
+    punpckldq   xmmE, xmmH        ; xmmE=(22 03 13 23 04 14 24 05 24 05 15 25 06 16 26 07)
+    punpckhdq   xmmD, xmmB        ; xmmD=(15 25 06 16 26 07 17 27 17 27 08 18 28 09 19 29)
+
+    pshufd      xmmH, xmmG, 0x4E  ; xmmH=(0C 1C 2C 0D 0E 1E 2E 0F 08 18 28 09 0A 1A 2A 0B)
+    movdqa      xmmB, xmmF
+    punpckldq   xmmG, xmmC        ; xmmG=(08 18 28 09 19 29 0A 1A 0A 1A 2A 0B 1B 2B 0C 1C)
+    punpckldq   xmmF, xmmH        ; xmmF=(2A 0B 1B 2B 0C 1C 2C 0D 2C 0D 1D 2D 0E 1E 2E 0F)
+    punpckhdq   xmmC, xmmB        ; xmmC=(1D 2D 0E 1E 2E 0F 1F 2F 1F 2F -- -- -- -- -- --)
+
+    punpcklqdq  xmmA, xmmE        ; xmmA=(00 10 20 01 11 21 02 12 22 03 13 23 04 14 24 05)
+    punpcklqdq  xmmD, xmmG        ; xmmD=(15 25 06 16 26 07 17 27 08 18 28 09 19 29 0A 1A)
+    punpcklqdq  xmmF, xmmC        ; xmmF=(2A 0B 1B 2B 0C 1C 2C 0D 1D 2D 0E 1E 2E 0F 1F 2F)
+
+    cmp         ecx, byte SIZEOF_XMMWORD
+    jb          short .column_st32
+
+    test        edi, SIZEOF_XMMWORD-1
+    jnz         short .out1
+    ; --(aligned)-------------------
+    movntdq     XMMWORD [edi+0*SIZEOF_XMMWORD], xmmA
+    movntdq     XMMWORD [edi+1*SIZEOF_XMMWORD], xmmD
+    movntdq     XMMWORD [edi+2*SIZEOF_XMMWORD], xmmF
+    jmp         short .out0
+.out1:  ; --(unaligned)-----------------
+    movdqu      XMMWORD [edi+0*SIZEOF_XMMWORD], xmmA
+    movdqu      XMMWORD [edi+1*SIZEOF_XMMWORD], xmmD
+    movdqu      XMMWORD [edi+2*SIZEOF_XMMWORD], xmmF
+.out0:
+    add         edi, byte RGB_PIXELSIZE*SIZEOF_XMMWORD  ; outptr
+    sub         ecx, byte SIZEOF_XMMWORD
+    jz          near .nextrow
+
+    add         esi, byte SIZEOF_XMMWORD  ; inptr0
+    add         ebx, byte SIZEOF_XMMWORD  ; inptr1
+    add         edx, byte SIZEOF_XMMWORD  ; inptr2
+    jmp         near .columnloop
+    alignx      16, 7
+
+.column_st32:
+    lea         ecx, [ecx+ecx*2]        ; imul ecx, RGB_PIXELSIZE
+    cmp         ecx, byte 2*SIZEOF_XMMWORD
+    jb          short .column_st16
+    movdqu      XMMWORD [edi+0*SIZEOF_XMMWORD], xmmA
+    movdqu      XMMWORD [edi+1*SIZEOF_XMMWORD], xmmD
+    add         edi, byte 2*SIZEOF_XMMWORD  ; outptr
+    movdqa      xmmA, xmmF
+    sub         ecx, byte 2*SIZEOF_XMMWORD
+    jmp         short .column_st15
+.column_st16:
+    cmp         ecx, byte SIZEOF_XMMWORD
+    jb          short .column_st15
+    movdqu      XMMWORD [edi+0*SIZEOF_XMMWORD], xmmA
+    add         edi, byte SIZEOF_XMMWORD    ; outptr
+    movdqa      xmmA, xmmD
+    sub         ecx, byte SIZEOF_XMMWORD
+.column_st15:
+    ; Store the lower 8 bytes of xmmA to the output when it has enough
+    ; space.
+    cmp         ecx, byte SIZEOF_MMWORD
+    jb          short .column_st7
+    movq        XMM_MMWORD [edi], xmmA
+    add         edi, byte SIZEOF_MMWORD
+    sub         ecx, byte SIZEOF_MMWORD
+    psrldq      xmmA, SIZEOF_MMWORD
+.column_st7:
+    ; Store the lower 4 bytes of xmmA to the output when it has enough
+    ; space.
+    cmp         ecx, byte SIZEOF_DWORD
+    jb          short .column_st3
+    movd        XMM_DWORD [edi], xmmA
+    add         edi, byte SIZEOF_DWORD
+    sub         ecx, byte SIZEOF_DWORD
+    psrldq      xmmA, SIZEOF_DWORD
+.column_st3:
+    ; Store the lower 2 bytes of eax to the output when it has enough
+    ; space.
+    movd        eax, xmmA
+    cmp         ecx, byte SIZEOF_WORD
+    jb          short .column_st1
+    mov         word [edi], ax
+    add         edi, byte SIZEOF_WORD
+    sub         ecx, byte SIZEOF_WORD
+    shr         eax, 16
+.column_st1:
+    ; Store the lower 1 byte of eax to the output when it has enough
+    ; space.
+    test        ecx, ecx
+    jz          short .nextrow
+    mov         byte [edi], al
+
+%else  ; RGB_PIXELSIZE == 4 ; -----------
+
+%ifdef RGBX_FILLER_0XFF
+    pcmpeqb     xmm6, xmm6              ; xmm6=XE=X(02468ACE********)
+    pcmpeqb     xmm7, xmm7              ; xmm7=XO=X(13579BDF********)
+%else
+    pxor        xmm6, xmm6              ; xmm6=XE=X(02468ACE********)
+    pxor        xmm7, xmm7              ; xmm7=XO=X(13579BDF********)
+%endif
+    ; xmmA=(00 02 04 06 08 0A 0C 0E **), xmmB=(01 03 05 07 09 0B 0D 0F **)
+    ; xmmC=(10 12 14 16 18 1A 1C 1E **), xmmD=(11 13 15 17 19 1B 1D 1F **)
+    ; xmmE=(20 22 24 26 28 2A 2C 2E **), xmmF=(21 23 25 27 29 2B 2D 2F **)
+    ; xmmG=(30 32 34 36 38 3A 3C 3E **), xmmH=(31 33 35 37 39 3B 3D 3F **)
+
+    punpcklbw   xmmA, xmmC  ; xmmA=(00 10 02 12 04 14 06 16 08 18 0A 1A 0C 1C 0E 1E)
+    punpcklbw   xmmE, xmmG  ; xmmE=(20 30 22 32 24 34 26 36 28 38 2A 3A 2C 3C 2E 3E)
+    punpcklbw   xmmB, xmmD  ; xmmB=(01 11 03 13 05 15 07 17 09 19 0B 1B 0D 1D 0F 1F)
+    punpcklbw   xmmF, xmmH  ; xmmF=(21 31 23 33 25 35 27 37 29 39 2B 3B 2D 3D 2F 3F)
+
+    movdqa      xmmC, xmmA
+    punpcklwd   xmmA, xmmE  ; xmmA=(00 10 20 30 02 12 22 32 04 14 24 34 06 16 26 36)
+    punpckhwd   xmmC, xmmE  ; xmmC=(08 18 28 38 0A 1A 2A 3A 0C 1C 2C 3C 0E 1E 2E 3E)
+    movdqa      xmmG, xmmB
+    punpcklwd   xmmB, xmmF  ; xmmB=(01 11 21 31 03 13 23 33 05 15 25 35 07 17 27 37)
+    punpckhwd   xmmG, xmmF  ; xmmG=(09 19 29 39 0B 1B 2B 3B 0D 1D 2D 3D 0F 1F 2F 3F)
+
+    movdqa      xmmD, xmmA
+    punpckldq   xmmA, xmmB  ; xmmA=(00 10 20 30 01 11 21 31 02 12 22 32 03 13 23 33)
+    punpckhdq   xmmD, xmmB  ; xmmD=(04 14 24 34 05 15 25 35 06 16 26 36 07 17 27 37)
+    movdqa      xmmH, xmmC
+    punpckldq   xmmC, xmmG  ; xmmC=(08 18 28 38 09 19 29 39 0A 1A 2A 3A 0B 1B 2B 3B)
+    punpckhdq   xmmH, xmmG  ; xmmH=(0C 1C 2C 3C 0D 1D 2D 3D 0E 1E 2E 3E 0F 1F 2F 3F)
+
+    cmp         ecx, byte SIZEOF_XMMWORD
+    jb          short .column_st32
+
+    test        edi, SIZEOF_XMMWORD-1
+    jnz         short .out1
+    ; --(aligned)-------------------
+    movntdq     XMMWORD [edi+0*SIZEOF_XMMWORD], xmmA
+    movntdq     XMMWORD [edi+1*SIZEOF_XMMWORD], xmmD
+    movntdq     XMMWORD [edi+2*SIZEOF_XMMWORD], xmmC
+    movntdq     XMMWORD [edi+3*SIZEOF_XMMWORD], xmmH
+    jmp         short .out0
+.out1:  ; --(unaligned)-----------------
+    movdqu      XMMWORD [edi+0*SIZEOF_XMMWORD], xmmA
+    movdqu      XMMWORD [edi+1*SIZEOF_XMMWORD], xmmD
+    movdqu      XMMWORD [edi+2*SIZEOF_XMMWORD], xmmC
+    movdqu      XMMWORD [edi+3*SIZEOF_XMMWORD], xmmH
+.out0:
+    add         edi, byte RGB_PIXELSIZE*SIZEOF_XMMWORD  ; outptr
+    sub         ecx, byte SIZEOF_XMMWORD
+    jz          near .nextrow
+
+    add         esi, byte SIZEOF_XMMWORD  ; inptr0
+    add         ebx, byte SIZEOF_XMMWORD  ; inptr1
+    add         edx, byte SIZEOF_XMMWORD  ; inptr2
+    jmp         near .columnloop
+    alignx      16, 7
+
+.column_st32:
+    cmp         ecx, byte SIZEOF_XMMWORD/2
+    jb          short .column_st16
+    movdqu      XMMWORD [edi+0*SIZEOF_XMMWORD], xmmA
+    movdqu      XMMWORD [edi+1*SIZEOF_XMMWORD], xmmD
+    add         edi, byte 2*SIZEOF_XMMWORD  ; outptr
+    movdqa      xmmA, xmmC
+    movdqa      xmmD, xmmH
+    sub         ecx, byte SIZEOF_XMMWORD/2
+.column_st16:
+    cmp         ecx, byte SIZEOF_XMMWORD/4
+    jb          short .column_st15
+    movdqu      XMMWORD [edi+0*SIZEOF_XMMWORD], xmmA
+    add         edi, byte SIZEOF_XMMWORD    ; outptr
+    movdqa      xmmA, xmmD
+    sub         ecx, byte SIZEOF_XMMWORD/4
+.column_st15:
+    ; Store two pixels (8 bytes) of xmmA to the output when it has enough
+    ; space.
+    cmp         ecx, byte SIZEOF_XMMWORD/8
+    jb          short .column_st7
+    movq        XMM_MMWORD [edi], xmmA
+    add         edi, byte SIZEOF_XMMWORD/8*4
+    sub         ecx, byte SIZEOF_XMMWORD/8
+    psrldq      xmmA, SIZEOF_XMMWORD/8*4
+.column_st7:
+    ; Store one pixel (4 bytes) of xmmA to the output when it has enough
+    ; space.
+    test        ecx, ecx
+    jz          short .nextrow
+    movd        XMM_DWORD [edi], xmmA
+
+%endif  ; RGB_PIXELSIZE ; ---------------
+
+    alignx      16, 7
+
+.nextrow:
+    pop         ecx
+    pop         esi
+    pop         ebx
+    pop         edx
+    pop         edi
+    pop         eax
+
+    add         esi, byte SIZEOF_JSAMPROW
+    add         ebx, byte SIZEOF_JSAMPROW
+    add         edx, byte SIZEOF_JSAMPROW
+    add         edi, byte SIZEOF_JSAMPROW  ; output_buf
+    dec         eax                        ; num_rows
+    jg          near .rowloop
+
+    sfence                              ; flush the write buffer
+
+.return:
+    pop         edi
+    pop         esi
+;   pop         edx                     ; need not be preserved
+;   pop         ecx                     ; need not be preserved
+    pop         ebx
+    mov         esp, ebp                ; esp <- aligned ebp
+    pop         esp                     ; esp <- original ebp
+    pop         ebp
+    ret
+
+; For some reason, the OS X linker does not honor the request to align the
+; segment unless we do this.
+    align       32
diff --git a/3rdparty/libjpeg/src/simd/i386/jdcolor-avx2.asm b/3rdparty/libjpeg/src/simd/i386/jdcolor-avx2.asm
new file mode 100644
index 00000000..e05b60d0
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/i386/jdcolor-avx2.asm
@@ -0,0 +1,118 @@
+;
+; jdcolor.asm - colorspace conversion (AVX2)
+;
+; Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+; Copyright (C) 2015, Intel Corporation.
+; Copyright (C) 2016, D. R. Commander.
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+;
+; This file should be assembled with NASM (Netwide Assembler),
+; can *not* be assembled with Microsoft's MASM or any compatible
+; assembler (including Borland's Turbo Assembler).
+; NASM is available from http://nasm.sourceforge.net/ or
+; http://sourceforge.net/project/showfiles.php?group_id=6208
+
+%include "jsimdext.inc"
+
+; --------------------------------------------------------------------------
+
+%define SCALEBITS  16
+
+F_0_344 equ  22554              ; FIX(0.34414)
+F_0_714 equ  46802              ; FIX(0.71414)
+F_1_402 equ  91881              ; FIX(1.40200)
+F_1_772 equ 116130              ; FIX(1.77200)
+F_0_402 equ (F_1_402 - 65536)   ; FIX(1.40200) - FIX(1)
+F_0_285 equ ( 65536 - F_0_714)  ; FIX(1) - FIX(0.71414)
+F_0_228 equ (131072 - F_1_772)  ; FIX(2) - FIX(1.77200)
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_CONST
+
+    alignz      32
+    GLOBAL_DATA(jconst_ycc_rgb_convert_avx2)
+
+EXTN(jconst_ycc_rgb_convert_avx2):
+
+PW_F0402        times 16 dw  F_0_402
+PW_MF0228       times 16 dw -F_0_228
+PW_MF0344_F0285 times 8  dw -F_0_344, F_0_285
+PW_ONE          times 16 dw  1
+PD_ONEHALF      times 8  dd  1 << (SCALEBITS - 1)
+
+    alignz      32
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_TEXT
+    BITS        32
+
+%include "jdcolext-avx2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_RGB_RED
+%define RGB_GREEN  EXT_RGB_GREEN
+%define RGB_BLUE  EXT_RGB_BLUE
+%define RGB_PIXELSIZE  EXT_RGB_PIXELSIZE
+%define jsimd_ycc_rgb_convert_avx2  jsimd_ycc_extrgb_convert_avx2
+%include "jdcolext-avx2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_RGBX_RED
+%define RGB_GREEN  EXT_RGBX_GREEN
+%define RGB_BLUE  EXT_RGBX_BLUE
+%define RGB_PIXELSIZE  EXT_RGBX_PIXELSIZE
+%define jsimd_ycc_rgb_convert_avx2  jsimd_ycc_extrgbx_convert_avx2
+%include "jdcolext-avx2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_BGR_RED
+%define RGB_GREEN  EXT_BGR_GREEN
+%define RGB_BLUE  EXT_BGR_BLUE
+%define RGB_PIXELSIZE  EXT_BGR_PIXELSIZE
+%define jsimd_ycc_rgb_convert_avx2  jsimd_ycc_extbgr_convert_avx2
+%include "jdcolext-avx2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_BGRX_RED
+%define RGB_GREEN  EXT_BGRX_GREEN
+%define RGB_BLUE  EXT_BGRX_BLUE
+%define RGB_PIXELSIZE  EXT_BGRX_PIXELSIZE
+%define jsimd_ycc_rgb_convert_avx2  jsimd_ycc_extbgrx_convert_avx2
+%include "jdcolext-avx2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_XBGR_RED
+%define RGB_GREEN  EXT_XBGR_GREEN
+%define RGB_BLUE  EXT_XBGR_BLUE
+%define RGB_PIXELSIZE  EXT_XBGR_PIXELSIZE
+%define jsimd_ycc_rgb_convert_avx2  jsimd_ycc_extxbgr_convert_avx2
+%include "jdcolext-avx2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_XRGB_RED
+%define RGB_GREEN  EXT_XRGB_GREEN
+%define RGB_BLUE  EXT_XRGB_BLUE
+%define RGB_PIXELSIZE  EXT_XRGB_PIXELSIZE
+%define jsimd_ycc_rgb_convert_avx2  jsimd_ycc_extxrgb_convert_avx2
+%include "jdcolext-avx2.asm"
diff --git a/3rdparty/libjpeg/src/simd/i386/jdcolor-mmx.asm b/3rdparty/libjpeg/src/simd/i386/jdcolor-mmx.asm
new file mode 100644
index 00000000..fb7e7bcc
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/i386/jdcolor-mmx.asm
@@ -0,0 +1,117 @@
+;
+; jdcolor.asm - colorspace conversion (MMX)
+;
+; Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+; Copyright (C) 2009, 2016, D. R. Commander.
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+;
+; This file should be assembled with NASM (Netwide Assembler),
+; can *not* be assembled with Microsoft's MASM or any compatible
+; assembler (including Borland's Turbo Assembler).
+; NASM is available from http://nasm.sourceforge.net/ or
+; http://sourceforge.net/project/showfiles.php?group_id=6208
+
+%include "jsimdext.inc"
+
+; --------------------------------------------------------------------------
+
+%define SCALEBITS  16
+
+F_0_344 equ  22554              ; FIX(0.34414)
+F_0_714 equ  46802              ; FIX(0.71414)
+F_1_402 equ  91881              ; FIX(1.40200)
+F_1_772 equ 116130              ; FIX(1.77200)
+F_0_402 equ (F_1_402 - 65536)   ; FIX(1.40200) - FIX(1)
+F_0_285 equ ( 65536 - F_0_714)  ; FIX(1) - FIX(0.71414)
+F_0_228 equ (131072 - F_1_772)  ; FIX(2) - FIX(1.77200)
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_CONST
+
+    alignz      32
+    GLOBAL_DATA(jconst_ycc_rgb_convert_mmx)
+
+EXTN(jconst_ycc_rgb_convert_mmx):
+
+PW_F0402        times 4 dw  F_0_402
+PW_MF0228       times 4 dw -F_0_228
+PW_MF0344_F0285 times 2 dw -F_0_344, F_0_285
+PW_ONE          times 4 dw  1
+PD_ONEHALF      times 2 dd  1 << (SCALEBITS - 1)
+
+    alignz      32
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_TEXT
+    BITS        32
+
+%include "jdcolext-mmx.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_RGB_RED
+%define RGB_GREEN  EXT_RGB_GREEN
+%define RGB_BLUE  EXT_RGB_BLUE
+%define RGB_PIXELSIZE  EXT_RGB_PIXELSIZE
+%define jsimd_ycc_rgb_convert_mmx  jsimd_ycc_extrgb_convert_mmx
+%include "jdcolext-mmx.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_RGBX_RED
+%define RGB_GREEN  EXT_RGBX_GREEN
+%define RGB_BLUE  EXT_RGBX_BLUE
+%define RGB_PIXELSIZE  EXT_RGBX_PIXELSIZE
+%define jsimd_ycc_rgb_convert_mmx  jsimd_ycc_extrgbx_convert_mmx
+%include "jdcolext-mmx.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_BGR_RED
+%define RGB_GREEN  EXT_BGR_GREEN
+%define RGB_BLUE  EXT_BGR_BLUE
+%define RGB_PIXELSIZE  EXT_BGR_PIXELSIZE
+%define jsimd_ycc_rgb_convert_mmx  jsimd_ycc_extbgr_convert_mmx
+%include "jdcolext-mmx.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_BGRX_RED
+%define RGB_GREEN  EXT_BGRX_GREEN
+%define RGB_BLUE  EXT_BGRX_BLUE
+%define RGB_PIXELSIZE  EXT_BGRX_PIXELSIZE
+%define jsimd_ycc_rgb_convert_mmx  jsimd_ycc_extbgrx_convert_mmx
+%include "jdcolext-mmx.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_XBGR_RED
+%define RGB_GREEN  EXT_XBGR_GREEN
+%define RGB_BLUE  EXT_XBGR_BLUE
+%define RGB_PIXELSIZE  EXT_XBGR_PIXELSIZE
+%define jsimd_ycc_rgb_convert_mmx  jsimd_ycc_extxbgr_convert_mmx
+%include "jdcolext-mmx.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_XRGB_RED
+%define RGB_GREEN  EXT_XRGB_GREEN
+%define RGB_BLUE  EXT_XRGB_BLUE
+%define RGB_PIXELSIZE  EXT_XRGB_PIXELSIZE
+%define jsimd_ycc_rgb_convert_mmx  jsimd_ycc_extxrgb_convert_mmx
+%include "jdcolext-mmx.asm"
diff --git a/3rdparty/libjpeg/src/simd/i386/jdcolor-sse2.asm b/3rdparty/libjpeg/src/simd/i386/jdcolor-sse2.asm
new file mode 100644
index 00000000..b7362553
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/i386/jdcolor-sse2.asm
@@ -0,0 +1,117 @@
+;
+; jdcolor.asm - colorspace conversion (SSE2)
+;
+; Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+; Copyright (C) 2009, 2016, D. R. Commander.
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+;
+; This file should be assembled with NASM (Netwide Assembler),
+; can *not* be assembled with Microsoft's MASM or any compatible
+; assembler (including Borland's Turbo Assembler).
+; NASM is available from http://nasm.sourceforge.net/ or
+; http://sourceforge.net/project/showfiles.php?group_id=6208
+
+%include "jsimdext.inc"
+
+; --------------------------------------------------------------------------
+
+%define SCALEBITS  16
+
+F_0_344 equ  22554              ; FIX(0.34414)
+F_0_714 equ  46802              ; FIX(0.71414)
+F_1_402 equ  91881              ; FIX(1.40200)
+F_1_772 equ 116130              ; FIX(1.77200)
+F_0_402 equ (F_1_402 - 65536)   ; FIX(1.40200) - FIX(1)
+F_0_285 equ ( 65536 - F_0_714)  ; FIX(1) - FIX(0.71414)
+F_0_228 equ (131072 - F_1_772)  ; FIX(2) - FIX(1.77200)
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_CONST
+
+    alignz      32
+    GLOBAL_DATA(jconst_ycc_rgb_convert_sse2)
+
+EXTN(jconst_ycc_rgb_convert_sse2):
+
+PW_F0402        times 8 dw  F_0_402
+PW_MF0228       times 8 dw -F_0_228
+PW_MF0344_F0285 times 4 dw -F_0_344, F_0_285
+PW_ONE          times 8 dw  1
+PD_ONEHALF      times 4 dd  1 << (SCALEBITS - 1)
+
+    alignz      32
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_TEXT
+    BITS        32
+
+%include "jdcolext-sse2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_RGB_RED
+%define RGB_GREEN  EXT_RGB_GREEN
+%define RGB_BLUE  EXT_RGB_BLUE
+%define RGB_PIXELSIZE  EXT_RGB_PIXELSIZE
+%define jsimd_ycc_rgb_convert_sse2  jsimd_ycc_extrgb_convert_sse2
+%include "jdcolext-sse2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_RGBX_RED
+%define RGB_GREEN  EXT_RGBX_GREEN
+%define RGB_BLUE  EXT_RGBX_BLUE
+%define RGB_PIXELSIZE  EXT_RGBX_PIXELSIZE
+%define jsimd_ycc_rgb_convert_sse2  jsimd_ycc_extrgbx_convert_sse2
+%include "jdcolext-sse2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_BGR_RED
+%define RGB_GREEN  EXT_BGR_GREEN
+%define RGB_BLUE  EXT_BGR_BLUE
+%define RGB_PIXELSIZE  EXT_BGR_PIXELSIZE
+%define jsimd_ycc_rgb_convert_sse2  jsimd_ycc_extbgr_convert_sse2
+%include "jdcolext-sse2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_BGRX_RED
+%define RGB_GREEN  EXT_BGRX_GREEN
+%define RGB_BLUE  EXT_BGRX_BLUE
+%define RGB_PIXELSIZE  EXT_BGRX_PIXELSIZE
+%define jsimd_ycc_rgb_convert_sse2  jsimd_ycc_extbgrx_convert_sse2
+%include "jdcolext-sse2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_XBGR_RED
+%define RGB_GREEN  EXT_XBGR_GREEN
+%define RGB_BLUE  EXT_XBGR_BLUE
+%define RGB_PIXELSIZE  EXT_XBGR_PIXELSIZE
+%define jsimd_ycc_rgb_convert_sse2  jsimd_ycc_extxbgr_convert_sse2
+%include "jdcolext-sse2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_XRGB_RED
+%define RGB_GREEN  EXT_XRGB_GREEN
+%define RGB_BLUE  EXT_XRGB_BLUE
+%define RGB_PIXELSIZE  EXT_XRGB_PIXELSIZE
+%define jsimd_ycc_rgb_convert_sse2  jsimd_ycc_extxrgb_convert_sse2
+%include "jdcolext-sse2.asm"
diff --git a/3rdparty/libjpeg/src/simd/i386/jdmerge-avx2.asm b/3rdparty/libjpeg/src/simd/i386/jdmerge-avx2.asm
new file mode 100644
index 00000000..711e6792
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/i386/jdmerge-avx2.asm
@@ -0,0 +1,136 @@
+;
+; jdmerge.asm - merged upsampling/color conversion (AVX2)
+;
+; Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+; Copyright (C) 2009, 2016, D. R. Commander.
+; Copyright (C) 2015, Intel Corporation.
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+;
+; This file should be assembled with NASM (Netwide Assembler),
+; can *not* be assembled with Microsoft's MASM or any compatible
+; assembler (including Borland's Turbo Assembler).
+; NASM is available from http://nasm.sourceforge.net/ or
+; http://sourceforge.net/project/showfiles.php?group_id=6208
+
+%include "jsimdext.inc"
+
+; --------------------------------------------------------------------------
+
+%define SCALEBITS  16
+
+F_0_344 equ  22554              ; FIX(0.34414)
+F_0_714 equ  46802              ; FIX(0.71414)
+F_1_402 equ  91881              ; FIX(1.40200)
+F_1_772 equ 116130              ; FIX(1.77200)
+F_0_402 equ (F_1_402 - 65536)   ; FIX(1.40200) - FIX(1)
+F_0_285 equ ( 65536 - F_0_714)  ; FIX(1) - FIX(0.71414)
+F_0_228 equ (131072 - F_1_772)  ; FIX(2) - FIX(1.77200)
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_CONST
+
+    alignz      32
+    GLOBAL_DATA(jconst_merged_upsample_avx2)
+
+EXTN(jconst_merged_upsample_avx2):
+
+PW_F0402        times 16 dw  F_0_402
+PW_MF0228       times 16 dw -F_0_228
+PW_MF0344_F0285 times 8  dw -F_0_344, F_0_285
+PW_ONE          times 16 dw  1
+PD_ONEHALF      times 8  dd  1 << (SCALEBITS - 1)
+
+    alignz      32
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_TEXT
+    BITS        32
+
+%include "jdmrgext-avx2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_RGB_RED
+%define RGB_GREEN  EXT_RGB_GREEN
+%define RGB_BLUE  EXT_RGB_BLUE
+%define RGB_PIXELSIZE  EXT_RGB_PIXELSIZE
+%define jsimd_h2v1_merged_upsample_avx2 \
+  jsimd_h2v1_extrgb_merged_upsample_avx2
+%define jsimd_h2v2_merged_upsample_avx2 \
+  jsimd_h2v2_extrgb_merged_upsample_avx2
+%include "jdmrgext-avx2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_RGBX_RED
+%define RGB_GREEN  EXT_RGBX_GREEN
+%define RGB_BLUE  EXT_RGBX_BLUE
+%define RGB_PIXELSIZE  EXT_RGBX_PIXELSIZE
+%define jsimd_h2v1_merged_upsample_avx2 \
+  jsimd_h2v1_extrgbx_merged_upsample_avx2
+%define jsimd_h2v2_merged_upsample_avx2 \
+  jsimd_h2v2_extrgbx_merged_upsample_avx2
+%include "jdmrgext-avx2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_BGR_RED
+%define RGB_GREEN  EXT_BGR_GREEN
+%define RGB_BLUE  EXT_BGR_BLUE
+%define RGB_PIXELSIZE  EXT_BGR_PIXELSIZE
+%define jsimd_h2v1_merged_upsample_avx2 \
+  jsimd_h2v1_extbgr_merged_upsample_avx2
+%define jsimd_h2v2_merged_upsample_avx2 \
+  jsimd_h2v2_extbgr_merged_upsample_avx2
+%include "jdmrgext-avx2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_BGRX_RED
+%define RGB_GREEN  EXT_BGRX_GREEN
+%define RGB_BLUE  EXT_BGRX_BLUE
+%define RGB_PIXELSIZE  EXT_BGRX_PIXELSIZE
+%define jsimd_h2v1_merged_upsample_avx2 \
+  jsimd_h2v1_extbgrx_merged_upsample_avx2
+%define jsimd_h2v2_merged_upsample_avx2 \
+  jsimd_h2v2_extbgrx_merged_upsample_avx2
+%include "jdmrgext-avx2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_XBGR_RED
+%define RGB_GREEN  EXT_XBGR_GREEN
+%define RGB_BLUE  EXT_XBGR_BLUE
+%define RGB_PIXELSIZE  EXT_XBGR_PIXELSIZE
+%define jsimd_h2v1_merged_upsample_avx2 \
+  jsimd_h2v1_extxbgr_merged_upsample_avx2
+%define jsimd_h2v2_merged_upsample_avx2 \
+  jsimd_h2v2_extxbgr_merged_upsample_avx2
+%include "jdmrgext-avx2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_XRGB_RED
+%define RGB_GREEN  EXT_XRGB_GREEN
+%define RGB_BLUE  EXT_XRGB_BLUE
+%define RGB_PIXELSIZE  EXT_XRGB_PIXELSIZE
+%define jsimd_h2v1_merged_upsample_avx2 \
+  jsimd_h2v1_extxrgb_merged_upsample_avx2
+%define jsimd_h2v2_merged_upsample_avx2 \
+  jsimd_h2v2_extxrgb_merged_upsample_avx2
+%include "jdmrgext-avx2.asm"
diff --git a/3rdparty/libjpeg/src/simd/i386/jdmerge-mmx.asm b/3rdparty/libjpeg/src/simd/i386/jdmerge-mmx.asm
new file mode 100644
index 00000000..6e8311d4
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/i386/jdmerge-mmx.asm
@@ -0,0 +1,123 @@
+;
+; jdmerge.asm - merged upsampling/color conversion (MMX)
+;
+; Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+; Copyright (C) 2009, 2016, D. R. Commander.
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+;
+; This file should be assembled with NASM (Netwide Assembler),
+; can *not* be assembled with Microsoft's MASM or any compatible
+; assembler (including Borland's Turbo Assembler).
+; NASM is available from http://nasm.sourceforge.net/ or
+; http://sourceforge.net/project/showfiles.php?group_id=6208
+
+%include "jsimdext.inc"
+
+; --------------------------------------------------------------------------
+
+%define SCALEBITS  16
+
+F_0_344 equ  22554              ; FIX(0.34414)
+F_0_714 equ  46802              ; FIX(0.71414)
+F_1_402 equ  91881              ; FIX(1.40200)
+F_1_772 equ 116130              ; FIX(1.77200)
+F_0_402 equ (F_1_402 - 65536)   ; FIX(1.40200) - FIX(1)
+F_0_285 equ ( 65536 - F_0_714)  ; FIX(1) - FIX(0.71414)
+F_0_228 equ (131072 - F_1_772)  ; FIX(2) - FIX(1.77200)
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_CONST
+
+    alignz      32
+    GLOBAL_DATA(jconst_merged_upsample_mmx)
+
+EXTN(jconst_merged_upsample_mmx):
+
+PW_F0402        times 4 dw  F_0_402
+PW_MF0228       times 4 dw -F_0_228
+PW_MF0344_F0285 times 2 dw -F_0_344, F_0_285
+PW_ONE          times 4 dw  1
+PD_ONEHALF      times 2 dd  1 << (SCALEBITS - 1)
+
+    alignz      32
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_TEXT
+    BITS        32
+
+%include "jdmrgext-mmx.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_RGB_RED
+%define RGB_GREEN  EXT_RGB_GREEN
+%define RGB_BLUE  EXT_RGB_BLUE
+%define RGB_PIXELSIZE  EXT_RGB_PIXELSIZE
+%define jsimd_h2v1_merged_upsample_mmx  jsimd_h2v1_extrgb_merged_upsample_mmx
+%define jsimd_h2v2_merged_upsample_mmx  jsimd_h2v2_extrgb_merged_upsample_mmx
+%include "jdmrgext-mmx.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_RGBX_RED
+%define RGB_GREEN  EXT_RGBX_GREEN
+%define RGB_BLUE  EXT_RGBX_BLUE
+%define RGB_PIXELSIZE  EXT_RGBX_PIXELSIZE
+%define jsimd_h2v1_merged_upsample_mmx  jsimd_h2v1_extrgbx_merged_upsample_mmx
+%define jsimd_h2v2_merged_upsample_mmx  jsimd_h2v2_extrgbx_merged_upsample_mmx
+%include "jdmrgext-mmx.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_BGR_RED
+%define RGB_GREEN  EXT_BGR_GREEN
+%define RGB_BLUE  EXT_BGR_BLUE
+%define RGB_PIXELSIZE  EXT_BGR_PIXELSIZE
+%define jsimd_h2v1_merged_upsample_mmx  jsimd_h2v1_extbgr_merged_upsample_mmx
+%define jsimd_h2v2_merged_upsample_mmx  jsimd_h2v2_extbgr_merged_upsample_mmx
+%include "jdmrgext-mmx.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_BGRX_RED
+%define RGB_GREEN  EXT_BGRX_GREEN
+%define RGB_BLUE  EXT_BGRX_BLUE
+%define RGB_PIXELSIZE  EXT_BGRX_PIXELSIZE
+%define jsimd_h2v1_merged_upsample_mmx  jsimd_h2v1_extbgrx_merged_upsample_mmx
+%define jsimd_h2v2_merged_upsample_mmx  jsimd_h2v2_extbgrx_merged_upsample_mmx
+%include "jdmrgext-mmx.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_XBGR_RED
+%define RGB_GREEN  EXT_XBGR_GREEN
+%define RGB_BLUE  EXT_XBGR_BLUE
+%define RGB_PIXELSIZE  EXT_XBGR_PIXELSIZE
+%define jsimd_h2v1_merged_upsample_mmx  jsimd_h2v1_extxbgr_merged_upsample_mmx
+%define jsimd_h2v2_merged_upsample_mmx  jsimd_h2v2_extxbgr_merged_upsample_mmx
+%include "jdmrgext-mmx.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_XRGB_RED
+%define RGB_GREEN  EXT_XRGB_GREEN
+%define RGB_BLUE  EXT_XRGB_BLUE
+%define RGB_PIXELSIZE  EXT_XRGB_PIXELSIZE
+%define jsimd_h2v1_merged_upsample_mmx  jsimd_h2v1_extxrgb_merged_upsample_mmx
+%define jsimd_h2v2_merged_upsample_mmx  jsimd_h2v2_extxrgb_merged_upsample_mmx
+%include "jdmrgext-mmx.asm"
diff --git a/3rdparty/libjpeg/src/simd/i386/jdmerge-sse2.asm b/3rdparty/libjpeg/src/simd/i386/jdmerge-sse2.asm
new file mode 100644
index 00000000..e32f90aa
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/i386/jdmerge-sse2.asm
@@ -0,0 +1,135 @@
+;
+; jdmerge.asm - merged upsampling/color conversion (SSE2)
+;
+; Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+; Copyright (C) 2009, 2016, D. R. Commander.
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+;
+; This file should be assembled with NASM (Netwide Assembler),
+; can *not* be assembled with Microsoft's MASM or any compatible
+; assembler (including Borland's Turbo Assembler).
+; NASM is available from http://nasm.sourceforge.net/ or
+; http://sourceforge.net/project/showfiles.php?group_id=6208
+
+%include "jsimdext.inc"
+
+; --------------------------------------------------------------------------
+
+%define SCALEBITS  16
+
+F_0_344 equ  22554              ; FIX(0.34414)
+F_0_714 equ  46802              ; FIX(0.71414)
+F_1_402 equ  91881              ; FIX(1.40200)
+F_1_772 equ 116130              ; FIX(1.77200)
+F_0_402 equ (F_1_402 - 65536)   ; FIX(1.40200) - FIX(1)
+F_0_285 equ ( 65536 - F_0_714)  ; FIX(1) - FIX(0.71414)
+F_0_228 equ (131072 - F_1_772)  ; FIX(2) - FIX(1.77200)
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_CONST
+
+    alignz      32
+    GLOBAL_DATA(jconst_merged_upsample_sse2)
+
+EXTN(jconst_merged_upsample_sse2):
+
+PW_F0402        times 8 dw  F_0_402
+PW_MF0228       times 8 dw -F_0_228
+PW_MF0344_F0285 times 4 dw -F_0_344, F_0_285
+PW_ONE          times 8 dw  1
+PD_ONEHALF      times 4 dd  1 << (SCALEBITS - 1)
+
+    alignz      32
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_TEXT
+    BITS        32
+
+%include "jdmrgext-sse2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_RGB_RED
+%define RGB_GREEN  EXT_RGB_GREEN
+%define RGB_BLUE  EXT_RGB_BLUE
+%define RGB_PIXELSIZE  EXT_RGB_PIXELSIZE
+%define jsimd_h2v1_merged_upsample_sse2 \
+  jsimd_h2v1_extrgb_merged_upsample_sse2
+%define jsimd_h2v2_merged_upsample_sse2 \
+  jsimd_h2v2_extrgb_merged_upsample_sse2
+%include "jdmrgext-sse2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_RGBX_RED
+%define RGB_GREEN  EXT_RGBX_GREEN
+%define RGB_BLUE  EXT_RGBX_BLUE
+%define RGB_PIXELSIZE  EXT_RGBX_PIXELSIZE
+%define jsimd_h2v1_merged_upsample_sse2 \
+  jsimd_h2v1_extrgbx_merged_upsample_sse2
+%define jsimd_h2v2_merged_upsample_sse2 \
+  jsimd_h2v2_extrgbx_merged_upsample_sse2
+%include "jdmrgext-sse2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_BGR_RED
+%define RGB_GREEN  EXT_BGR_GREEN
+%define RGB_BLUE  EXT_BGR_BLUE
+%define RGB_PIXELSIZE  EXT_BGR_PIXELSIZE
+%define jsimd_h2v1_merged_upsample_sse2 \
+  jsimd_h2v1_extbgr_merged_upsample_sse2
+%define jsimd_h2v2_merged_upsample_sse2 \
+  jsimd_h2v2_extbgr_merged_upsample_sse2
+%include "jdmrgext-sse2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_BGRX_RED
+%define RGB_GREEN  EXT_BGRX_GREEN
+%define RGB_BLUE  EXT_BGRX_BLUE
+%define RGB_PIXELSIZE  EXT_BGRX_PIXELSIZE
+%define jsimd_h2v1_merged_upsample_sse2 \
+  jsimd_h2v1_extbgrx_merged_upsample_sse2
+%define jsimd_h2v2_merged_upsample_sse2 \
+  jsimd_h2v2_extbgrx_merged_upsample_sse2
+%include "jdmrgext-sse2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_XBGR_RED
+%define RGB_GREEN  EXT_XBGR_GREEN
+%define RGB_BLUE  EXT_XBGR_BLUE
+%define RGB_PIXELSIZE  EXT_XBGR_PIXELSIZE
+%define jsimd_h2v1_merged_upsample_sse2 \
+  jsimd_h2v1_extxbgr_merged_upsample_sse2
+%define jsimd_h2v2_merged_upsample_sse2 \
+  jsimd_h2v2_extxbgr_merged_upsample_sse2
+%include "jdmrgext-sse2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_XRGB_RED
+%define RGB_GREEN  EXT_XRGB_GREEN
+%define RGB_BLUE  EXT_XRGB_BLUE
+%define RGB_PIXELSIZE  EXT_XRGB_PIXELSIZE
+%define jsimd_h2v1_merged_upsample_sse2 \
+  jsimd_h2v1_extxrgb_merged_upsample_sse2
+%define jsimd_h2v2_merged_upsample_sse2 \
+  jsimd_h2v2_extxrgb_merged_upsample_sse2
+%include "jdmrgext-sse2.asm"
diff --git a/3rdparty/libjpeg/src/simd/i386/jdmrgext-avx2.asm b/3rdparty/libjpeg/src/simd/i386/jdmrgext-avx2.asm
new file mode 100644
index 00000000..e35f7282
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/i386/jdmrgext-avx2.asm
@@ -0,0 +1,575 @@
+;
+; jdmrgext.asm - merged upsampling/color conversion (AVX2)
+;
+; Copyright 2009, 2012 Pierre Ossman <ossman@cendio.se> for Cendio AB
+; Copyright (C) 2012, 2016, D. R. Commander.
+; Copyright (C) 2015, Intel Corporation.
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+;
+; This file should be assembled with NASM (Netwide Assembler),
+; can *not* be assembled with Microsoft's MASM or any compatible
+; assembler (including Borland's Turbo Assembler).
+; NASM is available from http://nasm.sourceforge.net/ or
+; http://sourceforge.net/project/showfiles.php?group_id=6208
+
+%include "jcolsamp.inc"
+
+; --------------------------------------------------------------------------
+;
+; Upsample and color convert for the case of 2:1 horizontal and 1:1 vertical.
+;
+; GLOBAL(void)
+; jsimd_h2v1_merged_upsample_avx2(JDIMENSION output_width,
+;                                 JSAMPIMAGE input_buf,
+;                                 JDIMENSION in_row_group_ctr,
+;                                 JSAMPARRAY output_buf);
+;
+
+%define output_width(b)      (b) + 8    ; JDIMENSION output_width
+%define input_buf(b)         (b) + 12   ; JSAMPIMAGE input_buf
+%define in_row_group_ctr(b)  (b) + 16   ; JDIMENSION in_row_group_ctr
+%define output_buf(b)        (b) + 20   ; JSAMPARRAY output_buf
+
+%define original_ebp  ebp + 0
+%define wk(i)         ebp - (WK_NUM - (i)) * SIZEOF_YMMWORD
+                                        ; ymmword wk[WK_NUM]
+%define WK_NUM        3
+%define gotptr        wk(0) - SIZEOF_POINTER  ; void * gotptr
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_h2v1_merged_upsample_avx2)
+
+EXTN(jsimd_h2v1_merged_upsample_avx2):
+    push        ebp
+    mov         eax, esp                     ; eax = original ebp
+    sub         esp, byte 4
+    and         esp, byte (-SIZEOF_YMMWORD)  ; align to 256 bits
+    mov         [esp], eax
+    mov         ebp, esp                     ; ebp = aligned ebp
+    lea         esp, [wk(0)]
+    pushpic     eax                     ; make a room for GOT address
+    push        ebx
+;   push        ecx                     ; need not be preserved
+;   push        edx                     ; need not be preserved
+    push        esi
+    push        edi
+
+    get_GOT     ebx                     ; get GOT address
+    movpic      POINTER [gotptr], ebx   ; save GOT address
+
+    mov         ecx, JDIMENSION [output_width(eax)]  ; col
+    test        ecx, ecx
+    jz          near .return
+
+    push        ecx
+
+    mov         edi, JSAMPIMAGE [input_buf(eax)]
+    mov         ecx, JDIMENSION [in_row_group_ctr(eax)]
+    mov         esi, JSAMPARRAY [edi+0*SIZEOF_JSAMPARRAY]
+    mov         ebx, JSAMPARRAY [edi+1*SIZEOF_JSAMPARRAY]
+    mov         edx, JSAMPARRAY [edi+2*SIZEOF_JSAMPARRAY]
+    mov         edi, JSAMPARRAY [output_buf(eax)]
+    mov         esi, JSAMPROW [esi+ecx*SIZEOF_JSAMPROW]  ; inptr0
+    mov         ebx, JSAMPROW [ebx+ecx*SIZEOF_JSAMPROW]  ; inptr1
+    mov         edx, JSAMPROW [edx+ecx*SIZEOF_JSAMPROW]  ; inptr2
+    mov         edi, JSAMPROW [edi]                      ; outptr
+
+    pop         ecx                     ; col
+
+    alignx      16, 7
+.columnloop:
+    movpic      eax, POINTER [gotptr]   ; load GOT address (eax)
+
+    vmovdqu     ymm6, YMMWORD [ebx]     ; ymm6=Cb(0123456789ABCDEFGHIJKLMNOPQRSTUV)
+    vmovdqu     ymm7, YMMWORD [edx]     ; ymm7=Cr(0123456789ABCDEFGHIJKLMNOPQRSTUV)
+
+    vpxor       ymm1, ymm1, ymm1        ; ymm1=(all 0's)
+    vpcmpeqw    ymm3, ymm3, ymm3
+    vpsllw      ymm3, ymm3, 7           ; ymm3={0xFF80 0xFF80 0xFF80 0xFF80 ..}
+
+    vpermq      ymm6, ymm6, 0xd8        ; ymm6=Cb(01234567GHIJKLMN89ABCDEFOPQRSTUV)
+    vpermq      ymm7, ymm7, 0xd8        ; ymm7=Cr(01234567GHIJKLMN89ABCDEFOPQRSTUV)
+    vpunpcklbw  ymm4, ymm6, ymm1        ; ymm4=Cb(0123456789ABCDEF)=CbL
+    vpunpckhbw  ymm6, ymm6, ymm1        ; ymm6=Cb(GHIJKLMNOPQRSTUV)=CbH
+    vpunpcklbw  ymm0, ymm7, ymm1        ; ymm0=Cr(0123456789ABCDEF)=CrL
+    vpunpckhbw  ymm7, ymm7, ymm1        ; ymm7=Cr(GHIJKLMNOPQRSTUV)=CrH
+
+    vpaddw      ymm5, ymm6, ymm3
+    vpaddw      ymm2, ymm4, ymm3
+    vpaddw      ymm1, ymm7, ymm3
+    vpaddw      ymm3, ymm0, ymm3
+
+    ; (Original)
+    ; R = Y                + 1.40200 * Cr
+    ; G = Y - 0.34414 * Cb - 0.71414 * Cr
+    ; B = Y + 1.77200 * Cb
+    ;
+    ; (This implementation)
+    ; R = Y                + 0.40200 * Cr + Cr
+    ; G = Y - 0.34414 * Cb + 0.28586 * Cr - Cr
+    ; B = Y - 0.22800 * Cb + Cb + Cb
+
+    vpaddw      ymm6, ymm5, ymm5             ; ymm6=2*CbH
+    vpaddw      ymm4, ymm2, ymm2             ; ymm4=2*CbL
+    vpaddw      ymm7, ymm1, ymm1             ; ymm7=2*CrH
+    vpaddw      ymm0, ymm3, ymm3             ; ymm0=2*CrL
+
+    vpmulhw     ymm6, ymm6, [GOTOFF(eax,PW_MF0228)]  ; ymm6=(2*CbH * -FIX(0.22800))
+    vpmulhw     ymm4, ymm4, [GOTOFF(eax,PW_MF0228)]  ; ymm4=(2*CbL * -FIX(0.22800))
+    vpmulhw     ymm7, ymm7, [GOTOFF(eax,PW_F0402)]   ; ymm7=(2*CrH * FIX(0.40200))
+    vpmulhw     ymm0, ymm0, [GOTOFF(eax,PW_F0402)]   ; ymm0=(2*CrL * FIX(0.40200))
+
+    vpaddw      ymm6, ymm6, [GOTOFF(eax,PW_ONE)]
+    vpaddw      ymm4, ymm4, [GOTOFF(eax,PW_ONE)]
+    vpsraw      ymm6, ymm6, 1                     ; ymm6=(CbH * -FIX(0.22800))
+    vpsraw      ymm4, ymm4, 1                     ; ymm4=(CbL * -FIX(0.22800))
+    vpaddw      ymm7, ymm7, [GOTOFF(eax,PW_ONE)]
+    vpaddw      ymm0, ymm0, [GOTOFF(eax,PW_ONE)]
+    vpsraw      ymm7, ymm7, 1                     ; ymm7=(CrH * FIX(0.40200))
+    vpsraw      ymm0, ymm0, 1                     ; ymm0=(CrL * FIX(0.40200))
+
+    vpaddw      ymm6, ymm6, ymm5
+    vpaddw      ymm4, ymm4, ymm2
+    vpaddw      ymm6, ymm6, ymm5                  ; ymm6=(CbH * FIX(1.77200))=(B-Y)H
+    vpaddw      ymm4, ymm4, ymm2                  ; ymm4=(CbL * FIX(1.77200))=(B-Y)L
+    vpaddw      ymm7, ymm7, ymm1                  ; ymm7=(CrH * FIX(1.40200))=(R-Y)H
+    vpaddw      ymm0, ymm0, ymm3                  ; ymm0=(CrL * FIX(1.40200))=(R-Y)L
+
+    vmovdqa     YMMWORD [wk(0)], ymm6             ; wk(0)=(B-Y)H
+    vmovdqa     YMMWORD [wk(1)], ymm7             ; wk(1)=(R-Y)H
+
+    vpunpckhwd  ymm6, ymm5, ymm1
+    vpunpcklwd  ymm5, ymm5, ymm1
+    vpmaddwd    ymm5, ymm5, [GOTOFF(eax,PW_MF0344_F0285)]
+    vpmaddwd    ymm6, ymm6, [GOTOFF(eax,PW_MF0344_F0285)]
+    vpunpckhwd  ymm7, ymm2, ymm3
+    vpunpcklwd  ymm2, ymm2, ymm3
+    vpmaddwd    ymm2, ymm2, [GOTOFF(eax,PW_MF0344_F0285)]
+    vpmaddwd    ymm7, ymm7, [GOTOFF(eax,PW_MF0344_F0285)]
+
+    vpaddd      ymm5, ymm5, [GOTOFF(eax,PD_ONEHALF)]
+    vpaddd      ymm6, ymm6, [GOTOFF(eax,PD_ONEHALF)]
+    vpsrad      ymm5, ymm5, SCALEBITS
+    vpsrad      ymm6, ymm6, SCALEBITS
+    vpaddd      ymm2, ymm2, [GOTOFF(eax,PD_ONEHALF)]
+    vpaddd      ymm7, ymm7, [GOTOFF(eax,PD_ONEHALF)]
+    vpsrad      ymm2, ymm2, SCALEBITS
+    vpsrad      ymm7, ymm7, SCALEBITS
+
+    vpackssdw   ymm5, ymm5, ymm6        ; ymm5=CbH*-FIX(0.344)+CrH*FIX(0.285)
+    vpackssdw   ymm2, ymm2, ymm7        ; ymm2=CbL*-FIX(0.344)+CrL*FIX(0.285)
+    vpsubw      ymm5, ymm5, ymm1        ; ymm5=CbH*-FIX(0.344)+CrH*-FIX(0.714)=(G-Y)H
+    vpsubw      ymm2, ymm2, ymm3        ; ymm2=CbL*-FIX(0.344)+CrL*-FIX(0.714)=(G-Y)L
+
+    vmovdqa     YMMWORD [wk(2)], ymm5   ; wk(2)=(G-Y)H
+
+    mov         al, 2                   ; Yctr
+    jmp         short .Yloop_1st
+    alignx      16, 7
+
+.Yloop_2nd:
+    vmovdqa     ymm0, YMMWORD [wk(1)]   ; ymm0=(R-Y)H
+    vmovdqa     ymm2, YMMWORD [wk(2)]   ; ymm2=(G-Y)H
+    vmovdqa     ymm4, YMMWORD [wk(0)]   ; ymm4=(B-Y)H
+    alignx      16, 7
+
+.Yloop_1st:
+    vmovdqu     ymm7, YMMWORD [esi]     ; ymm7=Y(0123456789ABCDEFGHIJKLMNOPQRSTUV)
+
+    vpcmpeqw    ymm6, ymm6, ymm6
+    vpsrlw      ymm6, ymm6, BYTE_BIT    ; ymm6={0xFF 0x00 0xFF 0x00 ..}
+    vpand       ymm6, ymm6, ymm7        ; ymm6=Y(02468ACEGIKMOQSU)=YE
+    vpsrlw      ymm7, ymm7, BYTE_BIT    ; ymm7=Y(13579BDFHJLNPRTV)=YO
+
+    vmovdqa     ymm1, ymm0              ; ymm1=ymm0=(R-Y)(L/H)
+    vmovdqa     ymm3, ymm2              ; ymm3=ymm2=(G-Y)(L/H)
+    vmovdqa     ymm5, ymm4              ; ymm5=ymm4=(B-Y)(L/H)
+
+    vpaddw      ymm0, ymm0, ymm6        ; ymm0=((R-Y)+YE)=RE=R(02468ACEGIKMOQSU)
+    vpaddw      ymm1, ymm1, ymm7        ; ymm1=((R-Y)+YO)=RO=R(13579BDFHJLNPRTV)
+    vpackuswb   ymm0, ymm0, ymm0        ; ymm0=R(02468ACE********GIKMOQSU********)
+    vpackuswb   ymm1, ymm1, ymm1        ; ymm1=R(13579BDF********HJLNPRTV********)
+
+    vpaddw      ymm2, ymm2, ymm6        ; ymm2=((G-Y)+YE)=GE=G(02468ACEGIKMOQSU)
+    vpaddw      ymm3, ymm3, ymm7        ; ymm3=((G-Y)+YO)=GO=G(13579BDFHJLNPRTV)
+    vpackuswb   ymm2, ymm2, ymm2        ; ymm2=G(02468ACE********GIKMOQSU********)
+    vpackuswb   ymm3, ymm3, ymm3        ; ymm3=G(13579BDF********HJLNPRTV********)
+
+    vpaddw      ymm4, ymm4, ymm6        ; ymm4=((B-Y)+YE)=BE=B(02468ACEGIKMOQSU)
+    vpaddw      ymm5, ymm5, ymm7        ; ymm5=((B-Y)+YO)=BO=B(13579BDFHJLNPRTV)
+    vpackuswb   ymm4, ymm4, ymm4        ; ymm4=B(02468ACE********GIKMOQSU********)
+    vpackuswb   ymm5, ymm5, ymm5        ; ymm5=B(13579BDF********HJLNPRTV********)
+
+%if RGB_PIXELSIZE == 3  ; ---------------
+
+    ; ymmA=(00 02 04 06 08 0A 0C 0E ** 0G 0I 0K 0M 0O 0Q 0S 0U **)
+    ; ymmB=(01 03 05 07 09 0B 0D 0F ** 0H 0J 0L 0N 0P 0R 0T 0V **)
+    ; ymmC=(10 12 14 16 18 1A 1C 1E ** 1G 1I 1K 1M 1O 1Q 1S 1U **)
+    ; ymmD=(11 13 15 17 19 1B 1D 1F ** 1H 1J 1L 1N 1P 1R 1T 1V **)
+    ; ymmE=(20 22 24 26 28 2A 2C 2E ** 2G 2I 2K 2M 2O 2Q 2S 2U **)
+    ; ymmF=(21 23 25 27 29 2B 2D 2F ** 2H 2J 2L 2N 2P 2R 2T 2V **)
+    ; ymmG=(** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** **)
+    ; ymmH=(** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** **)
+
+    vpunpcklbw  ymmA, ymmA, ymmC        ; ymmA=(00 10 02 12 04 14 06 16 08 18 0A 1A 0C 1C 0E 1E
+                                        ;       0G 1G 0I 1I 0K 1K 0M 1M 0O 1O 0Q 1Q 0S 1S 0U 1U)
+    vpunpcklbw  ymmE, ymmE, ymmB        ; ymmE=(20 01 22 03 24 05 26 07 28 09 2A 0B 2C 0D 2E 0F
+                                        ;       2G 0H 2I 0J 2K 0L 2M 0N 2O 0P 2Q 0R 2S 0T 2U 0V)
+    vpunpcklbw  ymmD, ymmD, ymmF        ; ymmD=(11 21 13 23 15 25 17 27 19 29 1B 2B 1D 2D 1F 2F
+                                        ;       1H 2H 1J 2J 1L 2L 1N 2N 1P 2P 1R 2R 1T 2T 1V 2V)
+
+    vpsrldq     ymmH, ymmA, 2           ; ymmH=(02 12 04 14 06 16 08 18 0A 1A 0C 1C 0E 1E 0G 1G
+                                        ;       0I 1I 0K 1K 0M 1M 0O 1O 0Q 1Q 0S 1S 0U 1U -- --)
+    vpunpckhwd  ymmG, ymmA, ymmE        ; ymmG=(08 18 28 09 0A 1A 2A 0B 0C 1C 2C 0D 0E 1E 2E 0F
+                                        ;       0O 1O 2O 0P 0Q 1Q 2Q 0R 0S 1S 2S 0T 0U 1U 2U 0V)
+    vpunpcklwd  ymmA, ymmA, ymmE        ; ymmA=(00 10 20 01 02 12 22 03 04 14 24 05 06 16 26 07
+                                        ;       0G 1G 2G 0H 0I 1I 2I 0J 0K 1K 2K 0L 0M 1M 2M 0N)
+
+    vpsrldq     ymmE, ymmE, 2           ; ymmE=(22 03 24 05 26 07 28 09 2A 0B 2C 0D 2E 0F 2G 0H
+                                        ;       2I 0J 2K 0L 2M 0N 2O 0P 2Q 0R 2S 0T 2U 0V -- --)
+
+    vpsrldq     ymmB, ymmD, 2           ; ymmB=(13 23 15 25 17 27 19 29 1B 2B 1D 2D 1F 2F 1H 2H
+                                        ;       1J 2J 1L 2L 1N 2N 1P 2P 1R 2R 1T 2T 1V 2V -- --)
+    vpunpckhwd  ymmC, ymmD, ymmH        ; ymmC=(19 29 0A 1A 1B 2B 0C 1C 1D 2D 0E 1E 1F 2F 0G 1G
+                                        ;       1P 2P 0Q 1Q 1R 2R 0S 1S 1T 2T 0U 1U 1V 2V -- --)
+    vpunpcklwd  ymmD, ymmD, ymmH        ; ymmD=(11 21 02 12 13 23 04 14 15 25 06 16 17 27 08 18
+                                        ;       1H 2H 0I 1I 1J 2J 0K 1K 1L 2L 0M 1M 1N 2N 0O 1O)
+
+    vpunpckhwd  ymmF, ymmE, ymmB        ; ymmF=(2A 0B 1B 2B 2C 0D 1D 2D 2E 0F 1F 2F 2G 0H 1H 2H
+                                        ;       2Q 0R 1R 2R 2S 0T 1T 2T 2U 0V 1V 2V -- -- -- --)
+    vpunpcklwd  ymmE, ymmE, ymmB        ; ymmE=(22 03 13 23 24 05 15 25 26 07 17 27 28 09 19 29
+                                        ;       2I 0J 1J 2J 2K 0L 1L 2L 2M 0N 1N 2N 2O 0P 1P 2P)
+
+    vpshufd     ymmH, ymmA, 0x4E        ; ymmH=(04 14 24 05 06 16 26 07 00 10 20 01 02 12 22 03
+                                        ;       0K 1K 2K 0L 0M 1M 2M 0N 0G 1G 2G 0H 0I 1I 2I 0J)
+    vpunpckldq  ymmA, ymmA, ymmD        ; ymmA=(00 10 20 01 11 21 02 12 02 12 22 03 13 23 04 14
+                                        ;       0G 1G 2G 0H 1H 2H 0I 1I 0I 1I 2I 0J 1J 2J 0K 1K)
+    vpunpckhdq  ymmD, ymmD, ymmE        ; ymmD=(15 25 06 16 26 07 17 27 17 27 08 18 28 09 19 29
+                                        ;       1L 2L 0M 1M 2M 0N 1N 2N 1N 2N 0O 1O 2O 0P 1P 2P)
+    vpunpckldq  ymmE, ymmE, ymmH        ; ymmE=(22 03 13 23 04 14 24 05 24 05 15 25 06 16 26 07
+                                        ;       2I 0J 1J 2J 0K 1K 2K 0L 2K 0L 1L 2L 0M 1M 2M 0N)
+
+    vpshufd     ymmH, ymmG, 0x4E        ; ymmH=(0C 1C 2C 0D 0E 1E 2E 0F 08 18 28 09 0A 1A 2A 0B
+                                        ;       0S 1S 2S 0T 0U 1U 2U 0V 0O 1O 2O 0P 0Q 1Q 2Q 0R)
+    vpunpckldq  ymmG, ymmG, ymmC        ; ymmG=(08 18 28 09 19 29 0A 1A 0A 1A 2A 0B 1B 2B 0C 1C
+                                        ;       0O 1O 2O 0P 1P 2P 0Q 1Q 0Q 1Q 2Q 0R 1R 2R 0S 1S)
+    vpunpckhdq  ymmC, ymmC, ymmF        ; ymmC=(1D 2D 0E 1E 2E 0F 1F 2F 1F 2F 0G 1G 2G 0H 1H 2H
+                                        ;       1T 2T 0U 1U 2U 0V 1V 2V 1V 2V -- -- -- -- -- --)
+    vpunpckldq  ymmF, ymmF, ymmH        ; ymmF=(2A 0B 1B 2B 0C 1C 2C 0D 2C 0D 1D 2D 0E 1E 2E 0F
+                                        ;       2Q 0R 1R 2R 0S 1S 2S 0T 2S 0T 1T 2T 0U 1U 2U 0V)
+
+    vpunpcklqdq ymmH, ymmA, ymmE        ; ymmH=(00 10 20 01 11 21 02 12 22 03 13 23 04 14 24 05
+                                        ;       0G 1G 2G 0H 1H 2H 0I 1I 2I 0J 1J 2J 0K 1K 2K 0L)
+    vpunpcklqdq ymmG, ymmD, ymmG        ; ymmG=(15 25 06 16 26 07 17 27 08 18 28 09 19 29 0A 1A
+                                        ;       1L 2L 0M 1M 2M 0N 1N 2N 0O 1O 2O 0P 1P 2P 0Q 1Q)
+    vpunpcklqdq ymmC, ymmF, ymmC        ; ymmC=(2A 0B 1B 2B 0C 1C 2C 0D 1D 2D 0E 1E 2E 0F 1F 2F
+                                        ;       2Q 0R 1R 2R 0S 1S 2S 0T 1T 2T 0U 1U 2U 0V 1V 2V)
+
+    vperm2i128  ymmA, ymmH, ymmG, 0x20  ; ymmA=(00 10 20 01 11 21 02 12 22 03 13 23 04 14 24 05
+                                        ;       15 25 06 16 26 07 17 27 08 18 28 09 19 29 0A 1A)
+    vperm2i128  ymmD, ymmC, ymmH, 0x30  ; ymmD=(2A 0B 1B 2B 0C 1C 2C 0D 1D 2D 0E 1E 2E 0F 1F 2F
+                                        ;       0G 1G 2G 0H 1H 2H 0I 1I 2I 0J 1J 2J 0K 1K 2K 0L)
+    vperm2i128  ymmF, ymmG, ymmC, 0x31  ; ymmF=(1L 2L 0M 1M 2M 0N 1N 2N 0O 1O 2O 0P 1P 2P 0Q 1Q
+                                        ;       2Q 0R 1R 2R 0S 1S 2S 0T 1T 2T 0U 1U 2U 0V 1V 2V)
+
+    cmp         ecx, byte SIZEOF_YMMWORD
+    jb          short .column_st64
+
+    test        edi, SIZEOF_YMMWORD-1
+    jnz         short .out1
+    ; --(aligned)-------------------
+    vmovntdq    YMMWORD [edi+0*SIZEOF_YMMWORD], ymmA
+    vmovntdq    YMMWORD [edi+1*SIZEOF_YMMWORD], ymmD
+    vmovntdq    YMMWORD [edi+2*SIZEOF_YMMWORD], ymmF
+    jmp         short .out0
+.out1:  ; --(unaligned)-----------------
+    vmovdqu     YMMWORD [edi+0*SIZEOF_YMMWORD], ymmA
+    vmovdqu     YMMWORD [edi+1*SIZEOF_YMMWORD], ymmD
+    vmovdqu     YMMWORD [edi+2*SIZEOF_YMMWORD], ymmF
+.out0:
+    add         edi, byte RGB_PIXELSIZE*SIZEOF_YMMWORD  ; outptr
+    sub         ecx, byte SIZEOF_YMMWORD
+    jz          near .endcolumn
+
+    add         esi, byte SIZEOF_YMMWORD  ; inptr0
+    dec         al                        ; Yctr
+    jnz         near .Yloop_2nd
+
+    add         ebx, byte SIZEOF_YMMWORD  ; inptr1
+    add         edx, byte SIZEOF_YMMWORD  ; inptr2
+    jmp         near .columnloop
+    alignx      16, 7
+
+.column_st64:
+    lea         ecx, [ecx+ecx*2]            ; imul ecx, RGB_PIXELSIZE
+    cmp         ecx, byte 2*SIZEOF_YMMWORD
+    jb          short .column_st32
+    vmovdqu     YMMWORD [edi+0*SIZEOF_YMMWORD], ymmA
+    vmovdqu     YMMWORD [edi+1*SIZEOF_YMMWORD], ymmD
+    add         edi, byte 2*SIZEOF_YMMWORD  ; outptr
+    vmovdqa     ymmA, ymmF
+    sub         ecx, byte 2*SIZEOF_YMMWORD
+    jmp         short .column_st31
+.column_st32:
+    cmp         ecx, byte SIZEOF_YMMWORD
+    jb          short .column_st31
+    vmovdqu     YMMWORD [edi+0*SIZEOF_YMMWORD], ymmA
+    add         edi, byte SIZEOF_YMMWORD    ; outptr
+    vmovdqa     ymmA, ymmD
+    sub         ecx, byte SIZEOF_YMMWORD
+    jmp         short .column_st31
+.column_st31:
+    cmp         ecx, byte SIZEOF_XMMWORD
+    jb          short .column_st15
+    vmovdqu     XMMWORD [edi+0*SIZEOF_XMMWORD], xmmA
+    add         edi, byte SIZEOF_XMMWORD    ; outptr
+    vperm2i128  ymmA, ymmA, ymmA, 1
+    sub         ecx, byte SIZEOF_XMMWORD
+.column_st15:
+    ; Store the lower 8 bytes of xmmA to the output when it has enough
+    ; space.
+    cmp         ecx, byte SIZEOF_MMWORD
+    jb          short .column_st7
+    vmovq       XMM_MMWORD [edi], xmmA
+    add         edi, byte SIZEOF_MMWORD
+    sub         ecx, byte SIZEOF_MMWORD
+    vpsrldq     xmmA, xmmA, SIZEOF_MMWORD
+.column_st7:
+    ; Store the lower 4 bytes of xmmA to the output when it has enough
+    ; space.
+    cmp         ecx, byte SIZEOF_DWORD
+    jb          short .column_st3
+    vmovd       XMM_DWORD [edi], xmmA
+    add         edi, byte SIZEOF_DWORD
+    sub         ecx, byte SIZEOF_DWORD
+    vpsrldq     xmmA, xmmA, SIZEOF_DWORD
+.column_st3:
+    ; Store the lower 2 bytes of eax to the output when it has enough
+    ; space.
+    vmovd       eax, xmmA
+    cmp         ecx, byte SIZEOF_WORD
+    jb          short .column_st1
+    mov         word [edi], ax
+    add         edi, byte SIZEOF_WORD
+    sub         ecx, byte SIZEOF_WORD
+    shr         eax, 16
+.column_st1:
+    ; Store the lower 1 byte of eax to the output when it has enough
+    ; space.
+    test        ecx, ecx
+    jz          short .endcolumn
+    mov         byte [edi], al
+
+%else  ; RGB_PIXELSIZE == 4 ; -----------
+
+%ifdef RGBX_FILLER_0XFF
+    vpcmpeqb    ymm6, ymm6, ymm6        ; ymm6=XE=X(02468ACE********GIKMOQSU********)
+    vpcmpeqb    ymm7, ymm7, ymm7        ; ymm7=XO=X(13579BDF********HJLNPRTV********)
+%else
+    vpxor       ymm6, ymm6, ymm6        ; ymm6=XE=X(02468ACE********GIKMOQSU********)
+    vpxor       ymm7, ymm7, ymm7        ; ymm7=XO=X(13579BDF********HJLNPRTV********)
+%endif
+    ; ymmA=(00 02 04 06 08 0A 0C 0E ** 0G 0I 0K 0M 0O 0Q 0S 0U **)
+    ; ymmB=(01 03 05 07 09 0B 0D 0F ** 0H 0J 0L 0N 0P 0R 0T 0V **)
+    ; ymmC=(10 12 14 16 18 1A 1C 1E ** 1G 1I 1K 1M 1O 1Q 1S 1U **)
+    ; ymmD=(11 13 15 17 19 1B 1D 1F ** 1H 1J 1L 1N 1P 1R 1T 1V **)
+    ; ymmE=(20 22 24 26 28 2A 2C 2E ** 2G 2I 2K 2M 2O 2Q 2S 2U **)
+    ; ymmF=(21 23 25 27 29 2B 2D 2F ** 2H 2J 2L 2N 2P 2R 2T 2V **)
+    ; ymmG=(30 32 34 36 38 3A 3C 3E ** 3G 3I 3K 3M 3O 3Q 3S 3U **)
+    ; ymmH=(31 33 35 37 39 3B 3D 3F ** 3H 3J 3L 3N 3P 3R 3T 3V **)
+
+    vpunpcklbw  ymmA, ymmA, ymmC        ; ymmA=(00 10 02 12 04 14 06 16 08 18 0A 1A 0C 1C 0E 1E
+                                        ;       0G 1G 0I 1I 0K 1K 0M 1M 0O 1O 0Q 1Q 0S 1S 0U 1U)
+    vpunpcklbw  ymmE, ymmE, ymmG        ; ymmE=(20 30 22 32 24 34 26 36 28 38 2A 3A 2C 3C 2E 3E
+                                        ;       2G 3G 2I 3I 2K 3K 2M 3M 2O 3O 2Q 3Q 2S 3S 2U 3U)
+    vpunpcklbw  ymmB, ymmB, ymmD        ; ymmB=(01 11 03 13 05 15 07 17 09 19 0B 1B 0D 1D 0F 1F
+                                        ;       0H 1H 0J 1J 0L 1L 0N 1N 0P 1P 0R 1R 0T 1T 0V 1V)
+    vpunpcklbw  ymmF, ymmF, ymmH        ; ymmF=(21 31 23 33 25 35 27 37 29 39 2B 3B 2D 3D 2F 3F
+                                        ;       2H 3H 2J 3J 2L 3L 2N 3N 2P 3P 2R 3R 2T 3T 2V 3V)
+
+    vpunpckhwd  ymmC, ymmA, ymmE        ; ymmC=(08 18 28 38 0A 1A 2A 3A 0C 1C 2C 3C 0E 1E 2E 3E
+                                        ;       0O 1O 2O 3O 0Q 1Q 2Q 3Q 0S 1S 2S 3S 0U 1U 2U 3U)
+    vpunpcklwd  ymmA, ymmA, ymmE        ; ymmA=(00 10 20 30 02 12 22 32 04 14 24 34 06 16 26 36
+                                        ;       0G 1G 2G 3G 0I 1I 2I 3I 0K 1K 2K 3K 0M 1M 2M 3M)
+    vpunpckhwd  ymmG, ymmB, ymmF        ; ymmG=(09 19 29 39 0B 1B 2B 3B 0D 1D 2D 3D 0F 1F 2F 3F
+                                        ;       0P 1P 2P 3P 0R 1R 2R 3R 0T 1T 2T 3T 0V 1V 2V 3V)
+    vpunpcklwd  ymmB, ymmB, ymmF        ; ymmB=(01 11 21 31 03 13 23 33 05 15 25 35 07 17 27 37
+                                        ;       0H 1H 2H 3H 0J 1J 2J 3J 0L 1L 2L 3L 0N 1N 2N 3N)
+
+    vpunpckhdq  ymmE, ymmA, ymmB        ; ymmE=(04 14 24 34 05 15 25 35 06 16 26 36 07 17 27 37
+                                        ;       0K 1K 2K 3K 0L 1L 2L 3L 0M 1M 2M 3M 0N 1N 2N 3N)
+    vpunpckldq  ymmB, ymmA, ymmB        ; ymmB=(00 10 20 30 01 11 21 31 02 12 22 32 03 13 23 33
+                                        ;       0G 1G 2G 3G 0H 1H 2H 3H 0I 1I 2I 3I 0J 1J 2J 3J)
+    vpunpckhdq  ymmF, ymmC, ymmG        ; ymmF=(0C 1C 2C 3C 0D 1D 2D 3D 0E 1E 2E 3E 0F 1F 2F 3F
+                                        ;       0S 1S 2S 3S 0T 1T 2T 3T 0U 1U 2U 3U 0V 1V 2V 3V)
+    vpunpckldq  ymmG, ymmC, ymmG        ; ymmG=(08 18 28 38 09 19 29 39 0A 1A 2A 3A 0B 1B 2B 3B
+                                        ;       0O 1O 2O 3O 0P 1P 2P 3P 0Q 1Q 2Q 3Q 0R 1R 2R 3R)
+
+    vperm2i128  ymmA, ymmB, ymmE, 0x20  ; ymmA=(00 10 20 30 01 11 21 31 02 12 22 32 03 13 23 33
+                                        ;       04 14 24 34 05 15 25 35 06 16 26 36 07 17 27 37)
+    vperm2i128  ymmD, ymmG, ymmF, 0x20  ; ymmD=(08 18 28 38 09 19 29 39 0A 1A 2A 3A 0B 1B 2B 3B
+                                        ;       0C 1C 2C 3C 0D 1D 2D 3D 0E 1E 2E 3E 0F 1F 2F 3F)
+    vperm2i128  ymmC, ymmB, ymmE, 0x31  ; ymmC=(0G 1G 2G 3G 0H 1H 2H 3H 0I 1I 2I 3I 0J 1J 2J 3J
+                                        ;       0K 1K 2K 3K 0L 1L 2L 3L 0M 1M 2M 3M 0N 1N 2N 3N)
+    vperm2i128  ymmH, ymmG, ymmF, 0x31  ; ymmH=(0O 1O 2O 3O 0P 1P 2P 3P 0Q 1Q 2Q 3Q 0R 1R 2R 3R
+                                        ;       0S 1S 2S 3S 0T 1T 2T 3T 0U 1U 2U 3U 0V 1V 2V 3V)
+
+    cmp         ecx, byte SIZEOF_YMMWORD
+    jb          short .column_st64
+
+    test        edi, SIZEOF_YMMWORD-1
+    jnz         short .out1
+    ; --(aligned)-------------------
+    vmovntdq    YMMWORD [edi+0*SIZEOF_YMMWORD], ymmA
+    vmovntdq    YMMWORD [edi+1*SIZEOF_YMMWORD], ymmD
+    vmovntdq    YMMWORD [edi+2*SIZEOF_YMMWORD], ymmC
+    vmovntdq    YMMWORD [edi+3*SIZEOF_YMMWORD], ymmH
+    jmp         short .out0
+.out1:  ; --(unaligned)-----------------
+    vmovdqu     YMMWORD [edi+0*SIZEOF_YMMWORD], ymmA
+    vmovdqu     YMMWORD [edi+1*SIZEOF_YMMWORD], ymmD
+    vmovdqu     YMMWORD [edi+2*SIZEOF_YMMWORD], ymmC
+    vmovdqu     YMMWORD [edi+3*SIZEOF_YMMWORD], ymmH
+.out0:
+    add         edi, RGB_PIXELSIZE*SIZEOF_YMMWORD  ; outptr
+    sub         ecx, byte SIZEOF_YMMWORD
+    jz          near .endcolumn
+
+    add         esi, byte SIZEOF_YMMWORD  ; inptr0
+    dec         al
+    jnz         near .Yloop_2nd
+
+    add         ebx, byte SIZEOF_YMMWORD  ; inptr1
+    add         edx, byte SIZEOF_YMMWORD  ; inptr2
+    jmp         near .columnloop
+    alignx      16, 7
+
+.column_st64:
+    cmp         ecx, byte SIZEOF_YMMWORD/2
+    jb          short .column_st32
+    vmovdqu     YMMWORD [edi+0*SIZEOF_YMMWORD], ymmA
+    vmovdqu     YMMWORD [edi+1*SIZEOF_YMMWORD], ymmD
+    add         edi, byte 2*SIZEOF_YMMWORD  ; outptr
+    vmovdqa     ymmA, ymmC
+    vmovdqa     ymmD, ymmH
+    sub         ecx, byte SIZEOF_YMMWORD/2
+.column_st32:
+    cmp         ecx, byte SIZEOF_YMMWORD/4
+    jb          short .column_st16
+    vmovdqu     YMMWORD [edi+0*SIZEOF_YMMWORD], ymmA
+    add         edi, byte SIZEOF_YMMWORD    ; outptr
+    vmovdqa     ymmA, ymmD
+    sub         ecx, byte SIZEOF_YMMWORD/4
+.column_st16:
+    cmp         ecx, byte SIZEOF_YMMWORD/8
+    jb          short .column_st15
+    vmovdqu     XMMWORD [edi+0*SIZEOF_XMMWORD], xmmA
+    add         edi, byte SIZEOF_XMMWORD    ; outptr
+    vperm2i128  ymmA, ymmA, ymmA, 1
+    sub         ecx, byte SIZEOF_YMMWORD/8
+.column_st15:
+    ; Store two pixels (8 bytes) of ymmA to the output when it has enough
+    ; space.
+    cmp         ecx, byte SIZEOF_YMMWORD/16
+    jb          short .column_st7
+    vmovq       MMWORD [edi], xmmA
+    add         edi, byte SIZEOF_YMMWORD/16*4
+    sub         ecx, byte SIZEOF_YMMWORD/16
+    vpsrldq     xmmA, SIZEOF_YMMWORD/16*4
+.column_st7:
+    ; Store one pixel (4 bytes) of ymmA to the output when it has enough
+    ; space.
+    test        ecx, ecx
+    jz          short .endcolumn
+    vmovd       XMM_DWORD [edi], xmmA
+
+%endif  ; RGB_PIXELSIZE ; ---------------
+
+.endcolumn:
+    sfence                              ; flush the write buffer
+
+.return:
+    vzeroupper
+    pop         edi
+    pop         esi
+;   pop         edx                     ; need not be preserved
+;   pop         ecx                     ; need not be preserved
+    pop         ebx
+    mov         esp, ebp                ; esp <- aligned ebp
+    pop         esp                     ; esp <- original ebp
+    pop         ebp
+    ret
+
+; --------------------------------------------------------------------------
+;
+; Upsample and color convert for the case of 2:1 horizontal and 2:1 vertical.
+;
+; GLOBAL(void)
+; jsimd_h2v2_merged_upsample_avx2(JDIMENSION output_width,
+;                                 JSAMPIMAGE input_buf,
+;                                 JDIMENSION in_row_group_ctr,
+;                                 JSAMPARRAY output_buf);
+;
+
+%define output_width(b)      (b) + 8    ; JDIMENSION output_width
+%define input_buf(b)         (b) + 12   ; JSAMPIMAGE input_buf
+%define in_row_group_ctr(b)  (b) + 16   ; JDIMENSION in_row_group_ctr
+%define output_buf(b)        (b) + 20   ; JSAMPARRAY output_buf
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_h2v2_merged_upsample_avx2)
+
+EXTN(jsimd_h2v2_merged_upsample_avx2):
+    push        ebp
+    mov         ebp, esp
+    push        ebx
+;   push        ecx                     ; need not be preserved
+;   push        edx                     ; need not be preserved
+    push        esi
+    push        edi
+
+    mov         eax, POINTER [output_width(ebp)]
+
+    mov         edi, JSAMPIMAGE [input_buf(ebp)]
+    mov         ecx, JDIMENSION [in_row_group_ctr(ebp)]
+    mov         esi, JSAMPARRAY [edi+0*SIZEOF_JSAMPARRAY]
+    mov         ebx, JSAMPARRAY [edi+1*SIZEOF_JSAMPARRAY]
+    mov         edx, JSAMPARRAY [edi+2*SIZEOF_JSAMPARRAY]
+    mov         edi, JSAMPARRAY [output_buf(ebp)]
+    lea         esi, [esi+ecx*SIZEOF_JSAMPROW]
+
+    push        edx                     ; inptr2
+    push        ebx                     ; inptr1
+    push        esi                     ; inptr00
+    mov         ebx, esp
+
+    push        edi                     ; output_buf (outptr0)
+    push        ecx                     ; in_row_group_ctr
+    push        ebx                     ; input_buf
+    push        eax                     ; output_width
+
+    call        near EXTN(jsimd_h2v1_merged_upsample_avx2)
+
+    add         esi, byte SIZEOF_JSAMPROW  ; inptr01
+    add         edi, byte SIZEOF_JSAMPROW  ; outptr1
+    mov         POINTER [ebx+0*SIZEOF_POINTER], esi
+    mov         POINTER [ebx-1*SIZEOF_POINTER], edi
+
+    call        near EXTN(jsimd_h2v1_merged_upsample_avx2)
+
+    add         esp, byte 7*SIZEOF_DWORD
+
+    pop         edi
+    pop         esi
+;   pop         edx                     ; need not be preserved
+;   pop         ecx                     ; need not be preserved
+    pop         ebx
+    pop         ebp
+    ret
+
+; For some reason, the OS X linker does not honor the request to align the
+; segment unless we do this.
+    align       32
diff --git a/3rdparty/libjpeg/src/simd/i386/jdmrgext-mmx.asm b/3rdparty/libjpeg/src/simd/i386/jdmrgext-mmx.asm
new file mode 100644
index 00000000..eb3e36b4
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/i386/jdmrgext-mmx.asm
@@ -0,0 +1,460 @@
+;
+; jdmrgext.asm - merged upsampling/color conversion (MMX)
+;
+; Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+; Copyright (C) 2016, D. R. Commander.
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+;
+; This file should be assembled with NASM (Netwide Assembler),
+; can *not* be assembled with Microsoft's MASM or any compatible
+; assembler (including Borland's Turbo Assembler).
+; NASM is available from http://nasm.sourceforge.net/ or
+; http://sourceforge.net/project/showfiles.php?group_id=6208
+
+%include "jcolsamp.inc"
+
+; --------------------------------------------------------------------------
+;
+; Upsample and color convert for the case of 2:1 horizontal and 1:1 vertical.
+;
+; GLOBAL(void)
+; jsimd_h2v1_merged_upsample_mmx(JDIMENSION output_width, JSAMPIMAGE input_buf,
+;                                JDIMENSION in_row_group_ctr,
+;                                JSAMPARRAY output_buf);
+;
+
+%define output_width(b)      (b) + 8    ; JDIMENSION output_width
+%define input_buf(b)         (b) + 12   ; JSAMPIMAGE input_buf
+%define in_row_group_ctr(b)  (b) + 16   ; JDIMENSION in_row_group_ctr
+%define output_buf(b)        (b) + 20   ; JSAMPARRAY output_buf
+
+%define original_ebp  ebp + 0
+%define wk(i)         ebp - (WK_NUM - (i)) * SIZEOF_MMWORD  ; mmword wk[WK_NUM]
+%define WK_NUM        3
+%define gotptr        wk(0) - SIZEOF_POINTER  ; void * gotptr
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_h2v1_merged_upsample_mmx)
+
+EXTN(jsimd_h2v1_merged_upsample_mmx):
+    push        ebp
+    mov         eax, esp                    ; eax = original ebp
+    sub         esp, byte 4
+    and         esp, byte (-SIZEOF_MMWORD)  ; align to 64 bits
+    mov         [esp], eax
+    mov         ebp, esp                    ; ebp = aligned ebp
+    lea         esp, [wk(0)]
+    pushpic     eax                     ; make a room for GOT address
+    push        ebx
+;   push        ecx                     ; need not be preserved
+;   push        edx                     ; need not be preserved
+    push        esi
+    push        edi
+
+    get_GOT     ebx                     ; get GOT address
+    movpic      POINTER [gotptr], ebx   ; save GOT address
+
+    mov         ecx, JDIMENSION [output_width(eax)]  ; col
+    test        ecx, ecx
+    jz          near .return
+
+    push        ecx
+
+    mov         edi, JSAMPIMAGE [input_buf(eax)]
+    mov         ecx, JDIMENSION [in_row_group_ctr(eax)]
+    mov         esi, JSAMPARRAY [edi+0*SIZEOF_JSAMPARRAY]
+    mov         ebx, JSAMPARRAY [edi+1*SIZEOF_JSAMPARRAY]
+    mov         edx, JSAMPARRAY [edi+2*SIZEOF_JSAMPARRAY]
+    mov         edi, JSAMPARRAY [output_buf(eax)]
+    mov         esi, JSAMPROW [esi+ecx*SIZEOF_JSAMPROW]  ; inptr0
+    mov         ebx, JSAMPROW [ebx+ecx*SIZEOF_JSAMPROW]  ; inptr1
+    mov         edx, JSAMPROW [edx+ecx*SIZEOF_JSAMPROW]  ; inptr2
+    mov         edi, JSAMPROW [edi]                      ; outptr
+
+    pop         ecx                     ; col
+
+    alignx      16, 7
+.columnloop:
+    movpic      eax, POINTER [gotptr]   ; load GOT address (eax)
+
+    movq        mm6, MMWORD [ebx]       ; mm6=Cb(01234567)
+    movq        mm7, MMWORD [edx]       ; mm7=Cr(01234567)
+
+    pxor        mm1, mm1                ; mm1=(all 0's)
+    pcmpeqw     mm3, mm3
+    psllw       mm3, 7                  ; mm3={0xFF80 0xFF80 0xFF80 0xFF80}
+
+    movq        mm4, mm6
+    punpckhbw   mm6, mm1                ; mm6=Cb(4567)=CbH
+    punpcklbw   mm4, mm1                ; mm4=Cb(0123)=CbL
+    movq        mm0, mm7
+    punpckhbw   mm7, mm1                ; mm7=Cr(4567)=CrH
+    punpcklbw   mm0, mm1                ; mm0=Cr(0123)=CrL
+
+    paddw       mm6, mm3
+    paddw       mm4, mm3
+    paddw       mm7, mm3
+    paddw       mm0, mm3
+
+    ; (Original)
+    ; R = Y                + 1.40200 * Cr
+    ; G = Y - 0.34414 * Cb - 0.71414 * Cr
+    ; B = Y + 1.77200 * Cb
+    ;
+    ; (This implementation)
+    ; R = Y                + 0.40200 * Cr + Cr
+    ; G = Y - 0.34414 * Cb + 0.28586 * Cr - Cr
+    ; B = Y - 0.22800 * Cb + Cb + Cb
+
+    movq        mm5, mm6                ; mm5=CbH
+    movq        mm2, mm4                ; mm2=CbL
+    paddw       mm6, mm6                ; mm6=2*CbH
+    paddw       mm4, mm4                ; mm4=2*CbL
+    movq        mm1, mm7                ; mm1=CrH
+    movq        mm3, mm0                ; mm3=CrL
+    paddw       mm7, mm7                ; mm7=2*CrH
+    paddw       mm0, mm0                ; mm0=2*CrL
+
+    pmulhw      mm6, [GOTOFF(eax,PW_MF0228)]  ; mm6=(2*CbH * -FIX(0.22800))
+    pmulhw      mm4, [GOTOFF(eax,PW_MF0228)]  ; mm4=(2*CbL * -FIX(0.22800))
+    pmulhw      mm7, [GOTOFF(eax,PW_F0402)]   ; mm7=(2*CrH * FIX(0.40200))
+    pmulhw      mm0, [GOTOFF(eax,PW_F0402)]   ; mm0=(2*CrL * FIX(0.40200))
+
+    paddw       mm6, [GOTOFF(eax,PW_ONE)]
+    paddw       mm4, [GOTOFF(eax,PW_ONE)]
+    psraw       mm6, 1                  ; mm6=(CbH * -FIX(0.22800))
+    psraw       mm4, 1                  ; mm4=(CbL * -FIX(0.22800))
+    paddw       mm7, [GOTOFF(eax,PW_ONE)]
+    paddw       mm0, [GOTOFF(eax,PW_ONE)]
+    psraw       mm7, 1                  ; mm7=(CrH * FIX(0.40200))
+    psraw       mm0, 1                  ; mm0=(CrL * FIX(0.40200))
+
+    paddw       mm6, mm5
+    paddw       mm4, mm2
+    paddw       mm6, mm5                ; mm6=(CbH * FIX(1.77200))=(B-Y)H
+    paddw       mm4, mm2                ; mm4=(CbL * FIX(1.77200))=(B-Y)L
+    paddw       mm7, mm1                ; mm7=(CrH * FIX(1.40200))=(R-Y)H
+    paddw       mm0, mm3                ; mm0=(CrL * FIX(1.40200))=(R-Y)L
+
+    movq        MMWORD [wk(0)], mm6     ; wk(0)=(B-Y)H
+    movq        MMWORD [wk(1)], mm7     ; wk(1)=(R-Y)H
+
+    movq        mm6, mm5
+    movq        mm7, mm2
+    punpcklwd   mm5, mm1
+    punpckhwd   mm6, mm1
+    pmaddwd     mm5, [GOTOFF(eax,PW_MF0344_F0285)]
+    pmaddwd     mm6, [GOTOFF(eax,PW_MF0344_F0285)]
+    punpcklwd   mm2, mm3
+    punpckhwd   mm7, mm3
+    pmaddwd     mm2, [GOTOFF(eax,PW_MF0344_F0285)]
+    pmaddwd     mm7, [GOTOFF(eax,PW_MF0344_F0285)]
+
+    paddd       mm5, [GOTOFF(eax,PD_ONEHALF)]
+    paddd       mm6, [GOTOFF(eax,PD_ONEHALF)]
+    psrad       mm5, SCALEBITS
+    psrad       mm6, SCALEBITS
+    paddd       mm2, [GOTOFF(eax,PD_ONEHALF)]
+    paddd       mm7, [GOTOFF(eax,PD_ONEHALF)]
+    psrad       mm2, SCALEBITS
+    psrad       mm7, SCALEBITS
+
+    packssdw    mm5, mm6                ; mm5=CbH*-FIX(0.344)+CrH*FIX(0.285)
+    packssdw    mm2, mm7                ; mm2=CbL*-FIX(0.344)+CrL*FIX(0.285)
+    psubw       mm5, mm1                ; mm5=CbH*-FIX(0.344)+CrH*-FIX(0.714)=(G-Y)H
+    psubw       mm2, mm3                ; mm2=CbL*-FIX(0.344)+CrL*-FIX(0.714)=(G-Y)L
+
+    movq        MMWORD [wk(2)], mm5     ; wk(2)=(G-Y)H
+
+    mov         al, 2                   ; Yctr
+    jmp         short .Yloop_1st
+    alignx      16, 7
+
+.Yloop_2nd:
+    movq        mm0, MMWORD [wk(1)]     ; mm0=(R-Y)H
+    movq        mm2, MMWORD [wk(2)]     ; mm2=(G-Y)H
+    movq        mm4, MMWORD [wk(0)]     ; mm4=(B-Y)H
+    alignx      16, 7
+
+.Yloop_1st:
+    movq        mm7, MMWORD [esi]       ; mm7=Y(01234567)
+
+    pcmpeqw     mm6, mm6
+    psrlw       mm6, BYTE_BIT           ; mm6={0xFF 0x00 0xFF 0x00 ..}
+    pand        mm6, mm7                ; mm6=Y(0246)=YE
+    psrlw       mm7, BYTE_BIT           ; mm7=Y(1357)=YO
+
+    movq        mm1, mm0                ; mm1=mm0=(R-Y)(L/H)
+    movq        mm3, mm2                ; mm3=mm2=(G-Y)(L/H)
+    movq        mm5, mm4                ; mm5=mm4=(B-Y)(L/H)
+
+    paddw       mm0, mm6                ; mm0=((R-Y)+YE)=RE=(R0 R2 R4 R6)
+    paddw       mm1, mm7                ; mm1=((R-Y)+YO)=RO=(R1 R3 R5 R7)
+    packuswb    mm0, mm0                ; mm0=(R0 R2 R4 R6 ** ** ** **)
+    packuswb    mm1, mm1                ; mm1=(R1 R3 R5 R7 ** ** ** **)
+
+    paddw       mm2, mm6                ; mm2=((G-Y)+YE)=GE=(G0 G2 G4 G6)
+    paddw       mm3, mm7                ; mm3=((G-Y)+YO)=GO=(G1 G3 G5 G7)
+    packuswb    mm2, mm2                ; mm2=(G0 G2 G4 G6 ** ** ** **)
+    packuswb    mm3, mm3                ; mm3=(G1 G3 G5 G7 ** ** ** **)
+
+    paddw       mm4, mm6                ; mm4=((B-Y)+YE)=BE=(B0 B2 B4 B6)
+    paddw       mm5, mm7                ; mm5=((B-Y)+YO)=BO=(B1 B3 B5 B7)
+    packuswb    mm4, mm4                ; mm4=(B0 B2 B4 B6 ** ** ** **)
+    packuswb    mm5, mm5                ; mm5=(B1 B3 B5 B7 ** ** ** **)
+
+%if RGB_PIXELSIZE == 3  ; ---------------
+
+    ; mmA=(00 02 04 06 ** ** ** **), mmB=(01 03 05 07 ** ** ** **)
+    ; mmC=(10 12 14 16 ** ** ** **), mmD=(11 13 15 17 ** ** ** **)
+    ; mmE=(20 22 24 26 ** ** ** **), mmF=(21 23 25 27 ** ** ** **)
+    ; mmG=(** ** ** ** ** ** ** **), mmH=(** ** ** ** ** ** ** **)
+
+    punpcklbw   mmA, mmC                ; mmA=(00 10 02 12 04 14 06 16)
+    punpcklbw   mmE, mmB                ; mmE=(20 01 22 03 24 05 26 07)
+    punpcklbw   mmD, mmF                ; mmD=(11 21 13 23 15 25 17 27)
+
+    movq        mmG, mmA
+    movq        mmH, mmA
+    punpcklwd   mmA, mmE                ; mmA=(00 10 20 01 02 12 22 03)
+    punpckhwd   mmG, mmE                ; mmG=(04 14 24 05 06 16 26 07)
+
+    psrlq       mmH, 2*BYTE_BIT         ; mmH=(02 12 04 14 06 16 -- --)
+    psrlq       mmE, 2*BYTE_BIT         ; mmE=(22 03 24 05 26 07 -- --)
+
+    movq        mmC, mmD
+    movq        mmB, mmD
+    punpcklwd   mmD, mmH                ; mmD=(11 21 02 12 13 23 04 14)
+    punpckhwd   mmC, mmH                ; mmC=(15 25 06 16 17 27 -- --)
+
+    psrlq       mmB, 2*BYTE_BIT         ; mmB=(13 23 15 25 17 27 -- --)
+
+    movq        mmF, mmE
+    punpcklwd   mmE, mmB                ; mmE=(22 03 13 23 24 05 15 25)
+    punpckhwd   mmF, mmB                ; mmF=(26 07 17 27 -- -- -- --)
+
+    punpckldq   mmA, mmD                ; mmA=(00 10 20 01 11 21 02 12)
+    punpckldq   mmE, mmG                ; mmE=(22 03 13 23 04 14 24 05)
+    punpckldq   mmC, mmF                ; mmC=(15 25 06 16 26 07 17 27)
+
+    cmp         ecx, byte SIZEOF_MMWORD
+    jb          short .column_st16
+
+    movq        MMWORD [edi+0*SIZEOF_MMWORD], mmA
+    movq        MMWORD [edi+1*SIZEOF_MMWORD], mmE
+    movq        MMWORD [edi+2*SIZEOF_MMWORD], mmC
+
+    sub         ecx, byte SIZEOF_MMWORD
+    jz          near .endcolumn
+
+    add         edi, byte RGB_PIXELSIZE*SIZEOF_MMWORD  ; outptr
+    add         esi, byte SIZEOF_MMWORD                ; inptr0
+    dec         al                                     ; Yctr
+    jnz         near .Yloop_2nd
+
+    add         ebx, byte SIZEOF_MMWORD                ; inptr1
+    add         edx, byte SIZEOF_MMWORD                ; inptr2
+    jmp         near .columnloop
+    alignx      16, 7
+
+.column_st16:
+    lea         ecx, [ecx+ecx*2]        ; imul ecx, RGB_PIXELSIZE
+    cmp         ecx, byte 2*SIZEOF_MMWORD
+    jb          short .column_st8
+    movq        MMWORD [edi+0*SIZEOF_MMWORD], mmA
+    movq        MMWORD [edi+1*SIZEOF_MMWORD], mmE
+    movq        mmA, mmC
+    sub         ecx, byte 2*SIZEOF_MMWORD
+    add         edi, byte 2*SIZEOF_MMWORD
+    jmp         short .column_st4
+.column_st8:
+    cmp         ecx, byte SIZEOF_MMWORD
+    jb          short .column_st4
+    movq        MMWORD [edi+0*SIZEOF_MMWORD], mmA
+    movq        mmA, mmE
+    sub         ecx, byte SIZEOF_MMWORD
+    add         edi, byte SIZEOF_MMWORD
+.column_st4:
+    movd        eax, mmA
+    cmp         ecx, byte SIZEOF_DWORD
+    jb          short .column_st2
+    mov         dword [edi+0*SIZEOF_DWORD], eax
+    psrlq       mmA, DWORD_BIT
+    movd        eax, mmA
+    sub         ecx, byte SIZEOF_DWORD
+    add         edi, byte SIZEOF_DWORD
+.column_st2:
+    cmp         ecx, byte SIZEOF_WORD
+    jb          short .column_st1
+    mov         word [edi+0*SIZEOF_WORD], ax
+    shr         eax, WORD_BIT
+    sub         ecx, byte SIZEOF_WORD
+    add         edi, byte SIZEOF_WORD
+.column_st1:
+    cmp         ecx, byte SIZEOF_BYTE
+    jb          short .endcolumn
+    mov         byte [edi+0*SIZEOF_BYTE], al
+
+%else  ; RGB_PIXELSIZE == 4 ; -----------
+
+%ifdef RGBX_FILLER_0XFF
+    pcmpeqb     mm6, mm6                ; mm6=(X0 X2 X4 X6 ** ** ** **)
+    pcmpeqb     mm7, mm7                ; mm7=(X1 X3 X5 X7 ** ** ** **)
+%else
+    pxor        mm6, mm6                ; mm6=(X0 X2 X4 X6 ** ** ** **)
+    pxor        mm7, mm7                ; mm7=(X1 X3 X5 X7 ** ** ** **)
+%endif
+    ; mmA=(00 02 04 06 ** ** ** **), mmB=(01 03 05 07 ** ** ** **)
+    ; mmC=(10 12 14 16 ** ** ** **), mmD=(11 13 15 17 ** ** ** **)
+    ; mmE=(20 22 24 26 ** ** ** **), mmF=(21 23 25 27 ** ** ** **)
+    ; mmG=(30 32 34 36 ** ** ** **), mmH=(31 33 35 37 ** ** ** **)
+
+    punpcklbw   mmA, mmC                ; mmA=(00 10 02 12 04 14 06 16)
+    punpcklbw   mmE, mmG                ; mmE=(20 30 22 32 24 34 26 36)
+    punpcklbw   mmB, mmD                ; mmB=(01 11 03 13 05 15 07 17)
+    punpcklbw   mmF, mmH                ; mmF=(21 31 23 33 25 35 27 37)
+
+    movq        mmC, mmA
+    punpcklwd   mmA, mmE                ; mmA=(00 10 20 30 02 12 22 32)
+    punpckhwd   mmC, mmE                ; mmC=(04 14 24 34 06 16 26 36)
+    movq        mmG, mmB
+    punpcklwd   mmB, mmF                ; mmB=(01 11 21 31 03 13 23 33)
+    punpckhwd   mmG, mmF                ; mmG=(05 15 25 35 07 17 27 37)
+
+    movq        mmD, mmA
+    punpckldq   mmA, mmB                ; mmA=(00 10 20 30 01 11 21 31)
+    punpckhdq   mmD, mmB                ; mmD=(02 12 22 32 03 13 23 33)
+    movq        mmH, mmC
+    punpckldq   mmC, mmG                ; mmC=(04 14 24 34 05 15 25 35)
+    punpckhdq   mmH, mmG                ; mmH=(06 16 26 36 07 17 27 37)
+
+    cmp         ecx, byte SIZEOF_MMWORD
+    jb          short .column_st16
+
+    movq        MMWORD [edi+0*SIZEOF_MMWORD], mmA
+    movq        MMWORD [edi+1*SIZEOF_MMWORD], mmD
+    movq        MMWORD [edi+2*SIZEOF_MMWORD], mmC
+    movq        MMWORD [edi+3*SIZEOF_MMWORD], mmH
+
+    sub         ecx, byte SIZEOF_MMWORD
+    jz          short .endcolumn
+
+    add         edi, byte RGB_PIXELSIZE*SIZEOF_MMWORD  ; outptr
+    add         esi, byte SIZEOF_MMWORD                ; inptr0
+    dec         al                                     ; Yctr
+    jnz         near .Yloop_2nd
+
+    add         ebx, byte SIZEOF_MMWORD                ; inptr1
+    add         edx, byte SIZEOF_MMWORD                ; inptr2
+    jmp         near .columnloop
+    alignx      16, 7
+
+.column_st16:
+    cmp         ecx, byte SIZEOF_MMWORD/2
+    jb          short .column_st8
+    movq        MMWORD [edi+0*SIZEOF_MMWORD], mmA
+    movq        MMWORD [edi+1*SIZEOF_MMWORD], mmD
+    movq        mmA, mmC
+    movq        mmD, mmH
+    sub         ecx, byte SIZEOF_MMWORD/2
+    add         edi, byte 2*SIZEOF_MMWORD
+.column_st8:
+    cmp         ecx, byte SIZEOF_MMWORD/4
+    jb          short .column_st4
+    movq        MMWORD [edi+0*SIZEOF_MMWORD], mmA
+    movq        mmA, mmD
+    sub         ecx, byte SIZEOF_MMWORD/4
+    add         edi, byte 1*SIZEOF_MMWORD
+.column_st4:
+    cmp         ecx, byte SIZEOF_MMWORD/8
+    jb          short .endcolumn
+    movd        dword [edi+0*SIZEOF_DWORD], mmA
+
+%endif  ; RGB_PIXELSIZE ; ---------------
+
+.endcolumn:
+    emms                                ; empty MMX state
+
+.return:
+    pop         edi
+    pop         esi
+;   pop         edx                     ; need not be preserved
+;   pop         ecx                     ; need not be preserved
+    pop         ebx
+    mov         esp, ebp                ; esp <- aligned ebp
+    pop         esp                     ; esp <- original ebp
+    pop         ebp
+    ret
+
+; --------------------------------------------------------------------------
+;
+; Upsample and color convert for the case of 2:1 horizontal and 2:1 vertical.
+;
+; GLOBAL(void)
+; jsimd_h2v2_merged_upsample_mmx(JDIMENSION output_width, JSAMPIMAGE input_buf,
+;                                JDIMENSION in_row_group_ctr,
+;                                JSAMPARRAY output_buf);
+;
+
+%define output_width(b)      (b) + 8    ; JDIMENSION output_width
+%define input_buf(b)         (b) + 12   ; JSAMPIMAGE input_buf
+%define in_row_group_ctr(b)  (b) + 16   ; JDIMENSION in_row_group_ctr
+%define output_buf(b)        (b) + 20   ; JSAMPARRAY output_buf
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_h2v2_merged_upsample_mmx)
+
+EXTN(jsimd_h2v2_merged_upsample_mmx):
+    push        ebp
+    mov         ebp, esp
+    push        ebx
+;   push        ecx                     ; need not be preserved
+;   push        edx                     ; need not be preserved
+    push        esi
+    push        edi
+
+    mov         eax, JDIMENSION [output_width(ebp)]
+
+    mov         edi, JSAMPIMAGE [input_buf(ebp)]
+    mov         ecx, JDIMENSION [in_row_group_ctr(ebp)]
+    mov         esi, JSAMPARRAY [edi+0*SIZEOF_JSAMPARRAY]
+    mov         ebx, JSAMPARRAY [edi+1*SIZEOF_JSAMPARRAY]
+    mov         edx, JSAMPARRAY [edi+2*SIZEOF_JSAMPARRAY]
+    mov         edi, JSAMPARRAY [output_buf(ebp)]
+    lea         esi, [esi+ecx*SIZEOF_JSAMPROW]
+
+    push        edx                     ; inptr2
+    push        ebx                     ; inptr1
+    push        esi                     ; inptr00
+    mov         ebx, esp
+
+    push        edi                     ; output_buf (outptr0)
+    push        ecx                     ; in_row_group_ctr
+    push        ebx                     ; input_buf
+    push        eax                     ; output_width
+
+    call        near EXTN(jsimd_h2v1_merged_upsample_mmx)
+
+    add         esi, byte SIZEOF_JSAMPROW  ; inptr01
+    add         edi, byte SIZEOF_JSAMPROW  ; outptr1
+    mov         POINTER [ebx+0*SIZEOF_POINTER], esi
+    mov         POINTER [ebx-1*SIZEOF_POINTER], edi
+
+    call        near EXTN(jsimd_h2v1_merged_upsample_mmx)
+
+    add         esp, byte 7*SIZEOF_DWORD
+
+    pop         edi
+    pop         esi
+;   pop         edx                     ; need not be preserved
+;   pop         ecx                     ; need not be preserved
+    pop         ebx
+    pop         ebp
+    ret
+
+; For some reason, the OS X linker does not honor the request to align the
+; segment unless we do this.
+    align       32
diff --git a/3rdparty/libjpeg/src/simd/i386/jdmrgext-sse2.asm b/3rdparty/libjpeg/src/simd/i386/jdmrgext-sse2.asm
new file mode 100644
index 00000000..c113dc4d
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/i386/jdmrgext-sse2.asm
@@ -0,0 +1,517 @@
+;
+; jdmrgext.asm - merged upsampling/color conversion (SSE2)
+;
+; Copyright 2009, 2012 Pierre Ossman <ossman@cendio.se> for Cendio AB
+; Copyright (C) 2012, 2016, D. R. Commander.
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+;
+; This file should be assembled with NASM (Netwide Assembler),
+; can *not* be assembled with Microsoft's MASM or any compatible
+; assembler (including Borland's Turbo Assembler).
+; NASM is available from http://nasm.sourceforge.net/ or
+; http://sourceforge.net/project/showfiles.php?group_id=6208
+
+%include "jcolsamp.inc"
+
+; --------------------------------------------------------------------------
+;
+; Upsample and color convert for the case of 2:1 horizontal and 1:1 vertical.
+;
+; GLOBAL(void)
+; jsimd_h2v1_merged_upsample_sse2(JDIMENSION output_width,
+;                                 JSAMPIMAGE input_buf,
+;                                 JDIMENSION in_row_group_ctr,
+;                                 JSAMPARRAY output_buf);
+;
+
+%define output_width(b)      (b) + 8    ; JDIMENSION output_width
+%define input_buf(b)         (b) + 12   ; JSAMPIMAGE input_buf
+%define in_row_group_ctr(b)  (b) + 16   ; JDIMENSION in_row_group_ctr
+%define output_buf(b)        (b) + 20   ; JSAMPARRAY output_buf
+
+%define original_ebp  ebp + 0
+%define wk(i)         ebp - (WK_NUM - (i)) * SIZEOF_XMMWORD
+                                        ; xmmword wk[WK_NUM]
+%define WK_NUM        3
+%define gotptr        wk(0) - SIZEOF_POINTER  ; void * gotptr
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_h2v1_merged_upsample_sse2)
+
+EXTN(jsimd_h2v1_merged_upsample_sse2):
+    push        ebp
+    mov         eax, esp                     ; eax = original ebp
+    sub         esp, byte 4
+    and         esp, byte (-SIZEOF_XMMWORD)  ; align to 128 bits
+    mov         [esp], eax
+    mov         ebp, esp                     ; ebp = aligned ebp
+    lea         esp, [wk(0)]
+    pushpic     eax                     ; make a room for GOT address
+    push        ebx
+;   push        ecx                     ; need not be preserved
+;   push        edx                     ; need not be preserved
+    push        esi
+    push        edi
+
+    get_GOT     ebx                     ; get GOT address
+    movpic      POINTER [gotptr], ebx   ; save GOT address
+
+    mov         ecx, JDIMENSION [output_width(eax)]  ; col
+    test        ecx, ecx
+    jz          near .return
+
+    push        ecx
+
+    mov         edi, JSAMPIMAGE [input_buf(eax)]
+    mov         ecx, JDIMENSION [in_row_group_ctr(eax)]
+    mov         esi, JSAMPARRAY [edi+0*SIZEOF_JSAMPARRAY]
+    mov         ebx, JSAMPARRAY [edi+1*SIZEOF_JSAMPARRAY]
+    mov         edx, JSAMPARRAY [edi+2*SIZEOF_JSAMPARRAY]
+    mov         edi, JSAMPARRAY [output_buf(eax)]
+    mov         esi, JSAMPROW [esi+ecx*SIZEOF_JSAMPROW]  ; inptr0
+    mov         ebx, JSAMPROW [ebx+ecx*SIZEOF_JSAMPROW]  ; inptr1
+    mov         edx, JSAMPROW [edx+ecx*SIZEOF_JSAMPROW]  ; inptr2
+    mov         edi, JSAMPROW [edi]                      ; outptr
+
+    pop         ecx                     ; col
+
+    alignx      16, 7
+.columnloop:
+    movpic      eax, POINTER [gotptr]   ; load GOT address (eax)
+
+    movdqa      xmm6, XMMWORD [ebx]     ; xmm6=Cb(0123456789ABCDEF)
+    movdqa      xmm7, XMMWORD [edx]     ; xmm7=Cr(0123456789ABCDEF)
+
+    pxor        xmm1, xmm1              ; xmm1=(all 0's)
+    pcmpeqw     xmm3, xmm3
+    psllw       xmm3, 7                 ; xmm3={0xFF80 0xFF80 0xFF80 0xFF80 ..}
+
+    movdqa      xmm4, xmm6
+    punpckhbw   xmm6, xmm1              ; xmm6=Cb(89ABCDEF)=CbH
+    punpcklbw   xmm4, xmm1              ; xmm4=Cb(01234567)=CbL
+    movdqa      xmm0, xmm7
+    punpckhbw   xmm7, xmm1              ; xmm7=Cr(89ABCDEF)=CrH
+    punpcklbw   xmm0, xmm1              ; xmm0=Cr(01234567)=CrL
+
+    paddw       xmm6, xmm3
+    paddw       xmm4, xmm3
+    paddw       xmm7, xmm3
+    paddw       xmm0, xmm3
+
+    ; (Original)
+    ; R = Y                + 1.40200 * Cr
+    ; G = Y - 0.34414 * Cb - 0.71414 * Cr
+    ; B = Y + 1.77200 * Cb
+    ;
+    ; (This implementation)
+    ; R = Y                + 0.40200 * Cr + Cr
+    ; G = Y - 0.34414 * Cb + 0.28586 * Cr - Cr
+    ; B = Y - 0.22800 * Cb + Cb + Cb
+
+    movdqa      xmm5, xmm6              ; xmm5=CbH
+    movdqa      xmm2, xmm4              ; xmm2=CbL
+    paddw       xmm6, xmm6              ; xmm6=2*CbH
+    paddw       xmm4, xmm4              ; xmm4=2*CbL
+    movdqa      xmm1, xmm7              ; xmm1=CrH
+    movdqa      xmm3, xmm0              ; xmm3=CrL
+    paddw       xmm7, xmm7              ; xmm7=2*CrH
+    paddw       xmm0, xmm0              ; xmm0=2*CrL
+
+    pmulhw      xmm6, [GOTOFF(eax,PW_MF0228)]  ; xmm6=(2*CbH * -FIX(0.22800))
+    pmulhw      xmm4, [GOTOFF(eax,PW_MF0228)]  ; xmm4=(2*CbL * -FIX(0.22800))
+    pmulhw      xmm7, [GOTOFF(eax,PW_F0402)]   ; xmm7=(2*CrH * FIX(0.40200))
+    pmulhw      xmm0, [GOTOFF(eax,PW_F0402)]   ; xmm0=(2*CrL * FIX(0.40200))
+
+    paddw       xmm6, [GOTOFF(eax,PW_ONE)]
+    paddw       xmm4, [GOTOFF(eax,PW_ONE)]
+    psraw       xmm6, 1                 ; xmm6=(CbH * -FIX(0.22800))
+    psraw       xmm4, 1                 ; xmm4=(CbL * -FIX(0.22800))
+    paddw       xmm7, [GOTOFF(eax,PW_ONE)]
+    paddw       xmm0, [GOTOFF(eax,PW_ONE)]
+    psraw       xmm7, 1                 ; xmm7=(CrH * FIX(0.40200))
+    psraw       xmm0, 1                 ; xmm0=(CrL * FIX(0.40200))
+
+    paddw       xmm6, xmm5
+    paddw       xmm4, xmm2
+    paddw       xmm6, xmm5              ; xmm6=(CbH * FIX(1.77200))=(B-Y)H
+    paddw       xmm4, xmm2              ; xmm4=(CbL * FIX(1.77200))=(B-Y)L
+    paddw       xmm7, xmm1              ; xmm7=(CrH * FIX(1.40200))=(R-Y)H
+    paddw       xmm0, xmm3              ; xmm0=(CrL * FIX(1.40200))=(R-Y)L
+
+    movdqa      XMMWORD [wk(0)], xmm6   ; wk(0)=(B-Y)H
+    movdqa      XMMWORD [wk(1)], xmm7   ; wk(1)=(R-Y)H
+
+    movdqa      xmm6, xmm5
+    movdqa      xmm7, xmm2
+    punpcklwd   xmm5, xmm1
+    punpckhwd   xmm6, xmm1
+    pmaddwd     xmm5, [GOTOFF(eax,PW_MF0344_F0285)]
+    pmaddwd     xmm6, [GOTOFF(eax,PW_MF0344_F0285)]
+    punpcklwd   xmm2, xmm3
+    punpckhwd   xmm7, xmm3
+    pmaddwd     xmm2, [GOTOFF(eax,PW_MF0344_F0285)]
+    pmaddwd     xmm7, [GOTOFF(eax,PW_MF0344_F0285)]
+
+    paddd       xmm5, [GOTOFF(eax,PD_ONEHALF)]
+    paddd       xmm6, [GOTOFF(eax,PD_ONEHALF)]
+    psrad       xmm5, SCALEBITS
+    psrad       xmm6, SCALEBITS
+    paddd       xmm2, [GOTOFF(eax,PD_ONEHALF)]
+    paddd       xmm7, [GOTOFF(eax,PD_ONEHALF)]
+    psrad       xmm2, SCALEBITS
+    psrad       xmm7, SCALEBITS
+
+    packssdw    xmm5, xmm6              ; xmm5=CbH*-FIX(0.344)+CrH*FIX(0.285)
+    packssdw    xmm2, xmm7              ; xmm2=CbL*-FIX(0.344)+CrL*FIX(0.285)
+    psubw       xmm5, xmm1              ; xmm5=CbH*-FIX(0.344)+CrH*-FIX(0.714)=(G-Y)H
+    psubw       xmm2, xmm3              ; xmm2=CbL*-FIX(0.344)+CrL*-FIX(0.714)=(G-Y)L
+
+    movdqa      XMMWORD [wk(2)], xmm5   ; wk(2)=(G-Y)H
+
+    mov         al, 2                   ; Yctr
+    jmp         short .Yloop_1st
+    alignx      16, 7
+
+.Yloop_2nd:
+    movdqa      xmm0, XMMWORD [wk(1)]   ; xmm0=(R-Y)H
+    movdqa      xmm2, XMMWORD [wk(2)]   ; xmm2=(G-Y)H
+    movdqa      xmm4, XMMWORD [wk(0)]   ; xmm4=(B-Y)H
+    alignx      16, 7
+
+.Yloop_1st:
+    movdqa      xmm7, XMMWORD [esi]     ; xmm7=Y(0123456789ABCDEF)
+
+    pcmpeqw     xmm6, xmm6
+    psrlw       xmm6, BYTE_BIT          ; xmm6={0xFF 0x00 0xFF 0x00 ..}
+    pand        xmm6, xmm7              ; xmm6=Y(02468ACE)=YE
+    psrlw       xmm7, BYTE_BIT          ; xmm7=Y(13579BDF)=YO
+
+    movdqa      xmm1, xmm0              ; xmm1=xmm0=(R-Y)(L/H)
+    movdqa      xmm3, xmm2              ; xmm3=xmm2=(G-Y)(L/H)
+    movdqa      xmm5, xmm4              ; xmm5=xmm4=(B-Y)(L/H)
+
+    paddw       xmm0, xmm6              ; xmm0=((R-Y)+YE)=RE=R(02468ACE)
+    paddw       xmm1, xmm7              ; xmm1=((R-Y)+YO)=RO=R(13579BDF)
+    packuswb    xmm0, xmm0              ; xmm0=R(02468ACE********)
+    packuswb    xmm1, xmm1              ; xmm1=R(13579BDF********)
+
+    paddw       xmm2, xmm6              ; xmm2=((G-Y)+YE)=GE=G(02468ACE)
+    paddw       xmm3, xmm7              ; xmm3=((G-Y)+YO)=GO=G(13579BDF)
+    packuswb    xmm2, xmm2              ; xmm2=G(02468ACE********)
+    packuswb    xmm3, xmm3              ; xmm3=G(13579BDF********)
+
+    paddw       xmm4, xmm6              ; xmm4=((B-Y)+YE)=BE=B(02468ACE)
+    paddw       xmm5, xmm7              ; xmm5=((B-Y)+YO)=BO=B(13579BDF)
+    packuswb    xmm4, xmm4              ; xmm4=B(02468ACE********)
+    packuswb    xmm5, xmm5              ; xmm5=B(13579BDF********)
+
+%if RGB_PIXELSIZE == 3  ; ---------------
+
+    ; xmmA=(00 02 04 06 08 0A 0C 0E **), xmmB=(01 03 05 07 09 0B 0D 0F **)
+    ; xmmC=(10 12 14 16 18 1A 1C 1E **), xmmD=(11 13 15 17 19 1B 1D 1F **)
+    ; xmmE=(20 22 24 26 28 2A 2C 2E **), xmmF=(21 23 25 27 29 2B 2D 2F **)
+    ; xmmG=(** ** ** ** ** ** ** ** **), xmmH=(** ** ** ** ** ** ** ** **)
+
+    punpcklbw   xmmA, xmmC        ; xmmA=(00 10 02 12 04 14 06 16 08 18 0A 1A 0C 1C 0E 1E)
+    punpcklbw   xmmE, xmmB        ; xmmE=(20 01 22 03 24 05 26 07 28 09 2A 0B 2C 0D 2E 0F)
+    punpcklbw   xmmD, xmmF        ; xmmD=(11 21 13 23 15 25 17 27 19 29 1B 2B 1D 2D 1F 2F)
+
+    movdqa      xmmG, xmmA
+    movdqa      xmmH, xmmA
+    punpcklwd   xmmA, xmmE        ; xmmA=(00 10 20 01 02 12 22 03 04 14 24 05 06 16 26 07)
+    punpckhwd   xmmG, xmmE        ; xmmG=(08 18 28 09 0A 1A 2A 0B 0C 1C 2C 0D 0E 1E 2E 0F)
+
+    psrldq      xmmH, 2           ; xmmH=(02 12 04 14 06 16 08 18 0A 1A 0C 1C 0E 1E -- --)
+    psrldq      xmmE, 2           ; xmmE=(22 03 24 05 26 07 28 09 2A 0B 2C 0D 2E 0F -- --)
+
+    movdqa      xmmC, xmmD
+    movdqa      xmmB, xmmD
+    punpcklwd   xmmD, xmmH        ; xmmD=(11 21 02 12 13 23 04 14 15 25 06 16 17 27 08 18)
+    punpckhwd   xmmC, xmmH        ; xmmC=(19 29 0A 1A 1B 2B 0C 1C 1D 2D 0E 1E 1F 2F -- --)
+
+    psrldq      xmmB, 2           ; xmmB=(13 23 15 25 17 27 19 29 1B 2B 1D 2D 1F 2F -- --)
+
+    movdqa      xmmF, xmmE
+    punpcklwd   xmmE, xmmB        ; xmmE=(22 03 13 23 24 05 15 25 26 07 17 27 28 09 19 29)
+    punpckhwd   xmmF, xmmB        ; xmmF=(2A 0B 1B 2B 2C 0D 1D 2D 2E 0F 1F 2F -- -- -- --)
+
+    pshufd      xmmH, xmmA, 0x4E  ; xmmH=(04 14 24 05 06 16 26 07 00 10 20 01 02 12 22 03)
+    movdqa      xmmB, xmmE
+    punpckldq   xmmA, xmmD        ; xmmA=(00 10 20 01 11 21 02 12 02 12 22 03 13 23 04 14)
+    punpckldq   xmmE, xmmH        ; xmmE=(22 03 13 23 04 14 24 05 24 05 15 25 06 16 26 07)
+    punpckhdq   xmmD, xmmB        ; xmmD=(15 25 06 16 26 07 17 27 17 27 08 18 28 09 19 29)
+
+    pshufd      xmmH, xmmG, 0x4E  ; xmmH=(0C 1C 2C 0D 0E 1E 2E 0F 08 18 28 09 0A 1A 2A 0B)
+    movdqa      xmmB, xmmF
+    punpckldq   xmmG, xmmC        ; xmmG=(08 18 28 09 19 29 0A 1A 0A 1A 2A 0B 1B 2B 0C 1C)
+    punpckldq   xmmF, xmmH        ; xmmF=(2A 0B 1B 2B 0C 1C 2C 0D 2C 0D 1D 2D 0E 1E 2E 0F)
+    punpckhdq   xmmC, xmmB        ; xmmC=(1D 2D 0E 1E 2E 0F 1F 2F 1F 2F -- -- -- -- -- --)
+
+    punpcklqdq  xmmA, xmmE        ; xmmA=(00 10 20 01 11 21 02 12 22 03 13 23 04 14 24 05)
+    punpcklqdq  xmmD, xmmG        ; xmmD=(15 25 06 16 26 07 17 27 08 18 28 09 19 29 0A 1A)
+    punpcklqdq  xmmF, xmmC        ; xmmF=(2A 0B 1B 2B 0C 1C 2C 0D 1D 2D 0E 1E 2E 0F 1F 2F)
+
+    cmp         ecx, byte SIZEOF_XMMWORD
+    jb          short .column_st32
+
+    test        edi, SIZEOF_XMMWORD-1
+    jnz         short .out1
+    ; --(aligned)-------------------
+    movntdq     XMMWORD [edi+0*SIZEOF_XMMWORD], xmmA
+    movntdq     XMMWORD [edi+1*SIZEOF_XMMWORD], xmmD
+    movntdq     XMMWORD [edi+2*SIZEOF_XMMWORD], xmmF
+    jmp         short .out0
+.out1:  ; --(unaligned)-----------------
+    movdqu      XMMWORD [edi+0*SIZEOF_XMMWORD], xmmA
+    movdqu      XMMWORD [edi+1*SIZEOF_XMMWORD], xmmD
+    movdqu      XMMWORD [edi+2*SIZEOF_XMMWORD], xmmF
+.out0:
+    add         edi, byte RGB_PIXELSIZE*SIZEOF_XMMWORD  ; outptr
+    sub         ecx, byte SIZEOF_XMMWORD
+    jz          near .endcolumn
+
+    add         esi, byte SIZEOF_XMMWORD  ; inptr0
+    dec         al                        ; Yctr
+    jnz         near .Yloop_2nd
+
+    add         ebx, byte SIZEOF_XMMWORD  ; inptr1
+    add         edx, byte SIZEOF_XMMWORD  ; inptr2
+    jmp         near .columnloop
+    alignx      16, 7
+
+.column_st32:
+    lea         ecx, [ecx+ecx*2]            ; imul ecx, RGB_PIXELSIZE
+    cmp         ecx, byte 2*SIZEOF_XMMWORD
+    jb          short .column_st16
+    movdqu      XMMWORD [edi+0*SIZEOF_XMMWORD], xmmA
+    movdqu      XMMWORD [edi+1*SIZEOF_XMMWORD], xmmD
+    add         edi, byte 2*SIZEOF_XMMWORD  ; outptr
+    movdqa      xmmA, xmmF
+    sub         ecx, byte 2*SIZEOF_XMMWORD
+    jmp         short .column_st15
+.column_st16:
+    cmp         ecx, byte SIZEOF_XMMWORD
+    jb          short .column_st15
+    movdqu      XMMWORD [edi+0*SIZEOF_XMMWORD], xmmA
+    add         edi, byte SIZEOF_XMMWORD    ; outptr
+    movdqa      xmmA, xmmD
+    sub         ecx, byte SIZEOF_XMMWORD
+.column_st15:
+    ; Store the lower 8 bytes of xmmA to the output when it has enough
+    ; space.
+    cmp         ecx, byte SIZEOF_MMWORD
+    jb          short .column_st7
+    movq        XMM_MMWORD [edi], xmmA
+    add         edi, byte SIZEOF_MMWORD
+    sub         ecx, byte SIZEOF_MMWORD
+    psrldq      xmmA, SIZEOF_MMWORD
+.column_st7:
+    ; Store the lower 4 bytes of xmmA to the output when it has enough
+    ; space.
+    cmp         ecx, byte SIZEOF_DWORD
+    jb          short .column_st3
+    movd        XMM_DWORD [edi], xmmA
+    add         edi, byte SIZEOF_DWORD
+    sub         ecx, byte SIZEOF_DWORD
+    psrldq      xmmA, SIZEOF_DWORD
+.column_st3:
+    ; Store the lower 2 bytes of eax to the output when it has enough
+    ; space.
+    movd        eax, xmmA
+    cmp         ecx, byte SIZEOF_WORD
+    jb          short .column_st1
+    mov         word [edi], ax
+    add         edi, byte SIZEOF_WORD
+    sub         ecx, byte SIZEOF_WORD
+    shr         eax, 16
+.column_st1:
+    ; Store the lower 1 byte of eax to the output when it has enough
+    ; space.
+    test        ecx, ecx
+    jz          short .endcolumn
+    mov         byte [edi], al
+
+%else  ; RGB_PIXELSIZE == 4 ; -----------
+
+%ifdef RGBX_FILLER_0XFF
+    pcmpeqb     xmm6, xmm6              ; xmm6=XE=X(02468ACE********)
+    pcmpeqb     xmm7, xmm7              ; xmm7=XO=X(13579BDF********)
+%else
+    pxor        xmm6, xmm6              ; xmm6=XE=X(02468ACE********)
+    pxor        xmm7, xmm7              ; xmm7=XO=X(13579BDF********)
+%endif
+    ; xmmA=(00 02 04 06 08 0A 0C 0E **), xmmB=(01 03 05 07 09 0B 0D 0F **)
+    ; xmmC=(10 12 14 16 18 1A 1C 1E **), xmmD=(11 13 15 17 19 1B 1D 1F **)
+    ; xmmE=(20 22 24 26 28 2A 2C 2E **), xmmF=(21 23 25 27 29 2B 2D 2F **)
+    ; xmmG=(30 32 34 36 38 3A 3C 3E **), xmmH=(31 33 35 37 39 3B 3D 3F **)
+
+    punpcklbw   xmmA, xmmC  ; xmmA=(00 10 02 12 04 14 06 16 08 18 0A 1A 0C 1C 0E 1E)
+    punpcklbw   xmmE, xmmG  ; xmmE=(20 30 22 32 24 34 26 36 28 38 2A 3A 2C 3C 2E 3E)
+    punpcklbw   xmmB, xmmD  ; xmmB=(01 11 03 13 05 15 07 17 09 19 0B 1B 0D 1D 0F 1F)
+    punpcklbw   xmmF, xmmH  ; xmmF=(21 31 23 33 25 35 27 37 29 39 2B 3B 2D 3D 2F 3F)
+
+    movdqa      xmmC, xmmA
+    punpcklwd   xmmA, xmmE  ; xmmA=(00 10 20 30 02 12 22 32 04 14 24 34 06 16 26 36)
+    punpckhwd   xmmC, xmmE  ; xmmC=(08 18 28 38 0A 1A 2A 3A 0C 1C 2C 3C 0E 1E 2E 3E)
+    movdqa      xmmG, xmmB
+    punpcklwd   xmmB, xmmF  ; xmmB=(01 11 21 31 03 13 23 33 05 15 25 35 07 17 27 37)
+    punpckhwd   xmmG, xmmF  ; xmmG=(09 19 29 39 0B 1B 2B 3B 0D 1D 2D 3D 0F 1F 2F 3F)
+
+    movdqa      xmmD, xmmA
+    punpckldq   xmmA, xmmB  ; xmmA=(00 10 20 30 01 11 21 31 02 12 22 32 03 13 23 33)
+    punpckhdq   xmmD, xmmB  ; xmmD=(04 14 24 34 05 15 25 35 06 16 26 36 07 17 27 37)
+    movdqa      xmmH, xmmC
+    punpckldq   xmmC, xmmG  ; xmmC=(08 18 28 38 09 19 29 39 0A 1A 2A 3A 0B 1B 2B 3B)
+    punpckhdq   xmmH, xmmG  ; xmmH=(0C 1C 2C 3C 0D 1D 2D 3D 0E 1E 2E 3E 0F 1F 2F 3F)
+
+    cmp         ecx, byte SIZEOF_XMMWORD
+    jb          short .column_st32
+
+    test        edi, SIZEOF_XMMWORD-1
+    jnz         short .out1
+    ; --(aligned)-------------------
+    movntdq     XMMWORD [edi+0*SIZEOF_XMMWORD], xmmA
+    movntdq     XMMWORD [edi+1*SIZEOF_XMMWORD], xmmD
+    movntdq     XMMWORD [edi+2*SIZEOF_XMMWORD], xmmC
+    movntdq     XMMWORD [edi+3*SIZEOF_XMMWORD], xmmH
+    jmp         short .out0
+.out1:  ; --(unaligned)-----------------
+    movdqu      XMMWORD [edi+0*SIZEOF_XMMWORD], xmmA
+    movdqu      XMMWORD [edi+1*SIZEOF_XMMWORD], xmmD
+    movdqu      XMMWORD [edi+2*SIZEOF_XMMWORD], xmmC
+    movdqu      XMMWORD [edi+3*SIZEOF_XMMWORD], xmmH
+.out0:
+    add         edi, byte RGB_PIXELSIZE*SIZEOF_XMMWORD  ; outptr
+    sub         ecx, byte SIZEOF_XMMWORD
+    jz          near .endcolumn
+
+    add         esi, byte SIZEOF_XMMWORD  ; inptr0
+    dec         al                        ; Yctr
+    jnz         near .Yloop_2nd
+
+    add         ebx, byte SIZEOF_XMMWORD  ; inptr1
+    add         edx, byte SIZEOF_XMMWORD  ; inptr2
+    jmp         near .columnloop
+    alignx      16, 7
+
+.column_st32:
+    cmp         ecx, byte SIZEOF_XMMWORD/2
+    jb          short .column_st16
+    movdqu      XMMWORD [edi+0*SIZEOF_XMMWORD], xmmA
+    movdqu      XMMWORD [edi+1*SIZEOF_XMMWORD], xmmD
+    add         edi, byte 2*SIZEOF_XMMWORD  ; outptr
+    movdqa      xmmA, xmmC
+    movdqa      xmmD, xmmH
+    sub         ecx, byte SIZEOF_XMMWORD/2
+.column_st16:
+    cmp         ecx, byte SIZEOF_XMMWORD/4
+    jb          short .column_st15
+    movdqu      XMMWORD [edi+0*SIZEOF_XMMWORD], xmmA
+    add         edi, byte SIZEOF_XMMWORD    ; outptr
+    movdqa      xmmA, xmmD
+    sub         ecx, byte SIZEOF_XMMWORD/4
+.column_st15:
+    ; Store two pixels (8 bytes) of xmmA to the output when it has enough
+    ; space.
+    cmp         ecx, byte SIZEOF_XMMWORD/8
+    jb          short .column_st7
+    movq        XMM_MMWORD [edi], xmmA
+    add         edi, byte SIZEOF_XMMWORD/8*4
+    sub         ecx, byte SIZEOF_XMMWORD/8
+    psrldq      xmmA, SIZEOF_XMMWORD/8*4
+.column_st7:
+    ; Store one pixel (4 bytes) of xmmA to the output when it has enough
+    ; space.
+    test        ecx, ecx
+    jz          short .endcolumn
+    movd        XMM_DWORD [edi], xmmA
+
+%endif  ; RGB_PIXELSIZE ; ---------------
+
+.endcolumn:
+    sfence                              ; flush the write buffer
+
+.return:
+    pop         edi
+    pop         esi
+;   pop         edx                     ; need not be preserved
+;   pop         ecx                     ; need not be preserved
+    pop         ebx
+    mov         esp, ebp                ; esp <- aligned ebp
+    pop         esp                     ; esp <- original ebp
+    pop         ebp
+    ret
+
+; --------------------------------------------------------------------------
+;
+; Upsample and color convert for the case of 2:1 horizontal and 2:1 vertical.
+;
+; GLOBAL(void)
+; jsimd_h2v2_merged_upsample_sse2(JDIMENSION output_width,
+;                                 JSAMPIMAGE input_buf,
+;                                 JDIMENSION in_row_group_ctr,
+;                                 JSAMPARRAY output_buf);
+;
+
+%define output_width(b)      (b) + 8    ; JDIMENSION output_width
+%define input_buf(b)         (b) + 12   ; JSAMPIMAGE input_buf
+%define in_row_group_ctr(b)  (b) + 16   ; JDIMENSION in_row_group_ctr
+%define output_buf(b)        (b) + 20   ; JSAMPARRAY output_buf
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_h2v2_merged_upsample_sse2)
+
+EXTN(jsimd_h2v2_merged_upsample_sse2):
+    push        ebp
+    mov         ebp, esp
+    push        ebx
+;   push        ecx                     ; need not be preserved
+;   push        edx                     ; need not be preserved
+    push        esi
+    push        edi
+
+    mov         eax, POINTER [output_width(ebp)]
+
+    mov         edi, JSAMPIMAGE [input_buf(ebp)]
+    mov         ecx, JDIMENSION [in_row_group_ctr(ebp)]
+    mov         esi, JSAMPARRAY [edi+0*SIZEOF_JSAMPARRAY]
+    mov         ebx, JSAMPARRAY [edi+1*SIZEOF_JSAMPARRAY]
+    mov         edx, JSAMPARRAY [edi+2*SIZEOF_JSAMPARRAY]
+    mov         edi, JSAMPARRAY [output_buf(ebp)]
+    lea         esi, [esi+ecx*SIZEOF_JSAMPROW]
+
+    push        edx                     ; inptr2
+    push        ebx                     ; inptr1
+    push        esi                     ; inptr00
+    mov         ebx, esp
+
+    push        edi                     ; output_buf (outptr0)
+    push        ecx                     ; in_row_group_ctr
+    push        ebx                     ; input_buf
+    push        eax                     ; output_width
+
+    call        near EXTN(jsimd_h2v1_merged_upsample_sse2)
+
+    add         esi, byte SIZEOF_JSAMPROW  ; inptr01
+    add         edi, byte SIZEOF_JSAMPROW  ; outptr1
+    mov         POINTER [ebx+0*SIZEOF_POINTER], esi
+    mov         POINTER [ebx-1*SIZEOF_POINTER], edi
+
+    call        near EXTN(jsimd_h2v1_merged_upsample_sse2)
+
+    add         esp, byte 7*SIZEOF_DWORD
+
+    pop         edi
+    pop         esi
+;   pop         edx                     ; need not be preserved
+;   pop         ecx                     ; need not be preserved
+    pop         ebx
+    pop         ebp
+    ret
+
+; For some reason, the OS X linker does not honor the request to align the
+; segment unless we do this.
+    align       32
diff --git a/3rdparty/libjpeg/src/simd/i386/jdsample-avx2.asm b/3rdparty/libjpeg/src/simd/i386/jdsample-avx2.asm
new file mode 100644
index 00000000..a800c35e
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/i386/jdsample-avx2.asm
@@ -0,0 +1,760 @@
+;
+; jdsample.asm - upsampling (AVX2)
+;
+; Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+; Copyright (C) 2015, Intel Corporation.
+; Copyright (C) 2016, D. R. Commander.
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+;
+; This file should be assembled with NASM (Netwide Assembler),
+; can *not* be assembled with Microsoft's MASM or any compatible
+; assembler (including Borland's Turbo Assembler).
+; NASM is available from http://nasm.sourceforge.net/ or
+; http://sourceforge.net/project/showfiles.php?group_id=6208
+
+%include "jsimdext.inc"
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_CONST
+
+    alignz      32
+    GLOBAL_DATA(jconst_fancy_upsample_avx2)
+
+EXTN(jconst_fancy_upsample_avx2):
+
+PW_ONE   times 16 dw 1
+PW_TWO   times 16 dw 2
+PW_THREE times 16 dw 3
+PW_SEVEN times 16 dw 7
+PW_EIGHT times 16 dw 8
+
+    alignz      32
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_TEXT
+    BITS        32
+;
+; Fancy processing for the common case of 2:1 horizontal and 1:1 vertical.
+;
+; The upsampling algorithm is linear interpolation between pixel centers,
+; also known as a "triangle filter".  This is a good compromise between
+; speed and visual quality.  The centers of the output pixels are 1/4 and 3/4
+; of the way between input pixel centers.
+;
+; GLOBAL(void)
+; jsimd_h2v1_fancy_upsample_avx2(int max_v_samp_factor,
+;                                JDIMENSION downsampled_width,
+;                                JSAMPARRAY input_data,
+;                                JSAMPARRAY *output_data_ptr);
+;
+
+%define max_v_samp(b)       (b) + 8     ; int max_v_samp_factor
+%define downsamp_width(b)   (b) + 12    ; JDIMENSION downsampled_width
+%define input_data(b)       (b) + 16    ; JSAMPARRAY input_data
+%define output_data_ptr(b)  (b) + 20    ; JSAMPARRAY *output_data_ptr
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_h2v1_fancy_upsample_avx2)
+
+EXTN(jsimd_h2v1_fancy_upsample_avx2):
+    push        ebp
+    mov         ebp, esp
+    pushpic     ebx
+;   push        ecx                     ; need not be preserved
+;   push        edx                     ; need not be preserved
+    push        esi
+    push        edi
+
+    get_GOT     ebx                     ; get GOT address
+
+    mov         eax, JDIMENSION [downsamp_width(ebp)]  ; colctr
+    test        eax, eax
+    jz          near .return
+
+    mov         ecx, INT [max_v_samp(ebp)]  ; rowctr
+    test        ecx, ecx
+    jz          near .return
+
+    mov         esi, JSAMPARRAY [input_data(ebp)]    ; input_data
+    mov         edi, POINTER [output_data_ptr(ebp)]
+    mov         edi, JSAMPARRAY [edi]                ; output_data
+    alignx      16, 7
+.rowloop:
+    push        eax                     ; colctr
+    push        edi
+    push        esi
+
+    mov         esi, JSAMPROW [esi]     ; inptr
+    mov         edi, JSAMPROW [edi]     ; outptr
+
+    test        eax, SIZEOF_YMMWORD-1
+    jz          short .skip
+    mov         dl, JSAMPLE [esi+(eax-1)*SIZEOF_JSAMPLE]
+    mov         JSAMPLE [esi+eax*SIZEOF_JSAMPLE], dl    ; insert a dummy sample
+.skip:
+    vpxor       ymm0, ymm0, ymm0                ; ymm0=(all 0's)
+    vpcmpeqb    xmm7, xmm7, xmm7
+    vpsrldq     xmm7, xmm7, (SIZEOF_XMMWORD-1)  ; (ff -- -- -- ... -- --) LSB is ff
+    vpand       ymm7, ymm7, YMMWORD [esi+0*SIZEOF_YMMWORD]
+
+    add         eax, byte SIZEOF_YMMWORD-1
+    and         eax, byte -SIZEOF_YMMWORD
+    cmp         eax, byte SIZEOF_YMMWORD
+    ja          short .columnloop
+    alignx      16, 7
+
+.columnloop_last:
+    vpcmpeqb    xmm6, xmm6, xmm6
+    vpslldq     xmm6, xmm6, (SIZEOF_XMMWORD-1)
+    vperm2i128  ymm6, ymm6, ymm6, 1             ; (---- ---- ... ---- ---- ff) MSB is ff
+    vpand       ymm6, ymm6, YMMWORD [esi+0*SIZEOF_YMMWORD]
+    jmp         short .upsample
+    alignx      16, 7
+
+.columnloop:
+    vmovdqu     ymm6, YMMWORD [esi+1*SIZEOF_YMMWORD]
+    vperm2i128  ymm6, ymm0, ymm6, 0x20
+    vpslldq     ymm6, ymm6, 15
+
+.upsample:
+    vmovdqu     ymm1, YMMWORD [esi+0*SIZEOF_YMMWORD]  ; ymm1=( 0  1  2 ... 29 30 31)
+
+    vperm2i128  ymm2, ymm0, ymm1, 0x20
+    vpalignr    ymm2, ymm1, ymm2, 15            ; ymm2=(--  0  1 ... 28 29 30)
+    vperm2i128  ymm4, ymm0, ymm1, 0x03
+    vpalignr    ymm3, ymm4, ymm1, 1             ; ymm3=( 1  2  3 ... 30 31 --)
+
+    vpor        ymm2, ymm2, ymm7                ; ymm2=(-1  0  1 ... 28 29 30)
+    vpor        ymm3, ymm3, ymm6                ; ymm3=( 1  2  3 ... 30 31 32)
+
+    vpsrldq     ymm7, ymm4, (SIZEOF_XMMWORD-1)  ; ymm7=(31 -- -- ... -- -- --)
+
+    vpunpckhbw  ymm4, ymm1, ymm0                ; ymm4=( 8  9 10 11 12 13 14 15 24 25 26 27 28 29 30 31)
+    vpunpcklbw  ymm5, ymm1, ymm0                ; ymm5=( 0  1  2  3  4  5  6  7 16 17 18 19 20 21 22 23)
+    vperm2i128  ymm1, ymm5, ymm4, 0x20          ; ymm1=( 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15)
+    vperm2i128  ymm4, ymm5, ymm4, 0x31          ; ymm4=(16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31)
+
+    vpunpckhbw  ymm5, ymm2, ymm0                ; ymm5=( 7  8  9 10 11 12 13 14 23 24 25 26 27 28 29 30)
+    vpunpcklbw  ymm6, ymm2, ymm0                ; ymm6=(-1  0  1  2  3  4  5  6 15 16 17 18 19 20 21 22)
+    vperm2i128  ymm2, ymm6, ymm5, 0x20          ; ymm2=(-1  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14)
+    vperm2i128  ymm5, ymm6, ymm5, 0x31          ; ymm5=(15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30)
+
+    vpunpckhbw  ymm6, ymm3, ymm0                ; ymm6=( 1  2  3  4  5  6  7  8 17 18 19 20 21 22 23 24)
+    vpunpcklbw  ymm0, ymm3, ymm0                ; ymm0=( 9 10 11 12 13 14 15 16 25 26 27 28 29 30 31 32)
+    vperm2i128  ymm3, ymm0, ymm6, 0x20          ; ymm3=( 1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16)
+    vperm2i128  ymm6, ymm0, ymm6, 0x31          ; ymm6=(17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32)
+
+    vpxor       ymm0, ymm0, ymm0                ; ymm0=(all 0's)
+
+    vpmullw     ymm1, ymm1, [GOTOFF(ebx,PW_THREE)]
+    vpmullw     ymm4, ymm4, [GOTOFF(ebx,PW_THREE)]
+    vpaddw      ymm2, ymm2, [GOTOFF(ebx,PW_ONE)]
+    vpaddw      ymm5, ymm5, [GOTOFF(ebx,PW_ONE)]
+    vpaddw      ymm3, ymm3, [GOTOFF(ebx,PW_TWO)]
+    vpaddw      ymm6, ymm6, [GOTOFF(ebx,PW_TWO)]
+
+    vpaddw      ymm2, ymm2, ymm1
+    vpaddw      ymm5, ymm5, ymm4
+    vpsrlw      ymm2, ymm2, 2                   ; ymm2=OutLE=( 0  2  4  6  8 10 12 14 16 18 20 22 24 26 28 30)
+    vpsrlw      ymm5, ymm5, 2                   ; ymm5=OutHE=(32 34 36 38 40 42 44 46 48 50 52 54 56 58 60 62)
+    vpaddw      ymm3, ymm3, ymm1
+    vpaddw      ymm6, ymm6, ymm4
+    vpsrlw      ymm3, ymm3, 2                   ; ymm3=OutLO=( 1  3  5  7  9 11 13 15 17 19 21 23 25 27 29 31)
+    vpsrlw      ymm6, ymm6, 2                   ; ymm6=OutHO=(33 35 37 39 41 43 45 47 49 51 53 55 57 59 61 63)
+
+    vpsllw      ymm3, ymm3, BYTE_BIT
+    vpsllw      ymm6, ymm6, BYTE_BIT
+    vpor        ymm2, ymm2, ymm3                ; ymm2=OutL=( 0  1  2 ... 29 30 31)
+    vpor        ymm5, ymm5, ymm6                ; ymm5=OutH=(32 33 34 ... 61 62 63)
+
+    vmovdqu     YMMWORD [edi+0*SIZEOF_YMMWORD], ymm2
+    vmovdqu     YMMWORD [edi+1*SIZEOF_YMMWORD], ymm5
+
+    sub         eax, byte SIZEOF_YMMWORD
+    add         esi, byte 1*SIZEOF_YMMWORD  ; inptr
+    add         edi, byte 2*SIZEOF_YMMWORD  ; outptr
+    cmp         eax, byte SIZEOF_YMMWORD
+    ja          near .columnloop
+    test        eax, eax
+    jnz         near .columnloop_last
+
+    pop         esi
+    pop         edi
+    pop         eax
+
+    add         esi, byte SIZEOF_JSAMPROW  ; input_data
+    add         edi, byte SIZEOF_JSAMPROW  ; output_data
+    dec         ecx                        ; rowctr
+    jg          near .rowloop
+
+.return:
+    vzeroupper
+    pop         edi
+    pop         esi
+;   pop         edx                     ; need not be preserved
+;   pop         ecx                     ; need not be preserved
+    poppic      ebx
+    pop         ebp
+    ret
+
+; --------------------------------------------------------------------------
+;
+; Fancy processing for the common case of 2:1 horizontal and 2:1 vertical.
+; Again a triangle filter; see comments for h2v1 case, above.
+;
+; GLOBAL(void)
+; jsimd_h2v2_fancy_upsample_avx2(int max_v_samp_factor,
+;                                JDIMENSION downsampled_width,
+;                                JSAMPARRAY input_data,
+;                                JSAMPARRAY *output_data_ptr);
+;
+
+%define max_v_samp(b)       (b) + 8     ; int max_v_samp_factor
+%define downsamp_width(b)   (b) + 12    ; JDIMENSION downsampled_width
+%define input_data(b)       (b) + 16    ; JSAMPARRAY input_data
+%define output_data_ptr(b)  (b) + 20    ; JSAMPARRAY *output_data_ptr
+
+%define original_ebp  ebp + 0
+%define wk(i)         ebp - (WK_NUM - (i)) * SIZEOF_YMMWORD
+                                        ; ymmword wk[WK_NUM]
+%define WK_NUM        4
+%define gotptr        wk(0) - SIZEOF_POINTER  ; void *gotptr
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_h2v2_fancy_upsample_avx2)
+
+EXTN(jsimd_h2v2_fancy_upsample_avx2):
+    push        ebp
+    mov         eax, esp                     ; eax = original ebp
+    sub         esp, byte 4
+    and         esp, byte (-SIZEOF_YMMWORD)  ; align to 256 bits
+    mov         [esp], eax
+    mov         ebp, esp                     ; ebp = aligned ebp
+    lea         esp, [wk(0)]
+    pushpic     eax                     ; make a room for GOT address
+    push        ebx
+;   push        ecx                     ; need not be preserved
+;   push        edx                     ; need not be preserved
+    push        esi
+    push        edi
+
+    get_GOT     ebx                     ; get GOT address
+    movpic      POINTER [gotptr], ebx   ; save GOT address
+
+    mov         edx, eax                ; edx = original ebp
+    mov         eax, JDIMENSION [downsamp_width(edx)]  ; colctr
+    test        eax, eax
+    jz          near .return
+
+    mov         ecx, INT [max_v_samp(edx)]  ; rowctr
+    test        ecx, ecx
+    jz          near .return
+
+    mov         esi, JSAMPARRAY [input_data(edx)]    ; input_data
+    mov         edi, POINTER [output_data_ptr(edx)]
+    mov         edi, JSAMPARRAY [edi]                ; output_data
+    alignx      16, 7
+.rowloop:
+    push        eax                     ; colctr
+    push        ecx
+    push        edi
+    push        esi
+
+    mov         ecx, JSAMPROW [esi-1*SIZEOF_JSAMPROW]  ; inptr1(above)
+    mov         ebx, JSAMPROW [esi+0*SIZEOF_JSAMPROW]  ; inptr0
+    mov         esi, JSAMPROW [esi+1*SIZEOF_JSAMPROW]  ; inptr1(below)
+    mov         edx, JSAMPROW [edi+0*SIZEOF_JSAMPROW]  ; outptr0
+    mov         edi, JSAMPROW [edi+1*SIZEOF_JSAMPROW]  ; outptr1
+
+    test        eax, SIZEOF_YMMWORD-1
+    jz          short .skip
+    push        edx
+    mov         dl, JSAMPLE [ecx+(eax-1)*SIZEOF_JSAMPLE]
+    mov         JSAMPLE [ecx+eax*SIZEOF_JSAMPLE], dl
+    mov         dl, JSAMPLE [ebx+(eax-1)*SIZEOF_JSAMPLE]
+    mov         JSAMPLE [ebx+eax*SIZEOF_JSAMPLE], dl
+    mov         dl, JSAMPLE [esi+(eax-1)*SIZEOF_JSAMPLE]
+    mov         JSAMPLE [esi+eax*SIZEOF_JSAMPLE], dl    ; insert a dummy sample
+    pop         edx
+.skip:
+    ; -- process the first column block
+
+    vmovdqu     ymm0, YMMWORD [ebx+0*SIZEOF_YMMWORD]  ; ymm0=row[ 0][0]
+    vmovdqu     ymm1, YMMWORD [ecx+0*SIZEOF_YMMWORD]  ; ymm1=row[-1][0]
+    vmovdqu     ymm2, YMMWORD [esi+0*SIZEOF_YMMWORD]  ; ymm2=row[+1][0]
+
+    pushpic     ebx
+    movpic      ebx, POINTER [gotptr]   ; load GOT address
+
+    vpxor       ymm3, ymm3, ymm3        ; ymm3=(all 0's)
+
+    vpunpckhbw  ymm4, ymm0, ymm3        ; ymm4=row[ 0]( 8  9 10 11 12 13 14 15 24 25 26 27 28 29 30 31)
+    vpunpcklbw  ymm5, ymm0, ymm3        ; ymm5=row[ 0]( 0  1  2  3  4  5  6  7 16 17 18 19 20 21 22 23)
+    vperm2i128  ymm0, ymm5, ymm4, 0x20  ; ymm0=row[ 0]( 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15)
+    vperm2i128  ymm4, ymm5, ymm4, 0x31  ; ymm4=row[ 0](16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31)
+
+    vpunpckhbw  ymm5, ymm1, ymm3        ; ymm5=row[-1]( 8  9 10 11 12 13 14 15 24 25 26 27 28 29 30 31)
+    vpunpcklbw  ymm6, ymm1, ymm3        ; ymm6=row[-1]( 0  1  2  3  4  5  6  7 16 17 18 19 20 21 22 23)
+    vperm2i128  ymm1, ymm6, ymm5, 0x20  ; ymm1=row[-1]( 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15)
+    vperm2i128  ymm5, ymm6, ymm5, 0x31  ; ymm5=row[-1](16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31)
+
+    vpunpckhbw  ymm6, ymm2, ymm3        ; ymm6=row[+1]( 8  9 10 11 12 13 14 15 24 25 26 27 28 29 30 31)
+    vpunpcklbw  ymm3, ymm2, ymm3        ; ymm3=row[+1]( 0  1  2  3  4  5  6  7 16 17 18 19 20 21 22 23)
+    vperm2i128  ymm2, ymm3, ymm6, 0x20  ; ymm2=row[+1]( 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15)
+    vperm2i128  ymm6, ymm3, ymm6, 0x31  ; ymm6=row[+1](16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31)
+
+    vpmullw     ymm0, ymm0, [GOTOFF(ebx,PW_THREE)]
+    vpmullw     ymm4, ymm4, [GOTOFF(ebx,PW_THREE)]
+
+    vpcmpeqb    xmm7, xmm7, xmm7
+    vpsrldq     xmm7, xmm7, (SIZEOF_XMMWORD-2)  ; (ffff ---- ---- ... ---- ----) LSB is ffff
+
+    vpaddw      ymm1, ymm1, ymm0        ; ymm1=Int0L=( 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15)
+    vpaddw      ymm5, ymm5, ymm4        ; ymm5=Int0H=(16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31)
+    vpaddw      ymm2, ymm2, ymm0        ; ymm2=Int1L=( 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15)
+    vpaddw      ymm6, ymm6, ymm4        ; ymm6=Int1H=(16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31)
+
+    vmovdqu     YMMWORD [edx+0*SIZEOF_YMMWORD], ymm1  ; temporarily save
+    vmovdqu     YMMWORD [edx+1*SIZEOF_YMMWORD], ymm5  ; the intermediate data
+    vmovdqu     YMMWORD [edi+0*SIZEOF_YMMWORD], ymm2
+    vmovdqu     YMMWORD [edi+1*SIZEOF_YMMWORD], ymm6
+
+    vpand       ymm1, ymm1, ymm7        ; ymm1=( 0 -- -- -- -- -- -- -- -- -- -- -- -- -- -- --)
+    vpand       ymm2, ymm2, ymm7        ; ymm2=( 0 -- -- -- -- -- -- -- -- -- -- -- -- -- -- --)
+
+    vmovdqa     YMMWORD [wk(0)], ymm1
+    vmovdqa     YMMWORD [wk(1)], ymm2
+
+    poppic      ebx
+
+    add         eax, byte SIZEOF_YMMWORD-1
+    and         eax, byte -SIZEOF_YMMWORD
+    cmp         eax, byte SIZEOF_YMMWORD
+    ja          short .columnloop
+    alignx      16, 7
+
+.columnloop_last:
+    ; -- process the last column block
+
+    pushpic     ebx
+    movpic      ebx, POINTER [gotptr]   ; load GOT address
+
+    vpcmpeqb    xmm1, xmm1, xmm1
+    vpslldq     xmm1, xmm1, (SIZEOF_XMMWORD-2)
+    vperm2i128  ymm1, ymm1, ymm1, 1             ; (---- ---- ... ---- ---- ffff) MSB is ffff
+
+    vpand       ymm2, ymm1, YMMWORD [edi+1*SIZEOF_YMMWORD]
+    vpand       ymm1, ymm1, YMMWORD [edx+1*SIZEOF_YMMWORD]
+
+    vmovdqa     YMMWORD [wk(2)], ymm1          ; ymm1=(-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 31)
+    vmovdqa     YMMWORD [wk(3)], ymm2          ; ymm2=(-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 31)
+
+    jmp         near .upsample
+    alignx      16, 7
+
+.columnloop:
+    ; -- process the next column block
+
+    vmovdqu     ymm0, YMMWORD [ebx+1*SIZEOF_YMMWORD]  ; ymm0=row[ 0][1]
+    vmovdqu     ymm1, YMMWORD [ecx+1*SIZEOF_YMMWORD]  ; ymm1=row[-1][1]
+    vmovdqu     ymm2, YMMWORD [esi+1*SIZEOF_YMMWORD]  ; ymm2=row[+1][1]
+
+    pushpic     ebx
+    movpic      ebx, POINTER [gotptr]   ; load GOT address
+
+    vpxor       ymm3, ymm3, ymm3        ; ymm3=(all 0's)
+
+    vpunpckhbw  ymm4, ymm0, ymm3        ; ymm4=row[ 0]( 8  9 10 11 12 13 14 15 24 25 26 27 28 29 30 31)
+    vpunpcklbw  ymm5, ymm0, ymm3        ; ymm5=row[ 0]( 0  1  2  3  4  5  6  7 16 17 18 19 20 21 22 23)
+    vperm2i128  ymm0, ymm5, ymm4, 0x20  ; ymm0=row[ 0]( 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15)
+    vperm2i128  ymm4, ymm5, ymm4, 0x31  ; ymm4=row[ 0](16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31)
+
+    vpunpckhbw  ymm5, ymm1, ymm3        ; ymm5=row[-1]( 8  9 10 11 12 13 14 15 24 25 26 27 28 29 30 31)
+    vpunpcklbw  ymm6, ymm1, ymm3        ; ymm6=row[-1]( 0  1  2  3  4  5  6  7 16 17 18 19 20 21 22 23)
+    vperm2i128  ymm1, ymm6, ymm5, 0x20  ; ymm1=row[-1]( 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15)
+    vperm2i128  ymm5, ymm6, ymm5, 0x31  ; ymm5=row[-1](16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31)
+
+    vpunpckhbw  ymm6, ymm2, ymm3        ; ymm6=row[+1]( 8  9 10 11 12 13 14 15 24 25 26 27 28 29 30 31)
+    vpunpcklbw  ymm7, ymm2, ymm3        ; ymm7=row[+1]( 0  1  2  3  4  5  6  7 16 17 18 19 20 21 22 23)
+    vperm2i128  ymm2, ymm7, ymm6, 0x20  ; ymm2=row[+1]( 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15)
+    vperm2i128  ymm6, ymm7, ymm6, 0x31  ; ymm6=row[+1](16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31)
+
+    vpmullw     ymm0, ymm0, [GOTOFF(ebx,PW_THREE)]
+    vpmullw     ymm4, ymm4, [GOTOFF(ebx,PW_THREE)]
+
+    vpaddw      ymm1, ymm1, ymm0        ; ymm1=Int0L=( 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15)
+    vpaddw      ymm5, ymm5, ymm4        ; ymm5=Int0H=(16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31)
+    vpaddw      ymm2, ymm2, ymm0        ; ymm2=Int1L=( 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15)
+    vpaddw      ymm6, ymm6, ymm4        ; ymm6=Int1H=(16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31)
+
+    vmovdqu     YMMWORD [edx+2*SIZEOF_YMMWORD], ymm1  ; temporarily save
+    vmovdqu     YMMWORD [edx+3*SIZEOF_YMMWORD], ymm5  ; the intermediate data
+    vmovdqu     YMMWORD [edi+2*SIZEOF_YMMWORD], ymm2
+    vmovdqu     YMMWORD [edi+3*SIZEOF_YMMWORD], ymm6
+
+    vperm2i128  ymm1, ymm3, ymm1, 0x20
+    vpslldq     ymm1, ymm1, 14          ; ymm1=(-- -- -- -- -- -- -- -- -- -- -- -- -- -- --  0)
+    vperm2i128  ymm2, ymm3, ymm2, 0x20
+    vpslldq     ymm2, ymm2, 14          ; ymm2=(-- -- -- -- -- -- -- -- -- -- -- -- -- -- --  0)
+
+    vmovdqa     YMMWORD [wk(2)], ymm1
+    vmovdqa     YMMWORD [wk(3)], ymm2
+
+.upsample:
+    ; -- process the upper row
+
+    vmovdqu     ymm7, YMMWORD [edx+0*SIZEOF_YMMWORD]  ; ymm7=Int0L=( 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15)
+    vmovdqu     ymm3, YMMWORD [edx+1*SIZEOF_YMMWORD]  ; ymm3=Int0H=(16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31)
+
+    vpxor       ymm1, ymm1, ymm1        ; ymm1=(all 0's)
+
+    vperm2i128  ymm0, ymm1, ymm7, 0x03
+    vpalignr    ymm0, ymm0, ymm7, 2     ; ymm0=( 1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 --)
+    vperm2i128  ymm4, ymm1, ymm3, 0x20
+    vpslldq     ymm4, ymm4, 14          ; ymm4=(-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 16)
+
+    vperm2i128  ymm5, ymm1, ymm7, 0x03
+    vpsrldq     ymm5, ymm5, 14          ; ymm5=(15 -- -- -- -- -- -- -- -- -- -- -- -- -- -- --)
+    vperm2i128  ymm6, ymm1, ymm3, 0x20
+    vpalignr    ymm6, ymm3, ymm6, 14    ; ymm6=(-- 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30)
+
+    vpor        ymm0, ymm0, ymm4        ; ymm0=( 1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16)
+    vpor        ymm5, ymm5, ymm6        ; ymm5=(15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30)
+
+    vperm2i128  ymm2, ymm1, ymm3, 0x03
+    vpalignr    ymm2, ymm2, ymm3, 2     ; ymm2=(17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 --)
+    vperm2i128  ymm4, ymm1, ymm3, 0x03
+    vpsrldq     ymm4, ymm4, 14          ; ymm4=(31 -- -- -- -- -- -- -- -- -- -- -- -- -- -- --)
+    vperm2i128  ymm1, ymm1, ymm7, 0x20
+    vpalignr    ymm1, ymm7, ymm1, 14    ; ymm1=(--  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14)
+
+    vpor        ymm1, ymm1, YMMWORD [wk(0)]  ; ymm1=(-1  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14)
+    vpor        ymm2, ymm2, YMMWORD [wk(2)]  ; ymm2=(17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32)
+
+    vmovdqa     YMMWORD [wk(0)], ymm4
+
+    vpmullw     ymm7, ymm7, [GOTOFF(ebx,PW_THREE)]
+    vpmullw     ymm3, ymm3, [GOTOFF(ebx,PW_THREE)]
+    vpaddw      ymm1, ymm1, [GOTOFF(ebx,PW_EIGHT)]
+    vpaddw      ymm5, ymm5, [GOTOFF(ebx,PW_EIGHT)]
+    vpaddw      ymm0, ymm0, [GOTOFF(ebx,PW_SEVEN)]
+    vpaddw      ymm2, [GOTOFF(ebx,PW_SEVEN)]
+
+    vpaddw      ymm1, ymm1, ymm7
+    vpaddw      ymm5, ymm5, ymm3
+    vpsrlw      ymm1, ymm1, 4           ; ymm1=Out0LE=( 0  2  4  6  8 10 12 14 16 18 20 22 24 26 28 30)
+    vpsrlw      ymm5, ymm5, 4           ; ymm5=Out0HE=(32 34 36 38 40 42 44 46 48 50 52 54 56 58 60 62)
+    vpaddw      ymm0, ymm0, ymm7
+    vpaddw      ymm2, ymm2, ymm3
+    vpsrlw      ymm0, ymm0, 4           ; ymm0=Out0LO=( 1  3  5  7  9 11 13 15 17 19 21 23 25 27 29 31)
+    vpsrlw      ymm2, ymm2, 4           ; ymm2=Out0HO=(33 35 37 39 41 43 45 47 49 51 53 55 57 59 61 63)
+
+    vpsllw      ymm0, ymm0, BYTE_BIT
+    vpsllw      ymm2, ymm2, BYTE_BIT
+    vpor        ymm1, ymm1, ymm0        ; ymm1=Out0L=( 0  1  2 ... 29 30 31)
+    vpor        ymm5, ymm5, ymm2        ; ymm5=Out0H=(32 33 34 ... 61 62 63)
+
+    vmovdqu     YMMWORD [edx+0*SIZEOF_YMMWORD], ymm1
+    vmovdqu     YMMWORD [edx+1*SIZEOF_YMMWORD], ymm5
+
+    ; -- process the lower row
+
+    vmovdqu     ymm6, YMMWORD [edi+0*SIZEOF_YMMWORD]  ; ymm6=Int1L=( 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15)
+    vmovdqu     ymm4, YMMWORD [edi+1*SIZEOF_YMMWORD]  ; ymm4=Int1H=(16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31)
+
+    vpxor       ymm1, ymm1, ymm1        ; ymm1=(all 0's)
+
+    vperm2i128  ymm7, ymm1, ymm6, 0x03
+    vpalignr    ymm7, ymm7, ymm6, 2     ; ymm7=( 1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 --)
+    vperm2i128  ymm3, ymm1, ymm4, 0x20
+    vpslldq     ymm3, ymm3, 14          ; ymm3=(-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 16)
+
+    vperm2i128  ymm0, ymm1, ymm6, 0x03
+    vpsrldq     ymm0, ymm0, 14          ; ymm0=(15 -- -- -- -- -- -- -- -- -- -- -- -- -- -- --)
+    vperm2i128  ymm2, ymm1, ymm4, 0x20
+    vpalignr    ymm2, ymm4, ymm2, 14    ; ymm2=(-- 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30)
+
+    vpor        ymm7, ymm7, ymm3        ; ymm7=( 1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16)
+    vpor        ymm0, ymm0, ymm2        ; ymm0=(15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30)
+
+    vperm2i128  ymm5, ymm1, ymm4, 0x03
+    vpalignr    ymm5, ymm5, ymm4, 2     ; ymm5=(17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 --)
+    vperm2i128  ymm3, ymm1, ymm4, 0x03
+    vpsrldq     ymm3, ymm3, 14          ; ymm3=(31 -- -- -- -- -- -- -- -- -- -- -- -- -- -- --)
+    vperm2i128  ymm1, ymm1, ymm6, 0x20
+    vpalignr    ymm1, ymm6, ymm1, 14    ; ymm1=(--  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14)
+
+    vpor        ymm1, ymm1, YMMWORD [wk(1)]  ; ymm1=(-1  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14)
+    vpor        ymm5, ymm5, YMMWORD [wk(3)]  ; ymm5=(17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32)
+
+    vmovdqa     YMMWORD [wk(1)], ymm3
+
+    vpmullw     ymm6, ymm6, [GOTOFF(ebx,PW_THREE)]
+    vpmullw     ymm4, ymm4, [GOTOFF(ebx,PW_THREE)]
+    vpaddw      ymm1, ymm1, [GOTOFF(ebx,PW_EIGHT)]
+    vpaddw      ymm0, ymm0, [GOTOFF(ebx,PW_EIGHT)]
+    vpaddw      ymm7, ymm7, [GOTOFF(ebx,PW_SEVEN)]
+    vpaddw      ymm5, ymm5, [GOTOFF(ebx,PW_SEVEN)]
+
+    vpaddw      ymm1, ymm1, ymm6
+    vpaddw      ymm0, ymm0, ymm4
+    vpsrlw      ymm1, ymm1, 4           ; ymm1=Out1LE=( 0  2  4  6  8 10 12 14 16 18 20 22 24 26 28 30)
+    vpsrlw      ymm0, ymm0, 4           ; ymm0=Out1HE=(32 34 36 38 40 42 44 46 48 50 52 54 56 58 60 62)
+    vpaddw      ymm7, ymm7, ymm6
+    vpaddw      ymm5, ymm5, ymm4
+    vpsrlw      ymm7, ymm7, 4           ; ymm7=Out1LO=( 1  3  5  7  9 11 13 15 17 19 21 23 25 27 29 31)
+    vpsrlw      ymm5, ymm5, 4           ; ymm5=Out1HO=(33 35 37 39 41 43 45 47 49 51 53 55 57 59 61 63)
+
+    vpsllw      ymm7, ymm7, BYTE_BIT
+    vpsllw      ymm5, ymm5, BYTE_BIT
+    vpor        ymm1, ymm1, ymm7        ; ymm1=Out1L=( 0  1  2 ... 29 30 31)
+    vpor        ymm0, ymm0, ymm5        ; ymm0=Out1H=(32 33 34 ... 61 62 63)
+
+    vmovdqu     YMMWORD [edi+0*SIZEOF_YMMWORD], ymm1
+    vmovdqu     YMMWORD [edi+1*SIZEOF_YMMWORD], ymm0
+
+    poppic      ebx
+
+    sub         eax, byte SIZEOF_YMMWORD
+    add         ecx, byte 1*SIZEOF_YMMWORD  ; inptr1(above)
+    add         ebx, byte 1*SIZEOF_YMMWORD  ; inptr0
+    add         esi, byte 1*SIZEOF_YMMWORD  ; inptr1(below)
+    add         edx, byte 2*SIZEOF_YMMWORD  ; outptr0
+    add         edi, byte 2*SIZEOF_YMMWORD  ; outptr1
+    cmp         eax, byte SIZEOF_YMMWORD
+    ja          near .columnloop
+    test        eax, eax
+    jnz         near .columnloop_last
+
+    pop         esi
+    pop         edi
+    pop         ecx
+    pop         eax
+
+    add         esi, byte 1*SIZEOF_JSAMPROW  ; input_data
+    add         edi, byte 2*SIZEOF_JSAMPROW  ; output_data
+    sub         ecx, byte 2                  ; rowctr
+    jg          near .rowloop
+
+.return:
+    vzeroupper
+    pop         edi
+    pop         esi
+;   pop         edx                     ; need not be preserved
+;   pop         ecx                     ; need not be preserved
+    pop         ebx
+    mov         esp, ebp                ; esp <- aligned ebp
+    pop         esp                     ; esp <- original ebp
+    pop         ebp
+    ret
+
+; --------------------------------------------------------------------------
+;
+; Fast processing for the common case of 2:1 horizontal and 1:1 vertical.
+; It's still a box filter.
+;
+; GLOBAL(void)
+; jsimd_h2v1_upsample_avx2(int max_v_samp_factor, JDIMENSION output_width,
+;                          JSAMPARRAY input_data, JSAMPARRAY *output_data_ptr);
+;
+
+%define max_v_samp(b)       (b) + 8     ; int max_v_samp_factor
+%define output_width(b)     (b) + 12    ; JDIMENSION output_width
+%define input_data(b)       (b) + 16    ; JSAMPARRAY input_data
+%define output_data_ptr(b)  (b) + 20    ; JSAMPARRAY *output_data_ptr
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_h2v1_upsample_avx2)
+
+EXTN(jsimd_h2v1_upsample_avx2):
+    push        ebp
+    mov         ebp, esp
+;   push        ebx                     ; unused
+;   push        ecx                     ; need not be preserved
+;   push        edx                     ; need not be preserved
+    push        esi
+    push        edi
+
+    mov         edx, JDIMENSION [output_width(ebp)]
+    add         edx, byte (SIZEOF_YMMWORD-1)
+    and         edx, -SIZEOF_YMMWORD
+    jz          short .return
+
+    mov         ecx, INT [max_v_samp(ebp)]  ; rowctr
+    test        ecx, ecx
+    jz          short .return
+
+    mov         esi, JSAMPARRAY [input_data(ebp)]    ; input_data
+    mov         edi, POINTER [output_data_ptr(ebp)]
+    mov         edi, JSAMPARRAY [edi]                ; output_data
+    alignx      16, 7
+.rowloop:
+    push        edi
+    push        esi
+
+    mov         esi, JSAMPROW [esi]     ; inptr
+    mov         edi, JSAMPROW [edi]     ; outptr
+    mov         eax, edx                ; colctr
+    alignx      16, 7
+.columnloop:
+
+    cmp         eax, byte SIZEOF_YMMWORD
+    ja          near .above_16
+
+    vmovdqu     xmm0, XMMWORD [esi+0*SIZEOF_YMMWORD]
+    vpunpckhbw  xmm1, xmm0, xmm0
+    vpunpcklbw  xmm0, xmm0, xmm0
+
+    vmovdqu     XMMWORD [edi+0*SIZEOF_XMMWORD], xmm0
+    vmovdqu     XMMWORD [edi+1*SIZEOF_XMMWORD], xmm1
+
+    jmp         short .nextrow
+
+.above_16:
+    vmovdqu     ymm0, YMMWORD [esi+0*SIZEOF_YMMWORD]
+
+    vpermq      ymm0, ymm0, 0xd8
+    vpunpckhbw  ymm1, ymm0, ymm0
+    vpunpcklbw  ymm0, ymm0, ymm0
+
+    vmovdqu     YMMWORD [edi+0*SIZEOF_YMMWORD], ymm0
+    vmovdqu     YMMWORD [edi+1*SIZEOF_YMMWORD], ymm1
+
+    sub         eax, byte 2*SIZEOF_YMMWORD
+    jz          short .nextrow
+
+    add         esi, byte SIZEOF_YMMWORD    ; inptr
+    add         edi, byte 2*SIZEOF_YMMWORD  ; outptr
+    jmp         short .columnloop
+    alignx      16, 7
+
+.nextrow:
+    pop         esi
+    pop         edi
+
+    add         esi, byte SIZEOF_JSAMPROW  ; input_data
+    add         edi, byte SIZEOF_JSAMPROW  ; output_data
+    dec         ecx                        ; rowctr
+    jg          short .rowloop
+
+.return:
+    vzeroupper
+    pop         edi
+    pop         esi
+;   pop         edx                     ; need not be preserved
+;   pop         ecx                     ; need not be preserved
+;   pop         ebx                     ; unused
+    pop         ebp
+    ret
+
+; --------------------------------------------------------------------------
+;
+; Fast processing for the common case of 2:1 horizontal and 2:1 vertical.
+; It's still a box filter.
+;
+; GLOBAL(void)
+; jsimd_h2v2_upsample_avx2(int max_v_samp_factor, JDIMENSION output_width,
+;                          JSAMPARRAY input_data, JSAMPARRAY *output_data_ptr);
+;
+
+%define max_v_samp(b)       (b) + 8     ; int max_v_samp_factor
+%define output_width(b)     (b) + 12    ; JDIMENSION output_width
+%define input_data(b)       (b) + 16    ; JSAMPARRAY input_data
+%define output_data_ptr(b)  (b) + 20    ; JSAMPARRAY *output_data_ptr
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_h2v2_upsample_avx2)
+
+EXTN(jsimd_h2v2_upsample_avx2):
+    push        ebp
+    mov         ebp, esp
+    push        ebx
+;   push        ecx                     ; need not be preserved
+;   push        edx                     ; need not be preserved
+    push        esi
+    push        edi
+
+    mov         edx, JDIMENSION [output_width(ebp)]
+    add         edx, byte (SIZEOF_YMMWORD-1)
+    and         edx, -SIZEOF_YMMWORD
+    jz          near .return
+
+    mov         ecx, INT [max_v_samp(ebp)]  ; rowctr
+    test        ecx, ecx
+    jz          near .return
+
+    mov         esi, JSAMPARRAY [input_data(ebp)]    ; input_data
+    mov         edi, POINTER [output_data_ptr(ebp)]
+    mov         edi, JSAMPARRAY [edi]                ; output_data
+    alignx      16, 7
+.rowloop:
+    push        edi
+    push        esi
+
+    mov         esi, JSAMPROW [esi]                    ; inptr
+    mov         ebx, JSAMPROW [edi+0*SIZEOF_JSAMPROW]  ; outptr0
+    mov         edi, JSAMPROW [edi+1*SIZEOF_JSAMPROW]  ; outptr1
+    mov         eax, edx                               ; colctr
+    alignx      16, 7
+.columnloop:
+
+    cmp         eax, byte SIZEOF_YMMWORD
+    ja          short .above_16
+
+    vmovdqu     xmm0, XMMWORD [esi+0*SIZEOF_XMMWORD]
+    vpunpckhbw  xmm1, xmm0, xmm0
+    vpunpcklbw  xmm0, xmm0, xmm0
+
+    vmovdqu     XMMWORD [ebx+0*SIZEOF_XMMWORD], xmm0
+    vmovdqu     XMMWORD [ebx+1*SIZEOF_XMMWORD], xmm1
+    vmovdqu     XMMWORD [edi+0*SIZEOF_XMMWORD], xmm0
+    vmovdqu     XMMWORD [edi+1*SIZEOF_XMMWORD], xmm1
+
+    jmp         near .nextrow
+
+.above_16:
+    vmovdqu     ymm0, YMMWORD [esi+0*SIZEOF_YMMWORD]
+
+    vpermq      ymm0, ymm0, 0xd8
+    vpunpckhbw  ymm1, ymm0, ymm0
+    vpunpcklbw  ymm0, ymm0, ymm0
+
+    vmovdqu     YMMWORD [ebx+0*SIZEOF_YMMWORD], ymm0
+    vmovdqu     YMMWORD [ebx+1*SIZEOF_YMMWORD], ymm1
+    vmovdqu     YMMWORD [edi+0*SIZEOF_YMMWORD], ymm0
+    vmovdqu     YMMWORD [edi+1*SIZEOF_YMMWORD], ymm1
+
+    sub         eax, byte 2*SIZEOF_YMMWORD
+    jz          short .nextrow
+
+    add         esi, byte SIZEOF_YMMWORD  ; inptr
+    add         ebx, 2*SIZEOF_YMMWORD     ; outptr0
+    add         edi, 2*SIZEOF_YMMWORD     ; outptr1
+    jmp         short .columnloop
+    alignx      16, 7
+
+.nextrow:
+    pop         esi
+    pop         edi
+
+    add         esi, byte 1*SIZEOF_JSAMPROW  ; input_data
+    add         edi, byte 2*SIZEOF_JSAMPROW  ; output_data
+    sub         ecx, byte 2                  ; rowctr
+    jg          near .rowloop
+
+.return:
+    vzeroupper
+    pop         edi
+    pop         esi
+;   pop         edx                     ; need not be preserved
+;   pop         ecx                     ; need not be preserved
+    pop         ebx
+    pop         ebp
+    ret
+
+; For some reason, the OS X linker does not honor the request to align the
+; segment unless we do this.
+    align       32
diff --git a/3rdparty/libjpeg/src/simd/i386/jdsample-mmx.asm b/3rdparty/libjpeg/src/simd/i386/jdsample-mmx.asm
new file mode 100644
index 00000000..12c49f0e
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/i386/jdsample-mmx.asm
@@ -0,0 +1,731 @@
+;
+; jdsample.asm - upsampling (MMX)
+;
+; Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+; Copyright (C) 2016, D. R. Commander.
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+;
+; This file should be assembled with NASM (Netwide Assembler),
+; can *not* be assembled with Microsoft's MASM or any compatible
+; assembler (including Borland's Turbo Assembler).
+; NASM is available from http://nasm.sourceforge.net/ or
+; http://sourceforge.net/project/showfiles.php?group_id=6208
+
+%include "jsimdext.inc"
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_CONST
+
+    alignz      32
+    GLOBAL_DATA(jconst_fancy_upsample_mmx)
+
+EXTN(jconst_fancy_upsample_mmx):
+
+PW_ONE   times 4 dw 1
+PW_TWO   times 4 dw 2
+PW_THREE times 4 dw 3
+PW_SEVEN times 4 dw 7
+PW_EIGHT times 4 dw 8
+
+    alignz      32
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_TEXT
+    BITS        32
+;
+; Fancy processing for the common case of 2:1 horizontal and 1:1 vertical.
+;
+; The upsampling algorithm is linear interpolation between pixel centers,
+; also known as a "triangle filter".  This is a good compromise between
+; speed and visual quality.  The centers of the output pixels are 1/4 and 3/4
+; of the way between input pixel centers.
+;
+; GLOBAL(void)
+; jsimd_h2v1_fancy_upsample_mmx(int max_v_samp_factor,
+;                               JDIMENSION downsampled_width,
+;                               JSAMPARRAY input_data,
+;                               JSAMPARRAY *output_data_ptr);
+;
+
+%define max_v_samp(b)       (b) + 8     ; int max_v_samp_factor
+%define downsamp_width(b)   (b) + 12    ; JDIMENSION downsampled_width
+%define input_data(b)       (b) + 16    ; JSAMPARRAY input_data
+%define output_data_ptr(b)  (b) + 20    ; JSAMPARRAY *output_data_ptr
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_h2v1_fancy_upsample_mmx)
+
+EXTN(jsimd_h2v1_fancy_upsample_mmx):
+    push        ebp
+    mov         ebp, esp
+    pushpic     ebx
+;   push        ecx                     ; need not be preserved
+;   push        edx                     ; need not be preserved
+    push        esi
+    push        edi
+
+    get_GOT     ebx                     ; get GOT address
+
+    mov         eax, JDIMENSION [downsamp_width(ebp)]  ; colctr
+    test        eax, eax
+    jz          near .return
+
+    mov         ecx, INT [max_v_samp(ebp)]  ; rowctr
+    test        ecx, ecx
+    jz          near .return
+
+    mov         esi, JSAMPARRAY [input_data(ebp)]    ; input_data
+    mov         edi, POINTER [output_data_ptr(ebp)]
+    mov         edi, JSAMPARRAY [edi]                ; output_data
+    alignx      16, 7
+.rowloop:
+    push        eax                     ; colctr
+    push        edi
+    push        esi
+
+    mov         esi, JSAMPROW [esi]     ; inptr
+    mov         edi, JSAMPROW [edi]     ; outptr
+
+    test        eax, SIZEOF_MMWORD-1
+    jz          short .skip
+    mov         dl, JSAMPLE [esi+(eax-1)*SIZEOF_JSAMPLE]
+    mov         JSAMPLE [esi+eax*SIZEOF_JSAMPLE], dl    ; insert a dummy sample
+.skip:
+    pxor        mm0, mm0                ; mm0=(all 0's)
+    pcmpeqb     mm7, mm7
+    psrlq       mm7, (SIZEOF_MMWORD-1)*BYTE_BIT
+    pand        mm7,  MMWORD [esi+0*SIZEOF_MMWORD]
+
+    add         eax, byte SIZEOF_MMWORD-1
+    and         eax, byte -SIZEOF_MMWORD
+    cmp         eax, byte SIZEOF_MMWORD
+    ja          short .columnloop
+    alignx      16, 7
+
+.columnloop_last:
+    pcmpeqb     mm6, mm6
+    psllq       mm6, (SIZEOF_MMWORD-1)*BYTE_BIT
+    pand        mm6, MMWORD [esi+0*SIZEOF_MMWORD]
+    jmp         short .upsample
+    alignx      16, 7
+
+.columnloop:
+    movq        mm6, MMWORD [esi+1*SIZEOF_MMWORD]
+    psllq       mm6, (SIZEOF_MMWORD-1)*BYTE_BIT
+
+.upsample:
+    movq        mm1, MMWORD [esi+0*SIZEOF_MMWORD]
+    movq        mm2, mm1
+    movq        mm3, mm1                ; mm1=( 0 1 2 3 4 5 6 7)
+    psllq       mm2, BYTE_BIT           ; mm2=( - 0 1 2 3 4 5 6)
+    psrlq       mm3, BYTE_BIT           ; mm3=( 1 2 3 4 5 6 7 -)
+
+    por         mm2, mm7                ; mm2=(-1 0 1 2 3 4 5 6)
+    por         mm3, mm6                ; mm3=( 1 2 3 4 5 6 7 8)
+
+    movq        mm7, mm1
+    psrlq       mm7, (SIZEOF_MMWORD-1)*BYTE_BIT  ; mm7=( 7 - - - - - - -)
+
+    movq        mm4, mm1
+    punpcklbw   mm1, mm0                ; mm1=( 0 1 2 3)
+    punpckhbw   mm4, mm0                ; mm4=( 4 5 6 7)
+    movq        mm5, mm2
+    punpcklbw   mm2, mm0                ; mm2=(-1 0 1 2)
+    punpckhbw   mm5, mm0                ; mm5=( 3 4 5 6)
+    movq        mm6, mm3
+    punpcklbw   mm3, mm0                ; mm3=( 1 2 3 4)
+    punpckhbw   mm6, mm0                ; mm6=( 5 6 7 8)
+
+    pmullw      mm1, [GOTOFF(ebx,PW_THREE)]
+    pmullw      mm4, [GOTOFF(ebx,PW_THREE)]
+    paddw       mm2, [GOTOFF(ebx,PW_ONE)]
+    paddw       mm5, [GOTOFF(ebx,PW_ONE)]
+    paddw       mm3, [GOTOFF(ebx,PW_TWO)]
+    paddw       mm6, [GOTOFF(ebx,PW_TWO)]
+
+    paddw       mm2, mm1
+    paddw       mm5, mm4
+    psrlw       mm2, 2                  ; mm2=OutLE=( 0  2  4  6)
+    psrlw       mm5, 2                  ; mm5=OutHE=( 8 10 12 14)
+    paddw       mm3, mm1
+    paddw       mm6, mm4
+    psrlw       mm3, 2                  ; mm3=OutLO=( 1  3  5  7)
+    psrlw       mm6, 2                  ; mm6=OutHO=( 9 11 13 15)
+
+    psllw       mm3, BYTE_BIT
+    psllw       mm6, BYTE_BIT
+    por         mm2, mm3                ; mm2=OutL=( 0  1  2  3  4  5  6  7)
+    por         mm5, mm6                ; mm5=OutH=( 8  9 10 11 12 13 14 15)
+
+    movq        MMWORD [edi+0*SIZEOF_MMWORD], mm2
+    movq        MMWORD [edi+1*SIZEOF_MMWORD], mm5
+
+    sub         eax, byte SIZEOF_MMWORD
+    add         esi, byte 1*SIZEOF_MMWORD  ; inptr
+    add         edi, byte 2*SIZEOF_MMWORD  ; outptr
+    cmp         eax, byte SIZEOF_MMWORD
+    ja          near .columnloop
+    test        eax, eax
+    jnz         near .columnloop_last
+
+    pop         esi
+    pop         edi
+    pop         eax
+
+    add         esi, byte SIZEOF_JSAMPROW  ; input_data
+    add         edi, byte SIZEOF_JSAMPROW  ; output_data
+    dec         ecx                        ; rowctr
+    jg          near .rowloop
+
+    emms                                ; empty MMX state
+
+.return:
+    pop         edi
+    pop         esi
+;   pop         edx                     ; need not be preserved
+;   pop         ecx                     ; need not be preserved
+    poppic      ebx
+    pop         ebp
+    ret
+
+; --------------------------------------------------------------------------
+;
+; Fancy processing for the common case of 2:1 horizontal and 2:1 vertical.
+; Again a triangle filter; see comments for h2v1 case, above.
+;
+; GLOBAL(void)
+; jsimd_h2v2_fancy_upsample_mmx(int max_v_samp_factor,
+;                               JDIMENSION downsampled_width,
+;                               JSAMPARRAY input_data,
+;                               JSAMPARRAY *output_data_ptr);
+;
+
+%define max_v_samp(b)       (b) + 8     ; int max_v_samp_factor
+%define downsamp_width(b)   (b) + 12    ; JDIMENSION downsampled_width
+%define input_data(b)       (b) + 16    ; JSAMPARRAY input_data
+%define output_data_ptr(b)  (b) + 20    ; JSAMPARRAY *output_data_ptr
+
+%define original_ebp  ebp + 0
+%define wk(i)         ebp - (WK_NUM - (i)) * SIZEOF_MMWORD  ; mmword wk[WK_NUM]
+%define WK_NUM        4
+%define gotptr        wk(0) - SIZEOF_POINTER  ; void *gotptr
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_h2v2_fancy_upsample_mmx)
+
+EXTN(jsimd_h2v2_fancy_upsample_mmx):
+    push        ebp
+    mov         eax, esp                    ; eax = original ebp
+    sub         esp, byte 4
+    and         esp, byte (-SIZEOF_MMWORD)  ; align to 64 bits
+    mov         [esp], eax
+    mov         ebp, esp                    ; ebp = aligned ebp
+    lea         esp, [wk(0)]
+    pushpic     eax                     ; make a room for GOT address
+    push        ebx
+;   push        ecx                     ; need not be preserved
+;   push        edx                     ; need not be preserved
+    push        esi
+    push        edi
+
+    get_GOT     ebx                     ; get GOT address
+    movpic      POINTER [gotptr], ebx   ; save GOT address
+
+    mov         edx, eax                ; edx = original ebp
+    mov         eax, JDIMENSION [downsamp_width(edx)]  ; colctr
+    test        eax, eax
+    jz          near .return
+
+    mov         ecx, INT [max_v_samp(edx)]  ; rowctr
+    test        ecx, ecx
+    jz          near .return
+
+    mov         esi, JSAMPARRAY [input_data(edx)]    ; input_data
+    mov         edi, POINTER [output_data_ptr(edx)]
+    mov         edi, JSAMPARRAY [edi]                ; output_data
+    alignx      16, 7
+.rowloop:
+    push        eax                     ; colctr
+    push        ecx
+    push        edi
+    push        esi
+
+    mov         ecx, JSAMPROW [esi-1*SIZEOF_JSAMPROW]  ; inptr1(above)
+    mov         ebx, JSAMPROW [esi+0*SIZEOF_JSAMPROW]  ; inptr0
+    mov         esi, JSAMPROW [esi+1*SIZEOF_JSAMPROW]  ; inptr1(below)
+    mov         edx, JSAMPROW [edi+0*SIZEOF_JSAMPROW]  ; outptr0
+    mov         edi, JSAMPROW [edi+1*SIZEOF_JSAMPROW]  ; outptr1
+
+    test        eax, SIZEOF_MMWORD-1
+    jz          short .skip
+    push        edx
+    mov         dl, JSAMPLE [ecx+(eax-1)*SIZEOF_JSAMPLE]
+    mov         JSAMPLE [ecx+eax*SIZEOF_JSAMPLE], dl
+    mov         dl, JSAMPLE [ebx+(eax-1)*SIZEOF_JSAMPLE]
+    mov         JSAMPLE [ebx+eax*SIZEOF_JSAMPLE], dl
+    mov         dl, JSAMPLE [esi+(eax-1)*SIZEOF_JSAMPLE]
+    mov         JSAMPLE [esi+eax*SIZEOF_JSAMPLE], dl    ; insert a dummy sample
+    pop         edx
+.skip:
+    ; -- process the first column block
+
+    movq        mm0, MMWORD [ebx+0*SIZEOF_MMWORD]  ; mm0=row[ 0][0]
+    movq        mm1, MMWORD [ecx+0*SIZEOF_MMWORD]  ; mm1=row[-1][0]
+    movq        mm2, MMWORD [esi+0*SIZEOF_MMWORD]  ; mm2=row[+1][0]
+
+    pushpic     ebx
+    movpic      ebx, POINTER [gotptr]   ; load GOT address
+
+    pxor        mm3, mm3                ; mm3=(all 0's)
+    movq        mm4, mm0
+    punpcklbw   mm0, mm3                ; mm0=row[ 0][0]( 0 1 2 3)
+    punpckhbw   mm4, mm3                ; mm4=row[ 0][0]( 4 5 6 7)
+    movq        mm5, mm1
+    punpcklbw   mm1, mm3                ; mm1=row[-1][0]( 0 1 2 3)
+    punpckhbw   mm5, mm3                ; mm5=row[-1][0]( 4 5 6 7)
+    movq        mm6, mm2
+    punpcklbw   mm2, mm3                ; mm2=row[+1][0]( 0 1 2 3)
+    punpckhbw   mm6, mm3                ; mm6=row[+1][0]( 4 5 6 7)
+
+    pmullw      mm0, [GOTOFF(ebx,PW_THREE)]
+    pmullw      mm4, [GOTOFF(ebx,PW_THREE)]
+
+    pcmpeqb     mm7, mm7
+    psrlq       mm7, (SIZEOF_MMWORD-2)*BYTE_BIT
+
+    paddw       mm1, mm0                ; mm1=Int0L=( 0 1 2 3)
+    paddw       mm5, mm4                ; mm5=Int0H=( 4 5 6 7)
+    paddw       mm2, mm0                ; mm2=Int1L=( 0 1 2 3)
+    paddw       mm6, mm4                ; mm6=Int1H=( 4 5 6 7)
+
+    movq        MMWORD [edx+0*SIZEOF_MMWORD], mm1  ; temporarily save
+    movq        MMWORD [edx+1*SIZEOF_MMWORD], mm5  ; the intermediate data
+    movq        MMWORD [edi+0*SIZEOF_MMWORD], mm2
+    movq        MMWORD [edi+1*SIZEOF_MMWORD], mm6
+
+    pand        mm1, mm7                ; mm1=( 0 - - -)
+    pand        mm2, mm7                ; mm2=( 0 - - -)
+
+    movq        MMWORD [wk(0)], mm1
+    movq        MMWORD [wk(1)], mm2
+
+    poppic      ebx
+
+    add         eax, byte SIZEOF_MMWORD-1
+    and         eax, byte -SIZEOF_MMWORD
+    cmp         eax, byte SIZEOF_MMWORD
+    ja          short .columnloop
+    alignx      16, 7
+
+.columnloop_last:
+    ; -- process the last column block
+
+    pushpic     ebx
+    movpic      ebx, POINTER [gotptr]   ; load GOT address
+
+    pcmpeqb     mm1, mm1
+    psllq       mm1, (SIZEOF_MMWORD-2)*BYTE_BIT
+    movq        mm2, mm1
+
+    pand        mm1, MMWORD [edx+1*SIZEOF_MMWORD]  ; mm1=( - - - 7)
+    pand        mm2, MMWORD [edi+1*SIZEOF_MMWORD]  ; mm2=( - - - 7)
+
+    movq        MMWORD [wk(2)], mm1
+    movq        MMWORD [wk(3)], mm2
+
+    jmp         short .upsample
+    alignx      16, 7
+
+.columnloop:
+    ; -- process the next column block
+
+    movq        mm0, MMWORD [ebx+1*SIZEOF_MMWORD]  ; mm0=row[ 0][1]
+    movq        mm1, MMWORD [ecx+1*SIZEOF_MMWORD]  ; mm1=row[-1][1]
+    movq        mm2, MMWORD [esi+1*SIZEOF_MMWORD]  ; mm2=row[+1][1]
+
+    pushpic     ebx
+    movpic      ebx, POINTER [gotptr]   ; load GOT address
+
+    pxor        mm3, mm3                ; mm3=(all 0's)
+    movq        mm4, mm0
+    punpcklbw   mm0, mm3                ; mm0=row[ 0][1]( 0 1 2 3)
+    punpckhbw   mm4, mm3                ; mm4=row[ 0][1]( 4 5 6 7)
+    movq        mm5, mm1
+    punpcklbw   mm1, mm3                ; mm1=row[-1][1]( 0 1 2 3)
+    punpckhbw   mm5, mm3                ; mm5=row[-1][1]( 4 5 6 7)
+    movq        mm6, mm2
+    punpcklbw   mm2, mm3                ; mm2=row[+1][1]( 0 1 2 3)
+    punpckhbw   mm6, mm3                ; mm6=row[+1][1]( 4 5 6 7)
+
+    pmullw      mm0, [GOTOFF(ebx,PW_THREE)]
+    pmullw      mm4, [GOTOFF(ebx,PW_THREE)]
+
+    paddw       mm1, mm0                ; mm1=Int0L=( 0 1 2 3)
+    paddw       mm5, mm4                ; mm5=Int0H=( 4 5 6 7)
+    paddw       mm2, mm0                ; mm2=Int1L=( 0 1 2 3)
+    paddw       mm6, mm4                ; mm6=Int1H=( 4 5 6 7)
+
+    movq        MMWORD [edx+2*SIZEOF_MMWORD], mm1  ; temporarily save
+    movq        MMWORD [edx+3*SIZEOF_MMWORD], mm5  ; the intermediate data
+    movq        MMWORD [edi+2*SIZEOF_MMWORD], mm2
+    movq        MMWORD [edi+3*SIZEOF_MMWORD], mm6
+
+    psllq       mm1, (SIZEOF_MMWORD-2)*BYTE_BIT  ; mm1=( - - - 0)
+    psllq       mm2, (SIZEOF_MMWORD-2)*BYTE_BIT  ; mm2=( - - - 0)
+
+    movq        MMWORD [wk(2)], mm1
+    movq        MMWORD [wk(3)], mm2
+
+.upsample:
+    ; -- process the upper row
+
+    movq        mm7, MMWORD [edx+0*SIZEOF_MMWORD]  ; mm7=Int0L=( 0 1 2 3)
+    movq        mm3, MMWORD [edx+1*SIZEOF_MMWORD]  ; mm3=Int0H=( 4 5 6 7)
+
+    movq        mm0, mm7
+    movq        mm4, mm3
+    psrlq       mm0, 2*BYTE_BIT                  ; mm0=( 1 2 3 -)
+    psllq       mm4, (SIZEOF_MMWORD-2)*BYTE_BIT  ; mm4=( - - - 4)
+    movq        mm5, mm7
+    movq        mm6, mm3
+    psrlq       mm5, (SIZEOF_MMWORD-2)*BYTE_BIT  ; mm5=( 3 - - -)
+    psllq       mm6, 2*BYTE_BIT                  ; mm6=( - 4 5 6)
+
+    por         mm0, mm4                         ; mm0=( 1 2 3 4)
+    por         mm5, mm6                         ; mm5=( 3 4 5 6)
+
+    movq        mm1, mm7
+    movq        mm2, mm3
+    psllq       mm1, 2*BYTE_BIT                  ; mm1=( - 0 1 2)
+    psrlq       mm2, 2*BYTE_BIT                  ; mm2=( 5 6 7 -)
+    movq        mm4, mm3
+    psrlq       mm4, (SIZEOF_MMWORD-2)*BYTE_BIT  ; mm4=( 7 - - -)
+
+    por         mm1, MMWORD [wk(0)]              ; mm1=(-1 0 1 2)
+    por         mm2, MMWORD [wk(2)]              ; mm2=( 5 6 7 8)
+
+    movq        MMWORD [wk(0)], mm4
+
+    pmullw      mm7, [GOTOFF(ebx,PW_THREE)]
+    pmullw      mm3, [GOTOFF(ebx,PW_THREE)]
+    paddw       mm1, [GOTOFF(ebx,PW_EIGHT)]
+    paddw       mm5, [GOTOFF(ebx,PW_EIGHT)]
+    paddw       mm0, [GOTOFF(ebx,PW_SEVEN)]
+    paddw       mm2, [GOTOFF(ebx,PW_SEVEN)]
+
+    paddw       mm1, mm7
+    paddw       mm5, mm3
+    psrlw       mm1, 4                  ; mm1=Out0LE=( 0  2  4  6)
+    psrlw       mm5, 4                  ; mm5=Out0HE=( 8 10 12 14)
+    paddw       mm0, mm7
+    paddw       mm2, mm3
+    psrlw       mm0, 4                  ; mm0=Out0LO=( 1  3  5  7)
+    psrlw       mm2, 4                  ; mm2=Out0HO=( 9 11 13 15)
+
+    psllw       mm0, BYTE_BIT
+    psllw       mm2, BYTE_BIT
+    por         mm1, mm0                ; mm1=Out0L=( 0  1  2  3  4  5  6  7)
+    por         mm5, mm2                ; mm5=Out0H=( 8  9 10 11 12 13 14 15)
+
+    movq        MMWORD [edx+0*SIZEOF_MMWORD], mm1
+    movq        MMWORD [edx+1*SIZEOF_MMWORD], mm5
+
+    ; -- process the lower row
+
+    movq        mm6, MMWORD [edi+0*SIZEOF_MMWORD]  ; mm6=Int1L=( 0 1 2 3)
+    movq        mm4, MMWORD [edi+1*SIZEOF_MMWORD]  ; mm4=Int1H=( 4 5 6 7)
+
+    movq        mm7, mm6
+    movq        mm3, mm4
+    psrlq       mm7, 2*BYTE_BIT                  ; mm7=( 1 2 3 -)
+    psllq       mm3, (SIZEOF_MMWORD-2)*BYTE_BIT  ; mm3=( - - - 4)
+    movq        mm0, mm6
+    movq        mm2, mm4
+    psrlq       mm0, (SIZEOF_MMWORD-2)*BYTE_BIT  ; mm0=( 3 - - -)
+    psllq       mm2, 2*BYTE_BIT                  ; mm2=( - 4 5 6)
+
+    por         mm7, mm3                         ; mm7=( 1 2 3 4)
+    por         mm0, mm2                         ; mm0=( 3 4 5 6)
+
+    movq        mm1, mm6
+    movq        mm5, mm4
+    psllq       mm1, 2*BYTE_BIT                  ; mm1=( - 0 1 2)
+    psrlq       mm5, 2*BYTE_BIT                  ; mm5=( 5 6 7 -)
+    movq        mm3, mm4
+    psrlq       mm3, (SIZEOF_MMWORD-2)*BYTE_BIT  ; mm3=( 7 - - -)
+
+    por         mm1, MMWORD [wk(1)]              ; mm1=(-1 0 1 2)
+    por         mm5, MMWORD [wk(3)]              ; mm5=( 5 6 7 8)
+
+    movq        MMWORD [wk(1)], mm3
+
+    pmullw      mm6, [GOTOFF(ebx,PW_THREE)]
+    pmullw      mm4, [GOTOFF(ebx,PW_THREE)]
+    paddw       mm1, [GOTOFF(ebx,PW_EIGHT)]
+    paddw       mm0, [GOTOFF(ebx,PW_EIGHT)]
+    paddw       mm7, [GOTOFF(ebx,PW_SEVEN)]
+    paddw       mm5, [GOTOFF(ebx,PW_SEVEN)]
+
+    paddw       mm1, mm6
+    paddw       mm0, mm4
+    psrlw       mm1, 4                  ; mm1=Out1LE=( 0  2  4  6)
+    psrlw       mm0, 4                  ; mm0=Out1HE=( 8 10 12 14)
+    paddw       mm7, mm6
+    paddw       mm5, mm4
+    psrlw       mm7, 4                  ; mm7=Out1LO=( 1  3  5  7)
+    psrlw       mm5, 4                  ; mm5=Out1HO=( 9 11 13 15)
+
+    psllw       mm7, BYTE_BIT
+    psllw       mm5, BYTE_BIT
+    por         mm1, mm7                ; mm1=Out1L=( 0  1  2  3  4  5  6  7)
+    por         mm0, mm5                ; mm0=Out1H=( 8  9 10 11 12 13 14 15)
+
+    movq        MMWORD [edi+0*SIZEOF_MMWORD], mm1
+    movq        MMWORD [edi+1*SIZEOF_MMWORD], mm0
+
+    poppic      ebx
+
+    sub         eax, byte SIZEOF_MMWORD
+    add         ecx, byte 1*SIZEOF_MMWORD  ; inptr1(above)
+    add         ebx, byte 1*SIZEOF_MMWORD  ; inptr0
+    add         esi, byte 1*SIZEOF_MMWORD  ; inptr1(below)
+    add         edx, byte 2*SIZEOF_MMWORD  ; outptr0
+    add         edi, byte 2*SIZEOF_MMWORD  ; outptr1
+    cmp         eax, byte SIZEOF_MMWORD
+    ja          near .columnloop
+    test        eax, eax
+    jnz         near .columnloop_last
+
+    pop         esi
+    pop         edi
+    pop         ecx
+    pop         eax
+
+    add         esi, byte 1*SIZEOF_JSAMPROW  ; input_data
+    add         edi, byte 2*SIZEOF_JSAMPROW  ; output_data
+    sub         ecx, byte 2                  ; rowctr
+    jg          near .rowloop
+
+    emms                                ; empty MMX state
+
+.return:
+    pop         edi
+    pop         esi
+;   pop         edx                     ; need not be preserved
+;   pop         ecx                     ; need not be preserved
+    pop         ebx
+    mov         esp, ebp                ; esp <- aligned ebp
+    pop         esp                     ; esp <- original ebp
+    pop         ebp
+    ret
+
+; --------------------------------------------------------------------------
+;
+; Fast processing for the common case of 2:1 horizontal and 1:1 vertical.
+; It's still a box filter.
+;
+; GLOBAL(void)
+; jsimd_h2v1_upsample_mmx(int max_v_samp_factor, JDIMENSION output_width,
+;                         JSAMPARRAY input_data, JSAMPARRAY *output_data_ptr);
+;
+
+%define max_v_samp(b)       (b) + 8     ; int max_v_samp_factor
+%define output_width(b)     (b) + 12    ; JDIMENSION output_width
+%define input_data(b)       (b) + 16    ; JSAMPARRAY input_data
+%define output_data_ptr(b)  (b) + 20    ; JSAMPARRAY *output_data_ptr
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_h2v1_upsample_mmx)
+
+EXTN(jsimd_h2v1_upsample_mmx):
+    push        ebp
+    mov         ebp, esp
+;   push        ebx                     ; unused
+;   push        ecx                     ; need not be preserved
+;   push        edx                     ; need not be preserved
+    push        esi
+    push        edi
+
+    mov         edx, JDIMENSION [output_width(ebp)]
+    add         edx, byte (2*SIZEOF_MMWORD)-1
+    and         edx, byte -(2*SIZEOF_MMWORD)
+    jz          short .return
+
+    mov         ecx, INT [max_v_samp(ebp)]  ; rowctr
+    test        ecx, ecx
+    jz          short .return
+
+    mov         esi, JSAMPARRAY [input_data(ebp)]    ; input_data
+    mov         edi, POINTER [output_data_ptr(ebp)]
+    mov         edi, JSAMPARRAY [edi]                ; output_data
+    alignx      16, 7
+.rowloop:
+    push        edi
+    push        esi
+
+    mov         esi, JSAMPROW [esi]     ; inptr
+    mov         edi, JSAMPROW [edi]     ; outptr
+    mov         eax, edx                ; colctr
+    alignx      16, 7
+.columnloop:
+
+    movq        mm0, MMWORD [esi+0*SIZEOF_MMWORD]
+
+    movq        mm1, mm0
+    punpcklbw   mm0, mm0
+    punpckhbw   mm1, mm1
+
+    movq        MMWORD [edi+0*SIZEOF_MMWORD], mm0
+    movq        MMWORD [edi+1*SIZEOF_MMWORD], mm1
+
+    sub         eax, byte 2*SIZEOF_MMWORD
+    jz          short .nextrow
+
+    movq        mm2, MMWORD [esi+1*SIZEOF_MMWORD]
+
+    movq        mm3, mm2
+    punpcklbw   mm2, mm2
+    punpckhbw   mm3, mm3
+
+    movq        MMWORD [edi+2*SIZEOF_MMWORD], mm2
+    movq        MMWORD [edi+3*SIZEOF_MMWORD], mm3
+
+    sub         eax, byte 2*SIZEOF_MMWORD
+    jz          short .nextrow
+
+    add         esi, byte 2*SIZEOF_MMWORD  ; inptr
+    add         edi, byte 4*SIZEOF_MMWORD  ; outptr
+    jmp         short .columnloop
+    alignx      16, 7
+
+.nextrow:
+    pop         esi
+    pop         edi
+
+    add         esi, byte SIZEOF_JSAMPROW  ; input_data
+    add         edi, byte SIZEOF_JSAMPROW  ; output_data
+    dec         ecx                        ; rowctr
+    jg          short .rowloop
+
+    emms                                ; empty MMX state
+
+.return:
+    pop         edi
+    pop         esi
+;   pop         edx                     ; need not be preserved
+;   pop         ecx                     ; need not be preserved
+;   pop         ebx                     ; unused
+    pop         ebp
+    ret
+
+; --------------------------------------------------------------------------
+;
+; Fast processing for the common case of 2:1 horizontal and 2:1 vertical.
+; It's still a box filter.
+;
+; GLOBAL(void)
+; jsimd_h2v2_upsample_mmx(int max_v_samp_factor, JDIMENSION output_width,
+;                         JSAMPARRAY input_data, JSAMPARRAY *output_data_ptr);
+;
+
+%define max_v_samp(b)       (b) + 8     ; int max_v_samp_factor
+%define output_width(b)     (b) + 12    ; JDIMENSION output_width
+%define input_data(b)       (b) + 16    ; JSAMPARRAY input_data
+%define output_data_ptr(b)  (b) + 20    ; JSAMPARRAY *output_data_ptr
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_h2v2_upsample_mmx)
+
+EXTN(jsimd_h2v2_upsample_mmx):
+    push        ebp
+    mov         ebp, esp
+    push        ebx
+;   push        ecx                     ; need not be preserved
+;   push        edx                     ; need not be preserved
+    push        esi
+    push        edi
+
+    mov         edx, JDIMENSION [output_width(ebp)]
+    add         edx, byte (2*SIZEOF_MMWORD)-1
+    and         edx, byte -(2*SIZEOF_MMWORD)
+    jz          near .return
+
+    mov         ecx, INT [max_v_samp(ebp)]  ; rowctr
+    test        ecx, ecx
+    jz          short .return
+
+    mov         esi, JSAMPARRAY [input_data(ebp)]    ; input_data
+    mov         edi, POINTER [output_data_ptr(ebp)]
+    mov         edi, JSAMPARRAY [edi]                ; output_data
+    alignx      16, 7
+.rowloop:
+    push        edi
+    push        esi
+
+    mov         esi, JSAMPROW [esi]                    ; inptr
+    mov         ebx, JSAMPROW [edi+0*SIZEOF_JSAMPROW]  ; outptr0
+    mov         edi, JSAMPROW [edi+1*SIZEOF_JSAMPROW]  ; outptr1
+    mov         eax, edx                               ; colctr
+    alignx      16, 7
+.columnloop:
+
+    movq        mm0, MMWORD [esi+0*SIZEOF_MMWORD]
+
+    movq        mm1, mm0
+    punpcklbw   mm0, mm0
+    punpckhbw   mm1, mm1
+
+    movq        MMWORD [ebx+0*SIZEOF_MMWORD], mm0
+    movq        MMWORD [ebx+1*SIZEOF_MMWORD], mm1
+    movq        MMWORD [edi+0*SIZEOF_MMWORD], mm0
+    movq        MMWORD [edi+1*SIZEOF_MMWORD], mm1
+
+    sub         eax, byte 2*SIZEOF_MMWORD
+    jz          short .nextrow
+
+    movq        mm2, MMWORD [esi+1*SIZEOF_MMWORD]
+
+    movq        mm3, mm2
+    punpcklbw   mm2, mm2
+    punpckhbw   mm3, mm3
+
+    movq        MMWORD [ebx+2*SIZEOF_MMWORD], mm2
+    movq        MMWORD [ebx+3*SIZEOF_MMWORD], mm3
+    movq        MMWORD [edi+2*SIZEOF_MMWORD], mm2
+    movq        MMWORD [edi+3*SIZEOF_MMWORD], mm3
+
+    sub         eax, byte 2*SIZEOF_MMWORD
+    jz          short .nextrow
+
+    add         esi, byte 2*SIZEOF_MMWORD  ; inptr
+    add         ebx, byte 4*SIZEOF_MMWORD  ; outptr0
+    add         edi, byte 4*SIZEOF_MMWORD  ; outptr1
+    jmp         short .columnloop
+    alignx      16, 7
+
+.nextrow:
+    pop         esi
+    pop         edi
+
+    add         esi, byte 1*SIZEOF_JSAMPROW  ; input_data
+    add         edi, byte 2*SIZEOF_JSAMPROW  ; output_data
+    sub         ecx, byte 2                  ; rowctr
+    jg          short .rowloop
+
+    emms                                ; empty MMX state
+
+.return:
+    pop         edi
+    pop         esi
+;   pop         edx                     ; need not be preserved
+;   pop         ecx                     ; need not be preserved
+    pop         ebx
+    pop         ebp
+    ret
+
+; For some reason, the OS X linker does not honor the request to align the
+; segment unless we do this.
+    align       32
diff --git a/3rdparty/libjpeg/src/simd/i386/jdsample-sse2.asm b/3rdparty/libjpeg/src/simd/i386/jdsample-sse2.asm
new file mode 100644
index 00000000..4e28d2f4
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/i386/jdsample-sse2.asm
@@ -0,0 +1,724 @@
+;
+; jdsample.asm - upsampling (SSE2)
+;
+; Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+; Copyright (C) 2016, D. R. Commander.
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+;
+; This file should be assembled with NASM (Netwide Assembler),
+; can *not* be assembled with Microsoft's MASM or any compatible
+; assembler (including Borland's Turbo Assembler).
+; NASM is available from http://nasm.sourceforge.net/ or
+; http://sourceforge.net/project/showfiles.php?group_id=6208
+
+%include "jsimdext.inc"
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_CONST
+
+    alignz      32
+    GLOBAL_DATA(jconst_fancy_upsample_sse2)
+
+EXTN(jconst_fancy_upsample_sse2):
+
+PW_ONE   times 8 dw 1
+PW_TWO   times 8 dw 2
+PW_THREE times 8 dw 3
+PW_SEVEN times 8 dw 7
+PW_EIGHT times 8 dw 8
+
+    alignz      32
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_TEXT
+    BITS        32
+;
+; Fancy processing for the common case of 2:1 horizontal and 1:1 vertical.
+;
+; The upsampling algorithm is linear interpolation between pixel centers,
+; also known as a "triangle filter".  This is a good compromise between
+; speed and visual quality.  The centers of the output pixels are 1/4 and 3/4
+; of the way between input pixel centers.
+;
+; GLOBAL(void)
+; jsimd_h2v1_fancy_upsample_sse2(int max_v_samp_factor,
+;                                JDIMENSION downsampled_width,
+;                                JSAMPARRAY input_data,
+;                                JSAMPARRAY *output_data_ptr);
+;
+
+%define max_v_samp(b)       (b) + 8     ; int max_v_samp_factor
+%define downsamp_width(b)   (b) + 12    ; JDIMENSION downsampled_width
+%define input_data(b)       (b) + 16    ; JSAMPARRAY input_data
+%define output_data_ptr(b)  (b) + 20    ; JSAMPARRAY *output_data_ptr
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_h2v1_fancy_upsample_sse2)
+
+EXTN(jsimd_h2v1_fancy_upsample_sse2):
+    push        ebp
+    mov         ebp, esp
+    pushpic     ebx
+;   push        ecx                     ; need not be preserved
+;   push        edx                     ; need not be preserved
+    push        esi
+    push        edi
+
+    get_GOT     ebx                     ; get GOT address
+
+    mov         eax, JDIMENSION [downsamp_width(ebp)]  ; colctr
+    test        eax, eax
+    jz          near .return
+
+    mov         ecx, INT [max_v_samp(ebp)]  ; rowctr
+    test        ecx, ecx
+    jz          near .return
+
+    mov         esi, JSAMPARRAY [input_data(ebp)]    ; input_data
+    mov         edi, POINTER [output_data_ptr(ebp)]
+    mov         edi, JSAMPARRAY [edi]                ; output_data
+    alignx      16, 7
+.rowloop:
+    push        eax                     ; colctr
+    push        edi
+    push        esi
+
+    mov         esi, JSAMPROW [esi]     ; inptr
+    mov         edi, JSAMPROW [edi]     ; outptr
+
+    test        eax, SIZEOF_XMMWORD-1
+    jz          short .skip
+    mov         dl, JSAMPLE [esi+(eax-1)*SIZEOF_JSAMPLE]
+    mov         JSAMPLE [esi+eax*SIZEOF_JSAMPLE], dl    ; insert a dummy sample
+.skip:
+    pxor        xmm0, xmm0              ; xmm0=(all 0's)
+    pcmpeqb     xmm7, xmm7
+    psrldq      xmm7, (SIZEOF_XMMWORD-1)
+    pand        xmm7, XMMWORD [esi+0*SIZEOF_XMMWORD]
+
+    add         eax, byte SIZEOF_XMMWORD-1
+    and         eax, byte -SIZEOF_XMMWORD
+    cmp         eax, byte SIZEOF_XMMWORD
+    ja          short .columnloop
+    alignx      16, 7
+
+.columnloop_last:
+    pcmpeqb     xmm6, xmm6
+    pslldq      xmm6, (SIZEOF_XMMWORD-1)
+    pand        xmm6, XMMWORD [esi+0*SIZEOF_XMMWORD]
+    jmp         short .upsample
+    alignx      16, 7
+
+.columnloop:
+    movdqa      xmm6, XMMWORD [esi+1*SIZEOF_XMMWORD]
+    pslldq      xmm6, (SIZEOF_XMMWORD-1)
+
+.upsample:
+    movdqa      xmm1, XMMWORD [esi+0*SIZEOF_XMMWORD]
+    movdqa      xmm2, xmm1
+    movdqa      xmm3, xmm1                ; xmm1=( 0  1  2 ... 13 14 15)
+    pslldq      xmm2, 1                   ; xmm2=(--  0  1 ... 12 13 14)
+    psrldq      xmm3, 1                   ; xmm3=( 1  2  3 ... 14 15 --)
+
+    por         xmm2, xmm7                ; xmm2=(-1  0  1 ... 12 13 14)
+    por         xmm3, xmm6                ; xmm3=( 1  2  3 ... 14 15 16)
+
+    movdqa      xmm7, xmm1
+    psrldq      xmm7, (SIZEOF_XMMWORD-1)  ; xmm7=(15 -- -- ... -- -- --)
+
+    movdqa      xmm4, xmm1
+    punpcklbw   xmm1, xmm0                ; xmm1=( 0  1  2  3  4  5  6  7)
+    punpckhbw   xmm4, xmm0                ; xmm4=( 8  9 10 11 12 13 14 15)
+    movdqa      xmm5, xmm2
+    punpcklbw   xmm2, xmm0                ; xmm2=(-1  0  1  2  3  4  5  6)
+    punpckhbw   xmm5, xmm0                ; xmm5=( 7  8  9 10 11 12 13 14)
+    movdqa      xmm6, xmm3
+    punpcklbw   xmm3, xmm0                ; xmm3=( 1  2  3  4  5  6  7  8)
+    punpckhbw   xmm6, xmm0                ; xmm6=( 9 10 11 12 13 14 15 16)
+
+    pmullw      xmm1, [GOTOFF(ebx,PW_THREE)]
+    pmullw      xmm4, [GOTOFF(ebx,PW_THREE)]
+    paddw       xmm2, [GOTOFF(ebx,PW_ONE)]
+    paddw       xmm5, [GOTOFF(ebx,PW_ONE)]
+    paddw       xmm3, [GOTOFF(ebx,PW_TWO)]
+    paddw       xmm6, [GOTOFF(ebx,PW_TWO)]
+
+    paddw       xmm2, xmm1
+    paddw       xmm5, xmm4
+    psrlw       xmm2, 2                 ; xmm2=OutLE=( 0  2  4  6  8 10 12 14)
+    psrlw       xmm5, 2                 ; xmm5=OutHE=(16 18 20 22 24 26 28 30)
+    paddw       xmm3, xmm1
+    paddw       xmm6, xmm4
+    psrlw       xmm3, 2                 ; xmm3=OutLO=( 1  3  5  7  9 11 13 15)
+    psrlw       xmm6, 2                 ; xmm6=OutHO=(17 19 21 23 25 27 29 31)
+
+    psllw       xmm3, BYTE_BIT
+    psllw       xmm6, BYTE_BIT
+    por         xmm2, xmm3              ; xmm2=OutL=( 0  1  2 ... 13 14 15)
+    por         xmm5, xmm6              ; xmm5=OutH=(16 17 18 ... 29 30 31)
+
+    movdqa      XMMWORD [edi+0*SIZEOF_XMMWORD], xmm2
+    movdqa      XMMWORD [edi+1*SIZEOF_XMMWORD], xmm5
+
+    sub         eax, byte SIZEOF_XMMWORD
+    add         esi, byte 1*SIZEOF_XMMWORD  ; inptr
+    add         edi, byte 2*SIZEOF_XMMWORD  ; outptr
+    cmp         eax, byte SIZEOF_XMMWORD
+    ja          near .columnloop
+    test        eax, eax
+    jnz         near .columnloop_last
+
+    pop         esi
+    pop         edi
+    pop         eax
+
+    add         esi, byte SIZEOF_JSAMPROW  ; input_data
+    add         edi, byte SIZEOF_JSAMPROW  ; output_data
+    dec         ecx                        ; rowctr
+    jg          near .rowloop
+
+.return:
+    pop         edi
+    pop         esi
+;   pop         edx                     ; need not be preserved
+;   pop         ecx                     ; need not be preserved
+    poppic      ebx
+    pop         ebp
+    ret
+
+; --------------------------------------------------------------------------
+;
+; Fancy processing for the common case of 2:1 horizontal and 2:1 vertical.
+; Again a triangle filter; see comments for h2v1 case, above.
+;
+; GLOBAL(void)
+; jsimd_h2v2_fancy_upsample_sse2(int max_v_samp_factor,
+;                                JDIMENSION downsampled_width,
+;                                JSAMPARRAY input_data,
+;                                JSAMPARRAY *output_data_ptr);
+;
+
+%define max_v_samp(b)       (b) + 8     ; int max_v_samp_factor
+%define downsamp_width(b)   (b) + 12    ; JDIMENSION downsampled_width
+%define input_data(b)       (b) + 16    ; JSAMPARRAY input_data
+%define output_data_ptr(b)  (b) + 20    ; JSAMPARRAY *output_data_ptr
+
+%define original_ebp  ebp + 0
+%define wk(i)         ebp - (WK_NUM - (i)) * SIZEOF_XMMWORD
+                                        ; xmmword wk[WK_NUM]
+%define WK_NUM        4
+%define gotptr        wk(0) - SIZEOF_POINTER  ; void *gotptr
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_h2v2_fancy_upsample_sse2)
+
+EXTN(jsimd_h2v2_fancy_upsample_sse2):
+    push        ebp
+    mov         eax, esp                     ; eax = original ebp
+    sub         esp, byte 4
+    and         esp, byte (-SIZEOF_XMMWORD)  ; align to 128 bits
+    mov         [esp], eax
+    mov         ebp, esp                     ; ebp = aligned ebp
+    lea         esp, [wk(0)]
+    pushpic     eax                     ; make a room for GOT address
+    push        ebx
+;   push        ecx                     ; need not be preserved
+;   push        edx                     ; need not be preserved
+    push        esi
+    push        edi
+
+    get_GOT     ebx                     ; get GOT address
+    movpic      POINTER [gotptr], ebx   ; save GOT address
+
+    mov         edx, eax                ; edx = original ebp
+    mov         eax, JDIMENSION [downsamp_width(edx)]  ; colctr
+    test        eax, eax
+    jz          near .return
+
+    mov         ecx, INT [max_v_samp(edx)]  ; rowctr
+    test        ecx, ecx
+    jz          near .return
+
+    mov         esi, JSAMPARRAY [input_data(edx)]    ; input_data
+    mov         edi, POINTER [output_data_ptr(edx)]
+    mov         edi, JSAMPARRAY [edi]                ; output_data
+    alignx      16, 7
+.rowloop:
+    push        eax                     ; colctr
+    push        ecx
+    push        edi
+    push        esi
+
+    mov         ecx, JSAMPROW [esi-1*SIZEOF_JSAMPROW]  ; inptr1(above)
+    mov         ebx, JSAMPROW [esi+0*SIZEOF_JSAMPROW]  ; inptr0
+    mov         esi, JSAMPROW [esi+1*SIZEOF_JSAMPROW]  ; inptr1(below)
+    mov         edx, JSAMPROW [edi+0*SIZEOF_JSAMPROW]  ; outptr0
+    mov         edi, JSAMPROW [edi+1*SIZEOF_JSAMPROW]  ; outptr1
+
+    test        eax, SIZEOF_XMMWORD-1
+    jz          short .skip
+    push        edx
+    mov         dl, JSAMPLE [ecx+(eax-1)*SIZEOF_JSAMPLE]
+    mov         JSAMPLE [ecx+eax*SIZEOF_JSAMPLE], dl
+    mov         dl, JSAMPLE [ebx+(eax-1)*SIZEOF_JSAMPLE]
+    mov         JSAMPLE [ebx+eax*SIZEOF_JSAMPLE], dl
+    mov         dl, JSAMPLE [esi+(eax-1)*SIZEOF_JSAMPLE]
+    mov         JSAMPLE [esi+eax*SIZEOF_JSAMPLE], dl    ; insert a dummy sample
+    pop         edx
+.skip:
+    ; -- process the first column block
+
+    movdqa      xmm0, XMMWORD [ebx+0*SIZEOF_XMMWORD]  ; xmm0=row[ 0][0]
+    movdqa      xmm1, XMMWORD [ecx+0*SIZEOF_XMMWORD]  ; xmm1=row[-1][0]
+    movdqa      xmm2, XMMWORD [esi+0*SIZEOF_XMMWORD]  ; xmm2=row[+1][0]
+
+    pushpic     ebx
+    movpic      ebx, POINTER [gotptr]   ; load GOT address
+
+    pxor        xmm3, xmm3              ; xmm3=(all 0's)
+    movdqa      xmm4, xmm0
+    punpcklbw   xmm0, xmm3              ; xmm0=row[ 0]( 0  1  2  3  4  5  6  7)
+    punpckhbw   xmm4, xmm3              ; xmm4=row[ 0]( 8  9 10 11 12 13 14 15)
+    movdqa      xmm5, xmm1
+    punpcklbw   xmm1, xmm3              ; xmm1=row[-1]( 0  1  2  3  4  5  6  7)
+    punpckhbw   xmm5, xmm3              ; xmm5=row[-1]( 8  9 10 11 12 13 14 15)
+    movdqa      xmm6, xmm2
+    punpcklbw   xmm2, xmm3              ; xmm2=row[+1]( 0  1  2  3  4  5  6  7)
+    punpckhbw   xmm6, xmm3              ; xmm6=row[+1]( 8  9 10 11 12 13 14 15)
+
+    pmullw      xmm0, [GOTOFF(ebx,PW_THREE)]
+    pmullw      xmm4, [GOTOFF(ebx,PW_THREE)]
+
+    pcmpeqb     xmm7, xmm7
+    psrldq      xmm7, (SIZEOF_XMMWORD-2)
+
+    paddw       xmm1, xmm0              ; xmm1=Int0L=( 0  1  2  3  4  5  6  7)
+    paddw       xmm5, xmm4              ; xmm5=Int0H=( 8  9 10 11 12 13 14 15)
+    paddw       xmm2, xmm0              ; xmm2=Int1L=( 0  1  2  3  4  5  6  7)
+    paddw       xmm6, xmm4              ; xmm6=Int1H=( 8  9 10 11 12 13 14 15)
+
+    movdqa      XMMWORD [edx+0*SIZEOF_XMMWORD], xmm1  ; temporarily save
+    movdqa      XMMWORD [edx+1*SIZEOF_XMMWORD], xmm5  ; the intermediate data
+    movdqa      XMMWORD [edi+0*SIZEOF_XMMWORD], xmm2
+    movdqa      XMMWORD [edi+1*SIZEOF_XMMWORD], xmm6
+
+    pand        xmm1, xmm7              ; xmm1=( 0 -- -- -- -- -- -- --)
+    pand        xmm2, xmm7              ; xmm2=( 0 -- -- -- -- -- -- --)
+
+    movdqa      XMMWORD [wk(0)], xmm1
+    movdqa      XMMWORD [wk(1)], xmm2
+
+    poppic      ebx
+
+    add         eax, byte SIZEOF_XMMWORD-1
+    and         eax, byte -SIZEOF_XMMWORD
+    cmp         eax, byte SIZEOF_XMMWORD
+    ja          short .columnloop
+    alignx      16, 7
+
+.columnloop_last:
+    ; -- process the last column block
+
+    pushpic     ebx
+    movpic      ebx, POINTER [gotptr]   ; load GOT address
+
+    pcmpeqb     xmm1, xmm1
+    pslldq      xmm1, (SIZEOF_XMMWORD-2)
+    movdqa      xmm2, xmm1
+
+    pand        xmm1, XMMWORD [edx+1*SIZEOF_XMMWORD]
+    pand        xmm2, XMMWORD [edi+1*SIZEOF_XMMWORD]
+
+    movdqa      XMMWORD [wk(2)], xmm1   ; xmm1=(-- -- -- -- -- -- -- 15)
+    movdqa      XMMWORD [wk(3)], xmm2   ; xmm2=(-- -- -- -- -- -- -- 15)
+
+    jmp         near .upsample
+    alignx      16, 7
+
+.columnloop:
+    ; -- process the next column block
+
+    movdqa      xmm0, XMMWORD [ebx+1*SIZEOF_XMMWORD]  ; xmm0=row[ 0][1]
+    movdqa      xmm1, XMMWORD [ecx+1*SIZEOF_XMMWORD]  ; xmm1=row[-1][1]
+    movdqa      xmm2, XMMWORD [esi+1*SIZEOF_XMMWORD]  ; xmm2=row[+1][1]
+
+    pushpic     ebx
+    movpic      ebx, POINTER [gotptr]   ; load GOT address
+
+    pxor        xmm3, xmm3              ; xmm3=(all 0's)
+    movdqa      xmm4, xmm0
+    punpcklbw   xmm0, xmm3              ; xmm0=row[ 0]( 0  1  2  3  4  5  6  7)
+    punpckhbw   xmm4, xmm3              ; xmm4=row[ 0]( 8  9 10 11 12 13 14 15)
+    movdqa      xmm5, xmm1
+    punpcklbw   xmm1, xmm3              ; xmm1=row[-1]( 0  1  2  3  4  5  6  7)
+    punpckhbw   xmm5, xmm3              ; xmm5=row[-1]( 8  9 10 11 12 13 14 15)
+    movdqa      xmm6, xmm2
+    punpcklbw   xmm2, xmm3              ; xmm2=row[+1]( 0  1  2  3  4  5  6  7)
+    punpckhbw   xmm6, xmm3              ; xmm6=row[+1]( 8  9 10 11 12 13 14 15)
+
+    pmullw      xmm0, [GOTOFF(ebx,PW_THREE)]
+    pmullw      xmm4, [GOTOFF(ebx,PW_THREE)]
+
+    paddw       xmm1, xmm0              ; xmm1=Int0L=( 0  1  2  3  4  5  6  7)
+    paddw       xmm5, xmm4              ; xmm5=Int0H=( 8  9 10 11 12 13 14 15)
+    paddw       xmm2, xmm0              ; xmm2=Int1L=( 0  1  2  3  4  5  6  7)
+    paddw       xmm6, xmm4              ; xmm6=Int1H=( 8  9 10 11 12 13 14 15)
+
+    movdqa      XMMWORD [edx+2*SIZEOF_XMMWORD], xmm1  ; temporarily save
+    movdqa      XMMWORD [edx+3*SIZEOF_XMMWORD], xmm5  ; the intermediate data
+    movdqa      XMMWORD [edi+2*SIZEOF_XMMWORD], xmm2
+    movdqa      XMMWORD [edi+3*SIZEOF_XMMWORD], xmm6
+
+    pslldq      xmm1, (SIZEOF_XMMWORD-2)  ; xmm1=(-- -- -- -- -- -- --  0)
+    pslldq      xmm2, (SIZEOF_XMMWORD-2)  ; xmm2=(-- -- -- -- -- -- --  0)
+
+    movdqa      XMMWORD [wk(2)], xmm1
+    movdqa      XMMWORD [wk(3)], xmm2
+
+.upsample:
+    ; -- process the upper row
+
+    movdqa      xmm7, XMMWORD [edx+0*SIZEOF_XMMWORD]
+    movdqa      xmm3, XMMWORD [edx+1*SIZEOF_XMMWORD]
+
+    movdqa      xmm0, xmm7                ; xmm7=Int0L=( 0  1  2  3  4  5  6  7)
+    movdqa      xmm4, xmm3                ; xmm3=Int0H=( 8  9 10 11 12 13 14 15)
+    psrldq      xmm0, 2                   ; xmm0=( 1  2  3  4  5  6  7 --)
+    pslldq      xmm4, (SIZEOF_XMMWORD-2)  ; xmm4=(-- -- -- -- -- -- --  8)
+    movdqa      xmm5, xmm7
+    movdqa      xmm6, xmm3
+    psrldq      xmm5, (SIZEOF_XMMWORD-2)  ; xmm5=( 7 -- -- -- -- -- -- --)
+    pslldq      xmm6, 2                   ; xmm6=(--  8  9 10 11 12 13 14)
+
+    por         xmm0, xmm4                ; xmm0=( 1  2  3  4  5  6  7  8)
+    por         xmm5, xmm6                ; xmm5=( 7  8  9 10 11 12 13 14)
+
+    movdqa      xmm1, xmm7
+    movdqa      xmm2, xmm3
+    pslldq      xmm1, 2                   ; xmm1=(--  0  1  2  3  4  5  6)
+    psrldq      xmm2, 2                   ; xmm2=( 9 10 11 12 13 14 15 --)
+    movdqa      xmm4, xmm3
+    psrldq      xmm4, (SIZEOF_XMMWORD-2)  ; xmm4=(15 -- -- -- -- -- -- --)
+
+    por         xmm1, XMMWORD [wk(0)]     ; xmm1=(-1  0  1  2  3  4  5  6)
+    por         xmm2, XMMWORD [wk(2)]     ; xmm2=( 9 10 11 12 13 14 15 16)
+
+    movdqa      XMMWORD [wk(0)], xmm4
+
+    pmullw      xmm7, [GOTOFF(ebx,PW_THREE)]
+    pmullw      xmm3, [GOTOFF(ebx,PW_THREE)]
+    paddw       xmm1, [GOTOFF(ebx,PW_EIGHT)]
+    paddw       xmm5, [GOTOFF(ebx,PW_EIGHT)]
+    paddw       xmm0, [GOTOFF(ebx,PW_SEVEN)]
+    paddw       xmm2, [GOTOFF(ebx,PW_SEVEN)]
+
+    paddw       xmm1, xmm7
+    paddw       xmm5, xmm3
+    psrlw       xmm1, 4                 ; xmm1=Out0LE=( 0  2  4  6  8 10 12 14)
+    psrlw       xmm5, 4                 ; xmm5=Out0HE=(16 18 20 22 24 26 28 30)
+    paddw       xmm0, xmm7
+    paddw       xmm2, xmm3
+    psrlw       xmm0, 4                 ; xmm0=Out0LO=( 1  3  5  7  9 11 13 15)
+    psrlw       xmm2, 4                 ; xmm2=Out0HO=(17 19 21 23 25 27 29 31)
+
+    psllw       xmm0, BYTE_BIT
+    psllw       xmm2, BYTE_BIT
+    por         xmm1, xmm0              ; xmm1=Out0L=( 0  1  2 ... 13 14 15)
+    por         xmm5, xmm2              ; xmm5=Out0H=(16 17 18 ... 29 30 31)
+
+    movdqa      XMMWORD [edx+0*SIZEOF_XMMWORD], xmm1
+    movdqa      XMMWORD [edx+1*SIZEOF_XMMWORD], xmm5
+
+    ; -- process the lower row
+
+    movdqa      xmm6, XMMWORD [edi+0*SIZEOF_XMMWORD]
+    movdqa      xmm4, XMMWORD [edi+1*SIZEOF_XMMWORD]
+
+    movdqa      xmm7, xmm6                ; xmm6=Int1L=( 0  1  2  3  4  5  6  7)
+    movdqa      xmm3, xmm4                ; xmm4=Int1H=( 8  9 10 11 12 13 14 15)
+    psrldq      xmm7, 2                   ; xmm7=( 1  2  3  4  5  6  7 --)
+    pslldq      xmm3, (SIZEOF_XMMWORD-2)  ; xmm3=(-- -- -- -- -- -- --  8)
+    movdqa      xmm0, xmm6
+    movdqa      xmm2, xmm4
+    psrldq      xmm0, (SIZEOF_XMMWORD-2)  ; xmm0=( 7 -- -- -- -- -- -- --)
+    pslldq      xmm2, 2                   ; xmm2=(--  8  9 10 11 12 13 14)
+
+    por         xmm7, xmm3                ; xmm7=( 1  2  3  4  5  6  7  8)
+    por         xmm0, xmm2                ; xmm0=( 7  8  9 10 11 12 13 14)
+
+    movdqa      xmm1, xmm6
+    movdqa      xmm5, xmm4
+    pslldq      xmm1, 2                   ; xmm1=(--  0  1  2  3  4  5  6)
+    psrldq      xmm5, 2                   ; xmm5=( 9 10 11 12 13 14 15 --)
+    movdqa      xmm3, xmm4
+    psrldq      xmm3, (SIZEOF_XMMWORD-2)  ; xmm3=(15 -- -- -- -- -- -- --)
+
+    por         xmm1, XMMWORD [wk(1)]     ; xmm1=(-1  0  1  2  3  4  5  6)
+    por         xmm5, XMMWORD [wk(3)]     ; xmm5=( 9 10 11 12 13 14 15 16)
+
+    movdqa      XMMWORD [wk(1)], xmm3
+
+    pmullw      xmm6, [GOTOFF(ebx,PW_THREE)]
+    pmullw      xmm4, [GOTOFF(ebx,PW_THREE)]
+    paddw       xmm1, [GOTOFF(ebx,PW_EIGHT)]
+    paddw       xmm0, [GOTOFF(ebx,PW_EIGHT)]
+    paddw       xmm7, [GOTOFF(ebx,PW_SEVEN)]
+    paddw       xmm5, [GOTOFF(ebx,PW_SEVEN)]
+
+    paddw       xmm1, xmm6
+    paddw       xmm0, xmm4
+    psrlw       xmm1, 4                 ; xmm1=Out1LE=( 0  2  4  6  8 10 12 14)
+    psrlw       xmm0, 4                 ; xmm0=Out1HE=(16 18 20 22 24 26 28 30)
+    paddw       xmm7, xmm6
+    paddw       xmm5, xmm4
+    psrlw       xmm7, 4                 ; xmm7=Out1LO=( 1  3  5  7  9 11 13 15)
+    psrlw       xmm5, 4                 ; xmm5=Out1HO=(17 19 21 23 25 27 29 31)
+
+    psllw       xmm7, BYTE_BIT
+    psllw       xmm5, BYTE_BIT
+    por         xmm1, xmm7              ; xmm1=Out1L=( 0  1  2 ... 13 14 15)
+    por         xmm0, xmm5              ; xmm0=Out1H=(16 17 18 ... 29 30 31)
+
+    movdqa      XMMWORD [edi+0*SIZEOF_XMMWORD], xmm1
+    movdqa      XMMWORD [edi+1*SIZEOF_XMMWORD], xmm0
+
+    poppic      ebx
+
+    sub         eax, byte SIZEOF_XMMWORD
+    add         ecx, byte 1*SIZEOF_XMMWORD  ; inptr1(above)
+    add         ebx, byte 1*SIZEOF_XMMWORD  ; inptr0
+    add         esi, byte 1*SIZEOF_XMMWORD  ; inptr1(below)
+    add         edx, byte 2*SIZEOF_XMMWORD  ; outptr0
+    add         edi, byte 2*SIZEOF_XMMWORD  ; outptr1
+    cmp         eax, byte SIZEOF_XMMWORD
+    ja          near .columnloop
+    test        eax, eax
+    jnz         near .columnloop_last
+
+    pop         esi
+    pop         edi
+    pop         ecx
+    pop         eax
+
+    add         esi, byte 1*SIZEOF_JSAMPROW  ; input_data
+    add         edi, byte 2*SIZEOF_JSAMPROW  ; output_data
+    sub         ecx, byte 2                  ; rowctr
+    jg          near .rowloop
+
+.return:
+    pop         edi
+    pop         esi
+;   pop         edx                     ; need not be preserved
+;   pop         ecx                     ; need not be preserved
+    pop         ebx
+    mov         esp, ebp                ; esp <- aligned ebp
+    pop         esp                     ; esp <- original ebp
+    pop         ebp
+    ret
+
+; --------------------------------------------------------------------------
+;
+; Fast processing for the common case of 2:1 horizontal and 1:1 vertical.
+; It's still a box filter.
+;
+; GLOBAL(void)
+; jsimd_h2v1_upsample_sse2(int max_v_samp_factor, JDIMENSION output_width,
+;                          JSAMPARRAY input_data, JSAMPARRAY *output_data_ptr);
+;
+
+%define max_v_samp(b)       (b) + 8     ; int max_v_samp_factor
+%define output_width(b)     (b) + 12    ; JDIMENSION output_width
+%define input_data(b)       (b) + 16    ; JSAMPARRAY input_data
+%define output_data_ptr(b)  (b) + 20    ; JSAMPARRAY *output_data_ptr
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_h2v1_upsample_sse2)
+
+EXTN(jsimd_h2v1_upsample_sse2):
+    push        ebp
+    mov         ebp, esp
+;   push        ebx                     ; unused
+;   push        ecx                     ; need not be preserved
+;   push        edx                     ; need not be preserved
+    push        esi
+    push        edi
+
+    mov         edx, JDIMENSION [output_width(ebp)]
+    add         edx, byte (2*SIZEOF_XMMWORD)-1
+    and         edx, byte -(2*SIZEOF_XMMWORD)
+    jz          short .return
+
+    mov         ecx, INT [max_v_samp(ebp)]  ; rowctr
+    test        ecx, ecx
+    jz          short .return
+
+    mov         esi, JSAMPARRAY [input_data(ebp)]    ; input_data
+    mov         edi, POINTER [output_data_ptr(ebp)]
+    mov         edi, JSAMPARRAY [edi]                ; output_data
+    alignx      16, 7
+.rowloop:
+    push        edi
+    push        esi
+
+    mov         esi, JSAMPROW [esi]     ; inptr
+    mov         edi, JSAMPROW [edi]     ; outptr
+    mov         eax, edx                ; colctr
+    alignx      16, 7
+.columnloop:
+
+    movdqa      xmm0, XMMWORD [esi+0*SIZEOF_XMMWORD]
+
+    movdqa      xmm1, xmm0
+    punpcklbw   xmm0, xmm0
+    punpckhbw   xmm1, xmm1
+
+    movdqa      XMMWORD [edi+0*SIZEOF_XMMWORD], xmm0
+    movdqa      XMMWORD [edi+1*SIZEOF_XMMWORD], xmm1
+
+    sub         eax, byte 2*SIZEOF_XMMWORD
+    jz          short .nextrow
+
+    movdqa      xmm2, XMMWORD [esi+1*SIZEOF_XMMWORD]
+
+    movdqa      xmm3, xmm2
+    punpcklbw   xmm2, xmm2
+    punpckhbw   xmm3, xmm3
+
+    movdqa      XMMWORD [edi+2*SIZEOF_XMMWORD], xmm2
+    movdqa      XMMWORD [edi+3*SIZEOF_XMMWORD], xmm3
+
+    sub         eax, byte 2*SIZEOF_XMMWORD
+    jz          short .nextrow
+
+    add         esi, byte 2*SIZEOF_XMMWORD  ; inptr
+    add         edi, byte 4*SIZEOF_XMMWORD  ; outptr
+    jmp         short .columnloop
+    alignx      16, 7
+
+.nextrow:
+    pop         esi
+    pop         edi
+
+    add         esi, byte SIZEOF_JSAMPROW  ; input_data
+    add         edi, byte SIZEOF_JSAMPROW  ; output_data
+    dec         ecx                        ; rowctr
+    jg          short .rowloop
+
+.return:
+    pop         edi
+    pop         esi
+;   pop         edx                     ; need not be preserved
+;   pop         ecx                     ; need not be preserved
+;   pop         ebx                     ; unused
+    pop         ebp
+    ret
+
+; --------------------------------------------------------------------------
+;
+; Fast processing for the common case of 2:1 horizontal and 2:1 vertical.
+; It's still a box filter.
+;
+; GLOBAL(void)
+; jsimd_h2v2_upsample_sse2(int max_v_samp_factor, JDIMENSION output_width,
+;                          JSAMPARRAY input_data, JSAMPARRAY *output_data_ptr);
+;
+
+%define max_v_samp(b)       (b) + 8     ; int max_v_samp_factor
+%define output_width(b)     (b) + 12    ; JDIMENSION output_width
+%define input_data(b)       (b) + 16    ; JSAMPARRAY input_data
+%define output_data_ptr(b)  (b) + 20    ; JSAMPARRAY *output_data_ptr
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_h2v2_upsample_sse2)
+
+EXTN(jsimd_h2v2_upsample_sse2):
+    push        ebp
+    mov         ebp, esp
+    push        ebx
+;   push        ecx                     ; need not be preserved
+;   push        edx                     ; need not be preserved
+    push        esi
+    push        edi
+
+    mov         edx, JDIMENSION [output_width(ebp)]
+    add         edx, byte (2*SIZEOF_XMMWORD)-1
+    and         edx, byte -(2*SIZEOF_XMMWORD)
+    jz          near .return
+
+    mov         ecx, INT [max_v_samp(ebp)]  ; rowctr
+    test        ecx, ecx
+    jz          near .return
+
+    mov         esi, JSAMPARRAY [input_data(ebp)]    ; input_data
+    mov         edi, POINTER [output_data_ptr(ebp)]
+    mov         edi, JSAMPARRAY [edi]                ; output_data
+    alignx      16, 7
+.rowloop:
+    push        edi
+    push        esi
+
+    mov         esi, JSAMPROW [esi]                    ; inptr
+    mov         ebx, JSAMPROW [edi+0*SIZEOF_JSAMPROW]  ; outptr0
+    mov         edi, JSAMPROW [edi+1*SIZEOF_JSAMPROW]  ; outptr1
+    mov         eax, edx                               ; colctr
+    alignx      16, 7
+.columnloop:
+
+    movdqa      xmm0, XMMWORD [esi+0*SIZEOF_XMMWORD]
+
+    movdqa      xmm1, xmm0
+    punpcklbw   xmm0, xmm0
+    punpckhbw   xmm1, xmm1
+
+    movdqa      XMMWORD [ebx+0*SIZEOF_XMMWORD], xmm0
+    movdqa      XMMWORD [ebx+1*SIZEOF_XMMWORD], xmm1
+    movdqa      XMMWORD [edi+0*SIZEOF_XMMWORD], xmm0
+    movdqa      XMMWORD [edi+1*SIZEOF_XMMWORD], xmm1
+
+    sub         eax, byte 2*SIZEOF_XMMWORD
+    jz          short .nextrow
+
+    movdqa      xmm2, XMMWORD [esi+1*SIZEOF_XMMWORD]
+
+    movdqa      xmm3, xmm2
+    punpcklbw   xmm2, xmm2
+    punpckhbw   xmm3, xmm3
+
+    movdqa      XMMWORD [ebx+2*SIZEOF_XMMWORD], xmm2
+    movdqa      XMMWORD [ebx+3*SIZEOF_XMMWORD], xmm3
+    movdqa      XMMWORD [edi+2*SIZEOF_XMMWORD], xmm2
+    movdqa      XMMWORD [edi+3*SIZEOF_XMMWORD], xmm3
+
+    sub         eax, byte 2*SIZEOF_XMMWORD
+    jz          short .nextrow
+
+    add         esi, byte 2*SIZEOF_XMMWORD  ; inptr
+    add         ebx, byte 4*SIZEOF_XMMWORD  ; outptr0
+    add         edi, byte 4*SIZEOF_XMMWORD  ; outptr1
+    jmp         short .columnloop
+    alignx      16, 7
+
+.nextrow:
+    pop         esi
+    pop         edi
+
+    add         esi, byte 1*SIZEOF_JSAMPROW  ; input_data
+    add         edi, byte 2*SIZEOF_JSAMPROW  ; output_data
+    sub         ecx, byte 2                  ; rowctr
+    jg          short .rowloop
+
+.return:
+    pop         edi
+    pop         esi
+;   pop         edx                     ; need not be preserved
+;   pop         ecx                     ; need not be preserved
+    pop         ebx
+    pop         ebp
+    ret
+
+; For some reason, the OS X linker does not honor the request to align the
+; segment unless we do this.
+    align       32
diff --git a/3rdparty/libjpeg/src/simd/i386/jfdctflt-3dn.asm b/3rdparty/libjpeg/src/simd/i386/jfdctflt-3dn.asm
new file mode 100644
index 00000000..322ab163
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/i386/jfdctflt-3dn.asm
@@ -0,0 +1,318 @@
+;
+; jfdctflt.asm - floating-point FDCT (3DNow!)
+;
+; Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+; Copyright (C) 2016, D. R. Commander.
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+;
+; This file should be assembled with NASM (Netwide Assembler),
+; can *not* be assembled with Microsoft's MASM or any compatible
+; assembler (including Borland's Turbo Assembler).
+; NASM is available from http://nasm.sourceforge.net/ or
+; http://sourceforge.net/project/showfiles.php?group_id=6208
+;
+; This file contains a floating-point implementation of the forward DCT
+; (Discrete Cosine Transform). The following code is based directly on
+; the IJG's original jfdctflt.c; see the jfdctflt.c for more details.
+
+%include "jsimdext.inc"
+%include "jdct.inc"
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_CONST
+
+    alignz      32
+    GLOBAL_DATA(jconst_fdct_float_3dnow)
+
+EXTN(jconst_fdct_float_3dnow):
+
+PD_0_382 times 2 dd 0.382683432365089771728460
+PD_0_707 times 2 dd 0.707106781186547524400844
+PD_0_541 times 2 dd 0.541196100146196984399723
+PD_1_306 times 2 dd 1.306562964876376527856643
+
+    alignz      32
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_TEXT
+    BITS        32
+;
+; Perform the forward DCT on one block of samples.
+;
+; GLOBAL(void)
+; jsimd_fdct_float_3dnow(FAST_FLOAT *data)
+;
+
+%define data(b)       (b) + 8           ; FAST_FLOAT *data
+
+%define original_ebp  ebp + 0
+%define wk(i)         ebp - (WK_NUM - (i)) * SIZEOF_MMWORD  ; mmword wk[WK_NUM]
+%define WK_NUM        2
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_fdct_float_3dnow)
+
+EXTN(jsimd_fdct_float_3dnow):
+    push        ebp
+    mov         eax, esp                    ; eax = original ebp
+    sub         esp, byte 4
+    and         esp, byte (-SIZEOF_MMWORD)  ; align to 64 bits
+    mov         [esp], eax
+    mov         ebp, esp                    ; ebp = aligned ebp
+    lea         esp, [wk(0)]
+    pushpic     ebx
+;   push        ecx                     ; need not be preserved
+;   push        edx                     ; need not be preserved
+;   push        esi                     ; unused
+;   push        edi                     ; unused
+
+    get_GOT     ebx                     ; get GOT address
+
+    ; ---- Pass 1: process rows.
+
+    mov         edx, POINTER [data(eax)]  ; (FAST_FLOAT *)
+    mov         ecx, DCTSIZE/2
+    alignx      16, 7
+.rowloop:
+
+    movq        mm0, MMWORD [MMBLOCK(0,0,edx,SIZEOF_FAST_FLOAT)]
+    movq        mm1, MMWORD [MMBLOCK(1,0,edx,SIZEOF_FAST_FLOAT)]
+    movq        mm2, MMWORD [MMBLOCK(0,3,edx,SIZEOF_FAST_FLOAT)]
+    movq        mm3, MMWORD [MMBLOCK(1,3,edx,SIZEOF_FAST_FLOAT)]
+
+    ; mm0=(00 01), mm1=(10 11), mm2=(06 07), mm3=(16 17)
+
+    movq        mm4, mm0                ; transpose coefficients
+    punpckldq   mm0, mm1                ; mm0=(00 10)=data0
+    punpckhdq   mm4, mm1                ; mm4=(01 11)=data1
+    movq        mm5, mm2                ; transpose coefficients
+    punpckldq   mm2, mm3                ; mm2=(06 16)=data6
+    punpckhdq   mm5, mm3                ; mm5=(07 17)=data7
+
+    movq        mm6, mm4
+    movq        mm7, mm0
+    pfsub       mm4, mm2                ; mm4=data1-data6=tmp6
+    pfsub       mm0, mm5                ; mm0=data0-data7=tmp7
+    pfadd       mm6, mm2                ; mm6=data1+data6=tmp1
+    pfadd       mm7, mm5                ; mm7=data0+data7=tmp0
+
+    movq        mm1, MMWORD [MMBLOCK(0,1,edx,SIZEOF_FAST_FLOAT)]
+    movq        mm3, MMWORD [MMBLOCK(1,1,edx,SIZEOF_FAST_FLOAT)]
+    movq        mm2, MMWORD [MMBLOCK(0,2,edx,SIZEOF_FAST_FLOAT)]
+    movq        mm5, MMWORD [MMBLOCK(1,2,edx,SIZEOF_FAST_FLOAT)]
+
+    ; mm1=(02 03), mm3=(12 13), mm2=(04 05), mm5=(14 15)
+
+    movq        MMWORD [wk(0)], mm4     ; wk(0)=tmp6
+    movq        MMWORD [wk(1)], mm0     ; wk(1)=tmp7
+
+    movq        mm4, mm1                ; transpose coefficients
+    punpckldq   mm1, mm3                ; mm1=(02 12)=data2
+    punpckhdq   mm4, mm3                ; mm4=(03 13)=data3
+    movq        mm0, mm2                ; transpose coefficients
+    punpckldq   mm2, mm5                ; mm2=(04 14)=data4
+    punpckhdq   mm0, mm5                ; mm0=(05 15)=data5
+
+    movq        mm3, mm4
+    movq        mm5, mm1
+    pfadd       mm4, mm2                ; mm4=data3+data4=tmp3
+    pfadd       mm1, mm0                ; mm1=data2+data5=tmp2
+    pfsub       mm3, mm2                ; mm3=data3-data4=tmp4
+    pfsub       mm5, mm0                ; mm5=data2-data5=tmp5
+
+    ; -- Even part
+
+    movq        mm2, mm7
+    movq        mm0, mm6
+    pfsub       mm7, mm4                ; mm7=tmp13
+    pfsub       mm6, mm1                ; mm6=tmp12
+    pfadd       mm2, mm4                ; mm2=tmp10
+    pfadd       mm0, mm1                ; mm0=tmp11
+
+    pfadd       mm6, mm7
+    pfmul       mm6, [GOTOFF(ebx,PD_0_707)]  ; mm6=z1
+
+    movq        mm4, mm2
+    movq        mm1, mm7
+    pfsub       mm2, mm0                ; mm2=data4
+    pfsub       mm7, mm6                ; mm7=data6
+    pfadd       mm4, mm0                ; mm4=data0
+    pfadd       mm1, mm6                ; mm1=data2
+
+    movq        MMWORD [MMBLOCK(0,2,edx,SIZEOF_FAST_FLOAT)], mm2
+    movq        MMWORD [MMBLOCK(0,3,edx,SIZEOF_FAST_FLOAT)], mm7
+    movq        MMWORD [MMBLOCK(0,0,edx,SIZEOF_FAST_FLOAT)], mm4
+    movq        MMWORD [MMBLOCK(0,1,edx,SIZEOF_FAST_FLOAT)], mm1
+
+    ; -- Odd part
+
+    movq        mm0, MMWORD [wk(0)]     ; mm0=tmp6
+    movq        mm6, MMWORD [wk(1)]     ; mm6=tmp7
+
+    pfadd       mm3, mm5                ; mm3=tmp10
+    pfadd       mm5, mm0                ; mm5=tmp11
+    pfadd       mm0, mm6                ; mm0=tmp12, mm6=tmp7
+
+    pfmul       mm5, [GOTOFF(ebx,PD_0_707)]  ; mm5=z3
+
+    movq        mm2, mm3                     ; mm2=tmp10
+    pfsub       mm3, mm0
+    pfmul       mm3, [GOTOFF(ebx,PD_0_382)]  ; mm3=z5
+    pfmul       mm2, [GOTOFF(ebx,PD_0_541)]  ; mm2=MULTIPLY(tmp10,FIX_0_54119610)
+    pfmul       mm0, [GOTOFF(ebx,PD_1_306)]  ; mm0=MULTIPLY(tmp12,FIX_1_30656296)
+    pfadd       mm2, mm3                     ; mm2=z2
+    pfadd       mm0, mm3                     ; mm0=z4
+
+    movq        mm7, mm6
+    pfsub       mm6, mm5                ; mm6=z13
+    pfadd       mm7, mm5                ; mm7=z11
+
+    movq        mm4, mm6
+    movq        mm1, mm7
+    pfsub       mm6, mm2                ; mm6=data3
+    pfsub       mm7, mm0                ; mm7=data7
+    pfadd       mm4, mm2                ; mm4=data5
+    pfadd       mm1, mm0                ; mm1=data1
+
+    movq        MMWORD [MMBLOCK(1,1,edx,SIZEOF_FAST_FLOAT)], mm6
+    movq        MMWORD [MMBLOCK(1,3,edx,SIZEOF_FAST_FLOAT)], mm7
+    movq        MMWORD [MMBLOCK(1,2,edx,SIZEOF_FAST_FLOAT)], mm4
+    movq        MMWORD [MMBLOCK(1,0,edx,SIZEOF_FAST_FLOAT)], mm1
+
+    add         edx, byte 2*DCTSIZE*SIZEOF_FAST_FLOAT
+    dec         ecx
+    jnz         near .rowloop
+
+    ; ---- Pass 2: process columns.
+
+    mov         edx, POINTER [data(eax)]  ; (FAST_FLOAT *)
+    mov         ecx, DCTSIZE/2
+    alignx      16, 7
+.columnloop:
+
+    movq        mm0, MMWORD [MMBLOCK(0,0,edx,SIZEOF_FAST_FLOAT)]
+    movq        mm1, MMWORD [MMBLOCK(1,0,edx,SIZEOF_FAST_FLOAT)]
+    movq        mm2, MMWORD [MMBLOCK(6,0,edx,SIZEOF_FAST_FLOAT)]
+    movq        mm3, MMWORD [MMBLOCK(7,0,edx,SIZEOF_FAST_FLOAT)]
+
+    ; mm0=(00 10), mm1=(01 11), mm2=(60 70), mm3=(61 71)
+
+    movq        mm4, mm0                ; transpose coefficients
+    punpckldq   mm0, mm1                ; mm0=(00 01)=data0
+    punpckhdq   mm4, mm1                ; mm4=(10 11)=data1
+    movq        mm5, mm2                ; transpose coefficients
+    punpckldq   mm2, mm3                ; mm2=(60 61)=data6
+    punpckhdq   mm5, mm3                ; mm5=(70 71)=data7
+
+    movq        mm6, mm4
+    movq        mm7, mm0
+    pfsub       mm4, mm2                ; mm4=data1-data6=tmp6
+    pfsub       mm0, mm5                ; mm0=data0-data7=tmp7
+    pfadd       mm6, mm2                ; mm6=data1+data6=tmp1
+    pfadd       mm7, mm5                ; mm7=data0+data7=tmp0
+
+    movq        mm1, MMWORD [MMBLOCK(2,0,edx,SIZEOF_FAST_FLOAT)]
+    movq        mm3, MMWORD [MMBLOCK(3,0,edx,SIZEOF_FAST_FLOAT)]
+    movq        mm2, MMWORD [MMBLOCK(4,0,edx,SIZEOF_FAST_FLOAT)]
+    movq        mm5, MMWORD [MMBLOCK(5,0,edx,SIZEOF_FAST_FLOAT)]
+
+    ; mm1=(20 30), mm3=(21 31), mm2=(40 50), mm5=(41 51)
+
+    movq        MMWORD [wk(0)], mm4     ; wk(0)=tmp6
+    movq        MMWORD [wk(1)], mm0     ; wk(1)=tmp7
+
+    movq        mm4, mm1                ; transpose coefficients
+    punpckldq   mm1, mm3                ; mm1=(20 21)=data2
+    punpckhdq   mm4, mm3                ; mm4=(30 31)=data3
+    movq        mm0, mm2                ; transpose coefficients
+    punpckldq   mm2, mm5                ; mm2=(40 41)=data4
+    punpckhdq   mm0, mm5                ; mm0=(50 51)=data5
+
+    movq        mm3, mm4
+    movq        mm5, mm1
+    pfadd       mm4, mm2                ; mm4=data3+data4=tmp3
+    pfadd       mm1, mm0                ; mm1=data2+data5=tmp2
+    pfsub       mm3, mm2                ; mm3=data3-data4=tmp4
+    pfsub       mm5, mm0                ; mm5=data2-data5=tmp5
+
+    ; -- Even part
+
+    movq        mm2, mm7
+    movq        mm0, mm6
+    pfsub       mm7, mm4                ; mm7=tmp13
+    pfsub       mm6, mm1                ; mm6=tmp12
+    pfadd       mm2, mm4                ; mm2=tmp10
+    pfadd       mm0, mm1                ; mm0=tmp11
+
+    pfadd       mm6, mm7
+    pfmul       mm6, [GOTOFF(ebx,PD_0_707)]  ; mm6=z1
+
+    movq        mm4, mm2
+    movq        mm1, mm7
+    pfsub       mm2, mm0                ; mm2=data4
+    pfsub       mm7, mm6                ; mm7=data6
+    pfadd       mm4, mm0                ; mm4=data0
+    pfadd       mm1, mm6                ; mm1=data2
+
+    movq        MMWORD [MMBLOCK(4,0,edx,SIZEOF_FAST_FLOAT)], mm2
+    movq        MMWORD [MMBLOCK(6,0,edx,SIZEOF_FAST_FLOAT)], mm7
+    movq        MMWORD [MMBLOCK(0,0,edx,SIZEOF_FAST_FLOAT)], mm4
+    movq        MMWORD [MMBLOCK(2,0,edx,SIZEOF_FAST_FLOAT)], mm1
+
+    ; -- Odd part
+
+    movq        mm0, MMWORD [wk(0)]     ; mm0=tmp6
+    movq        mm6, MMWORD [wk(1)]     ; mm6=tmp7
+
+    pfadd       mm3, mm5                ; mm3=tmp10
+    pfadd       mm5, mm0                ; mm5=tmp11
+    pfadd       mm0, mm6                ; mm0=tmp12, mm6=tmp7
+
+    pfmul       mm5, [GOTOFF(ebx,PD_0_707)]  ; mm5=z3
+
+    movq        mm2, mm3                     ; mm2=tmp10
+    pfsub       mm3, mm0
+    pfmul       mm3, [GOTOFF(ebx,PD_0_382)]  ; mm3=z5
+    pfmul       mm2, [GOTOFF(ebx,PD_0_541)]  ; mm2=MULTIPLY(tmp10,FIX_0_54119610)
+    pfmul       mm0, [GOTOFF(ebx,PD_1_306)]  ; mm0=MULTIPLY(tmp12,FIX_1_30656296)
+    pfadd       mm2, mm3                     ; mm2=z2
+    pfadd       mm0, mm3                     ; mm0=z4
+
+    movq        mm7, mm6
+    pfsub       mm6, mm5                ; mm6=z13
+    pfadd       mm7, mm5                ; mm7=z11
+
+    movq        mm4, mm6
+    movq        mm1, mm7
+    pfsub       mm6, mm2                ; mm6=data3
+    pfsub       mm7, mm0                ; mm7=data7
+    pfadd       mm4, mm2                ; mm4=data5
+    pfadd       mm1, mm0                ; mm1=data1
+
+    movq        MMWORD [MMBLOCK(3,0,edx,SIZEOF_FAST_FLOAT)], mm6
+    movq        MMWORD [MMBLOCK(7,0,edx,SIZEOF_FAST_FLOAT)], mm7
+    movq        MMWORD [MMBLOCK(5,0,edx,SIZEOF_FAST_FLOAT)], mm4
+    movq        MMWORD [MMBLOCK(1,0,edx,SIZEOF_FAST_FLOAT)], mm1
+
+    add         edx, byte 2*SIZEOF_FAST_FLOAT
+    dec         ecx
+    jnz         near .columnloop
+
+    femms                               ; empty MMX/3DNow! state
+
+;   pop         edi                     ; unused
+;   pop         esi                     ; unused
+;   pop         edx                     ; need not be preserved
+;   pop         ecx                     ; need not be preserved
+    poppic      ebx
+    mov         esp, ebp                ; esp <- aligned ebp
+    pop         esp                     ; esp <- original ebp
+    pop         ebp
+    ret
+
+; For some reason, the OS X linker does not honor the request to align the
+; segment unless we do this.
+    align       32
diff --git a/3rdparty/libjpeg/src/simd/i386/jfdctflt-sse.asm b/3rdparty/libjpeg/src/simd/i386/jfdctflt-sse.asm
new file mode 100644
index 00000000..86952c64
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/i386/jfdctflt-sse.asm
@@ -0,0 +1,369 @@
+;
+; jfdctflt.asm - floating-point FDCT (SSE)
+;
+; Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+; Copyright (C) 2016, D. R. Commander.
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+;
+; This file should be assembled with NASM (Netwide Assembler),
+; can *not* be assembled with Microsoft's MASM or any compatible
+; assembler (including Borland's Turbo Assembler).
+; NASM is available from http://nasm.sourceforge.net/ or
+; http://sourceforge.net/project/showfiles.php?group_id=6208
+;
+; This file contains a floating-point implementation of the forward DCT
+; (Discrete Cosine Transform). The following code is based directly on
+; the IJG's original jfdctflt.c; see the jfdctflt.c for more details.
+
+%include "jsimdext.inc"
+%include "jdct.inc"
+
+; --------------------------------------------------------------------------
+
+%macro  unpcklps2 2  ; %1=(0 1 2 3) / %2=(4 5 6 7) => %1=(0 1 4 5)
+    shufps      %1, %2, 0x44
+%endmacro
+
+%macro  unpckhps2 2  ; %1=(0 1 2 3) / %2=(4 5 6 7) => %1=(2 3 6 7)
+    shufps      %1, %2, 0xEE
+%endmacro
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_CONST
+
+    alignz      32
+    GLOBAL_DATA(jconst_fdct_float_sse)
+
+EXTN(jconst_fdct_float_sse):
+
+PD_0_382 times 4 dd 0.382683432365089771728460
+PD_0_707 times 4 dd 0.707106781186547524400844
+PD_0_541 times 4 dd 0.541196100146196984399723
+PD_1_306 times 4 dd 1.306562964876376527856643
+
+    alignz      32
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_TEXT
+    BITS        32
+;
+; Perform the forward DCT on one block of samples.
+;
+; GLOBAL(void)
+; jsimd_fdct_float_sse(FAST_FLOAT *data)
+;
+
+%define data(b)       (b) + 8           ; FAST_FLOAT *data
+
+%define original_ebp  ebp + 0
+%define wk(i)         ebp - (WK_NUM - (i)) * SIZEOF_XMMWORD
+                                        ; xmmword wk[WK_NUM]
+%define WK_NUM        2
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_fdct_float_sse)
+
+EXTN(jsimd_fdct_float_sse):
+    push        ebp
+    mov         eax, esp                     ; eax = original ebp
+    sub         esp, byte 4
+    and         esp, byte (-SIZEOF_XMMWORD)  ; align to 128 bits
+    mov         [esp], eax
+    mov         ebp, esp                     ; ebp = aligned ebp
+    lea         esp, [wk(0)]
+    pushpic     ebx
+;   push        ecx                     ; need not be preserved
+;   push        edx                     ; need not be preserved
+;   push        esi                     ; unused
+;   push        edi                     ; unused
+
+    get_GOT     ebx                     ; get GOT address
+
+    ; ---- Pass 1: process rows.
+
+    mov         edx, POINTER [data(eax)]  ; (FAST_FLOAT *)
+    mov         ecx, DCTSIZE/4
+    alignx      16, 7
+.rowloop:
+
+    movaps      xmm0, XMMWORD [XMMBLOCK(2,0,edx,SIZEOF_FAST_FLOAT)]
+    movaps      xmm1, XMMWORD [XMMBLOCK(3,0,edx,SIZEOF_FAST_FLOAT)]
+    movaps      xmm2, XMMWORD [XMMBLOCK(2,1,edx,SIZEOF_FAST_FLOAT)]
+    movaps      xmm3, XMMWORD [XMMBLOCK(3,1,edx,SIZEOF_FAST_FLOAT)]
+
+    ; xmm0=(20 21 22 23), xmm2=(24 25 26 27)
+    ; xmm1=(30 31 32 33), xmm3=(34 35 36 37)
+
+    movaps      xmm4, xmm0              ; transpose coefficients(phase 1)
+    unpcklps    xmm0, xmm1              ; xmm0=(20 30 21 31)
+    unpckhps    xmm4, xmm1              ; xmm4=(22 32 23 33)
+    movaps      xmm5, xmm2              ; transpose coefficients(phase 1)
+    unpcklps    xmm2, xmm3              ; xmm2=(24 34 25 35)
+    unpckhps    xmm5, xmm3              ; xmm5=(26 36 27 37)
+
+    movaps      xmm6, XMMWORD [XMMBLOCK(0,0,edx,SIZEOF_FAST_FLOAT)]
+    movaps      xmm7, XMMWORD [XMMBLOCK(1,0,edx,SIZEOF_FAST_FLOAT)]
+    movaps      xmm1, XMMWORD [XMMBLOCK(0,1,edx,SIZEOF_FAST_FLOAT)]
+    movaps      xmm3, XMMWORD [XMMBLOCK(1,1,edx,SIZEOF_FAST_FLOAT)]
+
+    ; xmm6=(00 01 02 03), xmm1=(04 05 06 07)
+    ; xmm7=(10 11 12 13), xmm3=(14 15 16 17)
+
+    movaps      XMMWORD [wk(0)], xmm4   ; wk(0)=(22 32 23 33)
+    movaps      XMMWORD [wk(1)], xmm2   ; wk(1)=(24 34 25 35)
+
+    movaps      xmm4, xmm6              ; transpose coefficients(phase 1)
+    unpcklps    xmm6, xmm7              ; xmm6=(00 10 01 11)
+    unpckhps    xmm4, xmm7              ; xmm4=(02 12 03 13)
+    movaps      xmm2, xmm1              ; transpose coefficients(phase 1)
+    unpcklps    xmm1, xmm3              ; xmm1=(04 14 05 15)
+    unpckhps    xmm2, xmm3              ; xmm2=(06 16 07 17)
+
+    movaps      xmm7, xmm6              ; transpose coefficients(phase 2)
+    unpcklps2   xmm6, xmm0              ; xmm6=(00 10 20 30)=data0
+    unpckhps2   xmm7, xmm0              ; xmm7=(01 11 21 31)=data1
+    movaps      xmm3, xmm2              ; transpose coefficients(phase 2)
+    unpcklps2   xmm2, xmm5              ; xmm2=(06 16 26 36)=data6
+    unpckhps2   xmm3, xmm5              ; xmm3=(07 17 27 37)=data7
+
+    movaps      xmm0, xmm7
+    movaps      xmm5, xmm6
+    subps       xmm7, xmm2              ; xmm7=data1-data6=tmp6
+    subps       xmm6, xmm3              ; xmm6=data0-data7=tmp7
+    addps       xmm0, xmm2              ; xmm0=data1+data6=tmp1
+    addps       xmm5, xmm3              ; xmm5=data0+data7=tmp0
+
+    movaps      xmm2, XMMWORD [wk(0)]   ; xmm2=(22 32 23 33)
+    movaps      xmm3, XMMWORD [wk(1)]   ; xmm3=(24 34 25 35)
+    movaps      XMMWORD [wk(0)], xmm7   ; wk(0)=tmp6
+    movaps      XMMWORD [wk(1)], xmm6   ; wk(1)=tmp7
+
+    movaps      xmm7, xmm4              ; transpose coefficients(phase 2)
+    unpcklps2   xmm4, xmm2              ; xmm4=(02 12 22 32)=data2
+    unpckhps2   xmm7, xmm2              ; xmm7=(03 13 23 33)=data3
+    movaps      xmm6, xmm1              ; transpose coefficients(phase 2)
+    unpcklps2   xmm1, xmm3              ; xmm1=(04 14 24 34)=data4
+    unpckhps2   xmm6, xmm3              ; xmm6=(05 15 25 35)=data5
+
+    movaps      xmm2, xmm7
+    movaps      xmm3, xmm4
+    addps       xmm7, xmm1              ; xmm7=data3+data4=tmp3
+    addps       xmm4, xmm6              ; xmm4=data2+data5=tmp2
+    subps       xmm2, xmm1              ; xmm2=data3-data4=tmp4
+    subps       xmm3, xmm6              ; xmm3=data2-data5=tmp5
+
+    ; -- Even part
+
+    movaps      xmm1, xmm5
+    movaps      xmm6, xmm0
+    subps       xmm5, xmm7              ; xmm5=tmp13
+    subps       xmm0, xmm4              ; xmm0=tmp12
+    addps       xmm1, xmm7              ; xmm1=tmp10
+    addps       xmm6, xmm4              ; xmm6=tmp11
+
+    addps       xmm0, xmm5
+    mulps       xmm0, [GOTOFF(ebx,PD_0_707)]  ; xmm0=z1
+
+    movaps      xmm7, xmm1
+    movaps      xmm4, xmm5
+    subps       xmm1, xmm6              ; xmm1=data4
+    subps       xmm5, xmm0              ; xmm5=data6
+    addps       xmm7, xmm6              ; xmm7=data0
+    addps       xmm4, xmm0              ; xmm4=data2
+
+    movaps      XMMWORD [XMMBLOCK(0,1,edx,SIZEOF_FAST_FLOAT)], xmm1
+    movaps      XMMWORD [XMMBLOCK(2,1,edx,SIZEOF_FAST_FLOAT)], xmm5
+    movaps      XMMWORD [XMMBLOCK(0,0,edx,SIZEOF_FAST_FLOAT)], xmm7
+    movaps      XMMWORD [XMMBLOCK(2,0,edx,SIZEOF_FAST_FLOAT)], xmm4
+
+    ; -- Odd part
+
+    movaps      xmm6, XMMWORD [wk(0)]   ; xmm6=tmp6
+    movaps      xmm0, XMMWORD [wk(1)]   ; xmm0=tmp7
+
+    addps       xmm2, xmm3              ; xmm2=tmp10
+    addps       xmm3, xmm6              ; xmm3=tmp11
+    addps       xmm6, xmm0              ; xmm6=tmp12, xmm0=tmp7
+
+    mulps       xmm3, [GOTOFF(ebx,PD_0_707)]  ; xmm3=z3
+
+    movaps      xmm1, xmm2                    ; xmm1=tmp10
+    subps       xmm2, xmm6
+    mulps       xmm2, [GOTOFF(ebx,PD_0_382)]  ; xmm2=z5
+    mulps       xmm1, [GOTOFF(ebx,PD_0_541)]  ; xmm1=MULTIPLY(tmp10,FIX_0_541196)
+    mulps       xmm6, [GOTOFF(ebx,PD_1_306)]  ; xmm6=MULTIPLY(tmp12,FIX_1_306562)
+    addps       xmm1, xmm2                    ; xmm1=z2
+    addps       xmm6, xmm2                    ; xmm6=z4
+
+    movaps      xmm5, xmm0
+    subps       xmm0, xmm3              ; xmm0=z13
+    addps       xmm5, xmm3              ; xmm5=z11
+
+    movaps      xmm7, xmm0
+    movaps      xmm4, xmm5
+    subps       xmm0, xmm1              ; xmm0=data3
+    subps       xmm5, xmm6              ; xmm5=data7
+    addps       xmm7, xmm1              ; xmm7=data5
+    addps       xmm4, xmm6              ; xmm4=data1
+
+    movaps      XMMWORD [XMMBLOCK(3,0,edx,SIZEOF_FAST_FLOAT)], xmm0
+    movaps      XMMWORD [XMMBLOCK(3,1,edx,SIZEOF_FAST_FLOAT)], xmm5
+    movaps      XMMWORD [XMMBLOCK(1,1,edx,SIZEOF_FAST_FLOAT)], xmm7
+    movaps      XMMWORD [XMMBLOCK(1,0,edx,SIZEOF_FAST_FLOAT)], xmm4
+
+    add         edx, 4*DCTSIZE*SIZEOF_FAST_FLOAT
+    dec         ecx
+    jnz         near .rowloop
+
+    ; ---- Pass 2: process columns.
+
+    mov         edx, POINTER [data(eax)]  ; (FAST_FLOAT *)
+    mov         ecx, DCTSIZE/4
+    alignx      16, 7
+.columnloop:
+
+    movaps      xmm0, XMMWORD [XMMBLOCK(2,0,edx,SIZEOF_FAST_FLOAT)]
+    movaps      xmm1, XMMWORD [XMMBLOCK(3,0,edx,SIZEOF_FAST_FLOAT)]
+    movaps      xmm2, XMMWORD [XMMBLOCK(6,0,edx,SIZEOF_FAST_FLOAT)]
+    movaps      xmm3, XMMWORD [XMMBLOCK(7,0,edx,SIZEOF_FAST_FLOAT)]
+
+    ; xmm0=(02 12 22 32), xmm2=(42 52 62 72)
+    ; xmm1=(03 13 23 33), xmm3=(43 53 63 73)
+
+    movaps      xmm4, xmm0              ; transpose coefficients(phase 1)
+    unpcklps    xmm0, xmm1              ; xmm0=(02 03 12 13)
+    unpckhps    xmm4, xmm1              ; xmm4=(22 23 32 33)
+    movaps      xmm5, xmm2              ; transpose coefficients(phase 1)
+    unpcklps    xmm2, xmm3              ; xmm2=(42 43 52 53)
+    unpckhps    xmm5, xmm3              ; xmm5=(62 63 72 73)
+
+    movaps      xmm6, XMMWORD [XMMBLOCK(0,0,edx,SIZEOF_FAST_FLOAT)]
+    movaps      xmm7, XMMWORD [XMMBLOCK(1,0,edx,SIZEOF_FAST_FLOAT)]
+    movaps      xmm1, XMMWORD [XMMBLOCK(4,0,edx,SIZEOF_FAST_FLOAT)]
+    movaps      xmm3, XMMWORD [XMMBLOCK(5,0,edx,SIZEOF_FAST_FLOAT)]
+
+    ; xmm6=(00 10 20 30), xmm1=(40 50 60 70)
+    ; xmm7=(01 11 21 31), xmm3=(41 51 61 71)
+
+    movaps      XMMWORD [wk(0)], xmm4   ; wk(0)=(22 23 32 33)
+    movaps      XMMWORD [wk(1)], xmm2   ; wk(1)=(42 43 52 53)
+
+    movaps      xmm4, xmm6              ; transpose coefficients(phase 1)
+    unpcklps    xmm6, xmm7              ; xmm6=(00 01 10 11)
+    unpckhps    xmm4, xmm7              ; xmm4=(20 21 30 31)
+    movaps      xmm2, xmm1              ; transpose coefficients(phase 1)
+    unpcklps    xmm1, xmm3              ; xmm1=(40 41 50 51)
+    unpckhps    xmm2, xmm3              ; xmm2=(60 61 70 71)
+
+    movaps      xmm7, xmm6              ; transpose coefficients(phase 2)
+    unpcklps2   xmm6, xmm0              ; xmm6=(00 01 02 03)=data0
+    unpckhps2   xmm7, xmm0              ; xmm7=(10 11 12 13)=data1
+    movaps      xmm3, xmm2              ; transpose coefficients(phase 2)
+    unpcklps2   xmm2, xmm5              ; xmm2=(60 61 62 63)=data6
+    unpckhps2   xmm3, xmm5              ; xmm3=(70 71 72 73)=data7
+
+    movaps      xmm0, xmm7
+    movaps      xmm5, xmm6
+    subps       xmm7, xmm2              ; xmm7=data1-data6=tmp6
+    subps       xmm6, xmm3              ; xmm6=data0-data7=tmp7
+    addps       xmm0, xmm2              ; xmm0=data1+data6=tmp1
+    addps       xmm5, xmm3              ; xmm5=data0+data7=tmp0
+
+    movaps      xmm2, XMMWORD [wk(0)]   ; xmm2=(22 23 32 33)
+    movaps      xmm3, XMMWORD [wk(1)]   ; xmm3=(42 43 52 53)
+    movaps      XMMWORD [wk(0)], xmm7   ; wk(0)=tmp6
+    movaps      XMMWORD [wk(1)], xmm6   ; wk(1)=tmp7
+
+    movaps      xmm7, xmm4              ; transpose coefficients(phase 2)
+    unpcklps2   xmm4, xmm2              ; xmm4=(20 21 22 23)=data2
+    unpckhps2   xmm7, xmm2              ; xmm7=(30 31 32 33)=data3
+    movaps      xmm6, xmm1              ; transpose coefficients(phase 2)
+    unpcklps2   xmm1, xmm3              ; xmm1=(40 41 42 43)=data4
+    unpckhps2   xmm6, xmm3              ; xmm6=(50 51 52 53)=data5
+
+    movaps      xmm2, xmm7
+    movaps      xmm3, xmm4
+    addps       xmm7, xmm1              ; xmm7=data3+data4=tmp3
+    addps       xmm4, xmm6              ; xmm4=data2+data5=tmp2
+    subps       xmm2, xmm1              ; xmm2=data3-data4=tmp4
+    subps       xmm3, xmm6              ; xmm3=data2-data5=tmp5
+
+    ; -- Even part
+
+    movaps      xmm1, xmm5
+    movaps      xmm6, xmm0
+    subps       xmm5, xmm7              ; xmm5=tmp13
+    subps       xmm0, xmm4              ; xmm0=tmp12
+    addps       xmm1, xmm7              ; xmm1=tmp10
+    addps       xmm6, xmm4              ; xmm6=tmp11
+
+    addps       xmm0, xmm5
+    mulps       xmm0, [GOTOFF(ebx,PD_0_707)]  ; xmm0=z1
+
+    movaps      xmm7, xmm1
+    movaps      xmm4, xmm5
+    subps       xmm1, xmm6              ; xmm1=data4
+    subps       xmm5, xmm0              ; xmm5=data6
+    addps       xmm7, xmm6              ; xmm7=data0
+    addps       xmm4, xmm0              ; xmm4=data2
+
+    movaps      XMMWORD [XMMBLOCK(4,0,edx,SIZEOF_FAST_FLOAT)], xmm1
+    movaps      XMMWORD [XMMBLOCK(6,0,edx,SIZEOF_FAST_FLOAT)], xmm5
+    movaps      XMMWORD [XMMBLOCK(0,0,edx,SIZEOF_FAST_FLOAT)], xmm7
+    movaps      XMMWORD [XMMBLOCK(2,0,edx,SIZEOF_FAST_FLOAT)], xmm4
+
+    ; -- Odd part
+
+    movaps      xmm6, XMMWORD [wk(0)]   ; xmm6=tmp6
+    movaps      xmm0, XMMWORD [wk(1)]   ; xmm0=tmp7
+
+    addps       xmm2, xmm3              ; xmm2=tmp10
+    addps       xmm3, xmm6              ; xmm3=tmp11
+    addps       xmm6, xmm0              ; xmm6=tmp12, xmm0=tmp7
+
+    mulps       xmm3, [GOTOFF(ebx,PD_0_707)]  ; xmm3=z3
+
+    movaps      xmm1, xmm2                    ; xmm1=tmp10
+    subps       xmm2, xmm6
+    mulps       xmm2, [GOTOFF(ebx,PD_0_382)]  ; xmm2=z5
+    mulps       xmm1, [GOTOFF(ebx,PD_0_541)]  ; xmm1=MULTIPLY(tmp10,FIX_0_541196)
+    mulps       xmm6, [GOTOFF(ebx,PD_1_306)]  ; xmm6=MULTIPLY(tmp12,FIX_1_306562)
+    addps       xmm1, xmm2                    ; xmm1=z2
+    addps       xmm6, xmm2                    ; xmm6=z4
+
+    movaps      xmm5, xmm0
+    subps       xmm0, xmm3              ; xmm0=z13
+    addps       xmm5, xmm3              ; xmm5=z11
+
+    movaps      xmm7, xmm0
+    movaps      xmm4, xmm5
+    subps       xmm0, xmm1              ; xmm0=data3
+    subps       xmm5, xmm6              ; xmm5=data7
+    addps       xmm7, xmm1              ; xmm7=data5
+    addps       xmm4, xmm6              ; xmm4=data1
+
+    movaps      XMMWORD [XMMBLOCK(3,0,edx,SIZEOF_FAST_FLOAT)], xmm0
+    movaps      XMMWORD [XMMBLOCK(7,0,edx,SIZEOF_FAST_FLOAT)], xmm5
+    movaps      XMMWORD [XMMBLOCK(5,0,edx,SIZEOF_FAST_FLOAT)], xmm7
+    movaps      XMMWORD [XMMBLOCK(1,0,edx,SIZEOF_FAST_FLOAT)], xmm4
+
+    add         edx, byte 4*SIZEOF_FAST_FLOAT
+    dec         ecx
+    jnz         near .columnloop
+
+;   pop         edi                     ; unused
+;   pop         esi                     ; unused
+;   pop         edx                     ; need not be preserved
+;   pop         ecx                     ; need not be preserved
+    poppic      ebx
+    mov         esp, ebp                ; esp <- aligned ebp
+    pop         esp                     ; esp <- original ebp
+    pop         ebp
+    ret
+
+; For some reason, the OS X linker does not honor the request to align the
+; segment unless we do this.
+    align       32
diff --git a/3rdparty/libjpeg/src/simd/i386/jfdctfst-mmx.asm b/3rdparty/libjpeg/src/simd/i386/jfdctfst-mmx.asm
new file mode 100644
index 00000000..80645a50
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/i386/jfdctfst-mmx.asm
@@ -0,0 +1,395 @@
+;
+; jfdctfst.asm - fast integer FDCT (MMX)
+;
+; Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+; Copyright (C) 2016, D. R. Commander.
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+;
+; This file should be assembled with NASM (Netwide Assembler),
+; can *not* be assembled with Microsoft's MASM or any compatible
+; assembler (including Borland's Turbo Assembler).
+; NASM is available from http://nasm.sourceforge.net/ or
+; http://sourceforge.net/project/showfiles.php?group_id=6208
+;
+; This file contains a fast, not so accurate integer implementation of
+; the forward DCT (Discrete Cosine Transform). The following code is
+; based directly on the IJG's original jfdctfst.c; see the jfdctfst.c
+; for more details.
+
+%include "jsimdext.inc"
+%include "jdct.inc"
+
+; --------------------------------------------------------------------------
+
+%define CONST_BITS  8  ; 14 is also OK.
+
+%if CONST_BITS == 8
+F_0_382 equ  98  ; FIX(0.382683433)
+F_0_541 equ 139  ; FIX(0.541196100)
+F_0_707 equ 181  ; FIX(0.707106781)
+F_1_306 equ 334  ; FIX(1.306562965)
+%else
+; NASM cannot do compile-time arithmetic on floating-point constants.
+%define DESCALE(x, n)  (((x) + (1 << ((n) - 1))) >> (n))
+F_0_382 equ DESCALE( 410903207, 30 - CONST_BITS)  ; FIX(0.382683433)
+F_0_541 equ DESCALE( 581104887, 30 - CONST_BITS)  ; FIX(0.541196100)
+F_0_707 equ DESCALE( 759250124, 30 - CONST_BITS)  ; FIX(0.707106781)
+F_1_306 equ DESCALE(1402911301, 30 - CONST_BITS)  ; FIX(1.306562965)
+%endif
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_CONST
+
+; PRE_MULTIPLY_SCALE_BITS <= 2 (to avoid overflow)
+; CONST_BITS + CONST_SHIFT + PRE_MULTIPLY_SCALE_BITS == 16 (for pmulhw)
+
+%define PRE_MULTIPLY_SCALE_BITS  2
+%define CONST_SHIFT              (16 - PRE_MULTIPLY_SCALE_BITS - CONST_BITS)
+
+    alignz      32
+    GLOBAL_DATA(jconst_fdct_ifast_mmx)
+
+EXTN(jconst_fdct_ifast_mmx):
+
+PW_F0707 times 4 dw F_0_707 << CONST_SHIFT
+PW_F0382 times 4 dw F_0_382 << CONST_SHIFT
+PW_F0541 times 4 dw F_0_541 << CONST_SHIFT
+PW_F1306 times 4 dw F_1_306 << CONST_SHIFT
+
+    alignz      32
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_TEXT
+    BITS        32
+;
+; Perform the forward DCT on one block of samples.
+;
+; GLOBAL(void)
+; jsimd_fdct_ifast_mmx(DCTELEM *data)
+;
+
+%define data(b)       (b) + 8           ; DCTELEM *data
+
+%define original_ebp  ebp + 0
+%define wk(i)         ebp - (WK_NUM - (i)) * SIZEOF_MMWORD  ; mmword wk[WK_NUM]
+%define WK_NUM        2
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_fdct_ifast_mmx)
+
+EXTN(jsimd_fdct_ifast_mmx):
+    push        ebp
+    mov         eax, esp                    ; eax = original ebp
+    sub         esp, byte 4
+    and         esp, byte (-SIZEOF_MMWORD)  ; align to 64 bits
+    mov         [esp], eax
+    mov         ebp, esp                    ; ebp = aligned ebp
+    lea         esp, [wk(0)]
+    pushpic     ebx
+;   push        ecx                     ; need not be preserved
+;   push        edx                     ; need not be preserved
+;   push        esi                     ; unused
+;   push        edi                     ; unused
+
+    get_GOT     ebx                     ; get GOT address
+
+    ; ---- Pass 1: process rows.
+
+    mov         edx, POINTER [data(eax)]  ; (DCTELEM *)
+    mov         ecx, DCTSIZE/4
+    alignx      16, 7
+.rowloop:
+
+    movq        mm0, MMWORD [MMBLOCK(2,0,edx,SIZEOF_DCTELEM)]
+    movq        mm1, MMWORD [MMBLOCK(3,0,edx,SIZEOF_DCTELEM)]
+    movq        mm2, MMWORD [MMBLOCK(2,1,edx,SIZEOF_DCTELEM)]
+    movq        mm3, MMWORD [MMBLOCK(3,1,edx,SIZEOF_DCTELEM)]
+
+    ; mm0=(20 21 22 23), mm2=(24 25 26 27)
+    ; mm1=(30 31 32 33), mm3=(34 35 36 37)
+
+    movq        mm4, mm0                ; transpose coefficients(phase 1)
+    punpcklwd   mm0, mm1                ; mm0=(20 30 21 31)
+    punpckhwd   mm4, mm1                ; mm4=(22 32 23 33)
+    movq        mm5, mm2                ; transpose coefficients(phase 1)
+    punpcklwd   mm2, mm3                ; mm2=(24 34 25 35)
+    punpckhwd   mm5, mm3                ; mm5=(26 36 27 37)
+
+    movq        mm6, MMWORD [MMBLOCK(0,0,edx,SIZEOF_DCTELEM)]
+    movq        mm7, MMWORD [MMBLOCK(1,0,edx,SIZEOF_DCTELEM)]
+    movq        mm1, MMWORD [MMBLOCK(0,1,edx,SIZEOF_DCTELEM)]
+    movq        mm3, MMWORD [MMBLOCK(1,1,edx,SIZEOF_DCTELEM)]
+
+    ; mm6=(00 01 02 03), mm1=(04 05 06 07)
+    ; mm7=(10 11 12 13), mm3=(14 15 16 17)
+
+    movq        MMWORD [wk(0)], mm4     ; wk(0)=(22 32 23 33)
+    movq        MMWORD [wk(1)], mm2     ; wk(1)=(24 34 25 35)
+
+    movq        mm4, mm6                ; transpose coefficients(phase 1)
+    punpcklwd   mm6, mm7                ; mm6=(00 10 01 11)
+    punpckhwd   mm4, mm7                ; mm4=(02 12 03 13)
+    movq        mm2, mm1                ; transpose coefficients(phase 1)
+    punpcklwd   mm1, mm3                ; mm1=(04 14 05 15)
+    punpckhwd   mm2, mm3                ; mm2=(06 16 07 17)
+
+    movq        mm7, mm6                ; transpose coefficients(phase 2)
+    punpckldq   mm6, mm0                ; mm6=(00 10 20 30)=data0
+    punpckhdq   mm7, mm0                ; mm7=(01 11 21 31)=data1
+    movq        mm3, mm2                ; transpose coefficients(phase 2)
+    punpckldq   mm2, mm5                ; mm2=(06 16 26 36)=data6
+    punpckhdq   mm3, mm5                ; mm3=(07 17 27 37)=data7
+
+    movq        mm0, mm7
+    movq        mm5, mm6
+    psubw       mm7, mm2                ; mm7=data1-data6=tmp6
+    psubw       mm6, mm3                ; mm6=data0-data7=tmp7
+    paddw       mm0, mm2                ; mm0=data1+data6=tmp1
+    paddw       mm5, mm3                ; mm5=data0+data7=tmp0
+
+    movq        mm2, MMWORD [wk(0)]     ; mm2=(22 32 23 33)
+    movq        mm3, MMWORD [wk(1)]     ; mm3=(24 34 25 35)
+    movq        MMWORD [wk(0)], mm7     ; wk(0)=tmp6
+    movq        MMWORD [wk(1)], mm6     ; wk(1)=tmp7
+
+    movq        mm7, mm4                ; transpose coefficients(phase 2)
+    punpckldq   mm4, mm2                ; mm4=(02 12 22 32)=data2
+    punpckhdq   mm7, mm2                ; mm7=(03 13 23 33)=data3
+    movq        mm6, mm1                ; transpose coefficients(phase 2)
+    punpckldq   mm1, mm3                ; mm1=(04 14 24 34)=data4
+    punpckhdq   mm6, mm3                ; mm6=(05 15 25 35)=data5
+
+    movq        mm2, mm7
+    movq        mm3, mm4
+    paddw       mm7, mm1                ; mm7=data3+data4=tmp3
+    paddw       mm4, mm6                ; mm4=data2+data5=tmp2
+    psubw       mm2, mm1                ; mm2=data3-data4=tmp4
+    psubw       mm3, mm6                ; mm3=data2-data5=tmp5
+
+    ; -- Even part
+
+    movq        mm1, mm5
+    movq        mm6, mm0
+    psubw       mm5, mm7                ; mm5=tmp13
+    psubw       mm0, mm4                ; mm0=tmp12
+    paddw       mm1, mm7                ; mm1=tmp10
+    paddw       mm6, mm4                ; mm6=tmp11
+
+    paddw       mm0, mm5
+    psllw       mm0, PRE_MULTIPLY_SCALE_BITS
+    pmulhw      mm0, [GOTOFF(ebx,PW_F0707)]  ; mm0=z1
+
+    movq        mm7, mm1
+    movq        mm4, mm5
+    psubw       mm1, mm6                ; mm1=data4
+    psubw       mm5, mm0                ; mm5=data6
+    paddw       mm7, mm6                ; mm7=data0
+    paddw       mm4, mm0                ; mm4=data2
+
+    movq        MMWORD [MMBLOCK(0,1,edx,SIZEOF_DCTELEM)], mm1
+    movq        MMWORD [MMBLOCK(2,1,edx,SIZEOF_DCTELEM)], mm5
+    movq        MMWORD [MMBLOCK(0,0,edx,SIZEOF_DCTELEM)], mm7
+    movq        MMWORD [MMBLOCK(2,0,edx,SIZEOF_DCTELEM)], mm4
+
+    ; -- Odd part
+
+    movq        mm6, MMWORD [wk(0)]     ; mm6=tmp6
+    movq        mm0, MMWORD [wk(1)]     ; mm0=tmp7
+
+    paddw       mm2, mm3                ; mm2=tmp10
+    paddw       mm3, mm6                ; mm3=tmp11
+    paddw       mm6, mm0                ; mm6=tmp12, mm0=tmp7
+
+    psllw       mm2, PRE_MULTIPLY_SCALE_BITS
+    psllw       mm6, PRE_MULTIPLY_SCALE_BITS
+
+    psllw       mm3, PRE_MULTIPLY_SCALE_BITS
+    pmulhw      mm3, [GOTOFF(ebx,PW_F0707)]  ; mm3=z3
+
+    movq        mm1, mm2                     ; mm1=tmp10
+    psubw       mm2, mm6
+    pmulhw      mm2, [GOTOFF(ebx,PW_F0382)]  ; mm2=z5
+    pmulhw      mm1, [GOTOFF(ebx,PW_F0541)]  ; mm1=MULTIPLY(tmp10,FIX_0_54119610)
+    pmulhw      mm6, [GOTOFF(ebx,PW_F1306)]  ; mm6=MULTIPLY(tmp12,FIX_1_30656296)
+    paddw       mm1, mm2                     ; mm1=z2
+    paddw       mm6, mm2                     ; mm6=z4
+
+    movq        mm5, mm0
+    psubw       mm0, mm3                ; mm0=z13
+    paddw       mm5, mm3                ; mm5=z11
+
+    movq        mm7, mm0
+    movq        mm4, mm5
+    psubw       mm0, mm1                ; mm0=data3
+    psubw       mm5, mm6                ; mm5=data7
+    paddw       mm7, mm1                ; mm7=data5
+    paddw       mm4, mm6                ; mm4=data1
+
+    movq        MMWORD [MMBLOCK(3,0,edx,SIZEOF_DCTELEM)], mm0
+    movq        MMWORD [MMBLOCK(3,1,edx,SIZEOF_DCTELEM)], mm5
+    movq        MMWORD [MMBLOCK(1,1,edx,SIZEOF_DCTELEM)], mm7
+    movq        MMWORD [MMBLOCK(1,0,edx,SIZEOF_DCTELEM)], mm4
+
+    add         edx, byte 4*DCTSIZE*SIZEOF_DCTELEM
+    dec         ecx
+    jnz         near .rowloop
+
+    ; ---- Pass 2: process columns.
+
+    mov         edx, POINTER [data(eax)]  ; (DCTELEM *)
+    mov         ecx, DCTSIZE/4
+    alignx      16, 7
+.columnloop:
+
+    movq        mm0, MMWORD [MMBLOCK(2,0,edx,SIZEOF_DCTELEM)]
+    movq        mm1, MMWORD [MMBLOCK(3,0,edx,SIZEOF_DCTELEM)]
+    movq        mm2, MMWORD [MMBLOCK(6,0,edx,SIZEOF_DCTELEM)]
+    movq        mm3, MMWORD [MMBLOCK(7,0,edx,SIZEOF_DCTELEM)]
+
+    ; mm0=(02 12 22 32), mm2=(42 52 62 72)
+    ; mm1=(03 13 23 33), mm3=(43 53 63 73)
+
+    movq        mm4, mm0                ; transpose coefficients(phase 1)
+    punpcklwd   mm0, mm1                ; mm0=(02 03 12 13)
+    punpckhwd   mm4, mm1                ; mm4=(22 23 32 33)
+    movq        mm5, mm2                ; transpose coefficients(phase 1)
+    punpcklwd   mm2, mm3                ; mm2=(42 43 52 53)
+    punpckhwd   mm5, mm3                ; mm5=(62 63 72 73)
+
+    movq        mm6, MMWORD [MMBLOCK(0,0,edx,SIZEOF_DCTELEM)]
+    movq        mm7, MMWORD [MMBLOCK(1,0,edx,SIZEOF_DCTELEM)]
+    movq        mm1, MMWORD [MMBLOCK(4,0,edx,SIZEOF_DCTELEM)]
+    movq        mm3, MMWORD [MMBLOCK(5,0,edx,SIZEOF_DCTELEM)]
+
+    ; mm6=(00 10 20 30), mm1=(40 50 60 70)
+    ; mm7=(01 11 21 31), mm3=(41 51 61 71)
+
+    movq        MMWORD [wk(0)], mm4     ; wk(0)=(22 23 32 33)
+    movq        MMWORD [wk(1)], mm2     ; wk(1)=(42 43 52 53)
+
+    movq        mm4, mm6                ; transpose coefficients(phase 1)
+    punpcklwd   mm6, mm7                ; mm6=(00 01 10 11)
+    punpckhwd   mm4, mm7                ; mm4=(20 21 30 31)
+    movq        mm2, mm1                ; transpose coefficients(phase 1)
+    punpcklwd   mm1, mm3                ; mm1=(40 41 50 51)
+    punpckhwd   mm2, mm3                ; mm2=(60 61 70 71)
+
+    movq        mm7, mm6                ; transpose coefficients(phase 2)
+    punpckldq   mm6, mm0                ; mm6=(00 01 02 03)=data0
+    punpckhdq   mm7, mm0                ; mm7=(10 11 12 13)=data1
+    movq        mm3, mm2                ; transpose coefficients(phase 2)
+    punpckldq   mm2, mm5                ; mm2=(60 61 62 63)=data6
+    punpckhdq   mm3, mm5                ; mm3=(70 71 72 73)=data7
+
+    movq        mm0, mm7
+    movq        mm5, mm6
+    psubw       mm7, mm2                ; mm7=data1-data6=tmp6
+    psubw       mm6, mm3                ; mm6=data0-data7=tmp7
+    paddw       mm0, mm2                ; mm0=data1+data6=tmp1
+    paddw       mm5, mm3                ; mm5=data0+data7=tmp0
+
+    movq        mm2, MMWORD [wk(0)]     ; mm2=(22 23 32 33)
+    movq        mm3, MMWORD [wk(1)]     ; mm3=(42 43 52 53)
+    movq        MMWORD [wk(0)], mm7     ; wk(0)=tmp6
+    movq        MMWORD [wk(1)], mm6     ; wk(1)=tmp7
+
+    movq        mm7, mm4                ; transpose coefficients(phase 2)
+    punpckldq   mm4, mm2                ; mm4=(20 21 22 23)=data2
+    punpckhdq   mm7, mm2                ; mm7=(30 31 32 33)=data3
+    movq        mm6, mm1                ; transpose coefficients(phase 2)
+    punpckldq   mm1, mm3                ; mm1=(40 41 42 43)=data4
+    punpckhdq   mm6, mm3                ; mm6=(50 51 52 53)=data5
+
+    movq        mm2, mm7
+    movq        mm3, mm4
+    paddw       mm7, mm1                ; mm7=data3+data4=tmp3
+    paddw       mm4, mm6                ; mm4=data2+data5=tmp2
+    psubw       mm2, mm1                ; mm2=data3-data4=tmp4
+    psubw       mm3, mm6                ; mm3=data2-data5=tmp5
+
+    ; -- Even part
+
+    movq        mm1, mm5
+    movq        mm6, mm0
+    psubw       mm5, mm7                ; mm5=tmp13
+    psubw       mm0, mm4                ; mm0=tmp12
+    paddw       mm1, mm7                ; mm1=tmp10
+    paddw       mm6, mm4                ; mm6=tmp11
+
+    paddw       mm0, mm5
+    psllw       mm0, PRE_MULTIPLY_SCALE_BITS
+    pmulhw      mm0, [GOTOFF(ebx,PW_F0707)]  ; mm0=z1
+
+    movq        mm7, mm1
+    movq        mm4, mm5
+    psubw       mm1, mm6                ; mm1=data4
+    psubw       mm5, mm0                ; mm5=data6
+    paddw       mm7, mm6                ; mm7=data0
+    paddw       mm4, mm0                ; mm4=data2
+
+    movq        MMWORD [MMBLOCK(4,0,edx,SIZEOF_DCTELEM)], mm1
+    movq        MMWORD [MMBLOCK(6,0,edx,SIZEOF_DCTELEM)], mm5
+    movq        MMWORD [MMBLOCK(0,0,edx,SIZEOF_DCTELEM)], mm7
+    movq        MMWORD [MMBLOCK(2,0,edx,SIZEOF_DCTELEM)], mm4
+
+    ; -- Odd part
+
+    movq        mm6, MMWORD [wk(0)]     ; mm6=tmp6
+    movq        mm0, MMWORD [wk(1)]     ; mm0=tmp7
+
+    paddw       mm2, mm3                ; mm2=tmp10
+    paddw       mm3, mm6                ; mm3=tmp11
+    paddw       mm6, mm0                ; mm6=tmp12, mm0=tmp7
+
+    psllw       mm2, PRE_MULTIPLY_SCALE_BITS
+    psllw       mm6, PRE_MULTIPLY_SCALE_BITS
+
+    psllw       mm3, PRE_MULTIPLY_SCALE_BITS
+    pmulhw      mm3, [GOTOFF(ebx,PW_F0707)]  ; mm3=z3
+
+    movq        mm1, mm2                     ; mm1=tmp10
+    psubw       mm2, mm6
+    pmulhw      mm2, [GOTOFF(ebx,PW_F0382)]  ; mm2=z5
+    pmulhw      mm1, [GOTOFF(ebx,PW_F0541)]  ; mm1=MULTIPLY(tmp10,FIX_0_54119610)
+    pmulhw      mm6, [GOTOFF(ebx,PW_F1306)]  ; mm6=MULTIPLY(tmp12,FIX_1_30656296)
+    paddw       mm1, mm2                     ; mm1=z2
+    paddw       mm6, mm2                     ; mm6=z4
+
+    movq        mm5, mm0
+    psubw       mm0, mm3                ; mm0=z13
+    paddw       mm5, mm3                ; mm5=z11
+
+    movq        mm7, mm0
+    movq        mm4, mm5
+    psubw       mm0, mm1                ; mm0=data3
+    psubw       mm5, mm6                ; mm5=data7
+    paddw       mm7, mm1                ; mm7=data5
+    paddw       mm4, mm6                ; mm4=data1
+
+    movq        MMWORD [MMBLOCK(3,0,edx,SIZEOF_DCTELEM)], mm0
+    movq        MMWORD [MMBLOCK(7,0,edx,SIZEOF_DCTELEM)], mm5
+    movq        MMWORD [MMBLOCK(5,0,edx,SIZEOF_DCTELEM)], mm7
+    movq        MMWORD [MMBLOCK(1,0,edx,SIZEOF_DCTELEM)], mm4
+
+    add         edx, byte 4*SIZEOF_DCTELEM
+    dec         ecx
+    jnz         near .columnloop
+
+    emms                                ; empty MMX state
+
+;   pop         edi                     ; unused
+;   pop         esi                     ; unused
+;   pop         edx                     ; need not be preserved
+;   pop         ecx                     ; need not be preserved
+    poppic      ebx
+    mov         esp, ebp                ; esp <- aligned ebp
+    pop         esp                     ; esp <- original ebp
+    pop         ebp
+    ret
+
+; For some reason, the OS X linker does not honor the request to align the
+; segment unless we do this.
+    align       32
diff --git a/3rdparty/libjpeg/src/simd/i386/jfdctfst-sse2.asm b/3rdparty/libjpeg/src/simd/i386/jfdctfst-sse2.asm
new file mode 100644
index 00000000..446fa7a6
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/i386/jfdctfst-sse2.asm
@@ -0,0 +1,403 @@
+;
+; jfdctfst.asm - fast integer FDCT (SSE2)
+;
+; Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+; Copyright (C) 2016, D. R. Commander.
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+;
+; This file should be assembled with NASM (Netwide Assembler),
+; can *not* be assembled with Microsoft's MASM or any compatible
+; assembler (including Borland's Turbo Assembler).
+; NASM is available from http://nasm.sourceforge.net/ or
+; http://sourceforge.net/project/showfiles.php?group_id=6208
+;
+; This file contains a fast, not so accurate integer implementation of
+; the forward DCT (Discrete Cosine Transform). The following code is
+; based directly on the IJG's original jfdctfst.c; see the jfdctfst.c
+; for more details.
+
+%include "jsimdext.inc"
+%include "jdct.inc"
+
+; --------------------------------------------------------------------------
+
+%define CONST_BITS  8  ; 14 is also OK.
+
+%if CONST_BITS == 8
+F_0_382 equ  98  ; FIX(0.382683433)
+F_0_541 equ 139  ; FIX(0.541196100)
+F_0_707 equ 181  ; FIX(0.707106781)
+F_1_306 equ 334  ; FIX(1.306562965)
+%else
+; NASM cannot do compile-time arithmetic on floating-point constants.
+%define DESCALE(x, n)  (((x) + (1 << ((n) - 1))) >> (n))
+F_0_382 equ DESCALE( 410903207, 30 - CONST_BITS)  ; FIX(0.382683433)
+F_0_541 equ DESCALE( 581104887, 30 - CONST_BITS)  ; FIX(0.541196100)
+F_0_707 equ DESCALE( 759250124, 30 - CONST_BITS)  ; FIX(0.707106781)
+F_1_306 equ DESCALE(1402911301, 30 - CONST_BITS)  ; FIX(1.306562965)
+%endif
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_CONST
+
+; PRE_MULTIPLY_SCALE_BITS <= 2 (to avoid overflow)
+; CONST_BITS + CONST_SHIFT + PRE_MULTIPLY_SCALE_BITS == 16 (for pmulhw)
+
+%define PRE_MULTIPLY_SCALE_BITS  2
+%define CONST_SHIFT              (16 - PRE_MULTIPLY_SCALE_BITS - CONST_BITS)
+
+    alignz      32
+    GLOBAL_DATA(jconst_fdct_ifast_sse2)
+
+EXTN(jconst_fdct_ifast_sse2):
+
+PW_F0707 times 8 dw F_0_707 << CONST_SHIFT
+PW_F0382 times 8 dw F_0_382 << CONST_SHIFT
+PW_F0541 times 8 dw F_0_541 << CONST_SHIFT
+PW_F1306 times 8 dw F_1_306 << CONST_SHIFT
+
+    alignz      32
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_TEXT
+    BITS        32
+;
+; Perform the forward DCT on one block of samples.
+;
+; GLOBAL(void)
+; jsimd_fdct_ifast_sse2(DCTELEM *data)
+;
+
+%define data(b)       (b) + 8           ; DCTELEM *data
+
+%define original_ebp  ebp + 0
+%define wk(i)         ebp - (WK_NUM - (i)) * SIZEOF_XMMWORD
+                                        ; xmmword wk[WK_NUM]
+%define WK_NUM        2
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_fdct_ifast_sse2)
+
+EXTN(jsimd_fdct_ifast_sse2):
+    push        ebp
+    mov         eax, esp                     ; eax = original ebp
+    sub         esp, byte 4
+    and         esp, byte (-SIZEOF_XMMWORD)  ; align to 128 bits
+    mov         [esp], eax
+    mov         ebp, esp                     ; ebp = aligned ebp
+    lea         esp, [wk(0)]
+    pushpic     ebx
+;   push        ecx                     ; unused
+;   push        edx                     ; need not be preserved
+;   push        esi                     ; unused
+;   push        edi                     ; unused
+
+    get_GOT     ebx                     ; get GOT address
+
+    ; ---- Pass 1: process rows.
+
+    mov         edx, POINTER [data(eax)]  ; (DCTELEM *)
+
+    movdqa      xmm0, XMMWORD [XMMBLOCK(0,0,edx,SIZEOF_DCTELEM)]
+    movdqa      xmm1, XMMWORD [XMMBLOCK(1,0,edx,SIZEOF_DCTELEM)]
+    movdqa      xmm2, XMMWORD [XMMBLOCK(2,0,edx,SIZEOF_DCTELEM)]
+    movdqa      xmm3, XMMWORD [XMMBLOCK(3,0,edx,SIZEOF_DCTELEM)]
+
+    ; xmm0=(00 01 02 03 04 05 06 07), xmm2=(20 21 22 23 24 25 26 27)
+    ; xmm1=(10 11 12 13 14 15 16 17), xmm3=(30 31 32 33 34 35 36 37)
+
+    movdqa      xmm4, xmm0              ; transpose coefficients(phase 1)
+    punpcklwd   xmm0, xmm1              ; xmm0=(00 10 01 11 02 12 03 13)
+    punpckhwd   xmm4, xmm1              ; xmm4=(04 14 05 15 06 16 07 17)
+    movdqa      xmm5, xmm2              ; transpose coefficients(phase 1)
+    punpcklwd   xmm2, xmm3              ; xmm2=(20 30 21 31 22 32 23 33)
+    punpckhwd   xmm5, xmm3              ; xmm5=(24 34 25 35 26 36 27 37)
+
+    movdqa      xmm6, XMMWORD [XMMBLOCK(4,0,edx,SIZEOF_DCTELEM)]
+    movdqa      xmm7, XMMWORD [XMMBLOCK(5,0,edx,SIZEOF_DCTELEM)]
+    movdqa      xmm1, XMMWORD [XMMBLOCK(6,0,edx,SIZEOF_DCTELEM)]
+    movdqa      xmm3, XMMWORD [XMMBLOCK(7,0,edx,SIZEOF_DCTELEM)]
+
+    ; xmm6=( 4 12 20 28 36 44 52 60), xmm1=( 6 14 22 30 38 46 54 62)
+    ; xmm7=( 5 13 21 29 37 45 53 61), xmm3=( 7 15 23 31 39 47 55 63)
+
+    movdqa      XMMWORD [wk(0)], xmm2   ; wk(0)=(20 30 21 31 22 32 23 33)
+    movdqa      XMMWORD [wk(1)], xmm5   ; wk(1)=(24 34 25 35 26 36 27 37)
+
+    movdqa      xmm2, xmm6              ; transpose coefficients(phase 1)
+    punpcklwd   xmm6, xmm7              ; xmm6=(40 50 41 51 42 52 43 53)
+    punpckhwd   xmm2, xmm7              ; xmm2=(44 54 45 55 46 56 47 57)
+    movdqa      xmm5, xmm1              ; transpose coefficients(phase 1)
+    punpcklwd   xmm1, xmm3              ; xmm1=(60 70 61 71 62 72 63 73)
+    punpckhwd   xmm5, xmm3              ; xmm5=(64 74 65 75 66 76 67 77)
+
+    movdqa      xmm7, xmm6              ; transpose coefficients(phase 2)
+    punpckldq   xmm6, xmm1              ; xmm6=(40 50 60 70 41 51 61 71)
+    punpckhdq   xmm7, xmm1              ; xmm7=(42 52 62 72 43 53 63 73)
+    movdqa      xmm3, xmm2              ; transpose coefficients(phase 2)
+    punpckldq   xmm2, xmm5              ; xmm2=(44 54 64 74 45 55 65 75)
+    punpckhdq   xmm3, xmm5              ; xmm3=(46 56 66 76 47 57 67 77)
+
+    movdqa      xmm1, XMMWORD [wk(0)]   ; xmm1=(20 30 21 31 22 32 23 33)
+    movdqa      xmm5, XMMWORD [wk(1)]   ; xmm5=(24 34 25 35 26 36 27 37)
+    movdqa      XMMWORD [wk(0)], xmm7   ; wk(0)=(42 52 62 72 43 53 63 73)
+    movdqa      XMMWORD [wk(1)], xmm2   ; wk(1)=(44 54 64 74 45 55 65 75)
+
+    movdqa      xmm7, xmm0              ; transpose coefficients(phase 2)
+    punpckldq   xmm0, xmm1              ; xmm0=(00 10 20 30 01 11 21 31)
+    punpckhdq   xmm7, xmm1              ; xmm7=(02 12 22 32 03 13 23 33)
+    movdqa      xmm2, xmm4              ; transpose coefficients(phase 2)
+    punpckldq   xmm4, xmm5              ; xmm4=(04 14 24 34 05 15 25 35)
+    punpckhdq   xmm2, xmm5              ; xmm2=(06 16 26 36 07 17 27 37)
+
+    movdqa      xmm1, xmm0              ; transpose coefficients(phase 3)
+    punpcklqdq  xmm0, xmm6              ; xmm0=(00 10 20 30 40 50 60 70)=data0
+    punpckhqdq  xmm1, xmm6              ; xmm1=(01 11 21 31 41 51 61 71)=data1
+    movdqa      xmm5, xmm2              ; transpose coefficients(phase 3)
+    punpcklqdq  xmm2, xmm3              ; xmm2=(06 16 26 36 46 56 66 76)=data6
+    punpckhqdq  xmm5, xmm3              ; xmm5=(07 17 27 37 47 57 67 77)=data7
+
+    movdqa      xmm6, xmm1
+    movdqa      xmm3, xmm0
+    psubw       xmm1, xmm2              ; xmm1=data1-data6=tmp6
+    psubw       xmm0, xmm5              ; xmm0=data0-data7=tmp7
+    paddw       xmm6, xmm2              ; xmm6=data1+data6=tmp1
+    paddw       xmm3, xmm5              ; xmm3=data0+data7=tmp0
+
+    movdqa      xmm2, XMMWORD [wk(0)]   ; xmm2=(42 52 62 72 43 53 63 73)
+    movdqa      xmm5, XMMWORD [wk(1)]   ; xmm5=(44 54 64 74 45 55 65 75)
+    movdqa      XMMWORD [wk(0)], xmm1   ; wk(0)=tmp6
+    movdqa      XMMWORD [wk(1)], xmm0   ; wk(1)=tmp7
+
+    movdqa      xmm1, xmm7              ; transpose coefficients(phase 3)
+    punpcklqdq  xmm7, xmm2              ; xmm7=(02 12 22 32 42 52 62 72)=data2
+    punpckhqdq  xmm1, xmm2              ; xmm1=(03 13 23 33 43 53 63 73)=data3
+    movdqa      xmm0, xmm4              ; transpose coefficients(phase 3)
+    punpcklqdq  xmm4, xmm5              ; xmm4=(04 14 24 34 44 54 64 74)=data4
+    punpckhqdq  xmm0, xmm5              ; xmm0=(05 15 25 35 45 55 65 75)=data5
+
+    movdqa      xmm2, xmm1
+    movdqa      xmm5, xmm7
+    paddw       xmm1, xmm4              ; xmm1=data3+data4=tmp3
+    paddw       xmm7, xmm0              ; xmm7=data2+data5=tmp2
+    psubw       xmm2, xmm4              ; xmm2=data3-data4=tmp4
+    psubw       xmm5, xmm0              ; xmm5=data2-data5=tmp5
+
+    ; -- Even part
+
+    movdqa      xmm4, xmm3
+    movdqa      xmm0, xmm6
+    psubw       xmm3, xmm1              ; xmm3=tmp13
+    psubw       xmm6, xmm7              ; xmm6=tmp12
+    paddw       xmm4, xmm1              ; xmm4=tmp10
+    paddw       xmm0, xmm7              ; xmm0=tmp11
+
+    paddw       xmm6, xmm3
+    psllw       xmm6, PRE_MULTIPLY_SCALE_BITS
+    pmulhw      xmm6, [GOTOFF(ebx,PW_F0707)]  ; xmm6=z1
+
+    movdqa      xmm1, xmm4
+    movdqa      xmm7, xmm3
+    psubw       xmm4, xmm0              ; xmm4=data4
+    psubw       xmm3, xmm6              ; xmm3=data6
+    paddw       xmm1, xmm0              ; xmm1=data0
+    paddw       xmm7, xmm6              ; xmm7=data2
+
+    movdqa      xmm0, XMMWORD [wk(0)]   ; xmm0=tmp6
+    movdqa      xmm6, XMMWORD [wk(1)]   ; xmm6=tmp7
+    movdqa      XMMWORD [wk(0)], xmm4   ; wk(0)=data4
+    movdqa      XMMWORD [wk(1)], xmm3   ; wk(1)=data6
+
+    ; -- Odd part
+
+    paddw       xmm2, xmm5              ; xmm2=tmp10
+    paddw       xmm5, xmm0              ; xmm5=tmp11
+    paddw       xmm0, xmm6              ; xmm0=tmp12, xmm6=tmp7
+
+    psllw       xmm2, PRE_MULTIPLY_SCALE_BITS
+    psllw       xmm0, PRE_MULTIPLY_SCALE_BITS
+
+    psllw       xmm5, PRE_MULTIPLY_SCALE_BITS
+    pmulhw      xmm5, [GOTOFF(ebx,PW_F0707)]  ; xmm5=z3
+
+    movdqa      xmm4, xmm2                    ; xmm4=tmp10
+    psubw       xmm2, xmm0
+    pmulhw      xmm2, [GOTOFF(ebx,PW_F0382)]  ; xmm2=z5
+    pmulhw      xmm4, [GOTOFF(ebx,PW_F0541)]  ; xmm4=MULTIPLY(tmp10,FIX_0_541196)
+    pmulhw      xmm0, [GOTOFF(ebx,PW_F1306)]  ; xmm0=MULTIPLY(tmp12,FIX_1_306562)
+    paddw       xmm4, xmm2                    ; xmm4=z2
+    paddw       xmm0, xmm2                    ; xmm0=z4
+
+    movdqa      xmm3, xmm6
+    psubw       xmm6, xmm5              ; xmm6=z13
+    paddw       xmm3, xmm5              ; xmm3=z11
+
+    movdqa      xmm2, xmm6
+    movdqa      xmm5, xmm3
+    psubw       xmm6, xmm4              ; xmm6=data3
+    psubw       xmm3, xmm0              ; xmm3=data7
+    paddw       xmm2, xmm4              ; xmm2=data5
+    paddw       xmm5, xmm0              ; xmm5=data1
+
+    ; ---- Pass 2: process columns.
+
+;   mov         edx, POINTER [data(eax)]  ; (DCTELEM *)
+
+    ; xmm1=(00 10 20 30 40 50 60 70), xmm7=(02 12 22 32 42 52 62 72)
+    ; xmm5=(01 11 21 31 41 51 61 71), xmm6=(03 13 23 33 43 53 63 73)
+
+    movdqa      xmm4, xmm1              ; transpose coefficients(phase 1)
+    punpcklwd   xmm1, xmm5              ; xmm1=(00 01 10 11 20 21 30 31)
+    punpckhwd   xmm4, xmm5              ; xmm4=(40 41 50 51 60 61 70 71)
+    movdqa      xmm0, xmm7              ; transpose coefficients(phase 1)
+    punpcklwd   xmm7, xmm6              ; xmm7=(02 03 12 13 22 23 32 33)
+    punpckhwd   xmm0, xmm6              ; xmm0=(42 43 52 53 62 63 72 73)
+
+    movdqa      xmm5, XMMWORD [wk(0)]   ; xmm5=col4
+    movdqa      xmm6, XMMWORD [wk(1)]   ; xmm6=col6
+
+    ; xmm5=(04 14 24 34 44 54 64 74), xmm6=(06 16 26 36 46 56 66 76)
+    ; xmm2=(05 15 25 35 45 55 65 75), xmm3=(07 17 27 37 47 57 67 77)
+
+    movdqa      XMMWORD [wk(0)], xmm7   ; wk(0)=(02 03 12 13 22 23 32 33)
+    movdqa      XMMWORD [wk(1)], xmm0   ; wk(1)=(42 43 52 53 62 63 72 73)
+
+    movdqa      xmm7, xmm5              ; transpose coefficients(phase 1)
+    punpcklwd   xmm5, xmm2              ; xmm5=(04 05 14 15 24 25 34 35)
+    punpckhwd   xmm7, xmm2              ; xmm7=(44 45 54 55 64 65 74 75)
+    movdqa      xmm0, xmm6              ; transpose coefficients(phase 1)
+    punpcklwd   xmm6, xmm3              ; xmm6=(06 07 16 17 26 27 36 37)
+    punpckhwd   xmm0, xmm3              ; xmm0=(46 47 56 57 66 67 76 77)
+
+    movdqa      xmm2, xmm5              ; transpose coefficients(phase 2)
+    punpckldq   xmm5, xmm6              ; xmm5=(04 05 06 07 14 15 16 17)
+    punpckhdq   xmm2, xmm6              ; xmm2=(24 25 26 27 34 35 36 37)
+    movdqa      xmm3, xmm7              ; transpose coefficients(phase 2)
+    punpckldq   xmm7, xmm0              ; xmm7=(44 45 46 47 54 55 56 57)
+    punpckhdq   xmm3, xmm0              ; xmm3=(64 65 66 67 74 75 76 77)
+
+    movdqa      xmm6, XMMWORD [wk(0)]   ; xmm6=(02 03 12 13 22 23 32 33)
+    movdqa      xmm0, XMMWORD [wk(1)]   ; xmm0=(42 43 52 53 62 63 72 73)
+    movdqa      XMMWORD [wk(0)], xmm2   ; wk(0)=(24 25 26 27 34 35 36 37)
+    movdqa      XMMWORD [wk(1)], xmm7   ; wk(1)=(44 45 46 47 54 55 56 57)
+
+    movdqa      xmm2, xmm1              ; transpose coefficients(phase 2)
+    punpckldq   xmm1, xmm6              ; xmm1=(00 01 02 03 10 11 12 13)
+    punpckhdq   xmm2, xmm6              ; xmm2=(20 21 22 23 30 31 32 33)
+    movdqa      xmm7, xmm4              ; transpose coefficients(phase 2)
+    punpckldq   xmm4, xmm0              ; xmm4=(40 41 42 43 50 51 52 53)
+    punpckhdq   xmm7, xmm0              ; xmm7=(60 61 62 63 70 71 72 73)
+
+    movdqa      xmm6, xmm1              ; transpose coefficients(phase 3)
+    punpcklqdq  xmm1, xmm5              ; xmm1=(00 01 02 03 04 05 06 07)=data0
+    punpckhqdq  xmm6, xmm5              ; xmm6=(10 11 12 13 14 15 16 17)=data1
+    movdqa      xmm0, xmm7              ; transpose coefficients(phase 3)
+    punpcklqdq  xmm7, xmm3              ; xmm7=(60 61 62 63 64 65 66 67)=data6
+    punpckhqdq  xmm0, xmm3              ; xmm0=(70 71 72 73 74 75 76 77)=data7
+
+    movdqa      xmm5, xmm6
+    movdqa      xmm3, xmm1
+    psubw       xmm6, xmm7              ; xmm6=data1-data6=tmp6
+    psubw       xmm1, xmm0              ; xmm1=data0-data7=tmp7
+    paddw       xmm5, xmm7              ; xmm5=data1+data6=tmp1
+    paddw       xmm3, xmm0              ; xmm3=data0+data7=tmp0
+
+    movdqa      xmm7, XMMWORD [wk(0)]   ; xmm7=(24 25 26 27 34 35 36 37)
+    movdqa      xmm0, XMMWORD [wk(1)]   ; xmm0=(44 45 46 47 54 55 56 57)
+    movdqa      XMMWORD [wk(0)], xmm6   ; wk(0)=tmp6
+    movdqa      XMMWORD [wk(1)], xmm1   ; wk(1)=tmp7
+
+    movdqa      xmm6, xmm2              ; transpose coefficients(phase 3)
+    punpcklqdq  xmm2, xmm7              ; xmm2=(20 21 22 23 24 25 26 27)=data2
+    punpckhqdq  xmm6, xmm7              ; xmm6=(30 31 32 33 34 35 36 37)=data3
+    movdqa      xmm1, xmm4              ; transpose coefficients(phase 3)
+    punpcklqdq  xmm4, xmm0              ; xmm4=(40 41 42 43 44 45 46 47)=data4
+    punpckhqdq  xmm1, xmm0              ; xmm1=(50 51 52 53 54 55 56 57)=data5
+
+    movdqa      xmm7, xmm6
+    movdqa      xmm0, xmm2
+    paddw       xmm6, xmm4              ; xmm6=data3+data4=tmp3
+    paddw       xmm2, xmm1              ; xmm2=data2+data5=tmp2
+    psubw       xmm7, xmm4              ; xmm7=data3-data4=tmp4
+    psubw       xmm0, xmm1              ; xmm0=data2-data5=tmp5
+
+    ; -- Even part
+
+    movdqa      xmm4, xmm3
+    movdqa      xmm1, xmm5
+    psubw       xmm3, xmm6              ; xmm3=tmp13
+    psubw       xmm5, xmm2              ; xmm5=tmp12
+    paddw       xmm4, xmm6              ; xmm4=tmp10
+    paddw       xmm1, xmm2              ; xmm1=tmp11
+
+    paddw       xmm5, xmm3
+    psllw       xmm5, PRE_MULTIPLY_SCALE_BITS
+    pmulhw      xmm5, [GOTOFF(ebx,PW_F0707)]  ; xmm5=z1
+
+    movdqa      xmm6, xmm4
+    movdqa      xmm2, xmm3
+    psubw       xmm4, xmm1              ; xmm4=data4
+    psubw       xmm3, xmm5              ; xmm3=data6
+    paddw       xmm6, xmm1              ; xmm6=data0
+    paddw       xmm2, xmm5              ; xmm2=data2
+
+    movdqa      XMMWORD [XMMBLOCK(4,0,edx,SIZEOF_DCTELEM)], xmm4
+    movdqa      XMMWORD [XMMBLOCK(6,0,edx,SIZEOF_DCTELEM)], xmm3
+    movdqa      XMMWORD [XMMBLOCK(0,0,edx,SIZEOF_DCTELEM)], xmm6
+    movdqa      XMMWORD [XMMBLOCK(2,0,edx,SIZEOF_DCTELEM)], xmm2
+
+    ; -- Odd part
+
+    movdqa      xmm1, XMMWORD [wk(0)]   ; xmm1=tmp6
+    movdqa      xmm5, XMMWORD [wk(1)]   ; xmm5=tmp7
+
+    paddw       xmm7, xmm0              ; xmm7=tmp10
+    paddw       xmm0, xmm1              ; xmm0=tmp11
+    paddw       xmm1, xmm5              ; xmm1=tmp12, xmm5=tmp7
+
+    psllw       xmm7, PRE_MULTIPLY_SCALE_BITS
+    psllw       xmm1, PRE_MULTIPLY_SCALE_BITS
+
+    psllw       xmm0, PRE_MULTIPLY_SCALE_BITS
+    pmulhw      xmm0, [GOTOFF(ebx,PW_F0707)]  ; xmm0=z3
+
+    movdqa      xmm4, xmm7                    ; xmm4=tmp10
+    psubw       xmm7, xmm1
+    pmulhw      xmm7, [GOTOFF(ebx,PW_F0382)]  ; xmm7=z5
+    pmulhw      xmm4, [GOTOFF(ebx,PW_F0541)]  ; xmm4=MULTIPLY(tmp10,FIX_0_541196)
+    pmulhw      xmm1, [GOTOFF(ebx,PW_F1306)]  ; xmm1=MULTIPLY(tmp12,FIX_1_306562)
+    paddw       xmm4, xmm7                    ; xmm4=z2
+    paddw       xmm1, xmm7                    ; xmm1=z4
+
+    movdqa      xmm3, xmm5
+    psubw       xmm5, xmm0              ; xmm5=z13
+    paddw       xmm3, xmm0              ; xmm3=z11
+
+    movdqa      xmm6, xmm5
+    movdqa      xmm2, xmm3
+    psubw       xmm5, xmm4              ; xmm5=data3
+    psubw       xmm3, xmm1              ; xmm3=data7
+    paddw       xmm6, xmm4              ; xmm6=data5
+    paddw       xmm2, xmm1              ; xmm2=data1
+
+    movdqa      XMMWORD [XMMBLOCK(3,0,edx,SIZEOF_DCTELEM)], xmm5
+    movdqa      XMMWORD [XMMBLOCK(7,0,edx,SIZEOF_DCTELEM)], xmm3
+    movdqa      XMMWORD [XMMBLOCK(5,0,edx,SIZEOF_DCTELEM)], xmm6
+    movdqa      XMMWORD [XMMBLOCK(1,0,edx,SIZEOF_DCTELEM)], xmm2
+
+;   pop         edi                     ; unused
+;   pop         esi                     ; unused
+;   pop         edx                     ; need not be preserved
+;   pop         ecx                     ; unused
+    poppic      ebx
+    mov         esp, ebp                ; esp <- aligned ebp
+    pop         esp                     ; esp <- original ebp
+    pop         ebp
+    ret
+
+; For some reason, the OS X linker does not honor the request to align the
+; segment unless we do this.
+    align       32
diff --git a/3rdparty/libjpeg/src/simd/i386/jfdctint-avx2.asm b/3rdparty/libjpeg/src/simd/i386/jfdctint-avx2.asm
new file mode 100644
index 00000000..23cf7331
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/i386/jfdctint-avx2.asm
@@ -0,0 +1,331 @@
+;
+; jfdctint.asm - accurate integer FDCT (AVX2)
+;
+; Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+; Copyright (C) 2009, 2016, 2018, 2020, D. R. Commander.
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+;
+; This file should be assembled with NASM (Netwide Assembler),
+; can *not* be assembled with Microsoft's MASM or any compatible
+; assembler (including Borland's Turbo Assembler).
+; NASM is available from http://nasm.sourceforge.net/ or
+; http://sourceforge.net/project/showfiles.php?group_id=6208
+;
+; This file contains a slower but more accurate integer implementation of the
+; forward DCT (Discrete Cosine Transform). The following code is based
+; directly on the IJG's original jfdctint.c; see the jfdctint.c for
+; more details.
+
+%include "jsimdext.inc"
+%include "jdct.inc"
+
+; --------------------------------------------------------------------------
+
+%define CONST_BITS  13
+%define PASS1_BITS  2
+
+%define DESCALE_P1  (CONST_BITS - PASS1_BITS)
+%define DESCALE_P2  (CONST_BITS + PASS1_BITS)
+
+%if CONST_BITS == 13
+F_0_298 equ  2446  ; FIX(0.298631336)
+F_0_390 equ  3196  ; FIX(0.390180644)
+F_0_541 equ  4433  ; FIX(0.541196100)
+F_0_765 equ  6270  ; FIX(0.765366865)
+F_0_899 equ  7373  ; FIX(0.899976223)
+F_1_175 equ  9633  ; FIX(1.175875602)
+F_1_501 equ 12299  ; FIX(1.501321110)
+F_1_847 equ 15137  ; FIX(1.847759065)
+F_1_961 equ 16069  ; FIX(1.961570560)
+F_2_053 equ 16819  ; FIX(2.053119869)
+F_2_562 equ 20995  ; FIX(2.562915447)
+F_3_072 equ 25172  ; FIX(3.072711026)
+%else
+; NASM cannot do compile-time arithmetic on floating-point constants.
+%define DESCALE(x, n)  (((x) + (1 << ((n) - 1))) >> (n))
+F_0_298 equ DESCALE( 320652955, 30 - CONST_BITS)  ; FIX(0.298631336)
+F_0_390 equ DESCALE( 418953276, 30 - CONST_BITS)  ; FIX(0.390180644)
+F_0_541 equ DESCALE( 581104887, 30 - CONST_BITS)  ; FIX(0.541196100)
+F_0_765 equ DESCALE( 821806413, 30 - CONST_BITS)  ; FIX(0.765366865)
+F_0_899 equ DESCALE( 966342111, 30 - CONST_BITS)  ; FIX(0.899976223)
+F_1_175 equ DESCALE(1262586813, 30 - CONST_BITS)  ; FIX(1.175875602)
+F_1_501 equ DESCALE(1612031267, 30 - CONST_BITS)  ; FIX(1.501321110)
+F_1_847 equ DESCALE(1984016188, 30 - CONST_BITS)  ; FIX(1.847759065)
+F_1_961 equ DESCALE(2106220350, 30 - CONST_BITS)  ; FIX(1.961570560)
+F_2_053 equ DESCALE(2204520673, 30 - CONST_BITS)  ; FIX(2.053119869)
+F_2_562 equ DESCALE(2751909506, 30 - CONST_BITS)  ; FIX(2.562915447)
+F_3_072 equ DESCALE(3299298341, 30 - CONST_BITS)  ; FIX(3.072711026)
+%endif
+
+; --------------------------------------------------------------------------
+; In-place 8x8x16-bit matrix transpose using AVX2 instructions
+; %1-%4: Input/output registers
+; %5-%8: Temp registers
+
+%macro dotranspose 8
+    ; %1=(00 01 02 03 04 05 06 07  40 41 42 43 44 45 46 47)
+    ; %2=(10 11 12 13 14 15 16 17  50 51 52 53 54 55 56 57)
+    ; %3=(20 21 22 23 24 25 26 27  60 61 62 63 64 65 66 67)
+    ; %4=(30 31 32 33 34 35 36 37  70 71 72 73 74 75 76 77)
+
+    vpunpcklwd  %5, %1, %2
+    vpunpckhwd  %6, %1, %2
+    vpunpcklwd  %7, %3, %4
+    vpunpckhwd  %8, %3, %4
+    ; transpose coefficients(phase 1)
+    ; %5=(00 10 01 11 02 12 03 13  40 50 41 51 42 52 43 53)
+    ; %6=(04 14 05 15 06 16 07 17  44 54 45 55 46 56 47 57)
+    ; %7=(20 30 21 31 22 32 23 33  60 70 61 71 62 72 63 73)
+    ; %8=(24 34 25 35 26 36 27 37  64 74 65 75 66 76 67 77)
+
+    vpunpckldq  %1, %5, %7
+    vpunpckhdq  %2, %5, %7
+    vpunpckldq  %3, %6, %8
+    vpunpckhdq  %4, %6, %8
+    ; transpose coefficients(phase 2)
+    ; %1=(00 10 20 30 01 11 21 31  40 50 60 70 41 51 61 71)
+    ; %2=(02 12 22 32 03 13 23 33  42 52 62 72 43 53 63 73)
+    ; %3=(04 14 24 34 05 15 25 35  44 54 64 74 45 55 65 75)
+    ; %4=(06 16 26 36 07 17 27 37  46 56 66 76 47 57 67 77)
+
+    vpermq      %1, %1, 0x8D
+    vpermq      %2, %2, 0x8D
+    vpermq      %3, %3, 0xD8
+    vpermq      %4, %4, 0xD8
+    ; transpose coefficients(phase 3)
+    ; %1=(01 11 21 31 41 51 61 71  00 10 20 30 40 50 60 70)
+    ; %2=(03 13 23 33 43 53 63 73  02 12 22 32 42 52 62 72)
+    ; %3=(04 14 24 34 44 54 64 74  05 15 25 35 45 55 65 75)
+    ; %4=(06 16 26 36 46 56 66 76  07 17 27 37 47 57 67 77)
+%endmacro
+
+; --------------------------------------------------------------------------
+; In-place 8x8x16-bit accurate integer forward DCT using AVX2 instructions
+; %1-%4: Input/output registers
+; %5-%8: Temp registers
+; %9:    Pass (1 or 2)
+
+%macro dodct 9
+    vpsubw      %5, %1, %4              ; %5=data1_0-data6_7=tmp6_7
+    vpaddw      %6, %1, %4              ; %6=data1_0+data6_7=tmp1_0
+    vpaddw      %7, %2, %3              ; %7=data3_2+data4_5=tmp3_2
+    vpsubw      %8, %2, %3              ; %8=data3_2-data4_5=tmp4_5
+
+    ; -- Even part
+
+    vperm2i128  %6, %6, %6, 0x01        ; %6=tmp0_1
+    vpaddw      %1, %6, %7              ; %1=tmp0_1+tmp3_2=tmp10_11
+    vpsubw      %6, %6, %7              ; %6=tmp0_1-tmp3_2=tmp13_12
+
+    vperm2i128  %7, %1, %1, 0x01        ; %7=tmp11_10
+    vpsignw     %1, %1, [GOTOFF(ebx, PW_1_NEG1)]  ; %1=tmp10_neg11
+    vpaddw      %7, %7, %1              ; %7=(tmp10+tmp11)_(tmp10-tmp11)
+%if %9 == 1
+    vpsllw      %1, %7, PASS1_BITS      ; %1=data0_4
+%else
+    vpaddw      %7, %7, [GOTOFF(ebx, PW_DESCALE_P2X)]
+    vpsraw      %1, %7, PASS1_BITS      ; %1=data0_4
+%endif
+
+    ; (Original)
+    ; z1 = (tmp12 + tmp13) * 0.541196100;
+    ; data2 = z1 + tmp13 * 0.765366865;
+    ; data6 = z1 + tmp12 * -1.847759065;
+    ;
+    ; (This implementation)
+    ; data2 = tmp13 * (0.541196100 + 0.765366865) + tmp12 * 0.541196100;
+    ; data6 = tmp13 * 0.541196100 + tmp12 * (0.541196100 - 1.847759065);
+
+    vperm2i128  %7, %6, %6, 0x01        ; %7=tmp12_13
+    vpunpcklwd  %2, %6, %7
+    vpunpckhwd  %6, %6, %7
+    vpmaddwd    %2, %2, [GOTOFF(ebx, PW_F130_F054_MF130_F054)]  ; %2=data2_6L
+    vpmaddwd    %6, %6, [GOTOFF(ebx, PW_F130_F054_MF130_F054)]  ; %6=data2_6H
+
+    vpaddd      %2, %2, [GOTOFF(ebx, PD_DESCALE_P %+ %9)]
+    vpaddd      %6, %6, [GOTOFF(ebx, PD_DESCALE_P %+ %9)]
+    vpsrad      %2, %2, DESCALE_P %+ %9
+    vpsrad      %6, %6, DESCALE_P %+ %9
+
+    vpackssdw   %3, %2, %6              ; %6=data2_6
+
+    ; -- Odd part
+
+    vpaddw      %7, %8, %5              ; %7=tmp4_5+tmp6_7=z3_4
+
+    ; (Original)
+    ; z5 = (z3 + z4) * 1.175875602;
+    ; z3 = z3 * -1.961570560;  z4 = z4 * -0.390180644;
+    ; z3 += z5;  z4 += z5;
+    ;
+    ; (This implementation)
+    ; z3 = z3 * (1.175875602 - 1.961570560) + z4 * 1.175875602;
+    ; z4 = z3 * 1.175875602 + z4 * (1.175875602 - 0.390180644);
+
+    vperm2i128  %2, %7, %7, 0x01        ; %2=z4_3
+    vpunpcklwd  %6, %7, %2
+    vpunpckhwd  %7, %7, %2
+    vpmaddwd    %6, %6, [GOTOFF(ebx, PW_MF078_F117_F078_F117)]  ; %6=z3_4L
+    vpmaddwd    %7, %7, [GOTOFF(ebx, PW_MF078_F117_F078_F117)]  ; %7=z3_4H
+
+    ; (Original)
+    ; z1 = tmp4 + tmp7;  z2 = tmp5 + tmp6;
+    ; tmp4 = tmp4 * 0.298631336;  tmp5 = tmp5 * 2.053119869;
+    ; tmp6 = tmp6 * 3.072711026;  tmp7 = tmp7 * 1.501321110;
+    ; z1 = z1 * -0.899976223;  z2 = z2 * -2.562915447;
+    ; data7 = tmp4 + z1 + z3;  data5 = tmp5 + z2 + z4;
+    ; data3 = tmp6 + z2 + z3;  data1 = tmp7 + z1 + z4;
+    ;
+    ; (This implementation)
+    ; tmp4 = tmp4 * (0.298631336 - 0.899976223) + tmp7 * -0.899976223;
+    ; tmp5 = tmp5 * (2.053119869 - 2.562915447) + tmp6 * -2.562915447;
+    ; tmp6 = tmp5 * -2.562915447 + tmp6 * (3.072711026 - 2.562915447);
+    ; tmp7 = tmp4 * -0.899976223 + tmp7 * (1.501321110 - 0.899976223);
+    ; data7 = tmp4 + z3;  data5 = tmp5 + z4;
+    ; data3 = tmp6 + z3;  data1 = tmp7 + z4;
+
+    vperm2i128  %4, %5, %5, 0x01        ; %4=tmp7_6
+    vpunpcklwd  %2, %8, %4
+    vpunpckhwd  %4, %8, %4
+    vpmaddwd    %2, %2, [GOTOFF(ebx, PW_MF060_MF089_MF050_MF256)]  ; %2=tmp4_5L
+    vpmaddwd    %4, %4, [GOTOFF(ebx, PW_MF060_MF089_MF050_MF256)]  ; %4=tmp4_5H
+
+    vpaddd      %2, %2, %6              ; %2=data7_5L
+    vpaddd      %4, %4, %7              ; %4=data7_5H
+
+    vpaddd      %2, %2, [GOTOFF(ebx, PD_DESCALE_P %+ %9)]
+    vpaddd      %4, %4, [GOTOFF(ebx, PD_DESCALE_P %+ %9)]
+    vpsrad      %2, %2, DESCALE_P %+ %9
+    vpsrad      %4, %4, DESCALE_P %+ %9
+
+    vpackssdw   %4, %2, %4              ; %4=data7_5
+
+    vperm2i128  %2, %8, %8, 0x01        ; %2=tmp5_4
+    vpunpcklwd  %8, %5, %2
+    vpunpckhwd  %5, %5, %2
+    vpmaddwd    %8, %8, [GOTOFF(ebx, PW_F050_MF256_F060_MF089)]  ; %8=tmp6_7L
+    vpmaddwd    %5, %5, [GOTOFF(ebx, PW_F050_MF256_F060_MF089)]  ; %5=tmp6_7H
+
+    vpaddd      %8, %8, %6              ; %8=data3_1L
+    vpaddd      %5, %5, %7              ; %5=data3_1H
+
+    vpaddd      %8, %8, [GOTOFF(ebx, PD_DESCALE_P %+ %9)]
+    vpaddd      %5, %5, [GOTOFF(ebx, PD_DESCALE_P %+ %9)]
+    vpsrad      %8, %8, DESCALE_P %+ %9
+    vpsrad      %5, %5, DESCALE_P %+ %9
+
+    vpackssdw   %2, %8, %5              ; %2=data3_1
+%endmacro
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_CONST
+
+    alignz      32
+    GLOBAL_DATA(jconst_fdct_islow_avx2)
+
+EXTN(jconst_fdct_islow_avx2):
+
+PW_F130_F054_MF130_F054    times 4  dw  (F_0_541 + F_0_765),  F_0_541
+                           times 4  dw  (F_0_541 - F_1_847),  F_0_541
+PW_MF078_F117_F078_F117    times 4  dw  (F_1_175 - F_1_961),  F_1_175
+                           times 4  dw  (F_1_175 - F_0_390),  F_1_175
+PW_MF060_MF089_MF050_MF256 times 4  dw  (F_0_298 - F_0_899), -F_0_899
+                           times 4  dw  (F_2_053 - F_2_562), -F_2_562
+PW_F050_MF256_F060_MF089   times 4  dw  (F_3_072 - F_2_562), -F_2_562
+                           times 4  dw  (F_1_501 - F_0_899), -F_0_899
+PD_DESCALE_P1              times 8  dd  1 << (DESCALE_P1 - 1)
+PD_DESCALE_P2              times 8  dd  1 << (DESCALE_P2 - 1)
+PW_DESCALE_P2X             times 16 dw  1 << (PASS1_BITS - 1)
+PW_1_NEG1                  times 8  dw  1
+                           times 8  dw -1
+
+    alignz      32
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_TEXT
+    BITS        32
+;
+; Perform the forward DCT on one block of samples.
+;
+; GLOBAL(void)
+; jsimd_fdct_islow_avx2(DCTELEM *data)
+;
+
+%define data(b)       (b) + 8           ; DCTELEM *data
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_fdct_islow_avx2)
+
+EXTN(jsimd_fdct_islow_avx2):
+    push        ebp
+    mov         ebp, esp
+    pushpic     ebx
+;   push        ecx                     ; unused
+;   push        edx                     ; need not be preserved
+;   push        esi                     ; unused
+;   push        edi                     ; unused
+
+    get_GOT     ebx                     ; get GOT address
+
+    ; ---- Pass 1: process rows.
+
+    mov         edx, POINTER [data(ebp)]  ; (DCTELEM *)
+
+    vmovdqu     ymm4, YMMWORD [YMMBLOCK(0,0,edx,SIZEOF_DCTELEM)]
+    vmovdqu     ymm5, YMMWORD [YMMBLOCK(2,0,edx,SIZEOF_DCTELEM)]
+    vmovdqu     ymm6, YMMWORD [YMMBLOCK(4,0,edx,SIZEOF_DCTELEM)]
+    vmovdqu     ymm7, YMMWORD [YMMBLOCK(6,0,edx,SIZEOF_DCTELEM)]
+    ; ymm4=(00 01 02 03 04 05 06 07  10 11 12 13 14 15 16 17)
+    ; ymm5=(20 21 22 23 24 25 26 27  30 31 32 33 34 35 36 37)
+    ; ymm6=(40 41 42 43 44 45 46 47  50 51 52 53 54 55 56 57)
+    ; ymm7=(60 61 62 63 64 65 66 67  70 71 72 73 74 75 76 77)
+
+    vperm2i128  ymm0, ymm4, ymm6, 0x20
+    vperm2i128  ymm1, ymm4, ymm6, 0x31
+    vperm2i128  ymm2, ymm5, ymm7, 0x20
+    vperm2i128  ymm3, ymm5, ymm7, 0x31
+    ; ymm0=(00 01 02 03 04 05 06 07  40 41 42 43 44 45 46 47)
+    ; ymm1=(10 11 12 13 14 15 16 17  50 51 52 53 54 55 56 57)
+    ; ymm2=(20 21 22 23 24 25 26 27  60 61 62 63 64 65 66 67)
+    ; ymm3=(30 31 32 33 34 35 36 37  70 71 72 73 74 75 76 77)
+
+    dotranspose ymm0, ymm1, ymm2, ymm3, ymm4, ymm5, ymm6, ymm7
+
+    dodct       ymm0, ymm1, ymm2, ymm3, ymm4, ymm5, ymm6, ymm7, 1
+    ; ymm0=data0_4, ymm1=data3_1, ymm2=data2_6, ymm3=data7_5
+
+    ; ---- Pass 2: process columns.
+
+    vperm2i128  ymm4, ymm1, ymm3, 0x20  ; ymm4=data3_7
+    vperm2i128  ymm1, ymm1, ymm3, 0x31  ; ymm1=data1_5
+
+    dotranspose ymm0, ymm1, ymm2, ymm4, ymm3, ymm5, ymm6, ymm7
+
+    dodct       ymm0, ymm1, ymm2, ymm4, ymm3, ymm5, ymm6, ymm7, 2
+    ; ymm0=data0_4, ymm1=data3_1, ymm2=data2_6, ymm4=data7_5
+
+    vperm2i128 ymm3, ymm0, ymm1, 0x30   ; ymm3=data0_1
+    vperm2i128 ymm5, ymm2, ymm1, 0x20   ; ymm5=data2_3
+    vperm2i128 ymm6, ymm0, ymm4, 0x31   ; ymm6=data4_5
+    vperm2i128 ymm7, ymm2, ymm4, 0x21   ; ymm7=data6_7
+
+    vmovdqu     YMMWORD [YMMBLOCK(0,0,edx,SIZEOF_DCTELEM)], ymm3
+    vmovdqu     YMMWORD [YMMBLOCK(2,0,edx,SIZEOF_DCTELEM)], ymm5
+    vmovdqu     YMMWORD [YMMBLOCK(4,0,edx,SIZEOF_DCTELEM)], ymm6
+    vmovdqu     YMMWORD [YMMBLOCK(6,0,edx,SIZEOF_DCTELEM)], ymm7
+
+    vzeroupper
+;   pop         edi                     ; unused
+;   pop         esi                     ; unused
+;   pop         edx                     ; need not be preserved
+;   pop         ecx                     ; unused
+    poppic      ebx
+    pop         ebp
+    ret
+
+; For some reason, the OS X linker does not honor the request to align the
+; segment unless we do this.
+    align       32
diff --git a/3rdparty/libjpeg/src/simd/i386/jfdctint-mmx.asm b/3rdparty/libjpeg/src/simd/i386/jfdctint-mmx.asm
new file mode 100644
index 00000000..34a43b9e
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/i386/jfdctint-mmx.asm
@@ -0,0 +1,620 @@
+;
+; jfdctint.asm - accurate integer FDCT (MMX)
+;
+; Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+; Copyright (C) 2016, 2020, D. R. Commander.
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+;
+; This file should be assembled with NASM (Netwide Assembler),
+; can *not* be assembled with Microsoft's MASM or any compatible
+; assembler (including Borland's Turbo Assembler).
+; NASM is available from http://nasm.sourceforge.net/ or
+; http://sourceforge.net/project/showfiles.php?group_id=6208
+;
+; This file contains a slower but more accurate integer implementation of the
+; forward DCT (Discrete Cosine Transform). The following code is based
+; directly on the IJG's original jfdctint.c; see the jfdctint.c for
+; more details.
+
+%include "jsimdext.inc"
+%include "jdct.inc"
+
+; --------------------------------------------------------------------------
+
+%define CONST_BITS  13
+%define PASS1_BITS  2
+
+%define DESCALE_P1  (CONST_BITS - PASS1_BITS)
+%define DESCALE_P2  (CONST_BITS + PASS1_BITS)
+
+%if CONST_BITS == 13
+F_0_298 equ  2446  ; FIX(0.298631336)
+F_0_390 equ  3196  ; FIX(0.390180644)
+F_0_541 equ  4433  ; FIX(0.541196100)
+F_0_765 equ  6270  ; FIX(0.765366865)
+F_0_899 equ  7373  ; FIX(0.899976223)
+F_1_175 equ  9633  ; FIX(1.175875602)
+F_1_501 equ 12299  ; FIX(1.501321110)
+F_1_847 equ 15137  ; FIX(1.847759065)
+F_1_961 equ 16069  ; FIX(1.961570560)
+F_2_053 equ 16819  ; FIX(2.053119869)
+F_2_562 equ 20995  ; FIX(2.562915447)
+F_3_072 equ 25172  ; FIX(3.072711026)
+%else
+; NASM cannot do compile-time arithmetic on floating-point constants.
+%define DESCALE(x, n)  (((x) + (1 << ((n) - 1))) >> (n))
+F_0_298 equ DESCALE( 320652955, 30 - CONST_BITS)  ; FIX(0.298631336)
+F_0_390 equ DESCALE( 418953276, 30 - CONST_BITS)  ; FIX(0.390180644)
+F_0_541 equ DESCALE( 581104887, 30 - CONST_BITS)  ; FIX(0.541196100)
+F_0_765 equ DESCALE( 821806413, 30 - CONST_BITS)  ; FIX(0.765366865)
+F_0_899 equ DESCALE( 966342111, 30 - CONST_BITS)  ; FIX(0.899976223)
+F_1_175 equ DESCALE(1262586813, 30 - CONST_BITS)  ; FIX(1.175875602)
+F_1_501 equ DESCALE(1612031267, 30 - CONST_BITS)  ; FIX(1.501321110)
+F_1_847 equ DESCALE(1984016188, 30 - CONST_BITS)  ; FIX(1.847759065)
+F_1_961 equ DESCALE(2106220350, 30 - CONST_BITS)  ; FIX(1.961570560)
+F_2_053 equ DESCALE(2204520673, 30 - CONST_BITS)  ; FIX(2.053119869)
+F_2_562 equ DESCALE(2751909506, 30 - CONST_BITS)  ; FIX(2.562915447)
+F_3_072 equ DESCALE(3299298341, 30 - CONST_BITS)  ; FIX(3.072711026)
+%endif
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_CONST
+
+    alignz      32
+    GLOBAL_DATA(jconst_fdct_islow_mmx)
+
+EXTN(jconst_fdct_islow_mmx):
+
+PW_F130_F054   times 2 dw  (F_0_541 + F_0_765),  F_0_541
+PW_F054_MF130  times 2 dw  F_0_541, (F_0_541 - F_1_847)
+PW_MF078_F117  times 2 dw  (F_1_175 - F_1_961),  F_1_175
+PW_F117_F078   times 2 dw  F_1_175, (F_1_175 - F_0_390)
+PW_MF060_MF089 times 2 dw  (F_0_298 - F_0_899), -F_0_899
+PW_MF089_F060  times 2 dw -F_0_899, (F_1_501 - F_0_899)
+PW_MF050_MF256 times 2 dw  (F_2_053 - F_2_562), -F_2_562
+PW_MF256_F050  times 2 dw -F_2_562, (F_3_072 - F_2_562)
+PD_DESCALE_P1  times 2 dd  1 << (DESCALE_P1 - 1)
+PD_DESCALE_P2  times 2 dd  1 << (DESCALE_P2 - 1)
+PW_DESCALE_P2X times 4 dw  1 << (PASS1_BITS - 1)
+
+    alignz      32
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_TEXT
+    BITS        32
+;
+; Perform the forward DCT on one block of samples.
+;
+; GLOBAL(void)
+; jsimd_fdct_islow_mmx(DCTELEM *data)
+;
+
+%define data(b)       (b) + 8           ; DCTELEM *data
+
+%define original_ebp  ebp + 0
+%define wk(i)         ebp - (WK_NUM - (i)) * SIZEOF_MMWORD  ; mmword wk[WK_NUM]
+%define WK_NUM        2
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_fdct_islow_mmx)
+
+EXTN(jsimd_fdct_islow_mmx):
+    push        ebp
+    mov         eax, esp                    ; eax = original ebp
+    sub         esp, byte 4
+    and         esp, byte (-SIZEOF_MMWORD)  ; align to 64 bits
+    mov         [esp], eax
+    mov         ebp, esp                    ; ebp = aligned ebp
+    lea         esp, [wk(0)]
+    pushpic     ebx
+;   push        ecx                     ; need not be preserved
+;   push        edx                     ; need not be preserved
+;   push        esi                     ; unused
+;   push        edi                     ; unused
+
+    get_GOT     ebx                     ; get GOT address
+
+    ; ---- Pass 1: process rows.
+
+    mov         edx, POINTER [data(eax)]  ; (DCTELEM *)
+    mov         ecx, DCTSIZE/4
+    alignx      16, 7
+.rowloop:
+
+    movq        mm0, MMWORD [MMBLOCK(2,0,edx,SIZEOF_DCTELEM)]
+    movq        mm1, MMWORD [MMBLOCK(3,0,edx,SIZEOF_DCTELEM)]
+    movq        mm2, MMWORD [MMBLOCK(2,1,edx,SIZEOF_DCTELEM)]
+    movq        mm3, MMWORD [MMBLOCK(3,1,edx,SIZEOF_DCTELEM)]
+
+    ; mm0=(20 21 22 23), mm2=(24 25 26 27)
+    ; mm1=(30 31 32 33), mm3=(34 35 36 37)
+
+    movq        mm4, mm0                ; transpose coefficients(phase 1)
+    punpcklwd   mm0, mm1                ; mm0=(20 30 21 31)
+    punpckhwd   mm4, mm1                ; mm4=(22 32 23 33)
+    movq        mm5, mm2                ; transpose coefficients(phase 1)
+    punpcklwd   mm2, mm3                ; mm2=(24 34 25 35)
+    punpckhwd   mm5, mm3                ; mm5=(26 36 27 37)
+
+    movq        mm6, MMWORD [MMBLOCK(0,0,edx,SIZEOF_DCTELEM)]
+    movq        mm7, MMWORD [MMBLOCK(1,0,edx,SIZEOF_DCTELEM)]
+    movq        mm1, MMWORD [MMBLOCK(0,1,edx,SIZEOF_DCTELEM)]
+    movq        mm3, MMWORD [MMBLOCK(1,1,edx,SIZEOF_DCTELEM)]
+
+    ; mm6=(00 01 02 03), mm1=(04 05 06 07)
+    ; mm7=(10 11 12 13), mm3=(14 15 16 17)
+
+    movq        MMWORD [wk(0)], mm4     ; wk(0)=(22 32 23 33)
+    movq        MMWORD [wk(1)], mm2     ; wk(1)=(24 34 25 35)
+
+    movq        mm4, mm6                ; transpose coefficients(phase 1)
+    punpcklwd   mm6, mm7                ; mm6=(00 10 01 11)
+    punpckhwd   mm4, mm7                ; mm4=(02 12 03 13)
+    movq        mm2, mm1                ; transpose coefficients(phase 1)
+    punpcklwd   mm1, mm3                ; mm1=(04 14 05 15)
+    punpckhwd   mm2, mm3                ; mm2=(06 16 07 17)
+
+    movq        mm7, mm6                ; transpose coefficients(phase 2)
+    punpckldq   mm6, mm0                ; mm6=(00 10 20 30)=data0
+    punpckhdq   mm7, mm0                ; mm7=(01 11 21 31)=data1
+    movq        mm3, mm2                ; transpose coefficients(phase 2)
+    punpckldq   mm2, mm5                ; mm2=(06 16 26 36)=data6
+    punpckhdq   mm3, mm5                ; mm3=(07 17 27 37)=data7
+
+    movq        mm0, mm7
+    movq        mm5, mm6
+    psubw       mm7, mm2                ; mm7=data1-data6=tmp6
+    psubw       mm6, mm3                ; mm6=data0-data7=tmp7
+    paddw       mm0, mm2                ; mm0=data1+data6=tmp1
+    paddw       mm5, mm3                ; mm5=data0+data7=tmp0
+
+    movq        mm2, MMWORD [wk(0)]     ; mm2=(22 32 23 33)
+    movq        mm3, MMWORD [wk(1)]     ; mm3=(24 34 25 35)
+    movq        MMWORD [wk(0)], mm7     ; wk(0)=tmp6
+    movq        MMWORD [wk(1)], mm6     ; wk(1)=tmp7
+
+    movq        mm7, mm4                ; transpose coefficients(phase 2)
+    punpckldq   mm4, mm2                ; mm4=(02 12 22 32)=data2
+    punpckhdq   mm7, mm2                ; mm7=(03 13 23 33)=data3
+    movq        mm6, mm1                ; transpose coefficients(phase 2)
+    punpckldq   mm1, mm3                ; mm1=(04 14 24 34)=data4
+    punpckhdq   mm6, mm3                ; mm6=(05 15 25 35)=data5
+
+    movq        mm2, mm7
+    movq        mm3, mm4
+    paddw       mm7, mm1                ; mm7=data3+data4=tmp3
+    paddw       mm4, mm6                ; mm4=data2+data5=tmp2
+    psubw       mm2, mm1                ; mm2=data3-data4=tmp4
+    psubw       mm3, mm6                ; mm3=data2-data5=tmp5
+
+    ; -- Even part
+
+    movq        mm1, mm5
+    movq        mm6, mm0
+    paddw       mm5, mm7                ; mm5=tmp10
+    paddw       mm0, mm4                ; mm0=tmp11
+    psubw       mm1, mm7                ; mm1=tmp13
+    psubw       mm6, mm4                ; mm6=tmp12
+
+    movq        mm7, mm5
+    paddw       mm5, mm0                ; mm5=tmp10+tmp11
+    psubw       mm7, mm0                ; mm7=tmp10-tmp11
+
+    psllw       mm5, PASS1_BITS         ; mm5=data0
+    psllw       mm7, PASS1_BITS         ; mm7=data4
+
+    movq        MMWORD [MMBLOCK(0,0,edx,SIZEOF_DCTELEM)], mm5
+    movq        MMWORD [MMBLOCK(0,1,edx,SIZEOF_DCTELEM)], mm7
+
+    ; (Original)
+    ; z1 = (tmp12 + tmp13) * 0.541196100;
+    ; data2 = z1 + tmp13 * 0.765366865;
+    ; data6 = z1 + tmp12 * -1.847759065;
+    ;
+    ; (This implementation)
+    ; data2 = tmp13 * (0.541196100 + 0.765366865) + tmp12 * 0.541196100;
+    ; data6 = tmp13 * 0.541196100 + tmp12 * (0.541196100 - 1.847759065);
+
+    movq        mm4, mm1                ; mm1=tmp13
+    movq        mm0, mm1
+    punpcklwd   mm4, mm6                ; mm6=tmp12
+    punpckhwd   mm0, mm6
+    movq        mm1, mm4
+    movq        mm6, mm0
+    pmaddwd     mm4, [GOTOFF(ebx,PW_F130_F054)]   ; mm4=data2L
+    pmaddwd     mm0, [GOTOFF(ebx,PW_F130_F054)]   ; mm0=data2H
+    pmaddwd     mm1, [GOTOFF(ebx,PW_F054_MF130)]  ; mm1=data6L
+    pmaddwd     mm6, [GOTOFF(ebx,PW_F054_MF130)]  ; mm6=data6H
+
+    paddd       mm4, [GOTOFF(ebx,PD_DESCALE_P1)]
+    paddd       mm0, [GOTOFF(ebx,PD_DESCALE_P1)]
+    psrad       mm4, DESCALE_P1
+    psrad       mm0, DESCALE_P1
+    paddd       mm1, [GOTOFF(ebx,PD_DESCALE_P1)]
+    paddd       mm6, [GOTOFF(ebx,PD_DESCALE_P1)]
+    psrad       mm1, DESCALE_P1
+    psrad       mm6, DESCALE_P1
+
+    packssdw    mm4, mm0                ; mm4=data2
+    packssdw    mm1, mm6                ; mm1=data6
+
+    movq        MMWORD [MMBLOCK(2,0,edx,SIZEOF_DCTELEM)], mm4
+    movq        MMWORD [MMBLOCK(2,1,edx,SIZEOF_DCTELEM)], mm1
+
+    ; -- Odd part
+
+    movq        mm5, MMWORD [wk(0)]     ; mm5=tmp6
+    movq        mm7, MMWORD [wk(1)]     ; mm7=tmp7
+
+    movq        mm0, mm2                ; mm2=tmp4
+    movq        mm6, mm3                ; mm3=tmp5
+    paddw       mm0, mm5                ; mm0=z3
+    paddw       mm6, mm7                ; mm6=z4
+
+    ; (Original)
+    ; z5 = (z3 + z4) * 1.175875602;
+    ; z3 = z3 * -1.961570560;  z4 = z4 * -0.390180644;
+    ; z3 += z5;  z4 += z5;
+    ;
+    ; (This implementation)
+    ; z3 = z3 * (1.175875602 - 1.961570560) + z4 * 1.175875602;
+    ; z4 = z3 * 1.175875602 + z4 * (1.175875602 - 0.390180644);
+
+    movq        mm4, mm0
+    movq        mm1, mm0
+    punpcklwd   mm4, mm6
+    punpckhwd   mm1, mm6
+    movq        mm0, mm4
+    movq        mm6, mm1
+    pmaddwd     mm4, [GOTOFF(ebx,PW_MF078_F117)]  ; mm4=z3L
+    pmaddwd     mm1, [GOTOFF(ebx,PW_MF078_F117)]  ; mm1=z3H
+    pmaddwd     mm0, [GOTOFF(ebx,PW_F117_F078)]   ; mm0=z4L
+    pmaddwd     mm6, [GOTOFF(ebx,PW_F117_F078)]   ; mm6=z4H
+
+    movq        MMWORD [wk(0)], mm4     ; wk(0)=z3L
+    movq        MMWORD [wk(1)], mm1     ; wk(1)=z3H
+
+    ; (Original)
+    ; z1 = tmp4 + tmp7;  z2 = tmp5 + tmp6;
+    ; tmp4 = tmp4 * 0.298631336;  tmp5 = tmp5 * 2.053119869;
+    ; tmp6 = tmp6 * 3.072711026;  tmp7 = tmp7 * 1.501321110;
+    ; z1 = z1 * -0.899976223;  z2 = z2 * -2.562915447;
+    ; data7 = tmp4 + z1 + z3;  data5 = tmp5 + z2 + z4;
+    ; data3 = tmp6 + z2 + z3;  data1 = tmp7 + z1 + z4;
+    ;
+    ; (This implementation)
+    ; tmp4 = tmp4 * (0.298631336 - 0.899976223) + tmp7 * -0.899976223;
+    ; tmp5 = tmp5 * (2.053119869 - 2.562915447) + tmp6 * -2.562915447;
+    ; tmp6 = tmp5 * -2.562915447 + tmp6 * (3.072711026 - 2.562915447);
+    ; tmp7 = tmp4 * -0.899976223 + tmp7 * (1.501321110 - 0.899976223);
+    ; data7 = tmp4 + z3;  data5 = tmp5 + z4;
+    ; data3 = tmp6 + z3;  data1 = tmp7 + z4;
+
+    movq        mm4, mm2
+    movq        mm1, mm2
+    punpcklwd   mm4, mm7
+    punpckhwd   mm1, mm7
+    movq        mm2, mm4
+    movq        mm7, mm1
+    pmaddwd     mm4, [GOTOFF(ebx,PW_MF060_MF089)]  ; mm4=tmp4L
+    pmaddwd     mm1, [GOTOFF(ebx,PW_MF060_MF089)]  ; mm1=tmp4H
+    pmaddwd     mm2, [GOTOFF(ebx,PW_MF089_F060)]   ; mm2=tmp7L
+    pmaddwd     mm7, [GOTOFF(ebx,PW_MF089_F060)]   ; mm7=tmp7H
+
+    paddd       mm4, MMWORD [wk(0)]     ; mm4=data7L
+    paddd       mm1, MMWORD [wk(1)]     ; mm1=data7H
+    paddd       mm2, mm0                ; mm2=data1L
+    paddd       mm7, mm6                ; mm7=data1H
+
+    paddd       mm4, [GOTOFF(ebx,PD_DESCALE_P1)]
+    paddd       mm1, [GOTOFF(ebx,PD_DESCALE_P1)]
+    psrad       mm4, DESCALE_P1
+    psrad       mm1, DESCALE_P1
+    paddd       mm2, [GOTOFF(ebx,PD_DESCALE_P1)]
+    paddd       mm7, [GOTOFF(ebx,PD_DESCALE_P1)]
+    psrad       mm2, DESCALE_P1
+    psrad       mm7, DESCALE_P1
+
+    packssdw    mm4, mm1                ; mm4=data7
+    packssdw    mm2, mm7                ; mm2=data1
+
+    movq        MMWORD [MMBLOCK(3,1,edx,SIZEOF_DCTELEM)], mm4
+    movq        MMWORD [MMBLOCK(1,0,edx,SIZEOF_DCTELEM)], mm2
+
+    movq        mm1, mm3
+    movq        mm7, mm3
+    punpcklwd   mm1, mm5
+    punpckhwd   mm7, mm5
+    movq        mm3, mm1
+    movq        mm5, mm7
+    pmaddwd     mm1, [GOTOFF(ebx,PW_MF050_MF256)]  ; mm1=tmp5L
+    pmaddwd     mm7, [GOTOFF(ebx,PW_MF050_MF256)]  ; mm7=tmp5H
+    pmaddwd     mm3, [GOTOFF(ebx,PW_MF256_F050)]   ; mm3=tmp6L
+    pmaddwd     mm5, [GOTOFF(ebx,PW_MF256_F050)]   ; mm5=tmp6H
+
+    paddd       mm1, mm0                ; mm1=data5L
+    paddd       mm7, mm6                ; mm7=data5H
+    paddd       mm3, MMWORD [wk(0)]     ; mm3=data3L
+    paddd       mm5, MMWORD [wk(1)]     ; mm5=data3H
+
+    paddd       mm1, [GOTOFF(ebx,PD_DESCALE_P1)]
+    paddd       mm7, [GOTOFF(ebx,PD_DESCALE_P1)]
+    psrad       mm1, DESCALE_P1
+    psrad       mm7, DESCALE_P1
+    paddd       mm3, [GOTOFF(ebx,PD_DESCALE_P1)]
+    paddd       mm5, [GOTOFF(ebx,PD_DESCALE_P1)]
+    psrad       mm3, DESCALE_P1
+    psrad       mm5, DESCALE_P1
+
+    packssdw    mm1, mm7                ; mm1=data5
+    packssdw    mm3, mm5                ; mm3=data3
+
+    movq        MMWORD [MMBLOCK(1,1,edx,SIZEOF_DCTELEM)], mm1
+    movq        MMWORD [MMBLOCK(3,0,edx,SIZEOF_DCTELEM)], mm3
+
+    add         edx, byte 4*DCTSIZE*SIZEOF_DCTELEM
+    dec         ecx
+    jnz         near .rowloop
+
+    ; ---- Pass 2: process columns.
+
+    mov         edx, POINTER [data(eax)]  ; (DCTELEM *)
+    mov         ecx, DCTSIZE/4
+    alignx      16, 7
+.columnloop:
+
+    movq        mm0, MMWORD [MMBLOCK(2,0,edx,SIZEOF_DCTELEM)]
+    movq        mm1, MMWORD [MMBLOCK(3,0,edx,SIZEOF_DCTELEM)]
+    movq        mm2, MMWORD [MMBLOCK(6,0,edx,SIZEOF_DCTELEM)]
+    movq        mm3, MMWORD [MMBLOCK(7,0,edx,SIZEOF_DCTELEM)]
+
+    ; mm0=(02 12 22 32), mm2=(42 52 62 72)
+    ; mm1=(03 13 23 33), mm3=(43 53 63 73)
+
+    movq        mm4, mm0                ; transpose coefficients(phase 1)
+    punpcklwd   mm0, mm1                ; mm0=(02 03 12 13)
+    punpckhwd   mm4, mm1                ; mm4=(22 23 32 33)
+    movq        mm5, mm2                ; transpose coefficients(phase 1)
+    punpcklwd   mm2, mm3                ; mm2=(42 43 52 53)
+    punpckhwd   mm5, mm3                ; mm5=(62 63 72 73)
+
+    movq        mm6, MMWORD [MMBLOCK(0,0,edx,SIZEOF_DCTELEM)]
+    movq        mm7, MMWORD [MMBLOCK(1,0,edx,SIZEOF_DCTELEM)]
+    movq        mm1, MMWORD [MMBLOCK(4,0,edx,SIZEOF_DCTELEM)]
+    movq        mm3, MMWORD [MMBLOCK(5,0,edx,SIZEOF_DCTELEM)]
+
+    ; mm6=(00 10 20 30), mm1=(40 50 60 70)
+    ; mm7=(01 11 21 31), mm3=(41 51 61 71)
+
+    movq        MMWORD [wk(0)], mm4     ; wk(0)=(22 23 32 33)
+    movq        MMWORD [wk(1)], mm2     ; wk(1)=(42 43 52 53)
+
+    movq        mm4, mm6                ; transpose coefficients(phase 1)
+    punpcklwd   mm6, mm7                ; mm6=(00 01 10 11)
+    punpckhwd   mm4, mm7                ; mm4=(20 21 30 31)
+    movq        mm2, mm1                ; transpose coefficients(phase 1)
+    punpcklwd   mm1, mm3                ; mm1=(40 41 50 51)
+    punpckhwd   mm2, mm3                ; mm2=(60 61 70 71)
+
+    movq        mm7, mm6                ; transpose coefficients(phase 2)
+    punpckldq   mm6, mm0                ; mm6=(00 01 02 03)=data0
+    punpckhdq   mm7, mm0                ; mm7=(10 11 12 13)=data1
+    movq        mm3, mm2                ; transpose coefficients(phase 2)
+    punpckldq   mm2, mm5                ; mm2=(60 61 62 63)=data6
+    punpckhdq   mm3, mm5                ; mm3=(70 71 72 73)=data7
+
+    movq        mm0, mm7
+    movq        mm5, mm6
+    psubw       mm7, mm2                ; mm7=data1-data6=tmp6
+    psubw       mm6, mm3                ; mm6=data0-data7=tmp7
+    paddw       mm0, mm2                ; mm0=data1+data6=tmp1
+    paddw       mm5, mm3                ; mm5=data0+data7=tmp0
+
+    movq        mm2, MMWORD [wk(0)]     ; mm2=(22 23 32 33)
+    movq        mm3, MMWORD [wk(1)]     ; mm3=(42 43 52 53)
+    movq        MMWORD [wk(0)], mm7     ; wk(0)=tmp6
+    movq        MMWORD [wk(1)], mm6     ; wk(1)=tmp7
+
+    movq        mm7, mm4                ; transpose coefficients(phase 2)
+    punpckldq   mm4, mm2                ; mm4=(20 21 22 23)=data2
+    punpckhdq   mm7, mm2                ; mm7=(30 31 32 33)=data3
+    movq        mm6, mm1                ; transpose coefficients(phase 2)
+    punpckldq   mm1, mm3                ; mm1=(40 41 42 43)=data4
+    punpckhdq   mm6, mm3                ; mm6=(50 51 52 53)=data5
+
+    movq        mm2, mm7
+    movq        mm3, mm4
+    paddw       mm7, mm1                ; mm7=data3+data4=tmp3
+    paddw       mm4, mm6                ; mm4=data2+data5=tmp2
+    psubw       mm2, mm1                ; mm2=data3-data4=tmp4
+    psubw       mm3, mm6                ; mm3=data2-data5=tmp5
+
+    ; -- Even part
+
+    movq        mm1, mm5
+    movq        mm6, mm0
+    paddw       mm5, mm7                ; mm5=tmp10
+    paddw       mm0, mm4                ; mm0=tmp11
+    psubw       mm1, mm7                ; mm1=tmp13
+    psubw       mm6, mm4                ; mm6=tmp12
+
+    movq        mm7, mm5
+    paddw       mm5, mm0                ; mm5=tmp10+tmp11
+    psubw       mm7, mm0                ; mm7=tmp10-tmp11
+
+    paddw       mm5, [GOTOFF(ebx,PW_DESCALE_P2X)]
+    paddw       mm7, [GOTOFF(ebx,PW_DESCALE_P2X)]
+    psraw       mm5, PASS1_BITS         ; mm5=data0
+    psraw       mm7, PASS1_BITS         ; mm7=data4
+
+    movq        MMWORD [MMBLOCK(0,0,edx,SIZEOF_DCTELEM)], mm5
+    movq        MMWORD [MMBLOCK(4,0,edx,SIZEOF_DCTELEM)], mm7
+
+    ; (Original)
+    ; z1 = (tmp12 + tmp13) * 0.541196100;
+    ; data2 = z1 + tmp13 * 0.765366865;
+    ; data6 = z1 + tmp12 * -1.847759065;
+    ;
+    ; (This implementation)
+    ; data2 = tmp13 * (0.541196100 + 0.765366865) + tmp12 * 0.541196100;
+    ; data6 = tmp13 * 0.541196100 + tmp12 * (0.541196100 - 1.847759065);
+
+    movq        mm4, mm1                ; mm1=tmp13
+    movq        mm0, mm1
+    punpcklwd   mm4, mm6                ; mm6=tmp12
+    punpckhwd   mm0, mm6
+    movq        mm1, mm4
+    movq        mm6, mm0
+    pmaddwd     mm4, [GOTOFF(ebx,PW_F130_F054)]   ; mm4=data2L
+    pmaddwd     mm0, [GOTOFF(ebx,PW_F130_F054)]   ; mm0=data2H
+    pmaddwd     mm1, [GOTOFF(ebx,PW_F054_MF130)]  ; mm1=data6L
+    pmaddwd     mm6, [GOTOFF(ebx,PW_F054_MF130)]  ; mm6=data6H
+
+    paddd       mm4, [GOTOFF(ebx,PD_DESCALE_P2)]
+    paddd       mm0, [GOTOFF(ebx,PD_DESCALE_P2)]
+    psrad       mm4, DESCALE_P2
+    psrad       mm0, DESCALE_P2
+    paddd       mm1, [GOTOFF(ebx,PD_DESCALE_P2)]
+    paddd       mm6, [GOTOFF(ebx,PD_DESCALE_P2)]
+    psrad       mm1, DESCALE_P2
+    psrad       mm6, DESCALE_P2
+
+    packssdw    mm4, mm0                ; mm4=data2
+    packssdw    mm1, mm6                ; mm1=data6
+
+    movq        MMWORD [MMBLOCK(2,0,edx,SIZEOF_DCTELEM)], mm4
+    movq        MMWORD [MMBLOCK(6,0,edx,SIZEOF_DCTELEM)], mm1
+
+    ; -- Odd part
+
+    movq        mm5, MMWORD [wk(0)]     ; mm5=tmp6
+    movq        mm7, MMWORD [wk(1)]     ; mm7=tmp7
+
+    movq        mm0, mm2                ; mm2=tmp4
+    movq        mm6, mm3                ; mm3=tmp5
+    paddw       mm0, mm5                ; mm0=z3
+    paddw       mm6, mm7                ; mm6=z4
+
+    ; (Original)
+    ; z5 = (z3 + z4) * 1.175875602;
+    ; z3 = z3 * -1.961570560;  z4 = z4 * -0.390180644;
+    ; z3 += z5;  z4 += z5;
+    ;
+    ; (This implementation)
+    ; z3 = z3 * (1.175875602 - 1.961570560) + z4 * 1.175875602;
+    ; z4 = z3 * 1.175875602 + z4 * (1.175875602 - 0.390180644);
+
+    movq        mm4, mm0
+    movq        mm1, mm0
+    punpcklwd   mm4, mm6
+    punpckhwd   mm1, mm6
+    movq        mm0, mm4
+    movq        mm6, mm1
+    pmaddwd     mm4, [GOTOFF(ebx,PW_MF078_F117)]  ; mm4=z3L
+    pmaddwd     mm1, [GOTOFF(ebx,PW_MF078_F117)]  ; mm1=z3H
+    pmaddwd     mm0, [GOTOFF(ebx,PW_F117_F078)]   ; mm0=z4L
+    pmaddwd     mm6, [GOTOFF(ebx,PW_F117_F078)]   ; mm6=z4H
+
+    movq        MMWORD [wk(0)], mm4     ; wk(0)=z3L
+    movq        MMWORD [wk(1)], mm1     ; wk(1)=z3H
+
+    ; (Original)
+    ; z1 = tmp4 + tmp7;  z2 = tmp5 + tmp6;
+    ; tmp4 = tmp4 * 0.298631336;  tmp5 = tmp5 * 2.053119869;
+    ; tmp6 = tmp6 * 3.072711026;  tmp7 = tmp7 * 1.501321110;
+    ; z1 = z1 * -0.899976223;  z2 = z2 * -2.562915447;
+    ; data7 = tmp4 + z1 + z3;  data5 = tmp5 + z2 + z4;
+    ; data3 = tmp6 + z2 + z3;  data1 = tmp7 + z1 + z4;
+    ;
+    ; (This implementation)
+    ; tmp4 = tmp4 * (0.298631336 - 0.899976223) + tmp7 * -0.899976223;
+    ; tmp5 = tmp5 * (2.053119869 - 2.562915447) + tmp6 * -2.562915447;
+    ; tmp6 = tmp5 * -2.562915447 + tmp6 * (3.072711026 - 2.562915447);
+    ; tmp7 = tmp4 * -0.899976223 + tmp7 * (1.501321110 - 0.899976223);
+    ; data7 = tmp4 + z3;  data5 = tmp5 + z4;
+    ; data3 = tmp6 + z3;  data1 = tmp7 + z4;
+
+    movq        mm4, mm2
+    movq        mm1, mm2
+    punpcklwd   mm4, mm7
+    punpckhwd   mm1, mm7
+    movq        mm2, mm4
+    movq        mm7, mm1
+    pmaddwd     mm4, [GOTOFF(ebx,PW_MF060_MF089)]  ; mm4=tmp4L
+    pmaddwd     mm1, [GOTOFF(ebx,PW_MF060_MF089)]  ; mm1=tmp4H
+    pmaddwd     mm2, [GOTOFF(ebx,PW_MF089_F060)]   ; mm2=tmp7L
+    pmaddwd     mm7, [GOTOFF(ebx,PW_MF089_F060)]   ; mm7=tmp7H
+
+    paddd       mm4, MMWORD [wk(0)]     ; mm4=data7L
+    paddd       mm1, MMWORD [wk(1)]     ; mm1=data7H
+    paddd       mm2, mm0                ; mm2=data1L
+    paddd       mm7, mm6                ; mm7=data1H
+
+    paddd       mm4, [GOTOFF(ebx,PD_DESCALE_P2)]
+    paddd       mm1, [GOTOFF(ebx,PD_DESCALE_P2)]
+    psrad       mm4, DESCALE_P2
+    psrad       mm1, DESCALE_P2
+    paddd       mm2, [GOTOFF(ebx,PD_DESCALE_P2)]
+    paddd       mm7, [GOTOFF(ebx,PD_DESCALE_P2)]
+    psrad       mm2, DESCALE_P2
+    psrad       mm7, DESCALE_P2
+
+    packssdw    mm4, mm1                ; mm4=data7
+    packssdw    mm2, mm7                ; mm2=data1
+
+    movq        MMWORD [MMBLOCK(7,0,edx,SIZEOF_DCTELEM)], mm4
+    movq        MMWORD [MMBLOCK(1,0,edx,SIZEOF_DCTELEM)], mm2
+
+    movq        mm1, mm3
+    movq        mm7, mm3
+    punpcklwd   mm1, mm5
+    punpckhwd   mm7, mm5
+    movq        mm3, mm1
+    movq        mm5, mm7
+    pmaddwd     mm1, [GOTOFF(ebx,PW_MF050_MF256)]  ; mm1=tmp5L
+    pmaddwd     mm7, [GOTOFF(ebx,PW_MF050_MF256)]  ; mm7=tmp5H
+    pmaddwd     mm3, [GOTOFF(ebx,PW_MF256_F050)]   ; mm3=tmp6L
+    pmaddwd     mm5, [GOTOFF(ebx,PW_MF256_F050)]   ; mm5=tmp6H
+
+    paddd       mm1, mm0                ; mm1=data5L
+    paddd       mm7, mm6                ; mm7=data5H
+    paddd       mm3, MMWORD [wk(0)]     ; mm3=data3L
+    paddd       mm5, MMWORD [wk(1)]     ; mm5=data3H
+
+    paddd       mm1, [GOTOFF(ebx,PD_DESCALE_P2)]
+    paddd       mm7, [GOTOFF(ebx,PD_DESCALE_P2)]
+    psrad       mm1, DESCALE_P2
+    psrad       mm7, DESCALE_P2
+    paddd       mm3, [GOTOFF(ebx,PD_DESCALE_P2)]
+    paddd       mm5, [GOTOFF(ebx,PD_DESCALE_P2)]
+    psrad       mm3, DESCALE_P2
+    psrad       mm5, DESCALE_P2
+
+    packssdw    mm1, mm7                ; mm1=data5
+    packssdw    mm3, mm5                ; mm3=data3
+
+    movq        MMWORD [MMBLOCK(5,0,edx,SIZEOF_DCTELEM)], mm1
+    movq        MMWORD [MMBLOCK(3,0,edx,SIZEOF_DCTELEM)], mm3
+
+    add         edx, byte 4*SIZEOF_DCTELEM
+    dec         ecx
+    jnz         near .columnloop
+
+    emms                                ; empty MMX state
+
+;   pop         edi                     ; unused
+;   pop         esi                     ; unused
+;   pop         edx                     ; need not be preserved
+;   pop         ecx                     ; need not be preserved
+    poppic      ebx
+    mov         esp, ebp                ; esp <- aligned ebp
+    pop         esp                     ; esp <- original ebp
+    pop         ebp
+    ret
+
+; For some reason, the OS X linker does not honor the request to align the
+; segment unless we do this.
+    align       32
diff --git a/3rdparty/libjpeg/src/simd/i386/jfdctint-sse2.asm b/3rdparty/libjpeg/src/simd/i386/jfdctint-sse2.asm
new file mode 100644
index 00000000..6f8e18cb
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/i386/jfdctint-sse2.asm
@@ -0,0 +1,633 @@
+;
+; jfdctint.asm - accurate integer FDCT (SSE2)
+;
+; Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+; Copyright (C) 2016, 2020, D. R. Commander.
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+;
+; This file should be assembled with NASM (Netwide Assembler),
+; can *not* be assembled with Microsoft's MASM or any compatible
+; assembler (including Borland's Turbo Assembler).
+; NASM is available from http://nasm.sourceforge.net/ or
+; http://sourceforge.net/project/showfiles.php?group_id=6208
+;
+; This file contains a slower but more accurate integer implementation of the
+; forward DCT (Discrete Cosine Transform). The following code is based
+; directly on the IJG's original jfdctint.c; see the jfdctint.c for
+; more details.
+
+%include "jsimdext.inc"
+%include "jdct.inc"
+
+; --------------------------------------------------------------------------
+
+%define CONST_BITS  13
+%define PASS1_BITS  2
+
+%define DESCALE_P1  (CONST_BITS - PASS1_BITS)
+%define DESCALE_P2  (CONST_BITS + PASS1_BITS)
+
+%if CONST_BITS == 13
+F_0_298 equ  2446  ; FIX(0.298631336)
+F_0_390 equ  3196  ; FIX(0.390180644)
+F_0_541 equ  4433  ; FIX(0.541196100)
+F_0_765 equ  6270  ; FIX(0.765366865)
+F_0_899 equ  7373  ; FIX(0.899976223)
+F_1_175 equ  9633  ; FIX(1.175875602)
+F_1_501 equ 12299  ; FIX(1.501321110)
+F_1_847 equ 15137  ; FIX(1.847759065)
+F_1_961 equ 16069  ; FIX(1.961570560)
+F_2_053 equ 16819  ; FIX(2.053119869)
+F_2_562 equ 20995  ; FIX(2.562915447)
+F_3_072 equ 25172  ; FIX(3.072711026)
+%else
+; NASM cannot do compile-time arithmetic on floating-point constants.
+%define DESCALE(x, n)  (((x) + (1 << ((n) - 1))) >> (n))
+F_0_298 equ DESCALE( 320652955, 30 - CONST_BITS)  ; FIX(0.298631336)
+F_0_390 equ DESCALE( 418953276, 30 - CONST_BITS)  ; FIX(0.390180644)
+F_0_541 equ DESCALE( 581104887, 30 - CONST_BITS)  ; FIX(0.541196100)
+F_0_765 equ DESCALE( 821806413, 30 - CONST_BITS)  ; FIX(0.765366865)
+F_0_899 equ DESCALE( 966342111, 30 - CONST_BITS)  ; FIX(0.899976223)
+F_1_175 equ DESCALE(1262586813, 30 - CONST_BITS)  ; FIX(1.175875602)
+F_1_501 equ DESCALE(1612031267, 30 - CONST_BITS)  ; FIX(1.501321110)
+F_1_847 equ DESCALE(1984016188, 30 - CONST_BITS)  ; FIX(1.847759065)
+F_1_961 equ DESCALE(2106220350, 30 - CONST_BITS)  ; FIX(1.961570560)
+F_2_053 equ DESCALE(2204520673, 30 - CONST_BITS)  ; FIX(2.053119869)
+F_2_562 equ DESCALE(2751909506, 30 - CONST_BITS)  ; FIX(2.562915447)
+F_3_072 equ DESCALE(3299298341, 30 - CONST_BITS)  ; FIX(3.072711026)
+%endif
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_CONST
+
+    alignz      32
+    GLOBAL_DATA(jconst_fdct_islow_sse2)
+
+EXTN(jconst_fdct_islow_sse2):
+
+PW_F130_F054   times 4 dw  (F_0_541 + F_0_765),  F_0_541
+PW_F054_MF130  times 4 dw  F_0_541, (F_0_541 - F_1_847)
+PW_MF078_F117  times 4 dw  (F_1_175 - F_1_961),  F_1_175
+PW_F117_F078   times 4 dw  F_1_175, (F_1_175 - F_0_390)
+PW_MF060_MF089 times 4 dw  (F_0_298 - F_0_899), -F_0_899
+PW_MF089_F060  times 4 dw -F_0_899, (F_1_501 - F_0_899)
+PW_MF050_MF256 times 4 dw  (F_2_053 - F_2_562), -F_2_562
+PW_MF256_F050  times 4 dw -F_2_562, (F_3_072 - F_2_562)
+PD_DESCALE_P1  times 4 dd  1 << (DESCALE_P1 - 1)
+PD_DESCALE_P2  times 4 dd  1 << (DESCALE_P2 - 1)
+PW_DESCALE_P2X times 8 dw  1 << (PASS1_BITS - 1)
+
+    alignz      32
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_TEXT
+    BITS        32
+;
+; Perform the forward DCT on one block of samples.
+;
+; GLOBAL(void)
+; jsimd_fdct_islow_sse2(DCTELEM *data)
+;
+
+%define data(b)       (b) + 8           ; DCTELEM *data
+
+%define original_ebp  ebp + 0
+%define wk(i)         ebp - (WK_NUM - (i)) * SIZEOF_XMMWORD
+                                        ; xmmword wk[WK_NUM]
+%define WK_NUM        6
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_fdct_islow_sse2)
+
+EXTN(jsimd_fdct_islow_sse2):
+    push        ebp
+    mov         eax, esp                     ; eax = original ebp
+    sub         esp, byte 4
+    and         esp, byte (-SIZEOF_XMMWORD)  ; align to 128 bits
+    mov         [esp], eax
+    mov         ebp, esp                     ; ebp = aligned ebp
+    lea         esp, [wk(0)]
+    pushpic     ebx
+;   push        ecx                     ; unused
+;   push        edx                     ; need not be preserved
+;   push        esi                     ; unused
+;   push        edi                     ; unused
+
+    get_GOT     ebx                     ; get GOT address
+
+    ; ---- Pass 1: process rows.
+
+    mov         edx, POINTER [data(eax)]  ; (DCTELEM *)
+
+    movdqa      xmm0, XMMWORD [XMMBLOCK(0,0,edx,SIZEOF_DCTELEM)]
+    movdqa      xmm1, XMMWORD [XMMBLOCK(1,0,edx,SIZEOF_DCTELEM)]
+    movdqa      xmm2, XMMWORD [XMMBLOCK(2,0,edx,SIZEOF_DCTELEM)]
+    movdqa      xmm3, XMMWORD [XMMBLOCK(3,0,edx,SIZEOF_DCTELEM)]
+
+    ; xmm0=(00 01 02 03 04 05 06 07), xmm2=(20 21 22 23 24 25 26 27)
+    ; xmm1=(10 11 12 13 14 15 16 17), xmm3=(30 31 32 33 34 35 36 37)
+
+    movdqa      xmm4, xmm0              ; transpose coefficients(phase 1)
+    punpcklwd   xmm0, xmm1              ; xmm0=(00 10 01 11 02 12 03 13)
+    punpckhwd   xmm4, xmm1              ; xmm4=(04 14 05 15 06 16 07 17)
+    movdqa      xmm5, xmm2              ; transpose coefficients(phase 1)
+    punpcklwd   xmm2, xmm3              ; xmm2=(20 30 21 31 22 32 23 33)
+    punpckhwd   xmm5, xmm3              ; xmm5=(24 34 25 35 26 36 27 37)
+
+    movdqa      xmm6, XMMWORD [XMMBLOCK(4,0,edx,SIZEOF_DCTELEM)]
+    movdqa      xmm7, XMMWORD [XMMBLOCK(5,0,edx,SIZEOF_DCTELEM)]
+    movdqa      xmm1, XMMWORD [XMMBLOCK(6,0,edx,SIZEOF_DCTELEM)]
+    movdqa      xmm3, XMMWORD [XMMBLOCK(7,0,edx,SIZEOF_DCTELEM)]
+
+    ; xmm6=( 4 12 20 28 36 44 52 60), xmm1=( 6 14 22 30 38 46 54 62)
+    ; xmm7=( 5 13 21 29 37 45 53 61), xmm3=( 7 15 23 31 39 47 55 63)
+
+    movdqa      XMMWORD [wk(0)], xmm2   ; wk(0)=(20 30 21 31 22 32 23 33)
+    movdqa      XMMWORD [wk(1)], xmm5   ; wk(1)=(24 34 25 35 26 36 27 37)
+
+    movdqa      xmm2, xmm6              ; transpose coefficients(phase 1)
+    punpcklwd   xmm6, xmm7              ; xmm6=(40 50 41 51 42 52 43 53)
+    punpckhwd   xmm2, xmm7              ; xmm2=(44 54 45 55 46 56 47 57)
+    movdqa      xmm5, xmm1              ; transpose coefficients(phase 1)
+    punpcklwd   xmm1, xmm3              ; xmm1=(60 70 61 71 62 72 63 73)
+    punpckhwd   xmm5, xmm3              ; xmm5=(64 74 65 75 66 76 67 77)
+
+    movdqa      xmm7, xmm6              ; transpose coefficients(phase 2)
+    punpckldq   xmm6, xmm1              ; xmm6=(40 50 60 70 41 51 61 71)
+    punpckhdq   xmm7, xmm1              ; xmm7=(42 52 62 72 43 53 63 73)
+    movdqa      xmm3, xmm2              ; transpose coefficients(phase 2)
+    punpckldq   xmm2, xmm5              ; xmm2=(44 54 64 74 45 55 65 75)
+    punpckhdq   xmm3, xmm5              ; xmm3=(46 56 66 76 47 57 67 77)
+
+    movdqa      xmm1, XMMWORD [wk(0)]   ; xmm1=(20 30 21 31 22 32 23 33)
+    movdqa      xmm5, XMMWORD [wk(1)]   ; xmm5=(24 34 25 35 26 36 27 37)
+    movdqa      XMMWORD [wk(2)], xmm7   ; wk(2)=(42 52 62 72 43 53 63 73)
+    movdqa      XMMWORD [wk(3)], xmm2   ; wk(3)=(44 54 64 74 45 55 65 75)
+
+    movdqa      xmm7, xmm0              ; transpose coefficients(phase 2)
+    punpckldq   xmm0, xmm1              ; xmm0=(00 10 20 30 01 11 21 31)
+    punpckhdq   xmm7, xmm1              ; xmm7=(02 12 22 32 03 13 23 33)
+    movdqa      xmm2, xmm4              ; transpose coefficients(phase 2)
+    punpckldq   xmm4, xmm5              ; xmm4=(04 14 24 34 05 15 25 35)
+    punpckhdq   xmm2, xmm5              ; xmm2=(06 16 26 36 07 17 27 37)
+
+    movdqa      xmm1, xmm0              ; transpose coefficients(phase 3)
+    punpcklqdq  xmm0, xmm6              ; xmm0=(00 10 20 30 40 50 60 70)=data0
+    punpckhqdq  xmm1, xmm6              ; xmm1=(01 11 21 31 41 51 61 71)=data1
+    movdqa      xmm5, xmm2              ; transpose coefficients(phase 3)
+    punpcklqdq  xmm2, xmm3              ; xmm2=(06 16 26 36 46 56 66 76)=data6
+    punpckhqdq  xmm5, xmm3              ; xmm5=(07 17 27 37 47 57 67 77)=data7
+
+    movdqa      xmm6, xmm1
+    movdqa      xmm3, xmm0
+    psubw       xmm1, xmm2              ; xmm1=data1-data6=tmp6
+    psubw       xmm0, xmm5              ; xmm0=data0-data7=tmp7
+    paddw       xmm6, xmm2              ; xmm6=data1+data6=tmp1
+    paddw       xmm3, xmm5              ; xmm3=data0+data7=tmp0
+
+    movdqa      xmm2, XMMWORD [wk(2)]   ; xmm2=(42 52 62 72 43 53 63 73)
+    movdqa      xmm5, XMMWORD [wk(3)]   ; xmm5=(44 54 64 74 45 55 65 75)
+    movdqa      XMMWORD [wk(0)], xmm1   ; wk(0)=tmp6
+    movdqa      XMMWORD [wk(1)], xmm0   ; wk(1)=tmp7
+
+    movdqa      xmm1, xmm7              ; transpose coefficients(phase 3)
+    punpcklqdq  xmm7, xmm2              ; xmm7=(02 12 22 32 42 52 62 72)=data2
+    punpckhqdq  xmm1, xmm2              ; xmm1=(03 13 23 33 43 53 63 73)=data3
+    movdqa      xmm0, xmm4              ; transpose coefficients(phase 3)
+    punpcklqdq  xmm4, xmm5              ; xmm4=(04 14 24 34 44 54 64 74)=data4
+    punpckhqdq  xmm0, xmm5              ; xmm0=(05 15 25 35 45 55 65 75)=data5
+
+    movdqa      xmm2, xmm1
+    movdqa      xmm5, xmm7
+    paddw       xmm1, xmm4              ; xmm1=data3+data4=tmp3
+    paddw       xmm7, xmm0              ; xmm7=data2+data5=tmp2
+    psubw       xmm2, xmm4              ; xmm2=data3-data4=tmp4
+    psubw       xmm5, xmm0              ; xmm5=data2-data5=tmp5
+
+    ; -- Even part
+
+    movdqa      xmm4, xmm3
+    movdqa      xmm0, xmm6
+    paddw       xmm3, xmm1              ; xmm3=tmp10
+    paddw       xmm6, xmm7              ; xmm6=tmp11
+    psubw       xmm4, xmm1              ; xmm4=tmp13
+    psubw       xmm0, xmm7              ; xmm0=tmp12
+
+    movdqa      xmm1, xmm3
+    paddw       xmm3, xmm6              ; xmm3=tmp10+tmp11
+    psubw       xmm1, xmm6              ; xmm1=tmp10-tmp11
+
+    psllw       xmm3, PASS1_BITS        ; xmm3=data0
+    psllw       xmm1, PASS1_BITS        ; xmm1=data4
+
+    movdqa      XMMWORD [wk(2)], xmm3   ; wk(2)=data0
+    movdqa      XMMWORD [wk(3)], xmm1   ; wk(3)=data4
+
+    ; (Original)
+    ; z1 = (tmp12 + tmp13) * 0.541196100;
+    ; data2 = z1 + tmp13 * 0.765366865;
+    ; data6 = z1 + tmp12 * -1.847759065;
+    ;
+    ; (This implementation)
+    ; data2 = tmp13 * (0.541196100 + 0.765366865) + tmp12 * 0.541196100;
+    ; data6 = tmp13 * 0.541196100 + tmp12 * (0.541196100 - 1.847759065);
+
+    movdqa      xmm7, xmm4              ; xmm4=tmp13
+    movdqa      xmm6, xmm4
+    punpcklwd   xmm7, xmm0              ; xmm0=tmp12
+    punpckhwd   xmm6, xmm0
+    movdqa      xmm4, xmm7
+    movdqa      xmm0, xmm6
+    pmaddwd     xmm7, [GOTOFF(ebx,PW_F130_F054)]   ; xmm7=data2L
+    pmaddwd     xmm6, [GOTOFF(ebx,PW_F130_F054)]   ; xmm6=data2H
+    pmaddwd     xmm4, [GOTOFF(ebx,PW_F054_MF130)]  ; xmm4=data6L
+    pmaddwd     xmm0, [GOTOFF(ebx,PW_F054_MF130)]  ; xmm0=data6H
+
+    paddd       xmm7, [GOTOFF(ebx,PD_DESCALE_P1)]
+    paddd       xmm6, [GOTOFF(ebx,PD_DESCALE_P1)]
+    psrad       xmm7, DESCALE_P1
+    psrad       xmm6, DESCALE_P1
+    paddd       xmm4, [GOTOFF(ebx,PD_DESCALE_P1)]
+    paddd       xmm0, [GOTOFF(ebx,PD_DESCALE_P1)]
+    psrad       xmm4, DESCALE_P1
+    psrad       xmm0, DESCALE_P1
+
+    packssdw    xmm7, xmm6              ; xmm7=data2
+    packssdw    xmm4, xmm0              ; xmm4=data6
+
+    movdqa      XMMWORD [wk(4)], xmm7   ; wk(4)=data2
+    movdqa      XMMWORD [wk(5)], xmm4   ; wk(5)=data6
+
+    ; -- Odd part
+
+    movdqa      xmm3, XMMWORD [wk(0)]   ; xmm3=tmp6
+    movdqa      xmm1, XMMWORD [wk(1)]   ; xmm1=tmp7
+
+    movdqa      xmm6, xmm2              ; xmm2=tmp4
+    movdqa      xmm0, xmm5              ; xmm5=tmp5
+    paddw       xmm6, xmm3              ; xmm6=z3
+    paddw       xmm0, xmm1              ; xmm0=z4
+
+    ; (Original)
+    ; z5 = (z3 + z4) * 1.175875602;
+    ; z3 = z3 * -1.961570560;  z4 = z4 * -0.390180644;
+    ; z3 += z5;  z4 += z5;
+    ;
+    ; (This implementation)
+    ; z3 = z3 * (1.175875602 - 1.961570560) + z4 * 1.175875602;
+    ; z4 = z3 * 1.175875602 + z4 * (1.175875602 - 0.390180644);
+
+    movdqa      xmm7, xmm6
+    movdqa      xmm4, xmm6
+    punpcklwd   xmm7, xmm0
+    punpckhwd   xmm4, xmm0
+    movdqa      xmm6, xmm7
+    movdqa      xmm0, xmm4
+    pmaddwd     xmm7, [GOTOFF(ebx,PW_MF078_F117)]  ; xmm7=z3L
+    pmaddwd     xmm4, [GOTOFF(ebx,PW_MF078_F117)]  ; xmm4=z3H
+    pmaddwd     xmm6, [GOTOFF(ebx,PW_F117_F078)]   ; xmm6=z4L
+    pmaddwd     xmm0, [GOTOFF(ebx,PW_F117_F078)]   ; xmm0=z4H
+
+    movdqa      XMMWORD [wk(0)], xmm7   ; wk(0)=z3L
+    movdqa      XMMWORD [wk(1)], xmm4   ; wk(1)=z3H
+
+    ; (Original)
+    ; z1 = tmp4 + tmp7;  z2 = tmp5 + tmp6;
+    ; tmp4 = tmp4 * 0.298631336;  tmp5 = tmp5 * 2.053119869;
+    ; tmp6 = tmp6 * 3.072711026;  tmp7 = tmp7 * 1.501321110;
+    ; z1 = z1 * -0.899976223;  z2 = z2 * -2.562915447;
+    ; data7 = tmp4 + z1 + z3;  data5 = tmp5 + z2 + z4;
+    ; data3 = tmp6 + z2 + z3;  data1 = tmp7 + z1 + z4;
+    ;
+    ; (This implementation)
+    ; tmp4 = tmp4 * (0.298631336 - 0.899976223) + tmp7 * -0.899976223;
+    ; tmp5 = tmp5 * (2.053119869 - 2.562915447) + tmp6 * -2.562915447;
+    ; tmp6 = tmp5 * -2.562915447 + tmp6 * (3.072711026 - 2.562915447);
+    ; tmp7 = tmp4 * -0.899976223 + tmp7 * (1.501321110 - 0.899976223);
+    ; data7 = tmp4 + z3;  data5 = tmp5 + z4;
+    ; data3 = tmp6 + z3;  data1 = tmp7 + z4;
+
+    movdqa      xmm7, xmm2
+    movdqa      xmm4, xmm2
+    punpcklwd   xmm7, xmm1
+    punpckhwd   xmm4, xmm1
+    movdqa      xmm2, xmm7
+    movdqa      xmm1, xmm4
+    pmaddwd     xmm7, [GOTOFF(ebx,PW_MF060_MF089)]  ; xmm7=tmp4L
+    pmaddwd     xmm4, [GOTOFF(ebx,PW_MF060_MF089)]  ; xmm4=tmp4H
+    pmaddwd     xmm2, [GOTOFF(ebx,PW_MF089_F060)]   ; xmm2=tmp7L
+    pmaddwd     xmm1, [GOTOFF(ebx,PW_MF089_F060)]   ; xmm1=tmp7H
+
+    paddd       xmm7, XMMWORD [wk(0)]   ; xmm7=data7L
+    paddd       xmm4, XMMWORD [wk(1)]   ; xmm4=data7H
+    paddd       xmm2, xmm6              ; xmm2=data1L
+    paddd       xmm1, xmm0              ; xmm1=data1H
+
+    paddd       xmm7, [GOTOFF(ebx,PD_DESCALE_P1)]
+    paddd       xmm4, [GOTOFF(ebx,PD_DESCALE_P1)]
+    psrad       xmm7, DESCALE_P1
+    psrad       xmm4, DESCALE_P1
+    paddd       xmm2, [GOTOFF(ebx,PD_DESCALE_P1)]
+    paddd       xmm1, [GOTOFF(ebx,PD_DESCALE_P1)]
+    psrad       xmm2, DESCALE_P1
+    psrad       xmm1, DESCALE_P1
+
+    packssdw    xmm7, xmm4              ; xmm7=data7
+    packssdw    xmm2, xmm1              ; xmm2=data1
+
+    movdqa      xmm4, xmm5
+    movdqa      xmm1, xmm5
+    punpcklwd   xmm4, xmm3
+    punpckhwd   xmm1, xmm3
+    movdqa      xmm5, xmm4
+    movdqa      xmm3, xmm1
+    pmaddwd     xmm4, [GOTOFF(ebx,PW_MF050_MF256)]  ; xmm4=tmp5L
+    pmaddwd     xmm1, [GOTOFF(ebx,PW_MF050_MF256)]  ; xmm1=tmp5H
+    pmaddwd     xmm5, [GOTOFF(ebx,PW_MF256_F050)]   ; xmm5=tmp6L
+    pmaddwd     xmm3, [GOTOFF(ebx,PW_MF256_F050)]   ; xmm3=tmp6H
+
+    paddd       xmm4, xmm6              ; xmm4=data5L
+    paddd       xmm1, xmm0              ; xmm1=data5H
+    paddd       xmm5, XMMWORD [wk(0)]   ; xmm5=data3L
+    paddd       xmm3, XMMWORD [wk(1)]   ; xmm3=data3H
+
+    paddd       xmm4, [GOTOFF(ebx,PD_DESCALE_P1)]
+    paddd       xmm1, [GOTOFF(ebx,PD_DESCALE_P1)]
+    psrad       xmm4, DESCALE_P1
+    psrad       xmm1, DESCALE_P1
+    paddd       xmm5, [GOTOFF(ebx,PD_DESCALE_P1)]
+    paddd       xmm3, [GOTOFF(ebx,PD_DESCALE_P1)]
+    psrad       xmm5, DESCALE_P1
+    psrad       xmm3, DESCALE_P1
+
+    packssdw    xmm4, xmm1              ; xmm4=data5
+    packssdw    xmm5, xmm3              ; xmm5=data3
+
+    ; ---- Pass 2: process columns.
+
+;   mov         edx, POINTER [data(eax)]  ; (DCTELEM *)
+
+    movdqa      xmm6, XMMWORD [wk(2)]   ; xmm6=col0
+    movdqa      xmm0, XMMWORD [wk(4)]   ; xmm0=col2
+
+    ; xmm6=(00 10 20 30 40 50 60 70), xmm0=(02 12 22 32 42 52 62 72)
+    ; xmm2=(01 11 21 31 41 51 61 71), xmm5=(03 13 23 33 43 53 63 73)
+
+    movdqa      xmm1, xmm6              ; transpose coefficients(phase 1)
+    punpcklwd   xmm6, xmm2              ; xmm6=(00 01 10 11 20 21 30 31)
+    punpckhwd   xmm1, xmm2              ; xmm1=(40 41 50 51 60 61 70 71)
+    movdqa      xmm3, xmm0              ; transpose coefficients(phase 1)
+    punpcklwd   xmm0, xmm5              ; xmm0=(02 03 12 13 22 23 32 33)
+    punpckhwd   xmm3, xmm5              ; xmm3=(42 43 52 53 62 63 72 73)
+
+    movdqa      xmm2, XMMWORD [wk(3)]   ; xmm2=col4
+    movdqa      xmm5, XMMWORD [wk(5)]   ; xmm5=col6
+
+    ; xmm2=(04 14 24 34 44 54 64 74), xmm5=(06 16 26 36 46 56 66 76)
+    ; xmm4=(05 15 25 35 45 55 65 75), xmm7=(07 17 27 37 47 57 67 77)
+
+    movdqa      XMMWORD [wk(0)], xmm0   ; wk(0)=(02 03 12 13 22 23 32 33)
+    movdqa      XMMWORD [wk(1)], xmm3   ; wk(1)=(42 43 52 53 62 63 72 73)
+
+    movdqa      xmm0, xmm2              ; transpose coefficients(phase 1)
+    punpcklwd   xmm2, xmm4              ; xmm2=(04 05 14 15 24 25 34 35)
+    punpckhwd   xmm0, xmm4              ; xmm0=(44 45 54 55 64 65 74 75)
+    movdqa      xmm3, xmm5              ; transpose coefficients(phase 1)
+    punpcklwd   xmm5, xmm7              ; xmm5=(06 07 16 17 26 27 36 37)
+    punpckhwd   xmm3, xmm7              ; xmm3=(46 47 56 57 66 67 76 77)
+
+    movdqa      xmm4, xmm2              ; transpose coefficients(phase 2)
+    punpckldq   xmm2, xmm5              ; xmm2=(04 05 06 07 14 15 16 17)
+    punpckhdq   xmm4, xmm5              ; xmm4=(24 25 26 27 34 35 36 37)
+    movdqa      xmm7, xmm0              ; transpose coefficients(phase 2)
+    punpckldq   xmm0, xmm3              ; xmm0=(44 45 46 47 54 55 56 57)
+    punpckhdq   xmm7, xmm3              ; xmm7=(64 65 66 67 74 75 76 77)
+
+    movdqa      xmm5, XMMWORD [wk(0)]   ; xmm5=(02 03 12 13 22 23 32 33)
+    movdqa      xmm3, XMMWORD [wk(1)]   ; xmm3=(42 43 52 53 62 63 72 73)
+    movdqa      XMMWORD [wk(2)], xmm4   ; wk(2)=(24 25 26 27 34 35 36 37)
+    movdqa      XMMWORD [wk(3)], xmm0   ; wk(3)=(44 45 46 47 54 55 56 57)
+
+    movdqa      xmm4, xmm6              ; transpose coefficients(phase 2)
+    punpckldq   xmm6, xmm5              ; xmm6=(00 01 02 03 10 11 12 13)
+    punpckhdq   xmm4, xmm5              ; xmm4=(20 21 22 23 30 31 32 33)
+    movdqa      xmm0, xmm1              ; transpose coefficients(phase 2)
+    punpckldq   xmm1, xmm3              ; xmm1=(40 41 42 43 50 51 52 53)
+    punpckhdq   xmm0, xmm3              ; xmm0=(60 61 62 63 70 71 72 73)
+
+    movdqa      xmm5, xmm6              ; transpose coefficients(phase 3)
+    punpcklqdq  xmm6, xmm2              ; xmm6=(00 01 02 03 04 05 06 07)=data0
+    punpckhqdq  xmm5, xmm2              ; xmm5=(10 11 12 13 14 15 16 17)=data1
+    movdqa      xmm3, xmm0              ; transpose coefficients(phase 3)
+    punpcklqdq  xmm0, xmm7              ; xmm0=(60 61 62 63 64 65 66 67)=data6
+    punpckhqdq  xmm3, xmm7              ; xmm3=(70 71 72 73 74 75 76 77)=data7
+
+    movdqa      xmm2, xmm5
+    movdqa      xmm7, xmm6
+    psubw       xmm5, xmm0              ; xmm5=data1-data6=tmp6
+    psubw       xmm6, xmm3              ; xmm6=data0-data7=tmp7
+    paddw       xmm2, xmm0              ; xmm2=data1+data6=tmp1
+    paddw       xmm7, xmm3              ; xmm7=data0+data7=tmp0
+
+    movdqa      xmm0, XMMWORD [wk(2)]   ; xmm0=(24 25 26 27 34 35 36 37)
+    movdqa      xmm3, XMMWORD [wk(3)]   ; xmm3=(44 45 46 47 54 55 56 57)
+    movdqa      XMMWORD [wk(0)], xmm5   ; wk(0)=tmp6
+    movdqa      XMMWORD [wk(1)], xmm6   ; wk(1)=tmp7
+
+    movdqa      xmm5, xmm4              ; transpose coefficients(phase 3)
+    punpcklqdq  xmm4, xmm0              ; xmm4=(20 21 22 23 24 25 26 27)=data2
+    punpckhqdq  xmm5, xmm0              ; xmm5=(30 31 32 33 34 35 36 37)=data3
+    movdqa      xmm6, xmm1              ; transpose coefficients(phase 3)
+    punpcklqdq  xmm1, xmm3              ; xmm1=(40 41 42 43 44 45 46 47)=data4
+    punpckhqdq  xmm6, xmm3              ; xmm6=(50 51 52 53 54 55 56 57)=data5
+
+    movdqa      xmm0, xmm5
+    movdqa      xmm3, xmm4
+    paddw       xmm5, xmm1              ; xmm5=data3+data4=tmp3
+    paddw       xmm4, xmm6              ; xmm4=data2+data5=tmp2
+    psubw       xmm0, xmm1              ; xmm0=data3-data4=tmp4
+    psubw       xmm3, xmm6              ; xmm3=data2-data5=tmp5
+
+    ; -- Even part
+
+    movdqa      xmm1, xmm7
+    movdqa      xmm6, xmm2
+    paddw       xmm7, xmm5              ; xmm7=tmp10
+    paddw       xmm2, xmm4              ; xmm2=tmp11
+    psubw       xmm1, xmm5              ; xmm1=tmp13
+    psubw       xmm6, xmm4              ; xmm6=tmp12
+
+    movdqa      xmm5, xmm7
+    paddw       xmm7, xmm2              ; xmm7=tmp10+tmp11
+    psubw       xmm5, xmm2              ; xmm5=tmp10-tmp11
+
+    paddw       xmm7, [GOTOFF(ebx,PW_DESCALE_P2X)]
+    paddw       xmm5, [GOTOFF(ebx,PW_DESCALE_P2X)]
+    psraw       xmm7, PASS1_BITS        ; xmm7=data0
+    psraw       xmm5, PASS1_BITS        ; xmm5=data4
+
+    movdqa      XMMWORD [XMMBLOCK(0,0,edx,SIZEOF_DCTELEM)], xmm7
+    movdqa      XMMWORD [XMMBLOCK(4,0,edx,SIZEOF_DCTELEM)], xmm5
+
+    ; (Original)
+    ; z1 = (tmp12 + tmp13) * 0.541196100;
+    ; data2 = z1 + tmp13 * 0.765366865;
+    ; data6 = z1 + tmp12 * -1.847759065;
+    ;
+    ; (This implementation)
+    ; data2 = tmp13 * (0.541196100 + 0.765366865) + tmp12 * 0.541196100;
+    ; data6 = tmp13 * 0.541196100 + tmp12 * (0.541196100 - 1.847759065);
+
+    movdqa      xmm4, xmm1              ; xmm1=tmp13
+    movdqa      xmm2, xmm1
+    punpcklwd   xmm4, xmm6              ; xmm6=tmp12
+    punpckhwd   xmm2, xmm6
+    movdqa      xmm1, xmm4
+    movdqa      xmm6, xmm2
+    pmaddwd     xmm4, [GOTOFF(ebx,PW_F130_F054)]   ; xmm4=data2L
+    pmaddwd     xmm2, [GOTOFF(ebx,PW_F130_F054)]   ; xmm2=data2H
+    pmaddwd     xmm1, [GOTOFF(ebx,PW_F054_MF130)]  ; xmm1=data6L
+    pmaddwd     xmm6, [GOTOFF(ebx,PW_F054_MF130)]  ; xmm6=data6H
+
+    paddd       xmm4, [GOTOFF(ebx,PD_DESCALE_P2)]
+    paddd       xmm2, [GOTOFF(ebx,PD_DESCALE_P2)]
+    psrad       xmm4, DESCALE_P2
+    psrad       xmm2, DESCALE_P2
+    paddd       xmm1, [GOTOFF(ebx,PD_DESCALE_P2)]
+    paddd       xmm6, [GOTOFF(ebx,PD_DESCALE_P2)]
+    psrad       xmm1, DESCALE_P2
+    psrad       xmm6, DESCALE_P2
+
+    packssdw    xmm4, xmm2              ; xmm4=data2
+    packssdw    xmm1, xmm6              ; xmm1=data6
+
+    movdqa      XMMWORD [XMMBLOCK(2,0,edx,SIZEOF_DCTELEM)], xmm4
+    movdqa      XMMWORD [XMMBLOCK(6,0,edx,SIZEOF_DCTELEM)], xmm1
+
+    ; -- Odd part
+
+    movdqa      xmm7, XMMWORD [wk(0)]   ; xmm7=tmp6
+    movdqa      xmm5, XMMWORD [wk(1)]   ; xmm5=tmp7
+
+    movdqa      xmm2, xmm0              ; xmm0=tmp4
+    movdqa      xmm6, xmm3              ; xmm3=tmp5
+    paddw       xmm2, xmm7              ; xmm2=z3
+    paddw       xmm6, xmm5              ; xmm6=z4
+
+    ; (Original)
+    ; z5 = (z3 + z4) * 1.175875602;
+    ; z3 = z3 * -1.961570560;  z4 = z4 * -0.390180644;
+    ; z3 += z5;  z4 += z5;
+    ;
+    ; (This implementation)
+    ; z3 = z3 * (1.175875602 - 1.961570560) + z4 * 1.175875602;
+    ; z4 = z3 * 1.175875602 + z4 * (1.175875602 - 0.390180644);
+
+    movdqa      xmm4, xmm2
+    movdqa      xmm1, xmm2
+    punpcklwd   xmm4, xmm6
+    punpckhwd   xmm1, xmm6
+    movdqa      xmm2, xmm4
+    movdqa      xmm6, xmm1
+    pmaddwd     xmm4, [GOTOFF(ebx,PW_MF078_F117)]  ; xmm4=z3L
+    pmaddwd     xmm1, [GOTOFF(ebx,PW_MF078_F117)]  ; xmm1=z3H
+    pmaddwd     xmm2, [GOTOFF(ebx,PW_F117_F078)]   ; xmm2=z4L
+    pmaddwd     xmm6, [GOTOFF(ebx,PW_F117_F078)]   ; xmm6=z4H
+
+    movdqa      XMMWORD [wk(0)], xmm4   ; wk(0)=z3L
+    movdqa      XMMWORD [wk(1)], xmm1   ; wk(1)=z3H
+
+    ; (Original)
+    ; z1 = tmp4 + tmp7;  z2 = tmp5 + tmp6;
+    ; tmp4 = tmp4 * 0.298631336;  tmp5 = tmp5 * 2.053119869;
+    ; tmp6 = tmp6 * 3.072711026;  tmp7 = tmp7 * 1.501321110;
+    ; z1 = z1 * -0.899976223;  z2 = z2 * -2.562915447;
+    ; data7 = tmp4 + z1 + z3;  data5 = tmp5 + z2 + z4;
+    ; data3 = tmp6 + z2 + z3;  data1 = tmp7 + z1 + z4;
+    ;
+    ; (This implementation)
+    ; tmp4 = tmp4 * (0.298631336 - 0.899976223) + tmp7 * -0.899976223;
+    ; tmp5 = tmp5 * (2.053119869 - 2.562915447) + tmp6 * -2.562915447;
+    ; tmp6 = tmp5 * -2.562915447 + tmp6 * (3.072711026 - 2.562915447);
+    ; tmp7 = tmp4 * -0.899976223 + tmp7 * (1.501321110 - 0.899976223);
+    ; data7 = tmp4 + z3;  data5 = tmp5 + z4;
+    ; data3 = tmp6 + z3;  data1 = tmp7 + z4;
+
+    movdqa      xmm4, xmm0
+    movdqa      xmm1, xmm0
+    punpcklwd   xmm4, xmm5
+    punpckhwd   xmm1, xmm5
+    movdqa      xmm0, xmm4
+    movdqa      xmm5, xmm1
+    pmaddwd     xmm4, [GOTOFF(ebx,PW_MF060_MF089)]  ; xmm4=tmp4L
+    pmaddwd     xmm1, [GOTOFF(ebx,PW_MF060_MF089)]  ; xmm1=tmp4H
+    pmaddwd     xmm0, [GOTOFF(ebx,PW_MF089_F060)]   ; xmm0=tmp7L
+    pmaddwd     xmm5, [GOTOFF(ebx,PW_MF089_F060)]   ; xmm5=tmp7H
+
+    paddd       xmm4,  XMMWORD [wk(0)]  ; xmm4=data7L
+    paddd       xmm1,  XMMWORD [wk(1)]  ; xmm1=data7H
+    paddd       xmm0, xmm2              ; xmm0=data1L
+    paddd       xmm5, xmm6              ; xmm5=data1H
+
+    paddd       xmm4, [GOTOFF(ebx,PD_DESCALE_P2)]
+    paddd       xmm1, [GOTOFF(ebx,PD_DESCALE_P2)]
+    psrad       xmm4, DESCALE_P2
+    psrad       xmm1, DESCALE_P2
+    paddd       xmm0, [GOTOFF(ebx,PD_DESCALE_P2)]
+    paddd       xmm5, [GOTOFF(ebx,PD_DESCALE_P2)]
+    psrad       xmm0, DESCALE_P2
+    psrad       xmm5, DESCALE_P2
+
+    packssdw    xmm4, xmm1              ; xmm4=data7
+    packssdw    xmm0, xmm5              ; xmm0=data1
+
+    movdqa      XMMWORD [XMMBLOCK(7,0,edx,SIZEOF_DCTELEM)], xmm4
+    movdqa      XMMWORD [XMMBLOCK(1,0,edx,SIZEOF_DCTELEM)], xmm0
+
+    movdqa      xmm1, xmm3
+    movdqa      xmm5, xmm3
+    punpcklwd   xmm1, xmm7
+    punpckhwd   xmm5, xmm7
+    movdqa      xmm3, xmm1
+    movdqa      xmm7, xmm5
+    pmaddwd     xmm1, [GOTOFF(ebx,PW_MF050_MF256)]  ; xmm1=tmp5L
+    pmaddwd     xmm5, [GOTOFF(ebx,PW_MF050_MF256)]  ; xmm5=tmp5H
+    pmaddwd     xmm3, [GOTOFF(ebx,PW_MF256_F050)]   ; xmm3=tmp6L
+    pmaddwd     xmm7, [GOTOFF(ebx,PW_MF256_F050)]   ; xmm7=tmp6H
+
+    paddd       xmm1, xmm2              ; xmm1=data5L
+    paddd       xmm5, xmm6              ; xmm5=data5H
+    paddd       xmm3, XMMWORD [wk(0)]   ; xmm3=data3L
+    paddd       xmm7, XMMWORD [wk(1)]   ; xmm7=data3H
+
+    paddd       xmm1, [GOTOFF(ebx,PD_DESCALE_P2)]
+    paddd       xmm5, [GOTOFF(ebx,PD_DESCALE_P2)]
+    psrad       xmm1, DESCALE_P2
+    psrad       xmm5, DESCALE_P2
+    paddd       xmm3, [GOTOFF(ebx,PD_DESCALE_P2)]
+    paddd       xmm7, [GOTOFF(ebx,PD_DESCALE_P2)]
+    psrad       xmm3, DESCALE_P2
+    psrad       xmm7, DESCALE_P2
+
+    packssdw    xmm1, xmm5              ; xmm1=data5
+    packssdw    xmm3, xmm7              ; xmm3=data3
+
+    movdqa      XMMWORD [XMMBLOCK(5,0,edx,SIZEOF_DCTELEM)], xmm1
+    movdqa      XMMWORD [XMMBLOCK(3,0,edx,SIZEOF_DCTELEM)], xmm3
+
+;   pop         edi                     ; unused
+;   pop         esi                     ; unused
+;   pop         edx                     ; need not be preserved
+;   pop         ecx                     ; unused
+    poppic      ebx
+    mov         esp, ebp                ; esp <- aligned ebp
+    pop         esp                     ; esp <- original ebp
+    pop         ebp
+    ret
+
+; For some reason, the OS X linker does not honor the request to align the
+; segment unless we do this.
+    align       32
diff --git a/3rdparty/libjpeg/src/simd/i386/jidctflt-3dn.asm b/3rdparty/libjpeg/src/simd/i386/jidctflt-3dn.asm
new file mode 100644
index 00000000..87951910
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/i386/jidctflt-3dn.asm
@@ -0,0 +1,451 @@
+;
+; jidctflt.asm - floating-point IDCT (3DNow! & MMX)
+;
+; Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+; Copyright (C) 2016, D. R. Commander.
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+;
+; This file should be assembled with NASM (Netwide Assembler),
+; can *not* be assembled with Microsoft's MASM or any compatible
+; assembler (including Borland's Turbo Assembler).
+; NASM is available from http://nasm.sourceforge.net/ or
+; http://sourceforge.net/project/showfiles.php?group_id=6208
+;
+; This file contains a floating-point implementation of the inverse DCT
+; (Discrete Cosine Transform). The following code is based directly on
+; the IJG's original jidctflt.c; see the jidctflt.c for more details.
+
+%include "jsimdext.inc"
+%include "jdct.inc"
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_CONST
+
+    alignz      32
+    GLOBAL_DATA(jconst_idct_float_3dnow)
+
+EXTN(jconst_idct_float_3dnow):
+
+PD_1_414        times 2 dd 1.414213562373095048801689
+PD_1_847        times 2 dd 1.847759065022573512256366
+PD_1_082        times 2 dd 1.082392200292393968799446
+PD_2_613        times 2 dd 2.613125929752753055713286
+PD_RNDINT_MAGIC times 2 dd 100663296.0  ; (float)(0x00C00000 << 3)
+PB_CENTERJSAMP  times 8 db CENTERJSAMPLE
+
+    alignz      32
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_TEXT
+    BITS        32
+;
+; Perform dequantization and inverse DCT on one block of coefficients.
+;
+; GLOBAL(void)
+; jsimd_idct_float_3dnow(void *dct_table, JCOEFPTR coef_block,
+;                        JSAMPARRAY output_buf, JDIMENSION output_col)
+;
+
+%define dct_table(b)   (b) + 8          ; void *dct_table
+%define coef_block(b)  (b) + 12         ; JCOEFPTR coef_block
+%define output_buf(b)  (b) + 16         ; JSAMPARRAY output_buf
+%define output_col(b)  (b) + 20         ; JDIMENSION output_col
+
+%define original_ebp   ebp + 0
+%define wk(i)          ebp - (WK_NUM - (i)) * SIZEOF_MMWORD
+                                        ; mmword wk[WK_NUM]
+%define WK_NUM         2
+%define workspace      wk(0) - DCTSIZE2 * SIZEOF_FAST_FLOAT
+                                        ; FAST_FLOAT workspace[DCTSIZE2]
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_idct_float_3dnow)
+
+EXTN(jsimd_idct_float_3dnow):
+    push        ebp
+    mov         eax, esp                    ; eax = original ebp
+    sub         esp, byte 4
+    and         esp, byte (-SIZEOF_MMWORD)  ; align to 64 bits
+    mov         [esp], eax
+    mov         ebp, esp                    ; ebp = aligned ebp
+    lea         esp, [workspace]
+    push        ebx
+;   push        ecx                     ; need not be preserved
+;   push        edx                     ; need not be preserved
+    push        esi
+    push        edi
+
+    get_GOT     ebx                     ; get GOT address
+
+    ; ---- Pass 1: process columns from input, store into work array.
+
+;   mov         eax, [original_ebp]
+    mov         edx, POINTER [dct_table(eax)]    ; quantptr
+    mov         esi, JCOEFPTR [coef_block(eax)]  ; inptr
+    lea         edi, [workspace]                 ; FAST_FLOAT *wsptr
+    mov         ecx, DCTSIZE/2                   ; ctr
+    alignx      16, 7
+.columnloop:
+%ifndef NO_ZERO_COLUMN_TEST_FLOAT_3DNOW
+    mov         eax, dword [DWBLOCK(1,0,esi,SIZEOF_JCOEF)]
+    or          eax, dword [DWBLOCK(2,0,esi,SIZEOF_JCOEF)]
+    jnz         short .columnDCT
+
+    pushpic     ebx                     ; save GOT address
+    mov         ebx, dword [DWBLOCK(3,0,esi,SIZEOF_JCOEF)]
+    mov         eax, dword [DWBLOCK(4,0,esi,SIZEOF_JCOEF)]
+    or          ebx, dword [DWBLOCK(5,0,esi,SIZEOF_JCOEF)]
+    or          eax, dword [DWBLOCK(6,0,esi,SIZEOF_JCOEF)]
+    or          ebx, dword [DWBLOCK(7,0,esi,SIZEOF_JCOEF)]
+    or          eax, ebx
+    poppic      ebx                     ; restore GOT address
+    jnz         short .columnDCT
+
+    ; -- AC terms all zero
+
+    movd        mm0, dword [DWBLOCK(0,0,esi,SIZEOF_JCOEF)]
+
+    punpcklwd   mm0, mm0
+    psrad       mm0, (DWORD_BIT-WORD_BIT)
+    pi2fd       mm0, mm0
+
+    pfmul       mm0, MMWORD [MMBLOCK(0,0,edx,SIZEOF_FLOAT_MULT_TYPE)]
+
+    movq        mm1, mm0
+    punpckldq   mm0, mm0
+    punpckhdq   mm1, mm1
+
+    movq        MMWORD [MMBLOCK(0,0,edi,SIZEOF_FAST_FLOAT)], mm0
+    movq        MMWORD [MMBLOCK(0,1,edi,SIZEOF_FAST_FLOAT)], mm0
+    movq        MMWORD [MMBLOCK(0,2,edi,SIZEOF_FAST_FLOAT)], mm0
+    movq        MMWORD [MMBLOCK(0,3,edi,SIZEOF_FAST_FLOAT)], mm0
+    movq        MMWORD [MMBLOCK(1,0,edi,SIZEOF_FAST_FLOAT)], mm1
+    movq        MMWORD [MMBLOCK(1,1,edi,SIZEOF_FAST_FLOAT)], mm1
+    movq        MMWORD [MMBLOCK(1,2,edi,SIZEOF_FAST_FLOAT)], mm1
+    movq        MMWORD [MMBLOCK(1,3,edi,SIZEOF_FAST_FLOAT)], mm1
+    jmp         near .nextcolumn
+    alignx      16, 7
+%endif
+.columnDCT:
+
+    ; -- Even part
+
+    movd        mm0, dword [DWBLOCK(0,0,esi,SIZEOF_JCOEF)]
+    movd        mm1, dword [DWBLOCK(2,0,esi,SIZEOF_JCOEF)]
+    movd        mm2, dword [DWBLOCK(4,0,esi,SIZEOF_JCOEF)]
+    movd        mm3, dword [DWBLOCK(6,0,esi,SIZEOF_JCOEF)]
+
+    punpcklwd   mm0, mm0
+    punpcklwd   mm1, mm1
+    psrad       mm0, (DWORD_BIT-WORD_BIT)
+    psrad       mm1, (DWORD_BIT-WORD_BIT)
+    pi2fd       mm0, mm0
+    pi2fd       mm1, mm1
+
+    pfmul       mm0, MMWORD [MMBLOCK(0,0,edx,SIZEOF_FLOAT_MULT_TYPE)]
+    pfmul       mm1, MMWORD [MMBLOCK(2,0,edx,SIZEOF_FLOAT_MULT_TYPE)]
+
+    punpcklwd   mm2, mm2
+    punpcklwd   mm3, mm3
+    psrad       mm2, (DWORD_BIT-WORD_BIT)
+    psrad       mm3, (DWORD_BIT-WORD_BIT)
+    pi2fd       mm2, mm2
+    pi2fd       mm3, mm3
+
+    pfmul       mm2, MMWORD [MMBLOCK(4,0,edx,SIZEOF_FLOAT_MULT_TYPE)]
+    pfmul       mm3, MMWORD [MMBLOCK(6,0,edx,SIZEOF_FLOAT_MULT_TYPE)]
+
+    movq        mm4, mm0
+    movq        mm5, mm1
+    pfsub       mm0, mm2                ; mm0=tmp11
+    pfsub       mm1, mm3
+    pfadd       mm4, mm2                ; mm4=tmp10
+    pfadd       mm5, mm3                ; mm5=tmp13
+
+    pfmul       mm1, [GOTOFF(ebx,PD_1_414)]
+    pfsub       mm1, mm5                ; mm1=tmp12
+
+    movq        mm6, mm4
+    movq        mm7, mm0
+    pfsub       mm4, mm5                ; mm4=tmp3
+    pfsub       mm0, mm1                ; mm0=tmp2
+    pfadd       mm6, mm5                ; mm6=tmp0
+    pfadd       mm7, mm1                ; mm7=tmp1
+
+    movq        MMWORD [wk(1)], mm4     ; tmp3
+    movq        MMWORD [wk(0)], mm0     ; tmp2
+
+    ; -- Odd part
+
+    movd        mm2, dword [DWBLOCK(1,0,esi,SIZEOF_JCOEF)]
+    movd        mm3, dword [DWBLOCK(3,0,esi,SIZEOF_JCOEF)]
+    movd        mm5, dword [DWBLOCK(5,0,esi,SIZEOF_JCOEF)]
+    movd        mm1, dword [DWBLOCK(7,0,esi,SIZEOF_JCOEF)]
+
+    punpcklwd   mm2, mm2
+    punpcklwd   mm3, mm3
+    psrad       mm2, (DWORD_BIT-WORD_BIT)
+    psrad       mm3, (DWORD_BIT-WORD_BIT)
+    pi2fd       mm2, mm2
+    pi2fd       mm3, mm3
+
+    pfmul       mm2, MMWORD [MMBLOCK(1,0,edx,SIZEOF_FLOAT_MULT_TYPE)]
+    pfmul       mm3, MMWORD [MMBLOCK(3,0,edx,SIZEOF_FLOAT_MULT_TYPE)]
+
+    punpcklwd   mm5, mm5
+    punpcklwd   mm1, mm1
+    psrad       mm5, (DWORD_BIT-WORD_BIT)
+    psrad       mm1, (DWORD_BIT-WORD_BIT)
+    pi2fd       mm5, mm5
+    pi2fd       mm1, mm1
+
+    pfmul       mm5, MMWORD [MMBLOCK(5,0,edx,SIZEOF_FLOAT_MULT_TYPE)]
+    pfmul       mm1, MMWORD [MMBLOCK(7,0,edx,SIZEOF_FLOAT_MULT_TYPE)]
+
+    movq        mm4, mm2
+    movq        mm0, mm5
+    pfadd       mm2, mm1                ; mm2=z11
+    pfadd       mm5, mm3                ; mm5=z13
+    pfsub       mm4, mm1                ; mm4=z12
+    pfsub       mm0, mm3                ; mm0=z10
+
+    movq        mm1, mm2
+    pfsub       mm2, mm5
+    pfadd       mm1, mm5                ; mm1=tmp7
+
+    pfmul       mm2, [GOTOFF(ebx,PD_1_414)]  ; mm2=tmp11
+
+    movq        mm3, mm0
+    pfadd       mm0, mm4
+    pfmul       mm0, [GOTOFF(ebx,PD_1_847)]  ; mm0=z5
+    pfmul       mm3, [GOTOFF(ebx,PD_2_613)]  ; mm3=(z10 * 2.613125930)
+    pfmul       mm4, [GOTOFF(ebx,PD_1_082)]  ; mm4=(z12 * 1.082392200)
+    pfsubr      mm3, mm0                     ; mm3=tmp12
+    pfsub       mm4, mm0                     ; mm4=tmp10
+
+    ; -- Final output stage
+
+    pfsub       mm3, mm1                ; mm3=tmp6
+    movq        mm5, mm6
+    movq        mm0, mm7
+    pfadd       mm6, mm1                ; mm6=data0=(00 01)
+    pfadd       mm7, mm3                ; mm7=data1=(10 11)
+    pfsub       mm5, mm1                ; mm5=data7=(70 71)
+    pfsub       mm0, mm3                ; mm0=data6=(60 61)
+    pfsub       mm2, mm3                ; mm2=tmp5
+
+    movq        mm1, mm6                ; transpose coefficients
+    punpckldq   mm6, mm7                ; mm6=(00 10)
+    punpckhdq   mm1, mm7                ; mm1=(01 11)
+    movq        mm3, mm0                ; transpose coefficients
+    punpckldq   mm0, mm5                ; mm0=(60 70)
+    punpckhdq   mm3, mm5                ; mm3=(61 71)
+
+    movq        MMWORD [MMBLOCK(0,0,edi,SIZEOF_FAST_FLOAT)], mm6
+    movq        MMWORD [MMBLOCK(1,0,edi,SIZEOF_FAST_FLOAT)], mm1
+    movq        MMWORD [MMBLOCK(0,3,edi,SIZEOF_FAST_FLOAT)], mm0
+    movq        MMWORD [MMBLOCK(1,3,edi,SIZEOF_FAST_FLOAT)], mm3
+
+    movq        mm7, MMWORD [wk(0)]     ; mm7=tmp2
+    movq        mm5, MMWORD [wk(1)]     ; mm5=tmp3
+
+    pfadd       mm4, mm2                ; mm4=tmp4
+    movq        mm6, mm7
+    movq        mm1, mm5
+    pfadd       mm7, mm2                ; mm7=data2=(20 21)
+    pfadd       mm5, mm4                ; mm5=data4=(40 41)
+    pfsub       mm6, mm2                ; mm6=data5=(50 51)
+    pfsub       mm1, mm4                ; mm1=data3=(30 31)
+
+    movq        mm0, mm7                ; transpose coefficients
+    punpckldq   mm7, mm1                ; mm7=(20 30)
+    punpckhdq   mm0, mm1                ; mm0=(21 31)
+    movq        mm3, mm5                ; transpose coefficients
+    punpckldq   mm5, mm6                ; mm5=(40 50)
+    punpckhdq   mm3, mm6                ; mm3=(41 51)
+
+    movq        MMWORD [MMBLOCK(0,1,edi,SIZEOF_FAST_FLOAT)], mm7
+    movq        MMWORD [MMBLOCK(1,1,edi,SIZEOF_FAST_FLOAT)], mm0
+    movq        MMWORD [MMBLOCK(0,2,edi,SIZEOF_FAST_FLOAT)], mm5
+    movq        MMWORD [MMBLOCK(1,2,edi,SIZEOF_FAST_FLOAT)], mm3
+
+.nextcolumn:
+    add         esi, byte 2*SIZEOF_JCOEF               ; coef_block
+    add         edx, byte 2*SIZEOF_FLOAT_MULT_TYPE     ; quantptr
+    add         edi, byte 2*DCTSIZE*SIZEOF_FAST_FLOAT  ; wsptr
+    dec         ecx                                    ; ctr
+    jnz         near .columnloop
+
+    ; -- Prefetch the next coefficient block
+
+    prefetch [esi + (DCTSIZE2-8)*SIZEOF_JCOEF + 0*32]
+    prefetch [esi + (DCTSIZE2-8)*SIZEOF_JCOEF + 1*32]
+    prefetch [esi + (DCTSIZE2-8)*SIZEOF_JCOEF + 2*32]
+    prefetch [esi + (DCTSIZE2-8)*SIZEOF_JCOEF + 3*32]
+
+    ; ---- Pass 2: process rows from work array, store into output array.
+
+    mov         eax, [original_ebp]
+    lea         esi, [workspace]                   ; FAST_FLOAT *wsptr
+    mov         edi, JSAMPARRAY [output_buf(eax)]  ; (JSAMPROW *)
+    mov         eax, JDIMENSION [output_col(eax)]
+    mov         ecx, DCTSIZE/2                     ; ctr
+    alignx      16, 7
+.rowloop:
+
+    ; -- Even part
+
+    movq        mm0, MMWORD [MMBLOCK(0,0,esi,SIZEOF_FAST_FLOAT)]
+    movq        mm1, MMWORD [MMBLOCK(2,0,esi,SIZEOF_FAST_FLOAT)]
+    movq        mm2, MMWORD [MMBLOCK(4,0,esi,SIZEOF_FAST_FLOAT)]
+    movq        mm3, MMWORD [MMBLOCK(6,0,esi,SIZEOF_FAST_FLOAT)]
+
+    movq        mm4, mm0
+    movq        mm5, mm1
+    pfsub       mm0, mm2                ; mm0=tmp11
+    pfsub       mm1, mm3
+    pfadd       mm4, mm2                ; mm4=tmp10
+    pfadd       mm5, mm3                ; mm5=tmp13
+
+    pfmul       mm1, [GOTOFF(ebx,PD_1_414)]
+    pfsub       mm1, mm5                ; mm1=tmp12
+
+    movq        mm6, mm4
+    movq        mm7, mm0
+    pfsub       mm4, mm5                ; mm4=tmp3
+    pfsub       mm0, mm1                ; mm0=tmp2
+    pfadd       mm6, mm5                ; mm6=tmp0
+    pfadd       mm7, mm1                ; mm7=tmp1
+
+    movq        MMWORD [wk(1)], mm4     ; tmp3
+    movq        MMWORD [wk(0)], mm0     ; tmp2
+
+    ; -- Odd part
+
+    movq        mm2, MMWORD [MMBLOCK(1,0,esi,SIZEOF_FAST_FLOAT)]
+    movq        mm3, MMWORD [MMBLOCK(3,0,esi,SIZEOF_FAST_FLOAT)]
+    movq        mm5, MMWORD [MMBLOCK(5,0,esi,SIZEOF_FAST_FLOAT)]
+    movq        mm1, MMWORD [MMBLOCK(7,0,esi,SIZEOF_FAST_FLOAT)]
+
+    movq        mm4, mm2
+    movq        mm0, mm5
+    pfadd       mm2, mm1                ; mm2=z11
+    pfadd       mm5, mm3                ; mm5=z13
+    pfsub       mm4, mm1                ; mm4=z12
+    pfsub       mm0, mm3                ; mm0=z10
+
+    movq        mm1, mm2
+    pfsub       mm2, mm5
+    pfadd       mm1, mm5                ; mm1=tmp7
+
+    pfmul       mm2, [GOTOFF(ebx,PD_1_414)]  ; mm2=tmp11
+
+    movq        mm3, mm0
+    pfadd       mm0, mm4
+    pfmul       mm0, [GOTOFF(ebx,PD_1_847)]  ; mm0=z5
+    pfmul       mm3, [GOTOFF(ebx,PD_2_613)]  ; mm3=(z10 * 2.613125930)
+    pfmul       mm4, [GOTOFF(ebx,PD_1_082)]  ; mm4=(z12 * 1.082392200)
+    pfsubr      mm3, mm0                     ; mm3=tmp12
+    pfsub       mm4, mm0                     ; mm4=tmp10
+
+    ; -- Final output stage
+
+    pfsub       mm3, mm1                ; mm3=tmp6
+    movq        mm5, mm6
+    movq        mm0, mm7
+    pfadd       mm6, mm1                ; mm6=data0=(00 10)
+    pfadd       mm7, mm3                ; mm7=data1=(01 11)
+    pfsub       mm5, mm1                ; mm5=data7=(07 17)
+    pfsub       mm0, mm3                ; mm0=data6=(06 16)
+    pfsub       mm2, mm3                ; mm2=tmp5
+
+    movq        mm1, [GOTOFF(ebx,PD_RNDINT_MAGIC)]  ; mm1=[PD_RNDINT_MAGIC]
+    pcmpeqd     mm3, mm3
+    psrld       mm3, WORD_BIT           ; mm3={0xFFFF 0x0000 0xFFFF 0x0000}
+
+    pfadd       mm6, mm1                ; mm6=roundint(data0/8)=(00 ** 10 **)
+    pfadd       mm7, mm1                ; mm7=roundint(data1/8)=(01 ** 11 **)
+    pfadd       mm0, mm1                ; mm0=roundint(data6/8)=(06 ** 16 **)
+    pfadd       mm5, mm1                ; mm5=roundint(data7/8)=(07 ** 17 **)
+
+    pand        mm6, mm3                ; mm6=(00 -- 10 --)
+    pslld       mm7, WORD_BIT           ; mm7=(-- 01 -- 11)
+    pand        mm0, mm3                ; mm0=(06 -- 16 --)
+    pslld       mm5, WORD_BIT           ; mm5=(-- 07 -- 17)
+    por         mm6, mm7                ; mm6=(00 01 10 11)
+    por         mm0, mm5                ; mm0=(06 07 16 17)
+
+    movq        mm1, MMWORD [wk(0)]     ; mm1=tmp2
+    movq        mm3, MMWORD [wk(1)]     ; mm3=tmp3
+
+    pfadd       mm4, mm2                ; mm4=tmp4
+    movq        mm7, mm1
+    movq        mm5, mm3
+    pfadd       mm1, mm2                ; mm1=data2=(02 12)
+    pfadd       mm3, mm4                ; mm3=data4=(04 14)
+    pfsub       mm7, mm2                ; mm7=data5=(05 15)
+    pfsub       mm5, mm4                ; mm5=data3=(03 13)
+
+    movq        mm2, [GOTOFF(ebx,PD_RNDINT_MAGIC)]  ; mm2=[PD_RNDINT_MAGIC]
+    pcmpeqd     mm4, mm4
+    psrld       mm4, WORD_BIT           ; mm4={0xFFFF 0x0000 0xFFFF 0x0000}
+
+    pfadd       mm3, mm2                ; mm3=roundint(data4/8)=(04 ** 14 **)
+    pfadd       mm7, mm2                ; mm7=roundint(data5/8)=(05 ** 15 **)
+    pfadd       mm1, mm2                ; mm1=roundint(data2/8)=(02 ** 12 **)
+    pfadd       mm5, mm2                ; mm5=roundint(data3/8)=(03 ** 13 **)
+
+    pand        mm3, mm4                ; mm3=(04 -- 14 --)
+    pslld       mm7, WORD_BIT           ; mm7=(-- 05 -- 15)
+    pand        mm1, mm4                ; mm1=(02 -- 12 --)
+    pslld       mm5, WORD_BIT           ; mm5=(-- 03 -- 13)
+    por         mm3, mm7                ; mm3=(04 05 14 15)
+    por         mm1, mm5                ; mm1=(02 03 12 13)
+
+    movq        mm2, [GOTOFF(ebx,PB_CENTERJSAMP)]  ; mm2=[PB_CENTERJSAMP]
+
+    packsswb    mm6, mm3                ; mm6=(00 01 10 11 04 05 14 15)
+    packsswb    mm1, mm0                ; mm1=(02 03 12 13 06 07 16 17)
+    paddb       mm6, mm2
+    paddb       mm1, mm2
+
+    movq        mm4, mm6                ; transpose coefficients(phase 2)
+    punpcklwd   mm6, mm1                ; mm6=(00 01 02 03 10 11 12 13)
+    punpckhwd   mm4, mm1                ; mm4=(04 05 06 07 14 15 16 17)
+
+    movq        mm7, mm6                ; transpose coefficients(phase 3)
+    punpckldq   mm6, mm4                ; mm6=(00 01 02 03 04 05 06 07)
+    punpckhdq   mm7, mm4                ; mm7=(10 11 12 13 14 15 16 17)
+
+    pushpic     ebx                     ; save GOT address
+
+    mov         edx, JSAMPROW [edi+0*SIZEOF_JSAMPROW]
+    mov         ebx, JSAMPROW [edi+1*SIZEOF_JSAMPROW]
+    movq        MMWORD [edx+eax*SIZEOF_JSAMPLE], mm6
+    movq        MMWORD [ebx+eax*SIZEOF_JSAMPLE], mm7
+
+    poppic      ebx                     ; restore GOT address
+
+    add         esi, byte 2*SIZEOF_FAST_FLOAT  ; wsptr
+    add         edi, byte 2*SIZEOF_JSAMPROW
+    dec         ecx                            ; ctr
+    jnz         near .rowloop
+
+    femms                               ; empty MMX/3DNow! state
+
+    pop         edi
+    pop         esi
+;   pop         edx                     ; need not be preserved
+;   pop         ecx                     ; need not be preserved
+    pop         ebx
+    mov         esp, ebp                ; esp <- aligned ebp
+    pop         esp                     ; esp <- original ebp
+    pop         ebp
+    ret
+
+; For some reason, the OS X linker does not honor the request to align the
+; segment unless we do this.
+    align       32
diff --git a/3rdparty/libjpeg/src/simd/i386/jidctflt-sse.asm b/3rdparty/libjpeg/src/simd/i386/jidctflt-sse.asm
new file mode 100644
index 00000000..b27ecfdf
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/i386/jidctflt-sse.asm
@@ -0,0 +1,571 @@
+;
+; jidctflt.asm - floating-point IDCT (SSE & MMX)
+;
+; Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+; Copyright (C) 2016, D. R. Commander.
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+;
+; This file should be assembled with NASM (Netwide Assembler),
+; can *not* be assembled with Microsoft's MASM or any compatible
+; assembler (including Borland's Turbo Assembler).
+; NASM is available from http://nasm.sourceforge.net/ or
+; http://sourceforge.net/project/showfiles.php?group_id=6208
+;
+; This file contains a floating-point implementation of the inverse DCT
+; (Discrete Cosine Transform). The following code is based directly on
+; the IJG's original jidctflt.c; see the jidctflt.c for more details.
+
+%include "jsimdext.inc"
+%include "jdct.inc"
+
+; --------------------------------------------------------------------------
+
+%macro unpcklps2 2  ; %1=(0 1 2 3) / %2=(4 5 6 7) => %1=(0 1 4 5)
+    shufps      %1, %2, 0x44
+%endmacro
+
+%macro unpckhps2 2  ; %1=(0 1 2 3) / %2=(4 5 6 7) => %1=(2 3 6 7)
+    shufps      %1, %2, 0xEE
+%endmacro
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_CONST
+
+    alignz      32
+    GLOBAL_DATA(jconst_idct_float_sse)
+
+EXTN(jconst_idct_float_sse):
+
+PD_1_414       times 4 dd  1.414213562373095048801689
+PD_1_847       times 4 dd  1.847759065022573512256366
+PD_1_082       times 4 dd  1.082392200292393968799446
+PD_M2_613      times 4 dd -2.613125929752753055713286
+PD_0_125       times 4 dd  0.125        ; 1/8
+PB_CENTERJSAMP times 8 db  CENTERJSAMPLE
+
+    alignz      32
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_TEXT
+    BITS        32
+;
+; Perform dequantization and inverse DCT on one block of coefficients.
+;
+; GLOBAL(void)
+; jsimd_idct_float_sse(void *dct_table, JCOEFPTR coef_block,
+;                      JSAMPARRAY output_buf, JDIMENSION output_col)
+;
+
+%define dct_table(b)   (b) + 8          ; void *dct_table
+%define coef_block(b)  (b) + 12         ; JCOEFPTR coef_block
+%define output_buf(b)  (b) + 16         ; JSAMPARRAY output_buf
+%define output_col(b)  (b) + 20         ; JDIMENSION output_col
+
+%define original_ebp   ebp + 0
+%define wk(i)          ebp - (WK_NUM - (i)) * SIZEOF_XMMWORD
+                                        ; xmmword wk[WK_NUM]
+%define WK_NUM         2
+%define workspace      wk(0) - DCTSIZE2 * SIZEOF_FAST_FLOAT
+                                        ; FAST_FLOAT workspace[DCTSIZE2]
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_idct_float_sse)
+
+EXTN(jsimd_idct_float_sse):
+    push        ebp
+    mov         eax, esp                     ; eax = original ebp
+    sub         esp, byte 4
+    and         esp, byte (-SIZEOF_XMMWORD)  ; align to 128 bits
+    mov         [esp], eax
+    mov         ebp, esp                     ; ebp = aligned ebp
+    lea         esp, [workspace]
+    push        ebx
+;   push        ecx                     ; need not be preserved
+;   push        edx                     ; need not be preserved
+    push        esi
+    push        edi
+
+    get_GOT     ebx                     ; get GOT address
+
+    ; ---- Pass 1: process columns from input, store into work array.
+
+;   mov         eax, [original_ebp]
+    mov         edx, POINTER [dct_table(eax)]    ; quantptr
+    mov         esi, JCOEFPTR [coef_block(eax)]  ; inptr
+    lea         edi, [workspace]                 ; FAST_FLOAT *wsptr
+    mov         ecx, DCTSIZE/4                   ; ctr
+    alignx      16, 7
+.columnloop:
+%ifndef NO_ZERO_COLUMN_TEST_FLOAT_SSE
+    mov         eax, dword [DWBLOCK(1,0,esi,SIZEOF_JCOEF)]
+    or          eax, dword [DWBLOCK(2,0,esi,SIZEOF_JCOEF)]
+    jnz         near .columnDCT
+
+    movq        mm0, MMWORD [MMBLOCK(1,0,esi,SIZEOF_JCOEF)]
+    movq        mm1, MMWORD [MMBLOCK(2,0,esi,SIZEOF_JCOEF)]
+    por         mm0, MMWORD [MMBLOCK(3,0,esi,SIZEOF_JCOEF)]
+    por         mm1, MMWORD [MMBLOCK(4,0,esi,SIZEOF_JCOEF)]
+    por         mm0, MMWORD [MMBLOCK(5,0,esi,SIZEOF_JCOEF)]
+    por         mm1, MMWORD [MMBLOCK(6,0,esi,SIZEOF_JCOEF)]
+    por         mm0, MMWORD [MMBLOCK(7,0,esi,SIZEOF_JCOEF)]
+    por         mm1, mm0
+    packsswb    mm1, mm1
+    movd        eax, mm1
+    test        eax, eax
+    jnz         short .columnDCT
+
+    ; -- AC terms all zero
+
+    movq        mm0, MMWORD [MMBLOCK(0,0,esi,SIZEOF_JCOEF)]
+
+    punpckhwd   mm1, mm0                   ; mm1=(** 02 ** 03)
+    punpcklwd   mm0, mm0                   ; mm0=(00 00 01 01)
+    psrad       mm1, (DWORD_BIT-WORD_BIT)  ; mm1=in0H=(02 03)
+    psrad       mm0, (DWORD_BIT-WORD_BIT)  ; mm0=in0L=(00 01)
+    cvtpi2ps    xmm3, mm1                  ; xmm3=(02 03 ** **)
+    cvtpi2ps    xmm0, mm0                  ; xmm0=(00 01 ** **)
+    movlhps     xmm0, xmm3                 ; xmm0=in0=(00 01 02 03)
+
+    mulps       xmm0, XMMWORD [XMMBLOCK(0,0,edx,SIZEOF_FLOAT_MULT_TYPE)]
+
+    movaps      xmm1, xmm0
+    movaps      xmm2, xmm0
+    movaps      xmm3, xmm0
+
+    shufps      xmm0, xmm0, 0x00        ; xmm0=(00 00 00 00)
+    shufps      xmm1, xmm1, 0x55        ; xmm1=(01 01 01 01)
+    shufps      xmm2, xmm2, 0xAA        ; xmm2=(02 02 02 02)
+    shufps      xmm3, xmm3, 0xFF        ; xmm3=(03 03 03 03)
+
+    movaps      XMMWORD [XMMBLOCK(0,0,edi,SIZEOF_FAST_FLOAT)], xmm0
+    movaps      XMMWORD [XMMBLOCK(0,1,edi,SIZEOF_FAST_FLOAT)], xmm0
+    movaps      XMMWORD [XMMBLOCK(1,0,edi,SIZEOF_FAST_FLOAT)], xmm1
+    movaps      XMMWORD [XMMBLOCK(1,1,edi,SIZEOF_FAST_FLOAT)], xmm1
+    movaps      XMMWORD [XMMBLOCK(2,0,edi,SIZEOF_FAST_FLOAT)], xmm2
+    movaps      XMMWORD [XMMBLOCK(2,1,edi,SIZEOF_FAST_FLOAT)], xmm2
+    movaps      XMMWORD [XMMBLOCK(3,0,edi,SIZEOF_FAST_FLOAT)], xmm3
+    movaps      XMMWORD [XMMBLOCK(3,1,edi,SIZEOF_FAST_FLOAT)], xmm3
+    jmp         near .nextcolumn
+    alignx      16, 7
+%endif
+.columnDCT:
+
+    ; -- Even part
+
+    movq        mm0, MMWORD [MMBLOCK(0,0,esi,SIZEOF_JCOEF)]
+    movq        mm1, MMWORD [MMBLOCK(2,0,esi,SIZEOF_JCOEF)]
+    movq        mm2, MMWORD [MMBLOCK(4,0,esi,SIZEOF_JCOEF)]
+    movq        mm3, MMWORD [MMBLOCK(6,0,esi,SIZEOF_JCOEF)]
+
+    punpckhwd   mm4, mm0                ; mm4=(** 02 ** 03)
+    punpcklwd   mm0, mm0                ; mm0=(00 00 01 01)
+    punpckhwd   mm5, mm1                ; mm5=(** 22 ** 23)
+    punpcklwd   mm1, mm1                ; mm1=(20 20 21 21)
+
+    psrad       mm4, (DWORD_BIT-WORD_BIT)  ; mm4=in0H=(02 03)
+    psrad       mm0, (DWORD_BIT-WORD_BIT)  ; mm0=in0L=(00 01)
+    cvtpi2ps    xmm4, mm4                  ; xmm4=(02 03 ** **)
+    cvtpi2ps    xmm0, mm0                  ; xmm0=(00 01 ** **)
+    psrad       mm5, (DWORD_BIT-WORD_BIT)  ; mm5=in2H=(22 23)
+    psrad       mm1, (DWORD_BIT-WORD_BIT)  ; mm1=in2L=(20 21)
+    cvtpi2ps    xmm5, mm5                  ; xmm5=(22 23 ** **)
+    cvtpi2ps    xmm1, mm1                  ; xmm1=(20 21 ** **)
+
+    punpckhwd   mm6, mm2                ; mm6=(** 42 ** 43)
+    punpcklwd   mm2, mm2                ; mm2=(40 40 41 41)
+    punpckhwd   mm7, mm3                ; mm7=(** 62 ** 63)
+    punpcklwd   mm3, mm3                ; mm3=(60 60 61 61)
+
+    psrad       mm6, (DWORD_BIT-WORD_BIT)  ; mm6=in4H=(42 43)
+    psrad       mm2, (DWORD_BIT-WORD_BIT)  ; mm2=in4L=(40 41)
+    cvtpi2ps    xmm6, mm6                  ; xmm6=(42 43 ** **)
+    cvtpi2ps    xmm2, mm2                  ; xmm2=(40 41 ** **)
+    psrad       mm7, (DWORD_BIT-WORD_BIT)  ; mm7=in6H=(62 63)
+    psrad       mm3, (DWORD_BIT-WORD_BIT)  ; mm3=in6L=(60 61)
+    cvtpi2ps    xmm7, mm7                  ; xmm7=(62 63 ** **)
+    cvtpi2ps    xmm3, mm3                  ; xmm3=(60 61 ** **)
+
+    movlhps     xmm0, xmm4              ; xmm0=in0=(00 01 02 03)
+    movlhps     xmm1, xmm5              ; xmm1=in2=(20 21 22 23)
+    mulps       xmm0, XMMWORD [XMMBLOCK(0,0,edx,SIZEOF_FLOAT_MULT_TYPE)]
+    mulps       xmm1, XMMWORD [XMMBLOCK(2,0,edx,SIZEOF_FLOAT_MULT_TYPE)]
+
+    movlhps     xmm2, xmm6              ; xmm2=in4=(40 41 42 43)
+    movlhps     xmm3, xmm7              ; xmm3=in6=(60 61 62 63)
+    mulps       xmm2, XMMWORD [XMMBLOCK(4,0,edx,SIZEOF_FLOAT_MULT_TYPE)]
+    mulps       xmm3, XMMWORD [XMMBLOCK(6,0,edx,SIZEOF_FLOAT_MULT_TYPE)]
+
+    movaps      xmm4, xmm0
+    movaps      xmm5, xmm1
+    subps       xmm0, xmm2              ; xmm0=tmp11
+    subps       xmm1, xmm3
+    addps       xmm4, xmm2              ; xmm4=tmp10
+    addps       xmm5, xmm3              ; xmm5=tmp13
+
+    mulps       xmm1, [GOTOFF(ebx,PD_1_414)]
+    subps       xmm1, xmm5              ; xmm1=tmp12
+
+    movaps      xmm6, xmm4
+    movaps      xmm7, xmm0
+    subps       xmm4, xmm5              ; xmm4=tmp3
+    subps       xmm0, xmm1              ; xmm0=tmp2
+    addps       xmm6, xmm5              ; xmm6=tmp0
+    addps       xmm7, xmm1              ; xmm7=tmp1
+
+    movaps      XMMWORD [wk(1)], xmm4   ; tmp3
+    movaps      XMMWORD [wk(0)], xmm0   ; tmp2
+
+    ; -- Odd part
+
+    movq        mm4, MMWORD [MMBLOCK(1,0,esi,SIZEOF_JCOEF)]
+    movq        mm0, MMWORD [MMBLOCK(3,0,esi,SIZEOF_JCOEF)]
+    movq        mm5, MMWORD [MMBLOCK(5,0,esi,SIZEOF_JCOEF)]
+    movq        mm1, MMWORD [MMBLOCK(7,0,esi,SIZEOF_JCOEF)]
+
+    punpckhwd   mm6, mm4                ; mm6=(** 12 ** 13)
+    punpcklwd   mm4, mm4                ; mm4=(10 10 11 11)
+    punpckhwd   mm2, mm0                ; mm2=(** 32 ** 33)
+    punpcklwd   mm0, mm0                ; mm0=(30 30 31 31)
+
+    psrad       mm6, (DWORD_BIT-WORD_BIT)  ; mm6=in1H=(12 13)
+    psrad       mm4, (DWORD_BIT-WORD_BIT)  ; mm4=in1L=(10 11)
+    cvtpi2ps    xmm4, mm6                  ; xmm4=(12 13 ** **)
+    cvtpi2ps    xmm2, mm4                  ; xmm2=(10 11 ** **)
+    psrad       mm2, (DWORD_BIT-WORD_BIT)  ; mm2=in3H=(32 33)
+    psrad       mm0, (DWORD_BIT-WORD_BIT)  ; mm0=in3L=(30 31)
+    cvtpi2ps    xmm0, mm2                  ; xmm0=(32 33 ** **)
+    cvtpi2ps    xmm3, mm0                  ; xmm3=(30 31 ** **)
+
+    punpckhwd   mm7, mm5                ; mm7=(** 52 ** 53)
+    punpcklwd   mm5, mm5                ; mm5=(50 50 51 51)
+    punpckhwd   mm3, mm1                ; mm3=(** 72 ** 73)
+    punpcklwd   mm1, mm1                ; mm1=(70 70 71 71)
+
+    movlhps     xmm2, xmm4              ; xmm2=in1=(10 11 12 13)
+    movlhps     xmm3, xmm0              ; xmm3=in3=(30 31 32 33)
+
+    psrad       mm7, (DWORD_BIT-WORD_BIT)  ; mm7=in5H=(52 53)
+    psrad       mm5, (DWORD_BIT-WORD_BIT)  ; mm5=in5L=(50 51)
+    cvtpi2ps    xmm4, mm7                  ; xmm4=(52 53 ** **)
+    cvtpi2ps    xmm5, mm5                  ; xmm5=(50 51 ** **)
+    psrad       mm3, (DWORD_BIT-WORD_BIT)  ; mm3=in7H=(72 73)
+    psrad       mm1, (DWORD_BIT-WORD_BIT)  ; mm1=in7L=(70 71)
+    cvtpi2ps    xmm0, mm3                  ; xmm0=(72 73 ** **)
+    cvtpi2ps    xmm1, mm1                  ; xmm1=(70 71 ** **)
+
+    mulps       xmm2, XMMWORD [XMMBLOCK(1,0,edx,SIZEOF_FLOAT_MULT_TYPE)]
+    mulps       xmm3, XMMWORD [XMMBLOCK(3,0,edx,SIZEOF_FLOAT_MULT_TYPE)]
+
+    movlhps     xmm5, xmm4              ; xmm5=in5=(50 51 52 53)
+    movlhps     xmm1, xmm0              ; xmm1=in7=(70 71 72 73)
+    mulps       xmm5, XMMWORD [XMMBLOCK(5,0,edx,SIZEOF_FLOAT_MULT_TYPE)]
+    mulps       xmm1, XMMWORD [XMMBLOCK(7,0,edx,SIZEOF_FLOAT_MULT_TYPE)]
+
+    movaps      xmm4, xmm2
+    movaps      xmm0, xmm5
+    addps       xmm2, xmm1              ; xmm2=z11
+    addps       xmm5, xmm3              ; xmm5=z13
+    subps       xmm4, xmm1              ; xmm4=z12
+    subps       xmm0, xmm3              ; xmm0=z10
+
+    movaps      xmm1, xmm2
+    subps       xmm2, xmm5
+    addps       xmm1, xmm5              ; xmm1=tmp7
+
+    mulps       xmm2, [GOTOFF(ebx,PD_1_414)]  ; xmm2=tmp11
+
+    movaps      xmm3, xmm0
+    addps       xmm0, xmm4
+    mulps       xmm0, [GOTOFF(ebx,PD_1_847)]   ; xmm0=z5
+    mulps       xmm3, [GOTOFF(ebx,PD_M2_613)]  ; xmm3=(z10 * -2.613125930)
+    mulps       xmm4, [GOTOFF(ebx,PD_1_082)]   ; xmm4=(z12 * 1.082392200)
+    addps       xmm3, xmm0                     ; xmm3=tmp12
+    subps       xmm4, xmm0                     ; xmm4=tmp10
+
+    ; -- Final output stage
+
+    subps       xmm3, xmm1              ; xmm3=tmp6
+    movaps      xmm5, xmm6
+    movaps      xmm0, xmm7
+    addps       xmm6, xmm1              ; xmm6=data0=(00 01 02 03)
+    addps       xmm7, xmm3              ; xmm7=data1=(10 11 12 13)
+    subps       xmm5, xmm1              ; xmm5=data7=(70 71 72 73)
+    subps       xmm0, xmm3              ; xmm0=data6=(60 61 62 63)
+    subps       xmm2, xmm3              ; xmm2=tmp5
+
+    movaps      xmm1, xmm6              ; transpose coefficients(phase 1)
+    unpcklps    xmm6, xmm7              ; xmm6=(00 10 01 11)
+    unpckhps    xmm1, xmm7              ; xmm1=(02 12 03 13)
+    movaps      xmm3, xmm0              ; transpose coefficients(phase 1)
+    unpcklps    xmm0, xmm5              ; xmm0=(60 70 61 71)
+    unpckhps    xmm3, xmm5              ; xmm3=(62 72 63 73)
+
+    movaps      xmm7, XMMWORD [wk(0)]   ; xmm7=tmp2
+    movaps      xmm5, XMMWORD [wk(1)]   ; xmm5=tmp3
+
+    movaps      XMMWORD [wk(0)], xmm0   ; wk(0)=(60 70 61 71)
+    movaps      XMMWORD [wk(1)], xmm3   ; wk(1)=(62 72 63 73)
+
+    addps       xmm4, xmm2              ; xmm4=tmp4
+    movaps      xmm0, xmm7
+    movaps      xmm3, xmm5
+    addps       xmm7, xmm2              ; xmm7=data2=(20 21 22 23)
+    addps       xmm5, xmm4              ; xmm5=data4=(40 41 42 43)
+    subps       xmm0, xmm2              ; xmm0=data5=(50 51 52 53)
+    subps       xmm3, xmm4              ; xmm3=data3=(30 31 32 33)
+
+    movaps      xmm2, xmm7              ; transpose coefficients(phase 1)
+    unpcklps    xmm7, xmm3              ; xmm7=(20 30 21 31)
+    unpckhps    xmm2, xmm3              ; xmm2=(22 32 23 33)
+    movaps      xmm4, xmm5              ; transpose coefficients(phase 1)
+    unpcklps    xmm5, xmm0              ; xmm5=(40 50 41 51)
+    unpckhps    xmm4, xmm0              ; xmm4=(42 52 43 53)
+
+    movaps      xmm3, xmm6              ; transpose coefficients(phase 2)
+    unpcklps2   xmm6, xmm7              ; xmm6=(00 10 20 30)
+    unpckhps2   xmm3, xmm7              ; xmm3=(01 11 21 31)
+    movaps      xmm0, xmm1              ; transpose coefficients(phase 2)
+    unpcklps2   xmm1, xmm2              ; xmm1=(02 12 22 32)
+    unpckhps2   xmm0, xmm2              ; xmm0=(03 13 23 33)
+
+    movaps      xmm7, XMMWORD [wk(0)]   ; xmm7=(60 70 61 71)
+    movaps      xmm2, XMMWORD [wk(1)]   ; xmm2=(62 72 63 73)
+
+    movaps      XMMWORD [XMMBLOCK(0,0,edi,SIZEOF_FAST_FLOAT)], xmm6
+    movaps      XMMWORD [XMMBLOCK(1,0,edi,SIZEOF_FAST_FLOAT)], xmm3
+    movaps      XMMWORD [XMMBLOCK(2,0,edi,SIZEOF_FAST_FLOAT)], xmm1
+    movaps      XMMWORD [XMMBLOCK(3,0,edi,SIZEOF_FAST_FLOAT)], xmm0
+
+    movaps      xmm6, xmm5              ; transpose coefficients(phase 2)
+    unpcklps2   xmm5, xmm7              ; xmm5=(40 50 60 70)
+    unpckhps2   xmm6, xmm7              ; xmm6=(41 51 61 71)
+    movaps      xmm3, xmm4              ; transpose coefficients(phase 2)
+    unpcklps2   xmm4, xmm2              ; xmm4=(42 52 62 72)
+    unpckhps2   xmm3, xmm2              ; xmm3=(43 53 63 73)
+
+    movaps      XMMWORD [XMMBLOCK(0,1,edi,SIZEOF_FAST_FLOAT)], xmm5
+    movaps      XMMWORD [XMMBLOCK(1,1,edi,SIZEOF_FAST_FLOAT)], xmm6
+    movaps      XMMWORD [XMMBLOCK(2,1,edi,SIZEOF_FAST_FLOAT)], xmm4
+    movaps      XMMWORD [XMMBLOCK(3,1,edi,SIZEOF_FAST_FLOAT)], xmm3
+
+.nextcolumn:
+    add         esi, byte 4*SIZEOF_JCOEF               ; coef_block
+    add         edx, byte 4*SIZEOF_FLOAT_MULT_TYPE     ; quantptr
+    add         edi,      4*DCTSIZE*SIZEOF_FAST_FLOAT  ; wsptr
+    dec         ecx                                    ; ctr
+    jnz         near .columnloop
+
+    ; -- Prefetch the next coefficient block
+
+    prefetchnta [esi + (DCTSIZE2-8)*SIZEOF_JCOEF + 0*32]
+    prefetchnta [esi + (DCTSIZE2-8)*SIZEOF_JCOEF + 1*32]
+    prefetchnta [esi + (DCTSIZE2-8)*SIZEOF_JCOEF + 2*32]
+    prefetchnta [esi + (DCTSIZE2-8)*SIZEOF_JCOEF + 3*32]
+
+    ; ---- Pass 2: process rows from work array, store into output array.
+
+    mov         eax, [original_ebp]
+    lea         esi, [workspace]                   ; FAST_FLOAT *wsptr
+    mov         edi, JSAMPARRAY [output_buf(eax)]  ; (JSAMPROW *)
+    mov         eax, JDIMENSION [output_col(eax)]
+    mov         ecx, DCTSIZE/4                     ; ctr
+    alignx      16, 7
+.rowloop:
+
+    ; -- Even part
+
+    movaps      xmm0, XMMWORD [XMMBLOCK(0,0,esi,SIZEOF_FAST_FLOAT)]
+    movaps      xmm1, XMMWORD [XMMBLOCK(2,0,esi,SIZEOF_FAST_FLOAT)]
+    movaps      xmm2, XMMWORD [XMMBLOCK(4,0,esi,SIZEOF_FAST_FLOAT)]
+    movaps      xmm3, XMMWORD [XMMBLOCK(6,0,esi,SIZEOF_FAST_FLOAT)]
+
+    movaps      xmm4, xmm0
+    movaps      xmm5, xmm1
+    subps       xmm0, xmm2              ; xmm0=tmp11
+    subps       xmm1, xmm3
+    addps       xmm4, xmm2              ; xmm4=tmp10
+    addps       xmm5, xmm3              ; xmm5=tmp13
+
+    mulps       xmm1, [GOTOFF(ebx,PD_1_414)]
+    subps       xmm1, xmm5              ; xmm1=tmp12
+
+    movaps      xmm6, xmm4
+    movaps      xmm7, xmm0
+    subps       xmm4, xmm5              ; xmm4=tmp3
+    subps       xmm0, xmm1              ; xmm0=tmp2
+    addps       xmm6, xmm5              ; xmm6=tmp0
+    addps       xmm7, xmm1              ; xmm7=tmp1
+
+    movaps      XMMWORD [wk(1)], xmm4   ; tmp3
+    movaps      XMMWORD [wk(0)], xmm0   ; tmp2
+
+    ; -- Odd part
+
+    movaps      xmm2, XMMWORD [XMMBLOCK(1,0,esi,SIZEOF_FAST_FLOAT)]
+    movaps      xmm3, XMMWORD [XMMBLOCK(3,0,esi,SIZEOF_FAST_FLOAT)]
+    movaps      xmm5, XMMWORD [XMMBLOCK(5,0,esi,SIZEOF_FAST_FLOAT)]
+    movaps      xmm1, XMMWORD [XMMBLOCK(7,0,esi,SIZEOF_FAST_FLOAT)]
+
+    movaps      xmm4, xmm2
+    movaps      xmm0, xmm5
+    addps       xmm2, xmm1              ; xmm2=z11
+    addps       xmm5, xmm3              ; xmm5=z13
+    subps       xmm4, xmm1              ; xmm4=z12
+    subps       xmm0, xmm3              ; xmm0=z10
+
+    movaps      xmm1, xmm2
+    subps       xmm2, xmm5
+    addps       xmm1, xmm5              ; xmm1=tmp7
+
+    mulps       xmm2, [GOTOFF(ebx,PD_1_414)]  ; xmm2=tmp11
+
+    movaps      xmm3, xmm0
+    addps       xmm0, xmm4
+    mulps       xmm0, [GOTOFF(ebx,PD_1_847)]   ; xmm0=z5
+    mulps       xmm3, [GOTOFF(ebx,PD_M2_613)]  ; xmm3=(z10 * -2.613125930)
+    mulps       xmm4, [GOTOFF(ebx,PD_1_082)]   ; xmm4=(z12 * 1.082392200)
+    addps       xmm3, xmm0                     ; xmm3=tmp12
+    subps       xmm4, xmm0                     ; xmm4=tmp10
+
+    ; -- Final output stage
+
+    subps       xmm3, xmm1              ; xmm3=tmp6
+    movaps      xmm5, xmm6
+    movaps      xmm0, xmm7
+    addps       xmm6, xmm1              ; xmm6=data0=(00 10 20 30)
+    addps       xmm7, xmm3              ; xmm7=data1=(01 11 21 31)
+    subps       xmm5, xmm1              ; xmm5=data7=(07 17 27 37)
+    subps       xmm0, xmm3              ; xmm0=data6=(06 16 26 36)
+    subps       xmm2, xmm3              ; xmm2=tmp5
+
+    movaps      xmm1, [GOTOFF(ebx,PD_0_125)]  ; xmm1=[PD_0_125]
+
+    mulps       xmm6, xmm1              ; descale(1/8)
+    mulps       xmm7, xmm1              ; descale(1/8)
+    mulps       xmm5, xmm1              ; descale(1/8)
+    mulps       xmm0, xmm1              ; descale(1/8)
+
+    movhlps     xmm3, xmm6
+    movhlps     xmm1, xmm7
+    cvtps2pi    mm0, xmm6               ; round to int32, mm0=data0L=(00 10)
+    cvtps2pi    mm1, xmm7               ; round to int32, mm1=data1L=(01 11)
+    cvtps2pi    mm2, xmm3               ; round to int32, mm2=data0H=(20 30)
+    cvtps2pi    mm3, xmm1               ; round to int32, mm3=data1H=(21 31)
+    packssdw    mm0, mm2                ; mm0=data0=(00 10 20 30)
+    packssdw    mm1, mm3                ; mm1=data1=(01 11 21 31)
+
+    movhlps     xmm6, xmm5
+    movhlps     xmm7, xmm0
+    cvtps2pi    mm4, xmm5               ; round to int32, mm4=data7L=(07 17)
+    cvtps2pi    mm5, xmm0               ; round to int32, mm5=data6L=(06 16)
+    cvtps2pi    mm6, xmm6               ; round to int32, mm6=data7H=(27 37)
+    cvtps2pi    mm7, xmm7               ; round to int32, mm7=data6H=(26 36)
+    packssdw    mm4, mm6                ; mm4=data7=(07 17 27 37)
+    packssdw    mm5, mm7                ; mm5=data6=(06 16 26 36)
+
+    packsswb    mm0, mm5                ; mm0=(00 10 20 30 06 16 26 36)
+    packsswb    mm1, mm4                ; mm1=(01 11 21 31 07 17 27 37)
+
+    movaps      xmm3, XMMWORD [wk(0)]   ; xmm3=tmp2
+    movaps      xmm1, XMMWORD [wk(1)]   ; xmm1=tmp3
+
+    movaps      xmm6, [GOTOFF(ebx,PD_0_125)]  ; xmm6=[PD_0_125]
+
+    addps       xmm4, xmm2              ; xmm4=tmp4
+    movaps      xmm5, xmm3
+    movaps      xmm0, xmm1
+    addps       xmm3, xmm2              ; xmm3=data2=(02 12 22 32)
+    addps       xmm1, xmm4              ; xmm1=data4=(04 14 24 34)
+    subps       xmm5, xmm2              ; xmm5=data5=(05 15 25 35)
+    subps       xmm0, xmm4              ; xmm0=data3=(03 13 23 33)
+
+    mulps       xmm3, xmm6              ; descale(1/8)
+    mulps       xmm1, xmm6              ; descale(1/8)
+    mulps       xmm5, xmm6              ; descale(1/8)
+    mulps       xmm0, xmm6              ; descale(1/8)
+
+    movhlps     xmm7, xmm3
+    movhlps     xmm2, xmm1
+    cvtps2pi    mm2, xmm3               ; round to int32, mm2=data2L=(02 12)
+    cvtps2pi    mm3, xmm1               ; round to int32, mm3=data4L=(04 14)
+    cvtps2pi    mm6, xmm7               ; round to int32, mm6=data2H=(22 32)
+    cvtps2pi    mm7, xmm2               ; round to int32, mm7=data4H=(24 34)
+    packssdw    mm2, mm6                ; mm2=data2=(02 12 22 32)
+    packssdw    mm3, mm7                ; mm3=data4=(04 14 24 34)
+
+    movhlps     xmm4, xmm5
+    movhlps     xmm6, xmm0
+    cvtps2pi    mm5, xmm5               ; round to int32, mm5=data5L=(05 15)
+    cvtps2pi    mm4, xmm0               ; round to int32, mm4=data3L=(03 13)
+    cvtps2pi    mm6, xmm4               ; round to int32, mm6=data5H=(25 35)
+    cvtps2pi    mm7, xmm6               ; round to int32, mm7=data3H=(23 33)
+    packssdw    mm5, mm6                ; mm5=data5=(05 15 25 35)
+    packssdw    mm4, mm7                ; mm4=data3=(03 13 23 33)
+
+    movq        mm6, [GOTOFF(ebx,PB_CENTERJSAMP)]  ; mm6=[PB_CENTERJSAMP]
+
+    packsswb    mm2, mm3                ; mm2=(02 12 22 32 04 14 24 34)
+    packsswb    mm4, mm5                ; mm4=(03 13 23 33 05 15 25 35)
+
+    paddb       mm0, mm6
+    paddb       mm1, mm6
+    paddb       mm2, mm6
+    paddb       mm4, mm6
+
+    movq        mm7, mm0                ; transpose coefficients(phase 1)
+    punpcklbw   mm0, mm1                ; mm0=(00 01 10 11 20 21 30 31)
+    punpckhbw   mm7, mm1                ; mm7=(06 07 16 17 26 27 36 37)
+    movq        mm3, mm2                ; transpose coefficients(phase 1)
+    punpcklbw   mm2, mm4                ; mm2=(02 03 12 13 22 23 32 33)
+    punpckhbw   mm3, mm4                ; mm3=(04 05 14 15 24 25 34 35)
+
+    movq        mm5, mm0                ; transpose coefficients(phase 2)
+    punpcklwd   mm0, mm2                ; mm0=(00 01 02 03 10 11 12 13)
+    punpckhwd   mm5, mm2                ; mm5=(20 21 22 23 30 31 32 33)
+    movq        mm6, mm3                ; transpose coefficients(phase 2)
+    punpcklwd   mm3, mm7                ; mm3=(04 05 06 07 14 15 16 17)
+    punpckhwd   mm6, mm7                ; mm6=(24 25 26 27 34 35 36 37)
+
+    movq        mm1, mm0                ; transpose coefficients(phase 3)
+    punpckldq   mm0, mm3                ; mm0=(00 01 02 03 04 05 06 07)
+    punpckhdq   mm1, mm3                ; mm1=(10 11 12 13 14 15 16 17)
+    movq        mm4, mm5                ; transpose coefficients(phase 3)
+    punpckldq   mm5, mm6                ; mm5=(20 21 22 23 24 25 26 27)
+    punpckhdq   mm4, mm6                ; mm4=(30 31 32 33 34 35 36 37)
+
+    pushpic     ebx                     ; save GOT address
+
+    mov         edx, JSAMPROW [edi+0*SIZEOF_JSAMPROW]
+    mov         ebx, JSAMPROW [edi+1*SIZEOF_JSAMPROW]
+    movq        MMWORD [edx+eax*SIZEOF_JSAMPLE], mm0
+    movq        MMWORD [ebx+eax*SIZEOF_JSAMPLE], mm1
+    mov         edx, JSAMPROW [edi+2*SIZEOF_JSAMPROW]
+    mov         ebx, JSAMPROW [edi+3*SIZEOF_JSAMPROW]
+    movq        MMWORD [edx+eax*SIZEOF_JSAMPLE], mm5
+    movq        MMWORD [ebx+eax*SIZEOF_JSAMPLE], mm4
+
+    poppic      ebx                     ; restore GOT address
+
+    add         esi, byte 4*SIZEOF_FAST_FLOAT  ; wsptr
+    add         edi, byte 4*SIZEOF_JSAMPROW
+    dec         ecx                            ; ctr
+    jnz         near .rowloop
+
+    emms                                ; empty MMX state
+
+    pop         edi
+    pop         esi
+;   pop         edx                     ; need not be preserved
+;   pop         ecx                     ; need not be preserved
+    pop         ebx
+    mov         esp, ebp                ; esp <- aligned ebp
+    pop         esp                     ; esp <- original ebp
+    pop         ebp
+    ret
+
+; For some reason, the OS X linker does not honor the request to align the
+; segment unless we do this.
+    align       32
diff --git a/3rdparty/libjpeg/src/simd/i386/jidctflt-sse2.asm b/3rdparty/libjpeg/src/simd/i386/jidctflt-sse2.asm
new file mode 100644
index 00000000..c646eaef
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/i386/jidctflt-sse2.asm
@@ -0,0 +1,497 @@
+;
+; jidctflt.asm - floating-point IDCT (SSE & SSE2)
+;
+; Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+; Copyright (C) 2016, D. R. Commander.
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+;
+; This file should be assembled with NASM (Netwide Assembler),
+; can *not* be assembled with Microsoft's MASM or any compatible
+; assembler (including Borland's Turbo Assembler).
+; NASM is available from http://nasm.sourceforge.net/ or
+; http://sourceforge.net/project/showfiles.php?group_id=6208
+;
+; This file contains a floating-point implementation of the inverse DCT
+; (Discrete Cosine Transform). The following code is based directly on
+; the IJG's original jidctflt.c; see the jidctflt.c for more details.
+
+%include "jsimdext.inc"
+%include "jdct.inc"
+
+; --------------------------------------------------------------------------
+
+%macro unpcklps2 2  ; %1=(0 1 2 3) / %2=(4 5 6 7) => %1=(0 1 4 5)
+    shufps      %1, %2, 0x44
+%endmacro
+
+%macro unpckhps2 2  ; %1=(0 1 2 3) / %2=(4 5 6 7) => %1=(2 3 6 7)
+    shufps      %1, %2, 0xEE
+%endmacro
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_CONST
+
+    alignz      32
+    GLOBAL_DATA(jconst_idct_float_sse2)
+
+EXTN(jconst_idct_float_sse2):
+
+PD_1_414        times 4  dd  1.414213562373095048801689
+PD_1_847        times 4  dd  1.847759065022573512256366
+PD_1_082        times 4  dd  1.082392200292393968799446
+PD_M2_613       times 4  dd -2.613125929752753055713286
+PD_RNDINT_MAGIC times 4  dd  100663296.0  ; (float)(0x00C00000 << 3)
+PB_CENTERJSAMP  times 16 db  CENTERJSAMPLE
+
+    alignz      32
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_TEXT
+    BITS        32
+;
+; Perform dequantization and inverse DCT on one block of coefficients.
+;
+; GLOBAL(void)
+; jsimd_idct_float_sse2(void *dct_table, JCOEFPTR coef_block,
+;                       JSAMPARRAY output_buf, JDIMENSION output_col)
+;
+
+%define dct_table(b)   (b) + 8          ; void *dct_table
+%define coef_block(b)  (b) + 12         ; JCOEFPTR coef_block
+%define output_buf(b)  (b) + 16         ; JSAMPARRAY output_buf
+%define output_col(b)  (b) + 20         ; JDIMENSION output_col
+
+%define original_ebp   ebp + 0
+%define wk(i)          ebp - (WK_NUM - (i)) * SIZEOF_XMMWORD
+                                        ; xmmword wk[WK_NUM]
+%define WK_NUM         2
+%define workspace      wk(0) - DCTSIZE2 * SIZEOF_FAST_FLOAT
+                                        ; FAST_FLOAT workspace[DCTSIZE2]
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_idct_float_sse2)
+
+EXTN(jsimd_idct_float_sse2):
+    push        ebp
+    mov         eax, esp                     ; eax = original ebp
+    sub         esp, byte 4
+    and         esp, byte (-SIZEOF_XMMWORD)  ; align to 128 bits
+    mov         [esp], eax
+    mov         ebp, esp                     ; ebp = aligned ebp
+    lea         esp, [workspace]
+    push        ebx
+;   push        ecx                     ; need not be preserved
+;   push        edx                     ; need not be preserved
+    push        esi
+    push        edi
+
+    get_GOT     ebx                     ; get GOT address
+
+    ; ---- Pass 1: process columns from input, store into work array.
+
+;   mov         eax, [original_ebp]
+    mov         edx, POINTER [dct_table(eax)]    ; quantptr
+    mov         esi, JCOEFPTR [coef_block(eax)]  ; inptr
+    lea         edi, [workspace]                 ; FAST_FLOAT *wsptr
+    mov         ecx, DCTSIZE/4                   ; ctr
+    alignx      16, 7
+.columnloop:
+%ifndef NO_ZERO_COLUMN_TEST_FLOAT_SSE
+    mov         eax, dword [DWBLOCK(1,0,esi,SIZEOF_JCOEF)]
+    or          eax, dword [DWBLOCK(2,0,esi,SIZEOF_JCOEF)]
+    jnz         near .columnDCT
+
+    movq        xmm1, XMM_MMWORD [MMBLOCK(1,0,esi,SIZEOF_JCOEF)]
+    movq        xmm2, XMM_MMWORD [MMBLOCK(2,0,esi,SIZEOF_JCOEF)]
+    movq        xmm3, XMM_MMWORD [MMBLOCK(3,0,esi,SIZEOF_JCOEF)]
+    movq        xmm4, XMM_MMWORD [MMBLOCK(4,0,esi,SIZEOF_JCOEF)]
+    movq        xmm5, XMM_MMWORD [MMBLOCK(5,0,esi,SIZEOF_JCOEF)]
+    movq        xmm6, XMM_MMWORD [MMBLOCK(6,0,esi,SIZEOF_JCOEF)]
+    movq        xmm7, XMM_MMWORD [MMBLOCK(7,0,esi,SIZEOF_JCOEF)]
+    por         xmm1, xmm2
+    por         xmm3, xmm4
+    por         xmm5, xmm6
+    por         xmm1, xmm3
+    por         xmm5, xmm7
+    por         xmm1, xmm5
+    packsswb    xmm1, xmm1
+    movd        eax, xmm1
+    test        eax, eax
+    jnz         short .columnDCT
+
+    ; -- AC terms all zero
+
+    movq        xmm0, XMM_MMWORD [MMBLOCK(0,0,esi,SIZEOF_JCOEF)]
+
+    punpcklwd   xmm0, xmm0                  ; xmm0=(00 00 01 01 02 02 03 03)
+    psrad       xmm0, (DWORD_BIT-WORD_BIT)  ; xmm0=in0=(00 01 02 03)
+    cvtdq2ps    xmm0, xmm0                  ; xmm0=in0=(00 01 02 03)
+
+    mulps       xmm0, XMMWORD [XMMBLOCK(0,0,edx,SIZEOF_FLOAT_MULT_TYPE)]
+
+    movaps      xmm1, xmm0
+    movaps      xmm2, xmm0
+    movaps      xmm3, xmm0
+
+    shufps      xmm0, xmm0, 0x00        ; xmm0=(00 00 00 00)
+    shufps      xmm1, xmm1, 0x55        ; xmm1=(01 01 01 01)
+    shufps      xmm2, xmm2, 0xAA        ; xmm2=(02 02 02 02)
+    shufps      xmm3, xmm3, 0xFF        ; xmm3=(03 03 03 03)
+
+    movaps      XMMWORD [XMMBLOCK(0,0,edi,SIZEOF_FAST_FLOAT)], xmm0
+    movaps      XMMWORD [XMMBLOCK(0,1,edi,SIZEOF_FAST_FLOAT)], xmm0
+    movaps      XMMWORD [XMMBLOCK(1,0,edi,SIZEOF_FAST_FLOAT)], xmm1
+    movaps      XMMWORD [XMMBLOCK(1,1,edi,SIZEOF_FAST_FLOAT)], xmm1
+    movaps      XMMWORD [XMMBLOCK(2,0,edi,SIZEOF_FAST_FLOAT)], xmm2
+    movaps      XMMWORD [XMMBLOCK(2,1,edi,SIZEOF_FAST_FLOAT)], xmm2
+    movaps      XMMWORD [XMMBLOCK(3,0,edi,SIZEOF_FAST_FLOAT)], xmm3
+    movaps      XMMWORD [XMMBLOCK(3,1,edi,SIZEOF_FAST_FLOAT)], xmm3
+    jmp         near .nextcolumn
+    alignx      16, 7
+%endif
+.columnDCT:
+
+    ; -- Even part
+
+    movq        xmm0, XMM_MMWORD [MMBLOCK(0,0,esi,SIZEOF_JCOEF)]
+    movq        xmm1, XMM_MMWORD [MMBLOCK(2,0,esi,SIZEOF_JCOEF)]
+    movq        xmm2, XMM_MMWORD [MMBLOCK(4,0,esi,SIZEOF_JCOEF)]
+    movq        xmm3, XMM_MMWORD [MMBLOCK(6,0,esi,SIZEOF_JCOEF)]
+
+    punpcklwd   xmm0, xmm0                  ; xmm0=(00 00 01 01 02 02 03 03)
+    punpcklwd   xmm1, xmm1                  ; xmm1=(20 20 21 21 22 22 23 23)
+    psrad       xmm0, (DWORD_BIT-WORD_BIT)  ; xmm0=in0=(00 01 02 03)
+    psrad       xmm1, (DWORD_BIT-WORD_BIT)  ; xmm1=in2=(20 21 22 23)
+    cvtdq2ps    xmm0, xmm0                  ; xmm0=in0=(00 01 02 03)
+    cvtdq2ps    xmm1, xmm1                  ; xmm1=in2=(20 21 22 23)
+
+    punpcklwd   xmm2, xmm2                  ; xmm2=(40 40 41 41 42 42 43 43)
+    punpcklwd   xmm3, xmm3                  ; xmm3=(60 60 61 61 62 62 63 63)
+    psrad       xmm2, (DWORD_BIT-WORD_BIT)  ; xmm2=in4=(40 41 42 43)
+    psrad       xmm3, (DWORD_BIT-WORD_BIT)  ; xmm3=in6=(60 61 62 63)
+    cvtdq2ps    xmm2, xmm2                  ; xmm2=in4=(40 41 42 43)
+    cvtdq2ps    xmm3, xmm3                  ; xmm3=in6=(60 61 62 63)
+
+    mulps       xmm0, XMMWORD [XMMBLOCK(0,0,edx,SIZEOF_FLOAT_MULT_TYPE)]
+    mulps       xmm1, XMMWORD [XMMBLOCK(2,0,edx,SIZEOF_FLOAT_MULT_TYPE)]
+    mulps       xmm2, XMMWORD [XMMBLOCK(4,0,edx,SIZEOF_FLOAT_MULT_TYPE)]
+    mulps       xmm3, XMMWORD [XMMBLOCK(6,0,edx,SIZEOF_FLOAT_MULT_TYPE)]
+
+    movaps      xmm4, xmm0
+    movaps      xmm5, xmm1
+    subps       xmm0, xmm2              ; xmm0=tmp11
+    subps       xmm1, xmm3
+    addps       xmm4, xmm2              ; xmm4=tmp10
+    addps       xmm5, xmm3              ; xmm5=tmp13
+
+    mulps       xmm1, [GOTOFF(ebx,PD_1_414)]
+    subps       xmm1, xmm5              ; xmm1=tmp12
+
+    movaps      xmm6, xmm4
+    movaps      xmm7, xmm0
+    subps       xmm4, xmm5              ; xmm4=tmp3
+    subps       xmm0, xmm1              ; xmm0=tmp2
+    addps       xmm6, xmm5              ; xmm6=tmp0
+    addps       xmm7, xmm1              ; xmm7=tmp1
+
+    movaps      XMMWORD [wk(1)], xmm4   ; tmp3
+    movaps      XMMWORD [wk(0)], xmm0   ; tmp2
+
+    ; -- Odd part
+
+    movq        xmm2, XMM_MMWORD [MMBLOCK(1,0,esi,SIZEOF_JCOEF)]
+    movq        xmm3, XMM_MMWORD [MMBLOCK(3,0,esi,SIZEOF_JCOEF)]
+    movq        xmm5, XMM_MMWORD [MMBLOCK(5,0,esi,SIZEOF_JCOEF)]
+    movq        xmm1, XMM_MMWORD [MMBLOCK(7,0,esi,SIZEOF_JCOEF)]
+
+    punpcklwd   xmm2, xmm2                  ; xmm2=(10 10 11 11 12 12 13 13)
+    punpcklwd   xmm3, xmm3                  ; xmm3=(30 30 31 31 32 32 33 33)
+    psrad       xmm2, (DWORD_BIT-WORD_BIT)  ; xmm2=in1=(10 11 12 13)
+    psrad       xmm3, (DWORD_BIT-WORD_BIT)  ; xmm3=in3=(30 31 32 33)
+    cvtdq2ps    xmm2, xmm2                  ; xmm2=in1=(10 11 12 13)
+    cvtdq2ps    xmm3, xmm3                  ; xmm3=in3=(30 31 32 33)
+
+    punpcklwd   xmm5, xmm5                  ; xmm5=(50 50 51 51 52 52 53 53)
+    punpcklwd   xmm1, xmm1                  ; xmm1=(70 70 71 71 72 72 73 73)
+    psrad       xmm5, (DWORD_BIT-WORD_BIT)  ; xmm5=in5=(50 51 52 53)
+    psrad       xmm1, (DWORD_BIT-WORD_BIT)  ; xmm1=in7=(70 71 72 73)
+    cvtdq2ps    xmm5, xmm5                  ; xmm5=in5=(50 51 52 53)
+    cvtdq2ps    xmm1, xmm1                  ; xmm1=in7=(70 71 72 73)
+
+    mulps       xmm2, XMMWORD [XMMBLOCK(1,0,edx,SIZEOF_FLOAT_MULT_TYPE)]
+    mulps       xmm3, XMMWORD [XMMBLOCK(3,0,edx,SIZEOF_FLOAT_MULT_TYPE)]
+    mulps       xmm5, XMMWORD [XMMBLOCK(5,0,edx,SIZEOF_FLOAT_MULT_TYPE)]
+    mulps       xmm1, XMMWORD [XMMBLOCK(7,0,edx,SIZEOF_FLOAT_MULT_TYPE)]
+
+    movaps      xmm4, xmm2
+    movaps      xmm0, xmm5
+    addps       xmm2, xmm1              ; xmm2=z11
+    addps       xmm5, xmm3              ; xmm5=z13
+    subps       xmm4, xmm1              ; xmm4=z12
+    subps       xmm0, xmm3              ; xmm0=z10
+
+    movaps      xmm1, xmm2
+    subps       xmm2, xmm5
+    addps       xmm1, xmm5              ; xmm1=tmp7
+
+    mulps       xmm2, [GOTOFF(ebx,PD_1_414)]  ; xmm2=tmp11
+
+    movaps      xmm3, xmm0
+    addps       xmm0, xmm4
+    mulps       xmm0, [GOTOFF(ebx,PD_1_847)]   ; xmm0=z5
+    mulps       xmm3, [GOTOFF(ebx,PD_M2_613)]  ; xmm3=(z10 * -2.613125930)
+    mulps       xmm4, [GOTOFF(ebx,PD_1_082)]   ; xmm4=(z12 * 1.082392200)
+    addps       xmm3, xmm0                     ; xmm3=tmp12
+    subps       xmm4, xmm0                     ; xmm4=tmp10
+
+    ; -- Final output stage
+
+    subps       xmm3, xmm1              ; xmm3=tmp6
+    movaps      xmm5, xmm6
+    movaps      xmm0, xmm7
+    addps       xmm6, xmm1              ; xmm6=data0=(00 01 02 03)
+    addps       xmm7, xmm3              ; xmm7=data1=(10 11 12 13)
+    subps       xmm5, xmm1              ; xmm5=data7=(70 71 72 73)
+    subps       xmm0, xmm3              ; xmm0=data6=(60 61 62 63)
+    subps       xmm2, xmm3              ; xmm2=tmp5
+
+    movaps      xmm1, xmm6              ; transpose coefficients(phase 1)
+    unpcklps    xmm6, xmm7              ; xmm6=(00 10 01 11)
+    unpckhps    xmm1, xmm7              ; xmm1=(02 12 03 13)
+    movaps      xmm3, xmm0              ; transpose coefficients(phase 1)
+    unpcklps    xmm0, xmm5              ; xmm0=(60 70 61 71)
+    unpckhps    xmm3, xmm5              ; xmm3=(62 72 63 73)
+
+    movaps      xmm7, XMMWORD [wk(0)]   ; xmm7=tmp2
+    movaps      xmm5, XMMWORD [wk(1)]   ; xmm5=tmp3
+
+    movaps      XMMWORD [wk(0)], xmm0   ; wk(0)=(60 70 61 71)
+    movaps      XMMWORD [wk(1)], xmm3   ; wk(1)=(62 72 63 73)
+
+    addps       xmm4, xmm2              ; xmm4=tmp4
+    movaps      xmm0, xmm7
+    movaps      xmm3, xmm5
+    addps       xmm7, xmm2              ; xmm7=data2=(20 21 22 23)
+    addps       xmm5, xmm4              ; xmm5=data4=(40 41 42 43)
+    subps       xmm0, xmm2              ; xmm0=data5=(50 51 52 53)
+    subps       xmm3, xmm4              ; xmm3=data3=(30 31 32 33)
+
+    movaps      xmm2, xmm7              ; transpose coefficients(phase 1)
+    unpcklps    xmm7, xmm3              ; xmm7=(20 30 21 31)
+    unpckhps    xmm2, xmm3              ; xmm2=(22 32 23 33)
+    movaps      xmm4, xmm5              ; transpose coefficients(phase 1)
+    unpcklps    xmm5, xmm0              ; xmm5=(40 50 41 51)
+    unpckhps    xmm4, xmm0              ; xmm4=(42 52 43 53)
+
+    movaps      xmm3, xmm6              ; transpose coefficients(phase 2)
+    unpcklps2   xmm6, xmm7              ; xmm6=(00 10 20 30)
+    unpckhps2   xmm3, xmm7              ; xmm3=(01 11 21 31)
+    movaps      xmm0, xmm1              ; transpose coefficients(phase 2)
+    unpcklps2   xmm1, xmm2              ; xmm1=(02 12 22 32)
+    unpckhps2   xmm0, xmm2              ; xmm0=(03 13 23 33)
+
+    movaps      xmm7, XMMWORD [wk(0)]   ; xmm7=(60 70 61 71)
+    movaps      xmm2, XMMWORD [wk(1)]   ; xmm2=(62 72 63 73)
+
+    movaps      XMMWORD [XMMBLOCK(0,0,edi,SIZEOF_FAST_FLOAT)], xmm6
+    movaps      XMMWORD [XMMBLOCK(1,0,edi,SIZEOF_FAST_FLOAT)], xmm3
+    movaps      XMMWORD [XMMBLOCK(2,0,edi,SIZEOF_FAST_FLOAT)], xmm1
+    movaps      XMMWORD [XMMBLOCK(3,0,edi,SIZEOF_FAST_FLOAT)], xmm0
+
+    movaps      xmm6, xmm5              ; transpose coefficients(phase 2)
+    unpcklps2   xmm5, xmm7              ; xmm5=(40 50 60 70)
+    unpckhps2   xmm6, xmm7              ; xmm6=(41 51 61 71)
+    movaps      xmm3, xmm4              ; transpose coefficients(phase 2)
+    unpcklps2   xmm4, xmm2              ; xmm4=(42 52 62 72)
+    unpckhps2   xmm3, xmm2              ; xmm3=(43 53 63 73)
+
+    movaps      XMMWORD [XMMBLOCK(0,1,edi,SIZEOF_FAST_FLOAT)], xmm5
+    movaps      XMMWORD [XMMBLOCK(1,1,edi,SIZEOF_FAST_FLOAT)], xmm6
+    movaps      XMMWORD [XMMBLOCK(2,1,edi,SIZEOF_FAST_FLOAT)], xmm4
+    movaps      XMMWORD [XMMBLOCK(3,1,edi,SIZEOF_FAST_FLOAT)], xmm3
+
+.nextcolumn:
+    add         esi, byte 4*SIZEOF_JCOEF               ; coef_block
+    add         edx, byte 4*SIZEOF_FLOAT_MULT_TYPE     ; quantptr
+    add         edi,      4*DCTSIZE*SIZEOF_FAST_FLOAT  ; wsptr
+    dec         ecx                                    ; ctr
+    jnz         near .columnloop
+
+    ; -- Prefetch the next coefficient block
+
+    prefetchnta [esi + (DCTSIZE2-8)*SIZEOF_JCOEF + 0*32]
+    prefetchnta [esi + (DCTSIZE2-8)*SIZEOF_JCOEF + 1*32]
+    prefetchnta [esi + (DCTSIZE2-8)*SIZEOF_JCOEF + 2*32]
+    prefetchnta [esi + (DCTSIZE2-8)*SIZEOF_JCOEF + 3*32]
+
+    ; ---- Pass 2: process rows from work array, store into output array.
+
+    mov         eax, [original_ebp]
+    lea         esi, [workspace]                   ; FAST_FLOAT *wsptr
+    mov         edi, JSAMPARRAY [output_buf(eax)]  ; (JSAMPROW *)
+    mov         eax, JDIMENSION [output_col(eax)]
+    mov         ecx, DCTSIZE/4                     ; ctr
+    alignx      16, 7
+.rowloop:
+
+    ; -- Even part
+
+    movaps      xmm0, XMMWORD [XMMBLOCK(0,0,esi,SIZEOF_FAST_FLOAT)]
+    movaps      xmm1, XMMWORD [XMMBLOCK(2,0,esi,SIZEOF_FAST_FLOAT)]
+    movaps      xmm2, XMMWORD [XMMBLOCK(4,0,esi,SIZEOF_FAST_FLOAT)]
+    movaps      xmm3, XMMWORD [XMMBLOCK(6,0,esi,SIZEOF_FAST_FLOAT)]
+
+    movaps      xmm4, xmm0
+    movaps      xmm5, xmm1
+    subps       xmm0, xmm2              ; xmm0=tmp11
+    subps       xmm1, xmm3
+    addps       xmm4, xmm2              ; xmm4=tmp10
+    addps       xmm5, xmm3              ; xmm5=tmp13
+
+    mulps       xmm1, [GOTOFF(ebx,PD_1_414)]
+    subps       xmm1, xmm5              ; xmm1=tmp12
+
+    movaps      xmm6, xmm4
+    movaps      xmm7, xmm0
+    subps       xmm4, xmm5              ; xmm4=tmp3
+    subps       xmm0, xmm1              ; xmm0=tmp2
+    addps       xmm6, xmm5              ; xmm6=tmp0
+    addps       xmm7, xmm1              ; xmm7=tmp1
+
+    movaps      XMMWORD [wk(1)], xmm4   ; tmp3
+    movaps      XMMWORD [wk(0)], xmm0   ; tmp2
+
+    ; -- Odd part
+
+    movaps      xmm2, XMMWORD [XMMBLOCK(1,0,esi,SIZEOF_FAST_FLOAT)]
+    movaps      xmm3, XMMWORD [XMMBLOCK(3,0,esi,SIZEOF_FAST_FLOAT)]
+    movaps      xmm5, XMMWORD [XMMBLOCK(5,0,esi,SIZEOF_FAST_FLOAT)]
+    movaps      xmm1, XMMWORD [XMMBLOCK(7,0,esi,SIZEOF_FAST_FLOAT)]
+
+    movaps      xmm4, xmm2
+    movaps      xmm0, xmm5
+    addps       xmm2, xmm1              ; xmm2=z11
+    addps       xmm5, xmm3              ; xmm5=z13
+    subps       xmm4, xmm1              ; xmm4=z12
+    subps       xmm0, xmm3              ; xmm0=z10
+
+    movaps      xmm1, xmm2
+    subps       xmm2, xmm5
+    addps       xmm1, xmm5              ; xmm1=tmp7
+
+    mulps       xmm2, [GOTOFF(ebx,PD_1_414)]  ; xmm2=tmp11
+
+    movaps      xmm3, xmm0
+    addps       xmm0, xmm4
+    mulps       xmm0, [GOTOFF(ebx,PD_1_847)]   ; xmm0=z5
+    mulps       xmm3, [GOTOFF(ebx,PD_M2_613)]  ; xmm3=(z10 * -2.613125930)
+    mulps       xmm4, [GOTOFF(ebx,PD_1_082)]   ; xmm4=(z12 * 1.082392200)
+    addps       xmm3, xmm0                     ; xmm3=tmp12
+    subps       xmm4, xmm0                     ; xmm4=tmp10
+
+    ; -- Final output stage
+
+    subps       xmm3, xmm1              ; xmm3=tmp6
+    movaps      xmm5, xmm6
+    movaps      xmm0, xmm7
+    addps       xmm6, xmm1              ; xmm6=data0=(00 10 20 30)
+    addps       xmm7, xmm3              ; xmm7=data1=(01 11 21 31)
+    subps       xmm5, xmm1              ; xmm5=data7=(07 17 27 37)
+    subps       xmm0, xmm3              ; xmm0=data6=(06 16 26 36)
+    subps       xmm2, xmm3              ; xmm2=tmp5
+
+    movaps      xmm1, [GOTOFF(ebx,PD_RNDINT_MAGIC)]  ; xmm1=[PD_RNDINT_MAGIC]
+    pcmpeqd     xmm3, xmm3
+    psrld       xmm3, WORD_BIT          ; xmm3={0xFFFF 0x0000 0xFFFF 0x0000 ..}
+
+    addps       xmm6, xmm1              ; xmm6=roundint(data0/8)=(00 ** 10 ** 20 ** 30 **)
+    addps       xmm7, xmm1              ; xmm7=roundint(data1/8)=(01 ** 11 ** 21 ** 31 **)
+    addps       xmm0, xmm1              ; xmm0=roundint(data6/8)=(06 ** 16 ** 26 ** 36 **)
+    addps       xmm5, xmm1              ; xmm5=roundint(data7/8)=(07 ** 17 ** 27 ** 37 **)
+
+    pand        xmm6, xmm3              ; xmm6=(00 -- 10 -- 20 -- 30 --)
+    pslld       xmm7, WORD_BIT          ; xmm7=(-- 01 -- 11 -- 21 -- 31)
+    pand        xmm0, xmm3              ; xmm0=(06 -- 16 -- 26 -- 36 --)
+    pslld       xmm5, WORD_BIT          ; xmm5=(-- 07 -- 17 -- 27 -- 37)
+    por         xmm6, xmm7              ; xmm6=(00 01 10 11 20 21 30 31)
+    por         xmm0, xmm5              ; xmm0=(06 07 16 17 26 27 36 37)
+
+    movaps      xmm1, XMMWORD [wk(0)]   ; xmm1=tmp2
+    movaps      xmm3, XMMWORD [wk(1)]   ; xmm3=tmp3
+
+    addps       xmm4, xmm2              ; xmm4=tmp4
+    movaps      xmm7, xmm1
+    movaps      xmm5, xmm3
+    addps       xmm1, xmm2              ; xmm1=data2=(02 12 22 32)
+    addps       xmm3, xmm4              ; xmm3=data4=(04 14 24 34)
+    subps       xmm7, xmm2              ; xmm7=data5=(05 15 25 35)
+    subps       xmm5, xmm4              ; xmm5=data3=(03 13 23 33)
+
+    movaps      xmm2, [GOTOFF(ebx,PD_RNDINT_MAGIC)]  ; xmm2=[PD_RNDINT_MAGIC]
+    pcmpeqd     xmm4, xmm4
+    psrld       xmm4, WORD_BIT          ; xmm4={0xFFFF 0x0000 0xFFFF 0x0000 ..}
+
+    addps       xmm3, xmm2              ; xmm3=roundint(data4/8)=(04 ** 14 ** 24 ** 34 **)
+    addps       xmm7, xmm2              ; xmm7=roundint(data5/8)=(05 ** 15 ** 25 ** 35 **)
+    addps       xmm1, xmm2              ; xmm1=roundint(data2/8)=(02 ** 12 ** 22 ** 32 **)
+    addps       xmm5, xmm2              ; xmm5=roundint(data3/8)=(03 ** 13 ** 23 ** 33 **)
+
+    pand        xmm3, xmm4              ; xmm3=(04 -- 14 -- 24 -- 34 --)
+    pslld       xmm7, WORD_BIT          ; xmm7=(-- 05 -- 15 -- 25 -- 35)
+    pand        xmm1, xmm4              ; xmm1=(02 -- 12 -- 22 -- 32 --)
+    pslld       xmm5, WORD_BIT          ; xmm5=(-- 03 -- 13 -- 23 -- 33)
+    por         xmm3, xmm7              ; xmm3=(04 05 14 15 24 25 34 35)
+    por         xmm1, xmm5              ; xmm1=(02 03 12 13 22 23 32 33)
+
+    movdqa      xmm2, [GOTOFF(ebx,PB_CENTERJSAMP)]  ; xmm2=[PB_CENTERJSAMP]
+
+    packsswb    xmm6, xmm3        ; xmm6=(00 01 10 11 20 21 30 31 04 05 14 15 24 25 34 35)
+    packsswb    xmm1, xmm0        ; xmm1=(02 03 12 13 22 23 32 33 06 07 16 17 26 27 36 37)
+    paddb       xmm6, xmm2
+    paddb       xmm1, xmm2
+
+    movdqa      xmm4, xmm6        ; transpose coefficients(phase 2)
+    punpcklwd   xmm6, xmm1        ; xmm6=(00 01 02 03 10 11 12 13 20 21 22 23 30 31 32 33)
+    punpckhwd   xmm4, xmm1        ; xmm4=(04 05 06 07 14 15 16 17 24 25 26 27 34 35 36 37)
+
+    movdqa      xmm7, xmm6        ; transpose coefficients(phase 3)
+    punpckldq   xmm6, xmm4        ; xmm6=(00 01 02 03 04 05 06 07 10 11 12 13 14 15 16 17)
+    punpckhdq   xmm7, xmm4        ; xmm7=(20 21 22 23 24 25 26 27 30 31 32 33 34 35 36 37)
+
+    pshufd      xmm5, xmm6, 0x4E  ; xmm5=(10 11 12 13 14 15 16 17 00 01 02 03 04 05 06 07)
+    pshufd      xmm3, xmm7, 0x4E  ; xmm3=(30 31 32 33 34 35 36 37 20 21 22 23 24 25 26 27)
+
+    pushpic     ebx                     ; save GOT address
+
+    mov         edx, JSAMPROW [edi+0*SIZEOF_JSAMPROW]
+    mov         ebx, JSAMPROW [edi+2*SIZEOF_JSAMPROW]
+    movq        XMM_MMWORD [edx+eax*SIZEOF_JSAMPLE], xmm6
+    movq        XMM_MMWORD [ebx+eax*SIZEOF_JSAMPLE], xmm7
+    mov         edx, JSAMPROW [edi+1*SIZEOF_JSAMPROW]
+    mov         ebx, JSAMPROW [edi+3*SIZEOF_JSAMPROW]
+    movq        XMM_MMWORD [edx+eax*SIZEOF_JSAMPLE], xmm5
+    movq        XMM_MMWORD [ebx+eax*SIZEOF_JSAMPLE], xmm3
+
+    poppic      ebx                     ; restore GOT address
+
+    add         esi, byte 4*SIZEOF_FAST_FLOAT  ; wsptr
+    add         edi, byte 4*SIZEOF_JSAMPROW
+    dec         ecx                            ; ctr
+    jnz         near .rowloop
+
+    pop         edi
+    pop         esi
+;   pop         edx                     ; need not be preserved
+;   pop         ecx                     ; need not be preserved
+    pop         ebx
+    mov         esp, ebp                ; esp <- aligned ebp
+    pop         esp                     ; esp <- original ebp
+    pop         ebp
+    ret
+
+; For some reason, the OS X linker does not honor the request to align the
+; segment unless we do this.
+    align       32
diff --git a/3rdparty/libjpeg/src/simd/i386/jidctfst-mmx.asm b/3rdparty/libjpeg/src/simd/i386/jidctfst-mmx.asm
new file mode 100644
index 00000000..24622d43
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/i386/jidctfst-mmx.asm
@@ -0,0 +1,499 @@
+;
+; jidctfst.asm - fast integer IDCT (MMX)
+;
+; Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+; Copyright (C) 2016, D. R. Commander.
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+;
+; This file should be assembled with NASM (Netwide Assembler),
+; can *not* be assembled with Microsoft's MASM or any compatible
+; assembler (including Borland's Turbo Assembler).
+; NASM is available from http://nasm.sourceforge.net/ or
+; http://sourceforge.net/project/showfiles.php?group_id=6208
+;
+; This file contains a fast, not so accurate integer implementation of
+; the inverse DCT (Discrete Cosine Transform). The following code is
+; based directly on the IJG's original jidctfst.c; see the jidctfst.c
+; for more details.
+
+%include "jsimdext.inc"
+%include "jdct.inc"
+
+; --------------------------------------------------------------------------
+
+%define CONST_BITS  8  ; 14 is also OK.
+%define PASS1_BITS  2
+
+%if IFAST_SCALE_BITS != PASS1_BITS
+%error "'IFAST_SCALE_BITS' must be equal to 'PASS1_BITS'."
+%endif
+
+%if CONST_BITS == 8
+F_1_082 equ 277              ; FIX(1.082392200)
+F_1_414 equ 362              ; FIX(1.414213562)
+F_1_847 equ 473              ; FIX(1.847759065)
+F_2_613 equ 669              ; FIX(2.613125930)
+F_1_613 equ (F_2_613 - 256)  ; FIX(2.613125930) - FIX(1)
+%else
+; NASM cannot do compile-time arithmetic on floating-point constants.
+%define DESCALE(x, n)  (((x) + (1 << ((n) - 1))) >> (n))
+F_1_082 equ DESCALE(1162209775, 30 - CONST_BITS)  ; FIX(1.082392200)
+F_1_414 equ DESCALE(1518500249, 30 - CONST_BITS)  ; FIX(1.414213562)
+F_1_847 equ DESCALE(1984016188, 30 - CONST_BITS)  ; FIX(1.847759065)
+F_2_613 equ DESCALE(2805822602, 30 - CONST_BITS)  ; FIX(2.613125930)
+F_1_613 equ (F_2_613 - (1 << CONST_BITS))       ; FIX(2.613125930) - FIX(1)
+%endif
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_CONST
+
+; PRE_MULTIPLY_SCALE_BITS <= 2 (to avoid overflow)
+; CONST_BITS + CONST_SHIFT + PRE_MULTIPLY_SCALE_BITS == 16 (for pmulhw)
+
+%define PRE_MULTIPLY_SCALE_BITS  2
+%define CONST_SHIFT              (16 - PRE_MULTIPLY_SCALE_BITS - CONST_BITS)
+
+    alignz      32
+    GLOBAL_DATA(jconst_idct_ifast_mmx)
+
+EXTN(jconst_idct_ifast_mmx):
+
+PW_F1414       times 4 dw  F_1_414 << CONST_SHIFT
+PW_F1847       times 4 dw  F_1_847 << CONST_SHIFT
+PW_MF1613      times 4 dw -F_1_613 << CONST_SHIFT
+PW_F1082       times 4 dw  F_1_082 << CONST_SHIFT
+PB_CENTERJSAMP times 8 db  CENTERJSAMPLE
+
+    alignz      32
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_TEXT
+    BITS        32
+;
+; Perform dequantization and inverse DCT on one block of coefficients.
+;
+; GLOBAL(void)
+; jsimd_idct_ifast_mmx(void *dct_table, JCOEFPTR coef_block,
+;                      JSAMPARRAY output_buf, JDIMENSION output_col)
+;
+
+%define dct_table(b)   (b) + 8          ; jpeg_component_info *compptr
+%define coef_block(b)  (b) + 12         ; JCOEFPTR coef_block
+%define output_buf(b)  (b) + 16         ; JSAMPARRAY output_buf
+%define output_col(b)  (b) + 20         ; JDIMENSION output_col
+
+%define original_ebp   ebp + 0
+%define wk(i)          ebp - (WK_NUM - (i)) * SIZEOF_MMWORD
+                                        ; mmword wk[WK_NUM]
+%define WK_NUM         2
+%define workspace      wk(0) - DCTSIZE2 * SIZEOF_JCOEF
+                                        ; JCOEF workspace[DCTSIZE2]
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_idct_ifast_mmx)
+
+EXTN(jsimd_idct_ifast_mmx):
+    push        ebp
+    mov         eax, esp                    ; eax = original ebp
+    sub         esp, byte 4
+    and         esp, byte (-SIZEOF_MMWORD)  ; align to 64 bits
+    mov         [esp], eax
+    mov         ebp, esp                    ; ebp = aligned ebp
+    lea         esp, [workspace]
+    push        ebx
+;   push        ecx                     ; need not be preserved
+;   push        edx                     ; need not be preserved
+    push        esi
+    push        edi
+
+    get_GOT     ebx                     ; get GOT address
+
+    ; ---- Pass 1: process columns from input, store into work array.
+
+;   mov         eax, [original_ebp]
+    mov         edx, POINTER [dct_table(eax)]    ; quantptr
+    mov         esi, JCOEFPTR [coef_block(eax)]  ; inptr
+    lea         edi, [workspace]                 ; JCOEF *wsptr
+    mov         ecx, DCTSIZE/4                   ; ctr
+    alignx      16, 7
+.columnloop:
+%ifndef NO_ZERO_COLUMN_TEST_IFAST_MMX
+    mov         eax, dword [DWBLOCK(1,0,esi,SIZEOF_JCOEF)]
+    or          eax, dword [DWBLOCK(2,0,esi,SIZEOF_JCOEF)]
+    jnz         short .columnDCT
+
+    movq        mm0, MMWORD [MMBLOCK(1,0,esi,SIZEOF_JCOEF)]
+    movq        mm1, MMWORD [MMBLOCK(2,0,esi,SIZEOF_JCOEF)]
+    por         mm0, MMWORD [MMBLOCK(3,0,esi,SIZEOF_JCOEF)]
+    por         mm1, MMWORD [MMBLOCK(4,0,esi,SIZEOF_JCOEF)]
+    por         mm0, MMWORD [MMBLOCK(5,0,esi,SIZEOF_JCOEF)]
+    por         mm1, MMWORD [MMBLOCK(6,0,esi,SIZEOF_JCOEF)]
+    por         mm0, MMWORD [MMBLOCK(7,0,esi,SIZEOF_JCOEF)]
+    por         mm1, mm0
+    packsswb    mm1, mm1
+    movd        eax, mm1
+    test        eax, eax
+    jnz         short .columnDCT
+
+    ; -- AC terms all zero
+
+    movq        mm0, MMWORD [MMBLOCK(0,0,esi,SIZEOF_JCOEF)]
+    pmullw      mm0, MMWORD [MMBLOCK(0,0,edx,SIZEOF_IFAST_MULT_TYPE)]
+
+    movq        mm2, mm0                ; mm0=in0=(00 01 02 03)
+    punpcklwd   mm0, mm0                ; mm0=(00 00 01 01)
+    punpckhwd   mm2, mm2                ; mm2=(02 02 03 03)
+
+    movq        mm1, mm0
+    punpckldq   mm0, mm0                ; mm0=(00 00 00 00)
+    punpckhdq   mm1, mm1                ; mm1=(01 01 01 01)
+    movq        mm3, mm2
+    punpckldq   mm2, mm2                ; mm2=(02 02 02 02)
+    punpckhdq   mm3, mm3                ; mm3=(03 03 03 03)
+
+    movq        MMWORD [MMBLOCK(0,0,edi,SIZEOF_JCOEF)], mm0
+    movq        MMWORD [MMBLOCK(0,1,edi,SIZEOF_JCOEF)], mm0
+    movq        MMWORD [MMBLOCK(1,0,edi,SIZEOF_JCOEF)], mm1
+    movq        MMWORD [MMBLOCK(1,1,edi,SIZEOF_JCOEF)], mm1
+    movq        MMWORD [MMBLOCK(2,0,edi,SIZEOF_JCOEF)], mm2
+    movq        MMWORD [MMBLOCK(2,1,edi,SIZEOF_JCOEF)], mm2
+    movq        MMWORD [MMBLOCK(3,0,edi,SIZEOF_JCOEF)], mm3
+    movq        MMWORD [MMBLOCK(3,1,edi,SIZEOF_JCOEF)], mm3
+    jmp         near .nextcolumn
+    alignx      16, 7
+%endif
+.columnDCT:
+
+    ; -- Even part
+
+    movq        mm0, MMWORD [MMBLOCK(0,0,esi,SIZEOF_JCOEF)]
+    movq        mm1, MMWORD [MMBLOCK(2,0,esi,SIZEOF_JCOEF)]
+    pmullw      mm0, MMWORD [MMBLOCK(0,0,edx,SIZEOF_IFAST_MULT_TYPE)]
+    pmullw      mm1, MMWORD [MMBLOCK(2,0,edx,SIZEOF_IFAST_MULT_TYPE)]
+    movq        mm2, MMWORD [MMBLOCK(4,0,esi,SIZEOF_JCOEF)]
+    movq        mm3, MMWORD [MMBLOCK(6,0,esi,SIZEOF_JCOEF)]
+    pmullw      mm2, MMWORD [MMBLOCK(4,0,edx,SIZEOF_IFAST_MULT_TYPE)]
+    pmullw      mm3, MMWORD [MMBLOCK(6,0,edx,SIZEOF_IFAST_MULT_TYPE)]
+
+    movq        mm4, mm0
+    movq        mm5, mm1
+    psubw       mm0, mm2                ; mm0=tmp11
+    psubw       mm1, mm3
+    paddw       mm4, mm2                ; mm4=tmp10
+    paddw       mm5, mm3                ; mm5=tmp13
+
+    psllw       mm1, PRE_MULTIPLY_SCALE_BITS
+    pmulhw      mm1, [GOTOFF(ebx,PW_F1414)]
+    psubw       mm1, mm5                ; mm1=tmp12
+
+    movq        mm6, mm4
+    movq        mm7, mm0
+    psubw       mm4, mm5                ; mm4=tmp3
+    psubw       mm0, mm1                ; mm0=tmp2
+    paddw       mm6, mm5                ; mm6=tmp0
+    paddw       mm7, mm1                ; mm7=tmp1
+
+    movq        MMWORD [wk(1)], mm4     ; wk(1)=tmp3
+    movq        MMWORD [wk(0)], mm0     ; wk(0)=tmp2
+
+    ; -- Odd part
+
+    movq        mm2, MMWORD [MMBLOCK(1,0,esi,SIZEOF_JCOEF)]
+    movq        mm3, MMWORD [MMBLOCK(3,0,esi,SIZEOF_JCOEF)]
+    pmullw      mm2, MMWORD [MMBLOCK(1,0,edx,SIZEOF_IFAST_MULT_TYPE)]
+    pmullw      mm3, MMWORD [MMBLOCK(3,0,edx,SIZEOF_IFAST_MULT_TYPE)]
+    movq        mm5, MMWORD [MMBLOCK(5,0,esi,SIZEOF_JCOEF)]
+    movq        mm1, MMWORD [MMBLOCK(7,0,esi,SIZEOF_JCOEF)]
+    pmullw      mm5, MMWORD [MMBLOCK(5,0,edx,SIZEOF_IFAST_MULT_TYPE)]
+    pmullw      mm1, MMWORD [MMBLOCK(7,0,edx,SIZEOF_IFAST_MULT_TYPE)]
+
+    movq        mm4, mm2
+    movq        mm0, mm5
+    psubw       mm2, mm1                ; mm2=z12
+    psubw       mm5, mm3                ; mm5=z10
+    paddw       mm4, mm1                ; mm4=z11
+    paddw       mm0, mm3                ; mm0=z13
+
+    movq        mm1, mm5                ; mm1=z10(unscaled)
+    psllw       mm2, PRE_MULTIPLY_SCALE_BITS
+    psllw       mm5, PRE_MULTIPLY_SCALE_BITS
+
+    movq        mm3, mm4
+    psubw       mm4, mm0
+    paddw       mm3, mm0                ; mm3=tmp7
+
+    psllw       mm4, PRE_MULTIPLY_SCALE_BITS
+    pmulhw      mm4, [GOTOFF(ebx,PW_F1414)]  ; mm4=tmp11
+
+    ; To avoid overflow...
+    ;
+    ; (Original)
+    ; tmp12 = -2.613125930 * z10 + z5;
+    ;
+    ; (This implementation)
+    ; tmp12 = (-1.613125930 - 1) * z10 + z5;
+    ;       = -1.613125930 * z10 - z10 + z5;
+
+    movq        mm0, mm5
+    paddw       mm5, mm2
+    pmulhw      mm5, [GOTOFF(ebx,PW_F1847)]   ; mm5=z5
+    pmulhw      mm0, [GOTOFF(ebx,PW_MF1613)]
+    pmulhw      mm2, [GOTOFF(ebx,PW_F1082)]
+    psubw       mm0, mm1
+    psubw       mm2, mm5                ; mm2=tmp10
+    paddw       mm0, mm5                ; mm0=tmp12
+
+    ; -- Final output stage
+
+    psubw       mm0, mm3                ; mm0=tmp6
+    movq        mm1, mm6
+    movq        mm5, mm7
+    paddw       mm6, mm3                ; mm6=data0=(00 01 02 03)
+    paddw       mm7, mm0                ; mm7=data1=(10 11 12 13)
+    psubw       mm1, mm3                ; mm1=data7=(70 71 72 73)
+    psubw       mm5, mm0                ; mm5=data6=(60 61 62 63)
+    psubw       mm4, mm0                ; mm4=tmp5
+
+    movq        mm3, mm6                ; transpose coefficients(phase 1)
+    punpcklwd   mm6, mm7                ; mm6=(00 10 01 11)
+    punpckhwd   mm3, mm7                ; mm3=(02 12 03 13)
+    movq        mm0, mm5                ; transpose coefficients(phase 1)
+    punpcklwd   mm5, mm1                ; mm5=(60 70 61 71)
+    punpckhwd   mm0, mm1                ; mm0=(62 72 63 73)
+
+    movq        mm7, MMWORD [wk(0)]     ; mm7=tmp2
+    movq        mm1, MMWORD [wk(1)]     ; mm1=tmp3
+
+    movq        MMWORD [wk(0)], mm5     ; wk(0)=(60 70 61 71)
+    movq        MMWORD [wk(1)], mm0     ; wk(1)=(62 72 63 73)
+
+    paddw       mm2, mm4                ; mm2=tmp4
+    movq        mm5, mm7
+    movq        mm0, mm1
+    paddw       mm7, mm4                ; mm7=data2=(20 21 22 23)
+    paddw       mm1, mm2                ; mm1=data4=(40 41 42 43)
+    psubw       mm5, mm4                ; mm5=data5=(50 51 52 53)
+    psubw       mm0, mm2                ; mm0=data3=(30 31 32 33)
+
+    movq        mm4, mm7                ; transpose coefficients(phase 1)
+    punpcklwd   mm7, mm0                ; mm7=(20 30 21 31)
+    punpckhwd   mm4, mm0                ; mm4=(22 32 23 33)
+    movq        mm2, mm1                ; transpose coefficients(phase 1)
+    punpcklwd   mm1, mm5                ; mm1=(40 50 41 51)
+    punpckhwd   mm2, mm5                ; mm2=(42 52 43 53)
+
+    movq        mm0, mm6                ; transpose coefficients(phase 2)
+    punpckldq   mm6, mm7                ; mm6=(00 10 20 30)
+    punpckhdq   mm0, mm7                ; mm0=(01 11 21 31)
+    movq        mm5, mm3                ; transpose coefficients(phase 2)
+    punpckldq   mm3, mm4                ; mm3=(02 12 22 32)
+    punpckhdq   mm5, mm4                ; mm5=(03 13 23 33)
+
+    movq        mm7, MMWORD [wk(0)]     ; mm7=(60 70 61 71)
+    movq        mm4, MMWORD [wk(1)]     ; mm4=(62 72 63 73)
+
+    movq        MMWORD [MMBLOCK(0,0,edi,SIZEOF_JCOEF)], mm6
+    movq        MMWORD [MMBLOCK(1,0,edi,SIZEOF_JCOEF)], mm0
+    movq        MMWORD [MMBLOCK(2,0,edi,SIZEOF_JCOEF)], mm3
+    movq        MMWORD [MMBLOCK(3,0,edi,SIZEOF_JCOEF)], mm5
+
+    movq        mm6, mm1                ; transpose coefficients(phase 2)
+    punpckldq   mm1, mm7                ; mm1=(40 50 60 70)
+    punpckhdq   mm6, mm7                ; mm6=(41 51 61 71)
+    movq        mm0, mm2                ; transpose coefficients(phase 2)
+    punpckldq   mm2, mm4                ; mm2=(42 52 62 72)
+    punpckhdq   mm0, mm4                ; mm0=(43 53 63 73)
+
+    movq        MMWORD [MMBLOCK(0,1,edi,SIZEOF_JCOEF)], mm1
+    movq        MMWORD [MMBLOCK(1,1,edi,SIZEOF_JCOEF)], mm6
+    movq        MMWORD [MMBLOCK(2,1,edi,SIZEOF_JCOEF)], mm2
+    movq        MMWORD [MMBLOCK(3,1,edi,SIZEOF_JCOEF)], mm0
+
+.nextcolumn:
+    add         esi, byte 4*SIZEOF_JCOEF            ; coef_block
+    add         edx, byte 4*SIZEOF_IFAST_MULT_TYPE  ; quantptr
+    add         edi, byte 4*DCTSIZE*SIZEOF_JCOEF    ; wsptr
+    dec         ecx                                 ; ctr
+    jnz         near .columnloop
+
+    ; ---- Pass 2: process rows from work array, store into output array.
+
+    mov         eax, [original_ebp]
+    lea         esi, [workspace]                   ; JCOEF *wsptr
+    mov         edi, JSAMPARRAY [output_buf(eax)]  ; (JSAMPROW *)
+    mov         eax, JDIMENSION [output_col(eax)]
+    mov         ecx, DCTSIZE/4                     ; ctr
+    alignx      16, 7
+.rowloop:
+
+    ; -- Even part
+
+    movq        mm0, MMWORD [MMBLOCK(0,0,esi,SIZEOF_JCOEF)]
+    movq        mm1, MMWORD [MMBLOCK(2,0,esi,SIZEOF_JCOEF)]
+    movq        mm2, MMWORD [MMBLOCK(4,0,esi,SIZEOF_JCOEF)]
+    movq        mm3, MMWORD [MMBLOCK(6,0,esi,SIZEOF_JCOEF)]
+
+    movq        mm4, mm0
+    movq        mm5, mm1
+    psubw       mm0, mm2                ; mm0=tmp11
+    psubw       mm1, mm3
+    paddw       mm4, mm2                ; mm4=tmp10
+    paddw       mm5, mm3                ; mm5=tmp13
+
+    psllw       mm1, PRE_MULTIPLY_SCALE_BITS
+    pmulhw      mm1, [GOTOFF(ebx,PW_F1414)]
+    psubw       mm1, mm5                ; mm1=tmp12
+
+    movq        mm6, mm4
+    movq        mm7, mm0
+    psubw       mm4, mm5                ; mm4=tmp3
+    psubw       mm0, mm1                ; mm0=tmp2
+    paddw       mm6, mm5                ; mm6=tmp0
+    paddw       mm7, mm1                ; mm7=tmp1
+
+    movq        MMWORD [wk(1)], mm4     ; wk(1)=tmp3
+    movq        MMWORD [wk(0)], mm0     ; wk(0)=tmp2
+
+    ; -- Odd part
+
+    movq        mm2, MMWORD [MMBLOCK(1,0,esi,SIZEOF_JCOEF)]
+    movq        mm3, MMWORD [MMBLOCK(3,0,esi,SIZEOF_JCOEF)]
+    movq        mm5, MMWORD [MMBLOCK(5,0,esi,SIZEOF_JCOEF)]
+    movq        mm1, MMWORD [MMBLOCK(7,0,esi,SIZEOF_JCOEF)]
+
+    movq        mm4, mm2
+    movq        mm0, mm5
+    psubw       mm2, mm1                ; mm2=z12
+    psubw       mm5, mm3                ; mm5=z10
+    paddw       mm4, mm1                ; mm4=z11
+    paddw       mm0, mm3                ; mm0=z13
+
+    movq        mm1, mm5                ; mm1=z10(unscaled)
+    psllw       mm2, PRE_MULTIPLY_SCALE_BITS
+    psllw       mm5, PRE_MULTIPLY_SCALE_BITS
+
+    movq        mm3, mm4
+    psubw       mm4, mm0
+    paddw       mm3, mm0                ; mm3=tmp7
+
+    psllw       mm4, PRE_MULTIPLY_SCALE_BITS
+    pmulhw      mm4, [GOTOFF(ebx,PW_F1414)]  ; mm4=tmp11
+
+    ; To avoid overflow...
+    ;
+    ; (Original)
+    ; tmp12 = -2.613125930 * z10 + z5;
+    ;
+    ; (This implementation)
+    ; tmp12 = (-1.613125930 - 1) * z10 + z5;
+    ;       = -1.613125930 * z10 - z10 + z5;
+
+    movq        mm0, mm5
+    paddw       mm5, mm2
+    pmulhw      mm5, [GOTOFF(ebx,PW_F1847)]   ; mm5=z5
+    pmulhw      mm0, [GOTOFF(ebx,PW_MF1613)]
+    pmulhw      mm2, [GOTOFF(ebx,PW_F1082)]
+    psubw       mm0, mm1
+    psubw       mm2, mm5                ; mm2=tmp10
+    paddw       mm0, mm5                ; mm0=tmp12
+
+    ; -- Final output stage
+
+    psubw       mm0, mm3                ; mm0=tmp6
+    movq        mm1, mm6
+    movq        mm5, mm7
+    paddw       mm6, mm3                ; mm6=data0=(00 10 20 30)
+    paddw       mm7, mm0                ; mm7=data1=(01 11 21 31)
+    psraw       mm6, (PASS1_BITS+3)     ; descale
+    psraw       mm7, (PASS1_BITS+3)     ; descale
+    psubw       mm1, mm3                ; mm1=data7=(07 17 27 37)
+    psubw       mm5, mm0                ; mm5=data6=(06 16 26 36)
+    psraw       mm1, (PASS1_BITS+3)     ; descale
+    psraw       mm5, (PASS1_BITS+3)     ; descale
+    psubw       mm4, mm0                ; mm4=tmp5
+
+    packsswb    mm6, mm5                ; mm6=(00 10 20 30 06 16 26 36)
+    packsswb    mm7, mm1                ; mm7=(01 11 21 31 07 17 27 37)
+
+    movq        mm3, MMWORD [wk(0)]     ; mm3=tmp2
+    movq        mm0, MMWORD [wk(1)]     ; mm0=tmp3
+
+    paddw       mm2, mm4                ; mm2=tmp4
+    movq        mm5, mm3
+    movq        mm1, mm0
+    paddw       mm3, mm4                ; mm3=data2=(02 12 22 32)
+    paddw       mm0, mm2                ; mm0=data4=(04 14 24 34)
+    psraw       mm3, (PASS1_BITS+3)     ; descale
+    psraw       mm0, (PASS1_BITS+3)     ; descale
+    psubw       mm5, mm4                ; mm5=data5=(05 15 25 35)
+    psubw       mm1, mm2                ; mm1=data3=(03 13 23 33)
+    psraw       mm5, (PASS1_BITS+3)     ; descale
+    psraw       mm1, (PASS1_BITS+3)     ; descale
+
+    movq        mm4, [GOTOFF(ebx,PB_CENTERJSAMP)]  ; mm4=[PB_CENTERJSAMP]
+
+    packsswb    mm3, mm0                ; mm3=(02 12 22 32 04 14 24 34)
+    packsswb    mm1, mm5                ; mm1=(03 13 23 33 05 15 25 35)
+
+    paddb       mm6, mm4
+    paddb       mm7, mm4
+    paddb       mm3, mm4
+    paddb       mm1, mm4
+
+    movq        mm2, mm6                ; transpose coefficients(phase 1)
+    punpcklbw   mm6, mm7                ; mm6=(00 01 10 11 20 21 30 31)
+    punpckhbw   mm2, mm7                ; mm2=(06 07 16 17 26 27 36 37)
+    movq        mm0, mm3                ; transpose coefficients(phase 1)
+    punpcklbw   mm3, mm1                ; mm3=(02 03 12 13 22 23 32 33)
+    punpckhbw   mm0, mm1                ; mm0=(04 05 14 15 24 25 34 35)
+
+    movq        mm5, mm6                ; transpose coefficients(phase 2)
+    punpcklwd   mm6, mm3                ; mm6=(00 01 02 03 10 11 12 13)
+    punpckhwd   mm5, mm3                ; mm5=(20 21 22 23 30 31 32 33)
+    movq        mm4, mm0                ; transpose coefficients(phase 2)
+    punpcklwd   mm0, mm2                ; mm0=(04 05 06 07 14 15 16 17)
+    punpckhwd   mm4, mm2                ; mm4=(24 25 26 27 34 35 36 37)
+
+    movq        mm7, mm6                ; transpose coefficients(phase 3)
+    punpckldq   mm6, mm0                ; mm6=(00 01 02 03 04 05 06 07)
+    punpckhdq   mm7, mm0                ; mm7=(10 11 12 13 14 15 16 17)
+    movq        mm1, mm5                ; transpose coefficients(phase 3)
+    punpckldq   mm5, mm4                ; mm5=(20 21 22 23 24 25 26 27)
+    punpckhdq   mm1, mm4                ; mm1=(30 31 32 33 34 35 36 37)
+
+    pushpic     ebx                     ; save GOT address
+
+    mov         edx, JSAMPROW [edi+0*SIZEOF_JSAMPROW]
+    mov         ebx, JSAMPROW [edi+1*SIZEOF_JSAMPROW]
+    movq        MMWORD [edx+eax*SIZEOF_JSAMPLE], mm6
+    movq        MMWORD [ebx+eax*SIZEOF_JSAMPLE], mm7
+    mov         edx, JSAMPROW [edi+2*SIZEOF_JSAMPROW]
+    mov         ebx, JSAMPROW [edi+3*SIZEOF_JSAMPROW]
+    movq        MMWORD [edx+eax*SIZEOF_JSAMPLE], mm5
+    movq        MMWORD [ebx+eax*SIZEOF_JSAMPLE], mm1
+
+    poppic      ebx                     ; restore GOT address
+
+    add         esi, byte 4*SIZEOF_JCOEF     ; wsptr
+    add         edi, byte 4*SIZEOF_JSAMPROW
+    dec         ecx                          ; ctr
+    jnz         near .rowloop
+
+    emms                                ; empty MMX state
+
+    pop         edi
+    pop         esi
+;   pop         edx                     ; need not be preserved
+;   pop         ecx                     ; need not be preserved
+    pop         ebx
+    mov         esp, ebp                ; esp <- aligned ebp
+    pop         esp                     ; esp <- original ebp
+    pop         ebp
+    ret
+
+; For some reason, the OS X linker does not honor the request to align the
+; segment unless we do this.
+    align       32
diff --git a/3rdparty/libjpeg/src/simd/i386/jidctfst-sse2.asm b/3rdparty/libjpeg/src/simd/i386/jidctfst-sse2.asm
new file mode 100644
index 00000000..19704ffa
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/i386/jidctfst-sse2.asm
@@ -0,0 +1,501 @@
+;
+; jidctfst.asm - fast integer IDCT (SSE2)
+;
+; Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+; Copyright (C) 2016, D. R. Commander.
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+;
+; This file should be assembled with NASM (Netwide Assembler),
+; can *not* be assembled with Microsoft's MASM or any compatible
+; assembler (including Borland's Turbo Assembler).
+; NASM is available from http://nasm.sourceforge.net/ or
+; http://sourceforge.net/project/showfiles.php?group_id=6208
+;
+; This file contains a fast, not so accurate integer implementation of
+; the inverse DCT (Discrete Cosine Transform). The following code is
+; based directly on the IJG's original jidctfst.c; see the jidctfst.c
+; for more details.
+
+%include "jsimdext.inc"
+%include "jdct.inc"
+
+; --------------------------------------------------------------------------
+
+%define CONST_BITS  8  ; 14 is also OK.
+%define PASS1_BITS  2
+
+%if IFAST_SCALE_BITS != PASS1_BITS
+%error "'IFAST_SCALE_BITS' must be equal to 'PASS1_BITS'."
+%endif
+
+%if CONST_BITS == 8
+F_1_082 equ 277              ; FIX(1.082392200)
+F_1_414 equ 362              ; FIX(1.414213562)
+F_1_847 equ 473              ; FIX(1.847759065)
+F_2_613 equ 669              ; FIX(2.613125930)
+F_1_613 equ (F_2_613 - 256)  ; FIX(2.613125930) - FIX(1)
+%else
+; NASM cannot do compile-time arithmetic on floating-point constants.
+%define DESCALE(x, n)  (((x) + (1 << ((n) - 1))) >> (n))
+F_1_082 equ DESCALE(1162209775, 30 - CONST_BITS)  ; FIX(1.082392200)
+F_1_414 equ DESCALE(1518500249, 30 - CONST_BITS)  ; FIX(1.414213562)
+F_1_847 equ DESCALE(1984016188, 30 - CONST_BITS)  ; FIX(1.847759065)
+F_2_613 equ DESCALE(2805822602, 30 - CONST_BITS)  ; FIX(2.613125930)
+F_1_613 equ (F_2_613 - (1 << CONST_BITS))       ; FIX(2.613125930) - FIX(1)
+%endif
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_CONST
+
+; PRE_MULTIPLY_SCALE_BITS <= 2 (to avoid overflow)
+; CONST_BITS + CONST_SHIFT + PRE_MULTIPLY_SCALE_BITS == 16 (for pmulhw)
+
+%define PRE_MULTIPLY_SCALE_BITS  2
+%define CONST_SHIFT              (16 - PRE_MULTIPLY_SCALE_BITS - CONST_BITS)
+
+    alignz      32
+    GLOBAL_DATA(jconst_idct_ifast_sse2)
+
+EXTN(jconst_idct_ifast_sse2):
+
+PW_F1414       times 8  dw  F_1_414 << CONST_SHIFT
+PW_F1847       times 8  dw  F_1_847 << CONST_SHIFT
+PW_MF1613      times 8  dw -F_1_613 << CONST_SHIFT
+PW_F1082       times 8  dw  F_1_082 << CONST_SHIFT
+PB_CENTERJSAMP times 16 db  CENTERJSAMPLE
+
+    alignz      32
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_TEXT
+    BITS        32
+;
+; Perform dequantization and inverse DCT on one block of coefficients.
+;
+; GLOBAL(void)
+; jsimd_idct_ifast_sse2(void *dct_table, JCOEFPTR coef_block,
+;                       JSAMPARRAY output_buf, JDIMENSION output_col)
+;
+
+%define dct_table(b)   (b) + 8          ; jpeg_component_info *compptr
+%define coef_block(b)  (b) + 12         ; JCOEFPTR coef_block
+%define output_buf(b)  (b) + 16         ; JSAMPARRAY output_buf
+%define output_col(b)  (b) + 20         ; JDIMENSION output_col
+
+%define original_ebp   ebp + 0
+%define wk(i)          ebp - (WK_NUM - (i)) * SIZEOF_XMMWORD
+                                        ; xmmword wk[WK_NUM]
+%define WK_NUM         2
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_idct_ifast_sse2)
+
+EXTN(jsimd_idct_ifast_sse2):
+    push        ebp
+    mov         eax, esp                     ; eax = original ebp
+    sub         esp, byte 4
+    and         esp, byte (-SIZEOF_XMMWORD)  ; align to 128 bits
+    mov         [esp], eax
+    mov         ebp, esp                     ; ebp = aligned ebp
+    lea         esp, [wk(0)]
+    pushpic     ebx
+;   push        ecx                     ; unused
+;   push        edx                     ; need not be preserved
+    push        esi
+    push        edi
+
+    get_GOT     ebx                     ; get GOT address
+
+    ; ---- Pass 1: process columns from input.
+
+;   mov         eax, [original_ebp]
+    mov         edx, POINTER [dct_table(eax)]    ; quantptr
+    mov         esi, JCOEFPTR [coef_block(eax)]  ; inptr
+
+%ifndef NO_ZERO_COLUMN_TEST_IFAST_SSE2
+    mov         eax, dword [DWBLOCK(1,0,esi,SIZEOF_JCOEF)]
+    or          eax, dword [DWBLOCK(2,0,esi,SIZEOF_JCOEF)]
+    jnz         near .columnDCT
+
+    movdqa      xmm0, XMMWORD [XMMBLOCK(1,0,esi,SIZEOF_JCOEF)]
+    movdqa      xmm1, XMMWORD [XMMBLOCK(2,0,esi,SIZEOF_JCOEF)]
+    por         xmm0, XMMWORD [XMMBLOCK(3,0,esi,SIZEOF_JCOEF)]
+    por         xmm1, XMMWORD [XMMBLOCK(4,0,esi,SIZEOF_JCOEF)]
+    por         xmm0, XMMWORD [XMMBLOCK(5,0,esi,SIZEOF_JCOEF)]
+    por         xmm1, XMMWORD [XMMBLOCK(6,0,esi,SIZEOF_JCOEF)]
+    por         xmm0, XMMWORD [XMMBLOCK(7,0,esi,SIZEOF_JCOEF)]
+    por         xmm1, xmm0
+    packsswb    xmm1, xmm1
+    packsswb    xmm1, xmm1
+    movd        eax, xmm1
+    test        eax, eax
+    jnz         short .columnDCT
+
+    ; -- AC terms all zero
+
+    movdqa      xmm0, XMMWORD [XMMBLOCK(0,0,esi,SIZEOF_JCOEF)]
+    pmullw      xmm0, XMMWORD [XMMBLOCK(0,0,edx,SIZEOF_ISLOW_MULT_TYPE)]
+
+    movdqa      xmm7, xmm0              ; xmm0=in0=(00 01 02 03 04 05 06 07)
+    punpcklwd   xmm0, xmm0              ; xmm0=(00 00 01 01 02 02 03 03)
+    punpckhwd   xmm7, xmm7              ; xmm7=(04 04 05 05 06 06 07 07)
+
+    pshufd      xmm6, xmm0, 0x00        ; xmm6=col0=(00 00 00 00 00 00 00 00)
+    pshufd      xmm2, xmm0, 0x55        ; xmm2=col1=(01 01 01 01 01 01 01 01)
+    pshufd      xmm5, xmm0, 0xAA        ; xmm5=col2=(02 02 02 02 02 02 02 02)
+    pshufd      xmm0, xmm0, 0xFF        ; xmm0=col3=(03 03 03 03 03 03 03 03)
+    pshufd      xmm1, xmm7, 0x00        ; xmm1=col4=(04 04 04 04 04 04 04 04)
+    pshufd      xmm4, xmm7, 0x55        ; xmm4=col5=(05 05 05 05 05 05 05 05)
+    pshufd      xmm3, xmm7, 0xAA        ; xmm3=col6=(06 06 06 06 06 06 06 06)
+    pshufd      xmm7, xmm7, 0xFF        ; xmm7=col7=(07 07 07 07 07 07 07 07)
+
+    movdqa      XMMWORD [wk(0)], xmm2   ; wk(0)=col1
+    movdqa      XMMWORD [wk(1)], xmm0   ; wk(1)=col3
+    jmp         near .column_end
+    alignx      16, 7
+%endif
+.columnDCT:
+
+    ; -- Even part
+
+    movdqa      xmm0, XMMWORD [XMMBLOCK(0,0,esi,SIZEOF_JCOEF)]
+    movdqa      xmm1, XMMWORD [XMMBLOCK(2,0,esi,SIZEOF_JCOEF)]
+    pmullw      xmm0, XMMWORD [XMMBLOCK(0,0,edx,SIZEOF_IFAST_MULT_TYPE)]
+    pmullw      xmm1, XMMWORD [XMMBLOCK(2,0,edx,SIZEOF_IFAST_MULT_TYPE)]
+    movdqa      xmm2, XMMWORD [XMMBLOCK(4,0,esi,SIZEOF_JCOEF)]
+    movdqa      xmm3, XMMWORD [XMMBLOCK(6,0,esi,SIZEOF_JCOEF)]
+    pmullw      xmm2, XMMWORD [XMMBLOCK(4,0,edx,SIZEOF_IFAST_MULT_TYPE)]
+    pmullw      xmm3, XMMWORD [XMMBLOCK(6,0,edx,SIZEOF_IFAST_MULT_TYPE)]
+
+    movdqa      xmm4, xmm0
+    movdqa      xmm5, xmm1
+    psubw       xmm0, xmm2              ; xmm0=tmp11
+    psubw       xmm1, xmm3
+    paddw       xmm4, xmm2              ; xmm4=tmp10
+    paddw       xmm5, xmm3              ; xmm5=tmp13
+
+    psllw       xmm1, PRE_MULTIPLY_SCALE_BITS
+    pmulhw      xmm1, [GOTOFF(ebx,PW_F1414)]
+    psubw       xmm1, xmm5              ; xmm1=tmp12
+
+    movdqa      xmm6, xmm4
+    movdqa      xmm7, xmm0
+    psubw       xmm4, xmm5              ; xmm4=tmp3
+    psubw       xmm0, xmm1              ; xmm0=tmp2
+    paddw       xmm6, xmm5              ; xmm6=tmp0
+    paddw       xmm7, xmm1              ; xmm7=tmp1
+
+    movdqa      XMMWORD [wk(1)], xmm4   ; wk(1)=tmp3
+    movdqa      XMMWORD [wk(0)], xmm0   ; wk(0)=tmp2
+
+    ; -- Odd part
+
+    movdqa      xmm2, XMMWORD [XMMBLOCK(1,0,esi,SIZEOF_JCOEF)]
+    movdqa      xmm3, XMMWORD [XMMBLOCK(3,0,esi,SIZEOF_JCOEF)]
+    pmullw      xmm2, XMMWORD [XMMBLOCK(1,0,edx,SIZEOF_IFAST_MULT_TYPE)]
+    pmullw      xmm3, XMMWORD [XMMBLOCK(3,0,edx,SIZEOF_IFAST_MULT_TYPE)]
+    movdqa      xmm5, XMMWORD [XMMBLOCK(5,0,esi,SIZEOF_JCOEF)]
+    movdqa      xmm1, XMMWORD [XMMBLOCK(7,0,esi,SIZEOF_JCOEF)]
+    pmullw      xmm5, XMMWORD [XMMBLOCK(5,0,edx,SIZEOF_IFAST_MULT_TYPE)]
+    pmullw      xmm1, XMMWORD [XMMBLOCK(7,0,edx,SIZEOF_IFAST_MULT_TYPE)]
+
+    movdqa      xmm4, xmm2
+    movdqa      xmm0, xmm5
+    psubw       xmm2, xmm1              ; xmm2=z12
+    psubw       xmm5, xmm3              ; xmm5=z10
+    paddw       xmm4, xmm1              ; xmm4=z11
+    paddw       xmm0, xmm3              ; xmm0=z13
+
+    movdqa      xmm1, xmm5              ; xmm1=z10(unscaled)
+    psllw       xmm2, PRE_MULTIPLY_SCALE_BITS
+    psllw       xmm5, PRE_MULTIPLY_SCALE_BITS
+
+    movdqa      xmm3, xmm4
+    psubw       xmm4, xmm0
+    paddw       xmm3, xmm0              ; xmm3=tmp7
+
+    psllw       xmm4, PRE_MULTIPLY_SCALE_BITS
+    pmulhw      xmm4, [GOTOFF(ebx,PW_F1414)]  ; xmm4=tmp11
+
+    ; To avoid overflow...
+    ;
+    ; (Original)
+    ; tmp12 = -2.613125930 * z10 + z5;
+    ;
+    ; (This implementation)
+    ; tmp12 = (-1.613125930 - 1) * z10 + z5;
+    ;       = -1.613125930 * z10 - z10 + z5;
+
+    movdqa      xmm0, xmm5
+    paddw       xmm5, xmm2
+    pmulhw      xmm5, [GOTOFF(ebx,PW_F1847)]   ; xmm5=z5
+    pmulhw      xmm0, [GOTOFF(ebx,PW_MF1613)]
+    pmulhw      xmm2, [GOTOFF(ebx,PW_F1082)]
+    psubw       xmm0, xmm1
+    psubw       xmm2, xmm5              ; xmm2=tmp10
+    paddw       xmm0, xmm5              ; xmm0=tmp12
+
+    ; -- Final output stage
+
+    psubw       xmm0, xmm3              ; xmm0=tmp6
+    movdqa      xmm1, xmm6
+    movdqa      xmm5, xmm7
+    paddw       xmm6, xmm3              ; xmm6=data0=(00 01 02 03 04 05 06 07)
+    paddw       xmm7, xmm0              ; xmm7=data1=(10 11 12 13 14 15 16 17)
+    psubw       xmm1, xmm3              ; xmm1=data7=(70 71 72 73 74 75 76 77)
+    psubw       xmm5, xmm0              ; xmm5=data6=(60 61 62 63 64 65 66 67)
+    psubw       xmm4, xmm0              ; xmm4=tmp5
+
+    movdqa      xmm3, xmm6              ; transpose coefficients(phase 1)
+    punpcklwd   xmm6, xmm7              ; xmm6=(00 10 01 11 02 12 03 13)
+    punpckhwd   xmm3, xmm7              ; xmm3=(04 14 05 15 06 16 07 17)
+    movdqa      xmm0, xmm5              ; transpose coefficients(phase 1)
+    punpcklwd   xmm5, xmm1              ; xmm5=(60 70 61 71 62 72 63 73)
+    punpckhwd   xmm0, xmm1              ; xmm0=(64 74 65 75 66 76 67 77)
+
+    movdqa      xmm7, XMMWORD [wk(0)]   ; xmm7=tmp2
+    movdqa      xmm1, XMMWORD [wk(1)]   ; xmm1=tmp3
+
+    movdqa      XMMWORD [wk(0)], xmm5   ; wk(0)=(60 70 61 71 62 72 63 73)
+    movdqa      XMMWORD [wk(1)], xmm0   ; wk(1)=(64 74 65 75 66 76 67 77)
+
+    paddw       xmm2, xmm4              ; xmm2=tmp4
+    movdqa      xmm5, xmm7
+    movdqa      xmm0, xmm1
+    paddw       xmm7, xmm4              ; xmm7=data2=(20 21 22 23 24 25 26 27)
+    paddw       xmm1, xmm2              ; xmm1=data4=(40 41 42 43 44 45 46 47)
+    psubw       xmm5, xmm4              ; xmm5=data5=(50 51 52 53 54 55 56 57)
+    psubw       xmm0, xmm2              ; xmm0=data3=(30 31 32 33 34 35 36 37)
+
+    movdqa      xmm4, xmm7              ; transpose coefficients(phase 1)
+    punpcklwd   xmm7, xmm0              ; xmm7=(20 30 21 31 22 32 23 33)
+    punpckhwd   xmm4, xmm0              ; xmm4=(24 34 25 35 26 36 27 37)
+    movdqa      xmm2, xmm1              ; transpose coefficients(phase 1)
+    punpcklwd   xmm1, xmm5              ; xmm1=(40 50 41 51 42 52 43 53)
+    punpckhwd   xmm2, xmm5              ; xmm2=(44 54 45 55 46 56 47 57)
+
+    movdqa      xmm0, xmm3              ; transpose coefficients(phase 2)
+    punpckldq   xmm3, xmm4              ; xmm3=(04 14 24 34 05 15 25 35)
+    punpckhdq   xmm0, xmm4              ; xmm0=(06 16 26 36 07 17 27 37)
+    movdqa      xmm5, xmm6              ; transpose coefficients(phase 2)
+    punpckldq   xmm6, xmm7              ; xmm6=(00 10 20 30 01 11 21 31)
+    punpckhdq   xmm5, xmm7              ; xmm5=(02 12 22 32 03 13 23 33)
+
+    movdqa      xmm4, XMMWORD [wk(0)]   ; xmm4=(60 70 61 71 62 72 63 73)
+    movdqa      xmm7, XMMWORD [wk(1)]   ; xmm7=(64 74 65 75 66 76 67 77)
+
+    movdqa      XMMWORD [wk(0)], xmm3   ; wk(0)=(04 14 24 34 05 15 25 35)
+    movdqa      XMMWORD [wk(1)], xmm0   ; wk(1)=(06 16 26 36 07 17 27 37)
+
+    movdqa      xmm3, xmm1              ; transpose coefficients(phase 2)
+    punpckldq   xmm1, xmm4              ; xmm1=(40 50 60 70 41 51 61 71)
+    punpckhdq   xmm3, xmm4              ; xmm3=(42 52 62 72 43 53 63 73)
+    movdqa      xmm0, xmm2              ; transpose coefficients(phase 2)
+    punpckldq   xmm2, xmm7              ; xmm2=(44 54 64 74 45 55 65 75)
+    punpckhdq   xmm0, xmm7              ; xmm0=(46 56 66 76 47 57 67 77)
+
+    movdqa      xmm4, xmm6              ; transpose coefficients(phase 3)
+    punpcklqdq  xmm6, xmm1              ; xmm6=col0=(00 10 20 30 40 50 60 70)
+    punpckhqdq  xmm4, xmm1              ; xmm4=col1=(01 11 21 31 41 51 61 71)
+    movdqa      xmm7, xmm5              ; transpose coefficients(phase 3)
+    punpcklqdq  xmm5, xmm3              ; xmm5=col2=(02 12 22 32 42 52 62 72)
+    punpckhqdq  xmm7, xmm3              ; xmm7=col3=(03 13 23 33 43 53 63 73)
+
+    movdqa      xmm1, XMMWORD [wk(0)]   ; xmm1=(04 14 24 34 05 15 25 35)
+    movdqa      xmm3, XMMWORD [wk(1)]   ; xmm3=(06 16 26 36 07 17 27 37)
+
+    movdqa      XMMWORD [wk(0)], xmm4   ; wk(0)=col1
+    movdqa      XMMWORD [wk(1)], xmm7   ; wk(1)=col3
+
+    movdqa      xmm4, xmm1              ; transpose coefficients(phase 3)
+    punpcklqdq  xmm1, xmm2              ; xmm1=col4=(04 14 24 34 44 54 64 74)
+    punpckhqdq  xmm4, xmm2              ; xmm4=col5=(05 15 25 35 45 55 65 75)
+    movdqa      xmm7, xmm3              ; transpose coefficients(phase 3)
+    punpcklqdq  xmm3, xmm0              ; xmm3=col6=(06 16 26 36 46 56 66 76)
+    punpckhqdq  xmm7, xmm0              ; xmm7=col7=(07 17 27 37 47 57 67 77)
+.column_end:
+
+    ; -- Prefetch the next coefficient block
+
+    prefetchnta [esi + DCTSIZE2*SIZEOF_JCOEF + 0*32]
+    prefetchnta [esi + DCTSIZE2*SIZEOF_JCOEF + 1*32]
+    prefetchnta [esi + DCTSIZE2*SIZEOF_JCOEF + 2*32]
+    prefetchnta [esi + DCTSIZE2*SIZEOF_JCOEF + 3*32]
+
+    ; ---- Pass 2: process rows from work array, store into output array.
+
+    mov         eax, [original_ebp]
+    mov         edi, JSAMPARRAY [output_buf(eax)]  ; (JSAMPROW *)
+    mov         eax, JDIMENSION [output_col(eax)]
+
+    ; -- Even part
+
+    ; xmm6=col0, xmm5=col2, xmm1=col4, xmm3=col6
+
+    movdqa      xmm2, xmm6
+    movdqa      xmm0, xmm5
+    psubw       xmm6, xmm1              ; xmm6=tmp11
+    psubw       xmm5, xmm3
+    paddw       xmm2, xmm1              ; xmm2=tmp10
+    paddw       xmm0, xmm3              ; xmm0=tmp13
+
+    psllw       xmm5, PRE_MULTIPLY_SCALE_BITS
+    pmulhw      xmm5, [GOTOFF(ebx,PW_F1414)]
+    psubw       xmm5, xmm0              ; xmm5=tmp12
+
+    movdqa      xmm1, xmm2
+    movdqa      xmm3, xmm6
+    psubw       xmm2, xmm0              ; xmm2=tmp3
+    psubw       xmm6, xmm5              ; xmm6=tmp2
+    paddw       xmm1, xmm0              ; xmm1=tmp0
+    paddw       xmm3, xmm5              ; xmm3=tmp1
+
+    movdqa      xmm0, XMMWORD [wk(0)]   ; xmm0=col1
+    movdqa      xmm5, XMMWORD [wk(1)]   ; xmm5=col3
+
+    movdqa      XMMWORD [wk(0)], xmm2   ; wk(0)=tmp3
+    movdqa      XMMWORD [wk(1)], xmm6   ; wk(1)=tmp2
+
+    ; -- Odd part
+
+    ; xmm0=col1, xmm5=col3, xmm4=col5, xmm7=col7
+
+    movdqa      xmm2, xmm0
+    movdqa      xmm6, xmm4
+    psubw       xmm0, xmm7              ; xmm0=z12
+    psubw       xmm4, xmm5              ; xmm4=z10
+    paddw       xmm2, xmm7              ; xmm2=z11
+    paddw       xmm6, xmm5              ; xmm6=z13
+
+    movdqa      xmm7, xmm4              ; xmm7=z10(unscaled)
+    psllw       xmm0, PRE_MULTIPLY_SCALE_BITS
+    psllw       xmm4, PRE_MULTIPLY_SCALE_BITS
+
+    movdqa      xmm5, xmm2
+    psubw       xmm2, xmm6
+    paddw       xmm5, xmm6              ; xmm5=tmp7
+
+    psllw       xmm2, PRE_MULTIPLY_SCALE_BITS
+    pmulhw      xmm2, [GOTOFF(ebx,PW_F1414)]  ; xmm2=tmp11
+
+    ; To avoid overflow...
+    ;
+    ; (Original)
+    ; tmp12 = -2.613125930 * z10 + z5;
+    ;
+    ; (This implementation)
+    ; tmp12 = (-1.613125930 - 1) * z10 + z5;
+    ;       = -1.613125930 * z10 - z10 + z5;
+
+    movdqa      xmm6, xmm4
+    paddw       xmm4, xmm0
+    pmulhw      xmm4, [GOTOFF(ebx,PW_F1847)]   ; xmm4=z5
+    pmulhw      xmm6, [GOTOFF(ebx,PW_MF1613)]
+    pmulhw      xmm0, [GOTOFF(ebx,PW_F1082)]
+    psubw       xmm6, xmm7
+    psubw       xmm0, xmm4              ; xmm0=tmp10
+    paddw       xmm6, xmm4              ; xmm6=tmp12
+
+    ; -- Final output stage
+
+    psubw       xmm6, xmm5              ; xmm6=tmp6
+    movdqa      xmm7, xmm1
+    movdqa      xmm4, xmm3
+    paddw       xmm1, xmm5              ; xmm1=data0=(00 10 20 30 40 50 60 70)
+    paddw       xmm3, xmm6              ; xmm3=data1=(01 11 21 31 41 51 61 71)
+    psraw       xmm1, (PASS1_BITS+3)    ; descale
+    psraw       xmm3, (PASS1_BITS+3)    ; descale
+    psubw       xmm7, xmm5              ; xmm7=data7=(07 17 27 37 47 57 67 77)
+    psubw       xmm4, xmm6              ; xmm4=data6=(06 16 26 36 46 56 66 76)
+    psraw       xmm7, (PASS1_BITS+3)    ; descale
+    psraw       xmm4, (PASS1_BITS+3)    ; descale
+    psubw       xmm2, xmm6              ; xmm2=tmp5
+
+    packsswb    xmm1, xmm4        ; xmm1=(00 10 20 30 40 50 60 70 06 16 26 36 46 56 66 76)
+    packsswb    xmm3, xmm7        ; xmm3=(01 11 21 31 41 51 61 71 07 17 27 37 47 57 67 77)
+
+    movdqa      xmm5, XMMWORD [wk(1)]   ; xmm5=tmp2
+    movdqa      xmm6, XMMWORD [wk(0)]   ; xmm6=tmp3
+
+    paddw       xmm0, xmm2              ; xmm0=tmp4
+    movdqa      xmm4, xmm5
+    movdqa      xmm7, xmm6
+    paddw       xmm5, xmm2              ; xmm5=data2=(02 12 22 32 42 52 62 72)
+    paddw       xmm6, xmm0              ; xmm6=data4=(04 14 24 34 44 54 64 74)
+    psraw       xmm5, (PASS1_BITS+3)    ; descale
+    psraw       xmm6, (PASS1_BITS+3)    ; descale
+    psubw       xmm4, xmm2              ; xmm4=data5=(05 15 25 35 45 55 65 75)
+    psubw       xmm7, xmm0              ; xmm7=data3=(03 13 23 33 43 53 63 73)
+    psraw       xmm4, (PASS1_BITS+3)    ; descale
+    psraw       xmm7, (PASS1_BITS+3)    ; descale
+
+    movdqa      xmm2, [GOTOFF(ebx,PB_CENTERJSAMP)]  ; xmm2=[PB_CENTERJSAMP]
+
+    packsswb    xmm5, xmm6        ; xmm5=(02 12 22 32 42 52 62 72 04 14 24 34 44 54 64 74)
+    packsswb    xmm7, xmm4        ; xmm7=(03 13 23 33 43 53 63 73 05 15 25 35 45 55 65 75)
+
+    paddb       xmm1, xmm2
+    paddb       xmm3, xmm2
+    paddb       xmm5, xmm2
+    paddb       xmm7, xmm2
+
+    movdqa      xmm0, xmm1        ; transpose coefficients(phase 1)
+    punpcklbw   xmm1, xmm3        ; xmm1=(00 01 10 11 20 21 30 31 40 41 50 51 60 61 70 71)
+    punpckhbw   xmm0, xmm3        ; xmm0=(06 07 16 17 26 27 36 37 46 47 56 57 66 67 76 77)
+    movdqa      xmm6, xmm5        ; transpose coefficients(phase 1)
+    punpcklbw   xmm5, xmm7        ; xmm5=(02 03 12 13 22 23 32 33 42 43 52 53 62 63 72 73)
+    punpckhbw   xmm6, xmm7        ; xmm6=(04 05 14 15 24 25 34 35 44 45 54 55 64 65 74 75)
+
+    movdqa      xmm4, xmm1        ; transpose coefficients(phase 2)
+    punpcklwd   xmm1, xmm5        ; xmm1=(00 01 02 03 10 11 12 13 20 21 22 23 30 31 32 33)
+    punpckhwd   xmm4, xmm5        ; xmm4=(40 41 42 43 50 51 52 53 60 61 62 63 70 71 72 73)
+    movdqa      xmm2, xmm6        ; transpose coefficients(phase 2)
+    punpcklwd   xmm6, xmm0        ; xmm6=(04 05 06 07 14 15 16 17 24 25 26 27 34 35 36 37)
+    punpckhwd   xmm2, xmm0        ; xmm2=(44 45 46 47 54 55 56 57 64 65 66 67 74 75 76 77)
+
+    movdqa      xmm3, xmm1        ; transpose coefficients(phase 3)
+    punpckldq   xmm1, xmm6        ; xmm1=(00 01 02 03 04 05 06 07 10 11 12 13 14 15 16 17)
+    punpckhdq   xmm3, xmm6        ; xmm3=(20 21 22 23 24 25 26 27 30 31 32 33 34 35 36 37)
+    movdqa      xmm7, xmm4        ; transpose coefficients(phase 3)
+    punpckldq   xmm4, xmm2        ; xmm4=(40 41 42 43 44 45 46 47 50 51 52 53 54 55 56 57)
+    punpckhdq   xmm7, xmm2        ; xmm7=(60 61 62 63 64 65 66 67 70 71 72 73 74 75 76 77)
+
+    pshufd      xmm5, xmm1, 0x4E  ; xmm5=(10 11 12 13 14 15 16 17 00 01 02 03 04 05 06 07)
+    pshufd      xmm0, xmm3, 0x4E  ; xmm0=(30 31 32 33 34 35 36 37 20 21 22 23 24 25 26 27)
+    pshufd      xmm6, xmm4, 0x4E  ; xmm6=(50 51 52 53 54 55 56 57 40 41 42 43 44 45 46 47)
+    pshufd      xmm2, xmm7, 0x4E  ; xmm2=(70 71 72 73 74 75 76 77 60 61 62 63 64 65 66 67)
+
+    mov         edx, JSAMPROW [edi+0*SIZEOF_JSAMPROW]
+    mov         esi, JSAMPROW [edi+2*SIZEOF_JSAMPROW]
+    movq        XMM_MMWORD [edx+eax*SIZEOF_JSAMPLE], xmm1
+    movq        XMM_MMWORD [esi+eax*SIZEOF_JSAMPLE], xmm3
+    mov         edx, JSAMPROW [edi+4*SIZEOF_JSAMPROW]
+    mov         esi, JSAMPROW [edi+6*SIZEOF_JSAMPROW]
+    movq        XMM_MMWORD [edx+eax*SIZEOF_JSAMPLE], xmm4
+    movq        XMM_MMWORD [esi+eax*SIZEOF_JSAMPLE], xmm7
+
+    mov         edx, JSAMPROW [edi+1*SIZEOF_JSAMPROW]
+    mov         esi, JSAMPROW [edi+3*SIZEOF_JSAMPROW]
+    movq        XMM_MMWORD [edx+eax*SIZEOF_JSAMPLE], xmm5
+    movq        XMM_MMWORD [esi+eax*SIZEOF_JSAMPLE], xmm0
+    mov         edx, JSAMPROW [edi+5*SIZEOF_JSAMPROW]
+    mov         esi, JSAMPROW [edi+7*SIZEOF_JSAMPROW]
+    movq        XMM_MMWORD [edx+eax*SIZEOF_JSAMPLE], xmm6
+    movq        XMM_MMWORD [esi+eax*SIZEOF_JSAMPLE], xmm2
+
+    pop         edi
+    pop         esi
+;   pop         edx                     ; need not be preserved
+;   pop         ecx                     ; unused
+    poppic      ebx
+    mov         esp, ebp                ; esp <- aligned ebp
+    pop         esp                     ; esp <- original ebp
+    pop         ebp
+    ret
+
+; For some reason, the OS X linker does not honor the request to align the
+; segment unless we do this.
+    align       32
diff --git a/3rdparty/libjpeg/src/simd/i386/jidctint-avx2.asm b/3rdparty/libjpeg/src/simd/i386/jidctint-avx2.asm
new file mode 100644
index 00000000..199c7df3
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/i386/jidctint-avx2.asm
@@ -0,0 +1,453 @@
+;
+; jidctint.asm - accurate integer IDCT (AVX2)
+;
+; Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+; Copyright (C) 2009, 2016, 2018, 2020, D. R. Commander.
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+;
+; This file should be assembled with NASM (Netwide Assembler),
+; can *not* be assembled with Microsoft's MASM or any compatible
+; assembler (including Borland's Turbo Assembler).
+; NASM is available from http://nasm.sourceforge.net/ or
+; http://sourceforge.net/project/showfiles.php?group_id=6208
+;
+; This file contains a slower but more accurate integer implementation of the
+; inverse DCT (Discrete Cosine Transform). The following code is based
+; directly on the IJG's original jidctint.c; see the jidctint.c for
+; more details.
+
+%include "jsimdext.inc"
+%include "jdct.inc"
+
+; --------------------------------------------------------------------------
+
+%define CONST_BITS  13
+%define PASS1_BITS  2
+
+%define DESCALE_P1  (CONST_BITS - PASS1_BITS)
+%define DESCALE_P2  (CONST_BITS + PASS1_BITS + 3)
+
+%if CONST_BITS == 13
+F_0_298 equ  2446  ; FIX(0.298631336)
+F_0_390 equ  3196  ; FIX(0.390180644)
+F_0_541 equ  4433  ; FIX(0.541196100)
+F_0_765 equ  6270  ; FIX(0.765366865)
+F_0_899 equ  7373  ; FIX(0.899976223)
+F_1_175 equ  9633  ; FIX(1.175875602)
+F_1_501 equ 12299  ; FIX(1.501321110)
+F_1_847 equ 15137  ; FIX(1.847759065)
+F_1_961 equ 16069  ; FIX(1.961570560)
+F_2_053 equ 16819  ; FIX(2.053119869)
+F_2_562 equ 20995  ; FIX(2.562915447)
+F_3_072 equ 25172  ; FIX(3.072711026)
+%else
+; NASM cannot do compile-time arithmetic on floating-point constants.
+%define DESCALE(x, n)  (((x) + (1 << ((n) - 1))) >> (n))
+F_0_298 equ DESCALE( 320652955, 30 - CONST_BITS)  ; FIX(0.298631336)
+F_0_390 equ DESCALE( 418953276, 30 - CONST_BITS)  ; FIX(0.390180644)
+F_0_541 equ DESCALE( 581104887, 30 - CONST_BITS)  ; FIX(0.541196100)
+F_0_765 equ DESCALE( 821806413, 30 - CONST_BITS)  ; FIX(0.765366865)
+F_0_899 equ DESCALE( 966342111, 30 - CONST_BITS)  ; FIX(0.899976223)
+F_1_175 equ DESCALE(1262586813, 30 - CONST_BITS)  ; FIX(1.175875602)
+F_1_501 equ DESCALE(1612031267, 30 - CONST_BITS)  ; FIX(1.501321110)
+F_1_847 equ DESCALE(1984016188, 30 - CONST_BITS)  ; FIX(1.847759065)
+F_1_961 equ DESCALE(2106220350, 30 - CONST_BITS)  ; FIX(1.961570560)
+F_2_053 equ DESCALE(2204520673, 30 - CONST_BITS)  ; FIX(2.053119869)
+F_2_562 equ DESCALE(2751909506, 30 - CONST_BITS)  ; FIX(2.562915447)
+F_3_072 equ DESCALE(3299298341, 30 - CONST_BITS)  ; FIX(3.072711026)
+%endif
+
+; --------------------------------------------------------------------------
+; In-place 8x8x16-bit inverse matrix transpose using AVX2 instructions
+; %1-%4: Input/output registers
+; %5-%8: Temp registers
+
+%macro dotranspose 8
+    ; %5=(00 10 20 30 40 50 60 70  01 11 21 31 41 51 61 71)
+    ; %6=(03 13 23 33 43 53 63 73  02 12 22 32 42 52 62 72)
+    ; %7=(04 14 24 34 44 54 64 74  05 15 25 35 45 55 65 75)
+    ; %8=(07 17 27 37 47 57 67 77  06 16 26 36 46 56 66 76)
+
+    vpermq      %5, %1, 0xD8
+    vpermq      %6, %2, 0x72
+    vpermq      %7, %3, 0xD8
+    vpermq      %8, %4, 0x72
+    ; transpose coefficients(phase 1)
+    ; %5=(00 10 20 30 01 11 21 31  40 50 60 70 41 51 61 71)
+    ; %6=(02 12 22 32 03 13 23 33  42 52 62 72 43 53 63 73)
+    ; %7=(04 14 24 34 05 15 25 35  44 54 64 74 45 55 65 75)
+    ; %8=(06 16 26 36 07 17 27 37  46 56 66 76 47 57 67 77)
+
+    vpunpcklwd  %1, %5, %6
+    vpunpckhwd  %2, %5, %6
+    vpunpcklwd  %3, %7, %8
+    vpunpckhwd  %4, %7, %8
+    ; transpose coefficients(phase 2)
+    ; %1=(00 02 10 12 20 22 30 32  40 42 50 52 60 62 70 72)
+    ; %2=(01 03 11 13 21 23 31 33  41 43 51 53 61 63 71 73)
+    ; %3=(04 06 14 16 24 26 34 36  44 46 54 56 64 66 74 76)
+    ; %4=(05 07 15 17 25 27 35 37  45 47 55 57 65 67 75 77)
+
+    vpunpcklwd  %5, %1, %2
+    vpunpcklwd  %6, %3, %4
+    vpunpckhwd  %7, %1, %2
+    vpunpckhwd  %8, %3, %4
+    ; transpose coefficients(phase 3)
+    ; %5=(00 01 02 03 10 11 12 13  40 41 42 43 50 51 52 53)
+    ; %6=(04 05 06 07 14 15 16 17  44 45 46 47 54 55 56 57)
+    ; %7=(20 21 22 23 30 31 32 33  60 61 62 63 70 71 72 73)
+    ; %8=(24 25 26 27 34 35 36 37  64 65 66 67 74 75 76 77)
+
+    vpunpcklqdq %1, %5, %6
+    vpunpckhqdq %2, %5, %6
+    vpunpcklqdq %3, %7, %8
+    vpunpckhqdq %4, %7, %8
+    ; transpose coefficients(phase 4)
+    ; %1=(00 01 02 03 04 05 06 07  40 41 42 43 44 45 46 47)
+    ; %2=(10 11 12 13 14 15 16 17  50 51 52 53 54 55 56 57)
+    ; %3=(20 21 22 23 24 25 26 27  60 61 62 63 64 65 66 67)
+    ; %4=(30 31 32 33 34 35 36 37  70 71 72 73 74 75 76 77)
+%endmacro
+
+; --------------------------------------------------------------------------
+; In-place 8x8x16-bit accurate integer inverse DCT using AVX2 instructions
+; %1-%4:  Input/output registers
+; %5-%12: Temp registers
+; %9:     Pass (1 or 2)
+
+%macro dodct 13
+    ; -- Even part
+
+    ; (Original)
+    ; z1 = (z2 + z3) * 0.541196100;
+    ; tmp2 = z1 + z3 * -1.847759065;
+    ; tmp3 = z1 + z2 * 0.765366865;
+    ;
+    ; (This implementation)
+    ; tmp2 = z2 * 0.541196100 + z3 * (0.541196100 - 1.847759065);
+    ; tmp3 = z2 * (0.541196100 + 0.765366865) + z3 * 0.541196100;
+
+    vperm2i128  %6, %3, %3, 0x01        ; %6=in6_2
+    vpunpcklwd  %5, %3, %6              ; %5=in26_62L
+    vpunpckhwd  %6, %3, %6              ; %6=in26_62H
+    vpmaddwd    %5, %5, [GOTOFF(ebx,PW_F130_F054_MF130_F054)]  ; %5=tmp3_2L
+    vpmaddwd    %6, %6, [GOTOFF(ebx,PW_F130_F054_MF130_F054)]  ; %6=tmp3_2H
+
+    vperm2i128  %7, %1, %1, 0x01        ; %7=in4_0
+    vpsignw     %1, %1, [GOTOFF(ebx,PW_1_NEG1)]
+    vpaddw      %7, %7, %1              ; %7=(in0+in4)_(in0-in4)
+
+    vpxor       %1, %1, %1
+    vpunpcklwd  %8, %1, %7              ; %8=tmp0_1L
+    vpunpckhwd  %1, %1, %7              ; %1=tmp0_1H
+    vpsrad      %8, %8, (16-CONST_BITS)  ; vpsrad %8,16 & vpslld %8,CONST_BITS
+    vpsrad      %1, %1, (16-CONST_BITS)  ; vpsrad %1,16 & vpslld %1,CONST_BITS
+
+    vpsubd      %3, %8, %5
+    vmovdqu     %11, %3                 ; %11=tmp0_1L-tmp3_2L=tmp13_12L
+    vpaddd      %3, %8, %5
+    vmovdqu     %9, %3                  ; %9=tmp0_1L+tmp3_2L=tmp10_11L
+    vpsubd      %3, %1, %6
+    vmovdqu     %12, %3                 ; %12=tmp0_1H-tmp3_2H=tmp13_12H
+    vpaddd      %3, %1, %6
+    vmovdqu     %10, %3                 ; %10=tmp0_1H+tmp3_2H=tmp10_11H
+
+    ; -- Odd part
+
+    vpaddw      %1, %4, %2              ; %1=in7_5+in3_1=z3_4
+
+    ; (Original)
+    ; z5 = (z3 + z4) * 1.175875602;
+    ; z3 = z3 * -1.961570560;  z4 = z4 * -0.390180644;
+    ; z3 += z5;  z4 += z5;
+    ;
+    ; (This implementation)
+    ; z3 = z3 * (1.175875602 - 1.961570560) + z4 * 1.175875602;
+    ; z4 = z3 * 1.175875602 + z4 * (1.175875602 - 0.390180644);
+
+    vperm2i128  %8, %1, %1, 0x01        ; %8=z4_3
+    vpunpcklwd  %7, %1, %8              ; %7=z34_43L
+    vpunpckhwd  %8, %1, %8              ; %8=z34_43H
+    vpmaddwd    %7, %7, [GOTOFF(ebx,PW_MF078_F117_F078_F117)]  ; %7=z3_4L
+    vpmaddwd    %8, %8, [GOTOFF(ebx,PW_MF078_F117_F078_F117)]  ; %8=z3_4H
+
+    ; (Original)
+    ; z1 = tmp0 + tmp3;  z2 = tmp1 + tmp2;
+    ; tmp0 = tmp0 * 0.298631336;  tmp1 = tmp1 * 2.053119869;
+    ; tmp2 = tmp2 * 3.072711026;  tmp3 = tmp3 * 1.501321110;
+    ; z1 = z1 * -0.899976223;  z2 = z2 * -2.562915447;
+    ; tmp0 += z1 + z3;  tmp1 += z2 + z4;
+    ; tmp2 += z2 + z3;  tmp3 += z1 + z4;
+    ;
+    ; (This implementation)
+    ; tmp0 = tmp0 * (0.298631336 - 0.899976223) + tmp3 * -0.899976223;
+    ; tmp1 = tmp1 * (2.053119869 - 2.562915447) + tmp2 * -2.562915447;
+    ; tmp2 = tmp1 * -2.562915447 + tmp2 * (3.072711026 - 2.562915447);
+    ; tmp3 = tmp0 * -0.899976223 + tmp3 * (1.501321110 - 0.899976223);
+    ; tmp0 += z3;  tmp1 += z4;
+    ; tmp2 += z3;  tmp3 += z4;
+
+    vperm2i128  %2, %2, %2, 0x01        ; %2=in1_3
+    vpunpcklwd  %3, %4, %2              ; %3=in71_53L
+    vpunpckhwd  %4, %4, %2              ; %4=in71_53H
+
+    vpmaddwd    %5, %3, [GOTOFF(ebx,PW_MF060_MF089_MF050_MF256)]  ; %5=tmp0_1L
+    vpmaddwd    %6, %4, [GOTOFF(ebx,PW_MF060_MF089_MF050_MF256)]  ; %6=tmp0_1H
+    vpaddd      %5, %5, %7              ; %5=tmp0_1L+z3_4L=tmp0_1L
+    vpaddd      %6, %6, %8              ; %6=tmp0_1H+z3_4H=tmp0_1H
+
+    vpmaddwd    %3, %3, [GOTOFF(ebx,PW_MF089_F060_MF256_F050)]  ; %3=tmp3_2L
+    vpmaddwd    %4, %4, [GOTOFF(ebx,PW_MF089_F060_MF256_F050)]  ; %4=tmp3_2H
+    vperm2i128  %7, %7, %7, 0x01        ; %7=z4_3L
+    vperm2i128  %8, %8, %8, 0x01        ; %8=z4_3H
+    vpaddd      %7, %3, %7              ; %7=tmp3_2L+z4_3L=tmp3_2L
+    vpaddd      %8, %4, %8              ; %8=tmp3_2H+z4_3H=tmp3_2H
+
+    ; -- Final output stage
+
+    vmovdqu     %3, %9
+    vmovdqu     %4, %10
+
+    vpaddd      %1, %3, %7              ; %1=tmp10_11L+tmp3_2L=data0_1L
+    vpaddd      %2, %4, %8              ; %2=tmp10_11H+tmp3_2H=data0_1H
+    vpaddd      %1, %1, [GOTOFF(ebx,PD_DESCALE_P %+ %13)]
+    vpaddd      %2, %2, [GOTOFF(ebx,PD_DESCALE_P %+ %13)]
+    vpsrad      %1, %1, DESCALE_P %+ %13
+    vpsrad      %2, %2, DESCALE_P %+ %13
+    vpackssdw   %1, %1, %2              ; %1=data0_1
+
+    vpsubd      %3, %3, %7              ; %3=tmp10_11L-tmp3_2L=data7_6L
+    vpsubd      %4, %4, %8              ; %4=tmp10_11H-tmp3_2H=data7_6H
+    vpaddd      %3, %3, [GOTOFF(ebx,PD_DESCALE_P %+ %13)]
+    vpaddd      %4, %4, [GOTOFF(ebx,PD_DESCALE_P %+ %13)]
+    vpsrad      %3, %3, DESCALE_P %+ %13
+    vpsrad      %4, %4, DESCALE_P %+ %13
+    vpackssdw   %4, %3, %4              ; %4=data7_6
+
+    vmovdqu     %7, %11
+    vmovdqu     %8, %12
+
+    vpaddd      %2, %7, %5              ; %7=tmp13_12L+tmp0_1L=data3_2L
+    vpaddd      %3, %8, %6              ; %8=tmp13_12H+tmp0_1H=data3_2H
+    vpaddd      %2, %2, [GOTOFF(ebx,PD_DESCALE_P %+ %13)]
+    vpaddd      %3, %3, [GOTOFF(ebx,PD_DESCALE_P %+ %13)]
+    vpsrad      %2, %2, DESCALE_P %+ %13
+    vpsrad      %3, %3, DESCALE_P %+ %13
+    vpackssdw   %2, %2, %3              ; %2=data3_2
+
+    vpsubd      %3, %7, %5              ; %7=tmp13_12L-tmp0_1L=data4_5L
+    vpsubd      %6, %8, %6              ; %8=tmp13_12H-tmp0_1H=data4_5H
+    vpaddd      %3, %3, [GOTOFF(ebx,PD_DESCALE_P %+ %13)]
+    vpaddd      %6, %6, [GOTOFF(ebx,PD_DESCALE_P %+ %13)]
+    vpsrad      %3, %3, DESCALE_P %+ %13
+    vpsrad      %6, %6, DESCALE_P %+ %13
+    vpackssdw   %3, %3, %6              ; %3=data4_5
+%endmacro
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_CONST
+
+    alignz      32
+    GLOBAL_DATA(jconst_idct_islow_avx2)
+
+EXTN(jconst_idct_islow_avx2):
+
+PW_F130_F054_MF130_F054    times 4  dw  (F_0_541 + F_0_765),  F_0_541
+                           times 4  dw  (F_0_541 - F_1_847),  F_0_541
+PW_MF078_F117_F078_F117    times 4  dw  (F_1_175 - F_1_961),  F_1_175
+                           times 4  dw  (F_1_175 - F_0_390),  F_1_175
+PW_MF060_MF089_MF050_MF256 times 4  dw  (F_0_298 - F_0_899), -F_0_899
+                           times 4  dw  (F_2_053 - F_2_562), -F_2_562
+PW_MF089_F060_MF256_F050   times 4  dw -F_0_899, (F_1_501 - F_0_899)
+                           times 4  dw -F_2_562, (F_3_072 - F_2_562)
+PD_DESCALE_P1              times 8  dd  1 << (DESCALE_P1 - 1)
+PD_DESCALE_P2              times 8  dd  1 << (DESCALE_P2 - 1)
+PB_CENTERJSAMP             times 32 db  CENTERJSAMPLE
+PW_1_NEG1                  times 8  dw  1
+                           times 8  dw -1
+
+    alignz      32
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_TEXT
+    BITS        32
+;
+; Perform dequantization and inverse DCT on one block of coefficients.
+;
+; GLOBAL(void)
+; jsimd_idct_islow_avx2(void *dct_table, JCOEFPTR coef_block,
+;                       JSAMPARRAY output_buf, JDIMENSION output_col)
+;
+
+%define dct_table(b)   (b) + 8          ; jpeg_component_info *compptr
+%define coef_block(b)  (b) + 12         ; JCOEFPTR coef_block
+%define output_buf(b)  (b) + 16         ; JSAMPARRAY output_buf
+%define output_col(b)  (b) + 20         ; JDIMENSION output_col
+
+%define original_ebp   ebp + 0
+%define wk(i)          ebp - (WK_NUM - (i)) * SIZEOF_YMMWORD
+                                        ; ymmword wk[WK_NUM]
+%define WK_NUM         4
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_idct_islow_avx2)
+
+EXTN(jsimd_idct_islow_avx2):
+    push        ebp
+    mov         eax, esp                     ; eax = original ebp
+    sub         esp, byte 4
+    and         esp, byte (-SIZEOF_XMMWORD)  ; align to 128 bits
+    mov         [esp], eax
+    mov         ebp, esp                     ; ebp = aligned ebp
+    lea         esp, [wk(0)]
+    pushpic     ebx
+;   push        ecx                     ; unused
+;   push        edx                     ; need not be preserved
+    push        esi
+    push        edi
+
+    get_GOT     ebx                     ; get GOT address
+
+    ; ---- Pass 1: process columns.
+
+;   mov         eax, [original_ebp]
+    mov         edx, POINTER [dct_table(eax)]    ; quantptr
+    mov         esi, JCOEFPTR [coef_block(eax)]  ; inptr
+
+%ifndef NO_ZERO_COLUMN_TEST_ISLOW_AVX2
+    mov         eax, dword [DWBLOCK(1,0,esi,SIZEOF_JCOEF)]
+    or          eax, dword [DWBLOCK(2,0,esi,SIZEOF_JCOEF)]
+    jnz         near .columnDCT
+
+    movdqa      xmm0, XMMWORD [XMMBLOCK(1,0,esi,SIZEOF_JCOEF)]
+    movdqa      xmm1, XMMWORD [XMMBLOCK(2,0,esi,SIZEOF_JCOEF)]
+    vpor        xmm0, xmm0, XMMWORD [XMMBLOCK(3,0,esi,SIZEOF_JCOEF)]
+    vpor        xmm1, xmm1, XMMWORD [XMMBLOCK(4,0,esi,SIZEOF_JCOEF)]
+    vpor        xmm0, xmm0, XMMWORD [XMMBLOCK(5,0,esi,SIZEOF_JCOEF)]
+    vpor        xmm1, xmm1, XMMWORD [XMMBLOCK(6,0,esi,SIZEOF_JCOEF)]
+    vpor        xmm0, xmm0, XMMWORD [XMMBLOCK(7,0,esi,SIZEOF_JCOEF)]
+    vpor        xmm1, xmm1, xmm0
+    vpacksswb   xmm1, xmm1, xmm1
+    vpacksswb   xmm1, xmm1, xmm1
+    movd        eax, xmm1
+    test        eax, eax
+    jnz         short .columnDCT
+
+    ; -- AC terms all zero
+
+    movdqa      xmm5, XMMWORD [XMMBLOCK(0,0,esi,SIZEOF_JCOEF)]
+    vpmullw     xmm5, xmm5, XMMWORD [XMMBLOCK(0,0,edx,SIZEOF_ISLOW_MULT_TYPE)]
+
+    vpsllw      xmm5, xmm5, PASS1_BITS
+
+    vpunpcklwd  xmm4, xmm5, xmm5        ; xmm4=(00 00 01 01 02 02 03 03)
+    vpunpckhwd  xmm5, xmm5, xmm5        ; xmm5=(04 04 05 05 06 06 07 07)
+    vinserti128 ymm4, ymm4, xmm5, 1
+
+    vpshufd     ymm0, ymm4, 0x00        ; ymm0=col0_4=(00 00 00 00 00 00 00 00  04 04 04 04 04 04 04 04)
+    vpshufd     ymm1, ymm4, 0x55        ; ymm1=col1_5=(01 01 01 01 01 01 01 01  05 05 05 05 05 05 05 05)
+    vpshufd     ymm2, ymm4, 0xAA        ; ymm2=col2_6=(02 02 02 02 02 02 02 02  06 06 06 06 06 06 06 06)
+    vpshufd     ymm3, ymm4, 0xFF        ; ymm3=col3_7=(03 03 03 03 03 03 03 03  07 07 07 07 07 07 07 07)
+
+    jmp         near .column_end
+    alignx      16, 7
+%endif
+.columnDCT:
+
+    vmovdqu     ymm4, YMMWORD [YMMBLOCK(0,0,esi,SIZEOF_JCOEF)]  ; ymm4=in0_1
+    vmovdqu     ymm5, YMMWORD [YMMBLOCK(2,0,esi,SIZEOF_JCOEF)]  ; ymm5=in2_3
+    vmovdqu     ymm6, YMMWORD [YMMBLOCK(4,0,esi,SIZEOF_JCOEF)]  ; ymm6=in4_5
+    vmovdqu     ymm7, YMMWORD [YMMBLOCK(6,0,esi,SIZEOF_JCOEF)]  ; ymm7=in6_7
+    vpmullw     ymm4, ymm4, YMMWORD [YMMBLOCK(0,0,edx,SIZEOF_ISLOW_MULT_TYPE)]
+    vpmullw     ymm5, ymm5, YMMWORD [YMMBLOCK(2,0,edx,SIZEOF_ISLOW_MULT_TYPE)]
+    vpmullw     ymm6, ymm6, YMMWORD [YMMBLOCK(4,0,edx,SIZEOF_ISLOW_MULT_TYPE)]
+    vpmullw     ymm7, ymm7, YMMWORD [YMMBLOCK(6,0,edx,SIZEOF_ISLOW_MULT_TYPE)]
+
+    vperm2i128  ymm0, ymm4, ymm6, 0x20  ; ymm0=in0_4
+    vperm2i128  ymm1, ymm5, ymm4, 0x31  ; ymm1=in3_1
+    vperm2i128  ymm2, ymm5, ymm7, 0x20  ; ymm2=in2_6
+    vperm2i128  ymm3, ymm7, ymm6, 0x31  ; ymm3=in7_5
+
+    dodct ymm0, ymm1, ymm2, ymm3, ymm4, ymm5, ymm6, ymm7, XMMWORD [wk(0)], XMMWORD [wk(1)], XMMWORD [wk(2)], XMMWORD [wk(3)], 1
+    ; ymm0=data0_1, ymm1=data3_2, ymm2=data4_5, ymm3=data7_6
+
+    dotranspose ymm0, ymm1, ymm2, ymm3, ymm4, ymm5, ymm6, ymm7
+    ; ymm0=data0_4, ymm1=data1_5, ymm2=data2_6, ymm3=data3_7
+
+.column_end:
+
+    ; -- Prefetch the next coefficient block
+
+    prefetchnta [esi + DCTSIZE2*SIZEOF_JCOEF + 0*32]
+    prefetchnta [esi + DCTSIZE2*SIZEOF_JCOEF + 1*32]
+    prefetchnta [esi + DCTSIZE2*SIZEOF_JCOEF + 2*32]
+    prefetchnta [esi + DCTSIZE2*SIZEOF_JCOEF + 3*32]
+
+    ; ---- Pass 2: process rows.
+
+    mov         eax, [original_ebp]
+    mov         edi, JSAMPARRAY [output_buf(eax)]  ; (JSAMPROW *)
+    mov         eax, JDIMENSION [output_col(eax)]
+
+    vperm2i128  ymm4, ymm3, ymm1, 0x31  ; ymm3=in7_5
+    vperm2i128  ymm1, ymm3, ymm1, 0x20  ; ymm1=in3_1
+
+    dodct ymm0, ymm1, ymm2, ymm4, ymm3, ymm5, ymm6, ymm7, XMMWORD [wk(0)], XMMWORD [wk(1)], XMMWORD [wk(2)], XMMWORD [wk(3)], 2
+    ; ymm0=data0_1, ymm1=data3_2, ymm2=data4_5, ymm4=data7_6
+
+    dotranspose ymm0, ymm1, ymm2, ymm4, ymm3, ymm5, ymm6, ymm7
+    ; ymm0=data0_4, ymm1=data1_5, ymm2=data2_6, ymm4=data3_7
+
+    vpacksswb   ymm0, ymm0, ymm1        ; ymm0=data01_45
+    vpacksswb   ymm1, ymm2, ymm4        ; ymm1=data23_67
+    vpaddb      ymm0, ymm0, [GOTOFF(ebx,PB_CENTERJSAMP)]
+    vpaddb      ymm1, ymm1, [GOTOFF(ebx,PB_CENTERJSAMP)]
+
+    vextracti128 xmm6, ymm1, 1          ; xmm3=data67
+    vextracti128 xmm4, ymm0, 1          ; xmm2=data45
+    vextracti128 xmm2, ymm1, 0          ; xmm1=data23
+    vextracti128 xmm0, ymm0, 0          ; xmm0=data01
+
+    vpshufd     xmm1, xmm0, 0x4E  ; xmm1=(10 11 12 13 14 15 16 17 00 01 02 03 04 05 06 07)
+    vpshufd     xmm3, xmm2, 0x4E  ; xmm3=(30 31 32 33 34 35 36 37 20 21 22 23 24 25 26 27)
+    vpshufd     xmm5, xmm4, 0x4E  ; xmm5=(50 51 52 53 54 55 56 57 40 41 42 43 44 45 46 47)
+    vpshufd     xmm7, xmm6, 0x4E  ; xmm7=(70 71 72 73 74 75 76 77 60 61 62 63 64 65 66 67)
+
+    vzeroupper
+
+    mov         edx, JSAMPROW [edi+0*SIZEOF_JSAMPROW]  ; (JSAMPLE *)
+    mov         esi, JSAMPROW [edi+1*SIZEOF_JSAMPROW]  ; (JSAMPLE *)
+    movq        XMM_MMWORD [edx+eax*SIZEOF_JSAMPLE], xmm0
+    movq        XMM_MMWORD [esi+eax*SIZEOF_JSAMPLE], xmm1
+
+    mov         edx, JSAMPROW [edi+2*SIZEOF_JSAMPROW]  ; (JSAMPLE *)
+    mov         esi, JSAMPROW [edi+3*SIZEOF_JSAMPROW]  ; (JSAMPLE *)
+    movq        XMM_MMWORD [edx+eax*SIZEOF_JSAMPLE], xmm2
+    movq        XMM_MMWORD [esi+eax*SIZEOF_JSAMPLE], xmm3
+
+    mov         edx, JSAMPROW [edi+4*SIZEOF_JSAMPROW]  ; (JSAMPLE *)
+    mov         esi, JSAMPROW [edi+5*SIZEOF_JSAMPROW]  ; (JSAMPLE *)
+    movq        XMM_MMWORD [edx+eax*SIZEOF_JSAMPLE], xmm4
+    movq        XMM_MMWORD [esi+eax*SIZEOF_JSAMPLE], xmm5
+
+    mov         edx, JSAMPROW [edi+6*SIZEOF_JSAMPROW]  ; (JSAMPLE *)
+    mov         esi, JSAMPROW [edi+7*SIZEOF_JSAMPROW]  ; (JSAMPLE *)
+    movq        XMM_MMWORD [edx+eax*SIZEOF_JSAMPLE], xmm6
+    movq        XMM_MMWORD [esi+eax*SIZEOF_JSAMPLE], xmm7
+
+    pop         edi
+    pop         esi
+;   pop         edx                     ; need not be preserved
+;   pop         ecx                     ; unused
+    poppic      ebx
+    mov         esp, ebp                ; esp <- aligned ebp
+    pop         esp                     ; esp <- original ebp
+    pop         ebp
+    ret
+
+; For some reason, the OS X linker does not honor the request to align the
+; segment unless we do this.
+    align       32
diff --git a/3rdparty/libjpeg/src/simd/i386/jidctint-mmx.asm b/3rdparty/libjpeg/src/simd/i386/jidctint-mmx.asm
new file mode 100644
index 00000000..f15c8d34
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/i386/jidctint-mmx.asm
@@ -0,0 +1,851 @@
+;
+; jidctint.asm - accurate integer IDCT (MMX)
+;
+; Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+; Copyright (C) 2016, 2020, D. R. Commander.
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+;
+; This file should be assembled with NASM (Netwide Assembler),
+; can *not* be assembled with Microsoft's MASM or any compatible
+; assembler (including Borland's Turbo Assembler).
+; NASM is available from http://nasm.sourceforge.net/ or
+; http://sourceforge.net/project/showfiles.php?group_id=6208
+;
+; This file contains a slower but more accurate integer implementation of the
+; inverse DCT (Discrete Cosine Transform). The following code is based
+; directly on the IJG's original jidctint.c; see the jidctint.c for
+; more details.
+
+%include "jsimdext.inc"
+%include "jdct.inc"
+
+; --------------------------------------------------------------------------
+
+%define CONST_BITS  13
+%define PASS1_BITS  2
+
+%define DESCALE_P1  (CONST_BITS - PASS1_BITS)
+%define DESCALE_P2  (CONST_BITS + PASS1_BITS + 3)
+
+%if CONST_BITS == 13
+F_0_298 equ  2446  ; FIX(0.298631336)
+F_0_390 equ  3196  ; FIX(0.390180644)
+F_0_541 equ  4433  ; FIX(0.541196100)
+F_0_765 equ  6270  ; FIX(0.765366865)
+F_0_899 equ  7373  ; FIX(0.899976223)
+F_1_175 equ  9633  ; FIX(1.175875602)
+F_1_501 equ 12299  ; FIX(1.501321110)
+F_1_847 equ 15137  ; FIX(1.847759065)
+F_1_961 equ 16069  ; FIX(1.961570560)
+F_2_053 equ 16819  ; FIX(2.053119869)
+F_2_562 equ 20995  ; FIX(2.562915447)
+F_3_072 equ 25172  ; FIX(3.072711026)
+%else
+; NASM cannot do compile-time arithmetic on floating-point constants.
+%define DESCALE(x, n)  (((x) + (1 << ((n) - 1))) >> (n))
+F_0_298 equ DESCALE( 320652955, 30 - CONST_BITS)  ; FIX(0.298631336)
+F_0_390 equ DESCALE( 418953276, 30 - CONST_BITS)  ; FIX(0.390180644)
+F_0_541 equ DESCALE( 581104887, 30 - CONST_BITS)  ; FIX(0.541196100)
+F_0_765 equ DESCALE( 821806413, 30 - CONST_BITS)  ; FIX(0.765366865)
+F_0_899 equ DESCALE( 966342111, 30 - CONST_BITS)  ; FIX(0.899976223)
+F_1_175 equ DESCALE(1262586813, 30 - CONST_BITS)  ; FIX(1.175875602)
+F_1_501 equ DESCALE(1612031267, 30 - CONST_BITS)  ; FIX(1.501321110)
+F_1_847 equ DESCALE(1984016188, 30 - CONST_BITS)  ; FIX(1.847759065)
+F_1_961 equ DESCALE(2106220350, 30 - CONST_BITS)  ; FIX(1.961570560)
+F_2_053 equ DESCALE(2204520673, 30 - CONST_BITS)  ; FIX(2.053119869)
+F_2_562 equ DESCALE(2751909506, 30 - CONST_BITS)  ; FIX(2.562915447)
+F_3_072 equ DESCALE(3299298341, 30 - CONST_BITS)  ; FIX(3.072711026)
+%endif
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_CONST
+
+    alignz      32
+    GLOBAL_DATA(jconst_idct_islow_mmx)
+
+EXTN(jconst_idct_islow_mmx):
+
+PW_F130_F054   times 2 dw  (F_0_541 + F_0_765),  F_0_541
+PW_F054_MF130  times 2 dw  F_0_541, (F_0_541 - F_1_847)
+PW_MF078_F117  times 2 dw  (F_1_175 - F_1_961),  F_1_175
+PW_F117_F078   times 2 dw  F_1_175, (F_1_175 - F_0_390)
+PW_MF060_MF089 times 2 dw  (F_0_298 - F_0_899), -F_0_899
+PW_MF089_F060  times 2 dw -F_0_899, (F_1_501 - F_0_899)
+PW_MF050_MF256 times 2 dw  (F_2_053 - F_2_562), -F_2_562
+PW_MF256_F050  times 2 dw -F_2_562, (F_3_072 - F_2_562)
+PD_DESCALE_P1  times 2 dd  1 << (DESCALE_P1 - 1)
+PD_DESCALE_P2  times 2 dd  1 << (DESCALE_P2 - 1)
+PB_CENTERJSAMP times 8 db  CENTERJSAMPLE
+
+    alignz      32
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_TEXT
+    BITS        32
+;
+; Perform dequantization and inverse DCT on one block of coefficients.
+;
+; GLOBAL(void)
+; jsimd_idct_islow_mmx(void *dct_table, JCOEFPTR coef_block,
+;                      JSAMPARRAY output_buf, JDIMENSION output_col)
+;
+
+%define dct_table(b)   (b) + 8          ; jpeg_component_info *compptr
+%define coef_block(b)  (b) + 12         ; JCOEFPTR coef_block
+%define output_buf(b)  (b) + 16         ; JSAMPARRAY output_buf
+%define output_col(b)  (b) + 20         ; JDIMENSION output_col
+
+%define original_ebp   ebp + 0
+%define wk(i)          ebp - (WK_NUM - (i)) * SIZEOF_MMWORD
+                                        ; mmword wk[WK_NUM]
+%define WK_NUM         12
+%define workspace      wk(0) - DCTSIZE2 * SIZEOF_JCOEF
+                                        ; JCOEF workspace[DCTSIZE2]
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_idct_islow_mmx)
+
+EXTN(jsimd_idct_islow_mmx):
+    push        ebp
+    mov         eax, esp                    ; eax = original ebp
+    sub         esp, byte 4
+    and         esp, byte (-SIZEOF_MMWORD)  ; align to 64 bits
+    mov         [esp], eax
+    mov         ebp, esp                    ; ebp = aligned ebp
+    lea         esp, [workspace]
+    push        ebx
+;   push        ecx                     ; need not be preserved
+;   push        edx                     ; need not be preserved
+    push        esi
+    push        edi
+
+    get_GOT     ebx                     ; get GOT address
+
+    ; ---- Pass 1: process columns from input, store into work array.
+
+;   mov         eax, [original_ebp]
+    mov         edx, POINTER [dct_table(eax)]    ; quantptr
+    mov         esi, JCOEFPTR [coef_block(eax)]  ; inptr
+    lea         edi, [workspace]                 ; JCOEF *wsptr
+    mov         ecx, DCTSIZE/4                   ; ctr
+    alignx      16, 7
+.columnloop:
+%ifndef NO_ZERO_COLUMN_TEST_ISLOW_MMX
+    mov         eax, dword [DWBLOCK(1,0,esi,SIZEOF_JCOEF)]
+    or          eax, dword [DWBLOCK(2,0,esi,SIZEOF_JCOEF)]
+    jnz         short .columnDCT
+
+    movq        mm0, MMWORD [MMBLOCK(1,0,esi,SIZEOF_JCOEF)]
+    movq        mm1, MMWORD [MMBLOCK(2,0,esi,SIZEOF_JCOEF)]
+    por         mm0, MMWORD [MMBLOCK(3,0,esi,SIZEOF_JCOEF)]
+    por         mm1, MMWORD [MMBLOCK(4,0,esi,SIZEOF_JCOEF)]
+    por         mm0, MMWORD [MMBLOCK(5,0,esi,SIZEOF_JCOEF)]
+    por         mm1, MMWORD [MMBLOCK(6,0,esi,SIZEOF_JCOEF)]
+    por         mm0, MMWORD [MMBLOCK(7,0,esi,SIZEOF_JCOEF)]
+    por         mm1, mm0
+    packsswb    mm1, mm1
+    movd        eax, mm1
+    test        eax, eax
+    jnz         short .columnDCT
+
+    ; -- AC terms all zero
+
+    movq        mm0, MMWORD [MMBLOCK(0,0,esi,SIZEOF_JCOEF)]
+    pmullw      mm0, MMWORD [MMBLOCK(0,0,edx,SIZEOF_ISLOW_MULT_TYPE)]
+
+    psllw       mm0, PASS1_BITS
+
+    movq        mm2, mm0                ; mm0=in0=(00 01 02 03)
+    punpcklwd   mm0, mm0                ; mm0=(00 00 01 01)
+    punpckhwd   mm2, mm2                ; mm2=(02 02 03 03)
+
+    movq        mm1, mm0
+    punpckldq   mm0, mm0                ; mm0=(00 00 00 00)
+    punpckhdq   mm1, mm1                ; mm1=(01 01 01 01)
+    movq        mm3, mm2
+    punpckldq   mm2, mm2                ; mm2=(02 02 02 02)
+    punpckhdq   mm3, mm3                ; mm3=(03 03 03 03)
+
+    movq        MMWORD [MMBLOCK(0,0,edi,SIZEOF_JCOEF)], mm0
+    movq        MMWORD [MMBLOCK(0,1,edi,SIZEOF_JCOEF)], mm0
+    movq        MMWORD [MMBLOCK(1,0,edi,SIZEOF_JCOEF)], mm1
+    movq        MMWORD [MMBLOCK(1,1,edi,SIZEOF_JCOEF)], mm1
+    movq        MMWORD [MMBLOCK(2,0,edi,SIZEOF_JCOEF)], mm2
+    movq        MMWORD [MMBLOCK(2,1,edi,SIZEOF_JCOEF)], mm2
+    movq        MMWORD [MMBLOCK(3,0,edi,SIZEOF_JCOEF)], mm3
+    movq        MMWORD [MMBLOCK(3,1,edi,SIZEOF_JCOEF)], mm3
+    jmp         near .nextcolumn
+    alignx      16, 7
+%endif
+.columnDCT:
+
+    ; -- Even part
+
+    movq        mm0, MMWORD [MMBLOCK(0,0,esi,SIZEOF_JCOEF)]
+    movq        mm1, MMWORD [MMBLOCK(2,0,esi,SIZEOF_JCOEF)]
+    pmullw      mm0, MMWORD [MMBLOCK(0,0,edx,SIZEOF_ISLOW_MULT_TYPE)]
+    pmullw      mm1, MMWORD [MMBLOCK(2,0,edx,SIZEOF_ISLOW_MULT_TYPE)]
+    movq        mm2, MMWORD [MMBLOCK(4,0,esi,SIZEOF_JCOEF)]
+    movq        mm3, MMWORD [MMBLOCK(6,0,esi,SIZEOF_JCOEF)]
+    pmullw      mm2, MMWORD [MMBLOCK(4,0,edx,SIZEOF_ISLOW_MULT_TYPE)]
+    pmullw      mm3, MMWORD [MMBLOCK(6,0,edx,SIZEOF_ISLOW_MULT_TYPE)]
+
+    ; (Original)
+    ; z1 = (z2 + z3) * 0.541196100;
+    ; tmp2 = z1 + z3 * -1.847759065;
+    ; tmp3 = z1 + z2 * 0.765366865;
+    ;
+    ; (This implementation)
+    ; tmp2 = z2 * 0.541196100 + z3 * (0.541196100 - 1.847759065);
+    ; tmp3 = z2 * (0.541196100 + 0.765366865) + z3 * 0.541196100;
+
+    movq        mm4, mm1                ; mm1=in2=z2
+    movq        mm5, mm1
+    punpcklwd   mm4, mm3                ; mm3=in6=z3
+    punpckhwd   mm5, mm3
+    movq        mm1, mm4
+    movq        mm3, mm5
+    pmaddwd     mm4, [GOTOFF(ebx,PW_F130_F054)]   ; mm4=tmp3L
+    pmaddwd     mm5, [GOTOFF(ebx,PW_F130_F054)]   ; mm5=tmp3H
+    pmaddwd     mm1, [GOTOFF(ebx,PW_F054_MF130)]  ; mm1=tmp2L
+    pmaddwd     mm3, [GOTOFF(ebx,PW_F054_MF130)]  ; mm3=tmp2H
+
+    movq        mm6, mm0
+    paddw       mm0, mm2                ; mm0=in0+in4
+    psubw       mm6, mm2                ; mm6=in0-in4
+
+    pxor        mm7, mm7
+    pxor        mm2, mm2
+    punpcklwd   mm7, mm0                ; mm7=tmp0L
+    punpckhwd   mm2, mm0                ; mm2=tmp0H
+    psrad       mm7, (16-CONST_BITS)    ; psrad mm7,16 & pslld mm7,CONST_BITS
+    psrad       mm2, (16-CONST_BITS)    ; psrad mm2,16 & pslld mm2,CONST_BITS
+
+    movq        mm0, mm7
+    paddd       mm7, mm4                ; mm7=tmp10L
+    psubd       mm0, mm4                ; mm0=tmp13L
+    movq        mm4, mm2
+    paddd       mm2, mm5                ; mm2=tmp10H
+    psubd       mm4, mm5                ; mm4=tmp13H
+
+    movq        MMWORD [wk(0)], mm7     ; wk(0)=tmp10L
+    movq        MMWORD [wk(1)], mm2     ; wk(1)=tmp10H
+    movq        MMWORD [wk(2)], mm0     ; wk(2)=tmp13L
+    movq        MMWORD [wk(3)], mm4     ; wk(3)=tmp13H
+
+    pxor        mm5, mm5
+    pxor        mm7, mm7
+    punpcklwd   mm5, mm6                ; mm5=tmp1L
+    punpckhwd   mm7, mm6                ; mm7=tmp1H
+    psrad       mm5, (16-CONST_BITS)    ; psrad mm5,16 & pslld mm5,CONST_BITS
+    psrad       mm7, (16-CONST_BITS)    ; psrad mm7,16 & pslld mm7,CONST_BITS
+
+    movq        mm2, mm5
+    paddd       mm5, mm1                ; mm5=tmp11L
+    psubd       mm2, mm1                ; mm2=tmp12L
+    movq        mm0, mm7
+    paddd       mm7, mm3                ; mm7=tmp11H
+    psubd       mm0, mm3                ; mm0=tmp12H
+
+    movq        MMWORD [wk(4)], mm5     ; wk(4)=tmp11L
+    movq        MMWORD [wk(5)], mm7     ; wk(5)=tmp11H
+    movq        MMWORD [wk(6)], mm2     ; wk(6)=tmp12L
+    movq        MMWORD [wk(7)], mm0     ; wk(7)=tmp12H
+
+    ; -- Odd part
+
+    movq        mm4, MMWORD [MMBLOCK(1,0,esi,SIZEOF_JCOEF)]
+    movq        mm6, MMWORD [MMBLOCK(3,0,esi,SIZEOF_JCOEF)]
+    pmullw      mm4, MMWORD [MMBLOCK(1,0,edx,SIZEOF_ISLOW_MULT_TYPE)]
+    pmullw      mm6, MMWORD [MMBLOCK(3,0,edx,SIZEOF_ISLOW_MULT_TYPE)]
+    movq        mm1, MMWORD [MMBLOCK(5,0,esi,SIZEOF_JCOEF)]
+    movq        mm3, MMWORD [MMBLOCK(7,0,esi,SIZEOF_JCOEF)]
+    pmullw      mm1, MMWORD [MMBLOCK(5,0,edx,SIZEOF_ISLOW_MULT_TYPE)]
+    pmullw      mm3, MMWORD [MMBLOCK(7,0,edx,SIZEOF_ISLOW_MULT_TYPE)]
+
+    movq        mm5, mm6
+    movq        mm7, mm4
+    paddw       mm5, mm3                ; mm5=z3
+    paddw       mm7, mm1                ; mm7=z4
+
+    ; (Original)
+    ; z5 = (z3 + z4) * 1.175875602;
+    ; z3 = z3 * -1.961570560;  z4 = z4 * -0.390180644;
+    ; z3 += z5;  z4 += z5;
+    ;
+    ; (This implementation)
+    ; z3 = z3 * (1.175875602 - 1.961570560) + z4 * 1.175875602;
+    ; z4 = z3 * 1.175875602 + z4 * (1.175875602 - 0.390180644);
+
+    movq        mm2, mm5
+    movq        mm0, mm5
+    punpcklwd   mm2, mm7
+    punpckhwd   mm0, mm7
+    movq        mm5, mm2
+    movq        mm7, mm0
+    pmaddwd     mm2, [GOTOFF(ebx,PW_MF078_F117)]  ; mm2=z3L
+    pmaddwd     mm0, [GOTOFF(ebx,PW_MF078_F117)]  ; mm0=z3H
+    pmaddwd     mm5, [GOTOFF(ebx,PW_F117_F078)]   ; mm5=z4L
+    pmaddwd     mm7, [GOTOFF(ebx,PW_F117_F078)]   ; mm7=z4H
+
+    movq        MMWORD [wk(10)], mm2    ; wk(10)=z3L
+    movq        MMWORD [wk(11)], mm0    ; wk(11)=z3H
+
+    ; (Original)
+    ; z1 = tmp0 + tmp3;  z2 = tmp1 + tmp2;
+    ; tmp0 = tmp0 * 0.298631336;  tmp1 = tmp1 * 2.053119869;
+    ; tmp2 = tmp2 * 3.072711026;  tmp3 = tmp3 * 1.501321110;
+    ; z1 = z1 * -0.899976223;  z2 = z2 * -2.562915447;
+    ; tmp0 += z1 + z3;  tmp1 += z2 + z4;
+    ; tmp2 += z2 + z3;  tmp3 += z1 + z4;
+    ;
+    ; (This implementation)
+    ; tmp0 = tmp0 * (0.298631336 - 0.899976223) + tmp3 * -0.899976223;
+    ; tmp1 = tmp1 * (2.053119869 - 2.562915447) + tmp2 * -2.562915447;
+    ; tmp2 = tmp1 * -2.562915447 + tmp2 * (3.072711026 - 2.562915447);
+    ; tmp3 = tmp0 * -0.899976223 + tmp3 * (1.501321110 - 0.899976223);
+    ; tmp0 += z3;  tmp1 += z4;
+    ; tmp2 += z3;  tmp3 += z4;
+
+    movq        mm2, mm3
+    movq        mm0, mm3
+    punpcklwd   mm2, mm4
+    punpckhwd   mm0, mm4
+    movq        mm3, mm2
+    movq        mm4, mm0
+    pmaddwd     mm2, [GOTOFF(ebx,PW_MF060_MF089)]  ; mm2=tmp0L
+    pmaddwd     mm0, [GOTOFF(ebx,PW_MF060_MF089)]  ; mm0=tmp0H
+    pmaddwd     mm3, [GOTOFF(ebx,PW_MF089_F060)]   ; mm3=tmp3L
+    pmaddwd     mm4, [GOTOFF(ebx,PW_MF089_F060)]   ; mm4=tmp3H
+
+    paddd       mm2, MMWORD [wk(10)]    ; mm2=tmp0L
+    paddd       mm0, MMWORD [wk(11)]    ; mm0=tmp0H
+    paddd       mm3, mm5                ; mm3=tmp3L
+    paddd       mm4, mm7                ; mm4=tmp3H
+
+    movq        MMWORD [wk(8)], mm2     ; wk(8)=tmp0L
+    movq        MMWORD [wk(9)], mm0     ; wk(9)=tmp0H
+
+    movq        mm2, mm1
+    movq        mm0, mm1
+    punpcklwd   mm2, mm6
+    punpckhwd   mm0, mm6
+    movq        mm1, mm2
+    movq        mm6, mm0
+    pmaddwd     mm2, [GOTOFF(ebx,PW_MF050_MF256)]  ; mm2=tmp1L
+    pmaddwd     mm0, [GOTOFF(ebx,PW_MF050_MF256)]  ; mm0=tmp1H
+    pmaddwd     mm1, [GOTOFF(ebx,PW_MF256_F050)]   ; mm1=tmp2L
+    pmaddwd     mm6, [GOTOFF(ebx,PW_MF256_F050)]   ; mm6=tmp2H
+
+    paddd       mm2, mm5                ; mm2=tmp1L
+    paddd       mm0, mm7                ; mm0=tmp1H
+    paddd       mm1, MMWORD [wk(10)]    ; mm1=tmp2L
+    paddd       mm6, MMWORD [wk(11)]    ; mm6=tmp2H
+
+    movq        MMWORD [wk(10)], mm2    ; wk(10)=tmp1L
+    movq        MMWORD [wk(11)], mm0    ; wk(11)=tmp1H
+
+    ; -- Final output stage
+
+    movq        mm5, MMWORD [wk(0)]     ; mm5=tmp10L
+    movq        mm7, MMWORD [wk(1)]     ; mm7=tmp10H
+
+    movq        mm2, mm5
+    movq        mm0, mm7
+    paddd       mm5, mm3                ; mm5=data0L
+    paddd       mm7, mm4                ; mm7=data0H
+    psubd       mm2, mm3                ; mm2=data7L
+    psubd       mm0, mm4                ; mm0=data7H
+
+    movq        mm3, [GOTOFF(ebx,PD_DESCALE_P1)]  ; mm3=[PD_DESCALE_P1]
+
+    paddd       mm5, mm3
+    paddd       mm7, mm3
+    psrad       mm5, DESCALE_P1
+    psrad       mm7, DESCALE_P1
+    paddd       mm2, mm3
+    paddd       mm0, mm3
+    psrad       mm2, DESCALE_P1
+    psrad       mm0, DESCALE_P1
+
+    packssdw    mm5, mm7                ; mm5=data0=(00 01 02 03)
+    packssdw    mm2, mm0                ; mm2=data7=(70 71 72 73)
+
+    movq        mm4, MMWORD [wk(4)]     ; mm4=tmp11L
+    movq        mm3, MMWORD [wk(5)]     ; mm3=tmp11H
+
+    movq        mm7, mm4
+    movq        mm0, mm3
+    paddd       mm4, mm1                ; mm4=data1L
+    paddd       mm3, mm6                ; mm3=data1H
+    psubd       mm7, mm1                ; mm7=data6L
+    psubd       mm0, mm6                ; mm0=data6H
+
+    movq        mm1, [GOTOFF(ebx,PD_DESCALE_P1)]  ; mm1=[PD_DESCALE_P1]
+
+    paddd       mm4, mm1
+    paddd       mm3, mm1
+    psrad       mm4, DESCALE_P1
+    psrad       mm3, DESCALE_P1
+    paddd       mm7, mm1
+    paddd       mm0, mm1
+    psrad       mm7, DESCALE_P1
+    psrad       mm0, DESCALE_P1
+
+    packssdw    mm4, mm3                ; mm4=data1=(10 11 12 13)
+    packssdw    mm7, mm0                ; mm7=data6=(60 61 62 63)
+
+    movq        mm6, mm5                ; transpose coefficients(phase 1)
+    punpcklwd   mm5, mm4                ; mm5=(00 10 01 11)
+    punpckhwd   mm6, mm4                ; mm6=(02 12 03 13)
+    movq        mm1, mm7                ; transpose coefficients(phase 1)
+    punpcklwd   mm7, mm2                ; mm7=(60 70 61 71)
+    punpckhwd   mm1, mm2                ; mm1=(62 72 63 73)
+
+    movq        mm3, MMWORD [wk(6)]     ; mm3=tmp12L
+    movq        mm0, MMWORD [wk(7)]     ; mm0=tmp12H
+    movq        mm4, MMWORD [wk(10)]    ; mm4=tmp1L
+    movq        mm2, MMWORD [wk(11)]    ; mm2=tmp1H
+
+    movq        MMWORD [wk(0)], mm5     ; wk(0)=(00 10 01 11)
+    movq        MMWORD [wk(1)], mm6     ; wk(1)=(02 12 03 13)
+    movq        MMWORD [wk(4)], mm7     ; wk(4)=(60 70 61 71)
+    movq        MMWORD [wk(5)], mm1     ; wk(5)=(62 72 63 73)
+
+    movq        mm5, mm3
+    movq        mm6, mm0
+    paddd       mm3, mm4                ; mm3=data2L
+    paddd       mm0, mm2                ; mm0=data2H
+    psubd       mm5, mm4                ; mm5=data5L
+    psubd       mm6, mm2                ; mm6=data5H
+
+    movq        mm7, [GOTOFF(ebx,PD_DESCALE_P1)]  ; mm7=[PD_DESCALE_P1]
+
+    paddd       mm3, mm7
+    paddd       mm0, mm7
+    psrad       mm3, DESCALE_P1
+    psrad       mm0, DESCALE_P1
+    paddd       mm5, mm7
+    paddd       mm6, mm7
+    psrad       mm5, DESCALE_P1
+    psrad       mm6, DESCALE_P1
+
+    packssdw    mm3, mm0                ; mm3=data2=(20 21 22 23)
+    packssdw    mm5, mm6                ; mm5=data5=(50 51 52 53)
+
+    movq        mm1, MMWORD [wk(2)]     ; mm1=tmp13L
+    movq        mm4, MMWORD [wk(3)]     ; mm4=tmp13H
+    movq        mm2, MMWORD [wk(8)]     ; mm2=tmp0L
+    movq        mm7, MMWORD [wk(9)]     ; mm7=tmp0H
+
+    movq        mm0, mm1
+    movq        mm6, mm4
+    paddd       mm1, mm2                ; mm1=data3L
+    paddd       mm4, mm7                ; mm4=data3H
+    psubd       mm0, mm2                ; mm0=data4L
+    psubd       mm6, mm7                ; mm6=data4H
+
+    movq        mm2, [GOTOFF(ebx,PD_DESCALE_P1)]  ; mm2=[PD_DESCALE_P1]
+
+    paddd       mm1, mm2
+    paddd       mm4, mm2
+    psrad       mm1, DESCALE_P1
+    psrad       mm4, DESCALE_P1
+    paddd       mm0, mm2
+    paddd       mm6, mm2
+    psrad       mm0, DESCALE_P1
+    psrad       mm6, DESCALE_P1
+
+    packssdw    mm1, mm4                ; mm1=data3=(30 31 32 33)
+    packssdw    mm0, mm6                ; mm0=data4=(40 41 42 43)
+
+    movq        mm7, MMWORD [wk(0)]     ; mm7=(00 10 01 11)
+    movq        mm2, MMWORD [wk(1)]     ; mm2=(02 12 03 13)
+
+    movq        mm4, mm3                ; transpose coefficients(phase 1)
+    punpcklwd   mm3, mm1                ; mm3=(20 30 21 31)
+    punpckhwd   mm4, mm1                ; mm4=(22 32 23 33)
+    movq        mm6, mm0                ; transpose coefficients(phase 1)
+    punpcklwd   mm0, mm5                ; mm0=(40 50 41 51)
+    punpckhwd   mm6, mm5                ; mm6=(42 52 43 53)
+
+    movq        mm1, mm7                ; transpose coefficients(phase 2)
+    punpckldq   mm7, mm3                ; mm7=(00 10 20 30)
+    punpckhdq   mm1, mm3                ; mm1=(01 11 21 31)
+    movq        mm5, mm2                ; transpose coefficients(phase 2)
+    punpckldq   mm2, mm4                ; mm2=(02 12 22 32)
+    punpckhdq   mm5, mm4                ; mm5=(03 13 23 33)
+
+    movq        mm3, MMWORD [wk(4)]     ; mm3=(60 70 61 71)
+    movq        mm4, MMWORD [wk(5)]     ; mm4=(62 72 63 73)
+
+    movq        MMWORD [MMBLOCK(0,0,edi,SIZEOF_JCOEF)], mm7
+    movq        MMWORD [MMBLOCK(1,0,edi,SIZEOF_JCOEF)], mm1
+    movq        MMWORD [MMBLOCK(2,0,edi,SIZEOF_JCOEF)], mm2
+    movq        MMWORD [MMBLOCK(3,0,edi,SIZEOF_JCOEF)], mm5
+
+    movq        mm7, mm0                ; transpose coefficients(phase 2)
+    punpckldq   mm0, mm3                ; mm0=(40 50 60 70)
+    punpckhdq   mm7, mm3                ; mm7=(41 51 61 71)
+    movq        mm1, mm6                ; transpose coefficients(phase 2)
+    punpckldq   mm6, mm4                ; mm6=(42 52 62 72)
+    punpckhdq   mm1, mm4                ; mm1=(43 53 63 73)
+
+    movq        MMWORD [MMBLOCK(0,1,edi,SIZEOF_JCOEF)], mm0
+    movq        MMWORD [MMBLOCK(1,1,edi,SIZEOF_JCOEF)], mm7
+    movq        MMWORD [MMBLOCK(2,1,edi,SIZEOF_JCOEF)], mm6
+    movq        MMWORD [MMBLOCK(3,1,edi,SIZEOF_JCOEF)], mm1
+
+.nextcolumn:
+    add         esi, byte 4*SIZEOF_JCOEF            ; coef_block
+    add         edx, byte 4*SIZEOF_ISLOW_MULT_TYPE  ; quantptr
+    add         edi, byte 4*DCTSIZE*SIZEOF_JCOEF    ; wsptr
+    dec         ecx                                 ; ctr
+    jnz         near .columnloop
+
+    ; ---- Pass 2: process rows from work array, store into output array.
+
+    mov         eax, [original_ebp]
+    lea         esi, [workspace]                   ; JCOEF *wsptr
+    mov         edi, JSAMPARRAY [output_buf(eax)]  ; (JSAMPROW *)
+    mov         eax, JDIMENSION [output_col(eax)]
+    mov         ecx, DCTSIZE/4                     ; ctr
+    alignx      16, 7
+.rowloop:
+
+    ; -- Even part
+
+    movq        mm0, MMWORD [MMBLOCK(0,0,esi,SIZEOF_JCOEF)]
+    movq        mm1, MMWORD [MMBLOCK(2,0,esi,SIZEOF_JCOEF)]
+    movq        mm2, MMWORD [MMBLOCK(4,0,esi,SIZEOF_JCOEF)]
+    movq        mm3, MMWORD [MMBLOCK(6,0,esi,SIZEOF_JCOEF)]
+
+    ; (Original)
+    ; z1 = (z2 + z3) * 0.541196100;
+    ; tmp2 = z1 + z3 * -1.847759065;
+    ; tmp3 = z1 + z2 * 0.765366865;
+    ;
+    ; (This implementation)
+    ; tmp2 = z2 * 0.541196100 + z3 * (0.541196100 - 1.847759065);
+    ; tmp3 = z2 * (0.541196100 + 0.765366865) + z3 * 0.541196100;
+
+    movq        mm4, mm1                ; mm1=in2=z2
+    movq        mm5, mm1
+    punpcklwd   mm4, mm3                ; mm3=in6=z3
+    punpckhwd   mm5, mm3
+    movq        mm1, mm4
+    movq        mm3, mm5
+    pmaddwd     mm4, [GOTOFF(ebx,PW_F130_F054)]   ; mm4=tmp3L
+    pmaddwd     mm5, [GOTOFF(ebx,PW_F130_F054)]   ; mm5=tmp3H
+    pmaddwd     mm1, [GOTOFF(ebx,PW_F054_MF130)]  ; mm1=tmp2L
+    pmaddwd     mm3, [GOTOFF(ebx,PW_F054_MF130)]  ; mm3=tmp2H
+
+    movq        mm6, mm0
+    paddw       mm0, mm2                ; mm0=in0+in4
+    psubw       mm6, mm2                ; mm6=in0-in4
+
+    pxor        mm7, mm7
+    pxor        mm2, mm2
+    punpcklwd   mm7, mm0                ; mm7=tmp0L
+    punpckhwd   mm2, mm0                ; mm2=tmp0H
+    psrad       mm7, (16-CONST_BITS)    ; psrad mm7,16 & pslld mm7,CONST_BITS
+    psrad       mm2, (16-CONST_BITS)    ; psrad mm2,16 & pslld mm2,CONST_BITS
+
+    movq        mm0, mm7
+    paddd       mm7, mm4                ; mm7=tmp10L
+    psubd       mm0, mm4                ; mm0=tmp13L
+    movq        mm4, mm2
+    paddd       mm2, mm5                ; mm2=tmp10H
+    psubd       mm4, mm5                ; mm4=tmp13H
+
+    movq        MMWORD [wk(0)], mm7     ; wk(0)=tmp10L
+    movq        MMWORD [wk(1)], mm2     ; wk(1)=tmp10H
+    movq        MMWORD [wk(2)], mm0     ; wk(2)=tmp13L
+    movq        MMWORD [wk(3)], mm4     ; wk(3)=tmp13H
+
+    pxor        mm5, mm5
+    pxor        mm7, mm7
+    punpcklwd   mm5, mm6                ; mm5=tmp1L
+    punpckhwd   mm7, mm6                ; mm7=tmp1H
+    psrad       mm5, (16-CONST_BITS)    ; psrad mm5,16 & pslld mm5,CONST_BITS
+    psrad       mm7, (16-CONST_BITS)    ; psrad mm7,16 & pslld mm7,CONST_BITS
+
+    movq        mm2, mm5
+    paddd       mm5, mm1                ; mm5=tmp11L
+    psubd       mm2, mm1                ; mm2=tmp12L
+    movq        mm0, mm7
+    paddd       mm7, mm3                ; mm7=tmp11H
+    psubd       mm0, mm3                ; mm0=tmp12H
+
+    movq        MMWORD [wk(4)], mm5     ; wk(4)=tmp11L
+    movq        MMWORD [wk(5)], mm7     ; wk(5)=tmp11H
+    movq        MMWORD [wk(6)], mm2     ; wk(6)=tmp12L
+    movq        MMWORD [wk(7)], mm0     ; wk(7)=tmp12H
+
+    ; -- Odd part
+
+    movq        mm4, MMWORD [MMBLOCK(1,0,esi,SIZEOF_JCOEF)]
+    movq        mm6, MMWORD [MMBLOCK(3,0,esi,SIZEOF_JCOEF)]
+    movq        mm1, MMWORD [MMBLOCK(5,0,esi,SIZEOF_JCOEF)]
+    movq        mm3, MMWORD [MMBLOCK(7,0,esi,SIZEOF_JCOEF)]
+
+    movq        mm5, mm6
+    movq        mm7, mm4
+    paddw       mm5, mm3                ; mm5=z3
+    paddw       mm7, mm1                ; mm7=z4
+
+    ; (Original)
+    ; z5 = (z3 + z4) * 1.175875602;
+    ; z3 = z3 * -1.961570560;  z4 = z4 * -0.390180644;
+    ; z3 += z5;  z4 += z5;
+    ;
+    ; (This implementation)
+    ; z3 = z3 * (1.175875602 - 1.961570560) + z4 * 1.175875602;
+    ; z4 = z3 * 1.175875602 + z4 * (1.175875602 - 0.390180644);
+
+    movq        mm2, mm5
+    movq        mm0, mm5
+    punpcklwd   mm2, mm7
+    punpckhwd   mm0, mm7
+    movq        mm5, mm2
+    movq        mm7, mm0
+    pmaddwd     mm2, [GOTOFF(ebx,PW_MF078_F117)]  ; mm2=z3L
+    pmaddwd     mm0, [GOTOFF(ebx,PW_MF078_F117)]  ; mm0=z3H
+    pmaddwd     mm5, [GOTOFF(ebx,PW_F117_F078)]   ; mm5=z4L
+    pmaddwd     mm7, [GOTOFF(ebx,PW_F117_F078)]   ; mm7=z4H
+
+    movq        MMWORD [wk(10)], mm2    ; wk(10)=z3L
+    movq        MMWORD [wk(11)], mm0    ; wk(11)=z3H
+
+    ; (Original)
+    ; z1 = tmp0 + tmp3;  z2 = tmp1 + tmp2;
+    ; tmp0 = tmp0 * 0.298631336;  tmp1 = tmp1 * 2.053119869;
+    ; tmp2 = tmp2 * 3.072711026;  tmp3 = tmp3 * 1.501321110;
+    ; z1 = z1 * -0.899976223;  z2 = z2 * -2.562915447;
+    ; tmp0 += z1 + z3;  tmp1 += z2 + z4;
+    ; tmp2 += z2 + z3;  tmp3 += z1 + z4;
+    ;
+    ; (This implementation)
+    ; tmp0 = tmp0 * (0.298631336 - 0.899976223) + tmp3 * -0.899976223;
+    ; tmp1 = tmp1 * (2.053119869 - 2.562915447) + tmp2 * -2.562915447;
+    ; tmp2 = tmp1 * -2.562915447 + tmp2 * (3.072711026 - 2.562915447);
+    ; tmp3 = tmp0 * -0.899976223 + tmp3 * (1.501321110 - 0.899976223);
+    ; tmp0 += z3;  tmp1 += z4;
+    ; tmp2 += z3;  tmp3 += z4;
+
+    movq        mm2, mm3
+    movq        mm0, mm3
+    punpcklwd   mm2, mm4
+    punpckhwd   mm0, mm4
+    movq        mm3, mm2
+    movq        mm4, mm0
+    pmaddwd     mm2, [GOTOFF(ebx,PW_MF060_MF089)]  ; mm2=tmp0L
+    pmaddwd     mm0, [GOTOFF(ebx,PW_MF060_MF089)]  ; mm0=tmp0H
+    pmaddwd     mm3, [GOTOFF(ebx,PW_MF089_F060)]   ; mm3=tmp3L
+    pmaddwd     mm4, [GOTOFF(ebx,PW_MF089_F060)]   ; mm4=tmp3H
+
+    paddd       mm2, MMWORD [wk(10)]    ; mm2=tmp0L
+    paddd       mm0, MMWORD [wk(11)]    ; mm0=tmp0H
+    paddd       mm3, mm5                ; mm3=tmp3L
+    paddd       mm4, mm7                ; mm4=tmp3H
+
+    movq        MMWORD [wk(8)], mm2     ; wk(8)=tmp0L
+    movq        MMWORD [wk(9)], mm0     ; wk(9)=tmp0H
+
+    movq        mm2, mm1
+    movq        mm0, mm1
+    punpcklwd   mm2, mm6
+    punpckhwd   mm0, mm6
+    movq        mm1, mm2
+    movq        mm6, mm0
+    pmaddwd     mm2, [GOTOFF(ebx,PW_MF050_MF256)]  ; mm2=tmp1L
+    pmaddwd     mm0, [GOTOFF(ebx,PW_MF050_MF256)]  ; mm0=tmp1H
+    pmaddwd     mm1, [GOTOFF(ebx,PW_MF256_F050)]   ; mm1=tmp2L
+    pmaddwd     mm6, [GOTOFF(ebx,PW_MF256_F050)]   ; mm6=tmp2H
+
+    paddd       mm2, mm5                ; mm2=tmp1L
+    paddd       mm0, mm7                ; mm0=tmp1H
+    paddd       mm1, MMWORD [wk(10)]    ; mm1=tmp2L
+    paddd       mm6, MMWORD [wk(11)]    ; mm6=tmp2H
+
+    movq        MMWORD [wk(10)], mm2    ; wk(10)=tmp1L
+    movq        MMWORD [wk(11)], mm0    ; wk(11)=tmp1H
+
+    ; -- Final output stage
+
+    movq        mm5, MMWORD [wk(0)]     ; mm5=tmp10L
+    movq        mm7, MMWORD [wk(1)]     ; mm7=tmp10H
+
+    movq        mm2, mm5
+    movq        mm0, mm7
+    paddd       mm5, mm3                ; mm5=data0L
+    paddd       mm7, mm4                ; mm7=data0H
+    psubd       mm2, mm3                ; mm2=data7L
+    psubd       mm0, mm4                ; mm0=data7H
+
+    movq        mm3, [GOTOFF(ebx,PD_DESCALE_P2)]  ; mm3=[PD_DESCALE_P2]
+
+    paddd       mm5, mm3
+    paddd       mm7, mm3
+    psrad       mm5, DESCALE_P2
+    psrad       mm7, DESCALE_P2
+    paddd       mm2, mm3
+    paddd       mm0, mm3
+    psrad       mm2, DESCALE_P2
+    psrad       mm0, DESCALE_P2
+
+    packssdw    mm5, mm7                ; mm5=data0=(00 10 20 30)
+    packssdw    mm2, mm0                ; mm2=data7=(07 17 27 37)
+
+    movq        mm4, MMWORD [wk(4)]     ; mm4=tmp11L
+    movq        mm3, MMWORD [wk(5)]     ; mm3=tmp11H
+
+    movq        mm7, mm4
+    movq        mm0, mm3
+    paddd       mm4, mm1                ; mm4=data1L
+    paddd       mm3, mm6                ; mm3=data1H
+    psubd       mm7, mm1                ; mm7=data6L
+    psubd       mm0, mm6                ; mm0=data6H
+
+    movq        mm1, [GOTOFF(ebx,PD_DESCALE_P2)]  ; mm1=[PD_DESCALE_P2]
+
+    paddd       mm4, mm1
+    paddd       mm3, mm1
+    psrad       mm4, DESCALE_P2
+    psrad       mm3, DESCALE_P2
+    paddd       mm7, mm1
+    paddd       mm0, mm1
+    psrad       mm7, DESCALE_P2
+    psrad       mm0, DESCALE_P2
+
+    packssdw    mm4, mm3                ; mm4=data1=(01 11 21 31)
+    packssdw    mm7, mm0                ; mm7=data6=(06 16 26 36)
+
+    packsswb    mm5, mm7                ; mm5=(00 10 20 30 06 16 26 36)
+    packsswb    mm4, mm2                ; mm4=(01 11 21 31 07 17 27 37)
+
+    movq        mm6, MMWORD [wk(6)]     ; mm6=tmp12L
+    movq        mm1, MMWORD [wk(7)]     ; mm1=tmp12H
+    movq        mm3, MMWORD [wk(10)]    ; mm3=tmp1L
+    movq        mm0, MMWORD [wk(11)]    ; mm0=tmp1H
+
+    movq        MMWORD [wk(0)], mm5     ; wk(0)=(00 10 20 30 06 16 26 36)
+    movq        MMWORD [wk(1)], mm4     ; wk(1)=(01 11 21 31 07 17 27 37)
+
+    movq        mm7, mm6
+    movq        mm2, mm1
+    paddd       mm6, mm3                ; mm6=data2L
+    paddd       mm1, mm0                ; mm1=data2H
+    psubd       mm7, mm3                ; mm7=data5L
+    psubd       mm2, mm0                ; mm2=data5H
+
+    movq        mm5, [GOTOFF(ebx,PD_DESCALE_P2)]  ; mm5=[PD_DESCALE_P2]
+
+    paddd       mm6, mm5
+    paddd       mm1, mm5
+    psrad       mm6, DESCALE_P2
+    psrad       mm1, DESCALE_P2
+    paddd       mm7, mm5
+    paddd       mm2, mm5
+    psrad       mm7, DESCALE_P2
+    psrad       mm2, DESCALE_P2
+
+    packssdw    mm6, mm1                ; mm6=data2=(02 12 22 32)
+    packssdw    mm7, mm2                ; mm7=data5=(05 15 25 35)
+
+    movq        mm4, MMWORD [wk(2)]     ; mm4=tmp13L
+    movq        mm3, MMWORD [wk(3)]     ; mm3=tmp13H
+    movq        mm0, MMWORD [wk(8)]     ; mm0=tmp0L
+    movq        mm5, MMWORD [wk(9)]     ; mm5=tmp0H
+
+    movq        mm1, mm4
+    movq        mm2, mm3
+    paddd       mm4, mm0                ; mm4=data3L
+    paddd       mm3, mm5                ; mm3=data3H
+    psubd       mm1, mm0                ; mm1=data4L
+    psubd       mm2, mm5                ; mm2=data4H
+
+    movq        mm0, [GOTOFF(ebx,PD_DESCALE_P2)]  ; mm0=[PD_DESCALE_P2]
+
+    paddd       mm4, mm0
+    paddd       mm3, mm0
+    psrad       mm4, DESCALE_P2
+    psrad       mm3, DESCALE_P2
+    paddd       mm1, mm0
+    paddd       mm2, mm0
+    psrad       mm1, DESCALE_P2
+    psrad       mm2, DESCALE_P2
+
+    movq        mm5, [GOTOFF(ebx,PB_CENTERJSAMP)]  ; mm5=[PB_CENTERJSAMP]
+
+    packssdw    mm4, mm3                ; mm4=data3=(03 13 23 33)
+    packssdw    mm1, mm2                ; mm1=data4=(04 14 24 34)
+
+    movq        mm0, MMWORD [wk(0)]     ; mm0=(00 10 20 30 06 16 26 36)
+    movq        mm3, MMWORD [wk(1)]     ; mm3=(01 11 21 31 07 17 27 37)
+
+    packsswb    mm6, mm1                ; mm6=(02 12 22 32 04 14 24 34)
+    packsswb    mm4, mm7                ; mm4=(03 13 23 33 05 15 25 35)
+
+    paddb       mm0, mm5
+    paddb       mm3, mm5
+    paddb       mm6, mm5
+    paddb       mm4, mm5
+
+    movq        mm2, mm0                ; transpose coefficients(phase 1)
+    punpcklbw   mm0, mm3                ; mm0=(00 01 10 11 20 21 30 31)
+    punpckhbw   mm2, mm3                ; mm2=(06 07 16 17 26 27 36 37)
+    movq        mm1, mm6                ; transpose coefficients(phase 1)
+    punpcklbw   mm6, mm4                ; mm6=(02 03 12 13 22 23 32 33)
+    punpckhbw   mm1, mm4                ; mm1=(04 05 14 15 24 25 34 35)
+
+    movq        mm7, mm0                ; transpose coefficients(phase 2)
+    punpcklwd   mm0, mm6                ; mm0=(00 01 02 03 10 11 12 13)
+    punpckhwd   mm7, mm6                ; mm7=(20 21 22 23 30 31 32 33)
+    movq        mm5, mm1                ; transpose coefficients(phase 2)
+    punpcklwd   mm1, mm2                ; mm1=(04 05 06 07 14 15 16 17)
+    punpckhwd   mm5, mm2                ; mm5=(24 25 26 27 34 35 36 37)
+
+    movq        mm3, mm0                ; transpose coefficients(phase 3)
+    punpckldq   mm0, mm1                ; mm0=(00 01 02 03 04 05 06 07)
+    punpckhdq   mm3, mm1                ; mm3=(10 11 12 13 14 15 16 17)
+    movq        mm4, mm7                ; transpose coefficients(phase 3)
+    punpckldq   mm7, mm5                ; mm7=(20 21 22 23 24 25 26 27)
+    punpckhdq   mm4, mm5                ; mm4=(30 31 32 33 34 35 36 37)
+
+    pushpic     ebx                     ; save GOT address
+
+    mov         edx, JSAMPROW [edi+0*SIZEOF_JSAMPROW]
+    mov         ebx, JSAMPROW [edi+1*SIZEOF_JSAMPROW]
+    movq        MMWORD [edx+eax*SIZEOF_JSAMPLE], mm0
+    movq        MMWORD [ebx+eax*SIZEOF_JSAMPLE], mm3
+    mov         edx, JSAMPROW [edi+2*SIZEOF_JSAMPROW]
+    mov         ebx, JSAMPROW [edi+3*SIZEOF_JSAMPROW]
+    movq        MMWORD [edx+eax*SIZEOF_JSAMPLE], mm7
+    movq        MMWORD [ebx+eax*SIZEOF_JSAMPLE], mm4
+
+    poppic      ebx                     ; restore GOT address
+
+    add         esi, byte 4*SIZEOF_JCOEF     ; wsptr
+    add         edi, byte 4*SIZEOF_JSAMPROW
+    dec         ecx                          ; ctr
+    jnz         near .rowloop
+
+    emms                                ; empty MMX state
+
+    pop         edi
+    pop         esi
+;   pop         edx                     ; need not be preserved
+;   pop         ecx                     ; need not be preserved
+    pop         ebx
+    mov         esp, ebp                ; esp <- aligned ebp
+    pop         esp                     ; esp <- original ebp
+    pop         ebp
+    ret
+
+; For some reason, the OS X linker does not honor the request to align the
+; segment unless we do this.
+    align       32
diff --git a/3rdparty/libjpeg/src/simd/i386/jidctint-sse2.asm b/3rdparty/libjpeg/src/simd/i386/jidctint-sse2.asm
new file mode 100644
index 00000000..43e32018
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/i386/jidctint-sse2.asm
@@ -0,0 +1,858 @@
+;
+; jidctint.asm - accurate integer IDCT (SSE2)
+;
+; Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+; Copyright (C) 2016, 2020, D. R. Commander.
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+;
+; This file should be assembled with NASM (Netwide Assembler),
+; can *not* be assembled with Microsoft's MASM or any compatible
+; assembler (including Borland's Turbo Assembler).
+; NASM is available from http://nasm.sourceforge.net/ or
+; http://sourceforge.net/project/showfiles.php?group_id=6208
+;
+; This file contains a slower but more accurate integer implementation of the
+; inverse DCT (Discrete Cosine Transform). The following code is based
+; directly on the IJG's original jidctint.c; see the jidctint.c for
+; more details.
+
+%include "jsimdext.inc"
+%include "jdct.inc"
+
+; --------------------------------------------------------------------------
+
+%define CONST_BITS  13
+%define PASS1_BITS  2
+
+%define DESCALE_P1  (CONST_BITS - PASS1_BITS)
+%define DESCALE_P2  (CONST_BITS + PASS1_BITS + 3)
+
+%if CONST_BITS == 13
+F_0_298 equ  2446  ; FIX(0.298631336)
+F_0_390 equ  3196  ; FIX(0.390180644)
+F_0_541 equ  4433  ; FIX(0.541196100)
+F_0_765 equ  6270  ; FIX(0.765366865)
+F_0_899 equ  7373  ; FIX(0.899976223)
+F_1_175 equ  9633  ; FIX(1.175875602)
+F_1_501 equ 12299  ; FIX(1.501321110)
+F_1_847 equ 15137  ; FIX(1.847759065)
+F_1_961 equ 16069  ; FIX(1.961570560)
+F_2_053 equ 16819  ; FIX(2.053119869)
+F_2_562 equ 20995  ; FIX(2.562915447)
+F_3_072 equ 25172  ; FIX(3.072711026)
+%else
+; NASM cannot do compile-time arithmetic on floating-point constants.
+%define DESCALE(x, n)  (((x) + (1 << ((n) - 1))) >> (n))
+F_0_298 equ DESCALE( 320652955, 30 - CONST_BITS)  ; FIX(0.298631336)
+F_0_390 equ DESCALE( 418953276, 30 - CONST_BITS)  ; FIX(0.390180644)
+F_0_541 equ DESCALE( 581104887, 30 - CONST_BITS)  ; FIX(0.541196100)
+F_0_765 equ DESCALE( 821806413, 30 - CONST_BITS)  ; FIX(0.765366865)
+F_0_899 equ DESCALE( 966342111, 30 - CONST_BITS)  ; FIX(0.899976223)
+F_1_175 equ DESCALE(1262586813, 30 - CONST_BITS)  ; FIX(1.175875602)
+F_1_501 equ DESCALE(1612031267, 30 - CONST_BITS)  ; FIX(1.501321110)
+F_1_847 equ DESCALE(1984016188, 30 - CONST_BITS)  ; FIX(1.847759065)
+F_1_961 equ DESCALE(2106220350, 30 - CONST_BITS)  ; FIX(1.961570560)
+F_2_053 equ DESCALE(2204520673, 30 - CONST_BITS)  ; FIX(2.053119869)
+F_2_562 equ DESCALE(2751909506, 30 - CONST_BITS)  ; FIX(2.562915447)
+F_3_072 equ DESCALE(3299298341, 30 - CONST_BITS)  ; FIX(3.072711026)
+%endif
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_CONST
+
+    alignz      32
+    GLOBAL_DATA(jconst_idct_islow_sse2)
+
+EXTN(jconst_idct_islow_sse2):
+
+PW_F130_F054   times 4  dw  (F_0_541 + F_0_765),  F_0_541
+PW_F054_MF130  times 4  dw  F_0_541, (F_0_541 - F_1_847)
+PW_MF078_F117  times 4  dw  (F_1_175 - F_1_961),  F_1_175
+PW_F117_F078   times 4  dw  F_1_175, (F_1_175 - F_0_390)
+PW_MF060_MF089 times 4  dw  (F_0_298 - F_0_899), -F_0_899
+PW_MF089_F060  times 4  dw -F_0_899, (F_1_501 - F_0_899)
+PW_MF050_MF256 times 4  dw  (F_2_053 - F_2_562), -F_2_562
+PW_MF256_F050  times 4  dw -F_2_562, (F_3_072 - F_2_562)
+PD_DESCALE_P1  times 4  dd  1 << (DESCALE_P1 - 1)
+PD_DESCALE_P2  times 4  dd  1 << (DESCALE_P2 - 1)
+PB_CENTERJSAMP times 16 db  CENTERJSAMPLE
+
+    alignz      32
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_TEXT
+    BITS        32
+;
+; Perform dequantization and inverse DCT on one block of coefficients.
+;
+; GLOBAL(void)
+; jsimd_idct_islow_sse2(void *dct_table, JCOEFPTR coef_block,
+;                       JSAMPARRAY output_buf, JDIMENSION output_col)
+;
+
+%define dct_table(b)   (b) + 8          ; jpeg_component_info *compptr
+%define coef_block(b)  (b) + 12         ; JCOEFPTR coef_block
+%define output_buf(b)  (b) + 16         ; JSAMPARRAY output_buf
+%define output_col(b)  (b) + 20         ; JDIMENSION output_col
+
+%define original_ebp   ebp + 0
+%define wk(i)          ebp - (WK_NUM - (i)) * SIZEOF_XMMWORD
+                                        ; xmmword wk[WK_NUM]
+%define WK_NUM         12
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_idct_islow_sse2)
+
+EXTN(jsimd_idct_islow_sse2):
+    push        ebp
+    mov         eax, esp                     ; eax = original ebp
+    sub         esp, byte 4
+    and         esp, byte (-SIZEOF_XMMWORD)  ; align to 128 bits
+    mov         [esp], eax
+    mov         ebp, esp                     ; ebp = aligned ebp
+    lea         esp, [wk(0)]
+    pushpic     ebx
+;   push        ecx                     ; unused
+;   push        edx                     ; need not be preserved
+    push        esi
+    push        edi
+
+    get_GOT     ebx                     ; get GOT address
+
+    ; ---- Pass 1: process columns from input.
+
+;   mov         eax, [original_ebp]
+    mov         edx, POINTER [dct_table(eax)]    ; quantptr
+    mov         esi, JCOEFPTR [coef_block(eax)]  ; inptr
+
+%ifndef NO_ZERO_COLUMN_TEST_ISLOW_SSE2
+    mov         eax, dword [DWBLOCK(1,0,esi,SIZEOF_JCOEF)]
+    or          eax, dword [DWBLOCK(2,0,esi,SIZEOF_JCOEF)]
+    jnz         near .columnDCT
+
+    movdqa      xmm0, XMMWORD [XMMBLOCK(1,0,esi,SIZEOF_JCOEF)]
+    movdqa      xmm1, XMMWORD [XMMBLOCK(2,0,esi,SIZEOF_JCOEF)]
+    por         xmm0, XMMWORD [XMMBLOCK(3,0,esi,SIZEOF_JCOEF)]
+    por         xmm1, XMMWORD [XMMBLOCK(4,0,esi,SIZEOF_JCOEF)]
+    por         xmm0, XMMWORD [XMMBLOCK(5,0,esi,SIZEOF_JCOEF)]
+    por         xmm1, XMMWORD [XMMBLOCK(6,0,esi,SIZEOF_JCOEF)]
+    por         xmm0, XMMWORD [XMMBLOCK(7,0,esi,SIZEOF_JCOEF)]
+    por         xmm1, xmm0
+    packsswb    xmm1, xmm1
+    packsswb    xmm1, xmm1
+    movd        eax, xmm1
+    test        eax, eax
+    jnz         short .columnDCT
+
+    ; -- AC terms all zero
+
+    movdqa      xmm5, XMMWORD [XMMBLOCK(0,0,esi,SIZEOF_JCOEF)]
+    pmullw      xmm5, XMMWORD [XMMBLOCK(0,0,edx,SIZEOF_ISLOW_MULT_TYPE)]
+
+    psllw       xmm5, PASS1_BITS
+
+    movdqa      xmm4, xmm5              ; xmm5=in0=(00 01 02 03 04 05 06 07)
+    punpcklwd   xmm5, xmm5              ; xmm5=(00 00 01 01 02 02 03 03)
+    punpckhwd   xmm4, xmm4              ; xmm4=(04 04 05 05 06 06 07 07)
+
+    pshufd      xmm7, xmm5, 0x00        ; xmm7=col0=(00 00 00 00 00 00 00 00)
+    pshufd      xmm6, xmm5, 0x55        ; xmm6=col1=(01 01 01 01 01 01 01 01)
+    pshufd      xmm1, xmm5, 0xAA        ; xmm1=col2=(02 02 02 02 02 02 02 02)
+    pshufd      xmm5, xmm5, 0xFF        ; xmm5=col3=(03 03 03 03 03 03 03 03)
+    pshufd      xmm0, xmm4, 0x00        ; xmm0=col4=(04 04 04 04 04 04 04 04)
+    pshufd      xmm3, xmm4, 0x55        ; xmm3=col5=(05 05 05 05 05 05 05 05)
+    pshufd      xmm2, xmm4, 0xAA        ; xmm2=col6=(06 06 06 06 06 06 06 06)
+    pshufd      xmm4, xmm4, 0xFF        ; xmm4=col7=(07 07 07 07 07 07 07 07)
+
+    movdqa      XMMWORD [wk(8)], xmm6   ; wk(8)=col1
+    movdqa      XMMWORD [wk(9)], xmm5   ; wk(9)=col3
+    movdqa      XMMWORD [wk(10)], xmm3  ; wk(10)=col5
+    movdqa      XMMWORD [wk(11)], xmm4  ; wk(11)=col7
+    jmp         near .column_end
+    alignx      16, 7
+%endif
+.columnDCT:
+
+    ; -- Even part
+
+    movdqa      xmm0, XMMWORD [XMMBLOCK(0,0,esi,SIZEOF_JCOEF)]
+    movdqa      xmm1, XMMWORD [XMMBLOCK(2,0,esi,SIZEOF_JCOEF)]
+    pmullw      xmm0, XMMWORD [XMMBLOCK(0,0,edx,SIZEOF_ISLOW_MULT_TYPE)]
+    pmullw      xmm1, XMMWORD [XMMBLOCK(2,0,edx,SIZEOF_ISLOW_MULT_TYPE)]
+    movdqa      xmm2, XMMWORD [XMMBLOCK(4,0,esi,SIZEOF_JCOEF)]
+    movdqa      xmm3, XMMWORD [XMMBLOCK(6,0,esi,SIZEOF_JCOEF)]
+    pmullw      xmm2, XMMWORD [XMMBLOCK(4,0,edx,SIZEOF_ISLOW_MULT_TYPE)]
+    pmullw      xmm3, XMMWORD [XMMBLOCK(6,0,edx,SIZEOF_ISLOW_MULT_TYPE)]
+
+    ; (Original)
+    ; z1 = (z2 + z3) * 0.541196100;
+    ; tmp2 = z1 + z3 * -1.847759065;
+    ; tmp3 = z1 + z2 * 0.765366865;
+    ;
+    ; (This implementation)
+    ; tmp2 = z2 * 0.541196100 + z3 * (0.541196100 - 1.847759065);
+    ; tmp3 = z2 * (0.541196100 + 0.765366865) + z3 * 0.541196100;
+
+    movdqa      xmm4, xmm1              ; xmm1=in2=z2
+    movdqa      xmm5, xmm1
+    punpcklwd   xmm4, xmm3              ; xmm3=in6=z3
+    punpckhwd   xmm5, xmm3
+    movdqa      xmm1, xmm4
+    movdqa      xmm3, xmm5
+    pmaddwd     xmm4, [GOTOFF(ebx,PW_F130_F054)]   ; xmm4=tmp3L
+    pmaddwd     xmm5, [GOTOFF(ebx,PW_F130_F054)]   ; xmm5=tmp3H
+    pmaddwd     xmm1, [GOTOFF(ebx,PW_F054_MF130)]  ; xmm1=tmp2L
+    pmaddwd     xmm3, [GOTOFF(ebx,PW_F054_MF130)]  ; xmm3=tmp2H
+
+    movdqa      xmm6, xmm0
+    paddw       xmm0, xmm2              ; xmm0=in0+in4
+    psubw       xmm6, xmm2              ; xmm6=in0-in4
+
+    pxor        xmm7, xmm7
+    pxor        xmm2, xmm2
+    punpcklwd   xmm7, xmm0              ; xmm7=tmp0L
+    punpckhwd   xmm2, xmm0              ; xmm2=tmp0H
+    psrad       xmm7, (16-CONST_BITS)   ; psrad xmm7,16 & pslld xmm7,CONST_BITS
+    psrad       xmm2, (16-CONST_BITS)   ; psrad xmm2,16 & pslld xmm2,CONST_BITS
+
+    movdqa      xmm0, xmm7
+    paddd       xmm7, xmm4              ; xmm7=tmp10L
+    psubd       xmm0, xmm4              ; xmm0=tmp13L
+    movdqa      xmm4, xmm2
+    paddd       xmm2, xmm5              ; xmm2=tmp10H
+    psubd       xmm4, xmm5              ; xmm4=tmp13H
+
+    movdqa      XMMWORD [wk(0)], xmm7   ; wk(0)=tmp10L
+    movdqa      XMMWORD [wk(1)], xmm2   ; wk(1)=tmp10H
+    movdqa      XMMWORD [wk(2)], xmm0   ; wk(2)=tmp13L
+    movdqa      XMMWORD [wk(3)], xmm4   ; wk(3)=tmp13H
+
+    pxor        xmm5, xmm5
+    pxor        xmm7, xmm7
+    punpcklwd   xmm5, xmm6              ; xmm5=tmp1L
+    punpckhwd   xmm7, xmm6              ; xmm7=tmp1H
+    psrad       xmm5, (16-CONST_BITS)   ; psrad xmm5,16 & pslld xmm5,CONST_BITS
+    psrad       xmm7, (16-CONST_BITS)   ; psrad xmm7,16 & pslld xmm7,CONST_BITS
+
+    movdqa      xmm2, xmm5
+    paddd       xmm5, xmm1              ; xmm5=tmp11L
+    psubd       xmm2, xmm1              ; xmm2=tmp12L
+    movdqa      xmm0, xmm7
+    paddd       xmm7, xmm3              ; xmm7=tmp11H
+    psubd       xmm0, xmm3              ; xmm0=tmp12H
+
+    movdqa      XMMWORD [wk(4)], xmm5   ; wk(4)=tmp11L
+    movdqa      XMMWORD [wk(5)], xmm7   ; wk(5)=tmp11H
+    movdqa      XMMWORD [wk(6)], xmm2   ; wk(6)=tmp12L
+    movdqa      XMMWORD [wk(7)], xmm0   ; wk(7)=tmp12H
+
+    ; -- Odd part
+
+    movdqa      xmm4, XMMWORD [XMMBLOCK(1,0,esi,SIZEOF_JCOEF)]
+    movdqa      xmm6, XMMWORD [XMMBLOCK(3,0,esi,SIZEOF_JCOEF)]
+    pmullw      xmm4, XMMWORD [XMMBLOCK(1,0,edx,SIZEOF_ISLOW_MULT_TYPE)]
+    pmullw      xmm6, XMMWORD [XMMBLOCK(3,0,edx,SIZEOF_ISLOW_MULT_TYPE)]
+    movdqa      xmm1, XMMWORD [XMMBLOCK(5,0,esi,SIZEOF_JCOEF)]
+    movdqa      xmm3, XMMWORD [XMMBLOCK(7,0,esi,SIZEOF_JCOEF)]
+    pmullw      xmm1, XMMWORD [XMMBLOCK(5,0,edx,SIZEOF_ISLOW_MULT_TYPE)]
+    pmullw      xmm3, XMMWORD [XMMBLOCK(7,0,edx,SIZEOF_ISLOW_MULT_TYPE)]
+
+    movdqa      xmm5, xmm6
+    movdqa      xmm7, xmm4
+    paddw       xmm5, xmm3              ; xmm5=z3
+    paddw       xmm7, xmm1              ; xmm7=z4
+
+    ; (Original)
+    ; z5 = (z3 + z4) * 1.175875602;
+    ; z3 = z3 * -1.961570560;  z4 = z4 * -0.390180644;
+    ; z3 += z5;  z4 += z5;
+    ;
+    ; (This implementation)
+    ; z3 = z3 * (1.175875602 - 1.961570560) + z4 * 1.175875602;
+    ; z4 = z3 * 1.175875602 + z4 * (1.175875602 - 0.390180644);
+
+    movdqa      xmm2, xmm5
+    movdqa      xmm0, xmm5
+    punpcklwd   xmm2, xmm7
+    punpckhwd   xmm0, xmm7
+    movdqa      xmm5, xmm2
+    movdqa      xmm7, xmm0
+    pmaddwd     xmm2, [GOTOFF(ebx,PW_MF078_F117)]  ; xmm2=z3L
+    pmaddwd     xmm0, [GOTOFF(ebx,PW_MF078_F117)]  ; xmm0=z3H
+    pmaddwd     xmm5, [GOTOFF(ebx,PW_F117_F078)]   ; xmm5=z4L
+    pmaddwd     xmm7, [GOTOFF(ebx,PW_F117_F078)]   ; xmm7=z4H
+
+    movdqa      XMMWORD [wk(10)], xmm2  ; wk(10)=z3L
+    movdqa      XMMWORD [wk(11)], xmm0  ; wk(11)=z3H
+
+    ; (Original)
+    ; z1 = tmp0 + tmp3;  z2 = tmp1 + tmp2;
+    ; tmp0 = tmp0 * 0.298631336;  tmp1 = tmp1 * 2.053119869;
+    ; tmp2 = tmp2 * 3.072711026;  tmp3 = tmp3 * 1.501321110;
+    ; z1 = z1 * -0.899976223;  z2 = z2 * -2.562915447;
+    ; tmp0 += z1 + z3;  tmp1 += z2 + z4;
+    ; tmp2 += z2 + z3;  tmp3 += z1 + z4;
+    ;
+    ; (This implementation)
+    ; tmp0 = tmp0 * (0.298631336 - 0.899976223) + tmp3 * -0.899976223;
+    ; tmp1 = tmp1 * (2.053119869 - 2.562915447) + tmp2 * -2.562915447;
+    ; tmp2 = tmp1 * -2.562915447 + tmp2 * (3.072711026 - 2.562915447);
+    ; tmp3 = tmp0 * -0.899976223 + tmp3 * (1.501321110 - 0.899976223);
+    ; tmp0 += z3;  tmp1 += z4;
+    ; tmp2 += z3;  tmp3 += z4;
+
+    movdqa      xmm2, xmm3
+    movdqa      xmm0, xmm3
+    punpcklwd   xmm2, xmm4
+    punpckhwd   xmm0, xmm4
+    movdqa      xmm3, xmm2
+    movdqa      xmm4, xmm0
+    pmaddwd     xmm2, [GOTOFF(ebx,PW_MF060_MF089)]  ; xmm2=tmp0L
+    pmaddwd     xmm0, [GOTOFF(ebx,PW_MF060_MF089)]  ; xmm0=tmp0H
+    pmaddwd     xmm3, [GOTOFF(ebx,PW_MF089_F060)]   ; xmm3=tmp3L
+    pmaddwd     xmm4, [GOTOFF(ebx,PW_MF089_F060)]   ; xmm4=tmp3H
+
+    paddd       xmm2, XMMWORD [wk(10)]  ; xmm2=tmp0L
+    paddd       xmm0, XMMWORD [wk(11)]  ; xmm0=tmp0H
+    paddd       xmm3, xmm5              ; xmm3=tmp3L
+    paddd       xmm4, xmm7              ; xmm4=tmp3H
+
+    movdqa      XMMWORD [wk(8)], xmm2   ; wk(8)=tmp0L
+    movdqa      XMMWORD [wk(9)], xmm0   ; wk(9)=tmp0H
+
+    movdqa      xmm2, xmm1
+    movdqa      xmm0, xmm1
+    punpcklwd   xmm2, xmm6
+    punpckhwd   xmm0, xmm6
+    movdqa      xmm1, xmm2
+    movdqa      xmm6, xmm0
+    pmaddwd     xmm2, [GOTOFF(ebx,PW_MF050_MF256)]  ; xmm2=tmp1L
+    pmaddwd     xmm0, [GOTOFF(ebx,PW_MF050_MF256)]  ; xmm0=tmp1H
+    pmaddwd     xmm1, [GOTOFF(ebx,PW_MF256_F050)]   ; xmm1=tmp2L
+    pmaddwd     xmm6, [GOTOFF(ebx,PW_MF256_F050)]   ; xmm6=tmp2H
+
+    paddd       xmm2, xmm5              ; xmm2=tmp1L
+    paddd       xmm0, xmm7              ; xmm0=tmp1H
+    paddd       xmm1, XMMWORD [wk(10)]  ; xmm1=tmp2L
+    paddd       xmm6, XMMWORD [wk(11)]  ; xmm6=tmp2H
+
+    movdqa      XMMWORD [wk(10)], xmm2  ; wk(10)=tmp1L
+    movdqa      XMMWORD [wk(11)], xmm0  ; wk(11)=tmp1H
+
+    ; -- Final output stage
+
+    movdqa      xmm5, XMMWORD [wk(0)]   ; xmm5=tmp10L
+    movdqa      xmm7, XMMWORD [wk(1)]   ; xmm7=tmp10H
+
+    movdqa      xmm2, xmm5
+    movdqa      xmm0, xmm7
+    paddd       xmm5, xmm3              ; xmm5=data0L
+    paddd       xmm7, xmm4              ; xmm7=data0H
+    psubd       xmm2, xmm3              ; xmm2=data7L
+    psubd       xmm0, xmm4              ; xmm0=data7H
+
+    movdqa      xmm3, [GOTOFF(ebx,PD_DESCALE_P1)]  ; xmm3=[PD_DESCALE_P1]
+
+    paddd       xmm5, xmm3
+    paddd       xmm7, xmm3
+    psrad       xmm5, DESCALE_P1
+    psrad       xmm7, DESCALE_P1
+    paddd       xmm2, xmm3
+    paddd       xmm0, xmm3
+    psrad       xmm2, DESCALE_P1
+    psrad       xmm0, DESCALE_P1
+
+    packssdw    xmm5, xmm7              ; xmm5=data0=(00 01 02 03 04 05 06 07)
+    packssdw    xmm2, xmm0              ; xmm2=data7=(70 71 72 73 74 75 76 77)
+
+    movdqa      xmm4, XMMWORD [wk(4)]   ; xmm4=tmp11L
+    movdqa      xmm3, XMMWORD [wk(5)]   ; xmm3=tmp11H
+
+    movdqa      xmm7, xmm4
+    movdqa      xmm0, xmm3
+    paddd       xmm4, xmm1              ; xmm4=data1L
+    paddd       xmm3, xmm6              ; xmm3=data1H
+    psubd       xmm7, xmm1              ; xmm7=data6L
+    psubd       xmm0, xmm6              ; xmm0=data6H
+
+    movdqa      xmm1, [GOTOFF(ebx,PD_DESCALE_P1)]  ; xmm1=[PD_DESCALE_P1]
+
+    paddd       xmm4, xmm1
+    paddd       xmm3, xmm1
+    psrad       xmm4, DESCALE_P1
+    psrad       xmm3, DESCALE_P1
+    paddd       xmm7, xmm1
+    paddd       xmm0, xmm1
+    psrad       xmm7, DESCALE_P1
+    psrad       xmm0, DESCALE_P1
+
+    packssdw    xmm4, xmm3              ; xmm4=data1=(10 11 12 13 14 15 16 17)
+    packssdw    xmm7, xmm0              ; xmm7=data6=(60 61 62 63 64 65 66 67)
+
+    movdqa      xmm6, xmm5              ; transpose coefficients(phase 1)
+    punpcklwd   xmm5, xmm4              ; xmm5=(00 10 01 11 02 12 03 13)
+    punpckhwd   xmm6, xmm4              ; xmm6=(04 14 05 15 06 16 07 17)
+    movdqa      xmm1, xmm7              ; transpose coefficients(phase 1)
+    punpcklwd   xmm7, xmm2              ; xmm7=(60 70 61 71 62 72 63 73)
+    punpckhwd   xmm1, xmm2              ; xmm1=(64 74 65 75 66 76 67 77)
+
+    movdqa      xmm3, XMMWORD [wk(6)]   ; xmm3=tmp12L
+    movdqa      xmm0, XMMWORD [wk(7)]   ; xmm0=tmp12H
+    movdqa      xmm4, XMMWORD [wk(10)]  ; xmm4=tmp1L
+    movdqa      xmm2, XMMWORD [wk(11)]  ; xmm2=tmp1H
+
+    movdqa      XMMWORD [wk(0)], xmm5   ; wk(0)=(00 10 01 11 02 12 03 13)
+    movdqa      XMMWORD [wk(1)], xmm6   ; wk(1)=(04 14 05 15 06 16 07 17)
+    movdqa      XMMWORD [wk(4)], xmm7   ; wk(4)=(60 70 61 71 62 72 63 73)
+    movdqa      XMMWORD [wk(5)], xmm1   ; wk(5)=(64 74 65 75 66 76 67 77)
+
+    movdqa      xmm5, xmm3
+    movdqa      xmm6, xmm0
+    paddd       xmm3, xmm4              ; xmm3=data2L
+    paddd       xmm0, xmm2              ; xmm0=data2H
+    psubd       xmm5, xmm4              ; xmm5=data5L
+    psubd       xmm6, xmm2              ; xmm6=data5H
+
+    movdqa      xmm7, [GOTOFF(ebx,PD_DESCALE_P1)]  ; xmm7=[PD_DESCALE_P1]
+
+    paddd       xmm3, xmm7
+    paddd       xmm0, xmm7
+    psrad       xmm3, DESCALE_P1
+    psrad       xmm0, DESCALE_P1
+    paddd       xmm5, xmm7
+    paddd       xmm6, xmm7
+    psrad       xmm5, DESCALE_P1
+    psrad       xmm6, DESCALE_P1
+
+    packssdw    xmm3, xmm0              ; xmm3=data2=(20 21 22 23 24 25 26 27)
+    packssdw    xmm5, xmm6              ; xmm5=data5=(50 51 52 53 54 55 56 57)
+
+    movdqa      xmm1, XMMWORD [wk(2)]   ; xmm1=tmp13L
+    movdqa      xmm4, XMMWORD [wk(3)]   ; xmm4=tmp13H
+    movdqa      xmm2, XMMWORD [wk(8)]   ; xmm2=tmp0L
+    movdqa      xmm7, XMMWORD [wk(9)]   ; xmm7=tmp0H
+
+    movdqa      xmm0, xmm1
+    movdqa      xmm6, xmm4
+    paddd       xmm1, xmm2              ; xmm1=data3L
+    paddd       xmm4, xmm7              ; xmm4=data3H
+    psubd       xmm0, xmm2              ; xmm0=data4L
+    psubd       xmm6, xmm7              ; xmm6=data4H
+
+    movdqa      xmm2, [GOTOFF(ebx,PD_DESCALE_P1)]  ; xmm2=[PD_DESCALE_P1]
+
+    paddd       xmm1, xmm2
+    paddd       xmm4, xmm2
+    psrad       xmm1, DESCALE_P1
+    psrad       xmm4, DESCALE_P1
+    paddd       xmm0, xmm2
+    paddd       xmm6, xmm2
+    psrad       xmm0, DESCALE_P1
+    psrad       xmm6, DESCALE_P1
+
+    packssdw    xmm1, xmm4              ; xmm1=data3=(30 31 32 33 34 35 36 37)
+    packssdw    xmm0, xmm6              ; xmm0=data4=(40 41 42 43 44 45 46 47)
+
+    movdqa      xmm7, XMMWORD [wk(0)]   ; xmm7=(00 10 01 11 02 12 03 13)
+    movdqa      xmm2, XMMWORD [wk(1)]   ; xmm2=(04 14 05 15 06 16 07 17)
+
+    movdqa      xmm4, xmm3              ; transpose coefficients(phase 1)
+    punpcklwd   xmm3, xmm1              ; xmm3=(20 30 21 31 22 32 23 33)
+    punpckhwd   xmm4, xmm1              ; xmm4=(24 34 25 35 26 36 27 37)
+    movdqa      xmm6, xmm0              ; transpose coefficients(phase 1)
+    punpcklwd   xmm0, xmm5              ; xmm0=(40 50 41 51 42 52 43 53)
+    punpckhwd   xmm6, xmm5              ; xmm6=(44 54 45 55 46 56 47 57)
+
+    movdqa      xmm1, xmm7              ; transpose coefficients(phase 2)
+    punpckldq   xmm7, xmm3              ; xmm7=(00 10 20 30 01 11 21 31)
+    punpckhdq   xmm1, xmm3              ; xmm1=(02 12 22 32 03 13 23 33)
+    movdqa      xmm5, xmm2              ; transpose coefficients(phase 2)
+    punpckldq   xmm2, xmm4              ; xmm2=(04 14 24 34 05 15 25 35)
+    punpckhdq   xmm5, xmm4              ; xmm5=(06 16 26 36 07 17 27 37)
+
+    movdqa      xmm3, XMMWORD [wk(4)]   ; xmm3=(60 70 61 71 62 72 63 73)
+    movdqa      xmm4, XMMWORD [wk(5)]   ; xmm4=(64 74 65 75 66 76 67 77)
+
+    movdqa      XMMWORD [wk(6)], xmm2   ; wk(6)=(04 14 24 34 05 15 25 35)
+    movdqa      XMMWORD [wk(7)], xmm5   ; wk(7)=(06 16 26 36 07 17 27 37)
+
+    movdqa      xmm2, xmm0              ; transpose coefficients(phase 2)
+    punpckldq   xmm0, xmm3              ; xmm0=(40 50 60 70 41 51 61 71)
+    punpckhdq   xmm2, xmm3              ; xmm2=(42 52 62 72 43 53 63 73)
+    movdqa      xmm5, xmm6              ; transpose coefficients(phase 2)
+    punpckldq   xmm6, xmm4              ; xmm6=(44 54 64 74 45 55 65 75)
+    punpckhdq   xmm5, xmm4              ; xmm5=(46 56 66 76 47 57 67 77)
+
+    movdqa      xmm3, xmm7              ; transpose coefficients(phase 3)
+    punpcklqdq  xmm7, xmm0              ; xmm7=col0=(00 10 20 30 40 50 60 70)
+    punpckhqdq  xmm3, xmm0              ; xmm3=col1=(01 11 21 31 41 51 61 71)
+    movdqa      xmm4, xmm1              ; transpose coefficients(phase 3)
+    punpcklqdq  xmm1, xmm2              ; xmm1=col2=(02 12 22 32 42 52 62 72)
+    punpckhqdq  xmm4, xmm2              ; xmm4=col3=(03 13 23 33 43 53 63 73)
+
+    movdqa      xmm0, XMMWORD [wk(6)]   ; xmm0=(04 14 24 34 05 15 25 35)
+    movdqa      xmm2, XMMWORD [wk(7)]   ; xmm2=(06 16 26 36 07 17 27 37)
+
+    movdqa      XMMWORD [wk(8)], xmm3   ; wk(8)=col1
+    movdqa      XMMWORD [wk(9)], xmm4   ; wk(9)=col3
+
+    movdqa      xmm3, xmm0              ; transpose coefficients(phase 3)
+    punpcklqdq  xmm0, xmm6              ; xmm0=col4=(04 14 24 34 44 54 64 74)
+    punpckhqdq  xmm3, xmm6              ; xmm3=col5=(05 15 25 35 45 55 65 75)
+    movdqa      xmm4, xmm2              ; transpose coefficients(phase 3)
+    punpcklqdq  xmm2, xmm5              ; xmm2=col6=(06 16 26 36 46 56 66 76)
+    punpckhqdq  xmm4, xmm5              ; xmm4=col7=(07 17 27 37 47 57 67 77)
+
+    movdqa      XMMWORD [wk(10)], xmm3  ; wk(10)=col5
+    movdqa      XMMWORD [wk(11)], xmm4  ; wk(11)=col7
+.column_end:
+
+    ; -- Prefetch the next coefficient block
+
+    prefetchnta [esi + DCTSIZE2*SIZEOF_JCOEF + 0*32]
+    prefetchnta [esi + DCTSIZE2*SIZEOF_JCOEF + 1*32]
+    prefetchnta [esi + DCTSIZE2*SIZEOF_JCOEF + 2*32]
+    prefetchnta [esi + DCTSIZE2*SIZEOF_JCOEF + 3*32]
+
+    ; ---- Pass 2: process rows from work array, store into output array.
+
+    mov         eax, [original_ebp]
+    mov         edi, JSAMPARRAY [output_buf(eax)]  ; (JSAMPROW *)
+    mov         eax, JDIMENSION [output_col(eax)]
+
+    ; -- Even part
+
+    ; xmm7=col0, xmm1=col2, xmm0=col4, xmm2=col6
+
+    ; (Original)
+    ; z1 = (z2 + z3) * 0.541196100;
+    ; tmp2 = z1 + z3 * -1.847759065;
+    ; tmp3 = z1 + z2 * 0.765366865;
+    ;
+    ; (This implementation)
+    ; tmp2 = z2 * 0.541196100 + z3 * (0.541196100 - 1.847759065);
+    ; tmp3 = z2 * (0.541196100 + 0.765366865) + z3 * 0.541196100;
+
+    movdqa      xmm6, xmm1              ; xmm1=in2=z2
+    movdqa      xmm5, xmm1
+    punpcklwd   xmm6, xmm2              ; xmm2=in6=z3
+    punpckhwd   xmm5, xmm2
+    movdqa      xmm1, xmm6
+    movdqa      xmm2, xmm5
+    pmaddwd     xmm6, [GOTOFF(ebx,PW_F130_F054)]   ; xmm6=tmp3L
+    pmaddwd     xmm5, [GOTOFF(ebx,PW_F130_F054)]   ; xmm5=tmp3H
+    pmaddwd     xmm1, [GOTOFF(ebx,PW_F054_MF130)]  ; xmm1=tmp2L
+    pmaddwd     xmm2, [GOTOFF(ebx,PW_F054_MF130)]  ; xmm2=tmp2H
+
+    movdqa      xmm3, xmm7
+    paddw       xmm7, xmm0              ; xmm7=in0+in4
+    psubw       xmm3, xmm0              ; xmm3=in0-in4
+
+    pxor        xmm4, xmm4
+    pxor        xmm0, xmm0
+    punpcklwd   xmm4, xmm7              ; xmm4=tmp0L
+    punpckhwd   xmm0, xmm7              ; xmm0=tmp0H
+    psrad       xmm4, (16-CONST_BITS)   ; psrad xmm4,16 & pslld xmm4,CONST_BITS
+    psrad       xmm0, (16-CONST_BITS)   ; psrad xmm0,16 & pslld xmm0,CONST_BITS
+
+    movdqa      xmm7, xmm4
+    paddd       xmm4, xmm6              ; xmm4=tmp10L
+    psubd       xmm7, xmm6              ; xmm7=tmp13L
+    movdqa      xmm6, xmm0
+    paddd       xmm0, xmm5              ; xmm0=tmp10H
+    psubd       xmm6, xmm5              ; xmm6=tmp13H
+
+    movdqa      XMMWORD [wk(0)], xmm4   ; wk(0)=tmp10L
+    movdqa      XMMWORD [wk(1)], xmm0   ; wk(1)=tmp10H
+    movdqa      XMMWORD [wk(2)], xmm7   ; wk(2)=tmp13L
+    movdqa      XMMWORD [wk(3)], xmm6   ; wk(3)=tmp13H
+
+    pxor        xmm5, xmm5
+    pxor        xmm4, xmm4
+    punpcklwd   xmm5, xmm3              ; xmm5=tmp1L
+    punpckhwd   xmm4, xmm3              ; xmm4=tmp1H
+    psrad       xmm5, (16-CONST_BITS)   ; psrad xmm5,16 & pslld xmm5,CONST_BITS
+    psrad       xmm4, (16-CONST_BITS)   ; psrad xmm4,16 & pslld xmm4,CONST_BITS
+
+    movdqa      xmm0, xmm5
+    paddd       xmm5, xmm1              ; xmm5=tmp11L
+    psubd       xmm0, xmm1              ; xmm0=tmp12L
+    movdqa      xmm7, xmm4
+    paddd       xmm4, xmm2              ; xmm4=tmp11H
+    psubd       xmm7, xmm2              ; xmm7=tmp12H
+
+    movdqa      XMMWORD [wk(4)], xmm5   ; wk(4)=tmp11L
+    movdqa      XMMWORD [wk(5)], xmm4   ; wk(5)=tmp11H
+    movdqa      XMMWORD [wk(6)], xmm0   ; wk(6)=tmp12L
+    movdqa      XMMWORD [wk(7)], xmm7   ; wk(7)=tmp12H
+
+    ; -- Odd part
+
+    movdqa      xmm6, XMMWORD [wk(9)]   ; xmm6=col3
+    movdqa      xmm3, XMMWORD [wk(8)]   ; xmm3=col1
+    movdqa      xmm1, XMMWORD [wk(11)]  ; xmm1=col7
+    movdqa      xmm2, XMMWORD [wk(10)]  ; xmm2=col5
+
+    movdqa      xmm5, xmm6
+    movdqa      xmm4, xmm3
+    paddw       xmm5, xmm1              ; xmm5=z3
+    paddw       xmm4, xmm2              ; xmm4=z4
+
+    ; (Original)
+    ; z5 = (z3 + z4) * 1.175875602;
+    ; z3 = z3 * -1.961570560;  z4 = z4 * -0.390180644;
+    ; z3 += z5;  z4 += z5;
+    ;
+    ; (This implementation)
+    ; z3 = z3 * (1.175875602 - 1.961570560) + z4 * 1.175875602;
+    ; z4 = z3 * 1.175875602 + z4 * (1.175875602 - 0.390180644);
+
+    movdqa      xmm0, xmm5
+    movdqa      xmm7, xmm5
+    punpcklwd   xmm0, xmm4
+    punpckhwd   xmm7, xmm4
+    movdqa      xmm5, xmm0
+    movdqa      xmm4, xmm7
+    pmaddwd     xmm0, [GOTOFF(ebx,PW_MF078_F117)]  ; xmm0=z3L
+    pmaddwd     xmm7, [GOTOFF(ebx,PW_MF078_F117)]  ; xmm7=z3H
+    pmaddwd     xmm5, [GOTOFF(ebx,PW_F117_F078)]   ; xmm5=z4L
+    pmaddwd     xmm4, [GOTOFF(ebx,PW_F117_F078)]   ; xmm4=z4H
+
+    movdqa      XMMWORD [wk(10)], xmm0  ; wk(10)=z3L
+    movdqa      XMMWORD [wk(11)], xmm7  ; wk(11)=z3H
+
+    ; (Original)
+    ; z1 = tmp0 + tmp3;  z2 = tmp1 + tmp2;
+    ; tmp0 = tmp0 * 0.298631336;  tmp1 = tmp1 * 2.053119869;
+    ; tmp2 = tmp2 * 3.072711026;  tmp3 = tmp3 * 1.501321110;
+    ; z1 = z1 * -0.899976223;  z2 = z2 * -2.562915447;
+    ; tmp0 += z1 + z3;  tmp1 += z2 + z4;
+    ; tmp2 += z2 + z3;  tmp3 += z1 + z4;
+    ;
+    ; (This implementation)
+    ; tmp0 = tmp0 * (0.298631336 - 0.899976223) + tmp3 * -0.899976223;
+    ; tmp1 = tmp1 * (2.053119869 - 2.562915447) + tmp2 * -2.562915447;
+    ; tmp2 = tmp1 * -2.562915447 + tmp2 * (3.072711026 - 2.562915447);
+    ; tmp3 = tmp0 * -0.899976223 + tmp3 * (1.501321110 - 0.899976223);
+    ; tmp0 += z3;  tmp1 += z4;
+    ; tmp2 += z3;  tmp3 += z4;
+
+    movdqa      xmm0, xmm1
+    movdqa      xmm7, xmm1
+    punpcklwd   xmm0, xmm3
+    punpckhwd   xmm7, xmm3
+    movdqa      xmm1, xmm0
+    movdqa      xmm3, xmm7
+    pmaddwd     xmm0, [GOTOFF(ebx,PW_MF060_MF089)]  ; xmm0=tmp0L
+    pmaddwd     xmm7, [GOTOFF(ebx,PW_MF060_MF089)]  ; xmm7=tmp0H
+    pmaddwd     xmm1, [GOTOFF(ebx,PW_MF089_F060)]   ; xmm1=tmp3L
+    pmaddwd     xmm3, [GOTOFF(ebx,PW_MF089_F060)]   ; xmm3=tmp3H
+
+    paddd       xmm0, XMMWORD [wk(10)]  ; xmm0=tmp0L
+    paddd       xmm7, XMMWORD [wk(11)]  ; xmm7=tmp0H
+    paddd       xmm1, xmm5              ; xmm1=tmp3L
+    paddd       xmm3, xmm4              ; xmm3=tmp3H
+
+    movdqa      XMMWORD [wk(8)], xmm0   ; wk(8)=tmp0L
+    movdqa      XMMWORD [wk(9)], xmm7   ; wk(9)=tmp0H
+
+    movdqa      xmm0, xmm2
+    movdqa      xmm7, xmm2
+    punpcklwd   xmm0, xmm6
+    punpckhwd   xmm7, xmm6
+    movdqa      xmm2, xmm0
+    movdqa      xmm6, xmm7
+    pmaddwd     xmm0, [GOTOFF(ebx,PW_MF050_MF256)]  ; xmm0=tmp1L
+    pmaddwd     xmm7, [GOTOFF(ebx,PW_MF050_MF256)]  ; xmm7=tmp1H
+    pmaddwd     xmm2, [GOTOFF(ebx,PW_MF256_F050)]   ; xmm2=tmp2L
+    pmaddwd     xmm6, [GOTOFF(ebx,PW_MF256_F050)]   ; xmm6=tmp2H
+
+    paddd       xmm0, xmm5              ; xmm0=tmp1L
+    paddd       xmm7, xmm4              ; xmm7=tmp1H
+    paddd       xmm2, XMMWORD [wk(10)]  ; xmm2=tmp2L
+    paddd       xmm6, XMMWORD [wk(11)]  ; xmm6=tmp2H
+
+    movdqa      XMMWORD [wk(10)], xmm0  ; wk(10)=tmp1L
+    movdqa      XMMWORD [wk(11)], xmm7  ; wk(11)=tmp1H
+
+    ; -- Final output stage
+
+    movdqa      xmm5, XMMWORD [wk(0)]   ; xmm5=tmp10L
+    movdqa      xmm4, XMMWORD [wk(1)]   ; xmm4=tmp10H
+
+    movdqa      xmm0, xmm5
+    movdqa      xmm7, xmm4
+    paddd       xmm5, xmm1              ; xmm5=data0L
+    paddd       xmm4, xmm3              ; xmm4=data0H
+    psubd       xmm0, xmm1              ; xmm0=data7L
+    psubd       xmm7, xmm3              ; xmm7=data7H
+
+    movdqa      xmm1, [GOTOFF(ebx,PD_DESCALE_P2)]  ; xmm1=[PD_DESCALE_P2]
+
+    paddd       xmm5, xmm1
+    paddd       xmm4, xmm1
+    psrad       xmm5, DESCALE_P2
+    psrad       xmm4, DESCALE_P2
+    paddd       xmm0, xmm1
+    paddd       xmm7, xmm1
+    psrad       xmm0, DESCALE_P2
+    psrad       xmm7, DESCALE_P2
+
+    packssdw    xmm5, xmm4              ; xmm5=data0=(00 10 20 30 40 50 60 70)
+    packssdw    xmm0, xmm7              ; xmm0=data7=(07 17 27 37 47 57 67 77)
+
+    movdqa      xmm3, XMMWORD [wk(4)]   ; xmm3=tmp11L
+    movdqa      xmm1, XMMWORD [wk(5)]   ; xmm1=tmp11H
+
+    movdqa      xmm4, xmm3
+    movdqa      xmm7, xmm1
+    paddd       xmm3, xmm2              ; xmm3=data1L
+    paddd       xmm1, xmm6              ; xmm1=data1H
+    psubd       xmm4, xmm2              ; xmm4=data6L
+    psubd       xmm7, xmm6              ; xmm7=data6H
+
+    movdqa      xmm2, [GOTOFF(ebx,PD_DESCALE_P2)]  ; xmm2=[PD_DESCALE_P2]
+
+    paddd       xmm3, xmm2
+    paddd       xmm1, xmm2
+    psrad       xmm3, DESCALE_P2
+    psrad       xmm1, DESCALE_P2
+    paddd       xmm4, xmm2
+    paddd       xmm7, xmm2
+    psrad       xmm4, DESCALE_P2
+    psrad       xmm7, DESCALE_P2
+
+    packssdw    xmm3, xmm1              ; xmm3=data1=(01 11 21 31 41 51 61 71)
+    packssdw    xmm4, xmm7              ; xmm4=data6=(06 16 26 36 46 56 66 76)
+
+    packsswb    xmm5, xmm4              ; xmm5=(00 10 20 30 40 50 60 70 06 16 26 36 46 56 66 76)
+    packsswb    xmm3, xmm0              ; xmm3=(01 11 21 31 41 51 61 71 07 17 27 37 47 57 67 77)
+
+    movdqa      xmm6, XMMWORD [wk(6)]   ; xmm6=tmp12L
+    movdqa      xmm2, XMMWORD [wk(7)]   ; xmm2=tmp12H
+    movdqa      xmm1, XMMWORD [wk(10)]  ; xmm1=tmp1L
+    movdqa      xmm7, XMMWORD [wk(11)]  ; xmm7=tmp1H
+
+    movdqa      XMMWORD [wk(0)], xmm5   ; wk(0)=(00 10 20 30 40 50 60 70 06 16 26 36 46 56 66 76)
+    movdqa      XMMWORD [wk(1)], xmm3   ; wk(1)=(01 11 21 31 41 51 61 71 07 17 27 37 47 57 67 77)
+
+    movdqa      xmm4, xmm6
+    movdqa      xmm0, xmm2
+    paddd       xmm6, xmm1              ; xmm6=data2L
+    paddd       xmm2, xmm7              ; xmm2=data2H
+    psubd       xmm4, xmm1              ; xmm4=data5L
+    psubd       xmm0, xmm7              ; xmm0=data5H
+
+    movdqa      xmm5, [GOTOFF(ebx,PD_DESCALE_P2)]  ; xmm5=[PD_DESCALE_P2]
+
+    paddd       xmm6, xmm5
+    paddd       xmm2, xmm5
+    psrad       xmm6, DESCALE_P2
+    psrad       xmm2, DESCALE_P2
+    paddd       xmm4, xmm5
+    paddd       xmm0, xmm5
+    psrad       xmm4, DESCALE_P2
+    psrad       xmm0, DESCALE_P2
+
+    packssdw    xmm6, xmm2              ; xmm6=data2=(02 12 22 32 42 52 62 72)
+    packssdw    xmm4, xmm0              ; xmm4=data5=(05 15 25 35 45 55 65 75)
+
+    movdqa      xmm3, XMMWORD [wk(2)]   ; xmm3=tmp13L
+    movdqa      xmm1, XMMWORD [wk(3)]   ; xmm1=tmp13H
+    movdqa      xmm7, XMMWORD [wk(8)]   ; xmm7=tmp0L
+    movdqa      xmm5, XMMWORD [wk(9)]   ; xmm5=tmp0H
+
+    movdqa      xmm2, xmm3
+    movdqa      xmm0, xmm1
+    paddd       xmm3, xmm7              ; xmm3=data3L
+    paddd       xmm1, xmm5              ; xmm1=data3H
+    psubd       xmm2, xmm7              ; xmm2=data4L
+    psubd       xmm0, xmm5              ; xmm0=data4H
+
+    movdqa      xmm7, [GOTOFF(ebx,PD_DESCALE_P2)]  ; xmm7=[PD_DESCALE_P2]
+
+    paddd       xmm3, xmm7
+    paddd       xmm1, xmm7
+    psrad       xmm3, DESCALE_P2
+    psrad       xmm1, DESCALE_P2
+    paddd       xmm2, xmm7
+    paddd       xmm0, xmm7
+    psrad       xmm2, DESCALE_P2
+    psrad       xmm0, DESCALE_P2
+
+    movdqa      xmm5, [GOTOFF(ebx,PB_CENTERJSAMP)]  ; xmm5=[PB_CENTERJSAMP]
+
+    packssdw    xmm3, xmm1             ; xmm3=data3=(03 13 23 33 43 53 63 73)
+    packssdw    xmm2, xmm0             ; xmm2=data4=(04 14 24 34 44 54 64 74)
+
+    movdqa      xmm7, XMMWORD [wk(0)]  ; xmm7=(00 10 20 30 40 50 60 70 06 16 26 36 46 56 66 76)
+    movdqa      xmm1, XMMWORD [wk(1)]  ; xmm1=(01 11 21 31 41 51 61 71 07 17 27 37 47 57 67 77)
+
+    packsswb    xmm6, xmm2             ; xmm6=(02 12 22 32 42 52 62 72 04 14 24 34 44 54 64 74)
+    packsswb    xmm3, xmm4             ; xmm3=(03 13 23 33 43 53 63 73 05 15 25 35 45 55 65 75)
+
+    paddb       xmm7, xmm5
+    paddb       xmm1, xmm5
+    paddb       xmm6, xmm5
+    paddb       xmm3, xmm5
+
+    movdqa      xmm0, xmm7        ; transpose coefficients(phase 1)
+    punpcklbw   xmm7, xmm1        ; xmm7=(00 01 10 11 20 21 30 31 40 41 50 51 60 61 70 71)
+    punpckhbw   xmm0, xmm1        ; xmm0=(06 07 16 17 26 27 36 37 46 47 56 57 66 67 76 77)
+    movdqa      xmm2, xmm6        ; transpose coefficients(phase 1)
+    punpcklbw   xmm6, xmm3        ; xmm6=(02 03 12 13 22 23 32 33 42 43 52 53 62 63 72 73)
+    punpckhbw   xmm2, xmm3        ; xmm2=(04 05 14 15 24 25 34 35 44 45 54 55 64 65 74 75)
+
+    movdqa      xmm4, xmm7        ; transpose coefficients(phase 2)
+    punpcklwd   xmm7, xmm6        ; xmm7=(00 01 02 03 10 11 12 13 20 21 22 23 30 31 32 33)
+    punpckhwd   xmm4, xmm6        ; xmm4=(40 41 42 43 50 51 52 53 60 61 62 63 70 71 72 73)
+    movdqa      xmm5, xmm2        ; transpose coefficients(phase 2)
+    punpcklwd   xmm2, xmm0        ; xmm2=(04 05 06 07 14 15 16 17 24 25 26 27 34 35 36 37)
+    punpckhwd   xmm5, xmm0        ; xmm5=(44 45 46 47 54 55 56 57 64 65 66 67 74 75 76 77)
+
+    movdqa      xmm1, xmm7        ; transpose coefficients(phase 3)
+    punpckldq   xmm7, xmm2        ; xmm7=(00 01 02 03 04 05 06 07 10 11 12 13 14 15 16 17)
+    punpckhdq   xmm1, xmm2        ; xmm1=(20 21 22 23 24 25 26 27 30 31 32 33 34 35 36 37)
+    movdqa      xmm3, xmm4        ; transpose coefficients(phase 3)
+    punpckldq   xmm4, xmm5        ; xmm4=(40 41 42 43 44 45 46 47 50 51 52 53 54 55 56 57)
+    punpckhdq   xmm3, xmm5        ; xmm3=(60 61 62 63 64 65 66 67 70 71 72 73 74 75 76 77)
+
+    pshufd      xmm6, xmm7, 0x4E  ; xmm6=(10 11 12 13 14 15 16 17 00 01 02 03 04 05 06 07)
+    pshufd      xmm0, xmm1, 0x4E  ; xmm0=(30 31 32 33 34 35 36 37 20 21 22 23 24 25 26 27)
+    pshufd      xmm2, xmm4, 0x4E  ; xmm2=(50 51 52 53 54 55 56 57 40 41 42 43 44 45 46 47)
+    pshufd      xmm5, xmm3, 0x4E  ; xmm5=(70 71 72 73 74 75 76 77 60 61 62 63 64 65 66 67)
+
+    mov         edx, JSAMPROW [edi+0*SIZEOF_JSAMPROW]
+    mov         esi, JSAMPROW [edi+2*SIZEOF_JSAMPROW]
+    movq        XMM_MMWORD [edx+eax*SIZEOF_JSAMPLE], xmm7
+    movq        XMM_MMWORD [esi+eax*SIZEOF_JSAMPLE], xmm1
+    mov         edx, JSAMPROW [edi+4*SIZEOF_JSAMPROW]
+    mov         esi, JSAMPROW [edi+6*SIZEOF_JSAMPROW]
+    movq        XMM_MMWORD [edx+eax*SIZEOF_JSAMPLE], xmm4
+    movq        XMM_MMWORD [esi+eax*SIZEOF_JSAMPLE], xmm3
+
+    mov         edx, JSAMPROW [edi+1*SIZEOF_JSAMPROW]
+    mov         esi, JSAMPROW [edi+3*SIZEOF_JSAMPROW]
+    movq        XMM_MMWORD [edx+eax*SIZEOF_JSAMPLE], xmm6
+    movq        XMM_MMWORD [esi+eax*SIZEOF_JSAMPLE], xmm0
+    mov         edx, JSAMPROW [edi+5*SIZEOF_JSAMPROW]
+    mov         esi, JSAMPROW [edi+7*SIZEOF_JSAMPROW]
+    movq        XMM_MMWORD [edx+eax*SIZEOF_JSAMPLE], xmm2
+    movq        XMM_MMWORD [esi+eax*SIZEOF_JSAMPLE], xmm5
+
+    pop         edi
+    pop         esi
+;   pop         edx                     ; need not be preserved
+;   pop         ecx                     ; unused
+    poppic      ebx
+    mov         esp, ebp                ; esp <- aligned ebp
+    pop         esp                     ; esp <- original ebp
+    pop         ebp
+    ret
+
+; For some reason, the OS X linker does not honor the request to align the
+; segment unless we do this.
+    align       32
diff --git a/3rdparty/libjpeg/src/simd/i386/jidctred-mmx.asm b/3rdparty/libjpeg/src/simd/i386/jidctred-mmx.asm
new file mode 100644
index 00000000..e2307e1c
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/i386/jidctred-mmx.asm
@@ -0,0 +1,704 @@
+;
+; jidctred.asm - reduced-size IDCT (MMX)
+;
+; Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+; Copyright (C) 2016, D. R. Commander.
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+;
+; This file should be assembled with NASM (Netwide Assembler),
+; can *not* be assembled with Microsoft's MASM or any compatible
+; assembler (including Borland's Turbo Assembler).
+; NASM is available from http://nasm.sourceforge.net/ or
+; http://sourceforge.net/project/showfiles.php?group_id=6208
+;
+; This file contains inverse-DCT routines that produce reduced-size
+; output: either 4x4 or 2x2 pixels from an 8x8 DCT block.
+; The following code is based directly on the IJG's original jidctred.c;
+; see the jidctred.c for more details.
+
+%include "jsimdext.inc"
+%include "jdct.inc"
+
+; --------------------------------------------------------------------------
+
+%define CONST_BITS    13
+%define PASS1_BITS    2
+
+%define DESCALE_P1_4  (CONST_BITS - PASS1_BITS + 1)
+%define DESCALE_P2_4  (CONST_BITS + PASS1_BITS + 3 + 1)
+%define DESCALE_P1_2  (CONST_BITS - PASS1_BITS + 2)
+%define DESCALE_P2_2  (CONST_BITS + PASS1_BITS + 3 + 2)
+
+%if CONST_BITS == 13
+F_0_211 equ  1730  ; FIX(0.211164243)
+F_0_509 equ  4176  ; FIX(0.509795579)
+F_0_601 equ  4926  ; FIX(0.601344887)
+F_0_720 equ  5906  ; FIX(0.720959822)
+F_0_765 equ  6270  ; FIX(0.765366865)
+F_0_850 equ  6967  ; FIX(0.850430095)
+F_0_899 equ  7373  ; FIX(0.899976223)
+F_1_061 equ  8697  ; FIX(1.061594337)
+F_1_272 equ 10426  ; FIX(1.272758580)
+F_1_451 equ 11893  ; FIX(1.451774981)
+F_1_847 equ 15137  ; FIX(1.847759065)
+F_2_172 equ 17799  ; FIX(2.172734803)
+F_2_562 equ 20995  ; FIX(2.562915447)
+F_3_624 equ 29692  ; FIX(3.624509785)
+%else
+; NASM cannot do compile-time arithmetic on floating-point constants.
+%define DESCALE(x, n)  (((x) + (1 << ((n) - 1))) >> (n))
+F_0_211 equ DESCALE( 226735879, 30 - CONST_BITS)  ; FIX(0.211164243)
+F_0_509 equ DESCALE( 547388834, 30 - CONST_BITS)  ; FIX(0.509795579)
+F_0_601 equ DESCALE( 645689155, 30 - CONST_BITS)  ; FIX(0.601344887)
+F_0_720 equ DESCALE( 774124714, 30 - CONST_BITS)  ; FIX(0.720959822)
+F_0_765 equ DESCALE( 821806413, 30 - CONST_BITS)  ; FIX(0.765366865)
+F_0_850 equ DESCALE( 913142361, 30 - CONST_BITS)  ; FIX(0.850430095)
+F_0_899 equ DESCALE( 966342111, 30 - CONST_BITS)  ; FIX(0.899976223)
+F_1_061 equ DESCALE(1139878239, 30 - CONST_BITS)  ; FIX(1.061594337)
+F_1_272 equ DESCALE(1366614119, 30 - CONST_BITS)  ; FIX(1.272758580)
+F_1_451 equ DESCALE(1558831516, 30 - CONST_BITS)  ; FIX(1.451774981)
+F_1_847 equ DESCALE(1984016188, 30 - CONST_BITS)  ; FIX(1.847759065)
+F_2_172 equ DESCALE(2332956230, 30 - CONST_BITS)  ; FIX(2.172734803)
+F_2_562 equ DESCALE(2751909506, 30 - CONST_BITS)  ; FIX(2.562915447)
+F_3_624 equ DESCALE(3891787747, 30 - CONST_BITS)  ; FIX(3.624509785)
+%endif
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_CONST
+
+    alignz      32
+    GLOBAL_DATA(jconst_idct_red_mmx)
+
+EXTN(jconst_idct_red_mmx):
+
+PW_F184_MF076   times 2 dw  F_1_847, -F_0_765
+PW_F256_F089    times 2 dw  F_2_562,  F_0_899
+PW_F106_MF217   times 2 dw  F_1_061, -F_2_172
+PW_MF060_MF050  times 2 dw -F_0_601, -F_0_509
+PW_F145_MF021   times 2 dw  F_1_451, -F_0_211
+PW_F362_MF127   times 2 dw  F_3_624, -F_1_272
+PW_F085_MF072   times 2 dw  F_0_850, -F_0_720
+PD_DESCALE_P1_4 times 2 dd  1 << (DESCALE_P1_4 - 1)
+PD_DESCALE_P2_4 times 2 dd  1 << (DESCALE_P2_4 - 1)
+PD_DESCALE_P1_2 times 2 dd  1 << (DESCALE_P1_2 - 1)
+PD_DESCALE_P2_2 times 2 dd  1 << (DESCALE_P2_2 - 1)
+PB_CENTERJSAMP  times 8 db  CENTERJSAMPLE
+
+    alignz      32
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_TEXT
+    BITS        32
+;
+; Perform dequantization and inverse DCT on one block of coefficients,
+; producing a reduced-size 4x4 output block.
+;
+; GLOBAL(void)
+; jsimd_idct_4x4_mmx(void *dct_table, JCOEFPTR coef_block,
+;                    JSAMPARRAY output_buf, JDIMENSION output_col)
+;
+
+%define dct_table(b)   (b) + 8          ; void *dct_table
+%define coef_block(b)  (b) + 12         ; JCOEFPTR coef_block
+%define output_buf(b)  (b) + 16         ; JSAMPARRAY output_buf
+%define output_col(b)  (b) + 20         ; JDIMENSION output_col
+
+%define original_ebp   ebp + 0
+%define wk(i)          ebp - (WK_NUM - (i)) * SIZEOF_MMWORD
+                                        ; mmword wk[WK_NUM]
+%define WK_NUM         2
+%define workspace      wk(0) - DCTSIZE2 * SIZEOF_JCOEF
+                                        ; JCOEF workspace[DCTSIZE2]
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_idct_4x4_mmx)
+
+EXTN(jsimd_idct_4x4_mmx):
+    push        ebp
+    mov         eax, esp                    ; eax = original ebp
+    sub         esp, byte 4
+    and         esp, byte (-SIZEOF_MMWORD)  ; align to 64 bits
+    mov         [esp], eax
+    mov         ebp, esp                    ; ebp = aligned ebp
+    lea         esp, [workspace]
+    pushpic     ebx
+;   push        ecx                     ; need not be preserved
+;   push        edx                     ; need not be preserved
+    push        esi
+    push        edi
+
+    get_GOT     ebx                     ; get GOT address
+
+    ; ---- Pass 1: process columns from input, store into work array.
+
+;   mov         eax, [original_ebp]
+    mov         edx, POINTER [dct_table(eax)]    ; quantptr
+    mov         esi, JCOEFPTR [coef_block(eax)]  ; inptr
+    lea         edi, [workspace]                 ; JCOEF *wsptr
+    mov         ecx, DCTSIZE/4                   ; ctr
+    alignx      16, 7
+.columnloop:
+%ifndef NO_ZERO_COLUMN_TEST_4X4_MMX
+    mov         eax, dword [DWBLOCK(1,0,esi,SIZEOF_JCOEF)]
+    or          eax, dword [DWBLOCK(2,0,esi,SIZEOF_JCOEF)]
+    jnz         short .columnDCT
+
+    movq        mm0, MMWORD [MMBLOCK(1,0,esi,SIZEOF_JCOEF)]
+    movq        mm1, MMWORD [MMBLOCK(2,0,esi,SIZEOF_JCOEF)]
+    por         mm0, MMWORD [MMBLOCK(3,0,esi,SIZEOF_JCOEF)]
+    por         mm1, MMWORD [MMBLOCK(5,0,esi,SIZEOF_JCOEF)]
+    por         mm0, MMWORD [MMBLOCK(6,0,esi,SIZEOF_JCOEF)]
+    por         mm1, MMWORD [MMBLOCK(7,0,esi,SIZEOF_JCOEF)]
+    por         mm0, mm1
+    packsswb    mm0, mm0
+    movd        eax, mm0
+    test        eax, eax
+    jnz         short .columnDCT
+
+    ; -- AC terms all zero
+
+    movq        mm0, MMWORD [MMBLOCK(0,0,esi,SIZEOF_JCOEF)]
+    pmullw      mm0, MMWORD [MMBLOCK(0,0,edx,SIZEOF_ISLOW_MULT_TYPE)]
+
+    psllw       mm0, PASS1_BITS
+
+    movq        mm2, mm0                ; mm0=in0=(00 01 02 03)
+    punpcklwd   mm0, mm0                ; mm0=(00 00 01 01)
+    punpckhwd   mm2, mm2                ; mm2=(02 02 03 03)
+
+    movq        mm1, mm0
+    punpckldq   mm0, mm0                ; mm0=(00 00 00 00)
+    punpckhdq   mm1, mm1                ; mm1=(01 01 01 01)
+    movq        mm3, mm2
+    punpckldq   mm2, mm2                ; mm2=(02 02 02 02)
+    punpckhdq   mm3, mm3                ; mm3=(03 03 03 03)
+
+    movq        MMWORD [MMBLOCK(0,0,edi,SIZEOF_JCOEF)], mm0
+    movq        MMWORD [MMBLOCK(1,0,edi,SIZEOF_JCOEF)], mm1
+    movq        MMWORD [MMBLOCK(2,0,edi,SIZEOF_JCOEF)], mm2
+    movq        MMWORD [MMBLOCK(3,0,edi,SIZEOF_JCOEF)], mm3
+    jmp         near .nextcolumn
+    alignx      16, 7
+%endif
+.columnDCT:
+
+    ; -- Odd part
+
+    movq        mm0, MMWORD [MMBLOCK(1,0,esi,SIZEOF_JCOEF)]
+    movq        mm1, MMWORD [MMBLOCK(3,0,esi,SIZEOF_JCOEF)]
+    pmullw      mm0, MMWORD [MMBLOCK(1,0,edx,SIZEOF_ISLOW_MULT_TYPE)]
+    pmullw      mm1, MMWORD [MMBLOCK(3,0,edx,SIZEOF_ISLOW_MULT_TYPE)]
+    movq        mm2, MMWORD [MMBLOCK(5,0,esi,SIZEOF_JCOEF)]
+    movq        mm3, MMWORD [MMBLOCK(7,0,esi,SIZEOF_JCOEF)]
+    pmullw      mm2, MMWORD [MMBLOCK(5,0,edx,SIZEOF_ISLOW_MULT_TYPE)]
+    pmullw      mm3, MMWORD [MMBLOCK(7,0,edx,SIZEOF_ISLOW_MULT_TYPE)]
+
+    movq        mm4, mm0
+    movq        mm5, mm0
+    punpcklwd   mm4, mm1
+    punpckhwd   mm5, mm1
+    movq        mm0, mm4
+    movq        mm1, mm5
+    pmaddwd     mm4, [GOTOFF(ebx,PW_F256_F089)]   ; mm4=(tmp2L)
+    pmaddwd     mm5, [GOTOFF(ebx,PW_F256_F089)]   ; mm5=(tmp2H)
+    pmaddwd     mm0, [GOTOFF(ebx,PW_F106_MF217)]  ; mm0=(tmp0L)
+    pmaddwd     mm1, [GOTOFF(ebx,PW_F106_MF217)]  ; mm1=(tmp0H)
+
+    movq        mm6, mm2
+    movq        mm7, mm2
+    punpcklwd   mm6, mm3
+    punpckhwd   mm7, mm3
+    movq        mm2, mm6
+    movq        mm3, mm7
+    pmaddwd     mm6, [GOTOFF(ebx,PW_MF060_MF050)]  ; mm6=(tmp2L)
+    pmaddwd     mm7, [GOTOFF(ebx,PW_MF060_MF050)]  ; mm7=(tmp2H)
+    pmaddwd     mm2, [GOTOFF(ebx,PW_F145_MF021)]   ; mm2=(tmp0L)
+    pmaddwd     mm3, [GOTOFF(ebx,PW_F145_MF021)]   ; mm3=(tmp0H)
+
+    paddd       mm6, mm4                ; mm6=tmp2L
+    paddd       mm7, mm5                ; mm7=tmp2H
+    paddd       mm2, mm0                ; mm2=tmp0L
+    paddd       mm3, mm1                ; mm3=tmp0H
+
+    movq        MMWORD [wk(0)], mm2     ; wk(0)=tmp0L
+    movq        MMWORD [wk(1)], mm3     ; wk(1)=tmp0H
+
+    ; -- Even part
+
+    movq        mm4, MMWORD [MMBLOCK(0,0,esi,SIZEOF_JCOEF)]
+    movq        mm5, MMWORD [MMBLOCK(2,0,esi,SIZEOF_JCOEF)]
+    movq        mm0, MMWORD [MMBLOCK(6,0,esi,SIZEOF_JCOEF)]
+    pmullw      mm4, MMWORD [MMBLOCK(0,0,edx,SIZEOF_ISLOW_MULT_TYPE)]
+    pmullw      mm5, MMWORD [MMBLOCK(2,0,edx,SIZEOF_ISLOW_MULT_TYPE)]
+    pmullw      mm0, MMWORD [MMBLOCK(6,0,edx,SIZEOF_ISLOW_MULT_TYPE)]
+
+    pxor        mm1, mm1
+    pxor        mm2, mm2
+    punpcklwd   mm1, mm4                ; mm1=tmp0L
+    punpckhwd   mm2, mm4                ; mm2=tmp0H
+    psrad       mm1, (16-CONST_BITS-1)  ; psrad mm1,16 & pslld mm1,CONST_BITS+1
+    psrad       mm2, (16-CONST_BITS-1)  ; psrad mm2,16 & pslld mm2,CONST_BITS+1
+
+    movq        mm3, mm5                ; mm5=in2=z2
+    punpcklwd   mm5, mm0                ; mm0=in6=z3
+    punpckhwd   mm3, mm0
+    pmaddwd     mm5, [GOTOFF(ebx,PW_F184_MF076)]  ; mm5=tmp2L
+    pmaddwd     mm3, [GOTOFF(ebx,PW_F184_MF076)]  ; mm3=tmp2H
+
+    movq        mm4, mm1
+    movq        mm0, mm2
+    paddd       mm1, mm5                ; mm1=tmp10L
+    paddd       mm2, mm3                ; mm2=tmp10H
+    psubd       mm4, mm5                ; mm4=tmp12L
+    psubd       mm0, mm3                ; mm0=tmp12H
+
+    ; -- Final output stage
+
+    movq        mm5, mm1
+    movq        mm3, mm2
+    paddd       mm1, mm6                ; mm1=data0L
+    paddd       mm2, mm7                ; mm2=data0H
+    psubd       mm5, mm6                ; mm5=data3L
+    psubd       mm3, mm7                ; mm3=data3H
+
+    movq        mm6, [GOTOFF(ebx,PD_DESCALE_P1_4)]  ; mm6=[PD_DESCALE_P1_4]
+
+    paddd       mm1, mm6
+    paddd       mm2, mm6
+    psrad       mm1, DESCALE_P1_4
+    psrad       mm2, DESCALE_P1_4
+    paddd       mm5, mm6
+    paddd       mm3, mm6
+    psrad       mm5, DESCALE_P1_4
+    psrad       mm3, DESCALE_P1_4
+
+    packssdw    mm1, mm2                ; mm1=data0=(00 01 02 03)
+    packssdw    mm5, mm3                ; mm5=data3=(30 31 32 33)
+
+    movq        mm7, MMWORD [wk(0)]     ; mm7=tmp0L
+    movq        mm6, MMWORD [wk(1)]     ; mm6=tmp0H
+
+    movq        mm2, mm4
+    movq        mm3, mm0
+    paddd       mm4, mm7                ; mm4=data1L
+    paddd       mm0, mm6                ; mm0=data1H
+    psubd       mm2, mm7                ; mm2=data2L
+    psubd       mm3, mm6                ; mm3=data2H
+
+    movq        mm7, [GOTOFF(ebx,PD_DESCALE_P1_4)]  ; mm7=[PD_DESCALE_P1_4]
+
+    paddd       mm4, mm7
+    paddd       mm0, mm7
+    psrad       mm4, DESCALE_P1_4
+    psrad       mm0, DESCALE_P1_4
+    paddd       mm2, mm7
+    paddd       mm3, mm7
+    psrad       mm2, DESCALE_P1_4
+    psrad       mm3, DESCALE_P1_4
+
+    packssdw    mm4, mm0                ; mm4=data1=(10 11 12 13)
+    packssdw    mm2, mm3                ; mm2=data2=(20 21 22 23)
+
+    movq        mm6, mm1                ; transpose coefficients(phase 1)
+    punpcklwd   mm1, mm4                ; mm1=(00 10 01 11)
+    punpckhwd   mm6, mm4                ; mm6=(02 12 03 13)
+    movq        mm7, mm2                ; transpose coefficients(phase 1)
+    punpcklwd   mm2, mm5                ; mm2=(20 30 21 31)
+    punpckhwd   mm7, mm5                ; mm7=(22 32 23 33)
+
+    movq        mm0, mm1                ; transpose coefficients(phase 2)
+    punpckldq   mm1, mm2                ; mm1=(00 10 20 30)
+    punpckhdq   mm0, mm2                ; mm0=(01 11 21 31)
+    movq        mm3, mm6                ; transpose coefficients(phase 2)
+    punpckldq   mm6, mm7                ; mm6=(02 12 22 32)
+    punpckhdq   mm3, mm7                ; mm3=(03 13 23 33)
+
+    movq        MMWORD [MMBLOCK(0,0,edi,SIZEOF_JCOEF)], mm1
+    movq        MMWORD [MMBLOCK(1,0,edi,SIZEOF_JCOEF)], mm0
+    movq        MMWORD [MMBLOCK(2,0,edi,SIZEOF_JCOEF)], mm6
+    movq        MMWORD [MMBLOCK(3,0,edi,SIZEOF_JCOEF)], mm3
+
+.nextcolumn:
+    add         esi, byte 4*SIZEOF_JCOEF            ; coef_block
+    add         edx, byte 4*SIZEOF_ISLOW_MULT_TYPE  ; quantptr
+    add         edi, byte 4*DCTSIZE*SIZEOF_JCOEF    ; wsptr
+    dec         ecx                                 ; ctr
+    jnz         near .columnloop
+
+    ; ---- Pass 2: process rows from work array, store into output array.
+
+    mov         eax, [original_ebp]
+    lea         esi, [workspace]                   ; JCOEF *wsptr
+    mov         edi, JSAMPARRAY [output_buf(eax)]  ; (JSAMPROW *)
+    mov         eax, JDIMENSION [output_col(eax)]
+
+    ; -- Odd part
+
+    movq        mm0, MMWORD [MMBLOCK(1,0,esi,SIZEOF_JCOEF)]
+    movq        mm1, MMWORD [MMBLOCK(3,0,esi,SIZEOF_JCOEF)]
+    movq        mm2, MMWORD [MMBLOCK(5,0,esi,SIZEOF_JCOEF)]
+    movq        mm3, MMWORD [MMBLOCK(7,0,esi,SIZEOF_JCOEF)]
+
+    movq        mm4, mm0
+    movq        mm5, mm0
+    punpcklwd   mm4, mm1
+    punpckhwd   mm5, mm1
+    movq        mm0, mm4
+    movq        mm1, mm5
+    pmaddwd     mm4, [GOTOFF(ebx,PW_F256_F089)]   ; mm4=(tmp2L)
+    pmaddwd     mm5, [GOTOFF(ebx,PW_F256_F089)]   ; mm5=(tmp2H)
+    pmaddwd     mm0, [GOTOFF(ebx,PW_F106_MF217)]  ; mm0=(tmp0L)
+    pmaddwd     mm1, [GOTOFF(ebx,PW_F106_MF217)]  ; mm1=(tmp0H)
+
+    movq        mm6, mm2
+    movq        mm7, mm2
+    punpcklwd   mm6, mm3
+    punpckhwd   mm7, mm3
+    movq        mm2, mm6
+    movq        mm3, mm7
+    pmaddwd     mm6, [GOTOFF(ebx,PW_MF060_MF050)]  ; mm6=(tmp2L)
+    pmaddwd     mm7, [GOTOFF(ebx,PW_MF060_MF050)]  ; mm7=(tmp2H)
+    pmaddwd     mm2, [GOTOFF(ebx,PW_F145_MF021)]   ; mm2=(tmp0L)
+    pmaddwd     mm3, [GOTOFF(ebx,PW_F145_MF021)]   ; mm3=(tmp0H)
+
+    paddd       mm6, mm4                ; mm6=tmp2L
+    paddd       mm7, mm5                ; mm7=tmp2H
+    paddd       mm2, mm0                ; mm2=tmp0L
+    paddd       mm3, mm1                ; mm3=tmp0H
+
+    movq        MMWORD [wk(0)], mm2     ; wk(0)=tmp0L
+    movq        MMWORD [wk(1)], mm3     ; wk(1)=tmp0H
+
+    ; -- Even part
+
+    movq        mm4, MMWORD [MMBLOCK(0,0,esi,SIZEOF_JCOEF)]
+    movq        mm5, MMWORD [MMBLOCK(2,0,esi,SIZEOF_JCOEF)]
+    movq        mm0, MMWORD [MMBLOCK(6,0,esi,SIZEOF_JCOEF)]
+
+    pxor        mm1, mm1
+    pxor        mm2, mm2
+    punpcklwd   mm1, mm4                ; mm1=tmp0L
+    punpckhwd   mm2, mm4                ; mm2=tmp0H
+    psrad       mm1, (16-CONST_BITS-1)  ; psrad mm1,16 & pslld mm1,CONST_BITS+1
+    psrad       mm2, (16-CONST_BITS-1)  ; psrad mm2,16 & pslld mm2,CONST_BITS+1
+
+    movq        mm3, mm5                ; mm5=in2=z2
+    punpcklwd   mm5, mm0                ; mm0=in6=z3
+    punpckhwd   mm3, mm0
+    pmaddwd     mm5, [GOTOFF(ebx,PW_F184_MF076)]  ; mm5=tmp2L
+    pmaddwd     mm3, [GOTOFF(ebx,PW_F184_MF076)]  ; mm3=tmp2H
+
+    movq        mm4, mm1
+    movq        mm0, mm2
+    paddd       mm1, mm5                ; mm1=tmp10L
+    paddd       mm2, mm3                ; mm2=tmp10H
+    psubd       mm4, mm5                ; mm4=tmp12L
+    psubd       mm0, mm3                ; mm0=tmp12H
+
+    ; -- Final output stage
+
+    movq        mm5, mm1
+    movq        mm3, mm2
+    paddd       mm1, mm6                ; mm1=data0L
+    paddd       mm2, mm7                ; mm2=data0H
+    psubd       mm5, mm6                ; mm5=data3L
+    psubd       mm3, mm7                ; mm3=data3H
+
+    movq        mm6, [GOTOFF(ebx,PD_DESCALE_P2_4)]  ; mm6=[PD_DESCALE_P2_4]
+
+    paddd       mm1, mm6
+    paddd       mm2, mm6
+    psrad       mm1, DESCALE_P2_4
+    psrad       mm2, DESCALE_P2_4
+    paddd       mm5, mm6
+    paddd       mm3, mm6
+    psrad       mm5, DESCALE_P2_4
+    psrad       mm3, DESCALE_P2_4
+
+    packssdw    mm1, mm2                ; mm1=data0=(00 10 20 30)
+    packssdw    mm5, mm3                ; mm5=data3=(03 13 23 33)
+
+    movq        mm7, MMWORD [wk(0)]     ; mm7=tmp0L
+    movq        mm6, MMWORD [wk(1)]     ; mm6=tmp0H
+
+    movq        mm2, mm4
+    movq        mm3, mm0
+    paddd       mm4, mm7                ; mm4=data1L
+    paddd       mm0, mm6                ; mm0=data1H
+    psubd       mm2, mm7                ; mm2=data2L
+    psubd       mm3, mm6                ; mm3=data2H
+
+    movq        mm7, [GOTOFF(ebx,PD_DESCALE_P2_4)]  ; mm7=[PD_DESCALE_P2_4]
+
+    paddd       mm4, mm7
+    paddd       mm0, mm7
+    psrad       mm4, DESCALE_P2_4
+    psrad       mm0, DESCALE_P2_4
+    paddd       mm2, mm7
+    paddd       mm3, mm7
+    psrad       mm2, DESCALE_P2_4
+    psrad       mm3, DESCALE_P2_4
+
+    packssdw    mm4, mm0                ; mm4=data1=(01 11 21 31)
+    packssdw    mm2, mm3                ; mm2=data2=(02 12 22 32)
+
+    movq        mm6, [GOTOFF(ebx,PB_CENTERJSAMP)]  ; mm6=[PB_CENTERJSAMP]
+
+    packsswb    mm1, mm2                ; mm1=(00 10 20 30 02 12 22 32)
+    packsswb    mm4, mm5                ; mm4=(01 11 21 31 03 13 23 33)
+    paddb       mm1, mm6
+    paddb       mm4, mm6
+
+    movq        mm7, mm1                ; transpose coefficients(phase 1)
+    punpcklbw   mm1, mm4                ; mm1=(00 01 10 11 20 21 30 31)
+    punpckhbw   mm7, mm4                ; mm7=(02 03 12 13 22 23 32 33)
+
+    movq        mm0, mm1                ; transpose coefficients(phase 2)
+    punpcklwd   mm1, mm7                ; mm1=(00 01 02 03 10 11 12 13)
+    punpckhwd   mm0, mm7                ; mm0=(20 21 22 23 30 31 32 33)
+
+    mov         edx, JSAMPROW [edi+0*SIZEOF_JSAMPROW]
+    mov         esi, JSAMPROW [edi+2*SIZEOF_JSAMPROW]
+    movd        dword [edx+eax*SIZEOF_JSAMPLE], mm1
+    movd        dword [esi+eax*SIZEOF_JSAMPLE], mm0
+
+    psrlq       mm1, 4*BYTE_BIT
+    psrlq       mm0, 4*BYTE_BIT
+
+    mov         edx, JSAMPROW [edi+1*SIZEOF_JSAMPROW]
+    mov         esi, JSAMPROW [edi+3*SIZEOF_JSAMPROW]
+    movd        dword [edx+eax*SIZEOF_JSAMPLE], mm1
+    movd        dword [esi+eax*SIZEOF_JSAMPLE], mm0
+
+    emms                                ; empty MMX state
+
+    pop         edi
+    pop         esi
+;   pop         edx                     ; need not be preserved
+;   pop         ecx                     ; need not be preserved
+    poppic      ebx
+    mov         esp, ebp                ; esp <- aligned ebp
+    pop         esp                     ; esp <- original ebp
+    pop         ebp
+    ret
+
+; --------------------------------------------------------------------------
+;
+; Perform dequantization and inverse DCT on one block of coefficients,
+; producing a reduced-size 2x2 output block.
+;
+; GLOBAL(void)
+; jsimd_idct_2x2_mmx(void *dct_table, JCOEFPTR coef_block,
+;                    JSAMPARRAY output_buf, JDIMENSION output_col)
+;
+
+%define dct_table(b)   (b) + 8          ; void *dct_table
+%define coef_block(b)  (b) + 12         ; JCOEFPTR coef_block
+%define output_buf(b)  (b) + 16         ; JSAMPARRAY output_buf
+%define output_col(b)  (b) + 20         ; JDIMENSION output_col
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_idct_2x2_mmx)
+
+EXTN(jsimd_idct_2x2_mmx):
+    push        ebp
+    mov         ebp, esp
+    push        ebx
+;   push        ecx                     ; need not be preserved
+;   push        edx                     ; need not be preserved
+    push        esi
+    push        edi
+
+    get_GOT     ebx                     ; get GOT address
+
+    ; ---- Pass 1: process columns from input.
+
+    mov         edx, POINTER [dct_table(ebp)]    ; quantptr
+    mov         esi, JCOEFPTR [coef_block(ebp)]  ; inptr
+
+    ; | input:                  | result:        |
+    ; | 00 01 ** 03 ** 05 ** 07 |                |
+    ; | 10 11 ** 13 ** 15 ** 17 |                |
+    ; | ** ** ** ** ** ** ** ** |                |
+    ; | 30 31 ** 33 ** 35 ** 37 | A0 A1 A3 A5 A7 |
+    ; | ** ** ** ** ** ** ** ** | B0 B1 B3 B5 B7 |
+    ; | 50 51 ** 53 ** 55 ** 57 |                |
+    ; | ** ** ** ** ** ** ** ** |                |
+    ; | 70 71 ** 73 ** 75 ** 77 |                |
+
+    ; -- Odd part
+
+    movq        mm0, MMWORD [MMBLOCK(1,0,esi,SIZEOF_JCOEF)]
+    movq        mm1, MMWORD [MMBLOCK(3,0,esi,SIZEOF_JCOEF)]
+    pmullw      mm0, MMWORD [MMBLOCK(1,0,edx,SIZEOF_ISLOW_MULT_TYPE)]
+    pmullw      mm1, MMWORD [MMBLOCK(3,0,edx,SIZEOF_ISLOW_MULT_TYPE)]
+    movq        mm2, MMWORD [MMBLOCK(5,0,esi,SIZEOF_JCOEF)]
+    movq        mm3, MMWORD [MMBLOCK(7,0,esi,SIZEOF_JCOEF)]
+    pmullw      mm2, MMWORD [MMBLOCK(5,0,edx,SIZEOF_ISLOW_MULT_TYPE)]
+    pmullw      mm3, MMWORD [MMBLOCK(7,0,edx,SIZEOF_ISLOW_MULT_TYPE)]
+
+    ; mm0=(10 11 ** 13), mm1=(30 31 ** 33)
+    ; mm2=(50 51 ** 53), mm3=(70 71 ** 73)
+
+    pcmpeqd     mm7, mm7
+    pslld       mm7, WORD_BIT           ; mm7={0x0000 0xFFFF 0x0000 0xFFFF}
+
+    movq        mm4, mm0                ; mm4=(10 11 ** 13)
+    movq        mm5, mm2                ; mm5=(50 51 ** 53)
+    punpcklwd   mm4, mm1                ; mm4=(10 30 11 31)
+    punpcklwd   mm5, mm3                ; mm5=(50 70 51 71)
+    pmaddwd     mm4, [GOTOFF(ebx,PW_F362_MF127)]
+    pmaddwd     mm5, [GOTOFF(ebx,PW_F085_MF072)]
+
+    psrld       mm0, WORD_BIT           ; mm0=(11 -- 13 --)
+    pand        mm1, mm7                ; mm1=(-- 31 -- 33)
+    psrld       mm2, WORD_BIT           ; mm2=(51 -- 53 --)
+    pand        mm3, mm7                ; mm3=(-- 71 -- 73)
+    por         mm0, mm1                ; mm0=(11 31 13 33)
+    por         mm2, mm3                ; mm2=(51 71 53 73)
+    pmaddwd     mm0, [GOTOFF(ebx,PW_F362_MF127)]
+    pmaddwd     mm2, [GOTOFF(ebx,PW_F085_MF072)]
+
+    paddd       mm4, mm5                ; mm4=tmp0[col0 col1]
+
+    movq        mm6, MMWORD [MMBLOCK(1,1,esi,SIZEOF_JCOEF)]
+    movq        mm1, MMWORD [MMBLOCK(3,1,esi,SIZEOF_JCOEF)]
+    pmullw      mm6, MMWORD [MMBLOCK(1,1,edx,SIZEOF_ISLOW_MULT_TYPE)]
+    pmullw      mm1, MMWORD [MMBLOCK(3,1,edx,SIZEOF_ISLOW_MULT_TYPE)]
+    movq        mm3, MMWORD [MMBLOCK(5,1,esi,SIZEOF_JCOEF)]
+    movq        mm5, MMWORD [MMBLOCK(7,1,esi,SIZEOF_JCOEF)]
+    pmullw      mm3, MMWORD [MMBLOCK(5,1,edx,SIZEOF_ISLOW_MULT_TYPE)]
+    pmullw      mm5, MMWORD [MMBLOCK(7,1,edx,SIZEOF_ISLOW_MULT_TYPE)]
+
+    ; mm6=(** 15 ** 17), mm1=(** 35 ** 37)
+    ; mm3=(** 55 ** 57), mm5=(** 75 ** 77)
+
+    psrld       mm6, WORD_BIT           ; mm6=(15 -- 17 --)
+    pand        mm1, mm7                ; mm1=(-- 35 -- 37)
+    psrld       mm3, WORD_BIT           ; mm3=(55 -- 57 --)
+    pand        mm5, mm7                ; mm5=(-- 75 -- 77)
+    por         mm6, mm1                ; mm6=(15 35 17 37)
+    por         mm3, mm5                ; mm3=(55 75 57 77)
+    pmaddwd     mm6, [GOTOFF(ebx,PW_F362_MF127)]
+    pmaddwd     mm3, [GOTOFF(ebx,PW_F085_MF072)]
+
+    paddd       mm0, mm2                ; mm0=tmp0[col1 col3]
+    paddd       mm6, mm3                ; mm6=tmp0[col5 col7]
+
+    ; -- Even part
+
+    movq        mm1, MMWORD [MMBLOCK(0,0,esi,SIZEOF_JCOEF)]
+    movq        mm5, MMWORD [MMBLOCK(0,1,esi,SIZEOF_JCOEF)]
+    pmullw      mm1, MMWORD [MMBLOCK(0,0,edx,SIZEOF_ISLOW_MULT_TYPE)]
+    pmullw      mm5, MMWORD [MMBLOCK(0,1,edx,SIZEOF_ISLOW_MULT_TYPE)]
+
+    ; mm1=(00 01 ** 03), mm5=(** 05 ** 07)
+
+    movq        mm2, mm1                      ; mm2=(00 01 ** 03)
+    pslld       mm1, WORD_BIT                 ; mm1=(-- 00 -- **)
+    psrad       mm1, (WORD_BIT-CONST_BITS-2)  ; mm1=tmp10[col0 ****]
+
+    pand        mm2, mm7                      ; mm2=(-- 01 -- 03)
+    pand        mm5, mm7                      ; mm5=(-- 05 -- 07)
+    psrad       mm2, (WORD_BIT-CONST_BITS-2)  ; mm2=tmp10[col1 col3]
+    psrad       mm5, (WORD_BIT-CONST_BITS-2)  ; mm5=tmp10[col5 col7]
+
+    ; -- Final output stage
+
+    movq        mm3, mm1
+    paddd       mm1, mm4                ; mm1=data0[col0 ****]=(A0 **)
+    psubd       mm3, mm4                ; mm3=data1[col0 ****]=(B0 **)
+    punpckldq   mm1, mm3                ; mm1=(A0 B0)
+
+    movq        mm7, [GOTOFF(ebx,PD_DESCALE_P1_2)]  ; mm7=[PD_DESCALE_P1_2]
+
+    movq        mm4, mm2
+    movq        mm3, mm5
+    paddd       mm2, mm0                ; mm2=data0[col1 col3]=(A1 A3)
+    paddd       mm5, mm6                ; mm5=data0[col5 col7]=(A5 A7)
+    psubd       mm4, mm0                ; mm4=data1[col1 col3]=(B1 B3)
+    psubd       mm3, mm6                ; mm3=data1[col5 col7]=(B5 B7)
+
+    paddd       mm1, mm7
+    psrad       mm1, DESCALE_P1_2
+
+    paddd       mm2, mm7
+    paddd       mm5, mm7
+    psrad       mm2, DESCALE_P1_2
+    psrad       mm5, DESCALE_P1_2
+    paddd       mm4, mm7
+    paddd       mm3, mm7
+    psrad       mm4, DESCALE_P1_2
+    psrad       mm3, DESCALE_P1_2
+
+    ; ---- Pass 2: process rows, store into output array.
+
+    mov         edi, JSAMPARRAY [output_buf(ebp)]  ; (JSAMPROW *)
+    mov         eax, JDIMENSION [output_col(ebp)]
+
+    ; | input:| result:|
+    ; | A0 B0 |        |
+    ; | A1 B1 | C0 C1  |
+    ; | A3 B3 | D0 D1  |
+    ; | A5 B5 |        |
+    ; | A7 B7 |        |
+
+    ; -- Odd part
+
+    packssdw    mm2, mm4                ; mm2=(A1 A3 B1 B3)
+    packssdw    mm5, mm3                ; mm5=(A5 A7 B5 B7)
+    pmaddwd     mm2, [GOTOFF(ebx,PW_F362_MF127)]
+    pmaddwd     mm5, [GOTOFF(ebx,PW_F085_MF072)]
+
+    paddd       mm2, mm5                ; mm2=tmp0[row0 row1]
+
+    ; -- Even part
+
+    pslld       mm1, (CONST_BITS+2)     ; mm1=tmp10[row0 row1]
+
+    ; -- Final output stage
+
+    movq        mm0, [GOTOFF(ebx,PD_DESCALE_P2_2)]  ; mm0=[PD_DESCALE_P2_2]
+
+    movq        mm6, mm1
+    paddd       mm1, mm2                ; mm1=data0[row0 row1]=(C0 C1)
+    psubd       mm6, mm2                ; mm6=data1[row0 row1]=(D0 D1)
+
+    paddd       mm1, mm0
+    paddd       mm6, mm0
+    psrad       mm1, DESCALE_P2_2
+    psrad       mm6, DESCALE_P2_2
+
+    movq        mm7, mm1                ; transpose coefficients
+    punpckldq   mm1, mm6                ; mm1=(C0 D0)
+    punpckhdq   mm7, mm6                ; mm7=(C1 D1)
+
+    packssdw    mm1, mm7                ; mm1=(C0 D0 C1 D1)
+    packsswb    mm1, mm1                ; mm1=(C0 D0 C1 D1 C0 D0 C1 D1)
+    paddb       mm1, [GOTOFF(ebx,PB_CENTERJSAMP)]
+
+    movd        ecx, mm1
+    movd        ebx, mm1                ; ebx=(C0 D0 C1 D1)
+    shr         ecx, 2*BYTE_BIT         ; ecx=(C1 D1 -- --)
+
+    mov         edx, JSAMPROW [edi+0*SIZEOF_JSAMPROW]
+    mov         esi, JSAMPROW [edi+1*SIZEOF_JSAMPROW]
+    mov         word [edx+eax*SIZEOF_JSAMPLE], bx
+    mov         word [esi+eax*SIZEOF_JSAMPLE], cx
+
+    emms                                ; empty MMX state
+
+    pop         edi
+    pop         esi
+;   pop         edx                     ; need not be preserved
+;   pop         ecx                     ; need not be preserved
+    pop         ebx
+    pop         ebp
+    ret
+
+; For some reason, the OS X linker does not honor the request to align the
+; segment unless we do this.
+    align       32
diff --git a/3rdparty/libjpeg/src/simd/i386/jidctred-sse2.asm b/3rdparty/libjpeg/src/simd/i386/jidctred-sse2.asm
new file mode 100644
index 00000000..6e56494e
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/i386/jidctred-sse2.asm
@@ -0,0 +1,592 @@
+;
+; jidctred.asm - reduced-size IDCT (SSE2)
+;
+; Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+; Copyright (C) 2016, D. R. Commander.
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+;
+; This file should be assembled with NASM (Netwide Assembler),
+; can *not* be assembled with Microsoft's MASM or any compatible
+; assembler (including Borland's Turbo Assembler).
+; NASM is available from http://nasm.sourceforge.net/ or
+; http://sourceforge.net/project/showfiles.php?group_id=6208
+;
+; This file contains inverse-DCT routines that produce reduced-size
+; output: either 4x4 or 2x2 pixels from an 8x8 DCT block.
+; The following code is based directly on the IJG's original jidctred.c;
+; see the jidctred.c for more details.
+
+%include "jsimdext.inc"
+%include "jdct.inc"
+
+; --------------------------------------------------------------------------
+
+%define CONST_BITS    13
+%define PASS1_BITS    2
+
+%define DESCALE_P1_4  (CONST_BITS - PASS1_BITS + 1)
+%define DESCALE_P2_4  (CONST_BITS + PASS1_BITS + 3 + 1)
+%define DESCALE_P1_2  (CONST_BITS - PASS1_BITS + 2)
+%define DESCALE_P2_2  (CONST_BITS + PASS1_BITS + 3 + 2)
+
+%if CONST_BITS == 13
+F_0_211 equ  1730  ; FIX(0.211164243)
+F_0_509 equ  4176  ; FIX(0.509795579)
+F_0_601 equ  4926  ; FIX(0.601344887)
+F_0_720 equ  5906  ; FIX(0.720959822)
+F_0_765 equ  6270  ; FIX(0.765366865)
+F_0_850 equ  6967  ; FIX(0.850430095)
+F_0_899 equ  7373  ; FIX(0.899976223)
+F_1_061 equ  8697  ; FIX(1.061594337)
+F_1_272 equ 10426  ; FIX(1.272758580)
+F_1_451 equ 11893  ; FIX(1.451774981)
+F_1_847 equ 15137  ; FIX(1.847759065)
+F_2_172 equ 17799  ; FIX(2.172734803)
+F_2_562 equ 20995  ; FIX(2.562915447)
+F_3_624 equ 29692  ; FIX(3.624509785)
+%else
+; NASM cannot do compile-time arithmetic on floating-point constants.
+%define DESCALE(x, n)  (((x) + (1 << ((n) - 1))) >> (n))
+F_0_211 equ DESCALE( 226735879, 30 - CONST_BITS)  ; FIX(0.211164243)
+F_0_509 equ DESCALE( 547388834, 30 - CONST_BITS)  ; FIX(0.509795579)
+F_0_601 equ DESCALE( 645689155, 30 - CONST_BITS)  ; FIX(0.601344887)
+F_0_720 equ DESCALE( 774124714, 30 - CONST_BITS)  ; FIX(0.720959822)
+F_0_765 equ DESCALE( 821806413, 30 - CONST_BITS)  ; FIX(0.765366865)
+F_0_850 equ DESCALE( 913142361, 30 - CONST_BITS)  ; FIX(0.850430095)
+F_0_899 equ DESCALE( 966342111, 30 - CONST_BITS)  ; FIX(0.899976223)
+F_1_061 equ DESCALE(1139878239, 30 - CONST_BITS)  ; FIX(1.061594337)
+F_1_272 equ DESCALE(1366614119, 30 - CONST_BITS)  ; FIX(1.272758580)
+F_1_451 equ DESCALE(1558831516, 30 - CONST_BITS)  ; FIX(1.451774981)
+F_1_847 equ DESCALE(1984016188, 30 - CONST_BITS)  ; FIX(1.847759065)
+F_2_172 equ DESCALE(2332956230, 30 - CONST_BITS)  ; FIX(2.172734803)
+F_2_562 equ DESCALE(2751909506, 30 - CONST_BITS)  ; FIX(2.562915447)
+F_3_624 equ DESCALE(3891787747, 30 - CONST_BITS)  ; FIX(3.624509785)
+%endif
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_CONST
+
+    alignz      32
+    GLOBAL_DATA(jconst_idct_red_sse2)
+
+EXTN(jconst_idct_red_sse2):
+
+PW_F184_MF076   times 4  dw  F_1_847, -F_0_765
+PW_F256_F089    times 4  dw  F_2_562,  F_0_899
+PW_F106_MF217   times 4  dw  F_1_061, -F_2_172
+PW_MF060_MF050  times 4  dw -F_0_601, -F_0_509
+PW_F145_MF021   times 4  dw  F_1_451, -F_0_211
+PW_F362_MF127   times 4  dw  F_3_624, -F_1_272
+PW_F085_MF072   times 4  dw  F_0_850, -F_0_720
+PD_DESCALE_P1_4 times 4  dd  1 << (DESCALE_P1_4 - 1)
+PD_DESCALE_P2_4 times 4  dd  1 << (DESCALE_P2_4 - 1)
+PD_DESCALE_P1_2 times 4  dd  1 << (DESCALE_P1_2 - 1)
+PD_DESCALE_P2_2 times 4  dd  1 << (DESCALE_P2_2 - 1)
+PB_CENTERJSAMP  times 16 db  CENTERJSAMPLE
+
+    alignz      32
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_TEXT
+    BITS        32
+;
+; Perform dequantization and inverse DCT on one block of coefficients,
+; producing a reduced-size 4x4 output block.
+;
+; GLOBAL(void)
+; jsimd_idct_4x4_sse2(void *dct_table, JCOEFPTR coef_block,
+;                     JSAMPARRAY output_buf, JDIMENSION output_col)
+;
+
+%define dct_table(b)   (b) + 8          ; void *dct_table
+%define coef_block(b)  (b) + 12         ; JCOEFPTR coef_block
+%define output_buf(b)  (b) + 16         ; JSAMPARRAY output_buf
+%define output_col(b)  (b) + 20         ; JDIMENSION output_col
+
+%define original_ebp   ebp + 0
+%define wk(i)          ebp - (WK_NUM - (i)) * SIZEOF_XMMWORD
+                                        ; xmmword wk[WK_NUM]
+%define WK_NUM         2
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_idct_4x4_sse2)
+
+EXTN(jsimd_idct_4x4_sse2):
+    push        ebp
+    mov         eax, esp                     ; eax = original ebp
+    sub         esp, byte 4
+    and         esp, byte (-SIZEOF_XMMWORD)  ; align to 128 bits
+    mov         [esp], eax
+    mov         ebp, esp                     ; ebp = aligned ebp
+    lea         esp, [wk(0)]
+    pushpic     ebx
+;   push        ecx                     ; unused
+;   push        edx                     ; need not be preserved
+    push        esi
+    push        edi
+
+    get_GOT     ebx                     ; get GOT address
+
+    ; ---- Pass 1: process columns from input.
+
+;   mov         eax, [original_ebp]
+    mov         edx, POINTER [dct_table(eax)]    ; quantptr
+    mov         esi, JCOEFPTR [coef_block(eax)]  ; inptr
+
+%ifndef NO_ZERO_COLUMN_TEST_4X4_SSE2
+    mov         eax, dword [DWBLOCK(1,0,esi,SIZEOF_JCOEF)]
+    or          eax, dword [DWBLOCK(2,0,esi,SIZEOF_JCOEF)]
+    jnz         short .columnDCT
+
+    movdqa      xmm0, XMMWORD [XMMBLOCK(1,0,esi,SIZEOF_JCOEF)]
+    movdqa      xmm1, XMMWORD [XMMBLOCK(2,0,esi,SIZEOF_JCOEF)]
+    por         xmm0, XMMWORD [XMMBLOCK(3,0,esi,SIZEOF_JCOEF)]
+    por         xmm1, XMMWORD [XMMBLOCK(5,0,esi,SIZEOF_JCOEF)]
+    por         xmm0, XMMWORD [XMMBLOCK(6,0,esi,SIZEOF_JCOEF)]
+    por         xmm1, XMMWORD [XMMBLOCK(7,0,esi,SIZEOF_JCOEF)]
+    por         xmm0, xmm1
+    packsswb    xmm0, xmm0
+    packsswb    xmm0, xmm0
+    movd        eax, xmm0
+    test        eax, eax
+    jnz         short .columnDCT
+
+    ; -- AC terms all zero
+
+    movdqa      xmm0, XMMWORD [XMMBLOCK(0,0,esi,SIZEOF_JCOEF)]
+    pmullw      xmm0, XMMWORD [XMMBLOCK(0,0,edx,SIZEOF_ISLOW_MULT_TYPE)]
+
+    psllw       xmm0, PASS1_BITS
+
+    movdqa      xmm3, xmm0        ; xmm0=in0=(00 01 02 03 04 05 06 07)
+    punpcklwd   xmm0, xmm0        ; xmm0=(00 00 01 01 02 02 03 03)
+    punpckhwd   xmm3, xmm3        ; xmm3=(04 04 05 05 06 06 07 07)
+
+    pshufd      xmm1, xmm0, 0x50  ; xmm1=[col0 col1]=(00 00 00 00 01 01 01 01)
+    pshufd      xmm0, xmm0, 0xFA  ; xmm0=[col2 col3]=(02 02 02 02 03 03 03 03)
+    pshufd      xmm6, xmm3, 0x50  ; xmm6=[col4 col5]=(04 04 04 04 05 05 05 05)
+    pshufd      xmm3, xmm3, 0xFA  ; xmm3=[col6 col7]=(06 06 06 06 07 07 07 07)
+
+    jmp         near .column_end
+    alignx      16, 7
+%endif
+.columnDCT:
+
+    ; -- Odd part
+
+    movdqa      xmm0, XMMWORD [XMMBLOCK(1,0,esi,SIZEOF_JCOEF)]
+    movdqa      xmm1, XMMWORD [XMMBLOCK(3,0,esi,SIZEOF_JCOEF)]
+    pmullw      xmm0, XMMWORD [XMMBLOCK(1,0,edx,SIZEOF_ISLOW_MULT_TYPE)]
+    pmullw      xmm1, XMMWORD [XMMBLOCK(3,0,edx,SIZEOF_ISLOW_MULT_TYPE)]
+    movdqa      xmm2, XMMWORD [XMMBLOCK(5,0,esi,SIZEOF_JCOEF)]
+    movdqa      xmm3, XMMWORD [XMMBLOCK(7,0,esi,SIZEOF_JCOEF)]
+    pmullw      xmm2, XMMWORD [XMMBLOCK(5,0,edx,SIZEOF_ISLOW_MULT_TYPE)]
+    pmullw      xmm3, XMMWORD [XMMBLOCK(7,0,edx,SIZEOF_ISLOW_MULT_TYPE)]
+
+    movdqa      xmm4, xmm0
+    movdqa      xmm5, xmm0
+    punpcklwd   xmm4, xmm1
+    punpckhwd   xmm5, xmm1
+    movdqa      xmm0, xmm4
+    movdqa      xmm1, xmm5
+    pmaddwd     xmm4, [GOTOFF(ebx,PW_F256_F089)]   ; xmm4=(tmp2L)
+    pmaddwd     xmm5, [GOTOFF(ebx,PW_F256_F089)]   ; xmm5=(tmp2H)
+    pmaddwd     xmm0, [GOTOFF(ebx,PW_F106_MF217)]  ; xmm0=(tmp0L)
+    pmaddwd     xmm1, [GOTOFF(ebx,PW_F106_MF217)]  ; xmm1=(tmp0H)
+
+    movdqa      xmm6, xmm2
+    movdqa      xmm7, xmm2
+    punpcklwd   xmm6, xmm3
+    punpckhwd   xmm7, xmm3
+    movdqa      xmm2, xmm6
+    movdqa      xmm3, xmm7
+    pmaddwd     xmm6, [GOTOFF(ebx,PW_MF060_MF050)]  ; xmm6=(tmp2L)
+    pmaddwd     xmm7, [GOTOFF(ebx,PW_MF060_MF050)]  ; xmm7=(tmp2H)
+    pmaddwd     xmm2, [GOTOFF(ebx,PW_F145_MF021)]   ; xmm2=(tmp0L)
+    pmaddwd     xmm3, [GOTOFF(ebx,PW_F145_MF021)]   ; xmm3=(tmp0H)
+
+    paddd       xmm6, xmm4              ; xmm6=tmp2L
+    paddd       xmm7, xmm5              ; xmm7=tmp2H
+    paddd       xmm2, xmm0              ; xmm2=tmp0L
+    paddd       xmm3, xmm1              ; xmm3=tmp0H
+
+    movdqa      XMMWORD [wk(0)], xmm2   ; wk(0)=tmp0L
+    movdqa      XMMWORD [wk(1)], xmm3   ; wk(1)=tmp0H
+
+    ; -- Even part
+
+    movdqa      xmm4, XMMWORD [XMMBLOCK(0,0,esi,SIZEOF_JCOEF)]
+    movdqa      xmm5, XMMWORD [XMMBLOCK(2,0,esi,SIZEOF_JCOEF)]
+    movdqa      xmm0, XMMWORD [XMMBLOCK(6,0,esi,SIZEOF_JCOEF)]
+    pmullw      xmm4, XMMWORD [XMMBLOCK(0,0,edx,SIZEOF_ISLOW_MULT_TYPE)]
+    pmullw      xmm5, XMMWORD [XMMBLOCK(2,0,edx,SIZEOF_ISLOW_MULT_TYPE)]
+    pmullw      xmm0, XMMWORD [XMMBLOCK(6,0,edx,SIZEOF_ISLOW_MULT_TYPE)]
+
+    pxor        xmm1, xmm1
+    pxor        xmm2, xmm2
+    punpcklwd   xmm1, xmm4               ; xmm1=tmp0L
+    punpckhwd   xmm2, xmm4               ; xmm2=tmp0H
+    psrad       xmm1, (16-CONST_BITS-1)  ; psrad xmm1,16 & pslld xmm1,CONST_BITS+1
+    psrad       xmm2, (16-CONST_BITS-1)  ; psrad xmm2,16 & pslld xmm2,CONST_BITS+1
+
+    movdqa      xmm3, xmm5              ; xmm5=in2=z2
+    punpcklwd   xmm5, xmm0              ; xmm0=in6=z3
+    punpckhwd   xmm3, xmm0
+    pmaddwd     xmm5, [GOTOFF(ebx,PW_F184_MF076)]  ; xmm5=tmp2L
+    pmaddwd     xmm3, [GOTOFF(ebx,PW_F184_MF076)]  ; xmm3=tmp2H
+
+    movdqa      xmm4, xmm1
+    movdqa      xmm0, xmm2
+    paddd       xmm1, xmm5              ; xmm1=tmp10L
+    paddd       xmm2, xmm3              ; xmm2=tmp10H
+    psubd       xmm4, xmm5              ; xmm4=tmp12L
+    psubd       xmm0, xmm3              ; xmm0=tmp12H
+
+    ; -- Final output stage
+
+    movdqa      xmm5, xmm1
+    movdqa      xmm3, xmm2
+    paddd       xmm1, xmm6              ; xmm1=data0L
+    paddd       xmm2, xmm7              ; xmm2=data0H
+    psubd       xmm5, xmm6              ; xmm5=data3L
+    psubd       xmm3, xmm7              ; xmm3=data3H
+
+    movdqa      xmm6, [GOTOFF(ebx,PD_DESCALE_P1_4)]  ; xmm6=[PD_DESCALE_P1_4]
+
+    paddd       xmm1, xmm6
+    paddd       xmm2, xmm6
+    psrad       xmm1, DESCALE_P1_4
+    psrad       xmm2, DESCALE_P1_4
+    paddd       xmm5, xmm6
+    paddd       xmm3, xmm6
+    psrad       xmm5, DESCALE_P1_4
+    psrad       xmm3, DESCALE_P1_4
+
+    packssdw    xmm1, xmm2              ; xmm1=data0=(00 01 02 03 04 05 06 07)
+    packssdw    xmm5, xmm3              ; xmm5=data3=(30 31 32 33 34 35 36 37)
+
+    movdqa      xmm7, XMMWORD [wk(0)]   ; xmm7=tmp0L
+    movdqa      xmm6, XMMWORD [wk(1)]   ; xmm6=tmp0H
+
+    movdqa      xmm2, xmm4
+    movdqa      xmm3, xmm0
+    paddd       xmm4, xmm7              ; xmm4=data1L
+    paddd       xmm0, xmm6              ; xmm0=data1H
+    psubd       xmm2, xmm7              ; xmm2=data2L
+    psubd       xmm3, xmm6              ; xmm3=data2H
+
+    movdqa      xmm7, [GOTOFF(ebx,PD_DESCALE_P1_4)]  ; xmm7=[PD_DESCALE_P1_4]
+
+    paddd       xmm4, xmm7
+    paddd       xmm0, xmm7
+    psrad       xmm4, DESCALE_P1_4
+    psrad       xmm0, DESCALE_P1_4
+    paddd       xmm2, xmm7
+    paddd       xmm3, xmm7
+    psrad       xmm2, DESCALE_P1_4
+    psrad       xmm3, DESCALE_P1_4
+
+    packssdw    xmm4, xmm0        ; xmm4=data1=(10 11 12 13 14 15 16 17)
+    packssdw    xmm2, xmm3        ; xmm2=data2=(20 21 22 23 24 25 26 27)
+
+    movdqa      xmm6, xmm1        ; transpose coefficients(phase 1)
+    punpcklwd   xmm1, xmm4        ; xmm1=(00 10 01 11 02 12 03 13)
+    punpckhwd   xmm6, xmm4        ; xmm6=(04 14 05 15 06 16 07 17)
+    movdqa      xmm7, xmm2        ; transpose coefficients(phase 1)
+    punpcklwd   xmm2, xmm5        ; xmm2=(20 30 21 31 22 32 23 33)
+    punpckhwd   xmm7, xmm5        ; xmm7=(24 34 25 35 26 36 27 37)
+
+    movdqa      xmm0, xmm1        ; transpose coefficients(phase 2)
+    punpckldq   xmm1, xmm2        ; xmm1=[col0 col1]=(00 10 20 30 01 11 21 31)
+    punpckhdq   xmm0, xmm2        ; xmm0=[col2 col3]=(02 12 22 32 03 13 23 33)
+    movdqa      xmm3, xmm6        ; transpose coefficients(phase 2)
+    punpckldq   xmm6, xmm7        ; xmm6=[col4 col5]=(04 14 24 34 05 15 25 35)
+    punpckhdq   xmm3, xmm7        ; xmm3=[col6 col7]=(06 16 26 36 07 17 27 37)
+.column_end:
+
+    ; -- Prefetch the next coefficient block
+
+    prefetchnta [esi + DCTSIZE2*SIZEOF_JCOEF + 0*32]
+    prefetchnta [esi + DCTSIZE2*SIZEOF_JCOEF + 1*32]
+    prefetchnta [esi + DCTSIZE2*SIZEOF_JCOEF + 2*32]
+    prefetchnta [esi + DCTSIZE2*SIZEOF_JCOEF + 3*32]
+
+    ; ---- Pass 2: process rows, store into output array.
+
+    mov         eax, [original_ebp]
+    mov         edi, JSAMPARRAY [output_buf(eax)]  ; (JSAMPROW *)
+    mov         eax, JDIMENSION [output_col(eax)]
+
+    ; -- Even part
+
+    pxor        xmm4, xmm4
+    punpcklwd   xmm4, xmm1               ; xmm4=tmp0
+    psrad       xmm4, (16-CONST_BITS-1)  ; psrad xmm4,16 & pslld xmm4,CONST_BITS+1
+
+    ; -- Odd part
+
+    punpckhwd   xmm1, xmm0
+    punpckhwd   xmm6, xmm3
+    movdqa      xmm5, xmm1
+    movdqa      xmm2, xmm6
+    pmaddwd     xmm1, [GOTOFF(ebx,PW_F256_F089)]    ; xmm1=(tmp2)
+    pmaddwd     xmm6, [GOTOFF(ebx,PW_MF060_MF050)]  ; xmm6=(tmp2)
+    pmaddwd     xmm5, [GOTOFF(ebx,PW_F106_MF217)]   ; xmm5=(tmp0)
+    pmaddwd     xmm2, [GOTOFF(ebx,PW_F145_MF021)]   ; xmm2=(tmp0)
+
+    paddd       xmm6, xmm1              ; xmm6=tmp2
+    paddd       xmm2, xmm5              ; xmm2=tmp0
+
+    ; -- Even part
+
+    punpcklwd   xmm0, xmm3
+    pmaddwd     xmm0, [GOTOFF(ebx,PW_F184_MF076)]  ; xmm0=tmp2
+
+    movdqa      xmm7, xmm4
+    paddd       xmm4, xmm0              ; xmm4=tmp10
+    psubd       xmm7, xmm0              ; xmm7=tmp12
+
+    ; -- Final output stage
+
+    movdqa      xmm1, [GOTOFF(ebx,PD_DESCALE_P2_4)]  ; xmm1=[PD_DESCALE_P2_4]
+
+    movdqa      xmm5, xmm4
+    movdqa      xmm3, xmm7
+    paddd       xmm4, xmm6              ; xmm4=data0=(00 10 20 30)
+    paddd       xmm7, xmm2              ; xmm7=data1=(01 11 21 31)
+    psubd       xmm5, xmm6              ; xmm5=data3=(03 13 23 33)
+    psubd       xmm3, xmm2              ; xmm3=data2=(02 12 22 32)
+
+    paddd       xmm4, xmm1
+    paddd       xmm7, xmm1
+    psrad       xmm4, DESCALE_P2_4
+    psrad       xmm7, DESCALE_P2_4
+    paddd       xmm5, xmm1
+    paddd       xmm3, xmm1
+    psrad       xmm5, DESCALE_P2_4
+    psrad       xmm3, DESCALE_P2_4
+
+    packssdw    xmm4, xmm3              ; xmm4=(00 10 20 30 02 12 22 32)
+    packssdw    xmm7, xmm5              ; xmm7=(01 11 21 31 03 13 23 33)
+
+    movdqa      xmm0, xmm4              ; transpose coefficients(phase 1)
+    punpcklwd   xmm4, xmm7              ; xmm4=(00 01 10 11 20 21 30 31)
+    punpckhwd   xmm0, xmm7              ; xmm0=(02 03 12 13 22 23 32 33)
+
+    movdqa      xmm6, xmm4              ; transpose coefficients(phase 2)
+    punpckldq   xmm4, xmm0              ; xmm4=(00 01 02 03 10 11 12 13)
+    punpckhdq   xmm6, xmm0              ; xmm6=(20 21 22 23 30 31 32 33)
+
+    packsswb    xmm4, xmm6              ; xmm4=(00 01 02 03 10 11 12 13 20 ..)
+    paddb       xmm4, [GOTOFF(ebx,PB_CENTERJSAMP)]
+
+    pshufd      xmm2, xmm4, 0x39        ; xmm2=(10 11 12 13 20 21 22 23 30 ..)
+    pshufd      xmm1, xmm4, 0x4E        ; xmm1=(20 21 22 23 30 31 32 33 00 ..)
+    pshufd      xmm3, xmm4, 0x93        ; xmm3=(30 31 32 33 00 01 02 03 10 ..)
+
+    mov         edx, JSAMPROW [edi+0*SIZEOF_JSAMPROW]
+    mov         esi, JSAMPROW [edi+1*SIZEOF_JSAMPROW]
+    movd        XMM_DWORD [edx+eax*SIZEOF_JSAMPLE], xmm4
+    movd        XMM_DWORD [esi+eax*SIZEOF_JSAMPLE], xmm2
+    mov         edx, JSAMPROW [edi+2*SIZEOF_JSAMPROW]
+    mov         esi, JSAMPROW [edi+3*SIZEOF_JSAMPROW]
+    movd        XMM_DWORD [edx+eax*SIZEOF_JSAMPLE], xmm1
+    movd        XMM_DWORD [esi+eax*SIZEOF_JSAMPLE], xmm3
+
+    pop         edi
+    pop         esi
+;   pop         edx                     ; need not be preserved
+;   pop         ecx                     ; unused
+    poppic      ebx
+    mov         esp, ebp                ; esp <- aligned ebp
+    pop         esp                     ; esp <- original ebp
+    pop         ebp
+    ret
+
+; --------------------------------------------------------------------------
+;
+; Perform dequantization and inverse DCT on one block of coefficients,
+; producing a reduced-size 2x2 output block.
+;
+; GLOBAL(void)
+; jsimd_idct_2x2_sse2(void *dct_table, JCOEFPTR coef_block,
+;                     JSAMPARRAY output_buf, JDIMENSION output_col)
+;
+
+%define dct_table(b)   (b) + 8          ; void *dct_table
+%define coef_block(b)  (b) + 12         ; JCOEFPTR coef_block
+%define output_buf(b)  (b) + 16         ; JSAMPARRAY output_buf
+%define output_col(b)  (b) + 20         ; JDIMENSION output_col
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_idct_2x2_sse2)
+
+EXTN(jsimd_idct_2x2_sse2):
+    push        ebp
+    mov         ebp, esp
+    push        ebx
+;   push        ecx                     ; need not be preserved
+;   push        edx                     ; need not be preserved
+    push        esi
+    push        edi
+
+    get_GOT     ebx                     ; get GOT address
+
+    ; ---- Pass 1: process columns from input.
+
+    mov         edx, POINTER [dct_table(ebp)]    ; quantptr
+    mov         esi, JCOEFPTR [coef_block(ebp)]  ; inptr
+
+    ; | input:                  | result:        |
+    ; | 00 01 ** 03 ** 05 ** 07 |                |
+    ; | 10 11 ** 13 ** 15 ** 17 |                |
+    ; | ** ** ** ** ** ** ** ** |                |
+    ; | 30 31 ** 33 ** 35 ** 37 | A0 A1 A3 A5 A7 |
+    ; | ** ** ** ** ** ** ** ** | B0 B1 B3 B5 B7 |
+    ; | 50 51 ** 53 ** 55 ** 57 |                |
+    ; | ** ** ** ** ** ** ** ** |                |
+    ; | 70 71 ** 73 ** 75 ** 77 |                |
+
+    ; -- Odd part
+
+    movdqa      xmm0, XMMWORD [XMMBLOCK(1,0,esi,SIZEOF_JCOEF)]
+    movdqa      xmm1, XMMWORD [XMMBLOCK(3,0,esi,SIZEOF_JCOEF)]
+    pmullw      xmm0, XMMWORD [XMMBLOCK(1,0,edx,SIZEOF_ISLOW_MULT_TYPE)]
+    pmullw      xmm1, XMMWORD [XMMBLOCK(3,0,edx,SIZEOF_ISLOW_MULT_TYPE)]
+    movdqa      xmm2, XMMWORD [XMMBLOCK(5,0,esi,SIZEOF_JCOEF)]
+    movdqa      xmm3, XMMWORD [XMMBLOCK(7,0,esi,SIZEOF_JCOEF)]
+    pmullw      xmm2, XMMWORD [XMMBLOCK(5,0,edx,SIZEOF_ISLOW_MULT_TYPE)]
+    pmullw      xmm3, XMMWORD [XMMBLOCK(7,0,edx,SIZEOF_ISLOW_MULT_TYPE)]
+
+    ; xmm0=(10 11 ** 13 ** 15 ** 17), xmm1=(30 31 ** 33 ** 35 ** 37)
+    ; xmm2=(50 51 ** 53 ** 55 ** 57), xmm3=(70 71 ** 73 ** 75 ** 77)
+
+    pcmpeqd     xmm7, xmm7
+    pslld       xmm7, WORD_BIT          ; xmm7={0x0000 0xFFFF 0x0000 0xFFFF ..}
+
+    movdqa      xmm4, xmm0              ; xmm4=(10 11 ** 13 ** 15 ** 17)
+    movdqa      xmm5, xmm2              ; xmm5=(50 51 ** 53 ** 55 ** 57)
+    punpcklwd   xmm4, xmm1              ; xmm4=(10 30 11 31 ** ** 13 33)
+    punpcklwd   xmm5, xmm3              ; xmm5=(50 70 51 71 ** ** 53 73)
+    pmaddwd     xmm4, [GOTOFF(ebx,PW_F362_MF127)]
+    pmaddwd     xmm5, [GOTOFF(ebx,PW_F085_MF072)]
+
+    psrld       xmm0, WORD_BIT          ; xmm0=(11 -- 13 -- 15 -- 17 --)
+    pand        xmm1, xmm7              ; xmm1=(-- 31 -- 33 -- 35 -- 37)
+    psrld       xmm2, WORD_BIT          ; xmm2=(51 -- 53 -- 55 -- 57 --)
+    pand        xmm3, xmm7              ; xmm3=(-- 71 -- 73 -- 75 -- 77)
+    por         xmm0, xmm1              ; xmm0=(11 31 13 33 15 35 17 37)
+    por         xmm2, xmm3              ; xmm2=(51 71 53 73 55 75 57 77)
+    pmaddwd     xmm0, [GOTOFF(ebx,PW_F362_MF127)]
+    pmaddwd     xmm2, [GOTOFF(ebx,PW_F085_MF072)]
+
+    paddd       xmm4, xmm5              ; xmm4=tmp0[col0 col1 **** col3]
+    paddd       xmm0, xmm2              ; xmm0=tmp0[col1 col3 col5 col7]
+
+    ; -- Even part
+
+    movdqa      xmm6, XMMWORD [XMMBLOCK(0,0,esi,SIZEOF_JCOEF)]
+    pmullw      xmm6, XMMWORD [XMMBLOCK(0,0,edx,SIZEOF_ISLOW_MULT_TYPE)]
+
+    ; xmm6=(00 01 ** 03 ** 05 ** 07)
+
+    movdqa      xmm1, xmm6              ; xmm1=(00 01 ** 03 ** 05 ** 07)
+    pslld       xmm6, WORD_BIT          ; xmm6=(-- 00 -- ** -- ** -- **)
+    pand        xmm1, xmm7              ; xmm1=(-- 01 -- 03 -- 05 -- 07)
+    psrad       xmm6, (WORD_BIT-CONST_BITS-2)  ; xmm6=tmp10[col0 **** **** ****]
+    psrad       xmm1, (WORD_BIT-CONST_BITS-2)  ; xmm1=tmp10[col1 col3 col5 col7]
+
+    ; -- Final output stage
+
+    movdqa      xmm3, xmm6
+    movdqa      xmm5, xmm1
+    paddd       xmm6, xmm4      ; xmm6=data0[col0 **** **** ****]=(A0 ** ** **)
+    paddd       xmm1, xmm0      ; xmm1=data0[col1 col3 col5 col7]=(A1 A3 A5 A7)
+    psubd       xmm3, xmm4      ; xmm3=data1[col0 **** **** ****]=(B0 ** ** **)
+    psubd       xmm5, xmm0      ; xmm5=data1[col1 col3 col5 col7]=(B1 B3 B5 B7)
+
+    movdqa      xmm2, [GOTOFF(ebx,PD_DESCALE_P1_2)]  ; xmm2=[PD_DESCALE_P1_2]
+
+    punpckldq   xmm6, xmm3              ; xmm6=(A0 B0 ** **)
+
+    movdqa      xmm7, xmm1
+    punpcklqdq  xmm1, xmm5              ; xmm1=(A1 A3 B1 B3)
+    punpckhqdq  xmm7, xmm5              ; xmm7=(A5 A7 B5 B7)
+
+    paddd       xmm6, xmm2
+    psrad       xmm6, DESCALE_P1_2
+
+    paddd       xmm1, xmm2
+    paddd       xmm7, xmm2
+    psrad       xmm1, DESCALE_P1_2
+    psrad       xmm7, DESCALE_P1_2
+
+    ; -- Prefetch the next coefficient block
+
+    prefetchnta [esi + DCTSIZE2*SIZEOF_JCOEF + 0*32]
+    prefetchnta [esi + DCTSIZE2*SIZEOF_JCOEF + 1*32]
+    prefetchnta [esi + DCTSIZE2*SIZEOF_JCOEF + 2*32]
+    prefetchnta [esi + DCTSIZE2*SIZEOF_JCOEF + 3*32]
+
+    ; ---- Pass 2: process rows, store into output array.
+
+    mov         edi, JSAMPARRAY [output_buf(ebp)]  ; (JSAMPROW *)
+    mov         eax, JDIMENSION [output_col(ebp)]
+
+    ; | input:| result:|
+    ; | A0 B0 |        |
+    ; | A1 B1 | C0 C1  |
+    ; | A3 B3 | D0 D1  |
+    ; | A5 B5 |        |
+    ; | A7 B7 |        |
+
+    ; -- Odd part
+
+    packssdw    xmm1, xmm1              ; xmm1=(A1 A3 B1 B3 A1 A3 B1 B3)
+    packssdw    xmm7, xmm7              ; xmm7=(A5 A7 B5 B7 A5 A7 B5 B7)
+    pmaddwd     xmm1, [GOTOFF(ebx,PW_F362_MF127)]
+    pmaddwd     xmm7, [GOTOFF(ebx,PW_F085_MF072)]
+
+    paddd       xmm1, xmm7              ; xmm1=tmp0[row0 row1 row0 row1]
+
+    ; -- Even part
+
+    pslld       xmm6, (CONST_BITS+2)    ; xmm6=tmp10[row0 row1 **** ****]
+
+    ; -- Final output stage
+
+    movdqa      xmm4, xmm6
+    paddd       xmm6, xmm1     ; xmm6=data0[row0 row1 **** ****]=(C0 C1 ** **)
+    psubd       xmm4, xmm1     ; xmm4=data1[row0 row1 **** ****]=(D0 D1 ** **)
+
+    punpckldq   xmm6, xmm4     ; xmm6=(C0 D0 C1 D1)
+
+    paddd       xmm6, [GOTOFF(ebx,PD_DESCALE_P2_2)]
+    psrad       xmm6, DESCALE_P2_2
+
+    packssdw    xmm6, xmm6              ; xmm6=(C0 D0 C1 D1 C0 D0 C1 D1)
+    packsswb    xmm6, xmm6              ; xmm6=(C0 D0 C1 D1 C0 D0 C1 D1 ..)
+    paddb       xmm6, [GOTOFF(ebx,PB_CENTERJSAMP)]
+
+    pextrw      ebx, xmm6, 0x00         ; ebx=(C0 D0 -- --)
+    pextrw      ecx, xmm6, 0x01         ; ecx=(C1 D1 -- --)
+
+    mov         edx, JSAMPROW [edi+0*SIZEOF_JSAMPROW]
+    mov         esi, JSAMPROW [edi+1*SIZEOF_JSAMPROW]
+    mov         word [edx+eax*SIZEOF_JSAMPLE], bx
+    mov         word [esi+eax*SIZEOF_JSAMPLE], cx
+
+    pop         edi
+    pop         esi
+;   pop         edx                     ; need not be preserved
+;   pop         ecx                     ; need not be preserved
+    pop         ebx
+    pop         ebp
+    ret
+
+; For some reason, the OS X linker does not honor the request to align the
+; segment unless we do this.
+    align       32
diff --git a/3rdparty/libjpeg/src/simd/i386/jquant-3dn.asm b/3rdparty/libjpeg/src/simd/i386/jquant-3dn.asm
new file mode 100644
index 00000000..5cb60caa
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/i386/jquant-3dn.asm
@@ -0,0 +1,230 @@
+;
+; jquant.asm - sample data conversion and quantization (3DNow! & MMX)
+;
+; Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+; Copyright (C) 2016, D. R. Commander.
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+;
+; This file should be assembled with NASM (Netwide Assembler),
+; can *not* be assembled with Microsoft's MASM or any compatible
+; assembler (including Borland's Turbo Assembler).
+; NASM is available from http://nasm.sourceforge.net/ or
+; http://sourceforge.net/project/showfiles.php?group_id=6208
+
+%include "jsimdext.inc"
+%include "jdct.inc"
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_TEXT
+    BITS        32
+;
+; Load data into workspace, applying unsigned->signed conversion
+;
+; GLOBAL(void)
+; jsimd_convsamp_float_3dnow(JSAMPARRAY sample_data, JDIMENSION start_col,
+;                            FAST_FLOAT *workspace);
+;
+
+%define sample_data  ebp + 8            ; JSAMPARRAY sample_data
+%define start_col    ebp + 12           ; JDIMENSION start_col
+%define workspace    ebp + 16           ; FAST_FLOAT *workspace
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_convsamp_float_3dnow)
+
+EXTN(jsimd_convsamp_float_3dnow):
+    push        ebp
+    mov         ebp, esp
+    push        ebx
+;   push        ecx                     ; need not be preserved
+;   push        edx                     ; need not be preserved
+    push        esi
+    push        edi
+
+    pcmpeqw     mm7, mm7
+    psllw       mm7, 7
+    packsswb    mm7, mm7                ; mm7 = PB_CENTERJSAMPLE (0x808080..)
+
+    mov         esi, JSAMPARRAY [sample_data]  ; (JSAMPROW *)
+    mov         eax, JDIMENSION [start_col]
+    mov         edi, POINTER [workspace]       ; (DCTELEM *)
+    mov         ecx, DCTSIZE/2
+    alignx      16, 7
+.convloop:
+    mov         ebx, JSAMPROW [esi+0*SIZEOF_JSAMPROW]  ; (JSAMPLE *)
+    mov         edx, JSAMPROW [esi+1*SIZEOF_JSAMPROW]  ; (JSAMPLE *)
+
+    movq        mm0, MMWORD [ebx+eax*SIZEOF_JSAMPLE]
+    movq        mm1, MMWORD [edx+eax*SIZEOF_JSAMPLE]
+
+    psubb       mm0, mm7                ; mm0=(01234567)
+    psubb       mm1, mm7                ; mm1=(89ABCDEF)
+
+    punpcklbw   mm2, mm0                ; mm2=(*0*1*2*3)
+    punpckhbw   mm0, mm0                ; mm0=(*4*5*6*7)
+    punpcklbw   mm3, mm1                ; mm3=(*8*9*A*B)
+    punpckhbw   mm1, mm1                ; mm1=(*C*D*E*F)
+
+    punpcklwd   mm4, mm2                ; mm4=(***0***1)
+    punpckhwd   mm2, mm2                ; mm2=(***2***3)
+    punpcklwd   mm5, mm0                ; mm5=(***4***5)
+    punpckhwd   mm0, mm0                ; mm0=(***6***7)
+
+    psrad       mm4, (DWORD_BIT-BYTE_BIT)  ; mm4=(01)
+    psrad       mm2, (DWORD_BIT-BYTE_BIT)  ; mm2=(23)
+    pi2fd       mm4, mm4
+    pi2fd       mm2, mm2
+    psrad       mm5, (DWORD_BIT-BYTE_BIT)  ; mm5=(45)
+    psrad       mm0, (DWORD_BIT-BYTE_BIT)  ; mm0=(67)
+    pi2fd       mm5, mm5
+    pi2fd       mm0, mm0
+
+    movq        MMWORD [MMBLOCK(0,0,edi,SIZEOF_FAST_FLOAT)], mm4
+    movq        MMWORD [MMBLOCK(0,1,edi,SIZEOF_FAST_FLOAT)], mm2
+    movq        MMWORD [MMBLOCK(0,2,edi,SIZEOF_FAST_FLOAT)], mm5
+    movq        MMWORD [MMBLOCK(0,3,edi,SIZEOF_FAST_FLOAT)], mm0
+
+    punpcklwd   mm6, mm3                ; mm6=(***8***9)
+    punpckhwd   mm3, mm3                ; mm3=(***A***B)
+    punpcklwd   mm4, mm1                ; mm4=(***C***D)
+    punpckhwd   mm1, mm1                ; mm1=(***E***F)
+
+    psrad       mm6, (DWORD_BIT-BYTE_BIT)  ; mm6=(89)
+    psrad       mm3, (DWORD_BIT-BYTE_BIT)  ; mm3=(AB)
+    pi2fd       mm6, mm6
+    pi2fd       mm3, mm3
+    psrad       mm4, (DWORD_BIT-BYTE_BIT)  ; mm4=(CD)
+    psrad       mm1, (DWORD_BIT-BYTE_BIT)  ; mm1=(EF)
+    pi2fd       mm4, mm4
+    pi2fd       mm1, mm1
+
+    movq        MMWORD [MMBLOCK(1,0,edi,SIZEOF_FAST_FLOAT)], mm6
+    movq        MMWORD [MMBLOCK(1,1,edi,SIZEOF_FAST_FLOAT)], mm3
+    movq        MMWORD [MMBLOCK(1,2,edi,SIZEOF_FAST_FLOAT)], mm4
+    movq        MMWORD [MMBLOCK(1,3,edi,SIZEOF_FAST_FLOAT)], mm1
+
+    add         esi, byte 2*SIZEOF_JSAMPROW
+    add         edi, byte 2*DCTSIZE*SIZEOF_FAST_FLOAT
+    dec         ecx
+    jnz         near .convloop
+
+    femms                               ; empty MMX/3DNow! state
+
+    pop         edi
+    pop         esi
+;   pop         edx                     ; need not be preserved
+;   pop         ecx                     ; need not be preserved
+    pop         ebx
+    pop         ebp
+    ret
+
+; --------------------------------------------------------------------------
+;
+; Quantize/descale the coefficients, and store into coef_block
+;
+; GLOBAL(void)
+; jsimd_quantize_float_3dnow(JCOEFPTR coef_block, FAST_FLOAT *divisors,
+;                            FAST_FLOAT *workspace);
+;
+
+%define coef_block  ebp + 8             ; JCOEFPTR coef_block
+%define divisors    ebp + 12            ; FAST_FLOAT *divisors
+%define workspace   ebp + 16            ; FAST_FLOAT *workspace
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_quantize_float_3dnow)
+
+EXTN(jsimd_quantize_float_3dnow):
+    push        ebp
+    mov         ebp, esp
+;   push        ebx                     ; unused
+;   push        ecx                     ; unused
+;   push        edx                     ; need not be preserved
+    push        esi
+    push        edi
+
+    mov         eax, 0x4B400000         ; (float)0x00C00000 (rndint_magic)
+    movd        mm7, eax
+    punpckldq   mm7, mm7                ; mm7={12582912.0F 12582912.0F}
+
+    mov         esi, POINTER [workspace]
+    mov         edx, POINTER [divisors]
+    mov         edi, JCOEFPTR [coef_block]
+    mov         eax, DCTSIZE2/16
+    alignx      16, 7
+.quantloop:
+    movq        mm0, MMWORD [MMBLOCK(0,0,esi,SIZEOF_FAST_FLOAT)]
+    movq        mm1, MMWORD [MMBLOCK(0,1,esi,SIZEOF_FAST_FLOAT)]
+    pfmul       mm0, MMWORD [MMBLOCK(0,0,edx,SIZEOF_FAST_FLOAT)]
+    pfmul       mm1, MMWORD [MMBLOCK(0,1,edx,SIZEOF_FAST_FLOAT)]
+    movq        mm2, MMWORD [MMBLOCK(0,2,esi,SIZEOF_FAST_FLOAT)]
+    movq        mm3, MMWORD [MMBLOCK(0,3,esi,SIZEOF_FAST_FLOAT)]
+    pfmul       mm2, MMWORD [MMBLOCK(0,2,edx,SIZEOF_FAST_FLOAT)]
+    pfmul       mm3, MMWORD [MMBLOCK(0,3,edx,SIZEOF_FAST_FLOAT)]
+
+    pfadd       mm0, mm7                ; mm0=(00 ** 01 **)
+    pfadd       mm1, mm7                ; mm1=(02 ** 03 **)
+    pfadd       mm2, mm7                ; mm0=(04 ** 05 **)
+    pfadd       mm3, mm7                ; mm1=(06 ** 07 **)
+
+    movq        mm4, mm0
+    punpcklwd   mm0, mm1                ; mm0=(00 02 ** **)
+    punpckhwd   mm4, mm1                ; mm4=(01 03 ** **)
+    movq        mm5, mm2
+    punpcklwd   mm2, mm3                ; mm2=(04 06 ** **)
+    punpckhwd   mm5, mm3                ; mm5=(05 07 ** **)
+
+    punpcklwd   mm0, mm4                ; mm0=(00 01 02 03)
+    punpcklwd   mm2, mm5                ; mm2=(04 05 06 07)
+
+    movq        mm6, MMWORD [MMBLOCK(1,0,esi,SIZEOF_FAST_FLOAT)]
+    movq        mm1, MMWORD [MMBLOCK(1,1,esi,SIZEOF_FAST_FLOAT)]
+    pfmul       mm6, MMWORD [MMBLOCK(1,0,edx,SIZEOF_FAST_FLOAT)]
+    pfmul       mm1, MMWORD [MMBLOCK(1,1,edx,SIZEOF_FAST_FLOAT)]
+    movq        mm3, MMWORD [MMBLOCK(1,2,esi,SIZEOF_FAST_FLOAT)]
+    movq        mm4, MMWORD [MMBLOCK(1,3,esi,SIZEOF_FAST_FLOAT)]
+    pfmul       mm3, MMWORD [MMBLOCK(1,2,edx,SIZEOF_FAST_FLOAT)]
+    pfmul       mm4, MMWORD [MMBLOCK(1,3,edx,SIZEOF_FAST_FLOAT)]
+
+    pfadd       mm6, mm7                ; mm0=(10 ** 11 **)
+    pfadd       mm1, mm7                ; mm4=(12 ** 13 **)
+    pfadd       mm3, mm7                ; mm0=(14 ** 15 **)
+    pfadd       mm4, mm7                ; mm4=(16 ** 17 **)
+
+    movq        mm5, mm6
+    punpcklwd   mm6, mm1                ; mm6=(10 12 ** **)
+    punpckhwd   mm5, mm1                ; mm5=(11 13 ** **)
+    movq        mm1, mm3
+    punpcklwd   mm3, mm4                ; mm3=(14 16 ** **)
+    punpckhwd   mm1, mm4                ; mm1=(15 17 ** **)
+
+    punpcklwd   mm6, mm5                ; mm6=(10 11 12 13)
+    punpcklwd   mm3, mm1                ; mm3=(14 15 16 17)
+
+    movq        MMWORD [MMBLOCK(0,0,edi,SIZEOF_JCOEF)], mm0
+    movq        MMWORD [MMBLOCK(0,1,edi,SIZEOF_JCOEF)], mm2
+    movq        MMWORD [MMBLOCK(1,0,edi,SIZEOF_JCOEF)], mm6
+    movq        MMWORD [MMBLOCK(1,1,edi,SIZEOF_JCOEF)], mm3
+
+    add         esi, byte 16*SIZEOF_FAST_FLOAT
+    add         edx, byte 16*SIZEOF_FAST_FLOAT
+    add         edi, byte 16*SIZEOF_JCOEF
+    dec         eax
+    jnz         near .quantloop
+
+    femms                               ; empty MMX/3DNow! state
+
+    pop         edi
+    pop         esi
+;   pop         edx                     ; need not be preserved
+;   pop         ecx                     ; unused
+;   pop         ebx                     ; unused
+    pop         ebp
+    ret
+
+; For some reason, the OS X linker does not honor the request to align the
+; segment unless we do this.
+    align       32
diff --git a/3rdparty/libjpeg/src/simd/i386/jquant-mmx.asm b/3rdparty/libjpeg/src/simd/i386/jquant-mmx.asm
new file mode 100644
index 00000000..61305c62
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/i386/jquant-mmx.asm
@@ -0,0 +1,276 @@
+;
+; jquant.asm - sample data conversion and quantization (MMX)
+;
+; Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+; Copyright (C) 2016, D. R. Commander.
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+;
+; This file should be assembled with NASM (Netwide Assembler),
+; can *not* be assembled with Microsoft's MASM or any compatible
+; assembler (including Borland's Turbo Assembler).
+; NASM is available from http://nasm.sourceforge.net/ or
+; http://sourceforge.net/project/showfiles.php?group_id=6208
+
+%include "jsimdext.inc"
+%include "jdct.inc"
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_TEXT
+    BITS        32
+;
+; Load data into workspace, applying unsigned->signed conversion
+;
+; GLOBAL(void)
+; jsimd_convsamp_mmx(JSAMPARRAY sample_data, JDIMENSION start_col,
+;                    DCTELEM *workspace);
+;
+
+%define sample_data  ebp + 8            ; JSAMPARRAY sample_data
+%define start_col    ebp + 12           ; JDIMENSION start_col
+%define workspace    ebp + 16           ; DCTELEM *workspace
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_convsamp_mmx)
+
+EXTN(jsimd_convsamp_mmx):
+    push        ebp
+    mov         ebp, esp
+    push        ebx
+;   push        ecx                     ; need not be preserved
+;   push        edx                     ; need not be preserved
+    push        esi
+    push        edi
+
+    pxor        mm6, mm6                ; mm6=(all 0's)
+    pcmpeqw     mm7, mm7
+    psllw       mm7, 7                  ; mm7={0xFF80 0xFF80 0xFF80 0xFF80}
+
+    mov         esi, JSAMPARRAY [sample_data]  ; (JSAMPROW *)
+    mov         eax, JDIMENSION [start_col]
+    mov         edi, POINTER [workspace]       ; (DCTELEM *)
+    mov         ecx, DCTSIZE/4
+    alignx      16, 7
+.convloop:
+    mov         ebx, JSAMPROW [esi+0*SIZEOF_JSAMPROW]  ; (JSAMPLE *)
+    mov         edx, JSAMPROW [esi+1*SIZEOF_JSAMPROW]  ; (JSAMPLE *)
+
+    movq        mm0, MMWORD [ebx+eax*SIZEOF_JSAMPLE]   ; mm0=(01234567)
+    movq        mm1, MMWORD [edx+eax*SIZEOF_JSAMPLE]   ; mm1=(89ABCDEF)
+
+    mov         ebx, JSAMPROW [esi+2*SIZEOF_JSAMPROW]  ; (JSAMPLE *)
+    mov         edx, JSAMPROW [esi+3*SIZEOF_JSAMPROW]  ; (JSAMPLE *)
+
+    movq        mm2, MMWORD [ebx+eax*SIZEOF_JSAMPLE]   ; mm2=(GHIJKLMN)
+    movq        mm3, MMWORD [edx+eax*SIZEOF_JSAMPLE]   ; mm3=(OPQRSTUV)
+
+    movq        mm4, mm0
+    punpcklbw   mm0, mm6                ; mm0=(0123)
+    punpckhbw   mm4, mm6                ; mm4=(4567)
+    movq        mm5, mm1
+    punpcklbw   mm1, mm6                ; mm1=(89AB)
+    punpckhbw   mm5, mm6                ; mm5=(CDEF)
+
+    paddw       mm0, mm7
+    paddw       mm4, mm7
+    paddw       mm1, mm7
+    paddw       mm5, mm7
+
+    movq        MMWORD [MMBLOCK(0,0,edi,SIZEOF_DCTELEM)], mm0
+    movq        MMWORD [MMBLOCK(0,1,edi,SIZEOF_DCTELEM)], mm4
+    movq        MMWORD [MMBLOCK(1,0,edi,SIZEOF_DCTELEM)], mm1
+    movq        MMWORD [MMBLOCK(1,1,edi,SIZEOF_DCTELEM)], mm5
+
+    movq        mm0, mm2
+    punpcklbw   mm2, mm6                ; mm2=(GHIJ)
+    punpckhbw   mm0, mm6                ; mm0=(KLMN)
+    movq        mm4, mm3
+    punpcklbw   mm3, mm6                ; mm3=(OPQR)
+    punpckhbw   mm4, mm6                ; mm4=(STUV)
+
+    paddw       mm2, mm7
+    paddw       mm0, mm7
+    paddw       mm3, mm7
+    paddw       mm4, mm7
+
+    movq        MMWORD [MMBLOCK(2,0,edi,SIZEOF_DCTELEM)], mm2
+    movq        MMWORD [MMBLOCK(2,1,edi,SIZEOF_DCTELEM)], mm0
+    movq        MMWORD [MMBLOCK(3,0,edi,SIZEOF_DCTELEM)], mm3
+    movq        MMWORD [MMBLOCK(3,1,edi,SIZEOF_DCTELEM)], mm4
+
+    add         esi, byte 4*SIZEOF_JSAMPROW
+    add         edi, byte 4*DCTSIZE*SIZEOF_DCTELEM
+    dec         ecx
+    jnz         short .convloop
+
+    emms                                ; empty MMX state
+
+    pop         edi
+    pop         esi
+;   pop         edx                     ; need not be preserved
+;   pop         ecx                     ; need not be preserved
+    pop         ebx
+    pop         ebp
+    ret
+
+; --------------------------------------------------------------------------
+;
+; Quantize/descale the coefficients, and store into coef_block
+;
+; This implementation is based on an algorithm described in
+;   "How to optimize for the Pentium family of microprocessors"
+;   (http://www.agner.org/assem/).
+;
+; GLOBAL(void)
+; jsimd_quantize_mmx(JCOEFPTR coef_block, DCTELEM *divisors,
+;                    DCTELEM *workspace);
+;
+
+%define RECIPROCAL(m, n, b) \
+  MMBLOCK(DCTSIZE * 0 + (m), (n), (b), SIZEOF_DCTELEM)
+%define CORRECTION(m, n, b) \
+  MMBLOCK(DCTSIZE * 1 + (m), (n), (b), SIZEOF_DCTELEM)
+%define SCALE(m, n, b) \
+  MMBLOCK(DCTSIZE * 2 + (m), (n), (b), SIZEOF_DCTELEM)
+%define SHIFT(m, n, b) \
+  MMBLOCK(DCTSIZE * 3 + (m), (n), (b), SIZEOF_DCTELEM)
+
+%define coef_block  ebp + 8             ; JCOEFPTR coef_block
+%define divisors    ebp + 12            ; DCTELEM *divisors
+%define workspace   ebp + 16            ; DCTELEM *workspace
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_quantize_mmx)
+
+EXTN(jsimd_quantize_mmx):
+    push        ebp
+    mov         ebp, esp
+;   push        ebx                     ; unused
+;   push        ecx                     ; unused
+;   push        edx                     ; need not be preserved
+    push        esi
+    push        edi
+
+    mov         esi, POINTER [workspace]
+    mov         edx, POINTER [divisors]
+    mov         edi, JCOEFPTR [coef_block]
+    mov         ah, 2
+    alignx      16, 7
+.quantloop1:
+    mov         al, DCTSIZE2/8/2
+    alignx      16, 7
+.quantloop2:
+    movq        mm2, MMWORD [MMBLOCK(0,0,esi,SIZEOF_DCTELEM)]
+    movq        mm3, MMWORD [MMBLOCK(0,1,esi,SIZEOF_DCTELEM)]
+
+    movq        mm0, mm2
+    movq        mm1, mm3
+
+    psraw       mm2, (WORD_BIT-1)       ; -1 if value < 0, 0 otherwise
+    psraw       mm3, (WORD_BIT-1)
+
+    pxor        mm0, mm2                ; val = -val
+    pxor        mm1, mm3
+    psubw       mm0, mm2
+    psubw       mm1, mm3
+
+    ;
+    ; MMX is an annoyingly crappy instruction set. It has two
+    ; misfeatures that are causing problems here:
+    ;
+    ; - All multiplications are signed.
+    ;
+    ; - The second operand for the shifts is not treated as packed.
+    ;
+    ;
+    ; We work around the first problem by implementing this algorithm:
+    ;
+    ; unsigned long unsigned_multiply(unsigned short x, unsigned short y)
+    ; {
+    ;   enum { SHORT_BIT = 16 };
+    ;   signed short sx = (signed short)x;
+    ;   signed short sy = (signed short)y;
+    ;   signed long sz;
+    ;
+    ;   sz = (long)sx * (long)sy;    /* signed multiply */
+    ;
+    ;   if (sx < 0) sz += (long)sy << SHORT_BIT;
+    ;   if (sy < 0) sz += (long)sx << SHORT_BIT;
+    ;
+    ;   return (unsigned long)sz;
+    ; }
+    ;
+    ; (note that a negative sx adds _sy_ and vice versa)
+    ;
+    ; For the second problem, we replace the shift by a multiplication.
+    ; Unfortunately that means we have to deal with the signed issue again.
+    ;
+
+    paddw       mm0, MMWORD [CORRECTION(0,0,edx)]  ; correction + roundfactor
+    paddw       mm1, MMWORD [CORRECTION(0,1,edx)]
+
+    movq        mm4, mm0                ; store current value for later
+    movq        mm5, mm1
+    pmulhw      mm0, MMWORD [RECIPROCAL(0,0,edx)]  ; reciprocal
+    pmulhw      mm1, MMWORD [RECIPROCAL(0,1,edx)]
+    paddw       mm0, mm4  ; reciprocal is always negative (MSB=1),
+    paddw       mm1, mm5  ; so we always need to add the initial value
+                          ; (input value is never negative as we
+                          ; inverted it at the start of this routine)
+
+    ; here it gets a bit tricky as both scale
+    ; and mm0/mm1 can be negative
+    movq        mm6, MMWORD [SCALE(0,0,edx)]  ; scale
+    movq        mm7, MMWORD [SCALE(0,1,edx)]
+    movq        mm4, mm0
+    movq        mm5, mm1
+    pmulhw      mm0, mm6
+    pmulhw      mm1, mm7
+
+    psraw       mm6, (WORD_BIT-1)       ; determine if scale is negative
+    psraw       mm7, (WORD_BIT-1)
+
+    pand        mm6, mm4                ; and add input if it is
+    pand        mm7, mm5
+    paddw       mm0, mm6
+    paddw       mm1, mm7
+
+    psraw       mm4, (WORD_BIT-1)       ; then check if negative input
+    psraw       mm5, (WORD_BIT-1)
+
+    pand        mm4, MMWORD [SCALE(0,0,edx)]  ; and add scale if it is
+    pand        mm5, MMWORD [SCALE(0,1,edx)]
+    paddw       mm0, mm4
+    paddw       mm1, mm5
+
+    pxor        mm0, mm2                ; val = -val
+    pxor        mm1, mm3
+    psubw       mm0, mm2
+    psubw       mm1, mm3
+
+    movq        MMWORD [MMBLOCK(0,0,edi,SIZEOF_DCTELEM)], mm0
+    movq        MMWORD [MMBLOCK(0,1,edi,SIZEOF_DCTELEM)], mm1
+
+    add         esi, byte 8*SIZEOF_DCTELEM
+    add         edx, byte 8*SIZEOF_DCTELEM
+    add         edi, byte 8*SIZEOF_JCOEF
+    dec         al
+    jnz         near .quantloop2
+    dec         ah
+    jnz         near .quantloop1        ; to avoid branch misprediction
+
+    emms                                ; empty MMX state
+
+    pop         edi
+    pop         esi
+;   pop         edx                     ; need not be preserved
+;   pop         ecx                     ; unused
+;   pop         ebx                     ; unused
+    pop         ebp
+    ret
+
+; For some reason, the OS X linker does not honor the request to align the
+; segment unless we do this.
+    align       32
diff --git a/3rdparty/libjpeg/src/simd/i386/jquant-sse.asm b/3rdparty/libjpeg/src/simd/i386/jquant-sse.asm
new file mode 100644
index 00000000..218adc97
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/i386/jquant-sse.asm
@@ -0,0 +1,208 @@
+;
+; jquant.asm - sample data conversion and quantization (SSE & MMX)
+;
+; Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+; Copyright (C) 2016, D. R. Commander.
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+;
+; This file should be assembled with NASM (Netwide Assembler),
+; can *not* be assembled with Microsoft's MASM or any compatible
+; assembler (including Borland's Turbo Assembler).
+; NASM is available from http://nasm.sourceforge.net/ or
+; http://sourceforge.net/project/showfiles.php?group_id=6208
+
+%include "jsimdext.inc"
+%include "jdct.inc"
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_TEXT
+    BITS        32
+;
+; Load data into workspace, applying unsigned->signed conversion
+;
+; GLOBAL(void)
+; jsimd_convsamp_float_sse(JSAMPARRAY sample_data, JDIMENSION start_col,
+;                          FAST_FLOAT *workspace);
+;
+
+%define sample_data  ebp + 8            ; JSAMPARRAY sample_data
+%define start_col    ebp + 12           ; JDIMENSION start_col
+%define workspace    ebp + 16           ; FAST_FLOAT *workspace
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_convsamp_float_sse)
+
+EXTN(jsimd_convsamp_float_sse):
+    push        ebp
+    mov         ebp, esp
+    push        ebx
+;   push        ecx                     ; need not be preserved
+;   push        edx                     ; need not be preserved
+    push        esi
+    push        edi
+
+    pcmpeqw     mm7, mm7
+    psllw       mm7, 7
+    packsswb    mm7, mm7                ; mm7 = PB_CENTERJSAMPLE (0x808080..)
+
+    mov         esi, JSAMPARRAY [sample_data]  ; (JSAMPROW *)
+    mov         eax, JDIMENSION [start_col]
+    mov         edi, POINTER [workspace]       ; (DCTELEM *)
+    mov         ecx, DCTSIZE/2
+    alignx      16, 7
+.convloop:
+    mov         ebx, JSAMPROW [esi+0*SIZEOF_JSAMPROW]  ; (JSAMPLE *)
+    mov         edx, JSAMPROW [esi+1*SIZEOF_JSAMPROW]  ; (JSAMPLE *)
+
+    movq        mm0, MMWORD [ebx+eax*SIZEOF_JSAMPLE]
+    movq        mm1, MMWORD [edx+eax*SIZEOF_JSAMPLE]
+
+    psubb       mm0, mm7                ; mm0=(01234567)
+    psubb       mm1, mm7                ; mm1=(89ABCDEF)
+
+    punpcklbw   mm2, mm0                ; mm2=(*0*1*2*3)
+    punpckhbw   mm0, mm0                ; mm0=(*4*5*6*7)
+    punpcklbw   mm3, mm1                ; mm3=(*8*9*A*B)
+    punpckhbw   mm1, mm1                ; mm1=(*C*D*E*F)
+
+    punpcklwd   mm4, mm2                ; mm4=(***0***1)
+    punpckhwd   mm2, mm2                ; mm2=(***2***3)
+    punpcklwd   mm5, mm0                ; mm5=(***4***5)
+    punpckhwd   mm0, mm0                ; mm0=(***6***7)
+
+    psrad       mm4, (DWORD_BIT-BYTE_BIT)  ; mm4=(01)
+    psrad       mm2, (DWORD_BIT-BYTE_BIT)  ; mm2=(23)
+    cvtpi2ps    xmm0, mm4                  ; xmm0=(01**)
+    cvtpi2ps    xmm1, mm2                  ; xmm1=(23**)
+    psrad       mm5, (DWORD_BIT-BYTE_BIT)  ; mm5=(45)
+    psrad       mm0, (DWORD_BIT-BYTE_BIT)  ; mm0=(67)
+    cvtpi2ps    xmm2, mm5                  ; xmm2=(45**)
+    cvtpi2ps    xmm3, mm0                  ; xmm3=(67**)
+
+    punpcklwd   mm6, mm3                ; mm6=(***8***9)
+    punpckhwd   mm3, mm3                ; mm3=(***A***B)
+    punpcklwd   mm4, mm1                ; mm4=(***C***D)
+    punpckhwd   mm1, mm1                ; mm1=(***E***F)
+
+    psrad       mm6, (DWORD_BIT-BYTE_BIT)  ; mm6=(89)
+    psrad       mm3, (DWORD_BIT-BYTE_BIT)  ; mm3=(AB)
+    cvtpi2ps    xmm4, mm6                  ; xmm4=(89**)
+    cvtpi2ps    xmm5, mm3                  ; xmm5=(AB**)
+    psrad       mm4, (DWORD_BIT-BYTE_BIT)  ; mm4=(CD)
+    psrad       mm1, (DWORD_BIT-BYTE_BIT)  ; mm1=(EF)
+    cvtpi2ps    xmm6, mm4                  ; xmm6=(CD**)
+    cvtpi2ps    xmm7, mm1                  ; xmm7=(EF**)
+
+    movlhps     xmm0, xmm1              ; xmm0=(0123)
+    movlhps     xmm2, xmm3              ; xmm2=(4567)
+    movlhps     xmm4, xmm5              ; xmm4=(89AB)
+    movlhps     xmm6, xmm7              ; xmm6=(CDEF)
+
+    movaps      XMMWORD [XMMBLOCK(0,0,edi,SIZEOF_FAST_FLOAT)], xmm0
+    movaps      XMMWORD [XMMBLOCK(0,1,edi,SIZEOF_FAST_FLOAT)], xmm2
+    movaps      XMMWORD [XMMBLOCK(1,0,edi,SIZEOF_FAST_FLOAT)], xmm4
+    movaps      XMMWORD [XMMBLOCK(1,1,edi,SIZEOF_FAST_FLOAT)], xmm6
+
+    add         esi, byte 2*SIZEOF_JSAMPROW
+    add         edi, byte 2*DCTSIZE*SIZEOF_FAST_FLOAT
+    dec         ecx
+    jnz         near .convloop
+
+    emms                                ; empty MMX state
+
+    pop         edi
+    pop         esi
+;   pop         edx                     ; need not be preserved
+;   pop         ecx                     ; need not be preserved
+    pop         ebx
+    pop         ebp
+    ret
+
+; --------------------------------------------------------------------------
+;
+; Quantize/descale the coefficients, and store into coef_block
+;
+; GLOBAL(void)
+; jsimd_quantize_float_sse(JCOEFPTR coef_block, FAST_FLOAT *divisors,
+;                          FAST_FLOAT *workspace);
+;
+
+%define coef_block  ebp + 8             ; JCOEFPTR coef_block
+%define divisors    ebp + 12            ; FAST_FLOAT *divisors
+%define workspace   ebp + 16            ; FAST_FLOAT *workspace
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_quantize_float_sse)
+
+EXTN(jsimd_quantize_float_sse):
+    push        ebp
+    mov         ebp, esp
+;   push        ebx                     ; unused
+;   push        ecx                     ; unused
+;   push        edx                     ; need not be preserved
+    push        esi
+    push        edi
+
+    mov         esi, POINTER [workspace]
+    mov         edx, POINTER [divisors]
+    mov         edi, JCOEFPTR [coef_block]
+    mov         eax, DCTSIZE2/16
+    alignx      16, 7
+.quantloop:
+    movaps      xmm0, XMMWORD [XMMBLOCK(0,0,esi,SIZEOF_FAST_FLOAT)]
+    movaps      xmm1, XMMWORD [XMMBLOCK(0,1,esi,SIZEOF_FAST_FLOAT)]
+    mulps       xmm0, XMMWORD [XMMBLOCK(0,0,edx,SIZEOF_FAST_FLOAT)]
+    mulps       xmm1, XMMWORD [XMMBLOCK(0,1,edx,SIZEOF_FAST_FLOAT)]
+    movaps      xmm2, XMMWORD [XMMBLOCK(1,0,esi,SIZEOF_FAST_FLOAT)]
+    movaps      xmm3, XMMWORD [XMMBLOCK(1,1,esi,SIZEOF_FAST_FLOAT)]
+    mulps       xmm2, XMMWORD [XMMBLOCK(1,0,edx,SIZEOF_FAST_FLOAT)]
+    mulps       xmm3, XMMWORD [XMMBLOCK(1,1,edx,SIZEOF_FAST_FLOAT)]
+
+    movhlps     xmm4, xmm0
+    movhlps     xmm5, xmm1
+
+    cvtps2pi    mm0, xmm0
+    cvtps2pi    mm1, xmm1
+    cvtps2pi    mm4, xmm4
+    cvtps2pi    mm5, xmm5
+
+    movhlps     xmm6, xmm2
+    movhlps     xmm7, xmm3
+
+    cvtps2pi    mm2, xmm2
+    cvtps2pi    mm3, xmm3
+    cvtps2pi    mm6, xmm6
+    cvtps2pi    mm7, xmm7
+
+    packssdw    mm0, mm4
+    packssdw    mm1, mm5
+    packssdw    mm2, mm6
+    packssdw    mm3, mm7
+
+    movq        MMWORD [MMBLOCK(0,0,edi,SIZEOF_JCOEF)], mm0
+    movq        MMWORD [MMBLOCK(0,1,edi,SIZEOF_JCOEF)], mm1
+    movq        MMWORD [MMBLOCK(1,0,edi,SIZEOF_JCOEF)], mm2
+    movq        MMWORD [MMBLOCK(1,1,edi,SIZEOF_JCOEF)], mm3
+
+    add         esi, byte 16*SIZEOF_FAST_FLOAT
+    add         edx, byte 16*SIZEOF_FAST_FLOAT
+    add         edi, byte 16*SIZEOF_JCOEF
+    dec         eax
+    jnz         short .quantloop
+
+    emms                                ; empty MMX state
+
+    pop         edi
+    pop         esi
+;   pop         edx                     ; need not be preserved
+;   pop         ecx                     ; unused
+;   pop         ebx                     ; unused
+    pop         ebp
+    ret
+
+; For some reason, the OS X linker does not honor the request to align the
+; segment unless we do this.
+    align       32
diff --git a/3rdparty/libjpeg/src/simd/i386/jquantf-sse2.asm b/3rdparty/libjpeg/src/simd/i386/jquantf-sse2.asm
new file mode 100644
index 00000000..a881ab50
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/i386/jquantf-sse2.asm
@@ -0,0 +1,168 @@
+;
+; jquantf.asm - sample data conversion and quantization (SSE & SSE2)
+;
+; Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+; Copyright (C) 2016, D. R. Commander.
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+;
+; This file should be assembled with NASM (Netwide Assembler),
+; can *not* be assembled with Microsoft's MASM or any compatible
+; assembler (including Borland's Turbo Assembler).
+; NASM is available from http://nasm.sourceforge.net/ or
+; http://sourceforge.net/project/showfiles.php?group_id=6208
+
+%include "jsimdext.inc"
+%include "jdct.inc"
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_TEXT
+    BITS        32
+;
+; Load data into workspace, applying unsigned->signed conversion
+;
+; GLOBAL(void)
+; jsimd_convsamp_float_sse2(JSAMPARRAY sample_data, JDIMENSION start_col,
+;                           FAST_FLOAT *workspace);
+;
+
+%define sample_data  ebp + 8            ; JSAMPARRAY sample_data
+%define start_col    ebp + 12           ; JDIMENSION start_col
+%define workspace    ebp + 16           ; FAST_FLOAT *workspace
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_convsamp_float_sse2)
+
+EXTN(jsimd_convsamp_float_sse2):
+    push        ebp
+    mov         ebp, esp
+    push        ebx
+;   push        ecx                     ; need not be preserved
+;   push        edx                     ; need not be preserved
+    push        esi
+    push        edi
+
+    pcmpeqw     xmm7, xmm7
+    psllw       xmm7, 7
+    packsswb    xmm7, xmm7              ; xmm7 = PB_CENTERJSAMPLE (0x808080..)
+
+    mov         esi, JSAMPARRAY [sample_data]  ; (JSAMPROW *)
+    mov         eax, JDIMENSION [start_col]
+    mov         edi, POINTER [workspace]       ; (DCTELEM *)
+    mov         ecx, DCTSIZE/2
+    alignx      16, 7
+.convloop:
+    mov         ebx, JSAMPROW [esi+0*SIZEOF_JSAMPROW]  ; (JSAMPLE *)
+    mov         edx, JSAMPROW [esi+1*SIZEOF_JSAMPROW]  ; (JSAMPLE *)
+
+    movq        xmm0, XMM_MMWORD [ebx+eax*SIZEOF_JSAMPLE]
+    movq        xmm1, XMM_MMWORD [edx+eax*SIZEOF_JSAMPLE]
+
+    psubb       xmm0, xmm7              ; xmm0=(01234567)
+    psubb       xmm1, xmm7              ; xmm1=(89ABCDEF)
+
+    punpcklbw   xmm0, xmm0              ; xmm0=(*0*1*2*3*4*5*6*7)
+    punpcklbw   xmm1, xmm1              ; xmm1=(*8*9*A*B*C*D*E*F)
+
+    punpcklwd   xmm2, xmm0              ; xmm2=(***0***1***2***3)
+    punpckhwd   xmm0, xmm0              ; xmm0=(***4***5***6***7)
+    punpcklwd   xmm3, xmm1              ; xmm3=(***8***9***A***B)
+    punpckhwd   xmm1, xmm1              ; xmm1=(***C***D***E***F)
+
+    psrad       xmm2, (DWORD_BIT-BYTE_BIT)  ; xmm2=(0123)
+    psrad       xmm0, (DWORD_BIT-BYTE_BIT)  ; xmm0=(4567)
+    cvtdq2ps    xmm2, xmm2                  ; xmm2=(0123)
+    cvtdq2ps    xmm0, xmm0                  ; xmm0=(4567)
+    psrad       xmm3, (DWORD_BIT-BYTE_BIT)  ; xmm3=(89AB)
+    psrad       xmm1, (DWORD_BIT-BYTE_BIT)  ; xmm1=(CDEF)
+    cvtdq2ps    xmm3, xmm3                  ; xmm3=(89AB)
+    cvtdq2ps    xmm1, xmm1                  ; xmm1=(CDEF)
+
+    movaps      XMMWORD [XMMBLOCK(0,0,edi,SIZEOF_FAST_FLOAT)], xmm2
+    movaps      XMMWORD [XMMBLOCK(0,1,edi,SIZEOF_FAST_FLOAT)], xmm0
+    movaps      XMMWORD [XMMBLOCK(1,0,edi,SIZEOF_FAST_FLOAT)], xmm3
+    movaps      XMMWORD [XMMBLOCK(1,1,edi,SIZEOF_FAST_FLOAT)], xmm1
+
+    add         esi, byte 2*SIZEOF_JSAMPROW
+    add         edi, byte 2*DCTSIZE*SIZEOF_FAST_FLOAT
+    dec         ecx
+    jnz         short .convloop
+
+    pop         edi
+    pop         esi
+;   pop         edx                     ; need not be preserved
+;   pop         ecx                     ; need not be preserved
+    pop         ebx
+    pop         ebp
+    ret
+
+; --------------------------------------------------------------------------
+;
+; Quantize/descale the coefficients, and store into coef_block
+;
+; GLOBAL(void)
+; jsimd_quantize_float_sse2(JCOEFPTR coef_block, FAST_FLOAT *divisors,
+;                           FAST_FLOAT *workspace);
+;
+
+%define coef_block  ebp + 8             ; JCOEFPTR coef_block
+%define divisors    ebp + 12            ; FAST_FLOAT *divisors
+%define workspace   ebp + 16            ; FAST_FLOAT *workspace
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_quantize_float_sse2)
+
+EXTN(jsimd_quantize_float_sse2):
+    push        ebp
+    mov         ebp, esp
+;   push        ebx                     ; unused
+;   push        ecx                     ; unused
+;   push        edx                     ; need not be preserved
+    push        esi
+    push        edi
+
+    mov         esi, POINTER [workspace]
+    mov         edx, POINTER [divisors]
+    mov         edi, JCOEFPTR [coef_block]
+    mov         eax, DCTSIZE2/16
+    alignx      16, 7
+.quantloop:
+    movaps      xmm0, XMMWORD [XMMBLOCK(0,0,esi,SIZEOF_FAST_FLOAT)]
+    movaps      xmm1, XMMWORD [XMMBLOCK(0,1,esi,SIZEOF_FAST_FLOAT)]
+    mulps       xmm0, XMMWORD [XMMBLOCK(0,0,edx,SIZEOF_FAST_FLOAT)]
+    mulps       xmm1, XMMWORD [XMMBLOCK(0,1,edx,SIZEOF_FAST_FLOAT)]
+    movaps      xmm2, XMMWORD [XMMBLOCK(1,0,esi,SIZEOF_FAST_FLOAT)]
+    movaps      xmm3, XMMWORD [XMMBLOCK(1,1,esi,SIZEOF_FAST_FLOAT)]
+    mulps       xmm2, XMMWORD [XMMBLOCK(1,0,edx,SIZEOF_FAST_FLOAT)]
+    mulps       xmm3, XMMWORD [XMMBLOCK(1,1,edx,SIZEOF_FAST_FLOAT)]
+
+    cvtps2dq    xmm0, xmm0
+    cvtps2dq    xmm1, xmm1
+    cvtps2dq    xmm2, xmm2
+    cvtps2dq    xmm3, xmm3
+
+    packssdw    xmm0, xmm1
+    packssdw    xmm2, xmm3
+
+    movdqa      XMMWORD [XMMBLOCK(0,0,edi,SIZEOF_JCOEF)], xmm0
+    movdqa      XMMWORD [XMMBLOCK(1,0,edi,SIZEOF_JCOEF)], xmm2
+
+    add         esi, byte 16*SIZEOF_FAST_FLOAT
+    add         edx, byte 16*SIZEOF_FAST_FLOAT
+    add         edi, byte 16*SIZEOF_JCOEF
+    dec         eax
+    jnz         short .quantloop
+
+    pop         edi
+    pop         esi
+;   pop         edx                     ; need not be preserved
+;   pop         ecx                     ; unused
+;   pop         ebx                     ; unused
+    pop         ebp
+    ret
+
+; For some reason, the OS X linker does not honor the request to align the
+; segment unless we do this.
+    align       32
diff --git a/3rdparty/libjpeg/src/simd/i386/jquanti-avx2.asm b/3rdparty/libjpeg/src/simd/i386/jquanti-avx2.asm
new file mode 100644
index 00000000..5ed6bec2
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/i386/jquanti-avx2.asm
@@ -0,0 +1,188 @@
+;
+; jquanti.asm - sample data conversion and quantization (AVX2)
+;
+; Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+; Copyright (C) 2016, 2018, D. R. Commander.
+; Copyright (C) 2016, Matthieu Darbois.
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+;
+; This file should be assembled with NASM (Netwide Assembler),
+; can *not* be assembled with Microsoft's MASM or any compatible
+; assembler (including Borland's Turbo Assembler).
+; NASM is available from http://nasm.sourceforge.net/ or
+; http://sourceforge.net/project/showfiles.php?group_id=6208
+
+%include "jsimdext.inc"
+%include "jdct.inc"
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_TEXT
+    BITS        32
+;
+; Load data into workspace, applying unsigned->signed conversion
+;
+; GLOBAL(void)
+; jsimd_convsamp_avx2(JSAMPARRAY sample_data, JDIMENSION start_col,
+;                     DCTELEM *workspace);
+;
+
+%define sample_data  ebp + 8            ; JSAMPARRAY sample_data
+%define start_col    ebp + 12           ; JDIMENSION start_col
+%define workspace    ebp + 16           ; DCTELEM *workspace
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_convsamp_avx2)
+
+EXTN(jsimd_convsamp_avx2):
+    push        ebp
+    mov         ebp, esp
+    push        ebx
+;   push        ecx                     ; need not be preserved
+;   push        edx                     ; need not be preserved
+    push        esi
+    push        edi
+
+    mov         esi, JSAMPARRAY [sample_data]  ; (JSAMPROW *)
+    mov         eax, JDIMENSION [start_col]
+    mov         edi, POINTER [workspace]       ; (DCTELEM *)
+
+    mov         ebx, JSAMPROW [esi+0*SIZEOF_JSAMPROW]  ; (JSAMPLE *)
+    mov         edx, JSAMPROW [esi+1*SIZEOF_JSAMPROW]  ; (JSAMPLE *)
+    movq        xmm0, XMM_MMWORD [ebx+eax*SIZEOF_JSAMPLE]
+    movq        xmm1, XMM_MMWORD [edx+eax*SIZEOF_JSAMPLE]
+
+    mov         ebx, JSAMPROW [esi+2*SIZEOF_JSAMPROW]  ; (JSAMPLE *)
+    mov         edx, JSAMPROW [esi+3*SIZEOF_JSAMPROW]  ; (JSAMPLE *)
+    movq        xmm2, XMM_MMWORD [ebx+eax*SIZEOF_JSAMPLE]
+    movq        xmm3, XMM_MMWORD [edx+eax*SIZEOF_JSAMPLE]
+
+    mov         ebx, JSAMPROW [esi+4*SIZEOF_JSAMPROW]  ; (JSAMPLE *)
+    mov         edx, JSAMPROW [esi+5*SIZEOF_JSAMPROW]  ; (JSAMPLE *)
+    movq        xmm4, XMM_MMWORD [ebx+eax*SIZEOF_JSAMPLE]
+    movq        xmm5, XMM_MMWORD [edx+eax*SIZEOF_JSAMPLE]
+
+    mov         ebx, JSAMPROW [esi+6*SIZEOF_JSAMPROW]  ; (JSAMPLE *)
+    mov         edx, JSAMPROW [esi+7*SIZEOF_JSAMPROW]  ; (JSAMPLE *)
+    movq        xmm6, XMM_MMWORD [ebx+eax*SIZEOF_JSAMPLE]
+    movq        xmm7, XMM_MMWORD [edx+eax*SIZEOF_JSAMPLE]
+
+    vinserti128 ymm0, ymm0, xmm1, 1
+    vinserti128 ymm2, ymm2, xmm3, 1
+    vinserti128 ymm4, ymm4, xmm5, 1
+    vinserti128 ymm6, ymm6, xmm7, 1
+
+    vpxor       ymm1, ymm1, ymm1        ; ymm1=(all 0's)
+    vpunpcklbw  ymm0, ymm0, ymm1
+    vpunpcklbw  ymm2, ymm2, ymm1
+    vpunpcklbw  ymm4, ymm4, ymm1
+    vpunpcklbw  ymm6, ymm6, ymm1
+
+    vpcmpeqw    ymm7, ymm7, ymm7
+    vpsllw      ymm7, ymm7, 7           ; ymm7={0xFF80 0xFF80 0xFF80 0xFF80 ..}
+
+    vpaddw      ymm0, ymm0, ymm7
+    vpaddw      ymm2, ymm2, ymm7
+    vpaddw      ymm4, ymm4, ymm7
+    vpaddw      ymm6, ymm6, ymm7
+
+    vmovdqu     YMMWORD [YMMBLOCK(0,0,edi,SIZEOF_DCTELEM)], ymm0
+    vmovdqu     YMMWORD [YMMBLOCK(2,0,edi,SIZEOF_DCTELEM)], ymm2
+    vmovdqu     YMMWORD [YMMBLOCK(4,0,edi,SIZEOF_DCTELEM)], ymm4
+    vmovdqu     YMMWORD [YMMBLOCK(6,0,edi,SIZEOF_DCTELEM)], ymm6
+
+    vzeroupper
+    pop         edi
+    pop         esi
+;   pop         edx                     ; need not be preserved
+;   pop         ecx                     ; need not be preserved
+    pop         ebx
+    pop         ebp
+    ret
+
+; --------------------------------------------------------------------------
+;
+; Quantize/descale the coefficients, and store into coef_block
+;
+; This implementation is based on an algorithm described in
+;   "How to optimize for the Pentium family of microprocessors"
+;   (http://www.agner.org/assem/).
+;
+; GLOBAL(void)
+; jsimd_quantize_avx2(JCOEFPTR coef_block, DCTELEM *divisors,
+;                     DCTELEM *workspace);
+;
+
+%define RECIPROCAL(m, n, b) \
+  YMMBLOCK(DCTSIZE * 0 + (m), (n), (b), SIZEOF_DCTELEM)
+%define CORRECTION(m, n, b) \
+  YMMBLOCK(DCTSIZE * 1 + (m), (n), (b), SIZEOF_DCTELEM)
+%define SCALE(m, n, b) \
+  YMMBLOCK(DCTSIZE * 2 + (m), (n), (b), SIZEOF_DCTELEM)
+
+%define coef_block  ebp + 8             ; JCOEFPTR coef_block
+%define divisors    ebp + 12            ; DCTELEM *divisors
+%define workspace   ebp + 16            ; DCTELEM *workspace
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_quantize_avx2)
+
+EXTN(jsimd_quantize_avx2):
+    push        ebp
+    mov         ebp, esp
+;   push        ebx                     ; unused
+;   push        ecx                     ; unused
+;   push        edx                     ; need not be preserved
+    push        esi
+    push        edi
+
+    mov         esi, POINTER [workspace]
+    mov         edx, POINTER [divisors]
+    mov         edi, JCOEFPTR [coef_block]
+
+    vmovdqu     ymm4, [YMMBLOCK(0,0,esi,SIZEOF_DCTELEM)]
+    vmovdqu     ymm5, [YMMBLOCK(2,0,esi,SIZEOF_DCTELEM)]
+    vmovdqu     ymm6, [YMMBLOCK(4,0,esi,SIZEOF_DCTELEM)]
+    vmovdqu     ymm7, [YMMBLOCK(6,0,esi,SIZEOF_DCTELEM)]
+    vpabsw      ymm0, ymm4
+    vpabsw      ymm1, ymm5
+    vpabsw      ymm2, ymm6
+    vpabsw      ymm3, ymm7
+
+    vpaddw      ymm0, YMMWORD [CORRECTION(0,0,edx)]  ; correction + roundfactor
+    vpaddw      ymm1, YMMWORD [CORRECTION(2,0,edx)]
+    vpaddw      ymm2, YMMWORD [CORRECTION(4,0,edx)]
+    vpaddw      ymm3, YMMWORD [CORRECTION(6,0,edx)]
+    vpmulhuw    ymm0, YMMWORD [RECIPROCAL(0,0,edx)]  ; reciprocal
+    vpmulhuw    ymm1, YMMWORD [RECIPROCAL(2,0,edx)]
+    vpmulhuw    ymm2, YMMWORD [RECIPROCAL(4,0,edx)]
+    vpmulhuw    ymm3, YMMWORD [RECIPROCAL(6,0,edx)]
+    vpmulhuw    ymm0, YMMWORD [SCALE(0,0,edx)]       ; scale
+    vpmulhuw    ymm1, YMMWORD [SCALE(2,0,edx)]
+    vpmulhuw    ymm2, YMMWORD [SCALE(4,0,edx)]
+    vpmulhuw    ymm3, YMMWORD [SCALE(6,0,edx)]
+
+    vpsignw     ymm0, ymm0, ymm4
+    vpsignw     ymm1, ymm1, ymm5
+    vpsignw     ymm2, ymm2, ymm6
+    vpsignw     ymm3, ymm3, ymm7
+
+    vmovdqu     [YMMBLOCK(0,0,edi,SIZEOF_DCTELEM)], ymm0
+    vmovdqu     [YMMBLOCK(2,0,edi,SIZEOF_DCTELEM)], ymm1
+    vmovdqu     [YMMBLOCK(4,0,edi,SIZEOF_DCTELEM)], ymm2
+    vmovdqu     [YMMBLOCK(6,0,edi,SIZEOF_DCTELEM)], ymm3
+
+    vzeroupper
+    pop         edi
+    pop         esi
+;   pop         edx                     ; need not be preserved
+;   pop         ecx                     ; unused
+;   pop         ebx                     ; unused
+    pop         ebp
+    ret
+
+; For some reason, the OS X linker does not honor the request to align the
+; segment unless we do this.
+    align       32
diff --git a/3rdparty/libjpeg/src/simd/i386/jquanti-sse2.asm b/3rdparty/libjpeg/src/simd/i386/jquanti-sse2.asm
new file mode 100644
index 00000000..0a509408
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/i386/jquanti-sse2.asm
@@ -0,0 +1,201 @@
+;
+; jquanti.asm - sample data conversion and quantization (SSE2)
+;
+; Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+; Copyright (C) 2016, D. R. Commander.
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+;
+; This file should be assembled with NASM (Netwide Assembler),
+; can *not* be assembled with Microsoft's MASM or any compatible
+; assembler (including Borland's Turbo Assembler).
+; NASM is available from http://nasm.sourceforge.net/ or
+; http://sourceforge.net/project/showfiles.php?group_id=6208
+
+%include "jsimdext.inc"
+%include "jdct.inc"
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_TEXT
+    BITS        32
+;
+; Load data into workspace, applying unsigned->signed conversion
+;
+; GLOBAL(void)
+; jsimd_convsamp_sse2(JSAMPARRAY sample_data, JDIMENSION start_col,
+;                     DCTELEM *workspace);
+;
+
+%define sample_data  ebp + 8            ; JSAMPARRAY sample_data
+%define start_col    ebp + 12           ; JDIMENSION start_col
+%define workspace    ebp + 16           ; DCTELEM *workspace
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_convsamp_sse2)
+
+EXTN(jsimd_convsamp_sse2):
+    push        ebp
+    mov         ebp, esp
+    push        ebx
+;   push        ecx                     ; need not be preserved
+;   push        edx                     ; need not be preserved
+    push        esi
+    push        edi
+
+    pxor        xmm6, xmm6              ; xmm6=(all 0's)
+    pcmpeqw     xmm7, xmm7
+    psllw       xmm7, 7                 ; xmm7={0xFF80 0xFF80 0xFF80 0xFF80 ..}
+
+    mov         esi, JSAMPARRAY [sample_data]  ; (JSAMPROW *)
+    mov         eax, JDIMENSION [start_col]
+    mov         edi, POINTER [workspace]       ; (DCTELEM *)
+    mov         ecx, DCTSIZE/4
+    alignx      16, 7
+.convloop:
+    mov         ebx, JSAMPROW [esi+0*SIZEOF_JSAMPROW]  ; (JSAMPLE *)
+    mov         edx, JSAMPROW [esi+1*SIZEOF_JSAMPROW]  ; (JSAMPLE *)
+
+    movq        xmm0, XMM_MMWORD [ebx+eax*SIZEOF_JSAMPLE]  ; xmm0=(01234567)
+    movq        xmm1, XMM_MMWORD [edx+eax*SIZEOF_JSAMPLE]  ; xmm1=(89ABCDEF)
+
+    mov         ebx, JSAMPROW [esi+2*SIZEOF_JSAMPROW]  ; (JSAMPLE *)
+    mov         edx, JSAMPROW [esi+3*SIZEOF_JSAMPROW]  ; (JSAMPLE *)
+
+    movq        xmm2, XMM_MMWORD [ebx+eax*SIZEOF_JSAMPLE]  ; xmm2=(GHIJKLMN)
+    movq        xmm3, XMM_MMWORD [edx+eax*SIZEOF_JSAMPLE]  ; xmm3=(OPQRSTUV)
+
+    punpcklbw   xmm0, xmm6              ; xmm0=(01234567)
+    punpcklbw   xmm1, xmm6              ; xmm1=(89ABCDEF)
+    paddw       xmm0, xmm7
+    paddw       xmm1, xmm7
+    punpcklbw   xmm2, xmm6              ; xmm2=(GHIJKLMN)
+    punpcklbw   xmm3, xmm6              ; xmm3=(OPQRSTUV)
+    paddw       xmm2, xmm7
+    paddw       xmm3, xmm7
+
+    movdqa      XMMWORD [XMMBLOCK(0,0,edi,SIZEOF_DCTELEM)], xmm0
+    movdqa      XMMWORD [XMMBLOCK(1,0,edi,SIZEOF_DCTELEM)], xmm1
+    movdqa      XMMWORD [XMMBLOCK(2,0,edi,SIZEOF_DCTELEM)], xmm2
+    movdqa      XMMWORD [XMMBLOCK(3,0,edi,SIZEOF_DCTELEM)], xmm3
+
+    add         esi, byte 4*SIZEOF_JSAMPROW
+    add         edi, byte 4*DCTSIZE*SIZEOF_DCTELEM
+    dec         ecx
+    jnz         short .convloop
+
+    pop         edi
+    pop         esi
+;   pop         edx                     ; need not be preserved
+;   pop         ecx                     ; need not be preserved
+    pop         ebx
+    pop         ebp
+    ret
+
+; --------------------------------------------------------------------------
+;
+; Quantize/descale the coefficients, and store into coef_block
+;
+; This implementation is based on an algorithm described in
+;   "How to optimize for the Pentium family of microprocessors"
+;   (http://www.agner.org/assem/).
+;
+; GLOBAL(void)
+; jsimd_quantize_sse2(JCOEFPTR coef_block, DCTELEM *divisors,
+;                     DCTELEM *workspace);
+;
+
+%define RECIPROCAL(m, n, b) \
+  XMMBLOCK(DCTSIZE * 0 + (m), (n), (b), SIZEOF_DCTELEM)
+%define CORRECTION(m, n, b) \
+  XMMBLOCK(DCTSIZE * 1 + (m), (n), (b), SIZEOF_DCTELEM)
+%define SCALE(m, n, b) \
+  XMMBLOCK(DCTSIZE * 2 + (m), (n), (b), SIZEOF_DCTELEM)
+
+%define coef_block  ebp + 8             ; JCOEFPTR coef_block
+%define divisors    ebp + 12            ; DCTELEM *divisors
+%define workspace   ebp + 16            ; DCTELEM *workspace
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_quantize_sse2)
+
+EXTN(jsimd_quantize_sse2):
+    push        ebp
+    mov         ebp, esp
+;   push        ebx                     ; unused
+;   push        ecx                     ; unused
+;   push        edx                     ; need not be preserved
+    push        esi
+    push        edi
+
+    mov         esi, POINTER [workspace]
+    mov         edx, POINTER [divisors]
+    mov         edi, JCOEFPTR [coef_block]
+    mov         eax, DCTSIZE2/32
+    alignx      16, 7
+.quantloop:
+    movdqa      xmm4, XMMWORD [XMMBLOCK(0,0,esi,SIZEOF_DCTELEM)]
+    movdqa      xmm5, XMMWORD [XMMBLOCK(1,0,esi,SIZEOF_DCTELEM)]
+    movdqa      xmm6, XMMWORD [XMMBLOCK(2,0,esi,SIZEOF_DCTELEM)]
+    movdqa      xmm7, XMMWORD [XMMBLOCK(3,0,esi,SIZEOF_DCTELEM)]
+    movdqa      xmm0, xmm4
+    movdqa      xmm1, xmm5
+    movdqa      xmm2, xmm6
+    movdqa      xmm3, xmm7
+    psraw       xmm4, (WORD_BIT-1)
+    psraw       xmm5, (WORD_BIT-1)
+    psraw       xmm6, (WORD_BIT-1)
+    psraw       xmm7, (WORD_BIT-1)
+    pxor        xmm0, xmm4
+    pxor        xmm1, xmm5
+    pxor        xmm2, xmm6
+    pxor        xmm3, xmm7
+    psubw       xmm0, xmm4              ; if (xmm0 < 0) xmm0 = -xmm0;
+    psubw       xmm1, xmm5              ; if (xmm1 < 0) xmm1 = -xmm1;
+    psubw       xmm2, xmm6              ; if (xmm2 < 0) xmm2 = -xmm2;
+    psubw       xmm3, xmm7              ; if (xmm3 < 0) xmm3 = -xmm3;
+
+    paddw       xmm0, XMMWORD [CORRECTION(0,0,edx)]  ; correction + roundfactor
+    paddw       xmm1, XMMWORD [CORRECTION(1,0,edx)]
+    paddw       xmm2, XMMWORD [CORRECTION(2,0,edx)]
+    paddw       xmm3, XMMWORD [CORRECTION(3,0,edx)]
+    pmulhuw     xmm0, XMMWORD [RECIPROCAL(0,0,edx)]  ; reciprocal
+    pmulhuw     xmm1, XMMWORD [RECIPROCAL(1,0,edx)]
+    pmulhuw     xmm2, XMMWORD [RECIPROCAL(2,0,edx)]
+    pmulhuw     xmm3, XMMWORD [RECIPROCAL(3,0,edx)]
+    pmulhuw     xmm0, XMMWORD [SCALE(0,0,edx)]       ; scale
+    pmulhuw     xmm1, XMMWORD [SCALE(1,0,edx)]
+    pmulhuw     xmm2, XMMWORD [SCALE(2,0,edx)]
+    pmulhuw     xmm3, XMMWORD [SCALE(3,0,edx)]
+
+    pxor        xmm0, xmm4
+    pxor        xmm1, xmm5
+    pxor        xmm2, xmm6
+    pxor        xmm3, xmm7
+    psubw       xmm0, xmm4
+    psubw       xmm1, xmm5
+    psubw       xmm2, xmm6
+    psubw       xmm3, xmm7
+    movdqa      XMMWORD [XMMBLOCK(0,0,edi,SIZEOF_DCTELEM)], xmm0
+    movdqa      XMMWORD [XMMBLOCK(1,0,edi,SIZEOF_DCTELEM)], xmm1
+    movdqa      XMMWORD [XMMBLOCK(2,0,edi,SIZEOF_DCTELEM)], xmm2
+    movdqa      XMMWORD [XMMBLOCK(3,0,edi,SIZEOF_DCTELEM)], xmm3
+
+    add         esi, byte 32*SIZEOF_DCTELEM
+    add         edx, byte 32*SIZEOF_DCTELEM
+    add         edi, byte 32*SIZEOF_JCOEF
+    dec         eax
+    jnz         near .quantloop
+
+    pop         edi
+    pop         esi
+;   pop         edx                     ; need not be preserved
+;   pop         ecx                     ; unused
+;   pop         ebx                     ; unused
+    pop         ebp
+    ret
+
+; For some reason, the OS X linker does not honor the request to align the
+; segment unless we do this.
+    align       32
diff --git a/3rdparty/libjpeg/src/simd/i386/jsimd.c b/3rdparty/libjpeg/src/simd/i386/jsimd.c
new file mode 100644
index 00000000..563949a0
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/i386/jsimd.c
@@ -0,0 +1,1253 @@
+/*
+ * jsimd_i386.c
+ *
+ * Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+ * Copyright (C) 2009-2011, 2013-2014, 2016, 2018, D. R. Commander.
+ * Copyright (C) 2015-2016, 2018, Matthieu Darbois.
+ *
+ * Based on the x86 SIMD extension for IJG JPEG library,
+ * Copyright (C) 1999-2006, MIYASAKA Masaru.
+ * For conditions of distribution and use, see copyright notice in jsimdext.inc
+ *
+ * This file contains the interface between the "normal" portions
+ * of the library and the SIMD implementations when running on a
+ * 32-bit x86 architecture.
+ */
+
+#define JPEG_INTERNALS
+#include "../../jinclude.h"
+#include "../../jpeglib.h"
+#include "../../jsimd.h"
+#include "../../jdct.h"
+#include "../../jsimddct.h"
+#include "../jsimd.h"
+#include "jconfigint.h"
+
+/*
+ * In the PIC cases, we have no guarantee that constants will keep
+ * their alignment. This macro allows us to verify it at runtime.
+ */
+#define IS_ALIGNED(ptr, order)  (((unsigned)ptr & ((1 << order) - 1)) == 0)
+
+#define IS_ALIGNED_SSE(ptr)  (IS_ALIGNED(ptr, 4)) /* 16 byte alignment */
+#define IS_ALIGNED_AVX(ptr)  (IS_ALIGNED(ptr, 5)) /* 32 byte alignment */
+
+static unsigned int simd_support = (unsigned int)(~0);
+static unsigned int simd_huffman = 1;
+
+/*
+ * Check what SIMD accelerations are supported.
+ *
+ * FIXME: This code is racy under a multi-threaded environment.
+ */
+LOCAL(void)
+init_simd(void)
+{
+#ifndef NO_GETENV
+  char *env = NULL;
+#endif
+
+  if (simd_support != ~0U)
+    return;
+
+  simd_support = jpeg_simd_cpu_support();
+
+#ifndef NO_GETENV
+  /* Force different settings through environment variables */
+  env = getenv("JSIMD_FORCEMMX");
+  if ((env != NULL) && (strcmp(env, "1") == 0))
+    simd_support &= JSIMD_MMX;
+  env = getenv("JSIMD_FORCE3DNOW");
+  if ((env != NULL) && (strcmp(env, "1") == 0))
+    simd_support &= JSIMD_3DNOW | JSIMD_MMX;
+  env = getenv("JSIMD_FORCESSE");
+  if ((env != NULL) && (strcmp(env, "1") == 0))
+    simd_support &= JSIMD_SSE | JSIMD_MMX;
+  env = getenv("JSIMD_FORCESSE2");
+  if ((env != NULL) && (strcmp(env, "1") == 0))
+    simd_support &= JSIMD_SSE2;
+  env = getenv("JSIMD_FORCEAVX2");
+  if ((env != NULL) && (strcmp(env, "1") == 0))
+    simd_support &= JSIMD_AVX2;
+  env = getenv("JSIMD_FORCENONE");
+  if ((env != NULL) && (strcmp(env, "1") == 0))
+    simd_support = 0;
+  env = getenv("JSIMD_NOHUFFENC");
+  if ((env != NULL) && (strcmp(env, "1") == 0))
+    simd_huffman = 0;
+#endif
+}
+
+GLOBAL(int)
+jsimd_can_rgb_ycc(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+  if ((RGB_PIXELSIZE != 3) && (RGB_PIXELSIZE != 4))
+    return 0;
+
+  if ((simd_support & JSIMD_AVX2) &&
+      IS_ALIGNED_AVX(jconst_rgb_ycc_convert_avx2))
+    return 1;
+  if ((simd_support & JSIMD_SSE2) &&
+      IS_ALIGNED_SSE(jconst_rgb_ycc_convert_sse2))
+    return 1;
+  if (simd_support & JSIMD_MMX)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_rgb_gray(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+  if ((RGB_PIXELSIZE != 3) && (RGB_PIXELSIZE != 4))
+    return 0;
+
+  if ((simd_support & JSIMD_AVX2) &&
+      IS_ALIGNED_AVX(jconst_rgb_gray_convert_avx2))
+    return 1;
+  if ((simd_support & JSIMD_SSE2) &&
+      IS_ALIGNED_SSE(jconst_rgb_gray_convert_sse2))
+    return 1;
+  if (simd_support & JSIMD_MMX)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_ycc_rgb(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+  if ((RGB_PIXELSIZE != 3) && (RGB_PIXELSIZE != 4))
+    return 0;
+
+  if ((simd_support & JSIMD_AVX2) &&
+      IS_ALIGNED_AVX(jconst_ycc_rgb_convert_avx2))
+    return 1;
+  if ((simd_support & JSIMD_SSE2) &&
+      IS_ALIGNED_SSE(jconst_ycc_rgb_convert_sse2))
+    return 1;
+  if (simd_support & JSIMD_MMX)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_ycc_rgb565(void)
+{
+  return 0;
+}
+
+GLOBAL(void)
+jsimd_rgb_ycc_convert(j_compress_ptr cinfo, JSAMPARRAY input_buf,
+                      JSAMPIMAGE output_buf, JDIMENSION output_row,
+                      int num_rows)
+{
+  void (*avx2fct) (JDIMENSION, JSAMPARRAY, JSAMPIMAGE, JDIMENSION, int);
+  void (*sse2fct) (JDIMENSION, JSAMPARRAY, JSAMPIMAGE, JDIMENSION, int);
+  void (*mmxfct) (JDIMENSION, JSAMPARRAY, JSAMPIMAGE, JDIMENSION, int);
+
+  switch (cinfo->in_color_space) {
+  case JCS_EXT_RGB:
+    avx2fct = jsimd_extrgb_ycc_convert_avx2;
+    sse2fct = jsimd_extrgb_ycc_convert_sse2;
+    mmxfct = jsimd_extrgb_ycc_convert_mmx;
+    break;
+  case JCS_EXT_RGBX:
+  case JCS_EXT_RGBA:
+    avx2fct = jsimd_extrgbx_ycc_convert_avx2;
+    sse2fct = jsimd_extrgbx_ycc_convert_sse2;
+    mmxfct = jsimd_extrgbx_ycc_convert_mmx;
+    break;
+  case JCS_EXT_BGR:
+    avx2fct = jsimd_extbgr_ycc_convert_avx2;
+    sse2fct = jsimd_extbgr_ycc_convert_sse2;
+    mmxfct = jsimd_extbgr_ycc_convert_mmx;
+    break;
+  case JCS_EXT_BGRX:
+  case JCS_EXT_BGRA:
+    avx2fct = jsimd_extbgrx_ycc_convert_avx2;
+    sse2fct = jsimd_extbgrx_ycc_convert_sse2;
+    mmxfct = jsimd_extbgrx_ycc_convert_mmx;
+    break;
+  case JCS_EXT_XBGR:
+  case JCS_EXT_ABGR:
+    avx2fct = jsimd_extxbgr_ycc_convert_avx2;
+    sse2fct = jsimd_extxbgr_ycc_convert_sse2;
+    mmxfct = jsimd_extxbgr_ycc_convert_mmx;
+    break;
+  case JCS_EXT_XRGB:
+  case JCS_EXT_ARGB:
+    avx2fct = jsimd_extxrgb_ycc_convert_avx2;
+    sse2fct = jsimd_extxrgb_ycc_convert_sse2;
+    mmxfct = jsimd_extxrgb_ycc_convert_mmx;
+    break;
+  default:
+    avx2fct = jsimd_rgb_ycc_convert_avx2;
+    sse2fct = jsimd_rgb_ycc_convert_sse2;
+    mmxfct = jsimd_rgb_ycc_convert_mmx;
+    break;
+  }
+
+  if (simd_support & JSIMD_AVX2)
+    avx2fct(cinfo->image_width, input_buf, output_buf, output_row, num_rows);
+  else if (simd_support & JSIMD_SSE2)
+    sse2fct(cinfo->image_width, input_buf, output_buf, output_row, num_rows);
+  else
+    mmxfct(cinfo->image_width, input_buf, output_buf, output_row, num_rows);
+}
+
+GLOBAL(void)
+jsimd_rgb_gray_convert(j_compress_ptr cinfo, JSAMPARRAY input_buf,
+                       JSAMPIMAGE output_buf, JDIMENSION output_row,
+                       int num_rows)
+{
+  void (*avx2fct) (JDIMENSION, JSAMPARRAY, JSAMPIMAGE, JDIMENSION, int);
+  void (*sse2fct) (JDIMENSION, JSAMPARRAY, JSAMPIMAGE, JDIMENSION, int);
+  void (*mmxfct) (JDIMENSION, JSAMPARRAY, JSAMPIMAGE, JDIMENSION, int);
+
+  switch (cinfo->in_color_space) {
+  case JCS_EXT_RGB:
+    avx2fct = jsimd_extrgb_gray_convert_avx2;
+    sse2fct = jsimd_extrgb_gray_convert_sse2;
+    mmxfct = jsimd_extrgb_gray_convert_mmx;
+    break;
+  case JCS_EXT_RGBX:
+  case JCS_EXT_RGBA:
+    avx2fct = jsimd_extrgbx_gray_convert_avx2;
+    sse2fct = jsimd_extrgbx_gray_convert_sse2;
+    mmxfct = jsimd_extrgbx_gray_convert_mmx;
+    break;
+  case JCS_EXT_BGR:
+    avx2fct = jsimd_extbgr_gray_convert_avx2;
+    sse2fct = jsimd_extbgr_gray_convert_sse2;
+    mmxfct = jsimd_extbgr_gray_convert_mmx;
+    break;
+  case JCS_EXT_BGRX:
+  case JCS_EXT_BGRA:
+    avx2fct = jsimd_extbgrx_gray_convert_avx2;
+    sse2fct = jsimd_extbgrx_gray_convert_sse2;
+    mmxfct = jsimd_extbgrx_gray_convert_mmx;
+    break;
+  case JCS_EXT_XBGR:
+  case JCS_EXT_ABGR:
+    avx2fct = jsimd_extxbgr_gray_convert_avx2;
+    sse2fct = jsimd_extxbgr_gray_convert_sse2;
+    mmxfct = jsimd_extxbgr_gray_convert_mmx;
+    break;
+  case JCS_EXT_XRGB:
+  case JCS_EXT_ARGB:
+    avx2fct = jsimd_extxrgb_gray_convert_avx2;
+    sse2fct = jsimd_extxrgb_gray_convert_sse2;
+    mmxfct = jsimd_extxrgb_gray_convert_mmx;
+    break;
+  default:
+    avx2fct = jsimd_rgb_gray_convert_avx2;
+    sse2fct = jsimd_rgb_gray_convert_sse2;
+    mmxfct = jsimd_rgb_gray_convert_mmx;
+    break;
+  }
+
+  if (simd_support & JSIMD_AVX2)
+    avx2fct(cinfo->image_width, input_buf, output_buf, output_row, num_rows);
+  else if (simd_support & JSIMD_SSE2)
+    sse2fct(cinfo->image_width, input_buf, output_buf, output_row, num_rows);
+  else
+    mmxfct(cinfo->image_width, input_buf, output_buf, output_row, num_rows);
+}
+
+GLOBAL(void)
+jsimd_ycc_rgb_convert(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
+                      JDIMENSION input_row, JSAMPARRAY output_buf,
+                      int num_rows)
+{
+  void (*avx2fct) (JDIMENSION, JSAMPIMAGE, JDIMENSION, JSAMPARRAY, int);
+  void (*sse2fct) (JDIMENSION, JSAMPIMAGE, JDIMENSION, JSAMPARRAY, int);
+  void (*mmxfct) (JDIMENSION, JSAMPIMAGE, JDIMENSION, JSAMPARRAY, int);
+
+  switch (cinfo->out_color_space) {
+  case JCS_EXT_RGB:
+    avx2fct = jsimd_ycc_extrgb_convert_avx2;
+    sse2fct = jsimd_ycc_extrgb_convert_sse2;
+    mmxfct = jsimd_ycc_extrgb_convert_mmx;
+    break;
+  case JCS_EXT_RGBX:
+  case JCS_EXT_RGBA:
+    avx2fct = jsimd_ycc_extrgbx_convert_avx2;
+    sse2fct = jsimd_ycc_extrgbx_convert_sse2;
+    mmxfct = jsimd_ycc_extrgbx_convert_mmx;
+    break;
+  case JCS_EXT_BGR:
+    avx2fct = jsimd_ycc_extbgr_convert_avx2;
+    sse2fct = jsimd_ycc_extbgr_convert_sse2;
+    mmxfct = jsimd_ycc_extbgr_convert_mmx;
+    break;
+  case JCS_EXT_BGRX:
+  case JCS_EXT_BGRA:
+    avx2fct = jsimd_ycc_extbgrx_convert_avx2;
+    sse2fct = jsimd_ycc_extbgrx_convert_sse2;
+    mmxfct = jsimd_ycc_extbgrx_convert_mmx;
+    break;
+  case JCS_EXT_XBGR:
+  case JCS_EXT_ABGR:
+    avx2fct = jsimd_ycc_extxbgr_convert_avx2;
+    sse2fct = jsimd_ycc_extxbgr_convert_sse2;
+    mmxfct = jsimd_ycc_extxbgr_convert_mmx;
+    break;
+  case JCS_EXT_XRGB:
+  case JCS_EXT_ARGB:
+    avx2fct = jsimd_ycc_extxrgb_convert_avx2;
+    sse2fct = jsimd_ycc_extxrgb_convert_sse2;
+    mmxfct = jsimd_ycc_extxrgb_convert_mmx;
+    break;
+  default:
+    avx2fct = jsimd_ycc_rgb_convert_avx2;
+    sse2fct = jsimd_ycc_rgb_convert_sse2;
+    mmxfct = jsimd_ycc_rgb_convert_mmx;
+    break;
+  }
+
+  if (simd_support & JSIMD_AVX2)
+    avx2fct(cinfo->output_width, input_buf, input_row, output_buf, num_rows);
+  else if (simd_support & JSIMD_SSE2)
+    sse2fct(cinfo->output_width, input_buf, input_row, output_buf, num_rows);
+  else
+    mmxfct(cinfo->output_width, input_buf, input_row, output_buf, num_rows);
+}
+
+GLOBAL(void)
+jsimd_ycc_rgb565_convert(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
+                         JDIMENSION input_row, JSAMPARRAY output_buf,
+                         int num_rows)
+{
+}
+
+GLOBAL(int)
+jsimd_can_h2v2_downsample(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+
+  if (simd_support & JSIMD_AVX2)
+    return 1;
+  if (simd_support & JSIMD_SSE2)
+    return 1;
+  if (simd_support & JSIMD_MMX)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_h2v1_downsample(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+
+  if (simd_support & JSIMD_AVX2)
+    return 1;
+  if (simd_support & JSIMD_SSE2)
+    return 1;
+  if (simd_support & JSIMD_MMX)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(void)
+jsimd_h2v2_downsample(j_compress_ptr cinfo, jpeg_component_info *compptr,
+                      JSAMPARRAY input_data, JSAMPARRAY output_data)
+{
+  if (simd_support & JSIMD_AVX2)
+    jsimd_h2v2_downsample_avx2(cinfo->image_width, cinfo->max_v_samp_factor,
+                               compptr->v_samp_factor,
+                               compptr->width_in_blocks, input_data,
+                               output_data);
+  else if (simd_support & JSIMD_SSE2)
+    jsimd_h2v2_downsample_sse2(cinfo->image_width, cinfo->max_v_samp_factor,
+                               compptr->v_samp_factor,
+                               compptr->width_in_blocks, input_data,
+                               output_data);
+  else
+    jsimd_h2v2_downsample_mmx(cinfo->image_width, cinfo->max_v_samp_factor,
+                              compptr->v_samp_factor, compptr->width_in_blocks,
+                              input_data, output_data);
+}
+
+GLOBAL(void)
+jsimd_h2v1_downsample(j_compress_ptr cinfo, jpeg_component_info *compptr,
+                      JSAMPARRAY input_data, JSAMPARRAY output_data)
+{
+  if (simd_support & JSIMD_AVX2)
+    jsimd_h2v1_downsample_avx2(cinfo->image_width, cinfo->max_v_samp_factor,
+                               compptr->v_samp_factor,
+                               compptr->width_in_blocks, input_data,
+                               output_data);
+  else if (simd_support & JSIMD_SSE2)
+    jsimd_h2v1_downsample_sse2(cinfo->image_width, cinfo->max_v_samp_factor,
+                               compptr->v_samp_factor,
+                               compptr->width_in_blocks, input_data,
+                               output_data);
+  else
+    jsimd_h2v1_downsample_mmx(cinfo->image_width, cinfo->max_v_samp_factor,
+                              compptr->v_samp_factor, compptr->width_in_blocks,
+                              input_data, output_data);
+}
+
+GLOBAL(int)
+jsimd_can_h2v2_upsample(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+
+  if (simd_support & JSIMD_AVX2)
+    return 1;
+  if (simd_support & JSIMD_SSE2)
+    return 1;
+  if (simd_support & JSIMD_MMX)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_h2v1_upsample(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+
+  if (simd_support & JSIMD_AVX2)
+    return 1;
+  if (simd_support & JSIMD_SSE2)
+    return 1;
+  if (simd_support & JSIMD_MMX)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(void)
+jsimd_h2v2_upsample(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+                    JSAMPARRAY input_data, JSAMPARRAY *output_data_ptr)
+{
+  if (simd_support & JSIMD_AVX2)
+    jsimd_h2v2_upsample_avx2(cinfo->max_v_samp_factor, cinfo->output_width,
+                             input_data, output_data_ptr);
+  else if (simd_support & JSIMD_SSE2)
+    jsimd_h2v2_upsample_sse2(cinfo->max_v_samp_factor, cinfo->output_width,
+                             input_data, output_data_ptr);
+  else
+    jsimd_h2v2_upsample_mmx(cinfo->max_v_samp_factor, cinfo->output_width,
+                            input_data, output_data_ptr);
+}
+
+GLOBAL(void)
+jsimd_h2v1_upsample(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+                    JSAMPARRAY input_data, JSAMPARRAY *output_data_ptr)
+{
+  if (simd_support & JSIMD_AVX2)
+    jsimd_h2v1_upsample_avx2(cinfo->max_v_samp_factor, cinfo->output_width,
+                             input_data, output_data_ptr);
+  else if (simd_support & JSIMD_SSE2)
+    jsimd_h2v1_upsample_sse2(cinfo->max_v_samp_factor, cinfo->output_width,
+                             input_data, output_data_ptr);
+  else
+    jsimd_h2v1_upsample_mmx(cinfo->max_v_samp_factor, cinfo->output_width,
+                            input_data, output_data_ptr);
+}
+
+GLOBAL(int)
+jsimd_can_h2v2_fancy_upsample(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+
+  if ((simd_support & JSIMD_AVX2) &&
+      IS_ALIGNED_AVX(jconst_fancy_upsample_avx2))
+    return 1;
+  if ((simd_support & JSIMD_SSE2) &&
+      IS_ALIGNED_SSE(jconst_fancy_upsample_sse2))
+    return 1;
+  if (simd_support & JSIMD_MMX)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_h2v1_fancy_upsample(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+
+  if ((simd_support & JSIMD_AVX2) &&
+      IS_ALIGNED_AVX(jconst_fancy_upsample_avx2))
+    return 1;
+  if ((simd_support & JSIMD_SSE2) &&
+      IS_ALIGNED_SSE(jconst_fancy_upsample_sse2))
+    return 1;
+  if (simd_support & JSIMD_MMX)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(void)
+jsimd_h2v2_fancy_upsample(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+                          JSAMPARRAY input_data, JSAMPARRAY *output_data_ptr)
+{
+  if (simd_support & JSIMD_AVX2)
+    jsimd_h2v2_fancy_upsample_avx2(cinfo->max_v_samp_factor,
+                                   compptr->downsampled_width, input_data,
+                                   output_data_ptr);
+  else if (simd_support & JSIMD_SSE2)
+    jsimd_h2v2_fancy_upsample_sse2(cinfo->max_v_samp_factor,
+                                   compptr->downsampled_width, input_data,
+                                   output_data_ptr);
+  else
+    jsimd_h2v2_fancy_upsample_mmx(cinfo->max_v_samp_factor,
+                                  compptr->downsampled_width, input_data,
+                                  output_data_ptr);
+}
+
+GLOBAL(void)
+jsimd_h2v1_fancy_upsample(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+                          JSAMPARRAY input_data, JSAMPARRAY *output_data_ptr)
+{
+  if (simd_support & JSIMD_AVX2)
+    jsimd_h2v1_fancy_upsample_avx2(cinfo->max_v_samp_factor,
+                                   compptr->downsampled_width, input_data,
+                                   output_data_ptr);
+  else if (simd_support & JSIMD_SSE2)
+    jsimd_h2v1_fancy_upsample_sse2(cinfo->max_v_samp_factor,
+                                   compptr->downsampled_width, input_data,
+                                   output_data_ptr);
+  else
+    jsimd_h2v1_fancy_upsample_mmx(cinfo->max_v_samp_factor,
+                                  compptr->downsampled_width, input_data,
+                                  output_data_ptr);
+}
+
+GLOBAL(int)
+jsimd_can_h2v2_merged_upsample(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+
+  if ((simd_support & JSIMD_AVX2) &&
+      IS_ALIGNED_AVX(jconst_merged_upsample_avx2))
+    return 1;
+  if ((simd_support & JSIMD_SSE2) &&
+      IS_ALIGNED_SSE(jconst_merged_upsample_sse2))
+    return 1;
+  if (simd_support & JSIMD_MMX)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_h2v1_merged_upsample(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+
+  if ((simd_support & JSIMD_AVX2) &&
+      IS_ALIGNED_AVX(jconst_merged_upsample_avx2))
+    return 1;
+  if ((simd_support & JSIMD_SSE2) &&
+      IS_ALIGNED_SSE(jconst_merged_upsample_sse2))
+    return 1;
+  if (simd_support & JSIMD_MMX)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(void)
+jsimd_h2v2_merged_upsample(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
+                           JDIMENSION in_row_group_ctr, JSAMPARRAY output_buf)
+{
+  void (*avx2fct) (JDIMENSION, JSAMPIMAGE, JDIMENSION, JSAMPARRAY);
+  void (*sse2fct) (JDIMENSION, JSAMPIMAGE, JDIMENSION, JSAMPARRAY);
+  void (*mmxfct) (JDIMENSION, JSAMPIMAGE, JDIMENSION, JSAMPARRAY);
+
+  switch (cinfo->out_color_space) {
+  case JCS_EXT_RGB:
+    avx2fct = jsimd_h2v2_extrgb_merged_upsample_avx2;
+    sse2fct = jsimd_h2v2_extrgb_merged_upsample_sse2;
+    mmxfct = jsimd_h2v2_extrgb_merged_upsample_mmx;
+    break;
+  case JCS_EXT_RGBX:
+  case JCS_EXT_RGBA:
+    avx2fct = jsimd_h2v2_extrgbx_merged_upsample_avx2;
+    sse2fct = jsimd_h2v2_extrgbx_merged_upsample_sse2;
+    mmxfct = jsimd_h2v2_extrgbx_merged_upsample_mmx;
+    break;
+  case JCS_EXT_BGR:
+    avx2fct = jsimd_h2v2_extbgr_merged_upsample_avx2;
+    sse2fct = jsimd_h2v2_extbgr_merged_upsample_sse2;
+    mmxfct = jsimd_h2v2_extbgr_merged_upsample_mmx;
+    break;
+  case JCS_EXT_BGRX:
+  case JCS_EXT_BGRA:
+    avx2fct = jsimd_h2v2_extbgrx_merged_upsample_avx2;
+    sse2fct = jsimd_h2v2_extbgrx_merged_upsample_sse2;
+    mmxfct = jsimd_h2v2_extbgrx_merged_upsample_mmx;
+    break;
+  case JCS_EXT_XBGR:
+  case JCS_EXT_ABGR:
+    avx2fct = jsimd_h2v2_extxbgr_merged_upsample_avx2;
+    sse2fct = jsimd_h2v2_extxbgr_merged_upsample_sse2;
+    mmxfct = jsimd_h2v2_extxbgr_merged_upsample_mmx;
+    break;
+  case JCS_EXT_XRGB:
+  case JCS_EXT_ARGB:
+    avx2fct = jsimd_h2v2_extxrgb_merged_upsample_avx2;
+    sse2fct = jsimd_h2v2_extxrgb_merged_upsample_sse2;
+    mmxfct = jsimd_h2v2_extxrgb_merged_upsample_mmx;
+    break;
+  default:
+    avx2fct = jsimd_h2v2_merged_upsample_avx2;
+    sse2fct = jsimd_h2v2_merged_upsample_sse2;
+    mmxfct = jsimd_h2v2_merged_upsample_mmx;
+    break;
+  }
+
+  if (simd_support & JSIMD_AVX2)
+    avx2fct(cinfo->output_width, input_buf, in_row_group_ctr, output_buf);
+  else if (simd_support & JSIMD_SSE2)
+    sse2fct(cinfo->output_width, input_buf, in_row_group_ctr, output_buf);
+  else
+    mmxfct(cinfo->output_width, input_buf, in_row_group_ctr, output_buf);
+}
+
+GLOBAL(void)
+jsimd_h2v1_merged_upsample(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
+                           JDIMENSION in_row_group_ctr, JSAMPARRAY output_buf)
+{
+  void (*avx2fct) (JDIMENSION, JSAMPIMAGE, JDIMENSION, JSAMPARRAY);
+  void (*sse2fct) (JDIMENSION, JSAMPIMAGE, JDIMENSION, JSAMPARRAY);
+  void (*mmxfct) (JDIMENSION, JSAMPIMAGE, JDIMENSION, JSAMPARRAY);
+
+  switch (cinfo->out_color_space) {
+  case JCS_EXT_RGB:
+    avx2fct = jsimd_h2v1_extrgb_merged_upsample_avx2;
+    sse2fct = jsimd_h2v1_extrgb_merged_upsample_sse2;
+    mmxfct = jsimd_h2v1_extrgb_merged_upsample_mmx;
+    break;
+  case JCS_EXT_RGBX:
+  case JCS_EXT_RGBA:
+    avx2fct = jsimd_h2v1_extrgbx_merged_upsample_avx2;
+    sse2fct = jsimd_h2v1_extrgbx_merged_upsample_sse2;
+    mmxfct = jsimd_h2v1_extrgbx_merged_upsample_mmx;
+    break;
+  case JCS_EXT_BGR:
+    avx2fct = jsimd_h2v1_extbgr_merged_upsample_avx2;
+    sse2fct = jsimd_h2v1_extbgr_merged_upsample_sse2;
+    mmxfct = jsimd_h2v1_extbgr_merged_upsample_mmx;
+    break;
+  case JCS_EXT_BGRX:
+  case JCS_EXT_BGRA:
+    avx2fct = jsimd_h2v1_extbgrx_merged_upsample_avx2;
+    sse2fct = jsimd_h2v1_extbgrx_merged_upsample_sse2;
+    mmxfct = jsimd_h2v1_extbgrx_merged_upsample_mmx;
+    break;
+  case JCS_EXT_XBGR:
+  case JCS_EXT_ABGR:
+    avx2fct = jsimd_h2v1_extxbgr_merged_upsample_avx2;
+    sse2fct = jsimd_h2v1_extxbgr_merged_upsample_sse2;
+    mmxfct = jsimd_h2v1_extxbgr_merged_upsample_mmx;
+    break;
+  case JCS_EXT_XRGB:
+  case JCS_EXT_ARGB:
+    avx2fct = jsimd_h2v1_extxrgb_merged_upsample_avx2;
+    sse2fct = jsimd_h2v1_extxrgb_merged_upsample_sse2;
+    mmxfct = jsimd_h2v1_extxrgb_merged_upsample_mmx;
+    break;
+  default:
+    avx2fct = jsimd_h2v1_merged_upsample_avx2;
+    sse2fct = jsimd_h2v1_merged_upsample_sse2;
+    mmxfct = jsimd_h2v1_merged_upsample_mmx;
+    break;
+  }
+
+  if (simd_support & JSIMD_AVX2)
+    avx2fct(cinfo->output_width, input_buf, in_row_group_ctr, output_buf);
+  else if (simd_support & JSIMD_SSE2)
+    sse2fct(cinfo->output_width, input_buf, in_row_group_ctr, output_buf);
+  else
+    mmxfct(cinfo->output_width, input_buf, in_row_group_ctr, output_buf);
+}
+
+GLOBAL(int)
+jsimd_can_convsamp(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (DCTSIZE != 8)
+    return 0;
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+  if (sizeof(DCTELEM) != 2)
+    return 0;
+
+  if (simd_support & JSIMD_AVX2)
+    return 1;
+  if (simd_support & JSIMD_SSE2)
+    return 1;
+  if (simd_support & JSIMD_MMX)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_convsamp_float(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (DCTSIZE != 8)
+    return 0;
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+  if (sizeof(FAST_FLOAT) != 4)
+    return 0;
+
+  if (simd_support & JSIMD_SSE2)
+    return 1;
+  if (simd_support & JSIMD_SSE)
+    return 1;
+  if (simd_support & JSIMD_3DNOW)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(void)
+jsimd_convsamp(JSAMPARRAY sample_data, JDIMENSION start_col,
+               DCTELEM *workspace)
+{
+  if (simd_support & JSIMD_AVX2)
+    jsimd_convsamp_avx2(sample_data, start_col, workspace);
+  else if (simd_support & JSIMD_SSE2)
+    jsimd_convsamp_sse2(sample_data, start_col, workspace);
+  else
+    jsimd_convsamp_mmx(sample_data, start_col, workspace);
+}
+
+GLOBAL(void)
+jsimd_convsamp_float(JSAMPARRAY sample_data, JDIMENSION start_col,
+                     FAST_FLOAT *workspace)
+{
+  if (simd_support & JSIMD_SSE2)
+    jsimd_convsamp_float_sse2(sample_data, start_col, workspace);
+  else if (simd_support & JSIMD_SSE)
+    jsimd_convsamp_float_sse(sample_data, start_col, workspace);
+  else
+    jsimd_convsamp_float_3dnow(sample_data, start_col, workspace);
+}
+
+GLOBAL(int)
+jsimd_can_fdct_islow(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (DCTSIZE != 8)
+    return 0;
+  if (sizeof(DCTELEM) != 2)
+    return 0;
+
+  if ((simd_support & JSIMD_AVX2) && IS_ALIGNED_AVX(jconst_fdct_islow_avx2))
+    return 1;
+  if ((simd_support & JSIMD_SSE2) && IS_ALIGNED_SSE(jconst_fdct_islow_sse2))
+    return 1;
+  if (simd_support & JSIMD_MMX)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_fdct_ifast(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (DCTSIZE != 8)
+    return 0;
+  if (sizeof(DCTELEM) != 2)
+    return 0;
+
+  if ((simd_support & JSIMD_SSE2) && IS_ALIGNED_SSE(jconst_fdct_ifast_sse2))
+    return 1;
+  if (simd_support & JSIMD_MMX)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_fdct_float(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (DCTSIZE != 8)
+    return 0;
+  if (sizeof(FAST_FLOAT) != 4)
+    return 0;
+
+  if ((simd_support & JSIMD_SSE) && IS_ALIGNED_SSE(jconst_fdct_float_sse))
+    return 1;
+  if (simd_support & JSIMD_3DNOW)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(void)
+jsimd_fdct_islow(DCTELEM *data)
+{
+  if (simd_support & JSIMD_AVX2)
+    jsimd_fdct_islow_avx2(data);
+  else if (simd_support & JSIMD_SSE2)
+    jsimd_fdct_islow_sse2(data);
+  else
+    jsimd_fdct_islow_mmx(data);
+}
+
+GLOBAL(void)
+jsimd_fdct_ifast(DCTELEM *data)
+{
+  if ((simd_support & JSIMD_SSE2) && IS_ALIGNED_SSE(jconst_fdct_islow_sse2))
+    jsimd_fdct_ifast_sse2(data);
+  else
+    jsimd_fdct_ifast_mmx(data);
+}
+
+GLOBAL(void)
+jsimd_fdct_float(FAST_FLOAT *data)
+{
+  if ((simd_support & JSIMD_SSE) && IS_ALIGNED_SSE(jconst_fdct_float_sse))
+    jsimd_fdct_float_sse(data);
+  else if (simd_support & JSIMD_3DNOW)
+    jsimd_fdct_float_3dnow(data);
+}
+
+GLOBAL(int)
+jsimd_can_quantize(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (DCTSIZE != 8)
+    return 0;
+  if (sizeof(JCOEF) != 2)
+    return 0;
+  if (sizeof(DCTELEM) != 2)
+    return 0;
+
+  if (simd_support & JSIMD_AVX2)
+    return 1;
+  if (simd_support & JSIMD_SSE2)
+    return 1;
+  if (simd_support & JSIMD_MMX)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_quantize_float(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (DCTSIZE != 8)
+    return 0;
+  if (sizeof(JCOEF) != 2)
+    return 0;
+  if (sizeof(FAST_FLOAT) != 4)
+    return 0;
+
+  if (simd_support & JSIMD_SSE2)
+    return 1;
+  if (simd_support & JSIMD_SSE)
+    return 1;
+  if (simd_support & JSIMD_3DNOW)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(void)
+jsimd_quantize(JCOEFPTR coef_block, DCTELEM *divisors, DCTELEM *workspace)
+{
+  if (simd_support & JSIMD_AVX2)
+    jsimd_quantize_avx2(coef_block, divisors, workspace);
+  else if (simd_support & JSIMD_SSE2)
+    jsimd_quantize_sse2(coef_block, divisors, workspace);
+  else
+    jsimd_quantize_mmx(coef_block, divisors, workspace);
+}
+
+GLOBAL(void)
+jsimd_quantize_float(JCOEFPTR coef_block, FAST_FLOAT *divisors,
+                     FAST_FLOAT *workspace)
+{
+  if (simd_support & JSIMD_SSE2)
+    jsimd_quantize_float_sse2(coef_block, divisors, workspace);
+  else if (simd_support & JSIMD_SSE)
+    jsimd_quantize_float_sse(coef_block, divisors, workspace);
+  else
+    jsimd_quantize_float_3dnow(coef_block, divisors, workspace);
+}
+
+GLOBAL(int)
+jsimd_can_idct_2x2(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (DCTSIZE != 8)
+    return 0;
+  if (sizeof(JCOEF) != 2)
+    return 0;
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+  if (sizeof(ISLOW_MULT_TYPE) != 2)
+    return 0;
+
+  if ((simd_support & JSIMD_SSE2) && IS_ALIGNED_SSE(jconst_idct_red_sse2))
+    return 1;
+  if (simd_support & JSIMD_MMX)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_idct_4x4(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (DCTSIZE != 8)
+    return 0;
+  if (sizeof(JCOEF) != 2)
+    return 0;
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+  if (sizeof(ISLOW_MULT_TYPE) != 2)
+    return 0;
+
+  if ((simd_support & JSIMD_SSE2) && IS_ALIGNED_SSE(jconst_idct_red_sse2))
+    return 1;
+  if (simd_support & JSIMD_MMX)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(void)
+jsimd_idct_2x2(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+               JCOEFPTR coef_block, JSAMPARRAY output_buf,
+               JDIMENSION output_col)
+{
+  if ((simd_support & JSIMD_SSE2) && IS_ALIGNED_SSE(jconst_idct_red_sse2))
+    jsimd_idct_2x2_sse2(compptr->dct_table, coef_block, output_buf,
+                        output_col);
+  else
+    jsimd_idct_2x2_mmx(compptr->dct_table, coef_block, output_buf, output_col);
+}
+
+GLOBAL(void)
+jsimd_idct_4x4(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+               JCOEFPTR coef_block, JSAMPARRAY output_buf,
+               JDIMENSION output_col)
+{
+  if ((simd_support & JSIMD_SSE2) && IS_ALIGNED_SSE(jconst_idct_red_sse2))
+    jsimd_idct_4x4_sse2(compptr->dct_table, coef_block, output_buf,
+                        output_col);
+  else
+    jsimd_idct_4x4_mmx(compptr->dct_table, coef_block, output_buf, output_col);
+}
+
+GLOBAL(int)
+jsimd_can_idct_islow(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (DCTSIZE != 8)
+    return 0;
+  if (sizeof(JCOEF) != 2)
+    return 0;
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+  if (sizeof(ISLOW_MULT_TYPE) != 2)
+    return 0;
+
+  if ((simd_support & JSIMD_AVX2) && IS_ALIGNED_AVX(jconst_idct_islow_avx2))
+    return 1;
+  if ((simd_support & JSIMD_SSE2) && IS_ALIGNED_SSE(jconst_idct_islow_sse2))
+    return 1;
+  if (simd_support & JSIMD_MMX)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_idct_ifast(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (DCTSIZE != 8)
+    return 0;
+  if (sizeof(JCOEF) != 2)
+    return 0;
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+  if (sizeof(IFAST_MULT_TYPE) != 2)
+    return 0;
+  if (IFAST_SCALE_BITS != 2)
+    return 0;
+
+  if ((simd_support & JSIMD_SSE2) && IS_ALIGNED_SSE(jconst_idct_ifast_sse2))
+    return 1;
+  if (simd_support & JSIMD_MMX)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_idct_float(void)
+{
+  init_simd();
+
+  if (DCTSIZE != 8)
+    return 0;
+  if (sizeof(JCOEF) != 2)
+    return 0;
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+  if (sizeof(FAST_FLOAT) != 4)
+    return 0;
+  if (sizeof(FLOAT_MULT_TYPE) != 4)
+    return 0;
+
+  if ((simd_support & JSIMD_SSE2) && IS_ALIGNED_SSE(jconst_idct_float_sse2))
+    return 1;
+  if ((simd_support & JSIMD_SSE) && IS_ALIGNED_SSE(jconst_idct_float_sse))
+    return 1;
+  if (simd_support & JSIMD_3DNOW)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(void)
+jsimd_idct_islow(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+                 JCOEFPTR coef_block, JSAMPARRAY output_buf,
+                 JDIMENSION output_col)
+{
+  if (simd_support & JSIMD_AVX2)
+    jsimd_idct_islow_avx2(compptr->dct_table, coef_block, output_buf,
+                          output_col);
+  else if (simd_support & JSIMD_SSE2)
+    jsimd_idct_islow_sse2(compptr->dct_table, coef_block, output_buf,
+                          output_col);
+  else
+    jsimd_idct_islow_mmx(compptr->dct_table, coef_block, output_buf,
+                         output_col);
+}
+
+GLOBAL(void)
+jsimd_idct_ifast(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+                 JCOEFPTR coef_block, JSAMPARRAY output_buf,
+                 JDIMENSION output_col)
+{
+  if ((simd_support & JSIMD_SSE2) && IS_ALIGNED_SSE(jconst_idct_ifast_sse2))
+    jsimd_idct_ifast_sse2(compptr->dct_table, coef_block, output_buf,
+                          output_col);
+  else
+    jsimd_idct_ifast_mmx(compptr->dct_table, coef_block, output_buf,
+                         output_col);
+}
+
+GLOBAL(void)
+jsimd_idct_float(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+                 JCOEFPTR coef_block, JSAMPARRAY output_buf,
+                 JDIMENSION output_col)
+{
+  if ((simd_support & JSIMD_SSE2) && IS_ALIGNED_SSE(jconst_idct_float_sse2))
+    jsimd_idct_float_sse2(compptr->dct_table, coef_block, output_buf,
+                          output_col);
+  else if ((simd_support & JSIMD_SSE) && IS_ALIGNED_SSE(jconst_idct_float_sse))
+    jsimd_idct_float_sse(compptr->dct_table, coef_block, output_buf,
+                         output_col);
+  else
+    jsimd_idct_float_3dnow(compptr->dct_table, coef_block, output_buf,
+                           output_col);
+}
+
+GLOBAL(int)
+jsimd_can_huff_encode_one_block(void)
+{
+  init_simd();
+
+  if (DCTSIZE != 8)
+    return 0;
+  if (sizeof(JCOEF) != 2)
+    return 0;
+
+  if ((simd_support & JSIMD_SSE2) && simd_huffman &&
+      IS_ALIGNED_SSE(jconst_huff_encode_one_block))
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(JOCTET *)
+jsimd_huff_encode_one_block(void *state, JOCTET *buffer, JCOEFPTR block,
+                            int last_dc_val, c_derived_tbl *dctbl,
+                            c_derived_tbl *actbl)
+{
+  return jsimd_huff_encode_one_block_sse2(state, buffer, block, last_dc_val,
+                                          dctbl, actbl);
+}
+
+GLOBAL(int)
+jsimd_can_encode_mcu_AC_first_prepare(void)
+{
+  init_simd();
+
+  if (DCTSIZE != 8)
+    return 0;
+  if (sizeof(JCOEF) != 2)
+    return 0;
+  if (SIZEOF_SIZE_T != 4)
+    return 0;
+  if (simd_support & JSIMD_SSE2)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(void)
+jsimd_encode_mcu_AC_first_prepare(const JCOEF *block,
+                                  const int *jpeg_natural_order_start, int Sl,
+                                  int Al, JCOEF *values, size_t *zerobits)
+{
+  jsimd_encode_mcu_AC_first_prepare_sse2(block, jpeg_natural_order_start,
+                                         Sl, Al, values, zerobits);
+}
+
+GLOBAL(int)
+jsimd_can_encode_mcu_AC_refine_prepare(void)
+{
+  init_simd();
+
+  if (DCTSIZE != 8)
+    return 0;
+  if (sizeof(JCOEF) != 2)
+    return 0;
+  if (SIZEOF_SIZE_T != 4)
+    return 0;
+  if (simd_support & JSIMD_SSE2)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_encode_mcu_AC_refine_prepare(const JCOEF *block,
+                                   const int *jpeg_natural_order_start, int Sl,
+                                   int Al, JCOEF *absvalues, size_t *bits)
+{
+  return jsimd_encode_mcu_AC_refine_prepare_sse2(block,
+                                                 jpeg_natural_order_start,
+                                                 Sl, Al, absvalues, bits);
+}
diff --git a/3rdparty/libjpeg/src/simd/i386/jsimdcpu.asm b/3rdparty/libjpeg/src/simd/i386/jsimdcpu.asm
new file mode 100644
index 00000000..ddcafa9e
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/i386/jsimdcpu.asm
@@ -0,0 +1,135 @@
+;
+; jsimdcpu.asm - SIMD instruction support check
+;
+; Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+; Copyright (C) 2016, D. R. Commander.
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+;
+; This file should be assembled with NASM (Netwide Assembler),
+; can *not* be assembled with Microsoft's MASM or any compatible
+; assembler (including Borland's Turbo Assembler).
+; NASM is available from http://nasm.sourceforge.net/ or
+; http://sourceforge.net/project/showfiles.php?group_id=6208
+
+%include "jsimdext.inc"
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_TEXT
+    BITS        32
+;
+; Check if the CPU supports SIMD instructions
+;
+; GLOBAL(unsigned int)
+; jpeg_simd_cpu_support(void)
+;
+
+    align       32
+    GLOBAL_FUNCTION(jpeg_simd_cpu_support)
+
+EXTN(jpeg_simd_cpu_support):
+    push        ebx
+;   push        ecx                     ; need not be preserved
+;   push        edx                     ; need not be preserved
+;   push        esi                     ; unused
+    push        edi
+
+    xor         edi, edi                ; simd support flag
+
+    pushfd
+    pop         eax
+    mov         edx, eax
+    xor         eax, 1<<21              ; flip ID bit in EFLAGS
+    push        eax
+    popfd
+    pushfd
+    pop         eax
+    xor         eax, edx
+    jz          near .return            ; CPUID is not supported
+
+    ; Check whether CPUID leaf 07H is supported
+    ; (leaf 07H is used to check for AVX2 instruction support)
+    xor         eax, eax
+    cpuid
+    test        eax, eax
+    jz          near .return
+    cmp         eax, 7
+    jl          short .no_avx2          ; Maximum leaf < 07H
+
+    ; Check for AVX2 instruction support
+    mov         eax, 7
+    xor         ecx, ecx
+    cpuid
+    mov         eax, ebx
+    test        eax, 1<<5               ; bit5:AVX2
+    jz          short .no_avx2
+
+    ; Check for AVX2 O/S support
+    mov         eax, 1
+    xor         ecx, ecx
+    cpuid
+    test        ecx, 1<<27
+    jz          short .no_avx2          ; O/S does not support XSAVE
+    test        ecx, 1<<28
+    jz          short .no_avx2          ; CPU does not support AVX2
+
+    xor         ecx, ecx
+    xgetbv
+    and         eax, 6
+    cmp         eax, 6                  ; O/S does not manage XMM/YMM state
+                                        ; using XSAVE
+    jnz         short .no_avx2
+
+    or          edi, JSIMD_AVX2
+.no_avx2:
+
+    ; Check CPUID leaf 01H for MMX, SSE, and SSE2 support
+    xor         eax, eax
+    inc         eax
+    cpuid
+    mov         eax, edx                ; eax = Standard feature flags
+
+    ; Check for MMX instruction support
+    test        eax, 1<<23              ; bit23:MMX
+    jz          short .no_mmx
+    or          edi, byte JSIMD_MMX
+.no_mmx:
+    test        eax, 1<<25              ; bit25:SSE
+    jz          short .no_sse
+    or          edi, byte JSIMD_SSE
+.no_sse:
+    test        eax, 1<<26              ; bit26:SSE2
+    jz          short .no_sse2
+    or          edi, byte JSIMD_SSE2
+.no_sse2:
+
+    ; Check for 3DNow! instruction support
+    mov         eax, 0x80000000
+    cpuid
+    cmp         eax, 0x80000000
+    jbe         short .return
+
+    mov         eax, 0x80000001
+    cpuid
+    mov         eax, edx                ; eax = Extended feature flags
+
+    test        eax, 1<<31              ; bit31:3DNow!(vendor independent)
+    jz          short .no_3dnow
+    or          edi, byte JSIMD_3DNOW
+.no_3dnow:
+
+.return:
+    mov         eax, edi
+
+    pop         edi
+;   pop         esi                     ; unused
+;   pop         edx                     ; need not be preserved
+;   pop         ecx                     ; need not be preserved
+    pop         ebx
+    ret
+
+; For some reason, the OS X linker does not honor the request to align the
+; segment unless we do this.
+    align       32
diff --git a/3rdparty/libjpeg/src/simd/jsimd.h b/3rdparty/libjpeg/src/simd/jsimd.h
new file mode 100644
index 00000000..64747c63
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/jsimd.h
@@ -0,0 +1,1258 @@
+/*
+ * simd/jsimd.h
+ *
+ * Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+ * Copyright (C) 2011, 2014-2016, 2018, 2020, D. R. Commander.
+ * Copyright (C) 2013-2014, MIPS Technologies, Inc., California.
+ * Copyright (C) 2014, Linaro Limited.
+ * Copyright (C) 2015-2016, 2018, Matthieu Darbois.
+ * Copyright (C) 2016-2018, Loongson Technology Corporation Limited, BeiJing.
+ * Copyright (C) 2020, Arm Limited.
+ *
+ * Based on the x86 SIMD extension for IJG JPEG library,
+ * Copyright (C) 1999-2006, MIYASAKA Masaru.
+ * For conditions of distribution and use, see copyright notice in jsimdext.inc
+ *
+ */
+
+/* Bitmask for supported acceleration methods */
+
+#define JSIMD_NONE     0x00
+#define JSIMD_MMX      0x01
+#define JSIMD_3DNOW    0x02
+#define JSIMD_SSE      0x04
+#define JSIMD_SSE2     0x08
+#define JSIMD_NEON     0x10
+#define JSIMD_DSPR2    0x20
+#define JSIMD_ALTIVEC  0x40
+#define JSIMD_AVX2     0x80
+#define JSIMD_MMI      0x100
+
+/* SIMD Ext: retrieve SIMD/CPU information */
+EXTERN(unsigned int) jpeg_simd_cpu_support(void);
+
+/* RGB & extended RGB --> YCC Colorspace Conversion */
+EXTERN(void) jsimd_rgb_ycc_convert_mmx
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+EXTERN(void) jsimd_extrgb_ycc_convert_mmx
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+EXTERN(void) jsimd_extrgbx_ycc_convert_mmx
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+EXTERN(void) jsimd_extbgr_ycc_convert_mmx
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+EXTERN(void) jsimd_extbgrx_ycc_convert_mmx
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+EXTERN(void) jsimd_extxbgr_ycc_convert_mmx
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+EXTERN(void) jsimd_extxrgb_ycc_convert_mmx
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+
+extern const int jconst_rgb_ycc_convert_sse2[];
+EXTERN(void) jsimd_rgb_ycc_convert_sse2
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+EXTERN(void) jsimd_extrgb_ycc_convert_sse2
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+EXTERN(void) jsimd_extrgbx_ycc_convert_sse2
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+EXTERN(void) jsimd_extbgr_ycc_convert_sse2
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+EXTERN(void) jsimd_extbgrx_ycc_convert_sse2
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+EXTERN(void) jsimd_extxbgr_ycc_convert_sse2
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+EXTERN(void) jsimd_extxrgb_ycc_convert_sse2
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+
+extern const int jconst_rgb_ycc_convert_avx2[];
+EXTERN(void) jsimd_rgb_ycc_convert_avx2
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+EXTERN(void) jsimd_extrgb_ycc_convert_avx2
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+EXTERN(void) jsimd_extrgbx_ycc_convert_avx2
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+EXTERN(void) jsimd_extbgr_ycc_convert_avx2
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+EXTERN(void) jsimd_extbgrx_ycc_convert_avx2
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+EXTERN(void) jsimd_extxbgr_ycc_convert_avx2
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+EXTERN(void) jsimd_extxrgb_ycc_convert_avx2
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+
+EXTERN(void) jsimd_rgb_ycc_convert_neon
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+EXTERN(void) jsimd_extrgb_ycc_convert_neon
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+EXTERN(void) jsimd_extrgbx_ycc_convert_neon
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+EXTERN(void) jsimd_extbgr_ycc_convert_neon
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+EXTERN(void) jsimd_extbgrx_ycc_convert_neon
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+EXTERN(void) jsimd_extxbgr_ycc_convert_neon
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+EXTERN(void) jsimd_extxrgb_ycc_convert_neon
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+
+#ifndef NEON_INTRINSICS
+
+EXTERN(void) jsimd_extrgb_ycc_convert_neon_slowld3
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+EXTERN(void) jsimd_extbgr_ycc_convert_neon_slowld3
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+
+#endif
+
+EXTERN(void) jsimd_rgb_ycc_convert_dspr2
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+EXTERN(void) jsimd_extrgb_ycc_convert_dspr2
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+EXTERN(void) jsimd_extrgbx_ycc_convert_dspr2
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+EXTERN(void) jsimd_extbgr_ycc_convert_dspr2
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+EXTERN(void) jsimd_extbgrx_ycc_convert_dspr2
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+EXTERN(void) jsimd_extxbgr_ycc_convert_dspr2
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+EXTERN(void) jsimd_extxrgb_ycc_convert_dspr2
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+
+EXTERN(void) jsimd_rgb_ycc_convert_mmi
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+EXTERN(void) jsimd_extrgb_ycc_convert_mmi
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+EXTERN(void) jsimd_extrgbx_ycc_convert_mmi
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+EXTERN(void) jsimd_extbgr_ycc_convert_mmi
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+EXTERN(void) jsimd_extbgrx_ycc_convert_mmi
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+EXTERN(void) jsimd_extxbgr_ycc_convert_mmi
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+EXTERN(void) jsimd_extxrgb_ycc_convert_mmi
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+
+EXTERN(void) jsimd_rgb_ycc_convert_altivec
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+EXTERN(void) jsimd_extrgb_ycc_convert_altivec
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+EXTERN(void) jsimd_extrgbx_ycc_convert_altivec
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+EXTERN(void) jsimd_extbgr_ycc_convert_altivec
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+EXTERN(void) jsimd_extbgrx_ycc_convert_altivec
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+EXTERN(void) jsimd_extxbgr_ycc_convert_altivec
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+EXTERN(void) jsimd_extxrgb_ycc_convert_altivec
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+
+/* RGB & extended RGB --> Grayscale Colorspace Conversion */
+EXTERN(void) jsimd_rgb_gray_convert_mmx
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+EXTERN(void) jsimd_extrgb_gray_convert_mmx
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+EXTERN(void) jsimd_extrgbx_gray_convert_mmx
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+EXTERN(void) jsimd_extbgr_gray_convert_mmx
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+EXTERN(void) jsimd_extbgrx_gray_convert_mmx
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+EXTERN(void) jsimd_extxbgr_gray_convert_mmx
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+EXTERN(void) jsimd_extxrgb_gray_convert_mmx
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+
+extern const int jconst_rgb_gray_convert_sse2[];
+EXTERN(void) jsimd_rgb_gray_convert_sse2
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+EXTERN(void) jsimd_extrgb_gray_convert_sse2
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+EXTERN(void) jsimd_extrgbx_gray_convert_sse2
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+EXTERN(void) jsimd_extbgr_gray_convert_sse2
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+EXTERN(void) jsimd_extbgrx_gray_convert_sse2
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+EXTERN(void) jsimd_extxbgr_gray_convert_sse2
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+EXTERN(void) jsimd_extxrgb_gray_convert_sse2
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+
+extern const int jconst_rgb_gray_convert_avx2[];
+EXTERN(void) jsimd_rgb_gray_convert_avx2
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+EXTERN(void) jsimd_extrgb_gray_convert_avx2
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+EXTERN(void) jsimd_extrgbx_gray_convert_avx2
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+EXTERN(void) jsimd_extbgr_gray_convert_avx2
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+EXTERN(void) jsimd_extbgrx_gray_convert_avx2
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+EXTERN(void) jsimd_extxbgr_gray_convert_avx2
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+EXTERN(void) jsimd_extxrgb_gray_convert_avx2
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+
+EXTERN(void) jsimd_rgb_gray_convert_neon
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+EXTERN(void) jsimd_extrgb_gray_convert_neon
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+EXTERN(void) jsimd_extrgbx_gray_convert_neon
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+EXTERN(void) jsimd_extbgr_gray_convert_neon
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+EXTERN(void) jsimd_extbgrx_gray_convert_neon
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+EXTERN(void) jsimd_extxbgr_gray_convert_neon
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+EXTERN(void) jsimd_extxrgb_gray_convert_neon
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+
+EXTERN(void) jsimd_rgb_gray_convert_dspr2
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+EXTERN(void) jsimd_extrgb_gray_convert_dspr2
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+EXTERN(void) jsimd_extrgbx_gray_convert_dspr2
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+EXTERN(void) jsimd_extbgr_gray_convert_dspr2
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+EXTERN(void) jsimd_extbgrx_gray_convert_dspr2
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+EXTERN(void) jsimd_extxbgr_gray_convert_dspr2
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+EXTERN(void) jsimd_extxrgb_gray_convert_dspr2
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+
+EXTERN(void) jsimd_rgb_gray_convert_mmi
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+EXTERN(void) jsimd_extrgb_gray_convert_mmi
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+EXTERN(void) jsimd_extrgbx_gray_convert_mmi
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+EXTERN(void) jsimd_extbgr_gray_convert_mmi
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+EXTERN(void) jsimd_extbgrx_gray_convert_mmi
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+EXTERN(void) jsimd_extxbgr_gray_convert_mmi
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+EXTERN(void) jsimd_extxrgb_gray_convert_mmi
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+
+EXTERN(void) jsimd_rgb_gray_convert_altivec
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+EXTERN(void) jsimd_extrgb_gray_convert_altivec
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+EXTERN(void) jsimd_extrgbx_gray_convert_altivec
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+EXTERN(void) jsimd_extbgr_gray_convert_altivec
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+EXTERN(void) jsimd_extbgrx_gray_convert_altivec
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+EXTERN(void) jsimd_extxbgr_gray_convert_altivec
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+EXTERN(void) jsimd_extxrgb_gray_convert_altivec
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows);
+
+/* YCC --> RGB & extended RGB Colorspace Conversion */
+EXTERN(void) jsimd_ycc_rgb_convert_mmx
+  (JDIMENSION out_width, JSAMPIMAGE input_buf, JDIMENSION input_row,
+   JSAMPARRAY output_buf, int num_rows);
+EXTERN(void) jsimd_ycc_extrgb_convert_mmx
+  (JDIMENSION out_width, JSAMPIMAGE input_buf, JDIMENSION input_row,
+   JSAMPARRAY output_buf, int num_rows);
+EXTERN(void) jsimd_ycc_extrgbx_convert_mmx
+  (JDIMENSION out_width, JSAMPIMAGE input_buf, JDIMENSION input_row,
+   JSAMPARRAY output_buf, int num_rows);
+EXTERN(void) jsimd_ycc_extbgr_convert_mmx
+  (JDIMENSION out_width, JSAMPIMAGE input_buf, JDIMENSION input_row,
+   JSAMPARRAY output_buf, int num_rows);
+EXTERN(void) jsimd_ycc_extbgrx_convert_mmx
+  (JDIMENSION out_width, JSAMPIMAGE input_buf, JDIMENSION input_row,
+   JSAMPARRAY output_buf, int num_rows);
+EXTERN(void) jsimd_ycc_extxbgr_convert_mmx
+  (JDIMENSION out_width, JSAMPIMAGE input_buf, JDIMENSION input_row,
+   JSAMPARRAY output_buf, int num_rows);
+EXTERN(void) jsimd_ycc_extxrgb_convert_mmx
+  (JDIMENSION out_width, JSAMPIMAGE input_buf, JDIMENSION input_row,
+   JSAMPARRAY output_buf, int num_rows);
+
+extern const int jconst_ycc_rgb_convert_sse2[];
+EXTERN(void) jsimd_ycc_rgb_convert_sse2
+  (JDIMENSION out_width, JSAMPIMAGE input_buf, JDIMENSION input_row,
+   JSAMPARRAY output_buf, int num_rows);
+EXTERN(void) jsimd_ycc_extrgb_convert_sse2
+  (JDIMENSION out_width, JSAMPIMAGE input_buf, JDIMENSION input_row,
+   JSAMPARRAY output_buf, int num_rows);
+EXTERN(void) jsimd_ycc_extrgbx_convert_sse2
+  (JDIMENSION out_width, JSAMPIMAGE input_buf, JDIMENSION input_row,
+   JSAMPARRAY output_buf, int num_rows);
+EXTERN(void) jsimd_ycc_extbgr_convert_sse2
+  (JDIMENSION out_width, JSAMPIMAGE input_buf, JDIMENSION input_row,
+   JSAMPARRAY output_buf, int num_rows);
+EXTERN(void) jsimd_ycc_extbgrx_convert_sse2
+  (JDIMENSION out_width, JSAMPIMAGE input_buf, JDIMENSION input_row,
+   JSAMPARRAY output_buf, int num_rows);
+EXTERN(void) jsimd_ycc_extxbgr_convert_sse2
+  (JDIMENSION out_width, JSAMPIMAGE input_buf, JDIMENSION input_row,
+   JSAMPARRAY output_buf, int num_rows);
+EXTERN(void) jsimd_ycc_extxrgb_convert_sse2
+  (JDIMENSION out_width, JSAMPIMAGE input_buf, JDIMENSION input_row,
+   JSAMPARRAY output_buf, int num_rows);
+
+extern const int jconst_ycc_rgb_convert_avx2[];
+EXTERN(void) jsimd_ycc_rgb_convert_avx2
+  (JDIMENSION out_width, JSAMPIMAGE input_buf, JDIMENSION input_row,
+   JSAMPARRAY output_buf, int num_rows);
+EXTERN(void) jsimd_ycc_extrgb_convert_avx2
+  (JDIMENSION out_width, JSAMPIMAGE input_buf, JDIMENSION input_row,
+   JSAMPARRAY output_buf, int num_rows);
+EXTERN(void) jsimd_ycc_extrgbx_convert_avx2
+  (JDIMENSION out_width, JSAMPIMAGE input_buf, JDIMENSION input_row,
+   JSAMPARRAY output_buf, int num_rows);
+EXTERN(void) jsimd_ycc_extbgr_convert_avx2
+  (JDIMENSION out_width, JSAMPIMAGE input_buf, JDIMENSION input_row,
+   JSAMPARRAY output_buf, int num_rows);
+EXTERN(void) jsimd_ycc_extbgrx_convert_avx2
+  (JDIMENSION out_width, JSAMPIMAGE input_buf, JDIMENSION input_row,
+   JSAMPARRAY output_buf, int num_rows);
+EXTERN(void) jsimd_ycc_extxbgr_convert_avx2
+  (JDIMENSION out_width, JSAMPIMAGE input_buf, JDIMENSION input_row,
+   JSAMPARRAY output_buf, int num_rows);
+EXTERN(void) jsimd_ycc_extxrgb_convert_avx2
+  (JDIMENSION out_width, JSAMPIMAGE input_buf, JDIMENSION input_row,
+   JSAMPARRAY output_buf, int num_rows);
+
+EXTERN(void) jsimd_ycc_rgb_convert_neon
+  (JDIMENSION out_width, JSAMPIMAGE input_buf, JDIMENSION input_row,
+   JSAMPARRAY output_buf, int num_rows);
+EXTERN(void) jsimd_ycc_extrgb_convert_neon
+  (JDIMENSION out_width, JSAMPIMAGE input_buf, JDIMENSION input_row,
+   JSAMPARRAY output_buf, int num_rows);
+EXTERN(void) jsimd_ycc_extrgbx_convert_neon
+  (JDIMENSION out_width, JSAMPIMAGE input_buf, JDIMENSION input_row,
+   JSAMPARRAY output_buf, int num_rows);
+EXTERN(void) jsimd_ycc_extbgr_convert_neon
+  (JDIMENSION out_width, JSAMPIMAGE input_buf, JDIMENSION input_row,
+   JSAMPARRAY output_buf, int num_rows);
+EXTERN(void) jsimd_ycc_extbgrx_convert_neon
+  (JDIMENSION out_width, JSAMPIMAGE input_buf, JDIMENSION input_row,
+   JSAMPARRAY output_buf, int num_rows);
+EXTERN(void) jsimd_ycc_extxbgr_convert_neon
+  (JDIMENSION out_width, JSAMPIMAGE input_buf, JDIMENSION input_row,
+   JSAMPARRAY output_buf, int num_rows);
+EXTERN(void) jsimd_ycc_extxrgb_convert_neon
+  (JDIMENSION out_width, JSAMPIMAGE input_buf, JDIMENSION input_row,
+   JSAMPARRAY output_buf, int num_rows);
+EXTERN(void) jsimd_ycc_rgb565_convert_neon
+  (JDIMENSION out_width, JSAMPIMAGE input_buf, JDIMENSION input_row,
+   JSAMPARRAY output_buf, int num_rows);
+
+#ifndef NEON_INTRINSICS
+
+EXTERN(void) jsimd_ycc_extrgb_convert_neon_slowst3
+  (JDIMENSION out_width, JSAMPIMAGE input_buf, JDIMENSION input_row,
+   JSAMPARRAY output_buf, int num_rows);
+EXTERN(void) jsimd_ycc_extbgr_convert_neon_slowst3
+  (JDIMENSION out_width, JSAMPIMAGE input_buf, JDIMENSION input_row,
+   JSAMPARRAY output_buf, int num_rows);
+
+#endif
+
+EXTERN(void) jsimd_ycc_rgb_convert_dspr2
+  (JDIMENSION out_width, JSAMPIMAGE input_buf, JDIMENSION input_row,
+   JSAMPARRAY output_buf, int num_rows);
+EXTERN(void) jsimd_ycc_extrgb_convert_dspr2
+  (JDIMENSION out_width, JSAMPIMAGE input_buf, JDIMENSION input_row,
+   JSAMPARRAY output_buf, int num_rows);
+EXTERN(void) jsimd_ycc_extrgbx_convert_dspr2
+  (JDIMENSION out_width, JSAMPIMAGE input_buf, JDIMENSION input_row,
+   JSAMPARRAY output_buf, int num_rows);
+EXTERN(void) jsimd_ycc_extbgr_convert_dspr2
+  (JDIMENSION out_width, JSAMPIMAGE input_buf, JDIMENSION input_row,
+   JSAMPARRAY output_buf, int num_rows);
+EXTERN(void) jsimd_ycc_extbgrx_convert_dspr2
+  (JDIMENSION out_width, JSAMPIMAGE input_buf, JDIMENSION input_row,
+   JSAMPARRAY output_buf, int num_rows);
+EXTERN(void) jsimd_ycc_extxbgr_convert_dspr2
+  (JDIMENSION out_width, JSAMPIMAGE input_buf, JDIMENSION input_row,
+   JSAMPARRAY output_buf, int num_rows);
+EXTERN(void) jsimd_ycc_extxrgb_convert_dspr2
+  (JDIMENSION out_width, JSAMPIMAGE input_buf, JDIMENSION input_row,
+   JSAMPARRAY output_buf, int num_rows);
+
+EXTERN(void) jsimd_ycc_rgb_convert_mmi
+  (JDIMENSION out_width, JSAMPIMAGE input_buf, JDIMENSION input_row,
+   JSAMPARRAY output_buf, int num_rows);
+EXTERN(void) jsimd_ycc_extrgb_convert_mmi
+  (JDIMENSION out_width, JSAMPIMAGE input_buf, JDIMENSION input_row,
+   JSAMPARRAY output_buf, int num_rows);
+EXTERN(void) jsimd_ycc_extrgbx_convert_mmi
+  (JDIMENSION out_width, JSAMPIMAGE input_buf, JDIMENSION input_row,
+   JSAMPARRAY output_buf, int num_rows);
+EXTERN(void) jsimd_ycc_extbgr_convert_mmi
+  (JDIMENSION out_width, JSAMPIMAGE input_buf, JDIMENSION input_row,
+   JSAMPARRAY output_buf, int num_rows);
+EXTERN(void) jsimd_ycc_extbgrx_convert_mmi
+  (JDIMENSION out_width, JSAMPIMAGE input_buf, JDIMENSION input_row,
+   JSAMPARRAY output_buf, int num_rows);
+EXTERN(void) jsimd_ycc_extxbgr_convert_mmi
+  (JDIMENSION out_width, JSAMPIMAGE input_buf, JDIMENSION input_row,
+   JSAMPARRAY output_buf, int num_rows);
+EXTERN(void) jsimd_ycc_extxrgb_convert_mmi
+  (JDIMENSION out_width, JSAMPIMAGE input_buf, JDIMENSION input_row,
+   JSAMPARRAY output_buf, int num_rows);
+
+EXTERN(void) jsimd_ycc_rgb_convert_altivec
+  (JDIMENSION out_width, JSAMPIMAGE input_buf, JDIMENSION input_row,
+   JSAMPARRAY output_buf, int num_rows);
+EXTERN(void) jsimd_ycc_extrgb_convert_altivec
+  (JDIMENSION out_width, JSAMPIMAGE input_buf, JDIMENSION input_row,
+   JSAMPARRAY output_buf, int num_rows);
+EXTERN(void) jsimd_ycc_extrgbx_convert_altivec
+  (JDIMENSION out_width, JSAMPIMAGE input_buf, JDIMENSION input_row,
+   JSAMPARRAY output_buf, int num_rows);
+EXTERN(void) jsimd_ycc_extbgr_convert_altivec
+  (JDIMENSION out_width, JSAMPIMAGE input_buf, JDIMENSION input_row,
+   JSAMPARRAY output_buf, int num_rows);
+EXTERN(void) jsimd_ycc_extbgrx_convert_altivec
+  (JDIMENSION out_width, JSAMPIMAGE input_buf, JDIMENSION input_row,
+   JSAMPARRAY output_buf, int num_rows);
+EXTERN(void) jsimd_ycc_extxbgr_convert_altivec
+  (JDIMENSION out_width, JSAMPIMAGE input_buf, JDIMENSION input_row,
+   JSAMPARRAY output_buf, int num_rows);
+EXTERN(void) jsimd_ycc_extxrgb_convert_altivec
+  (JDIMENSION out_width, JSAMPIMAGE input_buf, JDIMENSION input_row,
+   JSAMPARRAY output_buf, int num_rows);
+
+/* NULL Colorspace Conversion */
+EXTERN(void) jsimd_c_null_convert_dspr2
+  (JDIMENSION img_width, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+   JDIMENSION output_row, int num_rows, int num_components);
+
+/* h2v1 Downsampling */
+EXTERN(void) jsimd_h2v1_downsample_mmx
+  (JDIMENSION image_width, int max_v_samp_factor, JDIMENSION v_samp_factor,
+   JDIMENSION width_in_blocks, JSAMPARRAY input_data, JSAMPARRAY output_data);
+
+EXTERN(void) jsimd_h2v1_downsample_sse2
+  (JDIMENSION image_width, int max_v_samp_factor, JDIMENSION v_samp_factor,
+   JDIMENSION width_in_blocks, JSAMPARRAY input_data, JSAMPARRAY output_data);
+
+EXTERN(void) jsimd_h2v1_downsample_avx2
+  (JDIMENSION image_width, int max_v_samp_factor, JDIMENSION v_samp_factor,
+   JDIMENSION width_in_blocks, JSAMPARRAY input_data, JSAMPARRAY output_data);
+
+EXTERN(void) jsimd_h2v1_downsample_neon
+  (JDIMENSION image_width, int max_v_samp_factor, JDIMENSION v_samp_factor,
+   JDIMENSION width_in_blocks, JSAMPARRAY input_data, JSAMPARRAY output_data);
+
+EXTERN(void) jsimd_h2v1_downsample_dspr2
+  (JDIMENSION image_width, int max_v_samp_factor, JDIMENSION v_samp_factor,
+   JDIMENSION width_in_blocks, JSAMPARRAY input_data, JSAMPARRAY output_data);
+
+EXTERN(void) jsimd_h2v1_downsample_altivec
+  (JDIMENSION image_width, int max_v_samp_factor, JDIMENSION v_samp_factor,
+   JDIMENSION width_in_blocks, JSAMPARRAY input_data, JSAMPARRAY output_data);
+
+/* h2v2 Downsampling */
+EXTERN(void) jsimd_h2v2_downsample_mmx
+  (JDIMENSION image_width, int max_v_samp_factor, JDIMENSION v_samp_factor,
+   JDIMENSION width_in_blocks, JSAMPARRAY input_data, JSAMPARRAY output_data);
+
+EXTERN(void) jsimd_h2v2_downsample_sse2
+  (JDIMENSION image_width, int max_v_samp_factor, JDIMENSION v_samp_factor,
+   JDIMENSION width_in_blocks, JSAMPARRAY input_data, JSAMPARRAY output_data);
+
+EXTERN(void) jsimd_h2v2_downsample_avx2
+  (JDIMENSION image_width, int max_v_samp_factor, JDIMENSION v_samp_factor,
+   JDIMENSION width_in_blocks, JSAMPARRAY input_data, JSAMPARRAY output_data);
+
+EXTERN(void) jsimd_h2v2_downsample_neon
+  (JDIMENSION image_width, int max_v_samp_factor, JDIMENSION v_samp_factor,
+   JDIMENSION width_in_blocks, JSAMPARRAY input_data, JSAMPARRAY output_data);
+
+EXTERN(void) jsimd_h2v2_downsample_dspr2
+  (JDIMENSION image_width, int max_v_samp_factor, JDIMENSION v_samp_factor,
+   JDIMENSION width_in_blocks, JSAMPARRAY input_data, JSAMPARRAY output_data);
+
+EXTERN(void) jsimd_h2v2_downsample_mmi
+  (JDIMENSION image_width, int max_v_samp_factor, JDIMENSION v_samp_factor,
+   JDIMENSION width_in_blocks, JSAMPARRAY input_data, JSAMPARRAY output_data);
+
+EXTERN(void) jsimd_h2v2_downsample_altivec
+  (JDIMENSION image_width, int max_v_samp_factor, JDIMENSION v_samp_factor,
+   JDIMENSION width_in_blocks, JSAMPARRAY input_data, JSAMPARRAY output_data);
+
+/* h2v2 Smooth Downsampling */
+EXTERN(void) jsimd_h2v2_smooth_downsample_dspr2
+  (JSAMPARRAY input_data, JSAMPARRAY output_data, JDIMENSION v_samp_factor,
+   int max_v_samp_factor, int smoothing_factor, JDIMENSION width_in_blocks,
+   JDIMENSION image_width);
+
+
+/* Upsampling */
+EXTERN(void) jsimd_h2v1_upsample_mmx
+  (int max_v_samp_factor, JDIMENSION output_width, JSAMPARRAY input_data,
+   JSAMPARRAY *output_data_ptr);
+EXTERN(void) jsimd_h2v2_upsample_mmx
+  (int max_v_samp_factor, JDIMENSION output_width, JSAMPARRAY input_data,
+   JSAMPARRAY *output_data_ptr);
+
+EXTERN(void) jsimd_h2v1_upsample_sse2
+  (int max_v_samp_factor, JDIMENSION output_width, JSAMPARRAY input_data,
+   JSAMPARRAY *output_data_ptr);
+EXTERN(void) jsimd_h2v2_upsample_sse2
+  (int max_v_samp_factor, JDIMENSION output_width, JSAMPARRAY input_data,
+   JSAMPARRAY *output_data_ptr);
+
+EXTERN(void) jsimd_h2v1_upsample_avx2
+  (int max_v_samp_factor, JDIMENSION output_width, JSAMPARRAY input_data,
+   JSAMPARRAY *output_data_ptr);
+EXTERN(void) jsimd_h2v2_upsample_avx2
+  (int max_v_samp_factor, JDIMENSION output_width, JSAMPARRAY input_data,
+   JSAMPARRAY *output_data_ptr);
+
+EXTERN(void) jsimd_h2v1_upsample_neon
+  (int max_v_samp_factor, JDIMENSION output_width, JSAMPARRAY input_data,
+   JSAMPARRAY *output_data_ptr);
+EXTERN(void) jsimd_h2v2_upsample_neon
+  (int max_v_samp_factor, JDIMENSION output_width, JSAMPARRAY input_data,
+   JSAMPARRAY *output_data_ptr);
+
+EXTERN(void) jsimd_h2v1_upsample_dspr2
+  (int max_v_samp_factor, JDIMENSION output_width, JSAMPARRAY input_data,
+   JSAMPARRAY *output_data_ptr);
+EXTERN(void) jsimd_h2v2_upsample_dspr2
+  (int max_v_samp_factor, JDIMENSION output_width, JSAMPARRAY input_data,
+   JSAMPARRAY *output_data_ptr);
+
+EXTERN(void) jsimd_int_upsample_dspr2
+  (UINT8 h_expand, UINT8 v_expand, JSAMPARRAY input_data,
+   JSAMPARRAY *output_data_ptr, JDIMENSION output_width,
+   int max_v_samp_factor);
+
+EXTERN(void) jsimd_h2v1_upsample_altivec
+  (int max_v_samp_factor, JDIMENSION output_width, JSAMPARRAY input_data,
+   JSAMPARRAY *output_data_ptr);
+EXTERN(void) jsimd_h2v2_upsample_altivec
+  (int max_v_samp_factor, JDIMENSION output_width, JSAMPARRAY input_data,
+   JSAMPARRAY *output_data_ptr);
+
+/* Fancy Upsampling */
+EXTERN(void) jsimd_h2v1_fancy_upsample_mmx
+  (int max_v_samp_factor, JDIMENSION downsampled_width, JSAMPARRAY input_data,
+   JSAMPARRAY *output_data_ptr);
+EXTERN(void) jsimd_h2v2_fancy_upsample_mmx
+  (int max_v_samp_factor, JDIMENSION downsampled_width, JSAMPARRAY input_data,
+   JSAMPARRAY *output_data_ptr);
+
+extern const int jconst_fancy_upsample_sse2[];
+EXTERN(void) jsimd_h2v1_fancy_upsample_sse2
+  (int max_v_samp_factor, JDIMENSION downsampled_width, JSAMPARRAY input_data,
+   JSAMPARRAY *output_data_ptr);
+EXTERN(void) jsimd_h2v2_fancy_upsample_sse2
+  (int max_v_samp_factor, JDIMENSION downsampled_width, JSAMPARRAY input_data,
+   JSAMPARRAY *output_data_ptr);
+
+extern const int jconst_fancy_upsample_avx2[];
+EXTERN(void) jsimd_h2v1_fancy_upsample_avx2
+  (int max_v_samp_factor, JDIMENSION downsampled_width, JSAMPARRAY input_data,
+   JSAMPARRAY *output_data_ptr);
+EXTERN(void) jsimd_h2v2_fancy_upsample_avx2
+  (int max_v_samp_factor, JDIMENSION downsampled_width, JSAMPARRAY input_data,
+   JSAMPARRAY *output_data_ptr);
+
+EXTERN(void) jsimd_h2v1_fancy_upsample_neon
+  (int max_v_samp_factor, JDIMENSION downsampled_width, JSAMPARRAY input_data,
+   JSAMPARRAY *output_data_ptr);
+EXTERN(void) jsimd_h2v2_fancy_upsample_neon
+  (int max_v_samp_factor, JDIMENSION downsampled_width, JSAMPARRAY input_data,
+   JSAMPARRAY *output_data_ptr);
+EXTERN(void) jsimd_h1v2_fancy_upsample_neon
+  (int max_v_samp_factor, JDIMENSION downsampled_width, JSAMPARRAY input_data,
+   JSAMPARRAY *output_data_ptr);
+
+EXTERN(void) jsimd_h2v1_fancy_upsample_dspr2
+  (int max_v_samp_factor, JDIMENSION downsampled_width, JSAMPARRAY input_data,
+   JSAMPARRAY *output_data_ptr);
+EXTERN(void) jsimd_h2v2_fancy_upsample_dspr2
+  (int max_v_samp_factor, JDIMENSION downsampled_width, JSAMPARRAY input_data,
+   JSAMPARRAY *output_data_ptr);
+
+EXTERN(void) jsimd_h2v1_fancy_upsample_mmi
+  (int max_v_samp_factor, JDIMENSION downsampled_width, JSAMPARRAY input_data,
+   JSAMPARRAY *output_data_ptr);
+EXTERN(void) jsimd_h2v2_fancy_upsample_mmi
+  (int max_v_samp_factor, JDIMENSION downsampled_width, JSAMPARRAY input_data,
+   JSAMPARRAY *output_data_ptr);
+
+EXTERN(void) jsimd_h2v1_fancy_upsample_altivec
+  (int max_v_samp_factor, JDIMENSION downsampled_width, JSAMPARRAY input_data,
+   JSAMPARRAY *output_data_ptr);
+EXTERN(void) jsimd_h2v2_fancy_upsample_altivec
+  (int max_v_samp_factor, JDIMENSION downsampled_width, JSAMPARRAY input_data,
+   JSAMPARRAY *output_data_ptr);
+
+/* Merged Upsampling */
+EXTERN(void) jsimd_h2v1_merged_upsample_mmx
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf);
+EXTERN(void) jsimd_h2v1_extrgb_merged_upsample_mmx
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf);
+EXTERN(void) jsimd_h2v1_extrgbx_merged_upsample_mmx
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf);
+EXTERN(void) jsimd_h2v1_extbgr_merged_upsample_mmx
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf);
+EXTERN(void) jsimd_h2v1_extbgrx_merged_upsample_mmx
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf);
+EXTERN(void) jsimd_h2v1_extxbgr_merged_upsample_mmx
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf);
+EXTERN(void) jsimd_h2v1_extxrgb_merged_upsample_mmx
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf);
+
+EXTERN(void) jsimd_h2v2_merged_upsample_mmx
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf);
+EXTERN(void) jsimd_h2v2_extrgb_merged_upsample_mmx
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf);
+EXTERN(void) jsimd_h2v2_extrgbx_merged_upsample_mmx
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf);
+EXTERN(void) jsimd_h2v2_extbgr_merged_upsample_mmx
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf);
+EXTERN(void) jsimd_h2v2_extbgrx_merged_upsample_mmx
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf);
+EXTERN(void) jsimd_h2v2_extxbgr_merged_upsample_mmx
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf);
+EXTERN(void) jsimd_h2v2_extxrgb_merged_upsample_mmx
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf);
+
+extern const int jconst_merged_upsample_sse2[];
+EXTERN(void) jsimd_h2v1_merged_upsample_sse2
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf);
+EXTERN(void) jsimd_h2v1_extrgb_merged_upsample_sse2
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf);
+EXTERN(void) jsimd_h2v1_extrgbx_merged_upsample_sse2
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf);
+EXTERN(void) jsimd_h2v1_extbgr_merged_upsample_sse2
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf);
+EXTERN(void) jsimd_h2v1_extbgrx_merged_upsample_sse2
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf);
+EXTERN(void) jsimd_h2v1_extxbgr_merged_upsample_sse2
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf);
+EXTERN(void) jsimd_h2v1_extxrgb_merged_upsample_sse2
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf);
+
+EXTERN(void) jsimd_h2v2_merged_upsample_sse2
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf);
+EXTERN(void) jsimd_h2v2_extrgb_merged_upsample_sse2
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf);
+EXTERN(void) jsimd_h2v2_extrgbx_merged_upsample_sse2
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf);
+EXTERN(void) jsimd_h2v2_extbgr_merged_upsample_sse2
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf);
+EXTERN(void) jsimd_h2v2_extbgrx_merged_upsample_sse2
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf);
+EXTERN(void) jsimd_h2v2_extxbgr_merged_upsample_sse2
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf);
+EXTERN(void) jsimd_h2v2_extxrgb_merged_upsample_sse2
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf);
+
+extern const int jconst_merged_upsample_avx2[];
+EXTERN(void) jsimd_h2v1_merged_upsample_avx2
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf);
+EXTERN(void) jsimd_h2v1_extrgb_merged_upsample_avx2
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf);
+EXTERN(void) jsimd_h2v1_extrgbx_merged_upsample_avx2
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf);
+EXTERN(void) jsimd_h2v1_extbgr_merged_upsample_avx2
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf);
+EXTERN(void) jsimd_h2v1_extbgrx_merged_upsample_avx2
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf);
+EXTERN(void) jsimd_h2v1_extxbgr_merged_upsample_avx2
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf);
+EXTERN(void) jsimd_h2v1_extxrgb_merged_upsample_avx2
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf);
+
+EXTERN(void) jsimd_h2v2_merged_upsample_avx2
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf);
+EXTERN(void) jsimd_h2v2_extrgb_merged_upsample_avx2
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf);
+EXTERN(void) jsimd_h2v2_extrgbx_merged_upsample_avx2
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf);
+EXTERN(void) jsimd_h2v2_extbgr_merged_upsample_avx2
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf);
+EXTERN(void) jsimd_h2v2_extbgrx_merged_upsample_avx2
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf);
+EXTERN(void) jsimd_h2v2_extxbgr_merged_upsample_avx2
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf);
+EXTERN(void) jsimd_h2v2_extxrgb_merged_upsample_avx2
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf);
+
+EXTERN(void) jsimd_h2v1_merged_upsample_neon
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf);
+EXTERN(void) jsimd_h2v1_extrgb_merged_upsample_neon
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf);
+EXTERN(void) jsimd_h2v1_extrgbx_merged_upsample_neon
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf);
+EXTERN(void) jsimd_h2v1_extbgr_merged_upsample_neon
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf);
+EXTERN(void) jsimd_h2v1_extbgrx_merged_upsample_neon
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf);
+EXTERN(void) jsimd_h2v1_extxbgr_merged_upsample_neon
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf);
+EXTERN(void) jsimd_h2v1_extxrgb_merged_upsample_neon
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf);
+
+EXTERN(void) jsimd_h2v2_merged_upsample_neon
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf);
+EXTERN(void) jsimd_h2v2_extrgb_merged_upsample_neon
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf);
+EXTERN(void) jsimd_h2v2_extrgbx_merged_upsample_neon
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf);
+EXTERN(void) jsimd_h2v2_extbgr_merged_upsample_neon
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf);
+EXTERN(void) jsimd_h2v2_extbgrx_merged_upsample_neon
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf);
+EXTERN(void) jsimd_h2v2_extxbgr_merged_upsample_neon
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf);
+EXTERN(void) jsimd_h2v2_extxrgb_merged_upsample_neon
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf);
+
+EXTERN(void) jsimd_h2v1_merged_upsample_dspr2
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf, JSAMPLE *range);
+EXTERN(void) jsimd_h2v1_extrgb_merged_upsample_dspr2
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf, JSAMPLE *range);
+EXTERN(void) jsimd_h2v1_extrgbx_merged_upsample_dspr2
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf, JSAMPLE *range);
+EXTERN(void) jsimd_h2v1_extbgr_merged_upsample_dspr2
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf, JSAMPLE *range);
+EXTERN(void) jsimd_h2v1_extbgrx_merged_upsample_dspr2
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf, JSAMPLE *range);
+EXTERN(void) jsimd_h2v1_extxbgr_merged_upsample_dspr2
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf, JSAMPLE *range);
+EXTERN(void) jsimd_h2v1_extxrgb_merged_upsample_dspr2
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf, JSAMPLE *range);
+
+EXTERN(void) jsimd_h2v2_merged_upsample_dspr2
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf, JSAMPLE *range);
+EXTERN(void) jsimd_h2v2_extrgb_merged_upsample_dspr2
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf, JSAMPLE *range);
+EXTERN(void) jsimd_h2v2_extrgbx_merged_upsample_dspr2
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf, JSAMPLE *range);
+EXTERN(void) jsimd_h2v2_extbgr_merged_upsample_dspr2
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf, JSAMPLE *range);
+EXTERN(void) jsimd_h2v2_extbgrx_merged_upsample_dspr2
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf, JSAMPLE *range);
+EXTERN(void) jsimd_h2v2_extxbgr_merged_upsample_dspr2
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf, JSAMPLE *range);
+EXTERN(void) jsimd_h2v2_extxrgb_merged_upsample_dspr2
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf, JSAMPLE *range);
+
+EXTERN(void) jsimd_h2v1_merged_upsample_mmi
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf);
+EXTERN(void) jsimd_h2v1_extrgb_merged_upsample_mmi
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf);
+EXTERN(void) jsimd_h2v1_extrgbx_merged_upsample_mmi
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf);
+EXTERN(void) jsimd_h2v1_extbgr_merged_upsample_mmi
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf);
+EXTERN(void) jsimd_h2v1_extbgrx_merged_upsample_mmi
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf);
+EXTERN(void) jsimd_h2v1_extxbgr_merged_upsample_mmi
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf);
+EXTERN(void) jsimd_h2v1_extxrgb_merged_upsample_mmi
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf);
+
+EXTERN(void) jsimd_h2v2_merged_upsample_mmi
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf);
+EXTERN(void) jsimd_h2v2_extrgb_merged_upsample_mmi
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf);
+EXTERN(void) jsimd_h2v2_extrgbx_merged_upsample_mmi
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf);
+EXTERN(void) jsimd_h2v2_extbgr_merged_upsample_mmi
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf);
+EXTERN(void) jsimd_h2v2_extbgrx_merged_upsample_mmi
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf);
+EXTERN(void) jsimd_h2v2_extxbgr_merged_upsample_mmi
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf);
+EXTERN(void) jsimd_h2v2_extxrgb_merged_upsample_mmi
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf);
+
+EXTERN(void) jsimd_h2v1_merged_upsample_altivec
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf);
+EXTERN(void) jsimd_h2v1_extrgb_merged_upsample_altivec
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf);
+EXTERN(void) jsimd_h2v1_extrgbx_merged_upsample_altivec
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf);
+EXTERN(void) jsimd_h2v1_extbgr_merged_upsample_altivec
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf);
+EXTERN(void) jsimd_h2v1_extbgrx_merged_upsample_altivec
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf);
+EXTERN(void) jsimd_h2v1_extxbgr_merged_upsample_altivec
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf);
+EXTERN(void) jsimd_h2v1_extxrgb_merged_upsample_altivec
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf);
+
+EXTERN(void) jsimd_h2v2_merged_upsample_altivec
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf);
+EXTERN(void) jsimd_h2v2_extrgb_merged_upsample_altivec
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf);
+EXTERN(void) jsimd_h2v2_extrgbx_merged_upsample_altivec
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf);
+EXTERN(void) jsimd_h2v2_extbgr_merged_upsample_altivec
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf);
+EXTERN(void) jsimd_h2v2_extbgrx_merged_upsample_altivec
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf);
+EXTERN(void) jsimd_h2v2_extxbgr_merged_upsample_altivec
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf);
+EXTERN(void) jsimd_h2v2_extxrgb_merged_upsample_altivec
+  (JDIMENSION output_width, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+   JSAMPARRAY output_buf);
+
+/* Sample Conversion */
+EXTERN(void) jsimd_convsamp_mmx
+  (JSAMPARRAY sample_data, JDIMENSION start_col, DCTELEM *workspace);
+
+EXTERN(void) jsimd_convsamp_sse2
+  (JSAMPARRAY sample_data, JDIMENSION start_col, DCTELEM *workspace);
+
+EXTERN(void) jsimd_convsamp_avx2
+  (JSAMPARRAY sample_data, JDIMENSION start_col, DCTELEM *workspace);
+
+EXTERN(void) jsimd_convsamp_neon
+  (JSAMPARRAY sample_data, JDIMENSION start_col, DCTELEM *workspace);
+
+EXTERN(void) jsimd_convsamp_dspr2
+  (JSAMPARRAY sample_data, JDIMENSION start_col, DCTELEM *workspace);
+
+EXTERN(void) jsimd_convsamp_altivec
+  (JSAMPARRAY sample_data, JDIMENSION start_col, DCTELEM *workspace);
+
+/* Floating Point Sample Conversion */
+EXTERN(void) jsimd_convsamp_float_3dnow
+  (JSAMPARRAY sample_data, JDIMENSION start_col, FAST_FLOAT *workspace);
+
+EXTERN(void) jsimd_convsamp_float_sse
+  (JSAMPARRAY sample_data, JDIMENSION start_col, FAST_FLOAT *workspace);
+
+EXTERN(void) jsimd_convsamp_float_sse2
+  (JSAMPARRAY sample_data, JDIMENSION start_col, FAST_FLOAT *workspace);
+
+EXTERN(void) jsimd_convsamp_float_dspr2
+  (JSAMPARRAY sample_data, JDIMENSION start_col, FAST_FLOAT *workspace);
+
+/* Accurate Integer Forward DCT */
+EXTERN(void) jsimd_fdct_islow_mmx(DCTELEM *data);
+
+extern const int jconst_fdct_islow_sse2[];
+EXTERN(void) jsimd_fdct_islow_sse2(DCTELEM *data);
+
+extern const int jconst_fdct_islow_avx2[];
+EXTERN(void) jsimd_fdct_islow_avx2(DCTELEM *data);
+
+EXTERN(void) jsimd_fdct_islow_neon(DCTELEM *data);
+
+EXTERN(void) jsimd_fdct_islow_dspr2(DCTELEM *data);
+
+EXTERN(void) jsimd_fdct_islow_mmi(DCTELEM *data);
+
+EXTERN(void) jsimd_fdct_islow_altivec(DCTELEM *data);
+
+/* Fast Integer Forward DCT */
+EXTERN(void) jsimd_fdct_ifast_mmx(DCTELEM *data);
+
+extern const int jconst_fdct_ifast_sse2[];
+EXTERN(void) jsimd_fdct_ifast_sse2(DCTELEM *data);
+
+EXTERN(void) jsimd_fdct_ifast_neon(DCTELEM *data);
+
+EXTERN(void) jsimd_fdct_ifast_dspr2(DCTELEM *data);
+
+EXTERN(void) jsimd_fdct_ifast_mmi(DCTELEM *data);
+
+EXTERN(void) jsimd_fdct_ifast_altivec(DCTELEM *data);
+
+/* Floating Point Forward DCT */
+EXTERN(void) jsimd_fdct_float_3dnow(FAST_FLOAT *data);
+
+extern const int jconst_fdct_float_sse[];
+EXTERN(void) jsimd_fdct_float_sse(FAST_FLOAT *data);
+
+/* Quantization */
+EXTERN(void) jsimd_quantize_mmx
+  (JCOEFPTR coef_block, DCTELEM *divisors, DCTELEM *workspace);
+
+EXTERN(void) jsimd_quantize_sse2
+  (JCOEFPTR coef_block, DCTELEM *divisors, DCTELEM *workspace);
+
+EXTERN(void) jsimd_quantize_avx2
+  (JCOEFPTR coef_block, DCTELEM *divisors, DCTELEM *workspace);
+
+EXTERN(void) jsimd_quantize_neon
+  (JCOEFPTR coef_block, DCTELEM *divisors, DCTELEM *workspace);
+
+EXTERN(void) jsimd_quantize_dspr2
+  (JCOEFPTR coef_block, DCTELEM *divisors, DCTELEM *workspace);
+
+EXTERN(void) jsimd_quantize_mmi
+  (JCOEFPTR coef_block, DCTELEM *divisors, DCTELEM *workspace);
+
+EXTERN(void) jsimd_quantize_altivec
+  (JCOEFPTR coef_block, DCTELEM *divisors, DCTELEM *workspace);
+
+/* Floating Point Quantization */
+EXTERN(void) jsimd_quantize_float_3dnow
+  (JCOEFPTR coef_block, FAST_FLOAT *divisors, FAST_FLOAT *workspace);
+
+EXTERN(void) jsimd_quantize_float_sse
+  (JCOEFPTR coef_block, FAST_FLOAT *divisors, FAST_FLOAT *workspace);
+
+EXTERN(void) jsimd_quantize_float_sse2
+  (JCOEFPTR coef_block, FAST_FLOAT *divisors, FAST_FLOAT *workspace);
+
+EXTERN(void) jsimd_quantize_float_dspr2
+  (JCOEFPTR coef_block, FAST_FLOAT *divisors, FAST_FLOAT *workspace);
+
+/* Scaled Inverse DCT */
+EXTERN(void) jsimd_idct_2x2_mmx
+  (void *dct_table, JCOEFPTR coef_block, JSAMPARRAY output_buf,
+   JDIMENSION output_col);
+EXTERN(void) jsimd_idct_4x4_mmx
+  (void *dct_table, JCOEFPTR coef_block, JSAMPARRAY output_buf,
+   JDIMENSION output_col);
+
+extern const int jconst_idct_red_sse2[];
+EXTERN(void) jsimd_idct_2x2_sse2
+  (void *dct_table, JCOEFPTR coef_block, JSAMPARRAY output_buf,
+   JDIMENSION output_col);
+EXTERN(void) jsimd_idct_4x4_sse2
+  (void *dct_table, JCOEFPTR coef_block, JSAMPARRAY output_buf,
+   JDIMENSION output_col);
+
+EXTERN(void) jsimd_idct_2x2_neon
+  (void *dct_table, JCOEFPTR coef_block, JSAMPARRAY output_buf,
+   JDIMENSION output_col);
+EXTERN(void) jsimd_idct_4x4_neon
+  (void *dct_table, JCOEFPTR coef_block, JSAMPARRAY output_buf,
+   JDIMENSION output_col);
+
+EXTERN(void) jsimd_idct_2x2_dspr2
+  (void *dct_table, JCOEFPTR coef_block, JSAMPARRAY output_buf,
+   JDIMENSION output_col);
+EXTERN(void) jsimd_idct_4x4_dspr2
+  (void *dct_table, JCOEFPTR coef_block, JSAMPARRAY output_buf,
+   JDIMENSION output_col, int *workspace);
+EXTERN(void) jsimd_idct_6x6_dspr2
+  (void *dct_table, JCOEFPTR coef_block, JSAMPARRAY output_buf,
+   JDIMENSION output_col);
+EXTERN(void) jsimd_idct_12x12_pass1_dspr2
+  (JCOEFPTR coef_block, void *dct_table, int *workspace);
+EXTERN(void) jsimd_idct_12x12_pass2_dspr2
+  (int *workspace, int *output);
+
+/* Accurate Integer Inverse DCT */
+EXTERN(void) jsimd_idct_islow_mmx
+  (void *dct_table, JCOEFPTR coef_block, JSAMPARRAY output_buf,
+   JDIMENSION output_col);
+
+extern const int jconst_idct_islow_sse2[];
+EXTERN(void) jsimd_idct_islow_sse2
+  (void *dct_table, JCOEFPTR coef_block, JSAMPARRAY output_buf,
+   JDIMENSION output_col);
+
+extern const int jconst_idct_islow_avx2[];
+EXTERN(void) jsimd_idct_islow_avx2
+  (void *dct_table, JCOEFPTR coef_block, JSAMPARRAY output_buf,
+   JDIMENSION output_col);
+
+EXTERN(void) jsimd_idct_islow_neon
+  (void *dct_table, JCOEFPTR coef_block, JSAMPARRAY output_buf,
+   JDIMENSION output_col);
+
+EXTERN(void) jsimd_idct_islow_dspr2
+  (void *dct_table, JCOEFPTR coef_block, int *output_buf, JSAMPLE *output_col);
+
+EXTERN(void) jsimd_idct_islow_mmi
+  (void *dct_table, JCOEFPTR coef_block, JSAMPARRAY output_buf,
+   JDIMENSION output_col);
+
+EXTERN(void) jsimd_idct_islow_altivec
+  (void *dct_table, JCOEFPTR coef_block, JSAMPARRAY output_buf,
+   JDIMENSION output_col);
+
+/* Fast Integer Inverse DCT */
+EXTERN(void) jsimd_idct_ifast_mmx
+  (void *dct_table, JCOEFPTR coef_block, JSAMPARRAY output_buf,
+   JDIMENSION output_col);
+
+extern const int jconst_idct_ifast_sse2[];
+EXTERN(void) jsimd_idct_ifast_sse2
+  (void *dct_table, JCOEFPTR coef_block, JSAMPARRAY output_buf,
+   JDIMENSION output_col);
+
+EXTERN(void) jsimd_idct_ifast_neon
+  (void *dct_table, JCOEFPTR coef_block, JSAMPARRAY output_buf,
+   JDIMENSION output_col);
+
+EXTERN(void) jsimd_idct_ifast_cols_dspr2
+  (JCOEF *inptr, IFAST_MULT_TYPE *quantptr, DCTELEM *wsptr,
+   const int *idct_coefs);
+EXTERN(void) jsimd_idct_ifast_rows_dspr2
+  (DCTELEM *wsptr, JSAMPARRAY output_buf, JDIMENSION output_col,
+   const int *idct_coefs);
+
+EXTERN(void) jsimd_idct_ifast_mmi
+  (void *dct_table, JCOEFPTR coef_block, JSAMPARRAY output_buf,
+   JDIMENSION output_col);
+
+EXTERN(void) jsimd_idct_ifast_altivec
+  (void *dct_table, JCOEFPTR coef_block, JSAMPARRAY output_buf,
+   JDIMENSION output_col);
+
+/* Floating Point Inverse DCT */
+EXTERN(void) jsimd_idct_float_3dnow
+  (void *dct_table, JCOEFPTR coef_block, JSAMPARRAY output_buf,
+   JDIMENSION output_col);
+
+extern const int jconst_idct_float_sse[];
+EXTERN(void) jsimd_idct_float_sse
+  (void *dct_table, JCOEFPTR coef_block, JSAMPARRAY output_buf,
+   JDIMENSION output_col);
+
+extern const int jconst_idct_float_sse2[];
+EXTERN(void) jsimd_idct_float_sse2
+  (void *dct_table, JCOEFPTR coef_block, JSAMPARRAY output_buf,
+   JDIMENSION output_col);
+
+/* Huffman coding */
+extern const int jconst_huff_encode_one_block[];
+EXTERN(JOCTET *) jsimd_huff_encode_one_block_sse2
+  (void *state, JOCTET *buffer, JCOEFPTR block, int last_dc_val,
+   c_derived_tbl *dctbl, c_derived_tbl *actbl);
+
+EXTERN(JOCTET *) jsimd_huff_encode_one_block_neon
+  (void *state, JOCTET *buffer, JCOEFPTR block, int last_dc_val,
+   c_derived_tbl *dctbl, c_derived_tbl *actbl);
+
+#ifndef NEON_INTRINSICS
+
+EXTERN(JOCTET *) jsimd_huff_encode_one_block_neon_slowtbl
+  (void *state, JOCTET *buffer, JCOEFPTR block, int last_dc_val,
+   c_derived_tbl *dctbl, c_derived_tbl *actbl);
+
+#endif
+
+/* Progressive Huffman encoding */
+EXTERN(void) jsimd_encode_mcu_AC_first_prepare_sse2
+  (const JCOEF *block, const int *jpeg_natural_order_start, int Sl, int Al,
+   JCOEF *values, size_t *zerobits);
+
+EXTERN(void) jsimd_encode_mcu_AC_first_prepare_neon
+  (const JCOEF *block, const int *jpeg_natural_order_start, int Sl, int Al,
+   JCOEF *values, size_t *zerobits);
+
+EXTERN(int) jsimd_encode_mcu_AC_refine_prepare_sse2
+  (const JCOEF *block, const int *jpeg_natural_order_start, int Sl, int Al,
+   JCOEF *absvalues, size_t *bits);
+
+EXTERN(int) jsimd_encode_mcu_AC_refine_prepare_neon
+  (const JCOEF *block, const int *jpeg_natural_order_start, int Sl, int Al,
+   JCOEF *absvalues, size_t *bits);
diff --git a/3rdparty/libjpeg/src/simd/mips/jsimd.c b/3rdparty/libjpeg/src/simd/mips/jsimd.c
new file mode 100644
index 00000000..d2546eed
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/mips/jsimd.c
@@ -0,0 +1,1147 @@
+/*
+ * jsimd_mips.c
+ *
+ * Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+ * Copyright (C) 2009-2011, 2014, 2016, 2018, 2020, D. R. Commander.
+ * Copyright (C) 2013-2014, MIPS Technologies, Inc., California.
+ * Copyright (C) 2015-2016, 2018, Matthieu Darbois.
+ *
+ * Based on the x86 SIMD extension for IJG JPEG library,
+ * Copyright (C) 1999-2006, MIYASAKA Masaru.
+ * For conditions of distribution and use, see copyright notice in jsimdext.inc
+ *
+ * This file contains the interface between the "normal" portions
+ * of the library and the SIMD implementations when running on a
+ * MIPS architecture.
+ */
+
+#define JPEG_INTERNALS
+#include "../../jinclude.h"
+#include "../../jpeglib.h"
+#include "../../jsimd.h"
+#include "../../jdct.h"
+#include "../../jsimddct.h"
+#include "../jsimd.h"
+
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+
+static unsigned int simd_support = ~0;
+
+#if !(defined(__mips_dsp) && (__mips_dsp_rev >= 2)) && defined(__linux__)
+
+LOCAL(void)
+parse_proc_cpuinfo(const char *search_string)
+{
+  const char *file_name = "/proc/cpuinfo";
+  char cpuinfo_line[256];
+  FILE *f = NULL;
+
+  simd_support = 0;
+
+  if ((f = fopen(file_name, "r")) != NULL) {
+    while (fgets(cpuinfo_line, sizeof(cpuinfo_line), f) != NULL) {
+      if (strstr(cpuinfo_line, search_string) != NULL) {
+        fclose(f);
+        simd_support |= JSIMD_DSPR2;
+        return;
+      }
+    }
+    fclose(f);
+  }
+  /* Did not find string in the proc file, or not Linux ELF. */
+}
+
+#endif
+
+/*
+ * Check what SIMD accelerations are supported.
+ *
+ * FIXME: This code is racy under a multi-threaded environment.
+ */
+LOCAL(void)
+init_simd(void)
+{
+#ifndef NO_GETENV
+  char *env = NULL;
+#endif
+
+  if (simd_support != ~0U)
+    return;
+
+  simd_support = 0;
+
+#if defined(__mips_dsp) && (__mips_dsp_rev >= 2)
+  simd_support |= JSIMD_DSPR2;
+#elif defined(__linux__)
+  /* We still have a chance to use MIPS DSPR2 regardless of globally used
+   * -mdspr2 options passed to gcc by performing runtime detection via
+   * /proc/cpuinfo parsing on linux */
+  parse_proc_cpuinfo("MIPS 74K");
+#endif
+
+#ifndef NO_GETENV
+  /* Force different settings through environment variables */
+  env = getenv("JSIMD_FORCEDSPR2");
+  if ((env != NULL) && (strcmp(env, "1") == 0))
+    simd_support = JSIMD_DSPR2;
+  env = getenv("JSIMD_FORCENONE");
+  if ((env != NULL) && (strcmp(env, "1") == 0))
+    simd_support = 0;
+#endif
+}
+
+static const int mips_idct_ifast_coefs[4] = {
+  0x45404540,           /* FIX( 1.082392200 / 2) =  17734 = 0x4546 */
+  0x5A805A80,           /* FIX( 1.414213562 / 2) =  23170 = 0x5A82 */
+  0x76407640,           /* FIX( 1.847759065 / 2) =  30274 = 0x7642 */
+  0xAC60AC60            /* FIX(-2.613125930 / 4) = -21407 = 0xAC61 */
+};
+
+/* The following struct is borrowed from jdsample.c */
+typedef void (*upsample1_ptr) (j_decompress_ptr cinfo,
+                               jpeg_component_info *compptr,
+                               JSAMPARRAY input_data,
+                               JSAMPARRAY *output_data_ptr);
+typedef struct {
+  struct jpeg_upsampler pub;
+  JSAMPARRAY color_buf[MAX_COMPONENTS];
+  upsample1_ptr methods[MAX_COMPONENTS];
+  int next_row_out;
+  JDIMENSION rows_to_go;
+  int rowgroup_height[MAX_COMPONENTS];
+  UINT8 h_expand[MAX_COMPONENTS];
+  UINT8 v_expand[MAX_COMPONENTS];
+} my_upsampler;
+
+typedef my_upsampler *my_upsample_ptr;
+
+GLOBAL(int)
+jsimd_can_rgb_ycc(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+  if ((RGB_PIXELSIZE != 3) && (RGB_PIXELSIZE != 4))
+    return 0;
+
+  if (simd_support & JSIMD_DSPR2)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_rgb_gray(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+  if ((RGB_PIXELSIZE != 3) && (RGB_PIXELSIZE != 4))
+    return 0;
+
+  if (simd_support & JSIMD_DSPR2)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_ycc_rgb(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+  if ((RGB_PIXELSIZE != 3) && (RGB_PIXELSIZE != 4))
+    return 0;
+
+  if (simd_support & JSIMD_DSPR2)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_ycc_rgb565(void)
+{
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_c_can_null_convert(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+
+  if (simd_support & JSIMD_DSPR2)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(void)
+jsimd_rgb_ycc_convert(j_compress_ptr cinfo, JSAMPARRAY input_buf,
+                      JSAMPIMAGE output_buf, JDIMENSION output_row,
+                      int num_rows)
+{
+  void (*dspr2fct) (JDIMENSION, JSAMPARRAY, JSAMPIMAGE, JDIMENSION, int);
+
+  switch (cinfo->in_color_space) {
+  case JCS_EXT_RGB:
+    dspr2fct = jsimd_extrgb_ycc_convert_dspr2;
+    break;
+  case JCS_EXT_RGBX:
+  case JCS_EXT_RGBA:
+    dspr2fct = jsimd_extrgbx_ycc_convert_dspr2;
+    break;
+  case JCS_EXT_BGR:
+    dspr2fct = jsimd_extbgr_ycc_convert_dspr2;
+    break;
+  case JCS_EXT_BGRX:
+  case JCS_EXT_BGRA:
+    dspr2fct = jsimd_extbgrx_ycc_convert_dspr2;
+    break;
+  case JCS_EXT_XBGR:
+  case JCS_EXT_ABGR:
+    dspr2fct = jsimd_extxbgr_ycc_convert_dspr2;
+    break;
+  case JCS_EXT_XRGB:
+  case JCS_EXT_ARGB:
+    dspr2fct = jsimd_extxrgb_ycc_convert_dspr2;
+    break;
+  default:
+    dspr2fct = jsimd_extrgb_ycc_convert_dspr2;
+    break;
+  }
+
+  dspr2fct(cinfo->image_width, input_buf, output_buf, output_row, num_rows);
+}
+
+GLOBAL(void)
+jsimd_rgb_gray_convert(j_compress_ptr cinfo, JSAMPARRAY input_buf,
+                       JSAMPIMAGE output_buf, JDIMENSION output_row,
+                       int num_rows)
+{
+  void (*dspr2fct) (JDIMENSION, JSAMPARRAY, JSAMPIMAGE, JDIMENSION, int);
+
+  switch (cinfo->in_color_space) {
+  case JCS_EXT_RGB:
+    dspr2fct = jsimd_extrgb_gray_convert_dspr2;
+    break;
+  case JCS_EXT_RGBX:
+  case JCS_EXT_RGBA:
+    dspr2fct = jsimd_extrgbx_gray_convert_dspr2;
+    break;
+  case JCS_EXT_BGR:
+    dspr2fct = jsimd_extbgr_gray_convert_dspr2;
+    break;
+  case JCS_EXT_BGRX:
+  case JCS_EXT_BGRA:
+    dspr2fct = jsimd_extbgrx_gray_convert_dspr2;
+    break;
+  case JCS_EXT_XBGR:
+  case JCS_EXT_ABGR:
+    dspr2fct = jsimd_extxbgr_gray_convert_dspr2;
+    break;
+  case JCS_EXT_XRGB:
+  case JCS_EXT_ARGB:
+    dspr2fct = jsimd_extxrgb_gray_convert_dspr2;
+    break;
+  default:
+    dspr2fct = jsimd_extrgb_gray_convert_dspr2;
+    break;
+  }
+
+  dspr2fct(cinfo->image_width, input_buf, output_buf, output_row, num_rows);
+}
+
+GLOBAL(void)
+jsimd_ycc_rgb_convert(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
+                      JDIMENSION input_row, JSAMPARRAY output_buf,
+                      int num_rows)
+{
+  void (*dspr2fct) (JDIMENSION, JSAMPIMAGE, JDIMENSION, JSAMPARRAY, int);
+
+  switch (cinfo->out_color_space) {
+  case JCS_EXT_RGB:
+    dspr2fct = jsimd_ycc_extrgb_convert_dspr2;
+    break;
+  case JCS_EXT_RGBX:
+  case JCS_EXT_RGBA:
+    dspr2fct = jsimd_ycc_extrgbx_convert_dspr2;
+    break;
+  case JCS_EXT_BGR:
+    dspr2fct = jsimd_ycc_extbgr_convert_dspr2;
+    break;
+  case JCS_EXT_BGRX:
+  case JCS_EXT_BGRA:
+    dspr2fct = jsimd_ycc_extbgrx_convert_dspr2;
+    break;
+  case JCS_EXT_XBGR:
+  case JCS_EXT_ABGR:
+    dspr2fct = jsimd_ycc_extxbgr_convert_dspr2;
+    break;
+  case JCS_EXT_XRGB:
+  case JCS_EXT_ARGB:
+    dspr2fct = jsimd_ycc_extxrgb_convert_dspr2;
+    break;
+  default:
+    dspr2fct = jsimd_ycc_extrgb_convert_dspr2;
+    break;
+  }
+
+  dspr2fct(cinfo->output_width, input_buf, input_row, output_buf, num_rows);
+}
+
+GLOBAL(void)
+jsimd_ycc_rgb565_convert(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
+                         JDIMENSION input_row, JSAMPARRAY output_buf,
+                         int num_rows)
+{
+}
+
+GLOBAL(void)
+jsimd_c_null_convert(j_compress_ptr cinfo, JSAMPARRAY input_buf,
+                     JSAMPIMAGE output_buf, JDIMENSION output_row,
+                     int num_rows)
+{
+  jsimd_c_null_convert_dspr2(cinfo->image_width, input_buf, output_buf,
+                             output_row, num_rows, cinfo->num_components);
+}
+
+GLOBAL(int)
+jsimd_can_h2v2_downsample(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+
+  /* FIXME: jsimd_h2v2_downsample_dspr2() fails some of the TJBench tiling
+   * regression tests, probably because the DSPr2 SIMD implementation predates
+   * those tests. */
+#if 0
+  if (simd_support & JSIMD_DSPR2)
+    return 1;
+#endif
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_h2v2_smooth_downsample(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+  if (DCTSIZE != 8)
+    return 0;
+
+  if (simd_support & JSIMD_DSPR2)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_h2v1_downsample(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+
+  /* FIXME: jsimd_h2v1_downsample_dspr2() fails some of the TJBench tiling
+   * regression tests, probably because the DSPr2 SIMD implementation predates
+   * those tests. */
+#if 0
+  if (simd_support & JSIMD_DSPR2)
+    return 1;
+#endif
+
+  return 0;
+}
+
+GLOBAL(void)
+jsimd_h2v2_downsample(j_compress_ptr cinfo, jpeg_component_info *compptr,
+                      JSAMPARRAY input_data, JSAMPARRAY output_data)
+{
+  jsimd_h2v2_downsample_dspr2(cinfo->image_width, cinfo->max_v_samp_factor,
+                              compptr->v_samp_factor, compptr->width_in_blocks,
+                              input_data, output_data);
+}
+
+GLOBAL(void)
+jsimd_h2v2_smooth_downsample(j_compress_ptr cinfo,
+                             jpeg_component_info *compptr,
+                             JSAMPARRAY input_data, JSAMPARRAY output_data)
+{
+  jsimd_h2v2_smooth_downsample_dspr2(input_data, output_data,
+                                     compptr->v_samp_factor,
+                                     cinfo->max_v_samp_factor,
+                                     cinfo->smoothing_factor,
+                                     compptr->width_in_blocks,
+                                     cinfo->image_width);
+}
+
+GLOBAL(void)
+jsimd_h2v1_downsample(j_compress_ptr cinfo, jpeg_component_info *compptr,
+                      JSAMPARRAY input_data, JSAMPARRAY output_data)
+{
+  jsimd_h2v1_downsample_dspr2(cinfo->image_width, cinfo->max_v_samp_factor,
+                              compptr->v_samp_factor, compptr->width_in_blocks,
+                              input_data, output_data);
+}
+
+GLOBAL(int)
+jsimd_can_h2v2_upsample(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+
+  if (simd_support & JSIMD_DSPR2)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_h2v1_upsample(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+
+#if defined(__MIPSEL__)
+  if (simd_support & JSIMD_DSPR2)
+    return 1;
+#endif
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_int_upsample(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+
+  if (simd_support & JSIMD_DSPR2)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(void)
+jsimd_h2v2_upsample(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+                    JSAMPARRAY input_data, JSAMPARRAY *output_data_ptr)
+{
+  jsimd_h2v2_upsample_dspr2(cinfo->max_v_samp_factor, cinfo->output_width,
+                            input_data, output_data_ptr);
+}
+
+GLOBAL(void)
+jsimd_h2v1_upsample(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+                    JSAMPARRAY input_data, JSAMPARRAY *output_data_ptr)
+{
+  jsimd_h2v1_upsample_dspr2(cinfo->max_v_samp_factor, cinfo->output_width,
+                            input_data, output_data_ptr);
+}
+
+GLOBAL(void)
+jsimd_int_upsample(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+                   JSAMPARRAY input_data, JSAMPARRAY *output_data_ptr)
+{
+  my_upsample_ptr upsample = (my_upsample_ptr)cinfo->upsample;
+
+  jsimd_int_upsample_dspr2(upsample->h_expand[compptr->component_index],
+                           upsample->v_expand[compptr->component_index],
+                           input_data, output_data_ptr, cinfo->output_width,
+                           cinfo->max_v_samp_factor);
+}
+
+GLOBAL(int)
+jsimd_can_h2v2_fancy_upsample(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+
+#if defined(__MIPSEL__)
+  if (simd_support & JSIMD_DSPR2)
+    return 1;
+#endif
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_h2v1_fancy_upsample(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+
+#if defined(__MIPSEL__)
+  if (simd_support & JSIMD_DSPR2)
+    return 1;
+#endif
+
+  return 0;
+}
+
+GLOBAL(void)
+jsimd_h2v2_fancy_upsample(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+                          JSAMPARRAY input_data, JSAMPARRAY *output_data_ptr)
+{
+  jsimd_h2v2_fancy_upsample_dspr2(cinfo->max_v_samp_factor,
+                                  compptr->downsampled_width, input_data,
+                                  output_data_ptr);
+}
+
+GLOBAL(void)
+jsimd_h2v1_fancy_upsample(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+                          JSAMPARRAY input_data, JSAMPARRAY *output_data_ptr)
+{
+  jsimd_h2v1_fancy_upsample_dspr2(cinfo->max_v_samp_factor,
+                                  compptr->downsampled_width, input_data,
+                                  output_data_ptr);
+}
+
+GLOBAL(int)
+jsimd_can_h2v2_merged_upsample(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+
+  if (simd_support & JSIMD_DSPR2)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_h2v1_merged_upsample(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+
+  if (simd_support & JSIMD_DSPR2)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(void)
+jsimd_h2v2_merged_upsample(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
+                           JDIMENSION in_row_group_ctr, JSAMPARRAY output_buf)
+{
+  void (*dspr2fct) (JDIMENSION, JSAMPIMAGE, JDIMENSION, JSAMPARRAY, JSAMPLE *);
+
+  switch (cinfo->out_color_space) {
+  case JCS_EXT_RGB:
+    dspr2fct = jsimd_h2v2_extrgb_merged_upsample_dspr2;
+    break;
+  case JCS_EXT_RGBX:
+  case JCS_EXT_RGBA:
+    dspr2fct = jsimd_h2v2_extrgbx_merged_upsample_dspr2;
+    break;
+  case JCS_EXT_BGR:
+    dspr2fct = jsimd_h2v2_extbgr_merged_upsample_dspr2;
+    break;
+  case JCS_EXT_BGRX:
+  case JCS_EXT_BGRA:
+    dspr2fct = jsimd_h2v2_extbgrx_merged_upsample_dspr2;
+    break;
+  case JCS_EXT_XBGR:
+  case JCS_EXT_ABGR:
+    dspr2fct = jsimd_h2v2_extxbgr_merged_upsample_dspr2;
+    break;
+  case JCS_EXT_XRGB:
+  case JCS_EXT_ARGB:
+    dspr2fct = jsimd_h2v2_extxrgb_merged_upsample_dspr2;
+    break;
+  default:
+    dspr2fct = jsimd_h2v2_extrgb_merged_upsample_dspr2;
+    break;
+  }
+
+  dspr2fct(cinfo->output_width, input_buf, in_row_group_ctr, output_buf,
+           cinfo->sample_range_limit);
+}
+
+GLOBAL(void)
+jsimd_h2v1_merged_upsample(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
+                           JDIMENSION in_row_group_ctr, JSAMPARRAY output_buf)
+{
+  void (*dspr2fct) (JDIMENSION, JSAMPIMAGE, JDIMENSION, JSAMPARRAY, JSAMPLE *);
+
+  switch (cinfo->out_color_space) {
+  case JCS_EXT_RGB:
+    dspr2fct = jsimd_h2v1_extrgb_merged_upsample_dspr2;
+    break;
+  case JCS_EXT_RGBX:
+  case JCS_EXT_RGBA:
+    dspr2fct = jsimd_h2v1_extrgbx_merged_upsample_dspr2;
+    break;
+  case JCS_EXT_BGR:
+    dspr2fct = jsimd_h2v1_extbgr_merged_upsample_dspr2;
+    break;
+  case JCS_EXT_BGRX:
+  case JCS_EXT_BGRA:
+    dspr2fct = jsimd_h2v1_extbgrx_merged_upsample_dspr2;
+    break;
+  case JCS_EXT_XBGR:
+  case JCS_EXT_ABGR:
+    dspr2fct = jsimd_h2v1_extxbgr_merged_upsample_dspr2;
+    break;
+  case JCS_EXT_XRGB:
+  case JCS_EXT_ARGB:
+    dspr2fct = jsimd_h2v1_extxrgb_merged_upsample_dspr2;
+    break;
+  default:
+    dspr2fct = jsimd_h2v1_extrgb_merged_upsample_dspr2;
+    break;
+  }
+
+  dspr2fct(cinfo->output_width, input_buf, in_row_group_ctr, output_buf,
+           cinfo->sample_range_limit);
+}
+
+GLOBAL(int)
+jsimd_can_convsamp(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (DCTSIZE != 8)
+    return 0;
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+  if (sizeof(DCTELEM) != 2)
+    return 0;
+
+#if defined(__MIPSEL__)
+  if (simd_support & JSIMD_DSPR2)
+    return 1;
+#endif
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_convsamp_float(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (DCTSIZE != 8)
+    return 0;
+  if (sizeof(JCOEF) != 2)
+    return 0;
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+  if (sizeof(ISLOW_MULT_TYPE) != 2)
+    return 0;
+
+#ifndef __mips_soft_float
+  if (simd_support & JSIMD_DSPR2)
+    return 1;
+#endif
+
+  return 0;
+}
+
+GLOBAL(void)
+jsimd_convsamp(JSAMPARRAY sample_data, JDIMENSION start_col,
+               DCTELEM *workspace)
+{
+  jsimd_convsamp_dspr2(sample_data, start_col, workspace);
+}
+
+GLOBAL(void)
+jsimd_convsamp_float(JSAMPARRAY sample_data, JDIMENSION start_col,
+                     FAST_FLOAT *workspace)
+{
+#ifndef __mips_soft_float
+  jsimd_convsamp_float_dspr2(sample_data, start_col, workspace);
+#endif
+}
+
+GLOBAL(int)
+jsimd_can_fdct_islow(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (DCTSIZE != 8)
+    return 0;
+  if (sizeof(DCTELEM) != 2)
+    return 0;
+
+#if defined(__MIPSEL__)
+  if (simd_support & JSIMD_DSPR2)
+    return 1;
+#endif
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_fdct_ifast(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (DCTSIZE != 8)
+    return 0;
+  if (sizeof(DCTELEM) != 2)
+    return 0;
+
+#if defined(__MIPSEL__)
+  if (simd_support & JSIMD_DSPR2)
+    return 1;
+#endif
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_fdct_float(void)
+{
+  return 0;
+}
+
+GLOBAL(void)
+jsimd_fdct_islow(DCTELEM *data)
+{
+  jsimd_fdct_islow_dspr2(data);
+}
+
+GLOBAL(void)
+jsimd_fdct_ifast(DCTELEM *data)
+{
+  jsimd_fdct_ifast_dspr2(data);
+}
+
+GLOBAL(void)
+jsimd_fdct_float(FAST_FLOAT *data)
+{
+}
+
+GLOBAL(int)
+jsimd_can_quantize(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (DCTSIZE != 8)
+    return 0;
+  if (sizeof(JCOEF) != 2)
+    return 0;
+  if (sizeof(DCTELEM) != 2)
+    return 0;
+
+  if (simd_support & JSIMD_DSPR2)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_quantize_float(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (DCTSIZE != 8)
+    return 0;
+  if (sizeof(JCOEF) != 2)
+    return 0;
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+  if (sizeof(ISLOW_MULT_TYPE) != 2)
+    return 0;
+
+#ifndef __mips_soft_float
+  if (simd_support & JSIMD_DSPR2)
+    return 1;
+#endif
+
+  return 0;
+}
+
+GLOBAL(void)
+jsimd_quantize(JCOEFPTR coef_block, DCTELEM *divisors, DCTELEM *workspace)
+{
+  jsimd_quantize_dspr2(coef_block, divisors, workspace);
+}
+
+GLOBAL(void)
+jsimd_quantize_float(JCOEFPTR coef_block, FAST_FLOAT *divisors,
+                     FAST_FLOAT *workspace)
+{
+#ifndef __mips_soft_float
+  jsimd_quantize_float_dspr2(coef_block, divisors, workspace);
+#endif
+}
+
+GLOBAL(int)
+jsimd_can_idct_2x2(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (DCTSIZE != 8)
+    return 0;
+  if (sizeof(JCOEF) != 2)
+    return 0;
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+  if (sizeof(ISLOW_MULT_TYPE) != 2)
+    return 0;
+
+  if (simd_support & JSIMD_DSPR2)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_idct_4x4(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (DCTSIZE != 8)
+    return 0;
+  if (sizeof(JCOEF) != 2)
+    return 0;
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+  if (sizeof(ISLOW_MULT_TYPE) != 2)
+    return 0;
+
+#if defined(__MIPSEL__)
+  if (simd_support & JSIMD_DSPR2)
+    return 1;
+#endif
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_idct_6x6(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (DCTSIZE != 8)
+    return 0;
+  if (sizeof(JCOEF) != 2)
+    return 0;
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+  if (sizeof(ISLOW_MULT_TYPE) != 2)
+    return 0;
+
+  if (simd_support & JSIMD_DSPR2)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_idct_12x12(void)
+{
+  init_simd();
+
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (DCTSIZE != 8)
+    return 0;
+  if (sizeof(JCOEF) != 2)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+  if (sizeof(ISLOW_MULT_TYPE) != 2)
+    return 0;
+
+  if (simd_support & JSIMD_DSPR2)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(void)
+jsimd_idct_2x2(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+               JCOEFPTR coef_block, JSAMPARRAY output_buf,
+               JDIMENSION output_col)
+{
+  jsimd_idct_2x2_dspr2(compptr->dct_table, coef_block, output_buf, output_col);
+}
+
+GLOBAL(void)
+jsimd_idct_4x4(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+               JCOEFPTR coef_block, JSAMPARRAY output_buf,
+               JDIMENSION output_col)
+{
+  int workspace[DCTSIZE * 4]; /* buffers data between passes */
+
+  jsimd_idct_4x4_dspr2(compptr->dct_table, coef_block, output_buf, output_col,
+                       workspace);
+}
+
+GLOBAL(void)
+jsimd_idct_6x6(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+               JCOEFPTR coef_block, JSAMPARRAY output_buf,
+               JDIMENSION output_col)
+{
+  jsimd_idct_6x6_dspr2(compptr->dct_table, coef_block, output_buf, output_col);
+}
+
+GLOBAL(void)
+jsimd_idct_12x12(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+                 JCOEFPTR coef_block, JSAMPARRAY output_buf,
+                 JDIMENSION output_col)
+{
+  int workspace[96];
+  int output[12] = {
+    (int)(output_buf[0] + output_col),
+    (int)(output_buf[1] + output_col),
+    (int)(output_buf[2] + output_col),
+    (int)(output_buf[3] + output_col),
+    (int)(output_buf[4] + output_col),
+    (int)(output_buf[5] + output_col),
+    (int)(output_buf[6] + output_col),
+    (int)(output_buf[7] + output_col),
+    (int)(output_buf[8] + output_col),
+    (int)(output_buf[9] + output_col),
+    (int)(output_buf[10] + output_col),
+    (int)(output_buf[11] + output_col)
+  };
+
+  jsimd_idct_12x12_pass1_dspr2(coef_block, compptr->dct_table, workspace);
+  jsimd_idct_12x12_pass2_dspr2(workspace, output);
+}
+
+GLOBAL(int)
+jsimd_can_idct_islow(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (DCTSIZE != 8)
+    return 0;
+  if (sizeof(JCOEF) != 2)
+    return 0;
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+  if (sizeof(ISLOW_MULT_TYPE) != 2)
+    return 0;
+
+  if (simd_support & JSIMD_DSPR2)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_idct_ifast(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (DCTSIZE != 8)
+    return 0;
+  if (sizeof(JCOEF) != 2)
+    return 0;
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+  if (sizeof(IFAST_MULT_TYPE) != 2)
+    return 0;
+  if (IFAST_SCALE_BITS != 2)
+    return 0;
+
+#if defined(__MIPSEL__)
+  if (simd_support & JSIMD_DSPR2)
+    return 1;
+#endif
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_idct_float(void)
+{
+  return 0;
+}
+
+GLOBAL(void)
+jsimd_idct_islow(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+                 JCOEFPTR coef_block, JSAMPARRAY output_buf,
+                 JDIMENSION output_col)
+{
+  int output[8] = {
+    (int)(output_buf[0] + output_col),
+    (int)(output_buf[1] + output_col),
+    (int)(output_buf[2] + output_col),
+    (int)(output_buf[3] + output_col),
+    (int)(output_buf[4] + output_col),
+    (int)(output_buf[5] + output_col),
+    (int)(output_buf[6] + output_col),
+    (int)(output_buf[7] + output_col)
+  };
+
+  jsimd_idct_islow_dspr2(coef_block, compptr->dct_table, output,
+                         IDCT_range_limit(cinfo));
+}
+
+GLOBAL(void)
+jsimd_idct_ifast(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+                 JCOEFPTR coef_block, JSAMPARRAY output_buf,
+                 JDIMENSION output_col)
+{
+  JCOEFPTR inptr;
+  IFAST_MULT_TYPE *quantptr;
+  DCTELEM workspace[DCTSIZE2];  /* buffers data between passes */
+
+  /* Pass 1: process columns from input, store into work array. */
+
+  inptr = coef_block;
+  quantptr = (IFAST_MULT_TYPE *)compptr->dct_table;
+
+  jsimd_idct_ifast_cols_dspr2(inptr, quantptr, workspace,
+                              mips_idct_ifast_coefs);
+
+  /* Pass 2: process rows from work array, store into output array. */
+  /* Note that we must descale the results by a factor of 8 == 2**3, */
+  /* and also undo the PASS1_BITS scaling. */
+
+  jsimd_idct_ifast_rows_dspr2(workspace, output_buf, output_col,
+                              mips_idct_ifast_coefs);
+}
+
+GLOBAL(void)
+jsimd_idct_float(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+                 JCOEFPTR coef_block, JSAMPARRAY output_buf,
+                 JDIMENSION output_col)
+{
+}
+
+GLOBAL(int)
+jsimd_can_huff_encode_one_block(void)
+{
+  return 0;
+}
+
+GLOBAL(JOCTET *)
+jsimd_huff_encode_one_block(void *state, JOCTET *buffer, JCOEFPTR block,
+                            int last_dc_val, c_derived_tbl *dctbl,
+                            c_derived_tbl *actbl)
+{
+  return NULL;
+}
+
+GLOBAL(int)
+jsimd_can_encode_mcu_AC_first_prepare(void)
+{
+  return 0;
+}
+
+GLOBAL(void)
+jsimd_encode_mcu_AC_first_prepare(const JCOEF *block,
+                                  const int *jpeg_natural_order_start, int Sl,
+                                  int Al, JCOEF *values, size_t *zerobits)
+{
+}
+
+GLOBAL(int)
+jsimd_can_encode_mcu_AC_refine_prepare(void)
+{
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_encode_mcu_AC_refine_prepare(const JCOEF *block,
+                                   const int *jpeg_natural_order_start, int Sl,
+                                   int Al, JCOEF *absvalues, size_t *bits)
+{
+  return 0;
+}
diff --git a/3rdparty/libjpeg/src/simd/mips/jsimd_dspr2.S b/3rdparty/libjpeg/src/simd/mips/jsimd_dspr2.S
new file mode 100644
index 00000000..c99288a8
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/mips/jsimd_dspr2.S
@@ -0,0 +1,4543 @@
+/*
+ * MIPS DSPr2 optimizations for libjpeg-turbo
+ *
+ * Copyright (C) 2013-2014, MIPS Technologies, Inc., California.
+ *                          All Rights Reserved.
+ * Authors:  Teodora Novkovic <teodora.novkovic@imgtec.com>
+ *           Darko Laus       <darko.laus@imgtec.com>
+ * Copyright (C) 2015, D. R. Commander.  All Rights Reserved.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+#include "jsimd_dspr2_asm.h"
+
+
+/*****************************************************************************/
+LEAF_DSPR2(jsimd_c_null_convert_dspr2)
+/*
+ * a0     = cinfo->image_width
+ * a1     = input_buf
+ * a2     = output_buf
+ * a3     = output_row
+ * 16(sp) = num_rows
+ * 20(sp) = cinfo->num_components
+ *
+ * Null conversion for compression
+ */
+    SAVE_REGS_ON_STACK 8, s0, s1
+
+    lw          t9, 24(sp)      /* t9 = num_rows */
+    lw          s0, 28(sp)      /* s0 = cinfo->num_components */
+    andi        t0, a0, 3       /* t0 = cinfo->image_width & 3 */
+    beqz        t0, 4f          /* no residual */
+     nop
+0:
+    addiu       t9, t9, -1
+    bltz        t9, 7f
+     li         t1, 0
+1:
+    sll         t3, t1, 2
+    lwx         t5, t3(a2)      /* t5 = outptr = output_buf[ci] */
+    lw          t2, 0(a1)       /* t2 = inptr = *input_buf */
+    sll         t4, a3, 2
+    lwx         t5, t4(t5)      /* t5 = outptr = output_buf[ci][output_row] */
+    addu        t2, t2, t1
+    addu        s1, t5, a0
+    addu        t6, t5, t0
+2:
+    lbu         t3, 0(t2)
+    addiu       t5, t5, 1
+    sb          t3, -1(t5)
+    bne         t6, t5, 2b
+     addu       t2, t2, s0
+3:
+    lbu         t3, 0(t2)
+    addu        t4, t2, s0
+    addu        t7, t4, s0
+    addu        t8, t7, s0
+    addu        t2, t8, s0
+    lbu         t4, 0(t4)
+    lbu         t7, 0(t7)
+    lbu         t8, 0(t8)
+    addiu       t5, t5, 4
+    sb          t3, -4(t5)
+    sb          t4, -3(t5)
+    sb          t7, -2(t5)
+    bne         s1, t5, 3b
+     sb         t8, -1(t5)
+    addiu       t1, t1, 1
+    bne         t1, s0, 1b
+     nop
+    addiu       a1, a1, 4
+    bgez        t9, 0b
+     addiu      a3, a3, 1
+    b           7f
+     nop
+4:
+    addiu       t9, t9, -1
+    bltz        t9, 7f
+     li         t1, 0
+5:
+    sll         t3, t1, 2
+    lwx         t5, t3(a2)      /* t5 = outptr = output_buf[ci] */
+    lw          t2, 0(a1)       /* t2 = inptr = *input_buf */
+    sll         t4, a3, 2
+    lwx         t5, t4(t5)      /* t5 = outptr = output_buf[ci][output_row] */
+    addu        t2, t2, t1
+    addu        s1, t5, a0
+    addu        t6, t5, t0
+6:
+    lbu         t3, 0(t2)
+    addu        t4, t2, s0
+    addu        t7, t4, s0
+    addu        t8, t7, s0
+    addu        t2, t8, s0
+    lbu         t4, 0(t4)
+    lbu         t7, 0(t7)
+    lbu         t8, 0(t8)
+    addiu       t5, t5, 4
+    sb          t3, -4(t5)
+    sb          t4, -3(t5)
+    sb          t7, -2(t5)
+    bne         s1, t5, 6b
+     sb         t8, -1(t5)
+    addiu       t1, t1, 1
+    bne         t1, s0, 5b
+     nop
+    addiu       a1, a1, 4
+    bgez        t9, 4b
+     addiu      a3, a3, 1
+7:
+    RESTORE_REGS_FROM_STACK 8, s0, s1
+
+    j           ra
+     nop
+
+END(jsimd_c_null_convert_dspr2)
+
+
+/*****************************************************************************/
+/*
+ * jsimd_extrgb_ycc_convert_dspr2
+ * jsimd_extbgr_ycc_convert_dspr2
+ * jsimd_extrgbx_ycc_convert_dspr2
+ * jsimd_extbgrx_ycc_convert_dspr2
+ * jsimd_extxbgr_ycc_convert_dspr2
+ * jsimd_extxrgb_ycc_convert_dspr2
+ *
+ * Colorspace conversion RGB -> YCbCr
+ */
+
+.macro GENERATE_JSIMD_RGB_YCC_CONVERT_DSPR2  colorid, pixel_size, \
+                                             r_offs, g_offs, b_offs
+
+.macro DO_RGB_TO_YCC  r, g, b, inptr
+    lbu         \r, \r_offs(\inptr)
+    lbu         \g, \g_offs(\inptr)
+    lbu         \b, \b_offs(\inptr)
+    addiu       \inptr, \pixel_size
+.endm
+
+LEAF_DSPR2(jsimd_\colorid\()_ycc_convert_dspr2)
+/*
+ * a0     = cinfo->image_width
+ * a1     = input_buf
+ * a2     = output_buf
+ * a3     = output_row
+ * 16(sp) = num_rows
+ */
+    SAVE_REGS_ON_STACK 32, s0, s1, s2, s3, s4, s5, s6, s7
+
+    lw          t7, 48(sp)      /* t7 = num_rows */
+    li          s0, 0x4c8b      /* FIX(0.29900) */
+    li          s1, 0x9646      /* FIX(0.58700) */
+    li          s2, 0x1d2f      /* FIX(0.11400) */
+    li          s3, 0xffffd4cd  /* -FIX(0.16874) */
+    li          s4, 0xffffab33  /* -FIX(0.33126) */
+    li          s5, 0x8000      /* FIX(0.50000) */
+    li          s6, 0xffff94d1  /* -FIX(0.41869) */
+    li          s7, 0xffffeb2f  /* -FIX(0.08131) */
+    li          t8, 0x807fff    /* CBCR_OFFSET + ONE_HALF-1 */
+
+0:
+    addiu       t7, -1          /* --num_rows */
+    lw          t6, 0(a1)       /* t6 = input_buf[0] */
+    lw          t0, 0(a2)
+    lw          t1, 4(a2)
+    lw          t2, 8(a2)
+    sll         t3, a3, 2
+    lwx         t0, t3(t0)      /* t0 = output_buf[0][output_row] */
+    lwx         t1, t3(t1)      /* t1 = output_buf[1][output_row] */
+    lwx         t2, t3(t2)      /* t2 = output_buf[2][output_row] */
+
+    addu        t9, t2, a0      /* t9 = end address */
+    addiu       a3, 1
+
+1:
+    DO_RGB_TO_YCC t3, t4, t5, t6
+
+    mtlo        s5, $ac0
+    mtlo        t8, $ac1
+    mtlo        t8, $ac2
+    maddu       $ac0, s2, t5
+    maddu       $ac1, s5, t5
+    maddu       $ac2, s5, t3
+    maddu       $ac0, s0, t3
+    maddu       $ac1, s3, t3
+    maddu       $ac2, s6, t4
+    maddu       $ac0, s1, t4
+    maddu       $ac1, s4, t4
+    maddu       $ac2, s7, t5
+    extr.w      t3, $ac0, 16
+    extr.w      t4, $ac1, 16
+    extr.w      t5, $ac2, 16
+    sb          t3, 0(t0)
+    sb          t4, 0(t1)
+    sb          t5, 0(t2)
+    addiu       t0, 1
+    addiu       t2, 1
+    bne         t2, t9, 1b
+     addiu      t1, 1
+    bgtz        t7, 0b
+     addiu      a1, 4
+
+    RESTORE_REGS_FROM_STACK 32, s0, s1, s2, s3, s4, s5, s6, s7
+
+    j           ra
+     nop
+END(jsimd_\colorid\()_ycc_convert_dspr2)
+
+.purgem DO_RGB_TO_YCC
+
+.endm
+
+/*-------------------------------------id -- pix R  G  B */
+GENERATE_JSIMD_RGB_YCC_CONVERT_DSPR2 extrgb,  3, 0, 1, 2
+GENERATE_JSIMD_RGB_YCC_CONVERT_DSPR2 extbgr,  3, 2, 1, 0
+GENERATE_JSIMD_RGB_YCC_CONVERT_DSPR2 extrgbx, 4, 0, 1, 2
+GENERATE_JSIMD_RGB_YCC_CONVERT_DSPR2 extbgrx, 4, 2, 1, 0
+GENERATE_JSIMD_RGB_YCC_CONVERT_DSPR2 extxbgr, 4, 3, 2, 1
+GENERATE_JSIMD_RGB_YCC_CONVERT_DSPR2 extxrgb, 4, 1, 2, 3
+
+
+/*****************************************************************************/
+/*
+ * jsimd_ycc_extrgb_convert_dspr2
+ * jsimd_ycc_extbgr_convert_dspr2
+ * jsimd_ycc_extrgbx_convert_dspr2
+ * jsimd_ycc_extbgrx_convert_dspr2
+ * jsimd_ycc_extxbgr_convert_dspr2
+ * jsimd_ycc_extxrgb_convert_dspr2
+ *
+ * Colorspace conversion YCbCr -> RGB
+ */
+
+.macro GENERATE_JSIMD_YCC_RGB_CONVERT_DSPR2  colorid, pixel_size, \
+                                             r_offs, g_offs, b_offs, a_offs
+
+.macro STORE_YCC_TO_RGB  scratch0 scratch1 scratch2 outptr
+    sb          \scratch0, \r_offs(\outptr)
+    sb          \scratch1, \g_offs(\outptr)
+    sb          \scratch2, \b_offs(\outptr)
+.if (\pixel_size == 4)
+    li          t0, 0xFF
+    sb          t0, \a_offs(\outptr)
+.endif
+    addiu       \outptr, \pixel_size
+.endm
+
+LEAF_DSPR2(jsimd_ycc_\colorid\()_convert_dspr2)
+/*
+ * a0     = cinfo->image_width
+ * a1     = input_buf
+ * a2     = input_row
+ * a3     = output_buf
+ * 16(sp) = num_rows
+ */
+    SAVE_REGS_ON_STACK 32, s0, s1, s2, s3, s4, s5, s6, s7
+
+    lw          s1, 48(sp)
+    li          t3, 0x8000
+    li          t4, 0x166e9     /* FIX(1.40200) */
+    li          t5, 0x1c5a2     /* FIX(1.77200) */
+    li          t6, 0xffff492e  /* -FIX(0.71414) */
+    li          t7, 0xffffa7e6  /* -FIX(0.34414) */
+    repl.ph     t8, 128
+
+0:
+    lw          s0, 0(a3)
+    lw          t0, 0(a1)
+    lw          t1, 4(a1)
+    lw          t2, 8(a1)
+    sll         s5, a2, 2
+    addiu       s1, -1
+    lwx         s2, s5(t0)
+    lwx         s3, s5(t1)
+    lwx         s4, s5(t2)
+    addu        t9, s2, a0
+    addiu       a2, 1
+
+1:
+    lbu         s7, 0(s4)       /* cr */
+    lbu         s6, 0(s3)       /* cb */
+    lbu         s5, 0(s2)       /* y */
+    addiu       s2, 1
+    addiu       s4, 1
+    addiu       s7, -128
+    addiu       s6, -128
+    mul         t2, t7, s6
+    mul         t0, t6, s7      /* Crgtab[cr] */
+    sll         s7, 15
+    mulq_rs.w   t1, t4, s7      /* Crrtab[cr] */
+    sll         s6, 15
+    addu        t2, t3          /* Cbgtab[cb] */
+    addu        t2, t0
+
+    mulq_rs.w   t0, t5, s6      /* Cbbtab[cb] */
+    sra         t2, 16
+    addu        t1, s5
+    addu        t2, s5          /* add y */
+    ins         t2, t1, 16, 16
+    subu.ph     t2, t2, t8
+    addu        t0, s5
+    shll_s.ph   t2, t2, 8
+    subu        t0, 128
+    shra.ph     t2, t2, 8
+    shll_s.w    t0, t0, 24
+    addu.ph     t2, t2, t8      /* clip & store */
+    sra         t0, t0, 24
+    sra         t1, t2, 16
+    addiu       t0, 128
+
+    STORE_YCC_TO_RGB t1, t2, t0, s0
+
+    bne         s2, t9, 1b
+     addiu      s3, 1
+    bgtz        s1, 0b
+     addiu      a3, 4
+
+    RESTORE_REGS_FROM_STACK 32, s0, s1, s2, s3, s4, s5, s6, s7
+
+    j           ra
+     nop
+END(jsimd_ycc_\colorid\()_convert_dspr2)
+
+.purgem STORE_YCC_TO_RGB
+
+.endm
+
+/*-------------------------------------id -- pix R  G  B  A */
+GENERATE_JSIMD_YCC_RGB_CONVERT_DSPR2 extrgb,  3, 0, 1, 2, 3
+GENERATE_JSIMD_YCC_RGB_CONVERT_DSPR2 extbgr,  3, 2, 1, 0, 3
+GENERATE_JSIMD_YCC_RGB_CONVERT_DSPR2 extrgbx, 4, 0, 1, 2, 3
+GENERATE_JSIMD_YCC_RGB_CONVERT_DSPR2 extbgrx, 4, 2, 1, 0, 3
+GENERATE_JSIMD_YCC_RGB_CONVERT_DSPR2 extxbgr, 4, 3, 2, 1, 0
+GENERATE_JSIMD_YCC_RGB_CONVERT_DSPR2 extxrgb, 4, 1, 2, 3, 0
+
+
+/*****************************************************************************/
+/*
+ * jsimd_extrgb_gray_convert_dspr2
+ * jsimd_extbgr_gray_convert_dspr2
+ * jsimd_extrgbx_gray_convert_dspr2
+ * jsimd_extbgrx_gray_convert_dspr2
+ * jsimd_extxbgr_gray_convert_dspr2
+ * jsimd_extxrgb_gray_convert_dspr2
+ *
+ * Colorspace conversion RGB -> GRAY
+ */
+
+.macro GENERATE_JSIMD_RGB_GRAY_CONVERT_DSPR2  colorid, pixel_size, \
+                                              r_offs, g_offs, b_offs
+
+.macro DO_RGB_TO_GRAY  r, g, b, inptr
+    lbu         \r, \r_offs(\inptr)
+    lbu         \g, \g_offs(\inptr)
+    lbu         \b, \b_offs(\inptr)
+    addiu       \inptr, \pixel_size
+.endm
+
+LEAF_DSPR2(jsimd_\colorid\()_gray_convert_dspr2)
+/*
+ * a0     = cinfo->image_width
+ * a1     = input_buf
+ * a2     = output_buf
+ * a3     = output_row
+ * 16(sp) = num_rows
+ */
+    SAVE_REGS_ON_STACK 32, s0, s1, s2, s3, s4, s5, s6, s7
+
+    li          s0, 0x4c8b      /* s0 = FIX(0.29900) */
+    li          s1, 0x9646      /* s1 = FIX(0.58700) */
+    li          s2, 0x1d2f      /* s2 = FIX(0.11400) */
+    li          s7, 0x8000      /* s7 = FIX(0.50000) */
+    lw          s6, 48(sp)
+    andi        t7, a0, 3
+
+0:
+    addiu       s6, -1          /* s6 = num_rows */
+    lw          t0, 0(a1)
+    lw          t1, 0(a2)
+    sll         t3, a3, 2
+    lwx         t1, t3(t1)
+    addiu       a3, 1
+    addu        t9, t1, a0
+    subu        t8, t9, t7
+    beq         t1, t8, 2f
+     nop
+
+1:
+    DO_RGB_TO_GRAY t3, t4, t5, t0
+    DO_RGB_TO_GRAY s3, s4, s5, t0
+
+    mtlo        s7, $ac0
+    maddu       $ac0, s2, t5
+    maddu       $ac0, s1, t4
+    maddu       $ac0, s0, t3
+    mtlo        s7, $ac1
+    maddu       $ac1, s2, s5
+    maddu       $ac1, s1, s4
+    maddu       $ac1, s0, s3
+    extr.w      t6, $ac0, 16
+
+    DO_RGB_TO_GRAY t3, t4, t5, t0
+    DO_RGB_TO_GRAY s3, s4, s5, t0
+
+    mtlo        s7, $ac0
+    maddu       $ac0, s2, t5
+    maddu       $ac0, s1, t4
+    extr.w      t2, $ac1, 16
+    maddu       $ac0, s0, t3
+    mtlo        s7, $ac1
+    maddu       $ac1, s2, s5
+    maddu       $ac1, s1, s4
+    maddu       $ac1, s0, s3
+    extr.w      t5, $ac0, 16
+    sb          t6, 0(t1)
+    sb          t2, 1(t1)
+    extr.w      t3, $ac1, 16
+    addiu       t1, 4
+    sb          t5, -2(t1)
+    sb          t3, -1(t1)
+    bne         t1, t8, 1b
+     nop
+
+2:
+    beqz        t7, 4f
+     nop
+
+3:
+    DO_RGB_TO_GRAY t3, t4, t5, t0
+
+    mtlo        s7, $ac0
+    maddu       $ac0, s2, t5
+    maddu       $ac0, s1, t4
+    maddu       $ac0, s0, t3
+    extr.w      t6, $ac0, 16
+    sb          t6, 0(t1)
+    addiu       t1, 1
+    bne         t1, t9, 3b
+     nop
+
+4:
+    bgtz        s6, 0b
+     addiu      a1, 4
+
+    RESTORE_REGS_FROM_STACK 32, s0, s1, s2, s3, s4, s5, s6, s7
+
+    j           ra
+     nop
+END(jsimd_\colorid\()_gray_convert_dspr2)
+
+.purgem DO_RGB_TO_GRAY
+
+.endm
+
+/*-------------------------------------id --  pix R  G  B */
+GENERATE_JSIMD_RGB_GRAY_CONVERT_DSPR2 extrgb,  3, 0, 1, 2
+GENERATE_JSIMD_RGB_GRAY_CONVERT_DSPR2 extbgr,  3, 2, 1, 0
+GENERATE_JSIMD_RGB_GRAY_CONVERT_DSPR2 extrgbx, 4, 0, 1, 2
+GENERATE_JSIMD_RGB_GRAY_CONVERT_DSPR2 extbgrx, 4, 2, 1, 0
+GENERATE_JSIMD_RGB_GRAY_CONVERT_DSPR2 extxbgr, 4, 3, 2, 1
+GENERATE_JSIMD_RGB_GRAY_CONVERT_DSPR2 extxrgb, 4, 1, 2, 3
+
+
+/*****************************************************************************/
+/*
+ * jsimd_h2v2_merged_upsample_dspr2
+ * jsimd_h2v2_extrgb_merged_upsample_dspr2
+ * jsimd_h2v2_extrgbx_merged_upsample_dspr2
+ * jsimd_h2v2_extbgr_merged_upsample_dspr2
+ * jsimd_h2v2_extbgrx_merged_upsample_dspr2
+ * jsimd_h2v2_extxbgr_merged_upsample_dspr2
+ * jsimd_h2v2_extxrgb_merged_upsample_dspr2
+ *
+ * Merged h2v2 upsample routines
+ */
+.macro GENERATE_H2V2_MERGED_UPSAMPLE_DSPR2  colorid, pixel_size, \
+                                            r1_offs, g1_offs, \
+                                            b1_offs, a1_offs, \
+                                            r2_offs, g2_offs, \
+                                            b2_offs, a2_offs
+
+.macro STORE_H2V2_2_PIXELS  scratch0 scratch1 scratch2 scratch3 scratch4 \
+                            scratch5 outptr
+    sb          \scratch0, \r1_offs(\outptr)
+    sb          \scratch1, \g1_offs(\outptr)
+    sb          \scratch2, \b1_offs(\outptr)
+    sb          \scratch3, \r2_offs(\outptr)
+    sb          \scratch4, \g2_offs(\outptr)
+    sb          \scratch5, \b2_offs(\outptr)
+.if (\pixel_size == 8)
+    li          \scratch0, 0xFF
+    sb          \scratch0, \a1_offs(\outptr)
+    sb          \scratch0, \a2_offs(\outptr)
+.endif
+    addiu       \outptr, \pixel_size
+.endm
+
+.macro STORE_H2V2_1_PIXEL  scratch0 scratch1 scratch2 outptr
+    sb          \scratch0, \r1_offs(\outptr)
+    sb          \scratch1, \g1_offs(\outptr)
+    sb          \scratch2, \b1_offs(\outptr)
+
+.if (\pixel_size == 8)
+    li          t0, 0xFF
+    sb          t0, \a1_offs(\outptr)
+.endif
+.endm
+
+LEAF_DSPR2(jsimd_h2v2_\colorid\()_merged_upsample_dspr2)
+/*
+ * a0     = cinfo->output_width
+ * a1     = input_buf
+ * a2     = in_row_group_ctr
+ * a3     = output_buf
+ * 16(sp) = cinfo->sample_range_limit
+ */
+    SAVE_REGS_ON_STACK 40, s0, s1, s2, s3, s4, s5, s6, s7, ra
+
+    lw          t9, 56(sp)      /* cinfo->sample_range_limit */
+    lw          v0, 0(a1)
+    lw          v1, 4(a1)
+    lw          t0, 8(a1)
+    sll         t1, a2, 3
+    addiu       t2, t1, 4
+    sll         t3, a2, 2
+    lw          t4, 0(a3)       /* t4 = output_buf[0] */
+    lwx         t1, t1(v0)      /* t1 = input_buf[0][in_row_group_ctr*2] */
+    lwx         t2, t2(v0)      /* t2 = input_buf[0][in_row_group_ctr*2 + 1] */
+    lwx         t5, t3(v1)      /* t5 = input_buf[1][in_row_group_ctr] */
+    lwx         t6, t3(t0)      /* t6 = input_buf[2][in_row_group_ctr] */
+    lw          t7, 4(a3)       /* t7 = output_buf[1] */
+    li          s1, 0xe6ea
+    addiu       t8, s1, 0x7fff    /* t8 = 0x166e9 [FIX(1.40200)] */
+    addiu       s0, t8, 0x5eb9    /* s0 = 0x1c5a2 [FIX(1.77200)] */
+    addiu       s1, zero, 0xa7e6  /* s4 = 0xffffa7e6 [-FIX(0.34414)] */
+    xori        s2, s1, 0xeec8    /* s3 = 0xffff492e [-FIX(0.71414)] */
+    srl         t3, a0, 1
+    blez        t3, 2f
+     addu       t0, t5, t3      /* t0 = end address */
+ 1:
+    lbu         t3, 0(t5)
+    lbu         s3, 0(t6)
+    addiu       t5, t5, 1
+    addiu       t3, t3, -128    /* (cb - 128) */
+    addiu       s3, s3, -128    /* (cr - 128) */
+    mult        $ac1, s1, t3
+    madd        $ac1, s2, s3
+    sll         s3, s3, 15
+    sll         t3, t3, 15
+    mulq_rs.w   s4, t8, s3      /* s4 = (C1 * cr + ONE_HALF)>> SCALEBITS */
+    extr_r.w    s5, $ac1, 16
+    mulq_rs.w   s6, s0, t3      /* s6 = (C2 * cb + ONE_HALF)>> SCALEBITS */
+    lbu         v0, 0(t1)
+    addiu       t6, t6, 1
+    addiu       t1, t1, 2
+    addu        t3, v0, s4      /* y+cred */
+    addu        s3, v0, s5      /* y+cgreen */
+    addu        v1, v0, s6      /* y+cblue */
+    addu        t3, t9, t3      /* y+cred */
+    addu        s3, t9, s3      /* y+cgreen */
+    addu        v1, t9, v1      /* y+cblue */
+    lbu         AT, 0(t3)
+    lbu         s7, 0(s3)
+    lbu         ra, 0(v1)
+    lbu         v0, -1(t1)
+    addu        t3, v0, s4      /* y+cred */
+    addu        s3, v0, s5      /* y+cgreen */
+    addu        v1, v0, s6      /* y+cblue */
+    addu        t3, t9, t3      /* y+cred */
+    addu        s3, t9, s3      /* y+cgreen */
+    addu        v1, t9, v1      /* y+cblue */
+    lbu         t3, 0(t3)
+    lbu         s3, 0(s3)
+    lbu         v1, 0(v1)
+    lbu         v0, 0(t2)
+
+    STORE_H2V2_2_PIXELS AT, s7, ra, t3, s3, v1, t4
+
+    addu        t3, v0, s4      /* y+cred */
+    addu        s3, v0, s5      /* y+cgreen */
+    addu        v1, v0, s6      /* y+cblue */
+    addu        t3, t9, t3      /* y+cred */
+    addu        s3, t9, s3      /* y+cgreen */
+    addu        v1, t9, v1      /* y+cblue */
+    lbu         AT, 0(t3)
+    lbu         s7, 0(s3)
+    lbu         ra, 0(v1)
+    lbu         v0, 1(t2)
+    addiu       t2, t2, 2
+    addu        t3, v0, s4      /* y+cred */
+    addu        s3, v0, s5      /* y+cgreen */
+    addu        v1, v0, s6      /* y+cblue */
+    addu        t3, t9, t3      /* y+cred */
+    addu        s3, t9, s3      /* y+cgreen */
+    addu        v1, t9, v1      /* y+cblue */
+    lbu         t3, 0(t3)
+    lbu         s3, 0(s3)
+    lbu         v1, 0(v1)
+
+    STORE_H2V2_2_PIXELS AT, s7, ra, t3, s3, v1, t7
+
+    bne         t0, t5, 1b
+     nop
+2:
+    andi        t0, a0, 1
+    beqz        t0, 4f
+     lbu        t3, 0(t5)
+    lbu         s3, 0(t6)
+    addiu       t3, t3, -128    /* (cb - 128) */
+    addiu       s3, s3, -128    /* (cr - 128) */
+    mult        $ac1, s1, t3
+    madd        $ac1, s2, s3
+    sll         s3, s3, 15
+    sll         t3, t3, 15
+    lbu         v0, 0(t1)
+    extr_r.w    s5, $ac1, 16
+    mulq_rs.w   s4, t8, s3      /* s4 = (C1 * cr + ONE_HALF)>> SCALEBITS */
+    mulq_rs.w   s6, s0, t3      /* s6 = (C2 * cb + ONE_HALF)>> SCALEBITS */
+    addu        t3, v0, s4      /* y+cred */
+    addu        s3, v0, s5      /* y+cgreen */
+    addu        v1, v0, s6      /* y+cblue */
+    addu        t3, t9, t3      /* y+cred */
+    addu        s3, t9, s3      /* y+cgreen */
+    addu        v1, t9, v1      /* y+cblue */
+    lbu         t3, 0(t3)
+    lbu         s3, 0(s3)
+    lbu         v1, 0(v1)
+    lbu         v0, 0(t2)
+
+    STORE_H2V2_1_PIXEL t3, s3, v1, t4
+
+    addu        t3, v0, s4      /* y+cred */
+    addu        s3, v0, s5      /* y+cgreen */
+    addu        v1, v0, s6      /* y+cblue */
+    addu        t3, t9, t3      /* y+cred */
+    addu        s3, t9, s3      /* y+cgreen */
+    addu        v1, t9, v1      /* y+cblue */
+    lbu         t3, 0(t3)
+    lbu         s3, 0(s3)
+    lbu         v1, 0(v1)
+
+    STORE_H2V2_1_PIXEL t3, s3, v1, t7
+4:
+    RESTORE_REGS_FROM_STACK 40, s0, s1, s2, s3, s4, s5, s6, s7, ra
+
+    j           ra
+     nop
+
+END(jsimd_h2v2_\colorid\()_merged_upsample_dspr2)
+
+.purgem STORE_H2V2_1_PIXEL
+.purgem STORE_H2V2_2_PIXELS
+.endm
+
+/*------------------------------------id -- pix R1 G1 B1 A1 R2 G2 B2 A2 */
+GENERATE_H2V2_MERGED_UPSAMPLE_DSPR2 extrgb,  6, 0, 1, 2, 6, 3, 4, 5, 6
+GENERATE_H2V2_MERGED_UPSAMPLE_DSPR2 extbgr,  6, 2, 1, 0, 3, 5, 4, 3, 6
+GENERATE_H2V2_MERGED_UPSAMPLE_DSPR2 extrgbx, 8, 0, 1, 2, 3, 4, 5, 6, 7
+GENERATE_H2V2_MERGED_UPSAMPLE_DSPR2 extbgrx, 8, 2, 1, 0, 3, 6, 5, 4, 7
+GENERATE_H2V2_MERGED_UPSAMPLE_DSPR2 extxbgr, 8, 3, 2, 1, 0, 7, 6, 5, 4
+GENERATE_H2V2_MERGED_UPSAMPLE_DSPR2 extxrgb, 8, 1, 2, 3, 0, 5, 6, 7, 4
+
+
+/*****************************************************************************/
+/*
+ * jsimd_h2v1_merged_upsample_dspr2
+ * jsimd_h2v1_extrgb_merged_upsample_dspr2
+ * jsimd_h2v1_extrgbx_merged_upsample_dspr2
+ * jsimd_h2v1_extbgr_merged_upsample_dspr2
+ * jsimd_h2v1_extbgrx_merged_upsample_dspr2
+ * jsimd_h2v1_extxbgr_merged_upsample_dspr2
+ * jsimd_h2v1_extxrgb_merged_upsample_dspr2
+ *
+ * Merged h2v1 upsample routines
+ */
+
+.macro GENERATE_H2V1_MERGED_UPSAMPLE_DSPR2  colorid, pixel_size, \
+                                            r1_offs, g1_offs, \
+                                            b1_offs, a1_offs, \
+                                            r2_offs, g2_offs, \
+                                            b2_offs, a2_offs
+
+.macro STORE_H2V1_2_PIXELS  scratch0 scratch1 scratch2 scratch3 scratch4 \
+                            scratch5 outptr
+    sb          \scratch0, \r1_offs(\outptr)
+    sb          \scratch1, \g1_offs(\outptr)
+    sb          \scratch2, \b1_offs(\outptr)
+    sb          \scratch3, \r2_offs(\outptr)
+    sb          \scratch4, \g2_offs(\outptr)
+    sb          \scratch5, \b2_offs(\outptr)
+.if (\pixel_size == 8)
+    li          t0, 0xFF
+    sb          t0, \a1_offs(\outptr)
+    sb          t0, \a2_offs(\outptr)
+.endif
+    addiu       \outptr, \pixel_size
+.endm
+
+.macro STORE_H2V1_1_PIXEL  scratch0 scratch1 scratch2 outptr
+    sb          \scratch0, \r1_offs(\outptr)
+    sb          \scratch1, \g1_offs(\outptr)
+    sb          \scratch2, \b1_offs(\outptr)
+.if (\pixel_size == 8)
+    li          t0, 0xFF
+    sb          t0, \a1_offs(\outptr)
+.endif
+.endm
+
+LEAF_DSPR2(jsimd_h2v1_\colorid\()_merged_upsample_dspr2)
+/*
+ * a0     = cinfo->output_width
+ * a1     = input_buf
+ * a2     = in_row_group_ctr
+ * a3     = output_buf
+ * 16(sp) = range_limit
+ */
+    SAVE_REGS_ON_STACK 40, s0, s1, s2, s3, s4, s5, s6, s7, ra
+
+    li          t0, 0xe6ea
+    lw          t1, 0(a1)         /* t1 = input_buf[0] */
+    lw          t2, 4(a1)         /* t2 = input_buf[1] */
+    lw          t3, 8(a1)         /* t3 = input_buf[2] */
+    lw          t8, 56(sp)        /* t8 = range_limit */
+    addiu       s1, t0, 0x7fff    /* s1 = 0x166e9 [FIX(1.40200)] */
+    addiu       s2, s1, 0x5eb9    /* s2 = 0x1c5a2 [FIX(1.77200)] */
+    addiu       s0, t0, 0x9916    /* s0 = 0x8000 */
+    addiu       s4, zero, 0xa7e6  /* s4 = 0xffffa7e6 [-FIX(0.34414)] */
+    xori        s3, s4, 0xeec8    /* s3 = 0xffff492e [-FIX(0.71414)] */
+    srl         t0, a0, 1
+    sll         t4, a2, 2
+    lwx         s5, t4(t1)      /* s5 = inptr0 */
+    lwx         s6, t4(t2)      /* s6 = inptr1 */
+    lwx         s7, t4(t3)      /* s7 = inptr2 */
+    lw          t7, 0(a3)       /* t7 = outptr */
+    blez        t0, 2f
+     addu       t9, s6, t0      /* t9 = end address */
+1:
+    lbu         t2, 0(s6)       /* t2 = cb */
+    lbu         t0, 0(s7)       /* t0 = cr */
+    lbu         t1, 0(s5)       /* t1 = y */
+    addiu       t2, t2, -128    /* t2 = cb - 128 */
+    addiu       t0, t0, -128    /* t0 = cr - 128 */
+    mult        $ac1, s4, t2
+    madd        $ac1, s3, t0
+    sll         t0, t0, 15
+    sll         t2, t2, 15
+    mulq_rs.w   t0, s1, t0      /* t0 = (C1*cr + ONE_HALF)>> SCALEBITS */
+    extr_r.w    t5, $ac1, 16
+    mulq_rs.w   t6, s2, t2      /* t6 = (C2*cb + ONE_HALF)>> SCALEBITS */
+    addiu       s7, s7, 1
+    addiu       s6, s6, 1
+    addu        t2, t1, t0      /* t2 = y + cred */
+    addu        t3, t1, t5      /* t3 = y + cgreen */
+    addu        t4, t1, t6      /* t4 = y + cblue */
+    addu        t2, t8, t2
+    addu        t3, t8, t3
+    addu        t4, t8, t4
+    lbu         t1, 1(s5)
+    lbu         v0, 0(t2)
+    lbu         v1, 0(t3)
+    lbu         ra, 0(t4)
+    addu        t2, t1, t0
+    addu        t3, t1, t5
+    addu        t4, t1, t6
+    addu        t2, t8, t2
+    addu        t3, t8, t3
+    addu        t4, t8, t4
+    lbu         t2, 0(t2)
+    lbu         t3, 0(t3)
+    lbu         t4, 0(t4)
+
+    STORE_H2V1_2_PIXELS v0, v1, ra, t2, t3, t4, t7
+
+    bne         t9, s6, 1b
+     addiu      s5, s5, 2
+2:
+    andi        t0, a0, 1
+    beqz        t0, 4f
+     nop
+3:
+    lbu         t2, 0(s6)
+    lbu         t0, 0(s7)
+    lbu         t1, 0(s5)
+    addiu       t2, t2, -128    /* (cb - 128) */
+    addiu       t0, t0, -128    /* (cr - 128) */
+    mul         t3, s4, t2
+    mul         t4, s3, t0
+    sll         t0, t0, 15
+    sll         t2, t2, 15
+    mulq_rs.w   t0, s1, t0      /* (C1*cr + ONE_HALF)>> SCALEBITS */
+    mulq_rs.w   t6, s2, t2      /* (C2*cb + ONE_HALF)>> SCALEBITS */
+    addu        t3, t3, s0
+    addu        t3, t4, t3
+    sra         t5, t3, 16      /* (C4*cb + ONE_HALF + C3*cr)>> SCALEBITS */
+    addu        t2, t1, t0      /* y + cred */
+    addu        t3, t1, t5      /* y + cgreen */
+    addu        t4, t1, t6      /* y + cblue */
+    addu        t2, t8, t2
+    addu        t3, t8, t3
+    addu        t4, t8, t4
+    lbu         t2, 0(t2)
+    lbu         t3, 0(t3)
+    lbu         t4, 0(t4)
+
+    STORE_H2V1_1_PIXEL t2, t3, t4, t7
+4:
+    RESTORE_REGS_FROM_STACK 40, s0, s1, s2, s3, s4, s5, s6, s7, ra
+
+    j           ra
+     nop
+
+END(jsimd_h2v1_\colorid\()_merged_upsample_dspr2)
+
+.purgem STORE_H2V1_1_PIXEL
+.purgem STORE_H2V1_2_PIXELS
+.endm
+
+/*------------------------------------id -- pix R1 G1 B1 A1 R2 G2 B2 A2 */
+GENERATE_H2V1_MERGED_UPSAMPLE_DSPR2 extrgb,  6, 0, 1, 2, 6, 3, 4, 5, 6
+GENERATE_H2V1_MERGED_UPSAMPLE_DSPR2 extbgr,  6, 2, 1, 0, 3, 5, 4, 3, 6
+GENERATE_H2V1_MERGED_UPSAMPLE_DSPR2 extrgbx, 8, 0, 1, 2, 3, 4, 5, 6, 7
+GENERATE_H2V1_MERGED_UPSAMPLE_DSPR2 extbgrx, 8, 2, 1, 0, 3, 6, 5, 4, 7
+GENERATE_H2V1_MERGED_UPSAMPLE_DSPR2 extxbgr, 8, 3, 2, 1, 0, 7, 6, 5, 4
+GENERATE_H2V1_MERGED_UPSAMPLE_DSPR2 extxrgb, 8, 1, 2, 3, 0, 5, 6, 7, 4
+
+
+/*****************************************************************************/
+/*
+ * jsimd_h2v2_fancy_upsample_dspr2
+ *
+ * Fancy processing for the common case of 2:1 horizontal and 2:1 vertical.
+ */
+LEAF_DSPR2(jsimd_h2v2_fancy_upsample_dspr2)
+/*
+ * a0 = cinfo->max_v_samp_factor
+ * a1 = downsampled_width
+ * a2 = input_data
+ * a3 = output_data_ptr
+ */
+    SAVE_REGS_ON_STACK 24, s0, s1, s2, s3, s4, s5
+
+    li            s4, 0
+    lw            s2, 0(a3)       /* s2 = *output_data_ptr */
+0:
+    li            t9, 2
+    lw            s1, -4(a2)      /* s1 = inptr1 */
+
+1:
+    lw            s0, 0(a2)       /* s0 = inptr0 */
+    lwx           s3, s4(s2)
+    addiu         s5, a1, -2      /* s5 = downsampled_width - 2 */
+    srl           t4, s5, 1
+    sll           t4, t4, 1
+    lbu           t0, 0(s0)
+    lbu           t1, 1(s0)
+    lbu           t2, 0(s1)
+    lbu           t3, 1(s1)
+    addiu         s0, 2
+    addiu         s1, 2
+    addu          t8, s0, t4      /* t8 = end address */
+    andi          s5, s5, 1       /* s5 = residual */
+    sll           t4, t0, 1
+    sll           t6, t1, 1
+    addu          t0, t0, t4      /* t0 = (*inptr0++) * 3 */
+    addu          t1, t1, t6      /* t1 = (*inptr0++) * 3 */
+    addu          t7, t0, t2      /* t7 = thiscolsum */
+    addu          t6, t1, t3      /* t5 = nextcolsum */
+    sll           t0, t7, 2       /* t0 = thiscolsum * 4 */
+    subu          t1, t0, t7      /* t1 = thiscolsum * 3 */
+    shra_r.w      t0, t0, 4
+    addiu         t1, 7
+    addu          t1, t1, t6
+    srl           t1, t1, 4
+    sb            t0, 0(s3)
+    sb            t1, 1(s3)
+    beq           t8, s0, 22f     /* skip to final iteration if width == 3 */
+     addiu        s3, 2
+2:
+    lh            t0, 0(s0)       /* t0 = A3|A2 */
+    lh            t2, 0(s1)       /* t2 = B3|B2 */
+    addiu         s0, 2
+    addiu         s1, 2
+    preceu.ph.qbr t0, t0          /* t0 = 0|A3|0|A2 */
+    preceu.ph.qbr t2, t2          /* t2 = 0|B3|0|B2 */
+    shll.ph       t1, t0, 1
+    sll           t3, t6, 1
+    addu.ph       t0, t1, t0      /* t0 = A3*3|A2*3 */
+    addu          t3, t3, t6      /* t3 = this * 3 */
+    addu.ph       t0, t0, t2      /* t0 = next2|next1 */
+    addu          t1, t3, t7
+    andi          t7, t0, 0xFFFF  /* t7 = next1 */
+    sll           t2, t7, 1
+    addu          t2, t7, t2      /* t2 = next1*3 */
+    addu          t4, t2, t6
+    srl           t6, t0, 16      /* t6 = next2 */
+    shra_r.w      t1, t1, 4       /* t1 = (this*3 + last + 8) >> 4 */
+    addu          t0, t3, t7
+    addiu         t0, 7
+    srl           t0, t0, 4       /* t0 = (this*3 + next1 + 7) >> 4 */
+    shra_r.w      t4, t4, 4       /* t3 = (next1*3 + this + 8) >> 4 */
+    addu          t2, t2, t6
+    addiu         t2, 7
+    srl           t2, t2, 4       /* t2 = (next1*3 + next2 + 7) >> 4 */
+    sb            t1, 0(s3)
+    sb            t0, 1(s3)
+    sb            t4, 2(s3)
+    sb            t2, 3(s3)
+    bne           t8, s0, 2b
+     addiu        s3, 4
+22:
+    beqz          s5, 4f
+     addu         t8, s0, s5
+3:
+    lbu           t0, 0(s0)
+    lbu           t2, 0(s1)
+    addiu         s0, 1
+    addiu         s1, 1
+    sll           t3, t6, 1
+    sll           t1, t0, 1
+    addu          t1, t0, t1      /* t1 = inptr0 * 3 */
+    addu          t3, t3, t6      /* t3 = thiscolsum * 3 */
+    addu          t5, t1, t2
+    addu          t1, t3, t7
+    shra_r.w      t1, t1, 4
+    addu          t0, t3, t5
+    addiu         t0, 7
+    srl           t0, t0, 4
+    sb            t1, 0(s3)
+    sb            t0, 1(s3)
+    addiu         s3, 2
+    move          t7, t6
+    bne           t8, s0, 3b
+     move         t6, t5
+4:
+    sll           t0, t6, 2       /* t0 = thiscolsum * 4 */
+    subu          t1, t0, t6      /* t1 = thiscolsum * 3 */
+    addu          t1, t1, t7
+    addiu         s4, 4
+    shra_r.w      t1, t1, 4
+    addiu         t0, 7
+    srl           t0, t0, 4
+    sb            t1, 0(s3)
+    sb            t0, 1(s3)
+    addiu         t9, -1
+    addiu         s3, 2
+    bnez          t9, 1b
+     lw           s1, 4(a2)
+    srl           t0, s4, 2
+    subu          t0, a0, t0
+    bgtz          t0, 0b
+     addiu        a2, 4
+
+    RESTORE_REGS_FROM_STACK 24, s0, s1, s2, s3, s4, s5
+
+    j             ra
+     nop
+END(jsimd_h2v2_fancy_upsample_dspr2)
+
+
+/*****************************************************************************/
+LEAF_DSPR2(jsimd_h2v1_fancy_upsample_dspr2)
+/*
+ * a0 = cinfo->max_v_samp_factor
+ * a1 = downsampled_width
+ * a2 = input_data
+ * a3 = output_data_ptr
+ */
+    SAVE_REGS_ON_STACK 16, s0, s1, s2, s3
+
+    .set at
+
+    beqz          a0, 3f
+     sll          t0, a0, 2
+    lw            s1, 0(a3)
+    li            s3, 0x10001
+    addu          s0, s1, t0
+0:
+    addiu         t8, a1, -2
+    srl           t9, t8, 2
+    lw            t7, 0(a2)
+    lw            s2, 0(s1)
+    lbu           t0, 0(t7)
+    lbu           t1, 1(t7)       /* t1 = inptr[1] */
+    sll           t2, t0, 1
+    addu          t2, t2, t0      /* t2 = invalue*3 */
+    addu          t2, t2, t1
+    shra_r.w      t2, t2, 2
+    sb            t0, 0(s2)
+    sb            t2, 1(s2)
+    beqz          t9, 11f
+     addiu        s2, 2
+1:
+    ulw           t0, 0(t7)       /* t0 = |P3|P2|P1|P0| */
+    ulw           t1, 1(t7)
+    ulh           t2, 4(t7)       /* t2 = |0|0|P5|P4| */
+    preceu.ph.qbl t3, t0          /* t3 = |0|P3|0|P2| */
+    preceu.ph.qbr t0, t0          /* t0 = |0|P1|0|P0| */
+    preceu.ph.qbr t2, t2          /* t2 = |0|P5|0|P4| */
+    preceu.ph.qbl t4, t1          /* t4 = |0|P4|0|P3| */
+    preceu.ph.qbr t1, t1          /* t1 = |0|P2|0|P1| */
+    shll.ph       t5, t4, 1
+    shll.ph       t6, t1, 1
+    addu.ph       t5, t5, t4      /* t5 = |P4*3|P3*3| */
+    addu.ph       t6, t6, t1      /* t6 = |P2*3|P1*3| */
+    addu.ph       t4, t3, s3
+    addu.ph       t0, t0, s3
+    addu.ph       t4, t4, t5
+    addu.ph       t0, t0, t6
+    shrl.ph       t4, t4, 2       /* t4 = |0|P3|0|P2| */
+    shrl.ph       t0, t0, 2       /* t0 = |0|P1|0|P0| */
+    addu.ph       t2, t2, t5
+    addu.ph       t3, t3, t6
+    shra_r.ph     t2, t2, 2       /* t2 = |0|P5|0|P4| */
+    shra_r.ph     t3, t3, 2       /* t3 = |0|P3|0|P2| */
+    shll.ph       t2, t2, 8
+    shll.ph       t3, t3, 8
+    or            t2, t4, t2
+    or            t3, t3, t0
+    addiu         t9, -1
+    usw           t3, 0(s2)
+    usw           t2, 4(s2)
+    addiu         s2, 8
+    bgtz          t9, 1b
+     addiu        t7, 4
+11:
+    andi          t8, 3
+    beqz          t8, 22f
+     addiu        t7, 1
+
+2:
+    lbu           t0, 0(t7)
+    addiu         t7, 1
+    sll           t1, t0, 1
+    addu          t2, t0, t1      /* t2 = invalue */
+    lbu           t3, -2(t7)
+    lbu           t4, 0(t7)
+    addiu         t3, 1
+    addiu         t4, 2
+    addu          t3, t3, t2
+    addu          t4, t4, t2
+    srl           t3, 2
+    srl           t4, 2
+    sb            t3, 0(s2)
+    sb            t4, 1(s2)
+    addiu         t8, -1
+    bgtz          t8, 2b
+     addiu        s2, 2
+
+22:
+    lbu           t0, 0(t7)
+    lbu           t2, -1(t7)
+    sll           t1, t0, 1
+    addu          t1, t1, t0      /* t1 = invalue * 3 */
+    addu          t1, t1, t2
+    addiu         t1, 1
+    srl           t1, t1, 2
+    sb            t1, 0(s2)
+    sb            t0, 1(s2)
+    addiu         s1, 4
+    bne           s1, s0, 0b
+     addiu        a2, 4
+3:
+    RESTORE_REGS_FROM_STACK 16, s0, s1, s2, s3
+
+    j             ra
+     nop
+END(jsimd_h2v1_fancy_upsample_dspr2)
+
+
+/*****************************************************************************/
+LEAF_DSPR2(jsimd_h2v1_downsample_dspr2)
+/*
+ * a0     = cinfo->image_width
+ * a1     = cinfo->max_v_samp_factor
+ * a2     = compptr->v_samp_factor
+ * a3     = compptr->width_in_blocks
+ * 16(sp) = input_data
+ * 20(sp) = output_data
+ */
+    .set at
+
+    SAVE_REGS_ON_STACK 24, s0, s1, s2, s3, s4
+
+    beqz        a2, 7f
+     lw         s1, 44(sp)      /* s1 = output_data */
+    lw          s0, 40(sp)      /* s0 = input_data */
+    srl         s2, a0, 2
+    andi        t9, a0, 2
+    srl         t7, t9, 1
+    addu        s2, t7, s2
+    sll         t0, a3, 3       /* t0 = width_in_blocks*DCT */
+    srl         t7, t0, 1
+    subu        s2, t7, s2
+0:
+    andi        t6, a0, 1       /* t6 = temp_index */
+    addiu       t6, -1
+    lw          t4, 0(s1)       /* t4 = outptr */
+    lw          t5, 0(s0)       /* t5 = inptr0 */
+    li          s3, 0           /* s3 = bias */
+    srl         t7, a0, 1       /* t7 = image_width1 */
+    srl         s4, t7, 2
+    andi        t8, t7, 3
+1:
+    ulhu        t0, 0(t5)
+    ulhu        t1, 2(t5)
+    ulhu        t2, 4(t5)
+    ulhu        t3, 6(t5)
+    raddu.w.qb  t0, t0
+    raddu.w.qb  t1, t1
+    raddu.w.qb  t2, t2
+    raddu.w.qb  t3, t3
+    shra.ph     t0, t0, 1
+    shra_r.ph   t1, t1, 1
+    shra.ph     t2, t2, 1
+    shra_r.ph   t3, t3, 1
+    sb          t0, 0(t4)
+    sb          t1, 1(t4)
+    sb          t2, 2(t4)
+    sb          t3, 3(t4)
+    addiu       s4, -1
+    addiu       t4, 4
+    bgtz        s4, 1b
+     addiu      t5, 8
+    beqz        t8, 3f
+     addu       s4, t4, t8
+2:
+    ulhu        t0, 0(t5)
+    raddu.w.qb  t0, t0
+    addqh.w     t0, t0, s3
+    xori        s3, s3, 1
+    sb          t0, 0(t4)
+    addiu       t4, 1
+    bne         t4, s4, 2b
+     addiu      t5, 2
+3:
+    lbux        t1, t6(t5)
+    sll         t1, 1
+    addqh.w     t2, t1, s3      /* t2 = pixval1 */
+    xori        s3, s3, 1
+    addqh.w     t3, t1, s3      /* t3 = pixval2 */
+    blez        s2, 5f
+     append     t3, t2,  8
+    addu        t5, t4, s2      /* t5 = loop_end2 */
+4:
+    ush         t3, 0(t4)
+    addiu       s2, -1
+    bgtz        s2, 4b
+     addiu      t4,  2
+5:
+    beqz        t9, 6f
+     nop
+    sb          t2, 0(t4)
+6:
+    addiu       s1, 4
+    addiu       a2, -1
+    bnez        a2, 0b
+     addiu      s0, 4
+7:
+    RESTORE_REGS_FROM_STACK 24, s0, s1, s2, s3, s4
+
+    j           ra
+    nop
+END(jsimd_h2v1_downsample_dspr2)
+
+
+/*****************************************************************************/
+LEAF_DSPR2(jsimd_h2v2_downsample_dspr2)
+/*
+ * a0     = cinfo->image_width
+ * a1     = cinfo->max_v_samp_factor
+ * a2     = compptr->v_samp_factor
+ * a3     = compptr->width_in_blocks
+ * 16(sp) = input_data
+ * 20(sp) = output_data
+ */
+    .set at
+
+    SAVE_REGS_ON_STACK 32, s0, s1, s2, s3, s4, s5, s6, s7
+
+    beqz        a2, 8f
+     lw         s1, 52(sp)      /* s1 = output_data */
+    lw          s0, 48(sp)      /* s0 = input_data */
+
+    andi        t6, a0, 1       /* t6 = temp_index */
+    addiu       t6, -1
+    srl         t7, a0, 1       /* t7 = image_width1 */
+    srl         s4, t7, 2
+    andi        t8, t7, 3
+    andi        t9, a0, 2
+    srl         s2, a0, 2
+    srl         t7, t9, 1
+    addu        s2, t7, s2
+    sll         t0, a3, 3       /* s2 = width_in_blocks*DCT */
+    srl         t7, t0, 1
+    subu        s2, t7, s2
+0:
+    lw          t4, 0(s1)       /* t4 = outptr */
+    lw          t5, 0(s0)       /* t5 = inptr0 */
+    lw          s7, 4(s0)       /* s7 = inptr1 */
+    li          s6, 1           /* s6 = bias */
+2:
+    ulw         t0, 0(t5)       /* t0 = |P3|P2|P1|P0| */
+    ulw         t1, 0(s7)       /* t1 = |Q3|Q2|Q1|Q0| */
+    ulw         t2, 4(t5)
+    ulw         t3, 4(s7)
+    precrq.ph.w t7, t0, t1      /* t2 = |P3|P2|Q3|Q2| */
+    ins         t0, t1, 16, 16  /* t0 = |Q1|Q0|P1|P0| */
+    raddu.w.qb  t1, t7
+    raddu.w.qb  t0, t0
+    shra_r.w    t1, t1, 2
+    addiu       t0, 1
+    srl         t0, 2
+    precrq.ph.w t7, t2, t3
+    ins         t2, t3, 16, 16
+    raddu.w.qb  t7, t7
+    raddu.w.qb  t2, t2
+    shra_r.w    t7, t7, 2
+    addiu       t2, 1
+    srl         t2, 2
+    sb          t0, 0(t4)
+    sb          t1, 1(t4)
+    sb          t2, 2(t4)
+    sb          t7, 3(t4)
+    addiu       t4, 4
+    addiu       t5, 8
+    addiu       s4, s4, -1
+    bgtz        s4, 2b
+     addiu      s7, 8
+    beqz        t8, 4f
+     addu       t8, t4, t8
+3:
+    ulhu        t0, 0(t5)
+    ulhu        t1, 0(s7)
+    ins         t0, t1, 16, 16
+    raddu.w.qb  t0, t0
+    addu        t0, t0, s6
+    srl         t0, 2
+    xori        s6, s6, 3
+    sb          t0, 0(t4)
+    addiu       t5, 2
+    addiu       t4, 1
+    bne         t8, t4, 3b
+     addiu      s7, 2
+4:
+    lbux        t1, t6(t5)
+    sll         t1, 1
+    lbux        t0, t6(s7)
+    sll         t0, 1
+    addu        t1, t1, t0
+    addu        t3, t1, s6
+    srl         t0, t3, 2       /* t2 = pixval1 */
+    xori        s6, s6, 3
+    addu        t2, t1, s6
+    srl         t1, t2, 2       /* t3 = pixval2 */
+    blez        s2, 6f
+     append     t1, t0, 8
+5:
+    ush         t1, 0(t4)
+    addiu       s2, -1
+    bgtz        s2, 5b
+     addiu      t4, 2
+6:
+    beqz        t9, 7f
+     nop
+    sb          t0, 0(t4)
+7:
+    addiu       s1, 4
+    addiu       a2, -1
+    bnez        a2, 0b
+     addiu      s0, 8
+8:
+    RESTORE_REGS_FROM_STACK 32, s0, s1, s2, s3, s4, s5, s6, s7
+
+    j           ra
+     nop
+END(jsimd_h2v2_downsample_dspr2)
+
+
+/*****************************************************************************/
+LEAF_DSPR2(jsimd_h2v2_smooth_downsample_dspr2)
+/*
+ * a0     = input_data
+ * a1     = output_data
+ * a2     = compptr->v_samp_factor
+ * a3     = cinfo->max_v_samp_factor
+ * 16(sp) = cinfo->smoothing_factor
+ * 20(sp) = compptr->width_in_blocks
+ * 24(sp) = cinfo->image_width
+ */
+    .set at
+
+    SAVE_REGS_ON_STACK 32, s0, s1, s2, s3, s4, s5, s6, s7
+
+    lw          s7, 52(sp)      /* compptr->width_in_blocks */
+    lw          s0, 56(sp)      /* cinfo->image_width */
+    lw          s6, 48(sp)      /* cinfo->smoothing_factor */
+    sll         s7, 3           /* output_cols = width_in_blocks * DCTSIZE */
+    sll         v0, s7, 1
+    subu        v0, v0, s0
+    blez        v0, 2f
+    move        v1, zero
+    addiu       t0, a3, 2       /* t0 = cinfo->max_v_samp_factor + 2 */
+0:
+    addiu       t1, a0, -4
+    sll         t2, v1, 2
+    lwx         t1, t2(t1)
+    move        t3, v0
+    addu        t1, t1, s0
+    lbu         t2, -1(t1)
+1:
+    addiu       t3, t3, -1
+    sb          t2, 0(t1)
+    bgtz        t3, 1b
+    addiu       t1, t1, 1
+    addiu       v1, v1, 1
+    bne         v1, t0, 0b
+    nop
+2:
+    li          v0, 80
+    mul         v0, s6, v0
+    li          v1, 16384
+    move        t4, zero
+    move        t5, zero
+    subu        t6, v1, v0      /* t6 = 16384 - tmp_smoot_f * 80 */
+    sll         t7, s6, 4       /* t7 = tmp_smoot_f * 16 */
+3:
+/* Special case for first column: pretend column -1 is same as column 0 */
+    sll         v0, t4, 2
+    lwx         t8, v0(a1)      /*  outptr = output_data[outrow] */
+    sll         v1, t5, 2
+    addiu       t9, v1, 4
+    addiu       s0, v1, -4
+    addiu       s1, v1, 8
+    lwx         s2, v1(a0)      /* inptr0 = input_data[inrow] */
+    lwx         t9, t9(a0)      /* inptr1 = input_data[inrow+1] */
+    lwx         s0, s0(a0)      /* above_ptr = input_data[inrow-1] */
+    lwx         s1, s1(a0)      /* below_ptr = input_data[inrow+2] */
+    lh          v0, 0(s2)
+    lh          v1, 0(t9)
+    lh          t0, 0(s0)
+    lh          t1, 0(s1)
+    ins         v0, v1, 16, 16
+    ins         t0, t1, 16, 16
+    raddu.w.qb  t2, v0
+    raddu.w.qb  s3, t0
+    lbu         v0, 0(s2)
+    lbu         v1, 2(s2)
+    lbu         t0, 0(t9)
+    lbu         t1, 2(t9)
+    addu        v0, v0, v1
+    mult        $ac1, t2, t6
+    addu        t0, t0, t1
+    lbu         t2, 2(s0)
+    addu        t0, t0, v0
+    lbu         t3, 2(s1)
+    addu        s3, t0, s3
+    lbu         v0, 0(s0)
+    lbu         t0, 0(s1)
+    sll         s3, s3, 1
+    addu        v0, v0, t2
+    addu        t0, t0, t3
+    addu        t0, t0, v0
+    addu        s3, t0, s3
+    madd        $ac1, s3, t7
+    extr_r.w    v0, $ac1, 16
+    addiu       t8, t8, 1
+    addiu       s2, s2, 2
+    addiu       t9, t9, 2
+    addiu       s0, s0, 2
+    addiu       s1, s1, 2
+    sb          v0, -1(t8)
+    addiu       s4, s7, -2
+    and         s4, s4, 3
+    addu        s5, s4, t8      /* end address */
+4:
+    lh          v0, 0(s2)
+    lh          v1, 0(t9)
+    lh          t0, 0(s0)
+    lh          t1, 0(s1)
+    ins         v0, v1, 16, 16
+    ins         t0, t1, 16, 16
+    raddu.w.qb  t2, v0
+    raddu.w.qb  s3, t0
+    lbu         v0, -1(s2)
+    lbu         v1, 2(s2)
+    lbu         t0, -1(t9)
+    lbu         t1, 2(t9)
+    addu        v0, v0, v1
+    mult        $ac1, t2, t6
+    addu        t0, t0, t1
+    lbu         t2, 2(s0)
+    addu        t0, t0, v0
+    lbu         t3, 2(s1)
+    addu        s3, t0, s3
+    lbu         v0, -1(s0)
+    lbu         t0, -1(s1)
+    sll         s3, s3, 1
+    addu        v0, v0, t2
+    addu        t0, t0, t3
+    addu        t0, t0, v0
+    addu        s3, t0, s3
+    madd        $ac1, s3, t7
+    extr_r.w    t2, $ac1, 16
+    addiu       t8, t8, 1
+    addiu       s2, s2, 2
+    addiu       t9, t9, 2
+    addiu       s0, s0, 2
+    sb          t2, -1(t8)
+    bne         s5, t8, 4b
+    addiu       s1, s1, 2
+    addiu       s5, s7, -2
+    subu        s5, s5, s4
+    addu        s5, s5, t8      /* end address */
+5:
+    lh          v0, 0(s2)
+    lh          v1, 0(t9)
+    lh          t0, 0(s0)
+    lh          t1, 0(s1)
+    ins         v0, v1, 16, 16
+    ins         t0, t1, 16, 16
+    raddu.w.qb  t2, v0
+    raddu.w.qb  s3, t0
+    lbu         v0, -1(s2)
+    lbu         v1, 2(s2)
+    lbu         t0, -1(t9)
+    lbu         t1, 2(t9)
+    addu        v0, v0, v1
+    mult        $ac1, t2, t6
+    addu        t0, t0, t1
+    lbu         t2, 2(s0)
+    addu        t0, t0, v0
+    lbu         t3, 2(s1)
+    addu        s3, t0, s3
+    lbu         v0, -1(s0)
+    lbu         t0, -1(s1)
+    sll         s3, s3, 1
+    addu        v0, v0, t2
+    addu        t0, t0, t3
+    lh          v1, 2(t9)
+    addu        t0, t0, v0
+    lh          v0, 2(s2)
+    addu        s3, t0, s3
+    lh          t0, 2(s0)
+    lh          t1, 2(s1)
+    madd        $ac1, s3, t7
+    extr_r.w    t2, $ac1, 16
+    ins         t0, t1, 16, 16
+    ins         v0, v1, 16, 16
+    raddu.w.qb  s3, t0
+    lbu         v1, 4(s2)
+    lbu         t0, 1(t9)
+    lbu         t1, 4(t9)
+    sb          t2, 0(t8)
+    raddu.w.qb  t3, v0
+    lbu         v0, 1(s2)
+    addu        t0, t0, t1
+    mult        $ac1, t3, t6
+    addu        v0, v0, v1
+    lbu         t2, 4(s0)
+    addu        t0, t0, v0
+    lbu         v0, 1(s0)
+    addu        s3, t0, s3
+    lbu         t0, 1(s1)
+    lbu         t3, 4(s1)
+    addu        v0, v0, t2
+    sll         s3, s3, 1
+    addu        t0, t0, t3
+    lh          v1, 4(t9)
+    addu        t0, t0, v0
+    lh          v0, 4(s2)
+    addu        s3, t0, s3
+    lh          t0, 4(s0)
+    lh          t1, 4(s1)
+    madd        $ac1, s3, t7
+    extr_r.w    t2, $ac1, 16
+    ins         t0, t1, 16, 16
+    ins         v0, v1, 16, 16
+    raddu.w.qb  s3, t0
+    lbu         v1, 6(s2)
+    lbu         t0, 3(t9)
+    lbu         t1, 6(t9)
+    sb          t2, 1(t8)
+    raddu.w.qb  t3, v0
+    lbu         v0, 3(s2)
+    addu        t0, t0, t1
+    mult        $ac1, t3, t6
+    addu        v0, v0, v1
+    lbu         t2, 6(s0)
+    addu        t0, t0, v0
+    lbu         v0, 3(s0)
+    addu        s3, t0, s3
+    lbu         t0, 3(s1)
+    lbu         t3, 6(s1)
+    addu        v0, v0, t2
+    sll         s3, s3, 1
+    addu        t0, t0, t3
+    lh          v1, 6(t9)
+    addu        t0, t0, v0
+    lh          v0, 6(s2)
+    addu        s3, t0, s3
+    lh          t0, 6(s0)
+    lh          t1, 6(s1)
+    madd        $ac1, s3, t7
+    extr_r.w    t3, $ac1, 16
+    ins         t0, t1, 16, 16
+    ins         v0, v1, 16, 16
+    raddu.w.qb  s3, t0
+    lbu         v1, 8(s2)
+    lbu         t0, 5(t9)
+    lbu         t1, 8(t9)
+    sb          t3, 2(t8)
+    raddu.w.qb  t2, v0
+    lbu         v0, 5(s2)
+    addu        t0, t0, t1
+    mult        $ac1, t2, t6
+    addu        v0, v0, v1
+    lbu         t2, 8(s0)
+    addu        t0, t0, v0
+    lbu         v0, 5(s0)
+    addu        s3, t0, s3
+    lbu         t0, 5(s1)
+    lbu         t3, 8(s1)
+    addu        v0, v0, t2
+    sll         s3, s3, 1
+    addu        t0, t0, t3
+    addiu       t8, t8, 4
+    addu        t0, t0, v0
+    addiu       s2, s2, 8
+    addu        s3, t0, s3
+    addiu       t9, t9, 8
+    madd        $ac1, s3, t7
+    extr_r.w    t1, $ac1, 16
+    addiu       s0, s0, 8
+    addiu       s1, s1, 8
+    bne         s5, t8, 5b
+    sb          t1, -1(t8)
+/* Special case for last column */
+    lh          v0, 0(s2)
+    lh          v1, 0(t9)
+    lh          t0, 0(s0)
+    lh          t1, 0(s1)
+    ins         v0, v1, 16, 16
+    ins         t0, t1, 16, 16
+    raddu.w.qb  t2, v0
+    raddu.w.qb  s3, t0
+    lbu         v0, -1(s2)
+    lbu         v1, 1(s2)
+    lbu         t0, -1(t9)
+    lbu         t1, 1(t9)
+    addu        v0, v0, v1
+    mult        $ac1, t2, t6
+    addu        t0, t0, t1
+    lbu         t2, 1(s0)
+    addu        t0, t0, v0
+    lbu         t3, 1(s1)
+    addu        s3, t0, s3
+    lbu         v0, -1(s0)
+    lbu         t0, -1(s1)
+    sll         s3, s3, 1
+    addu        v0, v0, t2
+    addu        t0, t0, t3
+    addu        t0, t0, v0
+    addu        s3, t0, s3
+    madd        $ac1, s3, t7
+    extr_r.w    t0, $ac1, 16
+    addiu       t5, t5, 2
+    sb          t0, 0(t8)
+    addiu       t4, t4, 1
+    bne         t4, a2, 3b
+    addiu       t5, t5, 2
+
+    RESTORE_REGS_FROM_STACK 32, s0, s1, s2, s3, s4, s5, s6, s7
+
+    j           ra
+     nop
+
+END(jsimd_h2v2_smooth_downsample_dspr2)
+
+
+/*****************************************************************************/
+LEAF_DSPR2(jsimd_int_upsample_dspr2)
+/*
+ * a0     = upsample->h_expand[compptr->component_index]
+ * a1     = upsample->v_expand[compptr->component_index]
+ * a2     = input_data
+ * a3     = output_data_ptr
+ * 16(sp) = cinfo->output_width
+ * 20(sp) = cinfo->max_v_samp_factor
+ */
+    .set at
+
+    SAVE_REGS_ON_STACK 16, s0, s1, s2, s3
+
+    lw          s0, 0(a3)       /* s0 = output_data */
+    lw          s1, 32(sp)      /* s1 = cinfo->output_width */
+    lw          s2, 36(sp)      /* s2 = cinfo->max_v_samp_factor */
+    li          t6, 0           /* t6 = inrow */
+    beqz        s2, 10f
+     li         s3, 0           /* s3 = outrow */
+0:
+    addu        t0, a2, t6
+    addu        t7, s0, s3
+    lw          t3, 0(t0)       /* t3 = inptr */
+    lw          t8, 0(t7)       /* t8 = outptr */
+    beqz        s1, 4f
+     addu       t5, t8, s1      /* t5 = outend */
+1:
+    lb          t2, 0(t3)       /* t2 = invalue = *inptr++ */
+    addiu       t3, 1
+    beqz        a0, 3f
+     move       t0, a0          /* t0 = h_expand */
+2:
+    sb          t2, 0(t8)
+    addiu       t0, -1
+    bgtz        t0, 2b
+     addiu      t8, 1
+3:
+    bgt         t5, t8, 1b
+     nop
+4:
+    addiu       t9, a1, -1      /* t9 = v_expand - 1 */
+    blez        t9, 9f
+     nop
+5:
+    lw          t3, 0(s0)
+    lw          t4, 4(s0)
+    subu        t0, s1, 0xF
+    blez        t0, 7f
+     addu       t5, t3, s1      /* t5 = end address */
+    andi        t7, s1, 0xF     /* t7 = residual */
+    subu        t8, t5, t7
+6:
+    ulw         t0, 0(t3)
+    ulw         t1, 4(t3)
+    ulw         t2, 8(t3)
+    usw         t0, 0(t4)
+    ulw         t0, 12(t3)
+    usw         t1, 4(t4)
+    usw         t2, 8(t4)
+    usw         t0, 12(t4)
+    addiu       t3, 16
+    bne         t3, t8, 6b
+     addiu      t4, 16
+    beqz        t7, 8f
+     nop
+7:
+    lbu         t0, 0(t3)
+    sb          t0, 0(t4)
+    addiu       t3, 1
+    bne         t3, t5, 7b
+     addiu      t4, 1
+8:
+    addiu       t9, -1
+    bgtz        t9, 5b
+     addiu      s0, 8
+9:
+    addu        s3, s3, a1
+    bne         s3, s2, 0b
+     addiu      t6, 1
+10:
+    RESTORE_REGS_FROM_STACK 16, s0, s1, s2, s3
+
+    j           ra
+     nop
+END(jsimd_int_upsample_dspr2)
+
+
+/*****************************************************************************/
+LEAF_DSPR2(jsimd_h2v1_upsample_dspr2)
+/*
+ * a0 = cinfo->max_v_samp_factor
+ * a1 = cinfo->output_width
+ * a2 = input_data
+ * a3 = output_data_ptr
+ */
+    lw          t7, 0(a3)       /* t7 = output_data */
+    andi        t8, a1, 0xf     /* t8 = residual */
+    sll         t0, a0, 2
+    blez        a0, 4f
+     addu       t9, t7, t0      /* t9 = output_data end address */
+0:
+    lw          t5, 0(t7)       /* t5 = outptr */
+    lw          t6, 0(a2)       /* t6 = inptr */
+    addu        t3, t5, a1      /* t3 = outptr + output_width (end address) */
+    subu        t3, t8          /* t3 = end address - residual */
+    beq         t5, t3, 2f
+     move       t4, t8
+1:
+    ulw         t0, 0(t6)       /* t0 = |P3|P2|P1|P0| */
+    ulw         t2, 4(t6)       /* t2 = |P7|P6|P5|P4| */
+    srl         t1, t0, 16      /* t1 = |X|X|P3|P2| */
+    ins         t0, t0, 16, 16  /* t0 = |P1|P0|P1|P0| */
+    ins         t1, t1, 16, 16  /* t1 = |P3|P2|P3|P2| */
+    ins         t0, t0, 8, 16   /* t0 = |P1|P1|P0|P0| */
+    ins         t1, t1, 8, 16   /* t1 = |P3|P3|P2|P2| */
+    usw         t0, 0(t5)
+    usw         t1, 4(t5)
+    srl         t0, t2, 16      /* t0 = |X|X|P7|P6| */
+    ins         t2, t2, 16, 16  /* t2 = |P5|P4|P5|P4| */
+    ins         t0, t0, 16, 16  /* t0 = |P7|P6|P7|P6| */
+    ins         t2, t2, 8, 16   /* t2 = |P5|P5|P4|P4| */
+    ins         t0, t0, 8, 16   /* t0 = |P7|P7|P6|P6| */
+    usw         t2, 8(t5)
+    usw         t0, 12(t5)
+    addiu       t5, 16
+    bne         t5, t3, 1b
+     addiu      t6, 8
+    beqz        t8, 3f
+     move       t4, t8
+2:
+    lbu         t1, 0(t6)
+    sb          t1, 0(t5)
+    sb          t1, 1(t5)
+    addiu       t4, -2
+    addiu       t6, 1
+    bgtz        t4, 2b
+     addiu      t5, 2
+3:
+    addiu       t7, 4
+    bne         t9, t7, 0b
+     addiu      a2, 4
+4:
+    j           ra
+     nop
+END(jsimd_h2v1_upsample_dspr2)
+
+
+/*****************************************************************************/
+LEAF_DSPR2(jsimd_h2v2_upsample_dspr2)
+/*
+ * a0 = cinfo->max_v_samp_factor
+ * a1 = cinfo->output_width
+ * a2 = input_data
+ * a3 = output_data_ptr
+ */
+    lw          t7, 0(a3)
+    blez        a0, 7f
+     andi       t9, a1, 0xf     /* t9 = residual */
+0:
+    lw          t6, 0(a2)       /* t6 = inptr */
+    lw          t5, 0(t7)       /* t5 = outptr */
+    addu        t8, t5, a1      /* t8 = outptr end address */
+    subu        t8, t9          /* t8 = end address - residual */
+    beq         t5, t8, 2f
+     move       t4, t9
+1:
+    ulw         t0, 0(t6)
+    srl         t1, t0, 16
+    ins         t0, t0, 16, 16
+    ins         t0, t0, 8, 16
+    ins         t1, t1, 16, 16
+    ins         t1, t1, 8, 16
+    ulw         t2, 4(t6)
+    usw         t0, 0(t5)
+    usw         t1, 4(t5)
+    srl         t3, t2, 16
+    ins         t2, t2, 16, 16
+    ins         t2, t2, 8, 16
+    ins         t3, t3, 16, 16
+    ins         t3, t3, 8, 16
+    usw         t2, 8(t5)
+    usw         t3, 12(t5)
+    addiu       t5, 16
+    bne         t5, t8, 1b
+     addiu      t6, 8
+    beqz        t9, 3f
+     move       t4, t9
+2:
+    lbu         t0, 0(t6)
+    sb          t0, 0(t5)
+    sb          t0, 1(t5)
+    addiu       t4, -2
+    addiu       t6, 1
+    bgtz        t4, 2b
+     addiu      t5, 2
+3:
+    lw          t6, 0(t7)       /* t6 = outptr[0] */
+    lw          t5, 4(t7)       /* t5 = outptr[1] */
+    addu        t4, t6, a1      /* t4 = new end address */
+    beq         a1, t9, 5f
+     subu       t8, t4, t9
+4:
+    ulw         t0, 0(t6)
+    ulw         t1, 4(t6)
+    ulw         t2, 8(t6)
+    usw         t0, 0(t5)
+    ulw         t0, 12(t6)
+    usw         t1, 4(t5)
+    usw         t2, 8(t5)
+    usw         t0, 12(t5)
+    addiu       t6, 16
+    bne         t6, t8, 4b
+     addiu      t5, 16
+    beqz        t9, 6f
+     nop
+5:
+    lbu         t0, 0(t6)
+    sb          t0, 0(t5)
+    addiu       t6, 1
+    bne         t6, t4, 5b
+     addiu      t5, 1
+6:
+    addiu       t7, 8
+    addiu       a0, -2
+    bgtz        a0, 0b
+     addiu      a2, 4
+7:
+    j           ra
+     nop
+END(jsimd_h2v2_upsample_dspr2)
+
+
+/*****************************************************************************/
+LEAF_DSPR2(jsimd_idct_islow_dspr2)
+/*
+ * a0 = coef_block
+ * a1 = compptr->dcttable
+ * a2 = output
+ * a3 = range_limit
+ */
+    SAVE_REGS_ON_STACK 32, s0, s1, s2, s3, s4, s5, s6, s7
+
+    addiu       sp, sp, -256
+    move        v0, sp
+    addiu       v1, zero, 8     /* v1 = DCTSIZE = 8 */
+1:
+    lh          s4, 32(a0)      /* s4 = inptr[16] */
+    lh          s5, 64(a0)      /* s5 = inptr[32] */
+    lh          s6, 96(a0)      /* s6 = inptr[48] */
+    lh          t1, 112(a0)     /* t1 = inptr[56] */
+    lh          t7, 16(a0)      /* t7 = inptr[8] */
+    lh          t5, 80(a0)      /* t5 = inptr[40] */
+    lh          t3, 48(a0)      /* t3 = inptr[24] */
+    or          s4, s4, t1
+    or          s4, s4, t3
+    or          s4, s4, t5
+    or          s4, s4, t7
+    or          s4, s4, s5
+    or          s4, s4, s6
+    bnez        s4, 2f
+     addiu      v1, v1, -1
+    lh          s5, 0(a1)       /* quantptr[DCTSIZE*0] */
+    lh          s6, 0(a0)       /* inptr[DCTSIZE*0] */
+    mul         s5, s5, s6      /* DEQUANTIZE(inptr[0], quantptr[0]) */
+    sll         s5, s5, 2
+    sw          s5, 0(v0)
+    sw          s5, 32(v0)
+    sw          s5, 64(v0)
+    sw          s5, 96(v0)
+    sw          s5, 128(v0)
+    sw          s5, 160(v0)
+    sw          s5, 192(v0)
+    b           3f
+     sw         s5, 224(v0)
+2:
+    lh          t0, 112(a1)
+    lh          t2, 48(a1)
+    lh          t4, 80(a1)
+    lh          t6, 16(a1)
+    mul         t0, t0, t1      /* DEQUANTIZE(inptr[DCTSIZE*7],
+                                              quantptr[DCTSIZE*7]) */
+    mul         t1, t2, t3      /* DEQUANTIZE(inptr[DCTSIZE*3],
+                                              quantptr[DCTSIZE*3]) */
+    mul         t2, t4, t5      /* DEQUANTIZE(inptr[DCTSIZE*5],
+                                              quantptr[DCTSIZE*5]) */
+    mul         t3, t6, t7      /* DEQUANTIZE(inptr[DCTSIZE*1],
+                                              quantptr[DCTSIZE*1]) */
+    lh          t4, 32(a1)
+    lh          t5, 32(a0)
+    lh          t6, 96(a1)
+    lh          t7, 96(a0)
+    addu        s0, t0, t1       /* z3 = tmp0 + tmp2 */
+    addu        s1, t1, t2       /* z2 = tmp1 + tmp2 */
+    addu        s2, t2, t3       /* z4 = tmp1 + tmp3 */
+    addu        s3, s0, s2       /* z3 + z4 */
+    addiu       t9, zero, 9633   /* FIX_1_175875602 */
+    mul         s3, s3, t9       /* z5 = MULTIPLY(z3 + z4, FIX_1_175875602) */
+    addu        t8, t0, t3       /* z1 = tmp0 + tmp3 */
+    addiu       t9, zero, 2446   /* FIX_0_298631336 */
+    mul         t0, t0, t9       /* tmp0 = MULTIPLY(tmp0, FIX_0_298631336) */
+    addiu       t9, zero, 16819  /* FIX_2_053119869 */
+    mul         t2, t2, t9       /* tmp1 = MULTIPLY(tmp1, FIX_2_053119869) */
+    addiu       t9, zero, 25172  /* FIX_3_072711026 */
+    mul         t1, t1, t9       /* tmp2 = MULTIPLY(tmp2, FIX_3_072711026) */
+    addiu       t9, zero, 12299  /* FIX_1_501321110 */
+    mul         t3, t3, t9       /* tmp3 = MULTIPLY(tmp3, FIX_1_501321110) */
+    addiu       t9, zero, 16069  /* FIX_1_961570560 */
+    mul         s0, s0, t9       /* -z3 = MULTIPLY(z3, FIX_1_961570560) */
+    addiu       t9, zero, 3196   /* FIX_0_390180644 */
+    mul         s2, s2, t9       /* -z4 = MULTIPLY(z4, FIX_0_390180644) */
+    addiu       t9, zero, 7373   /* FIX_0_899976223 */
+    mul         t8, t8, t9       /* -z1 = MULTIPLY(z1, FIX_0_899976223) */
+    addiu       t9, zero, 20995  /* FIX_2_562915447 */
+    mul         s1, s1, t9       /* -z2 = MULTIPLY(z2, FIX_2_562915447) */
+    subu        s0, s3, s0       /* z3 += z5 */
+    addu        t0, t0, s0       /* tmp0 += z3 */
+    addu        t1, t1, s0       /* tmp2 += z3 */
+    subu        s2, s3, s2       /* z4 += z5 */
+    addu        t2, t2, s2       /* tmp1 += z4 */
+    addu        t3, t3, s2       /* tmp3 += z4 */
+    subu        t0, t0, t8       /* tmp0 += z1 */
+    subu        t1, t1, s1       /* tmp2 += z2 */
+    subu        t2, t2, s1       /* tmp1 += z2 */
+    subu        t3, t3, t8       /* tmp3 += z1 */
+    mul         s0, t4, t5       /* DEQUANTIZE(inptr[DCTSIZE*2],
+                                               quantptr[DCTSIZE*2]) */
+    addiu       t9, zero, 6270   /* FIX_0_765366865 */
+    mul         s1, t6, t7       /* DEQUANTIZE(inptr[DCTSIZE*6],
+                                               quantptr[DCTSIZE*6]) */
+    lh          t4, 0(a1)
+    lh          t5, 0(a0)
+    lh          t6, 64(a1)
+    lh          t7, 64(a0)
+    mul         s2, t9, s0       /* MULTIPLY(z2, FIX_0_765366865) */
+    mul         t5, t4, t5       /* DEQUANTIZE(inptr[DCTSIZE*0],
+                                               quantptr[DCTSIZE*0]) */
+    mul         t6, t6, t7       /* DEQUANTIZE(inptr[DCTSIZE*4],
+                                               quantptr[DCTSIZE*4]) */
+    addiu       t9, zero, 4433   /* FIX_0_541196100 */
+    addu        s3, s0, s1       /* z2 + z3 */
+    mul         s3, s3, t9       /* z1 = MULTIPLY(z2 + z3, FIX_0_541196100) */
+    addiu       t9, zero, 15137  /* FIX_1_847759065 */
+    mul         t8, s1, t9       /* MULTIPLY(z3, FIX_1_847759065) */
+    addu        t4, t5, t6
+    subu        t5, t5, t6
+    sll         t4, t4, 13      /* tmp0 = (z2 + z3) << CONST_BITS */
+    sll         t5, t5, 13      /* tmp1 = (z2 - z3) << CONST_BITS */
+    addu        t7, s3, s2      /* tmp3 = z1 + MULTIPLY(z2, FIX_0_765366865) */
+    subu        t6, s3, t8      /* tmp2 =
+                                     z1 + MULTIPLY(z3, -FIX_1_847759065) */
+    addu        s0, t4, t7
+    subu        s1, t4, t7
+    addu        s2, t5, t6
+    subu        s3, t5, t6
+    addu        t4, s0, t3
+    subu        s0, s0, t3
+    addu        t3, s2, t1
+    subu        s2, s2, t1
+    addu        t1, s3, t2
+    subu        s3, s3, t2
+    addu        t2, s1, t0
+    subu        s1, s1, t0
+    shra_r.w    t4, t4, 11
+    shra_r.w    t3, t3, 11
+    shra_r.w    t1, t1, 11
+    shra_r.w    t2, t2, 11
+    shra_r.w    s1, s1, 11
+    shra_r.w    s3, s3, 11
+    shra_r.w    s2, s2, 11
+    shra_r.w    s0, s0, 11
+    sw          t4, 0(v0)
+    sw          t3, 32(v0)
+    sw          t1, 64(v0)
+    sw          t2, 96(v0)
+    sw          s1, 128(v0)
+    sw          s3, 160(v0)
+    sw          s2, 192(v0)
+    sw          s0, 224(v0)
+3:
+    addiu       a1, a1, 2
+    addiu       a0, a0, 2
+    bgtz        v1, 1b
+     addiu      v0, v0, 4
+    move        v0, sp
+    addiu       v1, zero, 8
+4:
+    lw          t0, 8(v0)       /* z2 = (JLONG)wsptr[2] */
+    lw          t1, 24(v0)      /* z3 = (JLONG)wsptr[6] */
+    lw          t2, 0(v0)       /* (JLONG)wsptr[0] */
+    lw          t3, 16(v0)      /* (JLONG)wsptr[4] */
+    lw          s4, 4(v0)       /* (JLONG)wsptr[1] */
+    lw          s5, 12(v0)      /* (JLONG)wsptr[3] */
+    lw          s6, 20(v0)      /* (JLONG)wsptr[5] */
+    lw          s7, 28(v0)      /* (JLONG)wsptr[7] */
+    or          s4, s4, t0
+    or          s4, s4, t1
+    or          s4, s4, t3
+    or          s4, s4, s7
+    or          s4, s4, s5
+    or          s4, s4, s6
+    bnez        s4, 5f
+     addiu      v1, v1, -1
+    shra_r.w    s5, t2, 5
+    andi        s5, s5, 0x3ff
+    lbux        s5, s5(a3)
+    lw          s1, 0(a2)
+    replv.qb    s5, s5
+    usw         s5, 0(s1)
+    usw         s5, 4(s1)
+    b           6f
+     nop
+5:
+    addu        t4, t0, t1       /* z2 + z3 */
+    addiu       t8, zero, 4433   /* FIX_0_541196100 */
+    mul         t5, t4, t8       /* z1 = MULTIPLY(z2 + z3, FIX_0_541196100) */
+    addiu       t8, zero, 15137  /* FIX_1_847759065 */
+    mul         t1, t1, t8       /* MULTIPLY(z3, FIX_1_847759065) */
+    addiu       t8, zero, 6270   /* FIX_0_765366865 */
+    mul         t0, t0, t8       /* MULTIPLY(z2, FIX_0_765366865) */
+    addu        t4, t2, t3       /* (JLONG)wsptr[0] + (JLONG)wsptr[4] */
+    subu        t2, t2, t3       /* (JLONG)wsptr[0] - (JLONG)wsptr[4] */
+    sll         t4, t4, 13       /* tmp0 =
+                                      (wsptr[0] + wsptr[4]) << CONST_BITS */
+    sll         t2, t2, 13       /* tmp1 =
+                                      (wsptr[0] - wsptr[4]) << CONST_BITS */
+    subu        t1, t5, t1       /* tmp2 =
+                                      z1 + MULTIPLY(z3, -FIX_1_847759065) */
+    subu        t3, t2, t1       /* tmp12 = tmp1 - tmp2 */
+    addu        t2, t2, t1       /* tmp11 = tmp1 + tmp2 */
+    addu        t5, t5, t0       /* tmp3 =
+                                      z1 + MULTIPLY(z2, FIX_0_765366865) */
+    subu        t1, t4, t5       /* tmp13 = tmp0 - tmp3 */
+    addu        t0, t4, t5       /* tmp10 = tmp0 + tmp3 */
+    lw          t4, 28(v0)       /* tmp0 = (JLONG)wsptr[7] */
+    lw          t6, 12(v0)       /* tmp2 = (JLONG)wsptr[3] */
+    lw          t5, 20(v0)       /* tmp1 = (JLONG)wsptr[5] */
+    lw          t7, 4(v0)        /* tmp3 = (JLONG)wsptr[1] */
+    addu        s0, t4, t6       /* z3 = tmp0 + tmp2 */
+    addiu       t8, zero, 9633   /* FIX_1_175875602 */
+    addu        s1, t5, t7       /* z4 = tmp1 + tmp3 */
+    addu        s2, s0, s1       /* z3 + z4 */
+    mul         s2, s2, t8       /* z5 = MULTIPLY(z3 + z4, FIX_1_175875602) */
+    addu        s3, t4, t7       /* z1 = tmp0 + tmp3 */
+    addu        t9, t5, t6       /* z2 = tmp1 + tmp2 */
+    addiu       t8, zero, 16069  /* FIX_1_961570560 */
+    mul         s0, s0, t8       /* -z3 = MULTIPLY(z3, FIX_1_961570560) */
+    addiu       t8, zero, 3196   /* FIX_0_390180644 */
+    mul         s1, s1, t8       /* -z4 = MULTIPLY(z4, FIX_0_390180644) */
+    addiu       t8, zero, 2446   /* FIX_0_298631336 */
+    mul         t4, t4, t8       /* tmp0 = MULTIPLY(tmp0, FIX_0_298631336) */
+    addiu       t8, zero, 7373   /* FIX_0_899976223 */
+    mul         s3, s3, t8       /* -z1 = MULTIPLY(z1, FIX_0_899976223) */
+    addiu       t8, zero, 16819  /* FIX_2_053119869 */
+    mul         t5, t5, t8       /* tmp1 = MULTIPLY(tmp1, FIX_2_053119869) */
+    addiu       t8, zero, 20995  /* FIX_2_562915447 */
+    mul         t9, t9, t8       /* -z2 = MULTIPLY(z2, FIX_2_562915447) */
+    addiu       t8, zero, 25172  /* FIX_3_072711026 */
+    mul         t6, t6, t8       /* tmp2 = MULTIPLY(tmp2, FIX_3_072711026) */
+    addiu       t8, zero, 12299  /* FIX_1_501321110 */
+    mul         t7, t7, t8       /* tmp3 = MULTIPLY(tmp3, FIX_1_501321110) */
+    subu        s0, s2, s0       /* z3 += z5 */
+    subu        s1, s2, s1       /* z4 += z5 */
+    addu        t4, t4, s0
+    subu        t4, t4, s3      /* tmp0 */
+    addu        t5, t5, s1
+    subu        t5, t5, t9      /* tmp1 */
+    addu        t6, t6, s0
+    subu        t6, t6, t9      /* tmp2 */
+    addu        t7, t7, s1
+    subu        t7, t7, s3      /* tmp3 */
+    addu        s0, t0, t7
+    subu        t0, t0, t7
+    addu        t7, t2, t6
+    subu        t2, t2, t6
+    addu        t6, t3, t5
+    subu        t3, t3, t5
+    addu        t5, t1, t4
+    subu        t1, t1, t4
+    shra_r.w    s0, s0, 18
+    shra_r.w    t7, t7, 18
+    shra_r.w    t6, t6, 18
+    shra_r.w    t5, t5, 18
+    shra_r.w    t1, t1, 18
+    shra_r.w    t3, t3, 18
+    shra_r.w    t2, t2, 18
+    shra_r.w    t0, t0, 18
+    andi        s0, s0, 0x3ff
+    andi        t7, t7, 0x3ff
+    andi        t6, t6, 0x3ff
+    andi        t5, t5, 0x3ff
+    andi        t1, t1, 0x3ff
+    andi        t3, t3, 0x3ff
+    andi        t2, t2, 0x3ff
+    andi        t0, t0, 0x3ff
+    lw          s1, 0(a2)
+    lbux        s0, s0(a3)
+    lbux        t7, t7(a3)
+    lbux        t6, t6(a3)
+    lbux        t5, t5(a3)
+    lbux        t1, t1(a3)
+    lbux        t3, t3(a3)
+    lbux        t2, t2(a3)
+    lbux        t0, t0(a3)
+    sb          s0, 0(s1)
+    sb          t7, 1(s1)
+    sb          t6, 2(s1)
+    sb          t5, 3(s1)
+    sb          t1, 4(s1)
+    sb          t3, 5(s1)
+    sb          t2, 6(s1)
+    sb          t0, 7(s1)
+6:
+    addiu       v0, v0, 32
+    bgtz        v1, 4b
+     addiu      a2, a2, 4
+    addiu       sp, sp, 256
+
+    RESTORE_REGS_FROM_STACK 32, s0, s1, s2, s3, s4, s5, s6, s7
+
+    j           ra
+     nop
+
+END(jsimd_idct_islow_dspr2)
+
+
+/*****************************************************************************/
+LEAF_DSPR2(jsimd_idct_ifast_cols_dspr2)
+/*
+ * a0 = inptr
+ * a1 = quantptr
+ * a2 = wsptr
+ * a3 = mips_idct_ifast_coefs
+ */
+    SAVE_REGS_ON_STACK 32, s0, s1, s2, s3, s4, s5, s6, s7
+
+    addiu         t9, a0, 16      /* end address */
+    or            AT, a3, zero
+
+0:
+    lw            s0, 0(a1)       /* quantptr[DCTSIZE*0] */
+    lw            t0, 0(a0)       /* inptr[DCTSIZE*0] */
+    lw            t1, 16(a0)      /* inptr[DCTSIZE*1] */
+    muleq_s.w.phl v0, t0, s0      /* tmp0 ... */
+    lw            t2, 32(a0)      /* inptr[DCTSIZE*2] */
+    lw            t3, 48(a0)      /* inptr[DCTSIZE*3] */
+    lw            t4, 64(a0)      /* inptr[DCTSIZE*4] */
+    lw            t5, 80(a0)      /* inptr[DCTSIZE*5] */
+    muleq_s.w.phr t0, t0, s0      /* ... tmp0 ... */
+    lw            t6, 96(a0)      /* inptr[DCTSIZE*6] */
+    lw            t7, 112(a0)     /* inptr[DCTSIZE*7] */
+    or            s4, t1, t2
+    or            s5, t3, t4
+    bnez          s4, 1f
+     ins          t0, v0, 16, 16  /* ... tmp0 */
+    bnez          s5, 1f
+     or           s6, t5, t6
+    or            s6, s6, t7
+    bnez          s6, 1f
+     sw           t0, 0(a2)       /* wsptr[DCTSIZE*0] */
+    sw            t0, 16(a2)      /* wsptr[DCTSIZE*1] */
+    sw            t0, 32(a2)      /* wsptr[DCTSIZE*2] */
+    sw            t0, 48(a2)      /* wsptr[DCTSIZE*3] */
+    sw            t0, 64(a2)      /* wsptr[DCTSIZE*4] */
+    sw            t0, 80(a2)      /* wsptr[DCTSIZE*5] */
+    sw            t0, 96(a2)      /* wsptr[DCTSIZE*6] */
+    sw            t0, 112(a2)     /* wsptr[DCTSIZE*7] */
+    addiu         a0, a0, 4
+    b             2f
+     addiu        a1, a1, 4
+
+1:
+    lw            s1, 32(a1)      /* quantptr[DCTSIZE*2] */
+    lw            s2, 64(a1)      /* quantptr[DCTSIZE*4] */
+    muleq_s.w.phl v0, t2, s1      /* tmp1 ... */
+    muleq_s.w.phr t2, t2, s1      /* ... tmp1 ... */
+    lw            s0, 16(a1)      /* quantptr[DCTSIZE*1] */
+    lw            s1, 48(a1)      /* quantptr[DCTSIZE*3] */
+    lw            s3, 96(a1)      /* quantptr[DCTSIZE*6] */
+    muleq_s.w.phl v1, t4, s2      /* tmp2 ... */
+    muleq_s.w.phr t4, t4, s2      /* ... tmp2 ... */
+    lw            s2, 80(a1)      /* quantptr[DCTSIZE*5] */
+    lw            t8, 4(AT)       /* FIX(1.414213562) */
+    ins           t2, v0, 16, 16  /* ... tmp1 */
+    muleq_s.w.phl v0, t6, s3      /* tmp3 ... */
+    muleq_s.w.phr t6, t6, s3      /* ... tmp3 ... */
+    ins           t4, v1, 16, 16  /* ... tmp2 */
+    addq.ph       s4, t0, t4      /* tmp10 */
+    subq.ph       s5, t0, t4      /* tmp11 */
+    ins           t6, v0, 16, 16  /* ... tmp3 */
+    subq.ph       s6, t2, t6      /* tmp12 ... */
+    addq.ph       s7, t2, t6      /* tmp13 */
+    mulq_s.ph     s6, s6, t8      /* ... tmp12 ... */
+    addq.ph       t0, s4, s7      /* tmp0 */
+    subq.ph       t6, s4, s7      /* tmp3 */
+    muleq_s.w.phl v0, t1, s0      /* tmp4 ... */
+    muleq_s.w.phr t1, t1, s0      /* ... tmp4 ... */
+    shll_s.ph     s6, s6, 1       /* x2 */
+    lw            s3, 112(a1)     /* quantptr[DCTSIZE*7] */
+    subq.ph       s6, s6, s7      /* ... tmp12 */
+    muleq_s.w.phl v1, t7, s3      /* tmp7 ... */
+    muleq_s.w.phr t7, t7, s3      /* ... tmp7 ... */
+    ins           t1, v0, 16, 16  /* ... tmp4 */
+    addq.ph       t2, s5, s6      /* tmp1 */
+    subq.ph       t4, s5, s6      /* tmp2 */
+    muleq_s.w.phl v0, t5, s2      /* tmp6 ... */
+    muleq_s.w.phr t5, t5, s2      /* ... tmp6 ... */
+    ins           t7, v1, 16, 16  /* ... tmp7 */
+    addq.ph       s5, t1, t7      /* z11 */
+    subq.ph       s6, t1, t7      /* z12 */
+    muleq_s.w.phl v1, t3, s1      /* tmp5 ... */
+    muleq_s.w.phr t3, t3, s1      /* ... tmp5 ... */
+    ins           t5, v0, 16, 16  /* ... tmp6 */
+    ins           t3, v1, 16, 16  /* ... tmp5 */
+    addq.ph       s7, t5, t3      /* z13 */
+    subq.ph       v0, t5, t3      /* z10 */
+    addq.ph       t7, s5, s7      /* tmp7 */
+    subq.ph       s5, s5, s7      /* tmp11 ... */
+    addq.ph       v1, v0, s6      /* z5 ... */
+    mulq_s.ph     s5, s5, t8      /* ... tmp11 */
+    lw            t8, 8(AT)       /* FIX(1.847759065) */
+    lw            s4, 0(AT)       /* FIX(1.082392200) */
+    addq.ph       s0, t0, t7
+    subq.ph       s1, t0, t7
+    mulq_s.ph     v1, v1, t8      /* ... z5 */
+    shll_s.ph     s5, s5, 1       /* x2 */
+    lw            t8, 12(AT)      /* FIX(-2.613125930) */
+    sw            s0, 0(a2)       /* wsptr[DCTSIZE*0] */
+    shll_s.ph     v0, v0, 1       /* x4 */
+    mulq_s.ph     v0, v0, t8      /* tmp12 ... */
+    mulq_s.ph     s4, s6, s4      /* tmp10 ... */
+    shll_s.ph     v1, v1, 1       /* x2 */
+    addiu         a0, a0, 4
+    addiu         a1, a1, 4
+    sw            s1, 112(a2)     /* wsptr[DCTSIZE*7] */
+    shll_s.ph     s6, v0, 1       /* x4 */
+    shll_s.ph     s4, s4, 1       /* x2 */
+    addq.ph       s6, s6, v1      /* ... tmp12 */
+    subq.ph       t5, s6, t7      /* tmp6 */
+    subq.ph       s4, s4, v1      /* ... tmp10 */
+    subq.ph       t3, s5, t5      /* tmp5 */
+    addq.ph       s2, t2, t5
+    addq.ph       t1, s4, t3      /* tmp4 */
+    subq.ph       s3, t2, t5
+    sw            s2, 16(a2)      /* wsptr[DCTSIZE*1] */
+    sw            s3, 96(a2)      /* wsptr[DCTSIZE*6] */
+    addq.ph       v0, t4, t3
+    subq.ph       v1, t4, t3
+    sw            v0, 32(a2)      /* wsptr[DCTSIZE*2] */
+    sw            v1, 80(a2)      /* wsptr[DCTSIZE*5] */
+    addq.ph       v0, t6, t1
+    subq.ph       v1, t6, t1
+    sw            v0, 64(a2)      /* wsptr[DCTSIZE*4] */
+    sw            v1, 48(a2)      /* wsptr[DCTSIZE*3] */
+
+2:
+    bne           a0, t9, 0b
+     addiu        a2, a2, 4
+
+    RESTORE_REGS_FROM_STACK 32, s0, s1, s2, s3, s4, s5, s6, s7
+
+    j             ra
+     nop
+
+END(jsimd_idct_ifast_cols_dspr2)
+
+
+/*****************************************************************************/
+LEAF_DSPR2(jsimd_idct_ifast_rows_dspr2)
+/*
+ * a0 = wsptr
+ * a1 = output_buf
+ * a2 = output_col
+ * a3 = mips_idct_ifast_coefs
+ */
+    SAVE_REGS_ON_STACK 40, s0, s1, s2, s3, s4, s5, s6, s7, s8, a3
+
+    addiu         t9, a0, 128     /* end address */
+    lui           s8, 0x8080
+    ori           s8, s8, 0x8080
+
+0:
+    lw            AT, 36(sp)      /* restore $a3 (mips_idct_ifast_coefs) */
+    lw            t0, 0(a0)       /* wsptr[DCTSIZE*0+0/1]  b a */
+    lw            s0, 16(a0)      /* wsptr[DCTSIZE*1+0/1]  B A */
+    lw            t2, 4(a0)       /* wsptr[DCTSIZE*0+2/3]  d c */
+    lw            s2, 20(a0)      /* wsptr[DCTSIZE*1+2/3]  D C */
+    lw            t4, 8(a0)       /* wsptr[DCTSIZE*0+4/5]  f e */
+    lw            s4, 24(a0)      /* wsptr[DCTSIZE*1+4/5]  F E */
+    lw            t6, 12(a0)      /* wsptr[DCTSIZE*0+6/7]  h g */
+    lw            s6, 28(a0)      /* wsptr[DCTSIZE*1+6/7]  H G */
+    precrq.ph.w   t1, s0, t0      /* B b */
+    ins           t0, s0, 16, 16  /* A a */
+    bnez          t1, 1f
+     or           s0, t2, s2
+    bnez          s0, 1f
+     or           s0, t4, s4
+    bnez          s0, 1f
+     or           s0, t6, s6
+    bnez          s0, 1f
+     shll_s.ph    s0, t0, 2       /* A a */
+    lw            a3, 0(a1)
+    lw            AT, 4(a1)
+    precrq.ph.w   t0, s0, s0      /* A A */
+    ins           s0, s0, 16, 16  /* a a */
+    addu          a3, a3, a2
+    addu          AT, AT, a2
+    precrq.qb.ph  t0, t0, t0      /* A A A A */
+    precrq.qb.ph  s0, s0, s0      /* a a a a */
+    addu.qb       s0, s0, s8
+    addu.qb       t0, t0, s8
+    sw            s0, 0(a3)
+    sw            s0, 4(a3)
+    sw            t0, 0(AT)
+    sw            t0, 4(AT)
+    addiu         a0, a0, 32
+    bne           a0, t9, 0b
+     addiu        a1, a1, 8
+    b             2f
+     nop
+
+1:
+    precrq.ph.w   t3, s2, t2
+    ins           t2, s2, 16, 16
+    precrq.ph.w   t5, s4, t4
+    ins           t4, s4, 16, 16
+    precrq.ph.w   t7, s6, t6
+    ins           t6, s6, 16, 16
+    lw            t8, 4(AT)       /* FIX(1.414213562) */
+    addq.ph       s4, t0, t4      /* tmp10 */
+    subq.ph       s5, t0, t4      /* tmp11 */
+    subq.ph       s6, t2, t6      /* tmp12 ... */
+    addq.ph       s7, t2, t6      /* tmp13 */
+    mulq_s.ph     s6, s6, t8      /* ... tmp12 ... */
+    addq.ph       t0, s4, s7      /* tmp0 */
+    subq.ph       t6, s4, s7      /* tmp3 */
+    shll_s.ph     s6, s6, 1       /* x2 */
+    subq.ph       s6, s6, s7      /* ... tmp12 */
+    addq.ph       t2, s5, s6      /* tmp1 */
+    subq.ph       t4, s5, s6      /* tmp2 */
+    addq.ph       s5, t1, t7      /* z11 */
+    subq.ph       s6, t1, t7      /* z12 */
+    addq.ph       s7, t5, t3      /* z13 */
+    subq.ph       v0, t5, t3      /* z10 */
+    addq.ph       t7, s5, s7      /* tmp7 */
+    subq.ph       s5, s5, s7      /* tmp11 ... */
+    addq.ph       v1, v0, s6      /* z5 ... */
+    mulq_s.ph     s5, s5, t8      /* ... tmp11 */
+    lw            t8, 8(AT)       /* FIX(1.847759065) */
+    lw            s4, 0(AT)       /* FIX(1.082392200) */
+    addq.ph       s0, t0, t7      /* tmp0 + tmp7 */
+    subq.ph       s7, t0, t7      /* tmp0 - tmp7 */
+    mulq_s.ph     v1, v1, t8      /* ... z5 */
+    lw            a3, 0(a1)
+    lw            t8, 12(AT)      /* FIX(-2.613125930) */
+    shll_s.ph     s5, s5, 1       /* x2 */
+    addu          a3, a3, a2
+    shll_s.ph     v0, v0, 1       /* x4 */
+    mulq_s.ph     v0, v0, t8      /* tmp12 ... */
+    mulq_s.ph     s4, s6, s4      /* tmp10 ... */
+    shll_s.ph     v1, v1, 1       /* x2 */
+    addiu         a0, a0, 32
+    addiu         a1, a1, 8
+    shll_s.ph     s6, v0, 1       /* x4 */
+    shll_s.ph     s4, s4, 1       /* x2 */
+    addq.ph       s6, s6, v1      /* ... tmp12 */
+    shll_s.ph     s0, s0, 2
+    subq.ph       t5, s6, t7      /* tmp6 */
+    subq.ph       s4, s4, v1      /* ... tmp10 */
+    subq.ph       t3, s5, t5      /* tmp5 */
+    shll_s.ph     s7, s7, 2
+    addq.ph       t1, s4, t3      /* tmp4 */
+    addq.ph       s1, t2, t5      /* tmp1 + tmp6 */
+    subq.ph       s6, t2, t5      /* tmp1 - tmp6 */
+    addq.ph       s2, t4, t3      /* tmp2 + tmp5 */
+    subq.ph       s5, t4, t3      /* tmp2 - tmp5 */
+    addq.ph       s4, t6, t1      /* tmp3 + tmp4 */
+    subq.ph       s3, t6, t1      /* tmp3 - tmp4 */
+    shll_s.ph     s1, s1, 2
+    shll_s.ph     s2, s2, 2
+    shll_s.ph     s3, s3, 2
+    shll_s.ph     s4, s4, 2
+    shll_s.ph     s5, s5, 2
+    shll_s.ph     s6, s6, 2
+    precrq.ph.w   t0, s1, s0      /* B A */
+    ins           s0, s1, 16, 16  /* b a */
+    precrq.ph.w   t2, s3, s2      /* D C */
+    ins           s2, s3, 16, 16  /* d c */
+    precrq.ph.w   t4, s5, s4      /* F E */
+    ins           s4, s5, 16, 16  /* f e */
+    precrq.ph.w   t6, s7, s6      /* H G */
+    ins           s6, s7, 16, 16  /* h g */
+    precrq.qb.ph  t0, t2, t0      /* D C B A */
+    precrq.qb.ph  s0, s2, s0      /* d c b a */
+    precrq.qb.ph  t4, t6, t4      /* H G F E */
+    precrq.qb.ph  s4, s6, s4      /* h g f e */
+    addu.qb       s0, s0, s8
+    addu.qb       s4, s4, s8
+    sw            s0, 0(a3)       /* outptr[0/1/2/3]       d c b a */
+    sw            s4, 4(a3)       /* outptr[4/5/6/7]       h g f e */
+    lw            a3, -4(a1)
+    addu.qb       t0, t0, s8
+    addu          a3, a3, a2
+    addu.qb       t4, t4, s8
+    sw            t0, 0(a3)       /* outptr[0/1/2/3]       D C B A */
+    bne           a0, t9, 0b
+     sw           t4, 4(a3)       /* outptr[4/5/6/7]       H G F E */
+
+2:
+
+    RESTORE_REGS_FROM_STACK 40, s0, s1, s2, s3, s4, s5, s6, s7, s8, a3
+
+    j             ra
+     nop
+
+END(jsimd_idct_ifast_rows_dspr2)
+
+
+/*****************************************************************************/
+LEAF_DSPR2(jsimd_fdct_islow_dspr2)
+/*
+ * a0 = data
+ */
+    SAVE_REGS_ON_STACK 40, s0, s1, s2, s3, s4, s5, s6, s7, s8
+
+    lui         t0, 6437
+    ori         t0, 2260
+    lui         t1, 9633
+    ori         t1, 11363
+    lui         t2, 0xd39e
+    ori         t2, 0xe6dc
+    lui         t3, 0xf72d
+    ori         t3, 9633
+    lui         t4, 2261
+    ori         t4, 9633
+    lui         t5, 0xd39e
+    ori         t5, 6437
+    lui         t6, 9633
+    ori         t6, 0xd39d
+    lui         t7, 0xe6dc
+    ori         t7, 2260
+    lui         t8, 4433
+    ori         t8, 10703
+    lui         t9, 0xd630
+    ori         t9, 4433
+    li          s8, 8
+    move        a1, a0
+1:
+    lw          s0, 0(a1)       /* tmp0 = 1|0 */
+    lw          s1, 4(a1)       /* tmp1 = 3|2 */
+    lw          s2, 8(a1)       /* tmp2 = 5|4 */
+    lw          s3, 12(a1)      /* tmp3 = 7|6 */
+    packrl.ph   s1, s1, s1      /* tmp1 = 2|3 */
+    packrl.ph   s3, s3, s3      /* tmp3 = 6|7 */
+    subq.ph     s7, s1, s2      /* tmp7 = 2-5|3-4 = t5|t4 */
+    subq.ph     s5, s0, s3      /* tmp5 = 1-6|0-7 = t6|t7 */
+    mult        $0, $0          /* ac0  = 0 */
+    dpa.w.ph    $ac0, s7, t0    /* ac0 += t5*  6437 + t4*  2260 */
+    dpa.w.ph    $ac0, s5, t1    /* ac0 += t6*  9633 + t7* 11363 */
+    mult        $ac1, $0, $0    /* ac1  = 0 */
+    dpa.w.ph    $ac1, s7, t2    /* ac1 += t5*-11362 + t4* -6436 */
+    dpa.w.ph    $ac1, s5, t3    /* ac1 += t6* -2259 + t7*  9633 */
+    mult        $ac2, $0, $0    /* ac2  = 0 */
+    dpa.w.ph    $ac2, s7, t4    /* ac2 += t5*  2261 + t4*  9633 */
+    dpa.w.ph    $ac2, s5, t5    /* ac2 += t6*-11362 + t7*  6437 */
+    mult        $ac3, $0, $0    /* ac3  = 0 */
+    dpa.w.ph    $ac3, s7, t6    /* ac3 += t5*  9633 + t4*-11363 */
+    dpa.w.ph    $ac3, s5, t7    /* ac3 += t6* -6436 + t7*  2260 */
+    addq.ph     s6, s1, s2      /* tmp6 = 2+5|3+4 = t2|t3 */
+    addq.ph     s4, s0, s3      /* tmp4 = 1+6|0+7 = t1|t0 */
+    extr_r.w    s0, $ac0, 11    /* tmp0 = (ac0 + 1024) >> 11 */
+    extr_r.w    s1, $ac1, 11    /* tmp1 = (ac1 + 1024) >> 11 */
+    extr_r.w    s2, $ac2, 11    /* tmp2 = (ac2 + 1024) >> 11 */
+    extr_r.w    s3, $ac3, 11    /* tmp3 = (ac3 + 1024) >> 11 */
+    addq.ph     s5, s4, s6      /* tmp5 = t1+t2|t0+t3 = t11|t10 */
+    subq.ph     s7, s4, s6      /* tmp7 = t1-t2|t0-t3 = t12|t13 */
+    sh          s0, 2(a1)
+    sh          s1, 6(a1)
+    sh          s2, 10(a1)
+    sh          s3, 14(a1)
+    mult        $0, $0          /* ac0  = 0 */
+    dpa.w.ph    $ac0, s7, t8    /* ac0 += t12*  4433 + t13* 10703 */
+    mult        $ac1, $0, $0    /* ac1  = 0 */
+    dpa.w.ph    $ac1, s7, t9    /* ac1 += t12*-10704 + t13*  4433 */
+    sra         s4, s5, 16      /* tmp4 = t11 */
+    addiu       a1, a1, 16
+    addiu       s8, s8, -1
+    extr_r.w    s0, $ac0, 11    /* tmp0 = (ac0 + 1024) >> 11 */
+    extr_r.w    s1, $ac1, 11    /* tmp1 = (ac1 + 1024) >> 11 */
+    addu        s2, s5, s4      /* tmp2 = t10 + t11 */
+    subu        s3, s5, s4      /* tmp3 = t10 - t11 */
+    sll         s2, s2, 2       /* tmp2 = (t10 + t11) << 2 */
+    sll         s3, s3, 2       /* tmp3 = (t10 - t11) << 2 */
+    sh          s2, -16(a1)
+    sh          s3, -8(a1)
+    sh          s0, -12(a1)
+    bgtz        s8, 1b
+     sh         s1, -4(a1)
+    li          t0, 2260
+    li          t1, 11363
+    li          t2, 9633
+    li          t3, 6436
+    li          t4, 6437
+    li          t5, 2261
+    li          t6, 11362
+    li          t7, 2259
+    li          t8, 4433
+    li          t9, 10703
+    li          a1, 10704
+    li          s8, 8
+
+2:
+    lh          a2, 0(a0)       /* 0 */
+    lh          a3, 16(a0)      /* 8 */
+    lh          v0, 32(a0)      /* 16 */
+    lh          v1, 48(a0)      /* 24 */
+    lh          s4, 64(a0)      /* 32 */
+    lh          s5, 80(a0)      /* 40 */
+    lh          s6, 96(a0)      /* 48 */
+    lh          s7, 112(a0)     /* 56 */
+    addu        s2, v0, s5      /* tmp2 = 16 + 40 */
+    subu        s5, v0, s5      /* tmp5 = 16 - 40 */
+    addu        s3, v1, s4      /* tmp3 = 24 + 32 */
+    subu        s4, v1, s4      /* tmp4 = 24 - 32 */
+    addu        s0, a2, s7      /* tmp0 =  0 + 56 */
+    subu        s7, a2, s7      /* tmp7 =  0 - 56 */
+    addu        s1, a3, s6      /* tmp1 =  8 + 48 */
+    subu        s6, a3, s6      /* tmp6 =  8 - 48 */
+    addu        a2, s0, s3      /* tmp10 = tmp0 + tmp3 */
+    subu        v1, s0, s3      /* tmp13 = tmp0 - tmp3 */
+    addu        a3, s1, s2      /* tmp11 = tmp1 + tmp2 */
+    subu        v0, s1, s2      /* tmp12 = tmp1 - tmp2 */
+    mult        s7, t1          /* ac0  = tmp7 * c1 */
+    madd        s4, t0          /* ac0 += tmp4 * c0 */
+    madd        s5, t4          /* ac0 += tmp5 * c4 */
+    madd        s6, t2          /* ac0 += tmp6 * c2 */
+    mult        $ac1, s7, t2    /* ac1  = tmp7 * c2 */
+    msub        $ac1, s4, t3    /* ac1 -= tmp4 * c3 */
+    msub        $ac1, s5, t6    /* ac1 -= tmp5 * c6 */
+    msub        $ac1, s6, t7    /* ac1 -= tmp6 * c7 */
+    mult        $ac2, s7, t4    /* ac2  = tmp7 * c4 */
+    madd        $ac2, s4, t2    /* ac2 += tmp4 * c2 */
+    madd        $ac2, s5, t5    /* ac2 += tmp5 * c5 */
+    msub        $ac2, s6, t6    /* ac2 -= tmp6 * c6 */
+    mult        $ac3, s7, t0    /* ac3  = tmp7 * c0 */
+    msub        $ac3, s4, t1    /* ac3 -= tmp4 * c1 */
+    madd        $ac3, s5, t2    /* ac3 += tmp5 * c2 */
+    msub        $ac3, s6, t3    /* ac3 -= tmp6 * c3 */
+    extr_r.w    s0, $ac0, 15    /* tmp0 = (ac0 + 16384) >> 15 */
+    extr_r.w    s1, $ac1, 15    /* tmp1 = (ac1 + 16384) >> 15 */
+    extr_r.w    s2, $ac2, 15    /* tmp2 = (ac2 + 16384) >> 15 */
+    extr_r.w    s3, $ac3, 15    /* tmp3 = (ac3 + 16384) >> 15 */
+    addiu       s8, s8, -1
+    addu        s4, a2, a3      /* tmp4 = tmp10 + tmp11 */
+    subu        s5, a2, a3      /* tmp5 = tmp10 - tmp11 */
+    sh          s0, 16(a0)
+    sh          s1, 48(a0)
+    sh          s2, 80(a0)
+    sh          s3, 112(a0)
+    mult        v0, t8          /* ac0  = tmp12 * c8 */
+    madd        v1, t9          /* ac0 += tmp13 * c9 */
+    mult        $ac1, v1, t8    /* ac1  = tmp13 * c8 */
+    msub        $ac1, v0, a1    /* ac1 -= tmp12 * c10 */
+    addiu       a0, a0, 2
+    extr_r.w    s6, $ac0, 15    /* tmp6 = (ac0 + 16384) >> 15 */
+    extr_r.w    s7, $ac1, 15    /* tmp7 = (ac1 + 16384) >> 15 */
+    shra_r.w    s4, s4, 2       /* tmp4 = (tmp4 + 2) >> 2 */
+    shra_r.w    s5, s5, 2       /* tmp5 = (tmp5 + 2) >> 2 */
+    sh          s4, -2(a0)
+    sh          s5, 62(a0)
+    sh          s6, 30(a0)
+    bgtz        s8, 2b
+     sh         s7, 94(a0)
+
+    RESTORE_REGS_FROM_STACK 40, s0, s1, s2, s3, s4, s5, s6, s7, s8
+
+    jr          ra
+     nop
+
+END(jsimd_fdct_islow_dspr2)
+
+
+/**************************************************************************/
+LEAF_DSPR2(jsimd_fdct_ifast_dspr2)
+/*
+ * a0 = data
+ */
+    .set at
+
+    SAVE_REGS_ON_STACK 8, s0, s1
+
+    li          a1, 0x014e014e  /* FIX_1_306562965 (334 << 16) |
+                                                   (334 & 0xffff) */
+    li          a2, 0x008b008b  /* FIX_0_541196100 (139 << 16) |
+                                                   (139 & 0xffff) */
+    li          a3, 0x00620062  /* FIX_0_382683433 (98 << 16) |
+                                                   (98 & 0xffff) */
+    li          s1, 0x00b500b5  /* FIX_0_707106781 (181 << 16) |
+                                                   (181 & 0xffff) */
+
+    move        v0, a0
+    addiu       v1, v0, 128     /* end address */
+
+0:
+    lw          t0, 0(v0)       /* tmp0 = 1|0 */
+    lw          t1, 4(v0)       /* tmp1 = 3|2 */
+    lw          t2, 8(v0)       /* tmp2 = 5|4 */
+    lw          t3, 12(v0)      /* tmp3 = 7|6 */
+    packrl.ph   t1, t1, t1      /* tmp1 = 2|3 */
+    packrl.ph   t3, t3, t3      /* tmp3 = 6|7 */
+    subq.ph     t7, t1, t2      /* tmp7 = 2-5|3-4 = t5|t4 */
+    subq.ph     t5, t0, t3      /* tmp5 = 1-6|0-7 = t6|t7 */
+    addq.ph     t6, t1, t2      /* tmp6 = 2+5|3+4 = t2|t3 */
+    addq.ph     t4, t0, t3      /* tmp4 = 1+6|0+7 = t1|t0 */
+    addq.ph     t8, t4, t6      /* tmp5 = t1+t2|t0+t3 = t11|t10 */
+    subq.ph     t9, t4, t6      /* tmp7 = t1-t2|t0-t3 = t12|t13 */
+    sra         t4, t8, 16      /* tmp4 = t11 */
+    mult        $0, $0          /* ac0  = 0 */
+    dpa.w.ph    $ac0, t9, s1
+    mult        $ac1, $0, $0    /* ac1  = 0 */
+    dpa.w.ph    $ac1, t7, a3    /* ac1 += t4*98 + t5*98 */
+    dpsx.w.ph   $ac1, t5, a3    /* ac1 += t6*98 + t7*98 */
+    mult        $ac2, $0, $0    /* ac2  = 0 */
+    dpa.w.ph    $ac2, t7, a2    /* ac2 += t4*139 + t5*139 */
+    mult        $ac3, $0, $0    /* ac3  = 0 */
+    dpa.w.ph    $ac3, t5, a1    /* ac3 += t6*334 + t7*334 */
+    precrq.ph.w t0, t5, t7      /* t0 = t5|t6 */
+    addq.ph     t2, t8, t4      /* tmp2 = t10 + t11 */
+    subq.ph     t3, t8, t4      /* tmp3 = t10 - t11 */
+    extr.w      t4, $ac0, 8
+    mult        $0, $0          /* ac0  = 0 */
+    dpa.w.ph    $ac0, t0, s1    /* ac0 += t5*181 + t6*181 */
+    extr.w      t0, $ac1, 8     /* t0 = z5 */
+    extr.w      t1, $ac2, 8     /* t1 = MULTIPLY(tmp10, 139) */
+    extr.w      t7, $ac3, 8     /* t2 = MULTIPLY(tmp12, 334) */
+    extr.w      t8, $ac0, 8     /* t8 = z3 = MULTIPLY(tmp11, 181) */
+    add         t6, t1, t0      /* t6 = z2 */
+    add         t7, t7, t0      /* t7 = z4 */
+    subq.ph     t0, t5, t8      /* t0 = z13 = tmp7 - z3 */
+    addq.ph     t8, t5, t8      /* t9 = z11 = tmp7 + z3 */
+    addq.ph     t1, t0, t6      /* t1 = z13 + z2 */
+    subq.ph     t6, t0, t6      /* t6 = z13 - z2 */
+    addq.ph     t0, t8, t7      /* t0 = z11 + z4 */
+    subq.ph     t7, t8, t7      /* t7 = z11 - z4 */
+    addq.ph     t5, t4, t9
+    subq.ph     t4, t9, t4
+    sh          t2, 0(v0)
+    sh          t5, 4(v0)
+    sh          t3, 8(v0)
+    sh          t4, 12(v0)
+    sh          t1, 10(v0)
+    sh          t6, 6(v0)
+    sh          t0, 2(v0)
+    sh          t7, 14(v0)
+    addiu       v0, 16
+    bne         v1, v0, 0b
+     nop
+    move        v0, a0
+    addiu       v1, v0, 16
+
+1:
+    lh          t0, 0(v0)       /* 0 */
+    lh          t1, 16(v0)      /* 8 */
+    lh          t2, 32(v0)      /* 16 */
+    lh          t3, 48(v0)      /* 24 */
+    lh          t4, 64(v0)      /* 32 */
+    lh          t5, 80(v0)      /* 40 */
+    lh          t6, 96(v0)      /* 48 */
+    lh          t7, 112(v0)     /* 56 */
+    add         t8, t0, t7      /* t8 = tmp0 */
+    sub         t7, t0, t7      /* t7 = tmp7 */
+    add         t0, t1, t6      /* t0 = tmp1 */
+    sub         t1, t1, t6      /* t1 = tmp6 */
+    add         t6, t2, t5      /* t6 = tmp2 */
+    sub         t5, t2, t5      /* t5 = tmp5 */
+    add         t2, t3, t4      /* t2 = tmp3 */
+    sub         t3, t3, t4      /* t3 = tmp4 */
+    add         t4, t8, t2      /* t4 = tmp10 = tmp0 + tmp3 */
+    sub         t8, t8, t2      /* t8 = tmp13 = tmp0 - tmp3 */
+    sub         s0, t0, t6      /* s0 = tmp12 = tmp1 - tmp2 */
+    ins         t8, s0, 16, 16  /* t8 = tmp12|tmp13 */
+    add         t2, t0, t6      /* t2 = tmp11 = tmp1 + tmp2 */
+    mult        $0, $0          /* ac0  = 0 */
+    dpa.w.ph    $ac0, t8, s1    /* ac0 += t12*181 + t13*181 */
+    add         s0, t4, t2      /* t8 = tmp10+tmp11 */
+    sub         t4, t4, t2      /* t4 = tmp10-tmp11 */
+    sh          s0, 0(v0)
+    sh          t4, 64(v0)
+    extr.w      t2, $ac0, 8     /* z1 = MULTIPLY(tmp12+tmp13,
+                                                 FIX_0_707106781) */
+    addq.ph     t4, t8, t2      /* t9 = tmp13 + z1 */
+    subq.ph     t8, t8, t2      /* t2 = tmp13 - z1 */
+    sh          t4, 32(v0)
+    sh          t8, 96(v0)
+    add         t3, t3, t5      /* t3 = tmp10 = tmp4 + tmp5 */
+    add         t0, t5, t1      /* t0 = tmp11 = tmp5 + tmp6 */
+    add         t1, t1, t7      /* t1 = tmp12 = tmp6 + tmp7 */
+    andi        t4, a1, 0xffff
+    mul         s0, t1, t4
+    sra         s0, s0, 8       /* s0 = z4 =
+                                     MULTIPLY(tmp12, FIX_1_306562965) */
+    ins         t1, t3, 16, 16  /* t1 = tmp10|tmp12 */
+    mult        $0, $0          /* ac0  = 0 */
+    mulsa.w.ph  $ac0, t1, a3    /* ac0 += t10*98 - t12*98 */
+    extr.w      t8, $ac0, 8     /* z5 = MULTIPLY(tmp10-tmp12,
+                                                 FIX_0_382683433) */
+    add         t2, t7, t8      /* t2 = tmp7 + z5 */
+    sub         t7, t7, t8      /* t7 = tmp7 - z5 */
+    andi        t4, a2, 0xffff
+    mul         t8, t3, t4
+    sra         t8, t8, 8       /* t8 = z2 =
+                                     MULTIPLY(tmp10, FIX_0_541196100) */
+    andi        t4, s1, 0xffff
+    mul         t6, t0, t4
+    sra         t6, t6, 8       /* t6 = z3 =
+                                     MULTIPLY(tmp11, FIX_0_707106781) */
+    add         t0, t6, t8      /* t0 = z3 + z2 */
+    sub         t1, t6, t8      /* t1 = z3 - z2 */
+    add         t3, t6, s0      /* t3 = z3 + z4 */
+    sub         t4, t6, s0      /* t4 = z3 - z4 */
+    sub         t5, t2, t1      /* t5 = dataptr[5] */
+    sub         t6, t7, t0      /* t6 = dataptr[3] */
+    add         t3, t2, t3      /* t3 = dataptr[1] */
+    add         t4, t7, t4      /* t4 = dataptr[7] */
+    sh          t5, 80(v0)
+    sh          t6, 48(v0)
+    sh          t3, 16(v0)
+    sh          t4, 112(v0)
+    addiu       v0, 2
+    bne         v0, v1, 1b
+     nop
+
+    RESTORE_REGS_FROM_STACK 8, s0, s1
+
+    j           ra
+     nop
+END(jsimd_fdct_ifast_dspr2)
+
+
+/*****************************************************************************/
+LEAF_DSPR2(jsimd_quantize_dspr2)
+/*
+ * a0 = coef_block
+ * a1 = divisors
+ * a2 = workspace
+ */
+    .set at
+
+    SAVE_REGS_ON_STACK 16, s0, s1, s2
+
+    addiu       v0, a2, 124     /* v0 = workspace_end */
+    lh          t0, 0(a2)
+    lh          t1, 0(a1)
+    lh          t2, 128(a1)
+    sra         t3, t0, 15
+    sll         t3, t3, 1
+    addiu       t3, t3, 1
+    mul         t0, t0, t3
+    lh          t4, 384(a1)
+    lh          t5, 130(a1)
+    lh          t6, 2(a2)
+    lh          t7, 2(a1)
+    lh          t8, 386(a1)
+
+1:
+    andi        t1, 0xffff
+    add         t9, t0, t2
+    andi        t9, 0xffff
+    mul         v1, t9, t1
+    sra         s0, t6, 15
+    sll         s0, s0, 1
+    addiu       s0, s0, 1
+    addiu       t9, t4, 16
+    srav        v1, v1, t9
+    mul         v1, v1, t3
+    mul         t6, t6, s0
+    andi        t7, 0xffff
+    addiu       a2, a2, 4
+    addiu       a1, a1, 4
+    add         s1, t6, t5
+    andi        s1, 0xffff
+    sh          v1, 0(a0)
+
+    mul         s2, s1, t7
+    addiu       s1, t8, 16
+    srav        s2, s2, s1
+    mul         s2, s2, s0
+    lh          t0, 0(a2)
+    lh          t1, 0(a1)
+    sra         t3, t0, 15
+    sll         t3, t3, 1
+    addiu       t3, t3, 1
+    mul         t0, t0, t3
+    lh          t2, 128(a1)
+    lh          t4, 384(a1)
+    lh          t5, 130(a1)
+    lh          t8, 386(a1)
+    lh          t6, 2(a2)
+    lh          t7, 2(a1)
+    sh          s2, 2(a0)
+    lh          t0, 0(a2)
+    sra         t3, t0, 15
+    sll         t3, t3, 1
+    addiu       t3, t3, 1
+    mul         t0, t0, t3
+    bne         a2, v0, 1b
+     addiu      a0, a0, 4
+
+    andi        t1, 0xffff
+    add         t9, t0, t2
+    andi        t9, 0xffff
+    mul         v1, t9, t1
+    sra         s0, t6, 15
+    sll         s0, s0, 1
+    addiu       s0, s0, 1
+    addiu       t9, t4, 16
+    srav        v1, v1, t9
+    mul         v1, v1, t3
+    mul         t6, t6, s0
+    andi        t7, 0xffff
+    sh          v1, 0(a0)
+    add         s1, t6, t5
+    andi        s1, 0xffff
+    mul         s2, s1, t7
+    addiu       s1, t8, 16
+    addiu       a2, a2, 4
+    addiu       a1, a1, 4
+    srav        s2, s2, s1
+    mul         s2, s2, s0
+    sh          s2, 2(a0)
+
+    RESTORE_REGS_FROM_STACK 16, s0, s1, s2
+
+    j           ra
+     nop
+
+END(jsimd_quantize_dspr2)
+
+
+#ifndef __mips_soft_float
+
+/*****************************************************************************/
+LEAF_DSPR2(jsimd_quantize_float_dspr2)
+/*
+ * a0 = coef_block
+ * a1 = divisors
+ * a2 = workspace
+ */
+    .set at
+
+    li          t1, 0x46800100  /* integer representation 16384.5 */
+    mtc1        t1, f0
+    li          t0, 63
+0:
+    lwc1        f2, 0(a2)
+    lwc1        f10, 0(a1)
+    lwc1        f4, 4(a2)
+    lwc1        f12, 4(a1)
+    lwc1        f6, 8(a2)
+    lwc1        f14, 8(a1)
+    lwc1        f8, 12(a2)
+    lwc1        f16, 12(a1)
+    madd.s      f2, f0, f2, f10
+    madd.s      f4, f0, f4, f12
+    madd.s      f6, f0, f6, f14
+    madd.s      f8, f0, f8, f16
+    lwc1        f10, 16(a1)
+    lwc1        f12, 20(a1)
+    trunc.w.s   f2, f2
+    trunc.w.s   f4, f4
+    trunc.w.s   f6, f6
+    trunc.w.s   f8, f8
+    lwc1        f14, 24(a1)
+    lwc1        f16, 28(a1)
+    mfc1        t1, f2
+    mfc1        t2, f4
+    mfc1        t3, f6
+    mfc1        t4, f8
+    lwc1        f2, 16(a2)
+    lwc1        f4, 20(a2)
+    lwc1        f6, 24(a2)
+    lwc1        f8, 28(a2)
+    madd.s      f2, f0, f2, f10
+    madd.s      f4, f0, f4, f12
+    madd.s      f6, f0, f6, f14
+    madd.s      f8, f0, f8, f16
+    addiu       t1, t1, -16384
+    addiu       t2, t2, -16384
+    addiu       t3, t3, -16384
+    addiu       t4, t4, -16384
+    trunc.w.s   f2, f2
+    trunc.w.s   f4, f4
+    trunc.w.s   f6, f6
+    trunc.w.s   f8, f8
+    sh          t1, 0(a0)
+    sh          t2, 2(a0)
+    sh          t3, 4(a0)
+    sh          t4, 6(a0)
+    mfc1        t1, f2
+    mfc1        t2, f4
+    mfc1        t3, f6
+    mfc1        t4, f8
+    addiu       t0, t0, -8
+    addiu       a2, a2, 32
+    addiu       a1, a1, 32
+    addiu       t1, t1, -16384
+    addiu       t2, t2, -16384
+    addiu       t3, t3, -16384
+    addiu       t4, t4, -16384
+    sh          t1, 8(a0)
+    sh          t2, 10(a0)
+    sh          t3, 12(a0)
+    sh          t4, 14(a0)
+    bgez        t0, 0b
+     addiu      a0, a0, 16
+
+    j           ra
+     nop
+
+END(jsimd_quantize_float_dspr2)
+
+#endif
+
+
+/*****************************************************************************/
+LEAF_DSPR2(jsimd_idct_2x2_dspr2)
+/*
+ * a0 = compptr->dct_table
+ * a1 = coef_block
+ * a2 = output_buf
+ * a3 = output_col
+ */
+    .set at
+
+    SAVE_REGS_ON_STACK 24, s0, s1, s2, s3, s4, s5
+
+    addiu       sp, sp, -40
+    move        v0, sp
+    addiu       s2, zero, 29692
+    addiu       s3, zero, -10426
+    addiu       s4, zero, 6967
+    addiu       s5, zero, -5906
+    lh          t0, 0(a1)       /* t0 = inptr[DCTSIZE*0] */
+    lh          t5, 0(a0)       /* t5 = quantptr[DCTSIZE*0] */
+    lh          t1, 48(a1)      /* t1 = inptr[DCTSIZE*3] */
+    lh          t6, 48(a0)      /* t6 = quantptr[DCTSIZE*3] */
+    mul         t4, t5, t0
+    lh          t0, 16(a1)      /* t0 = inptr[DCTSIZE*1] */
+    lh          t5, 16(a0)      /* t5 = quantptr[DCTSIZE*1] */
+    mul         t6, t6, t1
+    mul         t5, t5, t0
+    lh          t2, 80(a1)      /* t2 = inptr[DCTSIZE*5] */
+    lh          t7, 80(a0)      /* t7 = quantptr[DCTSIZE*5] */
+    lh          t3, 112(a1)     /* t3 = inptr[DCTSIZE*7] */
+    lh          t8, 112(a0)     /* t8 = quantptr[DCTSIZE*7] */
+    mul         t7, t7, t2
+    mult        zero, zero
+    mul         t8, t8, t3
+    li          s0, 0x73FCD746  /* s0 = (29692 << 16) | (-10426 & 0xffff) */
+    li          s1, 0x1B37E8EE  /* s1 = (6967 << 16) | (-5906 & 0xffff) */
+    ins         t6, t5, 16, 16  /* t6 = t5|t6 */
+    sll         t4, t4, 15
+    dpa.w.ph    $ac0, t6, s0
+    lh          t1, 2(a1)
+    lh          t6, 2(a0)
+    ins         t8, t7, 16, 16  /* t8 = t7|t8 */
+    dpa.w.ph    $ac0, t8, s1
+    mflo        t0, $ac0
+    mul         t5, t6, t1
+    lh          t1, 18(a1)
+    lh          t6, 18(a0)
+    lh          t2, 50(a1)
+    lh          t7, 50(a0)
+    mul         t6, t6, t1
+    subu        t8, t4, t0
+    mul         t7, t7, t2
+    addu        t0, t4, t0
+    shra_r.w    t0, t0, 13
+    lh          t1, 82(a1)
+    lh          t2, 82(a0)
+    lh          t3, 114(a1)
+    lh          t4, 114(a0)
+    shra_r.w    t8, t8, 13
+    mul         t1, t1, t2
+    mul         t3, t3, t4
+    sw          t0, 0(v0)
+    sw          t8, 20(v0)
+    sll         t4, t5, 15
+    ins         t7, t6, 16, 16
+    mult        zero, zero
+    dpa.w.ph    $ac0, t7, s0
+    ins         t3, t1, 16, 16
+    lh          t1, 6(a1)
+    lh          t6, 6(a0)
+    dpa.w.ph    $ac0, t3, s1
+    mflo        t0, $ac0
+    mul         t5, t6, t1
+    lh          t1, 22(a1)
+    lh          t6, 22(a0)
+    lh          t2, 54(a1)
+    lh          t7, 54(a0)
+    mul         t6, t6, t1
+    subu        t8, t4, t0
+    mul         t7, t7, t2
+    addu        t0, t4, t0
+    shra_r.w    t0, t0, 13
+    lh          t1, 86(a1)
+    lh          t2, 86(a0)
+    lh          t3, 118(a1)
+    lh          t4, 118(a0)
+    shra_r.w    t8, t8, 13
+    mul         t1, t1, t2
+    mul         t3, t3, t4
+    sw          t0, 4(v0)
+    sw          t8, 24(v0)
+    sll         t4, t5, 15
+    ins         t7, t6, 16, 16
+    mult        zero, zero
+    dpa.w.ph    $ac0, t7, s0
+    ins         t3, t1, 16, 16
+    lh          t1, 10(a1)
+    lh          t6, 10(a0)
+    dpa.w.ph    $ac0, t3, s1
+    mflo        t0, $ac0
+    mul         t5, t6, t1
+    lh          t1, 26(a1)
+    lh          t6, 26(a0)
+    lh          t2, 58(a1)
+    lh          t7, 58(a0)
+    mul         t6, t6, t1
+    subu        t8, t4, t0
+    mul         t7, t7, t2
+    addu        t0, t4, t0
+    shra_r.w    t0, t0, 13
+    lh          t1, 90(a1)
+    lh          t2, 90(a0)
+    lh          t3, 122(a1)
+    lh          t4, 122(a0)
+    shra_r.w    t8, t8, 13
+    mul         t1, t1, t2
+    mul         t3, t3, t4
+    sw          t0, 8(v0)
+    sw          t8, 28(v0)
+    sll         t4, t5, 15
+    ins         t7, t6, 16, 16
+    mult        zero, zero
+    dpa.w.ph    $ac0, t7, s0
+    ins         t3, t1, 16, 16
+    lh          t1, 14(a1)
+    lh          t6, 14(a0)
+    dpa.w.ph    $ac0, t3, s1
+    mflo        t0, $ac0
+    mul         t5, t6, t1
+    lh          t1, 30(a1)
+    lh          t6, 30(a0)
+    lh          t2, 62(a1)
+    lh          t7, 62(a0)
+    mul         t6, t6, t1
+    subu        t8, t4, t0
+    mul         t7, t7, t2
+    addu        t0, t4, t0
+    shra_r.w    t0, t0, 13
+    lh          t1, 94(a1)
+    lh          t2, 94(a0)
+    lh          t3, 126(a1)
+    lh          t4, 126(a0)
+    shra_r.w    t8, t8, 13
+    mul         t1, t1, t2
+    mul         t3, t3, t4
+    sw          t0, 12(v0)
+    sw          t8, 32(v0)
+    sll         t4, t5, 15
+    ins         t7, t6, 16, 16
+    mult        zero, zero
+    dpa.w.ph    $ac0, t7, s0
+    ins         t3, t1, 16, 16
+    dpa.w.ph    $ac0, t3, s1
+    mflo        t0, $ac0
+    lw          t9, 0(a2)
+    lw          t3, 0(v0)
+    lw          t7, 4(v0)
+    lw          t1, 8(v0)
+    addu        t9, t9, a3
+    sll         t3, t3, 15
+    subu        t8, t4, t0
+    addu        t0, t4, t0
+    shra_r.w    t0, t0, 13
+    shra_r.w    t8, t8, 13
+    sw          t0, 16(v0)
+    sw          t8, 36(v0)
+    lw          t5, 12(v0)
+    lw          t6, 16(v0)
+    mult        t7, s2
+    madd        t1, s3
+    madd        t5, s4
+    madd        t6, s5
+    lw          t5, 24(v0)
+    lw          t7, 28(v0)
+    mflo        t0, $ac0
+    lw          t8, 32(v0)
+    lw          t2, 36(v0)
+    mult        $ac1, t5, s2
+    madd        $ac1, t7, s3
+    madd        $ac1, t8, s4
+    madd        $ac1, t2, s5
+    addu        t1, t3, t0
+    subu        t6, t3, t0
+    shra_r.w    t1, t1, 20
+    shra_r.w    t6, t6, 20
+    mflo        t4, $ac1
+    shll_s.w    t1, t1, 24
+    shll_s.w    t6, t6, 24
+    sra         t1, t1, 24
+    sra         t6, t6, 24
+    addiu       t1, t1, 128
+    addiu       t6, t6, 128
+    lw          t0, 20(v0)
+    sb          t1, 0(t9)
+    sb          t6, 1(t9)
+    sll         t0, t0, 15
+    lw          t9, 4(a2)
+    addu        t1, t0, t4
+    subu        t6, t0, t4
+    addu        t9, t9, a3
+    shra_r.w    t1, t1, 20
+    shra_r.w    t6, t6, 20
+    shll_s.w    t1, t1, 24
+    shll_s.w    t6, t6, 24
+    sra         t1, t1, 24
+    sra         t6, t6, 24
+    addiu       t1, t1, 128
+    addiu       t6, t6, 128
+    sb          t1, 0(t9)
+    sb          t6, 1(t9)
+    addiu       sp, sp, 40
+
+    RESTORE_REGS_FROM_STACK 24, s0, s1, s2, s3, s4, s5
+
+    j           ra
+     nop
+
+END(jsimd_idct_2x2_dspr2)
+
+
+/*****************************************************************************/
+LEAF_DSPR2(jsimd_idct_4x4_dspr2)
+/*
+ * a0     = compptr->dct_table
+ * a1     = coef_block
+ * a2     = output_buf
+ * a3     = output_col
+ * 16(sp) = workspace[DCTSIZE*4]  (buffers data between passes)
+ */
+    .set at
+
+    SAVE_REGS_ON_STACK 32, s0, s1, s2, s3, s4, s5, s6, s7
+
+    lw          v1, 48(sp)
+    move        t0, a1
+    move        t1, v1
+    li          t9, 4
+    li          s0, 0x2e75f93e
+    li          s1, 0x21f9ba79
+    li          s2, 0xecc2efb0
+    li          s3, 0x52031ccd
+
+0:
+    lh          s6, 32(t0)      /* inptr[DCTSIZE*2] */
+    lh          t6, 32(a0)      /* quantptr[DCTSIZE*2] */
+    lh          s7, 96(t0)      /* inptr[DCTSIZE*6] */
+    lh          t7, 96(a0)      /* quantptr[DCTSIZE*6] */
+    mul         t6, s6, t6      /* z2 = (inptr[DCTSIZE*2] *
+                                         quantptr[DCTSIZE*2]) */
+    lh          s4, 0(t0)       /* inptr[DCTSIZE*0] */
+    mul         t7, s7, t7      /* z3 = (inptr[DCTSIZE*6] *
+                                         quantptr[DCTSIZE*6]) */
+    lh          s5, 0(a0)       /* quantptr[0] */
+    li          s6, 15137
+    li          s7, 6270
+    mul         t2, s4, s5      /* tmp0 = (inptr[0] * quantptr[0]) */
+    mul         t6, s6, t6      /* z2 = (inptr[DCTSIZE*2] *
+                                         quantptr[DCTSIZE*2]) */
+    lh          t5, 112(t0)     /* inptr[DCTSIZE*7] */
+    mul         t7, s7, t7      /* z3 = (inptr[DCTSIZE*6] *
+                                         quantptr[DCTSIZE*6]) */
+    lh          s4, 112(a0)     /* quantptr[DCTSIZE*7] */
+    lh          v0, 80(t0)      /* inptr[DCTSIZE*5] */
+    lh          s5, 80(a0)      /* quantptr[DCTSIZE*5] */
+    lh          s6, 48(a0)      /* quantptr[DCTSIZE*3] */
+    sll         t2, t2, 14      /* tmp0 <<= (CONST_BITS+1) */
+    lh          s7, 16(a0)      /* quantptr[DCTSIZE*1] */
+    lh          t8, 16(t0)      /* inptr[DCTSIZE*1] */
+    subu        t6, t6, t7      /* tmp2 =
+                                     MULTIPLY(z2, t5) - MULTIPLY(z3, t6) */
+    lh          t7, 48(t0)      /* inptr[DCTSIZE*3] */
+    mul         t5, s4, t5      /* z1 = (inptr[DCTSIZE*7] *
+                                         quantptr[DCTSIZE*7]) */
+    mul         v0, s5, v0      /* z2 = (inptr[DCTSIZE*5] *
+                                         quantptr[DCTSIZE*5]) */
+    mul         t7, s6, t7      /* z3 = (inptr[DCTSIZE*3] *
+                                         quantptr[DCTSIZE*3]) */
+    mul         t8, s7, t8      /* z4 = (inptr[DCTSIZE*1] *
+                                         quantptr[DCTSIZE*1]) */
+    addu        t3, t2, t6      /* tmp10 = tmp0 + z2 */
+    subu        t4, t2, t6      /* tmp10 = tmp0 - z2 */
+    mult        $ac0, zero, zero
+    mult        $ac1, zero, zero
+    ins         t5, v0, 16, 16
+    ins         t7, t8, 16, 16
+    addiu       t9, t9, -1
+    dpa.w.ph    $ac0, t5, s0
+    dpa.w.ph    $ac0, t7, s1
+    dpa.w.ph    $ac1, t5, s2
+    dpa.w.ph    $ac1, t7, s3
+    mflo        s4, $ac0
+    mflo        s5, $ac1
+    addiu       a0, a0, 2
+    addiu       t1, t1, 4
+    addiu       t0, t0, 2
+    addu        t6, t4, s4
+    subu        t5, t4, s4
+    addu        s6, t3, s5
+    subu        s7, t3, s5
+    shra_r.w    t6, t6, 12      /* DESCALE(tmp12 + temp1, 12) */
+    shra_r.w    t5, t5, 12      /* DESCALE(tmp12 - temp1, 12) */
+    shra_r.w    s6, s6, 12      /* DESCALE(tmp10 + temp2, 12) */
+    shra_r.w    s7, s7, 12      /* DESCALE(tmp10 - temp2, 12) */
+    sw          t6, 28(t1)
+    sw          t5, 60(t1)
+    sw          s6, -4(t1)
+    bgtz        t9, 0b
+     sw         s7, 92(t1)
+    /* second loop three pass */
+    li          t9, 3
+1:
+    lh          s6, 34(t0)      /* inptr[DCTSIZE*2] */
+    lh          t6, 34(a0)      /* quantptr[DCTSIZE*2] */
+    lh          s7, 98(t0)      /* inptr[DCTSIZE*6] */
+    lh          t7, 98(a0)      /* quantptr[DCTSIZE*6] */
+    mul         t6, s6, t6      /* z2 = (inptr[DCTSIZE*2] *
+                                         quantptr[DCTSIZE*2]) */
+    lh          s4, 2(t0)       /* inptr[DCTSIZE*0] */
+    mul         t7, s7, t7      /* z3 = (inptr[DCTSIZE*6] *
+                                         quantptr[DCTSIZE*6]) */
+    lh          s5, 2(a0)       /* quantptr[DCTSIZE*0] */
+    li          s6, 15137
+    li          s7, 6270
+    mul         t2, s4, s5      /* tmp0 = (inptr[0] * quantptr[0]) */
+    mul         v0, s6, t6      /* z2 = (inptr[DCTSIZE*2] *
+                                         quantptr[DCTSIZE*2]) */
+    lh          t5, 114(t0)     /* inptr[DCTSIZE*7] */
+    mul         t7, s7, t7      /* z3 = (inptr[DCTSIZE*6] *
+                                         quantptr[DCTSIZE*6]) */
+    lh          s4, 114(a0)     /* quantptr[DCTSIZE*7] */
+    lh          s5, 82(a0)      /* quantptr[DCTSIZE*5] */
+    lh          t6, 82(t0)      /* inptr[DCTSIZE*5] */
+    sll         t2, t2, 14      /* tmp0 <<= (CONST_BITS+1) */
+    lh          s6, 50(a0)      /* quantptr[DCTSIZE*3] */
+    lh          t8, 18(t0)      /* inptr[DCTSIZE*1] */
+    subu        v0, v0, t7      /* tmp2 =
+                                     MULTIPLY(z2, t5) - MULTIPLY(z3, t6) */
+    lh          t7, 50(t0)      /* inptr[DCTSIZE*3] */
+    lh          s7, 18(a0)      /* quantptr[DCTSIZE*1] */
+    mul         t5, s4, t5      /* z1 = (inptr[DCTSIZE*7] *
+                                         quantptr[DCTSIZE*7]) */
+    mul         t6, s5, t6      /* z2 = (inptr[DCTSIZE*5] *
+                                         quantptr[DCTSIZE*5]) */
+    mul         t7, s6, t7      /* z3 = (inptr[DCTSIZE*3] *
+                                         quantptr[DCTSIZE*3]) */
+    mul         t8, s7, t8      /* z4 = (inptr[DCTSIZE*1] *
+                                         quantptr[DCTSIZE*1]) */
+    addu        t3, t2, v0      /* tmp10 = tmp0 + z2 */
+    subu        t4, t2, v0      /* tmp10 = tmp0 - z2 */
+    mult        $ac0, zero, zero
+    mult        $ac1, zero, zero
+    ins         t5, t6, 16, 16
+    ins         t7, t8, 16, 16
+    dpa.w.ph    $ac0, t5, s0
+    dpa.w.ph    $ac0, t7, s1
+    dpa.w.ph    $ac1, t5, s2
+    dpa.w.ph    $ac1, t7, s3
+    mflo        t5, $ac0
+    mflo        t6, $ac1
+    addiu       t9, t9, -1
+    addiu       t0, t0, 2
+    addiu       a0, a0, 2
+    addiu       t1, t1, 4
+    addu        s5, t4, t5
+    subu        s4, t4, t5
+    addu        s6, t3, t6
+    subu        s7, t3, t6
+    shra_r.w    s5, s5, 12      /* DESCALE(tmp12 + temp1, 12) */
+    shra_r.w    s4, s4, 12      /* DESCALE(tmp12 - temp1, 12) */
+    shra_r.w    s6, s6, 12      /* DESCALE(tmp10 + temp2, 12) */
+    shra_r.w    s7, s7, 12      /* DESCALE(tmp10 - temp2, 12) */
+    sw          s5, 32(t1)
+    sw          s4, 64(t1)
+    sw          s6, 0(t1)
+    bgtz        t9, 1b
+     sw         s7, 96(t1)
+    move        t1, v1
+    li          s4, 15137
+    lw          s6, 8(t1)       /* wsptr[2] */
+    li          s5, 6270
+    lw          s7, 24(t1)      /* wsptr[6] */
+    mul         s4, s4, s6      /* MULTIPLY((JLONG)wsptr[2],
+                                            FIX_1_847759065) */
+    lw          t2, 0(t1)       /* wsptr[0] */
+    mul         s5, s5, s7      /* MULTIPLY((JLONG)wsptr[6],
+                                            -FIX_0_765366865) */
+    lh          t5, 28(t1)      /* wsptr[7] */
+    lh          t6, 20(t1)      /* wsptr[5] */
+    lh          t7, 12(t1)      /* wsptr[3] */
+    lh          t8, 4(t1)       /* wsptr[1] */
+    ins         t5, t6, 16, 16
+    ins         t7, t8, 16, 16
+    mult        $ac0, zero, zero
+    dpa.w.ph    $ac0, t5, s0
+    dpa.w.ph    $ac0, t7, s1
+    mult        $ac1, zero, zero
+    dpa.w.ph    $ac1, t5, s2
+    dpa.w.ph    $ac1, t7, s3
+    sll         t2, t2, 14      /* tmp0 =
+                                     ((JLONG)wsptr[0]) << (CONST_BITS+1) */
+    mflo        s6, $ac0
+    /* MULTIPLY(wsptr[2], FIX_1_847759065) +
+       MULTIPLY(wsptr[6], -FIX_0_765366865) */
+    subu        s4, s4, s5
+    addu        t3, t2, s4      /* tmp10 = tmp0 + z2 */
+    mflo        s7, $ac1
+    subu        t4, t2, s4      /* tmp10 = tmp0 - z2 */
+    addu        t7, t4, s6
+    subu        t8, t4, s6
+    addu        t5, t3, s7
+    subu        t6, t3, s7
+    shra_r.w    t5, t5, 19      /* DESCALE(tmp10 + temp2, 19) */
+    shra_r.w    t6, t6, 19      /* DESCALE(tmp10 - temp2, 19) */
+    shra_r.w    t7, t7, 19      /* DESCALE(tmp12 + temp1, 19) */
+    shra_r.w    t8, t8, 19      /* DESCALE(tmp12 - temp1, 19) */
+    sll         s4, t9, 2
+    lw          v0, 0(a2)       /* output_buf[ctr] */
+    shll_s.w    t5, t5, 24
+    shll_s.w    t6, t6, 24
+    shll_s.w    t7, t7, 24
+    shll_s.w    t8, t8, 24
+    sra         t5, t5, 24
+    sra         t6, t6, 24
+    sra         t7, t7, 24
+    sra         t8, t8, 24
+    addu        v0, v0, a3      /* outptr = output_buf[ctr] + output_col */
+    addiu       t5, t5, 128
+    addiu       t6, t6, 128
+    addiu       t7, t7, 128
+    addiu       t8, t8, 128
+    sb          t5, 0(v0)
+    sb          t7, 1(v0)
+    sb          t8, 2(v0)
+    sb          t6, 3(v0)
+    /* 2 */
+    li          s4, 15137
+    lw          s6, 40(t1)      /* wsptr[2] */
+    li          s5, 6270
+    lw          s7, 56(t1)      /* wsptr[6] */
+    mul         s4, s4, s6      /* MULTIPLY((JLONG)wsptr[2],
+                                            FIX_1_847759065) */
+    lw          t2, 32(t1)      /* wsptr[0] */
+    mul         s5, s5, s7      /* MULTIPLY((JLONG)wsptr[6],
+                                            -FIX_0_765366865) */
+    lh          t5, 60(t1)      /* wsptr[7] */
+    lh          t6, 52(t1)      /* wsptr[5] */
+    lh          t7, 44(t1)      /* wsptr[3] */
+    lh          t8, 36(t1)      /* wsptr[1] */
+    ins         t5, t6, 16, 16
+    ins         t7, t8, 16, 16
+    mult        $ac0, zero, zero
+    dpa.w.ph    $ac0, t5, s0
+    dpa.w.ph    $ac0, t7, s1
+    mult        $ac1, zero, zero
+    dpa.w.ph    $ac1, t5, s2
+    dpa.w.ph    $ac1, t7, s3
+    sll         t2, t2, 14      /* tmp0 =
+                                     ((JLONG)wsptr[0]) << (CONST_BITS+1) */
+    mflo        s6, $ac0
+    /* MULTIPLY(wsptr[2], FIX_1_847759065) +
+       MULTIPLY(wsptr[6], -FIX_0_765366865) */
+    subu        s4, s4, s5
+    addu        t3, t2, s4      /* tmp10 = tmp0 + z2 */
+    mflo        s7, $ac1
+    subu        t4, t2, s4      /* tmp10 = tmp0 - z2 */
+    addu        t7, t4, s6
+    subu        t8, t4, s6
+    addu        t5, t3, s7
+    subu        t6, t3, s7
+    shra_r.w    t5, t5, 19      /* DESCALE(tmp10 + temp2,
+                                           CONST_BITS-PASS1_BITS+1) */
+    shra_r.w    t6, t6, 19      /* DESCALE(tmp10 - temp2,
+                                           CONST_BITS-PASS1_BITS+1) */
+    shra_r.w    t7, t7, 19      /* DESCALE(tmp12 + temp1,
+                                           CONST_BITS-PASS1_BITS+1) */
+    shra_r.w    t8, t8, 19      /* DESCALE(tmp12 - temp1,
+                                           CONST_BITS-PASS1_BITS+1) */
+    sll         s4, t9, 2
+    lw          v0, 4(a2)       /* output_buf[ctr] */
+    shll_s.w    t5, t5, 24
+    shll_s.w    t6, t6, 24
+    shll_s.w    t7, t7, 24
+    shll_s.w    t8, t8, 24
+    sra         t5, t5, 24
+    sra         t6, t6, 24
+    sra         t7, t7, 24
+    sra         t8, t8, 24
+    addu        v0, v0, a3      /* outptr = output_buf[ctr] + output_col */
+    addiu       t5, t5, 128
+    addiu       t6, t6, 128
+    addiu       t7, t7, 128
+    addiu       t8, t8, 128
+    sb          t5, 0(v0)
+    sb          t7, 1(v0)
+    sb          t8, 2(v0)
+    sb          t6, 3(v0)
+    /* 3 */
+    li          s4, 15137
+    lw          s6, 72(t1)      /* wsptr[2] */
+    li          s5, 6270
+    lw          s7, 88(t1)      /* wsptr[6] */
+    mul         s4, s4, s6      /* MULTIPLY((JLONG)wsptr[2],
+                                            FIX_1_847759065) */
+    lw          t2, 64(t1)      /* wsptr[0] */
+    mul         s5, s5, s7      /* MULTIPLY((JLONG)wsptr[6],
+                                            -FIX_0_765366865) */
+    lh          t5, 92(t1)      /* wsptr[7] */
+    lh          t6, 84(t1)      /* wsptr[5] */
+    lh          t7, 76(t1)      /* wsptr[3] */
+    lh          t8, 68(t1)      /* wsptr[1] */
+    ins         t5, t6, 16, 16
+    ins         t7, t8, 16, 16
+    mult        $ac0, zero, zero
+    dpa.w.ph    $ac0, t5, s0
+    dpa.w.ph    $ac0, t7, s1
+    mult        $ac1, zero, zero
+    dpa.w.ph    $ac1, t5, s2
+    dpa.w.ph    $ac1, t7, s3
+    sll         t2, t2, 14      /* tmp0 =
+                                     ((JLONG)wsptr[0]) << (CONST_BITS+1) */
+    mflo        s6, $ac0
+    /* MULTIPLY(wsptr[2], FIX_1_847759065) +
+       MULTIPLY(wsptr[6], -FIX_0_765366865) */
+    subu        s4, s4, s5
+    addu        t3, t2, s4      /* tmp10 = tmp0 + z2 */
+    mflo        s7, $ac1
+    subu        t4, t2, s4      /* tmp10 = tmp0 - z2 */
+    addu        t7, t4, s6
+    subu        t8, t4, s6
+    addu        t5, t3, s7
+    subu        t6, t3, s7
+    shra_r.w    t5, t5, 19      /* DESCALE(tmp10 + temp2, 19) */
+    shra_r.w    t6, t6, 19      /* DESCALE(tmp10 - temp2, 19) */
+    shra_r.w    t7, t7, 19      /* DESCALE(tmp12 + temp1, 19) */
+    shra_r.w    t8, t8, 19      /* DESCALE(tmp12 - temp1, 19) */
+    sll         s4, t9, 2
+    lw          v0, 8(a2)       /* output_buf[ctr] */
+    shll_s.w    t5, t5, 24
+    shll_s.w    t6, t6, 24
+    shll_s.w    t7, t7, 24
+    shll_s.w    t8, t8, 24
+    sra         t5, t5, 24
+    sra         t6, t6, 24
+    sra         t7, t7, 24
+    sra         t8, t8, 24
+    addu        v0, v0, a3      /* outptr = output_buf[ctr] + output_col */
+    addiu       t5, t5, 128
+    addiu       t6, t6, 128
+    addiu       t7, t7, 128
+    addiu       t8, t8, 128
+    sb          t5, 0(v0)
+    sb          t7, 1(v0)
+    sb          t8, 2(v0)
+    sb          t6, 3(v0)
+    li          s4, 15137
+    lw          s6, 104(t1)     /* wsptr[2] */
+    li          s5, 6270
+    lw          s7, 120(t1)     /* wsptr[6] */
+    mul         s4, s4, s6      /* MULTIPLY((JLONG)wsptr[2],
+                                            FIX_1_847759065) */
+    lw          t2, 96(t1)      /* wsptr[0] */
+    mul         s5, s5, s7      /* MULTIPLY((JLONG)wsptr[6],
+                                            -FIX_0_765366865) */
+    lh          t5, 124(t1)     /* wsptr[7] */
+    lh          t6, 116(t1)     /* wsptr[5] */
+    lh          t7, 108(t1)     /* wsptr[3] */
+    lh          t8, 100(t1)     /* wsptr[1] */
+    ins         t5, t6, 16, 16
+    ins         t7, t8, 16, 16
+    mult        $ac0, zero, zero
+    dpa.w.ph    $ac0, t5, s0
+    dpa.w.ph    $ac0, t7, s1
+    mult        $ac1, zero, zero
+    dpa.w.ph    $ac1, t5, s2
+    dpa.w.ph    $ac1, t7, s3
+    sll         t2, t2, 14      /* tmp0 =
+                                     ((JLONG)wsptr[0]) << (CONST_BITS+1) */
+    mflo        s6, $ac0
+    /* MULTIPLY(wsptr[2], FIX_1_847759065) +
+       MULTIPLY(wsptr[6], -FIX_0_765366865) */
+    subu        s4, s4, s5
+    addu        t3, t2, s4      /* tmp10 = tmp0 + z2; */
+    mflo        s7, $ac1
+    subu        t4, t2, s4      /* tmp10 = tmp0 - z2; */
+    addu        t7, t4, s6
+    subu        t8, t4, s6
+    addu        t5, t3, s7
+    subu        t6, t3, s7
+    shra_r.w    t5, t5, 19      /* DESCALE(tmp10 + temp2, 19) */
+    shra_r.w    t6, t6, 19      /* DESCALE(tmp10 - temp2, 19) */
+    shra_r.w    t7, t7, 19      /* DESCALE(tmp12 + temp1, 19) */
+    shra_r.w    t8, t8, 19      /* DESCALE(tmp12 - temp1, 19) */
+    sll         s4, t9, 2
+    lw          v0, 12(a2)      /* output_buf[ctr] */
+    shll_s.w    t5, t5, 24
+    shll_s.w    t6, t6, 24
+    shll_s.w    t7, t7, 24
+    shll_s.w    t8, t8, 24
+    sra         t5, t5, 24
+    sra         t6, t6, 24
+    sra         t7, t7, 24
+    sra         t8, t8, 24
+    addu        v0, v0, a3      /* outptr = output_buf[ctr] + output_col */
+    addiu       t5, t5, 128
+    addiu       t6, t6, 128
+    addiu       t7, t7, 128
+    addiu       t8, t8, 128
+    sb          t5, 0(v0)
+    sb          t7, 1(v0)
+    sb          t8, 2(v0)
+    sb          t6, 3(v0)
+
+    RESTORE_REGS_FROM_STACK 32, s0, s1, s2, s3, s4, s5, s6, s7
+
+    j           ra
+     nop
+END(jsimd_idct_4x4_dspr2)
+
+
+/*****************************************************************************/
+LEAF_DSPR2(jsimd_idct_6x6_dspr2)
+/*
+ * a0 = compptr->dct_table
+ * a1 = coef_block
+ * a2 = output_buf
+ * a3 = output_col
+ */
+    .set at
+
+    SAVE_REGS_ON_STACK 32, s0, s1, s2, s3, s4, s5, s6, s7
+
+    addiu       sp, sp, -144
+    move        v0, sp
+    addiu       v1, v0, 24
+    addiu       t9, zero, 5793
+    addiu       s0, zero, 10033
+    addiu       s1, zero, 2998
+
+1:
+    lh          s2, 0(a0)       /* q0 = quantptr[ 0] */
+    lh          s3, 32(a0)      /* q1 = quantptr[16] */
+    lh          s4, 64(a0)      /* q2 = quantptr[32] */
+    lh          t2, 64(a1)      /* tmp2 = inptr[32] */
+    lh          t1, 32(a1)      /* tmp1 = inptr[16] */
+    lh          t0, 0(a1)       /* tmp0 = inptr[ 0] */
+    mul         t2, t2, s4      /* tmp2 = tmp2 * q2 */
+    mul         t1, t1, s3      /* tmp1 = tmp1 * q1 */
+    mul         t0, t0, s2      /* tmp0 = tmp0 * q0 */
+    lh          t6, 16(a1)      /* z1 = inptr[ 8] */
+    lh          t8, 80(a1)      /* z3 = inptr[40] */
+    lh          t7, 48(a1)      /* z2 = inptr[24] */
+    lh          s2, 16(a0)      /* q0 = quantptr[ 8] */
+    lh          s4, 80(a0)      /* q2 = quantptr[40] */
+    lh          s3, 48(a0)      /* q1 = quantptr[24] */
+    mul         t2, t2, t9      /* tmp2 = tmp2 * 5793 */
+    mul         t1, t1, s0      /* tmp1 = tmp1 * 10033 */
+    sll         t0, t0, 13      /* tmp0 = tmp0 << 13 */
+    mul         t6, t6, s2      /* z1 = z1 * q0 */
+    mul         t8, t8, s4      /* z3 = z3 * q2 */
+    mul         t7, t7, s3      /* z2 = z2 * q1 */
+    addu        t3, t0, t2      /* tmp10 = tmp0 + tmp2 */
+    sll         t2, t2, 1       /* tmp2 = tmp2 << 2 */
+    subu        t4, t0, t2      /* tmp11 = tmp0 - tmp2; */
+    subu        t5, t3, t1      /* tmp12 = tmp10 - tmp1 */
+    addu        t3, t3, t1      /* tmp10 = tmp10 + tmp1 */
+    addu        t1, t6, t8      /* tmp1 = z1 + z3 */
+    mul         t1, t1, s1      /* tmp1 = tmp1 * 2998 */
+    shra_r.w    t4, t4, 11      /* tmp11 = (tmp11 + 1024) >> 11 */
+    subu        t2, t6, t8      /* tmp2 = z1 - z3 */
+    subu        t2, t2, t7      /* tmp2 = tmp2 - z2 */
+    sll         t2, t2, 2       /* tmp2 = tmp2 << 2 */
+    addu        t0, t6, t7      /* tmp0 = z1 + z2 */
+    sll         t0, t0, 13      /* tmp0 = tmp0 << 13 */
+    subu        s2, t8, t7      /* q0 = z3 - z2 */
+    sll         s2, s2, 13      /* q0 = q0 << 13 */
+    addu        t0, t0, t1      /* tmp0 = tmp0 + tmp1 */
+    addu        t1, s2, t1      /* tmp1 = q0 + tmp1 */
+    addu        s2, t4, t2      /* q0 = tmp11 + tmp2 */
+    subu        s3, t4, t2      /* q1 = tmp11 - tmp2 */
+    addu        t6, t3, t0      /* z1 = tmp10 + tmp0 */
+    subu        t7, t3, t0      /* z2 = tmp10 - tmp0 */
+    addu        t4, t5, t1      /* tmp11 = tmp12 + tmp1 */
+    subu        t5, t5, t1      /* tmp12 = tmp12 - tmp1 */
+    shra_r.w    t6, t6, 11      /* z1 = (z1 + 1024) >> 11 */
+    shra_r.w    t7, t7, 11      /* z2 = (z2 + 1024) >> 11 */
+    shra_r.w    t4, t4, 11      /* tmp11 = (tmp11 + 1024) >> 11 */
+    shra_r.w    t5, t5, 11      /* tmp12 = (tmp12 + 1024) >> 11 */
+    sw          s2, 24(v0)
+    sw          s3, 96(v0)
+    sw          t6, 0(v0)
+    sw          t7, 120(v0)
+    sw          t4, 48(v0)
+    sw          t5, 72(v0)
+    addiu       v0, v0, 4
+    addiu       a1, a1, 2
+    bne         v0, v1, 1b
+     addiu      a0, a0, 2
+
+    /* Pass 2: process 6 rows from work array, store into output array. */
+    move        v0, sp
+    addiu       v1, v0, 144
+
+2:
+    lw          t0, 0(v0)
+    lw          t2, 16(v0)
+    lw          s5, 0(a2)
+    addiu       t0, t0, 16
+    sll         t0, t0, 13
+    mul         t3, t2, t9
+    lw          t6, 4(v0)
+    lw          t8, 20(v0)
+    lw          t7, 12(v0)
+    addu        s5, s5, a3
+    addu        s6, t6, t8
+    mul         s6, s6, s1
+    addu        t1, t0, t3
+    subu        t4, t0, t3
+    subu        t4, t4, t3
+    lw          t3, 8(v0)
+    mul         t0, t3, s0
+    addu        s7, t6, t7
+    sll         s7, s7, 13
+    addu        s7, s6, s7
+    subu        t2, t8, t7
+    sll         t2, t2, 13
+    addu        t2, s6, t2
+    subu        s6, t6, t7
+    subu        s6, s6, t8
+    sll         s6, s6, 13
+    addu        t3, t1, t0
+    subu        t5, t1, t0
+    addu        t6, t3, s7
+    subu        t3, t3, s7
+    addu        t7, t4, s6
+    subu        t4, t4, s6
+    addu        t8, t5, t2
+    subu        t5, t5, t2
+    shll_s.w    t6, t6, 6
+    shll_s.w    t3, t3, 6
+    shll_s.w    t7, t7, 6
+    shll_s.w    t4, t4, 6
+    shll_s.w    t8, t8, 6
+    shll_s.w    t5, t5, 6
+    sra         t6, t6, 24
+    addiu       t6, t6, 128
+    sra         t3, t3, 24
+    addiu       t3, t3, 128
+    sb          t6, 0(s5)
+    sra         t7, t7, 24
+    addiu       t7, t7, 128
+    sb          t3, 5(s5)
+    sra         t4, t4, 24
+    addiu       t4, t4, 128
+    sb          t7, 1(s5)
+    sra         t8, t8, 24
+    addiu       t8, t8, 128
+    sb          t4, 4(s5)
+    addiu       v0, v0, 24
+    sra         t5, t5, 24
+    addiu       t5, t5, 128
+    sb          t8, 2(s5)
+    addiu       a2, a2,  4
+    bne         v0, v1, 2b
+     sb         t5, 3(s5)
+
+    addiu       sp, sp, 144
+
+    RESTORE_REGS_FROM_STACK 32, s0, s1, s2, s3, s4, s5, s6, s7
+
+    j           ra
+     nop
+
+END(jsimd_idct_6x6_dspr2)
+
+
+/*****************************************************************************/
+LEAF_DSPR2(jsimd_idct_12x12_pass1_dspr2)
+/*
+ * a0 = compptr->dct_table
+ * a1 = coef_block
+ * a2 = workspace
+ */
+    SAVE_REGS_ON_STACK 16, s0, s1, s2, s3
+
+    li          a3, 8
+
+1:
+    /* odd part */
+    lh          t0, 48(a1)
+    lh          t1, 48(a0)
+    lh          t2, 16(a1)
+    lh          t3, 16(a0)
+    lh          t4, 80(a1)
+    lh          t5, 80(a0)
+    lh          t6, 112(a1)
+    lh          t7, 112(a0)
+    mul         t0, t0, t1      /* z2 */
+    mul         t1, t2, t3      /* z1 */
+    mul         t2, t4, t5      /* z3 */
+    mul         t3, t6, t7      /* z4 */
+    li          t4, 10703       /* FIX(1.306562965) */
+    li          t5, 4433        /* FIX_0_541196100 */
+    li          t6, 7053        /* FIX(0.860918669) */
+    mul         t4, t0, t4      /* tmp11 */
+    mul         t5, t0, t5      /* -tmp14 */
+    addu        t7, t1, t2      /* tmp10 */
+    addu        t8, t7, t3      /* tmp10 + z4 */
+    mul         t6, t6, t8      /* tmp15 */
+    li          t8, 2139        /* FIX(0.261052384) */
+    mul         t8, t7, t8      /* MULTIPLY(tmp10, FIX(0.261052384)) */
+    li          t7, 2295        /* FIX(0.280143716) */
+    mul         t7, t1, t7      /* MULTIPLY(z1, FIX(0.280143716)) */
+    addu        t9, t2, t3      /* z3 + z4 */
+    li          s0, 8565        /* FIX(1.045510580) */
+    mul         t9, t9, s0      /* -tmp13 */
+    li          s0, 12112       /* FIX(1.478575242) */
+    mul         s0, t2, s0      /* MULTIPLY(z3, FIX(1.478575242) */
+    li          s1, 12998       /* FIX(1.586706681) */
+    mul         s1, t3, s1      /* MULTIPLY(z4, FIX(1.586706681)) */
+    li          s2, 5540        /* FIX(0.676326758) */
+    mul         s2, t1, s2      /* MULTIPLY(z1, FIX(0.676326758)) */
+    li          s3, 16244       /* FIX(1.982889723) */
+    mul         s3, t3, s3      /* MULTIPLY(z4, FIX(1.982889723)) */
+    subu        t1, t1, t3      /* z1-=z4 */
+    subu        t0, t0, t2      /* z2-=z3 */
+    addu        t2, t0, t1      /* z1+z2 */
+    li          t3, 4433        /* FIX_0_541196100 */
+    mul         t2, t2, t3      /* z3 */
+    li          t3, 6270        /* FIX_0_765366865 */
+    mul         t1, t1, t3      /* MULTIPLY(z1, FIX_0_765366865) */
+    li          t3, 15137       /* FIX_0_765366865 */
+    mul         t0, t0, t3      /* MULTIPLY(z2, FIX_1_847759065) */
+    addu        t8, t6, t8      /* tmp12 */
+    addu        t3, t8, t4      /* tmp12 + tmp11 */
+    addu        t3, t3, t7      /* tmp10 */
+    subu        t8, t8, t9      /* tmp12 + tmp13 */
+    addu        s0, t5, s0
+    subu        t8, t8, s0      /* tmp12 */
+    subu        t9, t6, t9
+    subu        s1, s1, t4
+    addu        t9, t9, s1      /* tmp13 */
+    subu        t6, t6, t5
+    subu        t6, t6, s2
+    subu        t6, t6, s3      /* tmp15 */
+    /* even part start */
+    lh          t4, 64(a1)
+    lh          t5, 64(a0)
+    lh          t7, 32(a1)
+    lh          s0, 32(a0)
+    lh          s1, 0(a1)
+    lh          s2, 0(a0)
+    lh          s3, 96(a1)
+    lh          v0, 96(a0)
+    mul         t4, t4, t5      /* DEQUANTIZE(inptr[DCTSIZE*4],
+                                              quantptr[DCTSIZE*4]) */
+    mul         t5, t7, s0      /* DEQUANTIZE(inptr[DCTSIZE*2],
+                                              quantptr[DCTSIZE*2]) */
+    mul         t7, s1, s2      /* DEQUANTIZE(inptr[DCTSIZE*0],
+                                              quantptr[DCTSIZE*0]) */
+    mul         s0, s3, v0      /* DEQUANTIZE(inptr[DCTSIZE*6],
+                                              quantptr[DCTSIZE*6]) */
+    /* odd part end */
+    addu        t1, t2, t1      /* tmp11 */
+    subu        t0, t2, t0      /* tmp14 */
+    /* update counter and pointers */
+    addiu       a3, a3, -1
+    addiu       a0, a0, 2
+    addiu       a1, a1, 2
+    /* even part rest */
+    li          s1, 10033
+    li          s2, 11190
+    mul         t4, t4, s1      /* z4 */
+    mul         s1, t5, s2      /* z4 */
+    sll         t5, t5, 13      /* z1 */
+    sll         t7, t7, 13
+    addiu       t7, t7, 1024    /* z3 */
+    sll         s0, s0, 13      /* z2 */
+    addu        s2, t7, t4      /* tmp10 */
+    subu        t4, t7, t4      /* tmp11 */
+    subu        s3, t5, s0      /* tmp12 */
+    addu        t2, t7, s3      /* tmp21 */
+    subu        s3, t7, s3      /* tmp24 */
+    addu        t7, s1, s0      /* tmp12 */
+    addu        v0, s2, t7      /* tmp20 */
+    subu        s2, s2, t7      /* tmp25 */
+    subu        s1, s1, t5      /* z4 - z1 */
+    subu        s1, s1, s0      /* tmp12 */
+    addu        s0, t4, s1      /* tmp22 */
+    subu        t4, t4, s1      /* tmp23 */
+    /* final output stage */
+    addu        t5, v0, t3
+    subu        v0, v0, t3
+    addu        t3, t2, t1
+    subu        t2, t2, t1
+    addu        t1, s0, t8
+    subu        s0, s0, t8
+    addu        t8, t4, t9
+    subu        t4, t4, t9
+    addu        t9, s3, t0
+    subu        s3, s3, t0
+    addu        t0, s2, t6
+    subu        s2, s2, t6
+    sra         t5, t5, 11
+    sra         t3, t3, 11
+    sra         t1, t1, 11
+    sra         t8, t8, 11
+    sra         t9, t9, 11
+    sra         t0, t0, 11
+    sra         s2, s2, 11
+    sra         s3, s3, 11
+    sra         t4, t4, 11
+    sra         s0, s0, 11
+    sra         t2, t2, 11
+    sra         v0, v0, 11
+    sw          t5, 0(a2)
+    sw          t3, 32(a2)
+    sw          t1, 64(a2)
+    sw          t8, 96(a2)
+    sw          t9, 128(a2)
+    sw          t0, 160(a2)
+    sw          s2, 192(a2)
+    sw          s3, 224(a2)
+    sw          t4, 256(a2)
+    sw          s0, 288(a2)
+    sw          t2, 320(a2)
+    sw          v0, 352(a2)
+    bgtz        a3, 1b
+     addiu      a2, a2, 4
+
+    RESTORE_REGS_FROM_STACK 16, s0, s1, s2, s3
+
+    j           ra
+     nop
+
+END(jsimd_idct_12x12_pass1_dspr2)
+
+
+/*****************************************************************************/
+LEAF_DSPR2(jsimd_idct_12x12_pass2_dspr2)
+/*
+ * a0 = workspace
+ * a1 = output
+ */
+    SAVE_REGS_ON_STACK 16, s0, s1, s2, s3
+
+    li          a3, 12
+
+1:
+    /* Odd part */
+    lw          t0, 12(a0)
+    lw          t1, 4(a0)
+    lw          t2, 20(a0)
+    lw          t3, 28(a0)
+    li          t4, 10703       /* FIX(1.306562965) */
+    li          t5, 4433        /* FIX_0_541196100 */
+    mul         t4, t0, t4      /* tmp11 */
+    mul         t5, t0, t5      /* -tmp14 */
+    addu        t6, t1, t2      /* tmp10 */
+    li          t7, 2139        /* FIX(0.261052384) */
+    mul         t7, t6, t7      /* MULTIPLY(tmp10, FIX(0.261052384)) */
+    addu        t6, t6, t3      /* tmp10 + z4 */
+    li          t8, 7053        /* FIX(0.860918669) */
+    mul         t6, t6, t8      /* tmp15 */
+    li          t8, 2295        /* FIX(0.280143716) */
+    mul         t8, t1, t8      /* MULTIPLY(z1, FIX(0.280143716)) */
+    addu        t9, t2, t3      /* z3 + z4 */
+    li          s0, 8565        /* FIX(1.045510580) */
+    mul         t9, t9, s0      /* -tmp13 */
+    li          s0, 12112       /* FIX(1.478575242) */
+    mul         s0, t2, s0      /* MULTIPLY(z3, FIX(1.478575242)) */
+    li          s1, 12998       /* FIX(1.586706681) */
+    mul         s1, t3, s1      /* MULTIPLY(z4, FIX(1.586706681)) */
+    li          s2, 5540        /* FIX(0.676326758) */
+    mul         s2, t1, s2      /* MULTIPLY(z1, FIX(0.676326758)) */
+    li          s3, 16244       /* FIX(1.982889723) */
+    mul         s3, t3, s3      /* MULTIPLY(z4, FIX(1.982889723)) */
+    subu        t1, t1, t3      /* z1 -= z4 */
+    subu        t0, t0, t2      /* z2 -= z3 */
+    addu        t2, t1, t0      /* z1 + z2 */
+    li          t3, 4433        /* FIX_0_541196100 */
+    mul         t2, t2, t3      /* z3 */
+    li          t3, 6270        /* FIX_0_765366865 */
+    mul         t1, t1, t3      /* MULTIPLY(z1, FIX_0_765366865) */
+    li          t3, 15137       /* FIX_1_847759065 */
+    mul         t0, t0, t3      /* MULTIPLY(z2, FIX_1_847759065) */
+    addu        t3, t6, t7      /* tmp12 */
+    addu        t7, t3, t4
+    addu        t7, t7, t8      /* tmp10 */
+    subu        t3, t3, t9
+    subu        t3, t3, t5
+    subu        t3, t3, s0      /* tmp12 */
+    subu        t9, t6, t9
+    subu        t9, t9, t4
+    addu        t9, t9, s1      /* tmp13 */
+    subu        t6, t6, t5
+    subu        t6, t6, s2
+    subu        t6, t6, s3      /* tmp15 */
+    addu        t1, t2, t1      /* tmp11 */
+    subu        t0, t2, t0      /* tmp14 */
+    /* even part */
+    lw          t2, 16(a0)      /* z4 */
+    lw          t4, 8(a0)       /* z1 */
+    lw          t5, 0(a0)       /* z3 */
+    lw          t8, 24(a0)      /* z2 */
+    li          s0, 10033       /* FIX(1.224744871) */
+    li          s1, 11190       /* FIX(1.366025404) */
+    mul         t2, t2, s0      /* z4 */
+    mul         s0, t4, s1      /* z4 */
+    addiu       t5, t5, 0x10
+    sll         t5, t5, 13      /* z3 */
+    sll         t4, t4, 13      /* z1 */
+    sll         t8, t8, 13      /* z2 */
+    subu        s1, t4, t8      /* tmp12 */
+    addu        s2, t5, t2      /* tmp10 */
+    subu        t2, t5, t2      /* tmp11 */
+    addu        s3, t5, s1      /* tmp21 */
+    subu        s1, t5, s1      /* tmp24 */
+    addu        t5, s0, t8      /* tmp12 */
+    addu        v0, s2, t5      /* tmp20 */
+    subu        t5, s2, t5      /* tmp25 */
+    subu        t4, s0, t4
+    subu        t4, t4, t8      /* tmp12 */
+    addu        t8, t2, t4      /* tmp22 */
+    subu        t2, t2, t4      /* tmp23 */
+    /* increment counter and pointers */
+    addiu       a3, a3, -1
+    addiu       a0, a0, 32
+    /* Final stage */
+    addu        t4, v0, t7
+    subu        v0, v0, t7
+    addu        t7, s3, t1
+    subu        s3, s3, t1
+    addu        t1, t8, t3
+    subu        t8, t8, t3
+    addu        t3, t2, t9
+    subu        t2, t2, t9
+    addu        t9, s1, t0
+    subu        s1, s1, t0
+    addu        t0, t5, t6
+    subu        t5, t5, t6
+    sll         t4, t4, 4
+    sll         t7, t7, 4
+    sll         t1, t1, 4
+    sll         t3, t3, 4
+    sll         t9, t9, 4
+    sll         t0, t0, 4
+    sll         t5, t5, 4
+    sll         s1, s1, 4
+    sll         t2, t2, 4
+    sll         t8, t8, 4
+    sll         s3, s3, 4
+    sll         v0, v0, 4
+    shll_s.w    t4, t4, 2
+    shll_s.w    t7, t7, 2
+    shll_s.w    t1, t1, 2
+    shll_s.w    t3, t3, 2
+    shll_s.w    t9, t9, 2
+    shll_s.w    t0, t0, 2
+    shll_s.w    t5, t5, 2
+    shll_s.w    s1, s1, 2
+    shll_s.w    t2, t2, 2
+    shll_s.w    t8, t8, 2
+    shll_s.w    s3, s3, 2
+    shll_s.w    v0, v0, 2
+    srl         t4, t4, 24
+    srl         t7, t7, 24
+    srl         t1, t1, 24
+    srl         t3, t3, 24
+    srl         t9, t9, 24
+    srl         t0, t0, 24
+    srl         t5, t5, 24
+    srl         s1, s1, 24
+    srl         t2, t2, 24
+    srl         t8, t8, 24
+    srl         s3, s3, 24
+    srl         v0, v0, 24
+    lw          t6, 0(a1)
+    addiu       t4, t4, 0x80
+    addiu       t7, t7, 0x80
+    addiu       t1, t1, 0x80
+    addiu       t3, t3, 0x80
+    addiu       t9, t9, 0x80
+    addiu       t0, t0, 0x80
+    addiu       t5, t5, 0x80
+    addiu       s1, s1, 0x80
+    addiu       t2, t2, 0x80
+    addiu       t8, t8, 0x80
+    addiu       s3, s3, 0x80
+    addiu       v0, v0, 0x80
+    sb          t4, 0(t6)
+    sb          t7, 1(t6)
+    sb          t1, 2(t6)
+    sb          t3, 3(t6)
+    sb          t9, 4(t6)
+    sb          t0, 5(t6)
+    sb          t5, 6(t6)
+    sb          s1, 7(t6)
+    sb          t2, 8(t6)
+    sb          t8, 9(t6)
+    sb          s3, 10(t6)
+    sb          v0, 11(t6)
+    bgtz        a3, 1b
+     addiu      a1, a1, 4
+
+    RESTORE_REGS_FROM_STACK 16, s0, s1, s2, s3
+
+    jr          ra
+     nop
+
+END(jsimd_idct_12x12_pass2_dspr2)
+
+
+/*****************************************************************************/
+LEAF_DSPR2(jsimd_convsamp_dspr2)
+/*
+ * a0 = sample_data
+ * a1 = start_col
+ * a2 = workspace
+ */
+    lw            t0, 0(a0)
+    li            t7, 0xff80ff80
+    addu          t0, t0, a1
+    ulw           t1, 0(t0)
+    ulw           t2, 4(t0)
+    preceu.ph.qbr t3, t1
+    preceu.ph.qbl t4, t1
+    lw            t0, 4(a0)
+    preceu.ph.qbr t5, t2
+    preceu.ph.qbl t6, t2
+    addu          t0, t0, a1
+    addu.ph       t3, t3, t7
+    addu.ph       t4, t4, t7
+    ulw           t1, 0(t0)
+    ulw           t2, 4(t0)
+    addu.ph       t5, t5, t7
+    addu.ph       t6, t6, t7
+    usw           t3, 0(a2)
+    usw           t4, 4(a2)
+    preceu.ph.qbr t3, t1
+    preceu.ph.qbl t4, t1
+    usw           t5, 8(a2)
+    usw           t6, 12(a2)
+
+    lw            t0, 8(a0)
+    preceu.ph.qbr t5, t2
+    preceu.ph.qbl t6, t2
+    addu          t0, t0, a1
+    addu.ph       t3, t3, t7
+    addu.ph       t4, t4, t7
+    ulw           t1, 0(t0)
+    ulw           t2, 4(t0)
+    addu.ph       t5, t5, t7
+    addu.ph       t6, t6, t7
+    usw           t3, 16(a2)
+    usw           t4, 20(a2)
+    preceu.ph.qbr t3, t1
+    preceu.ph.qbl t4, t1
+    usw           t5, 24(a2)
+    usw           t6, 28(a2)
+
+    lw            t0, 12(a0)
+    preceu.ph.qbr t5, t2
+    preceu.ph.qbl t6, t2
+    addu          t0, t0, a1
+    addu.ph       t3, t3, t7
+    addu.ph       t4, t4, t7
+    ulw           t1, 0(t0)
+    ulw           t2, 4(t0)
+    addu.ph       t5, t5, t7
+    addu.ph       t6, t6, t7
+    usw           t3, 32(a2)
+    usw           t4, 36(a2)
+    preceu.ph.qbr t3, t1
+    preceu.ph.qbl t4, t1
+    usw           t5, 40(a2)
+    usw           t6, 44(a2)
+
+    lw            t0, 16(a0)
+    preceu.ph.qbr t5, t2
+    preceu.ph.qbl t6, t2
+    addu          t0, t0, a1
+    addu.ph       t3, t3, t7
+    addu.ph       t4, t4, t7
+    ulw           t1, 0(t0)
+    ulw           t2, 4(t0)
+    addu.ph       t5, t5, t7
+    addu.ph       t6, t6, t7
+    usw           t3, 48(a2)
+    usw           t4, 52(a2)
+    preceu.ph.qbr t3, t1
+    preceu.ph.qbl t4, t1
+    usw           t5, 56(a2)
+    usw           t6, 60(a2)
+
+    lw            t0, 20(a0)
+    preceu.ph.qbr t5, t2
+    preceu.ph.qbl t6, t2
+    addu          t0, t0, a1
+    addu.ph       t3, t3, t7
+    addu.ph       t4, t4, t7
+    ulw           t1, 0(t0)
+    ulw           t2, 4(t0)
+    addu.ph       t5, t5, t7
+    addu.ph       t6, t6, t7
+    usw           t3, 64(a2)
+    usw           t4, 68(a2)
+    preceu.ph.qbr t3, t1
+    preceu.ph.qbl t4, t1
+    usw           t5, 72(a2)
+    usw           t6, 76(a2)
+
+    lw            t0, 24(a0)
+    preceu.ph.qbr t5, t2
+    preceu.ph.qbl t6, t2
+    addu          t0, t0, a1
+    addu.ph       t3, t3, t7
+    addu.ph       t4, t4, t7
+    ulw           t1, 0(t0)
+    ulw           t2, 4(t0)
+    addu.ph       t5, t5, t7
+    addu.ph       t6, t6, t7
+    usw           t3, 80(a2)
+    usw           t4, 84(a2)
+    preceu.ph.qbr t3, t1
+    preceu.ph.qbl t4, t1
+    usw           t5, 88(a2)
+    usw           t6, 92(a2)
+
+    lw            t0, 28(a0)
+    preceu.ph.qbr t5, t2
+    preceu.ph.qbl t6, t2
+    addu          t0, t0, a1
+    addu.ph       t3, t3, t7
+    addu.ph       t4, t4, t7
+    ulw           t1, 0(t0)
+    ulw           t2, 4(t0)
+    addu.ph       t5, t5, t7
+    addu.ph       t6, t6, t7
+    usw           t3, 96(a2)
+    usw           t4, 100(a2)
+    preceu.ph.qbr t3, t1
+    preceu.ph.qbl t4, t1
+    usw           t5, 104(a2)
+    usw           t6, 108(a2)
+    preceu.ph.qbr t5, t2
+    preceu.ph.qbl t6, t2
+    addu.ph       t3, t3, t7
+    addu.ph       t4, t4, t7
+    addu.ph       t5, t5, t7
+    addu.ph       t6, t6, t7
+    usw           t3, 112(a2)
+    usw           t4, 116(a2)
+    usw           t5, 120(a2)
+    usw           t6, 124(a2)
+
+    j             ra
+     nop
+
+END(jsimd_convsamp_dspr2)
+
+
+#ifndef __mips_soft_float
+
+/*****************************************************************************/
+LEAF_DSPR2(jsimd_convsamp_float_dspr2)
+/*
+ * a0 = sample_data
+ * a1 = start_col
+ * a2 = workspace
+ */
+    .set at
+
+    lw          t0, 0(a0)
+    addu        t0, t0, a1
+    lbu         t1, 0(t0)
+    lbu         t2, 1(t0)
+    lbu         t3, 2(t0)
+    lbu         t4, 3(t0)
+    lbu         t5, 4(t0)
+    lbu         t6, 5(t0)
+    lbu         t7, 6(t0)
+    lbu         t8, 7(t0)
+    addiu       t1, t1, -128
+    addiu       t2, t2, -128
+    addiu       t3, t3, -128
+    addiu       t4, t4, -128
+    addiu       t5, t5, -128
+    addiu       t6, t6, -128
+    addiu       t7, t7, -128
+    addiu       t8, t8, -128
+    mtc1        t1, f2
+    mtc1        t2, f4
+    mtc1        t3, f6
+    mtc1        t4, f8
+    mtc1        t5, f10
+    mtc1        t6, f12
+    mtc1        t7, f14
+    mtc1        t8, f16
+    cvt.s.w     f2, f2
+    cvt.s.w     f4, f4
+    cvt.s.w     f6, f6
+    cvt.s.w     f8, f8
+    cvt.s.w     f10, f10
+    cvt.s.w     f12, f12
+    cvt.s.w     f14, f14
+    cvt.s.w     f16, f16
+    lw          t0, 4(a0)
+    swc1        f2, 0(a2)
+    swc1        f4, 4(a2)
+    swc1        f6, 8(a2)
+    addu        t0, t0, a1
+    swc1        f8, 12(a2)
+    swc1        f10, 16(a2)
+    swc1        f12, 20(a2)
+    swc1        f14, 24(a2)
+    swc1        f16, 28(a2)
+    /* elemr 1 */
+    lbu         t1, 0(t0)
+    lbu         t2, 1(t0)
+    lbu         t3, 2(t0)
+    lbu         t4, 3(t0)
+    lbu         t5, 4(t0)
+    lbu         t6, 5(t0)
+    lbu         t7, 6(t0)
+    lbu         t8, 7(t0)
+    addiu       t1, t1, -128
+    addiu       t2, t2, -128
+    addiu       t3, t3, -128
+    addiu       t4, t4, -128
+    addiu       t5, t5, -128
+    addiu       t6, t6, -128
+    addiu       t7, t7, -128
+    addiu       t8, t8, -128
+    mtc1        t1, f2
+    mtc1        t2, f4
+    mtc1        t3, f6
+    mtc1        t4, f8
+    mtc1        t5, f10
+    mtc1        t6, f12
+    mtc1        t7, f14
+    mtc1        t8, f16
+    cvt.s.w     f2, f2
+    cvt.s.w     f4, f4
+    cvt.s.w     f6, f6
+    cvt.s.w     f8, f8
+    cvt.s.w     f10, f10
+    cvt.s.w     f12, f12
+    cvt.s.w     f14, f14
+    cvt.s.w     f16, f16
+    lw          t0, 8(a0)
+    swc1        f2, 32(a2)
+    swc1        f4, 36(a2)
+    swc1        f6, 40(a2)
+    addu        t0, t0, a1
+    swc1        f8, 44(a2)
+    swc1        f10, 48(a2)
+    swc1        f12, 52(a2)
+    swc1        f14, 56(a2)
+    swc1        f16, 60(a2)
+    /* elemr 2 */
+    lbu         t1, 0(t0)
+    lbu         t2, 1(t0)
+    lbu         t3, 2(t0)
+    lbu         t4, 3(t0)
+    lbu         t5, 4(t0)
+    lbu         t6, 5(t0)
+    lbu         t7, 6(t0)
+    lbu         t8, 7(t0)
+    addiu       t1, t1, -128
+    addiu       t2, t2, -128
+    addiu       t3, t3, -128
+    addiu       t4, t4, -128
+    addiu       t5, t5, -128
+    addiu       t6, t6, -128
+    addiu       t7, t7, -128
+    addiu       t8, t8, -128
+    mtc1        t1, f2
+    mtc1        t2, f4
+    mtc1        t3, f6
+    mtc1        t4, f8
+    mtc1        t5, f10
+    mtc1        t6, f12
+    mtc1        t7, f14
+    mtc1        t8, f16
+    cvt.s.w     f2, f2
+    cvt.s.w     f4, f4
+    cvt.s.w     f6, f6
+    cvt.s.w     f8, f8
+    cvt.s.w     f10, f10
+    cvt.s.w     f12, f12
+    cvt.s.w     f14, f14
+    cvt.s.w     f16, f16
+    lw          t0, 12(a0)
+    swc1        f2, 64(a2)
+    swc1        f4, 68(a2)
+    swc1        f6, 72(a2)
+    addu        t0, t0, a1
+    swc1        f8, 76(a2)
+    swc1        f10, 80(a2)
+    swc1        f12, 84(a2)
+    swc1        f14, 88(a2)
+    swc1        f16, 92(a2)
+    /*  elemr 3 */
+    lbu         t1, 0(t0)
+    lbu         t2, 1(t0)
+    lbu         t3, 2(t0)
+    lbu         t4, 3(t0)
+    lbu         t5, 4(t0)
+    lbu         t6, 5(t0)
+    lbu         t7, 6(t0)
+    lbu         t8, 7(t0)
+    addiu       t1, t1, -128
+    addiu       t2, t2, -128
+    addiu       t3, t3, -128
+    addiu       t4, t4, -128
+    addiu       t5, t5, -128
+    addiu       t6, t6, -128
+    addiu       t7, t7, -128
+    addiu       t8, t8, -128
+    mtc1        t1, f2
+    mtc1        t2, f4
+    mtc1        t3, f6
+    mtc1        t4, f8
+    mtc1        t5, f10
+    mtc1        t6, f12
+    mtc1        t7, f14
+    mtc1        t8, f16
+    cvt.s.w     f2, f2
+    cvt.s.w     f4, f4
+    cvt.s.w     f6, f6
+    cvt.s.w     f8, f8
+    cvt.s.w     f10, f10
+    cvt.s.w     f12, f12
+    cvt.s.w     f14, f14
+    cvt.s.w     f16, f16
+    lw          t0, 16(a0)
+    swc1        f2, 96(a2)
+    swc1        f4, 100(a2)
+    swc1        f6, 104(a2)
+    addu        t0, t0, a1
+    swc1        f8, 108(a2)
+    swc1        f10, 112(a2)
+    swc1        f12, 116(a2)
+    swc1        f14, 120(a2)
+    swc1        f16, 124(a2)
+    /* elemr 4 */
+    lbu         t1, 0(t0)
+    lbu         t2, 1(t0)
+    lbu         t3, 2(t0)
+    lbu         t4, 3(t0)
+    lbu         t5, 4(t0)
+    lbu         t6, 5(t0)
+    lbu         t7, 6(t0)
+    lbu         t8, 7(t0)
+    addiu       t1, t1, -128
+    addiu       t2, t2, -128
+    addiu       t3, t3, -128
+    addiu       t4, t4, -128
+    addiu       t5, t5, -128
+    addiu       t6, t6, -128
+    addiu       t7, t7, -128
+    addiu       t8, t8, -128
+    mtc1        t1, f2
+    mtc1        t2, f4
+    mtc1        t3, f6
+    mtc1        t4, f8
+    mtc1        t5, f10
+    mtc1        t6, f12
+    mtc1        t7, f14
+    mtc1        t8, f16
+    cvt.s.w     f2, f2
+    cvt.s.w     f4, f4
+    cvt.s.w     f6, f6
+    cvt.s.w     f8, f8
+    cvt.s.w     f10, f10
+    cvt.s.w     f12, f12
+    cvt.s.w     f14, f14
+    cvt.s.w     f16, f16
+    lw          t0, 20(a0)
+    swc1        f2, 128(a2)
+    swc1        f4, 132(a2)
+    swc1        f6, 136(a2)
+    addu        t0, t0, a1
+    swc1        f8, 140(a2)
+    swc1        f10, 144(a2)
+    swc1        f12, 148(a2)
+    swc1        f14, 152(a2)
+    swc1        f16, 156(a2)
+    /* elemr 5 */
+    lbu         t1, 0(t0)
+    lbu         t2, 1(t0)
+    lbu         t3, 2(t0)
+    lbu         t4, 3(t0)
+    lbu         t5, 4(t0)
+    lbu         t6, 5(t0)
+    lbu         t7, 6(t0)
+    lbu         t8, 7(t0)
+    addiu       t1, t1, -128
+    addiu       t2, t2, -128
+    addiu       t3, t3, -128
+    addiu       t4, t4, -128
+    addiu       t5, t5, -128
+    addiu       t6, t6, -128
+    addiu       t7, t7, -128
+    addiu       t8, t8, -128
+    mtc1        t1, f2
+    mtc1        t2, f4
+    mtc1        t3, f6
+    mtc1        t4, f8
+    mtc1        t5, f10
+    mtc1        t6, f12
+    mtc1        t7, f14
+    mtc1        t8, f16
+    cvt.s.w     f2, f2
+    cvt.s.w     f4, f4
+    cvt.s.w     f6, f6
+    cvt.s.w     f8, f8
+    cvt.s.w     f10, f10
+    cvt.s.w     f12, f12
+    cvt.s.w     f14, f14
+    cvt.s.w     f16, f16
+    lw          t0, 24(a0)
+    swc1        f2, 160(a2)
+    swc1        f4, 164(a2)
+    swc1        f6, 168(a2)
+    addu        t0, t0, a1
+    swc1        f8, 172(a2)
+    swc1        f10, 176(a2)
+    swc1        f12, 180(a2)
+    swc1        f14, 184(a2)
+    swc1        f16, 188(a2)
+    /* elemr 6 */
+    lbu         t1, 0(t0)
+    lbu         t2, 1(t0)
+    lbu         t3, 2(t0)
+    lbu         t4, 3(t0)
+    lbu         t5, 4(t0)
+    lbu         t6, 5(t0)
+    lbu         t7, 6(t0)
+    lbu         t8, 7(t0)
+    addiu       t1, t1, -128
+    addiu       t2, t2, -128
+    addiu       t3, t3, -128
+    addiu       t4, t4, -128
+    addiu       t5, t5, -128
+    addiu       t6, t6, -128
+    addiu       t7, t7, -128
+    addiu       t8, t8, -128
+    mtc1        t1, f2
+    mtc1        t2, f4
+    mtc1        t3, f6
+    mtc1        t4, f8
+    mtc1        t5, f10
+    mtc1        t6, f12
+    mtc1        t7, f14
+    mtc1        t8, f16
+    cvt.s.w     f2, f2
+    cvt.s.w     f4, f4
+    cvt.s.w     f6, f6
+    cvt.s.w     f8, f8
+    cvt.s.w     f10, f10
+    cvt.s.w     f12, f12
+    cvt.s.w     f14, f14
+    cvt.s.w     f16, f16
+    lw          t0, 28(a0)
+    swc1        f2, 192(a2)
+    swc1        f4, 196(a2)
+    swc1        f6, 200(a2)
+    addu        t0, t0, a1
+    swc1        f8, 204(a2)
+    swc1        f10, 208(a2)
+    swc1        f12, 212(a2)
+    swc1        f14, 216(a2)
+    swc1        f16, 220(a2)
+    /* elemr 7 */
+    lbu         t1, 0(t0)
+    lbu         t2, 1(t0)
+    lbu         t3, 2(t0)
+    lbu         t4, 3(t0)
+    lbu         t5, 4(t0)
+    lbu         t6, 5(t0)
+    lbu         t7, 6(t0)
+    lbu         t8, 7(t0)
+    addiu       t1, t1, -128
+    addiu       t2, t2, -128
+    addiu       t3, t3, -128
+    addiu       t4, t4, -128
+    addiu       t5, t5, -128
+    addiu       t6, t6, -128
+    addiu       t7, t7, -128
+    addiu       t8, t8, -128
+    mtc1        t1, f2
+    mtc1        t2, f4
+    mtc1        t3, f6
+    mtc1        t4, f8
+    mtc1        t5, f10
+    mtc1        t6, f12
+    mtc1        t7, f14
+    mtc1        t8, f16
+    cvt.s.w     f2, f2
+    cvt.s.w     f4, f4
+    cvt.s.w     f6, f6
+    cvt.s.w     f8, f8
+    cvt.s.w     f10, f10
+    cvt.s.w     f12, f12
+    cvt.s.w     f14, f14
+    cvt.s.w     f16, f16
+    swc1        f2, 224(a2)
+    swc1        f4, 228(a2)
+    swc1        f6, 232(a2)
+    swc1        f8, 236(a2)
+    swc1        f10, 240(a2)
+    swc1        f12, 244(a2)
+    swc1        f14, 248(a2)
+    swc1        f16, 252(a2)
+
+    j           ra
+     nop
+
+END(jsimd_convsamp_float_dspr2)
+
+#endif
+
+/*****************************************************************************/
diff --git a/3rdparty/libjpeg/src/simd/mips/jsimd_dspr2_asm.h b/3rdparty/libjpeg/src/simd/mips/jsimd_dspr2_asm.h
new file mode 100644
index 00000000..12cfda48
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/mips/jsimd_dspr2_asm.h
@@ -0,0 +1,292 @@
+/*
+ * MIPS DSPr2 optimizations for libjpeg-turbo
+ *
+ * Copyright (C) 2013, MIPS Technologies, Inc., California.
+ * Copyright (C) 2018, Matthieu Darbois.
+ * All Rights Reserved.
+ * Authors:  Teodora Novkovic (teodora.novkovic@imgtec.com)
+ *           Darko Laus       (darko.laus@imgtec.com)
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+#define zero  $0
+#define AT    $1
+#define v0    $2
+#define v1    $3
+#define a0    $4
+#define a1    $5
+#define a2    $6
+#define a3    $7
+#define t0    $8
+#define t1    $9
+#define t2    $10
+#define t3    $11
+#define t4    $12
+#define t5    $13
+#define t6    $14
+#define t7    $15
+#define s0    $16
+#define s1    $17
+#define s2    $18
+#define s3    $19
+#define s4    $20
+#define s5    $21
+#define s6    $22
+#define s7    $23
+#define t8    $24
+#define t9    $25
+#define k0    $26
+#define k1    $27
+#define gp    $28
+#define sp    $29
+#define fp    $30
+#define s8    $30
+#define ra    $31
+
+#define f0    $f0
+#define f1    $f1
+#define f2    $f2
+#define f3    $f3
+#define f4    $f4
+#define f5    $f5
+#define f6    $f6
+#define f7    $f7
+#define f8    $f8
+#define f9    $f9
+#define f10   $f10
+#define f11   $f11
+#define f12   $f12
+#define f13   $f13
+#define f14   $f14
+#define f15   $f15
+#define f16   $f16
+#define f17   $f17
+#define f18   $f18
+#define f19   $f19
+#define f20   $f20
+#define f21   $f21
+#define f22   $f22
+#define f23   $f23
+#define f24   $f24
+#define f25   $f25
+#define f26   $f26
+#define f27   $f27
+#define f28   $f28
+#define f29   $f29
+#define f30   $f30
+#define f31   $f31
+
+#ifdef __ELF__
+#define HIDDEN_SYMBOL(symbol)  .hidden symbol;
+#else
+#define HIDDEN_SYMBOL(symbol)
+#endif
+
+/*
+ * LEAF_MIPS32R2 - declare leaf routine for MIPS32r2
+ */
+#define LEAF_MIPS32R2(symbol) \
+    .globl      symbol; \
+    HIDDEN_SYMBOL(symbol) \
+    .align      2; \
+    .type       symbol, @function; \
+    .ent        symbol, 0; \
+symbol: \
+    .frame      sp, 0, ra; \
+    .set        push; \
+    .set        arch = mips32r2; \
+    .set        noreorder; \
+    .set        noat;
+
+/*
+ * LEAF_DSPR2 - declare leaf routine for MIPS DSPr2
+ */
+#define LEAF_DSPR2(symbol) \
+LEAF_MIPS32R2(symbol) \
+    .set        dspr2;
+
+/*
+ * END - mark end of function
+ */
+#define END(function) \
+    .set        pop; \
+    .end        function; \
+    .size       function, .-function
+
+/*
+ * Checks if stack offset is big enough for storing/restoring regs_num
+ * number of register to/from stack. Stack offset must be greater than
+ * or equal to the number of bytes needed for storing registers (regs_num*4).
+ * Since MIPS ABI allows usage of first 16 bytes of stack frame (this is
+ * preserved for input arguments of the functions, already stored in a0-a3),
+ * stack size can be further optimized by utilizing this space.
+ */
+.macro CHECK_STACK_OFFSET regs_num, stack_offset
+.if \stack_offset < \regs_num * 4 - 16
+.error "Stack offset too small."
+.endif
+.endm
+
+/*
+ * Saves set of registers on stack. Maximum number of registers that
+ * can be saved on stack is limitted to 14 (a0-a3, v0-v1 and s0-s7).
+ * Stack offset is number of bytes that are added to stack pointer (sp)
+ * before registers are pushed in order to provide enough space on stack
+ * (offset must be multiple of 4, and must be big enough, as described by
+ * CHECK_STACK_OFFSET macro). This macro is intended to be used in
+ * combination with RESTORE_REGS_FROM_STACK macro. Example:
+ *  SAVE_REGS_ON_STACK      4, v0, v1, s0, s1
+ *  RESTORE_REGS_FROM_STACK 4, v0, v1, s0, s1
+ */
+.macro SAVE_REGS_ON_STACK  stack_offset = 0, r1, \
+                           r2  = 0, r3  = 0, r4  = 0, \
+                           r5  = 0, r6  = 0, r7  = 0, \
+                           r8  = 0, r9  = 0, r10 = 0, \
+                           r11 = 0, r12 = 0, r13 = 0, \
+                           r14 = 0
+.if (\stack_offset < 0) || (\stack_offset - (\stack_offset / 4) * 4)
+    .error "Stack offset must be pozitive and multiple of 4."
+.endif
+.if \stack_offset != 0
+    addiu       sp, sp, -\stack_offset
+.endif
+    sw          \r1, 0(sp)
+.if \r2 != 0
+    sw          \r2, 4(sp)
+.endif
+.if \r3 != 0
+    sw          \r3, 8(sp)
+.endif
+.if \r4 != 0
+    sw          \r4, 12(sp)
+.endif
+.if \r5 != 0
+    CHECK_STACK_OFFSET 5, \stack_offset
+    sw          \r5, 16(sp)
+.endif
+.if \r6 != 0
+    CHECK_STACK_OFFSET 6, \stack_offset
+    sw          \r6, 20(sp)
+.endif
+.if \r7 != 0
+    CHECK_STACK_OFFSET 7, \stack_offset
+    sw          \r7, 24(sp)
+.endif
+.if \r8 != 0
+    CHECK_STACK_OFFSET 8, \stack_offset
+    sw          \r8, 28(sp)
+.endif
+.if \r9 != 0
+    CHECK_STACK_OFFSET 9, \stack_offset
+    sw          \r9, 32(sp)
+.endif
+.if \r10 != 0
+    CHECK_STACK_OFFSET 10, \stack_offset
+    sw          \r10, 36(sp)
+.endif
+.if \r11 != 0
+    CHECK_STACK_OFFSET 11, \stack_offset
+    sw          \r11, 40(sp)
+.endif
+.if \r12 != 0
+    CHECK_STACK_OFFSET 12, \stack_offset
+    sw          \r12, 44(sp)
+.endif
+.if \r13 != 0
+    CHECK_STACK_OFFSET 13, \stack_offset
+    sw          \r13, 48(sp)
+.endif
+.if \r14 != 0
+    CHECK_STACK_OFFSET 14, \stack_offset
+    sw          \r14, 52(sp)
+.endif
+.endm
+
+/*
+ * Restores set of registers from stack. Maximum number of registers that
+ * can be restored from stack is limitted to 14 (a0-a3, v0-v1 and s0-s7).
+ * Stack offset is number of bytes that are added to stack pointer (sp)
+ * after registers are restored (offset must be multiple of 4, and must
+ * be big enough, as described by CHECK_STACK_OFFSET macro). This macro is
+ * intended to be used in combination with RESTORE_REGS_FROM_STACK macro.
+ * Example:
+ *  SAVE_REGS_ON_STACK      4, v0, v1, s0, s1
+ *  RESTORE_REGS_FROM_STACK 4, v0, v1, s0, s1
+ */
+.macro RESTORE_REGS_FROM_STACK  stack_offset = 0, r1, \
+                                r2  = 0, r3  = 0, r4  = 0, \
+                                r5  = 0, r6  = 0, r7  = 0, \
+                                r8  = 0, r9  = 0, r10 = 0, \
+                                r11 = 0, r12 = 0, r13 = 0, \
+                                r14 = 0
+.if (\stack_offset < 0) || (\stack_offset - (\stack_offset / 4) * 4)
+    .error "Stack offset must be pozitive and multiple of 4."
+.endif
+    lw          \r1, 0(sp)
+.if \r2 != 0
+    lw          \r2, 4(sp)
+.endif
+.if \r3 != 0
+    lw          \r3, 8(sp)
+.endif
+.if \r4 != 0
+    lw          \r4, 12(sp)
+.endif
+.if \r5 != 0
+    CHECK_STACK_OFFSET 5, \stack_offset
+    lw          \r5, 16(sp)
+.endif
+.if \r6 != 0
+    CHECK_STACK_OFFSET 6, \stack_offset
+    lw          \r6, 20(sp)
+.endif
+.if \r7 != 0
+    CHECK_STACK_OFFSET 7, \stack_offset
+    lw          \r7, 24(sp)
+.endif
+.if \r8 != 0
+    CHECK_STACK_OFFSET 8, \stack_offset
+    lw          \r8, 28(sp)
+.endif
+.if \r9 != 0
+    CHECK_STACK_OFFSET 9, \stack_offset
+    lw          \r9, 32(sp)
+.endif
+.if \r10 != 0
+    CHECK_STACK_OFFSET 10, \stack_offset
+    lw          \r10, 36(sp)
+.endif
+.if \r11 != 0
+    CHECK_STACK_OFFSET 11, \stack_offset
+    lw          \r11, 40(sp)
+.endif
+.if \r12 != 0
+    CHECK_STACK_OFFSET 12, \stack_offset
+    lw          \r12, 44(sp)
+.endif
+.if \r13 != 0
+    CHECK_STACK_OFFSET 13, \stack_offset
+    lw          \r13, 48(sp)
+.endif
+.if \r14 != 0
+    CHECK_STACK_OFFSET 14, \stack_offset
+    lw          \r14, 52(sp)
+.endif
+.if \stack_offset != 0
+    addiu       sp, sp, \stack_offset
+.endif
+.endm
diff --git a/3rdparty/libjpeg/src/simd/mips64/jccolext-mmi.c b/3rdparty/libjpeg/src/simd/mips64/jccolext-mmi.c
new file mode 100644
index 00000000..558eb2ab
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/mips64/jccolext-mmi.c
@@ -0,0 +1,455 @@
+/*
+ * Loongson MMI optimizations for libjpeg-turbo
+ *
+ * Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+ * Copyright (C) 2014-2015, 2019, D. R. Commander.  All Rights Reserved.
+ * Copyright (C) 2016-2018, Loongson Technology Corporation Limited, BeiJing.
+ *                          All Rights Reserved.
+ * Authors:  ZhuChen     <zhuchen@loongson.cn>
+ *           SunZhangzhi <sunzhangzhi-cq@loongson.cn>
+ *           CaiWanwei   <caiwanwei@loongson.cn>
+ *           ZhangLixia  <zhanglixia-hf@loongson.cn>
+ *
+ * Based on the x86 SIMD extension for IJG JPEG library
+ * Copyright (C) 1999-2006, MIYASAKA Masaru.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+/* This file is included by jccolor-mmi.c */
+
+
+#if RGB_RED == 0
+#define mmA  re
+#define mmB  ro
+#elif RGB_GREEN == 0
+#define mmA  ge
+#define mmB  go
+#elif RGB_BLUE == 0
+#define mmA  be
+#define mmB  bo
+#else
+#define mmA  xe
+#define mmB  xo
+#endif
+
+#if RGB_RED == 1
+#define mmC  re
+#define mmD  ro
+#elif RGB_GREEN == 1
+#define mmC  ge
+#define mmD  go
+#elif RGB_BLUE == 1
+#define mmC  be
+#define mmD  bo
+#else
+#define mmC  xe
+#define mmD  xo
+#endif
+
+#if RGB_RED == 2
+#define mmE  re
+#define mmF  ro
+#elif RGB_GREEN == 2
+#define mmE  ge
+#define mmF  go
+#elif RGB_BLUE == 2
+#define mmE  be
+#define mmF  bo
+#else
+#define mmE  xe
+#define mmF  xo
+#endif
+
+#if RGB_RED == 3
+#define mmG  re
+#define mmH  ro
+#elif RGB_GREEN == 3
+#define mmG  ge
+#define mmH  go
+#elif RGB_BLUE == 3
+#define mmG  be
+#define mmH  bo
+#else
+#define mmG  xe
+#define mmH  xo
+#endif
+
+
+void jsimd_rgb_ycc_convert_mmi(JDIMENSION image_width, JSAMPARRAY input_buf,
+                               JSAMPIMAGE output_buf, JDIMENSION output_row,
+                               int num_rows)
+{
+  JSAMPROW inptr, outptr0, outptr1, outptr2;
+  int num_cols, col;
+  __m64 re, ro, ge, go, be, bo, xe;
+#if RGB_PIXELSIZE == 4
+  __m64 xo;
+#endif
+  __m64 rgle, rghe, rglo, rgho, bgle, bghe, bglo, bgho;
+  __m64 ble, halfble, bhe, halfbhe, blo, halfblo, bho, halfbho;
+  __m64 rle, halfrle, rhe, halfrhe, rlo, halfrlo, rho, halfrho;
+  __m64 yle_rg, yhe_rg, yle_bg, yhe_bg, yle, yhe, ye;
+  __m64 ylo_rg, yho_rg, ylo_bg, yho_bg, ylo, yho, yo, y;
+  __m64 cble, cbhe, cbe, cblo, cbho, cbo, cb;
+  __m64 crle, crhe, cre, crlo, crho, cro, cr;
+
+  while (--num_rows >= 0) {
+    inptr = *input_buf++;
+    outptr0 = output_buf[0][output_row];
+    outptr1 = output_buf[1][output_row];
+    outptr2 = output_buf[2][output_row];
+    output_row++;
+
+    for (num_cols = image_width; num_cols > 0; num_cols -= 8,
+         outptr0 += 8, outptr1 += 8, outptr2 += 8) {
+
+#if RGB_PIXELSIZE == 3
+
+      if (num_cols < 8) {
+        col = num_cols * 3;
+        asm(".set noreorder\r\n"
+
+            "li       $8, 1\r\n"
+            "move     $9, %3\r\n"
+            "and      $10, $9, $8\r\n"
+            "beqz     $10, 1f\r\n"
+            "nop      \r\n"
+            "subu     $9, $9, 1\r\n"
+            "xor      $12, $12, $12\r\n"
+            "move     $13, %5\r\n"
+            PTR_ADDU  "$13, $13, $9\r\n"
+            "lbu      $12, 0($13)\r\n"
+
+            "1:       \r\n"
+            "li       $8, 2\r\n"
+            "and      $10, $9, $8\r\n"
+            "beqz     $10, 2f\r\n"
+            "nop      \r\n"
+            "subu     $9, $9, 2\r\n"
+            "xor      $11, $11, $11\r\n"
+            "move     $13, %5\r\n"
+            PTR_ADDU  "$13, $13, $9\r\n"
+            "lhu      $11, 0($13)\r\n"
+            "sll      $12, $12, 16\r\n"
+            "or       $12, $12, $11\r\n"
+
+            "2:       \r\n"
+            "dmtc1    $12, %0\r\n"
+            "li       $8, 4\r\n"
+            "and      $10, $9, $8\r\n"
+            "beqz     $10, 3f\r\n"
+            "nop      \r\n"
+            "subu     $9, $9, 4\r\n"
+            "move     $13, %5\r\n"
+            PTR_ADDU  "$13, $13, $9\r\n"
+            "lwu      $14, 0($13)\r\n"
+            "dmtc1    $14, %1\r\n"
+            "dsll32   $12, $12, 0\r\n"
+            "or       $12, $12, $14\r\n"
+            "dmtc1    $12, %0\r\n"
+
+            "3:       \r\n"
+            "li       $8, 8\r\n"
+            "and      $10, $9, $8\r\n"
+            "beqz     $10, 4f\r\n"
+            "nop      \r\n"
+            "mov.s    %1, %0\r\n"
+            "ldc1     %0, 0(%5)\r\n"
+            "li       $9, 8\r\n"
+            "j        5f\r\n"
+            "nop      \r\n"
+
+            "4:       \r\n"
+            "li       $8, 16\r\n"
+            "and      $10, $9, $8\r\n"
+            "beqz     $10, 5f\r\n"
+            "nop      \r\n"
+            "mov.s    %2, %0\r\n"
+            "ldc1     %0, 0(%5)\r\n"
+            "ldc1     %1, 8(%5)\r\n"
+
+            "5:       \r\n"
+            "nop      \r\n"
+            ".set reorder\r\n"
+
+            : "=f" (mmA), "=f" (mmG), "=f" (mmF)
+            : "r" (col), "r" (num_rows), "r" (inptr)
+            : "$f0", "$f2", "$f4", "$8", "$9", "$10", "$11", "$12", "$13",
+              "$14", "memory"
+           );
+      } else {
+        if (!(((long)inptr) & 7)) {
+          mmA = _mm_load_si64((__m64 *)&inptr[0]);
+          mmG = _mm_load_si64((__m64 *)&inptr[8]);
+          mmF = _mm_load_si64((__m64 *)&inptr[16]);
+        } else {
+          mmA = _mm_loadu_si64((__m64 *)&inptr[0]);
+          mmG = _mm_loadu_si64((__m64 *)&inptr[8]);
+          mmF = _mm_loadu_si64((__m64 *)&inptr[16]);
+        }
+        inptr += RGB_PIXELSIZE * 8;
+      }
+      mmD = _mm_srli_si64(mmA, 4 * BYTE_BIT);
+      mmA = _mm_slli_si64(mmA, 4 * BYTE_BIT);
+
+      mmA = _mm_unpackhi_pi8(mmA, mmG);
+      mmG = _mm_slli_si64(mmG, 4 * BYTE_BIT);
+
+      mmD = _mm_unpacklo_pi8(mmD, mmF);
+      mmG = _mm_unpackhi_pi8(mmG, mmF);
+
+      mmE = _mm_srli_si64(mmA, 4 * BYTE_BIT);
+      mmA = _mm_slli_si64(mmA, 4 * BYTE_BIT);
+
+      mmA = _mm_unpackhi_pi8(mmA, mmD);
+      mmD = _mm_slli_si64(mmD, 4 * BYTE_BIT);
+
+      mmE = _mm_unpacklo_pi8(mmE, mmG);
+      mmD = _mm_unpackhi_pi8(mmD, mmG);
+      mmC = _mm_loadhi_pi8_f(mmA);
+      mmA = _mm_loadlo_pi8_f(mmA);
+
+      mmB = _mm_loadhi_pi8_f(mmE);
+      mmE = _mm_loadlo_pi8_f(mmE);
+
+      mmF = _mm_loadhi_pi8_f(mmD);
+      mmD = _mm_loadlo_pi8_f(mmD);
+
+#else  /* RGB_PIXELSIZE == 4 */
+
+      if (num_cols < 8) {
+        col = num_cols;
+        asm(".set noreorder\r\n"
+
+            "li       $8, 1\r\n"
+            "move     $9, %4\r\n"
+            "and      $10, $9, $8\r\n"
+            "beqz     $10, 1f\r\n"
+            "nop      \r\n"
+            "subu     $9, $9, 1\r\n"
+            PTR_SLL   "$11, $9, 2\r\n"
+            "move     $13, %5\r\n"
+            PTR_ADDU  "$13, $13, $11\r\n"
+            "lwc1     %0, 0($13)\r\n"
+
+            "1:       \r\n"
+            "li       $8, 2\r\n"
+            "and      $10, $9, $8\r\n"
+            "beqz     $10, 2f\r\n"
+            "nop      \r\n"
+            "subu     $9, $9, 2\r\n"
+            PTR_SLL   "$11, $9, 2\r\n"
+            "move     $13, %5\r\n"
+            PTR_ADDU  "$13, $13, $11\r\n"
+            "mov.s    %1, %0\r\n"
+            "ldc1     %0, 0($13)\r\n"
+
+            "2:       \r\n"
+            "li       $8, 4\r\n"
+            "and      $10, $9, $8\r\n"
+            "beqz     $10, 3f\r\n"
+            "nop      \r\n"
+            "mov.s    %2, %0\r\n"
+            "mov.s    %3, %1\r\n"
+            "ldc1     %0, 0(%5)\r\n"
+            "ldc1     %1, 8(%5)\r\n"
+
+            "3:       \r\n"
+            "nop      \r\n"
+            ".set reorder\r\n"
+
+            : "=f" (mmA), "=f" (mmF), "=f" (mmD), "=f" (mmC)
+            : "r" (col), "r" (inptr)
+            : "$f0", "$f2", "$8", "$9", "$10", "$11", "$13", "memory"
+           );
+      } else {
+        if (!(((long)inptr) & 7)) {
+          mmA = _mm_load_si64((__m64 *)&inptr[0]);
+          mmF = _mm_load_si64((__m64 *)&inptr[8]);
+          mmD = _mm_load_si64((__m64 *)&inptr[16]);
+          mmC = _mm_load_si64((__m64 *)&inptr[24]);
+        } else {
+          mmA = _mm_loadu_si64((__m64 *)&inptr[0]);
+          mmF = _mm_loadu_si64((__m64 *)&inptr[8]);
+          mmD = _mm_loadu_si64((__m64 *)&inptr[16]);
+          mmC = _mm_loadu_si64((__m64 *)&inptr[24]);
+        }
+        inptr += RGB_PIXELSIZE * 8;
+      }
+      mmB = _mm_unpackhi_pi8(mmA, mmF);
+      mmA = _mm_unpacklo_pi8(mmA, mmF);
+
+      mmG = _mm_unpackhi_pi8(mmD, mmC);
+      mmD = _mm_unpacklo_pi8(mmD, mmC);
+
+      mmE = _mm_unpackhi_pi16(mmA, mmD);
+      mmA = _mm_unpacklo_pi16(mmA, mmD);
+
+      mmH = _mm_unpackhi_pi16(mmB, mmG);
+      mmB = _mm_unpacklo_pi16(mmB, mmG);
+
+      mmC = _mm_loadhi_pi8_f(mmA);
+      mmA = _mm_loadlo_pi8_f(mmA);
+
+      mmD = _mm_loadhi_pi8_f(mmB);
+      mmB = _mm_loadlo_pi8_f(mmB);
+
+      mmG = _mm_loadhi_pi8_f(mmE);
+      mmE = _mm_loadlo_pi8_f(mmE);
+
+      mmF = _mm_unpacklo_pi8(mmH, mmH);
+      mmH = _mm_unpackhi_pi8(mmH, mmH);
+      mmF = _mm_srli_pi16(mmF, BYTE_BIT);
+      mmH = _mm_srli_pi16(mmH, BYTE_BIT);
+
+#endif
+
+      /* re=(R0 R2 R4 R6), ge=(G0 G2 G4 G6), be=(B0 B2 B4 B6)
+       * ro=(R1 R3 R5 R7), go=(G1 G3 G5 G7), bo=(B1 B3 B5 B7)
+       *
+       * (Original)
+       * Y  =  0.29900 * R + 0.58700 * G + 0.11400 * B
+       * Cb = -0.16874 * R - 0.33126 * G + 0.50000 * B + CENTERJSAMPLE
+       * Cr =  0.50000 * R - 0.41869 * G - 0.08131 * B + CENTERJSAMPLE
+       *
+       * (This implementation)
+       * Y  =  0.29900 * R + 0.33700 * G + 0.11400 * B + 0.25000 * G
+       * Cb = -0.16874 * R - 0.33126 * G + 0.50000 * B + CENTERJSAMPLE
+       * Cr =  0.50000 * R - 0.41869 * G - 0.08131 * B + CENTERJSAMPLE
+       */
+
+      rglo = _mm_unpacklo_pi16(ro, go);
+      rgho = _mm_unpackhi_pi16(ro, go);
+      ylo_rg = _mm_madd_pi16(rglo, PW_F0299_F0337);
+      yho_rg = _mm_madd_pi16(rgho, PW_F0299_F0337);
+      cblo = _mm_madd_pi16(rglo, PW_MF016_MF033);
+      cbho = _mm_madd_pi16(rgho, PW_MF016_MF033);
+
+      blo = _mm_loadlo_pi16_f(bo);
+      bho = _mm_loadhi_pi16_f(bo);
+      halfblo = _mm_srli_pi32(blo, 1);
+      halfbho = _mm_srli_pi32(bho, 1);
+
+      cblo = _mm_add_pi32(cblo, halfblo);
+      cbho = _mm_add_pi32(cbho, halfbho);
+      cblo = _mm_add_pi32(cblo, PD_ONEHALFM1_CJ);
+      cbho = _mm_add_pi32(cbho, PD_ONEHALFM1_CJ);
+      cblo = _mm_srli_pi32(cblo, SCALEBITS);
+      cbho = _mm_srli_pi32(cbho, SCALEBITS);
+      cbo = _mm_packs_pi32(cblo, cbho);
+
+      rgle = _mm_unpacklo_pi16(re, ge);
+      rghe = _mm_unpackhi_pi16(re, ge);
+      yle_rg = _mm_madd_pi16(rgle, PW_F0299_F0337);
+      yhe_rg = _mm_madd_pi16(rghe, PW_F0299_F0337);
+      cble = _mm_madd_pi16(rgle, PW_MF016_MF033);
+      cbhe = _mm_madd_pi16(rghe, PW_MF016_MF033);
+
+      ble = _mm_loadlo_pi16_f(be);
+      bhe = _mm_loadhi_pi16_f(be);
+      halfble = _mm_srli_pi32(ble, 1);
+      halfbhe = _mm_srli_pi32(bhe, 1);
+
+      cble = _mm_add_pi32(cble, halfble);
+      cbhe = _mm_add_pi32(cbhe, halfbhe);
+      cble = _mm_add_pi32(cble, PD_ONEHALFM1_CJ);
+      cbhe = _mm_add_pi32(cbhe, PD_ONEHALFM1_CJ);
+      cble = _mm_srli_pi32(cble, SCALEBITS);
+      cbhe = _mm_srli_pi32(cbhe, SCALEBITS);
+      cbe = _mm_packs_pi32(cble, cbhe);
+
+      cbo = _mm_slli_pi16(cbo, BYTE_BIT);
+      cb = _mm_or_si64(cbe, cbo);
+
+      bglo = _mm_unpacklo_pi16(bo, go);
+      bgho = _mm_unpackhi_pi16(bo, go);
+      ylo_bg = _mm_madd_pi16(bglo, PW_F0114_F0250);
+      yho_bg = _mm_madd_pi16(bgho, PW_F0114_F0250);
+      crlo = _mm_madd_pi16(bglo, PW_MF008_MF041);
+      crho = _mm_madd_pi16(bgho, PW_MF008_MF041);
+
+      ylo = _mm_add_pi32(ylo_bg, ylo_rg);
+      yho = _mm_add_pi32(yho_bg, yho_rg);
+      ylo = _mm_add_pi32(ylo, PD_ONEHALF);
+      yho = _mm_add_pi32(yho, PD_ONEHALF);
+      ylo = _mm_srli_pi32(ylo, SCALEBITS);
+      yho = _mm_srli_pi32(yho, SCALEBITS);
+      yo = _mm_packs_pi32(ylo, yho);
+
+      rlo = _mm_loadlo_pi16_f(ro);
+      rho = _mm_loadhi_pi16_f(ro);
+      halfrlo = _mm_srli_pi32(rlo, 1);
+      halfrho = _mm_srli_pi32(rho, 1);
+
+      crlo = _mm_add_pi32(crlo, halfrlo);
+      crho = _mm_add_pi32(crho, halfrho);
+      crlo = _mm_add_pi32(crlo, PD_ONEHALFM1_CJ);
+      crho = _mm_add_pi32(crho, PD_ONEHALFM1_CJ);
+      crlo = _mm_srli_pi32(crlo, SCALEBITS);
+      crho = _mm_srli_pi32(crho, SCALEBITS);
+      cro = _mm_packs_pi32(crlo, crho);
+
+      bgle = _mm_unpacklo_pi16(be, ge);
+      bghe = _mm_unpackhi_pi16(be, ge);
+      yle_bg = _mm_madd_pi16(bgle, PW_F0114_F0250);
+      yhe_bg = _mm_madd_pi16(bghe, PW_F0114_F0250);
+      crle = _mm_madd_pi16(bgle, PW_MF008_MF041);
+      crhe = _mm_madd_pi16(bghe, PW_MF008_MF041);
+
+      yle = _mm_add_pi32(yle_bg, yle_rg);
+      yhe = _mm_add_pi32(yhe_bg, yhe_rg);
+      yle = _mm_add_pi32(yle, PD_ONEHALF);
+      yhe = _mm_add_pi32(yhe, PD_ONEHALF);
+      yle = _mm_srli_pi32(yle, SCALEBITS);
+      yhe = _mm_srli_pi32(yhe, SCALEBITS);
+      ye = _mm_packs_pi32(yle, yhe);
+
+      yo = _mm_slli_pi16(yo, BYTE_BIT);
+      y = _mm_or_si64(ye, yo);
+
+      rle = _mm_loadlo_pi16_f(re);
+      rhe = _mm_loadhi_pi16_f(re);
+      halfrle = _mm_srli_pi32(rle, 1);
+      halfrhe = _mm_srli_pi32(rhe, 1);
+
+      crle = _mm_add_pi32(crle, halfrle);
+      crhe = _mm_add_pi32(crhe, halfrhe);
+      crle = _mm_add_pi32(crle, PD_ONEHALFM1_CJ);
+      crhe = _mm_add_pi32(crhe, PD_ONEHALFM1_CJ);
+      crle = _mm_srli_pi32(crle, SCALEBITS);
+      crhe = _mm_srli_pi32(crhe, SCALEBITS);
+      cre = _mm_packs_pi32(crle, crhe);
+
+      cro = _mm_slli_pi16(cro, BYTE_BIT);
+      cr = _mm_or_si64(cre, cro);
+
+      _mm_store_si64((__m64 *)&outptr0[0], y);
+      _mm_store_si64((__m64 *)&outptr1[0], cb);
+      _mm_store_si64((__m64 *)&outptr2[0], cr);
+    }
+  }
+}
+
+#undef mmA
+#undef mmB
+#undef mmC
+#undef mmD
+#undef mmE
+#undef mmF
+#undef mmG
+#undef mmH
diff --git a/3rdparty/libjpeg/src/simd/mips64/jccolor-mmi.c b/3rdparty/libjpeg/src/simd/mips64/jccolor-mmi.c
new file mode 100644
index 00000000..93ef5c79
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/mips64/jccolor-mmi.c
@@ -0,0 +1,148 @@
+/*
+ * Loongson MMI optimizations for libjpeg-turbo
+ *
+ * Copyright (C) 2011, 2014, D. R. Commander.  All Rights Reserved.
+ * Copyright (C) 2016-2017, Loongson Technology Corporation Limited, BeiJing.
+ *                          All Rights Reserved.
+ * Authors:  ZhuChen     <zhuchen@loongson.cn>
+ *           CaiWanwei   <caiwanwei@loongson.cn>
+ *           SunZhangzhi <sunzhangzhi-cq@loongson.cn>
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+/* RGB --> YCC CONVERSION */
+
+#include "jsimd_mmi.h"
+
+
+#define F_0_081  ((short)5329)                /* FIX(0.08131) */
+#define F_0_114  ((short)7471)                /* FIX(0.11400) */
+#define F_0_168  ((short)11059)               /* FIX(0.16874) */
+#define F_0_250  ((short)16384)               /* FIX(0.25000) */
+#define F_0_299  ((short)19595)               /* FIX(0.29900) */
+#define F_0_331  ((short)21709)               /* FIX(0.33126) */
+#define F_0_418  ((short)27439)               /* FIX(0.41869) */
+#define F_0_587  ((short)38470)               /* FIX(0.58700) */
+#define F_0_337  ((short)(F_0_587 - F_0_250)) /* FIX(0.58700) - FIX(0.25000) */
+
+enum const_index {
+  index_PD_ONEHALF,
+  index_PW_F0299_F0337,
+  index_PW_F0114_F0250,
+  index_PW_MF016_MF033,
+  index_PW_MF008_MF041,
+  index_PD_ONEHALFM1_CJ
+};
+
+static uint64_t const_value[] = {
+  _uint64_set_pi32((int)(1 << (SCALEBITS - 1)), (int)(1 << (SCALEBITS - 1))),
+  _uint64_set_pi16(F_0_337, F_0_299, F_0_337, F_0_299),
+  _uint64_set_pi16(F_0_250, F_0_114, F_0_250, F_0_114),
+  _uint64_set_pi16(-F_0_331, -F_0_168, -F_0_331, -F_0_168),
+  _uint64_set_pi16(-F_0_418, -F_0_081, -F_0_418, -F_0_081),
+  _uint64_set_pi32(((1 << (SCALEBITS - 1)) - 1 + (CENTERJSAMPLE << SCALEBITS)),
+                   ((1 << (SCALEBITS - 1)) - 1 + (CENTERJSAMPLE << SCALEBITS)))
+};
+
+#define get_const_value(index)  (*(__m64 *)&const_value[index])
+
+#define PD_ONEHALF       get_const_value(index_PD_ONEHALF)
+#define PW_F0299_F0337   get_const_value(index_PW_F0299_F0337)
+#define PW_F0114_F0250   get_const_value(index_PW_F0114_F0250)
+#define PW_MF016_MF033   get_const_value(index_PW_MF016_MF033)
+#define PW_MF008_MF041   get_const_value(index_PW_MF008_MF041)
+#define PD_ONEHALFM1_CJ  get_const_value(index_PD_ONEHALFM1_CJ)
+
+
+#include "jccolext-mmi.c"
+#undef RGB_RED
+#undef RGB_GREEN
+#undef RGB_BLUE
+#undef RGB_PIXELSIZE
+
+#define RGB_RED  EXT_RGB_RED
+#define RGB_GREEN  EXT_RGB_GREEN
+#define RGB_BLUE  EXT_RGB_BLUE
+#define RGB_PIXELSIZE  EXT_RGB_PIXELSIZE
+#define jsimd_rgb_ycc_convert_mmi  jsimd_extrgb_ycc_convert_mmi
+#include "jccolext-mmi.c"
+#undef RGB_RED
+#undef RGB_GREEN
+#undef RGB_BLUE
+#undef RGB_PIXELSIZE
+#undef jsimd_rgb_ycc_convert_mmi
+
+#define RGB_RED  EXT_RGBX_RED
+#define RGB_GREEN  EXT_RGBX_GREEN
+#define RGB_BLUE  EXT_RGBX_BLUE
+#define RGB_PIXELSIZE  EXT_RGBX_PIXELSIZE
+#define jsimd_rgb_ycc_convert_mmi  jsimd_extrgbx_ycc_convert_mmi
+#include "jccolext-mmi.c"
+#undef RGB_RED
+#undef RGB_GREEN
+#undef RGB_BLUE
+#undef RGB_PIXELSIZE
+#undef jsimd_rgb_ycc_convert_mmi
+
+#define RGB_RED  EXT_BGR_RED
+#define RGB_GREEN  EXT_BGR_GREEN
+#define RGB_BLUE  EXT_BGR_BLUE
+#define RGB_PIXELSIZE  EXT_BGR_PIXELSIZE
+#define jsimd_rgb_ycc_convert_mmi  jsimd_extbgr_ycc_convert_mmi
+#include "jccolext-mmi.c"
+#undef RGB_RED
+#undef RGB_GREEN
+#undef RGB_BLUE
+#undef RGB_PIXELSIZE
+#undef jsimd_rgb_ycc_convert_mmi
+
+#define RGB_RED  EXT_BGRX_RED
+#define RGB_GREEN  EXT_BGRX_GREEN
+#define RGB_BLUE  EXT_BGRX_BLUE
+#define RGB_PIXELSIZE  EXT_BGRX_PIXELSIZE
+#define jsimd_rgb_ycc_convert_mmi  jsimd_extbgrx_ycc_convert_mmi
+#include "jccolext-mmi.c"
+#undef RGB_RED
+#undef RGB_GREEN
+#undef RGB_BLUE
+#undef RGB_PIXELSIZE
+#undef jsimd_rgb_ycc_convert_mmi
+
+#define RGB_RED  EXT_XBGR_RED
+#define RGB_GREEN  EXT_XBGR_GREEN
+#define RGB_BLUE  EXT_XBGR_BLUE
+#define RGB_PIXELSIZE  EXT_XBGR_PIXELSIZE
+#define jsimd_rgb_ycc_convert_mmi  jsimd_extxbgr_ycc_convert_mmi
+#include "jccolext-mmi.c"
+#undef RGB_RED
+#undef RGB_GREEN
+#undef RGB_BLUE
+#undef RGB_PIXELSIZE
+#undef jsimd_rgb_ycc_convert_mmi
+
+#define RGB_RED  EXT_XRGB_RED
+#define RGB_GREEN  EXT_XRGB_GREEN
+#define RGB_BLUE  EXT_XRGB_BLUE
+#define RGB_PIXELSIZE  EXT_XRGB_PIXELSIZE
+#define jsimd_rgb_ycc_convert_mmi  jsimd_extxrgb_ycc_convert_mmi
+#include "jccolext-mmi.c"
+#undef RGB_RED
+#undef RGB_GREEN
+#undef RGB_BLUE
+#undef RGB_PIXELSIZE
+#undef jsimd_rgb_ycc_convert_mmi
diff --git a/3rdparty/libjpeg/src/simd/mips64/jcgray-mmi.c b/3rdparty/libjpeg/src/simd/mips64/jcgray-mmi.c
new file mode 100644
index 00000000..9c7b833f
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/mips64/jcgray-mmi.c
@@ -0,0 +1,132 @@
+/*
+ * Loongson MMI optimizations for libjpeg-turbo
+ *
+ * Copyright (C) 2011, 2014, D. R. Commander.  All Rights Reserved.
+ * Copyright (C) 2016-2018, Loongson Technology Corporation Limited, BeiJing.
+ *                          All Rights Reserved.
+ * Authors:  ZhangLixia <zhanglixia-hf@loongson.cn>
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+/* RGB --> GRAYSCALE CONVERSION */
+
+#include "jsimd_mmi.h"
+
+
+#define F_0_114  ((short)7471)                /* FIX(0.11400) */
+#define F_0_250  ((short)16384)               /* FIX(0.25000) */
+#define F_0_299  ((short)19595)               /* FIX(0.29900) */
+#define F_0_587  ((short)38470)               /* FIX(0.58700) */
+#define F_0_337  ((short)(F_0_587 - F_0_250)) /* FIX(0.58700) - FIX(0.25000) */
+
+enum const_index {
+  index_PD_ONEHALF,
+  index_PW_F0299_F0337,
+  index_PW_F0114_F0250
+};
+
+static uint64_t const_value[] = {
+  _uint64_set_pi32((int)(1 << (SCALEBITS - 1)), (int)(1 << (SCALEBITS - 1))),
+  _uint64_set_pi16(F_0_337, F_0_299, F_0_337, F_0_299),
+  _uint64_set_pi16(F_0_250, F_0_114, F_0_250, F_0_114)
+};
+
+#define get_const_value(index)  (*(__m64 *)&const_value[index])
+
+#define PD_ONEHALF       get_const_value(index_PD_ONEHALF)
+#define PW_F0299_F0337   get_const_value(index_PW_F0299_F0337)
+#define PW_F0114_F0250   get_const_value(index_PW_F0114_F0250)
+
+
+#include "jcgryext-mmi.c"
+#undef RGB_RED
+#undef RGB_GREEN
+#undef RGB_BLUE
+#undef RGB_PIXELSIZE
+
+#define RGB_RED  EXT_RGB_RED
+#define RGB_GREEN  EXT_RGB_GREEN
+#define RGB_BLUE  EXT_RGB_BLUE
+#define RGB_PIXELSIZE  EXT_RGB_PIXELSIZE
+#define jsimd_rgb_gray_convert_mmi  jsimd_extrgb_gray_convert_mmi
+#include "jcgryext-mmi.c"
+#undef RGB_RED
+#undef RGB_GREEN
+#undef RGB_BLUE
+#undef RGB_PIXELSIZE
+#undef jsimd_rgb_gray_convert_mmi
+
+#define RGB_RED  EXT_RGBX_RED
+#define RGB_GREEN  EXT_RGBX_GREEN
+#define RGB_BLUE  EXT_RGBX_BLUE
+#define RGB_PIXELSIZE  EXT_RGBX_PIXELSIZE
+#define jsimd_rgb_gray_convert_mmi  jsimd_extrgbx_gray_convert_mmi
+#include "jcgryext-mmi.c"
+#undef RGB_RED
+#undef RGB_GREEN
+#undef RGB_BLUE
+#undef RGB_PIXELSIZE
+#undef jsimd_rgb_gray_convert_mmi
+
+#define RGB_RED  EXT_BGR_RED
+#define RGB_GREEN  EXT_BGR_GREEN
+#define RGB_BLUE  EXT_BGR_BLUE
+#define RGB_PIXELSIZE  EXT_BGR_PIXELSIZE
+#define jsimd_rgb_gray_convert_mmi  jsimd_extbgr_gray_convert_mmi
+#include "jcgryext-mmi.c"
+#undef RGB_RED
+#undef RGB_GREEN
+#undef RGB_BLUE
+#undef RGB_PIXELSIZE
+#undef jsimd_rgb_gray_convert_mmi
+
+#define RGB_RED  EXT_BGRX_RED
+#define RGB_GREEN  EXT_BGRX_GREEN
+#define RGB_BLUE  EXT_BGRX_BLUE
+#define RGB_PIXELSIZE  EXT_BGRX_PIXELSIZE
+#define jsimd_rgb_gray_convert_mmi  jsimd_extbgrx_gray_convert_mmi
+#include "jcgryext-mmi.c"
+#undef RGB_RED
+#undef RGB_GREEN
+#undef RGB_BLUE
+#undef RGB_PIXELSIZE
+#undef jsimd_rgb_gray_convert_mmi
+
+#define RGB_RED  EXT_XBGR_RED
+#define RGB_GREEN  EXT_XBGR_GREEN
+#define RGB_BLUE  EXT_XBGR_BLUE
+#define RGB_PIXELSIZE  EXT_XBGR_PIXELSIZE
+#define jsimd_rgb_gray_convert_mmi  jsimd_extxbgr_gray_convert_mmi
+#include "jcgryext-mmi.c"
+#undef RGB_RED
+#undef RGB_GREEN
+#undef RGB_BLUE
+#undef RGB_PIXELSIZE
+#undef jsimd_rgb_gray_convert_mmi
+
+#define RGB_RED  EXT_XRGB_RED
+#define RGB_GREEN  EXT_XRGB_GREEN
+#define RGB_BLUE  EXT_XRGB_BLUE
+#define RGB_PIXELSIZE  EXT_XRGB_PIXELSIZE
+#define jsimd_rgb_gray_convert_mmi  jsimd_extxrgb_gray_convert_mmi
+#include "jcgryext-mmi.c"
+#undef RGB_RED
+#undef RGB_GREEN
+#undef RGB_BLUE
+#undef RGB_PIXELSIZE
+#undef jsimd_rgb_gray_convert_mmi
diff --git a/3rdparty/libjpeg/src/simd/mips64/jcgryext-mmi.c b/3rdparty/libjpeg/src/simd/mips64/jcgryext-mmi.c
new file mode 100644
index 00000000..08a83d66
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/mips64/jcgryext-mmi.c
@@ -0,0 +1,374 @@
+/*
+ * Loongson MMI optimizations for libjpeg-turbo
+ *
+ * Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+ * Copyright (C) 2014-2015, 2019, D. R. Commander.  All Rights Reserved.
+ * Copyright (C) 2016-2018, Loongson Technology Corporation Limited, BeiJing.
+ *                          All Rights Reserved.
+ * Authors:  ZhangLixia <zhanglixia-hf@loongson.cn>
+ *
+ * Based on the x86 SIMD extension for IJG JPEG library
+ * Copyright (C) 1999-2006, MIYASAKA Masaru.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+/* This file is included by jcgray-mmi.c */
+
+
+#if RGB_RED == 0
+#define mmA  re
+#define mmB  ro
+#elif RGB_GREEN == 0
+#define mmA  ge
+#define mmB  go
+#elif RGB_BLUE == 0
+#define mmA  be
+#define mmB  bo
+#else
+#define mmA  xe
+#define mmB  xo
+#endif
+
+#if RGB_RED == 1
+#define mmC  re
+#define mmD  ro
+#elif RGB_GREEN == 1
+#define mmC  ge
+#define mmD  go
+#elif RGB_BLUE == 1
+#define mmC  be
+#define mmD  bo
+#else
+#define mmC  xe
+#define mmD  xo
+#endif
+
+#if RGB_RED == 2
+#define mmE  re
+#define mmF  ro
+#elif RGB_GREEN == 2
+#define mmE  ge
+#define mmF  go
+#elif RGB_BLUE == 2
+#define mmE  be
+#define mmF  bo
+#else
+#define mmE  xe
+#define mmF  xo
+#endif
+
+#if RGB_RED == 3
+#define mmG  re
+#define mmH  ro
+#elif RGB_GREEN == 3
+#define mmG  ge
+#define mmH  go
+#elif RGB_BLUE == 3
+#define mmG  be
+#define mmH  bo
+#else
+#define mmG  xe
+#define mmH  xo
+#endif
+
+
+void jsimd_rgb_gray_convert_mmi(JDIMENSION image_width, JSAMPARRAY input_buf,
+                                JSAMPIMAGE output_buf, JDIMENSION output_row,
+                                int num_rows)
+{
+  JSAMPROW inptr, outptr;
+  int num_cols, col;
+  __m64 re, ro, ge, go, be, bo, xe;
+#if RGB_PIXELSIZE == 4
+  __m64 xo;
+#endif
+  __m64 rgle, rghe, rglo, rgho, bgle, bghe, bglo, bgho;
+  __m64 yle_rg, yhe_rg, yle_bg, yhe_bg, yle, yhe, ye;
+  __m64 ylo_rg, yho_rg, ylo_bg, yho_bg, ylo, yho, yo, y;
+
+  while (--num_rows >= 0) {
+    inptr = *input_buf++;
+    outptr = output_buf[0][output_row];
+    output_row++;
+
+    for (num_cols = image_width; num_cols > 0; num_cols -= 8,
+         outptr += 8) {
+
+#if RGB_PIXELSIZE == 3
+
+      if (num_cols < 8) {
+        col = num_cols * 3;
+        asm(".set noreorder\r\n"
+
+            "li       $8, 1\r\n"
+            "move     $9, %3\r\n"
+            "and      $10, $9, $8\r\n"
+            "beqz     $10, 1f\r\n"
+            "nop      \r\n"
+            "subu     $9, $9, 1\r\n"
+            "xor      $12, $12, $12\r\n"
+            "move     $13, %5\r\n"
+            PTR_ADDU  "$13, $13, $9\r\n"
+            "lbu      $12, 0($13)\r\n"
+
+            "1:       \r\n"
+            "li       $8, 2\r\n"
+            "and      $10, $9, $8\r\n"
+            "beqz     $10, 2f\r\n"
+            "nop      \r\n"
+            "subu     $9, $9, 2\r\n"
+            "xor      $11, $11, $11\r\n"
+            "move     $13, %5\r\n"
+            PTR_ADDU  "$13, $13, $9\r\n"
+            "lhu      $11, 0($13)\r\n"
+            "sll      $12, $12, 16\r\n"
+            "or       $12, $12, $11\r\n"
+
+            "2:       \r\n"
+            "dmtc1    $12, %0\r\n"
+            "li       $8, 4\r\n"
+            "and      $10, $9, $8\r\n"
+            "beqz     $10, 3f\r\n"
+            "nop      \r\n"
+            "subu     $9, $9, 4\r\n"
+            "move     $13, %5\r\n"
+            PTR_ADDU  "$13, $13, $9\r\n"
+            "lwu      $14, 0($13)\r\n"
+            "dmtc1    $14, %1\r\n"
+            "dsll32   $12, $12, 0\r\n"
+            "or       $12, $12, $14\r\n"
+            "dmtc1    $12, %0\r\n"
+
+            "3:       \r\n"
+            "li       $8, 8\r\n"
+            "and      $10, $9, $8\r\n"
+            "beqz     $10, 4f\r\n"
+            "nop      \r\n"
+            "mov.s    %1, %0\r\n"
+            "ldc1     %0, 0(%5)\r\n"
+            "li       $9, 8\r\n"
+            "j        5f\r\n"
+            "nop      \r\n"
+
+            "4:       \r\n"
+            "li       $8, 16\r\n"
+            "and      $10, $9, $8\r\n"
+            "beqz     $10, 5f\r\n"
+            "nop      \r\n"
+            "mov.s    %2, %0\r\n"
+            "ldc1     %0, 0(%5)\r\n"
+            "ldc1     %1, 8(%5)\r\n"
+
+            "5:       \r\n"
+            "nop      \r\n"
+            ".set reorder\r\n"
+
+            : "=f" (mmA), "=f" (mmG), "=f" (mmF)
+            : "r" (col), "r" (num_rows), "r" (inptr)
+            : "$f0", "$f2", "$f4", "$8", "$9", "$10", "$11", "$12", "$13",
+              "$14", "memory"
+           );
+      } else {
+        if (!(((long)inptr) & 7)) {
+          mmA = _mm_load_si64((__m64 *)&inptr[0]);
+          mmG = _mm_load_si64((__m64 *)&inptr[8]);
+          mmF = _mm_load_si64((__m64 *)&inptr[16]);
+        } else {
+          mmA = _mm_loadu_si64((__m64 *)&inptr[0]);
+          mmG = _mm_loadu_si64((__m64 *)&inptr[8]);
+          mmF = _mm_loadu_si64((__m64 *)&inptr[16]);
+        }
+        inptr += RGB_PIXELSIZE * 8;
+      }
+      mmD = _mm_srli_si64(mmA, 4 * BYTE_BIT);
+      mmA = _mm_slli_si64(mmA, 4 * BYTE_BIT);
+
+      mmA = _mm_unpackhi_pi8(mmA, mmG);
+      mmG = _mm_slli_si64(mmG, 4 * BYTE_BIT);
+
+      mmD = _mm_unpacklo_pi8(mmD, mmF);
+      mmG = _mm_unpackhi_pi8(mmG, mmF);
+
+      mmE = _mm_srli_si64(mmA, 4 * BYTE_BIT);
+      mmA = _mm_slli_si64(mmA, 4 * BYTE_BIT);
+
+      mmA = _mm_unpackhi_pi8(mmA, mmD);
+      mmD = _mm_slli_si64(mmD, 4 * BYTE_BIT);
+
+      mmE = _mm_unpacklo_pi8(mmE, mmG);
+      mmD = _mm_unpackhi_pi8(mmD, mmG);
+      mmC = _mm_loadhi_pi8_f(mmA);
+      mmA = _mm_loadlo_pi8_f(mmA);
+
+      mmB = _mm_loadhi_pi8_f(mmE);
+      mmE = _mm_loadlo_pi8_f(mmE);
+
+      mmF = _mm_loadhi_pi8_f(mmD);
+      mmD = _mm_loadlo_pi8_f(mmD);
+
+#else  /* RGB_PIXELSIZE == 4 */
+
+      if (num_cols < 8) {
+        col = num_cols;
+        asm(".set noreorder\r\n"
+
+            "li       $8, 1\r\n"
+            "move     $9, %4\r\n"
+            "and      $10, $9, $8\r\n"
+            "beqz     $10, 1f\r\n"
+            "nop      \r\n"
+            "subu     $9, $9, 1\r\n"
+            PTR_SLL   "$11, $9, 2\r\n"
+            "move     $13, %5\r\n"
+            PTR_ADDU  "$13, $13, $11\r\n"
+            "lwc1     %0, 0($13)\r\n"
+
+            "1:       \r\n"
+            "li       $8, 2\r\n"
+            "and      $10, $9, $8\r\n"
+            "beqz     $10, 2f\r\n"
+            "nop      \r\n"
+            "subu     $9, $9, 2\r\n"
+            PTR_SLL   "$11, $9, 2\r\n"
+            "move     $13, %5\r\n"
+            PTR_ADDU  "$13, $13, $11\r\n"
+            "mov.s    %1, %0\r\n"
+            "ldc1     %0, 0($13)\r\n"
+
+            "2:       \r\n"
+            "li       $8, 4\r\n"
+            "and      $10, $9, $8\r\n"
+            "beqz     $10, 3f\r\n"
+            "nop      \r\n"
+            "mov.s    %2, %0\r\n"
+            "mov.s    %3, %1\r\n"
+            "ldc1     %0, 0(%5)\r\n"
+            "ldc1     %1, 8(%5)\r\n"
+
+            "3:       \r\n"
+            "nop      \r\n"
+            ".set reorder\r\n"
+
+            : "=f" (mmA), "=f" (mmF), "=f" (mmD), "=f" (mmC)
+            : "r" (col), "r" (inptr)
+            : "$f0", "$f2", "$8", "$9", "$10", "$11", "$13", "memory"
+           );
+      } else {
+        if (!(((long)inptr) & 7)) {
+          mmA = _mm_load_si64((__m64 *)&inptr[0]);
+          mmF = _mm_load_si64((__m64 *)&inptr[8]);
+          mmD = _mm_load_si64((__m64 *)&inptr[16]);
+          mmC = _mm_load_si64((__m64 *)&inptr[24]);
+        } else {
+          mmA = _mm_loadu_si64((__m64 *)&inptr[0]);
+          mmF = _mm_loadu_si64((__m64 *)&inptr[8]);
+          mmD = _mm_loadu_si64((__m64 *)&inptr[16]);
+          mmC = _mm_loadu_si64((__m64 *)&inptr[24]);
+        }
+        inptr += RGB_PIXELSIZE * 8;
+      }
+      mmB = _mm_unpackhi_pi8(mmA, mmF);
+      mmA = _mm_unpacklo_pi8(mmA, mmF);
+
+      mmG = _mm_unpackhi_pi8(mmD, mmC);
+      mmD = _mm_unpacklo_pi8(mmD, mmC);
+
+      mmE = _mm_unpackhi_pi16(mmA, mmD);
+      mmA = _mm_unpacklo_pi16(mmA, mmD);
+
+      mmH = _mm_unpackhi_pi16(mmB, mmG);
+      mmB = _mm_unpacklo_pi16(mmB, mmG);
+
+      mmC = _mm_loadhi_pi8_f(mmA);
+      mmA = _mm_loadlo_pi8_f(mmA);
+
+      mmD = _mm_loadhi_pi8_f(mmB);
+      mmB = _mm_loadlo_pi8_f(mmB);
+
+      mmG = _mm_loadhi_pi8_f(mmE);
+      mmE = _mm_loadlo_pi8_f(mmE);
+
+      mmF = _mm_unpacklo_pi8(mmH, mmH);
+      mmH = _mm_unpackhi_pi8(mmH, mmH);
+      mmF = _mm_srli_pi16(mmF, BYTE_BIT);
+      mmH = _mm_srli_pi16(mmH, BYTE_BIT);
+
+#endif
+
+      /* re=(R0 R2 R4 R6), ge=(G0 G2 G4 G6), be=(B0 B2 B4 B6)
+       * ro=(R1 R3 R5 R7), go=(G1 G3 G5 G7), bo=(B1 B3 B5 B7)
+       *
+       * (Original)
+       * Y  =  0.29900 * R + 0.58700 * G + 0.11400 * B
+       *
+       * (This implementation)
+       * Y  =  0.29900 * R + 0.33700 * G + 0.11400 * B + 0.25000 * G
+       */
+
+      rglo = _mm_unpacklo_pi16(ro, go);
+      rgho = _mm_unpackhi_pi16(ro, go);
+      ylo_rg = _mm_madd_pi16(rglo, PW_F0299_F0337);
+      yho_rg = _mm_madd_pi16(rgho, PW_F0299_F0337);
+
+      rgle = _mm_unpacklo_pi16(re, ge);
+      rghe = _mm_unpackhi_pi16(re, ge);
+      yle_rg = _mm_madd_pi16(rgle, PW_F0299_F0337);
+      yhe_rg = _mm_madd_pi16(rghe, PW_F0299_F0337);
+
+      bglo = _mm_unpacklo_pi16(bo, go);
+      bgho = _mm_unpackhi_pi16(bo, go);
+      ylo_bg = _mm_madd_pi16(bglo, PW_F0114_F0250);
+      yho_bg = _mm_madd_pi16(bgho, PW_F0114_F0250);
+
+      ylo = _mm_add_pi32(ylo_bg, ylo_rg);
+      yho = _mm_add_pi32(yho_bg, yho_rg);
+      ylo = _mm_add_pi32(ylo, PD_ONEHALF);
+      yho = _mm_add_pi32(yho, PD_ONEHALF);
+      ylo = _mm_srli_pi32(ylo, SCALEBITS);
+      yho = _mm_srli_pi32(yho, SCALEBITS);
+      yo = _mm_packs_pi32(ylo, yho);
+
+      bgle = _mm_unpacklo_pi16(be, ge);
+      bghe = _mm_unpackhi_pi16(be, ge);
+      yle_bg = _mm_madd_pi16(bgle, PW_F0114_F0250);
+      yhe_bg = _mm_madd_pi16(bghe, PW_F0114_F0250);
+
+      yle = _mm_add_pi32(yle_bg, yle_rg);
+      yhe = _mm_add_pi32(yhe_bg, yhe_rg);
+      yle = _mm_add_pi32(yle, PD_ONEHALF);
+      yhe = _mm_add_pi32(yhe, PD_ONEHALF);
+      yle = _mm_srli_pi32(yle, SCALEBITS);
+      yhe = _mm_srli_pi32(yhe, SCALEBITS);
+      ye = _mm_packs_pi32(yle, yhe);
+
+      yo = _mm_slli_pi16(yo, BYTE_BIT);
+      y = _mm_or_si64(ye, yo);
+
+      _mm_store_si64((__m64 *)&outptr[0], y);
+    }
+  }
+}
+
+#undef mmA
+#undef mmB
+#undef mmC
+#undef mmD
+#undef mmE
+#undef mmF
+#undef mmG
+#undef mmH
diff --git a/3rdparty/libjpeg/src/simd/mips64/jcsample-mmi.c b/3rdparty/libjpeg/src/simd/mips64/jcsample-mmi.c
new file mode 100644
index 00000000..0354dac0
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/mips64/jcsample-mmi.c
@@ -0,0 +1,98 @@
+/*
+ * Loongson MMI optimizations for libjpeg-turbo
+ *
+ * Copyright (C) 2015, 2018-2019, D. R. Commander.  All Rights Reserved.
+ * Copyright (C) 2016-2017, Loongson Technology Corporation Limited, BeiJing.
+ *                          All Rights Reserved.
+ * Authors:  ZhuChen     <zhuchen@loongson.cn>
+ *           CaiWanwei   <caiwanwei@loongson.cn>
+ *           SunZhangzhi <sunzhangzhi-cq@loongson.cn>
+ *
+ * Based on the x86 SIMD extension for IJG JPEG library
+ * Copyright (C) 1999-2006, MIYASAKA Masaru.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+/* CHROMA DOWNSAMPLING */
+
+#include "jsimd_mmi.h"
+#include "jcsample.h"
+
+
+void jsimd_h2v2_downsample_mmi(JDIMENSION image_width, int max_v_samp_factor,
+                               JDIMENSION v_samp_factor,
+                               JDIMENSION width_in_blocks,
+                               JSAMPARRAY input_data, JSAMPARRAY output_data)
+{
+  int inrow, outrow, outcol;
+  JDIMENSION output_cols = width_in_blocks * DCTSIZE;
+  JSAMPROW inptr0, inptr1, outptr;
+  __m64 bias, mask = 0.0, thisavg, nextavg, avg;
+  __m64 this0o, this0e, this0, this0sum, next0o, next0e, next0, next0sum;
+  __m64 this1o, this1e, this1, this1sum, next1o, next1e, next1, next1sum;
+
+  expand_right_edge(input_data, max_v_samp_factor, image_width,
+                    output_cols * 2);
+
+  bias = _mm_set1_pi32((1 << 17) + 1);   /* 0x00020001 (32-bit bias pattern) */
+                                         /* bias={1, 2, 1, 2} (16-bit) */
+  mask = _mm_cmpeq_pi16(mask, mask);
+  mask = _mm_srli_pi16(mask, BYTE_BIT);  /* {0xFF 0x00 0xFF 0x00 ..} */
+
+  for (inrow = 0, outrow = 0; outrow < v_samp_factor;
+       inrow += 2, outrow++) {
+
+    inptr0 = input_data[inrow];
+    inptr1 = input_data[inrow + 1];
+    outptr = output_data[outrow];
+
+    for (outcol = output_cols; outcol > 0;
+         outcol -= 8, inptr0 += 16, inptr1 += 16, outptr += 8) {
+
+      this0 = _mm_load_si64((__m64 *)&inptr0[0]);
+      this1 = _mm_load_si64((__m64 *)&inptr1[0]);
+      next0 = _mm_load_si64((__m64 *)&inptr0[8]);
+      next1 = _mm_load_si64((__m64 *)&inptr1[8]);
+
+      this0o = _mm_and_si64(this0, mask);
+      this0e = _mm_srli_pi16(this0, BYTE_BIT);
+      this1o = _mm_and_si64(this1, mask);
+      this1e = _mm_srli_pi16(this1, BYTE_BIT);
+      this0sum = _mm_add_pi16(this0o, this0e);
+      this1sum = _mm_add_pi16(this1o, this1e);
+
+      next0o = _mm_and_si64(next0, mask);
+      next0e = _mm_srli_pi16(next0, BYTE_BIT);
+      next1o = _mm_and_si64(next1, mask);
+      next1e = _mm_srli_pi16(next1, BYTE_BIT);
+      next0sum = _mm_add_pi16(next0o, next0e);
+      next1sum = _mm_add_pi16(next1o, next1e);
+
+      thisavg = _mm_add_pi16(this0sum, this1sum);
+      nextavg = _mm_add_pi16(next0sum, next1sum);
+      thisavg = _mm_add_pi16(thisavg, bias);
+      nextavg = _mm_add_pi16(nextavg, bias);
+      thisavg = _mm_srli_pi16(thisavg, 2);
+      nextavg = _mm_srli_pi16(nextavg, 2);
+
+      avg = _mm_packs_pu16(thisavg, nextavg);
+
+      _mm_store_si64((__m64 *)&outptr[0], avg);
+    }
+  }
+}
diff --git a/3rdparty/libjpeg/src/simd/mips64/jcsample.h b/3rdparty/libjpeg/src/simd/mips64/jcsample.h
new file mode 100644
index 00000000..bd07fcc4
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/mips64/jcsample.h
@@ -0,0 +1,28 @@
+/*
+ * jcsample.h
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1991-1996, Thomas G. Lane.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ */
+
+LOCAL(void)
+expand_right_edge(JSAMPARRAY image_data, int num_rows, JDIMENSION input_cols,
+                  JDIMENSION output_cols)
+{
+  register JSAMPROW ptr;
+  register JSAMPLE pixval;
+  register int count;
+  int row;
+  int numcols = (int)(output_cols - input_cols);
+
+  if (numcols > 0) {
+    for (row = 0; row < num_rows; row++) {
+      ptr = image_data[row] + input_cols;
+      pixval = ptr[-1];
+      for (count = numcols; count > 0; count--)
+        *ptr++ = pixval;
+    }
+  }
+}
diff --git a/3rdparty/libjpeg/src/simd/mips64/jdcolext-mmi.c b/3rdparty/libjpeg/src/simd/mips64/jdcolext-mmi.c
new file mode 100644
index 00000000..3b5b2f20
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/mips64/jdcolext-mmi.c
@@ -0,0 +1,415 @@
+/*
+ * Loongson MMI optimizations for libjpeg-turbo
+ *
+ * Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+ * Copyright (C) 2015, 2019, D. R. Commander.  All Rights Reserved.
+ * Copyright (C) 2016-2018, Loongson Technology Corporation Limited, BeiJing.
+ *                          All Rights Reserved.
+ * Authors:  ZhuChen     <zhuchen@loongson.cn>
+ *           SunZhangzhi <sunzhangzhi-cq@loongson.cn>
+ *           CaiWanwei   <caiwanwei@loongson.cn>
+ *
+ * Based on the x86 SIMD extension for IJG JPEG library
+ * Copyright (C) 1999-2006, MIYASAKA Masaru.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+/* This file is included by jdcolor-mmi.c */
+
+
+#if RGB_RED == 0
+#define mmA  re
+#define mmB  ro
+#elif RGB_GREEN == 0
+#define mmA  ge
+#define mmB  go
+#elif RGB_BLUE == 0
+#define mmA  be
+#define mmB  bo
+#else
+#define mmA  xe
+#define mmB  xo
+#endif
+
+#if RGB_RED == 1
+#define mmC  re
+#define mmD  ro
+#elif RGB_GREEN == 1
+#define mmC  ge
+#define mmD  go
+#elif RGB_BLUE == 1
+#define mmC  be
+#define mmD  bo
+#else
+#define mmC  xe
+#define mmD  xo
+#endif
+
+#if RGB_RED == 2
+#define mmE  re
+#define mmF  ro
+#elif RGB_GREEN == 2
+#define mmE  ge
+#define mmF  go
+#elif RGB_BLUE == 2
+#define mmE  be
+#define mmF  bo
+#else
+#define mmE  xe
+#define mmF  xo
+#endif
+
+#if RGB_RED == 3
+#define mmG  re
+#define mmH  ro
+#elif RGB_GREEN == 3
+#define mmG  ge
+#define mmH  go
+#elif RGB_BLUE == 3
+#define mmG  be
+#define mmH  bo
+#else
+#define mmG  xe
+#define mmH  xo
+#endif
+
+
+void jsimd_ycc_rgb_convert_mmi(JDIMENSION out_width, JSAMPIMAGE input_buf,
+                               JDIMENSION input_row, JSAMPARRAY output_buf,
+                               int num_rows)
+{
+  JSAMPROW outptr, inptr0, inptr1, inptr2;
+  int num_cols, col;
+  __m64 ye, yo, y, cbe, cbe2, cbo, cbo2, cb, cre, cre2, cro, cro2, cr;
+  __m64 re, ro, gle, ghe, ge, glo, gho, go, be, bo, xe = 0.0, xo = 0.0;
+  __m64 decenter, mask;
+
+  while (--num_rows >= 0) {
+    inptr0 = input_buf[0][input_row];
+    inptr1 = input_buf[1][input_row];
+    inptr2 = input_buf[2][input_row];
+    input_row++;
+    outptr = *output_buf++;
+
+    for (num_cols = out_width; num_cols > 0; num_cols -= 8,
+         inptr0 += 8, inptr1 += 8, inptr2 += 8) {
+
+      cb = _mm_load_si64((__m64 *)inptr1);
+      cr = _mm_load_si64((__m64 *)inptr2);
+      y = _mm_load_si64((__m64 *)inptr0);
+
+      mask = decenter = 0.0;
+      mask = _mm_cmpeq_pi16(mask, mask);
+      decenter = _mm_cmpeq_pi16(decenter, decenter);
+      mask = _mm_srli_pi16(mask, BYTE_BIT);   /* {0xFF 0x00 0xFF 0x00 ..} */
+      decenter = _mm_slli_pi16(decenter, 7);  /* {0xFF80 0xFF80 0xFF80 0xFF80} */
+
+      cbe = _mm_and_si64(mask, cb);           /* Cb(0246) */
+      cbo = _mm_srli_pi16(cb, BYTE_BIT);      /* Cb(1357) */
+      cre = _mm_and_si64(mask, cr);           /* Cr(0246) */
+      cro = _mm_srli_pi16(cr, BYTE_BIT);      /* Cr(1357) */
+      cbe = _mm_add_pi16(cbe, decenter);
+      cbo = _mm_add_pi16(cbo, decenter);
+      cre = _mm_add_pi16(cre, decenter);
+      cro = _mm_add_pi16(cro, decenter);
+
+      /* (Original)
+       * R = Y                + 1.40200 * Cr
+       * G = Y - 0.34414 * Cb - 0.71414 * Cr
+       * B = Y + 1.77200 * Cb
+       *
+       * (This implementation)
+       * R = Y                + 0.40200 * Cr + Cr
+       * G = Y - 0.34414 * Cb + 0.28586 * Cr - Cr
+       * B = Y - 0.22800 * Cb + Cb + Cb
+       */
+
+      cbe2 = _mm_add_pi16(cbe, cbe);          /* 2*CbE */
+      cbo2 = _mm_add_pi16(cbo, cbo);          /* 2*CbO */
+      cre2 = _mm_add_pi16(cre, cre);          /* 2*CrE */
+      cro2 = _mm_add_pi16(cro, cro);          /* 2*CrO */
+
+      be = _mm_mulhi_pi16(cbe2, PW_MF0228);   /* (2*CbE * -FIX(0.22800) */
+      bo = _mm_mulhi_pi16(cbo2, PW_MF0228);   /* (2*CbO * -FIX(0.22800) */
+      re = _mm_mulhi_pi16(cre2, PW_F0402);    /* (2*CrE * FIX(0.40200)) */
+      ro = _mm_mulhi_pi16(cro2, PW_F0402);    /* (2*CrO * FIX(0.40200)) */
+
+      be = _mm_add_pi16(be, PW_ONE);
+      bo = _mm_add_pi16(bo, PW_ONE);
+      be = _mm_srai_pi16(be, 1);              /* (CbE * -FIX(0.22800)) */
+      bo = _mm_srai_pi16(bo, 1);              /* (CbO * -FIX(0.22800)) */
+      re = _mm_add_pi16(re, PW_ONE);
+      ro = _mm_add_pi16(ro, PW_ONE);
+      re = _mm_srai_pi16(re, 1);              /* (CrE * FIX(0.40200)) */
+      ro = _mm_srai_pi16(ro, 1);              /* (CrO * FIX(0.40200)) */
+
+      be = _mm_add_pi16(be, cbe);
+      bo = _mm_add_pi16(bo, cbo);
+      be = _mm_add_pi16(be, cbe);             /* (CbE * FIX(1.77200))=(B-Y)E */
+      bo = _mm_add_pi16(bo, cbo);             /* (CbO * FIX(1.77200))=(B-Y)O */
+      re = _mm_add_pi16(re, cre);             /* (CrE * FIX(1.40200))=(R-Y)E */
+      ro = _mm_add_pi16(ro, cro);             /* (CrO * FIX(1.40200))=(R-Y)O */
+
+      gle = _mm_unpacklo_pi16(cbe, cre);
+      ghe = _mm_unpackhi_pi16(cbe, cre);
+      gle = _mm_madd_pi16(gle, PW_MF0344_F0285);
+      ghe = _mm_madd_pi16(ghe, PW_MF0344_F0285);
+      glo = _mm_unpacklo_pi16(cbo, cro);
+      gho = _mm_unpackhi_pi16(cbo, cro);
+      glo = _mm_madd_pi16(glo, PW_MF0344_F0285);
+      gho = _mm_madd_pi16(gho, PW_MF0344_F0285);
+
+      gle = _mm_add_pi32(gle, PD_ONEHALF);
+      ghe = _mm_add_pi32(ghe, PD_ONEHALF);
+      gle = _mm_srai_pi32(gle, SCALEBITS);
+      ghe = _mm_srai_pi32(ghe, SCALEBITS);
+      glo = _mm_add_pi32(glo, PD_ONEHALF);
+      gho = _mm_add_pi32(gho, PD_ONEHALF);
+      glo = _mm_srai_pi32(glo, SCALEBITS);
+      gho = _mm_srai_pi32(gho, SCALEBITS);
+
+      ge = _mm_packs_pi32(gle, ghe);       /* CbE*-FIX(0.344)+CrE*FIX(0.285) */
+      go = _mm_packs_pi32(glo, gho);       /* CbO*-FIX(0.344)+CrO*FIX(0.285) */
+      ge = _mm_sub_pi16(ge, cre);  /* CbE*-FIX(0.344)+CrE*-FIX(0.714)=(G-Y)E */
+      go = _mm_sub_pi16(go, cro);  /* CbO*-FIX(0.344)+CrO*-FIX(0.714)=(G-Y)O */
+
+      ye = _mm_and_si64(mask, y);             /* Y(0246) */
+      yo = _mm_srli_pi16(y, BYTE_BIT);        /* Y(1357) */
+
+      re = _mm_add_pi16(re, ye);              /* ((R-Y)E+YE)=(R0 R2 R4 R6) */
+      ro = _mm_add_pi16(ro, yo);              /* ((R-Y)O+YO)=(R1 R3 R5 R7) */
+      re = _mm_packs_pu16(re, re);            /* (R0 R2 R4 R6 ** ** ** **) */
+      ro = _mm_packs_pu16(ro, ro);            /* (R1 R3 R5 R7 ** ** ** **) */
+
+      ge = _mm_add_pi16(ge, ye);              /* ((G-Y)E+YE)=(G0 G2 G4 G6) */
+      go = _mm_add_pi16(go, yo);              /* ((G-Y)O+YO)=(G1 G3 G5 G7) */
+      ge = _mm_packs_pu16(ge, ge);            /* (G0 G2 G4 G6 ** ** ** **) */
+      go = _mm_packs_pu16(go, go);            /* (G1 G3 G5 G7 ** ** ** **) */
+
+      be = _mm_add_pi16(be, ye);              /* (YE+(B-Y)E)=(B0 B2 B4 B6) */
+      bo = _mm_add_pi16(bo, yo);              /* (YO+(B-Y)O)=(B1 B3 B5 B7) */
+      be = _mm_packs_pu16(be, be);            /* (B0 B2 B4 B6 ** ** ** **) */
+      bo = _mm_packs_pu16(bo, bo);            /* (B1 B3 B5 B7 ** ** ** **) */
+
+#if RGB_PIXELSIZE == 3
+
+      /* mmA=(00 02 04 06 ** ** ** **), mmB=(01 03 05 07 ** ** ** **) */
+      /* mmC=(10 12 14 16 ** ** ** **), mmD=(11 13 15 17 ** ** ** **) */
+      mmA = _mm_unpacklo_pi8(mmA, mmC);       /* (00 10 02 12 04 14 06 16) */
+      mmE = _mm_unpacklo_pi8(mmE, mmB);       /* (20 01 22 03 24 05 26 07) */
+      mmD = _mm_unpacklo_pi8(mmD, mmF);       /* (11 21 13 23 15 25 17 27) */
+
+      mmH = _mm_srli_si64(mmA, 2 * BYTE_BIT);
+
+      mmG = _mm_unpackhi_pi16(mmA, mmE);      /* (04 14 24 05 06 16 26 07) */
+      mmA = _mm_unpacklo_pi16(mmA, mmE);      /* (00 10 20 01 02 12 22 03) */
+
+      mmE = _mm_srli_si64(mmE, 2 * BYTE_BIT);
+      mmB = _mm_srli_si64(mmD, 2 * BYTE_BIT);  /* (13 23 15 25 17 27 -- --) */
+
+      mmC = _mm_unpackhi_pi16(mmD, mmH);      /* (15 25 06 16 17 27 -- --) */
+      mmD = _mm_unpacklo_pi16(mmD, mmH);      /* (11 21 02 12 13 23 04 14) */
+
+      mmF = _mm_unpackhi_pi16(mmE, mmB);      /* (26 07 17 27 -- -- -- --) */
+      mmE = _mm_unpacklo_pi16(mmE, mmB);      /* (22 03 13 23 24 05 15 25) */
+
+      mmA = _mm_unpacklo_pi32(mmA, mmD);      /* (00 10 20 01 11 21 02 12) */
+      mmE = _mm_unpacklo_pi32(mmE, mmG);      /* (22 03 13 23 04 14 24 05) */
+      mmC = _mm_unpacklo_pi32(mmC, mmF);      /* (15 25 06 16 26 07 17 27) */
+
+      if (num_cols >= 8) {
+        if (!(((long)outptr) & 7)) {
+          _mm_store_si64((__m64 *)outptr, mmA);
+          _mm_store_si64((__m64 *)(outptr + 8), mmE);
+          _mm_store_si64((__m64 *)(outptr + 16), mmC);
+        } else {
+          _mm_storeu_si64((__m64 *)outptr, mmA);
+          _mm_storeu_si64((__m64 *)(outptr + 8), mmE);
+          _mm_storeu_si64((__m64 *)(outptr + 16), mmC);
+        }
+        outptr += RGB_PIXELSIZE * 8;
+      } else {
+        col = num_cols * 3;
+        asm(".set noreorder\r\n"
+
+            "li       $8, 16\r\n"
+            "move     $9, %4\r\n"
+            "mov.s    $f4, %1\r\n"
+            "mov.s    $f6, %3\r\n"
+            "move     $10, %5\r\n"
+            "bltu     $9, $8, 1f\r\n"
+            "nop      \r\n"
+            "gssdlc1  $f4, 7($10)\r\n"
+            "gssdrc1  $f4, 0($10)\r\n"
+            "gssdlc1  $f6, 7+8($10)\r\n"
+            "gssdrc1  $f6, 8($10)\r\n"
+            "mov.s    $f4, %2\r\n"
+            "subu     $9, $9, 16\r\n"
+            PTR_ADDU  "$10, $10, 16\r\n"
+            "b        2f\r\n"
+            "nop      \r\n"
+
+            "1:       \r\n"
+            "li       $8, 8\r\n"              /* st8 */
+            "bltu     $9, $8, 2f\r\n"
+            "nop      \r\n"
+            "gssdlc1  $f4, 7($10)\r\n"
+            "gssdrc1  $f4, 0($10)\r\n"
+            "mov.s    $f4, %3\r\n"
+            "subu     $9, $9, 8\r\n"
+            PTR_ADDU  "$10, $10, 8\r\n"
+
+            "2:       \r\n"
+            "li       $8, 4\r\n"              /* st4 */
+            "mfc1     $11, $f4\r\n"
+            "bltu     $9, $8, 3f\r\n"
+            "nop      \r\n"
+            "swl      $11, 3($10)\r\n"
+            "swr      $11, 0($10)\r\n"
+            "li       $8, 32\r\n"
+            "mtc1     $8, $f6\r\n"
+            "dsrl     $f4, $f4, $f6\r\n"
+            "mfc1     $11, $f4\r\n"
+            "subu     $9, $9, 4\r\n"
+            PTR_ADDU  "$10, $10, 4\r\n"
+
+            "3:       \r\n"
+            "li       $8, 2\r\n"              /* st2 */
+            "bltu     $9, $8, 4f\r\n"
+            "nop      \r\n"
+            "ush      $11, 0($10)\r\n"
+            "srl      $11, 16\r\n"
+            "subu     $9, $9, 2\r\n"
+            PTR_ADDU  "$10, $10, 2\r\n"
+
+            "4:       \r\n"
+            "li       $8, 1\r\n"              /* st1 */
+            "bltu     $9, $8, 5f\r\n"
+            "nop      \r\n"
+            "sb       $11, 0($10)\r\n"
+
+            "5:       \r\n"
+            "nop      \r\n"                   /* end */
+            : "=m" (*outptr)
+            : "f" (mmA), "f" (mmC), "f" (mmE), "r" (col), "r" (outptr)
+            : "$f4", "$f6", "$8", "$9", "$10", "$11", "memory"
+           );
+      }
+
+#else  /* RGB_PIXELSIZE == 4 */
+
+#ifdef RGBX_FILLER_0XFF
+      xe = _mm_cmpeq_pi8(xe, xe);
+      xo = _mm_cmpeq_pi8(xo, xo);
+#else
+      xe = _mm_xor_si64(xe, xe);
+      xo = _mm_xor_si64(xo, xo);
+#endif
+      /* mmA=(00 02 04 06 ** ** ** **), mmB=(01 03 05 07 ** ** ** **) */
+      /* mmC=(10 12 14 16 ** ** ** **), mmD=(11 13 15 17 ** ** ** **) */
+      /* mmE=(20 22 24 26 ** ** ** **), mmF=(21 23 25 27 ** ** ** **) */
+      /* mmG=(30 32 34 36 ** ** ** **), mmH=(31 33 35 37 ** ** ** **) */
+
+      mmA = _mm_unpacklo_pi8(mmA, mmC);       /* (00 10 02 12 04 14 06 16) */
+      mmE = _mm_unpacklo_pi8(mmE, mmG);       /* (20 30 22 32 24 34 26 36) */
+      mmB = _mm_unpacklo_pi8(mmB, mmD);       /* (01 11 03 13 05 15 07 17) */
+      mmF = _mm_unpacklo_pi8(mmF, mmH);       /* (21 31 23 33 25 35 27 37) */
+
+      mmC = _mm_unpackhi_pi16(mmA, mmE);      /* (04 14 24 34 06 16 26 36) */
+      mmA = _mm_unpacklo_pi16(mmA, mmE);      /* (00 10 20 30 02 12 22 32) */
+      mmG = _mm_unpackhi_pi16(mmB, mmF);      /* (05 15 25 35 07 17 27 37) */
+      mmB = _mm_unpacklo_pi16(mmB, mmF);      /* (01 11 21 31 03 13 23 33) */
+
+      mmD = _mm_unpackhi_pi32(mmA, mmB);      /* (02 12 22 32 03 13 23 33) */
+      mmA = _mm_unpacklo_pi32(mmA, mmB);      /* (00 10 20 30 01 11 21 31) */
+      mmH = _mm_unpackhi_pi32(mmC, mmG);      /* (06 16 26 36 07 17 27 37) */
+      mmC = _mm_unpacklo_pi32(mmC, mmG);      /* (04 14 24 34 05 15 25 35) */
+
+      if (num_cols >= 8) {
+        if (!(((long)outptr) & 7)) {
+          _mm_store_si64((__m64 *)outptr, mmA);
+          _mm_store_si64((__m64 *)(outptr + 8), mmD);
+          _mm_store_si64((__m64 *)(outptr + 16), mmC);
+          _mm_store_si64((__m64 *)(outptr + 24), mmH);
+        } else {
+          _mm_storeu_si64((__m64 *)outptr, mmA);
+          _mm_storeu_si64((__m64 *)(outptr + 8), mmD);
+          _mm_storeu_si64((__m64 *)(outptr + 16), mmC);
+          _mm_storeu_si64((__m64 *)(outptr + 24), mmH);
+        }
+        outptr += RGB_PIXELSIZE * 8;
+      } else {
+        col = num_cols;
+        asm(".set noreorder\r\n"              /* st16 */
+
+            "li       $8, 4\r\n"
+            "move     $9, %6\r\n"
+            "move     $10, %7\r\n"
+            "mov.s    $f4, %2\r\n"
+            "mov.s    $f6, %4\r\n"
+            "bltu     $9, $8, 1f\r\n"
+            "nop      \r\n"
+            "gssdlc1  $f4, 7($10)\r\n"
+            "gssdrc1  $f4, 0($10)\r\n"
+            "gssdlc1  $f6, 7+8($10)\r\n"
+            "gssdrc1  $f6, 8($10)\r\n"
+            "mov.s    $f4, %3\r\n"
+            "mov.s    $f6, %5\r\n"
+            "subu     $9, $9, 4\r\n"
+            PTR_ADDU  "$10, $10, 16\r\n"
+
+            "1:       \r\n"
+            "li       $8, 2\r\n"              /* st8 */
+            "bltu     $9, $8, 2f\r\n"
+            "nop      \r\n"
+            "gssdlc1  $f4, 7($10)\r\n"
+            "gssdrc1  $f4, 0($10)\r\n"
+            "mov.s    $f4, $f6\r\n"
+            "subu     $9, $9, 2\r\n"
+            PTR_ADDU  "$10, $10, 8\r\n"
+
+            "2:       \r\n"
+            "li       $8, 1\r\n"              /* st4 */
+            "bltu     $9, $8, 3f\r\n"
+            "nop      \r\n"
+            "gsswlc1  $f4, 3($10)\r\n"
+            "gsswrc1  $f4, 0($10)\r\n"
+
+            "3:       \r\n"
+            "li       %1, 0\r\n"              /* end */
+            : "=m" (*outptr), "=r" (col)
+            : "f" (mmA), "f" (mmC), "f" (mmD), "f" (mmH), "r" (col),
+              "r" (outptr)
+            : "$f4", "$f6", "$8", "$9", "$10", "memory"
+           );
+      }
+
+#endif
+
+    }
+  }
+}
+
+#undef mmA
+#undef mmB
+#undef mmC
+#undef mmD
+#undef mmE
+#undef mmF
+#undef mmG
+#undef mmH
diff --git a/3rdparty/libjpeg/src/simd/mips64/jdcolor-mmi.c b/3rdparty/libjpeg/src/simd/mips64/jdcolor-mmi.c
new file mode 100644
index 00000000..2c58263d
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/mips64/jdcolor-mmi.c
@@ -0,0 +1,139 @@
+/*
+ * Loongson MMI optimizations for libjpeg-turbo
+ *
+ * Copyright (C) 2011, 2015, D. R. Commander.  All Rights Reserved.
+ * Copyright (C) 2016-2017, Loongson Technology Corporation Limited, BeiJing.
+ *                          All Rights Reserved.
+ * Authors:  ZhuChen     <zhuchen@loongson.cn>
+ *           CaiWanwei   <caiwanwei@loongson.cn>
+ *           SunZhangzhi <sunzhangzhi-cq@loongson.cn>
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+/* YCC --> RGB CONVERSION */
+
+#include "jsimd_mmi.h"
+
+
+#define F_0_344  ((short)22554)  /* FIX(0.34414) */
+#define F_0_402  ((short)26345)  /* FIX(1.40200) - FIX(1) */
+#define F_0_285  ((short)18734)  /* FIX(1) - FIX(0.71414) */
+#define F_0_228  ((short)14942)  /* FIX(2) - FIX(1.77200) */
+
+enum const_index {
+  index_PW_ONE,
+  index_PW_F0402,
+  index_PW_MF0228,
+  index_PW_MF0344_F0285,
+  index_PD_ONEHALF
+};
+
+static uint64_t const_value[] = {
+  _uint64_set_pi16(1, 1, 1, 1),
+  _uint64_set_pi16(F_0_402, F_0_402, F_0_402, F_0_402),
+  _uint64_set_pi16(-F_0_228, -F_0_228, -F_0_228, -F_0_228),
+  _uint64_set_pi16(F_0_285, -F_0_344, F_0_285, -F_0_344),
+  _uint64_set_pi32((int)(1 << (SCALEBITS - 1)), (int)(1 << (SCALEBITS - 1)))
+};
+
+#define PW_ONE           get_const_value(index_PW_ONE)
+#define PW_F0402         get_const_value(index_PW_F0402)
+#define PW_MF0228        get_const_value(index_PW_MF0228)
+#define PW_MF0344_F0285  get_const_value(index_PW_MF0344_F0285)
+#define PD_ONEHALF       get_const_value(index_PD_ONEHALF)
+
+#define RGBX_FILLER_0XFF  1
+
+
+#include "jdcolext-mmi.c"
+#undef RGB_RED
+#undef RGB_GREEN
+#undef RGB_BLUE
+#undef RGB_PIXELSIZE
+
+#define RGB_RED  EXT_RGB_RED
+#define RGB_GREEN  EXT_RGB_GREEN
+#define RGB_BLUE  EXT_RGB_BLUE
+#define RGB_PIXELSIZE  EXT_RGB_PIXELSIZE
+#define jsimd_ycc_rgb_convert_mmi  jsimd_ycc_extrgb_convert_mmi
+#include "jdcolext-mmi.c"
+#undef RGB_RED
+#undef RGB_GREEN
+#undef RGB_BLUE
+#undef RGB_PIXELSIZE
+#undef jsimd_ycc_rgb_convert_mmi
+
+#define RGB_RED  EXT_RGBX_RED
+#define RGB_GREEN  EXT_RGBX_GREEN
+#define RGB_BLUE  EXT_RGBX_BLUE
+#define RGB_PIXELSIZE  EXT_RGBX_PIXELSIZE
+#define jsimd_ycc_rgb_convert_mmi  jsimd_ycc_extrgbx_convert_mmi
+#include "jdcolext-mmi.c"
+#undef RGB_RED
+#undef RGB_GREEN
+#undef RGB_BLUE
+#undef RGB_PIXELSIZE
+#undef jsimd_ycc_rgb_convert_mmi
+
+#define RGB_RED  EXT_BGR_RED
+#define RGB_GREEN  EXT_BGR_GREEN
+#define RGB_BLUE  EXT_BGR_BLUE
+#define RGB_PIXELSIZE  EXT_BGR_PIXELSIZE
+#define jsimd_ycc_rgb_convert_mmi  jsimd_ycc_extbgr_convert_mmi
+#include "jdcolext-mmi.c"
+#undef RGB_RED
+#undef RGB_GREEN
+#undef RGB_BLUE
+#undef RGB_PIXELSIZE
+#undef jsimd_ycc_rgb_convert_mmi
+
+#define RGB_RED  EXT_BGRX_RED
+#define RGB_GREEN  EXT_BGRX_GREEN
+#define RGB_BLUE  EXT_BGRX_BLUE
+#define RGB_PIXELSIZE  EXT_BGRX_PIXELSIZE
+#define jsimd_ycc_rgb_convert_mmi  jsimd_ycc_extbgrx_convert_mmi
+#include "jdcolext-mmi.c"
+#undef RGB_RED
+#undef RGB_GREEN
+#undef RGB_BLUE
+#undef RGB_PIXELSIZE
+#undef jsimd_ycc_rgb_convert_mmi
+
+#define RGB_RED  EXT_XBGR_RED
+#define RGB_GREEN  EXT_XBGR_GREEN
+#define RGB_BLUE  EXT_XBGR_BLUE
+#define RGB_PIXELSIZE  EXT_XBGR_PIXELSIZE
+#define jsimd_ycc_rgb_convert_mmi  jsimd_ycc_extxbgr_convert_mmi
+#include "jdcolext-mmi.c"
+#undef RGB_RED
+#undef RGB_GREEN
+#undef RGB_BLUE
+#undef RGB_PIXELSIZE
+#undef jsimd_ycc_rgb_convert_mmi
+
+#define RGB_RED  EXT_XRGB_RED
+#define RGB_GREEN  EXT_XRGB_GREEN
+#define RGB_BLUE  EXT_XRGB_BLUE
+#define RGB_PIXELSIZE  EXT_XRGB_PIXELSIZE
+#define jsimd_ycc_rgb_convert_mmi  jsimd_ycc_extxrgb_convert_mmi
+#include "jdcolext-mmi.c"
+#undef RGB_RED
+#undef RGB_GREEN
+#undef RGB_BLUE
+#undef RGB_PIXELSIZE
+#undef jsimd_ycc_rgb_convert_mmi
diff --git a/3rdparty/libjpeg/src/simd/mips64/jdmerge-mmi.c b/3rdparty/libjpeg/src/simd/mips64/jdmerge-mmi.c
new file mode 100644
index 00000000..0a39bd56
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/mips64/jdmerge-mmi.c
@@ -0,0 +1,149 @@
+/*
+ * Loongson MMI optimizations for libjpeg-turbo
+ *
+ * Copyright (C) 2011, 2015, D. R. Commander.  All Rights Reserved.
+ * Copyright (C) 2016-2018, Loongson Technology Corporation Limited, BeiJing.
+ *                          All Rights Reserved.
+ * Authors:  ZhangLixia <zhanglixia-hf@loongson.cn>
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+/* YCC --> RGB CONVERSION */
+
+#include "jsimd_mmi.h"
+
+
+#define F_0_344  ((short)22554)  /* FIX(0.34414) */
+#define F_0_402  ((short)26345)  /* FIX(1.40200) - FIX(1) */
+#define F_0_285  ((short)18734)  /* FIX(1) - FIX(0.71414) */
+#define F_0_228  ((short)14942)  /* FIX(2) - FIX(1.77200) */
+
+enum const_index {
+  index_PW_ONE,
+  index_PW_F0402,
+  index_PW_MF0228,
+  index_PW_MF0344_F0285,
+  index_PD_ONEHALF
+};
+
+static uint64_t const_value[] = {
+  _uint64_set_pi16(1, 1, 1, 1),
+  _uint64_set_pi16(F_0_402, F_0_402, F_0_402, F_0_402),
+  _uint64_set_pi16(-F_0_228, -F_0_228, -F_0_228, -F_0_228),
+  _uint64_set_pi16(F_0_285, -F_0_344, F_0_285, -F_0_344),
+  _uint64_set_pi32((int)(1 << (SCALEBITS - 1)), (int)(1 << (SCALEBITS - 1)))
+};
+
+#define PW_ONE           get_const_value(index_PW_ONE)
+#define PW_F0402         get_const_value(index_PW_F0402)
+#define PW_MF0228        get_const_value(index_PW_MF0228)
+#define PW_MF0344_F0285  get_const_value(index_PW_MF0344_F0285)
+#define PD_ONEHALF       get_const_value(index_PD_ONEHALF)
+
+#define RGBX_FILLER_0XFF  1
+
+
+#include "jdmrgext-mmi.c"
+#undef RGB_RED
+#undef RGB_GREEN
+#undef RGB_BLUE
+#undef RGB_PIXELSIZE
+
+#define RGB_RED  EXT_RGB_RED
+#define RGB_GREEN  EXT_RGB_GREEN
+#define RGB_BLUE  EXT_RGB_BLUE
+#define RGB_PIXELSIZE  EXT_RGB_PIXELSIZE
+#define jsimd_h2v1_merged_upsample_mmi  jsimd_h2v1_extrgb_merged_upsample_mmi
+#define jsimd_h2v2_merged_upsample_mmi  jsimd_h2v2_extrgb_merged_upsample_mmi
+#include "jdmrgext-mmi.c"
+#undef RGB_RED
+#undef RGB_GREEN
+#undef RGB_BLUE
+#undef RGB_PIXELSIZE
+#undef jsimd_h2v1_merged_upsample_mmi
+#undef jsimd_h2v2_merged_upsample_mmi
+
+#define RGB_RED  EXT_RGBX_RED
+#define RGB_GREEN  EXT_RGBX_GREEN
+#define RGB_BLUE  EXT_RGBX_BLUE
+#define RGB_PIXELSIZE  EXT_RGBX_PIXELSIZE
+#define jsimd_h2v1_merged_upsample_mmi  jsimd_h2v1_extrgbx_merged_upsample_mmi
+#define jsimd_h2v2_merged_upsample_mmi  jsimd_h2v2_extrgbx_merged_upsample_mmi
+#include "jdmrgext-mmi.c"
+#undef RGB_RED
+#undef RGB_GREEN
+#undef RGB_BLUE
+#undef RGB_PIXELSIZE
+#undef jsimd_h2v1_merged_upsample_mmi
+#undef jsimd_h2v2_merged_upsample_mmi
+
+#define RGB_RED  EXT_BGR_RED
+#define RGB_GREEN  EXT_BGR_GREEN
+#define RGB_BLUE  EXT_BGR_BLUE
+#define RGB_PIXELSIZE  EXT_BGR_PIXELSIZE
+#define jsimd_h2v1_merged_upsample_mmi  jsimd_h2v1_extbgr_merged_upsample_mmi
+#define jsimd_h2v2_merged_upsample_mmi  jsimd_h2v2_extbgr_merged_upsample_mmi
+#include "jdmrgext-mmi.c"
+#undef RGB_RED
+#undef RGB_GREEN
+#undef RGB_BLUE
+#undef RGB_PIXELSIZE
+#undef jsimd_h2v1_merged_upsample_mmi
+#undef jsimd_h2v2_merged_upsample_mmi
+
+#define RGB_RED  EXT_BGRX_RED
+#define RGB_GREEN  EXT_BGRX_GREEN
+#define RGB_BLUE  EXT_BGRX_BLUE
+#define RGB_PIXELSIZE  EXT_BGRX_PIXELSIZE
+#define jsimd_h2v1_merged_upsample_mmi  jsimd_h2v1_extbgrx_merged_upsample_mmi
+#define jsimd_h2v2_merged_upsample_mmi  jsimd_h2v2_extbgrx_merged_upsample_mmi
+#include "jdmrgext-mmi.c"
+#undef RGB_RED
+#undef RGB_GREEN
+#undef RGB_BLUE
+#undef RGB_PIXELSIZE
+#undef jsimd_h2v1_merged_upsample_mmi
+#undef jsimd_h2v2_merged_upsample_mmi
+
+#define RGB_RED  EXT_XBGR_RED
+#define RGB_GREEN  EXT_XBGR_GREEN
+#define RGB_BLUE  EXT_XBGR_BLUE
+#define RGB_PIXELSIZE  EXT_XBGR_PIXELSIZE
+#define jsimd_h2v1_merged_upsample_mmi  jsimd_h2v1_extxbgr_merged_upsample_mmi
+#define jsimd_h2v2_merged_upsample_mmi  jsimd_h2v2_extxbgr_merged_upsample_mmi
+#include "jdmrgext-mmi.c"
+#undef RGB_RED
+#undef RGB_GREEN
+#undef RGB_BLUE
+#undef RGB_PIXELSIZE
+#undef jsimd_h2v1_merged_upsample_mmi
+#undef jsimd_h2v2_merged_upsample_mmi
+
+#define RGB_RED  EXT_XRGB_RED
+#define RGB_GREEN  EXT_XRGB_GREEN
+#define RGB_BLUE  EXT_XRGB_BLUE
+#define RGB_PIXELSIZE  EXT_XRGB_PIXELSIZE
+#define jsimd_h2v1_merged_upsample_mmi  jsimd_h2v1_extxrgb_merged_upsample_mmi
+#define jsimd_h2v2_merged_upsample_mmi  jsimd_h2v2_extxrgb_merged_upsample_mmi
+#include "jdmrgext-mmi.c"
+#undef RGB_RED
+#undef RGB_GREEN
+#undef RGB_BLUE
+#undef RGB_PIXELSIZE
+#undef jsimd_h2v1_merged_upsample_mmi
+#undef jsimd_h2v2_merged_upsample_mmi
diff --git a/3rdparty/libjpeg/src/simd/mips64/jdmrgext-mmi.c b/3rdparty/libjpeg/src/simd/mips64/jdmrgext-mmi.c
new file mode 100644
index 00000000..be09ff2a
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/mips64/jdmrgext-mmi.c
@@ -0,0 +1,615 @@
+/*
+ * Loongson MMI optimizations for libjpeg-turbo
+ *
+ * Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+ * Copyright (C) 2015, 2019, D. R. Commander.  All Rights Reserved.
+ * Copyright (C) 2016-2018, Loongson Technology Corporation Limited, BeiJing.
+ *                          All Rights Reserved.
+ * Authors:  ZhangLixia <zhanglixia-hf@loongson.cn>
+ *
+ * Based on the x86 SIMD extension for IJG JPEG library
+ * Copyright (C) 1999-2006, MIYASAKA Masaru.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+/* This file is included by jdmerge-mmi.c */
+
+
+#if RGB_RED == 0
+#define mmA  re
+#define mmB  ro
+#elif RGB_GREEN == 0
+#define mmA  ge
+#define mmB  go
+#elif RGB_BLUE == 0
+#define mmA  be
+#define mmB  bo
+#else
+#define mmA  xe
+#define mmB  xo
+#endif
+
+#if RGB_RED == 1
+#define mmC  re
+#define mmD  ro
+#elif RGB_GREEN == 1
+#define mmC  ge
+#define mmD  go
+#elif RGB_BLUE == 1
+#define mmC  be
+#define mmD  bo
+#else
+#define mmC  xe
+#define mmD  xo
+#endif
+
+#if RGB_RED == 2
+#define mmE  re
+#define mmF  ro
+#elif RGB_GREEN == 2
+#define mmE  ge
+#define mmF  go
+#elif RGB_BLUE == 2
+#define mmE  be
+#define mmF  bo
+#else
+#define mmE  xe
+#define mmF  xo
+#endif
+
+#if RGB_RED == 3
+#define mmG  re
+#define mmH  ro
+#elif RGB_GREEN == 3
+#define mmG  ge
+#define mmH  go
+#elif RGB_BLUE == 3
+#define mmG  be
+#define mmH  bo
+#else
+#define mmG  xe
+#define mmH  xo
+#endif
+
+
+void jsimd_h2v1_merged_upsample_mmi(JDIMENSION output_width,
+                                    JSAMPIMAGE input_buf,
+                                    JDIMENSION in_row_group_ctr,
+                                    JSAMPARRAY output_buf)
+{
+  JSAMPROW outptr, inptr0, inptr1, inptr2;
+  int num_cols, col;
+  __m64 ythise, ythiso, ythis, ynexte, ynexto, ynext, yl, y;
+  __m64 cbl, cbl2, cbh, cbh2, cb, crl, crl2, crh, crh2, cr;
+  __m64 rle, rlo, rl, rhe, rho, rh, re, ro;
+  __m64 ga, gb, gle, glo, gl, gc, gd, ghe, gho, gh, ge, go;
+  __m64 ble, blo, bl, bhe, bho, bh, be, bo, xe = 0.0, xo = 0.0;
+  __m64 decenter, mask, zero = 0.0;
+#if RGB_PIXELSIZE == 4
+  __m64 mm8, mm9;
+#endif
+
+  inptr0 = input_buf[0][in_row_group_ctr];
+  inptr1 = input_buf[1][in_row_group_ctr];
+  inptr2 = input_buf[2][in_row_group_ctr];
+  outptr = output_buf[0];
+
+  for (num_cols = output_width >> 1; num_cols > 0; num_cols -= 8,
+       inptr0 += 16, inptr1 += 8, inptr2 += 8) {
+
+    cb = _mm_load_si64((__m64 *)inptr1);
+    cr = _mm_load_si64((__m64 *)inptr2);
+    ythis = _mm_load_si64((__m64 *)inptr0);
+    ynext = _mm_load_si64((__m64 *)inptr0 + 1);
+
+    mask = decenter = 0.0;
+    mask = _mm_cmpeq_pi16(mask, mask);
+    decenter = _mm_cmpeq_pi16(decenter, decenter);
+    mask = _mm_srli_pi16(mask, BYTE_BIT);   /* {0xFF 0x00 0xFF 0x00 ..} */
+    decenter = _mm_slli_pi16(decenter, 7);  /* {0xFF80 0xFF80 0xFF80 0xFF80} */
+
+    cbl = _mm_unpacklo_pi8(cb, zero);         /* Cb(0123) */
+    cbh = _mm_unpackhi_pi8(cb, zero);         /* Cb(4567) */
+    crl = _mm_unpacklo_pi8(cr, zero);         /* Cr(0123) */
+    crh = _mm_unpackhi_pi8(cr, zero);         /* Cr(4567) */
+    cbl = _mm_add_pi16(cbl, decenter);
+    cbh = _mm_add_pi16(cbh, decenter);
+    crl = _mm_add_pi16(crl, decenter);
+    crh = _mm_add_pi16(crh, decenter);
+
+    /* (Original)
+     * R = Y                + 1.40200 * Cr
+     * G = Y - 0.34414 * Cb - 0.71414 * Cr
+     * B = Y + 1.77200 * Cb
+     *
+     * (This implementation)
+     * R = Y                + 0.40200 * Cr + Cr
+     * G = Y - 0.34414 * Cb + 0.28586 * Cr - Cr
+     * B = Y - 0.22800 * Cb + Cb + Cb
+     */
+
+    cbl2 = _mm_add_pi16(cbl, cbl);            /* 2*CbL */
+    cbh2 = _mm_add_pi16(cbh, cbh);            /* 2*CbH */
+    crl2 = _mm_add_pi16(crl, crl);            /* 2*CrL */
+    crh2 = _mm_add_pi16(crh, crh);            /* 2*CrH */
+
+    bl = _mm_mulhi_pi16(cbl2, PW_MF0228);     /* (2*CbL * -FIX(0.22800) */
+    bh = _mm_mulhi_pi16(cbh2, PW_MF0228);     /* (2*CbH * -FIX(0.22800) */
+    rl = _mm_mulhi_pi16(crl2, PW_F0402);      /* (2*CrL * FIX(0.40200)) */
+    rh = _mm_mulhi_pi16(crh2, PW_F0402);      /* (2*CrH * FIX(0.40200)) */
+
+    bl = _mm_add_pi16(bl, PW_ONE);
+    bh = _mm_add_pi16(bh, PW_ONE);
+    bl = _mm_srai_pi16(bl, 1);                /* (CbL * -FIX(0.22800)) */
+    bh = _mm_srai_pi16(bh, 1);                /* (CbH * -FIX(0.22800)) */
+    rl = _mm_add_pi16(rl, PW_ONE);
+    rh = _mm_add_pi16(rh, PW_ONE);
+    rl = _mm_srai_pi16(rl, 1);                /* (CrL * FIX(0.40200)) */
+    rh = _mm_srai_pi16(rh, 1);                /* (CrH * FIX(0.40200)) */
+
+    bl = _mm_add_pi16(bl, cbl);
+    bh = _mm_add_pi16(bh, cbh);
+    bl = _mm_add_pi16(bl, cbl);               /* (CbL * FIX(1.77200))=(B-Y)L */
+    bh = _mm_add_pi16(bh, cbh);               /* (CbH * FIX(1.77200))=(B-Y)H */
+    rl = _mm_add_pi16(rl, crl);               /* (CrL * FIX(1.40200))=(R-Y)L */
+    rh = _mm_add_pi16(rh, crh);               /* (CrH * FIX(1.40200))=(R-Y)H */
+
+    ga = _mm_unpacklo_pi16(cbl, crl);
+    gb = _mm_unpackhi_pi16(cbl, crl);
+    ga = _mm_madd_pi16(ga, PW_MF0344_F0285);
+    gb = _mm_madd_pi16(gb, PW_MF0344_F0285);
+    gc = _mm_unpacklo_pi16(cbh, crh);
+    gd = _mm_unpackhi_pi16(cbh, crh);
+    gc = _mm_madd_pi16(gc, PW_MF0344_F0285);
+    gd = _mm_madd_pi16(gd, PW_MF0344_F0285);
+
+    ga = _mm_add_pi32(ga, PD_ONEHALF);
+    gb = _mm_add_pi32(gb, PD_ONEHALF);
+    ga = _mm_srai_pi32(ga, SCALEBITS);
+    gb = _mm_srai_pi32(gb, SCALEBITS);
+    gc = _mm_add_pi32(gc, PD_ONEHALF);
+    gd = _mm_add_pi32(gd, PD_ONEHALF);
+    gc = _mm_srai_pi32(gc, SCALEBITS);
+    gd = _mm_srai_pi32(gd, SCALEBITS);
+
+    gl = _mm_packs_pi32(ga, gb);           /* CbL*-FIX(0.344)+CrL*FIX(0.285) */
+    gh = _mm_packs_pi32(gc, gd);           /* CbH*-FIX(0.344)+CrH*FIX(0.285) */
+    gl = _mm_sub_pi16(gl, crl);    /* CbL*-FIX(0.344)+CrL*-FIX(0.714)=(G-Y)L */
+    gh = _mm_sub_pi16(gh, crh);    /* CbH*-FIX(0.344)+CrH*-FIX(0.714)=(G-Y)H */
+
+    ythise = _mm_and_si64(mask, ythis);       /* Y(0246) */
+    ythiso = _mm_srli_pi16(ythis, BYTE_BIT);  /* Y(1357) */
+    ynexte = _mm_and_si64(mask, ynext);       /* Y(8ACE) */
+    ynexto = _mm_srli_pi16(ynext, BYTE_BIT);  /* Y(9BDF) */
+
+    rle = _mm_add_pi16(rl, ythise);           /* (R0 R2 R4 R6) */
+    rlo = _mm_add_pi16(rl, ythiso);           /* (R1 R3 R5 R7) */
+    rhe = _mm_add_pi16(rh, ynexte);           /* (R8 RA RC RE) */
+    rho = _mm_add_pi16(rh, ynexto);           /* (R9 RB RD RF) */
+    re = _mm_packs_pu16(rle, rhe);            /* (R0 R2 R4 R6 R8 RA RC RE) */
+    ro = _mm_packs_pu16(rlo, rho);            /* (R1 R3 R5 R7 R9 RB RD RF) */
+
+    gle = _mm_add_pi16(gl, ythise);           /* (G0 G2 G4 G6) */
+    glo = _mm_add_pi16(gl, ythiso);           /* (G1 G3 G5 G7) */
+    ghe = _mm_add_pi16(gh, ynexte);           /* (G8 GA GC GE) */
+    gho = _mm_add_pi16(gh, ynexto);           /* (G9 GB GD GF) */
+    ge = _mm_packs_pu16(gle, ghe);            /* (G0 G2 G4 G6 G8 GA GC GE) */
+    go = _mm_packs_pu16(glo, gho);            /* (G1 G3 G5 G7 G9 GB GD GF) */
+
+    ble = _mm_add_pi16(bl, ythise);           /* (B0 B2 B4 B6) */
+    blo = _mm_add_pi16(bl, ythiso);           /* (B1 B3 B5 B7) */
+    bhe = _mm_add_pi16(bh, ynexte);           /* (B8 BA BC BE) */
+    bho = _mm_add_pi16(bh, ynexto);           /* (B9 BB BD BF) */
+    be = _mm_packs_pu16(ble, bhe);            /* (B0 B2 B4 B6 B8 BA BC BE) */
+    bo = _mm_packs_pu16(blo, bho);            /* (B1 B3 B5 B7 B9 BB BD BF) */
+
+#if RGB_PIXELSIZE == 3
+
+    /* mmA=(00 02 04 06 08 0A 0C 0E), mmB=(01 03 05 07 09 0B 0D 0F) */
+    /* mmC=(10 12 14 16 18 1A 1C 1E), mmD=(11 13 15 17 19 1B 1D 1F) */
+    /* mmE=(20 22 24 26 28 2A 2C 2E), mmF=(21 23 25 27 29 2B 2D 2F) */
+    mmG = _mm_unpacklo_pi8(mmA, mmC);         /* (00 10 02 12 04 14 06 16) */
+    mmA = _mm_unpackhi_pi8(mmA, mmC);         /* (08 18 0A 1A 0C 1C 0E 1E) */
+    mmH = _mm_unpacklo_pi8(mmE, mmB);         /* (20 01 22 03 24 05 26 07) */
+    mmE = _mm_unpackhi_pi8(mmE, mmB);         /* (28 09 2A 0B 2C 0D 2E 0F) */
+    mmC = _mm_unpacklo_pi8(mmD, mmF);         /* (11 21 13 23 15 25 17 27) */
+    mmD = _mm_unpackhi_pi8(mmD, mmF);         /* (19 29 1B 2B 1D 2D 1F 2F) */
+
+    mmB = _mm_unpacklo_pi16(mmG, mmA);        /* (00 10 08 18 02 12 0A 1A) */
+    mmA = _mm_unpackhi_pi16(mmG, mmA);        /* (04 14 0C 1C 06 16 0E 1E) */
+    mmF = _mm_unpacklo_pi16(mmH, mmE);        /* (20 01 28 09 22 03 2A 0B) */
+    mmE = _mm_unpackhi_pi16(mmH, mmE);        /* (24 05 2C 0D 26 07 2E 0F) */
+    mmH = _mm_unpacklo_pi16(mmC, mmD);        /* (11 21 19 29 13 23 1B 2B) */
+    mmG = _mm_unpackhi_pi16(mmC, mmD);        /* (15 25 1D 2D 17 27 1F 2F) */
+
+    mmC = _mm_unpacklo_pi16(mmB, mmF);        /* (00 10 20 01 08 18 28 09) */
+    mmB = _mm_srli_si64(mmB, 4 * BYTE_BIT);
+    mmB = _mm_unpacklo_pi16(mmH, mmB);        /* (11 21 02 12 19 29 0A 1A) */
+    mmD = _mm_unpackhi_pi16(mmF, mmH);        /* (22 03 13 23 2A 0B 1B 2B) */
+    mmF = _mm_unpacklo_pi16(mmA, mmE);        /* (04 14 24 05 0C 1C 2C 0D) */
+    mmA = _mm_srli_si64(mmA, 4 * BYTE_BIT);
+    mmH = _mm_unpacklo_pi16(mmG, mmA);        /* (15 25 06 16 1D 2D 0E 1E) */
+    mmG = _mm_unpackhi_pi16(mmE, mmG);        /* (26 07 17 27 2E 0F 1F 2F) */
+
+    mmA = _mm_unpacklo_pi32(mmC, mmB);        /* (00 10 20 01 11 21 02 12) */
+    mmE = _mm_unpackhi_pi32(mmC, mmB);        /* (08 18 28 09 19 29 0A 1A) */
+    mmB = _mm_unpacklo_pi32(mmD, mmF);        /* (22 03 13 23 04 14 24 05) */
+    mmF = _mm_unpackhi_pi32(mmD, mmF);        /* (2A 0B 1B 2B 0C 1C 2C 0D) */
+    mmC = _mm_unpacklo_pi32(mmH, mmG);        /* (15 25 06 16 26 07 17 27) */
+    mmG = _mm_unpackhi_pi32(mmH, mmG);        /* (1D 2D 0E 1E 2E 0F 1F 2F) */
+
+    if (num_cols >= 8) {
+      if (!(((long)outptr) & 7)) {
+        _mm_store_si64((__m64 *)outptr, mmA);
+        _mm_store_si64((__m64 *)(outptr + 8), mmB);
+        _mm_store_si64((__m64 *)(outptr + 16), mmC);
+        _mm_store_si64((__m64 *)(outptr + 24), mmE);
+        _mm_store_si64((__m64 *)(outptr + 32), mmF);
+        _mm_store_si64((__m64 *)(outptr + 40), mmG);
+      } else {
+        _mm_storeu_si64((__m64 *)outptr, mmA);
+        _mm_storeu_si64((__m64 *)(outptr + 8), mmB);
+        _mm_storeu_si64((__m64 *)(outptr + 16), mmC);
+        _mm_storeu_si64((__m64 *)(outptr + 24), mmE);
+        _mm_storeu_si64((__m64 *)(outptr + 32), mmF);
+        _mm_storeu_si64((__m64 *)(outptr + 40), mmG);
+      }
+      outptr += RGB_PIXELSIZE * 16;
+    } else {
+      if (output_width & 1)
+        col = num_cols * 6 + 3;
+      else
+        col = num_cols * 6;
+
+      asm(".set noreorder\r\n"                /* st24 */
+
+          "li       $8, 24\r\n"
+          "move     $9, %7\r\n"
+          "mov.s    $f4, %1\r\n"
+          "mov.s    $f6, %2\r\n"
+          "mov.s    $f8, %3\r\n"
+          "move     $10, %8\r\n"
+          "bltu     $9, $8, 1f\r\n"
+          "nop      \r\n"
+          "gssdlc1  $f4, 7($10)\r\n"
+          "gssdrc1  $f4, 0($10)\r\n"
+          "gssdlc1  $f6, 7+8($10)\r\n"
+          "gssdrc1  $f6, 8($10)\r\n"
+          "gssdlc1  $f8, 7+16($10)\r\n"
+          "gssdrc1  $f8, 16($10)\r\n"
+          "mov.s    $f4, %4\r\n"
+          "mov.s    $f6, %5\r\n"
+          "mov.s    $f8, %6\r\n"
+          "subu     $9, $9, 24\r\n"
+          PTR_ADDU  "$10, $10, 24\r\n"
+
+          "1:       \r\n"
+          "li       $8, 16\r\n"               /* st16 */
+          "bltu     $9, $8, 2f\r\n"
+          "nop      \r\n"
+          "gssdlc1  $f4, 7($10)\r\n"
+          "gssdrc1  $f4, 0($10)\r\n"
+          "gssdlc1  $f6, 7+8($10)\r\n"
+          "gssdrc1  $f6, 8($10)\r\n"
+          "mov.s    $f4, $f8\r\n"
+          "subu     $9, $9, 16\r\n"
+          PTR_ADDU  "$10, $10, 16\r\n"
+
+          "2:       \r\n"
+          "li       $8,  8\r\n"               /* st8 */
+          "bltu     $9, $8, 3f\r\n"
+          "nop      \r\n"
+          "gssdlc1  $f4, 7($10)\r\n"
+          "gssdrc1  $f4, 0($10)\r\n"
+          "mov.s    $f4, $f6\r\n"
+          "subu     $9, $9, 8\r\n"
+          PTR_ADDU  "$10, $10, 8\r\n"
+
+          "3:       \r\n"
+          "li       $8,  4\r\n"               /* st4 */
+          "mfc1     $11, $f4\r\n"
+          "bltu     $9, $8, 4f\r\n"
+          "nop      \r\n"
+          "swl      $11, 3($10)\r\n"
+          "swr      $11, 0($10)\r\n"
+          "li       $8, 32\r\n"
+          "mtc1     $8, $f6\r\n"
+          "dsrl     $f4, $f4, $f6\r\n"
+          "mfc1     $11, $f4\r\n"
+          "subu     $9, $9, 4\r\n"
+          PTR_ADDU  "$10, $10, 4\r\n"
+
+          "4:       \r\n"
+          "li       $8, 2\r\n"                /* st2 */
+          "bltu     $9, $8, 5f\r\n"
+          "nop      \r\n"
+          "ush      $11, 0($10)\r\n"
+          "srl      $11, 16\r\n"
+          "subu     $9, $9, 2\r\n"
+          PTR_ADDU  "$10, $10, 2\r\n"
+
+          "5:       \r\n"
+          "li       $8, 1\r\n"                /* st1 */
+          "bltu     $9, $8, 6f\r\n"
+          "nop      \r\n"
+          "sb       $11, 0($10)\r\n"
+
+          "6:       \r\n"
+          "nop      \r\n"                     /* end */
+          : "=m" (*outptr)
+          : "f" (mmA), "f" (mmB), "f" (mmC), "f" (mmE), "f" (mmF),
+            "f" (mmG), "r" (col), "r" (outptr)
+          : "$f4", "$f6", "$f8", "$8", "$9", "$10", "$11", "memory"
+         );
+    }
+
+#else  /* RGB_PIXELSIZE == 4 */
+
+#ifdef RGBX_FILLER_0XFF
+    xe = _mm_cmpeq_pi8(xe, xe);
+    xo = _mm_cmpeq_pi8(xo, xo);
+#else
+    xe = _mm_xor_si64(xe, xe);
+    xo = _mm_xor_si64(xo, xo);
+#endif
+    /* mmA=(00 02 04 06 08 0A 0C 0E), mmB=(01 03 05 07 09 0B 0D 0F) */
+    /* mmC=(10 12 14 16 18 1A 1C 1E), mmD=(11 13 15 17 19 1B 1D 1F) */
+    /* mmE=(20 22 24 26 28 2A 2C 2E), mmF=(21 23 25 27 29 2B 2D 2F) */
+    /* mmG=(30 32 34 36 38 3A 3C 3E), mmH=(31 33 35 37 39 3B 3D 3F) */
+
+    mm8 = _mm_unpacklo_pi8(mmA, mmC);         /* (00 10 02 12 04 14 06 16) */
+    mm9 = _mm_unpackhi_pi8(mmA, mmC);         /* (08 18 0A 1A 0C 1C 0E 1E) */
+    mmA = _mm_unpacklo_pi8(mmE, mmG);         /* (20 30 22 32 24 34 26 36) */
+    mmE = _mm_unpackhi_pi8(mmE, mmG);         /* (28 38 2A 3A 2C 3C 2E 3E) */
+
+    mmG = _mm_unpacklo_pi8(mmB, mmD);         /* (01 11 03 13 05 15 07 17) */
+    mmB = _mm_unpackhi_pi8(mmB, mmD);         /* (09 19 0B 1B 0D 1D 0F 1F) */
+    mmD = _mm_unpacklo_pi8(mmF, mmH);         /* (21 31 23 33 25 35 27 37) */
+    mmF = _mm_unpackhi_pi8(mmF, mmH);         /* (29 39 2B 3B 2D 3D 2F 3F) */
+
+    mmH = _mm_unpacklo_pi16(mm8, mmA);        /* (00 10 20 30 02 12 22 32) */
+    mm8 = _mm_unpackhi_pi16(mm8, mmA);        /* (04 14 24 34 06 16 26 36) */
+    mmA = _mm_unpacklo_pi16(mmG, mmD);        /* (01 11 21 31 03 13 23 33) */
+    mmD = _mm_unpackhi_pi16(mmG, mmD);        /* (05 15 25 35 07 17 27 37) */
+
+    mmG = _mm_unpackhi_pi16(mm9, mmE);        /* (0C 1C 2C 3C 0E 1E 2E 3E) */
+    mm9 = _mm_unpacklo_pi16(mm9, mmE);        /* (08 18 28 38 0A 1A 2A 3A) */
+    mmE = _mm_unpacklo_pi16(mmB, mmF);        /* (09 19 29 39 0B 1B 2B 3B) */
+    mmF = _mm_unpackhi_pi16(mmB, mmF);        /* (0D 1D 2D 3D 0F 1F 2F 3F) */
+
+    mmB = _mm_unpackhi_pi32(mmH, mmA);        /* (02 12 22 32 03 13 23 33) */
+    mmA = _mm_unpacklo_pi32(mmH, mmA);        /* (00 10 20 30 01 11 21 31) */
+    mmC = _mm_unpacklo_pi32(mm8, mmD);        /* (04 14 24 34 05 15 25 35) */
+    mmD = _mm_unpackhi_pi32(mm8, mmD);        /* (06 16 26 36 07 17 27 37) */
+
+    mmH = _mm_unpackhi_pi32(mmG, mmF);        /* (0E 1E 2E 3E 0F 1F 2F 3F) */
+    mmG = _mm_unpacklo_pi32(mmG, mmF);        /* (0C 1C 2C 3C 0D 1D 2D 3D) */
+    mmF = _mm_unpackhi_pi32(mm9, mmE);        /* (0A 1A 2A 3A 0B 1B 2B 3B) */
+    mmE = _mm_unpacklo_pi32(mm9, mmE);        /* (08 18 28 38 09 19 29 39) */
+
+    if (num_cols >= 8) {
+      if (!(((long)outptr) & 7)) {
+        _mm_store_si64((__m64 *)outptr, mmA);
+        _mm_store_si64((__m64 *)(outptr + 8), mmB);
+        _mm_store_si64((__m64 *)(outptr + 16), mmC);
+        _mm_store_si64((__m64 *)(outptr + 24), mmD);
+        _mm_store_si64((__m64 *)(outptr + 32), mmE);
+        _mm_store_si64((__m64 *)(outptr + 40), mmF);
+        _mm_store_si64((__m64 *)(outptr + 48), mmG);
+        _mm_store_si64((__m64 *)(outptr + 56), mmH);
+      } else {
+        _mm_storeu_si64((__m64 *)outptr, mmA);
+        _mm_storeu_si64((__m64 *)(outptr + 8), mmB);
+        _mm_storeu_si64((__m64 *)(outptr + 16), mmC);
+        _mm_storeu_si64((__m64 *)(outptr + 24), mmD);
+        _mm_storeu_si64((__m64 *)(outptr + 32), mmE);
+        _mm_storeu_si64((__m64 *)(outptr + 40), mmF);
+        _mm_storeu_si64((__m64 *)(outptr + 48), mmG);
+        _mm_storeu_si64((__m64 *)(outptr + 56), mmH);
+      }
+      outptr += RGB_PIXELSIZE * 16;
+    } else {
+      if (output_width & 1)
+        col = num_cols * 2 + 1;
+      else
+        col = num_cols * 2;
+      asm(".set noreorder\r\n"                /* st32 */
+
+          "li       $8, 8\r\n"
+          "move     $9, %10\r\n"
+          "move     $10, %11\r\n"
+          "mov.s    $f4, %2\r\n"
+          "mov.s    $f6, %3\r\n"
+          "mov.s    $f8, %4\r\n"
+          "mov.s    $f10, %5\r\n"
+          "bltu     $9, $8, 1f\r\n"
+          "nop      \r\n"
+          "gssdlc1  $f4, 7($10)\r\n"
+          "gssdrc1  $f4, 0($10)\r\n"
+          "gssdlc1  $f6, 7+8($10)\r\n"
+          "gssdrc1  $f6, 8($10)\r\n"
+          "gssdlc1  $f8, 7+16($10)\r\n"
+          "gssdrc1  $f8, 16($10)\r\n"
+          "gssdlc1  $f10, 7+24($10)\r\n"
+          "gssdrc1  $f10, 24($10)\r\n"
+          "mov.s    $f4, %6\r\n"
+          "mov.s    $f6, %7\r\n"
+          "mov.s    $f8, %8\r\n"
+          "mov.s    $f10, %9\r\n"
+          "subu     $9, $9, 8\r\n"
+          PTR_ADDU  "$10, $10, 32\r\n"
+
+          "1:       \r\n"
+          "li       $8, 4\r\n"                /* st16 */
+          "bltu     $9, $8, 2f\r\n"
+          "nop      \r\n"
+          "gssdlc1  $f4, 7($10)\r\n"
+          "gssdrc1  $f4, 0($10)\r\n"
+          "gssdlc1  $f6, 7+8($10)\r\n"
+          "gssdrc1  $f6, 8($10)\r\n"
+          "mov.s    $f4, $f8\r\n"
+          "mov.s    $f6, $f10\r\n"
+          "subu     $9, $9, 4\r\n"
+          PTR_ADDU  "$10, $10, 16\r\n"
+
+          "2:       \r\n"
+          "li       $8, 2\r\n"                /* st8 */
+          "bltu     $9, $8, 3f\r\n"
+          "nop      \r\n"
+          "gssdlc1  $f4, 7($10)\r\n"
+          "gssdrc1  $f4, 0($10)\r\n"
+          "mov.s    $f4, $f6\r\n"
+          "subu     $9, $9, 2\r\n"
+          PTR_ADDU  "$10, $10, 8\r\n"
+
+          "3:       \r\n"
+          "li       $8, 1\r\n"                /* st4 */
+          "bltu     $9, $8, 4f\r\n"
+          "nop      \r\n"
+          "gsswlc1  $f4, 3($10)\r\n"
+          "gsswrc1  $f4, 0($10)\r\n"
+
+          "4:       \r\n"
+          "li       %1, 0\r\n"                /* end */
+          : "=m" (*outptr), "=r" (col)
+          : "f" (mmA), "f" (mmB), "f" (mmC), "f" (mmD), "f" (mmE), "f" (mmF),
+            "f" (mmG), "f" (mmH), "r" (col), "r" (outptr)
+          : "$f4", "$f6", "$f8", "$f10", "$8", "$9", "$10", "memory"
+         );
+    }
+
+#endif
+
+  }
+
+  if (!((output_width >> 1) & 7)) {
+    if (output_width & 1) {
+      cb = _mm_load_si64((__m64 *)inptr1);
+      cr = _mm_load_si64((__m64 *)inptr2);
+      y = _mm_load_si64((__m64 *)inptr0);
+
+      decenter = 0.0;
+      decenter = _mm_cmpeq_pi16(decenter, decenter);
+      decenter = _mm_slli_pi16(decenter, 7);  /* {0xFF80 0xFF80 0xFF80 0xFF80} */
+
+      cbl = _mm_unpacklo_pi8(cb, zero);       /* Cb(0123) */
+      crl = _mm_unpacklo_pi8(cr, zero);       /* Cr(0123) */
+      cbl = _mm_add_pi16(cbl, decenter);
+      crl = _mm_add_pi16(crl, decenter);
+
+      cbl2 = _mm_add_pi16(cbl, cbl);          /* 2*CbL */
+      crl2 = _mm_add_pi16(crl, crl);          /* 2*CrL */
+      bl = _mm_mulhi_pi16(cbl2, PW_MF0228);   /* (2*CbL * -FIX(0.22800) */
+      rl = _mm_mulhi_pi16(crl2, PW_F0402);    /* (2*CrL * FIX(0.40200)) */
+
+      bl = _mm_add_pi16(bl, PW_ONE);
+      bl = _mm_srai_pi16(bl, 1);              /* (CbL * -FIX(0.22800)) */
+      rl = _mm_add_pi16(rl, PW_ONE);
+      rl = _mm_srai_pi16(rl, 1);              /* (CrL * FIX(0.40200)) */
+
+      bl = _mm_add_pi16(bl, cbl);
+      bl = _mm_add_pi16(bl, cbl);             /* (CbL * FIX(1.77200))=(B-Y)L */
+      rl = _mm_add_pi16(rl, crl);             /* (CrL * FIX(1.40200))=(R-Y)L */
+
+      gl = _mm_unpacklo_pi16(cbl, crl);
+      gl = _mm_madd_pi16(gl, PW_MF0344_F0285);
+      gl = _mm_add_pi32(gl, PD_ONEHALF);
+      gl = _mm_srai_pi32(gl, SCALEBITS);
+      gl = _mm_packs_pi32(gl, zero);       /* CbL*-FIX(0.344)+CrL*FIX(0.285) */
+      gl = _mm_sub_pi16(gl, crl);  /* CbL*-FIX(0.344)+CrL*-FIX(0.714)=(G-Y)L */
+
+      yl = _mm_unpacklo_pi8(y, zero);         /* Y(0123) */
+      rl = _mm_add_pi16(rl, yl);              /* (R0 R1 R2 R3) */
+      gl = _mm_add_pi16(gl, yl);              /* (G0 G1 G2 G3) */
+      bl = _mm_add_pi16(bl, yl);              /* (B0 B1 B2 B3) */
+      re = _mm_packs_pu16(rl, rl);
+      ge = _mm_packs_pu16(gl, gl);
+      be = _mm_packs_pu16(bl, bl);
+#if RGB_PIXELSIZE == 3
+      mmA = _mm_unpacklo_pi8(mmA, mmC);
+      mmA = _mm_unpacklo_pi16(mmA, mmE);
+      asm(".set noreorder\r\n"
+
+          "move    $8, %2\r\n"
+          "mov.s   $f4, %1\r\n"
+          "mfc1    $9, $f4\r\n"
+          "ush     $9, 0($8)\r\n"
+          "srl     $9, 16\r\n"
+          "sb      $9, 2($8)\r\n"
+          : "=m" (*outptr)
+          : "f" (mmA), "r" (outptr)
+          : "$f4", "$8", "$9", "memory"
+         );
+#else  /* RGB_PIXELSIZE == 4 */
+
+#ifdef RGBX_FILLER_0XFF
+      xe = _mm_cmpeq_pi8(xe, xe);
+#else
+      xe = _mm_xor_si64(xe, xe);
+#endif
+      mmA = _mm_unpacklo_pi8(mmA, mmC);
+      mmE = _mm_unpacklo_pi8(mmE, mmG);
+      mmA = _mm_unpacklo_pi16(mmA, mmE);
+      asm(".set noreorder\r\n"
+
+          "move    $8, %2\r\n"
+          "mov.s   $f4, %1\r\n"
+          "gsswlc1 $f4, 3($8)\r\n"
+          "gsswrc1 $f4, 0($8)\r\n"
+          : "=m" (*outptr)
+          : "f" (mmA), "r" (outptr)
+          : "$f4", "$8", "memory"
+         );
+#endif
+    }
+  }
+}
+
+
+void jsimd_h2v2_merged_upsample_mmi(JDIMENSION output_width,
+                                    JSAMPIMAGE input_buf,
+                                    JDIMENSION in_row_group_ctr,
+                                    JSAMPARRAY output_buf)
+{
+  JSAMPROW inptr, outptr;
+
+  inptr = input_buf[0][in_row_group_ctr];
+  outptr = output_buf[0];
+
+  input_buf[0][in_row_group_ctr] = input_buf[0][in_row_group_ctr * 2];
+  jsimd_h2v1_merged_upsample_mmi(output_width, input_buf, in_row_group_ctr,
+                                 output_buf);
+
+  input_buf[0][in_row_group_ctr] = input_buf[0][in_row_group_ctr * 2 + 1];
+  output_buf[0] = output_buf[1];
+  jsimd_h2v1_merged_upsample_mmi(output_width, input_buf, in_row_group_ctr,
+                                 output_buf);
+
+  input_buf[0][in_row_group_ctr] = inptr;
+  output_buf[0] = outptr;
+}
+
+
+#undef mmA
+#undef mmB
+#undef mmC
+#undef mmD
+#undef mmE
+#undef mmF
+#undef mmG
+#undef mmH
diff --git a/3rdparty/libjpeg/src/simd/mips64/jdsample-mmi.c b/3rdparty/libjpeg/src/simd/mips64/jdsample-mmi.c
new file mode 100644
index 00000000..8ae94e7d
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/mips64/jdsample-mmi.c
@@ -0,0 +1,304 @@
+/*
+ * Loongson MMI optimizations for libjpeg-turbo
+ *
+ * Copyright (C) 2015, 2018-2019, D. R. Commander.  All Rights Reserved.
+ * Copyright (C) 2016-2018, Loongson Technology Corporation Limited, BeiJing.
+ *                          All Rights Reserved.
+ * Authors:  ZhuChen     <zhuchen@loongson.cn>
+ *           CaiWanwei   <caiwanwei@loongson.cn>
+ *           SunZhangzhi <sunzhangzhi-cq@loongson.cn>
+ *           ZhangLixia  <zhanglixia-hf@loongson.cn>
+ *
+ * Based on the x86 SIMD extension for IJG JPEG library
+ * Copyright (C) 1999-2006, MIYASAKA Masaru.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+/* CHROMA UPSAMPLING */
+
+#include "jsimd_mmi.h"
+
+
+enum const_index {
+  index_PW_ONE,
+  index_PW_TWO,
+  index_PW_THREE,
+  index_PW_SEVEN,
+  index_PW_EIGHT,
+};
+
+static uint64_t const_value[] = {
+  _uint64_set_pi16(1, 1, 1, 1),
+  _uint64_set_pi16(2, 2, 2, 2),
+  _uint64_set_pi16(3, 3, 3, 3),
+  _uint64_set_pi16(7, 7, 7, 7),
+  _uint64_set_pi16(8, 8, 8, 8),
+};
+
+#define PW_ONE    get_const_value(index_PW_ONE)
+#define PW_TWO    get_const_value(index_PW_TWO)
+#define PW_THREE  get_const_value(index_PW_THREE)
+#define PW_SEVEN  get_const_value(index_PW_SEVEN)
+#define PW_EIGHT  get_const_value(index_PW_EIGHT)
+
+
+#define PROCESS_ROW(row, wkoffset, bias1, bias2, shift) { \
+  __m64 samp123X, samp3XXX, samp1234, sampX012, samp_1012; \
+  __m64 sampXXX4, sampX456, samp3456, samp567X, samp7XXX, samp5678; \
+  __m64 outle, outhe, outlo, outho, outl, outh; \
+  \
+  samp123X = _mm_srli_si64(samp0123, 2 * BYTE_BIT);  /* ( 1 2 3 -) */ \
+  sampXXX4 = _mm_slli_si64(samp4567, (SIZEOF_MMWORD - 2) * BYTE_BIT);  /* ( - - - 4) */ \
+  samp3XXX = _mm_srli_si64(samp0123, (SIZEOF_MMWORD - 2) * BYTE_BIT);  /* ( 3 - - -) */ \
+  sampX456 = _mm_slli_si64(samp4567, 2 * BYTE_BIT);  /* ( - 4 5 6) */ \
+  \
+  samp1234 = _mm_or_si64(samp123X, sampXXX4);  /* ( 1 2 3 4) */ \
+  samp3456 = _mm_or_si64(samp3XXX, sampX456);  /* ( 3 4 5 6) */ \
+  \
+  sampX012 = _mm_slli_si64(samp0123, 2 * BYTE_BIT);  /* ( - 0 1 2) */ \
+  samp567X = _mm_srli_si64(samp4567, 2 * BYTE_BIT);  /* ( 5 6 7 -) */ \
+  samp7XXX = _mm_srli_si64(samp4567, (SIZEOF_MMWORD - 2) * BYTE_BIT);  /* ( 7 - - -) */ \
+  \
+  samp_1012 = _mm_or_si64(sampX012, wk[row]);            /* (-1 0 1 2) */ \
+  samp5678 = _mm_or_si64(samp567X, wk[row + wkoffset]);  /* ( 5 6 7 8) */ \
+  \
+  wk[row] = samp7XXX; \
+  \
+  samp0123 = _mm_mullo_pi16(samp0123, PW_THREE); \
+  samp4567 = _mm_mullo_pi16(samp4567, PW_THREE); \
+  samp_1012 = _mm_add_pi16(samp_1012, bias1); \
+  samp3456 = _mm_add_pi16(samp3456, bias1); \
+  samp1234 = _mm_add_pi16(samp1234, bias2); \
+  samp5678 = _mm_add_pi16(samp5678, bias2); \
+  \
+  outle = _mm_add_pi16(samp_1012, samp0123); \
+  outhe = _mm_add_pi16(samp3456, samp4567); \
+  outle = _mm_srli_pi16(outle, shift);        /* ( 0  2  4  6) */ \
+  outhe = _mm_srli_pi16(outhe, shift);        /* ( 8 10 12 14) */ \
+  outlo = _mm_add_pi16(samp1234, samp0123); \
+  outho = _mm_add_pi16(samp5678, samp4567); \
+  outlo = _mm_srli_pi16(outlo, shift);        /* ( 1  3  5  7) */ \
+  outho = _mm_srli_pi16(outho, shift);        /* ( 9 11 13 15) */ \
+  \
+  outlo = _mm_slli_pi16(outlo, BYTE_BIT); \
+  outho = _mm_slli_pi16(outho, BYTE_BIT); \
+  outl = _mm_or_si64(outle, outlo);           /* ( 0  1  2  3  4  5  6  7) */ \
+  outh = _mm_or_si64(outhe, outho);           /* ( 8  9 10 11 12 13 14 15) */ \
+  \
+  _mm_store_si64((__m64 *)outptr##row, outl); \
+  _mm_store_si64((__m64 *)outptr##row + 1, outh); \
+}
+
+void jsimd_h2v2_fancy_upsample_mmi(int max_v_samp_factor,
+                                   JDIMENSION downsampled_width,
+                                   JSAMPARRAY input_data,
+                                   JSAMPARRAY *output_data_ptr)
+{
+  JSAMPARRAY output_data = *output_data_ptr;
+  JSAMPROW inptr_1, inptr0, inptr1, outptr0, outptr1;
+  int inrow, outrow, incol, tmp, tmp1;
+  __m64 this_1l, this_1h, this_1, thiscolsum_1l, thiscolsum_1h;
+  __m64 this0l, this0h, this0;
+  __m64 this1l, this1h, this1, thiscolsum1l, thiscolsum1h;
+  __m64 next_1l, next_1h, next_1, nextcolsum_1l, nextcolsum_1h;
+  __m64 next0l, next0h, next0;
+  __m64 next1l, next1h, next1, nextcolsum1l, nextcolsum1h;
+  __m64 mask0 = 0.0, masklast, samp0123, samp4567, wk[4], zero = 0.0;
+
+  mask0 = _mm_cmpeq_pi8(mask0, mask0);
+  masklast = _mm_slli_si64(mask0, (SIZEOF_MMWORD - 2) * BYTE_BIT);
+  mask0 = _mm_srli_si64(mask0, (SIZEOF_MMWORD - 2) * BYTE_BIT);
+
+  for (inrow = 0, outrow = 0; outrow < max_v_samp_factor; inrow++) {
+
+    inptr_1 = input_data[inrow - 1];
+    inptr0 = input_data[inrow];
+    inptr1 = input_data[inrow + 1];
+    outptr0 = output_data[outrow++];
+    outptr1 = output_data[outrow++];
+
+    if (downsampled_width & 7) {
+      tmp = (downsampled_width - 1) * sizeof(JSAMPLE);
+      tmp1 = downsampled_width * sizeof(JSAMPLE);
+      asm(PTR_ADDU  "$8, %3, %6\r\n"
+          "lb       $9, ($8)\r\n"
+          PTR_ADDU  "$8, %3, %7\r\n"
+          "sb       $9, ($8)\r\n"
+          PTR_ADDU  "$8, %4, %6\r\n"
+          "lb       $9, ($8)\r\n"
+          PTR_ADDU  "$8, %4, %7\r\n"
+          "sb       $9, ($8)\r\n"
+          PTR_ADDU  "$8, %5, %6\r\n"
+          "lb       $9, ($8)\r\n"
+          PTR_ADDU  "$8, %5, %7\r\n"
+          "sb       $9, ($8)\r\n"
+          : "=m" (*inptr_1), "=m" (*inptr0), "=m" (*inptr1)
+          : "r" (inptr_1), "r" (inptr0), "r" (inptr1), "r" (tmp), "r" (tmp1)
+          : "$8", "$9"
+         );
+    }
+
+    /* process the first column block */
+    this0 = _mm_load_si64((__m64 *)inptr0);    /* row[ 0][0] */
+    this_1 = _mm_load_si64((__m64 *)inptr_1);  /* row[-1][0] */
+    this1 = _mm_load_si64((__m64 *)inptr1);    /* row[ 1][0] */
+
+    this0l = _mm_unpacklo_pi8(this0, zero);    /* row[ 0][0]( 0 1 2 3) */
+    this0h = _mm_unpackhi_pi8(this0, zero);    /* row[ 0][0]( 4 5 6 7) */
+    this_1l = _mm_unpacklo_pi8(this_1, zero);  /* row[-1][0]( 0 1 2 3) */
+    this_1h = _mm_unpackhi_pi8(this_1, zero);  /* row[-1][0]( 4 5 6 7) */
+    this1l = _mm_unpacklo_pi8(this1, zero);    /* row[+1][0]( 0 1 2 3) */
+    this1h = _mm_unpackhi_pi8(this1, zero);    /* row[+1][0]( 4 5 6 7) */
+
+    this0l = _mm_mullo_pi16(this0l, PW_THREE);
+    this0h = _mm_mullo_pi16(this0h, PW_THREE);
+
+    thiscolsum_1l = _mm_add_pi16(this_1l, this0l);  /* ( 0 1 2 3) */
+    thiscolsum_1h = _mm_add_pi16(this_1h, this0h);  /* ( 4 5 6 7) */
+    thiscolsum1l = _mm_add_pi16(this0l, this1l);    /* ( 0 1 2 3) */
+    thiscolsum1h = _mm_add_pi16(this0h, this1h);    /* ( 4 5 6 7) */
+
+    /* temporarily save the intermediate data */
+    _mm_store_si64((__m64 *)outptr0, thiscolsum_1l);
+    _mm_store_si64((__m64 *)outptr0 + 1, thiscolsum_1h);
+    _mm_store_si64((__m64 *)outptr1, thiscolsum1l);
+    _mm_store_si64((__m64 *)outptr1 + 1, thiscolsum1h);
+
+    wk[0] = _mm_and_si64(thiscolsum_1l, mask0);  /* ( 0 - - -) */
+    wk[1] = _mm_and_si64(thiscolsum1l, mask0);   /* ( 0 - - -) */
+
+    for (incol = downsampled_width; incol > 0;
+         incol -= 8, inptr_1 += 8, inptr0 += 8, inptr1 += 8,
+         outptr0 += 16, outptr1 += 16) {
+
+      if (incol > 8) {
+        /* process the next column block */
+        next0 = _mm_load_si64((__m64 *)inptr0 + 1);    /* row[ 0][1] */
+        next_1 = _mm_load_si64((__m64 *)inptr_1 + 1);  /* row[-1][1] */
+        next1 = _mm_load_si64((__m64 *)inptr1 + 1);    /* row[+1][1] */
+
+        next0l = _mm_unpacklo_pi8(next0, zero);    /* row[ 0][1]( 0 1 2 3) */
+        next0h = _mm_unpackhi_pi8(next0, zero);    /* row[ 0][1]( 4 5 6 7) */
+        next_1l = _mm_unpacklo_pi8(next_1, zero);  /* row[-1][1]( 0 1 2 3) */
+        next_1h = _mm_unpackhi_pi8(next_1, zero);  /* row[-1][1]( 4 5 6 7) */
+        next1l = _mm_unpacklo_pi8(next1, zero);    /* row[+1][1]( 0 1 2 3) */
+        next1h = _mm_unpackhi_pi8(next1, zero);    /* row[+1][1]( 4 5 6 7) */
+
+        next0l = _mm_mullo_pi16(next0l, PW_THREE);
+        next0h = _mm_mullo_pi16(next0h, PW_THREE);
+
+        nextcolsum_1l = _mm_add_pi16(next_1l, next0l);  /* ( 0 1 2 3) */
+        nextcolsum_1h = _mm_add_pi16(next_1h, next0h);  /* ( 4 5 6 7) */
+        nextcolsum1l = _mm_add_pi16(next0l, next1l);    /* ( 0 1 2 3) */
+        nextcolsum1h = _mm_add_pi16(next0h, next1h);    /* ( 4 5 6 7) */
+
+        /* temporarily save the intermediate data */
+        _mm_store_si64((__m64 *)outptr0 + 2, nextcolsum_1l);
+        _mm_store_si64((__m64 *)outptr0 + 3, nextcolsum_1h);
+        _mm_store_si64((__m64 *)outptr1 + 2, nextcolsum1l);
+        _mm_store_si64((__m64 *)outptr1 + 3, nextcolsum1h);
+
+        wk[2] = _mm_slli_si64(nextcolsum_1l, (SIZEOF_MMWORD - 2) * BYTE_BIT);  /* ( - - - 0) */
+        wk[3] = _mm_slli_si64(nextcolsum1l, (SIZEOF_MMWORD - 2) * BYTE_BIT);   /* ( - - - 0) */
+      } else {
+        __m64 tmp;
+
+        /* process the last column block */
+        tmp = _mm_load_si64((__m64 *)outptr0 + 1);
+        wk[2] = _mm_and_si64(masklast, tmp);        /* ( - - - 7) */
+        tmp = _mm_load_si64((__m64 *)outptr1 + 1);
+        wk[3] = _mm_and_si64(masklast, tmp);        /* ( - - - 7) */
+      }
+
+      /* process the upper row */
+      samp0123 = _mm_load_si64((__m64 *)outptr0);      /* ( 0 1 2 3) */ \
+      samp4567 = _mm_load_si64((__m64 *)outptr0 + 1);  /* ( 4 5 6 7) */ \
+      PROCESS_ROW(0, 2, PW_EIGHT, PW_SEVEN, 4)
+
+      /* process the lower row */
+      samp0123 = _mm_load_si64((__m64 *)outptr1);      /* ( 0 1 2 3) */ \
+      samp4567 = _mm_load_si64((__m64 *)outptr1 + 1);  /* ( 4 5 6 7) */ \
+      PROCESS_ROW(1, 2, PW_EIGHT, PW_SEVEN, 4)
+    }
+  }
+}
+
+
+void jsimd_h2v1_fancy_upsample_mmi(int max_v_samp_factor,
+                                   JDIMENSION downsampled_width,
+                                   JSAMPARRAY input_data,
+                                   JSAMPARRAY *output_data_ptr)
+{
+  JSAMPARRAY output_data = *output_data_ptr;
+  JSAMPROW inptr0, outptr0;
+  int inrow, incol, tmp, tmp1;
+  __m64 thisl, this, nextl, next;
+  __m64 mask0 = 0.0, masklast, samp0123, samp4567, wk[2], zero = 0.0;
+
+  mask0 = _mm_cmpeq_pi8(mask0, mask0);
+  masklast = _mm_slli_si64(mask0, (SIZEOF_MMWORD - 2) * BYTE_BIT);
+  mask0 = _mm_srli_si64(mask0, (SIZEOF_MMWORD - 2) * BYTE_BIT);
+
+  for (inrow = 0; inrow < max_v_samp_factor; inrow++) {
+
+    inptr0 = input_data[inrow];
+    outptr0 = output_data[inrow];
+
+    if (downsampled_width & 7) {
+      tmp = (downsampled_width - 1) * sizeof(JSAMPLE);
+      tmp1 = downsampled_width * sizeof(JSAMPLE);
+      asm(PTR_ADDU  "$8, %1, %2\r\n"
+          "lb       $9, ($8)\r\n"
+          PTR_ADDU  "$8, %1, %3\r\n"
+          "sb       $9, ($8)\r\n"
+          : "=m" (*inptr0)
+          : "r" (inptr0), "r" (tmp), "r" (tmp1)
+          : "$8", "$9"
+         );
+    }
+
+    /* process the first column block */
+    this = _mm_load_si64((__m64 *)inptr0);    /* row[ 0][0] */
+    thisl = _mm_unpacklo_pi8(this, zero);     /* row[ 0][0]( 0 1 2 3) */
+    wk[0] = _mm_and_si64(thisl, mask0);       /* ( 0 - - -) */
+
+    for (incol = downsampled_width; incol > 0;
+         incol -= 8, inptr0 += 8, outptr0 += 16) {
+
+      if (incol > 8) {
+        /* process the next column block */
+        next = _mm_load_si64((__m64 *)inptr0 + 1);  /* row[ 0][1] */
+        nextl = _mm_unpacklo_pi8(next, zero);       /* row[ 0][1]( 0 1 2 3) */
+        wk[1] = _mm_slli_si64(nextl, (SIZEOF_MMWORD - 2) * BYTE_BIT);  /* ( - - - 0) */
+      } else {
+        __m64 thish;
+
+        /* process the last column block */
+        this = _mm_load_si64((__m64 *)inptr0);  /* row[ 0][0] */
+        thish = _mm_unpackhi_pi8(this, zero);   /* row[ 0][1]( 4 5 6 7) */
+        wk[1] = _mm_and_si64(masklast, thish);  /* ( - - - 7) */
+      }
+
+      /* process the row */
+      this = _mm_load_si64((__m64 *)inptr0);    /* row[ 0][0] */
+      samp0123 = _mm_unpacklo_pi8(this, zero);  /* ( 0 1 2 3) */
+      samp4567 = _mm_unpackhi_pi8(this, zero);  /* ( 4 5 6 7) */
+      PROCESS_ROW(0, 1, PW_ONE, PW_TWO, 2)
+    }
+  }
+}
diff --git a/3rdparty/libjpeg/src/simd/mips64/jfdctfst-mmi.c b/3rdparty/libjpeg/src/simd/mips64/jfdctfst-mmi.c
new file mode 100644
index 00000000..f7caf09a
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/mips64/jfdctfst-mmi.c
@@ -0,0 +1,255 @@
+/*
+ * Loongson MMI optimizations for libjpeg-turbo
+ *
+ * Copyright (C) 2014, 2018-2019, D. R. Commander.  All Rights Reserved.
+ * Copyright (C) 2016-2018, Loongson Technology Corporation Limited, BeiJing.
+ *                          All Rights Reserved.
+ * Authors:  LiuQingfa <liuqingfa-hf@loongson.cn>
+ *
+ * Based on the x86 SIMD extension for IJG JPEG library
+ * Copyright (C) 1999-2006, MIYASAKA Masaru.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+/* FAST INTEGER FORWARD DCT */
+
+#include "jsimd_mmi.h"
+
+
+#define CONST_BITS  8
+
+#define F_0_382  ((short)98)   /* FIX(0.382683433) */
+#define F_0_541  ((short)139)  /* FIX(0.541196100) */
+#define F_0_707  ((short)181)  /* FIX(0.707106781) */
+#define F_1_306  ((short)334)  /* FIX(1.306562965) */
+
+#define PRE_MULTIPLY_SCALE_BITS  2
+#define CONST_SHIFT  (16 - PRE_MULTIPLY_SCALE_BITS - CONST_BITS)
+
+enum const_index {
+  index_PW_F0707,
+  index_PW_F0382,
+  index_PW_F0541,
+  index_PW_F1306
+};
+
+static uint64_t const_value[] = {
+  _uint64_set1_pi16(F_0_707),
+  _uint64_set1_pi16(F_0_382),
+  _uint64_set1_pi16(F_0_541),
+  _uint64_set1_pi16(F_1_306)
+};
+
+#define PW_F0707  get_const_value(index_PW_F0707)
+#define PW_F0382  get_const_value(index_PW_F0382)
+#define PW_F0541  get_const_value(index_PW_F0541)
+#define PW_F1306  get_const_value(index_PW_F1306)
+
+
+#define DO_FDCT_MULTIPLY(out, in, multiplier) { \
+  __m64 mulhi, mullo, mul12, mul34; \
+  \
+  mullo = _mm_mullo_pi16(in, multiplier); \
+  mulhi = _mm_mulhi_pi16(in, multiplier); \
+  mul12 = _mm_unpacklo_pi16(mullo, mulhi); \
+  mul34 = _mm_unpackhi_pi16(mullo, mulhi); \
+  mul12 = _mm_srai_pi32(mul12, CONST_BITS); \
+  mul34 = _mm_srai_pi32(mul34, CONST_BITS); \
+  out = _mm_packs_pi32(mul12, mul34); \
+}
+
+#define DO_FDCT_COMMON() { \
+  \
+  /* Even part */ \
+  \
+  tmp10 = _mm_add_pi16(tmp0, tmp3); \
+  tmp13 = _mm_sub_pi16(tmp0, tmp3); \
+  tmp11 = _mm_add_pi16(tmp1, tmp2); \
+  tmp12 = _mm_sub_pi16(tmp1, tmp2); \
+  \
+  out0 = _mm_add_pi16(tmp10, tmp11); \
+  out4 = _mm_sub_pi16(tmp10, tmp11); \
+  \
+  z1 = _mm_add_pi16(tmp12, tmp13); \
+  DO_FDCT_MULTIPLY(z1, z1, PW_F0707) \
+  \
+  out2 = _mm_add_pi16(tmp13, z1); \
+  out6 = _mm_sub_pi16(tmp13, z1); \
+  \
+  /* Odd part */ \
+  \
+  tmp10 = _mm_add_pi16(tmp4, tmp5); \
+  tmp11 = _mm_add_pi16(tmp5, tmp6); \
+  tmp12 = _mm_add_pi16(tmp6, tmp7); \
+  \
+  z5 = _mm_sub_pi16(tmp10, tmp12); \
+  DO_FDCT_MULTIPLY(z5, z5, PW_F0382) \
+  \
+  DO_FDCT_MULTIPLY(z2, tmp10, PW_F0541) \
+  z2 = _mm_add_pi16(z2, z5); \
+  \
+  DO_FDCT_MULTIPLY(z4, tmp12, PW_F1306) \
+  z4 = _mm_add_pi16(z4, z5); \
+  \
+  DO_FDCT_MULTIPLY(z3, tmp11, PW_F0707) \
+  \
+  z11 = _mm_add_pi16(tmp7, z3); \
+  z13 = _mm_sub_pi16(tmp7, z3); \
+  \
+  out5 = _mm_add_pi16(z13, z2); \
+  out3 = _mm_sub_pi16(z13, z2); \
+  out1 = _mm_add_pi16(z11, z4); \
+  out7 = _mm_sub_pi16(z11, z4); \
+}
+
+#define DO_FDCT_PASS1() { \
+  __m64 row0l, row0h, row1l, row1h, row2l, row2h, row3l, row3h; \
+  __m64 row01a, row01b, row01c, row01d, row23a, row23b, row23c, row23d; \
+  __m64 col0, col1, col2, col3, col4, col5, col6, col7; \
+  \
+  row0l = _mm_load_si64((__m64 *)&dataptr[DCTSIZE * 0]);     /* (00 01 02 03) */ \
+  row0h = _mm_load_si64((__m64 *)&dataptr[DCTSIZE * 0 + 4]); /* (04 05 06 07) */ \
+  row1l = _mm_load_si64((__m64 *)&dataptr[DCTSIZE * 1]);     /* (10 11 12 13) */ \
+  row1h = _mm_load_si64((__m64 *)&dataptr[DCTSIZE * 1 + 4]); /* (14 15 16 17) */ \
+  row2l = _mm_load_si64((__m64 *)&dataptr[DCTSIZE * 2]);     /* (20 21 22 23) */ \
+  row2h = _mm_load_si64((__m64 *)&dataptr[DCTSIZE * 2 + 4]); /* (24 25 26 27) */ \
+  row3l = _mm_load_si64((__m64 *)&dataptr[DCTSIZE * 3]);     /* (30 31 32 33) */ \
+  row3h = _mm_load_si64((__m64 *)&dataptr[DCTSIZE * 3 + 4]); /* (34 35 36 37) */ \
+  \
+  /* Transpose coefficients */ \
+  \
+  row23a = _mm_unpacklo_pi16(row2l, row3l);   /* row23a=(20 30 21 31) */ \
+  row23b = _mm_unpackhi_pi16(row2l, row3l);   /* row23b=(22 32 23 33) */ \
+  row23c = _mm_unpacklo_pi16(row2h, row3h);   /* row23c=(24 34 25 35) */ \
+  row23d = _mm_unpackhi_pi16(row2h, row3h);   /* row23d=(26 36 27 37) */ \
+  \
+  row01a = _mm_unpacklo_pi16(row0l, row1l);   /* row01a=(00 10 01 11) */ \
+  row01b = _mm_unpackhi_pi16(row0l, row1l);   /* row01b=(02 12 03 13) */ \
+  row01c = _mm_unpacklo_pi16(row0h, row1h);   /* row01c=(04 14 05 15) */ \
+  row01d = _mm_unpackhi_pi16(row0h, row1h);   /* row01d=(06 16 07 17) */ \
+  \
+  col0 = _mm_unpacklo_pi32(row01a, row23a);   /* col0=(00 10 20 30) */ \
+  col1 = _mm_unpackhi_pi32(row01a, row23a);   /* col1=(01 11 21 31) */ \
+  col6 = _mm_unpacklo_pi32(row01d, row23d);   /* col6=(06 16 26 36) */ \
+  col7 = _mm_unpackhi_pi32(row01d, row23d);   /* col7=(07 17 27 37) */ \
+  \
+  tmp6 = _mm_sub_pi16(col1, col6);            /* tmp6=col1-col6 */ \
+  tmp7 = _mm_sub_pi16(col0, col7);            /* tmp7=col0-col7 */ \
+  tmp1 = _mm_add_pi16(col1, col6);            /* tmp1=col1+col6 */ \
+  tmp0 = _mm_add_pi16(col0, col7);            /* tmp0=col0+col7 */ \
+  \
+  col2 = _mm_unpacklo_pi32(row01b, row23b);   /* col2=(02 12 22 32) */ \
+  col3 = _mm_unpackhi_pi32(row01b, row23b);   /* col3=(03 13 23 33) */ \
+  col4 = _mm_unpacklo_pi32(row01c, row23c);   /* col4=(04 14 24 34) */ \
+  col5 = _mm_unpackhi_pi32(row01c, row23c);   /* col5=(05 15 25 35) */ \
+  \
+  tmp3 = _mm_add_pi16(col3, col4);            /* tmp3=col3+col4 */ \
+  tmp2 = _mm_add_pi16(col2, col5);            /* tmp2=col2+col5 */ \
+  tmp4 = _mm_sub_pi16(col3, col4);            /* tmp4=col3-col4 */ \
+  tmp5 = _mm_sub_pi16(col2, col5);            /* tmp5=col2-col5 */ \
+  \
+  DO_FDCT_COMMON() \
+  \
+  _mm_store_si64((__m64 *)&dataptr[DCTSIZE * 0], out0); \
+  _mm_store_si64((__m64 *)&dataptr[DCTSIZE * 0 + 4], out4); \
+  _mm_store_si64((__m64 *)&dataptr[DCTSIZE * 1], out1); \
+  _mm_store_si64((__m64 *)&dataptr[DCTSIZE * 1 + 4], out5); \
+  _mm_store_si64((__m64 *)&dataptr[DCTSIZE * 2], out2); \
+  _mm_store_si64((__m64 *)&dataptr[DCTSIZE * 2 + 4], out6); \
+  _mm_store_si64((__m64 *)&dataptr[DCTSIZE * 3], out3); \
+  _mm_store_si64((__m64 *)&dataptr[DCTSIZE * 3 + 4], out7); \
+}
+
+#define DO_FDCT_PASS2() { \
+  __m64 col0l, col0h, col1l, col1h, col2l, col2h, col3l, col3h; \
+  __m64 col01a, col01b, col01c, col01d, col23a, col23b, col23c, col23d; \
+  __m64 row0, row1, row2, row3, row4, row5, row6, row7; \
+  \
+  col0l = _mm_load_si64((__m64 *)&dataptr[DCTSIZE * 0]);  /* (00 10 20 30) */ \
+  col1l = _mm_load_si64((__m64 *)&dataptr[DCTSIZE * 1]);  /* (01 11 21 31) */ \
+  col2l = _mm_load_si64((__m64 *)&dataptr[DCTSIZE * 2]);  /* (02 12 22 32) */ \
+  col3l = _mm_load_si64((__m64 *)&dataptr[DCTSIZE * 3]);  /* (03 13 23 33) */ \
+  col0h = _mm_load_si64((__m64 *)&dataptr[DCTSIZE * 4]);  /* (40 50 60 70) */ \
+  col1h = _mm_load_si64((__m64 *)&dataptr[DCTSIZE * 5]);  /* (41 51 61 71) */ \
+  col2h = _mm_load_si64((__m64 *)&dataptr[DCTSIZE * 6]);  /* (42 52 62 72) */ \
+  col3h = _mm_load_si64((__m64 *)&dataptr[DCTSIZE * 7]);  /* (43 53 63 73) */ \
+  \
+  /* Transpose coefficients */ \
+  \
+  col23a = _mm_unpacklo_pi16(col2l, col3l);   /* col23a=(02 03 12 13) */ \
+  col23b = _mm_unpackhi_pi16(col2l, col3l);   /* col23b=(22 23 32 33) */ \
+  col23c = _mm_unpacklo_pi16(col2h, col3h);   /* col23c=(42 43 52 53) */ \
+  col23d = _mm_unpackhi_pi16(col2h, col3h);   /* col23d=(62 63 72 73) */ \
+  \
+  col01a = _mm_unpacklo_pi16(col0l, col1l);   /* col01a=(00 01 10 11) */ \
+  col01b = _mm_unpackhi_pi16(col0l, col1l);   /* col01b=(20 21 30 31) */ \
+  col01c = _mm_unpacklo_pi16(col0h, col1h);   /* col01c=(40 41 50 51) */ \
+  col01d = _mm_unpackhi_pi16(col0h, col1h);   /* col01d=(60 61 70 71) */ \
+  \
+  row0 = _mm_unpacklo_pi32(col01a, col23a);   /* row0=(00 01 02 03) */ \
+  row1 = _mm_unpackhi_pi32(col01a, col23a);   /* row1=(10 11 12 13) */ \
+  row6 = _mm_unpacklo_pi32(col01d, col23d);   /* row6=(60 61 62 63) */ \
+  row7 = _mm_unpackhi_pi32(col01d, col23d);   /* row7=(70 71 72 73) */ \
+  \
+  tmp6 = _mm_sub_pi16(row1, row6);            /* tmp6=row1-row6 */ \
+  tmp7 = _mm_sub_pi16(row0, row7);            /* tmp7=row0-row7 */ \
+  tmp1 = _mm_add_pi16(row1, row6);            /* tmp1=row1+row6 */ \
+  tmp0 = _mm_add_pi16(row0, row7);            /* tmp0=row0+row7 */ \
+  \
+  row2 = _mm_unpacklo_pi32(col01b, col23b);   /* row2=(20 21 22 23) */ \
+  row3 = _mm_unpackhi_pi32(col01b, col23b);   /* row3=(30 31 32 33) */ \
+  row4 = _mm_unpacklo_pi32(col01c, col23c);   /* row4=(40 41 42 43) */ \
+  row5 = _mm_unpackhi_pi32(col01c, col23c);   /* row5=(50 51 52 53) */ \
+  \
+  tmp3 = _mm_add_pi16(row3, row4);            /* tmp3=row3+row4 */ \
+  tmp2 = _mm_add_pi16(row2, row5);            /* tmp2=row2+row5 */ \
+  tmp4 = _mm_sub_pi16(row3, row4);            /* tmp4=row3-row4 */ \
+  tmp5 = _mm_sub_pi16(row2, row5);            /* tmp5=row2-row5 */ \
+  \
+  DO_FDCT_COMMON() \
+  \
+  _mm_store_si64((__m64 *)&dataptr[DCTSIZE * 0], out0); \
+  _mm_store_si64((__m64 *)&dataptr[DCTSIZE * 1], out1); \
+  _mm_store_si64((__m64 *)&dataptr[DCTSIZE * 2], out2); \
+  _mm_store_si64((__m64 *)&dataptr[DCTSIZE * 3], out3); \
+  _mm_store_si64((__m64 *)&dataptr[DCTSIZE * 4], out4); \
+  _mm_store_si64((__m64 *)&dataptr[DCTSIZE * 5], out5); \
+  _mm_store_si64((__m64 *)&dataptr[DCTSIZE * 6], out6); \
+  _mm_store_si64((__m64 *)&dataptr[DCTSIZE * 7], out7); \
+}
+
+void jsimd_fdct_ifast_mmi(DCTELEM *data)
+{
+  __m64 tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
+  __m64 out0, out1, out2, out3, out4, out5, out6, out7;
+  __m64 tmp10, tmp11, tmp12, tmp13, z1, z2, z3, z4, z5, z11, z13;
+  DCTELEM *dataptr = data;
+
+  /* Pass 1: process rows. */
+
+  DO_FDCT_PASS1()
+  dataptr += DCTSIZE * 4;
+  DO_FDCT_PASS1()
+
+  /* Pass 2: process columns. */
+
+  dataptr = data;
+  DO_FDCT_PASS2()
+  dataptr += 4;
+  DO_FDCT_PASS2()
+}
diff --git a/3rdparty/libjpeg/src/simd/mips64/jfdctint-mmi.c b/3rdparty/libjpeg/src/simd/mips64/jfdctint-mmi.c
new file mode 100644
index 00000000..7f4dfe91
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/mips64/jfdctint-mmi.c
@@ -0,0 +1,398 @@
+/*
+ * Loongson MMI optimizations for libjpeg-turbo
+ *
+ * Copyright (C) 2014, 2018, 2020, D. R. Commander.  All Rights Reserved.
+ * Copyright (C) 2016-2017, Loongson Technology Corporation Limited, BeiJing.
+ *                          All Rights Reserved.
+ * Authors:  ZhuChen     <zhuchen@loongson.cn>
+ *           CaiWanwei   <caiwanwei@loongson.cn>
+ *           SunZhangzhi <sunzhangzhi-cq@loongson.cn>
+ *
+ * Based on the x86 SIMD extension for IJG JPEG library
+ * Copyright (C) 1999-2006, MIYASAKA Masaru.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+/* ACCURATE INTEGER FORWARD DCT */
+
+#include "jsimd_mmi.h"
+
+
+#define CONST_BITS  13
+#define PASS1_BITS  2
+#define DESCALE_P1  (CONST_BITS - PASS1_BITS)
+#define DESCALE_P2  (CONST_BITS + PASS1_BITS)
+
+#define FIX_0_298  ((short)2446)   /* FIX(0.298631336) */
+#define FIX_0_390  ((short)3196)   /* FIX(0.390180644) */
+#define FIX_0_541  ((short)4433)   /* FIX(0.541196100) */
+#define FIX_0_765  ((short)6270)   /* FIX(0.765366865) */
+#define FIX_0_899  ((short)7373)   /* FIX(0.899976223) */
+#define FIX_1_175  ((short)9633)   /* FIX(1.175875602) */
+#define FIX_1_501  ((short)12299)  /* FIX(1.501321110) */
+#define FIX_1_847  ((short)15137)  /* FIX(1.847759065) */
+#define FIX_1_961  ((short)16069)  /* FIX(1.961570560) */
+#define FIX_2_053  ((short)16819)  /* FIX(2.053119869) */
+#define FIX_2_562  ((short)20995)  /* FIX(2.562915447) */
+#define FIX_3_072  ((short)25172)  /* FIX(3.072711026) */
+
+enum const_index {
+  index_PW_F130_F054,
+  index_PW_F054_MF130,
+  index_PW_MF078_F117,
+  index_PW_F117_F078,
+  index_PW_MF060_MF089,
+  index_PW_MF089_F060,
+  index_PW_MF050_MF256,
+  index_PW_MF256_F050,
+  index_PD_DESCALE_P1,
+  index_PD_DESCALE_P2,
+  index_PW_DESCALE_P2X
+};
+
+static uint64_t const_value[] = {
+  _uint64_set_pi16(FIX_0_541, (FIX_0_541 + FIX_0_765),
+                   FIX_0_541, (FIX_0_541 + FIX_0_765)),
+  _uint64_set_pi16((FIX_0_541 - FIX_1_847), FIX_0_541,
+                   (FIX_0_541 - FIX_1_847), FIX_0_541),
+  _uint64_set_pi16(FIX_1_175, (FIX_1_175 - FIX_1_961),
+                   FIX_1_175, (FIX_1_175 - FIX_1_961)),
+  _uint64_set_pi16((FIX_1_175 - FIX_0_390), FIX_1_175,
+                   (FIX_1_175 - FIX_0_390), FIX_1_175),
+  _uint64_set_pi16(-FIX_0_899, (FIX_0_298 - FIX_0_899),
+                   -FIX_0_899, (FIX_0_298 - FIX_0_899)),
+  _uint64_set_pi16((FIX_1_501 - FIX_0_899), -FIX_0_899,
+                   (FIX_1_501 - FIX_0_899), -FIX_0_899),
+  _uint64_set_pi16(-FIX_2_562, (FIX_2_053 - FIX_2_562),
+                   -FIX_2_562, (FIX_2_053 - FIX_2_562)),
+  _uint64_set_pi16((FIX_3_072 - FIX_2_562), -FIX_2_562,
+                   (FIX_3_072 - FIX_2_562), -FIX_2_562),
+  _uint64_set_pi32((1 << (DESCALE_P1 - 1)), (1 << (DESCALE_P1 - 1))),
+  _uint64_set_pi32((1 << (DESCALE_P2 - 1)), (1 << (DESCALE_P2 - 1))),
+  _uint64_set_pi16((1 << (PASS1_BITS - 1)), (1 << (PASS1_BITS - 1)),
+                   (1 << (PASS1_BITS - 1)), (1 << (PASS1_BITS - 1)))
+};
+
+#define PW_F130_F054    get_const_value(index_PW_F130_F054)
+#define PW_F054_MF130   get_const_value(index_PW_F054_MF130)
+#define PW_MF078_F117   get_const_value(index_PW_MF078_F117)
+#define PW_F117_F078    get_const_value(index_PW_F117_F078)
+#define PW_MF060_MF089  get_const_value(index_PW_MF060_MF089)
+#define PW_MF089_F060   get_const_value(index_PW_MF089_F060)
+#define PW_MF050_MF256  get_const_value(index_PW_MF050_MF256)
+#define PW_MF256_F050   get_const_value(index_PW_MF256_F050)
+#define PD_DESCALE_P1   get_const_value(index_PD_DESCALE_P1)
+#define PD_DESCALE_P2   get_const_value(index_PD_DESCALE_P2)
+#define PW_DESCALE_P2X  get_const_value(index_PW_DESCALE_P2X)
+
+
+#define DO_FDCT_COMMON(PASS) { \
+  __m64 tmp1312l, tmp1312h, tmp47l, tmp47h, tmp4l, tmp4h, tmp7l, tmp7h; \
+  __m64 tmp56l, tmp56h, tmp5l, tmp5h, tmp6l, tmp6h; \
+  __m64 out1l, out1h, out2l, out2h, out3l, out3h; \
+  __m64 out5l, out5h, out6l, out6h, out7l, out7h; \
+  __m64 z34l, z34h, z3l, z3h, z4l, z4h, z3, z4; \
+  \
+  /* (Original) \
+   * z1 = (tmp12 + tmp13) * 0.541196100; \
+   * out2 = z1 + tmp13 * 0.765366865; \
+   * out6 = z1 + tmp12 * -1.847759065; \
+   * \
+   * (This implementation) \
+   * out2 = tmp13 * (0.541196100 + 0.765366865) + tmp12 * 0.541196100; \
+   * out6 = tmp13 * 0.541196100 + tmp12 * (0.541196100 - 1.847759065); \
+   */ \
+  \
+  tmp1312l = _mm_unpacklo_pi16(tmp13, tmp12); \
+  tmp1312h = _mm_unpackhi_pi16(tmp13, tmp12); \
+  \
+  out2l = _mm_madd_pi16(tmp1312l, PW_F130_F054); \
+  out2h = _mm_madd_pi16(tmp1312h, PW_F130_F054); \
+  out6l = _mm_madd_pi16(tmp1312l, PW_F054_MF130); \
+  out6h = _mm_madd_pi16(tmp1312h, PW_F054_MF130); \
+  \
+  out2l = _mm_add_pi32(out2l, PD_DESCALE_P##PASS); \
+  out2h = _mm_add_pi32(out2h, PD_DESCALE_P##PASS); \
+  out2l = _mm_srai_pi32(out2l, DESCALE_P##PASS); \
+  out2h = _mm_srai_pi32(out2h, DESCALE_P##PASS); \
+  \
+  out6l = _mm_add_pi32(out6l, PD_DESCALE_P##PASS); \
+  out6h = _mm_add_pi32(out6h, PD_DESCALE_P##PASS); \
+  out6l = _mm_srai_pi32(out6l, DESCALE_P##PASS); \
+  out6h = _mm_srai_pi32(out6h, DESCALE_P##PASS); \
+  \
+  out2 = _mm_packs_pi32(out2l, out2h); \
+  out6 = _mm_packs_pi32(out6l, out6h); \
+  \
+  /* Odd part */ \
+  \
+  z3 = _mm_add_pi16(tmp4, tmp6); \
+  z4 = _mm_add_pi16(tmp5, tmp7); \
+  \
+  /* (Original) \
+   * z5 = (z3 + z4) * 1.175875602; \
+   * z3 = z3 * -1.961570560;  z4 = z4 * -0.390180644; \
+   * z3 += z5;  z4 += z5; \
+   * \
+   * (This implementation) \
+   * z3 = z3 * (1.175875602 - 1.961570560) + z4 * 1.175875602; \
+   * z4 = z3 * 1.175875602 + z4 * (1.175875602 - 0.390180644); \
+   */ \
+  \
+  z34l = _mm_unpacklo_pi16(z3, z4); \
+  z34h = _mm_unpackhi_pi16(z3, z4); \
+  z3l = _mm_madd_pi16(z34l, PW_MF078_F117); \
+  z3h = _mm_madd_pi16(z34h, PW_MF078_F117); \
+  z4l = _mm_madd_pi16(z34l, PW_F117_F078); \
+  z4h = _mm_madd_pi16(z34h, PW_F117_F078); \
+  \
+  /* (Original) \
+   * z1 = tmp4 + tmp7;  z2 = tmp5 + tmp6; \
+   * tmp4 = tmp4 * 0.298631336;  tmp5 = tmp5 * 2.053119869; \
+   * tmp6 = tmp6 * 3.072711026;  tmp7 = tmp7 * 1.501321110; \
+   * z1 = z1 * -0.899976223;  z2 = z2 * -2.562915447; \
+   * out7 = tmp4 + z1 + z3;  out5 = tmp5 + z2 + z4; \
+   * out3 = tmp6 + z2 + z3;  out1 = tmp7 + z1 + z4; \
+   * \
+   * (This implementation) \
+   * tmp4 = tmp4 * (0.298631336 - 0.899976223) + tmp7 * -0.899976223; \
+   * tmp5 = tmp5 * (2.053119869 - 2.562915447) + tmp6 * -2.562915447; \
+   * tmp6 = tmp5 * -2.562915447 + tmp6 * (3.072711026 - 2.562915447); \
+   * tmp7 = tmp4 * -0.899976223 + tmp7 * (1.501321110 - 0.899976223); \
+   * out7 = tmp4 + z3;  out5 = tmp5 + z4; \
+   * out3 = tmp6 + z3;  out1 = tmp7 + z4; \
+   */ \
+  \
+  tmp47l = _mm_unpacklo_pi16(tmp4, tmp7); \
+  tmp47h = _mm_unpackhi_pi16(tmp4, tmp7); \
+  \
+  tmp4l = _mm_madd_pi16(tmp47l, PW_MF060_MF089); \
+  tmp4h = _mm_madd_pi16(tmp47h, PW_MF060_MF089); \
+  tmp7l = _mm_madd_pi16(tmp47l, PW_MF089_F060); \
+  tmp7h = _mm_madd_pi16(tmp47h, PW_MF089_F060); \
+  \
+  out7l = _mm_add_pi32(tmp4l, z3l); \
+  out7h = _mm_add_pi32(tmp4h, z3h); \
+  out1l = _mm_add_pi32(tmp7l, z4l); \
+  out1h = _mm_add_pi32(tmp7h, z4h); \
+  \
+  out7l = _mm_add_pi32(out7l, PD_DESCALE_P##PASS); \
+  out7h = _mm_add_pi32(out7h, PD_DESCALE_P##PASS); \
+  out7l = _mm_srai_pi32(out7l, DESCALE_P##PASS); \
+  out7h = _mm_srai_pi32(out7h, DESCALE_P##PASS); \
+  \
+  out1l = _mm_add_pi32(out1l, PD_DESCALE_P##PASS); \
+  out1h = _mm_add_pi32(out1h, PD_DESCALE_P##PASS); \
+  out1l = _mm_srai_pi32(out1l, DESCALE_P##PASS); \
+  out1h = _mm_srai_pi32(out1h, DESCALE_P##PASS); \
+  \
+  out7 = _mm_packs_pi32(out7l, out7h); \
+  out1 = _mm_packs_pi32(out1l, out1h); \
+  \
+  tmp56l = _mm_unpacklo_pi16(tmp5, tmp6); \
+  tmp56h = _mm_unpackhi_pi16(tmp5, tmp6); \
+  \
+  tmp5l = _mm_madd_pi16(tmp56l, PW_MF050_MF256); \
+  tmp5h = _mm_madd_pi16(tmp56h, PW_MF050_MF256); \
+  tmp6l = _mm_madd_pi16(tmp56l, PW_MF256_F050); \
+  tmp6h = _mm_madd_pi16(tmp56h, PW_MF256_F050); \
+  \
+  out5l = _mm_add_pi32(tmp5l, z4l); \
+  out5h = _mm_add_pi32(tmp5h, z4h); \
+  out3l = _mm_add_pi32(tmp6l, z3l); \
+  out3h = _mm_add_pi32(tmp6h, z3h); \
+  \
+  out5l = _mm_add_pi32(out5l, PD_DESCALE_P##PASS); \
+  out5h = _mm_add_pi32(out5h, PD_DESCALE_P##PASS); \
+  out5l = _mm_srai_pi32(out5l, DESCALE_P##PASS); \
+  out5h = _mm_srai_pi32(out5h, DESCALE_P##PASS); \
+  \
+  out3l = _mm_add_pi32(out3l, PD_DESCALE_P##PASS); \
+  out3h = _mm_add_pi32(out3h, PD_DESCALE_P##PASS); \
+  out3l = _mm_srai_pi32(out3l, DESCALE_P##PASS); \
+  out3h = _mm_srai_pi32(out3h, DESCALE_P##PASS); \
+  \
+  out5 = _mm_packs_pi32(out5l, out5h); \
+  out3 = _mm_packs_pi32(out3l, out3h); \
+}
+
+#define DO_FDCT_PASS1() { \
+  __m64 row0l, row0h, row1l, row1h, row2l, row2h, row3l, row3h; \
+  __m64 row01a, row01b, row01c, row01d, row23a, row23b, row23c, row23d; \
+  __m64 col0, col1, col2, col3, col4, col5, col6, col7; \
+  __m64 tmp10, tmp11; \
+  \
+  row0l = _mm_load_si64((__m64 *)&dataptr[DCTSIZE * 0]);     /* (00 01 02 03) */ \
+  row0h = _mm_load_si64((__m64 *)&dataptr[DCTSIZE * 0 + 4]); /* (04 05 06 07) */ \
+  row1l = _mm_load_si64((__m64 *)&dataptr[DCTSIZE * 1]);     /* (10 11 12 13) */ \
+  row1h = _mm_load_si64((__m64 *)&dataptr[DCTSIZE * 1 + 4]); /* (14 15 16 17) */ \
+  row2l = _mm_load_si64((__m64 *)&dataptr[DCTSIZE * 2]);     /* (20 21 22 23) */ \
+  row2h = _mm_load_si64((__m64 *)&dataptr[DCTSIZE * 2 + 4]); /* (24 25 26 27) */ \
+  row3l = _mm_load_si64((__m64 *)&dataptr[DCTSIZE * 3]);     /* (30 31 32 33) */ \
+  row3h = _mm_load_si64((__m64 *)&dataptr[DCTSIZE * 3 + 4]); /* (34 35 36 37) */ \
+  \
+  /* Transpose coefficients */ \
+  \
+  row23a = _mm_unpacklo_pi16(row2l, row3l);   /* row23a=(20 30 21 31) */ \
+  row23b = _mm_unpackhi_pi16(row2l, row3l);   /* row23b=(22 32 23 33) */ \
+  row23c = _mm_unpacklo_pi16(row2h, row3h);   /* row23c=(24 34 25 35) */ \
+  row23d = _mm_unpackhi_pi16(row2h, row3h);   /* row23d=(26 36 27 37) */ \
+  \
+  row01a = _mm_unpacklo_pi16(row0l, row1l);   /* row01a=(00 10 01 11) */ \
+  row01b = _mm_unpackhi_pi16(row0l, row1l);   /* row01b=(02 12 03 13) */ \
+  row01c = _mm_unpacklo_pi16(row0h, row1h);   /* row01c=(04 14 05 15) */ \
+  row01d = _mm_unpackhi_pi16(row0h, row1h);   /* row01d=(06 16 07 17) */ \
+  \
+  col0 = _mm_unpacklo_pi32(row01a, row23a);   /* col0=(00 10 20 30) */ \
+  col1 = _mm_unpackhi_pi32(row01a, row23a);   /* col1=(01 11 21 31) */ \
+  col6 = _mm_unpacklo_pi32(row01d, row23d);   /* col6=(06 16 26 36) */ \
+  col7 = _mm_unpackhi_pi32(row01d, row23d);   /* col7=(07 17 27 37) */ \
+  \
+  tmp6 = _mm_sub_pi16(col1, col6);            /* tmp6=col1-col6 */ \
+  tmp7 = _mm_sub_pi16(col0, col7);            /* tmp7=col0-col7 */ \
+  tmp1 = _mm_add_pi16(col1, col6);            /* tmp1=col1+col6 */ \
+  tmp0 = _mm_add_pi16(col0, col7);            /* tmp0=col0+col7 */ \
+  \
+  col2 = _mm_unpacklo_pi32(row01b, row23b);   /* col2=(02 12 22 32) */ \
+  col3 = _mm_unpackhi_pi32(row01b, row23b);   /* col3=(03 13 23 33) */ \
+  col4 = _mm_unpacklo_pi32(row01c, row23c);   /* col4=(04 14 24 34) */ \
+  col5 = _mm_unpackhi_pi32(row01c, row23c);   /* col5=(05 15 25 35) */ \
+  \
+  tmp3 = _mm_add_pi16(col3, col4);            /* tmp3=col3+col4 */ \
+  tmp2 = _mm_add_pi16(col2, col5);            /* tmp2=col2+col5 */ \
+  tmp4 = _mm_sub_pi16(col3, col4);            /* tmp4=col3-col4 */ \
+  tmp5 = _mm_sub_pi16(col2, col5);            /* tmp5=col2-col5 */ \
+  \
+  /* Even part */ \
+  \
+  tmp10 = _mm_add_pi16(tmp0, tmp3);           /* tmp10=tmp0+tmp3 */ \
+  tmp13 = _mm_sub_pi16(tmp0, tmp3);           /* tmp13=tmp0-tmp3 */ \
+  tmp11 = _mm_add_pi16(tmp1, tmp2);           /* tmp11=tmp1+tmp2 */ \
+  tmp12 = _mm_sub_pi16(tmp1, tmp2);           /* tmp12=tmp1-tmp2 */ \
+  \
+  out0 = _mm_add_pi16(tmp10, tmp11);          /* out0=tmp10+tmp11 */ \
+  out4 = _mm_sub_pi16(tmp10, tmp11);          /* out4=tmp10-tmp11 */ \
+  out0 = _mm_slli_pi16(out0, PASS1_BITS); \
+  out4 = _mm_slli_pi16(out4, PASS1_BITS); \
+  \
+  DO_FDCT_COMMON(1) \
+  \
+  _mm_store_si64((__m64 *)&dataptr[DCTSIZE * 0], out0); \
+  _mm_store_si64((__m64 *)&dataptr[DCTSIZE * 0 + 4], out4); \
+  _mm_store_si64((__m64 *)&dataptr[DCTSIZE * 1], out1); \
+  _mm_store_si64((__m64 *)&dataptr[DCTSIZE * 1 + 4], out5); \
+  _mm_store_si64((__m64 *)&dataptr[DCTSIZE * 2], out2); \
+  _mm_store_si64((__m64 *)&dataptr[DCTSIZE * 2 + 4], out6); \
+  _mm_store_si64((__m64 *)&dataptr[DCTSIZE * 3], out3); \
+  _mm_store_si64((__m64 *)&dataptr[DCTSIZE * 3 + 4], out7); \
+}
+
+#define DO_FDCT_PASS2() { \
+  __m64 col0l, col0h, col1l, col1h, col2l, col2h, col3l, col3h; \
+  __m64 col01a, col01b, col01c, col01d, col23a, col23b, col23c, col23d; \
+  __m64 row0, row1, row2, row3, row4, row5, row6, row7; \
+  __m64 tmp10, tmp11; \
+  \
+  col0l = _mm_load_si64((__m64 *)&dataptr[DCTSIZE * 0]);  /* (00 10 20 30) */ \
+  col1l = _mm_load_si64((__m64 *)&dataptr[DCTSIZE * 1]);  /* (01 11 21 31) */ \
+  col2l = _mm_load_si64((__m64 *)&dataptr[DCTSIZE * 2]);  /* (02 12 22 32) */ \
+  col3l = _mm_load_si64((__m64 *)&dataptr[DCTSIZE * 3]);  /* (03 13 23 33) */ \
+  col0h = _mm_load_si64((__m64 *)&dataptr[DCTSIZE * 4]);  /* (40 50 60 70) */ \
+  col1h = _mm_load_si64((__m64 *)&dataptr[DCTSIZE * 5]);  /* (41 51 61 71) */ \
+  col2h = _mm_load_si64((__m64 *)&dataptr[DCTSIZE * 6]);  /* (42 52 62 72) */ \
+  col3h = _mm_load_si64((__m64 *)&dataptr[DCTSIZE * 7]);  /* (43 53 63 73) */ \
+  \
+  /* Transpose coefficients */ \
+  \
+  col23a = _mm_unpacklo_pi16(col2l, col3l);   /* col23a=(02 03 12 13) */ \
+  col23b = _mm_unpackhi_pi16(col2l, col3l);   /* col23b=(22 23 32 33) */ \
+  col23c = _mm_unpacklo_pi16(col2h, col3h);   /* col23c=(42 43 52 53) */ \
+  col23d = _mm_unpackhi_pi16(col2h, col3h);   /* col23d=(62 63 72 73) */ \
+  \
+  col01a = _mm_unpacklo_pi16(col0l, col1l);   /* col01a=(00 01 10 11) */ \
+  col01b = _mm_unpackhi_pi16(col0l, col1l);   /* col01b=(20 21 30 31) */ \
+  col01c = _mm_unpacklo_pi16(col0h, col1h);   /* col01c=(40 41 50 51) */ \
+  col01d = _mm_unpackhi_pi16(col0h, col1h);   /* col01d=(60 61 70 71) */ \
+  \
+  row0 = _mm_unpacklo_pi32(col01a, col23a);   /* row0=(00 01 02 03) */ \
+  row1 = _mm_unpackhi_pi32(col01a, col23a);   /* row1=(10 11 12 13) */ \
+  row6 = _mm_unpacklo_pi32(col01d, col23d);   /* row6=(60 61 62 63) */ \
+  row7 = _mm_unpackhi_pi32(col01d, col23d);   /* row7=(70 71 72 73) */ \
+  \
+  tmp6 = _mm_sub_pi16(row1, row6);            /* tmp6=row1-row6 */ \
+  tmp7 = _mm_sub_pi16(row0, row7);            /* tmp7=row0-row7 */ \
+  tmp1 = _mm_add_pi16(row1, row6);            /* tmp1=row1+row6 */ \
+  tmp0 = _mm_add_pi16(row0, row7);            /* tmp0=row0+row7 */ \
+  \
+  row2 = _mm_unpacklo_pi32(col01b, col23b);   /* row2=(20 21 22 23) */ \
+  row3 = _mm_unpackhi_pi32(col01b, col23b);   /* row3=(30 31 32 33) */ \
+  row4 = _mm_unpacklo_pi32(col01c, col23c);   /* row4=(40 41 42 43) */ \
+  row5 = _mm_unpackhi_pi32(col01c, col23c);   /* row5=(50 51 52 53) */ \
+  \
+  tmp3 = _mm_add_pi16(row3, row4);            /* tmp3=row3+row4 */ \
+  tmp2 = _mm_add_pi16(row2, row5);            /* tmp2=row2+row5 */ \
+  tmp4 = _mm_sub_pi16(row3, row4);            /* tmp4=row3-row4 */ \
+  tmp5 = _mm_sub_pi16(row2, row5);            /* tmp5=row2-row5 */ \
+  \
+  /* Even part */ \
+  \
+  tmp10 = _mm_add_pi16(tmp0, tmp3);           /* tmp10=tmp0+tmp3 */ \
+  tmp13 = _mm_sub_pi16(tmp0, tmp3);           /* tmp13=tmp0-tmp3 */ \
+  tmp11 = _mm_add_pi16(tmp1, tmp2);           /* tmp11=tmp1+tmp2 */ \
+  tmp12 = _mm_sub_pi16(tmp1, tmp2);           /* tmp12=tmp1-tmp2 */ \
+  \
+  out0 = _mm_add_pi16(tmp10, tmp11);          /* out0=tmp10+tmp11 */ \
+  out4 = _mm_sub_pi16(tmp10, tmp11);          /* out4=tmp10-tmp11 */ \
+  \
+  out0 = _mm_add_pi16(out0, PW_DESCALE_P2X); \
+  out4 = _mm_add_pi16(out4, PW_DESCALE_P2X); \
+  out0 = _mm_srai_pi16(out0, PASS1_BITS); \
+  out4 = _mm_srai_pi16(out4, PASS1_BITS); \
+  \
+  DO_FDCT_COMMON(2) \
+  \
+  _mm_store_si64((__m64 *)&dataptr[DCTSIZE * 0], out0); \
+  _mm_store_si64((__m64 *)&dataptr[DCTSIZE * 1], out1); \
+  _mm_store_si64((__m64 *)&dataptr[DCTSIZE * 2], out2); \
+  _mm_store_si64((__m64 *)&dataptr[DCTSIZE * 3], out3); \
+  _mm_store_si64((__m64 *)&dataptr[DCTSIZE * 4], out4); \
+  _mm_store_si64((__m64 *)&dataptr[DCTSIZE * 5], out5); \
+  _mm_store_si64((__m64 *)&dataptr[DCTSIZE * 6], out6); \
+  _mm_store_si64((__m64 *)&dataptr[DCTSIZE * 7], out7); \
+}
+
+void jsimd_fdct_islow_mmi(DCTELEM *data)
+{
+  __m64 tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
+  __m64 out0, out1, out2, out3, out4, out5, out6, out7;
+  __m64 tmp12, tmp13;
+  DCTELEM *dataptr = data;
+
+  /* Pass 1: process rows. */
+
+  DO_FDCT_PASS1()
+  dataptr += DCTSIZE * 4;
+  DO_FDCT_PASS1()
+
+  /* Pass 2: process columns. */
+
+  dataptr = data;
+  DO_FDCT_PASS2()
+  dataptr += 4;
+  DO_FDCT_PASS2()
+}
diff --git a/3rdparty/libjpeg/src/simd/mips64/jidctfst-mmi.c b/3rdparty/libjpeg/src/simd/mips64/jidctfst-mmi.c
new file mode 100644
index 00000000..503bb35a
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/mips64/jidctfst-mmi.c
@@ -0,0 +1,395 @@
+/*
+ * Loongson MMI optimizations for libjpeg-turbo
+ *
+ * Copyright (C) 2014-2015, 2018-2019, D. R. Commander.  All Rights Reserved.
+ * Copyright (C) 2016-2018, Loongson Technology Corporation Limited, BeiJing.
+ *                          All Rights Reserved.
+ * Authors:  LiuQingfa <liuqingfa-hf@loongson.cn>
+ *
+ * Based on the x86 SIMD extension for IJG JPEG library
+ * Copyright (C) 1999-2006, MIYASAKA Masaru.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+/* FAST INTEGER INVERSE DCT */
+
+#include "jsimd_mmi.h"
+
+
+#define CONST_BITS  8
+#define PASS1_BITS  2
+
+#define FIX_1_082  ((short)277)                   /* FIX(1.082392200) */
+#define FIX_1_414  ((short)362)                   /* FIX(1.414213562) */
+#define FIX_1_847  ((short)473)                   /* FIX(1.847759065) */
+#define FIX_2_613  ((short)669)                   /* FIX(2.613125930) */
+#define FIX_1_613  ((short)(FIX_2_613 - 256 * 3)) /* FIX(2.613125930) - FIX(1) */
+
+#define PRE_MULTIPLY_SCALE_BITS  2
+#define CONST_SHIFT  (16 - PRE_MULTIPLY_SCALE_BITS - CONST_BITS)
+
+enum const_index {
+  index_PW_F1082,
+  index_PW_F1414,
+  index_PW_F1847,
+  index_PW_MF1613,
+  index_PB_CENTERJSAMP
+};
+
+static uint64_t const_value[] = {
+  _uint64_set1_pi16(FIX_1_082 << CONST_SHIFT),
+  _uint64_set1_pi16(FIX_1_414 << CONST_SHIFT),
+  _uint64_set1_pi16(FIX_1_847 << CONST_SHIFT),
+  _uint64_set1_pi16(-FIX_1_613 << CONST_SHIFT),
+  _uint64_set1_pi8(CENTERJSAMPLE)
+};
+
+#define PW_F1414        get_const_value(index_PW_F1414)
+#define PW_F1847        get_const_value(index_PW_F1847)
+#define PW_MF1613       get_const_value(index_PW_MF1613)
+#define PW_F1082        get_const_value(index_PW_F1082)
+#define PB_CENTERJSAMP  get_const_value(index_PB_CENTERJSAMP)
+
+
+#define test_m32_zero(mm32)  (!(*(uint32_t *)&mm32))
+#define test_m64_zero(mm64)  (!(*(uint64_t *)&mm64))
+
+
+#define DO_IDCT_COMMON() { \
+  tmp7 = _mm_add_pi16(z11, z13); \
+  \
+  tmp11 = _mm_sub_pi16(z11, z13); \
+  tmp11 = _mm_slli_pi16(tmp11, PRE_MULTIPLY_SCALE_BITS); \
+  tmp11 = _mm_mulhi_pi16(tmp11, PW_F1414); \
+  \
+  tmp10 = _mm_slli_pi16(z12, PRE_MULTIPLY_SCALE_BITS); \
+  tmp12 = _mm_slli_pi16(z10, PRE_MULTIPLY_SCALE_BITS); \
+  \
+  /* To avoid overflow... \
+   * \
+   * (Original) \
+   * tmp12 = -2.613125930 * z10 + z5; \
+   * \
+   * (This implementation) \
+   * tmp12 = (-1.613125930 - 1) * z10 + z5; \
+   *       = -1.613125930 * z10 - z10 + z5; \
+   */ \
+  \
+  z5 = _mm_add_pi16(tmp10, tmp12); \
+  z5 = _mm_mulhi_pi16(z5, PW_F1847); \
+  \
+  tmp10 = _mm_mulhi_pi16(tmp10, PW_F1082); \
+  tmp10 = _mm_sub_pi16(tmp10, z5); \
+  tmp12 = _mm_mulhi_pi16(tmp12, PW_MF1613); \
+  tmp12 = _mm_sub_pi16(tmp12, z10); \
+  tmp12 = _mm_sub_pi16(tmp12, z10); \
+  tmp12 = _mm_sub_pi16(tmp12, z10); \
+  tmp12 = _mm_add_pi16(tmp12, z5); \
+  \
+  /* Final output stage */ \
+  \
+  tmp6 = _mm_sub_pi16(tmp12, tmp7); \
+  tmp5 = _mm_sub_pi16(tmp11, tmp6); \
+  tmp4 = _mm_add_pi16(tmp10, tmp5); \
+  \
+  out0 = _mm_add_pi16(tmp0, tmp7); \
+  out7 = _mm_sub_pi16(tmp0, tmp7); \
+  out1 = _mm_add_pi16(tmp1, tmp6); \
+  out6 = _mm_sub_pi16(tmp1, tmp6); \
+  \
+  out2 = _mm_add_pi16(tmp2, tmp5); \
+  out5 = _mm_sub_pi16(tmp2, tmp5); \
+  out4 = _mm_add_pi16(tmp3, tmp4); \
+  out3 = _mm_sub_pi16(tmp3, tmp4); \
+}
+
+#define DO_IDCT_PASS1(iter) { \
+  __m64 col0l, col1l, col2l, col3l, col4l, col5l, col6l, col7l; \
+  __m64 quant0l, quant1l, quant2l, quant3l; \
+  __m64 quant4l, quant5l, quant6l, quant7l; \
+  __m64 row01a, row01b, row01c, row01d, row23a, row23b, row23c, row23d; \
+  __m64 row0l, row0h, row1l, row1h, row2l, row2h, row3l, row3h; \
+  __m32 col0a, col1a, mm0; \
+  \
+  col0a = _mm_load_si32((__m32 *)&inptr[DCTSIZE * 1]); \
+  col1a = _mm_load_si32((__m32 *)&inptr[DCTSIZE * 2]); \
+  mm0 = _mm_or_si32(col0a, col1a); \
+  \
+  if (test_m32_zero(mm0)) { \
+    __m64 mm1, mm2; \
+    \
+    col0l = _mm_load_si64((__m64 *)&inptr[DCTSIZE * 0]); \
+    col1l = _mm_load_si64((__m64 *)&inptr[DCTSIZE * 1]); \
+    col2l = _mm_load_si64((__m64 *)&inptr[DCTSIZE * 2]); \
+    col3l = _mm_load_si64((__m64 *)&inptr[DCTSIZE * 3]); \
+    col4l = _mm_load_si64((__m64 *)&inptr[DCTSIZE * 4]); \
+    col5l = _mm_load_si64((__m64 *)&inptr[DCTSIZE * 5]); \
+    col6l = _mm_load_si64((__m64 *)&inptr[DCTSIZE * 6]); \
+    col7l = _mm_load_si64((__m64 *)&inptr[DCTSIZE * 7]); \
+    \
+    mm1 = _mm_or_si64(col1l, col3l); \
+    mm2 = _mm_or_si64(col2l, col4l); \
+    mm1 = _mm_or_si64(mm1, col5l); \
+    mm2 = _mm_or_si64(mm2, col6l); \
+    mm1 = _mm_or_si64(mm1, col7l); \
+    mm1 = _mm_or_si64(mm1, mm2); \
+    \
+    if (test_m64_zero(mm1)) { \
+      __m64 dcval, dcvall, dcvalh, row0, row1, row2, row3; \
+      \
+      /* AC terms all zero */ \
+      \
+      quant0l = _mm_load_si64((__m64 *)&quantptr[DCTSIZE * 0]); \
+      \
+      dcval = _mm_mullo_pi16(col0l, quant0l);    /* dcval=(00 10 20 30) */ \
+      \
+      dcvall = _mm_unpacklo_pi16(dcval, dcval);  /* dcvall=(00 00 10 10) */ \
+      dcvalh = _mm_unpackhi_pi16(dcval, dcval);  /* dcvalh=(20 20 30 30) */ \
+      \
+      row0 = _mm_unpacklo_pi32(dcvall, dcvall);  /* row0=(00 00 00 00) */ \
+      row1 = _mm_unpackhi_pi32(dcvall, dcvall);  /* row1=(10 10 10 10) */ \
+      row2 = _mm_unpacklo_pi32(dcvalh, dcvalh);  /* row2=(20 20 20 20) */ \
+      row3 = _mm_unpackhi_pi32(dcvalh, dcvalh);  /* row3=(30 30 30 30) */ \
+      \
+      _mm_store_si64((__m64 *)&wsptr[DCTSIZE * 0], row0); \
+      _mm_store_si64((__m64 *)&wsptr[DCTSIZE * 0 + 4], row0); \
+      _mm_store_si64((__m64 *)&wsptr[DCTSIZE * 1], row1); \
+      _mm_store_si64((__m64 *)&wsptr[DCTSIZE * 1 + 4], row1); \
+      _mm_store_si64((__m64 *)&wsptr[DCTSIZE * 2], row2); \
+      _mm_store_si64((__m64 *)&wsptr[DCTSIZE * 2 + 4], row2); \
+      _mm_store_si64((__m64 *)&wsptr[DCTSIZE * 3], row3); \
+      _mm_store_si64((__m64 *)&wsptr[DCTSIZE * 3 + 4], row3); \
+      \
+      goto nextcolumn##iter; \
+    } \
+  } \
+  \
+  /* Even part */ \
+  \
+  col0l = _mm_load_si64((__m64 *)&inptr[DCTSIZE * 0]);  /* (00 10 20 30) */ \
+  col2l = _mm_load_si64((__m64 *)&inptr[DCTSIZE * 2]);  /* (02 12 22 32) */ \
+  col4l = _mm_load_si64((__m64 *)&inptr[DCTSIZE * 4]);  /* (04 14 24 34) */ \
+  col6l = _mm_load_si64((__m64 *)&inptr[DCTSIZE * 6]);  /* (06 16 26 36) */ \
+  \
+  quant0l = _mm_load_si64((__m64 *)&quantptr[DCTSIZE * 0]); \
+  quant2l = _mm_load_si64((__m64 *)&quantptr[DCTSIZE * 2]); \
+  quant4l = _mm_load_si64((__m64 *)&quantptr[DCTSIZE * 4]); \
+  quant6l = _mm_load_si64((__m64 *)&quantptr[DCTSIZE * 6]); \
+  \
+  tmp0 = _mm_mullo_pi16(col0l, quant0l); \
+  tmp1 = _mm_mullo_pi16(col2l, quant2l); \
+  tmp2 = _mm_mullo_pi16(col4l, quant4l); \
+  tmp3 = _mm_mullo_pi16(col6l, quant6l); \
+  \
+  tmp10 = _mm_add_pi16(tmp0, tmp2); \
+  tmp11 = _mm_sub_pi16(tmp0, tmp2); \
+  tmp13 = _mm_add_pi16(tmp1, tmp3); \
+  \
+  tmp12 = _mm_sub_pi16(tmp1, tmp3); \
+  tmp12 = _mm_slli_pi16(tmp12, PRE_MULTIPLY_SCALE_BITS); \
+  tmp12 = _mm_mulhi_pi16(tmp12, PW_F1414); \
+  tmp12 = _mm_sub_pi16(tmp12, tmp13); \
+  \
+  tmp0 = _mm_add_pi16(tmp10, tmp13); \
+  tmp3 = _mm_sub_pi16(tmp10, tmp13); \
+  tmp1 = _mm_add_pi16(tmp11, tmp12); \
+  tmp2 = _mm_sub_pi16(tmp11, tmp12); \
+  \
+  /* Odd part */ \
+  \
+  col1l = _mm_load_si64((__m64 *)&inptr[DCTSIZE * 1]);  /* (01 11 21 31) */ \
+  col3l = _mm_load_si64((__m64 *)&inptr[DCTSIZE * 3]);  /* (03 13 23 33) */ \
+  col5l = _mm_load_si64((__m64 *)&inptr[DCTSIZE * 5]);  /* (05 15 25 35) */ \
+  col7l = _mm_load_si64((__m64 *)&inptr[DCTSIZE * 7]);  /* (07 17 27 37) */ \
+  \
+  quant1l = _mm_load_si64((__m64 *)&quantptr[DCTSIZE * 1]); \
+  quant3l = _mm_load_si64((__m64 *)&quantptr[DCTSIZE * 3]); \
+  quant5l = _mm_load_si64((__m64 *)&quantptr[DCTSIZE * 5]); \
+  quant7l = _mm_load_si64((__m64 *)&quantptr[DCTSIZE * 7]); \
+  \
+  tmp4 = _mm_mullo_pi16(col1l, quant1l); \
+  tmp5 = _mm_mullo_pi16(col3l, quant3l); \
+  tmp6 = _mm_mullo_pi16(col5l, quant5l); \
+  tmp7 = _mm_mullo_pi16(col7l, quant7l); \
+  \
+  z13 = _mm_add_pi16(tmp6, tmp5); \
+  z10 = _mm_sub_pi16(tmp6, tmp5); \
+  z11 = _mm_add_pi16(tmp4, tmp7); \
+  z12 = _mm_sub_pi16(tmp4, tmp7); \
+  \
+  DO_IDCT_COMMON() \
+  \
+  /* out0=(00 10 20 30), out1=(01 11 21 31) */ \
+  /* out2=(02 12 22 32), out3=(03 13 23 33) */ \
+  /* out4=(04 14 24 34), out5=(05 15 25 35) */ \
+  /* out6=(06 16 26 36), out7=(07 17 27 37) */ \
+  \
+  /* Transpose coefficients */ \
+  \
+  row01a = _mm_unpacklo_pi16(out0, out1);     /* row01a=(00 01 10 11) */ \
+  row23a = _mm_unpackhi_pi16(out0, out1);     /* row23a=(20 21 30 31) */ \
+  row01d = _mm_unpacklo_pi16(out6, out7);     /* row01d=(06 07 16 17) */ \
+  row23d = _mm_unpackhi_pi16(out6, out7);     /* row23d=(26 27 36 37) */ \
+  \
+  row01b = _mm_unpacklo_pi16(out2, out3);     /* row01b=(02 03 12 13) */ \
+  row23b = _mm_unpackhi_pi16(out2, out3);     /* row23b=(22 23 32 33) */ \
+  row01c = _mm_unpacklo_pi16(out4, out5);     /* row01c=(04 05 14 15) */ \
+  row23c = _mm_unpackhi_pi16(out4, out5);     /* row23c=(24 25 34 35) */ \
+  \
+  row0l = _mm_unpacklo_pi32(row01a, row01b);  /* row0l=(00 01 02 03) */ \
+  row1l = _mm_unpackhi_pi32(row01a, row01b);  /* row1l=(10 11 12 13) */ \
+  row2l = _mm_unpacklo_pi32(row23a, row23b);  /* row2l=(20 21 22 23) */ \
+  row3l = _mm_unpackhi_pi32(row23a, row23b);  /* row3l=(30 31 32 33) */ \
+  \
+  row0h = _mm_unpacklo_pi32(row01c, row01d);  /* row0h=(04 05 06 07) */ \
+  row1h = _mm_unpackhi_pi32(row01c, row01d);  /* row1h=(14 15 16 17) */ \
+  row2h = _mm_unpacklo_pi32(row23c, row23d);  /* row2h=(24 25 26 27) */ \
+  row3h = _mm_unpackhi_pi32(row23c, row23d);  /* row3h=(34 35 36 37) */ \
+  \
+  _mm_store_si64((__m64 *)&wsptr[DCTSIZE * 0], row0l); \
+  _mm_store_si64((__m64 *)&wsptr[DCTSIZE * 0 + 4], row0h); \
+  _mm_store_si64((__m64 *)&wsptr[DCTSIZE * 1], row1l); \
+  _mm_store_si64((__m64 *)&wsptr[DCTSIZE * 1 + 4], row1h); \
+  _mm_store_si64((__m64 *)&wsptr[DCTSIZE * 2], row2l); \
+  _mm_store_si64((__m64 *)&wsptr[DCTSIZE * 2 + 4], row2h); \
+  _mm_store_si64((__m64 *)&wsptr[DCTSIZE * 3], row3l); \
+  _mm_store_si64((__m64 *)&wsptr[DCTSIZE * 3 + 4], row3h); \
+}
+
+#define DO_IDCT_PASS2(ctr) { \
+  __m64 row0l, row1l, row2l, row3l, row4l, row5l, row6l, row7l; \
+  __m64 col0123a, col0123b, col0123c, col0123d; \
+  __m64 col01l, col01h, col23l, col23h; \
+  __m64 col0, col1, col2, col3; \
+  __m64 row06, row17, row24, row35; \
+  \
+  row0l = _mm_load_si64((__m64 *)&wsptr[DCTSIZE * 0]);  /* (00 01 02 03) */ \
+  row1l = _mm_load_si64((__m64 *)&wsptr[DCTSIZE * 1]);  /* (10 11 12 13) */ \
+  row2l = _mm_load_si64((__m64 *)&wsptr[DCTSIZE * 2]);  /* (20 21 22 23) */ \
+  row3l = _mm_load_si64((__m64 *)&wsptr[DCTSIZE * 3]);  /* (30 31 32 33) */ \
+  row4l = _mm_load_si64((__m64 *)&wsptr[DCTSIZE * 4]);  /* (40 41 42 43) */ \
+  row5l = _mm_load_si64((__m64 *)&wsptr[DCTSIZE * 5]);  /* (50 51 52 53) */ \
+  row6l = _mm_load_si64((__m64 *)&wsptr[DCTSIZE * 6]);  /* (60 61 62 63) */ \
+  row7l = _mm_load_si64((__m64 *)&wsptr[DCTSIZE * 7]);  /* (70 71 72 73) */ \
+  \
+  /* Even part */ \
+  \
+  tmp10 = _mm_add_pi16(row0l, row4l); \
+  tmp11 = _mm_sub_pi16(row0l, row4l); \
+  tmp13 = _mm_add_pi16(row2l, row6l); \
+  \
+  tmp12 = _mm_sub_pi16(row2l, row6l); \
+  tmp12 = _mm_slli_pi16(tmp12, PRE_MULTIPLY_SCALE_BITS); \
+  tmp12 = _mm_mulhi_pi16(tmp12, PW_F1414); \
+  tmp12 = _mm_sub_pi16(tmp12, tmp13); \
+  \
+  tmp0 = _mm_add_pi16(tmp10, tmp13); \
+  tmp3 = _mm_sub_pi16(tmp10, tmp13); \
+  tmp1 = _mm_add_pi16(tmp11, tmp12); \
+  tmp2 = _mm_sub_pi16(tmp11, tmp12); \
+  \
+  /* Odd part */ \
+  \
+  z13 = _mm_add_pi16(row5l, row3l); \
+  z10 = _mm_sub_pi16(row5l, row3l); \
+  z11 = _mm_add_pi16(row1l, row7l); \
+  z12 = _mm_sub_pi16(row1l, row7l); \
+  \
+  DO_IDCT_COMMON() \
+  \
+  /* out0=(00 01 02 03), out1=(10 11 12 13) */ \
+  /* out2=(20 21 22 23), out3=(30 31 32 33) */ \
+  /* out4=(40 41 42 43), out5=(50 51 52 53) */ \
+  /* out6=(60 61 62 63), out7=(70 71 72 73) */ \
+  \
+  out0 = _mm_srai_pi16(out0, PASS1_BITS + 3); \
+  out1 = _mm_srai_pi16(out1, PASS1_BITS + 3); \
+  out2 = _mm_srai_pi16(out2, PASS1_BITS + 3); \
+  out3 = _mm_srai_pi16(out3, PASS1_BITS + 3); \
+  out4 = _mm_srai_pi16(out4, PASS1_BITS + 3); \
+  out5 = _mm_srai_pi16(out5, PASS1_BITS + 3); \
+  out6 = _mm_srai_pi16(out6, PASS1_BITS + 3); \
+  out7 = _mm_srai_pi16(out7, PASS1_BITS + 3); \
+  \
+  row06 = _mm_packs_pi16(out0, out6);  /* row06=(00 01 02 03 60 61 62 63) */ \
+  row17 = _mm_packs_pi16(out1, out7);  /* row17=(10 11 12 13 70 71 72 73) */ \
+  row24 = _mm_packs_pi16(out2, out4);  /* row24=(20 21 22 23 40 41 42 43) */ \
+  row35 = _mm_packs_pi16(out3, out5);  /* row35=(30 31 32 33 50 51 52 53) */ \
+  \
+  row06 = _mm_add_pi8(row06, PB_CENTERJSAMP); \
+  row17 = _mm_add_pi8(row17, PB_CENTERJSAMP); \
+  row24 = _mm_add_pi8(row24, PB_CENTERJSAMP); \
+  row35 = _mm_add_pi8(row35, PB_CENTERJSAMP); \
+  \
+  /* Transpose coefficients */ \
+  \
+  col0123a = _mm_unpacklo_pi8(row06, row17);  /* col0123a=(00 10 01 11 02 12 03 13) */ \
+  col0123d = _mm_unpackhi_pi8(row06, row17);  /* col0123d=(60 70 61 71 62 72 63 73) */ \
+  col0123b = _mm_unpacklo_pi8(row24, row35);  /* col0123b=(20 30 21 31 22 32 23 33) */ \
+  col0123c = _mm_unpackhi_pi8(row24, row35);  /* col0123c=(40 50 41 51 42 52 43 53) */ \
+  \
+  col01l = _mm_unpacklo_pi16(col0123a, col0123b);  /* col01l=(00 10 20 30 01 11 21 31) */ \
+  col23l = _mm_unpackhi_pi16(col0123a, col0123b);  /* col23l=(02 12 22 32 03 13 23 33) */ \
+  col01h = _mm_unpacklo_pi16(col0123c, col0123d);  /* col01h=(40 50 60 70 41 51 61 71) */ \
+  col23h = _mm_unpackhi_pi16(col0123c, col0123d);  /* col23h=(42 52 62 72 43 53 63 73) */ \
+  \
+  col0 = _mm_unpacklo_pi32(col01l, col01h);   /* col0=(00 10 20 30 40 50 60 70) */ \
+  col1 = _mm_unpackhi_pi32(col01l, col01h);   /* col1=(01 11 21 31 41 51 61 71) */ \
+  col2 = _mm_unpacklo_pi32(col23l, col23h);   /* col2=(02 12 22 32 42 52 62 72) */ \
+  col3 = _mm_unpackhi_pi32(col23l, col23h);   /* col3=(03 13 23 33 43 53 63 73) */ \
+  \
+  _mm_store_si64((__m64 *)(output_buf[ctr + 0] + output_col), col0); \
+  _mm_store_si64((__m64 *)(output_buf[ctr + 1] + output_col), col1); \
+  _mm_store_si64((__m64 *)(output_buf[ctr + 2] + output_col), col2); \
+  _mm_store_si64((__m64 *)(output_buf[ctr + 3] + output_col), col3); \
+}
+
+void jsimd_idct_ifast_mmi(void *dct_table, JCOEFPTR coef_block,
+                          JSAMPARRAY output_buf, JDIMENSION output_col)
+{
+  __m64 tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
+  __m64 tmp10, tmp11, tmp12, tmp13;
+  __m64 out0, out1, out2, out3, out4, out5, out6, out7;
+  __m64 z5, z10, z11, z12, z13;
+  JCOEFPTR inptr;
+  ISLOW_MULT_TYPE *quantptr;
+  JCOEF *wsptr;
+  JCOEF workspace[DCTSIZE2];  /* buffers data between passes */
+
+  /* Pass 1: process columns. */
+
+  inptr = coef_block;
+  quantptr = (ISLOW_MULT_TYPE *)dct_table;
+  wsptr = workspace;
+
+  DO_IDCT_PASS1(1)
+nextcolumn1:
+  inptr += 4;
+  quantptr += 4;
+  wsptr += DCTSIZE * 4;
+  DO_IDCT_PASS1(2)
+nextcolumn2:
+
+  /* Pass 2: process rows. */
+
+  wsptr = workspace;
+
+  DO_IDCT_PASS2(0)
+  wsptr += 4;
+  DO_IDCT_PASS2(4)
+}
diff --git a/3rdparty/libjpeg/src/simd/mips64/jidctint-mmi.c b/3rdparty/libjpeg/src/simd/mips64/jidctint-mmi.c
new file mode 100644
index 00000000..cd3db980
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/mips64/jidctint-mmi.c
@@ -0,0 +1,571 @@
+/*
+ * Loongson MMI optimizations for libjpeg-turbo
+ *
+ * Copyright (C) 2014-2015, 2018, 2020, D. R. Commander.  All Rights Reserved.
+ * Copyright (C) 2016-2017, Loongson Technology Corporation Limited, BeiJing.
+ *                          All Rights Reserved.
+ * Authors:  ZhuChen     <zhuchen@loongson.cn>
+ *           CaiWanwei   <caiwanwei@loongson.cn>
+ *           SunZhangzhi <sunzhangzhi-cq@loongson.cn>
+ *
+ * Based on the x86 SIMD extension for IJG JPEG library
+ * Copyright (C) 1999-2006, MIYASAKA Masaru.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+/* ACCUATE INTEGER INVERSE DCT */
+
+#include "jsimd_mmi.h"
+
+
+#define CONST_BITS  13
+#define PASS1_BITS  2
+#define DESCALE_P1  (CONST_BITS - PASS1_BITS)
+#define DESCALE_P2  (CONST_BITS + PASS1_BITS + 3)
+#define CENTERJSAMPLE  128
+
+#define FIX_0_298  ((short)2446)  /* FIX(0.298631336) */
+#define FIX_0_390  ((short)3196)  /* FIX(0.390180644) */
+#define FIX_0_899  ((short)7373)  /* FIX(0.899976223) */
+#define FIX_0_541  ((short)4433)  /* FIX(0.541196100) */
+#define FIX_0_765  ((short)6270)  /* FIX(0.765366865) */
+#define FIX_1_175  ((short)9633)  /* FIX(1.175875602) */
+#define FIX_1_501  ((short)12299) /* FIX(1.501321110) */
+#define FIX_1_847  ((short)15137) /* FIX(1.847759065) */
+#define FIX_1_961  ((short)16069) /* FIX(1.961570560) */
+#define FIX_2_053  ((short)16819) /* FIX(2.053119869) */
+#define FIX_2_562  ((short)20995) /* FIX(2.562915447) */
+#define FIX_3_072  ((short)25172) /* FIX(3.072711026) */
+
+enum const_index {
+  index_PW_F130_F054,
+  index_PW_F054_MF130,
+  index_PW_MF078_F117,
+  index_PW_F117_F078,
+  index_PW_MF060_MF089,
+  index_PW_MF089_F060,
+  index_PW_MF050_MF256,
+  index_PW_MF256_F050,
+  index_PD_DESCALE_P1,
+  index_PD_DESCALE_P2,
+  index_PB_CENTERJSAMP
+};
+
+static uint64_t const_value[] = {
+  _uint64_set_pi16(FIX_0_541, (FIX_0_541 + FIX_0_765),
+                   FIX_0_541, (FIX_0_541 + FIX_0_765)),
+  _uint64_set_pi16((FIX_0_541 - FIX_1_847), FIX_0_541,
+                   (FIX_0_541 - FIX_1_847), FIX_0_541),
+  _uint64_set_pi16(FIX_1_175, (FIX_1_175 - FIX_1_961),
+                   FIX_1_175, (FIX_1_175 - FIX_1_961)),
+  _uint64_set_pi16((FIX_1_175 - FIX_0_390), FIX_1_175,
+                   (FIX_1_175 - FIX_0_390), FIX_1_175),
+  _uint64_set_pi16(-FIX_0_899, (FIX_0_298 - FIX_0_899),
+                   -FIX_0_899, (FIX_0_298 - FIX_0_899)),
+  _uint64_set_pi16((FIX_1_501 - FIX_0_899), -FIX_0_899,
+                   (FIX_1_501 - FIX_0_899), -FIX_0_899),
+  _uint64_set_pi16(-FIX_2_562, (FIX_2_053 - FIX_2_562),
+                   -FIX_2_562, (FIX_2_053 - FIX_2_562)),
+  _uint64_set_pi16((FIX_3_072 - FIX_2_562), -FIX_2_562,
+                   (FIX_3_072 - FIX_2_562), -FIX_2_562),
+  _uint64_set_pi32((1 << (DESCALE_P1 - 1)), (1 << (DESCALE_P1 - 1))),
+  _uint64_set_pi32((1 << (DESCALE_P2 - 1)), (1 << (DESCALE_P2 - 1))),
+  _uint64_set_pi8(CENTERJSAMPLE, CENTERJSAMPLE, CENTERJSAMPLE, CENTERJSAMPLE,
+                  CENTERJSAMPLE, CENTERJSAMPLE, CENTERJSAMPLE, CENTERJSAMPLE)
+};
+
+#define PW_F130_F054    get_const_value(index_PW_F130_F054)
+#define PW_F054_MF130   get_const_value(index_PW_F054_MF130)
+#define PW_MF078_F117   get_const_value(index_PW_MF078_F117)
+#define PW_F117_F078    get_const_value(index_PW_F117_F078)
+#define PW_MF060_MF089  get_const_value(index_PW_MF060_MF089)
+#define PW_MF089_F060   get_const_value(index_PW_MF089_F060)
+#define PW_MF050_MF256  get_const_value(index_PW_MF050_MF256)
+#define PW_MF256_F050   get_const_value(index_PW_MF256_F050)
+#define PD_DESCALE_P1   get_const_value(index_PD_DESCALE_P1)
+#define PD_DESCALE_P2   get_const_value(index_PD_DESCALE_P2)
+#define PB_CENTERJSAMP  get_const_value(index_PB_CENTERJSAMP)
+
+
+#define test_m32_zero(mm32)  (!(*(uint32_t *)&mm32))
+#define test_m64_zero(mm64)  (!(*(uint64_t *)&mm64))
+
+
+#define DO_IDCT_COMMON(PASS) { \
+  __m64 tmp0_3l, tmp0_3h, tmp1_2l, tmp1_2h; \
+  __m64 tmp0l, tmp0h, tmp1l, tmp1h, tmp2l, tmp2h, tmp3l, tmp3h; \
+  __m64 z34l, z34h, z3l, z3h, z4l, z4h, z3, z4; \
+  __m64 out0l, out0h, out1l, out1h, out2l, out2h, out3l, out3h; \
+  __m64 out4l, out4h, out5l, out5h, out6l, out6h, out7l, out7h; \
+  \
+  z3 = _mm_add_pi16(tmp0, tmp2); \
+  z4 = _mm_add_pi16(tmp1, tmp3); \
+  \
+  /* (Original) \
+   * z5 = (z3 + z4) * 1.175875602; \
+   * z3 = z3 * -1.961570560;  z4 = z4 * -0.390180644; \
+   * z3 += z5;  z4 += z5; \
+   * \
+   * (This implementation) \
+   * z3 = z3 * (1.175875602 - 1.961570560) + z4 * 1.175875602; \
+   * z4 = z3 * 1.175875602 + z4 * (1.175875602 - 0.390180644); \
+   */ \
+  \
+  z34l = _mm_unpacklo_pi16(z3, z4); \
+  z34h = _mm_unpackhi_pi16(z3, z4); \
+  z3l = _mm_madd_pi16(z34l, PW_MF078_F117); \
+  z3h = _mm_madd_pi16(z34h, PW_MF078_F117); \
+  z4l = _mm_madd_pi16(z34l, PW_F117_F078); \
+  z4h = _mm_madd_pi16(z34h, PW_F117_F078); \
+  \
+  /* (Original) \
+   * z1 = tmp0 + tmp3;  z2 = tmp1 + tmp2; \
+   * tmp0 = tmp0 * 0.298631336;  tmp1 = tmp1 * 2.053119869; \
+   * tmp2 = tmp2 * 3.072711026;  tmp3 = tmp3 * 1.501321110; \
+   * z1 = z1 * -0.899976223;  z2 = z2 * -2.562915447; \
+   * tmp0 += z1 + z3;  tmp1 += z2 + z4; \
+   * tmp2 += z2 + z3;  tmp3 += z1 + z4; \
+   * \
+   * (This implementation) \
+   * tmp0 = tmp0 * (0.298631336 - 0.899976223) + tmp3 * -0.899976223; \
+   * tmp1 = tmp1 * (2.053119869 - 2.562915447) + tmp2 * -2.562915447; \
+   * tmp2 = tmp1 * -2.562915447 + tmp2 * (3.072711026 - 2.562915447); \
+   * tmp3 = tmp0 * -0.899976223 + tmp3 * (1.501321110 - 0.899976223); \
+   * tmp0 += z3;  tmp1 += z4; \
+   * tmp2 += z3;  tmp3 += z4; \
+   */ \
+  \
+  tmp0_3l = _mm_unpacklo_pi16(tmp0, tmp3); \
+  tmp0_3h = _mm_unpackhi_pi16(tmp0, tmp3); \
+  \
+  tmp0l = _mm_madd_pi16(tmp0_3l, PW_MF060_MF089); \
+  tmp0h = _mm_madd_pi16(tmp0_3h, PW_MF060_MF089); \
+  tmp3l = _mm_madd_pi16(tmp0_3l, PW_MF089_F060); \
+  tmp3h = _mm_madd_pi16(tmp0_3h, PW_MF089_F060); \
+  \
+  tmp0l = _mm_add_pi32(tmp0l, z3l); \
+  tmp0h = _mm_add_pi32(tmp0h, z3h); \
+  tmp3l = _mm_add_pi32(tmp3l, z4l); \
+  tmp3h = _mm_add_pi32(tmp3h, z4h); \
+  \
+  tmp1_2l = _mm_unpacklo_pi16(tmp1, tmp2); \
+  tmp1_2h = _mm_unpackhi_pi16(tmp1, tmp2); \
+  \
+  tmp1l = _mm_madd_pi16(tmp1_2l, PW_MF050_MF256); \
+  tmp1h = _mm_madd_pi16(tmp1_2h, PW_MF050_MF256); \
+  tmp2l = _mm_madd_pi16(tmp1_2l, PW_MF256_F050); \
+  tmp2h = _mm_madd_pi16(tmp1_2h, PW_MF256_F050); \
+  \
+  tmp1l = _mm_add_pi32(tmp1l, z4l); \
+  tmp1h = _mm_add_pi32(tmp1h, z4h); \
+  tmp2l = _mm_add_pi32(tmp2l, z3l); \
+  tmp2h = _mm_add_pi32(tmp2h, z3h); \
+  \
+  /* Final output stage */ \
+  \
+  out0l = _mm_add_pi32(tmp10l, tmp3l); \
+  out0h = _mm_add_pi32(tmp10h, tmp3h); \
+  out7l = _mm_sub_pi32(tmp10l, tmp3l); \
+  out7h = _mm_sub_pi32(tmp10h, tmp3h); \
+  \
+  out0l = _mm_add_pi32(out0l, PD_DESCALE_P##PASS); \
+  out0h = _mm_add_pi32(out0h, PD_DESCALE_P##PASS); \
+  out0l = _mm_srai_pi32(out0l, DESCALE_P##PASS); \
+  out0h = _mm_srai_pi32(out0h, DESCALE_P##PASS); \
+  \
+  out7l = _mm_add_pi32(out7l, PD_DESCALE_P##PASS); \
+  out7h = _mm_add_pi32(out7h, PD_DESCALE_P##PASS); \
+  out7l = _mm_srai_pi32(out7l, DESCALE_P##PASS); \
+  out7h = _mm_srai_pi32(out7h, DESCALE_P##PASS); \
+  \
+  out0 = _mm_packs_pi32(out0l, out0h); \
+  out7 = _mm_packs_pi32(out7l, out7h); \
+  \
+  out1l = _mm_add_pi32(tmp11l, tmp2l); \
+  out1h = _mm_add_pi32(tmp11h, tmp2h); \
+  out6l = _mm_sub_pi32(tmp11l, tmp2l); \
+  out6h = _mm_sub_pi32(tmp11h, tmp2h); \
+  \
+  out1l = _mm_add_pi32(out1l, PD_DESCALE_P##PASS); \
+  out1h = _mm_add_pi32(out1h, PD_DESCALE_P##PASS); \
+  out1l = _mm_srai_pi32(out1l, DESCALE_P##PASS); \
+  out1h = _mm_srai_pi32(out1h, DESCALE_P##PASS); \
+  \
+  out6l = _mm_add_pi32(out6l, PD_DESCALE_P##PASS); \
+  out6h = _mm_add_pi32(out6h, PD_DESCALE_P##PASS); \
+  out6l = _mm_srai_pi32(out6l, DESCALE_P##PASS); \
+  out6h = _mm_srai_pi32(out6h, DESCALE_P##PASS); \
+  \
+  out1 = _mm_packs_pi32(out1l, out1h); \
+  out6 = _mm_packs_pi32(out6l, out6h); \
+  \
+  out2l = _mm_add_pi32(tmp12l, tmp1l); \
+  out2h = _mm_add_pi32(tmp12h, tmp1h); \
+  out5l = _mm_sub_pi32(tmp12l, tmp1l); \
+  out5h = _mm_sub_pi32(tmp12h, tmp1h); \
+  \
+  out2l = _mm_add_pi32(out2l, PD_DESCALE_P##PASS); \
+  out2h = _mm_add_pi32(out2h, PD_DESCALE_P##PASS); \
+  out2l = _mm_srai_pi32(out2l, DESCALE_P##PASS); \
+  out2h = _mm_srai_pi32(out2h, DESCALE_P##PASS); \
+  \
+  out5l = _mm_add_pi32(out5l, PD_DESCALE_P##PASS); \
+  out5h = _mm_add_pi32(out5h, PD_DESCALE_P##PASS); \
+  out5l = _mm_srai_pi32(out5l, DESCALE_P##PASS); \
+  out5h = _mm_srai_pi32(out5h, DESCALE_P##PASS); \
+  \
+  out2 = _mm_packs_pi32(out2l, out2h); \
+  out5 = _mm_packs_pi32(out5l, out5h); \
+  \
+  out3l = _mm_add_pi32(tmp13l, tmp0l); \
+  out3h = _mm_add_pi32(tmp13h, tmp0h); \
+  \
+  out4l = _mm_sub_pi32(tmp13l, tmp0l); \
+  out4h = _mm_sub_pi32(tmp13h, tmp0h); \
+  \
+  out3l = _mm_add_pi32(out3l, PD_DESCALE_P##PASS); \
+  out3h = _mm_add_pi32(out3h, PD_DESCALE_P##PASS); \
+  out3l = _mm_srai_pi32(out3l, DESCALE_P##PASS); \
+  out3h = _mm_srai_pi32(out3h, DESCALE_P##PASS); \
+  \
+  out4l = _mm_add_pi32(out4l, PD_DESCALE_P##PASS); \
+  out4h = _mm_add_pi32(out4h, PD_DESCALE_P##PASS); \
+  out4l = _mm_srai_pi32(out4l, DESCALE_P##PASS); \
+  out4h = _mm_srai_pi32(out4h, DESCALE_P##PASS); \
+  \
+  out3 = _mm_packs_pi32(out3l, out3h); \
+  out4 = _mm_packs_pi32(out4l, out4h); \
+}
+
+#define DO_IDCT_PASS1(iter) { \
+  __m64 col0l, col1l, col2l, col3l, col4l, col5l, col6l, col7l; \
+  __m64 quant0l, quant1l, quant2l, quant3l; \
+  __m64 quant4l, quant5l, quant6l, quant7l; \
+  __m64 z23, z2, z3, z23l, z23h; \
+  __m64 row01a, row01b, row01c, row01d, row23a, row23b, row23c, row23d; \
+  __m64 row0l, row0h, row1l, row1h, row2l, row2h, row3l, row3h; \
+  __m64 tmp0l, tmp0h, tmp1l, tmp1h, tmp2l, tmp2h, tmp3l, tmp3h; \
+  __m64 tmp10l, tmp10h, tmp11l, tmp11h, tmp12l, tmp12h, tmp13l, tmp13h; \
+  __m32 col0a, col1a, mm0; \
+  \
+  col0a = _mm_load_si32((__m32 *)&inptr[DCTSIZE * 1]); \
+  col1a = _mm_load_si32((__m32 *)&inptr[DCTSIZE * 2]); \
+  mm0 = _mm_or_si32(col0a, col1a); \
+  \
+  if (test_m32_zero(mm0)) { \
+    __m64 mm1, mm2; \
+    \
+    col0l = _mm_load_si64((__m64 *)&inptr[DCTSIZE * 0]); \
+    col1l = _mm_load_si64((__m64 *)&inptr[DCTSIZE * 1]); \
+    col2l = _mm_load_si64((__m64 *)&inptr[DCTSIZE * 2]); \
+    col3l = _mm_load_si64((__m64 *)&inptr[DCTSIZE * 3]); \
+    col4l = _mm_load_si64((__m64 *)&inptr[DCTSIZE * 4]); \
+    col5l = _mm_load_si64((__m64 *)&inptr[DCTSIZE * 5]); \
+    col6l = _mm_load_si64((__m64 *)&inptr[DCTSIZE * 6]); \
+    col7l = _mm_load_si64((__m64 *)&inptr[DCTSIZE * 7]); \
+    \
+    mm1 = _mm_or_si64(col1l, col3l); \
+    mm2 = _mm_or_si64(col2l, col4l); \
+    mm1 = _mm_or_si64(mm1, col5l); \
+    mm2 = _mm_or_si64(mm2, col6l); \
+    mm1 = _mm_or_si64(mm1, col7l); \
+    mm1 = _mm_or_si64(mm1, mm2); \
+    \
+    if (test_m64_zero(mm1)) { \
+      __m64 dcval, dcvall, dcvalh, row0, row1, row2, row3; \
+      \
+      /* AC terms all zero */ \
+      \
+      quant0l = _mm_load_si64((__m64 *)&quantptr[DCTSIZE * 0]); \
+      \
+      dcval = _mm_mullo_pi16(col0l, quant0l); \
+      dcval = _mm_slli_pi16(dcval, PASS1_BITS);  /* dcval=(00 10 20 30) */ \
+      \
+      dcvall = _mm_unpacklo_pi16(dcval, dcval);  /* dcvall=(00 00 10 10) */ \
+      dcvalh = _mm_unpackhi_pi16(dcval, dcval);  /* dcvalh=(20 20 30 30) */ \
+      \
+      row0 = _mm_unpacklo_pi32(dcvall, dcvall);  /* row0=(00 00 00 00) */ \
+      row1 = _mm_unpackhi_pi32(dcvall, dcvall);  /* row1=(10 10 10 10) */ \
+      row2 = _mm_unpacklo_pi32(dcvalh, dcvalh);  /* row2=(20 20 20 20) */ \
+      row3 = _mm_unpackhi_pi32(dcvalh, dcvalh);  /* row3=(30 30 30 30) */ \
+      \
+      _mm_store_si64((__m64 *)&wsptr[DCTSIZE * 0], row0); \
+      _mm_store_si64((__m64 *)&wsptr[DCTSIZE * 0 + 4], row0); \
+      _mm_store_si64((__m64 *)&wsptr[DCTSIZE * 1], row1); \
+      _mm_store_si64((__m64 *)&wsptr[DCTSIZE * 1 + 4], row1); \
+      _mm_store_si64((__m64 *)&wsptr[DCTSIZE * 2], row2); \
+      _mm_store_si64((__m64 *)&wsptr[DCTSIZE * 2 + 4], row2); \
+      _mm_store_si64((__m64 *)&wsptr[DCTSIZE * 3], row3); \
+      _mm_store_si64((__m64 *)&wsptr[DCTSIZE * 3 + 4], row3); \
+      \
+      goto nextcolumn##iter; \
+    } \
+  } \
+  \
+  /* Even part \
+   * \
+   * (Original) \
+   * z1 = (z2 + z3) * 0.541196100; \
+   * tmp2 = z1 + z3 * -1.847759065; \
+   * tmp3 = z1 + z2 * 0.765366865; \
+   * \
+   * (This implementation) \
+   * tmp2 = z2 * 0.541196100 + z3 * (0.541196100 - 1.847759065); \
+   * tmp3 = z2 * (0.541196100 + 0.765366865) + z3 * 0.541196100; \
+   */ \
+  \
+  col0l = _mm_load_si64((__m64 *)&inptr[DCTSIZE * 0]);  /* (00 10 20 30) */ \
+  col2l = _mm_load_si64((__m64 *)&inptr[DCTSIZE * 2]);  /* (02 12 22 32) */ \
+  col4l = _mm_load_si64((__m64 *)&inptr[DCTSIZE * 4]);  /* (04 14 24 34) */ \
+  col6l = _mm_load_si64((__m64 *)&inptr[DCTSIZE * 6]);  /* (06 16 26 36) */ \
+  \
+  quant0l = _mm_load_si64((__m64 *)&quantptr[DCTSIZE * 0]); \
+  quant2l = _mm_load_si64((__m64 *)&quantptr[DCTSIZE * 2]); \
+  quant4l = _mm_load_si64((__m64 *)&quantptr[DCTSIZE * 4]); \
+  quant6l = _mm_load_si64((__m64 *)&quantptr[DCTSIZE * 6]); \
+  \
+  z2 = _mm_mullo_pi16(col2l, quant2l); \
+  z3 = _mm_mullo_pi16(col6l, quant6l); \
+  \
+  z23l = _mm_unpacklo_pi16(z2, z3); \
+  z23h = _mm_unpackhi_pi16(z2, z3); \
+  tmp3l = _mm_madd_pi16(z23l, PW_F130_F054); \
+  tmp3h = _mm_madd_pi16(z23h, PW_F130_F054); \
+  tmp2l = _mm_madd_pi16(z23l, PW_F054_MF130); \
+  tmp2h = _mm_madd_pi16(z23h, PW_F054_MF130); \
+  \
+  z2 = _mm_mullo_pi16(col0l, quant0l); \
+  z3 = _mm_mullo_pi16(col4l, quant4l); \
+  \
+  z23 = _mm_add_pi16(z2, z3); \
+  tmp0l = _mm_loadlo_pi16_f(z23); \
+  tmp0h = _mm_loadhi_pi16_f(z23); \
+  tmp0l = _mm_srai_pi32(tmp0l, (16 - CONST_BITS)); \
+  tmp0h = _mm_srai_pi32(tmp0h, (16 - CONST_BITS)); \
+  \
+  tmp10l = _mm_add_pi32(tmp0l, tmp3l); \
+  tmp10h = _mm_add_pi32(tmp0h, tmp3h); \
+  tmp13l = _mm_sub_pi32(tmp0l, tmp3l); \
+  tmp13h = _mm_sub_pi32(tmp0h, tmp3h); \
+  \
+  z23 = _mm_sub_pi16(z2, z3); \
+  tmp1l = _mm_loadlo_pi16_f(z23); \
+  tmp1h = _mm_loadhi_pi16_f(z23); \
+  tmp1l = _mm_srai_pi32(tmp1l, (16 - CONST_BITS)); \
+  tmp1h = _mm_srai_pi32(tmp1h, (16 - CONST_BITS)); \
+  \
+  tmp11l = _mm_add_pi32(tmp1l, tmp2l); \
+  tmp11h = _mm_add_pi32(tmp1h, tmp2h); \
+  tmp12l = _mm_sub_pi32(tmp1l, tmp2l); \
+  tmp12h = _mm_sub_pi32(tmp1h, tmp2h); \
+  \
+  /* Odd part */ \
+  \
+  col1l = _mm_load_si64((__m64 *)&inptr[DCTSIZE * 1]);  /* (01 11 21 31) */ \
+  col3l = _mm_load_si64((__m64 *)&inptr[DCTSIZE * 3]);  /* (03 13 23 33) */ \
+  col5l = _mm_load_si64((__m64 *)&inptr[DCTSIZE * 5]);  /* (05 15 25 35) */ \
+  col7l = _mm_load_si64((__m64 *)&inptr[DCTSIZE * 7]);  /* (07 17 27 37) */ \
+  \
+  quant1l = _mm_load_si64((__m64 *)&quantptr[DCTSIZE * 1]); \
+  quant3l = _mm_load_si64((__m64 *)&quantptr[DCTSIZE * 3]); \
+  quant5l = _mm_load_si64((__m64 *)&quantptr[DCTSIZE * 5]); \
+  quant7l = _mm_load_si64((__m64 *)&quantptr[DCTSIZE * 7]); \
+  \
+  tmp0 = _mm_mullo_pi16(col7l, quant7l); \
+  tmp1 = _mm_mullo_pi16(col5l, quant5l); \
+  tmp2 = _mm_mullo_pi16(col3l, quant3l); \
+  tmp3 = _mm_mullo_pi16(col1l, quant1l); \
+  \
+  DO_IDCT_COMMON(1) \
+  \
+  /* out0=(00 10 20 30), out1=(01 11 21 31) */ \
+  /* out2=(02 12 22 32), out3=(03 13 23 33) */ \
+  /* out4=(04 14 24 34), out5=(05 15 25 35) */ \
+  /* out6=(06 16 26 36), out7=(07 17 27 37) */ \
+  \
+  /* Transpose coefficients */ \
+  \
+  row01a = _mm_unpacklo_pi16(out0, out1);     /* row01a=(00 01 10 11) */ \
+  row23a = _mm_unpackhi_pi16(out0, out1);     /* row23a=(20 21 30 31) */ \
+  row01d = _mm_unpacklo_pi16(out6, out7);     /* row01d=(06 07 16 17) */ \
+  row23d = _mm_unpackhi_pi16(out6, out7);     /* row23d=(26 27 36 37) */ \
+  \
+  row01b = _mm_unpacklo_pi16(out2, out3);     /* row01b=(02 03 12 13) */ \
+  row23b = _mm_unpackhi_pi16(out2, out3);     /* row23b=(22 23 32 33) */ \
+  row01c = _mm_unpacklo_pi16(out4, out5);     /* row01c=(04 05 14 15) */ \
+  row23c = _mm_unpackhi_pi16(out4, out5);     /* row23c=(24 25 34 35) */ \
+  \
+  row0l = _mm_unpacklo_pi32(row01a, row01b);  /* row0l=(00 01 02 03) */ \
+  row1l = _mm_unpackhi_pi32(row01a, row01b);  /* row1l=(10 11 12 13) */ \
+  row2l = _mm_unpacklo_pi32(row23a, row23b);  /* row2l=(20 21 22 23) */ \
+  row3l = _mm_unpackhi_pi32(row23a, row23b);  /* row3l=(30 31 32 33) */ \
+  \
+  row0h = _mm_unpacklo_pi32(row01c, row01d);  /* row0h=(04 05 06 07) */ \
+  row1h = _mm_unpackhi_pi32(row01c, row01d);  /* row1h=(14 15 16 17) */ \
+  row2h = _mm_unpacklo_pi32(row23c, row23d);  /* row2h=(24 25 26 27) */ \
+  row3h = _mm_unpackhi_pi32(row23c, row23d);  /* row3h=(34 35 36 37) */ \
+  \
+  _mm_store_si64((__m64 *)&wsptr[DCTSIZE * 0], row0l); \
+  _mm_store_si64((__m64 *)&wsptr[DCTSIZE * 0 + 4], row0h); \
+  _mm_store_si64((__m64 *)&wsptr[DCTSIZE * 1], row1l); \
+  _mm_store_si64((__m64 *)&wsptr[DCTSIZE * 1 + 4], row1h); \
+  _mm_store_si64((__m64 *)&wsptr[DCTSIZE * 2], row2l); \
+  _mm_store_si64((__m64 *)&wsptr[DCTSIZE * 2 + 4], row2h); \
+  _mm_store_si64((__m64 *)&wsptr[DCTSIZE * 3], row3l); \
+  _mm_store_si64((__m64 *)&wsptr[DCTSIZE * 3 + 4], row3h); \
+}
+
+#define DO_IDCT_PASS2(ctr) { \
+  __m64 row0l, row1l, row2l, row3l, row4l, row5l, row6l, row7l; \
+  __m64 z23, z23l, z23h; \
+  __m64 col0123a, col0123b, col0123c, col0123d; \
+  __m64 col01l, col01h, col23l, col23h, row06, row17, row24, row35; \
+  __m64 col0, col1, col2, col3; \
+  __m64 tmp0l, tmp0h, tmp1l, tmp1h, tmp2l, tmp2h, tmp3l, tmp3h; \
+  __m64 tmp10l, tmp10h, tmp11l, tmp11h, tmp12l, tmp12h, tmp13l, tmp13h; \
+  \
+  row0l = _mm_load_si64((__m64 *)&wsptr[DCTSIZE * 0]);  /* (00 01 02 03) */ \
+  row1l = _mm_load_si64((__m64 *)&wsptr[DCTSIZE * 1]);  /* (10 11 12 13) */ \
+  row2l = _mm_load_si64((__m64 *)&wsptr[DCTSIZE * 2]);  /* (20 21 22 23) */ \
+  row3l = _mm_load_si64((__m64 *)&wsptr[DCTSIZE * 3]);  /* (30 31 32 33) */ \
+  row4l = _mm_load_si64((__m64 *)&wsptr[DCTSIZE * 4]);  /* (40 41 42 43) */ \
+  row5l = _mm_load_si64((__m64 *)&wsptr[DCTSIZE * 5]);  /* (50 51 52 53) */ \
+  row6l = _mm_load_si64((__m64 *)&wsptr[DCTSIZE * 6]);  /* (60 61 62 63) */ \
+  row7l = _mm_load_si64((__m64 *)&wsptr[DCTSIZE * 7]);  /* (70 71 72 73) */ \
+  \
+  /* Even part \
+   * \
+   * (Original) \
+   * z1 = (z2 + z3) * 0.541196100; \
+   * tmp2 = z1 + z3 * -1.847759065; \
+   * tmp3 = z1 + z2 * 0.765366865; \
+   * \
+   * (This implementation) \
+   * tmp2 = z2 * 0.541196100 + z3 * (0.541196100 - 1.847759065); \
+   * tmp3 = z2 * (0.541196100 + 0.765366865) + z3 * 0.541196100; \
+   */ \
+  \
+  z23l = _mm_unpacklo_pi16(row2l, row6l); \
+  z23h = _mm_unpackhi_pi16(row2l, row6l); \
+  \
+  tmp3l = _mm_madd_pi16(z23l, PW_F130_F054); \
+  tmp3h = _mm_madd_pi16(z23h, PW_F130_F054); \
+  tmp2l = _mm_madd_pi16(z23l, PW_F054_MF130); \
+  tmp2h = _mm_madd_pi16(z23h, PW_F054_MF130); \
+  \
+  z23 = _mm_add_pi16(row0l, row4l); \
+  tmp0l = _mm_loadlo_pi16_f(z23); \
+  tmp0h = _mm_loadhi_pi16_f(z23); \
+  tmp0l = _mm_srai_pi32(tmp0l, (16 - CONST_BITS)); \
+  tmp0h = _mm_srai_pi32(tmp0h, (16 - CONST_BITS)); \
+  \
+  tmp10l = _mm_add_pi32(tmp0l, tmp3l); \
+  tmp10h = _mm_add_pi32(tmp0h, tmp3h); \
+  tmp13l = _mm_sub_pi32(tmp0l, tmp3l); \
+  tmp13h = _mm_sub_pi32(tmp0h, tmp3h); \
+  \
+  z23 = _mm_sub_pi16(row0l, row4l); \
+  tmp1l = _mm_loadlo_pi16_f(z23); \
+  tmp1h = _mm_loadhi_pi16_f(z23); \
+  tmp1l = _mm_srai_pi32(tmp1l, (16 - CONST_BITS)); \
+  tmp1h = _mm_srai_pi32(tmp1h, (16 - CONST_BITS)); \
+  \
+  tmp11l = _mm_add_pi32(tmp1l, tmp2l); \
+  tmp11h = _mm_add_pi32(tmp1h, tmp2h); \
+  tmp12l = _mm_sub_pi32(tmp1l, tmp2l); \
+  tmp12h = _mm_sub_pi32(tmp1h, tmp2h); \
+  \
+  /* Odd part */ \
+  \
+  tmp0 = row7l; \
+  tmp1 = row5l; \
+  tmp2 = row3l; \
+  tmp3 = row1l; \
+  \
+  DO_IDCT_COMMON(2) \
+  \
+  /* out0=(00 01 02 03), out1=(10 11 12 13) */ \
+  /* out2=(20 21 22 23), out3=(30 31 32 33) */ \
+  /* out4=(40 41 42 43), out5=(50 51 52 53) */ \
+  /* out6=(60 61 62 63), out7=(70 71 72 73) */ \
+  \
+  row06 = _mm_packs_pi16(out0, out6);  /* row06=(00 01 02 03 60 61 62 63) */ \
+  row17 = _mm_packs_pi16(out1, out7);  /* row17=(10 11 12 13 70 71 72 73) */ \
+  row24 = _mm_packs_pi16(out2, out4);  /* row24=(20 21 22 23 40 41 42 43) */ \
+  row35 = _mm_packs_pi16(out3, out5);  /* row35=(30 31 32 33 50 51 52 53) */ \
+  \
+  row06 = _mm_add_pi8(row06, PB_CENTERJSAMP); \
+  row17 = _mm_add_pi8(row17, PB_CENTERJSAMP); \
+  row24 = _mm_add_pi8(row24, PB_CENTERJSAMP); \
+  row35 = _mm_add_pi8(row35, PB_CENTERJSAMP); \
+  \
+  /* Transpose coefficients */ \
+  \
+  col0123a = _mm_unpacklo_pi8(row06, row17);  /* col0123a=(00 10 01 11 02 12 03 13) */ \
+  col0123d = _mm_unpackhi_pi8(row06, row17);  /* col0123d=(60 70 61 71 62 72 63 73) */ \
+  col0123b = _mm_unpacklo_pi8(row24, row35);  /* col0123b=(20 30 21 31 22 32 23 33) */ \
+  col0123c = _mm_unpackhi_pi8(row24, row35);  /* col0123c=(40 50 41 51 42 52 43 53) */ \
+  \
+  col01l = _mm_unpacklo_pi16(col0123a, col0123b);  /* col01l=(00 10 20 30 01 11 21 31) */ \
+  col23l = _mm_unpackhi_pi16(col0123a, col0123b);  /* col23l=(02 12 22 32 03 13 23 33) */ \
+  col01h = _mm_unpacklo_pi16(col0123c, col0123d);  /* col01h=(40 50 60 70 41 51 61 71) */ \
+  col23h = _mm_unpackhi_pi16(col0123c, col0123d);  /* col23h=(42 52 62 72 43 53 63 73) */ \
+  \
+  col0 = _mm_unpacklo_pi32(col01l, col01h);   /* col0=(00 10 20 30 40 50 60 70) */ \
+  col1 = _mm_unpackhi_pi32(col01l, col01h);   /* col1=(01 11 21 31 41 51 61 71) */ \
+  col2 = _mm_unpacklo_pi32(col23l, col23h);   /* col2=(02 12 22 32 42 52 62 72) */ \
+  col3 = _mm_unpackhi_pi32(col23l, col23h);   /* col3=(03 13 23 33 43 53 63 73) */ \
+  \
+  _mm_store_si64((__m64 *)(output_buf[ctr + 0] + output_col), col0); \
+  _mm_store_si64((__m64 *)(output_buf[ctr + 1] + output_col), col1); \
+  _mm_store_si64((__m64 *)(output_buf[ctr + 2] + output_col), col2); \
+  _mm_store_si64((__m64 *)(output_buf[ctr + 3] + output_col), col3); \
+}
+
+void jsimd_idct_islow_mmi(void *dct_table, JCOEFPTR coef_block,
+                          JSAMPARRAY output_buf, JDIMENSION output_col)
+{
+  __m64 tmp0, tmp1, tmp2, tmp3;
+  __m64 out0, out1, out2, out3, out4, out5, out6, out7;
+  JCOEFPTR inptr;
+  ISLOW_MULT_TYPE *quantptr;
+  JCOEF *wsptr;
+  JCOEF workspace[DCTSIZE2];  /* buffers data between passes */
+
+  /* Pass 1: process columns. */
+
+  inptr = coef_block;
+  quantptr = (ISLOW_MULT_TYPE *)dct_table;
+  wsptr = workspace;
+
+  DO_IDCT_PASS1(1)
+nextcolumn1:
+  inptr += 4;
+  quantptr += 4;
+  wsptr += DCTSIZE * 4;
+  DO_IDCT_PASS1(2)
+nextcolumn2:
+
+  /* Pass 2: process rows. */
+
+  wsptr = workspace;
+
+  DO_IDCT_PASS2(0)
+  wsptr += 4;
+  DO_IDCT_PASS2(4)
+}
diff --git a/3rdparty/libjpeg/src/simd/mips64/jquanti-mmi.c b/3rdparty/libjpeg/src/simd/mips64/jquanti-mmi.c
new file mode 100644
index 00000000..339002fd
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/mips64/jquanti-mmi.c
@@ -0,0 +1,124 @@
+/*
+ * Loongson MMI optimizations for libjpeg-turbo
+ *
+ * Copyright (C) 2016-2017, Loongson Technology Corporation Limited, BeiJing.
+ *                          All Rights Reserved.
+ * Authors:  ZhuChen     <zhuchen@loongson.cn>
+ *           CaiWanwei   <caiwanwei@loongson.cn>
+ *           SunZhangzhi <sunzhangzhi-cq@loongson.cn>
+ * Copyright (C) 2018-2019, D. R. Commander.  All Rights Reserved.
+ *
+ * Based on the x86 SIMD extension for IJG JPEG library
+ * Copyright (C) 1999-2006, MIYASAKA Masaru.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+/* INTEGER QUANTIZATION AND SAMPLE CONVERSION */
+
+#include "jsimd_mmi.h"
+
+
+#define DO_QUANT() { \
+  __m64 rowl, rowh, rowls, rowhs, rowlsave, rowhsave; \
+  __m64 corrl, corrh, recipl, reciph, scalel, scaleh; \
+  \
+  rowl = _mm_load_si64((__m64 *)&workspace[0]); \
+  rowh = _mm_load_si64((__m64 *)&workspace[4]); \
+  \
+  /* Branch-less absolute value */ \
+  rowls = _mm_srai_pi16(rowl, (WORD_BIT - 1));  /* -1 if value < 0, */ \
+                                                /* 0 otherwise */ \
+  rowhs = _mm_srai_pi16(rowh, (WORD_BIT - 1)); \
+  \
+  rowl = _mm_xor_si64(rowl, rowls);           /* val = -val */ \
+  rowh = _mm_xor_si64(rowh, rowhs); \
+  rowl = _mm_sub_pi16(rowl, rowls); \
+  rowh = _mm_sub_pi16(rowh, rowhs); \
+  \
+  corrl = _mm_load_si64((__m64 *)&divisors[DCTSIZE2 * 1]);  /* correction */ \
+  corrh = _mm_load_si64((__m64 *)&divisors[DCTSIZE2 * 1 + 4]); \
+  \
+  rowlsave = rowl = _mm_add_pi16(rowl, corrl);  /* correction + roundfactor */ \
+  rowhsave = rowh = _mm_add_pi16(rowh, corrh); \
+  \
+  recipl = _mm_load_si64((__m64 *)&divisors[DCTSIZE2 * 0]);  /* reciprocal */ \
+  reciph = _mm_load_si64((__m64 *)&divisors[DCTSIZE2 * 0 + 4]); \
+  \
+  rowl = _mm_mulhi_pi16(rowl, recipl); \
+  rowh = _mm_mulhi_pi16(rowh, reciph); \
+  \
+  /* reciprocal is always negative (MSB=1), so we always need to add the */ \
+  /* initial value (input value is never negative as we inverted it at the */ \
+  /* start of this routine) */ \
+  rowlsave = rowl = _mm_add_pi16(rowl, rowlsave); \
+  rowhsave = rowh = _mm_add_pi16(rowh, rowhsave); \
+  \
+  scalel = _mm_load_si64((__m64 *)&divisors[DCTSIZE2 * 2]);  /* scale */ \
+  scaleh = _mm_load_si64((__m64 *)&divisors[DCTSIZE2 * 2 + 4]); \
+  \
+  rowl = _mm_mulhi_pi16(rowl, scalel); \
+  rowh = _mm_mulhi_pi16(rowh, scaleh); \
+  \
+  /* determine if scale is negative */ \
+  scalel = _mm_srai_pi16(scalel, (WORD_BIT - 1)); \
+  scaleh = _mm_srai_pi16(scaleh, (WORD_BIT - 1)); \
+  \
+  /* and add input if it is */ \
+  scalel = _mm_and_si64(scalel, rowlsave); \
+  scaleh = _mm_and_si64(scaleh, rowhsave); \
+  rowl = _mm_add_pi16(rowl, scalel); \
+  rowh = _mm_add_pi16(rowh, scaleh); \
+  \
+  /* then check if negative input */ \
+  rowlsave = _mm_srai_pi16(rowlsave, (WORD_BIT - 1)); \
+  rowhsave = _mm_srai_pi16(rowhsave, (WORD_BIT - 1)); \
+  \
+  /* and add scale if it is */ \
+  rowlsave = _mm_and_si64(rowlsave, scalel); \
+  rowhsave = _mm_and_si64(rowhsave, scaleh); \
+  rowl = _mm_add_pi16(rowl, rowlsave); \
+  rowh = _mm_add_pi16(rowh, rowhsave); \
+  \
+  rowl = _mm_xor_si64(rowl, rowls);           /* val = -val */ \
+  rowh = _mm_xor_si64(rowh, rowhs); \
+  rowl = _mm_sub_pi16(rowl, rowls); \
+  rowh = _mm_sub_pi16(rowh, rowhs); \
+  \
+  _mm_store_si64((__m64 *)&output_ptr[0], rowl); \
+  _mm_store_si64((__m64 *)&output_ptr[4], rowh); \
+  \
+  workspace += DCTSIZE; \
+  divisors += DCTSIZE; \
+  output_ptr += DCTSIZE; \
+}
+
+
+void jsimd_quantize_mmi(JCOEFPTR coef_block, DCTELEM *divisors,
+                        DCTELEM *workspace)
+{
+  JCOEFPTR output_ptr = coef_block;
+
+  DO_QUANT()
+  DO_QUANT()
+  DO_QUANT()
+  DO_QUANT()
+  DO_QUANT()
+  DO_QUANT()
+  DO_QUANT()
+  DO_QUANT()
+}
diff --git a/3rdparty/libjpeg/src/simd/mips64/jsimd.c b/3rdparty/libjpeg/src/simd/mips64/jsimd.c
new file mode 100644
index 00000000..e8f1af56
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/mips64/jsimd.c
@@ -0,0 +1,870 @@
+/*
+ * jsimd_mips64.c
+ *
+ * Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+ * Copyright (C) 2009-2011, 2014, 2016, 2018, D. R. Commander.
+ * Copyright (C) 2013-2014, MIPS Technologies, Inc., California.
+ * Copyright (C) 2015, 2018, Matthieu Darbois.
+ * Copyright (C) 2016-2018, Loongson Technology Corporation Limited, BeiJing.
+ *
+ * Based on the x86 SIMD extension for IJG JPEG library,
+ * Copyright (C) 1999-2006, MIYASAKA Masaru.
+ * For conditions of distribution and use, see copyright notice in jsimdext.inc
+ *
+ * This file contains the interface between the "normal" portions
+ * of the library and the SIMD implementations when running on a
+ * 64-bit MIPS architecture.
+ */
+
+#define JPEG_INTERNALS
+#include "../../jinclude.h"
+#include "../../jpeglib.h"
+#include "../../jsimd.h"
+#include "../../jdct.h"
+#include "../../jsimddct.h"
+#include "../jsimd.h"
+
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+
+static unsigned int simd_support = ~0;
+
+#if defined(__linux__)
+
+#define SOMEWHAT_SANE_PROC_CPUINFO_SIZE_LIMIT  (1024 * 1024)
+
+LOCAL(int)
+check_feature(char *buffer, char *feature)
+{
+  char *p;
+
+  if (*feature == 0)
+    return 0;
+  if (strncmp(buffer, "ASEs implemented", 16) != 0)
+    return 0;
+  buffer += 16;
+  while (isspace(*buffer))
+    buffer++;
+
+  /* Check if 'feature' is present in the buffer as a separate word */
+  while ((p = strstr(buffer, feature))) {
+    if (p > buffer && !isspace(*(p - 1))) {
+      buffer++;
+      continue;
+    }
+    p += strlen(feature);
+    if (*p != 0 && !isspace(*p)) {
+      buffer++;
+      continue;
+    }
+    return 1;
+  }
+  return 0;
+}
+
+LOCAL(int)
+parse_proc_cpuinfo(int bufsize)
+{
+  char *buffer = (char *)malloc(bufsize);
+  FILE *fd;
+
+  simd_support = 0;
+
+  if (!buffer)
+    return 0;
+
+  fd = fopen("/proc/cpuinfo", "r");
+  if (fd) {
+    while (fgets(buffer, bufsize, fd)) {
+      if (!strchr(buffer, '\n') && !feof(fd)) {
+        /* "impossible" happened - insufficient size of the buffer! */
+        fclose(fd);
+        free(buffer);
+        return 0;
+      }
+      if (check_feature(buffer, "loongson-mmi"))
+        simd_support |= JSIMD_MMI;
+    }
+    fclose(fd);
+  }
+  free(buffer);
+  return 1;
+}
+
+#endif
+
+/*
+ * Check what SIMD accelerations are supported.
+ *
+ * FIXME: This code is racy under a multi-threaded environment.
+ */
+LOCAL(void)
+init_simd(void)
+{
+#ifndef NO_GETENV
+  char *env = NULL;
+#endif
+#if defined(__linux__)
+  int bufsize = 1024; /* an initial guess for the line buffer size limit */
+#endif
+
+  if (simd_support != ~0U)
+    return;
+
+  simd_support = 0;
+
+#if defined(__linux__)
+  while (!parse_proc_cpuinfo(bufsize)) {
+    bufsize *= 2;
+    if (bufsize > SOMEWHAT_SANE_PROC_CPUINFO_SIZE_LIMIT)
+      break;
+  }
+#elif defined(__mips_loongson_vector_rev)
+  /* Only enable MMI by default on non-Linux platforms when the compiler flags
+   * support it. */
+  simd_support |= JSIMD_MMI;
+#endif
+
+#ifndef NO_GETENV
+  /* Force different settings through environment variables */
+  env = getenv("JSIMD_FORCEMMI");
+  if ((env != NULL) && (strcmp(env, "1") == 0))
+    simd_support = JSIMD_MMI;
+  env = getenv("JSIMD_FORCENONE");
+  if ((env != NULL) && (strcmp(env, "1") == 0))
+    simd_support = 0;
+#endif
+}
+
+GLOBAL(int)
+jsimd_can_rgb_ycc(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+  if ((RGB_PIXELSIZE != 3) && (RGB_PIXELSIZE != 4))
+    return 0;
+
+  if (simd_support & JSIMD_MMI)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_rgb_gray(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+  if ((RGB_PIXELSIZE != 3) && (RGB_PIXELSIZE != 4))
+    return 0;
+
+  if (simd_support & JSIMD_MMI)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_ycc_rgb(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+  if ((RGB_PIXELSIZE != 3) && (RGB_PIXELSIZE != 4))
+    return 0;
+
+  if (simd_support & JSIMD_MMI)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_ycc_rgb565(void)
+{
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_c_can_null_convert(void)
+{
+  return 0;
+}
+
+GLOBAL(void)
+jsimd_rgb_ycc_convert(j_compress_ptr cinfo, JSAMPARRAY input_buf,
+                      JSAMPIMAGE output_buf, JDIMENSION output_row,
+                      int num_rows)
+{
+  void (*mmifct) (JDIMENSION, JSAMPARRAY, JSAMPIMAGE, JDIMENSION, int);
+
+  switch (cinfo->in_color_space) {
+  case JCS_EXT_RGB:
+    mmifct = jsimd_extrgb_ycc_convert_mmi;
+    break;
+  case JCS_EXT_RGBX:
+  case JCS_EXT_RGBA:
+    mmifct = jsimd_extrgbx_ycc_convert_mmi;
+    break;
+  case JCS_EXT_BGR:
+    mmifct = jsimd_extbgr_ycc_convert_mmi;
+    break;
+  case JCS_EXT_BGRX:
+  case JCS_EXT_BGRA:
+    mmifct = jsimd_extbgrx_ycc_convert_mmi;
+    break;
+  case JCS_EXT_XBGR:
+  case JCS_EXT_ABGR:
+    mmifct = jsimd_extxbgr_ycc_convert_mmi;
+    break;
+  case JCS_EXT_XRGB:
+  case JCS_EXT_ARGB:
+    mmifct = jsimd_extxrgb_ycc_convert_mmi;
+    break;
+  default:
+    mmifct = jsimd_rgb_ycc_convert_mmi;
+    break;
+  }
+
+  mmifct(cinfo->image_width, input_buf, output_buf, output_row, num_rows);
+}
+
+GLOBAL(void)
+jsimd_rgb_gray_convert(j_compress_ptr cinfo, JSAMPARRAY input_buf,
+                       JSAMPIMAGE output_buf, JDIMENSION output_row,
+                       int num_rows)
+{
+  void (*mmifct) (JDIMENSION, JSAMPARRAY, JSAMPIMAGE, JDIMENSION, int);
+
+  switch (cinfo->in_color_space) {
+  case JCS_EXT_RGB:
+    mmifct = jsimd_extrgb_gray_convert_mmi;
+    break;
+  case JCS_EXT_RGBX:
+  case JCS_EXT_RGBA:
+    mmifct = jsimd_extrgbx_gray_convert_mmi;
+    break;
+  case JCS_EXT_BGR:
+    mmifct = jsimd_extbgr_gray_convert_mmi;
+    break;
+  case JCS_EXT_BGRX:
+  case JCS_EXT_BGRA:
+    mmifct = jsimd_extbgrx_gray_convert_mmi;
+    break;
+  case JCS_EXT_XBGR:
+  case JCS_EXT_ABGR:
+    mmifct = jsimd_extxbgr_gray_convert_mmi;
+    break;
+  case JCS_EXT_XRGB:
+  case JCS_EXT_ARGB:
+    mmifct = jsimd_extxrgb_gray_convert_mmi;
+    break;
+  default:
+    mmifct = jsimd_rgb_gray_convert_mmi;
+    break;
+  }
+
+  mmifct(cinfo->image_width, input_buf, output_buf, output_row, num_rows);
+}
+
+GLOBAL(void)
+jsimd_ycc_rgb_convert(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
+                      JDIMENSION input_row, JSAMPARRAY output_buf,
+                      int num_rows)
+{
+  void (*mmifct) (JDIMENSION, JSAMPIMAGE, JDIMENSION, JSAMPARRAY, int);
+
+  switch (cinfo->out_color_space) {
+  case JCS_EXT_RGB:
+    mmifct = jsimd_ycc_extrgb_convert_mmi;
+    break;
+  case JCS_EXT_RGBX:
+  case JCS_EXT_RGBA:
+    mmifct = jsimd_ycc_extrgbx_convert_mmi;
+    break;
+  case JCS_EXT_BGR:
+    mmifct = jsimd_ycc_extbgr_convert_mmi;
+    break;
+  case JCS_EXT_BGRX:
+  case JCS_EXT_BGRA:
+    mmifct = jsimd_ycc_extbgrx_convert_mmi;
+    break;
+  case JCS_EXT_XBGR:
+  case JCS_EXT_ABGR:
+    mmifct = jsimd_ycc_extxbgr_convert_mmi;
+    break;
+  case JCS_EXT_XRGB:
+  case JCS_EXT_ARGB:
+    mmifct = jsimd_ycc_extxrgb_convert_mmi;
+    break;
+  default:
+    mmifct = jsimd_ycc_rgb_convert_mmi;
+    break;
+  }
+
+  mmifct(cinfo->output_width, input_buf, input_row, output_buf, num_rows);
+}
+
+GLOBAL(void)
+jsimd_ycc_rgb565_convert(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
+                         JDIMENSION input_row, JSAMPARRAY output_buf,
+                         int num_rows)
+{
+}
+
+GLOBAL(void)
+jsimd_c_null_convert(j_compress_ptr cinfo, JSAMPARRAY input_buf,
+                     JSAMPIMAGE output_buf, JDIMENSION output_row,
+                     int num_rows)
+{
+}
+
+GLOBAL(int)
+jsimd_can_h2v2_downsample(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+
+  if (simd_support & JSIMD_MMI)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_h2v2_smooth_downsample(void)
+{
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_h2v1_downsample(void)
+{
+  return 0;
+}
+
+GLOBAL(void)
+jsimd_h2v2_downsample(j_compress_ptr cinfo, jpeg_component_info *compptr,
+                      JSAMPARRAY input_data, JSAMPARRAY output_data)
+{
+  jsimd_h2v2_downsample_mmi(cinfo->image_width, cinfo->max_v_samp_factor,
+                            compptr->v_samp_factor, compptr->width_in_blocks,
+                            input_data, output_data);
+}
+
+GLOBAL(void)
+jsimd_h2v2_smooth_downsample(j_compress_ptr cinfo,
+                             jpeg_component_info *compptr,
+                             JSAMPARRAY input_data, JSAMPARRAY output_data)
+{
+}
+
+GLOBAL(void)
+jsimd_h2v1_downsample(j_compress_ptr cinfo, jpeg_component_info *compptr,
+                      JSAMPARRAY input_data, JSAMPARRAY output_data)
+{
+}
+
+GLOBAL(int)
+jsimd_can_h2v2_upsample(void)
+{
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_h2v1_upsample(void)
+{
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_int_upsample(void)
+{
+  return 0;
+}
+
+GLOBAL(void)
+jsimd_h2v2_upsample(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+                    JSAMPARRAY input_data, JSAMPARRAY *output_data_ptr)
+{
+}
+
+GLOBAL(void)
+jsimd_h2v1_upsample(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+                    JSAMPARRAY input_data, JSAMPARRAY *output_data_ptr)
+{
+}
+
+GLOBAL(void)
+jsimd_int_upsample(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+                   JSAMPARRAY input_data, JSAMPARRAY *output_data_ptr)
+{
+}
+
+GLOBAL(int)
+jsimd_can_h2v2_fancy_upsample(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+
+  if (simd_support & JSIMD_MMI)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_h2v1_fancy_upsample(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+
+  if (simd_support & JSIMD_MMI)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(void)
+jsimd_h2v2_fancy_upsample(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+                          JSAMPARRAY input_data, JSAMPARRAY *output_data_ptr)
+{
+  jsimd_h2v2_fancy_upsample_mmi(cinfo->max_v_samp_factor,
+                                compptr->downsampled_width, input_data,
+                                output_data_ptr);
+}
+
+GLOBAL(void)
+jsimd_h2v1_fancy_upsample(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+                          JSAMPARRAY input_data, JSAMPARRAY *output_data_ptr)
+{
+  jsimd_h2v1_fancy_upsample_mmi(cinfo->max_v_samp_factor,
+                                compptr->downsampled_width, input_data,
+                                output_data_ptr);
+}
+
+GLOBAL(int)
+jsimd_can_h2v2_merged_upsample(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+
+  if (simd_support & JSIMD_MMI)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_h2v1_merged_upsample(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+
+  if (simd_support & JSIMD_MMI)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(void)
+jsimd_h2v2_merged_upsample(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
+                           JDIMENSION in_row_group_ctr, JSAMPARRAY output_buf)
+{
+  void (*mmifct) (JDIMENSION, JSAMPIMAGE, JDIMENSION, JSAMPARRAY);
+
+  switch (cinfo->out_color_space) {
+  case JCS_EXT_RGB:
+    mmifct = jsimd_h2v2_extrgb_merged_upsample_mmi;
+    break;
+  case JCS_EXT_RGBX:
+  case JCS_EXT_RGBA:
+    mmifct = jsimd_h2v2_extrgbx_merged_upsample_mmi;
+    break;
+  case JCS_EXT_BGR:
+    mmifct = jsimd_h2v2_extbgr_merged_upsample_mmi;
+    break;
+  case JCS_EXT_BGRX:
+  case JCS_EXT_BGRA:
+    mmifct = jsimd_h2v2_extbgrx_merged_upsample_mmi;
+    break;
+  case JCS_EXT_XBGR:
+  case JCS_EXT_ABGR:
+    mmifct = jsimd_h2v2_extxbgr_merged_upsample_mmi;
+    break;
+  case JCS_EXT_XRGB:
+  case JCS_EXT_ARGB:
+    mmifct = jsimd_h2v2_extxrgb_merged_upsample_mmi;
+    break;
+  default:
+    mmifct = jsimd_h2v2_merged_upsample_mmi;
+    break;
+  }
+
+  mmifct(cinfo->output_width, input_buf, in_row_group_ctr, output_buf);
+}
+
+GLOBAL(void)
+jsimd_h2v1_merged_upsample(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
+                           JDIMENSION in_row_group_ctr, JSAMPARRAY output_buf)
+{
+  void (*mmifct) (JDIMENSION, JSAMPIMAGE, JDIMENSION, JSAMPARRAY);
+
+  switch (cinfo->out_color_space) {
+  case JCS_EXT_RGB:
+    mmifct = jsimd_h2v1_extrgb_merged_upsample_mmi;
+    break;
+  case JCS_EXT_RGBX:
+  case JCS_EXT_RGBA:
+    mmifct = jsimd_h2v1_extrgbx_merged_upsample_mmi;
+    break;
+  case JCS_EXT_BGR:
+    mmifct = jsimd_h2v1_extbgr_merged_upsample_mmi;
+    break;
+  case JCS_EXT_BGRX:
+  case JCS_EXT_BGRA:
+    mmifct = jsimd_h2v1_extbgrx_merged_upsample_mmi;
+    break;
+  case JCS_EXT_XBGR:
+  case JCS_EXT_ABGR:
+    mmifct = jsimd_h2v1_extxbgr_merged_upsample_mmi;
+    break;
+  case JCS_EXT_XRGB:
+  case JCS_EXT_ARGB:
+    mmifct = jsimd_h2v1_extxrgb_merged_upsample_mmi;
+    break;
+  default:
+    mmifct = jsimd_h2v1_merged_upsample_mmi;
+    break;
+  }
+
+  mmifct(cinfo->output_width, input_buf, in_row_group_ctr, output_buf);
+}
+
+GLOBAL(int)
+jsimd_can_convsamp(void)
+{
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_convsamp_float(void)
+{
+  return 0;
+}
+
+GLOBAL(void)
+jsimd_convsamp(JSAMPARRAY sample_data, JDIMENSION start_col,
+               DCTELEM *workspace)
+{
+}
+
+GLOBAL(void)
+jsimd_convsamp_float(JSAMPARRAY sample_data, JDIMENSION start_col,
+                     FAST_FLOAT *workspace)
+{
+}
+
+GLOBAL(int)
+jsimd_can_fdct_islow(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (DCTSIZE != 8)
+    return 0;
+  if (sizeof(DCTELEM) != 2)
+    return 0;
+
+  if (simd_support & JSIMD_MMI)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_fdct_ifast(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (DCTSIZE != 8)
+    return 0;
+  if (sizeof(DCTELEM) != 2)
+    return 0;
+
+  if (simd_support & JSIMD_MMI)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_fdct_float(void)
+{
+  return 0;
+}
+
+GLOBAL(void)
+jsimd_fdct_islow(DCTELEM *data)
+{
+  jsimd_fdct_islow_mmi(data);
+}
+
+GLOBAL(void)
+jsimd_fdct_ifast(DCTELEM *data)
+{
+  jsimd_fdct_ifast_mmi(data);
+}
+
+GLOBAL(void)
+jsimd_fdct_float(FAST_FLOAT *data)
+{
+}
+
+GLOBAL(int)
+jsimd_can_quantize(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (DCTSIZE != 8)
+    return 0;
+  if (sizeof(JCOEF) != 2)
+    return 0;
+  if (sizeof(DCTELEM) != 2)
+    return 0;
+
+  if (simd_support & JSIMD_MMI)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_quantize_float(void)
+{
+  return 0;
+}
+
+GLOBAL(void)
+jsimd_quantize(JCOEFPTR coef_block, DCTELEM *divisors, DCTELEM *workspace)
+{
+  jsimd_quantize_mmi(coef_block, divisors, workspace);
+}
+
+GLOBAL(void)
+jsimd_quantize_float(JCOEFPTR coef_block, FAST_FLOAT *divisors,
+                     FAST_FLOAT *workspace)
+{
+}
+
+GLOBAL(int)
+jsimd_can_idct_2x2(void)
+{
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_idct_4x4(void)
+{
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_idct_6x6(void)
+{
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_idct_12x12(void)
+{
+  return 0;
+}
+
+GLOBAL(void)
+jsimd_idct_2x2(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+               JCOEFPTR coef_block, JSAMPARRAY output_buf,
+               JDIMENSION output_col)
+{
+}
+
+GLOBAL(void)
+jsimd_idct_4x4(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+               JCOEFPTR coef_block, JSAMPARRAY output_buf,
+               JDIMENSION output_col)
+{
+}
+
+GLOBAL(void)
+jsimd_idct_6x6(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+               JCOEFPTR coef_block, JSAMPARRAY output_buf,
+               JDIMENSION output_col)
+{
+}
+
+GLOBAL(void)
+jsimd_idct_12x12(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+                 JCOEFPTR coef_block, JSAMPARRAY output_buf,
+                 JDIMENSION output_col)
+{
+}
+
+GLOBAL(int)
+jsimd_can_idct_islow(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (DCTSIZE != 8)
+    return 0;
+  if (sizeof(JCOEF) != 2)
+    return 0;
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+  if (sizeof(ISLOW_MULT_TYPE) != 2)
+    return 0;
+
+  if (simd_support & JSIMD_MMI)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_idct_ifast(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (DCTSIZE != 8)
+    return 0;
+  if (sizeof(JCOEF) != 2)
+    return 0;
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+  if (sizeof(IFAST_MULT_TYPE) != 2)
+    return 0;
+  if (IFAST_SCALE_BITS != 2)
+    return 0;
+
+  if (simd_support & JSIMD_MMI)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_idct_float(void)
+{
+  return 0;
+}
+
+GLOBAL(void)
+jsimd_idct_islow(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+                 JCOEFPTR coef_block, JSAMPARRAY output_buf,
+                 JDIMENSION output_col)
+{
+  jsimd_idct_islow_mmi(compptr->dct_table, coef_block, output_buf, output_col);
+}
+
+GLOBAL(void)
+jsimd_idct_ifast(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+                 JCOEFPTR coef_block, JSAMPARRAY output_buf,
+                 JDIMENSION output_col)
+{
+  jsimd_idct_ifast_mmi(compptr->dct_table, coef_block, output_buf, output_col);
+}
+
+GLOBAL(void)
+jsimd_idct_float(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+                 JCOEFPTR coef_block, JSAMPARRAY output_buf,
+                 JDIMENSION output_col)
+{
+}
+
+GLOBAL(int)
+jsimd_can_huff_encode_one_block(void)
+{
+  return 0;
+}
+
+GLOBAL(JOCTET *)
+jsimd_huff_encode_one_block(void *state, JOCTET *buffer, JCOEFPTR block,
+                            int last_dc_val, c_derived_tbl *dctbl,
+                            c_derived_tbl *actbl)
+{
+  return NULL;
+}
+
+GLOBAL(int)
+jsimd_can_encode_mcu_AC_first_prepare(void)
+{
+  return 0;
+}
+
+GLOBAL(void)
+jsimd_encode_mcu_AC_first_prepare(const JCOEF *block,
+                                  const int *jpeg_natural_order_start, int Sl,
+                                  int Al, JCOEF *values, size_t *zerobits)
+{
+}
+
+GLOBAL(int)
+jsimd_can_encode_mcu_AC_refine_prepare(void)
+{
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_encode_mcu_AC_refine_prepare(const JCOEF *block,
+                                   const int *jpeg_natural_order_start, int Sl,
+                                   int Al, JCOEF *absvalues, size_t *bits)
+{
+  return 0;
+}
diff --git a/3rdparty/libjpeg/src/simd/mips64/jsimd_mmi.h b/3rdparty/libjpeg/src/simd/mips64/jsimd_mmi.h
new file mode 100644
index 00000000..5e4261c9
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/mips64/jsimd_mmi.h
@@ -0,0 +1,69 @@
+/*
+ * Loongson MMI optimizations for libjpeg-turbo
+ *
+ * Copyright (C) 2016-2018, Loongson Technology Corporation Limited, BeiJing.
+ *                          All Rights Reserved.
+ * Authors:  ZhuChen     <zhuchen@loongson.cn>
+ *           CaiWanwei   <caiwanwei@loongson.cn>
+ *           SunZhangzhi <sunzhangzhi-cq@loongson.cn>
+ *           QingfaLiu   <liuqingfa-hf@loongson.cn>
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+#define JPEG_INTERNALS
+#include "../../jinclude.h"
+#include "../../jpeglib.h"
+#include "../../jdct.h"
+#include "loongson-mmintrin.h"
+
+
+/* Common code */
+#if defined(_ABI64) && _MIPS_SIM == _ABI64
+# define PTR_ADDU  "daddu "
+# define PTR_SLL   "dsll "
+#else
+# define PTR_ADDU  "addu "
+# define PTR_SLL   "sll "
+#endif
+
+#define SIZEOF_MMWORD  8
+#define BYTE_BIT  8
+#define WORD_BIT  16
+#define SCALEBITS  16
+
+#define _uint64_set_pi8(a, b, c, d, e, f, g, h) \
+  (((uint64_t)(uint8_t)a << 56) | \
+   ((uint64_t)(uint8_t)b << 48) | \
+   ((uint64_t)(uint8_t)c << 40) | \
+   ((uint64_t)(uint8_t)d << 32) | \
+   ((uint64_t)(uint8_t)e << 24) | \
+   ((uint64_t)(uint8_t)f << 16) | \
+   ((uint64_t)(uint8_t)g << 8)  | \
+   ((uint64_t)(uint8_t)h))
+#define _uint64_set1_pi8(a)  _uint64_set_pi8(a, a, a, a, a, a, a, a)
+#define _uint64_set_pi16(a, b, c, d) \
+  (((uint64_t)(uint16_t)a << 48) | \
+   ((uint64_t)(uint16_t)b << 32) | \
+   ((uint64_t)(uint16_t)c << 16) | \
+   ((uint64_t)(uint16_t)d))
+#define _uint64_set1_pi16(a)  _uint64_set_pi16(a, a, a, a)
+#define _uint64_set_pi32(a, b) \
+  (((uint64_t)(uint32_t)a << 32) | \
+   ((uint64_t)(uint32_t)b))
+
+#define get_const_value(index)  (*(__m64 *)&const_value[index])
diff --git a/3rdparty/libjpeg/src/simd/mips64/loongson-mmintrin.h b/3rdparty/libjpeg/src/simd/mips64/loongson-mmintrin.h
new file mode 100644
index 00000000..db9b35ab
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/mips64/loongson-mmintrin.h
@@ -0,0 +1,1334 @@
+/*
+ * Loongson MMI optimizations for libjpeg-turbo
+ *
+ * Copyright (C) 2016-2018, Loongson Technology Corporation Limited, BeiJing.
+ *                          All Rights Reserved.
+ * Copyright (C) 2019, D. R. Commander.  All Rights Reserved.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+#ifndef __LOONGSON_MMINTRIN_H__
+#define __LOONGSON_MMINTRIN_H__
+
+#include <stdint.h>
+
+
+#define FUNCTION_ATTRIBS \
+  __attribute__((__gnu_inline__, __always_inline__, __artificial__))
+
+
+/* Vectors are stored in 64-bit floating-point registers. */
+typedef double __m64;
+
+/* Having a 32-bit datatype allows us to use 32-bit loads in places like
+   load8888. */
+typedef float __m32;
+
+
+/********** Set Operations **********/
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_setzero_si64(void)
+{
+  return 0.0;
+}
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_set_pi8(uint8_t __b7, uint8_t __b6, uint8_t __b5, uint8_t __b4,
+            uint8_t __b3, uint8_t __b2, uint8_t __b1, uint8_t __b0)
+{
+  __m64 ret;
+  uint32_t lo = ((uint32_t)__b6 << 24) |
+                ((uint32_t)__b4 << 16) |
+                ((uint32_t)__b2 << 8) |
+                (uint32_t)__b0;
+  uint32_t hi = ((uint32_t)__b7 << 24) |
+                ((uint32_t)__b5 << 16) |
+                ((uint32_t)__b3 << 8) |
+                (uint32_t)__b1;
+
+  asm("mtc1      %1, %0\n\t"
+      "mtc1      %2, $f0\n\t"
+      "punpcklbh %0, %0, $f0\n\t"
+      : "=f" (ret)
+      : "r" (lo), "r" (hi)
+      : "$f0"
+     );
+
+  return ret;
+}
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_set_pi16(uint16_t __h3, uint16_t __h2, uint16_t __h1, uint16_t __h0)
+{
+  __m64 ret;
+  uint32_t lo = ((uint32_t)__h2 << 16) | (uint32_t)__h0;
+  uint32_t hi = ((uint32_t)__h3 << 16) | (uint32_t)__h1;
+
+  asm("mtc1      %1, %0\n\t"
+      "mtc1      %2, $f0\n\t"
+      "punpcklhw %0, %0, $f0\n\t"
+      : "=f" (ret)
+      : "r" (lo), "r" (hi)
+      : "$f0"
+     );
+
+  return ret;
+}
+
+#define _MM_SHUFFLE(fp3, fp2, fp1, fp0) \
+  (((fp3) << 6) | ((fp2) << 4) | ((fp1) << 2) | (fp0))
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_set_pi32(uint32_t __i1, uint32_t __i0)
+{
+  if (__builtin_constant_p(__i1) && __builtin_constant_p(__i0)) {
+    uint64_t val = ((uint64_t)__i1 << 32) |
+                   ((uint64_t)__i0 <<  0);
+
+    return *(__m64 *)&val;
+  } else if (__i1 == __i0) {
+    uint64_t imm = _MM_SHUFFLE(1, 0, 1, 0);
+    __m64 ret;
+
+    asm("pshufh %0, %1, %2\n\t"
+        : "=f" (ret)
+        : "f" (*(__m32 *)&__i1), "f" (*(__m64 *)&imm)
+       );
+
+    return ret;
+  } else {
+    uint64_t val = ((uint64_t)__i1 << 32) |
+                   ((uint64_t)__i0 <<  0);
+
+    return *(__m64 *)&val;
+  }
+}
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_set1_pi8(uint8_t __b0)
+{
+  __m64 ret;
+
+  asm("sll    $8, %1, 8\n\t"
+      "or     %1, %1, $8\n\t"
+      "mtc1   %1, %0\n\t"
+      "mtc1   $0, $f0\n\t"
+      "pshufh %0, %0, $f0\n\t"
+      : "=f" (ret)
+      : "r" (__b0)
+      : "$8", "$f0"
+     );
+
+  return ret;
+}
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_set1_pi16(uint16_t __h0)
+{
+  __m64 ret;
+
+  asm("mtc1   %1, %0\n\t"
+      "mtc1   $0, $f0\n\t"
+      "pshufh %0, %0, $f0\n\t"
+      : "=f" (ret)
+      : "r" (__h0)
+      : "$8", "$f0"
+     );
+
+  return ret;
+}
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_set1_pi32(unsigned __i0)
+{
+  return _mm_set_pi32(__i0, __i0);
+}
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_setr_pi8(uint8_t __h0, uint8_t __h1, uint8_t __h2, uint8_t __h3,
+             uint8_t __h4, uint8_t __h5, uint8_t __h6, uint8_t __h7)
+{
+  return _mm_set_pi8(__h7, __h6, __h5, __h4,
+                     __h3, __h2, __h1, __h0);
+}
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_setr_pi16(uint16_t __w0, uint16_t __w1, uint16_t __w2, uint16_t __w3)
+{
+  return _mm_set_pi16(__w3, __w2, __w1, __w0);
+}
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_setr_pi32(uint32_t __i0, uint32_t __i1)
+{
+  return _mm_set_pi32(__i1, __i0);
+}
+
+
+/********** Arithmetic Operations **********/
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_add_pi8(__m64 __m1, __m64 __m2)
+{
+  __m64 ret;
+
+  asm("paddb %0, %1, %2\n\t"
+      : "=f" (ret)
+      : "f" (__m1), "f" (__m2)
+     );
+
+  return ret;
+}
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_add_pi16(__m64 __m1, __m64 __m2)
+{
+  __m64 ret;
+
+  asm("paddh %0, %1, %2\n\t"
+      : "=f" (ret)
+      : "f" (__m1), "f" (__m2)
+     );
+
+  return ret;
+}
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_add_pi32(__m64 __m1, __m64 __m2)
+{
+  __m64 ret;
+
+  asm("paddw %0, %1, %2\n\t"
+      : "=f" (ret)
+      : "f" (__m1), "f" (__m2)
+     );
+
+  return ret;
+}
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_add_si64(__m64 __m1, __m64 __m2)
+{
+  __m64 ret;
+
+  asm("paddd %0, %1, %2\n\t"
+      : "=f" (ret)
+      : "f" (__m1), "f" (__m2)
+     );
+
+  return ret;
+}
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_adds_pi8(__m64 __m1, __m64 __m2)
+{
+  __m64 ret;
+
+  asm("paddsb %0, %1, %2\n\t"
+      : "=f" (ret)
+      : "f" (__m1), "f" (__m2)
+     );
+
+  return ret;
+}
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_adds_pi16(__m64 __m1, __m64 __m2)
+{
+  __m64 ret;
+
+  asm("paddsh %0, %1, %2\n\t"
+      : "=f" (ret)
+      : "f" (__m1), "f" (__m2)
+     );
+
+  return ret;
+}
+
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_adds_pu8(__m64 __m1, __m64 __m2)
+{
+  __m64 ret;
+
+  asm("paddusb %0, %1, %2\n\t"
+      : "=f" (ret)
+      : "f" (__m1), "f" (__m2)
+     );
+
+  return ret;
+}
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_adds_pu16(__m64 __m1, __m64 __m2)
+{
+  __m64 ret;
+
+  asm("paddush %0, %1, %2\n\t"
+      : "=f" (ret)
+      : "f" (__m1), "f" (__m2)
+     );
+
+  return ret;
+}
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_avg_pu8(__m64 __m1, __m64 __m2)
+{
+  __m64 ret;
+
+  asm("pavgb %0, %1, %2\n\t"
+      : "=f" (ret)
+      : "f" (__m1), "f" (__m2)
+     );
+
+  return ret;
+}
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_avg_pu16(__m64 __m1, __m64 __m2)
+{
+  __m64 ret;
+
+  asm("pavgh %0, %1, %2\n\t"
+      : "=f" (ret)
+      : "f" (__m1), "f" (__m2)
+     );
+
+  return ret;
+}
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_madd_pi16(__m64 __m1, __m64 __m2)
+{
+  __m64 ret;
+
+  asm("pmaddhw %0, %1, %2\n\t"
+      : "=f" (ret)
+      : "f" (__m1), "f" (__m2)
+     );
+
+  return ret;
+}
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_max_pi16(__m64 __m1, __m64 __m2)
+{
+  __m64 ret;
+
+  asm("pmaxsh %0, %1, %2\n\t"
+      : "=f" (ret)
+      : "f" (__m1), "f" (__m2)
+     );
+
+  return ret;
+}
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_max_pu8(__m64 __m1, __m64 __m2)
+{
+  __m64 ret;
+
+  asm("pmaxub %0, %1, %2\n\t"
+      : "=f" (ret)
+      : "f" (__m1), "f" (__m2)
+     );
+
+  return ret;
+}
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_min_pi16(__m64 __m1, __m64 __m2)
+{
+  __m64 ret;
+
+  asm("pminsh %0, %1, %2\n\t"
+      : "=f" (ret)
+      : "f" (__m1), "f" (__m2)
+     );
+
+  return ret;
+}
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_min_pu8(__m64 __m1, __m64 __m2)
+{
+  __m64 ret;
+
+  asm("pminub %0, %1, %2\n\t"
+      : "=f" (ret)
+      : "f" (__m1), "f" (__m2)
+     );
+
+  return ret;
+}
+
+extern __inline int FUNCTION_ATTRIBS
+_mm_movemask_pi8(__m64 __m1)
+{
+  int ret;
+
+  asm("pmovmskb %0, %1\n\t"
+      : "=r" (ret)
+      : "y" (__m1)
+     );
+
+  return ret;
+}
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_mulhi_pi16(__m64 __m1, __m64 __m2)
+{
+  __m64 ret;
+
+  asm("pmulhh %0, %1, %2\n\t"
+      : "=f" (ret)
+      : "f" (__m1), "f" (__m2)
+     );
+
+  return ret;
+}
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_mulhi_pu16(__m64 __m1, __m64 __m2)
+{
+  __m64 ret;
+
+  asm("pmulhuh %0, %1, %2\n\t"
+      : "=f" (ret)
+      : "f" (__m1), "f" (__m2)
+     );
+
+  return ret;
+}
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_mullo_pi16(__m64 __m1, __m64 __m2)
+{
+  __m64 ret;
+
+  asm("pmullh %0, %1, %2\n\t"
+      : "=f" (ret)
+      : "f" (__m1), "f" (__m2)
+     );
+
+  return ret;
+}
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_mul_pu32(__m64 __m1, __m64 __m2)
+{
+  __m64 ret;
+
+  asm("pmuluw %0, %1, %2\n\t"
+      : "=f" (ret)
+      : "f" (__m1), "f" (__m2)
+     );
+
+  return ret;
+}
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_sad_pu8(__m64 __m1, __m64 __m2)
+{
+  __m64 ret;
+
+  asm("psadbh %0, %1, %2\n\t"
+      : "=f" (ret)
+      : "f" (__m1), "f" (__m2)
+     );
+
+  return ret;
+}
+
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_asub_pu8(__m64 __m1, __m64 __m2)
+{
+  __m64 ret;
+
+  asm("pasubub %0, %1, %2\n\t"
+      : "=f" (ret)
+      : "f" (__m1), "f" (__m2)
+     );
+
+  return ret;
+}
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_biadd_pu8(__m64 __m1, __m64 __m2)
+{
+  __m64 ret;
+
+  asm("biadd %0, %1, %2\n\t"
+      : "=f" (ret)
+      : "f" (__m1), "f" (__m2)
+     );
+
+  return ret;
+}
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_sub_pi8(__m64 __m1, __m64 __m2)
+{
+  __m64 ret;
+
+  asm("psubb %0, %1, %2\n\t"
+      : "=f" (ret)
+      : "f" (__m1), "f" (__m2)
+     );
+
+  return ret;
+}
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_sub_pi16(__m64 __m1, __m64 __m2)
+{
+  __m64 ret;
+
+  asm("psubh %0, %1, %2\n\t"
+      : "=f" (ret)
+      : "f" (__m1), "f" (__m2)
+     );
+
+  return ret;
+}
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_sub_pi32(__m64 __m1, __m64 __m2)
+{
+  __m64 ret;
+
+  asm("psubw %0, %1, %2\n\t"
+      : "=f" (ret)
+      : "f" (__m1), "f" (__m2)
+     );
+
+  return ret;
+}
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_sub_si64(__m64 __m1, __m64 __m2)
+{
+  __m64 ret;
+
+  asm("psubd %0, %1, %2\n\t"
+      : "=f" (ret)
+      : "f" (__m1), "f" (__m2)
+     );
+
+  return ret;
+}
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_subs_pi8(__m64 __m1, __m64 __m2)
+{
+  __m64 ret;
+
+  asm("psubsb %0, %1, %2\n\t"
+      : "=f" (ret)
+      : "f" (__m1), "f" (__m2)
+     );
+
+  return ret;
+}
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_subs_pi16(__m64 __m1, __m64 __m2)
+{
+  __m64 ret;
+
+  asm("psubsh %0, %1, %2\n\t"
+      : "=f" (ret)
+      : "f" (__m1), "f" (__m2)
+     );
+
+  return ret;
+}
+
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_subs_pu8(__m64 __m1, __m64 __m2)
+{
+  __m64 ret;
+
+  asm("psubusb %0, %1, %2\n\t"
+      : "=f" (ret)
+      : "f" (__m1), "f" (__m2)
+     );
+
+  return ret;
+}
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_subs_pu16(__m64 __m1, __m64 __m2)
+{
+  __m64 ret;
+
+  asm("psubush %0, %1, %2\n\t"
+      : "=f" (ret)
+      : "f" (__m1), "f" (__m2)
+     );
+
+  return ret;
+}
+
+
+/********** Logical Operations **********/
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_and_si64(__m64 __m1, __m64 __m2)
+{
+  __m64 ret;
+
+  asm("and %0, %1, %2\n\t"
+      : "=f" (ret)
+      : "f" (__m1), "f" (__m2)
+     );
+
+  return ret;
+}
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_andnot_si64(__m64 __m1, __m64 __m2)
+{
+  __m64 ret;
+
+  asm("andn %0, %1, %2\n\t"
+      : "=f" (ret)
+      : "f" (__m1), "f" (__m2)
+     );
+
+  return ret;
+}
+
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_or_si32(__m32 __m1, __m32 __m2)
+{
+  __m32 ret;
+
+  asm("or %0, %1, %2\n\t"
+      : "=f" (ret)
+      : "f" (__m1), "f" (__m2)
+     );
+
+  return ret;
+}
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_or_si64(__m64 __m1, __m64 __m2)
+{
+  __m64 ret;
+
+  asm("or %0, %1, %2\n\t"
+      : "=f" (ret)
+      : "f" (__m1), "f" (__m2)
+     );
+
+  return ret;
+}
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_xor_si64(__m64 __m1, __m64 __m2)
+{
+  __m64 ret;
+
+  asm("xor %0, %1, %2\n\t"
+      : "=f" (ret)
+      : "f" (__m1), "f" (__m2)
+     );
+
+  return ret;
+}
+
+
+/********** Shift Operations **********/
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_slli_pi16(__m64 __m, int64_t __count)
+{
+  __m64 ret;
+
+  asm("psllh  %0, %1, %2\n\t"
+      : "=f" (ret)
+      : "f" (__m), "f" (*(__m64 *)&__count)
+     );
+
+  return ret;
+}
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_slli_pi32(__m64 __m, int64_t __count)
+{
+  __m64 ret;
+
+  asm("psllw %0, %1, %2\n\t"
+      : "=f" (ret)
+      : "f" (__m), "f" (*(__m64 *)&__count)
+     );
+
+  return ret;
+}
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_slli_si64(__m64 __m, int64_t __count)
+{
+  __m64 ret;
+
+  asm("dsll  %0, %1, %2\n\t"
+      : "=f" (ret)
+      : "f" (__m), "f" (*(__m64 *)&__count)
+     );
+
+  return ret;
+}
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_srli_pi16(__m64 __m, int64_t __count)
+{
+  __m64 ret;
+
+  asm("psrlh %0, %1, %2\n\t"
+      : "=f" (ret)
+      : "f" (__m), "f" (*(__m64 *)&__count)
+     );
+
+  return ret;
+}
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_srli_pi32(__m64 __m, int64_t __count)
+{
+  __m64 ret;
+
+  asm("psrlw %0, %1, %2\n\t"
+      : "=f" (ret)
+      : "f" (__m), "f" (*(__m64 *)&__count)
+     );
+
+  return ret;
+}
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_srli_si64(__m64 __m, int64_t __count)
+{
+  __m64 ret;
+
+  asm("dsrl  %0, %1, %2\n\t"
+      : "=f" (ret)
+      : "f" (__m), "f" (*(__m64 *)&__count)
+     );
+
+  return ret;
+}
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_srai_pi16(__m64 __m, int64_t __count)
+{
+  __m64 ret;
+
+  asm("psrah %0, %1, %2\n\t"
+      : "=f" (ret)
+      : "f" (__m), "f" (*(__m64 *)&__count)
+     );
+
+  return ret;
+}
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_srai_pi32(__m64 __m, int64_t __count)
+{
+  __m64 ret;
+
+  asm("psraw %0, %1, %2\n\t"
+      : "=f" (ret)
+      : "f" (__m), "f" (*(__m64 *)&__count)
+     );
+
+  return ret;
+}
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_srai_si64(__m64 __m, int64_t __count)
+{
+  __m64 ret;
+
+  asm("dsra %0, %1, %2\n\t"
+      : "=f" (ret)
+      : "f" (__m), "f" (*(__m64 *)&__count)
+     );
+
+  return ret;
+}
+
+
+/********** Conversion Intrinsics **********/
+
+extern __inline __m64 FUNCTION_ATTRIBS
+to_m64(uint64_t x)
+{
+  return *(__m64 *)&x;
+}
+
+extern __inline uint64_t FUNCTION_ATTRIBS
+to_uint64(__m64 x)
+{
+  return *(uint64_t *)&x;
+}
+
+
+/********** Comparison Intrinsics **********/
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_cmpeq_pi8(__m64 __m1, __m64 __m2)
+{
+  __m64 ret;
+
+  asm("pcmpeqb %0, %1, %2\n\t"
+      : "=f" (ret)
+      : "f" (__m1), "f" (__m2)
+     );
+
+  return ret;
+}
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_cmpeq_pi16(__m64 __m1, __m64 __m2)
+{
+  __m64 ret;
+
+  asm("pcmpeqh %0, %1, %2\n\t"
+      : "=f" (ret)
+      : "f" (__m1), "f" (__m2)
+     );
+
+  return ret;
+}
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_cmpeq_pi32(__m64 __m1, __m64 __m2)
+{
+  __m64 ret;
+
+  asm("pcmpeqw %0, %1, %2\n\t"
+      : "=f" (ret)
+      : "f" (__m1), "f" (__m2)
+     );
+
+  return ret;
+}
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_cmpgt_pi8(__m64 __m1, __m64 __m2)
+{
+  __m64 ret;
+
+  asm("pcmpgtb %0, %1, %2\n\t"
+      : "=f" (ret)
+      : "f" (__m1), "f" (__m2)
+     );
+
+  return ret;
+}
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_cmpgt_pi16(__m64 __m1, __m64 __m2)
+{
+  __m64 ret;
+
+  asm("pcmpgth %0, %1, %2\n\t"
+      : "=f" (ret)
+      : "f" (__m1), "f" (__m2)
+     );
+
+  return ret;
+}
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_cmpgt_pi32(__m64 __m1, __m64 __m2)
+{
+  __m64 ret;
+
+  asm("pcmpgtw %0, %1, %2\n\t"
+      : "=f" (ret)
+      : "f" (__m1), "f" (__m2)
+     );
+
+  return ret;
+}
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_cmplt_pi8(__m64 __m1, __m64 __m2)
+{
+  __m64 ret;
+
+  asm("pcmpltb %0, %1, %2\n\t"
+      : "=f" (ret)
+      : "f" (__m1), "f" (__m2)
+     );
+
+  return ret;
+}
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_cmplt_pi16(__m64 __m1, __m64 __m2)
+{
+  __m64 ret;
+
+  asm("pcmplth %0, %1, %2\n\t"
+      : "=f" (ret)
+      : "f" (__m1), "f" (__m2)
+     );
+
+  return ret;
+}
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_cmplt_pi32(__m64 __m1, __m64 __m2)
+{
+  __m64 ret;
+
+  asm("pcmpltw %0, %1, %2\n\t"
+      : "=f" (ret)
+      : "f" (__m1), "f" (__m2)
+     );
+
+  return ret;
+}
+
+
+/********** Miscellaneous Operations **********/
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_packs_pi16(__m64 __m1, __m64 __m2)
+{
+  __m64 ret;
+
+  asm("packsshb %0, %1, %2\n\t"
+      : "=f" (ret)
+      : "f" (__m1), "f" (__m2)
+     );
+
+  return ret;
+}
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_packs_pi32(__m64 __m1, __m64 __m2)
+{
+  __m64 ret;
+
+  asm("packsswh %0, %1, %2\n\t"
+      : "=f" (ret)
+      : "f" (__m1), "f" (__m2)
+     );
+
+  return ret;
+}
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_packs_pi32_f(__m64 __m1, __m64 __m2)
+{
+  __m64 ret;
+
+  asm("packsswh %0, %1, %2\n\t"
+      : "=f" (ret)
+      : "f" (__m1), "f" (__m2)
+     );
+
+  return ret;
+}
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_packs_pu16(__m64 __m1, __m64 __m2)
+{
+  __m64 ret;
+
+  asm("packushb %0, %1, %2\n\t"
+      : "=f" (ret)
+      : "f" (__m1), "f" (__m2)
+     );
+
+  return ret;
+}
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_extract_pi16(__m64 __m, int64_t __pos)
+{
+  __m64 ret;
+
+  asm("pextrh %0, %1, %2\n\t"
+      : "=f" (ret)
+      : "f" (__m), "f" (*(__m64 *)&__pos)
+     );
+
+  return ret;
+}
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_insert_pi16(__m64 __m1, __m64 __m2, int64_t __pos)
+{
+  __m64 ret;
+
+  switch (__pos) {
+  case 0:
+
+    asm("pinsrh_0 %0, %1, %2\n\t"
+        : "=f" (ret)
+        : "f" (__m1), "f" (__m2), "i" (__pos)
+       );
+
+    break;
+
+  case 1:
+
+    asm("pinsrh_1 %0, %1, %2\n\t"
+        : "=f" (ret)
+        : "f" (__m1), "f" (__m2), "i" (__pos)
+       );
+
+    break;
+  case 2:
+
+    asm("pinsrh_2 %0, %1, %2\n\t"
+        : "=f" (ret)
+        : "f" (__m1), "f" (__m2), "i" (__pos)
+       );
+
+    break;
+
+  case 3:
+
+    asm("pinsrh_3 %0, %1, %2\n\t"
+        : "=f" (ret)
+        : "f" (__m1), "f" (__m2), "i" (__pos)
+       );
+
+    break;
+  }
+
+  return ret;
+}
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_shuffle_pi16(__m64 __m, int64_t __n)
+{
+  __m64 ret;
+
+  asm("pshufh %0, %1, %2\n\t"
+      : "=f" (ret)
+      : "f" (__m), "f" (*(__m64 *)&__n)
+     );
+
+  return ret;
+}
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_unpackhi_pi8(__m64 __m1, __m64 __m2)
+{
+  __m64 ret;
+
+  asm("punpckhbh %0, %1, %2\n\t"
+      : "=f" (ret)
+      : "f" (__m1), "f" (__m2)
+     );
+
+  return ret;
+}
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_unpackhi_pi8_f(__m64 __m1, __m64 __m2)
+{
+  __m64 ret;
+
+  asm("punpckhbh %0, %1, %2\n\t"
+      : "=f" (ret)
+      : "f" (__m1), "f" (__m2)
+     );
+
+  return ret;
+}
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_unpackhi_pi16(__m64 __m1, __m64 __m2)
+{
+  __m64 ret;
+
+  asm("punpckhhw %0, %1, %2\n\t"
+      : "=f" (ret)
+      : "f" (__m1), "f" (__m2)
+     );
+
+  return ret;
+}
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_unpackhi_pi16_f(__m64 __m1, __m64 __m2)
+{
+  __m64 ret;
+
+  asm("punpckhhw %0, %1, %2\n\t"
+      : "=f" (ret)
+      : "f" (__m1), "f" (__m2)
+     );
+
+  return ret;
+}
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_unpackhi_pi32(__m64 __m1, __m64 __m2)
+{
+  __m64 ret;
+
+  asm("punpckhwd %0, %1, %2\n\t"
+      : "=f" (ret)
+      : "f" (__m1), "f" (__m2)
+     );
+
+  return ret;
+}
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_unpacklo_pi8(__m64 __m1, __m64 __m2)
+{
+  __m64 ret;
+
+  asm("punpcklbh %0, %1, %2\n\t"
+      : "=f" (ret)
+      : "f" (__m1), "f" (__m2)
+     );
+
+  return ret;
+}
+
+/* Since punpcklbh cares about the high 32-bits, we use the __m64 datatype,
+   which preserves the data. */
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_unpacklo_pi8_f64(__m64 __m1, __m64 __m2)
+{
+  __m64 ret;
+
+  asm("punpcklbh %0, %1, %2\n\t"
+      : "=f" (ret)
+      : "f" (__m1), "f" (__m2)
+     );
+
+  return ret;
+}
+
+/* Since punpcklbh doesn't care about the high 32-bits, we use the __m32,
+   datatype, which allows load8888 to use 32-bit loads. */
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_unpacklo_pi8_f(__m32 __m1, __m64 __m2)
+{
+  __m64 ret;
+
+  asm("punpcklbh %0, %1, %2\n\t"
+      : "=f" (ret)
+      : "f" (__m1), "f" (__m2)
+     );
+
+  return ret;
+}
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_unpacklo_pi16(__m64 __m1, __m64 __m2)
+{
+  __m64 ret;
+
+  asm("punpcklhw %0, %1, %2\n\t"
+      : "=f" (ret)
+      : "f" (__m1), "f" (__m2)
+     );
+
+  return ret;
+}
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_unpacklo_pi16_f(__m64 __m1, __m64 __m2)
+{
+  __m64 ret;
+
+  asm("punpcklhw %0, %1, %2\n\t"
+      : "=f" (ret)
+      : "f" (__m1), "f" (__m2)
+     );
+
+  return ret;
+}
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_unpacklo_pi32(__m64 __m1, __m64 __m2)
+{
+  __m64 ret;
+
+  asm("punpcklwd %0, %1, %2\n\t"
+      : "=f" (ret)
+      : "f" (__m1), "f" (__m2)
+     );
+
+  return ret;
+}
+
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_unpacklo_pi32_f(__m64 __m1, __m64 __m2)
+{
+  __m64 ret;
+
+  asm("punpcklwd %0, %1, %2\n\t"
+      : "=f" (ret)
+      : "f" (__m1), "f" (__m2)
+     );
+
+  return ret;
+}
+
+extern __inline void FUNCTION_ATTRIBS
+_mm_store_pi32(__m32 *dest, __m64 src)
+{
+  src = _mm_packs_pu16(src, _mm_setzero_si64());
+
+  asm("swc1 %1, %0\n\t"
+      : "=m" (*dest)
+      : "f" (src)
+      : "memory"
+     );
+}
+
+extern __inline void FUNCTION_ATTRIBS
+_mm_store_si64(__m64 *dest, __m64 src)
+{
+  asm("sdc1 %1, %0 \n\t"
+      : "=m" (*dest)
+      : "f" (src)
+      : "memory"
+     );
+}
+
+extern __inline void FUNCTION_ATTRIBS
+_mm_storeu_si64(__m64 *dest, __m64 src)
+{
+  asm("gssdlc1 %1, 7(%0) \n\t"
+      "gssdrc1 %1, 0(%0) \n\t"
+      :
+      : "r" (dest), "f" (src)
+      : "memory"
+     );
+}
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_load_si32(const __m32 *src)
+{
+  __m32 ret;
+
+  asm("lwc1 %0, %1\n\t"
+      : "=f" (ret)
+      : "m" (*src)
+     );
+
+  return ret;
+}
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_load_si64(const __m64 *src)
+{
+  __m64 ret;
+
+  asm("ldc1 %0, %1\n\t"
+      : "=f" (ret)
+      : "m" (*src)
+      : "memory"
+     );
+
+  return ret;
+}
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_loadu_si64(const __m64 *src)
+{
+  __m64 ret;
+
+  asm("gsldlc1 %0,  7(%1)\n\t"
+      "gsldrc1 %0,  0(%1)\n\t"
+      : "=f" (ret)
+      : "r" (src)
+      : "memory"
+     );
+
+  return ret;
+}
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_loadlo_pi8(const uint32_t *src)
+{
+  return _mm_unpacklo_pi8_f(*(__m32 *)src, _mm_setzero_si64());
+}
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_loadlo_pi8_f(__m64 src)
+{
+  return _mm_unpacklo_pi8_f64(src, _mm_setzero_si64());
+}
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_loadhi_pi8_f(__m64 src)
+{
+  return _mm_unpackhi_pi8_f(src, _mm_setzero_si64());
+}
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_loadlo_pi16(__m64 src)
+{
+  return _mm_unpacklo_pi16(src, _mm_setzero_si64());
+}
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_loadlo_pi16_f(__m64 src)
+{
+  return _mm_unpacklo_pi16_f(_mm_setzero_si64(), src);
+}
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_loadhi_pi16(__m64 src)
+{
+  return _mm_unpackhi_pi16(src, _mm_setzero_si64());
+}
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_loadhi_pi16_f(__m64 src)
+{
+  return _mm_unpackhi_pi16_f(_mm_setzero_si64(), src);
+}
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_expand_alpha(__m64 pixel)
+{
+  return _mm_shuffle_pi16(pixel, _MM_SHUFFLE(3, 3, 3, 3));
+}
+
+extern __inline __m64 FUNCTION_ATTRIBS
+_mm_expand_alpha_rev(__m64 pixel)
+{
+  return _mm_shuffle_pi16(pixel, _MM_SHUFFLE(0, 0, 0, 0));
+}
+
+#endif  /* __LOONGSON_MMINTRIN_H__ */
diff --git a/3rdparty/libjpeg/src/simd/nasm/jcolsamp.inc b/3rdparty/libjpeg/src/simd/nasm/jcolsamp.inc
new file mode 100644
index 00000000..6f6d7f29
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/nasm/jcolsamp.inc
@@ -0,0 +1,135 @@
+;
+; jcolsamp.inc - private declarations for color conversion & up/downsampling
+;
+; Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+; Copyright (C) 2015, Intel Corporation.
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+
+; --------------------------------------------------------------------------
+
+; pseudo-resisters to make ordering of RGB configurable
+;
+%if RGB_RED == 0
+%define mmA  mm0
+%define mmB  mm1
+%define xmmA  xmm0
+%define xmmB  xmm1
+%define ymmA  ymm0
+%define ymmB  ymm1
+%elif RGB_GREEN == 0
+%define mmA  mm2
+%define mmB  mm3
+%define xmmA  xmm2
+%define xmmB  xmm3
+%define ymmA  ymm2
+%define ymmB  ymm3
+%elif RGB_BLUE == 0
+%define mmA  mm4
+%define mmB  mm5
+%define xmmA  xmm4
+%define xmmB  xmm5
+%define ymmA  ymm4
+%define ymmB  ymm5
+%else
+%define mmA  mm6
+%define mmB  mm7
+%define xmmA  xmm6
+%define xmmB  xmm7
+%define ymmA  ymm6
+%define ymmB  ymm7
+%endif
+
+%if RGB_RED == 1
+%define mmC  mm0
+%define mmD  mm1
+%define xmmC  xmm0
+%define xmmD  xmm1
+%define ymmC  ymm0
+%define ymmD  ymm1
+%elif RGB_GREEN == 1
+%define mmC  mm2
+%define mmD  mm3
+%define xmmC  xmm2
+%define xmmD  xmm3
+%define ymmC  ymm2
+%define ymmD  ymm3
+%elif RGB_BLUE == 1
+%define mmC  mm4
+%define mmD  mm5
+%define xmmC  xmm4
+%define xmmD  xmm5
+%define ymmC  ymm4
+%define ymmD  ymm5
+%else
+%define mmC  mm6
+%define mmD  mm7
+%define xmmC  xmm6
+%define xmmD  xmm7
+%define ymmC  ymm6
+%define ymmD  ymm7
+%endif
+
+%if RGB_RED == 2
+%define mmE  mm0
+%define mmF  mm1
+%define xmmE  xmm0
+%define xmmF  xmm1
+%define ymmE  ymm0
+%define ymmF  ymm1
+%elif RGB_GREEN == 2
+%define mmE  mm2
+%define mmF  mm3
+%define xmmE  xmm2
+%define xmmF  xmm3
+%define ymmE  ymm2
+%define ymmF  ymm3
+%elif RGB_BLUE == 2
+%define mmE  mm4
+%define mmF  mm5
+%define xmmE  xmm4
+%define xmmF  xmm5
+%define ymmE  ymm4
+%define ymmF  ymm5
+%else
+%define mmE  mm6
+%define mmF  mm7
+%define xmmE  xmm6
+%define xmmF  xmm7
+%define ymmE  ymm6
+%define ymmF  ymm7
+%endif
+
+%if RGB_RED == 3
+%define mmG  mm0
+%define mmH  mm1
+%define xmmG  xmm0
+%define xmmH  xmm1
+%define ymmG  ymm0
+%define ymmH  ymm1
+%elif RGB_GREEN == 3
+%define mmG  mm2
+%define mmH  mm3
+%define xmmG  xmm2
+%define xmmH  xmm3
+%define ymmG  ymm2
+%define ymmH  ymm3
+%elif RGB_BLUE == 3
+%define mmG  mm4
+%define mmH  mm5
+%define xmmG  xmm4
+%define xmmH  xmm5
+%define ymmG  ymm4
+%define ymmH  ymm5
+%else
+%define mmG  mm6
+%define mmH  mm7
+%define xmmG  xmm6
+%define xmmH  xmm7
+%define ymmG  ymm6
+%define ymmH  ymm7
+%endif
+
+; --------------------------------------------------------------------------
diff --git a/3rdparty/libjpeg/src/simd/nasm/jdct.inc b/3rdparty/libjpeg/src/simd/nasm/jdct.inc
new file mode 100644
index 00000000..9192f66f
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/nasm/jdct.inc
@@ -0,0 +1,31 @@
+;
+; jdct.inc - private declarations for forward & reverse DCT subsystems
+;
+; Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+; Copyright (C) 2018, D. R. Commander.
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+
+; Each IDCT routine is responsible for range-limiting its results and
+; converting them to unsigned form (0..MAXJSAMPLE).  The raw outputs could
+; be quite far out of range if the input data is corrupt, so a bulletproof
+; range-limiting step is required.  We use a mask-and-table-lookup method
+; to do the combined operations quickly.
+;
+%define RANGE_MASK  (MAXJSAMPLE * 4 + 3)  ; 2 bits wider than legal samples
+
+%define ROW(n, b, s)  ((b) + (n) * (s))
+%define COL(n, b, s)  ((b) + (n) * (s) * DCTSIZE)
+
+%define DWBLOCK(m, n, b, s) \
+  ((b) + (m) * DCTSIZE * (s) + (n) * SIZEOF_DWORD)
+%define MMBLOCK(m, n, b, s) \
+  ((b) + (m) * DCTSIZE * (s) + (n) * SIZEOF_MMWORD)
+%define XMMBLOCK(m, n, b, s) \
+  ((b) + (m) * DCTSIZE * (s) + (n) * SIZEOF_XMMWORD)
+%define YMMBLOCK(m, n, b, s) \
+  ((b) + (m) * DCTSIZE * (s) + (n) * SIZEOF_YMMWORD)
+
+; --------------------------------------------------------------------------
diff --git a/3rdparty/libjpeg/src/simd/nasm/jsimdcfg.inc b/3rdparty/libjpeg/src/simd/nasm/jsimdcfg.inc
new file mode 100644
index 00000000..667024a5
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/nasm/jsimdcfg.inc
@@ -0,0 +1,93 @@
+;
+; Automatically generated include file from jsimdcfg.inc.h
+;
+;
+; -- jpeglib.h
+;
+%define DCTSIZE 8
+%define DCTSIZE2 64
+;
+; -- jmorecfg.h
+;
+%define RGB_RED 0
+%define RGB_GREEN 1
+%define RGB_BLUE 2
+%define RGB_PIXELSIZE 3
+%define EXT_RGB_RED 0
+%define EXT_RGB_GREEN 1
+%define EXT_RGB_BLUE 2
+%define EXT_RGB_PIXELSIZE 3
+%define EXT_RGBX_RED 0
+%define EXT_RGBX_GREEN 1
+%define EXT_RGBX_BLUE 2
+%define EXT_RGBX_PIXELSIZE 4
+%define EXT_BGR_RED 2
+%define EXT_BGR_GREEN 1
+%define EXT_BGR_BLUE 0
+%define EXT_BGR_PIXELSIZE 3
+%define EXT_BGRX_RED 2
+%define EXT_BGRX_GREEN 1
+%define EXT_BGRX_BLUE 0
+%define EXT_BGRX_PIXELSIZE 4
+%define EXT_XBGR_RED 3
+%define EXT_XBGR_GREEN 2
+%define EXT_XBGR_BLUE 1
+%define EXT_XBGR_PIXELSIZE 4
+%define EXT_XRGB_RED 1
+%define EXT_XRGB_GREEN 2
+%define EXT_XRGB_BLUE 3
+%define EXT_XRGB_PIXELSIZE 4
+%define RGBX_FILLER_0XFF 1
+; Representation of a single sample (pixel element value).
+; On this SIMD implementation, this must be 'unsigned char'.
+;
+%define JSAMPLE byte ; unsigned char
+%define SIZEOF_JSAMPLE SIZEOF_BYTE ; sizeof(JSAMPLE)
+%define CENTERJSAMPLE 128
+; Representation of a DCT frequency coefficient.
+; On this SIMD implementation, this must be 'short'.
+;
+%define JCOEF word ; short
+%define SIZEOF_JCOEF SIZEOF_WORD ; sizeof(JCOEF)
+; Datatype used for image dimensions.
+; On this SIMD implementation, this must be 'unsigned int'.
+;
+%define JDIMENSION dword ; unsigned int
+%define SIZEOF_JDIMENSION SIZEOF_DWORD ; sizeof(JDIMENSION)
+%define JSAMPROW POINTER ; JSAMPLE * (jpeglib.h)
+%define JSAMPARRAY POINTER ; JSAMPROW * (jpeglib.h)
+%define JSAMPIMAGE POINTER ; JSAMPARRAY * (jpeglib.h)
+%define JCOEFPTR POINTER ; JCOEF * (jpeglib.h)
+%define SIZEOF_JSAMPROW SIZEOF_POINTER ; sizeof(JSAMPROW)
+%define SIZEOF_JSAMPARRAY SIZEOF_POINTER ; sizeof(JSAMPARRAY)
+%define SIZEOF_JSAMPIMAGE SIZEOF_POINTER ; sizeof(JSAMPIMAGE)
+%define SIZEOF_JCOEFPTR SIZEOF_POINTER ; sizeof(JCOEFPTR)
+;
+; -- jdct.h
+;
+; A forward DCT routine is given a pointer to a work area of type DCTELEM[];
+; the DCT is to be performed in-place in that buffer.
+; To maximize parallelism, Type DCTELEM is changed to short (originally, int).
+;
+%define DCTELEM word ; short
+%define SIZEOF_DCTELEM SIZEOF_WORD ; sizeof(DCTELEM)
+%define float FP32 ; float
+%define SIZEOF_FAST_FLOAT SIZEOF_FP32 ; sizeof(float)
+; To maximize parallelism, Type short is changed to short.
+;
+%define ISLOW_MULT_TYPE word ; must be short
+%define SIZEOF_ISLOW_MULT_TYPE SIZEOF_WORD ; sizeof(ISLOW_MULT_TYPE)
+%define IFAST_MULT_TYPE word ; must be short
+%define SIZEOF_IFAST_MULT_TYPE SIZEOF_WORD ; sizeof(IFAST_MULT_TYPE)
+%define IFAST_SCALE_BITS 2 ; fractional bits in scale factors
+%define FLOAT_MULT_TYPE FP32 ; must be float
+%define SIZEOF_FLOAT_MULT_TYPE SIZEOF_FP32 ; sizeof(FLOAT_MULT_TYPE)
+;
+; -- jsimd.h
+;
+%define JSIMD_NONE 0x00
+%define JSIMD_MMX 0x01
+%define JSIMD_3DNOW 0x02
+%define JSIMD_SSE 0x04
+%define JSIMD_SSE2 0x08
+%define JSIMD_AVX2 0x80
diff --git a/3rdparty/libjpeg/src/simd/nasm/jsimdcfg.inc.h b/3rdparty/libjpeg/src/simd/nasm/jsimdcfg.inc.h
new file mode 100644
index 00000000..bf2a45ad
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/nasm/jsimdcfg.inc.h
@@ -0,0 +1,133 @@
+/*
+ * This file generates the include file for the assembly
+ * implementations by abusing the C preprocessor.
+ *
+ * Note: Some things are manually defined as they need to
+ * be mapped to NASM types.
+ */
+
+;
+; Automatically generated include file from jsimdcfg.inc.h
+;
+
+#define JPEG_INTERNALS
+
+#include "../jpeglib.h"
+#include "../jconfig.h"
+#include "../jmorecfg.h"
+#include "jsimd.h"
+
+;
+; -- jpeglib.h
+;
+
+%define _cpp_protection_DCTSIZE   DCTSIZE
+%define _cpp_protection_DCTSIZE2  DCTSIZE2
+
+;
+; -- jmorecfg.h
+;
+
+%define _cpp_protection_RGB_RED             RGB_RED
+%define _cpp_protection_RGB_GREEN           RGB_GREEN
+%define _cpp_protection_RGB_BLUE            RGB_BLUE
+%define _cpp_protection_RGB_PIXELSIZE       RGB_PIXELSIZE
+
+%define _cpp_protection_EXT_RGB_RED         EXT_RGB_RED
+%define _cpp_protection_EXT_RGB_GREEN       EXT_RGB_GREEN
+%define _cpp_protection_EXT_RGB_BLUE        EXT_RGB_BLUE
+%define _cpp_protection_EXT_RGB_PIXELSIZE   EXT_RGB_PIXELSIZE
+
+%define _cpp_protection_EXT_RGBX_RED        EXT_RGBX_RED
+%define _cpp_protection_EXT_RGBX_GREEN      EXT_RGBX_GREEN
+%define _cpp_protection_EXT_RGBX_BLUE       EXT_RGBX_BLUE
+%define _cpp_protection_EXT_RGBX_PIXELSIZE  EXT_RGBX_PIXELSIZE
+
+%define _cpp_protection_EXT_BGR_RED         EXT_BGR_RED
+%define _cpp_protection_EXT_BGR_GREEN       EXT_BGR_GREEN
+%define _cpp_protection_EXT_BGR_BLUE        EXT_BGR_BLUE
+%define _cpp_protection_EXT_BGR_PIXELSIZE   EXT_BGR_PIXELSIZE
+
+%define _cpp_protection_EXT_BGRX_RED        EXT_BGRX_RED
+%define _cpp_protection_EXT_BGRX_GREEN      EXT_BGRX_GREEN
+%define _cpp_protection_EXT_BGRX_BLUE       EXT_BGRX_BLUE
+%define _cpp_protection_EXT_BGRX_PIXELSIZE  EXT_BGRX_PIXELSIZE
+
+%define _cpp_protection_EXT_XBGR_RED        EXT_XBGR_RED
+%define _cpp_protection_EXT_XBGR_GREEN      EXT_XBGR_GREEN
+%define _cpp_protection_EXT_XBGR_BLUE       EXT_XBGR_BLUE
+%define _cpp_protection_EXT_XBGR_PIXELSIZE  EXT_XBGR_PIXELSIZE
+
+%define _cpp_protection_EXT_XRGB_RED        EXT_XRGB_RED
+%define _cpp_protection_EXT_XRGB_GREEN      EXT_XRGB_GREEN
+%define _cpp_protection_EXT_XRGB_BLUE       EXT_XRGB_BLUE
+%define _cpp_protection_EXT_XRGB_PIXELSIZE  EXT_XRGB_PIXELSIZE
+
+%define RGBX_FILLER_0XFF  1
+
+; Representation of a single sample (pixel element value).
+; On this SIMD implementation, this must be 'unsigned char'.
+;
+
+%define JSAMPLE            byte            ; unsigned char
+%define SIZEOF_JSAMPLE     SIZEOF_BYTE     ; sizeof(JSAMPLE)
+
+%define _cpp_protection_CENTERJSAMPLE  CENTERJSAMPLE
+
+; Representation of a DCT frequency coefficient.
+; On this SIMD implementation, this must be 'short'.
+;
+%define JCOEF              word            ; short
+%define SIZEOF_JCOEF       SIZEOF_WORD     ; sizeof(JCOEF)
+
+; Datatype used for image dimensions.
+; On this SIMD implementation, this must be 'unsigned int'.
+;
+%define JDIMENSION         dword           ; unsigned int
+%define SIZEOF_JDIMENSION  SIZEOF_DWORD    ; sizeof(JDIMENSION)
+
+%define JSAMPROW           POINTER         ; JSAMPLE *     (jpeglib.h)
+%define JSAMPARRAY         POINTER         ; JSAMPROW *    (jpeglib.h)
+%define JSAMPIMAGE         POINTER         ; JSAMPARRAY *  (jpeglib.h)
+%define JCOEFPTR           POINTER         ; JCOEF *       (jpeglib.h)
+%define SIZEOF_JSAMPROW    SIZEOF_POINTER  ; sizeof(JSAMPROW)
+%define SIZEOF_JSAMPARRAY  SIZEOF_POINTER  ; sizeof(JSAMPARRAY)
+%define SIZEOF_JSAMPIMAGE  SIZEOF_POINTER  ; sizeof(JSAMPIMAGE)
+%define SIZEOF_JCOEFPTR    SIZEOF_POINTER  ; sizeof(JCOEFPTR)
+
+;
+; -- jdct.h
+;
+
+; A forward DCT routine is given a pointer to a work area of type DCTELEM[];
+; the DCT is to be performed in-place in that buffer.
+; To maximize parallelism, Type DCTELEM is changed to short (originally, int).
+;
+%define DCTELEM                 word         ; short
+%define SIZEOF_DCTELEM          SIZEOF_WORD  ; sizeof(DCTELEM)
+
+%define FAST_FLOAT              FP32         ; float
+%define SIZEOF_FAST_FLOAT       SIZEOF_FP32  ; sizeof(FAST_FLOAT)
+
+; To maximize parallelism, Type MULTIPLIER is changed to short.
+;
+%define ISLOW_MULT_TYPE         word         ; must be short
+%define SIZEOF_ISLOW_MULT_TYPE  SIZEOF_WORD  ; sizeof(ISLOW_MULT_TYPE)
+
+%define IFAST_MULT_TYPE         word         ; must be short
+%define SIZEOF_IFAST_MULT_TYPE  SIZEOF_WORD  ; sizeof(IFAST_MULT_TYPE)
+%define IFAST_SCALE_BITS        2            ; fractional bits in scale factors
+
+%define FLOAT_MULT_TYPE         FP32         ; must be float
+%define SIZEOF_FLOAT_MULT_TYPE  SIZEOF_FP32  ; sizeof(FLOAT_MULT_TYPE)
+
+;
+; -- jsimd.h
+;
+
+%define _cpp_protection_JSIMD_NONE   JSIMD_NONE
+%define _cpp_protection_JSIMD_MMX    JSIMD_MMX
+%define _cpp_protection_JSIMD_3DNOW  JSIMD_3DNOW
+%define _cpp_protection_JSIMD_SSE    JSIMD_SSE
+%define _cpp_protection_JSIMD_SSE2   JSIMD_SSE2
+%define _cpp_protection_JSIMD_AVX2   JSIMD_AVX2
diff --git a/3rdparty/libjpeg/src/simd/nasm/jsimdext.inc b/3rdparty/libjpeg/src/simd/nasm/jsimdext.inc
new file mode 100644
index 00000000..e8d50b03
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/nasm/jsimdext.inc
@@ -0,0 +1,520 @@
+;
+; jsimdext.inc - common declarations
+;
+; Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+; Copyright (C) 2010, 2016, 2018-2019, D. R. Commander.
+; Copyright (C) 2018, Matthieu Darbois.
+; Copyright (C) 2018, Matthias Räncker.
+;
+; Based on the x86 SIMD extension for IJG JPEG library - version 1.02
+;
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+;
+; This software is provided 'as-is', without any express or implied
+; warranty.  In no event will the authors be held liable for any damages
+; arising from the use of this software.
+;
+; Permission is granted to anyone to use this software for any purpose,
+; including commercial applications, and to alter it and redistribute it
+; freely, subject to the following restrictions:
+;
+; 1. The origin of this software must not be misrepresented; you must not
+;    claim that you wrote the original software. If you use this software
+;    in a product, an acknowledgment in the product documentation would be
+;    appreciated but is not required.
+; 2. Altered source versions must be plainly marked as such, and must not be
+;    misrepresented as being the original software.
+; 3. This notice may not be removed or altered from any source distribution.
+
+; ==========================================================================
+;  System-dependent configurations
+
+%ifdef WIN32    ; ----(nasm -fwin32 -DWIN32 ...)--------
+; * Microsoft Visual C++
+; * MinGW (Minimalist GNU for Windows)
+; * CygWin
+; * LCC-Win32
+
+; -- segment definition --
+;
+%ifdef __YASM_VER__
+%define SEG_TEXT   .text  align=32
+%define SEG_CONST  .rdata align=32
+%else
+%define SEG_TEXT   .text  align=32 public use32 class=CODE
+%define SEG_CONST  .rdata align=32 public use32 class=CONST
+%endif
+
+%elifdef WIN64  ; ----(nasm -fwin64 -DWIN64 ...)--------
+; * Microsoft Visual C++
+
+; -- segment definition --
+;
+%ifdef __YASM_VER__
+%define SEG_TEXT    .text  align=32
+%define SEG_CONST   .rdata align=32
+%else
+%define SEG_TEXT    .text  align=32 public use64 class=CODE
+%define SEG_CONST   .rdata align=32 public use64 class=CONST
+%endif
+%define EXTN(name)  name                ; foo() -> foo
+
+%elifdef OBJ32  ; ----(nasm -fobj -DOBJ32 ...)----------
+; * Borland C++ (Win32)
+
+; -- segment definition --
+;
+%define SEG_TEXT   _text align=32 public use32 class=CODE
+%define SEG_CONST  _data align=32 public use32 class=DATA
+
+%elifdef ELF    ; ----(nasm -felf[64] -DELF ...)------------
+; * Linux
+; * *BSD family Unix using elf format
+; * Unix System V, including Solaris x86, UnixWare and SCO Unix
+
+; mark stack as non-executable
+section .note.GNU-stack noalloc noexec nowrite progbits
+
+; -- segment definition --
+;
+%ifdef __x86_64__
+%define SEG_TEXT   .text   progbits align=32
+%define SEG_CONST  .rodata progbits align=32
+%else
+%define SEG_TEXT   .text   progbits alloc exec   nowrite align=32
+%define SEG_CONST  .rodata progbits alloc noexec nowrite align=32
+%endif
+
+; To make the code position-independent, append -DPIC to the commandline
+;
+%define GOT_SYMBOL  _GLOBAL_OFFSET_TABLE_  ; ELF supports PIC
+%define EXTN(name)  name                   ; foo() -> foo
+
+%elifdef AOUT   ; ----(nasm -faoutb/aout -DAOUT ...)----
+; * Older Linux using a.out format  (nasm -f aout -DAOUT ...)
+; * *BSD family Unix using a.out format  (nasm -f aoutb -DAOUT ...)
+
+; -- segment definition --
+;
+%define SEG_TEXT   .text
+%define SEG_CONST  .data
+
+; To make the code position-independent, append -DPIC to the commandline
+;
+%define GOT_SYMBOL  __GLOBAL_OFFSET_TABLE_  ; BSD-style a.out supports PIC
+
+%elifdef MACHO  ; ----(nasm -fmacho -DMACHO ...)--------
+; * NeXTstep/OpenStep/Rhapsody/Darwin/MacOS X (Mach-O format)
+
+; -- segment definition --
+;
+%define SEG_TEXT   .text  ;align=32     ; nasm doesn't accept align=32. why?
+%define SEG_CONST  .rodata align=32
+
+; The generation of position-independent code (PIC) is the default on Darwin.
+;
+%define PIC
+%define GOT_SYMBOL  _MACHO_PIC_         ; Mach-O style code-relative addressing
+
+%else           ; ----(Other case)----------------------
+
+; -- segment definition --
+;
+%define SEG_TEXT   .text
+%define SEG_CONST  .data
+
+%endif          ; ----------------------------------------------
+
+; ==========================================================================
+
+; --------------------------------------------------------------------------
+;  Common types
+;
+%ifdef __x86_64__
+%ifnidn __OUTPUT_FORMAT__, elfx32
+%define POINTER         qword           ; general pointer type
+%define SIZEOF_POINTER  SIZEOF_QWORD    ; sizeof(POINTER)
+%define POINTER_BIT     QWORD_BIT       ; sizeof(POINTER)*BYTE_BIT
+%define resp            resq
+%define dp              dq
+%define raxp            rax
+%define rbxp            rbx
+%define rcxp            rcx
+%define rdxp            rdx
+%define rsip            rsi
+%define rdip            rdi
+%define rbpp            rbp
+%define rspp            rsp
+%define r8p             r8
+%define r9p             r9
+%define r10p            r10
+%define r11p            r11
+%define r12p            r12
+%define r13p            r13
+%define r14p            r14
+%define r15p            r15
+%endif
+%endif
+%ifndef raxp
+%define POINTER         dword           ; general pointer type
+%define SIZEOF_POINTER  SIZEOF_DWORD    ; sizeof(POINTER)
+%define POINTER_BIT     DWORD_BIT       ; sizeof(POINTER)*BYTE_BIT
+%define resp            resd
+%define dp              dd
+; x86_64 ILP32 ABI (x32)
+%define raxp            eax
+%define rbxp            ebx
+%define rcxp            ecx
+%define rdxp            edx
+%define rsip            esi
+%define rdip            edi
+%define rbpp            ebp
+%define rspp            esp
+%define r8p             r8d
+%define r9p             r9d
+%define r10p            r10d
+%define r11p            r11d
+%define r12p            r12d
+%define r13p            r13d
+%define r14p            r14d
+%define r15p            r15d
+%endif
+
+%define INT             dword           ; signed integer type
+%define SIZEOF_INT      SIZEOF_DWORD    ; sizeof(INT)
+%define INT_BIT         DWORD_BIT       ; sizeof(INT)*BYTE_BIT
+
+%define FP32            dword           ; IEEE754 single
+%define SIZEOF_FP32     SIZEOF_DWORD    ; sizeof(FP32)
+%define FP32_BIT        DWORD_BIT       ; sizeof(FP32)*BYTE_BIT
+
+%define MMWORD          qword           ; int64  (MMX register)
+%define SIZEOF_MMWORD   SIZEOF_QWORD    ; sizeof(MMWORD)
+%define MMWORD_BIT      QWORD_BIT       ; sizeof(MMWORD)*BYTE_BIT
+
+; NASM is buggy and doesn't properly handle operand sizes for SSE
+; instructions, so for now we have to define XMMWORD as blank.
+%define XMMWORD                         ; int128 (SSE register)
+%define SIZEOF_XMMWORD  SIZEOF_OWORD    ; sizeof(XMMWORD)
+%define XMMWORD_BIT     OWORD_BIT       ; sizeof(XMMWORD)*BYTE_BIT
+
+%define YMMWORD                         ; int256 (AVX register)
+%define SIZEOF_YMMWORD  SIZEOF_YWORD    ; sizeof(YMMWORD)
+%define YMMWORD_BIT     YWORD_BIT       ; sizeof(YMMWORD)*BYTE_BIT
+
+; Similar hacks for when we load a dword or MMWORD into an xmm# register
+%define XMM_DWORD
+%define XMM_MMWORD
+
+%define SIZEOF_BYTE   1                 ; sizeof(byte)
+%define SIZEOF_WORD   2                 ; sizeof(word)
+%define SIZEOF_DWORD  4                 ; sizeof(dword)
+%define SIZEOF_QWORD  8                 ; sizeof(qword)
+%define SIZEOF_OWORD  16                ; sizeof(oword)
+%define SIZEOF_YWORD  32                ; sizeof(yword)
+
+%define BYTE_BIT      8                 ; CHAR_BIT in C
+%define WORD_BIT      16                ; sizeof(word)*BYTE_BIT
+%define DWORD_BIT     32                ; sizeof(dword)*BYTE_BIT
+%define QWORD_BIT     64                ; sizeof(qword)*BYTE_BIT
+%define OWORD_BIT     128               ; sizeof(oword)*BYTE_BIT
+%define YWORD_BIT     256               ; sizeof(yword)*BYTE_BIT
+
+; --------------------------------------------------------------------------
+;  External Symbol Name
+;
+%ifndef EXTN
+%define EXTN(name)  _ %+ name           ; foo() -> _foo
+%endif
+
+; --------------------------------------------------------------------------
+;  Hidden symbols
+;
+%ifdef ELF      ; ----(nasm -felf[64] -DELF ...)--------
+%define GLOBAL_FUNCTION(name)  global EXTN(name):function hidden
+%define GLOBAL_DATA(name)      global EXTN(name):data hidden
+%elifdef MACHO  ; ----(nasm -fmacho -DMACHO ...)--------
+%ifdef __YASM_VER__
+%define GLOBAL_FUNCTION(name)  global EXTN(name):private_extern
+%define GLOBAL_DATA(name)      global EXTN(name):private_extern
+%else
+%if __NASM_VERSION_ID__ >= 0x020E0000
+%define GLOBAL_FUNCTION(name)  global EXTN(name):private_extern
+%define GLOBAL_DATA(name)      global EXTN(name):private_extern
+%endif
+%endif
+%endif
+
+%ifndef GLOBAL_FUNCTION
+%define GLOBAL_FUNCTION(name)  global EXTN(name)
+%endif
+%ifndef GLOBAL_DATA
+%define GLOBAL_DATA(name)      global EXTN(name)
+%endif
+
+; --------------------------------------------------------------------------
+;  Macros for position-independent code (PIC) support
+;
+%ifndef GOT_SYMBOL
+%undef PIC
+%endif
+
+%ifdef PIC  ; -------------------------------------------
+
+%ifidn GOT_SYMBOL, _MACHO_PIC_  ; --------------------
+
+; At present, nasm doesn't seem to support PIC generation for Mach-O.
+; The PIC support code below is a little tricky.
+
+    SECTION     SEG_CONST
+const_base:
+
+%define GOTOFF(got, sym)  (got) + (sym) - const_base
+
+%imacro get_GOT 1
+    ; NOTE: this macro destroys ecx resister.
+    call        %%geteip
+    add         ecx, byte (%%ref - $)
+    jmp         short %%adjust
+%%geteip:
+    mov         ecx, POINTER [esp]
+    ret
+%%adjust:
+    push        ebp
+    xor         ebp, ebp                ; ebp = 0
+%ifidni %1, ebx  ; (%1 == ebx)
+    ; db 0x8D,0x9C + jmp near const_base =
+    ;   lea ebx, [ecx+ebp*8+(const_base-%%ref)] ; 8D,9C,E9,(offset32)
+    db          0x8D, 0x9C              ; 8D,9C
+    jmp         near const_base         ; E9,(const_base-%%ref)
+%%ref:
+%else  ; (%1 != ebx)
+    ; db 0x8D,0x8C + jmp near const_base =
+    ;   lea ecx, [ecx+ebp*8+(const_base-%%ref)] ; 8D,8C,E9,(offset32)
+    db          0x8D, 0x8C              ; 8D,8C
+    jmp         near const_base         ; E9,(const_base-%%ref)
+%%ref:
+    mov         %1, ecx
+%endif  ; (%1 == ebx)
+    pop         ebp
+%endmacro
+
+%else     ; GOT_SYMBOL != _MACHO_PIC_ ----------------
+
+%define GOTOFF(got, sym)  (got) + (sym) wrt ..gotoff
+
+%imacro get_GOT 1
+    extern      GOT_SYMBOL
+    call        %%geteip
+    add         %1, GOT_SYMBOL + $$ - $ wrt ..gotpc
+    jmp         short %%done
+%%geteip:
+    mov         %1, POINTER [esp]
+    ret
+%%done:
+%endmacro
+
+%endif    ; GOT_SYMBOL == _MACHO_PIC_ ----------------
+
+%imacro pushpic 1.nolist
+    push        %1
+%endmacro
+%imacro poppic  1.nolist
+    pop         %1
+%endmacro
+%imacro movpic  2.nolist
+    mov         %1, %2
+%endmacro
+
+%else    ; !PIC -----------------------------------------
+
+%define GOTOFF(got, sym)  (sym)
+
+%imacro get_GOT 1.nolist
+%endmacro
+%imacro pushpic 1.nolist
+%endmacro
+%imacro poppic  1.nolist
+%endmacro
+%imacro movpic  2.nolist
+%endmacro
+
+%endif   ;  PIC -----------------------------------------
+
+; --------------------------------------------------------------------------
+;  Align the next instruction on {2,4,8,16,..}-byte boundary.
+;  ".balign n,,m" in GNU as
+;
+%define MSKLE(x, y)  (~(((y) & 0xFFFF) - ((x) & 0xFFFF)) >> 16)
+%define FILLB(b, n)  (($$-(b)) & ((n)-1))
+
+%imacro alignx 1-2.nolist 0xFFFF
+%%bs: \
+  times MSKLE(FILLB(%%bs, %1), %2) & MSKLE(16, FILLB($, %1)) & FILLB($, %1) \
+        db 0x90                                      ; nop
+  times MSKLE(FILLB(%%bs, %1), %2) & FILLB($, %1) / 9 \
+        db 0x8D, 0x9C, 0x23, 0x00, 0x00, 0x00, 0x00  ; lea ebx,[ebx+0x00000000]
+  times MSKLE(FILLB(%%bs, %1), %2) & FILLB($, %1) / 7 \
+        db 0x8D, 0xAC, 0x25, 0x00, 0x00, 0x00, 0x00  ; lea ebp,[ebp+0x00000000]
+  times MSKLE(FILLB(%%bs, %1), %2) & FILLB($, %1) / 6 \
+        db 0x8D, 0xAD, 0x00, 0x00, 0x00, 0x00        ; lea ebp,[ebp+0x00000000]
+  times MSKLE(FILLB(%%bs, %1), %2) & FILLB($, %1) / 4 \
+        db 0x8D, 0x6C, 0x25, 0x00                    ; lea ebp,[ebp+0x00]
+  times MSKLE(FILLB(%%bs, %1), %2) & FILLB($, %1) / 3 \
+        db 0x8D, 0x6D, 0x00                          ; lea ebp,[ebp+0x00]
+  times MSKLE(FILLB(%%bs, %1), %2) & FILLB($, %1) / 2 \
+        db 0x8B, 0xED                                ; mov ebp,ebp
+  times MSKLE(FILLB(%%bs, %1), %2) & FILLB($, %1) / 1 \
+        db 0x90                                      ; nop
+%endmacro
+
+; Align the next data on {2,4,8,16,..}-byte boundary.
+;
+%imacro alignz 1.nolist
+    align       %1, db 0                ; filling zeros
+%endmacro
+
+%ifdef __x86_64__
+
+%ifdef WIN64
+
+%imacro collect_args 1
+    sub         rsp, SIZEOF_XMMWORD
+    movaps      XMMWORD [rsp], xmm6
+    sub         rsp, SIZEOF_XMMWORD
+    movaps      XMMWORD [rsp], xmm7
+    mov         r10, rcx
+%if %1 > 1
+    mov         r11, rdx
+%endif
+%if %1 > 2
+    push        r12
+    mov         r12, r8
+%endif
+%if %1 > 3
+    push        r13
+    mov         r13, r9
+%endif
+%if %1 > 4
+    push        r14
+    mov         r14, [rax+48]
+%endif
+%if %1 > 5
+    push        r15
+    mov         r15, [rax+56]
+%endif
+    push        rsi
+    push        rdi
+%endmacro
+
+%imacro uncollect_args 1
+    pop         rdi
+    pop         rsi
+%if %1 > 5
+    pop         r15
+%endif
+%if %1 > 4
+    pop         r14
+%endif
+%if %1 > 3
+    pop         r13
+%endif
+%if %1 > 2
+    pop         r12
+%endif
+    movaps      xmm7, XMMWORD [rsp]
+    add         rsp, SIZEOF_XMMWORD
+    movaps      xmm6, XMMWORD [rsp]
+    add         rsp, SIZEOF_XMMWORD
+%endmacro
+
+%imacro push_xmm 1
+    sub         rsp, %1 * SIZEOF_XMMWORD
+    movaps      XMMWORD [rsp+0*SIZEOF_XMMWORD], xmm8
+%if %1 > 1
+    movaps      XMMWORD [rsp+1*SIZEOF_XMMWORD], xmm9
+%endif
+%if %1 > 2
+    movaps      XMMWORD [rsp+2*SIZEOF_XMMWORD], xmm10
+%endif
+%if %1 > 3
+    movaps      XMMWORD [rsp+3*SIZEOF_XMMWORD], xmm11
+%endif
+%endmacro
+
+%imacro pop_xmm 1
+    movaps      xmm8, XMMWORD [rsp+0*SIZEOF_XMMWORD]
+%if %1 > 1
+    movaps      xmm9, XMMWORD [rsp+1*SIZEOF_XMMWORD]
+%endif
+%if %1 > 2
+    movaps      xmm10, XMMWORD [rsp+2*SIZEOF_XMMWORD]
+%endif
+%if %1 > 3
+    movaps      xmm11, XMMWORD [rsp+3*SIZEOF_XMMWORD]
+%endif
+    add         rsp, %1 * SIZEOF_XMMWORD
+%endmacro
+
+%else
+
+%imacro collect_args 1
+    push        r10
+    mov         r10, rdi
+%if %1 > 1
+    push        r11
+    mov         r11, rsi
+%endif
+%if %1 > 2
+    push        r12
+    mov         r12, rdx
+%endif
+%if %1 > 3
+    push        r13
+    mov         r13, rcx
+%endif
+%if %1 > 4
+    push        r14
+    mov         r14, r8
+%endif
+%if %1 > 5
+    push        r15
+    mov         r15, r9
+%endif
+%endmacro
+
+%imacro uncollect_args 1
+%if %1 > 5
+    pop         r15
+%endif
+%if %1 > 4
+    pop         r14
+%endif
+%if %1 > 3
+    pop         r13
+%endif
+%if %1 > 2
+    pop         r12
+%endif
+%if %1 > 1
+    pop         r11
+%endif
+    pop         r10
+%endmacro
+
+%imacro push_xmm 1
+%endmacro
+
+%imacro pop_xmm 1
+%endmacro
+
+%endif
+
+%endif
+
+; --------------------------------------------------------------------------
+;  Defines picked up from the C headers
+;
+%include "jsimdcfg.inc"
+
+; --------------------------------------------------------------------------
diff --git a/3rdparty/libjpeg/src/simd/powerpc/jccolext-altivec.c b/3rdparty/libjpeg/src/simd/powerpc/jccolext-altivec.c
new file mode 100644
index 00000000..170f90ff
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/powerpc/jccolext-altivec.c
@@ -0,0 +1,269 @@
+/*
+ * AltiVec optimizations for libjpeg-turbo
+ *
+ * Copyright (C) 2014-2015, D. R. Commander.  All Rights Reserved.
+ * Copyright (C) 2014, Jay Foad.  All Rights Reserved.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+/* This file is included by jccolor-altivec.c */
+
+
+void jsimd_rgb_ycc_convert_altivec(JDIMENSION img_width, JSAMPARRAY input_buf,
+                                   JSAMPIMAGE output_buf,
+                                   JDIMENSION output_row, int num_rows)
+{
+  JSAMPROW inptr, outptr0, outptr1, outptr2;
+  int pitch = img_width * RGB_PIXELSIZE, num_cols;
+#if __BIG_ENDIAN__
+  int offset;
+#endif
+  unsigned char __attribute__((aligned(16))) tmpbuf[RGB_PIXELSIZE * 16];
+
+  __vector unsigned char rgb0, rgb1 = { 0 }, rgb2 = { 0 },
+    rgbg0, rgbg1, rgbg2, rgbg3, y, cb, cr;
+#if __BIG_ENDIAN__ || RGB_PIXELSIZE == 4
+  __vector unsigned char rgb3 = { 0 };
+#endif
+#if __BIG_ENDIAN__ && RGB_PIXELSIZE == 4
+  __vector unsigned char rgb4 = { 0 };
+#endif
+  __vector short rg0, rg1, rg2, rg3, bg0, bg1, bg2, bg3;
+  __vector unsigned short yl, yh, crl, crh, cbl, cbh;
+  __vector int y0, y1, y2, y3, cr0, cr1, cr2, cr3, cb0, cb1, cb2, cb3;
+
+  /* Constants */
+  __vector short pw_f0299_f0337 = { __4X2(F_0_299, F_0_337) },
+    pw_f0114_f0250 = { __4X2(F_0_114, F_0_250) },
+    pw_mf016_mf033 = { __4X2(-F_0_168, -F_0_331) },
+    pw_mf008_mf041 = { __4X2(-F_0_081, -F_0_418) };
+  __vector unsigned short pw_f050_f000 = { __4X2(F_0_500, 0) };
+  __vector int pd_onehalf = { __4X(ONE_HALF) },
+    pd_onehalfm1_cj = { __4X(ONE_HALF - 1 + (CENTERJSAMPLE << SCALEBITS)) };
+  __vector unsigned char pb_zero = { __16X(0) },
+#if __BIG_ENDIAN__
+    shift_pack_index =
+      {  0,  1,  4,  5,  8,  9, 12, 13, 16, 17, 20, 21, 24, 25, 28, 29 };
+#else
+    shift_pack_index =
+      {  2,  3,  6,  7, 10, 11, 14, 15, 18, 19, 22, 23, 26, 27, 30, 31 };
+#endif
+
+  while (--num_rows >= 0) {
+    inptr = *input_buf++;
+    outptr0 = output_buf[0][output_row];
+    outptr1 = output_buf[1][output_row];
+    outptr2 = output_buf[2][output_row];
+    output_row++;
+
+    for (num_cols = pitch; num_cols > 0;
+         num_cols -= RGB_PIXELSIZE * 16, inptr += RGB_PIXELSIZE * 16,
+         outptr0 += 16, outptr1 += 16, outptr2 += 16) {
+
+#if __BIG_ENDIAN__
+      /* Load 16 pixels == 48 or 64 bytes */
+      offset = (size_t)inptr & 15;
+      if (offset) {
+        __vector unsigned char unaligned_shift_index;
+        int bytes = num_cols + offset;
+
+        if (bytes < (RGB_PIXELSIZE + 1) * 16 && (bytes & 15)) {
+          /* Slow path to prevent buffer overread.  Since there is no way to
+           * read a partial AltiVec register, overread would occur on the last
+           * chunk of the last image row if the right edge is not on a 16-byte
+           * boundary.  It could also occur on other rows if the bytes per row
+           * is low enough.  Since we can't determine whether we're on the last
+           * image row, we have to assume every row is the last.
+           */
+          memcpy(tmpbuf, inptr, min(num_cols, RGB_PIXELSIZE * 16));
+          rgb0 = vec_ld(0, tmpbuf);
+          rgb1 = vec_ld(16, tmpbuf);
+          rgb2 = vec_ld(32, tmpbuf);
+#if RGB_PIXELSIZE == 4
+          rgb3 = vec_ld(48, tmpbuf);
+#endif
+        } else {
+          /* Fast path */
+          rgb0 = vec_ld(0, inptr);
+          if (bytes > 16)
+            rgb1 = vec_ld(16, inptr);
+          if (bytes > 32)
+            rgb2 = vec_ld(32, inptr);
+          if (bytes > 48)
+            rgb3 = vec_ld(48, inptr);
+#if RGB_PIXELSIZE == 4
+          if (bytes > 64)
+            rgb4 = vec_ld(64, inptr);
+#endif
+          unaligned_shift_index = vec_lvsl(0, inptr);
+          rgb0 = vec_perm(rgb0, rgb1, unaligned_shift_index);
+          rgb1 = vec_perm(rgb1, rgb2, unaligned_shift_index);
+          rgb2 = vec_perm(rgb2, rgb3, unaligned_shift_index);
+#if RGB_PIXELSIZE == 4
+          rgb3 = vec_perm(rgb3, rgb4, unaligned_shift_index);
+#endif
+        }
+      } else {
+#endif /* __BIG_ENDIAN__ */
+        if (num_cols < RGB_PIXELSIZE * 16 && (num_cols & 15)) {
+          /* Slow path */
+          memcpy(tmpbuf, inptr, min(num_cols, RGB_PIXELSIZE * 16));
+          rgb0 = VEC_LD(0, tmpbuf);
+          rgb1 = VEC_LD(16, tmpbuf);
+          rgb2 = VEC_LD(32, tmpbuf);
+#if RGB_PIXELSIZE == 4
+          rgb3 = VEC_LD(48, tmpbuf);
+#endif
+        } else {
+          /* Fast path */
+          rgb0 = VEC_LD(0, inptr);
+          if (num_cols > 16)
+            rgb1 = VEC_LD(16, inptr);
+          if (num_cols > 32)
+            rgb2 = VEC_LD(32, inptr);
+#if RGB_PIXELSIZE == 4
+          if (num_cols > 48)
+            rgb3 = VEC_LD(48, inptr);
+#endif
+        }
+#if __BIG_ENDIAN__
+      }
+#endif
+
+#if RGB_PIXELSIZE == 3
+      /* rgb0 = R0 G0 B0 R1 G1 B1 R2 G2 B2 R3 G3 B3 R4 G4 B4 R5
+       * rgb1 = G5 B5 R6 G6 B6 R7 G7 B7 R8 G8 B8 R9 G9 B9 Ra Ga
+       * rgb2 = Ba Rb Gb Bb Rc Gc Bc Rd Gd Bd Re Ge Be Rf Gf Bf
+       *
+       * rgbg0 = R0 G0 R1 G1 R2 G2 R3 G3 B0 G0 B1 G1 B2 G2 B3 G3
+       * rgbg1 = R4 G4 R5 G5 R6 G6 R7 G7 B4 G4 B5 G5 B6 G6 B7 G7
+       * rgbg2 = R8 G8 R9 G9 Ra Ga Rb Gb B8 G8 B9 G9 Ba Ga Bb Gb
+       * rgbg3 = Rc Gc Rd Gd Re Ge Rf Gf Bc Gc Bd Gd Be Ge Bf Gf
+       */
+      rgbg0 = vec_perm(rgb0, rgb0, (__vector unsigned char)RGBG_INDEX0);
+      rgbg1 = vec_perm(rgb0, rgb1, (__vector unsigned char)RGBG_INDEX1);
+      rgbg2 = vec_perm(rgb1, rgb2, (__vector unsigned char)RGBG_INDEX2);
+      rgbg3 = vec_perm(rgb2, rgb2, (__vector unsigned char)RGBG_INDEX3);
+#else
+      /* rgb0 = R0 G0 B0 X0 R1 G1 B1 X1 R2 G2 B2 X2 R3 G3 B3 X3
+       * rgb1 = R4 G4 B4 X4 R5 G5 B5 X5 R6 G6 B6 X6 R7 G7 B7 X7
+       * rgb2 = R8 G8 B8 X8 R9 G9 B9 X9 Ra Ga Ba Xa Rb Gb Bb Xb
+       * rgb3 = Rc Gc Bc Xc Rd Gd Bd Xd Re Ge Be Xe Rf Gf Bf Xf
+       *
+       * rgbg0 = R0 G0 R1 G1 R2 G2 R3 G3 B0 G0 B1 G1 B2 G2 B3 G3
+       * rgbg1 = R4 G4 R5 G5 R6 G6 R7 G7 B4 G4 B5 G5 B6 G6 B7 G7
+       * rgbg2 = R8 G8 R9 G9 Ra Ga Rb Gb B8 G8 B9 G9 Ba Ga Bb Gb
+       * rgbg3 = Rc Gc Rd Gd Re Ge Rf Gf Bc Gc Bd Gd Be Ge Bf Gf
+       */
+      rgbg0 = vec_perm(rgb0, rgb0, (__vector unsigned char)RGBG_INDEX);
+      rgbg1 = vec_perm(rgb1, rgb1, (__vector unsigned char)RGBG_INDEX);
+      rgbg2 = vec_perm(rgb2, rgb2, (__vector unsigned char)RGBG_INDEX);
+      rgbg3 = vec_perm(rgb3, rgb3, (__vector unsigned char)RGBG_INDEX);
+#endif
+
+      /* rg0 = R0 G0 R1 G1 R2 G2 R3 G3
+       * bg0 = B0 G0 B1 G1 B2 G2 B3 G3
+       * ...
+       *
+       * NOTE: We have to use vec_merge*() here because vec_unpack*() doesn't
+       * support unsigned vectors.
+       */
+      rg0 = (__vector signed short)VEC_UNPACKHU(rgbg0);
+      bg0 = (__vector signed short)VEC_UNPACKLU(rgbg0);
+      rg1 = (__vector signed short)VEC_UNPACKHU(rgbg1);
+      bg1 = (__vector signed short)VEC_UNPACKLU(rgbg1);
+      rg2 = (__vector signed short)VEC_UNPACKHU(rgbg2);
+      bg2 = (__vector signed short)VEC_UNPACKLU(rgbg2);
+      rg3 = (__vector signed short)VEC_UNPACKHU(rgbg3);
+      bg3 = (__vector signed short)VEC_UNPACKLU(rgbg3);
+
+      /* (Original)
+       * Y  =  0.29900 * R + 0.58700 * G + 0.11400 * B
+       * Cb = -0.16874 * R - 0.33126 * G + 0.50000 * B + CENTERJSAMPLE
+       * Cr =  0.50000 * R - 0.41869 * G - 0.08131 * B + CENTERJSAMPLE
+       *
+       * (This implementation)
+       * Y  =  0.29900 * R + 0.33700 * G + 0.11400 * B + 0.25000 * G
+       * Cb = -0.16874 * R - 0.33126 * G + 0.50000 * B + CENTERJSAMPLE
+       * Cr =  0.50000 * R - 0.41869 * G - 0.08131 * B + CENTERJSAMPLE
+       */
+
+      /* Calculate Y values */
+
+      y0 = vec_msums(rg0, pw_f0299_f0337, pd_onehalf);
+      y1 = vec_msums(rg1, pw_f0299_f0337, pd_onehalf);
+      y2 = vec_msums(rg2, pw_f0299_f0337, pd_onehalf);
+      y3 = vec_msums(rg3, pw_f0299_f0337, pd_onehalf);
+      y0 = vec_msums(bg0, pw_f0114_f0250, y0);
+      y1 = vec_msums(bg1, pw_f0114_f0250, y1);
+      y2 = vec_msums(bg2, pw_f0114_f0250, y2);
+      y3 = vec_msums(bg3, pw_f0114_f0250, y3);
+      /* Clever way to avoid 4 shifts + 2 packs.  This packs the high word from
+       * each dword into a new 16-bit vector, which is the equivalent of
+       * descaling the 32-bit results (right-shifting by 16 bits) and then
+       * packing them.
+       */
+      yl = vec_perm((__vector unsigned short)y0, (__vector unsigned short)y1,
+                    shift_pack_index);
+      yh = vec_perm((__vector unsigned short)y2, (__vector unsigned short)y3,
+                    shift_pack_index);
+      y = vec_pack(yl, yh);
+      vec_st(y, 0, outptr0);
+
+      /* Calculate Cb values */
+      cb0 = vec_msums(rg0, pw_mf016_mf033, pd_onehalfm1_cj);
+      cb1 = vec_msums(rg1, pw_mf016_mf033, pd_onehalfm1_cj);
+      cb2 = vec_msums(rg2, pw_mf016_mf033, pd_onehalfm1_cj);
+      cb3 = vec_msums(rg3, pw_mf016_mf033, pd_onehalfm1_cj);
+      cb0 = (__vector int)vec_msum((__vector unsigned short)bg0, pw_f050_f000,
+                                   (__vector unsigned int)cb0);
+      cb1 = (__vector int)vec_msum((__vector unsigned short)bg1, pw_f050_f000,
+                                   (__vector unsigned int)cb1);
+      cb2 = (__vector int)vec_msum((__vector unsigned short)bg2, pw_f050_f000,
+                                   (__vector unsigned int)cb2);
+      cb3 = (__vector int)vec_msum((__vector unsigned short)bg3, pw_f050_f000,
+                                   (__vector unsigned int)cb3);
+      cbl = vec_perm((__vector unsigned short)cb0,
+                     (__vector unsigned short)cb1, shift_pack_index);
+      cbh = vec_perm((__vector unsigned short)cb2,
+                     (__vector unsigned short)cb3, shift_pack_index);
+      cb = vec_pack(cbl, cbh);
+      vec_st(cb, 0, outptr1);
+
+      /* Calculate Cr values */
+      cr0 = vec_msums(bg0, pw_mf008_mf041, pd_onehalfm1_cj);
+      cr1 = vec_msums(bg1, pw_mf008_mf041, pd_onehalfm1_cj);
+      cr2 = vec_msums(bg2, pw_mf008_mf041, pd_onehalfm1_cj);
+      cr3 = vec_msums(bg3, pw_mf008_mf041, pd_onehalfm1_cj);
+      cr0 = (__vector int)vec_msum((__vector unsigned short)rg0, pw_f050_f000,
+                                   (__vector unsigned int)cr0);
+      cr1 = (__vector int)vec_msum((__vector unsigned short)rg1, pw_f050_f000,
+                                   (__vector unsigned int)cr1);
+      cr2 = (__vector int)vec_msum((__vector unsigned short)rg2, pw_f050_f000,
+                                   (__vector unsigned int)cr2);
+      cr3 = (__vector int)vec_msum((__vector unsigned short)rg3, pw_f050_f000,
+                                   (__vector unsigned int)cr3);
+      crl = vec_perm((__vector unsigned short)cr0,
+                     (__vector unsigned short)cr1, shift_pack_index);
+      crh = vec_perm((__vector unsigned short)cr2,
+                     (__vector unsigned short)cr3, shift_pack_index);
+      cr = vec_pack(crl, crh);
+      vec_st(cr, 0, outptr2);
+    }
+  }
+}
diff --git a/3rdparty/libjpeg/src/simd/powerpc/jccolor-altivec.c b/3rdparty/libjpeg/src/simd/powerpc/jccolor-altivec.c
new file mode 100644
index 00000000..d670dbcd
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/powerpc/jccolor-altivec.c
@@ -0,0 +1,116 @@
+/*
+ * AltiVec optimizations for libjpeg-turbo
+ *
+ * Copyright (C) 2014, D. R. Commander.  All Rights Reserved.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+/* RGB --> YCC CONVERSION */
+
+#include "jsimd_altivec.h"
+
+
+#define F_0_081  5329                 /* FIX(0.08131) */
+#define F_0_114  7471                 /* FIX(0.11400) */
+#define F_0_168  11059                /* FIX(0.16874) */
+#define F_0_250  16384                /* FIX(0.25000) */
+#define F_0_299  19595                /* FIX(0.29900) */
+#define F_0_331  21709                /* FIX(0.33126) */
+#define F_0_418  27439                /* FIX(0.41869) */
+#define F_0_500  32768                /* FIX(0.50000) */
+#define F_0_587  38470                /* FIX(0.58700) */
+#define F_0_337  (F_0_587 - F_0_250)  /* FIX(0.58700) - FIX(0.25000) */
+
+#define SCALEBITS  16
+#define ONE_HALF  (1 << (SCALEBITS - 1))
+
+
+#define RGBG_INDEX0 \
+  {  0,  1,  3,  4,  6,  7,  9, 10,  2,  1,  5,  4,  8,  7, 11, 10 }
+#define RGBG_INDEX1 \
+  { 12, 13, 15, 16, 18, 19, 21, 22, 14, 13, 17, 16, 20, 19, 23, 22 }
+#define RGBG_INDEX2 \
+  {  8,  9, 11, 12, 14, 15, 17, 18, 10,  9, 13, 12, 16, 15, 19, 18 }
+#define RGBG_INDEX3 \
+  {  4,  5,  7,  8, 10, 11, 13, 14,  6,  5,  9,  8, 12, 11, 15, 14 }
+#include "jccolext-altivec.c"
+#undef RGB_PIXELSIZE
+
+#define RGB_PIXELSIZE  EXT_RGB_PIXELSIZE
+#define jsimd_rgb_ycc_convert_altivec  jsimd_extrgb_ycc_convert_altivec
+#include "jccolext-altivec.c"
+#undef RGB_PIXELSIZE
+#undef RGBG_INDEX0
+#undef RGBG_INDEX1
+#undef RGBG_INDEX2
+#undef RGBG_INDEX3
+#undef jsimd_rgb_ycc_convert_altivec
+
+#define RGB_PIXELSIZE  EXT_RGBX_PIXELSIZE
+#define RGBG_INDEX \
+  {  0,  1,  4,  5,  8,  9, 12, 13,  2,  1,  6,  5, 10,  9, 14, 13 }
+#define jsimd_rgb_ycc_convert_altivec  jsimd_extrgbx_ycc_convert_altivec
+#include "jccolext-altivec.c"
+#undef RGB_PIXELSIZE
+#undef RGBG_INDEX
+#undef jsimd_rgb_ycc_convert_altivec
+
+#define RGB_PIXELSIZE  EXT_BGR_PIXELSIZE
+#define RGBG_INDEX0 \
+  {  2,  1,  5,  4,  8,  7, 11, 10,  0,  1,  3,  4,  6,  7,  9, 10 }
+#define RGBG_INDEX1 \
+  { 14, 13, 17, 16, 20, 19, 23, 22, 12, 13, 15, 16, 18, 19, 21, 22 }
+#define RGBG_INDEX2 \
+  { 10,  9, 13, 12, 16, 15, 19, 18,  8,  9, 11, 12, 14, 15, 17, 18 }
+#define RGBG_INDEX3 \
+  {  6,  5,  9,  8, 12, 11, 15, 14,  4,  5,  7,  8, 10, 11, 13, 14 }
+#define jsimd_rgb_ycc_convert_altivec  jsimd_extbgr_ycc_convert_altivec
+#include "jccolext-altivec.c"
+#undef RGB_PIXELSIZE
+#undef RGBG_INDEX0
+#undef RGBG_INDEX1
+#undef RGBG_INDEX2
+#undef RGBG_INDEX3
+#undef jsimd_rgb_ycc_convert_altivec
+
+#define RGB_PIXELSIZE  EXT_BGRX_PIXELSIZE
+#define RGBG_INDEX \
+  {  2,  1,  6,  5, 10,  9, 14, 13,  0,  1,  4,  5,  8,  9, 12, 13 }
+#define jsimd_rgb_ycc_convert_altivec  jsimd_extbgrx_ycc_convert_altivec
+#include "jccolext-altivec.c"
+#undef RGB_PIXELSIZE
+#undef RGBG_INDEX
+#undef jsimd_rgb_ycc_convert_altivec
+
+#define RGB_PIXELSIZE  EXT_XBGR_PIXELSIZE
+#define RGBG_INDEX \
+  {  3,  2,  7,  6, 11, 10, 15, 14,  1,  2,  5,  6,  9, 10, 13, 14 }
+#define jsimd_rgb_ycc_convert_altivec  jsimd_extxbgr_ycc_convert_altivec
+#include "jccolext-altivec.c"
+#undef RGB_PIXELSIZE
+#undef RGBG_INDEX
+#undef jsimd_rgb_ycc_convert_altivec
+
+#define RGB_PIXELSIZE  EXT_XRGB_PIXELSIZE
+#define RGBG_INDEX \
+  {  1,  2,  5,  6,  9, 10, 13, 14,  3,  2,  7,  6, 11, 10, 15, 14 }
+#define jsimd_rgb_ycc_convert_altivec  jsimd_extxrgb_ycc_convert_altivec
+#include "jccolext-altivec.c"
+#undef RGB_PIXELSIZE
+#undef RGBG_INDEX
+#undef jsimd_rgb_ycc_convert_altivec
diff --git a/3rdparty/libjpeg/src/simd/powerpc/jcgray-altivec.c b/3rdparty/libjpeg/src/simd/powerpc/jcgray-altivec.c
new file mode 100644
index 00000000..a11a7e70
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/powerpc/jcgray-altivec.c
@@ -0,0 +1,111 @@
+/*
+ * AltiVec optimizations for libjpeg-turbo
+ *
+ * Copyright (C) 2014, D. R. Commander.  All Rights Reserved.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+/* RGB --> GRAYSCALE CONVERSION */
+
+#include "jsimd_altivec.h"
+
+
+#define F_0_114  7471                 /* FIX(0.11400) */
+#define F_0_250  16384                /* FIX(0.25000) */
+#define F_0_299  19595                /* FIX(0.29900) */
+#define F_0_587  38470                /* FIX(0.58700) */
+#define F_0_337  (F_0_587 - F_0_250)  /* FIX(0.58700) - FIX(0.25000) */
+
+#define SCALEBITS  16
+#define ONE_HALF  (1 << (SCALEBITS - 1))
+
+
+#define RGBG_INDEX0 \
+  {  0,  1,  3,  4,  6,  7,  9, 10,  2,  1,  5,  4,  8,  7, 11, 10 }
+#define RGBG_INDEX1 \
+  { 12, 13, 15, 16, 18, 19, 21, 22, 14, 13, 17, 16, 20, 19, 23, 22 }
+#define RGBG_INDEX2 \
+  {  8,  9, 11, 12, 14, 15, 17, 18, 10,  9, 13, 12, 16, 15, 19, 18 }
+#define RGBG_INDEX3 \
+  {  4,  5,  7,  8, 10, 11, 13, 14,  6,  5,  9,  8, 12, 11, 15, 14 }
+#include "jcgryext-altivec.c"
+#undef RGB_PIXELSIZE
+
+#define RGB_PIXELSIZE  EXT_RGB_PIXELSIZE
+#define jsimd_rgb_gray_convert_altivec  jsimd_extrgb_gray_convert_altivec
+#include "jcgryext-altivec.c"
+#undef RGB_PIXELSIZE
+#undef RGBG_INDEX0
+#undef RGBG_INDEX1
+#undef RGBG_INDEX2
+#undef RGBG_INDEX3
+#undef jsimd_rgb_gray_convert_altivec
+
+#define RGB_PIXELSIZE  EXT_RGBX_PIXELSIZE
+#define RGBG_INDEX \
+  {  0,  1,  4,  5,  8,  9, 12, 13,  2,  1,  6,  5, 10,  9, 14, 13 }
+#define jsimd_rgb_gray_convert_altivec  jsimd_extrgbx_gray_convert_altivec
+#include "jcgryext-altivec.c"
+#undef RGB_PIXELSIZE
+#undef RGBG_INDEX
+#undef jsimd_rgb_gray_convert_altivec
+
+#define RGB_PIXELSIZE  EXT_BGR_PIXELSIZE
+#define RGBG_INDEX0 \
+  {  2,  1,  5,  4,  8,  7, 11, 10,  0,  1,  3,  4,  6,  7,  9, 10 }
+#define RGBG_INDEX1 \
+  { 14, 13, 17, 16, 20, 19, 23, 22, 12, 13, 15, 16, 18, 19, 21, 22 }
+#define RGBG_INDEX2 \
+  { 10,  9, 13, 12, 16, 15, 19, 18,  8,  9, 11, 12, 14, 15, 17, 18 }
+#define RGBG_INDEX3 \
+  {  6,  5,  9,  8, 12, 11, 15, 14,  4,  5,  7,  8, 10, 11, 13, 14 }
+#define jsimd_rgb_gray_convert_altivec  jsimd_extbgr_gray_convert_altivec
+#include "jcgryext-altivec.c"
+#undef RGB_PIXELSIZE
+#undef RGBG_INDEX0
+#undef RGBG_INDEX1
+#undef RGBG_INDEX2
+#undef RGBG_INDEX3
+#undef jsimd_rgb_gray_convert_altivec
+
+#define RGB_PIXELSIZE  EXT_BGRX_PIXELSIZE
+#define RGBG_INDEX \
+  {  2,  1,  6,  5, 10,  9, 14, 13,  0,  1,  4,  5,  8,  9, 12, 13 }
+#define jsimd_rgb_gray_convert_altivec  jsimd_extbgrx_gray_convert_altivec
+#include "jcgryext-altivec.c"
+#undef RGB_PIXELSIZE
+#undef RGBG_INDEX
+#undef jsimd_rgb_gray_convert_altivec
+
+#define RGB_PIXELSIZE  EXT_XBGR_PIXELSIZE
+#define RGBG_INDEX \
+  {  3,  2,  7,  6, 11, 10, 15, 14,  1,  2,  5,  6,  9, 10, 13, 14 }
+#define jsimd_rgb_gray_convert_altivec  jsimd_extxbgr_gray_convert_altivec
+#include "jcgryext-altivec.c"
+#undef RGB_PIXELSIZE
+#undef RGBG_INDEX
+#undef jsimd_rgb_gray_convert_altivec
+
+#define RGB_PIXELSIZE  EXT_XRGB_PIXELSIZE
+#define RGBG_INDEX \
+  {  1,  2,  5,  6,  9, 10, 13, 14,  3,  2,  7,  6, 11, 10, 15, 14 }
+#define jsimd_rgb_gray_convert_altivec  jsimd_extxrgb_gray_convert_altivec
+#include "jcgryext-altivec.c"
+#undef RGB_PIXELSIZE
+#undef RGBG_INDEX
+#undef jsimd_rgb_gray_convert_altivec
diff --git a/3rdparty/libjpeg/src/simd/powerpc/jcgryext-altivec.c b/3rdparty/libjpeg/src/simd/powerpc/jcgryext-altivec.c
new file mode 100644
index 00000000..b280cbbd
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/powerpc/jcgryext-altivec.c
@@ -0,0 +1,228 @@
+/*
+ * AltiVec optimizations for libjpeg-turbo
+ *
+ * Copyright (C) 2014-2015, D. R. Commander.  All Rights Reserved.
+ * Copyright (C) 2014, Jay Foad.  All Rights Reserved.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+/* This file is included by jcgray-altivec.c */
+
+
+void jsimd_rgb_gray_convert_altivec(JDIMENSION img_width, JSAMPARRAY input_buf,
+                                    JSAMPIMAGE output_buf,
+                                    JDIMENSION output_row, int num_rows)
+{
+  JSAMPROW inptr, outptr;
+  int pitch = img_width * RGB_PIXELSIZE, num_cols;
+#if __BIG_ENDIAN__
+  int offset;
+  unsigned char __attribute__((aligned(16))) tmpbuf[RGB_PIXELSIZE * 16];
+#endif
+
+  __vector unsigned char rgb0, rgb1 = { 0 }, rgb2 = { 0 },
+    rgbg0, rgbg1, rgbg2, rgbg3, y;
+#if __BIG_ENDIAN__ || RGB_PIXELSIZE == 4
+  __vector unsigned char rgb3 = { 0 };
+#endif
+#if __BIG_ENDIAN__ && RGB_PIXELSIZE == 4
+  __vector unsigned char rgb4 = { 0 };
+#endif
+  __vector short rg0, rg1, rg2, rg3, bg0, bg1, bg2, bg3;
+  __vector unsigned short yl, yh;
+  __vector int y0, y1, y2, y3;
+
+  /* Constants */
+  __vector short pw_f0299_f0337 = { __4X2(F_0_299, F_0_337) },
+    pw_f0114_f0250 = { __4X2(F_0_114, F_0_250) };
+  __vector int pd_onehalf = { __4X(ONE_HALF) };
+  __vector unsigned char pb_zero = { __16X(0) },
+#if __BIG_ENDIAN__
+    shift_pack_index =
+      { 0, 1, 4, 5,  8,  9, 12, 13, 16, 17, 20, 21, 24, 25, 28, 29 };
+#else
+    shift_pack_index =
+      { 2, 3, 6, 7, 10, 11, 14, 15, 18, 19, 22, 23, 26, 27, 30, 31 };
+#endif
+
+  while (--num_rows >= 0) {
+    inptr = *input_buf++;
+    outptr = output_buf[0][output_row];
+    output_row++;
+
+    for (num_cols = pitch; num_cols > 0;
+         num_cols -= RGB_PIXELSIZE * 16, inptr += RGB_PIXELSIZE * 16,
+         outptr += 16) {
+
+#if __BIG_ENDIAN__
+      /* Load 16 pixels == 48 or 64 bytes */
+      offset = (size_t)inptr & 15;
+      if (offset) {
+        __vector unsigned char unaligned_shift_index;
+        int bytes = num_cols + offset;
+
+        if (bytes < (RGB_PIXELSIZE + 1) * 16 && (bytes & 15)) {
+          /* Slow path to prevent buffer overread.  Since there is no way to
+           * read a partial AltiVec register, overread would occur on the last
+           * chunk of the last image row if the right edge is not on a 16-byte
+           * boundary.  It could also occur on other rows if the bytes per row
+           * is low enough.  Since we can't determine whether we're on the last
+           * image row, we have to assume every row is the last.
+           */
+          memcpy(tmpbuf, inptr, min(num_cols, RGB_PIXELSIZE * 16));
+          rgb0 = vec_ld(0, tmpbuf);
+          rgb1 = vec_ld(16, tmpbuf);
+          rgb2 = vec_ld(32, tmpbuf);
+#if RGB_PIXELSIZE == 4
+          rgb3 = vec_ld(48, tmpbuf);
+#endif
+        } else {
+          /* Fast path */
+          rgb0 = vec_ld(0, inptr);
+          if (bytes > 16)
+            rgb1 = vec_ld(16, inptr);
+          if (bytes > 32)
+            rgb2 = vec_ld(32, inptr);
+          if (bytes > 48)
+            rgb3 = vec_ld(48, inptr);
+#if RGB_PIXELSIZE == 4
+          if (bytes > 64)
+            rgb4 = vec_ld(64, inptr);
+#endif
+          unaligned_shift_index = vec_lvsl(0, inptr);
+          rgb0 = vec_perm(rgb0, rgb1, unaligned_shift_index);
+          rgb1 = vec_perm(rgb1, rgb2, unaligned_shift_index);
+          rgb2 = vec_perm(rgb2, rgb3, unaligned_shift_index);
+#if RGB_PIXELSIZE == 4
+          rgb3 = vec_perm(rgb3, rgb4, unaligned_shift_index);
+#endif
+        }
+      } else {
+        if (num_cols < RGB_PIXELSIZE * 16 && (num_cols & 15)) {
+          /* Slow path */
+          memcpy(tmpbuf, inptr, min(num_cols, RGB_PIXELSIZE * 16));
+          rgb0 = vec_ld(0, tmpbuf);
+          rgb1 = vec_ld(16, tmpbuf);
+          rgb2 = vec_ld(32, tmpbuf);
+#if RGB_PIXELSIZE == 4
+          rgb3 = vec_ld(48, tmpbuf);
+#endif
+        } else {
+          /* Fast path */
+          rgb0 = vec_ld(0, inptr);
+          if (num_cols > 16)
+            rgb1 = vec_ld(16, inptr);
+          if (num_cols > 32)
+            rgb2 = vec_ld(32, inptr);
+#if RGB_PIXELSIZE == 4
+          if (num_cols > 48)
+            rgb3 = vec_ld(48, inptr);
+#endif
+        }
+      }
+#else
+      /* Little endian */
+      rgb0 = vec_vsx_ld(0, inptr);
+      if (num_cols > 16)
+        rgb1 = vec_vsx_ld(16, inptr);
+      if (num_cols > 32)
+        rgb2 = vec_vsx_ld(32, inptr);
+#if RGB_PIXELSIZE == 4
+      if (num_cols > 48)
+        rgb3 = vec_vsx_ld(48, inptr);
+#endif
+#endif
+
+#if RGB_PIXELSIZE == 3
+      /* rgb0 = R0 G0 B0 R1 G1 B1 R2 G2 B2 R3 G3 B3 R4 G4 B4 R5
+       * rgb1 = G5 B5 R6 G6 B6 R7 G7 B7 R8 G8 B8 R9 G9 B9 Ra Ga
+       * rgb2 = Ba Rb Gb Bb Rc Gc Bc Rd Gd Bd Re Ge Be Rf Gf Bf
+       *
+       * rgbg0 = R0 G0 R1 G1 R2 G2 R3 G3 B0 G0 B1 G1 B2 G2 B3 G3
+       * rgbg1 = R4 G4 R5 G5 R6 G6 R7 G7 B4 G4 B5 G5 B6 G6 B7 G7
+       * rgbg2 = R8 G8 R9 G9 Ra Ga Rb Gb B8 G8 B9 G9 Ba Ga Bb Gb
+       * rgbg3 = Rc Gc Rd Gd Re Ge Rf Gf Bc Gc Bd Gd Be Ge Bf Gf
+       */
+      rgbg0 = vec_perm(rgb0, rgb0, (__vector unsigned char)RGBG_INDEX0);
+      rgbg1 = vec_perm(rgb0, rgb1, (__vector unsigned char)RGBG_INDEX1);
+      rgbg2 = vec_perm(rgb1, rgb2, (__vector unsigned char)RGBG_INDEX2);
+      rgbg3 = vec_perm(rgb2, rgb2, (__vector unsigned char)RGBG_INDEX3);
+#else
+      /* rgb0 = R0 G0 B0 X0 R1 G1 B1 X1 R2 G2 B2 X2 R3 G3 B3 X3
+       * rgb1 = R4 G4 B4 X4 R5 G5 B5 X5 R6 G6 B6 X6 R7 G7 B7 X7
+       * rgb2 = R8 G8 B8 X8 R9 G9 B9 X9 Ra Ga Ba Xa Rb Gb Bb Xb
+       * rgb3 = Rc Gc Bc Xc Rd Gd Bd Xd Re Ge Be Xe Rf Gf Bf Xf
+       *
+       * rgbg0 = R0 G0 R1 G1 R2 G2 R3 G3 B0 G0 B1 G1 B2 G2 B3 G3
+       * rgbg1 = R4 G4 R5 G5 R6 G6 R7 G7 B4 G4 B5 G5 B6 G6 B7 G7
+       * rgbg2 = R8 G8 R9 G9 Ra Ga Rb Gb B8 G8 B9 G9 Ba Ga Bb Gb
+       * rgbg3 = Rc Gc Rd Gd Re Ge Rf Gf Bc Gc Bd Gd Be Ge Bf Gf
+       */
+      rgbg0 = vec_perm(rgb0, rgb0, (__vector unsigned char)RGBG_INDEX);
+      rgbg1 = vec_perm(rgb1, rgb1, (__vector unsigned char)RGBG_INDEX);
+      rgbg2 = vec_perm(rgb2, rgb2, (__vector unsigned char)RGBG_INDEX);
+      rgbg3 = vec_perm(rgb3, rgb3, (__vector unsigned char)RGBG_INDEX);
+#endif
+
+      /* rg0 = R0 G0 R1 G1 R2 G2 R3 G3
+       * bg0 = B0 G0 B1 G1 B2 G2 B3 G3
+       * ...
+       *
+       * NOTE: We have to use vec_merge*() here because vec_unpack*() doesn't
+       * support unsigned vectors.
+       */
+      rg0 = (__vector signed short)VEC_UNPACKHU(rgbg0);
+      bg0 = (__vector signed short)VEC_UNPACKLU(rgbg0);
+      rg1 = (__vector signed short)VEC_UNPACKHU(rgbg1);
+      bg1 = (__vector signed short)VEC_UNPACKLU(rgbg1);
+      rg2 = (__vector signed short)VEC_UNPACKHU(rgbg2);
+      bg2 = (__vector signed short)VEC_UNPACKLU(rgbg2);
+      rg3 = (__vector signed short)VEC_UNPACKHU(rgbg3);
+      bg3 = (__vector signed short)VEC_UNPACKLU(rgbg3);
+
+      /* (Original)
+       * Y  =  0.29900 * R + 0.58700 * G + 0.11400 * B
+       *
+       * (This implementation)
+       * Y  =  0.29900 * R + 0.33700 * G + 0.11400 * B + 0.25000 * G
+       */
+
+      /* Calculate Y values */
+
+      y0 = vec_msums(rg0, pw_f0299_f0337, pd_onehalf);
+      y1 = vec_msums(rg1, pw_f0299_f0337, pd_onehalf);
+      y2 = vec_msums(rg2, pw_f0299_f0337, pd_onehalf);
+      y3 = vec_msums(rg3, pw_f0299_f0337, pd_onehalf);
+      y0 = vec_msums(bg0, pw_f0114_f0250, y0);
+      y1 = vec_msums(bg1, pw_f0114_f0250, y1);
+      y2 = vec_msums(bg2, pw_f0114_f0250, y2);
+      y3 = vec_msums(bg3, pw_f0114_f0250, y3);
+      /* Clever way to avoid 4 shifts + 2 packs.  This packs the high word from
+       * each dword into a new 16-bit vector, which is the equivalent of
+       * descaling the 32-bit results (right-shifting by 16 bits) and then
+       * packing them.
+       */
+      yl = vec_perm((__vector unsigned short)y0, (__vector unsigned short)y1,
+                    shift_pack_index);
+      yh = vec_perm((__vector unsigned short)y2, (__vector unsigned short)y3,
+                    shift_pack_index);
+      y = vec_pack(yl, yh);
+      vec_st(y, 0, outptr);
+    }
+  }
+}
diff --git a/3rdparty/libjpeg/src/simd/powerpc/jcsample-altivec.c b/3rdparty/libjpeg/src/simd/powerpc/jcsample-altivec.c
new file mode 100644
index 00000000..6e25b8db
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/powerpc/jcsample-altivec.c
@@ -0,0 +1,159 @@
+/*
+ * AltiVec optimizations for libjpeg-turbo
+ *
+ * Copyright (C) 2015, D. R. Commander.  All Rights Reserved.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+/* CHROMA DOWNSAMPLING */
+
+#include "jsimd_altivec.h"
+#include "jcsample.h"
+
+
+void jsimd_h2v1_downsample_altivec(JDIMENSION image_width,
+                                   int max_v_samp_factor,
+                                   JDIMENSION v_samp_factor,
+                                   JDIMENSION width_in_blocks,
+                                   JSAMPARRAY input_data,
+                                   JSAMPARRAY output_data)
+{
+  int outrow, outcol;
+  JDIMENSION output_cols = width_in_blocks * DCTSIZE;
+  JSAMPROW inptr, outptr;
+
+  __vector unsigned char this0, next0, out;
+  __vector unsigned short this0e, this0o, next0e, next0o, outl, outh;
+
+  /* Constants */
+  __vector unsigned short pw_bias = { __4X2(0, 1) },
+    pw_one = { __8X(1) };
+  __vector unsigned char even_odd_index =
+    {  0,  2,  4,  6,  8, 10, 12, 14,  1,  3,  5,  7,  9, 11, 13, 15 },
+    pb_zero = { __16X(0) };
+
+  expand_right_edge(input_data, max_v_samp_factor, image_width,
+                    output_cols * 2);
+
+  for (outrow = 0; outrow < v_samp_factor; outrow++) {
+    outptr = output_data[outrow];
+    inptr = input_data[outrow];
+
+    for (outcol = output_cols; outcol > 0;
+         outcol -= 16, inptr += 32, outptr += 16) {
+
+      this0 = vec_ld(0, inptr);
+      this0 = vec_perm(this0, this0, even_odd_index);
+      this0e = (__vector unsigned short)VEC_UNPACKHU(this0);
+      this0o = (__vector unsigned short)VEC_UNPACKLU(this0);
+      outl = vec_add(this0e, this0o);
+      outl = vec_add(outl, pw_bias);
+      outl = vec_sr(outl, pw_one);
+
+      if (outcol > 8) {
+        next0 = vec_ld(16, inptr);
+        next0 = vec_perm(next0, next0, even_odd_index);
+        next0e = (__vector unsigned short)VEC_UNPACKHU(next0);
+        next0o = (__vector unsigned short)VEC_UNPACKLU(next0);
+        outh = vec_add(next0e, next0o);
+        outh = vec_add(outh, pw_bias);
+        outh = vec_sr(outh, pw_one);
+      } else
+        outh = vec_splat_u16(0);
+
+      out = vec_pack(outl, outh);
+      vec_st(out, 0, outptr);
+    }
+  }
+}
+
+
+void
+jsimd_h2v2_downsample_altivec(JDIMENSION image_width, int max_v_samp_factor,
+                              JDIMENSION v_samp_factor,
+                              JDIMENSION width_in_blocks,
+                              JSAMPARRAY input_data, JSAMPARRAY output_data)
+{
+  int inrow, outrow, outcol;
+  JDIMENSION output_cols = width_in_blocks * DCTSIZE;
+  JSAMPROW inptr0, inptr1, outptr;
+
+  __vector unsigned char this0, next0, this1, next1, out;
+  __vector unsigned short this0e, this0o, next0e, next0o, this1e, this1o,
+    next1e, next1o, out0l, out0h, out1l, out1h, outl, outh;
+
+  /* Constants */
+  __vector unsigned short pw_bias = { __4X2(1, 2) },
+    pw_two = { __8X(2) };
+  __vector unsigned char even_odd_index =
+    {  0,  2,  4,  6,  8, 10, 12, 14,  1,  3,  5,  7,  9, 11, 13, 15 },
+    pb_zero = { __16X(0) };
+
+  expand_right_edge(input_data, max_v_samp_factor, image_width,
+                    output_cols * 2);
+
+  for (inrow = 0, outrow = 0; outrow < v_samp_factor;
+       inrow += 2, outrow++) {
+
+    inptr0 = input_data[inrow];
+    inptr1 = input_data[inrow + 1];
+    outptr = output_data[outrow];
+
+    for (outcol = output_cols; outcol > 0;
+         outcol -= 16, inptr0 += 32, inptr1 += 32, outptr += 16) {
+
+      this0 = vec_ld(0, inptr0);
+      this0 = vec_perm(this0, this0, even_odd_index);
+      this0e = (__vector unsigned short)VEC_UNPACKHU(this0);
+      this0o = (__vector unsigned short)VEC_UNPACKLU(this0);
+      out0l = vec_add(this0e, this0o);
+
+      this1 = vec_ld(0, inptr1);
+      this1 = vec_perm(this1, this1, even_odd_index);
+      this1e = (__vector unsigned short)VEC_UNPACKHU(this1);
+      this1o = (__vector unsigned short)VEC_UNPACKLU(this1);
+      out1l = vec_add(this1e, this1o);
+
+      outl = vec_add(out0l, out1l);
+      outl = vec_add(outl, pw_bias);
+      outl = vec_sr(outl, pw_two);
+
+      if (outcol > 8) {
+        next0 = vec_ld(16, inptr0);
+        next0 = vec_perm(next0, next0, even_odd_index);
+        next0e = (__vector unsigned short)VEC_UNPACKHU(next0);
+        next0o = (__vector unsigned short)VEC_UNPACKLU(next0);
+        out0h = vec_add(next0e, next0o);
+
+        next1 = vec_ld(16, inptr1);
+        next1 = vec_perm(next1, next1, even_odd_index);
+        next1e = (__vector unsigned short)VEC_UNPACKHU(next1);
+        next1o = (__vector unsigned short)VEC_UNPACKLU(next1);
+        out1h = vec_add(next1e, next1o);
+
+        outh = vec_add(out0h, out1h);
+        outh = vec_add(outh, pw_bias);
+        outh = vec_sr(outh, pw_two);
+      } else
+        outh = vec_splat_u16(0);
+
+      out = vec_pack(outl, outh);
+      vec_st(out, 0, outptr);
+    }
+  }
+}
diff --git a/3rdparty/libjpeg/src/simd/powerpc/jcsample.h b/3rdparty/libjpeg/src/simd/powerpc/jcsample.h
new file mode 100644
index 00000000..bd07fcc4
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/powerpc/jcsample.h
@@ -0,0 +1,28 @@
+/*
+ * jcsample.h
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1991-1996, Thomas G. Lane.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ */
+
+LOCAL(void)
+expand_right_edge(JSAMPARRAY image_data, int num_rows, JDIMENSION input_cols,
+                  JDIMENSION output_cols)
+{
+  register JSAMPROW ptr;
+  register JSAMPLE pixval;
+  register int count;
+  int row;
+  int numcols = (int)(output_cols - input_cols);
+
+  if (numcols > 0) {
+    for (row = 0; row < num_rows; row++) {
+      ptr = image_data[row] + input_cols;
+      pixval = ptr[-1];
+      for (count = numcols; count > 0; count--)
+        *ptr++ = pixval;
+    }
+  }
+}
diff --git a/3rdparty/libjpeg/src/simd/powerpc/jdcolext-altivec.c b/3rdparty/libjpeg/src/simd/powerpc/jdcolext-altivec.c
new file mode 100644
index 00000000..68d52bd8
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/powerpc/jdcolext-altivec.c
@@ -0,0 +1,276 @@
+/*
+ * AltiVec optimizations for libjpeg-turbo
+ *
+ * Copyright (C) 2015, D. R. Commander.  All Rights Reserved.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+/* This file is included by jdcolor-altivec.c */
+
+
+void jsimd_ycc_rgb_convert_altivec(JDIMENSION out_width, JSAMPIMAGE input_buf,
+                                   JDIMENSION input_row, JSAMPARRAY output_buf,
+                                   int num_rows)
+{
+  JSAMPROW outptr, inptr0, inptr1, inptr2;
+  int pitch = out_width * RGB_PIXELSIZE, num_cols;
+#if __BIG_ENDIAN__
+  int offset;
+#endif
+  unsigned char __attribute__((aligned(16))) tmpbuf[RGB_PIXELSIZE * 16];
+
+  __vector unsigned char rgb0, rgb1, rgb2, rgbx0, rgbx1, rgbx2, rgbx3,
+    y, cb, cr;
+#if __BIG_ENDIAN__
+  __vector unsigned char edgel, edgeh, edges, out0, out1, out2, out3;
+#if RGB_PIXELSIZE == 4
+  __vector unsigned char out4;
+#endif
+#endif
+#if RGB_PIXELSIZE == 4
+  __vector unsigned char rgb3;
+#endif
+  __vector short rg0, rg1, rg2, rg3, bx0, bx1, bx2, bx3, yl, yh, cbl, cbh,
+    crl, crh, rl, rh, gl, gh, bl, bh, g0w, g1w, g2w, g3w;
+  __vector int g0, g1, g2, g3;
+
+  /* Constants
+   * NOTE: The >> 1 is to compensate for the fact that vec_madds() returns 17
+   * high-order bits, not 16.
+   */
+  __vector short pw_f0402 = { __8X(F_0_402 >> 1) },
+    pw_mf0228 = { __8X(-F_0_228 >> 1) },
+    pw_mf0344_f0285 = { __4X2(-F_0_344, F_0_285) },
+    pw_one = { __8X(1) }, pw_255 = { __8X(255) },
+    pw_cj = { __8X(CENTERJSAMPLE) };
+  __vector int pd_onehalf = { __4X(ONE_HALF) };
+  __vector unsigned char pb_zero = { __16X(0) },
+#if __BIG_ENDIAN__
+    shift_pack_index =
+      {  0,  1,  4,  5,  8,  9, 12, 13, 16, 17, 20, 21, 24, 25, 28, 29 };
+#else
+    shift_pack_index =
+      {  2,  3,  6,  7, 10, 11, 14, 15, 18, 19, 22, 23, 26, 27, 30, 31 };
+#endif
+
+  while (--num_rows >= 0) {
+    inptr0 = input_buf[0][input_row];
+    inptr1 = input_buf[1][input_row];
+    inptr2 = input_buf[2][input_row];
+    input_row++;
+    outptr = *output_buf++;
+
+    for (num_cols = pitch; num_cols > 0;
+         num_cols -= RGB_PIXELSIZE * 16, outptr += RGB_PIXELSIZE * 16,
+         inptr0 += 16, inptr1 += 16, inptr2 += 16) {
+
+      y = vec_ld(0, inptr0);
+      /* NOTE: We have to use vec_merge*() here because vec_unpack*() doesn't
+       * support unsigned vectors.
+       */
+      yl = (__vector signed short)VEC_UNPACKHU(y);
+      yh = (__vector signed short)VEC_UNPACKLU(y);
+
+      cb = vec_ld(0, inptr1);
+      cbl = (__vector signed short)VEC_UNPACKHU(cb);
+      cbh = (__vector signed short)VEC_UNPACKLU(cb);
+      cbl = vec_sub(cbl, pw_cj);
+      cbh = vec_sub(cbh, pw_cj);
+
+      cr = vec_ld(0, inptr2);
+      crl = (__vector signed short)VEC_UNPACKHU(cr);
+      crh = (__vector signed short)VEC_UNPACKLU(cr);
+      crl = vec_sub(crl, pw_cj);
+      crh = vec_sub(crh, pw_cj);
+
+      /* (Original)
+       * R = Y                + 1.40200 * Cr
+       * G = Y - 0.34414 * Cb - 0.71414 * Cr
+       * B = Y + 1.77200 * Cb
+       *
+       * (This implementation)
+       * R = Y                + 0.40200 * Cr + Cr
+       * G = Y - 0.34414 * Cb + 0.28586 * Cr - Cr
+       * B = Y - 0.22800 * Cb + Cb + Cb
+       */
+      bl = vec_add(cbl, cbl);
+      bh = vec_add(cbh, cbh);
+      bl = vec_madds(bl, pw_mf0228, pw_one);
+      bh = vec_madds(bh, pw_mf0228, pw_one);
+      bl = vec_sra(bl, (__vector unsigned short)pw_one);
+      bh = vec_sra(bh, (__vector unsigned short)pw_one);
+      bl = vec_add(bl, cbl);
+      bh = vec_add(bh, cbh);
+      bl = vec_add(bl, cbl);
+      bh = vec_add(bh, cbh);
+      bl = vec_add(bl, yl);
+      bh = vec_add(bh, yh);
+
+      rl = vec_add(crl, crl);
+      rh = vec_add(crh, crh);
+      rl = vec_madds(rl, pw_f0402, pw_one);
+      rh = vec_madds(rh, pw_f0402, pw_one);
+      rl = vec_sra(rl, (__vector unsigned short)pw_one);
+      rh = vec_sra(rh, (__vector unsigned short)pw_one);
+      rl = vec_add(rl, crl);
+      rh = vec_add(rh, crh);
+      rl = vec_add(rl, yl);
+      rh = vec_add(rh, yh);
+
+      g0w = vec_mergeh(cbl, crl);
+      g1w = vec_mergel(cbl, crl);
+      g0 = vec_msums(g0w, pw_mf0344_f0285, pd_onehalf);
+      g1 = vec_msums(g1w, pw_mf0344_f0285, pd_onehalf);
+      g2w = vec_mergeh(cbh, crh);
+      g3w = vec_mergel(cbh, crh);
+      g2 = vec_msums(g2w, pw_mf0344_f0285, pd_onehalf);
+      g3 = vec_msums(g3w, pw_mf0344_f0285, pd_onehalf);
+      /* Clever way to avoid 4 shifts + 2 packs.  This packs the high word from
+       * each dword into a new 16-bit vector, which is the equivalent of
+       * descaling the 32-bit results (right-shifting by 16 bits) and then
+       * packing them.
+       */
+      gl = vec_perm((__vector short)g0, (__vector short)g1, shift_pack_index);
+      gh = vec_perm((__vector short)g2, (__vector short)g3, shift_pack_index);
+      gl = vec_sub(gl, crl);
+      gh = vec_sub(gh, crh);
+      gl = vec_add(gl, yl);
+      gh = vec_add(gh, yh);
+
+      rg0 = vec_mergeh(rl, gl);
+      bx0 = vec_mergeh(bl, pw_255);
+      rg1 = vec_mergel(rl, gl);
+      bx1 = vec_mergel(bl, pw_255);
+      rg2 = vec_mergeh(rh, gh);
+      bx2 = vec_mergeh(bh, pw_255);
+      rg3 = vec_mergel(rh, gh);
+      bx3 = vec_mergel(bh, pw_255);
+
+      rgbx0 = vec_packsu(rg0, bx0);
+      rgbx1 = vec_packsu(rg1, bx1);
+      rgbx2 = vec_packsu(rg2, bx2);
+      rgbx3 = vec_packsu(rg3, bx3);
+
+#if RGB_PIXELSIZE == 3
+      /* rgbx0 = R0 G0 R1 G1 R2 G2 R3 G3 B0 X0 B1 X1 B2 X2 B3 X3
+       * rgbx1 = R4 G4 R5 G5 R6 G6 R7 G7 B4 X4 B5 X5 B6 X6 B7 X7
+       * rgbx2 = R8 G8 R9 G9 Ra Ga Rb Gb B8 X8 B9 X9 Ba Xa Bb Xb
+       * rgbx3 = Rc Gc Rd Gd Re Ge Rf Gf Bc Xc Bd Xd Be Xe Bf Xf
+       *
+       * rgb0 = R0 G0 B0 R1 G1 B1 R2 G2 B2 R3 G3 B3 R4 G4 B4 R5
+       * rgb1 = G5 B5 R6 G6 B6 R7 G7 B7 R8 G8 B8 R9 G9 B9 Ra Ga
+       * rgb2 = Ba Rb Gb Bb Rc Gc Bc Rd Gd Bd Re Ge Be Rf Gf Bf
+       */
+      rgb0 = vec_perm(rgbx0, rgbx1, (__vector unsigned char)RGB_INDEX0);
+      rgb1 = vec_perm(rgbx1, rgbx2, (__vector unsigned char)RGB_INDEX1);
+      rgb2 = vec_perm(rgbx2, rgbx3, (__vector unsigned char)RGB_INDEX2);
+#else
+      /* rgbx0 = R0 G0 R1 G1 R2 G2 R3 G3 B0 X0 B1 X1 B2 X2 B3 X3
+       * rgbx1 = R4 G4 R5 G5 R6 G6 R7 G7 B4 X4 B5 X5 B6 X6 B7 X7
+       * rgbx2 = R8 G8 R9 G9 Ra Ga Rb Gb B8 X8 B9 X9 Ba Xa Bb Xb
+       * rgbx3 = Rc Gc Rd Gd Re Ge Rf Gf Bc Xc Bd Xd Be Xe Bf Xf
+       *
+       * rgb0 = R0 G0 B0 X0 R1 G1 B1 X1 R2 G2 B2 X2 R3 G3 B3 X3
+       * rgb1 = R4 G4 B4 X4 R5 G5 B5 X5 R6 G6 B6 X6 R7 G7 B7 X7
+       * rgb2 = R8 G8 B8 X8 R9 G9 B9 X9 Ra Ga Ba Xa Rb Gb Bb Xb
+       * rgb3 = Rc Gc Bc Xc Rd Gd Bd Xd Re Ge Be Xe Rf Gf Bf Xf
+       */
+      rgb0 = vec_perm(rgbx0, rgbx0, (__vector unsigned char)RGB_INDEX);
+      rgb1 = vec_perm(rgbx1, rgbx1, (__vector unsigned char)RGB_INDEX);
+      rgb2 = vec_perm(rgbx2, rgbx2, (__vector unsigned char)RGB_INDEX);
+      rgb3 = vec_perm(rgbx3, rgbx3, (__vector unsigned char)RGB_INDEX);
+#endif
+
+#if __BIG_ENDIAN__
+      offset = (size_t)outptr & 15;
+      if (offset) {
+        __vector unsigned char unaligned_shift_index;
+        int bytes = num_cols + offset;
+
+        if (bytes < (RGB_PIXELSIZE + 1) * 16 && (bytes & 15)) {
+          /* Slow path to prevent buffer overwrite.  Since there is no way to
+           * write a partial AltiVec register, overwrite would occur on the
+           * last chunk of the last image row if the right edge is not on a
+           * 16-byte boundary.  It could also occur on other rows if the bytes
+           * per row is low enough.  Since we can't determine whether we're on
+           * the last image row, we have to assume every row is the last.
+           */
+          vec_st(rgb0, 0, tmpbuf);
+          vec_st(rgb1, 16, tmpbuf);
+          vec_st(rgb2, 32, tmpbuf);
+#if RGB_PIXELSIZE == 4
+          vec_st(rgb3, 48, tmpbuf);
+#endif
+          memcpy(outptr, tmpbuf, min(num_cols, RGB_PIXELSIZE * 16));
+        } else {
+          /* Fast path */
+          unaligned_shift_index = vec_lvsl(0, outptr);
+          edgel = vec_ld(0, outptr);
+          edgeh = vec_ld(min(num_cols - 1, RGB_PIXELSIZE * 16), outptr);
+          edges = vec_perm(edgeh, edgel, unaligned_shift_index);
+          unaligned_shift_index = vec_lvsr(0, outptr);
+          out0 = vec_perm(edges, rgb0, unaligned_shift_index);
+          out1 = vec_perm(rgb0, rgb1, unaligned_shift_index);
+          out2 = vec_perm(rgb1, rgb2, unaligned_shift_index);
+#if RGB_PIXELSIZE == 4
+          out3 = vec_perm(rgb2, rgb3, unaligned_shift_index);
+          out4 = vec_perm(rgb3, edges, unaligned_shift_index);
+#else
+          out3 = vec_perm(rgb2, edges, unaligned_shift_index);
+#endif
+          vec_st(out0, 0, outptr);
+          if (bytes > 16)
+            vec_st(out1, 16, outptr);
+          if (bytes > 32)
+            vec_st(out2, 32, outptr);
+          if (bytes > 48)
+            vec_st(out3, 48, outptr);
+#if RGB_PIXELSIZE == 4
+          if (bytes > 64)
+            vec_st(out4, 64, outptr);
+#endif
+        }
+      } else {
+#endif /* __BIG_ENDIAN__ */
+        if (num_cols < RGB_PIXELSIZE * 16 && (num_cols & 15)) {
+          /* Slow path */
+          VEC_ST(rgb0, 0, tmpbuf);
+          VEC_ST(rgb1, 16, tmpbuf);
+          VEC_ST(rgb2, 32, tmpbuf);
+#if RGB_PIXELSIZE == 4
+          VEC_ST(rgb3, 48, tmpbuf);
+#endif
+          memcpy(outptr, tmpbuf, min(num_cols, RGB_PIXELSIZE * 16));
+        } else {
+          /* Fast path */
+          VEC_ST(rgb0, 0, outptr);
+          if (num_cols > 16)
+            VEC_ST(rgb1, 16, outptr);
+          if (num_cols > 32)
+            VEC_ST(rgb2, 32, outptr);
+#if RGB_PIXELSIZE == 4
+          if (num_cols > 48)
+            VEC_ST(rgb3, 48, outptr);
+#endif
+        }
+#if __BIG_ENDIAN__
+      }
+#endif
+    }
+  }
+}
diff --git a/3rdparty/libjpeg/src/simd/powerpc/jdcolor-altivec.c b/3rdparty/libjpeg/src/simd/powerpc/jdcolor-altivec.c
new file mode 100644
index 00000000..eb35b671
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/powerpc/jdcolor-altivec.c
@@ -0,0 +1,106 @@
+/*
+ * AltiVec optimizations for libjpeg-turbo
+ *
+ * Copyright (C) 2015, D. R. Commander.  All Rights Reserved.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+/* YCC --> RGB CONVERSION */
+
+#include "jsimd_altivec.h"
+
+
+#define F_0_344  22554              /* FIX(0.34414) */
+#define F_0_714  46802              /* FIX(0.71414) */
+#define F_1_402  91881              /* FIX(1.40200) */
+#define F_1_772  116130             /* FIX(1.77200) */
+#define F_0_402  (F_1_402 - 65536)  /* FIX(1.40200) - FIX(1) */
+#define F_0_285  (65536 - F_0_714)  /* FIX(1) - FIX(0.71414) */
+#define F_0_228  (131072 - F_1_772) /* FIX(2) - FIX(1.77200) */
+
+#define SCALEBITS  16
+#define ONE_HALF  (1 << (SCALEBITS - 1))
+
+#define RGB_INDEX0 \
+  {  0,  1,  8,  2,  3, 10,  4,  5, 12,  6,  7, 14, 16, 17, 24, 18 }
+#define RGB_INDEX1 \
+  {  3, 10,  4,  5, 12,  6,  7, 14, 16, 17, 24, 18, 19, 26, 20, 21 }
+#define RGB_INDEX2 \
+  { 12,  6,  7, 14, 16, 17, 24, 18, 19, 26, 20, 21, 28, 22, 23, 30 }
+#include "jdcolext-altivec.c"
+#undef RGB_PIXELSIZE
+
+#define RGB_PIXELSIZE  EXT_RGB_PIXELSIZE
+#define jsimd_ycc_rgb_convert_altivec  jsimd_ycc_extrgb_convert_altivec
+#include "jdcolext-altivec.c"
+#undef RGB_PIXELSIZE
+#undef RGB_INDEX0
+#undef RGB_INDEX1
+#undef RGB_INDEX2
+#undef jsimd_ycc_rgb_convert_altivec
+
+#define RGB_PIXELSIZE  EXT_RGBX_PIXELSIZE
+#define RGB_INDEX \
+  {  0,  1,  8,  9,  2,  3, 10, 11,  4,  5, 12, 13,  6,  7, 14, 15 }
+#define jsimd_ycc_rgb_convert_altivec  jsimd_ycc_extrgbx_convert_altivec
+#include "jdcolext-altivec.c"
+#undef RGB_PIXELSIZE
+#undef RGB_INDEX
+#undef jsimd_ycc_rgb_convert_altivec
+
+#define RGB_PIXELSIZE  EXT_BGR_PIXELSIZE
+#define RGB_INDEX0 \
+  {  8,  1,  0, 10,  3,  2, 12,  5,  4, 14,  7,  6, 24, 17, 16, 26 }
+#define RGB_INDEX1 \
+  {  3,  2, 12,  5,  4, 14,  7,  6, 24, 17, 16, 26, 19, 18, 28, 21 }
+#define RGB_INDEX2 \
+  {  4, 14,  7,  6, 24, 17, 16, 26, 19, 18, 28, 21, 20, 30, 23, 22 }
+#define jsimd_ycc_rgb_convert_altivec  jsimd_ycc_extbgr_convert_altivec
+#include "jdcolext-altivec.c"
+#undef RGB_PIXELSIZE
+#undef RGB_INDEX0
+#undef RGB_INDEX1
+#undef RGB_INDEX2
+#undef jsimd_ycc_rgb_convert_altivec
+
+#define RGB_PIXELSIZE  EXT_BGRX_PIXELSIZE
+#define RGB_INDEX \
+  {  8,  1,  0,  9, 10,  3,  2, 11, 12,  5,  4, 13, 14,  7,  6, 15 }
+#define jsimd_ycc_rgb_convert_altivec  jsimd_ycc_extbgrx_convert_altivec
+#include "jdcolext-altivec.c"
+#undef RGB_PIXELSIZE
+#undef RGB_INDEX
+#undef jsimd_ycc_rgb_convert_altivec
+
+#define RGB_PIXELSIZE  EXT_XBGR_PIXELSIZE
+#define RGB_INDEX \
+  {  9,  8,  1,  0, 11, 10,  3,  2, 13, 12,  5,  4, 15, 14,  7,  6 }
+#define jsimd_ycc_rgb_convert_altivec  jsimd_ycc_extxbgr_convert_altivec
+#include "jdcolext-altivec.c"
+#undef RGB_PIXELSIZE
+#undef RGB_INDEX
+#undef jsimd_ycc_rgb_convert_altivec
+
+#define RGB_PIXELSIZE  EXT_XRGB_PIXELSIZE
+#define RGB_INDEX \
+  {  9,  0,  1,  8, 11,  2,  3, 10, 13,  4,  5, 12, 15,  6,  7, 14 }
+#define jsimd_ycc_rgb_convert_altivec  jsimd_ycc_extxrgb_convert_altivec
+#include "jdcolext-altivec.c"
+#undef RGB_PIXELSIZE
+#undef RGB_INDEX
+#undef jsimd_ycc_rgb_convert_altivec
diff --git a/3rdparty/libjpeg/src/simd/powerpc/jdmerge-altivec.c b/3rdparty/libjpeg/src/simd/powerpc/jdmerge-altivec.c
new file mode 100644
index 00000000..79c577f1
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/powerpc/jdmerge-altivec.c
@@ -0,0 +1,130 @@
+/*
+ * AltiVec optimizations for libjpeg-turbo
+ *
+ * Copyright (C) 2015, D. R. Commander.  All Rights Reserved.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+/* MERGED YCC --> RGB CONVERSION AND UPSAMPLING */
+
+#include "jsimd_altivec.h"
+
+
+#define F_0_344  22554              /* FIX(0.34414) */
+#define F_0_714  46802              /* FIX(0.71414) */
+#define F_1_402  91881              /* FIX(1.40200) */
+#define F_1_772  116130             /* FIX(1.77200) */
+#define F_0_402  (F_1_402 - 65536)  /* FIX(1.40200) - FIX(1) */
+#define F_0_285  (65536 - F_0_714)  /* FIX(1) - FIX(0.71414) */
+#define F_0_228  (131072 - F_1_772) /* FIX(2) - FIX(1.77200) */
+
+#define SCALEBITS  16
+#define ONE_HALF  (1 << (SCALEBITS - 1))
+
+#define RGB_INDEX0 \
+  {  0,  1,  8,  2,  3, 10,  4,  5, 12,  6,  7, 14, 16, 17, 24, 18 }
+#define RGB_INDEX1 \
+  {  3, 10,  4,  5, 12,  6,  7, 14, 16, 17, 24, 18, 19, 26, 20, 21 }
+#define RGB_INDEX2 \
+  { 12,  6,  7, 14, 16, 17, 24, 18, 19, 26, 20, 21, 28, 22, 23, 30 }
+#include "jdmrgext-altivec.c"
+#undef RGB_PIXELSIZE
+
+#define RGB_PIXELSIZE  EXT_RGB_PIXELSIZE
+#define jsimd_h2v1_merged_upsample_altivec \
+  jsimd_h2v1_extrgb_merged_upsample_altivec
+#define jsimd_h2v2_merged_upsample_altivec \
+  jsimd_h2v2_extrgb_merged_upsample_altivec
+#include "jdmrgext-altivec.c"
+#undef RGB_PIXELSIZE
+#undef RGB_INDEX0
+#undef RGB_INDEX1
+#undef RGB_INDEX2
+#undef jsimd_h2v1_merged_upsample_altivec
+#undef jsimd_h2v2_merged_upsample_altivec
+
+#define RGB_PIXELSIZE  EXT_RGBX_PIXELSIZE
+#define RGB_INDEX \
+  {  0,  1,  8,  9,  2,  3, 10, 11,  4,  5, 12, 13,  6,  7, 14, 15 }
+#define jsimd_h2v1_merged_upsample_altivec \
+  jsimd_h2v1_extrgbx_merged_upsample_altivec
+#define jsimd_h2v2_merged_upsample_altivec \
+  jsimd_h2v2_extrgbx_merged_upsample_altivec
+#include "jdmrgext-altivec.c"
+#undef RGB_PIXELSIZE
+#undef RGB_INDEX
+#undef jsimd_h2v1_merged_upsample_altivec
+#undef jsimd_h2v2_merged_upsample_altivec
+
+#define RGB_PIXELSIZE  EXT_BGR_PIXELSIZE
+#define RGB_INDEX0 \
+  {  8,  1,  0, 10,  3,  2, 12,  5,  4, 14,  7,  6, 24, 17, 16, 26 }
+#define RGB_INDEX1 \
+  {  3,  2, 12,  5,  4, 14,  7,  6, 24, 17, 16, 26, 19, 18, 28, 21 }
+#define RGB_INDEX2 \
+  {  4, 14,  7,  6, 24, 17, 16, 26, 19, 18, 28, 21, 20, 30, 23, 22 }
+#define jsimd_h2v1_merged_upsample_altivec \
+  jsimd_h2v1_extbgr_merged_upsample_altivec
+#define jsimd_h2v2_merged_upsample_altivec \
+  jsimd_h2v2_extbgr_merged_upsample_altivec
+#include "jdmrgext-altivec.c"
+#undef RGB_PIXELSIZE
+#undef RGB_INDEX0
+#undef RGB_INDEX1
+#undef RGB_INDEX2
+#undef jsimd_h2v1_merged_upsample_altivec
+#undef jsimd_h2v2_merged_upsample_altivec
+
+#define RGB_PIXELSIZE  EXT_BGRX_PIXELSIZE
+#define RGB_INDEX \
+  {  8,  1,  0,  9, 10,  3,  2, 11, 12,  5,  4, 13, 14,  7,  6, 15 }
+#define jsimd_h2v1_merged_upsample_altivec \
+  jsimd_h2v1_extbgrx_merged_upsample_altivec
+#define jsimd_h2v2_merged_upsample_altivec \
+  jsimd_h2v2_extbgrx_merged_upsample_altivec
+#include "jdmrgext-altivec.c"
+#undef RGB_PIXELSIZE
+#undef RGB_INDEX
+#undef jsimd_h2v1_merged_upsample_altivec
+#undef jsimd_h2v2_merged_upsample_altivec
+
+#define RGB_PIXELSIZE  EXT_XBGR_PIXELSIZE
+#define RGB_INDEX \
+  {  9,  8,  1,  0, 11, 10,  3,  2, 13, 12,  5,  4, 15, 14,  7,  6 }
+#define jsimd_h2v1_merged_upsample_altivec \
+  jsimd_h2v1_extxbgr_merged_upsample_altivec
+#define jsimd_h2v2_merged_upsample_altivec \
+  jsimd_h2v2_extxbgr_merged_upsample_altivec
+#include "jdmrgext-altivec.c"
+#undef RGB_PIXELSIZE
+#undef RGB_INDEX
+#undef jsimd_h2v1_merged_upsample_altivec
+#undef jsimd_h2v2_merged_upsample_altivec
+
+#define RGB_PIXELSIZE  EXT_XRGB_PIXELSIZE
+#define RGB_INDEX \
+  {  9,  0,  1,  8, 11,  2,  3, 10, 13,  4,  5, 12, 15,  6,  7, 14 }
+#define jsimd_h2v1_merged_upsample_altivec \
+  jsimd_h2v1_extxrgb_merged_upsample_altivec
+#define jsimd_h2v2_merged_upsample_altivec \
+  jsimd_h2v2_extxrgb_merged_upsample_altivec
+#include "jdmrgext-altivec.c"
+#undef RGB_PIXELSIZE
+#undef RGB_INDEX
+#undef jsimd_h2v1_merged_upsample_altivec
+#undef jsimd_h2v2_merged_upsample_altivec
diff --git a/3rdparty/libjpeg/src/simd/powerpc/jdmrgext-altivec.c b/3rdparty/libjpeg/src/simd/powerpc/jdmrgext-altivec.c
new file mode 100644
index 00000000..40f02c33
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/powerpc/jdmrgext-altivec.c
@@ -0,0 +1,329 @@
+/*
+ * AltiVec optimizations for libjpeg-turbo
+ *
+ * Copyright (C) 2015, D. R. Commander.  All Rights Reserved.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+/* This file is included by jdmerge-altivec.c */
+
+
+void jsimd_h2v1_merged_upsample_altivec(JDIMENSION output_width,
+                                        JSAMPIMAGE input_buf,
+                                        JDIMENSION in_row_group_ctr,
+                                        JSAMPARRAY output_buf)
+{
+  JSAMPROW outptr, inptr0, inptr1, inptr2;
+  int pitch = output_width * RGB_PIXELSIZE, num_cols, yloop;
+#if __BIG_ENDIAN__
+  int offset;
+#endif
+  unsigned char __attribute__((aligned(16))) tmpbuf[RGB_PIXELSIZE * 16];
+
+  __vector unsigned char rgb0, rgb1, rgb2, rgbx0, rgbx1, rgbx2, rgbx3,
+    y, cb, cr;
+#if __BIG_ENDIAN__
+  __vector unsigned char edgel, edgeh, edges, out0, out1, out2, out3;
+#if RGB_PIXELSIZE == 4
+  __vector unsigned char out4;
+#endif
+#endif
+#if RGB_PIXELSIZE == 4
+  __vector unsigned char rgb3;
+#endif
+  __vector short rg0, rg1, rg2, rg3, bx0, bx1, bx2, bx3, ye, yo, cbl, cbh,
+    crl, crh, r_yl, r_yh, g_yl, g_yh, b_yl, b_yh, g_y0w, g_y1w, g_y2w, g_y3w,
+    rl, rh, gl, gh, bl, bh, re, ro, ge, go, be, bo;
+  __vector int g_y0, g_y1, g_y2, g_y3;
+
+  /* Constants
+   * NOTE: The >> 1 is to compensate for the fact that vec_madds() returns 17
+   * high-order bits, not 16.
+   */
+  __vector short pw_f0402 = { __8X(F_0_402 >> 1) },
+    pw_mf0228 = { __8X(-F_0_228 >> 1) },
+    pw_mf0344_f0285 = { __4X2(-F_0_344, F_0_285) },
+    pw_one = { __8X(1) }, pw_255 = { __8X(255) },
+    pw_cj = { __8X(CENTERJSAMPLE) };
+  __vector int pd_onehalf = { __4X(ONE_HALF) };
+  __vector unsigned char pb_zero = { __16X(0) },
+#if __BIG_ENDIAN__
+    shift_pack_index =
+      {  0,  1,  4,  5,  8,  9, 12, 13, 16, 17, 20, 21, 24, 25, 28, 29 },
+    even_index =
+      {  0, 16,  0, 18,  0, 20,  0, 22,  0, 24,  0, 26,  0, 28,  0, 30 },
+    odd_index =
+      {  0, 17,  0, 19,  0, 21,  0, 23,  0, 25,  0, 27,  0, 29,  0, 31 };
+#else
+    shift_pack_index =
+      {  2,  3,  6,  7, 10, 11, 14, 15, 18, 19, 22, 23, 26, 27, 30, 31 },
+    even_index =
+      { 16,  0, 18,  0, 20,  0, 22,  0, 24,  0, 26,  0, 28,  0, 30,  0 },
+    odd_index =
+      { 17,  0, 19,  0, 21,  0, 23,  0, 25,  0, 27,  0, 29,  0, 31,  0 };
+#endif
+
+  inptr0 = input_buf[0][in_row_group_ctr];
+  inptr1 = input_buf[1][in_row_group_ctr];
+  inptr2 = input_buf[2][in_row_group_ctr];
+  outptr = output_buf[0];
+
+  for (num_cols = pitch; num_cols > 0; inptr1 += 16, inptr2 += 16) {
+
+    cb = vec_ld(0, inptr1);
+    /* NOTE: We have to use vec_merge*() here because vec_unpack*() doesn't
+     * support unsigned vectors.
+     */
+    cbl = (__vector signed short)VEC_UNPACKHU(cb);
+    cbh = (__vector signed short)VEC_UNPACKLU(cb);
+    cbl = vec_sub(cbl, pw_cj);
+    cbh = vec_sub(cbh, pw_cj);
+
+    cr = vec_ld(0, inptr2);
+    crl = (__vector signed short)VEC_UNPACKHU(cr);
+    crh = (__vector signed short)VEC_UNPACKLU(cr);
+    crl = vec_sub(crl, pw_cj);
+    crh = vec_sub(crh, pw_cj);
+
+    /* (Original)
+     * R = Y                + 1.40200 * Cr
+     * G = Y - 0.34414 * Cb - 0.71414 * Cr
+     * B = Y + 1.77200 * Cb
+     *
+     * (This implementation)
+     * R = Y                + 0.40200 * Cr + Cr
+     * G = Y - 0.34414 * Cb + 0.28586 * Cr - Cr
+     * B = Y - 0.22800 * Cb + Cb + Cb
+     */
+    b_yl = vec_add(cbl, cbl);
+    b_yh = vec_add(cbh, cbh);
+    b_yl = vec_madds(b_yl, pw_mf0228, pw_one);
+    b_yh = vec_madds(b_yh, pw_mf0228, pw_one);
+    b_yl = vec_sra(b_yl, (__vector unsigned short)pw_one);
+    b_yh = vec_sra(b_yh, (__vector unsigned short)pw_one);
+    b_yl = vec_add(b_yl, cbl);
+    b_yh = vec_add(b_yh, cbh);
+    b_yl = vec_add(b_yl, cbl);
+    b_yh = vec_add(b_yh, cbh);
+
+    r_yl = vec_add(crl, crl);
+    r_yh = vec_add(crh, crh);
+    r_yl = vec_madds(r_yl, pw_f0402, pw_one);
+    r_yh = vec_madds(r_yh, pw_f0402, pw_one);
+    r_yl = vec_sra(r_yl, (__vector unsigned short)pw_one);
+    r_yh = vec_sra(r_yh, (__vector unsigned short)pw_one);
+    r_yl = vec_add(r_yl, crl);
+    r_yh = vec_add(r_yh, crh);
+
+    g_y0w = vec_mergeh(cbl, crl);
+    g_y1w = vec_mergel(cbl, crl);
+    g_y0 = vec_msums(g_y0w, pw_mf0344_f0285, pd_onehalf);
+    g_y1 = vec_msums(g_y1w, pw_mf0344_f0285, pd_onehalf);
+    g_y2w = vec_mergeh(cbh, crh);
+    g_y3w = vec_mergel(cbh, crh);
+    g_y2 = vec_msums(g_y2w, pw_mf0344_f0285, pd_onehalf);
+    g_y3 = vec_msums(g_y3w, pw_mf0344_f0285, pd_onehalf);
+    /* Clever way to avoid 4 shifts + 2 packs.  This packs the high word from
+     * each dword into a new 16-bit vector, which is the equivalent of
+     * descaling the 32-bit results (right-shifting by 16 bits) and then
+     * packing them.
+     */
+    g_yl = vec_perm((__vector short)g_y0, (__vector short)g_y1,
+                    shift_pack_index);
+    g_yh = vec_perm((__vector short)g_y2, (__vector short)g_y3,
+                    shift_pack_index);
+    g_yl = vec_sub(g_yl, crl);
+    g_yh = vec_sub(g_yh, crh);
+
+    for (yloop = 0; yloop < 2 && num_cols > 0; yloop++,
+         num_cols -= RGB_PIXELSIZE * 16,
+         outptr += RGB_PIXELSIZE * 16, inptr0 += 16) {
+
+      y = vec_ld(0, inptr0);
+      ye = (__vector signed short)vec_perm(pb_zero, y, even_index);
+      yo = (__vector signed short)vec_perm(pb_zero, y, odd_index);
+
+      if (yloop == 0) {
+        be = vec_add(b_yl, ye);
+        bo = vec_add(b_yl, yo);
+        re = vec_add(r_yl, ye);
+        ro = vec_add(r_yl, yo);
+        ge = vec_add(g_yl, ye);
+        go = vec_add(g_yl, yo);
+      } else {
+        be = vec_add(b_yh, ye);
+        bo = vec_add(b_yh, yo);
+        re = vec_add(r_yh, ye);
+        ro = vec_add(r_yh, yo);
+        ge = vec_add(g_yh, ye);
+        go = vec_add(g_yh, yo);
+      }
+
+      rl = vec_mergeh(re, ro);
+      rh = vec_mergel(re, ro);
+      gl = vec_mergeh(ge, go);
+      gh = vec_mergel(ge, go);
+      bl = vec_mergeh(be, bo);
+      bh = vec_mergel(be, bo);
+
+      rg0 = vec_mergeh(rl, gl);
+      bx0 = vec_mergeh(bl, pw_255);
+      rg1 = vec_mergel(rl, gl);
+      bx1 = vec_mergel(bl, pw_255);
+      rg2 = vec_mergeh(rh, gh);
+      bx2 = vec_mergeh(bh, pw_255);
+      rg3 = vec_mergel(rh, gh);
+      bx3 = vec_mergel(bh, pw_255);
+
+      rgbx0 = vec_packsu(rg0, bx0);
+      rgbx1 = vec_packsu(rg1, bx1);
+      rgbx2 = vec_packsu(rg2, bx2);
+      rgbx3 = vec_packsu(rg3, bx3);
+
+#if RGB_PIXELSIZE == 3
+      /* rgbx0 = R0 G0 R1 G1 R2 G2 R3 G3 B0 X0 B1 X1 B2 X2 B3 X3
+       * rgbx1 = R4 G4 R5 G5 R6 G6 R7 G7 B4 X4 B5 X5 B6 X6 B7 X7
+       * rgbx2 = R8 G8 R9 G9 Ra Ga Rb Gb B8 X8 B9 X9 Ba Xa Bb Xb
+       * rgbx3 = Rc Gc Rd Gd Re Ge Rf Gf Bc Xc Bd Xd Be Xe Bf Xf
+       *
+       * rgb0 = R0 G0 B0 R1 G1 B1 R2 G2 B2 R3 G3 B3 R4 G4 B4 R5
+       * rgb1 = G5 B5 R6 G6 B6 R7 G7 B7 R8 G8 B8 R9 G9 B9 Ra Ga
+       * rgb2 = Ba Rb Gb Bb Rc Gc Bc Rd Gd Bd Re Ge Be Rf Gf Bf
+       */
+      rgb0 = vec_perm(rgbx0, rgbx1, (__vector unsigned char)RGB_INDEX0);
+      rgb1 = vec_perm(rgbx1, rgbx2, (__vector unsigned char)RGB_INDEX1);
+      rgb2 = vec_perm(rgbx2, rgbx3, (__vector unsigned char)RGB_INDEX2);
+#else
+      /* rgbx0 = R0 G0 R1 G1 R2 G2 R3 G3 B0 X0 B1 X1 B2 X2 B3 X3
+       * rgbx1 = R4 G4 R5 G5 R6 G6 R7 G7 B4 X4 B5 X5 B6 X6 B7 X7
+       * rgbx2 = R8 G8 R9 G9 Ra Ga Rb Gb B8 X8 B9 X9 Ba Xa Bb Xb
+       * rgbx3 = Rc Gc Rd Gd Re Ge Rf Gf Bc Xc Bd Xd Be Xe Bf Xf
+       *
+       * rgb0 = R0 G0 B0 X0 R1 G1 B1 X1 R2 G2 B2 X2 R3 G3 B3 X3
+       * rgb1 = R4 G4 B4 X4 R5 G5 B5 X5 R6 G6 B6 X6 R7 G7 B7 X7
+       * rgb2 = R8 G8 B8 X8 R9 G9 B9 X9 Ra Ga Ba Xa Rb Gb Bb Xb
+       * rgb3 = Rc Gc Bc Xc Rd Gd Bd Xd Re Ge Be Xe Rf Gf Bf Xf
+       */
+      rgb0 = vec_perm(rgbx0, rgbx0, (__vector unsigned char)RGB_INDEX);
+      rgb1 = vec_perm(rgbx1, rgbx1, (__vector unsigned char)RGB_INDEX);
+      rgb2 = vec_perm(rgbx2, rgbx2, (__vector unsigned char)RGB_INDEX);
+      rgb3 = vec_perm(rgbx3, rgbx3, (__vector unsigned char)RGB_INDEX);
+#endif
+
+#if __BIG_ENDIAN__
+      offset = (size_t)outptr & 15;
+      if (offset) {
+        __vector unsigned char unaligned_shift_index;
+        int bytes = num_cols + offset;
+
+        if (bytes < (RGB_PIXELSIZE + 1) * 16 && (bytes & 15)) {
+          /* Slow path to prevent buffer overwrite.  Since there is no way to
+           * write a partial AltiVec register, overwrite would occur on the
+           * last chunk of the last image row if the right edge is not on a
+           * 16-byte boundary.  It could also occur on other rows if the bytes
+           * per row is low enough.  Since we can't determine whether we're on
+           * the last image row, we have to assume every row is the last.
+           */
+          vec_st(rgb0, 0, tmpbuf);
+          vec_st(rgb1, 16, tmpbuf);
+          vec_st(rgb2, 32, tmpbuf);
+#if RGB_PIXELSIZE == 4
+          vec_st(rgb3, 48, tmpbuf);
+#endif
+          memcpy(outptr, tmpbuf, min(num_cols, RGB_PIXELSIZE * 16));
+        } else {
+          /* Fast path */
+          unaligned_shift_index = vec_lvsl(0, outptr);
+          edgel = vec_ld(0, outptr);
+          edgeh = vec_ld(min(num_cols - 1, RGB_PIXELSIZE * 16), outptr);
+          edges = vec_perm(edgeh, edgel, unaligned_shift_index);
+          unaligned_shift_index = vec_lvsr(0, outptr);
+          out0 = vec_perm(edges, rgb0, unaligned_shift_index);
+          out1 = vec_perm(rgb0, rgb1, unaligned_shift_index);
+          out2 = vec_perm(rgb1, rgb2, unaligned_shift_index);
+#if RGB_PIXELSIZE == 4
+          out3 = vec_perm(rgb2, rgb3, unaligned_shift_index);
+          out4 = vec_perm(rgb3, edges, unaligned_shift_index);
+#else
+          out3 = vec_perm(rgb2, edges, unaligned_shift_index);
+#endif
+          vec_st(out0, 0, outptr);
+          if (bytes > 16)
+            vec_st(out1, 16, outptr);
+          if (bytes > 32)
+            vec_st(out2, 32, outptr);
+          if (bytes > 48)
+            vec_st(out3, 48, outptr);
+#if RGB_PIXELSIZE == 4
+          if (bytes > 64)
+            vec_st(out4, 64, outptr);
+#endif
+        }
+      } else {
+#endif /* __BIG_ENDIAN__ */
+        if (num_cols < RGB_PIXELSIZE * 16 && (num_cols & 15)) {
+          /* Slow path */
+          VEC_ST(rgb0, 0, tmpbuf);
+          VEC_ST(rgb1, 16, tmpbuf);
+          VEC_ST(rgb2, 32, tmpbuf);
+#if RGB_PIXELSIZE == 4
+          VEC_ST(rgb3, 48, tmpbuf);
+#endif
+          memcpy(outptr, tmpbuf, min(num_cols, RGB_PIXELSIZE * 16));
+        } else {
+          /* Fast path */
+          VEC_ST(rgb0, 0, outptr);
+          if (num_cols > 16)
+            VEC_ST(rgb1, 16, outptr);
+          if (num_cols > 32)
+            VEC_ST(rgb2, 32, outptr);
+#if RGB_PIXELSIZE == 4
+          if (num_cols > 48)
+            VEC_ST(rgb3, 48, outptr);
+#endif
+        }
+#if __BIG_ENDIAN__
+      }
+#endif
+    }
+  }
+}
+
+
+void jsimd_h2v2_merged_upsample_altivec(JDIMENSION output_width,
+                                        JSAMPIMAGE input_buf,
+                                        JDIMENSION in_row_group_ctr,
+                                        JSAMPARRAY output_buf)
+{
+  JSAMPROW inptr, outptr;
+
+  inptr = input_buf[0][in_row_group_ctr];
+  outptr = output_buf[0];
+
+  input_buf[0][in_row_group_ctr] = input_buf[0][in_row_group_ctr * 2];
+  jsimd_h2v1_merged_upsample_altivec(output_width, input_buf, in_row_group_ctr,
+                                     output_buf);
+
+  input_buf[0][in_row_group_ctr] = input_buf[0][in_row_group_ctr * 2 + 1];
+  output_buf[0] = output_buf[1];
+  jsimd_h2v1_merged_upsample_altivec(output_width, input_buf, in_row_group_ctr,
+                                     output_buf);
+
+  input_buf[0][in_row_group_ctr] = inptr;
+  output_buf[0] = outptr;
+}
diff --git a/3rdparty/libjpeg/src/simd/powerpc/jdsample-altivec.c b/3rdparty/libjpeg/src/simd/powerpc/jdsample-altivec.c
new file mode 100644
index 00000000..04df0cf1
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/powerpc/jdsample-altivec.c
@@ -0,0 +1,400 @@
+/*
+ * AltiVec optimizations for libjpeg-turbo
+ *
+ * Copyright (C) 2015, D. R. Commander.  All Rights Reserved.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+/* CHROMA UPSAMPLING */
+
+#include "jsimd_altivec.h"
+
+
+void jsimd_h2v1_fancy_upsample_altivec(int max_v_samp_factor,
+                                       JDIMENSION downsampled_width,
+                                       JSAMPARRAY input_data,
+                                       JSAMPARRAY *output_data_ptr)
+{
+  JSAMPARRAY output_data = *output_data_ptr;
+  JSAMPROW inptr, outptr;
+  int inrow, incol;
+
+  __vector unsigned char this0, last0, p_last0, next0 = { 0 }, p_next0,
+    out;
+  __vector short this0e, this0o, this0l, this0h, last0l, last0h,
+    next0l, next0h, outle, outhe, outlo, outho;
+
+  /* Constants */
+  __vector unsigned char pb_zero = { __16X(0) }, pb_three = { __16X(3) },
+    last_index_col0 =
+      {  0,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14 },
+    last_index =
+      { 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30 },
+    next_index =
+      {  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16 },
+    next_index_lastcol =
+      {  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 15 },
+#if __BIG_ENDIAN__
+    merge_pack_index =
+      {  1, 17,  3, 19,  5, 21,  7, 23,  9, 25, 11, 27, 13, 29, 15, 31 };
+#else
+    merge_pack_index =
+      {  0, 16,  2, 18,  4, 20,  6, 22,  8, 24, 10, 26, 12, 28, 14, 30 };
+#endif
+  __vector short pw_one = { __8X(1) }, pw_two = { __8X(2) };
+
+  for (inrow = 0; inrow < max_v_samp_factor; inrow++) {
+    inptr = input_data[inrow];
+    outptr = output_data[inrow];
+
+    if (downsampled_width & 15)
+      inptr[downsampled_width] = inptr[downsampled_width - 1];
+
+    this0 = vec_ld(0, inptr);
+    p_last0 = vec_perm(this0, this0, last_index_col0);
+    last0 = this0;
+
+    for (incol = downsampled_width; incol > 0;
+         incol -= 16, inptr += 16, outptr += 32) {
+
+      if (downsampled_width - incol > 0) {
+        p_last0 = vec_perm(last0, this0, last_index);
+        last0 = this0;
+      }
+
+      if (incol <= 16)
+        p_next0 = vec_perm(this0, this0, next_index_lastcol);
+      else {
+        next0 = vec_ld(16, inptr);
+        p_next0 = vec_perm(this0, next0, next_index);
+      }
+
+      this0e = (__vector short)vec_mule(this0, pb_three);
+      this0o = (__vector short)vec_mulo(this0, pb_three);
+      this0l = vec_mergeh(this0e, this0o);
+      this0h = vec_mergel(this0e, this0o);
+
+      last0l = (__vector short)VEC_UNPACKHU(p_last0);
+      last0h = (__vector short)VEC_UNPACKLU(p_last0);
+      last0l = vec_add(last0l, pw_one);
+
+      next0l = (__vector short)VEC_UNPACKHU(p_next0);
+      next0h = (__vector short)VEC_UNPACKLU(p_next0);
+      next0l = vec_add(next0l, pw_two);
+
+      outle = vec_add(this0l, last0l);
+      outlo = vec_add(this0l, next0l);
+      outle = vec_sr(outle, (__vector unsigned short)pw_two);
+      outlo = vec_sr(outlo, (__vector unsigned short)pw_two);
+
+      out = vec_perm((__vector unsigned char)outle,
+                     (__vector unsigned char)outlo, merge_pack_index);
+      vec_st(out, 0, outptr);
+
+      if (incol > 8) {
+        last0h = vec_add(last0h, pw_one);
+        next0h = vec_add(next0h, pw_two);
+
+        outhe = vec_add(this0h, last0h);
+        outho = vec_add(this0h, next0h);
+        outhe = vec_sr(outhe, (__vector unsigned short)pw_two);
+        outho = vec_sr(outho, (__vector unsigned short)pw_two);
+
+        out = vec_perm((__vector unsigned char)outhe,
+                       (__vector unsigned char)outho, merge_pack_index);
+        vec_st(out, 16, outptr);
+      }
+
+      this0 = next0;
+    }
+  }
+}
+
+
+void jsimd_h2v2_fancy_upsample_altivec(int max_v_samp_factor,
+                                       JDIMENSION downsampled_width,
+                                       JSAMPARRAY input_data,
+                                       JSAMPARRAY *output_data_ptr)
+{
+  JSAMPARRAY output_data = *output_data_ptr;
+  JSAMPROW inptr_1, inptr0, inptr1, outptr0, outptr1;
+  int inrow, outrow, incol;
+
+  __vector unsigned char this_1, this0, this1, out;
+  __vector short this_1l, this_1h, this0l, this0h, this1l, this1h,
+    lastcolsum_1h, lastcolsum1h,
+    p_lastcolsum_1l, p_lastcolsum_1h, p_lastcolsum1l, p_lastcolsum1h,
+    thiscolsum_1l, thiscolsum_1h, thiscolsum1l, thiscolsum1h,
+    nextcolsum_1l = { 0 }, nextcolsum_1h = { 0 },
+    nextcolsum1l = { 0 }, nextcolsum1h = { 0 },
+    p_nextcolsum_1l, p_nextcolsum_1h, p_nextcolsum1l, p_nextcolsum1h,
+    tmpl, tmph, outle, outhe, outlo, outho;
+
+  /* Constants */
+  __vector unsigned char pb_zero = { __16X(0) },
+    last_index_col0 =
+      {  0,  1,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13 },
+    last_index =
+      { 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29 },
+    next_index =
+      {  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17 },
+    next_index_lastcol =
+      {  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 14, 15 },
+#if __BIG_ENDIAN__
+    merge_pack_index =
+      {  1, 17,  3, 19,  5, 21,  7, 23,  9, 25, 11, 27, 13, 29, 15, 31 };
+#else
+    merge_pack_index =
+      {  0, 16,  2, 18,  4, 20,  6, 22,  8, 24, 10, 26, 12, 28, 14, 30 };
+#endif
+  __vector short pw_zero = { __8X(0) }, pw_three = { __8X(3) },
+    pw_seven = { __8X(7) }, pw_eight = { __8X(8) };
+  __vector unsigned short pw_four = { __8X(4) };
+
+  for (inrow = 0, outrow = 0; outrow < max_v_samp_factor; inrow++) {
+
+    inptr_1 = input_data[inrow - 1];
+    inptr0 = input_data[inrow];
+    inptr1 = input_data[inrow + 1];
+    outptr0 = output_data[outrow++];
+    outptr1 = output_data[outrow++];
+
+    if (downsampled_width & 15) {
+      inptr_1[downsampled_width] = inptr_1[downsampled_width - 1];
+      inptr0[downsampled_width] = inptr0[downsampled_width - 1];
+      inptr1[downsampled_width] = inptr1[downsampled_width - 1];
+    }
+
+    this0 = vec_ld(0, inptr0);
+    this0l = (__vector short)VEC_UNPACKHU(this0);
+    this0h = (__vector short)VEC_UNPACKLU(this0);
+    this0l = vec_mladd(this0l, pw_three, pw_zero);
+    this0h = vec_mladd(this0h, pw_three, pw_zero);
+
+    this_1 = vec_ld(0, inptr_1);
+    this_1l = (__vector short)VEC_UNPACKHU(this_1);
+    this_1h = (__vector short)VEC_UNPACKLU(this_1);
+    thiscolsum_1l = vec_add(this0l, this_1l);
+    thiscolsum_1h = vec_add(this0h, this_1h);
+    lastcolsum_1h = thiscolsum_1h;
+    p_lastcolsum_1l = vec_perm(thiscolsum_1l, thiscolsum_1l, last_index_col0);
+    p_lastcolsum_1h = vec_perm(thiscolsum_1l, thiscolsum_1h, last_index);
+
+    this1 = vec_ld(0, inptr1);
+    this1l = (__vector short)VEC_UNPACKHU(this1);
+    this1h = (__vector short)VEC_UNPACKLU(this1);
+    thiscolsum1l = vec_add(this0l, this1l);
+    thiscolsum1h = vec_add(this0h, this1h);
+    lastcolsum1h = thiscolsum1h;
+    p_lastcolsum1l = vec_perm(thiscolsum1l, thiscolsum1l, last_index_col0);
+    p_lastcolsum1h = vec_perm(thiscolsum1l, thiscolsum1h, last_index);
+
+    for (incol = downsampled_width; incol > 0;
+         incol -= 16, inptr_1 += 16, inptr0 += 16, inptr1 += 16,
+         outptr0 += 32, outptr1 += 32) {
+
+      if (downsampled_width - incol > 0) {
+        p_lastcolsum_1l = vec_perm(lastcolsum_1h, thiscolsum_1l, last_index);
+        p_lastcolsum_1h = vec_perm(thiscolsum_1l, thiscolsum_1h, last_index);
+        p_lastcolsum1l = vec_perm(lastcolsum1h, thiscolsum1l, last_index);
+        p_lastcolsum1h = vec_perm(thiscolsum1l, thiscolsum1h, last_index);
+        lastcolsum_1h = thiscolsum_1h;  lastcolsum1h = thiscolsum1h;
+      }
+
+      if (incol <= 16) {
+        p_nextcolsum_1l = vec_perm(thiscolsum_1l, thiscolsum_1h, next_index);
+        p_nextcolsum_1h = vec_perm(thiscolsum_1h, thiscolsum_1h,
+                                   next_index_lastcol);
+        p_nextcolsum1l = vec_perm(thiscolsum1l, thiscolsum1h, next_index);
+        p_nextcolsum1h = vec_perm(thiscolsum1h, thiscolsum1h,
+                                  next_index_lastcol);
+      } else {
+        this0 = vec_ld(16, inptr0);
+        this0l = (__vector short)VEC_UNPACKHU(this0);
+        this0h = (__vector short)VEC_UNPACKLU(this0);
+        this0l = vec_mladd(this0l, pw_three, pw_zero);
+        this0h = vec_mladd(this0h, pw_three, pw_zero);
+
+        this_1 = vec_ld(16, inptr_1);
+        this_1l = (__vector short)VEC_UNPACKHU(this_1);
+        this_1h = (__vector short)VEC_UNPACKLU(this_1);
+        nextcolsum_1l = vec_add(this0l, this_1l);
+        nextcolsum_1h = vec_add(this0h, this_1h);
+        p_nextcolsum_1l = vec_perm(thiscolsum_1l, thiscolsum_1h, next_index);
+        p_nextcolsum_1h = vec_perm(thiscolsum_1h, nextcolsum_1l, next_index);
+
+        this1 = vec_ld(16, inptr1);
+        this1l = (__vector short)VEC_UNPACKHU(this1);
+        this1h = (__vector short)VEC_UNPACKLU(this1);
+        nextcolsum1l = vec_add(this0l, this1l);
+        nextcolsum1h = vec_add(this0h, this1h);
+        p_nextcolsum1l = vec_perm(thiscolsum1l, thiscolsum1h, next_index);
+        p_nextcolsum1h = vec_perm(thiscolsum1h, nextcolsum1l, next_index);
+      }
+
+      /* Process the upper row */
+
+      tmpl = vec_mladd(thiscolsum_1l, pw_three, pw_zero);
+      outle = vec_add(tmpl, p_lastcolsum_1l);
+      outle = vec_add(outle, pw_eight);
+      outle = vec_sr(outle, pw_four);
+
+      outlo = vec_add(tmpl, p_nextcolsum_1l);
+      outlo = vec_add(outlo, pw_seven);
+      outlo = vec_sr(outlo, pw_four);
+
+      out = vec_perm((__vector unsigned char)outle,
+                     (__vector unsigned char)outlo, merge_pack_index);
+      vec_st(out, 0, outptr0);
+
+      if (incol > 8) {
+        tmph = vec_mladd(thiscolsum_1h, pw_three, pw_zero);
+        outhe = vec_add(tmph, p_lastcolsum_1h);
+        outhe = vec_add(outhe, pw_eight);
+        outhe = vec_sr(outhe, pw_four);
+
+        outho = vec_add(tmph, p_nextcolsum_1h);
+        outho = vec_add(outho, pw_seven);
+        outho = vec_sr(outho, pw_four);
+
+        out = vec_perm((__vector unsigned char)outhe,
+                       (__vector unsigned char)outho, merge_pack_index);
+        vec_st(out, 16, outptr0);
+      }
+
+      /* Process the lower row */
+
+      tmpl = vec_mladd(thiscolsum1l, pw_three, pw_zero);
+      outle = vec_add(tmpl, p_lastcolsum1l);
+      outle = vec_add(outle, pw_eight);
+      outle = vec_sr(outle, pw_four);
+
+      outlo = vec_add(tmpl, p_nextcolsum1l);
+      outlo = vec_add(outlo, pw_seven);
+      outlo = vec_sr(outlo, pw_four);
+
+      out = vec_perm((__vector unsigned char)outle,
+                     (__vector unsigned char)outlo, merge_pack_index);
+      vec_st(out, 0, outptr1);
+
+      if (incol > 8) {
+        tmph = vec_mladd(thiscolsum1h, pw_three, pw_zero);
+        outhe = vec_add(tmph, p_lastcolsum1h);
+        outhe = vec_add(outhe, pw_eight);
+        outhe = vec_sr(outhe, pw_four);
+
+        outho = vec_add(tmph, p_nextcolsum1h);
+        outho = vec_add(outho, pw_seven);
+        outho = vec_sr(outho, pw_four);
+
+        out = vec_perm((__vector unsigned char)outhe,
+                       (__vector unsigned char)outho, merge_pack_index);
+        vec_st(out, 16, outptr1);
+      }
+
+      thiscolsum_1l = nextcolsum_1l;  thiscolsum_1h = nextcolsum_1h;
+      thiscolsum1l = nextcolsum1l;  thiscolsum1h = nextcolsum1h;
+    }
+  }
+}
+
+
+/* These are rarely used (mainly just for decompressing YCCK images) */
+
+void jsimd_h2v1_upsample_altivec(int max_v_samp_factor,
+                                 JDIMENSION output_width,
+                                 JSAMPARRAY input_data,
+                                 JSAMPARRAY *output_data_ptr)
+{
+  JSAMPARRAY output_data = *output_data_ptr;
+  JSAMPROW inptr, outptr;
+  int inrow, incol;
+
+  __vector unsigned char in, inl, inh;
+
+  for (inrow = 0; inrow < max_v_samp_factor; inrow++) {
+    inptr = input_data[inrow];
+    outptr = output_data[inrow];
+
+    for (incol = (output_width + 31) & (~31); incol > 0;
+         incol -= 64, inptr += 32, outptr += 64) {
+
+      in = vec_ld(0, inptr);
+      inl = vec_mergeh(in, in);
+      inh = vec_mergel(in, in);
+
+      vec_st(inl, 0, outptr);
+      vec_st(inh, 16, outptr);
+
+      if (incol > 32) {
+        in = vec_ld(16, inptr);
+        inl = vec_mergeh(in, in);
+        inh = vec_mergel(in, in);
+
+        vec_st(inl, 32, outptr);
+        vec_st(inh, 48, outptr);
+      }
+    }
+  }
+}
+
+
+void jsimd_h2v2_upsample_altivec(int max_v_samp_factor,
+                                 JDIMENSION output_width,
+                                 JSAMPARRAY input_data,
+                                 JSAMPARRAY *output_data_ptr)
+{
+  JSAMPARRAY output_data = *output_data_ptr;
+  JSAMPROW inptr, outptr0, outptr1;
+  int inrow, outrow, incol;
+
+  __vector unsigned char in, inl, inh;
+
+  for (inrow = 0, outrow = 0; outrow < max_v_samp_factor; inrow++) {
+
+    inptr = input_data[inrow];
+    outptr0 = output_data[outrow++];
+    outptr1 = output_data[outrow++];
+
+    for (incol = (output_width + 31) & (~31); incol > 0;
+         incol -= 64, inptr += 32, outptr0 += 64, outptr1 += 64) {
+
+      in = vec_ld(0, inptr);
+      inl = vec_mergeh(in, in);
+      inh = vec_mergel(in, in);
+
+      vec_st(inl, 0, outptr0);
+      vec_st(inl, 0, outptr1);
+
+      vec_st(inh, 16, outptr0);
+      vec_st(inh, 16, outptr1);
+
+      if (incol > 32) {
+        in = vec_ld(16, inptr);
+        inl = vec_mergeh(in, in);
+        inh = vec_mergel(in, in);
+
+        vec_st(inl, 32, outptr0);
+        vec_st(inl, 32, outptr1);
+
+        vec_st(inh, 48, outptr0);
+        vec_st(inh, 48, outptr1);
+      }
+    }
+  }
+}
diff --git a/3rdparty/libjpeg/src/simd/powerpc/jfdctfst-altivec.c b/3rdparty/libjpeg/src/simd/powerpc/jfdctfst-altivec.c
new file mode 100644
index 00000000..ad9af81e
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/powerpc/jfdctfst-altivec.c
@@ -0,0 +1,154 @@
+/*
+ * AltiVec optimizations for libjpeg-turbo
+ *
+ * Copyright (C) 2014, D. R. Commander.  All Rights Reserved.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+/* FAST INTEGER FORWARD DCT
+ *
+ * This is similar to the SSE2 implementation, except that we left-shift the
+ * constants by 1 less bit (the -1 in CONST_SHIFT.)  This is because
+ * vec_madds(arg1, arg2, arg3) generates the 16-bit saturated sum of:
+ *   the elements in arg3 + the most significant 17 bits of
+ *     (the elements in arg1 * the elements in arg2).
+ */
+
+#include "jsimd_altivec.h"
+
+
+#define F_0_382  98   /* FIX(0.382683433) */
+#define F_0_541  139  /* FIX(0.541196100) */
+#define F_0_707  181  /* FIX(0.707106781) */
+#define F_1_306  334  /* FIX(1.306562965) */
+
+#define CONST_BITS  8
+#define PRE_MULTIPLY_SCALE_BITS  2
+#define CONST_SHIFT  (16 - PRE_MULTIPLY_SCALE_BITS - CONST_BITS - 1)
+
+
+#define DO_FDCT() { \
+  /* Even part */ \
+  \
+  tmp10 = vec_add(tmp0, tmp3); \
+  tmp13 = vec_sub(tmp0, tmp3); \
+  tmp11 = vec_add(tmp1, tmp2); \
+  tmp12 = vec_sub(tmp1, tmp2); \
+  \
+  out0  = vec_add(tmp10, tmp11); \
+  out4  = vec_sub(tmp10, tmp11); \
+  \
+  z1 = vec_add(tmp12, tmp13); \
+  z1 = vec_sl(z1, pre_multiply_scale_bits); \
+  z1 = vec_madds(z1, pw_0707, pw_zero); \
+  \
+  out2 = vec_add(tmp13, z1); \
+  out6 = vec_sub(tmp13, z1); \
+  \
+  /* Odd part */ \
+  \
+  tmp10 = vec_add(tmp4, tmp5); \
+  tmp11 = vec_add(tmp5, tmp6); \
+  tmp12 = vec_add(tmp6, tmp7); \
+  \
+  tmp10 = vec_sl(tmp10, pre_multiply_scale_bits); \
+  tmp12 = vec_sl(tmp12, pre_multiply_scale_bits); \
+  z5 = vec_sub(tmp10, tmp12); \
+  z5 = vec_madds(z5, pw_0382, pw_zero); \
+  \
+  z2 = vec_madds(tmp10, pw_0541, z5); \
+  z4 = vec_madds(tmp12, pw_1306, z5); \
+  \
+  tmp11 = vec_sl(tmp11, pre_multiply_scale_bits); \
+  z3 = vec_madds(tmp11, pw_0707, pw_zero); \
+  \
+  z11 = vec_add(tmp7, z3); \
+  z13 = vec_sub(tmp7, z3); \
+  \
+  out5 = vec_add(z13, z2); \
+  out3 = vec_sub(z13, z2); \
+  out1 = vec_add(z11, z4); \
+  out7 = vec_sub(z11, z4); \
+}
+
+
+void jsimd_fdct_ifast_altivec(DCTELEM *data)
+{
+  __vector short row0, row1, row2, row3, row4, row5, row6, row7,
+    col0, col1, col2, col3, col4, col5, col6, col7,
+    tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7, tmp10, tmp11, tmp12, tmp13,
+    z1, z2, z3, z4, z5, z11, z13,
+    out0, out1, out2, out3, out4, out5, out6, out7;
+
+  /* Constants */
+  __vector short pw_zero = { __8X(0) },
+    pw_0382 = { __8X(F_0_382 << CONST_SHIFT) },
+    pw_0541 = { __8X(F_0_541 << CONST_SHIFT) },
+    pw_0707 = { __8X(F_0_707 << CONST_SHIFT) },
+    pw_1306 = { __8X(F_1_306 << CONST_SHIFT) };
+  __vector unsigned short
+    pre_multiply_scale_bits = { __8X(PRE_MULTIPLY_SCALE_BITS) };
+
+  /* Pass 1: process rows */
+
+  row0 = vec_ld(0, data);
+  row1 = vec_ld(16, data);
+  row2 = vec_ld(32, data);
+  row3 = vec_ld(48, data);
+  row4 = vec_ld(64, data);
+  row5 = vec_ld(80, data);
+  row6 = vec_ld(96, data);
+  row7 = vec_ld(112, data);
+
+  TRANSPOSE(row, col);
+
+  tmp0 = vec_add(col0, col7);
+  tmp7 = vec_sub(col0, col7);
+  tmp1 = vec_add(col1, col6);
+  tmp6 = vec_sub(col1, col6);
+  tmp2 = vec_add(col2, col5);
+  tmp5 = vec_sub(col2, col5);
+  tmp3 = vec_add(col3, col4);
+  tmp4 = vec_sub(col3, col4);
+
+  DO_FDCT();
+
+  /* Pass 2: process columns */
+
+  TRANSPOSE(out, row);
+
+  tmp0 = vec_add(row0, row7);
+  tmp7 = vec_sub(row0, row7);
+  tmp1 = vec_add(row1, row6);
+  tmp6 = vec_sub(row1, row6);
+  tmp2 = vec_add(row2, row5);
+  tmp5 = vec_sub(row2, row5);
+  tmp3 = vec_add(row3, row4);
+  tmp4 = vec_sub(row3, row4);
+
+  DO_FDCT();
+
+  vec_st(out0, 0, data);
+  vec_st(out1, 16, data);
+  vec_st(out2, 32, data);
+  vec_st(out3, 48, data);
+  vec_st(out4, 64, data);
+  vec_st(out5, 80, data);
+  vec_st(out6, 96, data);
+  vec_st(out7, 112, data);
+}
diff --git a/3rdparty/libjpeg/src/simd/powerpc/jfdctint-altivec.c b/3rdparty/libjpeg/src/simd/powerpc/jfdctint-altivec.c
new file mode 100644
index 00000000..3d4f0171
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/powerpc/jfdctint-altivec.c
@@ -0,0 +1,258 @@
+/*
+ * AltiVec optimizations for libjpeg-turbo
+ *
+ * Copyright (C) 2014, 2020, D. R. Commander.  All Rights Reserved.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+/* ACCURATE INTEGER FORWARD DCT */
+
+#include "jsimd_altivec.h"
+
+
+#define F_0_298  2446   /* FIX(0.298631336) */
+#define F_0_390  3196   /* FIX(0.390180644) */
+#define F_0_541  4433   /* FIX(0.541196100) */
+#define F_0_765  6270   /* FIX(0.765366865) */
+#define F_0_899  7373   /* FIX(0.899976223) */
+#define F_1_175  9633   /* FIX(1.175875602) */
+#define F_1_501  12299  /* FIX(1.501321110) */
+#define F_1_847  15137  /* FIX(1.847759065) */
+#define F_1_961  16069  /* FIX(1.961570560) */
+#define F_2_053  16819  /* FIX(2.053119869) */
+#define F_2_562  20995  /* FIX(2.562915447) */
+#define F_3_072  25172  /* FIX(3.072711026) */
+
+#define CONST_BITS  13
+#define PASS1_BITS  2
+#define DESCALE_P1  (CONST_BITS - PASS1_BITS)
+#define DESCALE_P2  (CONST_BITS + PASS1_BITS)
+
+
+#define DO_FDCT_COMMON(PASS) { \
+  /* (Original) \
+   * z1 = (tmp12 + tmp13) * 0.541196100; \
+   * data2 = z1 + tmp13 * 0.765366865; \
+   * data6 = z1 + tmp12 * -1.847759065; \
+   * \
+   * (This implementation) \
+   * data2 = tmp13 * (0.541196100 + 0.765366865) + tmp12 * 0.541196100; \
+   * data6 = tmp13 * 0.541196100 + tmp12 * (0.541196100 - 1.847759065); \
+   */ \
+  \
+  tmp1312l = vec_mergeh(tmp13, tmp12); \
+  tmp1312h = vec_mergel(tmp13, tmp12); \
+  \
+  out2l = vec_msums(tmp1312l, pw_f130_f054, pd_descale_p##PASS); \
+  out2h = vec_msums(tmp1312h, pw_f130_f054, pd_descale_p##PASS); \
+  out6l = vec_msums(tmp1312l, pw_f054_mf130, pd_descale_p##PASS); \
+  out6h = vec_msums(tmp1312h, pw_f054_mf130, pd_descale_p##PASS); \
+  \
+  out2l = vec_sra(out2l, descale_p##PASS); \
+  out2h = vec_sra(out2h, descale_p##PASS); \
+  out6l = vec_sra(out6l, descale_p##PASS); \
+  out6h = vec_sra(out6h, descale_p##PASS); \
+  \
+  out2 = vec_pack(out2l, out2h); \
+  out6 = vec_pack(out6l, out6h); \
+  \
+  /* Odd part */ \
+  \
+  z3 = vec_add(tmp4, tmp6); \
+  z4 = vec_add(tmp5, tmp7); \
+  \
+  /* (Original) \
+   * z5 = (z3 + z4) * 1.175875602; \
+   * z3 = z3 * -1.961570560;  z4 = z4 * -0.390180644; \
+   * z3 += z5;  z4 += z5; \
+   * \
+   * (This implementation) \
+   * z3 = z3 * (1.175875602 - 1.961570560) + z4 * 1.175875602; \
+   * z4 = z3 * 1.175875602 + z4 * (1.175875602 - 0.390180644); \
+   */ \
+  \
+  z34l = vec_mergeh(z3, z4); \
+  z34h = vec_mergel(z3, z4); \
+  \
+  z3l = vec_msums(z34l, pw_mf078_f117, pd_descale_p##PASS); \
+  z3h = vec_msums(z34h, pw_mf078_f117, pd_descale_p##PASS); \
+  z4l = vec_msums(z34l, pw_f117_f078, pd_descale_p##PASS); \
+  z4h = vec_msums(z34h, pw_f117_f078, pd_descale_p##PASS); \
+  \
+  /* (Original) \
+   * z1 = tmp4 + tmp7;  z2 = tmp5 + tmp6; \
+   * tmp4 = tmp4 * 0.298631336;  tmp5 = tmp5 * 2.053119869; \
+   * tmp6 = tmp6 * 3.072711026;  tmp7 = tmp7 * 1.501321110; \
+   * z1 = z1 * -0.899976223;  z2 = z2 * -2.562915447; \
+   * data7 = tmp4 + z1 + z3;  data5 = tmp5 + z2 + z4; \
+   * data3 = tmp6 + z2 + z3;  data1 = tmp7 + z1 + z4; \
+   * \
+   * (This implementation) \
+   * tmp4 = tmp4 * (0.298631336 - 0.899976223) + tmp7 * -0.899976223; \
+   * tmp5 = tmp5 * (2.053119869 - 2.562915447) + tmp6 * -2.562915447; \
+   * tmp6 = tmp5 * -2.562915447 + tmp6 * (3.072711026 - 2.562915447); \
+   * tmp7 = tmp4 * -0.899976223 + tmp7 * (1.501321110 - 0.899976223); \
+   * data7 = tmp4 + z3;  data5 = tmp5 + z4; \
+   * data3 = tmp6 + z3;  data1 = tmp7 + z4; \
+   */ \
+  \
+  tmp47l = vec_mergeh(tmp4, tmp7); \
+  tmp47h = vec_mergel(tmp4, tmp7); \
+  \
+  out7l = vec_msums(tmp47l, pw_mf060_mf089, z3l); \
+  out7h = vec_msums(tmp47h, pw_mf060_mf089, z3h); \
+  out1l = vec_msums(tmp47l, pw_mf089_f060, z4l); \
+  out1h = vec_msums(tmp47h, pw_mf089_f060, z4h); \
+  \
+  out7l = vec_sra(out7l, descale_p##PASS); \
+  out7h = vec_sra(out7h, descale_p##PASS); \
+  out1l = vec_sra(out1l, descale_p##PASS); \
+  out1h = vec_sra(out1h, descale_p##PASS); \
+  \
+  out7 = vec_pack(out7l, out7h); \
+  out1 = vec_pack(out1l, out1h); \
+  \
+  tmp56l = vec_mergeh(tmp5, tmp6); \
+  tmp56h = vec_mergel(tmp5, tmp6); \
+  \
+  out5l = vec_msums(tmp56l, pw_mf050_mf256, z4l); \
+  out5h = vec_msums(tmp56h, pw_mf050_mf256, z4h); \
+  out3l = vec_msums(tmp56l, pw_mf256_f050, z3l); \
+  out3h = vec_msums(tmp56h, pw_mf256_f050, z3h); \
+  \
+  out5l = vec_sra(out5l, descale_p##PASS); \
+  out5h = vec_sra(out5h, descale_p##PASS); \
+  out3l = vec_sra(out3l, descale_p##PASS); \
+  out3h = vec_sra(out3h, descale_p##PASS); \
+  \
+  out5 = vec_pack(out5l, out5h); \
+  out3 = vec_pack(out3l, out3h); \
+}
+
+#define DO_FDCT_PASS1() { \
+  /* Even part */ \
+  \
+  tmp10 = vec_add(tmp0, tmp3); \
+  tmp13 = vec_sub(tmp0, tmp3); \
+  tmp11 = vec_add(tmp1, tmp2); \
+  tmp12 = vec_sub(tmp1, tmp2); \
+  \
+  out0  = vec_add(tmp10, tmp11); \
+  out0  = vec_sl(out0, pass1_bits); \
+  out4  = vec_sub(tmp10, tmp11); \
+  out4  = vec_sl(out4, pass1_bits); \
+  \
+  DO_FDCT_COMMON(1); \
+}
+
+#define DO_FDCT_PASS2() { \
+  /* Even part */ \
+  \
+  tmp10 = vec_add(tmp0, tmp3); \
+  tmp13 = vec_sub(tmp0, tmp3); \
+  tmp11 = vec_add(tmp1, tmp2); \
+  tmp12 = vec_sub(tmp1, tmp2); \
+  \
+  out0  = vec_add(tmp10, tmp11); \
+  out0  = vec_add(out0, pw_descale_p2x); \
+  out0  = vec_sra(out0, pass1_bits); \
+  out4  = vec_sub(tmp10, tmp11); \
+  out4  = vec_add(out4, pw_descale_p2x); \
+  out4  = vec_sra(out4, pass1_bits); \
+  \
+  DO_FDCT_COMMON(2); \
+}
+
+
+void jsimd_fdct_islow_altivec(DCTELEM *data)
+{
+  __vector short row0, row1, row2, row3, row4, row5, row6, row7,
+    col0, col1, col2, col3, col4, col5, col6, col7,
+    tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7, tmp10, tmp11, tmp12, tmp13,
+    tmp47l, tmp47h, tmp56l, tmp56h, tmp1312l, tmp1312h,
+    z3, z4, z34l, z34h,
+    out0, out1, out2, out3, out4, out5, out6, out7;
+  __vector int z3l, z3h, z4l, z4h,
+    out1l, out1h, out2l, out2h, out3l, out3h, out5l, out5h, out6l, out6h,
+    out7l, out7h;
+
+  /* Constants */
+  __vector short
+    pw_f130_f054 = { __4X2(F_0_541 + F_0_765, F_0_541) },
+    pw_f054_mf130 = { __4X2(F_0_541, F_0_541 - F_1_847) },
+    pw_mf078_f117 = { __4X2(F_1_175 - F_1_961, F_1_175) },
+    pw_f117_f078 = { __4X2(F_1_175, F_1_175 - F_0_390) },
+    pw_mf060_mf089 = { __4X2(F_0_298 - F_0_899, -F_0_899) },
+    pw_mf089_f060 = { __4X2(-F_0_899, F_1_501 - F_0_899) },
+    pw_mf050_mf256 = { __4X2(F_2_053 - F_2_562, -F_2_562) },
+    pw_mf256_f050 = { __4X2(-F_2_562, F_3_072 - F_2_562) },
+    pw_descale_p2x = { __8X(1 << (PASS1_BITS - 1)) };
+  __vector unsigned short pass1_bits = { __8X(PASS1_BITS) };
+  __vector int pd_descale_p1 = { __4X(1 << (DESCALE_P1 - 1)) },
+    pd_descale_p2 = { __4X(1 << (DESCALE_P2 - 1)) };
+  __vector unsigned int descale_p1 = { __4X(DESCALE_P1) },
+    descale_p2 = { __4X(DESCALE_P2) };
+
+  /* Pass 1: process rows */
+
+  row0 = vec_ld(0, data);
+  row1 = vec_ld(16, data);
+  row2 = vec_ld(32, data);
+  row3 = vec_ld(48, data);
+  row4 = vec_ld(64, data);
+  row5 = vec_ld(80, data);
+  row6 = vec_ld(96, data);
+  row7 = vec_ld(112, data);
+
+  TRANSPOSE(row, col);
+
+  tmp0 = vec_add(col0, col7);
+  tmp7 = vec_sub(col0, col7);
+  tmp1 = vec_add(col1, col6);
+  tmp6 = vec_sub(col1, col6);
+  tmp2 = vec_add(col2, col5);
+  tmp5 = vec_sub(col2, col5);
+  tmp3 = vec_add(col3, col4);
+  tmp4 = vec_sub(col3, col4);
+
+  DO_FDCT_PASS1();
+
+  /* Pass 2: process columns */
+
+  TRANSPOSE(out, row);
+
+  tmp0 = vec_add(row0, row7);
+  tmp7 = vec_sub(row0, row7);
+  tmp1 = vec_add(row1, row6);
+  tmp6 = vec_sub(row1, row6);
+  tmp2 = vec_add(row2, row5);
+  tmp5 = vec_sub(row2, row5);
+  tmp3 = vec_add(row3, row4);
+  tmp4 = vec_sub(row3, row4);
+
+  DO_FDCT_PASS2();
+
+  vec_st(out0, 0, data);
+  vec_st(out1, 16, data);
+  vec_st(out2, 32, data);
+  vec_st(out3, 48, data);
+  vec_st(out4, 64, data);
+  vec_st(out5, 80, data);
+  vec_st(out6, 96, data);
+  vec_st(out7, 112, data);
+}
diff --git a/3rdparty/libjpeg/src/simd/powerpc/jidctfst-altivec.c b/3rdparty/libjpeg/src/simd/powerpc/jidctfst-altivec.c
new file mode 100644
index 00000000..456c6c61
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/powerpc/jidctfst-altivec.c
@@ -0,0 +1,255 @@
+/*
+ * AltiVec optimizations for libjpeg-turbo
+ *
+ * Copyright (C) 2014-2015, D. R. Commander.  All Rights Reserved.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+/* FAST INTEGER INVERSE DCT
+ *
+ * This is similar to the SSE2 implementation, except that we left-shift the
+ * constants by 1 less bit (the -1 in CONST_SHIFT.)  This is because
+ * vec_madds(arg1, arg2, arg3) generates the 16-bit saturated sum of:
+ *   the elements in arg3 + the most significant 17 bits of
+ *     (the elements in arg1 * the elements in arg2).
+ */
+
+#include "jsimd_altivec.h"
+
+
+#define F_1_082  277              /* FIX(1.082392200) */
+#define F_1_414  362              /* FIX(1.414213562) */
+#define F_1_847  473              /* FIX(1.847759065) */
+#define F_2_613  669              /* FIX(2.613125930) */
+#define F_1_613  (F_2_613 - 256)  /* FIX(2.613125930) - FIX(1) */
+
+#define CONST_BITS  8
+#define PASS1_BITS  2
+#define PRE_MULTIPLY_SCALE_BITS  2
+#define CONST_SHIFT  (16 - PRE_MULTIPLY_SCALE_BITS - CONST_BITS - 1)
+
+
+#define DO_IDCT(in) { \
+  /* Even part */ \
+  \
+  tmp10 = vec_add(in##0, in##4); \
+  tmp11 = vec_sub(in##0, in##4); \
+  tmp13 = vec_add(in##2, in##6); \
+  \
+  tmp12 = vec_sub(in##2, in##6); \
+  tmp12 = vec_sl(tmp12, pre_multiply_scale_bits); \
+  tmp12 = vec_madds(tmp12, pw_F1414, pw_zero); \
+  tmp12 = vec_sub(tmp12, tmp13); \
+  \
+  tmp0 = vec_add(tmp10, tmp13); \
+  tmp3 = vec_sub(tmp10, tmp13); \
+  tmp1 = vec_add(tmp11, tmp12); \
+  tmp2 = vec_sub(tmp11, tmp12); \
+  \
+  /* Odd part */ \
+  \
+  z13 = vec_add(in##5, in##3); \
+  z10 = vec_sub(in##5, in##3); \
+  z10s = vec_sl(z10, pre_multiply_scale_bits); \
+  z11 = vec_add(in##1, in##7); \
+  z12s = vec_sub(in##1, in##7); \
+  z12s = vec_sl(z12s, pre_multiply_scale_bits); \
+  \
+  tmp11 = vec_sub(z11, z13); \
+  tmp11 = vec_sl(tmp11, pre_multiply_scale_bits); \
+  tmp11 = vec_madds(tmp11, pw_F1414, pw_zero); \
+  \
+  tmp7 = vec_add(z11, z13); \
+  \
+  /* To avoid overflow... \
+   * \
+   * (Original) \
+   * tmp12 = -2.613125930 * z10 + z5; \
+   * \
+   * (This implementation) \
+   * tmp12 = (-1.613125930 - 1) * z10 + z5; \
+   *       = -1.613125930 * z10 - z10 + z5; \
+   */ \
+  \
+  z5 = vec_add(z10s, z12s); \
+  z5 = vec_madds(z5, pw_F1847, pw_zero); \
+  \
+  tmp10 = vec_madds(z12s, pw_F1082, pw_zero); \
+  tmp10 = vec_sub(tmp10, z5); \
+  tmp12 = vec_madds(z10s, pw_MF1613, z5); \
+  tmp12 = vec_sub(tmp12, z10); \
+  \
+  tmp6 = vec_sub(tmp12, tmp7); \
+  tmp5 = vec_sub(tmp11, tmp6); \
+  tmp4 = vec_add(tmp10, tmp5); \
+  \
+  out0 = vec_add(tmp0, tmp7); \
+  out1 = vec_add(tmp1, tmp6); \
+  out2 = vec_add(tmp2, tmp5); \
+  out3 = vec_sub(tmp3, tmp4); \
+  out4 = vec_add(tmp3, tmp4); \
+  out5 = vec_sub(tmp2, tmp5); \
+  out6 = vec_sub(tmp1, tmp6); \
+  out7 = vec_sub(tmp0, tmp7); \
+}
+
+
+void jsimd_idct_ifast_altivec(void *dct_table_, JCOEFPTR coef_block,
+                              JSAMPARRAY output_buf, JDIMENSION output_col)
+{
+  short *dct_table = (short *)dct_table_;
+  int *outptr;
+
+  __vector short row0, row1, row2, row3, row4, row5, row6, row7,
+    col0, col1, col2, col3, col4, col5, col6, col7,
+    quant0, quant1, quant2, quant3, quant4, quant5, quant6, quant7,
+    tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7, tmp10, tmp11, tmp12, tmp13,
+    z5, z10, z10s, z11, z12s, z13,
+    out0, out1, out2, out3, out4, out5, out6, out7;
+  __vector signed char outb;
+
+  /* Constants */
+  __vector short pw_zero = { __8X(0) },
+    pw_F1414 = { __8X(F_1_414 << CONST_SHIFT) },
+    pw_F1847 = { __8X(F_1_847 << CONST_SHIFT) },
+    pw_MF1613 = { __8X(-F_1_613 << CONST_SHIFT) },
+    pw_F1082 = { __8X(F_1_082 << CONST_SHIFT) };
+  __vector unsigned short
+    pre_multiply_scale_bits = { __8X(PRE_MULTIPLY_SCALE_BITS) },
+    pass1_bits3 = { __8X(PASS1_BITS + 3) };
+  __vector signed char pb_centerjsamp = { __16X(CENTERJSAMPLE) };
+
+  /* Pass 1: process columns */
+
+  col0 = vec_ld(0, coef_block);
+  col1 = vec_ld(16, coef_block);
+  col2 = vec_ld(32, coef_block);
+  col3 = vec_ld(48, coef_block);
+  col4 = vec_ld(64, coef_block);
+  col5 = vec_ld(80, coef_block);
+  col6 = vec_ld(96, coef_block);
+  col7 = vec_ld(112, coef_block);
+
+  tmp1 = vec_or(col1, col2);
+  tmp2 = vec_or(col3, col4);
+  tmp1 = vec_or(tmp1, tmp2);
+  tmp3 = vec_or(col5, col6);
+  tmp3 = vec_or(tmp3, col7);
+  tmp1 = vec_or(tmp1, tmp3);
+
+  quant0 = vec_ld(0, dct_table);
+  col0 = vec_mladd(col0, quant0, pw_zero);
+
+  if (vec_all_eq(tmp1, pw_zero)) {
+    /* AC terms all zero */
+
+    row0 = vec_splat(col0, 0);
+    row1 = vec_splat(col0, 1);
+    row2 = vec_splat(col0, 2);
+    row3 = vec_splat(col0, 3);
+    row4 = vec_splat(col0, 4);
+    row5 = vec_splat(col0, 5);
+    row6 = vec_splat(col0, 6);
+    row7 = vec_splat(col0, 7);
+
+  } else {
+
+    quant1 = vec_ld(16, dct_table);
+    quant2 = vec_ld(32, dct_table);
+    quant3 = vec_ld(48, dct_table);
+    quant4 = vec_ld(64, dct_table);
+    quant5 = vec_ld(80, dct_table);
+    quant6 = vec_ld(96, dct_table);
+    quant7 = vec_ld(112, dct_table);
+
+    col1 = vec_mladd(col1, quant1, pw_zero);
+    col2 = vec_mladd(col2, quant2, pw_zero);
+    col3 = vec_mladd(col3, quant3, pw_zero);
+    col4 = vec_mladd(col4, quant4, pw_zero);
+    col5 = vec_mladd(col5, quant5, pw_zero);
+    col6 = vec_mladd(col6, quant6, pw_zero);
+    col7 = vec_mladd(col7, quant7, pw_zero);
+
+    DO_IDCT(col);
+
+    TRANSPOSE(out, row);
+  }
+
+  /* Pass 2: process rows */
+
+  DO_IDCT(row);
+
+  out0 = vec_sra(out0, pass1_bits3);
+  out1 = vec_sra(out1, pass1_bits3);
+  out2 = vec_sra(out2, pass1_bits3);
+  out3 = vec_sra(out3, pass1_bits3);
+  out4 = vec_sra(out4, pass1_bits3);
+  out5 = vec_sra(out5, pass1_bits3);
+  out6 = vec_sra(out6, pass1_bits3);
+  out7 = vec_sra(out7, pass1_bits3);
+
+  TRANSPOSE(out, col);
+
+  outb = vec_packs(col0, col0);
+  outb = vec_add(outb, pb_centerjsamp);
+  outptr = (int *)(output_buf[0] + output_col);
+  vec_ste((__vector int)outb, 0, outptr);
+  vec_ste((__vector int)outb, 4, outptr);
+
+  outb = vec_packs(col1, col1);
+  outb = vec_add(outb, pb_centerjsamp);
+  outptr = (int *)(output_buf[1] + output_col);
+  vec_ste((__vector int)outb, 0, outptr);
+  vec_ste((__vector int)outb, 4, outptr);
+
+  outb = vec_packs(col2, col2);
+  outb = vec_add(outb, pb_centerjsamp);
+  outptr = (int *)(output_buf[2] + output_col);
+  vec_ste((__vector int)outb, 0, outptr);
+  vec_ste((__vector int)outb, 4, outptr);
+
+  outb = vec_packs(col3, col3);
+  outb = vec_add(outb, pb_centerjsamp);
+  outptr = (int *)(output_buf[3] + output_col);
+  vec_ste((__vector int)outb, 0, outptr);
+  vec_ste((__vector int)outb, 4, outptr);
+
+  outb = vec_packs(col4, col4);
+  outb = vec_add(outb, pb_centerjsamp);
+  outptr = (int *)(output_buf[4] + output_col);
+  vec_ste((__vector int)outb, 0, outptr);
+  vec_ste((__vector int)outb, 4, outptr);
+
+  outb = vec_packs(col5, col5);
+  outb = vec_add(outb, pb_centerjsamp);
+  outptr = (int *)(output_buf[5] + output_col);
+  vec_ste((__vector int)outb, 0, outptr);
+  vec_ste((__vector int)outb, 4, outptr);
+
+  outb = vec_packs(col6, col6);
+  outb = vec_add(outb, pb_centerjsamp);
+  outptr = (int *)(output_buf[6] + output_col);
+  vec_ste((__vector int)outb, 0, outptr);
+  vec_ste((__vector int)outb, 4, outptr);
+
+  outb = vec_packs(col7, col7);
+  outb = vec_add(outb, pb_centerjsamp);
+  outptr = (int *)(output_buf[7] + output_col);
+  vec_ste((__vector int)outb, 0, outptr);
+  vec_ste((__vector int)outb, 4, outptr);
+}
diff --git a/3rdparty/libjpeg/src/simd/powerpc/jidctint-altivec.c b/3rdparty/libjpeg/src/simd/powerpc/jidctint-altivec.c
new file mode 100644
index 00000000..60e619f1
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/powerpc/jidctint-altivec.c
@@ -0,0 +1,357 @@
+/*
+ * AltiVec optimizations for libjpeg-turbo
+ *
+ * Copyright (C) 2014-2015, 2020, D. R. Commander.  All Rights Reserved.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+/* ACCURATE INTEGER INVERSE DCT */
+
+#include "jsimd_altivec.h"
+
+
+#define F_0_298  2446   /* FIX(0.298631336) */
+#define F_0_390  3196   /* FIX(0.390180644) */
+#define F_0_541  4433   /* FIX(0.541196100) */
+#define F_0_765  6270   /* FIX(0.765366865) */
+#define F_0_899  7373   /* FIX(0.899976223) */
+#define F_1_175  9633   /* FIX(1.175875602) */
+#define F_1_501  12299  /* FIX(1.501321110) */
+#define F_1_847  15137  /* FIX(1.847759065) */
+#define F_1_961  16069  /* FIX(1.961570560) */
+#define F_2_053  16819  /* FIX(2.053119869) */
+#define F_2_562  20995  /* FIX(2.562915447) */
+#define F_3_072  25172  /* FIX(3.072711026) */
+
+#define CONST_BITS  13
+#define PASS1_BITS  2
+#define DESCALE_P1  (CONST_BITS - PASS1_BITS)
+#define DESCALE_P2  (CONST_BITS + PASS1_BITS + 3)
+
+
+#define DO_IDCT(in, PASS) { \
+  /* Even part \
+   * \
+   * (Original) \
+   * z1 = (z2 + z3) * 0.541196100; \
+   * tmp2 = z1 + z3 * -1.847759065; \
+   * tmp3 = z1 + z2 * 0.765366865; \
+   * \
+   * (This implementation) \
+   * tmp2 = z2 * 0.541196100 + z3 * (0.541196100 - 1.847759065); \
+   * tmp3 = z2 * (0.541196100 + 0.765366865) + z3 * 0.541196100; \
+   */ \
+  \
+  in##26l = vec_mergeh(in##2, in##6); \
+  in##26h = vec_mergel(in##2, in##6); \
+  \
+  tmp3l = vec_msums(in##26l, pw_f130_f054, pd_zero); \
+  tmp3h = vec_msums(in##26h, pw_f130_f054, pd_zero); \
+  tmp2l = vec_msums(in##26l, pw_f054_mf130, pd_zero); \
+  tmp2h = vec_msums(in##26h, pw_f054_mf130, pd_zero); \
+  \
+  tmp0 = vec_add(in##0, in##4); \
+  tmp1 = vec_sub(in##0, in##4); \
+  \
+  tmp0l = vec_unpackh(tmp0); \
+  tmp0h = vec_unpackl(tmp0); \
+  tmp0l = vec_sl(tmp0l, const_bits); \
+  tmp0h = vec_sl(tmp0h, const_bits); \
+  tmp0l = vec_add(tmp0l, pd_descale_p##PASS); \
+  tmp0h = vec_add(tmp0h, pd_descale_p##PASS); \
+  \
+  tmp10l = vec_add(tmp0l, tmp3l); \
+  tmp10h = vec_add(tmp0h, tmp3h); \
+  tmp13l = vec_sub(tmp0l, tmp3l); \
+  tmp13h = vec_sub(tmp0h, tmp3h); \
+  \
+  tmp1l = vec_unpackh(tmp1); \
+  tmp1h = vec_unpackl(tmp1); \
+  tmp1l = vec_sl(tmp1l, const_bits); \
+  tmp1h = vec_sl(tmp1h, const_bits); \
+  tmp1l = vec_add(tmp1l, pd_descale_p##PASS); \
+  tmp1h = vec_add(tmp1h, pd_descale_p##PASS); \
+  \
+  tmp11l = vec_add(tmp1l, tmp2l); \
+  tmp11h = vec_add(tmp1h, tmp2h); \
+  tmp12l = vec_sub(tmp1l, tmp2l); \
+  tmp12h = vec_sub(tmp1h, tmp2h); \
+  \
+  /* Odd part */ \
+  \
+  z3 = vec_add(in##3, in##7); \
+  z4 = vec_add(in##1, in##5); \
+  \
+  /* (Original) \
+   * z5 = (z3 + z4) * 1.175875602; \
+   * z3 = z3 * -1.961570560;  z4 = z4 * -0.390180644; \
+   * z3 += z5;  z4 += z5; \
+   * \
+   * (This implementation) \
+   * z3 = z3 * (1.175875602 - 1.961570560) + z4 * 1.175875602; \
+   * z4 = z3 * 1.175875602 + z4 * (1.175875602 - 0.390180644); \
+   */ \
+  \
+  z34l = vec_mergeh(z3, z4); \
+  z34h = vec_mergel(z3, z4); \
+  \
+  z3l = vec_msums(z34l, pw_mf078_f117, pd_zero); \
+  z3h = vec_msums(z34h, pw_mf078_f117, pd_zero); \
+  z4l = vec_msums(z34l, pw_f117_f078, pd_zero); \
+  z4h = vec_msums(z34h, pw_f117_f078, pd_zero); \
+  \
+  /* (Original) \
+   * z1 = tmp0 + tmp3;  z2 = tmp1 + tmp2; \
+   * tmp0 = tmp0 * 0.298631336;  tmp1 = tmp1 * 2.053119869; \
+   * tmp2 = tmp2 * 3.072711026;  tmp3 = tmp3 * 1.501321110; \
+   * z1 = z1 * -0.899976223;  z2 = z2 * -2.562915447; \
+   * tmp0 += z1 + z3;  tmp1 += z2 + z4; \
+   * tmp2 += z2 + z3;  tmp3 += z1 + z4; \
+   * \
+   * (This implementation) \
+   * tmp0 = tmp0 * (0.298631336 - 0.899976223) + tmp3 * -0.899976223; \
+   * tmp1 = tmp1 * (2.053119869 - 2.562915447) + tmp2 * -2.562915447; \
+   * tmp2 = tmp1 * -2.562915447 + tmp2 * (3.072711026 - 2.562915447); \
+   * tmp3 = tmp0 * -0.899976223 + tmp3 * (1.501321110 - 0.899976223); \
+   * tmp0 += z3;  tmp1 += z4; \
+   * tmp2 += z3;  tmp3 += z4; \
+   */ \
+  \
+  in##71l = vec_mergeh(in##7, in##1); \
+  in##71h = vec_mergel(in##7, in##1); \
+  \
+  tmp0l = vec_msums(in##71l, pw_mf060_mf089, z3l); \
+  tmp0h = vec_msums(in##71h, pw_mf060_mf089, z3h); \
+  tmp3l = vec_msums(in##71l, pw_mf089_f060, z4l); \
+  tmp3h = vec_msums(in##71h, pw_mf089_f060, z4h); \
+  \
+  in##53l = vec_mergeh(in##5, in##3); \
+  in##53h = vec_mergel(in##5, in##3); \
+  \
+  tmp1l = vec_msums(in##53l, pw_mf050_mf256, z4l); \
+  tmp1h = vec_msums(in##53h, pw_mf050_mf256, z4h); \
+  tmp2l = vec_msums(in##53l, pw_mf256_f050, z3l); \
+  tmp2h = vec_msums(in##53h, pw_mf256_f050, z3h); \
+  \
+  /* Final output stage */ \
+  \
+  out0l = vec_add(tmp10l, tmp3l); \
+  out0h = vec_add(tmp10h, tmp3h); \
+  out7l = vec_sub(tmp10l, tmp3l); \
+  out7h = vec_sub(tmp10h, tmp3h); \
+  \
+  out0l = vec_sra(out0l, descale_p##PASS); \
+  out0h = vec_sra(out0h, descale_p##PASS); \
+  out7l = vec_sra(out7l, descale_p##PASS); \
+  out7h = vec_sra(out7h, descale_p##PASS); \
+  \
+  out0 = vec_pack(out0l, out0h); \
+  out7 = vec_pack(out7l, out7h); \
+  \
+  out1l = vec_add(tmp11l, tmp2l); \
+  out1h = vec_add(tmp11h, tmp2h); \
+  out6l = vec_sub(tmp11l, tmp2l); \
+  out6h = vec_sub(tmp11h, tmp2h); \
+  \
+  out1l = vec_sra(out1l, descale_p##PASS); \
+  out1h = vec_sra(out1h, descale_p##PASS); \
+  out6l = vec_sra(out6l, descale_p##PASS); \
+  out6h = vec_sra(out6h, descale_p##PASS); \
+  \
+  out1 = vec_pack(out1l, out1h); \
+  out6 = vec_pack(out6l, out6h); \
+  \
+  out2l = vec_add(tmp12l, tmp1l); \
+  out2h = vec_add(tmp12h, tmp1h); \
+  out5l = vec_sub(tmp12l, tmp1l); \
+  out5h = vec_sub(tmp12h, tmp1h); \
+  \
+  out2l = vec_sra(out2l, descale_p##PASS); \
+  out2h = vec_sra(out2h, descale_p##PASS); \
+  out5l = vec_sra(out5l, descale_p##PASS); \
+  out5h = vec_sra(out5h, descale_p##PASS); \
+  \
+  out2 = vec_pack(out2l, out2h); \
+  out5 = vec_pack(out5l, out5h); \
+  \
+  out3l = vec_add(tmp13l, tmp0l); \
+  out3h = vec_add(tmp13h, tmp0h); \
+  out4l = vec_sub(tmp13l, tmp0l); \
+  out4h = vec_sub(tmp13h, tmp0h); \
+  \
+  out3l = vec_sra(out3l, descale_p##PASS); \
+  out3h = vec_sra(out3h, descale_p##PASS); \
+  out4l = vec_sra(out4l, descale_p##PASS); \
+  out4h = vec_sra(out4h, descale_p##PASS); \
+  \
+  out3 = vec_pack(out3l, out3h); \
+  out4 = vec_pack(out4l, out4h); \
+}
+
+
+void jsimd_idct_islow_altivec(void *dct_table_, JCOEFPTR coef_block,
+                              JSAMPARRAY output_buf, JDIMENSION output_col)
+{
+  short *dct_table = (short *)dct_table_;
+  int *outptr;
+
+  __vector short row0, row1, row2, row3, row4, row5, row6, row7,
+    col0, col1, col2, col3, col4, col5, col6, col7,
+    quant0, quant1, quant2, quant3, quant4, quant5, quant6, quant7,
+    tmp0, tmp1, tmp2, tmp3, z3, z4,
+    z34l, z34h, col71l, col71h, col26l, col26h, col53l, col53h,
+    row71l, row71h, row26l, row26h, row53l, row53h,
+    out0, out1, out2, out3, out4, out5, out6, out7;
+  __vector int tmp0l, tmp0h, tmp1l, tmp1h, tmp2l, tmp2h, tmp3l, tmp3h,
+    tmp10l, tmp10h, tmp11l, tmp11h, tmp12l, tmp12h, tmp13l, tmp13h,
+    z3l, z3h, z4l, z4h,
+    out0l, out0h, out1l, out1h, out2l, out2h, out3l, out3h, out4l, out4h,
+    out5l, out5h, out6l, out6h, out7l, out7h;
+  __vector signed char outb;
+
+  /* Constants */
+  __vector short pw_zero = { __8X(0) },
+    pw_f130_f054 = { __4X2(F_0_541 + F_0_765, F_0_541) },
+    pw_f054_mf130 = { __4X2(F_0_541, F_0_541 - F_1_847) },
+    pw_mf078_f117 = { __4X2(F_1_175 - F_1_961, F_1_175) },
+    pw_f117_f078 = { __4X2(F_1_175, F_1_175 - F_0_390) },
+    pw_mf060_mf089 = { __4X2(F_0_298 - F_0_899, -F_0_899) },
+    pw_mf089_f060 = { __4X2(-F_0_899, F_1_501 - F_0_899) },
+    pw_mf050_mf256 = { __4X2(F_2_053 - F_2_562, -F_2_562) },
+    pw_mf256_f050 = { __4X2(-F_2_562, F_3_072 - F_2_562) };
+  __vector unsigned short pass1_bits = { __8X(PASS1_BITS) };
+  __vector int pd_zero = { __4X(0) },
+    pd_descale_p1 = { __4X(1 << (DESCALE_P1 - 1)) },
+    pd_descale_p2 = { __4X(1 << (DESCALE_P2 - 1)) };
+  __vector unsigned int descale_p1 = { __4X(DESCALE_P1) },
+    descale_p2 = { __4X(DESCALE_P2) },
+    const_bits = { __4X(CONST_BITS) };
+  __vector signed char pb_centerjsamp = { __16X(CENTERJSAMPLE) };
+
+  /* Pass 1: process columns */
+
+  col0 = vec_ld(0, coef_block);
+  col1 = vec_ld(16, coef_block);
+  col2 = vec_ld(32, coef_block);
+  col3 = vec_ld(48, coef_block);
+  col4 = vec_ld(64, coef_block);
+  col5 = vec_ld(80, coef_block);
+  col6 = vec_ld(96, coef_block);
+  col7 = vec_ld(112, coef_block);
+
+  tmp1 = vec_or(col1, col2);
+  tmp2 = vec_or(col3, col4);
+  tmp1 = vec_or(tmp1, tmp2);
+  tmp3 = vec_or(col5, col6);
+  tmp3 = vec_or(tmp3, col7);
+  tmp1 = vec_or(tmp1, tmp3);
+
+  quant0 = vec_ld(0, dct_table);
+  col0 = vec_mladd(col0, quant0, pw_zero);
+
+  if (vec_all_eq(tmp1, pw_zero)) {
+    /* AC terms all zero */
+
+    col0 = vec_sl(col0, pass1_bits);
+
+    row0 = vec_splat(col0, 0);
+    row1 = vec_splat(col0, 1);
+    row2 = vec_splat(col0, 2);
+    row3 = vec_splat(col0, 3);
+    row4 = vec_splat(col0, 4);
+    row5 = vec_splat(col0, 5);
+    row6 = vec_splat(col0, 6);
+    row7 = vec_splat(col0, 7);
+
+  } else {
+
+    quant1 = vec_ld(16, dct_table);
+    quant2 = vec_ld(32, dct_table);
+    quant3 = vec_ld(48, dct_table);
+    quant4 = vec_ld(64, dct_table);
+    quant5 = vec_ld(80, dct_table);
+    quant6 = vec_ld(96, dct_table);
+    quant7 = vec_ld(112, dct_table);
+
+    col1 = vec_mladd(col1, quant1, pw_zero);
+    col2 = vec_mladd(col2, quant2, pw_zero);
+    col3 = vec_mladd(col3, quant3, pw_zero);
+    col4 = vec_mladd(col4, quant4, pw_zero);
+    col5 = vec_mladd(col5, quant5, pw_zero);
+    col6 = vec_mladd(col6, quant6, pw_zero);
+    col7 = vec_mladd(col7, quant7, pw_zero);
+
+    DO_IDCT(col, 1);
+
+    TRANSPOSE(out, row);
+  }
+
+  /* Pass 2: process rows */
+
+  DO_IDCT(row, 2);
+
+  TRANSPOSE(out, col);
+
+  outb = vec_packs(col0, col0);
+  outb = vec_add(outb, pb_centerjsamp);
+  outptr = (int *)(output_buf[0] + output_col);
+  vec_ste((__vector int)outb, 0, outptr);
+  vec_ste((__vector int)outb, 4, outptr);
+
+  outb = vec_packs(col1, col1);
+  outb = vec_add(outb, pb_centerjsamp);
+  outptr = (int *)(output_buf[1] + output_col);
+  vec_ste((__vector int)outb, 0, outptr);
+  vec_ste((__vector int)outb, 4, outptr);
+
+  outb = vec_packs(col2, col2);
+  outb = vec_add(outb, pb_centerjsamp);
+  outptr = (int *)(output_buf[2] + output_col);
+  vec_ste((__vector int)outb, 0, outptr);
+  vec_ste((__vector int)outb, 4, outptr);
+
+  outb = vec_packs(col3, col3);
+  outb = vec_add(outb, pb_centerjsamp);
+  outptr = (int *)(output_buf[3] + output_col);
+  vec_ste((__vector int)outb, 0, outptr);
+  vec_ste((__vector int)outb, 4, outptr);
+
+  outb = vec_packs(col4, col4);
+  outb = vec_add(outb, pb_centerjsamp);
+  outptr = (int *)(output_buf[4] + output_col);
+  vec_ste((__vector int)outb, 0, outptr);
+  vec_ste((__vector int)outb, 4, outptr);
+
+  outb = vec_packs(col5, col5);
+  outb = vec_add(outb, pb_centerjsamp);
+  outptr = (int *)(output_buf[5] + output_col);
+  vec_ste((__vector int)outb, 0, outptr);
+  vec_ste((__vector int)outb, 4, outptr);
+
+  outb = vec_packs(col6, col6);
+  outb = vec_add(outb, pb_centerjsamp);
+  outptr = (int *)(output_buf[6] + output_col);
+  vec_ste((__vector int)outb, 0, outptr);
+  vec_ste((__vector int)outb, 4, outptr);
+
+  outb = vec_packs(col7, col7);
+  outb = vec_add(outb, pb_centerjsamp);
+  outptr = (int *)(output_buf[7] + output_col);
+  vec_ste((__vector int)outb, 0, outptr);
+  vec_ste((__vector int)outb, 4, outptr);
+}
diff --git a/3rdparty/libjpeg/src/simd/powerpc/jquanti-altivec.c b/3rdparty/libjpeg/src/simd/powerpc/jquanti-altivec.c
new file mode 100644
index 00000000..7d6e3254
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/powerpc/jquanti-altivec.c
@@ -0,0 +1,250 @@
+/*
+ * AltiVec optimizations for libjpeg-turbo
+ *
+ * Copyright (C) 2014-2015, D. R. Commander.  All Rights Reserved.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+/* INTEGER QUANTIZATION AND SAMPLE CONVERSION */
+
+#include "jsimd_altivec.h"
+
+
+/* NOTE: The address will either be aligned or offset by 8 bytes, so we can
+ * always get the data we want by using a single vector load (although we may
+ * have to permute the result.)
+ */
+#if __BIG_ENDIAN__
+
+#define LOAD_ROW(row) { \
+  elemptr = sample_data[row] + start_col; \
+  in##row = vec_ld(0, elemptr); \
+  if ((size_t)elemptr & 15) \
+    in##row = vec_perm(in##row, in##row, vec_lvsl(0, elemptr)); \
+}
+
+#else
+
+#define LOAD_ROW(row) { \
+  elemptr = sample_data[row] + start_col; \
+  in##row = vec_vsx_ld(0, elemptr); \
+}
+
+#endif
+
+
+void jsimd_convsamp_altivec(JSAMPARRAY sample_data, JDIMENSION start_col,
+                            DCTELEM *workspace)
+{
+  JSAMPROW elemptr;
+
+  __vector unsigned char in0, in1, in2, in3, in4, in5, in6, in7;
+  __vector short out0, out1, out2, out3, out4, out5, out6, out7;
+
+  /* Constants */
+  __vector short pw_centerjsamp = { __8X(CENTERJSAMPLE) };
+  __vector unsigned char pb_zero = { __16X(0) };
+
+  LOAD_ROW(0);
+  LOAD_ROW(1);
+  LOAD_ROW(2);
+  LOAD_ROW(3);
+  LOAD_ROW(4);
+  LOAD_ROW(5);
+  LOAD_ROW(6);
+  LOAD_ROW(7);
+
+  out0 = (__vector short)VEC_UNPACKHU(in0);
+  out1 = (__vector short)VEC_UNPACKHU(in1);
+  out2 = (__vector short)VEC_UNPACKHU(in2);
+  out3 = (__vector short)VEC_UNPACKHU(in3);
+  out4 = (__vector short)VEC_UNPACKHU(in4);
+  out5 = (__vector short)VEC_UNPACKHU(in5);
+  out6 = (__vector short)VEC_UNPACKHU(in6);
+  out7 = (__vector short)VEC_UNPACKHU(in7);
+
+  out0 = vec_sub(out0, pw_centerjsamp);
+  out1 = vec_sub(out1, pw_centerjsamp);
+  out2 = vec_sub(out2, pw_centerjsamp);
+  out3 = vec_sub(out3, pw_centerjsamp);
+  out4 = vec_sub(out4, pw_centerjsamp);
+  out5 = vec_sub(out5, pw_centerjsamp);
+  out6 = vec_sub(out6, pw_centerjsamp);
+  out7 = vec_sub(out7, pw_centerjsamp);
+
+  vec_st(out0, 0, workspace);
+  vec_st(out1, 16, workspace);
+  vec_st(out2, 32, workspace);
+  vec_st(out3, 48, workspace);
+  vec_st(out4, 64, workspace);
+  vec_st(out5, 80, workspace);
+  vec_st(out6, 96, workspace);
+  vec_st(out7, 112, workspace);
+}
+
+
+#define WORD_BIT  16
+
+/* There is no AltiVec 16-bit unsigned multiply instruction, hence this.
+   We basically need an unsigned equivalent of vec_madds(). */
+
+#define MULTIPLY(vs0, vs1, out) { \
+  tmpe = vec_mule((__vector unsigned short)vs0, \
+                  (__vector unsigned short)vs1); \
+  tmpo = vec_mulo((__vector unsigned short)vs0, \
+                  (__vector unsigned short)vs1); \
+  out = (__vector short)vec_perm((__vector unsigned short)tmpe, \
+                                 (__vector unsigned short)tmpo, \
+                                 shift_pack_index); \
+}
+
+void jsimd_quantize_altivec(JCOEFPTR coef_block, DCTELEM *divisors,
+                            DCTELEM *workspace)
+{
+  __vector short row0, row1, row2, row3, row4, row5, row6, row7,
+    row0s, row1s, row2s, row3s, row4s, row5s, row6s, row7s,
+    corr0, corr1, corr2, corr3, corr4, corr5, corr6, corr7,
+    recip0, recip1, recip2, recip3, recip4, recip5, recip6, recip7,
+    scale0, scale1, scale2, scale3, scale4, scale5, scale6, scale7;
+  __vector unsigned int tmpe, tmpo;
+
+  /* Constants */
+  __vector unsigned short pw_word_bit_m1 = { __8X(WORD_BIT - 1) };
+#if __BIG_ENDIAN__
+  __vector unsigned char shift_pack_index =
+    {  0,  1, 16, 17,  4,  5, 20, 21,  8,  9, 24, 25, 12, 13, 28, 29 };
+#else
+  __vector unsigned char shift_pack_index =
+    {  2,  3, 18, 19,  6,  7, 22, 23, 10, 11, 26, 27, 14, 15, 30, 31 };
+#endif
+
+  row0 = vec_ld(0, workspace);
+  row1 = vec_ld(16, workspace);
+  row2 = vec_ld(32, workspace);
+  row3 = vec_ld(48, workspace);
+  row4 = vec_ld(64, workspace);
+  row5 = vec_ld(80, workspace);
+  row6 = vec_ld(96, workspace);
+  row7 = vec_ld(112, workspace);
+
+  /* Branch-less absolute value */
+  row0s = vec_sra(row0, pw_word_bit_m1);
+  row1s = vec_sra(row1, pw_word_bit_m1);
+  row2s = vec_sra(row2, pw_word_bit_m1);
+  row3s = vec_sra(row3, pw_word_bit_m1);
+  row4s = vec_sra(row4, pw_word_bit_m1);
+  row5s = vec_sra(row5, pw_word_bit_m1);
+  row6s = vec_sra(row6, pw_word_bit_m1);
+  row7s = vec_sra(row7, pw_word_bit_m1);
+  row0 = vec_xor(row0, row0s);
+  row1 = vec_xor(row1, row1s);
+  row2 = vec_xor(row2, row2s);
+  row3 = vec_xor(row3, row3s);
+  row4 = vec_xor(row4, row4s);
+  row5 = vec_xor(row5, row5s);
+  row6 = vec_xor(row6, row6s);
+  row7 = vec_xor(row7, row7s);
+  row0 = vec_sub(row0, row0s);
+  row1 = vec_sub(row1, row1s);
+  row2 = vec_sub(row2, row2s);
+  row3 = vec_sub(row3, row3s);
+  row4 = vec_sub(row4, row4s);
+  row5 = vec_sub(row5, row5s);
+  row6 = vec_sub(row6, row6s);
+  row7 = vec_sub(row7, row7s);
+
+  corr0 = vec_ld(DCTSIZE2 * 2, divisors);
+  corr1 = vec_ld(DCTSIZE2 * 2 + 16, divisors);
+  corr2 = vec_ld(DCTSIZE2 * 2 + 32, divisors);
+  corr3 = vec_ld(DCTSIZE2 * 2 + 48, divisors);
+  corr4 = vec_ld(DCTSIZE2 * 2 + 64, divisors);
+  corr5 = vec_ld(DCTSIZE2 * 2 + 80, divisors);
+  corr6 = vec_ld(DCTSIZE2 * 2 + 96, divisors);
+  corr7 = vec_ld(DCTSIZE2 * 2 + 112, divisors);
+
+  row0 = vec_add(row0, corr0);
+  row1 = vec_add(row1, corr1);
+  row2 = vec_add(row2, corr2);
+  row3 = vec_add(row3, corr3);
+  row4 = vec_add(row4, corr4);
+  row5 = vec_add(row5, corr5);
+  row6 = vec_add(row6, corr6);
+  row7 = vec_add(row7, corr7);
+
+  recip0 = vec_ld(0, divisors);
+  recip1 = vec_ld(16, divisors);
+  recip2 = vec_ld(32, divisors);
+  recip3 = vec_ld(48, divisors);
+  recip4 = vec_ld(64, divisors);
+  recip5 = vec_ld(80, divisors);
+  recip6 = vec_ld(96, divisors);
+  recip7 = vec_ld(112, divisors);
+
+  MULTIPLY(row0, recip0, row0);
+  MULTIPLY(row1, recip1, row1);
+  MULTIPLY(row2, recip2, row2);
+  MULTIPLY(row3, recip3, row3);
+  MULTIPLY(row4, recip4, row4);
+  MULTIPLY(row5, recip5, row5);
+  MULTIPLY(row6, recip6, row6);
+  MULTIPLY(row7, recip7, row7);
+
+  scale0 = vec_ld(DCTSIZE2 * 4, divisors);
+  scale1 = vec_ld(DCTSIZE2 * 4 + 16, divisors);
+  scale2 = vec_ld(DCTSIZE2 * 4 + 32, divisors);
+  scale3 = vec_ld(DCTSIZE2 * 4 + 48, divisors);
+  scale4 = vec_ld(DCTSIZE2 * 4 + 64, divisors);
+  scale5 = vec_ld(DCTSIZE2 * 4 + 80, divisors);
+  scale6 = vec_ld(DCTSIZE2 * 4 + 96, divisors);
+  scale7 = vec_ld(DCTSIZE2 * 4 + 112, divisors);
+
+  MULTIPLY(row0, scale0, row0);
+  MULTIPLY(row1, scale1, row1);
+  MULTIPLY(row2, scale2, row2);
+  MULTIPLY(row3, scale3, row3);
+  MULTIPLY(row4, scale4, row4);
+  MULTIPLY(row5, scale5, row5);
+  MULTIPLY(row6, scale6, row6);
+  MULTIPLY(row7, scale7, row7);
+
+  row0 = vec_xor(row0, row0s);
+  row1 = vec_xor(row1, row1s);
+  row2 = vec_xor(row2, row2s);
+  row3 = vec_xor(row3, row3s);
+  row4 = vec_xor(row4, row4s);
+  row5 = vec_xor(row5, row5s);
+  row6 = vec_xor(row6, row6s);
+  row7 = vec_xor(row7, row7s);
+  row0 = vec_sub(row0, row0s);
+  row1 = vec_sub(row1, row1s);
+  row2 = vec_sub(row2, row2s);
+  row3 = vec_sub(row3, row3s);
+  row4 = vec_sub(row4, row4s);
+  row5 = vec_sub(row5, row5s);
+  row6 = vec_sub(row6, row6s);
+  row7 = vec_sub(row7, row7s);
+
+  vec_st(row0, 0, coef_block);
+  vec_st(row1, 16, coef_block);
+  vec_st(row2, 32, coef_block);
+  vec_st(row3, 48, coef_block);
+  vec_st(row4, 64, coef_block);
+  vec_st(row5, 80, coef_block);
+  vec_st(row6, 96, coef_block);
+  vec_st(row7, 112, coef_block);
+}
diff --git a/3rdparty/libjpeg/src/simd/powerpc/jsimd.c b/3rdparty/libjpeg/src/simd/powerpc/jsimd.c
new file mode 100644
index 00000000..d0d3981e
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/powerpc/jsimd.c
@@ -0,0 +1,872 @@
+/*
+ * jsimd_powerpc.c
+ *
+ * Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+ * Copyright (C) 2009-2011, 2014-2016, 2018, D. R. Commander.
+ * Copyright (C) 2015-2016, 2018, Matthieu Darbois.
+ *
+ * Based on the x86 SIMD extension for IJG JPEG library,
+ * Copyright (C) 1999-2006, MIYASAKA Masaru.
+ * For conditions of distribution and use, see copyright notice in jsimdext.inc
+ *
+ * This file contains the interface between the "normal" portions
+ * of the library and the SIMD implementations when running on a
+ * PowerPC architecture.
+ */
+
+#ifdef __amigaos4__
+/* This must be defined first as it re-defines GLOBAL otherwise */
+#include <proto/exec.h>
+#endif
+
+#define JPEG_INTERNALS
+#include "../../jinclude.h"
+#include "../../jpeglib.h"
+#include "../../jsimd.h"
+#include "../../jdct.h"
+#include "../../jsimddct.h"
+#include "../jsimd.h"
+
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+
+#if defined(__OpenBSD__)
+#include <sys/param.h>
+#include <sys/sysctl.h>
+#include <machine/cpu.h>
+#endif
+
+static unsigned int simd_support = ~0;
+
+#if !defined(__ALTIVEC__) && (defined(__linux__) || defined(ANDROID) || defined(__ANDROID__))
+
+#define SOMEWHAT_SANE_PROC_CPUINFO_SIZE_LIMIT  (1024 * 1024)
+
+LOCAL(int)
+check_feature(char *buffer, char *feature)
+{
+  char *p;
+
+  if (*feature == 0)
+    return 0;
+  if (strncmp(buffer, "cpu", 3) != 0)
+    return 0;
+  buffer += 3;
+  while (isspace(*buffer))
+    buffer++;
+
+  /* Check if 'feature' is present in the buffer as a separate word */
+  while ((p = strstr(buffer, feature))) {
+    if (p > buffer && !isspace(*(p - 1))) {
+      buffer++;
+      continue;
+    }
+    p += strlen(feature);
+    if (*p != 0 && !isspace(*p)) {
+      buffer++;
+      continue;
+    }
+    return 1;
+  }
+  return 0;
+}
+
+LOCAL(int)
+parse_proc_cpuinfo(int bufsize)
+{
+  char *buffer = (char *)malloc(bufsize);
+  FILE *fd;
+
+  simd_support = 0;
+
+  if (!buffer)
+    return 0;
+
+  fd = fopen("/proc/cpuinfo", "r");
+  if (fd) {
+    while (fgets(buffer, bufsize, fd)) {
+      if (!strchr(buffer, '\n') && !feof(fd)) {
+        /* "impossible" happened - insufficient size of the buffer! */
+        fclose(fd);
+        free(buffer);
+        return 0;
+      }
+      if (check_feature(buffer, "altivec"))
+        simd_support |= JSIMD_ALTIVEC;
+    }
+    fclose(fd);
+  }
+  free(buffer);
+  return 1;
+}
+
+#endif
+
+/*
+ * Check what SIMD accelerations are supported.
+ *
+ * FIXME: This code is racy under a multi-threaded environment.
+ */
+LOCAL(void)
+init_simd(void)
+{
+#ifndef NO_GETENV
+  char *env = NULL;
+#endif
+#if !defined(__ALTIVEC__) && (defined(__linux__) || defined(ANDROID) || defined(__ANDROID__))
+  int bufsize = 1024; /* an initial guess for the line buffer size limit */
+#elif defined(__amigaos4__)
+  uint32 altivec = 0;
+#elif defined(__OpenBSD__)
+  int mib[2] = { CTL_MACHDEP, CPU_ALTIVEC };
+  int altivec;
+  size_t len = sizeof(altivec);
+#endif
+
+  if (simd_support != ~0U)
+    return;
+
+  simd_support = 0;
+
+#if defined(__ALTIVEC__) || defined(__APPLE__)
+  simd_support |= JSIMD_ALTIVEC;
+#elif defined(__linux__) || defined(ANDROID) || defined(__ANDROID__)
+  while (!parse_proc_cpuinfo(bufsize)) {
+    bufsize *= 2;
+    if (bufsize > SOMEWHAT_SANE_PROC_CPUINFO_SIZE_LIMIT)
+      break;
+  }
+#elif defined(__amigaos4__)
+  IExec->GetCPUInfoTags(GCIT_VectorUnit, &altivec, TAG_DONE);
+  if (altivec == VECTORTYPE_ALTIVEC)
+    simd_support |= JSIMD_ALTIVEC;
+#elif defined(__OpenBSD__)
+  if (sysctl(mib, 2, &altivec, &len, NULL, 0) == 0 && altivec != 0)
+    simd_support |= JSIMD_ALTIVEC;
+#endif
+
+#ifndef NO_GETENV
+  /* Force different settings through environment variables */
+  env = getenv("JSIMD_FORCEALTIVEC");
+  if ((env != NULL) && (strcmp(env, "1") == 0))
+    simd_support = JSIMD_ALTIVEC;
+  env = getenv("JSIMD_FORCENONE");
+  if ((env != NULL) && (strcmp(env, "1") == 0))
+    simd_support = 0;
+#endif
+}
+
+GLOBAL(int)
+jsimd_can_rgb_ycc(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+  if ((RGB_PIXELSIZE != 3) && (RGB_PIXELSIZE != 4))
+    return 0;
+
+  if (simd_support & JSIMD_ALTIVEC)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_rgb_gray(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+  if ((RGB_PIXELSIZE != 3) && (RGB_PIXELSIZE != 4))
+    return 0;
+
+  if (simd_support & JSIMD_ALTIVEC)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_ycc_rgb(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+  if ((RGB_PIXELSIZE != 3) && (RGB_PIXELSIZE != 4))
+    return 0;
+
+  if (simd_support & JSIMD_ALTIVEC)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_ycc_rgb565(void)
+{
+  return 0;
+}
+
+GLOBAL(void)
+jsimd_rgb_ycc_convert(j_compress_ptr cinfo, JSAMPARRAY input_buf,
+                      JSAMPIMAGE output_buf, JDIMENSION output_row,
+                      int num_rows)
+{
+  void (*altivecfct) (JDIMENSION, JSAMPARRAY, JSAMPIMAGE, JDIMENSION, int);
+
+  switch (cinfo->in_color_space) {
+  case JCS_EXT_RGB:
+    altivecfct = jsimd_extrgb_ycc_convert_altivec;
+    break;
+  case JCS_EXT_RGBX:
+  case JCS_EXT_RGBA:
+    altivecfct = jsimd_extrgbx_ycc_convert_altivec;
+    break;
+  case JCS_EXT_BGR:
+    altivecfct = jsimd_extbgr_ycc_convert_altivec;
+    break;
+  case JCS_EXT_BGRX:
+  case JCS_EXT_BGRA:
+    altivecfct = jsimd_extbgrx_ycc_convert_altivec;
+    break;
+  case JCS_EXT_XBGR:
+  case JCS_EXT_ABGR:
+    altivecfct = jsimd_extxbgr_ycc_convert_altivec;
+    break;
+  case JCS_EXT_XRGB:
+  case JCS_EXT_ARGB:
+    altivecfct = jsimd_extxrgb_ycc_convert_altivec;
+    break;
+  default:
+    altivecfct = jsimd_rgb_ycc_convert_altivec;
+    break;
+  }
+
+  altivecfct(cinfo->image_width, input_buf, output_buf, output_row, num_rows);
+}
+
+GLOBAL(void)
+jsimd_rgb_gray_convert(j_compress_ptr cinfo, JSAMPARRAY input_buf,
+                       JSAMPIMAGE output_buf, JDIMENSION output_row,
+                       int num_rows)
+{
+  void (*altivecfct) (JDIMENSION, JSAMPARRAY, JSAMPIMAGE, JDIMENSION, int);
+
+  switch (cinfo->in_color_space) {
+  case JCS_EXT_RGB:
+    altivecfct = jsimd_extrgb_gray_convert_altivec;
+    break;
+  case JCS_EXT_RGBX:
+  case JCS_EXT_RGBA:
+    altivecfct = jsimd_extrgbx_gray_convert_altivec;
+    break;
+  case JCS_EXT_BGR:
+    altivecfct = jsimd_extbgr_gray_convert_altivec;
+    break;
+  case JCS_EXT_BGRX:
+  case JCS_EXT_BGRA:
+    altivecfct = jsimd_extbgrx_gray_convert_altivec;
+    break;
+  case JCS_EXT_XBGR:
+  case JCS_EXT_ABGR:
+    altivecfct = jsimd_extxbgr_gray_convert_altivec;
+    break;
+  case JCS_EXT_XRGB:
+  case JCS_EXT_ARGB:
+    altivecfct = jsimd_extxrgb_gray_convert_altivec;
+    break;
+  default:
+    altivecfct = jsimd_rgb_gray_convert_altivec;
+    break;
+  }
+
+  altivecfct(cinfo->image_width, input_buf, output_buf, output_row, num_rows);
+}
+
+GLOBAL(void)
+jsimd_ycc_rgb_convert(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
+                      JDIMENSION input_row, JSAMPARRAY output_buf,
+                      int num_rows)
+{
+  void (*altivecfct) (JDIMENSION, JSAMPIMAGE, JDIMENSION, JSAMPARRAY, int);
+
+  switch (cinfo->out_color_space) {
+  case JCS_EXT_RGB:
+    altivecfct = jsimd_ycc_extrgb_convert_altivec;
+    break;
+  case JCS_EXT_RGBX:
+  case JCS_EXT_RGBA:
+    altivecfct = jsimd_ycc_extrgbx_convert_altivec;
+    break;
+  case JCS_EXT_BGR:
+    altivecfct = jsimd_ycc_extbgr_convert_altivec;
+    break;
+  case JCS_EXT_BGRX:
+  case JCS_EXT_BGRA:
+    altivecfct = jsimd_ycc_extbgrx_convert_altivec;
+    break;
+  case JCS_EXT_XBGR:
+  case JCS_EXT_ABGR:
+    altivecfct = jsimd_ycc_extxbgr_convert_altivec;
+    break;
+  case JCS_EXT_XRGB:
+  case JCS_EXT_ARGB:
+    altivecfct = jsimd_ycc_extxrgb_convert_altivec;
+    break;
+  default:
+    altivecfct = jsimd_ycc_rgb_convert_altivec;
+    break;
+  }
+
+  altivecfct(cinfo->output_width, input_buf, input_row, output_buf, num_rows);
+}
+
+GLOBAL(void)
+jsimd_ycc_rgb565_convert(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
+                         JDIMENSION input_row, JSAMPARRAY output_buf,
+                         int num_rows)
+{
+}
+
+GLOBAL(int)
+jsimd_can_h2v2_downsample(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+
+  if (simd_support & JSIMD_ALTIVEC)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_h2v1_downsample(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+
+  if (simd_support & JSIMD_ALTIVEC)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(void)
+jsimd_h2v2_downsample(j_compress_ptr cinfo, jpeg_component_info *compptr,
+                      JSAMPARRAY input_data, JSAMPARRAY output_data)
+{
+  jsimd_h2v2_downsample_altivec(cinfo->image_width, cinfo->max_v_samp_factor,
+                                compptr->v_samp_factor,
+                                compptr->width_in_blocks, input_data,
+                                output_data);
+}
+
+GLOBAL(void)
+jsimd_h2v1_downsample(j_compress_ptr cinfo, jpeg_component_info *compptr,
+                      JSAMPARRAY input_data, JSAMPARRAY output_data)
+{
+  jsimd_h2v1_downsample_altivec(cinfo->image_width, cinfo->max_v_samp_factor,
+                                compptr->v_samp_factor,
+                                compptr->width_in_blocks, input_data,
+                                output_data);
+}
+
+GLOBAL(int)
+jsimd_can_h2v2_upsample(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+
+  if (simd_support & JSIMD_ALTIVEC)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_h2v1_upsample(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+
+  if (simd_support & JSIMD_ALTIVEC)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(void)
+jsimd_h2v2_upsample(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+                    JSAMPARRAY input_data, JSAMPARRAY *output_data_ptr)
+{
+  jsimd_h2v2_upsample_altivec(cinfo->max_v_samp_factor, cinfo->output_width,
+                              input_data, output_data_ptr);
+}
+
+GLOBAL(void)
+jsimd_h2v1_upsample(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+                    JSAMPARRAY input_data, JSAMPARRAY *output_data_ptr)
+{
+  jsimd_h2v1_upsample_altivec(cinfo->max_v_samp_factor, cinfo->output_width,
+                              input_data, output_data_ptr);
+}
+
+GLOBAL(int)
+jsimd_can_h2v2_fancy_upsample(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+
+  if (simd_support & JSIMD_ALTIVEC)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_h2v1_fancy_upsample(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+
+  if (simd_support & JSIMD_ALTIVEC)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(void)
+jsimd_h2v2_fancy_upsample(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+                          JSAMPARRAY input_data, JSAMPARRAY *output_data_ptr)
+{
+  jsimd_h2v2_fancy_upsample_altivec(cinfo->max_v_samp_factor,
+                                    compptr->downsampled_width, input_data,
+                                    output_data_ptr);
+}
+
+GLOBAL(void)
+jsimd_h2v1_fancy_upsample(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+                          JSAMPARRAY input_data, JSAMPARRAY *output_data_ptr)
+{
+  jsimd_h2v1_fancy_upsample_altivec(cinfo->max_v_samp_factor,
+                                    compptr->downsampled_width, input_data,
+                                    output_data_ptr);
+}
+
+GLOBAL(int)
+jsimd_can_h2v2_merged_upsample(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+
+  if (simd_support & JSIMD_ALTIVEC)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_h2v1_merged_upsample(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+
+  if (simd_support & JSIMD_ALTIVEC)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(void)
+jsimd_h2v2_merged_upsample(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
+                           JDIMENSION in_row_group_ctr, JSAMPARRAY output_buf)
+{
+  void (*altivecfct) (JDIMENSION, JSAMPIMAGE, JDIMENSION, JSAMPARRAY);
+
+  switch (cinfo->out_color_space) {
+  case JCS_EXT_RGB:
+    altivecfct = jsimd_h2v2_extrgb_merged_upsample_altivec;
+    break;
+  case JCS_EXT_RGBX:
+  case JCS_EXT_RGBA:
+    altivecfct = jsimd_h2v2_extrgbx_merged_upsample_altivec;
+    break;
+  case JCS_EXT_BGR:
+    altivecfct = jsimd_h2v2_extbgr_merged_upsample_altivec;
+    break;
+  case JCS_EXT_BGRX:
+  case JCS_EXT_BGRA:
+    altivecfct = jsimd_h2v2_extbgrx_merged_upsample_altivec;
+    break;
+  case JCS_EXT_XBGR:
+  case JCS_EXT_ABGR:
+    altivecfct = jsimd_h2v2_extxbgr_merged_upsample_altivec;
+    break;
+  case JCS_EXT_XRGB:
+  case JCS_EXT_ARGB:
+    altivecfct = jsimd_h2v2_extxrgb_merged_upsample_altivec;
+    break;
+  default:
+    altivecfct = jsimd_h2v2_merged_upsample_altivec;
+    break;
+  }
+
+  altivecfct(cinfo->output_width, input_buf, in_row_group_ctr, output_buf);
+}
+
+GLOBAL(void)
+jsimd_h2v1_merged_upsample(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
+                           JDIMENSION in_row_group_ctr, JSAMPARRAY output_buf)
+{
+  void (*altivecfct) (JDIMENSION, JSAMPIMAGE, JDIMENSION, JSAMPARRAY);
+
+  switch (cinfo->out_color_space) {
+  case JCS_EXT_RGB:
+    altivecfct = jsimd_h2v1_extrgb_merged_upsample_altivec;
+    break;
+  case JCS_EXT_RGBX:
+  case JCS_EXT_RGBA:
+    altivecfct = jsimd_h2v1_extrgbx_merged_upsample_altivec;
+    break;
+  case JCS_EXT_BGR:
+    altivecfct = jsimd_h2v1_extbgr_merged_upsample_altivec;
+    break;
+  case JCS_EXT_BGRX:
+  case JCS_EXT_BGRA:
+    altivecfct = jsimd_h2v1_extbgrx_merged_upsample_altivec;
+    break;
+  case JCS_EXT_XBGR:
+  case JCS_EXT_ABGR:
+    altivecfct = jsimd_h2v1_extxbgr_merged_upsample_altivec;
+    break;
+  case JCS_EXT_XRGB:
+  case JCS_EXT_ARGB:
+    altivecfct = jsimd_h2v1_extxrgb_merged_upsample_altivec;
+    break;
+  default:
+    altivecfct = jsimd_h2v1_merged_upsample_altivec;
+    break;
+  }
+
+  altivecfct(cinfo->output_width, input_buf, in_row_group_ctr, output_buf);
+}
+
+GLOBAL(int)
+jsimd_can_convsamp(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (DCTSIZE != 8)
+    return 0;
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+  if (sizeof(DCTELEM) != 2)
+    return 0;
+
+  if (simd_support & JSIMD_ALTIVEC)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_convsamp_float(void)
+{
+  return 0;
+}
+
+GLOBAL(void)
+jsimd_convsamp(JSAMPARRAY sample_data, JDIMENSION start_col,
+               DCTELEM *workspace)
+{
+  jsimd_convsamp_altivec(sample_data, start_col, workspace);
+}
+
+GLOBAL(void)
+jsimd_convsamp_float(JSAMPARRAY sample_data, JDIMENSION start_col,
+                     FAST_FLOAT *workspace)
+{
+}
+
+GLOBAL(int)
+jsimd_can_fdct_islow(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (DCTSIZE != 8)
+    return 0;
+  if (sizeof(DCTELEM) != 2)
+    return 0;
+
+  if (simd_support & JSIMD_ALTIVEC)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_fdct_ifast(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (DCTSIZE != 8)
+    return 0;
+  if (sizeof(DCTELEM) != 2)
+    return 0;
+
+  if (simd_support & JSIMD_ALTIVEC)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_fdct_float(void)
+{
+  return 0;
+}
+
+GLOBAL(void)
+jsimd_fdct_islow(DCTELEM *data)
+{
+  jsimd_fdct_islow_altivec(data);
+}
+
+GLOBAL(void)
+jsimd_fdct_ifast(DCTELEM *data)
+{
+  jsimd_fdct_ifast_altivec(data);
+}
+
+GLOBAL(void)
+jsimd_fdct_float(FAST_FLOAT *data)
+{
+}
+
+GLOBAL(int)
+jsimd_can_quantize(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (DCTSIZE != 8)
+    return 0;
+  if (sizeof(JCOEF) != 2)
+    return 0;
+  if (sizeof(DCTELEM) != 2)
+    return 0;
+
+  if (simd_support & JSIMD_ALTIVEC)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_quantize_float(void)
+{
+  return 0;
+}
+
+GLOBAL(void)
+jsimd_quantize(JCOEFPTR coef_block, DCTELEM *divisors, DCTELEM *workspace)
+{
+  jsimd_quantize_altivec(coef_block, divisors, workspace);
+}
+
+GLOBAL(void)
+jsimd_quantize_float(JCOEFPTR coef_block, FAST_FLOAT *divisors,
+                     FAST_FLOAT *workspace)
+{
+}
+
+GLOBAL(int)
+jsimd_can_idct_2x2(void)
+{
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_idct_4x4(void)
+{
+  return 0;
+}
+
+GLOBAL(void)
+jsimd_idct_2x2(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+               JCOEFPTR coef_block, JSAMPARRAY output_buf,
+               JDIMENSION output_col)
+{
+}
+
+GLOBAL(void)
+jsimd_idct_4x4(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+               JCOEFPTR coef_block, JSAMPARRAY output_buf,
+               JDIMENSION output_col)
+{
+}
+
+GLOBAL(int)
+jsimd_can_idct_islow(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (DCTSIZE != 8)
+    return 0;
+  if (sizeof(JCOEF) != 2)
+    return 0;
+
+  if (simd_support & JSIMD_ALTIVEC)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_idct_ifast(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (DCTSIZE != 8)
+    return 0;
+  if (sizeof(JCOEF) != 2)
+    return 0;
+
+  if (simd_support & JSIMD_ALTIVEC)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_idct_float(void)
+{
+  return 0;
+}
+
+GLOBAL(void)
+jsimd_idct_islow(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+                 JCOEFPTR coef_block, JSAMPARRAY output_buf,
+                 JDIMENSION output_col)
+{
+  jsimd_idct_islow_altivec(compptr->dct_table, coef_block, output_buf,
+                           output_col);
+}
+
+GLOBAL(void)
+jsimd_idct_ifast(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+                 JCOEFPTR coef_block, JSAMPARRAY output_buf,
+                 JDIMENSION output_col)
+{
+  jsimd_idct_ifast_altivec(compptr->dct_table, coef_block, output_buf,
+                           output_col);
+}
+
+GLOBAL(void)
+jsimd_idct_float(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+                 JCOEFPTR coef_block, JSAMPARRAY output_buf,
+                 JDIMENSION output_col)
+{
+}
+
+GLOBAL(int)
+jsimd_can_huff_encode_one_block(void)
+{
+  return 0;
+}
+
+GLOBAL(JOCTET *)
+jsimd_huff_encode_one_block(void *state, JOCTET *buffer, JCOEFPTR block,
+                            int last_dc_val, c_derived_tbl *dctbl,
+                            c_derived_tbl *actbl)
+{
+  return NULL;
+}
+
+GLOBAL(int)
+jsimd_can_encode_mcu_AC_first_prepare(void)
+{
+  return 0;
+}
+
+GLOBAL(void)
+jsimd_encode_mcu_AC_first_prepare(const JCOEF *block,
+                                  const int *jpeg_natural_order_start, int Sl,
+                                  int Al, JCOEF *values, size_t *zerobits)
+{
+}
+
+GLOBAL(int)
+jsimd_can_encode_mcu_AC_refine_prepare(void)
+{
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_encode_mcu_AC_refine_prepare(const JCOEF *block,
+                                   const int *jpeg_natural_order_start, int Sl,
+                                   int Al, JCOEF *absvalues, size_t *bits)
+{
+  return 0;
+}
diff --git a/3rdparty/libjpeg/src/simd/powerpc/jsimd_altivec.h b/3rdparty/libjpeg/src/simd/powerpc/jsimd_altivec.h
new file mode 100644
index 00000000..e8bdb06a
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/powerpc/jsimd_altivec.h
@@ -0,0 +1,98 @@
+/*
+ * AltiVec optimizations for libjpeg-turbo
+ *
+ * Copyright (C) 2014-2015, D. R. Commander.  All Rights Reserved.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+#define JPEG_INTERNALS
+#include "../../jinclude.h"
+#include "../../jpeglib.h"
+#include "../../jsimd.h"
+#include "../../jdct.h"
+#include "../../jsimddct.h"
+#include "../jsimd.h"
+#include <altivec.h>
+
+
+/* Common code */
+
+#define __4X(a)      a, a, a, a
+#define __4X2(a, b)  a, b, a, b, a, b, a, b
+#define __8X(a)      __4X(a), __4X(a)
+#define __16X(a)     __8X(a), __8X(a)
+
+#define TRANSPOSE(row, col) { \
+  __vector short row04l, row04h, row15l, row15h, \
+                 row26l, row26h, row37l, row37h; \
+  __vector short col01e, col01o, col23e, col23o, \
+                 col45e, col45o, col67e, col67o; \
+  \
+                                       /* transpose coefficients (phase 1) */ \
+  row04l = vec_mergeh(row##0, row##4); /* row04l=(00 40 01 41 02 42 03 43) */ \
+  row04h = vec_mergel(row##0, row##4); /* row04h=(04 44 05 45 06 46 07 47) */ \
+  row15l = vec_mergeh(row##1, row##5); /* row15l=(10 50 11 51 12 52 13 53) */ \
+  row15h = vec_mergel(row##1, row##5); /* row15h=(14 54 15 55 16 56 17 57) */ \
+  row26l = vec_mergeh(row##2, row##6); /* row26l=(20 60 21 61 22 62 23 63) */ \
+  row26h = vec_mergel(row##2, row##6); /* row26h=(24 64 25 65 26 66 27 67) */ \
+  row37l = vec_mergeh(row##3, row##7); /* row37l=(30 70 31 71 32 72 33 73) */ \
+  row37h = vec_mergel(row##3, row##7); /* row37h=(34 74 35 75 36 76 37 77) */ \
+  \
+                                       /* transpose coefficients (phase 2) */ \
+  col01e = vec_mergeh(row04l, row26l); /* col01e=(00 20 40 60 01 21 41 61) */ \
+  col23e = vec_mergel(row04l, row26l); /* col23e=(02 22 42 62 03 23 43 63) */ \
+  col45e = vec_mergeh(row04h, row26h); /* col45e=(04 24 44 64 05 25 45 65) */ \
+  col67e = vec_mergel(row04h, row26h); /* col67e=(06 26 46 66 07 27 47 67) */ \
+  col01o = vec_mergeh(row15l, row37l); /* col01o=(10 30 50 70 11 31 51 71) */ \
+  col23o = vec_mergel(row15l, row37l); /* col23o=(12 32 52 72 13 33 53 73) */ \
+  col45o = vec_mergeh(row15h, row37h); /* col45o=(14 34 54 74 15 35 55 75) */ \
+  col67o = vec_mergel(row15h, row37h); /* col67o=(16 36 56 76 17 37 57 77) */ \
+  \
+                                       /* transpose coefficients (phase 3) */ \
+  col##0 = vec_mergeh(col01e, col01o); /* col0=(00 10 20 30 40 50 60 70) */ \
+  col##1 = vec_mergel(col01e, col01o); /* col1=(01 11 21 31 41 51 61 71) */ \
+  col##2 = vec_mergeh(col23e, col23o); /* col2=(02 12 22 32 42 52 62 72) */ \
+  col##3 = vec_mergel(col23e, col23o); /* col3=(03 13 23 33 43 53 63 73) */ \
+  col##4 = vec_mergeh(col45e, col45o); /* col4=(04 14 24 34 44 54 64 74) */ \
+  col##5 = vec_mergel(col45e, col45o); /* col5=(05 15 25 35 45 55 65 75) */ \
+  col##6 = vec_mergeh(col67e, col67o); /* col6=(06 16 26 36 46 56 66 76) */ \
+  col##7 = vec_mergel(col67e, col67o); /* col7=(07 17 27 37 47 57 67 77) */ \
+}
+
+#ifndef min
+#define min(a, b)  ((a) < (b) ? (a) : (b))
+#endif
+
+
+/* Macros to abstract big/little endian bit twiddling */
+
+#if __BIG_ENDIAN__
+
+#define VEC_LD(a, b)     vec_ld(a, b)
+#define VEC_ST(a, b, c)  vec_st(a, b, c)
+#define VEC_UNPACKHU(a)  vec_mergeh(pb_zero, a)
+#define VEC_UNPACKLU(a)  vec_mergel(pb_zero, a)
+
+#else
+
+#define VEC_LD(a, b)     vec_vsx_ld(a, b)
+#define VEC_ST(a, b, c)  vec_vsx_st(a, b, c)
+#define VEC_UNPACKHU(a)  vec_mergeh(a, pb_zero)
+#define VEC_UNPACKLU(a)  vec_mergel(a, pb_zero)
+
+#endif
diff --git a/3rdparty/libjpeg/src/simd/x86_64/jccolext-avx2.asm b/3rdparty/libjpeg/src/simd/x86_64/jccolext-avx2.asm
new file mode 100644
index 00000000..ffb527db
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/x86_64/jccolext-avx2.asm
@@ -0,0 +1,559 @@
+;
+; jccolext.asm - colorspace conversion (64-bit AVX2)
+;
+; Copyright (C) 2009, 2016, D. R. Commander.
+; Copyright (C) 2015, Intel Corporation.
+; Copyright (C) 2018, Matthias Räncker.
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+;
+; This file should be assembled with NASM (Netwide Assembler),
+; can *not* be assembled with Microsoft's MASM or any compatible
+; assembler (including Borland's Turbo Assembler).
+; NASM is available from http://nasm.sourceforge.net/ or
+; http://sourceforge.net/project/showfiles.php?group_id=6208
+
+%include "jcolsamp.inc"
+
+; --------------------------------------------------------------------------
+;
+; Convert some rows of samples to the output colorspace.
+;
+; GLOBAL(void)
+; jsimd_rgb_ycc_convert_avx2(JDIMENSION img_width, JSAMPARRAY input_buf,
+;                            JSAMPIMAGE output_buf, JDIMENSION output_row,
+;                            int num_rows);
+;
+
+; r10d = JDIMENSION img_width
+; r11 = JSAMPARRAY input_buf
+; r12 = JSAMPIMAGE output_buf
+; r13d = JDIMENSION output_row
+; r14d = int num_rows
+
+%define wk(i)   rbp - (WK_NUM - (i)) * SIZEOF_YMMWORD  ; ymmword wk[WK_NUM]
+%define WK_NUM  8
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_rgb_ycc_convert_avx2)
+
+EXTN(jsimd_rgb_ycc_convert_avx2):
+    push        rbp
+    mov         rax, rsp                     ; rax = original rbp
+    sub         rsp, byte 4
+    and         rsp, byte (-SIZEOF_YMMWORD)  ; align to 256 bits
+    mov         [rsp], rax
+    mov         rbp, rsp                     ; rbp = aligned rbp
+    lea         rsp, [wk(0)]
+    collect_args 5
+    push        rbx
+
+    mov         ecx, r10d
+    test        rcx, rcx
+    jz          near .return
+
+    push        rcx
+
+    mov         rsi, r12
+    mov         ecx, r13d
+    mov         rdip, JSAMPARRAY [rsi+0*SIZEOF_JSAMPARRAY]
+    mov         rbxp, JSAMPARRAY [rsi+1*SIZEOF_JSAMPARRAY]
+    mov         rdxp, JSAMPARRAY [rsi+2*SIZEOF_JSAMPARRAY]
+    lea         rdi, [rdi+rcx*SIZEOF_JSAMPROW]
+    lea         rbx, [rbx+rcx*SIZEOF_JSAMPROW]
+    lea         rdx, [rdx+rcx*SIZEOF_JSAMPROW]
+
+    pop         rcx
+
+    mov         rsi, r11
+    mov         eax, r14d
+    test        rax, rax
+    jle         near .return
+.rowloop:
+    push        rdx
+    push        rbx
+    push        rdi
+    push        rsi
+    push        rcx                     ; col
+
+    mov         rsip, JSAMPROW [rsi]    ; inptr
+    mov         rdip, JSAMPROW [rdi]    ; outptr0
+    mov         rbxp, JSAMPROW [rbx]    ; outptr1
+    mov         rdxp, JSAMPROW [rdx]    ; outptr2
+
+    cmp         rcx, byte SIZEOF_YMMWORD
+    jae         near .columnloop
+
+%if RGB_PIXELSIZE == 3  ; ---------------
+
+.column_ld1:
+    push        rax
+    push        rdx
+    lea         rcx, [rcx+rcx*2]        ; imul ecx,RGB_PIXELSIZE
+    test        cl, SIZEOF_BYTE
+    jz          short .column_ld2
+    sub         rcx, byte SIZEOF_BYTE
+    movzx       rax, byte [rsi+rcx]
+.column_ld2:
+    test        cl, SIZEOF_WORD
+    jz          short .column_ld4
+    sub         rcx, byte SIZEOF_WORD
+    movzx       rdx, word [rsi+rcx]
+    shl         rax, WORD_BIT
+    or          rax, rdx
+.column_ld4:
+    vmovd       xmmA, eax
+    pop         rdx
+    pop         rax
+    test        cl, SIZEOF_DWORD
+    jz          short .column_ld8
+    sub         rcx, byte SIZEOF_DWORD
+    vmovd       xmmF, XMM_DWORD [rsi+rcx]
+    vpslldq     xmmA, xmmA, SIZEOF_DWORD
+    vpor        xmmA, xmmA, xmmF
+.column_ld8:
+    test        cl, SIZEOF_MMWORD
+    jz          short .column_ld16
+    sub         rcx, byte SIZEOF_MMWORD
+    vmovq       xmmB, XMM_MMWORD [rsi+rcx]
+    vpslldq     xmmA, xmmA, SIZEOF_MMWORD
+    vpor        xmmA, xmmA, xmmB
+.column_ld16:
+    test        cl, SIZEOF_XMMWORD
+    jz          short .column_ld32
+    sub         rcx, byte SIZEOF_XMMWORD
+    vmovdqu     xmmB, XMM_MMWORD [rsi+rcx]
+    vperm2i128  ymmA, ymmA, ymmA, 1
+    vpor        ymmA, ymmB
+.column_ld32:
+    test        cl, SIZEOF_YMMWORD
+    jz          short .column_ld64
+    sub         rcx, byte SIZEOF_YMMWORD
+    vmovdqa     ymmF, ymmA
+    vmovdqu     ymmA, YMMWORD [rsi+0*SIZEOF_YMMWORD]
+.column_ld64:
+    test        cl, 2*SIZEOF_YMMWORD
+    mov         rcx, SIZEOF_YMMWORD
+    jz          short .rgb_ycc_cnv
+    vmovdqa     ymmB, ymmA
+    vmovdqu     ymmA, YMMWORD [rsi+0*SIZEOF_YMMWORD]
+    vmovdqu     ymmF, YMMWORD [rsi+1*SIZEOF_YMMWORD]
+    jmp         short .rgb_ycc_cnv
+
+.columnloop:
+    vmovdqu     ymmA, YMMWORD [rsi+0*SIZEOF_YMMWORD]
+    vmovdqu     ymmF, YMMWORD [rsi+1*SIZEOF_YMMWORD]
+    vmovdqu     ymmB, YMMWORD [rsi+2*SIZEOF_YMMWORD]
+
+.rgb_ycc_cnv:
+    ; ymmA=(00 10 20 01 11 21 02 12 22 03 13 23 04 14 24 05
+    ;       15 25 06 16 26 07 17 27 08 18 28 09 19 29 0A 1A)
+    ; ymmF=(2A 0B 1B 2B 0C 1C 2C 0D 1D 2D 0E 1E 2E 0F 1F 2F
+    ;       0G 1G 2G 0H 1H 2H 0I 1I 2I 0J 1J 2J 0K 1K 2K 0L)
+    ; ymmB=(1L 2L 0M 1M 2M 0N 1N 2N 0O 1O 2O 0P 1P 2P 0Q 1Q
+    ;       2Q 0R 1R 2R 0S 1S 2S 0T 1T 2T 0U 1U 2U 0V 1V 2V)
+
+    vmovdqu     ymmC, ymmA
+    vinserti128 ymmA, ymmF, xmmA, 0  ; ymmA=(00 10 20 01 11 21 02 12 22 03 13 23 04 14 24 05
+                                     ;       0G 1G 2G 0H 1H 2H 0I 1I 2I 0J 1J 2J 0K 1K 2K 0L)
+    vinserti128 ymmC, ymmC, xmmB, 0  ; ymmC=(1L 2L 0M 1M 2M 0N 1N 2N 0O 1O 2O 0P 1P 2P 0Q 1Q
+                                     ;       15 25 06 16 26 07 17 27 08 18 28 09 19 29 0A 1A)
+    vinserti128 ymmB, ymmB, xmmF, 0  ; ymmB=(2A 0B 1B 2B 0C 1C 2C 0D 1D 2D 0E 1E 2E 0F 1F 2F
+                                     ;       2Q 0R 1R 2R 0S 1S 2S 0T 1T 2T 0U 1U 2U 0V 1V 2V)
+    vperm2i128  ymmF, ymmC, ymmC, 1  ; ymmF=(15 25 06 16 26 07 17 27 08 18 28 09 19 29 0A 1A
+                                     ;       1L 2L 0M 1M 2M 0N 1N 2N 0O 1O 2O 0P 1P 2P 0Q 1Q)
+
+    vmovdqa     ymmG, ymmA
+    vpslldq     ymmA, ymmA, 8     ; ymmA=(-- -- -- -- -- -- -- -- 00 10 20 01 11 21 02 12
+                                  ;       22 03 13 23 04 14 24 05 0G 1G 2G 0H 1H 2H 0I 1I)
+    vpsrldq     ymmG, ymmG, 8     ; ymmG=(22 03 13 23 04 14 24 05 0G 1G 2G 0H 1H 2H 0I 1I
+                                  ;       2I 0J 1J 2J 0K 1K 2K 0L -- -- -- -- -- -- -- --)
+
+    vpunpckhbw  ymmA, ymmA, ymmF  ; ymmA=(00 08 10 18 20 28 01 09 11 19 21 29 02 0A 12 1A
+                                  ;       0G 0O 1G 1O 2G 2O 0H 0P 1H 1P 2H 2P 0I 0Q 1I 1Q)
+    vpslldq     ymmF, ymmF, 8     ; ymmF=(-- -- -- -- -- -- -- -- 15 25 06 16 26 07 17 27
+                                  ;       08 18 28 09 19 29 0A 1A 1L 2L 0M 1M 2M 0N 1N 2N)
+
+    vpunpcklbw  ymmG, ymmG, ymmB  ; ymmG=(22 2A 03 0B 13 1B 23 2B 04 0C 14 1C 24 2C 05 0D
+                                  ;       2I 2Q 0J 0R 1J 1R 2J 2R 0K 0S 1K 1S 2K 2S 0L 0T)
+    vpunpckhbw  ymmF, ymmF, ymmB  ; ymmF=(15 1D 25 2D 06 0E 16 1E 26 2E 07 0F 17 1F 27 2F
+                                  ;       1L 1T 2L 2T 0M 0U 1M 1U 2M 2U 0N 0V 1N 1V 2N 2V)
+
+    vmovdqa     ymmD, ymmA
+    vpslldq     ymmA, ymmA, 8     ; ymmA=(-- -- -- -- -- -- -- -- 00 08 10 18 20 28 01 09
+                                  ;       11 19 21 29 02 0A 12 1A 0G 0O 1G 1O 2G 2O 0H 0P)
+    vpsrldq     ymmD, ymmD, 8     ; ymmD=(11 19 21 29 02 0A 12 1A 0G 0O 1G 1O 2G 2O 0H 0P
+                                  ;       1H 1P 2H 2P 0I 0Q 1I 1Q -- -- -- -- -- -- -- --)
+
+    vpunpckhbw  ymmA, ymmA, ymmG  ; ymmA=(00 04 08 0C 10 14 18 1C 20 24 28 2C 01 05 09 0D
+                                  ;       0G 0K 0O 0S 1G 1K 1O 1S 2G 2K 2O 2S 0H 0L 0P 0T)
+    vpslldq     ymmG, ymmG, 8     ; ymmG=(-- -- -- -- -- -- -- -- 22 2A 03 0B 13 1B 23 2B
+                                  ;       04 0C 14 1C 24 2C 05 0D 2I 2Q 0J 0R 1J 1R 2J 2R)
+
+    vpunpcklbw  ymmD, ymmD, ymmF  ; ymmD=(11 15 19 1D 21 25 29 2D 02 06 0A 0E 12 16 1A 1E
+                                  ;       1H 1L 1P 1T 2H 2L 2P 2T 0I 0M 0Q 0U 1I 1M 1Q 1U)
+    vpunpckhbw  ymmG, ymmG, ymmF  ; ymmG=(22 26 2A 2E 03 07 0B 0F 13 17 1B 1F 23 27 2B 2F
+                                  ;       2I 2M 2Q 2U 0J 0N 0R 0V 1J 1N 1R 1V 2J 2N 2R 2V)
+
+    vmovdqa     ymmE, ymmA
+    vpslldq     ymmA, ymmA, 8     ; ymmA=(-- -- -- -- -- -- -- -- 00 04 08 0C 10 14 18 1C
+                                  ;       20 24 28 2C 01 05 09 0D 0G 0K 0O 0S 1G 1K 1O 1S)
+    vpsrldq     ymmE, ymmE, 8     ; ymmE=(20 24 28 2C 01 05 09 0D 0G 0K 0O 0S 1G 1K 1O 1S
+                                  ;       2G 2K 2O 2S 0H 0L 0P 0T -- -- -- -- -- -- -- --)
+
+    vpunpckhbw  ymmA, ymmA, ymmD  ; ymmA=(00 02 04 06 08 0A 0C 0E 10 12 14 16 18 1A 1C 1E
+                                  ;       0G 0I 0K 0M 0O 0Q 0S 0U 1G 1I 1K 1M 1O 1Q 1S 1U)
+    vpslldq     ymmD, ymmD, 8     ; ymmD=(-- -- -- -- -- -- -- -- 11 15 19 1D 21 25 29 2D
+                                  ;       02 06 0A 0E 12 16 1A 1E 1H 1L 1P 1T 2H 2L 2P 2T)
+
+    vpunpcklbw  ymmE, ymmE, ymmG  ; ymmE=(20 22 24 26 28 2A 2C 2E 01 03 05 07 09 0B 0D 0F
+                                  ;       2G 2I 2K 2M 2O 2Q 2S 2U 0H 0J 0L 0N 0P 0R 0T 0V)
+    vpunpckhbw  ymmD, ymmD, ymmG  ; ymmD=(11 13 15 17 19 1B 1D 1F 21 23 25 27 29 2B 2D 2F
+                                  ;       1H 1J 1L 1N 1P 1R 1T 1V 2H 2J 2L 2N 2P 2R 2T 2V)
+
+    vpxor       ymmH, ymmH, ymmH
+
+    vmovdqa     ymmC, ymmA
+    vpunpcklbw  ymmA, ymmA, ymmH  ; ymmA=(00 02 04 06 08 0A 0C 0E 0G 0I 0K 0M 0O 0Q 0S 0U)
+    vpunpckhbw  ymmC, ymmC, ymmH  ; ymmC=(10 12 14 16 18 1A 1C 1E 1G 1I 1K 1M 1O 1Q 1S 1U)
+
+    vmovdqa     ymmB, ymmE
+    vpunpcklbw  ymmE, ymmE, ymmH  ; ymmE=(20 22 24 26 28 2A 2C 2E 2G 2I 2K 2M 2O 2Q 2S 2U)
+    vpunpckhbw  ymmB, ymmB, ymmH  ; ymmB=(01 03 05 07 09 0B 0D 0F 0H 0J 0L 0N 0P 0R 0T 0V)
+
+    vmovdqa     ymmF, ymmD
+    vpunpcklbw  ymmD, ymmD, ymmH  ; ymmD=(11 13 15 17 19 1B 1D 1F 1H 1J 1L 1N 1P 1R 1T 1V)
+    vpunpckhbw  ymmF, ymmF, ymmH  ; ymmF=(21 23 25 27 29 2B 2D 2F 2H 2J 2L 2N 2P 2R 2T 2V)
+
+%else  ; RGB_PIXELSIZE == 4 ; -----------
+
+.column_ld1:
+    test        cl, SIZEOF_XMMWORD/16
+    jz          short .column_ld2
+    sub         rcx, byte SIZEOF_XMMWORD/16
+    vmovd       xmmA, XMM_DWORD [rsi+rcx*RGB_PIXELSIZE]
+.column_ld2:
+    test        cl, SIZEOF_XMMWORD/8
+    jz          short .column_ld4
+    sub         rcx, byte SIZEOF_XMMWORD/8
+    vmovq       xmmF, XMM_MMWORD [rsi+rcx*RGB_PIXELSIZE]
+    vpslldq     xmmA, xmmA, SIZEOF_MMWORD
+    vpor        xmmA, xmmA, xmmF
+.column_ld4:
+    test        cl, SIZEOF_XMMWORD/4
+    jz          short .column_ld8
+    sub         rcx, byte SIZEOF_XMMWORD/4
+    vmovdqa     xmmF, xmmA
+    vperm2i128  ymmF, ymmF, ymmF, 1
+    vmovdqu     xmmA, XMMWORD [rsi+rcx*RGB_PIXELSIZE]
+    vpor        ymmA, ymmA, ymmF
+.column_ld8:
+    test        cl, SIZEOF_XMMWORD/2
+    jz          short .column_ld16
+    sub         rcx, byte SIZEOF_XMMWORD/2
+    vmovdqa     ymmF, ymmA
+    vmovdqu     ymmA, YMMWORD [rsi+rcx*RGB_PIXELSIZE]
+.column_ld16:
+    test        cl, SIZEOF_XMMWORD
+    mov         rcx, SIZEOF_YMMWORD
+    jz          short .rgb_ycc_cnv
+    vmovdqa     ymmE, ymmA
+    vmovdqa     ymmH, ymmF
+    vmovdqu     ymmA, YMMWORD [rsi+0*SIZEOF_YMMWORD]
+    vmovdqu     ymmF, YMMWORD [rsi+1*SIZEOF_YMMWORD]
+    jmp         short .rgb_ycc_cnv
+
+.columnloop:
+    vmovdqu     ymmA, YMMWORD [rsi+0*SIZEOF_YMMWORD]
+    vmovdqu     ymmF, YMMWORD [rsi+1*SIZEOF_YMMWORD]
+    vmovdqu     ymmE, YMMWORD [rsi+2*SIZEOF_YMMWORD]
+    vmovdqu     ymmH, YMMWORD [rsi+3*SIZEOF_YMMWORD]
+
+.rgb_ycc_cnv:
+    ; ymmA=(00 10 20 30 01 11 21 31 02 12 22 32 03 13 23 33
+    ;       04 14 24 34 05 15 25 35 06 16 26 36 07 17 27 37)
+    ; ymmF=(08 18 28 38 09 19 29 39 0A 1A 2A 3A 0B 1B 2B 3B
+    ;       0C 1C 2C 3C 0D 1D 2D 3D 0E 1E 2E 3E 0F 1F 2F 3F)
+    ; ymmE=(0G 1G 2G 3G 0H 1H 2H 3H 0I 1I 2I 3I 0J 1J 2J 3J
+    ;       0K 1K 2K 3K 0L 1L 2L 3L 0M 1M 2M 3M 0N 1N 2N 3N)
+    ; ymmH=(0O 1O 2O 3O 0P 1P 2P 3P 0Q 1Q 2Q 3Q 0R 1R 2R 3R
+    ;       0S 1S 2S 3S 0T 1T 2T 3T 0U 1U 2U 3U 0V 1V 2V 3V)
+
+    vmovdqa     ymmB, ymmA
+    vinserti128 ymmA, ymmA, xmmE, 1     ; ymmA=(00 10 20 30 01 11 21 31 02 12 22 32 03 13 23 33
+                                        ;       0G 1G 2G 3G 0H 1H 2H 3H 0I 1I 2I 3I 0J 1J 2J 3J)
+    vperm2i128  ymmE, ymmB, ymmE, 0x31  ; ymmE=(04 14 24 34 05 15 25 35 06 16 26 36 07 17 27 37
+                                        ;       0K 1K 2K 3K 0L 1L 2L 3L 0M 1M 2M 3M 0N 1N 2N 3N)
+
+    vmovdqa     ymmB, ymmF
+    vinserti128 ymmF, ymmF, xmmH, 1     ; ymmF=(08 18 28 38 09 19 29 39 0A 1A 2A 3A 0B 1B 2B 3B
+                                        ;       0O 1O 2O 3O 0P 1P 2P 3P 0Q 1Q 2Q 3Q 0R 1R 2R 3R)
+    vperm2i128  ymmH, ymmB, ymmH, 0x31  ; ymmH=(0C 1C 2C 3C 0D 1D 2D 3D 0E 1E 2E 3E 0F 1F 2F 3F
+                                        ;       0S 1S 2S 3S 0T 1T 2T 3T 0U 1U 2U 3U 0V 1V 2V 3V)
+
+    vmovdqa     ymmD, ymmA
+    vpunpcklbw  ymmA, ymmA, ymmE      ; ymmA=(00 04 10 14 20 24 30 34 01 05 11 15 21 25 31 35
+                                      ;       0G 0K 1G 1K 2G 2K 3G 3K 0H 0L 1H 1L 2H 2L 3H 3L)
+    vpunpckhbw  ymmD, ymmD, ymmE      ; ymmD=(02 06 12 16 22 26 32 36 03 07 13 17 23 27 33 37
+                                      ;       0I 0M 1I 1M 2I 2M 3I 3M 0J 0N 1J 1N 2J 2N 3J 3N)
+
+    vmovdqa     ymmC, ymmF
+    vpunpcklbw  ymmF, ymmF, ymmH      ; ymmF=(08 0C 18 1C 28 2C 38 3C 09 0D 19 1D 29 2D 39 3D
+                                      ;       0O 0S 1O 1S 2O 2S 3O 3S 0P 0T 1P 1T 2P 2T 3P 3T)
+    vpunpckhbw  ymmC, ymmC, ymmH      ; ymmC=(0A 0E 1A 1E 2A 2E 3A 3E 0B 0F 1B 1F 2B 2F 3B 3F
+                                      ;       0Q 0U 1Q 1U 2Q 2U 3Q 3U 0R 0V 1R 1V 2R 2V 3R 3V)
+
+    vmovdqa     ymmB, ymmA
+    vpunpcklwd  ymmA, ymmA, ymmF      ; ymmA=(00 04 08 0C 10 14 18 1C 20 24 28 2C 30 34 38 3C
+                                      ;       0G 0K 0O 0S 1G 1K 1O 1S 2G 2K 2O 2S 3G 3K 3O 3S)
+    vpunpckhwd  ymmB, ymmB, ymmF      ; ymmB=(01 05 09 0D 11 15 19 1D 21 25 29 2D 31 35 39 3D
+                                      ;       0H 0L 0P 0T 1H 1L 1P 1T 2H 2L 2P 2T 3H 3L 3P 3T)
+
+    vmovdqa     ymmG, ymmD
+    vpunpcklwd  ymmD, ymmD, ymmC      ; ymmD=(02 06 0A 0E 12 16 1A 1E 22 26 2A 2E 32 36 3A 3E
+                                      ;       0I 0M 0Q 0U 1I 1M 1Q 1U 2I 2M 2Q 2U 3I 3M 3Q 3U)
+    vpunpckhwd  ymmG, ymmG, ymmC      ; ymmG=(03 07 0B 0F 13 17 1B 1F 23 27 2B 2F 33 37 3B 3F
+                                      ;       0J 0N 0R 0V 1J 1N 1R 1V 2J 2N 2R 2V 3J 3N 3R 3V)
+
+    vmovdqa     ymmE, ymmA
+    vpunpcklbw  ymmA, ymmA, ymmD      ; ymmA=(00 02 04 06 08 0A 0C 0E 10 12 14 16 18 1A 1C 1E
+                                      ;       0G 0I 0K 0M 0O 0Q 0S 0U 1G 1I 1K 1M 1O 1Q 1S 1U)
+    vpunpckhbw  ymmE, ymmE, ymmD      ; ymmE=(20 22 24 26 28 2A 2C 2E 30 32 34 36 38 3A 3C 3E
+                                      ;       2G 2I 2K 2M 2O 2Q 2S 2U 3G 3I 3K 3M 3O 3Q 3S 3U)
+
+    vmovdqa     ymmH, ymmB
+    vpunpcklbw  ymmB, ymmB, ymmG      ; ymmB=(01 03 05 07 09 0B 0D 0F 11 13 15 17 19 1B 1D 1F
+                                      ;       0H 0J 0L 0N 0P 0R 0T 0V 1H 1J 1L 1N 1P 1R 1T 1V)
+    vpunpckhbw  ymmH, ymmH, ymmG      ; ymmH=(21 23 25 27 29 2B 2D 2F 31 33 35 37 39 3B 3D 3F
+                                      ;       2H 2J 2L 2N 2P 2R 2T 2V 3H 3J 3L 3N 3P 3R 3T 3V)
+
+    vpxor       ymmF, ymmF, ymmF
+
+    vmovdqa     ymmC, ymmA
+    vpunpcklbw  ymmA, ymmA, ymmF      ; ymmA=(00 02 04 06 08 0A 0C 0E 0G 0I 0K 0M 0O 0Q 0S 0U)
+    vpunpckhbw  ymmC, ymmC, ymmF      ; ymmC=(10 12 14 16 18 1A 1C 1E 1G 1I 1K 1M 1O 1Q 1S 1U)
+
+    vmovdqa     ymmD, ymmB
+    vpunpcklbw  ymmB, ymmB, ymmF      ; ymmB=(01 03 05 07 09 0B 0D 0F 0H 0J 0L 0N 0P 0R 0T 0V)
+    vpunpckhbw  ymmD, ymmD, ymmF      ; ymmD=(11 13 15 17 19 1B 1D 1F 1H 1J 1L 1N 1P 1R 1T 1V)
+
+    vmovdqa     ymmG, ymmE
+    vpunpcklbw  ymmE, ymmE, ymmF      ; ymmE=(20 22 24 26 28 2A 2C 2E 2G 2I 2K 2M 2O 2Q 2S 2U)
+    vpunpckhbw  ymmG, ymmG, ymmF      ; ymmG=(30 32 34 36 38 3A 3C 3E 3G 3I 3K 3M 3O 3Q 3S 3U)
+
+    vpunpcklbw  ymmF, ymmF, ymmH
+    vpunpckhbw  ymmH, ymmH, ymmH
+    vpsrlw      ymmF, ymmF, BYTE_BIT  ; ymmF=(21 23 25 27 29 2B 2D 2F 2H 2J 2L 2N 2P 2R 2T 2V)
+    vpsrlw      ymmH, ymmH, BYTE_BIT  ; ymmH=(31 33 35 37 39 3B 3D 3F 3H 3J 3L 3N 3P 3R 3T 3V)
+
+%endif  ; RGB_PIXELSIZE ; ---------------
+
+    ; ymm0=R(02468ACEGIKMOQSU)=RE, ymm2=G(02468ACEGIKMOQSU)=GE, ymm4=B(02468ACEGIKMOQSU)=BE
+    ; ymm1=R(13579BDFHJLNPRTV)=RO, ymm3=G(13579BDFHJLNPRTV)=GO, ymm5=B(13579BDFHJLNPRTV)=BO
+
+    ; (Original)
+    ; Y  =  0.29900 * R + 0.58700 * G + 0.11400 * B
+    ; Cb = -0.16874 * R - 0.33126 * G + 0.50000 * B + CENTERJSAMPLE
+    ; Cr =  0.50000 * R - 0.41869 * G - 0.08131 * B + CENTERJSAMPLE
+    ;
+    ; (This implementation)
+    ; Y  =  0.29900 * R + 0.33700 * G + 0.11400 * B + 0.25000 * G
+    ; Cb = -0.16874 * R - 0.33126 * G + 0.50000 * B + CENTERJSAMPLE
+    ; Cr =  0.50000 * R - 0.41869 * G - 0.08131 * B + CENTERJSAMPLE
+
+    vmovdqa     YMMWORD [wk(0)], ymm0   ; wk(0)=RE
+    vmovdqa     YMMWORD [wk(1)], ymm1   ; wk(1)=RO
+    vmovdqa     YMMWORD [wk(2)], ymm4   ; wk(2)=BE
+    vmovdqa     YMMWORD [wk(3)], ymm5   ; wk(3)=BO
+
+    vmovdqa     ymm6, ymm1
+    vpunpcklwd  ymm1, ymm1, ymm3
+    vpunpckhwd  ymm6, ymm6, ymm3
+    vmovdqa     ymm7, ymm1
+    vmovdqa     ymm4, ymm6
+    vpmaddwd    ymm1, ymm1, [rel PW_F0299_F0337]  ; ymm1=ROL*FIX(0.299)+GOL*FIX(0.337)
+    vpmaddwd    ymm6, ymm6, [rel PW_F0299_F0337]  ; ymm6=ROH*FIX(0.299)+GOH*FIX(0.337)
+    vpmaddwd    ymm7, ymm7, [rel PW_MF016_MF033]  ; ymm7=ROL*-FIX(0.168)+GOL*-FIX(0.331)
+    vpmaddwd    ymm4, ymm4, [rel PW_MF016_MF033]  ; ymm4=ROH*-FIX(0.168)+GOH*-FIX(0.331)
+
+    vmovdqa     YMMWORD [wk(4)], ymm1   ; wk(4)=ROL*FIX(0.299)+GOL*FIX(0.337)
+    vmovdqa     YMMWORD [wk(5)], ymm6   ; wk(5)=ROH*FIX(0.299)+GOH*FIX(0.337)
+
+    vpxor       ymm1, ymm1, ymm1
+    vpxor       ymm6, ymm6, ymm6
+    vpunpcklwd  ymm1, ymm1, ymm5        ; ymm1=BOL
+    vpunpckhwd  ymm6, ymm6, ymm5        ; ymm6=BOH
+    vpsrld      ymm1, ymm1, 1           ; ymm1=BOL*FIX(0.500)
+    vpsrld      ymm6, ymm6, 1           ; ymm6=BOH*FIX(0.500)
+
+    vmovdqa     ymm5, [rel PD_ONEHALFM1_CJ]  ; ymm5=[PD_ONEHALFM1_CJ]
+
+    vpaddd      ymm7, ymm7, ymm1
+    vpaddd      ymm4, ymm4, ymm6
+    vpaddd      ymm7, ymm7, ymm5
+    vpaddd      ymm4, ymm4, ymm5
+    vpsrld      ymm7, ymm7, SCALEBITS   ; ymm7=CbOL
+    vpsrld      ymm4, ymm4, SCALEBITS   ; ymm4=CbOH
+    vpackssdw   ymm7, ymm7, ymm4        ; ymm7=CbO
+
+    vmovdqa     ymm1, YMMWORD [wk(2)]   ; ymm1=BE
+
+    vmovdqa     ymm6, ymm0
+    vpunpcklwd  ymm0, ymm0, ymm2
+    vpunpckhwd  ymm6, ymm6, ymm2
+    vmovdqa     ymm5, ymm0
+    vmovdqa     ymm4, ymm6
+    vpmaddwd    ymm0, ymm0, [rel PW_F0299_F0337]  ; ymm0=REL*FIX(0.299)+GEL*FIX(0.337)
+    vpmaddwd    ymm6, ymm6, [rel PW_F0299_F0337]  ; ymm6=REH*FIX(0.299)+GEH*FIX(0.337)
+    vpmaddwd    ymm5, ymm5, [rel PW_MF016_MF033]  ; ymm5=REL*-FIX(0.168)+GEL*-FIX(0.331)
+    vpmaddwd    ymm4, ymm4, [rel PW_MF016_MF033]  ; ymm4=REH*-FIX(0.168)+GEH*-FIX(0.331)
+
+    vmovdqa     YMMWORD [wk(6)], ymm0   ; wk(6)=REL*FIX(0.299)+GEL*FIX(0.337)
+    vmovdqa     YMMWORD [wk(7)], ymm6   ; wk(7)=REH*FIX(0.299)+GEH*FIX(0.337)
+
+    vpxor       ymm0, ymm0, ymm0
+    vpxor       ymm6, ymm6, ymm6
+    vpunpcklwd  ymm0, ymm0, ymm1        ; ymm0=BEL
+    vpunpckhwd  ymm6, ymm6, ymm1        ; ymm6=BEH
+    vpsrld      ymm0, ymm0, 1           ; ymm0=BEL*FIX(0.500)
+    vpsrld      ymm6, ymm6, 1           ; ymm6=BEH*FIX(0.500)
+
+    vmovdqa     ymm1, [rel PD_ONEHALFM1_CJ]  ; ymm1=[PD_ONEHALFM1_CJ]
+
+    vpaddd      ymm5, ymm5, ymm0
+    vpaddd      ymm4, ymm4, ymm6
+    vpaddd      ymm5, ymm5, ymm1
+    vpaddd      ymm4, ymm4, ymm1
+    vpsrld      ymm5, ymm5, SCALEBITS   ; ymm5=CbEL
+    vpsrld      ymm4, ymm4, SCALEBITS   ; ymm4=CbEH
+    vpackssdw   ymm5, ymm5, ymm4        ; ymm5=CbE
+
+    vpsllw      ymm7, ymm7, BYTE_BIT
+    vpor        ymm5, ymm5, ymm7        ; ymm5=Cb
+    vmovdqu     YMMWORD [rbx], ymm5     ; Save Cb
+
+    vmovdqa     ymm0, YMMWORD [wk(3)]   ; ymm0=BO
+    vmovdqa     ymm6, YMMWORD [wk(2)]   ; ymm6=BE
+    vmovdqa     ymm1, YMMWORD [wk(1)]   ; ymm1=RO
+
+    vmovdqa     ymm4, ymm0
+    vpunpcklwd  ymm0, ymm0, ymm3
+    vpunpckhwd  ymm4, ymm4, ymm3
+    vmovdqa     ymm7, ymm0
+    vmovdqa     ymm5, ymm4
+    vpmaddwd    ymm0, ymm0, [rel PW_F0114_F0250]  ; ymm0=BOL*FIX(0.114)+GOL*FIX(0.250)
+    vpmaddwd    ymm4, ymm4, [rel PW_F0114_F0250]  ; ymm4=BOH*FIX(0.114)+GOH*FIX(0.250)
+    vpmaddwd    ymm7, ymm7, [rel PW_MF008_MF041]  ; ymm7=BOL*-FIX(0.081)+GOL*-FIX(0.418)
+    vpmaddwd    ymm5, ymm5, [rel PW_MF008_MF041]  ; ymm5=BOH*-FIX(0.081)+GOH*-FIX(0.418)
+
+    vmovdqa     ymm3, [rel PD_ONEHALF]            ; ymm3=[PD_ONEHALF]
+
+    vpaddd      ymm0, ymm0, YMMWORD [wk(4)]
+    vpaddd      ymm4, ymm4, YMMWORD [wk(5)]
+    vpaddd      ymm0, ymm0, ymm3
+    vpaddd      ymm4, ymm4, ymm3
+    vpsrld      ymm0, ymm0, SCALEBITS   ; ymm0=YOL
+    vpsrld      ymm4, ymm4, SCALEBITS   ; ymm4=YOH
+    vpackssdw   ymm0, ymm0, ymm4        ; ymm0=YO
+
+    vpxor       ymm3, ymm3, ymm3
+    vpxor       ymm4, ymm4, ymm4
+    vpunpcklwd  ymm3, ymm3, ymm1        ; ymm3=ROL
+    vpunpckhwd  ymm4, ymm4, ymm1        ; ymm4=ROH
+    vpsrld      ymm3, ymm3, 1           ; ymm3=ROL*FIX(0.500)
+    vpsrld      ymm4, ymm4, 1           ; ymm4=ROH*FIX(0.500)
+
+    vmovdqa     ymm1, [rel PD_ONEHALFM1_CJ]  ; ymm1=[PD_ONEHALFM1_CJ]
+
+    vpaddd      ymm7, ymm7, ymm3
+    vpaddd      ymm5, ymm5, ymm4
+    vpaddd      ymm7, ymm7, ymm1
+    vpaddd      ymm5, ymm5, ymm1
+    vpsrld      ymm7, ymm7, SCALEBITS   ; ymm7=CrOL
+    vpsrld      ymm5, ymm5, SCALEBITS   ; ymm5=CrOH
+    vpackssdw   ymm7, ymm7, ymm5        ; ymm7=CrO
+
+    vmovdqa     ymm3, YMMWORD [wk(0)]   ; ymm3=RE
+
+    vmovdqa     ymm4, ymm6
+    vpunpcklwd  ymm6, ymm6, ymm2
+    vpunpckhwd  ymm4, ymm4, ymm2
+    vmovdqa     ymm1, ymm6
+    vmovdqa     ymm5, ymm4
+    vpmaddwd    ymm6, ymm6, [rel PW_F0114_F0250]  ; ymm6=BEL*FIX(0.114)+GEL*FIX(0.250)
+    vpmaddwd    ymm4, ymm4, [rel PW_F0114_F0250]  ; ymm4=BEH*FIX(0.114)+GEH*FIX(0.250)
+    vpmaddwd    ymm1, ymm1, [rel PW_MF008_MF041]  ; ymm1=BEL*-FIX(0.081)+GEL*-FIX(0.418)
+    vpmaddwd    ymm5, ymm5, [rel PW_MF008_MF041]  ; ymm5=BEH*-FIX(0.081)+GEH*-FIX(0.418)
+
+    vmovdqa     ymm2, [rel PD_ONEHALF]            ; ymm2=[PD_ONEHALF]
+
+    vpaddd      ymm6, ymm6, YMMWORD [wk(6)]
+    vpaddd      ymm4, ymm4, YMMWORD [wk(7)]
+    vpaddd      ymm6, ymm6, ymm2
+    vpaddd      ymm4, ymm4, ymm2
+    vpsrld      ymm6, ymm6, SCALEBITS   ; ymm6=YEL
+    vpsrld      ymm4, ymm4, SCALEBITS   ; ymm4=YEH
+    vpackssdw   ymm6, ymm6, ymm4        ; ymm6=YE
+
+    vpsllw      ymm0, ymm0, BYTE_BIT
+    vpor        ymm6, ymm6, ymm0        ; ymm6=Y
+    vmovdqu     YMMWORD [rdi], ymm6     ; Save Y
+
+    vpxor       ymm2, ymm2, ymm2
+    vpxor       ymm4, ymm4, ymm4
+    vpunpcklwd  ymm2, ymm2, ymm3        ; ymm2=REL
+    vpunpckhwd  ymm4, ymm4, ymm3        ; ymm4=REH
+    vpsrld      ymm2, ymm2, 1           ; ymm2=REL*FIX(0.500)
+    vpsrld      ymm4, ymm4, 1           ; ymm4=REH*FIX(0.500)
+
+    vmovdqa     ymm0, [rel PD_ONEHALFM1_CJ]  ; ymm0=[PD_ONEHALFM1_CJ]
+
+    vpaddd      ymm1, ymm1, ymm2
+    vpaddd      ymm5, ymm5, ymm4
+    vpaddd      ymm1, ymm1, ymm0
+    vpaddd      ymm5, ymm5, ymm0
+    vpsrld      ymm1, ymm1, SCALEBITS   ; ymm1=CrEL
+    vpsrld      ymm5, ymm5, SCALEBITS   ; ymm5=CrEH
+    vpackssdw   ymm1, ymm1, ymm5        ; ymm1=CrE
+
+    vpsllw      ymm7, ymm7, BYTE_BIT
+    vpor        ymm1, ymm1, ymm7        ; ymm1=Cr
+    vmovdqu     YMMWORD [rdx], ymm1     ; Save Cr
+
+    sub         rcx, byte SIZEOF_YMMWORD
+    add         rsi, RGB_PIXELSIZE*SIZEOF_YMMWORD  ; inptr
+    add         rdi, byte SIZEOF_YMMWORD           ; outptr0
+    add         rbx, byte SIZEOF_YMMWORD           ; outptr1
+    add         rdx, byte SIZEOF_YMMWORD           ; outptr2
+    cmp         rcx, byte SIZEOF_YMMWORD
+    jae         near .columnloop
+    test        rcx, rcx
+    jnz         near .column_ld1
+
+    pop         rcx                     ; col
+    pop         rsi
+    pop         rdi
+    pop         rbx
+    pop         rdx
+
+    add         rsi, byte SIZEOF_JSAMPROW  ; input_buf
+    add         rdi, byte SIZEOF_JSAMPROW
+    add         rbx, byte SIZEOF_JSAMPROW
+    add         rdx, byte SIZEOF_JSAMPROW
+    dec         rax                        ; num_rows
+    jg          near .rowloop
+
+.return:
+    pop         rbx
+    vzeroupper
+    uncollect_args 5
+    mov         rsp, rbp                ; rsp <- aligned rbp
+    pop         rsp                     ; rsp <- original rbp
+    pop         rbp
+    ret
+
+; For some reason, the OS X linker does not honor the request to align the
+; segment unless we do this.
+    align       32
diff --git a/3rdparty/libjpeg/src/simd/x86_64/jccolext-sse2.asm b/3rdparty/libjpeg/src/simd/x86_64/jccolext-sse2.asm
new file mode 100644
index 00000000..af70ed60
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/x86_64/jccolext-sse2.asm
@@ -0,0 +1,484 @@
+;
+; jccolext.asm - colorspace conversion (64-bit SSE2)
+;
+; Copyright (C) 2009, 2016, D. R. Commander.
+; Copyright (C) 2018, Matthias Räncker.
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+;
+; This file should be assembled with NASM (Netwide Assembler),
+; can *not* be assembled with Microsoft's MASM or any compatible
+; assembler (including Borland's Turbo Assembler).
+; NASM is available from http://nasm.sourceforge.net/ or
+; http://sourceforge.net/project/showfiles.php?group_id=6208
+
+%include "jcolsamp.inc"
+
+; --------------------------------------------------------------------------
+;
+; Convert some rows of samples to the output colorspace.
+;
+; GLOBAL(void)
+; jsimd_rgb_ycc_convert_sse2(JDIMENSION img_width, JSAMPARRAY input_buf,
+;                            JSAMPIMAGE output_buf, JDIMENSION output_row,
+;                            int num_rows);
+;
+
+; r10d = JDIMENSION img_width
+; r11 = JSAMPARRAY input_buf
+; r12 = JSAMPIMAGE output_buf
+; r13d = JDIMENSION output_row
+; r14d = int num_rows
+
+%define wk(i)   rbp - (WK_NUM - (i)) * SIZEOF_XMMWORD  ; xmmword wk[WK_NUM]
+%define WK_NUM  8
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_rgb_ycc_convert_sse2)
+
+EXTN(jsimd_rgb_ycc_convert_sse2):
+    push        rbp
+    mov         rax, rsp                     ; rax = original rbp
+    sub         rsp, byte 4
+    and         rsp, byte (-SIZEOF_XMMWORD)  ; align to 128 bits
+    mov         [rsp], rax
+    mov         rbp, rsp                     ; rbp = aligned rbp
+    lea         rsp, [wk(0)]
+    collect_args 5
+    push        rbx
+
+    mov         ecx, r10d
+    test        rcx, rcx
+    jz          near .return
+
+    push        rcx
+
+    mov         rsi, r12
+    mov         ecx, r13d
+    mov         rdip, JSAMPARRAY [rsi+0*SIZEOF_JSAMPARRAY]
+    mov         rbxp, JSAMPARRAY [rsi+1*SIZEOF_JSAMPARRAY]
+    mov         rdxp, JSAMPARRAY [rsi+2*SIZEOF_JSAMPARRAY]
+    lea         rdi, [rdi+rcx*SIZEOF_JSAMPROW]
+    lea         rbx, [rbx+rcx*SIZEOF_JSAMPROW]
+    lea         rdx, [rdx+rcx*SIZEOF_JSAMPROW]
+
+    pop         rcx
+
+    mov         rsi, r11
+    mov         eax, r14d
+    test        rax, rax
+    jle         near .return
+.rowloop:
+    push        rdx
+    push        rbx
+    push        rdi
+    push        rsi
+    push        rcx                     ; col
+
+    mov         rsip, JSAMPROW [rsi]    ; inptr
+    mov         rdip, JSAMPROW [rdi]    ; outptr0
+    mov         rbxp, JSAMPROW [rbx]    ; outptr1
+    mov         rdxp, JSAMPROW [rdx]    ; outptr2
+
+    cmp         rcx, byte SIZEOF_XMMWORD
+    jae         near .columnloop
+
+%if RGB_PIXELSIZE == 3  ; ---------------
+
+.column_ld1:
+    push        rax
+    push        rdx
+    lea         rcx, [rcx+rcx*2]        ; imul ecx,RGB_PIXELSIZE
+    test        cl, SIZEOF_BYTE
+    jz          short .column_ld2
+    sub         rcx, byte SIZEOF_BYTE
+    movzx       rax, byte [rsi+rcx]
+.column_ld2:
+    test        cl, SIZEOF_WORD
+    jz          short .column_ld4
+    sub         rcx, byte SIZEOF_WORD
+    movzx       rdx, word [rsi+rcx]
+    shl         rax, WORD_BIT
+    or          rax, rdx
+.column_ld4:
+    movd        xmmA, eax
+    pop         rdx
+    pop         rax
+    test        cl, SIZEOF_DWORD
+    jz          short .column_ld8
+    sub         rcx, byte SIZEOF_DWORD
+    movd        xmmF, XMM_DWORD [rsi+rcx]
+    pslldq      xmmA, SIZEOF_DWORD
+    por         xmmA, xmmF
+.column_ld8:
+    test        cl, SIZEOF_MMWORD
+    jz          short .column_ld16
+    sub         rcx, byte SIZEOF_MMWORD
+    movq        xmmB, XMM_MMWORD [rsi+rcx]
+    pslldq      xmmA, SIZEOF_MMWORD
+    por         xmmA, xmmB
+.column_ld16:
+    test        cl, SIZEOF_XMMWORD
+    jz          short .column_ld32
+    movdqa      xmmF, xmmA
+    movdqu      xmmA, XMMWORD [rsi+0*SIZEOF_XMMWORD]
+    mov         rcx, SIZEOF_XMMWORD
+    jmp         short .rgb_ycc_cnv
+.column_ld32:
+    test        cl, 2*SIZEOF_XMMWORD
+    mov         rcx, SIZEOF_XMMWORD
+    jz          short .rgb_ycc_cnv
+    movdqa      xmmB, xmmA
+    movdqu      xmmA, XMMWORD [rsi+0*SIZEOF_XMMWORD]
+    movdqu      xmmF, XMMWORD [rsi+1*SIZEOF_XMMWORD]
+    jmp         short .rgb_ycc_cnv
+
+.columnloop:
+    movdqu      xmmA, XMMWORD [rsi+0*SIZEOF_XMMWORD]
+    movdqu      xmmF, XMMWORD [rsi+1*SIZEOF_XMMWORD]
+    movdqu      xmmB, XMMWORD [rsi+2*SIZEOF_XMMWORD]
+
+.rgb_ycc_cnv:
+    ; xmmA=(00 10 20 01 11 21 02 12 22 03 13 23 04 14 24 05)
+    ; xmmF=(15 25 06 16 26 07 17 27 08 18 28 09 19 29 0A 1A)
+    ; xmmB=(2A 0B 1B 2B 0C 1C 2C 0D 1D 2D 0E 1E 2E 0F 1F 2F)
+
+    movdqa      xmmG, xmmA
+    pslldq      xmmA, 8     ; xmmA=(-- -- -- -- -- -- -- -- 00 10 20 01 11 21 02 12)
+    psrldq      xmmG, 8     ; xmmG=(22 03 13 23 04 14 24 05 -- -- -- -- -- -- -- --)
+
+    punpckhbw   xmmA, xmmF  ; xmmA=(00 08 10 18 20 28 01 09 11 19 21 29 02 0A 12 1A)
+    pslldq      xmmF, 8     ; xmmF=(-- -- -- -- -- -- -- -- 15 25 06 16 26 07 17 27)
+
+    punpcklbw   xmmG, xmmB  ; xmmG=(22 2A 03 0B 13 1B 23 2B 04 0C 14 1C 24 2C 05 0D)
+    punpckhbw   xmmF, xmmB  ; xmmF=(15 1D 25 2D 06 0E 16 1E 26 2E 07 0F 17 1F 27 2F)
+
+    movdqa      xmmD, xmmA
+    pslldq      xmmA, 8     ; xmmA=(-- -- -- -- -- -- -- -- 00 08 10 18 20 28 01 09)
+    psrldq      xmmD, 8     ; xmmD=(11 19 21 29 02 0A 12 1A -- -- -- -- -- -- -- --)
+
+    punpckhbw   xmmA, xmmG  ; xmmA=(00 04 08 0C 10 14 18 1C 20 24 28 2C 01 05 09 0D)
+    pslldq      xmmG, 8     ; xmmG=(-- -- -- -- -- -- -- -- 22 2A 03 0B 13 1B 23 2B)
+
+    punpcklbw   xmmD, xmmF  ; xmmD=(11 15 19 1D 21 25 29 2D 02 06 0A 0E 12 16 1A 1E)
+    punpckhbw   xmmG, xmmF  ; xmmG=(22 26 2A 2E 03 07 0B 0F 13 17 1B 1F 23 27 2B 2F)
+
+    movdqa      xmmE, xmmA
+    pslldq      xmmA, 8     ; xmmA=(-- -- -- -- -- -- -- -- 00 04 08 0C 10 14 18 1C)
+    psrldq      xmmE, 8     ; xmmE=(20 24 28 2C 01 05 09 0D -- -- -- -- -- -- -- --)
+
+    punpckhbw   xmmA, xmmD  ; xmmA=(00 02 04 06 08 0A 0C 0E 10 12 14 16 18 1A 1C 1E)
+    pslldq      xmmD, 8     ; xmmD=(-- -- -- -- -- -- -- -- 11 15 19 1D 21 25 29 2D)
+
+    punpcklbw   xmmE, xmmG  ; xmmE=(20 22 24 26 28 2A 2C 2E 01 03 05 07 09 0B 0D 0F)
+    punpckhbw   xmmD, xmmG  ; xmmD=(11 13 15 17 19 1B 1D 1F 21 23 25 27 29 2B 2D 2F)
+
+    pxor        xmmH, xmmH
+
+    movdqa      xmmC, xmmA
+    punpcklbw   xmmA, xmmH  ; xmmA=(00 02 04 06 08 0A 0C 0E)
+    punpckhbw   xmmC, xmmH  ; xmmC=(10 12 14 16 18 1A 1C 1E)
+
+    movdqa      xmmB, xmmE
+    punpcklbw   xmmE, xmmH  ; xmmE=(20 22 24 26 28 2A 2C 2E)
+    punpckhbw   xmmB, xmmH  ; xmmB=(01 03 05 07 09 0B 0D 0F)
+
+    movdqa      xmmF, xmmD
+    punpcklbw   xmmD, xmmH  ; xmmD=(11 13 15 17 19 1B 1D 1F)
+    punpckhbw   xmmF, xmmH  ; xmmF=(21 23 25 27 29 2B 2D 2F)
+
+%else  ; RGB_PIXELSIZE == 4 ; -----------
+
+.column_ld1:
+    test        cl, SIZEOF_XMMWORD/16
+    jz          short .column_ld2
+    sub         rcx, byte SIZEOF_XMMWORD/16
+    movd        xmmA, XMM_DWORD [rsi+rcx*RGB_PIXELSIZE]
+.column_ld2:
+    test        cl, SIZEOF_XMMWORD/8
+    jz          short .column_ld4
+    sub         rcx, byte SIZEOF_XMMWORD/8
+    movq        xmmE, XMM_MMWORD [rsi+rcx*RGB_PIXELSIZE]
+    pslldq      xmmA, SIZEOF_MMWORD
+    por         xmmA, xmmE
+.column_ld4:
+    test        cl, SIZEOF_XMMWORD/4
+    jz          short .column_ld8
+    sub         rcx, byte SIZEOF_XMMWORD/4
+    movdqa      xmmE, xmmA
+    movdqu      xmmA, XMMWORD [rsi+rcx*RGB_PIXELSIZE]
+.column_ld8:
+    test        cl, SIZEOF_XMMWORD/2
+    mov         rcx, SIZEOF_XMMWORD
+    jz          short .rgb_ycc_cnv
+    movdqa      xmmF, xmmA
+    movdqa      xmmH, xmmE
+    movdqu      xmmA, XMMWORD [rsi+0*SIZEOF_XMMWORD]
+    movdqu      xmmE, XMMWORD [rsi+1*SIZEOF_XMMWORD]
+    jmp         short .rgb_ycc_cnv
+
+.columnloop:
+    movdqu      xmmA, XMMWORD [rsi+0*SIZEOF_XMMWORD]
+    movdqu      xmmE, XMMWORD [rsi+1*SIZEOF_XMMWORD]
+    movdqu      xmmF, XMMWORD [rsi+2*SIZEOF_XMMWORD]
+    movdqu      xmmH, XMMWORD [rsi+3*SIZEOF_XMMWORD]
+
+.rgb_ycc_cnv:
+    ; xmmA=(00 10 20 30 01 11 21 31 02 12 22 32 03 13 23 33)
+    ; xmmE=(04 14 24 34 05 15 25 35 06 16 26 36 07 17 27 37)
+    ; xmmF=(08 18 28 38 09 19 29 39 0A 1A 2A 3A 0B 1B 2B 3B)
+    ; xmmH=(0C 1C 2C 3C 0D 1D 2D 3D 0E 1E 2E 3E 0F 1F 2F 3F)
+
+    movdqa      xmmD, xmmA
+    punpcklbw   xmmA, xmmE      ; xmmA=(00 04 10 14 20 24 30 34 01 05 11 15 21 25 31 35)
+    punpckhbw   xmmD, xmmE      ; xmmD=(02 06 12 16 22 26 32 36 03 07 13 17 23 27 33 37)
+
+    movdqa      xmmC, xmmF
+    punpcklbw   xmmF, xmmH      ; xmmF=(08 0C 18 1C 28 2C 38 3C 09 0D 19 1D 29 2D 39 3D)
+    punpckhbw   xmmC, xmmH      ; xmmC=(0A 0E 1A 1E 2A 2E 3A 3E 0B 0F 1B 1F 2B 2F 3B 3F)
+
+    movdqa      xmmB, xmmA
+    punpcklwd   xmmA, xmmF      ; xmmA=(00 04 08 0C 10 14 18 1C 20 24 28 2C 30 34 38 3C)
+    punpckhwd   xmmB, xmmF      ; xmmB=(01 05 09 0D 11 15 19 1D 21 25 29 2D 31 35 39 3D)
+
+    movdqa      xmmG, xmmD
+    punpcklwd   xmmD, xmmC      ; xmmD=(02 06 0A 0E 12 16 1A 1E 22 26 2A 2E 32 36 3A 3E)
+    punpckhwd   xmmG, xmmC      ; xmmG=(03 07 0B 0F 13 17 1B 1F 23 27 2B 2F 33 37 3B 3F)
+
+    movdqa      xmmE, xmmA
+    punpcklbw   xmmA, xmmD      ; xmmA=(00 02 04 06 08 0A 0C 0E 10 12 14 16 18 1A 1C 1E)
+    punpckhbw   xmmE, xmmD      ; xmmE=(20 22 24 26 28 2A 2C 2E 30 32 34 36 38 3A 3C 3E)
+
+    movdqa      xmmH, xmmB
+    punpcklbw   xmmB, xmmG      ; xmmB=(01 03 05 07 09 0B 0D 0F 11 13 15 17 19 1B 1D 1F)
+    punpckhbw   xmmH, xmmG      ; xmmH=(21 23 25 27 29 2B 2D 2F 31 33 35 37 39 3B 3D 3F)
+
+    pxor        xmmF, xmmF
+
+    movdqa      xmmC, xmmA
+    punpcklbw   xmmA, xmmF      ; xmmA=(00 02 04 06 08 0A 0C 0E)
+    punpckhbw   xmmC, xmmF      ; xmmC=(10 12 14 16 18 1A 1C 1E)
+
+    movdqa      xmmD, xmmB
+    punpcklbw   xmmB, xmmF      ; xmmB=(01 03 05 07 09 0B 0D 0F)
+    punpckhbw   xmmD, xmmF      ; xmmD=(11 13 15 17 19 1B 1D 1F)
+
+    movdqa      xmmG, xmmE
+    punpcklbw   xmmE, xmmF      ; xmmE=(20 22 24 26 28 2A 2C 2E)
+    punpckhbw   xmmG, xmmF      ; xmmG=(30 32 34 36 38 3A 3C 3E)
+
+    punpcklbw   xmmF, xmmH
+    punpckhbw   xmmH, xmmH
+    psrlw       xmmF, BYTE_BIT  ; xmmF=(21 23 25 27 29 2B 2D 2F)
+    psrlw       xmmH, BYTE_BIT  ; xmmH=(31 33 35 37 39 3B 3D 3F)
+
+%endif  ; RGB_PIXELSIZE ; ---------------
+
+    ; xmm0=R(02468ACE)=RE, xmm2=G(02468ACE)=GE, xmm4=B(02468ACE)=BE
+    ; xmm1=R(13579BDF)=RO, xmm3=G(13579BDF)=GO, xmm5=B(13579BDF)=BO
+
+    ; (Original)
+    ; Y  =  0.29900 * R + 0.58700 * G + 0.11400 * B
+    ; Cb = -0.16874 * R - 0.33126 * G + 0.50000 * B + CENTERJSAMPLE
+    ; Cr =  0.50000 * R - 0.41869 * G - 0.08131 * B + CENTERJSAMPLE
+    ;
+    ; (This implementation)
+    ; Y  =  0.29900 * R + 0.33700 * G + 0.11400 * B + 0.25000 * G
+    ; Cb = -0.16874 * R - 0.33126 * G + 0.50000 * B + CENTERJSAMPLE
+    ; Cr =  0.50000 * R - 0.41869 * G - 0.08131 * B + CENTERJSAMPLE
+
+    movdqa      XMMWORD [wk(0)], xmm0   ; wk(0)=RE
+    movdqa      XMMWORD [wk(1)], xmm1   ; wk(1)=RO
+    movdqa      XMMWORD [wk(2)], xmm4   ; wk(2)=BE
+    movdqa      XMMWORD [wk(3)], xmm5   ; wk(3)=BO
+
+    movdqa      xmm6, xmm1
+    punpcklwd   xmm1, xmm3
+    punpckhwd   xmm6, xmm3
+    movdqa      xmm7, xmm1
+    movdqa      xmm4, xmm6
+    pmaddwd     xmm1, [rel PW_F0299_F0337]  ; xmm1=ROL*FIX(0.299)+GOL*FIX(0.337)
+    pmaddwd     xmm6, [rel PW_F0299_F0337]  ; xmm6=ROH*FIX(0.299)+GOH*FIX(0.337)
+    pmaddwd     xmm7, [rel PW_MF016_MF033]  ; xmm7=ROL*-FIX(0.168)+GOL*-FIX(0.331)
+    pmaddwd     xmm4, [rel PW_MF016_MF033]  ; xmm4=ROH*-FIX(0.168)+GOH*-FIX(0.331)
+
+    movdqa      XMMWORD [wk(4)], xmm1   ; wk(4)=ROL*FIX(0.299)+GOL*FIX(0.337)
+    movdqa      XMMWORD [wk(5)], xmm6   ; wk(5)=ROH*FIX(0.299)+GOH*FIX(0.337)
+
+    pxor        xmm1, xmm1
+    pxor        xmm6, xmm6
+    punpcklwd   xmm1, xmm5              ; xmm1=BOL
+    punpckhwd   xmm6, xmm5              ; xmm6=BOH
+    psrld       xmm1, 1                 ; xmm1=BOL*FIX(0.500)
+    psrld       xmm6, 1                 ; xmm6=BOH*FIX(0.500)
+
+    movdqa      xmm5, [rel PD_ONEHALFM1_CJ]  ; xmm5=[PD_ONEHALFM1_CJ]
+
+    paddd       xmm7, xmm1
+    paddd       xmm4, xmm6
+    paddd       xmm7, xmm5
+    paddd       xmm4, xmm5
+    psrld       xmm7, SCALEBITS         ; xmm7=CbOL
+    psrld       xmm4, SCALEBITS         ; xmm4=CbOH
+    packssdw    xmm7, xmm4              ; xmm7=CbO
+
+    movdqa      xmm1, XMMWORD [wk(2)]   ; xmm1=BE
+
+    movdqa      xmm6, xmm0
+    punpcklwd   xmm0, xmm2
+    punpckhwd   xmm6, xmm2
+    movdqa      xmm5, xmm0
+    movdqa      xmm4, xmm6
+    pmaddwd     xmm0, [rel PW_F0299_F0337]  ; xmm0=REL*FIX(0.299)+GEL*FIX(0.337)
+    pmaddwd     xmm6, [rel PW_F0299_F0337]  ; xmm6=REH*FIX(0.299)+GEH*FIX(0.337)
+    pmaddwd     xmm5, [rel PW_MF016_MF033]  ; xmm5=REL*-FIX(0.168)+GEL*-FIX(0.331)
+    pmaddwd     xmm4, [rel PW_MF016_MF033]  ; xmm4=REH*-FIX(0.168)+GEH*-FIX(0.331)
+
+    movdqa      XMMWORD [wk(6)], xmm0   ; wk(6)=REL*FIX(0.299)+GEL*FIX(0.337)
+    movdqa      XMMWORD [wk(7)], xmm6   ; wk(7)=REH*FIX(0.299)+GEH*FIX(0.337)
+
+    pxor        xmm0, xmm0
+    pxor        xmm6, xmm6
+    punpcklwd   xmm0, xmm1              ; xmm0=BEL
+    punpckhwd   xmm6, xmm1              ; xmm6=BEH
+    psrld       xmm0, 1                 ; xmm0=BEL*FIX(0.500)
+    psrld       xmm6, 1                 ; xmm6=BEH*FIX(0.500)
+
+    movdqa      xmm1, [rel PD_ONEHALFM1_CJ]  ; xmm1=[PD_ONEHALFM1_CJ]
+
+    paddd       xmm5, xmm0
+    paddd       xmm4, xmm6
+    paddd       xmm5, xmm1
+    paddd       xmm4, xmm1
+    psrld       xmm5, SCALEBITS         ; xmm5=CbEL
+    psrld       xmm4, SCALEBITS         ; xmm4=CbEH
+    packssdw    xmm5, xmm4              ; xmm5=CbE
+
+    psllw       xmm7, BYTE_BIT
+    por         xmm5, xmm7              ; xmm5=Cb
+    movdqa      XMMWORD [rbx], xmm5     ; Save Cb
+
+    movdqa      xmm0, XMMWORD [wk(3)]   ; xmm0=BO
+    movdqa      xmm6, XMMWORD [wk(2)]   ; xmm6=BE
+    movdqa      xmm1, XMMWORD [wk(1)]   ; xmm1=RO
+
+    movdqa      xmm4, xmm0
+    punpcklwd   xmm0, xmm3
+    punpckhwd   xmm4, xmm3
+    movdqa      xmm7, xmm0
+    movdqa      xmm5, xmm4
+    pmaddwd     xmm0, [rel PW_F0114_F0250]  ; xmm0=BOL*FIX(0.114)+GOL*FIX(0.250)
+    pmaddwd     xmm4, [rel PW_F0114_F0250]  ; xmm4=BOH*FIX(0.114)+GOH*FIX(0.250)
+    pmaddwd     xmm7, [rel PW_MF008_MF041]  ; xmm7=BOL*-FIX(0.081)+GOL*-FIX(0.418)
+    pmaddwd     xmm5, [rel PW_MF008_MF041]  ; xmm5=BOH*-FIX(0.081)+GOH*-FIX(0.418)
+
+    movdqa      xmm3, [rel PD_ONEHALF]      ; xmm3=[PD_ONEHALF]
+
+    paddd       xmm0, XMMWORD [wk(4)]
+    paddd       xmm4, XMMWORD [wk(5)]
+    paddd       xmm0, xmm3
+    paddd       xmm4, xmm3
+    psrld       xmm0, SCALEBITS         ; xmm0=YOL
+    psrld       xmm4, SCALEBITS         ; xmm4=YOH
+    packssdw    xmm0, xmm4              ; xmm0=YO
+
+    pxor        xmm3, xmm3
+    pxor        xmm4, xmm4
+    punpcklwd   xmm3, xmm1              ; xmm3=ROL
+    punpckhwd   xmm4, xmm1              ; xmm4=ROH
+    psrld       xmm3, 1                 ; xmm3=ROL*FIX(0.500)
+    psrld       xmm4, 1                 ; xmm4=ROH*FIX(0.500)
+
+    movdqa      xmm1, [rel PD_ONEHALFM1_CJ]  ; xmm1=[PD_ONEHALFM1_CJ]
+
+    paddd       xmm7, xmm3
+    paddd       xmm5, xmm4
+    paddd       xmm7, xmm1
+    paddd       xmm5, xmm1
+    psrld       xmm7, SCALEBITS         ; xmm7=CrOL
+    psrld       xmm5, SCALEBITS         ; xmm5=CrOH
+    packssdw    xmm7, xmm5              ; xmm7=CrO
+
+    movdqa      xmm3, XMMWORD [wk(0)]   ; xmm3=RE
+
+    movdqa      xmm4, xmm6
+    punpcklwd   xmm6, xmm2
+    punpckhwd   xmm4, xmm2
+    movdqa      xmm1, xmm6
+    movdqa      xmm5, xmm4
+    pmaddwd     xmm6, [rel PW_F0114_F0250]  ; xmm6=BEL*FIX(0.114)+GEL*FIX(0.250)
+    pmaddwd     xmm4, [rel PW_F0114_F0250]  ; xmm4=BEH*FIX(0.114)+GEH*FIX(0.250)
+    pmaddwd     xmm1, [rel PW_MF008_MF041]  ; xmm1=BEL*-FIX(0.081)+GEL*-FIX(0.418)
+    pmaddwd     xmm5, [rel PW_MF008_MF041]  ; xmm5=BEH*-FIX(0.081)+GEH*-FIX(0.418)
+
+    movdqa      xmm2, [rel PD_ONEHALF]      ; xmm2=[PD_ONEHALF]
+
+    paddd       xmm6, XMMWORD [wk(6)]
+    paddd       xmm4, XMMWORD [wk(7)]
+    paddd       xmm6, xmm2
+    paddd       xmm4, xmm2
+    psrld       xmm6, SCALEBITS         ; xmm6=YEL
+    psrld       xmm4, SCALEBITS         ; xmm4=YEH
+    packssdw    xmm6, xmm4              ; xmm6=YE
+
+    psllw       xmm0, BYTE_BIT
+    por         xmm6, xmm0              ; xmm6=Y
+    movdqa      XMMWORD [rdi], xmm6     ; Save Y
+
+    pxor        xmm2, xmm2
+    pxor        xmm4, xmm4
+    punpcklwd   xmm2, xmm3              ; xmm2=REL
+    punpckhwd   xmm4, xmm3              ; xmm4=REH
+    psrld       xmm2, 1                 ; xmm2=REL*FIX(0.500)
+    psrld       xmm4, 1                 ; xmm4=REH*FIX(0.500)
+
+    movdqa      xmm0, [rel PD_ONEHALFM1_CJ]  ; xmm0=[PD_ONEHALFM1_CJ]
+
+    paddd       xmm1, xmm2
+    paddd       xmm5, xmm4
+    paddd       xmm1, xmm0
+    paddd       xmm5, xmm0
+    psrld       xmm1, SCALEBITS         ; xmm1=CrEL
+    psrld       xmm5, SCALEBITS         ; xmm5=CrEH
+    packssdw    xmm1, xmm5              ; xmm1=CrE
+
+    psllw       xmm7, BYTE_BIT
+    por         xmm1, xmm7              ; xmm1=Cr
+    movdqa      XMMWORD [rdx], xmm1     ; Save Cr
+
+    sub         rcx, byte SIZEOF_XMMWORD
+    add         rsi, byte RGB_PIXELSIZE*SIZEOF_XMMWORD  ; inptr
+    add         rdi, byte SIZEOF_XMMWORD                ; outptr0
+    add         rbx, byte SIZEOF_XMMWORD                ; outptr1
+    add         rdx, byte SIZEOF_XMMWORD                ; outptr2
+    cmp         rcx, byte SIZEOF_XMMWORD
+    jae         near .columnloop
+    test        rcx, rcx
+    jnz         near .column_ld1
+
+    pop         rcx                     ; col
+    pop         rsi
+    pop         rdi
+    pop         rbx
+    pop         rdx
+
+    add         rsi, byte SIZEOF_JSAMPROW  ; input_buf
+    add         rdi, byte SIZEOF_JSAMPROW
+    add         rbx, byte SIZEOF_JSAMPROW
+    add         rdx, byte SIZEOF_JSAMPROW
+    dec         rax                        ; num_rows
+    jg          near .rowloop
+
+.return:
+    pop         rbx
+    uncollect_args 5
+    mov         rsp, rbp                ; rsp <- aligned rbp
+    pop         rsp                     ; rsp <- original rbp
+    pop         rbp
+    ret
+
+; For some reason, the OS X linker does not honor the request to align the
+; segment unless we do this.
+    align       32
diff --git a/3rdparty/libjpeg/src/simd/x86_64/jccolor-avx2.asm b/3rdparty/libjpeg/src/simd/x86_64/jccolor-avx2.asm
new file mode 100644
index 00000000..16b78298
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/x86_64/jccolor-avx2.asm
@@ -0,0 +1,121 @@
+;
+; jccolor.asm - colorspace conversion (64-bit AVX2)
+;
+; Copyright (C) 2009, 2016, D. R. Commander.
+; Copyright (C) 2015, Intel Corporation.
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+;
+; This file should be assembled with NASM (Netwide Assembler),
+; can *not* be assembled with Microsoft's MASM or any compatible
+; assembler (including Borland's Turbo Assembler).
+; NASM is available from http://nasm.sourceforge.net/ or
+; http://sourceforge.net/project/showfiles.php?group_id=6208
+
+%include "jsimdext.inc"
+
+; --------------------------------------------------------------------------
+
+%define SCALEBITS  16
+
+F_0_081 equ  5329                ; FIX(0.08131)
+F_0_114 equ  7471                ; FIX(0.11400)
+F_0_168 equ 11059                ; FIX(0.16874)
+F_0_250 equ 16384                ; FIX(0.25000)
+F_0_299 equ 19595                ; FIX(0.29900)
+F_0_331 equ 21709                ; FIX(0.33126)
+F_0_418 equ 27439                ; FIX(0.41869)
+F_0_587 equ 38470                ; FIX(0.58700)
+F_0_337 equ (F_0_587 - F_0_250)  ; FIX(0.58700) - FIX(0.25000)
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_CONST
+
+    alignz      32
+    GLOBAL_DATA(jconst_rgb_ycc_convert_avx2)
+
+EXTN(jconst_rgb_ycc_convert_avx2):
+
+PW_F0299_F0337  times 8 dw  F_0_299,  F_0_337
+PW_F0114_F0250  times 8 dw  F_0_114,  F_0_250
+PW_MF016_MF033  times 8 dw -F_0_168, -F_0_331
+PW_MF008_MF041  times 8 dw -F_0_081, -F_0_418
+PD_ONEHALFM1_CJ times 8 dd  (1 << (SCALEBITS - 1)) - 1 + \
+                            (CENTERJSAMPLE << SCALEBITS)
+PD_ONEHALF      times 8 dd  (1 << (SCALEBITS - 1))
+
+    alignz      32
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_TEXT
+    BITS        64
+
+%include "jccolext-avx2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_RGB_RED
+%define RGB_GREEN  EXT_RGB_GREEN
+%define RGB_BLUE  EXT_RGB_BLUE
+%define RGB_PIXELSIZE  EXT_RGB_PIXELSIZE
+%define jsimd_rgb_ycc_convert_avx2  jsimd_extrgb_ycc_convert_avx2
+%include "jccolext-avx2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_RGBX_RED
+%define RGB_GREEN  EXT_RGBX_GREEN
+%define RGB_BLUE  EXT_RGBX_BLUE
+%define RGB_PIXELSIZE  EXT_RGBX_PIXELSIZE
+%define jsimd_rgb_ycc_convert_avx2  jsimd_extrgbx_ycc_convert_avx2
+%include "jccolext-avx2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_BGR_RED
+%define RGB_GREEN  EXT_BGR_GREEN
+%define RGB_BLUE  EXT_BGR_BLUE
+%define RGB_PIXELSIZE  EXT_BGR_PIXELSIZE
+%define jsimd_rgb_ycc_convert_avx2  jsimd_extbgr_ycc_convert_avx2
+%include "jccolext-avx2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_BGRX_RED
+%define RGB_GREEN  EXT_BGRX_GREEN
+%define RGB_BLUE  EXT_BGRX_BLUE
+%define RGB_PIXELSIZE  EXT_BGRX_PIXELSIZE
+%define jsimd_rgb_ycc_convert_avx2  jsimd_extbgrx_ycc_convert_avx2
+%include "jccolext-avx2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_XBGR_RED
+%define RGB_GREEN  EXT_XBGR_GREEN
+%define RGB_BLUE  EXT_XBGR_BLUE
+%define RGB_PIXELSIZE  EXT_XBGR_PIXELSIZE
+%define jsimd_rgb_ycc_convert_avx2  jsimd_extxbgr_ycc_convert_avx2
+%include "jccolext-avx2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_XRGB_RED
+%define RGB_GREEN  EXT_XRGB_GREEN
+%define RGB_BLUE  EXT_XRGB_BLUE
+%define RGB_PIXELSIZE  EXT_XRGB_PIXELSIZE
+%define jsimd_rgb_ycc_convert_avx2  jsimd_extxrgb_ycc_convert_avx2
+%include "jccolext-avx2.asm"
diff --git a/3rdparty/libjpeg/src/simd/x86_64/jccolor-sse2.asm b/3rdparty/libjpeg/src/simd/x86_64/jccolor-sse2.asm
new file mode 100644
index 00000000..e2955c21
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/x86_64/jccolor-sse2.asm
@@ -0,0 +1,120 @@
+;
+; jccolor.asm - colorspace conversion (64-bit SSE2)
+;
+; Copyright (C) 2009, 2016, D. R. Commander.
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+;
+; This file should be assembled with NASM (Netwide Assembler),
+; can *not* be assembled with Microsoft's MASM or any compatible
+; assembler (including Borland's Turbo Assembler).
+; NASM is available from http://nasm.sourceforge.net/ or
+; http://sourceforge.net/project/showfiles.php?group_id=6208
+
+%include "jsimdext.inc"
+
+; --------------------------------------------------------------------------
+
+%define SCALEBITS  16
+
+F_0_081 equ  5329                ; FIX(0.08131)
+F_0_114 equ  7471                ; FIX(0.11400)
+F_0_168 equ 11059                ; FIX(0.16874)
+F_0_250 equ 16384                ; FIX(0.25000)
+F_0_299 equ 19595                ; FIX(0.29900)
+F_0_331 equ 21709                ; FIX(0.33126)
+F_0_418 equ 27439                ; FIX(0.41869)
+F_0_587 equ 38470                ; FIX(0.58700)
+F_0_337 equ (F_0_587 - F_0_250)  ; FIX(0.58700) - FIX(0.25000)
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_CONST
+
+    alignz      32
+    GLOBAL_DATA(jconst_rgb_ycc_convert_sse2)
+
+EXTN(jconst_rgb_ycc_convert_sse2):
+
+PW_F0299_F0337  times 4 dw  F_0_299,  F_0_337
+PW_F0114_F0250  times 4 dw  F_0_114,  F_0_250
+PW_MF016_MF033  times 4 dw -F_0_168, -F_0_331
+PW_MF008_MF041  times 4 dw -F_0_081, -F_0_418
+PD_ONEHALFM1_CJ times 4 dd  (1 << (SCALEBITS - 1)) - 1 + \
+                            (CENTERJSAMPLE << SCALEBITS)
+PD_ONEHALF      times 4 dd  (1 << (SCALEBITS - 1))
+
+    alignz      32
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_TEXT
+    BITS        64
+
+%include "jccolext-sse2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_RGB_RED
+%define RGB_GREEN  EXT_RGB_GREEN
+%define RGB_BLUE  EXT_RGB_BLUE
+%define RGB_PIXELSIZE  EXT_RGB_PIXELSIZE
+%define jsimd_rgb_ycc_convert_sse2  jsimd_extrgb_ycc_convert_sse2
+%include "jccolext-sse2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_RGBX_RED
+%define RGB_GREEN  EXT_RGBX_GREEN
+%define RGB_BLUE  EXT_RGBX_BLUE
+%define RGB_PIXELSIZE  EXT_RGBX_PIXELSIZE
+%define jsimd_rgb_ycc_convert_sse2  jsimd_extrgbx_ycc_convert_sse2
+%include "jccolext-sse2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_BGR_RED
+%define RGB_GREEN  EXT_BGR_GREEN
+%define RGB_BLUE  EXT_BGR_BLUE
+%define RGB_PIXELSIZE  EXT_BGR_PIXELSIZE
+%define jsimd_rgb_ycc_convert_sse2  jsimd_extbgr_ycc_convert_sse2
+%include "jccolext-sse2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_BGRX_RED
+%define RGB_GREEN  EXT_BGRX_GREEN
+%define RGB_BLUE  EXT_BGRX_BLUE
+%define RGB_PIXELSIZE  EXT_BGRX_PIXELSIZE
+%define jsimd_rgb_ycc_convert_sse2  jsimd_extbgrx_ycc_convert_sse2
+%include "jccolext-sse2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_XBGR_RED
+%define RGB_GREEN  EXT_XBGR_GREEN
+%define RGB_BLUE  EXT_XBGR_BLUE
+%define RGB_PIXELSIZE  EXT_XBGR_PIXELSIZE
+%define jsimd_rgb_ycc_convert_sse2  jsimd_extxbgr_ycc_convert_sse2
+%include "jccolext-sse2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_XRGB_RED
+%define RGB_GREEN  EXT_XRGB_GREEN
+%define RGB_BLUE  EXT_XRGB_BLUE
+%define RGB_PIXELSIZE  EXT_XRGB_PIXELSIZE
+%define jsimd_rgb_ycc_convert_sse2  jsimd_extxrgb_ycc_convert_sse2
+%include "jccolext-sse2.asm"
diff --git a/3rdparty/libjpeg/src/simd/x86_64/jcgray-avx2.asm b/3rdparty/libjpeg/src/simd/x86_64/jcgray-avx2.asm
new file mode 100644
index 00000000..591255bb
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/x86_64/jcgray-avx2.asm
@@ -0,0 +1,113 @@
+;
+; jcgray.asm - grayscale colorspace conversion (64-bit AVX2)
+;
+; Copyright (C) 2011, 2016, D. R. Commander.
+; Copyright (C) 2015, Intel Corporation.
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+;
+; This file should be assembled with NASM (Netwide Assembler),
+; can *not* be assembled with Microsoft's MASM or any compatible
+; assembler (including Borland's Turbo Assembler).
+; NASM is available from http://nasm.sourceforge.net/ or
+; http://sourceforge.net/project/showfiles.php?group_id=6208
+
+%include "jsimdext.inc"
+
+; --------------------------------------------------------------------------
+
+%define SCALEBITS  16
+
+F_0_114 equ  7471                ; FIX(0.11400)
+F_0_250 equ 16384                ; FIX(0.25000)
+F_0_299 equ 19595                ; FIX(0.29900)
+F_0_587 equ 38470                ; FIX(0.58700)
+F_0_337 equ (F_0_587 - F_0_250)  ; FIX(0.58700) - FIX(0.25000)
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_CONST
+
+    alignz      32
+    GLOBAL_DATA(jconst_rgb_gray_convert_avx2)
+
+EXTN(jconst_rgb_gray_convert_avx2):
+
+PW_F0299_F0337 times 8 dw F_0_299, F_0_337
+PW_F0114_F0250 times 8 dw F_0_114, F_0_250
+PD_ONEHALF     times 8 dd (1 << (SCALEBITS - 1))
+
+    alignz      32
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_TEXT
+    BITS        64
+
+%include "jcgryext-avx2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_RGB_RED
+%define RGB_GREEN  EXT_RGB_GREEN
+%define RGB_BLUE  EXT_RGB_BLUE
+%define RGB_PIXELSIZE  EXT_RGB_PIXELSIZE
+%define jsimd_rgb_gray_convert_avx2  jsimd_extrgb_gray_convert_avx2
+%include "jcgryext-avx2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_RGBX_RED
+%define RGB_GREEN  EXT_RGBX_GREEN
+%define RGB_BLUE  EXT_RGBX_BLUE
+%define RGB_PIXELSIZE  EXT_RGBX_PIXELSIZE
+%define jsimd_rgb_gray_convert_avx2  jsimd_extrgbx_gray_convert_avx2
+%include "jcgryext-avx2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_BGR_RED
+%define RGB_GREEN  EXT_BGR_GREEN
+%define RGB_BLUE  EXT_BGR_BLUE
+%define RGB_PIXELSIZE  EXT_BGR_PIXELSIZE
+%define jsimd_rgb_gray_convert_avx2  jsimd_extbgr_gray_convert_avx2
+%include "jcgryext-avx2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_BGRX_RED
+%define RGB_GREEN  EXT_BGRX_GREEN
+%define RGB_BLUE  EXT_BGRX_BLUE
+%define RGB_PIXELSIZE  EXT_BGRX_PIXELSIZE
+%define jsimd_rgb_gray_convert_avx2  jsimd_extbgrx_gray_convert_avx2
+%include "jcgryext-avx2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_XBGR_RED
+%define RGB_GREEN  EXT_XBGR_GREEN
+%define RGB_BLUE  EXT_XBGR_BLUE
+%define RGB_PIXELSIZE  EXT_XBGR_PIXELSIZE
+%define jsimd_rgb_gray_convert_avx2  jsimd_extxbgr_gray_convert_avx2
+%include "jcgryext-avx2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_XRGB_RED
+%define RGB_GREEN  EXT_XRGB_GREEN
+%define RGB_BLUE  EXT_XRGB_BLUE
+%define RGB_PIXELSIZE  EXT_XRGB_PIXELSIZE
+%define jsimd_rgb_gray_convert_avx2  jsimd_extxrgb_gray_convert_avx2
+%include "jcgryext-avx2.asm"
diff --git a/3rdparty/libjpeg/src/simd/x86_64/jcgray-sse2.asm b/3rdparty/libjpeg/src/simd/x86_64/jcgray-sse2.asm
new file mode 100644
index 00000000..e389904f
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/x86_64/jcgray-sse2.asm
@@ -0,0 +1,112 @@
+;
+; jcgray.asm - grayscale colorspace conversion (64-bit SSE2)
+;
+; Copyright (C) 2011, 2016, D. R. Commander.
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+;
+; This file should be assembled with NASM (Netwide Assembler),
+; can *not* be assembled with Microsoft's MASM or any compatible
+; assembler (including Borland's Turbo Assembler).
+; NASM is available from http://nasm.sourceforge.net/ or
+; http://sourceforge.net/project/showfiles.php?group_id=6208
+
+%include "jsimdext.inc"
+
+; --------------------------------------------------------------------------
+
+%define SCALEBITS  16
+
+F_0_114 equ  7471                ; FIX(0.11400)
+F_0_250 equ 16384                ; FIX(0.25000)
+F_0_299 equ 19595                ; FIX(0.29900)
+F_0_587 equ 38470                ; FIX(0.58700)
+F_0_337 equ (F_0_587 - F_0_250)  ; FIX(0.58700) - FIX(0.25000)
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_CONST
+
+    alignz      32
+    GLOBAL_DATA(jconst_rgb_gray_convert_sse2)
+
+EXTN(jconst_rgb_gray_convert_sse2):
+
+PW_F0299_F0337 times 4 dw F_0_299, F_0_337
+PW_F0114_F0250 times 4 dw F_0_114, F_0_250
+PD_ONEHALF     times 4 dd (1 << (SCALEBITS - 1))
+
+    alignz      32
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_TEXT
+    BITS        64
+
+%include "jcgryext-sse2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_RGB_RED
+%define RGB_GREEN  EXT_RGB_GREEN
+%define RGB_BLUE  EXT_RGB_BLUE
+%define RGB_PIXELSIZE  EXT_RGB_PIXELSIZE
+%define jsimd_rgb_gray_convert_sse2  jsimd_extrgb_gray_convert_sse2
+%include "jcgryext-sse2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_RGBX_RED
+%define RGB_GREEN  EXT_RGBX_GREEN
+%define RGB_BLUE  EXT_RGBX_BLUE
+%define RGB_PIXELSIZE  EXT_RGBX_PIXELSIZE
+%define jsimd_rgb_gray_convert_sse2  jsimd_extrgbx_gray_convert_sse2
+%include "jcgryext-sse2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_BGR_RED
+%define RGB_GREEN  EXT_BGR_GREEN
+%define RGB_BLUE  EXT_BGR_BLUE
+%define RGB_PIXELSIZE  EXT_BGR_PIXELSIZE
+%define jsimd_rgb_gray_convert_sse2  jsimd_extbgr_gray_convert_sse2
+%include "jcgryext-sse2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_BGRX_RED
+%define RGB_GREEN  EXT_BGRX_GREEN
+%define RGB_BLUE  EXT_BGRX_BLUE
+%define RGB_PIXELSIZE  EXT_BGRX_PIXELSIZE
+%define jsimd_rgb_gray_convert_sse2  jsimd_extbgrx_gray_convert_sse2
+%include "jcgryext-sse2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_XBGR_RED
+%define RGB_GREEN  EXT_XBGR_GREEN
+%define RGB_BLUE  EXT_XBGR_BLUE
+%define RGB_PIXELSIZE  EXT_XBGR_PIXELSIZE
+%define jsimd_rgb_gray_convert_sse2  jsimd_extxbgr_gray_convert_sse2
+%include "jcgryext-sse2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_XRGB_RED
+%define RGB_GREEN  EXT_XRGB_GREEN
+%define RGB_BLUE  EXT_XRGB_BLUE
+%define RGB_PIXELSIZE  EXT_XRGB_PIXELSIZE
+%define jsimd_rgb_gray_convert_sse2  jsimd_extxrgb_gray_convert_sse2
+%include "jcgryext-sse2.asm"
diff --git a/3rdparty/libjpeg/src/simd/x86_64/jcgryext-avx2.asm b/3rdparty/libjpeg/src/simd/x86_64/jcgryext-avx2.asm
new file mode 100644
index 00000000..ddcc2c0a
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/x86_64/jcgryext-avx2.asm
@@ -0,0 +1,438 @@
+;
+; jcgryext.asm - grayscale colorspace conversion (64-bit AVX2)
+;
+; Copyright (C) 2011, 2016, D. R. Commander.
+; Copyright (C) 2015, Intel Corporation.
+; Copyright (C) 2018, Matthias Räncker.
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+;
+; This file should be assembled with NASM (Netwide Assembler),
+; can *not* be assembled with Microsoft's MASM or any compatible
+; assembler (including Borland's Turbo Assembler).
+; NASM is available from http://nasm.sourceforge.net/ or
+; http://sourceforge.net/project/showfiles.php?group_id=6208
+
+%include "jcolsamp.inc"
+
+; --------------------------------------------------------------------------
+;
+; Convert some rows of samples to the output colorspace.
+;
+; GLOBAL(void)
+; jsimd_rgb_gray_convert_avx2(JDIMENSION img_width, JSAMPARRAY input_buf,
+;                             JSAMPIMAGE output_buf, JDIMENSION output_row,
+;                             int num_rows);
+;
+
+; r10d = JDIMENSION img_width
+; r11 = JSAMPARRAY input_buf
+; r12 = JSAMPIMAGE output_buf
+; r13d = JDIMENSION output_row
+; r14d = int num_rows
+
+%define wk(i)   rbp - (WK_NUM - (i)) * SIZEOF_YMMWORD  ; ymmword wk[WK_NUM]
+%define WK_NUM  2
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_rgb_gray_convert_avx2)
+
+EXTN(jsimd_rgb_gray_convert_avx2):
+    push        rbp
+    mov         rax, rsp                     ; rax = original rbp
+    sub         rsp, byte 4
+    and         rsp, byte (-SIZEOF_YMMWORD)  ; align to 256 bits
+    mov         [rsp], rax
+    mov         rbp, rsp                     ; rbp = aligned rbp
+    lea         rsp, [wk(0)]
+    collect_args 5
+    push        rbx
+
+    mov         ecx, r10d
+    test        rcx, rcx
+    jz          near .return
+
+    push        rcx
+
+    mov         rsi, r12
+    mov         ecx, r13d
+    mov         rdip, JSAMPARRAY [rsi+0*SIZEOF_JSAMPARRAY]
+    lea         rdi, [rdi+rcx*SIZEOF_JSAMPROW]
+
+    pop         rcx
+
+    mov         rsi, r11
+    mov         eax, r14d
+    test        rax, rax
+    jle         near .return
+.rowloop:
+    push        rdi
+    push        rsi
+    push        rcx                     ; col
+
+    mov         rsip, JSAMPROW [rsi]    ; inptr
+    mov         rdip, JSAMPROW [rdi]    ; outptr0
+
+    cmp         rcx, byte SIZEOF_YMMWORD
+    jae         near .columnloop
+
+%if RGB_PIXELSIZE == 3  ; ---------------
+
+.column_ld1:
+    push        rax
+    push        rdx
+    lea         rcx, [rcx+rcx*2]        ; imul ecx,RGB_PIXELSIZE
+    test        cl, SIZEOF_BYTE
+    jz          short .column_ld2
+    sub         rcx, byte SIZEOF_BYTE
+    movzx       rax, byte [rsi+rcx]
+.column_ld2:
+    test        cl, SIZEOF_WORD
+    jz          short .column_ld4
+    sub         rcx, byte SIZEOF_WORD
+    movzx       rdx, word [rsi+rcx]
+    shl         rax, WORD_BIT
+    or          rax, rdx
+.column_ld4:
+    vmovd       xmmA, eax
+    pop         rdx
+    pop         rax
+    test        cl, SIZEOF_DWORD
+    jz          short .column_ld8
+    sub         rcx, byte SIZEOF_DWORD
+    vmovd       xmmF, XMM_DWORD [rsi+rcx]
+    vpslldq     xmmA, xmmA, SIZEOF_DWORD
+    vpor        xmmA, xmmA, xmmF
+.column_ld8:
+    test        cl, SIZEOF_MMWORD
+    jz          short .column_ld16
+    sub         rcx, byte SIZEOF_MMWORD
+    vmovq       xmmB, XMM_MMWORD [rsi+rcx]
+    vpslldq     xmmA, xmmA, SIZEOF_MMWORD
+    vpor        xmmA, xmmA, xmmB
+.column_ld16:
+    test        cl, SIZEOF_XMMWORD
+    jz          short .column_ld32
+    sub         rcx, byte SIZEOF_XMMWORD
+    vmovdqu     xmmB, XMM_MMWORD [rsi+rcx]
+    vperm2i128  ymmA, ymmA, ymmA, 1
+    vpor        ymmA, ymmB
+.column_ld32:
+    test        cl, SIZEOF_YMMWORD
+    jz          short .column_ld64
+    sub         rcx, byte SIZEOF_YMMWORD
+    vmovdqa     ymmF, ymmA
+    vmovdqu     ymmA, YMMWORD [rsi+0*SIZEOF_YMMWORD]
+.column_ld64:
+    test        cl, 2*SIZEOF_YMMWORD
+    mov         rcx, SIZEOF_YMMWORD
+    jz          short .rgb_gray_cnv
+    vmovdqa     ymmB, ymmA
+    vmovdqu     ymmA, YMMWORD [rsi+0*SIZEOF_YMMWORD]
+    vmovdqu     ymmF, YMMWORD [rsi+1*SIZEOF_YMMWORD]
+    jmp         short .rgb_gray_cnv
+
+.columnloop:
+    vmovdqu     ymmA, YMMWORD [rsi+0*SIZEOF_YMMWORD]
+    vmovdqu     ymmF, YMMWORD [rsi+1*SIZEOF_YMMWORD]
+    vmovdqu     ymmB, YMMWORD [rsi+2*SIZEOF_YMMWORD]
+
+.rgb_gray_cnv:
+    ; ymmA=(00 10 20 01 11 21 02 12 22 03 13 23 04 14 24 05
+    ;       15 25 06 16 26 07 17 27 08 18 28 09 19 29 0A 1A)
+    ; ymmF=(2A 0B 1B 2B 0C 1C 2C 0D 1D 2D 0E 1E 2E 0F 1F 2F
+    ;       0G 1G 2G 0H 1H 2H 0I 1I 2I 0J 1J 2J 0K 1K 2K 0L)
+    ; ymmB=(1L 2L 0M 1M 2M 0N 1N 2N 0O 1O 2O 0P 1P 2P 0Q 1Q
+    ;       2Q 0R 1R 2R 0S 1S 2S 0T 1T 2T 0U 1U 2U 0V 1V 2V)
+
+    vmovdqu     ymmC, ymmA
+    vinserti128 ymmA, ymmF, xmmA, 0  ; ymmA=(00 10 20 01 11 21 02 12 22 03 13 23 04 14 24 05
+                                     ;       0G 1G 2G 0H 1H 2H 0I 1I 2I 0J 1J 2J 0K 1K 2K 0L)
+    vinserti128 ymmC, ymmC, xmmB, 0  ; ymmC=(1L 2L 0M 1M 2M 0N 1N 2N 0O 1O 2O 0P 1P 2P 0Q 1Q
+                                     ;       15 25 06 16 26 07 17 27 08 18 28 09 19 29 0A 1A)
+    vinserti128 ymmB, ymmB, xmmF, 0  ; ymmB=(2A 0B 1B 2B 0C 1C 2C 0D 1D 2D 0E 1E 2E 0F 1F 2F
+                                     ;       2Q 0R 1R 2R 0S 1S 2S 0T 1T 2T 0U 1U 2U 0V 1V 2V)
+    vperm2i128  ymmF, ymmC, ymmC, 1  ; ymmF=(15 25 06 16 26 07 17 27 08 18 28 09 19 29 0A 1A
+                                     ;       1L 2L 0M 1M 2M 0N 1N 2N 0O 1O 2O 0P 1P 2P 0Q 1Q)
+
+    vmovdqa     ymmG, ymmA
+    vpslldq     ymmA, ymmA, 8     ; ymmA=(-- -- -- -- -- -- -- -- 00 10 20 01 11 21 02 12
+                                  ;       22 03 13 23 04 14 24 05 0G 1G 2G 0H 1H 2H 0I 1I)
+    vpsrldq     ymmG, ymmG, 8     ; ymmG=(22 03 13 23 04 14 24 05 0G 1G 2G 0H 1H 2H 0I 1I
+                                  ;       2I 0J 1J 2J 0K 1K 2K 0L -- -- -- -- -- -- -- --)
+
+    vpunpckhbw  ymmA, ymmA, ymmF  ; ymmA=(00 08 10 18 20 28 01 09 11 19 21 29 02 0A 12 1A
+                                  ;       0G 0O 1G 1O 2G 2O 0H 0P 1H 1P 2H 2P 0I 0Q 1I 1Q)
+    vpslldq     ymmF, ymmF, 8     ; ymmF=(-- -- -- -- -- -- -- -- 15 25 06 16 26 07 17 27
+                                  ;       08 18 28 09 19 29 0A 1A 1L 2L 0M 1M 2M 0N 1N 2N)
+
+    vpunpcklbw  ymmG, ymmG, ymmB  ; ymmG=(22 2A 03 0B 13 1B 23 2B 04 0C 14 1C 24 2C 05 0D
+                                  ;       2I 2Q 0J 0R 1J 1R 2J 2R 0K 0S 1K 1S 2K 2S 0L 0T)
+    vpunpckhbw  ymmF, ymmF, ymmB  ; ymmF=(15 1D 25 2D 06 0E 16 1E 26 2E 07 0F 17 1F 27 2F
+                                  ;       1L 1T 2L 2T 0M 0U 1M 1U 2M 2U 0N 0V 1N 1V 2N 2V)
+
+    vmovdqa     ymmD, ymmA
+    vpslldq     ymmA, ymmA, 8     ; ymmA=(-- -- -- -- -- -- -- -- 00 08 10 18 20 28 01 09
+                                  ;       11 19 21 29 02 0A 12 1A 0G 0O 1G 1O 2G 2O 0H 0P)
+    vpsrldq     ymmD, ymmD, 8     ; ymmD=(11 19 21 29 02 0A 12 1A 0G 0O 1G 1O 2G 2O 0H 0P
+                                  ;       1H 1P 2H 2P 0I 0Q 1I 1Q -- -- -- -- -- -- -- --)
+
+    vpunpckhbw  ymmA, ymmA, ymmG  ; ymmA=(00 04 08 0C 10 14 18 1C 20 24 28 2C 01 05 09 0D
+                                  ;       0G 0K 0O 0S 1G 1K 1O 1S 2G 2K 2O 2S 0H 0L 0P 0T)
+    vpslldq     ymmG, ymmG, 8     ; ymmG=(-- -- -- -- -- -- -- -- 22 2A 03 0B 13 1B 23 2B
+                                  ;       04 0C 14 1C 24 2C 05 0D 2I 2Q 0J 0R 1J 1R 2J 2R)
+
+    vpunpcklbw  ymmD, ymmD, ymmF  ; ymmD=(11 15 19 1D 21 25 29 2D 02 06 0A 0E 12 16 1A 1E
+                                  ;       1H 1L 1P 1T 2H 2L 2P 2T 0I 0M 0Q 0U 1I 1M 1Q 1U)
+    vpunpckhbw  ymmG, ymmG, ymmF  ; ymmG=(22 26 2A 2E 03 07 0B 0F 13 17 1B 1F 23 27 2B 2F
+                                  ;       2I 2M 2Q 2U 0J 0N 0R 0V 1J 1N 1R 1V 2J 2N 2R 2V)
+
+    vmovdqa     ymmE, ymmA
+    vpslldq     ymmA, ymmA, 8     ; ymmA=(-- -- -- -- -- -- -- -- 00 04 08 0C 10 14 18 1C
+                                  ;       20 24 28 2C 01 05 09 0D 0G 0K 0O 0S 1G 1K 1O 1S)
+    vpsrldq     ymmE, ymmE, 8     ; ymmE=(20 24 28 2C 01 05 09 0D 0G 0K 0O 0S 1G 1K 1O 1S
+                                  ;       2G 2K 2O 2S 0H 0L 0P 0T -- -- -- -- -- -- -- --)
+
+    vpunpckhbw  ymmA, ymmA, ymmD  ; ymmA=(00 02 04 06 08 0A 0C 0E 10 12 14 16 18 1A 1C 1E
+                                  ;       0G 0I 0K 0M 0O 0Q 0S 0U 1G 1I 1K 1M 1O 1Q 1S 1U)
+    vpslldq     ymmD, ymmD, 8     ; ymmD=(-- -- -- -- -- -- -- -- 11 15 19 1D 21 25 29 2D
+                                  ;       02 06 0A 0E 12 16 1A 1E 1H 1L 1P 1T 2H 2L 2P 2T)
+
+    vpunpcklbw  ymmE, ymmE, ymmG  ; ymmE=(20 22 24 26 28 2A 2C 2E 01 03 05 07 09 0B 0D 0F
+                                  ;       2G 2I 2K 2M 2O 2Q 2S 2U 0H 0J 0L 0N 0P 0R 0T 0V)
+    vpunpckhbw  ymmD, ymmD, ymmG  ; ymmD=(11 13 15 17 19 1B 1D 1F 21 23 25 27 29 2B 2D 2F
+                                  ;       1H 1J 1L 1N 1P 1R 1T 1V 2H 2J 2L 2N 2P 2R 2T 2V)
+
+    vpxor       ymmH, ymmH, ymmH
+
+    vmovdqa     ymmC, ymmA
+    vpunpcklbw  ymmA, ymmA, ymmH  ; ymmA=(00 02 04 06 08 0A 0C 0E 0G 0I 0K 0M 0O 0Q 0S 0U)
+    vpunpckhbw  ymmC, ymmC, ymmH  ; ymmC=(10 12 14 16 18 1A 1C 1E 1G 1I 1K 1M 1O 1Q 1S 1U)
+
+    vmovdqa     ymmB, ymmE
+    vpunpcklbw  ymmE, ymmE, ymmH  ; ymmE=(20 22 24 26 28 2A 2C 2E 2G 2I 2K 2M 2O 2Q 2S 2U)
+    vpunpckhbw  ymmB, ymmB, ymmH  ; ymmB=(01 03 05 07 09 0B 0D 0F 0H 0J 0L 0N 0P 0R 0T 0V)
+
+    vmovdqa     ymmF, ymmD
+    vpunpcklbw  ymmD, ymmD, ymmH  ; ymmD=(11 13 15 17 19 1B 1D 1F 1H 1J 1L 1N 1P 1R 1T 1V)
+    vpunpckhbw  ymmF, ymmF, ymmH  ; ymmF=(21 23 25 27 29 2B 2D 2F 2H 2J 2L 2N 2P 2R 2T 2V)
+
+%else  ; RGB_PIXELSIZE == 4 ; -----------
+
+.column_ld1:
+    test        cl, SIZEOF_XMMWORD/16
+    jz          short .column_ld2
+    sub         rcx, byte SIZEOF_XMMWORD/16
+    vmovd       xmmA, XMM_DWORD [rsi+rcx*RGB_PIXELSIZE]
+.column_ld2:
+    test        cl, SIZEOF_XMMWORD/8
+    jz          short .column_ld4
+    sub         rcx, byte SIZEOF_XMMWORD/8
+    vmovq       xmmF, XMM_MMWORD [rsi+rcx*RGB_PIXELSIZE]
+    vpslldq     xmmA, xmmA, SIZEOF_MMWORD
+    vpor        xmmA, xmmA, xmmF
+.column_ld4:
+    test        cl, SIZEOF_XMMWORD/4
+    jz          short .column_ld8
+    sub         rcx, byte SIZEOF_XMMWORD/4
+    vmovdqa     xmmF, xmmA
+    vperm2i128  ymmF, ymmF, ymmF, 1
+    vmovdqu     xmmA, XMMWORD [rsi+rcx*RGB_PIXELSIZE]
+    vpor        ymmA, ymmA, ymmF
+.column_ld8:
+    test        cl, SIZEOF_XMMWORD/2
+    jz          short .column_ld16
+    sub         rcx, byte SIZEOF_XMMWORD/2
+    vmovdqa     ymmF, ymmA
+    vmovdqu     ymmA, YMMWORD [rsi+rcx*RGB_PIXELSIZE]
+.column_ld16:
+    test        cl, SIZEOF_XMMWORD
+    mov         rcx, SIZEOF_YMMWORD
+    jz          short .rgb_gray_cnv
+    vmovdqa     ymmE, ymmA
+    vmovdqa     ymmH, ymmF
+    vmovdqu     ymmA, YMMWORD [rsi+0*SIZEOF_YMMWORD]
+    vmovdqu     ymmF, YMMWORD [rsi+1*SIZEOF_YMMWORD]
+    jmp         short .rgb_gray_cnv
+
+.columnloop:
+    vmovdqu     ymmA, YMMWORD [rsi+0*SIZEOF_YMMWORD]
+    vmovdqu     ymmF, YMMWORD [rsi+1*SIZEOF_YMMWORD]
+    vmovdqu     ymmE, YMMWORD [rsi+2*SIZEOF_YMMWORD]
+    vmovdqu     ymmH, YMMWORD [rsi+3*SIZEOF_YMMWORD]
+
+.rgb_gray_cnv:
+    ; ymmA=(00 10 20 30 01 11 21 31 02 12 22 32 03 13 23 33
+    ;       04 14 24 34 05 15 25 35 06 16 26 36 07 17 27 37)
+    ; ymmF=(08 18 28 38 09 19 29 39 0A 1A 2A 3A 0B 1B 2B 3B
+    ;       0C 1C 2C 3C 0D 1D 2D 3D 0E 1E 2E 3E 0F 1F 2F 3F)
+    ; ymmE=(0G 1G 2G 3G 0H 1H 2H 3H 0I 1I 2I 3I 0J 1J 2J 3J
+    ;       0K 1K 2K 3K 0L 1L 2L 3L 0M 1M 2M 3M 0N 1N 2N 3N)
+    ; ymmH=(0O 1O 2O 3O 0P 1P 2P 3P 0Q 1Q 2Q 3Q 0R 1R 2R 3R
+    ;       0S 1S 2S 3S 0T 1T 2T 3T 0U 1U 2U 3U 0V 1V 2V 3V)
+
+    vmovdqa     ymmB, ymmA
+    vinserti128 ymmA, ymmA, xmmE, 1     ; ymmA=(00 10 20 30 01 11 21 31 02 12 22 32 03 13 23 33
+                                        ;       0G 1G 2G 3G 0H 1H 2H 3H 0I 1I 2I 3I 0J 1J 2J 3J)
+    vperm2i128  ymmE, ymmB, ymmE, 0x31  ; ymmE=(04 14 24 34 05 15 25 35 06 16 26 36 07 17 27 37
+                                        ;       0K 1K 2K 3K 0L 1L 2L 3L 0M 1M 2M 3M 0N 1N 2N 3N)
+
+    vmovdqa     ymmB, ymmF
+    vinserti128 ymmF, ymmF, xmmH, 1     ; ymmF=(08 18 28 38 09 19 29 39 0A 1A 2A 3A 0B 1B 2B 3B
+                                        ;       0O 1O 2O 3O 0P 1P 2P 3P 0Q 1Q 2Q 3Q 0R 1R 2R 3R)
+    vperm2i128  ymmH, ymmB, ymmH, 0x31  ; ymmH=(0C 1C 2C 3C 0D 1D 2D 3D 0E 1E 2E 3E 0F 1F 2F 3F
+                                        ;       0S 1S 2S 3S 0T 1T 2T 3T 0U 1U 2U 3U 0V 1V 2V 3V)
+
+    vmovdqa     ymmD, ymmA
+    vpunpcklbw  ymmA, ymmA, ymmE      ; ymmA=(00 04 10 14 20 24 30 34 01 05 11 15 21 25 31 35
+                                      ;       0G 0K 1G 1K 2G 2K 3G 3K 0H 0L 1H 1L 2H 2L 3H 3L)
+    vpunpckhbw  ymmD, ymmD, ymmE      ; ymmD=(02 06 12 16 22 26 32 36 03 07 13 17 23 27 33 37
+                                      ;       0I 0M 1I 1M 2I 2M 3I 3M 0J 0N 1J 1N 2J 2N 3J 3N)
+
+    vmovdqa     ymmC, ymmF
+    vpunpcklbw  ymmF, ymmF, ymmH      ; ymmF=(08 0C 18 1C 28 2C 38 3C 09 0D 19 1D 29 2D 39 3D
+                                      ;       0O 0S 1O 1S 2O 2S 3O 3S 0P 0T 1P 1T 2P 2T 3P 3T)
+    vpunpckhbw  ymmC, ymmC, ymmH      ; ymmC=(0A 0E 1A 1E 2A 2E 3A 3E 0B 0F 1B 1F 2B 2F 3B 3F
+                                      ;       0Q 0U 1Q 1U 2Q 2U 3Q 3U 0R 0V 1R 1V 2R 2V 3R 3V)
+
+    vmovdqa     ymmB, ymmA
+    vpunpcklwd  ymmA, ymmA, ymmF      ; ymmA=(00 04 08 0C 10 14 18 1C 20 24 28 2C 30 34 38 3C
+                                      ;       0G 0K 0O 0S 1G 1K 1O 1S 2G 2K 2O 2S 3G 3K 3O 3S)
+    vpunpckhwd  ymmB, ymmB, ymmF      ; ymmB=(01 05 09 0D 11 15 19 1D 21 25 29 2D 31 35 39 3D
+                                      ;       0H 0L 0P 0T 1H 1L 1P 1T 2H 2L 2P 2T 3H 3L 3P 3T)
+
+    vmovdqa     ymmG, ymmD
+    vpunpcklwd  ymmD, ymmD, ymmC      ; ymmD=(02 06 0A 0E 12 16 1A 1E 22 26 2A 2E 32 36 3A 3E
+                                      ;       0I 0M 0Q 0U 1I 1M 1Q 1U 2I 2M 2Q 2U 3I 3M 3Q 3U)
+    vpunpckhwd  ymmG, ymmG, ymmC      ; ymmG=(03 07 0B 0F 13 17 1B 1F 23 27 2B 2F 33 37 3B 3F
+                                      ;       0J 0N 0R 0V 1J 1N 1R 1V 2J 2N 2R 2V 3J 3N 3R 3V)
+
+    vmovdqa     ymmE, ymmA
+    vpunpcklbw  ymmA, ymmA, ymmD      ; ymmA=(00 02 04 06 08 0A 0C 0E 10 12 14 16 18 1A 1C 1E
+                                      ;       0G 0I 0K 0M 0O 0Q 0S 0U 1G 1I 1K 1M 1O 1Q 1S 1U)
+    vpunpckhbw  ymmE, ymmE, ymmD      ; ymmE=(20 22 24 26 28 2A 2C 2E 30 32 34 36 38 3A 3C 3E
+                                      ;       2G 2I 2K 2M 2O 2Q 2S 2U 3G 3I 3K 3M 3O 3Q 3S 3U)
+
+    vmovdqa     ymmH, ymmB
+    vpunpcklbw  ymmB, ymmB, ymmG      ; ymmB=(01 03 05 07 09 0B 0D 0F 11 13 15 17 19 1B 1D 1F
+                                      ;       0H 0J 0L 0N 0P 0R 0T 0V 1H 1J 1L 1N 1P 1R 1T 1V)
+    vpunpckhbw  ymmH, ymmH, ymmG      ; ymmH=(21 23 25 27 29 2B 2D 2F 31 33 35 37 39 3B 3D 3F
+                                      ;       2H 2J 2L 2N 2P 2R 2T 2V 3H 3J 3L 3N 3P 3R 3T 3V)
+
+    vpxor       ymmF, ymmF, ymmF
+
+    vmovdqa     ymmC, ymmA
+    vpunpcklbw  ymmA, ymmA, ymmF      ; ymmA=(00 02 04 06 08 0A 0C 0E 0G 0I 0K 0M 0O 0Q 0S 0U)
+    vpunpckhbw  ymmC, ymmC, ymmF      ; ymmC=(10 12 14 16 18 1A 1C 1E 1G 1I 1K 1M 1O 1Q 1S 1U)
+
+    vmovdqa     ymmD, ymmB
+    vpunpcklbw  ymmB, ymmB, ymmF      ; ymmB=(01 03 05 07 09 0B 0D 0F 0H 0J 0L 0N 0P 0R 0T 0V)
+    vpunpckhbw  ymmD, ymmD, ymmF      ; ymmD=(11 13 15 17 19 1B 1D 1F 1H 1J 1L 1N 1P 1R 1T 1V)
+
+    vmovdqa     ymmG, ymmE
+    vpunpcklbw  ymmE, ymmE, ymmF      ; ymmE=(20 22 24 26 28 2A 2C 2E 2G 2I 2K 2M 2O 2Q 2S 2U)
+    vpunpckhbw  ymmG, ymmG, ymmF      ; ymmG=(30 32 34 36 38 3A 3C 3E 3G 3I 3K 3M 3O 3Q 3S 3U)
+
+    vpunpcklbw  ymmF, ymmF, ymmH
+    vpunpckhbw  ymmH, ymmH, ymmH
+    vpsrlw      ymmF, ymmF, BYTE_BIT  ; ymmF=(21 23 25 27 29 2B 2D 2F 2H 2J 2L 2N 2P 2R 2T 2V)
+    vpsrlw      ymmH, ymmH, BYTE_BIT  ; ymmH=(31 33 35 37 39 3B 3D 3F 3H 3J 3L 3N 3P 3R 3T 3V)
+
+%endif  ; RGB_PIXELSIZE ; ---------------
+
+    ; ymm0=R(02468ACEGIKMOQSU)=RE, ymm2=G(02468ACEGIKMOQSU)=GE, ymm4=B(02468ACEGIKMOQSU)=BE
+    ; ymm1=R(13579BDFHJLNPRTV)=RO, ymm3=G(13579BDFHJLNPRTV)=GO, ymm5=B(13579BDFHJLNPRTV)=BO
+
+    ; (Original)
+    ; Y  =  0.29900 * R + 0.58700 * G + 0.11400 * B
+    ;
+    ; (This implementation)
+    ; Y  =  0.29900 * R + 0.33700 * G + 0.11400 * B + 0.25000 * G
+
+    vmovdqa     ymm6, ymm1
+    vpunpcklwd  ymm1, ymm1, ymm3
+    vpunpckhwd  ymm6, ymm6, ymm3
+    vpmaddwd    ymm1, ymm1, [rel PW_F0299_F0337]  ; ymm1=ROL*FIX(0.299)+GOL*FIX(0.337)
+    vpmaddwd    ymm6, ymm6, [rel PW_F0299_F0337]  ; ymm6=ROH*FIX(0.299)+GOH*FIX(0.337)
+
+    vmovdqa     ymm7, ymm6              ; ymm7=ROH*FIX(0.299)+GOH*FIX(0.337)
+
+    vmovdqa     ymm6, ymm0
+    vpunpcklwd  ymm0, ymm0, ymm2
+    vpunpckhwd  ymm6, ymm6, ymm2
+    vpmaddwd    ymm0, ymm0, [rel PW_F0299_F0337]  ; ymm0=REL*FIX(0.299)+GEL*FIX(0.337)
+    vpmaddwd    ymm6, ymm6, [rel PW_F0299_F0337]  ; ymm6=REH*FIX(0.299)+GEH*FIX(0.337)
+
+    vmovdqa     YMMWORD [wk(0)], ymm0   ; wk(0)=REL*FIX(0.299)+GEL*FIX(0.337)
+    vmovdqa     YMMWORD [wk(1)], ymm6   ; wk(1)=REH*FIX(0.299)+GEH*FIX(0.337)
+
+    vmovdqa     ymm0, ymm5              ; ymm0=BO
+    vmovdqa     ymm6, ymm4              ; ymm6=BE
+
+    vmovdqa     ymm4, ymm0
+    vpunpcklwd  ymm0, ymm0, ymm3
+    vpunpckhwd  ymm4, ymm4, ymm3
+    vpmaddwd    ymm0, ymm0, [rel PW_F0114_F0250]  ; ymm0=BOL*FIX(0.114)+GOL*FIX(0.250)
+    vpmaddwd    ymm4, ymm4, [rel PW_F0114_F0250]  ; ymm4=BOH*FIX(0.114)+GOH*FIX(0.250)
+
+    vmovdqa     ymm3, [rel PD_ONEHALF]            ; ymm3=[PD_ONEHALF]
+
+    vpaddd      ymm0, ymm0, ymm1
+    vpaddd      ymm4, ymm4, ymm7
+    vpaddd      ymm0, ymm0, ymm3
+    vpaddd      ymm4, ymm4, ymm3
+    vpsrld      ymm0, ymm0, SCALEBITS   ; ymm0=YOL
+    vpsrld      ymm4, ymm4, SCALEBITS   ; ymm4=YOH
+    vpackssdw   ymm0, ymm0, ymm4        ; ymm0=YO
+
+    vmovdqa     ymm4, ymm6
+    vpunpcklwd  ymm6, ymm6, ymm2
+    vpunpckhwd  ymm4, ymm4, ymm2
+    vpmaddwd    ymm6, ymm6, [rel PW_F0114_F0250]  ; ymm6=BEL*FIX(0.114)+GEL*FIX(0.250)
+    vpmaddwd    ymm4, ymm4, [rel PW_F0114_F0250]  ; ymm4=BEH*FIX(0.114)+GEH*FIX(0.250)
+
+    vmovdqa     ymm2, [rel PD_ONEHALF]            ; ymm2=[PD_ONEHALF]
+
+    vpaddd      ymm6, ymm6, YMMWORD [wk(0)]
+    vpaddd      ymm4, ymm4, YMMWORD [wk(1)]
+    vpaddd      ymm6, ymm6, ymm2
+    vpaddd      ymm4, ymm4, ymm2
+    vpsrld      ymm6, ymm6, SCALEBITS   ; ymm6=YEL
+    vpsrld      ymm4, ymm4, SCALEBITS   ; ymm4=YEH
+    vpackssdw   ymm6, ymm6, ymm4        ; ymm6=YE
+
+    vpsllw      ymm0, ymm0, BYTE_BIT
+    vpor        ymm6, ymm6, ymm0        ; ymm6=Y
+    vmovdqu     YMMWORD [rdi], ymm6     ; Save Y
+
+    sub         rcx, byte SIZEOF_YMMWORD
+    add         rsi, RGB_PIXELSIZE*SIZEOF_YMMWORD  ; inptr
+    add         rdi, byte SIZEOF_YMMWORD           ; outptr0
+    cmp         rcx, byte SIZEOF_YMMWORD
+    jae         near .columnloop
+    test        rcx, rcx
+    jnz         near .column_ld1
+
+    pop         rcx                     ; col
+    pop         rsi
+    pop         rdi
+
+    add         rsi, byte SIZEOF_JSAMPROW  ; input_buf
+    add         rdi, byte SIZEOF_JSAMPROW
+    dec         rax                        ; num_rows
+    jg          near .rowloop
+
+.return:
+    pop         rbx
+    vzeroupper
+    uncollect_args 5
+    mov         rsp, rbp                ; rsp <- aligned rbp
+    pop         rsp                     ; rsp <- original rbp
+    pop         rbp
+    ret
+
+; For some reason, the OS X linker does not honor the request to align the
+; segment unless we do this.
+    align       32
diff --git a/3rdparty/libjpeg/src/simd/x86_64/jcgryext-sse2.asm b/3rdparty/libjpeg/src/simd/x86_64/jcgryext-sse2.asm
new file mode 100644
index 00000000..f1d399a6
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/x86_64/jcgryext-sse2.asm
@@ -0,0 +1,363 @@
+;
+; jcgryext.asm - grayscale colorspace conversion (64-bit SSE2)
+;
+; Copyright (C) 2011, 2016, D. R. Commander.
+; Copyright (C) 2018, Matthias Räncker.
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+;
+; This file should be assembled with NASM (Netwide Assembler),
+; can *not* be assembled with Microsoft's MASM or any compatible
+; assembler (including Borland's Turbo Assembler).
+; NASM is available from http://nasm.sourceforge.net/ or
+; http://sourceforge.net/project/showfiles.php?group_id=6208
+
+%include "jcolsamp.inc"
+
+; --------------------------------------------------------------------------
+;
+; Convert some rows of samples to the output colorspace.
+;
+; GLOBAL(void)
+; jsimd_rgb_gray_convert_sse2(JDIMENSION img_width, JSAMPARRAY input_buf,
+;                             JSAMPIMAGE output_buf, JDIMENSION output_row,
+;                             int num_rows);
+;
+
+; r10d = JDIMENSION img_width
+; r11 = JSAMPARRAY input_buf
+; r12 = JSAMPIMAGE output_buf
+; r13d = JDIMENSION output_row
+; r14d = int num_rows
+
+%define wk(i)   rbp - (WK_NUM - (i)) * SIZEOF_XMMWORD  ; xmmword wk[WK_NUM]
+%define WK_NUM  2
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_rgb_gray_convert_sse2)
+
+EXTN(jsimd_rgb_gray_convert_sse2):
+    push        rbp
+    mov         rax, rsp                     ; rax = original rbp
+    sub         rsp, byte 4
+    and         rsp, byte (-SIZEOF_XMMWORD)  ; align to 128 bits
+    mov         [rsp], rax
+    mov         rbp, rsp                     ; rbp = aligned rbp
+    lea         rsp, [wk(0)]
+    collect_args 5
+    push        rbx
+
+    mov         ecx, r10d
+    test        rcx, rcx
+    jz          near .return
+
+    push        rcx
+
+    mov         rsi, r12
+    mov         ecx, r13d
+    mov         rdip, JSAMPARRAY [rsi+0*SIZEOF_JSAMPARRAY]
+    lea         rdi, [rdi+rcx*SIZEOF_JSAMPROW]
+
+    pop         rcx
+
+    mov         rsi, r11
+    mov         eax, r14d
+    test        rax, rax
+    jle         near .return
+.rowloop:
+    push        rdi
+    push        rsi
+    push        rcx                     ; col
+
+    mov         rsip, JSAMPROW [rsi]    ; inptr
+    mov         rdip, JSAMPROW [rdi]    ; outptr0
+
+    cmp         rcx, byte SIZEOF_XMMWORD
+    jae         near .columnloop
+
+%if RGB_PIXELSIZE == 3  ; ---------------
+
+.column_ld1:
+    push        rax
+    push        rdx
+    lea         rcx, [rcx+rcx*2]        ; imul ecx,RGB_PIXELSIZE
+    test        cl, SIZEOF_BYTE
+    jz          short .column_ld2
+    sub         rcx, byte SIZEOF_BYTE
+    movzx       rax, byte [rsi+rcx]
+.column_ld2:
+    test        cl, SIZEOF_WORD
+    jz          short .column_ld4
+    sub         rcx, byte SIZEOF_WORD
+    movzx       rdx, word [rsi+rcx]
+    shl         rax, WORD_BIT
+    or          rax, rdx
+.column_ld4:
+    movd        xmmA, eax
+    pop         rdx
+    pop         rax
+    test        cl, SIZEOF_DWORD
+    jz          short .column_ld8
+    sub         rcx, byte SIZEOF_DWORD
+    movd        xmmF, XMM_DWORD [rsi+rcx]
+    pslldq      xmmA, SIZEOF_DWORD
+    por         xmmA, xmmF
+.column_ld8:
+    test        cl, SIZEOF_MMWORD
+    jz          short .column_ld16
+    sub         rcx, byte SIZEOF_MMWORD
+    movq        xmmB, XMM_MMWORD [rsi+rcx]
+    pslldq      xmmA, SIZEOF_MMWORD
+    por         xmmA, xmmB
+.column_ld16:
+    test        cl, SIZEOF_XMMWORD
+    jz          short .column_ld32
+    movdqa      xmmF, xmmA
+    movdqu      xmmA, XMMWORD [rsi+0*SIZEOF_XMMWORD]
+    mov         rcx, SIZEOF_XMMWORD
+    jmp         short .rgb_gray_cnv
+.column_ld32:
+    test        cl, 2*SIZEOF_XMMWORD
+    mov         rcx, SIZEOF_XMMWORD
+    jz          short .rgb_gray_cnv
+    movdqa      xmmB, xmmA
+    movdqu      xmmA, XMMWORD [rsi+0*SIZEOF_XMMWORD]
+    movdqu      xmmF, XMMWORD [rsi+1*SIZEOF_XMMWORD]
+    jmp         short .rgb_gray_cnv
+
+.columnloop:
+    movdqu      xmmA, XMMWORD [rsi+0*SIZEOF_XMMWORD]
+    movdqu      xmmF, XMMWORD [rsi+1*SIZEOF_XMMWORD]
+    movdqu      xmmB, XMMWORD [rsi+2*SIZEOF_XMMWORD]
+
+.rgb_gray_cnv:
+    ; xmmA=(00 10 20 01 11 21 02 12 22 03 13 23 04 14 24 05)
+    ; xmmF=(15 25 06 16 26 07 17 27 08 18 28 09 19 29 0A 1A)
+    ; xmmB=(2A 0B 1B 2B 0C 1C 2C 0D 1D 2D 0E 1E 2E 0F 1F 2F)
+
+    movdqa      xmmG, xmmA
+    pslldq      xmmA, 8     ; xmmA=(-- -- -- -- -- -- -- -- 00 10 20 01 11 21 02 12)
+    psrldq      xmmG, 8     ; xmmG=(22 03 13 23 04 14 24 05 -- -- -- -- -- -- -- --)
+
+    punpckhbw   xmmA, xmmF  ; xmmA=(00 08 10 18 20 28 01 09 11 19 21 29 02 0A 12 1A)
+    pslldq      xmmF, 8     ; xmmF=(-- -- -- -- -- -- -- -- 15 25 06 16 26 07 17 27)
+
+    punpcklbw   xmmG, xmmB  ; xmmG=(22 2A 03 0B 13 1B 23 2B 04 0C 14 1C 24 2C 05 0D)
+    punpckhbw   xmmF, xmmB  ; xmmF=(15 1D 25 2D 06 0E 16 1E 26 2E 07 0F 17 1F 27 2F)
+
+    movdqa      xmmD, xmmA
+    pslldq      xmmA, 8     ; xmmA=(-- -- -- -- -- -- -- -- 00 08 10 18 20 28 01 09)
+    psrldq      xmmD, 8     ; xmmD=(11 19 21 29 02 0A 12 1A -- -- -- -- -- -- -- --)
+
+    punpckhbw   xmmA, xmmG  ; xmmA=(00 04 08 0C 10 14 18 1C 20 24 28 2C 01 05 09 0D)
+    pslldq      xmmG, 8     ; xmmG=(-- -- -- -- -- -- -- -- 22 2A 03 0B 13 1B 23 2B)
+
+    punpcklbw   xmmD, xmmF  ; xmmD=(11 15 19 1D 21 25 29 2D 02 06 0A 0E 12 16 1A 1E)
+    punpckhbw   xmmG, xmmF  ; xmmG=(22 26 2A 2E 03 07 0B 0F 13 17 1B 1F 23 27 2B 2F)
+
+    movdqa      xmmE, xmmA
+    pslldq      xmmA, 8     ; xmmA=(-- -- -- -- -- -- -- -- 00 04 08 0C 10 14 18 1C)
+    psrldq      xmmE, 8     ; xmmE=(20 24 28 2C 01 05 09 0D -- -- -- -- -- -- -- --)
+
+    punpckhbw   xmmA, xmmD  ; xmmA=(00 02 04 06 08 0A 0C 0E 10 12 14 16 18 1A 1C 1E)
+    pslldq      xmmD, 8     ; xmmD=(-- -- -- -- -- -- -- -- 11 15 19 1D 21 25 29 2D)
+
+    punpcklbw   xmmE, xmmG  ; xmmE=(20 22 24 26 28 2A 2C 2E 01 03 05 07 09 0B 0D 0F)
+    punpckhbw   xmmD, xmmG  ; xmmD=(11 13 15 17 19 1B 1D 1F 21 23 25 27 29 2B 2D 2F)
+
+    pxor        xmmH, xmmH
+
+    movdqa      xmmC, xmmA
+    punpcklbw   xmmA, xmmH  ; xmmA=(00 02 04 06 08 0A 0C 0E)
+    punpckhbw   xmmC, xmmH  ; xmmC=(10 12 14 16 18 1A 1C 1E)
+
+    movdqa      xmmB, xmmE
+    punpcklbw   xmmE, xmmH  ; xmmE=(20 22 24 26 28 2A 2C 2E)
+    punpckhbw   xmmB, xmmH  ; xmmB=(01 03 05 07 09 0B 0D 0F)
+
+    movdqa      xmmF, xmmD
+    punpcklbw   xmmD, xmmH  ; xmmD=(11 13 15 17 19 1B 1D 1F)
+    punpckhbw   xmmF, xmmH  ; xmmF=(21 23 25 27 29 2B 2D 2F)
+
+%else  ; RGB_PIXELSIZE == 4 ; -----------
+
+.column_ld1:
+    test        cl, SIZEOF_XMMWORD/16
+    jz          short .column_ld2
+    sub         rcx, byte SIZEOF_XMMWORD/16
+    movd        xmmA, XMM_DWORD [rsi+rcx*RGB_PIXELSIZE]
+.column_ld2:
+    test        cl, SIZEOF_XMMWORD/8
+    jz          short .column_ld4
+    sub         rcx, byte SIZEOF_XMMWORD/8
+    movq        xmmE, XMM_MMWORD [rsi+rcx*RGB_PIXELSIZE]
+    pslldq      xmmA, SIZEOF_MMWORD
+    por         xmmA, xmmE
+.column_ld4:
+    test        cl, SIZEOF_XMMWORD/4
+    jz          short .column_ld8
+    sub         rcx, byte SIZEOF_XMMWORD/4
+    movdqa      xmmE, xmmA
+    movdqu      xmmA, XMMWORD [rsi+rcx*RGB_PIXELSIZE]
+.column_ld8:
+    test        cl, SIZEOF_XMMWORD/2
+    mov         rcx, SIZEOF_XMMWORD
+    jz          short .rgb_gray_cnv
+    movdqa      xmmF, xmmA
+    movdqa      xmmH, xmmE
+    movdqu      xmmA, XMMWORD [rsi+0*SIZEOF_XMMWORD]
+    movdqu      xmmE, XMMWORD [rsi+1*SIZEOF_XMMWORD]
+    jmp         short .rgb_gray_cnv
+
+.columnloop:
+    movdqu      xmmA, XMMWORD [rsi+0*SIZEOF_XMMWORD]
+    movdqu      xmmE, XMMWORD [rsi+1*SIZEOF_XMMWORD]
+    movdqu      xmmF, XMMWORD [rsi+2*SIZEOF_XMMWORD]
+    movdqu      xmmH, XMMWORD [rsi+3*SIZEOF_XMMWORD]
+
+.rgb_gray_cnv:
+    ; xmmA=(00 10 20 30 01 11 21 31 02 12 22 32 03 13 23 33)
+    ; xmmE=(04 14 24 34 05 15 25 35 06 16 26 36 07 17 27 37)
+    ; xmmF=(08 18 28 38 09 19 29 39 0A 1A 2A 3A 0B 1B 2B 3B)
+    ; xmmH=(0C 1C 2C 3C 0D 1D 2D 3D 0E 1E 2E 3E 0F 1F 2F 3F)
+
+    movdqa      xmmD, xmmA
+    punpcklbw   xmmA, xmmE      ; xmmA=(00 04 10 14 20 24 30 34 01 05 11 15 21 25 31 35)
+    punpckhbw   xmmD, xmmE      ; xmmD=(02 06 12 16 22 26 32 36 03 07 13 17 23 27 33 37)
+
+    movdqa      xmmC, xmmF
+    punpcklbw   xmmF, xmmH      ; xmmF=(08 0C 18 1C 28 2C 38 3C 09 0D 19 1D 29 2D 39 3D)
+    punpckhbw   xmmC, xmmH      ; xmmC=(0A 0E 1A 1E 2A 2E 3A 3E 0B 0F 1B 1F 2B 2F 3B 3F)
+
+    movdqa      xmmB, xmmA
+    punpcklwd   xmmA, xmmF      ; xmmA=(00 04 08 0C 10 14 18 1C 20 24 28 2C 30 34 38 3C)
+    punpckhwd   xmmB, xmmF      ; xmmB=(01 05 09 0D 11 15 19 1D 21 25 29 2D 31 35 39 3D)
+
+    movdqa      xmmG, xmmD
+    punpcklwd   xmmD, xmmC      ; xmmD=(02 06 0A 0E 12 16 1A 1E 22 26 2A 2E 32 36 3A 3E)
+    punpckhwd   xmmG, xmmC      ; xmmG=(03 07 0B 0F 13 17 1B 1F 23 27 2B 2F 33 37 3B 3F)
+
+    movdqa      xmmE, xmmA
+    punpcklbw   xmmA, xmmD      ; xmmA=(00 02 04 06 08 0A 0C 0E 10 12 14 16 18 1A 1C 1E)
+    punpckhbw   xmmE, xmmD      ; xmmE=(20 22 24 26 28 2A 2C 2E 30 32 34 36 38 3A 3C 3E)
+
+    movdqa      xmmH, xmmB
+    punpcklbw   xmmB, xmmG      ; xmmB=(01 03 05 07 09 0B 0D 0F 11 13 15 17 19 1B 1D 1F)
+    punpckhbw   xmmH, xmmG      ; xmmH=(21 23 25 27 29 2B 2D 2F 31 33 35 37 39 3B 3D 3F)
+
+    pxor        xmmF, xmmF
+
+    movdqa      xmmC, xmmA
+    punpcklbw   xmmA, xmmF      ; xmmA=(00 02 04 06 08 0A 0C 0E)
+    punpckhbw   xmmC, xmmF      ; xmmC=(10 12 14 16 18 1A 1C 1E)
+
+    movdqa      xmmD, xmmB
+    punpcklbw   xmmB, xmmF      ; xmmB=(01 03 05 07 09 0B 0D 0F)
+    punpckhbw   xmmD, xmmF      ; xmmD=(11 13 15 17 19 1B 1D 1F)
+
+    movdqa      xmmG, xmmE
+    punpcklbw   xmmE, xmmF      ; xmmE=(20 22 24 26 28 2A 2C 2E)
+    punpckhbw   xmmG, xmmF      ; xmmG=(30 32 34 36 38 3A 3C 3E)
+
+    punpcklbw   xmmF, xmmH
+    punpckhbw   xmmH, xmmH
+    psrlw       xmmF, BYTE_BIT  ; xmmF=(21 23 25 27 29 2B 2D 2F)
+    psrlw       xmmH, BYTE_BIT  ; xmmH=(31 33 35 37 39 3B 3D 3F)
+
+%endif  ; RGB_PIXELSIZE ; ---------------
+
+    ; xmm0=R(02468ACE)=RE, xmm2=G(02468ACE)=GE, xmm4=B(02468ACE)=BE
+    ; xmm1=R(13579BDF)=RO, xmm3=G(13579BDF)=GO, xmm5=B(13579BDF)=BO
+
+    ; (Original)
+    ; Y  =  0.29900 * R + 0.58700 * G + 0.11400 * B
+    ;
+    ; (This implementation)
+    ; Y  =  0.29900 * R + 0.33700 * G + 0.11400 * B + 0.25000 * G
+
+    movdqa      xmm6, xmm1
+    punpcklwd   xmm1, xmm3
+    punpckhwd   xmm6, xmm3
+    pmaddwd     xmm1, [rel PW_F0299_F0337]  ; xmm1=ROL*FIX(0.299)+GOL*FIX(0.337)
+    pmaddwd     xmm6, [rel PW_F0299_F0337]  ; xmm6=ROH*FIX(0.299)+GOH*FIX(0.337)
+
+    movdqa      xmm7, xmm6              ; xmm7=ROH*FIX(0.299)+GOH*FIX(0.337)
+
+    movdqa      xmm6, xmm0
+    punpcklwd   xmm0, xmm2
+    punpckhwd   xmm6, xmm2
+    pmaddwd     xmm0, [rel PW_F0299_F0337]  ; xmm0=REL*FIX(0.299)+GEL*FIX(0.337)
+    pmaddwd     xmm6, [rel PW_F0299_F0337]  ; xmm6=REH*FIX(0.299)+GEH*FIX(0.337)
+
+    movdqa      XMMWORD [wk(0)], xmm0   ; wk(0)=REL*FIX(0.299)+GEL*FIX(0.337)
+    movdqa      XMMWORD [wk(1)], xmm6   ; wk(1)=REH*FIX(0.299)+GEH*FIX(0.337)
+
+    movdqa      xmm0, xmm5              ; xmm0=BO
+    movdqa      xmm6, xmm4              ; xmm6=BE
+
+    movdqa      xmm4, xmm0
+    punpcklwd   xmm0, xmm3
+    punpckhwd   xmm4, xmm3
+    pmaddwd     xmm0, [rel PW_F0114_F0250]  ; xmm0=BOL*FIX(0.114)+GOL*FIX(0.250)
+    pmaddwd     xmm4, [rel PW_F0114_F0250]  ; xmm4=BOH*FIX(0.114)+GOH*FIX(0.250)
+
+    movdqa      xmm3, [rel PD_ONEHALF]      ; xmm3=[PD_ONEHALF]
+
+    paddd       xmm0, xmm1
+    paddd       xmm4, xmm7
+    paddd       xmm0, xmm3
+    paddd       xmm4, xmm3
+    psrld       xmm0, SCALEBITS         ; xmm0=YOL
+    psrld       xmm4, SCALEBITS         ; xmm4=YOH
+    packssdw    xmm0, xmm4              ; xmm0=YO
+
+    movdqa      xmm4, xmm6
+    punpcklwd   xmm6, xmm2
+    punpckhwd   xmm4, xmm2
+    pmaddwd     xmm6, [rel PW_F0114_F0250]  ; xmm6=BEL*FIX(0.114)+GEL*FIX(0.250)
+    pmaddwd     xmm4, [rel PW_F0114_F0250]  ; xmm4=BEH*FIX(0.114)+GEH*FIX(0.250)
+
+    movdqa      xmm2, [rel PD_ONEHALF]      ; xmm2=[PD_ONEHALF]
+
+    paddd       xmm6, XMMWORD [wk(0)]
+    paddd       xmm4, XMMWORD [wk(1)]
+    paddd       xmm6, xmm2
+    paddd       xmm4, xmm2
+    psrld       xmm6, SCALEBITS         ; xmm6=YEL
+    psrld       xmm4, SCALEBITS         ; xmm4=YEH
+    packssdw    xmm6, xmm4              ; xmm6=YE
+
+    psllw       xmm0, BYTE_BIT
+    por         xmm6, xmm0              ; xmm6=Y
+    movdqa      XMMWORD [rdi], xmm6     ; Save Y
+
+    sub         rcx, byte SIZEOF_XMMWORD
+    add         rsi, byte RGB_PIXELSIZE*SIZEOF_XMMWORD  ; inptr
+    add         rdi, byte SIZEOF_XMMWORD                ; outptr0
+    cmp         rcx, byte SIZEOF_XMMWORD
+    jae         near .columnloop
+    test        rcx, rcx
+    jnz         near .column_ld1
+
+    pop         rcx                     ; col
+    pop         rsi
+    pop         rdi
+
+    add         rsi, byte SIZEOF_JSAMPROW  ; input_buf
+    add         rdi, byte SIZEOF_JSAMPROW
+    dec         rax                        ; num_rows
+    jg          near .rowloop
+
+.return:
+    pop         rbx
+    uncollect_args 5
+    mov         rsp, rbp                ; rsp <- aligned rbp
+    pop         rsp                     ; rsp <- original rbp
+    pop         rbp
+    ret
+
+; For some reason, the OS X linker does not honor the request to align the
+; segment unless we do this.
+    align       32
diff --git a/3rdparty/libjpeg/src/simd/x86_64/jchuff-sse2.asm b/3rdparty/libjpeg/src/simd/x86_64/jchuff-sse2.asm
new file mode 100644
index 00000000..00720283
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/x86_64/jchuff-sse2.asm
@@ -0,0 +1,582 @@
+;
+; jchuff-sse2.asm - Huffman entropy encoding (64-bit SSE2)
+;
+; Copyright (C) 2009-2011, 2014-2016, 2019, D. R. Commander.
+; Copyright (C) 2015, Matthieu Darbois.
+; Copyright (C) 2018, Matthias Räncker.
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+;
+; This file should be assembled with NASM (Netwide Assembler),
+; can *not* be assembled with Microsoft's MASM or any compatible
+; assembler (including Borland's Turbo Assembler).
+; NASM is available from http://nasm.sourceforge.net/ or
+; http://sourceforge.net/project/showfiles.php?group_id=6208
+;
+; This file contains an SSE2 implementation for Huffman coding of one block.
+; The following code is based on jchuff.c; see jchuff.c for more details.
+
+%include "jsimdext.inc"
+
+struc working_state
+.next_output_byte:   resp 1     ; => next byte to write in buffer
+.free_in_buffer:     resp 1     ; # of byte spaces remaining in buffer
+.cur.put_buffer.simd resq 1     ; current bit accumulation buffer
+.cur.free_bits       resd 1     ; # of bits available in it
+.cur.last_dc_val     resd 4     ; last DC coef for each component
+.cinfo:              resp 1     ; dump_buffer needs access to this
+endstruc
+
+struc c_derived_tbl
+.ehufco:             resd 256   ; code for each symbol
+.ehufsi:             resb 256   ; length of code for each symbol
+; If no code has been allocated for a symbol S, ehufsi[S] contains 0
+endstruc
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_CONST
+
+    alignz      32
+    GLOBAL_DATA(jconst_huff_encode_one_block)
+
+EXTN(jconst_huff_encode_one_block):
+
+jpeg_mask_bits dd 0x0000, 0x0001, 0x0003, 0x0007
+               dd 0x000f, 0x001f, 0x003f, 0x007f
+               dd 0x00ff, 0x01ff, 0x03ff, 0x07ff
+               dd 0x0fff, 0x1fff, 0x3fff, 0x7fff
+
+    alignz      32
+
+times 1 << 14 db 15
+times 1 << 13 db 14
+times 1 << 12 db 13
+times 1 << 11 db 12
+times 1 << 10 db 11
+times 1 <<  9 db 10
+times 1 <<  8 db  9
+times 1 <<  7 db  8
+times 1 <<  6 db  7
+times 1 <<  5 db  6
+times 1 <<  4 db  5
+times 1 <<  3 db  4
+times 1 <<  2 db  3
+times 1 <<  1 db  2
+times 1 <<  0 db  1
+times 1       db  0
+jpeg_nbits_table:
+times 1       db  0
+times 1 <<  0 db  1
+times 1 <<  1 db  2
+times 1 <<  2 db  3
+times 1 <<  3 db  4
+times 1 <<  4 db  5
+times 1 <<  5 db  6
+times 1 <<  6 db  7
+times 1 <<  7 db  8
+times 1 <<  8 db  9
+times 1 <<  9 db 10
+times 1 << 10 db 11
+times 1 << 11 db 12
+times 1 << 12 db 13
+times 1 << 13 db 14
+times 1 << 14 db 15
+
+    alignz      32
+
+%define NBITS(x)      nbits_base + x
+%define MASK_BITS(x)  NBITS((x) * 4) + (jpeg_mask_bits - jpeg_nbits_table)
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_TEXT
+    BITS        64
+
+; Shorthand used to describe SIMD operations:
+; wN:  xmmN treated as eight signed 16-bit values
+; wN[i]:  perform the same operation on all eight signed 16-bit values, i=0..7
+; bN:  xmmN treated as 16 unsigned 8-bit values
+; bN[i]:  perform the same operation on all 16 unsigned 8-bit values, i=0..15
+; Contents of SIMD registers are shown in memory order.
+
+; Fill the bit buffer to capacity with the leading bits from code, then output
+; the bit buffer and put the remaining bits from code into the bit buffer.
+;
+; Usage:
+; code - contains the bits to shift into the bit buffer (LSB-aligned)
+; %1 - the label to which to jump when the macro completes
+; %2 (optional) - extra instructions to execute after nbits has been set
+;
+; Upon completion, free_bits will be set to the number of remaining bits from
+; code, and put_buffer will contain those remaining bits.  temp and code will
+; be clobbered.
+;
+; This macro encodes any 0xFF bytes as 0xFF 0x00, as does the EMIT_BYTE()
+; macro in jchuff.c.
+
+%macro EMIT_QWORD 1-2
+    add         nbitsb, free_bitsb      ; nbits += free_bits;
+    neg         free_bitsb              ; free_bits = -free_bits;
+    mov         tempd, code             ; temp = code;
+    shl         put_buffer, nbitsb      ; put_buffer <<= nbits;
+    mov         nbitsb, free_bitsb      ; nbits = free_bits;
+    neg         free_bitsb              ; free_bits = -free_bits;
+    shr         tempd, nbitsb           ; temp >>= nbits;
+    or          tempq, put_buffer       ; temp |= put_buffer;
+    movq        xmm0, tempq             ; xmm0.u64 = { temp, 0 };
+    bswap       tempq                   ; temp = htonl(temp);
+    mov         put_buffer, codeq       ; put_buffer = code;
+    pcmpeqb     xmm0, xmm1              ; b0[i] = (b0[i] == 0xFF ? 0xFF : 0);
+    %2
+    pmovmskb    code, xmm0              ; code = 0;  code |= ((b0[i] >> 7) << i);
+    mov         qword [buffer], tempq   ; memcpy(buffer, &temp, 8);
+                                        ; (speculative; will be overwritten if
+                                        ; code contains any 0xFF bytes)
+    add         free_bitsb, 64          ; free_bits += 64;
+    add         bufferp, 8              ; buffer += 8;
+    test        code, code              ; if (code == 0)  /* No 0xFF bytes */
+    jz          %1                      ;   return;
+    ; Execute the equivalent of the EMIT_BYTE() macro in jchuff.c for all 8
+    ; bytes in the qword.
+    cmp         tempb, 0xFF             ; Set CF if temp[0] < 0xFF
+    mov         byte [buffer-7], 0      ; buffer[-7] = 0;
+    sbb         bufferp, 6              ; buffer -= (6 + (temp[0] < 0xFF ? 1 : 0));
+    mov         byte [buffer], temph    ; buffer[0] = temp[1];
+    cmp         temph, 0xFF             ; Set CF if temp[1] < 0xFF
+    mov         byte [buffer+1], 0      ; buffer[1] = 0;
+    sbb         bufferp, -2             ; buffer -= (-2 + (temp[1] < 0xFF ? 1 : 0));
+    shr         tempq, 16               ; temp >>= 16;
+    mov         byte [buffer], tempb    ; buffer[0] = temp[0];
+    cmp         tempb, 0xFF             ; Set CF if temp[0] < 0xFF
+    mov         byte [buffer+1], 0      ; buffer[1] = 0;
+    sbb         bufferp, -2             ; buffer -= (-2 + (temp[0] < 0xFF ? 1 : 0));
+    mov         byte [buffer], temph    ; buffer[0] = temp[1];
+    cmp         temph, 0xFF             ; Set CF if temp[1] < 0xFF
+    mov         byte [buffer+1], 0      ; buffer[1] = 0;
+    sbb         bufferp, -2             ; buffer -= (-2 + (temp[1] < 0xFF ? 1 : 0));
+    shr         tempq, 16               ; temp >>= 16;
+    mov         byte [buffer], tempb    ; buffer[0] = temp[0];
+    cmp         tempb, 0xFF             ; Set CF if temp[0] < 0xFF
+    mov         byte [buffer+1], 0      ; buffer[1] = 0;
+    sbb         bufferp, -2             ; buffer -= (-2 + (temp[0] < 0xFF ? 1 : 0));
+    mov         byte [buffer], temph    ; buffer[0] = temp[1];
+    cmp         temph, 0xFF             ; Set CF if temp[1] < 0xFF
+    mov         byte [buffer+1], 0      ; buffer[1] = 0;
+    sbb         bufferp, -2             ; buffer -= (-2 + (temp[1] < 0xFF ? 1 : 0));
+    shr         tempd, 16               ; temp >>= 16;
+    mov         byte [buffer], tempb    ; buffer[0] = temp[0];
+    cmp         tempb, 0xFF             ; Set CF if temp[0] < 0xFF
+    mov         byte [buffer+1], 0      ; buffer[1] = 0;
+    sbb         bufferp, -2             ; buffer -= (-2 + (temp[0] < 0xFF ? 1 : 0));
+    mov         byte [buffer], temph    ; buffer[0] = temp[1];
+    cmp         temph, 0xFF             ; Set CF if temp[1] < 0xFF
+    mov         byte [buffer+1], 0      ; buffer[1] = 0;
+    sbb         bufferp, -2             ; buffer -= (-2 + (temp[1] < 0xFF ? 1 : 0));
+    jmp         %1                      ; return;
+%endmacro
+
+;
+; Encode a single block's worth of coefficients.
+;
+; GLOBAL(JOCTET *)
+; jsimd_huff_encode_one_block_sse2(working_state *state, JOCTET *buffer,
+;                                  JCOEFPTR block, int last_dc_val,
+;                                  c_derived_tbl *dctbl, c_derived_tbl *actbl)
+;
+; NOTES:
+; When shuffling data, we try to avoid pinsrw as much as possible, since it is
+; slow on many CPUs.  Its reciprocal throughput (issue latency) is 1 even on
+; modern CPUs, so chains of pinsrw instructions (even with different outputs)
+; can limit performance.  pinsrw is a VectorPath instruction on AMD K8 and
+; requires 2 µops (with memory operand) on Intel.  In either case, only one
+; pinsrw instruction can be decoded per cycle (and nothing else if they are
+; back-to-back), so out-of-order execution cannot be used to work around long
+; pinsrw chains (though for Sandy Bridge and later, this may be less of a
+; problem if the code runs from the µop cache.)
+;
+; We use tzcnt instead of bsf without checking for support.  The instruction is
+; executed as bsf on CPUs that don't support tzcnt (encoding is equivalent to
+; rep bsf.)  The destination (first) operand of bsf (and tzcnt on some CPUs) is
+; an input dependency (although the behavior is not formally defined, Intel
+; CPUs usually leave the destination unmodified if the source is zero.)  This
+; can prevent out-of-order execution, so we clear the destination before
+; invoking tzcnt.
+;
+; Initial register allocation
+; rax - buffer
+; rbx - temp
+; rcx - nbits
+; rdx - block --> free_bits
+; rsi - nbits_base
+; rdi - t
+; rbp - code
+; r8  - dctbl --> code_temp
+; r9  - actbl
+; r10 - state
+; r11 - index
+; r12 - put_buffer
+
+%define buffer       rax
+%ifdef WIN64
+%define bufferp      rax
+%else
+%define bufferp      raxp
+%endif
+%define tempq        rbx
+%define tempd        ebx
+%define tempb        bl
+%define temph        bh
+%define nbitsq       rcx
+%define nbits        ecx
+%define nbitsb       cl
+%define block        rdx
+%define nbits_base   rsi
+%define t            rdi
+%define td           edi
+%define codeq        rbp
+%define code         ebp
+%define dctbl        r8
+%define actbl        r9
+%define state        r10
+%define index        r11
+%define indexd       r11d
+%define put_buffer   r12
+%define put_bufferd  r12d
+
+; Step 1: Re-arrange input data according to jpeg_natural_order
+; xx 01 02 03 04 05 06 07      xx 01 08 16 09 02 03 10
+; 08 09 10 11 12 13 14 15      17 24 32 25 18 11 04 05
+; 16 17 18 19 20 21 22 23      12 19 26 33 40 48 41 34
+; 24 25 26 27 28 29 30 31 ==>  27 20 13 06 07 14 21 28
+; 32 33 34 35 36 37 38 39      35 42 49 56 57 50 43 36
+; 40 41 42 43 44 45 46 47      29 22 15 23 30 37 44 51
+; 48 49 50 51 52 53 54 55      58 59 52 45 38 31 39 46
+; 56 57 58 59 60 61 62 63      53 60 61 54 47 55 62 63
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_huff_encode_one_block_sse2)
+
+EXTN(jsimd_huff_encode_one_block_sse2):
+
+%ifdef WIN64
+
+; rcx = working_state *state
+; rdx = JOCTET *buffer
+; r8 = JCOEFPTR block
+; r9 = int last_dc_val
+; [rax+48] = c_derived_tbl *dctbl
+; [rax+56] = c_derived_tbl *actbl
+
+                                                          ;X: X = code stream
+    mov         buffer, rdx
+    mov         block, r8
+    movups      xmm3, XMMWORD [block + 0 * SIZEOF_WORD]   ;D: w3 = xx 01 02 03 04 05 06 07
+    push        rbx
+    push        rbp
+    movdqa      xmm0, xmm3                                ;A: w0 = xx 01 02 03 04 05 06 07
+    push        rsi
+    push        rdi
+    push        r12
+    movups      xmm1, XMMWORD [block + 8 * SIZEOF_WORD]   ;B: w1 = 08 09 10 11 12 13 14 15
+    mov         state, rcx
+    movsx       code, word [block]                        ;Z:     code = block[0];
+    pxor        xmm4, xmm4                                ;A: w4[i] = 0;
+    sub         code, r9d                                 ;Z:     code -= last_dc_val;
+    mov         dctbl, POINTER [rsp+6*8+4*8]
+    mov         actbl, POINTER [rsp+6*8+5*8]
+    punpckldq   xmm0, xmm1                                ;A: w0 = xx 01 08 09 02 03 10 11
+    lea         nbits_base, [rel jpeg_nbits_table]
+    add         rsp, -DCTSIZE2 * SIZEOF_WORD
+    mov         t, rsp
+
+%else
+
+; rdi = working_state *state
+; rsi = JOCTET *buffer
+; rdx = JCOEFPTR block
+; rcx = int last_dc_val
+; r8 = c_derived_tbl *dctbl
+; r9 = c_derived_tbl *actbl
+
+                                                          ;X: X = code stream
+    movups      xmm3, XMMWORD [block + 0 * SIZEOF_WORD]   ;D: w3 = xx 01 02 03 04 05 06 07
+    push        rbx
+    push        rbp
+    movdqa      xmm0, xmm3                                ;A: w0 = xx 01 02 03 04 05 06 07
+    push        r12
+    mov         state, rdi
+    mov         buffer, rsi
+    movups      xmm1, XMMWORD [block + 8 * SIZEOF_WORD]   ;B: w1 = 08 09 10 11 12 13 14 15
+    movsx       codeq, word [block]                       ;Z:     code = block[0];
+    lea         nbits_base, [rel jpeg_nbits_table]
+    pxor        xmm4, xmm4                                ;A: w4[i] = 0;
+    sub         codeq, rcx                                ;Z:     code -= last_dc_val;
+    punpckldq   xmm0, xmm1                                ;A: w0 = xx 01 08 09 02 03 10 11
+    lea         t, [rsp - DCTSIZE2 * SIZEOF_WORD]         ;   use red zone for t_
+
+%endif
+
+    pshuflw     xmm0, xmm0, 11001001b                     ;A: w0 = 01 08 xx 09 02 03 10 11
+    pinsrw      xmm0, word [block + 16 * SIZEOF_WORD], 2  ;A: w0 = 01 08 16 09 02 03 10 11
+    punpckhdq   xmm3, xmm1                                ;D: w3 = 04 05 12 13 06 07 14 15
+    punpcklqdq  xmm1, xmm3                                ;B: w1 = 08 09 10 11 04 05 12 13
+    pinsrw      xmm0, word [block + 17 * SIZEOF_WORD], 7  ;A: w0 = 01 08 16 09 02 03 10 17
+                                                          ;A:      (Row 0, offset 1)
+    pcmpgtw     xmm4, xmm0                                ;A: w4[i] = (w0[i] < 0 ? -1 : 0);
+    paddw       xmm0, xmm4                                ;A: w0[i] += w4[i];
+    movaps      XMMWORD [t + 0 * SIZEOF_WORD], xmm0       ;A: t[i] = w0[i];
+
+    movq        xmm2, qword [block + 24 * SIZEOF_WORD]    ;B: w2 = 24 25 26 27 -- -- -- --
+    pshuflw     xmm2, xmm2, 11011000b                     ;B: w2 = 24 26 25 27 -- -- -- --
+    pslldq      xmm1, 1 * SIZEOF_WORD                     ;B: w1 = -- 08 09 10 11 04 05 12
+    movups      xmm5, XMMWORD [block + 48 * SIZEOF_WORD]  ;H: w5 = 48 49 50 51 52 53 54 55
+    movsd       xmm1, xmm2                                ;B: w1 = 24 26 25 27 11 04 05 12
+    punpcklqdq  xmm2, xmm5                                ;C: w2 = 24 26 25 27 48 49 50 51
+    pinsrw      xmm1, word [block + 32 * SIZEOF_WORD], 1  ;B: w1 = 24 32 25 27 11 04 05 12
+    pxor        xmm4, xmm4                                ;A: w4[i] = 0;
+    psrldq      xmm3, 2 * SIZEOF_WORD                     ;D: w3 = 12 13 06 07 14 15 -- --
+    pcmpeqw     xmm0, xmm4                                ;A: w0[i] = (w0[i] == 0 ? -1 : 0);
+    pinsrw      xmm1, word [block + 18 * SIZEOF_WORD], 3  ;B: w1 = 24 32 25 18 11 04 05 12
+                                                          ;        (Row 1, offset 1)
+    pcmpgtw     xmm4, xmm1                                ;B: w4[i] = (w1[i] < 0 ? -1 : 0);
+    paddw       xmm1, xmm4                                ;B: w1[i] += w4[i];
+    movaps      XMMWORD [t + 8 * SIZEOF_WORD], xmm1       ;B: t[i+8] = w1[i];
+    pxor        xmm4, xmm4                                ;B: w4[i] = 0;
+    pcmpeqw     xmm1, xmm4                                ;B: w1[i] = (w1[i] == 0 ? -1 : 0);
+
+    packsswb    xmm0, xmm1                                ;AB: b0[i] = w0[i], b0[i+8] = w1[i]
+                                                          ;    w/ signed saturation
+
+    pinsrw      xmm3, word [block + 20 * SIZEOF_WORD], 0  ;D: w3 = 20 13 06 07 14 15 -- --
+    pinsrw      xmm3, word [block + 21 * SIZEOF_WORD], 5  ;D: w3 = 20 13 06 07 14 21 -- --
+    pinsrw      xmm3, word [block + 28 * SIZEOF_WORD], 6  ;D: w3 = 20 13 06 07 14 21 28 --
+    pinsrw      xmm3, word [block + 35 * SIZEOF_WORD], 7  ;D: w3 = 20 13 06 07 14 21 28 35
+                                                          ;        (Row 3, offset 1)
+    pcmpgtw     xmm4, xmm3                                ;D: w4[i] = (w3[i] < 0 ? -1 : 0);
+    paddw       xmm3, xmm4                                ;D: w3[i] += w4[i];
+    movaps      XMMWORD [t + 24 * SIZEOF_WORD], xmm3      ;D: t[i+24] = w3[i];
+    pxor        xmm4, xmm4                                ;D: w4[i] = 0;
+    pcmpeqw     xmm3, xmm4                                ;D: w3[i] = (w3[i] == 0 ? -1 : 0);
+
+    pinsrw      xmm2, word [block + 19 * SIZEOF_WORD], 0  ;C: w2 = 19 26 25 27 48 49 50 51
+    cmp         code, 1 << 31                             ;Z:     Set CF if code < 0x80000000,
+                                                          ;Z:     i.e. if code is positive
+    pinsrw      xmm2, word [block + 33 * SIZEOF_WORD], 2  ;C: w2 = 19 26 33 27 48 49 50 51
+    pinsrw      xmm2, word [block + 40 * SIZEOF_WORD], 3  ;C: w2 = 19 26 33 40 48 49 50 51
+    adc         code, -1                                  ;Z:     code += -1 + (code >= 0 ? 1 : 0);
+    pinsrw      xmm2, word [block + 41 * SIZEOF_WORD], 5  ;C: w2 = 19 26 33 40 48 41 50 51
+    pinsrw      xmm2, word [block + 34 * SIZEOF_WORD], 6  ;C: w2 = 19 26 33 40 48 41 34 51
+    movsxd      codeq, code                               ;Z:     sign extend code
+    pinsrw      xmm2, word [block + 27 * SIZEOF_WORD], 7  ;C: w2 = 19 26 33 40 48 41 34 27
+                                                          ;        (Row 2, offset 1)
+    pcmpgtw     xmm4, xmm2                                ;C: w4[i] = (w2[i] < 0 ? -1 : 0);
+    paddw       xmm2, xmm4                                ;C: w2[i] += w4[i];
+    movaps      XMMWORD [t + 16 * SIZEOF_WORD], xmm2      ;C: t[i+16] = w2[i];
+    pxor        xmm4, xmm4                                ;C: w4[i] = 0;
+    pcmpeqw     xmm2, xmm4                                ;C: w2[i] = (w2[i] == 0 ? -1 : 0);
+
+    packsswb    xmm2, xmm3                                ;CD: b2[i] = w2[i], b2[i+8] = w3[i]
+                                                          ;    w/ signed saturation
+
+    movzx       nbitsq, byte [NBITS(codeq)]               ;Z:     nbits = JPEG_NBITS(code);
+    movdqa      xmm3, xmm5                                ;H: w3 = 48 49 50 51 52 53 54 55
+    pmovmskb    tempd, xmm2                               ;Z:     temp = 0;  temp |= ((b2[i] >> 7) << i);
+    pmovmskb    put_bufferd, xmm0                         ;Z:     put_buffer = 0;  put_buffer |= ((b0[i] >> 7) << i);
+    movups      xmm0, XMMWORD [block + 56 * SIZEOF_WORD]  ;H: w0 = 56 57 58 59 60 61 62 63
+    punpckhdq   xmm3, xmm0                                ;H: w3 = 52 53 60 61 54 55 62 63
+    shl         tempd, 16                                 ;Z:     temp <<= 16;
+    psrldq      xmm3, 1 * SIZEOF_WORD                     ;H: w3 = 53 60 61 54 55 62 63 --
+    pxor        xmm2, xmm2                                ;H: w2[i] = 0;
+    or          put_bufferd, tempd                        ;Z:     put_buffer |= temp;
+    pshuflw     xmm3, xmm3, 00111001b                     ;H: w3 = 60 61 54 53 55 62 63 --
+    movq        xmm1, qword [block + 44 * SIZEOF_WORD]    ;G: w1 = 44 45 46 47 -- -- -- --
+    unpcklps    xmm5, xmm0                                ;E: w5 = 48 49 56 57 50 51 58 59
+    pxor        xmm0, xmm0                                ;H: w0[i] = 0;
+    pinsrw      xmm3, word [block + 47 * SIZEOF_WORD], 3  ;H: w3 = 60 61 54 47 55 62 63 --
+                                                          ;        (Row 7, offset 1)
+    pcmpgtw     xmm2, xmm3                                ;H: w2[i] = (w3[i] < 0 ? -1 : 0);
+    paddw       xmm3, xmm2                                ;H: w3[i] += w2[i];
+    movaps      XMMWORD [t + 56 * SIZEOF_WORD], xmm3      ;H: t[i+56] = w3[i];
+    movq        xmm4, qword [block + 36 * SIZEOF_WORD]    ;G: w4 = 36 37 38 39 -- -- -- --
+    pcmpeqw     xmm3, xmm0                                ;H: w3[i] = (w3[i] == 0 ? -1 : 0);
+    punpckldq   xmm4, xmm1                                ;G: w4 = 36 37 44 45 38 39 46 47
+    mov         tempd, [dctbl + c_derived_tbl.ehufco + nbitsq * 4]
+                                                          ;Z:     temp = dctbl->ehufco[nbits];
+    movdqa      xmm1, xmm4                                ;F: w1 = 36 37 44 45 38 39 46 47
+    psrldq      xmm4, 1 * SIZEOF_WORD                     ;G: w4 = 37 44 45 38 39 46 47 --
+    shufpd      xmm1, xmm5, 10b                           ;F: w1 = 36 37 44 45 50 51 58 59
+    and         code, dword [MASK_BITS(nbitsq)]           ;Z:     code &= (1 << nbits) - 1;
+    pshufhw     xmm4, xmm4, 11010011b                     ;G: w4 = 37 44 45 38 -- 39 46 --
+    pslldq      xmm1, 1 * SIZEOF_WORD                     ;F: w1 = -- 36 37 44 45 50 51 58
+    shl         tempq, nbitsb                             ;Z:     temp <<= nbits;
+    pinsrw      xmm4, word [block + 59 * SIZEOF_WORD], 0  ;G: w4 = 59 44 45 38 -- 39 46 --
+    pshufd      xmm1, xmm1, 11011000b                     ;F: w1 = -- 36 45 50 37 44 51 58
+    pinsrw      xmm4, word [block + 52 * SIZEOF_WORD], 1  ;G: w4 = 59 52 45 38 -- 39 46 --
+    or          code, tempd                               ;Z:     code |= temp;
+    movlps      xmm1, qword [block + 20 * SIZEOF_WORD]    ;F: w1 = 20 21 22 23 37 44 51 58
+    pinsrw      xmm4, word [block + 31 * SIZEOF_WORD], 4  ;G: w4 = 59 52 45 38 31 39 46 --
+    pshuflw     xmm1, xmm1, 01110010b                     ;F: w1 = 22 20 23 21 37 44 51 58
+    pinsrw      xmm4, word [block + 53 * SIZEOF_WORD], 7  ;G: w4 = 59 52 45 38 31 39 46 53
+                                                          ;        (Row 6, offset 1)
+    pxor        xmm2, xmm2                                ;G: w2[i] = 0;
+    pcmpgtw     xmm0, xmm4                                ;G: w0[i] = (w4[i] < 0 ? -1 : 0);
+    pinsrw      xmm1, word [block + 15 * SIZEOF_WORD], 1  ;F: w1 = 22 15 23 21 37 44 51 58
+    paddw       xmm4, xmm0                                ;G: w4[i] += w0[i];
+    movaps      XMMWORD [t + 48 * SIZEOF_WORD], xmm4      ;G: t[48+i] = w4[i];
+    pinsrw      xmm1, word [block + 30 * SIZEOF_WORD], 3  ;F: w1 = 22 15 23 30 37 44 51 58
+                                                          ;        (Row 5, offset 1)
+    pcmpeqw     xmm4, xmm2                                ;G: w4[i] = (w4[i] == 0 ? -1 : 0);
+    pinsrw      xmm5, word [block + 42 * SIZEOF_WORD], 0  ;E: w5 = 42 49 56 57 50 51 58 59
+
+    packsswb    xmm4, xmm3                                ;GH: b4[i] = w4[i], b4[i+8] = w3[i]
+                                                          ;    w/ signed saturation
+
+    pxor        xmm0, xmm0                                ;F: w0[i] = 0;
+    pinsrw      xmm5, word [block + 43 * SIZEOF_WORD], 5  ;E: w5 = 42 49 56 57 50 43 58 59
+    pcmpgtw     xmm2, xmm1                                ;F: w2[i] = (w1[i] < 0 ? -1 : 0);
+    pmovmskb    tempd, xmm4                               ;Z:     temp = 0;  temp |= ((b4[i] >> 7) << i);
+    pinsrw      xmm5, word [block + 36 * SIZEOF_WORD], 6  ;E: w5 = 42 49 56 57 50 43 36 59
+    paddw       xmm1, xmm2                                ;F: w1[i] += w2[i];
+    movaps      XMMWORD [t + 40 * SIZEOF_WORD], xmm1      ;F: t[40+i] = w1[i];
+    pinsrw      xmm5, word [block + 29 * SIZEOF_WORD], 7  ;E: w5 = 42 49 56 57 50 43 36 29
+                                                          ;        (Row 4, offset 1)
+%undef block
+%define free_bitsq  rdx
+%define free_bitsd  edx
+%define free_bitsb  dl
+    pcmpeqw     xmm1, xmm0                                ;F: w1[i] = (w1[i] == 0 ? -1 : 0);
+    shl         tempq, 48                                 ;Z:     temp <<= 48;
+    pxor        xmm2, xmm2                                ;E: w2[i] = 0;
+    pcmpgtw     xmm0, xmm5                                ;E: w0[i] = (w5[i] < 0 ? -1 : 0);
+    paddw       xmm5, xmm0                                ;E: w5[i] += w0[i];
+    or          tempq, put_buffer                         ;Z:     temp |= put_buffer;
+    movaps      XMMWORD [t + 32 * SIZEOF_WORD], xmm5      ;E: t[32+i] = w5[i];
+    lea         t, [dword t - 2]                          ;Z:     t = &t[-1];
+    pcmpeqw     xmm5, xmm2                                ;E: w5[i] = (w5[i] == 0 ? -1 : 0);
+
+    packsswb    xmm5, xmm1                                ;EF: b5[i] = w5[i], b5[i+8] = w1[i]
+                                                          ;    w/ signed saturation
+
+    add         nbitsb, byte [dctbl + c_derived_tbl.ehufsi + nbitsq]
+                                                          ;Z:     nbits += dctbl->ehufsi[nbits];
+%undef dctbl
+%define code_temp  r8d
+    pmovmskb    indexd, xmm5                              ;Z:     index = 0;  index |= ((b5[i] >> 7) << i);
+    mov         free_bitsd, [state+working_state.cur.free_bits]
+                                                          ;Z:     free_bits = state->cur.free_bits;
+    pcmpeqw     xmm1, xmm1                                ;Z:     b1[i] = 0xFF;
+    shl         index, 32                                 ;Z:     index <<= 32;
+    mov         put_buffer, [state+working_state.cur.put_buffer.simd]
+                                                          ;Z:     put_buffer = state->cur.put_buffer.simd;
+    or          index, tempq                              ;Z:     index |= temp;
+    not         index                                     ;Z:     index = ~index;
+    sub         free_bitsb, nbitsb                        ;Z:     if ((free_bits -= nbits) >= 0)
+    jnl         .ENTRY_SKIP_EMIT_CODE                     ;Z:       goto .ENTRY_SKIP_EMIT_CODE;
+    align       16
+.EMIT_CODE:                                               ;Z:     .EMIT_CODE:
+    EMIT_QWORD  .BLOOP_COND                               ;Z:     insert code, flush buffer, goto .BLOOP_COND
+
+; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    align       16
+.BRLOOP:                                                  ; do {
+    lea         code_temp, [nbitsq - 16]                  ;   code_temp = nbits - 16;
+    movzx       nbits, byte [actbl + c_derived_tbl.ehufsi + 0xf0]
+                                                          ;   nbits = actbl->ehufsi[0xf0];
+    mov         code, [actbl + c_derived_tbl.ehufco + 0xf0 * 4]
+                                                          ;   code = actbl->ehufco[0xf0];
+    sub         free_bitsb, nbitsb                        ;   if ((free_bits -= nbits) <= 0)
+    jle         .EMIT_BRLOOP_CODE                         ;     goto .EMIT_BRLOOP_CODE;
+    shl         put_buffer, nbitsb                        ;   put_buffer <<= nbits;
+    mov         nbits, code_temp                          ;   nbits = code_temp;
+    or          put_buffer, codeq                         ;   put_buffer |= code;
+    cmp         nbits, 16                                 ;   if (nbits <= 16)
+    jle         .ERLOOP                                   ;     break;
+    jmp         .BRLOOP                                   ; } while (1);
+
+; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    align       16
+    times 5     nop
+.ENTRY_SKIP_EMIT_CODE:                                    ; .ENTRY_SKIP_EMIT_CODE:
+    shl         put_buffer, nbitsb                        ; put_buffer <<= nbits;
+    or          put_buffer, codeq                         ; put_buffer |= code;
+.BLOOP_COND:                                              ; .BLOOP_COND:
+    test        index, index                              ; if (index != 0)
+    jz          .ELOOP                                    ; {
+.BLOOP:                                                   ;   do {
+    xor         nbits, nbits                              ;     nbits = 0;  /* kill tzcnt input dependency */
+    tzcnt       nbitsq, index                             ;     nbits = # of trailing 0 bits in index
+    inc         nbits                                     ;     ++nbits;
+    lea         t, [t + nbitsq * 2]                       ;     t = &t[nbits];
+    shr         index, nbitsb                             ;     index >>= nbits;
+.EMIT_BRLOOP_CODE_END:                                    ; .EMIT_BRLOOP_CODE_END:
+    cmp         nbits, 16                                 ;     if (nbits > 16)
+    jg          .BRLOOP                                   ;       goto .BRLOOP;
+.ERLOOP:                                                  ; .ERLOOP:
+    movsx       codeq, word [t]                           ;     code = *t;
+    lea         tempd, [nbitsq * 2]                       ;     temp = nbits * 2;
+    movzx       nbits, byte [NBITS(codeq)]                ;     nbits = JPEG_NBITS(code);
+    lea         tempd, [nbitsq + tempq * 8]               ;     temp = temp * 8 + nbits;
+    mov         code_temp, [actbl + c_derived_tbl.ehufco + (tempq - 16) * 4]
+                                                          ;     code_temp = actbl->ehufco[temp-16];
+    shl         code_temp, nbitsb                         ;     code_temp <<= nbits;
+    and         code, dword [MASK_BITS(nbitsq)]           ;     code &= (1 << nbits) - 1;
+    add         nbitsb, [actbl + c_derived_tbl.ehufsi + (tempq - 16)]
+                                                          ;     free_bits -= actbl->ehufsi[temp-16];
+    or          code, code_temp                           ;     code |= code_temp;
+    sub         free_bitsb, nbitsb                        ;     if ((free_bits -= nbits) <= 0)
+    jle         .EMIT_CODE                                ;       goto .EMIT_CODE;
+    shl         put_buffer, nbitsb                        ;     put_buffer <<= nbits;
+    or          put_buffer, codeq                         ;     put_buffer |= code;
+    test        index, index
+    jnz         .BLOOP                                    ;   } while (index != 0);
+.ELOOP:                                                   ; }  /* index != 0 */
+    sub         td, esp                                   ; t -= (WIN64: &t_[0], UNIX: &t_[64]);
+%ifdef WIN64
+    cmp         td, (DCTSIZE2 - 2) * SIZEOF_WORD          ; if (t != 62)
+%else
+    cmp         td, -2 * SIZEOF_WORD                      ; if (t != -2)
+%endif
+    je          .EFN                                      ; {
+    movzx       nbits, byte [actbl + c_derived_tbl.ehufsi + 0]
+                                                          ;   nbits = actbl->ehufsi[0];
+    mov         code, [actbl + c_derived_tbl.ehufco + 0]  ;   code = actbl->ehufco[0];
+    sub         free_bitsb, nbitsb                        ;   if ((free_bits -= nbits) <= 0)
+    jg          .EFN_SKIP_EMIT_CODE                       ;   {
+    EMIT_QWORD  .EFN                                      ;     insert code, flush buffer
+    align       16
+.EFN_SKIP_EMIT_CODE:                                      ;   } else {
+    shl         put_buffer, nbitsb                        ;     put_buffer <<= nbits;
+    or          put_buffer, codeq                         ;     put_buffer |= code;
+.EFN:                                                     ; } }
+    mov         [state + working_state.cur.put_buffer.simd], put_buffer
+                                                          ; state->cur.put_buffer.simd = put_buffer;
+    mov         byte [state + working_state.cur.free_bits], free_bitsb
+                                                          ; state->cur.free_bits = free_bits;
+%ifdef WIN64
+    sub         rsp, -DCTSIZE2 * SIZEOF_WORD
+    pop         r12
+    pop         rdi
+    pop         rsi
+    pop         rbp
+    pop         rbx
+%else
+    pop         r12
+    pop         rbp
+    pop         rbx
+%endif
+    ret
+
+; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    align       16
+.EMIT_BRLOOP_CODE:
+    EMIT_QWORD  .EMIT_BRLOOP_CODE_END, { mov nbits, code_temp }
+                                                          ; insert code, flush buffer,
+                                                          ; nbits = code_temp, goto .EMIT_BRLOOP_CODE_END
+
+; For some reason, the OS X linker does not honor the request to align the
+; segment unless we do this.
+    align       32
diff --git a/3rdparty/libjpeg/src/simd/x86_64/jcphuff-sse2.asm b/3rdparty/libjpeg/src/simd/x86_64/jcphuff-sse2.asm
new file mode 100644
index 00000000..8ed44728
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/x86_64/jcphuff-sse2.asm
@@ -0,0 +1,637 @@
+;
+; jcphuff-sse2.asm - prepare data for progressive Huffman encoding
+; (64-bit SSE2)
+;
+; Copyright (C) 2016, 2018, Matthieu Darbois
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+;
+; This file should be assembled with NASM (Netwide Assembler),
+; can *not* be assembled with Microsoft's MASM or any compatible
+; assembler (including Borland's Turbo Assembler).
+; NASM is available from http://nasm.sourceforge.net/ or
+; http://sourceforge.net/project/showfiles.php?group_id=6208
+;
+; This file contains an SSE2 implementation of data preparation for progressive
+; Huffman encoding.  See jcphuff.c for more details.
+
+%include "jsimdext.inc"
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_TEXT
+    BITS        64
+
+; --------------------------------------------------------------------------
+; Macros to load data for jsimd_encode_mcu_AC_first_prepare_sse2() and
+; jsimd_encode_mcu_AC_refine_prepare_sse2()
+
+%macro LOAD16 0
+    pxor        N0, N0
+    pxor        N1, N1
+
+    mov         T0d, INT [LUT +  0*SIZEOF_INT]
+    mov         T1d, INT [LUT +  8*SIZEOF_INT]
+    pinsrw      X0, word [BLOCK + T0 * 2], 0
+    pinsrw      X1, word [BLOCK + T1 * 2], 0
+
+    mov         T0d, INT [LUT +  1*SIZEOF_INT]
+    mov         T1d, INT [LUT +  9*SIZEOF_INT]
+    pinsrw      X0, word [BLOCK + T0 * 2], 1
+    pinsrw      X1, word [BLOCK + T1 * 2], 1
+
+    mov         T0d, INT [LUT +  2*SIZEOF_INT]
+    mov         T1d, INT [LUT + 10*SIZEOF_INT]
+    pinsrw      X0, word [BLOCK + T0 * 2], 2
+    pinsrw      X1, word [BLOCK + T1 * 2], 2
+
+    mov         T0d, INT [LUT +  3*SIZEOF_INT]
+    mov         T1d, INT [LUT + 11*SIZEOF_INT]
+    pinsrw      X0, word [BLOCK + T0 * 2], 3
+    pinsrw      X1, word [BLOCK + T1 * 2], 3
+
+    mov         T0d, INT [LUT +  4*SIZEOF_INT]
+    mov         T1d, INT [LUT + 12*SIZEOF_INT]
+    pinsrw      X0, word [BLOCK + T0 * 2], 4
+    pinsrw      X1, word [BLOCK + T1 * 2], 4
+
+    mov         T0d, INT [LUT +  5*SIZEOF_INT]
+    mov         T1d, INT [LUT + 13*SIZEOF_INT]
+    pinsrw      X0, word [BLOCK + T0 * 2], 5
+    pinsrw      X1, word [BLOCK + T1 * 2], 5
+
+    mov         T0d, INT [LUT +  6*SIZEOF_INT]
+    mov         T1d, INT [LUT + 14*SIZEOF_INT]
+    pinsrw      X0, word [BLOCK + T0 * 2], 6
+    pinsrw      X1, word [BLOCK + T1 * 2], 6
+
+    mov         T0d, INT [LUT +  7*SIZEOF_INT]
+    mov         T1d, INT [LUT + 15*SIZEOF_INT]
+    pinsrw      X0, word [BLOCK + T0 * 2], 7
+    pinsrw      X1, word [BLOCK + T1 * 2], 7
+%endmacro
+
+%macro LOAD15 0
+    pxor        N0, N0
+    pxor        N1, N1
+    pxor        X1, X1
+
+    mov         T0d, INT [LUT +  0*SIZEOF_INT]
+    mov         T1d, INT [LUT +  8*SIZEOF_INT]
+    pinsrw      X0, word [BLOCK + T0 * 2], 0
+    pinsrw      X1, word [BLOCK + T1 * 2], 0
+
+    mov         T0d, INT [LUT +  1*SIZEOF_INT]
+    pinsrw      X0, word [BLOCK + T0 * 2], 1
+
+    mov         T0d, INT [LUT +  2*SIZEOF_INT]
+    pinsrw      X0, word [BLOCK + T0 * 2], 2
+
+    mov         T0d, INT [LUT +  3*SIZEOF_INT]
+    pinsrw      X0, word [BLOCK + T0 * 2], 3
+
+    mov         T0d, INT [LUT +  4*SIZEOF_INT]
+    pinsrw      X0, word [BLOCK + T0 * 2], 4
+
+    mov         T0d, INT [LUT +  5*SIZEOF_INT]
+    pinsrw      X0, word [BLOCK + T0 * 2], 5
+
+    mov         T0d, INT [LUT +  6*SIZEOF_INT]
+    pinsrw      X0, word [BLOCK + T0 * 2], 6
+
+    mov         T0d, INT [LUT +  7*SIZEOF_INT]
+    pinsrw      X0, word [BLOCK + T0 * 2], 7
+
+    cmp         LENEND, 2
+    jl          %%.ELOAD15
+    mov         T1d, INT [LUT +  9*SIZEOF_INT]
+    pinsrw      X1, word [BLOCK + T1 * 2], 1
+
+    cmp         LENEND, 3
+    jl          %%.ELOAD15
+    mov         T1d, INT [LUT + 10*SIZEOF_INT]
+    pinsrw      X1, word [BLOCK + T1 * 2], 2
+
+    cmp         LENEND, 4
+    jl          %%.ELOAD15
+    mov         T1d, INT [LUT + 11*SIZEOF_INT]
+    pinsrw      X1, word [BLOCK + T1 * 2], 3
+
+    cmp         LENEND, 5
+    jl          %%.ELOAD15
+    mov         T1d, INT [LUT + 12*SIZEOF_INT]
+    pinsrw      X1, word [BLOCK + T1 * 2], 4
+
+    cmp         LENEND, 6
+    jl          %%.ELOAD15
+    mov         T1d, INT [LUT + 13*SIZEOF_INT]
+    pinsrw      X1, word [BLOCK + T1 * 2], 5
+
+    cmp         LENEND, 7
+    jl          %%.ELOAD15
+    mov         T1d, INT [LUT + 14*SIZEOF_INT]
+    pinsrw      X1, word [BLOCK + T1 * 2], 6
+%%.ELOAD15:
+%endmacro
+
+%macro LOAD8 0
+    pxor        N0, N0
+
+    mov         T0d, INT [LUT +  0*SIZEOF_INT]
+    pinsrw      X0, word [BLOCK + T0 * 2], 0
+
+    mov         T0d, INT [LUT +  1*SIZEOF_INT]
+    pinsrw      X0, word [BLOCK + T0 * 2], 1
+
+    mov         T0d, INT [LUT +  2*SIZEOF_INT]
+    pinsrw      X0, word [BLOCK + T0 * 2], 2
+
+    mov         T0d, INT [LUT +  3*SIZEOF_INT]
+    pinsrw      X0, word [BLOCK + T0 * 2], 3
+
+    mov         T0d, INT [LUT +  4*SIZEOF_INT]
+    pinsrw      X0, word [BLOCK + T0 * 2], 4
+
+    mov         T0d, INT [LUT +  5*SIZEOF_INT]
+    pinsrw      X0, word [BLOCK + T0 * 2], 5
+
+    mov         T0d, INT [LUT +  6*SIZEOF_INT]
+    pinsrw      X0, word [BLOCK + T0 * 2], 6
+
+    mov         T0d, INT [LUT +  7*SIZEOF_INT]
+    pinsrw      X0, word [BLOCK + T0 * 2], 7
+%endmacro
+
+%macro LOAD7 0
+    pxor        N0, N0
+    pxor        X0, X0
+
+    mov         T1d, INT [LUT +  0*SIZEOF_INT]
+    pinsrw      X0, word [BLOCK + T1 * 2], 0
+
+    cmp         LENEND, 2
+    jl          %%.ELOAD7
+    mov         T1d, INT [LUT +  1*SIZEOF_INT]
+    pinsrw      X0, word [BLOCK + T1 * 2], 1
+
+    cmp         LENEND, 3
+    jl          %%.ELOAD7
+    mov         T1d, INT [LUT +  2*SIZEOF_INT]
+    pinsrw      X0, word [BLOCK + T1 * 2], 2
+
+    cmp         LENEND, 4
+    jl          %%.ELOAD7
+    mov         T1d, INT [LUT +  3*SIZEOF_INT]
+    pinsrw      X0, word [BLOCK + T1 * 2], 3
+
+    cmp         LENEND, 5
+    jl          %%.ELOAD7
+    mov         T1d, INT [LUT +  4*SIZEOF_INT]
+    pinsrw      X0, word [BLOCK + T1 * 2], 4
+
+    cmp         LENEND, 6
+    jl          %%.ELOAD7
+    mov         T1d, INT [LUT +  5*SIZEOF_INT]
+    pinsrw      X0, word [BLOCK + T1 * 2], 5
+
+    cmp         LENEND, 7
+    jl          %%.ELOAD7
+    mov         T1d, INT [LUT +  6*SIZEOF_INT]
+    pinsrw      X0, word [BLOCK + T1 * 2], 6
+%%.ELOAD7:
+%endmacro
+
+%macro REDUCE0 0
+    movdqa      xmm0, XMMWORD [VALUES + ( 0*2)]
+    movdqa      xmm1, XMMWORD [VALUES + ( 8*2)]
+    movdqa      xmm2, XMMWORD [VALUES + (16*2)]
+    movdqa      xmm3, XMMWORD [VALUES + (24*2)]
+    movdqa      xmm4, XMMWORD [VALUES + (32*2)]
+    movdqa      xmm5, XMMWORD [VALUES + (40*2)]
+    movdqa      xmm6, XMMWORD [VALUES + (48*2)]
+    movdqa      xmm7, XMMWORD [VALUES + (56*2)]
+
+    pcmpeqw     xmm0, ZERO
+    pcmpeqw     xmm1, ZERO
+    pcmpeqw     xmm2, ZERO
+    pcmpeqw     xmm3, ZERO
+    pcmpeqw     xmm4, ZERO
+    pcmpeqw     xmm5, ZERO
+    pcmpeqw     xmm6, ZERO
+    pcmpeqw     xmm7, ZERO
+
+    packsswb    xmm0, xmm1
+    packsswb    xmm2, xmm3
+    packsswb    xmm4, xmm5
+    packsswb    xmm6, xmm7
+
+    pmovmskb    eax, xmm0
+    pmovmskb    ecx, xmm2
+    pmovmskb    edx, xmm4
+    pmovmskb    esi, xmm6
+
+    shl         rcx, 16
+    shl         rdx, 32
+    shl         rsi, 48
+
+    or          rax, rcx
+    or          rdx, rsi
+    or          rax, rdx
+
+    not         rax
+
+    mov         MMWORD [r15], rax
+%endmacro
+
+;
+; Prepare data for jsimd_encode_mcu_AC_first().
+;
+; GLOBAL(void)
+; jsimd_encode_mcu_AC_first_prepare_sse2(const JCOEF *block,
+;                                        const int *jpeg_natural_order_start,
+;                                        int Sl, int Al, JCOEF *values,
+;                                        size_t *zerobits)
+;
+; r10 = const JCOEF *block
+; r11 = const int *jpeg_natural_order_start
+; r12 = int Sl
+; r13 = int Al
+; r14 = JCOEF *values
+; r15 = size_t *zerobits
+
+%define ZERO    xmm9
+%define X0      xmm0
+%define X1      xmm1
+%define N0      xmm2
+%define N1      xmm3
+%define AL      xmm4
+%define K       eax
+%define LUT     r11
+%define T0      rcx
+%define T0d     ecx
+%define T1      rdx
+%define T1d     edx
+%define BLOCK   r10
+%define VALUES  r14
+%define LEN     r12d
+%define LENEND  r13d
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_encode_mcu_AC_first_prepare_sse2)
+
+EXTN(jsimd_encode_mcu_AC_first_prepare_sse2):
+    push        rbp
+    mov         rax, rsp                     ; rax = original rbp
+    sub         rsp, byte 4
+    and         rsp, byte (-SIZEOF_XMMWORD)  ; align to 128 bits
+    mov         [rsp], rax
+    mov         rbp, rsp                     ; rbp = aligned rbp
+    lea         rsp, [rbp - 16]
+    collect_args 6
+
+    movdqa      XMMWORD [rbp - 16], ZERO
+
+    movd        AL, r13d
+    pxor        ZERO, ZERO
+    mov         K, LEN
+    mov         LENEND, LEN
+    and         K, -16
+    and         LENEND, 7
+    shr         K, 4
+    jz          .ELOOP16
+.BLOOP16:
+    LOAD16
+    pcmpgtw     N0, X0
+    pcmpgtw     N1, X1
+    paddw       X0, N0
+    paddw       X1, N1
+    pxor        X0, N0
+    pxor        X1, N1
+    psrlw       X0, AL
+    psrlw       X1, AL
+    pxor        N0, X0
+    pxor        N1, X1
+    movdqa      XMMWORD [VALUES + (0) * 2], X0
+    movdqa      XMMWORD [VALUES + (8) * 2], X1
+    movdqa      XMMWORD [VALUES + (0 + DCTSIZE2) * 2], N0
+    movdqa      XMMWORD [VALUES + (8 + DCTSIZE2) * 2], N1
+    add         VALUES, 16*2
+    add         LUT, 16*SIZEOF_INT
+    dec         K
+    jnz         .BLOOP16
+    test        LEN, 15
+    je          .PADDING
+.ELOOP16:
+    test        LEN, 8
+    jz          .TRY7
+    test        LEN, 7
+    jz          .TRY8
+
+    LOAD15
+    pcmpgtw     N0, X0
+    pcmpgtw     N1, X1
+    paddw       X0, N0
+    paddw       X1, N1
+    pxor        X0, N0
+    pxor        X1, N1
+    psrlw       X0, AL
+    psrlw       X1, AL
+    pxor        N0, X0
+    pxor        N1, X1
+    movdqa      XMMWORD [VALUES + (0) * 2], X0
+    movdqa      XMMWORD [VALUES + (8) * 2], X1
+    movdqa      XMMWORD [VALUES + (0 + DCTSIZE2) * 2], N0
+    movdqa      XMMWORD [VALUES + (8 + DCTSIZE2) * 2], N1
+    add         VALUES, 16*2
+    jmp         .PADDING
+.TRY8:
+    LOAD8
+    pcmpgtw     N0, X0
+    paddw       X0, N0
+    pxor        X0, N0
+    psrlw       X0, AL
+    pxor        N0, X0
+    movdqa      XMMWORD [VALUES + (0) * 2], X0
+    movdqa      XMMWORD [VALUES + (0 + DCTSIZE2) * 2], N0
+    add         VALUES, 8*2
+    jmp         .PADDING
+.TRY7:
+    LOAD7
+    pcmpgtw     N0, X0
+    paddw       X0, N0
+    pxor        X0, N0
+    psrlw       X0, AL
+    pxor        N0, X0
+    movdqa      XMMWORD [VALUES + (0) * 2], X0
+    movdqa      XMMWORD [VALUES + (0 + DCTSIZE2) * 2], N0
+    add         VALUES, 8*2
+.PADDING:
+    mov         K, LEN
+    add         K, 7
+    and         K, -8
+    shr         K, 3
+    sub         K, DCTSIZE2/8
+    jz          .EPADDING
+    align       16
+.ZEROLOOP:
+    movdqa      XMMWORD [VALUES + 0], ZERO
+    add         VALUES, 8*2
+    inc         K
+    jnz         .ZEROLOOP
+.EPADDING:
+    sub         VALUES, DCTSIZE2*2
+
+    REDUCE0
+
+    movdqa      ZERO, XMMWORD [rbp - 16]
+    uncollect_args 6
+    mov         rsp, rbp                ; rsp <- aligned rbp
+    pop         rsp                     ; rsp <- original rbp
+    pop         rbp
+    ret
+
+%undef ZERO
+%undef X0
+%undef X1
+%undef N0
+%undef N1
+%undef AL
+%undef K
+%undef LUT
+%undef T0
+%undef T0d
+%undef T1
+%undef T1d
+%undef BLOCK
+%undef VALUES
+%undef LEN
+%undef LENEND
+
+;
+; Prepare data for jsimd_encode_mcu_AC_refine().
+;
+; GLOBAL(int)
+; jsimd_encode_mcu_AC_refine_prepare_sse2(const JCOEF *block,
+;                                         const int *jpeg_natural_order_start,
+;                                         int Sl, int Al, JCOEF *absvalues,
+;                                         size_t *bits)
+;
+; r10 = const JCOEF *block
+; r11 = const int *jpeg_natural_order_start
+; r12 = int Sl
+; r13 = int Al
+; r14 = JCOEF *values
+; r15 = size_t *bits
+
+%define ZERO    xmm9
+%define ONE     xmm5
+%define X0      xmm0
+%define X1      xmm1
+%define N0      xmm2
+%define N1      xmm3
+%define AL      xmm4
+%define K       eax
+%define KK      r9d
+%define EOB     r8d
+%define SIGN    rdi
+%define LUT     r11
+%define T0      rcx
+%define T0d     ecx
+%define T1      rdx
+%define T1d     edx
+%define BLOCK   r10
+%define VALUES  r14
+%define LEN     r12d
+%define LENEND  r13d
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_encode_mcu_AC_refine_prepare_sse2)
+
+EXTN(jsimd_encode_mcu_AC_refine_prepare_sse2):
+    push        rbp
+    mov         rax, rsp                     ; rax = original rbp
+    sub         rsp, byte 4
+    and         rsp, byte (-SIZEOF_XMMWORD)  ; align to 128 bits
+    mov         [rsp], rax
+    mov         rbp, rsp                     ; rbp = aligned rbp
+    lea         rsp, [rbp - 16]
+    collect_args 6
+
+    movdqa      XMMWORD [rbp - 16], ZERO
+
+    xor         SIGN, SIGN
+    xor         EOB, EOB
+    xor         KK, KK
+    movd        AL, r13d
+    pxor        ZERO, ZERO
+    pcmpeqw     ONE, ONE
+    psrlw       ONE, 15
+    mov         K, LEN
+    mov         LENEND, LEN
+    and         K, -16
+    and         LENEND, 7
+    shr         K, 4
+    jz          .ELOOPR16
+.BLOOPR16:
+    LOAD16
+    pcmpgtw     N0, X0
+    pcmpgtw     N1, X1
+    paddw       X0, N0
+    paddw       X1, N1
+    pxor        X0, N0
+    pxor        X1, N1
+    psrlw       X0, AL
+    psrlw       X1, AL
+    movdqa      XMMWORD [VALUES + (0) * 2], X0
+    movdqa      XMMWORD [VALUES + (8) * 2], X1
+    pcmpeqw     X0, ONE
+    pcmpeqw     X1, ONE
+    packsswb    N0, N1
+    packsswb    X0, X1
+    pmovmskb    T0d, N0                 ; lsignbits.val16u[k>>4] = _mm_movemask_epi8(neg);
+    pmovmskb    T1d, X0                 ; idx = _mm_movemask_epi8(x1);
+    shr         SIGN, 16                ; make room for sizebits
+    shl         T0, 48
+    or          SIGN, T0
+    bsr         T1d, T1d                ;  idx = 16 - (__builtin_clz(idx)>>1);
+    jz          .CONTINUER16            ; if (idx) {
+    mov         EOB, KK
+    add         EOB, T1d                ; EOB = k + idx;
+.CONTINUER16:
+    add         VALUES, 16*2
+    add         LUT, 16*SIZEOF_INT
+    add         KK, 16
+    dec         K
+    jnz         .BLOOPR16
+.ELOOPR16:
+    test        LEN, 8
+    jz          .TRYR7
+    test        LEN, 7
+    jz          .TRYR8
+
+    LOAD15
+    pcmpgtw     N0, X0
+    pcmpgtw     N1, X1
+    paddw       X0, N0
+    paddw       X1, N1
+    pxor        X0, N0
+    pxor        X1, N1
+    psrlw       X0, AL
+    psrlw       X1, AL
+    movdqa      XMMWORD [VALUES + (0) * 2], X0
+    movdqa      XMMWORD [VALUES + (8) * 2], X1
+    pcmpeqw     X0, ONE
+    pcmpeqw     X1, ONE
+    packsswb    N0, N1
+    packsswb    X0, X1
+    pmovmskb    T0d, N0                 ; lsignbits.val16u[k>>4] = _mm_movemask_epi8(neg);
+    pmovmskb    T1d, X0                 ; idx = _mm_movemask_epi8(x1);
+    shr         SIGN, 16                ; make room for sizebits
+    shl         T0, 48
+    or          SIGN, T0
+    bsr         T1d, T1d                ;  idx = 16 - (__builtin_clz(idx)>>1);
+    jz          .CONTINUER15            ; if (idx) {
+    mov         EOB, KK
+    add         EOB, T1d                ; EOB = k + idx;
+.CONTINUER15:
+    add         VALUES, 16*2
+    jmp         .PADDINGR
+.TRYR8:
+    LOAD8
+
+    pcmpgtw     N0, X0
+    paddw       X0, N0
+    pxor        X0, N0
+    psrlw       X0, AL
+    movdqa      XMMWORD [VALUES + (0) * 2], X0
+    pcmpeqw     X0, ONE
+    packsswb    N0, ZERO
+    packsswb    X0, ZERO
+    pmovmskb    T0d, N0                 ; lsignbits.val16u[k>>4] = _mm_movemask_epi8(neg);
+    pmovmskb    T1d, X0                 ; idx = _mm_movemask_epi8(x1);
+    shr         SIGN, 8                 ; make room for sizebits
+    shl         T0, 56
+    or          SIGN, T0
+    bsr         T1d, T1d                ;  idx = 16 - (__builtin_clz(idx)>>1);
+    jz          .CONTINUER8             ; if (idx) {
+    mov         EOB, KK
+    add         EOB, T1d                ; EOB = k + idx;
+.CONTINUER8:
+    add         VALUES, 8*2
+    jmp         .PADDINGR
+.TRYR7:
+    LOAD7
+
+    pcmpgtw     N0, X0
+    paddw       X0, N0
+    pxor        X0, N0
+    psrlw       X0, AL
+    movdqa      XMMWORD [VALUES + (0) * 2], X0
+    pcmpeqw     X0, ONE
+    packsswb    N0, ZERO
+    packsswb    X0, ZERO
+    pmovmskb    T0d, N0                 ; lsignbits.val16u[k>>4] = _mm_movemask_epi8(neg);
+    pmovmskb    T1d, X0                 ; idx = _mm_movemask_epi8(x1);
+    shr         SIGN, 8                 ; make room for sizebits
+    shl         T0, 56
+    or          SIGN, T0
+    bsr         T1d, T1d                ; idx = 16 - (__builtin_clz(idx)>>1);
+    jz          .CONTINUER7             ; if (idx) {
+    mov         EOB, KK
+    add         EOB, T1d                ; EOB = k + idx;
+.CONTINUER7:
+    add         VALUES, 8*2
+.PADDINGR:
+    mov         K, LEN
+    add         K, 7
+    and         K, -8
+    shr         K, 3
+    sub         K, DCTSIZE2/8
+    jz          .EPADDINGR
+    align       16
+.ZEROLOOPR:
+    movdqa      XMMWORD [VALUES + 0], ZERO
+    shr         SIGN, 8
+    add         VALUES, 8*2
+    inc         K
+    jnz         .ZEROLOOPR
+.EPADDINGR:
+    not         SIGN
+    sub         VALUES, DCTSIZE2*2
+    mov         MMWORD [r15+SIZEOF_MMWORD], SIGN
+
+    REDUCE0
+
+    mov         eax, EOB
+    movdqa      ZERO, XMMWORD [rbp - 16]
+    uncollect_args 6
+    mov         rsp, rbp                ; rsp <- aligned rbp
+    pop         rsp                     ; rsp <- original rbp
+    pop         rbp
+    ret
+
+%undef ZERO
+%undef ONE
+%undef X0
+%undef X1
+%undef N0
+%undef N1
+%undef AL
+%undef K
+%undef KK
+%undef EOB
+%undef SIGN
+%undef LUT
+%undef T0
+%undef T0d
+%undef T1
+%undef T1d
+%undef BLOCK
+%undef VALUES
+%undef LEN
+%undef LENEND
+
+; For some reason, the OS X linker does not honor the request to align the
+; segment unless we do this.
+    align       32
diff --git a/3rdparty/libjpeg/src/simd/x86_64/jcsample-avx2.asm b/3rdparty/libjpeg/src/simd/x86_64/jcsample-avx2.asm
new file mode 100644
index 00000000..b32527ae
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/x86_64/jcsample-avx2.asm
@@ -0,0 +1,367 @@
+;
+; jcsample.asm - downsampling (64-bit AVX2)
+;
+; Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+; Copyright (C) 2009, 2016, D. R. Commander.
+; Copyright (C) 2015, Intel Corporation.
+; Copyright (C) 2018, Matthias Räncker.
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+;
+; This file should be assembled with NASM (Netwide Assembler),
+; can *not* be assembled with Microsoft's MASM or any compatible
+; assembler (including Borland's Turbo Assembler).
+; NASM is available from http://nasm.sourceforge.net/ or
+; http://sourceforge.net/project/showfiles.php?group_id=6208
+
+%include "jsimdext.inc"
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_TEXT
+    BITS        64
+;
+; Downsample pixel values of a single component.
+; This version handles the common case of 2:1 horizontal and 1:1 vertical,
+; without smoothing.
+;
+; GLOBAL(void)
+; jsimd_h2v1_downsample_avx2(JDIMENSION image_width, int max_v_samp_factor,
+;                            JDIMENSION v_samp_factor,
+;                            JDIMENSION width_in_blocks, JSAMPARRAY input_data,
+;                            JSAMPARRAY output_data);
+;
+
+; r10d = JDIMENSION image_width
+; r11 = int max_v_samp_factor
+; r12d = JDIMENSION v_samp_factor
+; r13d = JDIMENSION width_in_blocks
+; r14 = JSAMPARRAY input_data
+; r15 = JSAMPARRAY output_data
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_h2v1_downsample_avx2)
+
+EXTN(jsimd_h2v1_downsample_avx2):
+    push        rbp
+    mov         rax, rsp
+    mov         rbp, rsp
+    collect_args 6
+
+    mov         ecx, r13d
+    shl         rcx, 3                  ; imul rcx,DCTSIZE (rcx = output_cols)
+    jz          near .return
+
+    mov         edx, r10d
+
+    ; -- expand_right_edge
+
+    push        rcx
+    shl         rcx, 1                  ; output_cols * 2
+    sub         rcx, rdx
+    jle         short .expand_end
+
+    mov         rax, r11
+    test        rax, rax
+    jle         short .expand_end
+
+    cld
+    mov         rsi, r14                ; input_data
+.expandloop:
+    push        rax
+    push        rcx
+
+    mov         rdip, JSAMPROW [rsi]
+    add         rdi, rdx
+    mov         al, JSAMPLE [rdi-1]
+
+    rep stosb
+
+    pop         rcx
+    pop         rax
+
+    add         rsi, byte SIZEOF_JSAMPROW
+    dec         rax
+    jg          short .expandloop
+
+.expand_end:
+    pop         rcx                     ; output_cols
+
+    ; -- h2v1_downsample
+
+    mov         eax, r12d               ; rowctr
+    test        eax, eax
+    jle         near .return
+
+    mov         rdx, 0x00010000         ; bias pattern
+    vmovd       xmm7, edx
+    vpshufd     xmm7, xmm7, 0x00        ; xmm7={0, 1, 0, 1, 0, 1, 0, 1}
+    vperm2i128  ymm7, ymm7, ymm7, 0     ; ymm7={xmm7, xmm7}
+    vpcmpeqw    ymm6, ymm6, ymm6
+    vpsrlw      ymm6, ymm6, BYTE_BIT    ; ymm6={0xFF 0x00 0xFF 0x00 ..}
+
+    mov         rsi, r14                ; input_data
+    mov         rdi, r15                ; output_data
+.rowloop:
+    push        rcx
+    push        rdi
+    push        rsi
+
+    mov         rsip, JSAMPROW [rsi]    ; inptr
+    mov         rdip, JSAMPROW [rdi]    ; outptr
+
+    cmp         rcx, byte SIZEOF_YMMWORD
+    jae         short .columnloop
+
+.columnloop_r24:
+    ; rcx can possibly be 8, 16, 24
+    cmp         rcx, 24
+    jne         .columnloop_r16
+    vmovdqu     ymm0, YMMWORD [rsi+0*SIZEOF_YMMWORD]
+    vmovdqu     xmm1, XMMWORD [rsi+1*SIZEOF_YMMWORD]
+    mov         rcx, SIZEOF_YMMWORD
+    jmp         short .downsample
+
+.columnloop_r16:
+    cmp         rcx, 16
+    jne         .columnloop_r8
+    vmovdqu     ymm0, YMMWORD [rsi+0*SIZEOF_YMMWORD]
+    vpxor       ymm1, ymm1, ymm1
+    mov         rcx, SIZEOF_YMMWORD
+    jmp         short .downsample
+
+.columnloop_r8:
+    vmovdqu     xmm0, XMMWORD[rsi+0*SIZEOF_YMMWORD]
+    vpxor       ymm1, ymm1, ymm1
+    mov         rcx, SIZEOF_YMMWORD
+    jmp         short .downsample
+
+.columnloop:
+    vmovdqu     ymm0, YMMWORD [rsi+0*SIZEOF_YMMWORD]
+    vmovdqu     ymm1, YMMWORD [rsi+1*SIZEOF_YMMWORD]
+
+.downsample:
+    vpsrlw      ymm2, ymm0, BYTE_BIT
+    vpand       ymm0, ymm0, ymm6
+    vpsrlw      ymm3, ymm1, BYTE_BIT
+    vpand       ymm1, ymm1, ymm6
+
+    vpaddw      ymm0, ymm0, ymm2
+    vpaddw      ymm1, ymm1, ymm3
+    vpaddw      ymm0, ymm0, ymm7
+    vpaddw      ymm1, ymm1, ymm7
+    vpsrlw      ymm0, ymm0, 1
+    vpsrlw      ymm1, ymm1, 1
+
+    vpackuswb   ymm0, ymm0, ymm1
+    vpermq      ymm0, ymm0, 0xd8
+
+    vmovdqu     YMMWORD [rdi+0*SIZEOF_YMMWORD], ymm0
+
+    sub         rcx, byte SIZEOF_YMMWORD    ; outcol
+    add         rsi, byte 2*SIZEOF_YMMWORD  ; inptr
+    add         rdi, byte 1*SIZEOF_YMMWORD  ; outptr
+    cmp         rcx, byte SIZEOF_YMMWORD
+    jae         short .columnloop
+    test        rcx, rcx
+    jnz         near .columnloop_r24
+
+    pop         rsi
+    pop         rdi
+    pop         rcx
+
+    add         rsi, byte SIZEOF_JSAMPROW  ; input_data
+    add         rdi, byte SIZEOF_JSAMPROW  ; output_data
+    dec         rax                        ; rowctr
+    jg          near .rowloop
+
+.return:
+    vzeroupper
+    uncollect_args 6
+    pop         rbp
+    ret
+
+; --------------------------------------------------------------------------
+;
+; Downsample pixel values of a single component.
+; This version handles the standard case of 2:1 horizontal and 2:1 vertical,
+; without smoothing.
+;
+; GLOBAL(void)
+; jsimd_h2v2_downsample_avx2(JDIMENSION image_width, int max_v_samp_factor,
+;                            JDIMENSION v_samp_factor,
+;                            JDIMENSION width_in_blocks, JSAMPARRAY input_data,
+;                            JSAMPARRAY output_data);
+;
+
+; r10d = JDIMENSION image_width
+; r11 = int max_v_samp_factor
+; r12d = JDIMENSION v_samp_factor
+; r13d = JDIMENSION width_in_blocks
+; r14 = JSAMPARRAY input_data
+; r15 = JSAMPARRAY output_data
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_h2v2_downsample_avx2)
+
+EXTN(jsimd_h2v2_downsample_avx2):
+    push        rbp
+    mov         rax, rsp
+    mov         rbp, rsp
+    collect_args 6
+
+    mov         ecx, r13d
+    shl         rcx, 3                  ; imul rcx,DCTSIZE (rcx = output_cols)
+    jz          near .return
+
+    mov         edx, r10d
+
+    ; -- expand_right_edge
+
+    push        rcx
+    shl         rcx, 1                  ; output_cols * 2
+    sub         rcx, rdx
+    jle         short .expand_end
+
+    mov         rax, r11
+    test        rax, rax
+    jle         short .expand_end
+
+    cld
+    mov         rsi, r14                ; input_data
+.expandloop:
+    push        rax
+    push        rcx
+
+    mov         rdip, JSAMPROW [rsi]
+    add         rdi, rdx
+    mov         al, JSAMPLE [rdi-1]
+
+    rep stosb
+
+    pop         rcx
+    pop         rax
+
+    add         rsi, byte SIZEOF_JSAMPROW
+    dec         rax
+    jg          short .expandloop
+
+.expand_end:
+    pop         rcx                     ; output_cols
+
+    ; -- h2v2_downsample
+
+    mov         eax, r12d               ; rowctr
+    test        rax, rax
+    jle         near .return
+
+    mov         rdx, 0x00020001         ; bias pattern
+    vmovd       xmm7, edx
+    vpcmpeqw    ymm6, ymm6, ymm6
+    vpshufd     xmm7, xmm7, 0x00        ; ymm7={1, 2, 1, 2, 1, 2, 1, 2}
+    vperm2i128  ymm7, ymm7, ymm7, 0
+    vpsrlw      ymm6, ymm6, BYTE_BIT    ; ymm6={0xFF 0x00 0xFF 0x00 ..}
+
+    mov         rsi, r14                ; input_data
+    mov         rdi, r15                ; output_data
+.rowloop:
+    push        rcx
+    push        rdi
+    push        rsi
+
+    mov         rdxp, JSAMPROW [rsi+0*SIZEOF_JSAMPROW]  ; inptr0
+    mov         rsip, JSAMPROW [rsi+1*SIZEOF_JSAMPROW]  ; inptr1
+    mov         rdip, JSAMPROW [rdi]                    ; outptr
+
+    cmp         rcx, byte SIZEOF_YMMWORD
+    jae         short .columnloop
+
+.columnloop_r24:
+    cmp         rcx, 24
+    jne         .columnloop_r16
+    vmovdqu     ymm0, YMMWORD [rdx+0*SIZEOF_YMMWORD]
+    vmovdqu     ymm1, YMMWORD [rsi+0*SIZEOF_YMMWORD]
+    vmovdqu     xmm2, XMMWORD [rdx+1*SIZEOF_YMMWORD]
+    vmovdqu     xmm3, XMMWORD [rsi+1*SIZEOF_YMMWORD]
+    mov         rcx, SIZEOF_YMMWORD
+    jmp         short .downsample
+
+.columnloop_r16:
+    cmp         rcx, 16
+    jne         .columnloop_r8
+    vmovdqu     ymm0, YMMWORD [rdx+0*SIZEOF_YMMWORD]
+    vmovdqu     ymm1, YMMWORD [rsi+0*SIZEOF_YMMWORD]
+    vpxor       ymm2, ymm2, ymm2
+    vpxor       ymm3, ymm3, ymm3
+    mov         rcx, SIZEOF_YMMWORD
+    jmp         short .downsample
+
+.columnloop_r8:
+    vmovdqu     xmm0, XMMWORD [rdx+0*SIZEOF_XMMWORD]
+    vmovdqu     xmm1, XMMWORD [rsi+0*SIZEOF_XMMWORD]
+    vpxor       ymm2, ymm2, ymm2
+    vpxor       ymm3, ymm3, ymm3
+    mov         rcx, SIZEOF_YMMWORD
+    jmp         short .downsample
+
+.columnloop:
+    vmovdqu     ymm0, YMMWORD [rdx+0*SIZEOF_YMMWORD]
+    vmovdqu     ymm1, YMMWORD [rsi+0*SIZEOF_YMMWORD]
+    vmovdqu     ymm2, YMMWORD [rdx+1*SIZEOF_YMMWORD]
+    vmovdqu     ymm3, YMMWORD [rsi+1*SIZEOF_YMMWORD]
+
+.downsample:
+    vpand       ymm4, ymm0, ymm6
+    vpsrlw      ymm0, ymm0, BYTE_BIT
+    vpand       ymm5, ymm1, ymm6
+    vpsrlw      ymm1, ymm1, BYTE_BIT
+    vpaddw      ymm0, ymm0, ymm4
+    vpaddw      ymm1, ymm1, ymm5
+
+    vpand       ymm4, ymm2, ymm6
+    vpsrlw      ymm2, ymm2, BYTE_BIT
+    vpand       ymm5, ymm3, ymm6
+    vpsrlw      ymm3, ymm3, BYTE_BIT
+    vpaddw      ymm2, ymm2, ymm4
+    vpaddw      ymm3, ymm3, ymm5
+
+    vpaddw      ymm0, ymm0, ymm1
+    vpaddw      ymm2, ymm2, ymm3
+    vpaddw      ymm0, ymm0, ymm7
+    vpaddw      ymm2, ymm2, ymm7
+    vpsrlw      ymm0, ymm0, 2
+    vpsrlw      ymm2, ymm2, 2
+
+    vpackuswb   ymm0, ymm0, ymm2
+    vpermq      ymm0, ymm0, 0xd8
+
+    vmovdqu     YMMWORD [rdi+0*SIZEOF_YMMWORD], ymm0
+
+    sub         rcx, byte SIZEOF_YMMWORD    ; outcol
+    add         rdx, byte 2*SIZEOF_YMMWORD  ; inptr0
+    add         rsi, byte 2*SIZEOF_YMMWORD  ; inptr1
+    add         rdi, byte 1*SIZEOF_YMMWORD  ; outptr
+    cmp         rcx, byte SIZEOF_YMMWORD
+    jae         near .columnloop
+    test        rcx, rcx
+    jnz         near .columnloop_r24
+
+    pop         rsi
+    pop         rdi
+    pop         rcx
+
+    add         rsi, byte 2*SIZEOF_JSAMPROW  ; input_data
+    add         rdi, byte 1*SIZEOF_JSAMPROW  ; output_data
+    dec         rax                          ; rowctr
+    jg          near .rowloop
+
+.return:
+    vzeroupper
+    uncollect_args 6
+    pop         rbp
+    ret
+
+; For some reason, the OS X linker does not honor the request to align the
+; segment unless we do this.
+    align       32
diff --git a/3rdparty/libjpeg/src/simd/x86_64/jcsample-sse2.asm b/3rdparty/libjpeg/src/simd/x86_64/jcsample-sse2.asm
new file mode 100644
index 00000000..2fcfe456
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/x86_64/jcsample-sse2.asm
@@ -0,0 +1,330 @@
+;
+; jcsample.asm - downsampling (64-bit SSE2)
+;
+; Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+; Copyright (C) 2009, 2016, D. R. Commander.
+; Copyright (C) 2018, Matthias Räncker.
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+;
+; This file should be assembled with NASM (Netwide Assembler),
+; can *not* be assembled with Microsoft's MASM or any compatible
+; assembler (including Borland's Turbo Assembler).
+; NASM is available from http://nasm.sourceforge.net/ or
+; http://sourceforge.net/project/showfiles.php?group_id=6208
+
+%include "jsimdext.inc"
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_TEXT
+    BITS        64
+;
+; Downsample pixel values of a single component.
+; This version handles the common case of 2:1 horizontal and 1:1 vertical,
+; without smoothing.
+;
+; GLOBAL(void)
+; jsimd_h2v1_downsample_sse2(JDIMENSION image_width, int max_v_samp_factor,
+;                            JDIMENSION v_samp_factor,
+;                            JDIMENSION width_in_blocks, JSAMPARRAY input_data,
+;                            JSAMPARRAY output_data);
+;
+
+; r10d = JDIMENSION image_width
+; r11 = int max_v_samp_factor
+; r12d = JDIMENSION v_samp_factor
+; r13d = JDIMENSION width_in_blocks
+; r14 = JSAMPARRAY input_data
+; r15 = JSAMPARRAY output_data
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_h2v1_downsample_sse2)
+
+EXTN(jsimd_h2v1_downsample_sse2):
+    push        rbp
+    mov         rax, rsp
+    mov         rbp, rsp
+    collect_args 6
+
+    mov         ecx, r13d
+    shl         rcx, 3                  ; imul rcx,DCTSIZE (rcx = output_cols)
+    jz          near .return
+
+    mov         edx, r10d
+
+    ; -- expand_right_edge
+
+    push        rcx
+    shl         rcx, 1                  ; output_cols * 2
+    sub         rcx, rdx
+    jle         short .expand_end
+
+    mov         rax, r11
+    test        rax, rax
+    jle         short .expand_end
+
+    cld
+    mov         rsi, r14                ; input_data
+.expandloop:
+    push        rax
+    push        rcx
+
+    mov         rdip, JSAMPROW [rsi]
+    add         rdi, rdx
+    mov         al, JSAMPLE [rdi-1]
+
+    rep stosb
+
+    pop         rcx
+    pop         rax
+
+    add         rsi, byte SIZEOF_JSAMPROW
+    dec         rax
+    jg          short .expandloop
+
+.expand_end:
+    pop         rcx                     ; output_cols
+
+    ; -- h2v1_downsample
+
+    mov         eax, r12d               ; rowctr
+    test        eax, eax
+    jle         near .return
+
+    mov         rdx, 0x00010000         ; bias pattern
+    movd        xmm7, edx
+    pcmpeqw     xmm6, xmm6
+    pshufd      xmm7, xmm7, 0x00        ; xmm7={0, 1, 0, 1, 0, 1, 0, 1}
+    psrlw       xmm6, BYTE_BIT          ; xmm6={0xFF 0x00 0xFF 0x00 ..}
+
+    mov         rsi, r14                ; input_data
+    mov         rdi, r15                ; output_data
+.rowloop:
+    push        rcx
+    push        rdi
+    push        rsi
+
+    mov         rsip, JSAMPROW [rsi]    ; inptr
+    mov         rdip, JSAMPROW [rdi]    ; outptr
+
+    cmp         rcx, byte SIZEOF_XMMWORD
+    jae         short .columnloop
+
+.columnloop_r8:
+    movdqa      xmm0, XMMWORD [rsi+0*SIZEOF_XMMWORD]
+    pxor        xmm1, xmm1
+    mov         rcx, SIZEOF_XMMWORD
+    jmp         short .downsample
+
+.columnloop:
+    movdqa      xmm0, XMMWORD [rsi+0*SIZEOF_XMMWORD]
+    movdqa      xmm1, XMMWORD [rsi+1*SIZEOF_XMMWORD]
+
+.downsample:
+    movdqa      xmm2, xmm0
+    movdqa      xmm3, xmm1
+
+    pand        xmm0, xmm6
+    psrlw       xmm2, BYTE_BIT
+    pand        xmm1, xmm6
+    psrlw       xmm3, BYTE_BIT
+
+    paddw       xmm0, xmm2
+    paddw       xmm1, xmm3
+    paddw       xmm0, xmm7
+    paddw       xmm1, xmm7
+    psrlw       xmm0, 1
+    psrlw       xmm1, 1
+
+    packuswb    xmm0, xmm1
+
+    movdqa      XMMWORD [rdi+0*SIZEOF_XMMWORD], xmm0
+
+    sub         rcx, byte SIZEOF_XMMWORD    ; outcol
+    add         rsi, byte 2*SIZEOF_XMMWORD  ; inptr
+    add         rdi, byte 1*SIZEOF_XMMWORD  ; outptr
+    cmp         rcx, byte SIZEOF_XMMWORD
+    jae         short .columnloop
+    test        rcx, rcx
+    jnz         short .columnloop_r8
+
+    pop         rsi
+    pop         rdi
+    pop         rcx
+
+    add         rsi, byte SIZEOF_JSAMPROW  ; input_data
+    add         rdi, byte SIZEOF_JSAMPROW  ; output_data
+    dec         rax                        ; rowctr
+    jg          near .rowloop
+
+.return:
+    uncollect_args 6
+    pop         rbp
+    ret
+
+; --------------------------------------------------------------------------
+;
+; Downsample pixel values of a single component.
+; This version handles the standard case of 2:1 horizontal and 2:1 vertical,
+; without smoothing.
+;
+; GLOBAL(void)
+; jsimd_h2v2_downsample_sse2(JDIMENSION image_width, int max_v_samp_factor,
+;                            JDIMENSION v_samp_factor,
+;                            JDIMENSION width_in_blocks, JSAMPARRAY input_data,
+;                            JSAMPARRAY output_data);
+;
+
+; r10d = JDIMENSION image_width
+; r11 = int max_v_samp_factor
+; r12d = JDIMENSION v_samp_factor
+; r13d = JDIMENSION width_in_blocks
+; r14 = JSAMPARRAY input_data
+; r15 = JSAMPARRAY output_data
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_h2v2_downsample_sse2)
+
+EXTN(jsimd_h2v2_downsample_sse2):
+    push        rbp
+    mov         rax, rsp
+    mov         rbp, rsp
+    collect_args 6
+
+    mov         ecx, r13d
+    shl         rcx, 3                  ; imul rcx,DCTSIZE (rcx = output_cols)
+    jz          near .return
+
+    mov         edx, r10d
+
+    ; -- expand_right_edge
+
+    push        rcx
+    shl         rcx, 1                  ; output_cols * 2
+    sub         rcx, rdx
+    jle         short .expand_end
+
+    mov         rax, r11
+    test        rax, rax
+    jle         short .expand_end
+
+    cld
+    mov         rsi, r14                ; input_data
+.expandloop:
+    push        rax
+    push        rcx
+
+    mov         rdip, JSAMPROW [rsi]
+    add         rdi, rdx
+    mov         al, JSAMPLE [rdi-1]
+
+    rep stosb
+
+    pop         rcx
+    pop         rax
+
+    add         rsi, byte SIZEOF_JSAMPROW
+    dec         rax
+    jg          short .expandloop
+
+.expand_end:
+    pop         rcx                     ; output_cols
+
+    ; -- h2v2_downsample
+
+    mov         eax, r12d               ; rowctr
+    test        rax, rax
+    jle         near .return
+
+    mov         rdx, 0x00020001         ; bias pattern
+    movd        xmm7, edx
+    pcmpeqw     xmm6, xmm6
+    pshufd      xmm7, xmm7, 0x00        ; xmm7={1, 2, 1, 2, 1, 2, 1, 2}
+    psrlw       xmm6, BYTE_BIT          ; xmm6={0xFF 0x00 0xFF 0x00 ..}
+
+    mov         rsi, r14                ; input_data
+    mov         rdi, r15                ; output_data
+.rowloop:
+    push        rcx
+    push        rdi
+    push        rsi
+
+    mov         rdxp, JSAMPROW [rsi+0*SIZEOF_JSAMPROW]  ; inptr0
+    mov         rsip, JSAMPROW [rsi+1*SIZEOF_JSAMPROW]  ; inptr1
+    mov         rdip, JSAMPROW [rdi]                    ; outptr
+
+    cmp         rcx, byte SIZEOF_XMMWORD
+    jae         short .columnloop
+
+.columnloop_r8:
+    movdqa      xmm0, XMMWORD [rdx+0*SIZEOF_XMMWORD]
+    movdqa      xmm1, XMMWORD [rsi+0*SIZEOF_XMMWORD]
+    pxor        xmm2, xmm2
+    pxor        xmm3, xmm3
+    mov         rcx, SIZEOF_XMMWORD
+    jmp         short .downsample
+
+.columnloop:
+    movdqa      xmm0, XMMWORD [rdx+0*SIZEOF_XMMWORD]
+    movdqa      xmm1, XMMWORD [rsi+0*SIZEOF_XMMWORD]
+    movdqa      xmm2, XMMWORD [rdx+1*SIZEOF_XMMWORD]
+    movdqa      xmm3, XMMWORD [rsi+1*SIZEOF_XMMWORD]
+
+.downsample:
+    movdqa      xmm4, xmm0
+    movdqa      xmm5, xmm1
+    pand        xmm0, xmm6
+    psrlw       xmm4, BYTE_BIT
+    pand        xmm1, xmm6
+    psrlw       xmm5, BYTE_BIT
+    paddw       xmm0, xmm4
+    paddw       xmm1, xmm5
+
+    movdqa      xmm4, xmm2
+    movdqa      xmm5, xmm3
+    pand        xmm2, xmm6
+    psrlw       xmm4, BYTE_BIT
+    pand        xmm3, xmm6
+    psrlw       xmm5, BYTE_BIT
+    paddw       xmm2, xmm4
+    paddw       xmm3, xmm5
+
+    paddw       xmm0, xmm1
+    paddw       xmm2, xmm3
+    paddw       xmm0, xmm7
+    paddw       xmm2, xmm7
+    psrlw       xmm0, 2
+    psrlw       xmm2, 2
+
+    packuswb    xmm0, xmm2
+
+    movdqa      XMMWORD [rdi+0*SIZEOF_XMMWORD], xmm0
+
+    sub         rcx, byte SIZEOF_XMMWORD    ; outcol
+    add         rdx, byte 2*SIZEOF_XMMWORD  ; inptr0
+    add         rsi, byte 2*SIZEOF_XMMWORD  ; inptr1
+    add         rdi, byte 1*SIZEOF_XMMWORD  ; outptr
+    cmp         rcx, byte SIZEOF_XMMWORD
+    jae         near .columnloop
+    test        rcx, rcx
+    jnz         near .columnloop_r8
+
+    pop         rsi
+    pop         rdi
+    pop         rcx
+
+    add         rsi, byte 2*SIZEOF_JSAMPROW  ; input_data
+    add         rdi, byte 1*SIZEOF_JSAMPROW  ; output_data
+    dec         rax                          ; rowctr
+    jg          near .rowloop
+
+.return:
+    uncollect_args 6
+    pop         rbp
+    ret
+
+; For some reason, the OS X linker does not honor the request to align the
+; segment unless we do this.
+    align       32
diff --git a/3rdparty/libjpeg/src/simd/x86_64/jdcolext-avx2.asm b/3rdparty/libjpeg/src/simd/x86_64/jdcolext-avx2.asm
new file mode 100644
index 00000000..2370fda6
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/x86_64/jdcolext-avx2.asm
@@ -0,0 +1,496 @@
+;
+; jdcolext.asm - colorspace conversion (64-bit AVX2)
+;
+; Copyright 2009, 2012 Pierre Ossman <ossman@cendio.se> for Cendio AB
+; Copyright (C) 2009, 2012, 2016, D. R. Commander.
+; Copyright (C) 2015, Intel Corporation.
+; Copyright (C) 2018, Matthias Räncker.
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+;
+; This file should be assembled with NASM (Netwide Assembler),
+; can *not* be assembled with Microsoft's MASM or any compatible
+; assembler (including Borland's Turbo Assembler).
+; NASM is available from http://nasm.sourceforge.net/ or
+; http://sourceforge.net/project/showfiles.php?group_id=6208
+
+%include "jcolsamp.inc"
+
+; --------------------------------------------------------------------------
+;
+; Convert some rows of samples to the output colorspace.
+;
+; GLOBAL(void)
+; jsimd_ycc_rgb_convert_avx2(JDIMENSION out_width, JSAMPIMAGE input_buf,
+;                            JDIMENSION input_row, JSAMPARRAY output_buf,
+;                            int num_rows)
+;
+
+; r10d = JDIMENSION out_width
+; r11 = JSAMPIMAGE input_buf
+; r12d = JDIMENSION input_row
+; r13 = JSAMPARRAY output_buf
+; r14d = int num_rows
+
+%define wk(i)   rbp - (WK_NUM - (i)) * SIZEOF_YMMWORD  ; ymmword wk[WK_NUM]
+%define WK_NUM  2
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_ycc_rgb_convert_avx2)
+
+EXTN(jsimd_ycc_rgb_convert_avx2):
+    push        rbp
+    mov         rax, rsp                     ; rax = original rbp
+    sub         rsp, byte 4
+    and         rsp, byte (-SIZEOF_YMMWORD)  ; align to 256 bits
+    mov         [rsp], rax
+    mov         rbp, rsp                     ; rbp = aligned rbp
+    lea         rsp, [wk(0)]
+    collect_args 5
+    push        rbx
+
+    mov         ecx, r10d               ; num_cols
+    test        rcx, rcx
+    jz          near .return
+
+    push        rcx
+
+    mov         rdi, r11
+    mov         ecx, r12d
+    mov         rsip, JSAMPARRAY [rdi+0*SIZEOF_JSAMPARRAY]
+    mov         rbxp, JSAMPARRAY [rdi+1*SIZEOF_JSAMPARRAY]
+    mov         rdxp, JSAMPARRAY [rdi+2*SIZEOF_JSAMPARRAY]
+    lea         rsi, [rsi+rcx*SIZEOF_JSAMPROW]
+    lea         rbx, [rbx+rcx*SIZEOF_JSAMPROW]
+    lea         rdx, [rdx+rcx*SIZEOF_JSAMPROW]
+
+    pop         rcx
+
+    mov         rdi, r13
+    mov         eax, r14d
+    test        rax, rax
+    jle         near .return
+.rowloop:
+    push        rax
+    push        rdi
+    push        rdx
+    push        rbx
+    push        rsi
+    push        rcx                     ; col
+
+    mov         rsip, JSAMPROW [rsi]    ; inptr0
+    mov         rbxp, JSAMPROW [rbx]    ; inptr1
+    mov         rdxp, JSAMPROW [rdx]    ; inptr2
+    mov         rdip, JSAMPROW [rdi]    ; outptr
+.columnloop:
+
+    vmovdqu     ymm5, YMMWORD [rbx]     ; ymm5=Cb(0123456789ABCDEFGHIJKLMNOPQRSTUV)
+    vmovdqu     ymm1, YMMWORD [rdx]     ; ymm1=Cr(0123456789ABCDEFGHIJKLMNOPQRSTUV)
+
+    vpcmpeqw    ymm0, ymm0, ymm0
+    vpcmpeqw    ymm7, ymm7, ymm7
+    vpsrlw      ymm0, ymm0, BYTE_BIT    ; ymm0={0xFF 0x00 0xFF 0x00 ..}
+    vpsllw      ymm7, ymm7, 7           ; ymm7={0xFF80 0xFF80 0xFF80 0xFF80 ..}
+
+    vpand       ymm4, ymm0, ymm5        ; ymm4=Cb(02468ACEGIKMOQSU)=CbE
+    vpsrlw      ymm5, ymm5, BYTE_BIT    ; ymm5=Cb(13579BDFHJLNPRTV)=CbO
+    vpand       ymm0, ymm0, ymm1        ; ymm0=Cr(02468ACEGIKMOQSU)=CrE
+    vpsrlw      ymm1, ymm1, BYTE_BIT    ; ymm1=Cr(13579BDFHJLNPRTV)=CrO
+
+    vpaddw      ymm2, ymm4, ymm7
+    vpaddw      ymm3, ymm5, ymm7
+    vpaddw      ymm6, ymm0, ymm7
+    vpaddw      ymm7, ymm1, ymm7
+
+    ; (Original)
+    ; R = Y                + 1.40200 * Cr
+    ; G = Y - 0.34414 * Cb - 0.71414 * Cr
+    ; B = Y + 1.77200 * Cb
+    ;
+    ; (This implementation)
+    ; R = Y                + 0.40200 * Cr + Cr
+    ; G = Y - 0.34414 * Cb + 0.28586 * Cr - Cr
+    ; B = Y - 0.22800 * Cb + Cb + Cb
+
+    vpaddw      ymm4, ymm2, ymm2             ; ymm4=2*CbE
+    vpaddw      ymm5, ymm3, ymm3             ; ymm5=2*CbO
+    vpaddw      ymm0, ymm6, ymm6             ; ymm0=2*CrE
+    vpaddw      ymm1, ymm7, ymm7             ; ymm1=2*CrO
+
+    vpmulhw     ymm4, ymm4, [rel PW_MF0228]  ; ymm4=(2*CbE * -FIX(0.22800))
+    vpmulhw     ymm5, ymm5, [rel PW_MF0228]  ; ymm5=(2*CbO * -FIX(0.22800))
+    vpmulhw     ymm0, ymm0, [rel PW_F0402]   ; ymm0=(2*CrE * FIX(0.40200))
+    vpmulhw     ymm1, ymm1, [rel PW_F0402]   ; ymm1=(2*CrO * FIX(0.40200))
+
+    vpaddw      ymm4, ymm4, [rel PW_ONE]
+    vpaddw      ymm5, ymm5, [rel PW_ONE]
+    vpsraw      ymm4, ymm4, 1                ; ymm4=(CbE * -FIX(0.22800))
+    vpsraw      ymm5, ymm5, 1                ; ymm5=(CbO * -FIX(0.22800))
+    vpaddw      ymm0, ymm0, [rel PW_ONE]
+    vpaddw      ymm1, ymm1, [rel PW_ONE]
+    vpsraw      ymm0, ymm0, 1                ; ymm0=(CrE * FIX(0.40200))
+    vpsraw      ymm1, ymm1, 1                ; ymm1=(CrO * FIX(0.40200))
+
+    vpaddw      ymm4, ymm4, ymm2
+    vpaddw      ymm5, ymm5, ymm3
+    vpaddw      ymm4, ymm4, ymm2             ; ymm4=(CbE * FIX(1.77200))=(B-Y)E
+    vpaddw      ymm5, ymm5, ymm3             ; ymm5=(CbO * FIX(1.77200))=(B-Y)O
+    vpaddw      ymm0, ymm0, ymm6             ; ymm0=(CrE * FIX(1.40200))=(R-Y)E
+    vpaddw      ymm1, ymm1, ymm7             ; ymm1=(CrO * FIX(1.40200))=(R-Y)O
+
+    vmovdqa     YMMWORD [wk(0)], ymm4        ; wk(0)=(B-Y)E
+    vmovdqa     YMMWORD [wk(1)], ymm5        ; wk(1)=(B-Y)O
+
+    vpunpckhwd  ymm4, ymm2, ymm6
+    vpunpcklwd  ymm2, ymm2, ymm6
+    vpmaddwd    ymm2, ymm2, [rel PW_MF0344_F0285]
+    vpmaddwd    ymm4, ymm4, [rel PW_MF0344_F0285]
+    vpunpckhwd  ymm5, ymm3, ymm7
+    vpunpcklwd  ymm3, ymm3, ymm7
+    vpmaddwd    ymm3, ymm3, [rel PW_MF0344_F0285]
+    vpmaddwd    ymm5, ymm5, [rel PW_MF0344_F0285]
+
+    vpaddd      ymm2, ymm2, [rel PD_ONEHALF]
+    vpaddd      ymm4, ymm4, [rel PD_ONEHALF]
+    vpsrad      ymm2, ymm2, SCALEBITS
+    vpsrad      ymm4, ymm4, SCALEBITS
+    vpaddd      ymm3, ymm3, [rel PD_ONEHALF]
+    vpaddd      ymm5, ymm5, [rel PD_ONEHALF]
+    vpsrad      ymm3, ymm3, SCALEBITS
+    vpsrad      ymm5, ymm5, SCALEBITS
+
+    vpackssdw   ymm2, ymm2, ymm4             ; ymm2=CbE*-FIX(0.344)+CrE*FIX(0.285)
+    vpackssdw   ymm3, ymm3, ymm5             ; ymm3=CbO*-FIX(0.344)+CrO*FIX(0.285)
+    vpsubw      ymm2, ymm2, ymm6             ; ymm2=CbE*-FIX(0.344)+CrE*-FIX(0.714)=(G-Y)E
+    vpsubw      ymm3, ymm3, ymm7             ; ymm3=CbO*-FIX(0.344)+CrO*-FIX(0.714)=(G-Y)O
+
+    vmovdqu     ymm5, YMMWORD [rsi]          ; ymm5=Y(0123456789ABCDEFGHIJKLMNOPQRSTUV)
+
+    vpcmpeqw    ymm4, ymm4, ymm4
+    vpsrlw      ymm4, ymm4, BYTE_BIT         ; ymm4={0xFF 0x00 0xFF 0x00 ..}
+    vpand       ymm4, ymm4, ymm5             ; ymm4=Y(02468ACEGIKMOQSU)=YE
+    vpsrlw      ymm5, ymm5, BYTE_BIT         ; ymm5=Y(13579BDFHJLNPRTV)=YO
+
+    vpaddw      ymm0, ymm0, ymm4             ; ymm0=((R-Y)E+YE)=RE=R(02468ACEGIKMOQSU)
+    vpaddw      ymm1, ymm1, ymm5             ; ymm1=((R-Y)O+YO)=RO=R(13579BDFHJLNPRTV)
+    vpackuswb   ymm0, ymm0, ymm0             ; ymm0=R(02468ACE********GIKMOQSU********)
+    vpackuswb   ymm1, ymm1, ymm1             ; ymm1=R(13579BDF********HJLNPRTV********)
+
+    vpaddw      ymm2, ymm2, ymm4             ; ymm2=((G-Y)E+YE)=GE=G(02468ACEGIKMOQSU)
+    vpaddw      ymm3, ymm3, ymm5             ; ymm3=((G-Y)O+YO)=GO=G(13579BDFHJLNPRTV)
+    vpackuswb   ymm2, ymm2, ymm2             ; ymm2=G(02468ACE********GIKMOQSU********)
+    vpackuswb   ymm3, ymm3, ymm3             ; ymm3=G(13579BDF********HJLNPRTV********)
+
+    vpaddw      ymm4, ymm4, YMMWORD [wk(0)]  ; ymm4=(YE+(B-Y)E)=BE=B(02468ACEGIKMOQSU)
+    vpaddw      ymm5, ymm5, YMMWORD [wk(1)]  ; ymm5=(YO+(B-Y)O)=BO=B(13579BDFHJLNPRTV)
+    vpackuswb   ymm4, ymm4, ymm4             ; ymm4=B(02468ACE********GIKMOQSU********)
+    vpackuswb   ymm5, ymm5, ymm5             ; ymm5=B(13579BDF********HJLNPRTV********)
+
+%if RGB_PIXELSIZE == 3  ; ---------------
+
+    ; ymmA=(00 02 04 06 08 0A 0C 0E ** 0G 0I 0K 0M 0O 0Q 0S 0U **)
+    ; ymmB=(01 03 05 07 09 0B 0D 0F ** 0H 0J 0L 0N 0P 0R 0T 0V **)
+    ; ymmC=(10 12 14 16 18 1A 1C 1E ** 1G 1I 1K 1M 1O 1Q 1S 1U **)
+    ; ymmD=(11 13 15 17 19 1B 1D 1F ** 1H 1J 1L 1N 1P 1R 1T 1V **)
+    ; ymmE=(20 22 24 26 28 2A 2C 2E ** 2G 2I 2K 2M 2O 2Q 2S 2U **)
+    ; ymmF=(21 23 25 27 29 2B 2D 2F ** 2H 2J 2L 2N 2P 2R 2T 2V **)
+    ; ymmG=(** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** **)
+    ; ymmH=(** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** **)
+
+    vpunpcklbw  ymmA, ymmA, ymmC        ; ymmA=(00 10 02 12 04 14 06 16 08 18 0A 1A 0C 1C 0E 1E
+                                        ;       0G 1G 0I 1I 0K 1K 0M 1M 0O 1O 0Q 1Q 0S 1S 0U 1U)
+    vpunpcklbw  ymmE, ymmE, ymmB        ; ymmE=(20 01 22 03 24 05 26 07 28 09 2A 0B 2C 0D 2E 0F
+                                        ;       2G 0H 2I 0J 2K 0L 2M 0N 2O 0P 2Q 0R 2S 0T 2U 0V)
+    vpunpcklbw  ymmD, ymmD, ymmF        ; ymmD=(11 21 13 23 15 25 17 27 19 29 1B 2B 1D 2D 1F 2F
+                                        ;       1H 2H 1J 2J 1L 2L 1N 2N 1P 2P 1R 2R 1T 2T 1V 2V)
+
+    vpsrldq     ymmH, ymmA, 2           ; ymmH=(02 12 04 14 06 16 08 18 0A 1A 0C 1C 0E 1E 0G 1G
+                                        ;       0I 1I 0K 1K 0M 1M 0O 1O 0Q 1Q 0S 1S 0U 1U -- --)
+    vpunpckhwd  ymmG, ymmA, ymmE        ; ymmG=(08 18 28 09 0A 1A 2A 0B 0C 1C 2C 0D 0E 1E 2E 0F
+                                        ;       0O 1O 2O 0P 0Q 1Q 2Q 0R 0S 1S 2S 0T 0U 1U 2U 0V)
+    vpunpcklwd  ymmA, ymmA, ymmE        ; ymmA=(00 10 20 01 02 12 22 03 04 14 24 05 06 16 26 07
+                                        ;       0G 1G 2G 0H 0I 1I 2I 0J 0K 1K 2K 0L 0M 1M 2M 0N)
+
+    vpsrldq     ymmE, ymmE, 2           ; ymmE=(22 03 24 05 26 07 28 09 2A 0B 2C 0D 2E 0F 2G 0H
+                                        ;       2I 0J 2K 0L 2M 0N 2O 0P 2Q 0R 2S 0T 2U 0V -- --)
+
+    vpsrldq     ymmB, ymmD, 2           ; ymmB=(13 23 15 25 17 27 19 29 1B 2B 1D 2D 1F 2F 1H 2H
+                                        ;       1J 2J 1L 2L 1N 2N 1P 2P 1R 2R 1T 2T 1V 2V -- --)
+    vpunpckhwd  ymmC, ymmD, ymmH        ; ymmC=(19 29 0A 1A 1B 2B 0C 1C 1D 2D 0E 1E 1F 2F 0G 1G
+                                        ;       1P 2P 0Q 1Q 1R 2R 0S 1S 1T 2T 0U 1U 1V 2V -- --)
+    vpunpcklwd  ymmD, ymmD, ymmH        ; ymmD=(11 21 02 12 13 23 04 14 15 25 06 16 17 27 08 18
+                                        ;       1H 2H 0I 1I 1J 2J 0K 1K 1L 2L 0M 1M 1N 2N 0O 1O)
+
+    vpunpckhwd  ymmF, ymmE, ymmB        ; ymmF=(2A 0B 1B 2B 2C 0D 1D 2D 2E 0F 1F 2F 2G 0H 1H 2H
+                                        ;       2Q 0R 1R 2R 2S 0T 1T 2T 2U 0V 1V 2V -- -- -- --)
+    vpunpcklwd  ymmE, ymmE, ymmB        ; ymmE=(22 03 13 23 24 05 15 25 26 07 17 27 28 09 19 29
+                                        ;       2I 0J 1J 2J 2K 0L 1L 2L 2M 0N 1N 2N 2O 0P 1P 2P)
+
+    vpshufd     ymmH, ymmA, 0x4E        ; ymmH=(04 14 24 05 06 16 26 07 00 10 20 01 02 12 22 03
+                                        ;       0K 1K 2K 0L 0M 1M 2M 0N 0G 1G 2G 0H 0I 1I 2I 0J)
+    vpunpckldq  ymmA, ymmA, ymmD        ; ymmA=(00 10 20 01 11 21 02 12 02 12 22 03 13 23 04 14
+                                        ;       0G 1G 2G 0H 1H 2H 0I 1I 0I 1I 2I 0J 1J 2J 0K 1K)
+    vpunpckhdq  ymmD, ymmD, ymmE        ; ymmD=(15 25 06 16 26 07 17 27 17 27 08 18 28 09 19 29
+                                        ;       1L 2L 0M 1M 2M 0N 1N 2N 1N 2N 0O 1O 2O 0P 1P 2P)
+    vpunpckldq  ymmE, ymmE, ymmH        ; ymmE=(22 03 13 23 04 14 24 05 24 05 15 25 06 16 26 07
+                                        ;       2I 0J 1J 2J 0K 1K 2K 0L 2K 0L 1L 2L 0M 1M 2M 0N)
+
+    vpshufd     ymmH, ymmG, 0x4E        ; ymmH=(0C 1C 2C 0D 0E 1E 2E 0F 08 18 28 09 0A 1A 2A 0B
+                                        ;       0S 1S 2S 0T 0U 1U 2U 0V 0O 1O 2O 0P 0Q 1Q 2Q 0R)
+    vpunpckldq  ymmG, ymmG, ymmC        ; ymmG=(08 18 28 09 19 29 0A 1A 0A 1A 2A 0B 1B 2B 0C 1C
+                                        ;       0O 1O 2O 0P 1P 2P 0Q 1Q 0Q 1Q 2Q 0R 1R 2R 0S 1S)
+    vpunpckhdq  ymmC, ymmC, ymmF        ; ymmC=(1D 2D 0E 1E 2E 0F 1F 2F 1F 2F 0G 1G 2G 0H 1H 2H
+                                        ;       1T 2T 0U 1U 2U 0V 1V 2V 1V 2V -- -- -- -- -- --)
+    vpunpckldq  ymmF, ymmF, ymmH        ; ymmF=(2A 0B 1B 2B 0C 1C 2C 0D 2C 0D 1D 2D 0E 1E 2E 0F
+                                        ;       2Q 0R 1R 2R 0S 1S 2S 0T 2S 0T 1T 2T 0U 1U 2U 0V)
+
+    vpunpcklqdq ymmH, ymmA, ymmE        ; ymmH=(00 10 20 01 11 21 02 12 22 03 13 23 04 14 24 05
+                                        ;       0G 1G 2G 0H 1H 2H 0I 1I 2I 0J 1J 2J 0K 1K 2K 0L)
+    vpunpcklqdq ymmG, ymmD, ymmG        ; ymmG=(15 25 06 16 26 07 17 27 08 18 28 09 19 29 0A 1A
+                                        ;       1L 2L 0M 1M 2M 0N 1N 2N 0O 1O 2O 0P 1P 2P 0Q 1Q)
+    vpunpcklqdq ymmC, ymmF, ymmC        ; ymmC=(2A 0B 1B 2B 0C 1C 2C 0D 1D 2D 0E 1E 2E 0F 1F 2F
+                                        ;       2Q 0R 1R 2R 0S 1S 2S 0T 1T 2T 0U 1U 2U 0V 1V 2V)
+
+    vperm2i128  ymmA, ymmH, ymmG, 0x20  ; ymmA=(00 10 20 01 11 21 02 12 22 03 13 23 04 14 24 05
+                                        ;       15 25 06 16 26 07 17 27 08 18 28 09 19 29 0A 1A)
+    vperm2i128  ymmD, ymmC, ymmH, 0x30  ; ymmD=(2A 0B 1B 2B 0C 1C 2C 0D 1D 2D 0E 1E 2E 0F 1F 2F
+                                        ;       0G 1G 2G 0H 1H 2H 0I 1I 2I 0J 1J 2J 0K 1K 2K 0L)
+    vperm2i128  ymmF, ymmG, ymmC, 0x31  ; ymmF=(1L 2L 0M 1M 2M 0N 1N 2N 0O 1O 2O 0P 1P 2P 0Q 1Q
+                                        ;       2Q 0R 1R 2R 0S 1S 2S 0T 1T 2T 0U 1U 2U 0V 1V 2V)
+
+    cmp         rcx, byte SIZEOF_YMMWORD
+    jb          short .column_st64
+
+    test        rdi, SIZEOF_YMMWORD-1
+    jnz         short .out1
+    ; --(aligned)-------------------
+    vmovntdq    YMMWORD [rdi+0*SIZEOF_YMMWORD], ymmA
+    vmovntdq    YMMWORD [rdi+1*SIZEOF_YMMWORD], ymmD
+    vmovntdq    YMMWORD [rdi+2*SIZEOF_YMMWORD], ymmF
+    jmp         short .out0
+.out1:  ; --(unaligned)-----------------
+    vmovdqu     YMMWORD [rdi+0*SIZEOF_YMMWORD], ymmA
+    vmovdqu     YMMWORD [rdi+1*SIZEOF_YMMWORD], ymmD
+    vmovdqu     YMMWORD [rdi+2*SIZEOF_YMMWORD], ymmF
+.out0:
+    add         rdi, byte RGB_PIXELSIZE*SIZEOF_YMMWORD  ; outptr
+    sub         rcx, byte SIZEOF_YMMWORD
+    jz          near .nextrow
+
+    add         rsi, byte SIZEOF_YMMWORD  ; inptr0
+    add         rbx, byte SIZEOF_YMMWORD  ; inptr1
+    add         rdx, byte SIZEOF_YMMWORD  ; inptr2
+    jmp         near .columnloop
+
+.column_st64:
+    lea         rcx, [rcx+rcx*2]            ; imul ecx, RGB_PIXELSIZE
+    cmp         rcx, byte 2*SIZEOF_YMMWORD
+    jb          short .column_st32
+    vmovdqu     YMMWORD [rdi+0*SIZEOF_YMMWORD], ymmA
+    vmovdqu     YMMWORD [rdi+1*SIZEOF_YMMWORD], ymmD
+    add         rdi, byte 2*SIZEOF_YMMWORD  ; outptr
+    vmovdqa     ymmA, ymmF
+    sub         rcx, byte 2*SIZEOF_YMMWORD
+    jmp         short .column_st31
+.column_st32:
+    cmp         rcx, byte SIZEOF_YMMWORD
+    jb          short .column_st31
+    vmovdqu     YMMWORD [rdi+0*SIZEOF_YMMWORD], ymmA
+    add         rdi, byte SIZEOF_YMMWORD    ; outptr
+    vmovdqa     ymmA, ymmD
+    sub         rcx, byte SIZEOF_YMMWORD
+    jmp         short .column_st31
+.column_st31:
+    cmp         rcx, byte SIZEOF_XMMWORD
+    jb          short .column_st15
+    vmovdqu     XMMWORD [rdi+0*SIZEOF_XMMWORD], xmmA
+    add         rdi, byte SIZEOF_XMMWORD    ; outptr
+    vperm2i128  ymmA, ymmA, ymmA, 1
+    sub         rcx, byte SIZEOF_XMMWORD
+.column_st15:
+    ; Store the lower 8 bytes of xmmA to the output when it has enough
+    ; space.
+    cmp         rcx, byte SIZEOF_MMWORD
+    jb          short .column_st7
+    vmovq       XMM_MMWORD [rdi], xmmA
+    add         rdi, byte SIZEOF_MMWORD
+    sub         rcx, byte SIZEOF_MMWORD
+    vpsrldq     xmmA, xmmA, SIZEOF_MMWORD
+.column_st7:
+    ; Store the lower 4 bytes of xmmA to the output when it has enough
+    ; space.
+    cmp         rcx, byte SIZEOF_DWORD
+    jb          short .column_st3
+    vmovd       XMM_DWORD [rdi], xmmA
+    add         rdi, byte SIZEOF_DWORD
+    sub         rcx, byte SIZEOF_DWORD
+    vpsrldq     xmmA, xmmA, SIZEOF_DWORD
+.column_st3:
+    ; Store the lower 2 bytes of rax to the output when it has enough
+    ; space.
+    vmovd       eax, xmmA
+    cmp         rcx, byte SIZEOF_WORD
+    jb          short .column_st1
+    mov         word [rdi], ax
+    add         rdi, byte SIZEOF_WORD
+    sub         rcx, byte SIZEOF_WORD
+    shr         rax, 16
+.column_st1:
+    ; Store the lower 1 byte of rax to the output when it has enough
+    ; space.
+    test        rcx, rcx
+    jz          short .nextrow
+    mov         byte [rdi], al
+
+%else  ; RGB_PIXELSIZE == 4 ; -----------
+
+%ifdef RGBX_FILLER_0XFF
+    vpcmpeqb    ymm6, ymm6, ymm6        ; ymm6=XE=X(02468ACE********GIKMOQSU********)
+    vpcmpeqb    ymm7, ymm7, ymm7        ; ymm7=XO=X(13579BDF********HJLNPRTV********)
+%else
+    vpxor       ymm6, ymm6, ymm6        ; ymm6=XE=X(02468ACE********GIKMOQSU********)
+    vpxor       ymm7, ymm7, ymm7        ; ymm7=XO=X(13579BDF********HJLNPRTV********)
+%endif
+    ; ymmA=(00 02 04 06 08 0A 0C 0E ** 0G 0I 0K 0M 0O 0Q 0S 0U **)
+    ; ymmB=(01 03 05 07 09 0B 0D 0F ** 0H 0J 0L 0N 0P 0R 0T 0V **)
+    ; ymmC=(10 12 14 16 18 1A 1C 1E ** 1G 1I 1K 1M 1O 1Q 1S 1U **)
+    ; ymmD=(11 13 15 17 19 1B 1D 1F ** 1H 1J 1L 1N 1P 1R 1T 1V **)
+    ; ymmE=(20 22 24 26 28 2A 2C 2E ** 2G 2I 2K 2M 2O 2Q 2S 2U **)
+    ; ymmF=(21 23 25 27 29 2B 2D 2F ** 2H 2J 2L 2N 2P 2R 2T 2V **)
+    ; ymmG=(30 32 34 36 38 3A 3C 3E ** 3G 3I 3K 3M 3O 3Q 3S 3U **)
+    ; ymmH=(31 33 35 37 39 3B 3D 3F ** 3H 3J 3L 3N 3P 3R 3T 3V **)
+
+    vpunpcklbw  ymmA, ymmA, ymmC        ; ymmA=(00 10 02 12 04 14 06 16 08 18 0A 1A 0C 1C 0E 1E
+                                        ;       0G 1G 0I 1I 0K 1K 0M 1M 0O 1O 0Q 1Q 0S 1S 0U 1U)
+    vpunpcklbw  ymmE, ymmE, ymmG        ; ymmE=(20 30 22 32 24 34 26 36 28 38 2A 3A 2C 3C 2E 3E
+                                        ;       2G 3G 2I 3I 2K 3K 2M 3M 2O 3O 2Q 3Q 2S 3S 2U 3U)
+    vpunpcklbw  ymmB, ymmB, ymmD        ; ymmB=(01 11 03 13 05 15 07 17 09 19 0B 1B 0D 1D 0F 1F
+                                        ;       0H 1H 0J 1J 0L 1L 0N 1N 0P 1P 0R 1R 0T 1T 0V 1V)
+    vpunpcklbw  ymmF, ymmF, ymmH        ; ymmF=(21 31 23 33 25 35 27 37 29 39 2B 3B 2D 3D 2F 3F
+                                        ;       2H 3H 2J 3J 2L 3L 2N 3N 2P 3P 2R 3R 2T 3T 2V 3V)
+
+    vpunpckhwd  ymmC, ymmA, ymmE        ; ymmC=(08 18 28 38 0A 1A 2A 3A 0C 1C 2C 3C 0E 1E 2E 3E
+                                        ;       0O 1O 2O 3O 0Q 1Q 2Q 3Q 0S 1S 2S 3S 0U 1U 2U 3U)
+    vpunpcklwd  ymmA, ymmA, ymmE        ; ymmA=(00 10 20 30 02 12 22 32 04 14 24 34 06 16 26 36
+                                        ;       0G 1G 2G 3G 0I 1I 2I 3I 0K 1K 2K 3K 0M 1M 2M 3M)
+    vpunpckhwd  ymmG, ymmB, ymmF        ; ymmG=(09 19 29 39 0B 1B 2B 3B 0D 1D 2D 3D 0F 1F 2F 3F
+                                        ;       0P 1P 2P 3P 0R 1R 2R 3R 0T 1T 2T 3T 0V 1V 2V 3V)
+    vpunpcklwd  ymmB, ymmB, ymmF        ; ymmB=(01 11 21 31 03 13 23 33 05 15 25 35 07 17 27 37
+                                        ;       0H 1H 2H 3H 0J 1J 2J 3J 0L 1L 2L 3L 0N 1N 2N 3N)
+
+    vpunpckhdq  ymmE, ymmA, ymmB        ; ymmE=(04 14 24 34 05 15 25 35 06 16 26 36 07 17 27 37
+                                        ;       0K 1K 2K 3K 0L 1L 2L 3L 0M 1M 2M 3M 0N 1N 2N 3N)
+    vpunpckldq  ymmB, ymmA, ymmB        ; ymmB=(00 10 20 30 01 11 21 31 02 12 22 32 03 13 23 33
+                                        ;       0G 1G 2G 3G 0H 1H 2H 3H 0I 1I 2I 3I 0J 1J 2J 3J)
+    vpunpckhdq  ymmF, ymmC, ymmG        ; ymmF=(0C 1C 2C 3C 0D 1D 2D 3D 0E 1E 2E 3E 0F 1F 2F 3F
+                                        ;       0S 1S 2S 3S 0T 1T 2T 3T 0U 1U 2U 3U 0V 1V 2V 3V)
+    vpunpckldq  ymmG, ymmC, ymmG        ; ymmG=(08 18 28 38 09 19 29 39 0A 1A 2A 3A 0B 1B 2B 3B
+                                        ;       0O 1O 2O 3O 0P 1P 2P 3P 0Q 1Q 2Q 3Q 0R 1R 2R 3R)
+
+    vperm2i128  ymmA, ymmB, ymmE, 0x20  ; ymmA=(00 10 20 30 01 11 21 31 02 12 22 32 03 13 23 33
+                                        ;       04 14 24 34 05 15 25 35 06 16 26 36 07 17 27 37)
+    vperm2i128  ymmD, ymmG, ymmF, 0x20  ; ymmD=(08 18 28 38 09 19 29 39 0A 1A 2A 3A 0B 1B 2B 3B
+                                        ;       0C 1C 2C 3C 0D 1D 2D 3D 0E 1E 2E 3E 0F 1F 2F 3F)
+    vperm2i128  ymmC, ymmB, ymmE, 0x31  ; ymmC=(0G 1G 2G 3G 0H 1H 2H 3H 0I 1I 2I 3I 0J 1J 2J 3J
+                                        ;       0K 1K 2K 3K 0L 1L 2L 3L 0M 1M 2M 3M 0N 1N 2N 3N)
+    vperm2i128  ymmH, ymmG, ymmF, 0x31  ; ymmH=(0O 1O 2O 3O 0P 1P 2P 3P 0Q 1Q 2Q 3Q 0R 1R 2R 3R
+                                        ;       0S 1S 2S 3S 0T 1T 2T 3T 0U 1U 2U 3U 0V 1V 2V 3V)
+
+    cmp         rcx, byte SIZEOF_YMMWORD
+    jb          short .column_st64
+
+    test        rdi, SIZEOF_YMMWORD-1
+    jnz         short .out1
+    ; --(aligned)-------------------
+    vmovntdq    YMMWORD [rdi+0*SIZEOF_YMMWORD], ymmA
+    vmovntdq    YMMWORD [rdi+1*SIZEOF_YMMWORD], ymmD
+    vmovntdq    YMMWORD [rdi+2*SIZEOF_YMMWORD], ymmC
+    vmovntdq    YMMWORD [rdi+3*SIZEOF_YMMWORD], ymmH
+    jmp         short .out0
+.out1:  ; --(unaligned)-----------------
+    vmovdqu     YMMWORD [rdi+0*SIZEOF_YMMWORD], ymmA
+    vmovdqu     YMMWORD [rdi+1*SIZEOF_YMMWORD], ymmD
+    vmovdqu     YMMWORD [rdi+2*SIZEOF_YMMWORD], ymmC
+    vmovdqu     YMMWORD [rdi+3*SIZEOF_YMMWORD], ymmH
+.out0:
+    add         rdi, RGB_PIXELSIZE*SIZEOF_YMMWORD  ; outptr
+    sub         rcx, byte SIZEOF_YMMWORD
+    jz          near .nextrow
+
+    add         rsi, byte SIZEOF_YMMWORD  ; inptr0
+    add         rbx, byte SIZEOF_YMMWORD  ; inptr1
+    add         rdx, byte SIZEOF_YMMWORD  ; inptr2
+    jmp         near .columnloop
+
+.column_st64:
+    cmp         rcx, byte SIZEOF_YMMWORD/2
+    jb          short .column_st32
+    vmovdqu     YMMWORD [rdi+0*SIZEOF_YMMWORD], ymmA
+    vmovdqu     YMMWORD [rdi+1*SIZEOF_YMMWORD], ymmD
+    add         rdi, byte 2*SIZEOF_YMMWORD  ; outptr
+    vmovdqa     ymmA, ymmC
+    vmovdqa     ymmD, ymmH
+    sub         rcx, byte SIZEOF_YMMWORD/2
+.column_st32:
+    cmp         rcx, byte SIZEOF_YMMWORD/4
+    jb          short .column_st16
+    vmovdqu     YMMWORD [rdi+0*SIZEOF_YMMWORD], ymmA
+    add         rdi, byte SIZEOF_YMMWORD    ; outptr
+    vmovdqa     ymmA, ymmD
+    sub         rcx, byte SIZEOF_YMMWORD/4
+.column_st16:
+    cmp         rcx, byte SIZEOF_YMMWORD/8
+    jb          short .column_st15
+    vmovdqu     XMMWORD [rdi+0*SIZEOF_XMMWORD], xmmA
+    vperm2i128  ymmA, ymmA, ymmA, 1
+    add         rdi, byte SIZEOF_XMMWORD    ; outptr
+    sub         rcx, byte SIZEOF_YMMWORD/8
+.column_st15:
+    ; Store two pixels (8 bytes) of ymmA to the output when it has enough
+    ; space.
+    cmp         rcx, byte SIZEOF_YMMWORD/16
+    jb          short .column_st7
+    vmovq       MMWORD [rdi], xmmA
+    add         rdi, byte SIZEOF_YMMWORD/16*4
+    sub         rcx, byte SIZEOF_YMMWORD/16
+    vpsrldq     xmmA, SIZEOF_YMMWORD/16*4
+.column_st7:
+    ; Store one pixel (4 bytes) of ymmA to the output when it has enough
+    ; space.
+    test        rcx, rcx
+    jz          short .nextrow
+    vmovd       XMM_DWORD [rdi], xmmA
+
+%endif  ; RGB_PIXELSIZE ; ---------------
+
+.nextrow:
+    pop         rcx
+    pop         rsi
+    pop         rbx
+    pop         rdx
+    pop         rdi
+    pop         rax
+
+    add         rsi, byte SIZEOF_JSAMPROW
+    add         rbx, byte SIZEOF_JSAMPROW
+    add         rdx, byte SIZEOF_JSAMPROW
+    add         rdi, byte SIZEOF_JSAMPROW  ; output_buf
+    dec         rax                        ; num_rows
+    jg          near .rowloop
+
+    sfence                              ; flush the write buffer
+
+.return:
+    pop         rbx
+    vzeroupper
+    uncollect_args 5
+    mov         rsp, rbp                ; rsp <- aligned rbp
+    pop         rsp                     ; rsp <- original rbp
+    pop         rbp
+    ret
+
+; For some reason, the OS X linker does not honor the request to align the
+; segment unless we do this.
+    align       32
diff --git a/3rdparty/libjpeg/src/simd/x86_64/jdcolext-sse2.asm b/3rdparty/libjpeg/src/simd/x86_64/jdcolext-sse2.asm
new file mode 100644
index 00000000..e07c8d75
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/x86_64/jdcolext-sse2.asm
@@ -0,0 +1,439 @@
+;
+; jdcolext.asm - colorspace conversion (64-bit SSE2)
+;
+; Copyright 2009, 2012 Pierre Ossman <ossman@cendio.se> for Cendio AB
+; Copyright (C) 2009, 2012, 2016, D. R. Commander.
+; Copyright (C) 2018, Matthias Räncker.
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+;
+; This file should be assembled with NASM (Netwide Assembler),
+; can *not* be assembled with Microsoft's MASM or any compatible
+; assembler (including Borland's Turbo Assembler).
+; NASM is available from http://nasm.sourceforge.net/ or
+; http://sourceforge.net/project/showfiles.php?group_id=6208
+
+%include "jcolsamp.inc"
+
+; --------------------------------------------------------------------------
+;
+; Convert some rows of samples to the output colorspace.
+;
+; GLOBAL(void)
+; jsimd_ycc_rgb_convert_sse2(JDIMENSION out_width, JSAMPIMAGE input_buf,
+;                            JDIMENSION input_row, JSAMPARRAY output_buf,
+;                            int num_rows)
+;
+
+; r10d = JDIMENSION out_width
+; r11 = JSAMPIMAGE input_buf
+; r12d = JDIMENSION input_row
+; r13 = JSAMPARRAY output_buf
+; r14d = int num_rows
+
+%define wk(i)   rbp - (WK_NUM - (i)) * SIZEOF_XMMWORD  ; xmmword wk[WK_NUM]
+%define WK_NUM  2
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_ycc_rgb_convert_sse2)
+
+EXTN(jsimd_ycc_rgb_convert_sse2):
+    push        rbp
+    mov         rax, rsp                     ; rax = original rbp
+    sub         rsp, byte 4
+    and         rsp, byte (-SIZEOF_XMMWORD)  ; align to 128 bits
+    mov         [rsp], rax
+    mov         rbp, rsp                     ; rbp = aligned rbp
+    lea         rsp, [wk(0)]
+    collect_args 5
+    push        rbx
+
+    mov         ecx, r10d               ; num_cols
+    test        rcx, rcx
+    jz          near .return
+
+    push        rcx
+
+    mov         rdi, r11
+    mov         ecx, r12d
+    mov         rsip, JSAMPARRAY [rdi+0*SIZEOF_JSAMPARRAY]
+    mov         rbxp, JSAMPARRAY [rdi+1*SIZEOF_JSAMPARRAY]
+    mov         rdxp, JSAMPARRAY [rdi+2*SIZEOF_JSAMPARRAY]
+    lea         rsi, [rsi+rcx*SIZEOF_JSAMPROW]
+    lea         rbx, [rbx+rcx*SIZEOF_JSAMPROW]
+    lea         rdx, [rdx+rcx*SIZEOF_JSAMPROW]
+
+    pop         rcx
+
+    mov         rdi, r13
+    mov         eax, r14d
+    test        rax, rax
+    jle         near .return
+.rowloop:
+    push        rax
+    push        rdi
+    push        rdx
+    push        rbx
+    push        rsi
+    push        rcx                     ; col
+
+    mov         rsip, JSAMPROW [rsi]    ; inptr0
+    mov         rbxp, JSAMPROW [rbx]    ; inptr1
+    mov         rdxp, JSAMPROW [rdx]    ; inptr2
+    mov         rdip, JSAMPROW [rdi]    ; outptr
+.columnloop:
+
+    movdqa      xmm5, XMMWORD [rbx]     ; xmm5=Cb(0123456789ABCDEF)
+    movdqa      xmm1, XMMWORD [rdx]     ; xmm1=Cr(0123456789ABCDEF)
+
+    pcmpeqw     xmm4, xmm4
+    pcmpeqw     xmm7, xmm7
+    psrlw       xmm4, BYTE_BIT
+    psllw       xmm7, 7                 ; xmm7={0xFF80 0xFF80 0xFF80 0xFF80 ..}
+    movdqa      xmm0, xmm4              ; xmm0=xmm4={0xFF 0x00 0xFF 0x00 ..}
+
+    pand        xmm4, xmm5              ; xmm4=Cb(02468ACE)=CbE
+    psrlw       xmm5, BYTE_BIT          ; xmm5=Cb(13579BDF)=CbO
+    pand        xmm0, xmm1              ; xmm0=Cr(02468ACE)=CrE
+    psrlw       xmm1, BYTE_BIT          ; xmm1=Cr(13579BDF)=CrO
+
+    paddw       xmm4, xmm7
+    paddw       xmm5, xmm7
+    paddw       xmm0, xmm7
+    paddw       xmm1, xmm7
+
+    ; (Original)
+    ; R = Y                + 1.40200 * Cr
+    ; G = Y - 0.34414 * Cb - 0.71414 * Cr
+    ; B = Y + 1.77200 * Cb
+    ;
+    ; (This implementation)
+    ; R = Y                + 0.40200 * Cr + Cr
+    ; G = Y - 0.34414 * Cb + 0.28586 * Cr - Cr
+    ; B = Y - 0.22800 * Cb + Cb + Cb
+
+    movdqa      xmm2, xmm4              ; xmm2=CbE
+    movdqa      xmm3, xmm5              ; xmm3=CbO
+    paddw       xmm4, xmm4              ; xmm4=2*CbE
+    paddw       xmm5, xmm5              ; xmm5=2*CbO
+    movdqa      xmm6, xmm0              ; xmm6=CrE
+    movdqa      xmm7, xmm1              ; xmm7=CrO
+    paddw       xmm0, xmm0              ; xmm0=2*CrE
+    paddw       xmm1, xmm1              ; xmm1=2*CrO
+
+    pmulhw      xmm4, [rel PW_MF0228]   ; xmm4=(2*CbE * -FIX(0.22800))
+    pmulhw      xmm5, [rel PW_MF0228]   ; xmm5=(2*CbO * -FIX(0.22800))
+    pmulhw      xmm0, [rel PW_F0402]    ; xmm0=(2*CrE * FIX(0.40200))
+    pmulhw      xmm1, [rel PW_F0402]    ; xmm1=(2*CrO * FIX(0.40200))
+
+    paddw       xmm4, [rel PW_ONE]
+    paddw       xmm5, [rel PW_ONE]
+    psraw       xmm4, 1                 ; xmm4=(CbE * -FIX(0.22800))
+    psraw       xmm5, 1                 ; xmm5=(CbO * -FIX(0.22800))
+    paddw       xmm0, [rel PW_ONE]
+    paddw       xmm1, [rel PW_ONE]
+    psraw       xmm0, 1                 ; xmm0=(CrE * FIX(0.40200))
+    psraw       xmm1, 1                 ; xmm1=(CrO * FIX(0.40200))
+
+    paddw       xmm4, xmm2
+    paddw       xmm5, xmm3
+    paddw       xmm4, xmm2              ; xmm4=(CbE * FIX(1.77200))=(B-Y)E
+    paddw       xmm5, xmm3              ; xmm5=(CbO * FIX(1.77200))=(B-Y)O
+    paddw       xmm0, xmm6              ; xmm0=(CrE * FIX(1.40200))=(R-Y)E
+    paddw       xmm1, xmm7              ; xmm1=(CrO * FIX(1.40200))=(R-Y)O
+
+    movdqa      XMMWORD [wk(0)], xmm4   ; wk(0)=(B-Y)E
+    movdqa      XMMWORD [wk(1)], xmm5   ; wk(1)=(B-Y)O
+
+    movdqa      xmm4, xmm2
+    movdqa      xmm5, xmm3
+    punpcklwd   xmm2, xmm6
+    punpckhwd   xmm4, xmm6
+    pmaddwd     xmm2, [rel PW_MF0344_F0285]
+    pmaddwd     xmm4, [rel PW_MF0344_F0285]
+    punpcklwd   xmm3, xmm7
+    punpckhwd   xmm5, xmm7
+    pmaddwd     xmm3, [rel PW_MF0344_F0285]
+    pmaddwd     xmm5, [rel PW_MF0344_F0285]
+
+    paddd       xmm2, [rel PD_ONEHALF]
+    paddd       xmm4, [rel PD_ONEHALF]
+    psrad       xmm2, SCALEBITS
+    psrad       xmm4, SCALEBITS
+    paddd       xmm3, [rel PD_ONEHALF]
+    paddd       xmm5, [rel PD_ONEHALF]
+    psrad       xmm3, SCALEBITS
+    psrad       xmm5, SCALEBITS
+
+    packssdw    xmm2, xmm4              ; xmm2=CbE*-FIX(0.344)+CrE*FIX(0.285)
+    packssdw    xmm3, xmm5              ; xmm3=CbO*-FIX(0.344)+CrO*FIX(0.285)
+    psubw       xmm2, xmm6              ; xmm2=CbE*-FIX(0.344)+CrE*-FIX(0.714)=(G-Y)E
+    psubw       xmm3, xmm7              ; xmm3=CbO*-FIX(0.344)+CrO*-FIX(0.714)=(G-Y)O
+
+    movdqa      xmm5, XMMWORD [rsi]     ; xmm5=Y(0123456789ABCDEF)
+
+    pcmpeqw     xmm4, xmm4
+    psrlw       xmm4, BYTE_BIT          ; xmm4={0xFF 0x00 0xFF 0x00 ..}
+    pand        xmm4, xmm5              ; xmm4=Y(02468ACE)=YE
+    psrlw       xmm5, BYTE_BIT          ; xmm5=Y(13579BDF)=YO
+
+    paddw       xmm0, xmm4              ; xmm0=((R-Y)E+YE)=RE=R(02468ACE)
+    paddw       xmm1, xmm5              ; xmm1=((R-Y)O+YO)=RO=R(13579BDF)
+    packuswb    xmm0, xmm0              ; xmm0=R(02468ACE********)
+    packuswb    xmm1, xmm1              ; xmm1=R(13579BDF********)
+
+    paddw       xmm2, xmm4              ; xmm2=((G-Y)E+YE)=GE=G(02468ACE)
+    paddw       xmm3, xmm5              ; xmm3=((G-Y)O+YO)=GO=G(13579BDF)
+    packuswb    xmm2, xmm2              ; xmm2=G(02468ACE********)
+    packuswb    xmm3, xmm3              ; xmm3=G(13579BDF********)
+
+    paddw       xmm4, XMMWORD [wk(0)]   ; xmm4=(YE+(B-Y)E)=BE=B(02468ACE)
+    paddw       xmm5, XMMWORD [wk(1)]   ; xmm5=(YO+(B-Y)O)=BO=B(13579BDF)
+    packuswb    xmm4, xmm4              ; xmm4=B(02468ACE********)
+    packuswb    xmm5, xmm5              ; xmm5=B(13579BDF********)
+
+%if RGB_PIXELSIZE == 3  ; ---------------
+
+    ; xmmA=(00 02 04 06 08 0A 0C 0E **), xmmB=(01 03 05 07 09 0B 0D 0F **)
+    ; xmmC=(10 12 14 16 18 1A 1C 1E **), xmmD=(11 13 15 17 19 1B 1D 1F **)
+    ; xmmE=(20 22 24 26 28 2A 2C 2E **), xmmF=(21 23 25 27 29 2B 2D 2F **)
+    ; xmmG=(** ** ** ** ** ** ** ** **), xmmH=(** ** ** ** ** ** ** ** **)
+
+    punpcklbw   xmmA, xmmC        ; xmmA=(00 10 02 12 04 14 06 16 08 18 0A 1A 0C 1C 0E 1E)
+    punpcklbw   xmmE, xmmB        ; xmmE=(20 01 22 03 24 05 26 07 28 09 2A 0B 2C 0D 2E 0F)
+    punpcklbw   xmmD, xmmF        ; xmmD=(11 21 13 23 15 25 17 27 19 29 1B 2B 1D 2D 1F 2F)
+
+    movdqa      xmmG, xmmA
+    movdqa      xmmH, xmmA
+    punpcklwd   xmmA, xmmE        ; xmmA=(00 10 20 01 02 12 22 03 04 14 24 05 06 16 26 07)
+    punpckhwd   xmmG, xmmE        ; xmmG=(08 18 28 09 0A 1A 2A 0B 0C 1C 2C 0D 0E 1E 2E 0F)
+
+    psrldq      xmmH, 2           ; xmmH=(02 12 04 14 06 16 08 18 0A 1A 0C 1C 0E 1E -- --)
+    psrldq      xmmE, 2           ; xmmE=(22 03 24 05 26 07 28 09 2A 0B 2C 0D 2E 0F -- --)
+
+    movdqa      xmmC, xmmD
+    movdqa      xmmB, xmmD
+    punpcklwd   xmmD, xmmH        ; xmmD=(11 21 02 12 13 23 04 14 15 25 06 16 17 27 08 18)
+    punpckhwd   xmmC, xmmH        ; xmmC=(19 29 0A 1A 1B 2B 0C 1C 1D 2D 0E 1E 1F 2F -- --)
+
+    psrldq      xmmB, 2           ; xmmB=(13 23 15 25 17 27 19 29 1B 2B 1D 2D 1F 2F -- --)
+
+    movdqa      xmmF, xmmE
+    punpcklwd   xmmE, xmmB        ; xmmE=(22 03 13 23 24 05 15 25 26 07 17 27 28 09 19 29)
+    punpckhwd   xmmF, xmmB        ; xmmF=(2A 0B 1B 2B 2C 0D 1D 2D 2E 0F 1F 2F -- -- -- --)
+
+    pshufd      xmmH, xmmA, 0x4E  ; xmmH=(04 14 24 05 06 16 26 07 00 10 20 01 02 12 22 03)
+    movdqa      xmmB, xmmE
+    punpckldq   xmmA, xmmD        ; xmmA=(00 10 20 01 11 21 02 12 02 12 22 03 13 23 04 14)
+    punpckldq   xmmE, xmmH        ; xmmE=(22 03 13 23 04 14 24 05 24 05 15 25 06 16 26 07)
+    punpckhdq   xmmD, xmmB        ; xmmD=(15 25 06 16 26 07 17 27 17 27 08 18 28 09 19 29)
+
+    pshufd      xmmH, xmmG, 0x4E  ; xmmH=(0C 1C 2C 0D 0E 1E 2E 0F 08 18 28 09 0A 1A 2A 0B)
+    movdqa      xmmB, xmmF
+    punpckldq   xmmG, xmmC        ; xmmG=(08 18 28 09 19 29 0A 1A 0A 1A 2A 0B 1B 2B 0C 1C)
+    punpckldq   xmmF, xmmH        ; xmmF=(2A 0B 1B 2B 0C 1C 2C 0D 2C 0D 1D 2D 0E 1E 2E 0F)
+    punpckhdq   xmmC, xmmB        ; xmmC=(1D 2D 0E 1E 2E 0F 1F 2F 1F 2F -- -- -- -- -- --)
+
+    punpcklqdq  xmmA, xmmE        ; xmmA=(00 10 20 01 11 21 02 12 22 03 13 23 04 14 24 05)
+    punpcklqdq  xmmD, xmmG        ; xmmD=(15 25 06 16 26 07 17 27 08 18 28 09 19 29 0A 1A)
+    punpcklqdq  xmmF, xmmC        ; xmmF=(2A 0B 1B 2B 0C 1C 2C 0D 1D 2D 0E 1E 2E 0F 1F 2F)
+
+    cmp         rcx, byte SIZEOF_XMMWORD
+    jb          short .column_st32
+
+    test        rdi, SIZEOF_XMMWORD-1
+    jnz         short .out1
+    ; --(aligned)-------------------
+    movntdq     XMMWORD [rdi+0*SIZEOF_XMMWORD], xmmA
+    movntdq     XMMWORD [rdi+1*SIZEOF_XMMWORD], xmmD
+    movntdq     XMMWORD [rdi+2*SIZEOF_XMMWORD], xmmF
+    jmp         short .out0
+.out1:  ; --(unaligned)-----------------
+    movdqu      XMMWORD [rdi+0*SIZEOF_XMMWORD], xmmA
+    movdqu      XMMWORD [rdi+1*SIZEOF_XMMWORD], xmmD
+    movdqu      XMMWORD [rdi+2*SIZEOF_XMMWORD], xmmF
+.out0:
+    add         rdi, byte RGB_PIXELSIZE*SIZEOF_XMMWORD  ; outptr
+    sub         rcx, byte SIZEOF_XMMWORD
+    jz          near .nextrow
+
+    add         rsi, byte SIZEOF_XMMWORD  ; inptr0
+    add         rbx, byte SIZEOF_XMMWORD  ; inptr1
+    add         rdx, byte SIZEOF_XMMWORD  ; inptr2
+    jmp         near .columnloop
+
+.column_st32:
+    lea         rcx, [rcx+rcx*2]            ; imul ecx, RGB_PIXELSIZE
+    cmp         rcx, byte 2*SIZEOF_XMMWORD
+    jb          short .column_st16
+    movdqu      XMMWORD [rdi+0*SIZEOF_XMMWORD], xmmA
+    movdqu      XMMWORD [rdi+1*SIZEOF_XMMWORD], xmmD
+    add         rdi, byte 2*SIZEOF_XMMWORD  ; outptr
+    movdqa      xmmA, xmmF
+    sub         rcx, byte 2*SIZEOF_XMMWORD
+    jmp         short .column_st15
+.column_st16:
+    cmp         rcx, byte SIZEOF_XMMWORD
+    jb          short .column_st15
+    movdqu      XMMWORD [rdi+0*SIZEOF_XMMWORD], xmmA
+    add         rdi, byte SIZEOF_XMMWORD    ; outptr
+    movdqa      xmmA, xmmD
+    sub         rcx, byte SIZEOF_XMMWORD
+.column_st15:
+    ; Store the lower 8 bytes of xmmA to the output when it has enough
+    ; space.
+    cmp         rcx, byte SIZEOF_MMWORD
+    jb          short .column_st7
+    movq        XMM_MMWORD [rdi], xmmA
+    add         rdi, byte SIZEOF_MMWORD
+    sub         rcx, byte SIZEOF_MMWORD
+    psrldq      xmmA, SIZEOF_MMWORD
+.column_st7:
+    ; Store the lower 4 bytes of xmmA to the output when it has enough
+    ; space.
+    cmp         rcx, byte SIZEOF_DWORD
+    jb          short .column_st3
+    movd        XMM_DWORD [rdi], xmmA
+    add         rdi, byte SIZEOF_DWORD
+    sub         rcx, byte SIZEOF_DWORD
+    psrldq      xmmA, SIZEOF_DWORD
+.column_st3:
+    ; Store the lower 2 bytes of rax to the output when it has enough
+    ; space.
+    movd        eax, xmmA
+    cmp         rcx, byte SIZEOF_WORD
+    jb          short .column_st1
+    mov         word [rdi], ax
+    add         rdi, byte SIZEOF_WORD
+    sub         rcx, byte SIZEOF_WORD
+    shr         rax, 16
+.column_st1:
+    ; Store the lower 1 byte of rax to the output when it has enough
+    ; space.
+    test        rcx, rcx
+    jz          short .nextrow
+    mov         byte [rdi], al
+
+%else  ; RGB_PIXELSIZE == 4 ; -----------
+
+%ifdef RGBX_FILLER_0XFF
+    pcmpeqb     xmm6, xmm6              ; xmm6=XE=X(02468ACE********)
+    pcmpeqb     xmm7, xmm7              ; xmm7=XO=X(13579BDF********)
+%else
+    pxor        xmm6, xmm6              ; xmm6=XE=X(02468ACE********)
+    pxor        xmm7, xmm7              ; xmm7=XO=X(13579BDF********)
+%endif
+    ; xmmA=(00 02 04 06 08 0A 0C 0E **), xmmB=(01 03 05 07 09 0B 0D 0F **)
+    ; xmmC=(10 12 14 16 18 1A 1C 1E **), xmmD=(11 13 15 17 19 1B 1D 1F **)
+    ; xmmE=(20 22 24 26 28 2A 2C 2E **), xmmF=(21 23 25 27 29 2B 2D 2F **)
+    ; xmmG=(30 32 34 36 38 3A 3C 3E **), xmmH=(31 33 35 37 39 3B 3D 3F **)
+
+    punpcklbw   xmmA, xmmC  ; xmmA=(00 10 02 12 04 14 06 16 08 18 0A 1A 0C 1C 0E 1E)
+    punpcklbw   xmmE, xmmG  ; xmmE=(20 30 22 32 24 34 26 36 28 38 2A 3A 2C 3C 2E 3E)
+    punpcklbw   xmmB, xmmD  ; xmmB=(01 11 03 13 05 15 07 17 09 19 0B 1B 0D 1D 0F 1F)
+    punpcklbw   xmmF, xmmH  ; xmmF=(21 31 23 33 25 35 27 37 29 39 2B 3B 2D 3D 2F 3F)
+
+    movdqa      xmmC, xmmA
+    punpcklwd   xmmA, xmmE  ; xmmA=(00 10 20 30 02 12 22 32 04 14 24 34 06 16 26 36)
+    punpckhwd   xmmC, xmmE  ; xmmC=(08 18 28 38 0A 1A 2A 3A 0C 1C 2C 3C 0E 1E 2E 3E)
+    movdqa      xmmG, xmmB
+    punpcklwd   xmmB, xmmF  ; xmmB=(01 11 21 31 03 13 23 33 05 15 25 35 07 17 27 37)
+    punpckhwd   xmmG, xmmF  ; xmmG=(09 19 29 39 0B 1B 2B 3B 0D 1D 2D 3D 0F 1F 2F 3F)
+
+    movdqa      xmmD, xmmA
+    punpckldq   xmmA, xmmB  ; xmmA=(00 10 20 30 01 11 21 31 02 12 22 32 03 13 23 33)
+    punpckhdq   xmmD, xmmB  ; xmmD=(04 14 24 34 05 15 25 35 06 16 26 36 07 17 27 37)
+    movdqa      xmmH, xmmC
+    punpckldq   xmmC, xmmG  ; xmmC=(08 18 28 38 09 19 29 39 0A 1A 2A 3A 0B 1B 2B 3B)
+    punpckhdq   xmmH, xmmG  ; xmmH=(0C 1C 2C 3C 0D 1D 2D 3D 0E 1E 2E 3E 0F 1F 2F 3F)
+
+    cmp         rcx, byte SIZEOF_XMMWORD
+    jb          short .column_st32
+
+    test        rdi, SIZEOF_XMMWORD-1
+    jnz         short .out1
+    ; --(aligned)-------------------
+    movntdq     XMMWORD [rdi+0*SIZEOF_XMMWORD], xmmA
+    movntdq     XMMWORD [rdi+1*SIZEOF_XMMWORD], xmmD
+    movntdq     XMMWORD [rdi+2*SIZEOF_XMMWORD], xmmC
+    movntdq     XMMWORD [rdi+3*SIZEOF_XMMWORD], xmmH
+    jmp         short .out0
+.out1:  ; --(unaligned)-----------------
+    movdqu      XMMWORD [rdi+0*SIZEOF_XMMWORD], xmmA
+    movdqu      XMMWORD [rdi+1*SIZEOF_XMMWORD], xmmD
+    movdqu      XMMWORD [rdi+2*SIZEOF_XMMWORD], xmmC
+    movdqu      XMMWORD [rdi+3*SIZEOF_XMMWORD], xmmH
+.out0:
+    add         rdi, byte RGB_PIXELSIZE*SIZEOF_XMMWORD  ; outptr
+    sub         rcx, byte SIZEOF_XMMWORD
+    jz          near .nextrow
+
+    add         rsi, byte SIZEOF_XMMWORD  ; inptr0
+    add         rbx, byte SIZEOF_XMMWORD  ; inptr1
+    add         rdx, byte SIZEOF_XMMWORD  ; inptr2
+    jmp         near .columnloop
+
+.column_st32:
+    cmp         rcx, byte SIZEOF_XMMWORD/2
+    jb          short .column_st16
+    movdqu      XMMWORD [rdi+0*SIZEOF_XMMWORD], xmmA
+    movdqu      XMMWORD [rdi+1*SIZEOF_XMMWORD], xmmD
+    add         rdi, byte 2*SIZEOF_XMMWORD  ; outptr
+    movdqa      xmmA, xmmC
+    movdqa      xmmD, xmmH
+    sub         rcx, byte SIZEOF_XMMWORD/2
+.column_st16:
+    cmp         rcx, byte SIZEOF_XMMWORD/4
+    jb          short .column_st15
+    movdqu      XMMWORD [rdi+0*SIZEOF_XMMWORD], xmmA
+    add         rdi, byte SIZEOF_XMMWORD    ; outptr
+    movdqa      xmmA, xmmD
+    sub         rcx, byte SIZEOF_XMMWORD/4
+.column_st15:
+    ; Store two pixels (8 bytes) of xmmA to the output when it has enough
+    ; space.
+    cmp         rcx, byte SIZEOF_XMMWORD/8
+    jb          short .column_st7
+    movq        MMWORD [rdi], xmmA
+    add         rdi, byte SIZEOF_XMMWORD/8*4
+    sub         rcx, byte SIZEOF_XMMWORD/8
+    psrldq      xmmA, SIZEOF_XMMWORD/8*4
+.column_st7:
+    ; Store one pixel (4 bytes) of xmmA to the output when it has enough
+    ; space.
+    test        rcx, rcx
+    jz          short .nextrow
+    movd        XMM_DWORD [rdi], xmmA
+
+%endif  ; RGB_PIXELSIZE ; ---------------
+
+.nextrow:
+    pop         rcx
+    pop         rsi
+    pop         rbx
+    pop         rdx
+    pop         rdi
+    pop         rax
+
+    add         rsi, byte SIZEOF_JSAMPROW
+    add         rbx, byte SIZEOF_JSAMPROW
+    add         rdx, byte SIZEOF_JSAMPROW
+    add         rdi, byte SIZEOF_JSAMPROW  ; output_buf
+    dec         rax                        ; num_rows
+    jg          near .rowloop
+
+    sfence                              ; flush the write buffer
+
+.return:
+    pop         rbx
+    uncollect_args 5
+    mov         rsp, rbp                ; rsp <- aligned rbp
+    pop         rsp                     ; rsp <- original rbp
+    pop         rbp
+    ret
+
+; For some reason, the OS X linker does not honor the request to align the
+; segment unless we do this.
+    align       32
diff --git a/3rdparty/libjpeg/src/simd/x86_64/jdcolor-avx2.asm b/3rdparty/libjpeg/src/simd/x86_64/jdcolor-avx2.asm
new file mode 100644
index 00000000..43de9db0
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/x86_64/jdcolor-avx2.asm
@@ -0,0 +1,118 @@
+;
+; jdcolor.asm - colorspace conversion (64-bit AVX2)
+;
+; Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+; Copyright (C) 2009, 2016, D. R. Commander.
+; Copyright (C) 2015, Intel Corporation.
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+;
+; This file should be assembled with NASM (Netwide Assembler),
+; can *not* be assembled with Microsoft's MASM or any compatible
+; assembler (including Borland's Turbo Assembler).
+; NASM is available from http://nasm.sourceforge.net/ or
+; http://sourceforge.net/project/showfiles.php?group_id=6208
+
+%include "jsimdext.inc"
+
+; --------------------------------------------------------------------------
+
+%define SCALEBITS  16
+
+F_0_344 equ  22554              ; FIX(0.34414)
+F_0_714 equ  46802              ; FIX(0.71414)
+F_1_402 equ  91881              ; FIX(1.40200)
+F_1_772 equ 116130              ; FIX(1.77200)
+F_0_402 equ (F_1_402 - 65536)   ; FIX(1.40200) - FIX(1)
+F_0_285 equ ( 65536 - F_0_714)  ; FIX(1) - FIX(0.71414)
+F_0_228 equ (131072 - F_1_772)  ; FIX(2) - FIX(1.77200)
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_CONST
+
+    alignz      32
+    GLOBAL_DATA(jconst_ycc_rgb_convert_avx2)
+
+EXTN(jconst_ycc_rgb_convert_avx2):
+
+PW_F0402        times 16 dw  F_0_402
+PW_MF0228       times 16 dw -F_0_228
+PW_MF0344_F0285 times 8  dw -F_0_344, F_0_285
+PW_ONE          times 16 dw  1
+PD_ONEHALF      times 8  dd  1 << (SCALEBITS - 1)
+
+    alignz      32
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_TEXT
+    BITS        64
+
+%include "jdcolext-avx2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_RGB_RED
+%define RGB_GREEN  EXT_RGB_GREEN
+%define RGB_BLUE  EXT_RGB_BLUE
+%define RGB_PIXELSIZE  EXT_RGB_PIXELSIZE
+%define jsimd_ycc_rgb_convert_avx2  jsimd_ycc_extrgb_convert_avx2
+%include "jdcolext-avx2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_RGBX_RED
+%define RGB_GREEN  EXT_RGBX_GREEN
+%define RGB_BLUE  EXT_RGBX_BLUE
+%define RGB_PIXELSIZE  EXT_RGBX_PIXELSIZE
+%define jsimd_ycc_rgb_convert_avx2  jsimd_ycc_extrgbx_convert_avx2
+%include "jdcolext-avx2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_BGR_RED
+%define RGB_GREEN  EXT_BGR_GREEN
+%define RGB_BLUE  EXT_BGR_BLUE
+%define RGB_PIXELSIZE  EXT_BGR_PIXELSIZE
+%define jsimd_ycc_rgb_convert_avx2  jsimd_ycc_extbgr_convert_avx2
+%include "jdcolext-avx2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_BGRX_RED
+%define RGB_GREEN  EXT_BGRX_GREEN
+%define RGB_BLUE  EXT_BGRX_BLUE
+%define RGB_PIXELSIZE  EXT_BGRX_PIXELSIZE
+%define jsimd_ycc_rgb_convert_avx2  jsimd_ycc_extbgrx_convert_avx2
+%include "jdcolext-avx2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_XBGR_RED
+%define RGB_GREEN  EXT_XBGR_GREEN
+%define RGB_BLUE  EXT_XBGR_BLUE
+%define RGB_PIXELSIZE  EXT_XBGR_PIXELSIZE
+%define jsimd_ycc_rgb_convert_avx2  jsimd_ycc_extxbgr_convert_avx2
+%include "jdcolext-avx2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_XRGB_RED
+%define RGB_GREEN  EXT_XRGB_GREEN
+%define RGB_BLUE  EXT_XRGB_BLUE
+%define RGB_PIXELSIZE  EXT_XRGB_PIXELSIZE
+%define jsimd_ycc_rgb_convert_avx2  jsimd_ycc_extxrgb_convert_avx2
+%include "jdcolext-avx2.asm"
diff --git a/3rdparty/libjpeg/src/simd/x86_64/jdcolor-sse2.asm b/3rdparty/libjpeg/src/simd/x86_64/jdcolor-sse2.asm
new file mode 100644
index 00000000..b3f1fec0
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/x86_64/jdcolor-sse2.asm
@@ -0,0 +1,117 @@
+;
+; jdcolor.asm - colorspace conversion (64-bit SSE2)
+;
+; Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+; Copyright (C) 2009, 2016, D. R. Commander.
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+;
+; This file should be assembled with NASM (Netwide Assembler),
+; can *not* be assembled with Microsoft's MASM or any compatible
+; assembler (including Borland's Turbo Assembler).
+; NASM is available from http://nasm.sourceforge.net/ or
+; http://sourceforge.net/project/showfiles.php?group_id=6208
+
+%include "jsimdext.inc"
+
+; --------------------------------------------------------------------------
+
+%define SCALEBITS  16
+
+F_0_344 equ  22554              ; FIX(0.34414)
+F_0_714 equ  46802              ; FIX(0.71414)
+F_1_402 equ  91881              ; FIX(1.40200)
+F_1_772 equ 116130              ; FIX(1.77200)
+F_0_402 equ (F_1_402 - 65536)   ; FIX(1.40200) - FIX(1)
+F_0_285 equ ( 65536 - F_0_714)  ; FIX(1) - FIX(0.71414)
+F_0_228 equ (131072 - F_1_772)  ; FIX(2) - FIX(1.77200)
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_CONST
+
+    alignz      32
+    GLOBAL_DATA(jconst_ycc_rgb_convert_sse2)
+
+EXTN(jconst_ycc_rgb_convert_sse2):
+
+PW_F0402        times 8 dw  F_0_402
+PW_MF0228       times 8 dw -F_0_228
+PW_MF0344_F0285 times 4 dw -F_0_344, F_0_285
+PW_ONE          times 8 dw  1
+PD_ONEHALF      times 4 dd  1 << (SCALEBITS - 1)
+
+    alignz      32
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_TEXT
+    BITS        64
+
+%include "jdcolext-sse2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_RGB_RED
+%define RGB_GREEN  EXT_RGB_GREEN
+%define RGB_BLUE  EXT_RGB_BLUE
+%define RGB_PIXELSIZE  EXT_RGB_PIXELSIZE
+%define jsimd_ycc_rgb_convert_sse2  jsimd_ycc_extrgb_convert_sse2
+%include "jdcolext-sse2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_RGBX_RED
+%define RGB_GREEN  EXT_RGBX_GREEN
+%define RGB_BLUE  EXT_RGBX_BLUE
+%define RGB_PIXELSIZE  EXT_RGBX_PIXELSIZE
+%define jsimd_ycc_rgb_convert_sse2  jsimd_ycc_extrgbx_convert_sse2
+%include "jdcolext-sse2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_BGR_RED
+%define RGB_GREEN  EXT_BGR_GREEN
+%define RGB_BLUE  EXT_BGR_BLUE
+%define RGB_PIXELSIZE  EXT_BGR_PIXELSIZE
+%define jsimd_ycc_rgb_convert_sse2  jsimd_ycc_extbgr_convert_sse2
+%include "jdcolext-sse2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_BGRX_RED
+%define RGB_GREEN  EXT_BGRX_GREEN
+%define RGB_BLUE  EXT_BGRX_BLUE
+%define RGB_PIXELSIZE  EXT_BGRX_PIXELSIZE
+%define jsimd_ycc_rgb_convert_sse2  jsimd_ycc_extbgrx_convert_sse2
+%include "jdcolext-sse2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_XBGR_RED
+%define RGB_GREEN  EXT_XBGR_GREEN
+%define RGB_BLUE  EXT_XBGR_BLUE
+%define RGB_PIXELSIZE  EXT_XBGR_PIXELSIZE
+%define jsimd_ycc_rgb_convert_sse2  jsimd_ycc_extxbgr_convert_sse2
+%include "jdcolext-sse2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_XRGB_RED
+%define RGB_GREEN  EXT_XRGB_GREEN
+%define RGB_BLUE  EXT_XRGB_BLUE
+%define RGB_PIXELSIZE  EXT_XRGB_PIXELSIZE
+%define jsimd_ycc_rgb_convert_sse2  jsimd_ycc_extxrgb_convert_sse2
+%include "jdcolext-sse2.asm"
diff --git a/3rdparty/libjpeg/src/simd/x86_64/jdmerge-avx2.asm b/3rdparty/libjpeg/src/simd/x86_64/jdmerge-avx2.asm
new file mode 100644
index 00000000..9515a170
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/x86_64/jdmerge-avx2.asm
@@ -0,0 +1,136 @@
+;
+; jdmerge.asm - merged upsampling/color conversion (64-bit AVX2)
+;
+; Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+; Copyright (C) 2009, 2016, D. R. Commander.
+; Copyright (C) 2015, Intel Corporation.
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+;
+; This file should be assembled with NASM (Netwide Assembler),
+; can *not* be assembled with Microsoft's MASM or any compatible
+; assembler (including Borland's Turbo Assembler).
+; NASM is available from http://nasm.sourceforge.net/ or
+; http://sourceforge.net/project/showfiles.php?group_id=6208
+
+%include "jsimdext.inc"
+
+; --------------------------------------------------------------------------
+
+%define SCALEBITS  16
+
+F_0_344 equ  22554              ; FIX(0.34414)
+F_0_714 equ  46802              ; FIX(0.71414)
+F_1_402 equ  91881              ; FIX(1.40200)
+F_1_772 equ 116130              ; FIX(1.77200)
+F_0_402 equ (F_1_402 - 65536)   ; FIX(1.40200) - FIX(1)
+F_0_285 equ ( 65536 - F_0_714)  ; FIX(1) - FIX(0.71414)
+F_0_228 equ (131072 - F_1_772)  ; FIX(2) - FIX(1.77200)
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_CONST
+
+    alignz      32
+    GLOBAL_DATA(jconst_merged_upsample_avx2)
+
+EXTN(jconst_merged_upsample_avx2):
+
+PW_F0402        times 16 dw  F_0_402
+PW_MF0228       times 16 dw -F_0_228
+PW_MF0344_F0285 times 8  dw -F_0_344, F_0_285
+PW_ONE          times 16 dw  1
+PD_ONEHALF      times 8  dd  1 << (SCALEBITS - 1)
+
+    alignz      32
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_TEXT
+    BITS        64
+
+%include "jdmrgext-avx2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_RGB_RED
+%define RGB_GREEN  EXT_RGB_GREEN
+%define RGB_BLUE  EXT_RGB_BLUE
+%define RGB_PIXELSIZE  EXT_RGB_PIXELSIZE
+%define jsimd_h2v1_merged_upsample_avx2 \
+  jsimd_h2v1_extrgb_merged_upsample_avx2
+%define jsimd_h2v2_merged_upsample_avx2 \
+  jsimd_h2v2_extrgb_merged_upsample_avx2
+%include "jdmrgext-avx2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_RGBX_RED
+%define RGB_GREEN  EXT_RGBX_GREEN
+%define RGB_BLUE  EXT_RGBX_BLUE
+%define RGB_PIXELSIZE  EXT_RGBX_PIXELSIZE
+%define jsimd_h2v1_merged_upsample_avx2 \
+  jsimd_h2v1_extrgbx_merged_upsample_avx2
+%define jsimd_h2v2_merged_upsample_avx2 \
+  jsimd_h2v2_extrgbx_merged_upsample_avx2
+%include "jdmrgext-avx2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_BGR_RED
+%define RGB_GREEN  EXT_BGR_GREEN
+%define RGB_BLUE  EXT_BGR_BLUE
+%define RGB_PIXELSIZE  EXT_BGR_PIXELSIZE
+%define jsimd_h2v1_merged_upsample_avx2 \
+  jsimd_h2v1_extbgr_merged_upsample_avx2
+%define jsimd_h2v2_merged_upsample_avx2 \
+  jsimd_h2v2_extbgr_merged_upsample_avx2
+%include "jdmrgext-avx2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_BGRX_RED
+%define RGB_GREEN  EXT_BGRX_GREEN
+%define RGB_BLUE  EXT_BGRX_BLUE
+%define RGB_PIXELSIZE  EXT_BGRX_PIXELSIZE
+%define jsimd_h2v1_merged_upsample_avx2 \
+  jsimd_h2v1_extbgrx_merged_upsample_avx2
+%define jsimd_h2v2_merged_upsample_avx2 \
+  jsimd_h2v2_extbgrx_merged_upsample_avx2
+%include "jdmrgext-avx2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_XBGR_RED
+%define RGB_GREEN  EXT_XBGR_GREEN
+%define RGB_BLUE  EXT_XBGR_BLUE
+%define RGB_PIXELSIZE  EXT_XBGR_PIXELSIZE
+%define jsimd_h2v1_merged_upsample_avx2 \
+  jsimd_h2v1_extxbgr_merged_upsample_avx2
+%define jsimd_h2v2_merged_upsample_avx2 \
+  jsimd_h2v2_extxbgr_merged_upsample_avx2
+%include "jdmrgext-avx2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_XRGB_RED
+%define RGB_GREEN  EXT_XRGB_GREEN
+%define RGB_BLUE  EXT_XRGB_BLUE
+%define RGB_PIXELSIZE  EXT_XRGB_PIXELSIZE
+%define jsimd_h2v1_merged_upsample_avx2 \
+  jsimd_h2v1_extxrgb_merged_upsample_avx2
+%define jsimd_h2v2_merged_upsample_avx2 \
+  jsimd_h2v2_extxrgb_merged_upsample_avx2
+%include "jdmrgext-avx2.asm"
diff --git a/3rdparty/libjpeg/src/simd/x86_64/jdmerge-sse2.asm b/3rdparty/libjpeg/src/simd/x86_64/jdmerge-sse2.asm
new file mode 100644
index 00000000..aedccc20
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/x86_64/jdmerge-sse2.asm
@@ -0,0 +1,135 @@
+;
+; jdmerge.asm - merged upsampling/color conversion (64-bit SSE2)
+;
+; Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+; Copyright (C) 2009, 2016, D. R. Commander.
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+;
+; This file should be assembled with NASM (Netwide Assembler),
+; can *not* be assembled with Microsoft's MASM or any compatible
+; assembler (including Borland's Turbo Assembler).
+; NASM is available from http://nasm.sourceforge.net/ or
+; http://sourceforge.net/project/showfiles.php?group_id=6208
+
+%include "jsimdext.inc"
+
+; --------------------------------------------------------------------------
+
+%define SCALEBITS  16
+
+F_0_344 equ  22554              ; FIX(0.34414)
+F_0_714 equ  46802              ; FIX(0.71414)
+F_1_402 equ  91881              ; FIX(1.40200)
+F_1_772 equ 116130              ; FIX(1.77200)
+F_0_402 equ (F_1_402 - 65536)   ; FIX(1.40200) - FIX(1)
+F_0_285 equ ( 65536 - F_0_714)  ; FIX(1) - FIX(0.71414)
+F_0_228 equ (131072 - F_1_772)  ; FIX(2) - FIX(1.77200)
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_CONST
+
+    alignz      32
+    GLOBAL_DATA(jconst_merged_upsample_sse2)
+
+EXTN(jconst_merged_upsample_sse2):
+
+PW_F0402        times 8 dw  F_0_402
+PW_MF0228       times 8 dw -F_0_228
+PW_MF0344_F0285 times 4 dw -F_0_344, F_0_285
+PW_ONE          times 8 dw  1
+PD_ONEHALF      times 4 dd  1 << (SCALEBITS - 1)
+
+    alignz      32
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_TEXT
+    BITS        64
+
+%include "jdmrgext-sse2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_RGB_RED
+%define RGB_GREEN  EXT_RGB_GREEN
+%define RGB_BLUE  EXT_RGB_BLUE
+%define RGB_PIXELSIZE  EXT_RGB_PIXELSIZE
+%define jsimd_h2v1_merged_upsample_sse2 \
+  jsimd_h2v1_extrgb_merged_upsample_sse2
+%define jsimd_h2v2_merged_upsample_sse2 \
+  jsimd_h2v2_extrgb_merged_upsample_sse2
+%include "jdmrgext-sse2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_RGBX_RED
+%define RGB_GREEN  EXT_RGBX_GREEN
+%define RGB_BLUE  EXT_RGBX_BLUE
+%define RGB_PIXELSIZE  EXT_RGBX_PIXELSIZE
+%define jsimd_h2v1_merged_upsample_sse2 \
+  jsimd_h2v1_extrgbx_merged_upsample_sse2
+%define jsimd_h2v2_merged_upsample_sse2 \
+  jsimd_h2v2_extrgbx_merged_upsample_sse2
+%include "jdmrgext-sse2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_BGR_RED
+%define RGB_GREEN  EXT_BGR_GREEN
+%define RGB_BLUE  EXT_BGR_BLUE
+%define RGB_PIXELSIZE  EXT_BGR_PIXELSIZE
+%define jsimd_h2v1_merged_upsample_sse2 \
+  jsimd_h2v1_extbgr_merged_upsample_sse2
+%define jsimd_h2v2_merged_upsample_sse2 \
+  jsimd_h2v2_extbgr_merged_upsample_sse2
+%include "jdmrgext-sse2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_BGRX_RED
+%define RGB_GREEN  EXT_BGRX_GREEN
+%define RGB_BLUE  EXT_BGRX_BLUE
+%define RGB_PIXELSIZE  EXT_BGRX_PIXELSIZE
+%define jsimd_h2v1_merged_upsample_sse2 \
+  jsimd_h2v1_extbgrx_merged_upsample_sse2
+%define jsimd_h2v2_merged_upsample_sse2 \
+  jsimd_h2v2_extbgrx_merged_upsample_sse2
+%include "jdmrgext-sse2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_XBGR_RED
+%define RGB_GREEN  EXT_XBGR_GREEN
+%define RGB_BLUE  EXT_XBGR_BLUE
+%define RGB_PIXELSIZE  EXT_XBGR_PIXELSIZE
+%define jsimd_h2v1_merged_upsample_sse2 \
+  jsimd_h2v1_extxbgr_merged_upsample_sse2
+%define jsimd_h2v2_merged_upsample_sse2 \
+  jsimd_h2v2_extxbgr_merged_upsample_sse2
+%include "jdmrgext-sse2.asm"
+
+%undef RGB_RED
+%undef RGB_GREEN
+%undef RGB_BLUE
+%undef RGB_PIXELSIZE
+%define RGB_RED  EXT_XRGB_RED
+%define RGB_GREEN  EXT_XRGB_GREEN
+%define RGB_BLUE  EXT_XRGB_BLUE
+%define RGB_PIXELSIZE  EXT_XRGB_PIXELSIZE
+%define jsimd_h2v1_merged_upsample_sse2 \
+  jsimd_h2v1_extxrgb_merged_upsample_sse2
+%define jsimd_h2v2_merged_upsample_sse2 \
+  jsimd_h2v2_extxrgb_merged_upsample_sse2
+%include "jdmrgext-sse2.asm"
diff --git a/3rdparty/libjpeg/src/simd/x86_64/jdmrgext-avx2.asm b/3rdparty/libjpeg/src/simd/x86_64/jdmrgext-avx2.asm
new file mode 100644
index 00000000..8b264b4f
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/x86_64/jdmrgext-avx2.asm
@@ -0,0 +1,596 @@
+;
+; jdmrgext.asm - merged upsampling/color conversion (64-bit AVX2)
+;
+; Copyright 2009, 2012 Pierre Ossman <ossman@cendio.se> for Cendio AB
+; Copyright (C) 2009, 2012, 2016, D. R. Commander.
+; Copyright (C) 2015, Intel Corporation.
+; Copyright (C) 2018, Matthias Räncker.
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+;
+; This file should be assembled with NASM (Netwide Assembler),
+; can *not* be assembled with Microsoft's MASM or any compatible
+; assembler (including Borland's Turbo Assembler).
+; NASM is available from http://nasm.sourceforge.net/ or
+; http://sourceforge.net/project/showfiles.php?group_id=6208
+
+%include "jcolsamp.inc"
+
+; --------------------------------------------------------------------------
+;
+; Upsample and color convert for the case of 2:1 horizontal and 1:1 vertical.
+;
+; GLOBAL(void)
+; jsimd_h2v1_merged_upsample_avx2(JDIMENSION output_width,
+;                                 JSAMPIMAGE input_buf,
+;                                 JDIMENSION in_row_group_ctr,
+;                                 JSAMPARRAY output_buf);
+;
+
+; r10d = JDIMENSION output_width
+; r11 = JSAMPIMAGE input_buf
+; r12d = JDIMENSION in_row_group_ctr
+; r13 = JSAMPARRAY output_buf
+
+%define wk(i)   rbp - (WK_NUM - (i)) * SIZEOF_YMMWORD  ; ymmword wk[WK_NUM]
+%define WK_NUM  3
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_h2v1_merged_upsample_avx2)
+
+EXTN(jsimd_h2v1_merged_upsample_avx2):
+    push        rbp
+    mov         rax, rsp                     ; rax = original rbp
+    sub         rsp, byte 4
+    and         rsp, byte (-SIZEOF_YMMWORD)  ; align to 256 bits
+    mov         [rsp], rax
+    mov         rbp, rsp                     ; rbp = aligned rbp
+    lea         rsp, [wk(0)]
+    collect_args 4
+    push        rbx
+
+    mov         ecx, r10d               ; col
+    test        rcx, rcx
+    jz          near .return
+
+    push        rcx
+
+    mov         rdi, r11
+    mov         ecx, r12d
+    mov         rsip, JSAMPARRAY [rdi+0*SIZEOF_JSAMPARRAY]
+    mov         rbxp, JSAMPARRAY [rdi+1*SIZEOF_JSAMPARRAY]
+    mov         rdxp, JSAMPARRAY [rdi+2*SIZEOF_JSAMPARRAY]
+    mov         rdi, r13
+    mov         rsip, JSAMPROW [rsi+rcx*SIZEOF_JSAMPROW]  ; inptr0
+    mov         rbxp, JSAMPROW [rbx+rcx*SIZEOF_JSAMPROW]  ; inptr1
+    mov         rdxp, JSAMPROW [rdx+rcx*SIZEOF_JSAMPROW]  ; inptr2
+    mov         rdip, JSAMPROW [rdi]                      ; outptr
+
+    pop         rcx                     ; col
+
+.columnloop:
+
+    vmovdqu     ymm6, YMMWORD [rbx]     ; ymm6=Cb(0123456789ABCDEFGHIJKLMNOPQRSTUV)
+    vmovdqu     ymm7, YMMWORD [rdx]     ; ymm7=Cr(0123456789ABCDEFGHIJKLMNOPQRSTUV)
+
+    vpxor       ymm1, ymm1, ymm1        ; ymm1=(all 0's)
+    vpcmpeqw    ymm3, ymm3, ymm3
+    vpsllw      ymm3, ymm3, 7           ; ymm3={0xFF80 0xFF80 0xFF80 0xFF80 ..}
+
+    vpermq      ymm6, ymm6, 0xd8        ; ymm6=Cb(01234567GHIJKLMN89ABCDEFOPQRSTUV)
+    vpermq      ymm7, ymm7, 0xd8        ; ymm7=Cr(01234567GHIJKLMN89ABCDEFOPQRSTUV)
+    vpunpcklbw  ymm4, ymm6, ymm1        ; ymm4=Cb(0123456789ABCDEF)=CbL
+    vpunpckhbw  ymm6, ymm6, ymm1        ; ymm6=Cb(GHIJKLMNOPQRSTUV)=CbH
+    vpunpcklbw  ymm0, ymm7, ymm1        ; ymm0=Cr(0123456789ABCDEF)=CrL
+    vpunpckhbw  ymm7, ymm7, ymm1        ; ymm7=Cr(GHIJKLMNOPQRSTUV)=CrH
+
+    vpaddw      ymm5, ymm6, ymm3
+    vpaddw      ymm2, ymm4, ymm3
+    vpaddw      ymm1, ymm7, ymm3
+    vpaddw      ymm3, ymm0, ymm3
+
+    ; (Original)
+    ; R = Y                + 1.40200 * Cr
+    ; G = Y - 0.34414 * Cb - 0.71414 * Cr
+    ; B = Y + 1.77200 * Cb
+    ;
+    ; (This implementation)
+    ; R = Y                + 0.40200 * Cr + Cr
+    ; G = Y - 0.34414 * Cb + 0.28586 * Cr - Cr
+    ; B = Y - 0.22800 * Cb + Cb + Cb
+
+    vpaddw      ymm6, ymm5, ymm5             ; ymm6=2*CbH
+    vpaddw      ymm4, ymm2, ymm2             ; ymm4=2*CbL
+    vpaddw      ymm7, ymm1, ymm1             ; ymm7=2*CrH
+    vpaddw      ymm0, ymm3, ymm3             ; ymm0=2*CrL
+
+    vpmulhw     ymm6, ymm6, [rel PW_MF0228]  ; ymm6=(2*CbH * -FIX(0.22800))
+    vpmulhw     ymm4, ymm4, [rel PW_MF0228]  ; ymm4=(2*CbL * -FIX(0.22800))
+    vpmulhw     ymm7, ymm7, [rel PW_F0402]   ; ymm7=(2*CrH * FIX(0.40200))
+    vpmulhw     ymm0, ymm0, [rel PW_F0402]   ; ymm0=(2*CrL * FIX(0.40200))
+
+    vpaddw      ymm6, ymm6, [rel PW_ONE]
+    vpaddw      ymm4, ymm4, [rel PW_ONE]
+    vpsraw      ymm6, ymm6, 1                ; ymm6=(CbH * -FIX(0.22800))
+    vpsraw      ymm4, ymm4, 1                ; ymm4=(CbL * -FIX(0.22800))
+    vpaddw      ymm7, ymm7, [rel PW_ONE]
+    vpaddw      ymm0, ymm0, [rel PW_ONE]
+    vpsraw      ymm7, ymm7, 1                ; ymm7=(CrH * FIX(0.40200))
+    vpsraw      ymm0, ymm0, 1                ; ymm0=(CrL * FIX(0.40200))
+
+    vpaddw      ymm6, ymm6, ymm5
+    vpaddw      ymm4, ymm4, ymm2
+    vpaddw      ymm6, ymm6, ymm5             ; ymm6=(CbH * FIX(1.77200))=(B-Y)H
+    vpaddw      ymm4, ymm4, ymm2             ; ymm4=(CbL * FIX(1.77200))=(B-Y)L
+    vpaddw      ymm7, ymm7, ymm1             ; ymm7=(CrH * FIX(1.40200))=(R-Y)H
+    vpaddw      ymm0, ymm0, ymm3             ; ymm0=(CrL * FIX(1.40200))=(R-Y)L
+
+    vmovdqa     YMMWORD [wk(0)], ymm6        ; wk(0)=(B-Y)H
+    vmovdqa     YMMWORD [wk(1)], ymm7        ; wk(1)=(R-Y)H
+
+    vpunpckhwd  ymm6, ymm5, ymm1
+    vpunpcklwd  ymm5, ymm5, ymm1
+    vpmaddwd    ymm5, ymm5, [rel PW_MF0344_F0285]
+    vpmaddwd    ymm6, ymm6, [rel PW_MF0344_F0285]
+    vpunpckhwd  ymm7, ymm2, ymm3
+    vpunpcklwd  ymm2, ymm2, ymm3
+    vpmaddwd    ymm2, ymm2, [rel PW_MF0344_F0285]
+    vpmaddwd    ymm7, ymm7, [rel PW_MF0344_F0285]
+
+    vpaddd      ymm5, ymm5, [rel PD_ONEHALF]
+    vpaddd      ymm6, ymm6, [rel PD_ONEHALF]
+    vpsrad      ymm5, ymm5, SCALEBITS
+    vpsrad      ymm6, ymm6, SCALEBITS
+    vpaddd      ymm2, ymm2, [rel PD_ONEHALF]
+    vpaddd      ymm7, ymm7, [rel PD_ONEHALF]
+    vpsrad      ymm2, ymm2, SCALEBITS
+    vpsrad      ymm7, ymm7, SCALEBITS
+
+    vpackssdw   ymm5, ymm5, ymm6        ; ymm5=CbH*-FIX(0.344)+CrH*FIX(0.285)
+    vpackssdw   ymm2, ymm2, ymm7        ; ymm2=CbL*-FIX(0.344)+CrL*FIX(0.285)
+    vpsubw      ymm5, ymm5, ymm1        ; ymm5=CbH*-FIX(0.344)+CrH*-FIX(0.714)=(G-Y)H
+    vpsubw      ymm2, ymm2, ymm3        ; ymm2=CbL*-FIX(0.344)+CrL*-FIX(0.714)=(G-Y)L
+
+    vmovdqa     YMMWORD [wk(2)], ymm5   ; wk(2)=(G-Y)H
+
+    mov         al, 2                   ; Yctr
+    jmp         short .Yloop_1st
+
+.Yloop_2nd:
+    vmovdqa     ymm0, YMMWORD [wk(1)]   ; ymm0=(R-Y)H
+    vmovdqa     ymm2, YMMWORD [wk(2)]   ; ymm2=(G-Y)H
+    vmovdqa     ymm4, YMMWORD [wk(0)]   ; ymm4=(B-Y)H
+
+.Yloop_1st:
+    vmovdqu     ymm7, YMMWORD [rsi]     ; ymm7=Y(0123456789ABCDEFGHIJKLMNOPQRSTUV)
+
+    vpcmpeqw    ymm6, ymm6, ymm6
+    vpsrlw      ymm6, ymm6, BYTE_BIT    ; ymm6={0xFF 0x00 0xFF 0x00 ..}
+    vpand       ymm6, ymm6, ymm7        ; ymm6=Y(02468ACEGIKMOQSU)=YE
+    vpsrlw      ymm7, ymm7, BYTE_BIT    ; ymm7=Y(13579BDFHJLNPRTV)=YO
+
+    vmovdqa     ymm1, ymm0              ; ymm1=ymm0=(R-Y)(L/H)
+    vmovdqa     ymm3, ymm2              ; ymm3=ymm2=(G-Y)(L/H)
+    vmovdqa     ymm5, ymm4              ; ymm5=ymm4=(B-Y)(L/H)
+
+    vpaddw      ymm0, ymm0, ymm6        ; ymm0=((R-Y)+YE)=RE=R(02468ACEGIKMOQSU)
+    vpaddw      ymm1, ymm1, ymm7        ; ymm1=((R-Y)+YO)=RO=R(13579BDFHJLNPRTV)
+    vpackuswb   ymm0, ymm0, ymm0        ; ymm0=R(02468ACE********GIKMOQSU********)
+    vpackuswb   ymm1, ymm1, ymm1        ; ymm1=R(13579BDF********HJLNPRTV********)
+
+    vpaddw      ymm2, ymm2, ymm6        ; ymm2=((G-Y)+YE)=GE=G(02468ACEGIKMOQSU)
+    vpaddw      ymm3, ymm3, ymm7        ; ymm3=((G-Y)+YO)=GO=G(13579BDFHJLNPRTV)
+    vpackuswb   ymm2, ymm2, ymm2        ; ymm2=G(02468ACE********GIKMOQSU********)
+    vpackuswb   ymm3, ymm3, ymm3        ; ymm3=G(13579BDF********HJLNPRTV********)
+
+    vpaddw      ymm4, ymm4, ymm6        ; ymm4=((B-Y)+YE)=BE=B(02468ACEGIKMOQSU)
+    vpaddw      ymm5, ymm5, ymm7        ; ymm5=((B-Y)+YO)=BO=B(13579BDFHJLNPRTV)
+    vpackuswb   ymm4, ymm4, ymm4        ; ymm4=B(02468ACE********GIKMOQSU********)
+    vpackuswb   ymm5, ymm5, ymm5        ; ymm5=B(13579BDF********HJLNPRTV********)
+
+%if RGB_PIXELSIZE == 3  ; ---------------
+
+    ; ymmA=(00 02 04 06 08 0A 0C 0E ** 0G 0I 0K 0M 0O 0Q 0S 0U **)
+    ; ymmB=(01 03 05 07 09 0B 0D 0F ** 0H 0J 0L 0N 0P 0R 0T 0V **)
+    ; ymmC=(10 12 14 16 18 1A 1C 1E ** 1G 1I 1K 1M 1O 1Q 1S 1U **)
+    ; ymmD=(11 13 15 17 19 1B 1D 1F ** 1H 1J 1L 1N 1P 1R 1T 1V **)
+    ; ymmE=(20 22 24 26 28 2A 2C 2E ** 2G 2I 2K 2M 2O 2Q 2S 2U **)
+    ; ymmF=(21 23 25 27 29 2B 2D 2F ** 2H 2J 2L 2N 2P 2R 2T 2V **)
+    ; ymmG=(** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** **)
+    ; ymmH=(** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** **)
+
+    vpunpcklbw  ymmA, ymmA, ymmC        ; ymmA=(00 10 02 12 04 14 06 16 08 18 0A 1A 0C 1C 0E 1E
+                                        ;       0G 1G 0I 1I 0K 1K 0M 1M 0O 1O 0Q 1Q 0S 1S 0U 1U)
+    vpunpcklbw  ymmE, ymmE, ymmB        ; ymmE=(20 01 22 03 24 05 26 07 28 09 2A 0B 2C 0D 2E 0F
+                                        ;       2G 0H 2I 0J 2K 0L 2M 0N 2O 0P 2Q 0R 2S 0T 2U 0V)
+    vpunpcklbw  ymmD, ymmD, ymmF        ; ymmD=(11 21 13 23 15 25 17 27 19 29 1B 2B 1D 2D 1F 2F
+                                        ;       1H 2H 1J 2J 1L 2L 1N 2N 1P 2P 1R 2R 1T 2T 1V 2V)
+
+    vpsrldq     ymmH, ymmA, 2           ; ymmH=(02 12 04 14 06 16 08 18 0A 1A 0C 1C 0E 1E 0G 1G
+                                        ;       0I 1I 0K 1K 0M 1M 0O 1O 0Q 1Q 0S 1S 0U 1U -- --)
+    vpunpckhwd  ymmG, ymmA, ymmE        ; ymmG=(08 18 28 09 0A 1A 2A 0B 0C 1C 2C 0D 0E 1E 2E 0F
+                                        ;       0O 1O 2O 0P 0Q 1Q 2Q 0R 0S 1S 2S 0T 0U 1U 2U 0V)
+    vpunpcklwd  ymmA, ymmA, ymmE        ; ymmA=(00 10 20 01 02 12 22 03 04 14 24 05 06 16 26 07
+                                        ;       0G 1G 2G 0H 0I 1I 2I 0J 0K 1K 2K 0L 0M 1M 2M 0N)
+
+    vpsrldq     ymmE, ymmE, 2           ; ymmE=(22 03 24 05 26 07 28 09 2A 0B 2C 0D 2E 0F 2G 0H
+                                        ;       2I 0J 2K 0L 2M 0N 2O 0P 2Q 0R 2S 0T 2U 0V -- --)
+
+    vpsrldq     ymmB, ymmD, 2           ; ymmB=(13 23 15 25 17 27 19 29 1B 2B 1D 2D 1F 2F 1H 2H
+                                        ;       1J 2J 1L 2L 1N 2N 1P 2P 1R 2R 1T 2T 1V 2V -- --)
+    vpunpckhwd  ymmC, ymmD, ymmH        ; ymmC=(19 29 0A 1A 1B 2B 0C 1C 1D 2D 0E 1E 1F 2F 0G 1G
+                                        ;       1P 2P 0Q 1Q 1R 2R 0S 1S 1T 2T 0U 1U 1V 2V -- --)
+    vpunpcklwd  ymmD, ymmD, ymmH        ; ymmD=(11 21 02 12 13 23 04 14 15 25 06 16 17 27 08 18
+                                        ;       1H 2H 0I 1I 1J 2J 0K 1K 1L 2L 0M 1M 1N 2N 0O 1O)
+
+    vpunpckhwd  ymmF, ymmE, ymmB        ; ymmF=(2A 0B 1B 2B 2C 0D 1D 2D 2E 0F 1F 2F 2G 0H 1H 2H
+                                        ;       2Q 0R 1R 2R 2S 0T 1T 2T 2U 0V 1V 2V -- -- -- --)
+    vpunpcklwd  ymmE, ymmE, ymmB        ; ymmE=(22 03 13 23 24 05 15 25 26 07 17 27 28 09 19 29
+                                        ;       2I 0J 1J 2J 2K 0L 1L 2L 2M 0N 1N 2N 2O 0P 1P 2P)
+
+    vpshufd     ymmH, ymmA, 0x4E        ; ymmH=(04 14 24 05 06 16 26 07 00 10 20 01 02 12 22 03
+                                        ;       0K 1K 2K 0L 0M 1M 2M 0N 0G 1G 2G 0H 0I 1I 2I 0J)
+    vpunpckldq  ymmA, ymmA, ymmD        ; ymmA=(00 10 20 01 11 21 02 12 02 12 22 03 13 23 04 14
+                                        ;       0G 1G 2G 0H 1H 2H 0I 1I 0I 1I 2I 0J 1J 2J 0K 1K)
+    vpunpckhdq  ymmD, ymmD, ymmE        ; ymmD=(15 25 06 16 26 07 17 27 17 27 08 18 28 09 19 29
+                                        ;       1L 2L 0M 1M 2M 0N 1N 2N 1N 2N 0O 1O 2O 0P 1P 2P)
+    vpunpckldq  ymmE, ymmE, ymmH        ; ymmE=(22 03 13 23 04 14 24 05 24 05 15 25 06 16 26 07
+                                        ;       2I 0J 1J 2J 0K 1K 2K 0L 2K 0L 1L 2L 0M 1M 2M 0N)
+
+    vpshufd     ymmH, ymmG, 0x4E        ; ymmH=(0C 1C 2C 0D 0E 1E 2E 0F 08 18 28 09 0A 1A 2A 0B
+                                        ;       0S 1S 2S 0T 0U 1U 2U 0V 0O 1O 2O 0P 0Q 1Q 2Q 0R)
+    vpunpckldq  ymmG, ymmG, ymmC        ; ymmG=(08 18 28 09 19 29 0A 1A 0A 1A 2A 0B 1B 2B 0C 1C
+                                        ;       0O 1O 2O 0P 1P 2P 0Q 1Q 0Q 1Q 2Q 0R 1R 2R 0S 1S)
+    vpunpckhdq  ymmC, ymmC, ymmF        ; ymmC=(1D 2D 0E 1E 2E 0F 1F 2F 1F 2F 0G 1G 2G 0H 1H 2H
+                                        ;       1T 2T 0U 1U 2U 0V 1V 2V 1V 2V -- -- -- -- -- --)
+    vpunpckldq  ymmF, ymmF, ymmH        ; ymmF=(2A 0B 1B 2B 0C 1C 2C 0D 2C 0D 1D 2D 0E 1E 2E 0F
+                                        ;       2Q 0R 1R 2R 0S 1S 2S 0T 2S 0T 1T 2T 0U 1U 2U 0V)
+
+    vpunpcklqdq ymmH, ymmA, ymmE        ; ymmH=(00 10 20 01 11 21 02 12 22 03 13 23 04 14 24 05
+                                        ;       0G 1G 2G 0H 1H 2H 0I 1I 2I 0J 1J 2J 0K 1K 2K 0L)
+    vpunpcklqdq ymmG, ymmD, ymmG        ; ymmG=(15 25 06 16 26 07 17 27 08 18 28 09 19 29 0A 1A
+                                        ;       1L 2L 0M 1M 2M 0N 1N 2N 0O 1O 2O 0P 1P 2P 0Q 1Q)
+    vpunpcklqdq ymmC, ymmF, ymmC        ; ymmC=(2A 0B 1B 2B 0C 1C 2C 0D 1D 2D 0E 1E 2E 0F 1F 2F
+                                        ;       2Q 0R 1R 2R 0S 1S 2S 0T 1T 2T 0U 1U 2U 0V 1V 2V)
+
+    vperm2i128  ymmA, ymmH, ymmG, 0x20  ; ymmA=(00 10 20 01 11 21 02 12 22 03 13 23 04 14 24 05
+                                        ;       15 25 06 16 26 07 17 27 08 18 28 09 19 29 0A 1A)
+    vperm2i128  ymmD, ymmC, ymmH, 0x30  ; ymmD=(2A 0B 1B 2B 0C 1C 2C 0D 1D 2D 0E 1E 2E 0F 1F 2F
+                                        ;       0G 1G 2G 0H 1H 2H 0I 1I 2I 0J 1J 2J 0K 1K 2K 0L)
+    vperm2i128  ymmF, ymmG, ymmC, 0x31  ; ymmF=(1L 2L 0M 1M 2M 0N 1N 2N 0O 1O 2O 0P 1P 2P 0Q 1Q
+                                        ;       2Q 0R 1R 2R 0S 1S 2S 0T 1T 2T 0U 1U 2U 0V 1V 2V)
+
+    cmp         rcx, byte SIZEOF_YMMWORD
+    jb          short .column_st64
+
+    test        rdi, SIZEOF_YMMWORD-1
+    jnz         short .out1
+    ; --(aligned)-------------------
+    vmovntdq    YMMWORD [rdi+0*SIZEOF_YMMWORD], ymmA
+    vmovntdq    YMMWORD [rdi+1*SIZEOF_YMMWORD], ymmD
+    vmovntdq    YMMWORD [rdi+2*SIZEOF_YMMWORD], ymmF
+    jmp         short .out0
+.out1:  ; --(unaligned)-----------------
+    vmovdqu     YMMWORD [rdi+0*SIZEOF_YMMWORD], ymmA
+    vmovdqu     YMMWORD [rdi+1*SIZEOF_YMMWORD], ymmD
+    vmovdqu     YMMWORD [rdi+2*SIZEOF_YMMWORD], ymmF
+.out0:
+    add         rdi, byte RGB_PIXELSIZE*SIZEOF_YMMWORD  ; outptr
+    sub         rcx, byte SIZEOF_YMMWORD
+    jz          near .endcolumn
+
+    add         rsi, byte SIZEOF_YMMWORD  ; inptr0
+    dec         al                        ; Yctr
+    jnz         near .Yloop_2nd
+
+    add         rbx, byte SIZEOF_YMMWORD  ; inptr1
+    add         rdx, byte SIZEOF_YMMWORD  ; inptr2
+    jmp         near .columnloop
+
+.column_st64:
+    lea         rcx, [rcx+rcx*2]            ; imul ecx, RGB_PIXELSIZE
+    cmp         rcx, byte 2*SIZEOF_YMMWORD
+    jb          short .column_st32
+    vmovdqu     YMMWORD [rdi+0*SIZEOF_YMMWORD], ymmA
+    vmovdqu     YMMWORD [rdi+1*SIZEOF_YMMWORD], ymmD
+    add         rdi, byte 2*SIZEOF_YMMWORD  ; outptr
+    vmovdqa     ymmA, ymmF
+    sub         rcx, byte 2*SIZEOF_YMMWORD
+    jmp         short .column_st31
+.column_st32:
+    cmp         rcx, byte SIZEOF_YMMWORD
+    jb          short .column_st31
+    vmovdqu     YMMWORD [rdi+0*SIZEOF_YMMWORD], ymmA
+    add         rdi, byte SIZEOF_YMMWORD    ; outptr
+    vmovdqa     ymmA, ymmD
+    sub         rcx, byte SIZEOF_YMMWORD
+    jmp         short .column_st31
+.column_st31:
+    cmp         rcx, byte SIZEOF_XMMWORD
+    jb          short .column_st15
+    vmovdqu     XMMWORD [rdi+0*SIZEOF_XMMWORD], xmmA
+    add         rdi, byte SIZEOF_XMMWORD    ; outptr
+    vperm2i128  ymmA, ymmA, ymmA, 1
+    sub         rcx, byte SIZEOF_XMMWORD
+.column_st15:
+    ; Store the lower 8 bytes of xmmA to the output when it has enough
+    ; space.
+    cmp         rcx, byte SIZEOF_MMWORD
+    jb          short .column_st7
+    vmovq       XMM_MMWORD [rdi], xmmA
+    add         rdi, byte SIZEOF_MMWORD
+    sub         rcx, byte SIZEOF_MMWORD
+    vpsrldq     xmmA, xmmA, SIZEOF_MMWORD
+.column_st7:
+    ; Store the lower 4 bytes of xmmA to the output when it has enough
+    ; space.
+    cmp         rcx, byte SIZEOF_DWORD
+    jb          short .column_st3
+    vmovd       XMM_DWORD [rdi], xmmA
+    add         rdi, byte SIZEOF_DWORD
+    sub         rcx, byte SIZEOF_DWORD
+    vpsrldq     xmmA, xmmA, SIZEOF_DWORD
+.column_st3:
+    ; Store the lower 2 bytes of rax to the output when it has enough
+    ; space.
+    vmovd       eax, xmmA
+    cmp         rcx, byte SIZEOF_WORD
+    jb          short .column_st1
+    mov         word [rdi], ax
+    add         rdi, byte SIZEOF_WORD
+    sub         rcx, byte SIZEOF_WORD
+    shr         rax, 16
+.column_st1:
+    ; Store the lower 1 byte of rax to the output when it has enough
+    ; space.
+    test        rcx, rcx
+    jz          short .endcolumn
+    mov         byte [rdi], al
+
+%else  ; RGB_PIXELSIZE == 4 ; -----------
+
+%ifdef RGBX_FILLER_0XFF
+    vpcmpeqb    ymm6, ymm6, ymm6        ; ymm6=XE=X(02468ACE********GIKMOQSU********)
+    vpcmpeqb    ymm7, ymm7, ymm7        ; ymm7=XO=X(13579BDF********HJLNPRTV********)
+%else
+    vpxor       ymm6, ymm6, ymm6        ; ymm6=XE=X(02468ACE********GIKMOQSU********)
+    vpxor       ymm7, ymm7, ymm7        ; ymm7=XO=X(13579BDF********HJLNPRTV********)
+%endif
+    ; ymmA=(00 02 04 06 08 0A 0C 0E ** 0G 0I 0K 0M 0O 0Q 0S 0U **)
+    ; ymmB=(01 03 05 07 09 0B 0D 0F ** 0H 0J 0L 0N 0P 0R 0T 0V **)
+    ; ymmC=(10 12 14 16 18 1A 1C 1E ** 1G 1I 1K 1M 1O 1Q 1S 1U **)
+    ; ymmD=(11 13 15 17 19 1B 1D 1F ** 1H 1J 1L 1N 1P 1R 1T 1V **)
+    ; ymmE=(20 22 24 26 28 2A 2C 2E ** 2G 2I 2K 2M 2O 2Q 2S 2U **)
+    ; ymmF=(21 23 25 27 29 2B 2D 2F ** 2H 2J 2L 2N 2P 2R 2T 2V **)
+    ; ymmG=(30 32 34 36 38 3A 3C 3E ** 3G 3I 3K 3M 3O 3Q 3S 3U **)
+    ; ymmH=(31 33 35 37 39 3B 3D 3F ** 3H 3J 3L 3N 3P 3R 3T 3V **)
+
+    vpunpcklbw  ymmA, ymmA, ymmC        ; ymmA=(00 10 02 12 04 14 06 16 08 18 0A 1A 0C 1C 0E 1E
+                                        ;       0G 1G 0I 1I 0K 1K 0M 1M 0O 1O 0Q 1Q 0S 1S 0U 1U)
+    vpunpcklbw  ymmE, ymmE, ymmG        ; ymmE=(20 30 22 32 24 34 26 36 28 38 2A 3A 2C 3C 2E 3E
+                                        ;       2G 3G 2I 3I 2K 3K 2M 3M 2O 3O 2Q 3Q 2S 3S 2U 3U)
+    vpunpcklbw  ymmB, ymmB, ymmD        ; ymmB=(01 11 03 13 05 15 07 17 09 19 0B 1B 0D 1D 0F 1F
+                                        ;       0H 1H 0J 1J 0L 1L 0N 1N 0P 1P 0R 1R 0T 1T 0V 1V)
+    vpunpcklbw  ymmF, ymmF, ymmH        ; ymmF=(21 31 23 33 25 35 27 37 29 39 2B 3B 2D 3D 2F 3F
+                                        ;       2H 3H 2J 3J 2L 3L 2N 3N 2P 3P 2R 3R 2T 3T 2V 3V)
+
+    vpunpckhwd  ymmC, ymmA, ymmE        ; ymmC=(08 18 28 38 0A 1A 2A 3A 0C 1C 2C 3C 0E 1E 2E 3E
+                                        ;       0O 1O 2O 3O 0Q 1Q 2Q 3Q 0S 1S 2S 3S 0U 1U 2U 3U)
+    vpunpcklwd  ymmA, ymmA, ymmE        ; ymmA=(00 10 20 30 02 12 22 32 04 14 24 34 06 16 26 36
+                                        ;       0G 1G 2G 3G 0I 1I 2I 3I 0K 1K 2K 3K 0M 1M 2M 3M)
+    vpunpckhwd  ymmG, ymmB, ymmF        ; ymmG=(09 19 29 39 0B 1B 2B 3B 0D 1D 2D 3D 0F 1F 2F 3F
+                                        ;       0P 1P 2P 3P 0R 1R 2R 3R 0T 1T 2T 3T 0V 1V 2V 3V)
+    vpunpcklwd  ymmB, ymmB, ymmF        ; ymmB=(01 11 21 31 03 13 23 33 05 15 25 35 07 17 27 37
+                                        ;       0H 1H 2H 3H 0J 1J 2J 3J 0L 1L 2L 3L 0N 1N 2N 3N)
+
+    vpunpckhdq  ymmE, ymmA, ymmB        ; ymmE=(04 14 24 34 05 15 25 35 06 16 26 36 07 17 27 37
+                                        ;       0K 1K 2K 3K 0L 1L 2L 3L 0M 1M 2M 3M 0N 1N 2N 3N)
+    vpunpckldq  ymmB, ymmA, ymmB        ; ymmB=(00 10 20 30 01 11 21 31 02 12 22 32 03 13 23 33
+                                        ;       0G 1G 2G 3G 0H 1H 2H 3H 0I 1I 2I 3I 0J 1J 2J 3J)
+    vpunpckhdq  ymmF, ymmC, ymmG        ; ymmF=(0C 1C 2C 3C 0D 1D 2D 3D 0E 1E 2E 3E 0F 1F 2F 3F
+                                        ;       0S 1S 2S 3S 0T 1T 2T 3T 0U 1U 2U 3U 0V 1V 2V 3V)
+    vpunpckldq  ymmG, ymmC, ymmG        ; ymmG=(08 18 28 38 09 19 29 39 0A 1A 2A 3A 0B 1B 2B 3B
+                                        ;       0O 1O 2O 3O 0P 1P 2P 3P 0Q 1Q 2Q 3Q 0R 1R 2R 3R)
+
+    vperm2i128  ymmA, ymmB, ymmE, 0x20  ; ymmA=(00 10 20 30 01 11 21 31 02 12 22 32 03 13 23 33
+                                        ;       04 14 24 34 05 15 25 35 06 16 26 36 07 17 27 37)
+    vperm2i128  ymmD, ymmG, ymmF, 0x20  ; ymmD=(08 18 28 38 09 19 29 39 0A 1A 2A 3A 0B 1B 2B 3B
+                                        ;       0C 1C 2C 3C 0D 1D 2D 3D 0E 1E 2E 3E 0F 1F 2F 3F)
+    vperm2i128  ymmC, ymmB, ymmE, 0x31  ; ymmC=(0G 1G 2G 3G 0H 1H 2H 3H 0I 1I 2I 3I 0J 1J 2J 3J
+                                        ;       0K 1K 2K 3K 0L 1L 2L 3L 0M 1M 2M 3M 0N 1N 2N 3N)
+    vperm2i128  ymmH, ymmG, ymmF, 0x31  ; ymmH=(0O 1O 2O 3O 0P 1P 2P 3P 0Q 1Q 2Q 3Q 0R 1R 2R 3R
+                                        ;       0S 1S 2S 3S 0T 1T 2T 3T 0U 1U 2U 3U 0V 1V 2V 3V)
+
+    cmp         rcx, byte SIZEOF_YMMWORD
+    jb          short .column_st64
+
+    test        rdi, SIZEOF_YMMWORD-1
+    jnz         short .out1
+    ; --(aligned)-------------------
+    vmovntdq    YMMWORD [rdi+0*SIZEOF_YMMWORD], ymmA
+    vmovntdq    YMMWORD [rdi+1*SIZEOF_YMMWORD], ymmD
+    vmovntdq    YMMWORD [rdi+2*SIZEOF_YMMWORD], ymmC
+    vmovntdq    YMMWORD [rdi+3*SIZEOF_YMMWORD], ymmH
+    jmp         short .out0
+.out1:  ; --(unaligned)-----------------
+    vmovdqu     YMMWORD [rdi+0*SIZEOF_YMMWORD], ymmA
+    vmovdqu     YMMWORD [rdi+1*SIZEOF_YMMWORD], ymmD
+    vmovdqu     YMMWORD [rdi+2*SIZEOF_YMMWORD], ymmC
+    vmovdqu     YMMWORD [rdi+3*SIZEOF_YMMWORD], ymmH
+.out0:
+    add         rdi, RGB_PIXELSIZE*SIZEOF_YMMWORD  ; outptr
+    sub         rcx, byte SIZEOF_YMMWORD
+    jz          near .endcolumn
+
+    add         rsi, byte SIZEOF_YMMWORD  ; inptr0
+    dec         al
+    jnz         near .Yloop_2nd
+
+    add         rbx, byte SIZEOF_YMMWORD  ; inptr1
+    add         rdx, byte SIZEOF_YMMWORD  ; inptr2
+    jmp         near .columnloop
+
+.column_st64:
+    cmp         rcx, byte SIZEOF_YMMWORD/2
+    jb          short .column_st32
+    vmovdqu     YMMWORD [rdi+0*SIZEOF_YMMWORD], ymmA
+    vmovdqu     YMMWORD [rdi+1*SIZEOF_YMMWORD], ymmD
+    add         rdi, byte 2*SIZEOF_YMMWORD  ; outptr
+    vmovdqa     ymmA, ymmC
+    vmovdqa     ymmD, ymmH
+    sub         rcx, byte SIZEOF_YMMWORD/2
+.column_st32:
+    cmp         rcx, byte SIZEOF_YMMWORD/4
+    jb          short .column_st16
+    vmovdqu     YMMWORD [rdi+0*SIZEOF_YMMWORD], ymmA
+    add         rdi, byte SIZEOF_YMMWORD    ; outptr
+    vmovdqa     ymmA, ymmD
+    sub         rcx, byte SIZEOF_YMMWORD/4
+.column_st16:
+    cmp         rcx, byte SIZEOF_YMMWORD/8
+    jb          short .column_st15
+    vmovdqu     XMMWORD [rdi+0*SIZEOF_XMMWORD], xmmA
+    add         rdi, byte SIZEOF_XMMWORD    ; outptr
+    vperm2i128  ymmA, ymmA, ymmA, 1
+    sub         rcx, byte SIZEOF_YMMWORD/8
+.column_st15:
+    ; Store two pixels (8 bytes) of ymmA to the output when it has enough
+    ; space.
+    cmp         rcx, byte SIZEOF_YMMWORD/16
+    jb          short .column_st7
+    vmovq       MMWORD [rdi], xmmA
+    add         rdi, byte SIZEOF_YMMWORD/16*4
+    sub         rcx, byte SIZEOF_YMMWORD/16
+    vpsrldq     xmmA, SIZEOF_YMMWORD/16*4
+.column_st7:
+    ; Store one pixel (4 bytes) of ymmA to the output when it has enough
+    ; space.
+    test        rcx, rcx
+    jz          short .endcolumn
+    vmovd       XMM_DWORD [rdi], xmmA
+
+%endif  ; RGB_PIXELSIZE ; ---------------
+
+.endcolumn:
+    sfence                              ; flush the write buffer
+
+.return:
+    pop         rbx
+    vzeroupper
+    uncollect_args 4
+    mov         rsp, rbp                ; rsp <- aligned rbp
+    pop         rsp                     ; rsp <- original rbp
+    pop         rbp
+    ret
+
+; --------------------------------------------------------------------------
+;
+; Upsample and color convert for the case of 2:1 horizontal and 2:1 vertical.
+;
+; GLOBAL(void)
+; jsimd_h2v2_merged_upsample_avx2(JDIMENSION output_width,
+;                                 JSAMPIMAGE input_buf,
+;                                 JDIMENSION in_row_group_ctr,
+;                                 JSAMPARRAY output_buf);
+;
+
+; r10d = JDIMENSION output_width
+; r11 = JSAMPIMAGE input_buf
+; r12d = JDIMENSION in_row_group_ctr
+; r13 = JSAMPARRAY output_buf
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_h2v2_merged_upsample_avx2)
+
+EXTN(jsimd_h2v2_merged_upsample_avx2):
+    push        rbp
+    mov         rax, rsp
+    mov         rbp, rsp
+    collect_args 4
+    push        rbx
+
+    mov         eax, r10d
+
+    mov         rdi, r11
+    mov         ecx, r12d
+    mov         rsip, JSAMPARRAY [rdi+0*SIZEOF_JSAMPARRAY]
+    mov         rbxp, JSAMPARRAY [rdi+1*SIZEOF_JSAMPARRAY]
+    mov         rdxp, JSAMPARRAY [rdi+2*SIZEOF_JSAMPARRAY]
+    mov         rdi, r13
+    lea         rsi, [rsi+rcx*SIZEOF_JSAMPROW]
+
+    sub         rsp, SIZEOF_JSAMPARRAY*4
+    mov         JSAMPARRAY [rsp+0*SIZEOF_JSAMPARRAY], rsip  ; intpr00
+    mov         JSAMPARRAY [rsp+1*SIZEOF_JSAMPARRAY], rbxp  ; intpr1
+    mov         JSAMPARRAY [rsp+2*SIZEOF_JSAMPARRAY], rdxp  ; intpr2
+    mov         rbx, rsp
+
+    push        rdi
+    push        rcx
+    push        rax
+
+    %ifdef WIN64
+    mov         r8, rcx
+    mov         r9, rdi
+    mov         rcx, rax
+    mov         rdx, rbx
+    %else
+    mov         rdx, rcx
+    mov         rcx, rdi
+    mov         rdi, rax
+    mov         rsi, rbx
+    %endif
+
+    call        EXTN(jsimd_h2v1_merged_upsample_avx2)
+
+    pop         rax
+    pop         rcx
+    pop         rdi
+    mov         rsip, JSAMPARRAY [rsp+0*SIZEOF_JSAMPARRAY]
+    mov         rbxp, JSAMPARRAY [rsp+1*SIZEOF_JSAMPARRAY]
+    mov         rdxp, JSAMPARRAY [rsp+2*SIZEOF_JSAMPARRAY]
+
+    add         rdi, byte SIZEOF_JSAMPROW  ; outptr1
+    add         rsi, byte SIZEOF_JSAMPROW  ; inptr01
+
+    mov         JSAMPARRAY [rsp+0*SIZEOF_JSAMPARRAY], rsip  ; intpr00
+    mov         JSAMPARRAY [rsp+1*SIZEOF_JSAMPARRAY], rbxp  ; intpr1
+    mov         JSAMPARRAY [rsp+2*SIZEOF_JSAMPARRAY], rdxp  ; intpr2
+    mov         rbx, rsp
+
+    push        rdi
+    push        rcx
+    push        rax
+
+    %ifdef WIN64
+    mov         r8, rcx
+    mov         r9, rdi
+    mov         rcx, rax
+    mov         rdx, rbx
+    %else
+    mov         rdx, rcx
+    mov         rcx, rdi
+    mov         rdi, rax
+    mov         rsi, rbx
+    %endif
+
+    call        EXTN(jsimd_h2v1_merged_upsample_avx2)
+
+    pop         rax
+    pop         rcx
+    pop         rdi
+    mov         rsip, JSAMPARRAY [rsp+0*SIZEOF_JSAMPARRAY]
+    mov         rbxp, JSAMPARRAY [rsp+1*SIZEOF_JSAMPARRAY]
+    mov         rdxp, JSAMPARRAY [rsp+2*SIZEOF_JSAMPARRAY]
+    add         rsp, SIZEOF_JSAMPARRAY*4
+
+    pop         rbx
+    uncollect_args 4
+    pop         rbp
+    ret
+
+; For some reason, the OS X linker does not honor the request to align the
+; segment unless we do this.
+    align       32
diff --git a/3rdparty/libjpeg/src/simd/x86_64/jdmrgext-sse2.asm b/3rdparty/libjpeg/src/simd/x86_64/jdmrgext-sse2.asm
new file mode 100644
index 00000000..eb3ab9db
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/x86_64/jdmrgext-sse2.asm
@@ -0,0 +1,538 @@
+;
+; jdmrgext.asm - merged upsampling/color conversion (64-bit SSE2)
+;
+; Copyright 2009, 2012 Pierre Ossman <ossman@cendio.se> for Cendio AB
+; Copyright (C) 2009, 2012, 2016, D. R. Commander.
+; Copyright (C) 2018, Matthias Räncker.
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+;
+; This file should be assembled with NASM (Netwide Assembler),
+; can *not* be assembled with Microsoft's MASM or any compatible
+; assembler (including Borland's Turbo Assembler).
+; NASM is available from http://nasm.sourceforge.net/ or
+; http://sourceforge.net/project/showfiles.php?group_id=6208
+
+%include "jcolsamp.inc"
+
+; --------------------------------------------------------------------------
+;
+; Upsample and color convert for the case of 2:1 horizontal and 1:1 vertical.
+;
+; GLOBAL(void)
+; jsimd_h2v1_merged_upsample_sse2(JDIMENSION output_width,
+;                                 JSAMPIMAGE input_buf,
+;                                 JDIMENSION in_row_group_ctr,
+;                                 JSAMPARRAY output_buf);
+;
+
+; r10d = JDIMENSION output_width
+; r11 = JSAMPIMAGE input_buf
+; r12d = JDIMENSION in_row_group_ctr
+; r13 = JSAMPARRAY output_buf
+
+%define wk(i)   rbp - (WK_NUM - (i)) * SIZEOF_XMMWORD  ; xmmword wk[WK_NUM]
+%define WK_NUM  3
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_h2v1_merged_upsample_sse2)
+
+EXTN(jsimd_h2v1_merged_upsample_sse2):
+    push        rbp
+    mov         rax, rsp                     ; rax = original rbp
+    sub         rsp, byte 4
+    and         rsp, byte (-SIZEOF_XMMWORD)  ; align to 128 bits
+    mov         [rsp], rax
+    mov         rbp, rsp                     ; rbp = aligned rbp
+    lea         rsp, [wk(0)]
+    collect_args 4
+    push        rbx
+
+    mov         ecx, r10d               ; col
+    test        rcx, rcx
+    jz          near .return
+
+    push        rcx
+
+    mov         rdi, r11
+    mov         ecx, r12d
+    mov         rsip, JSAMPARRAY [rdi+0*SIZEOF_JSAMPARRAY]
+    mov         rbxp, JSAMPARRAY [rdi+1*SIZEOF_JSAMPARRAY]
+    mov         rdxp, JSAMPARRAY [rdi+2*SIZEOF_JSAMPARRAY]
+    mov         rdi, r13
+    mov         rsip, JSAMPROW [rsi+rcx*SIZEOF_JSAMPROW]  ; inptr0
+    mov         rbxp, JSAMPROW [rbx+rcx*SIZEOF_JSAMPROW]  ; inptr1
+    mov         rdxp, JSAMPROW [rdx+rcx*SIZEOF_JSAMPROW]  ; inptr2
+    mov         rdip, JSAMPROW [rdi]                      ; outptr
+
+    pop         rcx                     ; col
+
+.columnloop:
+
+    movdqa      xmm6, XMMWORD [rbx]     ; xmm6=Cb(0123456789ABCDEF)
+    movdqa      xmm7, XMMWORD [rdx]     ; xmm7=Cr(0123456789ABCDEF)
+
+    pxor        xmm1, xmm1              ; xmm1=(all 0's)
+    pcmpeqw     xmm3, xmm3
+    psllw       xmm3, 7                 ; xmm3={0xFF80 0xFF80 0xFF80 0xFF80 ..}
+
+    movdqa      xmm4, xmm6
+    punpckhbw   xmm6, xmm1              ; xmm6=Cb(89ABCDEF)=CbH
+    punpcklbw   xmm4, xmm1              ; xmm4=Cb(01234567)=CbL
+    movdqa      xmm0, xmm7
+    punpckhbw   xmm7, xmm1              ; xmm7=Cr(89ABCDEF)=CrH
+    punpcklbw   xmm0, xmm1              ; xmm0=Cr(01234567)=CrL
+
+    paddw       xmm6, xmm3
+    paddw       xmm4, xmm3
+    paddw       xmm7, xmm3
+    paddw       xmm0, xmm3
+
+    ; (Original)
+    ; R = Y                + 1.40200 * Cr
+    ; G = Y - 0.34414 * Cb - 0.71414 * Cr
+    ; B = Y + 1.77200 * Cb
+    ;
+    ; (This implementation)
+    ; R = Y                + 0.40200 * Cr + Cr
+    ; G = Y - 0.34414 * Cb + 0.28586 * Cr - Cr
+    ; B = Y - 0.22800 * Cb + Cb + Cb
+
+    movdqa      xmm5, xmm6              ; xmm5=CbH
+    movdqa      xmm2, xmm4              ; xmm2=CbL
+    paddw       xmm6, xmm6              ; xmm6=2*CbH
+    paddw       xmm4, xmm4              ; xmm4=2*CbL
+    movdqa      xmm1, xmm7              ; xmm1=CrH
+    movdqa      xmm3, xmm0              ; xmm3=CrL
+    paddw       xmm7, xmm7              ; xmm7=2*CrH
+    paddw       xmm0, xmm0              ; xmm0=2*CrL
+
+    pmulhw      xmm6, [rel PW_MF0228]   ; xmm6=(2*CbH * -FIX(0.22800))
+    pmulhw      xmm4, [rel PW_MF0228]   ; xmm4=(2*CbL * -FIX(0.22800))
+    pmulhw      xmm7, [rel PW_F0402]    ; xmm7=(2*CrH * FIX(0.40200))
+    pmulhw      xmm0, [rel PW_F0402]    ; xmm0=(2*CrL * FIX(0.40200))
+
+    paddw       xmm6, [rel PW_ONE]
+    paddw       xmm4, [rel PW_ONE]
+    psraw       xmm6, 1                 ; xmm6=(CbH * -FIX(0.22800))
+    psraw       xmm4, 1                 ; xmm4=(CbL * -FIX(0.22800))
+    paddw       xmm7, [rel PW_ONE]
+    paddw       xmm0, [rel PW_ONE]
+    psraw       xmm7, 1                 ; xmm7=(CrH * FIX(0.40200))
+    psraw       xmm0, 1                 ; xmm0=(CrL * FIX(0.40200))
+
+    paddw       xmm6, xmm5
+    paddw       xmm4, xmm2
+    paddw       xmm6, xmm5              ; xmm6=(CbH * FIX(1.77200))=(B-Y)H
+    paddw       xmm4, xmm2              ; xmm4=(CbL * FIX(1.77200))=(B-Y)L
+    paddw       xmm7, xmm1              ; xmm7=(CrH * FIX(1.40200))=(R-Y)H
+    paddw       xmm0, xmm3              ; xmm0=(CrL * FIX(1.40200))=(R-Y)L
+
+    movdqa      XMMWORD [wk(0)], xmm6   ; wk(0)=(B-Y)H
+    movdqa      XMMWORD [wk(1)], xmm7   ; wk(1)=(R-Y)H
+
+    movdqa      xmm6, xmm5
+    movdqa      xmm7, xmm2
+    punpcklwd   xmm5, xmm1
+    punpckhwd   xmm6, xmm1
+    pmaddwd     xmm5, [rel PW_MF0344_F0285]
+    pmaddwd     xmm6, [rel PW_MF0344_F0285]
+    punpcklwd   xmm2, xmm3
+    punpckhwd   xmm7, xmm3
+    pmaddwd     xmm2, [rel PW_MF0344_F0285]
+    pmaddwd     xmm7, [rel PW_MF0344_F0285]
+
+    paddd       xmm5, [rel PD_ONEHALF]
+    paddd       xmm6, [rel PD_ONEHALF]
+    psrad       xmm5, SCALEBITS
+    psrad       xmm6, SCALEBITS
+    paddd       xmm2, [rel PD_ONEHALF]
+    paddd       xmm7, [rel PD_ONEHALF]
+    psrad       xmm2, SCALEBITS
+    psrad       xmm7, SCALEBITS
+
+    packssdw    xmm5, xmm6              ; xmm5=CbH*-FIX(0.344)+CrH*FIX(0.285)
+    packssdw    xmm2, xmm7              ; xmm2=CbL*-FIX(0.344)+CrL*FIX(0.285)
+    psubw       xmm5, xmm1              ; xmm5=CbH*-FIX(0.344)+CrH*-FIX(0.714)=(G-Y)H
+    psubw       xmm2, xmm3              ; xmm2=CbL*-FIX(0.344)+CrL*-FIX(0.714)=(G-Y)L
+
+    movdqa      XMMWORD [wk(2)], xmm5   ; wk(2)=(G-Y)H
+
+    mov         al, 2                   ; Yctr
+    jmp         short .Yloop_1st
+
+.Yloop_2nd:
+    movdqa      xmm0, XMMWORD [wk(1)]   ; xmm0=(R-Y)H
+    movdqa      xmm2, XMMWORD [wk(2)]   ; xmm2=(G-Y)H
+    movdqa      xmm4, XMMWORD [wk(0)]   ; xmm4=(B-Y)H
+
+.Yloop_1st:
+    movdqa      xmm7, XMMWORD [rsi]     ; xmm7=Y(0123456789ABCDEF)
+
+    pcmpeqw     xmm6, xmm6
+    psrlw       xmm6, BYTE_BIT          ; xmm6={0xFF 0x00 0xFF 0x00 ..}
+    pand        xmm6, xmm7              ; xmm6=Y(02468ACE)=YE
+    psrlw       xmm7, BYTE_BIT          ; xmm7=Y(13579BDF)=YO
+
+    movdqa      xmm1, xmm0              ; xmm1=xmm0=(R-Y)(L/H)
+    movdqa      xmm3, xmm2              ; xmm3=xmm2=(G-Y)(L/H)
+    movdqa      xmm5, xmm4              ; xmm5=xmm4=(B-Y)(L/H)
+
+    paddw       xmm0, xmm6              ; xmm0=((R-Y)+YE)=RE=R(02468ACE)
+    paddw       xmm1, xmm7              ; xmm1=((R-Y)+YO)=RO=R(13579BDF)
+    packuswb    xmm0, xmm0              ; xmm0=R(02468ACE********)
+    packuswb    xmm1, xmm1              ; xmm1=R(13579BDF********)
+
+    paddw       xmm2, xmm6              ; xmm2=((G-Y)+YE)=GE=G(02468ACE)
+    paddw       xmm3, xmm7              ; xmm3=((G-Y)+YO)=GO=G(13579BDF)
+    packuswb    xmm2, xmm2              ; xmm2=G(02468ACE********)
+    packuswb    xmm3, xmm3              ; xmm3=G(13579BDF********)
+
+    paddw       xmm4, xmm6              ; xmm4=((B-Y)+YE)=BE=B(02468ACE)
+    paddw       xmm5, xmm7              ; xmm5=((B-Y)+YO)=BO=B(13579BDF)
+    packuswb    xmm4, xmm4              ; xmm4=B(02468ACE********)
+    packuswb    xmm5, xmm5              ; xmm5=B(13579BDF********)
+
+%if RGB_PIXELSIZE == 3  ; ---------------
+
+    ; xmmA=(00 02 04 06 08 0A 0C 0E **), xmmB=(01 03 05 07 09 0B 0D 0F **)
+    ; xmmC=(10 12 14 16 18 1A 1C 1E **), xmmD=(11 13 15 17 19 1B 1D 1F **)
+    ; xmmE=(20 22 24 26 28 2A 2C 2E **), xmmF=(21 23 25 27 29 2B 2D 2F **)
+    ; xmmG=(** ** ** ** ** ** ** ** **), xmmH=(** ** ** ** ** ** ** ** **)
+
+    punpcklbw   xmmA, xmmC        ; xmmA=(00 10 02 12 04 14 06 16 08 18 0A 1A 0C 1C 0E 1E)
+    punpcklbw   xmmE, xmmB        ; xmmE=(20 01 22 03 24 05 26 07 28 09 2A 0B 2C 0D 2E 0F)
+    punpcklbw   xmmD, xmmF        ; xmmD=(11 21 13 23 15 25 17 27 19 29 1B 2B 1D 2D 1F 2F)
+
+    movdqa      xmmG, xmmA
+    movdqa      xmmH, xmmA
+    punpcklwd   xmmA, xmmE        ; xmmA=(00 10 20 01 02 12 22 03 04 14 24 05 06 16 26 07)
+    punpckhwd   xmmG, xmmE        ; xmmG=(08 18 28 09 0A 1A 2A 0B 0C 1C 2C 0D 0E 1E 2E 0F)
+
+    psrldq      xmmH, 2           ; xmmH=(02 12 04 14 06 16 08 18 0A 1A 0C 1C 0E 1E -- --)
+    psrldq      xmmE, 2           ; xmmE=(22 03 24 05 26 07 28 09 2A 0B 2C 0D 2E 0F -- --)
+
+    movdqa      xmmC, xmmD
+    movdqa      xmmB, xmmD
+    punpcklwd   xmmD, xmmH        ; xmmD=(11 21 02 12 13 23 04 14 15 25 06 16 17 27 08 18)
+    punpckhwd   xmmC, xmmH        ; xmmC=(19 29 0A 1A 1B 2B 0C 1C 1D 2D 0E 1E 1F 2F -- --)
+
+    psrldq      xmmB, 2           ; xmmB=(13 23 15 25 17 27 19 29 1B 2B 1D 2D 1F 2F -- --)
+
+    movdqa      xmmF, xmmE
+    punpcklwd   xmmE, xmmB        ; xmmE=(22 03 13 23 24 05 15 25 26 07 17 27 28 09 19 29)
+    punpckhwd   xmmF, xmmB        ; xmmF=(2A 0B 1B 2B 2C 0D 1D 2D 2E 0F 1F 2F -- -- -- --)
+
+    pshufd      xmmH, xmmA, 0x4E  ; xmmH=(04 14 24 05 06 16 26 07 00 10 20 01 02 12 22 03)
+    movdqa      xmmB, xmmE
+    punpckldq   xmmA, xmmD        ; xmmA=(00 10 20 01 11 21 02 12 02 12 22 03 13 23 04 14)
+    punpckldq   xmmE, xmmH        ; xmmE=(22 03 13 23 04 14 24 05 24 05 15 25 06 16 26 07)
+    punpckhdq   xmmD, xmmB        ; xmmD=(15 25 06 16 26 07 17 27 17 27 08 18 28 09 19 29)
+
+    pshufd      xmmH, xmmG, 0x4E  ; xmmH=(0C 1C 2C 0D 0E 1E 2E 0F 08 18 28 09 0A 1A 2A 0B)
+    movdqa      xmmB, xmmF
+    punpckldq   xmmG, xmmC        ; xmmG=(08 18 28 09 19 29 0A 1A 0A 1A 2A 0B 1B 2B 0C 1C)
+    punpckldq   xmmF, xmmH        ; xmmF=(2A 0B 1B 2B 0C 1C 2C 0D 2C 0D 1D 2D 0E 1E 2E 0F)
+    punpckhdq   xmmC, xmmB        ; xmmC=(1D 2D 0E 1E 2E 0F 1F 2F 1F 2F -- -- -- -- -- --)
+
+    punpcklqdq  xmmA, xmmE        ; xmmA=(00 10 20 01 11 21 02 12 22 03 13 23 04 14 24 05)
+    punpcklqdq  xmmD, xmmG        ; xmmD=(15 25 06 16 26 07 17 27 08 18 28 09 19 29 0A 1A)
+    punpcklqdq  xmmF, xmmC        ; xmmF=(2A 0B 1B 2B 0C 1C 2C 0D 1D 2D 0E 1E 2E 0F 1F 2F)
+
+    cmp         rcx, byte SIZEOF_XMMWORD
+    jb          short .column_st32
+
+    test        rdi, SIZEOF_XMMWORD-1
+    jnz         short .out1
+    ; --(aligned)-------------------
+    movntdq     XMMWORD [rdi+0*SIZEOF_XMMWORD], xmmA
+    movntdq     XMMWORD [rdi+1*SIZEOF_XMMWORD], xmmD
+    movntdq     XMMWORD [rdi+2*SIZEOF_XMMWORD], xmmF
+    jmp         short .out0
+.out1:  ; --(unaligned)-----------------
+    movdqu      XMMWORD [rdi+0*SIZEOF_XMMWORD], xmmA
+    movdqu      XMMWORD [rdi+1*SIZEOF_XMMWORD], xmmD
+    movdqu      XMMWORD [rdi+2*SIZEOF_XMMWORD], xmmF
+.out0:
+    add         rdi, byte RGB_PIXELSIZE*SIZEOF_XMMWORD  ; outptr
+    sub         rcx, byte SIZEOF_XMMWORD
+    jz          near .endcolumn
+
+    add         rsi, byte SIZEOF_XMMWORD  ; inptr0
+    dec         al                        ; Yctr
+    jnz         near .Yloop_2nd
+
+    add         rbx, byte SIZEOF_XMMWORD  ; inptr1
+    add         rdx, byte SIZEOF_XMMWORD  ; inptr2
+    jmp         near .columnloop
+
+.column_st32:
+    lea         rcx, [rcx+rcx*2]            ; imul ecx, RGB_PIXELSIZE
+    cmp         rcx, byte 2*SIZEOF_XMMWORD
+    jb          short .column_st16
+    movdqu      XMMWORD [rdi+0*SIZEOF_XMMWORD], xmmA
+    movdqu      XMMWORD [rdi+1*SIZEOF_XMMWORD], xmmD
+    add         rdi, byte 2*SIZEOF_XMMWORD  ; outptr
+    movdqa      xmmA, xmmF
+    sub         rcx, byte 2*SIZEOF_XMMWORD
+    jmp         short .column_st15
+.column_st16:
+    cmp         rcx, byte SIZEOF_XMMWORD
+    jb          short .column_st15
+    movdqu      XMMWORD [rdi+0*SIZEOF_XMMWORD], xmmA
+    add         rdi, byte SIZEOF_XMMWORD    ; outptr
+    movdqa      xmmA, xmmD
+    sub         rcx, byte SIZEOF_XMMWORD
+.column_st15:
+    ; Store the lower 8 bytes of xmmA to the output when it has enough
+    ; space.
+    cmp         rcx, byte SIZEOF_MMWORD
+    jb          short .column_st7
+    movq        XMM_MMWORD [rdi], xmmA
+    add         rdi, byte SIZEOF_MMWORD
+    sub         rcx, byte SIZEOF_MMWORD
+    psrldq      xmmA, SIZEOF_MMWORD
+.column_st7:
+    ; Store the lower 4 bytes of xmmA to the output when it has enough
+    ; space.
+    cmp         rcx, byte SIZEOF_DWORD
+    jb          short .column_st3
+    movd        XMM_DWORD [rdi], xmmA
+    add         rdi, byte SIZEOF_DWORD
+    sub         rcx, byte SIZEOF_DWORD
+    psrldq      xmmA, SIZEOF_DWORD
+.column_st3:
+    ; Store the lower 2 bytes of rax to the output when it has enough
+    ; space.
+    movd        eax, xmmA
+    cmp         rcx, byte SIZEOF_WORD
+    jb          short .column_st1
+    mov         word [rdi], ax
+    add         rdi, byte SIZEOF_WORD
+    sub         rcx, byte SIZEOF_WORD
+    shr         rax, 16
+.column_st1:
+    ; Store the lower 1 byte of rax to the output when it has enough
+    ; space.
+    test        rcx, rcx
+    jz          short .endcolumn
+    mov         byte [rdi], al
+
+%else  ; RGB_PIXELSIZE == 4 ; -----------
+
+%ifdef RGBX_FILLER_0XFF
+    pcmpeqb     xmm6, xmm6              ; xmm6=XE=X(02468ACE********)
+    pcmpeqb     xmm7, xmm7              ; xmm7=XO=X(13579BDF********)
+%else
+    pxor        xmm6, xmm6              ; xmm6=XE=X(02468ACE********)
+    pxor        xmm7, xmm7              ; xmm7=XO=X(13579BDF********)
+%endif
+    ; xmmA=(00 02 04 06 08 0A 0C 0E **), xmmB=(01 03 05 07 09 0B 0D 0F **)
+    ; xmmC=(10 12 14 16 18 1A 1C 1E **), xmmD=(11 13 15 17 19 1B 1D 1F **)
+    ; xmmE=(20 22 24 26 28 2A 2C 2E **), xmmF=(21 23 25 27 29 2B 2D 2F **)
+    ; xmmG=(30 32 34 36 38 3A 3C 3E **), xmmH=(31 33 35 37 39 3B 3D 3F **)
+
+    punpcklbw   xmmA, xmmC  ; xmmA=(00 10 02 12 04 14 06 16 08 18 0A 1A 0C 1C 0E 1E)
+    punpcklbw   xmmE, xmmG  ; xmmE=(20 30 22 32 24 34 26 36 28 38 2A 3A 2C 3C 2E 3E)
+    punpcklbw   xmmB, xmmD  ; xmmB=(01 11 03 13 05 15 07 17 09 19 0B 1B 0D 1D 0F 1F)
+    punpcklbw   xmmF, xmmH  ; xmmF=(21 31 23 33 25 35 27 37 29 39 2B 3B 2D 3D 2F 3F)
+
+    movdqa      xmmC, xmmA
+    punpcklwd   xmmA, xmmE  ; xmmA=(00 10 20 30 02 12 22 32 04 14 24 34 06 16 26 36)
+    punpckhwd   xmmC, xmmE  ; xmmC=(08 18 28 38 0A 1A 2A 3A 0C 1C 2C 3C 0E 1E 2E 3E)
+    movdqa      xmmG, xmmB
+    punpcklwd   xmmB, xmmF  ; xmmB=(01 11 21 31 03 13 23 33 05 15 25 35 07 17 27 37)
+    punpckhwd   xmmG, xmmF  ; xmmG=(09 19 29 39 0B 1B 2B 3B 0D 1D 2D 3D 0F 1F 2F 3F)
+
+    movdqa      xmmD, xmmA
+    punpckldq   xmmA, xmmB  ; xmmA=(00 10 20 30 01 11 21 31 02 12 22 32 03 13 23 33)
+    punpckhdq   xmmD, xmmB  ; xmmD=(04 14 24 34 05 15 25 35 06 16 26 36 07 17 27 37)
+    movdqa      xmmH, xmmC
+    punpckldq   xmmC, xmmG  ; xmmC=(08 18 28 38 09 19 29 39 0A 1A 2A 3A 0B 1B 2B 3B)
+    punpckhdq   xmmH, xmmG  ; xmmH=(0C 1C 2C 3C 0D 1D 2D 3D 0E 1E 2E 3E 0F 1F 2F 3F)
+
+    cmp         rcx, byte SIZEOF_XMMWORD
+    jb          short .column_st32
+
+    test        rdi, SIZEOF_XMMWORD-1
+    jnz         short .out1
+    ; --(aligned)-------------------
+    movntdq     XMMWORD [rdi+0*SIZEOF_XMMWORD], xmmA
+    movntdq     XMMWORD [rdi+1*SIZEOF_XMMWORD], xmmD
+    movntdq     XMMWORD [rdi+2*SIZEOF_XMMWORD], xmmC
+    movntdq     XMMWORD [rdi+3*SIZEOF_XMMWORD], xmmH
+    jmp         short .out0
+.out1:  ; --(unaligned)-----------------
+    movdqu      XMMWORD [rdi+0*SIZEOF_XMMWORD], xmmA
+    movdqu      XMMWORD [rdi+1*SIZEOF_XMMWORD], xmmD
+    movdqu      XMMWORD [rdi+2*SIZEOF_XMMWORD], xmmC
+    movdqu      XMMWORD [rdi+3*SIZEOF_XMMWORD], xmmH
+.out0:
+    add         rdi, byte RGB_PIXELSIZE*SIZEOF_XMMWORD  ; outptr
+    sub         rcx, byte SIZEOF_XMMWORD
+    jz          near .endcolumn
+
+    add         rsi, byte SIZEOF_XMMWORD  ; inptr0
+    dec         al                        ; Yctr
+    jnz         near .Yloop_2nd
+
+    add         rbx, byte SIZEOF_XMMWORD  ; inptr1
+    add         rdx, byte SIZEOF_XMMWORD  ; inptr2
+    jmp         near .columnloop
+
+.column_st32:
+    cmp         rcx, byte SIZEOF_XMMWORD/2
+    jb          short .column_st16
+    movdqu      XMMWORD [rdi+0*SIZEOF_XMMWORD], xmmA
+    movdqu      XMMWORD [rdi+1*SIZEOF_XMMWORD], xmmD
+    add         rdi, byte 2*SIZEOF_XMMWORD  ; outptr
+    movdqa      xmmA, xmmC
+    movdqa      xmmD, xmmH
+    sub         rcx, byte SIZEOF_XMMWORD/2
+.column_st16:
+    cmp         rcx, byte SIZEOF_XMMWORD/4
+    jb          short .column_st15
+    movdqu      XMMWORD [rdi+0*SIZEOF_XMMWORD], xmmA
+    add         rdi, byte SIZEOF_XMMWORD    ; outptr
+    movdqa      xmmA, xmmD
+    sub         rcx, byte SIZEOF_XMMWORD/4
+.column_st15:
+    ; Store two pixels (8 bytes) of xmmA to the output when it has enough
+    ; space.
+    cmp         rcx, byte SIZEOF_XMMWORD/8
+    jb          short .column_st7
+    movq        XMM_MMWORD [rdi], xmmA
+    add         rdi, byte SIZEOF_XMMWORD/8*4
+    sub         rcx, byte SIZEOF_XMMWORD/8
+    psrldq      xmmA, SIZEOF_XMMWORD/8*4
+.column_st7:
+    ; Store one pixel (4 bytes) of xmmA to the output when it has enough
+    ; space.
+    test        rcx, rcx
+    jz          short .endcolumn
+    movd        XMM_DWORD [rdi], xmmA
+
+%endif  ; RGB_PIXELSIZE ; ---------------
+
+.endcolumn:
+    sfence                              ; flush the write buffer
+
+.return:
+    pop         rbx
+    uncollect_args 4
+    mov         rsp, rbp                ; rsp <- aligned rbp
+    pop         rsp                     ; rsp <- original rbp
+    pop         rbp
+    ret
+
+; --------------------------------------------------------------------------
+;
+; Upsample and color convert for the case of 2:1 horizontal and 2:1 vertical.
+;
+; GLOBAL(void)
+; jsimd_h2v2_merged_upsample_sse2(JDIMENSION output_width,
+;                                 JSAMPIMAGE input_buf,
+;                                 JDIMENSION in_row_group_ctr,
+;                                 JSAMPARRAY output_buf);
+;
+
+; r10d = JDIMENSION output_width
+; r11 = JSAMPIMAGE input_buf
+; r12d = JDIMENSION in_row_group_ctr
+; r13 = JSAMPARRAY output_buf
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_h2v2_merged_upsample_sse2)
+
+EXTN(jsimd_h2v2_merged_upsample_sse2):
+    push        rbp
+    mov         rax, rsp
+    mov         rbp, rsp
+    collect_args 4
+    push        rbx
+
+    mov         eax, r10d
+
+    mov         rdi, r11
+    mov         ecx, r12d
+    mov         rsip, JSAMPARRAY [rdi+0*SIZEOF_JSAMPARRAY]
+    mov         rbxp, JSAMPARRAY [rdi+1*SIZEOF_JSAMPARRAY]
+    mov         rdxp, JSAMPARRAY [rdi+2*SIZEOF_JSAMPARRAY]
+    mov         rdi, r13
+    lea         rsi, [rsi+rcx*SIZEOF_JSAMPROW]
+
+    sub         rsp, SIZEOF_JSAMPARRAY*4
+    mov         JSAMPARRAY [rsp+0*SIZEOF_JSAMPARRAY], rsip  ; intpr00
+    mov         JSAMPARRAY [rsp+1*SIZEOF_JSAMPARRAY], rbxp  ; intpr1
+    mov         JSAMPARRAY [rsp+2*SIZEOF_JSAMPARRAY], rdxp  ; intpr2
+    mov         rbx, rsp
+
+    push        rdi
+    push        rcx
+    push        rax
+
+    %ifdef WIN64
+    mov         r8, rcx
+    mov         r9, rdi
+    mov         rcx, rax
+    mov         rdx, rbx
+    %else
+    mov         rdx, rcx
+    mov         rcx, rdi
+    mov         rdi, rax
+    mov         rsi, rbx
+    %endif
+
+    call        EXTN(jsimd_h2v1_merged_upsample_sse2)
+
+    pop         rax
+    pop         rcx
+    pop         rdi
+    mov         rsip, JSAMPARRAY [rsp+0*SIZEOF_JSAMPARRAY]
+    mov         rbxp, JSAMPARRAY [rsp+1*SIZEOF_JSAMPARRAY]
+    mov         rdxp, JSAMPARRAY [rsp+2*SIZEOF_JSAMPARRAY]
+
+    add         rdi, byte SIZEOF_JSAMPROW  ; outptr1
+    add         rsi, byte SIZEOF_JSAMPROW  ; inptr01
+
+    mov         JSAMPARRAY [rsp+0*SIZEOF_JSAMPARRAY], rsip  ; intpr00
+    mov         JSAMPARRAY [rsp+1*SIZEOF_JSAMPARRAY], rbxp  ; intpr1
+    mov         JSAMPARRAY [rsp+2*SIZEOF_JSAMPARRAY], rdxp  ; intpr2
+    mov         rbx, rsp
+
+    push        rdi
+    push        rcx
+    push        rax
+
+    %ifdef WIN64
+    mov         r8, rcx
+    mov         r9, rdi
+    mov         rcx, rax
+    mov         rdx, rbx
+    %else
+    mov         rdx, rcx
+    mov         rcx, rdi
+    mov         rdi, rax
+    mov         rsi, rbx
+    %endif
+
+    call        EXTN(jsimd_h2v1_merged_upsample_sse2)
+
+    pop         rax
+    pop         rcx
+    pop         rdi
+    mov         rsip, JSAMPARRAY [rsp+0*SIZEOF_JSAMPARRAY]
+    mov         rbxp, JSAMPARRAY [rsp+1*SIZEOF_JSAMPARRAY]
+    mov         rdxp, JSAMPARRAY [rsp+2*SIZEOF_JSAMPARRAY]
+    add         rsp, SIZEOF_JSAMPARRAY*4
+
+    pop         rbx
+    uncollect_args 4
+    pop         rbp
+    ret
+
+; For some reason, the OS X linker does not honor the request to align the
+; segment unless we do this.
+    align       32
diff --git a/3rdparty/libjpeg/src/simd/x86_64/jdsample-avx2.asm b/3rdparty/libjpeg/src/simd/x86_64/jdsample-avx2.asm
new file mode 100644
index 00000000..1e4979f9
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/x86_64/jdsample-avx2.asm
@@ -0,0 +1,696 @@
+;
+; jdsample.asm - upsampling (64-bit AVX2)
+;
+; Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+; Copyright (C) 2009, 2016, D. R. Commander.
+; Copyright (C) 2015, Intel Corporation.
+; Copyright (C) 2018, Matthias Räncker.
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+;
+; This file should be assembled with NASM (Netwide Assembler),
+; can *not* be assembled with Microsoft's MASM or any compatible
+; assembler (including Borland's Turbo Assembler).
+; NASM is available from http://nasm.sourceforge.net/ or
+; http://sourceforge.net/project/showfiles.php?group_id=6208
+
+%include "jsimdext.inc"
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_CONST
+
+    alignz      32
+    GLOBAL_DATA(jconst_fancy_upsample_avx2)
+
+EXTN(jconst_fancy_upsample_avx2):
+
+PW_ONE   times 16 dw 1
+PW_TWO   times 16 dw 2
+PW_THREE times 16 dw 3
+PW_SEVEN times 16 dw 7
+PW_EIGHT times 16 dw 8
+
+    alignz      32
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_TEXT
+    BITS        64
+;
+; Fancy processing for the common case of 2:1 horizontal and 1:1 vertical.
+;
+; The upsampling algorithm is linear interpolation between pixel centers,
+; also known as a "triangle filter".  This is a good compromise between
+; speed and visual quality.  The centers of the output pixels are 1/4 and 3/4
+; of the way between input pixel centers.
+;
+; GLOBAL(void)
+; jsimd_h2v1_fancy_upsample_avx2(int max_v_samp_factor,
+;                                JDIMENSION downsampled_width,
+;                                JSAMPARRAY input_data,
+;                                JSAMPARRAY *output_data_ptr);
+;
+
+; r10 = int max_v_samp_factor
+; r11d = JDIMENSION downsampled_width
+; r12 = JSAMPARRAY input_data
+; r13 = JSAMPARRAY *output_data_ptr
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_h2v1_fancy_upsample_avx2)
+
+EXTN(jsimd_h2v1_fancy_upsample_avx2):
+    push        rbp
+    mov         rax, rsp
+    mov         rbp, rsp
+    push_xmm    3
+    collect_args 4
+
+    mov         eax, r11d               ; colctr
+    test        rax, rax
+    jz          near .return
+
+    mov         rcx, r10                ; rowctr
+    test        rcx, rcx
+    jz          near .return
+
+    mov         rsi, r12                ; input_data
+    mov         rdi, r13
+    mov         rdip, JSAMPARRAY [rdi]  ; output_data
+
+    vpxor       ymm0, ymm0, ymm0                 ; ymm0=(all 0's)
+    vpcmpeqb    xmm9, xmm9, xmm9
+    vpsrldq     xmm10, xmm9, (SIZEOF_XMMWORD-1)  ; (ff -- -- -- ... -- --) LSB is ff
+
+    vpslldq     xmm9, xmm9, (SIZEOF_XMMWORD-1)
+    vperm2i128  ymm9, ymm9, ymm9, 1              ; (---- ---- ... ---- ---- ff) MSB is ff
+
+.rowloop:
+    push        rax                     ; colctr
+    push        rdi
+    push        rsi
+
+    mov         rsip, JSAMPROW [rsi]    ; inptr
+    mov         rdip, JSAMPROW [rdi]    ; outptr
+
+    test        rax, SIZEOF_YMMWORD-1
+    jz          short .skip
+    mov         dl, JSAMPLE [rsi+(rax-1)*SIZEOF_JSAMPLE]
+    mov         JSAMPLE [rsi+rax*SIZEOF_JSAMPLE], dl    ; insert a dummy sample
+.skip:
+    vpand       ymm7, ymm10, YMMWORD [rsi+0*SIZEOF_YMMWORD]
+
+    add         rax, byte SIZEOF_YMMWORD-1
+    and         rax, byte -SIZEOF_YMMWORD
+    cmp         rax, byte SIZEOF_YMMWORD
+    ja          short .columnloop
+
+.columnloop_last:
+    vpand       ymm6, ymm9, YMMWORD [rsi+0*SIZEOF_YMMWORD]
+    jmp         short .upsample
+
+.columnloop:
+    vmovdqu     ymm6, YMMWORD [rsi+1*SIZEOF_YMMWORD]
+    vperm2i128  ymm6, ymm0, ymm6, 0x20
+    vpslldq     ymm6, ymm6, 15
+
+.upsample:
+    vmovdqu     ymm1, YMMWORD [rsi+0*SIZEOF_YMMWORD]  ; ymm1=( 0  1  2 ... 29 30 31)
+
+    vperm2i128  ymm2, ymm0, ymm1, 0x20
+    vpalignr    ymm2, ymm1, ymm2, 15            ; ymm2=(--  0  1 ... 28 29 30)
+    vperm2i128  ymm4, ymm0, ymm1, 0x03
+    vpalignr    ymm3, ymm4, ymm1, 1             ; ymm3=( 1  2  3 ... 30 31 --)
+
+    vpor        ymm2, ymm2, ymm7                ; ymm2=(-1  0  1 ... 28 29 30)
+    vpor        ymm3, ymm3, ymm6                ; ymm3=( 1  2  3 ... 30 31 32)
+
+    vpsrldq     ymm7, ymm4, (SIZEOF_XMMWORD-1)  ; ymm7=(31 -- -- ... -- -- --)
+
+    vpunpckhbw  ymm4, ymm1, ymm0                ; ymm4=( 8  9 10 11 12 13 14 15 24 25 26 27 28 29 30 31)
+    vpunpcklbw  ymm5, ymm1, ymm0                ; ymm5=( 0  1  2  3  4  5  6  7 16 17 18 19 20 21 22 23)
+    vperm2i128  ymm1, ymm5, ymm4, 0x20          ; ymm1=( 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15)
+    vperm2i128  ymm4, ymm5, ymm4, 0x31          ; ymm4=(16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31)
+
+    vpunpckhbw  ymm5, ymm2, ymm0                ; ymm5=( 7  8  9 10 11 12 13 14 23 24 25 26 27 28 29 30)
+    vpunpcklbw  ymm6, ymm2, ymm0                ; ymm6=(-1  0  1  2  3  4  5  6 15 16 17 18 19 20 21 22)
+    vperm2i128  ymm2, ymm6, ymm5, 0x20          ; ymm2=(-1  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14)
+    vperm2i128  ymm5, ymm6, ymm5, 0x31          ; ymm5=(15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30)
+
+    vpunpckhbw  ymm6, ymm3, ymm0                ; ymm6=( 1  2  3  4  5  6  7  8 17 18 19 20 21 22 23 24)
+    vpunpcklbw  ymm8, ymm3, ymm0                ; ymm8=( 9 10 11 12 13 14 15 16 25 26 27 28 29 30 31 32)
+    vperm2i128  ymm3, ymm8, ymm6, 0x20          ; ymm3=( 1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16)
+    vperm2i128  ymm6, ymm8, ymm6, 0x31          ; ymm6=(17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32)
+
+    vpmullw     ymm1, ymm1, [rel PW_THREE]
+    vpmullw     ymm4, ymm4, [rel PW_THREE]
+    vpaddw      ymm2, ymm2, [rel PW_ONE]
+    vpaddw      ymm5, ymm5, [rel PW_ONE]
+    vpaddw      ymm3, ymm3, [rel PW_TWO]
+    vpaddw      ymm6, ymm6, [rel PW_TWO]
+
+    vpaddw      ymm2, ymm2, ymm1
+    vpaddw      ymm5, ymm5, ymm4
+    vpsrlw      ymm2, ymm2, 2                   ; ymm2=OutLE=( 0  2  4  6  8 10 12 14 16 18 20 22 24 26 28 30)
+    vpsrlw      ymm5, ymm5, 2                   ; ymm5=OutHE=(32 34 36 38 40 42 44 46 48 50 52 54 56 58 60 62)
+    vpaddw      ymm3, ymm3, ymm1
+    vpaddw      ymm6, ymm6, ymm4
+    vpsrlw      ymm3, ymm3, 2                   ; ymm3=OutLO=( 1  3  5  7  9 11 13 15 17 19 21 23 25 27 29 31)
+    vpsrlw      ymm6, ymm6, 2                   ; ymm6=OutHO=(33 35 37 39 41 43 45 47 49 51 53 55 57 59 61 63)
+
+    vpsllw      ymm3, ymm3, BYTE_BIT
+    vpsllw      ymm6, ymm6, BYTE_BIT
+    vpor        ymm2, ymm2, ymm3                ; ymm2=OutL=( 0  1  2 ... 29 30 31)
+    vpor        ymm5, ymm5, ymm6                ; ymm5=OutH=(32 33 34 ... 61 62 63)
+
+    vmovdqu     YMMWORD [rdi+0*SIZEOF_YMMWORD], ymm2
+    vmovdqu     YMMWORD [rdi+1*SIZEOF_YMMWORD], ymm5
+
+    sub         rax, byte SIZEOF_YMMWORD
+    add         rsi, byte 1*SIZEOF_YMMWORD  ; inptr
+    add         rdi, byte 2*SIZEOF_YMMWORD  ; outptr
+    cmp         rax, byte SIZEOF_YMMWORD
+    ja          near .columnloop
+    test        eax, eax
+    jnz         near .columnloop_last
+
+    pop         rsi
+    pop         rdi
+    pop         rax
+
+    add         rsi, byte SIZEOF_JSAMPROW  ; input_data
+    add         rdi, byte SIZEOF_JSAMPROW  ; output_data
+    dec         rcx                        ; rowctr
+    jg          near .rowloop
+
+.return:
+    vzeroupper
+    uncollect_args 4
+    pop_xmm     3
+    pop         rbp
+    ret
+
+; --------------------------------------------------------------------------
+;
+; Fancy processing for the common case of 2:1 horizontal and 2:1 vertical.
+; Again a triangle filter; see comments for h2v1 case, above.
+;
+; GLOBAL(void)
+; jsimd_h2v2_fancy_upsample_avx2(int max_v_samp_factor,
+;                                JDIMENSION downsampled_width,
+;                                JSAMPARRAY input_data,
+;                                JSAMPARRAY *output_data_ptr);
+;
+
+; r10 = int max_v_samp_factor
+; r11d = JDIMENSION downsampled_width
+; r12 = JSAMPARRAY input_data
+; r13 = JSAMPARRAY *output_data_ptr
+
+%define wk(i)   rbp - (WK_NUM - (i)) * SIZEOF_YMMWORD  ; ymmword wk[WK_NUM]
+%define WK_NUM  4
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_h2v2_fancy_upsample_avx2)
+
+EXTN(jsimd_h2v2_fancy_upsample_avx2):
+    push        rbp
+    mov         rax, rsp                     ; rax = original rbp
+    sub         rsp, byte 4
+    and         rsp, byte (-SIZEOF_YMMWORD)  ; align to 256 bits
+    mov         [rsp], rax
+    mov         rbp, rsp                     ; rbp = aligned rbp
+    lea         rsp, [wk(0)]
+    push_xmm    3
+    collect_args 4
+    push        rbx
+
+    mov         eax, r11d               ; colctr
+    test        rax, rax
+    jz          near .return
+
+    mov         rcx, r10                ; rowctr
+    test        rcx, rcx
+    jz          near .return
+
+    mov         rsi, r12                ; input_data
+    mov         rdi, r13
+    mov         rdip, JSAMPARRAY [rdi]  ; output_data
+.rowloop:
+    push        rax                     ; colctr
+    push        rcx
+    push        rdi
+    push        rsi
+
+    mov         rcxp, JSAMPROW [rsi-1*SIZEOF_JSAMPROW]  ; inptr1(above)
+    mov         rbxp, JSAMPROW [rsi+0*SIZEOF_JSAMPROW]  ; inptr0
+    mov         rsip, JSAMPROW [rsi+1*SIZEOF_JSAMPROW]  ; inptr1(below)
+    mov         rdxp, JSAMPROW [rdi+0*SIZEOF_JSAMPROW]  ; outptr0
+    mov         rdip, JSAMPROW [rdi+1*SIZEOF_JSAMPROW]  ; outptr1
+
+    vpxor       ymm8, ymm8, ymm8                 ; ymm8=(all 0's)
+    vpcmpeqb    xmm9, xmm9, xmm9
+    vpsrldq     xmm10, xmm9, (SIZEOF_XMMWORD-2)  ; (ffff ---- ---- ... ---- ----) LSB is ffff
+    vpslldq     xmm9, xmm9, (SIZEOF_XMMWORD-2)
+    vperm2i128  ymm9, ymm9, ymm9, 1              ; (---- ---- ... ---- ---- ffff) MSB is ffff
+
+    test        rax, SIZEOF_YMMWORD-1
+    jz          short .skip
+    push        rdx
+    mov         dl, JSAMPLE [rcx+(rax-1)*SIZEOF_JSAMPLE]
+    mov         JSAMPLE [rcx+rax*SIZEOF_JSAMPLE], dl
+    mov         dl, JSAMPLE [rbx+(rax-1)*SIZEOF_JSAMPLE]
+    mov         JSAMPLE [rbx+rax*SIZEOF_JSAMPLE], dl
+    mov         dl, JSAMPLE [rsi+(rax-1)*SIZEOF_JSAMPLE]
+    mov         JSAMPLE [rsi+rax*SIZEOF_JSAMPLE], dl    ; insert a dummy sample
+    pop         rdx
+.skip:
+    ; -- process the first column block
+
+    vmovdqu     ymm0, YMMWORD [rbx+0*SIZEOF_YMMWORD]  ; ymm0=row[ 0][0]
+    vmovdqu     ymm1, YMMWORD [rcx+0*SIZEOF_YMMWORD]  ; ymm1=row[-1][0]
+    vmovdqu     ymm2, YMMWORD [rsi+0*SIZEOF_YMMWORD]  ; ymm2=row[+1][0]
+
+    vpunpckhbw  ymm4, ymm0, ymm8        ; ymm4=row[ 0]( 8  9 10 11 12 13 14 15 24 25 26 27 28 29 30 31)
+    vpunpcklbw  ymm5, ymm0, ymm8        ; ymm5=row[ 0]( 0  1  2  3  4  5  6  7 16 17 18 19 20 21 22 23)
+    vperm2i128  ymm0, ymm5, ymm4, 0x20  ; ymm0=row[ 0]( 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15)
+    vperm2i128  ymm4, ymm5, ymm4, 0x31  ; ymm4=row[ 0](16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31)
+
+    vpunpckhbw  ymm5, ymm1, ymm8        ; ymm5=row[-1]( 8  9 10 11 12 13 14 15 24 25 26 27 28 29 30 31)
+    vpunpcklbw  ymm6, ymm1, ymm8        ; ymm6=row[-1]( 0  1  2  3  4  5  6  7 16 17 18 19 20 21 22 23)
+    vperm2i128  ymm1, ymm6, ymm5, 0x20  ; ymm1=row[-1]( 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15)
+    vperm2i128  ymm5, ymm6, ymm5, 0x31  ; ymm5=row[-1](16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31)
+
+    vpunpckhbw  ymm6, ymm2, ymm8        ; ymm6=row[+1]( 8  9 10 11 12 13 14 15 24 25 26 27 28 29 30 31)
+    vpunpcklbw  ymm3, ymm2, ymm8        ; ymm3=row[+1]( 0  1  2  3  4  5  6  7 16 17 18 19 20 21 22 23)
+    vperm2i128  ymm2, ymm3, ymm6, 0x20  ; ymm2=row[+1]( 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15)
+    vperm2i128  ymm6, ymm3, ymm6, 0x31  ; ymm6=row[+1](16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31)
+
+    vpmullw     ymm0, ymm0, [rel PW_THREE]
+    vpmullw     ymm4, ymm4, [rel PW_THREE]
+
+    vpaddw      ymm1, ymm1, ymm0        ; ymm1=Int0L=( 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15)
+    vpaddw      ymm5, ymm5, ymm4        ; ymm5=Int0H=(16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31)
+    vpaddw      ymm2, ymm2, ymm0        ; ymm2=Int1L=( 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15)
+    vpaddw      ymm6, ymm6, ymm4        ; ymm6=Int1H=(16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31)
+
+    vmovdqu     YMMWORD [rdx+0*SIZEOF_YMMWORD], ymm1  ; temporarily save
+    vmovdqu     YMMWORD [rdx+1*SIZEOF_YMMWORD], ymm5  ; the intermediate data
+    vmovdqu     YMMWORD [rdi+0*SIZEOF_YMMWORD], ymm2
+    vmovdqu     YMMWORD [rdi+1*SIZEOF_YMMWORD], ymm6
+
+    vpand       ymm1, ymm1, ymm10       ; ymm1=( 0 -- -- -- -- -- -- -- -- -- -- -- -- -- -- --)
+    vpand       ymm2, ymm2, ymm10       ; ymm2=( 0 -- -- -- -- -- -- -- -- -- -- -- -- -- -- --)
+
+    vmovdqa     YMMWORD [wk(0)], ymm1
+    vmovdqa     YMMWORD [wk(1)], ymm2
+
+    add         rax, byte SIZEOF_YMMWORD-1
+    and         rax, byte -SIZEOF_YMMWORD
+    cmp         rax, byte SIZEOF_YMMWORD
+    ja          short .columnloop
+
+.columnloop_last:
+    ; -- process the last column block
+
+    vpand       ymm1, ymm9, YMMWORD [rdx+1*SIZEOF_YMMWORD]
+    vpand       ymm2, ymm9, YMMWORD [rdi+1*SIZEOF_YMMWORD]
+
+    vmovdqa     YMMWORD [wk(2)], ymm1   ; ymm1=(-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 31)
+    vmovdqa     YMMWORD [wk(3)], ymm2   ; ymm2=(-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 31)
+
+    jmp         near .upsample
+
+.columnloop:
+    ; -- process the next column block
+
+    vmovdqu     ymm0, YMMWORD [rbx+1*SIZEOF_YMMWORD]  ; ymm0=row[ 0][1]
+    vmovdqu     ymm1, YMMWORD [rcx+1*SIZEOF_YMMWORD]  ; ymm1=row[-1][1]
+    vmovdqu     ymm2, YMMWORD [rsi+1*SIZEOF_YMMWORD]  ; ymm2=row[+1][1]
+
+    vpunpckhbw  ymm4, ymm0, ymm8        ; ymm4=row[ 0]( 8  9 10 11 12 13 14 15 24 25 26 27 28 29 30 31)
+    vpunpcklbw  ymm5, ymm0, ymm8        ; ymm5=row[ 0]( 0  1  2  3  4  5  6  7 16 17 18 19 20 21 22 23)
+    vperm2i128  ymm0, ymm5, ymm4, 0x20  ; ymm0=row[ 0]( 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15)
+    vperm2i128  ymm4, ymm5, ymm4, 0x31  ; ymm4=row[ 0](16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31)
+
+    vpunpckhbw  ymm5, ymm1, ymm8        ; ymm5=row[-1]( 8  9 10 11 12 13 14 15 24 25 26 27 28 29 30 31)
+    vpunpcklbw  ymm6, ymm1, ymm8        ; ymm6=row[-1]( 0  1  2  3  4  5  6  7 16 17 18 19 20 21 22 23)
+    vperm2i128  ymm1, ymm6, ymm5, 0x20  ; ymm1=row[-1]( 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15)
+    vperm2i128  ymm5, ymm6, ymm5, 0x31  ; ymm5=row[-1](16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31)
+
+    vpunpckhbw  ymm6, ymm2, ymm8        ; ymm6=row[+1]( 8  9 10 11 12 13 14 15 24 25 26 27 28 29 30 31)
+    vpunpcklbw  ymm7, ymm2, ymm8        ; ymm7=row[+1]( 0  1  2  3  4  5  6  7 16 17 18 19 20 21 22 23)
+    vperm2i128  ymm2, ymm7, ymm6, 0x20  ; ymm2=row[+1]( 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15)
+    vperm2i128  ymm6, ymm7, ymm6, 0x31  ; ymm6=row[+1](16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31)
+
+    vpmullw     ymm0, ymm0, [rel PW_THREE]
+    vpmullw     ymm4, ymm4, [rel PW_THREE]
+
+    vpaddw      ymm1, ymm1, ymm0        ; ymm1=Int0L=( 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15)
+    vpaddw      ymm5, ymm5, ymm4        ; ymm5=Int0H=(16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31)
+    vpaddw      ymm2, ymm2, ymm0        ; ymm2=Int1L=( 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15)
+    vpaddw      ymm6, ymm6, ymm4        ; ymm6=Int1H=(16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31)
+
+    vmovdqu     YMMWORD [rdx+2*SIZEOF_YMMWORD], ymm1  ; temporarily save
+    vmovdqu     YMMWORD [rdx+3*SIZEOF_YMMWORD], ymm5  ; the intermediate data
+    vmovdqu     YMMWORD [rdi+2*SIZEOF_YMMWORD], ymm2
+    vmovdqu     YMMWORD [rdi+3*SIZEOF_YMMWORD], ymm6
+
+    vperm2i128  ymm1, ymm8, ymm1, 0x20
+    vpslldq     ymm1, ymm1, 14          ; ymm1=(-- -- -- -- -- -- -- -- -- -- -- -- -- -- --  0)
+    vperm2i128  ymm2, ymm8, ymm2, 0x20
+    vpslldq     ymm2, ymm2, 14          ; ymm2=(-- -- -- -- -- -- -- -- -- -- -- -- -- -- --  0)
+
+    vmovdqa     YMMWORD [wk(2)], ymm1
+    vmovdqa     YMMWORD [wk(3)], ymm2
+
+.upsample:
+    ; -- process the upper row
+
+    vmovdqu     ymm7, YMMWORD [rdx+0*SIZEOF_YMMWORD]  ; ymm7=Int0L=( 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15)
+    vmovdqu     ymm3, YMMWORD [rdx+1*SIZEOF_YMMWORD]  ; ymm3=Int0H=(16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31)
+
+    vperm2i128  ymm0, ymm8, ymm7, 0x03
+    vpalignr    ymm0, ymm0, ymm7, 2     ; ymm0=( 1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 --)
+    vperm2i128  ymm4, ymm8, ymm3, 0x20
+    vpslldq     ymm4, ymm4, 14          ; ymm4=(-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 16)
+
+    vperm2i128  ymm5, ymm8, ymm7, 0x03
+    vpsrldq     ymm5, ymm5, 14          ; ymm5=(15 -- -- -- -- -- -- -- -- -- -- -- -- -- -- --)
+    vperm2i128  ymm6, ymm8, ymm3, 0x20
+    vpalignr    ymm6, ymm3, ymm6, 14    ; ymm6=(-- 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30)
+
+    vpor        ymm0, ymm0, ymm4        ; ymm0=( 1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16)
+    vpor        ymm5, ymm5, ymm6        ; ymm5=(15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30)
+
+    vperm2i128  ymm2, ymm8, ymm3, 0x03
+    vpalignr    ymm2, ymm2, ymm3, 2     ; ymm2=(17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 --)
+    vperm2i128  ymm4, ymm8, ymm3, 0x03
+    vpsrldq     ymm4, ymm4, 14          ; ymm4=(31 -- -- -- -- -- -- -- -- -- -- -- -- -- -- --)
+    vperm2i128  ymm1, ymm8, ymm7, 0x20
+    vpalignr    ymm1, ymm7, ymm1, 14    ; ymm1=(--  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14)
+
+    vpor        ymm1, ymm1, YMMWORD [wk(0)]  ; ymm1=(-1  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14)
+    vpor        ymm2, ymm2, YMMWORD [wk(2)]  ; ymm2=(17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32)
+
+    vmovdqa     YMMWORD [wk(0)], ymm4
+
+    vpmullw     ymm7, ymm7, [rel PW_THREE]
+    vpmullw     ymm3, ymm3, [rel PW_THREE]
+    vpaddw      ymm1, ymm1, [rel PW_EIGHT]
+    vpaddw      ymm5, ymm5, [rel PW_EIGHT]
+    vpaddw      ymm0, ymm0, [rel PW_SEVEN]
+    vpaddw      ymm2, [rel PW_SEVEN]
+
+    vpaddw      ymm1, ymm1, ymm7
+    vpaddw      ymm5, ymm5, ymm3
+    vpsrlw      ymm1, ymm1, 4           ; ymm1=Out0LE=( 0  2  4  6  8 10 12 14 16 18 20 22 24 26 28 30)
+    vpsrlw      ymm5, ymm5, 4           ; ymm5=Out0HE=(32 34 36 38 40 42 44 46 48 50 52 54 56 58 60 62)
+    vpaddw      ymm0, ymm0, ymm7
+    vpaddw      ymm2, ymm2, ymm3
+    vpsrlw      ymm0, ymm0, 4           ; ymm0=Out0LO=( 1  3  5  7  9 11 13 15 17 19 21 23 25 27 29 31)
+    vpsrlw      ymm2, ymm2, 4           ; ymm2=Out0HO=(33 35 37 39 41 43 45 47 49 51 53 55 57 59 61 63)
+
+    vpsllw      ymm0, ymm0, BYTE_BIT
+    vpsllw      ymm2, ymm2, BYTE_BIT
+    vpor        ymm1, ymm1, ymm0        ; ymm1=Out0L=( 0  1  2 ... 29 30 31)
+    vpor        ymm5, ymm5, ymm2        ; ymm5=Out0H=(32 33 34 ... 61 62 63)
+
+    vmovdqu     YMMWORD [rdx+0*SIZEOF_YMMWORD], ymm1
+    vmovdqu     YMMWORD [rdx+1*SIZEOF_YMMWORD], ymm5
+
+    ; -- process the lower row
+
+    vmovdqu     ymm6, YMMWORD [rdi+0*SIZEOF_YMMWORD]  ; ymm6=Int1L=( 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15)
+    vmovdqu     ymm4, YMMWORD [rdi+1*SIZEOF_YMMWORD]  ; ymm4=Int1H=(16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31)
+
+    vperm2i128  ymm7, ymm8, ymm6, 0x03
+    vpalignr    ymm7, ymm7, ymm6, 2     ; ymm7=( 1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 --)
+    vperm2i128  ymm3, ymm8, ymm4, 0x20
+    vpslldq     ymm3, ymm3, 14          ; ymm3=(-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 16)
+
+    vperm2i128  ymm0, ymm8, ymm6, 0x03
+    vpsrldq     ymm0, ymm0, 14          ; ymm0=(15 -- -- -- -- -- -- -- -- -- -- -- -- -- -- --)
+    vperm2i128  ymm2, ymm8, ymm4, 0x20
+    vpalignr    ymm2, ymm4, ymm2, 14    ; ymm2=(-- 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30)
+
+    vpor        ymm7, ymm7, ymm3        ; ymm7=( 1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16)
+    vpor        ymm0, ymm0, ymm2        ; ymm0=(15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30)
+
+    vperm2i128  ymm5, ymm8, ymm4, 0x03
+    vpalignr    ymm5, ymm5, ymm4, 2     ; ymm5=(17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 --)
+    vperm2i128  ymm3, ymm8, ymm4, 0x03
+    vpsrldq     ymm3, ymm3, 14          ; ymm3=(31 -- -- -- -- -- -- -- -- -- -- -- -- -- -- --)
+    vperm2i128  ymm1, ymm8, ymm6, 0x20
+    vpalignr    ymm1, ymm6, ymm1, 14    ; ymm1=(--  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14)
+
+    vpor        ymm1, ymm1, YMMWORD [wk(1)]  ; ymm1=(-1  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14)
+    vpor        ymm5, ymm5, YMMWORD [wk(3)]  ; ymm5=(17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32)
+
+    vmovdqa     YMMWORD [wk(1)], ymm3
+
+    vpmullw     ymm6, ymm6, [rel PW_THREE]
+    vpmullw     ymm4, ymm4, [rel PW_THREE]
+    vpaddw      ymm1, ymm1, [rel PW_EIGHT]
+    vpaddw      ymm0, ymm0, [rel PW_EIGHT]
+    vpaddw      ymm7, ymm7, [rel PW_SEVEN]
+    vpaddw      ymm5, ymm5, [rel PW_SEVEN]
+
+    vpaddw      ymm1, ymm1, ymm6
+    vpaddw      ymm0, ymm0, ymm4
+    vpsrlw      ymm1, ymm1, 4           ; ymm1=Out1LE=( 0  2  4  6  8 10 12 14 16 18 20 22 24 26 28 30)
+    vpsrlw      ymm0, ymm0, 4           ; ymm0=Out1HE=(32 34 36 38 40 42 44 46 48 50 52 54 56 58 60 62)
+    vpaddw      ymm7, ymm7, ymm6
+    vpaddw      ymm5, ymm5, ymm4
+    vpsrlw      ymm7, ymm7, 4           ; ymm7=Out1LO=( 1  3  5  7  9 11 13 15 17 19 21 23 25 27 29 31)
+    vpsrlw      ymm5, ymm5, 4           ; ymm5=Out1HO=(33 35 37 39 41 43 45 47 49 51 53 55 57 59 61 63)
+
+    vpsllw      ymm7, ymm7, BYTE_BIT
+    vpsllw      ymm5, ymm5, BYTE_BIT
+    vpor        ymm1, ymm1, ymm7        ; ymm1=Out1L=( 0  1  2 ... 29 30 31)
+    vpor        ymm0, ymm0, ymm5        ; ymm0=Out1H=(32 33 34 ... 61 62 63)
+
+    vmovdqu     YMMWORD [rdi+0*SIZEOF_YMMWORD], ymm1
+    vmovdqu     YMMWORD [rdi+1*SIZEOF_YMMWORD], ymm0
+
+    sub         rax, byte SIZEOF_YMMWORD
+    add         rcx, byte 1*SIZEOF_YMMWORD  ; inptr1(above)
+    add         rbx, byte 1*SIZEOF_YMMWORD  ; inptr0
+    add         rsi, byte 1*SIZEOF_YMMWORD  ; inptr1(below)
+    add         rdx, byte 2*SIZEOF_YMMWORD  ; outptr0
+    add         rdi, byte 2*SIZEOF_YMMWORD  ; outptr1
+    cmp         rax, byte SIZEOF_YMMWORD
+    ja          near .columnloop
+    test        rax, rax
+    jnz         near .columnloop_last
+
+    pop         rsi
+    pop         rdi
+    pop         rcx
+    pop         rax
+
+    add         rsi, byte 1*SIZEOF_JSAMPROW  ; input_data
+    add         rdi, byte 2*SIZEOF_JSAMPROW  ; output_data
+    sub         rcx, byte 2                  ; rowctr
+    jg          near .rowloop
+
+.return:
+    pop         rbx
+    vzeroupper
+    uncollect_args 4
+    pop_xmm     3
+    mov         rsp, rbp                ; rsp <- aligned rbp
+    pop         rsp                     ; rsp <- original rbp
+    pop         rbp
+    ret
+
+; --------------------------------------------------------------------------
+;
+; Fast processing for the common case of 2:1 horizontal and 1:1 vertical.
+; It's still a box filter.
+;
+; GLOBAL(void)
+; jsimd_h2v1_upsample_avx2(int max_v_samp_factor, JDIMENSION output_width,
+;                          JSAMPARRAY input_data, JSAMPARRAY *output_data_ptr);
+;
+
+; r10 = int max_v_samp_factor
+; r11d = JDIMENSION output_width
+; r12 = JSAMPARRAY input_data
+; r13 = JSAMPARRAY *output_data_ptr
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_h2v1_upsample_avx2)
+
+EXTN(jsimd_h2v1_upsample_avx2):
+    push        rbp
+    mov         rax, rsp
+    mov         rbp, rsp
+    collect_args 4
+
+    mov         edx, r11d
+    add         rdx, byte (SIZEOF_YMMWORD-1)
+    and         rdx, -SIZEOF_YMMWORD
+    jz          near .return
+
+    mov         rcx, r10                ; rowctr
+    test        rcx, rcx
+    jz          short .return
+
+    mov         rsi, r12                ; input_data
+    mov         rdi, r13
+    mov         rdip, JSAMPARRAY [rdi]  ; output_data
+.rowloop:
+    push        rdi
+    push        rsi
+
+    mov         rsip, JSAMPROW [rsi]    ; inptr
+    mov         rdip, JSAMPROW [rdi]    ; outptr
+    mov         rax, rdx                ; colctr
+.columnloop:
+
+    cmp         rax, byte SIZEOF_YMMWORD
+    ja          near .above_16
+
+    vmovdqu     xmm0, XMMWORD [rsi+0*SIZEOF_YMMWORD]
+    vpunpckhbw  xmm1, xmm0, xmm0
+    vpunpcklbw  xmm0, xmm0, xmm0
+
+    vmovdqu     XMMWORD [rdi+0*SIZEOF_XMMWORD], xmm0
+    vmovdqu     XMMWORD [rdi+1*SIZEOF_XMMWORD], xmm1
+
+    jmp         short .nextrow
+
+.above_16:
+    vmovdqu     ymm0, YMMWORD [rsi+0*SIZEOF_YMMWORD]
+
+    vpermq      ymm0, ymm0, 0xd8
+    vpunpckhbw  ymm1, ymm0, ymm0
+    vpunpcklbw  ymm0, ymm0, ymm0
+
+    vmovdqu     YMMWORD [rdi+0*SIZEOF_YMMWORD], ymm0
+    vmovdqu     YMMWORD [rdi+1*SIZEOF_YMMWORD], ymm1
+
+    sub         rax, byte 2*SIZEOF_YMMWORD
+    jz          short .nextrow
+
+    add         rsi, byte SIZEOF_YMMWORD    ; inptr
+    add         rdi, byte 2*SIZEOF_YMMWORD  ; outptr
+    jmp         short .columnloop
+
+.nextrow:
+    pop         rsi
+    pop         rdi
+
+    add         rsi, byte SIZEOF_JSAMPROW  ; input_data
+    add         rdi, byte SIZEOF_JSAMPROW  ; output_data
+    dec         rcx                        ; rowctr
+    jg          short .rowloop
+
+.return:
+    vzeroupper
+    uncollect_args 4
+    pop         rbp
+    ret
+
+; --------------------------------------------------------------------------
+;
+; Fast processing for the common case of 2:1 horizontal and 2:1 vertical.
+; It's still a box filter.
+;
+; GLOBAL(void)
+; jsimd_h2v2_upsample_avx2(int max_v_samp_factor, JDIMENSION output_width,
+;                          JSAMPARRAY input_data, JSAMPARRAY *output_data_ptr);
+;
+
+; r10 = int max_v_samp_factor
+; r11d = JDIMENSION output_width
+; r12 = JSAMPARRAY input_data
+; r13 = JSAMPARRAY *output_data_ptr
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_h2v2_upsample_avx2)
+
+EXTN(jsimd_h2v2_upsample_avx2):
+    push        rbp
+    mov         rax, rsp
+    mov         rbp, rsp
+    collect_args 4
+    push        rbx
+
+    mov         edx, r11d
+    add         rdx, byte (SIZEOF_YMMWORD-1)
+    and         rdx, -SIZEOF_YMMWORD
+    jz          near .return
+
+    mov         rcx, r10                ; rowctr
+    test        rcx, rcx
+    jz          near .return
+
+    mov         rsi, r12                ; input_data
+    mov         rdi, r13
+    mov         rdip, JSAMPARRAY [rdi]  ; output_data
+.rowloop:
+    push        rdi
+    push        rsi
+
+    mov         rsip, JSAMPROW [rsi]                   ; inptr
+    mov         rbxp, JSAMPROW [rdi+0*SIZEOF_JSAMPROW] ; outptr0
+    mov         rdip, JSAMPROW [rdi+1*SIZEOF_JSAMPROW] ; outptr1
+    mov         rax, rdx                               ; colctr
+.columnloop:
+
+    cmp         rax, byte SIZEOF_YMMWORD
+    ja          short .above_16
+
+    vmovdqu     xmm0, XMMWORD [rsi+0*SIZEOF_XMMWORD]
+    vpunpckhbw  xmm1, xmm0, xmm0
+    vpunpcklbw  xmm0, xmm0, xmm0
+
+    vmovdqu     XMMWORD [rbx+0*SIZEOF_XMMWORD], xmm0
+    vmovdqu     XMMWORD [rbx+1*SIZEOF_XMMWORD], xmm1
+    vmovdqu     XMMWORD [rdi+0*SIZEOF_XMMWORD], xmm0
+    vmovdqu     XMMWORD [rdi+1*SIZEOF_XMMWORD], xmm1
+
+    jmp         near .nextrow
+
+.above_16:
+    vmovdqu     ymm0, YMMWORD [rsi+0*SIZEOF_YMMWORD]
+
+    vpermq      ymm0, ymm0, 0xd8
+    vpunpckhbw  ymm1, ymm0, ymm0
+    vpunpcklbw  ymm0, ymm0, ymm0
+
+    vmovdqu     YMMWORD [rbx+0*SIZEOF_YMMWORD], ymm0
+    vmovdqu     YMMWORD [rbx+1*SIZEOF_YMMWORD], ymm1
+    vmovdqu     YMMWORD [rdi+0*SIZEOF_YMMWORD], ymm0
+    vmovdqu     YMMWORD [rdi+1*SIZEOF_YMMWORD], ymm1
+
+    sub         rax, byte 2*SIZEOF_YMMWORD
+    jz          short .nextrow
+
+    add         rsi, byte SIZEOF_YMMWORD  ; inptr
+    add         rbx, 2*SIZEOF_YMMWORD     ; outptr0
+    add         rdi, 2*SIZEOF_YMMWORD     ; outptr1
+    jmp         short .columnloop
+
+.nextrow:
+    pop         rsi
+    pop         rdi
+
+    add         rsi, byte 1*SIZEOF_JSAMPROW  ; input_data
+    add         rdi, byte 2*SIZEOF_JSAMPROW  ; output_data
+    sub         rcx, byte 2                  ; rowctr
+    jg          near .rowloop
+
+.return:
+    pop         rbx
+    vzeroupper
+    uncollect_args 4
+    pop         rbp
+    ret
+
+; For some reason, the OS X linker does not honor the request to align the
+; segment unless we do this.
+    align       32
diff --git a/3rdparty/libjpeg/src/simd/x86_64/jdsample-sse2.asm b/3rdparty/libjpeg/src/simd/x86_64/jdsample-sse2.asm
new file mode 100644
index 00000000..38dbceec
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/x86_64/jdsample-sse2.asm
@@ -0,0 +1,665 @@
+;
+; jdsample.asm - upsampling (64-bit SSE2)
+;
+; Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+; Copyright (C) 2009, 2016, D. R. Commander.
+; Copyright (C) 2018, Matthias Räncker.
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+;
+; This file should be assembled with NASM (Netwide Assembler),
+; can *not* be assembled with Microsoft's MASM or any compatible
+; assembler (including Borland's Turbo Assembler).
+; NASM is available from http://nasm.sourceforge.net/ or
+; http://sourceforge.net/project/showfiles.php?group_id=6208
+
+%include "jsimdext.inc"
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_CONST
+
+    alignz      32
+    GLOBAL_DATA(jconst_fancy_upsample_sse2)
+
+EXTN(jconst_fancy_upsample_sse2):
+
+PW_ONE   times 8 dw 1
+PW_TWO   times 8 dw 2
+PW_THREE times 8 dw 3
+PW_SEVEN times 8 dw 7
+PW_EIGHT times 8 dw 8
+
+    alignz      32
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_TEXT
+    BITS        64
+;
+; Fancy processing for the common case of 2:1 horizontal and 1:1 vertical.
+;
+; The upsampling algorithm is linear interpolation between pixel centers,
+; also known as a "triangle filter".  This is a good compromise between
+; speed and visual quality.  The centers of the output pixels are 1/4 and 3/4
+; of the way between input pixel centers.
+;
+; GLOBAL(void)
+; jsimd_h2v1_fancy_upsample_sse2(int max_v_samp_factor,
+;                                JDIMENSION downsampled_width,
+;                                JSAMPARRAY input_data,
+;                                JSAMPARRAY *output_data_ptr);
+;
+
+; r10 = int max_v_samp_factor
+; r11d = JDIMENSION downsampled_width
+; r12 = JSAMPARRAY input_data
+; r13 = JSAMPARRAY *output_data_ptr
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_h2v1_fancy_upsample_sse2)
+
+EXTN(jsimd_h2v1_fancy_upsample_sse2):
+    push        rbp
+    mov         rax, rsp
+    mov         rbp, rsp
+    collect_args 4
+
+    mov         eax, r11d               ; colctr
+    test        rax, rax
+    jz          near .return
+
+    mov         rcx, r10                ; rowctr
+    test        rcx, rcx
+    jz          near .return
+
+    mov         rsi, r12                ; input_data
+    mov         rdi, r13
+    mov         rdip, JSAMPARRAY [rdi]  ; output_data
+.rowloop:
+    push        rax                     ; colctr
+    push        rdi
+    push        rsi
+
+    mov         rsip, JSAMPROW [rsi]    ; inptr
+    mov         rdip, JSAMPROW [rdi]    ; outptr
+
+    test        rax, SIZEOF_XMMWORD-1
+    jz          short .skip
+    mov         dl, JSAMPLE [rsi+(rax-1)*SIZEOF_JSAMPLE]
+    mov         JSAMPLE [rsi+rax*SIZEOF_JSAMPLE], dl    ; insert a dummy sample
+.skip:
+    pxor        xmm0, xmm0              ; xmm0=(all 0's)
+    pcmpeqb     xmm7, xmm7
+    psrldq      xmm7, (SIZEOF_XMMWORD-1)
+    pand        xmm7, XMMWORD [rsi+0*SIZEOF_XMMWORD]
+
+    add         rax, byte SIZEOF_XMMWORD-1
+    and         rax, byte -SIZEOF_XMMWORD
+    cmp         rax, byte SIZEOF_XMMWORD
+    ja          short .columnloop
+
+.columnloop_last:
+    pcmpeqb     xmm6, xmm6
+    pslldq      xmm6, (SIZEOF_XMMWORD-1)
+    pand        xmm6, XMMWORD [rsi+0*SIZEOF_XMMWORD]
+    jmp         short .upsample
+
+.columnloop:
+    movdqa      xmm6, XMMWORD [rsi+1*SIZEOF_XMMWORD]
+    pslldq      xmm6, (SIZEOF_XMMWORD-1)
+
+.upsample:
+    movdqa      xmm1, XMMWORD [rsi+0*SIZEOF_XMMWORD]
+    movdqa      xmm2, xmm1
+    movdqa      xmm3, xmm1                ; xmm1=( 0  1  2 ... 13 14 15)
+    pslldq      xmm2, 1                   ; xmm2=(--  0  1 ... 12 13 14)
+    psrldq      xmm3, 1                   ; xmm3=( 1  2  3 ... 14 15 --)
+
+    por         xmm2, xmm7                ; xmm2=(-1  0  1 ... 12 13 14)
+    por         xmm3, xmm6                ; xmm3=( 1  2  3 ... 14 15 16)
+
+    movdqa      xmm7, xmm1
+    psrldq      xmm7, (SIZEOF_XMMWORD-1)  ; xmm7=(15 -- -- ... -- -- --)
+
+    movdqa      xmm4, xmm1
+    punpcklbw   xmm1, xmm0                ; xmm1=( 0  1  2  3  4  5  6  7)
+    punpckhbw   xmm4, xmm0                ; xmm4=( 8  9 10 11 12 13 14 15)
+    movdqa      xmm5, xmm2
+    punpcklbw   xmm2, xmm0                ; xmm2=(-1  0  1  2  3  4  5  6)
+    punpckhbw   xmm5, xmm0                ; xmm5=( 7  8  9 10 11 12 13 14)
+    movdqa      xmm6, xmm3
+    punpcklbw   xmm3, xmm0                ; xmm3=( 1  2  3  4  5  6  7  8)
+    punpckhbw   xmm6, xmm0                ; xmm6=( 9 10 11 12 13 14 15 16)
+
+    pmullw      xmm1, [rel PW_THREE]
+    pmullw      xmm4, [rel PW_THREE]
+    paddw       xmm2, [rel PW_ONE]
+    paddw       xmm5, [rel PW_ONE]
+    paddw       xmm3, [rel PW_TWO]
+    paddw       xmm6, [rel PW_TWO]
+
+    paddw       xmm2, xmm1
+    paddw       xmm5, xmm4
+    psrlw       xmm2, 2                 ; xmm2=OutLE=( 0  2  4  6  8 10 12 14)
+    psrlw       xmm5, 2                 ; xmm5=OutHE=(16 18 20 22 24 26 28 30)
+    paddw       xmm3, xmm1
+    paddw       xmm6, xmm4
+    psrlw       xmm3, 2                 ; xmm3=OutLO=( 1  3  5  7  9 11 13 15)
+    psrlw       xmm6, 2                 ; xmm6=OutHO=(17 19 21 23 25 27 29 31)
+
+    psllw       xmm3, BYTE_BIT
+    psllw       xmm6, BYTE_BIT
+    por         xmm2, xmm3              ; xmm2=OutL=( 0  1  2 ... 13 14 15)
+    por         xmm5, xmm6              ; xmm5=OutH=(16 17 18 ... 29 30 31)
+
+    movdqa      XMMWORD [rdi+0*SIZEOF_XMMWORD], xmm2
+    movdqa      XMMWORD [rdi+1*SIZEOF_XMMWORD], xmm5
+
+    sub         rax, byte SIZEOF_XMMWORD
+    add         rsi, byte 1*SIZEOF_XMMWORD  ; inptr
+    add         rdi, byte 2*SIZEOF_XMMWORD  ; outptr
+    cmp         rax, byte SIZEOF_XMMWORD
+    ja          near .columnloop
+    test        eax, eax
+    jnz         near .columnloop_last
+
+    pop         rsi
+    pop         rdi
+    pop         rax
+
+    add         rsi, byte SIZEOF_JSAMPROW  ; input_data
+    add         rdi, byte SIZEOF_JSAMPROW  ; output_data
+    dec         rcx                        ; rowctr
+    jg          near .rowloop
+
+.return:
+    uncollect_args 4
+    pop         rbp
+    ret
+
+; --------------------------------------------------------------------------
+;
+; Fancy processing for the common case of 2:1 horizontal and 2:1 vertical.
+; Again a triangle filter; see comments for h2v1 case, above.
+;
+; GLOBAL(void)
+; jsimd_h2v2_fancy_upsample_sse2(int max_v_samp_factor,
+;                                JDIMENSION downsampled_width,
+;                                JSAMPARRAY input_data,
+;                                JSAMPARRAY *output_data_ptr);
+;
+
+; r10 = int max_v_samp_factor
+; r11d = JDIMENSION downsampled_width
+; r12 = JSAMPARRAY input_data
+; r13 = JSAMPARRAY *output_data_ptr
+
+%define wk(i)   rbp - (WK_NUM - (i)) * SIZEOF_XMMWORD  ; xmmword wk[WK_NUM]
+%define WK_NUM  4
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_h2v2_fancy_upsample_sse2)
+
+EXTN(jsimd_h2v2_fancy_upsample_sse2):
+    push        rbp
+    mov         rax, rsp                     ; rax = original rbp
+    sub         rsp, byte 4
+    and         rsp, byte (-SIZEOF_XMMWORD)  ; align to 128 bits
+    mov         [rsp], rax
+    mov         rbp, rsp                     ; rbp = aligned rbp
+    lea         rsp, [wk(0)]
+    collect_args 4
+    push        rbx
+
+    mov         eax, r11d               ; colctr
+    test        rax, rax
+    jz          near .return
+
+    mov         rcx, r10                ; rowctr
+    test        rcx, rcx
+    jz          near .return
+
+    mov         rsi, r12                ; input_data
+    mov         rdi, r13
+    mov         rdip, JSAMPARRAY [rdi]  ; output_data
+.rowloop:
+    push        rax                     ; colctr
+    push        rcx
+    push        rdi
+    push        rsi
+
+    mov         rcxp, JSAMPROW [rsi-1*SIZEOF_JSAMPROW]  ; inptr1(above)
+    mov         rbxp, JSAMPROW [rsi+0*SIZEOF_JSAMPROW]  ; inptr0
+    mov         rsip, JSAMPROW [rsi+1*SIZEOF_JSAMPROW]  ; inptr1(below)
+    mov         rdxp, JSAMPROW [rdi+0*SIZEOF_JSAMPROW]  ; outptr0
+    mov         rdip, JSAMPROW [rdi+1*SIZEOF_JSAMPROW]  ; outptr1
+
+    test        rax, SIZEOF_XMMWORD-1
+    jz          short .skip
+    push        rdx
+    mov         dl, JSAMPLE [rcx+(rax-1)*SIZEOF_JSAMPLE]
+    mov         JSAMPLE [rcx+rax*SIZEOF_JSAMPLE], dl
+    mov         dl, JSAMPLE [rbx+(rax-1)*SIZEOF_JSAMPLE]
+    mov         JSAMPLE [rbx+rax*SIZEOF_JSAMPLE], dl
+    mov         dl, JSAMPLE [rsi+(rax-1)*SIZEOF_JSAMPLE]
+    mov         JSAMPLE [rsi+rax*SIZEOF_JSAMPLE], dl    ; insert a dummy sample
+    pop         rdx
+.skip:
+    ; -- process the first column block
+
+    movdqa      xmm0, XMMWORD [rbx+0*SIZEOF_XMMWORD]  ; xmm0=row[ 0][0]
+    movdqa      xmm1, XMMWORD [rcx+0*SIZEOF_XMMWORD]  ; xmm1=row[-1][0]
+    movdqa      xmm2, XMMWORD [rsi+0*SIZEOF_XMMWORD]  ; xmm2=row[+1][0]
+
+    pxor        xmm3, xmm3              ; xmm3=(all 0's)
+    movdqa      xmm4, xmm0
+    punpcklbw   xmm0, xmm3              ; xmm0=row[ 0]( 0  1  2  3  4  5  6  7)
+    punpckhbw   xmm4, xmm3              ; xmm4=row[ 0]( 8  9 10 11 12 13 14 15)
+    movdqa      xmm5, xmm1
+    punpcklbw   xmm1, xmm3              ; xmm1=row[-1]( 0  1  2  3  4  5  6  7)
+    punpckhbw   xmm5, xmm3              ; xmm5=row[-1]( 8  9 10 11 12 13 14 15)
+    movdqa      xmm6, xmm2
+    punpcklbw   xmm2, xmm3              ; xmm2=row[+1]( 0  1  2  3  4  5  6  7)
+    punpckhbw   xmm6, xmm3              ; xmm6=row[+1]( 8  9 10 11 12 13 14 15)
+
+    pmullw      xmm0, [rel PW_THREE]
+    pmullw      xmm4, [rel PW_THREE]
+
+    pcmpeqb     xmm7, xmm7
+    psrldq      xmm7, (SIZEOF_XMMWORD-2)
+
+    paddw       xmm1, xmm0              ; xmm1=Int0L=( 0  1  2  3  4  5  6  7)
+    paddw       xmm5, xmm4              ; xmm5=Int0H=( 8  9 10 11 12 13 14 15)
+    paddw       xmm2, xmm0              ; xmm2=Int1L=( 0  1  2  3  4  5  6  7)
+    paddw       xmm6, xmm4              ; xmm6=Int1H=( 8  9 10 11 12 13 14 15)
+
+    movdqa      XMMWORD [rdx+0*SIZEOF_XMMWORD], xmm1  ; temporarily save
+    movdqa      XMMWORD [rdx+1*SIZEOF_XMMWORD], xmm5  ; the intermediate data
+    movdqa      XMMWORD [rdi+0*SIZEOF_XMMWORD], xmm2
+    movdqa      XMMWORD [rdi+1*SIZEOF_XMMWORD], xmm6
+
+    pand        xmm1, xmm7              ; xmm1=( 0 -- -- -- -- -- -- --)
+    pand        xmm2, xmm7              ; xmm2=( 0 -- -- -- -- -- -- --)
+
+    movdqa      XMMWORD [wk(0)], xmm1
+    movdqa      XMMWORD [wk(1)], xmm2
+
+    add         rax, byte SIZEOF_XMMWORD-1
+    and         rax, byte -SIZEOF_XMMWORD
+    cmp         rax, byte SIZEOF_XMMWORD
+    ja          short .columnloop
+
+.columnloop_last:
+    ; -- process the last column block
+
+    pcmpeqb     xmm1, xmm1
+    pslldq      xmm1, (SIZEOF_XMMWORD-2)
+    movdqa      xmm2, xmm1
+
+    pand        xmm1, XMMWORD [rdx+1*SIZEOF_XMMWORD]
+    pand        xmm2, XMMWORD [rdi+1*SIZEOF_XMMWORD]
+
+    movdqa      XMMWORD [wk(2)], xmm1   ; xmm1=(-- -- -- -- -- -- -- 15)
+    movdqa      XMMWORD [wk(3)], xmm2   ; xmm2=(-- -- -- -- -- -- -- 15)
+
+    jmp         near .upsample
+
+.columnloop:
+    ; -- process the next column block
+
+    movdqa      xmm0, XMMWORD [rbx+1*SIZEOF_XMMWORD]  ; xmm0=row[ 0][1]
+    movdqa      xmm1, XMMWORD [rcx+1*SIZEOF_XMMWORD]  ; xmm1=row[-1][1]
+    movdqa      xmm2, XMMWORD [rsi+1*SIZEOF_XMMWORD]  ; xmm2=row[+1][1]
+
+    pxor        xmm3, xmm3              ; xmm3=(all 0's)
+    movdqa      xmm4, xmm0
+    punpcklbw   xmm0, xmm3              ; xmm0=row[ 0]( 0  1  2  3  4  5  6  7)
+    punpckhbw   xmm4, xmm3              ; xmm4=row[ 0]( 8  9 10 11 12 13 14 15)
+    movdqa      xmm5, xmm1
+    punpcklbw   xmm1, xmm3              ; xmm1=row[-1]( 0  1  2  3  4  5  6  7)
+    punpckhbw   xmm5, xmm3              ; xmm5=row[-1]( 8  9 10 11 12 13 14 15)
+    movdqa      xmm6, xmm2
+    punpcklbw   xmm2, xmm3              ; xmm2=row[+1]( 0  1  2  3  4  5  6  7)
+    punpckhbw   xmm6, xmm3              ; xmm6=row[+1]( 8  9 10 11 12 13 14 15)
+
+    pmullw      xmm0, [rel PW_THREE]
+    pmullw      xmm4, [rel PW_THREE]
+
+    paddw       xmm1, xmm0              ; xmm1=Int0L=( 0  1  2  3  4  5  6  7)
+    paddw       xmm5, xmm4              ; xmm5=Int0H=( 8  9 10 11 12 13 14 15)
+    paddw       xmm2, xmm0              ; xmm2=Int1L=( 0  1  2  3  4  5  6  7)
+    paddw       xmm6, xmm4              ; xmm6=Int1H=( 8  9 10 11 12 13 14 15)
+
+    movdqa      XMMWORD [rdx+2*SIZEOF_XMMWORD], xmm1  ; temporarily save
+    movdqa      XMMWORD [rdx+3*SIZEOF_XMMWORD], xmm5  ; the intermediate data
+    movdqa      XMMWORD [rdi+2*SIZEOF_XMMWORD], xmm2
+    movdqa      XMMWORD [rdi+3*SIZEOF_XMMWORD], xmm6
+
+    pslldq      xmm1, (SIZEOF_XMMWORD-2)  ; xmm1=(-- -- -- -- -- -- --  0)
+    pslldq      xmm2, (SIZEOF_XMMWORD-2)  ; xmm2=(-- -- -- -- -- -- --  0)
+
+    movdqa      XMMWORD [wk(2)], xmm1
+    movdqa      XMMWORD [wk(3)], xmm2
+
+.upsample:
+    ; -- process the upper row
+
+    movdqa      xmm7, XMMWORD [rdx+0*SIZEOF_XMMWORD]
+    movdqa      xmm3, XMMWORD [rdx+1*SIZEOF_XMMWORD]
+
+    movdqa      xmm0, xmm7                ; xmm7=Int0L=( 0  1  2  3  4  5  6  7)
+    movdqa      xmm4, xmm3                ; xmm3=Int0H=( 8  9 10 11 12 13 14 15)
+    psrldq      xmm0, 2                   ; xmm0=( 1  2  3  4  5  6  7 --)
+    pslldq      xmm4, (SIZEOF_XMMWORD-2)  ; xmm4=(-- -- -- -- -- -- --  8)
+    movdqa      xmm5, xmm7
+    movdqa      xmm6, xmm3
+    psrldq      xmm5, (SIZEOF_XMMWORD-2)  ; xmm5=( 7 -- -- -- -- -- -- --)
+    pslldq      xmm6, 2                   ; xmm6=(--  8  9 10 11 12 13 14)
+
+    por         xmm0, xmm4                ; xmm0=( 1  2  3  4  5  6  7  8)
+    por         xmm5, xmm6                ; xmm5=( 7  8  9 10 11 12 13 14)
+
+    movdqa      xmm1, xmm7
+    movdqa      xmm2, xmm3
+    pslldq      xmm1, 2                   ; xmm1=(--  0  1  2  3  4  5  6)
+    psrldq      xmm2, 2                   ; xmm2=( 9 10 11 12 13 14 15 --)
+    movdqa      xmm4, xmm3
+    psrldq      xmm4, (SIZEOF_XMMWORD-2)  ; xmm4=(15 -- -- -- -- -- -- --)
+
+    por         xmm1, XMMWORD [wk(0)]     ; xmm1=(-1  0  1  2  3  4  5  6)
+    por         xmm2, XMMWORD [wk(2)]     ; xmm2=( 9 10 11 12 13 14 15 16)
+
+    movdqa      XMMWORD [wk(0)], xmm4
+
+    pmullw      xmm7, [rel PW_THREE]
+    pmullw      xmm3, [rel PW_THREE]
+    paddw       xmm1, [rel PW_EIGHT]
+    paddw       xmm5, [rel PW_EIGHT]
+    paddw       xmm0, [rel PW_SEVEN]
+    paddw       xmm2, [rel PW_SEVEN]
+
+    paddw       xmm1, xmm7
+    paddw       xmm5, xmm3
+    psrlw       xmm1, 4                 ; xmm1=Out0LE=( 0  2  4  6  8 10 12 14)
+    psrlw       xmm5, 4                 ; xmm5=Out0HE=(16 18 20 22 24 26 28 30)
+    paddw       xmm0, xmm7
+    paddw       xmm2, xmm3
+    psrlw       xmm0, 4                 ; xmm0=Out0LO=( 1  3  5  7  9 11 13 15)
+    psrlw       xmm2, 4                 ; xmm2=Out0HO=(17 19 21 23 25 27 29 31)
+
+    psllw       xmm0, BYTE_BIT
+    psllw       xmm2, BYTE_BIT
+    por         xmm1, xmm0              ; xmm1=Out0L=( 0  1  2 ... 13 14 15)
+    por         xmm5, xmm2              ; xmm5=Out0H=(16 17 18 ... 29 30 31)
+
+    movdqa      XMMWORD [rdx+0*SIZEOF_XMMWORD], xmm1
+    movdqa      XMMWORD [rdx+1*SIZEOF_XMMWORD], xmm5
+
+    ; -- process the lower row
+
+    movdqa      xmm6, XMMWORD [rdi+0*SIZEOF_XMMWORD]
+    movdqa      xmm4, XMMWORD [rdi+1*SIZEOF_XMMWORD]
+
+    movdqa      xmm7, xmm6                ; xmm6=Int1L=( 0  1  2  3  4  5  6  7)
+    movdqa      xmm3, xmm4                ; xmm4=Int1H=( 8  9 10 11 12 13 14 15)
+    psrldq      xmm7, 2                   ; xmm7=( 1  2  3  4  5  6  7 --)
+    pslldq      xmm3, (SIZEOF_XMMWORD-2)  ; xmm3=(-- -- -- -- -- -- --  8)
+    movdqa      xmm0, xmm6
+    movdqa      xmm2, xmm4
+    psrldq      xmm0, (SIZEOF_XMMWORD-2)  ; xmm0=( 7 -- -- -- -- -- -- --)
+    pslldq      xmm2, 2                   ; xmm2=(--  8  9 10 11 12 13 14)
+
+    por         xmm7, xmm3                ; xmm7=( 1  2  3  4  5  6  7  8)
+    por         xmm0, xmm2                ; xmm0=( 7  8  9 10 11 12 13 14)
+
+    movdqa      xmm1, xmm6
+    movdqa      xmm5, xmm4
+    pslldq      xmm1, 2                   ; xmm1=(--  0  1  2  3  4  5  6)
+    psrldq      xmm5, 2                   ; xmm5=( 9 10 11 12 13 14 15 --)
+    movdqa      xmm3, xmm4
+    psrldq      xmm3, (SIZEOF_XMMWORD-2)  ; xmm3=(15 -- -- -- -- -- -- --)
+
+    por         xmm1, XMMWORD [wk(1)]     ; xmm1=(-1  0  1  2  3  4  5  6)
+    por         xmm5, XMMWORD [wk(3)]     ; xmm5=( 9 10 11 12 13 14 15 16)
+
+    movdqa      XMMWORD [wk(1)], xmm3
+
+    pmullw      xmm6, [rel PW_THREE]
+    pmullw      xmm4, [rel PW_THREE]
+    paddw       xmm1, [rel PW_EIGHT]
+    paddw       xmm0, [rel PW_EIGHT]
+    paddw       xmm7, [rel PW_SEVEN]
+    paddw       xmm5, [rel PW_SEVEN]
+
+    paddw       xmm1, xmm6
+    paddw       xmm0, xmm4
+    psrlw       xmm1, 4                 ; xmm1=Out1LE=( 0  2  4  6  8 10 12 14)
+    psrlw       xmm0, 4                 ; xmm0=Out1HE=(16 18 20 22 24 26 28 30)
+    paddw       xmm7, xmm6
+    paddw       xmm5, xmm4
+    psrlw       xmm7, 4                 ; xmm7=Out1LO=( 1  3  5  7  9 11 13 15)
+    psrlw       xmm5, 4                 ; xmm5=Out1HO=(17 19 21 23 25 27 29 31)
+
+    psllw       xmm7, BYTE_BIT
+    psllw       xmm5, BYTE_BIT
+    por         xmm1, xmm7              ; xmm1=Out1L=( 0  1  2 ... 13 14 15)
+    por         xmm0, xmm5              ; xmm0=Out1H=(16 17 18 ... 29 30 31)
+
+    movdqa      XMMWORD [rdi+0*SIZEOF_XMMWORD], xmm1
+    movdqa      XMMWORD [rdi+1*SIZEOF_XMMWORD], xmm0
+
+    sub         rax, byte SIZEOF_XMMWORD
+    add         rcx, byte 1*SIZEOF_XMMWORD  ; inptr1(above)
+    add         rbx, byte 1*SIZEOF_XMMWORD  ; inptr0
+    add         rsi, byte 1*SIZEOF_XMMWORD  ; inptr1(below)
+    add         rdx, byte 2*SIZEOF_XMMWORD  ; outptr0
+    add         rdi, byte 2*SIZEOF_XMMWORD  ; outptr1
+    cmp         rax, byte SIZEOF_XMMWORD
+    ja          near .columnloop
+    test        rax, rax
+    jnz         near .columnloop_last
+
+    pop         rsi
+    pop         rdi
+    pop         rcx
+    pop         rax
+
+    add         rsi, byte 1*SIZEOF_JSAMPROW  ; input_data
+    add         rdi, byte 2*SIZEOF_JSAMPROW  ; output_data
+    sub         rcx, byte 2                  ; rowctr
+    jg          near .rowloop
+
+.return:
+    pop         rbx
+    uncollect_args 4
+    mov         rsp, rbp                ; rsp <- aligned rbp
+    pop         rsp                     ; rsp <- original rbp
+    pop         rbp
+    ret
+
+; --------------------------------------------------------------------------
+;
+; Fast processing for the common case of 2:1 horizontal and 1:1 vertical.
+; It's still a box filter.
+;
+; GLOBAL(void)
+; jsimd_h2v1_upsample_sse2(int max_v_samp_factor, JDIMENSION output_width,
+;                          JSAMPARRAY input_data, JSAMPARRAY *output_data_ptr);
+;
+
+; r10 = int max_v_samp_factor
+; r11d = JDIMENSION output_width
+; r12 = JSAMPARRAY input_data
+; r13 = JSAMPARRAY *output_data_ptr
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_h2v1_upsample_sse2)
+
+EXTN(jsimd_h2v1_upsample_sse2):
+    push        rbp
+    mov         rax, rsp
+    mov         rbp, rsp
+    collect_args 4
+
+    mov         edx, r11d
+    add         rdx, byte (2*SIZEOF_XMMWORD)-1
+    and         rdx, byte -(2*SIZEOF_XMMWORD)
+    jz          near .return
+
+    mov         rcx, r10                ; rowctr
+    test        rcx, rcx
+    jz          short .return
+
+    mov         rsi, r12                ; input_data
+    mov         rdi, r13
+    mov         rdip, JSAMPARRAY [rdi]  ; output_data
+.rowloop:
+    push        rdi
+    push        rsi
+
+    mov         rsip, JSAMPROW [rsi]    ; inptr
+    mov         rdip, JSAMPROW [rdi]    ; outptr
+    mov         rax, rdx                ; colctr
+.columnloop:
+
+    movdqa      xmm0, XMMWORD [rsi+0*SIZEOF_XMMWORD]
+
+    movdqa      xmm1, xmm0
+    punpcklbw   xmm0, xmm0
+    punpckhbw   xmm1, xmm1
+
+    movdqa      XMMWORD [rdi+0*SIZEOF_XMMWORD], xmm0
+    movdqa      XMMWORD [rdi+1*SIZEOF_XMMWORD], xmm1
+
+    sub         rax, byte 2*SIZEOF_XMMWORD
+    jz          short .nextrow
+
+    movdqa      xmm2, XMMWORD [rsi+1*SIZEOF_XMMWORD]
+
+    movdqa      xmm3, xmm2
+    punpcklbw   xmm2, xmm2
+    punpckhbw   xmm3, xmm3
+
+    movdqa      XMMWORD [rdi+2*SIZEOF_XMMWORD], xmm2
+    movdqa      XMMWORD [rdi+3*SIZEOF_XMMWORD], xmm3
+
+    sub         rax, byte 2*SIZEOF_XMMWORD
+    jz          short .nextrow
+
+    add         rsi, byte 2*SIZEOF_XMMWORD  ; inptr
+    add         rdi, byte 4*SIZEOF_XMMWORD  ; outptr
+    jmp         short .columnloop
+
+.nextrow:
+    pop         rsi
+    pop         rdi
+
+    add         rsi, byte SIZEOF_JSAMPROW  ; input_data
+    add         rdi, byte SIZEOF_JSAMPROW  ; output_data
+    dec         rcx                        ; rowctr
+    jg          short .rowloop
+
+.return:
+    uncollect_args 4
+    pop         rbp
+    ret
+
+; --------------------------------------------------------------------------
+;
+; Fast processing for the common case of 2:1 horizontal and 2:1 vertical.
+; It's still a box filter.
+;
+; GLOBAL(void)
+; jsimd_h2v2_upsample_sse2(int max_v_samp_factor, JDIMENSION output_width,
+;                          JSAMPARRAY input_data, JSAMPARRAY *output_data_ptr);
+;
+
+; r10 = int max_v_samp_factor
+; r11d = JDIMENSION output_width
+; r12 = JSAMPARRAY input_data
+; r13 = JSAMPARRAY *output_data_ptr
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_h2v2_upsample_sse2)
+
+EXTN(jsimd_h2v2_upsample_sse2):
+    push        rbp
+    mov         rax, rsp
+    mov         rbp, rsp
+    collect_args 4
+    push        rbx
+
+    mov         edx, r11d
+    add         rdx, byte (2*SIZEOF_XMMWORD)-1
+    and         rdx, byte -(2*SIZEOF_XMMWORD)
+    jz          near .return
+
+    mov         rcx, r10                ; rowctr
+    test        rcx, rcx
+    jz          near .return
+
+    mov         rsi, r12                ; input_data
+    mov         rdi, r13
+    mov         rdip, JSAMPARRAY [rdi]  ; output_data
+.rowloop:
+    push        rdi
+    push        rsi
+
+    mov         rsip, JSAMPROW [rsi]                   ; inptr
+    mov         rbxp, JSAMPROW [rdi+0*SIZEOF_JSAMPROW] ; outptr0
+    mov         rdip, JSAMPROW [rdi+1*SIZEOF_JSAMPROW] ; outptr1
+    mov         rax, rdx                               ; colctr
+.columnloop:
+
+    movdqa      xmm0, XMMWORD [rsi+0*SIZEOF_XMMWORD]
+
+    movdqa      xmm1, xmm0
+    punpcklbw   xmm0, xmm0
+    punpckhbw   xmm1, xmm1
+
+    movdqa      XMMWORD [rbx+0*SIZEOF_XMMWORD], xmm0
+    movdqa      XMMWORD [rbx+1*SIZEOF_XMMWORD], xmm1
+    movdqa      XMMWORD [rdi+0*SIZEOF_XMMWORD], xmm0
+    movdqa      XMMWORD [rdi+1*SIZEOF_XMMWORD], xmm1
+
+    sub         rax, byte 2*SIZEOF_XMMWORD
+    jz          short .nextrow
+
+    movdqa      xmm2, XMMWORD [rsi+1*SIZEOF_XMMWORD]
+
+    movdqa      xmm3, xmm2
+    punpcklbw   xmm2, xmm2
+    punpckhbw   xmm3, xmm3
+
+    movdqa      XMMWORD [rbx+2*SIZEOF_XMMWORD], xmm2
+    movdqa      XMMWORD [rbx+3*SIZEOF_XMMWORD], xmm3
+    movdqa      XMMWORD [rdi+2*SIZEOF_XMMWORD], xmm2
+    movdqa      XMMWORD [rdi+3*SIZEOF_XMMWORD], xmm3
+
+    sub         rax, byte 2*SIZEOF_XMMWORD
+    jz          short .nextrow
+
+    add         rsi, byte 2*SIZEOF_XMMWORD  ; inptr
+    add         rbx, byte 4*SIZEOF_XMMWORD  ; outptr0
+    add         rdi, byte 4*SIZEOF_XMMWORD  ; outptr1
+    jmp         short .columnloop
+
+.nextrow:
+    pop         rsi
+    pop         rdi
+
+    add         rsi, byte 1*SIZEOF_JSAMPROW  ; input_data
+    add         rdi, byte 2*SIZEOF_JSAMPROW  ; output_data
+    sub         rcx, byte 2                  ; rowctr
+    jg          near .rowloop
+
+.return:
+    pop         rbx
+    uncollect_args 4
+    pop         rbp
+    ret
+
+; For some reason, the OS X linker does not honor the request to align the
+; segment unless we do this.
+    align       32
diff --git a/3rdparty/libjpeg/src/simd/x86_64/jfdctflt-sse.asm b/3rdparty/libjpeg/src/simd/x86_64/jfdctflt-sse.asm
new file mode 100644
index 00000000..ef279664
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/x86_64/jfdctflt-sse.asm
@@ -0,0 +1,355 @@
+;
+; jfdctflt.asm - floating-point FDCT (64-bit SSE)
+;
+; Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+; Copyright (C) 2009, 2016, D. R. Commander.
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+;
+; This file should be assembled with NASM (Netwide Assembler),
+; can *not* be assembled with Microsoft's MASM or any compatible
+; assembler (including Borland's Turbo Assembler).
+; NASM is available from http://nasm.sourceforge.net/ or
+; http://sourceforge.net/project/showfiles.php?group_id=6208
+;
+; This file contains a floating-point implementation of the forward DCT
+; (Discrete Cosine Transform). The following code is based directly on
+; the IJG's original jfdctflt.c; see the jfdctflt.c for more details.
+
+%include "jsimdext.inc"
+%include "jdct.inc"
+
+; --------------------------------------------------------------------------
+
+%macro  unpcklps2 2  ; %1=(0 1 2 3) / %2=(4 5 6 7) => %1=(0 1 4 5)
+    shufps      %1, %2, 0x44
+%endmacro
+
+%macro  unpckhps2 2  ; %1=(0 1 2 3) / %2=(4 5 6 7) => %1=(2 3 6 7)
+    shufps      %1, %2, 0xEE
+%endmacro
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_CONST
+
+    alignz      32
+    GLOBAL_DATA(jconst_fdct_float_sse)
+
+EXTN(jconst_fdct_float_sse):
+
+PD_0_382 times 4 dd 0.382683432365089771728460
+PD_0_707 times 4 dd 0.707106781186547524400844
+PD_0_541 times 4 dd 0.541196100146196984399723
+PD_1_306 times 4 dd 1.306562964876376527856643
+
+    alignz      32
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_TEXT
+    BITS        64
+;
+; Perform the forward DCT on one block of samples.
+;
+; GLOBAL(void)
+; jsimd_fdct_float_sse(FAST_FLOAT *data)
+;
+
+; r10 = FAST_FLOAT *data
+
+%define wk(i)   rbp - (WK_NUM - (i)) * SIZEOF_XMMWORD  ; xmmword wk[WK_NUM]
+%define WK_NUM  2
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_fdct_float_sse)
+
+EXTN(jsimd_fdct_float_sse):
+    push        rbp
+    mov         rax, rsp                     ; rax = original rbp
+    sub         rsp, byte 4
+    and         rsp, byte (-SIZEOF_XMMWORD)  ; align to 128 bits
+    mov         [rsp], rax
+    mov         rbp, rsp                     ; rbp = aligned rbp
+    lea         rsp, [wk(0)]
+    collect_args 1
+
+    ; ---- Pass 1: process rows.
+
+    mov         rdx, r10                ; (FAST_FLOAT *)
+    mov         rcx, DCTSIZE/4
+.rowloop:
+
+    movaps      xmm0, XMMWORD [XMMBLOCK(2,0,rdx,SIZEOF_FAST_FLOAT)]
+    movaps      xmm1, XMMWORD [XMMBLOCK(3,0,rdx,SIZEOF_FAST_FLOAT)]
+    movaps      xmm2, XMMWORD [XMMBLOCK(2,1,rdx,SIZEOF_FAST_FLOAT)]
+    movaps      xmm3, XMMWORD [XMMBLOCK(3,1,rdx,SIZEOF_FAST_FLOAT)]
+
+    ; xmm0=(20 21 22 23), xmm2=(24 25 26 27)
+    ; xmm1=(30 31 32 33), xmm3=(34 35 36 37)
+
+    movaps      xmm4, xmm0              ; transpose coefficients(phase 1)
+    unpcklps    xmm0, xmm1              ; xmm0=(20 30 21 31)
+    unpckhps    xmm4, xmm1              ; xmm4=(22 32 23 33)
+    movaps      xmm5, xmm2              ; transpose coefficients(phase 1)
+    unpcklps    xmm2, xmm3              ; xmm2=(24 34 25 35)
+    unpckhps    xmm5, xmm3              ; xmm5=(26 36 27 37)
+
+    movaps      xmm6, XMMWORD [XMMBLOCK(0,0,rdx,SIZEOF_FAST_FLOAT)]
+    movaps      xmm7, XMMWORD [XMMBLOCK(1,0,rdx,SIZEOF_FAST_FLOAT)]
+    movaps      xmm1, XMMWORD [XMMBLOCK(0,1,rdx,SIZEOF_FAST_FLOAT)]
+    movaps      xmm3, XMMWORD [XMMBLOCK(1,1,rdx,SIZEOF_FAST_FLOAT)]
+
+    ; xmm6=(00 01 02 03), xmm1=(04 05 06 07)
+    ; xmm7=(10 11 12 13), xmm3=(14 15 16 17)
+
+    movaps      XMMWORD [wk(0)], xmm4   ; wk(0)=(22 32 23 33)
+    movaps      XMMWORD [wk(1)], xmm2   ; wk(1)=(24 34 25 35)
+
+    movaps      xmm4, xmm6              ; transpose coefficients(phase 1)
+    unpcklps    xmm6, xmm7              ; xmm6=(00 10 01 11)
+    unpckhps    xmm4, xmm7              ; xmm4=(02 12 03 13)
+    movaps      xmm2, xmm1              ; transpose coefficients(phase 1)
+    unpcklps    xmm1, xmm3              ; xmm1=(04 14 05 15)
+    unpckhps    xmm2, xmm3              ; xmm2=(06 16 07 17)
+
+    movaps      xmm7, xmm6              ; transpose coefficients(phase 2)
+    unpcklps2   xmm6, xmm0              ; xmm6=(00 10 20 30)=data0
+    unpckhps2   xmm7, xmm0              ; xmm7=(01 11 21 31)=data1
+    movaps      xmm3, xmm2              ; transpose coefficients(phase 2)
+    unpcklps2   xmm2, xmm5              ; xmm2=(06 16 26 36)=data6
+    unpckhps2   xmm3, xmm5              ; xmm3=(07 17 27 37)=data7
+
+    movaps      xmm0, xmm7
+    movaps      xmm5, xmm6
+    subps       xmm7, xmm2              ; xmm7=data1-data6=tmp6
+    subps       xmm6, xmm3              ; xmm6=data0-data7=tmp7
+    addps       xmm0, xmm2              ; xmm0=data1+data6=tmp1
+    addps       xmm5, xmm3              ; xmm5=data0+data7=tmp0
+
+    movaps      xmm2, XMMWORD [wk(0)]   ; xmm2=(22 32 23 33)
+    movaps      xmm3, XMMWORD [wk(1)]   ; xmm3=(24 34 25 35)
+    movaps      XMMWORD [wk(0)], xmm7   ; wk(0)=tmp6
+    movaps      XMMWORD [wk(1)], xmm6   ; wk(1)=tmp7
+
+    movaps      xmm7, xmm4              ; transpose coefficients(phase 2)
+    unpcklps2   xmm4, xmm2              ; xmm4=(02 12 22 32)=data2
+    unpckhps2   xmm7, xmm2              ; xmm7=(03 13 23 33)=data3
+    movaps      xmm6, xmm1              ; transpose coefficients(phase 2)
+    unpcklps2   xmm1, xmm3              ; xmm1=(04 14 24 34)=data4
+    unpckhps2   xmm6, xmm3              ; xmm6=(05 15 25 35)=data5
+
+    movaps      xmm2, xmm7
+    movaps      xmm3, xmm4
+    addps       xmm7, xmm1              ; xmm7=data3+data4=tmp3
+    addps       xmm4, xmm6              ; xmm4=data2+data5=tmp2
+    subps       xmm2, xmm1              ; xmm2=data3-data4=tmp4
+    subps       xmm3, xmm6              ; xmm3=data2-data5=tmp5
+
+    ; -- Even part
+
+    movaps      xmm1, xmm5
+    movaps      xmm6, xmm0
+    subps       xmm5, xmm7              ; xmm5=tmp13
+    subps       xmm0, xmm4              ; xmm0=tmp12
+    addps       xmm1, xmm7              ; xmm1=tmp10
+    addps       xmm6, xmm4              ; xmm6=tmp11
+
+    addps       xmm0, xmm5
+    mulps       xmm0, [rel PD_0_707]    ; xmm0=z1
+
+    movaps      xmm7, xmm1
+    movaps      xmm4, xmm5
+    subps       xmm1, xmm6              ; xmm1=data4
+    subps       xmm5, xmm0              ; xmm5=data6
+    addps       xmm7, xmm6              ; xmm7=data0
+    addps       xmm4, xmm0              ; xmm4=data2
+
+    movaps      XMMWORD [XMMBLOCK(0,1,rdx,SIZEOF_FAST_FLOAT)], xmm1
+    movaps      XMMWORD [XMMBLOCK(2,1,rdx,SIZEOF_FAST_FLOAT)], xmm5
+    movaps      XMMWORD [XMMBLOCK(0,0,rdx,SIZEOF_FAST_FLOAT)], xmm7
+    movaps      XMMWORD [XMMBLOCK(2,0,rdx,SIZEOF_FAST_FLOAT)], xmm4
+
+    ; -- Odd part
+
+    movaps      xmm6, XMMWORD [wk(0)]   ; xmm6=tmp6
+    movaps      xmm0, XMMWORD [wk(1)]   ; xmm0=tmp7
+
+    addps       xmm2, xmm3              ; xmm2=tmp10
+    addps       xmm3, xmm6              ; xmm3=tmp11
+    addps       xmm6, xmm0              ; xmm6=tmp12, xmm0=tmp7
+
+    mulps       xmm3, [rel PD_0_707]    ; xmm3=z3
+
+    movaps      xmm1, xmm2              ; xmm1=tmp10
+    subps       xmm2, xmm6
+    mulps       xmm2, [rel PD_0_382]    ; xmm2=z5
+    mulps       xmm1, [rel PD_0_541]    ; xmm1=MULTIPLY(tmp10,FIX_0_541196)
+    mulps       xmm6, [rel PD_1_306]    ; xmm6=MULTIPLY(tmp12,FIX_1_306562)
+    addps       xmm1, xmm2              ; xmm1=z2
+    addps       xmm6, xmm2              ; xmm6=z4
+
+    movaps      xmm5, xmm0
+    subps       xmm0, xmm3              ; xmm0=z13
+    addps       xmm5, xmm3              ; xmm5=z11
+
+    movaps      xmm7, xmm0
+    movaps      xmm4, xmm5
+    subps       xmm0, xmm1              ; xmm0=data3
+    subps       xmm5, xmm6              ; xmm5=data7
+    addps       xmm7, xmm1              ; xmm7=data5
+    addps       xmm4, xmm6              ; xmm4=data1
+
+    movaps      XMMWORD [XMMBLOCK(3,0,rdx,SIZEOF_FAST_FLOAT)], xmm0
+    movaps      XMMWORD [XMMBLOCK(3,1,rdx,SIZEOF_FAST_FLOAT)], xmm5
+    movaps      XMMWORD [XMMBLOCK(1,1,rdx,SIZEOF_FAST_FLOAT)], xmm7
+    movaps      XMMWORD [XMMBLOCK(1,0,rdx,SIZEOF_FAST_FLOAT)], xmm4
+
+    add         rdx, 4*DCTSIZE*SIZEOF_FAST_FLOAT
+    dec         rcx
+    jnz         near .rowloop
+
+    ; ---- Pass 2: process columns.
+
+    mov         rdx, r10                ; (FAST_FLOAT *)
+    mov         rcx, DCTSIZE/4
+.columnloop:
+
+    movaps      xmm0, XMMWORD [XMMBLOCK(2,0,rdx,SIZEOF_FAST_FLOAT)]
+    movaps      xmm1, XMMWORD [XMMBLOCK(3,0,rdx,SIZEOF_FAST_FLOAT)]
+    movaps      xmm2, XMMWORD [XMMBLOCK(6,0,rdx,SIZEOF_FAST_FLOAT)]
+    movaps      xmm3, XMMWORD [XMMBLOCK(7,0,rdx,SIZEOF_FAST_FLOAT)]
+
+    ; xmm0=(02 12 22 32), xmm2=(42 52 62 72)
+    ; xmm1=(03 13 23 33), xmm3=(43 53 63 73)
+
+    movaps      xmm4, xmm0              ; transpose coefficients(phase 1)
+    unpcklps    xmm0, xmm1              ; xmm0=(02 03 12 13)
+    unpckhps    xmm4, xmm1              ; xmm4=(22 23 32 33)
+    movaps      xmm5, xmm2              ; transpose coefficients(phase 1)
+    unpcklps    xmm2, xmm3              ; xmm2=(42 43 52 53)
+    unpckhps    xmm5, xmm3              ; xmm5=(62 63 72 73)
+
+    movaps      xmm6, XMMWORD [XMMBLOCK(0,0,rdx,SIZEOF_FAST_FLOAT)]
+    movaps      xmm7, XMMWORD [XMMBLOCK(1,0,rdx,SIZEOF_FAST_FLOAT)]
+    movaps      xmm1, XMMWORD [XMMBLOCK(4,0,rdx,SIZEOF_FAST_FLOAT)]
+    movaps      xmm3, XMMWORD [XMMBLOCK(5,0,rdx,SIZEOF_FAST_FLOAT)]
+
+    ; xmm6=(00 10 20 30), xmm1=(40 50 60 70)
+    ; xmm7=(01 11 21 31), xmm3=(41 51 61 71)
+
+    movaps      XMMWORD [wk(0)], xmm4   ; wk(0)=(22 23 32 33)
+    movaps      XMMWORD [wk(1)], xmm2   ; wk(1)=(42 43 52 53)
+
+    movaps      xmm4, xmm6              ; transpose coefficients(phase 1)
+    unpcklps    xmm6, xmm7              ; xmm6=(00 01 10 11)
+    unpckhps    xmm4, xmm7              ; xmm4=(20 21 30 31)
+    movaps      xmm2, xmm1              ; transpose coefficients(phase 1)
+    unpcklps    xmm1, xmm3              ; xmm1=(40 41 50 51)
+    unpckhps    xmm2, xmm3              ; xmm2=(60 61 70 71)
+
+    movaps      xmm7, xmm6              ; transpose coefficients(phase 2)
+    unpcklps2   xmm6, xmm0              ; xmm6=(00 01 02 03)=data0
+    unpckhps2   xmm7, xmm0              ; xmm7=(10 11 12 13)=data1
+    movaps      xmm3, xmm2              ; transpose coefficients(phase 2)
+    unpcklps2   xmm2, xmm5              ; xmm2=(60 61 62 63)=data6
+    unpckhps2   xmm3, xmm5              ; xmm3=(70 71 72 73)=data7
+
+    movaps      xmm0, xmm7
+    movaps      xmm5, xmm6
+    subps       xmm7, xmm2              ; xmm7=data1-data6=tmp6
+    subps       xmm6, xmm3              ; xmm6=data0-data7=tmp7
+    addps       xmm0, xmm2              ; xmm0=data1+data6=tmp1
+    addps       xmm5, xmm3              ; xmm5=data0+data7=tmp0
+
+    movaps      xmm2, XMMWORD [wk(0)]   ; xmm2=(22 23 32 33)
+    movaps      xmm3, XMMWORD [wk(1)]   ; xmm3=(42 43 52 53)
+    movaps      XMMWORD [wk(0)], xmm7   ; wk(0)=tmp6
+    movaps      XMMWORD [wk(1)], xmm6   ; wk(1)=tmp7
+
+    movaps      xmm7, xmm4              ; transpose coefficients(phase 2)
+    unpcklps2   xmm4, xmm2              ; xmm4=(20 21 22 23)=data2
+    unpckhps2   xmm7, xmm2              ; xmm7=(30 31 32 33)=data3
+    movaps      xmm6, xmm1              ; transpose coefficients(phase 2)
+    unpcklps2   xmm1, xmm3              ; xmm1=(40 41 42 43)=data4
+    unpckhps2   xmm6, xmm3              ; xmm6=(50 51 52 53)=data5
+
+    movaps      xmm2, xmm7
+    movaps      xmm3, xmm4
+    addps       xmm7, xmm1              ; xmm7=data3+data4=tmp3
+    addps       xmm4, xmm6              ; xmm4=data2+data5=tmp2
+    subps       xmm2, xmm1              ; xmm2=data3-data4=tmp4
+    subps       xmm3, xmm6              ; xmm3=data2-data5=tmp5
+
+    ; -- Even part
+
+    movaps      xmm1, xmm5
+    movaps      xmm6, xmm0
+    subps       xmm5, xmm7              ; xmm5=tmp13
+    subps       xmm0, xmm4              ; xmm0=tmp12
+    addps       xmm1, xmm7              ; xmm1=tmp10
+    addps       xmm6, xmm4              ; xmm6=tmp11
+
+    addps       xmm0, xmm5
+    mulps       xmm0, [rel PD_0_707]    ; xmm0=z1
+
+    movaps      xmm7, xmm1
+    movaps      xmm4, xmm5
+    subps       xmm1, xmm6              ; xmm1=data4
+    subps       xmm5, xmm0              ; xmm5=data6
+    addps       xmm7, xmm6              ; xmm7=data0
+    addps       xmm4, xmm0              ; xmm4=data2
+
+    movaps      XMMWORD [XMMBLOCK(4,0,rdx,SIZEOF_FAST_FLOAT)], xmm1
+    movaps      XMMWORD [XMMBLOCK(6,0,rdx,SIZEOF_FAST_FLOAT)], xmm5
+    movaps      XMMWORD [XMMBLOCK(0,0,rdx,SIZEOF_FAST_FLOAT)], xmm7
+    movaps      XMMWORD [XMMBLOCK(2,0,rdx,SIZEOF_FAST_FLOAT)], xmm4
+
+    ; -- Odd part
+
+    movaps      xmm6, XMMWORD [wk(0)]   ; xmm6=tmp6
+    movaps      xmm0, XMMWORD [wk(1)]   ; xmm0=tmp7
+
+    addps       xmm2, xmm3              ; xmm2=tmp10
+    addps       xmm3, xmm6              ; xmm3=tmp11
+    addps       xmm6, xmm0              ; xmm6=tmp12, xmm0=tmp7
+
+    mulps       xmm3, [rel PD_0_707]    ; xmm3=z3
+
+    movaps      xmm1, xmm2              ; xmm1=tmp10
+    subps       xmm2, xmm6
+    mulps       xmm2, [rel PD_0_382]    ; xmm2=z5
+    mulps       xmm1, [rel PD_0_541]    ; xmm1=MULTIPLY(tmp10,FIX_0_541196)
+    mulps       xmm6, [rel PD_1_306]    ; xmm6=MULTIPLY(tmp12,FIX_1_306562)
+    addps       xmm1, xmm2              ; xmm1=z2
+    addps       xmm6, xmm2              ; xmm6=z4
+
+    movaps      xmm5, xmm0
+    subps       xmm0, xmm3              ; xmm0=z13
+    addps       xmm5, xmm3              ; xmm5=z11
+
+    movaps      xmm7, xmm0
+    movaps      xmm4, xmm5
+    subps       xmm0, xmm1              ; xmm0=data3
+    subps       xmm5, xmm6              ; xmm5=data7
+    addps       xmm7, xmm1              ; xmm7=data5
+    addps       xmm4, xmm6              ; xmm4=data1
+
+    movaps      XMMWORD [XMMBLOCK(3,0,rdx,SIZEOF_FAST_FLOAT)], xmm0
+    movaps      XMMWORD [XMMBLOCK(7,0,rdx,SIZEOF_FAST_FLOAT)], xmm5
+    movaps      XMMWORD [XMMBLOCK(5,0,rdx,SIZEOF_FAST_FLOAT)], xmm7
+    movaps      XMMWORD [XMMBLOCK(1,0,rdx,SIZEOF_FAST_FLOAT)], xmm4
+
+    add         rdx, byte 4*SIZEOF_FAST_FLOAT
+    dec         rcx
+    jnz         near .columnloop
+
+    uncollect_args 1
+    mov         rsp, rbp                ; rsp <- aligned rbp
+    pop         rsp                     ; rsp <- original rbp
+    pop         rbp
+    ret
+
+; For some reason, the OS X linker does not honor the request to align the
+; segment unless we do this.
+    align       32
diff --git a/3rdparty/libjpeg/src/simd/x86_64/jfdctfst-sse2.asm b/3rdparty/libjpeg/src/simd/x86_64/jfdctfst-sse2.asm
new file mode 100644
index 00000000..2e1bfe6e
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/x86_64/jfdctfst-sse2.asm
@@ -0,0 +1,389 @@
+;
+; jfdctfst.asm - fast integer FDCT (64-bit SSE2)
+;
+; Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+; Copyright (C) 2009, 2016, D. R. Commander.
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+;
+; This file should be assembled with NASM (Netwide Assembler),
+; can *not* be assembled with Microsoft's MASM or any compatible
+; assembler (including Borland's Turbo Assembler).
+; NASM is available from http://nasm.sourceforge.net/ or
+; http://sourceforge.net/project/showfiles.php?group_id=6208
+;
+; This file contains a fast, not so accurate integer implementation of
+; the forward DCT (Discrete Cosine Transform). The following code is
+; based directly on the IJG's original jfdctfst.c; see the jfdctfst.c
+; for more details.
+
+%include "jsimdext.inc"
+%include "jdct.inc"
+
+; --------------------------------------------------------------------------
+
+%define CONST_BITS  8  ; 14 is also OK.
+
+%if CONST_BITS == 8
+F_0_382 equ  98  ; FIX(0.382683433)
+F_0_541 equ 139  ; FIX(0.541196100)
+F_0_707 equ 181  ; FIX(0.707106781)
+F_1_306 equ 334  ; FIX(1.306562965)
+%else
+; NASM cannot do compile-time arithmetic on floating-point constants.
+%define DESCALE(x, n)  (((x) + (1 << ((n) - 1))) >> (n))
+F_0_382 equ DESCALE( 410903207, 30 - CONST_BITS)  ; FIX(0.382683433)
+F_0_541 equ DESCALE( 581104887, 30 - CONST_BITS)  ; FIX(0.541196100)
+F_0_707 equ DESCALE( 759250124, 30 - CONST_BITS)  ; FIX(0.707106781)
+F_1_306 equ DESCALE(1402911301, 30 - CONST_BITS)  ; FIX(1.306562965)
+%endif
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_CONST
+
+; PRE_MULTIPLY_SCALE_BITS <= 2 (to avoid overflow)
+; CONST_BITS + CONST_SHIFT + PRE_MULTIPLY_SCALE_BITS == 16 (for pmulhw)
+
+%define PRE_MULTIPLY_SCALE_BITS  2
+%define CONST_SHIFT              (16 - PRE_MULTIPLY_SCALE_BITS - CONST_BITS)
+
+    alignz      32
+    GLOBAL_DATA(jconst_fdct_ifast_sse2)
+
+EXTN(jconst_fdct_ifast_sse2):
+
+PW_F0707 times 8 dw F_0_707 << CONST_SHIFT
+PW_F0382 times 8 dw F_0_382 << CONST_SHIFT
+PW_F0541 times 8 dw F_0_541 << CONST_SHIFT
+PW_F1306 times 8 dw F_1_306 << CONST_SHIFT
+
+    alignz      32
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_TEXT
+    BITS        64
+;
+; Perform the forward DCT on one block of samples.
+;
+; GLOBAL(void)
+; jsimd_fdct_ifast_sse2(DCTELEM *data)
+;
+
+; r10 = DCTELEM *data
+
+%define wk(i)   rbp - (WK_NUM - (i)) * SIZEOF_XMMWORD  ; xmmword wk[WK_NUM]
+%define WK_NUM  2
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_fdct_ifast_sse2)
+
+EXTN(jsimd_fdct_ifast_sse2):
+    push        rbp
+    mov         rax, rsp                     ; rax = original rbp
+    sub         rsp, byte 4
+    and         rsp, byte (-SIZEOF_XMMWORD)  ; align to 128 bits
+    mov         [rsp], rax
+    mov         rbp, rsp                     ; rbp = aligned rbp
+    lea         rsp, [wk(0)]
+    collect_args 1
+
+    ; ---- Pass 1: process rows.
+
+    mov         rdx, r10                ; (DCTELEM *)
+
+    movdqa      xmm0, XMMWORD [XMMBLOCK(0,0,rdx,SIZEOF_DCTELEM)]
+    movdqa      xmm1, XMMWORD [XMMBLOCK(1,0,rdx,SIZEOF_DCTELEM)]
+    movdqa      xmm2, XMMWORD [XMMBLOCK(2,0,rdx,SIZEOF_DCTELEM)]
+    movdqa      xmm3, XMMWORD [XMMBLOCK(3,0,rdx,SIZEOF_DCTELEM)]
+
+    ; xmm0=(00 01 02 03 04 05 06 07), xmm2=(20 21 22 23 24 25 26 27)
+    ; xmm1=(10 11 12 13 14 15 16 17), xmm3=(30 31 32 33 34 35 36 37)
+
+    movdqa      xmm4, xmm0              ; transpose coefficients(phase 1)
+    punpcklwd   xmm0, xmm1              ; xmm0=(00 10 01 11 02 12 03 13)
+    punpckhwd   xmm4, xmm1              ; xmm4=(04 14 05 15 06 16 07 17)
+    movdqa      xmm5, xmm2              ; transpose coefficients(phase 1)
+    punpcklwd   xmm2, xmm3              ; xmm2=(20 30 21 31 22 32 23 33)
+    punpckhwd   xmm5, xmm3              ; xmm5=(24 34 25 35 26 36 27 37)
+
+    movdqa      xmm6, XMMWORD [XMMBLOCK(4,0,rdx,SIZEOF_DCTELEM)]
+    movdqa      xmm7, XMMWORD [XMMBLOCK(5,0,rdx,SIZEOF_DCTELEM)]
+    movdqa      xmm1, XMMWORD [XMMBLOCK(6,0,rdx,SIZEOF_DCTELEM)]
+    movdqa      xmm3, XMMWORD [XMMBLOCK(7,0,rdx,SIZEOF_DCTELEM)]
+
+    ; xmm6=( 4 12 20 28 36 44 52 60), xmm1=( 6 14 22 30 38 46 54 62)
+    ; xmm7=( 5 13 21 29 37 45 53 61), xmm3=( 7 15 23 31 39 47 55 63)
+
+    movdqa      XMMWORD [wk(0)], xmm2   ; wk(0)=(20 30 21 31 22 32 23 33)
+    movdqa      XMMWORD [wk(1)], xmm5   ; wk(1)=(24 34 25 35 26 36 27 37)
+
+    movdqa      xmm2, xmm6              ; transpose coefficients(phase 1)
+    punpcklwd   xmm6, xmm7              ; xmm6=(40 50 41 51 42 52 43 53)
+    punpckhwd   xmm2, xmm7              ; xmm2=(44 54 45 55 46 56 47 57)
+    movdqa      xmm5, xmm1              ; transpose coefficients(phase 1)
+    punpcklwd   xmm1, xmm3              ; xmm1=(60 70 61 71 62 72 63 73)
+    punpckhwd   xmm5, xmm3              ; xmm5=(64 74 65 75 66 76 67 77)
+
+    movdqa      xmm7, xmm6              ; transpose coefficients(phase 2)
+    punpckldq   xmm6, xmm1              ; xmm6=(40 50 60 70 41 51 61 71)
+    punpckhdq   xmm7, xmm1              ; xmm7=(42 52 62 72 43 53 63 73)
+    movdqa      xmm3, xmm2              ; transpose coefficients(phase 2)
+    punpckldq   xmm2, xmm5              ; xmm2=(44 54 64 74 45 55 65 75)
+    punpckhdq   xmm3, xmm5              ; xmm3=(46 56 66 76 47 57 67 77)
+
+    movdqa      xmm1, XMMWORD [wk(0)]   ; xmm1=(20 30 21 31 22 32 23 33)
+    movdqa      xmm5, XMMWORD [wk(1)]   ; xmm5=(24 34 25 35 26 36 27 37)
+    movdqa      XMMWORD [wk(0)], xmm7   ; wk(0)=(42 52 62 72 43 53 63 73)
+    movdqa      XMMWORD [wk(1)], xmm2   ; wk(1)=(44 54 64 74 45 55 65 75)
+
+    movdqa      xmm7, xmm0              ; transpose coefficients(phase 2)
+    punpckldq   xmm0, xmm1              ; xmm0=(00 10 20 30 01 11 21 31)
+    punpckhdq   xmm7, xmm1              ; xmm7=(02 12 22 32 03 13 23 33)
+    movdqa      xmm2, xmm4              ; transpose coefficients(phase 2)
+    punpckldq   xmm4, xmm5              ; xmm4=(04 14 24 34 05 15 25 35)
+    punpckhdq   xmm2, xmm5              ; xmm2=(06 16 26 36 07 17 27 37)
+
+    movdqa      xmm1, xmm0              ; transpose coefficients(phase 3)
+    punpcklqdq  xmm0, xmm6              ; xmm0=(00 10 20 30 40 50 60 70)=data0
+    punpckhqdq  xmm1, xmm6              ; xmm1=(01 11 21 31 41 51 61 71)=data1
+    movdqa      xmm5, xmm2              ; transpose coefficients(phase 3)
+    punpcklqdq  xmm2, xmm3              ; xmm2=(06 16 26 36 46 56 66 76)=data6
+    punpckhqdq  xmm5, xmm3              ; xmm5=(07 17 27 37 47 57 67 77)=data7
+
+    movdqa      xmm6, xmm1
+    movdqa      xmm3, xmm0
+    psubw       xmm1, xmm2              ; xmm1=data1-data6=tmp6
+    psubw       xmm0, xmm5              ; xmm0=data0-data7=tmp7
+    paddw       xmm6, xmm2              ; xmm6=data1+data6=tmp1
+    paddw       xmm3, xmm5              ; xmm3=data0+data7=tmp0
+
+    movdqa      xmm2, XMMWORD [wk(0)]   ; xmm2=(42 52 62 72 43 53 63 73)
+    movdqa      xmm5, XMMWORD [wk(1)]   ; xmm5=(44 54 64 74 45 55 65 75)
+    movdqa      XMMWORD [wk(0)], xmm1   ; wk(0)=tmp6
+    movdqa      XMMWORD [wk(1)], xmm0   ; wk(1)=tmp7
+
+    movdqa      xmm1, xmm7              ; transpose coefficients(phase 3)
+    punpcklqdq  xmm7, xmm2              ; xmm7=(02 12 22 32 42 52 62 72)=data2
+    punpckhqdq  xmm1, xmm2              ; xmm1=(03 13 23 33 43 53 63 73)=data3
+    movdqa      xmm0, xmm4              ; transpose coefficients(phase 3)
+    punpcklqdq  xmm4, xmm5              ; xmm4=(04 14 24 34 44 54 64 74)=data4
+    punpckhqdq  xmm0, xmm5              ; xmm0=(05 15 25 35 45 55 65 75)=data5
+
+    movdqa      xmm2, xmm1
+    movdqa      xmm5, xmm7
+    paddw       xmm1, xmm4              ; xmm1=data3+data4=tmp3
+    paddw       xmm7, xmm0              ; xmm7=data2+data5=tmp2
+    psubw       xmm2, xmm4              ; xmm2=data3-data4=tmp4
+    psubw       xmm5, xmm0              ; xmm5=data2-data5=tmp5
+
+    ; -- Even part
+
+    movdqa      xmm4, xmm3
+    movdqa      xmm0, xmm6
+    psubw       xmm3, xmm1              ; xmm3=tmp13
+    psubw       xmm6, xmm7              ; xmm6=tmp12
+    paddw       xmm4, xmm1              ; xmm4=tmp10
+    paddw       xmm0, xmm7              ; xmm0=tmp11
+
+    paddw       xmm6, xmm3
+    psllw       xmm6, PRE_MULTIPLY_SCALE_BITS
+    pmulhw      xmm6, [rel PW_F0707]    ; xmm6=z1
+
+    movdqa      xmm1, xmm4
+    movdqa      xmm7, xmm3
+    psubw       xmm4, xmm0              ; xmm4=data4
+    psubw       xmm3, xmm6              ; xmm3=data6
+    paddw       xmm1, xmm0              ; xmm1=data0
+    paddw       xmm7, xmm6              ; xmm7=data2
+
+    movdqa      xmm0, XMMWORD [wk(0)]   ; xmm0=tmp6
+    movdqa      xmm6, XMMWORD [wk(1)]   ; xmm6=tmp7
+    movdqa      XMMWORD [wk(0)], xmm4   ; wk(0)=data4
+    movdqa      XMMWORD [wk(1)], xmm3   ; wk(1)=data6
+
+    ; -- Odd part
+
+    paddw       xmm2, xmm5              ; xmm2=tmp10
+    paddw       xmm5, xmm0              ; xmm5=tmp11
+    paddw       xmm0, xmm6              ; xmm0=tmp12, xmm6=tmp7
+
+    psllw       xmm2, PRE_MULTIPLY_SCALE_BITS
+    psllw       xmm0, PRE_MULTIPLY_SCALE_BITS
+
+    psllw       xmm5, PRE_MULTIPLY_SCALE_BITS
+    pmulhw      xmm5, [rel PW_F0707]    ; xmm5=z3
+
+    movdqa      xmm4, xmm2              ; xmm4=tmp10
+    psubw       xmm2, xmm0
+    pmulhw      xmm2, [rel PW_F0382]    ; xmm2=z5
+    pmulhw      xmm4, [rel PW_F0541]    ; xmm4=MULTIPLY(tmp10,FIX_0_541196)
+    pmulhw      xmm0, [rel PW_F1306]    ; xmm0=MULTIPLY(tmp12,FIX_1_306562)
+    paddw       xmm4, xmm2              ; xmm4=z2
+    paddw       xmm0, xmm2              ; xmm0=z4
+
+    movdqa      xmm3, xmm6
+    psubw       xmm6, xmm5              ; xmm6=z13
+    paddw       xmm3, xmm5              ; xmm3=z11
+
+    movdqa      xmm2, xmm6
+    movdqa      xmm5, xmm3
+    psubw       xmm6, xmm4              ; xmm6=data3
+    psubw       xmm3, xmm0              ; xmm3=data7
+    paddw       xmm2, xmm4              ; xmm2=data5
+    paddw       xmm5, xmm0              ; xmm5=data1
+
+    ; ---- Pass 2: process columns.
+
+    ; xmm1=(00 10 20 30 40 50 60 70), xmm7=(02 12 22 32 42 52 62 72)
+    ; xmm5=(01 11 21 31 41 51 61 71), xmm6=(03 13 23 33 43 53 63 73)
+
+    movdqa      xmm4, xmm1              ; transpose coefficients(phase 1)
+    punpcklwd   xmm1, xmm5              ; xmm1=(00 01 10 11 20 21 30 31)
+    punpckhwd   xmm4, xmm5              ; xmm4=(40 41 50 51 60 61 70 71)
+    movdqa      xmm0, xmm7              ; transpose coefficients(phase 1)
+    punpcklwd   xmm7, xmm6              ; xmm7=(02 03 12 13 22 23 32 33)
+    punpckhwd   xmm0, xmm6              ; xmm0=(42 43 52 53 62 63 72 73)
+
+    movdqa      xmm5, XMMWORD [wk(0)]   ; xmm5=col4
+    movdqa      xmm6, XMMWORD [wk(1)]   ; xmm6=col6
+
+    ; xmm5=(04 14 24 34 44 54 64 74), xmm6=(06 16 26 36 46 56 66 76)
+    ; xmm2=(05 15 25 35 45 55 65 75), xmm3=(07 17 27 37 47 57 67 77)
+
+    movdqa      XMMWORD [wk(0)], xmm7   ; wk(0)=(02 03 12 13 22 23 32 33)
+    movdqa      XMMWORD [wk(1)], xmm0   ; wk(1)=(42 43 52 53 62 63 72 73)
+
+    movdqa      xmm7, xmm5              ; transpose coefficients(phase 1)
+    punpcklwd   xmm5, xmm2              ; xmm5=(04 05 14 15 24 25 34 35)
+    punpckhwd   xmm7, xmm2              ; xmm7=(44 45 54 55 64 65 74 75)
+    movdqa      xmm0, xmm6              ; transpose coefficients(phase 1)
+    punpcklwd   xmm6, xmm3              ; xmm6=(06 07 16 17 26 27 36 37)
+    punpckhwd   xmm0, xmm3              ; xmm0=(46 47 56 57 66 67 76 77)
+
+    movdqa      xmm2, xmm5              ; transpose coefficients(phase 2)
+    punpckldq   xmm5, xmm6              ; xmm5=(04 05 06 07 14 15 16 17)
+    punpckhdq   xmm2, xmm6              ; xmm2=(24 25 26 27 34 35 36 37)
+    movdqa      xmm3, xmm7              ; transpose coefficients(phase 2)
+    punpckldq   xmm7, xmm0              ; xmm7=(44 45 46 47 54 55 56 57)
+    punpckhdq   xmm3, xmm0              ; xmm3=(64 65 66 67 74 75 76 77)
+
+    movdqa      xmm6, XMMWORD [wk(0)]   ; xmm6=(02 03 12 13 22 23 32 33)
+    movdqa      xmm0, XMMWORD [wk(1)]   ; xmm0=(42 43 52 53 62 63 72 73)
+    movdqa      XMMWORD [wk(0)], xmm2   ; wk(0)=(24 25 26 27 34 35 36 37)
+    movdqa      XMMWORD [wk(1)], xmm7   ; wk(1)=(44 45 46 47 54 55 56 57)
+
+    movdqa      xmm2, xmm1              ; transpose coefficients(phase 2)
+    punpckldq   xmm1, xmm6              ; xmm1=(00 01 02 03 10 11 12 13)
+    punpckhdq   xmm2, xmm6              ; xmm2=(20 21 22 23 30 31 32 33)
+    movdqa      xmm7, xmm4              ; transpose coefficients(phase 2)
+    punpckldq   xmm4, xmm0              ; xmm4=(40 41 42 43 50 51 52 53)
+    punpckhdq   xmm7, xmm0              ; xmm7=(60 61 62 63 70 71 72 73)
+
+    movdqa      xmm6, xmm1              ; transpose coefficients(phase 3)
+    punpcklqdq  xmm1, xmm5              ; xmm1=(00 01 02 03 04 05 06 07)=data0
+    punpckhqdq  xmm6, xmm5              ; xmm6=(10 11 12 13 14 15 16 17)=data1
+    movdqa      xmm0, xmm7              ; transpose coefficients(phase 3)
+    punpcklqdq  xmm7, xmm3              ; xmm7=(60 61 62 63 64 65 66 67)=data6
+    punpckhqdq  xmm0, xmm3              ; xmm0=(70 71 72 73 74 75 76 77)=data7
+
+    movdqa      xmm5, xmm6
+    movdqa      xmm3, xmm1
+    psubw       xmm6, xmm7              ; xmm6=data1-data6=tmp6
+    psubw       xmm1, xmm0              ; xmm1=data0-data7=tmp7
+    paddw       xmm5, xmm7              ; xmm5=data1+data6=tmp1
+    paddw       xmm3, xmm0              ; xmm3=data0+data7=tmp0
+
+    movdqa      xmm7, XMMWORD [wk(0)]   ; xmm7=(24 25 26 27 34 35 36 37)
+    movdqa      xmm0, XMMWORD [wk(1)]   ; xmm0=(44 45 46 47 54 55 56 57)
+    movdqa      XMMWORD [wk(0)], xmm6   ; wk(0)=tmp6
+    movdqa      XMMWORD [wk(1)], xmm1   ; wk(1)=tmp7
+
+    movdqa      xmm6, xmm2              ; transpose coefficients(phase 3)
+    punpcklqdq  xmm2, xmm7              ; xmm2=(20 21 22 23 24 25 26 27)=data2
+    punpckhqdq  xmm6, xmm7              ; xmm6=(30 31 32 33 34 35 36 37)=data3
+    movdqa      xmm1, xmm4              ; transpose coefficients(phase 3)
+    punpcklqdq  xmm4, xmm0              ; xmm4=(40 41 42 43 44 45 46 47)=data4
+    punpckhqdq  xmm1, xmm0              ; xmm1=(50 51 52 53 54 55 56 57)=data5
+
+    movdqa      xmm7, xmm6
+    movdqa      xmm0, xmm2
+    paddw       xmm6, xmm4              ; xmm6=data3+data4=tmp3
+    paddw       xmm2, xmm1              ; xmm2=data2+data5=tmp2
+    psubw       xmm7, xmm4              ; xmm7=data3-data4=tmp4
+    psubw       xmm0, xmm1              ; xmm0=data2-data5=tmp5
+
+    ; -- Even part
+
+    movdqa      xmm4, xmm3
+    movdqa      xmm1, xmm5
+    psubw       xmm3, xmm6              ; xmm3=tmp13
+    psubw       xmm5, xmm2              ; xmm5=tmp12
+    paddw       xmm4, xmm6              ; xmm4=tmp10
+    paddw       xmm1, xmm2              ; xmm1=tmp11
+
+    paddw       xmm5, xmm3
+    psllw       xmm5, PRE_MULTIPLY_SCALE_BITS
+    pmulhw      xmm5, [rel PW_F0707]    ; xmm5=z1
+
+    movdqa      xmm6, xmm4
+    movdqa      xmm2, xmm3
+    psubw       xmm4, xmm1              ; xmm4=data4
+    psubw       xmm3, xmm5              ; xmm3=data6
+    paddw       xmm6, xmm1              ; xmm6=data0
+    paddw       xmm2, xmm5              ; xmm2=data2
+
+    movdqa      XMMWORD [XMMBLOCK(4,0,rdx,SIZEOF_DCTELEM)], xmm4
+    movdqa      XMMWORD [XMMBLOCK(6,0,rdx,SIZEOF_DCTELEM)], xmm3
+    movdqa      XMMWORD [XMMBLOCK(0,0,rdx,SIZEOF_DCTELEM)], xmm6
+    movdqa      XMMWORD [XMMBLOCK(2,0,rdx,SIZEOF_DCTELEM)], xmm2
+
+    ; -- Odd part
+
+    movdqa      xmm1, XMMWORD [wk(0)]   ; xmm1=tmp6
+    movdqa      xmm5, XMMWORD [wk(1)]   ; xmm5=tmp7
+
+    paddw       xmm7, xmm0              ; xmm7=tmp10
+    paddw       xmm0, xmm1              ; xmm0=tmp11
+    paddw       xmm1, xmm5              ; xmm1=tmp12, xmm5=tmp7
+
+    psllw       xmm7, PRE_MULTIPLY_SCALE_BITS
+    psllw       xmm1, PRE_MULTIPLY_SCALE_BITS
+
+    psllw       xmm0, PRE_MULTIPLY_SCALE_BITS
+    pmulhw      xmm0, [rel PW_F0707]    ; xmm0=z3
+
+    movdqa      xmm4, xmm7              ; xmm4=tmp10
+    psubw       xmm7, xmm1
+    pmulhw      xmm7, [rel PW_F0382]    ; xmm7=z5
+    pmulhw      xmm4, [rel PW_F0541]    ; xmm4=MULTIPLY(tmp10,FIX_0_541196)
+    pmulhw      xmm1, [rel PW_F1306]    ; xmm1=MULTIPLY(tmp12,FIX_1_306562)
+    paddw       xmm4, xmm7              ; xmm4=z2
+    paddw       xmm1, xmm7              ; xmm1=z4
+
+    movdqa      xmm3, xmm5
+    psubw       xmm5, xmm0              ; xmm5=z13
+    paddw       xmm3, xmm0              ; xmm3=z11
+
+    movdqa      xmm6, xmm5
+    movdqa      xmm2, xmm3
+    psubw       xmm5, xmm4              ; xmm5=data3
+    psubw       xmm3, xmm1              ; xmm3=data7
+    paddw       xmm6, xmm4              ; xmm6=data5
+    paddw       xmm2, xmm1              ; xmm2=data1
+
+    movdqa      XMMWORD [XMMBLOCK(3,0,rdx,SIZEOF_DCTELEM)], xmm5
+    movdqa      XMMWORD [XMMBLOCK(7,0,rdx,SIZEOF_DCTELEM)], xmm3
+    movdqa      XMMWORD [XMMBLOCK(5,0,rdx,SIZEOF_DCTELEM)], xmm6
+    movdqa      XMMWORD [XMMBLOCK(1,0,rdx,SIZEOF_DCTELEM)], xmm2
+
+    uncollect_args 1
+    mov         rsp, rbp                ; rsp <- aligned rbp
+    pop         rsp                     ; rsp <- original rbp
+    pop         rbp
+    ret
+
+; For some reason, the OS X linker does not honor the request to align the
+; segment unless we do this.
+    align       32
diff --git a/3rdparty/libjpeg/src/simd/x86_64/jfdctint-avx2.asm b/3rdparty/libjpeg/src/simd/x86_64/jfdctint-avx2.asm
new file mode 100644
index 00000000..e56258b4
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/x86_64/jfdctint-avx2.asm
@@ -0,0 +1,320 @@
+;
+; jfdctint.asm - accurate integer FDCT (64-bit AVX2)
+;
+; Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+; Copyright (C) 2009, 2016, 2018, 2020, D. R. Commander.
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+;
+; This file should be assembled with NASM (Netwide Assembler),
+; can *not* be assembled with Microsoft's MASM or any compatible
+; assembler (including Borland's Turbo Assembler).
+; NASM is available from http://nasm.sourceforge.net/ or
+; http://sourceforge.net/project/showfiles.php?group_id=6208
+;
+; This file contains a slower but more accurate integer implementation of the
+; forward DCT (Discrete Cosine Transform). The following code is based
+; directly on the IJG's original jfdctint.c; see the jfdctint.c for
+; more details.
+
+%include "jsimdext.inc"
+%include "jdct.inc"
+
+; --------------------------------------------------------------------------
+
+%define CONST_BITS  13
+%define PASS1_BITS  2
+
+%define DESCALE_P1  (CONST_BITS - PASS1_BITS)
+%define DESCALE_P2  (CONST_BITS + PASS1_BITS)
+
+%if CONST_BITS == 13
+F_0_298 equ  2446  ; FIX(0.298631336)
+F_0_390 equ  3196  ; FIX(0.390180644)
+F_0_541 equ  4433  ; FIX(0.541196100)
+F_0_765 equ  6270  ; FIX(0.765366865)
+F_0_899 equ  7373  ; FIX(0.899976223)
+F_1_175 equ  9633  ; FIX(1.175875602)
+F_1_501 equ 12299  ; FIX(1.501321110)
+F_1_847 equ 15137  ; FIX(1.847759065)
+F_1_961 equ 16069  ; FIX(1.961570560)
+F_2_053 equ 16819  ; FIX(2.053119869)
+F_2_562 equ 20995  ; FIX(2.562915447)
+F_3_072 equ 25172  ; FIX(3.072711026)
+%else
+; NASM cannot do compile-time arithmetic on floating-point constants.
+%define DESCALE(x, n)  (((x) + (1 << ((n) - 1))) >> (n))
+F_0_298 equ DESCALE( 320652955, 30 - CONST_BITS)  ; FIX(0.298631336)
+F_0_390 equ DESCALE( 418953276, 30 - CONST_BITS)  ; FIX(0.390180644)
+F_0_541 equ DESCALE( 581104887, 30 - CONST_BITS)  ; FIX(0.541196100)
+F_0_765 equ DESCALE( 821806413, 30 - CONST_BITS)  ; FIX(0.765366865)
+F_0_899 equ DESCALE( 966342111, 30 - CONST_BITS)  ; FIX(0.899976223)
+F_1_175 equ DESCALE(1262586813, 30 - CONST_BITS)  ; FIX(1.175875602)
+F_1_501 equ DESCALE(1612031267, 30 - CONST_BITS)  ; FIX(1.501321110)
+F_1_847 equ DESCALE(1984016188, 30 - CONST_BITS)  ; FIX(1.847759065)
+F_1_961 equ DESCALE(2106220350, 30 - CONST_BITS)  ; FIX(1.961570560)
+F_2_053 equ DESCALE(2204520673, 30 - CONST_BITS)  ; FIX(2.053119869)
+F_2_562 equ DESCALE(2751909506, 30 - CONST_BITS)  ; FIX(2.562915447)
+F_3_072 equ DESCALE(3299298341, 30 - CONST_BITS)  ; FIX(3.072711026)
+%endif
+
+; --------------------------------------------------------------------------
+; In-place 8x8x16-bit matrix transpose using AVX2 instructions
+; %1-%4: Input/output registers
+; %5-%8: Temp registers
+
+%macro dotranspose 8
+    ; %1=(00 01 02 03 04 05 06 07  40 41 42 43 44 45 46 47)
+    ; %2=(10 11 12 13 14 15 16 17  50 51 52 53 54 55 56 57)
+    ; %3=(20 21 22 23 24 25 26 27  60 61 62 63 64 65 66 67)
+    ; %4=(30 31 32 33 34 35 36 37  70 71 72 73 74 75 76 77)
+
+    vpunpcklwd  %5, %1, %2
+    vpunpckhwd  %6, %1, %2
+    vpunpcklwd  %7, %3, %4
+    vpunpckhwd  %8, %3, %4
+    ; transpose coefficients(phase 1)
+    ; %5=(00 10 01 11 02 12 03 13  40 50 41 51 42 52 43 53)
+    ; %6=(04 14 05 15 06 16 07 17  44 54 45 55 46 56 47 57)
+    ; %7=(20 30 21 31 22 32 23 33  60 70 61 71 62 72 63 73)
+    ; %8=(24 34 25 35 26 36 27 37  64 74 65 75 66 76 67 77)
+
+    vpunpckldq  %1, %5, %7
+    vpunpckhdq  %2, %5, %7
+    vpunpckldq  %3, %6, %8
+    vpunpckhdq  %4, %6, %8
+    ; transpose coefficients(phase 2)
+    ; %1=(00 10 20 30 01 11 21 31  40 50 60 70 41 51 61 71)
+    ; %2=(02 12 22 32 03 13 23 33  42 52 62 72 43 53 63 73)
+    ; %3=(04 14 24 34 05 15 25 35  44 54 64 74 45 55 65 75)
+    ; %4=(06 16 26 36 07 17 27 37  46 56 66 76 47 57 67 77)
+
+    vpermq      %1, %1, 0x8D
+    vpermq      %2, %2, 0x8D
+    vpermq      %3, %3, 0xD8
+    vpermq      %4, %4, 0xD8
+    ; transpose coefficients(phase 3)
+    ; %1=(01 11 21 31 41 51 61 71  00 10 20 30 40 50 60 70)
+    ; %2=(03 13 23 33 43 53 63 73  02 12 22 32 42 52 62 72)
+    ; %3=(04 14 24 34 44 54 64 74  05 15 25 35 45 55 65 75)
+    ; %4=(06 16 26 36 46 56 66 76  07 17 27 37 47 57 67 77)
+%endmacro
+
+; --------------------------------------------------------------------------
+; In-place 8x8x16-bit accurate integer forward DCT using AVX2 instructions
+; %1-%4: Input/output registers
+; %5-%8: Temp registers
+; %9:    Pass (1 or 2)
+
+%macro dodct 9
+    vpsubw      %5, %1, %4              ; %5=data1_0-data6_7=tmp6_7
+    vpaddw      %6, %1, %4              ; %6=data1_0+data6_7=tmp1_0
+    vpaddw      %7, %2, %3              ; %7=data3_2+data4_5=tmp3_2
+    vpsubw      %8, %2, %3              ; %8=data3_2-data4_5=tmp4_5
+
+    ; -- Even part
+
+    vperm2i128  %6, %6, %6, 0x01        ; %6=tmp0_1
+    vpaddw      %1, %6, %7              ; %1=tmp0_1+tmp3_2=tmp10_11
+    vpsubw      %6, %6, %7              ; %6=tmp0_1-tmp3_2=tmp13_12
+
+    vperm2i128  %7, %1, %1, 0x01        ; %7=tmp11_10
+    vpsignw     %1, %1, [rel PW_1_NEG1]  ; %1=tmp10_neg11
+    vpaddw      %7, %7, %1              ; %7=(tmp10+tmp11)_(tmp10-tmp11)
+%if %9 == 1
+    vpsllw      %1, %7, PASS1_BITS      ; %1=data0_4
+%else
+    vpaddw      %7, %7, [rel PW_DESCALE_P2X]
+    vpsraw      %1, %7, PASS1_BITS      ; %1=data0_4
+%endif
+
+    ; (Original)
+    ; z1 = (tmp12 + tmp13) * 0.541196100;
+    ; data2 = z1 + tmp13 * 0.765366865;
+    ; data6 = z1 + tmp12 * -1.847759065;
+    ;
+    ; (This implementation)
+    ; data2 = tmp13 * (0.541196100 + 0.765366865) + tmp12 * 0.541196100;
+    ; data6 = tmp13 * 0.541196100 + tmp12 * (0.541196100 - 1.847759065);
+
+    vperm2i128  %7, %6, %6, 0x01        ; %7=tmp12_13
+    vpunpcklwd  %2, %6, %7
+    vpunpckhwd  %6, %6, %7
+    vpmaddwd    %2, %2, [rel PW_F130_F054_MF130_F054]  ; %2=data2_6L
+    vpmaddwd    %6, %6, [rel PW_F130_F054_MF130_F054]  ; %6=data2_6H
+
+    vpaddd      %2, %2, [rel PD_DESCALE_P %+ %9]
+    vpaddd      %6, %6, [rel PD_DESCALE_P %+ %9]
+    vpsrad      %2, %2, DESCALE_P %+ %9
+    vpsrad      %6, %6, DESCALE_P %+ %9
+
+    vpackssdw   %3, %2, %6              ; %6=data2_6
+
+    ; -- Odd part
+
+    vpaddw      %7, %8, %5              ; %7=tmp4_5+tmp6_7=z3_4
+
+    ; (Original)
+    ; z5 = (z3 + z4) * 1.175875602;
+    ; z3 = z3 * -1.961570560;  z4 = z4 * -0.390180644;
+    ; z3 += z5;  z4 += z5;
+    ;
+    ; (This implementation)
+    ; z3 = z3 * (1.175875602 - 1.961570560) + z4 * 1.175875602;
+    ; z4 = z3 * 1.175875602 + z4 * (1.175875602 - 0.390180644);
+
+    vperm2i128  %2, %7, %7, 0x01        ; %2=z4_3
+    vpunpcklwd  %6, %7, %2
+    vpunpckhwd  %7, %7, %2
+    vpmaddwd    %6, %6, [rel PW_MF078_F117_F078_F117]  ; %6=z3_4L
+    vpmaddwd    %7, %7, [rel PW_MF078_F117_F078_F117]  ; %7=z3_4H
+
+    ; (Original)
+    ; z1 = tmp4 + tmp7;  z2 = tmp5 + tmp6;
+    ; tmp4 = tmp4 * 0.298631336;  tmp5 = tmp5 * 2.053119869;
+    ; tmp6 = tmp6 * 3.072711026;  tmp7 = tmp7 * 1.501321110;
+    ; z1 = z1 * -0.899976223;  z2 = z2 * -2.562915447;
+    ; data7 = tmp4 + z1 + z3;  data5 = tmp5 + z2 + z4;
+    ; data3 = tmp6 + z2 + z3;  data1 = tmp7 + z1 + z4;
+    ;
+    ; (This implementation)
+    ; tmp4 = tmp4 * (0.298631336 - 0.899976223) + tmp7 * -0.899976223;
+    ; tmp5 = tmp5 * (2.053119869 - 2.562915447) + tmp6 * -2.562915447;
+    ; tmp6 = tmp5 * -2.562915447 + tmp6 * (3.072711026 - 2.562915447);
+    ; tmp7 = tmp4 * -0.899976223 + tmp7 * (1.501321110 - 0.899976223);
+    ; data7 = tmp4 + z3;  data5 = tmp5 + z4;
+    ; data3 = tmp6 + z3;  data1 = tmp7 + z4;
+
+    vperm2i128  %4, %5, %5, 0x01        ; %4=tmp7_6
+    vpunpcklwd  %2, %8, %4
+    vpunpckhwd  %4, %8, %4
+    vpmaddwd    %2, %2, [rel PW_MF060_MF089_MF050_MF256]  ; %2=tmp4_5L
+    vpmaddwd    %4, %4, [rel PW_MF060_MF089_MF050_MF256]  ; %4=tmp4_5H
+
+    vpaddd      %2, %2, %6              ; %2=data7_5L
+    vpaddd      %4, %4, %7              ; %4=data7_5H
+
+    vpaddd      %2, %2, [rel PD_DESCALE_P %+ %9]
+    vpaddd      %4, %4, [rel PD_DESCALE_P %+ %9]
+    vpsrad      %2, %2, DESCALE_P %+ %9
+    vpsrad      %4, %4, DESCALE_P %+ %9
+
+    vpackssdw   %4, %2, %4              ; %4=data7_5
+
+    vperm2i128  %2, %8, %8, 0x01        ; %2=tmp5_4
+    vpunpcklwd  %8, %5, %2
+    vpunpckhwd  %5, %5, %2
+    vpmaddwd    %8, %8, [rel PW_F050_MF256_F060_MF089]  ; %8=tmp6_7L
+    vpmaddwd    %5, %5, [rel PW_F050_MF256_F060_MF089]  ; %5=tmp6_7H
+
+    vpaddd      %8, %8, %6              ; %8=data3_1L
+    vpaddd      %5, %5, %7              ; %5=data3_1H
+
+    vpaddd      %8, %8, [rel PD_DESCALE_P %+ %9]
+    vpaddd      %5, %5, [rel PD_DESCALE_P %+ %9]
+    vpsrad      %8, %8, DESCALE_P %+ %9
+    vpsrad      %5, %5, DESCALE_P %+ %9
+
+    vpackssdw   %2, %8, %5              ; %2=data3_1
+%endmacro
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_CONST
+
+    alignz      32
+    GLOBAL_DATA(jconst_fdct_islow_avx2)
+
+EXTN(jconst_fdct_islow_avx2):
+
+PW_F130_F054_MF130_F054    times 4  dw  (F_0_541 + F_0_765),  F_0_541
+                           times 4  dw  (F_0_541 - F_1_847),  F_0_541
+PW_MF078_F117_F078_F117    times 4  dw  (F_1_175 - F_1_961),  F_1_175
+                           times 4  dw  (F_1_175 - F_0_390),  F_1_175
+PW_MF060_MF089_MF050_MF256 times 4  dw  (F_0_298 - F_0_899), -F_0_899
+                           times 4  dw  (F_2_053 - F_2_562), -F_2_562
+PW_F050_MF256_F060_MF089   times 4  dw  (F_3_072 - F_2_562), -F_2_562
+                           times 4  dw  (F_1_501 - F_0_899), -F_0_899
+PD_DESCALE_P1              times 8  dd  1 << (DESCALE_P1 - 1)
+PD_DESCALE_P2              times 8  dd  1 << (DESCALE_P2 - 1)
+PW_DESCALE_P2X             times 16 dw  1 << (PASS1_BITS - 1)
+PW_1_NEG1                  times 8  dw  1
+                           times 8  dw -1
+
+    alignz      32
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_TEXT
+    BITS        64
+;
+; Perform the forward DCT on one block of samples.
+;
+; GLOBAL(void)
+; jsimd_fdct_islow_avx2(DCTELEM *data)
+;
+
+; r10 = DCTELEM *data
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_fdct_islow_avx2)
+
+EXTN(jsimd_fdct_islow_avx2):
+    push        rbp
+    mov         rax, rsp
+    mov         rbp, rsp
+    collect_args 1
+
+    ; ---- Pass 1: process rows.
+
+    vmovdqu     ymm4, YMMWORD [YMMBLOCK(0,0,r10,SIZEOF_DCTELEM)]
+    vmovdqu     ymm5, YMMWORD [YMMBLOCK(2,0,r10,SIZEOF_DCTELEM)]
+    vmovdqu     ymm6, YMMWORD [YMMBLOCK(4,0,r10,SIZEOF_DCTELEM)]
+    vmovdqu     ymm7, YMMWORD [YMMBLOCK(6,0,r10,SIZEOF_DCTELEM)]
+    ; ymm4=(00 01 02 03 04 05 06 07  10 11 12 13 14 15 16 17)
+    ; ymm5=(20 21 22 23 24 25 26 27  30 31 32 33 34 35 36 37)
+    ; ymm6=(40 41 42 43 44 45 46 47  50 51 52 53 54 55 56 57)
+    ; ymm7=(60 61 62 63 64 65 66 67  70 71 72 73 74 75 76 77)
+
+    vperm2i128  ymm0, ymm4, ymm6, 0x20
+    vperm2i128  ymm1, ymm4, ymm6, 0x31
+    vperm2i128  ymm2, ymm5, ymm7, 0x20
+    vperm2i128  ymm3, ymm5, ymm7, 0x31
+    ; ymm0=(00 01 02 03 04 05 06 07  40 41 42 43 44 45 46 47)
+    ; ymm1=(10 11 12 13 14 15 16 17  50 51 52 53 54 55 56 57)
+    ; ymm2=(20 21 22 23 24 25 26 27  60 61 62 63 64 65 66 67)
+    ; ymm3=(30 31 32 33 34 35 36 37  70 71 72 73 74 75 76 77)
+
+    dotranspose ymm0, ymm1, ymm2, ymm3, ymm4, ymm5, ymm6, ymm7
+
+    dodct       ymm0, ymm1, ymm2, ymm3, ymm4, ymm5, ymm6, ymm7, 1
+    ; ymm0=data0_4, ymm1=data3_1, ymm2=data2_6, ymm3=data7_5
+
+    ; ---- Pass 2: process columns.
+
+    vperm2i128  ymm4, ymm1, ymm3, 0x20  ; ymm4=data3_7
+    vperm2i128  ymm1, ymm1, ymm3, 0x31  ; ymm1=data1_5
+
+    dotranspose ymm0, ymm1, ymm2, ymm4, ymm3, ymm5, ymm6, ymm7
+
+    dodct       ymm0, ymm1, ymm2, ymm4, ymm3, ymm5, ymm6, ymm7, 2
+    ; ymm0=data0_4, ymm1=data3_1, ymm2=data2_6, ymm4=data7_5
+
+    vperm2i128 ymm3, ymm0, ymm1, 0x30   ; ymm3=data0_1
+    vperm2i128 ymm5, ymm2, ymm1, 0x20   ; ymm5=data2_3
+    vperm2i128 ymm6, ymm0, ymm4, 0x31   ; ymm6=data4_5
+    vperm2i128 ymm7, ymm2, ymm4, 0x21   ; ymm7=data6_7
+
+    vmovdqu     YMMWORD [YMMBLOCK(0,0,r10,SIZEOF_DCTELEM)], ymm3
+    vmovdqu     YMMWORD [YMMBLOCK(2,0,r10,SIZEOF_DCTELEM)], ymm5
+    vmovdqu     YMMWORD [YMMBLOCK(4,0,r10,SIZEOF_DCTELEM)], ymm6
+    vmovdqu     YMMWORD [YMMBLOCK(6,0,r10,SIZEOF_DCTELEM)], ymm7
+
+    vzeroupper
+    uncollect_args 1
+    pop         rbp
+    ret
+
+; For some reason, the OS X linker does not honor the request to align the
+; segment unless we do this.
+    align       32
diff --git a/3rdparty/libjpeg/src/simd/x86_64/jfdctint-sse2.asm b/3rdparty/libjpeg/src/simd/x86_64/jfdctint-sse2.asm
new file mode 100644
index 00000000..ec1f383c
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/x86_64/jfdctint-sse2.asm
@@ -0,0 +1,619 @@
+;
+; jfdctint.asm - accurate integer FDCT (64-bit SSE2)
+;
+; Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+; Copyright (C) 2009, 2016, 2020, D. R. Commander.
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+;
+; This file should be assembled with NASM (Netwide Assembler),
+; can *not* be assembled with Microsoft's MASM or any compatible
+; assembler (including Borland's Turbo Assembler).
+; NASM is available from http://nasm.sourceforge.net/ or
+; http://sourceforge.net/project/showfiles.php?group_id=6208
+;
+; This file contains a slower but more accurate integer implementation of the
+; forward DCT (Discrete Cosine Transform). The following code is based
+; directly on the IJG's original jfdctint.c; see the jfdctint.c for
+; more details.
+
+%include "jsimdext.inc"
+%include "jdct.inc"
+
+; --------------------------------------------------------------------------
+
+%define CONST_BITS  13
+%define PASS1_BITS  2
+
+%define DESCALE_P1  (CONST_BITS - PASS1_BITS)
+%define DESCALE_P2  (CONST_BITS + PASS1_BITS)
+
+%if CONST_BITS == 13
+F_0_298 equ  2446  ; FIX(0.298631336)
+F_0_390 equ  3196  ; FIX(0.390180644)
+F_0_541 equ  4433  ; FIX(0.541196100)
+F_0_765 equ  6270  ; FIX(0.765366865)
+F_0_899 equ  7373  ; FIX(0.899976223)
+F_1_175 equ  9633  ; FIX(1.175875602)
+F_1_501 equ 12299  ; FIX(1.501321110)
+F_1_847 equ 15137  ; FIX(1.847759065)
+F_1_961 equ 16069  ; FIX(1.961570560)
+F_2_053 equ 16819  ; FIX(2.053119869)
+F_2_562 equ 20995  ; FIX(2.562915447)
+F_3_072 equ 25172  ; FIX(3.072711026)
+%else
+; NASM cannot do compile-time arithmetic on floating-point constants.
+%define DESCALE(x, n)  (((x) + (1 << ((n) - 1))) >> (n))
+F_0_298 equ DESCALE( 320652955, 30 - CONST_BITS)  ; FIX(0.298631336)
+F_0_390 equ DESCALE( 418953276, 30 - CONST_BITS)  ; FIX(0.390180644)
+F_0_541 equ DESCALE( 581104887, 30 - CONST_BITS)  ; FIX(0.541196100)
+F_0_765 equ DESCALE( 821806413, 30 - CONST_BITS)  ; FIX(0.765366865)
+F_0_899 equ DESCALE( 966342111, 30 - CONST_BITS)  ; FIX(0.899976223)
+F_1_175 equ DESCALE(1262586813, 30 - CONST_BITS)  ; FIX(1.175875602)
+F_1_501 equ DESCALE(1612031267, 30 - CONST_BITS)  ; FIX(1.501321110)
+F_1_847 equ DESCALE(1984016188, 30 - CONST_BITS)  ; FIX(1.847759065)
+F_1_961 equ DESCALE(2106220350, 30 - CONST_BITS)  ; FIX(1.961570560)
+F_2_053 equ DESCALE(2204520673, 30 - CONST_BITS)  ; FIX(2.053119869)
+F_2_562 equ DESCALE(2751909506, 30 - CONST_BITS)  ; FIX(2.562915447)
+F_3_072 equ DESCALE(3299298341, 30 - CONST_BITS)  ; FIX(3.072711026)
+%endif
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_CONST
+
+    alignz      32
+    GLOBAL_DATA(jconst_fdct_islow_sse2)
+
+EXTN(jconst_fdct_islow_sse2):
+
+PW_F130_F054   times 4 dw  (F_0_541 + F_0_765),  F_0_541
+PW_F054_MF130  times 4 dw  F_0_541, (F_0_541 - F_1_847)
+PW_MF078_F117  times 4 dw  (F_1_175 - F_1_961),  F_1_175
+PW_F117_F078   times 4 dw  F_1_175, (F_1_175 - F_0_390)
+PW_MF060_MF089 times 4 dw  (F_0_298 - F_0_899), -F_0_899
+PW_MF089_F060  times 4 dw -F_0_899, (F_1_501 - F_0_899)
+PW_MF050_MF256 times 4 dw  (F_2_053 - F_2_562), -F_2_562
+PW_MF256_F050  times 4 dw -F_2_562, (F_3_072 - F_2_562)
+PD_DESCALE_P1  times 4 dd  1 << (DESCALE_P1 - 1)
+PD_DESCALE_P2  times 4 dd  1 << (DESCALE_P2 - 1)
+PW_DESCALE_P2X times 8 dw  1 << (PASS1_BITS - 1)
+
+    alignz      32
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_TEXT
+    BITS        64
+;
+; Perform the forward DCT on one block of samples.
+;
+; GLOBAL(void)
+; jsimd_fdct_islow_sse2(DCTELEM *data)
+;
+
+; r10 = DCTELEM *data
+
+%define wk(i)   rbp - (WK_NUM - (i)) * SIZEOF_XMMWORD  ; xmmword wk[WK_NUM]
+%define WK_NUM  6
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_fdct_islow_sse2)
+
+EXTN(jsimd_fdct_islow_sse2):
+    push        rbp
+    mov         rax, rsp                     ; rax = original rbp
+    sub         rsp, byte 4
+    and         rsp, byte (-SIZEOF_XMMWORD)  ; align to 128 bits
+    mov         [rsp], rax
+    mov         rbp, rsp                     ; rbp = aligned rbp
+    lea         rsp, [wk(0)]
+    collect_args 1
+
+    ; ---- Pass 1: process rows.
+
+    mov         rdx, r10                ; (DCTELEM *)
+
+    movdqa      xmm0, XMMWORD [XMMBLOCK(0,0,rdx,SIZEOF_DCTELEM)]
+    movdqa      xmm1, XMMWORD [XMMBLOCK(1,0,rdx,SIZEOF_DCTELEM)]
+    movdqa      xmm2, XMMWORD [XMMBLOCK(2,0,rdx,SIZEOF_DCTELEM)]
+    movdqa      xmm3, XMMWORD [XMMBLOCK(3,0,rdx,SIZEOF_DCTELEM)]
+
+    ; xmm0=(00 01 02 03 04 05 06 07), xmm2=(20 21 22 23 24 25 26 27)
+    ; xmm1=(10 11 12 13 14 15 16 17), xmm3=(30 31 32 33 34 35 36 37)
+
+    movdqa      xmm4, xmm0              ; transpose coefficients(phase 1)
+    punpcklwd   xmm0, xmm1              ; xmm0=(00 10 01 11 02 12 03 13)
+    punpckhwd   xmm4, xmm1              ; xmm4=(04 14 05 15 06 16 07 17)
+    movdqa      xmm5, xmm2              ; transpose coefficients(phase 1)
+    punpcklwd   xmm2, xmm3              ; xmm2=(20 30 21 31 22 32 23 33)
+    punpckhwd   xmm5, xmm3              ; xmm5=(24 34 25 35 26 36 27 37)
+
+    movdqa      xmm6, XMMWORD [XMMBLOCK(4,0,rdx,SIZEOF_DCTELEM)]
+    movdqa      xmm7, XMMWORD [XMMBLOCK(5,0,rdx,SIZEOF_DCTELEM)]
+    movdqa      xmm1, XMMWORD [XMMBLOCK(6,0,rdx,SIZEOF_DCTELEM)]
+    movdqa      xmm3, XMMWORD [XMMBLOCK(7,0,rdx,SIZEOF_DCTELEM)]
+
+    ; xmm6=( 4 12 20 28 36 44 52 60), xmm1=( 6 14 22 30 38 46 54 62)
+    ; xmm7=( 5 13 21 29 37 45 53 61), xmm3=( 7 15 23 31 39 47 55 63)
+
+    movdqa      XMMWORD [wk(0)], xmm2   ; wk(0)=(20 30 21 31 22 32 23 33)
+    movdqa      XMMWORD [wk(1)], xmm5   ; wk(1)=(24 34 25 35 26 36 27 37)
+
+    movdqa      xmm2, xmm6              ; transpose coefficients(phase 1)
+    punpcklwd   xmm6, xmm7              ; xmm6=(40 50 41 51 42 52 43 53)
+    punpckhwd   xmm2, xmm7              ; xmm2=(44 54 45 55 46 56 47 57)
+    movdqa      xmm5, xmm1              ; transpose coefficients(phase 1)
+    punpcklwd   xmm1, xmm3              ; xmm1=(60 70 61 71 62 72 63 73)
+    punpckhwd   xmm5, xmm3              ; xmm5=(64 74 65 75 66 76 67 77)
+
+    movdqa      xmm7, xmm6              ; transpose coefficients(phase 2)
+    punpckldq   xmm6, xmm1              ; xmm6=(40 50 60 70 41 51 61 71)
+    punpckhdq   xmm7, xmm1              ; xmm7=(42 52 62 72 43 53 63 73)
+    movdqa      xmm3, xmm2              ; transpose coefficients(phase 2)
+    punpckldq   xmm2, xmm5              ; xmm2=(44 54 64 74 45 55 65 75)
+    punpckhdq   xmm3, xmm5              ; xmm3=(46 56 66 76 47 57 67 77)
+
+    movdqa      xmm1, XMMWORD [wk(0)]   ; xmm1=(20 30 21 31 22 32 23 33)
+    movdqa      xmm5, XMMWORD [wk(1)]   ; xmm5=(24 34 25 35 26 36 27 37)
+    movdqa      XMMWORD [wk(2)], xmm7   ; wk(2)=(42 52 62 72 43 53 63 73)
+    movdqa      XMMWORD [wk(3)], xmm2   ; wk(3)=(44 54 64 74 45 55 65 75)
+
+    movdqa      xmm7, xmm0              ; transpose coefficients(phase 2)
+    punpckldq   xmm0, xmm1              ; xmm0=(00 10 20 30 01 11 21 31)
+    punpckhdq   xmm7, xmm1              ; xmm7=(02 12 22 32 03 13 23 33)
+    movdqa      xmm2, xmm4              ; transpose coefficients(phase 2)
+    punpckldq   xmm4, xmm5              ; xmm4=(04 14 24 34 05 15 25 35)
+    punpckhdq   xmm2, xmm5              ; xmm2=(06 16 26 36 07 17 27 37)
+
+    movdqa      xmm1, xmm0              ; transpose coefficients(phase 3)
+    punpcklqdq  xmm0, xmm6              ; xmm0=(00 10 20 30 40 50 60 70)=data0
+    punpckhqdq  xmm1, xmm6              ; xmm1=(01 11 21 31 41 51 61 71)=data1
+    movdqa      xmm5, xmm2              ; transpose coefficients(phase 3)
+    punpcklqdq  xmm2, xmm3              ; xmm2=(06 16 26 36 46 56 66 76)=data6
+    punpckhqdq  xmm5, xmm3              ; xmm5=(07 17 27 37 47 57 67 77)=data7
+
+    movdqa      xmm6, xmm1
+    movdqa      xmm3, xmm0
+    psubw       xmm1, xmm2              ; xmm1=data1-data6=tmp6
+    psubw       xmm0, xmm5              ; xmm0=data0-data7=tmp7
+    paddw       xmm6, xmm2              ; xmm6=data1+data6=tmp1
+    paddw       xmm3, xmm5              ; xmm3=data0+data7=tmp0
+
+    movdqa      xmm2, XMMWORD [wk(2)]   ; xmm2=(42 52 62 72 43 53 63 73)
+    movdqa      xmm5, XMMWORD [wk(3)]   ; xmm5=(44 54 64 74 45 55 65 75)
+    movdqa      XMMWORD [wk(0)], xmm1   ; wk(0)=tmp6
+    movdqa      XMMWORD [wk(1)], xmm0   ; wk(1)=tmp7
+
+    movdqa      xmm1, xmm7              ; transpose coefficients(phase 3)
+    punpcklqdq  xmm7, xmm2              ; xmm7=(02 12 22 32 42 52 62 72)=data2
+    punpckhqdq  xmm1, xmm2              ; xmm1=(03 13 23 33 43 53 63 73)=data3
+    movdqa      xmm0, xmm4              ; transpose coefficients(phase 3)
+    punpcklqdq  xmm4, xmm5              ; xmm4=(04 14 24 34 44 54 64 74)=data4
+    punpckhqdq  xmm0, xmm5              ; xmm0=(05 15 25 35 45 55 65 75)=data5
+
+    movdqa      xmm2, xmm1
+    movdqa      xmm5, xmm7
+    paddw       xmm1, xmm4              ; xmm1=data3+data4=tmp3
+    paddw       xmm7, xmm0              ; xmm7=data2+data5=tmp2
+    psubw       xmm2, xmm4              ; xmm2=data3-data4=tmp4
+    psubw       xmm5, xmm0              ; xmm5=data2-data5=tmp5
+
+    ; -- Even part
+
+    movdqa      xmm4, xmm3
+    movdqa      xmm0, xmm6
+    paddw       xmm3, xmm1              ; xmm3=tmp10
+    paddw       xmm6, xmm7              ; xmm6=tmp11
+    psubw       xmm4, xmm1              ; xmm4=tmp13
+    psubw       xmm0, xmm7              ; xmm0=tmp12
+
+    movdqa      xmm1, xmm3
+    paddw       xmm3, xmm6              ; xmm3=tmp10+tmp11
+    psubw       xmm1, xmm6              ; xmm1=tmp10-tmp11
+
+    psllw       xmm3, PASS1_BITS        ; xmm3=data0
+    psllw       xmm1, PASS1_BITS        ; xmm1=data4
+
+    movdqa      XMMWORD [wk(2)], xmm3   ; wk(2)=data0
+    movdqa      XMMWORD [wk(3)], xmm1   ; wk(3)=data4
+
+    ; (Original)
+    ; z1 = (tmp12 + tmp13) * 0.541196100;
+    ; data2 = z1 + tmp13 * 0.765366865;
+    ; data6 = z1 + tmp12 * -1.847759065;
+    ;
+    ; (This implementation)
+    ; data2 = tmp13 * (0.541196100 + 0.765366865) + tmp12 * 0.541196100;
+    ; data6 = tmp13 * 0.541196100 + tmp12 * (0.541196100 - 1.847759065);
+
+    movdqa      xmm7, xmm4              ; xmm4=tmp13
+    movdqa      xmm6, xmm4
+    punpcklwd   xmm7, xmm0              ; xmm0=tmp12
+    punpckhwd   xmm6, xmm0
+    movdqa      xmm4, xmm7
+    movdqa      xmm0, xmm6
+    pmaddwd     xmm7, [rel PW_F130_F054]   ; xmm7=data2L
+    pmaddwd     xmm6, [rel PW_F130_F054]   ; xmm6=data2H
+    pmaddwd     xmm4, [rel PW_F054_MF130]  ; xmm4=data6L
+    pmaddwd     xmm0, [rel PW_F054_MF130]  ; xmm0=data6H
+
+    paddd       xmm7, [rel PD_DESCALE_P1]
+    paddd       xmm6, [rel PD_DESCALE_P1]
+    psrad       xmm7, DESCALE_P1
+    psrad       xmm6, DESCALE_P1
+    paddd       xmm4, [rel PD_DESCALE_P1]
+    paddd       xmm0, [rel PD_DESCALE_P1]
+    psrad       xmm4, DESCALE_P1
+    psrad       xmm0, DESCALE_P1
+
+    packssdw    xmm7, xmm6              ; xmm7=data2
+    packssdw    xmm4, xmm0              ; xmm4=data6
+
+    movdqa      XMMWORD [wk(4)], xmm7   ; wk(4)=data2
+    movdqa      XMMWORD [wk(5)], xmm4   ; wk(5)=data6
+
+    ; -- Odd part
+
+    movdqa      xmm3, XMMWORD [wk(0)]   ; xmm3=tmp6
+    movdqa      xmm1, XMMWORD [wk(1)]   ; xmm1=tmp7
+
+    movdqa      xmm6, xmm2              ; xmm2=tmp4
+    movdqa      xmm0, xmm5              ; xmm5=tmp5
+    paddw       xmm6, xmm3              ; xmm6=z3
+    paddw       xmm0, xmm1              ; xmm0=z4
+
+    ; (Original)
+    ; z5 = (z3 + z4) * 1.175875602;
+    ; z3 = z3 * -1.961570560;  z4 = z4 * -0.390180644;
+    ; z3 += z5;  z4 += z5;
+    ;
+    ; (This implementation)
+    ; z3 = z3 * (1.175875602 - 1.961570560) + z4 * 1.175875602;
+    ; z4 = z3 * 1.175875602 + z4 * (1.175875602 - 0.390180644);
+
+    movdqa      xmm7, xmm6
+    movdqa      xmm4, xmm6
+    punpcklwd   xmm7, xmm0
+    punpckhwd   xmm4, xmm0
+    movdqa      xmm6, xmm7
+    movdqa      xmm0, xmm4
+    pmaddwd     xmm7, [rel PW_MF078_F117]  ; xmm7=z3L
+    pmaddwd     xmm4, [rel PW_MF078_F117]  ; xmm4=z3H
+    pmaddwd     xmm6, [rel PW_F117_F078]   ; xmm6=z4L
+    pmaddwd     xmm0, [rel PW_F117_F078]   ; xmm0=z4H
+
+    movdqa      XMMWORD [wk(0)], xmm7   ; wk(0)=z3L
+    movdqa      XMMWORD [wk(1)], xmm4   ; wk(1)=z3H
+
+    ; (Original)
+    ; z1 = tmp4 + tmp7;  z2 = tmp5 + tmp6;
+    ; tmp4 = tmp4 * 0.298631336;  tmp5 = tmp5 * 2.053119869;
+    ; tmp6 = tmp6 * 3.072711026;  tmp7 = tmp7 * 1.501321110;
+    ; z1 = z1 * -0.899976223;  z2 = z2 * -2.562915447;
+    ; data7 = tmp4 + z1 + z3;  data5 = tmp5 + z2 + z4;
+    ; data3 = tmp6 + z2 + z3;  data1 = tmp7 + z1 + z4;
+    ;
+    ; (This implementation)
+    ; tmp4 = tmp4 * (0.298631336 - 0.899976223) + tmp7 * -0.899976223;
+    ; tmp5 = tmp5 * (2.053119869 - 2.562915447) + tmp6 * -2.562915447;
+    ; tmp6 = tmp5 * -2.562915447 + tmp6 * (3.072711026 - 2.562915447);
+    ; tmp7 = tmp4 * -0.899976223 + tmp7 * (1.501321110 - 0.899976223);
+    ; data7 = tmp4 + z3;  data5 = tmp5 + z4;
+    ; data3 = tmp6 + z3;  data1 = tmp7 + z4;
+
+    movdqa      xmm7, xmm2
+    movdqa      xmm4, xmm2
+    punpcklwd   xmm7, xmm1
+    punpckhwd   xmm4, xmm1
+    movdqa      xmm2, xmm7
+    movdqa      xmm1, xmm4
+    pmaddwd     xmm7, [rel PW_MF060_MF089]  ; xmm7=tmp4L
+    pmaddwd     xmm4, [rel PW_MF060_MF089]  ; xmm4=tmp4H
+    pmaddwd     xmm2, [rel PW_MF089_F060]   ; xmm2=tmp7L
+    pmaddwd     xmm1, [rel PW_MF089_F060]   ; xmm1=tmp7H
+
+    paddd       xmm7, XMMWORD [wk(0)]   ; xmm7=data7L
+    paddd       xmm4, XMMWORD [wk(1)]   ; xmm4=data7H
+    paddd       xmm2, xmm6              ; xmm2=data1L
+    paddd       xmm1, xmm0              ; xmm1=data1H
+
+    paddd       xmm7, [rel PD_DESCALE_P1]
+    paddd       xmm4, [rel PD_DESCALE_P1]
+    psrad       xmm7, DESCALE_P1
+    psrad       xmm4, DESCALE_P1
+    paddd       xmm2, [rel PD_DESCALE_P1]
+    paddd       xmm1, [rel PD_DESCALE_P1]
+    psrad       xmm2, DESCALE_P1
+    psrad       xmm1, DESCALE_P1
+
+    packssdw    xmm7, xmm4              ; xmm7=data7
+    packssdw    xmm2, xmm1              ; xmm2=data1
+
+    movdqa      xmm4, xmm5
+    movdqa      xmm1, xmm5
+    punpcklwd   xmm4, xmm3
+    punpckhwd   xmm1, xmm3
+    movdqa      xmm5, xmm4
+    movdqa      xmm3, xmm1
+    pmaddwd     xmm4, [rel PW_MF050_MF256]  ; xmm4=tmp5L
+    pmaddwd     xmm1, [rel PW_MF050_MF256]  ; xmm1=tmp5H
+    pmaddwd     xmm5, [rel PW_MF256_F050]   ; xmm5=tmp6L
+    pmaddwd     xmm3, [rel PW_MF256_F050]   ; xmm3=tmp6H
+
+    paddd       xmm4, xmm6              ; xmm4=data5L
+    paddd       xmm1, xmm0              ; xmm1=data5H
+    paddd       xmm5, XMMWORD [wk(0)]   ; xmm5=data3L
+    paddd       xmm3, XMMWORD [wk(1)]   ; xmm3=data3H
+
+    paddd       xmm4, [rel PD_DESCALE_P1]
+    paddd       xmm1, [rel PD_DESCALE_P1]
+    psrad       xmm4, DESCALE_P1
+    psrad       xmm1, DESCALE_P1
+    paddd       xmm5, [rel PD_DESCALE_P1]
+    paddd       xmm3, [rel PD_DESCALE_P1]
+    psrad       xmm5, DESCALE_P1
+    psrad       xmm3, DESCALE_P1
+
+    packssdw    xmm4, xmm1              ; xmm4=data5
+    packssdw    xmm5, xmm3              ; xmm5=data3
+
+    ; ---- Pass 2: process columns.
+
+    movdqa      xmm6, XMMWORD [wk(2)]   ; xmm6=col0
+    movdqa      xmm0, XMMWORD [wk(4)]   ; xmm0=col2
+
+    ; xmm6=(00 10 20 30 40 50 60 70), xmm0=(02 12 22 32 42 52 62 72)
+    ; xmm2=(01 11 21 31 41 51 61 71), xmm5=(03 13 23 33 43 53 63 73)
+
+    movdqa      xmm1, xmm6              ; transpose coefficients(phase 1)
+    punpcklwd   xmm6, xmm2              ; xmm6=(00 01 10 11 20 21 30 31)
+    punpckhwd   xmm1, xmm2              ; xmm1=(40 41 50 51 60 61 70 71)
+    movdqa      xmm3, xmm0              ; transpose coefficients(phase 1)
+    punpcklwd   xmm0, xmm5              ; xmm0=(02 03 12 13 22 23 32 33)
+    punpckhwd   xmm3, xmm5              ; xmm3=(42 43 52 53 62 63 72 73)
+
+    movdqa      xmm2, XMMWORD [wk(3)]   ; xmm2=col4
+    movdqa      xmm5, XMMWORD [wk(5)]   ; xmm5=col6
+
+    ; xmm2=(04 14 24 34 44 54 64 74), xmm5=(06 16 26 36 46 56 66 76)
+    ; xmm4=(05 15 25 35 45 55 65 75), xmm7=(07 17 27 37 47 57 67 77)
+
+    movdqa      XMMWORD [wk(0)], xmm0   ; wk(0)=(02 03 12 13 22 23 32 33)
+    movdqa      XMMWORD [wk(1)], xmm3   ; wk(1)=(42 43 52 53 62 63 72 73)
+
+    movdqa      xmm0, xmm2              ; transpose coefficients(phase 1)
+    punpcklwd   xmm2, xmm4              ; xmm2=(04 05 14 15 24 25 34 35)
+    punpckhwd   xmm0, xmm4              ; xmm0=(44 45 54 55 64 65 74 75)
+    movdqa      xmm3, xmm5              ; transpose coefficients(phase 1)
+    punpcklwd   xmm5, xmm7              ; xmm5=(06 07 16 17 26 27 36 37)
+    punpckhwd   xmm3, xmm7              ; xmm3=(46 47 56 57 66 67 76 77)
+
+    movdqa      xmm4, xmm2              ; transpose coefficients(phase 2)
+    punpckldq   xmm2, xmm5              ; xmm2=(04 05 06 07 14 15 16 17)
+    punpckhdq   xmm4, xmm5              ; xmm4=(24 25 26 27 34 35 36 37)
+    movdqa      xmm7, xmm0              ; transpose coefficients(phase 2)
+    punpckldq   xmm0, xmm3              ; xmm0=(44 45 46 47 54 55 56 57)
+    punpckhdq   xmm7, xmm3              ; xmm7=(64 65 66 67 74 75 76 77)
+
+    movdqa      xmm5, XMMWORD [wk(0)]   ; xmm5=(02 03 12 13 22 23 32 33)
+    movdqa      xmm3, XMMWORD [wk(1)]   ; xmm3=(42 43 52 53 62 63 72 73)
+    movdqa      XMMWORD [wk(2)], xmm4   ; wk(2)=(24 25 26 27 34 35 36 37)
+    movdqa      XMMWORD [wk(3)], xmm0   ; wk(3)=(44 45 46 47 54 55 56 57)
+
+    movdqa      xmm4, xmm6              ; transpose coefficients(phase 2)
+    punpckldq   xmm6, xmm5              ; xmm6=(00 01 02 03 10 11 12 13)
+    punpckhdq   xmm4, xmm5              ; xmm4=(20 21 22 23 30 31 32 33)
+    movdqa      xmm0, xmm1              ; transpose coefficients(phase 2)
+    punpckldq   xmm1, xmm3              ; xmm1=(40 41 42 43 50 51 52 53)
+    punpckhdq   xmm0, xmm3              ; xmm0=(60 61 62 63 70 71 72 73)
+
+    movdqa      xmm5, xmm6              ; transpose coefficients(phase 3)
+    punpcklqdq  xmm6, xmm2              ; xmm6=(00 01 02 03 04 05 06 07)=data0
+    punpckhqdq  xmm5, xmm2              ; xmm5=(10 11 12 13 14 15 16 17)=data1
+    movdqa      xmm3, xmm0              ; transpose coefficients(phase 3)
+    punpcklqdq  xmm0, xmm7              ; xmm0=(60 61 62 63 64 65 66 67)=data6
+    punpckhqdq  xmm3, xmm7              ; xmm3=(70 71 72 73 74 75 76 77)=data7
+
+    movdqa      xmm2, xmm5
+    movdqa      xmm7, xmm6
+    psubw       xmm5, xmm0              ; xmm5=data1-data6=tmp6
+    psubw       xmm6, xmm3              ; xmm6=data0-data7=tmp7
+    paddw       xmm2, xmm0              ; xmm2=data1+data6=tmp1
+    paddw       xmm7, xmm3              ; xmm7=data0+data7=tmp0
+
+    movdqa      xmm0, XMMWORD [wk(2)]   ; xmm0=(24 25 26 27 34 35 36 37)
+    movdqa      xmm3, XMMWORD [wk(3)]   ; xmm3=(44 45 46 47 54 55 56 57)
+    movdqa      XMMWORD [wk(0)], xmm5   ; wk(0)=tmp6
+    movdqa      XMMWORD [wk(1)], xmm6   ; wk(1)=tmp7
+
+    movdqa      xmm5, xmm4              ; transpose coefficients(phase 3)
+    punpcklqdq  xmm4, xmm0              ; xmm4=(20 21 22 23 24 25 26 27)=data2
+    punpckhqdq  xmm5, xmm0              ; xmm5=(30 31 32 33 34 35 36 37)=data3
+    movdqa      xmm6, xmm1              ; transpose coefficients(phase 3)
+    punpcklqdq  xmm1, xmm3              ; xmm1=(40 41 42 43 44 45 46 47)=data4
+    punpckhqdq  xmm6, xmm3              ; xmm6=(50 51 52 53 54 55 56 57)=data5
+
+    movdqa      xmm0, xmm5
+    movdqa      xmm3, xmm4
+    paddw       xmm5, xmm1              ; xmm5=data3+data4=tmp3
+    paddw       xmm4, xmm6              ; xmm4=data2+data5=tmp2
+    psubw       xmm0, xmm1              ; xmm0=data3-data4=tmp4
+    psubw       xmm3, xmm6              ; xmm3=data2-data5=tmp5
+
+    ; -- Even part
+
+    movdqa      xmm1, xmm7
+    movdqa      xmm6, xmm2
+    paddw       xmm7, xmm5              ; xmm7=tmp10
+    paddw       xmm2, xmm4              ; xmm2=tmp11
+    psubw       xmm1, xmm5              ; xmm1=tmp13
+    psubw       xmm6, xmm4              ; xmm6=tmp12
+
+    movdqa      xmm5, xmm7
+    paddw       xmm7, xmm2              ; xmm7=tmp10+tmp11
+    psubw       xmm5, xmm2              ; xmm5=tmp10-tmp11
+
+    paddw       xmm7, [rel PW_DESCALE_P2X]
+    paddw       xmm5, [rel PW_DESCALE_P2X]
+    psraw       xmm7, PASS1_BITS        ; xmm7=data0
+    psraw       xmm5, PASS1_BITS        ; xmm5=data4
+
+    movdqa      XMMWORD [XMMBLOCK(0,0,rdx,SIZEOF_DCTELEM)], xmm7
+    movdqa      XMMWORD [XMMBLOCK(4,0,rdx,SIZEOF_DCTELEM)], xmm5
+
+    ; (Original)
+    ; z1 = (tmp12 + tmp13) * 0.541196100;
+    ; data2 = z1 + tmp13 * 0.765366865;
+    ; data6 = z1 + tmp12 * -1.847759065;
+    ;
+    ; (This implementation)
+    ; data2 = tmp13 * (0.541196100 + 0.765366865) + tmp12 * 0.541196100;
+    ; data6 = tmp13 * 0.541196100 + tmp12 * (0.541196100 - 1.847759065);
+
+    movdqa      xmm4, xmm1              ; xmm1=tmp13
+    movdqa      xmm2, xmm1
+    punpcklwd   xmm4, xmm6              ; xmm6=tmp12
+    punpckhwd   xmm2, xmm6
+    movdqa      xmm1, xmm4
+    movdqa      xmm6, xmm2
+    pmaddwd     xmm4, [rel PW_F130_F054]   ; xmm4=data2L
+    pmaddwd     xmm2, [rel PW_F130_F054]   ; xmm2=data2H
+    pmaddwd     xmm1, [rel PW_F054_MF130]  ; xmm1=data6L
+    pmaddwd     xmm6, [rel PW_F054_MF130]  ; xmm6=data6H
+
+    paddd       xmm4, [rel PD_DESCALE_P2]
+    paddd       xmm2, [rel PD_DESCALE_P2]
+    psrad       xmm4, DESCALE_P2
+    psrad       xmm2, DESCALE_P2
+    paddd       xmm1, [rel PD_DESCALE_P2]
+    paddd       xmm6, [rel PD_DESCALE_P2]
+    psrad       xmm1, DESCALE_P2
+    psrad       xmm6, DESCALE_P2
+
+    packssdw    xmm4, xmm2              ; xmm4=data2
+    packssdw    xmm1, xmm6              ; xmm1=data6
+
+    movdqa      XMMWORD [XMMBLOCK(2,0,rdx,SIZEOF_DCTELEM)], xmm4
+    movdqa      XMMWORD [XMMBLOCK(6,0,rdx,SIZEOF_DCTELEM)], xmm1
+
+    ; -- Odd part
+
+    movdqa      xmm7, XMMWORD [wk(0)]   ; xmm7=tmp6
+    movdqa      xmm5, XMMWORD [wk(1)]   ; xmm5=tmp7
+
+    movdqa      xmm2, xmm0              ; xmm0=tmp4
+    movdqa      xmm6, xmm3              ; xmm3=tmp5
+    paddw       xmm2, xmm7              ; xmm2=z3
+    paddw       xmm6, xmm5              ; xmm6=z4
+
+    ; (Original)
+    ; z5 = (z3 + z4) * 1.175875602;
+    ; z3 = z3 * -1.961570560;  z4 = z4 * -0.390180644;
+    ; z3 += z5;  z4 += z5;
+    ;
+    ; (This implementation)
+    ; z3 = z3 * (1.175875602 - 1.961570560) + z4 * 1.175875602;
+    ; z4 = z3 * 1.175875602 + z4 * (1.175875602 - 0.390180644);
+
+    movdqa      xmm4, xmm2
+    movdqa      xmm1, xmm2
+    punpcklwd   xmm4, xmm6
+    punpckhwd   xmm1, xmm6
+    movdqa      xmm2, xmm4
+    movdqa      xmm6, xmm1
+    pmaddwd     xmm4, [rel PW_MF078_F117]  ; xmm4=z3L
+    pmaddwd     xmm1, [rel PW_MF078_F117]  ; xmm1=z3H
+    pmaddwd     xmm2, [rel PW_F117_F078]   ; xmm2=z4L
+    pmaddwd     xmm6, [rel PW_F117_F078]   ; xmm6=z4H
+
+    movdqa      XMMWORD [wk(0)], xmm4   ; wk(0)=z3L
+    movdqa      XMMWORD [wk(1)], xmm1   ; wk(1)=z3H
+
+    ; (Original)
+    ; z1 = tmp4 + tmp7;  z2 = tmp5 + tmp6;
+    ; tmp4 = tmp4 * 0.298631336;  tmp5 = tmp5 * 2.053119869;
+    ; tmp6 = tmp6 * 3.072711026;  tmp7 = tmp7 * 1.501321110;
+    ; z1 = z1 * -0.899976223;  z2 = z2 * -2.562915447;
+    ; data7 = tmp4 + z1 + z3;  data5 = tmp5 + z2 + z4;
+    ; data3 = tmp6 + z2 + z3;  data1 = tmp7 + z1 + z4;
+    ;
+    ; (This implementation)
+    ; tmp4 = tmp4 * (0.298631336 - 0.899976223) + tmp7 * -0.899976223;
+    ; tmp5 = tmp5 * (2.053119869 - 2.562915447) + tmp6 * -2.562915447;
+    ; tmp6 = tmp5 * -2.562915447 + tmp6 * (3.072711026 - 2.562915447);
+    ; tmp7 = tmp4 * -0.899976223 + tmp7 * (1.501321110 - 0.899976223);
+    ; data7 = tmp4 + z3;  data5 = tmp5 + z4;
+    ; data3 = tmp6 + z3;  data1 = tmp7 + z4;
+
+    movdqa      xmm4, xmm0
+    movdqa      xmm1, xmm0
+    punpcklwd   xmm4, xmm5
+    punpckhwd   xmm1, xmm5
+    movdqa      xmm0, xmm4
+    movdqa      xmm5, xmm1
+    pmaddwd     xmm4, [rel PW_MF060_MF089]  ; xmm4=tmp4L
+    pmaddwd     xmm1, [rel PW_MF060_MF089]  ; xmm1=tmp4H
+    pmaddwd     xmm0, [rel PW_MF089_F060]   ; xmm0=tmp7L
+    pmaddwd     xmm5, [rel PW_MF089_F060]   ; xmm5=tmp7H
+
+    paddd       xmm4,  XMMWORD [wk(0)]  ; xmm4=data7L
+    paddd       xmm1,  XMMWORD [wk(1)]  ; xmm1=data7H
+    paddd       xmm0, xmm2              ; xmm0=data1L
+    paddd       xmm5, xmm6              ; xmm5=data1H
+
+    paddd       xmm4, [rel PD_DESCALE_P2]
+    paddd       xmm1, [rel PD_DESCALE_P2]
+    psrad       xmm4, DESCALE_P2
+    psrad       xmm1, DESCALE_P2
+    paddd       xmm0, [rel PD_DESCALE_P2]
+    paddd       xmm5, [rel PD_DESCALE_P2]
+    psrad       xmm0, DESCALE_P2
+    psrad       xmm5, DESCALE_P2
+
+    packssdw    xmm4, xmm1              ; xmm4=data7
+    packssdw    xmm0, xmm5              ; xmm0=data1
+
+    movdqa      XMMWORD [XMMBLOCK(7,0,rdx,SIZEOF_DCTELEM)], xmm4
+    movdqa      XMMWORD [XMMBLOCK(1,0,rdx,SIZEOF_DCTELEM)], xmm0
+
+    movdqa      xmm1, xmm3
+    movdqa      xmm5, xmm3
+    punpcklwd   xmm1, xmm7
+    punpckhwd   xmm5, xmm7
+    movdqa      xmm3, xmm1
+    movdqa      xmm7, xmm5
+    pmaddwd     xmm1, [rel PW_MF050_MF256]  ; xmm1=tmp5L
+    pmaddwd     xmm5, [rel PW_MF050_MF256]  ; xmm5=tmp5H
+    pmaddwd     xmm3, [rel PW_MF256_F050]   ; xmm3=tmp6L
+    pmaddwd     xmm7, [rel PW_MF256_F050]   ; xmm7=tmp6H
+
+    paddd       xmm1, xmm2              ; xmm1=data5L
+    paddd       xmm5, xmm6              ; xmm5=data5H
+    paddd       xmm3, XMMWORD [wk(0)]   ; xmm3=data3L
+    paddd       xmm7, XMMWORD [wk(1)]   ; xmm7=data3H
+
+    paddd       xmm1, [rel PD_DESCALE_P2]
+    paddd       xmm5, [rel PD_DESCALE_P2]
+    psrad       xmm1, DESCALE_P2
+    psrad       xmm5, DESCALE_P2
+    paddd       xmm3, [rel PD_DESCALE_P2]
+    paddd       xmm7, [rel PD_DESCALE_P2]
+    psrad       xmm3, DESCALE_P2
+    psrad       xmm7, DESCALE_P2
+
+    packssdw    xmm1, xmm5              ; xmm1=data5
+    packssdw    xmm3, xmm7              ; xmm3=data3
+
+    movdqa      XMMWORD [XMMBLOCK(5,0,rdx,SIZEOF_DCTELEM)], xmm1
+    movdqa      XMMWORD [XMMBLOCK(3,0,rdx,SIZEOF_DCTELEM)], xmm3
+
+    uncollect_args 1
+    mov         rsp, rbp                ; rsp <- aligned rbp
+    pop         rsp                     ; rsp <- original rbp
+    pop         rbp
+    ret
+
+; For some reason, the OS X linker does not honor the request to align the
+; segment unless we do this.
+    align       32
diff --git a/3rdparty/libjpeg/src/simd/x86_64/jidctflt-sse2.asm b/3rdparty/libjpeg/src/simd/x86_64/jidctflt-sse2.asm
new file mode 100644
index 00000000..60bf9618
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/x86_64/jidctflt-sse2.asm
@@ -0,0 +1,482 @@
+;
+; jidctflt.asm - floating-point IDCT (64-bit SSE & SSE2)
+;
+; Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+; Copyright (C) 2009, 2016, D. R. Commander.
+; Copyright (C) 2018, Matthias Räncker.
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+;
+; This file should be assembled with NASM (Netwide Assembler),
+; can *not* be assembled with Microsoft's MASM or any compatible
+; assembler (including Borland's Turbo Assembler).
+; NASM is available from http://nasm.sourceforge.net/ or
+; http://sourceforge.net/project/showfiles.php?group_id=6208
+;
+; This file contains a floating-point implementation of the inverse DCT
+; (Discrete Cosine Transform). The following code is based directly on
+; the IJG's original jidctflt.c; see the jidctflt.c for more details.
+
+%include "jsimdext.inc"
+%include "jdct.inc"
+
+; --------------------------------------------------------------------------
+
+%macro unpcklps2 2  ; %1=(0 1 2 3) / %2=(4 5 6 7) => %1=(0 1 4 5)
+    shufps      %1, %2, 0x44
+%endmacro
+
+%macro unpckhps2 2  ; %1=(0 1 2 3) / %2=(4 5 6 7) => %1=(2 3 6 7)
+    shufps      %1, %2, 0xEE
+%endmacro
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_CONST
+
+    alignz      32
+    GLOBAL_DATA(jconst_idct_float_sse2)
+
+EXTN(jconst_idct_float_sse2):
+
+PD_1_414        times 4  dd  1.414213562373095048801689
+PD_1_847        times 4  dd  1.847759065022573512256366
+PD_1_082        times 4  dd  1.082392200292393968799446
+PD_M2_613       times 4  dd -2.613125929752753055713286
+PD_RNDINT_MAGIC times 4  dd  100663296.0  ; (float)(0x00C00000 << 3)
+PB_CENTERJSAMP  times 16 db  CENTERJSAMPLE
+
+    alignz      32
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_TEXT
+    BITS        64
+;
+; Perform dequantization and inverse DCT on one block of coefficients.
+;
+; GLOBAL(void)
+; jsimd_idct_float_sse2(void *dct_table, JCOEFPTR coef_block,
+;                       JSAMPARRAY output_buf, JDIMENSION output_col)
+;
+
+; r10 = void *dct_table
+; r11 = JCOEFPTR coef_block
+; r12 = JSAMPARRAY output_buf
+; r13d = JDIMENSION output_col
+
+%define original_rbp  rbp + 0
+%define wk(i)         rbp - (WK_NUM - (i)) * SIZEOF_XMMWORD
+                                        ; xmmword wk[WK_NUM]
+%define WK_NUM        2
+%define workspace     wk(0) - DCTSIZE2 * SIZEOF_FAST_FLOAT
+                                        ; FAST_FLOAT workspace[DCTSIZE2]
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_idct_float_sse2)
+
+EXTN(jsimd_idct_float_sse2):
+    push        rbp
+    mov         rax, rsp                     ; rax = original rbp
+    sub         rsp, byte 4
+    and         rsp, byte (-SIZEOF_XMMWORD)  ; align to 128 bits
+    mov         [rsp], rax
+    mov         rbp, rsp                     ; rbp = aligned rbp
+    lea         rsp, [workspace]
+    collect_args 4
+    push        rbx
+
+    ; ---- Pass 1: process columns from input, store into work array.
+
+    mov         rdx, r10                ; quantptr
+    mov         rsi, r11                ; inptr
+    lea         rdi, [workspace]        ; FAST_FLOAT *wsptr
+    mov         rcx, DCTSIZE/4          ; ctr
+.columnloop:
+%ifndef NO_ZERO_COLUMN_TEST_FLOAT_SSE
+    mov         eax, dword [DWBLOCK(1,0,rsi,SIZEOF_JCOEF)]
+    or          eax, dword [DWBLOCK(2,0,rsi,SIZEOF_JCOEF)]
+    jnz         near .columnDCT
+
+    movq        xmm1, XMM_MMWORD [MMBLOCK(1,0,rsi,SIZEOF_JCOEF)]
+    movq        xmm2, XMM_MMWORD [MMBLOCK(2,0,rsi,SIZEOF_JCOEF)]
+    movq        xmm3, XMM_MMWORD [MMBLOCK(3,0,rsi,SIZEOF_JCOEF)]
+    movq        xmm4, XMM_MMWORD [MMBLOCK(4,0,rsi,SIZEOF_JCOEF)]
+    movq        xmm5, XMM_MMWORD [MMBLOCK(5,0,rsi,SIZEOF_JCOEF)]
+    movq        xmm6, XMM_MMWORD [MMBLOCK(6,0,rsi,SIZEOF_JCOEF)]
+    movq        xmm7, XMM_MMWORD [MMBLOCK(7,0,rsi,SIZEOF_JCOEF)]
+    por         xmm1, xmm2
+    por         xmm3, xmm4
+    por         xmm5, xmm6
+    por         xmm1, xmm3
+    por         xmm5, xmm7
+    por         xmm1, xmm5
+    packsswb    xmm1, xmm1
+    movd        eax, xmm1
+    test        rax, rax
+    jnz         short .columnDCT
+
+    ; -- AC terms all zero
+
+    movq        xmm0, XMM_MMWORD [MMBLOCK(0,0,rsi,SIZEOF_JCOEF)]
+
+    punpcklwd   xmm0, xmm0                  ; xmm0=(00 00 01 01 02 02 03 03)
+    psrad       xmm0, (DWORD_BIT-WORD_BIT)  ; xmm0=in0=(00 01 02 03)
+    cvtdq2ps    xmm0, xmm0                  ; xmm0=in0=(00 01 02 03)
+
+    mulps       xmm0, XMMWORD [XMMBLOCK(0,0,rdx,SIZEOF_FLOAT_MULT_TYPE)]
+
+    movaps      xmm1, xmm0
+    movaps      xmm2, xmm0
+    movaps      xmm3, xmm0
+
+    shufps      xmm0, xmm0, 0x00        ; xmm0=(00 00 00 00)
+    shufps      xmm1, xmm1, 0x55        ; xmm1=(01 01 01 01)
+    shufps      xmm2, xmm2, 0xAA        ; xmm2=(02 02 02 02)
+    shufps      xmm3, xmm3, 0xFF        ; xmm3=(03 03 03 03)
+
+    movaps      XMMWORD [XMMBLOCK(0,0,rdi,SIZEOF_FAST_FLOAT)], xmm0
+    movaps      XMMWORD [XMMBLOCK(0,1,rdi,SIZEOF_FAST_FLOAT)], xmm0
+    movaps      XMMWORD [XMMBLOCK(1,0,rdi,SIZEOF_FAST_FLOAT)], xmm1
+    movaps      XMMWORD [XMMBLOCK(1,1,rdi,SIZEOF_FAST_FLOAT)], xmm1
+    movaps      XMMWORD [XMMBLOCK(2,0,rdi,SIZEOF_FAST_FLOAT)], xmm2
+    movaps      XMMWORD [XMMBLOCK(2,1,rdi,SIZEOF_FAST_FLOAT)], xmm2
+    movaps      XMMWORD [XMMBLOCK(3,0,rdi,SIZEOF_FAST_FLOAT)], xmm3
+    movaps      XMMWORD [XMMBLOCK(3,1,rdi,SIZEOF_FAST_FLOAT)], xmm3
+    jmp         near .nextcolumn
+%endif
+.columnDCT:
+
+    ; -- Even part
+
+    movq        xmm0, XMM_MMWORD [MMBLOCK(0,0,rsi,SIZEOF_JCOEF)]
+    movq        xmm1, XMM_MMWORD [MMBLOCK(2,0,rsi,SIZEOF_JCOEF)]
+    movq        xmm2, XMM_MMWORD [MMBLOCK(4,0,rsi,SIZEOF_JCOEF)]
+    movq        xmm3, XMM_MMWORD [MMBLOCK(6,0,rsi,SIZEOF_JCOEF)]
+
+    punpcklwd   xmm0, xmm0                  ; xmm0=(00 00 01 01 02 02 03 03)
+    punpcklwd   xmm1, xmm1                  ; xmm1=(20 20 21 21 22 22 23 23)
+    psrad       xmm0, (DWORD_BIT-WORD_BIT)  ; xmm0=in0=(00 01 02 03)
+    psrad       xmm1, (DWORD_BIT-WORD_BIT)  ; xmm1=in2=(20 21 22 23)
+    cvtdq2ps    xmm0, xmm0                  ; xmm0=in0=(00 01 02 03)
+    cvtdq2ps    xmm1, xmm1                  ; xmm1=in2=(20 21 22 23)
+
+    punpcklwd   xmm2, xmm2                  ; xmm2=(40 40 41 41 42 42 43 43)
+    punpcklwd   xmm3, xmm3                  ; xmm3=(60 60 61 61 62 62 63 63)
+    psrad       xmm2, (DWORD_BIT-WORD_BIT)  ; xmm2=in4=(40 41 42 43)
+    psrad       xmm3, (DWORD_BIT-WORD_BIT)  ; xmm3=in6=(60 61 62 63)
+    cvtdq2ps    xmm2, xmm2                  ; xmm2=in4=(40 41 42 43)
+    cvtdq2ps    xmm3, xmm3                  ; xmm3=in6=(60 61 62 63)
+
+    mulps       xmm0, XMMWORD [XMMBLOCK(0,0,rdx,SIZEOF_FLOAT_MULT_TYPE)]
+    mulps       xmm1, XMMWORD [XMMBLOCK(2,0,rdx,SIZEOF_FLOAT_MULT_TYPE)]
+    mulps       xmm2, XMMWORD [XMMBLOCK(4,0,rdx,SIZEOF_FLOAT_MULT_TYPE)]
+    mulps       xmm3, XMMWORD [XMMBLOCK(6,0,rdx,SIZEOF_FLOAT_MULT_TYPE)]
+
+    movaps      xmm4, xmm0
+    movaps      xmm5, xmm1
+    subps       xmm0, xmm2              ; xmm0=tmp11
+    subps       xmm1, xmm3
+    addps       xmm4, xmm2              ; xmm4=tmp10
+    addps       xmm5, xmm3              ; xmm5=tmp13
+
+    mulps       xmm1, [rel PD_1_414]
+    subps       xmm1, xmm5              ; xmm1=tmp12
+
+    movaps      xmm6, xmm4
+    movaps      xmm7, xmm0
+    subps       xmm4, xmm5              ; xmm4=tmp3
+    subps       xmm0, xmm1              ; xmm0=tmp2
+    addps       xmm6, xmm5              ; xmm6=tmp0
+    addps       xmm7, xmm1              ; xmm7=tmp1
+
+    movaps      XMMWORD [wk(1)], xmm4   ; tmp3
+    movaps      XMMWORD [wk(0)], xmm0   ; tmp2
+
+    ; -- Odd part
+
+    movq        xmm2, XMM_MMWORD [MMBLOCK(1,0,rsi,SIZEOF_JCOEF)]
+    movq        xmm3, XMM_MMWORD [MMBLOCK(3,0,rsi,SIZEOF_JCOEF)]
+    movq        xmm5, XMM_MMWORD [MMBLOCK(5,0,rsi,SIZEOF_JCOEF)]
+    movq        xmm1, XMM_MMWORD [MMBLOCK(7,0,rsi,SIZEOF_JCOEF)]
+
+    punpcklwd   xmm2, xmm2                  ; xmm2=(10 10 11 11 12 12 13 13)
+    punpcklwd   xmm3, xmm3                  ; xmm3=(30 30 31 31 32 32 33 33)
+    psrad       xmm2, (DWORD_BIT-WORD_BIT)  ; xmm2=in1=(10 11 12 13)
+    psrad       xmm3, (DWORD_BIT-WORD_BIT)  ; xmm3=in3=(30 31 32 33)
+    cvtdq2ps    xmm2, xmm2                  ; xmm2=in1=(10 11 12 13)
+    cvtdq2ps    xmm3, xmm3                  ; xmm3=in3=(30 31 32 33)
+
+    punpcklwd   xmm5, xmm5                  ; xmm5=(50 50 51 51 52 52 53 53)
+    punpcklwd   xmm1, xmm1                  ; xmm1=(70 70 71 71 72 72 73 73)
+    psrad       xmm5, (DWORD_BIT-WORD_BIT)  ; xmm5=in5=(50 51 52 53)
+    psrad       xmm1, (DWORD_BIT-WORD_BIT)  ; xmm1=in7=(70 71 72 73)
+    cvtdq2ps    xmm5, xmm5                  ; xmm5=in5=(50 51 52 53)
+    cvtdq2ps    xmm1, xmm1                  ; xmm1=in7=(70 71 72 73)
+
+    mulps       xmm2, XMMWORD [XMMBLOCK(1,0,rdx,SIZEOF_FLOAT_MULT_TYPE)]
+    mulps       xmm3, XMMWORD [XMMBLOCK(3,0,rdx,SIZEOF_FLOAT_MULT_TYPE)]
+    mulps       xmm5, XMMWORD [XMMBLOCK(5,0,rdx,SIZEOF_FLOAT_MULT_TYPE)]
+    mulps       xmm1, XMMWORD [XMMBLOCK(7,0,rdx,SIZEOF_FLOAT_MULT_TYPE)]
+
+    movaps      xmm4, xmm2
+    movaps      xmm0, xmm5
+    addps       xmm2, xmm1              ; xmm2=z11
+    addps       xmm5, xmm3              ; xmm5=z13
+    subps       xmm4, xmm1              ; xmm4=z12
+    subps       xmm0, xmm3              ; xmm0=z10
+
+    movaps      xmm1, xmm2
+    subps       xmm2, xmm5
+    addps       xmm1, xmm5              ; xmm1=tmp7
+
+    mulps       xmm2, [rel PD_1_414]    ; xmm2=tmp11
+
+    movaps      xmm3, xmm0
+    addps       xmm0, xmm4
+    mulps       xmm0, [rel PD_1_847]    ; xmm0=z5
+    mulps       xmm3, [rel PD_M2_613]   ; xmm3=(z10 * -2.613125930)
+    mulps       xmm4, [rel PD_1_082]    ; xmm4=(z12 * 1.082392200)
+    addps       xmm3, xmm0              ; xmm3=tmp12
+    subps       xmm4, xmm0              ; xmm4=tmp10
+
+    ; -- Final output stage
+
+    subps       xmm3, xmm1              ; xmm3=tmp6
+    movaps      xmm5, xmm6
+    movaps      xmm0, xmm7
+    addps       xmm6, xmm1              ; xmm6=data0=(00 01 02 03)
+    addps       xmm7, xmm3              ; xmm7=data1=(10 11 12 13)
+    subps       xmm5, xmm1              ; xmm5=data7=(70 71 72 73)
+    subps       xmm0, xmm3              ; xmm0=data6=(60 61 62 63)
+    subps       xmm2, xmm3              ; xmm2=tmp5
+
+    movaps      xmm1, xmm6              ; transpose coefficients(phase 1)
+    unpcklps    xmm6, xmm7              ; xmm6=(00 10 01 11)
+    unpckhps    xmm1, xmm7              ; xmm1=(02 12 03 13)
+    movaps      xmm3, xmm0              ; transpose coefficients(phase 1)
+    unpcklps    xmm0, xmm5              ; xmm0=(60 70 61 71)
+    unpckhps    xmm3, xmm5              ; xmm3=(62 72 63 73)
+
+    movaps      xmm7, XMMWORD [wk(0)]   ; xmm7=tmp2
+    movaps      xmm5, XMMWORD [wk(1)]   ; xmm5=tmp3
+
+    movaps      XMMWORD [wk(0)], xmm0   ; wk(0)=(60 70 61 71)
+    movaps      XMMWORD [wk(1)], xmm3   ; wk(1)=(62 72 63 73)
+
+    addps       xmm4, xmm2              ; xmm4=tmp4
+    movaps      xmm0, xmm7
+    movaps      xmm3, xmm5
+    addps       xmm7, xmm2              ; xmm7=data2=(20 21 22 23)
+    addps       xmm5, xmm4              ; xmm5=data4=(40 41 42 43)
+    subps       xmm0, xmm2              ; xmm0=data5=(50 51 52 53)
+    subps       xmm3, xmm4              ; xmm3=data3=(30 31 32 33)
+
+    movaps      xmm2, xmm7              ; transpose coefficients(phase 1)
+    unpcklps    xmm7, xmm3              ; xmm7=(20 30 21 31)
+    unpckhps    xmm2, xmm3              ; xmm2=(22 32 23 33)
+    movaps      xmm4, xmm5              ; transpose coefficients(phase 1)
+    unpcklps    xmm5, xmm0              ; xmm5=(40 50 41 51)
+    unpckhps    xmm4, xmm0              ; xmm4=(42 52 43 53)
+
+    movaps      xmm3, xmm6              ; transpose coefficients(phase 2)
+    unpcklps2   xmm6, xmm7              ; xmm6=(00 10 20 30)
+    unpckhps2   xmm3, xmm7              ; xmm3=(01 11 21 31)
+    movaps      xmm0, xmm1              ; transpose coefficients(phase 2)
+    unpcklps2   xmm1, xmm2              ; xmm1=(02 12 22 32)
+    unpckhps2   xmm0, xmm2              ; xmm0=(03 13 23 33)
+
+    movaps      xmm7, XMMWORD [wk(0)]   ; xmm7=(60 70 61 71)
+    movaps      xmm2, XMMWORD [wk(1)]   ; xmm2=(62 72 63 73)
+
+    movaps      XMMWORD [XMMBLOCK(0,0,rdi,SIZEOF_FAST_FLOAT)], xmm6
+    movaps      XMMWORD [XMMBLOCK(1,0,rdi,SIZEOF_FAST_FLOAT)], xmm3
+    movaps      XMMWORD [XMMBLOCK(2,0,rdi,SIZEOF_FAST_FLOAT)], xmm1
+    movaps      XMMWORD [XMMBLOCK(3,0,rdi,SIZEOF_FAST_FLOAT)], xmm0
+
+    movaps      xmm6, xmm5              ; transpose coefficients(phase 2)
+    unpcklps2   xmm5, xmm7              ; xmm5=(40 50 60 70)
+    unpckhps2   xmm6, xmm7              ; xmm6=(41 51 61 71)
+    movaps      xmm3, xmm4              ; transpose coefficients(phase 2)
+    unpcklps2   xmm4, xmm2              ; xmm4=(42 52 62 72)
+    unpckhps2   xmm3, xmm2              ; xmm3=(43 53 63 73)
+
+    movaps      XMMWORD [XMMBLOCK(0,1,rdi,SIZEOF_FAST_FLOAT)], xmm5
+    movaps      XMMWORD [XMMBLOCK(1,1,rdi,SIZEOF_FAST_FLOAT)], xmm6
+    movaps      XMMWORD [XMMBLOCK(2,1,rdi,SIZEOF_FAST_FLOAT)], xmm4
+    movaps      XMMWORD [XMMBLOCK(3,1,rdi,SIZEOF_FAST_FLOAT)], xmm3
+
+.nextcolumn:
+    add         rsi, byte 4*SIZEOF_JCOEF               ; coef_block
+    add         rdx, byte 4*SIZEOF_FLOAT_MULT_TYPE     ; quantptr
+    add         rdi,      4*DCTSIZE*SIZEOF_FAST_FLOAT  ; wsptr
+    dec         rcx                                    ; ctr
+    jnz         near .columnloop
+
+    ; -- Prefetch the next coefficient block
+
+    prefetchnta [rsi + (DCTSIZE2-8)*SIZEOF_JCOEF + 0*32]
+    prefetchnta [rsi + (DCTSIZE2-8)*SIZEOF_JCOEF + 1*32]
+    prefetchnta [rsi + (DCTSIZE2-8)*SIZEOF_JCOEF + 2*32]
+    prefetchnta [rsi + (DCTSIZE2-8)*SIZEOF_JCOEF + 3*32]
+
+    ; ---- Pass 2: process rows from work array, store into output array.
+
+    mov         rax, [original_rbp]
+    lea         rsi, [workspace]        ; FAST_FLOAT *wsptr
+    mov         rdi, r12                ; (JSAMPROW *)
+    mov         eax, r13d
+    mov         rcx, DCTSIZE/4          ; ctr
+.rowloop:
+
+    ; -- Even part
+
+    movaps      xmm0, XMMWORD [XMMBLOCK(0,0,rsi,SIZEOF_FAST_FLOAT)]
+    movaps      xmm1, XMMWORD [XMMBLOCK(2,0,rsi,SIZEOF_FAST_FLOAT)]
+    movaps      xmm2, XMMWORD [XMMBLOCK(4,0,rsi,SIZEOF_FAST_FLOAT)]
+    movaps      xmm3, XMMWORD [XMMBLOCK(6,0,rsi,SIZEOF_FAST_FLOAT)]
+
+    movaps      xmm4, xmm0
+    movaps      xmm5, xmm1
+    subps       xmm0, xmm2              ; xmm0=tmp11
+    subps       xmm1, xmm3
+    addps       xmm4, xmm2              ; xmm4=tmp10
+    addps       xmm5, xmm3              ; xmm5=tmp13
+
+    mulps       xmm1, [rel PD_1_414]
+    subps       xmm1, xmm5              ; xmm1=tmp12
+
+    movaps      xmm6, xmm4
+    movaps      xmm7, xmm0
+    subps       xmm4, xmm5              ; xmm4=tmp3
+    subps       xmm0, xmm1              ; xmm0=tmp2
+    addps       xmm6, xmm5              ; xmm6=tmp0
+    addps       xmm7, xmm1              ; xmm7=tmp1
+
+    movaps      XMMWORD [wk(1)], xmm4   ; tmp3
+    movaps      XMMWORD [wk(0)], xmm0   ; tmp2
+
+    ; -- Odd part
+
+    movaps      xmm2, XMMWORD [XMMBLOCK(1,0,rsi,SIZEOF_FAST_FLOAT)]
+    movaps      xmm3, XMMWORD [XMMBLOCK(3,0,rsi,SIZEOF_FAST_FLOAT)]
+    movaps      xmm5, XMMWORD [XMMBLOCK(5,0,rsi,SIZEOF_FAST_FLOAT)]
+    movaps      xmm1, XMMWORD [XMMBLOCK(7,0,rsi,SIZEOF_FAST_FLOAT)]
+
+    movaps      xmm4, xmm2
+    movaps      xmm0, xmm5
+    addps       xmm2, xmm1              ; xmm2=z11
+    addps       xmm5, xmm3              ; xmm5=z13
+    subps       xmm4, xmm1              ; xmm4=z12
+    subps       xmm0, xmm3              ; xmm0=z10
+
+    movaps      xmm1, xmm2
+    subps       xmm2, xmm5
+    addps       xmm1, xmm5              ; xmm1=tmp7
+
+    mulps       xmm2, [rel PD_1_414]    ; xmm2=tmp11
+
+    movaps      xmm3, xmm0
+    addps       xmm0, xmm4
+    mulps       xmm0, [rel PD_1_847]    ; xmm0=z5
+    mulps       xmm3, [rel PD_M2_613]   ; xmm3=(z10 * -2.613125930)
+    mulps       xmm4, [rel PD_1_082]    ; xmm4=(z12 * 1.082392200)
+    addps       xmm3, xmm0              ; xmm3=tmp12
+    subps       xmm4, xmm0              ; xmm4=tmp10
+
+    ; -- Final output stage
+
+    subps       xmm3, xmm1              ; xmm3=tmp6
+    movaps      xmm5, xmm6
+    movaps      xmm0, xmm7
+    addps       xmm6, xmm1              ; xmm6=data0=(00 10 20 30)
+    addps       xmm7, xmm3              ; xmm7=data1=(01 11 21 31)
+    subps       xmm5, xmm1              ; xmm5=data7=(07 17 27 37)
+    subps       xmm0, xmm3              ; xmm0=data6=(06 16 26 36)
+    subps       xmm2, xmm3              ; xmm2=tmp5
+
+    movaps      xmm1, [rel PD_RNDINT_MAGIC]  ; xmm1=[rel PD_RNDINT_MAGIC]
+    pcmpeqd     xmm3, xmm3
+    psrld       xmm3, WORD_BIT          ; xmm3={0xFFFF 0x0000 0xFFFF 0x0000 ..}
+
+    addps       xmm6, xmm1              ; xmm6=roundint(data0/8)=(00 ** 10 ** 20 ** 30 **)
+    addps       xmm7, xmm1              ; xmm7=roundint(data1/8)=(01 ** 11 ** 21 ** 31 **)
+    addps       xmm0, xmm1              ; xmm0=roundint(data6/8)=(06 ** 16 ** 26 ** 36 **)
+    addps       xmm5, xmm1              ; xmm5=roundint(data7/8)=(07 ** 17 ** 27 ** 37 **)
+
+    pand        xmm6, xmm3              ; xmm6=(00 -- 10 -- 20 -- 30 --)
+    pslld       xmm7, WORD_BIT          ; xmm7=(-- 01 -- 11 -- 21 -- 31)
+    pand        xmm0, xmm3              ; xmm0=(06 -- 16 -- 26 -- 36 --)
+    pslld       xmm5, WORD_BIT          ; xmm5=(-- 07 -- 17 -- 27 -- 37)
+    por         xmm6, xmm7              ; xmm6=(00 01 10 11 20 21 30 31)
+    por         xmm0, xmm5              ; xmm0=(06 07 16 17 26 27 36 37)
+
+    movaps      xmm1,  XMMWORD [wk(0)]  ; xmm1=tmp2
+    movaps      xmm3,  XMMWORD [wk(1)]  ; xmm3=tmp3
+
+    addps       xmm4, xmm2              ; xmm4=tmp4
+    movaps      xmm7, xmm1
+    movaps      xmm5, xmm3
+    addps       xmm1, xmm2              ; xmm1=data2=(02 12 22 32)
+    addps       xmm3, xmm4              ; xmm3=data4=(04 14 24 34)
+    subps       xmm7, xmm2              ; xmm7=data5=(05 15 25 35)
+    subps       xmm5, xmm4              ; xmm5=data3=(03 13 23 33)
+
+    movaps      xmm2, [rel PD_RNDINT_MAGIC]  ; xmm2=[rel PD_RNDINT_MAGIC]
+    pcmpeqd     xmm4, xmm4
+    psrld       xmm4, WORD_BIT          ; xmm4={0xFFFF 0x0000 0xFFFF 0x0000 ..}
+
+    addps       xmm3, xmm2              ; xmm3=roundint(data4/8)=(04 ** 14 ** 24 ** 34 **)
+    addps       xmm7, xmm2              ; xmm7=roundint(data5/8)=(05 ** 15 ** 25 ** 35 **)
+    addps       xmm1, xmm2              ; xmm1=roundint(data2/8)=(02 ** 12 ** 22 ** 32 **)
+    addps       xmm5, xmm2              ; xmm5=roundint(data3/8)=(03 ** 13 ** 23 ** 33 **)
+
+    pand        xmm3, xmm4              ; xmm3=(04 -- 14 -- 24 -- 34 --)
+    pslld       xmm7, WORD_BIT          ; xmm7=(-- 05 -- 15 -- 25 -- 35)
+    pand        xmm1, xmm4              ; xmm1=(02 -- 12 -- 22 -- 32 --)
+    pslld       xmm5, WORD_BIT          ; xmm5=(-- 03 -- 13 -- 23 -- 33)
+    por         xmm3, xmm7              ; xmm3=(04 05 14 15 24 25 34 35)
+    por         xmm1, xmm5              ; xmm1=(02 03 12 13 22 23 32 33)
+
+    movdqa      xmm2, [rel PB_CENTERJSAMP]  ; xmm2=[rel PB_CENTERJSAMP]
+
+    packsswb    xmm6, xmm3        ; xmm6=(00 01 10 11 20 21 30 31 04 05 14 15 24 25 34 35)
+    packsswb    xmm1, xmm0        ; xmm1=(02 03 12 13 22 23 32 33 06 07 16 17 26 27 36 37)
+    paddb       xmm6, xmm2
+    paddb       xmm1, xmm2
+
+    movdqa      xmm4, xmm6        ; transpose coefficients(phase 2)
+    punpcklwd   xmm6, xmm1        ; xmm6=(00 01 02 03 10 11 12 13 20 21 22 23 30 31 32 33)
+    punpckhwd   xmm4, xmm1        ; xmm4=(04 05 06 07 14 15 16 17 24 25 26 27 34 35 36 37)
+
+    movdqa      xmm7, xmm6        ; transpose coefficients(phase 3)
+    punpckldq   xmm6, xmm4        ; xmm6=(00 01 02 03 04 05 06 07 10 11 12 13 14 15 16 17)
+    punpckhdq   xmm7, xmm4        ; xmm7=(20 21 22 23 24 25 26 27 30 31 32 33 34 35 36 37)
+
+    pshufd      xmm5, xmm6, 0x4E  ; xmm5=(10 11 12 13 14 15 16 17 00 01 02 03 04 05 06 07)
+    pshufd      xmm3, xmm7, 0x4E  ; xmm3=(30 31 32 33 34 35 36 37 20 21 22 23 24 25 26 27)
+
+    mov         rdxp, JSAMPROW [rdi+0*SIZEOF_JSAMPROW]
+    mov         rbxp, JSAMPROW [rdi+2*SIZEOF_JSAMPROW]
+    movq        XMM_MMWORD [rdx+rax*SIZEOF_JSAMPLE], xmm6
+    movq        XMM_MMWORD [rbx+rax*SIZEOF_JSAMPLE], xmm7
+    mov         rdxp, JSAMPROW [rdi+1*SIZEOF_JSAMPROW]
+    mov         rbxp, JSAMPROW [rdi+3*SIZEOF_JSAMPROW]
+    movq        XMM_MMWORD [rdx+rax*SIZEOF_JSAMPLE], xmm5
+    movq        XMM_MMWORD [rbx+rax*SIZEOF_JSAMPLE], xmm3
+
+    add         rsi, byte 4*SIZEOF_FAST_FLOAT  ; wsptr
+    add         rdi, byte 4*SIZEOF_JSAMPROW
+    dec         rcx                            ; ctr
+    jnz         near .rowloop
+
+    pop         rbx
+    uncollect_args 4
+    mov         rsp, rbp                ; rsp <- aligned rbp
+    pop         rsp                     ; rsp <- original rbp
+    pop         rbp
+    ret
+
+; For some reason, the OS X linker does not honor the request to align the
+; segment unless we do this.
+    align       32
diff --git a/3rdparty/libjpeg/src/simd/x86_64/jidctfst-sse2.asm b/3rdparty/libjpeg/src/simd/x86_64/jidctfst-sse2.asm
new file mode 100644
index 00000000..cb97fdfb
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/x86_64/jidctfst-sse2.asm
@@ -0,0 +1,491 @@
+;
+; jidctfst.asm - fast integer IDCT (64-bit SSE2)
+;
+; Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+; Copyright (C) 2009, 2016, D. R. Commander.
+; Copyright (C) 2018, Matthias Räncker.
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+;
+; This file should be assembled with NASM (Netwide Assembler),
+; can *not* be assembled with Microsoft's MASM or any compatible
+; assembler (including Borland's Turbo Assembler).
+; NASM is available from http://nasm.sourceforge.net/ or
+; http://sourceforge.net/project/showfiles.php?group_id=6208
+;
+; This file contains a fast, not so accurate integer implementation of
+; the inverse DCT (Discrete Cosine Transform). The following code is
+; based directly on the IJG's original jidctfst.c; see the jidctfst.c
+; for more details.
+
+%include "jsimdext.inc"
+%include "jdct.inc"
+
+; --------------------------------------------------------------------------
+
+%define CONST_BITS  8  ; 14 is also OK.
+%define PASS1_BITS  2
+
+%if IFAST_SCALE_BITS != PASS1_BITS
+%error "'IFAST_SCALE_BITS' must be equal to 'PASS1_BITS'."
+%endif
+
+%if CONST_BITS == 8
+F_1_082 equ 277              ; FIX(1.082392200)
+F_1_414 equ 362              ; FIX(1.414213562)
+F_1_847 equ 473              ; FIX(1.847759065)
+F_2_613 equ 669              ; FIX(2.613125930)
+F_1_613 equ (F_2_613 - 256)  ; FIX(2.613125930) - FIX(1)
+%else
+; NASM cannot do compile-time arithmetic on floating-point constants.
+%define DESCALE(x, n)  (((x) + (1 << ((n) - 1))) >> (n))
+F_1_082 equ DESCALE(1162209775, 30 - CONST_BITS)  ; FIX(1.082392200)
+F_1_414 equ DESCALE(1518500249, 30 - CONST_BITS)  ; FIX(1.414213562)
+F_1_847 equ DESCALE(1984016188, 30 - CONST_BITS)  ; FIX(1.847759065)
+F_2_613 equ DESCALE(2805822602, 30 - CONST_BITS)  ; FIX(2.613125930)
+F_1_613 equ (F_2_613 - (1 << CONST_BITS))         ; FIX(2.613125930) - FIX(1)
+%endif
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_CONST
+
+; PRE_MULTIPLY_SCALE_BITS <= 2 (to avoid overflow)
+; CONST_BITS + CONST_SHIFT + PRE_MULTIPLY_SCALE_BITS == 16 (for pmulhw)
+
+%define PRE_MULTIPLY_SCALE_BITS  2
+%define CONST_SHIFT              (16 - PRE_MULTIPLY_SCALE_BITS - CONST_BITS)
+
+    alignz      32
+    GLOBAL_DATA(jconst_idct_ifast_sse2)
+
+EXTN(jconst_idct_ifast_sse2):
+
+PW_F1414       times 8  dw  F_1_414 << CONST_SHIFT
+PW_F1847       times 8  dw  F_1_847 << CONST_SHIFT
+PW_MF1613      times 8  dw -F_1_613 << CONST_SHIFT
+PW_F1082       times 8  dw  F_1_082 << CONST_SHIFT
+PB_CENTERJSAMP times 16 db  CENTERJSAMPLE
+
+    alignz      32
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_TEXT
+    BITS        64
+;
+; Perform dequantization and inverse DCT on one block of coefficients.
+;
+; GLOBAL(void)
+; jsimd_idct_ifast_sse2(void *dct_table, JCOEFPTR coef_block,
+;                      JSAMPARRAY output_buf, JDIMENSION output_col)
+;
+
+; r10 = jpeg_component_info *compptr
+; r11 = JCOEFPTR coef_block
+; r12 = JSAMPARRAY output_buf
+; r13d = JDIMENSION output_col
+
+%define original_rbp  rbp + 0
+%define wk(i)         rbp - (WK_NUM - (i)) * SIZEOF_XMMWORD
+                                        ; xmmword wk[WK_NUM]
+%define WK_NUM        2
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_idct_ifast_sse2)
+
+EXTN(jsimd_idct_ifast_sse2):
+    push        rbp
+    mov         rax, rsp                     ; rax = original rbp
+    sub         rsp, byte 4
+    and         rsp, byte (-SIZEOF_XMMWORD)  ; align to 128 bits
+    mov         [rsp], rax
+    mov         rbp, rsp                     ; rbp = aligned rbp
+    lea         rsp, [wk(0)]
+    collect_args 4
+
+    ; ---- Pass 1: process columns from input.
+
+    mov         rdx, r10                ; quantptr
+    mov         rsi, r11                ; inptr
+
+%ifndef NO_ZERO_COLUMN_TEST_IFAST_SSE2
+    mov         eax, dword [DWBLOCK(1,0,rsi,SIZEOF_JCOEF)]
+    or          eax, dword [DWBLOCK(2,0,rsi,SIZEOF_JCOEF)]
+    jnz         near .columnDCT
+
+    movdqa      xmm0, XMMWORD [XMMBLOCK(1,0,rsi,SIZEOF_JCOEF)]
+    movdqa      xmm1, XMMWORD [XMMBLOCK(2,0,rsi,SIZEOF_JCOEF)]
+    por         xmm0, XMMWORD [XMMBLOCK(3,0,rsi,SIZEOF_JCOEF)]
+    por         xmm1, XMMWORD [XMMBLOCK(4,0,rsi,SIZEOF_JCOEF)]
+    por         xmm0, XMMWORD [XMMBLOCK(5,0,rsi,SIZEOF_JCOEF)]
+    por         xmm1, XMMWORD [XMMBLOCK(6,0,rsi,SIZEOF_JCOEF)]
+    por         xmm0, XMMWORD [XMMBLOCK(7,0,rsi,SIZEOF_JCOEF)]
+    por         xmm1, xmm0
+    packsswb    xmm1, xmm1
+    packsswb    xmm1, xmm1
+    movd        eax, xmm1
+    test        rax, rax
+    jnz         short .columnDCT
+
+    ; -- AC terms all zero
+
+    movdqa      xmm0, XMMWORD [XMMBLOCK(0,0,rsi,SIZEOF_JCOEF)]
+    pmullw      xmm0, XMMWORD [XMMBLOCK(0,0,rdx,SIZEOF_ISLOW_MULT_TYPE)]
+
+    movdqa      xmm7, xmm0              ; xmm0=in0=(00 01 02 03 04 05 06 07)
+    punpcklwd   xmm0, xmm0              ; xmm0=(00 00 01 01 02 02 03 03)
+    punpckhwd   xmm7, xmm7              ; xmm7=(04 04 05 05 06 06 07 07)
+
+    pshufd      xmm6, xmm0, 0x00        ; xmm6=col0=(00 00 00 00 00 00 00 00)
+    pshufd      xmm2, xmm0, 0x55        ; xmm2=col1=(01 01 01 01 01 01 01 01)
+    pshufd      xmm5, xmm0, 0xAA        ; xmm5=col2=(02 02 02 02 02 02 02 02)
+    pshufd      xmm0, xmm0, 0xFF        ; xmm0=col3=(03 03 03 03 03 03 03 03)
+    pshufd      xmm1, xmm7, 0x00        ; xmm1=col4=(04 04 04 04 04 04 04 04)
+    pshufd      xmm4, xmm7, 0x55        ; xmm4=col5=(05 05 05 05 05 05 05 05)
+    pshufd      xmm3, xmm7, 0xAA        ; xmm3=col6=(06 06 06 06 06 06 06 06)
+    pshufd      xmm7, xmm7, 0xFF        ; xmm7=col7=(07 07 07 07 07 07 07 07)
+
+    movdqa      XMMWORD [wk(0)], xmm2   ; wk(0)=col1
+    movdqa      XMMWORD [wk(1)], xmm0   ; wk(1)=col3
+    jmp         near .column_end
+%endif
+.columnDCT:
+
+    ; -- Even part
+
+    movdqa      xmm0, XMMWORD [XMMBLOCK(0,0,rsi,SIZEOF_JCOEF)]
+    movdqa      xmm1, XMMWORD [XMMBLOCK(2,0,rsi,SIZEOF_JCOEF)]
+    pmullw      xmm0, XMMWORD [XMMBLOCK(0,0,rdx,SIZEOF_IFAST_MULT_TYPE)]
+    pmullw      xmm1, XMMWORD [XMMBLOCK(2,0,rdx,SIZEOF_IFAST_MULT_TYPE)]
+    movdqa      xmm2, XMMWORD [XMMBLOCK(4,0,rsi,SIZEOF_JCOEF)]
+    movdqa      xmm3, XMMWORD [XMMBLOCK(6,0,rsi,SIZEOF_JCOEF)]
+    pmullw      xmm2, XMMWORD [XMMBLOCK(4,0,rdx,SIZEOF_IFAST_MULT_TYPE)]
+    pmullw      xmm3, XMMWORD [XMMBLOCK(6,0,rdx,SIZEOF_IFAST_MULT_TYPE)]
+
+    movdqa      xmm4, xmm0
+    movdqa      xmm5, xmm1
+    psubw       xmm0, xmm2              ; xmm0=tmp11
+    psubw       xmm1, xmm3
+    paddw       xmm4, xmm2              ; xmm4=tmp10
+    paddw       xmm5, xmm3              ; xmm5=tmp13
+
+    psllw       xmm1, PRE_MULTIPLY_SCALE_BITS
+    pmulhw      xmm1, [rel PW_F1414]
+    psubw       xmm1, xmm5              ; xmm1=tmp12
+
+    movdqa      xmm6, xmm4
+    movdqa      xmm7, xmm0
+    psubw       xmm4, xmm5              ; xmm4=tmp3
+    psubw       xmm0, xmm1              ; xmm0=tmp2
+    paddw       xmm6, xmm5              ; xmm6=tmp0
+    paddw       xmm7, xmm1              ; xmm7=tmp1
+
+    movdqa      XMMWORD [wk(1)], xmm4   ; wk(1)=tmp3
+    movdqa      XMMWORD [wk(0)], xmm0   ; wk(0)=tmp2
+
+    ; -- Odd part
+
+    movdqa      xmm2, XMMWORD [XMMBLOCK(1,0,rsi,SIZEOF_JCOEF)]
+    movdqa      xmm3, XMMWORD [XMMBLOCK(3,0,rsi,SIZEOF_JCOEF)]
+    pmullw      xmm2, XMMWORD [XMMBLOCK(1,0,rdx,SIZEOF_IFAST_MULT_TYPE)]
+    pmullw      xmm3, XMMWORD [XMMBLOCK(3,0,rdx,SIZEOF_IFAST_MULT_TYPE)]
+    movdqa      xmm5, XMMWORD [XMMBLOCK(5,0,rsi,SIZEOF_JCOEF)]
+    movdqa      xmm1, XMMWORD [XMMBLOCK(7,0,rsi,SIZEOF_JCOEF)]
+    pmullw      xmm5, XMMWORD [XMMBLOCK(5,0,rdx,SIZEOF_IFAST_MULT_TYPE)]
+    pmullw      xmm1, XMMWORD [XMMBLOCK(7,0,rdx,SIZEOF_IFAST_MULT_TYPE)]
+
+    movdqa      xmm4, xmm2
+    movdqa      xmm0, xmm5
+    psubw       xmm2, xmm1              ; xmm2=z12
+    psubw       xmm5, xmm3              ; xmm5=z10
+    paddw       xmm4, xmm1              ; xmm4=z11
+    paddw       xmm0, xmm3              ; xmm0=z13
+
+    movdqa      xmm1, xmm5              ; xmm1=z10(unscaled)
+    psllw       xmm2, PRE_MULTIPLY_SCALE_BITS
+    psllw       xmm5, PRE_MULTIPLY_SCALE_BITS
+
+    movdqa      xmm3, xmm4
+    psubw       xmm4, xmm0
+    paddw       xmm3, xmm0              ; xmm3=tmp7
+
+    psllw       xmm4, PRE_MULTIPLY_SCALE_BITS
+    pmulhw      xmm4, [rel PW_F1414]    ; xmm4=tmp11
+
+    ; To avoid overflow...
+    ;
+    ; (Original)
+    ; tmp12 = -2.613125930 * z10 + z5;
+    ;
+    ; (This implementation)
+    ; tmp12 = (-1.613125930 - 1) * z10 + z5;
+    ;       = -1.613125930 * z10 - z10 + z5;
+
+    movdqa      xmm0, xmm5
+    paddw       xmm5, xmm2
+    pmulhw      xmm5, [rel PW_F1847]    ; xmm5=z5
+    pmulhw      xmm0, [rel PW_MF1613]
+    pmulhw      xmm2, [rel PW_F1082]
+    psubw       xmm0, xmm1
+    psubw       xmm2, xmm5              ; xmm2=tmp10
+    paddw       xmm0, xmm5              ; xmm0=tmp12
+
+    ; -- Final output stage
+
+    psubw       xmm0, xmm3              ; xmm0=tmp6
+    movdqa      xmm1, xmm6
+    movdqa      xmm5, xmm7
+    paddw       xmm6, xmm3              ; xmm6=data0=(00 01 02 03 04 05 06 07)
+    paddw       xmm7, xmm0              ; xmm7=data1=(10 11 12 13 14 15 16 17)
+    psubw       xmm1, xmm3              ; xmm1=data7=(70 71 72 73 74 75 76 77)
+    psubw       xmm5, xmm0              ; xmm5=data6=(60 61 62 63 64 65 66 67)
+    psubw       xmm4, xmm0              ; xmm4=tmp5
+
+    movdqa      xmm3, xmm6              ; transpose coefficients(phase 1)
+    punpcklwd   xmm6, xmm7              ; xmm6=(00 10 01 11 02 12 03 13)
+    punpckhwd   xmm3, xmm7              ; xmm3=(04 14 05 15 06 16 07 17)
+    movdqa      xmm0, xmm5              ; transpose coefficients(phase 1)
+    punpcklwd   xmm5, xmm1              ; xmm5=(60 70 61 71 62 72 63 73)
+    punpckhwd   xmm0, xmm1              ; xmm0=(64 74 65 75 66 76 67 77)
+
+    movdqa      xmm7, XMMWORD [wk(0)]   ; xmm7=tmp2
+    movdqa      xmm1, XMMWORD [wk(1)]   ; xmm1=tmp3
+
+    movdqa      XMMWORD [wk(0)], xmm5   ; wk(0)=(60 70 61 71 62 72 63 73)
+    movdqa      XMMWORD [wk(1)], xmm0   ; wk(1)=(64 74 65 75 66 76 67 77)
+
+    paddw       xmm2, xmm4              ; xmm2=tmp4
+    movdqa      xmm5, xmm7
+    movdqa      xmm0, xmm1
+    paddw       xmm7, xmm4              ; xmm7=data2=(20 21 22 23 24 25 26 27)
+    paddw       xmm1, xmm2              ; xmm1=data4=(40 41 42 43 44 45 46 47)
+    psubw       xmm5, xmm4              ; xmm5=data5=(50 51 52 53 54 55 56 57)
+    psubw       xmm0, xmm2              ; xmm0=data3=(30 31 32 33 34 35 36 37)
+
+    movdqa      xmm4, xmm7              ; transpose coefficients(phase 1)
+    punpcklwd   xmm7, xmm0              ; xmm7=(20 30 21 31 22 32 23 33)
+    punpckhwd   xmm4, xmm0              ; xmm4=(24 34 25 35 26 36 27 37)
+    movdqa      xmm2, xmm1              ; transpose coefficients(phase 1)
+    punpcklwd   xmm1, xmm5              ; xmm1=(40 50 41 51 42 52 43 53)
+    punpckhwd   xmm2, xmm5              ; xmm2=(44 54 45 55 46 56 47 57)
+
+    movdqa      xmm0, xmm3              ; transpose coefficients(phase 2)
+    punpckldq   xmm3, xmm4              ; xmm3=(04 14 24 34 05 15 25 35)
+    punpckhdq   xmm0, xmm4              ; xmm0=(06 16 26 36 07 17 27 37)
+    movdqa      xmm5, xmm6              ; transpose coefficients(phase 2)
+    punpckldq   xmm6, xmm7              ; xmm6=(00 10 20 30 01 11 21 31)
+    punpckhdq   xmm5, xmm7              ; xmm5=(02 12 22 32 03 13 23 33)
+
+    movdqa      xmm4, XMMWORD [wk(0)]   ; xmm4=(60 70 61 71 62 72 63 73)
+    movdqa      xmm7, XMMWORD [wk(1)]   ; xmm7=(64 74 65 75 66 76 67 77)
+
+    movdqa      XMMWORD [wk(0)], xmm3   ; wk(0)=(04 14 24 34 05 15 25 35)
+    movdqa      XMMWORD [wk(1)], xmm0   ; wk(1)=(06 16 26 36 07 17 27 37)
+
+    movdqa      xmm3, xmm1              ; transpose coefficients(phase 2)
+    punpckldq   xmm1, xmm4              ; xmm1=(40 50 60 70 41 51 61 71)
+    punpckhdq   xmm3, xmm4              ; xmm3=(42 52 62 72 43 53 63 73)
+    movdqa      xmm0, xmm2              ; transpose coefficients(phase 2)
+    punpckldq   xmm2, xmm7              ; xmm2=(44 54 64 74 45 55 65 75)
+    punpckhdq   xmm0, xmm7              ; xmm0=(46 56 66 76 47 57 67 77)
+
+    movdqa      xmm4, xmm6              ; transpose coefficients(phase 3)
+    punpcklqdq  xmm6, xmm1              ; xmm6=col0=(00 10 20 30 40 50 60 70)
+    punpckhqdq  xmm4, xmm1              ; xmm4=col1=(01 11 21 31 41 51 61 71)
+    movdqa      xmm7, xmm5              ; transpose coefficients(phase 3)
+    punpcklqdq  xmm5, xmm3              ; xmm5=col2=(02 12 22 32 42 52 62 72)
+    punpckhqdq  xmm7, xmm3              ; xmm7=col3=(03 13 23 33 43 53 63 73)
+
+    movdqa      xmm1, XMMWORD [wk(0)]   ; xmm1=(04 14 24 34 05 15 25 35)
+    movdqa      xmm3, XMMWORD [wk(1)]   ; xmm3=(06 16 26 36 07 17 27 37)
+
+    movdqa      XMMWORD [wk(0)], xmm4   ; wk(0)=col1
+    movdqa      XMMWORD [wk(1)], xmm7   ; wk(1)=col3
+
+    movdqa      xmm4, xmm1              ; transpose coefficients(phase 3)
+    punpcklqdq  xmm1, xmm2              ; xmm1=col4=(04 14 24 34 44 54 64 74)
+    punpckhqdq  xmm4, xmm2              ; xmm4=col5=(05 15 25 35 45 55 65 75)
+    movdqa      xmm7, xmm3              ; transpose coefficients(phase 3)
+    punpcklqdq  xmm3, xmm0              ; xmm3=col6=(06 16 26 36 46 56 66 76)
+    punpckhqdq  xmm7, xmm0              ; xmm7=col7=(07 17 27 37 47 57 67 77)
+.column_end:
+
+    ; -- Prefetch the next coefficient block
+
+    prefetchnta [rsi + DCTSIZE2*SIZEOF_JCOEF + 0*32]
+    prefetchnta [rsi + DCTSIZE2*SIZEOF_JCOEF + 1*32]
+    prefetchnta [rsi + DCTSIZE2*SIZEOF_JCOEF + 2*32]
+    prefetchnta [rsi + DCTSIZE2*SIZEOF_JCOEF + 3*32]
+
+    ; ---- Pass 2: process rows from work array, store into output array.
+
+    mov         rax, [original_rbp]
+    mov         rdi, r12                ; (JSAMPROW *)
+    mov         eax, r13d
+
+    ; -- Even part
+
+    ; xmm6=col0, xmm5=col2, xmm1=col4, xmm3=col6
+
+    movdqa      xmm2, xmm6
+    movdqa      xmm0, xmm5
+    psubw       xmm6, xmm1              ; xmm6=tmp11
+    psubw       xmm5, xmm3
+    paddw       xmm2, xmm1              ; xmm2=tmp10
+    paddw       xmm0, xmm3              ; xmm0=tmp13
+
+    psllw       xmm5, PRE_MULTIPLY_SCALE_BITS
+    pmulhw      xmm5, [rel PW_F1414]
+    psubw       xmm5, xmm0              ; xmm5=tmp12
+
+    movdqa      xmm1, xmm2
+    movdqa      xmm3, xmm6
+    psubw       xmm2, xmm0              ; xmm2=tmp3
+    psubw       xmm6, xmm5              ; xmm6=tmp2
+    paddw       xmm1, xmm0              ; xmm1=tmp0
+    paddw       xmm3, xmm5              ; xmm3=tmp1
+
+    movdqa      xmm0, XMMWORD [wk(0)]   ; xmm0=col1
+    movdqa      xmm5, XMMWORD [wk(1)]   ; xmm5=col3
+
+    movdqa      XMMWORD [wk(0)], xmm2   ; wk(0)=tmp3
+    movdqa      XMMWORD [wk(1)], xmm6   ; wk(1)=tmp2
+
+    ; -- Odd part
+
+    ; xmm0=col1, xmm5=col3, xmm4=col5, xmm7=col7
+
+    movdqa      xmm2, xmm0
+    movdqa      xmm6, xmm4
+    psubw       xmm0, xmm7              ; xmm0=z12
+    psubw       xmm4, xmm5              ; xmm4=z10
+    paddw       xmm2, xmm7              ; xmm2=z11
+    paddw       xmm6, xmm5              ; xmm6=z13
+
+    movdqa      xmm7, xmm4              ; xmm7=z10(unscaled)
+    psllw       xmm0, PRE_MULTIPLY_SCALE_BITS
+    psllw       xmm4, PRE_MULTIPLY_SCALE_BITS
+
+    movdqa      xmm5, xmm2
+    psubw       xmm2, xmm6
+    paddw       xmm5, xmm6              ; xmm5=tmp7
+
+    psllw       xmm2, PRE_MULTIPLY_SCALE_BITS
+    pmulhw      xmm2, [rel PW_F1414]    ; xmm2=tmp11
+
+    ; To avoid overflow...
+    ;
+    ; (Original)
+    ; tmp12 = -2.613125930 * z10 + z5;
+    ;
+    ; (This implementation)
+    ; tmp12 = (-1.613125930 - 1) * z10 + z5;
+    ;       = -1.613125930 * z10 - z10 + z5;
+
+    movdqa      xmm6, xmm4
+    paddw       xmm4, xmm0
+    pmulhw      xmm4, [rel PW_F1847]    ; xmm4=z5
+    pmulhw      xmm6, [rel PW_MF1613]
+    pmulhw      xmm0, [rel PW_F1082]
+    psubw       xmm6, xmm7
+    psubw       xmm0, xmm4              ; xmm0=tmp10
+    paddw       xmm6, xmm4              ; xmm6=tmp12
+
+    ; -- Final output stage
+
+    psubw       xmm6, xmm5              ; xmm6=tmp6
+    movdqa      xmm7, xmm1
+    movdqa      xmm4, xmm3
+    paddw       xmm1, xmm5              ; xmm1=data0=(00 10 20 30 40 50 60 70)
+    paddw       xmm3, xmm6              ; xmm3=data1=(01 11 21 31 41 51 61 71)
+    psraw       xmm1, (PASS1_BITS+3)    ; descale
+    psraw       xmm3, (PASS1_BITS+3)    ; descale
+    psubw       xmm7, xmm5              ; xmm7=data7=(07 17 27 37 47 57 67 77)
+    psubw       xmm4, xmm6              ; xmm4=data6=(06 16 26 36 46 56 66 76)
+    psraw       xmm7, (PASS1_BITS+3)    ; descale
+    psraw       xmm4, (PASS1_BITS+3)    ; descale
+    psubw       xmm2, xmm6              ; xmm2=tmp5
+
+    packsswb    xmm1, xmm4        ; xmm1=(00 10 20 30 40 50 60 70 06 16 26 36 46 56 66 76)
+    packsswb    xmm3, xmm7        ; xmm3=(01 11 21 31 41 51 61 71 07 17 27 37 47 57 67 77)
+
+    movdqa      xmm5, XMMWORD [wk(1)]   ; xmm5=tmp2
+    movdqa      xmm6, XMMWORD [wk(0)]   ; xmm6=tmp3
+
+    paddw       xmm0, xmm2              ; xmm0=tmp4
+    movdqa      xmm4, xmm5
+    movdqa      xmm7, xmm6
+    paddw       xmm5, xmm2              ; xmm5=data2=(02 12 22 32 42 52 62 72)
+    paddw       xmm6, xmm0              ; xmm6=data4=(04 14 24 34 44 54 64 74)
+    psraw       xmm5, (PASS1_BITS+3)    ; descale
+    psraw       xmm6, (PASS1_BITS+3)    ; descale
+    psubw       xmm4, xmm2              ; xmm4=data5=(05 15 25 35 45 55 65 75)
+    psubw       xmm7, xmm0              ; xmm7=data3=(03 13 23 33 43 53 63 73)
+    psraw       xmm4, (PASS1_BITS+3)    ; descale
+    psraw       xmm7, (PASS1_BITS+3)    ; descale
+
+    movdqa      xmm2, [rel PB_CENTERJSAMP]  ; xmm2=[rel PB_CENTERJSAMP]
+
+    packsswb    xmm5, xmm6        ; xmm5=(02 12 22 32 42 52 62 72 04 14 24 34 44 54 64 74)
+    packsswb    xmm7, xmm4        ; xmm7=(03 13 23 33 43 53 63 73 05 15 25 35 45 55 65 75)
+
+    paddb       xmm1, xmm2
+    paddb       xmm3, xmm2
+    paddb       xmm5, xmm2
+    paddb       xmm7, xmm2
+
+    movdqa      xmm0, xmm1        ; transpose coefficients(phase 1)
+    punpcklbw   xmm1, xmm3        ; xmm1=(00 01 10 11 20 21 30 31 40 41 50 51 60 61 70 71)
+    punpckhbw   xmm0, xmm3        ; xmm0=(06 07 16 17 26 27 36 37 46 47 56 57 66 67 76 77)
+    movdqa      xmm6, xmm5        ; transpose coefficients(phase 1)
+    punpcklbw   xmm5, xmm7        ; xmm5=(02 03 12 13 22 23 32 33 42 43 52 53 62 63 72 73)
+    punpckhbw   xmm6, xmm7        ; xmm6=(04 05 14 15 24 25 34 35 44 45 54 55 64 65 74 75)
+
+    movdqa      xmm4, xmm1        ; transpose coefficients(phase 2)
+    punpcklwd   xmm1, xmm5        ; xmm1=(00 01 02 03 10 11 12 13 20 21 22 23 30 31 32 33)
+    punpckhwd   xmm4, xmm5        ; xmm4=(40 41 42 43 50 51 52 53 60 61 62 63 70 71 72 73)
+    movdqa      xmm2, xmm6        ; transpose coefficients(phase 2)
+    punpcklwd   xmm6, xmm0        ; xmm6=(04 05 06 07 14 15 16 17 24 25 26 27 34 35 36 37)
+    punpckhwd   xmm2, xmm0        ; xmm2=(44 45 46 47 54 55 56 57 64 65 66 67 74 75 76 77)
+
+    movdqa      xmm3, xmm1        ; transpose coefficients(phase 3)
+    punpckldq   xmm1, xmm6        ; xmm1=(00 01 02 03 04 05 06 07 10 11 12 13 14 15 16 17)
+    punpckhdq   xmm3, xmm6        ; xmm3=(20 21 22 23 24 25 26 27 30 31 32 33 34 35 36 37)
+    movdqa      xmm7, xmm4        ; transpose coefficients(phase 3)
+    punpckldq   xmm4, xmm2        ; xmm4=(40 41 42 43 44 45 46 47 50 51 52 53 54 55 56 57)
+    punpckhdq   xmm7, xmm2        ; xmm7=(60 61 62 63 64 65 66 67 70 71 72 73 74 75 76 77)
+
+    pshufd      xmm5, xmm1, 0x4E  ; xmm5=(10 11 12 13 14 15 16 17 00 01 02 03 04 05 06 07)
+    pshufd      xmm0, xmm3, 0x4E  ; xmm0=(30 31 32 33 34 35 36 37 20 21 22 23 24 25 26 27)
+    pshufd      xmm6, xmm4, 0x4E  ; xmm6=(50 51 52 53 54 55 56 57 40 41 42 43 44 45 46 47)
+    pshufd      xmm2, xmm7, 0x4E  ; xmm2=(70 71 72 73 74 75 76 77 60 61 62 63 64 65 66 67)
+
+    mov         rdxp, JSAMPROW [rdi+0*SIZEOF_JSAMPROW]
+    mov         rsip, JSAMPROW [rdi+2*SIZEOF_JSAMPROW]
+    movq        XMM_MMWORD [rdx+rax*SIZEOF_JSAMPLE], xmm1
+    movq        XMM_MMWORD [rsi+rax*SIZEOF_JSAMPLE], xmm3
+    mov         rdxp, JSAMPROW [rdi+4*SIZEOF_JSAMPROW]
+    mov         rsip, JSAMPROW [rdi+6*SIZEOF_JSAMPROW]
+    movq        XMM_MMWORD [rdx+rax*SIZEOF_JSAMPLE], xmm4
+    movq        XMM_MMWORD [rsi+rax*SIZEOF_JSAMPLE], xmm7
+
+    mov         rdxp, JSAMPROW [rdi+1*SIZEOF_JSAMPROW]
+    mov         rsip, JSAMPROW [rdi+3*SIZEOF_JSAMPROW]
+    movq        XMM_MMWORD [rdx+rax*SIZEOF_JSAMPLE], xmm5
+    movq        XMM_MMWORD [rsi+rax*SIZEOF_JSAMPLE], xmm0
+    mov         rdxp, JSAMPROW [rdi+5*SIZEOF_JSAMPROW]
+    mov         rsip, JSAMPROW [rdi+7*SIZEOF_JSAMPROW]
+    movq        XMM_MMWORD [rdx+rax*SIZEOF_JSAMPLE], xmm6
+    movq        XMM_MMWORD [rsi+rax*SIZEOF_JSAMPLE], xmm2
+
+    uncollect_args 4
+    mov         rsp, rbp                ; rsp <- aligned rbp
+    pop         rsp                     ; rsp <- original rbp
+    pop         rbp
+    ret
+    ret
+
+; For some reason, the OS X linker does not honor the request to align the
+; segment unless we do this.
+    align       32
diff --git a/3rdparty/libjpeg/src/simd/x86_64/jidctint-avx2.asm b/3rdparty/libjpeg/src/simd/x86_64/jidctint-avx2.asm
new file mode 100644
index 00000000..ca7e317f
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/x86_64/jidctint-avx2.asm
@@ -0,0 +1,418 @@
+;
+; jidctint.asm - accurate integer IDCT (64-bit AVX2)
+;
+; Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+; Copyright (C) 2009, 2016, 2018, 2020, D. R. Commander.
+; Copyright (C) 2018, Matthias Räncker.
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+;
+; This file should be assembled with NASM (Netwide Assembler),
+; can *not* be assembled with Microsoft's MASM or any compatible
+; assembler (including Borland's Turbo Assembler).
+; NASM is available from http://nasm.sourceforge.net/ or
+; http://sourceforge.net/project/showfiles.php?group_id=6208
+;
+; This file contains a slower but more accurate integer implementation of the
+; inverse DCT (Discrete Cosine Transform). The following code is based
+; directly on the IJG's original jidctint.c; see the jidctint.c for
+; more details.
+
+%include "jsimdext.inc"
+%include "jdct.inc"
+
+; --------------------------------------------------------------------------
+
+%define CONST_BITS  13
+%define PASS1_BITS  2
+
+%define DESCALE_P1  (CONST_BITS - PASS1_BITS)
+%define DESCALE_P2  (CONST_BITS + PASS1_BITS + 3)
+
+%if CONST_BITS == 13
+F_0_298 equ  2446  ; FIX(0.298631336)
+F_0_390 equ  3196  ; FIX(0.390180644)
+F_0_541 equ  4433  ; FIX(0.541196100)
+F_0_765 equ  6270  ; FIX(0.765366865)
+F_0_899 equ  7373  ; FIX(0.899976223)
+F_1_175 equ  9633  ; FIX(1.175875602)
+F_1_501 equ 12299  ; FIX(1.501321110)
+F_1_847 equ 15137  ; FIX(1.847759065)
+F_1_961 equ 16069  ; FIX(1.961570560)
+F_2_053 equ 16819  ; FIX(2.053119869)
+F_2_562 equ 20995  ; FIX(2.562915447)
+F_3_072 equ 25172  ; FIX(3.072711026)
+%else
+; NASM cannot do compile-time arithmetic on floating-point constants.
+%define DESCALE(x, n)  (((x) + (1 << ((n) - 1))) >> (n))
+F_0_298 equ DESCALE( 320652955, 30 - CONST_BITS)  ; FIX(0.298631336)
+F_0_390 equ DESCALE( 418953276, 30 - CONST_BITS)  ; FIX(0.390180644)
+F_0_541 equ DESCALE( 581104887, 30 - CONST_BITS)  ; FIX(0.541196100)
+F_0_765 equ DESCALE( 821806413, 30 - CONST_BITS)  ; FIX(0.765366865)
+F_0_899 equ DESCALE( 966342111, 30 - CONST_BITS)  ; FIX(0.899976223)
+F_1_175 equ DESCALE(1262586813, 30 - CONST_BITS)  ; FIX(1.175875602)
+F_1_501 equ DESCALE(1612031267, 30 - CONST_BITS)  ; FIX(1.501321110)
+F_1_847 equ DESCALE(1984016188, 30 - CONST_BITS)  ; FIX(1.847759065)
+F_1_961 equ DESCALE(2106220350, 30 - CONST_BITS)  ; FIX(1.961570560)
+F_2_053 equ DESCALE(2204520673, 30 - CONST_BITS)  ; FIX(2.053119869)
+F_2_562 equ DESCALE(2751909506, 30 - CONST_BITS)  ; FIX(2.562915447)
+F_3_072 equ DESCALE(3299298341, 30 - CONST_BITS)  ; FIX(3.072711026)
+%endif
+
+; --------------------------------------------------------------------------
+; In-place 8x8x16-bit inverse matrix transpose using AVX2 instructions
+; %1-%4: Input/output registers
+; %5-%8: Temp registers
+
+%macro dotranspose 8
+    ; %5=(00 10 20 30 40 50 60 70  01 11 21 31 41 51 61 71)
+    ; %6=(03 13 23 33 43 53 63 73  02 12 22 32 42 52 62 72)
+    ; %7=(04 14 24 34 44 54 64 74  05 15 25 35 45 55 65 75)
+    ; %8=(07 17 27 37 47 57 67 77  06 16 26 36 46 56 66 76)
+
+    vpermq      %5, %1, 0xD8
+    vpermq      %6, %2, 0x72
+    vpermq      %7, %3, 0xD8
+    vpermq      %8, %4, 0x72
+    ; transpose coefficients(phase 1)
+    ; %5=(00 10 20 30 01 11 21 31  40 50 60 70 41 51 61 71)
+    ; %6=(02 12 22 32 03 13 23 33  42 52 62 72 43 53 63 73)
+    ; %7=(04 14 24 34 05 15 25 35  44 54 64 74 45 55 65 75)
+    ; %8=(06 16 26 36 07 17 27 37  46 56 66 76 47 57 67 77)
+
+    vpunpcklwd  %1, %5, %6
+    vpunpckhwd  %2, %5, %6
+    vpunpcklwd  %3, %7, %8
+    vpunpckhwd  %4, %7, %8
+    ; transpose coefficients(phase 2)
+    ; %1=(00 02 10 12 20 22 30 32  40 42 50 52 60 62 70 72)
+    ; %2=(01 03 11 13 21 23 31 33  41 43 51 53 61 63 71 73)
+    ; %3=(04 06 14 16 24 26 34 36  44 46 54 56 64 66 74 76)
+    ; %4=(05 07 15 17 25 27 35 37  45 47 55 57 65 67 75 77)
+
+    vpunpcklwd  %5, %1, %2
+    vpunpcklwd  %6, %3, %4
+    vpunpckhwd  %7, %1, %2
+    vpunpckhwd  %8, %3, %4
+    ; transpose coefficients(phase 3)
+    ; %5=(00 01 02 03 10 11 12 13  40 41 42 43 50 51 52 53)
+    ; %6=(04 05 06 07 14 15 16 17  44 45 46 47 54 55 56 57)
+    ; %7=(20 21 22 23 30 31 32 33  60 61 62 63 70 71 72 73)
+    ; %8=(24 25 26 27 34 35 36 37  64 65 66 67 74 75 76 77)
+
+    vpunpcklqdq %1, %5, %6
+    vpunpckhqdq %2, %5, %6
+    vpunpcklqdq %3, %7, %8
+    vpunpckhqdq %4, %7, %8
+    ; transpose coefficients(phase 4)
+    ; %1=(00 01 02 03 04 05 06 07  40 41 42 43 44 45 46 47)
+    ; %2=(10 11 12 13 14 15 16 17  50 51 52 53 54 55 56 57)
+    ; %3=(20 21 22 23 24 25 26 27  60 61 62 63 64 65 66 67)
+    ; %4=(30 31 32 33 34 35 36 37  70 71 72 73 74 75 76 77)
+%endmacro
+
+; --------------------------------------------------------------------------
+; In-place 8x8x16-bit accurate integer inverse DCT using AVX2 instructions
+; %1-%4:  Input/output registers
+; %5-%12: Temp registers
+; %9:     Pass (1 or 2)
+
+%macro dodct 13
+    ; -- Even part
+
+    ; (Original)
+    ; z1 = (z2 + z3) * 0.541196100;
+    ; tmp2 = z1 + z3 * -1.847759065;
+    ; tmp3 = z1 + z2 * 0.765366865;
+    ;
+    ; (This implementation)
+    ; tmp2 = z2 * 0.541196100 + z3 * (0.541196100 - 1.847759065);
+    ; tmp3 = z2 * (0.541196100 + 0.765366865) + z3 * 0.541196100;
+
+    vperm2i128  %6, %3, %3, 0x01        ; %6=in6_2
+    vpunpcklwd  %5, %3, %6              ; %5=in26_62L
+    vpunpckhwd  %6, %3, %6              ; %6=in26_62H
+    vpmaddwd    %5, %5, [rel PW_F130_F054_MF130_F054]  ; %5=tmp3_2L
+    vpmaddwd    %6, %6, [rel PW_F130_F054_MF130_F054]  ; %6=tmp3_2H
+
+    vperm2i128  %7, %1, %1, 0x01        ; %7=in4_0
+    vpsignw     %1, %1, [rel PW_1_NEG1]
+    vpaddw      %7, %7, %1              ; %7=(in0+in4)_(in0-in4)
+
+    vpxor       %1, %1, %1
+    vpunpcklwd  %8, %1, %7              ; %8=tmp0_1L
+    vpunpckhwd  %1, %1, %7              ; %1=tmp0_1H
+    vpsrad      %8, %8, (16-CONST_BITS)  ; vpsrad %8,16 & vpslld %8,CONST_BITS
+    vpsrad      %1, %1, (16-CONST_BITS)  ; vpsrad %1,16 & vpslld %1,CONST_BITS
+
+    vpsubd      %11, %8, %5             ; %11=tmp0_1L-tmp3_2L=tmp13_12L
+    vpaddd      %9, %8, %5              ; %9=tmp0_1L+tmp3_2L=tmp10_11L
+    vpsubd      %12, %1, %6             ; %12=tmp0_1H-tmp3_2H=tmp13_12H
+    vpaddd      %10, %1, %6             ; %10=tmp0_1H+tmp3_2H=tmp10_11H
+
+    ; -- Odd part
+
+    vpaddw      %1, %4, %2              ; %1=in7_5+in3_1=z3_4
+
+    ; (Original)
+    ; z5 = (z3 + z4) * 1.175875602;
+    ; z3 = z3 * -1.961570560;  z4 = z4 * -0.390180644;
+    ; z3 += z5;  z4 += z5;
+    ;
+    ; (This implementation)
+    ; z3 = z3 * (1.175875602 - 1.961570560) + z4 * 1.175875602;
+    ; z4 = z3 * 1.175875602 + z4 * (1.175875602 - 0.390180644);
+
+    vperm2i128  %8, %1, %1, 0x01        ; %8=z4_3
+    vpunpcklwd  %7, %1, %8              ; %7=z34_43L
+    vpunpckhwd  %8, %1, %8              ; %8=z34_43H
+    vpmaddwd    %7, %7, [rel PW_MF078_F117_F078_F117]  ; %7=z3_4L
+    vpmaddwd    %8, %8, [rel PW_MF078_F117_F078_F117]  ; %8=z3_4H
+
+    ; (Original)
+    ; z1 = tmp0 + tmp3;  z2 = tmp1 + tmp2;
+    ; tmp0 = tmp0 * 0.298631336;  tmp1 = tmp1 * 2.053119869;
+    ; tmp2 = tmp2 * 3.072711026;  tmp3 = tmp3 * 1.501321110;
+    ; z1 = z1 * -0.899976223;  z2 = z2 * -2.562915447;
+    ; tmp0 += z1 + z3;  tmp1 += z2 + z4;
+    ; tmp2 += z2 + z3;  tmp3 += z1 + z4;
+    ;
+    ; (This implementation)
+    ; tmp0 = tmp0 * (0.298631336 - 0.899976223) + tmp3 * -0.899976223;
+    ; tmp1 = tmp1 * (2.053119869 - 2.562915447) + tmp2 * -2.562915447;
+    ; tmp2 = tmp1 * -2.562915447 + tmp2 * (3.072711026 - 2.562915447);
+    ; tmp3 = tmp0 * -0.899976223 + tmp3 * (1.501321110 - 0.899976223);
+    ; tmp0 += z3;  tmp1 += z4;
+    ; tmp2 += z3;  tmp3 += z4;
+
+    vperm2i128  %2, %2, %2, 0x01        ; %2=in1_3
+    vpunpcklwd  %3, %4, %2              ; %3=in71_53L
+    vpunpckhwd  %4, %4, %2              ; %4=in71_53H
+
+    vpmaddwd    %5, %3, [rel PW_MF060_MF089_MF050_MF256]  ; %5=tmp0_1L
+    vpmaddwd    %6, %4, [rel PW_MF060_MF089_MF050_MF256]  ; %6=tmp0_1H
+    vpaddd      %5, %5, %7              ; %5=tmp0_1L+z3_4L=tmp0_1L
+    vpaddd      %6, %6, %8              ; %6=tmp0_1H+z3_4H=tmp0_1H
+
+    vpmaddwd    %3, %3, [rel PW_MF089_F060_MF256_F050]  ; %3=tmp3_2L
+    vpmaddwd    %4, %4, [rel PW_MF089_F060_MF256_F050]  ; %4=tmp3_2H
+    vperm2i128  %7, %7, %7, 0x01        ; %7=z4_3L
+    vperm2i128  %8, %8, %8, 0x01        ; %8=z4_3H
+    vpaddd      %7, %3, %7              ; %7=tmp3_2L+z4_3L=tmp3_2L
+    vpaddd      %8, %4, %8              ; %8=tmp3_2H+z4_3H=tmp3_2H
+
+    ; -- Final output stage
+
+    vpaddd      %1, %9, %7              ; %1=tmp10_11L+tmp3_2L=data0_1L
+    vpaddd      %2, %10, %8             ; %2=tmp10_11H+tmp3_2H=data0_1H
+    vpaddd      %1, %1, [rel PD_DESCALE_P %+ %13]
+    vpaddd      %2, %2, [rel PD_DESCALE_P %+ %13]
+    vpsrad      %1, %1, DESCALE_P %+ %13
+    vpsrad      %2, %2, DESCALE_P %+ %13
+    vpackssdw   %1, %1, %2              ; %1=data0_1
+
+    vpsubd      %3, %9, %7              ; %3=tmp10_11L-tmp3_2L=data7_6L
+    vpsubd      %4, %10, %8             ; %4=tmp10_11H-tmp3_2H=data7_6H
+    vpaddd      %3, %3, [rel PD_DESCALE_P %+ %13]
+    vpaddd      %4, %4, [rel PD_DESCALE_P %+ %13]
+    vpsrad      %3, %3, DESCALE_P %+ %13
+    vpsrad      %4, %4, DESCALE_P %+ %13
+    vpackssdw   %4, %3, %4              ; %4=data7_6
+
+    vpaddd      %7, %11, %5             ; %7=tmp13_12L+tmp0_1L=data3_2L
+    vpaddd      %8, %12, %6             ; %8=tmp13_12H+tmp0_1H=data3_2H
+    vpaddd      %7, %7, [rel PD_DESCALE_P %+ %13]
+    vpaddd      %8, %8, [rel PD_DESCALE_P %+ %13]
+    vpsrad      %7, %7, DESCALE_P %+ %13
+    vpsrad      %8, %8, DESCALE_P %+ %13
+    vpackssdw   %2, %7, %8              ; %2=data3_2
+
+    vpsubd      %7, %11, %5             ; %7=tmp13_12L-tmp0_1L=data4_5L
+    vpsubd      %8, %12, %6             ; %8=tmp13_12H-tmp0_1H=data4_5H
+    vpaddd      %7, %7, [rel PD_DESCALE_P %+ %13]
+    vpaddd      %8, %8, [rel PD_DESCALE_P %+ %13]
+    vpsrad      %7, %7, DESCALE_P %+ %13
+    vpsrad      %8, %8, DESCALE_P %+ %13
+    vpackssdw   %3, %7, %8              ; %3=data4_5
+%endmacro
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_CONST
+
+    alignz      32
+    GLOBAL_DATA(jconst_idct_islow_avx2)
+
+EXTN(jconst_idct_islow_avx2):
+
+PW_F130_F054_MF130_F054    times 4  dw  (F_0_541 + F_0_765),  F_0_541
+                           times 4  dw  (F_0_541 - F_1_847),  F_0_541
+PW_MF078_F117_F078_F117    times 4  dw  (F_1_175 - F_1_961),  F_1_175
+                           times 4  dw  (F_1_175 - F_0_390),  F_1_175
+PW_MF060_MF089_MF050_MF256 times 4  dw  (F_0_298 - F_0_899), -F_0_899
+                           times 4  dw  (F_2_053 - F_2_562), -F_2_562
+PW_MF089_F060_MF256_F050   times 4  dw -F_0_899, (F_1_501 - F_0_899)
+                           times 4  dw -F_2_562, (F_3_072 - F_2_562)
+PD_DESCALE_P1              times 8  dd  1 << (DESCALE_P1 - 1)
+PD_DESCALE_P2              times 8  dd  1 << (DESCALE_P2 - 1)
+PB_CENTERJSAMP             times 32 db  CENTERJSAMPLE
+PW_1_NEG1                  times 8  dw  1
+                           times 8  dw -1
+
+    alignz      32
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_TEXT
+    BITS        64
+;
+; Perform dequantization and inverse DCT on one block of coefficients.
+;
+; GLOBAL(void)
+; jsimd_idct_islow_avx2(void *dct_table, JCOEFPTR coef_block,
+;                       JSAMPARRAY output_buf, JDIMENSION output_col)
+;
+
+; r10 = jpeg_component_info *compptr
+; r11 = JCOEFPTR coef_block
+; r12 = JSAMPARRAY output_buf
+; r13d = JDIMENSION output_col
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_idct_islow_avx2)
+
+EXTN(jsimd_idct_islow_avx2):
+    push        rbp
+    mov         rax, rsp                     ; rax = original rbp
+    mov         rbp, rsp                     ; rbp = aligned rbp
+    push_xmm    4
+    collect_args 4
+
+    ; ---- Pass 1: process columns.
+
+%ifndef NO_ZERO_COLUMN_TEST_ISLOW_AVX2
+    mov         eax, dword [DWBLOCK(1,0,r11,SIZEOF_JCOEF)]
+    or          eax, dword [DWBLOCK(2,0,r11,SIZEOF_JCOEF)]
+    jnz         near .columnDCT
+
+    movdqa      xmm0, XMMWORD [XMMBLOCK(1,0,r11,SIZEOF_JCOEF)]
+    movdqa      xmm1, XMMWORD [XMMBLOCK(2,0,r11,SIZEOF_JCOEF)]
+    vpor        xmm0, xmm0, XMMWORD [XMMBLOCK(3,0,r11,SIZEOF_JCOEF)]
+    vpor        xmm1, xmm1, XMMWORD [XMMBLOCK(4,0,r11,SIZEOF_JCOEF)]
+    vpor        xmm0, xmm0, XMMWORD [XMMBLOCK(5,0,r11,SIZEOF_JCOEF)]
+    vpor        xmm1, xmm1, XMMWORD [XMMBLOCK(6,0,r11,SIZEOF_JCOEF)]
+    vpor        xmm0, xmm0, XMMWORD [XMMBLOCK(7,0,r11,SIZEOF_JCOEF)]
+    vpor        xmm1, xmm1, xmm0
+    vpacksswb   xmm1, xmm1, xmm1
+    vpacksswb   xmm1, xmm1, xmm1
+    movd        eax, xmm1
+    test        rax, rax
+    jnz         short .columnDCT
+
+    ; -- AC terms all zero
+
+    movdqa      xmm5, XMMWORD [XMMBLOCK(0,0,r11,SIZEOF_JCOEF)]
+    vpmullw     xmm5, xmm5, XMMWORD [XMMBLOCK(0,0,r10,SIZEOF_ISLOW_MULT_TYPE)]
+
+    vpsllw      xmm5, xmm5, PASS1_BITS
+
+    vpunpcklwd  xmm4, xmm5, xmm5        ; xmm4=(00 00 01 01 02 02 03 03)
+    vpunpckhwd  xmm5, xmm5, xmm5        ; xmm5=(04 04 05 05 06 06 07 07)
+    vinserti128 ymm4, ymm4, xmm5, 1
+
+    vpshufd     ymm0, ymm4, 0x00        ; ymm0=col0_4=(00 00 00 00 00 00 00 00  04 04 04 04 04 04 04 04)
+    vpshufd     ymm1, ymm4, 0x55        ; ymm1=col1_5=(01 01 01 01 01 01 01 01  05 05 05 05 05 05 05 05)
+    vpshufd     ymm2, ymm4, 0xAA        ; ymm2=col2_6=(02 02 02 02 02 02 02 02  06 06 06 06 06 06 06 06)
+    vpshufd     ymm3, ymm4, 0xFF        ; ymm3=col3_7=(03 03 03 03 03 03 03 03  07 07 07 07 07 07 07 07)
+
+    jmp         near .column_end
+%endif
+.columnDCT:
+
+    vmovdqu     ymm4, YMMWORD [YMMBLOCK(0,0,r11,SIZEOF_JCOEF)]  ; ymm4=in0_1
+    vmovdqu     ymm5, YMMWORD [YMMBLOCK(2,0,r11,SIZEOF_JCOEF)]  ; ymm5=in2_3
+    vmovdqu     ymm6, YMMWORD [YMMBLOCK(4,0,r11,SIZEOF_JCOEF)]  ; ymm6=in4_5
+    vmovdqu     ymm7, YMMWORD [YMMBLOCK(6,0,r11,SIZEOF_JCOEF)]  ; ymm7=in6_7
+    vpmullw     ymm4, ymm4, YMMWORD [YMMBLOCK(0,0,r10,SIZEOF_ISLOW_MULT_TYPE)]
+    vpmullw     ymm5, ymm5, YMMWORD [YMMBLOCK(2,0,r10,SIZEOF_ISLOW_MULT_TYPE)]
+    vpmullw     ymm6, ymm6, YMMWORD [YMMBLOCK(4,0,r10,SIZEOF_ISLOW_MULT_TYPE)]
+    vpmullw     ymm7, ymm7, YMMWORD [YMMBLOCK(6,0,r10,SIZEOF_ISLOW_MULT_TYPE)]
+
+    vperm2i128  ymm0, ymm4, ymm6, 0x20  ; ymm0=in0_4
+    vperm2i128  ymm1, ymm5, ymm4, 0x31  ; ymm1=in3_1
+    vperm2i128  ymm2, ymm5, ymm7, 0x20  ; ymm2=in2_6
+    vperm2i128  ymm3, ymm7, ymm6, 0x31  ; ymm3=in7_5
+
+    dodct ymm0, ymm1, ymm2, ymm3, ymm4, ymm5, ymm6, ymm7, ymm8, ymm9, ymm10, ymm11, 1
+    ; ymm0=data0_1, ymm1=data3_2, ymm2=data4_5, ymm3=data7_6
+
+    dotranspose ymm0, ymm1, ymm2, ymm3, ymm4, ymm5, ymm6, ymm7
+    ; ymm0=data0_4, ymm1=data1_5, ymm2=data2_6, ymm3=data3_7
+
+.column_end:
+
+    ; -- Prefetch the next coefficient block
+
+    prefetchnta [r11 + DCTSIZE2*SIZEOF_JCOEF + 0*32]
+    prefetchnta [r11 + DCTSIZE2*SIZEOF_JCOEF + 1*32]
+    prefetchnta [r11 + DCTSIZE2*SIZEOF_JCOEF + 2*32]
+    prefetchnta [r11 + DCTSIZE2*SIZEOF_JCOEF + 3*32]
+
+    ; ---- Pass 2: process rows.
+
+    vperm2i128  ymm4, ymm3, ymm1, 0x31  ; ymm3=in7_5
+    vperm2i128  ymm1, ymm3, ymm1, 0x20  ; ymm1=in3_1
+
+    dodct ymm0, ymm1, ymm2, ymm4, ymm3, ymm5, ymm6, ymm7, ymm8, ymm9, ymm10, ymm11, 2
+    ; ymm0=data0_1, ymm1=data3_2, ymm2=data4_5, ymm4=data7_6
+
+    dotranspose ymm0, ymm1, ymm2, ymm4, ymm3, ymm5, ymm6, ymm7
+    ; ymm0=data0_4, ymm1=data1_5, ymm2=data2_6, ymm4=data3_7
+
+    vpacksswb   ymm0, ymm0, ymm1        ; ymm0=data01_45
+    vpacksswb   ymm1, ymm2, ymm4        ; ymm1=data23_67
+    vpaddb      ymm0, ymm0, [rel PB_CENTERJSAMP]
+    vpaddb      ymm1, ymm1, [rel PB_CENTERJSAMP]
+
+    vextracti128 xmm6, ymm1, 1          ; xmm3=data67
+    vextracti128 xmm4, ymm0, 1          ; xmm2=data45
+    vextracti128 xmm2, ymm1, 0          ; xmm1=data23
+    vextracti128 xmm0, ymm0, 0          ; xmm0=data01
+
+    vpshufd     xmm1, xmm0, 0x4E  ; xmm1=(10 11 12 13 14 15 16 17 00 01 02 03 04 05 06 07)
+    vpshufd     xmm3, xmm2, 0x4E  ; xmm3=(30 31 32 33 34 35 36 37 20 21 22 23 24 25 26 27)
+    vpshufd     xmm5, xmm4, 0x4E  ; xmm5=(50 51 52 53 54 55 56 57 40 41 42 43 44 45 46 47)
+    vpshufd     xmm7, xmm6, 0x4E  ; xmm7=(70 71 72 73 74 75 76 77 60 61 62 63 64 65 66 67)
+
+    vzeroupper
+
+    mov         eax, r13d
+
+    mov         rdxp, JSAMPROW [r12+0*SIZEOF_JSAMPROW]  ; (JSAMPLE *)
+    mov         rsip, JSAMPROW [r12+1*SIZEOF_JSAMPROW]  ; (JSAMPLE *)
+    movq        XMM_MMWORD [rdx+rax*SIZEOF_JSAMPLE], xmm0
+    movq        XMM_MMWORD [rsi+rax*SIZEOF_JSAMPLE], xmm1
+
+    mov         rdxp, JSAMPROW [r12+2*SIZEOF_JSAMPROW]  ; (JSAMPLE *)
+    mov         rsip, JSAMPROW [r12+3*SIZEOF_JSAMPROW]  ; (JSAMPLE *)
+    movq        XMM_MMWORD [rdx+rax*SIZEOF_JSAMPLE], xmm2
+    movq        XMM_MMWORD [rsi+rax*SIZEOF_JSAMPLE], xmm3
+
+    mov         rdxp, JSAMPROW [r12+4*SIZEOF_JSAMPROW]  ; (JSAMPLE *)
+    mov         rsip, JSAMPROW [r12+5*SIZEOF_JSAMPROW]  ; (JSAMPLE *)
+    movq        XMM_MMWORD [rdx+rax*SIZEOF_JSAMPLE], xmm4
+    movq        XMM_MMWORD [rsi+rax*SIZEOF_JSAMPLE], xmm5
+
+    mov         rdxp, JSAMPROW [r12+6*SIZEOF_JSAMPROW]  ; (JSAMPLE *)
+    mov         rsip, JSAMPROW [r12+7*SIZEOF_JSAMPROW]  ; (JSAMPLE *)
+    movq        XMM_MMWORD [rdx+rax*SIZEOF_JSAMPLE], xmm6
+    movq        XMM_MMWORD [rsi+rax*SIZEOF_JSAMPLE], xmm7
+
+    uncollect_args 4
+    pop_xmm     4
+    pop         rbp
+    ret
+
+; For some reason, the OS X linker does not honor the request to align the
+; segment unless we do this.
+    align       32
diff --git a/3rdparty/libjpeg/src/simd/x86_64/jidctint-sse2.asm b/3rdparty/libjpeg/src/simd/x86_64/jidctint-sse2.asm
new file mode 100644
index 00000000..7aa869bc
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/x86_64/jidctint-sse2.asm
@@ -0,0 +1,847 @@
+;
+; jidctint.asm - accurate integer IDCT (64-bit SSE2)
+;
+; Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+; Copyright (C) 2009, 2016, 2020, D. R. Commander.
+; Copyright (C) 2018, Matthias Räncker.
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+;
+; This file should be assembled with NASM (Netwide Assembler),
+; can *not* be assembled with Microsoft's MASM or any compatible
+; assembler (including Borland's Turbo Assembler).
+; NASM is available from http://nasm.sourceforge.net/ or
+; http://sourceforge.net/project/showfiles.php?group_id=6208
+;
+; This file contains a slower but more accurate integer implementation of the
+; inverse DCT (Discrete Cosine Transform). The following code is based
+; directly on the IJG's original jidctint.c; see the jidctint.c for
+; more details.
+
+%include "jsimdext.inc"
+%include "jdct.inc"
+
+; --------------------------------------------------------------------------
+
+%define CONST_BITS  13
+%define PASS1_BITS  2
+
+%define DESCALE_P1  (CONST_BITS - PASS1_BITS)
+%define DESCALE_P2  (CONST_BITS + PASS1_BITS + 3)
+
+%if CONST_BITS == 13
+F_0_298 equ  2446  ; FIX(0.298631336)
+F_0_390 equ  3196  ; FIX(0.390180644)
+F_0_541 equ  4433  ; FIX(0.541196100)
+F_0_765 equ  6270  ; FIX(0.765366865)
+F_0_899 equ  7373  ; FIX(0.899976223)
+F_1_175 equ  9633  ; FIX(1.175875602)
+F_1_501 equ 12299  ; FIX(1.501321110)
+F_1_847 equ 15137  ; FIX(1.847759065)
+F_1_961 equ 16069  ; FIX(1.961570560)
+F_2_053 equ 16819  ; FIX(2.053119869)
+F_2_562 equ 20995  ; FIX(2.562915447)
+F_3_072 equ 25172  ; FIX(3.072711026)
+%else
+; NASM cannot do compile-time arithmetic on floating-point constants.
+%define DESCALE(x, n)  (((x) + (1 << ((n) - 1))) >> (n))
+F_0_298 equ DESCALE( 320652955, 30 - CONST_BITS)  ; FIX(0.298631336)
+F_0_390 equ DESCALE( 418953276, 30 - CONST_BITS)  ; FIX(0.390180644)
+F_0_541 equ DESCALE( 581104887, 30 - CONST_BITS)  ; FIX(0.541196100)
+F_0_765 equ DESCALE( 821806413, 30 - CONST_BITS)  ; FIX(0.765366865)
+F_0_899 equ DESCALE( 966342111, 30 - CONST_BITS)  ; FIX(0.899976223)
+F_1_175 equ DESCALE(1262586813, 30 - CONST_BITS)  ; FIX(1.175875602)
+F_1_501 equ DESCALE(1612031267, 30 - CONST_BITS)  ; FIX(1.501321110)
+F_1_847 equ DESCALE(1984016188, 30 - CONST_BITS)  ; FIX(1.847759065)
+F_1_961 equ DESCALE(2106220350, 30 - CONST_BITS)  ; FIX(1.961570560)
+F_2_053 equ DESCALE(2204520673, 30 - CONST_BITS)  ; FIX(2.053119869)
+F_2_562 equ DESCALE(2751909506, 30 - CONST_BITS)  ; FIX(2.562915447)
+F_3_072 equ DESCALE(3299298341, 30 - CONST_BITS)  ; FIX(3.072711026)
+%endif
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_CONST
+
+    alignz      32
+    GLOBAL_DATA(jconst_idct_islow_sse2)
+
+EXTN(jconst_idct_islow_sse2):
+
+PW_F130_F054   times 4  dw  (F_0_541 + F_0_765),  F_0_541
+PW_F054_MF130  times 4  dw  F_0_541, (F_0_541 - F_1_847)
+PW_MF078_F117  times 4  dw  (F_1_175 - F_1_961),  F_1_175
+PW_F117_F078   times 4  dw  F_1_175, (F_1_175 - F_0_390)
+PW_MF060_MF089 times 4  dw  (F_0_298 - F_0_899), -F_0_899
+PW_MF089_F060  times 4  dw -F_0_899, (F_1_501 - F_0_899)
+PW_MF050_MF256 times 4  dw  (F_2_053 - F_2_562), -F_2_562
+PW_MF256_F050  times 4  dw -F_2_562, (F_3_072 - F_2_562)
+PD_DESCALE_P1  times 4  dd  1 << (DESCALE_P1 - 1)
+PD_DESCALE_P2  times 4  dd  1 << (DESCALE_P2 - 1)
+PB_CENTERJSAMP times 16 db  CENTERJSAMPLE
+
+    alignz      32
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_TEXT
+    BITS        64
+;
+; Perform dequantization and inverse DCT on one block of coefficients.
+;
+; GLOBAL(void)
+; jsimd_idct_islow_sse2(void *dct_table, JCOEFPTR coef_block,
+;                       JSAMPARRAY output_buf, JDIMENSION output_col)
+;
+
+; r10 = jpeg_component_info *compptr
+; r11 = JCOEFPTR coef_block
+; r12 = JSAMPARRAY output_buf
+; r13d = JDIMENSION output_col
+
+%define original_rbp  rbp + 0
+%define wk(i)         rbp - (WK_NUM - (i)) * SIZEOF_XMMWORD
+                                        ; xmmword wk[WK_NUM]
+%define WK_NUM        12
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_idct_islow_sse2)
+
+EXTN(jsimd_idct_islow_sse2):
+    push        rbp
+    mov         rax, rsp                     ; rax = original rbp
+    sub         rsp, byte 4
+    and         rsp, byte (-SIZEOF_XMMWORD)  ; align to 128 bits
+    mov         [rsp], rax
+    mov         rbp, rsp                     ; rbp = aligned rbp
+    lea         rsp, [wk(0)]
+    collect_args 4
+
+    ; ---- Pass 1: process columns from input.
+
+    mov         rdx, r10                ; quantptr
+    mov         rsi, r11                ; inptr
+
+%ifndef NO_ZERO_COLUMN_TEST_ISLOW_SSE2
+    mov         eax, dword [DWBLOCK(1,0,rsi,SIZEOF_JCOEF)]
+    or          eax, dword [DWBLOCK(2,0,rsi,SIZEOF_JCOEF)]
+    jnz         near .columnDCT
+
+    movdqa      xmm0, XMMWORD [XMMBLOCK(1,0,rsi,SIZEOF_JCOEF)]
+    movdqa      xmm1, XMMWORD [XMMBLOCK(2,0,rsi,SIZEOF_JCOEF)]
+    por         xmm0, XMMWORD [XMMBLOCK(3,0,rsi,SIZEOF_JCOEF)]
+    por         xmm1, XMMWORD [XMMBLOCK(4,0,rsi,SIZEOF_JCOEF)]
+    por         xmm0, XMMWORD [XMMBLOCK(5,0,rsi,SIZEOF_JCOEF)]
+    por         xmm1, XMMWORD [XMMBLOCK(6,0,rsi,SIZEOF_JCOEF)]
+    por         xmm0, XMMWORD [XMMBLOCK(7,0,rsi,SIZEOF_JCOEF)]
+    por         xmm1, xmm0
+    packsswb    xmm1, xmm1
+    packsswb    xmm1, xmm1
+    movd        eax, xmm1
+    test        rax, rax
+    jnz         short .columnDCT
+
+    ; -- AC terms all zero
+
+    movdqa      xmm5, XMMWORD [XMMBLOCK(0,0,rsi,SIZEOF_JCOEF)]
+    pmullw      xmm5, XMMWORD [XMMBLOCK(0,0,rdx,SIZEOF_ISLOW_MULT_TYPE)]
+
+    psllw       xmm5, PASS1_BITS
+
+    movdqa      xmm4, xmm5              ; xmm5=in0=(00 01 02 03 04 05 06 07)
+    punpcklwd   xmm5, xmm5              ; xmm5=(00 00 01 01 02 02 03 03)
+    punpckhwd   xmm4, xmm4              ; xmm4=(04 04 05 05 06 06 07 07)
+
+    pshufd      xmm7, xmm5, 0x00        ; xmm7=col0=(00 00 00 00 00 00 00 00)
+    pshufd      xmm6, xmm5, 0x55        ; xmm6=col1=(01 01 01 01 01 01 01 01)
+    pshufd      xmm1, xmm5, 0xAA        ; xmm1=col2=(02 02 02 02 02 02 02 02)
+    pshufd      xmm5, xmm5, 0xFF        ; xmm5=col3=(03 03 03 03 03 03 03 03)
+    pshufd      xmm0, xmm4, 0x00        ; xmm0=col4=(04 04 04 04 04 04 04 04)
+    pshufd      xmm3, xmm4, 0x55        ; xmm3=col5=(05 05 05 05 05 05 05 05)
+    pshufd      xmm2, xmm4, 0xAA        ; xmm2=col6=(06 06 06 06 06 06 06 06)
+    pshufd      xmm4, xmm4, 0xFF        ; xmm4=col7=(07 07 07 07 07 07 07 07)
+
+    movdqa      XMMWORD [wk(8)], xmm6   ; wk(8)=col1
+    movdqa      XMMWORD [wk(9)], xmm5   ; wk(9)=col3
+    movdqa      XMMWORD [wk(10)], xmm3  ; wk(10)=col5
+    movdqa      XMMWORD [wk(11)], xmm4  ; wk(11)=col7
+    jmp         near .column_end
+%endif
+.columnDCT:
+
+    ; -- Even part
+
+    movdqa      xmm0, XMMWORD [XMMBLOCK(0,0,rsi,SIZEOF_JCOEF)]
+    movdqa      xmm1, XMMWORD [XMMBLOCK(2,0,rsi,SIZEOF_JCOEF)]
+    pmullw      xmm0, XMMWORD [XMMBLOCK(0,0,rdx,SIZEOF_ISLOW_MULT_TYPE)]
+    pmullw      xmm1, XMMWORD [XMMBLOCK(2,0,rdx,SIZEOF_ISLOW_MULT_TYPE)]
+    movdqa      xmm2, XMMWORD [XMMBLOCK(4,0,rsi,SIZEOF_JCOEF)]
+    movdqa      xmm3, XMMWORD [XMMBLOCK(6,0,rsi,SIZEOF_JCOEF)]
+    pmullw      xmm2, XMMWORD [XMMBLOCK(4,0,rdx,SIZEOF_ISLOW_MULT_TYPE)]
+    pmullw      xmm3, XMMWORD [XMMBLOCK(6,0,rdx,SIZEOF_ISLOW_MULT_TYPE)]
+
+    ; (Original)
+    ; z1 = (z2 + z3) * 0.541196100;
+    ; tmp2 = z1 + z3 * -1.847759065;
+    ; tmp3 = z1 + z2 * 0.765366865;
+    ;
+    ; (This implementation)
+    ; tmp2 = z2 * 0.541196100 + z3 * (0.541196100 - 1.847759065);
+    ; tmp3 = z2 * (0.541196100 + 0.765366865) + z3 * 0.541196100;
+
+    movdqa      xmm4, xmm1              ; xmm1=in2=z2
+    movdqa      xmm5, xmm1
+    punpcklwd   xmm4, xmm3              ; xmm3=in6=z3
+    punpckhwd   xmm5, xmm3
+    movdqa      xmm1, xmm4
+    movdqa      xmm3, xmm5
+    pmaddwd     xmm4, [rel PW_F130_F054]   ; xmm4=tmp3L
+    pmaddwd     xmm5, [rel PW_F130_F054]   ; xmm5=tmp3H
+    pmaddwd     xmm1, [rel PW_F054_MF130]  ; xmm1=tmp2L
+    pmaddwd     xmm3, [rel PW_F054_MF130]  ; xmm3=tmp2H
+
+    movdqa      xmm6, xmm0
+    paddw       xmm0, xmm2              ; xmm0=in0+in4
+    psubw       xmm6, xmm2              ; xmm6=in0-in4
+
+    pxor        xmm7, xmm7
+    pxor        xmm2, xmm2
+    punpcklwd   xmm7, xmm0              ; xmm7=tmp0L
+    punpckhwd   xmm2, xmm0              ; xmm2=tmp0H
+    psrad       xmm7, (16-CONST_BITS)   ; psrad xmm7,16 & pslld xmm7,CONST_BITS
+    psrad       xmm2, (16-CONST_BITS)   ; psrad xmm2,16 & pslld xmm2,CONST_BITS
+
+    movdqa      xmm0, xmm7
+    paddd       xmm7, xmm4              ; xmm7=tmp10L
+    psubd       xmm0, xmm4              ; xmm0=tmp13L
+    movdqa      xmm4, xmm2
+    paddd       xmm2, xmm5              ; xmm2=tmp10H
+    psubd       xmm4, xmm5              ; xmm4=tmp13H
+
+    movdqa      XMMWORD [wk(0)], xmm7   ; wk(0)=tmp10L
+    movdqa      XMMWORD [wk(1)], xmm2   ; wk(1)=tmp10H
+    movdqa      XMMWORD [wk(2)], xmm0   ; wk(2)=tmp13L
+    movdqa      XMMWORD [wk(3)], xmm4   ; wk(3)=tmp13H
+
+    pxor        xmm5, xmm5
+    pxor        xmm7, xmm7
+    punpcklwd   xmm5, xmm6              ; xmm5=tmp1L
+    punpckhwd   xmm7, xmm6              ; xmm7=tmp1H
+    psrad       xmm5, (16-CONST_BITS)   ; psrad xmm5,16 & pslld xmm5,CONST_BITS
+    psrad       xmm7, (16-CONST_BITS)   ; psrad xmm7,16 & pslld xmm7,CONST_BITS
+
+    movdqa      xmm2, xmm5
+    paddd       xmm5, xmm1              ; xmm5=tmp11L
+    psubd       xmm2, xmm1              ; xmm2=tmp12L
+    movdqa      xmm0, xmm7
+    paddd       xmm7, xmm3              ; xmm7=tmp11H
+    psubd       xmm0, xmm3              ; xmm0=tmp12H
+
+    movdqa      XMMWORD [wk(4)], xmm5   ; wk(4)=tmp11L
+    movdqa      XMMWORD [wk(5)], xmm7   ; wk(5)=tmp11H
+    movdqa      XMMWORD [wk(6)], xmm2   ; wk(6)=tmp12L
+    movdqa      XMMWORD [wk(7)], xmm0   ; wk(7)=tmp12H
+
+    ; -- Odd part
+
+    movdqa      xmm4, XMMWORD [XMMBLOCK(1,0,rsi,SIZEOF_JCOEF)]
+    movdqa      xmm6, XMMWORD [XMMBLOCK(3,0,rsi,SIZEOF_JCOEF)]
+    pmullw      xmm4, XMMWORD [XMMBLOCK(1,0,rdx,SIZEOF_ISLOW_MULT_TYPE)]
+    pmullw      xmm6, XMMWORD [XMMBLOCK(3,0,rdx,SIZEOF_ISLOW_MULT_TYPE)]
+    movdqa      xmm1, XMMWORD [XMMBLOCK(5,0,rsi,SIZEOF_JCOEF)]
+    movdqa      xmm3, XMMWORD [XMMBLOCK(7,0,rsi,SIZEOF_JCOEF)]
+    pmullw      xmm1, XMMWORD [XMMBLOCK(5,0,rdx,SIZEOF_ISLOW_MULT_TYPE)]
+    pmullw      xmm3, XMMWORD [XMMBLOCK(7,0,rdx,SIZEOF_ISLOW_MULT_TYPE)]
+
+    movdqa      xmm5, xmm6
+    movdqa      xmm7, xmm4
+    paddw       xmm5, xmm3              ; xmm5=z3
+    paddw       xmm7, xmm1              ; xmm7=z4
+
+    ; (Original)
+    ; z5 = (z3 + z4) * 1.175875602;
+    ; z3 = z3 * -1.961570560;  z4 = z4 * -0.390180644;
+    ; z3 += z5;  z4 += z5;
+    ;
+    ; (This implementation)
+    ; z3 = z3 * (1.175875602 - 1.961570560) + z4 * 1.175875602;
+    ; z4 = z3 * 1.175875602 + z4 * (1.175875602 - 0.390180644);
+
+    movdqa      xmm2, xmm5
+    movdqa      xmm0, xmm5
+    punpcklwd   xmm2, xmm7
+    punpckhwd   xmm0, xmm7
+    movdqa      xmm5, xmm2
+    movdqa      xmm7, xmm0
+    pmaddwd     xmm2, [rel PW_MF078_F117]  ; xmm2=z3L
+    pmaddwd     xmm0, [rel PW_MF078_F117]  ; xmm0=z3H
+    pmaddwd     xmm5, [rel PW_F117_F078]   ; xmm5=z4L
+    pmaddwd     xmm7, [rel PW_F117_F078]   ; xmm7=z4H
+
+    movdqa      XMMWORD [wk(10)], xmm2  ; wk(10)=z3L
+    movdqa      XMMWORD [wk(11)], xmm0  ; wk(11)=z3H
+
+    ; (Original)
+    ; z1 = tmp0 + tmp3;  z2 = tmp1 + tmp2;
+    ; tmp0 = tmp0 * 0.298631336;  tmp1 = tmp1 * 2.053119869;
+    ; tmp2 = tmp2 * 3.072711026;  tmp3 = tmp3 * 1.501321110;
+    ; z1 = z1 * -0.899976223;  z2 = z2 * -2.562915447;
+    ; tmp0 += z1 + z3;  tmp1 += z2 + z4;
+    ; tmp2 += z2 + z3;  tmp3 += z1 + z4;
+    ;
+    ; (This implementation)
+    ; tmp0 = tmp0 * (0.298631336 - 0.899976223) + tmp3 * -0.899976223;
+    ; tmp1 = tmp1 * (2.053119869 - 2.562915447) + tmp2 * -2.562915447;
+    ; tmp2 = tmp1 * -2.562915447 + tmp2 * (3.072711026 - 2.562915447);
+    ; tmp3 = tmp0 * -0.899976223 + tmp3 * (1.501321110 - 0.899976223);
+    ; tmp0 += z3;  tmp1 += z4;
+    ; tmp2 += z3;  tmp3 += z4;
+
+    movdqa      xmm2, xmm3
+    movdqa      xmm0, xmm3
+    punpcklwd   xmm2, xmm4
+    punpckhwd   xmm0, xmm4
+    movdqa      xmm3, xmm2
+    movdqa      xmm4, xmm0
+    pmaddwd     xmm2, [rel PW_MF060_MF089]  ; xmm2=tmp0L
+    pmaddwd     xmm0, [rel PW_MF060_MF089]  ; xmm0=tmp0H
+    pmaddwd     xmm3, [rel PW_MF089_F060]   ; xmm3=tmp3L
+    pmaddwd     xmm4, [rel PW_MF089_F060]   ; xmm4=tmp3H
+
+    paddd       xmm2, XMMWORD [wk(10)]  ; xmm2=tmp0L
+    paddd       xmm0, XMMWORD [wk(11)]  ; xmm0=tmp0H
+    paddd       xmm3, xmm5              ; xmm3=tmp3L
+    paddd       xmm4, xmm7              ; xmm4=tmp3H
+
+    movdqa      XMMWORD [wk(8)], xmm2   ; wk(8)=tmp0L
+    movdqa      XMMWORD [wk(9)], xmm0   ; wk(9)=tmp0H
+
+    movdqa      xmm2, xmm1
+    movdqa      xmm0, xmm1
+    punpcklwd   xmm2, xmm6
+    punpckhwd   xmm0, xmm6
+    movdqa      xmm1, xmm2
+    movdqa      xmm6, xmm0
+    pmaddwd     xmm2, [rel PW_MF050_MF256]  ; xmm2=tmp1L
+    pmaddwd     xmm0, [rel PW_MF050_MF256]  ; xmm0=tmp1H
+    pmaddwd     xmm1, [rel PW_MF256_F050]   ; xmm1=tmp2L
+    pmaddwd     xmm6, [rel PW_MF256_F050]   ; xmm6=tmp2H
+
+    paddd       xmm2, xmm5              ; xmm2=tmp1L
+    paddd       xmm0, xmm7              ; xmm0=tmp1H
+    paddd       xmm1, XMMWORD [wk(10)]  ; xmm1=tmp2L
+    paddd       xmm6, XMMWORD [wk(11)]  ; xmm6=tmp2H
+
+    movdqa      XMMWORD [wk(10)], xmm2  ; wk(10)=tmp1L
+    movdqa      XMMWORD [wk(11)], xmm0  ; wk(11)=tmp1H
+
+    ; -- Final output stage
+
+    movdqa      xmm5, XMMWORD [wk(0)]   ; xmm5=tmp10L
+    movdqa      xmm7, XMMWORD [wk(1)]   ; xmm7=tmp10H
+
+    movdqa      xmm2, xmm5
+    movdqa      xmm0, xmm7
+    paddd       xmm5, xmm3              ; xmm5=data0L
+    paddd       xmm7, xmm4              ; xmm7=data0H
+    psubd       xmm2, xmm3              ; xmm2=data7L
+    psubd       xmm0, xmm4              ; xmm0=data7H
+
+    movdqa      xmm3, [rel PD_DESCALE_P1]  ; xmm3=[rel PD_DESCALE_P1]
+
+    paddd       xmm5, xmm3
+    paddd       xmm7, xmm3
+    psrad       xmm5, DESCALE_P1
+    psrad       xmm7, DESCALE_P1
+    paddd       xmm2, xmm3
+    paddd       xmm0, xmm3
+    psrad       xmm2, DESCALE_P1
+    psrad       xmm0, DESCALE_P1
+
+    packssdw    xmm5, xmm7              ; xmm5=data0=(00 01 02 03 04 05 06 07)
+    packssdw    xmm2, xmm0              ; xmm2=data7=(70 71 72 73 74 75 76 77)
+
+    movdqa      xmm4, XMMWORD [wk(4)]   ; xmm4=tmp11L
+    movdqa      xmm3, XMMWORD [wk(5)]   ; xmm3=tmp11H
+
+    movdqa      xmm7, xmm4
+    movdqa      xmm0, xmm3
+    paddd       xmm4, xmm1              ; xmm4=data1L
+    paddd       xmm3, xmm6              ; xmm3=data1H
+    psubd       xmm7, xmm1              ; xmm7=data6L
+    psubd       xmm0, xmm6              ; xmm0=data6H
+
+    movdqa      xmm1, [rel PD_DESCALE_P1]  ; xmm1=[rel PD_DESCALE_P1]
+
+    paddd       xmm4, xmm1
+    paddd       xmm3, xmm1
+    psrad       xmm4, DESCALE_P1
+    psrad       xmm3, DESCALE_P1
+    paddd       xmm7, xmm1
+    paddd       xmm0, xmm1
+    psrad       xmm7, DESCALE_P1
+    psrad       xmm0, DESCALE_P1
+
+    packssdw    xmm4, xmm3              ; xmm4=data1=(10 11 12 13 14 15 16 17)
+    packssdw    xmm7, xmm0              ; xmm7=data6=(60 61 62 63 64 65 66 67)
+
+    movdqa      xmm6, xmm5              ; transpose coefficients(phase 1)
+    punpcklwd   xmm5, xmm4              ; xmm5=(00 10 01 11 02 12 03 13)
+    punpckhwd   xmm6, xmm4              ; xmm6=(04 14 05 15 06 16 07 17)
+    movdqa      xmm1, xmm7              ; transpose coefficients(phase 1)
+    punpcklwd   xmm7, xmm2              ; xmm7=(60 70 61 71 62 72 63 73)
+    punpckhwd   xmm1, xmm2              ; xmm1=(64 74 65 75 66 76 67 77)
+
+    movdqa      xmm3, XMMWORD [wk(6)]   ; xmm3=tmp12L
+    movdqa      xmm0, XMMWORD [wk(7)]   ; xmm0=tmp12H
+    movdqa      xmm4, XMMWORD [wk(10)]  ; xmm4=tmp1L
+    movdqa      xmm2, XMMWORD [wk(11)]  ; xmm2=tmp1H
+
+    movdqa      XMMWORD [wk(0)], xmm5   ; wk(0)=(00 10 01 11 02 12 03 13)
+    movdqa      XMMWORD [wk(1)], xmm6   ; wk(1)=(04 14 05 15 06 16 07 17)
+    movdqa      XMMWORD [wk(4)], xmm7   ; wk(4)=(60 70 61 71 62 72 63 73)
+    movdqa      XMMWORD [wk(5)], xmm1   ; wk(5)=(64 74 65 75 66 76 67 77)
+
+    movdqa      xmm5, xmm3
+    movdqa      xmm6, xmm0
+    paddd       xmm3, xmm4              ; xmm3=data2L
+    paddd       xmm0, xmm2              ; xmm0=data2H
+    psubd       xmm5, xmm4              ; xmm5=data5L
+    psubd       xmm6, xmm2              ; xmm6=data5H
+
+    movdqa      xmm7, [rel PD_DESCALE_P1]  ; xmm7=[rel PD_DESCALE_P1]
+
+    paddd       xmm3, xmm7
+    paddd       xmm0, xmm7
+    psrad       xmm3, DESCALE_P1
+    psrad       xmm0, DESCALE_P1
+    paddd       xmm5, xmm7
+    paddd       xmm6, xmm7
+    psrad       xmm5, DESCALE_P1
+    psrad       xmm6, DESCALE_P1
+
+    packssdw    xmm3, xmm0              ; xmm3=data2=(20 21 22 23 24 25 26 27)
+    packssdw    xmm5, xmm6              ; xmm5=data5=(50 51 52 53 54 55 56 57)
+
+    movdqa      xmm1, XMMWORD [wk(2)]   ; xmm1=tmp13L
+    movdqa      xmm4, XMMWORD [wk(3)]   ; xmm4=tmp13H
+    movdqa      xmm2, XMMWORD [wk(8)]   ; xmm2=tmp0L
+    movdqa      xmm7, XMMWORD [wk(9)]   ; xmm7=tmp0H
+
+    movdqa      xmm0, xmm1
+    movdqa      xmm6, xmm4
+    paddd       xmm1, xmm2              ; xmm1=data3L
+    paddd       xmm4, xmm7              ; xmm4=data3H
+    psubd       xmm0, xmm2              ; xmm0=data4L
+    psubd       xmm6, xmm7              ; xmm6=data4H
+
+    movdqa      xmm2, [rel PD_DESCALE_P1]  ; xmm2=[rel PD_DESCALE_P1]
+
+    paddd       xmm1, xmm2
+    paddd       xmm4, xmm2
+    psrad       xmm1, DESCALE_P1
+    psrad       xmm4, DESCALE_P1
+    paddd       xmm0, xmm2
+    paddd       xmm6, xmm2
+    psrad       xmm0, DESCALE_P1
+    psrad       xmm6, DESCALE_P1
+
+    packssdw    xmm1, xmm4              ; xmm1=data3=(30 31 32 33 34 35 36 37)
+    packssdw    xmm0, xmm6              ; xmm0=data4=(40 41 42 43 44 45 46 47)
+
+    movdqa      xmm7, XMMWORD [wk(0)]   ; xmm7=(00 10 01 11 02 12 03 13)
+    movdqa      xmm2, XMMWORD [wk(1)]   ; xmm2=(04 14 05 15 06 16 07 17)
+
+    movdqa      xmm4, xmm3              ; transpose coefficients(phase 1)
+    punpcklwd   xmm3, xmm1              ; xmm3=(20 30 21 31 22 32 23 33)
+    punpckhwd   xmm4, xmm1              ; xmm4=(24 34 25 35 26 36 27 37)
+    movdqa      xmm6, xmm0              ; transpose coefficients(phase 1)
+    punpcklwd   xmm0, xmm5              ; xmm0=(40 50 41 51 42 52 43 53)
+    punpckhwd   xmm6, xmm5              ; xmm6=(44 54 45 55 46 56 47 57)
+
+    movdqa      xmm1, xmm7              ; transpose coefficients(phase 2)
+    punpckldq   xmm7, xmm3              ; xmm7=(00 10 20 30 01 11 21 31)
+    punpckhdq   xmm1, xmm3              ; xmm1=(02 12 22 32 03 13 23 33)
+    movdqa      xmm5, xmm2              ; transpose coefficients(phase 2)
+    punpckldq   xmm2, xmm4              ; xmm2=(04 14 24 34 05 15 25 35)
+    punpckhdq   xmm5, xmm4              ; xmm5=(06 16 26 36 07 17 27 37)
+
+    movdqa      xmm3, XMMWORD [wk(4)]   ; xmm3=(60 70 61 71 62 72 63 73)
+    movdqa      xmm4, XMMWORD [wk(5)]   ; xmm4=(64 74 65 75 66 76 67 77)
+
+    movdqa      XMMWORD [wk(6)], xmm2   ; wk(6)=(04 14 24 34 05 15 25 35)
+    movdqa      XMMWORD [wk(7)], xmm5   ; wk(7)=(06 16 26 36 07 17 27 37)
+
+    movdqa      xmm2, xmm0              ; transpose coefficients(phase 2)
+    punpckldq   xmm0, xmm3              ; xmm0=(40 50 60 70 41 51 61 71)
+    punpckhdq   xmm2, xmm3              ; xmm2=(42 52 62 72 43 53 63 73)
+    movdqa      xmm5, xmm6              ; transpose coefficients(phase 2)
+    punpckldq   xmm6, xmm4              ; xmm6=(44 54 64 74 45 55 65 75)
+    punpckhdq   xmm5, xmm4              ; xmm5=(46 56 66 76 47 57 67 77)
+
+    movdqa      xmm3, xmm7              ; transpose coefficients(phase 3)
+    punpcklqdq  xmm7, xmm0              ; xmm7=col0=(00 10 20 30 40 50 60 70)
+    punpckhqdq  xmm3, xmm0              ; xmm3=col1=(01 11 21 31 41 51 61 71)
+    movdqa      xmm4, xmm1              ; transpose coefficients(phase 3)
+    punpcklqdq  xmm1, xmm2              ; xmm1=col2=(02 12 22 32 42 52 62 72)
+    punpckhqdq  xmm4, xmm2              ; xmm4=col3=(03 13 23 33 43 53 63 73)
+
+    movdqa      xmm0, XMMWORD [wk(6)]   ; xmm0=(04 14 24 34 05 15 25 35)
+    movdqa      xmm2, XMMWORD [wk(7)]   ; xmm2=(06 16 26 36 07 17 27 37)
+
+    movdqa      XMMWORD [wk(8)], xmm3   ; wk(8)=col1
+    movdqa      XMMWORD [wk(9)], xmm4   ; wk(9)=col3
+
+    movdqa      xmm3, xmm0              ; transpose coefficients(phase 3)
+    punpcklqdq  xmm0, xmm6              ; xmm0=col4=(04 14 24 34 44 54 64 74)
+    punpckhqdq  xmm3, xmm6              ; xmm3=col5=(05 15 25 35 45 55 65 75)
+    movdqa      xmm4, xmm2              ; transpose coefficients(phase 3)
+    punpcklqdq  xmm2, xmm5              ; xmm2=col6=(06 16 26 36 46 56 66 76)
+    punpckhqdq  xmm4, xmm5              ; xmm4=col7=(07 17 27 37 47 57 67 77)
+
+    movdqa      XMMWORD [wk(10)], xmm3  ; wk(10)=col5
+    movdqa      XMMWORD [wk(11)], xmm4  ; wk(11)=col7
+.column_end:
+
+    ; -- Prefetch the next coefficient block
+
+    prefetchnta [rsi + DCTSIZE2*SIZEOF_JCOEF + 0*32]
+    prefetchnta [rsi + DCTSIZE2*SIZEOF_JCOEF + 1*32]
+    prefetchnta [rsi + DCTSIZE2*SIZEOF_JCOEF + 2*32]
+    prefetchnta [rsi + DCTSIZE2*SIZEOF_JCOEF + 3*32]
+
+    ; ---- Pass 2: process rows from work array, store into output array.
+
+    mov         rax, [original_rbp]
+    mov         rdi, r12                ; (JSAMPROW *)
+    mov         eax, r13d
+
+    ; -- Even part
+
+    ; xmm7=col0, xmm1=col2, xmm0=col4, xmm2=col6
+
+    ; (Original)
+    ; z1 = (z2 + z3) * 0.541196100;
+    ; tmp2 = z1 + z3 * -1.847759065;
+    ; tmp3 = z1 + z2 * 0.765366865;
+    ;
+    ; (This implementation)
+    ; tmp2 = z2 * 0.541196100 + z3 * (0.541196100 - 1.847759065);
+    ; tmp3 = z2 * (0.541196100 + 0.765366865) + z3 * 0.541196100;
+
+    movdqa      xmm6, xmm1              ; xmm1=in2=z2
+    movdqa      xmm5, xmm1
+    punpcklwd   xmm6, xmm2              ; xmm2=in6=z3
+    punpckhwd   xmm5, xmm2
+    movdqa      xmm1, xmm6
+    movdqa      xmm2, xmm5
+    pmaddwd     xmm6, [rel PW_F130_F054]   ; xmm6=tmp3L
+    pmaddwd     xmm5, [rel PW_F130_F054]   ; xmm5=tmp3H
+    pmaddwd     xmm1, [rel PW_F054_MF130]  ; xmm1=tmp2L
+    pmaddwd     xmm2, [rel PW_F054_MF130]  ; xmm2=tmp2H
+
+    movdqa      xmm3, xmm7
+    paddw       xmm7, xmm0              ; xmm7=in0+in4
+    psubw       xmm3, xmm0              ; xmm3=in0-in4
+
+    pxor        xmm4, xmm4
+    pxor        xmm0, xmm0
+    punpcklwd   xmm4, xmm7              ; xmm4=tmp0L
+    punpckhwd   xmm0, xmm7              ; xmm0=tmp0H
+    psrad       xmm4, (16-CONST_BITS)   ; psrad xmm4,16 & pslld xmm4,CONST_BITS
+    psrad       xmm0, (16-CONST_BITS)   ; psrad xmm0,16 & pslld xmm0,CONST_BITS
+
+    movdqa      xmm7, xmm4
+    paddd       xmm4, xmm6              ; xmm4=tmp10L
+    psubd       xmm7, xmm6              ; xmm7=tmp13L
+    movdqa      xmm6, xmm0
+    paddd       xmm0, xmm5              ; xmm0=tmp10H
+    psubd       xmm6, xmm5              ; xmm6=tmp13H
+
+    movdqa      XMMWORD [wk(0)], xmm4   ; wk(0)=tmp10L
+    movdqa      XMMWORD [wk(1)], xmm0   ; wk(1)=tmp10H
+    movdqa      XMMWORD [wk(2)], xmm7   ; wk(2)=tmp13L
+    movdqa      XMMWORD [wk(3)], xmm6   ; wk(3)=tmp13H
+
+    pxor        xmm5, xmm5
+    pxor        xmm4, xmm4
+    punpcklwd   xmm5, xmm3              ; xmm5=tmp1L
+    punpckhwd   xmm4, xmm3              ; xmm4=tmp1H
+    psrad       xmm5, (16-CONST_BITS)   ; psrad xmm5,16 & pslld xmm5,CONST_BITS
+    psrad       xmm4, (16-CONST_BITS)   ; psrad xmm4,16 & pslld xmm4,CONST_BITS
+
+    movdqa      xmm0, xmm5
+    paddd       xmm5, xmm1              ; xmm5=tmp11L
+    psubd       xmm0, xmm1              ; xmm0=tmp12L
+    movdqa      xmm7, xmm4
+    paddd       xmm4, xmm2              ; xmm4=tmp11H
+    psubd       xmm7, xmm2              ; xmm7=tmp12H
+
+    movdqa      XMMWORD [wk(4)], xmm5   ; wk(4)=tmp11L
+    movdqa      XMMWORD [wk(5)], xmm4   ; wk(5)=tmp11H
+    movdqa      XMMWORD [wk(6)], xmm0   ; wk(6)=tmp12L
+    movdqa      XMMWORD [wk(7)], xmm7   ; wk(7)=tmp12H
+
+    ; -- Odd part
+
+    movdqa      xmm6, XMMWORD [wk(9)]   ; xmm6=col3
+    movdqa      xmm3, XMMWORD [wk(8)]   ; xmm3=col1
+    movdqa      xmm1, XMMWORD [wk(11)]  ; xmm1=col7
+    movdqa      xmm2, XMMWORD [wk(10)]  ; xmm2=col5
+
+    movdqa      xmm5, xmm6
+    movdqa      xmm4, xmm3
+    paddw       xmm5, xmm1              ; xmm5=z3
+    paddw       xmm4, xmm2              ; xmm4=z4
+
+    ; (Original)
+    ; z5 = (z3 + z4) * 1.175875602;
+    ; z3 = z3 * -1.961570560;  z4 = z4 * -0.390180644;
+    ; z3 += z5;  z4 += z5;
+    ;
+    ; (This implementation)
+    ; z3 = z3 * (1.175875602 - 1.961570560) + z4 * 1.175875602;
+    ; z4 = z3 * 1.175875602 + z4 * (1.175875602 - 0.390180644);
+
+    movdqa      xmm0, xmm5
+    movdqa      xmm7, xmm5
+    punpcklwd   xmm0, xmm4
+    punpckhwd   xmm7, xmm4
+    movdqa      xmm5, xmm0
+    movdqa      xmm4, xmm7
+    pmaddwd     xmm0, [rel PW_MF078_F117]  ; xmm0=z3L
+    pmaddwd     xmm7, [rel PW_MF078_F117]  ; xmm7=z3H
+    pmaddwd     xmm5, [rel PW_F117_F078]   ; xmm5=z4L
+    pmaddwd     xmm4, [rel PW_F117_F078]   ; xmm4=z4H
+
+    movdqa      XMMWORD [wk(10)], xmm0  ; wk(10)=z3L
+    movdqa      XMMWORD [wk(11)], xmm7  ; wk(11)=z3H
+
+    ; (Original)
+    ; z1 = tmp0 + tmp3;  z2 = tmp1 + tmp2;
+    ; tmp0 = tmp0 * 0.298631336;  tmp1 = tmp1 * 2.053119869;
+    ; tmp2 = tmp2 * 3.072711026;  tmp3 = tmp3 * 1.501321110;
+    ; z1 = z1 * -0.899976223;  z2 = z2 * -2.562915447;
+    ; tmp0 += z1 + z3;  tmp1 += z2 + z4;
+    ; tmp2 += z2 + z3;  tmp3 += z1 + z4;
+    ;
+    ; (This implementation)
+    ; tmp0 = tmp0 * (0.298631336 - 0.899976223) + tmp3 * -0.899976223;
+    ; tmp1 = tmp1 * (2.053119869 - 2.562915447) + tmp2 * -2.562915447;
+    ; tmp2 = tmp1 * -2.562915447 + tmp2 * (3.072711026 - 2.562915447);
+    ; tmp3 = tmp0 * -0.899976223 + tmp3 * (1.501321110 - 0.899976223);
+    ; tmp0 += z3;  tmp1 += z4;
+    ; tmp2 += z3;  tmp3 += z4;
+
+    movdqa      xmm0, xmm1
+    movdqa      xmm7, xmm1
+    punpcklwd   xmm0, xmm3
+    punpckhwd   xmm7, xmm3
+    movdqa      xmm1, xmm0
+    movdqa      xmm3, xmm7
+    pmaddwd     xmm0, [rel PW_MF060_MF089]  ; xmm0=tmp0L
+    pmaddwd     xmm7, [rel PW_MF060_MF089]  ; xmm7=tmp0H
+    pmaddwd     xmm1, [rel PW_MF089_F060]   ; xmm1=tmp3L
+    pmaddwd     xmm3, [rel PW_MF089_F060]   ; xmm3=tmp3H
+
+    paddd       xmm0, XMMWORD [wk(10)]  ; xmm0=tmp0L
+    paddd       xmm7, XMMWORD [wk(11)]  ; xmm7=tmp0H
+    paddd       xmm1, xmm5              ; xmm1=tmp3L
+    paddd       xmm3, xmm4              ; xmm3=tmp3H
+
+    movdqa      XMMWORD [wk(8)], xmm0   ; wk(8)=tmp0L
+    movdqa      XMMWORD [wk(9)], xmm7   ; wk(9)=tmp0H
+
+    movdqa      xmm0, xmm2
+    movdqa      xmm7, xmm2
+    punpcklwd   xmm0, xmm6
+    punpckhwd   xmm7, xmm6
+    movdqa      xmm2, xmm0
+    movdqa      xmm6, xmm7
+    pmaddwd     xmm0, [rel PW_MF050_MF256]  ; xmm0=tmp1L
+    pmaddwd     xmm7, [rel PW_MF050_MF256]  ; xmm7=tmp1H
+    pmaddwd     xmm2, [rel PW_MF256_F050]   ; xmm2=tmp2L
+    pmaddwd     xmm6, [rel PW_MF256_F050]   ; xmm6=tmp2H
+
+    paddd       xmm0, xmm5              ; xmm0=tmp1L
+    paddd       xmm7, xmm4              ; xmm7=tmp1H
+    paddd       xmm2, XMMWORD [wk(10)]  ; xmm2=tmp2L
+    paddd       xmm6, XMMWORD [wk(11)]  ; xmm6=tmp2H
+
+    movdqa      XMMWORD [wk(10)], xmm0  ; wk(10)=tmp1L
+    movdqa      XMMWORD [wk(11)], xmm7  ; wk(11)=tmp1H
+
+    ; -- Final output stage
+
+    movdqa      xmm5, XMMWORD [wk(0)]   ; xmm5=tmp10L
+    movdqa      xmm4, XMMWORD [wk(1)]   ; xmm4=tmp10H
+
+    movdqa      xmm0, xmm5
+    movdqa      xmm7, xmm4
+    paddd       xmm5, xmm1              ; xmm5=data0L
+    paddd       xmm4, xmm3              ; xmm4=data0H
+    psubd       xmm0, xmm1              ; xmm0=data7L
+    psubd       xmm7, xmm3              ; xmm7=data7H
+
+    movdqa      xmm1, [rel PD_DESCALE_P2]  ; xmm1=[rel PD_DESCALE_P2]
+
+    paddd       xmm5, xmm1
+    paddd       xmm4, xmm1
+    psrad       xmm5, DESCALE_P2
+    psrad       xmm4, DESCALE_P2
+    paddd       xmm0, xmm1
+    paddd       xmm7, xmm1
+    psrad       xmm0, DESCALE_P2
+    psrad       xmm7, DESCALE_P2
+
+    packssdw    xmm5, xmm4              ; xmm5=data0=(00 10 20 30 40 50 60 70)
+    packssdw    xmm0, xmm7              ; xmm0=data7=(07 17 27 37 47 57 67 77)
+
+    movdqa      xmm3, XMMWORD [wk(4)]   ; xmm3=tmp11L
+    movdqa      xmm1, XMMWORD [wk(5)]   ; xmm1=tmp11H
+
+    movdqa      xmm4, xmm3
+    movdqa      xmm7, xmm1
+    paddd       xmm3, xmm2              ; xmm3=data1L
+    paddd       xmm1, xmm6              ; xmm1=data1H
+    psubd       xmm4, xmm2              ; xmm4=data6L
+    psubd       xmm7, xmm6              ; xmm7=data6H
+
+    movdqa      xmm2, [rel PD_DESCALE_P2]  ; xmm2=[rel PD_DESCALE_P2]
+
+    paddd       xmm3, xmm2
+    paddd       xmm1, xmm2
+    psrad       xmm3, DESCALE_P2
+    psrad       xmm1, DESCALE_P2
+    paddd       xmm4, xmm2
+    paddd       xmm7, xmm2
+    psrad       xmm4, DESCALE_P2
+    psrad       xmm7, DESCALE_P2
+
+    packssdw    xmm3, xmm1              ; xmm3=data1=(01 11 21 31 41 51 61 71)
+    packssdw    xmm4, xmm7              ; xmm4=data6=(06 16 26 36 46 56 66 76)
+
+    packsswb    xmm5, xmm4              ; xmm5=(00 10 20 30 40 50 60 70 06 16 26 36 46 56 66 76)
+    packsswb    xmm3, xmm0              ; xmm3=(01 11 21 31 41 51 61 71 07 17 27 37 47 57 67 77)
+
+    movdqa      xmm6, XMMWORD [wk(6)]   ; xmm6=tmp12L
+    movdqa      xmm2, XMMWORD [wk(7)]   ; xmm2=tmp12H
+    movdqa      xmm1, XMMWORD [wk(10)]  ; xmm1=tmp1L
+    movdqa      xmm7, XMMWORD [wk(11)]  ; xmm7=tmp1H
+
+    movdqa      XMMWORD [wk(0)], xmm5   ; wk(0)=(00 10 20 30 40 50 60 70 06 16 26 36 46 56 66 76)
+    movdqa      XMMWORD [wk(1)], xmm3   ; wk(1)=(01 11 21 31 41 51 61 71 07 17 27 37 47 57 67 77)
+
+    movdqa      xmm4, xmm6
+    movdqa      xmm0, xmm2
+    paddd       xmm6, xmm1              ; xmm6=data2L
+    paddd       xmm2, xmm7              ; xmm2=data2H
+    psubd       xmm4, xmm1              ; xmm4=data5L
+    psubd       xmm0, xmm7              ; xmm0=data5H
+
+    movdqa      xmm5, [rel PD_DESCALE_P2]  ; xmm5=[rel PD_DESCALE_P2]
+
+    paddd       xmm6, xmm5
+    paddd       xmm2, xmm5
+    psrad       xmm6, DESCALE_P2
+    psrad       xmm2, DESCALE_P2
+    paddd       xmm4, xmm5
+    paddd       xmm0, xmm5
+    psrad       xmm4, DESCALE_P2
+    psrad       xmm0, DESCALE_P2
+
+    packssdw    xmm6, xmm2              ; xmm6=data2=(02 12 22 32 42 52 62 72)
+    packssdw    xmm4, xmm0              ; xmm4=data5=(05 15 25 35 45 55 65 75)
+
+    movdqa      xmm3, XMMWORD [wk(2)]   ; xmm3=tmp13L
+    movdqa      xmm1, XMMWORD [wk(3)]   ; xmm1=tmp13H
+    movdqa      xmm7, XMMWORD [wk(8)]   ; xmm7=tmp0L
+    movdqa      xmm5, XMMWORD [wk(9)]   ; xmm5=tmp0H
+
+    movdqa      xmm2, xmm3
+    movdqa      xmm0, xmm1
+    paddd       xmm3, xmm7              ; xmm3=data3L
+    paddd       xmm1, xmm5              ; xmm1=data3H
+    psubd       xmm2, xmm7              ; xmm2=data4L
+    psubd       xmm0, xmm5              ; xmm0=data4H
+
+    movdqa      xmm7, [rel PD_DESCALE_P2]  ; xmm7=[rel PD_DESCALE_P2]
+
+    paddd       xmm3, xmm7
+    paddd       xmm1, xmm7
+    psrad       xmm3, DESCALE_P2
+    psrad       xmm1, DESCALE_P2
+    paddd       xmm2, xmm7
+    paddd       xmm0, xmm7
+    psrad       xmm2, DESCALE_P2
+    psrad       xmm0, DESCALE_P2
+
+    movdqa      xmm5, [rel PB_CENTERJSAMP]  ; xmm5=[rel PB_CENTERJSAMP]
+
+    packssdw    xmm3, xmm1             ; xmm3=data3=(03 13 23 33 43 53 63 73)
+    packssdw    xmm2, xmm0             ; xmm2=data4=(04 14 24 34 44 54 64 74)
+
+    movdqa      xmm7, XMMWORD [wk(0)]  ; xmm7=(00 10 20 30 40 50 60 70 06 16 26 36 46 56 66 76)
+    movdqa      xmm1, XMMWORD [wk(1)]  ; xmm1=(01 11 21 31 41 51 61 71 07 17 27 37 47 57 67 77)
+
+    packsswb    xmm6, xmm2             ; xmm6=(02 12 22 32 42 52 62 72 04 14 24 34 44 54 64 74)
+    packsswb    xmm3, xmm4             ; xmm3=(03 13 23 33 43 53 63 73 05 15 25 35 45 55 65 75)
+
+    paddb       xmm7, xmm5
+    paddb       xmm1, xmm5
+    paddb       xmm6, xmm5
+    paddb       xmm3, xmm5
+
+    movdqa      xmm0, xmm7        ; transpose coefficients(phase 1)
+    punpcklbw   xmm7, xmm1        ; xmm7=(00 01 10 11 20 21 30 31 40 41 50 51 60 61 70 71)
+    punpckhbw   xmm0, xmm1        ; xmm0=(06 07 16 17 26 27 36 37 46 47 56 57 66 67 76 77)
+    movdqa      xmm2, xmm6        ; transpose coefficients(phase 1)
+    punpcklbw   xmm6, xmm3        ; xmm6=(02 03 12 13 22 23 32 33 42 43 52 53 62 63 72 73)
+    punpckhbw   xmm2, xmm3        ; xmm2=(04 05 14 15 24 25 34 35 44 45 54 55 64 65 74 75)
+
+    movdqa      xmm4, xmm7        ; transpose coefficients(phase 2)
+    punpcklwd   xmm7, xmm6        ; xmm7=(00 01 02 03 10 11 12 13 20 21 22 23 30 31 32 33)
+    punpckhwd   xmm4, xmm6        ; xmm4=(40 41 42 43 50 51 52 53 60 61 62 63 70 71 72 73)
+    movdqa      xmm5, xmm2        ; transpose coefficients(phase 2)
+    punpcklwd   xmm2, xmm0        ; xmm2=(04 05 06 07 14 15 16 17 24 25 26 27 34 35 36 37)
+    punpckhwd   xmm5, xmm0        ; xmm5=(44 45 46 47 54 55 56 57 64 65 66 67 74 75 76 77)
+
+    movdqa      xmm1, xmm7        ; transpose coefficients(phase 3)
+    punpckldq   xmm7, xmm2        ; xmm7=(00 01 02 03 04 05 06 07 10 11 12 13 14 15 16 17)
+    punpckhdq   xmm1, xmm2        ; xmm1=(20 21 22 23 24 25 26 27 30 31 32 33 34 35 36 37)
+    movdqa      xmm3, xmm4        ; transpose coefficients(phase 3)
+    punpckldq   xmm4, xmm5        ; xmm4=(40 41 42 43 44 45 46 47 50 51 52 53 54 55 56 57)
+    punpckhdq   xmm3, xmm5        ; xmm3=(60 61 62 63 64 65 66 67 70 71 72 73 74 75 76 77)
+
+    pshufd      xmm6, xmm7, 0x4E  ; xmm6=(10 11 12 13 14 15 16 17 00 01 02 03 04 05 06 07)
+    pshufd      xmm0, xmm1, 0x4E  ; xmm0=(30 31 32 33 34 35 36 37 20 21 22 23 24 25 26 27)
+    pshufd      xmm2, xmm4, 0x4E  ; xmm2=(50 51 52 53 54 55 56 57 40 41 42 43 44 45 46 47)
+    pshufd      xmm5, xmm3, 0x4E  ; xmm5=(70 71 72 73 74 75 76 77 60 61 62 63 64 65 66 67)
+
+    mov         rdxp, JSAMPROW [rdi+0*SIZEOF_JSAMPROW]
+    mov         rsip, JSAMPROW [rdi+2*SIZEOF_JSAMPROW]
+    movq        XMM_MMWORD [rdx+rax*SIZEOF_JSAMPLE], xmm7
+    movq        XMM_MMWORD [rsi+rax*SIZEOF_JSAMPLE], xmm1
+    mov         rdxp, JSAMPROW [rdi+4*SIZEOF_JSAMPROW]
+    mov         rsip, JSAMPROW [rdi+6*SIZEOF_JSAMPROW]
+    movq        XMM_MMWORD [rdx+rax*SIZEOF_JSAMPLE], xmm4
+    movq        XMM_MMWORD [rsi+rax*SIZEOF_JSAMPLE], xmm3
+
+    mov         rdxp, JSAMPROW [rdi+1*SIZEOF_JSAMPROW]
+    mov         rsip, JSAMPROW [rdi+3*SIZEOF_JSAMPROW]
+    movq        XMM_MMWORD [rdx+rax*SIZEOF_JSAMPLE], xmm6
+    movq        XMM_MMWORD [rsi+rax*SIZEOF_JSAMPLE], xmm0
+    mov         rdxp, JSAMPROW [rdi+5*SIZEOF_JSAMPROW]
+    mov         rsip, JSAMPROW [rdi+7*SIZEOF_JSAMPROW]
+    movq        XMM_MMWORD [rdx+rax*SIZEOF_JSAMPLE], xmm2
+    movq        XMM_MMWORD [rsi+rax*SIZEOF_JSAMPLE], xmm5
+
+    uncollect_args 4
+    mov         rsp, rbp                ; rsp <- aligned rbp
+    pop         rsp                     ; rsp <- original rbp
+    pop         rbp
+    ret
+
+; For some reason, the OS X linker does not honor the request to align the
+; segment unless we do this.
+    align       32
diff --git a/3rdparty/libjpeg/src/simd/x86_64/jidctred-sse2.asm b/3rdparty/libjpeg/src/simd/x86_64/jidctred-sse2.asm
new file mode 100644
index 00000000..4ece9d89
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/x86_64/jidctred-sse2.asm
@@ -0,0 +1,574 @@
+;
+; jidctred.asm - reduced-size IDCT (64-bit SSE2)
+;
+; Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+; Copyright (C) 2009, 2016, D. R. Commander.
+; Copyright (C) 2018, Matthias Räncker.
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+;
+; This file should be assembled with NASM (Netwide Assembler),
+; can *not* be assembled with Microsoft's MASM or any compatible
+; assembler (including Borland's Turbo Assembler).
+; NASM is available from http://nasm.sourceforge.net/ or
+; http://sourceforge.net/project/showfiles.php?group_id=6208
+;
+; This file contains inverse-DCT routines that produce reduced-size
+; output: either 4x4 or 2x2 pixels from an 8x8 DCT block.
+; The following code is based directly on the IJG's original jidctred.c;
+; see the jidctred.c for more details.
+
+%include "jsimdext.inc"
+%include "jdct.inc"
+
+; --------------------------------------------------------------------------
+
+%define CONST_BITS    13
+%define PASS1_BITS    2
+
+%define DESCALE_P1_4  (CONST_BITS - PASS1_BITS + 1)
+%define DESCALE_P2_4  (CONST_BITS + PASS1_BITS + 3 + 1)
+%define DESCALE_P1_2  (CONST_BITS - PASS1_BITS + 2)
+%define DESCALE_P2_2  (CONST_BITS + PASS1_BITS + 3 + 2)
+
+%if CONST_BITS == 13
+F_0_211 equ  1730  ; FIX(0.211164243)
+F_0_509 equ  4176  ; FIX(0.509795579)
+F_0_601 equ  4926  ; FIX(0.601344887)
+F_0_720 equ  5906  ; FIX(0.720959822)
+F_0_765 equ  6270  ; FIX(0.765366865)
+F_0_850 equ  6967  ; FIX(0.850430095)
+F_0_899 equ  7373  ; FIX(0.899976223)
+F_1_061 equ  8697  ; FIX(1.061594337)
+F_1_272 equ 10426  ; FIX(1.272758580)
+F_1_451 equ 11893  ; FIX(1.451774981)
+F_1_847 equ 15137  ; FIX(1.847759065)
+F_2_172 equ 17799  ; FIX(2.172734803)
+F_2_562 equ 20995  ; FIX(2.562915447)
+F_3_624 equ 29692  ; FIX(3.624509785)
+%else
+; NASM cannot do compile-time arithmetic on floating-point constants.
+%define DESCALE(x, n)  (((x) + (1 << ((n) - 1))) >> (n))
+F_0_211 equ DESCALE( 226735879, 30 - CONST_BITS)  ; FIX(0.211164243)
+F_0_509 equ DESCALE( 547388834, 30 - CONST_BITS)  ; FIX(0.509795579)
+F_0_601 equ DESCALE( 645689155, 30 - CONST_BITS)  ; FIX(0.601344887)
+F_0_720 equ DESCALE( 774124714, 30 - CONST_BITS)  ; FIX(0.720959822)
+F_0_765 equ DESCALE( 821806413, 30 - CONST_BITS)  ; FIX(0.765366865)
+F_0_850 equ DESCALE( 913142361, 30 - CONST_BITS)  ; FIX(0.850430095)
+F_0_899 equ DESCALE( 966342111, 30 - CONST_BITS)  ; FIX(0.899976223)
+F_1_061 equ DESCALE(1139878239, 30 - CONST_BITS)  ; FIX(1.061594337)
+F_1_272 equ DESCALE(1366614119, 30 - CONST_BITS)  ; FIX(1.272758580)
+F_1_451 equ DESCALE(1558831516, 30 - CONST_BITS)  ; FIX(1.451774981)
+F_1_847 equ DESCALE(1984016188, 30 - CONST_BITS)  ; FIX(1.847759065)
+F_2_172 equ DESCALE(2332956230, 30 - CONST_BITS)  ; FIX(2.172734803)
+F_2_562 equ DESCALE(2751909506, 30 - CONST_BITS)  ; FIX(2.562915447)
+F_3_624 equ DESCALE(3891787747, 30 - CONST_BITS)  ; FIX(3.624509785)
+%endif
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_CONST
+
+    alignz      32
+    GLOBAL_DATA(jconst_idct_red_sse2)
+
+EXTN(jconst_idct_red_sse2):
+
+PW_F184_MF076   times 4  dw  F_1_847, -F_0_765
+PW_F256_F089    times 4  dw  F_2_562,  F_0_899
+PW_F106_MF217   times 4  dw  F_1_061, -F_2_172
+PW_MF060_MF050  times 4  dw -F_0_601, -F_0_509
+PW_F145_MF021   times 4  dw  F_1_451, -F_0_211
+PW_F362_MF127   times 4  dw  F_3_624, -F_1_272
+PW_F085_MF072   times 4  dw  F_0_850, -F_0_720
+PD_DESCALE_P1_4 times 4  dd  1 << (DESCALE_P1_4 - 1)
+PD_DESCALE_P2_4 times 4  dd  1 << (DESCALE_P2_4 - 1)
+PD_DESCALE_P1_2 times 4  dd  1 << (DESCALE_P1_2 - 1)
+PD_DESCALE_P2_2 times 4  dd  1 << (DESCALE_P2_2 - 1)
+PB_CENTERJSAMP  times 16 db  CENTERJSAMPLE
+
+    alignz      32
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_TEXT
+    BITS        64
+;
+; Perform dequantization and inverse DCT on one block of coefficients,
+; producing a reduced-size 4x4 output block.
+;
+; GLOBAL(void)
+; jsimd_idct_4x4_sse2(void *dct_table, JCOEFPTR coef_block,
+;                     JSAMPARRAY output_buf, JDIMENSION output_col)
+;
+
+; r10 = void *dct_table
+; r11 = JCOEFPTR coef_block
+; r12 = JSAMPARRAY output_buf
+; r13d = JDIMENSION output_col
+
+%define original_rbp  rbp + 0
+%define wk(i)         rbp - (WK_NUM - (i)) * SIZEOF_XMMWORD
+                                        ; xmmword wk[WK_NUM]
+%define WK_NUM        2
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_idct_4x4_sse2)
+
+EXTN(jsimd_idct_4x4_sse2):
+    push        rbp
+    mov         rax, rsp                     ; rax = original rbp
+    sub         rsp, byte 4
+    and         rsp, byte (-SIZEOF_XMMWORD)  ; align to 128 bits
+    mov         [rsp], rax
+    mov         rbp, rsp                     ; rbp = aligned rbp
+    lea         rsp, [wk(0)]
+    collect_args 4
+
+    ; ---- Pass 1: process columns from input.
+
+    mov         rdx, r10                ; quantptr
+    mov         rsi, r11                ; inptr
+
+%ifndef NO_ZERO_COLUMN_TEST_4X4_SSE2
+    mov         eax, dword [DWBLOCK(1,0,rsi,SIZEOF_JCOEF)]
+    or          eax, dword [DWBLOCK(2,0,rsi,SIZEOF_JCOEF)]
+    jnz         short .columnDCT
+
+    movdqa      xmm0, XMMWORD [XMMBLOCK(1,0,rsi,SIZEOF_JCOEF)]
+    movdqa      xmm1, XMMWORD [XMMBLOCK(2,0,rsi,SIZEOF_JCOEF)]
+    por         xmm0, XMMWORD [XMMBLOCK(3,0,rsi,SIZEOF_JCOEF)]
+    por         xmm1, XMMWORD [XMMBLOCK(5,0,rsi,SIZEOF_JCOEF)]
+    por         xmm0, XMMWORD [XMMBLOCK(6,0,rsi,SIZEOF_JCOEF)]
+    por         xmm1, XMMWORD [XMMBLOCK(7,0,rsi,SIZEOF_JCOEF)]
+    por         xmm0, xmm1
+    packsswb    xmm0, xmm0
+    packsswb    xmm0, xmm0
+    movd        eax, xmm0
+    test        rax, rax
+    jnz         short .columnDCT
+
+    ; -- AC terms all zero
+
+    movdqa      xmm0, XMMWORD [XMMBLOCK(0,0,rsi,SIZEOF_JCOEF)]
+    pmullw      xmm0, XMMWORD [XMMBLOCK(0,0,rdx,SIZEOF_ISLOW_MULT_TYPE)]
+
+    psllw       xmm0, PASS1_BITS
+
+    movdqa      xmm3, xmm0        ; xmm0=in0=(00 01 02 03 04 05 06 07)
+    punpcklwd   xmm0, xmm0        ; xmm0=(00 00 01 01 02 02 03 03)
+    punpckhwd   xmm3, xmm3        ; xmm3=(04 04 05 05 06 06 07 07)
+
+    pshufd      xmm1, xmm0, 0x50  ; xmm1=[col0 col1]=(00 00 00 00 01 01 01 01)
+    pshufd      xmm0, xmm0, 0xFA  ; xmm0=[col2 col3]=(02 02 02 02 03 03 03 03)
+    pshufd      xmm6, xmm3, 0x50  ; xmm6=[col4 col5]=(04 04 04 04 05 05 05 05)
+    pshufd      xmm3, xmm3, 0xFA  ; xmm3=[col6 col7]=(06 06 06 06 07 07 07 07)
+
+    jmp         near .column_end
+%endif
+.columnDCT:
+
+    ; -- Odd part
+
+    movdqa      xmm0, XMMWORD [XMMBLOCK(1,0,rsi,SIZEOF_JCOEF)]
+    movdqa      xmm1, XMMWORD [XMMBLOCK(3,0,rsi,SIZEOF_JCOEF)]
+    pmullw      xmm0, XMMWORD [XMMBLOCK(1,0,rdx,SIZEOF_ISLOW_MULT_TYPE)]
+    pmullw      xmm1, XMMWORD [XMMBLOCK(3,0,rdx,SIZEOF_ISLOW_MULT_TYPE)]
+    movdqa      xmm2, XMMWORD [XMMBLOCK(5,0,rsi,SIZEOF_JCOEF)]
+    movdqa      xmm3, XMMWORD [XMMBLOCK(7,0,rsi,SIZEOF_JCOEF)]
+    pmullw      xmm2, XMMWORD [XMMBLOCK(5,0,rdx,SIZEOF_ISLOW_MULT_TYPE)]
+    pmullw      xmm3, XMMWORD [XMMBLOCK(7,0,rdx,SIZEOF_ISLOW_MULT_TYPE)]
+
+    movdqa      xmm4, xmm0
+    movdqa      xmm5, xmm0
+    punpcklwd   xmm4, xmm1
+    punpckhwd   xmm5, xmm1
+    movdqa      xmm0, xmm4
+    movdqa      xmm1, xmm5
+    pmaddwd     xmm4, [rel PW_F256_F089]   ; xmm4=(tmp2L)
+    pmaddwd     xmm5, [rel PW_F256_F089]   ; xmm5=(tmp2H)
+    pmaddwd     xmm0, [rel PW_F106_MF217]  ; xmm0=(tmp0L)
+    pmaddwd     xmm1, [rel PW_F106_MF217]  ; xmm1=(tmp0H)
+
+    movdqa      xmm6, xmm2
+    movdqa      xmm7, xmm2
+    punpcklwd   xmm6, xmm3
+    punpckhwd   xmm7, xmm3
+    movdqa      xmm2, xmm6
+    movdqa      xmm3, xmm7
+    pmaddwd     xmm6, [rel PW_MF060_MF050]  ; xmm6=(tmp2L)
+    pmaddwd     xmm7, [rel PW_MF060_MF050]  ; xmm7=(tmp2H)
+    pmaddwd     xmm2, [rel PW_F145_MF021]   ; xmm2=(tmp0L)
+    pmaddwd     xmm3, [rel PW_F145_MF021]   ; xmm3=(tmp0H)
+
+    paddd       xmm6, xmm4              ; xmm6=tmp2L
+    paddd       xmm7, xmm5              ; xmm7=tmp2H
+    paddd       xmm2, xmm0              ; xmm2=tmp0L
+    paddd       xmm3, xmm1              ; xmm3=tmp0H
+
+    movdqa      XMMWORD [wk(0)], xmm2   ; wk(0)=tmp0L
+    movdqa      XMMWORD [wk(1)], xmm3   ; wk(1)=tmp0H
+
+    ; -- Even part
+
+    movdqa      xmm4, XMMWORD [XMMBLOCK(0,0,rsi,SIZEOF_JCOEF)]
+    movdqa      xmm5, XMMWORD [XMMBLOCK(2,0,rsi,SIZEOF_JCOEF)]
+    movdqa      xmm0, XMMWORD [XMMBLOCK(6,0,rsi,SIZEOF_JCOEF)]
+    pmullw      xmm4, XMMWORD [XMMBLOCK(0,0,rdx,SIZEOF_ISLOW_MULT_TYPE)]
+    pmullw      xmm5, XMMWORD [XMMBLOCK(2,0,rdx,SIZEOF_ISLOW_MULT_TYPE)]
+    pmullw      xmm0, XMMWORD [XMMBLOCK(6,0,rdx,SIZEOF_ISLOW_MULT_TYPE)]
+
+    pxor        xmm1, xmm1
+    pxor        xmm2, xmm2
+    punpcklwd   xmm1, xmm4               ; xmm1=tmp0L
+    punpckhwd   xmm2, xmm4               ; xmm2=tmp0H
+    psrad       xmm1, (16-CONST_BITS-1)  ; psrad xmm1,16 & pslld xmm1,CONST_BITS+1
+    psrad       xmm2, (16-CONST_BITS-1)  ; psrad xmm2,16 & pslld xmm2,CONST_BITS+1
+
+    movdqa      xmm3, xmm5              ; xmm5=in2=z2
+    punpcklwd   xmm5, xmm0              ; xmm0=in6=z3
+    punpckhwd   xmm3, xmm0
+    pmaddwd     xmm5, [rel PW_F184_MF076]  ; xmm5=tmp2L
+    pmaddwd     xmm3, [rel PW_F184_MF076]  ; xmm3=tmp2H
+
+    movdqa      xmm4, xmm1
+    movdqa      xmm0, xmm2
+    paddd       xmm1, xmm5              ; xmm1=tmp10L
+    paddd       xmm2, xmm3              ; xmm2=tmp10H
+    psubd       xmm4, xmm5              ; xmm4=tmp12L
+    psubd       xmm0, xmm3              ; xmm0=tmp12H
+
+    ; -- Final output stage
+
+    movdqa      xmm5, xmm1
+    movdqa      xmm3, xmm2
+    paddd       xmm1, xmm6              ; xmm1=data0L
+    paddd       xmm2, xmm7              ; xmm2=data0H
+    psubd       xmm5, xmm6              ; xmm5=data3L
+    psubd       xmm3, xmm7              ; xmm3=data3H
+
+    movdqa      xmm6, [rel PD_DESCALE_P1_4]  ; xmm6=[rel PD_DESCALE_P1_4]
+
+    paddd       xmm1, xmm6
+    paddd       xmm2, xmm6
+    psrad       xmm1, DESCALE_P1_4
+    psrad       xmm2, DESCALE_P1_4
+    paddd       xmm5, xmm6
+    paddd       xmm3, xmm6
+    psrad       xmm5, DESCALE_P1_4
+    psrad       xmm3, DESCALE_P1_4
+
+    packssdw    xmm1, xmm2              ; xmm1=data0=(00 01 02 03 04 05 06 07)
+    packssdw    xmm5, xmm3              ; xmm5=data3=(30 31 32 33 34 35 36 37)
+
+    movdqa      xmm7, XMMWORD [wk(0)]   ; xmm7=tmp0L
+    movdqa      xmm6, XMMWORD [wk(1)]   ; xmm6=tmp0H
+
+    movdqa      xmm2, xmm4
+    movdqa      xmm3, xmm0
+    paddd       xmm4, xmm7              ; xmm4=data1L
+    paddd       xmm0, xmm6              ; xmm0=data1H
+    psubd       xmm2, xmm7              ; xmm2=data2L
+    psubd       xmm3, xmm6              ; xmm3=data2H
+
+    movdqa      xmm7, [rel PD_DESCALE_P1_4]  ; xmm7=[rel PD_DESCALE_P1_4]
+
+    paddd       xmm4, xmm7
+    paddd       xmm0, xmm7
+    psrad       xmm4, DESCALE_P1_4
+    psrad       xmm0, DESCALE_P1_4
+    paddd       xmm2, xmm7
+    paddd       xmm3, xmm7
+    psrad       xmm2, DESCALE_P1_4
+    psrad       xmm3, DESCALE_P1_4
+
+    packssdw    xmm4, xmm0        ; xmm4=data1=(10 11 12 13 14 15 16 17)
+    packssdw    xmm2, xmm3        ; xmm2=data2=(20 21 22 23 24 25 26 27)
+
+    movdqa      xmm6, xmm1        ; transpose coefficients(phase 1)
+    punpcklwd   xmm1, xmm4        ; xmm1=(00 10 01 11 02 12 03 13)
+    punpckhwd   xmm6, xmm4        ; xmm6=(04 14 05 15 06 16 07 17)
+    movdqa      xmm7, xmm2        ; transpose coefficients(phase 1)
+    punpcklwd   xmm2, xmm5        ; xmm2=(20 30 21 31 22 32 23 33)
+    punpckhwd   xmm7, xmm5        ; xmm7=(24 34 25 35 26 36 27 37)
+
+    movdqa      xmm0, xmm1        ; transpose coefficients(phase 2)
+    punpckldq   xmm1, xmm2        ; xmm1=[col0 col1]=(00 10 20 30 01 11 21 31)
+    punpckhdq   xmm0, xmm2        ; xmm0=[col2 col3]=(02 12 22 32 03 13 23 33)
+    movdqa      xmm3, xmm6        ; transpose coefficients(phase 2)
+    punpckldq   xmm6, xmm7        ; xmm6=[col4 col5]=(04 14 24 34 05 15 25 35)
+    punpckhdq   xmm3, xmm7        ; xmm3=[col6 col7]=(06 16 26 36 07 17 27 37)
+.column_end:
+
+    ; -- Prefetch the next coefficient block
+
+    prefetchnta [rsi + DCTSIZE2*SIZEOF_JCOEF + 0*32]
+    prefetchnta [rsi + DCTSIZE2*SIZEOF_JCOEF + 1*32]
+    prefetchnta [rsi + DCTSIZE2*SIZEOF_JCOEF + 2*32]
+    prefetchnta [rsi + DCTSIZE2*SIZEOF_JCOEF + 3*32]
+
+    ; ---- Pass 2: process rows, store into output array.
+
+    mov         rax, [original_rbp]
+    mov         rdi, r12                ; (JSAMPROW *)
+    mov         eax, r13d
+
+    ; -- Even part
+
+    pxor        xmm4, xmm4
+    punpcklwd   xmm4, xmm1               ; xmm4=tmp0
+    psrad       xmm4, (16-CONST_BITS-1)  ; psrad xmm4,16 & pslld xmm4,CONST_BITS+1
+
+    ; -- Odd part
+
+    punpckhwd   xmm1, xmm0
+    punpckhwd   xmm6, xmm3
+    movdqa      xmm5, xmm1
+    movdqa      xmm2, xmm6
+    pmaddwd     xmm1, [rel PW_F256_F089]    ; xmm1=(tmp2)
+    pmaddwd     xmm6, [rel PW_MF060_MF050]  ; xmm6=(tmp2)
+    pmaddwd     xmm5, [rel PW_F106_MF217]   ; xmm5=(tmp0)
+    pmaddwd     xmm2, [rel PW_F145_MF021]   ; xmm2=(tmp0)
+
+    paddd       xmm6, xmm1              ; xmm6=tmp2
+    paddd       xmm2, xmm5              ; xmm2=tmp0
+
+    ; -- Even part
+
+    punpcklwd   xmm0, xmm3
+    pmaddwd     xmm0, [rel PW_F184_MF076]  ; xmm0=tmp2
+
+    movdqa      xmm7, xmm4
+    paddd       xmm4, xmm0              ; xmm4=tmp10
+    psubd       xmm7, xmm0              ; xmm7=tmp12
+
+    ; -- Final output stage
+
+    movdqa      xmm1, [rel PD_DESCALE_P2_4]  ; xmm1=[rel PD_DESCALE_P2_4]
+
+    movdqa      xmm5, xmm4
+    movdqa      xmm3, xmm7
+    paddd       xmm4, xmm6              ; xmm4=data0=(00 10 20 30)
+    paddd       xmm7, xmm2              ; xmm7=data1=(01 11 21 31)
+    psubd       xmm5, xmm6              ; xmm5=data3=(03 13 23 33)
+    psubd       xmm3, xmm2              ; xmm3=data2=(02 12 22 32)
+
+    paddd       xmm4, xmm1
+    paddd       xmm7, xmm1
+    psrad       xmm4, DESCALE_P2_4
+    psrad       xmm7, DESCALE_P2_4
+    paddd       xmm5, xmm1
+    paddd       xmm3, xmm1
+    psrad       xmm5, DESCALE_P2_4
+    psrad       xmm3, DESCALE_P2_4
+
+    packssdw    xmm4, xmm3              ; xmm4=(00 10 20 30 02 12 22 32)
+    packssdw    xmm7, xmm5              ; xmm7=(01 11 21 31 03 13 23 33)
+
+    movdqa      xmm0, xmm4              ; transpose coefficients(phase 1)
+    punpcklwd   xmm4, xmm7              ; xmm4=(00 01 10 11 20 21 30 31)
+    punpckhwd   xmm0, xmm7              ; xmm0=(02 03 12 13 22 23 32 33)
+
+    movdqa      xmm6, xmm4              ; transpose coefficients(phase 2)
+    punpckldq   xmm4, xmm0              ; xmm4=(00 01 02 03 10 11 12 13)
+    punpckhdq   xmm6, xmm0              ; xmm6=(20 21 22 23 30 31 32 33)
+
+    packsswb    xmm4, xmm6              ; xmm4=(00 01 02 03 10 11 12 13 20 ..)
+    paddb       xmm4, [rel PB_CENTERJSAMP]
+
+    pshufd      xmm2, xmm4, 0x39        ; xmm2=(10 11 12 13 20 21 22 23 30 ..)
+    pshufd      xmm1, xmm4, 0x4E        ; xmm1=(20 21 22 23 30 31 32 33 00 ..)
+    pshufd      xmm3, xmm4, 0x93        ; xmm3=(30 31 32 33 00 01 02 03 10 ..)
+
+    mov         rdxp, JSAMPROW [rdi+0*SIZEOF_JSAMPROW]
+    mov         rsip, JSAMPROW [rdi+1*SIZEOF_JSAMPROW]
+    movd        XMM_DWORD [rdx+rax*SIZEOF_JSAMPLE], xmm4
+    movd        XMM_DWORD [rsi+rax*SIZEOF_JSAMPLE], xmm2
+    mov         rdxp, JSAMPROW [rdi+2*SIZEOF_JSAMPROW]
+    mov         rsip, JSAMPROW [rdi+3*SIZEOF_JSAMPROW]
+    movd        XMM_DWORD [rdx+rax*SIZEOF_JSAMPLE], xmm1
+    movd        XMM_DWORD [rsi+rax*SIZEOF_JSAMPLE], xmm3
+
+    uncollect_args 4
+    mov         rsp, rbp                ; rsp <- aligned rbp
+    pop         rsp                     ; rsp <- original rbp
+    pop         rbp
+    ret
+
+; --------------------------------------------------------------------------
+;
+; Perform dequantization and inverse DCT on one block of coefficients,
+; producing a reduced-size 2x2 output block.
+;
+; GLOBAL(void)
+; jsimd_idct_2x2_sse2(void *dct_table, JCOEFPTR coef_block,
+;                     JSAMPARRAY output_buf, JDIMENSION output_col)
+;
+
+; r10 = void *dct_table
+; r11 = JCOEFPTR coef_block
+; r12 = JSAMPARRAY output_buf
+; r13d = JDIMENSION output_col
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_idct_2x2_sse2)
+
+EXTN(jsimd_idct_2x2_sse2):
+    push        rbp
+    mov         rax, rsp
+    mov         rbp, rsp
+    collect_args 4
+    push        rbx
+
+    ; ---- Pass 1: process columns from input.
+
+    mov         rdx, r10                ; quantptr
+    mov         rsi, r11                ; inptr
+
+    ; | input:                  | result:        |
+    ; | 00 01 ** 03 ** 05 ** 07 |                |
+    ; | 10 11 ** 13 ** 15 ** 17 |                |
+    ; | ** ** ** ** ** ** ** ** |                |
+    ; | 30 31 ** 33 ** 35 ** 37 | A0 A1 A3 A5 A7 |
+    ; | ** ** ** ** ** ** ** ** | B0 B1 B3 B5 B7 |
+    ; | 50 51 ** 53 ** 55 ** 57 |                |
+    ; | ** ** ** ** ** ** ** ** |                |
+    ; | 70 71 ** 73 ** 75 ** 77 |                |
+
+    ; -- Odd part
+
+    movdqa      xmm0, XMMWORD [XMMBLOCK(1,0,rsi,SIZEOF_JCOEF)]
+    movdqa      xmm1, XMMWORD [XMMBLOCK(3,0,rsi,SIZEOF_JCOEF)]
+    pmullw      xmm0, XMMWORD [XMMBLOCK(1,0,rdx,SIZEOF_ISLOW_MULT_TYPE)]
+    pmullw      xmm1, XMMWORD [XMMBLOCK(3,0,rdx,SIZEOF_ISLOW_MULT_TYPE)]
+    movdqa      xmm2, XMMWORD [XMMBLOCK(5,0,rsi,SIZEOF_JCOEF)]
+    movdqa      xmm3, XMMWORD [XMMBLOCK(7,0,rsi,SIZEOF_JCOEF)]
+    pmullw      xmm2, XMMWORD [XMMBLOCK(5,0,rdx,SIZEOF_ISLOW_MULT_TYPE)]
+    pmullw      xmm3, XMMWORD [XMMBLOCK(7,0,rdx,SIZEOF_ISLOW_MULT_TYPE)]
+
+    ; xmm0=(10 11 ** 13 ** 15 ** 17), xmm1=(30 31 ** 33 ** 35 ** 37)
+    ; xmm2=(50 51 ** 53 ** 55 ** 57), xmm3=(70 71 ** 73 ** 75 ** 77)
+
+    pcmpeqd     xmm7, xmm7
+    pslld       xmm7, WORD_BIT          ; xmm7={0x0000 0xFFFF 0x0000 0xFFFF ..}
+
+    movdqa      xmm4, xmm0              ; xmm4=(10 11 ** 13 ** 15 ** 17)
+    movdqa      xmm5, xmm2              ; xmm5=(50 51 ** 53 ** 55 ** 57)
+    punpcklwd   xmm4, xmm1              ; xmm4=(10 30 11 31 ** ** 13 33)
+    punpcklwd   xmm5, xmm3              ; xmm5=(50 70 51 71 ** ** 53 73)
+    pmaddwd     xmm4, [rel PW_F362_MF127]
+    pmaddwd     xmm5, [rel PW_F085_MF072]
+
+    psrld       xmm0, WORD_BIT          ; xmm0=(11 -- 13 -- 15 -- 17 --)
+    pand        xmm1, xmm7              ; xmm1=(-- 31 -- 33 -- 35 -- 37)
+    psrld       xmm2, WORD_BIT          ; xmm2=(51 -- 53 -- 55 -- 57 --)
+    pand        xmm3, xmm7              ; xmm3=(-- 71 -- 73 -- 75 -- 77)
+    por         xmm0, xmm1              ; xmm0=(11 31 13 33 15 35 17 37)
+    por         xmm2, xmm3              ; xmm2=(51 71 53 73 55 75 57 77)
+    pmaddwd     xmm0, [rel PW_F362_MF127]
+    pmaddwd     xmm2, [rel PW_F085_MF072]
+
+    paddd       xmm4, xmm5              ; xmm4=tmp0[col0 col1 **** col3]
+    paddd       xmm0, xmm2              ; xmm0=tmp0[col1 col3 col5 col7]
+
+    ; -- Even part
+
+    movdqa      xmm6, XMMWORD [XMMBLOCK(0,0,rsi,SIZEOF_JCOEF)]
+    pmullw      xmm6, XMMWORD [XMMBLOCK(0,0,rdx,SIZEOF_ISLOW_MULT_TYPE)]
+
+    ; xmm6=(00 01 ** 03 ** 05 ** 07)
+
+    movdqa      xmm1, xmm6              ; xmm1=(00 01 ** 03 ** 05 ** 07)
+    pslld       xmm6, WORD_BIT          ; xmm6=(-- 00 -- ** -- ** -- **)
+    pand        xmm1, xmm7              ; xmm1=(-- 01 -- 03 -- 05 -- 07)
+    psrad       xmm6, (WORD_BIT-CONST_BITS-2)  ; xmm6=tmp10[col0 **** **** ****]
+    psrad       xmm1, (WORD_BIT-CONST_BITS-2)  ; xmm1=tmp10[col1 col3 col5 col7]
+
+    ; -- Final output stage
+
+    movdqa      xmm3, xmm6
+    movdqa      xmm5, xmm1
+    paddd       xmm6, xmm4      ; xmm6=data0[col0 **** **** ****]=(A0 ** ** **)
+    paddd       xmm1, xmm0      ; xmm1=data0[col1 col3 col5 col7]=(A1 A3 A5 A7)
+    psubd       xmm3, xmm4      ; xmm3=data1[col0 **** **** ****]=(B0 ** ** **)
+    psubd       xmm5, xmm0      ; xmm5=data1[col1 col3 col5 col7]=(B1 B3 B5 B7)
+
+    movdqa      xmm2, [rel PD_DESCALE_P1_2]  ; xmm2=[rel PD_DESCALE_P1_2]
+
+    punpckldq   xmm6, xmm3              ; xmm6=(A0 B0 ** **)
+
+    movdqa      xmm7, xmm1
+    punpcklqdq  xmm1, xmm5              ; xmm1=(A1 A3 B1 B3)
+    punpckhqdq  xmm7, xmm5              ; xmm7=(A5 A7 B5 B7)
+
+    paddd       xmm6, xmm2
+    psrad       xmm6, DESCALE_P1_2
+
+    paddd       xmm1, xmm2
+    paddd       xmm7, xmm2
+    psrad       xmm1, DESCALE_P1_2
+    psrad       xmm7, DESCALE_P1_2
+
+    ; -- Prefetch the next coefficient block
+
+    prefetchnta [rsi + DCTSIZE2*SIZEOF_JCOEF + 0*32]
+    prefetchnta [rsi + DCTSIZE2*SIZEOF_JCOEF + 1*32]
+    prefetchnta [rsi + DCTSIZE2*SIZEOF_JCOEF + 2*32]
+    prefetchnta [rsi + DCTSIZE2*SIZEOF_JCOEF + 3*32]
+
+    ; ---- Pass 2: process rows, store into output array.
+
+    mov         rdi, r12                ; (JSAMPROW *)
+    mov         eax, r13d
+
+    ; | input:| result:|
+    ; | A0 B0 |        |
+    ; | A1 B1 | C0 C1  |
+    ; | A3 B3 | D0 D1  |
+    ; | A5 B5 |        |
+    ; | A7 B7 |        |
+
+    ; -- Odd part
+
+    packssdw    xmm1, xmm1              ; xmm1=(A1 A3 B1 B3 A1 A3 B1 B3)
+    packssdw    xmm7, xmm7              ; xmm7=(A5 A7 B5 B7 A5 A7 B5 B7)
+    pmaddwd     xmm1, [rel PW_F362_MF127]
+    pmaddwd     xmm7, [rel PW_F085_MF072]
+
+    paddd       xmm1, xmm7              ; xmm1=tmp0[row0 row1 row0 row1]
+
+    ; -- Even part
+
+    pslld       xmm6, (CONST_BITS+2)    ; xmm6=tmp10[row0 row1 **** ****]
+
+    ; -- Final output stage
+
+    movdqa      xmm4, xmm6
+    paddd       xmm6, xmm1     ; xmm6=data0[row0 row1 **** ****]=(C0 C1 ** **)
+    psubd       xmm4, xmm1     ; xmm4=data1[row0 row1 **** ****]=(D0 D1 ** **)
+
+    punpckldq   xmm6, xmm4     ; xmm6=(C0 D0 C1 D1)
+
+    paddd       xmm6, [rel PD_DESCALE_P2_2]
+    psrad       xmm6, DESCALE_P2_2
+
+    packssdw    xmm6, xmm6              ; xmm6=(C0 D0 C1 D1 C0 D0 C1 D1)
+    packsswb    xmm6, xmm6              ; xmm6=(C0 D0 C1 D1 C0 D0 C1 D1 ..)
+    paddb       xmm6, [rel PB_CENTERJSAMP]
+
+    pextrw      ebx, xmm6, 0x00         ; ebx=(C0 D0 -- --)
+    pextrw      ecx, xmm6, 0x01         ; ecx=(C1 D1 -- --)
+
+    mov         rdxp, JSAMPROW [rdi+0*SIZEOF_JSAMPROW]
+    mov         rsip, JSAMPROW [rdi+1*SIZEOF_JSAMPROW]
+    mov         word [rdx+rax*SIZEOF_JSAMPLE], bx
+    mov         word [rsi+rax*SIZEOF_JSAMPLE], cx
+
+    pop         rbx
+    uncollect_args 4
+    pop         rbp
+    ret
+
+; For some reason, the OS X linker does not honor the request to align the
+; segment unless we do this.
+    align       32
diff --git a/3rdparty/libjpeg/src/simd/x86_64/jquantf-sse2.asm b/3rdparty/libjpeg/src/simd/x86_64/jquantf-sse2.asm
new file mode 100644
index 00000000..ab2e3954
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/x86_64/jquantf-sse2.asm
@@ -0,0 +1,155 @@
+;
+; jquantf.asm - sample data conversion and quantization (64-bit SSE & SSE2)
+;
+; Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+; Copyright (C) 2009, 2016, D. R. Commander.
+; Copyright (C) 2018, Matthias Räncker.
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+;
+; This file should be assembled with NASM (Netwide Assembler),
+; can *not* be assembled with Microsoft's MASM or any compatible
+; assembler (including Borland's Turbo Assembler).
+; NASM is available from http://nasm.sourceforge.net/ or
+; http://sourceforge.net/project/showfiles.php?group_id=6208
+
+%include "jsimdext.inc"
+%include "jdct.inc"
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_TEXT
+    BITS        64
+;
+; Load data into workspace, applying unsigned->signed conversion
+;
+; GLOBAL(void)
+; jsimd_convsamp_float_sse2(JSAMPARRAY sample_data, JDIMENSION start_col,
+;                           FAST_FLOAT *workspace);
+;
+
+; r10 = JSAMPARRAY sample_data
+; r11d = JDIMENSION start_col
+; r12 = FAST_FLOAT *workspace
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_convsamp_float_sse2)
+
+EXTN(jsimd_convsamp_float_sse2):
+    push        rbp
+    mov         rax, rsp
+    mov         rbp, rsp
+    collect_args 3
+    push        rbx
+
+    pcmpeqw     xmm7, xmm7
+    psllw       xmm7, 7
+    packsswb    xmm7, xmm7              ; xmm7 = PB_CENTERJSAMPLE (0x808080..)
+
+    mov         rsi, r10
+    mov         eax, r11d
+    mov         rdi, r12
+    mov         rcx, DCTSIZE/2
+.convloop:
+    mov         rbxp, JSAMPROW [rsi+0*SIZEOF_JSAMPROW]  ; (JSAMPLE *)
+    mov         rdxp, JSAMPROW [rsi+1*SIZEOF_JSAMPROW]  ; (JSAMPLE *)
+
+    movq        xmm0, XMM_MMWORD [rbx+rax*SIZEOF_JSAMPLE]
+    movq        xmm1, XMM_MMWORD [rdx+rax*SIZEOF_JSAMPLE]
+
+    psubb       xmm0, xmm7              ; xmm0=(01234567)
+    psubb       xmm1, xmm7              ; xmm1=(89ABCDEF)
+
+    punpcklbw   xmm0, xmm0              ; xmm0=(*0*1*2*3*4*5*6*7)
+    punpcklbw   xmm1, xmm1              ; xmm1=(*8*9*A*B*C*D*E*F)
+
+    punpcklwd   xmm2, xmm0              ; xmm2=(***0***1***2***3)
+    punpckhwd   xmm0, xmm0              ; xmm0=(***4***5***6***7)
+    punpcklwd   xmm3, xmm1              ; xmm3=(***8***9***A***B)
+    punpckhwd   xmm1, xmm1              ; xmm1=(***C***D***E***F)
+
+    psrad       xmm2, (DWORD_BIT-BYTE_BIT)  ; xmm2=(0123)
+    psrad       xmm0, (DWORD_BIT-BYTE_BIT)  ; xmm0=(4567)
+    cvtdq2ps    xmm2, xmm2                  ; xmm2=(0123)
+    cvtdq2ps    xmm0, xmm0                  ; xmm0=(4567)
+    psrad       xmm3, (DWORD_BIT-BYTE_BIT)  ; xmm3=(89AB)
+    psrad       xmm1, (DWORD_BIT-BYTE_BIT)  ; xmm1=(CDEF)
+    cvtdq2ps    xmm3, xmm3                  ; xmm3=(89AB)
+    cvtdq2ps    xmm1, xmm1                  ; xmm1=(CDEF)
+
+    movaps      XMMWORD [XMMBLOCK(0,0,rdi,SIZEOF_FAST_FLOAT)], xmm2
+    movaps      XMMWORD [XMMBLOCK(0,1,rdi,SIZEOF_FAST_FLOAT)], xmm0
+    movaps      XMMWORD [XMMBLOCK(1,0,rdi,SIZEOF_FAST_FLOAT)], xmm3
+    movaps      XMMWORD [XMMBLOCK(1,1,rdi,SIZEOF_FAST_FLOAT)], xmm1
+
+    add         rsi, byte 2*SIZEOF_JSAMPROW
+    add         rdi, byte 2*DCTSIZE*SIZEOF_FAST_FLOAT
+    dec         rcx
+    jnz         short .convloop
+
+    pop         rbx
+    uncollect_args 3
+    pop         rbp
+    ret
+
+; --------------------------------------------------------------------------
+;
+; Quantize/descale the coefficients, and store into coef_block
+;
+; GLOBAL(void)
+; jsimd_quantize_float_sse2(JCOEFPTR coef_block, FAST_FLOAT *divisors,
+;                           FAST_FLOAT *workspace);
+;
+
+; r10 = JCOEFPTR coef_block
+; r11 = FAST_FLOAT *divisors
+; r12 = FAST_FLOAT *workspace
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_quantize_float_sse2)
+
+EXTN(jsimd_quantize_float_sse2):
+    push        rbp
+    mov         rax, rsp
+    mov         rbp, rsp
+    collect_args 3
+
+    mov         rsi, r12
+    mov         rdx, r11
+    mov         rdi, r10
+    mov         rax, DCTSIZE2/16
+.quantloop:
+    movaps      xmm0, XMMWORD [XMMBLOCK(0,0,rsi,SIZEOF_FAST_FLOAT)]
+    movaps      xmm1, XMMWORD [XMMBLOCK(0,1,rsi,SIZEOF_FAST_FLOAT)]
+    mulps       xmm0, XMMWORD [XMMBLOCK(0,0,rdx,SIZEOF_FAST_FLOAT)]
+    mulps       xmm1, XMMWORD [XMMBLOCK(0,1,rdx,SIZEOF_FAST_FLOAT)]
+    movaps      xmm2, XMMWORD [XMMBLOCK(1,0,rsi,SIZEOF_FAST_FLOAT)]
+    movaps      xmm3, XMMWORD [XMMBLOCK(1,1,rsi,SIZEOF_FAST_FLOAT)]
+    mulps       xmm2, XMMWORD [XMMBLOCK(1,0,rdx,SIZEOF_FAST_FLOAT)]
+    mulps       xmm3, XMMWORD [XMMBLOCK(1,1,rdx,SIZEOF_FAST_FLOAT)]
+
+    cvtps2dq    xmm0, xmm0
+    cvtps2dq    xmm1, xmm1
+    cvtps2dq    xmm2, xmm2
+    cvtps2dq    xmm3, xmm3
+
+    packssdw    xmm0, xmm1
+    packssdw    xmm2, xmm3
+
+    movdqa      XMMWORD [XMMBLOCK(0,0,rdi,SIZEOF_JCOEF)], xmm0
+    movdqa      XMMWORD [XMMBLOCK(1,0,rdi,SIZEOF_JCOEF)], xmm2
+
+    add         rsi, byte 16*SIZEOF_FAST_FLOAT
+    add         rdx, byte 16*SIZEOF_FAST_FLOAT
+    add         rdi, byte 16*SIZEOF_JCOEF
+    dec         rax
+    jnz         short .quantloop
+
+    uncollect_args 3
+    pop         rbp
+    ret
+
+; For some reason, the OS X linker does not honor the request to align the
+; segment unless we do this.
+    align       32
diff --git a/3rdparty/libjpeg/src/simd/x86_64/jquanti-avx2.asm b/3rdparty/libjpeg/src/simd/x86_64/jquanti-avx2.asm
new file mode 100644
index 00000000..70fe8113
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/x86_64/jquanti-avx2.asm
@@ -0,0 +1,163 @@
+;
+; jquanti.asm - sample data conversion and quantization (64-bit AVX2)
+;
+; Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+; Copyright (C) 2009, 2016, 2018, D. R. Commander.
+; Copyright (C) 2016, Matthieu Darbois.
+; Copyright (C) 2018, Matthias Räncker.
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+;
+; This file should be assembled with NASM (Netwide Assembler),
+; can *not* be assembled with Microsoft's MASM or any compatible
+; assembler (including Borland's Turbo Assembler).
+; NASM is available from http://nasm.sourceforge.net/ or
+; http://sourceforge.net/project/showfiles.php?group_id=6208
+
+%include "jsimdext.inc"
+%include "jdct.inc"
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_TEXT
+    BITS        64
+;
+; Load data into workspace, applying unsigned->signed conversion
+;
+; GLOBAL(void)
+; jsimd_convsamp_avx2(JSAMPARRAY sample_data, JDIMENSION start_col,
+;                     DCTELEM *workspace);
+;
+
+; r10 = JSAMPARRAY sample_data
+; r11d = JDIMENSION start_col
+; r12 = DCTELEM *workspace
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_convsamp_avx2)
+
+EXTN(jsimd_convsamp_avx2):
+    push        rbp
+    mov         rax, rsp
+    mov         rbp, rsp
+    collect_args 3
+
+    mov         eax, r11d
+
+    mov         rsip, JSAMPROW [r10+0*SIZEOF_JSAMPROW]  ; (JSAMPLE *)
+    mov         rdip, JSAMPROW [r10+1*SIZEOF_JSAMPROW]  ; (JSAMPLE *)
+    movq        xmm0, XMM_MMWORD [rsi+rax*SIZEOF_JSAMPLE]
+    pinsrq      xmm0, XMM_MMWORD [rdi+rax*SIZEOF_JSAMPLE], 1
+
+    mov         rsip, JSAMPROW [r10+2*SIZEOF_JSAMPROW]  ; (JSAMPLE *)
+    mov         rdip, JSAMPROW [r10+3*SIZEOF_JSAMPROW]  ; (JSAMPLE *)
+    movq        xmm1, XMM_MMWORD [rsi+rax*SIZEOF_JSAMPLE]
+    pinsrq      xmm1, XMM_MMWORD [rdi+rax*SIZEOF_JSAMPLE], 1
+
+    mov         rsip, JSAMPROW [r10+4*SIZEOF_JSAMPROW]  ; (JSAMPLE *)
+    mov         rdip, JSAMPROW [r10+5*SIZEOF_JSAMPROW]  ; (JSAMPLE *)
+    movq        xmm2, XMM_MMWORD [rsi+rax*SIZEOF_JSAMPLE]
+    pinsrq      xmm2, XMM_MMWORD [rdi+rax*SIZEOF_JSAMPLE], 1
+
+    mov         rsip, JSAMPROW [r10+6*SIZEOF_JSAMPROW]  ; (JSAMPLE *)
+    mov         rdip, JSAMPROW [r10+7*SIZEOF_JSAMPROW]  ; (JSAMPLE *)
+    movq        xmm3, XMM_MMWORD [rsi+rax*SIZEOF_JSAMPLE]
+    pinsrq      xmm3, XMM_MMWORD [rdi+rax*SIZEOF_JSAMPLE], 1
+
+    vpmovzxbw   ymm0, xmm0              ; ymm0=(00 01 02 03 04 05 06 07 10 11 12 13 14 15 16 17)
+    vpmovzxbw   ymm1, xmm1              ; ymm1=(20 21 22 23 24 25 26 27 30 31 32 33 34 35 36 37)
+    vpmovzxbw   ymm2, xmm2              ; ymm2=(40 41 42 43 44 45 46 47 50 51 52 53 54 55 56 57)
+    vpmovzxbw   ymm3, xmm3              ; ymm3=(60 61 62 63 64 65 66 67 70 71 72 73 74 75 76 77)
+
+    vpcmpeqw    ymm7, ymm7, ymm7
+    vpsllw      ymm7, ymm7, 7           ; ymm7={0xFF80 0xFF80 0xFF80 0xFF80 ..}
+
+    vpaddw      ymm0, ymm0, ymm7
+    vpaddw      ymm1, ymm1, ymm7
+    vpaddw      ymm2, ymm2, ymm7
+    vpaddw      ymm3, ymm3, ymm7
+
+    vmovdqu     YMMWORD [YMMBLOCK(0,0,r12,SIZEOF_DCTELEM)], ymm0
+    vmovdqu     YMMWORD [YMMBLOCK(2,0,r12,SIZEOF_DCTELEM)], ymm1
+    vmovdqu     YMMWORD [YMMBLOCK(4,0,r12,SIZEOF_DCTELEM)], ymm2
+    vmovdqu     YMMWORD [YMMBLOCK(6,0,r12,SIZEOF_DCTELEM)], ymm3
+
+    vzeroupper
+    uncollect_args 3
+    pop         rbp
+    ret
+
+; --------------------------------------------------------------------------
+;
+; Quantize/descale the coefficients, and store into coef_block
+;
+; This implementation is based on an algorithm described in
+;   "How to optimize for the Pentium family of microprocessors"
+;   (http://www.agner.org/assem/).
+;
+; GLOBAL(void)
+; jsimd_quantize_avx2(JCOEFPTR coef_block, DCTELEM *divisors,
+;                     DCTELEM *workspace);
+;
+
+%define RECIPROCAL(m, n, b) \
+  YMMBLOCK(DCTSIZE * 0 + (m), (n), (b), SIZEOF_DCTELEM)
+%define CORRECTION(m, n, b) \
+  YMMBLOCK(DCTSIZE * 1 + (m), (n), (b), SIZEOF_DCTELEM)
+%define SCALE(m, n, b) \
+  YMMBLOCK(DCTSIZE * 2 + (m), (n), (b), SIZEOF_DCTELEM)
+
+; r10 = JCOEFPTR coef_block
+; r11 = DCTELEM *divisors
+; r12 = DCTELEM *workspace
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_quantize_avx2)
+
+EXTN(jsimd_quantize_avx2):
+    push        rbp
+    mov         rax, rsp
+    mov         rbp, rsp
+    collect_args 3
+
+    vmovdqu     ymm4, [YMMBLOCK(0,0,r12,SIZEOF_DCTELEM)]
+    vmovdqu     ymm5, [YMMBLOCK(2,0,r12,SIZEOF_DCTELEM)]
+    vmovdqu     ymm6, [YMMBLOCK(4,0,r12,SIZEOF_DCTELEM)]
+    vmovdqu     ymm7, [YMMBLOCK(6,0,r12,SIZEOF_DCTELEM)]
+    vpabsw      ymm0, ymm4
+    vpabsw      ymm1, ymm5
+    vpabsw      ymm2, ymm6
+    vpabsw      ymm3, ymm7
+
+    vpaddw      ymm0, YMMWORD [CORRECTION(0,0,r11)]  ; correction + roundfactor
+    vpaddw      ymm1, YMMWORD [CORRECTION(2,0,r11)]
+    vpaddw      ymm2, YMMWORD [CORRECTION(4,0,r11)]
+    vpaddw      ymm3, YMMWORD [CORRECTION(6,0,r11)]
+    vpmulhuw    ymm0, YMMWORD [RECIPROCAL(0,0,r11)]  ; reciprocal
+    vpmulhuw    ymm1, YMMWORD [RECIPROCAL(2,0,r11)]
+    vpmulhuw    ymm2, YMMWORD [RECIPROCAL(4,0,r11)]
+    vpmulhuw    ymm3, YMMWORD [RECIPROCAL(6,0,r11)]
+    vpmulhuw    ymm0, YMMWORD [SCALE(0,0,r11)]       ; scale
+    vpmulhuw    ymm1, YMMWORD [SCALE(2,0,r11)]
+    vpmulhuw    ymm2, YMMWORD [SCALE(4,0,r11)]
+    vpmulhuw    ymm3, YMMWORD [SCALE(6,0,r11)]
+
+    vpsignw     ymm0, ymm0, ymm4
+    vpsignw     ymm1, ymm1, ymm5
+    vpsignw     ymm2, ymm2, ymm6
+    vpsignw     ymm3, ymm3, ymm7
+
+    vmovdqu     [YMMBLOCK(0,0,r10,SIZEOF_DCTELEM)], ymm0
+    vmovdqu     [YMMBLOCK(2,0,r10,SIZEOF_DCTELEM)], ymm1
+    vmovdqu     [YMMBLOCK(4,0,r10,SIZEOF_DCTELEM)], ymm2
+    vmovdqu     [YMMBLOCK(6,0,r10,SIZEOF_DCTELEM)], ymm3
+
+    vzeroupper
+    uncollect_args 3
+    pop         rbp
+    ret
+
+; For some reason, the OS X linker does not honor the request to align the
+; segment unless we do this.
+    align       32
diff --git a/3rdparty/libjpeg/src/simd/x86_64/jquanti-sse2.asm b/3rdparty/libjpeg/src/simd/x86_64/jquanti-sse2.asm
new file mode 100644
index 00000000..3ee44202
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/x86_64/jquanti-sse2.asm
@@ -0,0 +1,188 @@
+;
+; jquanti.asm - sample data conversion and quantization (64-bit SSE2)
+;
+; Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+; Copyright (C) 2009, 2016, D. R. Commander.
+; Copyright (C) 2018, Matthias Räncker.
+;
+; Based on the x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+;
+; This file should be assembled with NASM (Netwide Assembler),
+; can *not* be assembled with Microsoft's MASM or any compatible
+; assembler (including Borland's Turbo Assembler).
+; NASM is available from http://nasm.sourceforge.net/ or
+; http://sourceforge.net/project/showfiles.php?group_id=6208
+
+%include "jsimdext.inc"
+%include "jdct.inc"
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_TEXT
+    BITS        64
+;
+; Load data into workspace, applying unsigned->signed conversion
+;
+; GLOBAL(void)
+; jsimd_convsamp_sse2(JSAMPARRAY sample_data, JDIMENSION start_col,
+;                     DCTELEM *workspace);
+;
+
+; r10 = JSAMPARRAY sample_data
+; r11d = JDIMENSION start_col
+; r12 = DCTELEM *workspace
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_convsamp_sse2)
+
+EXTN(jsimd_convsamp_sse2):
+    push        rbp
+    mov         rax, rsp
+    mov         rbp, rsp
+    collect_args 3
+    push        rbx
+
+    pxor        xmm6, xmm6              ; xmm6=(all 0's)
+    pcmpeqw     xmm7, xmm7
+    psllw       xmm7, 7                 ; xmm7={0xFF80 0xFF80 0xFF80 0xFF80 ..}
+
+    mov         rsi, r10
+    mov         eax, r11d
+    mov         rdi, r12
+    mov         rcx, DCTSIZE/4
+.convloop:
+    mov         rbxp, JSAMPROW [rsi+0*SIZEOF_JSAMPROW]  ; (JSAMPLE *)
+    mov         rdxp, JSAMPROW [rsi+1*SIZEOF_JSAMPROW]  ; (JSAMPLE *)
+
+    movq        xmm0, XMM_MMWORD [rbx+rax*SIZEOF_JSAMPLE]  ; xmm0=(01234567)
+    movq        xmm1, XMM_MMWORD [rdx+rax*SIZEOF_JSAMPLE]  ; xmm1=(89ABCDEF)
+
+    mov         rbxp, JSAMPROW [rsi+2*SIZEOF_JSAMPROW]  ; (JSAMPLE *)
+    mov         rdxp, JSAMPROW [rsi+3*SIZEOF_JSAMPROW]  ; (JSAMPLE *)
+
+    movq        xmm2, XMM_MMWORD [rbx+rax*SIZEOF_JSAMPLE]  ; xmm2=(GHIJKLMN)
+    movq        xmm3, XMM_MMWORD [rdx+rax*SIZEOF_JSAMPLE]  ; xmm3=(OPQRSTUV)
+
+    punpcklbw   xmm0, xmm6              ; xmm0=(01234567)
+    punpcklbw   xmm1, xmm6              ; xmm1=(89ABCDEF)
+    paddw       xmm0, xmm7
+    paddw       xmm1, xmm7
+    punpcklbw   xmm2, xmm6              ; xmm2=(GHIJKLMN)
+    punpcklbw   xmm3, xmm6              ; xmm3=(OPQRSTUV)
+    paddw       xmm2, xmm7
+    paddw       xmm3, xmm7
+
+    movdqa      XMMWORD [XMMBLOCK(0,0,rdi,SIZEOF_DCTELEM)], xmm0
+    movdqa      XMMWORD [XMMBLOCK(1,0,rdi,SIZEOF_DCTELEM)], xmm1
+    movdqa      XMMWORD [XMMBLOCK(2,0,rdi,SIZEOF_DCTELEM)], xmm2
+    movdqa      XMMWORD [XMMBLOCK(3,0,rdi,SIZEOF_DCTELEM)], xmm3
+
+    add         rsi, byte 4*SIZEOF_JSAMPROW
+    add         rdi, byte 4*DCTSIZE*SIZEOF_DCTELEM
+    dec         rcx
+    jnz         short .convloop
+
+    pop         rbx
+    uncollect_args 3
+    pop         rbp
+    ret
+
+; --------------------------------------------------------------------------
+;
+; Quantize/descale the coefficients, and store into coef_block
+;
+; This implementation is based on an algorithm described in
+;   "How to optimize for the Pentium family of microprocessors"
+;   (http://www.agner.org/assem/).
+;
+; GLOBAL(void)
+; jsimd_quantize_sse2(JCOEFPTR coef_block, DCTELEM *divisors,
+;                     DCTELEM *workspace);
+;
+
+%define RECIPROCAL(m, n, b) \
+  XMMBLOCK(DCTSIZE * 0 + (m), (n), (b), SIZEOF_DCTELEM)
+%define CORRECTION(m, n, b) \
+  XMMBLOCK(DCTSIZE * 1 + (m), (n), (b), SIZEOF_DCTELEM)
+%define SCALE(m, n, b) \
+  XMMBLOCK(DCTSIZE * 2 + (m), (n), (b), SIZEOF_DCTELEM)
+
+; r10 = JCOEFPTR coef_block
+; r11 = DCTELEM *divisors
+; r12 = DCTELEM *workspace
+
+    align       32
+    GLOBAL_FUNCTION(jsimd_quantize_sse2)
+
+EXTN(jsimd_quantize_sse2):
+    push        rbp
+    mov         rax, rsp
+    mov         rbp, rsp
+    collect_args 3
+
+    mov         rsi, r12
+    mov         rdx, r11
+    mov         rdi, r10
+    mov         rax, DCTSIZE2/32
+.quantloop:
+    movdqa      xmm4, XMMWORD [XMMBLOCK(0,0,rsi,SIZEOF_DCTELEM)]
+    movdqa      xmm5, XMMWORD [XMMBLOCK(1,0,rsi,SIZEOF_DCTELEM)]
+    movdqa      xmm6, XMMWORD [XMMBLOCK(2,0,rsi,SIZEOF_DCTELEM)]
+    movdqa      xmm7, XMMWORD [XMMBLOCK(3,0,rsi,SIZEOF_DCTELEM)]
+    movdqa      xmm0, xmm4
+    movdqa      xmm1, xmm5
+    movdqa      xmm2, xmm6
+    movdqa      xmm3, xmm7
+    psraw       xmm4, (WORD_BIT-1)
+    psraw       xmm5, (WORD_BIT-1)
+    psraw       xmm6, (WORD_BIT-1)
+    psraw       xmm7, (WORD_BIT-1)
+    pxor        xmm0, xmm4
+    pxor        xmm1, xmm5
+    pxor        xmm2, xmm6
+    pxor        xmm3, xmm7
+    psubw       xmm0, xmm4              ; if (xmm0 < 0) xmm0 = -xmm0;
+    psubw       xmm1, xmm5              ; if (xmm1 < 0) xmm1 = -xmm1;
+    psubw       xmm2, xmm6              ; if (xmm2 < 0) xmm2 = -xmm2;
+    psubw       xmm3, xmm7              ; if (xmm3 < 0) xmm3 = -xmm3;
+
+    paddw       xmm0, XMMWORD [CORRECTION(0,0,rdx)]  ; correction + roundfactor
+    paddw       xmm1, XMMWORD [CORRECTION(1,0,rdx)]
+    paddw       xmm2, XMMWORD [CORRECTION(2,0,rdx)]
+    paddw       xmm3, XMMWORD [CORRECTION(3,0,rdx)]
+    pmulhuw     xmm0, XMMWORD [RECIPROCAL(0,0,rdx)]  ; reciprocal
+    pmulhuw     xmm1, XMMWORD [RECIPROCAL(1,0,rdx)]
+    pmulhuw     xmm2, XMMWORD [RECIPROCAL(2,0,rdx)]
+    pmulhuw     xmm3, XMMWORD [RECIPROCAL(3,0,rdx)]
+    pmulhuw     xmm0, XMMWORD [SCALE(0,0,rdx)]       ; scale
+    pmulhuw     xmm1, XMMWORD [SCALE(1,0,rdx)]
+    pmulhuw     xmm2, XMMWORD [SCALE(2,0,rdx)]
+    pmulhuw     xmm3, XMMWORD [SCALE(3,0,rdx)]
+
+    pxor        xmm0, xmm4
+    pxor        xmm1, xmm5
+    pxor        xmm2, xmm6
+    pxor        xmm3, xmm7
+    psubw       xmm0, xmm4
+    psubw       xmm1, xmm5
+    psubw       xmm2, xmm6
+    psubw       xmm3, xmm7
+    movdqa      XMMWORD [XMMBLOCK(0,0,rdi,SIZEOF_DCTELEM)], xmm0
+    movdqa      XMMWORD [XMMBLOCK(1,0,rdi,SIZEOF_DCTELEM)], xmm1
+    movdqa      XMMWORD [XMMBLOCK(2,0,rdi,SIZEOF_DCTELEM)], xmm2
+    movdqa      XMMWORD [XMMBLOCK(3,0,rdi,SIZEOF_DCTELEM)], xmm3
+
+    add         rsi, byte 32*SIZEOF_DCTELEM
+    add         rdx, byte 32*SIZEOF_DCTELEM
+    add         rdi, byte 32*SIZEOF_JCOEF
+    dec         rax
+    jnz         near .quantloop
+
+    uncollect_args 3
+    pop         rbp
+    ret
+
+; For some reason, the OS X linker does not honor the request to align the
+; segment unless we do this.
+    align       32
diff --git a/3rdparty/libjpeg/src/simd/x86_64/jsimd.c b/3rdparty/libjpeg/src/simd/x86_64/jsimd.c
new file mode 100644
index 00000000..eb766799
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/x86_64/jsimd.c
@@ -0,0 +1,1072 @@
+/*
+ * jsimd_x86_64.c
+ *
+ * Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+ * Copyright (C) 2009-2011, 2014, 2016, 2018, D. R. Commander.
+ * Copyright (C) 2015-2016, 2018, Matthieu Darbois.
+ *
+ * Based on the x86 SIMD extension for IJG JPEG library,
+ * Copyright (C) 1999-2006, MIYASAKA Masaru.
+ * For conditions of distribution and use, see copyright notice in jsimdext.inc
+ *
+ * This file contains the interface between the "normal" portions
+ * of the library and the SIMD implementations when running on a
+ * 64-bit x86 architecture.
+ */
+
+#define JPEG_INTERNALS
+#include "../../jinclude.h"
+#include "../../jpeglib.h"
+#include "../../jsimd.h"
+#include "../../jdct.h"
+#include "../../jsimddct.h"
+#include "../jsimd.h"
+#include "jconfigint.h"
+
+/*
+ * In the PIC cases, we have no guarantee that constants will keep
+ * their alignment. This macro allows us to verify it at runtime.
+ */
+#define IS_ALIGNED(ptr, order)  (((size_t)ptr & ((1 << order) - 1)) == 0)
+
+#define IS_ALIGNED_SSE(ptr)  (IS_ALIGNED(ptr, 4)) /* 16 byte alignment */
+#define IS_ALIGNED_AVX(ptr)  (IS_ALIGNED(ptr, 5)) /* 32 byte alignment */
+
+static unsigned int simd_support = (unsigned int)(~0);
+static unsigned int simd_huffman = 1;
+
+/*
+ * Check what SIMD accelerations are supported.
+ *
+ * FIXME: This code is racy under a multi-threaded environment.
+ */
+LOCAL(void)
+init_simd(void)
+{
+#ifndef NO_GETENV
+  char *env = NULL;
+#endif
+
+  if (simd_support != ~0U)
+    return;
+
+  simd_support = jpeg_simd_cpu_support();
+
+#ifndef NO_GETENV
+  /* Force different settings through environment variables */
+  env = getenv("JSIMD_FORCESSE2");
+  if ((env != NULL) && (strcmp(env, "1") == 0))
+    simd_support &= JSIMD_SSE2;
+  env = getenv("JSIMD_FORCEAVX2");
+  if ((env != NULL) && (strcmp(env, "1") == 0))
+    simd_support &= JSIMD_AVX2;
+  env = getenv("JSIMD_FORCENONE");
+  if ((env != NULL) && (strcmp(env, "1") == 0))
+    simd_support = 0;
+  env = getenv("JSIMD_NOHUFFENC");
+  if ((env != NULL) && (strcmp(env, "1") == 0))
+    simd_huffman = 0;
+#endif
+}
+
+GLOBAL(int)
+jsimd_can_rgb_ycc(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+  if ((RGB_PIXELSIZE != 3) && (RGB_PIXELSIZE != 4))
+    return 0;
+
+  if ((simd_support & JSIMD_AVX2) &&
+      IS_ALIGNED_AVX(jconst_rgb_ycc_convert_avx2))
+    return 1;
+  if ((simd_support & JSIMD_SSE2) &&
+      IS_ALIGNED_SSE(jconst_rgb_ycc_convert_sse2))
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_rgb_gray(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+  if ((RGB_PIXELSIZE != 3) && (RGB_PIXELSIZE != 4))
+    return 0;
+
+  if ((simd_support & JSIMD_AVX2) &&
+      IS_ALIGNED_AVX(jconst_rgb_gray_convert_avx2))
+    return 1;
+  if ((simd_support & JSIMD_SSE2) &&
+      IS_ALIGNED_SSE(jconst_rgb_gray_convert_sse2))
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_ycc_rgb(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+  if ((RGB_PIXELSIZE != 3) && (RGB_PIXELSIZE != 4))
+    return 0;
+
+  if ((simd_support & JSIMD_AVX2) &&
+      IS_ALIGNED_AVX(jconst_ycc_rgb_convert_avx2))
+    return 1;
+  if ((simd_support & JSIMD_SSE2) &&
+      IS_ALIGNED_SSE(jconst_ycc_rgb_convert_sse2))
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_ycc_rgb565(void)
+{
+  return 0;
+}
+
+GLOBAL(void)
+jsimd_rgb_ycc_convert(j_compress_ptr cinfo, JSAMPARRAY input_buf,
+                      JSAMPIMAGE output_buf, JDIMENSION output_row,
+                      int num_rows)
+{
+  void (*avx2fct) (JDIMENSION, JSAMPARRAY, JSAMPIMAGE, JDIMENSION, int);
+  void (*sse2fct) (JDIMENSION, JSAMPARRAY, JSAMPIMAGE, JDIMENSION, int);
+
+  switch (cinfo->in_color_space) {
+  case JCS_EXT_RGB:
+    avx2fct = jsimd_extrgb_ycc_convert_avx2;
+    sse2fct = jsimd_extrgb_ycc_convert_sse2;
+    break;
+  case JCS_EXT_RGBX:
+  case JCS_EXT_RGBA:
+    avx2fct = jsimd_extrgbx_ycc_convert_avx2;
+    sse2fct = jsimd_extrgbx_ycc_convert_sse2;
+    break;
+  case JCS_EXT_BGR:
+    avx2fct = jsimd_extbgr_ycc_convert_avx2;
+    sse2fct = jsimd_extbgr_ycc_convert_sse2;
+    break;
+  case JCS_EXT_BGRX:
+  case JCS_EXT_BGRA:
+    avx2fct = jsimd_extbgrx_ycc_convert_avx2;
+    sse2fct = jsimd_extbgrx_ycc_convert_sse2;
+    break;
+  case JCS_EXT_XBGR:
+  case JCS_EXT_ABGR:
+    avx2fct = jsimd_extxbgr_ycc_convert_avx2;
+    sse2fct = jsimd_extxbgr_ycc_convert_sse2;
+    break;
+  case JCS_EXT_XRGB:
+  case JCS_EXT_ARGB:
+    avx2fct = jsimd_extxrgb_ycc_convert_avx2;
+    sse2fct = jsimd_extxrgb_ycc_convert_sse2;
+    break;
+  default:
+    avx2fct = jsimd_rgb_ycc_convert_avx2;
+    sse2fct = jsimd_rgb_ycc_convert_sse2;
+    break;
+  }
+
+  if (simd_support & JSIMD_AVX2)
+    avx2fct(cinfo->image_width, input_buf, output_buf, output_row, num_rows);
+  else
+    sse2fct(cinfo->image_width, input_buf, output_buf, output_row, num_rows);
+}
+
+GLOBAL(void)
+jsimd_rgb_gray_convert(j_compress_ptr cinfo, JSAMPARRAY input_buf,
+                       JSAMPIMAGE output_buf, JDIMENSION output_row,
+                       int num_rows)
+{
+  void (*avx2fct) (JDIMENSION, JSAMPARRAY, JSAMPIMAGE, JDIMENSION, int);
+  void (*sse2fct) (JDIMENSION, JSAMPARRAY, JSAMPIMAGE, JDIMENSION, int);
+
+  switch (cinfo->in_color_space) {
+  case JCS_EXT_RGB:
+    avx2fct = jsimd_extrgb_gray_convert_avx2;
+    sse2fct = jsimd_extrgb_gray_convert_sse2;
+    break;
+  case JCS_EXT_RGBX:
+  case JCS_EXT_RGBA:
+    avx2fct = jsimd_extrgbx_gray_convert_avx2;
+    sse2fct = jsimd_extrgbx_gray_convert_sse2;
+    break;
+  case JCS_EXT_BGR:
+    avx2fct = jsimd_extbgr_gray_convert_avx2;
+    sse2fct = jsimd_extbgr_gray_convert_sse2;
+    break;
+  case JCS_EXT_BGRX:
+  case JCS_EXT_BGRA:
+    avx2fct = jsimd_extbgrx_gray_convert_avx2;
+    sse2fct = jsimd_extbgrx_gray_convert_sse2;
+    break;
+  case JCS_EXT_XBGR:
+  case JCS_EXT_ABGR:
+    avx2fct = jsimd_extxbgr_gray_convert_avx2;
+    sse2fct = jsimd_extxbgr_gray_convert_sse2;
+    break;
+  case JCS_EXT_XRGB:
+  case JCS_EXT_ARGB:
+    avx2fct = jsimd_extxrgb_gray_convert_avx2;
+    sse2fct = jsimd_extxrgb_gray_convert_sse2;
+    break;
+  default:
+    avx2fct = jsimd_rgb_gray_convert_avx2;
+    sse2fct = jsimd_rgb_gray_convert_sse2;
+    break;
+  }
+
+  if (simd_support & JSIMD_AVX2)
+    avx2fct(cinfo->image_width, input_buf, output_buf, output_row, num_rows);
+  else
+    sse2fct(cinfo->image_width, input_buf, output_buf, output_row, num_rows);
+}
+
+GLOBAL(void)
+jsimd_ycc_rgb_convert(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
+                      JDIMENSION input_row, JSAMPARRAY output_buf,
+                      int num_rows)
+{
+  void (*avx2fct) (JDIMENSION, JSAMPIMAGE, JDIMENSION, JSAMPARRAY, int);
+  void (*sse2fct) (JDIMENSION, JSAMPIMAGE, JDIMENSION, JSAMPARRAY, int);
+
+  switch (cinfo->out_color_space) {
+  case JCS_EXT_RGB:
+    avx2fct = jsimd_ycc_extrgb_convert_avx2;
+    sse2fct = jsimd_ycc_extrgb_convert_sse2;
+    break;
+  case JCS_EXT_RGBX:
+  case JCS_EXT_RGBA:
+    avx2fct = jsimd_ycc_extrgbx_convert_avx2;
+    sse2fct = jsimd_ycc_extrgbx_convert_sse2;
+    break;
+  case JCS_EXT_BGR:
+    avx2fct = jsimd_ycc_extbgr_convert_avx2;
+    sse2fct = jsimd_ycc_extbgr_convert_sse2;
+    break;
+  case JCS_EXT_BGRX:
+  case JCS_EXT_BGRA:
+    avx2fct = jsimd_ycc_extbgrx_convert_avx2;
+    sse2fct = jsimd_ycc_extbgrx_convert_sse2;
+    break;
+  case JCS_EXT_XBGR:
+  case JCS_EXT_ABGR:
+    avx2fct = jsimd_ycc_extxbgr_convert_avx2;
+    sse2fct = jsimd_ycc_extxbgr_convert_sse2;
+    break;
+  case JCS_EXT_XRGB:
+  case JCS_EXT_ARGB:
+    avx2fct = jsimd_ycc_extxrgb_convert_avx2;
+    sse2fct = jsimd_ycc_extxrgb_convert_sse2;
+    break;
+  default:
+    avx2fct = jsimd_ycc_rgb_convert_avx2;
+    sse2fct = jsimd_ycc_rgb_convert_sse2;
+    break;
+  }
+
+  if (simd_support & JSIMD_AVX2)
+    avx2fct(cinfo->output_width, input_buf, input_row, output_buf, num_rows);
+  else
+    sse2fct(cinfo->output_width, input_buf, input_row, output_buf, num_rows);
+}
+
+GLOBAL(void)
+jsimd_ycc_rgb565_convert(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
+                         JDIMENSION input_row, JSAMPARRAY output_buf,
+                         int num_rows)
+{
+}
+
+GLOBAL(int)
+jsimd_can_h2v2_downsample(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+
+  if (simd_support & JSIMD_AVX2)
+    return 1;
+  if (simd_support & JSIMD_SSE2)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_h2v1_downsample(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+
+  if (simd_support & JSIMD_AVX2)
+    return 1;
+  if (simd_support & JSIMD_SSE2)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(void)
+jsimd_h2v2_downsample(j_compress_ptr cinfo, jpeg_component_info *compptr,
+                      JSAMPARRAY input_data, JSAMPARRAY output_data)
+{
+  if (simd_support & JSIMD_AVX2)
+    jsimd_h2v2_downsample_avx2(cinfo->image_width, cinfo->max_v_samp_factor,
+                               compptr->v_samp_factor,
+                               compptr->width_in_blocks, input_data,
+                               output_data);
+  else
+    jsimd_h2v2_downsample_sse2(cinfo->image_width, cinfo->max_v_samp_factor,
+                               compptr->v_samp_factor,
+                               compptr->width_in_blocks, input_data,
+                               output_data);
+}
+
+GLOBAL(void)
+jsimd_h2v1_downsample(j_compress_ptr cinfo, jpeg_component_info *compptr,
+                      JSAMPARRAY input_data, JSAMPARRAY output_data)
+{
+  if (simd_support & JSIMD_AVX2)
+    jsimd_h2v1_downsample_avx2(cinfo->image_width, cinfo->max_v_samp_factor,
+                               compptr->v_samp_factor,
+                               compptr->width_in_blocks, input_data,
+                               output_data);
+  else
+    jsimd_h2v1_downsample_sse2(cinfo->image_width, cinfo->max_v_samp_factor,
+                               compptr->v_samp_factor,
+                               compptr->width_in_blocks, input_data,
+                               output_data);
+}
+
+GLOBAL(int)
+jsimd_can_h2v2_upsample(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+
+  if (simd_support & JSIMD_AVX2)
+    return 1;
+  if (simd_support & JSIMD_SSE2)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_h2v1_upsample(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+
+  if (simd_support & JSIMD_AVX2)
+    return 1;
+  if (simd_support & JSIMD_SSE2)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(void)
+jsimd_h2v2_upsample(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+                    JSAMPARRAY input_data, JSAMPARRAY *output_data_ptr)
+{
+  if (simd_support & JSIMD_AVX2)
+    jsimd_h2v2_upsample_avx2(cinfo->max_v_samp_factor, cinfo->output_width,
+                             input_data, output_data_ptr);
+  else
+    jsimd_h2v2_upsample_sse2(cinfo->max_v_samp_factor, cinfo->output_width,
+                             input_data, output_data_ptr);
+}
+
+GLOBAL(void)
+jsimd_h2v1_upsample(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+                    JSAMPARRAY input_data, JSAMPARRAY *output_data_ptr)
+{
+  if (simd_support & JSIMD_AVX2)
+    jsimd_h2v1_upsample_avx2(cinfo->max_v_samp_factor, cinfo->output_width,
+                             input_data, output_data_ptr);
+  else
+    jsimd_h2v1_upsample_sse2(cinfo->max_v_samp_factor, cinfo->output_width,
+                             input_data, output_data_ptr);
+}
+
+GLOBAL(int)
+jsimd_can_h2v2_fancy_upsample(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+
+  if ((simd_support & JSIMD_AVX2) &&
+      IS_ALIGNED_AVX(jconst_fancy_upsample_avx2))
+    return 1;
+  if ((simd_support & JSIMD_SSE2) &&
+      IS_ALIGNED_SSE(jconst_fancy_upsample_sse2))
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_h2v1_fancy_upsample(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+
+  if ((simd_support & JSIMD_AVX2) &&
+      IS_ALIGNED_AVX(jconst_fancy_upsample_avx2))
+    return 1;
+  if ((simd_support & JSIMD_SSE2) &&
+      IS_ALIGNED_SSE(jconst_fancy_upsample_sse2))
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(void)
+jsimd_h2v2_fancy_upsample(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+                          JSAMPARRAY input_data, JSAMPARRAY *output_data_ptr)
+{
+  if (simd_support & JSIMD_AVX2)
+    jsimd_h2v2_fancy_upsample_avx2(cinfo->max_v_samp_factor,
+                                   compptr->downsampled_width, input_data,
+                                   output_data_ptr);
+  else
+    jsimd_h2v2_fancy_upsample_sse2(cinfo->max_v_samp_factor,
+                                   compptr->downsampled_width, input_data,
+                                   output_data_ptr);
+}
+
+GLOBAL(void)
+jsimd_h2v1_fancy_upsample(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+                          JSAMPARRAY input_data, JSAMPARRAY *output_data_ptr)
+{
+  if (simd_support & JSIMD_AVX2)
+    jsimd_h2v1_fancy_upsample_avx2(cinfo->max_v_samp_factor,
+                                   compptr->downsampled_width, input_data,
+                                   output_data_ptr);
+  else
+    jsimd_h2v1_fancy_upsample_sse2(cinfo->max_v_samp_factor,
+                                   compptr->downsampled_width, input_data,
+                                   output_data_ptr);
+}
+
+GLOBAL(int)
+jsimd_can_h2v2_merged_upsample(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+
+  if ((simd_support & JSIMD_AVX2) &&
+      IS_ALIGNED_AVX(jconst_merged_upsample_avx2))
+    return 1;
+  if ((simd_support & JSIMD_SSE2) &&
+      IS_ALIGNED_SSE(jconst_merged_upsample_sse2))
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_h2v1_merged_upsample(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+
+  if ((simd_support & JSIMD_AVX2) &&
+      IS_ALIGNED_AVX(jconst_merged_upsample_avx2))
+    return 1;
+  if ((simd_support & JSIMD_SSE2) &&
+      IS_ALIGNED_SSE(jconst_merged_upsample_sse2))
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(void)
+jsimd_h2v2_merged_upsample(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
+                           JDIMENSION in_row_group_ctr, JSAMPARRAY output_buf)
+{
+  void (*avx2fct) (JDIMENSION, JSAMPIMAGE, JDIMENSION, JSAMPARRAY);
+  void (*sse2fct) (JDIMENSION, JSAMPIMAGE, JDIMENSION, JSAMPARRAY);
+
+  switch (cinfo->out_color_space) {
+  case JCS_EXT_RGB:
+    avx2fct = jsimd_h2v2_extrgb_merged_upsample_avx2;
+    sse2fct = jsimd_h2v2_extrgb_merged_upsample_sse2;
+    break;
+  case JCS_EXT_RGBX:
+  case JCS_EXT_RGBA:
+    avx2fct = jsimd_h2v2_extrgbx_merged_upsample_avx2;
+    sse2fct = jsimd_h2v2_extrgbx_merged_upsample_sse2;
+    break;
+  case JCS_EXT_BGR:
+    avx2fct = jsimd_h2v2_extbgr_merged_upsample_avx2;
+    sse2fct = jsimd_h2v2_extbgr_merged_upsample_sse2;
+    break;
+  case JCS_EXT_BGRX:
+  case JCS_EXT_BGRA:
+    avx2fct = jsimd_h2v2_extbgrx_merged_upsample_avx2;
+    sse2fct = jsimd_h2v2_extbgrx_merged_upsample_sse2;
+    break;
+  case JCS_EXT_XBGR:
+  case JCS_EXT_ABGR:
+    avx2fct = jsimd_h2v2_extxbgr_merged_upsample_avx2;
+    sse2fct = jsimd_h2v2_extxbgr_merged_upsample_sse2;
+    break;
+  case JCS_EXT_XRGB:
+  case JCS_EXT_ARGB:
+    avx2fct = jsimd_h2v2_extxrgb_merged_upsample_avx2;
+    sse2fct = jsimd_h2v2_extxrgb_merged_upsample_sse2;
+    break;
+  default:
+    avx2fct = jsimd_h2v2_merged_upsample_avx2;
+    sse2fct = jsimd_h2v2_merged_upsample_sse2;
+    break;
+  }
+
+  if (simd_support & JSIMD_AVX2)
+    avx2fct(cinfo->output_width, input_buf, in_row_group_ctr, output_buf);
+  else
+    sse2fct(cinfo->output_width, input_buf, in_row_group_ctr, output_buf);
+}
+
+GLOBAL(void)
+jsimd_h2v1_merged_upsample(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
+                           JDIMENSION in_row_group_ctr, JSAMPARRAY output_buf)
+{
+  void (*avx2fct) (JDIMENSION, JSAMPIMAGE, JDIMENSION, JSAMPARRAY);
+  void (*sse2fct) (JDIMENSION, JSAMPIMAGE, JDIMENSION, JSAMPARRAY);
+
+  switch (cinfo->out_color_space) {
+  case JCS_EXT_RGB:
+    avx2fct = jsimd_h2v1_extrgb_merged_upsample_avx2;
+    sse2fct = jsimd_h2v1_extrgb_merged_upsample_sse2;
+    break;
+  case JCS_EXT_RGBX:
+  case JCS_EXT_RGBA:
+    avx2fct = jsimd_h2v1_extrgbx_merged_upsample_avx2;
+    sse2fct = jsimd_h2v1_extrgbx_merged_upsample_sse2;
+    break;
+  case JCS_EXT_BGR:
+    avx2fct = jsimd_h2v1_extbgr_merged_upsample_avx2;
+    sse2fct = jsimd_h2v1_extbgr_merged_upsample_sse2;
+    break;
+  case JCS_EXT_BGRX:
+  case JCS_EXT_BGRA:
+    avx2fct = jsimd_h2v1_extbgrx_merged_upsample_avx2;
+    sse2fct = jsimd_h2v1_extbgrx_merged_upsample_sse2;
+    break;
+  case JCS_EXT_XBGR:
+  case JCS_EXT_ABGR:
+    avx2fct = jsimd_h2v1_extxbgr_merged_upsample_avx2;
+    sse2fct = jsimd_h2v1_extxbgr_merged_upsample_sse2;
+    break;
+  case JCS_EXT_XRGB:
+  case JCS_EXT_ARGB:
+    avx2fct = jsimd_h2v1_extxrgb_merged_upsample_avx2;
+    sse2fct = jsimd_h2v1_extxrgb_merged_upsample_sse2;
+    break;
+  default:
+    avx2fct = jsimd_h2v1_merged_upsample_avx2;
+    sse2fct = jsimd_h2v1_merged_upsample_sse2;
+    break;
+  }
+
+  if (simd_support & JSIMD_AVX2)
+    avx2fct(cinfo->output_width, input_buf, in_row_group_ctr, output_buf);
+  else
+    sse2fct(cinfo->output_width, input_buf, in_row_group_ctr, output_buf);
+}
+
+GLOBAL(int)
+jsimd_can_convsamp(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (DCTSIZE != 8)
+    return 0;
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+  if (sizeof(DCTELEM) != 2)
+    return 0;
+
+  if (simd_support & JSIMD_AVX2)
+    return 1;
+  if (simd_support & JSIMD_SSE2)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_convsamp_float(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (DCTSIZE != 8)
+    return 0;
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+  if (sizeof(FAST_FLOAT) != 4)
+    return 0;
+
+  if (simd_support & JSIMD_SSE2)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(void)
+jsimd_convsamp(JSAMPARRAY sample_data, JDIMENSION start_col,
+               DCTELEM *workspace)
+{
+  if (simd_support & JSIMD_AVX2)
+    jsimd_convsamp_avx2(sample_data, start_col, workspace);
+  else
+    jsimd_convsamp_sse2(sample_data, start_col, workspace);
+}
+
+GLOBAL(void)
+jsimd_convsamp_float(JSAMPARRAY sample_data, JDIMENSION start_col,
+                     FAST_FLOAT *workspace)
+{
+  jsimd_convsamp_float_sse2(sample_data, start_col, workspace);
+}
+
+GLOBAL(int)
+jsimd_can_fdct_islow(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (DCTSIZE != 8)
+    return 0;
+  if (sizeof(DCTELEM) != 2)
+    return 0;
+
+  if ((simd_support & JSIMD_AVX2) && IS_ALIGNED_AVX(jconst_fdct_islow_avx2))
+    return 1;
+  if ((simd_support & JSIMD_SSE2) && IS_ALIGNED_SSE(jconst_fdct_islow_sse2))
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_fdct_ifast(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (DCTSIZE != 8)
+    return 0;
+  if (sizeof(DCTELEM) != 2)
+    return 0;
+
+  if ((simd_support & JSIMD_SSE2) && IS_ALIGNED_SSE(jconst_fdct_ifast_sse2))
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_fdct_float(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (DCTSIZE != 8)
+    return 0;
+  if (sizeof(FAST_FLOAT) != 4)
+    return 0;
+
+  if ((simd_support & JSIMD_SSE) && IS_ALIGNED_SSE(jconst_fdct_float_sse))
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(void)
+jsimd_fdct_islow(DCTELEM *data)
+{
+  if (simd_support & JSIMD_AVX2)
+    jsimd_fdct_islow_avx2(data);
+  else
+    jsimd_fdct_islow_sse2(data);
+}
+
+GLOBAL(void)
+jsimd_fdct_ifast(DCTELEM *data)
+{
+  jsimd_fdct_ifast_sse2(data);
+}
+
+GLOBAL(void)
+jsimd_fdct_float(FAST_FLOAT *data)
+{
+  jsimd_fdct_float_sse(data);
+}
+
+GLOBAL(int)
+jsimd_can_quantize(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (DCTSIZE != 8)
+    return 0;
+  if (sizeof(JCOEF) != 2)
+    return 0;
+  if (sizeof(DCTELEM) != 2)
+    return 0;
+
+  if (simd_support & JSIMD_AVX2)
+    return 1;
+  if (simd_support & JSIMD_SSE2)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_quantize_float(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (DCTSIZE != 8)
+    return 0;
+  if (sizeof(JCOEF) != 2)
+    return 0;
+  if (sizeof(FAST_FLOAT) != 4)
+    return 0;
+
+  if (simd_support & JSIMD_SSE2)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(void)
+jsimd_quantize(JCOEFPTR coef_block, DCTELEM *divisors, DCTELEM *workspace)
+{
+  if (simd_support & JSIMD_AVX2)
+    jsimd_quantize_avx2(coef_block, divisors, workspace);
+  else
+    jsimd_quantize_sse2(coef_block, divisors, workspace);
+}
+
+GLOBAL(void)
+jsimd_quantize_float(JCOEFPTR coef_block, FAST_FLOAT *divisors,
+                     FAST_FLOAT *workspace)
+{
+  jsimd_quantize_float_sse2(coef_block, divisors, workspace);
+}
+
+GLOBAL(int)
+jsimd_can_idct_2x2(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (DCTSIZE != 8)
+    return 0;
+  if (sizeof(JCOEF) != 2)
+    return 0;
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+  if (sizeof(ISLOW_MULT_TYPE) != 2)
+    return 0;
+
+  if ((simd_support & JSIMD_SSE2) && IS_ALIGNED_SSE(jconst_idct_red_sse2))
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_idct_4x4(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (DCTSIZE != 8)
+    return 0;
+  if (sizeof(JCOEF) != 2)
+    return 0;
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+  if (sizeof(ISLOW_MULT_TYPE) != 2)
+    return 0;
+
+  if ((simd_support & JSIMD_SSE2) && IS_ALIGNED_SSE(jconst_idct_red_sse2))
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(void)
+jsimd_idct_2x2(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+               JCOEFPTR coef_block, JSAMPARRAY output_buf,
+               JDIMENSION output_col)
+{
+  jsimd_idct_2x2_sse2(compptr->dct_table, coef_block, output_buf, output_col);
+}
+
+GLOBAL(void)
+jsimd_idct_4x4(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+               JCOEFPTR coef_block, JSAMPARRAY output_buf,
+               JDIMENSION output_col)
+{
+  jsimd_idct_4x4_sse2(compptr->dct_table, coef_block, output_buf, output_col);
+}
+
+GLOBAL(int)
+jsimd_can_idct_islow(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (DCTSIZE != 8)
+    return 0;
+  if (sizeof(JCOEF) != 2)
+    return 0;
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+  if (sizeof(ISLOW_MULT_TYPE) != 2)
+    return 0;
+
+  if ((simd_support & JSIMD_AVX2) && IS_ALIGNED_AVX(jconst_idct_islow_avx2))
+    return 1;
+  if ((simd_support & JSIMD_SSE2) && IS_ALIGNED_SSE(jconst_idct_islow_sse2))
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_idct_ifast(void)
+{
+  init_simd();
+
+  /* The code is optimised for these values only */
+  if (DCTSIZE != 8)
+    return 0;
+  if (sizeof(JCOEF) != 2)
+    return 0;
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+  if (sizeof(IFAST_MULT_TYPE) != 2)
+    return 0;
+  if (IFAST_SCALE_BITS != 2)
+    return 0;
+
+  if ((simd_support & JSIMD_SSE2) && IS_ALIGNED_SSE(jconst_idct_ifast_sse2))
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_can_idct_float(void)
+{
+  init_simd();
+
+  if (DCTSIZE != 8)
+    return 0;
+  if (sizeof(JCOEF) != 2)
+    return 0;
+  if (BITS_IN_JSAMPLE != 8)
+    return 0;
+  if (sizeof(JDIMENSION) != 4)
+    return 0;
+  if (sizeof(FAST_FLOAT) != 4)
+    return 0;
+  if (sizeof(FLOAT_MULT_TYPE) != 4)
+    return 0;
+
+  if ((simd_support & JSIMD_SSE2) && IS_ALIGNED_SSE(jconst_idct_float_sse2))
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(void)
+jsimd_idct_islow(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+                 JCOEFPTR coef_block, JSAMPARRAY output_buf,
+                 JDIMENSION output_col)
+{
+  if (simd_support & JSIMD_AVX2)
+    jsimd_idct_islow_avx2(compptr->dct_table, coef_block, output_buf,
+                          output_col);
+  else
+    jsimd_idct_islow_sse2(compptr->dct_table, coef_block, output_buf,
+                          output_col);
+}
+
+GLOBAL(void)
+jsimd_idct_ifast(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+                 JCOEFPTR coef_block, JSAMPARRAY output_buf,
+                 JDIMENSION output_col)
+{
+  jsimd_idct_ifast_sse2(compptr->dct_table, coef_block, output_buf,
+                        output_col);
+}
+
+GLOBAL(void)
+jsimd_idct_float(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+                 JCOEFPTR coef_block, JSAMPARRAY output_buf,
+                 JDIMENSION output_col)
+{
+  jsimd_idct_float_sse2(compptr->dct_table, coef_block, output_buf,
+                        output_col);
+}
+
+GLOBAL(int)
+jsimd_can_huff_encode_one_block(void)
+{
+  init_simd();
+
+  if (DCTSIZE != 8)
+    return 0;
+  if (sizeof(JCOEF) != 2)
+    return 0;
+
+  if ((simd_support & JSIMD_SSE2) && simd_huffman &&
+      IS_ALIGNED_SSE(jconst_huff_encode_one_block))
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(JOCTET *)
+jsimd_huff_encode_one_block(void *state, JOCTET *buffer, JCOEFPTR block,
+                            int last_dc_val, c_derived_tbl *dctbl,
+                            c_derived_tbl *actbl)
+{
+  return jsimd_huff_encode_one_block_sse2(state, buffer, block, last_dc_val,
+                                          dctbl, actbl);
+}
+
+GLOBAL(int)
+jsimd_can_encode_mcu_AC_first_prepare(void)
+{
+  init_simd();
+
+  if (DCTSIZE != 8)
+    return 0;
+  if (sizeof(JCOEF) != 2)
+    return 0;
+  if (simd_support & JSIMD_SSE2)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(void)
+jsimd_encode_mcu_AC_first_prepare(const JCOEF *block,
+                                  const int *jpeg_natural_order_start, int Sl,
+                                  int Al, JCOEF *values, size_t *zerobits)
+{
+  jsimd_encode_mcu_AC_first_prepare_sse2(block, jpeg_natural_order_start,
+                                         Sl, Al, values, zerobits);
+}
+
+GLOBAL(int)
+jsimd_can_encode_mcu_AC_refine_prepare(void)
+{
+  init_simd();
+
+  if (DCTSIZE != 8)
+    return 0;
+  if (sizeof(JCOEF) != 2)
+    return 0;
+  if (simd_support & JSIMD_SSE2)
+    return 1;
+
+  return 0;
+}
+
+GLOBAL(int)
+jsimd_encode_mcu_AC_refine_prepare(const JCOEF *block,
+                                   const int *jpeg_natural_order_start, int Sl,
+                                   int Al, JCOEF *absvalues, size_t *bits)
+{
+  return jsimd_encode_mcu_AC_refine_prepare_sse2(block,
+                                                 jpeg_natural_order_start,
+                                                 Sl, Al, absvalues, bits);
+}
diff --git a/3rdparty/libjpeg/src/simd/x86_64/jsimdcpu.asm b/3rdparty/libjpeg/src/simd/x86_64/jsimdcpu.asm
new file mode 100644
index 00000000..705f813d
--- /dev/null
+++ b/3rdparty/libjpeg/src/simd/x86_64/jsimdcpu.asm
@@ -0,0 +1,86 @@
+;
+; jsimdcpu.asm - SIMD instruction support check
+;
+; Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+; Copyright (C) 2016, D. R. Commander.
+;
+; Based on
+; x86 SIMD extension for IJG JPEG library
+; Copyright (C) 1999-2006, MIYASAKA Masaru.
+; For conditions of distribution and use, see copyright notice in jsimdext.inc
+;
+; This file should be assembled with NASM (Netwide Assembler),
+; can *not* be assembled with Microsoft's MASM or any compatible
+; assembler (including Borland's Turbo Assembler).
+; NASM is available from http://nasm.sourceforge.net/ or
+; http://sourceforge.net/project/showfiles.php?group_id=6208
+
+%include "jsimdext.inc"
+
+; --------------------------------------------------------------------------
+    SECTION     SEG_TEXT
+    BITS        64
+;
+; Check if the CPU supports SIMD instructions
+;
+; GLOBAL(unsigned int)
+; jpeg_simd_cpu_support(void)
+;
+
+    align       32
+    GLOBAL_FUNCTION(jpeg_simd_cpu_support)
+
+EXTN(jpeg_simd_cpu_support):
+    push        rbx
+    push        rdi
+
+    xor         rdi, rdi                ; simd support flag
+
+    ; Assume that all x86-64 processors support SSE & SSE2 instructions
+    or          rdi, JSIMD_SSE2
+    or          rdi, JSIMD_SSE
+
+    ; Check whether CPUID leaf 07H is supported
+    ; (leaf 07H is used to check for AVX2 instruction support)
+    mov         rax, 0
+    cpuid
+    cmp         rax, 7
+    jl          short .return           ; Maximum leaf < 07H
+
+    ; Check for AVX2 instruction support
+    mov         rax, 7
+    xor         rcx, rcx
+    cpuid
+    mov         rax, rbx                ; rax = Extended feature flags
+
+    test        rax, 1<<5               ; bit5:AVX2
+    jz          short .return
+
+    ; Check for AVX2 O/S support
+    mov         rax, 1
+    xor         rcx, rcx
+    cpuid
+    test        rcx, 1<<27
+    jz          short .return           ; O/S does not support XSAVE
+    test        rcx, 1<<28
+    jz          short .return           ; CPU does not support AVX2
+
+    xor         rcx, rcx
+    xgetbv
+    and         rax, 6
+    cmp         rax, 6                  ; O/S does not manage XMM/YMM state
+                                        ; using XSAVE
+    jnz         short .return
+
+    or          rdi, JSIMD_AVX2
+
+.return:
+    mov         rax, rdi
+
+    pop         rdi
+    pop         rbx
+    ret
+
+; For some reason, the OS X linker does not honor the request to align the
+; segment unless we do this.
+    align       32
diff --git a/3rdparty/libjpeg/src/structure.txt b/3rdparty/libjpeg/src/structure.txt
new file mode 100644
index 00000000..15b8d378
--- /dev/null
+++ b/3rdparty/libjpeg/src/structure.txt
@@ -0,0 +1,900 @@
+IJG JPEG LIBRARY:  SYSTEM ARCHITECTURE
+
+This file was part of the Independent JPEG Group's software:
+Copyright (C) 1991-2012, Thomas G. Lane, Guido Vollbeding.
+It was modified by The libjpeg-turbo Project to include only information
+relevant to libjpeg-turbo.
+For conditions of distribution and use, see the accompanying README.ijg file.
+
+
+This file provides an overview of the architecture of the IJG JPEG software;
+that is, the functions of the various modules in the system and the interfaces
+between modules.  For more precise details about any data structure or calling
+convention, see the include files and comments in the source code.
+
+We assume that the reader is already somewhat familiar with the JPEG standard.
+The README.ijg file includes references for learning about JPEG.  The file
+libjpeg.txt describes the library from the viewpoint of an application
+programmer using the library; it's best to read that file before this one.
+Also, the file coderules.txt describes the coding style conventions we use.
+
+In this document, JPEG-specific terminology follows the JPEG standard:
+  A "component" means a color channel, e.g., Red or Luminance.
+  A "sample" is a single component value (i.e., one number in the image data).
+  A "coefficient" is a frequency coefficient (a DCT transform output number).
+  A "block" is an 8x8 group of samples or coefficients.
+  An "MCU" (minimum coded unit) is an interleaved set of blocks of size
+        determined by the sampling factors, or a single block in a
+        noninterleaved scan.
+We do not use the terms "pixel" and "sample" interchangeably.  When we say
+pixel, we mean an element of the full-size image, while a sample is an element
+of the downsampled image.  Thus the number of samples may vary across
+components while the number of pixels does not.  (This terminology is not used
+rigorously throughout the code, but it is used in places where confusion would
+otherwise result.)
+
+
+*** System features ***
+
+The IJG distribution contains two parts:
+  * A subroutine library for JPEG compression and decompression.
+  * cjpeg/djpeg, two sample applications that use the library to transform
+    JFIF JPEG files to and from several other image formats.
+cjpeg/djpeg are of no great intellectual complexity: they merely add a simple
+command-line user interface and I/O routines for several uncompressed image
+formats.  This document concentrates on the library itself.
+
+We desire the library to be capable of supporting all JPEG baseline, extended
+sequential, and progressive DCT processes.  Hierarchical processes are not
+supported.
+
+The library does not support the lossless (spatial) JPEG process.  Lossless
+JPEG shares little or no code with lossy JPEG, and would normally be used
+without the extensive pre- and post-processing provided by this library.
+We feel that lossless JPEG is better handled by a separate library.
+
+Within these limits, any set of compression parameters allowed by the JPEG
+spec should be readable for decompression.  (We can be more restrictive about
+what formats we can generate.)  Although the system design allows for all
+parameter values, some uncommon settings are not yet implemented and may
+never be; nonintegral sampling ratios are the prime example.  Furthermore,
+we treat 8-bit vs. 12-bit data precision as a compile-time switch, not a
+run-time option, because most machines can store 8-bit pixels much more
+compactly than 12-bit.
+
+By itself, the library handles only interchange JPEG datastreams --- in
+particular the widely used JFIF file format.  The library can be used by
+surrounding code to process interchange or abbreviated JPEG datastreams that
+are embedded in more complex file formats.  (For example, libtiff uses this
+library to implement JPEG compression within the TIFF file format.)
+
+The library includes a substantial amount of code that is not covered by the
+JPEG standard but is necessary for typical applications of JPEG.  These
+functions preprocess the image before JPEG compression or postprocess it after
+decompression.  They include colorspace conversion, downsampling/upsampling,
+and color quantization.  This code can be omitted if not needed.
+
+A wide range of quality vs. speed tradeoffs are possible in JPEG processing,
+and even more so in decompression postprocessing.  The decompression library
+provides multiple implementations that cover most of the useful tradeoffs,
+ranging from very-high-quality down to fast-preview operation.  On the
+compression side we have generally not provided low-quality choices, since
+compression is normally less time-critical.  It should be understood that the
+low-quality modes may not meet the JPEG standard's accuracy requirements;
+nonetheless, they are useful for viewers.
+
+
+*** System overview ***
+
+The compressor and decompressor are each divided into two main sections:
+the JPEG compressor or decompressor proper, and the preprocessing or
+postprocessing functions.  The interface between these two sections is the
+image data that Rec. ITU-T T.81 | ISO/IEC 10918-1 regards as its input or
+output: this data is in the colorspace to be used for compression, and it is
+downsampled to the sampling factors to be used.  The preprocessing and
+postprocessing steps are responsible for converting a normal image
+representation to or from this form.  (Those few applications that want to deal
+with YCbCr downsampled data can skip the preprocessing or postprocessing step.)
+
+Looking more closely, the compressor library contains the following main
+elements:
+
+  Preprocessing:
+    * Color space conversion (e.g., RGB to YCbCr).
+    * Edge expansion and downsampling.  Optionally, this step can do simple
+      smoothing --- this is often helpful for low-quality source data.
+  JPEG proper:
+    * MCU assembly, DCT, quantization.
+    * Entropy coding (sequential or progressive, Huffman or arithmetic).
+
+In addition to these modules we need overall control, marker generation,
+and support code (memory management & error handling).  There is also a
+module responsible for physically writing the output data --- typically
+this is just an interface to fwrite(), but some applications may need to
+do something else with the data.
+
+The decompressor library contains the following main elements:
+
+  JPEG proper:
+    * Entropy decoding (sequential or progressive, Huffman or arithmetic).
+    * Dequantization, inverse DCT, MCU disassembly.
+  Postprocessing:
+    * Upsampling.  Optionally, this step may be able to do more general
+      rescaling of the image.
+    * Color space conversion (e.g., YCbCr to RGB).  This step may also
+      provide gamma adjustment [ currently it does not ].
+    * Optional color quantization (e.g., reduction to 256 colors).
+    * Optional color precision reduction (e.g., 24-bit to 15-bit color).
+      [This feature is not currently implemented.]
+
+We also need overall control, marker parsing, and a data source module.
+The support code (memory management & error handling) can be shared with
+the compression half of the library.
+
+There may be several implementations of each of these elements, particularly
+in the decompressor, where a wide range of speed/quality tradeoffs is very
+useful.  It must be understood that some of the best speedups involve
+merging adjacent steps in the pipeline.  For example, upsampling, color space
+conversion, and color quantization might all be done at once when using a
+low-quality ordered-dither technique.  The system architecture is designed to
+allow such merging where appropriate.
+
+
+Note: it is convenient to regard edge expansion (padding to block boundaries)
+as a preprocessing/postprocessing function, even though
+Rec. ITU-T T.81 | ISO/IEC 10918-1 includes it in compression/decompression.  We
+do this because downsampling/upsampling can be simplified a little if they work
+on padded data: it's not necessary to have special cases at the right and
+bottom edges.  Therefore the interface buffer is always an integral number of
+blocks wide and high, and we expect compression preprocessing to pad the source
+data properly.  Padding will occur only to the next block (8-sample) boundary.
+In an interleaved-scan situation, additional dummy blocks may be used to fill
+out MCUs, but the MCU assembly and disassembly logic will create or discard
+these blocks internally.  (This is advantageous for speed reasons, since we
+avoid DCTing the dummy blocks.  It also permits a small reduction in file size,
+because the compressor can choose dummy block contents so as to minimize their
+size in compressed form.  Finally, it makes the interface buffer specification
+independent of whether the file is actually interleaved or not.)  Applications
+that wish to deal directly with the downsampled data must provide similar
+buffering and padding for odd-sized images.
+
+
+*** Poor man's object-oriented programming ***
+
+It should be clear by now that we have a lot of quasi-independent processing
+steps, many of which have several possible behaviors.  To avoid cluttering the
+code with lots of switch statements, we use a simple form of object-style
+programming to separate out the different possibilities.
+
+For example, two different color quantization algorithms could be implemented
+as two separate modules that present the same external interface; at runtime,
+the calling code will access the proper module indirectly through an "object".
+
+We can get the limited features we need while staying within portable C.
+The basic tool is a function pointer.  An "object" is just a struct
+containing one or more function pointer fields, each of which corresponds to
+a method name in real object-oriented languages.  During initialization we
+fill in the function pointers with references to whichever module we have
+determined we need to use in this run.  Then invocation of the module is done
+by indirecting through a function pointer; on most machines this is no more
+expensive than a switch statement, which would be the only other way of
+making the required run-time choice.  The really significant benefit, of
+course, is keeping the source code clean and well structured.
+
+We can also arrange to have private storage that varies between different
+implementations of the same kind of object.  We do this by making all the
+module-specific object structs be separately allocated entities, which will
+be accessed via pointers in the master compression or decompression struct.
+The "public" fields or methods for a given kind of object are specified by
+a commonly known struct.  But a module's initialization code can allocate
+a larger struct that contains the common struct as its first member, plus
+additional private fields.  With appropriate pointer casting, the module's
+internal functions can access these private fields.  (For a simple example,
+see jdatadst.c, which implements the external interface specified by struct
+jpeg_destination_mgr, but adds extra fields.)
+
+(Of course this would all be a lot easier if we were using C++, but we are
+not yet prepared to assume that everyone has a C++ compiler.)
+
+An important benefit of this scheme is that it is easy to provide multiple
+versions of any method, each tuned to a particular case.  While a lot of
+precalculation might be done to select an optimal implementation of a method,
+the cost per invocation is constant.  For example, the upsampling step might
+have a "generic" method, plus one or more "hardwired" methods for the most
+popular sampling factors; the hardwired methods would be faster because they'd
+use straight-line code instead of for-loops.  The cost to determine which
+method to use is paid only once, at startup, and the selection criteria are
+hidden from the callers of the method.
+
+This plan differs a little bit from usual object-oriented structures, in that
+only one instance of each object class will exist during execution.  The
+reason for having the class structure is that on different runs we may create
+different instances (choose to execute different modules).  You can think of
+the term "method" as denoting the common interface presented by a particular
+set of interchangeable functions, and "object" as denoting a group of related
+methods, or the total shared interface behavior of a group of modules.
+
+
+*** Overall control structure ***
+
+We previously mentioned the need for overall control logic in the compression
+and decompression libraries.  In IJG implementations prior to v5, overall
+control was mostly provided by "pipeline control" modules, which proved to be
+large, unwieldy, and hard to understand.  To improve the situation, the
+control logic has been subdivided into multiple modules.  The control modules
+consist of:
+
+1. Master control for module selection and initialization.  This has two
+responsibilities:
+
+   1A.  Startup initialization at the beginning of image processing.
+        The individual processing modules to be used in this run are selected
+        and given initialization calls.
+
+   1B.  Per-pass control.  This determines how many passes will be performed
+        and calls each active processing module to configure itself
+        appropriately at the beginning of each pass.  End-of-pass processing,
+        where necessary, is also invoked from the master control module.
+
+   Method selection is partially distributed, in that a particular processing
+   module may contain several possible implementations of a particular method,
+   which it will select among when given its initialization call.  The master
+   control code need only be concerned with decisions that affect more than
+   one module.
+
+2. Data buffering control.  A separate control module exists for each
+   inter-processing-step data buffer.  This module is responsible for
+   invoking the processing steps that write or read that data buffer.
+
+Each buffer controller sees the world as follows:
+
+input data => processing step A => buffer => processing step B => output data
+                      |              |               |
+              ------------------ controller ------------------
+
+The controller knows the dataflow requirements of steps A and B: how much data
+they want to accept in one chunk and how much they output in one chunk.  Its
+function is to manage its buffer and call A and B at the proper times.
+
+A data buffer control module may itself be viewed as a processing step by a
+higher-level control module; thus the control modules form a binary tree with
+elementary processing steps at the leaves of the tree.
+
+The control modules are objects.  A considerable amount of flexibility can
+be had by replacing implementations of a control module.  For example:
+* Merging of adjacent steps in the pipeline is done by replacing a control
+  module and its pair of processing-step modules with a single processing-
+  step module.  (Hence the possible merges are determined by the tree of
+  control modules.)
+* In some processing modes, a given interstep buffer need only be a "strip"
+  buffer large enough to accommodate the desired data chunk sizes.  In other
+  modes, a full-image buffer is needed and several passes are required.
+  The control module determines which kind of buffer is used and manipulates
+  virtual array buffers as needed.  One or both processing steps may be
+  unaware of the multi-pass behavior.
+
+In theory, we might be able to make all of the data buffer controllers
+interchangeable and provide just one set of implementations for all.  In
+practice, each one contains considerable special-case processing for its
+particular job.  The buffer controller concept should be regarded as an
+overall system structuring principle, not as a complete description of the
+task performed by any one controller.
+
+
+*** Compression object structure ***
+
+Here is a sketch of the logical structure of the JPEG compression library:
+
+                                                 |-- Colorspace conversion
+                  |-- Preprocessing controller --|
+                  |                              |-- Downsampling
+Main controller --|
+                  |                            |-- Forward DCT, quantize
+                  |-- Coefficient controller --|
+                                               |-- Entropy encoding
+
+This sketch also describes the flow of control (subroutine calls) during
+typical image data processing.  Each of the components shown in the diagram is
+an "object" which may have several different implementations available.  One
+or more source code files contain the actual implementation(s) of each object.
+
+The objects shown above are:
+
+* Main controller: buffer controller for the subsampled-data buffer, which
+  holds the preprocessed input data.  This controller invokes preprocessing to
+  fill the subsampled-data buffer, and JPEG compression to empty it.  There is
+  usually no need for a full-image buffer here; a strip buffer is adequate.
+
+* Preprocessing controller: buffer controller for the downsampling input data
+  buffer, which lies between colorspace conversion and downsampling.  Note
+  that a unified conversion/downsampling module would probably replace this
+  controller entirely.
+
+* Colorspace conversion: converts application image data into the desired
+  JPEG color space; also changes the data from pixel-interleaved layout to
+  separate component planes.  Processes one pixel row at a time.
+
+* Downsampling: performs reduction of chroma components as required.
+  Optionally may perform pixel-level smoothing as well.  Processes a "row
+  group" at a time, where a row group is defined as Vmax pixel rows of each
+  component before downsampling, and Vk sample rows afterwards (remember Vk
+  differs across components).  Some downsampling or smoothing algorithms may
+  require context rows above and below the current row group; the
+  preprocessing controller is responsible for supplying these rows via proper
+  buffering.  The downsampler is responsible for edge expansion at the right
+  edge (i.e., extending each sample row to a multiple of 8 samples); but the
+  preprocessing controller is responsible for vertical edge expansion (i.e.,
+  duplicating the bottom sample row as needed to make a multiple of 8 rows).
+
+* Coefficient controller: buffer controller for the DCT-coefficient data.
+  This controller handles MCU assembly, including insertion of dummy DCT
+  blocks when needed at the right or bottom edge.  When performing
+  Huffman-code optimization or emitting a multiscan JPEG file, this
+  controller is responsible for buffering the full image.  The equivalent of
+  one fully interleaved MCU row of subsampled data is processed per call,
+  even when the JPEG file is noninterleaved.
+
+* Forward DCT and quantization: Perform DCT, quantize, and emit coefficients.
+  Works on one or more DCT blocks at a time.  (Note: the coefficients are now
+  emitted in normal array order, which the entropy encoder is expected to
+  convert to zigzag order as necessary.  Prior versions of the IJG code did
+  the conversion to zigzag order within the quantization step.)
+
+* Entropy encoding: Perform Huffman or arithmetic entropy coding and emit the
+  coded data to the data destination module.  Works on one MCU per call.
+  For progressive JPEG, the same DCT blocks are fed to the entropy coder
+  during each pass, and the coder must emit the appropriate subset of
+  coefficients.
+
+In addition to the above objects, the compression library includes these
+objects:
+
+* Master control: determines the number of passes required, controls overall
+  and per-pass initialization of the other modules.
+
+* Marker writing: generates JPEG markers (except for RSTn, which is emitted
+  by the entropy encoder when needed).
+
+* Data destination manager: writes the output JPEG datastream to its final
+  destination (e.g., a file).  The destination manager supplied with the
+  library knows how to write to a stdio stream or to a memory buffer;
+  for other behaviors, the surrounding application may provide its own
+  destination manager.
+
+* Memory manager: allocates and releases memory, controls virtual arrays
+  (with backing store management, where required).
+
+* Error handler: performs formatting and output of error and trace messages;
+  determines handling of nonfatal errors.  The surrounding application may
+  override some or all of this object's methods to change error handling.
+
+* Progress monitor: supports output of "percent-done" progress reports.
+  This object represents an optional callback to the surrounding application:
+  if wanted, it must be supplied by the application.
+
+The error handler, destination manager, and progress monitor objects are
+defined as separate objects in order to simplify application-specific
+customization of the JPEG library.  A surrounding application may override
+individual methods or supply its own all-new implementation of one of these
+objects.  The object interfaces for these objects are therefore treated as
+part of the application interface of the library, whereas the other objects
+are internal to the library.
+
+The error handler and memory manager are shared by JPEG compression and
+decompression; the progress monitor, if used, may be shared as well.
+
+
+*** Decompression object structure ***
+
+Here is a sketch of the logical structure of the JPEG decompression library:
+
+                                               |-- Entropy decoding
+                  |-- Coefficient controller --|
+                  |                            |-- Dequantize, Inverse DCT
+Main controller --|
+                  |                               |-- Upsampling
+                  |-- Postprocessing controller --|   |-- Colorspace conversion
+                                                  |-- Color quantization
+                                                  |-- Color precision reduction
+
+As before, this diagram also represents typical control flow.  The objects
+shown are:
+
+* Main controller: buffer controller for the subsampled-data buffer, which
+  holds the output of JPEG decompression proper.  This controller's primary
+  task is to feed the postprocessing procedure.  Some upsampling algorithms
+  may require context rows above and below the current row group; when this
+  is true, the main controller is responsible for managing its buffer so as
+  to make context rows available.  In the current design, the main buffer is
+  always a strip buffer; a full-image buffer is never required.
+
+* Coefficient controller: buffer controller for the DCT-coefficient data.
+  This controller handles MCU disassembly, including deletion of any dummy
+  DCT blocks at the right or bottom edge.  When reading a multiscan JPEG
+  file, this controller is responsible for buffering the full image.
+  (Buffering DCT coefficients, rather than samples, is necessary to support
+  progressive JPEG.)  The equivalent of one fully interleaved MCU row of
+  subsampled data is processed per call, even when the source JPEG file is
+  noninterleaved.
+
+* Entropy decoding: Read coded data from the data source module and perform
+  Huffman or arithmetic entropy decoding.  Works on one MCU per call.
+  For progressive JPEG decoding, the coefficient controller supplies the prior
+  coefficients of each MCU (initially all zeroes), which the entropy decoder
+  modifies in each scan.
+
+* Dequantization and inverse DCT: like it says.  Note that the coefficients
+  buffered by the coefficient controller have NOT been dequantized; we
+  merge dequantization and inverse DCT into a single step for speed reasons.
+  When scaled-down output is asked for, simplified DCT algorithms may be used
+  that emit fewer samples per DCT block, not the full 8x8.  Works on one DCT
+  block at a time.
+
+* Postprocessing controller: buffer controller for the color quantization
+  input buffer, when quantization is in use.  (Without quantization, this
+  controller just calls the upsampler.)  For two-pass quantization, this
+  controller is responsible for buffering the full-image data.
+
+* Upsampling: restores chroma components to full size.  (May support more
+  general output rescaling, too.  Note that if undersized DCT outputs have
+  been emitted by the DCT module, this module must adjust so that properly
+  sized outputs are created.)  Works on one row group at a time.  This module
+  also calls the color conversion module, so its top level is effectively a
+  buffer controller for the upsampling->color conversion buffer.  However, in
+  all but the highest-quality operating modes, upsampling and color
+  conversion are likely to be merged into a single step.
+
+* Colorspace conversion: convert from JPEG color space to output color space,
+  and change data layout from separate component planes to pixel-interleaved.
+  Works on one pixel row at a time.
+
+* Color quantization: reduce the data to colormapped form, using either an
+  externally specified colormap or an internally generated one.  This module
+  is not used for full-color output.  Works on one pixel row at a time; may
+  require two passes to generate a color map.  Note that the output will
+  always be a single component representing colormap indexes.  In the current
+  design, the output values are JSAMPLEs, so an 8-bit compilation cannot
+  quantize to more than 256 colors.  This is unlikely to be a problem in
+  practice.
+
+* Color reduction: this module handles color precision reduction, e.g.,
+  generating 15-bit color (5 bits/primary) from JPEG's 24-bit output.
+  Not quite clear yet how this should be handled... should we merge it with
+  colorspace conversion???
+
+Note that some high-speed operating modes might condense the entire
+postprocessing sequence to a single module (upsample, color convert, and
+quantize in one step).
+
+In addition to the above objects, the decompression library includes these
+objects:
+
+* Master control: determines the number of passes required, controls overall
+  and per-pass initialization of the other modules.  This is subdivided into
+  input and output control: jdinput.c controls only input-side processing,
+  while jdmaster.c handles overall initialization and output-side control.
+
+* Marker reading: decodes JPEG markers (except for RSTn).
+
+* Data source manager: supplies the input JPEG datastream.  The source
+  manager supplied with the library knows how to read from a stdio stream
+  or from a memory buffer;  for other behaviors, the surrounding application
+  may provide its own source manager.
+
+* Memory manager: same as for compression library.
+
+* Error handler: same as for compression library.
+
+* Progress monitor: same as for compression library.
+
+As with compression, the data source manager, error handler, and progress
+monitor are candidates for replacement by a surrounding application.
+
+
+*** Decompression input and output separation ***
+
+To support efficient incremental display of progressive JPEG files, the
+decompressor is divided into two sections that can run independently:
+
+1. Data input includes marker parsing, entropy decoding, and input into the
+   coefficient controller's DCT coefficient buffer.  Note that this
+   processing is relatively cheap and fast.
+
+2. Data output reads from the DCT coefficient buffer and performs the IDCT
+   and all postprocessing steps.
+
+For a progressive JPEG file, the data input processing is allowed to get
+arbitrarily far ahead of the data output processing.  (This occurs only
+if the application calls jpeg_consume_input(); otherwise input and output
+run in lockstep, since the input section is called only when the output
+section needs more data.)  In this way the application can avoid making
+extra display passes when data is arriving faster than the display pass
+can run.  Furthermore, it is possible to abort an output pass without
+losing anything, since the coefficient buffer is read-only as far as the
+output section is concerned.  See libjpeg.txt for more detail.
+
+A full-image coefficient array is only created if the JPEG file has multiple
+scans (or if the application specifies buffered-image mode anyway).  When
+reading a single-scan file, the coefficient controller normally creates only
+a one-MCU buffer, so input and output processing must run in lockstep in this
+case.  jpeg_consume_input() is effectively a no-op in this situation.
+
+The main impact of dividing the decompressor in this fashion is that we must
+be very careful with shared variables in the cinfo data structure.  Each
+variable that can change during the course of decompression must be
+classified as belonging to data input or data output, and each section must
+look only at its own variables.  For example, the data output section may not
+depend on any of the variables that describe the current scan in the JPEG
+file, because these may change as the data input section advances into a new
+scan.
+
+The progress monitor is (somewhat arbitrarily) defined to treat input of the
+file as one pass when buffered-image mode is not used, and to ignore data
+input work completely when buffered-image mode is used.  Note that the
+library has no reliable way to predict the number of passes when dealing
+with a progressive JPEG file, nor can it predict the number of output passes
+in buffered-image mode.  So the work estimate is inherently bogus anyway.
+
+No comparable division is currently made in the compression library, because
+there isn't any real need for it.
+
+
+*** Data formats ***
+
+Arrays of pixel sample values use the following data structure:
+
+    typedef something JSAMPLE;          a pixel component value, 0..MAXJSAMPLE
+    typedef JSAMPLE *JSAMPROW;          ptr to a row of samples
+    typedef JSAMPROW *JSAMPARRAY;       ptr to a list of rows
+    typedef JSAMPARRAY *JSAMPIMAGE;     ptr to a list of color-component arrays
+
+The basic element type JSAMPLE will be one of unsigned char or short.  Short
+will be used if samples wider than 8 bits are to be supported (this is a
+compile-time option).  Otherwise, unsigned char is used.
+
+With these conventions, JSAMPLE values can be assumed to be >= 0.  This helps
+simplify correct rounding during downsampling, etc.  The JPEG standard's
+specification that sample values run from -128..127 is accommodated by
+subtracting 128 from the sample value in the DCT step.  Similarly, during
+decompression the output of the IDCT step will be immediately shifted back to
+0..255.  (NB: different values are required when 12-bit samples are in use.
+The code is written in terms of MAXJSAMPLE and CENTERJSAMPLE, which will be
+defined as 255 and 128 respectively in an 8-bit implementation, and as 4095
+and 2048 in a 12-bit implementation.)
+
+We use a pointer per row, rather than a two-dimensional JSAMPLE array.  This
+choice costs only a small amount of memory and has several benefits:
+* Code using the data structure doesn't need to know the allocated width of
+  the rows.  This simplifies edge expansion/compression, since we can work
+  in an array that's wider than the logical picture width.
+* Indexing doesn't require multiplication; this is a performance win on many
+  machines.
+* Arrays with more than 64K total elements can be supported even on machines
+  where malloc() cannot allocate chunks larger than 64K.
+* The rows forming a component array may be allocated at different times
+  without extra copying.  This trick allows some speedups in smoothing steps
+  that need access to the previous and next rows.
+
+Note that each color component is stored in a separate array; we don't use the
+traditional layout in which the components of a pixel are stored together.
+This simplifies coding of modules that work on each component independently,
+because they don't need to know how many components there are.  Furthermore,
+we can read or write each component to a temporary file independently, which
+is helpful when dealing with noninterleaved JPEG files.
+
+In general, a specific sample value is accessed by code such as
+        image[colorcomponent][row][col]
+where col is measured from the image left edge, but row is measured from the
+first sample row currently in memory.  Either of the first two indexings can
+be precomputed by copying the relevant pointer.
+
+
+Since most image-processing applications prefer to work on images in which
+the components of a pixel are stored together, the data passed to or from the
+surrounding application uses the traditional convention: a single pixel is
+represented by N consecutive JSAMPLE values, and an image row is an array of
+(# of color components)*(image width) JSAMPLEs.  One or more rows of data can
+be represented by a pointer of type JSAMPARRAY in this scheme.  This scheme is
+converted to component-wise storage inside the JPEG library.  (Applications
+that want to skip JPEG preprocessing or postprocessing will have to contend
+with component-wise storage.)
+
+
+Arrays of DCT-coefficient values use the following data structure:
+
+    typedef short JCOEF;                a 16-bit signed integer
+    typedef JCOEF JBLOCK[DCTSIZE2];     an 8x8 block of coefficients
+    typedef JBLOCK *JBLOCKROW;          ptr to one horizontal row of 8x8 blocks
+    typedef JBLOCKROW *JBLOCKARRAY;     ptr to a list of such rows
+    typedef JBLOCKARRAY *JBLOCKIMAGE;   ptr to a list of color component arrays
+
+The underlying type is at least a 16-bit signed integer; while "short" is big
+enough on all machines of interest, on some machines it is preferable to use
+"int" for speed reasons, despite the storage cost.  Coefficients are grouped
+into 8x8 blocks (but we always use #defines DCTSIZE and DCTSIZE2 rather than
+"8" and "64").
+
+The contents of a coefficient block may be in either "natural" or zigzagged
+order, and may be true values or divided by the quantization coefficients,
+depending on where the block is in the processing pipeline.  In the current
+library, coefficient blocks are kept in natural order everywhere; the entropy
+codecs zigzag or dezigzag the data as it is written or read.  The blocks
+contain quantized coefficients everywhere outside the DCT/IDCT subsystems.
+(This latter decision may need to be revisited to support variable
+quantization a la JPEG Part 3.)
+
+Notice that the allocation unit is now a row of 8x8 blocks, corresponding to
+eight rows of samples.  Otherwise the structure is much the same as for
+samples, and for the same reasons.
+
+
+*** Suspendable processing ***
+
+In some applications it is desirable to use the JPEG library as an
+incremental, memory-to-memory filter.  In this situation the data source or
+destination may be a limited-size buffer, and we can't rely on being able to
+empty or refill the buffer at arbitrary times.  Instead the application would
+like to have control return from the library at buffer overflow/underrun, and
+then resume compression or decompression at a later time.
+
+This scenario is supported for simple cases.  (For anything more complex, we
+recommend that the application "bite the bullet" and develop real multitasking
+capability.)  The libjpeg.txt file goes into more detail about the usage and
+limitations of this capability; here we address the implications for library
+structure.
+
+The essence of the problem is that the entropy codec (coder or decoder) must
+be prepared to stop at arbitrary times.  In turn, the controllers that call
+the entropy codec must be able to stop before having produced or consumed all
+the data that they normally would handle in one call.  That part is reasonably
+straightforward: we make the controller call interfaces include "progress
+counters" which indicate the number of data chunks successfully processed, and
+we require callers to test the counter rather than just assume all of the data
+was processed.
+
+Rather than trying to restart at an arbitrary point, the current Huffman
+codecs are designed to restart at the beginning of the current MCU after a
+suspension due to buffer overflow/underrun.  At the start of each call, the
+codec's internal state is loaded from permanent storage (in the JPEG object
+structures) into local variables.  On successful completion of the MCU, the
+permanent state is updated.  (This copying is not very expensive, and may even
+lead to *improved* performance if the local variables can be registerized.)
+If a suspension occurs, the codec simply returns without updating the state,
+thus effectively reverting to the start of the MCU.  Note that this implies
+leaving some data unprocessed in the source/destination buffer (ie, the
+compressed partial MCU).  The data source/destination module interfaces are
+specified so as to make this possible.  This also implies that the data buffer
+must be large enough to hold a worst-case compressed MCU; a couple thousand
+bytes should be enough.
+
+In a successive-approximation AC refinement scan, the progressive Huffman
+decoder has to be able to undo assignments of newly nonzero coefficients if it
+suspends before the MCU is complete, since decoding requires distinguishing
+previously-zero and previously-nonzero coefficients.  This is a bit tedious
+but probably won't have much effect on performance.  Other variants of Huffman
+decoding need not worry about this, since they will just store the same values
+again if forced to repeat the MCU.
+
+This approach would probably not work for an arithmetic codec, since its
+modifiable state is quite large and couldn't be copied cheaply.  Instead it
+would have to suspend and resume exactly at the point of the buffer end.
+
+The JPEG marker reader is designed to cope with suspension at an arbitrary
+point.  It does so by backing up to the start of the marker parameter segment,
+so the data buffer must be big enough to hold the largest marker of interest.
+Again, a couple KB should be adequate.  (A special "skip" convention is used
+to bypass COM and APPn markers, so these can be larger than the buffer size
+without causing problems; otherwise a 64K buffer would be needed in the worst
+case.)
+
+The JPEG marker writer currently does *not* cope with suspension.
+We feel that this is not necessary; it is much easier simply to require
+the application to ensure there is enough buffer space before starting.  (An
+empty 2K buffer is more than sufficient for the header markers; and ensuring
+there are a dozen or two bytes available before calling jpeg_finish_compress()
+will suffice for the trailer.)  This would not work for writing multi-scan
+JPEG files, but we simply do not intend to support that capability with
+suspension.
+
+
+*** Memory manager services ***
+
+The JPEG library's memory manager controls allocation and deallocation of
+memory, and it manages large "virtual" data arrays on machines where the
+operating system does not provide virtual memory.  Note that the same
+memory manager serves both compression and decompression operations.
+
+In all cases, allocated objects are tied to a particular compression or
+decompression master record, and they will be released when that master
+record is destroyed.
+
+The memory manager does not provide explicit deallocation of objects.
+Instead, objects are created in "pools" of free storage, and a whole pool
+can be freed at once.  This approach helps prevent storage-leak bugs, and
+it speeds up operations whenever malloc/free are slow (as they often are).
+The pools can be regarded as lifetime identifiers for objects.  Two
+pools/lifetimes are defined:
+  * JPOOL_PERMANENT     lasts until master record is destroyed
+  * JPOOL_IMAGE         lasts until done with image (JPEG datastream)
+Permanent lifetime is used for parameters and tables that should be carried
+across from one datastream to another; this includes all application-visible
+parameters.  Image lifetime is used for everything else.  (A third lifetime,
+JPOOL_PASS = one processing pass, was originally planned.  However it was
+dropped as not being worthwhile.  The actual usage patterns are such that the
+peak memory usage would be about the same anyway; and having per-pass storage
+substantially complicates the virtual memory allocation rules --- see below.)
+
+The memory manager deals with three kinds of object:
+1. "Small" objects.  Typically these require no more than 10K-20K total.
+2. "Large" objects.  These may require tens to hundreds of K depending on
+   image size.  Semantically they behave the same as small objects, but we
+   distinguish them because pool allocation heuristics may differ for large and
+   small objects (historically, large objects were also referenced by far
+   pointers on MS-DOS machines.)  Note that individual "large" objects cannot
+   exceed the size allowed by type size_t, which may be 64K or less on some
+   machines.
+3. "Virtual" objects.  These are large 2-D arrays of JSAMPLEs or JBLOCKs
+   (typically large enough for the entire image being processed).  The
+   memory manager provides stripwise access to these arrays.  On machines
+   without virtual memory, the rest of the array may be swapped out to a
+   temporary file.
+
+(Note: JSAMPARRAY and JBLOCKARRAY data structures are a combination of large
+objects for the data proper and small objects for the row pointers.  For
+convenience and speed, the memory manager provides single routines to create
+these structures.  Similarly, virtual arrays include a small control block
+and a JSAMPARRAY or JBLOCKARRAY working buffer, all created with one call.)
+
+In the present implementation, virtual arrays are only permitted to have image
+lifespan.  (Permanent lifespan would not be reasonable, and pass lifespan is
+not very useful since a virtual array's raison d'etre is to store data for
+multiple passes through the image.)  We also expect that only "small" objects
+will be given permanent lifespan, though this restriction is not required by
+the memory manager.
+
+In a non-virtual-memory machine, some performance benefit can be gained by
+making the in-memory buffers for virtual arrays be as large as possible.
+(For small images, the buffers might fit entirely in memory, so blind
+swapping would be very wasteful.)  The memory manager will adjust the height
+of the buffers to fit within a prespecified maximum memory usage.  In order
+to do this in a reasonably optimal fashion, the manager needs to allocate all
+of the virtual arrays at once.  Therefore, there isn't a one-step allocation
+routine for virtual arrays; instead, there is a "request" routine that simply
+allocates the control block, and a "realize" routine (called just once) that
+determines space allocation and creates all of the actual buffers.  The
+realize routine must allow for space occupied by non-virtual large objects.
+(We don't bother to factor in the space needed for small objects, on the
+grounds that it isn't worth the trouble.)
+
+To support all this, we establish the following protocol for doing business
+with the memory manager:
+  1. Modules must request virtual arrays (which may have only image lifespan)
+     during the initial setup phase, i.e., in their jinit_xxx routines.
+  2. All "large" objects (including JSAMPARRAYs and JBLOCKARRAYs) must also be
+     allocated during initial setup.
+  3. realize_virt_arrays will be called at the completion of initial setup.
+     The above conventions ensure that sufficient information is available
+     for it to choose a good size for virtual array buffers.
+Small objects of any lifespan may be allocated at any time.  We expect that
+the total space used for small objects will be small enough to be negligible
+in the realize_virt_arrays computation.
+
+In a virtual-memory machine, we simply pretend that the available space is
+infinite, thus causing realize_virt_arrays to decide that it can allocate all
+the virtual arrays as full-size in-memory buffers.  The overhead of the
+virtual-array access protocol is very small when no swapping occurs.
+
+A virtual array can be specified to be "pre-zeroed"; when this flag is set,
+never-yet-written sections of the array are set to zero before being made
+available to the caller.  If this flag is not set, never-written sections
+of the array contain garbage.  (This feature exists primarily because the
+equivalent logic would otherwise be needed in jdcoefct.c for progressive
+JPEG mode; we may as well make it available for possible other uses.)
+
+The first write pass on a virtual array is required to occur in top-to-bottom
+order; read passes, as well as any write passes after the first one, may
+access the array in any order.  This restriction exists partly to simplify
+the virtual array control logic, and partly because some file systems may not
+support seeking beyond the current end-of-file in a temporary file.  The main
+implication of this restriction is that rearrangement of rows (such as
+converting top-to-bottom data order to bottom-to-top) must be handled while
+reading data out of the virtual array, not while putting it in.
+
+
+*** Memory manager internal structure ***
+
+To isolate system dependencies as much as possible, we have broken the
+memory manager into two parts.  There is a reasonably system-independent
+"front end" (jmemmgr.c) and a "back end" that contains only the code
+likely to change across systems.  All of the memory management methods
+outlined above are implemented by the front end.  The back end provides
+the following routines for use by the front end (none of these routines
+are known to the rest of the JPEG code):
+
+jpeg_mem_init, jpeg_mem_term    system-dependent initialization/shutdown
+
+jpeg_get_small, jpeg_free_small interface to malloc and free library routines
+                                (or their equivalents)
+
+jpeg_get_large, jpeg_free_large historically was used to interface with
+                                FAR malloc/free on MS-DOS machines;  now the
+                                same as jpeg_get_small/jpeg_free_small
+
+jpeg_mem_available              estimate available memory
+
+jpeg_open_backing_store         create a backing-store object
+
+read_backing_store,             manipulate a backing-store object
+write_backing_store,
+close_backing_store
+
+On some systems there will be more than one type of backing-store object.
+jpeg_open_backing_store is responsible for choosing how to implement a given
+object.  The read/write/close routines are method pointers in the structure
+that describes a given object; this lets them be different for different object
+types.
+
+It may be necessary to ensure that backing store objects are explicitly
+released upon abnormal program termination.  To support this, we will expect
+the main program or surrounding application to arrange to call self_destruct
+(typically via jpeg_destroy) upon abnormal termination.  This may require a
+SIGINT signal handler or equivalent.  We don't want to have the back end module
+install its own signal handler, because that would pre-empt the surrounding
+application's ability to control signal handling.
+
+The IJG distribution includes several memory manager back end implementations.
+Usually the same back end should be suitable for all applications on a given
+system, but it is possible for an application to supply its own back end at
+need.
+
+
+*** Implications of DNL marker ***
+
+Some JPEG files may use a DNL marker to postpone definition of the image
+height (this would be useful for a fax-like scanner's output, for instance).
+In these files the SOF marker claims the image height is 0, and you only
+find out the true image height at the end of the first scan.
+
+We could read these files as follows:
+1. Upon seeing zero image height, replace it by 65535 (the maximum allowed).
+2. When the DNL is found, update the image height in the global image
+   descriptor.
+This implies that control modules must avoid making copies of the image
+height, and must re-test for termination after each MCU row.  This would
+be easy enough to do.
+
+In cases where image-size data structures are allocated, this approach will
+result in very inefficient use of virtual memory or much-larger-than-necessary
+temporary files.  This seems acceptable for something that probably won't be a
+mainstream usage.  People might have to forgo use of memory-hogging options
+(such as two-pass color quantization or noninterleaved JPEG files) if they
+want efficient conversion of such files.  (One could improve efficiency by
+demanding a user-supplied upper bound for the height, less than 65536; in most
+cases it could be much less.)
+
+The standard also permits the SOF marker to overestimate the image height,
+with a DNL to give the true, smaller height at the end of the first scan.
+This would solve the space problems if the overestimate wasn't too great.
+However, it implies that you don't even know whether DNL will be used.
+
+This leads to a couple of very serious objections:
+1. Testing for a DNL marker must occur in the inner loop of the decompressor's
+   Huffman decoder; this implies a speed penalty whether the feature is used
+   or not.
+2. There is no way to hide the last-minute change in image height from an
+   application using the decoder.  Thus *every* application using the IJG
+   library would suffer a complexity penalty whether it cared about DNL or
+   not.
+We currently do not support DNL because of these problems.
+
+A different approach is to insist that DNL-using files be preprocessed by a
+separate program that reads ahead to the DNL, then goes back and fixes the SOF
+marker.  This is a much simpler solution and is probably far more efficient.
+Even if one wants piped input, buffering the first scan of the JPEG file needs
+a lot smaller temp file than is implied by the maximum-height method.  For
+this approach we'd simply treat DNL as a no-op in the decompressor (at most,
+check that it matches the SOF image height).
+
+We will not worry about making the compressor capable of outputting DNL.
+Something similar to the first scheme above could be applied if anyone ever
+wants to make that work.
diff --git a/3rdparty/libjpeg/src/testimages/nightshot_iso_100.bmp b/3rdparty/libjpeg/src/testimages/nightshot_iso_100.bmp
new file mode 100644
index 00000000..5a271516
Binary files /dev/null and b/3rdparty/libjpeg/src/testimages/nightshot_iso_100.bmp differ
diff --git a/3rdparty/libjpeg/src/testimages/nightshot_iso_100.txt b/3rdparty/libjpeg/src/testimages/nightshot_iso_100.txt
new file mode 100644
index 00000000..93208865
--- /dev/null
+++ b/3rdparty/libjpeg/src/testimages/nightshot_iso_100.txt
@@ -0,0 +1,25 @@
+libjpeg-turbo note:  This image was extracted from the 8-bit nightshot_iso_100
+image.  The original can be downloaded at the link below.
+
+The New Image Compression Test Set - Jan 2008
+http://www.imagecompression.info/test_images
+
+The images historically used for compression research (lena, barbra, pepper etc...) have outlived their useful life and its about time they become a part of history only. They are too small, come from data sources too old and are available in only 8-bit precision.
+
+These images have been carefully selected to aid in image compression algorithm research and evaluation. These are photographic images chosen to come from a wide variety of sources and each one picked to stress different aspects of algorithms. Images are available in 8-bit, 16-bit and 16-bit linear variations, RGB and gray.
+
+Images are available without any prohibitive copyright restrictions.
+
+These images are (c) there respective owners. You are granted full redistribution and publication rights on these images provided:
+
+1. The origin of the pictures must not be misrepresented; you must not claim that you took the original pictures. If you use, publish or redistribute them, an acknowledgment would be appreciated but is not required.
+2. Altered versions must be plainly marked as such, and must not be misinterpreted as being the originals.
+3. No payment is required for distribution this material, it must be available freely under the conditions stated here. That is, it is prohibited to sell the material.
+4. This notice may not be removed or altered from any distribution.
+
+Acknowledgments: A lot of people contributed a lot of time and effort in making this test set possible. Thanks to everyone who voiced their opinion in any of the discussions online. Thanks to Axel Becker, Thomas Richter and Niels Fröhling for their extensive help in picking images, running all the various tests etc... Thanks to Pete Fraser, Tony Story, Wayne J. Cosshall, David Coffin, Bruce Lindbloom and raw.fotosite.pl for the images which make up this set.
+
+Sachin Garg [India]
+sachingarg@c10n.info
+
+www.sachingarg.com | www.c10n.info | www.imagecompression.info
diff --git a/3rdparty/libjpeg/src/testimages/test.scan b/3rdparty/libjpeg/src/testimages/test.scan
new file mode 100644
index 00000000..563446da
--- /dev/null
+++ b/3rdparty/libjpeg/src/testimages/test.scan
@@ -0,0 +1,5 @@
+0 1 2: 0 0 0 0;
+0: 1 16 0 0;
+0: 17 63 0 0;
+1: 1 63 0 0;
+2: 1 63 0 0;
diff --git a/3rdparty/libjpeg/src/testimages/test1.icc b/3rdparty/libjpeg/src/testimages/test1.icc
new file mode 100644
index 00000000..d0245c81
Binary files /dev/null and b/3rdparty/libjpeg/src/testimages/test1.icc differ
diff --git a/3rdparty/libjpeg/src/testimages/test1.icc.txt b/3rdparty/libjpeg/src/testimages/test1.icc.txt
new file mode 100644
index 00000000..57fc52f7
--- /dev/null
+++ b/3rdparty/libjpeg/src/testimages/test1.icc.txt
@@ -0,0 +1,20 @@
+Little CMS
+Copyright (c) 1998-2011 Marti Maria Saguer
+
+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.
diff --git a/3rdparty/libjpeg/src/testimages/test2.icc b/3rdparty/libjpeg/src/testimages/test2.icc
new file mode 100644
index 00000000..73f1b5aa
Binary files /dev/null and b/3rdparty/libjpeg/src/testimages/test2.icc differ
diff --git a/3rdparty/libjpeg/src/testimages/test2.icc.txt b/3rdparty/libjpeg/src/testimages/test2.icc.txt
new file mode 100644
index 00000000..57fc52f7
--- /dev/null
+++ b/3rdparty/libjpeg/src/testimages/test2.icc.txt
@@ -0,0 +1,20 @@
+Little CMS
+Copyright (c) 1998-2011 Marti Maria Saguer
+
+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.
diff --git a/3rdparty/libjpeg/src/testimages/testimgari.jpg b/3rdparty/libjpeg/src/testimages/testimgari.jpg
new file mode 100644
index 00000000..89664874
Binary files /dev/null and b/3rdparty/libjpeg/src/testimages/testimgari.jpg differ
diff --git a/3rdparty/libjpeg/src/testimages/testimgint.jpg b/3rdparty/libjpeg/src/testimages/testimgint.jpg
new file mode 100644
index 00000000..2501c615
Binary files /dev/null and b/3rdparty/libjpeg/src/testimages/testimgint.jpg differ
diff --git a/3rdparty/libjpeg/src/testimages/testorig.jpg b/3rdparty/libjpeg/src/testimages/testorig.jpg
new file mode 100644
index 00000000..9816a0c6
Binary files /dev/null and b/3rdparty/libjpeg/src/testimages/testorig.jpg differ
diff --git a/3rdparty/libjpeg/src/testimages/testorig.ppm b/3rdparty/libjpeg/src/testimages/testorig.ppm
new file mode 100644
index 00000000..2a5d1e95
--- /dev/null
+++ b/3rdparty/libjpeg/src/testimages/testorig.ppm
@@ -0,0 +1,4 @@
+P6
+227 149
+255
+0/-0/-10.21/51.51.62/62/83/83/:2/:2/:3-:3-:3-:3-:2/:2/91.80-80-91.:2/:2/80-80-80-80-80-80-80-80-6.+6.+6.+5-*5-*5-*4,)4,)4,)4,)4,)4,)4,)4,)4,)2-)/*$/,%0-&0-&1.'2/(30)30)63,63,74-85.96/96/:70:7.A:0B<0D>2F@4IA4JB5KC6KC6NE6MD5OC3NB2OC3OC3PD4RE5R?1Y?2b@4nB5}E6�H8�G9�F7�H;�F;�F;�F=�G>�H@�H@�EB�FL�CL�EM�EI�CI�BD�?C�=A�;A�:@�:?�<?�?B�?@�?<�A7�=/�@.�@.�?-�?-�@-�?-�@-�?.�A.�A-�B,�A-�@+�A+�A,�>-�?/�?/�>.�>,�>,�<+�<+�>-�>-�=*�=*�>+�>+�?,�@/�?6�>5�=4�?3�B3�D3�D4�D4�?0�B3�F:�H;�G;oA2U9+C3&=52:659548437116005//5//72/72/72/61.61-61-50,41,//-.0-//-//-0/-0/-2.-2.-5,-4+,4*+3)*7(+=.1E69P:<jAE|HJ�NO�OQ�W[�dn�o��t��{������~��tz�`a�TKvQEiSJgPH_MH^TQbfdo|}�������������������{|lfgWYXFQNEUR[UQbUQb0/-0/-10.10.40-51.62/62/83/83/:2/:2/:3-:3-:3-:3-:2/91.80-80-80-80-91.:2/80-80-80-80-80-80-80-80-6.+6.+6.+5-*5-*4,)4,)4,)5-*5-*5-*5-*5-*5-*5-*3.*1,(0-&0-&1.'2/(30)41*41*63,63,74-85.85.96/:70:7.@9/B<0C=1E?3H@3IA4JB5JB5LC4LC4MA3MA1MA1NB2OC3QD4P>0U?1^A3jC4xD6�F5�E5�C3�C4�A4�@6�B7�D:�E<�F=�C@�EI�BI�CI�DH�DG�CE�@C�?C�;A�:@�:?�<?�?@�@@�@<�@6�>/�@.�?-�?-�?-�?,�?-�@-�?.�A.�A-�B,�@,�@+�@*�A,�>-�?/�?/�>.�>,�=+�<+�<+�>-�=,�=*�=*�=*�>+�?,�@1�A6�?6�>5�?4�A3�D4�C4�D5�A2�C6�F:�H=�G:l@3S9*B4)>63:65:6584382271160060072/72/72/61.61-61-50,41,//-.0-//-//-0/-0/-2.-2.-4..5,-5+,3)*5)+<-0C47N8:d=>vDC�JI�MN�TV�aj�l}�r��{������{��ou�[[�RIvOCiOFePH`PH_RN_[Yfnot������������������~qjk[][LVSJXSZVRaXQa/.,0/-0/-10.40/40/51.51.72.72.72.72.92,92,92,92,91.80.80.7/-7/-80.80.91/80.80.80.80.80.80.80.80.6.,6.,5-+5-+5-+4,*4,*4,*6.,6.,6.,6.,6.,6.,6.,4/+2-)1.)2/*30+30+41,52-52-63.63.74/74/850961961:70?8.@:.B<0D>2G?4H@5H@3H@3J@4I@1K?1K?1K?1L@2MA1NB2MA3QA2YB4dC4qC4|C2�B2�A0�<-�;,�;.�=2�@6�D:�F=�D>�CE�@F�BG�CG�DF�CE�AD�?D�;@�:?�;@�=@�@@�B>�@;�@5�=.�@-�@-�@-�?-�?-�>,�@,�?-�@-�@.�@-�A,�@+�@*�@+�>-�?/�>.�>.�>.�=-�=+�=+�>,�>,�<+�<+�=,�>-�?.�?0�A6�?5�>3�?3�A4�C5�D5�C5�D8�G<�I=�J=�G;h@4Q:,B5,?74=77<66;5594183072/72/62/62/62/51.52-52-41,21,/1.-2./1./1.00.00.10.3/.5//4..5,-4*+4*+9-/>24I56[97l?:}FA�ID�OM�[`�fv�n��w��}�}��u~�gl�UU�MEvLAkMAeOFcQHcNI_NK\[[esty��������������|xzlfhZZ[MVSLZU[ZT`[S`.-+/.,/.,0/-3/.40/40-51.61-61-61-61-81+81+81+80-80.7/-6.,6.,6.,6.,7/-80.80.80.80.80.80.80.80.80.5-+5-+5-+5-+4,*4,*3+)3+)6.,6.,6.,6.,6.,6.,6.,4/,30+30+30+41,41,52-52-52-52-63.63.74/85096196196/>7-?9-A;/B<0E=2E=2F>3F>1G=1G=1H<.I=/I=/J>0L@0JA0LE5NE4VE5^D3iD2sB1~A/�?-�9)�9'�9*�=.�@3�E8�H<�F>�DC�AC�BE�DE�DE�BC�@C�?A�;@�:?�<A�>@�A@�B=�@9�@3�>.�@,�@,�@,�>,�?,�?,�?+�@-�?,�@-�?,�@+�@*�@)�?*�>,�>.�>.�>.�=-�=-�<*�<*�=+�=+�=+�=+�<+�>,�>-�?/�A6�@6�>2�@4�B6�C8�C7�B7�F<�J?�KB�J@|F:b@4L:.A7-@85>88=77<66:5294183083062/62/62/32.52-32-21,12--2.-2./1./1.00.00.10.10.5106005//5,-4+,6,-:01D22T71c;3rB8{E;�IE�RU�_l�i��s�}y�x}�ow�ae�SR�MDyL@pL@hPEgQFfLC^HCWNLZ^^fjnquyxy~xz�vwzokoa`bUWYLTTL]WY]V]]V^------/.,/.,0/-10.3/,40-40-40-50,50,50,50,7/,7/,4/,4/,3.+3.+3.+3.+4/,4/,50-50-50-50-50-50-50-50-3.+3.+3.+2-*2-*1,)1,)1,)4/,4/,4/,4/,4/,4/,4/,4/,41,41,41,41,52-52-52-52-52-52-63.74/74/85096196/<5-=6,?8.@9/B90C;0C;0C;0E;/D:.F:.G;/H<.I=/J>0I@1JG6MH5RG5YF5bE3jD1uB/|?,�;)�:)�:*�=,�B2�F8�J=�J@�GB�DC�DD�ED�CC�AA�=@�<>�:?�;=�<>�?>�B>�C:�A5�?0�?-�@-�?,�?,�?.�>-�>-�?-�>.�?-�?,�?+�?,�?+�>*�?+�>,�?.�?.�>-�>-�=,�=,�=,�=,�=,�=,�=,�<,�>-�>.�@/�B4�A4�@4�@3�A7�C9�B:�A9�C;�H?�LC�KCtE;Z>2E9-=6,A96@86?75>64=53<4294183062/43/43/23.32.23.12-02--2.,2.-2.-2./1./1.00.10.3205105104..2,,5,-7./>0/N5.Y9.e=1oA4tC<yKK�Ze�h�p�zx�u{�lt�_d�TT�OG�LBwNAmNBhMAeJA`GBYHEXKKWMPU^bc`fbbia`f\Z`VWZOUXMXXP^YV`WX`WZ,,,,,,.-+/.,/.,0/-3/.3/,2.+2.+3.*3.*3.*3.*5-*5-*3.+3.+2-*2-*2-*2-*3.+3.+3.+3.+3.+3.+3.+3.+3.+3.+3.+2-*2-*2-*1,)1,)1,)0+(4/,4/,4/,4/,4/,4/,4/,4/,40-41,41,41,41,41,41,41,41,52-52-63.74/85085096/;4,<5+=6,?8.@7.A8/A8/A9.C9/C9-E9-F:.G;/I=/J>0HA1JG6JI7NG5VF6\E3dC2lA0t?-|=,�<*�;*�=,�@1�F5�J:�J=�H@�EA�FA�E@�CA�A?�>?�;=�;<�:;�<=�@=�C=�C8�@2�?-�?,�@,�@,�?+�?-�>,�>,�?,�>-�@-�?,�?-�?+�>*�>)�?*�?,�>-�>-�>-�=,�=,�=,�<+�=,�<+�<+�<+�<-�=,�>/�?0�B4�B3�A3�B5�C9�C:�B:�B<�B:�HB�NG�NEpH>T@5A;/96-@85A75?75>63=5394194173043/43/34/23.23.13.02-.3--3/-3/.3/.3/02/02/11/11/21/32032040/2.-1-,4..8.,G4-O4)X8+`<0e?6mGFyYd�k��u�||�w|�nu�dh�[[�SL�LB~OArL@hI=cH>`HB^ECX@BO<AGCHKDMJJQJJQIIPHKQGOUKVWO^YS`YS`XU+++,,,,,,---/-.0/-0/-0/-1-*1-*1-*1-*2-)2-)2-)2-)2-*2,,1++1++1++1++2,,2,,1++1++1++1++1++1++1++1++2,,2,,2,,1++1++1++0**0**3--3--3--3--3--3--3--3.+40-40-40-40-3/,3/,3/,3/,40-40-51.62/730730841850:3-;4,<5-=6.?6/?6-?6-?6-C90C9/E8/F90G:1I=1J>2H@3HE6GE6KE5QD4YD3_B2g@/n=,v=,|:*�9+�:,�=.�B2�F7�F8�G=�F>�F>�E>�D@�C?�@@�>>�::�;:�<<�A<�C;�D6�@/�=)�?-�@-�@-�@-�>.�>.�=-�>-�=.�?.�?-�?-�?,�?+�?*�>)�>+�>-�>-�=,�=.�=.�<-�<-�<-�=-�;,�<,�</�>.�>1�?/�C4�B3�A3�B6�C:�D=�C=�C=�GB�QK�YS�XQsRIWI>CC7<?6>93@72>63=60:5194083/63.43.43.34/23.13.13.02-.3--3/-3/.3/.3/.3/.3/02/02/00.11/22021/10./.,2.-4/,?0+D0)K3)T8-Z<4eGGu]j�s�������~��tz�mp�ee�VS�LC�K?qJ=hG;cE>_FB]DBW?AN;?H:BE>HGDMHGQIGQHJRGNVKUXM^ZOaYNaXO++++++,,,---.,-/-.0/-0/-1-,1-*1-*1-*2-)2-)2-)2-*2,,1++1++0**0**1++1++2,,0**0**0**0**0**0**0**0**2,,2,,2,,1++1++0**0**0**2,,2,,2,,2,,2,,2,,2,,2,,3/,3/,3/,3/,3/,3/,3/,3/,40-40-51.62/62/73084185092,:3+;4,<5->5.>5.>5.>5,B8/B8/E80F90G:1I<3J=4I?5FB6FB6JB5OA4UB3\@2c?1j<-q<.w9*}8)�7*�:,�>0�B4�B5�F:�E;�F>�G?�G@�FA�CA�B@�;;�;;�>;�B;�D:�D4�A.�>(�A-�A-�A-�@.�@.�?-�?-�>/�>.�@.�?.�?-�>+�?*�>)�>+�>-�>-�>-�=,�=.�<-�<-�=-�=-�=/�<.�<.�</�=0�>1�?1�D4�C3�B4�C6�C;�D>�D@�EA�PL�[T�f]�f]u_T[UIHNBCI?<92?82>71;6094.74-63.43.43.43.34/23.13.13..3-.3-.3/-3/.3/.3/.3/.3/02/02///-11/22022010.0/-0/-3/,8,,<-*C0*K70S<6^HJtbn�z������Ƅ��z��tw�jl�YW�ID�E=nG<dD<aC>^CAY@CV@DP>EKGQRKWUQ^WU`XT`VS]TT^SY_S^[LaZJaZJ,-/,-/--/--/------.,-.-+/.,/.,1-*0,)0,)0,)/+(/+(/+*/+*/+*/+*/+*/+*0,+0,+/+*/+*/+*/+*/+*/+*/+*/+*/+*/+*/+*0,+0,+1-,1-,2.-2.-2.-1-,1-,1-,1-,1-,1-,0,)1-*2.+3/,3/,3/,3/,3/,3/,3/,3/,3/,40-51.62/73080-92,:3-;4.=4/>5.>5.>5.@5/@6-B5-C6.D7/F91H;3G=4G>5H@5J@6P?5T>3X<1^90c7,m9.t8-|8-�9.�;/�=0�?1�>0�A3�A4�C8�E:�G=�G>�E?�C@�@?�BA�DA�E>�D8�B1�A.�B,�A.�@-�?,�>.�=-�=-�>.�?/�<,�=,�<-�>-�=,�=+�=*�=,�<+�<+�=-�<,�<,�<,�:-�;-�=/�=0�=0�=0�>3�@4�A5�A4�E5�D4�E9�I>�G@�D>�EA�MG�[S�f_�qf�sh~rdjj^V^SJRGLLBJF=B>5=90:6-74+63,33+54/34.34/23.02-/1,.0-,1--2.-2.-2.-2./1./1./1./1.02/02/11/11/11/11/11/40/4+0;/3A32C41J;8]NQym{��������ϐ�ك��tz�jn�`c�Z[�LItHBdA>]>>X?BUAIVLU\U`bbqno~yv�|s�vlyohth_k_W_P^]Ib\Fc]G,-/,-/--/--/------.,-.,-/.,/.,0,+0,)0,)/+(/+(/+(.*).*).*)/+*/+*/+*/+*/+*/+*/+*/+*/+*/+*/+*/+*/+*/+*/+*/+*0,+0,+1-,1-,1-,1-,1-,1-,1-,1-,1-,1-,1-,0,+1-*2.+2.+3/,3/,3/,2.+2.+2.+2.+2.+3/,40-62/62/80.91.:2/;4.=4/>50>50>5.?4.?4.B5/B5-D7/E80G:2H;3H>5H>5L=6O>6R>5V;2Z90_7/i81p7.x8.�8/�:/�<1�<1�=1�@3�A3�C6�D8�E:�F<�E=�C>�D@�EA�GB�G>�F:�D3�B/�B-�C.�A/�@.�?-�?-�?-�>.�?/�=,�>,�=-�=,�=+�>+�=,�=,�<+�=+�<,�<,�<,�;+�;-�<-�</�=/�=1�=1�?3�@6�B8�B6�G9�F8�G<�JB�HD�GC�KH�TN�d\�qf�~o�o|mmseZfZNXMLNCKI=EC7A>5=:188.44,11)23-23-12-01,/1,/1,.0-.0-/1.-2./1./1./1./1./1./1.02/02/11/11/11/11/11/2015+49-7<15?54I?=^UVys}��������ʐ�Ԅ��y��qy�kt�hn�]`�XZqSUjRWjT^hZgmfvvr�t�~�����~��w�zr�qftgZeT[ZE`ZBb\D-.0-.0-.0-.0-.0-.0.......,-.-+.-+-,*/+*.*).*'.*',+),*+,*+,*+,*+,*++)*+)*-+,-+,-+,-+,-+,-+,-+,-+,,*+-+,-+,-+,-+,.,-.,-.,-.,-/-./-./-./-./-./-./.,0,+0,+1-,2.-2.-2.-2.-1-,1-,1-,1-,1-,2.-3/.40/51.80.91/:20<41=31>42=31=4/?40?4.A4.A4.C60D71F93G:4H;5J;6K<7N=6P;6S:5W83[6.c60k6.t5,}7/�9/�;0�<2�=2�@6�@4�@3�@3�C6�D8�E<�D<�F@�HB�IB�I?�E:�C3�B0�A.�B/�A/�?.�>-�>-�>-�>/�?0�<-�=-�<.�=.�>-�=,�=.�=-�<,�<,�<,�<,�;-�<-�:-�;-�<0�<0�<2�>3�?4�A8�C:�D9�J=�H;�H>�KD�KF�LG�SM�`V�sg��q��z��{��ws�ocqbXcUNRDMN@HI;DD8@@4:</46+/1&12*01+/0+/0+./*/0+//-//-//-.0-//-//-//-//-//-//-00.00.00.00.00.00.00.1/26+98,:8/4;63HE@_^Yzy~�����������DŽ��}��{��|��}��}��y��q~�o~�n~~p�y��������������������|�{j{k\hTXX@]Y>_[@-.0-.0-.0-.0-.0-.0.......,-.,--,*-,*/+*.*).*'.*),*+,*++)*+)*+)*+)**()*(),*+,*+,*+,*+,*+,*+,*+,*+,*+,*+,*+,*+-+,-+,-+,-+,.,-.,-.,-.,-.,-/-./-./-./+*0,+1-,1-,1-,1-,0,+0,+0,+0,+0,+0,+1-,2.-3/.40/91/:20;31<42=31=31=31=31>3/>3/@2/@3-A4.C60D71E82F93H94I:5J;6L:6N94Q83T50^72e60o6/x8/�90�;2�<2�=3�@7�?4�?2�?1�A2�B5�C9�E:�H?�H@�JA�H@�F:�B5�A0�@.�A/�@.�?-�>,�>,�>,�=.�?/�=-�=,�=.�=-�=,�=+�=-�<,�<,�;+�;+�;+�;,�;,�;-�;,�;/�<1�=2�>5�@7�C:�D<�E<�KB�H>�G@�JE�LI�QL�]V�j^��o��y���������z�xm{lbm_SZJQUFKO@EI:@D6;=057,13(01)/0(./*.-).-)/.*0/-0/-0/-0/-0/-0/-0/-//-0/-//-10.00.10.00.00.00.00.3.27,:6*83-1961HJ?bfX{�z������������������������������������������}�����������������������~�}k|iXfOSU=ZV;^Z?+/2+/2-.2-.2-.0-.0..0..0------.-+-,*-,*-,*,+),+),*+,*+,*++)*+)**()*()*(),*+,*+,*+,*+,*+,*+,*+,*+,*+,*+,*+,*+,*+,*++)*+)*-+,-+,-+,.,-.,-/-./-./-./+*0,+0,+1-,0,+0,+/+*/+*0,+/+*/+*0,+0,+2.-3/.40/:12:12;31<42=32=32<20<20>31=2.?1.?1.@2/A30B41C52D63C84D95E:6G96H94K84N50X72_60i70s80}:1�<1�>2�>2�@6�?5�?5�?3�@3�C5�C6�E8�E;�G=�H>�G=�D8�A5�@1�@/�@-�@-�?.�>-�=,�=-�=/�=/�<.�;-�</�<.�<-�=-�;.�<.�;+�;+�:*�:*�;,�:+�:,�:.�:0�<1�=4?6�B9�D=�F@�H?�KC�H?�GA�KG�PL�YR�f]�vh��w������������~�}t�qjue\eTV_LNUCEL:?F6<@27:/58-12*/0(.-)/+(/+*0,+1-,2.-1-,1-,1-,1-,1-,/.,1-,/.,2.-0/-2.-0/-0/-0/-0/-2-18,:5)51++66,GL8aiRz�p������������������������������������������������������������������{�xgzdTbIQT9VU9YX<,03,03./3./3./1./1//1//1....../.,.-+.-+.-+-,*-,*.,--+,-+,,*++)*+)**()*(),*+,*+,*+,*+,*+,*+,*+,*+,*+,*++)*+)*+)**()*()*(),*+,*+,*+-+,.,-/-./-./-./+*/+*0,+0,+0,+/+*.*)-)(0,+0,+0,+0,+1-,2.-3/.40/:12;23;31<42=32=32<21<20=20=20>0->0-?1.@2/A30?40@51@72@93A:4B94C84F74H5/Q51X5/a6/l8-v:/�</�>0�=1�?5�>5�?5�?4�B4�B4�C4�D4�B5�D8�E:�E;�B7�@5�>1�>0�?.�@,�>-�=,�<+�<+�<.�<.�;-�<-�<.�;-�<-�<,�;-�;-�:*�:*�:*�:)�:+�9+9-9-�<1<3?6�A8�C<�F?�IB�IC�IB�G@�HD�OK�VS�`Z�pe��r��}������������~�~z�uq|kdp\]iUR^JJS@BK:>E5<@29<134,22*1-*/+(/))0**1++2,,1++1++1++1++1++0,+0,+0,+1-,1-,1-,1-,/.,/.,/.,2,.8*75(13+(56&EK1\gGu�d��y�������������������ť�έ�ɭ�ɰ�˱�Ȭ��������������������������{w�rdx]R`FNR7QQ5SR6,03,03,03,03./1./1./1./1000//////////.,/.,/.,.-+/-./-..,--+,,*++)*+)**()+)*+)*+)*+)*+)*+)*+)*+)*,*++)*+)*+)**()*())'()'(+)*+)*,*+-+,.,-/-./-.0.//+*/+*/+*/+*/+*.*)-)(,('0,+0,+0,+0,+1-,3/.40/510:12;23<34<34=34<21<21;10<1/<1/>0/=/.>0-?1.@2/>3/=52;62;83<94=:5>93@72C60G4.O4-Y4,d5+n8,x:-;.�;.�<4�<5�>3�@3�A2�B1�A2�A1�>1�@4�B7�B9�A7�>5�>3�?2�?-�?-�>,�=+�;,�<-�<-�<-�;.�;.�<.�;-�;.�:-�;-�;,�9)�9)�:)�:)�9*�9+~8,~8,�=2�=4�@7�B9�E>�HC�KF�MF�IC�GA�JH�SO�]Z�hb�{n��y������������������~�wx�njwcdr[ZgSQ]IKTCEL<@D6<?467/44,3/,1,)1()1()3*+4+,2)*2)*2)*2)*2)*0**0**0**1++1++0,+0,+0,+0,+0,+1+-6)25)-4-%46!BI'Wc;q�W��m��}����������������Ȕ�Н�ӫ�Ү�ѭ�˥�����������������������{{�tq�k_sWM]BIO3JM0KK/./1,01./1./1.0/.0/.0////00.00.00.10.0/-0/+/.,1-,2.-1-,1-,0,+/+,,*++)*+)*+)*+)*+)*+)*+)*+)*+),+)*+),+)*-(,*(),())'()'()'(+)*+)*,*+-,*.,-.-+/.,0/--,*-,*/+*/+*/+*.*),(',('1-,2-*2-*2-*3.+4/,50-61.;31;31<42<42=32<21;10;1/<1/<1/=/.=/.=/,>0-?1.=2.=4/=60;81::29:49:4;81?61C2+J1,T1+^3,g7-o9-u=.{=0�=4�=3�?2�@2�@3�@1�?1�=/�</�>2�B6�C7�B7�?4�>2�?2�>/�=.�=-�<,�<.�=.�=.�>/�<.�<.�</�;.�;.�:-�:,�;,�:+�:+�;+~;+~;+|:,}9,|:.�>2�>5�@7�C:�G?�KC�OH�OG�HE�HF�OL�[V�g`�ui��u������������������~�|�yt�oj~ccz^]qXWfOO\HIRAAH8>@399/85.7/,3+)2()2()3)*4*+0*,/+*0*,0**0*,0*,2),2),3*-1+-1+-1+-0,-0,-0,-1+/5*05+,4-%46!?F%T`8n}R��g��t��z��~��z��{����Ĉ�ː�ə�ǝ�ƚ�����������������������~�xv�ol�fZnSJZ@GM3FJ1DF./0+.0+/0+01,01,12-12-21-43/43/43/62/51.41,3/,4/,50-50-4/,3.+3--1-,0,+0,+.,-.,-..0--/,,.++-*).))+.)/.)-/(/.)-/)-.)-.*+.*+/+*/+*-,*.-)--+./*./*./*------.,-/-./.,0/-2.+2.+2-*4,)5-*6.+90+:1,;2+;2+=4-=4->50>50>50=4/<3.<3.=2.<1-<1/;0.=/.>0/>0/@1.A0)@1*;4*77-39/39/560:3-?-+F*'L)'S*&Z/(`5,d<0k@0yA2�A0�A2�B3�@3�=0�;/�8-�;/�>/�A1�B2�C2�A0�>.�;.�:2�:2�;1�>1�?0�?/�?.�>.�@1�?0�>1�<0�;/�:.�:-�;-{9+~@3w<.q7)w=/w=/v;-}?2{;/�@4�E<�JA�LB�MB�PE�NE�KI�SR�b[�oc�}j��q��|������������������~��u�{o�ui�ib�_[zXZsU[mSWeNPWEJK=C?6@93;0.6**4(*3'+3'+1&*,*-)+***,*(),'+.(,1(-2'-3(.3(.3(02(00)00)0/*1/*0/)-1++0-(//#<?,V\BpzX�g��u��s��v��w��v��u��{�����������������}��|��{��~��}��~��|y�ur�mh|cYkUN[GIP>CH4?B/01+01+01+01+12,12,21,32-43.43.74/74/63.52-50,50,7/,7/,6.,6.,3.+2-*1-,0,+/-./-./-0..0-,1+*/)*.)(-.)//(//(//(//)-/)-.*+.*+/+*0,+.-).-)./*./*./)/0+.....0....../.,/.,2.+3.+5-*5-*7.)8/(:/)<1+<2)=3*>5,>5,>5.?6/>5.=4-=4/<3.=2.<1-<1/;0.=/.>0/>00@1.C0*C0)A2+>3-:5/94.:2/<1/?-+D*)I*(N+'T/)Z5-`;2e=1pA1x@/�A0�@2�?4�>4�;3�;1�9.�</�=0�@0�A1�A1�B2�@2�;2�;2�<2�=0�?1�@/�?/�?.�@1�>/�=0�<.�;.�;,�;-�;,x8,x<1t:.n9+t?/s>.r8*u:,}=1�A5�E<�H?�KB�MB�PC�OF�JH�SR�f]�wi��p��w�����������������������w�}o�ve�ia�aZ�[Y{X\wXZnSSaJNUCFH;C@7<737/-3*+2)*1(+.(*,*-**,+),+),-(,/)-2(02(04)13)13)21*20+2.+2.+4.+22-13/.0,)--%8:-SXDox]��i��o��l��n��p��p��p��w��������������|��x��w��y��|��|���{x�uq�nh{eYjWN[IEL<@D5;=/12,12,12,23-23-23-43.43.54/65085085085074/72.72.80-80-7/,7/,4/,3.+1-,1-,1-.0./0.1/-0..0,,.+*/+)./(/1'//)-/)-/)-/)-.*+.*+0,+0,+/.*/.*0/*0/*/0*/0+//-///0./0./0/-/.,1-*2-*6.+7/,90+:1*<1+=3*>4+?5,?6-@7.@7.@7.?6/>5.=4/=4/=2.<1-<1/;0.;0.<1/<1/?1.C2+E0+H/+K--L,/K+.I*/E+.A-,@.*A.(F/)N/*X1*b3-g5.j:,o;-x<1�=4�<6�<5�:4�:4�;4�=2�>2�?3�@4�B6�B5�C6�?2�=/�>1�>.�>/�?-�=.�<,�;.�<,�:-�;+�;,<)~=+{<+}=1z<1v:/v<0x@1x@1v<.v;-?5�C9�F=�H?�JA�LB�NE�NF�KI�TQ�f\�wh��n��t�{�����������������������}y�xi�ma�e\�a\�`^�a[|]UrVQgPHYGBPA:D93:2.3,+0**,)**(1(+1&*1&*1&*0'*1(+2).1+//*.-+.,+0+,0)-0(-0(-1)-01/23/./+(**"57*QVBmu]|�i��k~�j�l��o��o~�m��q��x��|��z��x��v��v��u��w��y��y��}}�yw�tp�mh{eYkUN[IDH9>@399-23-23-34.34.45/45/54/54/761761:72:72:72961:51940:2/:2/91.80-50-50-3/.3/.3/03/01/01/20.1..0--/-+.0)02).0*.0*.0*.0*,/+,/+*1-,2.-0/+0/+10+10+01+12-11/1111/010.10.2.+3.+3.*91.92,;2+<3,?5,@6-A7.A7.B8/A8/B90A8/A81@70>50>50=2.=2.<1/<1/<1/<1/=20=2.B3.E2.M//R+0W(0U&.P'/I).C/.<1+;2+?2)H1)S0*_.*d/)i9/k;/u<3}<6�<9�;9�;7�:6�>9�?9�B9�B9�B9�B9�A7�B6�@1�A/�A/�@.�>-�<,�<,�:+�9+�9*�:*�:)<){=(x>(x>*�>3{7.z7.z<1v;-w=/|A3{@2�B7�E:�H=�I@�KA�MB�OF�QH�SK�\Q�h[�tb�g��m~�v�|��������������������~}�yq�oj�if�gf�eg�gd�e_~_\v[PhRK^KBPA8D62:/.4*,/(+*%2&(5%(4%(2&(1&*/)+/+,.,-++-*+-*+-(,-(,/',/',/*+-/+,1++0+(/,%99-PTCiqYv�e{�hy�h|�k�n}�oy�k{�m��r��t��q}�p}�p~�s~�v~�x}�x|�x}�zz�wu�qn�je|bXlSN[GDF9?=1:8,45/45/45/560560671761761872983;83<94<94<94<73<73<41<41;30;3083072/61.61.5106216213123121/00./1-.2,04+.4+.4+.2,.2,,2,,2,,3/.3/,3/,40-21,21,32-32.22022032032051051.61.61-;30<5/>5.?6-A7.B8/E8/C9/E;2E;2E;2D:1C90B8/A60@5/>3/>3/=2.=2.=20=20>31>31@51F42M02T,4X)3W(2R)1K,1B30:6-77-:6*B4)M2)X/)^/)f:1j;3s<7z=:�<:�<;�;;�::�;7�>8�@:�C<�C:�C:�@9�@7�C2�C1�B0�?/�>/�<.�:-�9-�8,�8+�9+�:+~=+x>*v?*x=+�9-|/'�8/�>4w4+t6+}A6}C7E:�G<�I>�KB�KB�MD�RH�WJ}`N{iQ�pY�u]�|b��i��u��|��~��������������{�}z�wz�p{�ly�lw�ku�ms�mm�gkd`rZ[hTR[JIM>@@4;7,70&5*$6('5''3''1'&.((,+)++)+-*(,+(,+*,+*,+++-,*-,*-.*+,#$3+(50*85,BC5UZFfpWn}^t�eq�bu�ex�iv�js�ht�iw�kz�nx�lw�mx�n{�s{�u{�w|�wy�uz�ww�ts�om�hd{_WkPN[GCC7>:195,560671671671782782872983983:94=:5>;6>;6>;6>95>95?74?74>63>63;63:5294194184195495484384343151240/6-06-.6-06-.4..4..4..4/,40-40-40-51.32-32-43.43.43/442542540841850:51:5/>71>7/@7.A8/C90D:0G:1H;2G=4G=4F<3F<3E;2C90B71A60@51@51?40?40?42?42@53?53@72D63I35P16T/6S.5P05J22C52=90<:.=9-C7)I6(Q3)W2)]2+d3,l50v64}77�87�77�77~75}:4}<6~?8�?9�@8�?;�A8�C4�C1�B1�@0�=/�;.�:.�9-�9,�9,�:,<,|=,y>,x?,|=,�4,�2,�LE�XQ�A8|90�F;�K=yH:zJ<{M@|NA}OB�QE�UJ�_LrkOptS|uX�w]�yb�i��s��z��z��|����������~{�y~�v��p��o��p��p�r{�pw�mt�lj~cfv\_hSV[GOM>GA3A7+=0';,'9+(6+)3+(/,',-'+-().().(+-(-,*/+*3)*4(*7'*7'(3($<3,E>4IG:QR@^cMgqVjyZo�^k�\l�]p�bq�eo�do�er�fu�mr�jq�it�nx�rz�vy�vy�vv�tw�vu�ro�kk�fc|^UlON\ECC7@91;4,782782782782893893:94:94:94;:5>;6?<7@=8@=8@;7@;7B:7B:7A96@85=84=84<73<73<73<74<74<74;639529338308/09/.8/080.80.80.61.61-61-61-52-63.63.63.74/54/540651841952;74<94=84@93@70A8/C90D:0G:1H<0I=1J>2J=4J=4J=4I<3F<3D:1C90B8/A81A81@72?61?61@72A83A83?74@85B86E:8G96I:7H96H94E80E8/E9-E9+G9,I9*K9+Q7*Z/&d/'n3-z63�98�;9�;:�=;�A>�@:�>7<4:3�<4�=8�@9�A5�B3�@2�?2�=1�<0�;/�</=/}>/|>/|>/|>/}>/=/�9/�1+�;8�kf�~y�ZT�D=�LAN@tJ<rN>pQ?qR@tSB{WG�[J~eOmsOpzU�y[�u_�oc�mf�qk�wo��w��z��~��������~��y��v��r��r��r��r��t}�sx�pt�pm�ii�edx]]kRV^GMP;ED0B;+@3+?2,;0,70*30)00(./)./)01+30+7-,;+,?),D',F%,D'+F5-LC4VP@[XE`bLgmSjxWj{Wl�[g�Wg�Zl�^o�cn�an�br�fs�kp�jo�ir�nv�sy�xx�wv�vs�su�vs�rn�lk�db{[UmMN\CGH:E<5@707827828938938939:4:94:94;:5<;6?<7@=8@=8@=8A<8A<8D<9C;8C;8B:7?:6>95>95=84>95>95>95>95=85<73:52<41:0/:0.91/91.91/91.91.72.61-61-63.63.63.74/74/74/540651952;83<94?:4B;5C<4A8/B:/D:0E;/H<0I=1J>2J>2K>5K>5K>5J=4F<3E;2C90B8/B92B92A83A83A83A83B94A:4@85A96B;5D=7F=8G<6K<5N;4M6.O7-Q6+Q6+R8+P9+P9)W7(f6*r6,~;3�@9�D@�HD�JG�LF�QJ�LD�D;�<1�7-�8.�91�=6�>5�>7�=6�<5�<5�=4}=3z>3x@3vA3x@3z>3<3�:3�84�42�(&�=;�{z����hc�G@�K@xH:nM<jQ=fT>hV@lWBt[E`L�hP{rQ�vU�t\�l^�__�V\�Q[�T\�ou�zx̆~��������}��x��v��r��t��u��u��u��u��s��r|�ny�ju{anpZgbN_TBUE5R</O4-N2.I0,D/*>/(9/&7.'6/'92*;0*>/,B-,G*,I),L'.I)*TB6YQ<d^HgeLilOnuVm{Xl~Xn�[h�Vg�Xm�]p�bq�br�dv�it�lq�ko�jr�mw�vz�xx�yt�uu�uu�us�ro�kj�eb{[UmMM]BMN@KB;F=69:49:49:49:4:;5;<6=<7=<7=<7=<7@=8@=8A>9B?:D?;D?;E@<E@<E@<D?;D?9C>8E>8E>8B;5B;5B;5B;5B:7B;5B:7A:4A75A83A75@72@64>71>71>71<71<71;60:5/96185074/74/961961961:72<73>93A:2B;1C:1D<1F<2J>2L@4L@2N@3N@5N@7N@7L?6K>5J=4H;2F<3E;2B90B90@91?80?82?82@93@93<5/MD?M@:K:3T?:S73O0+a<6\3-`5.`4+^/'^/%f6,m=1q=0�J>�G;�I?�KA�F>�>7�>7�D;�ND�QF�WK�YK�OB�A5�;0�>6�98�:9�65�52�84�?8|@6r>1rB4oA2q=0w;1�72�43�-1�',�HI�ba�ED�WU�yv�VO�F<�VFnS>i[AibFjeHj`En^D|dL�jT�bL�l]�nh�X]�;L�-E�+H�0L�@Y�I\�[e�nr�{|ۀ}ۃ؉��~w��w��x��x��x��y��y��x��o�~m�xi�oc�bY�UM{IBxA>u:<i.2d04b14P&'G%#L0-M51G4.E2,D1-F1.F.,G+*K-/Q51YH6`V;f_CgdEkoNu|Zu�]o�Yl�Wl�Zp�_r�at�cu�dw�fx�hq�is�ot�qr�ou�ty�x{�|y�zx�ys�rm�lk�gi�dazZTmMO_DNOASJAQH?9:49:49:49:4:;5;<6>=8?>9>=8>=8A>9A>9B?:C@;D?;D?;FA=FA=E@<E@<D?9D?9E>8E>8E>8E>8E>8D=5D=7C<4D;4C:3B92B92B92B92B94A83@93@93>71<71<71;6096185085074/961961961:70<71>:1A:0B<0C;0E;/I=1J>0L@2L@2N@3N@3N@5N@7M?6K>5I<3H;2E;2E;2C:1B90A:2@91@93@93A:4B94E:4J71L.,V..j68u9;{;;�EC�E@�IA�IA�H?�IB�NH�PL�OG�D7�B4�B6�D9�>3�7-�7-�=2�C5�@1�@0�D5�G6�F6�H:�NE�LM�HL�@D�9;�98�>:�@8x>3o>0zI;�LA�?8�-,�).�9D�LW�KN�MM�>=�@?�`\�YQ�@5�UEyaIe[@_^@ihIslOvgJ~dK�cN�dX�_[�UZ�AN�,E�&E�&H�'I�.N�3N�<R�I[�P^�Q]�S]�Xb�bk�fl�io�mq�qr�ut�xw�yw�||�yz�vx�qt�kr�fn�ak�_k�`n�Sa�LX�GQ�EL�EIm69HT1-M0*I2,J6/L92K:2O>7UE8[O7cZ;hbBifEnrO{�^z�bt�^r�_p�_p�`r�`u�dw�dw�dw�fs�kx�t|�x{�x�}������������z�|r�qm�jh�d`y[TmMP`ERSCVPDUOC8938938939:4;<6=>8?>9@?:@?:@?:C@;C@;C@;C@;E@<E@<FA;FA;FA;FA;E@:E@:G@8G@8JA:I@9I@9H?6F=6E<3F<3E;2D:1D:1D:1D:1D;4D;4D;4C<4?80?80<71;60;60:5/94.94.96/96/:5/;7.>7/@9/C:1C;0E;1F<0I=1K?1M?2NA1P@1P@3P?5M?4L>3K=2I<3H;2E;1E;1D;2C:1B;1A:0?;2@<3A=4D;4VE>U4/j25�AG�LW�Ub�]f�_c�B>�I?�LA�ND�QL�UR�OS�LM�@6�B0�@0�?1�;.�7+�8+�=/�E6�=-�7$�:'�>-�A1�C2�E;�02�:B�DL�LR�MR�KL�A>�71{8/v6,x2*�1-�37�=G�GW�M[�FI�53�:9�31�NK�c]�K@�[J}cLk`DgdEtoOpS�gL�hN�hY�bb�QZ�DQ�7I�2K�2N�/M�+I�2O�0K�1J�5N�5N�2K�3L�8Q�@Z�C[�F_�Ia�Nc�Qf�Tj�Vk�Sj�Ri�Pj�Ni�Nl�Po�Ss�Vu�g��`}�[u�Ul�Zm�dr�R]r-2^&'Y0,W:4Q?5C;.:8)>B3LN9VO3aV6e_?heDquT�e��ix�dx�iu�et�dr�cv�ey�hz�iz�j��v��������������������������z�yp�mhc_vYTmMPcGTWDYVGYVG7827828939:4;<6=>8@?:A@;BA<BA<DA<DA<DA<DA<E@<E@<GB<GB<GB<GB<FA;FA;HA9HA9LC<KB9JA8I@7H>5G=3F<2E;1D:0D:0E;1E;2D;2E<3E<5E<5@91?80=82<71;60;60:5/:5/:70:70;7.;7.?8.@9/C;0D</F<0G>/J>0K?/M@0NA1P@1O?0O?2O>4L>3K=2J<3H;2E;1D:0D;2D;2B;1@<1@<3A=4B>5G=4S81[*&�;@�T`�Te�Tg�Uc�JO�41�;0�?1�A3�F=�IG�BH�?C�B7�F5�B3�@3�?3�>3�B4�E7�G7�B1�<)�;(�;*�:*�6&�3(�97�9=�7>�7<�<B�JL�TS�XS�?7�4*�,%�61�HK�OW�BR�3@�:9�.*�84�74�E@�]U�WK�XGwW@veI~pS�qR�fL�cL�o[�ui�SW�DP�;J�:J�=N�@Q�;O�4H�?S�9P�4K�3K�1J�/I�0N�6S�3T�4V�6W�7W�:[�=\�>`�@a�Cf�Ag�?e�?g�?h�Cm�Er�Is�Ow�Qu�Uv�Sq�Tp�ax�fv�Wb~17j0/Y2+P8,G>/>A.;D/?G/QL/_T8g`CokN||`��r��v~�q|�q|�t|�sz�qz�m}�o��u��|���������������������������������s�qh|c]tXSlNQdHRZCWYDYZH671671782893:;5<=7?>9@?:BA<BA<DA<DA<EB=EB=FA=FA=FC<GD=HC=HC=HD;HD;JC;JC;LC:KB9KA8J@6K>5I=1H<0H<0E;/E;/E;/E;1E;1E;1D;2D;2A:2@91@91?80<71;60;60:5/;7.;7.;7.<8/?8.A:0C;0D</G=1G>/K?1M@0NA1NA0P@0O?0O?2O>4N=3K=2I;0G;/D:0D:0D<1D<1B;1@<1A=2A?3B?6K=4\50w32�LS�]i�M_�?S�6E�&+�1+�7(�;'�<)�@3�D=�>?�;<�?5�B4�@3�>3�@5�C9�G=�I>�>/�?/�=+�;)�9)�:,�;/�<1�FA�EB�>?�79�7<�BE�LN�SP�C>�LD�TL�SM�KJ�@C�5>�27�4.�7.�1+�:4�84�@9�[P�TD{N9�bI�kP�aG�[F�gU�rd�mh�EK�:D�9C�<D�BH�FK�GM�FM�KT�AO�8I�5H�2G�0G�3M�8R�9V�9X�:X�:Z�;]�=_�?d�Ae�Ci�Dk�Dm�Cm�Co�Co�Cr�Cp�Gp�@h�Gm�Mp�Ij�Ok�[r�cs�Ye�?D`&$Q+"V@3VO=IL7@D-RJ3eYCvkW�{g��y����������������������������������������������þ�����þ�����������y�vi{e\sYTmORfJQ[BUZCW\F560671671782893:;5=<7>=8@?:@?:C@;DA<EB=EB=GB>GB>GD=GD=HC=ID>IE<IE<LE=LE;LC:LD9LB8KA5L@4K?3J>2J>2G=1G=1F<0F<0E;1E;1D;2C:1A:2A:2@91@91=82<71<71;60;7.;7.<8/<8-@9/A;/D</E=0H?0J>0L?/M@0NA0NA0O?/O?/O?2N=3M<2L;1I;0G;/F90C9/C;0B<0B;1@<1@>2A?3B?6N;4n95�FE�Y_�Wb�CQ�8F�3;�++�1'�8%�:!�9 �;&�>.�:2�71�7,�:-�9/�7,�:1�A9�E<�E:�>2�?0�<,�6'�6)�>0�D;�G=�8-�@6�E@�BB�=A�9>�27�.0�75�GB�SL�NG�=9�10�/2�67�1(�</�,"�71�3,�7/�g\�l^�WC�ZC�V?�R=�\L�la�gb�UU�EK�=F�;@�=>�A>�GD�OM�WW�NS�DM�9G�5F�1F�.D�1G�7N�8S�8T�9W�:X�;\�>a�Ae�Ck�<f�<h�>j�?m�>n�>o�=m�:j�Hr�;a�?d�Jp�Kn�Nm�Uo�Yp�r��`j�INt:8\6-P9+PC2UM:^QAreU�|n��������������������������������������������������������������ʿ����������~m~kau\XoSVjNS`FV`EX`H560560560671782893:94;:5>=8>=8A>9C@;DA<FC>HC?HC?HE>HE>ID>JE?JF=JF=MF<MF<MD;ME:MC9MC7NB6NB4N@3MA3JA2JA2I@1H?0G=1F<0D<1D<1C:1C:1A:2@91?82?82<71<71<8/<8-<8-=9.@9/A;/D</E=0H?0K?1M@0NA1P@0P@0O@-O?/O=1O=1M<2L;1I;0F:.F90C9/B:/A;/A:0?;0?=1@>2@@4Q:2r1/�KL�RX�>D�06�03�//�1)�2"�9#�>"�;�< �=#�;%�6%�6)�8-�6/�4,�92�@:�C<�@6�B7�A4�</�8+�:0�C8�E>�@7�>-�>-�5+�*&�"%�%+�+2�.4�)*�.+�3,�4,�3,�3-�0-�2+�2%�6&�2&�7,�6.�>7�`U�q�eS�VB�M:�WI�f[�d_�RT�CI�FM�AE�??�@<�@8�?9�FA�ML�JP�@K�9H�7H�5H�3E�6G�;M�9Q�7R�6R�6U�6X�9]�;a�<g�>k�?m�@q�Bt�Bu�Bu�Bt�Bp�Fm�Aa�Ee�Jl�Kk�Vt�_z�]v�j~�p~�mx�]a�CAg6/hB7sUJye\�}v�����������������������ž�������������������������������������������˺��������t�qexb\sY[oS[jM\iK]gL561561561560561671983983<;6=<7@=8B?:DA<FC<GD?HE>HE>HE>HE<JF=KG<KG;KG;NH:MG;MG;NF;MD;MD;MD=NC?NC=MC7MD5LC4JA2H>2G=1E=2D;2C:1C:3A:2A:4@93?74<73<71>7/>7/<8/=90>:1B;3C<2D=3H@5I?3L@2MA1NA1P@0O@-O@-L?/L>1M<2L;1J91I81E80C90@9/>:/;;/<<0=>0>?1A?0S8-�<7�\[�ZY�86�.*�1+�/&�2#�9&�B*�F,�D)�A&�A&�=$�9#�:+�;0�:0�7.�<4�C<�E;�A6�=0�=0�;.�=1�E9�MB�E<�8,�6$�;)�;.�3,�+*�(+�&+�%'�**�.+�2,�4,�3*�3)�2(�3%�:*�2�?0�7*�8-�?5�A6�l`�gY�RB�NC�cZ�hb�RR�AF�CK�>D�;=�<<�@9�>4�8,�6.�94�HH�@E�:F�;I�:I�8G�;I�?N�AU�?V�<T�9T�8U�9Z�:^�;c�>i�?m�>o�>p�?r�@r�@t�Aq�Cj�Mm�Ss�Jh�Aa�Ts�g��e��]w�_x�g{�p�qx�gg�^X{ZQ�~w������ļ������������������������������������������������������������������«�����z�xlzibu_`rZcqWcpTcmT21/320542651875984984984;:5<;6==5??7AA9CC9EE=EE=HH@HH>HH<JH;KJ8LK7ML8OL9NK:JF:HE<JFCNIMNIPICOE>ENE>LC4J@4KA5MC9LB8F=4B90E<5C:5@93@85@85@86<74<42C97B94A96>95?:7>:7?;8@<9B?:D@7G@6J@4L@0O@-O@+L?,G@.G@0I;0K81M53L76J88F;9C@;6904</9D4:A/69$?=(bC1�j^�JA�7,�5)�7+�5'�7&�=+�8$�<&�@*�@+�=)�:'�6%�6%�6'�7)�9+�<.�@2�B4�B2�A1�>.�=.�<,�=/�D7�G;�?2�2&�9+�8*�8+�8-�8.�5.�3/�1-�/-�.-�0,�1,�5,�8,�:)�:(�9&�3�3"�8'�7'�6(�B5�SI�ME�TL�[X�\\�PR�>C�9?�?G�AF�CD�BB�?9�<3�;/�</�<0�KB�KC�FE�>?�<A�?G�?I�;G�DQ�CQ�DR�DU�@V�<U�<Z�Bd�Fk�Aj�;g�:g�=n�Ct�H{�K{�My�Mt�Ps�Op�Mi�Mj�Yx�g��_��Gl�Vx�_{�^n�z��a^�xp�������Ļ��������������������������������������������������������������������ʻ��������y�xr}op{k}�sx�lv}k0./1/0320542653873873984;:5;:5==5??7AA7CC9DD:EE;HH@HH>HH<JH9KJ6LK6ML7NM8LK9KI=KJEPPRWU`YXjVTjSO`QHKMD?H?:F=8G>9H?:F=8B;5D:8A96?74?74@85@85=85<73=31=31=52=85=96>:9>=;>=9B?:D?9G@6J@4M@0O@-P?+L@*B?,B?.F<0H:1J65I56F35@65A=::=6;>5@@4E<-J9)^B4�L>�QB�;-�2#�6&�:'�7$�9%�>*�;%�<(�?,�@.�=,�9*�7)�8*�9)�:*�:*�<,�?/�A1�B/�@.�?.�:*�=,�F7�H:�?2�8+�6)�7+�7,�9.�;-�</�:.�8/�4-�1-�.-�/,�1,�3+�7*�:'�:&�;(�6#�8%�=,�;*�5&�:/�F<�F?�IF�OO�PQ�GK�<A�:A�CH�BE�ED�BA�>8�;1�:-�<-�=.�E5�L?�NE�GC�@A�?B�@I�@J�DM�CL�DP�FT�CT�?T�>X�Ba�Gi�Ci�?i�@j�Bp�Fv�Jz�K|�Jz�Ht�Kp�Qs�\z�_{�Wv�Nq�Ek�Dl�Ej�Ki�^r�nukLI�~t���̲���������������������������������������������������������������������������Ŵ����������������������~/.,0/-10.21/43/651762761:94:94<<4>>6@@6BB8CC9DD:IF=JH<JH;LI:MJ7NK8OL9OL9KI:NKBTRS_^fihxmm�lk�kh�`YiYQ\OGRH@KH>GG=EE<AA;=D;<?:7=85<73=82>93>:1>:194.:5/;60<92>;4?<5?<5@<3E>4G?4I?3L@2O?0P?/P?-L?,<;&:=(?<+A;-B71A62>42;30=84B;5H94N2.Y,)l/.�<>�GF�;0�2$�1"�9)�<)�8%�7$�;(�;&�>*�A-�A/�>.�=.�:-�</�<.�<.�:,�9+�<+�>-�>-�<,�?-�8(�>/�K>�G:�6*�2&�9.�6,�6+�8,�:.�:/�9/�6/�4-�0-�.+�.+�0+�2'�6&�7$�7#�8%�5#�9'�>/�=.�6)�9,�A7�<5�?9�EA�KI�JJ�CC�@B�CC�CA�D?�B=�=4�:.�8*�:*�;+�8)�D8�NH�JH�?B�=A�BK�HR�@I�@I�CO�GT�EU�@U�?X�A_�Eg�Ci�Ck�Fp�Iw�K{�L|�Jz�Fx�Hw�Kt�Ou�Z|�a��Uv�Cd�Ik�Tv�?\�I`�{��||aC;�{p���ճ���������������������������������������������������������������������������ξ�����������������������/.,/.,0/-10,21-43/54/650983983;;3==5??5AA7BB8CC9IF=JF;LI:MJ9PK8OL9QL9OL=LJ>QPL^]bmlzzz����������{u�rk�e_{YSmTLdMEZG@PB<HD?F@;?<87;63<71=90=90;8/:70991;;3>;2?=1@<1?;/A;-F?/H?0K?1M@0O?0O?/P>0L?/@=*?>,@=.?;/?;2>93=:5:94<94E:6M51V-+j)-�18�8C�=C�8/�7(�:*�?/�?,�9&�8%�;&�:&�<)�?-�@/�?0�=0�=1�>2�?3�=2�9.�8*�9+�:,�:,�9*�;,�<.�B5�E9�>3�2(�2(�9/�5+�5+�6-�7-�7.�7-�4-�1*�0,�/,�.+�0(�2&�4$�5"�5!�2�0�4&�<.�=/�:/�=2�D:�5-�60�;5�EA�NJ�KI�C?�=8�@9�A8�?5�=0�9-�9+�9+�;-�4&�?3�HB�HE�AB�@D�GM�NU�?G�?G�BM�HU�HW�BW�@X�A^�Ac�Cf�Fm�Ir�My�O|�L{�Iy�Dv�N~�R}�Kr�Mo�Vu�Uu�Mj�Gd�Lg�>V�dt���ӏ�d92lJ@�ypХ������������������������������������������������������������������������������º��������������������10,10,0/+0/+10,21,43.54/77/880::2;;3>>4??5AA7DA8IE:LF:NH:PJ:RK9RM:SL<RL@OJDVTUfdqwx���������Ï�Ǝ�����{w�pm�id�_[~UPnNJaKGXFCN?=B<8995296/85,85.671783891;;1></@=,B=*C<)G?,J?-K@.L@0M@0M?2L@4K>5M@7K>5F<3B92=82:946;47<59<5>:1H4-Y2-x89�?D�>E�8<�;0�=,�@.�A/�@-�<)�;'�>*�8%�;(�=,�=.�<-�;.�<0�=3�?6�>3�:/�7,�8-�8+�8+�8+�7+�A5�C8�9/�1(�3)�8.�5+�4+�3)�4-�6,�6-�4-�2-�/*�/,�/*�/)�1(�3&�4!�5�4�2�/�2$�6)�9-�;1�?6�E=�F>�@7�<5�@9�KD�NG�E>�;1�=1�=1�</�;,�9+�:+�<-�?0�9-�<2�@:�C?�BD�DH�JO�OV�@F�>E�BL�IU�JY�FX�CY�C]�@_�Bd�El�Js�Nz�O|�Ly�Iv�Jw�T��T}�Jq�Im�St�Vt�Ni�D^�F]�Xk������󝞎HFk.)�ke͖�����������������������������������������������������������������������������������ɿ��������Ⱦȿ�¹65154/32.21,10+21,32-43.66.77/880::2<<2>>4@@6CA5JD8ME8OH8RK;TK:TM=SK>RKAQLIZW^li|~������̙�ؚ�ޙ�ڔ�Ԍ�Ɇ���~�xv�nk�fe�^[xWTiMKYDAJ><?;:8;76875557457664872<:.?<+C>*F@*G?*H@+IA.IB0IA4HB6HA9G@:K=<I;;C9:=77875384/83/917<574+C1']80~C=�GC�>?�52�<0�<+�?-�?-�?-�>*�?+�?-�8%�9(�:+�9-�9,�:.�:0�<4�>5�;4�91�8.�8.�9/�8.�6,�8.�C9�A8�0&�,#�7/�<4�2*�3,�1*�2+�3,�3-�2+�/*�-*�/*�/*�/)�1(�4$�5"�6 �5�7#�3#�3$�3&�5)�8,�<1�?6�YQ�RJ�IB�C;�F=�J@�E;�>1�:*�;+�:*�:)�9*�;,�>0�A3�A6�=4�=7�A=�EE�GH�IM�MQ�BF�@C�BK�KT�N[�JZ�F\�F_�A_�Ba�Ei�Jp�Nw�Oz�Nx�Lv�Q{�R{�Ov�Ot�Vy�]{�So�D^�Tl�Qd�dt��������`d�MM�jgΏ�Ｘ������������������������������������������������������������������������������������������������=:5;8185063,41*41*52+63,74-85.:70;81>;2?<3A>5C?4KC8MC7PG8SJ;WK;UL=UK?SJCSJK]Wcom������ś�ڟ�ꢩ�뙛啘ݔ�֐�ʉ�����zy�rq�fc~ZWlPN\IGRFCNCAL??K==G;:@;9:=:5?;/C=-E@,F@*FA+EB/EC4CC7BC;AC>@ACB<FD>LD@NEEOCHNAIL?IJ?HECHAA=2L:.gF7�OA�J=�?4�8+�>/�>,�=,�>-�@,�@-�?-�=+�8'�8)�9*�9,�8-�8.�91�;5�:4�:3�81�81�92�:2�70�6/�=6�>5�91�2(�4*�<3�<3�4+�1*�1)�1*�1+�0+�/)�-(�,(�.*�/*�0)�2(�5'�6%�6#�7"�9%�8%�6%�5&�4(�7+�8.�7/�NG�XP�ZS�QI�G>�D9�@7�>/�<*�<(�<(�:'�9(�;*�>0�A4�D;�@7�@:�FC�IH�HG�GJ�IK�FH�BD�DK�LS�P\�O]�L]�K`�D^�Da�Ff�Il�Nu�Ox�Ox�Py�Uz�Ux�Tv�Yx�]{�Zw�Qk�I`�Wk�Ug�M^�^m�KZ�Ta�Tc�Xc�efȃ~嫧������������������������������������������������������������������������������������������������@=6>;4:7074-52+52+52+63,74-85.96/;81=:1?<3@=4B>3JB7MC7SG9VJ<WK;XL>WK?TICSJM^Xfpm������˜�㤬�������������ꝡᙛ֕�̒�ĉ��zx�ji�`]|XUpRPhOMeOKdKG^FBS@=H?:>?:6@<1A>/C@/CB0BC3BD7?D=>D@<ED;BJ>CVDHaMRhV[n\br`dobbje`dfXWaJDlG>�TF�XF�J7�@-�>+�A0�@/�@/�@-�A.�A/�=+�8'�7(�8+�8+�8-�6-�7/�81�;4�72�83�72�93�94�94�83�6/�A:�8/�3*�8/�>5�=5�91�6.�2+�0)�/*�0+�/)�-)�,(�,(�-)�/)�1)�4)�5'�7&�7$�8#�7"�8%�8'�6&�7)�9+�7+�5+�5,�NG�d\�`Y�OF�A7�;2�9-�>)�>'�='�;%�9&�9*�</�>2�D;�A9�E?�KH�MJ�GD�EE�HG�II�CD�FI�MS�SZ�R\�O^�Oa�H^�G`�Gd�Ii�Nr�Qx�Ry�Tz�Uu�Zx�^}�^|�Tr�Mg�Oi�Yn�[m�ct�M^�Uf�O`�Ug�L_�R_�^_�vqל�������������������������������������������������������������������������������������������������B>5A=4@<3>:1<8/:6-84+84+62)62)72,83-;60>93A<6E>6I@7MC7RF8UI;WJ:XK;ZLA[NHTIMXR`gd�|~���ʗ�㠩����������������������쩫蟡ڙ�ҍ����ur�he�]Z�XR~XQ{YQxVOpNI`C?M?:@?;:B?8>>4AC6BE:?D=<B>:CB>FH?LUEWoSf�bq�is�tv��x��o��_m�[c�XZ�WU�VM�M?�@.�:%�:$�=)�=*�?,�@.�@.�?-�=,�;,�6'�7)�6*�7-�7-�8/�91�83�84�95�:6�93�61�61�83�;4�D=�=6�70�@7�[R�lc�]T�?6�3)�2)�2*�/)�*&�(%�((�**�-+�0,�2+�1'�0#�1"�4$�:(�;&�<(�<)�<*�:,�9+�8,�7-�@8�81�GA�c^�XQ�B<�A<�4*�:&�<$�<&�<&�:(�:+�<0�>2�>6�C;�PJ�XT�NK�?;�?:�HD�IH�GE�JK�PT�RW�NV�LY�L\�Rf�Of�Jf�Jh�Mn�Qu�Rv�Rv�Wv�Xu�Xw�[w�\x�Zs�Wn�Vk�bu�Vg�\m�[l�FX�DX�Qe�Ve�fg�ieʏ�網���������������������������������������������������������������������������������������������C?6B>3A=4?;2=90;7.:6-95,73*73*72,83-:5/>93A<6D=5H?6LB8OE9TH8VI8WJ:YK@ZMGUJNXP_fay{���ɔ�⛦������������������������������뢣㘘،�ɀ�uq�jf�d_�`W�`V�]TVPtMIbFCTBAIAAC<<:AB=FEACD?A?@DBEOMRWVdch�qu�}��}��|��|��p��`u�Yi�Va�QU�HF�@4�;)�<&�>(�8$�7%�9'�9(�9(�9(�7(�6(�3%�4(�7-�:2�<3�=5�<5�<5�>9�<7�<7�>9�B=�C=�C=�A;�@:�B9�@7�8/�1(�5,�H?�ZQ�@6�6,�,$�)#�-)�//�,-�((�0.�4/�61�6.�3)�2&�2%�6&�:'�;'�<(�:(�9*�7)�5)�5)�:0�5-�=6�PJ�TQ�LH�B?�1(�;(�=&�<'�;'�9(�9+�:.�:/�>4�B:�NH�XQ�RL�D=�C;�HC�LH�JF�ML�SR�TW�PV�NV�OZ�Vf�Uh�Sk�Rl�Qo�Rs�St�Ru�Mm�Ut�\|�_}�\v�Uo�Ri�Re�Ug�Rb�Zj�Zj�N^�Sc�Yi�S^�`_�^W��}٩����������������������������������������������������������������������������������������������FB7EA5C?4A=2?;0=9.<8-;7,84+84+83-83-:5/=82?:4A=4F?5JB7ND8RF6TG6WG7WI<XKCWKKXP]b^ysu����ܘ�����������������������������������뙗���Ӄ��xu�sm�k`�i]�cZ�]W�VRwNKhEDV@@L85<A<@KABL@BQ>B[FKpW]�cu�s��{����{��v��p��c��Sp�F^�K\�HR�<<�5.�9*�<'�<%�;)�;*�:)�;*�<,�<-�<-�<.�6*�8.�<1�?5�A8�>7�=4�:4�84�40�40�93�B<�E?�B<�=5�<4�5-�4+�7-�2'�, �6*�G:�K>�@6�4-�-)�,*�-/�+.�*,�*)�/+�3/�5.�4+�2)�1'�3'�7(�:)�:(�:)�;*�:*�8+�8,�4+�<4�:5�<7�ON�YW�EE�3/�<-�<(�;*�;*�9+�9+�8,�8,�=3�A6�JA�UK�SJ�G>�D:�G>�KD�JD�LI�SP�ST�PS�MS�NW�Xd�Zh�[p�Zr�Uo�Qn�Pn�Qr�Gm�Pv�Z}�[{�Vr�Sm�Vm�\m�Xi�Zh�`n�`l�]g�fn�fm�\_�]W{OF�mf���ݺ�������������������������������������������������������������������������������������������IE9HD8FB6EA5B>3A=2?;0>:/:6-:6-94.94.:5/<71?:4@;5C?6HA7LD7OF5SF5UE5UH8VJ>YNLXNW^Zqpp������ԕ�革����������������������������������ꗖ⌋׃��}y�um�pg�f`�_Z�YX�QQuGGcB?R=5DH8BT=C`@EnCJ�OU�^g�gx�k��n��o��i��`��Wx�Ig�;U�2H�AP�DO�;=�82�?0�@,�:$�5$�5%�6%�5&�7(�9,�;-�</�@6�@7�@6�@7�=5�93�6.�4,�.(�-'�.(�3-�:4�<4�81�5-�5-�,"�* �7,�B6�>2�5&�.�F7�I<�H?�<9�,,�#%�')�/2�-.�0/�2.�3,�1*�0*�/)�0'�7+�9+�:-�<-�>/�?0�@3�@3�6*�LB�JE�50�GF�Z\�IK�A?�</�;+�:*�:*�:,�:,�9-�8,�<1�>2�F9�OB�PD�H<�C7�C7�H?�F?�JE�PK�RO�ML�KM�LQ�X`�[g�aq�au�Wo�Nh�Mg�Mm�Ou�Ry�Uw�Tq�Tm�[p�cu�iz�gu�bo�am�dn�fl�hj�gh�fa�^TeG<^U���ͫ�������������������������������������������������������������������������������������������NH:MG9LF8JD6HB6F@4D=3D=3?80>7/=60=60=60?82@85?:4C>8EA8LD9NE6RE4RE2VF6VH;ZMGVMR[Whlk�~����Δ�㜦���������������������������������铕⌋ن�у�|v�mk�de�_a�Y[�RQsNHbWFY_CQmBL�FP�LV�U^�[d�Zh�Rp�Ru�Tu�Pl�Jb�BW�8J�.?�8E�CM�GL�>>�>8�F:�H6�@,�>-�=-�<-�>/�?0�B4�D7�E:�E9�B7�>5�;2�6-�5,�3+�2*�0*�4-�60�90�80�7/�6.�6-�/&�6,�8,�2#�2#�9)�>-�;+�<-�D8�JA�DA�56�*-�*-�/2�67�55�41�1,�0*�/,�0-�1.�81�91�;2�;2�=1�=0�?0�>1�7+�WL�aZ�;6�;:�PQ�FH�PQ�<4�:/�8,�9,�:-�<.�<0�:.�:-�<.�A3�H9�I;�D6�@2�>0�F<�E<�IB�PI�RM�NK�LL�LO�Z`�^h�et�hz�]q�Og�Me�Nk�Vz�Tx�Rr�Tm�]q�hx�jw�er�et�_m�`k�kt�ru�jf�d\�la}fVYI:kXJ�{t���������������������������������������������������������������������������������������������QK=PJ<OI;MG9KE9IC7G@6G@6B;3A:2@93?82?82@93A96@;7B?8EB9KE9MF6PE3RE2VG4UH7YLDUKLZScii�|����ȓ�ޚ�리��������������������������������훟閘㒔ޒ�ډ��|��ty�ou�mp�ig�j_}y_x�Wj�P_�O\�S^�T]�PW�HR�@Q�?R�CR�DP�CK�@D�9<�46�JL�IJ�AA�87�95�A8�D8�>1�E6�E6�F7�E8�F8�G:�G<�G=�>3�;1�8/�5-�3*�4+�4,�7.�81�;4�=4�<3�90�5-�5,�7-�.$�;0�=.�1"�.�7&�<+�:(�8'�8)�:1�=9�@@�<>�37�,/�,.�+*�*)�+(�/,�44�88�9;�88�75�73�71�7-�6*�5(�5&�5(�PE�mc�HA�42�CC�?C�VV�A<�>4�80�7,�:-�</�=1�=0�:,�<-�?0�A2�A2�@.�=.�<-�D7�D9�H?�PG�RL�PJ�NL�ON�_c�ai�it�m|�dw�Vj�Qi�Uo�Wv�Vt�Xp�^p�ny�w��ks�Xa�`m�`m�bo�s}숊́|�th�yjskXON<_VG�rh���������������������������������������������������������������������������������������������SM=SM=QK=OI;MG;KE9JC9IB8E>6D=5B;5A:4@93A:4B:7@;7A@;CC;IE:MG7OG4RF0VG2UH5WJASIHXR^jg�}����Ē�ژ�礧��������������������������������ퟤ蝢晞┙ۋ�҆�ʃ�„������y��m��cz�Xi�Q_�NZ�IR�AI�=A�=;�?9�C9�H:�I8�G4�C0�@1�TI�G?�;7�64�88�;<�98�74�:/�<.�;.�:.�8+�7*�3)�2(�5+�3*�3(�3)�3*�5,�6.�8/�>4�<2�;1�8/�7.�6-�4*�3)�3&�3%�4%�7'�=)�>*�9$�2�:&�4%�1(�51�<<�=@�8>�37�-1�-.�--�0/�43�9:�;=�9=�26�03�01�1/�2+�2(�1%�3$�1$�=1�j_�TL�95�@?�:=�RS�JH�C=�94�6.�9/�;0�<0�=/�;*�?-�A/�?-�;*�;(�;+�<,�>0�>2�D:�LB�PH�NF�LI�NL�`d�ah�hr�o{�hx�Zk�Uj�Zr�Ys�]t�ar�jt�}���wy�_d�gt�m|�eu�lw���좟Ĕ���|ikVHQ<WUFtg^���۾����������������������������������������������������������������������������������������VO?TN>SK>PJ<OG<MG;LD9JC9H?6F?5E<5B;3B92A:2C:5A<6C@9DD:JF;MG7OG2QF0TH2UH5UH?QGFWQ]jh�~����œ�ؙ�矠��������������������������뤩������薠唟ߔ�ו�͚���������e�]p�Rd�IW�BN�>F�<A�<<�@9�A4�E4�I4�I3�F.�B,�?-�SE�D<�97�>>�DF�@D�8=�65�B;�E9�C8�A5�>2�9.�5+�2'�2(�3(�4*�5,�5.�4.�4.�4,�A8�>2�7,�6,�8/�:.�5)�1%�8(�2 �1!�9(�9(�4"�7%�C0�7&�8*�7-�5.�40�53�:9�?>�LK�HF�BB�>?�<=�8;�26�+2�+1�)/�,.�/.�1+�4*�5)�7(�0!�.�dY�]S�@:�DC�;;�MM�RQ�HE�<9�6/�8.�9/�;/�:+�<,�@-�A.�=*�8%�9&�<)�?.�7)�8,�>3�G<�K@�IA�JB�JE�a_�^`�dj�nw�ku�]i�Xe�]m�^s�bt�dq�lr�~�������qs�ry�y��aq�Xf������Ю����]jPDR9QTAjbU���������������������������������������������������������������������������������������������XNBWOBWMAUM@TJ>RJ=RH<PH=MC9KC8KA7H@5H>4G?4H>4F?5GC:GE9JF:NI6RJ5UJ4VK5VK9XNEULMZTbkh�{~���Ñ�ט�磤����������������������������쥨���ﭩ�����������▟֦�ζ������gz�L]�ER�>M�;G�<D�=B�@@�@@�>?�<=�EB�:4�D;�E<�1)�KF�JI�CE�>B�<@�<?�=>�<=�<;�B;�?7�D;�MA�K>�=0�6)�9,�7+�6,�5-�2*�/*�0,�2/�50�@7�9-�2%�3&�9+�;-�8(�2�2�4�5!�4"�4"�4%�5(�5)�0&�3)�5)�6*�5)�3&�3'�4)�2)�3.�52�33�/2�-2�-4�.5�-3�+/�+,�0.�5.�9,�7(�4%�-�3"�XH�YN�;3�NI�41�HH�OP�JJ�BB�<7�80�8.�:.�<-�=+�;(�9&�;(�<)�>,�=+�<,�8,�;0�=1�?3�?3�@4�@5�A7�ja�pi�c_�mj�qq�ad�gm�py�lz�hx�do�bi�dj�ln�qo�qo�y{�}��Zl�cw�bp������}�u]rQJY:LR8snZ���˷����������������������������������������������������������������������������������������YOCYOCXNBVL@UK?TJ>SI=RH<ND8ND8LB6KA5J@4J@4J@4IA6GC8HD9LF8OH6RJ5SK4VK7TK:XNEULMYUckh�{}������Ӗ�៞젞����������������������ퟧ袥襤ꩣ�������ᣜб������q��Tb�CO�<F�8A�7?�:=�<?�@A�AC�<C�:@�AD�<<�CA�@>�31�OP�DG�@E�;B�8?�8;�9:�:8�;7�E?�=5�=5�G>�LA�D6�:,�9+�7*�7+�6-�5.�3/�3/�55�84�>5�;-�6)�5&�6(�5'�6#�4�9$�9"�9%�:&�<+�<,�8.�4,�4.�5-�6-�7)�5&�5#�4!�4"�2$�2(�0+�.,�,-�,/�-2�/4�+.�,-�0/�2.�5+�5'�8'�9'�?.�*�D5�?2�F>�VP�B?�BA�UV�RR�JJ�C@�>6�:/�8-�8*�<+�;(�:'�<)�>-�?-�@/�>.�:,�;0�=0�>1�>2�?1�A4�C5�i\�md�b[�kf�ol�ba�kl�tx�q~�o|�ht�]f�Y`�bf�qp�zx�vw�x~�Rd�[p�]n������j�k[sOO_;SZ;us\����ĺ���������������������������������������������������������������������������������������\PB[OA[OAZN@XL>WK=WK=VJ<SG9RF8QE7PD6OC5OC5OC5MC7KD:JF;MG9PI7SK6VK5VK7TK:WMCVMNZWbki�z|������ˑ�֘�ޙ�㚙隝������������蜤㜢������៙㜘▛ߚ�ڤ�б������r��Yq�CT�AL�>D�=?�==�<?�=?�>C�=D�<C�8=�@B�A@�C?�<8�96�WW�BC�>B�;A�8>�68�66�96�<7�HA�;1�5+�A5�K>�H:�=/�8)�6)�7)�7,�6.�50�71�87�=9�3*�5*�6,�6*�5*�7)�:*�>,�4!�4�4!�7#�8)�9*�4*�-%�?=�>8�>6�<.�8)�7$�7"�8$�7%�3&�/&�.'�/+�/.�//�./�,)�0+�5.�5,�3&�4%�9&�>*�A/�1 �SE�;0�A;�C?�KJ�TU�TV�TT�OM�IE�C<�<2�7-�6(�8'�7%�7&�:'�=+�>-�=-�=,�:,�;/�<1�=/�=0�?0�C4�E7�\Q�g]�aY�lg�po�ab�fg�jq�R^�^k�gs�em�`g�fj�qq�xw�tu�nu�J]�Rh�[m񜡣��b`VoHRd>W`Axx^���������������������������������������������������������������������������������������������\PB\PB[OA[OAZN@YM?XL>XL>UI;TH:SG9RF8RF8RF8RF8QG;LE;KG<OI;RK9TL7WL6WL8WK;VLBUMK\V`jh~yy�������Γ�ҕ�֕�ۖ�㘛蘞욢훣뜥虡ߖ�ڕ�Ք�Օ�֒�֑�҅������}��s��f��W{�Ga�<K�AJ�BC�CA�B?�AA�?C�=F�=F�?F�:>�?@�ED�A<�61�>:�ZY�AB�@C�=B�:?�89�97�<8�A8�E;�:.�2(�</�E8�E6�>/�9(�8)�9)�9/�:/�91�91�;7�>8�2,�2*�3,�5,�5-�7.�:/�=/�7(�:)�<+�<,�;/�;0�<6�95�CB�A=�@7�<1�9*�8%�:&�;%�=)�7'�1%�1%�1(�3,�1,�/*�2*�5,�7+�6*�5'�7%�;(�>*�;(�<,�^P�F<�3/�/-�@@�WX�tu�rq�jg�^Y�PI�A7�5(�. �8'�8(�8&�;)�<,�=-�=,�<-�;.�=/�</�</�;-�>0�B3�F9�MA�`W�a[�pl�st�_c�]a�]d�HT�Ye�gr�go�el�kp�sv�vv�ps�en�DX�Kb�Xk뒖���_zYRkCSh?\gEy|_���������������������������������������������������������������������������������������������\PB\PB[OA[OAZN@YM?YM?YM?WK=VJ<VJ<UI;UI;UI;UI;TJ>OG<OI=QI<SL:UM:XM9YL9XL<UKAVLJ\U]hexut�|~������Ž�Ï�Ȑ�ϒ�Ԓ�ܔ����ߕ�ޗ�ܔ�֎�Ή�Dž�Ł��}��~�}t��p��g��\��Nv�Ac�:U�9K�AG�EC�GA�GC�EE�AG�<J�=J�BI�>A�@?�IE�?9�3-�C<�UP�DC�AC�@A�>?�?=�@<�D;�F<�=2�8*�5)�9*�>0�=-�;+�<)�:*�;*�;/�;/�8/�90�83�:5�:6�63�20�21�43�40�2+�0'�2(�7-�;1�8/�3/�40�;<�?@�8;�76�71�5,�4&�5"�7#�:%�=)�8&�4&�5'�8,�;1�9/�8-�>1�;-�8'�8'�:(�<)�<)�;)�>-�:*�>2�C:�/-�::�24�67�53�;7�C?�KF�QI�TI�TH�UG�?0�?.�<,�=-�=.�>0�?/�>0�<.�<0�=/�<.�<,�=.�A3�D6�MB�bZ�c]�ol�rr�`c�`e�`g�kv�oz�kv�`h�_f�lq�y|�y|�ms�^j�AW�D^�Uh懍���h�^[tJ_vJhwP��f��������������������������������������ǻ伺޺�޼���������������������������������������������[OA[OA[OAZN@ZN@YM?YM?YM?XL>XL>WK=VJ<VJ<WK=WK=XL>QI>RJ?SK>UL;XM;YN:ZM:YL;XL@ULGYSWe^nnj�ut�~}���������������Ȏ�ώ�ԏ�Տ�Ӑ�Ӌ�ʄ��|��u|�ov�io�lj��k��dz�Yv�Po�Bd�7V�4L�9I�@E�FB�JC�JE�GG�CJ�=N�>N�CI�BD�A>�ID�<5�4,�JA�LF�BA�>?�;;�=<�A>�E?�G<�G:�8*�7*�8*�9(�8)�9'�:(�;(�;)�=,�<.�;.�8.�6.�6/�50�32�./�-1�02�47�79�45�21�.,�4/�63�32�/1�/4�7>�:D�06�02�21�3,�5)�7'�9(�<(�8$�6$�7)�;-�>2�A5�@7�B7�G8�A1�<)�:'�<)�=*�<*�8&�:+�8*�0'�C<�2/�?A�.3�*,�1/�6/�83�92�8.�5*�2&�1#�E5�A2�=.�:+�9+�9+�:,�:,�<0�=0�>/�<.�<+�=-�?0�A4�SI�g_�d_�ki�no�ch�jq�ox�p}�s}�mw�bk�dn�rz�x~�qu�ip�Wf�AY�@[�Qf�}����z�kn�]o�Zy�`��r�������������������������������������կ�Ӧ�Ч�ӫ�Ԯ�ֱ�ں������������������������������������[N>[N>[N>[N>ZM=ZM=ZM=ZM=ZM=YL<YL<XK;XK;YL<YL<YM?SI?TJ>UL=XL<YN<ZM:ZM:ZM<ZN@VKEXOR_Wbd_sjf�so�zz�|~�~����������ƈ�ˉ�̉�ʈ�ȃ��|}�vw�qr�kl�fg�l`��_s�V_�N^�J^�@X�7L�3F�9C�?B�D@�HB�IC�FI�BJ�=N�>N�AE�FD�A=�HB�:/�7,�PG�C=�>9�64�21�53�>8�E<�G:�D5�8*�:*�:*�:'�8'�9&�:'�:&�:'�:)�:,�9+�7+�5+�4,�3-�*+�*-�-3�/4�17�39�49�58�8;�8<�9?�9A�9D�8G�6H�5G�+5�-2�12�4/�6-�8+�:,�=,�5&�8*�;/�>3�>4�=4�>6�A6�J<�H8�A1�<,�:*�9'�8*�9)�2'�9/�@8�D>�0/�..�59�58�3/�7.�82�:1�;1�;0�:0�;/�L?�F:�@1�9*�6)�6*�7*�8*�;-�=/�>0�=/�=,�<+�<.�=0�LB�c[�c^�ki�os�in�rz�v��fr�oy�q{�js�lv�w�u|�ho�cn�Rb�B[�<Y�Ka�t{�����z}�k{�f��h��u����̭����������������������շ�ˮ�Ǥ����‘�Ó�ș�˝�ˡ�ͧ�Ұ�ٻ����������������������������Ǿ[N>[N>ZM=ZM=ZM=ZM=YL<YL<ZM=YL<YL<XK;XK;YL<ZM=ZL?VJ>VJ>XL>YN<ZM<[N;ZM:ZM<[OAWMDWML\RZ^Xfb]qjfsp�wv�xx�|{��~�����ň�ȉ�ǂ}�y�zu�xq�vo�tk�pg�za��P\�HG�EH�HO�BN�:F�6A�:A�==�A=�DA�EB�CH�AK�=M�?M�?B�GD�A<�H@�9.�:/�UK�>7�83�/,�*(�/*�;4�C9�C6�>/�<-�;+�<)�:'�;(�<)�;'�8%�5$�7%�8)�7*�6+�3*�3)�3+�33�58�8<�4:�-2�(-�(/�+1�-3�)0�&1�)6�,?�*A�!:�/�"1�'0�,1�0/�2-�3+�4+�6*�6+�90�=6�>7�:4�71�51�92�H=�K<�E7�=/�6(�3%�5+�8-�4,�6-�C<�93�21�  �89�55�0*�4+�4+�5+�6+�6*�5+�7+�YN�RF�H;�@4�;/�;0�<1�<1�9-�;/�>1�=.�;,�9*�9,�:-�<2�YQ�b]�pp�vy�mr�q|�r}�z����x��hq�ep�q|�u�kv�^j�Oa�A^�8W�G^�nt��������n}�f��g��q�������ͭ�ܽ�ٻ�Դ�̩�Ÿ�������������������������Ñ�ř�ȡ�Ϊ�ѵ���������������������ν�ȷ�ZM=ZM=ZM=ZM=ZM=ZM=ZM=ZM=XK;XK;YL<YL<YL<ZM=ZM=ZL?ZLAZLA[M@[N=]M=^O<\O<\O>YM=YLCXMIXNO[QY]Ub`Yia\rjf�ok�sp�vq�{u��}���Ɍ�Lj��~��y��r��s��t��l��\��GN�B9�@<�C@�@?�:;�=?�DE�><�>=�?@�@C�BI�CM�AN�AL�??�@9�?6�>3�</�<0�D8�MD�72�:8�2.�3.�C<�?4�6'�>,�6%�:'�<)�;(�9%�9&�;(�:(�:'�9(�6(�2$�."�0&�7.�=5�82�40�0-�**�&(�%'�%'�$)�&,�!)�".�'7�(>�!;�7�1�'8�#.�#+�+-�--�+(�.*�41�64�64�77�65�23�./�,,�/,�92�:1�91�SK�#�+#�F@�.&�.*�<7�E@�:7�/*�.*�51�<7�>4�;/�5)�3&�5*�;.�;0�8.�bX�ZO�C:�6,�:/�8-�3'�6*�1&�2&�2&�5&�6'�:*�<.�=1�:0�C;�\W�pp�sv�x|�y��q|�|��w��t}�s{�r~�r~�my�gt�`n�I\�>\�>]�@X�el�����|��m}�f~�c��j��w�������������|��vz�qy�o|�r��v��u��w��y������������������������§�̹���������Կ�̺�������ZM=ZM=ZM=ZM=ZM=ZM=ZM=ZM=XK;XK;YL<YL<YL<ZM=ZM=ZM=ZL?ZL?]M>]M=]N;^O<\O<\O>]P@[OC[NFYNJZPQ\SX_U^_Wfd\tib�ng�qj�xp��y��ċ�ď���~��t��n��q��u��k��W}�<C�5+�6,�<3�@8�>8�?:�A=�=;�;<�;@�>D�@I�AI�@K�BG�<9�=4�<1�;/�:,�:-�A5�JA�FB�A=�63�51�A:�C8�:,�5#�8'�;(�=*�=*�;(�;(�;)�:)�9(�6&�2%�2%�5*�8.�91�91�1&�0&�.%�,&�+'�+)�,+�-.�)/�$,�$0�'7�$;�8�3�0�0�.9�3<�+2�(,�.0�02�+.�:>�7=�4:�26�05�03�25�87�2-�;5�82�E?�EA�/+�2.�"�51�?<�E@�=8�3-�2,�60�:1�:.�9*�5'�5(�9+�<0�<2�9/�cY�XN�@8�4+�91�:0�6,�9/�5+�5+�4*�5)�6)�5(�7(�6)�;0�C:�YT�lj�qt�x|�|��v��|��y��v~�u�s�p}�kw�dq�_n�I]�>\�>\�DZ�dj��y��qz�du�\x�]�c��k��p��p��mr�`m�]i�]g�^l�bq�ey�iz�k��t��v��|��}������������������������Ʒ�ǿ���ϼ�Ʒ�������\L<\L<\L<\L<\L<\L<\L<\L<ZJ:ZJ:[K;[K;[K;\L<\L<\L=\L=\L=^L>]M=]N;^O<^O<\O<_RA]QA\PD[NFZOK[PN]QS]RZ_SgcXvh]�kb�sk�v��|��}��������v��p��u��v��i��Rv�<D�5/�4+�<0�C7�E9�C8�?9�=<�:>�:A�=E�@G�AH�@E�@B�;6�90�8-�9,�9)�9*�?3�F>�D>�:7�75�;7�C=�PF�H<�3#�9(�:'�;)�=+�=,�<+�:)�9)�7)�3$�/#�5+�=5�@9�:2�4+�4&�5&�2%�/$�-%�+%�+(�,)�+-�(+�&/�(6�%:�7�3�3�%7�0;�5A�8C�<E�<E�6?�,6�2<�/;�.9�-7�.3�.1�/1�42�0,�=9�64�;9�mk�CA�0.�/,�;8�@<�A;�<6�7.�5-�5+�6*�6'�7&�6'�8)�;.�<1�<1�;1�`Y�TM�<3�0(�;3�>6�;3�=6�=8�<7�>7�=3�<2�:.�7*�6)�;/�@6�TM�ge�or�z~����|��|��y��x��w��s��n}�gv�`p�[m�G^�<Z�>\�FZ�`c�~gy�]i�Qh�Om�Rt�X|�^}�`x�\q�XazP_Pa�Uf�Zn�au�g}�j~�m��r��t��x��y��y��z��~�����������������ǹ�˸�ȶ����������[K;[K;[K;[K;[K;[K;[K;[K;ZJ:ZJ:[K;[K;[K;\L<\L<\L<]K=]K=^M=^M=^M;^O<^O<^O<^Q@^Q@]OB[OC\NE\OG]PJ]OO^P_bTmdY{i^�pg�}u��{��{�����������z��x��u��d��Ml�FR�A@�A=�E;�H;�G;�E9�A:�@A�<A�=D�?G�BI�BG�@A�?<�?6�<1�:.�;-�9)�9+�>2�D:�<7�31�;9�A?�D?�SL�UJ�:+�:*�8%�7%�;)�=,�=,�9*�8)�5'�2&�2)�9/�>7�>8�50�/&�5+�6)�4*�1'�.)�-)�+)�++�),�',�'1�)9�'=�"<�>�%A�6H�(6�.<�P\�`l�P\�<I�9G�)8�*8�.:�0:�27�01�+*�)&�0-�72�2/�C@�sp�VS�==�GF�=<�<9�:5�80�7-�6*�4&�3#�5#�6$�8&�;,�</�9.�:/�<4�XQ�MG�70�0)�<7�A:�<6�<5�>9�=9�?9�@8�?5�<2�:.�9-�9,�<3�OI�c_�no�|����~��y��y��y��x��t��n}�et�^n�Vh�E\�8V�<Z�H\�YZ�mScrG]uC\yCdzIm~Qt�Vv�Xs�Yo�Wm�Zl�\o�bu�h{�n��q��q��p��q��t��u��v��v��v��x��|��~��{��~���������ȷ�Ǹ����������[K;[K;[K;[K;[K;[K;[K;[K;ZJ:ZJ:[K;[K;[K;\L<\L<\L<]K=^K=_L=^M=^M;_N<^O<^O<^O<^N>^N>\O?_OB]OB^PE^OJbNYcRecTqdZ}le�xr�w��v��}����‰�΂��w��l��Xw�D_�CU�EQ�JP�IH�F?�E<�E>�EA�CC�@C�@G�BH�DI�CD�A?�@8�@7�=/�:+�:*�9)�8*�;.�?6�FB�=;�BB�AA�;6�KC�XL�K>�A3�8(�3#�8(�<-�:*�7)�8+�0%�3)�8/�;4�:5�62�/-�,)�0,�1-�10�31�25�37�48�6;�-5�,6�.=�0C�-F�)H�+N�3R�9L�3?�@M�_l�ky�Wf�CS�>P�3D�3A�3@�7=�99�83�4*�/$�2*�.(�72�YT�\Z�XV�AA�HF�B@�<7�70�6-�9.�9+�7'�5#�8%�8&�:(�>.�;-�6+�7.�>6�NG�EA�50�1-�>9�@:�81�51�20�21�52�83�:2�:/�9.�:.�5+�7-�IB�_Y�nl�}�������v}�w~�y��x��s��k}�dv�^p�Rg�F_�8V�=Z�L]�TR{`CWh<Yq?[vCfyKn~Qt�Vx�Zy�_w�ay�ex�hz�m|�q��r��r��p��o��r��t��t��t��t��r��v��w��{��x��x������������������������[K;[K;[K;[K;[K;[K;[K;[K;ZJ:ZJ:[K;[K;[K;\L<\L<]L<^K=^K=_L=_L=^M;_N<^O<^O<]N;]N;^O<_O?`P@`P@aQAbPFbNPcN]_Pe`Usga�to�{t�~r��v����̋�ۂ��r��du�Pd�;R�3L�<Q�ER�DK�?@�@>�CA�EB�EF�BD�AE�CF�DG�DC�B<�@5�?3�;-�8(�:)�9)�8*�:-�;3�IE�@@�=>�78�2/�B;�ZP�h[�QD�A3�4'�6'�:,�9+�7+�8,�0&�6-�;4�;4�40�/,�-+�--�49�3;�3=�3=�1>�1>�1=�1>�0A�1D�4K�5N�/P�-Q�2Y�>_�3H�O\�an�_n�Wf�P`�DX�8J�AQ�:G�2;�/2�2-�8-�;+�;+�:/�2(�JB�kc�LG�PK�;9�;9�LJ�@<�81�7-�</�=,�:)�;(�;&�;&�<)�>-�9+�3'�:1�C=�GA�D>�72�2.�;7�:6�2.�2-�,-�,,�/0�31�71�:1�<1�>2�6,�4)�B:�YS�jh�|}�������v}�x�z��x��q��i{�bt�]o�Pe�Ib�:X�@\�O_�QNqX:Sf8]uEa|In�Sv�Y{�]~�`��g��l��l}�m|�o}�p��o��n��l��l��q��q��r��r��o��p��r��t��v��t��w�������ï��������̫�����ZK8ZK8ZK8ZK8ZK8ZK8ZK8ZK8ZK8ZK8[L9[L9[L9\M:\M:]L:^K<`J<_L=_L=^M=_N>^O<^O<^O<_P=aP>aP>aP>aP>aP>bOAeMMdMW`O_aUmgb�uq�|v��s��u����Ά��~��qy�cl�P[�;M�*F�2Q�<S�<M�<E�@E�CD�BC�CE�BC�AD�CE�DB�C>�@8�>3�>1�9+�7'�:)�<*�<,�=1�?7�>;�99�03�/2�42�94�NF�la�h]�QC�</�:-�:.�7*�6+�8/�4,�7/�93�73�1/�/-�1/�15�2C�0E�-F�*B�&A�#=� :� :�&C�*G�.M�/P�+R�)T�2`�Ah�CX�`m�hu�Ve�KZ�L\�BU�2C�@R�7C�,3�((�.$�8&�?&�@'�?.�:,�YM�]Q�G>�D>�63�;7�UQ�F@�91�8-�;-�:)�9(�=)�>)�<&�;'�=*�7(�3(�=4�LF�GA�E@�96�30�73�62�0+�1-�,/�+-�./�1/�4/�81�;1�>2�9.�3(�;2�NH�a^�yz�������z��|��{��x��n~�ew�^p�Zl�L`�Ia�9W�=Y�M]�KHhQ1Qd6\tDf~Nv�[�c��h��j��n��s��t��t�r}�p�n��m��l��l��n��n��o��o��l��k��n��r��t��t��w�������Ư�ο��̻�ʤ�����[J8ZK8[J8ZK8[J8ZK8[J8ZK8[J8ZK8\K9[L9\K9\M:]L:]L:^K<^K<_L=^M=^M=^N>^N>\O<aR?aR?aR?bQ?bQ?aP>aN=bL?hOKgNRbP\cWkjfwv�}|��x��z����Ƅ��}��uz�kl�Y[�DL�0J�5T�<U�=Q�?L�CM�BH�=@�AC�@C�@A�A?�C?�A9�>4�=0�?1�;+�8(�<,�?.�@1�A7�C=�74�85�//�30�;7�0'�5)�UG�vl�[P�C7�<0�;0�8+�6+�:0�70�82�63�32�01�12�36�4<�&7�#9�"9�"9�!8�8�6�6�4�9�%B�)H�&J�'M�3^�Eh�bu�`l�Wc�Q]�P]�MZ�@M�2=�=F�7;�/.�/(�5'�;(�@'�>%�9'�8+�VJ�;2�?8�41�2/�C@�WS�HA�91�6,�7)�5%�5$�:(�<(�:&�7%�9*�4&�1%�?5�RJ�ID�HC�;6�2.�41�1/�-+�22�,/�+.�+-�++�-*�1*�4,�8,�=1�2(�7.�IB�\X�ww������������}��v��j|�_s�Xl�Ti�E]�D^�6U�:V�LZ�HC^K-Mc5Wo?b}Ju�\��g��l��n��r��v��z��w��r~�m|�i}�g��h��i��k��m��m��l�h~�i��j��o��s��r��x�������ũ�ʵ��¶�Ş�����]K7\K7]K7\K7]K7\K7]K7\K7^L8]L8^L8]L8^L8]L8^L8]L:]J<]K=^L>]M>\L=[N=]P?^SA`SB_RA`P@bQAcRBdQBdNAdLBjMIhKMdPYf[lnk�x{����������������Ђ��y~�sq�jb�a^�JW�>Q�:L�?P�CQ�@M�=H�>F�=C�<A�<=�<:�>9�=4�;0�;-�7'�A0�<,�6(�A5�F=�>6�72�85�71�5.�6-�8*�<*�:'�6%�;2�SL�YQ�E9�8*�>.�B3�:-�3+�GB�//�5:�6=�,7�BM�'3�&2�)2�(2�'�!+�'0�(0�'�)�+7� .�&7�-C�#;�Xs�.E�]l�_i�Zc�U\�PW�HM�?@�95�>7�A7�?1�7&�3"�6#�;'�<)�8-�80�E?�;7�31�75�54�DC�LH�KE�D;�:0�4)�5(�5*�5*�</�9,�/#�(�-$�9/�C;�H?�OH�E=�70�0*�/-�21�24�14�/2�/2�01�0.�0.�3.�5-�9/�=0�2%�>1�=3�_Y�sq�������������x��h}�_w�[u�Uo�Lf�Ec�:Y�;[�?Y�]i�@;VF-L^6ZuBh�Nw�]}�c�g��j��p��q��n�m~�l}�i}�h�f�f�f~�k�m��n�k~�g�f��g��i��m��r��v��|������������������z��]K7]K7]K7]K7]K7]K7]K7]K7^L8^L8^L8^L8^L8^L8^L8^K:]K=^L>`N@^N?[N>[N>\P@^RB_SC]QC]OB_NDaOEbPFcOHeNHiMJgNQeS_h_ton�y~���������ʣ�����x��y��|{�vj�i`�]a�OZ�FR�HU�JY�FS�?J�;E�9A�:>�::�=8�?7�?5�</�<,�<+�?-�9)�:,�A6�=5�72�<7�50�5-�5*�5)�7&�:&�;%�9'�6.�A;�MD�J=�?0�8(�9*�</�;4�JF�12�6;�6A�.<�@N�'4�$,�%(�),�+.�+.�((�(*�+,�$'�%(�&-�<E�)�4C�AT�&6�ju�bj�Za�W]�OS�BC�=9�>6�8,�D5�H6�>,�/�)�(�(�-%�;7�TR�HG�54�56�==�WU�GB�GA�A9�9/�3)�6,�7/�81�=3�91�5.�3.�4.�83�?9�F@�JB�A8�6-�0*�/-�12�03�03�04�12�02�/0�0.�2.�4-�9-�=1�3$�</�=2�^W�vs�������������t��f|�\v�Xt�Qo�Ih�Ab�:Z�?_�Ja�S\|@8SG1M_9[vCg�Ks�Yx�_w�b{�f}�k}�l|�i|�i|�h{�g{�d}�d~�c~�e|�j}�n}�l}�i|�e}�c�c��e��h��k��p��s��|���������x��dppR^^]L:]L:]L:]L:]L:]L:]L:]L:^M;^M;^M;^M;^M;^M;^M;^M;^K<_N>aP@`P@]P?\O?\P@[RC\RF[QG\OG\OI_PMcQOfTTgUUhVVhW]h]nmh�sv�|����ˊ�Ԙ�נ�ʪ���}�π�䄆�v�sj�fh�S\�GQ�FQ�GT�EQ�@L�=G�8>�7:�99�<7�@7�A4�?0�>-�>-�<+�:,�B6�H?�;2�1*�:2�6/�6.�7,�8,�7(�8&�9&�:*�4-�4.�A9�OC�H:�5%�3$�@2�>5�HD�13�5;�7@�4@�ES�2?�)0�#&�$'�13�-/�''�&'�12�)*�8:�+1�)1�4@�R^�=M�\i�^f�V\�OT�NS�EI�:;�74�?9�6,�?2�B5�=1�7-�3)�,%�' �%�0+�EC�::�--�35�AB�^]�@;�C=�A9�=3�9/�=4�A9�@;�@<�=;�==�@A�>>�::�?=�JG�A;�<4�5,�2+�1-�31�12�02�04�02�02�/0�0.�2.�4-�9-�>2�4%�8+�;0�[T�zw����������~��r��dy�[t�Tq�Nm�Fg�=a�<^�Fc�Tg�AHp;3SH2Qa<^yFh�Nr�Zu�^t�_x�c{�g|�hy�fy�fy�cx�by�b{�b}�b|�cz�h{�j{�h{�e{�a{�`}�`�b��j��n��s��t��w��uy�np�mTdYCOM4@>^M;^M;^M;^M;^M;^M;^M;^M;^M;^M;^M;^M;^M;^M;^M;^M;^L8`N:aP<`Q>]P?ZN>YOCXPEXOH[QO_UTbXYeX_iYcl\fk^glaimerok�tt�y~��ʆ�ڍ�ᎇן�ӭ�ij���y��{�ށz�w�sr�cg�U\�MT�GQ�CM�>I�;D�6;�88�97�<7�@6�B5�A1�?.�:*�>-�=0�F:�SH�H?�5.�1)�91�81�<1�=1�;-�6'�6&�8+�5-�2+�>5�NB�L>�:,�8*�B6�7.�>:�/0�16�4<�8B�NZ�LU�>E�38�$&�/1�,,�22�**�/.�::��37�,2�8B�EN�Xc�NW�=C�BE�BG�>C�:>�8<�88�97�83�91�:2�A:�NH�VS�NN�CB�72�95�KI�ML�RS�YZ�SR�YV�51�>6�B9�@7�?5�B9�C<�A>�?@�8=�9?�?C�;@�58�>?�MJ�93�60�3+�3,�4.�41�21�01�02�/2�/2�/0�/.�1.�4-�8-�?3�6'�5(�:/�VO�|y����������z��o�cw�Xq�Ol�Fh�@c�9^�?`�Kd�Zh�35g;0WO8XhDa{Kj�Ps�Yt�\u�^w�by�ez�fw�dv�aw�av�`x�ax�a{�a|�cz�fz�g|�fz�dz�`z�]|�]~�_��g��n��t��s��u��qt�ii�dRbUFSL:G@_N<_N<_N<_N<_N<_N<_N<_N<^M;^M;^M;^M;^M;^M;^M;^M9]K5_M5`P9_P;\O?ZNBXOFXQKYPQ`W\g`hnfsshysg{sg}ri~pm~pq�sv�x|�|����҅����敍㝌ڠ���u��l��nq�vl�vi�sm�ll�gi�^`�RY�FM�;D�7=�6<�89�98�=7�A7�B5�B0�@/�7)�A4�;1�;1�RH�\S�ME�;2�90�7-�9/�?4�=1�6*�4'�6*�3,�70�=5�E9�F9�B3�A2�>2�0&�72�0/�.1�.4�7?�PX�]d�Z_�OS�.1�03�,/�DG�66�,,�-.�>@�36�37�bh�<C�*2�-4�&*�;=�@E�6:�37�9=�7;�/0�43�;;�GF�RS�`c�hn�ek�]c�@>�E@�^[�hg�op�jj�KK�=;�40�>7�E=�C;�>5�<4�93�43�6<�-9�,6�.8�,6�,3�9>�JK�3/�3.�3+�3,�5.�40�4/�21�02�/2�/2�.0�/.�1.�3-�7-�?3�8*�2%�8-�NG�|y���������w��l|�at�Tn�Hg�>b�:_�6\�Bb�Ne�Waq0,_?0[W>^lIf~Nk�St�\u�_v�_x�cy�ex�dv�`v�`u�_v�_w�_x�`{�a|�bz�d{�e|�d|�by�^y�\{�\}�^��a��g��m��p��s��r{�nr�jfwe[k^RbU_N<_N<_N<_N<_N<_N<_N<_N<_N<_N<_N<_N<_N<_N<_N<_N:^L4_N4`N8^O<[N>YOEZSMZTT_Zahbprm�zu�}t�{q�zp�vp�qt�rx�u|�y��{���φ�ڍ�ޖ�ܙ�͛���������~y�l[�R?�MB�QI�WR�WU�ST�KO�>C�5;�9<�9;�;9�>9�@8�B6�B1�?/�:-�A6�5+�.$�I?�g\�dZ�UK�=3�5+�3)�:0�;0�6,�3)�6-�1*�82�;2�9/�>0�F7�B5�9-�1(�5.�31�./�*.�17�EJ�V[�]b�\a�9<�9<�+.�JM�89�00�57�()�'+�W\�>C�:>�7=�#�),�<>�BF�49�,2�17�16�(.�37�KN�ae�hn�cl�_k�`l�bk�LL�NJ�\Z�VT�MM�HF�42�3/�A<�KD�OH�JC�@8�:3�50�.-�1;�,<�*7�'4�)4�0:�>C�JL�1.�3,�3,�5,�4-�4/�4/�42�02�/2�.2�-0�..�0.�2-�7-�=1�;-�2%�7,�D>�yv�������|��q��hx�_r�Rl�Dc�9^�6]�8]�Gd�N`�IMe5+VD0[Y@^lIe|Nk�Rt�[w�_x�`{�dz�ev�`s�]s�\s�\t�]v�^w�_{�az�bz�b{�b|�b{�_x�[x�Yz�Y{�Z~�_��e��k��m��s��u��u|�rv�pnlfwe_O?_O?_O?_O?_O?_O?_O?_O?^N>^N>^N>^N>^N>^N>^N>_N:aO7aP6aO9^O<[OC[RK\VV_Zakgvso�}z��~��|�}w�{u�xv�sy�s}�z��}����ą�ɍ�Δ�͚�Ǡ��������ɭ�Ŧ���m�fJ�E2�A4�A5�C:�IE�OO�JK�?C�=?�;=�<;�=:�@:�@7�>1�=0�:2�@8�4,�1'�J@�bW�g\�eY�OB�>2�4)�7.�90�5,�2+�60�1-�50�7/�8/�>1�D7�>0�4'�4*�0+�3/�..�-.�14�78�BE�MR�Y^�FK�QW�48�FJ�8<�AE�7:�/1�05�HK�8<�7:�#%�:>�8;�;>�<A�7=�-6�)2�1;�<D�LS�]e�ks�js�`l�Zh�Xh�[h�dd�ZV�WT�@=�10�44�33�C@�JE�RK�SL�JA�?7�93�81�33�.8�0>�0>�*8�.:�;E�CH�AD�1/�4-�4-�5,�4-�3,�4/�53�02�/2�.2�-0�..�0.�2-�7-�:/�>0�1%�7,�;5�sq�������v��i}�at�[p�Pj�Cb�8`�8a�;a�Lh�O[~86]=0NF1VX@ZeEcxMj�Rr�[v�^y�a{�dx�at�]p�Zp�Yq�Zq�Xt�\u�]y�_x�`y�_y�^z�^y�\x�Yx�Wy�V{�X�_��d��h��l��o��q��ox�jr�il~ddv^_O?_O?_O?_O?_O?_O?_O?_O?^N>^N>^N>^N>^N>^N>^N>_N<cQ9cQ9aP<]P@ZPG\TR_Zaa_mtr�zy�������}�{x�zv�ww�w|�x��}�Ă�ć��������������������ȸ�о����ѻ�Ь��oT�]H�H6�>0�G?�WQ�WV�NO�@C�=?�<=�><�=:�=8�:1�90�80�<7�:3�>5�PF�XM�]P�eX�cU�M?�9/�8.�91�4-�2,�60�40�3.�5.�<3�C7�B6�:-�3'�5,�.&�0-�0-�31�54�-.�35�BF�X]�W\�ou�DJ�HM�=D�[`�ou�>C�}��mq�QT�>@�02�:=�IL�9@�8@�=F�7B�-8�>J�]h�mw�jr�cn�]g�^k�ap�]n�Ye�\]�OK�JG�74�01�54�0.�95�D?�JD�JB�@8�6/�4/�71�77�'/�0<�2>�,7�0:�>E�>C�44�3.�5.�6-�4,�3*�3,�4/�43�/2�/2�.2�-0�..�0.�2-�7-�9.�?2�0%�6,�61�on�������p��cx�\p�Xn�Oi�Bb�9a�<d�Ad�Ri�QWd/'WD3GG/RT<U^?cuMi�Qq�[v�_z�b|�dx�_r�Zn�Wn�Un�Uo�Vr�Zt�\w�]w�]w�[x�[y�[w�Xv�Wv�Uw�Ty�Xz�Z~�_��c�d~�f{�fr�_k�Z`vR[nPSfH\L<^N>`P@`P@_O?_O?`P@aQAbRB_O?]M=^N>aQAcSCbRB`Q>dS?aP>]P@^QI[QPZSZeapsq�yx�z|�~�����~~�yy�sr�nn�tw�v{̀�ʋ�Ɩ�ä���������Ƴ�̰�Ϭ�ϧ�ϣ�У�˜�˜Ѩ���g�_I�zg�tg�H?�QN�cc�KL�?A�89�:;�:9�75�53�;6�73�50�B;�=3�I?�XK�OA�dV�cT�XI�G;�:/�6-�7/�6/�4/�0-�2,�70�=4�=1�7+�5(�7,�0'�/(�/+�1-�20�40�51�75�79�JN�Y]�OT�8=�6<�X`�~��~��ou�go�ip�fl�\a�X[�Z_�U\�DL�8B�7C�3A�,:�0>�=I�S_�`i�gr�ep�bm�bp�`o�]g�SS�FA�85�41�11�/.�31�94�D=�B:�?7�<4�90�81�93�66�7<�5<�4<�4<�5=�59�35�1/�3,�5.�7.�6.�3+�2,�2,�31�03�03�/3�.1�//�1/�3.�7.�?5�8,�6,�/&�;7�XW����{��m��e|�\t�Pj�Hf�Ce�;d�9`�Nl�Rd�=?R,!C;&CG.KM5Z`DZjEcxMq�Zx�bx�`t�\r�Yq�Yl�Sm�Rn�So�Tr�Xt�Zu�]u�[t�Xt�Wv�Xw�Wv�Wv�Uu�Tt�S{�[{�]z�^u�[m�Ub~MXrCSj>AW0?U/<R,\L<^N>`P@aQA`P@_O?`P@aQAcSC`P@_O?`P@bRBcSCbRB`P@fVG_QF]PH^TSaZad`omk�vw�xz�{}�}�x|�rv�lo�mp�oq�uv�|~Չ�Ә�Ψ�ǹ���ź�α�ת�ۥ�ޥ�ݢ�ۤ�أ�Ѡ�ǛӼ�����|eŋw�}m�VJ�a[�rp�Z[�KL�?@�>?�>@�<<�66�55�=8�83�?8�6.�>3�LA�H;�]M�o`�`Q�H:�5)�1'�6-�5-�0)�51�95�=7�<3�8.�5)�4*�5*�7.�5-�2-�0+�0,�2,�4.�52�87�>@�JN�W[�]d�\d�]e�ai�S[�NV�Q[�_g�jq�fl�Z`�NT�4:�,5�*6�-9�'5�!/�'6�7D�O\�Zd�bl�dm�en�cm�[h�QZ�EE�<7�64�63�55�30�2/�62�>9�>7�<5�:3�81�82�95�:6�8;�7:�6:�6;�79�57�31�2,�4-�6-�7.�6,�2+�1,�1,�20�03�03�/3�.1�//�1/�3.�7.�<3�=2�8.�1*�74�Z[����s}�fz�^v�Vq�Nk�Gg�@c�<c�Ad�Oh�LWy<9L2#<:#<B(EG/PT9VdA`rJn�Xu�_v�_t�Zq�Wp�Tk�Ok�Pl�Qm�Rp�Vr�Xs�[s�Yu�Yu�Wu�Wu�Wt�Tr�Qq�Rq�Qo�Pl�Ni�Lb�FXu?Ni6F]/@W+@W-AX.AX.YL<[N>^QA^QA^QA^QA_RB`SCaTD`SC_RB`SCbUEbUE`SC^PCbUM\QM[QRcYbkdtqm�vu�z|�y{�y~�x|�ot�ei�bf�jn�ru�}}ׇ�ݗ�۩�ػ������ؿ�������������ۧ�ϡ�Þ��������l��p�o`�RG�]U�mi�uu�__�JL�AE�AD�>@�8;�68�=;�;6�A:�81�7,�>3�=/�G9�j\�i[�\N�B6�3)�4+�6-�2,�52�A>�GC�=6�2)�1'�3(�0'�4-�1+�.)�/)�2,�80�=4�B9�-(�43�CE�VX�^b�Za�S[�Q[�GR�HS�O[�\f�mv�nt�Y_�>D�.5�-4�2<�2>�+9�'6�6E�KW�IS�PW�W_�^f�ck�`i�RY�BI�97�71�75�<8�<<�95�51�60�:3�;2�90�90�71�94�;7�<8�99�99�87�88�88�66�40�2+�6-�7-�7.�6,�2+�0)�0,�10�13�13�03�/1�//�1/�3.�6.�:1�D9�91�4.�/.�_b����lw�bx�Ws�Pm�Ll�Bh�:`�<`�If�Sg�DJm<5O>,=<':?(ED/FH0Q\<YkEg|Qr�[t�\q�Wm�Rl�Pi�Mi�Kj�Mk�Pn�To�Up�Xq�Yu�Yu�Wt�Vr�Tp�Rm�Mk�Mj�Lf�Ha�E\~AUt;Li3E`-AX*>U'D[/E_2Ic6WJ:ZM=]P@^QA^QA^QA_RBaTD`SC`SCaTDaTDaTDaTD_RB]QEZOM[RWbXcjcsqm�vu�xz�z|�w|�sy�mr�dh�]d�ag�lr�x{ʉ�ߕ�夡䷴���������������������۪�ө�¡�����������v��q�rc�bW�i`�rm����ut�[]�LN�DH�@D�;A�;=�:8�<8�F@�C;�:0�:/�6)�1#�I;�aR�j]�SG�:/�4)�6+�4-�42�MK�ZX�KF�91�4+�4+�2(�.&�-&�,%�-%�1)�6,�;0�?4�/'�4,�:8�CB�FH�EI�GN�MV�Q]�Vb�Xd�\g�gr�mu�Ya�;@�28�.4�.7�*4�%2�)5�<K�S_�?I�AI�GL�QV�Y`�X]�GM�79�53�84�<9�@>�@?�=;�95�72�82�91�80�80�71�84�96�;8�:7�;9�:7�:8�98�84�5.�3+�6,�8.�8,�6,�2)�0)�/+�0/�23�23�03�01�0/�1/�3.�6.�8/�F<�91�4/�,,�fj�y��gt�by�Tq�Kk�Gj�=e�6\�=^�Qh�Xe�BBgC7[N;GF1AC-JH3EE-LU6Sc>btLl�Up�Xo�Tm�Pi�Ki�Ih�Jh�Kj�Ml�Rn�To�Xp�Xt�Xs�Uq�So�Qk�Nh�Ke�Hd�G`�D]�AWy=Rq8Mi6Lf6Oe7Of8Ne7Oi9Sm>UH8XK;[N>\O?]P@]P@_RBaTD_RB`SCaTDaTD`SC`SC_RB^QIVMR_Xhnf{uq�xt�xw�xz�y{�tx�lq�bf�\c�`f�kq�v|ƀ�Γ����䮭罼������������������߹�׶�е�Ʊ��������������y�|q�vk�si�me�oi扄�~�sr�ed�WY�MN�DG�?A�:7�;7�B=�E?�<3�=3�B5�2$�0"�J<�XK�N@�=/�7,�7+�3*�42�UU�kh�]X�D>�;3�;2�80�4-�2,�1+�0)�0'�/$�/$�0#�9,�4'�2*�;6�CA�EG�BG�@H�DO�P[�Vc�Va�^i�go�Ya�BG�:<�57�28�28�2=�9C�HU�Va�7@�4;�6;�AD�JO�IM�<B�13�54�95�=9�=:�;9�:7�73�81�;2�;1�:2�92�82�73�64�75�:8�;8�:8�:9�;7�95�6/�3,�7-�8.�9-�6,�3)�1)�0)�1-�23�33�23�01�1/�1/�3.�6.�7/�C:�70�1-�13�kq�qz�ft�]t�Pm�Bh�>g�9c�8^�Ed�Zm�V[wE>dJ=aYFTO;KI4PI7GE0GP3M]9ZlFf{Pm�Sm�Rl�Mh�Ji�Ig�Hg�Ji�Lk�Rl�Sn�Wo�Wt�Xs�Un�Rk�Of�Kc�Ha�F_�F[�CY}@St;Pn8Ok:Rl=Xn@ZqCWo?Vq>WqARE5UH8XK;ZM=[N>\O?^QA`SC`SCaTDaTDaTD`SC`SCbUEbWQ^Vckf}yu�~z�zy�xy�vy�tx�lq�cj�\c�^d�io�w}ǁ�ш�ә�ݣ�ల㼾��������������������������þŹ����������yztyvqulele�ph�a[�`[�sm�yu�~}�|y�rq�cc�ST�HH�DB�>:�<6�B<�:3�C:�UK�>2�6)�9,�=.�?/�B4�C5�@1�7-�30�LM�_]�WS�D?�:4�81�81�93�92�92�:1�:0�9,�8+�9*�)�3"�@2�I>�D@�;:�7;�:@�8B�HR�Ua�Xd�^g�`i�U[�AE�@>�?;�@C�GJ�LT�QY�T]�V`�3<�/5�04�8;�>B�;?�48�04�42�96�97�53�20�20�40�4.�<4�=4�<5�;4�83�73�43�43�99�98�88�99�97�75�5/�3,�8.�9-�9-�7*�3)�1)�0(�1,�33�43�23�11�1/�2/�3.�6.�91�<3�71�0-�@C�nu�ku�bq�Ri�Hf�;c�5a�6b�?e�Ni�]j�GFjF:^M=^WDYR?RJ7OF5ID0DJ.GU2Sc>^sHgMj�Oj�Kg�Gg�Ff�Gf�Ih�Ki�Nk�Rm�Vm�Uq�Up�Rk�Og�Kc�H`�E_�F_�G^�E[~DYwAVr?Uo@YpB]rG^uG[sCYtAXs@NB2QE5UI9WK;XL<ZN>\P@^RBaUEbVFbVFaUE`TDaUEfZJi^Zngwup�|x�{y�wx�vw�pu�jo�ch�`g�`f�em�qx�~�͉�؏�ؙ�֡�֪�۴�ߺ�����������������ºɼ�Ļ��������������qqquqppfewhe�nj�_Y�d_�ZT�f`�so�zv�{y�vu�hh�ZX�RN�HB�=8�E>�<5�G=�\R�;0�<0�7+�7)�>.�C5�B3�A1�B4�86�>>�CC�B@�=7�81�7/�7/�:3�93�:3�;3�>5�B6�E8�G6�-�;%�J8�L=�=5�0+�00�9>�AJ�LW�U`�Ze�]e�Ya�LT�>@�4/�7/�;9�@@�CH�DJ�BI�?F�5;�26�36�8<�8:�14�/2�14�20�95�85�0.�,*�0,�3/�4.�=5�>5�=4�<3�:5�95�65�65�57�57�57�68�66�54�2.�1+�7.�9-�9-�7*�3(�1&�1(�1,�43�53�33�21�1/�2/�3.�6.�;3�4+�:5�20�VY�px�cn�Zi�I`�Ef�8b�0^�5b�Bh�Le�PYk60^G7XK:UN;[O?VI9M@0JC0@F,AO.L\7Xj@bxGf�Jh�If�Fe�Dc�Bd�Fe�Hg�Lh�Oj�Sk�Sn�Rm�Qh�Ne�Kb�Ha�G`�H`�Ha�H_�H_}I]yH]wH`wKcxOczN]uC[vA[vAJC3MF6RI:TK<WK=YM?\O?^QAdWFeXGdXHbVF_UIbXNg^Ulcfwr�zv�zu�ts�ss�tu�lp�bg�\`�ae�fl�nt�x{ȃ�ӏ�ݗ�ޛ�ՠ�ө�ڮ�ݱ�ݲ�۴�ڶ�۵�ֳ�Ѯ�ɫ�Ī�¥������~�|x�dbgiefdZ[j[X{c_yVP�c]�NF�UM�`Y�ke�wr�{�zw�nj�a\�TO�GD�OK�B=�G@�WO�,"�1'�4'�?/�E6�>-�2"�7'�E7�E?�97�3.�61�;5�=5�<4�=4�;4�92�5.�4+�5)�8+�<,�?-�T?�G2�<)�;.�=2�;5�74�35�KP�MR�PU�TY�Y]�VX�MQ�CB�5+�7+�80�52�24�26�18�/9�4>�3;�5?�9B�4>�+5�(3�0:�-3�59�59�./�*+�1/�43�51�<6�=4�=4�=4�;6�:6�87�77�46�35�25�34�55�41�1-�0(�8,�:+�:+�8(�4&�3$�3&�4,�52�53�42�3/�2/�3-�3.�6.�=4�/&�>9�35�bg�oy�[i�Nc�C]�Eh�:e�0]�6a�Fj�J]�BHS-$WJ9SL:OH6[O?UI9F?/HF1>B'@J(IU1Sd:_rEe}Kg�Je�Hc�Ca�Bc�Dc�Ee�Jg�Mh�Pi�Ql�Pk�Mf�Jc�Ia�Gb�Fb�Hc�J_�G^H_}I`|Ka{Kd{Mf|Nf~N]xC]z@^{CDB6FD8KG<PG>RH>XJ?]M>`P@`Q>aR?`SB_VGcZSgb_ojnso~wq�zt�~x�yw�pp�gg�`a�\_�`b�fh�op�yz̄�֎�ߖ�眙栞ݡ�ף�٤�ڦ�ئ�ץ�Ԧ�ӥ�Ѥ�͢�ɢ�ȟ�Ù������|�rn}igld^`g[[kYUrWP}WN�WO�RI�[Q�XP�ZS�kd�yr��|����uq�us�_]�QM�EC�ZT�71�2*�7+�7(�7'�7&�9(�;+�=/�?1�8.�<2�@5�<1�5(�4(�:/�A6�90�90�7.�7+�7)�:*�?,�A/�=.�@4�E:�G<�C;�<4�3-�+&�<9�EB�PM�VS�YV�XR�NK�C:�;*�:(�8,�5.�./�*2�(3�'8�->�,@�*?�)?�(?�&?�%=�%=�#:�':�+<�,9�,6�.5�45�;9�84�:3�;4�;5�:5�95�73�54�35�46�54�54�53�5/�5,�5)�8,�9*�9(�9&�8&�7%�6%�4&�5/�41�50�4.�4.�5+�6-�7,�90�7/�:6�?B�mw�bs�Sj�Ic�Kj�6[�6_�<g�>c�Nj�IV^$#E-!?:'HE4PM<PI9EB1>B1?G/BH&EK%KS.S]8[kDavKd~Nd�Jc�F`�Ba�@c�Be�Fj�Jl�Pn�Rl�Lj�Ig�Gf�Hf�Jf�Ic�Ha�Ge�Kd�IbIdJgKg�Ie~Ga}C\|=\=_�B=?4@B7FC<JE?PE?TG>[K>^N>aP>`Q<^SA^VIc[Xhcinlyso�uo�vp�tp�pm�gf�aa�]^�]]�ed�kj�us�}{φ�َ����易囖ٜ�՝�֞�מ�֝�՞�ԝ�ў�ќ�͜�ʛ�ǚ�ē�����x�tk|mdif]^f[YiZSoWM{UJ�VK�VK�]S�ZS�XR�fa�qj�vo�~w�������uu�gd�US�ZU�2,�/%�7)�7&�8&�8&�8'�;*�;-�=/�9,�9,�:,�:,�9+�9+�8+�8,�;1�90�8.�8,�9*�9(�:&�9&�6*�80�=5�@8�A9�?7�<4�:2�4-�>6�IA�OG�QI�NF�C;�7*�8&�8$�7)�4,�//�+3�)7�);�+B�*A�)A�'B�#@�!<�=�;�:� ;�%;�);�-9�19�7:�;;�94�:5�;4�;5�:5�95�73�54�46�46�65�64�71�6/�5,�5)�9*�9*�9(�9&�9&�8%�8%�6&�5+�3-�4,�4,�5*�5*�7)�8+�<2�3.�54�TY�es�[p�Hc�Ih�Ad�;`�4\�<b�Mm�Lb�8?S*&A5)7:);<,B@1F@0@?-=B.?H-=CKP'\b<fpKhvRf{Rf}Qe�Na�Fa�Aa�@c�@g�Fj�Jk�Mm�Om�Lj�Gh�Hg�Gg�Jg�Jf�Je�If�Kd�IdHdHg�Gg�GfEb~A^�?_�?b�B7:/;=2@@8EB;KB=OE<VH=YL<^N>]P?\SD^WMc]]ifmom{sq�so�qk�jf�c`�\[�ZZ�\]�\_�hj�no�wxʁ҇�؋�ܐ����ݓ�ӓ�Г�Г�Д�ѓ�Г�ϒ�Ε�͓�ǔ�Ĕ���������z��r�|ewu^fi[[e\Wd[RgYLrVH�TH�ZQ�`Y�\Y�ZX�cb�ki�ok�vq����������}y�nh�aX�5,�2&�9*�:'�9&�9%�9'�:)�:+�:,�:-�6*�5'�8*�>/�>/�7)�/"�:.�8-�7,�8,�:+�:)�9&�7$�6*�6,�8.�;1�=3�@6�A7�B8�:1�A7�E;�F<�H>�G=�@6�7+�6%�6&�7,�50�03�-7�+9�*<�'=�'=�%=�#;�!:�7�7�6�8�6�$8�*;�2<�6=�8;�::�94�:5�;6�;7�95�85�75�54�36�47�55�65�72�6/�5,�5)�8)�9)�9'�8%�8%�7$�7$�6%�5)�4)�5*�6(�7)�7(�7*�7+�<2�1+�88�kr�]n�Pi�<[�Hl�7]�>e�5[�>b�Vq�?Qa#(L/+;7+18(37&:;)B=*A<(@>)BB&?FXa4s~T��dw�`i�Tb|MaI`�E`�@a�@d�Ah�Gj�Jk�Ml�Nn�Mk�Hi�Ig�Gh�Kh�Kh�Lg�Kf�Ke�Jc�Hd�If�Hf�He�Fb�Bc�De�Eh�H25*69.;<4A>7G@:KB=SF>VJ>XL>YM?YQD^WOc^bigron�ro�rm�jg�a_�WW�TU�WX�\_�ac�ln�rs�{|΂�Ո�ً�ی�܍�א�ҏ�Ώ�ώ�Ώ�ώ�Ў�ύ�Ώ�ʎ�Ə������������x�o��_p|Y`lXYd[T^_Q_\IjWF}SE�UL�\Y�Z\�X\�cg�kk�pl�xs�|x�zu��~�����{�ka�<2�8)�;(�;(�;&�:%�:'�9(�9)�8*�;/�6*�5'�9*�>.�>.�8(�/!�6)�5)�5)�7*�9+�<+�=*�;)�:-�:/�90�9/�:1�;1�<3�=3�E=�E;�A9�=3�=5�A7�@8�;1�6(�5)�6/�31�/5�+6�*:�)<�&9�&;�'<�'<�&<�%:�$:�#:�#8�#7�&8�,;�5>�9?�8:�87�94�:5�;6�;7�95�85�75�54�47�58�66�65�72�6/�5,�5*�9+�9)�9)�9'�8'�8%�7%�7%�5%�6(�7'�9(�9(�:(�9)�:+�:1�4/�IL�oy�Vj�E`�<_�Ag�3\�8b�>c�Ml�Oe�0=J C1-11'/7(5<,>A.B@+B<$E>$IF%U\0p~M��r��|��mj�W_{J]~E_�Ca�Ac�Bf�Ck�Jm�Mm�Om�Oo�Nl�Ki�Ih�Hi�Li�Lj�Ni�Mg�Le�Jd�Ie�Hg�Ih�Ig�Hd�Dg�Hi�Il�L.4(36+891<;6B=9H@=MD=QG=SI=SK>UNDZUQa^eigumk�lk�ki�b`�XV�PP�QQ�XY�`c�fj�or�ux�|Ѓ�ֆ�ى�؊�ً�֌�ϋ�̊�͉�Љ�ш�ъ�щ�Ќ�ϋ�ȍ�����������~w�m��Yj�SZnVTc\RZaOZ_HeZDxUB�ME�TR�SW�RY�^d�ej�kl�uq�un�oh�~v��{��~�l`�?2�8(�;(�<(�='�<'�;'�:'�9)�7)�:/�8.�8,�9+�:+�:*�9)�7(�9+�7+�8,�7+�7*�8*�<,�>-�<0�=0�<2�;/�:0�9-�7-�5*�@7�@5�=4�9.�80�;1�:2�5,�/%�0)�20�25�/8�-9�+;�+>�-?�/@�/@�/@�/A�/?�.@�.@�)9�)8�,8�0:�6=�8=�77�43�86�:7�;6�:7�97�77�65�44�48�48�67�76�74�6/�6,�5*�8*�9(�9(�9&�9&�8&�7&�8&�8%�:&�;'�=(�=(�=*�=,�<.�7/�<9�^e�aq�Pi�<[�Ai�4_�5a�1Y�Kl�Yq�>NZ%-C),:20.1*08-8A0=B,<<"A<UH(`[5|�T��n��������wo�[aK^F`�Dc�Bg�Dl�Go�Np�Po�So�So�Ol�Ki�Ig�Gi�Li�Li�Oh�Ng�Ke�Id�He�Ih�Jh�Hg�Ge�Fi�Ki�Kl�N+1%.4*470894>:7B=:HA;KD<NG=NG=PKEWSR_^ffeugggf�ba�[Y�RR�NO�RS�[^�ei�lo�uw�z|��փ�؆�ن�׈�Չ�Ӈ�ˆ�Ȇ�˅�΅�Ѕ�҇҇�Ѝ�Ҍ�ˍ����������{v�}k{�Vc�PVnUQd^P[eMYcJb^EsXC�OE�WR�UZ�T[�\c�ag�gj�po�yr�qh�|t�sj�xm�\Q�;+�5#�<)�=(�=(�<(�;(�;)�9*�7*�6,�7-�:.�:,�:)�8'�;*�=,�=.�@2�A4�>1�8*�5'�8)�<,�:,�:,�;/�<.�:/�9+�5+�5(�6,�;/�>4�?3�?6�>3�7.�,#�+%�-*�02�39�1;�0>�0A�1B�1A�1@�1@�0=�/<�-9�,9�*7�0<�/;�0:�4;�6;�69�55�53�86�97�:6�:7�97�77�65�44�59�59�67�76�74�72�6-�6*�7+�8)�8)�9'�8'�8%�7'�9%�9$�<%�=&�?'�@(�@*�?.�<1�61�HI�fr�Od�Hf�7[�Am�/]�7a�4X�Qk�Ufm19E(,E697325426926=-5:#38CCja:��T��w����͙�Ǖ��}v�be�Q`�F`�Bc�Bi�Fo�Jr�Or�Rq�Up�To�Ol�Kh�Hf�Fh�Ki�Lj�Oi�Og�Kf�Je�If�Ii�Ij�Ji�Ig�Fj�Jk�Mn�P(0#+1'14-561764<87@<9C>8IE<HE<KHCRPQ\Zecbtbb|``�_^�ZX�TT�TT�\]�gi�ps�vx�{�~�ۃ�ބ�݄�؃�օ�Ԇ�у�˂�ȃ�˂�̓�х�Ԉ�Ո�Ӎ�ҋ�ȋ���������|�wp�wfp~U[|PQnUNf_O^fNZdIaaGq]E�TF�]T�Z[�VZ�[a�]d�ae�ll�zs�rj�xo�YP�[P�D8�5'�:)�9(�;(�<)�=(�;*�;+�9,�6+�0'�4*�8,�;,�;*�;(�;(�<)�;*�C4�K=�H:�=/�5'�6(�;,�9)�9)�9+�9)�8+�9*�8,�7)�6+�<.�?4�@3�A7�A5�:1�1)�0.�14�5:�6>�4>�2?�0@�0@�.<�/<�/9�07�-5�,2�+2�+2�3;�4;�5;�6:�57�55�65�75�86�97�:8�99�87�77�67�46�5:�5:�7:�79�85�72�6-�6+�7+�8*�8*�9(�9(�9&�8(�9&�9"�:"�=&�?'�@(�@*�=-�;1�96�U\�^q�Gc�?a�;b�7g�3b�8`�Fd�Na�@IT15A55@:<:46?56>6389+6<"9CSZ.��Q��q�Ŋ�ˎ�˔�Í��}{�eh�R_�E^�@c�@i�Do�Js�Ps�Sq�Uo�So�Nl�Jh�Gf�Eg�Ji�Li�Ni�Nf�Kd�Id�Ie�Ji�Jj�Ii�Hf�Ej�Ll�No�Q&.!)/%-2+13.333764:97=<7GD=DD<HGCPPRZZd_ap``z\\~`_�][�YX�]]�gg�rt�z|��܁�ႅ䅆ㄅჃہ�Ճ�҃�΄�̃�Ʉ�̃�΅�Ӈ�֊�׌�ԍ�Ќ�ċ��������x�snuqbewXVtSLjVKg`NbfO_eIcaHp^F{R@�\N�ZS�TS�VZ�W\�Y`�ce�qn�me�qh�D;�A7�1%�4&�C2�8'�:(�;'�<)�;,�:,�7-�6-�,#�1&�6)�<,�@-�?+�;'�7$�4#�B2�OA�OA�B4�7)�7)�>/�;+�:*�8(�7'�6'�6(�8*�8+�;.�;/�9-�6*�7,�<1�<2�71�88�8=�;B�9B�4A�0=�,;�,:�/;�19�2:�48�49�48�36�57�37�6;�9<�69�45�44�76�;9�86�97�98�99�87�77�67�46�5:�5:�7:�89�95�82�7/�7+�8+�9+�9+�;*�:*�:(�:*�;(�9"�;#�=$�>'�?(�?,�<.�92�<?�\f�Qh�If�9]�=h�.]�<h�;\�\p�LV^-0G85BC><89?48F37C41=:)>D(GV-bs?��a���ˌ�ɋ�Ë�����z{�ef�PZ|@^�?a�>i�Do�Jr�Or�Rp�Tn�Ro�Nl�Jg�Fe�Df�Ih�Ki�Ni�Nf�Ke�Jd�Ie�Hg�Hh�Gj�Gg�Ek�Lm�Op�R)/#)/%(-&+-(///3317759:4==5?@8DE@KKKQQYVXe[[s^]}YX�[Y�^]�ee�nn�wx��؄�⌌���솇䂂܀�ւ�Ӄ�΂�ȃ�ǃ�˄�Ά�Ј�Ӌ�Ҍ�ϊ�Ŋ������}��x�wozkegf]Xm[Qm[Mi\Lf^Kd_IeaHh`Io_FoP;�UA�^P�bZ�YX�QT�S[�\`�gg�YR�D<�70�7/�:1�<0�;-�9*�:(�:)�:)�8+�8,�5,�5-�/%�3)�8,�>/�@/�A.�=*�:(�9)�0"�WJ�L@�/#�=1�</�8(�;+�:)�9(�8'�7&�6&�5&�4&�7)�;.�>2�<0�7,�8-�>4�C<�BE�9?�3=�4?�2@�-;�-:�2=�7@�5;�5:�78�8;�9;�89�77�;=�<<�::�87�77�76�75�75�97�98�99�::�9;�9<�9<�8<�7;�6:�8:�9:�;9�;5�90�7,�8+�9+�9+�:)�:)�;)�;*�<)�9#�='�:#�4�9%�D3�?6�0.�^e�Vg�Ib�<\�1X�0Y�6c�Bi�Yo�FQo33N3,B?6>C<A89@-1L/3K2.B9(DI)Zm?~�_��w�ł�ɋ��������~��nf�RYwCY{?^�?c�Ai�Fn�Im�Ll�Nk�Ql�Pj�If�Dc�Bc�Bf�Ih�Kg�Lf�Kh�Nh�Ng�Kf�He�Gg�Gk�Im�Lq�Sr�Ut�W*0$)/#).',.)//-220561782;<4>?7CD>IIGOPTSUaXYk[[u\Z^]�db�kj�ut�~·�ߋ�鍍���년 ؀~Ҁρ�˅�Ɇ�ȇ�ˉ�΋�ό�΍�̎�Ȋ�����|��x�{s�tknlb`e]Re_Oe^Lf^Kf^Kh]Ij^Hk_Io_Fw_G[C�YF�ZL�VP�RS�QX�X_�US�KF�>9�60�6/�90�9.�9*�7(�8(�9)�8)�7+�5,�4,�4-�0'�5)�9+�>.�A/�@-�<*�9(�8)�<.�RE�H<�4(�:-�:,�4&�=,�<+�;*�;*�:)�9)�8)�7)�7*�8,�7,�4*�1'�1(�7.�<5�DG�8>�/9�/:�0=�.;�1<�6?�6=�36�24�:8�DD�II�DC�?>�:7�98�97�96�77�87�98�98�87�88�99�9:�9;�9<�9<�8<�6:�59�68�88�;8�:5�9/�7+�8*�:*�:*�;*�<+�<)�<+�<)�9$�@*�:%�5�;(�;/�94�<?�]i�Pd�A[�8W�6[�;`�>d�Ie�?L�?>`;3G;/:>08>2F<:R>=N0.S8/VK7ciEx�[��p��}�Ɓ��}��������xr�^YuETp=\{B_@b�@i�Em�Hl�Kk�Mj�Pi�Og�Ge�Cc�Bd�Eg�Ji�Li�Nh�Mi�Oi�Mi�Kh�Hg�Gh�Gl�Im�Lp�Sq�Tt�W-1#-1#,/&,.)//-11/34/56.:<1<>1@B7FGAKMLQRWVVbXWi\Yt^]fd�pn�zx���΍�ߐ�ꐎ튉燄߁�|�}Ȁņ�Lj�Ɗ�ʌ�Ɏ�ɍ�Ō���������|��v�{p�ujpoeci_Vc]M_aL_aKc^Jg\Jl[In\Ho]Ir^FwaIxX?�S=�VD�XO�US�OT�MS�>=�<7�84�71�6/�7/�7+�7(�7&�8&�9'�8'�6)�5*�3,�4-�3(�6*�8+�<-�>/�>/�<-�8*�5)�I?�F<�A7�<2�6*�:-�6&�:)�:)�;*�:*�9*�7)�6(�4(�9-�7,�4+�3*�3+�6/�:3�<8�<=�49�07�29�3<�4<�7@�=C�7;�AA�NM�YU�YW�QN�B>�84�62�72�74�74�85�96�::�::�77�88�8:�9<�8<�9=�8<�8;�58�58�57�77�:7�:4�8/�7,�8+�:+�;+�<+�<+�<)�<+�<)�9&�@*�9$�6$�;+�0'�40�PT�[i�J`�:U�7V�@]�Hf�Hd�Na�89e?6R@2DA09=,57)?7,L:0F.$R=,g]B��_��t��{��z��{��z��������m]vLHb5Nh8\wB_}?c�@h�Dl�Gk�Ji�Jg�Lg�Nd�Dd�Cc�De�Fh�Kk�Nk�Ok�Ok�Ok�Oi�Mh�Jg�Hi�Hl�Ko�Mu�Vt�Wv�Y24&04&12*01+12-23.34.46+9;-;>-?A3DF9JKENPORQWTT^XVd\Zoda~nl�zw���Ì�֑�㔑ꓐ뎋≅ق�|�|��~����������Ì��������}��{��v�yn~rgmmaak^Vi[Pc\J^aL]aJc^Jh[JmZKqZJtZIv[FsWAxR;�Q=�ZG�[P�TP�FI�>A�2/�5/�51�60�5.�5+�6)�8)�6&�8&�9'�9'�6)�6*�3,�6-�7*�8*�7(�9*�=-�>/�;-�8+�3)�UK�=4�8.�A6�4'�<-�<-�8(�8'�9(�:)�9)�7)�6(�3'�6*�3)�2)�5-�:3�>7�?9�=:�45�59�6<�5;�2:�39�7=�<@�UV�bb�mj�id�VQ�A<�63�50�61�71�63�74�85�96�99�::�78�89�8;�9<�8<�8<�8<�7<�6;�68�67�97�<7�<4�9/�9,�9*�;*�<*�<)�<+�=)�<+�<(�:'�@,�8&�8'�;-�+"�54�`i�Td�G]�<U�=X�H`�Od�O_�SZvGAXH9KD2FE1BE0=?*:8#;3?3PG*nkH��f��v��t��s��x��������l�[K_:BW0Mb7Yq?`|Ad�@i�Cl�Fi�Hg�Ie�Ke�Jb�Bc�Bd�Eg�Hj�Ml�Om�Qn�Rl�Pj�Nj�Li�Ji�Hi�Gm�Kp�Ov�Yw�Zy�\78(68*77-56056167267/68+;>-=@-@C.DG4IK>MNFQPNRRRVUSYX]a_lki�us��}���nj�ӕ�ᔑ␍܋�ӄ�ā}�|�|��~����������������z��x��t�znzrfjm_^j[Ti[PjZKfZJb_Lb_Le^Li\Kn[Lr[Kw\K|[HVB�S>�RA�VF�SI�G@�88�33�1-�3/�51�4/�3,�3)�6)�9(�8$�9$�;'�:'�8)�7*�5,�7-�:+�9)�6%�8'�;+�>/�;.�7,�90�\T�=5�5+�A5�4%�:(�?-�;*�:*�:+�:,�;-�:-�8-�7-�3*�1)�1+�71�<7�>:�<8�74�77�;<�<?�6;�28�5:�BF�MO�xw�qn�`[�JC�83�2.�75�?<�93�93�72�72�64�75�76�76�79�79�7;�8<�8>�8>�7=�7;�8<�7;�7:�::�=:�=7�;2�;/�8*�:*�;*�<)�<*�<(�;)�;)�<)�>+�9(�9*�8-�/)�@C�hr�M^�H[�EZ�H[�O^�T]�TW�XUdM?PM:LG4KF2FD-@C(>E$?I$KV.\g<x�T��h��m��n��r��}������u�dRcC?P0BS1Oa9Wm>b{Be�Bi�Ck�Ei�Hf�Hb�Hc�Gb�Bf�Cg�Hi�Jk�Nm�Pn�Ro�Sk�Ok�Ok�Mi�Ki�Ik�Io�Mr�Qv�Yv�Zw�[?=.=>0==3==5=<7<=7;=2;=/?B/@D-CG.FJ3KL:NOAQQIRRHYWJZZN`_]gerqn�{y������ď�я�Ӎ�ϊ�ǃ�~y�zw�yv�{v�|y��|��}��}�x�|t�zr�vksrffn`]j\Sk[NlZLl[Kk[Ki]Mg^Mi]Mj]Mo^Ns^Mz]M�[J�`O�VG�N@�J=�@7�60�1+�1+�51�70�5/�4-�2)�4'�6&�;(�9$�;$�<'�;'�:)�9*�7,�9-�=,�:(�5#�6$�9)�<.�;/�7-�?7�[T�IA�:0�@3�6&�3 �<)�:(�7'�7'�7(�7)�7*�7,�7-�<3�;3�:4�<7�>:�>:�85�41�96�;;�::�8:�>@�OR�be�pp�he�UQ�=6�1+�40�;7�=;�;9�;5�;5�94�83�75�65�55�66�69�7:�7;�8<�8>�8>�7=�7=�8=�8;�8:�;:�>:�>7�=3�</�8)�:)�;)�<)�<(�;'�;'�:(�<)�9(�;)�9*�6*�>8�TX�ep�K\�I]�J^�M[�QZ�VV�ZR�`RPI7IN:NI5H@+;578>O%Lf6l�Tw�\��e��d��f��l��t��|��mn}\Q`C<J09F,AP1O_;Wj=d{Ef�Ck�Dl�Fi�He�Fa�Fc�Gc�Ci�Fj�Kl�Ml�Ol�Om�Qn�Rm�Qm�Om�Pl�Ll�Ln�Lr�Os�R{�]{�_z�^EB1DB3DB6CC;CC;CC;BB6BC3DF0EH-GJ-JM2ON9RQ?TREUSD\ZC\\D\]Oaaaihxrq�{z��~������È�����{�ys�to�ql�qm�rn�vp�wr�wr�to�skzrinmb`l_Wj\Qk[Lm\Lo\Mp]Lq[Mq[No[Pm]Nl_Om`Os`O{`O�ZM�_S�QG�A:�;4�6.�1*�2)�5,�70�6/�4.�4-�4*�5(�8&�9%�:"�="�>%�>'�<)�;*�9,�;-�@-�<(�5!�3!�8(�<.�:/�5-�93�NI�TM�B9�B5�?.�1�=)�=-�9+�7*�7*�7+�9.�;1�<4�E>�A<�?;�>;�=;�;:�88�85�96�95�66�;<�JK�\]�de�ba�=9�82�4.�92�A=�E@�=;�42�;5�;3�94�94�84�84�77�88�69�7:�7<�8<�8>�7=�7?�6<�6;�7:�89�;9�>9�>6�<2�</�8)�;)�;(�;'�;(�:'�:'�:&�>+�7%�=+�9)�2'�PK�km�\f�P^�J\�HY�LV�RS�[R�cQ�jUJM8DL7JB/H9$B7FH#Up=g�V~�p��q��h}�Y��Y��c��d|�_XfCHU9:F.7C+:D,=J0JX7Wh>e|Fi�Dl�Em�Gi�Gd�Ga�Ga�Gf�Fl�Im�Nn�Ol�Ok�Nk�Om�Qp�Tq�Sp�Sp�Po�Pq�Pv�Sw�V|�^z�^y�]IC3JD6IE9JF;IF=IG;HF9HG5IH3JJ2LL2NN4RP;TQ>XRDYTA]Y>[Z>\YH_\Udahnk~xs�}x��{��}����|�}w�vo�oi�lf�ie�jf�mh�mi�mh|lfrkbgj`^g]Th\Nh[Kk\Io^Lq_Kq^Mq^Mp]Op]Op]Os]Ow]N~]N�\L�XL�VI�F<�9/�7/�7/�7.�6-�6-�6/�5.�4,�5-�7,�8*�6'�6$�:$�<$�='�='�;)�;*�:,�<-�A/�<'�4"�3 �9'�=.�;/�8.�3+�A;�[T�I@�D7�F7�2�>,�F7�B5�@5�?2�@4�A7�E<�F?�@;�=9�:7�75�54�65�:8�<9�?9�=8�:5�@<�LI�QL�?;�)#�-&�6.�>7�@;�>9�;8�;;�==�96�96�96�86�95�:6�99�::�88�88�8;�8;�9<�8;�6<�6<�6:�68�89�:8�=8�>6�<1�;-�8*�;*�;)�;(�;'�<)�;(�;'�?-�5"�=.�8*�/&�\X�y|�X_�Xd�Q^�KT�LO�VR�`U�hV�nVPW8?J*<;C=UQ+lvD��f��~��v��s|�bn�MvR��^u}V[b@;D)4<%5=(=D2<E29C+CP2Vf?g{Hi�Fm�Hm�Gj�Gf�Gb�Gc�Gh�Jl�Mo�Po�Pl�Mi�Kj�Jj�Ls�Us�Us�Sr�Qr�Qs�Ry�V{�Zv�Zu�[s�YRK;RK;RJ=RJ=RJ=RJ=RJ=RK;UN<VO=WP>XQ?YR@[TD\UE\UEc\Ib[IaYLbYRe][kaiqftuj{zn�|p�s�s�|p�uj{mbrf^kc`k`_g_\c_Z^^ZY^YUaZRbZOe[Og[Ki\Kk\Il]Hm]Fm\Hj^HibOqfTqZJuOB�WJ�\P�ZM�ZL�M?�E5�<,�7(�8-�80�41�1-�6/�7.�7.�7.�7.�7+�7*�7)�8)�8)�9)�9)�9+�9+�8+�;,�;+�>-�9(�1 �2!�:+�</�9.�6,�5-�:2�B:�K>�H9�=,�2#�PF�KA�E=�E<�G?�G@�C>�=;�74�87�;;�::�77�75�85�=7�F>�B9�:0�3)�1&�6*�;/�@4�:0�=4�@8�@;�=;�;;�8;�9<�7:�8:�8:�99�97�97�95�95�51�51�65�76�89�9:�9;�9;�;>�9;�9;�=:�A=�B;�A6�?1�9+�<+�=*�<(�:&�9'�8&�9&�A0�<-�/#�0'�LJ�mo�lo�VZ�LN�NO�PO�UO�XP�]R�aT�jSWZ/:M7FTa)~�P��o��y��y��s~�ah�N\mCYdBT]BHP9?D0:=,@C2=A2;?1<C3:C0AN2Rd>]sBg�Hp�Ko�Kl�Gj�Ii�Kg�Ll�Pm�So�Sn�Pm�Mk�Jm�Jm�Iq�Mq�Nr�Nr�Pt�Rv�Vz�Y{�^y�cm�Zc�PWN?WN?WN?WN?WN?WN?WN?WN?XO@YPAZQB[RC\SD]TE^UF_VGd[Jd[LcYMcYOf[Uj_]nbdpdhreltgpvirvirsfmm`gg[_bXY^[VZZRZWPXULXTIXTH\VH^WGcZKcZIf[Ig\Hi]Gj^Fk_IiaJcbMngTv\M�SF�WN�VO�RJ�RF�G:�B2�=,�9)�8,�80�62�40�6.�8.�8.�8.�8.�8-�7,�7+�7+�7+�7+�7+�8+�8+�8+�:,�<.�>.�9(�1 �2 �:)�>.�<.�:-�5+�4+�;2�E:�OB�QC�OC�F?�@;�;6�:5�=7�=8�86�44�8:�78�79�78�77�97�=9�B<�A7�@5�:,�6'�5&�8)�=-�@1�A4�@6�@7�=8�:7�77�58�7<�6<�6<�7:�89�87�95�95�:5�92�:3�:5�;6�;8�;8�::�8:�:=�:=�<=�?=�A;�@7�=2�<.�;+�=*�=+�<)�;(�:&�8&�9'�9'�8)�5*�<5�QP�ee�^a�NN�NL�SO�XQ�\R�^S�_T�_V�fQ`_/Sg*^r3z�O��n��|��p��bj�HbvCTe;KY8FP7@I69?158-:</AB4=?4:=2>B4:C0@M3Rd>^tEh�Iq�Mp�Ln�Hm�Jk�Lj�Nm�Sn�To�So�Ql�Mk�Hl�Hm�Hp�Jp�Jp�Ls�Qu�Tx�Xx�Xx�^m�Xb�QY�H]TE]TE]TE]TE]TE]TE]TE]TE\SD\SD]TE^UF_VG`WHaXIaXGe]Je]Jd[Je[Oe[Qf[Uh]Yi^\j^^j^`k_ak__i^\f[YbWU_VQZUOWTKUQHRNCQMBSOCWQCXRB^WG_XFaYFc[Fg\Hi^Hk`LicMbaMngUy_P�XN�[U�VQ�IE�E@�@8�>3�;/�8+�8+�9.�;/�:/�8.�7-�8.�9.�8-�8-�7,�7+�7+�7+�7+�8+�8+�8+�9+�;,�>0�?/�:(�2 �2 �9'�>,�?/�?0�8+�2(�4*�<0�F9�N@�ND�:6�43�20�42�97�=<�<=�;<�9<�5:�27�37�58�99�<:�@:�8-�:+�6'�4%�5%�8(�<+�=.�D7�C9�B8�>8�96�66�66�79�6;�7;�7:�88�88�:6�:6�;4�:3�;4�;6�<6�;8�:9�99�88�9:�<<�@>�B=�?9�;2�7+�7(�;,�<+�<+�;)�:(�9&�8%�9&z6#y6%�9,�F=�SO�WT�PO�IF�MH�SL�ZQ�^S�aW�aW�_V�ePsrFz�V��n��������{|�[[o<@S%AS+BQ0?L2:C06<.69058/9;.@A3=?4:=2=A3:C0@M3Qc=`vGi�Js�Or�Np�Jo�Lm�Nl�Pp�Tq�Uo�Sn�Pl�Ml�Il�Hn�Ip�Lp�Lp�Nu�Sx�Xy�[u�Wq�X_�JVGOx@aXIaXIaXIaXIaXIaXIaXIaXI_VG`WH`WHaXIbYJcZKd[Ld[Je]Hf^If^Kg^Mg^Of\Pf\Rf\Sh]Wh]Wh]Wh]Wg]Tf\RdZPc[P]YNZVKVRFRNBPL@PM>TN@UO?XRBYTA[VC]XDaZGd]Jf_LfaMdcQleUv\O�[Q�b\�ZX�FD�<:�<9�;6�92�8-�8,�;+�?.�?/�9-�7,�8-�9-�8-�9-�8,�7+�7+�8+�8+�8+�8+�8+�9+�;,�?1�?/�:(�3 �3�7#�=)�@.�?-�:+�7*�5*�7+�:.�</�:2�66�24�12�34�88�<=�=?�<?�7<�38�06�25�58�77�65�61�5(�7'�6&�7&�7&�9(�:)�:*�A3�B6�A7�?8�;8�87�76�79�6:�7:�78�86�86�94�:4�;4�92�:2�:4�;7�:8�;9�:8�99�<:�A=�C?�A;�<3�6+�6'�7(�;*�;)�;)�;(�:&�9%�7#�9%�=*w6$�5'�E:�PH�MG�LG�QL�PJ�UL�ZO�^R�aV�bW�aW�gT��_��z��������ts�YN`8/A->4C&:F.=F3;A3:=2:=4<=5::.?@2<>39<1<@29B/?L2Qc=awHj�Kt�Ps�Or�Lq�No�Pn�Pr�Ts�Up�Ro�Pm�Lm�Jn�Jp�Kq�Mr�Ot�Sy�X|�]w�[m�Se�M[�HS|DNw?d[Ld[Ld[Ld[Ld[Ld[Ld[Ld[LcZKcZKd[Ld[Le\Mf]Nf]Ng^Mf^Ig_Hh`IiaLiaNi`Oh_Ph_Pj`Tj`Ti`Qh_Ph_Nh_Nh`MhaOd^N`ZL[UGVPBPM>NK:NK:NK:QN=RO>TQ@VS@XWC[ZF]\H^]Kb`Qf^QmWJ�[R�jd�c`�MM�BC�;=�89�84�70�9-�=+�B-�B+�;+�7)�8*�:+�9+�9*�9*�8)�8)�8)�8)�9)�9)�9)�9)�;,�?1�>0�:(�6"�4�7 �=&�B-�;*�;,�:,�9-�8.�:0�=3�;5�9<�4<�39�28�38�59�38�17�6<�49�4:�7:�9<�76�21�/*�6*�9*�:(�:(�:(�:(�9&�7&�:+�;/�>3�?7�>9�;8�96�87�68�66�66�74�84�:3�:3�<3�:2�;2�<5�=7�=:�><�=;�>=�@<�C=�A<�>6�7-�5(�7(�:*�;)�<)�;*�:(�9&�8%�7$�8%�@-u4"{3%�G:�RJ�NF�NG�WN�VM�YM�ZN�]O�]R�`U�`Y�hW��h��|�����j]kHDS42@&$2-:&0;*5=.9?3<?4=>6;<4::099-?@2;=28;0;?18A.>K1Pb<bxIk�Lu�Qt�Ps�Ms�Pq�Rp�Rr�Sr�Sr�Sp�Om�Mm�Kp�Ls�Ot�Qv�Uz�Y{�^z�_q�Vd�JZ�D]�JW~GRyBe\Me\Me\Me\Me\Me\Me\Me\Me\Mf]Nf]Nf]Ng^Og^Oh_Ph_Nh`Kh`IiaLjbMjbOjbOjaPjaPjaPiaNh`Mh`Kh`Kh`IiaJjbKf_Mc^K^XHXRBSM=MJ9KH7IH6LK9LK9LM;NO=PQ?QTCSVETUE[YL^VIcQEzXN�ha�ea�VU�RS�@C�:>�87�83�;.�?-�C*�A(�;*�8)�8)�9*�:+�9*�9*�9*�8)�9)�9)�9)�9)�9)�9)�;,�?1�>0�<)�:%�6�5�;#�A*�B.�@/�;,�7*�2(�4+�;2�=:�5:�3<�6=�8>�:>�;>�:=�9<�58�7:�9>�=>�=>�96�2/�0'�9+�=,�=,�>*�=)�<(�:'�8%�6%�7)�;0�=3�<5�<7�;8�:7�87�75�75�85�:4�;4�<4�=4�>5�?7�A:�B<�A>�A?�A>�B?�@:�@8�=3�8-�5(�5'�9)�<*�;*�<)�<(�;'�9'�7%�6$�7&}:)t3!~9*�OA�YN�RG�OE�WK�YN�[M�ZM�[M�\Q�_T�`Y�gY~wZy�`r|ZVaC;E,/;%0;*0<.3=25=27=3<?6@A9?A6<<277+89+>?1:<17:/;?17@->K1Oa;bxIk�Lu�Qu�Qt�Ns�Pr�Sq�Rs�Rs�Pr�Op�Mn�Lp�Ns�Ov�Ty�X{�\|�]z�]q�Wg�O]�EX�Ba�OY�ISzCg^Og^Og^Og^Og^Og^Og^Og^Og^Og^Og^Oh_Ph_Ph_Pi`Qi`OjaPjbOjbOjbOi`Oi`OiaNiaNiaNh`Kh`Kh`Ih`IhaGhaGhaGg`Me^Kb[I\WDWR?PM:MJ9IH6IG8GH8GJ9GK:HL;IM>JN?KM?PPDXRF[OCiRD�ZN�VL�SL�ZY�IJ�?B�99�75�;1�@.�B*�<$�:)�7(�8)�:*�9*�:*�:*�:*�9)�:)�:)�:)�:)�:)�:)�;,�=0�=/�=,�<)�8"�4�9 �A)�C-�A/�=/�6+�/%�0'�6.�:8�59�6>�;C�?E�AE�BC�@A�@@�12�66�:<�=;�;9�82�4.�4)�<-�>+�?,�@,�>+�?)�<(�:'�7%�7'�8+�8.�70�94�<9�>;�97�95�95�:4�;4�;4�=4�>4�B7�C9�C<�B;�A=�?<�=;�>9�<3�:/�8+�6(�7'�8)�:)�:(�<+�<*�<)�:'�9(�7&6%}6$x3#x5%�C3�UE�WK�PC�PD�ZL�YM�ZN�\Q�\Q�[T�\U�\W�bUkbEWa>JS4=G,6?*3>-4>35?66=69@9=B;CF=EG<DE7@>/;9*78*=>0:<17:/:>07@-=J0N`:awHk�Lu�Qu�Qt�Nt�Qr�Sq�Rq�Or�Nq�Mp�Lo�Kr�Nu�Ty�X�`~�az�^q�Wf�L_�G]�E^�Ib�PY�KSzEh_Ph_Ph_Ph_Ph_Ph_Ph_Ph_Ph_Ph_Ph_Ph_Ph_Pi`Qi`Qi`QmdUlcTj`Ti`Qh_Pg^Oh_Nh`MiaNiaLiaLiaLiaJh`IhaGh`IgaKg`Me^Kb[H\WDUR?QN=ML:EF6EH7DH7DH7CJ:CJ:CI;EI;IK>SQDSPAYM=eK:tD6�I?�YS�QQ�DE�::�86�<4�>/�=)�8"�:)�9(�:)�;*�;*�;*�;*�;*�:)�:)�:)�:)�:)�:)�:)�;,�;0�:.�<,�>+�9#�3�7�?'�9$�<)�>0�=2�8.�7/�<5�?=�=B�?D�DH�DE�@?�;7�50�1.�/,�51�:6�<6�:2�8.�8,�;,�=-�>+�?,�@-�@-�A+�?+�=*�;*�:(�7(�5)�5+�90�>9�C>�<7�;5�;5�<4�<5�=4�>5�@5�D9�D:�C;�B:�?:�<7�85�93�7-�8(�5'�6'�:)�<,�:)�8&�=*�<+�<*�<)~9)}9&{6&{6&z2$�8*�G8�SC�QC�L=�RE�_S�WL�YN�[R�]T�^W�\V�ZU�_RaX;EM(6@8A&>G2=F53=2-7.1817>6CF?GJ?HI;BC1?>*;:&78(=>09;069.:>06?,=J0N`:awHj�Ku�Qt�Pt�Nt�Qr�Sq�Rq�Mq�Lq�Lp�Kp�Ls�Qw�V{�\��e��dx�^j�P]�EY�A^�He�Pc�SZ�LSzEi`Qi`Qi`Qi`Qi`Qi`Qi`Qi`Qi`Qi`Qi`Qi`Qi`Qi`Qi`Qi_Sj`Wj`Wj_Yj`Wj`Vj`Vj`TjaRjaRjaPjaPjbOjbOjbOjbMjbMg_Jg_Jf^Ie_Ib]IZXCSP=ML:HI9EH7AE6@D5?E7?G8?G:?E9GK=IK=BF5KJ6\Q;aE0�J9�j]�g`�US�FE�A@�A=�>5�=0�=-�4%�5&�6'�7(�7(�9*�;,�=.�<-�<-�<-�<-�<-�;,�;,�<-�2(�7.�;/�:+�7"�5�7!�9"�A-�=,�6)�4*�6/�<7�C?�HE�DE�FI�CE�98�61�80�8.�4+�9/�9.�9/�8-�9,�:+�<+�<+�=+�=*�>+�?,�@-�@.�A/�@-�;*�:(�7(�6)�7,�8-�;3�<4�=6�=6�?8�A7�A9�B6�@6�@5�H=�E;�A8�;2�5/�3-�0,�2+�9-�;*�9+�:*�:)�;+�;+�<+�:(~9)|9(|9(|9){8'y6&x3$w- �A6�PD�MA�MA�RF�UJ�RG�\R�\R�UM�TL�ZU�XS�WT�gZ]T5IQ*BL)BK,>H/7@+2=-4?14<1HPCZ]RX\MMO:DF.AA'==%:;)>?1;=2:=2<@24=*;H.Pb<cyJl�Mu�Qs�Or�Lr�Or�Sr�Sr�Nq�Kr�Nr�Ns�Pv�U{�\�b��fx�^j�O`�G^�Ga�Jf�Pi�Ud�S[�LTyEi`Qi`Qi`Qi`Qi`Qi`Qi`Qi`Qi`Qi`Qi`Qi`Qi`Qi`Qi`Qi_Sj_Yj_]j_]j_[j_Yj`Wj`Vj`Tj`TjaRjaRjaRjaRjaRjaPjaPh`Mh`Kg_Jg_Jd]J^YEUR?ON<IJ:FI8BD6@D5?E7?G8>F9=E6@F8>E5>F1HL5MI0U?(P<�sd�cX�_Z�UT�GG�@>�A>�?9�:0�9-�<-�=.�=.�;-�:,�:,�:,�:,�:,�:,�:,�:,�:,�:,�;.�?5�B:�B7�=/�7$�2�1�2�5#�7(�:0�A8�F@�ID�JF�KH�CA�ED�B@�;5�9/�=0�?1�=0�?1�>2�?1�>/�=/�>.�@.�?,�=*�;*�<+�=,�>-�?,�>,�?-�@.�=-�:,�8,�8+�8-�:0�9/�;3�;4�?5�B8�C9�C9�D9�E8�B6�A4�=3�:0�6/�5.�5/�7.�</�=,�;,�;+�:*�;*�;,�<,~;*|:*{9)y:)x9(w8'v7(w3&�3)�C9�NC�L@�K?�QD�TI�RG�SJ�XO�UO�WQ�]X�WR�SO�cT]W5Xc9_jBZfBIT66C)4@*<H4OXGYbQ_fTW\HJN7BE*??#<<"9:(=>0:<1:=2<@25>+;H.Pb<dzKl�Mu�Qt�Pr�Ls�Pr�Sq�Qs�Pr�Lp�Lq�Nt�Sx�Y|�_�c{�ao�Uc�J]�Da�Je�Ne�Nc�Od�S[�LTyEi`Qi`Qi`Qi`Qi`Qi`Qi`Qi`QjaRjaRjaRjaRjaRjaRjaRj`Vk`\k__k__k`^k`\k`ZkaXkaWkaWkaUkaUkaUkaUkaUkaWkaUlaOk`LiaNiaNf_Ma\IYVESR@NL=IJ:DF8AE6AE6?F6>D6<D5=F57@-@H1IK3F?%W?'�ZE�rb�VJ�bZ�eb�TS�FH�GH�CD�:7�7-�:,�:,�:,�9,�8+�7*�6)�8+�7+�7+�8,�8,�8,�8,�8.�3-�5/�6-�3(�0"�. �2!�3$�@4�C7�G?�LF�MI�JG�FB�D@�CA�DA�@:�;1�</�A1�E4�E3�D3�D4�B2�A0�@0�A/~A.@.�:*�9+�:)�;*�<+�<+�=,�<*�?.�>.�;+�9*�8+�9-�:/�9/�90�90�;0�>3�?4�A5�B4�A4�:.�9.�8-�7+�6+�8-�8/�;1�</�=-�;-�;,�:+�;+�;,<,};+{<-z;,w9*v8)u7(t6)v4&�<2�G=�MD�J?�H<�OB�TI�RI�OI�TO�SQ�WS�]Z�YU�[T�l[�}X~�^��alxRLX46D#=J.LZ@eqYeoW]eMPU>EI0?C(=@#:<$89';<.9;09<1=A36?,<I/Pb<dzKm�Nv�Rt�Ps�Ms�Pr�Sp�Pu�Rp�Ln�Lp�Ow�V{�\}�a|�bp�Uf�M\�E\�Ee�Mj�Rf�N`�Ic�RZLSxEi`Qi`Qi`Qi`Qi`Qi`Qi`Qi`QjaRjaRjaRjaRjaRjaRjaRj`Vk`\k__k`^k`\k`\kaXkaXkaWkaUkaUkaUkaUkaWkaWkaXkaWnbRmbPjbOjbOibPe^L_YIYVERO@NL=GH:DF8CE7BD6@D5<C3<H4:C.FJ3MG1P;&qL9�bQ�^P�A5�SL�c_�^^�SU�JO�DJ�AC�92�9-�7-�7+�8/�:/�;2�:0�>6�>4�=6�>4�>7�?5�>7�>7�@<�B>�D>�F=�F<�I>�M@�QE�SJ�QJ�MG�IE�FC�C@�A=�B=�FB�D?�?7�=0�?/�C2�H4�I6�G5�E3�C3�B2�A0~A/zA0}@.�:,�8,�9+�:,�:,�;-�;+�;+�:+�9+�9*�9+�9,�;/�=1�<0�:/�9/�:0�:.�:.�:.�9+�8*�7)�7*�6)�6*�7+�8-�9/�<0�<.�<-�;,�:+:+~9*~;+};+|:,z;,y;,w9,s8*q6(r7)u5)�C:�I>�KA�H<�I<�OD�TK�TL�QL�TP�QO�SO�\X�_X�h^�~j��p��fu�WYh?CR+?O*P`<crQetU\iKOY>CL1?E+?C*=A(;='78(:;-79.9<1=A37@-<I/Oa;bxIl�Mv�Ru�Qt�Nt�Qr�Sp�Rs�Po�Mo�Ms�R|�]~�ay�_t�Zc�J^�E[�D_�Hg�Oj�Pf�L`�Hb�QY~KRwDi`Qi`Qi`Qi`Qi`Qi`Qi`Qi`QjaRjaRjaRjaRjaRjaRjaRj`Tk`Zk`\k`ZkaXkaXkaUkaUkbSkbSkbSkbSkaUkaWkaWkaXkaWocUnbRkbQlcRkbShaQd]M`ZJXRBSP?NK<IG8GE6DE5BC3>B1=I1?G/LG1S>+g=-�ZL�_S�>6�3+�?9�XU�ig�de�RU�JN�OQ�ID�F<�@7�>4�?7�D:�F>�G>�JB�JA�JC�JB�KD�KC�KE�KE�SR�TT�SR�SP�SL�SL�TN�UP�LH�IF�EB�C@�B@�C@�EB�GE�IH�DA�?8�=2�?2�B1�E3�G6�E3�D4�B3�A1�?1~?0z?1|>/�:.�9.�9.�:/�;-�;-�;-�;-�9*�:+�9+�9,�;,�;-�<.�;/�:1�9/�9-�:.�9,�9,�8*�8*�8)�8)�8(�8)�9*�:,�:-�;-�:-�:,�9+�8*}7+}7+|8+{9+{9-y9-x:-v8-q5*o5)q7+u:,�H=�J?�I=�I;�L@�RF�WM�XO�QM�UQ�SP�VQ�`Y�bW�g[�{enrQZi@JY0BS)IZ0WiAdvNj|VXiEL[:?L.:D)<D,>C-<A-:=,89+:;-79.9<1>B47@-;H.L^8_uFi�Jt�Pt�Pt�Nt�Qs�Tq�Sn�Mm�Lp�Pw�Y|�az�`r�Xj�RZ�C\�Ea�Ie�Mg�Mg�Kh�Jg�Mc�PZ|JRtBi`Qi`Qi`Qi`Qi`Qi`Qi`Qi`QkbSkbSkbSkbSkbSkbSkbSkaUlbYlbYlbYlbVlbVlcRlcRldQldQldQlcRlcTlbVlbXlbXlbXocUnbRkbQlcRlcTkbSg`Pd]M^WGYSCTN@MJ;KH9GE6FC4@C0;H.@I.OC-a=-�F;�YS�NJ�,+�:9�=;�SR�pn�vv�eh�X^�^_�UQ�PF�G@�C:�D=�G>�GA�G?�HC�JB�HD�JC�JF�KD�KG�KG�HH�GI�HH�GG�HD�HD�GD�ED�BA�AB�BA�BB�CB�B@�A>�A?�II�C@�<6�>3�@3�@2�B3�D3�A2�@1�?1�=1�<2�<1=1=1�;1�;1�:3�;1�;1�</�<1=/�</�=-�;/�;,�:,�9*�8+�7*�:/�8.�9-�:/�;.�=.�</�>.�9+�:+�:*�:+�;,�;+�;,�:+�:,�9+�8*~6(|6*{5){5){7*x6*x8,x:/s7,p4)o5)r:-w=1�M@�K>�J<�M=�QC�VH�XM�WN�NI�TO�VR�]V�e\|_QgWGa_HEO->N)?O(J\4_qGk}SewMXj@N`8@Q-6E&7D*=F1=D4:>07;-8:,:;-68-9<1?C57@-9F,I[5[qBe�Fr�Ns�Ot�Nt�Qs�Tq�Sm�Lo�Os�Ux�\z�`s�[i�Q`�HY�B^�Ge�Mg�Mg�Ke�Gg�Gh�La�NXzHQsAi`Qi`Qi`Qi`Qi`Qi`Qi`Qi`QkbSkbSkbSkbSkbSkbSkbSkbSlbXlbVlbVlcRlcRldOldOldMldMldMldOldQlcTlbVlbVlbVocUnbTkbSlcTmdUlcTjaRf_Ob[K^WGXQARL<OI9JG6IC3AC.:G+AG+U@+xG9�PL�II�8<�39�AE�?@�JI�b`�qp�np�be�Z\�QN�LD�E@�B;�D?�E>�B>�A:�C?�C=�C@�D?�DB�D@�EC�DC�AD�AD�DF�GH�IH�JI�II�GH�AC�AD�BE�BE�AA�@>�=:�=:�FF�=<�83�<3�@4�?1�>0�A1�=0�<0�;1�:0�81�93�:4�;4�;3�<3�:4�<3<3}=1}=3}=1|<0|=.|<0|=.};-{9)z8*{7*�:.�9.�9-�9.�9.�;.�<.�=-�9+�9+�;+�;*�;+�<*�;+<+�8*�8,~6*}5)|3*z4*z4*y5*u2)v6,w9.s7,p4*o5*s:/x@3�QC�N?�N=�Q@�VF�XI�UJ�SJ�PJ�SP�TR�\V�e\n[LPK7EK1AN0KZ9WgC`rLgyQdyNWm?G\1AV-7H$1@!6B*=F5<D98=67:3:</;<.79.9<1?C57@-7D*FX2Vl=b~Co�Kq�Ms�Mt�Qt�Ur�To�Pq�Qu�Wv�Zs�Yj�Rb�J[�E^�H`�Id�Lf�Lh�Jh�Hf�Fe�Ia�NXzHPr@i`Qi`Qi`Qi`Qi`Qi`Qi`Qi`QkbSkbSkbSkbSkbSkbSkbSkbSlbVlcTlcTlcRldQldOldOldMldMldOldOldQlcRlcTlbVlcTnbTmaSmaSmaSmdUlcTjaRg`Pd]M_YIZSCTN>PK8MH5ID1DC.@F*DD([B,�TG�\X�>A�/5�HO�?E�;>�;<�FG�Z[�ef�Y[�GH�JG�EB�B?�B>�FB�FB�B>�?8�D?�D?�D@�EA�EB�EC�DE�DF�@D�@D�BE�EG�GG�FF�BC�>?�BD�@C�>A�=>�>>�A?�C@�EC�CC�98�50�;4�?6�>3�=/�?2�</�:0�:0�81�83�94�94�;5�:3�;3�:2;2~<0~<0|<0|<0x8,y9-z:.z:.{<-{<-{<-z;,};/9/�7.�7,�6*�5*�7*�8)�8,�9*�:-�<-�<-�=,~<,~<,}9,}7-|6,z6+z4*x4)y5,x5,r2(u5+v8-r6+n4)n5*t;0xB6�UG�PB�O@�SD�WI�VJ�RG�NG�TN�UP�RK�XOcUf[GGK2=J,IX9ZkIhyUcxQZoFSh?Pb:L^6;M'0?,95>)=C5<B8:<79<5;=2;=079.9<1?C58?-8B)EU1Uh;azCn�Mr�Nr�Pt�Qt�Ur�Tt�Uu�Xv�[t�Zo�Uf�N^�H[�Dd�Na�K`�Hc�Ih�Ji�Ke�Ea�E`�MWyGPr@i`Qi`QjaRjaRjaRkbSkbSkbSjaRjaRjaRjaRjaRjaRjaRjaRkbSkbSkbSkbSkbQkbQkbQkbQlcRlcRlcRlcRlcTlcTlcTnbTk]PqaRtdWrdWnbVj`TiaThbTgaSebQc]M[VCVQ=TO9NH2GA)KG,I?$bI3�gW�wn�lg�YW�PR�BE�BE�DG�FH�HK�JK�LM�KM�EE�DE�ED�FE�FB�C?�D=�F<�C:�D;�E<�E?�D@�CC�AD�@D�BF�BD�CD�DE�DE�EF�ED�EE�CC�B@�@?�@?�?>�@=�A>�C?�B?�?;�93�70�:0�=2�>3�>2�?4�?3�=2�<4�93�83�92�92�;0�<.�<.�;-�;/�;/�:.�:.~:-~:-~:/~:/};/};/};/};/}90}90~80~8.�7.�7.�8/9-�7.~8,}9.|8-{9-z8,x8,x8,x8.x8.w7-v8-v6,t6+s4+q5+m1'r6,n4)m3(o6+m4)q8-I=�SH�SJ�RJ�QJ�QI�QJ�QK�RL�TM�TK�[N�cQo_HYU:MV7O_;j~YbxQZpIUjCRg@Pa=IY5DR17D&4>#2:#6;'<>0@B5@@6<>358-39-4:.7:/9=/;?.=B,=F)S_;arFo�Rt�Ut�St�Ss�Ss�Uu�Z~�e~�ep�Yb�K^�G^�H^�G`�Ib�Kd�Mf�Ne�Mc�K`�H^�G_�LTvDKm;i`Qi`QjaRjaRjaRkbSkbSkbSjaRjaRjaRjaRjaRjaRjaRjaRkbSkbSkbSkbSkbSkbSkbSkbSlcTlcTlcTlcTlcTlcTlcTnbTrbSqaRrbUrdWrfZogZmeXjdVgcWliZmjYjgThcOc^H[U=RL4PJ0I?&Q?)kP=XI�ND�E=�EA�WV�TT�QQ�PO�NM�MM�MK�KJ�TT�HI�=>�=:�B@�EA�B;�>4�D9�F:�F=�H?�FB�DD�AE�AE�BF�CD�CD�DE�DE�EF�FD�FD�EA�D@�B?�A>�A=�A=�A=�C?�E?�C<�>6�;1�90�:/�<0�=1�@4~@5~>4�=4�:3�91�92�90�;.�<-�<-�;,�;-�:,�:,�:,9-9-9/9/~:/~:/~:/~:/}90}90}90}90}90}90|90|90|90z:0z:0z:0y9/y9/x:/w9.w8/w8/t8.s7-r6,r6,p6+p6+l2'q7,m4)l3(o6+l3(p7,~H>�SJ�SL�QL�QM�QL�PM�QN�SO�OG�SH�[K{ePsiPilMfqQgxT^tMXnGPf@Ma<M^<L[:HU7CP4<F-8@)6;'7:)<=/?@2>>2;=04:04<15;16<0:</<?.>A,>D*Q[9^mDn�Ss�Ur�Ss�Ss�Ss�Vx�^|�ex�ak�T`�I]�F]�F\�E`�Ia�Jd�Me�Ne�Nb�K`�I^�I]LRtBIk9i`Qi`QjaRjaRjaRkbSkbSkbSjaRjaRjaRjaRjaRjaRjaRjaRkbSkbSkbSkbSkbSkbSkbSkbSlcTlcTlcTlcTlcTlcTlcTnbTqcVo_Rm\Rm_Tqd[og\ldYhbVfbWqma{xi~{j�zj{vcqjWe`JTT<FF.C>(MB.S@/U8*]7*m>4n70u91~;5�@:�IB�PJ�XP�ZT�^Y�RO�GE�B?�DB�ED�D@�@:�A;�C<�E>�G@�GC�FF�EF�DF�CD�CD�CD�DE�DE�EE�EC�FD�EC�DB�D?�C>�C>�C>�C=�C>�E@�F@�B<�>5�:1�8-�9.�;/�@2?3~>2�>2�:1�91�92�90�;.�<-�:-�:-�;-�:,�:.�:.9-9-~:/~:/~:/~:/~:/~:/}90}90}90}90|90|90|90{8/{;1{;1z:0y;0y;0x:/x:/x:/t8.t8.s7-s7-r6,q5+p6+o5*j1&p7,m4)k2'l6*i3'm7+}G=�PI�QJ�QK�QL�RM�TO�UP�VP�WO�[P~^OtbNoiQorUlwYfwUQeBK_:EY6DU3EV6GV9GT8ER8@J2<D/9>*7;*:<.<>0;=/9;.6<25=26<26<0:</<>0=@-=C)MW5Zi@h{Mn�Pp�Qs�Ru�Ut�Wz�`w�`n�Wc�L\�E\�E\�E[�D_�Ha�Jc�Ld�Mc�La�J_�H]�H[}JPr@Gh9i`Qi`QjaRjaRjaRkbSkbSkbSjaRjaRjaRjaRjaRjaRjaRjaRkbSkbSkbSkbSkbSkbSkbSkbSlcTlcTlcTlcTlcTlcTlcTnbTrdWpbUm_Tl_VkaWlcZle[jf]jf]yuj��x��������~��r}zg`cNOT>DG2GF2HC0F=,L<,VC4P9+R6*V4*Y4+\6+a9/e=3n>4�KB�RL�UQ�OL�FF�AB�DC�GG�@>�A?�B>�E@�EC�FD�ED�ED�DD�CD�CD�DD�DD�ED�FC�FC�FB�FB�E?�E>�D=�D=�D=�E>�D<�F?�F>�A8�;1�8,�8-�;.�@0@1~?0�>0�:1�:/�:0�:.�:-�;,�:-�:-�:,�:,�9-9-9-9-~:/~:/~:/~:/~:/~:/}90|90}90{8/{8/{8/{8/y9/{;1z<1y;0y;0x:/x:/x:/v:/t8.s7-s7-r6,q5+o5*o5*m4)j1&o6+l3(h2&k5)h2&l6*|F<�OG�OJ�PK�RM�TO�VP�WP�ZQ�]R�aUy_Pj[Hd_IdhO\fKN]@EU8AQ4>M0=L/?M3DQ7FR:GS;BK6>G2:A/9=,9=.9=.8<-7;-7=36=56;47=3:<1;=/<?,<A*JS4Ve>dwIl�Lp�Qu�Tw�Wx�Z{�ar�[e�N\�EZ�C\�E\�EZ�C_�H`�Ia�Jb�Ka�J`�I^�G]�HZ|INp>Ef7haQhaQibRibRibRjcSjcSjcSibRibRibRibRibRibRibRibRkbSkbSkbSkbSkbSkbSkbSkbSlcTlcTlcTlcTlcTlcTlcTlcTrfZth\sf]ndZjaXle]snh{xq�~w���������������������z{kdgTOR?GJ7EH5BE2BE2EH5KL<JH9GD5D>0B:-A7+@6*G5)S5*qB8�PH�PK�HI�GI�EI�BE�@B�@B�BA�DC�EA�FB�EB�DA�DD�DF�DF�DF�DD�ED�ED�ED�FB�FA�F>�E=�E=�F=�E=�F>�A:�C;�E=�B9�>3�:.�;.�=0�?0�?/�>.�>.�;/�:-�;.�;.�:-�;-�;-�:,�:,�9+9-9-9/~:/~:/~:/}:1}:1}:1}:1|91z:1|91y90y90x8/x8/w8/y:1y:1x90v:0v:0u9/u9/t:/r7/q6.q6.p5-o4,o4,n3+m4+j1(m7-j4*h2(j4*f2'j6+}D;�NG�NH�QJ�TL�UO�WP�YR�\R{YMw]PkZJ]UBYXDY^HOYA?K3:H/7E.5A+5A+8D.?H3CL7EN9BK8@I6<E4:A19@07>.5<,4:,5<45<56;56;49;0:</;>-;@)GP1Sb;buGk�Kq�Rw�Vy�Yy�[x�`n�W`�IZ}C\E^�G^�G]�F`�Ia�Jb�Kb�Kb�K`�I_�H^�IY{INo@Ef9haQhaQibRibRibRjcSjcSjcSibRibRibRibRibRibRibRibRkbSkbSkbSkbSkbSkbSkbSkbSlcTlcTlcTlcTlcTlcTlcTlcTkaUoe[pf\lcZkd\rmg��|����������������ľ��������������rgdUPQ?FI8>E3;D1:F28E38E38C3:B3<B6@C8CD<HE<>4*P:/e?6�EA�PO�X[�RW�CI�FJ�EF�FF�FE�FC�DB�E@�CA�DD�DF�DF�DF�DC�DC�DC�DC�EA�FA�F@�F=�F=�G=�G=�E=�?8�@9�C:�C9�A7�=0�=/�=.�>/�?/�>.�>.�<-�;-�;.�;.�;-�:,�:,�:,�9+:+9-~8,~:/~:/~:/~:/}:1}:1}:1}:1z:1z:1z:1y90x8/v7.v7.t8.w8/u9/u9/t:/t8.s9.s9.r8-q6.q6.p5-o4,o4,m4+l3*j4*h2(m7-i3)f2'i5*e1&i5*{B9�MG�MH�PJ�TL�VO�XN�ZP|\Qs\Nl\M`WFVSBQRBJQ?@I64@,3<+2;*09(09(2;*5>-9B1<E4?H7?H7>G6;F5:C25@/3>-1<,3:33954954928919;.;>-;@*CL/O^7`sEk�Mr�Sy�Yy�Yw�Yq�Yf�OZ}CX{A\E^�G^�G^�G`�I`�I`�I`�I`�I_�H^�G^�KXzHLm@Cd7haQhaQibRibRibRjcSjcSjcSibRibRibRibRibRibRibRibRkbSkbSkbSkbSkbSkbSkbSkbSlcTlcTlcTlcTlcTlcTlcTlbVj`VjaXkdZlh_upl���������������������������������μ������zym]_YIKL:AF2<E0?K7>I8>F7;C6;>5:;3983872==3C<2N71a84�HH�]_�`d�WZ�QS�NO�MK�KJ�HG�FD�DA�BB�CF�CG�DF�CE�CE�CE�BB�CB�DC�D@�D?�F?�E>�E>�G=�E=�@:�@:�B:�D;�C:�@4�;/�9+�=/�>.�>-�>-�<,�;,�<-�<-�:,�:,�:.�9-9-9-~8.}9.~:/~:/}:1}:1}:1}:1}:2}:2{;2y:1y:1x90w8/t8.s7-r8-t8.s9.r8-q8-r8-p7,p7,p7,o6-o6-o6-n5,m4+l3*l3*i3)h2(k7,h4)f2'h4)b0%f4)zA8�MG�NI�PJ�UL�XN�YOxZOr\Nk^N_XHRPAKN=EI:9B13;,08)17+17-06,06,06*17+2:+4<-9D4;F5=H7<I7;F56C13@,1>-.800621622717829;0:<.:?)?H+LZ6]pCj�Ls�Vy�[w�Ys�Vg�P^�IVyAX{C[~F[~F[~F]�H_�J_�J_�J_�J_�J^�I]�H]�JUvIJk@Ab7haQhaQibRibRibRjcSjcSjcSibRibRibRibRibRibRibRibRkbSkbSkbSkbSkbSkbSkbSkbSlcTlcTlcTlcTlcTlcTlcTlbVqh_ng_mhbtqj������������������������������������������������}ub^\GKM7CH2AI2AH6@G7BD9BB:B=9C97?:6:=6>?7C82J.+e77�QR�hj�nm�\\�ZW�VS�QN�ML�HH�CD�BE�DG�DG�DF�CE�CE�BD�BB�BB�DC�CB�C?�D>�E>�E>�G=�E=�C=�A9�B:�D;�E:�A6�:-�6'�</�=.�=-�>-�<,�<,�<-�<-�:,�:,�:.9-9-~8,}9.}9.~:/~:/}:1}:1}:1}:1}:2{;2z;2w;1x90v:0u9/s9.r8-r8-r8-q8-p7,n8,p7,m7+o6+o6+o6-o6-n5,m4+m4+j4*i3)h4)f2'k7,h4)c1&f4)b0%e3(xB8�NH�OI�RM�VN�XOzZOq[Mj]MZTDIJ:@D5>D69A219,/7*6<247058157247025.06,08-2:-6A3:E5=J9>K9<I77F33B-1>-,6..400511606718:/:<.:?+<E*IW4[nAi�Mr�Vx�\u�Xp�U`�IX{CSv>WzB[~FZ}EY|D\G_�J_�J_�J^�I^�I]�H]�H]LStIHhA@^8icSicSicSicSicSicSicSicSicSicSicSicSicSicSicSjcSkbSkbSlcTlcTlcTmdUmdUmdUmdUmdUmdUmdUmdUmdUmdUldWjc[gd]vsn����������������������������������������������ɷƵ������ibbFEH-EI0CG0FE3GC7F<3C60G53I;:>=9>?:B:7I75cGF�jjœ�譩ҋ��tn�]X�SP�ON�KM�FK�FK�DH�IK�EG�<?�>@�GI�DG�:=�@@�@@�A@�B@�C>�C=�A;�A9�C>�A9�@9�A9�B8�@5�:.�8*�=0�>/�>.�>-�=,�=,�<,�<,:+9-9-~8,~8.}9.|8-|8-|90|90|90|90z:1z:1z:1z:1y=5w<4w;3u:2t91q8/p7.p7.o6-m7-m7-l8-m7-l8-m7-m7-i2+m6/p92p92l5.g2*g2*h3+e0(i7.d2)^.$`0&_/%b2(s>6�OJ�QL�QL�RJ}XOx]RhXITN>DE5@D5:B37?24</3;04:049279478366457246116//6./7,.9+2=-6C2:G6:I68G44C.1?.*4+,2.-2./4.45/79.:</:?+6>&ES2YkCj�Ru�]y�_r�Yk�R[~DXyDTu@Tu@XyDZ{F[|GZ{F^Jb�Nb�N^J\}H_�K`�L_NTsJFd@<W6icSicSicSicSicSicSicSicSicSicSicSicSicSicSicSicSkbSkbSlcTlcTlcTmdUmdUmdUmdUmdUmdUmdUmdUmdUmdUldYgd]onj����������������������������������������������������Ͳ��������cgjKLQ3GJ/EC.GA1H>4I:3L95K<9?:7CB@NIF]RPyjg���β��ſ���벩͂|�c^�VV�RS�HM�AD�DE�EE�HH�JK�EF�<>�<>�AC�??�??�A@�A@�B>�B=�A<�A:�A<�@;�A:�B:�C;�A6�;1�8-�=0�>/�>.�>-�=,�=,�<,�<-9-9-9-~8,}9.}9.|8-|8-|90|90|90|90{;2{;2{;2z;2w<4u<3u:2s:1r90n8.p7.m7-m7-l8-l8-l8-l8-j8-l8-l8-k6.n70p92n91l7/i4,g2*e3*c1(d4*_/%^.$b2(^.$`0&p>7�KF�RN�XR~XOrVKdRFRI:A?0<@18@15@23>04<14<15:37:379677577557246116/07//7,.9+1<.5B19F59H58G44E24B1.8//6/.3--2+23+46+8:-9=,7?(DQ3YkEj�Uv�`y�bp�Zg�QY|DWxCTtBTu@VvDYzEYyGYzE[{I_�K`�N\}H[{I^J^~L^{MSnKF_A9R5icSicSicSicSicSicSicSicSicSicSicSicSicSicSicSicSkbSkbSlcTlcTlcTmdUmdUmdUmdUmdUmdUmdUneVneVneVlfZed_y{x�������������������������������������������������������ش�Š�����l`gEQX9EH-DC.JD4LD9KA8J?;C;9SJKia_�wv�����������������������ec�BE�DI�RV�UT�MK�DA�CA�FE�EF�DD�CD�=?�>@�@?�@?�B@�B?�B?�A=�@;�@:�C;�E<�D<�B7�<2�9.�<0�=0�>/�>.=-=-�=-�=-9-9/~:/}9.}9.}9.{8/{8/}:1}:1{;2{;2{;2{;2z;4x<4t;2q;1r90o9/n8.l8-l6,k7,l8-j8-j8-j8-j8-i9-j8-j8-n91m82m82m82m82i70f4-c1*e3,a0)],%_0(c4,\-%_0(sD<}PK�VP~YQpSK^J?OC7@=.46(3:*1<,1<.2=/5=26<27:37:379679668368357227018008-.9+0;-2?.6C27E48G49H59F54>33:205.,2(/0(13(57*7;*6>'ER6[lJm�Zy�fy�fl�Z`�NWwEWuCUrBUsAWtDXvDYvFYwEZwG^|J_|L]{I]zJ_}K^{KZwKPgJAW@3I2icSicSicSicSicSicSicSicSicSicSicSicSicSicSicSicSjcSkbSlcTlcTlcTmdUmdUmdUmdUmdUmdUneVneVneVofWmg[jkf�������������������������������������������������������������ڴ��������efmLNR7FH0JI7KI<HD9D@7OGDj`_���������������������������������収�cf�@?�PK�TM�PH�GA�GB�MJ�KH�@?�>>�??�?>�A?�A?�C@�B?�B=�>9�@:�C=�E?�E>�A9�=5�;2�<1�=0�>/�>.=/=-�=-�</9/9/~:/}9.}9.}9.{8/{8/~;2~;2|<3|<3{;2{;2z;4x<4r90o9/o9/m9.l8-k7,j6+h6+i7,i7,i7,h8,h8,h8,h8,h8.m;4l71j5/i70j81j81f4-a0)e4-a2*].&a2*b3+Y*"a2*yNG�\VvWRjOHXD;I<3@:.:;-8<.08)/:*3;.4</6<26<27:169279479468349238139/19.19..9+/:,1<,2?.5B17E4;H6<I89C87?428.-3'./'/1&24'48'4<'ER8_pPt�d}�ny�if�XU|GSsBTqASp@Sp@TqAUrBVsCVsCXuE[xH]zJ]zJ^{K_|L\yIWrIK_F<M;.?-gdSgdSgdSgdSgdSgdSgdSgdSgdSgdSgdSgdSgdSgdSgdSicSjcSkbSlcTlcTlcTmdUmdUmdUmdUmdUneVneVofWofWofWng]qqo����������������������������������������������������������������ѯ������}�bY]BIM6GJ9FJ;CF;AB:c^X�}z������������������������������������騤�id�MB�PD�YN�\R�QH�D=�A<�DA�A>�@>�@?�A@�C?�C?�C?�C?�?;�A<�E@�E@�C>�@9�=7�<4�<1�<2�=1�=0=1=/=/=/~:/~:/~:/}9.|90|90{8/{8/|<3|<3|<3{;2z;4y:3y:3w;3n70m80m80l7/k6.i7.h6-h6-i7.h8.h8.g8.g8.g8.g8.h8.k92h6/f4-g5.i70h70e4-b1*c2+c4,_0(]1(]1(W+"c7.{ULtXTaNHN?8A7.=6,;9-9;.9<139-3;.5;/6<06<07:/68-47.69049238139/39/2:/19.19,08+.9+/:,1<.3>.6C2:E5<G7=E8:B55;/06(02'02%13%26%2:%GS;dtWy�k~�rs�g]�RJp?Oo>Qn>Qn>Qn>Qn>Ro?Sp@TqAWtD[xH]zJ]zJ_|L`}MZwGSmFCU?6D7(6)gdSgdSgdSgdSgdSgdSgdSgdSgdSgdSgdSgdSgdSgdSgdSicSjcSkbSlcTlcTlcTmdUmdUmdUmdUmdUneVneVofWpgXpgXoh^lnmz���������������������������������������������������������������׹�Ħ�����rggONP;GK:FL>HPEKQG{{s���ž����������������������������������������ؓ��eS�K;�TF�WI�F;�@8�KE�C>�C?�C@�C@�C>�C>�D>�B=�B<�C?�DA�D?�A=�=8�;6�<6�;3�<4�=3�=2=1=1=1=/~:/~:/~:/}9.|90|90{8/{8/|<3|<3{;2z:1y:3x92w81u91n70m80l7/j8/i7.i7.h6-g7-h8.h8.g8.g8.g8.g8.g8.g8.h70h6/g5.g5.h70h70g6/f5.a2*e6.^2)\0'`4+a5,i=4uSJXG@E>6<5/:6-;8199/57,36+7:/5;/7:/7:/69.58-57,36+28,19,28.19,19.19,19,19,08+08+.9+/:,0;+3>.6A18C3<D5:C28>05;-57*35(13%04%18&HT>gw\w�mv�lh�_RwKBh9Kk<Nk;Pm=Pm=Ol<Nk;Pm=Qn>WtDZwG]zJ^{K`}M_|LVsCNg@<J90;3%/'gdSgdSgdSgdSgdSgdSgdSgdSgdSgdSgdSgdSgdSgdSgdSicSjcSkbSlcTlcTlcTmdUmdUmdUmdUmdUneVofWofWpgXqhYoh^hikmtz����������������������������������������������������������������Ư�����}vn[ZWFPQCSVK\c[fme���������������������������������������������������񪔼o[�VD�RC�PD�LA�JA�G@�E@�E@�E@�E>�D=�C<�B<�C?�E@�EA�C=�=9�;5�;5�<6�<5�<6�<5�=4<3=1=1=1~:/~:/~:/}9.|90|90{80{80{;2{;2y:3x92w81v70v70t80n70k90j8/j8/j8/h8.h8.h8.g7-f7-f7-f7-d8-d8-d8-f7-g6/h70i81i81h70i81j;3l=5g80l=5c7.a5,oC:xLCtI@nMDD:167/45/891:;556.14+25,58/58/57,46+46+46+46)48*08).9)08+08)08+08)08)08)19,08+08+08+08+2:-3;.4<-9B1:C0;B2:A1:<.68*35'/3$29'IU?eu[o�gh�bYyTInE?d8Hg;Li;Ol>Nk=Mj<Li;Mj<Ol>UrDYvH[xJ]zL^{M\yKQn@G_;6B4+4/#)%gdSgdSgdSgdSgdSgdSgdSgdSgdSgdSgdSgdSgdSgdSgdSicSjcSjcSkcVlbVlbVmcWmdUmdUmdUleUmfVngWogZoi]oh^mjekormtz����������������������������������������������������������������η������|ubb_NXZL^dXmwn|�}�������������������������������������������������������̻�p�RE�SF�TI�C:�IA�H@�F@�F>�F>�E=�C;�C;�G>�G>�G>�C;�>5�;3�;4�>6�=5�=6�=5�=4�<3�<1�;1�;1~:/~:/~:1}90|90|90{80{80z:1z:1x92w81v70v70u6/q6.m80k90k90j8/i9/i9/i9/i9/g7-f7-g7-f7-f7-f7-f7-f7-f5.j81m;4k:3j92j:0m>4oC8mA6oD;e=3d>3zVJ�dZyWMbLA>:13814927<569214-25,9<336-25,24)03(13(25*46+47,/7*-8*/7*/7*/7*/7*/7*/7*19.08-08-/7,/7,/7,08-08+7?09B1<E4=D4;A38<.26'-4$2;*JVBcr[i{a^uXRmLGeAAa:Hd;Kh<Nk?Nk?Kh<Jg9Li=Nk=TqEXuIZwK[xL]zNZvMNjAC[;2>4*00!''heVheVheVheVheVheVheVheVheVheVheVheVheVheVheVheVjdVjdVkeYldYlcZmeZmeXmfVg`NkfSnkXol]he\feasqr�������������������������������������������������������������������������Զ�����|qtY_dMdkYr}l������������������������������������������������������������������ا��`X�E>�NG�MC�F>�D9�F=�I@�KA�H@�G<�G8�H8�J8�H8�E5�B4�B5�C5�B7�B6�A5�>3�<2�:1�91�91�:2~:1|91|91{80z7/w7.w7.w7.w7.w8/w8/v7.u6-q5+o4,l7/i81i81h70h70g6/g6/g6/f5.g6/i70i81i81g6/f5.e3,h3-j5/m80k90j:0i;.j>1kA3gB2jI:dH:v_O~k\�xj�oRJ=79.4:04:039/39/39/28.28.17-17-36-06,25,06,14+/5+/4-.5-/4-/4-/4-/4-/4-/4-05.05./4-.3,.3,/4-05./6.1;23=26@59C89D67B45@03>-4?.DQ=XfO[kQRbHEX<BU9BW6Jd?Ke>Ke>Ke>Je<Je:Mh?Oj?UpGYtK\vO]wP]wRWqNHaA;N8&1+&+.$),heVheVheVheVheVheVheVheVheVheVheVheVheVheVheVheVheVheVkdZkdZlc\md[meZmfVidQjhSmjWjk[gg_lll~��������������������������������������������������������������������������ϰ�����vkqUZbJbkVu�o�����������������������������������������������������������������������~u�KA�MB�J?�L@�K>�E9�=4�?6�E9�F7�J7�L:�I9�F6�C4�C6�E7�C7�B8�A7�>5�<4�:3�91�93:3}:2{;2z:1y90x8/v7.v7.v7.v7.u9/u9/t8.r6,p6+m4+l7/i81j81h70i70h70g6/g6/e3,f4-g5.h6/j81j81k92k92k60l71k90k;1l<0j>1j@0iD2gH6lQ>gRAvgT�ue��s��rKL<69.39/39/39/28.28.28.28.17-17-17-06,06,06,/5+/5+/4./4./4./4./4./4./4./4.05//4./4..3-.3-/4./4./6/.80/:22>44@66B66B66B45B16C1CP>P]IR`IIW@AO6BP7FV;Jb@Ke@LfAKe@Ic<Hc:Id;Je<SnEXrK\vQ]wT\uUTmOC\?6I5&1-',0%*.heVheVheVheVheVheVheVheVheVheVheVheVheVheVheVheVheVheVkdZkdZlc\md[meZmfVmhUljUmjWjk[kkcwww�������������������������������������������������������������������������ۿ�ʫ�����yuy`kpZt{i������������������������������������������������������������������������������؞��M?�RD�L=�@1�G;�YM�UJ�@4�D7�H:�K@�I=�C8�?5�@7�D=�@9�B:�@:>8~>5}=4<4}=4z;4x<4x<4w;3u:2t91t91t91r90r90r90r90o9/n8.l6,k5+m80j81l71j81k60i70i70h6/g5.g5.f5.g6/h70i81k:3l;4l;4j;3i:0h<1k?2jC4iD2fE2gJ8lVAjYGujV�m��{�mDG658-39/28.28.17-17-17-17-17-17-17-06,06,06,/5+/5+/4./4./4./4./4./4./4./4./4./4..3--2,-2,.3-/4..5.+5-+6.-9//;12>25A56B47D38E3?L:ER>CQ:;I28F->L3DT9J_@Jb@LdBKc?Ia=G`9F_8G`9RkDXpL]uS^vVZqTPgK=T8.A.&1-',0%*.heVheVheVheVheVheVheVheVheVheVheVheVheVheVheVheVheVheVkdZkdZlc\md[meZmfVniVljUlkWlm]pqi����������������������������������������������������������������������������ؼ�ǫ��������}�������������ſ�������������������������������������������������������������������������²��p�P@�O?�XJ�M?�E9�G<�A6�E;�IA�F>�@9�;6�=8�B?�?;�@<�@<}@;z?9y@9y@9y@9v=4v=4v=4u<3s=3r<2r<2r<2o;0o;0o;0n:/k9.k9.j8-i7.m82n72n72l71l71k60i70i70l:3j92h70f7/f7/g80h91g;2j?6f>4e=1f>2hC3iE5fG3cG2cJ6hV@i\IskV��o��zor_9=,28,28.28.17-17-06,06,06,17-17-17-06,06,06,/5+/5+.3-.3-.3-.3-.3-.3-.3-.3-.3-.3--2,-2,-2,-2,.3--4-*4,)4,*6,+7-.:01=14@46B46C2:G5<I78E12?+2@)8F/>N4DX<E]=K`AJb@K`?G_;H^:F^:ShGXpN`uV^uX[oTLcI9M4):(%.+%*.$)-heVheVheVheVheVheVheVheVheVheVheVheVheVheVheVheVheVheVkdZkdZlc\md[meZmfVlgTljUnmYop`tum����������������������������������������������������������������������������ؿ�ʱ½����������������������������������������������������������������������������������������������������Ŝ��bP�J:�L<�QA�L>�@7�C;�F@�D?�>;�:8�::�>=�=;�?<�@=}@=xA<tB;rC;rC;q?6s>6s>6r=5r=5r=5p>5p>5n>4m=3l<2k;1j;1i:0i:0j:0n72p62p62n72m61l71i70i70l;4k:3h91e90e90e90f;2d<2fB6dB6cC4dD5dG5dI6bI3_I2^L6eV?jbMrmW��o��r\aM3:(28,28.28.17-17-06,06,06,17-17-17-06,06,06,/5+/5+.3-.3-.3-.3-.3-.3-.3-.3-.3--2,,1+,1+,1+,1+-2,-4-,6.+5-*4,*4+,6-.8-0:/2=/2=-5@/7B15A-2>*1=)5A-8F/=O7@T9FX>H\@J]?I^=K^>K`?TgI[oScvZauZZlTJ]G6G4'5&$-*$),"'*heVheVheVheVheVheVheVheVheVheVheVheVheVheVheVheVheVheVkdZkdZlc\md[meZlfVjgTkjUlnYorasvm�������������������������������������������������������������������������������θ�κ�ƶ�ø������������������������������������������������������������������������������������������������ͧ��kX�[G�WE�L;�D:�D<�E>�E?�A>�=:�:9�:;�=<�?=�?=~A<wB<sD<oD;oD;p?8q?6q?8q?6q?8q?6p?8o?5o@8n?5m>6k<2i=4h<1h<3l;4o83r73p62p62n72l71j81i81h70g80e90e:1d<2e?4f@5dB6_C5aG8cL:dM;cM8`K6^L4]M4^R:bX?mhRss[��nv{eFO:4=*39-39/28.28.17-17-17-17-17-17-17-06,06,06,/5+/5+.3-.3-.3-.3-.3-.3-.3-.3--2,,1+,1++0*+0*,1+,1+,3,/6/,6.+5-*4,*4++5,-7,.8--8*0;+4?/5@/4?.3?+4?.3@,7F19K3@O8CU;GW<H[?M]BM`DUeJ\nTdtZ`rZXgRGXE4B1$2%$-*$),"'*heVheVheVheVheVheVheVheVheVheVheVheVheVheVheVheVjdVjdVkdZkdZlc\md[lfZlfVliVlkVkmXlo^lrhz�~����������������������������������������������������������������������������о�������������������������������������������������������������������������������������������������������������λ�wb�Q:�\H�N>�J=�I>�I@�G@�D>�=:�:7�=9�>:�?9�A:yB;tD:pF:pE<p?8q?8q>:q?8q>:q?8p?:p?8qB<pA9n?9l=5j=7j>5j=7n=6o83r73q73p62n72l71j81i81d8/d90d<2d>3d@4cA5cA5_C5ZE4_N<gVBhWCcS<^O8[O5\R7]V<]Y>nlUtv^|�kcmU2>(6B.3;.39/39/39/28.28.28.28.17-17-17-06,06,06,/5+/5+-2,-2,-2,-2,-2,-2,-2,-2,,1+,1++0*+0*+0*+0*,1++2+-4-+5-*4,*4,+5,+5,,6--7,,6+/:,2=/6A17B27B15@04?.2?-4C.:G3=L5AO8DT:JX?L\BTbI\kTcp\^mZUbQDRC2>0#/%'0-&,,$**heVheVheVheVheVheVheVheVheVheVheVheVheVheVheVheVjdVjdVkdZkdZlc\md[lfZlfVolYmlWjlWgkZgmcr{x������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������׭��oY�WD�Q@�O>�OA�OB�K@�C<�<5�>7�?6�@9�A7{B7uD6qE8qE:p?8q>:s>:q>:q>:q>:r?;q@;sB=qB<p?:m>8l=7k>8m>8o>9o83q73o83m82m82j92h91f:1f;2d>3d@4bB5`C5]A3\@2WB1TG4\T?f^Gj_IbX?ZS9ZS7\W:[W<XW;kmUsw^u}fUaI&28D03;.4:04:039/39/39/28.28.17-17-17-06,06,06,/5+/5+-2,-2,-2,-2,-2,-2,-2,-2,,1++0*+0**/)*/)+0*+0*,1++2+)3+*4,+5-,6-,6--7.-7.-7./9.2<16A39D69D47B46A10;+2?-6C19F2<I5AO8FT=JX?R`I[hTan\]jYQ]OBN@0<0",#+1/(..&,,ifWheVheVheVheVheVheVheVifWifWifWifWifWifWifWifWkeWkeWle[le[md]ne\mg[mgWqn[kmWknYkr`kshpyv�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Ѻ�i�bK�O9�T?�ZF�RA�K;�M?�<0�=0�>2=/x=/t?/sB3uE7r=7s>:t=:t?;u@<u@<t?;q>:s@<rA<r?;q@;p?:o@:o>9o>9k92m82l:3l;4l;4h<3g<3d>3c?3^>1dG9cG9T=-N9(M8'@1XR<PN7KI0OK2]Y>ieJeaDVU7XX<^aDpt[z�fdlU>J2-9#2>*4</5;15;14:04:039/39/39/39/39/39/28.28.17-17-06,16016005/05/05//4./4./4.,1+,1+,1+,1+,1+,1+,1++0*.5..5.-4--4--4--4-.5./6.+2*-4,1805=29A6=E8@H=?J<7B26A03>-1=)3?+9E/BN8IU?O[GWcO]hWZeULWI<F;/90)3+)/+(.,'-+heVheVheVheVheVheVheVheVifWifWifWifWifWifWifWifWkeWkeWle[le[md]ne\mg[khWonZjlVknYlsajtiq|x���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������౗�u\�\D�ZB�YC�VC�SA�G5�F6�E4�D3|C2wB0s@/o>/u@8t?9u>;u@:t?;p>7p=9tB;q>:p?8p?:o>7o>9m>6n=8m>6k<4l=5m>6k?6j?6gA6eA5bB5dG9[A2^G7_J9O>,F7$G8%?7"LL4HL3DG,CF+MM1[[?baC`aBZZ>dgJsw^sy_X`I:D,/;%7C/6>17=36<26<26<25;15;15;15;15;15;14:04:04:039/39/27127127116016016005/05/.3-.3--2,-2,,1+,1++0*+0**1**1*)0))0)*1**1*+2+,3,.5..5-.5-07/4;3:B7?F>BJ?;F8:E57B14?.3?+6B.<H2@L6LXDS_KYdTWbRLVK=G<1;2+5-+1-*0,)/-heVheVheVheVheVheVheVheVifWifWifWifWifWifWifWifWkeWkeWmd[md[md]ne\mg[khWnmYimVjoYktaiuiq}y���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������㿧��j�YB�R<�[F�]I�S?F2u>)r>)tA,tD0vE6q?4n<3q<6tB9tB;o?5q@9xH>n=6m>4m>6m>4l=5j>3l=5j>5g?5gA6hB7gC7eC7cC6aD6^D5bK;UB1ZI7`S@RG3D<'E=(FA+BF-BH.AE*<@%?B%LO2_`AijKaaEnqTvzagmSJO95=&5=(=F39?38>48>48>47=37=37=37=38>48>48>47=37=37=36<26<25:45:449349338238238238205/05//4..3--2,,1++0*+0*).*).*).*).*).**/++0,,1-162/4.,1+,1+05/6;4=B<AH@@K=>K:<I78E34A-2?+3A*5C,DQ=KXDQ^MQ^MHTH<H<2>4.8/-4--4-,2.gdUgdUheVheVheVifWifWifWifWifWifWifWifWifWifWifWkeWkeWmd[md[md]mf\mg[jiWkmXimVjoYjs`hthn}x����������������������������������������������������������ڻ�ּ�������������������������������������������������������������������������������������������������������������������������������������������������������ҽ��zyS>tJ4uH3vI4zM8~O;yL7nA.e7'{M@tE;qB8sD:oC8g;0d8-g=1i?3i?3i?3g?3g?3f>2f>2e?2cA5bB5`C5`D6_C5[D4ZE4WD3XI6OB/\T?oiSc^HMK4IG0IK3>D*?H-@F*<B&<A#EJ,XY:deFmmQxx\tv^[_FAD/6;%:?+>B19?39?59?58>48>48>47=37=39?59?58>48>48>48>48>48>47<67<67<66;56;56;55:45:438238227105//4.-2,,1+,1++0,+0,+0,+0,+0,,1--2.-2.051.3/+0,+0*-2.3828=9;B:AL>@M;@M;=J68E14A-1?(1?(=J6BO;IVDJWFDPB;G;2>4.:0,6..5.-4-gdUgdUgdUheVheVifWifWifWifWifWifWifWifWifWifWifWkeWldWmd[md[md]mf\mg[jiWlnYinWiqZgs_drejyt�������������������������������������������������������ܿ�չ�й�Ѿ������������������������������������������������������������������������������������������������������������������������������������������������������������ϴ�����uawVClI6mH6rM=uP@mF7jC4gB2kF6nI9nJ:oK;pL<eA1cB1cB1cB1cB1cB1bC1`C3]F6\G6]H7ZG6ZG6WH5TG4RG3PH3OI3fdM~~frrZVX@JL4GM3<E*<F+?H+AG+AF(CH*MN/TU6xw[{z^nnVUU=CB.?A,?@.;>-;>39?59?58>48>47=37=37=38>48>48>48>48>48>48>48>49>89>89>89>88=78=77<67<66;56;55:438227105//4./4.-2.-2.,1-,1-,1-,1--2.-2.-10,0/,0/-2..211623764;4;G9=L9@O<@O:<K67F/4C,2A*6E.:I4@O<BP??M>8F71?2-9-,6--4,,3+fcTgdUgdUheVheVifWjgXjgXifWifWifWifWifWifWifWifWldWldWmd[md[md]mf\mg[jiWkmXinWiqZgs_bpcgxr�������������������������������������������������������ڽ�ѵ�˴�˺����������������������������������������������������������������������������������������������������������������������������������������������������������������������ҿԺ������u�rd|]K}^LtUCbE3X;)Y<*[>,X=*`E2`E2`E2`G3`G3`G3`G3^I4\K7\M:\M:ZM:XM9UM8SM7QL6NL5QQ9jlT|�gmqXSY?FL2>G,<F+<F+?H+DJ.EJ,DG*HI*LM.yx\tsWfdMTR;LI6KJ6FE3<=-<?4:@69?59?58>48>48>48>47=37=38>48>48>49?59?59?5;@::?9:?9:?99>89>89>89>89>88=77<66;55:4493382382/40.3/-2.,1-+0,+0,+0,+0,+/.,0/-10.21/32/32/32.5.4@27F3=L7@O:?N7<K49H18G05D-8G0<K6>M:<J97E61?2-9-+5,-4,,3+fcTfcTgdUheVifWifWjgXjgXifWifWifWifWifWifWifWifWldWldWmd[md[md]mf\mg[jiWjlWhmVhrZfs_cqdhys�������������������������������������������������������չ�̳�İ�Ĵ�ɿ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������ʴ��xt^GeO8cM6\H0^J2\J2\J2]K3]K3^L4^L4\M6YN8XP;XP;VP:UO9SN8PN7NN6MO7PT;`fLfoTU^CEO4AK0<F+?I.?I.CL/HN2HM/GJ-OP1YX:qmRkgLa\F[V@YTATQ>MJ9BC3>A6;A7;A7;A7:@6:@6:@69?58>48>48>49?59?5:@6:@6:@6;@:;@:;@::?9:?99>89>89>8:?9:?9:?99>88=78=78=77<6495384162/40-2.,1-,0/+/.,0/-10-10.21.23.23-12,2.+9*/@-6H2<N8=O7<N6:L2:L25G/7I1:L6<M:;L:6G70@3-;.,6--4,,3+cdTcdRdeUgfThfWigXigXjhYhfWifWifWifWifWifWifWkeWkeWkeWmeZle[md]mf\kg[jiWikVhmWis[gt`dqgk|v�������������������������������������������������������Ѹ�DZž�ƾ��ü�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Þ�u`P7RB)XH/XH.[M3[M3ZN4ZN4[O5[O5\P6[Q8UO7TO9TO9QO8PN7NN6KM5IM4JN5LR8S\APY>@I,<E(AL.?J,DM0EN1JP4MR4KN1LL0YY=kjNhdIb^E^ZA_ZD`[GZUAQO:KJ8AB4@B5@B5>A6>A6>A6=@7=@79?59?59?5:@6:@6:B7:B7;C8;@9;@9;@::?8:?9:?89>89>7;@:;@9;@:;@9:?9:?8:?9:?98?87=94;4382160/4..3/.3/.21.21-2.,2.,3,,3+,3+)6%$6*>"2F+8L3;O6<N6;M5;M58J29K3;M5=O7<N87H51B0.<--7..5--4,]eP^fO_gRbgQdiUfiVgjWijXfgUhgUheVheVjdVkeWlfZlfXlfXkhYmg[kg\mf^jf]ieZgeVghVfkUenYbo]dqht������������������������������������������������������Ҿ�ϼ���������·������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Ə�nUN2WM2TK.SJ+WN1WN1UN1UN1TO2TO2TN4SO4QM4RN5QO6PP6MO7KO6HM6GL5JP6FO4AJ-=F)@G(DK*FM+EL*PV4PS4KN/IL/TT8bbFccIZZ@[Y@\ZA][B][B[Y@XV=US:SQ8HF1GD1EB1B@1A?2>>2??5>@5;>59?59?59A69A48C58C59C8:B79A69@88@58?79A69@8:B7:A9:B7:A9:B7;B:<D9=D<>E=8B:8B:8B98@56>14</39/271.40/51070.8-.;)0@&6F)7M';V+:W+;U0;T4;R8=P<>O<>O<:L6@R8EW=FY=DX=@T;5H2+<*,6+-4,+2*ZfN[gO^hP_iQbjSckTglXhkXhiWghVifWifWkeWlfXmeZmgYmgYkhYkg[kg\je_jf]hfZfgWhiWglVfo\erajwnz������������������������������������������������������˹ʿ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Nj�lRM0SN1RK.QK+UO/UO/TO1TO1SO2SO2QP4QO6QM2PO3PN5NQ6MO7JP6HM6EM5HQ6FO4BK.?H)CH(GM+JP,KQ-OS0PT1VZ9^aB_bCZ]@VV<UU=VV>WU>XV=YW>YW>XW;WV:XT9QK3PJ4LG4ID1DA2B@3A?3>@5<=59?59?59A67B48C57C57C5:B7:B79A68@58@59A6:B7:B7:B7:B7:B7:B7;C8<D9=E:<F;=G?<H><F;;F6<D5:B39?38=67>76=63=52>04C,9L,BY/Ga1Qo;Mm;Li=Fa>BY?<R=<M=:K9=O9DV<K^BNaCL`DH\A:Q71D0+5*+2*)0(ZfN[gO\hP`jRbjSdlUglXilYijXijXkhYkhYmgYmgYog\nhZmgYkhYkg[jf[je_jf]hfZfgWhiWejTdmZgtco|s���������������������������������������������������˸������������ö���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Ɖ�jPK.RM0QJ-QJ-UO/UO/UP2UP2TP3SO2QP4PO3QM2ON2PN5MP5MO7JP6IN7GO7HQ6FO4CL/CL-GL,KQ/OU1SY5QY2X`9jpLy]qvVY^@LO4MP5QQ9QQ9RP9SQ8TR9VT;YU<ZV=XR<VP:RM:NI6HE6DB5CA5?A6<=59?5:@69A67B48C57C57C5:B7:B79A69A69A69A6:B7:B7:B7:B7:B7:B7;C8<D9>F;<F;?IA>J@?I>?J:@H9>F7>D8=B;>E><C<7A95A39H1BU5Pg=XrB`~J\|JXuINiFD[A9O:6G74E3<N8EW=NaESfHSgKNbG@W=6I5/9./6.-4,ZfN[gO\hP^jRblTemVhmYinZklZklZlj[liZnhZnhZph]oi[liZkhYkg[jf[id^ie\hfZghXfgUbgQajWerao|s~���������������������������������������������˸�Ƴþ����÷�ǹ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Ɋ�mPJ0RM0SL/SL/UO/UO/UP2VQ3TP3SO2PO3ON2PL1ON2OM4LO4MO7KQ7JO8HP8JS8GP5GP3IR3NS3PV4W]9\d=grHt�U��j��u��lnuTZaBSW<MO7NN6MM5NL5OM6RP9WR<YT>ZT>XR<TO<QL9KH9GE8EC7AC8=>6:@6:@69A67B47B46B46B4;C8:B7:B79A69A6:B7:B7;C8;C8:B7:B7;C8<D9=E:>F;=G<=G?=I?>H=>I9?G8>F7>D8=B;=D=;B;6@85A3:I2DW7Ri?[uE\zFXxFTqEIdA>U;2H3/@0.?-6H2@R8L_CReGSgKOcH@W=6I51;007/-4,YgNZhO\hP^jRblTemVinZjo[mn\lm[mk\mj[oi[oi[oi]oi[liZkhYjfZieZid^ie\ig[ghXghVchRajWerao|s{���������������������������������������ѿ�ɸ�ıþ�������ʾ��Ÿ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������̌�oRL2TO2TM0UN1UO/UO/VQ3VQ3UQ4SO2ON2NM1PL1NM1NL3KN3LN6KQ7LQ:JR:LU:IR7JS6OX9TY9U[9]c?fnG��c��s�������z��pr{\\bFLP7LN6LK6LJ5LJ5QL8TM:VP:WQ;VP:SN;QL9MJ;IG:GE9CE:=>6:@6:@69A67B47B46B46B4;C8;C8:B7:B7:B7:B7;C8;C8;C8;C8;C8;C8<D9=E:>F;=G<=G?<H>=G<=H8?G8=E6=C7=B;:A:9@96@85A39H1BU5Ne;Vp@Vt@SsAPmAE`=9P6-C.+<,+<*1C-<N4H[?PcERfJNbG@W=5H4,6++2*'.&
\ No newline at end of file
diff --git a/3rdparty/libjpeg/src/testimages/testorig12.jpg b/3rdparty/libjpeg/src/testimages/testorig12.jpg
new file mode 100644
index 00000000..861aff98
Binary files /dev/null and b/3rdparty/libjpeg/src/testimages/testorig12.jpg differ
diff --git a/3rdparty/libjpeg/src/testimages/vgl_5674_0098.bmp b/3rdparty/libjpeg/src/testimages/vgl_5674_0098.bmp
new file mode 100644
index 00000000..d74ea64a
Binary files /dev/null and b/3rdparty/libjpeg/src/testimages/vgl_5674_0098.bmp differ
diff --git a/3rdparty/libjpeg/src/testimages/vgl_6434_0018a.bmp b/3rdparty/libjpeg/src/testimages/vgl_6434_0018a.bmp
new file mode 100644
index 00000000..25e77b76
Binary files /dev/null and b/3rdparty/libjpeg/src/testimages/vgl_6434_0018a.bmp differ
diff --git a/3rdparty/libjpeg/src/testimages/vgl_6548_0026a.bmp b/3rdparty/libjpeg/src/testimages/vgl_6548_0026a.bmp
new file mode 100644
index 00000000..41e35b59
Binary files /dev/null and b/3rdparty/libjpeg/src/testimages/vgl_6548_0026a.bmp differ
diff --git a/3rdparty/libjpeg/src/tjbench.c b/3rdparty/libjpeg/src/tjbench.c
new file mode 100644
index 00000000..faad9784
--- /dev/null
+++ b/3rdparty/libjpeg/src/tjbench.c
@@ -0,0 +1,1027 @@
+/*
+ * Copyright (C)2009-2019 D. R. Commander.  All Rights Reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright notice,
+ *   this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright notice,
+ *   this list of conditions and the following disclaimer in the documentation
+ *   and/or other materials provided with the distribution.
+ * - Neither the name of the libjpeg-turbo Project nor the names of its
+ *   contributors may be used to endorse or promote products derived from this
+ *   software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE 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 HOLDERS 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 <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include <math.h>
+#include <errno.h>
+#include <limits.h>
+#include <cdjpeg.h>
+#include "./tjutil.h"
+#include "./turbojpeg.h"
+
+
+#define THROW(op, err) { \
+  printf("ERROR in line %d while %s:\n%s\n", __LINE__, op, err); \
+  retval = -1;  goto bailout; \
+}
+#define THROW_UNIX(m)  THROW(m, strerror(errno))
+
+char tjErrorStr[JMSG_LENGTH_MAX] = "\0", tjErrorMsg[JMSG_LENGTH_MAX] = "\0";
+int tjErrorLine = -1, tjErrorCode = -1;
+
+#define THROW_TJG(m) { \
+  printf("ERROR in line %d while %s:\n%s\n", __LINE__, m, \
+         tjGetErrorStr2(NULL)); \
+  retval = -1;  goto bailout; \
+}
+
+#define THROW_TJ(m) { \
+  int _tjErrorCode = tjGetErrorCode(handle); \
+  char *_tjErrorStr = tjGetErrorStr2(handle); \
+  \
+  if (!(flags & TJFLAG_STOPONWARNING) && _tjErrorCode == TJERR_WARNING) { \
+    if (strncmp(tjErrorStr, _tjErrorStr, JMSG_LENGTH_MAX) || \
+        strncmp(tjErrorMsg, m, JMSG_LENGTH_MAX) || \
+        tjErrorCode != _tjErrorCode || tjErrorLine != __LINE__) { \
+      strncpy(tjErrorStr, _tjErrorStr, JMSG_LENGTH_MAX - 1); \
+      strncpy(tjErrorMsg, m, JMSG_LENGTH_MAX - 1); \
+      tjErrorCode = _tjErrorCode; \
+      tjErrorLine = __LINE__; \
+      printf("WARNING in line %d while %s:\n%s\n", __LINE__, m, _tjErrorStr); \
+    } \
+  } else { \
+    printf("%s in line %d while %s:\n%s\n", \
+           _tjErrorCode == TJERR_WARNING ? "WARNING" : "ERROR", __LINE__, m, \
+           _tjErrorStr); \
+    retval = -1;  goto bailout; \
+  } \
+}
+
+int flags = TJFLAG_NOREALLOC, compOnly = 0, decompOnly = 0, doYUV = 0,
+  quiet = 0, doTile = 0, pf = TJPF_BGR, yuvPad = 1, doWrite = 1;
+char *ext = "ppm";
+const char *pixFormatStr[TJ_NUMPF] = {
+  "RGB", "BGR", "RGBX", "BGRX", "XBGR", "XRGB", "GRAY", "", "", "", "", "CMYK"
+};
+const char *subNameLong[TJ_NUMSAMP] = {
+  "4:4:4", "4:2:2", "4:2:0", "GRAY", "4:4:0", "4:1:1"
+};
+const char *csName[TJ_NUMCS] = {
+  "RGB", "YCbCr", "GRAY", "CMYK", "YCCK"
+};
+const char *subName[TJ_NUMSAMP] = {
+  "444", "422", "420", "GRAY", "440", "411"
+};
+tjscalingfactor *scalingFactors = NULL, sf = { 1, 1 };
+int nsf = 0, xformOp = TJXOP_NONE, xformOpt = 0;
+int (*customFilter) (short *, tjregion, tjregion, int, int, tjtransform *);
+double benchTime = 5.0, warmup = 1.0;
+
+
+static char *formatName(int subsamp, int cs, char *buf)
+{
+  if (cs == TJCS_YCbCr)
+    return (char *)subNameLong[subsamp];
+  else if (cs == TJCS_YCCK || cs == TJCS_CMYK) {
+    snprintf(buf, 80, "%s %s", csName[cs], subNameLong[subsamp]);
+    return buf;
+  } else
+    return (char *)csName[cs];
+}
+
+
+static char *sigfig(double val, int figs, char *buf, int len)
+{
+  char format[80];
+  int digitsAfterDecimal = figs - (int)ceil(log10(fabs(val)));
+
+  if (digitsAfterDecimal < 1)
+    snprintf(format, 80, "%%.0f");
+  else
+    snprintf(format, 80, "%%.%df", digitsAfterDecimal);
+  snprintf(buf, len, format, val);
+  return buf;
+}
+
+
+/* Custom DCT filter which produces a negative of the image */
+static int dummyDCTFilter(short *coeffs, tjregion arrayRegion,
+                          tjregion planeRegion, int componentIndex,
+                          int transformIndex, tjtransform *transform)
+{
+  int i;
+
+  for (i = 0; i < arrayRegion.w * arrayRegion.h; i++)
+    coeffs[i] = -coeffs[i];
+  return 0;
+}
+
+
+/* Decompression test */
+static int decomp(unsigned char *srcBuf, unsigned char **jpegBuf,
+                  unsigned long *jpegSize, unsigned char *dstBuf, int w, int h,
+                  int subsamp, int jpegQual, char *fileName, int tilew,
+                  int tileh)
+{
+  char tempStr[1024], sizeStr[24] = "\0", qualStr[13] = "\0", *ptr;
+  FILE *file = NULL;
+  tjhandle handle = NULL;
+  int row, col, iter = 0, dstBufAlloc = 0, retval = 0;
+  double elapsed, elapsedDecode;
+  int ps = tjPixelSize[pf];
+  int scaledw = TJSCALED(w, sf);
+  int scaledh = TJSCALED(h, sf);
+  int pitch = scaledw * ps;
+  int ntilesw = (w + tilew - 1) / tilew, ntilesh = (h + tileh - 1) / tileh;
+  unsigned char *dstPtr, *dstPtr2, *yuvBuf = NULL;
+
+  if (jpegQual > 0) {
+    snprintf(qualStr, 13, "_Q%d", jpegQual);
+    qualStr[12] = 0;
+  }
+
+  if ((handle = tjInitDecompress()) == NULL)
+    THROW_TJ("executing tjInitDecompress()");
+
+  if (dstBuf == NULL) {
+    if ((unsigned long long)pitch * (unsigned long long)scaledh >
+        (unsigned long long)((size_t)-1))
+      THROW("allocating destination buffer", "Image is too large");
+    if ((dstBuf = (unsigned char *)malloc((size_t)pitch * scaledh)) == NULL)
+      THROW_UNIX("allocating destination buffer");
+    dstBufAlloc = 1;
+  }
+  /* Set the destination buffer to gray so we know whether the decompressor
+     attempted to write to it */
+  memset(dstBuf, 127, (size_t)pitch * scaledh);
+
+  if (doYUV) {
+    int width = doTile ? tilew : scaledw;
+    int height = doTile ? tileh : scaledh;
+    unsigned long yuvSize = tjBufSizeYUV2(width, yuvPad, height, subsamp);
+
+    if (yuvSize == (unsigned long)-1)
+      THROW_TJ("allocating YUV buffer");
+    if ((yuvBuf = (unsigned char *)malloc(yuvSize)) == NULL)
+      THROW_UNIX("allocating YUV buffer");
+    memset(yuvBuf, 127, yuvSize);
+  }
+
+  /* Benchmark */
+  iter = -1;
+  elapsed = elapsedDecode = 0.;
+  while (1) {
+    int tile = 0;
+    double start = getTime();
+
+    for (row = 0, dstPtr = dstBuf; row < ntilesh;
+         row++, dstPtr += (size_t)pitch * tileh) {
+      for (col = 0, dstPtr2 = dstPtr; col < ntilesw;
+           col++, tile++, dstPtr2 += ps * tilew) {
+        int width = doTile ? min(tilew, w - col * tilew) : scaledw;
+        int height = doTile ? min(tileh, h - row * tileh) : scaledh;
+
+        if (doYUV) {
+          double startDecode;
+
+          if (tjDecompressToYUV2(handle, jpegBuf[tile], jpegSize[tile], yuvBuf,
+                                 width, yuvPad, height, flags) == -1)
+            THROW_TJ("executing tjDecompressToYUV2()");
+          startDecode = getTime();
+          if (tjDecodeYUV(handle, yuvBuf, yuvPad, subsamp, dstPtr2, width,
+                          pitch, height, pf, flags) == -1)
+            THROW_TJ("executing tjDecodeYUV()");
+          if (iter >= 0) elapsedDecode += getTime() - startDecode;
+        } else if (tjDecompress2(handle, jpegBuf[tile], jpegSize[tile],
+                                 dstPtr2, width, pitch, height, pf,
+                                 flags) == -1)
+          THROW_TJ("executing tjDecompress2()");
+      }
+    }
+    elapsed += getTime() - start;
+    if (iter >= 0) {
+      iter++;
+      if (elapsed >= benchTime) break;
+    } else if (elapsed >= warmup) {
+      iter = 0;
+      elapsed = elapsedDecode = 0.;
+    }
+  }
+  if (doYUV) elapsed -= elapsedDecode;
+
+  if (tjDestroy(handle) == -1) THROW_TJ("executing tjDestroy()");
+  handle = NULL;
+
+  if (quiet) {
+    printf("%-6s%s",
+           sigfig((double)(w * h) / 1000000. * (double)iter / elapsed, 4,
+                  tempStr, 1024),
+           quiet == 2 ? "\n" : "  ");
+    if (doYUV)
+      printf("%s\n",
+             sigfig((double)(w * h) / 1000000. * (double)iter / elapsedDecode,
+                    4, tempStr, 1024));
+    else if (quiet != 2) printf("\n");
+  } else {
+    printf("%s --> Frame rate:         %f fps\n",
+           doYUV ? "Decomp to YUV" : "Decompress   ", (double)iter / elapsed);
+    printf("                  Throughput:         %f Megapixels/sec\n",
+           (double)(w * h) / 1000000. * (double)iter / elapsed);
+    if (doYUV) {
+      printf("YUV Decode    --> Frame rate:         %f fps\n",
+             (double)iter / elapsedDecode);
+      printf("                  Throughput:         %f Megapixels/sec\n",
+             (double)(w * h) / 1000000. * (double)iter / elapsedDecode);
+    }
+  }
+
+  if (!doWrite) goto bailout;
+
+  if (sf.num != 1 || sf.denom != 1)
+    snprintf(sizeStr, 24, "%d_%d", sf.num, sf.denom);
+  else if (tilew != w || tileh != h)
+    snprintf(sizeStr, 24, "%dx%d", tilew, tileh);
+  else snprintf(sizeStr, 24, "full");
+  if (decompOnly)
+    snprintf(tempStr, 1024, "%s_%s.%s", fileName, sizeStr, ext);
+  else
+    snprintf(tempStr, 1024, "%s_%s%s_%s.%s", fileName, subName[subsamp],
+             qualStr, sizeStr, ext);
+
+  if (tjSaveImage(tempStr, dstBuf, scaledw, 0, scaledh, pf, flags) == -1)
+    THROW_TJG("saving bitmap");
+  ptr = strrchr(tempStr, '.');
+  snprintf(ptr, 1024 - (ptr - tempStr), "-err.%s", ext);
+  if (srcBuf && sf.num == 1 && sf.denom == 1) {
+    if (!quiet) printf("Compression error written to %s.\n", tempStr);
+    if (subsamp == TJ_GRAYSCALE) {
+      unsigned long index, index2;
+
+      for (row = 0, index = 0; row < h; row++, index += pitch) {
+        for (col = 0, index2 = index; col < w; col++, index2 += ps) {
+          unsigned long rindex = index2 + tjRedOffset[pf];
+          unsigned long gindex = index2 + tjGreenOffset[pf];
+          unsigned long bindex = index2 + tjBlueOffset[pf];
+          int y = (int)((double)srcBuf[rindex] * 0.299 +
+                        (double)srcBuf[gindex] * 0.587 +
+                        (double)srcBuf[bindex] * 0.114 + 0.5);
+
+          if (y > 255) y = 255;
+          if (y < 0) y = 0;
+          dstBuf[rindex] = abs(dstBuf[rindex] - y);
+          dstBuf[gindex] = abs(dstBuf[gindex] - y);
+          dstBuf[bindex] = abs(dstBuf[bindex] - y);
+        }
+      }
+    } else {
+      for (row = 0; row < h; row++)
+        for (col = 0; col < w * ps; col++)
+          dstBuf[pitch * row + col] =
+            abs(dstBuf[pitch * row + col] - srcBuf[pitch * row + col]);
+    }
+    if (tjSaveImage(tempStr, dstBuf, w, 0, h, pf, flags) == -1)
+      THROW_TJG("saving bitmap");
+  }
+
+bailout:
+  if (file) fclose(file);
+  if (handle) tjDestroy(handle);
+  if (dstBufAlloc) free(dstBuf);
+  free(yuvBuf);
+  return retval;
+}
+
+
+static int fullTest(unsigned char *srcBuf, int w, int h, int subsamp,
+                    int jpegQual, char *fileName)
+{
+  char tempStr[1024], tempStr2[80];
+  FILE *file = NULL;
+  tjhandle handle = NULL;
+  unsigned char **jpegBuf = NULL, *yuvBuf = NULL, *tmpBuf = NULL, *srcPtr,
+    *srcPtr2;
+  double start, elapsed, elapsedEncode;
+  int totalJpegSize = 0, row, col, i, tilew = w, tileh = h, retval = 0;
+  int iter;
+  unsigned long *jpegSize = NULL, yuvSize = 0;
+  int ps = tjPixelSize[pf];
+  int ntilesw = 1, ntilesh = 1, pitch = w * ps;
+  const char *pfStr = pixFormatStr[pf];
+
+  if ((unsigned long long)pitch * (unsigned long long)h >
+      (unsigned long long)((size_t)-1))
+    THROW("allocating temporary image buffer", "Image is too large");
+  if ((tmpBuf = (unsigned char *)malloc((size_t)pitch * h)) == NULL)
+    THROW_UNIX("allocating temporary image buffer");
+
+  if (!quiet)
+    printf(">>>>>  %s (%s) <--> JPEG %s Q%d  <<<<<\n", pfStr,
+           (flags & TJFLAG_BOTTOMUP) ? "Bottom-up" : "Top-down",
+           subNameLong[subsamp], jpegQual);
+
+  for (tilew = doTile ? 8 : w, tileh = doTile ? 8 : h; ;
+       tilew *= 2, tileh *= 2) {
+    if (tilew > w) tilew = w;
+    if (tileh > h) tileh = h;
+    ntilesw = (w + tilew - 1) / tilew;
+    ntilesh = (h + tileh - 1) / tileh;
+
+    if ((jpegBuf = (unsigned char **)malloc(sizeof(unsigned char *) *
+                                            ntilesw * ntilesh)) == NULL)
+      THROW_UNIX("allocating JPEG tile array");
+    memset(jpegBuf, 0, sizeof(unsigned char *) * ntilesw * ntilesh);
+    if ((jpegSize = (unsigned long *)malloc(sizeof(unsigned long) *
+                                            ntilesw * ntilesh)) == NULL)
+      THROW_UNIX("allocating JPEG size array");
+    memset(jpegSize, 0, sizeof(unsigned long) * ntilesw * ntilesh);
+
+    if ((flags & TJFLAG_NOREALLOC) != 0)
+      for (i = 0; i < ntilesw * ntilesh; i++) {
+        if (tjBufSize(tilew, tileh, subsamp) > (unsigned long)INT_MAX)
+          THROW("getting buffer size", "Image is too large");
+        if ((jpegBuf[i] = (unsigned char *)
+                          tjAlloc(tjBufSize(tilew, tileh, subsamp))) == NULL)
+          THROW_UNIX("allocating JPEG tiles");
+      }
+
+    /* Compression test */
+    if (quiet == 1)
+      printf("%-4s (%s)  %-5s    %-3d   ", pfStr,
+             (flags & TJFLAG_BOTTOMUP) ? "BU" : "TD", subNameLong[subsamp],
+             jpegQual);
+    for (i = 0; i < h; i++)
+      memcpy(&tmpBuf[pitch * i], &srcBuf[w * ps * i], w * ps);
+    if ((handle = tjInitCompress()) == NULL)
+      THROW_TJ("executing tjInitCompress()");
+
+    if (doYUV) {
+      yuvSize = tjBufSizeYUV2(tilew, yuvPad, tileh, subsamp);
+      if (yuvSize == (unsigned long)-1)
+        THROW_TJ("allocating YUV buffer");
+      if ((yuvBuf = (unsigned char *)malloc(yuvSize)) == NULL)
+        THROW_UNIX("allocating YUV buffer");
+      memset(yuvBuf, 127, yuvSize);
+    }
+
+    /* Benchmark */
+    iter = -1;
+    elapsed = elapsedEncode = 0.;
+    while (1) {
+      int tile = 0;
+
+      totalJpegSize = 0;
+      start = getTime();
+      for (row = 0, srcPtr = srcBuf; row < ntilesh;
+           row++, srcPtr += pitch * tileh) {
+        for (col = 0, srcPtr2 = srcPtr; col < ntilesw;
+             col++, tile++, srcPtr2 += ps * tilew) {
+          int width = min(tilew, w - col * tilew);
+          int height = min(tileh, h - row * tileh);
+
+          if (doYUV) {
+            double startEncode = getTime();
+
+            if (tjEncodeYUV3(handle, srcPtr2, width, pitch, height, pf, yuvBuf,
+                             yuvPad, subsamp, flags) == -1)
+              THROW_TJ("executing tjEncodeYUV3()");
+            if (iter >= 0) elapsedEncode += getTime() - startEncode;
+            if (tjCompressFromYUV(handle, yuvBuf, width, yuvPad, height,
+                                  subsamp, &jpegBuf[tile], &jpegSize[tile],
+                                  jpegQual, flags) == -1)
+              THROW_TJ("executing tjCompressFromYUV()");
+          } else {
+            if (tjCompress2(handle, srcPtr2, width, pitch, height, pf,
+                            &jpegBuf[tile], &jpegSize[tile], subsamp, jpegQual,
+                            flags) == -1)
+              THROW_TJ("executing tjCompress2()");
+          }
+          totalJpegSize += jpegSize[tile];
+        }
+      }
+      elapsed += getTime() - start;
+      if (iter >= 0) {
+        iter++;
+        if (elapsed >= benchTime) break;
+      } else if (elapsed >= warmup) {
+        iter = 0;
+        elapsed = elapsedEncode = 0.;
+      }
+    }
+    if (doYUV) elapsed -= elapsedEncode;
+
+    if (tjDestroy(handle) == -1) THROW_TJ("executing tjDestroy()");
+    handle = NULL;
+
+    if (quiet == 1) printf("%-5d  %-5d   ", tilew, tileh);
+    if (quiet) {
+      if (doYUV)
+        printf("%-6s%s",
+               sigfig((double)(w * h) / 1000000. *
+                      (double)iter / elapsedEncode, 4, tempStr, 1024),
+               quiet == 2 ? "\n" : "  ");
+      printf("%-6s%s",
+             sigfig((double)(w * h) / 1000000. * (double)iter / elapsed, 4,
+                    tempStr, 1024),
+             quiet == 2 ? "\n" : "  ");
+      printf("%-6s%s",
+             sigfig((double)(w * h * ps) / (double)totalJpegSize, 4, tempStr2,
+                    80),
+             quiet == 2 ? "\n" : "  ");
+    } else {
+      printf("\n%s size: %d x %d\n", doTile ? "Tile" : "Image", tilew, tileh);
+      if (doYUV) {
+        printf("Encode YUV    --> Frame rate:         %f fps\n",
+               (double)iter / elapsedEncode);
+        printf("                  Output image size:  %lu bytes\n", yuvSize);
+        printf("                  Compression ratio:  %f:1\n",
+               (double)(w * h * ps) / (double)yuvSize);
+        printf("                  Throughput:         %f Megapixels/sec\n",
+               (double)(w * h) / 1000000. * (double)iter / elapsedEncode);
+        printf("                  Output bit stream:  %f Megabits/sec\n",
+               (double)yuvSize * 8. / 1000000. * (double)iter / elapsedEncode);
+      }
+      printf("%s --> Frame rate:         %f fps\n",
+             doYUV ? "Comp from YUV" : "Compress     ",
+             (double)iter / elapsed);
+      printf("                  Output image size:  %d bytes\n",
+             totalJpegSize);
+      printf("                  Compression ratio:  %f:1\n",
+             (double)(w * h * ps) / (double)totalJpegSize);
+      printf("                  Throughput:         %f Megapixels/sec\n",
+             (double)(w * h) / 1000000. * (double)iter / elapsed);
+      printf("                  Output bit stream:  %f Megabits/sec\n",
+             (double)totalJpegSize * 8. / 1000000. * (double)iter / elapsed);
+    }
+    if (tilew == w && tileh == h && doWrite) {
+      snprintf(tempStr, 1024, "%s_%s_Q%d.jpg", fileName, subName[subsamp],
+               jpegQual);
+      if ((file = fopen(tempStr, "wb")) == NULL)
+        THROW_UNIX("opening reference image");
+      if (fwrite(jpegBuf[0], jpegSize[0], 1, file) != 1)
+        THROW_UNIX("writing reference image");
+      fclose(file);  file = NULL;
+      if (!quiet) printf("Reference image written to %s\n", tempStr);
+    }
+
+    /* Decompression test */
+    if (!compOnly) {
+      if (decomp(srcBuf, jpegBuf, jpegSize, tmpBuf, w, h, subsamp, jpegQual,
+                 fileName, tilew, tileh) == -1)
+        goto bailout;
+    } else if (quiet == 1) printf("N/A\n");
+
+    for (i = 0; i < ntilesw * ntilesh; i++) {
+      tjFree(jpegBuf[i]);
+      jpegBuf[i] = NULL;
+    }
+    free(jpegBuf);  jpegBuf = NULL;
+    free(jpegSize);  jpegSize = NULL;
+    if (doYUV) {
+      free(yuvBuf);  yuvBuf = NULL;
+    }
+
+    if (tilew == w && tileh == h) break;
+  }
+
+bailout:
+  if (file) fclose(file);
+  if (jpegBuf) {
+    for (i = 0; i < ntilesw * ntilesh; i++)
+      tjFree(jpegBuf[i]);
+  }
+  free(jpegBuf);
+  free(yuvBuf);
+  free(jpegSize);
+  free(tmpBuf);
+  if (handle) tjDestroy(handle);
+  return retval;
+}
+
+
+static int decompTest(char *fileName)
+{
+  FILE *file = NULL;
+  tjhandle handle = NULL;
+  unsigned char **jpegBuf = NULL, *srcBuf = NULL;
+  unsigned long *jpegSize = NULL, srcSize, totalJpegSize;
+  tjtransform *t = NULL;
+  double start, elapsed;
+  int ps = tjPixelSize[pf], tile, row, col, i, iter, retval = 0, decompsrc = 0;
+  char *temp = NULL, tempStr[80], tempStr2[80];
+  /* Original image */
+  int w = 0, h = 0, tilew, tileh, ntilesw = 1, ntilesh = 1, subsamp = -1,
+    cs = -1;
+  /* Transformed image */
+  int tw, th, ttilew, ttileh, tntilesw, tntilesh, tsubsamp;
+
+  if ((file = fopen(fileName, "rb")) == NULL)
+    THROW_UNIX("opening file");
+  if (fseek(file, 0, SEEK_END) < 0 ||
+      (srcSize = ftell(file)) == (unsigned long)-1)
+    THROW_UNIX("determining file size");
+  if ((srcBuf = (unsigned char *)malloc(srcSize)) == NULL)
+    THROW_UNIX("allocating memory");
+  if (fseek(file, 0, SEEK_SET) < 0)
+    THROW_UNIX("setting file position");
+  if (fread(srcBuf, srcSize, 1, file) < 1)
+    THROW_UNIX("reading JPEG data");
+  fclose(file);  file = NULL;
+
+  temp = strrchr(fileName, '.');
+  if (temp != NULL) *temp = '\0';
+
+  if ((handle = tjInitTransform()) == NULL)
+    THROW_TJ("executing tjInitTransform()");
+  if (tjDecompressHeader3(handle, srcBuf, srcSize, &w, &h, &subsamp,
+                          &cs) == -1)
+    THROW_TJ("executing tjDecompressHeader3()");
+  if (w < 1 || h < 1)
+    THROW("reading JPEG header", "Invalid image dimensions");
+  if (cs == TJCS_YCCK || cs == TJCS_CMYK) {
+    pf = TJPF_CMYK;  ps = tjPixelSize[pf];
+  }
+
+  if (quiet == 1) {
+    printf("All performance values in Mpixels/sec\n\n");
+    printf("Bitmap     JPEG   JPEG     %s  %s   Xform   Comp    Decomp  ",
+           doTile ? "Tile " : "Image", doTile ? "Tile " : "Image");
+    if (doYUV) printf("Decode");
+    printf("\n");
+    printf("Format     CS     Subsamp  Width  Height  Perf    Ratio   Perf    ");
+    if (doYUV) printf("Perf");
+    printf("\n\n");
+  } else if (!quiet)
+    printf(">>>>>  JPEG %s --> %s (%s)  <<<<<\n",
+           formatName(subsamp, cs, tempStr), pixFormatStr[pf],
+           (flags & TJFLAG_BOTTOMUP) ? "Bottom-up" : "Top-down");
+
+  for (tilew = doTile ? 16 : w, tileh = doTile ? 16 : h; ;
+       tilew *= 2, tileh *= 2) {
+    if (tilew > w) tilew = w;
+    if (tileh > h) tileh = h;
+    ntilesw = (w + tilew - 1) / tilew;
+    ntilesh = (h + tileh - 1) / tileh;
+
+    if ((jpegBuf = (unsigned char **)malloc(sizeof(unsigned char *) *
+                                            ntilesw * ntilesh)) == NULL)
+      THROW_UNIX("allocating JPEG tile array");
+    memset(jpegBuf, 0, sizeof(unsigned char *) * ntilesw * ntilesh);
+    if ((jpegSize = (unsigned long *)malloc(sizeof(unsigned long) *
+                                            ntilesw * ntilesh)) == NULL)
+      THROW_UNIX("allocating JPEG size array");
+    memset(jpegSize, 0, sizeof(unsigned long) * ntilesw * ntilesh);
+
+    if ((flags & TJFLAG_NOREALLOC) != 0 &&
+        (doTile || xformOp != TJXOP_NONE || xformOpt != 0 || customFilter))
+      for (i = 0; i < ntilesw * ntilesh; i++) {
+        if (tjBufSize(tilew, tileh, subsamp) > (unsigned long)INT_MAX)
+          THROW("getting buffer size", "Image is too large");
+        if ((jpegBuf[i] = (unsigned char *)
+                          tjAlloc(tjBufSize(tilew, tileh, subsamp))) == NULL)
+          THROW_UNIX("allocating JPEG tiles");
+      }
+
+    tw = w;  th = h;  ttilew = tilew;  ttileh = tileh;
+    if (!quiet) {
+      printf("\n%s size: %d x %d", doTile ? "Tile" : "Image", ttilew, ttileh);
+      if (sf.num != 1 || sf.denom != 1)
+        printf(" --> %d x %d", TJSCALED(tw, sf), TJSCALED(th, sf));
+      printf("\n");
+    } else if (quiet == 1) {
+      printf("%-4s (%s)  %-5s  %-5s    ", pixFormatStr[pf],
+             (flags & TJFLAG_BOTTOMUP) ? "BU" : "TD", csName[cs],
+             subNameLong[subsamp]);
+      printf("%-5d  %-5d   ", tilew, tileh);
+    }
+
+    tsubsamp = subsamp;
+    if (doTile || xformOp != TJXOP_NONE || xformOpt != 0 || customFilter) {
+      if ((t = (tjtransform *)malloc(sizeof(tjtransform) * ntilesw *
+                                     ntilesh)) == NULL)
+        THROW_UNIX("allocating image transform array");
+
+      if (xformOp == TJXOP_TRANSPOSE || xformOp == TJXOP_TRANSVERSE ||
+          xformOp == TJXOP_ROT90 || xformOp == TJXOP_ROT270) {
+        tw = h;  th = w;  ttilew = tileh;  ttileh = tilew;
+      }
+
+      if (xformOpt & TJXOPT_GRAY) tsubsamp = TJ_GRAYSCALE;
+      if (xformOp == TJXOP_HFLIP || xformOp == TJXOP_ROT180)
+        tw = tw - (tw % tjMCUWidth[tsubsamp]);
+      if (xformOp == TJXOP_VFLIP || xformOp == TJXOP_ROT180)
+        th = th - (th % tjMCUHeight[tsubsamp]);
+      if (xformOp == TJXOP_TRANSVERSE || xformOp == TJXOP_ROT90)
+        tw = tw - (tw % tjMCUHeight[tsubsamp]);
+      if (xformOp == TJXOP_TRANSVERSE || xformOp == TJXOP_ROT270)
+        th = th - (th % tjMCUWidth[tsubsamp]);
+      tntilesw = (tw + ttilew - 1) / ttilew;
+      tntilesh = (th + ttileh - 1) / ttileh;
+
+      if (xformOp == TJXOP_TRANSPOSE || xformOp == TJXOP_TRANSVERSE ||
+          xformOp == TJXOP_ROT90 || xformOp == TJXOP_ROT270) {
+        if (tsubsamp == TJSAMP_422) tsubsamp = TJSAMP_440;
+        else if (tsubsamp == TJSAMP_440) tsubsamp = TJSAMP_422;
+      }
+
+      for (row = 0, tile = 0; row < tntilesh; row++) {
+        for (col = 0; col < tntilesw; col++, tile++) {
+          t[tile].r.w = min(ttilew, tw - col * ttilew);
+          t[tile].r.h = min(ttileh, th - row * ttileh);
+          t[tile].r.x = col * ttilew;
+          t[tile].r.y = row * ttileh;
+          t[tile].op = xformOp;
+          t[tile].options = xformOpt | TJXOPT_TRIM;
+          t[tile].customFilter = customFilter;
+          if (t[tile].options & TJXOPT_NOOUTPUT && jpegBuf[tile]) {
+            tjFree(jpegBuf[tile]);  jpegBuf[tile] = NULL;
+          }
+        }
+      }
+
+      iter = -1;
+      elapsed = 0.;
+      while (1) {
+        start = getTime();
+        if (tjTransform(handle, srcBuf, srcSize, tntilesw * tntilesh, jpegBuf,
+                        jpegSize, t, flags) == -1)
+          THROW_TJ("executing tjTransform()");
+        elapsed += getTime() - start;
+        if (iter >= 0) {
+          iter++;
+          if (elapsed >= benchTime) break;
+        } else if (elapsed >= warmup) {
+          iter = 0;
+          elapsed = 0.;
+        }
+      }
+
+      free(t);  t = NULL;
+
+      for (tile = 0, totalJpegSize = 0; tile < tntilesw * tntilesh; tile++)
+        totalJpegSize += jpegSize[tile];
+
+      if (quiet) {
+        printf("%-6s%s%-6s%s",
+               sigfig((double)(w * h) / 1000000. / elapsed, 4, tempStr, 80),
+               quiet == 2 ? "\n" : "  ",
+               sigfig((double)(w * h * ps) / (double)totalJpegSize, 4,
+                      tempStr2, 80),
+               quiet == 2 ? "\n" : "  ");
+      } else if (!quiet) {
+        printf("Transform     --> Frame rate:         %f fps\n",
+               1.0 / elapsed);
+        printf("                  Output image size:  %lu bytes\n",
+               totalJpegSize);
+        printf("                  Compression ratio:  %f:1\n",
+               (double)(w * h * ps) / (double)totalJpegSize);
+        printf("                  Throughput:         %f Megapixels/sec\n",
+               (double)(w * h) / 1000000. / elapsed);
+        printf("                  Output bit stream:  %f Megabits/sec\n",
+               (double)totalJpegSize * 8. / 1000000. / elapsed);
+      }
+    } else {
+      if (quiet == 1) printf("N/A     N/A     ");
+      tjFree(jpegBuf[0]);
+      jpegBuf[0] = NULL;
+      decompsrc = 1;
+    }
+
+    if (w == tilew) ttilew = tw;
+    if (h == tileh) ttileh = th;
+    if (!(xformOpt & TJXOPT_NOOUTPUT)) {
+      if (decomp(NULL, decompsrc ? &srcBuf : jpegBuf,
+                 decompsrc ? &srcSize : jpegSize, NULL, tw, th, tsubsamp, 0,
+                 fileName, ttilew, ttileh) == -1)
+        goto bailout;
+    } else if (quiet == 1) printf("N/A\n");
+
+    for (i = 0; i < ntilesw * ntilesh; i++) {
+      tjFree(jpegBuf[i]);
+      jpegBuf[i] = NULL;
+    }
+    free(jpegBuf);  jpegBuf = NULL;
+    free(jpegSize);  jpegSize = NULL;
+
+    if (tilew == w && tileh == h) break;
+  }
+
+bailout:
+  if (file) fclose(file);
+  if (jpegBuf) {
+    for (i = 0; i < ntilesw * ntilesh; i++)
+      tjFree(jpegBuf[i]);
+  }
+  free(jpegBuf);
+  free(jpegSize);
+  free(srcBuf);
+  free(t);
+  if (handle) { tjDestroy(handle);  handle = NULL; }
+  return retval;
+}
+
+
+static void usage(char *progName)
+{
+  int i;
+
+  printf("USAGE: %s\n", progName);
+  printf("       <Inputfile (BMP|PPM)> <Quality> [options]\n\n");
+  printf("       %s\n", progName);
+  printf("       <Inputfile (JPG)> [options]\n\n");
+  printf("Options:\n\n");
+  printf("-alloc = Dynamically allocate JPEG image buffers\n");
+  printf("-bmp = Generate output images in Windows Bitmap format (default = PPM)\n");
+  printf("-bottomup = Test bottom-up compression/decompression\n");
+  printf("-tile = Test performance of the codec when the image is encoded as separate\n");
+  printf("     tiles of varying sizes.\n");
+  printf("-rgb, -bgr, -rgbx, -bgrx, -xbgr, -xrgb =\n");
+  printf("     Test the specified color conversion path in the codec (default = BGR)\n");
+  printf("-cmyk = Indirectly test YCCK JPEG compression/decompression (the source\n");
+  printf("     and destination bitmaps are still RGB.  The conversion is done\n");
+  printf("     internally prior to compression or after decompression.)\n");
+  printf("-fastupsample = Use the fastest chrominance upsampling algorithm available in\n");
+  printf("     the underlying codec\n");
+  printf("-fastdct = Use the fastest DCT/IDCT algorithms available in the underlying\n");
+  printf("     codec\n");
+  printf("-accuratedct = Use the most accurate DCT/IDCT algorithms available in the\n");
+  printf("     underlying codec\n");
+  printf("-progressive = Use progressive entropy coding in JPEG images generated by\n");
+  printf("     compression and transform operations.\n");
+  printf("-subsamp <s> = When testing JPEG compression, this option specifies the level\n");
+  printf("     of chrominance subsampling to use (<s> = 444, 422, 440, 420, 411, or\n");
+  printf("     GRAY).  The default is to test Grayscale, 4:2:0, 4:2:2, and 4:4:4 in\n");
+  printf("     sequence.\n");
+  printf("-quiet = Output results in tabular rather than verbose format\n");
+  printf("-yuv = Test YUV encoding/decoding functions\n");
+  printf("-yuvpad <p> = If testing YUV encoding/decoding, this specifies the number of\n");
+  printf("     bytes to which each row of each plane in the intermediate YUV image is\n");
+  printf("     padded (default = 1)\n");
+  printf("-scale M/N = Scale down the width/height of the decompressed JPEG image by a\n");
+  printf("     factor of M/N (M/N = ");
+  for (i = 0; i < nsf; i++) {
+    printf("%d/%d", scalingFactors[i].num, scalingFactors[i].denom);
+    if (nsf == 2 && i != nsf - 1) printf(" or ");
+    else if (nsf > 2) {
+      if (i != nsf - 1) printf(", ");
+      if (i == nsf - 2) printf("or ");
+    }
+    if (i % 8 == 0 && i != 0) printf("\n     ");
+  }
+  printf(")\n");
+  printf("-hflip, -vflip, -transpose, -transverse, -rot90, -rot180, -rot270 =\n");
+  printf("     Perform the corresponding lossless transform prior to\n");
+  printf("     decompression (these options are mutually exclusive)\n");
+  printf("-grayscale = Perform lossless grayscale conversion prior to decompression\n");
+  printf("     test (can be combined with the other transforms above)\n");
+  printf("-copynone = Do not copy any extra markers (including EXIF and ICC profile data)\n");
+  printf("     when transforming the image.\n");
+  printf("-benchtime <t> = Run each benchmark for at least <t> seconds (default = 5.0)\n");
+  printf("-warmup <t> = Run each benchmark for <t> seconds (default = 1.0) prior to\n");
+  printf("     starting the timer, in order to prime the caches and thus improve the\n");
+  printf("     consistency of the results.\n");
+  printf("-componly = Stop after running compression tests.  Do not test decompression.\n");
+  printf("-nowrite = Do not write reference or output images (improves consistency of\n");
+  printf("     performance measurements.)\n");
+  printf("-stoponwarning = Immediately discontinue the current\n");
+  printf("     compression/decompression/transform operation if the underlying codec\n");
+  printf("     throws a warning (non-fatal error)\n\n");
+  printf("NOTE:  If the quality is specified as a range (e.g. 90-100), a separate\n");
+  printf("test will be performed for all quality values in the range.\n\n");
+  exit(1);
+}
+
+
+int main(int argc, char *argv[])
+{
+  unsigned char *srcBuf = NULL;
+  int w = 0, h = 0, i, j, minQual = -1, maxQual = -1;
+  char *temp;
+  int minArg = 2, retval = 0, subsamp = -1;
+
+  if ((scalingFactors = tjGetScalingFactors(&nsf)) == NULL || nsf == 0)
+    THROW("executing tjGetScalingFactors()", tjGetErrorStr());
+
+  if (argc < minArg) usage(argv[0]);
+
+  temp = strrchr(argv[1], '.');
+  if (temp != NULL) {
+    if (!strcasecmp(temp, ".bmp")) ext = "bmp";
+    if (!strcasecmp(temp, ".jpg") || !strcasecmp(temp, ".jpeg"))
+      decompOnly = 1;
+  }
+
+  printf("\n");
+
+  if (!decompOnly) {
+    minArg = 3;
+    if (argc < minArg) usage(argv[0]);
+    if ((minQual = atoi(argv[2])) < 1 || minQual > 100) {
+      puts("ERROR: Quality must be between 1 and 100.");
+      exit(1);
+    }
+    if ((temp = strchr(argv[2], '-')) != NULL && strlen(temp) > 1 &&
+        sscanf(&temp[1], "%d", &maxQual) == 1 && maxQual > minQual &&
+        maxQual >= 1 && maxQual <= 100) {}
+    else maxQual = minQual;
+  }
+
+  if (argc > minArg) {
+    for (i = minArg; i < argc; i++) {
+      if (!strcasecmp(argv[i], "-tile")) {
+        doTile = 1;  xformOpt |= TJXOPT_CROP;
+      } else if (!strcasecmp(argv[i], "-fastupsample")) {
+        printf("Using fast upsampling code\n\n");
+        flags |= TJFLAG_FASTUPSAMPLE;
+      } else if (!strcasecmp(argv[i], "-fastdct")) {
+        printf("Using fastest DCT/IDCT algorithm\n\n");
+        flags |= TJFLAG_FASTDCT;
+      } else if (!strcasecmp(argv[i], "-accuratedct")) {
+        printf("Using most accurate DCT/IDCT algorithm\n\n");
+        flags |= TJFLAG_ACCURATEDCT;
+      } else if (!strcasecmp(argv[i], "-progressive")) {
+        printf("Using progressive entropy coding\n\n");
+        flags |= TJFLAG_PROGRESSIVE;
+      } else if (!strcasecmp(argv[i], "-rgb"))
+        pf = TJPF_RGB;
+      else if (!strcasecmp(argv[i], "-rgbx"))
+        pf = TJPF_RGBX;
+      else if (!strcasecmp(argv[i], "-bgr"))
+        pf = TJPF_BGR;
+      else if (!strcasecmp(argv[i], "-bgrx"))
+        pf = TJPF_BGRX;
+      else if (!strcasecmp(argv[i], "-xbgr"))
+        pf = TJPF_XBGR;
+      else if (!strcasecmp(argv[i], "-xrgb"))
+        pf = TJPF_XRGB;
+      else if (!strcasecmp(argv[i], "-cmyk"))
+        pf = TJPF_CMYK;
+      else if (!strcasecmp(argv[i], "-bottomup"))
+        flags |= TJFLAG_BOTTOMUP;
+      else if (!strcasecmp(argv[i], "-quiet"))
+        quiet = 1;
+      else if (!strcasecmp(argv[i], "-qq"))
+        quiet = 2;
+      else if (!strcasecmp(argv[i], "-scale") && i < argc - 1) {
+        int temp1 = 0, temp2 = 0, match = 0;
+
+        if (sscanf(argv[++i], "%d/%d", &temp1, &temp2) == 2) {
+          for (j = 0; j < nsf; j++) {
+            if ((double)temp1 / (double)temp2 ==
+                (double)scalingFactors[j].num /
+                (double)scalingFactors[j].denom) {
+              sf = scalingFactors[j];
+              match = 1;  break;
+            }
+          }
+          if (!match) usage(argv[0]);
+        } else usage(argv[0]);
+      } else if (!strcasecmp(argv[i], "-hflip"))
+        xformOp = TJXOP_HFLIP;
+      else if (!strcasecmp(argv[i], "-vflip"))
+        xformOp = TJXOP_VFLIP;
+      else if (!strcasecmp(argv[i], "-transpose"))
+        xformOp = TJXOP_TRANSPOSE;
+      else if (!strcasecmp(argv[i], "-transverse"))
+        xformOp = TJXOP_TRANSVERSE;
+      else if (!strcasecmp(argv[i], "-rot90"))
+        xformOp = TJXOP_ROT90;
+      else if (!strcasecmp(argv[i], "-rot180"))
+        xformOp = TJXOP_ROT180;
+      else if (!strcasecmp(argv[i], "-rot270"))
+        xformOp = TJXOP_ROT270;
+      else if (!strcasecmp(argv[i], "-grayscale"))
+        xformOpt |= TJXOPT_GRAY;
+      else if (!strcasecmp(argv[i], "-custom"))
+        customFilter = dummyDCTFilter;
+      else if (!strcasecmp(argv[i], "-nooutput"))
+        xformOpt |= TJXOPT_NOOUTPUT;
+      else if (!strcasecmp(argv[i], "-copynone"))
+        xformOpt |= TJXOPT_COPYNONE;
+      else if (!strcasecmp(argv[i], "-benchtime") && i < argc - 1) {
+        double tempd = atof(argv[++i]);
+
+        if (tempd > 0.0) benchTime = tempd;
+        else usage(argv[0]);
+      } else if (!strcasecmp(argv[i], "-warmup") && i < argc - 1) {
+        double tempd = atof(argv[++i]);
+
+        if (tempd >= 0.0) warmup = tempd;
+        else usage(argv[0]);
+        printf("Warmup time = %.1f seconds\n\n", warmup);
+      } else if (!strcasecmp(argv[i], "-alloc"))
+        flags &= (~TJFLAG_NOREALLOC);
+      else if (!strcasecmp(argv[i], "-bmp"))
+        ext = "bmp";
+      else if (!strcasecmp(argv[i], "-yuv")) {
+        printf("Testing YUV planar encoding/decoding\n\n");
+        doYUV = 1;
+      } else if (!strcasecmp(argv[i], "-yuvpad") && i < argc - 1) {
+        int tempi = atoi(argv[++i]);
+
+        if (tempi >= 1) yuvPad = tempi;
+      } else if (!strcasecmp(argv[i], "-subsamp") && i < argc - 1) {
+        i++;
+        if (toupper(argv[i][0]) == 'G') subsamp = TJSAMP_GRAY;
+        else {
+          int tempi = atoi(argv[i]);
+
+          switch (tempi) {
+          case 444:  subsamp = TJSAMP_444;  break;
+          case 422:  subsamp = TJSAMP_422;  break;
+          case 440:  subsamp = TJSAMP_440;  break;
+          case 420:  subsamp = TJSAMP_420;  break;
+          case 411:  subsamp = TJSAMP_411;  break;
+          }
+        }
+      } else if (!strcasecmp(argv[i], "-componly"))
+        compOnly = 1;
+      else if (!strcasecmp(argv[i], "-nowrite"))
+        doWrite = 0;
+      else if (!strcasecmp(argv[i], "-stoponwarning"))
+        flags |= TJFLAG_STOPONWARNING;
+      else usage(argv[0]);
+    }
+  }
+
+  if ((sf.num != 1 || sf.denom != 1) && doTile) {
+    printf("Disabling tiled compression/decompression tests, because those tests do not\n");
+    printf("work when scaled decompression is enabled.\n");
+    doTile = 0;
+  }
+
+  if ((flags & TJFLAG_NOREALLOC) == 0 && doTile) {
+    printf("Disabling tiled compression/decompression tests, because those tests do not\n");
+    printf("work when dynamic JPEG buffer allocation is enabled.\n\n");
+    doTile = 0;
+  }
+
+  if (!decompOnly) {
+    if ((srcBuf = tjLoadImage(argv[1], &w, 1, &h, &pf, flags)) == NULL)
+      THROW_TJG("loading bitmap");
+    temp = strrchr(argv[1], '.');
+    if (temp != NULL) *temp = '\0';
+  }
+
+  if (quiet == 1 && !decompOnly) {
+    printf("All performance values in Mpixels/sec\n\n");
+    printf("Bitmap     JPEG     JPEG  %s  %s   ",
+           doTile ? "Tile " : "Image", doTile ? "Tile " : "Image");
+    if (doYUV) printf("Encode  ");
+    printf("Comp    Comp    Decomp  ");
+    if (doYUV) printf("Decode");
+    printf("\n");
+    printf("Format     Subsamp  Qual  Width  Height  ");
+    if (doYUV) printf("Perf    ");
+    printf("Perf    Ratio   Perf    ");
+    if (doYUV) printf("Perf");
+    printf("\n\n");
+  }
+
+  if (decompOnly) {
+    decompTest(argv[1]);
+    printf("\n");
+    goto bailout;
+  }
+  if (subsamp >= 0 && subsamp < TJ_NUMSAMP) {
+    for (i = maxQual; i >= minQual; i--)
+      fullTest(srcBuf, w, h, subsamp, i, argv[1]);
+    printf("\n");
+  } else {
+    if (pf != TJPF_CMYK) {
+      for (i = maxQual; i >= minQual; i--)
+        fullTest(srcBuf, w, h, TJSAMP_GRAY, i, argv[1]);
+      printf("\n");
+    }
+    for (i = maxQual; i >= minQual; i--)
+      fullTest(srcBuf, w, h, TJSAMP_420, i, argv[1]);
+    printf("\n");
+    for (i = maxQual; i >= minQual; i--)
+      fullTest(srcBuf, w, h, TJSAMP_422, i, argv[1]);
+    printf("\n");
+    for (i = maxQual; i >= minQual; i--)
+      fullTest(srcBuf, w, h, TJSAMP_444, i, argv[1]);
+    printf("\n");
+  }
+
+bailout:
+  tjFree(srcBuf);
+  return retval;
+}
diff --git a/3rdparty/libjpeg/src/tjbenchtest.in b/3rdparty/libjpeg/src/tjbenchtest.in
new file mode 100644
index 00000000..1c08b374
--- /dev/null
+++ b/3rdparty/libjpeg/src/tjbenchtest.in
@@ -0,0 +1,256 @@
+#!/bin/bash
+
+set -u
+set -e
+trap onexit INT
+trap onexit TERM
+trap onexit EXIT
+
+onexit()
+{
+	if [ -d $OUTDIR ]; then
+		rm -rf $OUTDIR
+	fi
+}
+
+runme()
+{
+	echo \*\*\* $*
+	$*
+}
+
+EXT=bmp
+IMAGES="vgl_5674_0098.${EXT} vgl_6434_0018a.${EXT} vgl_6548_0026a.${EXT} nightshot_iso_100.${EXT}"
+IMGDIR=@CMAKE_CURRENT_SOURCE_DIR@/testimages
+OUTDIR=`mktemp -d /tmp/__tjbenchtest_output.XXXXXX`
+EXEDIR=@CMAKE_CURRENT_BINARY_DIR@
+BMPARG=
+NSARG=
+YUVARG=
+ALLOC=0
+ALLOCARG=
+PROGARG=
+if [ "$EXT" = "bmp" ]; then BMPARG=-bmp; fi
+
+if [ -d $OUTDIR ]; then
+	rm -rf $OUTDIR
+fi
+mkdir -p $OUTDIR
+
+while [ $# -gt 0 ]; do
+	case "$1" in
+	-yuv)
+		NSARG=-nosmooth
+		YUVARG=-yuv
+
+# NOTE: The combination of tjEncodeYUV*() and tjCompressFromYUV*() does not
+# always produce bitwise-identical results to tjCompress*() if subsampling is
+# enabled.  In both cases, if the image width or height are not evenly
+# divisible by the MCU width/height, then the bottom and/or right edge are
+# expanded.  However, the libjpeg code performs this expansion prior to
+# downsampling, and TurboJPEG performs it in tjCompressFromYUV*(), which is
+# after downsampling.  Thus, the two will agree only if the width/height along
+# each downsampled dimension is an odd number or is evenly divisible by the MCU
+# width/height.  This disagreement basically amounts to a round-off error, but
+# there is no easy way around it, so for now, we just test the only image that
+# works.  (NOTE: nightshot_iso_100 does not suffer from the above issue, but
+# it suffers from an unrelated problem whereby the combination of
+# tjDecompressToYUV*() and tjDecodeYUV*() do not produce bitwise-identical
+# results to tjDecompress*() if decompression scaling is enabled.  This latter
+# phenomenon is not yet fully understood but is also believed to be some sort
+# of round-off error.)
+		IMAGES="vgl_6548_0026a.${EXT}"
+		;;
+	-alloc)
+		ALLOCARG=-alloc
+		ALLOC=1
+		;;
+	-progressive)
+		PROGARG=-progressive
+		;;
+	esac
+	shift
+done
+
+exec >$EXEDIR/tjbenchtest$YUVARG$ALLOCARG$PROGARG.log
+
+# Standard tests
+for image in $IMAGES; do
+
+	cp $IMGDIR/$image $OUTDIR
+	basename=`basename $image .${EXT}`
+	runme $EXEDIR/cjpeg -quality 95 -dct fast $PROGARG -grayscale -outfile $OUTDIR/${basename}_GRAY_fast_cjpeg.jpg $IMGDIR/${basename}.${EXT}
+	runme $EXEDIR/cjpeg -quality 95 -dct fast $PROGARG -sample 2x2 -outfile $OUTDIR/${basename}_420_fast_cjpeg.jpg $IMGDIR/${basename}.${EXT}
+	runme $EXEDIR/cjpeg -quality 95 -dct fast $PROGARG -sample 2x1 -outfile $OUTDIR/${basename}_422_fast_cjpeg.jpg $IMGDIR/${basename}.${EXT}
+	runme $EXEDIR/cjpeg -quality 95 -dct fast $PROGARG -sample 1x1 -outfile $OUTDIR/${basename}_444_fast_cjpeg.jpg $IMGDIR/${basename}.${EXT}
+	runme $EXEDIR/cjpeg -quality 95 -dct int $PROGARG -grayscale -outfile $OUTDIR/${basename}_GRAY_accurate_cjpeg.jpg $IMGDIR/${basename}.${EXT}
+	runme $EXEDIR/cjpeg -quality 95 -dct int $PROGARG -sample 2x2 -outfile $OUTDIR/${basename}_420_accurate_cjpeg.jpg $IMGDIR/${basename}.${EXT}
+	runme $EXEDIR/cjpeg -quality 95 -dct int $PROGARG -sample 2x1 -outfile $OUTDIR/${basename}_422_accurate_cjpeg.jpg $IMGDIR/${basename}.${EXT}
+	runme $EXEDIR/cjpeg -quality 95 -dct int $PROGARG -sample 1x1 -outfile $OUTDIR/${basename}_444_accurate_cjpeg.jpg $IMGDIR/${basename}.${EXT}
+	for samp in GRAY 420 422 444; do
+		runme $EXEDIR/djpeg -rgb $NSARG $BMPARG -outfile $OUTDIR/${basename}_${samp}_default_djpeg.${EXT} $OUTDIR/${basename}_${samp}_fast_cjpeg.jpg
+		runme $EXEDIR/djpeg -dct fast -rgb $NSARG $BMPARG -outfile $OUTDIR/${basename}_${samp}_fast_djpeg.${EXT} $OUTDIR/${basename}_${samp}_fast_cjpeg.jpg
+		runme $EXEDIR/djpeg -dct int -rgb $NSARG $BMPARG -outfile $OUTDIR/${basename}_${samp}_accurate_djpeg.${EXT} $OUTDIR/${basename}_${samp}_accurate_cjpeg.jpg
+	done
+	for samp in 420 422; do
+		runme $EXEDIR/djpeg -nosmooth $BMPARG -outfile $OUTDIR/${basename}_${samp}_default_nosmooth_djpeg.${EXT} $OUTDIR/${basename}_${samp}_fast_cjpeg.jpg
+		runme $EXEDIR/djpeg -dct fast -nosmooth $BMPARG -outfile $OUTDIR/${basename}_${samp}_fast_nosmooth_djpeg.${EXT} $OUTDIR/${basename}_${samp}_fast_cjpeg.jpg
+		runme $EXEDIR/djpeg -dct int -nosmooth $BMPARG -outfile $OUTDIR/${basename}_${samp}_accurate_nosmooth_djpeg.${EXT} $OUTDIR/${basename}_${samp}_accurate_cjpeg.jpg
+	done
+
+	# Compression
+	for dct in accurate fast; do
+		runme $EXEDIR/tjbench $OUTDIR/$image 95 -rgb -quiet -benchtime 0.01 -warmup 0 -${dct}dct $YUVARG $ALLOCARG $PROGARG
+		for samp in GRAY 420 422 444; do
+			runme cmp $OUTDIR/${basename}_${samp}_Q95.jpg $OUTDIR/${basename}_${samp}_${dct}_cjpeg.jpg
+		done
+	done
+
+	for dct in fast accurate default; do
+		dctarg=-${dct}dct
+		if [ "${dct}" = "default" ]; then
+			dctarg=
+		fi
+
+		# Tiled compression & decompression
+		runme $EXEDIR/tjbench $OUTDIR/$image 95 -rgb -tile -quiet -benchtime 0.01 -warmup 0 ${dctarg} $YUVARG $ALLOCARG $PROGARG
+		for samp in GRAY 444; do
+			if [ $ALLOC = 1 ]; then
+				runme cmp $OUTDIR/${basename}_${samp}_Q95_full.${EXT} $OUTDIR/${basename}_${samp}_${dct}_djpeg.${EXT}
+				rm $OUTDIR/${basename}_${samp}_Q95_full.${EXT}
+			else
+				for i in $OUTDIR/${basename}_${samp}_Q95_[0-9]*[0-9]x[0-9]*[0-9].${EXT} \
+					$OUTDIR/${basename}_${samp}_Q95_full.${EXT}; do
+					runme cmp $i $OUTDIR/${basename}_${samp}_${dct}_djpeg.${EXT}
+					rm $i
+				done
+			fi
+		done
+		runme $EXEDIR/tjbench $OUTDIR/$image 95 -rgb -tile -quiet -benchtime 0.01 -warmup 0 -fastupsample ${dctarg} $YUVARG $ALLOCARG $PROGARG
+		for samp in 420 422; do
+			if [ $ALLOC = 1 ]; then
+				runme cmp $OUTDIR/${basename}_${samp}_Q95_full.${EXT} $OUTDIR/${basename}_${samp}_${dct}_nosmooth_djpeg.${EXT}
+				rm $OUTDIR/${basename}_${samp}_Q95_full.${EXT}
+			else
+				for i in $OUTDIR/${basename}_${samp}_Q95_[0-9]*[0-9]x[0-9]*[0-9].${EXT} \
+					$OUTDIR/${basename}_${samp}_Q95_full.${EXT}; do
+					runme cmp $i $OUTDIR/${basename}_${samp}_${dct}_nosmooth_djpeg.${EXT}
+					rm $i
+				done
+			fi
+		done
+
+		# Tiled decompression
+		for samp in GRAY 444; do
+			runme $EXEDIR/tjbench $OUTDIR/${basename}_${samp}_Q95.jpg $BMPARG -tile -quiet -benchtime 0.01 -warmup 0 ${dctarg} $YUVARG $ALLOCARG $PROGARG
+			if [ $ALLOC = 1 ]; then
+				runme cmp $OUTDIR/${basename}_${samp}_Q95_full.${EXT} $OUTDIR/${basename}_${samp}_${dct}_djpeg.${EXT}
+				rm $OUTDIR/${basename}_${samp}_Q95_full.${EXT}
+			else
+				for i in $OUTDIR/${basename}_${samp}_Q95_[0-9]*[0-9]x[0-9]*[0-9].${EXT} \
+					$OUTDIR/${basename}_${samp}_Q95_full.${EXT}; do
+					runme cmp $i $OUTDIR/${basename}_${samp}_${dct}_djpeg.${EXT}
+					rm $i
+				done
+			fi
+		done
+		for samp in 420 422; do
+			runme $EXEDIR/tjbench $OUTDIR/${basename}_${samp}_Q95.jpg $BMPARG -tile -quiet -benchtime 0.01 -warmup 0 -fastupsample ${dctarg} $YUVARG $ALLOCARG $PROGARG
+			if [ $ALLOC = 1 ]; then
+				runme cmp $OUTDIR/${basename}_${samp}_Q95_full.${EXT} $OUTDIR/${basename}_${samp}_${dct}_nosmooth_djpeg.${EXT}
+				rm $OUTDIR/${basename}_${samp}_Q95_full.${EXT}
+			else
+				for i in $OUTDIR/${basename}_${samp}_Q95_[0-9]*[0-9]x[0-9]*[0-9].${EXT} \
+					$OUTDIR/${basename}_${samp}_Q95_full.${EXT}; do
+					runme cmp $i $OUTDIR/${basename}_${samp}_${dct}_nosmooth_djpeg.${EXT}
+					rm $i
+				done
+			fi
+		done
+	done
+
+	# Scaled decompression
+	for scale in 2_1 15_8 7_4 13_8 3_2 11_8 5_4 9_8 7_8 3_4 5_8 1_2 3_8 1_4 1_8; do
+		scalearg=`echo $scale | sed 's/\_/\//g'`
+		for samp in GRAY 420 422 444; do
+			runme $EXEDIR/djpeg -rgb -scale ${scalearg} $NSARG $BMPARG -outfile $OUTDIR/${basename}_${samp}_${scale}_djpeg.${EXT} $OUTDIR/${basename}_${samp}_fast_cjpeg.jpg
+			runme $EXEDIR/tjbench $OUTDIR/${basename}_${samp}_Q95.jpg $BMPARG -scale ${scalearg} -quiet -benchtime 0.01 -warmup 0 $YUVARG $ALLOCARG $PROGARG
+			runme cmp $OUTDIR/${basename}_${samp}_Q95_${scale}.${EXT} $OUTDIR/${basename}_${samp}_${scale}_djpeg.${EXT}
+			rm $OUTDIR/${basename}_${samp}_Q95_${scale}.${EXT}
+		done
+	done
+
+	# Transforms
+	for samp in GRAY 420 422 444; do
+		runme $EXEDIR/jpegtran -flip horizontal -trim -outfile $OUTDIR/${basename}_${samp}_hflip_jpegtran.jpg $OUTDIR/${basename}_${samp}_Q95.jpg
+		runme $EXEDIR/jpegtran -flip vertical -trim -outfile $OUTDIR/${basename}_${samp}_vflip_jpegtran.jpg $OUTDIR/${basename}_${samp}_Q95.jpg
+		runme $EXEDIR/jpegtran -transpose -trim -outfile $OUTDIR/${basename}_${samp}_transpose_jpegtran.jpg $OUTDIR/${basename}_${samp}_Q95.jpg
+		runme $EXEDIR/jpegtran -transverse -trim -outfile $OUTDIR/${basename}_${samp}_transverse_jpegtran.jpg $OUTDIR/${basename}_${samp}_Q95.jpg
+		runme $EXEDIR/jpegtran -rotate 90 -trim -outfile $OUTDIR/${basename}_${samp}_rot90_jpegtran.jpg $OUTDIR/${basename}_${samp}_Q95.jpg
+		runme $EXEDIR/jpegtran -rotate 180 -trim -outfile $OUTDIR/${basename}_${samp}_rot180_jpegtran.jpg $OUTDIR/${basename}_${samp}_Q95.jpg
+		runme $EXEDIR/jpegtran -rotate 270 -trim -outfile $OUTDIR/${basename}_${samp}_rot270_jpegtran.jpg $OUTDIR/${basename}_${samp}_Q95.jpg
+	done
+	for xform in hflip vflip transpose transverse rot90 rot180 rot270; do
+		for samp in GRAY 444; do
+			runme $EXEDIR/djpeg -rgb $BMPARG -outfile $OUTDIR/${basename}_${samp}_${xform}_jpegtran.${EXT} $OUTDIR/${basename}_${samp}_${xform}_jpegtran.jpg
+			runme $EXEDIR/tjbench $OUTDIR/${basename}_${samp}_Q95.jpg $BMPARG -$xform -tile -quiet -benchtime 0.01 -warmup 0 $YUVARG $ALLOCARG $PROGARG
+			if [ $ALLOC = 1 ]; then
+				runme cmp $OUTDIR/${basename}_${samp}_Q95_full.${EXT} $OUTDIR/${basename}_${samp}_${xform}_jpegtran.${EXT}
+				rm $OUTDIR/${basename}_${samp}_Q95_full.${EXT}
+			else
+				for i in $OUTDIR/${basename}_${samp}_Q95_[0-9]*[0-9]x[0-9]*[0-9].${EXT} \
+					$OUTDIR/${basename}_${samp}_Q95_full.${EXT}; do
+					runme cmp $i $OUTDIR/${basename}_${samp}_${xform}_jpegtran.${EXT}
+					rm $i
+				done
+			fi
+		done
+		for samp in 420 422; do
+			runme $EXEDIR/djpeg -nosmooth -rgb $BMPARG -outfile $OUTDIR/${basename}_${samp}_${xform}_jpegtran.${EXT} $OUTDIR/${basename}_${samp}_${xform}_jpegtran.jpg
+			runme $EXEDIR/tjbench $OUTDIR/${basename}_${samp}_Q95.jpg $BMPARG -$xform -tile -quiet -benchtime 0.01 -warmup 0 -fastupsample $YUVARG $ALLOCARG $PROGARG
+			if [ $ALLOC = 1 ]; then
+				runme cmp $OUTDIR/${basename}_${samp}_Q95_full.${EXT} $OUTDIR/${basename}_${samp}_${xform}_jpegtran.${EXT}
+				rm $OUTDIR/${basename}_${samp}_Q95_full.${EXT}
+			else
+				for i in $OUTDIR/${basename}_${samp}_Q95_[0-9]*[0-9]x[0-9]*[0-9].${EXT} \
+					$OUTDIR/${basename}_${samp}_Q95_full.${EXT}; do
+					runme cmp $i $OUTDIR/${basename}_${samp}_${xform}_jpegtran.${EXT}
+					rm $i
+				done
+			fi
+		done
+	done
+
+	# Grayscale transform
+	for xform in hflip vflip transpose transverse rot90 rot180 rot270; do
+		for samp in GRAY 444 422 420; do
+			runme $EXEDIR/tjbench $OUTDIR/${basename}_${samp}_Q95.jpg $BMPARG -$xform -tile -quiet -benchtime 0.01 -warmup 0 -grayscale $YUVARG $ALLOCARG $PROGARG
+			if [ $ALLOC = 1 ]; then
+				runme cmp $OUTDIR/${basename}_${samp}_Q95_full.${EXT} $OUTDIR/${basename}_GRAY_${xform}_jpegtran.${EXT}
+				rm $OUTDIR/${basename}_${samp}_Q95_full.${EXT}
+			else
+				for i in $OUTDIR/${basename}_${samp}_Q95_[0-9]*[0-9]x[0-9]*[0-9].${EXT} \
+					$OUTDIR/${basename}_${samp}_Q95_full.${EXT}; do
+					runme cmp $i $OUTDIR/${basename}_GRAY_${xform}_jpegtran.${EXT}
+					rm $i
+				done
+			fi
+		done
+	done
+
+	# Transforms with scaling
+	for xform in hflip vflip transpose transverse rot90 rot180 rot270; do
+		for samp in GRAY 444 422 420; do
+			for scale in 2_1 15_8 7_4 13_8 3_2 11_8 5_4 9_8 7_8 3_4 5_8 1_2 3_8 1_4 1_8; do
+				scalearg=`echo $scale | sed 's/\_/\//g'`
+				runme $EXEDIR/djpeg -rgb -scale ${scalearg} $NSARG $BMPARG -outfile $OUTDIR/${basename}_${samp}_${xform}_${scale}_jpegtran.${EXT} $OUTDIR/${basename}_${samp}_${xform}_jpegtran.jpg
+				runme $EXEDIR/tjbench $OUTDIR/${basename}_${samp}_Q95.jpg $BMPARG -$xform -scale ${scalearg} -quiet -benchtime 0.01 -warmup 0 $YUVARG $ALLOCARG $PROGARG
+				runme cmp $OUTDIR/${basename}_${samp}_Q95_${scale}.${EXT} $OUTDIR/${basename}_${samp}_${xform}_${scale}_jpegtran.${EXT}
+				rm $OUTDIR/${basename}_${samp}_Q95_${scale}.${EXT}
+			done
+		done
+	done
+
+done
+
+echo SUCCESS!
diff --git a/3rdparty/libjpeg/src/tjbenchtest.java.in b/3rdparty/libjpeg/src/tjbenchtest.java.in
new file mode 100644
index 00000000..689561d2
--- /dev/null
+++ b/3rdparty/libjpeg/src/tjbenchtest.java.in
@@ -0,0 +1,215 @@
+#!/bin/bash
+
+set -u
+set -e
+trap onexit INT
+trap onexit TERM
+trap onexit EXIT
+
+onexit()
+{
+	if [ -d $OUTDIR ]; then
+		rm -rf $OUTDIR
+	fi
+}
+
+runme()
+{
+	echo \*\*\* $*
+	"$@"
+}
+
+IMAGES="vgl_5674_0098.bmp vgl_6434_0018a.bmp vgl_6548_0026a.bmp nightshot_iso_100.bmp"
+IMGDIR=@CMAKE_CURRENT_SOURCE_DIR@/testimages
+OUTDIR=`mktemp -d /tmp/__tjbenchtest_java_output.XXXXXX`
+EXEDIR=@CMAKE_CURRENT_BINARY_DIR@
+JAVA="@Java_JAVA_EXECUTABLE@"
+JAVAARGS="-cp $EXEDIR/java/turbojpeg.jar -Djava.library.path=$EXEDIR"
+BMPARG=
+NSARG=
+YUVARG=
+PROGARG=
+
+if [ -d $OUTDIR ]; then
+	rm -rf $OUTDIR
+fi
+mkdir -p $OUTDIR
+
+while [ $# -gt 0 ]; do
+	case "$1" in
+	-yuv)
+		NSARG=-nosmooth
+		YUVARG=-yuv
+
+# NOTE: The combination of tjEncodeYUV*() and tjCompressFromYUV*() does not
+# always produce bitwise-identical results to tjCompress*() if subsampling is
+# enabled.  In both cases, if the image width or height are not evenly
+# divisible by the MCU width/height, then the bottom and/or right edge are
+# expanded.  However, the libjpeg code performs this expansion prior to
+# downsampling, and TurboJPEG performs it in tjCompressFromYUV*(), which is
+# after downsampling.  Thus, the two will agree only if the width/height along
+# each downsampled dimension is an odd number or is evenly divisible by the MCU
+# width/height.  This disagreement basically amounts to a round-off error, but
+# there is no easy way around it, so for now, we just test the only image that
+# works.  (NOTE: nightshot_iso_100 does not suffer from the above issue, but
+# it suffers from an unrelated problem whereby the combination of
+# tjDecompressToYUV*() and tjDecodeYUV*() do not produce bitwise-identical
+# results to tjDecompress*() if decompression scaling is enabled.  This latter
+# phenomenon is not yet fully understood but is also believed to be some sort
+# of round-off error.)
+		IMAGES="vgl_6548_0026a.bmp"
+		;;
+	-progressive)
+		PROGARG=-progressive
+		;;
+	esac
+	shift
+done
+
+exec >$EXEDIR/tjbenchtest-java$YUVARG$PROGARG.log
+
+# Standard tests
+for image in $IMAGES; do
+
+	cp $IMGDIR/$image $OUTDIR
+	basename=`basename $image .bmp`
+	runme $EXEDIR/cjpeg -quality 95 -dct fast $PROGARG -grayscale -outfile $OUTDIR/${basename}_GRAY_fast_cjpeg.jpg $IMGDIR/${basename}.bmp
+	runme $EXEDIR/cjpeg -quality 95 -dct fast $PROGARG -sample 2x2 -outfile $OUTDIR/${basename}_420_fast_cjpeg.jpg $IMGDIR/${basename}.bmp
+	runme $EXEDIR/cjpeg -quality 95 -dct fast $PROGARG -sample 2x1 -outfile $OUTDIR/${basename}_422_fast_cjpeg.jpg $IMGDIR/${basename}.bmp
+	runme $EXEDIR/cjpeg -quality 95 -dct fast $PROGARG -sample 1x1 -outfile $OUTDIR/${basename}_444_fast_cjpeg.jpg $IMGDIR/${basename}.bmp
+	runme $EXEDIR/cjpeg -quality 95 -dct int $PROGARG -grayscale -outfile $OUTDIR/${basename}_GRAY_accurate_cjpeg.jpg $IMGDIR/${basename}.bmp
+	runme $EXEDIR/cjpeg -quality 95 -dct int $PROGARG -sample 2x2 -outfile $OUTDIR/${basename}_420_accurate_cjpeg.jpg $IMGDIR/${basename}.bmp
+	runme $EXEDIR/cjpeg -quality 95 -dct int $PROGARG -sample 2x1 -outfile $OUTDIR/${basename}_422_accurate_cjpeg.jpg $IMGDIR/${basename}.bmp
+	runme $EXEDIR/cjpeg -quality 95 -dct int $PROGARG -sample 1x1 -outfile $OUTDIR/${basename}_444_accurate_cjpeg.jpg $IMGDIR/${basename}.bmp
+	for samp in GRAY 420 422 444; do
+		runme $EXEDIR/djpeg -rgb -bmp -outfile $OUTDIR/${basename}_${samp}_default_djpeg.bmp $OUTDIR/${basename}_${samp}_fast_cjpeg.jpg
+		runme $EXEDIR/djpeg -dct fast -rgb -bmp -outfile $OUTDIR/${basename}_${samp}_fast_djpeg.bmp $OUTDIR/${basename}_${samp}_fast_cjpeg.jpg
+		runme $EXEDIR/djpeg -dct int -rgb -bmp -outfile $OUTDIR/${basename}_${samp}_accurate_djpeg.bmp $OUTDIR/${basename}_${samp}_accurate_cjpeg.jpg
+	done
+	for samp in 420 422; do
+		runme $EXEDIR/djpeg -nosmooth -bmp -outfile $OUTDIR/${basename}_${samp}_default_nosmooth_djpeg.bmp $OUTDIR/${basename}_${samp}_fast_cjpeg.jpg
+		runme $EXEDIR/djpeg -dct fast -nosmooth -bmp -outfile $OUTDIR/${basename}_${samp}_fast_nosmooth_djpeg.bmp $OUTDIR/${basename}_${samp}_fast_cjpeg.jpg
+		runme $EXEDIR/djpeg -dct int -nosmooth -bmp -outfile $OUTDIR/${basename}_${samp}_accurate_nosmooth_djpeg.bmp $OUTDIR/${basename}_${samp}_accurate_cjpeg.jpg
+	done
+
+	# Compression
+	for dct in accurate fast; do
+		runme "$JAVA" $JAVAARGS TJBench $OUTDIR/$image 95 -rgb -quiet -benchtime 0.01 -warmup 0 -${dct}dct $YUVARG $PROGARG
+		for samp in GRAY 420 422 444; do
+			runme cmp $OUTDIR/${basename}_${samp}_Q95.jpg $OUTDIR/${basename}_${samp}_${dct}_cjpeg.jpg
+		done
+	done
+
+	for dct in fast accurate default; do
+		dctarg=-${dct}dct
+		if [ "${dct}" = "default" ]; then
+			dctarg=
+		fi
+
+		# Tiled compression & decompression
+		runme "$JAVA" $JAVAARGS TJBench $OUTDIR/$image 95 -rgb -tile -quiet -benchtime 0.01 -warmup 0 ${dctarg} $YUVARG $PROGARG
+		for samp in GRAY 444; do
+			for i in $OUTDIR/${basename}_${samp}_Q95_[0-9]*[0-9]x[0-9]*[0-9].bmp \
+				$OUTDIR/${basename}_${samp}_Q95_full.bmp; do
+				runme cmp -i 54:54 $i $OUTDIR/${basename}_${samp}_${dct}_djpeg.bmp
+				rm $i
+			done
+		done
+		runme "$JAVA" $JAVAARGS TJBench $OUTDIR/$image 95 -rgb -tile -quiet -benchtime 0.01 -warmup 0 -fastupsample ${dctarg} $YUVARG $PROGARG
+		for samp in 420 422; do
+			for i in $OUTDIR/${basename}_${samp}_Q95_[0-9]*[0-9]x[0-9]*[0-9].bmp \
+				$OUTDIR/${basename}_${samp}_Q95_full.bmp; do
+				runme cmp -i 54:54 $i $OUTDIR/${basename}_${samp}_${dct}_nosmooth_djpeg.bmp
+				rm $i
+			done
+		done
+
+		# Tiled decompression
+		for samp in GRAY 444; do
+			runme "$JAVA" $JAVAARGS TJBench $OUTDIR/${basename}_${samp}_Q95.jpg -tile -quiet -benchtime 0.01 -warmup 0 ${dctarg} $YUVARG $PROGARG
+			for i in $OUTDIR/${basename}_${samp}_Q95_[0-9]*[0-9]x[0-9]*[0-9].bmp \
+				$OUTDIR/${basename}_${samp}_Q95_full.bmp; do
+				runme cmp -i 54:54 $i $OUTDIR/${basename}_${samp}_${dct}_djpeg.bmp
+				rm $i
+			done
+		done
+		for samp in 420 422; do
+			runme "$JAVA" $JAVAARGS TJBench $OUTDIR/${basename}_${samp}_Q95.jpg -tile -quiet -benchtime 0.01 -warmup 0 -fastupsample ${dctarg} $YUVARG $PROGARG
+			for i in $OUTDIR/${basename}_${samp}_Q95_[0-9]*[0-9]x[0-9]*[0-9].bmp \
+				$OUTDIR/${basename}_${samp}_Q95_full.bmp; do
+				runme cmp $i -i 54:54 $OUTDIR/${basename}_${samp}_${dct}_nosmooth_djpeg.bmp
+				rm $i
+			done
+		done
+	done
+
+	# Scaled decompression
+	for scale in 2_1 15_8 7_4 13_8 3_2 11_8 5_4 9_8 7_8 3_4 5_8 1_2 3_8 1_4 1_8; do
+		scalearg=`echo $scale | sed 's/\_/\//g'`
+		for samp in GRAY 420 422 444; do
+			runme $EXEDIR/djpeg -rgb -scale ${scalearg} $NSARG -bmp -outfile $OUTDIR/${basename}_${samp}_${scale}_djpeg.bmp $OUTDIR/${basename}_${samp}_fast_cjpeg.jpg
+			runme "$JAVA" $JAVAARGS TJBench $OUTDIR/${basename}_${samp}_Q95.jpg -scale ${scalearg} -quiet -benchtime 0.01 -warmup 0 $YUVARG $PROGARG
+			runme cmp -i 54:54 $OUTDIR/${basename}_${samp}_Q95_${scale}.bmp $OUTDIR/${basename}_${samp}_${scale}_djpeg.bmp
+			rm $OUTDIR/${basename}_${samp}_Q95_${scale}.bmp
+		done
+	done
+
+	# Transforms
+	for samp in GRAY 420 422 444; do
+		runme $EXEDIR/jpegtran -flip horizontal -trim -outfile $OUTDIR/${basename}_${samp}_hflip_jpegtran.jpg $OUTDIR/${basename}_${samp}_Q95.jpg
+		runme $EXEDIR/jpegtran -flip vertical -trim -outfile $OUTDIR/${basename}_${samp}_vflip_jpegtran.jpg $OUTDIR/${basename}_${samp}_Q95.jpg
+		runme $EXEDIR/jpegtran -transpose -trim -outfile $OUTDIR/${basename}_${samp}_transpose_jpegtran.jpg $OUTDIR/${basename}_${samp}_Q95.jpg
+		runme $EXEDIR/jpegtran -transverse -trim -outfile $OUTDIR/${basename}_${samp}_transverse_jpegtran.jpg $OUTDIR/${basename}_${samp}_Q95.jpg
+		runme $EXEDIR/jpegtran -rotate 90 -trim -outfile $OUTDIR/${basename}_${samp}_rot90_jpegtran.jpg $OUTDIR/${basename}_${samp}_Q95.jpg
+		runme $EXEDIR/jpegtran -rotate 180 -trim -outfile $OUTDIR/${basename}_${samp}_rot180_jpegtran.jpg $OUTDIR/${basename}_${samp}_Q95.jpg
+		runme $EXEDIR/jpegtran -rotate 270 -trim -outfile $OUTDIR/${basename}_${samp}_rot270_jpegtran.jpg $OUTDIR/${basename}_${samp}_Q95.jpg
+	done
+	for xform in hflip vflip transpose transverse rot90 rot180 rot270; do
+		for samp in GRAY 444; do
+			runme $EXEDIR/djpeg -rgb -bmp -outfile $OUTDIR/${basename}_${samp}_${xform}_jpegtran.bmp $OUTDIR/${basename}_${samp}_${xform}_jpegtran.jpg
+			runme "$JAVA" $JAVAARGS TJBench $OUTDIR/${basename}_${samp}_Q95.jpg -$xform -tile -quiet -benchtime 0.01 -warmup 0 $YUVARG $PROGARG
+			for i in $OUTDIR/${basename}_${samp}_Q95_[0-9]*[0-9]x[0-9]*[0-9].bmp \
+				$OUTDIR/${basename}_${samp}_Q95_full.bmp; do
+				runme cmp -i 54:54 $i $OUTDIR/${basename}_${samp}_${xform}_jpegtran.bmp
+				rm $i
+			done
+		done
+		for samp in 420 422; do
+			runme $EXEDIR/djpeg -nosmooth -rgb -bmp -outfile $OUTDIR/${basename}_${samp}_${xform}_jpegtran.bmp $OUTDIR/${basename}_${samp}_${xform}_jpegtran.jpg
+			runme "$JAVA" $JAVAARGS TJBench $OUTDIR/${basename}_${samp}_Q95.jpg -$xform -tile -quiet -benchtime 0.01 -warmup 0 -fastupsample $YUVARG $PROGARG
+			for i in $OUTDIR/${basename}_${samp}_Q95_[0-9]*[0-9]x[0-9]*[0-9].bmp \
+				$OUTDIR/${basename}_${samp}_Q95_full.bmp; do
+				runme cmp -i 54:54 $i $OUTDIR/${basename}_${samp}_${xform}_jpegtran.bmp
+				rm $i
+			done
+		done
+	done
+
+	# Grayscale transform
+	for xform in hflip vflip transpose transverse rot90 rot180 rot270; do
+		for samp in GRAY 444 422 420; do
+			runme "$JAVA" $JAVAARGS TJBench $OUTDIR/${basename}_${samp}_Q95.jpg -$xform -tile -quiet -benchtime 0.01 -warmup 0 -grayscale $YUVARG $PROGARG
+			for i in $OUTDIR/${basename}_${samp}_Q95_[0-9]*[0-9]x[0-9]*[0-9].bmp \
+				$OUTDIR/${basename}_${samp}_Q95_full.bmp; do
+				runme cmp -i 54:54 $i $OUTDIR/${basename}_GRAY_${xform}_jpegtran.bmp
+				rm $i
+			done
+		done
+	done
+
+	# Transforms with scaling
+	for xform in hflip vflip transpose transverse rot90 rot180 rot270; do
+		for samp in GRAY 444 422 420; do
+			for scale in 2_1 15_8 7_4 13_8 3_2 11_8 5_4 9_8 7_8 3_4 5_8 1_2 3_8 1_4 1_8; do
+				scalearg=`echo $scale | sed 's/\_/\//g'`
+				runme $EXEDIR/djpeg -rgb -scale ${scalearg} $NSARG -bmp -outfile $OUTDIR/${basename}_${samp}_${xform}_${scale}_jpegtran.bmp $OUTDIR/${basename}_${samp}_${xform}_jpegtran.jpg
+				runme "$JAVA" $JAVAARGS TJBench $OUTDIR/${basename}_${samp}_Q95.jpg -$xform -scale ${scalearg} -quiet -benchtime 0.01 -warmup 0 $YUVARG $PROGARG
+				runme cmp -i 54:54 $OUTDIR/${basename}_${samp}_Q95_${scale}.bmp $OUTDIR/${basename}_${samp}_${xform}_${scale}_jpegtran.bmp
+				rm $OUTDIR/${basename}_${samp}_Q95_${scale}.bmp
+			done
+		done
+	done
+
+done
+
+echo SUCCESS!
diff --git a/3rdparty/libjpeg/src/tjexample.c b/3rdparty/libjpeg/src/tjexample.c
new file mode 100644
index 00000000..ef32c939
--- /dev/null
+++ b/3rdparty/libjpeg/src/tjexample.c
@@ -0,0 +1,396 @@
+/*
+ * Copyright (C)2011-2012, 2014-2015, 2017, 2019 D. R. Commander.
+ *                                               All Rights Reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright notice,
+ *   this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright notice,
+ *   this list of conditions and the following disclaimer in the documentation
+ *   and/or other materials provided with the distribution.
+ * - Neither the name of the libjpeg-turbo Project nor the names of its
+ *   contributors may be used to endorse or promote products derived from this
+ *   software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE 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 HOLDERS 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.
+ */
+
+/*
+ * This program demonstrates how to compress, decompress, and transform JPEG
+ * images using the TurboJPEG C API
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <turbojpeg.h>
+
+
+#ifdef _WIN32
+#define strcasecmp  stricmp
+#define strncasecmp  strnicmp
+#endif
+
+#define THROW(action, message) { \
+  printf("ERROR in line %d while %s:\n%s\n", __LINE__, action, message); \
+  retval = -1;  goto bailout; \
+}
+
+#define THROW_TJ(action)  THROW(action, tjGetErrorStr2(tjInstance))
+
+#define THROW_UNIX(action)  THROW(action, strerror(errno))
+
+#define DEFAULT_SUBSAMP  TJSAMP_444
+#define DEFAULT_QUALITY  95
+
+
+const char *subsampName[TJ_NUMSAMP] = {
+  "4:4:4", "4:2:2", "4:2:0", "Grayscale", "4:4:0", "4:1:1"
+};
+
+const char *colorspaceName[TJ_NUMCS] = {
+  "RGB", "YCbCr", "GRAY", "CMYK", "YCCK"
+};
+
+tjscalingfactor *scalingFactors = NULL;
+int numScalingFactors = 0;
+
+
+/* DCT filter example.  This produces a negative of the image. */
+
+static int customFilter(short *coeffs, tjregion arrayRegion,
+                        tjregion planeRegion, int componentIndex,
+                        int transformIndex, tjtransform *transform)
+{
+  int i;
+
+  for (i = 0; i < arrayRegion.w * arrayRegion.h; i++)
+    coeffs[i] = -coeffs[i];
+
+  return 0;
+}
+
+
+static void usage(char *programName)
+{
+  int i;
+
+  printf("\nUSAGE: %s <Input image> <Output image> [options]\n\n",
+         programName);
+
+  printf("Input and output images can be in Windows BMP or PBMPLUS (PPM/PGM) format.  If\n");
+  printf("either filename ends in a .jpg extension, then the TurboJPEG API will be used\n");
+  printf("to compress or decompress the image.\n\n");
+
+  printf("Compression Options (used if the output image is a JPEG image)\n");
+  printf("--------------------------------------------------------------\n\n");
+
+  printf("-subsamp <444|422|420|gray> = Apply this level of chrominance subsampling when\n");
+  printf("     compressing the output image.  The default is to use the same level of\n");
+  printf("     subsampling as in the input image, if the input image is also a JPEG\n");
+  printf("     image, or to use grayscale if the input image is a grayscale non-JPEG\n");
+  printf("     image, or to use %s subsampling otherwise.\n\n",
+         subsampName[DEFAULT_SUBSAMP]);
+
+  printf("-q <1-100> = Compress the output image with this JPEG quality level\n");
+  printf("     (default = %d).\n\n", DEFAULT_QUALITY);
+
+  printf("Decompression Options (used if the input image is a JPEG image)\n");
+  printf("---------------------------------------------------------------\n\n");
+
+  printf("-scale M/N = Scale the input image by a factor of M/N when decompressing it.\n");
+  printf("(M/N = ");
+  for (i = 0; i < numScalingFactors; i++) {
+    printf("%d/%d", scalingFactors[i].num, scalingFactors[i].denom);
+    if (numScalingFactors == 2 && i != numScalingFactors - 1)
+      printf(" or ");
+    else if (numScalingFactors > 2) {
+      if (i != numScalingFactors - 1)
+        printf(", ");
+      if (i == numScalingFactors - 2)
+        printf("or ");
+    }
+  }
+  printf(")\n\n");
+
+  printf("-hflip, -vflip, -transpose, -transverse, -rot90, -rot180, -rot270 =\n");
+  printf("     Perform one of these lossless transform operations on the input image\n");
+  printf("     prior to decompressing it (these options are mutually exclusive.)\n\n");
+
+  printf("-grayscale = Perform lossless grayscale conversion on the input image prior\n");
+  printf("     to decompressing it (can be combined with the other transform operations\n");
+  printf("     above.)\n\n");
+
+  printf("-crop WxH+X+Y = Perform lossless cropping on the input image prior to\n");
+  printf("     decompressing it.  X and Y specify the upper left corner of the cropping\n");
+  printf("     region, and W and H specify the width and height of the cropping region.\n");
+  printf("     X and Y must be evenly divible by the MCU block size (8x8 if the input\n");
+  printf("     image was compressed using no subsampling or grayscale, 16x8 if it was\n");
+  printf("     compressed using 4:2:2 subsampling, or 16x16 if it was compressed using\n");
+  printf("     4:2:0 subsampling.)\n\n");
+
+  printf("General Options\n");
+  printf("---------------\n\n");
+
+  printf("-fastupsample = Use the fastest chrominance upsampling algorithm available in\n");
+  printf("     the underlying codec.\n\n");
+
+  printf("-fastdct = Use the fastest DCT/IDCT algorithms available in the underlying\n");
+  printf("     codec.\n\n");
+
+  printf("-accuratedct = Use the most accurate DCT/IDCT algorithms available in the\n");
+  printf("     underlying codec.\n\n");
+
+  exit(1);
+}
+
+
+int main(int argc, char **argv)
+{
+  tjscalingfactor scalingFactor = { 1, 1 };
+  int outSubsamp = -1, outQual = -1;
+  tjtransform xform;
+  int flags = 0;
+  int width, height;
+  char *inFormat, *outFormat;
+  FILE *jpegFile = NULL;
+  unsigned char *imgBuf = NULL, *jpegBuf = NULL;
+  int retval = 0, i, pixelFormat = TJPF_UNKNOWN;
+  tjhandle tjInstance = NULL;
+
+  if ((scalingFactors = tjGetScalingFactors(&numScalingFactors)) == NULL)
+    THROW_TJ("getting scaling factors");
+  memset(&xform, 0, sizeof(tjtransform));
+
+  if (argc < 3)
+    usage(argv[0]);
+
+  /* Parse arguments. */
+  for (i = 3; i < argc; i++) {
+    if (!strncasecmp(argv[i], "-sc", 3) && i < argc - 1) {
+      int match = 0, temp1 = 0, temp2 = 0, j;
+
+      if (sscanf(argv[++i], "%d/%d", &temp1, &temp2) < 2)
+        usage(argv[0]);
+      for (j = 0; j < numScalingFactors; j++) {
+        if ((double)temp1 / (double)temp2 == (double)scalingFactors[j].num /
+                                             (double)scalingFactors[j].denom) {
+          scalingFactor = scalingFactors[j];
+          match = 1;
+          break;
+        }
+      }
+      if (match != 1)
+        usage(argv[0]);
+    } else if (!strncasecmp(argv[i], "-su", 3) && i < argc - 1) {
+      i++;
+      if (!strncasecmp(argv[i], "g", 1))
+        outSubsamp = TJSAMP_GRAY;
+      else if (!strcasecmp(argv[i], "444"))
+        outSubsamp = TJSAMP_444;
+      else if (!strcasecmp(argv[i], "422"))
+        outSubsamp = TJSAMP_422;
+      else if (!strcasecmp(argv[i], "420"))
+        outSubsamp = TJSAMP_420;
+      else
+        usage(argv[0]);
+    } else if (!strncasecmp(argv[i], "-q", 2) && i < argc - 1) {
+      outQual = atoi(argv[++i]);
+      if (outQual < 1 || outQual > 100)
+        usage(argv[0]);
+    } else if (!strncasecmp(argv[i], "-g", 2))
+      xform.options |= TJXOPT_GRAY;
+    else if (!strcasecmp(argv[i], "-hflip"))
+      xform.op = TJXOP_HFLIP;
+    else if (!strcasecmp(argv[i], "-vflip"))
+      xform.op = TJXOP_VFLIP;
+    else if (!strcasecmp(argv[i], "-transpose"))
+      xform.op = TJXOP_TRANSPOSE;
+    else if (!strcasecmp(argv[i], "-transverse"))
+      xform.op = TJXOP_TRANSVERSE;
+    else if (!strcasecmp(argv[i], "-rot90"))
+      xform.op = TJXOP_ROT90;
+    else if (!strcasecmp(argv[i], "-rot180"))
+      xform.op = TJXOP_ROT180;
+    else if (!strcasecmp(argv[i], "-rot270"))
+      xform.op = TJXOP_ROT270;
+    else if (!strcasecmp(argv[i], "-custom"))
+      xform.customFilter = customFilter;
+    else if (!strncasecmp(argv[i], "-c", 2) && i < argc - 1) {
+      if (sscanf(argv[++i], "%dx%d+%d+%d", &xform.r.w, &xform.r.h, &xform.r.x,
+                 &xform.r.y) < 4 ||
+          xform.r.x < 0 || xform.r.y < 0 || xform.r.w < 1 || xform.r.h < 1)
+        usage(argv[0]);
+      xform.options |= TJXOPT_CROP;
+    } else if (!strcasecmp(argv[i], "-fastupsample")) {
+      printf("Using fast upsampling code\n");
+      flags |= TJFLAG_FASTUPSAMPLE;
+    } else if (!strcasecmp(argv[i], "-fastdct")) {
+      printf("Using fastest DCT/IDCT algorithm\n");
+      flags |= TJFLAG_FASTDCT;
+    } else if (!strcasecmp(argv[i], "-accuratedct")) {
+      printf("Using most accurate DCT/IDCT algorithm\n");
+      flags |= TJFLAG_ACCURATEDCT;
+    } else usage(argv[0]);
+  }
+
+  /* Determine input and output image formats based on file extensions. */
+  inFormat = strrchr(argv[1], '.');
+  outFormat = strrchr(argv[2], '.');
+  if (inFormat == NULL || outFormat == NULL || strlen(inFormat) < 2 ||
+      strlen(outFormat) < 2)
+    usage(argv[0]);
+  inFormat = &inFormat[1];
+  outFormat = &outFormat[1];
+
+  if (!strcasecmp(inFormat, "jpg")) {
+    /* Input image is a JPEG image.  Decompress and/or transform it. */
+    long size;
+    int inSubsamp, inColorspace;
+    int doTransform = (xform.op != TJXOP_NONE || xform.options != 0 ||
+                       xform.customFilter != NULL);
+    unsigned long jpegSize;
+
+    /* Read the JPEG file into memory. */
+    if ((jpegFile = fopen(argv[1], "rb")) == NULL)
+      THROW_UNIX("opening input file");
+    if (fseek(jpegFile, 0, SEEK_END) < 0 || ((size = ftell(jpegFile)) < 0) ||
+        fseek(jpegFile, 0, SEEK_SET) < 0)
+      THROW_UNIX("determining input file size");
+    if (size == 0)
+      THROW("determining input file size", "Input file contains no data");
+    jpegSize = (unsigned long)size;
+    if ((jpegBuf = (unsigned char *)tjAlloc(jpegSize)) == NULL)
+      THROW_UNIX("allocating JPEG buffer");
+    if (fread(jpegBuf, jpegSize, 1, jpegFile) < 1)
+      THROW_UNIX("reading input file");
+    fclose(jpegFile);  jpegFile = NULL;
+
+    if (doTransform) {
+      /* Transform it. */
+      unsigned char *dstBuf = NULL;  /* Dynamically allocate the JPEG buffer */
+      unsigned long dstSize = 0;
+
+      if ((tjInstance = tjInitTransform()) == NULL)
+        THROW_TJ("initializing transformer");
+      xform.options |= TJXOPT_TRIM;
+      if (tjTransform(tjInstance, jpegBuf, jpegSize, 1, &dstBuf, &dstSize,
+                      &xform, flags) < 0)
+        THROW_TJ("transforming input image");
+      tjFree(jpegBuf);
+      jpegBuf = dstBuf;
+      jpegSize = dstSize;
+    } else {
+      if ((tjInstance = tjInitDecompress()) == NULL)
+        THROW_TJ("initializing decompressor");
+    }
+
+    if (tjDecompressHeader3(tjInstance, jpegBuf, jpegSize, &width, &height,
+                            &inSubsamp, &inColorspace) < 0)
+      THROW_TJ("reading JPEG header");
+
+    printf("%s Image:  %d x %d pixels, %s subsampling, %s colorspace\n",
+           (doTransform ? "Transformed" : "Input"), width, height,
+           subsampName[inSubsamp], colorspaceName[inColorspace]);
+
+    if (!strcasecmp(outFormat, "jpg") && doTransform &&
+        scalingFactor.num == 1 && scalingFactor.denom == 1 && outSubsamp < 0 &&
+        outQual < 0) {
+      /* Input image has been transformed, and no re-compression options
+         have been selected.  Write the transformed image to disk and exit. */
+      if ((jpegFile = fopen(argv[2], "wb")) == NULL)
+        THROW_UNIX("opening output file");
+      if (fwrite(jpegBuf, jpegSize, 1, jpegFile) < 1)
+        THROW_UNIX("writing output file");
+      fclose(jpegFile);  jpegFile = NULL;
+      goto bailout;
+    }
+
+    /* Scaling and/or a non-JPEG output image format and/or compression options
+       have been selected, so we need to decompress the input/transformed
+       image. */
+    width = TJSCALED(width, scalingFactor);
+    height = TJSCALED(height, scalingFactor);
+    if (outSubsamp < 0)
+      outSubsamp = inSubsamp;
+
+    pixelFormat = TJPF_BGRX;
+    if ((imgBuf = (unsigned char *)tjAlloc(width * height *
+                                           tjPixelSize[pixelFormat])) == NULL)
+      THROW_UNIX("allocating uncompressed image buffer");
+
+    if (tjDecompress2(tjInstance, jpegBuf, jpegSize, imgBuf, width, 0, height,
+                      pixelFormat, flags) < 0)
+      THROW_TJ("decompressing JPEG image");
+    tjFree(jpegBuf);  jpegBuf = NULL;
+    tjDestroy(tjInstance);  tjInstance = NULL;
+  } else {
+    /* Input image is not a JPEG image.  Load it into memory. */
+    if ((imgBuf = tjLoadImage(argv[1], &width, 1, &height, &pixelFormat,
+                              0)) == NULL)
+      THROW_TJ("loading input image");
+    if (outSubsamp < 0) {
+      if (pixelFormat == TJPF_GRAY)
+        outSubsamp = TJSAMP_GRAY;
+      else
+        outSubsamp = TJSAMP_444;
+    }
+    printf("Input Image:  %d x %d pixels\n", width, height);
+  }
+
+  printf("Output Image (%s):  %d x %d pixels", outFormat, width, height);
+
+  if (!strcasecmp(outFormat, "jpg")) {
+    /* Output image format is JPEG.  Compress the uncompressed image. */
+    unsigned long jpegSize = 0;
+
+    jpegBuf = NULL;  /* Dynamically allocate the JPEG buffer */
+
+    if (outQual < 0)
+      outQual = DEFAULT_QUALITY;
+    printf(", %s subsampling, quality = %d\n", subsampName[outSubsamp],
+           outQual);
+
+    if ((tjInstance = tjInitCompress()) == NULL)
+      THROW_TJ("initializing compressor");
+    if (tjCompress2(tjInstance, imgBuf, width, 0, height, pixelFormat,
+                    &jpegBuf, &jpegSize, outSubsamp, outQual, flags) < 0)
+      THROW_TJ("compressing image");
+    tjDestroy(tjInstance);  tjInstance = NULL;
+
+    /* Write the JPEG image to disk. */
+    if ((jpegFile = fopen(argv[2], "wb")) == NULL)
+      THROW_UNIX("opening output file");
+    if (fwrite(jpegBuf, jpegSize, 1, jpegFile) < 1)
+      THROW_UNIX("writing output file");
+    tjDestroy(tjInstance);  tjInstance = NULL;
+    fclose(jpegFile);  jpegFile = NULL;
+    tjFree(jpegBuf);  jpegBuf = NULL;
+  } else {
+    /* Output image format is not JPEG.  Save the uncompressed image
+       directly to disk. */
+    printf("\n");
+    if (tjSaveImage(argv[2], imgBuf, width, 0, height, pixelFormat, 0) < 0)
+      THROW_TJ("saving output image");
+  }
+
+bailout:
+  tjFree(imgBuf);
+  if (tjInstance) tjDestroy(tjInstance);
+  tjFree(jpegBuf);
+  if (jpegFile) fclose(jpegFile);
+  return retval;
+}
diff --git a/3rdparty/libjpeg/src/tjexampletest.in b/3rdparty/libjpeg/src/tjexampletest.in
new file mode 100644
index 00000000..0d3047e2
--- /dev/null
+++ b/3rdparty/libjpeg/src/tjexampletest.in
@@ -0,0 +1,149 @@
+#!/bin/bash
+
+set -u
+set -e
+trap onexit INT
+trap onexit TERM
+trap onexit EXIT
+
+onexit()
+{
+	if [ -d $OUTDIR ]; then
+		rm -rf $OUTDIR
+	fi
+}
+
+runme()
+{
+	echo \*\*\* $*
+	$*
+}
+
+IMAGES="vgl_5674_0098.bmp vgl_6434_0018a.bmp vgl_6548_0026a.bmp nightshot_iso_100.bmp"
+IMGDIR=@CMAKE_CURRENT_SOURCE_DIR@/testimages
+OUTDIR=`mktemp -d /tmp/__tjexampletest_output.XXXXXX`
+EXEDIR=@CMAKE_CURRENT_BINARY_DIR@
+
+if [ -d $OUTDIR ]; then
+	rm -rf $OUTDIR
+fi
+mkdir -p $OUTDIR
+
+exec >$EXEDIR/tjexampletest.log
+
+for image in $IMAGES; do
+
+	cp $IMGDIR/$image $OUTDIR
+	basename=`basename $image .bmp`
+	runme $EXEDIR/cjpeg -quality 95 -dct fast -grayscale -outfile $OUTDIR/${basename}_GRAY_fast_cjpeg.jpg $IMGDIR/${basename}.bmp
+	runme $EXEDIR/cjpeg -quality 95 -dct fast -sample 2x2 -outfile $OUTDIR/${basename}_420_fast_cjpeg.jpg $IMGDIR/${basename}.bmp
+	runme $EXEDIR/cjpeg -quality 95 -dct fast -sample 2x1 -outfile $OUTDIR/${basename}_422_fast_cjpeg.jpg $IMGDIR/${basename}.bmp
+	runme $EXEDIR/cjpeg -quality 95 -dct fast -sample 1x1 -outfile $OUTDIR/${basename}_444_fast_cjpeg.jpg $IMGDIR/${basename}.bmp
+	runme $EXEDIR/cjpeg -quality 95 -dct int -grayscale -outfile $OUTDIR/${basename}_GRAY_accurate_cjpeg.jpg $IMGDIR/${basename}.bmp
+	runme $EXEDIR/cjpeg -quality 95 -dct int -sample 2x2 -outfile $OUTDIR/${basename}_420_accurate_cjpeg.jpg $IMGDIR/${basename}.bmp
+	runme $EXEDIR/cjpeg -quality 95 -dct int -sample 2x1 -outfile $OUTDIR/${basename}_422_accurate_cjpeg.jpg $IMGDIR/${basename}.bmp
+	runme $EXEDIR/cjpeg -quality 95 -dct int -sample 1x1 -outfile $OUTDIR/${basename}_444_accurate_cjpeg.jpg $IMGDIR/${basename}.bmp
+	for samp in GRAY 420 422 444; do
+		runme $EXEDIR/djpeg -rgb -bmp -outfile $OUTDIR/${basename}_${samp}_default_djpeg.bmp $OUTDIR/${basename}_${samp}_fast_cjpeg.jpg
+		runme $EXEDIR/djpeg -dct fast -rgb -bmp -outfile $OUTDIR/${basename}_${samp}_fast_djpeg.bmp $OUTDIR/${basename}_${samp}_fast_cjpeg.jpg
+		runme $EXEDIR/djpeg -dct int -rgb -bmp -outfile $OUTDIR/${basename}_${samp}_accurate_djpeg.bmp $OUTDIR/${basename}_${samp}_accurate_cjpeg.jpg
+	done
+	for samp in 420 422; do
+		runme $EXEDIR/djpeg -nosmooth -bmp -outfile $OUTDIR/${basename}_${samp}_default_nosmooth_djpeg.bmp $OUTDIR/${basename}_${samp}_fast_cjpeg.jpg
+		runme $EXEDIR/djpeg -dct fast -nosmooth -bmp -outfile $OUTDIR/${basename}_${samp}_fast_nosmooth_djpeg.bmp $OUTDIR/${basename}_${samp}_fast_cjpeg.jpg
+		runme $EXEDIR/djpeg -dct int -nosmooth -bmp -outfile $OUTDIR/${basename}_${samp}_accurate_nosmooth_djpeg.bmp $OUTDIR/${basename}_${samp}_accurate_cjpeg.jpg
+	done
+
+	# Compression
+	for dct in fast accurate; do
+		for samp in GRAY 420 422 444; do
+			runme $EXEDIR/tjexample $OUTDIR/$image $OUTDIR/${basename}_${samp}_${dct}.jpg -q 95 -subsamp ${samp} -${dct}dct
+			runme cmp $OUTDIR/${basename}_${samp}_${dct}.jpg $OUTDIR/${basename}_${samp}_${dct}_cjpeg.jpg
+		done
+	done
+
+	# Decompression
+	for dct in fast accurate default; do
+		srcdct=${dct}
+		dctarg=-${dct}dct
+		if [ "${dct}" = "default" ]; then
+			srcdct=fast
+			dctarg=
+		fi
+		for samp in GRAY 420 422 444; do
+			runme $EXEDIR/tjexample $OUTDIR/${basename}_${samp}_${srcdct}.jpg $OUTDIR/${basename}_${samp}_${dct}.bmp ${dctarg}
+			runme cmp -i 54:54 $OUTDIR/${basename}_${samp}_${dct}.bmp $OUTDIR/${basename}_${samp}_${dct}_djpeg.bmp
+			rm $OUTDIR/${basename}_${samp}_${dct}.bmp
+		done
+		for samp in 420 422; do
+			runme $EXEDIR/tjexample $OUTDIR/${basename}_${samp}_${srcdct}.jpg $OUTDIR/${basename}_${samp}_${dct}_nosmooth.bmp -fastupsample ${dctarg}
+			runme cmp -i 54:54 $OUTDIR/${basename}_${samp}_${dct}_nosmooth.bmp $OUTDIR/${basename}_${samp}_${dct}_nosmooth_djpeg.bmp
+			rm $OUTDIR/${basename}_${samp}_${dct}_nosmooth.bmp
+		done
+	done
+
+	# Scaled decompression
+	for scale in 2_1 15_8 7_4 13_8 3_2 11_8 5_4 9_8 7_8 3_4 5_8 1_2 3_8 1_4 1_8; do
+		scalearg=`echo $scale | sed 's/\_/\//g'`
+		for samp in GRAY 420 422 444; do
+			runme $EXEDIR/djpeg -rgb -bmp -scale ${scalearg} -outfile $OUTDIR/${basename}_${samp}_${scale}_djpeg.bmp $OUTDIR/${basename}_${samp}_fast_cjpeg.jpg
+			runme $EXEDIR/tjexample $OUTDIR/${basename}_${samp}_fast.jpg $OUTDIR/${basename}_${samp}_${scale}.bmp -scale ${scalearg}
+			runme cmp -i 54:54 $OUTDIR/${basename}_${samp}_${scale}.bmp $OUTDIR/${basename}_${samp}_${scale}_djpeg.bmp
+			rm $OUTDIR/${basename}_${samp}_${scale}.bmp
+		done
+	done
+
+	# Transforms
+	for samp in GRAY 420 422 444; do
+		runme $EXEDIR/jpegtran -crop 70x60+16+16 -flip horizontal -trim -outfile $OUTDIR/${basename}_${samp}_hflip_jpegtran.jpg $OUTDIR/${basename}_${samp}_fast.jpg
+		runme $EXEDIR/jpegtran -crop 70x60+16+16 -flip vertical -trim -outfile $OUTDIR/${basename}_${samp}_vflip_jpegtran.jpg $OUTDIR/${basename}_${samp}_fast.jpg
+		runme $EXEDIR/jpegtran -crop 70x60+16+16 -transpose -trim -outfile $OUTDIR/${basename}_${samp}_transpose_jpegtran.jpg $OUTDIR/${basename}_${samp}_fast.jpg
+		runme $EXEDIR/jpegtran -crop 70x60+16+16 -transverse -trim -outfile $OUTDIR/${basename}_${samp}_transverse_jpegtran.jpg $OUTDIR/${basename}_${samp}_fast.jpg
+		runme $EXEDIR/jpegtran -crop 70x60+16+16 -rotate 90 -trim -outfile $OUTDIR/${basename}_${samp}_rot90_jpegtran.jpg $OUTDIR/${basename}_${samp}_fast.jpg
+		runme $EXEDIR/jpegtran -crop 70x60+16+16 -rotate 180 -trim -outfile $OUTDIR/${basename}_${samp}_rot180_jpegtran.jpg $OUTDIR/${basename}_${samp}_fast.jpg
+		runme $EXEDIR/jpegtran -crop 70x60+16+16 -rotate 270 -trim -outfile $OUTDIR/${basename}_${samp}_rot270_jpegtran.jpg $OUTDIR/${basename}_${samp}_fast.jpg
+	done
+	for xform in hflip vflip transpose transverse rot90 rot180 rot270; do
+		for samp in GRAY 420 422 444; do
+			runme $EXEDIR/tjexample $OUTDIR/${basename}_${samp}_fast.jpg $OUTDIR/${basename}_${samp}_${xform}.jpg -$xform -crop 70x60+16+16
+			runme cmp $OUTDIR/${basename}_${samp}_${xform}.jpg $OUTDIR/${basename}_${samp}_${xform}_jpegtran.jpg
+			runme $EXEDIR/djpeg -rgb -bmp -outfile $OUTDIR/${basename}_${samp}_${xform}_jpegtran.bmp $OUTDIR/${basename}_${samp}_${xform}_jpegtran.jpg
+			runme $EXEDIR/tjexample $OUTDIR/${basename}_${samp}_fast.jpg $OUTDIR/${basename}_${samp}_${xform}.bmp -$xform -crop 70x60+16+16
+			runme cmp -i 54:54 $OUTDIR/${basename}_${samp}_${xform}.bmp $OUTDIR/${basename}_${samp}_${xform}_jpegtran.bmp
+			rm $OUTDIR/${basename}_${samp}_${xform}.bmp
+		done
+		for samp in 420 422; do
+			runme $EXEDIR/djpeg -nosmooth -rgb -bmp -outfile $OUTDIR/${basename}_${samp}_${xform}_jpegtran.bmp $OUTDIR/${basename}_${samp}_${xform}_jpegtran.jpg
+			runme $EXEDIR/tjexample $OUTDIR/${basename}_${samp}_fast.jpg $OUTDIR/${basename}_${samp}_${xform}.bmp -$xform -crop 70x60+16+16 -fastupsample
+			runme cmp -i 54:54 $OUTDIR/${basename}_${samp}_${xform}.bmp $OUTDIR/${basename}_${samp}_${xform}_jpegtran.bmp
+			rm $OUTDIR/${basename}_${samp}_${xform}.bmp
+		done
+	done
+
+	# Grayscale transform
+	for xform in hflip vflip transpose transverse rot90 rot180 rot270; do
+		for samp in GRAY 444 422 420; do
+			runme $EXEDIR/tjexample $OUTDIR/${basename}_${samp}_fast.jpg $OUTDIR/${basename}_${samp}_${xform}.jpg -$xform -grayscale -crop 70x60+16+16
+			runme cmp $OUTDIR/${basename}_${samp}_${xform}.jpg $OUTDIR/${basename}_GRAY_${xform}_jpegtran.jpg
+			runme $EXEDIR/tjexample $OUTDIR/${basename}_${samp}_fast.jpg $OUTDIR/${basename}_${samp}_${xform}.bmp -$xform -grayscale -crop 70x60+16+16
+			runme cmp -i 54:54 $OUTDIR/${basename}_${samp}_${xform}.bmp $OUTDIR/${basename}_GRAY_${xform}_jpegtran.bmp
+			rm $OUTDIR/${basename}_${samp}_${xform}.bmp
+		done
+	done
+
+	# Transforms with scaling
+	for xform in hflip vflip transpose transverse rot90 rot180 rot270; do
+		for samp in GRAY 444 422 420; do
+			for scale in 2_1 15_8 7_4 13_8 3_2 11_8 5_4 9_8 7_8 3_4 5_8 1_2 3_8 1_4 1_8; do
+				scalearg=`echo $scale | sed 's/\_/\//g'`
+				runme $EXEDIR/djpeg -rgb -bmp -scale ${scalearg} -outfile $OUTDIR/${basename}_${samp}_${xform}_${scale}_jpegtran.bmp $OUTDIR/${basename}_${samp}_${xform}_jpegtran.jpg
+				runme $EXEDIR/tjexample $OUTDIR/${basename}_${samp}_fast.jpg $OUTDIR/${basename}_${samp}_${xform}_${scale}.bmp -$xform -scale ${scalearg} -crop 70x60+16+16
+				runme cmp -i 54:54 $OUTDIR/${basename}_${samp}_${xform}_${scale}.bmp $OUTDIR/${basename}_${samp}_${xform}_${scale}_jpegtran.bmp
+				rm $OUTDIR/${basename}_${samp}_${xform}_${scale}.bmp
+			done
+		done
+	done
+
+done
+
+echo SUCCESS!
diff --git a/3rdparty/libjpeg/src/tjexampletest.java.in b/3rdparty/libjpeg/src/tjexampletest.java.in
new file mode 100644
index 00000000..d4b63bc5
--- /dev/null
+++ b/3rdparty/libjpeg/src/tjexampletest.java.in
@@ -0,0 +1,151 @@
+#!/bin/bash
+
+set -u
+set -e
+trap onexit INT
+trap onexit TERM
+trap onexit EXIT
+
+onexit()
+{
+	if [ -d $OUTDIR ]; then
+		rm -rf $OUTDIR
+	fi
+}
+
+runme()
+{
+	echo \*\*\* $*
+	"$@"
+}
+
+IMAGES="vgl_5674_0098.bmp vgl_6434_0018a.bmp vgl_6548_0026a.bmp nightshot_iso_100.bmp"
+IMGDIR=@CMAKE_CURRENT_SOURCE_DIR@/testimages
+OUTDIR=`mktemp -d /tmp/__tjexampletest_java_output.XXXXXX`
+EXEDIR=@CMAKE_CURRENT_BINARY_DIR@
+JAVA="@Java_JAVA_EXECUTABLE@"
+JAVAARGS="-cp $EXEDIR/java/turbojpeg.jar -Djava.library.path=$EXEDIR"
+
+if [ -d $OUTDIR ]; then
+	rm -rf $OUTDIR
+fi
+mkdir -p $OUTDIR
+
+exec >$EXEDIR/tjexampletest-java.log
+
+for image in $IMAGES; do
+
+	cp $IMGDIR/$image $OUTDIR
+	basename=`basename $image .bmp`
+	runme $EXEDIR/cjpeg -quality 95 -dct fast -grayscale -outfile $OUTDIR/${basename}_GRAY_fast_cjpeg.jpg $IMGDIR/${basename}.bmp
+	runme $EXEDIR/cjpeg -quality 95 -dct fast -sample 2x2 -outfile $OUTDIR/${basename}_420_fast_cjpeg.jpg $IMGDIR/${basename}.bmp
+	runme $EXEDIR/cjpeg -quality 95 -dct fast -sample 2x1 -outfile $OUTDIR/${basename}_422_fast_cjpeg.jpg $IMGDIR/${basename}.bmp
+	runme $EXEDIR/cjpeg -quality 95 -dct fast -sample 1x1 -outfile $OUTDIR/${basename}_444_fast_cjpeg.jpg $IMGDIR/${basename}.bmp
+	runme $EXEDIR/cjpeg -quality 95 -dct int -grayscale -outfile $OUTDIR/${basename}_GRAY_accurate_cjpeg.jpg $IMGDIR/${basename}.bmp
+	runme $EXEDIR/cjpeg -quality 95 -dct int -sample 2x2 -outfile $OUTDIR/${basename}_420_accurate_cjpeg.jpg $IMGDIR/${basename}.bmp
+	runme $EXEDIR/cjpeg -quality 95 -dct int -sample 2x1 -outfile $OUTDIR/${basename}_422_accurate_cjpeg.jpg $IMGDIR/${basename}.bmp
+	runme $EXEDIR/cjpeg -quality 95 -dct int -sample 1x1 -outfile $OUTDIR/${basename}_444_accurate_cjpeg.jpg $IMGDIR/${basename}.bmp
+	for samp in GRAY 420 422 444; do
+		runme $EXEDIR/djpeg -rgb -bmp -outfile $OUTDIR/${basename}_${samp}_default_djpeg.bmp $OUTDIR/${basename}_${samp}_fast_cjpeg.jpg
+		runme $EXEDIR/djpeg -dct fast -rgb -bmp -outfile $OUTDIR/${basename}_${samp}_fast_djpeg.bmp $OUTDIR/${basename}_${samp}_fast_cjpeg.jpg
+		runme $EXEDIR/djpeg -dct int -rgb -bmp -outfile $OUTDIR/${basename}_${samp}_accurate_djpeg.bmp $OUTDIR/${basename}_${samp}_accurate_cjpeg.jpg
+	done
+	for samp in 420 422; do
+		runme $EXEDIR/djpeg -nosmooth -bmp -outfile $OUTDIR/${basename}_${samp}_default_nosmooth_djpeg.bmp $OUTDIR/${basename}_${samp}_fast_cjpeg.jpg
+		runme $EXEDIR/djpeg -dct fast -nosmooth -bmp -outfile $OUTDIR/${basename}_${samp}_fast_nosmooth_djpeg.bmp $OUTDIR/${basename}_${samp}_fast_cjpeg.jpg
+		runme $EXEDIR/djpeg -dct int -nosmooth -bmp -outfile $OUTDIR/${basename}_${samp}_accurate_nosmooth_djpeg.bmp $OUTDIR/${basename}_${samp}_accurate_cjpeg.jpg
+	done
+
+	# Compression
+	for dct in fast accurate; do
+		for samp in GRAY 420 422 444; do
+			runme "$JAVA" $JAVAARGS TJExample $OUTDIR/$image $OUTDIR/${basename}_${samp}_${dct}.jpg -q 95 -subsamp ${samp} -${dct}dct
+			runme cmp $OUTDIR/${basename}_${samp}_${dct}.jpg $OUTDIR/${basename}_${samp}_${dct}_cjpeg.jpg
+		done
+	done
+
+	# Decompression
+	for dct in fast accurate default; do
+		srcdct=${dct}
+		dctarg=-${dct}dct
+		if [ "${dct}" = "default" ]; then
+			srcdct=fast
+			dctarg=
+		fi
+		for samp in GRAY 420 422 444; do
+			runme "$JAVA" $JAVAARGS TJExample $OUTDIR/${basename}_${samp}_${srcdct}.jpg $OUTDIR/${basename}_${samp}_${dct}.bmp ${dctarg}
+			runme cmp -i 54:54 $OUTDIR/${basename}_${samp}_${dct}.bmp $OUTDIR/${basename}_${samp}_${dct}_djpeg.bmp
+			rm $OUTDIR/${basename}_${samp}_${dct}.bmp
+		done
+		for samp in 420 422; do
+			runme "$JAVA" $JAVAARGS TJExample $OUTDIR/${basename}_${samp}_${srcdct}.jpg $OUTDIR/${basename}_${samp}_${dct}_nosmooth.bmp -fastupsample ${dctarg}
+			runme cmp -i 54:54 $OUTDIR/${basename}_${samp}_${dct}_nosmooth.bmp $OUTDIR/${basename}_${samp}_${dct}_nosmooth_djpeg.bmp
+			rm $OUTDIR/${basename}_${samp}_${dct}_nosmooth.bmp
+		done
+	done
+
+	# Scaled decompression
+	for scale in 2_1 15_8 7_4 13_8 3_2 11_8 5_4 9_8 7_8 3_4 5_8 1_2 3_8 1_4 1_8; do
+		scalearg=`echo $scale | sed 's/\_/\//g'`
+		for samp in GRAY 420 422 444; do
+			runme $EXEDIR/djpeg -rgb -bmp -scale ${scalearg} -outfile $OUTDIR/${basename}_${samp}_${scale}_djpeg.bmp $OUTDIR/${basename}_${samp}_fast_cjpeg.jpg
+			runme "$JAVA" $JAVAARGS TJExample $OUTDIR/${basename}_${samp}_fast.jpg $OUTDIR/${basename}_${samp}_${scale}.bmp -scale ${scalearg}
+			runme cmp -i 54:54 $OUTDIR/${basename}_${samp}_${scale}.bmp $OUTDIR/${basename}_${samp}_${scale}_djpeg.bmp
+			rm $OUTDIR/${basename}_${samp}_${scale}.bmp
+		done
+	done
+
+	# Transforms
+	for samp in GRAY 420 422 444; do
+		runme $EXEDIR/jpegtran -crop 70x60+16+16 -flip horizontal -trim -outfile $OUTDIR/${basename}_${samp}_hflip_jpegtran.jpg $OUTDIR/${basename}_${samp}_fast.jpg
+		runme $EXEDIR/jpegtran -crop 70x60+16+16 -flip vertical -trim -outfile $OUTDIR/${basename}_${samp}_vflip_jpegtran.jpg $OUTDIR/${basename}_${samp}_fast.jpg
+		runme $EXEDIR/jpegtran -crop 70x60+16+16 -transpose -trim -outfile $OUTDIR/${basename}_${samp}_transpose_jpegtran.jpg $OUTDIR/${basename}_${samp}_fast.jpg
+		runme $EXEDIR/jpegtran -crop 70x60+16+16 -transverse -trim -outfile $OUTDIR/${basename}_${samp}_transverse_jpegtran.jpg $OUTDIR/${basename}_${samp}_fast.jpg
+		runme $EXEDIR/jpegtran -crop 70x60+16+16 -rotate 90 -trim -outfile $OUTDIR/${basename}_${samp}_rot90_jpegtran.jpg $OUTDIR/${basename}_${samp}_fast.jpg
+		runme $EXEDIR/jpegtran -crop 70x60+16+16 -rotate 180 -trim -outfile $OUTDIR/${basename}_${samp}_rot180_jpegtran.jpg $OUTDIR/${basename}_${samp}_fast.jpg
+		runme $EXEDIR/jpegtran -crop 70x60+16+16 -rotate 270 -trim -outfile $OUTDIR/${basename}_${samp}_rot270_jpegtran.jpg $OUTDIR/${basename}_${samp}_fast.jpg
+	done
+	for xform in hflip vflip transpose transverse rot90 rot180 rot270; do
+		for samp in GRAY 420 422 444; do
+			runme "$JAVA" $JAVAARGS TJExample $OUTDIR/${basename}_${samp}_fast.jpg $OUTDIR/${basename}_${samp}_${xform}.jpg -$xform -crop 70x60+16+16
+			runme cmp $OUTDIR/${basename}_${samp}_${xform}.jpg $OUTDIR/${basename}_${samp}_${xform}_jpegtran.jpg
+			runme $EXEDIR/djpeg -rgb -bmp -outfile $OUTDIR/${basename}_${samp}_${xform}_jpegtran.bmp $OUTDIR/${basename}_${samp}_${xform}_jpegtran.jpg
+			runme "$JAVA" $JAVAARGS TJExample $OUTDIR/${basename}_${samp}_fast.jpg $OUTDIR/${basename}_${samp}_${xform}.bmp -$xform -crop 70x60+16+16
+			runme cmp -i 54:54 $OUTDIR/${basename}_${samp}_${xform}.bmp $OUTDIR/${basename}_${samp}_${xform}_jpegtran.bmp
+			rm $OUTDIR/${basename}_${samp}_${xform}.bmp
+		done
+		for samp in 420 422; do
+			runme $EXEDIR/djpeg -nosmooth -rgb -bmp -outfile $OUTDIR/${basename}_${samp}_${xform}_jpegtran.bmp $OUTDIR/${basename}_${samp}_${xform}_jpegtran.jpg
+			runme "$JAVA" $JAVAARGS TJExample $OUTDIR/${basename}_${samp}_fast.jpg $OUTDIR/${basename}_${samp}_${xform}.bmp -$xform -crop 70x60+16+16 -fastupsample
+			runme cmp -i 54:54 $OUTDIR/${basename}_${samp}_${xform}.bmp $OUTDIR/${basename}_${samp}_${xform}_jpegtran.bmp
+			rm $OUTDIR/${basename}_${samp}_${xform}.bmp
+		done
+	done
+
+	# Grayscale transform
+	for xform in hflip vflip transpose transverse rot90 rot180 rot270; do
+		for samp in GRAY 444 422 420; do
+			runme "$JAVA" $JAVAARGS TJExample $OUTDIR/${basename}_${samp}_fast.jpg $OUTDIR/${basename}_${samp}_${xform}.jpg -$xform -grayscale -crop 70x60+16+16
+			runme cmp $OUTDIR/${basename}_${samp}_${xform}.jpg $OUTDIR/${basename}_GRAY_${xform}_jpegtran.jpg
+			runme "$JAVA" $JAVAARGS TJExample $OUTDIR/${basename}_${samp}_fast.jpg $OUTDIR/${basename}_${samp}_${xform}.bmp -$xform -grayscale -crop 70x60+16+16
+			runme cmp -i 54:54 $OUTDIR/${basename}_${samp}_${xform}.bmp $OUTDIR/${basename}_GRAY_${xform}_jpegtran.bmp
+			rm $OUTDIR/${basename}_${samp}_${xform}.bmp
+		done
+	done
+
+	# Transforms with scaling
+	for xform in hflip vflip transpose transverse rot90 rot180 rot270; do
+		for samp in GRAY 444 422 420; do
+			for scale in 2_1 15_8 7_4 13_8 3_2 11_8 5_4 9_8 7_8 3_4 5_8 1_2 3_8 1_4 1_8; do
+				scalearg=`echo $scale | sed 's/\_/\//g'`
+				runme $EXEDIR/djpeg -rgb -bmp -scale ${scalearg} -outfile $OUTDIR/${basename}_${samp}_${xform}_${scale}_jpegtran.bmp $OUTDIR/${basename}_${samp}_${xform}_jpegtran.jpg
+				runme "$JAVA" $JAVAARGS TJExample $OUTDIR/${basename}_${samp}_fast.jpg $OUTDIR/${basename}_${samp}_${xform}_${scale}.bmp -$xform -scale ${scalearg} -crop 70x60+16+16
+				runme cmp -i 54:54 $OUTDIR/${basename}_${samp}_${xform}_${scale}.bmp $OUTDIR/${basename}_${samp}_${xform}_${scale}_jpegtran.bmp
+				rm $OUTDIR/${basename}_${samp}_${xform}_${scale}.bmp
+			done
+		done
+	done
+
+done
+
+echo SUCCESS!
diff --git a/3rdparty/libjpeg/src/tjunittest.c b/3rdparty/libjpeg/src/tjunittest.c
new file mode 100644
index 00000000..f59939fd
--- /dev/null
+++ b/3rdparty/libjpeg/src/tjunittest.c
@@ -0,0 +1,931 @@
+/*
+ * Copyright (C)2009-2014, 2017-2019 D. R. Commander.  All Rights Reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright notice,
+ *   this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright notice,
+ *   this list of conditions and the following disclaimer in the documentation
+ *   and/or other materials provided with the distribution.
+ * - Neither the name of the libjpeg-turbo Project nor the names of its
+ *   contributors may be used to endorse or promote products derived from this
+ *   software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE 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 HOLDERS 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.
+ */
+
+/*
+ * This program tests the various code paths in the TurboJPEG C Wrapper
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include "tjutil.h"
+#include "turbojpeg.h"
+#include "md5/md5.h"
+#include "cmyk.h"
+#ifdef _WIN32
+#include <time.h>
+#define random()  rand()
+#else
+#include <unistd.h>
+#endif
+
+
+static void usage(char *progName)
+{
+  printf("\nUSAGE: %s [options]\n\n", progName);
+  printf("Options:\n");
+  printf("-yuv = test YUV encoding/decoding support\n");
+  printf("-noyuvpad = do not pad each line of each Y, U, and V plane to the nearest\n");
+  printf("            4-byte boundary\n");
+  printf("-alloc = test automatic buffer allocation\n");
+  printf("-bmp = tjLoadImage()/tjSaveImage() unit test\n\n");
+  exit(1);
+}
+
+
+#define THROW_TJ() { \
+  printf("TurboJPEG ERROR:\n%s\n", tjGetErrorStr()); \
+  BAILOUT() \
+}
+#define TRY_TJ(f) { if ((f) == -1) THROW_TJ(); }
+#define THROW(m) { printf("ERROR: %s\n", m);  BAILOUT() }
+#define THROW_MD5(filename, md5sum, ref) { \
+  printf("\n%s has an MD5 sum of %s.\n   Should be %s.\n", filename, md5sum, \
+         ref); \
+  BAILOUT() \
+}
+
+const char *subNameLong[TJ_NUMSAMP] = {
+  "4:4:4", "4:2:2", "4:2:0", "GRAY", "4:4:0", "4:1:1"
+};
+const char *subName[TJ_NUMSAMP] = {
+  "444", "422", "420", "GRAY", "440", "411"
+};
+
+const char *pixFormatStr[TJ_NUMPF] = {
+  "RGB", "BGR", "RGBX", "BGRX", "XBGR", "XRGB", "Grayscale",
+  "RGBA", "BGRA", "ABGR", "ARGB", "CMYK"
+};
+
+const int _3byteFormats[] = { TJPF_RGB, TJPF_BGR };
+const int _4byteFormats[] = {
+  TJPF_RGBX, TJPF_BGRX, TJPF_XBGR, TJPF_XRGB, TJPF_CMYK
+};
+const int _onlyGray[] = { TJPF_GRAY };
+const int _onlyRGB[] = { TJPF_RGB };
+
+int doYUV = 0, alloc = 0, pad = 4;
+
+int exitStatus = 0;
+#define BAILOUT() { exitStatus = -1;  goto bailout; }
+
+
+static void initBuf(unsigned char *buf, int w, int h, int pf, int flags)
+{
+  int roffset = tjRedOffset[pf];
+  int goffset = tjGreenOffset[pf];
+  int boffset = tjBlueOffset[pf];
+  int ps = tjPixelSize[pf];
+  int index, row, col, halfway = 16;
+
+  if (pf == TJPF_GRAY) {
+    memset(buf, 0, w * h * ps);
+    for (row = 0; row < h; row++) {
+      for (col = 0; col < w; col++) {
+        if (flags & TJFLAG_BOTTOMUP) index = (h - row - 1) * w + col;
+        else index = row * w + col;
+        if (((row / 8) + (col / 8)) % 2 == 0)
+          buf[index] = (row < halfway) ? 255 : 0;
+        else buf[index] = (row < halfway) ? 76 : 226;
+      }
+    }
+  } else if (pf == TJPF_CMYK) {
+    memset(buf, 255, w * h * ps);
+    for (row = 0; row < h; row++) {
+      for (col = 0; col < w; col++) {
+        if (flags & TJFLAG_BOTTOMUP) index = (h - row - 1) * w + col;
+        else index = row * w + col;
+        if (((row / 8) + (col / 8)) % 2 == 0) {
+          if (row >= halfway) buf[index * ps + 3] = 0;
+        } else {
+          buf[index * ps + 2] = 0;
+          if (row < halfway) buf[index * ps + 1] = 0;
+        }
+      }
+    }
+  } else {
+    memset(buf, 0, w * h * ps);
+    for (row = 0; row < h; row++) {
+      for (col = 0; col < w; col++) {
+        if (flags & TJFLAG_BOTTOMUP) index = (h - row - 1) * w + col;
+        else index = row * w + col;
+        if (((row / 8) + (col / 8)) % 2 == 0) {
+          if (row < halfway) {
+            buf[index * ps + roffset] = 255;
+            buf[index * ps + goffset] = 255;
+            buf[index * ps + boffset] = 255;
+          }
+        } else {
+          buf[index * ps + roffset] = 255;
+          if (row >= halfway) buf[index * ps + goffset] = 255;
+        }
+      }
+    }
+  }
+}
+
+
+#define CHECKVAL(v, cv) { \
+  if (v < cv - 1 || v > cv + 1) { \
+    printf("\nComp. %s at %d,%d should be %d, not %d\n", #v, row, col, cv, \
+           v); \
+    retval = 0;  exitStatus = -1;  goto bailout; \
+  } \
+}
+
+#define CHECKVAL0(v) { \
+  if (v > 1) { \
+    printf("\nComp. %s at %d,%d should be 0, not %d\n", #v, row, col, v); \
+    retval = 0;  exitStatus = -1;  goto bailout; \
+  } \
+}
+
+#define CHECKVAL255(v) { \
+  if (v < 254) { \
+    printf("\nComp. %s at %d,%d should be 255, not %d\n", #v, row, col, v); \
+    retval = 0;  exitStatus = -1;  goto bailout; \
+  } \
+}
+
+
+static int checkBuf(unsigned char *buf, int w, int h, int pf, int subsamp,
+                    tjscalingfactor sf, int flags)
+{
+  int roffset = tjRedOffset[pf];
+  int goffset = tjGreenOffset[pf];
+  int boffset = tjBlueOffset[pf];
+  int aoffset = tjAlphaOffset[pf];
+  int ps = tjPixelSize[pf];
+  int index, row, col, retval = 1;
+  int halfway = 16 * sf.num / sf.denom;
+  int blocksize = 8 * sf.num / sf.denom;
+
+  if (pf == TJPF_GRAY) roffset = goffset = boffset = 0;
+
+  if (pf == TJPF_CMYK) {
+    for (row = 0; row < h; row++) {
+      for (col = 0; col < w; col++) {
+        unsigned char c, m, y, k;
+
+        if (flags & TJFLAG_BOTTOMUP) index = (h - row - 1) * w + col;
+        else index = row * w + col;
+        c = buf[index * ps];
+        m = buf[index * ps + 1];
+        y = buf[index * ps + 2];
+        k = buf[index * ps + 3];
+        if (((row / blocksize) + (col / blocksize)) % 2 == 0) {
+          CHECKVAL255(c);  CHECKVAL255(m);  CHECKVAL255(y);
+          if (row < halfway) CHECKVAL255(k)
+          else CHECKVAL0(k)
+        } else {
+          CHECKVAL255(c);  CHECKVAL0(y);  CHECKVAL255(k);
+          if (row < halfway) CHECKVAL0(m)
+          else CHECKVAL255(m)
+        }
+      }
+    }
+    return 1;
+  }
+
+  for (row = 0; row < h; row++) {
+    for (col = 0; col < w; col++) {
+      unsigned char r, g, b, a;
+
+      if (flags & TJFLAG_BOTTOMUP) index = (h - row - 1) * w + col;
+      else index = row * w + col;
+      r = buf[index * ps + roffset];
+      g = buf[index * ps + goffset];
+      b = buf[index * ps + boffset];
+      a = aoffset >= 0 ? buf[index * ps + aoffset] : 0xFF;
+      if (((row / blocksize) + (col / blocksize)) % 2 == 0) {
+        if (row < halfway) {
+          CHECKVAL255(r);  CHECKVAL255(g);  CHECKVAL255(b);
+        } else {
+          CHECKVAL0(r);  CHECKVAL0(g);  CHECKVAL0(b);
+        }
+      } else {
+        if (subsamp == TJSAMP_GRAY) {
+          if (row < halfway) {
+            CHECKVAL(r, 76);  CHECKVAL(g, 76);  CHECKVAL(b, 76);
+          } else {
+            CHECKVAL(r, 226);  CHECKVAL(g, 226);  CHECKVAL(b, 226);
+          }
+        } else {
+          if (row < halfway) {
+            CHECKVAL255(r);  CHECKVAL0(g);  CHECKVAL0(b);
+          } else {
+            CHECKVAL255(r);  CHECKVAL255(g);  CHECKVAL0(b);
+          }
+        }
+      }
+      CHECKVAL255(a);
+    }
+  }
+
+bailout:
+  if (retval == 0) {
+    for (row = 0; row < h; row++) {
+      for (col = 0; col < w; col++) {
+        if (pf == TJPF_CMYK)
+          printf("%.3d/%.3d/%.3d/%.3d ", buf[(row * w + col) * ps],
+                 buf[(row * w + col) * ps + 1], buf[(row * w + col) * ps + 2],
+                 buf[(row * w + col) * ps + 3]);
+        else
+          printf("%.3d/%.3d/%.3d ", buf[(row * w + col) * ps + roffset],
+                 buf[(row * w + col) * ps + goffset],
+                 buf[(row * w + col) * ps + boffset]);
+      }
+      printf("\n");
+    }
+  }
+  return retval;
+}
+
+
+#define PAD(v, p)  ((v + (p) - 1) & (~((p) - 1)))
+
+static int checkBufYUV(unsigned char *buf, int w, int h, int subsamp,
+                       tjscalingfactor sf)
+{
+  int row, col;
+  int hsf = tjMCUWidth[subsamp] / 8, vsf = tjMCUHeight[subsamp] / 8;
+  int pw = PAD(w, hsf), ph = PAD(h, vsf);
+  int cw = pw / hsf, ch = ph / vsf;
+  int ypitch = PAD(pw, pad), uvpitch = PAD(cw, pad);
+  int retval = 1;
+  int halfway = 16 * sf.num / sf.denom;
+  int blocksize = 8 * sf.num / sf.denom;
+
+  for (row = 0; row < ph; row++) {
+    for (col = 0; col < pw; col++) {
+      unsigned char y = buf[ypitch * row + col];
+
+      if (((row / blocksize) + (col / blocksize)) % 2 == 0) {
+        if (row < halfway) CHECKVAL255(y)
+        else CHECKVAL0(y);
+      } else {
+        if (row < halfway) CHECKVAL(y, 76)
+        else CHECKVAL(y, 226);
+      }
+    }
+  }
+  if (subsamp != TJSAMP_GRAY) {
+    halfway = 16 / vsf * sf.num / sf.denom;
+
+    for (row = 0; row < ch; row++) {
+      for (col = 0; col < cw; col++) {
+        unsigned char u = buf[ypitch * ph + (uvpitch * row + col)],
+          v = buf[ypitch * ph + uvpitch * ch + (uvpitch * row + col)];
+
+        if (((row * vsf / blocksize) + (col * hsf / blocksize)) % 2 == 0) {
+          CHECKVAL(u, 128);  CHECKVAL(v, 128);
+        } else {
+          if (row < halfway) {
+            CHECKVAL(u, 85);  CHECKVAL255(v);
+          } else {
+            CHECKVAL0(u);  CHECKVAL(v, 149);
+          }
+        }
+      }
+    }
+  }
+
+bailout:
+  if (retval == 0) {
+    for (row = 0; row < ph; row++) {
+      for (col = 0; col < pw; col++)
+        printf("%.3d ", buf[ypitch * row + col]);
+      printf("\n");
+    }
+    printf("\n");
+    for (row = 0; row < ch; row++) {
+      for (col = 0; col < cw; col++)
+        printf("%.3d ", buf[ypitch * ph + (uvpitch * row + col)]);
+      printf("\n");
+    }
+    printf("\n");
+    for (row = 0; row < ch; row++) {
+      for (col = 0; col < cw; col++)
+        printf("%.3d ",
+               buf[ypitch * ph + uvpitch * ch + (uvpitch * row + col)]);
+      printf("\n");
+    }
+  }
+
+  return retval;
+}
+
+
+static void writeJPEG(unsigned char *jpegBuf, unsigned long jpegSize,
+                      char *filename)
+{
+  FILE *file = fopen(filename, "wb");
+
+  if (!file || fwrite(jpegBuf, jpegSize, 1, file) != 1) {
+    printf("ERROR: Could not write to %s.\n%s\n", filename, strerror(errno));
+    BAILOUT()
+  }
+
+bailout:
+  if (file) fclose(file);
+}
+
+
+static void compTest(tjhandle handle, unsigned char **dstBuf,
+                     unsigned long *dstSize, int w, int h, int pf,
+                     char *basename, int subsamp, int jpegQual, int flags)
+{
+  char tempStr[1024];
+  unsigned char *srcBuf = NULL, *yuvBuf = NULL;
+  const char *pfStr = pixFormatStr[pf];
+  const char *buStrLong =
+    (flags & TJFLAG_BOTTOMUP) ? "Bottom-Up" : "Top-Down ";
+  const char *buStr = (flags & TJFLAG_BOTTOMUP) ? "BU" : "TD";
+
+  if ((srcBuf = (unsigned char *)malloc(w * h * tjPixelSize[pf])) == NULL)
+    THROW("Memory allocation failure");
+  initBuf(srcBuf, w, h, pf, flags);
+
+  if (*dstBuf && *dstSize > 0) memset(*dstBuf, 0, *dstSize);
+
+  if (!alloc) flags |= TJFLAG_NOREALLOC;
+  if (doYUV) {
+    unsigned long yuvSize = tjBufSizeYUV2(w, pad, h, subsamp);
+    tjscalingfactor sf = { 1, 1 };
+    tjhandle handle2 = tjInitCompress();
+
+    if (!handle2) THROW_TJ();
+
+    if ((yuvBuf = (unsigned char *)malloc(yuvSize)) == NULL)
+      THROW("Memory allocation failure");
+    memset(yuvBuf, 0, yuvSize);
+
+    printf("%s %s -> YUV %s ... ", pfStr, buStrLong, subNameLong[subsamp]);
+    TRY_TJ(tjEncodeYUV3(handle2, srcBuf, w, 0, h, pf, yuvBuf, pad, subsamp,
+                        flags));
+    tjDestroy(handle2);
+    if (checkBufYUV(yuvBuf, w, h, subsamp, sf)) printf("Passed.\n");
+    else printf("FAILED!\n");
+
+    printf("YUV %s %s -> JPEG Q%d ... ", subNameLong[subsamp], buStrLong,
+           jpegQual);
+    TRY_TJ(tjCompressFromYUV(handle, yuvBuf, w, pad, h, subsamp, dstBuf,
+                             dstSize, jpegQual, flags));
+  } else {
+    printf("%s %s -> %s Q%d ... ", pfStr, buStrLong, subNameLong[subsamp],
+           jpegQual);
+    TRY_TJ(tjCompress2(handle, srcBuf, w, 0, h, pf, dstBuf, dstSize, subsamp,
+                       jpegQual, flags));
+  }
+
+  snprintf(tempStr, 1024, "%s_enc_%s_%s_%s_Q%d.jpg", basename, pfStr, buStr,
+           subName[subsamp], jpegQual);
+  writeJPEG(*dstBuf, *dstSize, tempStr);
+  printf("Done.\n  Result in %s\n", tempStr);
+
+bailout:
+  free(yuvBuf);
+  free(srcBuf);
+}
+
+
+static void _decompTest(tjhandle handle, unsigned char *jpegBuf,
+                        unsigned long jpegSize, int w, int h, int pf,
+                        char *basename, int subsamp, int flags,
+                        tjscalingfactor sf)
+{
+  unsigned char *dstBuf = NULL, *yuvBuf = NULL;
+  int _hdrw = 0, _hdrh = 0, _hdrsubsamp = -1;
+  int scaledWidth = TJSCALED(w, sf);
+  int scaledHeight = TJSCALED(h, sf);
+  unsigned long dstSize = 0;
+
+  TRY_TJ(tjDecompressHeader2(handle, jpegBuf, jpegSize, &_hdrw, &_hdrh,
+                             &_hdrsubsamp));
+  if (_hdrw != w || _hdrh != h || _hdrsubsamp != subsamp)
+    THROW("Incorrect JPEG header");
+
+  dstSize = scaledWidth * scaledHeight * tjPixelSize[pf];
+  if ((dstBuf = (unsigned char *)malloc(dstSize)) == NULL)
+    THROW("Memory allocation failure");
+  memset(dstBuf, 0, dstSize);
+
+  if (doYUV) {
+    unsigned long yuvSize = tjBufSizeYUV2(scaledWidth, pad, scaledHeight,
+                                          subsamp);
+    tjhandle handle2 = tjInitDecompress();
+
+    if (!handle2) THROW_TJ();
+
+    if ((yuvBuf = (unsigned char *)malloc(yuvSize)) == NULL)
+      THROW("Memory allocation failure");
+    memset(yuvBuf, 0, yuvSize);
+
+    printf("JPEG -> YUV %s ", subNameLong[subsamp]);
+    if (sf.num != 1 || sf.denom != 1)
+      printf("%d/%d ... ", sf.num, sf.denom);
+    else printf("... ");
+    TRY_TJ(tjDecompressToYUV2(handle, jpegBuf, jpegSize, yuvBuf, scaledWidth,
+                              pad, scaledHeight, flags));
+    if (checkBufYUV(yuvBuf, scaledWidth, scaledHeight, subsamp, sf))
+      printf("Passed.\n");
+    else printf("FAILED!\n");
+
+    printf("YUV %s -> %s %s ... ", subNameLong[subsamp], pixFormatStr[pf],
+           (flags & TJFLAG_BOTTOMUP) ? "Bottom-Up" : "Top-Down ");
+    TRY_TJ(tjDecodeYUV(handle2, yuvBuf, pad, subsamp, dstBuf, scaledWidth, 0,
+                       scaledHeight, pf, flags));
+    tjDestroy(handle2);
+  } else {
+    printf("JPEG -> %s %s ", pixFormatStr[pf],
+           (flags & TJFLAG_BOTTOMUP) ? "Bottom-Up" : "Top-Down ");
+    if (sf.num != 1 || sf.denom != 1)
+      printf("%d/%d ... ", sf.num, sf.denom);
+    else printf("... ");
+    TRY_TJ(tjDecompress2(handle, jpegBuf, jpegSize, dstBuf, scaledWidth, 0,
+                         scaledHeight, pf, flags));
+  }
+
+  if (checkBuf(dstBuf, scaledWidth, scaledHeight, pf, subsamp, sf, flags))
+    printf("Passed.");
+  else printf("FAILED!");
+  printf("\n");
+
+bailout:
+  free(yuvBuf);
+  free(dstBuf);
+}
+
+
+static void decompTest(tjhandle handle, unsigned char *jpegBuf,
+                       unsigned long jpegSize, int w, int h, int pf,
+                       char *basename, int subsamp, int flags)
+{
+  int i, n = 0;
+  tjscalingfactor *sf = tjGetScalingFactors(&n);
+
+  if (!sf || !n) THROW_TJ();
+
+  for (i = 0; i < n; i++) {
+    if (subsamp == TJSAMP_444 || subsamp == TJSAMP_GRAY ||
+        (subsamp == TJSAMP_411 && sf[i].num == 1 &&
+         (sf[i].denom == 2 || sf[i].denom == 1)) ||
+        (subsamp != TJSAMP_411 && sf[i].num == 1 &&
+         (sf[i].denom == 4 || sf[i].denom == 2 || sf[i].denom == 1)))
+      _decompTest(handle, jpegBuf, jpegSize, w, h, pf, basename, subsamp,
+                  flags, sf[i]);
+  }
+
+bailout:
+  return;
+}
+
+
+static void doTest(int w, int h, const int *formats, int nformats, int subsamp,
+                   char *basename)
+{
+  tjhandle chandle = NULL, dhandle = NULL;
+  unsigned char *dstBuf = NULL;
+  unsigned long size = 0;
+  int pfi, pf, i;
+
+  if (!alloc)
+    size = tjBufSize(w, h, subsamp);
+  if (size != 0)
+    if ((dstBuf = (unsigned char *)tjAlloc(size)) == NULL)
+      THROW("Memory allocation failure.");
+
+  if ((chandle = tjInitCompress()) == NULL ||
+      (dhandle = tjInitDecompress()) == NULL)
+    THROW_TJ();
+
+  for (pfi = 0; pfi < nformats; pfi++) {
+    for (i = 0; i < 2; i++) {
+      int flags = 0;
+
+      if (subsamp == TJSAMP_422 || subsamp == TJSAMP_420 ||
+          subsamp == TJSAMP_440 || subsamp == TJSAMP_411)
+        flags |= TJFLAG_FASTUPSAMPLE;
+      if (i == 1) flags |= TJFLAG_BOTTOMUP;
+      pf = formats[pfi];
+      compTest(chandle, &dstBuf, &size, w, h, pf, basename, subsamp, 100,
+               flags);
+      decompTest(dhandle, dstBuf, size, w, h, pf, basename, subsamp, flags);
+      if (pf >= TJPF_RGBX && pf <= TJPF_XRGB) {
+        printf("\n");
+        decompTest(dhandle, dstBuf, size, w, h, pf + (TJPF_RGBA - TJPF_RGBX),
+                   basename, subsamp, flags);
+      }
+      printf("\n");
+    }
+  }
+  printf("--------------------\n\n");
+
+bailout:
+  if (chandle) tjDestroy(chandle);
+  if (dhandle) tjDestroy(dhandle);
+  tjFree(dstBuf);
+}
+
+
+#if SIZEOF_SIZE_T == 8
+#define CHECKSIZE(function) { \
+  if ((unsigned long long)size < (unsigned long long)0xFFFFFFFF) \
+    THROW(#function " overflow"); \
+}
+#else
+#define CHECKSIZE(function) { \
+  if (size != (unsigned long)(-1) || \
+      !strcmp(tjGetErrorStr2(NULL), "No error")) \
+    THROW(#function " overflow"); \
+}
+#endif
+
+static void overflowTest(void)
+{
+  /* Ensure that the various buffer size functions don't overflow */
+  unsigned long size;
+
+  size = tjBufSize(26755, 26755, TJSAMP_444);
+  CHECKSIZE(tjBufSize());
+  size = TJBUFSIZE(26755, 26755);
+  CHECKSIZE(TJBUFSIZE());
+  size = tjBufSizeYUV2(37838, 1, 37838, TJSAMP_444);
+  CHECKSIZE(tjBufSizeYUV2());
+  size = TJBUFSIZEYUV(37838, 37838, TJSAMP_444);
+  CHECKSIZE(TJBUFSIZEYUV());
+  size = tjBufSizeYUV(37838, 37838, TJSAMP_444);
+  CHECKSIZE(tjBufSizeYUV());
+  size = tjPlaneSizeYUV(0, 65536, 0, 65536, TJSAMP_444);
+  CHECKSIZE(tjPlaneSizeYUV());
+
+bailout:
+  return;
+}
+
+
+static void bufSizeTest(void)
+{
+  int w, h, i, subsamp;
+  unsigned char *srcBuf = NULL, *dstBuf = NULL;
+  tjhandle handle = NULL;
+  unsigned long dstSize = 0;
+
+  if ((handle = tjInitCompress()) == NULL) THROW_TJ();
+
+  printf("Buffer size regression test\n");
+  for (subsamp = 0; subsamp < TJ_NUMSAMP; subsamp++) {
+    for (w = 1; w < 48; w++) {
+      int maxh = (w == 1) ? 2048 : 48;
+
+      for (h = 1; h < maxh; h++) {
+        if (h % 100 == 0) printf("%.4d x %.4d\b\b\b\b\b\b\b\b\b\b\b", w, h);
+        if ((srcBuf = (unsigned char *)malloc(w * h * 4)) == NULL)
+          THROW("Memory allocation failure");
+        if (!alloc || doYUV) {
+          if (doYUV) dstSize = tjBufSizeYUV2(w, pad, h, subsamp);
+          else dstSize = tjBufSize(w, h, subsamp);
+          if ((dstBuf = (unsigned char *)tjAlloc(dstSize)) == NULL)
+            THROW("Memory allocation failure");
+        }
+
+        for (i = 0; i < w * h * 4; i++) {
+          if (random() < RAND_MAX / 2) srcBuf[i] = 0;
+          else srcBuf[i] = 255;
+        }
+
+        if (doYUV) {
+          TRY_TJ(tjEncodeYUV3(handle, srcBuf, w, 0, h, TJPF_BGRX, dstBuf, pad,
+                              subsamp, 0));
+        } else {
+          TRY_TJ(tjCompress2(handle, srcBuf, w, 0, h, TJPF_BGRX, &dstBuf,
+                             &dstSize, subsamp, 100,
+                             alloc ? 0 : TJFLAG_NOREALLOC));
+        }
+        free(srcBuf);  srcBuf = NULL;
+        if (!alloc || doYUV) {
+          tjFree(dstBuf);  dstBuf = NULL;
+        }
+
+        if ((srcBuf = (unsigned char *)malloc(h * w * 4)) == NULL)
+          THROW("Memory allocation failure");
+        if (!alloc || doYUV) {
+          if (doYUV) dstSize = tjBufSizeYUV2(h, pad, w, subsamp);
+          else dstSize = tjBufSize(h, w, subsamp);
+          if ((dstBuf = (unsigned char *)tjAlloc(dstSize)) == NULL)
+            THROW("Memory allocation failure");
+        }
+
+        for (i = 0; i < h * w * 4; i++) {
+          if (random() < RAND_MAX / 2) srcBuf[i] = 0;
+          else srcBuf[i] = 255;
+        }
+
+        if (doYUV) {
+          TRY_TJ(tjEncodeYUV3(handle, srcBuf, h, 0, w, TJPF_BGRX, dstBuf, pad,
+                              subsamp, 0));
+        } else {
+          TRY_TJ(tjCompress2(handle, srcBuf, h, 0, w, TJPF_BGRX, &dstBuf,
+                             &dstSize, subsamp, 100,
+                             alloc ? 0 : TJFLAG_NOREALLOC));
+        }
+        free(srcBuf);  srcBuf = NULL;
+        if (!alloc || doYUV) {
+          tjFree(dstBuf);  dstBuf = NULL;
+        }
+      }
+    }
+  }
+  printf("Done.      \n");
+
+bailout:
+  free(srcBuf);
+  tjFree(dstBuf);
+  if (handle) tjDestroy(handle);
+}
+
+
+static void initBitmap(unsigned char *buf, int width, int pitch, int height,
+                       int pf, int flags)
+{
+  int roffset = tjRedOffset[pf];
+  int goffset = tjGreenOffset[pf];
+  int boffset = tjBlueOffset[pf];
+  int ps = tjPixelSize[pf];
+  int i, j;
+
+  for (j = 0; j < height; j++) {
+    int row = (flags & TJFLAG_BOTTOMUP) ? height - j - 1 : j;
+
+    for (i = 0; i < width; i++) {
+      unsigned char r = (i * 256 / width) % 256;
+      unsigned char g = (j * 256 / height) % 256;
+      unsigned char b = (j * 256 / height + i * 256 / width) % 256;
+
+      memset(&buf[row * pitch + i * ps], 0, ps);
+      if (pf == TJPF_GRAY) buf[row * pitch + i * ps] = b;
+      else if (pf == TJPF_CMYK)
+        rgb_to_cmyk(r, g, b, &buf[row * pitch + i * ps + 0],
+                    &buf[row * pitch + i * ps + 1],
+                    &buf[row * pitch + i * ps + 2],
+                    &buf[row * pitch + i * ps + 3]);
+      else {
+        buf[row * pitch + i * ps + roffset] = r;
+        buf[row * pitch + i * ps + goffset] = g;
+        buf[row * pitch + i * ps + boffset] = b;
+      }
+    }
+  }
+}
+
+
+static int cmpBitmap(unsigned char *buf, int width, int pitch, int height,
+                     int pf, int flags, int gray2rgb)
+{
+  int roffset = tjRedOffset[pf];
+  int goffset = tjGreenOffset[pf];
+  int boffset = tjBlueOffset[pf];
+  int aoffset = tjAlphaOffset[pf];
+  int ps = tjPixelSize[pf];
+  int i, j;
+
+  for (j = 0; j < height; j++) {
+    int row = (flags & TJFLAG_BOTTOMUP) ? height - j - 1 : j;
+
+    for (i = 0; i < width; i++) {
+      unsigned char r = (i * 256 / width) % 256;
+      unsigned char g = (j * 256 / height) % 256;
+      unsigned char b = (j * 256 / height + i * 256 / width) % 256;
+
+      if (pf == TJPF_GRAY) {
+        if (buf[row * pitch + i * ps] != b)
+          return 0;
+      } else if (pf == TJPF_CMYK) {
+        unsigned char rf, gf, bf;
+
+        cmyk_to_rgb(buf[row * pitch + i * ps + 0],
+                    buf[row * pitch + i * ps + 1],
+                    buf[row * pitch + i * ps + 2],
+                    buf[row * pitch + i * ps + 3], &rf, &gf, &bf);
+        if (gray2rgb) {
+          if (rf != b || gf != b || bf != b)
+            return 0;
+        } else if (rf != r || gf != g || bf != b) return 0;
+      } else {
+        if (gray2rgb) {
+          if (buf[row * pitch + i * ps + roffset] != b ||
+              buf[row * pitch + i * ps + goffset] != b ||
+              buf[row * pitch + i * ps + boffset] != b)
+            return 0;
+        } else if (buf[row * pitch + i * ps + roffset] != r ||
+                   buf[row * pitch + i * ps + goffset] != g ||
+                   buf[row * pitch + i * ps + boffset] != b)
+          return 0;
+        if (aoffset >= 0 && buf[row * pitch + i * ps + aoffset] != 0xFF)
+          return 0;
+      }
+    }
+  }
+  return 1;
+}
+
+
+static int doBmpTest(const char *ext, int width, int align, int height, int pf,
+                     int flags)
+{
+  char filename[80], *md5sum, md5buf[65];
+  int ps = tjPixelSize[pf], pitch = PAD(width * ps, align), loadWidth = 0,
+    loadHeight = 0, retval = 0, pixelFormat = pf;
+  unsigned char *buf = NULL;
+  char *md5ref;
+
+  if (pf == TJPF_GRAY) {
+    md5ref = !strcasecmp(ext, "ppm") ? "112c682e82ce5de1cca089e20d60000b" :
+                                       "51976530acf75f02beddf5d21149101d";
+  } else {
+    md5ref = !strcasecmp(ext, "ppm") ? "c0c9f772b464d1896326883a5c79c545" :
+                                       "6d659071b9bfcdee2def22cb58ddadca";
+  }
+
+  if ((buf = (unsigned char *)tjAlloc(pitch * height)) == NULL)
+    THROW("Could not allocate memory");
+  initBitmap(buf, width, pitch, height, pf, flags);
+
+  snprintf(filename, 80, "test_bmp_%s_%d_%s.%s", pixFormatStr[pf], align,
+           (flags & TJFLAG_BOTTOMUP) ? "bu" : "td", ext);
+  TRY_TJ(tjSaveImage(filename, buf, width, pitch, height, pf, flags));
+  md5sum = MD5File(filename, md5buf);
+  if (strcasecmp(md5sum, md5ref))
+    THROW_MD5(filename, md5sum, md5ref);
+
+  tjFree(buf);  buf = NULL;
+  if ((buf = tjLoadImage(filename, &loadWidth, align, &loadHeight, &pf,
+                         flags)) == NULL)
+    THROW_TJ();
+  if (width != loadWidth || height != loadHeight) {
+    printf("\n   Image dimensions of %s are bogus\n", filename);
+    retval = -1;  goto bailout;
+  }
+  if (!cmpBitmap(buf, width, pitch, height, pf, flags, 0)) {
+    printf("\n   Pixel data in %s is bogus\n", filename);
+    retval = -1;  goto bailout;
+  }
+  if (pf == TJPF_GRAY) {
+    tjFree(buf);  buf = NULL;
+    pf = TJPF_XBGR;
+    if ((buf = tjLoadImage(filename, &loadWidth, align, &loadHeight, &pf,
+                           flags)) == NULL)
+      THROW_TJ();
+    pitch = PAD(width * tjPixelSize[pf], align);
+    if (!cmpBitmap(buf, width, pitch, height, pf, flags, 1)) {
+      printf("\n   Converting %s to RGB failed\n", filename);
+      retval = -1;  goto bailout;
+    }
+
+    tjFree(buf);  buf = NULL;
+    pf = TJPF_CMYK;
+    if ((buf = tjLoadImage(filename, &loadWidth, align, &loadHeight, &pf,
+                           flags)) == NULL)
+      THROW_TJ();
+    pitch = PAD(width * tjPixelSize[pf], align);
+    if (!cmpBitmap(buf, width, pitch, height, pf, flags, 1)) {
+      printf("\n   Converting %s to CMYK failed\n", filename);
+      retval = -1;  goto bailout;
+    }
+  }
+  /* Verify that tjLoadImage() returns the proper "preferred" pixel format for
+     the file type. */
+  tjFree(buf);  buf = NULL;
+  pf = pixelFormat;
+  pixelFormat = TJPF_UNKNOWN;
+  if ((buf = tjLoadImage(filename, &loadWidth, align, &loadHeight,
+                         &pixelFormat, flags)) == NULL)
+    THROW_TJ();
+  if ((pf == TJPF_GRAY && pixelFormat != TJPF_GRAY) ||
+      (pf != TJPF_GRAY && !strcasecmp(ext, "bmp") &&
+       pixelFormat != TJPF_BGR) ||
+      (pf != TJPF_GRAY && !strcasecmp(ext, "ppm") &&
+       pixelFormat != TJPF_RGB)) {
+    printf("\n   tjLoadImage() returned unexpected pixel format: %s\n",
+           pixFormatStr[pixelFormat]);
+    retval = -1;
+  }
+  unlink(filename);
+
+bailout:
+  tjFree(buf);
+  if (exitStatus < 0) return exitStatus;
+  return retval;
+}
+
+
+static int bmpTest(void)
+{
+  int align, width = 35, height = 39, format;
+
+  for (align = 1; align <= 8; align *= 2) {
+    for (format = 0; format < TJ_NUMPF; format++) {
+      printf("%s Top-Down BMP (row alignment = %d bytes)  ...  ",
+             pixFormatStr[format], align);
+      if (doBmpTest("bmp", width, align, height, format, 0) == -1)
+        return -1;
+      printf("OK.\n");
+
+      printf("%s Top-Down PPM (row alignment = %d bytes)  ...  ",
+             pixFormatStr[format], align);
+      if (doBmpTest("ppm", width, align, height, format,
+                    TJFLAG_BOTTOMUP) == -1)
+        return -1;
+      printf("OK.\n");
+
+      printf("%s Bottom-Up BMP (row alignment = %d bytes)  ...  ",
+             pixFormatStr[format], align);
+      if (doBmpTest("bmp", width, align, height, format, 0) == -1)
+        return -1;
+      printf("OK.\n");
+
+      printf("%s Bottom-Up PPM (row alignment = %d bytes)  ...  ",
+             pixFormatStr[format], align);
+      if (doBmpTest("ppm", width, align, height, format,
+                    TJFLAG_BOTTOMUP) == -1)
+        return -1;
+      printf("OK.\n");
+    }
+  }
+
+  return 0;
+}
+
+
+int main(int argc, char *argv[])
+{
+  int i, num4bf = 5;
+
+#ifdef _WIN32
+  srand((unsigned int)time(NULL));
+#endif
+  if (argc > 1) {
+    for (i = 1; i < argc; i++) {
+      if (!strcasecmp(argv[i], "-yuv")) doYUV = 1;
+      else if (!strcasecmp(argv[i], "-noyuvpad")) pad = 1;
+      else if (!strcasecmp(argv[i], "-alloc")) alloc = 1;
+      else if (!strcasecmp(argv[i], "-bmp")) return bmpTest();
+      else usage(argv[0]);
+    }
+  }
+  if (alloc) printf("Testing automatic buffer allocation\n");
+  if (doYUV) num4bf = 4;
+  overflowTest();
+  doTest(35, 39, _3byteFormats, 2, TJSAMP_444, "test");
+  doTest(39, 41, _4byteFormats, num4bf, TJSAMP_444, "test");
+  doTest(41, 35, _3byteFormats, 2, TJSAMP_422, "test");
+  doTest(35, 39, _4byteFormats, num4bf, TJSAMP_422, "test");
+  doTest(39, 41, _3byteFormats, 2, TJSAMP_420, "test");
+  doTest(41, 35, _4byteFormats, num4bf, TJSAMP_420, "test");
+  doTest(35, 39, _3byteFormats, 2, TJSAMP_440, "test");
+  doTest(39, 41, _4byteFormats, num4bf, TJSAMP_440, "test");
+  doTest(41, 35, _3byteFormats, 2, TJSAMP_411, "test");
+  doTest(35, 39, _4byteFormats, num4bf, TJSAMP_411, "test");
+  doTest(39, 41, _onlyGray, 1, TJSAMP_GRAY, "test");
+  doTest(41, 35, _3byteFormats, 2, TJSAMP_GRAY, "test");
+  doTest(35, 39, _4byteFormats, 4, TJSAMP_GRAY, "test");
+  bufSizeTest();
+  if (doYUV) {
+    printf("\n--------------------\n\n");
+    doTest(48, 48, _onlyRGB, 1, TJSAMP_444, "test_yuv0");
+    doTest(48, 48, _onlyRGB, 1, TJSAMP_422, "test_yuv0");
+    doTest(48, 48, _onlyRGB, 1, TJSAMP_420, "test_yuv0");
+    doTest(48, 48, _onlyRGB, 1, TJSAMP_440, "test_yuv0");
+    doTest(48, 48, _onlyRGB, 1, TJSAMP_411, "test_yuv0");
+    doTest(48, 48, _onlyRGB, 1, TJSAMP_GRAY, "test_yuv0");
+    doTest(48, 48, _onlyGray, 1, TJSAMP_GRAY, "test_yuv0");
+  }
+
+  return exitStatus;
+}
diff --git a/3rdparty/libjpeg/src/tjutil.c b/3rdparty/libjpeg/src/tjutil.c
new file mode 100644
index 00000000..2018160b
--- /dev/null
+++ b/3rdparty/libjpeg/src/tjutil.c
@@ -0,0 +1,70 @@
+/*
+ * Copyright (C)2011, 2019 D. R. Commander.  All Rights Reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright notice,
+ *   this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright notice,
+ *   this list of conditions and the following disclaimer in the documentation
+ *   and/or other materials provided with the distribution.
+ * - Neither the name of the libjpeg-turbo Project nor the names of its
+ *   contributors may be used to endorse or promote products derived from this
+ *   software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE 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 HOLDERS 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.
+ */
+
+#ifdef _WIN32
+
+#include <windows.h>
+#include "tjutil.h"
+
+static double getFreq(void)
+{
+  LARGE_INTEGER freq;
+
+  if (!QueryPerformanceFrequency(&freq)) return 0.0;
+  return (double)freq.QuadPart;
+}
+
+static double f = -1.0;
+
+double getTime(void)
+{
+  LARGE_INTEGER t;
+
+  if (f < 0.0) f = getFreq();
+  if (f == 0.0) return (double)GetTickCount() / 1000.;
+  else {
+    QueryPerformanceCounter(&t);
+    return (double)t.QuadPart / f;
+  }
+}
+
+#else
+
+#include <stdlib.h>
+#include <sys/time.h>
+#include "tjutil.h"
+
+double getTime(void)
+{
+  struct timeval tv;
+
+  if (gettimeofday(&tv, NULL) < 0) return 0.0;
+  else return (double)tv.tv_sec + ((double)tv.tv_usec / 1000000.);
+}
+
+#endif
diff --git a/3rdparty/libjpeg/src/tjutil.h b/3rdparty/libjpeg/src/tjutil.h
new file mode 100644
index 00000000..f72840ce
--- /dev/null
+++ b/3rdparty/libjpeg/src/tjutil.h
@@ -0,0 +1,47 @@
+/*
+ * Copyright (C)2011 D. R. Commander.  All Rights Reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright notice,
+ *   this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright notice,
+ *   this list of conditions and the following disclaimer in the documentation
+ *   and/or other materials provided with the distribution.
+ * - Neither the name of the libjpeg-turbo Project nor the names of its
+ *   contributors may be used to endorse or promote products derived from this
+ *   software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE 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 HOLDERS 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.
+ */
+
+#ifdef _WIN32
+#ifndef __MINGW32__
+#include <stdio.h>
+#define snprintf(str, n, format, ...) \
+  _snprintf_s(str, n, _TRUNCATE, format, __VA_ARGS__)
+#endif
+#define strcasecmp  stricmp
+#define strncasecmp  strnicmp
+#endif
+
+#ifndef min
+#define min(a, b)  ((a) < (b) ? (a) : (b))
+#endif
+
+#ifndef max
+#define max(a, b)  ((a) > (b) ? (a) : (b))
+#endif
+
+extern double getTime(void);
diff --git a/3rdparty/libjpeg/src/transupp.c b/3rdparty/libjpeg/src/transupp.c
new file mode 100644
index 00000000..6e860778
--- /dev/null
+++ b/3rdparty/libjpeg/src/transupp.c
@@ -0,0 +1,2367 @@
+/*
+ * transupp.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1997-2019, Thomas G. Lane, Guido Vollbeding.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2010, 2017, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains image transformation routines and other utility code
+ * used by the jpegtran sample application.  These are NOT part of the core
+ * JPEG library.  But we keep these routines separate from jpegtran.c to
+ * ease the task of maintaining jpegtran-like programs that have other user
+ * interfaces.
+ */
+
+/* Although this file really shouldn't have access to the library internals,
+ * it's helpful to let it call jround_up() and jcopy_block_row().
+ */
+#define JPEG_INTERNALS
+
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "transupp.h"           /* My own external interface */
+#include "jpegcomp.h"
+#include <ctype.h>              /* to declare isdigit() */
+
+
+#if JPEG_LIB_VERSION >= 70
+#define dstinfo_min_DCT_h_scaled_size  dstinfo->min_DCT_h_scaled_size
+#define dstinfo_min_DCT_v_scaled_size  dstinfo->min_DCT_v_scaled_size
+#else
+#define dstinfo_min_DCT_h_scaled_size  DCTSIZE
+#define dstinfo_min_DCT_v_scaled_size  DCTSIZE
+#endif
+
+
+#if TRANSFORMS_SUPPORTED
+
+/*
+ * Lossless image transformation routines.  These routines work on DCT
+ * coefficient arrays and thus do not require any lossy decompression
+ * or recompression of the image.
+ * Thanks to Guido Vollbeding for the initial design and code of this feature,
+ * and to Ben Jackson for introducing the cropping feature.
+ *
+ * Horizontal flipping is done in-place, using a single top-to-bottom
+ * pass through the virtual source array.  It will thus be much the
+ * fastest option for images larger than main memory.
+ *
+ * The other routines require a set of destination virtual arrays, so they
+ * need twice as much memory as jpegtran normally does.  The destination
+ * arrays are always written in normal scan order (top to bottom) because
+ * the virtual array manager expects this.  The source arrays will be scanned
+ * in the corresponding order, which means multiple passes through the source
+ * arrays for most of the transforms.  That could result in much thrashing
+ * if the image is larger than main memory.
+ *
+ * If cropping or trimming is involved, the destination arrays may be smaller
+ * than the source arrays.  Note it is not possible to do horizontal flip
+ * in-place when a nonzero Y crop offset is specified, since we'd have to move
+ * data from one block row to another but the virtual array manager doesn't
+ * guarantee we can touch more than one row at a time.  So in that case,
+ * we have to use a separate destination array.
+ *
+ * Some notes about the operating environment of the individual transform
+ * routines:
+ * 1. Both the source and destination virtual arrays are allocated from the
+ *    source JPEG object, and therefore should be manipulated by calling the
+ *    source's memory manager.
+ * 2. The destination's component count should be used.  It may be smaller
+ *    than the source's when forcing to grayscale.
+ * 3. Likewise the destination's sampling factors should be used.  When
+ *    forcing to grayscale the destination's sampling factors will be all 1,
+ *    and we may as well take that as the effective iMCU size.
+ * 4. When "trim" is in effect, the destination's dimensions will be the
+ *    trimmed values but the source's will be untrimmed.
+ * 5. When "crop" is in effect, the destination's dimensions will be the
+ *    cropped values but the source's will be uncropped.  Each transform
+ *    routine is responsible for picking up source data starting at the
+ *    correct X and Y offset for the crop region.  (The X and Y offsets
+ *    passed to the transform routines are measured in iMCU blocks of the
+ *    destination.)
+ * 6. All the routines assume that the source and destination buffers are
+ *    padded out to a full iMCU boundary.  This is true, although for the
+ *    source buffer it is an undocumented property of jdcoefct.c.
+ */
+
+
+LOCAL(void)
+dequant_comp(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+             jvirt_barray_ptr coef_array, JQUANT_TBL *qtblptr1)
+{
+  JDIMENSION blk_x, blk_y;
+  int offset_y, k;
+  JQUANT_TBL *qtblptr;
+  JBLOCKARRAY buffer;
+  JBLOCKROW block;
+  JCOEFPTR ptr;
+
+  qtblptr = compptr->quant_table;
+  for (blk_y = 0; blk_y < compptr->height_in_blocks;
+       blk_y += compptr->v_samp_factor) {
+    buffer = (*cinfo->mem->access_virt_barray)
+      ((j_common_ptr)cinfo, coef_array, blk_y,
+       (JDIMENSION)compptr->v_samp_factor, TRUE);
+    for (offset_y = 0; offset_y < compptr->v_samp_factor; offset_y++) {
+      block = buffer[offset_y];
+      for (blk_x = 0; blk_x < compptr->width_in_blocks; blk_x++) {
+        ptr = block[blk_x];
+        for (k = 0; k < DCTSIZE2; k++)
+          if (qtblptr->quantval[k] != qtblptr1->quantval[k])
+            ptr[k] *= qtblptr->quantval[k] / qtblptr1->quantval[k];
+      }
+    }
+  }
+}
+
+
+LOCAL(void)
+requant_comp(j_decompress_ptr cinfo, jpeg_component_info *compptr,
+             jvirt_barray_ptr coef_array, JQUANT_TBL *qtblptr1)
+{
+  JDIMENSION blk_x, blk_y;
+  int offset_y, k;
+  JQUANT_TBL *qtblptr;
+  JBLOCKARRAY buffer;
+  JBLOCKROW block;
+  JCOEFPTR ptr;
+  JCOEF temp, qval;
+
+  qtblptr = compptr->quant_table;
+  for (blk_y = 0; blk_y < compptr->height_in_blocks;
+       blk_y += compptr->v_samp_factor) {
+    buffer = (*cinfo->mem->access_virt_barray)
+      ((j_common_ptr)cinfo, coef_array, blk_y,
+       (JDIMENSION)compptr->v_samp_factor, TRUE);
+    for (offset_y = 0; offset_y < compptr->v_samp_factor; offset_y++) {
+      block = buffer[offset_y];
+      for (blk_x = 0; blk_x < compptr->width_in_blocks; blk_x++) {
+        ptr = block[blk_x];
+        for (k = 0; k < DCTSIZE2; k++) {
+          temp = qtblptr->quantval[k];
+          qval = qtblptr1->quantval[k];
+          if (temp != qval) {
+            temp *= ptr[k];
+            /* The following quantization code is copied from jcdctmgr.c */
+#ifdef FAST_DIVIDE
+#define DIVIDE_BY(a, b)  a /= b
+#else
+#define DIVIDE_BY(a, b)  if (a >= b) a /= b;  else a = 0
+#endif
+            if (temp < 0) {
+              temp = -temp;
+              temp += qval >> 1; /* for rounding */
+              DIVIDE_BY(temp, qval);
+              temp = -temp;
+            } else {
+              temp += qval >> 1; /* for rounding */
+              DIVIDE_BY(temp, qval);
+            }
+            ptr[k] = temp;
+          }
+        }
+      }
+    }
+  }
+}
+
+
+/*
+ * Calculate largest common denominator using Euclid's algorithm.
+ */
+LOCAL(JCOEF)
+largest_common_denominator(JCOEF a, JCOEF b)
+{
+  JCOEF c;
+
+  do {
+    c = a % b;
+    a = b;
+    b = c;
+  } while (c);
+
+  return a;
+}
+
+
+LOCAL(void)
+adjust_quant(j_decompress_ptr srcinfo, jvirt_barray_ptr *src_coef_arrays,
+             j_decompress_ptr dropinfo, jvirt_barray_ptr *drop_coef_arrays,
+             boolean trim, j_compress_ptr dstinfo)
+{
+  jpeg_component_info *compptr1, *compptr2;
+  JQUANT_TBL *qtblptr1, *qtblptr2, *qtblptr3;
+  int ci, k;
+
+  for (ci = 0; ci < dstinfo->num_components && ci < dropinfo->num_components;
+       ci++) {
+    compptr1 = srcinfo->comp_info + ci;
+    compptr2 = dropinfo->comp_info + ci;
+    qtblptr1 = compptr1->quant_table;
+    qtblptr2 = compptr2->quant_table;
+    for (k = 0; k < DCTSIZE2; k++) {
+      if (qtblptr1->quantval[k] != qtblptr2->quantval[k]) {
+        if (trim)
+          requant_comp(dropinfo, compptr2, drop_coef_arrays[ci], qtblptr1);
+        else {
+          qtblptr3 = dstinfo->quant_tbl_ptrs[compptr1->quant_tbl_no];
+          for (k = 0; k < DCTSIZE2; k++)
+            if (qtblptr1->quantval[k] != qtblptr2->quantval[k])
+              qtblptr3->quantval[k] =
+                largest_common_denominator(qtblptr1->quantval[k],
+                                           qtblptr2->quantval[k]);
+          dequant_comp(srcinfo, compptr1, src_coef_arrays[ci], qtblptr3);
+          dequant_comp(dropinfo, compptr2, drop_coef_arrays[ci], qtblptr3);
+        }
+        break;
+      }
+    }
+  }
+}
+
+
+LOCAL(void)
+do_drop(j_decompress_ptr srcinfo, j_compress_ptr dstinfo,
+        JDIMENSION x_crop_offset, JDIMENSION y_crop_offset,
+        jvirt_barray_ptr *src_coef_arrays,
+        j_decompress_ptr dropinfo, jvirt_barray_ptr *drop_coef_arrays,
+        JDIMENSION drop_width, JDIMENSION drop_height)
+/* Drop (insert) the contents of another image into the source image.  If the
+ * number of components in the drop image is smaller than the number of
+ * components in the destination image, then we fill in the remaining
+ * components with zero.  This allows for dropping the contents of grayscale
+ * images into (arbitrarily sampled) color images.
+ */
+{
+  JDIMENSION comp_width, comp_height;
+  JDIMENSION blk_y, x_drop_blocks, y_drop_blocks;
+  int ci, offset_y;
+  JBLOCKARRAY src_buffer, dst_buffer;
+  jpeg_component_info *compptr;
+
+  for (ci = 0; ci < dstinfo->num_components; ci++) {
+    compptr = dstinfo->comp_info + ci;
+    comp_width = drop_width * compptr->h_samp_factor;
+    comp_height = drop_height * compptr->v_samp_factor;
+    x_drop_blocks = x_crop_offset * compptr->h_samp_factor;
+    y_drop_blocks = y_crop_offset * compptr->v_samp_factor;
+    for (blk_y = 0; blk_y < comp_height; blk_y += compptr->v_samp_factor) {
+      dst_buffer = (*srcinfo->mem->access_virt_barray)
+        ((j_common_ptr)srcinfo, src_coef_arrays[ci], blk_y + y_drop_blocks,
+         (JDIMENSION)compptr->v_samp_factor, TRUE);
+      if (ci < dropinfo->num_components) {
+        src_buffer = (*dropinfo->mem->access_virt_barray)
+          ((j_common_ptr)dropinfo, drop_coef_arrays[ci], blk_y,
+           (JDIMENSION)compptr->v_samp_factor, FALSE);
+        for (offset_y = 0; offset_y < compptr->v_samp_factor; offset_y++) {
+          jcopy_block_row(src_buffer[offset_y],
+                          dst_buffer[offset_y] + x_drop_blocks, comp_width);
+        }
+      } else {
+        for (offset_y = 0; offset_y < compptr->v_samp_factor; offset_y++) {
+          MEMZERO(dst_buffer[offset_y] + x_drop_blocks,
+                  comp_width * sizeof(JBLOCK));
+        }
+      }
+    }
+  }
+}
+
+
+LOCAL(void)
+do_crop(j_decompress_ptr srcinfo, j_compress_ptr dstinfo,
+        JDIMENSION x_crop_offset, JDIMENSION y_crop_offset,
+        jvirt_barray_ptr *src_coef_arrays,
+        jvirt_barray_ptr *dst_coef_arrays)
+/* Crop.  This is only used when no rotate/flip is requested with the crop. */
+{
+  JDIMENSION dst_blk_y, x_crop_blocks, y_crop_blocks;
+  int ci, offset_y;
+  JBLOCKARRAY src_buffer, dst_buffer;
+  jpeg_component_info *compptr;
+
+  /* We simply have to copy the right amount of data (the destination's
+   * image size) starting at the given X and Y offsets in the source.
+   */
+  for (ci = 0; ci < dstinfo->num_components; ci++) {
+    compptr = dstinfo->comp_info + ci;
+    x_crop_blocks = x_crop_offset * compptr->h_samp_factor;
+    y_crop_blocks = y_crop_offset * compptr->v_samp_factor;
+    for (dst_blk_y = 0; dst_blk_y < compptr->height_in_blocks;
+         dst_blk_y += compptr->v_samp_factor) {
+      dst_buffer = (*srcinfo->mem->access_virt_barray)
+        ((j_common_ptr)srcinfo, dst_coef_arrays[ci], dst_blk_y,
+         (JDIMENSION)compptr->v_samp_factor, TRUE);
+      src_buffer = (*srcinfo->mem->access_virt_barray)
+        ((j_common_ptr)srcinfo, src_coef_arrays[ci], dst_blk_y + y_crop_blocks,
+         (JDIMENSION)compptr->v_samp_factor, FALSE);
+      for (offset_y = 0; offset_y < compptr->v_samp_factor; offset_y++) {
+        jcopy_block_row(src_buffer[offset_y] + x_crop_blocks,
+                        dst_buffer[offset_y], compptr->width_in_blocks);
+      }
+    }
+  }
+}
+
+
+LOCAL(void)
+do_crop_ext_zero(j_decompress_ptr srcinfo, j_compress_ptr dstinfo,
+                 JDIMENSION x_crop_offset, JDIMENSION y_crop_offset,
+                 jvirt_barray_ptr *src_coef_arrays,
+                 jvirt_barray_ptr *dst_coef_arrays)
+/* Crop.  This is only used when no rotate/flip is requested with the crop.
+ * Extension: If the destination size is larger than the source, we fill in the
+ * expanded region with zero (neutral gray).  Note that we also have to zero
+ * partial iMCUs at the right and bottom edge of the source image area in this
+ * case.
+ */
+{
+  JDIMENSION MCU_cols, MCU_rows, comp_width, comp_height;
+  JDIMENSION dst_blk_y, x_crop_blocks, y_crop_blocks;
+  int ci, offset_y;
+  JBLOCKARRAY src_buffer, dst_buffer;
+  jpeg_component_info *compptr;
+
+  MCU_cols = srcinfo->output_width /
+             (dstinfo->max_h_samp_factor * dstinfo_min_DCT_h_scaled_size);
+  MCU_rows = srcinfo->output_height /
+             (dstinfo->max_v_samp_factor * dstinfo_min_DCT_v_scaled_size);
+
+  for (ci = 0; ci < dstinfo->num_components; ci++) {
+    compptr = dstinfo->comp_info + ci;
+    comp_width = MCU_cols * compptr->h_samp_factor;
+    comp_height = MCU_rows * compptr->v_samp_factor;
+    x_crop_blocks = x_crop_offset * compptr->h_samp_factor;
+    y_crop_blocks = y_crop_offset * compptr->v_samp_factor;
+    for (dst_blk_y = 0; dst_blk_y < compptr->height_in_blocks;
+         dst_blk_y += compptr->v_samp_factor) {
+      dst_buffer = (*srcinfo->mem->access_virt_barray)
+        ((j_common_ptr)srcinfo, dst_coef_arrays[ci], dst_blk_y,
+         (JDIMENSION)compptr->v_samp_factor, TRUE);
+      if (dstinfo->_jpeg_height > srcinfo->output_height) {
+        if (dst_blk_y < y_crop_blocks ||
+            dst_blk_y >= y_crop_blocks + comp_height) {
+          for (offset_y = 0; offset_y < compptr->v_samp_factor; offset_y++) {
+            MEMZERO(dst_buffer[offset_y],
+                    compptr->width_in_blocks * sizeof(JBLOCK));
+          }
+          continue;
+        }
+        src_buffer = (*srcinfo->mem->access_virt_barray)
+          ((j_common_ptr)srcinfo, src_coef_arrays[ci],
+           dst_blk_y - y_crop_blocks, (JDIMENSION)compptr->v_samp_factor,
+           FALSE);
+      } else {
+        src_buffer = (*srcinfo->mem->access_virt_barray)
+          ((j_common_ptr)srcinfo, src_coef_arrays[ci],
+           dst_blk_y + y_crop_blocks, (JDIMENSION)compptr->v_samp_factor,
+           FALSE);
+      }
+      for (offset_y = 0; offset_y < compptr->v_samp_factor; offset_y++) {
+        if (dstinfo->_jpeg_width > srcinfo->output_width) {
+          if (x_crop_blocks > 0) {
+            MEMZERO(dst_buffer[offset_y], x_crop_blocks * sizeof(JBLOCK));
+          }
+          jcopy_block_row(src_buffer[offset_y],
+                          dst_buffer[offset_y] + x_crop_blocks, comp_width);
+          if (compptr->width_in_blocks > x_crop_blocks + comp_width) {
+            MEMZERO(dst_buffer[offset_y] + x_crop_blocks + comp_width,
+                    (compptr->width_in_blocks - x_crop_blocks - comp_width) *
+                    sizeof(JBLOCK));
+          }
+        } else {
+          jcopy_block_row(src_buffer[offset_y] + x_crop_blocks,
+                          dst_buffer[offset_y], compptr->width_in_blocks);
+        }
+      }
+    }
+  }
+}
+
+
+LOCAL(void)
+do_crop_ext_flat(j_decompress_ptr srcinfo, j_compress_ptr dstinfo,
+                 JDIMENSION x_crop_offset, JDIMENSION y_crop_offset,
+                 jvirt_barray_ptr *src_coef_arrays,
+                 jvirt_barray_ptr *dst_coef_arrays)
+/* Crop.  This is only used when no rotate/flip is requested with the crop.
+ * Extension: The destination width is larger than the source, and we fill in
+ * the expanded region with the DC coefficient of the adjacent block.  Note
+ * that we also have to fill partial iMCUs at the right and bottom edge of the
+ * source image area in this case.
+ */
+{
+  JDIMENSION MCU_cols, MCU_rows, comp_width, comp_height;
+  JDIMENSION dst_blk_x, dst_blk_y, x_crop_blocks, y_crop_blocks;
+  int ci, offset_y;
+  JCOEF dc;
+  JBLOCKARRAY src_buffer, dst_buffer;
+  jpeg_component_info *compptr;
+
+  MCU_cols = srcinfo->output_width /
+             (dstinfo->max_h_samp_factor * dstinfo_min_DCT_h_scaled_size);
+  MCU_rows = srcinfo->output_height /
+             (dstinfo->max_v_samp_factor * dstinfo_min_DCT_v_scaled_size);
+
+  for (ci = 0; ci < dstinfo->num_components; ci++) {
+    compptr = dstinfo->comp_info + ci;
+    comp_width = MCU_cols * compptr->h_samp_factor;
+    comp_height = MCU_rows * compptr->v_samp_factor;
+    x_crop_blocks = x_crop_offset * compptr->h_samp_factor;
+    y_crop_blocks = y_crop_offset * compptr->v_samp_factor;
+    for (dst_blk_y = 0; dst_blk_y < compptr->height_in_blocks;
+         dst_blk_y += compptr->v_samp_factor) {
+      dst_buffer = (*srcinfo->mem->access_virt_barray)
+        ((j_common_ptr)srcinfo, dst_coef_arrays[ci], dst_blk_y,
+         (JDIMENSION)compptr->v_samp_factor, TRUE);
+      if (dstinfo->_jpeg_height > srcinfo->output_height) {
+        if (dst_blk_y < y_crop_blocks ||
+            dst_blk_y >= y_crop_blocks + comp_height) {
+          for (offset_y = 0; offset_y < compptr->v_samp_factor; offset_y++) {
+            MEMZERO(dst_buffer[offset_y],
+                    compptr->width_in_blocks * sizeof(JBLOCK));
+          }
+          continue;
+        }
+        src_buffer = (*srcinfo->mem->access_virt_barray)
+          ((j_common_ptr)srcinfo, src_coef_arrays[ci],
+           dst_blk_y - y_crop_blocks, (JDIMENSION)compptr->v_samp_factor,
+           FALSE);
+      } else {
+        src_buffer = (*srcinfo->mem->access_virt_barray)
+          ((j_common_ptr)srcinfo, src_coef_arrays[ci],
+           dst_blk_y + y_crop_blocks, (JDIMENSION)compptr->v_samp_factor,
+          FALSE);
+      }
+      for (offset_y = 0; offset_y < compptr->v_samp_factor; offset_y++) {
+        if (x_crop_blocks > 0) {
+          MEMZERO(dst_buffer[offset_y], x_crop_blocks * sizeof(JBLOCK));
+          dc = src_buffer[offset_y][0][0];
+          for (dst_blk_x = 0; dst_blk_x < x_crop_blocks; dst_blk_x++) {
+            dst_buffer[offset_y][dst_blk_x][0] = dc;
+          }
+        }
+        jcopy_block_row(src_buffer[offset_y],
+                        dst_buffer[offset_y] + x_crop_blocks, comp_width);
+        if (compptr->width_in_blocks > x_crop_blocks + comp_width) {
+          MEMZERO(dst_buffer[offset_y] + x_crop_blocks + comp_width,
+                  (compptr->width_in_blocks - x_crop_blocks - comp_width) *
+                  sizeof(JBLOCK));
+          dc = src_buffer[offset_y][comp_width - 1][0];
+          for (dst_blk_x = x_crop_blocks + comp_width;
+               dst_blk_x < compptr->width_in_blocks; dst_blk_x++) {
+            dst_buffer[offset_y][dst_blk_x][0] = dc;
+          }
+        }
+      }
+    }
+  }
+}
+
+
+LOCAL(void)
+do_crop_ext_reflect(j_decompress_ptr srcinfo, j_compress_ptr dstinfo,
+                    JDIMENSION x_crop_offset, JDIMENSION y_crop_offset,
+                    jvirt_barray_ptr *src_coef_arrays,
+                    jvirt_barray_ptr *dst_coef_arrays)
+/* Crop.  This is only used when no rotate/flip is requested with the crop.
+ * Extension: The destination width is larger than the source, and we fill in
+ * the expanded region with repeated reflections of the source image.  Note
+ * that we also have to fill partial iMCUs at the right and bottom edge of the
+ * source image area in this case.
+ */
+{
+  JDIMENSION MCU_cols, MCU_rows, comp_width, comp_height, src_blk_x;
+  JDIMENSION dst_blk_x, dst_blk_y, x_crop_blocks, y_crop_blocks;
+  int ci, k, offset_y;
+  JBLOCKARRAY src_buffer, dst_buffer;
+  JBLOCKROW src_row_ptr, dst_row_ptr;
+  JCOEFPTR src_ptr, dst_ptr;
+  jpeg_component_info *compptr;
+
+  MCU_cols = srcinfo->output_width /
+             (dstinfo->max_h_samp_factor * dstinfo_min_DCT_h_scaled_size);
+  MCU_rows = srcinfo->output_height /
+             (dstinfo->max_v_samp_factor * dstinfo_min_DCT_v_scaled_size);
+
+  for (ci = 0; ci < dstinfo->num_components; ci++) {
+    compptr = dstinfo->comp_info + ci;
+    comp_width = MCU_cols * compptr->h_samp_factor;
+    comp_height = MCU_rows * compptr->v_samp_factor;
+    x_crop_blocks = x_crop_offset * compptr->h_samp_factor;
+    y_crop_blocks = y_crop_offset * compptr->v_samp_factor;
+    for (dst_blk_y = 0; dst_blk_y < compptr->height_in_blocks;
+         dst_blk_y += compptr->v_samp_factor) {
+      dst_buffer = (*srcinfo->mem->access_virt_barray)
+        ((j_common_ptr)srcinfo, dst_coef_arrays[ci], dst_blk_y,
+         (JDIMENSION)compptr->v_samp_factor, TRUE);
+      if (dstinfo->_jpeg_height > srcinfo->output_height) {
+        if (dst_blk_y < y_crop_blocks ||
+            dst_blk_y >= y_crop_blocks + comp_height) {
+          for (offset_y = 0; offset_y < compptr->v_samp_factor; offset_y++) {
+            MEMZERO(dst_buffer[offset_y],
+                    compptr->width_in_blocks * sizeof(JBLOCK));
+          }
+          continue;
+        }
+        src_buffer = (*srcinfo->mem->access_virt_barray)
+          ((j_common_ptr)srcinfo, src_coef_arrays[ci],
+           dst_blk_y - y_crop_blocks, (JDIMENSION)compptr->v_samp_factor,
+           FALSE);
+      } else {
+        src_buffer = (*srcinfo->mem->access_virt_barray)
+          ((j_common_ptr)srcinfo, src_coef_arrays[ci],
+           dst_blk_y + y_crop_blocks, (JDIMENSION)compptr->v_samp_factor,
+           FALSE);
+      }
+      for (offset_y = 0; offset_y < compptr->v_samp_factor; offset_y++) {
+        /* Copy source region */
+        jcopy_block_row(src_buffer[offset_y],
+                        dst_buffer[offset_y] + x_crop_blocks, comp_width);
+        if (x_crop_blocks > 0) {
+          /* Reflect to left */
+          dst_row_ptr = dst_buffer[offset_y] + x_crop_blocks;
+          for (dst_blk_x = x_crop_blocks; dst_blk_x > 0;) {
+            src_row_ptr = dst_row_ptr;      /* (re)set axis of reflection */
+            for (src_blk_x = comp_width; src_blk_x > 0 && dst_blk_x > 0;
+                 src_blk_x--, dst_blk_x--) {
+              dst_ptr = *(--dst_row_ptr);   /* destination goes left */
+              src_ptr = *src_row_ptr++;     /* source goes right */
+              /* This unrolled loop doesn't need to know which row it's on. */
+              for (k = 0; k < DCTSIZE2; k += 2) {
+                *dst_ptr++ = *src_ptr++;    /* copy even column */
+                *dst_ptr++ = -(*src_ptr++); /* copy odd column with sign
+                                               change */
+              }
+            }
+          }
+        }
+        if (compptr->width_in_blocks > x_crop_blocks + comp_width) {
+          /* Reflect to right */
+          dst_row_ptr = dst_buffer[offset_y] + x_crop_blocks + comp_width;
+          for (dst_blk_x = compptr->width_in_blocks - x_crop_blocks - comp_width;
+               dst_blk_x > 0;) {
+            src_row_ptr = dst_row_ptr;      /* (re)set axis of reflection */
+            for (src_blk_x = comp_width; src_blk_x > 0 && dst_blk_x > 0;
+                 src_blk_x--, dst_blk_x--) {
+              dst_ptr = *dst_row_ptr++;     /* destination goes right */
+              src_ptr = *(--src_row_ptr);   /* source goes left */
+              /* This unrolled loop doesn't need to know which row it's on. */
+              for (k = 0; k < DCTSIZE2; k += 2) {
+                *dst_ptr++ = *src_ptr++;    /* copy even column */
+                *dst_ptr++ = -(*src_ptr++); /* copy odd column with sign
+                                               change */
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+
+LOCAL(void)
+do_wipe(j_decompress_ptr srcinfo, j_compress_ptr dstinfo,
+        JDIMENSION x_crop_offset, JDIMENSION y_crop_offset,
+        jvirt_barray_ptr *src_coef_arrays,
+        JDIMENSION drop_width, JDIMENSION drop_height)
+/* Wipe - discard image contents of specified region and fill with zero
+ * (neutral gray)
+ */
+{
+  JDIMENSION x_wipe_blocks, wipe_width;
+  JDIMENSION y_wipe_blocks, wipe_bottom;
+  int ci, offset_y;
+  JBLOCKARRAY buffer;
+  jpeg_component_info *compptr;
+
+  for (ci = 0; ci < dstinfo->num_components; ci++) {
+    compptr = dstinfo->comp_info + ci;
+    x_wipe_blocks = x_crop_offset * compptr->h_samp_factor;
+    wipe_width = drop_width * compptr->h_samp_factor;
+    y_wipe_blocks = y_crop_offset * compptr->v_samp_factor;
+    wipe_bottom = drop_height * compptr->v_samp_factor + y_wipe_blocks;
+    for (; y_wipe_blocks < wipe_bottom;
+         y_wipe_blocks += compptr->v_samp_factor) {
+      buffer = (*srcinfo->mem->access_virt_barray)
+        ((j_common_ptr)srcinfo, src_coef_arrays[ci], y_wipe_blocks,
+         (JDIMENSION)compptr->v_samp_factor, TRUE);
+      for (offset_y = 0; offset_y < compptr->v_samp_factor; offset_y++) {
+        MEMZERO(buffer[offset_y] + x_wipe_blocks, wipe_width * sizeof(JBLOCK));
+      }
+    }
+  }
+}
+
+
+LOCAL(void)
+do_flatten(j_decompress_ptr srcinfo, j_compress_ptr dstinfo,
+           JDIMENSION x_crop_offset, JDIMENSION y_crop_offset,
+           jvirt_barray_ptr *src_coef_arrays,
+           JDIMENSION drop_width, JDIMENSION drop_height)
+/* Flatten - discard image contents of specified region, similarly to wipe,
+ * but fill with the average of adjacent blocks instead of zero.
+ */
+{
+  JDIMENSION x_wipe_blocks, wipe_width, wipe_right;
+  JDIMENSION y_wipe_blocks, wipe_bottom, blk_x;
+  int ci, offset_y, dc_left_value, dc_right_value, average;
+  JBLOCKARRAY buffer;
+  jpeg_component_info *compptr;
+
+  for (ci = 0; ci < dstinfo->num_components; ci++) {
+    compptr = dstinfo->comp_info + ci;
+    x_wipe_blocks = x_crop_offset * compptr->h_samp_factor;
+    wipe_width = drop_width * compptr->h_samp_factor;
+    wipe_right = wipe_width + x_wipe_blocks;
+    y_wipe_blocks = y_crop_offset * compptr->v_samp_factor;
+    wipe_bottom = drop_height * compptr->v_samp_factor + y_wipe_blocks;
+    for (; y_wipe_blocks < wipe_bottom;
+         y_wipe_blocks += compptr->v_samp_factor) {
+      buffer = (*srcinfo->mem->access_virt_barray)
+        ((j_common_ptr)srcinfo, src_coef_arrays[ci], y_wipe_blocks,
+         (JDIMENSION)compptr->v_samp_factor, TRUE);
+      for (offset_y = 0; offset_y < compptr->v_samp_factor; offset_y++) {
+        MEMZERO(buffer[offset_y] + x_wipe_blocks, wipe_width * sizeof(JBLOCK));
+        if (x_wipe_blocks > 0) {
+          dc_left_value = buffer[offset_y][x_wipe_blocks - 1][0];
+          if (wipe_right < compptr->width_in_blocks) {
+            dc_right_value = buffer[offset_y][wipe_right][0];
+            average = (dc_left_value + dc_right_value) >> 1;
+          } else {
+            average = dc_left_value;
+          }
+        } else if (wipe_right < compptr->width_in_blocks) {
+          average = buffer[offset_y][wipe_right][0];
+        } else continue;
+        for (blk_x = x_wipe_blocks; blk_x < wipe_right; blk_x++) {
+          buffer[offset_y][blk_x][0] = (JCOEF)average;
+        }
+      }
+    }
+  }
+}
+
+
+LOCAL(void)
+do_reflect(j_decompress_ptr srcinfo, j_compress_ptr dstinfo,
+           JDIMENSION x_crop_offset, jvirt_barray_ptr *src_coef_arrays,
+           JDIMENSION drop_width, JDIMENSION drop_height)
+/* Reflect - discard image contents of specified region, similarly to wipe,
+ * but fill with repeated reflections of the outside region instead of zero.
+ * NB: y_crop_offset is assumed to be zero.
+ */
+{
+  JDIMENSION x_wipe_blocks, wipe_width;
+  JDIMENSION y_wipe_blocks, wipe_bottom;
+  JDIMENSION src_blk_x, dst_blk_x;
+  int ci, k, offset_y;
+  JBLOCKARRAY buffer;
+  JBLOCKROW src_row_ptr, dst_row_ptr;
+  JCOEFPTR src_ptr, dst_ptr;
+  jpeg_component_info *compptr;
+
+  for (ci = 0; ci < dstinfo->num_components; ci++) {
+    compptr = dstinfo->comp_info + ci;
+    x_wipe_blocks = x_crop_offset * compptr->h_samp_factor;
+    wipe_width = drop_width * compptr->h_samp_factor;
+    wipe_bottom = drop_height * compptr->v_samp_factor;
+    for (y_wipe_blocks = 0; y_wipe_blocks < wipe_bottom;
+         y_wipe_blocks += compptr->v_samp_factor) {
+      buffer = (*srcinfo->mem->access_virt_barray)
+        ((j_common_ptr)srcinfo, src_coef_arrays[ci], y_wipe_blocks,
+         (JDIMENSION)compptr->v_samp_factor, TRUE);
+      for (offset_y = 0; offset_y < compptr->v_samp_factor; offset_y++) {
+        if (x_wipe_blocks > 0) {
+          /* Reflect from left */
+          dst_row_ptr = buffer[offset_y] + x_wipe_blocks;
+          for (dst_blk_x = wipe_width; dst_blk_x > 0;) {
+            src_row_ptr = dst_row_ptr;     /* (re)set axis of reflection */
+            for (src_blk_x = x_wipe_blocks;
+                 src_blk_x > 0 && dst_blk_x > 0; src_blk_x--, dst_blk_x--) {
+              dst_ptr = *dst_row_ptr++;    /* destination goes right */
+              src_ptr = *(--src_row_ptr);  /* source goes left */
+              /* this unrolled loop doesn't need to know which row it's on... */
+              for (k = 0; k < DCTSIZE2; k += 2) {
+                *dst_ptr++ = *src_ptr++;   /* copy even column */
+                *dst_ptr++ = -(*src_ptr++); /* copy odd column with sign change */
+              }
+            }
+          }
+        } else if (compptr->width_in_blocks > x_wipe_blocks + wipe_width) {
+          /* Reflect from right */
+          dst_row_ptr = buffer[offset_y] + x_wipe_blocks + wipe_width;
+          for (dst_blk_x = wipe_width; dst_blk_x > 0;) {
+            src_row_ptr = dst_row_ptr;     /* (re)set axis of reflection */
+            src_blk_x = compptr->width_in_blocks - x_wipe_blocks - wipe_width;
+            for (; src_blk_x > 0 && dst_blk_x > 0; src_blk_x--, dst_blk_x--) {
+              dst_ptr = *(--dst_row_ptr);  /* destination goes left */
+              src_ptr = *src_row_ptr++;    /* source goes right */
+              /* this unrolled loop doesn't need to know which row it's on... */
+              for (k = 0; k < DCTSIZE2; k += 2) {
+                *dst_ptr++ = *src_ptr++;   /* copy even column */
+                *dst_ptr++ = -(*src_ptr++); /* copy odd column with sign change */
+              }
+            }
+          }
+        } else {
+          MEMZERO(buffer[offset_y] + x_wipe_blocks,
+                  wipe_width * sizeof(JBLOCK));
+        }
+      }
+    }
+  }
+}
+
+
+LOCAL(void)
+do_flip_h_no_crop(j_decompress_ptr srcinfo, j_compress_ptr dstinfo,
+                  JDIMENSION x_crop_offset, jvirt_barray_ptr *src_coef_arrays)
+/* Horizontal flip; done in-place, so no separate dest array is required.
+ * NB: this only works when y_crop_offset is zero.
+ */
+{
+  JDIMENSION MCU_cols, comp_width, blk_x, blk_y, x_crop_blocks;
+  int ci, k, offset_y;
+  JBLOCKARRAY buffer;
+  JCOEFPTR ptr1, ptr2;
+  JCOEF temp1, temp2;
+  jpeg_component_info *compptr;
+
+  /* Horizontal mirroring of DCT blocks is accomplished by swapping
+   * pairs of blocks in-place.  Within a DCT block, we perform horizontal
+   * mirroring by changing the signs of odd-numbered columns.
+   * Partial iMCUs at the right edge are left untouched.
+   */
+  MCU_cols = srcinfo->output_width /
+             (dstinfo->max_h_samp_factor * dstinfo_min_DCT_h_scaled_size);
+
+  for (ci = 0; ci < dstinfo->num_components; ci++) {
+    compptr = dstinfo->comp_info + ci;
+    comp_width = MCU_cols * compptr->h_samp_factor;
+    x_crop_blocks = x_crop_offset * compptr->h_samp_factor;
+    for (blk_y = 0; blk_y < compptr->height_in_blocks;
+         blk_y += compptr->v_samp_factor) {
+      buffer = (*srcinfo->mem->access_virt_barray)
+        ((j_common_ptr)srcinfo, src_coef_arrays[ci], blk_y,
+         (JDIMENSION)compptr->v_samp_factor, TRUE);
+      for (offset_y = 0; offset_y < compptr->v_samp_factor; offset_y++) {
+        /* Do the mirroring */
+        for (blk_x = 0; blk_x * 2 < comp_width; blk_x++) {
+          ptr1 = buffer[offset_y][blk_x];
+          ptr2 = buffer[offset_y][comp_width - blk_x - 1];
+          /* this unrolled loop doesn't need to know which row it's on... */
+          for (k = 0; k < DCTSIZE2; k += 2) {
+            temp1 = *ptr1;      /* swap even column */
+            temp2 = *ptr2;
+            *ptr1++ = temp2;
+            *ptr2++ = temp1;
+            temp1 = *ptr1;      /* swap odd column with sign change */
+            temp2 = *ptr2;
+            *ptr1++ = -temp2;
+            *ptr2++ = -temp1;
+          }
+        }
+        if (x_crop_blocks > 0) {
+          /* Now left-justify the portion of the data to be kept.
+           * We can't use a single jcopy_block_row() call because that routine
+           * depends on memcpy(), whose behavior is unspecified for overlapping
+           * source and destination areas.  Sigh.
+           */
+          for (blk_x = 0; blk_x < compptr->width_in_blocks; blk_x++) {
+            jcopy_block_row(buffer[offset_y] + blk_x + x_crop_blocks,
+                            buffer[offset_y] + blk_x, (JDIMENSION)1);
+          }
+        }
+      }
+    }
+  }
+}
+
+
+LOCAL(void)
+do_flip_h(j_decompress_ptr srcinfo, j_compress_ptr dstinfo,
+          JDIMENSION x_crop_offset, JDIMENSION y_crop_offset,
+          jvirt_barray_ptr *src_coef_arrays,
+          jvirt_barray_ptr *dst_coef_arrays)
+/* Horizontal flip in general cropping case */
+{
+  JDIMENSION MCU_cols, comp_width, dst_blk_x, dst_blk_y;
+  JDIMENSION x_crop_blocks, y_crop_blocks;
+  int ci, k, offset_y;
+  JBLOCKARRAY src_buffer, dst_buffer;
+  JBLOCKROW src_row_ptr, dst_row_ptr;
+  JCOEFPTR src_ptr, dst_ptr;
+  jpeg_component_info *compptr;
+
+  /* Here we must output into a separate array because we can't touch
+   * different rows of a single virtual array simultaneously.  Otherwise,
+   * this is essentially the same as the routine above.
+   */
+  MCU_cols = srcinfo->output_width /
+             (dstinfo->max_h_samp_factor * dstinfo_min_DCT_h_scaled_size);
+
+  for (ci = 0; ci < dstinfo->num_components; ci++) {
+    compptr = dstinfo->comp_info + ci;
+    comp_width = MCU_cols * compptr->h_samp_factor;
+    x_crop_blocks = x_crop_offset * compptr->h_samp_factor;
+    y_crop_blocks = y_crop_offset * compptr->v_samp_factor;
+    for (dst_blk_y = 0; dst_blk_y < compptr->height_in_blocks;
+         dst_blk_y += compptr->v_samp_factor) {
+      dst_buffer = (*srcinfo->mem->access_virt_barray)
+        ((j_common_ptr)srcinfo, dst_coef_arrays[ci], dst_blk_y,
+         (JDIMENSION)compptr->v_samp_factor, TRUE);
+      src_buffer = (*srcinfo->mem->access_virt_barray)
+        ((j_common_ptr)srcinfo, src_coef_arrays[ci], dst_blk_y + y_crop_blocks,
+         (JDIMENSION)compptr->v_samp_factor, FALSE);
+      for (offset_y = 0; offset_y < compptr->v_samp_factor; offset_y++) {
+        dst_row_ptr = dst_buffer[offset_y];
+        src_row_ptr = src_buffer[offset_y];
+        for (dst_blk_x = 0; dst_blk_x < compptr->width_in_blocks;
+             dst_blk_x++) {
+          if (x_crop_blocks + dst_blk_x < comp_width) {
+            /* Do the mirrorable blocks */
+            dst_ptr = dst_row_ptr[dst_blk_x];
+            src_ptr = src_row_ptr[comp_width - x_crop_blocks - dst_blk_x - 1];
+            /* this unrolled loop doesn't need to know which row it's on... */
+            for (k = 0; k < DCTSIZE2; k += 2) {
+              *dst_ptr++ = *src_ptr++;    /* copy even column */
+              *dst_ptr++ = -(*src_ptr++); /* copy odd column with sign
+                                             change */
+            }
+          } else {
+            /* Copy last partial block(s) verbatim */
+            jcopy_block_row(src_row_ptr + dst_blk_x + x_crop_blocks,
+                            dst_row_ptr + dst_blk_x, (JDIMENSION)1);
+          }
+        }
+      }
+    }
+  }
+}
+
+
+LOCAL(void)
+do_flip_v(j_decompress_ptr srcinfo, j_compress_ptr dstinfo,
+          JDIMENSION x_crop_offset, JDIMENSION y_crop_offset,
+          jvirt_barray_ptr *src_coef_arrays,
+          jvirt_barray_ptr *dst_coef_arrays)
+/* Vertical flip */
+{
+  JDIMENSION MCU_rows, comp_height, dst_blk_x, dst_blk_y;
+  JDIMENSION x_crop_blocks, y_crop_blocks;
+  int ci, i, j, offset_y;
+  JBLOCKARRAY src_buffer, dst_buffer;
+  JBLOCKROW src_row_ptr, dst_row_ptr;
+  JCOEFPTR src_ptr, dst_ptr;
+  jpeg_component_info *compptr;
+
+  /* We output into a separate array because we can't touch different
+   * rows of the source virtual array simultaneously.  Otherwise, this
+   * is a pretty straightforward analog of horizontal flip.
+   * Within a DCT block, vertical mirroring is done by changing the signs
+   * of odd-numbered rows.
+   * Partial iMCUs at the bottom edge are copied verbatim.
+   */
+  MCU_rows = srcinfo->output_height /
+             (dstinfo->max_v_samp_factor * dstinfo_min_DCT_v_scaled_size);
+
+  for (ci = 0; ci < dstinfo->num_components; ci++) {
+    compptr = dstinfo->comp_info + ci;
+    comp_height = MCU_rows * compptr->v_samp_factor;
+    x_crop_blocks = x_crop_offset * compptr->h_samp_factor;
+    y_crop_blocks = y_crop_offset * compptr->v_samp_factor;
+    for (dst_blk_y = 0; dst_blk_y < compptr->height_in_blocks;
+         dst_blk_y += compptr->v_samp_factor) {
+      dst_buffer = (*srcinfo->mem->access_virt_barray)
+        ((j_common_ptr)srcinfo, dst_coef_arrays[ci], dst_blk_y,
+         (JDIMENSION)compptr->v_samp_factor, TRUE);
+      if (y_crop_blocks + dst_blk_y < comp_height) {
+        /* Row is within the mirrorable area. */
+        src_buffer = (*srcinfo->mem->access_virt_barray)
+          ((j_common_ptr)srcinfo, src_coef_arrays[ci],
+           comp_height - y_crop_blocks - dst_blk_y -
+           (JDIMENSION)compptr->v_samp_factor,
+           (JDIMENSION)compptr->v_samp_factor, FALSE);
+      } else {
+        /* Bottom-edge blocks will be copied verbatim. */
+        src_buffer = (*srcinfo->mem->access_virt_barray)
+          ((j_common_ptr)srcinfo, src_coef_arrays[ci],
+           dst_blk_y + y_crop_blocks,
+           (JDIMENSION)compptr->v_samp_factor, FALSE);
+      }
+      for (offset_y = 0; offset_y < compptr->v_samp_factor; offset_y++) {
+        if (y_crop_blocks + dst_blk_y < comp_height) {
+          /* Row is within the mirrorable area. */
+          dst_row_ptr = dst_buffer[offset_y];
+          src_row_ptr = src_buffer[compptr->v_samp_factor - offset_y - 1];
+          src_row_ptr += x_crop_blocks;
+          for (dst_blk_x = 0; dst_blk_x < compptr->width_in_blocks;
+               dst_blk_x++) {
+            dst_ptr = dst_row_ptr[dst_blk_x];
+            src_ptr = src_row_ptr[dst_blk_x];
+            for (i = 0; i < DCTSIZE; i += 2) {
+              /* copy even row */
+              for (j = 0; j < DCTSIZE; j++)
+                *dst_ptr++ = *src_ptr++;
+              /* copy odd row with sign change */
+              for (j = 0; j < DCTSIZE; j++)
+                *dst_ptr++ = -(*src_ptr++);
+            }
+          }
+        } else {
+          /* Just copy row verbatim. */
+          jcopy_block_row(src_buffer[offset_y] + x_crop_blocks,
+                          dst_buffer[offset_y], compptr->width_in_blocks);
+        }
+      }
+    }
+  }
+}
+
+
+LOCAL(void)
+do_transpose(j_decompress_ptr srcinfo, j_compress_ptr dstinfo,
+             JDIMENSION x_crop_offset, JDIMENSION y_crop_offset,
+             jvirt_barray_ptr *src_coef_arrays,
+             jvirt_barray_ptr *dst_coef_arrays)
+/* Transpose source into destination */
+{
+  JDIMENSION dst_blk_x, dst_blk_y, x_crop_blocks, y_crop_blocks;
+  int ci, i, j, offset_x, offset_y;
+  JBLOCKARRAY src_buffer, dst_buffer;
+  JCOEFPTR src_ptr, dst_ptr;
+  jpeg_component_info *compptr;
+
+  /* Transposing pixels within a block just requires transposing the
+   * DCT coefficients.
+   * Partial iMCUs at the edges require no special treatment; we simply
+   * process all the available DCT blocks for every component.
+   */
+  for (ci = 0; ci < dstinfo->num_components; ci++) {
+    compptr = dstinfo->comp_info + ci;
+    x_crop_blocks = x_crop_offset * compptr->h_samp_factor;
+    y_crop_blocks = y_crop_offset * compptr->v_samp_factor;
+    for (dst_blk_y = 0; dst_blk_y < compptr->height_in_blocks;
+         dst_blk_y += compptr->v_samp_factor) {
+      dst_buffer = (*srcinfo->mem->access_virt_barray)
+        ((j_common_ptr)srcinfo, dst_coef_arrays[ci], dst_blk_y,
+         (JDIMENSION)compptr->v_samp_factor, TRUE);
+      for (offset_y = 0; offset_y < compptr->v_samp_factor; offset_y++) {
+        for (dst_blk_x = 0; dst_blk_x < compptr->width_in_blocks;
+             dst_blk_x += compptr->h_samp_factor) {
+          src_buffer = (*srcinfo->mem->access_virt_barray)
+            ((j_common_ptr)srcinfo, src_coef_arrays[ci],
+             dst_blk_x + x_crop_blocks,
+             (JDIMENSION)compptr->h_samp_factor, FALSE);
+          for (offset_x = 0; offset_x < compptr->h_samp_factor; offset_x++) {
+            dst_ptr = dst_buffer[offset_y][dst_blk_x + offset_x];
+            src_ptr =
+              src_buffer[offset_x][dst_blk_y + offset_y + y_crop_blocks];
+            for (i = 0; i < DCTSIZE; i++)
+              for (j = 0; j < DCTSIZE; j++)
+                dst_ptr[j * DCTSIZE + i] = src_ptr[i * DCTSIZE + j];
+          }
+        }
+      }
+    }
+  }
+}
+
+
+LOCAL(void)
+do_rot_90(j_decompress_ptr srcinfo, j_compress_ptr dstinfo,
+          JDIMENSION x_crop_offset, JDIMENSION y_crop_offset,
+          jvirt_barray_ptr *src_coef_arrays,
+          jvirt_barray_ptr *dst_coef_arrays)
+/* 90 degree rotation is equivalent to
+ *   1. Transposing the image;
+ *   2. Horizontal mirroring.
+ * These two steps are merged into a single processing routine.
+ */
+{
+  JDIMENSION MCU_cols, comp_width, dst_blk_x, dst_blk_y;
+  JDIMENSION x_crop_blocks, y_crop_blocks;
+  int ci, i, j, offset_x, offset_y;
+  JBLOCKARRAY src_buffer, dst_buffer;
+  JCOEFPTR src_ptr, dst_ptr;
+  jpeg_component_info *compptr;
+
+  /* Because of the horizontal mirror step, we can't process partial iMCUs
+   * at the (output) right edge properly.  They just get transposed and
+   * not mirrored.
+   */
+  MCU_cols = srcinfo->output_height /
+             (dstinfo->max_h_samp_factor * dstinfo_min_DCT_h_scaled_size);
+
+  for (ci = 0; ci < dstinfo->num_components; ci++) {
+    compptr = dstinfo->comp_info + ci;
+    comp_width = MCU_cols * compptr->h_samp_factor;
+    x_crop_blocks = x_crop_offset * compptr->h_samp_factor;
+    y_crop_blocks = y_crop_offset * compptr->v_samp_factor;
+    for (dst_blk_y = 0; dst_blk_y < compptr->height_in_blocks;
+         dst_blk_y += compptr->v_samp_factor) {
+      dst_buffer = (*srcinfo->mem->access_virt_barray)
+        ((j_common_ptr)srcinfo, dst_coef_arrays[ci], dst_blk_y,
+         (JDIMENSION)compptr->v_samp_factor, TRUE);
+      for (offset_y = 0; offset_y < compptr->v_samp_factor; offset_y++) {
+        for (dst_blk_x = 0; dst_blk_x < compptr->width_in_blocks;
+             dst_blk_x += compptr->h_samp_factor) {
+          if (x_crop_blocks + dst_blk_x < comp_width) {
+            /* Block is within the mirrorable area. */
+            src_buffer = (*srcinfo->mem->access_virt_barray)
+              ((j_common_ptr)srcinfo, src_coef_arrays[ci],
+               comp_width - x_crop_blocks - dst_blk_x -
+               (JDIMENSION)compptr->h_samp_factor,
+               (JDIMENSION)compptr->h_samp_factor, FALSE);
+          } else {
+            /* Edge blocks are transposed but not mirrored. */
+            src_buffer = (*srcinfo->mem->access_virt_barray)
+              ((j_common_ptr)srcinfo, src_coef_arrays[ci],
+               dst_blk_x + x_crop_blocks,
+               (JDIMENSION)compptr->h_samp_factor, FALSE);
+          }
+          for (offset_x = 0; offset_x < compptr->h_samp_factor; offset_x++) {
+            dst_ptr = dst_buffer[offset_y][dst_blk_x + offset_x];
+            if (x_crop_blocks + dst_blk_x < comp_width) {
+              /* Block is within the mirrorable area. */
+              src_ptr = src_buffer[compptr->h_samp_factor - offset_x - 1]
+                [dst_blk_y + offset_y + y_crop_blocks];
+              for (i = 0; i < DCTSIZE; i++) {
+                for (j = 0; j < DCTSIZE; j++)
+                  dst_ptr[j * DCTSIZE + i] = src_ptr[i * DCTSIZE + j];
+                i++;
+                for (j = 0; j < DCTSIZE; j++)
+                  dst_ptr[j * DCTSIZE + i] = -src_ptr[i * DCTSIZE + j];
+              }
+            } else {
+              /* Edge blocks are transposed but not mirrored. */
+              src_ptr = src_buffer[offset_x]
+                [dst_blk_y + offset_y + y_crop_blocks];
+              for (i = 0; i < DCTSIZE; i++)
+                for (j = 0; j < DCTSIZE; j++)
+                  dst_ptr[j * DCTSIZE + i] = src_ptr[i * DCTSIZE + j];
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+
+LOCAL(void)
+do_rot_270(j_decompress_ptr srcinfo, j_compress_ptr dstinfo,
+           JDIMENSION x_crop_offset, JDIMENSION y_crop_offset,
+           jvirt_barray_ptr *src_coef_arrays,
+           jvirt_barray_ptr *dst_coef_arrays)
+/* 270 degree rotation is equivalent to
+ *   1. Horizontal mirroring;
+ *   2. Transposing the image.
+ * These two steps are merged into a single processing routine.
+ */
+{
+  JDIMENSION MCU_rows, comp_height, dst_blk_x, dst_blk_y;
+  JDIMENSION x_crop_blocks, y_crop_blocks;
+  int ci, i, j, offset_x, offset_y;
+  JBLOCKARRAY src_buffer, dst_buffer;
+  JCOEFPTR src_ptr, dst_ptr;
+  jpeg_component_info *compptr;
+
+  /* Because of the horizontal mirror step, we can't process partial iMCUs
+   * at the (output) bottom edge properly.  They just get transposed and
+   * not mirrored.
+   */
+  MCU_rows = srcinfo->output_width /
+             (dstinfo->max_v_samp_factor * dstinfo_min_DCT_v_scaled_size);
+
+  for (ci = 0; ci < dstinfo->num_components; ci++) {
+    compptr = dstinfo->comp_info + ci;
+    comp_height = MCU_rows * compptr->v_samp_factor;
+    x_crop_blocks = x_crop_offset * compptr->h_samp_factor;
+    y_crop_blocks = y_crop_offset * compptr->v_samp_factor;
+    for (dst_blk_y = 0; dst_blk_y < compptr->height_in_blocks;
+         dst_blk_y += compptr->v_samp_factor) {
+      dst_buffer = (*srcinfo->mem->access_virt_barray)
+        ((j_common_ptr)srcinfo, dst_coef_arrays[ci], dst_blk_y,
+         (JDIMENSION)compptr->v_samp_factor, TRUE);
+      for (offset_y = 0; offset_y < compptr->v_samp_factor; offset_y++) {
+        for (dst_blk_x = 0; dst_blk_x < compptr->width_in_blocks;
+             dst_blk_x += compptr->h_samp_factor) {
+          src_buffer = (*srcinfo->mem->access_virt_barray)
+            ((j_common_ptr)srcinfo, src_coef_arrays[ci],
+             dst_blk_x + x_crop_blocks,
+             (JDIMENSION)compptr->h_samp_factor, FALSE);
+          for (offset_x = 0; offset_x < compptr->h_samp_factor; offset_x++) {
+            dst_ptr = dst_buffer[offset_y][dst_blk_x + offset_x];
+            if (y_crop_blocks + dst_blk_y < comp_height) {
+              /* Block is within the mirrorable area. */
+              src_ptr = src_buffer[offset_x]
+                [comp_height - y_crop_blocks - dst_blk_y - offset_y - 1];
+              for (i = 0; i < DCTSIZE; i++) {
+                for (j = 0; j < DCTSIZE; j++) {
+                  dst_ptr[j * DCTSIZE + i] = src_ptr[i * DCTSIZE + j];
+                  j++;
+                  dst_ptr[j * DCTSIZE + i] = -src_ptr[i * DCTSIZE + j];
+                }
+              }
+            } else {
+              /* Edge blocks are transposed but not mirrored. */
+              src_ptr = src_buffer[offset_x]
+                [dst_blk_y + offset_y + y_crop_blocks];
+              for (i = 0; i < DCTSIZE; i++)
+                for (j = 0; j < DCTSIZE; j++)
+                  dst_ptr[j * DCTSIZE + i] = src_ptr[i * DCTSIZE + j];
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+
+LOCAL(void)
+do_rot_180(j_decompress_ptr srcinfo, j_compress_ptr dstinfo,
+           JDIMENSION x_crop_offset, JDIMENSION y_crop_offset,
+           jvirt_barray_ptr *src_coef_arrays,
+           jvirt_barray_ptr *dst_coef_arrays)
+/* 180 degree rotation is equivalent to
+ *   1. Vertical mirroring;
+ *   2. Horizontal mirroring.
+ * These two steps are merged into a single processing routine.
+ */
+{
+  JDIMENSION MCU_cols, MCU_rows, comp_width, comp_height, dst_blk_x, dst_blk_y;
+  JDIMENSION x_crop_blocks, y_crop_blocks;
+  int ci, i, j, offset_y;
+  JBLOCKARRAY src_buffer, dst_buffer;
+  JBLOCKROW src_row_ptr, dst_row_ptr;
+  JCOEFPTR src_ptr, dst_ptr;
+  jpeg_component_info *compptr;
+
+  MCU_cols = srcinfo->output_width /
+             (dstinfo->max_h_samp_factor * dstinfo_min_DCT_h_scaled_size);
+  MCU_rows = srcinfo->output_height /
+             (dstinfo->max_v_samp_factor * dstinfo_min_DCT_v_scaled_size);
+
+  for (ci = 0; ci < dstinfo->num_components; ci++) {
+    compptr = dstinfo->comp_info + ci;
+    comp_width = MCU_cols * compptr->h_samp_factor;
+    comp_height = MCU_rows * compptr->v_samp_factor;
+    x_crop_blocks = x_crop_offset * compptr->h_samp_factor;
+    y_crop_blocks = y_crop_offset * compptr->v_samp_factor;
+    for (dst_blk_y = 0; dst_blk_y < compptr->height_in_blocks;
+         dst_blk_y += compptr->v_samp_factor) {
+      dst_buffer = (*srcinfo->mem->access_virt_barray)
+        ((j_common_ptr)srcinfo, dst_coef_arrays[ci], dst_blk_y,
+         (JDIMENSION)compptr->v_samp_factor, TRUE);
+      if (y_crop_blocks + dst_blk_y < comp_height) {
+        /* Row is within the vertically mirrorable area. */
+        src_buffer = (*srcinfo->mem->access_virt_barray)
+          ((j_common_ptr)srcinfo, src_coef_arrays[ci],
+           comp_height - y_crop_blocks - dst_blk_y -
+           (JDIMENSION)compptr->v_samp_factor,
+           (JDIMENSION)compptr->v_samp_factor, FALSE);
+      } else {
+        /* Bottom-edge rows are only mirrored horizontally. */
+        src_buffer = (*srcinfo->mem->access_virt_barray)
+          ((j_common_ptr)srcinfo, src_coef_arrays[ci],
+           dst_blk_y + y_crop_blocks,
+           (JDIMENSION)compptr->v_samp_factor, FALSE);
+      }
+      for (offset_y = 0; offset_y < compptr->v_samp_factor; offset_y++) {
+        dst_row_ptr = dst_buffer[offset_y];
+        if (y_crop_blocks + dst_blk_y < comp_height) {
+          /* Row is within the mirrorable area. */
+          src_row_ptr = src_buffer[compptr->v_samp_factor - offset_y - 1];
+          for (dst_blk_x = 0; dst_blk_x < compptr->width_in_blocks;
+               dst_blk_x++) {
+            dst_ptr = dst_row_ptr[dst_blk_x];
+            if (x_crop_blocks + dst_blk_x < comp_width) {
+              /* Process the blocks that can be mirrored both ways. */
+              src_ptr =
+                src_row_ptr[comp_width - x_crop_blocks - dst_blk_x - 1];
+              for (i = 0; i < DCTSIZE; i += 2) {
+                /* For even row, negate every odd column. */
+                for (j = 0; j < DCTSIZE; j += 2) {
+                  *dst_ptr++ = *src_ptr++;
+                  *dst_ptr++ = -(*src_ptr++);
+                }
+                /* For odd row, negate every even column. */
+                for (j = 0; j < DCTSIZE; j += 2) {
+                  *dst_ptr++ = -(*src_ptr++);
+                  *dst_ptr++ = *src_ptr++;
+                }
+              }
+            } else {
+              /* Any remaining right-edge blocks are only mirrored vertically. */
+              src_ptr = src_row_ptr[x_crop_blocks + dst_blk_x];
+              for (i = 0; i < DCTSIZE; i += 2) {
+                for (j = 0; j < DCTSIZE; j++)
+                  *dst_ptr++ = *src_ptr++;
+                for (j = 0; j < DCTSIZE; j++)
+                  *dst_ptr++ = -(*src_ptr++);
+              }
+            }
+          }
+        } else {
+          /* Remaining rows are just mirrored horizontally. */
+          src_row_ptr = src_buffer[offset_y];
+          for (dst_blk_x = 0; dst_blk_x < compptr->width_in_blocks;
+               dst_blk_x++) {
+            if (x_crop_blocks + dst_blk_x < comp_width) {
+              /* Process the blocks that can be mirrored. */
+              dst_ptr = dst_row_ptr[dst_blk_x];
+              src_ptr =
+                src_row_ptr[comp_width - x_crop_blocks - dst_blk_x - 1];
+              for (i = 0; i < DCTSIZE2; i += 2) {
+                *dst_ptr++ = *src_ptr++;
+                *dst_ptr++ = -(*src_ptr++);
+              }
+            } else {
+              /* Any remaining right-edge blocks are only copied. */
+              jcopy_block_row(src_row_ptr + dst_blk_x + x_crop_blocks,
+                              dst_row_ptr + dst_blk_x, (JDIMENSION)1);
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+
+LOCAL(void)
+do_transverse(j_decompress_ptr srcinfo, j_compress_ptr dstinfo,
+              JDIMENSION x_crop_offset, JDIMENSION y_crop_offset,
+              jvirt_barray_ptr *src_coef_arrays,
+              jvirt_barray_ptr *dst_coef_arrays)
+/* Transverse transpose is equivalent to
+ *   1. 180 degree rotation;
+ *   2. Transposition;
+ * or
+ *   1. Horizontal mirroring;
+ *   2. Transposition;
+ *   3. Horizontal mirroring.
+ * These steps are merged into a single processing routine.
+ */
+{
+  JDIMENSION MCU_cols, MCU_rows, comp_width, comp_height, dst_blk_x, dst_blk_y;
+  JDIMENSION x_crop_blocks, y_crop_blocks;
+  int ci, i, j, offset_x, offset_y;
+  JBLOCKARRAY src_buffer, dst_buffer;
+  JCOEFPTR src_ptr, dst_ptr;
+  jpeg_component_info *compptr;
+
+  MCU_cols = srcinfo->output_height /
+             (dstinfo->max_h_samp_factor * dstinfo_min_DCT_h_scaled_size);
+  MCU_rows = srcinfo->output_width /
+             (dstinfo->max_v_samp_factor * dstinfo_min_DCT_v_scaled_size);
+
+  for (ci = 0; ci < dstinfo->num_components; ci++) {
+    compptr = dstinfo->comp_info + ci;
+    comp_width = MCU_cols * compptr->h_samp_factor;
+    comp_height = MCU_rows * compptr->v_samp_factor;
+    x_crop_blocks = x_crop_offset * compptr->h_samp_factor;
+    y_crop_blocks = y_crop_offset * compptr->v_samp_factor;
+    for (dst_blk_y = 0; dst_blk_y < compptr->height_in_blocks;
+         dst_blk_y += compptr->v_samp_factor) {
+      dst_buffer = (*srcinfo->mem->access_virt_barray)
+        ((j_common_ptr)srcinfo, dst_coef_arrays[ci], dst_blk_y,
+         (JDIMENSION)compptr->v_samp_factor, TRUE);
+      for (offset_y = 0; offset_y < compptr->v_samp_factor; offset_y++) {
+        for (dst_blk_x = 0; dst_blk_x < compptr->width_in_blocks;
+             dst_blk_x += compptr->h_samp_factor) {
+          if (x_crop_blocks + dst_blk_x < comp_width) {
+            /* Block is within the mirrorable area. */
+            src_buffer = (*srcinfo->mem->access_virt_barray)
+              ((j_common_ptr)srcinfo, src_coef_arrays[ci],
+               comp_width - x_crop_blocks - dst_blk_x -
+               (JDIMENSION)compptr->h_samp_factor,
+               (JDIMENSION)compptr->h_samp_factor, FALSE);
+          } else {
+            src_buffer = (*srcinfo->mem->access_virt_barray)
+              ((j_common_ptr)srcinfo, src_coef_arrays[ci],
+               dst_blk_x + x_crop_blocks,
+               (JDIMENSION)compptr->h_samp_factor, FALSE);
+          }
+          for (offset_x = 0; offset_x < compptr->h_samp_factor; offset_x++) {
+            dst_ptr = dst_buffer[offset_y][dst_blk_x + offset_x];
+            if (y_crop_blocks + dst_blk_y < comp_height) {
+              if (x_crop_blocks + dst_blk_x < comp_width) {
+                /* Block is within the mirrorable area. */
+                src_ptr = src_buffer[compptr->h_samp_factor - offset_x - 1]
+                  [comp_height - y_crop_blocks - dst_blk_y - offset_y - 1];
+                for (i = 0; i < DCTSIZE; i++) {
+                  for (j = 0; j < DCTSIZE; j++) {
+                    dst_ptr[j * DCTSIZE + i] = src_ptr[i * DCTSIZE + j];
+                    j++;
+                    dst_ptr[j * DCTSIZE + i] = -src_ptr[i * DCTSIZE + j];
+                  }
+                  i++;
+                  for (j = 0; j < DCTSIZE; j++) {
+                    dst_ptr[j * DCTSIZE + i] = -src_ptr[i * DCTSIZE + j];
+                    j++;
+                    dst_ptr[j * DCTSIZE + i] = src_ptr[i * DCTSIZE + j];
+                  }
+                }
+              } else {
+                /* Right-edge blocks are mirrored in y only */
+                src_ptr = src_buffer[offset_x]
+                  [comp_height - y_crop_blocks - dst_blk_y - offset_y - 1];
+                for (i = 0; i < DCTSIZE; i++) {
+                  for (j = 0; j < DCTSIZE; j++) {
+                    dst_ptr[j * DCTSIZE + i] = src_ptr[i * DCTSIZE + j];
+                    j++;
+                    dst_ptr[j * DCTSIZE + i] = -src_ptr[i * DCTSIZE + j];
+                  }
+                }
+              }
+            } else {
+              if (x_crop_blocks + dst_blk_x < comp_width) {
+                /* Bottom-edge blocks are mirrored in x only */
+                src_ptr = src_buffer[compptr->h_samp_factor - offset_x - 1]
+                  [dst_blk_y + offset_y + y_crop_blocks];
+                for (i = 0; i < DCTSIZE; i++) {
+                  for (j = 0; j < DCTSIZE; j++)
+                    dst_ptr[j * DCTSIZE + i] = src_ptr[i * DCTSIZE + j];
+                  i++;
+                  for (j = 0; j < DCTSIZE; j++)
+                    dst_ptr[j * DCTSIZE + i] = -src_ptr[i * DCTSIZE + j];
+                }
+              } else {
+                /* At lower right corner, just transpose, no mirroring */
+                src_ptr = src_buffer[offset_x]
+                  [dst_blk_y + offset_y + y_crop_blocks];
+                for (i = 0; i < DCTSIZE; i++)
+                  for (j = 0; j < DCTSIZE; j++)
+                    dst_ptr[j * DCTSIZE + i] = src_ptr[i * DCTSIZE + j];
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+
+/* Parse an unsigned integer: subroutine for jtransform_parse_crop_spec.
+ * Returns TRUE if valid integer found, FALSE if not.
+ * *strptr is advanced over the digit string, and *result is set to its value.
+ */
+
+LOCAL(boolean)
+jt_read_integer(const char **strptr, JDIMENSION *result)
+{
+  const char *ptr = *strptr;
+  JDIMENSION val = 0;
+
+  for (; isdigit(*ptr); ptr++) {
+    val = val * 10 + (JDIMENSION)(*ptr - '0');
+  }
+  *result = val;
+  if (ptr == *strptr)
+    return FALSE;               /* oops, no digits */
+  *strptr = ptr;
+  return TRUE;
+}
+
+
+/* Parse a crop specification (written in X11 geometry style).
+ * The routine returns TRUE if the spec string is valid, FALSE if not.
+ *
+ * The crop spec string should have the format
+ *      <width>[{fr}]x<height>[{fr}]{+-}<xoffset>{+-}<yoffset>
+ * where width, height, xoffset, and yoffset are unsigned integers.
+ * Each of the elements can be omitted to indicate a default value.
+ * (A weakness of this style is that it is not possible to omit xoffset
+ * while specifying yoffset, since they look alike.)
+ *
+ * This code is loosely based on XParseGeometry from the X11 distribution.
+ */
+
+GLOBAL(boolean)
+jtransform_parse_crop_spec(jpeg_transform_info *info, const char *spec)
+{
+  info->crop = FALSE;
+  info->crop_width_set = JCROP_UNSET;
+  info->crop_height_set = JCROP_UNSET;
+  info->crop_xoffset_set = JCROP_UNSET;
+  info->crop_yoffset_set = JCROP_UNSET;
+
+  if (isdigit(*spec)) {
+    /* fetch width */
+    if (!jt_read_integer(&spec, &info->crop_width))
+      return FALSE;
+    if (*spec == 'f' || *spec == 'F') {
+      spec++;
+      info->crop_width_set = JCROP_FORCE;
+    } else if (*spec == 'r' || *spec == 'R') {
+      spec++;
+      info->crop_width_set = JCROP_REFLECT;
+    } else
+      info->crop_width_set = JCROP_POS;
+  }
+  if (*spec == 'x' || *spec == 'X') {
+    /* fetch height */
+    spec++;
+    if (!jt_read_integer(&spec, &info->crop_height))
+      return FALSE;
+    if (*spec == 'f' || *spec == 'F') {
+      spec++;
+      info->crop_height_set = JCROP_FORCE;
+    } else if (*spec == 'r' || *spec == 'R') {
+      spec++;
+      info->crop_height_set = JCROP_REFLECT;
+    } else
+      info->crop_height_set = JCROP_POS;
+  }
+  if (*spec == '+' || *spec == '-') {
+    /* fetch xoffset */
+    info->crop_xoffset_set = (*spec == '-') ? JCROP_NEG : JCROP_POS;
+    spec++;
+    if (!jt_read_integer(&spec, &info->crop_xoffset))
+      return FALSE;
+  }
+  if (*spec == '+' || *spec == '-') {
+    /* fetch yoffset */
+    info->crop_yoffset_set = (*spec == '-') ? JCROP_NEG : JCROP_POS;
+    spec++;
+    if (!jt_read_integer(&spec, &info->crop_yoffset))
+      return FALSE;
+  }
+  /* We had better have gotten to the end of the string. */
+  if (*spec != '\0')
+    return FALSE;
+  info->crop = TRUE;
+  return TRUE;
+}
+
+
+/* Trim off any partial iMCUs on the indicated destination edge */
+
+LOCAL(void)
+trim_right_edge(jpeg_transform_info *info, JDIMENSION full_width)
+{
+  JDIMENSION MCU_cols;
+
+  MCU_cols = info->output_width / info->iMCU_sample_width;
+  if (MCU_cols > 0 && info->x_crop_offset + MCU_cols ==
+      full_width / info->iMCU_sample_width)
+    info->output_width = MCU_cols * info->iMCU_sample_width;
+}
+
+LOCAL(void)
+trim_bottom_edge(jpeg_transform_info *info, JDIMENSION full_height)
+{
+  JDIMENSION MCU_rows;
+
+  MCU_rows = info->output_height / info->iMCU_sample_height;
+  if (MCU_rows > 0 && info->y_crop_offset + MCU_rows ==
+      full_height / info->iMCU_sample_height)
+    info->output_height = MCU_rows * info->iMCU_sample_height;
+}
+
+
+/* Request any required workspace.
+ *
+ * This routine figures out the size that the output image will be
+ * (which implies that all the transform parameters must be set before
+ * it is called).
+ *
+ * We allocate the workspace virtual arrays from the source decompression
+ * object, so that all the arrays (both the original data and the workspace)
+ * will be taken into account while making memory management decisions.
+ * Hence, this routine must be called after jpeg_read_header (which reads
+ * the image dimensions) and before jpeg_read_coefficients (which realizes
+ * the source's virtual arrays).
+ *
+ * This function returns FALSE right away if -perfect is given
+ * and transformation is not perfect.  Otherwise returns TRUE.
+ */
+
+GLOBAL(boolean)
+jtransform_request_workspace(j_decompress_ptr srcinfo,
+                             jpeg_transform_info *info)
+{
+  jvirt_barray_ptr *coef_arrays;
+  boolean need_workspace, transpose_it;
+  jpeg_component_info *compptr;
+  JDIMENSION xoffset, yoffset, dtemp;
+  JDIMENSION width_in_iMCUs, height_in_iMCUs;
+  JDIMENSION width_in_blocks, height_in_blocks;
+  int itemp, ci, h_samp_factor, v_samp_factor;
+
+  /* Determine number of components in output image */
+  if (info->force_grayscale &&
+      srcinfo->jpeg_color_space == JCS_YCbCr &&
+      srcinfo->num_components == 3)
+    /* We'll only process the first component */
+    info->num_components = 1;
+  else
+    /* Process all the components */
+    info->num_components = srcinfo->num_components;
+
+  /* Compute output image dimensions and related values. */
+#if JPEG_LIB_VERSION >= 80
+  jpeg_core_output_dimensions(srcinfo);
+#else
+  srcinfo->output_width = srcinfo->image_width;
+  srcinfo->output_height = srcinfo->image_height;
+#endif
+
+  /* Return right away if -perfect is given and transformation is not perfect.
+   */
+  if (info->perfect) {
+    if (info->num_components == 1) {
+      if (!jtransform_perfect_transform(srcinfo->output_width,
+          srcinfo->output_height,
+          srcinfo->_min_DCT_h_scaled_size,
+          srcinfo->_min_DCT_v_scaled_size,
+          info->transform))
+        return FALSE;
+    } else {
+      if (!jtransform_perfect_transform(srcinfo->output_width,
+          srcinfo->output_height,
+          srcinfo->max_h_samp_factor * srcinfo->_min_DCT_h_scaled_size,
+          srcinfo->max_v_samp_factor * srcinfo->_min_DCT_v_scaled_size,
+          info->transform))
+        return FALSE;
+    }
+  }
+
+  /* If there is only one output component, force the iMCU size to be 1;
+   * else use the source iMCU size.  (This allows us to do the right thing
+   * when reducing color to grayscale, and also provides a handy way of
+   * cleaning up "funny" grayscale images whose sampling factors are not 1x1.)
+   */
+  switch (info->transform) {
+  case JXFORM_TRANSPOSE:
+  case JXFORM_TRANSVERSE:
+  case JXFORM_ROT_90:
+  case JXFORM_ROT_270:
+    info->output_width = srcinfo->output_height;
+    info->output_height = srcinfo->output_width;
+    if (info->num_components == 1) {
+      info->iMCU_sample_width = srcinfo->_min_DCT_v_scaled_size;
+      info->iMCU_sample_height = srcinfo->_min_DCT_h_scaled_size;
+    } else {
+      info->iMCU_sample_width =
+        srcinfo->max_v_samp_factor * srcinfo->_min_DCT_v_scaled_size;
+      info->iMCU_sample_height =
+        srcinfo->max_h_samp_factor * srcinfo->_min_DCT_h_scaled_size;
+    }
+    break;
+  default:
+    info->output_width = srcinfo->output_width;
+    info->output_height = srcinfo->output_height;
+    if (info->num_components == 1) {
+      info->iMCU_sample_width = srcinfo->_min_DCT_h_scaled_size;
+      info->iMCU_sample_height = srcinfo->_min_DCT_v_scaled_size;
+    } else {
+      info->iMCU_sample_width =
+        srcinfo->max_h_samp_factor * srcinfo->_min_DCT_h_scaled_size;
+      info->iMCU_sample_height =
+        srcinfo->max_v_samp_factor * srcinfo->_min_DCT_v_scaled_size;
+    }
+    break;
+  }
+
+  /* If cropping has been requested, compute the crop area's position and
+   * dimensions, ensuring that its upper left corner falls at an iMCU boundary.
+   */
+  if (info->crop) {
+    /* Insert default values for unset crop parameters */
+    if (info->crop_xoffset_set == JCROP_UNSET)
+      info->crop_xoffset = 0;   /* default to +0 */
+    if (info->crop_yoffset_set == JCROP_UNSET)
+      info->crop_yoffset = 0;   /* default to +0 */
+    if (info->crop_width_set == JCROP_UNSET) {
+      if (info->crop_xoffset >= info->output_width)
+        ERREXIT(srcinfo, JERR_BAD_CROP_SPEC);
+      info->crop_width = info->output_width - info->crop_xoffset;
+    } else {
+      /* Check for crop extension */
+      if (info->crop_width > info->output_width) {
+        /* Crop extension does not work when transforming! */
+        if (info->transform != JXFORM_NONE ||
+            info->crop_xoffset >= info->crop_width ||
+            info->crop_xoffset > info->crop_width - info->output_width)
+          ERREXIT(srcinfo, JERR_BAD_CROP_SPEC);
+      } else {
+        if (info->crop_xoffset >= info->output_width ||
+            info->crop_width <= 0 ||
+            info->crop_xoffset > info->output_width - info->crop_width)
+          ERREXIT(srcinfo, JERR_BAD_CROP_SPEC);
+      }
+    }
+    if (info->crop_height_set == JCROP_UNSET) {
+      if (info->crop_yoffset >= info->output_height)
+        ERREXIT(srcinfo, JERR_BAD_CROP_SPEC);
+      info->crop_height = info->output_height - info->crop_yoffset;
+    } else {
+      /* Check for crop extension */
+      if (info->crop_height > info->output_height) {
+        /* Crop extension does not work when transforming! */
+        if (info->transform != JXFORM_NONE ||
+            info->crop_yoffset >= info->crop_height ||
+            info->crop_yoffset > info->crop_height - info->output_height)
+          ERREXIT(srcinfo, JERR_BAD_CROP_SPEC);
+      } else {
+        if (info->crop_yoffset >= info->output_height ||
+            info->crop_height <= 0 ||
+            info->crop_yoffset > info->output_height - info->crop_height)
+          ERREXIT(srcinfo, JERR_BAD_CROP_SPEC);
+      }
+    }
+    /* Convert negative crop offsets into regular offsets */
+    if (info->crop_xoffset_set != JCROP_NEG)
+      xoffset = info->crop_xoffset;
+    else if (info->crop_width > info->output_width) /* crop extension */
+      xoffset = info->crop_width - info->output_width - info->crop_xoffset;
+    else
+      xoffset = info->output_width - info->crop_width - info->crop_xoffset;
+    if (info->crop_yoffset_set != JCROP_NEG)
+      yoffset = info->crop_yoffset;
+    else if (info->crop_height > info->output_height) /* crop extension */
+      yoffset = info->crop_height - info->output_height - info->crop_yoffset;
+    else
+      yoffset = info->output_height - info->crop_height - info->crop_yoffset;
+    /* Now adjust so that upper left corner falls at an iMCU boundary */
+    switch (info->transform) {
+    case JXFORM_DROP:
+      /* Ensure the effective drop region will not exceed the requested */
+      itemp = info->iMCU_sample_width;
+      dtemp = itemp - 1 - ((xoffset + itemp - 1) % itemp);
+      xoffset += dtemp;
+      if (info->crop_width <= dtemp)
+        info->drop_width = 0;
+      else if (xoffset + info->crop_width - dtemp == info->output_width)
+        /* Matching right edge: include partial iMCU */
+        info->drop_width = (info->crop_width - dtemp + itemp - 1) / itemp;
+      else
+        info->drop_width = (info->crop_width - dtemp) / itemp;
+      itemp = info->iMCU_sample_height;
+      dtemp = itemp - 1 - ((yoffset + itemp - 1) % itemp);
+      yoffset += dtemp;
+      if (info->crop_height <= dtemp)
+        info->drop_height = 0;
+      else if (yoffset + info->crop_height - dtemp == info->output_height)
+        /* Matching bottom edge: include partial iMCU */
+        info->drop_height = (info->crop_height - dtemp + itemp - 1) / itemp;
+      else
+        info->drop_height = (info->crop_height - dtemp) / itemp;
+      /* Check if sampling factors match for dropping */
+      if (info->drop_width != 0 && info->drop_height != 0)
+        for (ci = 0; ci < info->num_components &&
+                     ci < info->drop_ptr->num_components; ci++) {
+          if (info->drop_ptr->comp_info[ci].h_samp_factor *
+              srcinfo->max_h_samp_factor !=
+              srcinfo->comp_info[ci].h_samp_factor *
+              info->drop_ptr->max_h_samp_factor)
+            ERREXIT6(srcinfo, JERR_BAD_DROP_SAMPLING, ci,
+              info->drop_ptr->comp_info[ci].h_samp_factor,
+              info->drop_ptr->max_h_samp_factor,
+              srcinfo->comp_info[ci].h_samp_factor,
+              srcinfo->max_h_samp_factor, 'h');
+          if (info->drop_ptr->comp_info[ci].v_samp_factor *
+              srcinfo->max_v_samp_factor !=
+              srcinfo->comp_info[ci].v_samp_factor *
+              info->drop_ptr->max_v_samp_factor)
+            ERREXIT6(srcinfo, JERR_BAD_DROP_SAMPLING, ci,
+              info->drop_ptr->comp_info[ci].v_samp_factor,
+              info->drop_ptr->max_v_samp_factor,
+              srcinfo->comp_info[ci].v_samp_factor,
+              srcinfo->max_v_samp_factor, 'v');
+        }
+      break;
+    case JXFORM_WIPE:
+      /* Ensure the effective wipe region will cover the requested */
+      info->drop_width = (JDIMENSION)jdiv_round_up
+        ((long)(info->crop_width + (xoffset % info->iMCU_sample_width)),
+         (long)info->iMCU_sample_width);
+      info->drop_height = (JDIMENSION)jdiv_round_up
+        ((long)(info->crop_height + (yoffset % info->iMCU_sample_height)),
+         (long)info->iMCU_sample_height);
+      break;
+    default:
+      /* Ensure the effective crop region will cover the requested */
+      if (info->crop_width_set == JCROP_FORCE ||
+          info->crop_width > info->output_width)
+        info->output_width = info->crop_width;
+      else
+        info->output_width =
+          info->crop_width + (xoffset % info->iMCU_sample_width);
+      if (info->crop_height_set == JCROP_FORCE ||
+          info->crop_height > info->output_height)
+        info->output_height = info->crop_height;
+      else
+        info->output_height =
+          info->crop_height + (yoffset % info->iMCU_sample_height);
+    }
+    /* Save x/y offsets measured in iMCUs */
+    info->x_crop_offset = xoffset / info->iMCU_sample_width;
+    info->y_crop_offset = yoffset / info->iMCU_sample_height;
+  } else {
+    info->x_crop_offset = 0;
+    info->y_crop_offset = 0;
+  }
+
+  /* Figure out whether we need workspace arrays,
+   * and if so whether they are transposed relative to the source.
+   */
+  need_workspace = FALSE;
+  transpose_it = FALSE;
+  switch (info->transform) {
+  case JXFORM_NONE:
+    if (info->x_crop_offset != 0 || info->y_crop_offset != 0 ||
+        info->output_width > srcinfo->output_width ||
+        info->output_height > srcinfo->output_height)
+      need_workspace = TRUE;
+    /* No workspace needed if neither cropping nor transforming */
+    break;
+  case JXFORM_FLIP_H:
+    if (info->trim)
+      trim_right_edge(info, srcinfo->output_width);
+    if (info->y_crop_offset != 0 || info->slow_hflip)
+      need_workspace = TRUE;
+    /* do_flip_h_no_crop doesn't need a workspace array */
+    break;
+  case JXFORM_FLIP_V:
+    if (info->trim)
+      trim_bottom_edge(info, srcinfo->output_height);
+    /* Need workspace arrays having same dimensions as source image. */
+    need_workspace = TRUE;
+    break;
+  case JXFORM_TRANSPOSE:
+    /* transpose does NOT have to trim anything */
+    /* Need workspace arrays having transposed dimensions. */
+    need_workspace = TRUE;
+    transpose_it = TRUE;
+    break;
+  case JXFORM_TRANSVERSE:
+    if (info->trim) {
+      trim_right_edge(info, srcinfo->output_height);
+      trim_bottom_edge(info, srcinfo->output_width);
+    }
+    /* Need workspace arrays having transposed dimensions. */
+    need_workspace = TRUE;
+    transpose_it = TRUE;
+    break;
+  case JXFORM_ROT_90:
+    if (info->trim)
+      trim_right_edge(info, srcinfo->output_height);
+    /* Need workspace arrays having transposed dimensions. */
+    need_workspace = TRUE;
+    transpose_it = TRUE;
+    break;
+  case JXFORM_ROT_180:
+    if (info->trim) {
+      trim_right_edge(info, srcinfo->output_width);
+      trim_bottom_edge(info, srcinfo->output_height);
+    }
+    /* Need workspace arrays having same dimensions as source image. */
+    need_workspace = TRUE;
+    break;
+  case JXFORM_ROT_270:
+    if (info->trim)
+      trim_bottom_edge(info, srcinfo->output_width);
+    /* Need workspace arrays having transposed dimensions. */
+    need_workspace = TRUE;
+    transpose_it = TRUE;
+    break;
+  case JXFORM_WIPE:
+    break;
+  case JXFORM_DROP:
+    break;
+  }
+
+  /* Allocate workspace if needed.
+   * Note that we allocate arrays padded out to the next iMCU boundary,
+   * so that transform routines need not worry about missing edge blocks.
+   */
+  if (need_workspace) {
+    coef_arrays = (jvirt_barray_ptr *)
+      (*srcinfo->mem->alloc_small) ((j_common_ptr)srcinfo, JPOOL_IMAGE,
+                sizeof(jvirt_barray_ptr) * info->num_components);
+    width_in_iMCUs = (JDIMENSION)
+      jdiv_round_up((long)info->output_width, (long)info->iMCU_sample_width);
+    height_in_iMCUs = (JDIMENSION)
+      jdiv_round_up((long)info->output_height, (long)info->iMCU_sample_height);
+    for (ci = 0; ci < info->num_components; ci++) {
+      compptr = srcinfo->comp_info + ci;
+      if (info->num_components == 1) {
+        /* we're going to force samp factors to 1x1 in this case */
+        h_samp_factor = v_samp_factor = 1;
+      } else if (transpose_it) {
+        h_samp_factor = compptr->v_samp_factor;
+        v_samp_factor = compptr->h_samp_factor;
+      } else {
+        h_samp_factor = compptr->h_samp_factor;
+        v_samp_factor = compptr->v_samp_factor;
+      }
+      width_in_blocks = width_in_iMCUs * h_samp_factor;
+      height_in_blocks = height_in_iMCUs * v_samp_factor;
+      coef_arrays[ci] = (*srcinfo->mem->request_virt_barray)
+        ((j_common_ptr)srcinfo, JPOOL_IMAGE, FALSE,
+         width_in_blocks, height_in_blocks, (JDIMENSION)v_samp_factor);
+    }
+    info->workspace_coef_arrays = coef_arrays;
+  } else
+    info->workspace_coef_arrays = NULL;
+
+  return TRUE;
+}
+
+
+/* Transpose destination image parameters */
+
+LOCAL(void)
+transpose_critical_parameters(j_compress_ptr dstinfo)
+{
+  int tblno, i, j, ci, itemp;
+  jpeg_component_info *compptr;
+  JQUANT_TBL *qtblptr;
+  JDIMENSION jtemp;
+  UINT16 qtemp;
+
+  /* Transpose image dimensions */
+  jtemp = dstinfo->image_width;
+  dstinfo->image_width = dstinfo->image_height;
+  dstinfo->image_height = jtemp;
+#if JPEG_LIB_VERSION >= 70
+  itemp = dstinfo->min_DCT_h_scaled_size;
+  dstinfo->min_DCT_h_scaled_size = dstinfo->min_DCT_v_scaled_size;
+  dstinfo->min_DCT_v_scaled_size = itemp;
+#endif
+
+  /* Transpose sampling factors */
+  for (ci = 0; ci < dstinfo->num_components; ci++) {
+    compptr = dstinfo->comp_info + ci;
+    itemp = compptr->h_samp_factor;
+    compptr->h_samp_factor = compptr->v_samp_factor;
+    compptr->v_samp_factor = itemp;
+  }
+
+  /* Transpose quantization tables */
+  for (tblno = 0; tblno < NUM_QUANT_TBLS; tblno++) {
+    qtblptr = dstinfo->quant_tbl_ptrs[tblno];
+    if (qtblptr != NULL) {
+      for (i = 0; i < DCTSIZE; i++) {
+        for (j = 0; j < i; j++) {
+          qtemp = qtblptr->quantval[i * DCTSIZE + j];
+          qtblptr->quantval[i * DCTSIZE + j] =
+            qtblptr->quantval[j * DCTSIZE + i];
+          qtblptr->quantval[j * DCTSIZE + i] = qtemp;
+        }
+      }
+    }
+  }
+}
+
+
+/* Adjust Exif image parameters.
+ *
+ * We try to adjust the Tags ExifImageWidth and ExifImageHeight if possible.
+ */
+
+LOCAL(void)
+adjust_exif_parameters(JOCTET *data, unsigned int length, JDIMENSION new_width,
+                       JDIMENSION new_height)
+{
+  boolean is_motorola; /* Flag for byte order */
+  unsigned int number_of_tags, tagnum;
+  unsigned int firstoffset, offset;
+  JDIMENSION new_value;
+
+  if (length < 12) return; /* Length of an IFD entry */
+
+  /* Discover byte order */
+  if (data[0] == 0x49 && data[1] == 0x49)
+    is_motorola = FALSE;
+  else if (data[0] == 0x4D && data[1] == 0x4D)
+    is_motorola = TRUE;
+  else
+    return;
+
+  /* Check Tag Mark */
+  if (is_motorola) {
+    if (data[2] != 0) return;
+    if (data[3] != 0x2A) return;
+  } else {
+    if (data[3] != 0) return;
+    if (data[2] != 0x2A) return;
+  }
+
+  /* Get first IFD offset (offset to IFD0) */
+  if (is_motorola) {
+    if (data[4] != 0) return;
+    if (data[5] != 0) return;
+    firstoffset = data[6];
+    firstoffset <<= 8;
+    firstoffset += data[7];
+  } else {
+    if (data[7] != 0) return;
+    if (data[6] != 0) return;
+    firstoffset = data[5];
+    firstoffset <<= 8;
+    firstoffset += data[4];
+  }
+  if (firstoffset > length - 2) return; /* check end of data segment */
+
+  /* Get the number of directory entries contained in this IFD */
+  if (is_motorola) {
+    number_of_tags = data[firstoffset];
+    number_of_tags <<= 8;
+    number_of_tags += data[firstoffset + 1];
+  } else {
+    number_of_tags = data[firstoffset + 1];
+    number_of_tags <<= 8;
+    number_of_tags += data[firstoffset];
+  }
+  if (number_of_tags == 0) return;
+  firstoffset += 2;
+
+  /* Search for ExifSubIFD offset Tag in IFD0 */
+  for (;;) {
+    if (firstoffset > length - 12) return; /* check end of data segment */
+    /* Get Tag number */
+    if (is_motorola) {
+      tagnum = data[firstoffset];
+      tagnum <<= 8;
+      tagnum += data[firstoffset + 1];
+    } else {
+      tagnum = data[firstoffset + 1];
+      tagnum <<= 8;
+      tagnum += data[firstoffset];
+    }
+    if (tagnum == 0x8769) break; /* found ExifSubIFD offset Tag */
+    if (--number_of_tags == 0) return;
+    firstoffset += 12;
+  }
+
+  /* Get the ExifSubIFD offset */
+  if (is_motorola) {
+    if (data[firstoffset + 8] != 0) return;
+    if (data[firstoffset + 9] != 0) return;
+    offset = data[firstoffset + 10];
+    offset <<= 8;
+    offset += data[firstoffset + 11];
+  } else {
+    if (data[firstoffset + 11] != 0) return;
+    if (data[firstoffset + 10] != 0) return;
+    offset = data[firstoffset + 9];
+    offset <<= 8;
+    offset += data[firstoffset + 8];
+  }
+  if (offset > length - 2) return; /* check end of data segment */
+
+  /* Get the number of directory entries contained in this SubIFD */
+  if (is_motorola) {
+    number_of_tags = data[offset];
+    number_of_tags <<= 8;
+    number_of_tags += data[offset + 1];
+  } else {
+    number_of_tags = data[offset + 1];
+    number_of_tags <<= 8;
+    number_of_tags += data[offset];
+  }
+  if (number_of_tags < 2) return;
+  offset += 2;
+
+  /* Search for ExifImageWidth and ExifImageHeight Tags in this SubIFD */
+  do {
+    if (offset > length - 12) return; /* check end of data segment */
+    /* Get Tag number */
+    if (is_motorola) {
+      tagnum = data[offset];
+      tagnum <<= 8;
+      tagnum += data[offset + 1];
+    } else {
+      tagnum = data[offset + 1];
+      tagnum <<= 8;
+      tagnum += data[offset];
+    }
+    if (tagnum == 0xA002 || tagnum == 0xA003) {
+      if (tagnum == 0xA002)
+        new_value = new_width; /* ExifImageWidth Tag */
+      else
+        new_value = new_height; /* ExifImageHeight Tag */
+      if (is_motorola) {
+        data[offset + 2] = 0; /* Format = unsigned long (4 octets) */
+        data[offset + 3] = 4;
+        data[offset + 4] = 0; /* Number Of Components = 1 */
+        data[offset + 5] = 0;
+        data[offset + 6] = 0;
+        data[offset + 7] = 1;
+        data[offset + 8] = 0;
+        data[offset + 9] = 0;
+        data[offset + 10] = (JOCTET)((new_value >> 8) & 0xFF);
+        data[offset + 11] = (JOCTET)(new_value & 0xFF);
+      } else {
+        data[offset + 2] = 4; /* Format = unsigned long (4 octets) */
+        data[offset + 3] = 0;
+        data[offset + 4] = 1; /* Number Of Components = 1 */
+        data[offset + 5] = 0;
+        data[offset + 6] = 0;
+        data[offset + 7] = 0;
+        data[offset + 8] = (JOCTET)(new_value & 0xFF);
+        data[offset + 9] = (JOCTET)((new_value >> 8) & 0xFF);
+        data[offset + 10] = 0;
+        data[offset + 11] = 0;
+      }
+    }
+    offset += 12;
+  } while (--number_of_tags);
+}
+
+
+/* Adjust output image parameters as needed.
+ *
+ * This must be called after jpeg_copy_critical_parameters()
+ * and before jpeg_write_coefficients().
+ *
+ * The return value is the set of virtual coefficient arrays to be written
+ * (either the ones allocated by jtransform_request_workspace, or the
+ * original source data arrays).  The caller will need to pass this value
+ * to jpeg_write_coefficients().
+ */
+
+GLOBAL(jvirt_barray_ptr *)
+jtransform_adjust_parameters(j_decompress_ptr srcinfo, j_compress_ptr dstinfo,
+                             jvirt_barray_ptr *src_coef_arrays,
+                             jpeg_transform_info *info)
+{
+  /* If force-to-grayscale is requested, adjust destination parameters */
+  if (info->force_grayscale) {
+    /* First, ensure we have YCbCr or grayscale data, and that the source's
+     * Y channel is full resolution.  (No reasonable person would make Y
+     * be less than full resolution, so actually coping with that case
+     * isn't worth extra code space.  But we check it to avoid crashing.)
+     */
+    if (((dstinfo->jpeg_color_space == JCS_YCbCr &&
+          dstinfo->num_components == 3) ||
+         (dstinfo->jpeg_color_space == JCS_GRAYSCALE &&
+          dstinfo->num_components == 1)) &&
+        srcinfo->comp_info[0].h_samp_factor == srcinfo->max_h_samp_factor &&
+        srcinfo->comp_info[0].v_samp_factor == srcinfo->max_v_samp_factor) {
+      /* We use jpeg_set_colorspace to make sure subsidiary settings get fixed
+       * properly.  Among other things, it sets the target h_samp_factor &
+       * v_samp_factor to 1, which typically won't match the source.
+       * We have to preserve the source's quantization table number, however.
+       */
+      int sv_quant_tbl_no = dstinfo->comp_info[0].quant_tbl_no;
+      jpeg_set_colorspace(dstinfo, JCS_GRAYSCALE);
+      dstinfo->comp_info[0].quant_tbl_no = sv_quant_tbl_no;
+    } else {
+      /* Sorry, can't do it */
+      ERREXIT(dstinfo, JERR_CONVERSION_NOTIMPL);
+    }
+  } else if (info->num_components == 1) {
+    /* For a single-component source, we force the destination sampling factors
+     * to 1x1, with or without force_grayscale.  This is useful because some
+     * decoders choke on grayscale images with other sampling factors.
+     */
+    dstinfo->comp_info[0].h_samp_factor = 1;
+    dstinfo->comp_info[0].v_samp_factor = 1;
+  }
+
+  /* Correct the destination's image dimensions as necessary
+   * for rotate/flip, resize, and crop operations.
+   */
+#if JPEG_LIB_VERSION >= 80
+  dstinfo->jpeg_width = info->output_width;
+  dstinfo->jpeg_height = info->output_height;
+#endif
+
+  /* Transpose destination image parameters, adjust quantization */
+  switch (info->transform) {
+  case JXFORM_TRANSPOSE:
+  case JXFORM_TRANSVERSE:
+  case JXFORM_ROT_90:
+  case JXFORM_ROT_270:
+#if JPEG_LIB_VERSION < 80
+    dstinfo->image_width = info->output_height;
+    dstinfo->image_height = info->output_width;
+#endif
+    transpose_critical_parameters(dstinfo);
+    break;
+  case JXFORM_DROP:
+    if (info->drop_width != 0 && info->drop_height != 0)
+      adjust_quant(srcinfo, src_coef_arrays,
+                   info->drop_ptr, info->drop_coef_arrays,
+                   info->trim, dstinfo);
+    break;
+  default:
+#if JPEG_LIB_VERSION < 80
+    dstinfo->image_width = info->output_width;
+    dstinfo->image_height = info->output_height;
+#endif
+    break;
+  }
+
+  /* Adjust Exif properties */
+  if (srcinfo->marker_list != NULL &&
+      srcinfo->marker_list->marker == JPEG_APP0 + 1 &&
+      srcinfo->marker_list->data_length >= 6 &&
+      srcinfo->marker_list->data[0] == 0x45 &&
+      srcinfo->marker_list->data[1] == 0x78 &&
+      srcinfo->marker_list->data[2] == 0x69 &&
+      srcinfo->marker_list->data[3] == 0x66 &&
+      srcinfo->marker_list->data[4] == 0 &&
+      srcinfo->marker_list->data[5] == 0) {
+    /* Suppress output of JFIF marker */
+    dstinfo->write_JFIF_header = FALSE;
+    /* Adjust Exif image parameters */
+#if JPEG_LIB_VERSION >= 80
+    if (dstinfo->jpeg_width != srcinfo->image_width ||
+        dstinfo->jpeg_height != srcinfo->image_height)
+      /* Align data segment to start of TIFF structure for parsing */
+      adjust_exif_parameters(srcinfo->marker_list->data + 6,
+                             srcinfo->marker_list->data_length - 6,
+                             dstinfo->jpeg_width, dstinfo->jpeg_height);
+#else
+    if (dstinfo->image_width != srcinfo->image_width ||
+        dstinfo->image_height != srcinfo->image_height)
+      /* Align data segment to start of TIFF structure for parsing */
+      adjust_exif_parameters(srcinfo->marker_list->data + 6,
+                             srcinfo->marker_list->data_length - 6,
+                             dstinfo->image_width, dstinfo->image_height);
+#endif
+  }
+
+  /* Return the appropriate output data set */
+  if (info->workspace_coef_arrays != NULL)
+    return info->workspace_coef_arrays;
+  return src_coef_arrays;
+}
+
+
+/* Execute the actual transformation, if any.
+ *
+ * This must be called *after* jpeg_write_coefficients, because it depends
+ * on jpeg_write_coefficients to have computed subsidiary values such as
+ * the per-component width and height fields in the destination object.
+ *
+ * Note that some transformations will modify the source data arrays!
+ */
+
+GLOBAL(void)
+jtransform_execute_transform(j_decompress_ptr srcinfo, j_compress_ptr dstinfo,
+                             jvirt_barray_ptr *src_coef_arrays,
+                             jpeg_transform_info *info)
+{
+  jvirt_barray_ptr *dst_coef_arrays = info->workspace_coef_arrays;
+
+  /* Note: conditions tested here should match those in switch statement
+   * in jtransform_request_workspace()
+   */
+  switch (info->transform) {
+  case JXFORM_NONE:
+    if (info->output_width > srcinfo->output_width ||
+        info->output_height > srcinfo->output_height) {
+      if (info->output_width > srcinfo->output_width &&
+          info->crop_width_set == JCROP_REFLECT)
+        do_crop_ext_reflect(srcinfo, dstinfo,
+                            info->x_crop_offset, info->y_crop_offset,
+                            src_coef_arrays, dst_coef_arrays);
+      else if (info->output_width > srcinfo->output_width &&
+               info->crop_width_set == JCROP_FORCE)
+        do_crop_ext_flat(srcinfo, dstinfo,
+                         info->x_crop_offset, info->y_crop_offset,
+                         src_coef_arrays, dst_coef_arrays);
+      else
+        do_crop_ext_zero(srcinfo, dstinfo,
+                         info->x_crop_offset, info->y_crop_offset,
+                         src_coef_arrays, dst_coef_arrays);
+    } else if (info->x_crop_offset != 0 || info->y_crop_offset != 0)
+      do_crop(srcinfo, dstinfo, info->x_crop_offset, info->y_crop_offset,
+              src_coef_arrays, dst_coef_arrays);
+    break;
+  case JXFORM_FLIP_H:
+    if (info->y_crop_offset != 0 || info->slow_hflip)
+      do_flip_h(srcinfo, dstinfo, info->x_crop_offset, info->y_crop_offset,
+                src_coef_arrays, dst_coef_arrays);
+    else
+      do_flip_h_no_crop(srcinfo, dstinfo, info->x_crop_offset,
+                        src_coef_arrays);
+    break;
+  case JXFORM_FLIP_V:
+    do_flip_v(srcinfo, dstinfo, info->x_crop_offset, info->y_crop_offset,
+              src_coef_arrays, dst_coef_arrays);
+    break;
+  case JXFORM_TRANSPOSE:
+    do_transpose(srcinfo, dstinfo, info->x_crop_offset, info->y_crop_offset,
+                 src_coef_arrays, dst_coef_arrays);
+    break;
+  case JXFORM_TRANSVERSE:
+    do_transverse(srcinfo, dstinfo, info->x_crop_offset, info->y_crop_offset,
+                  src_coef_arrays, dst_coef_arrays);
+    break;
+  case JXFORM_ROT_90:
+    do_rot_90(srcinfo, dstinfo, info->x_crop_offset, info->y_crop_offset,
+              src_coef_arrays, dst_coef_arrays);
+    break;
+  case JXFORM_ROT_180:
+    do_rot_180(srcinfo, dstinfo, info->x_crop_offset, info->y_crop_offset,
+               src_coef_arrays, dst_coef_arrays);
+    break;
+  case JXFORM_ROT_270:
+    do_rot_270(srcinfo, dstinfo, info->x_crop_offset, info->y_crop_offset,
+               src_coef_arrays, dst_coef_arrays);
+    break;
+  case JXFORM_WIPE:
+    if (info->crop_width_set == JCROP_REFLECT &&
+        info->y_crop_offset == 0 && info->drop_height ==
+        (JDIMENSION)jdiv_round_up
+          ((long)info->output_height, (long)info->iMCU_sample_height) &&
+        (info->x_crop_offset == 0 ||
+         info->x_crop_offset + info->drop_width ==
+         (JDIMENSION)jdiv_round_up
+           ((long)info->output_width, (long)info->iMCU_sample_width)))
+      do_reflect(srcinfo, dstinfo, info->x_crop_offset,
+                 src_coef_arrays, info->drop_width, info->drop_height);
+    else if (info->crop_width_set == JCROP_FORCE)
+      do_flatten(srcinfo, dstinfo, info->x_crop_offset, info->y_crop_offset,
+                 src_coef_arrays, info->drop_width, info->drop_height);
+    else
+      do_wipe(srcinfo, dstinfo, info->x_crop_offset, info->y_crop_offset,
+              src_coef_arrays, info->drop_width, info->drop_height);
+    break;
+  case JXFORM_DROP:
+    if (info->drop_width != 0 && info->drop_height != 0)
+      do_drop(srcinfo, dstinfo, info->x_crop_offset, info->y_crop_offset,
+              src_coef_arrays, info->drop_ptr, info->drop_coef_arrays,
+              info->drop_width, info->drop_height);
+    break;
+  }
+}
+
+/* jtransform_perfect_transform
+ *
+ * Determine whether lossless transformation is perfectly
+ * possible for a specified image and transformation.
+ *
+ * Inputs:
+ *   image_width, image_height: source image dimensions.
+ *   MCU_width, MCU_height: pixel dimensions of MCU.
+ *   transform: transformation identifier.
+ * Parameter sources from initialized jpeg_struct
+ * (after reading source header):
+ *   image_width = cinfo.image_width
+ *   image_height = cinfo.image_height
+ *   MCU_width = cinfo.max_h_samp_factor * cinfo.block_size
+ *   MCU_height = cinfo.max_v_samp_factor * cinfo.block_size
+ * Result:
+ *   TRUE = perfect transformation possible
+ *   FALSE = perfect transformation not possible
+ *           (may use custom action then)
+ */
+
+GLOBAL(boolean)
+jtransform_perfect_transform(JDIMENSION image_width, JDIMENSION image_height,
+                             int MCU_width, int MCU_height,
+                             JXFORM_CODE transform)
+{
+  boolean result = TRUE; /* initialize TRUE */
+
+  switch (transform) {
+  case JXFORM_FLIP_H:
+  case JXFORM_ROT_270:
+    if (image_width % (JDIMENSION)MCU_width)
+      result = FALSE;
+    break;
+  case JXFORM_FLIP_V:
+  case JXFORM_ROT_90:
+    if (image_height % (JDIMENSION)MCU_height)
+      result = FALSE;
+    break;
+  case JXFORM_TRANSVERSE:
+  case JXFORM_ROT_180:
+    if (image_width % (JDIMENSION)MCU_width)
+      result = FALSE;
+    if (image_height % (JDIMENSION)MCU_height)
+      result = FALSE;
+    break;
+  default:
+    break;
+  }
+
+  return result;
+}
+
+#endif /* TRANSFORMS_SUPPORTED */
+
+
+/* Setup decompression object to save desired markers in memory.
+ * This must be called before jpeg_read_header() to have the desired effect.
+ */
+
+GLOBAL(void)
+jcopy_markers_setup(j_decompress_ptr srcinfo, JCOPY_OPTION option)
+{
+#ifdef SAVE_MARKERS_SUPPORTED
+  int m;
+
+  /* Save comments except under NONE option */
+  if (option != JCOPYOPT_NONE) {
+    jpeg_save_markers(srcinfo, JPEG_COM, 0xFFFF);
+  }
+  /* Save all types of APPn markers iff ALL option */
+  if (option == JCOPYOPT_ALL || option == JCOPYOPT_ALL_EXCEPT_ICC) {
+    for (m = 0; m < 16; m++) {
+      if (option == JCOPYOPT_ALL_EXCEPT_ICC && m == 2)
+        continue;
+      jpeg_save_markers(srcinfo, JPEG_APP0 + m, 0xFFFF);
+    }
+  }
+#endif /* SAVE_MARKERS_SUPPORTED */
+}
+
+/* Copy markers saved in the given source object to the destination object.
+ * This should be called just after jpeg_start_compress() or
+ * jpeg_write_coefficients().
+ * Note that those routines will have written the SOI, and also the
+ * JFIF APP0 or Adobe APP14 markers if selected.
+ */
+
+GLOBAL(void)
+jcopy_markers_execute(j_decompress_ptr srcinfo, j_compress_ptr dstinfo,
+                      JCOPY_OPTION option)
+{
+  jpeg_saved_marker_ptr marker;
+
+  /* In the current implementation, we don't actually need to examine the
+   * option flag here; we just copy everything that got saved.
+   * But to avoid confusion, we do not output JFIF and Adobe APP14 markers
+   * if the encoder library already wrote one.
+   */
+  for (marker = srcinfo->marker_list; marker != NULL; marker = marker->next) {
+    if (dstinfo->write_JFIF_header &&
+        marker->marker == JPEG_APP0 &&
+        marker->data_length >= 5 &&
+        marker->data[0] == 0x4A &&
+        marker->data[1] == 0x46 &&
+        marker->data[2] == 0x49 &&
+        marker->data[3] == 0x46 &&
+        marker->data[4] == 0)
+      continue;                 /* reject duplicate JFIF */
+    if (dstinfo->write_Adobe_marker &&
+        marker->marker == JPEG_APP0 + 14 &&
+        marker->data_length >= 5 &&
+        marker->data[0] == 0x41 &&
+        marker->data[1] == 0x64 &&
+        marker->data[2] == 0x6F &&
+        marker->data[3] == 0x62 &&
+        marker->data[4] == 0x65)
+      continue;                 /* reject duplicate Adobe */
+    jpeg_write_marker(dstinfo, marker->marker,
+                      marker->data, marker->data_length);
+  }
+}
diff --git a/3rdparty/libjpeg/src/transupp.h b/3rdparty/libjpeg/src/transupp.h
new file mode 100644
index 00000000..ea6be1fc
--- /dev/null
+++ b/3rdparty/libjpeg/src/transupp.h
@@ -0,0 +1,230 @@
+/*
+ * transupp.h
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1997-2019, Thomas G. Lane, Guido Vollbeding.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2017, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains declarations for image transformation routines and
+ * other utility code used by the jpegtran sample application.  These are
+ * NOT part of the core JPEG library.  But we keep these routines separate
+ * from jpegtran.c to ease the task of maintaining jpegtran-like programs
+ * that have other user interfaces.
+ *
+ * NOTE: all the routines declared here have very specific requirements
+ * about when they are to be executed during the reading and writing of the
+ * source and destination files.  See the comments in transupp.c, or see
+ * jpegtran.c for an example of correct usage.
+ */
+
+/* If you happen not to want the image transform support, disable it here */
+#ifndef TRANSFORMS_SUPPORTED
+#define TRANSFORMS_SUPPORTED  1         /* 0 disables transform code */
+#endif
+
+/*
+ * Although rotating and flipping data expressed as DCT coefficients is not
+ * hard, there is an asymmetry in the JPEG format specification for images
+ * whose dimensions aren't multiples of the iMCU size.  The right and bottom
+ * image edges are padded out to the next iMCU boundary with junk data; but
+ * no padding is possible at the top and left edges.  If we were to flip
+ * the whole image including the pad data, then pad garbage would become
+ * visible at the top and/or left, and real pixels would disappear into the
+ * pad margins --- perhaps permanently, since encoders & decoders may not
+ * bother to preserve DCT blocks that appear to be completely outside the
+ * nominal image area.  So, we have to exclude any partial iMCUs from the
+ * basic transformation.
+ *
+ * Transpose is the only transformation that can handle partial iMCUs at the
+ * right and bottom edges completely cleanly.  flip_h can flip partial iMCUs
+ * at the bottom, but leaves any partial iMCUs at the right edge untouched.
+ * Similarly flip_v leaves any partial iMCUs at the bottom edge untouched.
+ * The other transforms are defined as combinations of these basic transforms
+ * and process edge blocks in a way that preserves the equivalence.
+ *
+ * The "trim" option causes untransformable partial iMCUs to be dropped;
+ * this is not strictly lossless, but it usually gives the best-looking
+ * result for odd-size images.  Note that when this option is active,
+ * the expected mathematical equivalences between the transforms may not hold.
+ * (For example, -rot 270 -trim trims only the bottom edge, but -rot 90 -trim
+ * followed by -rot 180 -trim trims both edges.)
+ *
+ * We also offer a lossless-crop option, which discards data outside a given
+ * image region but losslessly preserves what is inside.  Like the rotate and
+ * flip transforms, lossless crop is restricted by the JPEG format: the upper
+ * left corner of the selected region must fall on an iMCU boundary.  If this
+ * does not hold for the given crop parameters, we silently move the upper left
+ * corner up and/or left to make it so, simultaneously increasing the region
+ * dimensions to keep the lower right crop corner unchanged.  (Thus, the
+ * output image covers at least the requested region, but may cover more.)
+ * The adjustment of the region dimensions may be optionally disabled.
+ *
+ * A complementary lossless wipe option is provided to discard (gray out) data
+ * inside a given image region while losslessly preserving what is outside.
+ * A lossless drop option is also provided, which allows another JPEG image to
+ * be inserted ("dropped") into the source image data at a given position,
+ * replacing the existing image data at that position.  Both the source image
+ * and the drop image must have the same subsampling level.  It is best if they
+ * also have the same quantization (quality.)  Otherwise, the quantization of
+ * the output image will be adapted to accommodate the higher of the source
+ * image quality and the drop image quality.  The trim option can be used with
+ * the drop option to requantize the drop image to match the source image.
+ *
+ * We also provide a lossless-resize option, which is kind of a lossless-crop
+ * operation in the DCT coefficient block domain - it discards higher-order
+ * coefficients and losslessly preserves lower-order coefficients of a
+ * sub-block.
+ *
+ * Rotate/flip transform, resize, and crop can be requested together in a
+ * single invocation.  The crop is applied last --- that is, the crop region
+ * is specified in terms of the destination image after transform/resize.
+ *
+ * We also offer a "force to grayscale" option, which simply discards the
+ * chrominance channels of a YCbCr image.  This is lossless in the sense that
+ * the luminance channel is preserved exactly.  It's not the same kind of
+ * thing as the rotate/flip transformations, but it's convenient to handle it
+ * as part of this package, mainly because the transformation routines have to
+ * be aware of the option to know how many components to work on.
+ */
+
+
+/*
+ * Codes for supported types of image transformations.
+ */
+
+typedef enum {
+  JXFORM_NONE,            /* no transformation */
+  JXFORM_FLIP_H,          /* horizontal flip */
+  JXFORM_FLIP_V,          /* vertical flip */
+  JXFORM_TRANSPOSE,       /* transpose across UL-to-LR axis */
+  JXFORM_TRANSVERSE,      /* transpose across UR-to-LL axis */
+  JXFORM_ROT_90,          /* 90-degree clockwise rotation */
+  JXFORM_ROT_180,         /* 180-degree rotation */
+  JXFORM_ROT_270,         /* 270-degree clockwise (or 90 ccw) */
+  JXFORM_WIPE,            /* wipe */
+  JXFORM_DROP             /* drop */
+} JXFORM_CODE;
+
+/*
+ * Codes for crop parameters, which can individually be unspecified,
+ * positive or negative for xoffset or yoffset,
+ * positive or force or reflect for width or height.
+ */
+
+typedef enum {
+  JCROP_UNSET,
+  JCROP_POS,
+  JCROP_NEG,
+  JCROP_FORCE,
+  JCROP_REFLECT
+} JCROP_CODE;
+
+/*
+ * Transform parameters struct.
+ * NB: application must not change any elements of this struct after
+ * calling jtransform_request_workspace.
+ */
+
+typedef struct {
+  /* Options: set by caller */
+  JXFORM_CODE transform;        /* image transform operator */
+  boolean perfect;              /* if TRUE, fail if partial MCUs are requested */
+  boolean trim;                 /* if TRUE, trim partial MCUs as needed */
+  boolean force_grayscale;      /* if TRUE, convert color image to grayscale */
+  boolean crop;                 /* if TRUE, crop or wipe source image, or drop */
+  boolean slow_hflip;  /* For best performance, the JXFORM_FLIP_H transform
+                          normally modifies the source coefficients in place.
+                          Setting this to TRUE will instead use a slower,
+                          double-buffered algorithm, which leaves the source
+                          coefficients in tact (necessary if other transformed
+                          images must be generated from the same set of
+                          coefficients. */
+
+  /* Crop parameters: application need not set these unless crop is TRUE.
+   * These can be filled in by jtransform_parse_crop_spec().
+   */
+  JDIMENSION crop_width;        /* Width of selected region */
+  JCROP_CODE crop_width_set;    /* (force-disables adjustment) */
+  JDIMENSION crop_height;       /* Height of selected region */
+  JCROP_CODE crop_height_set;   /* (force-disables adjustment) */
+  JDIMENSION crop_xoffset;      /* X offset of selected region */
+  JCROP_CODE crop_xoffset_set;  /* (negative measures from right edge) */
+  JDIMENSION crop_yoffset;      /* Y offset of selected region */
+  JCROP_CODE crop_yoffset_set;  /* (negative measures from bottom edge) */
+
+  /* Drop parameters: set by caller for drop request */
+  j_decompress_ptr drop_ptr;
+  jvirt_barray_ptr *drop_coef_arrays;
+
+  /* Internal workspace: caller should not touch these */
+  int num_components;           /* # of components in workspace */
+  jvirt_barray_ptr *workspace_coef_arrays; /* workspace for transformations */
+  JDIMENSION output_width;      /* cropped destination dimensions */
+  JDIMENSION output_height;
+  JDIMENSION x_crop_offset;     /* destination crop offsets measured in iMCUs */
+  JDIMENSION y_crop_offset;
+  JDIMENSION drop_width;        /* drop/wipe dimensions measured in iMCUs */
+  JDIMENSION drop_height;
+  int iMCU_sample_width;        /* destination iMCU size */
+  int iMCU_sample_height;
+} jpeg_transform_info;
+
+
+#if TRANSFORMS_SUPPORTED
+
+/* Parse a crop specification (written in X11 geometry style) */
+EXTERN(boolean) jtransform_parse_crop_spec(jpeg_transform_info *info,
+                                           const char *spec);
+/* Request any required workspace */
+EXTERN(boolean) jtransform_request_workspace(j_decompress_ptr srcinfo,
+                                             jpeg_transform_info *info);
+/* Adjust output image parameters */
+EXTERN(jvirt_barray_ptr *) jtransform_adjust_parameters
+  (j_decompress_ptr srcinfo, j_compress_ptr dstinfo,
+   jvirt_barray_ptr *src_coef_arrays, jpeg_transform_info *info);
+/* Execute the actual transformation, if any */
+EXTERN(void) jtransform_execute_transform(j_decompress_ptr srcinfo,
+                                          j_compress_ptr dstinfo,
+                                          jvirt_barray_ptr *src_coef_arrays,
+                                          jpeg_transform_info *info);
+/* Determine whether lossless transformation is perfectly
+ * possible for a specified image and transformation.
+ */
+EXTERN(boolean) jtransform_perfect_transform(JDIMENSION image_width,
+                                             JDIMENSION image_height,
+                                             int MCU_width, int MCU_height,
+                                             JXFORM_CODE transform);
+
+/* jtransform_execute_transform used to be called
+ * jtransform_execute_transformation, but some compilers complain about
+ * routine names that long.  This macro is here to avoid breaking any
+ * old source code that uses the original name...
+ */
+#define jtransform_execute_transformation       jtransform_execute_transform
+
+#endif /* TRANSFORMS_SUPPORTED */
+
+
+/*
+ * Support for copying optional markers from source to destination file.
+ */
+
+typedef enum {
+  JCOPYOPT_NONE,          /* copy no optional markers */
+  JCOPYOPT_COMMENTS,      /* copy only comment (COM) markers */
+  JCOPYOPT_ALL,           /* copy all optional markers */
+  JCOPYOPT_ALL_EXCEPT_ICC /* copy all optional markers except APP2 */
+} JCOPY_OPTION;
+
+#define JCOPYOPT_DEFAULT  JCOPYOPT_COMMENTS     /* recommended default */
+
+/* Setup decompression object to save desired markers in memory */
+EXTERN(void) jcopy_markers_setup(j_decompress_ptr srcinfo,
+                                 JCOPY_OPTION option);
+/* Copy markers saved in the given source object to the destination object */
+EXTERN(void) jcopy_markers_execute(j_decompress_ptr srcinfo,
+                                   j_compress_ptr dstinfo,
+                                   JCOPY_OPTION option);
diff --git a/3rdparty/libjpeg/src/turbojpeg-jni.c b/3rdparty/libjpeg/src/turbojpeg-jni.c
new file mode 100644
index 00000000..1b728e3a
--- /dev/null
+++ b/3rdparty/libjpeg/src/turbojpeg-jni.c
@@ -0,0 +1,1228 @@
+/*
+ * Copyright (C)2011-2020 D. R. Commander.  All Rights Reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright notice,
+ *   this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright notice,
+ *   this list of conditions and the following disclaimer in the documentation
+ *   and/or other materials provided with the distribution.
+ * - Neither the name of the libjpeg-turbo Project nor the names of its
+ *   contributors may be used to endorse or promote products derived from this
+ *   software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE 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 HOLDERS 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 <stdlib.h>
+#include <string.h>
+#include "turbojpeg.h"
+#ifdef WIN32
+#include "tjutil.h"
+#endif
+#include <jni.h>
+#include "java/org_libjpegturbo_turbojpeg_TJCompressor.h"
+#include "java/org_libjpegturbo_turbojpeg_TJDecompressor.h"
+#include "java/org_libjpegturbo_turbojpeg_TJTransformer.h"
+#include "java/org_libjpegturbo_turbojpeg_TJ.h"
+
+#define BAILIF0(f) { \
+  if (!(f) || (*env)->ExceptionCheck(env)) { \
+    goto bailout; \
+  } \
+}
+
+#define THROW(msg, exceptionClass) { \
+  jclass _exccls = (*env)->FindClass(env, exceptionClass); \
+  \
+  BAILIF0(_exccls); \
+  (*env)->ThrowNew(env, _exccls, msg); \
+  goto bailout; \
+}
+
+#define THROW_TJ() { \
+  jclass _exccls; \
+  jmethodID _excid; \
+  jobject _excobj; \
+  jstring _errstr; \
+  \
+  BAILIF0(_errstr = (*env)->NewStringUTF(env, tjGetErrorStr2(handle))); \
+  BAILIF0(_exccls = (*env)->FindClass(env, \
+    "org/libjpegturbo/turbojpeg/TJException")); \
+  BAILIF0(_excid = (*env)->GetMethodID(env, _exccls, "<init>", \
+                                       "(Ljava/lang/String;I)V")); \
+  BAILIF0(_excobj = (*env)->NewObject(env, _exccls, _excid, _errstr, \
+                                      tjGetErrorCode(handle))); \
+  (*env)->Throw(env, _excobj); \
+  goto bailout; \
+}
+
+#define THROW_ARG(msg)  THROW(msg, "java/lang/IllegalArgumentException")
+
+#define THROW_MEM() \
+  THROW("Memory allocation failure", "java/lang/OutOfMemoryError");
+
+#define GET_HANDLE() \
+  jclass _cls = (*env)->GetObjectClass(env, obj); \
+  jfieldID _fid; \
+  \
+  BAILIF0(_cls); \
+  BAILIF0(_fid = (*env)->GetFieldID(env, _cls, "handle", "J")); \
+  handle = (tjhandle)(size_t)(*env)->GetLongField(env, obj, _fid);
+
+#ifdef _WIN32
+#define setenv(envvar, value, dummy)  _putenv_s(envvar, value)
+#endif
+
+#define PROP2ENV(property, envvar) { \
+  if ((jName = (*env)->NewStringUTF(env, property)) != NULL && \
+      (jValue = (*env)->CallStaticObjectMethod(env, cls, mid, \
+                                               jName)) != NULL) { \
+    if ((value = (*env)->GetStringUTFChars(env, jValue, 0)) != NULL) { \
+      setenv(envvar, value, 1); \
+      (*env)->ReleaseStringUTFChars(env, jValue, value); \
+    } \
+  } \
+}
+
+#define SAFE_RELEASE(javaArray, cArray) { \
+  if (javaArray && cArray) \
+    (*env)->ReleasePrimitiveArrayCritical(env, javaArray, (void *)cArray, 0); \
+  cArray = NULL; \
+}
+
+static int ProcessSystemProperties(JNIEnv *env)
+{
+  jclass cls;
+  jmethodID mid;
+  jstring jName, jValue;
+  const char *value;
+
+  BAILIF0(cls = (*env)->FindClass(env, "java/lang/System"));
+  BAILIF0(mid = (*env)->GetStaticMethodID(env, cls, "getProperty",
+    "(Ljava/lang/String;)Ljava/lang/String;"));
+
+  PROP2ENV("turbojpeg.optimize", "TJ_OPTIMIZE");
+  PROP2ENV("turbojpeg.arithmetic", "TJ_ARITHMETIC");
+  PROP2ENV("turbojpeg.restart", "TJ_RESTART");
+  PROP2ENV("turbojpeg.progressive", "TJ_PROGRESSIVE");
+  return 0;
+
+bailout:
+  return -1;
+}
+
+/* TurboJPEG 1.2.x: TJ::bufSize() */
+JNIEXPORT jint JNICALL Java_org_libjpegturbo_turbojpeg_TJ_bufSize
+  (JNIEnv *env, jclass cls, jint width, jint height, jint jpegSubsamp)
+{
+  jint retval = (jint)tjBufSize(width, height, jpegSubsamp);
+
+  if (retval == -1) THROW_ARG(tjGetErrorStr());
+
+bailout:
+  return retval;
+}
+
+/* TurboJPEG 1.4.x: TJ::bufSizeYUV() */
+JNIEXPORT jint JNICALL Java_org_libjpegturbo_turbojpeg_TJ_bufSizeYUV__IIII
+  (JNIEnv *env, jclass cls, jint width, jint pad, jint height, jint subsamp)
+{
+  jint retval = (jint)tjBufSizeYUV2(width, pad, height, subsamp);
+
+  if (retval == -1) THROW_ARG(tjGetErrorStr());
+
+bailout:
+  return retval;
+}
+
+/* TurboJPEG 1.2.x: TJ::bufSizeYUV() */
+JNIEXPORT jint JNICALL Java_org_libjpegturbo_turbojpeg_TJ_bufSizeYUV__III
+  (JNIEnv *env, jclass cls, jint width, jint height, jint subsamp)
+{
+  return Java_org_libjpegturbo_turbojpeg_TJ_bufSizeYUV__IIII(env, cls, width,
+                                                             4, height,
+                                                             subsamp);
+}
+
+/* TurboJPEG 1.4.x: TJ::planeSizeYUV() */
+JNIEXPORT jint JNICALL Java_org_libjpegturbo_turbojpeg_TJ_planeSizeYUV__IIIII
+  (JNIEnv *env, jclass cls, jint componentID, jint width, jint stride,
+   jint height, jint subsamp)
+{
+  jint retval = (jint)tjPlaneSizeYUV(componentID, width, stride, height,
+                                     subsamp);
+
+  if (retval == -1) THROW_ARG(tjGetErrorStr());
+
+bailout:
+  return retval;
+}
+
+/* TurboJPEG 1.4.x: TJ::planeWidth() */
+JNIEXPORT jint JNICALL Java_org_libjpegturbo_turbojpeg_TJ_planeWidth__III
+  (JNIEnv *env, jclass cls, jint componentID, jint width, jint subsamp)
+{
+  jint retval = (jint)tjPlaneWidth(componentID, width, subsamp);
+
+  if (retval == -1) THROW_ARG(tjGetErrorStr());
+
+bailout:
+  return retval;
+}
+
+/* TurboJPEG 1.4.x: TJ::planeHeight() */
+JNIEXPORT jint JNICALL Java_org_libjpegturbo_turbojpeg_TJ_planeHeight__III
+  (JNIEnv *env, jclass cls, jint componentID, jint height, jint subsamp)
+{
+  jint retval = (jint)tjPlaneHeight(componentID, height, subsamp);
+
+  if (retval == -1) THROW_ARG(tjGetErrorStr());
+
+bailout:
+  return retval;
+}
+
+/* TurboJPEG 1.2.x: TJCompressor::init() */
+JNIEXPORT void JNICALL Java_org_libjpegturbo_turbojpeg_TJCompressor_init
+  (JNIEnv *env, jobject obj)
+{
+  jclass cls;
+  jfieldID fid;
+  tjhandle handle;
+
+  if ((handle = tjInitCompress()) == NULL)
+    THROW(tjGetErrorStr(), "org/libjpegturbo/turbojpeg/TJException");
+
+  BAILIF0(cls = (*env)->GetObjectClass(env, obj));
+  BAILIF0(fid = (*env)->GetFieldID(env, cls, "handle", "J"));
+  (*env)->SetLongField(env, obj, fid, (size_t)handle);
+
+bailout:
+  return;
+}
+
+static jint TJCompressor_compress
+  (JNIEnv *env, jobject obj, jarray src, jint srcElementSize, jint x, jint y,
+   jint width, jint pitch, jint height, jint pf, jbyteArray dst,
+   jint jpegSubsamp, jint jpegQual, jint flags)
+{
+  tjhandle handle = 0;
+  unsigned long jpegSize = 0;
+  jsize arraySize = 0, actualPitch;
+  unsigned char *srcBuf = NULL, *jpegBuf = NULL;
+
+  GET_HANDLE();
+
+  if (pf < 0 || pf >= org_libjpegturbo_turbojpeg_TJ_NUMPF || width < 1 ||
+      height < 1 || pitch < 0)
+    THROW_ARG("Invalid argument in compress()");
+  if (org_libjpegturbo_turbojpeg_TJ_NUMPF != TJ_NUMPF)
+    THROW_ARG("Mismatch between Java and C API");
+
+  actualPitch = (pitch == 0) ? width * tjPixelSize[pf] : pitch;
+  arraySize = (y + height - 1) * actualPitch + (x + width) * tjPixelSize[pf];
+  if ((*env)->GetArrayLength(env, src) * srcElementSize < arraySize)
+    THROW_ARG("Source buffer is not large enough");
+  jpegSize = tjBufSize(width, height, jpegSubsamp);
+  if ((*env)->GetArrayLength(env, dst) < (jsize)jpegSize)
+    THROW_ARG("Destination buffer is not large enough");
+
+  if (ProcessSystemProperties(env) < 0) goto bailout;
+
+  BAILIF0(srcBuf = (*env)->GetPrimitiveArrayCritical(env, src, 0));
+  BAILIF0(jpegBuf = (*env)->GetPrimitiveArrayCritical(env, dst, 0));
+
+  if (tjCompress2(handle, &srcBuf[y * actualPitch + x * tjPixelSize[pf]],
+                  width, pitch, height, pf, &jpegBuf, &jpegSize, jpegSubsamp,
+                  jpegQual, flags | TJFLAG_NOREALLOC) == -1) {
+    SAFE_RELEASE(dst, jpegBuf);
+    SAFE_RELEASE(src, srcBuf);
+    THROW_TJ();
+  }
+
+bailout:
+  SAFE_RELEASE(dst, jpegBuf);
+  SAFE_RELEASE(src, srcBuf);
+  return (jint)jpegSize;
+}
+
+/* TurboJPEG 1.3.x: TJCompressor::compress() byte source */
+JNIEXPORT jint JNICALL Java_org_libjpegturbo_turbojpeg_TJCompressor_compress___3BIIIIII_3BIII
+  (JNIEnv *env, jobject obj, jbyteArray src, jint x, jint y, jint width,
+   jint pitch, jint height, jint pf, jbyteArray dst, jint jpegSubsamp,
+   jint jpegQual, jint flags)
+{
+  return TJCompressor_compress(env, obj, src, 1, x, y, width, pitch, height,
+                               pf, dst, jpegSubsamp, jpegQual, flags);
+}
+
+/* TurboJPEG 1.2.x: TJCompressor::compress() byte source */
+JNIEXPORT jint JNICALL Java_org_libjpegturbo_turbojpeg_TJCompressor_compress___3BIIII_3BIII
+  (JNIEnv *env, jobject obj, jbyteArray src, jint width, jint pitch,
+   jint height, jint pf, jbyteArray dst, jint jpegSubsamp, jint jpegQual,
+   jint flags)
+{
+  return TJCompressor_compress(env, obj, src, 1, 0, 0, width, pitch, height,
+                               pf, dst, jpegSubsamp, jpegQual, flags);
+}
+
+/* TurboJPEG 1.3.x: TJCompressor::compress() int source */
+JNIEXPORT jint JNICALL Java_org_libjpegturbo_turbojpeg_TJCompressor_compress___3IIIIIII_3BIII
+  (JNIEnv *env, jobject obj, jintArray src, jint x, jint y, jint width,
+   jint stride, jint height, jint pf, jbyteArray dst, jint jpegSubsamp,
+   jint jpegQual, jint flags)
+{
+  if (pf < 0 || pf >= org_libjpegturbo_turbojpeg_TJ_NUMPF)
+    THROW_ARG("Invalid argument in compress()");
+  if (tjPixelSize[pf] != sizeof(jint))
+    THROW_ARG("Pixel format must be 32-bit when compressing from an integer buffer.");
+
+  return TJCompressor_compress(env, obj, src, sizeof(jint), x, y, width,
+                               stride * sizeof(jint), height, pf, dst,
+                               jpegSubsamp, jpegQual, flags);
+
+bailout:
+  return 0;
+}
+
+/* TurboJPEG 1.2.x: TJCompressor::compress() int source */
+JNIEXPORT jint JNICALL Java_org_libjpegturbo_turbojpeg_TJCompressor_compress___3IIIII_3BIII
+  (JNIEnv *env, jobject obj, jintArray src, jint width, jint stride,
+   jint height, jint pf, jbyteArray dst, jint jpegSubsamp, jint jpegQual,
+   jint flags)
+{
+  if (pf < 0 || pf >= org_libjpegturbo_turbojpeg_TJ_NUMPF)
+    THROW_ARG("Invalid argument in compress()");
+  if (tjPixelSize[pf] != sizeof(jint))
+    THROW_ARG("Pixel format must be 32-bit when compressing from an integer buffer.");
+
+  return TJCompressor_compress(env, obj, src, sizeof(jint), 0, 0, width,
+                               stride * sizeof(jint), height, pf, dst,
+                               jpegSubsamp, jpegQual, flags);
+
+bailout:
+  return 0;
+}
+
+/* TurboJPEG 1.4.x: TJCompressor::compressFromYUV() */
+JNIEXPORT jint JNICALL Java_org_libjpegturbo_turbojpeg_TJCompressor_compressFromYUV___3_3B_3II_3III_3BII
+  (JNIEnv *env, jobject obj, jobjectArray srcobjs, jintArray jSrcOffsets,
+   jint width, jintArray jSrcStrides, jint height, jint subsamp,
+   jbyteArray dst, jint jpegQual, jint flags)
+{
+  tjhandle handle = 0;
+  unsigned long jpegSize = 0;
+  jbyteArray jSrcPlanes[3] = { NULL, NULL, NULL };
+  const unsigned char *srcPlanesTmp[3] = { NULL, NULL, NULL };
+  const unsigned char *srcPlanes[3] = { NULL, NULL, NULL };
+  int *srcOffsetsTmp = NULL, srcOffsets[3] = { 0, 0, 0 };
+  int *srcStridesTmp = NULL, srcStrides[3] = { 0, 0, 0 };
+  unsigned char *jpegBuf = NULL;
+  int nc = (subsamp == org_libjpegturbo_turbojpeg_TJ_SAMP_GRAY ? 1 : 3), i;
+
+  GET_HANDLE();
+
+  if (subsamp < 0 || subsamp >= org_libjpegturbo_turbojpeg_TJ_NUMSAMP)
+    THROW_ARG("Invalid argument in compressFromYUV()");
+  if (org_libjpegturbo_turbojpeg_TJ_NUMSAMP != TJ_NUMSAMP)
+    THROW_ARG("Mismatch between Java and C API");
+
+  if ((*env)->GetArrayLength(env, srcobjs) < nc)
+    THROW_ARG("Planes array is too small for the subsampling type");
+  if ((*env)->GetArrayLength(env, jSrcOffsets) < nc)
+    THROW_ARG("Offsets array is too small for the subsampling type");
+  if ((*env)->GetArrayLength(env, jSrcStrides) < nc)
+    THROW_ARG("Strides array is too small for the subsampling type");
+
+  jpegSize = tjBufSize(width, height, subsamp);
+  if ((*env)->GetArrayLength(env, dst) < (jsize)jpegSize)
+    THROW_ARG("Destination buffer is not large enough");
+
+  if (ProcessSystemProperties(env) < 0) goto bailout;
+
+  BAILIF0(srcOffsetsTmp =
+          (*env)->GetPrimitiveArrayCritical(env, jSrcOffsets, 0));
+  for (i = 0; i < nc; i++) srcOffsets[i] = srcOffsetsTmp[i];
+  SAFE_RELEASE(jSrcOffsets, srcOffsetsTmp);
+
+  BAILIF0(srcStridesTmp =
+          (*env)->GetPrimitiveArrayCritical(env, jSrcStrides, 0));
+  for (i = 0; i < nc; i++) srcStrides[i] = srcStridesTmp[i];
+  SAFE_RELEASE(jSrcStrides, srcStridesTmp);
+
+  for (i = 0; i < nc; i++) {
+    int planeSize = tjPlaneSizeYUV(i, width, srcStrides[i], height, subsamp);
+    int pw = tjPlaneWidth(i, width, subsamp);
+
+    if (planeSize < 0 || pw < 0)
+      THROW_ARG(tjGetErrorStr());
+
+    if (srcOffsets[i] < 0)
+      THROW_ARG("Invalid argument in compressFromYUV()");
+    if (srcStrides[i] < 0 && srcOffsets[i] - planeSize + pw < 0)
+      THROW_ARG("Negative plane stride would cause memory to be accessed below plane boundary");
+
+    BAILIF0(jSrcPlanes[i] = (*env)->GetObjectArrayElement(env, srcobjs, i));
+    if ((*env)->GetArrayLength(env, jSrcPlanes[i]) <
+        srcOffsets[i] + planeSize)
+      THROW_ARG("Source plane is not large enough");
+
+    BAILIF0(srcPlanesTmp[i] =
+            (*env)->GetPrimitiveArrayCritical(env, jSrcPlanes[i], 0));
+    srcPlanes[i] = &srcPlanesTmp[i][srcOffsets[i]];
+    SAFE_RELEASE(jSrcPlanes[i], srcPlanesTmp[i]);
+  }
+  BAILIF0(jpegBuf = (*env)->GetPrimitiveArrayCritical(env, dst, 0));
+
+  if (tjCompressFromYUVPlanes(handle, srcPlanes, width, srcStrides, height,
+                              subsamp, &jpegBuf, &jpegSize, jpegQual,
+                              flags | TJFLAG_NOREALLOC) == -1) {
+    SAFE_RELEASE(dst, jpegBuf);
+    THROW_TJ();
+  }
+
+bailout:
+  SAFE_RELEASE(dst, jpegBuf);
+  return (jint)jpegSize;
+}
+
+static void TJCompressor_encodeYUV
+  (JNIEnv *env, jobject obj, jarray src, jint srcElementSize, jint x, jint y,
+   jint width, jint pitch, jint height, jint pf, jobjectArray dstobjs,
+   jintArray jDstOffsets, jintArray jDstStrides, jint subsamp, jint flags)
+{
+  tjhandle handle = 0;
+  jsize arraySize = 0, actualPitch;
+  unsigned char *srcBuf = NULL;
+  jbyteArray jDstPlanes[3] = { NULL, NULL, NULL };
+  unsigned char *dstPlanesTmp[3] = { NULL, NULL, NULL };
+  unsigned char *dstPlanes[3] = { NULL, NULL, NULL };
+  int *dstOffsetsTmp = NULL, dstOffsets[3] = { 0, 0, 0 };
+  int *dstStridesTmp = NULL, dstStrides[3] = { 0, 0, 0 };
+  int nc = (subsamp == org_libjpegturbo_turbojpeg_TJ_SAMP_GRAY ? 1 : 3), i;
+
+  GET_HANDLE();
+
+  if (pf < 0 || pf >= org_libjpegturbo_turbojpeg_TJ_NUMPF || width < 1 ||
+      height < 1 || pitch < 0 || subsamp < 0 ||
+      subsamp >= org_libjpegturbo_turbojpeg_TJ_NUMSAMP)
+    THROW_ARG("Invalid argument in encodeYUV()");
+  if (org_libjpegturbo_turbojpeg_TJ_NUMPF != TJ_NUMPF ||
+      org_libjpegturbo_turbojpeg_TJ_NUMSAMP != TJ_NUMSAMP)
+    THROW_ARG("Mismatch between Java and C API");
+
+  if ((*env)->GetArrayLength(env, dstobjs) < nc)
+    THROW_ARG("Planes array is too small for the subsampling type");
+  if ((*env)->GetArrayLength(env, jDstOffsets) < nc)
+    THROW_ARG("Offsets array is too small for the subsampling type");
+  if ((*env)->GetArrayLength(env, jDstStrides) < nc)
+    THROW_ARG("Strides array is too small for the subsampling type");
+
+  actualPitch = (pitch == 0) ? width * tjPixelSize[pf] : pitch;
+  arraySize = (y + height - 1) * actualPitch + (x + width) * tjPixelSize[pf];
+  if ((*env)->GetArrayLength(env, src) * srcElementSize < arraySize)
+    THROW_ARG("Source buffer is not large enough");
+
+  BAILIF0(dstOffsetsTmp =
+          (*env)->GetPrimitiveArrayCritical(env, jDstOffsets, 0));
+  for (i = 0; i < nc; i++) dstOffsets[i] = dstOffsetsTmp[i];
+  SAFE_RELEASE(jDstOffsets, dstOffsetsTmp);
+
+  BAILIF0(dstStridesTmp =
+          (*env)->GetPrimitiveArrayCritical(env, jDstStrides, 0));
+  for (i = 0; i < nc; i++) dstStrides[i] = dstStridesTmp[i];
+  SAFE_RELEASE(jDstStrides, dstStridesTmp);
+
+  for (i = 0; i < nc; i++) {
+    int planeSize = tjPlaneSizeYUV(i, width, dstStrides[i], height, subsamp);
+    int pw = tjPlaneWidth(i, width, subsamp);
+
+    if (planeSize < 0 || pw < 0)
+      THROW_ARG(tjGetErrorStr());
+
+    if (dstOffsets[i] < 0)
+      THROW_ARG("Invalid argument in encodeYUV()");
+    if (dstStrides[i] < 0 && dstOffsets[i] - planeSize + pw < 0)
+      THROW_ARG("Negative plane stride would cause memory to be accessed below plane boundary");
+
+    BAILIF0(jDstPlanes[i] = (*env)->GetObjectArrayElement(env, dstobjs, i));
+    if ((*env)->GetArrayLength(env, jDstPlanes[i]) <
+        dstOffsets[i] + planeSize)
+      THROW_ARG("Destination plane is not large enough");
+
+    BAILIF0(dstPlanesTmp[i] =
+            (*env)->GetPrimitiveArrayCritical(env, jDstPlanes[i], 0));
+    dstPlanes[i] = &dstPlanesTmp[i][dstOffsets[i]];
+    SAFE_RELEASE(jDstPlanes[i], dstPlanesTmp[i]);
+  }
+  BAILIF0(srcBuf = (*env)->GetPrimitiveArrayCritical(env, src, 0));
+
+  if (tjEncodeYUVPlanes(handle, &srcBuf[y * actualPitch + x * tjPixelSize[pf]],
+                        width, pitch, height, pf, dstPlanes, dstStrides,
+                        subsamp, flags) == -1) {
+    SAFE_RELEASE(src, srcBuf);
+    THROW_TJ();
+  }
+
+bailout:
+  SAFE_RELEASE(src, srcBuf);
+}
+
+/* TurboJPEG 1.4.x: TJCompressor::encodeYUV() byte source */
+JNIEXPORT void JNICALL Java_org_libjpegturbo_turbojpeg_TJCompressor_encodeYUV___3BIIIIII_3_3B_3I_3III
+  (JNIEnv *env, jobject obj, jbyteArray src, jint x, jint y, jint width,
+   jint pitch, jint height, jint pf, jobjectArray dstobjs,
+   jintArray jDstOffsets, jintArray jDstStrides, jint subsamp, jint flags)
+{
+  TJCompressor_encodeYUV(env, obj, src, 1, x, y, width, pitch, height, pf,
+                         dstobjs, jDstOffsets, jDstStrides, subsamp, flags);
+}
+
+/* TurboJPEG 1.4.x: TJCompressor::encodeYUV() int source */
+JNIEXPORT void JNICALL Java_org_libjpegturbo_turbojpeg_TJCompressor_encodeYUV___3IIIIIII_3_3B_3I_3III
+  (JNIEnv *env, jobject obj, jintArray src, jint x, jint y, jint width,
+   jint stride, jint height, jint pf, jobjectArray dstobjs,
+   jintArray jDstOffsets, jintArray jDstStrides, jint subsamp, jint flags)
+{
+  if (pf < 0 || pf >= org_libjpegturbo_turbojpeg_TJ_NUMPF)
+    THROW_ARG("Invalid argument in encodeYUV()");
+  if (tjPixelSize[pf] != sizeof(jint))
+    THROW_ARG("Pixel format must be 32-bit when encoding from an integer buffer.");
+
+  TJCompressor_encodeYUV(env, obj, src, sizeof(jint), x, y, width,
+                         stride * sizeof(jint), height, pf, dstobjs,
+                         jDstOffsets, jDstStrides, subsamp, flags);
+
+bailout:
+  return;
+}
+
+static void JNICALL TJCompressor_encodeYUV_12
+  (JNIEnv *env, jobject obj, jarray src, jint srcElementSize, jint width,
+   jint pitch, jint height, jint pf, jbyteArray dst, jint subsamp, jint flags)
+{
+  tjhandle handle = 0;
+  jsize arraySize = 0;
+  unsigned char *srcBuf = NULL, *dstBuf = NULL;
+
+  GET_HANDLE();
+
+  if (pf < 0 || pf >= org_libjpegturbo_turbojpeg_TJ_NUMPF || width < 1 ||
+      height < 1 || pitch < 0)
+    THROW_ARG("Invalid argument in encodeYUV()");
+  if (org_libjpegturbo_turbojpeg_TJ_NUMPF != TJ_NUMPF)
+    THROW_ARG("Mismatch between Java and C API");
+
+  arraySize = (pitch == 0) ? width * tjPixelSize[pf] * height : pitch * height;
+  if ((*env)->GetArrayLength(env, src) * srcElementSize < arraySize)
+    THROW_ARG("Source buffer is not large enough");
+  if ((*env)->GetArrayLength(env, dst) <
+      (jsize)tjBufSizeYUV(width, height, subsamp))
+    THROW_ARG("Destination buffer is not large enough");
+
+  BAILIF0(srcBuf = (*env)->GetPrimitiveArrayCritical(env, src, 0));
+  BAILIF0(dstBuf = (*env)->GetPrimitiveArrayCritical(env, dst, 0));
+
+  if (tjEncodeYUV2(handle, srcBuf, width, pitch, height, pf, dstBuf, subsamp,
+                   flags) == -1) {
+    SAFE_RELEASE(dst, dstBuf);
+    SAFE_RELEASE(src, srcBuf);
+    THROW_TJ();
+  }
+
+bailout:
+  SAFE_RELEASE(dst, dstBuf);
+  SAFE_RELEASE(src, srcBuf);
+}
+
+/* TurboJPEG 1.2.x: TJCompressor::encodeYUV() byte source */
+JNIEXPORT void JNICALL Java_org_libjpegturbo_turbojpeg_TJCompressor_encodeYUV___3BIIII_3BII
+  (JNIEnv *env, jobject obj, jbyteArray src, jint width, jint pitch,
+   jint height, jint pf, jbyteArray dst, jint subsamp, jint flags)
+{
+  TJCompressor_encodeYUV_12(env, obj, src, 1, width, pitch, height, pf, dst,
+                            subsamp, flags);
+}
+
+/* TurboJPEG 1.2.x: TJCompressor::encodeYUV() int source */
+JNIEXPORT void JNICALL Java_org_libjpegturbo_turbojpeg_TJCompressor_encodeYUV___3IIIII_3BII
+  (JNIEnv *env, jobject obj, jintArray src, jint width, jint stride,
+   jint height, jint pf, jbyteArray dst, jint subsamp, jint flags)
+{
+  if (pf < 0 || pf >= org_libjpegturbo_turbojpeg_TJ_NUMPF)
+    THROW_ARG("Invalid argument in encodeYUV()");
+  if (tjPixelSize[pf] != sizeof(jint))
+    THROW_ARG("Pixel format must be 32-bit when encoding from an integer buffer.");
+
+  TJCompressor_encodeYUV_12(env, obj, src, sizeof(jint), width,
+                            stride * sizeof(jint), height, pf, dst, subsamp,
+                            flags);
+
+bailout:
+  return;
+}
+
+/* TurboJPEG 1.2.x: TJCompressor::destroy() */
+JNIEXPORT void JNICALL Java_org_libjpegturbo_turbojpeg_TJCompressor_destroy
+  (JNIEnv *env, jobject obj)
+{
+  tjhandle handle = 0;
+
+  GET_HANDLE();
+
+  if (tjDestroy(handle) == -1) THROW_TJ();
+  (*env)->SetLongField(env, obj, _fid, 0);
+
+bailout:
+  return;
+}
+
+/* TurboJPEG 1.2.x: TJDecompressor::init() */
+JNIEXPORT void JNICALL Java_org_libjpegturbo_turbojpeg_TJDecompressor_init
+  (JNIEnv *env, jobject obj)
+{
+  jclass cls;
+  jfieldID fid;
+  tjhandle handle;
+
+  if ((handle = tjInitDecompress()) == NULL)
+    THROW(tjGetErrorStr(), "org/libjpegturbo/turbojpeg/TJException");
+
+  BAILIF0(cls = (*env)->GetObjectClass(env, obj));
+  BAILIF0(fid = (*env)->GetFieldID(env, cls, "handle", "J"));
+  (*env)->SetLongField(env, obj, fid, (size_t)handle);
+
+bailout:
+  return;
+}
+
+/* TurboJPEG 1.2.x: TJDecompressor::getScalingFactors() */
+JNIEXPORT jobjectArray JNICALL Java_org_libjpegturbo_turbojpeg_TJ_getScalingFactors
+  (JNIEnv *env, jclass cls)
+{
+  jclass sfcls = NULL;
+  jfieldID fid = 0;
+  tjscalingfactor *sf = NULL;
+  int n = 0, i;
+  jobject sfobj = NULL;
+  jobjectArray sfjava = NULL;
+
+  if ((sf = tjGetScalingFactors(&n)) == NULL || n == 0)
+    THROW_ARG(tjGetErrorStr());
+
+  BAILIF0(sfcls = (*env)->FindClass(env,
+    "org/libjpegturbo/turbojpeg/TJScalingFactor"));
+  BAILIF0(sfjava = (jobjectArray)(*env)->NewObjectArray(env, n, sfcls, 0));
+
+  for (i = 0; i < n; i++) {
+    BAILIF0(sfobj = (*env)->AllocObject(env, sfcls));
+    BAILIF0(fid = (*env)->GetFieldID(env, sfcls, "num", "I"));
+    (*env)->SetIntField(env, sfobj, fid, sf[i].num);
+    BAILIF0(fid = (*env)->GetFieldID(env, sfcls, "denom", "I"));
+    (*env)->SetIntField(env, sfobj, fid, sf[i].denom);
+    (*env)->SetObjectArrayElement(env, sfjava, i, sfobj);
+  }
+
+bailout:
+  return sfjava;
+}
+
+/* TurboJPEG 1.2.x: TJDecompressor::decompressHeader() */
+JNIEXPORT void JNICALL Java_org_libjpegturbo_turbojpeg_TJDecompressor_decompressHeader
+  (JNIEnv *env, jobject obj, jbyteArray src, jint jpegSize)
+{
+  tjhandle handle = 0;
+  unsigned char *jpegBuf = NULL;
+  int width = 0, height = 0, jpegSubsamp = -1, jpegColorspace = -1;
+
+  GET_HANDLE();
+
+  if ((*env)->GetArrayLength(env, src) < jpegSize)
+    THROW_ARG("Source buffer is not large enough");
+
+  BAILIF0(jpegBuf = (*env)->GetPrimitiveArrayCritical(env, src, 0));
+
+  if (tjDecompressHeader3(handle, jpegBuf, (unsigned long)jpegSize, &width,
+                          &height, &jpegSubsamp, &jpegColorspace) == -1) {
+    SAFE_RELEASE(src, jpegBuf);
+    THROW_TJ();
+  }
+
+  SAFE_RELEASE(src, jpegBuf);
+
+  BAILIF0(_fid = (*env)->GetFieldID(env, _cls, "jpegSubsamp", "I"));
+  (*env)->SetIntField(env, obj, _fid, jpegSubsamp);
+  if ((_fid = (*env)->GetFieldID(env, _cls, "jpegColorspace", "I")) == 0)
+    (*env)->ExceptionClear(env);
+  else
+    (*env)->SetIntField(env, obj, _fid, jpegColorspace);
+  BAILIF0(_fid = (*env)->GetFieldID(env, _cls, "jpegWidth", "I"));
+  (*env)->SetIntField(env, obj, _fid, width);
+  BAILIF0(_fid = (*env)->GetFieldID(env, _cls, "jpegHeight", "I"));
+  (*env)->SetIntField(env, obj, _fid, height);
+
+bailout:
+  SAFE_RELEASE(src, jpegBuf);
+}
+
+static void TJDecompressor_decompress
+  (JNIEnv *env, jobject obj, jbyteArray src, jint jpegSize, jarray dst,
+   jint dstElementSize, jint x, jint y, jint width, jint pitch, jint height,
+   jint pf, jint flags)
+{
+  tjhandle handle = 0;
+  jsize arraySize = 0, actualPitch;
+  unsigned char *jpegBuf = NULL, *dstBuf = NULL;
+
+  GET_HANDLE();
+
+  if (pf < 0 || pf >= org_libjpegturbo_turbojpeg_TJ_NUMPF)
+    THROW_ARG("Invalid argument in decompress()");
+  if (org_libjpegturbo_turbojpeg_TJ_NUMPF != TJ_NUMPF)
+    THROW_ARG("Mismatch between Java and C API");
+
+  if ((*env)->GetArrayLength(env, src) < jpegSize)
+    THROW_ARG("Source buffer is not large enough");
+  actualPitch = (pitch == 0) ? width * tjPixelSize[pf] : pitch;
+  arraySize = (y + height - 1) * actualPitch + (x + width) * tjPixelSize[pf];
+  if ((*env)->GetArrayLength(env, dst) * dstElementSize < arraySize)
+    THROW_ARG("Destination buffer is not large enough");
+
+  BAILIF0(jpegBuf = (*env)->GetPrimitiveArrayCritical(env, src, 0));
+  BAILIF0(dstBuf = (*env)->GetPrimitiveArrayCritical(env, dst, 0));
+
+  if (tjDecompress2(handle, jpegBuf, (unsigned long)jpegSize,
+                    &dstBuf[y * actualPitch + x * tjPixelSize[pf]], width,
+                    pitch, height, pf, flags) == -1) {
+    SAFE_RELEASE(dst, dstBuf);
+    SAFE_RELEASE(src, jpegBuf);
+    THROW_TJ();
+  }
+
+bailout:
+  SAFE_RELEASE(dst, dstBuf);
+  SAFE_RELEASE(src, jpegBuf);
+}
+
+/* TurboJPEG 1.3.x: TJDecompressor::decompress() byte destination */
+JNIEXPORT void JNICALL Java_org_libjpegturbo_turbojpeg_TJDecompressor_decompress___3BI_3BIIIIIII
+  (JNIEnv *env, jobject obj, jbyteArray src, jint jpegSize, jbyteArray dst,
+   jint x, jint y, jint width, jint pitch, jint height, jint pf, jint flags)
+{
+  TJDecompressor_decompress(env, obj, src, jpegSize, dst, 1, x, y, width,
+                            pitch, height, pf, flags);
+}
+
+/* TurboJPEG 1.2.x: TJDecompressor::decompress() byte destination */
+JNIEXPORT void JNICALL Java_org_libjpegturbo_turbojpeg_TJDecompressor_decompress___3BI_3BIIIII
+  (JNIEnv *env, jobject obj, jbyteArray src, jint jpegSize, jbyteArray dst,
+   jint width, jint pitch, jint height, jint pf, jint flags)
+{
+  TJDecompressor_decompress(env, obj, src, jpegSize, dst, 1, 0, 0, width,
+                            pitch, height, pf, flags);
+}
+
+/* TurboJPEG 1.3.x: TJDecompressor::decompress() int destination */
+JNIEXPORT void JNICALL Java_org_libjpegturbo_turbojpeg_TJDecompressor_decompress___3BI_3IIIIIIII
+  (JNIEnv *env, jobject obj, jbyteArray src, jint jpegSize, jintArray dst,
+   jint x, jint y, jint width, jint stride, jint height, jint pf, jint flags)
+{
+  if (pf < 0 || pf >= org_libjpegturbo_turbojpeg_TJ_NUMPF)
+    THROW_ARG("Invalid argument in decompress()");
+  if (tjPixelSize[pf] != sizeof(jint))
+    THROW_ARG("Pixel format must be 32-bit when decompressing to an integer buffer.");
+
+  TJDecompressor_decompress(env, obj, src, jpegSize, dst, sizeof(jint), x, y,
+                            width, stride * sizeof(jint), height, pf, flags);
+
+bailout:
+  return;
+}
+
+/* TurboJPEG 1.2.x: TJDecompressor::decompress() int destination */
+JNIEXPORT void JNICALL Java_org_libjpegturbo_turbojpeg_TJDecompressor_decompress___3BI_3IIIIII
+  (JNIEnv *env, jobject obj, jbyteArray src, jint jpegSize, jintArray dst,
+   jint width, jint stride, jint height, jint pf, jint flags)
+{
+  if (pf < 0 || pf >= org_libjpegturbo_turbojpeg_TJ_NUMPF)
+    THROW_ARG("Invalid argument in decompress()");
+  if (tjPixelSize[pf] != sizeof(jint))
+    THROW_ARG("Pixel format must be 32-bit when decompressing to an integer buffer.");
+
+  TJDecompressor_decompress(env, obj, src, jpegSize, dst, sizeof(jint), 0, 0,
+                            width, stride * sizeof(jint), height, pf, flags);
+
+bailout:
+  return;
+}
+
+/* TurboJPEG 1.4.x: TJDecompressor::decompressToYUV() */
+JNIEXPORT void JNICALL Java_org_libjpegturbo_turbojpeg_TJDecompressor_decompressToYUV___3BI_3_3B_3II_3III
+  (JNIEnv *env, jobject obj, jbyteArray src, jint jpegSize,
+   jobjectArray dstobjs, jintArray jDstOffsets, jint desiredWidth,
+   jintArray jDstStrides, jint desiredHeight, jint flags)
+{
+  tjhandle handle = 0;
+  unsigned char *jpegBuf = NULL;
+  jbyteArray jDstPlanes[3] = { NULL, NULL, NULL };
+  unsigned char *dstPlanesTmp[3] = { NULL, NULL, NULL };
+  unsigned char *dstPlanes[3] = { NULL, NULL, NULL };
+  int *dstOffsetsTmp = NULL, dstOffsets[3] = { 0, 0, 0 };
+  int *dstStridesTmp = NULL, dstStrides[3] = { 0, 0, 0 };
+  int jpegSubsamp = -1, jpegWidth = 0, jpegHeight = 0;
+  int nc = 0, i, width, height, scaledWidth, scaledHeight, nsf = 0;
+  tjscalingfactor *sf;
+
+  GET_HANDLE();
+
+  if ((*env)->GetArrayLength(env, src) < jpegSize)
+    THROW_ARG("Source buffer is not large enough");
+  BAILIF0(_fid = (*env)->GetFieldID(env, _cls, "jpegSubsamp", "I"));
+  jpegSubsamp = (int)(*env)->GetIntField(env, obj, _fid);
+  BAILIF0(_fid = (*env)->GetFieldID(env, _cls, "jpegWidth", "I"));
+  jpegWidth = (int)(*env)->GetIntField(env, obj, _fid);
+  BAILIF0(_fid = (*env)->GetFieldID(env, _cls, "jpegHeight", "I"));
+  jpegHeight = (int)(*env)->GetIntField(env, obj, _fid);
+
+  nc = (jpegSubsamp == org_libjpegturbo_turbojpeg_TJ_SAMP_GRAY ? 1 : 3);
+
+  width = desiredWidth;
+  height = desiredHeight;
+  if (width == 0) width = jpegWidth;
+  if (height == 0) height = jpegHeight;
+  sf = tjGetScalingFactors(&nsf);
+  if (!sf || nsf < 1)
+    THROW_ARG(tjGetErrorStr());
+  for (i = 0; i < nsf; i++) {
+    scaledWidth = TJSCALED(jpegWidth, sf[i]);
+    scaledHeight = TJSCALED(jpegHeight, sf[i]);
+    if (scaledWidth <= width && scaledHeight <= height)
+      break;
+  }
+  if (i >= nsf)
+    THROW_ARG("Could not scale down to desired image dimensions");
+
+  BAILIF0(dstOffsetsTmp =
+          (*env)->GetPrimitiveArrayCritical(env, jDstOffsets, 0));
+  for (i = 0; i < nc; i++) dstOffsets[i] = dstOffsetsTmp[i];
+  SAFE_RELEASE(jDstOffsets, dstOffsetsTmp);
+
+  BAILIF0(dstStridesTmp =
+          (*env)->GetPrimitiveArrayCritical(env, jDstStrides, 0));
+  for (i = 0; i < nc; i++) dstStrides[i] = dstStridesTmp[i];
+  SAFE_RELEASE(jDstStrides, dstStridesTmp);
+
+  for (i = 0; i < nc; i++) {
+    int planeSize = tjPlaneSizeYUV(i, scaledWidth, dstStrides[i], scaledHeight,
+                                   jpegSubsamp);
+    int pw = tjPlaneWidth(i, scaledWidth, jpegSubsamp);
+
+    if (planeSize < 0 || pw < 0)
+      THROW_ARG(tjGetErrorStr());
+
+    if (dstOffsets[i] < 0)
+      THROW_ARG("Invalid argument in decompressToYUV()");
+    if (dstStrides[i] < 0 && dstOffsets[i] - planeSize + pw < 0)
+      THROW_ARG("Negative plane stride would cause memory to be accessed below plane boundary");
+
+    BAILIF0(jDstPlanes[i] = (*env)->GetObjectArrayElement(env, dstobjs, i));
+    if ((*env)->GetArrayLength(env, jDstPlanes[i]) <
+        dstOffsets[i] + planeSize)
+      THROW_ARG("Destination plane is not large enough");
+
+    BAILIF0(dstPlanesTmp[i] =
+            (*env)->GetPrimitiveArrayCritical(env, jDstPlanes[i], 0));
+    dstPlanes[i] = &dstPlanesTmp[i][dstOffsets[i]];
+    SAFE_RELEASE(jDstPlanes[i], dstPlanesTmp[i]);
+  }
+  BAILIF0(jpegBuf = (*env)->GetPrimitiveArrayCritical(env, src, 0));
+
+  if (tjDecompressToYUVPlanes(handle, jpegBuf, (unsigned long)jpegSize,
+                              dstPlanes, desiredWidth, dstStrides,
+                              desiredHeight, flags) == -1) {
+    SAFE_RELEASE(src, jpegBuf);
+    THROW_TJ();
+  }
+
+bailout:
+  SAFE_RELEASE(src, jpegBuf);
+}
+
+/* TurboJPEG 1.2.x: TJDecompressor::decompressToYUV() */
+JNIEXPORT void JNICALL Java_org_libjpegturbo_turbojpeg_TJDecompressor_decompressToYUV___3BI_3BI
+  (JNIEnv *env, jobject obj, jbyteArray src, jint jpegSize, jbyteArray dst,
+   jint flags)
+{
+  tjhandle handle = 0;
+  unsigned char *jpegBuf = NULL, *dstBuf = NULL;
+  int jpegSubsamp = -1, jpegWidth = 0, jpegHeight = 0;
+
+  GET_HANDLE();
+
+  if ((*env)->GetArrayLength(env, src) < jpegSize)
+    THROW_ARG("Source buffer is not large enough");
+  BAILIF0(_fid = (*env)->GetFieldID(env, _cls, "jpegSubsamp", "I"));
+  jpegSubsamp = (int)(*env)->GetIntField(env, obj, _fid);
+  BAILIF0(_fid = (*env)->GetFieldID(env, _cls, "jpegWidth", "I"));
+  jpegWidth = (int)(*env)->GetIntField(env, obj, _fid);
+  BAILIF0(_fid = (*env)->GetFieldID(env, _cls, "jpegHeight", "I"));
+  jpegHeight = (int)(*env)->GetIntField(env, obj, _fid);
+  if ((*env)->GetArrayLength(env, dst) <
+      (jsize)tjBufSizeYUV(jpegWidth, jpegHeight, jpegSubsamp))
+    THROW_ARG("Destination buffer is not large enough");
+
+  BAILIF0(jpegBuf = (*env)->GetPrimitiveArrayCritical(env, src, 0));
+  BAILIF0(dstBuf = (*env)->GetPrimitiveArrayCritical(env, dst, 0));
+
+  if (tjDecompressToYUV(handle, jpegBuf, (unsigned long)jpegSize, dstBuf,
+                        flags) == -1) {
+    SAFE_RELEASE(dst, dstBuf);
+    SAFE_RELEASE(src, jpegBuf);
+    THROW_TJ();
+  }
+
+bailout:
+  SAFE_RELEASE(dst, dstBuf);
+  SAFE_RELEASE(src, jpegBuf);
+}
+
+static void TJDecompressor_decodeYUV
+  (JNIEnv *env, jobject obj, jobjectArray srcobjs, jintArray jSrcOffsets,
+   jintArray jSrcStrides, jint subsamp, jarray dst, jint dstElementSize,
+   jint x, jint y, jint width, jint pitch, jint height, jint pf, jint flags)
+{
+  tjhandle handle = 0;
+  jsize arraySize = 0, actualPitch;
+  jbyteArray jSrcPlanes[3] = { NULL, NULL, NULL };
+  const unsigned char *srcPlanesTmp[3] = { NULL, NULL, NULL };
+  const unsigned char *srcPlanes[3] = { NULL, NULL, NULL };
+  int *srcOffsetsTmp = NULL, srcOffsets[3] = { 0, 0, 0 };
+  int *srcStridesTmp = NULL, srcStrides[3] = { 0, 0, 0 };
+  unsigned char *dstBuf = NULL;
+  int nc = (subsamp == org_libjpegturbo_turbojpeg_TJ_SAMP_GRAY ? 1 : 3), i;
+
+  GET_HANDLE();
+
+  if (pf < 0 || pf >= org_libjpegturbo_turbojpeg_TJ_NUMPF || subsamp < 0 ||
+      subsamp >= org_libjpegturbo_turbojpeg_TJ_NUMSAMP)
+    THROW_ARG("Invalid argument in decodeYUV()");
+  if (org_libjpegturbo_turbojpeg_TJ_NUMPF != TJ_NUMPF ||
+      org_libjpegturbo_turbojpeg_TJ_NUMSAMP != TJ_NUMSAMP)
+    THROW_ARG("Mismatch between Java and C API");
+
+  if ((*env)->GetArrayLength(env, srcobjs) < nc)
+    THROW_ARG("Planes array is too small for the subsampling type");
+  if ((*env)->GetArrayLength(env, jSrcOffsets) < nc)
+    THROW_ARG("Offsets array is too small for the subsampling type");
+  if ((*env)->GetArrayLength(env, jSrcStrides) < nc)
+    THROW_ARG("Strides array is too small for the subsampling type");
+
+  actualPitch = (pitch == 0) ? width * tjPixelSize[pf] : pitch;
+  arraySize = (y + height - 1) * actualPitch + (x + width) * tjPixelSize[pf];
+  if ((*env)->GetArrayLength(env, dst) * dstElementSize < arraySize)
+    THROW_ARG("Destination buffer is not large enough");
+
+  BAILIF0(srcOffsetsTmp =
+          (*env)->GetPrimitiveArrayCritical(env, jSrcOffsets, 0));
+  for (i = 0; i < nc; i++) srcOffsets[i] = srcOffsetsTmp[i];
+  SAFE_RELEASE(jSrcOffsets, srcOffsetsTmp);
+
+  BAILIF0(srcStridesTmp =
+          (*env)->GetPrimitiveArrayCritical(env, jSrcStrides, 0));
+  for (i = 0; i < nc; i++) srcStrides[i] = srcStridesTmp[i];
+  SAFE_RELEASE(jSrcStrides, srcStridesTmp);
+
+  for (i = 0; i < nc; i++) {
+    int planeSize = tjPlaneSizeYUV(i, width, srcStrides[i], height, subsamp);
+    int pw = tjPlaneWidth(i, width, subsamp);
+
+    if (planeSize < 0 || pw < 0)
+      THROW_ARG(tjGetErrorStr());
+
+    if (srcOffsets[i] < 0)
+      THROW_ARG("Invalid argument in decodeYUV()");
+    if (srcStrides[i] < 0 && srcOffsets[i] - planeSize + pw < 0)
+      THROW_ARG("Negative plane stride would cause memory to be accessed below plane boundary");
+
+    BAILIF0(jSrcPlanes[i] = (*env)->GetObjectArrayElement(env, srcobjs, i));
+    if ((*env)->GetArrayLength(env, jSrcPlanes[i]) <
+        srcOffsets[i] + planeSize)
+      THROW_ARG("Source plane is not large enough");
+
+    BAILIF0(srcPlanesTmp[i] =
+            (*env)->GetPrimitiveArrayCritical(env, jSrcPlanes[i], 0));
+    srcPlanes[i] = &srcPlanesTmp[i][srcOffsets[i]];
+    SAFE_RELEASE(jSrcPlanes[i], srcPlanesTmp[i]);
+  }
+  BAILIF0(dstBuf = (*env)->GetPrimitiveArrayCritical(env, dst, 0));
+
+  if (tjDecodeYUVPlanes(handle, srcPlanes, srcStrides, subsamp,
+                        &dstBuf[y * actualPitch + x * tjPixelSize[pf]], width,
+                        pitch, height, pf, flags) == -1) {
+    SAFE_RELEASE(dst, dstBuf);
+    THROW_TJ();
+  }
+
+bailout:
+  SAFE_RELEASE(dst, dstBuf);
+}
+
+/* TurboJPEG 1.4.x: TJDecompressor::decodeYUV() byte destination */
+JNIEXPORT void JNICALL Java_org_libjpegturbo_turbojpeg_TJDecompressor_decodeYUV___3_3B_3I_3II_3BIIIIIII
+  (JNIEnv *env, jobject obj, jobjectArray srcobjs, jintArray jSrcOffsets,
+   jintArray jSrcStrides, jint subsamp, jbyteArray dst, jint x, jint y,
+   jint width, jint pitch, jint height, jint pf, jint flags)
+{
+  TJDecompressor_decodeYUV(env, obj, srcobjs, jSrcOffsets, jSrcStrides,
+                           subsamp, dst, 1, x, y, width, pitch, height, pf,
+                           flags);
+}
+
+/* TurboJPEG 1.4.x: TJDecompressor::decodeYUV() int destination */
+JNIEXPORT void JNICALL Java_org_libjpegturbo_turbojpeg_TJDecompressor_decodeYUV___3_3B_3I_3II_3IIIIIIII
+  (JNIEnv *env, jobject obj, jobjectArray srcobjs, jintArray jSrcOffsets,
+   jintArray jSrcStrides, jint subsamp, jintArray dst, jint x, jint y,
+   jint width, jint stride, jint height, jint pf, jint flags)
+{
+  if (pf < 0 || pf >= org_libjpegturbo_turbojpeg_TJ_NUMPF)
+    THROW_ARG("Invalid argument in decodeYUV()");
+  if (tjPixelSize[pf] != sizeof(jint))
+    THROW_ARG("Pixel format must be 32-bit when decoding to an integer buffer.");
+
+  TJDecompressor_decodeYUV(env, obj, srcobjs, jSrcOffsets, jSrcStrides,
+                           subsamp, dst, sizeof(jint), x, y, width,
+                           stride * sizeof(jint), height, pf, flags);
+
+bailout:
+  return;
+}
+
+/* TurboJPEG 1.2.x: TJTransformer::init() */
+JNIEXPORT void JNICALL Java_org_libjpegturbo_turbojpeg_TJTransformer_init
+  (JNIEnv *env, jobject obj)
+{
+  jclass cls;
+  jfieldID fid;
+  tjhandle handle;
+
+  if ((handle = tjInitTransform()) == NULL)
+    THROW(tjGetErrorStr(), "org/libjpegturbo/turbojpeg/TJException");
+
+  BAILIF0(cls = (*env)->GetObjectClass(env, obj));
+  BAILIF0(fid = (*env)->GetFieldID(env, cls, "handle", "J"));
+  (*env)->SetLongField(env, obj, fid, (size_t)handle);
+
+bailout:
+  return;
+}
+
+typedef struct _JNICustomFilterParams {
+  JNIEnv *env;
+  jobject tobj;
+  jobject cfobj;
+} JNICustomFilterParams;
+
+static int JNICustomFilter(short *coeffs, tjregion arrayRegion,
+                           tjregion planeRegion, int componentIndex,
+                           int transformIndex, tjtransform *transform)
+{
+  JNICustomFilterParams *params = (JNICustomFilterParams *)transform->data;
+  JNIEnv *env = params->env;
+  jobject tobj = params->tobj, cfobj = params->cfobj;
+  jobject arrayRegionObj, planeRegionObj, bufobj, borobj;
+  jclass cls;
+  jmethodID mid;
+  jfieldID fid;
+
+  BAILIF0(bufobj = (*env)->NewDirectByteBuffer(env, coeffs,
+    sizeof(short) * arrayRegion.w * arrayRegion.h));
+  BAILIF0(cls = (*env)->FindClass(env, "java/nio/ByteOrder"));
+  BAILIF0(mid = (*env)->GetStaticMethodID(env, cls, "nativeOrder",
+                                          "()Ljava/nio/ByteOrder;"));
+  BAILIF0(borobj = (*env)->CallStaticObjectMethod(env, cls, mid));
+  BAILIF0(cls = (*env)->GetObjectClass(env, bufobj));
+  BAILIF0(mid = (*env)->GetMethodID(env, cls, "order",
+    "(Ljava/nio/ByteOrder;)Ljava/nio/ByteBuffer;"));
+  (*env)->CallObjectMethod(env, bufobj, mid, borobj);
+  BAILIF0(mid = (*env)->GetMethodID(env, cls, "asShortBuffer",
+                                    "()Ljava/nio/ShortBuffer;"));
+  BAILIF0(bufobj = (*env)->CallObjectMethod(env, bufobj, mid));
+
+  BAILIF0(cls = (*env)->FindClass(env, "java/awt/Rectangle"));
+  BAILIF0(arrayRegionObj = (*env)->AllocObject(env, cls));
+  BAILIF0(fid = (*env)->GetFieldID(env, cls, "x", "I"));
+  (*env)->SetIntField(env, arrayRegionObj, fid, arrayRegion.x);
+  BAILIF0(fid = (*env)->GetFieldID(env, cls, "y", "I"));
+  (*env)->SetIntField(env, arrayRegionObj, fid, arrayRegion.y);
+  BAILIF0(fid = (*env)->GetFieldID(env, cls, "width", "I"));
+  (*env)->SetIntField(env, arrayRegionObj, fid, arrayRegion.w);
+  BAILIF0(fid = (*env)->GetFieldID(env, cls, "height", "I"));
+  (*env)->SetIntField(env, arrayRegionObj, fid, arrayRegion.h);
+
+  BAILIF0(planeRegionObj = (*env)->AllocObject(env, cls));
+  BAILIF0(fid = (*env)->GetFieldID(env, cls, "x", "I"));
+  (*env)->SetIntField(env, planeRegionObj, fid, planeRegion.x);
+  BAILIF0(fid = (*env)->GetFieldID(env, cls, "y", "I"));
+  (*env)->SetIntField(env, planeRegionObj, fid, planeRegion.y);
+  BAILIF0(fid = (*env)->GetFieldID(env, cls, "width", "I"));
+  (*env)->SetIntField(env, planeRegionObj, fid, planeRegion.w);
+  BAILIF0(fid = (*env)->GetFieldID(env, cls, "height", "I"));
+  (*env)->SetIntField(env, planeRegionObj, fid, planeRegion.h);
+
+  BAILIF0(cls = (*env)->GetObjectClass(env, cfobj));
+  BAILIF0(mid = (*env)->GetMethodID(env, cls, "customFilter",
+    "(Ljava/nio/ShortBuffer;Ljava/awt/Rectangle;Ljava/awt/Rectangle;IILorg/libjpegturbo/turbojpeg/TJTransform;)V"));
+  (*env)->CallVoidMethod(env, cfobj, mid, bufobj, arrayRegionObj,
+                         planeRegionObj, componentIndex, transformIndex, tobj);
+
+  return 0;
+
+bailout:
+  return -1;
+}
+
+/* TurboJPEG 1.2.x: TJTransformer::transform() */
+JNIEXPORT jintArray JNICALL Java_org_libjpegturbo_turbojpeg_TJTransformer_transform
+  (JNIEnv *env, jobject obj, jbyteArray jsrcBuf, jint jpegSize,
+   jobjectArray dstobjs, jobjectArray tobjs, jint flags)
+{
+  tjhandle handle = 0;
+  unsigned char *jpegBuf = NULL, **dstBufs = NULL;
+  jsize n = 0;
+  unsigned long *dstSizes = NULL;
+  tjtransform *t = NULL;
+  jbyteArray *jdstBufs = NULL;
+  int i, jpegWidth = 0, jpegHeight = 0, jpegSubsamp;
+  jintArray jdstSizes = 0;
+  jint *dstSizesi = NULL;
+  JNICustomFilterParams *params = NULL;
+
+  GET_HANDLE();
+
+  if ((*env)->GetArrayLength(env, jsrcBuf) < jpegSize)
+    THROW_ARG("Source buffer is not large enough");
+  BAILIF0(_fid = (*env)->GetFieldID(env, _cls, "jpegWidth", "I"));
+  jpegWidth = (int)(*env)->GetIntField(env, obj, _fid);
+  BAILIF0(_fid = (*env)->GetFieldID(env, _cls, "jpegHeight", "I"));
+  jpegHeight = (int)(*env)->GetIntField(env, obj, _fid);
+  BAILIF0(_fid = (*env)->GetFieldID(env, _cls, "jpegSubsamp", "I"));
+  jpegSubsamp = (int)(*env)->GetIntField(env, obj, _fid);
+
+  n = (*env)->GetArrayLength(env, dstobjs);
+  if (n != (*env)->GetArrayLength(env, tobjs))
+    THROW_ARG("Mismatch between size of transforms array and destination buffers array");
+
+  if ((dstBufs =
+       (unsigned char **)malloc(sizeof(unsigned char *) * n)) == NULL)
+    THROW_MEM();
+  if ((jdstBufs = (jbyteArray *)malloc(sizeof(jbyteArray) * n)) == NULL)
+    THROW_MEM();
+  if ((dstSizes = (unsigned long *)malloc(sizeof(unsigned long) * n)) == NULL)
+    THROW_MEM();
+  if ((t = (tjtransform *)malloc(sizeof(tjtransform) * n)) == NULL)
+    THROW_MEM();
+  if ((params = (JNICustomFilterParams *)malloc(sizeof(JNICustomFilterParams) *
+                                                n)) == NULL)
+    THROW_MEM();
+  for (i = 0; i < n; i++) {
+    dstBufs[i] = NULL;  jdstBufs[i] = NULL;  dstSizes[i] = 0;
+    memset(&t[i], 0, sizeof(tjtransform));
+    memset(&params[i], 0, sizeof(JNICustomFilterParams));
+  }
+
+  for (i = 0; i < n; i++) {
+    jobject tobj, cfobj;
+
+    BAILIF0(tobj = (*env)->GetObjectArrayElement(env, tobjs, i));
+    BAILIF0(_cls = (*env)->GetObjectClass(env, tobj));
+    BAILIF0(_fid = (*env)->GetFieldID(env, _cls, "op", "I"));
+    t[i].op = (*env)->GetIntField(env, tobj, _fid);
+    BAILIF0(_fid = (*env)->GetFieldID(env, _cls, "options", "I"));
+    t[i].options = (*env)->GetIntField(env, tobj, _fid);
+    BAILIF0(_fid = (*env)->GetFieldID(env, _cls, "x", "I"));
+    t[i].r.x = (*env)->GetIntField(env, tobj, _fid);
+    BAILIF0(_fid = (*env)->GetFieldID(env, _cls, "y", "I"));
+    t[i].r.y = (*env)->GetIntField(env, tobj, _fid);
+    BAILIF0(_fid = (*env)->GetFieldID(env, _cls, "width", "I"));
+    t[i].r.w = (*env)->GetIntField(env, tobj, _fid);
+    BAILIF0(_fid = (*env)->GetFieldID(env, _cls, "height", "I"));
+    t[i].r.h = (*env)->GetIntField(env, tobj, _fid);
+
+    BAILIF0(_fid = (*env)->GetFieldID(env, _cls, "cf",
+      "Lorg/libjpegturbo/turbojpeg/TJCustomFilter;"));
+    cfobj = (*env)->GetObjectField(env, tobj, _fid);
+    if (cfobj) {
+      params[i].env = env;
+      params[i].tobj = tobj;
+      params[i].cfobj = cfobj;
+      t[i].customFilter = JNICustomFilter;
+      t[i].data = (void *)&params[i];
+    }
+  }
+
+  for (i = 0; i < n; i++) {
+    int w = jpegWidth, h = jpegHeight;
+
+    if (t[i].r.w != 0) w = t[i].r.w;
+    if (t[i].r.h != 0) h = t[i].r.h;
+    BAILIF0(jdstBufs[i] = (*env)->GetObjectArrayElement(env, dstobjs, i));
+    if ((unsigned long)(*env)->GetArrayLength(env, jdstBufs[i]) <
+        tjBufSize(w, h, jpegSubsamp))
+      THROW_ARG("Destination buffer is not large enough");
+  }
+  BAILIF0(jpegBuf = (*env)->GetPrimitiveArrayCritical(env, jsrcBuf, 0));
+  for (i = 0; i < n; i++)
+    BAILIF0(dstBufs[i] =
+            (*env)->GetPrimitiveArrayCritical(env, jdstBufs[i], 0));
+
+  if (tjTransform(handle, jpegBuf, jpegSize, n, dstBufs, dstSizes, t,
+                  flags | TJFLAG_NOREALLOC) == -1) {
+    for (i = 0; i < n; i++)
+      SAFE_RELEASE(jdstBufs[i], dstBufs[i]);
+    SAFE_RELEASE(jsrcBuf, jpegBuf);
+    THROW_TJ();
+  }
+
+  for (i = 0; i < n; i++)
+    SAFE_RELEASE(jdstBufs[i], dstBufs[i]);
+  SAFE_RELEASE(jsrcBuf, jpegBuf);
+
+  jdstSizes = (*env)->NewIntArray(env, n);
+  BAILIF0(dstSizesi = (*env)->GetIntArrayElements(env, jdstSizes, 0));
+  for (i = 0; i < n; i++) dstSizesi[i] = (int)dstSizes[i];
+
+bailout:
+  if (dstSizesi) (*env)->ReleaseIntArrayElements(env, jdstSizes, dstSizesi, 0);
+  if (dstBufs) {
+    for (i = 0; i < n; i++) {
+      if (dstBufs[i] && jdstBufs && jdstBufs[i])
+        (*env)->ReleasePrimitiveArrayCritical(env, jdstBufs[i], dstBufs[i], 0);
+    }
+    free(dstBufs);
+  }
+  SAFE_RELEASE(jsrcBuf, jpegBuf);
+  free(jdstBufs);
+  free(dstSizes);
+  free(t);
+  return jdstSizes;
+}
+
+/* TurboJPEG 1.2.x: TJDecompressor::destroy() */
+JNIEXPORT void JNICALL Java_org_libjpegturbo_turbojpeg_TJDecompressor_destroy
+  (JNIEnv *env, jobject obj)
+{
+  Java_org_libjpegturbo_turbojpeg_TJCompressor_destroy(env, obj);
+}
diff --git a/3rdparty/libjpeg/src/turbojpeg-mapfile b/3rdparty/libjpeg/src/turbojpeg-mapfile
new file mode 100644
index 00000000..5477fed2
--- /dev/null
+++ b/3rdparty/libjpeg/src/turbojpeg-mapfile
@@ -0,0 +1,65 @@
+TURBOJPEG_1.0
+{
+  global:
+    tjInitCompress;
+    tjCompress;
+    TJBUFSIZE;
+    tjInitDecompress;
+    tjDecompressHeader;
+    tjDecompress;
+    tjDestroy;
+    tjGetErrorStr;
+  local:
+    *;
+};
+
+TURBOJPEG_1.1
+{
+  global:
+    TJBUFSIZEYUV;
+    tjDecompressHeader2;
+    tjDecompressToYUV;
+    tjEncodeYUV;
+} TURBOJPEG_1.0;
+
+TURBOJPEG_1.2
+{
+  global:
+    tjAlloc;
+    tjBufSize;
+    tjBufSizeYUV;
+    tjCompress2;
+    tjDecompress2;
+    tjEncodeYUV2;
+    tjFree;
+    tjGetScalingFactors;
+    tjInitTransform;
+    tjTransform;
+} TURBOJPEG_1.1;
+
+TURBOJPEG_1.4
+{
+  global:
+    tjBufSizeYUV2;
+    tjCompressFromYUV;
+    tjCompressFromYUVPlanes;
+    tjDecodeYUV;
+    tjDecodeYUVPlanes;
+    tjDecompressHeader3;
+    tjDecompressToYUV2;
+    tjDecompressToYUVPlanes;
+    tjEncodeYUV3;
+    tjEncodeYUVPlanes;
+    tjPlaneHeight;
+    tjPlaneSizeYUV;
+    tjPlaneWidth;
+} TURBOJPEG_1.2;
+
+TURBOJPEG_2.0
+{
+  global:
+    tjGetErrorCode;
+    tjGetErrorStr2;
+    tjLoadImage;
+    tjSaveImage;
+} TURBOJPEG_1.4;
diff --git a/3rdparty/libjpeg/src/turbojpeg-mapfile.jni b/3rdparty/libjpeg/src/turbojpeg-mapfile.jni
new file mode 100644
index 00000000..44327912
--- /dev/null
+++ b/3rdparty/libjpeg/src/turbojpeg-mapfile.jni
@@ -0,0 +1,101 @@
+TURBOJPEG_1.0
+{
+  global:
+    tjInitCompress;
+    tjCompress;
+    TJBUFSIZE;
+    tjInitDecompress;
+    tjDecompressHeader;
+    tjDecompress;
+    tjDestroy;
+    tjGetErrorStr;
+  local:
+    *;
+};
+
+TURBOJPEG_1.1
+{
+  global:
+    TJBUFSIZEYUV;
+    tjDecompressHeader2;
+    tjDecompressToYUV;
+    tjEncodeYUV;
+} TURBOJPEG_1.0;
+
+TURBOJPEG_1.2
+{
+  global:
+    tjAlloc;
+    tjBufSize;
+    tjBufSizeYUV;
+    tjCompress2;
+    tjDecompress2;
+    tjEncodeYUV2;
+    tjFree;
+    tjGetScalingFactors;
+    tjInitTransform;
+    tjTransform;
+    Java_org_libjpegturbo_turbojpeg_TJ_bufSize;
+    Java_org_libjpegturbo_turbojpeg_TJ_bufSizeYUV__III;
+    Java_org_libjpegturbo_turbojpeg_TJ_getScalingFactors;
+    Java_org_libjpegturbo_turbojpeg_TJCompressor_init;
+    Java_org_libjpegturbo_turbojpeg_TJCompressor_compress___3BIIII_3BIII;
+    Java_org_libjpegturbo_turbojpeg_TJCompressor_compress___3IIIII_3BIII;
+    Java_org_libjpegturbo_turbojpeg_TJCompressor_encodeYUV___3BIIII_3BII;
+    Java_org_libjpegturbo_turbojpeg_TJCompressor_encodeYUV___3IIIII_3BII;
+    Java_org_libjpegturbo_turbojpeg_TJCompressor_destroy;
+    Java_org_libjpegturbo_turbojpeg_TJDecompressor_init;
+    Java_org_libjpegturbo_turbojpeg_TJDecompressor_decompressHeader;
+    Java_org_libjpegturbo_turbojpeg_TJDecompressor_decompress___3BI_3BIIIII;
+    Java_org_libjpegturbo_turbojpeg_TJDecompressor_decompress___3BI_3IIIIII;
+    Java_org_libjpegturbo_turbojpeg_TJDecompressor_decompressToYUV___3BI_3BI;
+    Java_org_libjpegturbo_turbojpeg_TJDecompressor_destroy;
+    Java_org_libjpegturbo_turbojpeg_TJTransformer_init;
+    Java_org_libjpegturbo_turbojpeg_TJTransformer_transform;
+} TURBOJPEG_1.1;
+
+TURBOJPEG_1.3
+{
+  global:
+    Java_org_libjpegturbo_turbojpeg_TJCompressor_compress___3BIIIIII_3BIII;
+    Java_org_libjpegturbo_turbojpeg_TJCompressor_compress___3IIIIIII_3BIII;
+    Java_org_libjpegturbo_turbojpeg_TJDecompressor_decompress___3BI_3BIIIIIII;
+    Java_org_libjpegturbo_turbojpeg_TJDecompressor_decompress___3BI_3IIIIIIII;
+} TURBOJPEG_1.2;
+
+TURBOJPEG_1.4
+{
+  global:
+    tjBufSizeYUV2;
+    tjCompressFromYUV;
+    tjCompressFromYUVPlanes;
+    tjDecodeYUV;
+    tjDecodeYUVPlanes;
+    tjDecompressHeader3;
+    tjDecompressToYUV2;
+    tjDecompressToYUVPlanes;
+    tjEncodeYUV3;
+    tjEncodeYUVPlanes;
+    tjPlaneHeight;
+    tjPlaneSizeYUV;
+    tjPlaneWidth;
+    Java_org_libjpegturbo_turbojpeg_TJ_bufSizeYUV__IIII;
+    Java_org_libjpegturbo_turbojpeg_TJCompressor_compressFromYUV___3_3B_3II_3III_3BII;
+    Java_org_libjpegturbo_turbojpeg_TJCompressor_encodeYUV___3BIIIIII_3_3B_3I_3III;
+    Java_org_libjpegturbo_turbojpeg_TJCompressor_encodeYUV___3IIIIIII_3_3B_3I_3III;
+    Java_org_libjpegturbo_turbojpeg_TJDecompressor_decompressToYUV___3BI_3_3B_3II_3III;
+    Java_org_libjpegturbo_turbojpeg_TJDecompressor_decodeYUV___3_3B_3I_3II_3BIIIIIII;
+    Java_org_libjpegturbo_turbojpeg_TJDecompressor_decodeYUV___3_3B_3I_3II_3IIIIIIII;
+    Java_org_libjpegturbo_turbojpeg_TJ_planeHeight__III;
+    Java_org_libjpegturbo_turbojpeg_TJ_planeSizeYUV__IIIII;
+    Java_org_libjpegturbo_turbojpeg_TJ_planeWidth__III;
+} TURBOJPEG_1.3;
+
+TURBOJPEG_2.0
+{
+  global:
+    tjGetErrorCode;
+    tjGetErrorStr2;
+    tjLoadImage;
+    tjSaveImage;
+} TURBOJPEG_1.4;
diff --git a/3rdparty/libjpeg/src/turbojpeg.c b/3rdparty/libjpeg/src/turbojpeg.c
new file mode 100644
index 00000000..8260555b
--- /dev/null
+++ b/3rdparty/libjpeg/src/turbojpeg.c
@@ -0,0 +1,2149 @@
+/*
+ * Copyright (C)2009-2020 D. R. Commander.  All Rights Reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright notice,
+ *   this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright notice,
+ *   this list of conditions and the following disclaimer in the documentation
+ *   and/or other materials provided with the distribution.
+ * - Neither the name of the libjpeg-turbo Project nor the names of its
+ *   contributors may be used to endorse or promote products derived from this
+ *   software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE 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 HOLDERS 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.
+ */
+
+/* TurboJPEG/LJT:  this implements the TurboJPEG API using libjpeg or
+   libjpeg-turbo */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <jinclude.h>
+#define JPEG_INTERNALS
+#include <jpeglib.h>
+#include <jerror.h>
+#include <setjmp.h>
+#include <errno.h>
+#include "./turbojpeg.h"
+#include "./tjutil.h"
+#include "transupp.h"
+#include "./jpegcomp.h"
+#include "./cdjpeg.h"
+#include "jconfigint.h"
+
+extern void jpeg_mem_dest_tj(j_compress_ptr, unsigned char **, unsigned long *,
+                             boolean);
+extern void jpeg_mem_src_tj(j_decompress_ptr, const unsigned char *,
+                            unsigned long);
+
+#define PAD(v, p)  ((v + (p) - 1) & (~((p) - 1)))
+#define IS_POW2(x)  (((x) & (x - 1)) == 0)
+
+
+/* Error handling (based on example in example.txt) */
+
+static THREAD_LOCAL char errStr[JMSG_LENGTH_MAX] = "No error";
+
+struct my_error_mgr {
+  struct jpeg_error_mgr pub;
+  jmp_buf setjmp_buffer;
+  void (*emit_message) (j_common_ptr, int);
+  boolean warning, stopOnWarning;
+};
+typedef struct my_error_mgr *my_error_ptr;
+
+#define JMESSAGE(code, string)  string,
+static const char *turbojpeg_message_table[] = {
+#include "cderror.h"
+  NULL
+};
+
+static void my_error_exit(j_common_ptr cinfo)
+{
+  my_error_ptr myerr = (my_error_ptr)cinfo->err;
+
+  (*cinfo->err->output_message) (cinfo);
+  longjmp(myerr->setjmp_buffer, 1);
+}
+
+/* Based on output_message() in jerror.c */
+
+static void my_output_message(j_common_ptr cinfo)
+{
+  (*cinfo->err->format_message) (cinfo, errStr);
+}
+
+static void my_emit_message(j_common_ptr cinfo, int msg_level)
+{
+  my_error_ptr myerr = (my_error_ptr)cinfo->err;
+
+  myerr->emit_message(cinfo, msg_level);
+  if (msg_level < 0) {
+    myerr->warning = TRUE;
+    if (myerr->stopOnWarning) longjmp(myerr->setjmp_buffer, 1);
+  }
+}
+
+
+/* Global structures, macros, etc. */
+
+enum { COMPRESS = 1, DECOMPRESS = 2 };
+
+typedef struct _tjinstance {
+  struct jpeg_compress_struct cinfo;
+  struct jpeg_decompress_struct dinfo;
+  struct my_error_mgr jerr;
+  int init, headerRead;
+  char errStr[JMSG_LENGTH_MAX];
+  boolean isInstanceError;
+} tjinstance;
+
+static const int pixelsize[TJ_NUMSAMP] = { 3, 3, 3, 1, 3, 3 };
+
+static const JXFORM_CODE xformtypes[TJ_NUMXOP] = {
+  JXFORM_NONE, JXFORM_FLIP_H, JXFORM_FLIP_V, JXFORM_TRANSPOSE,
+  JXFORM_TRANSVERSE, JXFORM_ROT_90, JXFORM_ROT_180, JXFORM_ROT_270
+};
+
+#define NUMSF  16
+static const tjscalingfactor sf[NUMSF] = {
+  { 2, 1 },
+  { 15, 8 },
+  { 7, 4 },
+  { 13, 8 },
+  { 3, 2 },
+  { 11, 8 },
+  { 5, 4 },
+  { 9, 8 },
+  { 1, 1 },
+  { 7, 8 },
+  { 3, 4 },
+  { 5, 8 },
+  { 1, 2 },
+  { 3, 8 },
+  { 1, 4 },
+  { 1, 8 }
+};
+
+static J_COLOR_SPACE pf2cs[TJ_NUMPF] = {
+  JCS_EXT_RGB, JCS_EXT_BGR, JCS_EXT_RGBX, JCS_EXT_BGRX, JCS_EXT_XBGR,
+  JCS_EXT_XRGB, JCS_GRAYSCALE, JCS_EXT_RGBA, JCS_EXT_BGRA, JCS_EXT_ABGR,
+  JCS_EXT_ARGB, JCS_CMYK
+};
+
+static int cs2pf[JPEG_NUMCS] = {
+  TJPF_UNKNOWN, TJPF_GRAY,
+#if RGB_RED == 0 && RGB_GREEN == 1 && RGB_BLUE == 2 && RGB_PIXELSIZE == 3
+  TJPF_RGB,
+#elif RGB_RED == 2 && RGB_GREEN == 1 && RGB_BLUE == 0 && RGB_PIXELSIZE == 3
+  TJPF_BGR,
+#elif RGB_RED == 0 && RGB_GREEN == 1 && RGB_BLUE == 2 && RGB_PIXELSIZE == 4
+  TJPF_RGBX,
+#elif RGB_RED == 2 && RGB_GREEN == 1 && RGB_BLUE == 0 && RGB_PIXELSIZE == 4
+  TJPF_BGRX,
+#elif RGB_RED == 3 && RGB_GREEN == 2 && RGB_BLUE == 1 && RGB_PIXELSIZE == 4
+  TJPF_XBGR,
+#elif RGB_RED == 1 && RGB_GREEN == 2 && RGB_BLUE == 3 && RGB_PIXELSIZE == 4
+  TJPF_XRGB,
+#endif
+  TJPF_UNKNOWN, TJPF_CMYK, TJPF_UNKNOWN, TJPF_RGB, TJPF_RGBX, TJPF_BGR,
+  TJPF_BGRX, TJPF_XBGR, TJPF_XRGB, TJPF_RGBA, TJPF_BGRA, TJPF_ABGR, TJPF_ARGB,
+  TJPF_UNKNOWN
+};
+
+#define THROWG(m) { \
+  snprintf(errStr, JMSG_LENGTH_MAX, "%s", m); \
+  retval = -1;  goto bailout; \
+}
+#define THROW_UNIX(m) { \
+  snprintf(errStr, JMSG_LENGTH_MAX, "%s\n%s", m, strerror(errno)); \
+  retval = -1;  goto bailout; \
+}
+#define THROW(m) { \
+  snprintf(this->errStr, JMSG_LENGTH_MAX, "%s", m); \
+  this->isInstanceError = TRUE;  THROWG(m) \
+}
+
+#define GET_INSTANCE(handle) \
+  tjinstance *this = (tjinstance *)handle; \
+  j_compress_ptr cinfo = NULL; \
+  j_decompress_ptr dinfo = NULL; \
+  \
+  if (!this) { \
+    snprintf(errStr, JMSG_LENGTH_MAX, "Invalid handle"); \
+    return -1; \
+  } \
+  cinfo = &this->cinfo;  dinfo = &this->dinfo; \
+  this->jerr.warning = FALSE; \
+  this->isInstanceError = FALSE;
+
+#define GET_CINSTANCE(handle) \
+  tjinstance *this = (tjinstance *)handle; \
+  j_compress_ptr cinfo = NULL; \
+  \
+  if (!this) { \
+    snprintf(errStr, JMSG_LENGTH_MAX, "Invalid handle"); \
+    return -1; \
+  } \
+  cinfo = &this->cinfo; \
+  this->jerr.warning = FALSE; \
+  this->isInstanceError = FALSE;
+
+#define GET_DINSTANCE(handle) \
+  tjinstance *this = (tjinstance *)handle; \
+  j_decompress_ptr dinfo = NULL; \
+  \
+  if (!this) { \
+    snprintf(errStr, JMSG_LENGTH_MAX, "Invalid handle"); \
+    return -1; \
+  } \
+  dinfo = &this->dinfo; \
+  this->jerr.warning = FALSE; \
+  this->isInstanceError = FALSE;
+
+static int getPixelFormat(int pixelSize, int flags)
+{
+  if (pixelSize == 1) return TJPF_GRAY;
+  if (pixelSize == 3) {
+    if (flags & TJ_BGR) return TJPF_BGR;
+    else return TJPF_RGB;
+  }
+  if (pixelSize == 4) {
+    if (flags & TJ_ALPHAFIRST) {
+      if (flags & TJ_BGR) return TJPF_XBGR;
+      else return TJPF_XRGB;
+    } else {
+      if (flags & TJ_BGR) return TJPF_BGRX;
+      else return TJPF_RGBX;
+    }
+  }
+  return -1;
+}
+
+static void setCompDefaults(struct jpeg_compress_struct *cinfo,
+                            int pixelFormat, int subsamp, int jpegQual,
+                            int flags)
+{
+#ifndef NO_GETENV
+  char *env = NULL;
+#endif
+
+  cinfo->in_color_space = pf2cs[pixelFormat];
+  cinfo->input_components = tjPixelSize[pixelFormat];
+  jpeg_set_defaults(cinfo);
+
+#ifndef NO_GETENV
+  if ((env = getenv("TJ_OPTIMIZE")) != NULL && strlen(env) > 0 &&
+      !strcmp(env, "1"))
+    cinfo->optimize_coding = TRUE;
+  if ((env = getenv("TJ_ARITHMETIC")) != NULL && strlen(env) > 0 &&
+      !strcmp(env, "1"))
+    cinfo->arith_code = TRUE;
+  if ((env = getenv("TJ_RESTART")) != NULL && strlen(env) > 0) {
+    int temp = -1;
+    char tempc = 0;
+
+    if (sscanf(env, "%d%c", &temp, &tempc) >= 1 && temp >= 0 &&
+        temp <= 65535) {
+      if (toupper(tempc) == 'B') {
+        cinfo->restart_interval = temp;
+        cinfo->restart_in_rows = 0;
+      } else
+        cinfo->restart_in_rows = temp;
+    }
+  }
+#endif
+
+  if (jpegQual >= 0) {
+    jpeg_set_quality(cinfo, jpegQual, TRUE);
+    if (jpegQual >= 96 || flags & TJFLAG_ACCURATEDCT)
+      cinfo->dct_method = JDCT_ISLOW;
+    else
+      cinfo->dct_method = JDCT_FASTEST;
+  }
+  if (subsamp == TJSAMP_GRAY)
+    jpeg_set_colorspace(cinfo, JCS_GRAYSCALE);
+  else if (pixelFormat == TJPF_CMYK)
+    jpeg_set_colorspace(cinfo, JCS_YCCK);
+  else
+    jpeg_set_colorspace(cinfo, JCS_YCbCr);
+
+  if (flags & TJFLAG_PROGRESSIVE)
+    jpeg_simple_progression(cinfo);
+#ifndef NO_GETENV
+  else if ((env = getenv("TJ_PROGRESSIVE")) != NULL && strlen(env) > 0 &&
+           !strcmp(env, "1"))
+    jpeg_simple_progression(cinfo);
+#endif
+
+  cinfo->comp_info[0].h_samp_factor = tjMCUWidth[subsamp] / 8;
+  cinfo->comp_info[1].h_samp_factor = 1;
+  cinfo->comp_info[2].h_samp_factor = 1;
+  if (cinfo->num_components > 3)
+    cinfo->comp_info[3].h_samp_factor = tjMCUWidth[subsamp] / 8;
+  cinfo->comp_info[0].v_samp_factor = tjMCUHeight[subsamp] / 8;
+  cinfo->comp_info[1].v_samp_factor = 1;
+  cinfo->comp_info[2].v_samp_factor = 1;
+  if (cinfo->num_components > 3)
+    cinfo->comp_info[3].v_samp_factor = tjMCUHeight[subsamp] / 8;
+}
+
+
+static int getSubsamp(j_decompress_ptr dinfo)
+{
+  int retval = -1, i, k;
+
+  /* The sampling factors actually have no meaning with grayscale JPEG files,
+     and in fact it's possible to generate grayscale JPEGs with sampling
+     factors > 1 (even though those sampling factors are ignored by the
+     decompressor.)  Thus, we need to treat grayscale as a special case. */
+  if (dinfo->num_components == 1 && dinfo->jpeg_color_space == JCS_GRAYSCALE)
+    return TJSAMP_GRAY;
+
+  for (i = 0; i < NUMSUBOPT; i++) {
+    if (dinfo->num_components == pixelsize[i] ||
+        ((dinfo->jpeg_color_space == JCS_YCCK ||
+          dinfo->jpeg_color_space == JCS_CMYK) &&
+         pixelsize[i] == 3 && dinfo->num_components == 4)) {
+      if (dinfo->comp_info[0].h_samp_factor == tjMCUWidth[i] / 8 &&
+          dinfo->comp_info[0].v_samp_factor == tjMCUHeight[i] / 8) {
+        int match = 0;
+
+        for (k = 1; k < dinfo->num_components; k++) {
+          int href = 1, vref = 1;
+
+          if ((dinfo->jpeg_color_space == JCS_YCCK ||
+               dinfo->jpeg_color_space == JCS_CMYK) && k == 3) {
+            href = tjMCUWidth[i] / 8;  vref = tjMCUHeight[i] / 8;
+          }
+          if (dinfo->comp_info[k].h_samp_factor == href &&
+              dinfo->comp_info[k].v_samp_factor == vref)
+            match++;
+        }
+        if (match == dinfo->num_components - 1) {
+          retval = i;  break;
+        }
+      }
+      /* Handle 4:2:2 and 4:4:0 images whose sampling factors are specified
+         in non-standard ways. */
+      if (dinfo->comp_info[0].h_samp_factor == 2 &&
+          dinfo->comp_info[0].v_samp_factor == 2 &&
+          (i == TJSAMP_422 || i == TJSAMP_440)) {
+        int match = 0;
+
+        for (k = 1; k < dinfo->num_components; k++) {
+          int href = tjMCUHeight[i] / 8, vref = tjMCUWidth[i] / 8;
+
+          if ((dinfo->jpeg_color_space == JCS_YCCK ||
+               dinfo->jpeg_color_space == JCS_CMYK) && k == 3) {
+            href = vref = 2;
+          }
+          if (dinfo->comp_info[k].h_samp_factor == href &&
+              dinfo->comp_info[k].v_samp_factor == vref)
+            match++;
+        }
+        if (match == dinfo->num_components - 1) {
+          retval = i;  break;
+        }
+      }
+      /* Handle 4:4:4 images whose sampling factors are specified in
+         non-standard ways. */
+      if (dinfo->comp_info[0].h_samp_factor *
+          dinfo->comp_info[0].v_samp_factor <=
+          D_MAX_BLOCKS_IN_MCU / pixelsize[i] && i == TJSAMP_444) {
+        int match = 0;
+        for (k = 1; k < dinfo->num_components; k++) {
+          if (dinfo->comp_info[k].h_samp_factor ==
+              dinfo->comp_info[0].h_samp_factor &&
+              dinfo->comp_info[k].v_samp_factor ==
+              dinfo->comp_info[0].v_samp_factor)
+            match++;
+          if (match == dinfo->num_components - 1) {
+            retval = i;  break;
+          }
+        }
+      }
+    }
+  }
+  return retval;
+}
+
+
+/* General API functions */
+
+DLLEXPORT char *tjGetErrorStr2(tjhandle handle)
+{
+  tjinstance *this = (tjinstance *)handle;
+
+  if (this && this->isInstanceError) {
+    this->isInstanceError = FALSE;
+    return this->errStr;
+  } else
+    return errStr;
+}
+
+
+DLLEXPORT char *tjGetErrorStr(void)
+{
+  return errStr;
+}
+
+
+DLLEXPORT int tjGetErrorCode(tjhandle handle)
+{
+  tjinstance *this = (tjinstance *)handle;
+
+  if (this && this->jerr.warning) return TJERR_WARNING;
+  else return TJERR_FATAL;
+}
+
+
+DLLEXPORT int tjDestroy(tjhandle handle)
+{
+  GET_INSTANCE(handle);
+
+  if (setjmp(this->jerr.setjmp_buffer)) return -1;
+  if (this->init & COMPRESS) jpeg_destroy_compress(cinfo);
+  if (this->init & DECOMPRESS) jpeg_destroy_decompress(dinfo);
+  free(this);
+  return 0;
+}
+
+
+/* These are exposed mainly because Windows can't malloc() and free() across
+   DLL boundaries except when the CRT DLL is used, and we don't use the CRT DLL
+   with turbojpeg.dll for compatibility reasons.  However, these functions
+   can potentially be used for other purposes by different implementations. */
+
+DLLEXPORT void tjFree(unsigned char *buf)
+{
+  free(buf);
+}
+
+
+DLLEXPORT unsigned char *tjAlloc(int bytes)
+{
+  return (unsigned char *)malloc(bytes);
+}
+
+
+/* Compressor  */
+
+static tjhandle _tjInitCompress(tjinstance *this)
+{
+  static unsigned char buffer[1];
+  unsigned char *buf = buffer;
+  unsigned long size = 1;
+
+  /* This is also straight out of example.txt */
+  this->cinfo.err = jpeg_std_error(&this->jerr.pub);
+  this->jerr.pub.error_exit = my_error_exit;
+  this->jerr.pub.output_message = my_output_message;
+  this->jerr.emit_message = this->jerr.pub.emit_message;
+  this->jerr.pub.emit_message = my_emit_message;
+  this->jerr.pub.addon_message_table = turbojpeg_message_table;
+  this->jerr.pub.first_addon_message = JMSG_FIRSTADDONCODE;
+  this->jerr.pub.last_addon_message = JMSG_LASTADDONCODE;
+
+  if (setjmp(this->jerr.setjmp_buffer)) {
+    /* If we get here, the JPEG code has signaled an error. */
+    free(this);
+    return NULL;
+  }
+
+  jpeg_create_compress(&this->cinfo);
+  /* Make an initial call so it will create the destination manager */
+  jpeg_mem_dest_tj(&this->cinfo, &buf, &size, 0);
+
+  this->init |= COMPRESS;
+  return (tjhandle)this;
+}
+
+DLLEXPORT tjhandle tjInitCompress(void)
+{
+  tjinstance *this = NULL;
+
+  if ((this = (tjinstance *)malloc(sizeof(tjinstance))) == NULL) {
+    snprintf(errStr, JMSG_LENGTH_MAX,
+             "tjInitCompress(): Memory allocation failure");
+    return NULL;
+  }
+  MEMZERO(this, sizeof(tjinstance));
+  snprintf(this->errStr, JMSG_LENGTH_MAX, "No error");
+  return _tjInitCompress(this);
+}
+
+
+DLLEXPORT unsigned long tjBufSize(int width, int height, int jpegSubsamp)
+{
+  unsigned long long retval = 0;
+  int mcuw, mcuh, chromasf;
+
+  if (width < 1 || height < 1 || jpegSubsamp < 0 || jpegSubsamp >= NUMSUBOPT)
+    THROWG("tjBufSize(): Invalid argument");
+
+  /* This allows for rare corner cases in which a JPEG image can actually be
+     larger than the uncompressed input (we wouldn't mention it if it hadn't
+     happened before.) */
+  mcuw = tjMCUWidth[jpegSubsamp];
+  mcuh = tjMCUHeight[jpegSubsamp];
+  chromasf = jpegSubsamp == TJSAMP_GRAY ? 0 : 4 * 64 / (mcuw * mcuh);
+  retval = PAD(width, mcuw) * PAD(height, mcuh) * (2ULL + chromasf) + 2048ULL;
+  if (retval > (unsigned long long)((unsigned long)-1))
+    THROWG("tjBufSize(): Image is too large");
+
+bailout:
+  return (unsigned long)retval;
+}
+
+DLLEXPORT unsigned long TJBUFSIZE(int width, int height)
+{
+  unsigned long long retval = 0;
+
+  if (width < 1 || height < 1)
+    THROWG("TJBUFSIZE(): Invalid argument");
+
+  /* This allows for rare corner cases in which a JPEG image can actually be
+     larger than the uncompressed input (we wouldn't mention it if it hadn't
+     happened before.) */
+  retval = PAD(width, 16) * PAD(height, 16) * 6ULL + 2048ULL;
+  if (retval > (unsigned long long)((unsigned long)-1))
+    THROWG("TJBUFSIZE(): Image is too large");
+
+bailout:
+  return (unsigned long)retval;
+}
+
+
+DLLEXPORT unsigned long tjBufSizeYUV2(int width, int pad, int height,
+                                      int subsamp)
+{
+  unsigned long long retval = 0;
+  int nc, i;
+
+  if (subsamp < 0 || subsamp >= NUMSUBOPT)
+    THROWG("tjBufSizeYUV2(): Invalid argument");
+
+  nc = (subsamp == TJSAMP_GRAY ? 1 : 3);
+  for (i = 0; i < nc; i++) {
+    int pw = tjPlaneWidth(i, width, subsamp);
+    int stride = PAD(pw, pad);
+    int ph = tjPlaneHeight(i, height, subsamp);
+
+    if (pw < 0 || ph < 0) return -1;
+    else retval += (unsigned long long)stride * ph;
+  }
+  if (retval > (unsigned long long)((unsigned long)-1))
+    THROWG("tjBufSizeYUV2(): Image is too large");
+
+bailout:
+  return (unsigned long)retval;
+}
+
+DLLEXPORT unsigned long tjBufSizeYUV(int width, int height, int subsamp)
+{
+  return tjBufSizeYUV2(width, 4, height, subsamp);
+}
+
+DLLEXPORT unsigned long TJBUFSIZEYUV(int width, int height, int subsamp)
+{
+  return tjBufSizeYUV(width, height, subsamp);
+}
+
+
+DLLEXPORT int tjPlaneWidth(int componentID, int width, int subsamp)
+{
+  int pw, nc, retval = 0;
+
+  if (width < 1 || subsamp < 0 || subsamp >= TJ_NUMSAMP)
+    THROWG("tjPlaneWidth(): Invalid argument");
+  nc = (subsamp == TJSAMP_GRAY ? 1 : 3);
+  if (componentID < 0 || componentID >= nc)
+    THROWG("tjPlaneWidth(): Invalid argument");
+
+  pw = PAD(width, tjMCUWidth[subsamp] / 8);
+  if (componentID == 0)
+    retval = pw;
+  else
+    retval = pw * 8 / tjMCUWidth[subsamp];
+
+bailout:
+  return retval;
+}
+
+
+DLLEXPORT int tjPlaneHeight(int componentID, int height, int subsamp)
+{
+  int ph, nc, retval = 0;
+
+  if (height < 1 || subsamp < 0 || subsamp >= TJ_NUMSAMP)
+    THROWG("tjPlaneHeight(): Invalid argument");
+  nc = (subsamp == TJSAMP_GRAY ? 1 : 3);
+  if (componentID < 0 || componentID >= nc)
+    THROWG("tjPlaneHeight(): Invalid argument");
+
+  ph = PAD(height, tjMCUHeight[subsamp] / 8);
+  if (componentID == 0)
+    retval = ph;
+  else
+    retval = ph * 8 / tjMCUHeight[subsamp];
+
+bailout:
+  return retval;
+}
+
+
+DLLEXPORT unsigned long tjPlaneSizeYUV(int componentID, int width, int stride,
+                                       int height, int subsamp)
+{
+  unsigned long long retval = 0;
+  int pw, ph;
+
+  if (width < 1 || height < 1 || subsamp < 0 || subsamp >= NUMSUBOPT)
+    THROWG("tjPlaneSizeYUV(): Invalid argument");
+
+  pw = tjPlaneWidth(componentID, width, subsamp);
+  ph = tjPlaneHeight(componentID, height, subsamp);
+  if (pw < 0 || ph < 0) return -1;
+
+  if (stride == 0) stride = pw;
+  else stride = abs(stride);
+
+  retval = (unsigned long long)stride * (ph - 1) + pw;
+  if (retval > (unsigned long long)((unsigned long)-1))
+    THROWG("tjPlaneSizeYUV(): Image is too large");
+
+bailout:
+  return (unsigned long)retval;
+}
+
+
+DLLEXPORT int tjCompress2(tjhandle handle, const unsigned char *srcBuf,
+                          int width, int pitch, int height, int pixelFormat,
+                          unsigned char **jpegBuf, unsigned long *jpegSize,
+                          int jpegSubsamp, int jpegQual, int flags)
+{
+  int i, retval = 0, alloc = 1;
+  JSAMPROW *row_pointer = NULL;
+
+  GET_CINSTANCE(handle)
+  this->jerr.stopOnWarning = (flags & TJFLAG_STOPONWARNING) ? TRUE : FALSE;
+  if ((this->init & COMPRESS) == 0)
+    THROW("tjCompress2(): Instance has not been initialized for compression");
+
+  if (srcBuf == NULL || width <= 0 || pitch < 0 || height <= 0 ||
+      pixelFormat < 0 || pixelFormat >= TJ_NUMPF || jpegBuf == NULL ||
+      jpegSize == NULL || jpegSubsamp < 0 || jpegSubsamp >= NUMSUBOPT ||
+      jpegQual < 0 || jpegQual > 100)
+    THROW("tjCompress2(): Invalid argument");
+
+  if (pitch == 0) pitch = width * tjPixelSize[pixelFormat];
+
+  if ((row_pointer = (JSAMPROW *)malloc(sizeof(JSAMPROW) * height)) == NULL)
+    THROW("tjCompress2(): Memory allocation failure");
+
+  if (setjmp(this->jerr.setjmp_buffer)) {
+    /* If we get here, the JPEG code has signaled an error. */
+    retval = -1;  goto bailout;
+  }
+
+  cinfo->image_width = width;
+  cinfo->image_height = height;
+
+#ifndef NO_PUTENV
+  if (flags & TJFLAG_FORCEMMX) putenv("JSIMD_FORCEMMX=1");
+  else if (flags & TJFLAG_FORCESSE) putenv("JSIMD_FORCESSE=1");
+  else if (flags & TJFLAG_FORCESSE2) putenv("JSIMD_FORCESSE2=1");
+#endif
+
+  if (flags & TJFLAG_NOREALLOC) {
+    alloc = 0;  *jpegSize = tjBufSize(width, height, jpegSubsamp);
+  }
+  jpeg_mem_dest_tj(cinfo, jpegBuf, jpegSize, alloc);
+  setCompDefaults(cinfo, pixelFormat, jpegSubsamp, jpegQual, flags);
+
+  jpeg_start_compress(cinfo, TRUE);
+  for (i = 0; i < height; i++) {
+    if (flags & TJFLAG_BOTTOMUP)
+      row_pointer[i] = (JSAMPROW)&srcBuf[(height - i - 1) * (size_t)pitch];
+    else
+      row_pointer[i] = (JSAMPROW)&srcBuf[i * (size_t)pitch];
+  }
+  while (cinfo->next_scanline < cinfo->image_height)
+    jpeg_write_scanlines(cinfo, &row_pointer[cinfo->next_scanline],
+                         cinfo->image_height - cinfo->next_scanline);
+  jpeg_finish_compress(cinfo);
+
+bailout:
+  if (cinfo->global_state > CSTATE_START) jpeg_abort_compress(cinfo);
+  free(row_pointer);
+  if (this->jerr.warning) retval = -1;
+  this->jerr.stopOnWarning = FALSE;
+  return retval;
+}
+
+DLLEXPORT int tjCompress(tjhandle handle, unsigned char *srcBuf, int width,
+                         int pitch, int height, int pixelSize,
+                         unsigned char *jpegBuf, unsigned long *jpegSize,
+                         int jpegSubsamp, int jpegQual, int flags)
+{
+  int retval = 0;
+  unsigned long size;
+
+  if (flags & TJ_YUV) {
+    size = tjBufSizeYUV(width, height, jpegSubsamp);
+    retval = tjEncodeYUV2(handle, srcBuf, width, pitch, height,
+                          getPixelFormat(pixelSize, flags), jpegBuf,
+                          jpegSubsamp, flags);
+  } else {
+    retval = tjCompress2(handle, srcBuf, width, pitch, height,
+                         getPixelFormat(pixelSize, flags), &jpegBuf, &size,
+                         jpegSubsamp, jpegQual, flags | TJFLAG_NOREALLOC);
+  }
+  *jpegSize = size;
+  return retval;
+}
+
+
+DLLEXPORT int tjEncodeYUVPlanes(tjhandle handle, const unsigned char *srcBuf,
+                                int width, int pitch, int height,
+                                int pixelFormat, unsigned char **dstPlanes,
+                                int *strides, int subsamp, int flags)
+{
+  JSAMPROW *row_pointer = NULL;
+  JSAMPLE *_tmpbuf[MAX_COMPONENTS], *_tmpbuf2[MAX_COMPONENTS];
+  JSAMPROW *tmpbuf[MAX_COMPONENTS], *tmpbuf2[MAX_COMPONENTS];
+  JSAMPROW *outbuf[MAX_COMPONENTS];
+  int i, retval = 0, row, pw0, ph0, pw[MAX_COMPONENTS], ph[MAX_COMPONENTS];
+  JSAMPLE *ptr;
+  jpeg_component_info *compptr;
+
+  GET_CINSTANCE(handle);
+  this->jerr.stopOnWarning = (flags & TJFLAG_STOPONWARNING) ? TRUE : FALSE;
+
+  for (i = 0; i < MAX_COMPONENTS; i++) {
+    tmpbuf[i] = NULL;  _tmpbuf[i] = NULL;
+    tmpbuf2[i] = NULL;  _tmpbuf2[i] = NULL;  outbuf[i] = NULL;
+  }
+
+  if ((this->init & COMPRESS) == 0)
+    THROW("tjEncodeYUVPlanes(): Instance has not been initialized for compression");
+
+  if (srcBuf == NULL || width <= 0 || pitch < 0 || height <= 0 ||
+      pixelFormat < 0 || pixelFormat >= TJ_NUMPF || !dstPlanes ||
+      !dstPlanes[0] || subsamp < 0 || subsamp >= NUMSUBOPT)
+    THROW("tjEncodeYUVPlanes(): Invalid argument");
+  if (subsamp != TJSAMP_GRAY && (!dstPlanes[1] || !dstPlanes[2]))
+    THROW("tjEncodeYUVPlanes(): Invalid argument");
+
+  if (pixelFormat == TJPF_CMYK)
+    THROW("tjEncodeYUVPlanes(): Cannot generate YUV images from CMYK pixels");
+
+  if (pitch == 0) pitch = width * tjPixelSize[pixelFormat];
+
+  if (setjmp(this->jerr.setjmp_buffer)) {
+    /* If we get here, the JPEG code has signaled an error. */
+    retval = -1;  goto bailout;
+  }
+
+  cinfo->image_width = width;
+  cinfo->image_height = height;
+
+#ifndef NO_PUTENV
+  if (flags & TJFLAG_FORCEMMX) putenv("JSIMD_FORCEMMX=1");
+  else if (flags & TJFLAG_FORCESSE) putenv("JSIMD_FORCESSE=1");
+  else if (flags & TJFLAG_FORCESSE2) putenv("JSIMD_FORCESSE2=1");
+#endif
+
+  setCompDefaults(cinfo, pixelFormat, subsamp, -1, flags);
+
+  /* Execute only the parts of jpeg_start_compress() that we need.  If we
+     were to call the whole jpeg_start_compress() function, then it would try
+     to write the file headers, which could overflow the output buffer if the
+     YUV image were very small. */
+  if (cinfo->global_state != CSTATE_START)
+    THROW("tjEncodeYUVPlanes(): libjpeg API is in the wrong state");
+  (*cinfo->err->reset_error_mgr) ((j_common_ptr)cinfo);
+  jinit_c_master_control(cinfo, FALSE);
+  jinit_color_converter(cinfo);
+  jinit_downsampler(cinfo);
+  (*cinfo->cconvert->start_pass) (cinfo);
+
+  pw0 = PAD(width, cinfo->max_h_samp_factor);
+  ph0 = PAD(height, cinfo->max_v_samp_factor);
+
+  if ((row_pointer = (JSAMPROW *)malloc(sizeof(JSAMPROW) * ph0)) == NULL)
+    THROW("tjEncodeYUVPlanes(): Memory allocation failure");
+  for (i = 0; i < height; i++) {
+    if (flags & TJFLAG_BOTTOMUP)
+      row_pointer[i] = (JSAMPROW)&srcBuf[(height - i - 1) * (size_t)pitch];
+    else
+      row_pointer[i] = (JSAMPROW)&srcBuf[i * (size_t)pitch];
+  }
+  if (height < ph0)
+    for (i = height; i < ph0; i++) row_pointer[i] = row_pointer[height - 1];
+
+  for (i = 0; i < cinfo->num_components; i++) {
+    compptr = &cinfo->comp_info[i];
+    _tmpbuf[i] = (JSAMPLE *)malloc(
+      PAD((compptr->width_in_blocks * cinfo->max_h_samp_factor * DCTSIZE) /
+          compptr->h_samp_factor, 32) *
+      cinfo->max_v_samp_factor + 32);
+    if (!_tmpbuf[i])
+      THROW("tjEncodeYUVPlanes(): Memory allocation failure");
+    tmpbuf[i] =
+      (JSAMPROW *)malloc(sizeof(JSAMPROW) * cinfo->max_v_samp_factor);
+    if (!tmpbuf[i])
+      THROW("tjEncodeYUVPlanes(): Memory allocation failure");
+    for (row = 0; row < cinfo->max_v_samp_factor; row++) {
+      unsigned char *_tmpbuf_aligned =
+        (unsigned char *)PAD((size_t)_tmpbuf[i], 32);
+
+      tmpbuf[i][row] = &_tmpbuf_aligned[
+        PAD((compptr->width_in_blocks * cinfo->max_h_samp_factor * DCTSIZE) /
+            compptr->h_samp_factor, 32) * row];
+    }
+    _tmpbuf2[i] =
+      (JSAMPLE *)malloc(PAD(compptr->width_in_blocks * DCTSIZE, 32) *
+                        compptr->v_samp_factor + 32);
+    if (!_tmpbuf2[i])
+      THROW("tjEncodeYUVPlanes(): Memory allocation failure");
+    tmpbuf2[i] = (JSAMPROW *)malloc(sizeof(JSAMPROW) * compptr->v_samp_factor);
+    if (!tmpbuf2[i])
+      THROW("tjEncodeYUVPlanes(): Memory allocation failure");
+    for (row = 0; row < compptr->v_samp_factor; row++) {
+      unsigned char *_tmpbuf2_aligned =
+        (unsigned char *)PAD((size_t)_tmpbuf2[i], 32);
+
+      tmpbuf2[i][row] =
+        &_tmpbuf2_aligned[PAD(compptr->width_in_blocks * DCTSIZE, 32) * row];
+    }
+    pw[i] = pw0 * compptr->h_samp_factor / cinfo->max_h_samp_factor;
+    ph[i] = ph0 * compptr->v_samp_factor / cinfo->max_v_samp_factor;
+    outbuf[i] = (JSAMPROW *)malloc(sizeof(JSAMPROW) * ph[i]);
+    if (!outbuf[i])
+      THROW("tjEncodeYUVPlanes(): Memory allocation failure");
+    ptr = dstPlanes[i];
+    for (row = 0; row < ph[i]; row++) {
+      outbuf[i][row] = ptr;
+      ptr += (strides && strides[i] != 0) ? strides[i] : pw[i];
+    }
+  }
+
+  if (setjmp(this->jerr.setjmp_buffer)) {
+    /* If we get here, the JPEG code has signaled an error. */
+    retval = -1;  goto bailout;
+  }
+
+  for (row = 0; row < ph0; row += cinfo->max_v_samp_factor) {
+    (*cinfo->cconvert->color_convert) (cinfo, &row_pointer[row], tmpbuf, 0,
+                                       cinfo->max_v_samp_factor);
+    (cinfo->downsample->downsample) (cinfo, tmpbuf, 0, tmpbuf2, 0);
+    for (i = 0, compptr = cinfo->comp_info; i < cinfo->num_components;
+         i++, compptr++)
+      jcopy_sample_rows(tmpbuf2[i], 0, outbuf[i],
+        row * compptr->v_samp_factor / cinfo->max_v_samp_factor,
+        compptr->v_samp_factor, pw[i]);
+  }
+  cinfo->next_scanline += height;
+  jpeg_abort_compress(cinfo);
+
+bailout:
+  if (cinfo->global_state > CSTATE_START) jpeg_abort_compress(cinfo);
+  free(row_pointer);
+  for (i = 0; i < MAX_COMPONENTS; i++) {
+    free(tmpbuf[i]);
+    free(_tmpbuf[i]);
+    free(tmpbuf2[i]);
+    free(_tmpbuf2[i]);
+    free(outbuf[i]);
+  }
+  if (this->jerr.warning) retval = -1;
+  this->jerr.stopOnWarning = FALSE;
+  return retval;
+}
+
+DLLEXPORT int tjEncodeYUV3(tjhandle handle, const unsigned char *srcBuf,
+                           int width, int pitch, int height, int pixelFormat,
+                           unsigned char *dstBuf, int pad, int subsamp,
+                           int flags)
+{
+  unsigned char *dstPlanes[3];
+  int pw0, ph0, strides[3], retval = -1;
+  tjinstance *this = (tjinstance *)handle;
+
+  if (!this) THROWG("tjEncodeYUV3(): Invalid handle");
+  this->isInstanceError = FALSE;
+
+  if (width <= 0 || height <= 0 || dstBuf == NULL || pad < 0 ||
+      !IS_POW2(pad) || subsamp < 0 || subsamp >= NUMSUBOPT)
+    THROW("tjEncodeYUV3(): Invalid argument");
+
+  pw0 = tjPlaneWidth(0, width, subsamp);
+  ph0 = tjPlaneHeight(0, height, subsamp);
+  dstPlanes[0] = dstBuf;
+  strides[0] = PAD(pw0, pad);
+  if (subsamp == TJSAMP_GRAY) {
+    strides[1] = strides[2] = 0;
+    dstPlanes[1] = dstPlanes[2] = NULL;
+  } else {
+    int pw1 = tjPlaneWidth(1, width, subsamp);
+    int ph1 = tjPlaneHeight(1, height, subsamp);
+
+    strides[1] = strides[2] = PAD(pw1, pad);
+    dstPlanes[1] = dstPlanes[0] + strides[0] * ph0;
+    dstPlanes[2] = dstPlanes[1] + strides[1] * ph1;
+  }
+
+  return tjEncodeYUVPlanes(handle, srcBuf, width, pitch, height, pixelFormat,
+                           dstPlanes, strides, subsamp, flags);
+
+bailout:
+  return retval;
+}
+
+DLLEXPORT int tjEncodeYUV2(tjhandle handle, unsigned char *srcBuf, int width,
+                           int pitch, int height, int pixelFormat,
+                           unsigned char *dstBuf, int subsamp, int flags)
+{
+  return tjEncodeYUV3(handle, srcBuf, width, pitch, height, pixelFormat,
+                      dstBuf, 4, subsamp, flags);
+}
+
+DLLEXPORT int tjEncodeYUV(tjhandle handle, unsigned char *srcBuf, int width,
+                          int pitch, int height, int pixelSize,
+                          unsigned char *dstBuf, int subsamp, int flags)
+{
+  return tjEncodeYUV2(handle, srcBuf, width, pitch, height,
+                      getPixelFormat(pixelSize, flags), dstBuf, subsamp,
+                      flags);
+}
+
+
+DLLEXPORT int tjCompressFromYUVPlanes(tjhandle handle,
+                                      const unsigned char **srcPlanes,
+                                      int width, const int *strides,
+                                      int height, int subsamp,
+                                      unsigned char **jpegBuf,
+                                      unsigned long *jpegSize, int jpegQual,
+                                      int flags)
+{
+  int i, row, retval = 0, alloc = 1;
+  int pw[MAX_COMPONENTS], ph[MAX_COMPONENTS], iw[MAX_COMPONENTS],
+    tmpbufsize = 0, usetmpbuf = 0, th[MAX_COMPONENTS];
+  JSAMPLE *_tmpbuf = NULL, *ptr;
+  JSAMPROW *inbuf[MAX_COMPONENTS], *tmpbuf[MAX_COMPONENTS];
+
+  GET_CINSTANCE(handle)
+  this->jerr.stopOnWarning = (flags & TJFLAG_STOPONWARNING) ? TRUE : FALSE;
+
+  for (i = 0; i < MAX_COMPONENTS; i++) {
+    tmpbuf[i] = NULL;  inbuf[i] = NULL;
+  }
+
+  if ((this->init & COMPRESS) == 0)
+    THROW("tjCompressFromYUVPlanes(): Instance has not been initialized for compression");
+
+  if (!srcPlanes || !srcPlanes[0] || width <= 0 || height <= 0 ||
+      subsamp < 0 || subsamp >= NUMSUBOPT || jpegBuf == NULL ||
+      jpegSize == NULL || jpegQual < 0 || jpegQual > 100)
+    THROW("tjCompressFromYUVPlanes(): Invalid argument");
+  if (subsamp != TJSAMP_GRAY && (!srcPlanes[1] || !srcPlanes[2]))
+    THROW("tjCompressFromYUVPlanes(): Invalid argument");
+
+  if (setjmp(this->jerr.setjmp_buffer)) {
+    /* If we get here, the JPEG code has signaled an error. */
+    retval = -1;  goto bailout;
+  }
+
+  cinfo->image_width = width;
+  cinfo->image_height = height;
+
+#ifndef NO_PUTENV
+  if (flags & TJFLAG_FORCEMMX) putenv("JSIMD_FORCEMMX=1");
+  else if (flags & TJFLAG_FORCESSE) putenv("JSIMD_FORCESSE=1");
+  else if (flags & TJFLAG_FORCESSE2) putenv("JSIMD_FORCESSE2=1");
+#endif
+
+  if (flags & TJFLAG_NOREALLOC) {
+    alloc = 0;  *jpegSize = tjBufSize(width, height, subsamp);
+  }
+  jpeg_mem_dest_tj(cinfo, jpegBuf, jpegSize, alloc);
+  setCompDefaults(cinfo, TJPF_RGB, subsamp, jpegQual, flags);
+  cinfo->raw_data_in = TRUE;
+
+  jpeg_start_compress(cinfo, TRUE);
+  for (i = 0; i < cinfo->num_components; i++) {
+    jpeg_component_info *compptr = &cinfo->comp_info[i];
+    int ih;
+
+    iw[i] = compptr->width_in_blocks * DCTSIZE;
+    ih = compptr->height_in_blocks * DCTSIZE;
+    pw[i] = PAD(cinfo->image_width, cinfo->max_h_samp_factor) *
+            compptr->h_samp_factor / cinfo->max_h_samp_factor;
+    ph[i] = PAD(cinfo->image_height, cinfo->max_v_samp_factor) *
+            compptr->v_samp_factor / cinfo->max_v_samp_factor;
+    if (iw[i] != pw[i] || ih != ph[i]) usetmpbuf = 1;
+    th[i] = compptr->v_samp_factor * DCTSIZE;
+    tmpbufsize += iw[i] * th[i];
+    if ((inbuf[i] = (JSAMPROW *)malloc(sizeof(JSAMPROW) * ph[i])) == NULL)
+      THROW("tjCompressFromYUVPlanes(): Memory allocation failure");
+    ptr = (JSAMPLE *)srcPlanes[i];
+    for (row = 0; row < ph[i]; row++) {
+      inbuf[i][row] = ptr;
+      ptr += (strides && strides[i] != 0) ? strides[i] : pw[i];
+    }
+  }
+  if (usetmpbuf) {
+    if ((_tmpbuf = (JSAMPLE *)malloc(sizeof(JSAMPLE) * tmpbufsize)) == NULL)
+      THROW("tjCompressFromYUVPlanes(): Memory allocation failure");
+    ptr = _tmpbuf;
+    for (i = 0; i < cinfo->num_components; i++) {
+      if ((tmpbuf[i] = (JSAMPROW *)malloc(sizeof(JSAMPROW) * th[i])) == NULL)
+        THROW("tjCompressFromYUVPlanes(): Memory allocation failure");
+      for (row = 0; row < th[i]; row++) {
+        tmpbuf[i][row] = ptr;
+        ptr += iw[i];
+      }
+    }
+  }
+
+  if (setjmp(this->jerr.setjmp_buffer)) {
+    /* If we get here, the JPEG code has signaled an error. */
+    retval = -1;  goto bailout;
+  }
+
+  for (row = 0; row < (int)cinfo->image_height;
+       row += cinfo->max_v_samp_factor * DCTSIZE) {
+    JSAMPARRAY yuvptr[MAX_COMPONENTS];
+    int crow[MAX_COMPONENTS];
+
+    for (i = 0; i < cinfo->num_components; i++) {
+      jpeg_component_info *compptr = &cinfo->comp_info[i];
+
+      crow[i] = row * compptr->v_samp_factor / cinfo->max_v_samp_factor;
+      if (usetmpbuf) {
+        int j, k;
+
+        for (j = 0; j < MIN(th[i], ph[i] - crow[i]); j++) {
+          memcpy(tmpbuf[i][j], inbuf[i][crow[i] + j], pw[i]);
+          /* Duplicate last sample in row to fill out MCU */
+          for (k = pw[i]; k < iw[i]; k++)
+            tmpbuf[i][j][k] = tmpbuf[i][j][pw[i] - 1];
+        }
+        /* Duplicate last row to fill out MCU */
+        for (j = ph[i] - crow[i]; j < th[i]; j++)
+          memcpy(tmpbuf[i][j], tmpbuf[i][ph[i] - crow[i] - 1], iw[i]);
+        yuvptr[i] = tmpbuf[i];
+      } else
+        yuvptr[i] = &inbuf[i][crow[i]];
+    }
+    jpeg_write_raw_data(cinfo, yuvptr, cinfo->max_v_samp_factor * DCTSIZE);
+  }
+  jpeg_finish_compress(cinfo);
+
+bailout:
+  if (cinfo->global_state > CSTATE_START) jpeg_abort_compress(cinfo);
+  for (i = 0; i < MAX_COMPONENTS; i++) {
+    free(tmpbuf[i]);
+    free(inbuf[i]);
+  }
+  free(_tmpbuf);
+  if (this->jerr.warning) retval = -1;
+  this->jerr.stopOnWarning = FALSE;
+  return retval;
+}
+
+DLLEXPORT int tjCompressFromYUV(tjhandle handle, const unsigned char *srcBuf,
+                                int width, int pad, int height, int subsamp,
+                                unsigned char **jpegBuf,
+                                unsigned long *jpegSize, int jpegQual,
+                                int flags)
+{
+  const unsigned char *srcPlanes[3];
+  int pw0, ph0, strides[3], retval = -1;
+  tjinstance *this = (tjinstance *)handle;
+
+  if (!this) THROWG("tjCompressFromYUV(): Invalid handle");
+  this->isInstanceError = FALSE;
+
+  if (srcBuf == NULL || width <= 0 || pad < 1 || height <= 0 || subsamp < 0 ||
+      subsamp >= NUMSUBOPT)
+    THROW("tjCompressFromYUV(): Invalid argument");
+
+  pw0 = tjPlaneWidth(0, width, subsamp);
+  ph0 = tjPlaneHeight(0, height, subsamp);
+  srcPlanes[0] = srcBuf;
+  strides[0] = PAD(pw0, pad);
+  if (subsamp == TJSAMP_GRAY) {
+    strides[1] = strides[2] = 0;
+    srcPlanes[1] = srcPlanes[2] = NULL;
+  } else {
+    int pw1 = tjPlaneWidth(1, width, subsamp);
+    int ph1 = tjPlaneHeight(1, height, subsamp);
+
+    strides[1] = strides[2] = PAD(pw1, pad);
+    srcPlanes[1] = srcPlanes[0] + strides[0] * ph0;
+    srcPlanes[2] = srcPlanes[1] + strides[1] * ph1;
+  }
+
+  return tjCompressFromYUVPlanes(handle, srcPlanes, width, strides, height,
+                                 subsamp, jpegBuf, jpegSize, jpegQual, flags);
+
+bailout:
+  return retval;
+}
+
+
+/* Decompressor */
+
+static tjhandle _tjInitDecompress(tjinstance *this)
+{
+  static unsigned char buffer[1];
+
+  /* This is also straight out of example.txt */
+  this->dinfo.err = jpeg_std_error(&this->jerr.pub);
+  this->jerr.pub.error_exit = my_error_exit;
+  this->jerr.pub.output_message = my_output_message;
+  this->jerr.emit_message = this->jerr.pub.emit_message;
+  this->jerr.pub.emit_message = my_emit_message;
+  this->jerr.pub.addon_message_table = turbojpeg_message_table;
+  this->jerr.pub.first_addon_message = JMSG_FIRSTADDONCODE;
+  this->jerr.pub.last_addon_message = JMSG_LASTADDONCODE;
+
+  if (setjmp(this->jerr.setjmp_buffer)) {
+    /* If we get here, the JPEG code has signaled an error. */
+    free(this);
+    return NULL;
+  }
+
+  jpeg_create_decompress(&this->dinfo);
+  /* Make an initial call so it will create the source manager */
+  jpeg_mem_src_tj(&this->dinfo, buffer, 1);
+
+  this->init |= DECOMPRESS;
+  return (tjhandle)this;
+}
+
+DLLEXPORT tjhandle tjInitDecompress(void)
+{
+  tjinstance *this;
+
+  if ((this = (tjinstance *)malloc(sizeof(tjinstance))) == NULL) {
+    snprintf(errStr, JMSG_LENGTH_MAX,
+             "tjInitDecompress(): Memory allocation failure");
+    return NULL;
+  }
+  MEMZERO(this, sizeof(tjinstance));
+  snprintf(this->errStr, JMSG_LENGTH_MAX, "No error");
+  return _tjInitDecompress(this);
+}
+
+
+DLLEXPORT int tjDecompressHeader3(tjhandle handle,
+                                  const unsigned char *jpegBuf,
+                                  unsigned long jpegSize, int *width,
+                                  int *height, int *jpegSubsamp,
+                                  int *jpegColorspace)
+{
+  int retval = 0;
+
+  GET_DINSTANCE(handle);
+  if ((this->init & DECOMPRESS) == 0)
+    THROW("tjDecompressHeader3(): Instance has not been initialized for decompression");
+
+  if (jpegBuf == NULL || jpegSize <= 0 || width == NULL || height == NULL ||
+      jpegSubsamp == NULL || jpegColorspace == NULL)
+    THROW("tjDecompressHeader3(): Invalid argument");
+
+  if (setjmp(this->jerr.setjmp_buffer)) {
+    /* If we get here, the JPEG code has signaled an error. */
+    return -1;
+  }
+
+  jpeg_mem_src_tj(dinfo, jpegBuf, jpegSize);
+  jpeg_read_header(dinfo, TRUE);
+
+  *width = dinfo->image_width;
+  *height = dinfo->image_height;
+  *jpegSubsamp = getSubsamp(dinfo);
+  switch (dinfo->jpeg_color_space) {
+  case JCS_GRAYSCALE:  *jpegColorspace = TJCS_GRAY;  break;
+  case JCS_RGB:        *jpegColorspace = TJCS_RGB;  break;
+  case JCS_YCbCr:      *jpegColorspace = TJCS_YCbCr;  break;
+  case JCS_CMYK:       *jpegColorspace = TJCS_CMYK;  break;
+  case JCS_YCCK:       *jpegColorspace = TJCS_YCCK;  break;
+  default:             *jpegColorspace = -1;  break;
+  }
+
+  jpeg_abort_decompress(dinfo);
+
+  if (*jpegSubsamp < 0)
+    THROW("tjDecompressHeader3(): Could not determine subsampling type for JPEG image");
+  if (*jpegColorspace < 0)
+    THROW("tjDecompressHeader3(): Could not determine colorspace of JPEG image");
+  if (*width < 1 || *height < 1)
+    THROW("tjDecompressHeader3(): Invalid data returned in header");
+
+bailout:
+  if (this->jerr.warning) retval = -1;
+  return retval;
+}
+
+DLLEXPORT int tjDecompressHeader2(tjhandle handle, unsigned char *jpegBuf,
+                                  unsigned long jpegSize, int *width,
+                                  int *height, int *jpegSubsamp)
+{
+  int jpegColorspace;
+
+  return tjDecompressHeader3(handle, jpegBuf, jpegSize, width, height,
+                             jpegSubsamp, &jpegColorspace);
+}
+
+DLLEXPORT int tjDecompressHeader(tjhandle handle, unsigned char *jpegBuf,
+                                 unsigned long jpegSize, int *width,
+                                 int *height)
+{
+  int jpegSubsamp;
+
+  return tjDecompressHeader2(handle, jpegBuf, jpegSize, width, height,
+                             &jpegSubsamp);
+}
+
+
+DLLEXPORT tjscalingfactor *tjGetScalingFactors(int *numscalingfactors)
+{
+  if (numscalingfactors == NULL) {
+    snprintf(errStr, JMSG_LENGTH_MAX,
+             "tjGetScalingFactors(): Invalid argument");
+    return NULL;
+  }
+
+  *numscalingfactors = NUMSF;
+  return (tjscalingfactor *)sf;
+}
+
+
+DLLEXPORT int tjDecompress2(tjhandle handle, const unsigned char *jpegBuf,
+                            unsigned long jpegSize, unsigned char *dstBuf,
+                            int width, int pitch, int height, int pixelFormat,
+                            int flags)
+{
+  JSAMPROW *row_pointer = NULL;
+  int i, retval = 0, jpegwidth, jpegheight, scaledw, scaledh;
+
+  GET_DINSTANCE(handle);
+  this->jerr.stopOnWarning = (flags & TJFLAG_STOPONWARNING) ? TRUE : FALSE;
+  if ((this->init & DECOMPRESS) == 0)
+    THROW("tjDecompress2(): Instance has not been initialized for decompression");
+
+  if (jpegBuf == NULL || jpegSize <= 0 || dstBuf == NULL || width < 0 ||
+      pitch < 0 || height < 0 || pixelFormat < 0 || pixelFormat >= TJ_NUMPF)
+    THROW("tjDecompress2(): Invalid argument");
+
+#ifndef NO_PUTENV
+  if (flags & TJFLAG_FORCEMMX) putenv("JSIMD_FORCEMMX=1");
+  else if (flags & TJFLAG_FORCESSE) putenv("JSIMD_FORCESSE=1");
+  else if (flags & TJFLAG_FORCESSE2) putenv("JSIMD_FORCESSE2=1");
+#endif
+
+  if (setjmp(this->jerr.setjmp_buffer)) {
+    /* If we get here, the JPEG code has signaled an error. */
+    retval = -1;  goto bailout;
+  }
+
+  jpeg_mem_src_tj(dinfo, jpegBuf, jpegSize);
+  jpeg_read_header(dinfo, TRUE);
+  this->dinfo.out_color_space = pf2cs[pixelFormat];
+  if (flags & TJFLAG_FASTDCT) this->dinfo.dct_method = JDCT_FASTEST;
+  if (flags & TJFLAG_FASTUPSAMPLE) dinfo->do_fancy_upsampling = FALSE;
+
+  jpegwidth = dinfo->image_width;  jpegheight = dinfo->image_height;
+  if (width == 0) width = jpegwidth;
+  if (height == 0) height = jpegheight;
+  for (i = 0; i < NUMSF; i++) {
+    scaledw = TJSCALED(jpegwidth, sf[i]);
+    scaledh = TJSCALED(jpegheight, sf[i]);
+    if (scaledw <= width && scaledh <= height)
+      break;
+  }
+  if (i >= NUMSF)
+    THROW("tjDecompress2(): Could not scale down to desired image dimensions");
+  width = scaledw;  height = scaledh;
+  dinfo->scale_num = sf[i].num;
+  dinfo->scale_denom = sf[i].denom;
+
+  jpeg_start_decompress(dinfo);
+  if (pitch == 0) pitch = dinfo->output_width * tjPixelSize[pixelFormat];
+
+  if ((row_pointer =
+       (JSAMPROW *)malloc(sizeof(JSAMPROW) * dinfo->output_height)) == NULL)
+    THROW("tjDecompress2(): Memory allocation failure");
+  if (setjmp(this->jerr.setjmp_buffer)) {
+    /* If we get here, the JPEG code has signaled an error. */
+    retval = -1;  goto bailout;
+  }
+  for (i = 0; i < (int)dinfo->output_height; i++) {
+    if (flags & TJFLAG_BOTTOMUP)
+      row_pointer[i] = &dstBuf[(dinfo->output_height - i - 1) * (size_t)pitch];
+    else
+      row_pointer[i] = &dstBuf[i * (size_t)pitch];
+  }
+  while (dinfo->output_scanline < dinfo->output_height)
+    jpeg_read_scanlines(dinfo, &row_pointer[dinfo->output_scanline],
+                        dinfo->output_height - dinfo->output_scanline);
+  jpeg_finish_decompress(dinfo);
+
+bailout:
+  if (dinfo->global_state > DSTATE_START) jpeg_abort_decompress(dinfo);
+  free(row_pointer);
+  if (this->jerr.warning) retval = -1;
+  this->jerr.stopOnWarning = FALSE;
+  return retval;
+}
+
+DLLEXPORT int tjDecompress(tjhandle handle, unsigned char *jpegBuf,
+                           unsigned long jpegSize, unsigned char *dstBuf,
+                           int width, int pitch, int height, int pixelSize,
+                           int flags)
+{
+  if (flags & TJ_YUV)
+    return tjDecompressToYUV(handle, jpegBuf, jpegSize, dstBuf, flags);
+  else
+    return tjDecompress2(handle, jpegBuf, jpegSize, dstBuf, width, pitch,
+                         height, getPixelFormat(pixelSize, flags), flags);
+}
+
+
+static int setDecodeDefaults(struct jpeg_decompress_struct *dinfo,
+                             int pixelFormat, int subsamp, int flags)
+{
+  int i;
+
+  dinfo->scale_num = dinfo->scale_denom = 1;
+
+  if (subsamp == TJSAMP_GRAY) {
+    dinfo->num_components = dinfo->comps_in_scan = 1;
+    dinfo->jpeg_color_space = JCS_GRAYSCALE;
+  } else {
+    dinfo->num_components = dinfo->comps_in_scan = 3;
+    dinfo->jpeg_color_space = JCS_YCbCr;
+  }
+
+  dinfo->comp_info = (jpeg_component_info *)
+    (*dinfo->mem->alloc_small) ((j_common_ptr)dinfo, JPOOL_IMAGE,
+                                dinfo->num_components *
+                                sizeof(jpeg_component_info));
+
+  for (i = 0; i < dinfo->num_components; i++) {
+    jpeg_component_info *compptr = &dinfo->comp_info[i];
+
+    compptr->h_samp_factor = (i == 0) ? tjMCUWidth[subsamp] / 8 : 1;
+    compptr->v_samp_factor = (i == 0) ? tjMCUHeight[subsamp] / 8 : 1;
+    compptr->component_index = i;
+    compptr->component_id = i + 1;
+    compptr->quant_tbl_no = compptr->dc_tbl_no =
+      compptr->ac_tbl_no = (i == 0) ? 0 : 1;
+    dinfo->cur_comp_info[i] = compptr;
+  }
+  dinfo->data_precision = 8;
+  for (i = 0; i < 2; i++) {
+    if (dinfo->quant_tbl_ptrs[i] == NULL)
+      dinfo->quant_tbl_ptrs[i] = jpeg_alloc_quant_table((j_common_ptr)dinfo);
+  }
+
+  return 0;
+}
+
+
+static int my_read_markers(j_decompress_ptr dinfo)
+{
+  return JPEG_REACHED_SOS;
+}
+
+static void my_reset_marker_reader(j_decompress_ptr dinfo)
+{
+}
+
+DLLEXPORT int tjDecodeYUVPlanes(tjhandle handle,
+                                const unsigned char **srcPlanes,
+                                const int *strides, int subsamp,
+                                unsigned char *dstBuf, int width, int pitch,
+                                int height, int pixelFormat, int flags)
+{
+  JSAMPROW *row_pointer = NULL;
+  JSAMPLE *_tmpbuf[MAX_COMPONENTS];
+  JSAMPROW *tmpbuf[MAX_COMPONENTS], *inbuf[MAX_COMPONENTS];
+  int i, retval = 0, row, pw0, ph0, pw[MAX_COMPONENTS], ph[MAX_COMPONENTS];
+  JSAMPLE *ptr;
+  jpeg_component_info *compptr;
+  int (*old_read_markers) (j_decompress_ptr);
+  void (*old_reset_marker_reader) (j_decompress_ptr);
+
+  GET_DINSTANCE(handle);
+  this->jerr.stopOnWarning = (flags & TJFLAG_STOPONWARNING) ? TRUE : FALSE;
+
+  for (i = 0; i < MAX_COMPONENTS; i++) {
+    tmpbuf[i] = NULL;  _tmpbuf[i] = NULL;  inbuf[i] = NULL;
+  }
+
+  if ((this->init & DECOMPRESS) == 0)
+    THROW("tjDecodeYUVPlanes(): Instance has not been initialized for decompression");
+
+  if (!srcPlanes || !srcPlanes[0] || subsamp < 0 || subsamp >= NUMSUBOPT ||
+      dstBuf == NULL || width <= 0 || pitch < 0 || height <= 0 ||
+      pixelFormat < 0 || pixelFormat >= TJ_NUMPF)
+    THROW("tjDecodeYUVPlanes(): Invalid argument");
+  if (subsamp != TJSAMP_GRAY && (!srcPlanes[1] || !srcPlanes[2]))
+    THROW("tjDecodeYUVPlanes(): Invalid argument");
+
+  if (setjmp(this->jerr.setjmp_buffer)) {
+    /* If we get here, the JPEG code has signaled an error. */
+    retval = -1;  goto bailout;
+  }
+
+  if (pixelFormat == TJPF_CMYK)
+    THROW("tjDecodeYUVPlanes(): Cannot decode YUV images into CMYK pixels.");
+
+  if (pitch == 0) pitch = width * tjPixelSize[pixelFormat];
+  dinfo->image_width = width;
+  dinfo->image_height = height;
+
+#ifndef NO_PUTENV
+  if (flags & TJFLAG_FORCEMMX) putenv("JSIMD_FORCEMMX=1");
+  else if (flags & TJFLAG_FORCESSE) putenv("JSIMD_FORCESSE=1");
+  else if (flags & TJFLAG_FORCESSE2) putenv("JSIMD_FORCESSE2=1");
+#endif
+
+  dinfo->progressive_mode = dinfo->inputctl->has_multiple_scans = FALSE;
+  dinfo->Ss = dinfo->Ah = dinfo->Al = 0;
+  dinfo->Se = DCTSIZE2 - 1;
+  if (setDecodeDefaults(dinfo, pixelFormat, subsamp, flags) == -1) {
+    retval = -1;  goto bailout;
+  }
+  old_read_markers = dinfo->marker->read_markers;
+  dinfo->marker->read_markers = my_read_markers;
+  old_reset_marker_reader = dinfo->marker->reset_marker_reader;
+  dinfo->marker->reset_marker_reader = my_reset_marker_reader;
+  jpeg_read_header(dinfo, TRUE);
+  dinfo->marker->read_markers = old_read_markers;
+  dinfo->marker->reset_marker_reader = old_reset_marker_reader;
+
+  this->dinfo.out_color_space = pf2cs[pixelFormat];
+  if (flags & TJFLAG_FASTDCT) this->dinfo.dct_method = JDCT_FASTEST;
+  dinfo->do_fancy_upsampling = FALSE;
+  dinfo->Se = DCTSIZE2 - 1;
+  jinit_master_decompress(dinfo);
+  (*dinfo->upsample->start_pass) (dinfo);
+
+  pw0 = PAD(width, dinfo->max_h_samp_factor);
+  ph0 = PAD(height, dinfo->max_v_samp_factor);
+
+  if (pitch == 0) pitch = dinfo->output_width * tjPixelSize[pixelFormat];
+
+  if ((row_pointer = (JSAMPROW *)malloc(sizeof(JSAMPROW) * ph0)) == NULL)
+    THROW("tjDecodeYUVPlanes(): Memory allocation failure");
+  for (i = 0; i < height; i++) {
+    if (flags & TJFLAG_BOTTOMUP)
+      row_pointer[i] = &dstBuf[(height - i - 1) * (size_t)pitch];
+    else
+      row_pointer[i] = &dstBuf[i * (size_t)pitch];
+  }
+  if (height < ph0)
+    for (i = height; i < ph0; i++) row_pointer[i] = row_pointer[height - 1];
+
+  for (i = 0; i < dinfo->num_components; i++) {
+    compptr = &dinfo->comp_info[i];
+    _tmpbuf[i] =
+      (JSAMPLE *)malloc(PAD(compptr->width_in_blocks * DCTSIZE, 32) *
+                        compptr->v_samp_factor + 32);
+    if (!_tmpbuf[i])
+      THROW("tjDecodeYUVPlanes(): Memory allocation failure");
+    tmpbuf[i] = (JSAMPROW *)malloc(sizeof(JSAMPROW) * compptr->v_samp_factor);
+    if (!tmpbuf[i])
+      THROW("tjDecodeYUVPlanes(): Memory allocation failure");
+    for (row = 0; row < compptr->v_samp_factor; row++) {
+      unsigned char *_tmpbuf_aligned =
+        (unsigned char *)PAD((size_t)_tmpbuf[i], 32);
+
+      tmpbuf[i][row] =
+        &_tmpbuf_aligned[PAD(compptr->width_in_blocks * DCTSIZE, 32) * row];
+    }
+    pw[i] = pw0 * compptr->h_samp_factor / dinfo->max_h_samp_factor;
+    ph[i] = ph0 * compptr->v_samp_factor / dinfo->max_v_samp_factor;
+    inbuf[i] = (JSAMPROW *)malloc(sizeof(JSAMPROW) * ph[i]);
+    if (!inbuf[i])
+      THROW("tjDecodeYUVPlanes(): Memory allocation failure");
+    ptr = (JSAMPLE *)srcPlanes[i];
+    for (row = 0; row < ph[i]; row++) {
+      inbuf[i][row] = ptr;
+      ptr += (strides && strides[i] != 0) ? strides[i] : pw[i];
+    }
+  }
+
+  if (setjmp(this->jerr.setjmp_buffer)) {
+    /* If we get here, the JPEG code has signaled an error. */
+    retval = -1;  goto bailout;
+  }
+
+  for (row = 0; row < ph0; row += dinfo->max_v_samp_factor) {
+    JDIMENSION inrow = 0, outrow = 0;
+
+    for (i = 0, compptr = dinfo->comp_info; i < dinfo->num_components;
+         i++, compptr++)
+      jcopy_sample_rows(inbuf[i],
+        row * compptr->v_samp_factor / dinfo->max_v_samp_factor, tmpbuf[i], 0,
+        compptr->v_samp_factor, pw[i]);
+    (dinfo->upsample->upsample) (dinfo, tmpbuf, &inrow,
+                                 dinfo->max_v_samp_factor, &row_pointer[row],
+                                 &outrow, dinfo->max_v_samp_factor);
+  }
+  jpeg_abort_decompress(dinfo);
+
+bailout:
+  if (dinfo->global_state > DSTATE_START) jpeg_abort_decompress(dinfo);
+  free(row_pointer);
+  for (i = 0; i < MAX_COMPONENTS; i++) {
+    free(tmpbuf[i]);
+    free(_tmpbuf[i]);
+    free(inbuf[i]);
+  }
+  if (this->jerr.warning) retval = -1;
+  this->jerr.stopOnWarning = FALSE;
+  return retval;
+}
+
+DLLEXPORT int tjDecodeYUV(tjhandle handle, const unsigned char *srcBuf,
+                          int pad, int subsamp, unsigned char *dstBuf,
+                          int width, int pitch, int height, int pixelFormat,
+                          int flags)
+{
+  const unsigned char *srcPlanes[3];
+  int pw0, ph0, strides[3], retval = -1;
+  tjinstance *this = (tjinstance *)handle;
+
+  if (!this) THROWG("tjDecodeYUV(): Invalid handle");
+  this->isInstanceError = FALSE;
+
+  if (srcBuf == NULL || pad < 0 || !IS_POW2(pad) || subsamp < 0 ||
+      subsamp >= NUMSUBOPT || width <= 0 || height <= 0)
+    THROW("tjDecodeYUV(): Invalid argument");
+
+  pw0 = tjPlaneWidth(0, width, subsamp);
+  ph0 = tjPlaneHeight(0, height, subsamp);
+  srcPlanes[0] = srcBuf;
+  strides[0] = PAD(pw0, pad);
+  if (subsamp == TJSAMP_GRAY) {
+    strides[1] = strides[2] = 0;
+    srcPlanes[1] = srcPlanes[2] = NULL;
+  } else {
+    int pw1 = tjPlaneWidth(1, width, subsamp);
+    int ph1 = tjPlaneHeight(1, height, subsamp);
+
+    strides[1] = strides[2] = PAD(pw1, pad);
+    srcPlanes[1] = srcPlanes[0] + strides[0] * ph0;
+    srcPlanes[2] = srcPlanes[1] + strides[1] * ph1;
+  }
+
+  return tjDecodeYUVPlanes(handle, srcPlanes, strides, subsamp, dstBuf, width,
+                           pitch, height, pixelFormat, flags);
+
+bailout:
+  return retval;
+}
+
+DLLEXPORT int tjDecompressToYUVPlanes(tjhandle handle,
+                                      const unsigned char *jpegBuf,
+                                      unsigned long jpegSize,
+                                      unsigned char **dstPlanes, int width,
+                                      int *strides, int height, int flags)
+{
+  int i, sfi, row, retval = 0;
+  int jpegwidth, jpegheight, jpegSubsamp, scaledw, scaledh;
+  int pw[MAX_COMPONENTS], ph[MAX_COMPONENTS], iw[MAX_COMPONENTS],
+    tmpbufsize = 0, usetmpbuf = 0, th[MAX_COMPONENTS];
+  JSAMPLE *_tmpbuf = NULL, *ptr;
+  JSAMPROW *outbuf[MAX_COMPONENTS], *tmpbuf[MAX_COMPONENTS];
+  int dctsize;
+
+  GET_DINSTANCE(handle);
+  this->jerr.stopOnWarning = (flags & TJFLAG_STOPONWARNING) ? TRUE : FALSE;
+
+  for (i = 0; i < MAX_COMPONENTS; i++) {
+    tmpbuf[i] = NULL;  outbuf[i] = NULL;
+  }
+
+  if ((this->init & DECOMPRESS) == 0)
+    THROW("tjDecompressToYUVPlanes(): Instance has not been initialized for decompression");
+
+  if (jpegBuf == NULL || jpegSize <= 0 || !dstPlanes || !dstPlanes[0] ||
+      width < 0 || height < 0)
+    THROW("tjDecompressToYUVPlanes(): Invalid argument");
+
+#ifndef NO_PUTENV
+  if (flags & TJFLAG_FORCEMMX) putenv("JSIMD_FORCEMMX=1");
+  else if (flags & TJFLAG_FORCESSE) putenv("JSIMD_FORCESSE=1");
+  else if (flags & TJFLAG_FORCESSE2) putenv("JSIMD_FORCESSE2=1");
+#endif
+
+  if (setjmp(this->jerr.setjmp_buffer)) {
+    /* If we get here, the JPEG code has signaled an error. */
+    retval = -1;  goto bailout;
+  }
+
+  if (!this->headerRead) {
+    jpeg_mem_src_tj(dinfo, jpegBuf, jpegSize);
+    jpeg_read_header(dinfo, TRUE);
+  }
+  this->headerRead = 0;
+  jpegSubsamp = getSubsamp(dinfo);
+  if (jpegSubsamp < 0)
+    THROW("tjDecompressToYUVPlanes(): Could not determine subsampling type for JPEG image");
+
+  if (jpegSubsamp != TJSAMP_GRAY && (!dstPlanes[1] || !dstPlanes[2]))
+    THROW("tjDecompressToYUVPlanes(): Invalid argument");
+
+  jpegwidth = dinfo->image_width;  jpegheight = dinfo->image_height;
+  if (width == 0) width = jpegwidth;
+  if (height == 0) height = jpegheight;
+  for (i = 0; i < NUMSF; i++) {
+    scaledw = TJSCALED(jpegwidth, sf[i]);
+    scaledh = TJSCALED(jpegheight, sf[i]);
+    if (scaledw <= width && scaledh <= height)
+      break;
+  }
+  if (i >= NUMSF)
+    THROW("tjDecompressToYUVPlanes(): Could not scale down to desired image dimensions");
+  if (dinfo->num_components > 3)
+    THROW("tjDecompressToYUVPlanes(): JPEG image must have 3 or fewer components");
+
+  width = scaledw;  height = scaledh;
+  dinfo->scale_num = sf[i].num;
+  dinfo->scale_denom = sf[i].denom;
+  sfi = i;
+  jpeg_calc_output_dimensions(dinfo);
+
+  dctsize = DCTSIZE * sf[sfi].num / sf[sfi].denom;
+
+  for (i = 0; i < dinfo->num_components; i++) {
+    jpeg_component_info *compptr = &dinfo->comp_info[i];
+    int ih;
+
+    iw[i] = compptr->width_in_blocks * dctsize;
+    ih = compptr->height_in_blocks * dctsize;
+    pw[i] = tjPlaneWidth(i, dinfo->output_width, jpegSubsamp);
+    ph[i] = tjPlaneHeight(i, dinfo->output_height, jpegSubsamp);
+    if (iw[i] != pw[i] || ih != ph[i]) usetmpbuf = 1;
+    th[i] = compptr->v_samp_factor * dctsize;
+    tmpbufsize += iw[i] * th[i];
+    if ((outbuf[i] = (JSAMPROW *)malloc(sizeof(JSAMPROW) * ph[i])) == NULL)
+      THROW("tjDecompressToYUVPlanes(): Memory allocation failure");
+    ptr = dstPlanes[i];
+    for (row = 0; row < ph[i]; row++) {
+      outbuf[i][row] = ptr;
+      ptr += (strides && strides[i] != 0) ? strides[i] : pw[i];
+    }
+  }
+  if (usetmpbuf) {
+    if ((_tmpbuf = (JSAMPLE *)malloc(sizeof(JSAMPLE) * tmpbufsize)) == NULL)
+      THROW("tjDecompressToYUVPlanes(): Memory allocation failure");
+    ptr = _tmpbuf;
+    for (i = 0; i < dinfo->num_components; i++) {
+      if ((tmpbuf[i] = (JSAMPROW *)malloc(sizeof(JSAMPROW) * th[i])) == NULL)
+        THROW("tjDecompressToYUVPlanes(): Memory allocation failure");
+      for (row = 0; row < th[i]; row++) {
+        tmpbuf[i][row] = ptr;
+        ptr += iw[i];
+      }
+    }
+  }
+
+  if (setjmp(this->jerr.setjmp_buffer)) {
+    /* If we get here, the JPEG code has signaled an error. */
+    retval = -1;  goto bailout;
+  }
+
+  if (flags & TJFLAG_FASTUPSAMPLE) dinfo->do_fancy_upsampling = FALSE;
+  if (flags & TJFLAG_FASTDCT) dinfo->dct_method = JDCT_FASTEST;
+  dinfo->raw_data_out = TRUE;
+
+  jpeg_start_decompress(dinfo);
+  for (row = 0; row < (int)dinfo->output_height;
+       row += dinfo->max_v_samp_factor * dinfo->_min_DCT_scaled_size) {
+    JSAMPARRAY yuvptr[MAX_COMPONENTS];
+    int crow[MAX_COMPONENTS];
+
+    for (i = 0; i < dinfo->num_components; i++) {
+      jpeg_component_info *compptr = &dinfo->comp_info[i];
+
+      if (jpegSubsamp == TJ_420) {
+        /* When 4:2:0 subsampling is used with IDCT scaling, libjpeg will try
+           to be clever and use the IDCT to perform upsampling on the U and V
+           planes.  For instance, if the output image is to be scaled by 1/2
+           relative to the JPEG image, then the scaling factor and upsampling
+           effectively cancel each other, so a normal 8x8 IDCT can be used.
+           However, this is not desirable when using the decompress-to-YUV
+           functionality in TurboJPEG, since we want to output the U and V
+           planes in their subsampled form.  Thus, we have to override some
+           internal libjpeg parameters to force it to use the "scaled" IDCT
+           functions on the U and V planes. */
+        compptr->_DCT_scaled_size = dctsize;
+        compptr->MCU_sample_width = tjMCUWidth[jpegSubsamp] *
+          sf[sfi].num / sf[sfi].denom *
+          compptr->v_samp_factor / dinfo->max_v_samp_factor;
+        dinfo->idct->inverse_DCT[i] = dinfo->idct->inverse_DCT[0];
+      }
+      crow[i] = row * compptr->v_samp_factor / dinfo->max_v_samp_factor;
+      if (usetmpbuf) yuvptr[i] = tmpbuf[i];
+      else yuvptr[i] = &outbuf[i][crow[i]];
+    }
+    jpeg_read_raw_data(dinfo, yuvptr,
+                       dinfo->max_v_samp_factor * dinfo->_min_DCT_scaled_size);
+    if (usetmpbuf) {
+      int j;
+
+      for (i = 0; i < dinfo->num_components; i++) {
+        for (j = 0; j < MIN(th[i], ph[i] - crow[i]); j++) {
+          memcpy(outbuf[i][crow[i] + j], tmpbuf[i][j], pw[i]);
+        }
+      }
+    }
+  }
+  jpeg_finish_decompress(dinfo);
+
+bailout:
+  if (dinfo->global_state > DSTATE_START) jpeg_abort_decompress(dinfo);
+  for (i = 0; i < MAX_COMPONENTS; i++) {
+    free(tmpbuf[i]);
+    free(outbuf[i]);
+  }
+  free(_tmpbuf);
+  if (this->jerr.warning) retval = -1;
+  this->jerr.stopOnWarning = FALSE;
+  return retval;
+}
+
+DLLEXPORT int tjDecompressToYUV2(tjhandle handle, const unsigned char *jpegBuf,
+                                 unsigned long jpegSize, unsigned char *dstBuf,
+                                 int width, int pad, int height, int flags)
+{
+  unsigned char *dstPlanes[3];
+  int pw0, ph0, strides[3], retval = -1, jpegSubsamp = -1;
+  int i, jpegwidth, jpegheight, scaledw, scaledh;
+
+  GET_DINSTANCE(handle);
+  this->jerr.stopOnWarning = (flags & TJFLAG_STOPONWARNING) ? TRUE : FALSE;
+
+  if (jpegBuf == NULL || jpegSize <= 0 || dstBuf == NULL || width < 0 ||
+      pad < 1 || !IS_POW2(pad) || height < 0)
+    THROW("tjDecompressToYUV2(): Invalid argument");
+
+  if (setjmp(this->jerr.setjmp_buffer)) {
+    /* If we get here, the JPEG code has signaled an error. */
+    return -1;
+  }
+
+  jpeg_mem_src_tj(dinfo, jpegBuf, jpegSize);
+  jpeg_read_header(dinfo, TRUE);
+  jpegSubsamp = getSubsamp(dinfo);
+  if (jpegSubsamp < 0)
+    THROW("tjDecompressToYUV2(): Could not determine subsampling type for JPEG image");
+
+  jpegwidth = dinfo->image_width;  jpegheight = dinfo->image_height;
+  if (width == 0) width = jpegwidth;
+  if (height == 0) height = jpegheight;
+
+  for (i = 0; i < NUMSF; i++) {
+    scaledw = TJSCALED(jpegwidth, sf[i]);
+    scaledh = TJSCALED(jpegheight, sf[i]);
+    if (scaledw <= width && scaledh <= height)
+      break;
+  }
+  if (i >= NUMSF)
+    THROW("tjDecompressToYUV2(): Could not scale down to desired image dimensions");
+
+  pw0 = tjPlaneWidth(0, width, jpegSubsamp);
+  ph0 = tjPlaneHeight(0, height, jpegSubsamp);
+  dstPlanes[0] = dstBuf;
+  strides[0] = PAD(pw0, pad);
+  if (jpegSubsamp == TJSAMP_GRAY) {
+    strides[1] = strides[2] = 0;
+    dstPlanes[1] = dstPlanes[2] = NULL;
+  } else {
+    int pw1 = tjPlaneWidth(1, width, jpegSubsamp);
+    int ph1 = tjPlaneHeight(1, height, jpegSubsamp);
+
+    strides[1] = strides[2] = PAD(pw1, pad);
+    dstPlanes[1] = dstPlanes[0] + strides[0] * ph0;
+    dstPlanes[2] = dstPlanes[1] + strides[1] * ph1;
+  }
+
+  this->headerRead = 1;
+  return tjDecompressToYUVPlanes(handle, jpegBuf, jpegSize, dstPlanes, width,
+                                 strides, height, flags);
+
+bailout:
+  this->jerr.stopOnWarning = FALSE;
+  return retval;
+}
+
+DLLEXPORT int tjDecompressToYUV(tjhandle handle, unsigned char *jpegBuf,
+                                unsigned long jpegSize, unsigned char *dstBuf,
+                                int flags)
+{
+  return tjDecompressToYUV2(handle, jpegBuf, jpegSize, dstBuf, 0, 4, 0, flags);
+}
+
+
+/* Transformer */
+
+DLLEXPORT tjhandle tjInitTransform(void)
+{
+  tjinstance *this = NULL;
+  tjhandle handle = NULL;
+
+  if ((this = (tjinstance *)malloc(sizeof(tjinstance))) == NULL) {
+    snprintf(errStr, JMSG_LENGTH_MAX,
+             "tjInitTransform(): Memory allocation failure");
+    return NULL;
+  }
+  MEMZERO(this, sizeof(tjinstance));
+  snprintf(this->errStr, JMSG_LENGTH_MAX, "No error");
+  handle = _tjInitCompress(this);
+  if (!handle) return NULL;
+  handle = _tjInitDecompress(this);
+  return handle;
+}
+
+
+DLLEXPORT int tjTransform(tjhandle handle, const unsigned char *jpegBuf,
+                          unsigned long jpegSize, int n,
+                          unsigned char **dstBufs, unsigned long *dstSizes,
+                          tjtransform *t, int flags)
+{
+  jpeg_transform_info *xinfo = NULL;
+  jvirt_barray_ptr *srccoefs, *dstcoefs;
+  int retval = 0, i, jpegSubsamp, saveMarkers = 0;
+
+  GET_INSTANCE(handle);
+  this->jerr.stopOnWarning = (flags & TJFLAG_STOPONWARNING) ? TRUE : FALSE;
+  if ((this->init & COMPRESS) == 0 || (this->init & DECOMPRESS) == 0)
+    THROW("tjTransform(): Instance has not been initialized for transformation");
+
+  if (jpegBuf == NULL || jpegSize <= 0 || n < 1 || dstBufs == NULL ||
+      dstSizes == NULL || t == NULL || flags < 0)
+    THROW("tjTransform(): Invalid argument");
+
+#ifndef NO_PUTENV
+  if (flags & TJFLAG_FORCEMMX) putenv("JSIMD_FORCEMMX=1");
+  else if (flags & TJFLAG_FORCESSE) putenv("JSIMD_FORCESSE=1");
+  else if (flags & TJFLAG_FORCESSE2) putenv("JSIMD_FORCESSE2=1");
+#endif
+
+  if ((xinfo =
+       (jpeg_transform_info *)malloc(sizeof(jpeg_transform_info) * n)) == NULL)
+    THROW("tjTransform(): Memory allocation failure");
+  MEMZERO(xinfo, sizeof(jpeg_transform_info) * n);
+
+  if (setjmp(this->jerr.setjmp_buffer)) {
+    /* If we get here, the JPEG code has signaled an error. */
+    retval = -1;  goto bailout;
+  }
+
+  jpeg_mem_src_tj(dinfo, jpegBuf, jpegSize);
+
+  for (i = 0; i < n; i++) {
+    xinfo[i].transform = xformtypes[t[i].op];
+    xinfo[i].perfect = (t[i].options & TJXOPT_PERFECT) ? 1 : 0;
+    xinfo[i].trim = (t[i].options & TJXOPT_TRIM) ? 1 : 0;
+    xinfo[i].force_grayscale = (t[i].options & TJXOPT_GRAY) ? 1 : 0;
+    xinfo[i].crop = (t[i].options & TJXOPT_CROP) ? 1 : 0;
+    if (n != 1 && t[i].op == TJXOP_HFLIP) xinfo[i].slow_hflip = 1;
+    else xinfo[i].slow_hflip = 0;
+
+    if (xinfo[i].crop) {
+      xinfo[i].crop_xoffset = t[i].r.x;  xinfo[i].crop_xoffset_set = JCROP_POS;
+      xinfo[i].crop_yoffset = t[i].r.y;  xinfo[i].crop_yoffset_set = JCROP_POS;
+      if (t[i].r.w != 0) {
+        xinfo[i].crop_width = t[i].r.w;  xinfo[i].crop_width_set = JCROP_POS;
+      } else
+        xinfo[i].crop_width = JCROP_UNSET;
+      if (t[i].r.h != 0) {
+        xinfo[i].crop_height = t[i].r.h;  xinfo[i].crop_height_set = JCROP_POS;
+      } else
+        xinfo[i].crop_height = JCROP_UNSET;
+    }
+    if (!(t[i].options & TJXOPT_COPYNONE)) saveMarkers = 1;
+  }
+
+  jcopy_markers_setup(dinfo, saveMarkers ? JCOPYOPT_ALL : JCOPYOPT_NONE);
+  jpeg_read_header(dinfo, TRUE);
+  jpegSubsamp = getSubsamp(dinfo);
+  if (jpegSubsamp < 0)
+    THROW("tjTransform(): Could not determine subsampling type for JPEG image");
+
+  for (i = 0; i < n; i++) {
+    if (!jtransform_request_workspace(dinfo, &xinfo[i]))
+      THROW("tjTransform(): Transform is not perfect");
+
+    if (xinfo[i].crop) {
+      if ((t[i].r.x % xinfo[i].iMCU_sample_width) != 0 ||
+          (t[i].r.y % xinfo[i].iMCU_sample_height) != 0) {
+        snprintf(this->errStr, JMSG_LENGTH_MAX,
+                 "To crop this JPEG image, x must be a multiple of %d\n"
+                 "and y must be a multiple of %d.\n",
+                 xinfo[i].iMCU_sample_width, xinfo[i].iMCU_sample_height);
+        this->isInstanceError = TRUE;
+        retval = -1;  goto bailout;
+      }
+    }
+  }
+
+  srccoefs = jpeg_read_coefficients(dinfo);
+
+  for (i = 0; i < n; i++) {
+    int w, h, alloc = 1;
+
+    if (!xinfo[i].crop) {
+      w = dinfo->image_width;  h = dinfo->image_height;
+    } else {
+      w = xinfo[i].crop_width;  h = xinfo[i].crop_height;
+    }
+    if (flags & TJFLAG_NOREALLOC) {
+      alloc = 0;  dstSizes[i] = tjBufSize(w, h, jpegSubsamp);
+    }
+    if (!(t[i].options & TJXOPT_NOOUTPUT))
+      jpeg_mem_dest_tj(cinfo, &dstBufs[i], &dstSizes[i], alloc);
+    jpeg_copy_critical_parameters(dinfo, cinfo);
+    dstcoefs = jtransform_adjust_parameters(dinfo, cinfo, srccoefs, &xinfo[i]);
+    if (flags & TJFLAG_PROGRESSIVE || t[i].options & TJXOPT_PROGRESSIVE)
+      jpeg_simple_progression(cinfo);
+    if (!(t[i].options & TJXOPT_NOOUTPUT)) {
+      jpeg_write_coefficients(cinfo, dstcoefs);
+      jcopy_markers_execute(dinfo, cinfo, t[i].options & TJXOPT_COPYNONE ?
+                                          JCOPYOPT_NONE : JCOPYOPT_ALL);
+    } else
+      jinit_c_master_control(cinfo, TRUE);
+    jtransform_execute_transformation(dinfo, cinfo, srccoefs, &xinfo[i]);
+    if (t[i].customFilter) {
+      int ci, y;
+      JDIMENSION by;
+
+      for (ci = 0; ci < cinfo->num_components; ci++) {
+        jpeg_component_info *compptr = &cinfo->comp_info[ci];
+        tjregion arrayRegion = {
+          0, 0, compptr->width_in_blocks * DCTSIZE, DCTSIZE
+        };
+        tjregion planeRegion = {
+          0, 0, compptr->width_in_blocks * DCTSIZE,
+          compptr->height_in_blocks * DCTSIZE
+        };
+
+        for (by = 0; by < compptr->height_in_blocks;
+             by += compptr->v_samp_factor) {
+          JBLOCKARRAY barray = (dinfo->mem->access_virt_barray)
+            ((j_common_ptr)dinfo, dstcoefs[ci], by, compptr->v_samp_factor,
+             TRUE);
+
+          for (y = 0; y < compptr->v_samp_factor; y++) {
+            if (t[i].customFilter(barray[y][0], arrayRegion, planeRegion, ci,
+                                  i, &t[i]) == -1)
+              THROW("tjTransform(): Error in custom filter");
+            arrayRegion.y += DCTSIZE;
+          }
+        }
+      }
+    }
+    if (!(t[i].options & TJXOPT_NOOUTPUT)) jpeg_finish_compress(cinfo);
+  }
+
+  jpeg_finish_decompress(dinfo);
+
+bailout:
+  if (cinfo->global_state > CSTATE_START) jpeg_abort_compress(cinfo);
+  if (dinfo->global_state > DSTATE_START) jpeg_abort_decompress(dinfo);
+  free(xinfo);
+  if (this->jerr.warning) retval = -1;
+  this->jerr.stopOnWarning = FALSE;
+  return retval;
+}
+
+
+DLLEXPORT unsigned char *tjLoadImage(const char *filename, int *width,
+                                     int align, int *height, int *pixelFormat,
+                                     int flags)
+{
+  int retval = 0, tempc;
+  size_t pitch;
+  tjhandle handle = NULL;
+  tjinstance *this;
+  j_compress_ptr cinfo = NULL;
+  cjpeg_source_ptr src;
+  unsigned char *dstBuf = NULL;
+  FILE *file = NULL;
+  boolean invert;
+
+  if (!filename || !width || align < 1 || !height || !pixelFormat ||
+      *pixelFormat < TJPF_UNKNOWN || *pixelFormat >= TJ_NUMPF)
+    THROWG("tjLoadImage(): Invalid argument");
+  if ((align & (align - 1)) != 0)
+    THROWG("tjLoadImage(): Alignment must be a power of 2");
+
+  if ((handle = tjInitCompress()) == NULL) return NULL;
+  this = (tjinstance *)handle;
+  cinfo = &this->cinfo;
+
+  if ((file = fopen(filename, "rb")) == NULL)
+    THROW_UNIX("tjLoadImage(): Cannot open input file");
+
+  if ((tempc = getc(file)) < 0 || ungetc(tempc, file) == EOF)
+    THROW_UNIX("tjLoadImage(): Could not read input file")
+  else if (tempc == EOF)
+    THROWG("tjLoadImage(): Input file contains no data");
+
+  if (setjmp(this->jerr.setjmp_buffer)) {
+    /* If we get here, the JPEG code has signaled an error. */
+    retval = -1;  goto bailout;
+  }
+
+  if (*pixelFormat == TJPF_UNKNOWN) cinfo->in_color_space = JCS_UNKNOWN;
+  else cinfo->in_color_space = pf2cs[*pixelFormat];
+  if (tempc == 'B') {
+    if ((src = jinit_read_bmp(cinfo, FALSE)) == NULL)
+      THROWG("tjLoadImage(): Could not initialize bitmap loader");
+    invert = (flags & TJFLAG_BOTTOMUP) == 0;
+  } else if (tempc == 'P') {
+    if ((src = jinit_read_ppm(cinfo)) == NULL)
+      THROWG("tjLoadImage(): Could not initialize bitmap loader");
+    invert = (flags & TJFLAG_BOTTOMUP) != 0;
+  } else
+    THROWG("tjLoadImage(): Unsupported file type");
+
+  src->input_file = file;
+  (*src->start_input) (cinfo, src);
+  (*cinfo->mem->realize_virt_arrays) ((j_common_ptr)cinfo);
+
+  *width = cinfo->image_width;  *height = cinfo->image_height;
+  *pixelFormat = cs2pf[cinfo->in_color_space];
+
+  pitch = PAD((*width) * tjPixelSize[*pixelFormat], align);
+  if ((unsigned long long)pitch * (unsigned long long)(*height) >
+      (unsigned long long)((size_t)-1) ||
+      (dstBuf = (unsigned char *)malloc(pitch * (*height))) == NULL)
+    THROWG("tjLoadImage(): Memory allocation failure");
+
+  if (setjmp(this->jerr.setjmp_buffer)) {
+    /* If we get here, the JPEG code has signaled an error. */
+    retval = -1;  goto bailout;
+  }
+
+  while (cinfo->next_scanline < cinfo->image_height) {
+    int i, nlines = (*src->get_pixel_rows) (cinfo, src);
+
+    for (i = 0; i < nlines; i++) {
+      unsigned char *dstptr;
+      int row;
+
+      row = cinfo->next_scanline + i;
+      if (invert) dstptr = &dstBuf[((*height) - row - 1) * pitch];
+      else dstptr = &dstBuf[row * pitch];
+      memcpy(dstptr, src->buffer[i], (*width) * tjPixelSize[*pixelFormat]);
+    }
+    cinfo->next_scanline += nlines;
+  }
+
+  (*src->finish_input) (cinfo, src);
+
+bailout:
+  if (handle) tjDestroy(handle);
+  if (file) fclose(file);
+  if (retval < 0) { free(dstBuf);  dstBuf = NULL; }
+  return dstBuf;
+}
+
+
+DLLEXPORT int tjSaveImage(const char *filename, unsigned char *buffer,
+                          int width, int pitch, int height, int pixelFormat,
+                          int flags)
+{
+  int retval = 0;
+  tjhandle handle = NULL;
+  tjinstance *this;
+  j_decompress_ptr dinfo = NULL;
+  djpeg_dest_ptr dst;
+  FILE *file = NULL;
+  char *ptr = NULL;
+  boolean invert;
+
+  if (!filename || !buffer || width < 1 || pitch < 0 || height < 1 ||
+      pixelFormat < 0 || pixelFormat >= TJ_NUMPF)
+    THROWG("tjSaveImage(): Invalid argument");
+
+  if ((handle = tjInitDecompress()) == NULL)
+    return -1;
+  this = (tjinstance *)handle;
+  dinfo = &this->dinfo;
+
+  if ((file = fopen(filename, "wb")) == NULL)
+    THROW_UNIX("tjSaveImage(): Cannot open output file");
+
+  if (setjmp(this->jerr.setjmp_buffer)) {
+    /* If we get here, the JPEG code has signaled an error. */
+    retval = -1;  goto bailout;
+  }
+
+  this->dinfo.out_color_space = pf2cs[pixelFormat];
+  dinfo->image_width = width;  dinfo->image_height = height;
+  dinfo->global_state = DSTATE_READY;
+  dinfo->scale_num = dinfo->scale_denom = 1;
+
+  ptr = strrchr(filename, '.');
+  if (ptr && !strcasecmp(ptr, ".bmp")) {
+    if ((dst = jinit_write_bmp(dinfo, FALSE, FALSE)) == NULL)
+      THROWG("tjSaveImage(): Could not initialize bitmap writer");
+    invert = (flags & TJFLAG_BOTTOMUP) == 0;
+  } else {
+    if ((dst = jinit_write_ppm(dinfo)) == NULL)
+      THROWG("tjSaveImage(): Could not initialize PPM writer");
+    invert = (flags & TJFLAG_BOTTOMUP) != 0;
+  }
+
+  dst->output_file = file;
+  (*dst->start_output) (dinfo, dst);
+  (*dinfo->mem->realize_virt_arrays) ((j_common_ptr)dinfo);
+
+  if (pitch == 0) pitch = width * tjPixelSize[pixelFormat];
+
+  while (dinfo->output_scanline < dinfo->output_height) {
+    unsigned char *rowptr;
+
+    if (invert)
+      rowptr = &buffer[(height - dinfo->output_scanline - 1) * pitch];
+    else
+      rowptr = &buffer[dinfo->output_scanline * pitch];
+    memcpy(dst->buffer[0], rowptr, width * tjPixelSize[pixelFormat]);
+    (*dst->put_pixel_rows) (dinfo, dst, 1);
+    dinfo->output_scanline++;
+  }
+
+  (*dst->finish_output) (dinfo, dst);
+
+bailout:
+  if (handle) tjDestroy(handle);
+  if (file) fclose(file);
+  return retval;
+}
diff --git a/3rdparty/libjpeg/src/turbojpeg.h b/3rdparty/libjpeg/src/turbojpeg.h
new file mode 100644
index 00000000..f3209dd3
--- /dev/null
+++ b/3rdparty/libjpeg/src/turbojpeg.h
@@ -0,0 +1,1745 @@
+/*
+ * Copyright (C)2009-2015, 2017, 2020 D. R. Commander.  All Rights Reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright notice,
+ *   this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright notice,
+ *   this list of conditions and the following disclaimer in the documentation
+ *   and/or other materials provided with the distribution.
+ * - Neither the name of the libjpeg-turbo Project nor the names of its
+ *   contributors may be used to endorse or promote products derived from this
+ *   software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE 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 HOLDERS 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.
+ */
+
+#ifndef __TURBOJPEG_H__
+#define __TURBOJPEG_H__
+
+#if defined(_WIN32) && defined(DLLDEFINE)
+#define DLLEXPORT  __declspec(dllexport)
+#else
+#define DLLEXPORT
+#endif
+#define DLLCALL
+
+
+/**
+ * @addtogroup TurboJPEG
+ * TurboJPEG API.  This API provides an interface for generating, decoding, and
+ * transforming planar YUV and JPEG images in memory.
+ *
+ * @anchor YUVnotes
+ * YUV Image Format Notes
+ * ----------------------
+ * Technically, the JPEG format uses the YCbCr colorspace (which is technically
+ * not a colorspace but a color transform), but per the convention of the
+ * digital video community, the TurboJPEG API uses "YUV" to refer to an image
+ * format consisting of Y, Cb, and Cr image planes.
+ *
+ * Each plane is simply a 2D array of bytes, each byte representing the value
+ * of one of the components (Y, Cb, or Cr) at a particular location in the
+ * image.  The width and height of each plane are determined by the image
+ * width, height, and level of chrominance subsampling.   The luminance plane
+ * width is the image width padded to the nearest multiple of the horizontal
+ * subsampling factor (2 in the case of 4:2:0 and 4:2:2, 4 in the case of
+ * 4:1:1, 1 in the case of 4:4:4 or grayscale.)  Similarly, the luminance plane
+ * height is the image height padded to the nearest multiple of the vertical
+ * subsampling factor (2 in the case of 4:2:0 or 4:4:0, 1 in the case of 4:4:4
+ * or grayscale.)  This is irrespective of any additional padding that may be
+ * specified as an argument to the various YUV functions.  The chrominance
+ * plane width is equal to the luminance plane width divided by the horizontal
+ * subsampling factor, and the chrominance plane height is equal to the
+ * luminance plane height divided by the vertical subsampling factor.
+ *
+ * For example, if the source image is 35 x 35 pixels and 4:2:2 subsampling is
+ * used, then the luminance plane would be 36 x 35 bytes, and each of the
+ * chrominance planes would be 18 x 35 bytes.  If you specify a line padding of
+ * 4 bytes on top of this, then the luminance plane would be 36 x 35 bytes, and
+ * each of the chrominance planes would be 20 x 35 bytes.
+ *
+ * @{
+ */
+
+
+/**
+ * The number of chrominance subsampling options
+ */
+#define TJ_NUMSAMP  6
+
+/**
+ * Chrominance subsampling options.
+ * When pixels are converted from RGB to YCbCr (see #TJCS_YCbCr) or from CMYK
+ * to YCCK (see #TJCS_YCCK) as part of the JPEG compression process, some of
+ * the Cb and Cr (chrominance) components can be discarded or averaged together
+ * to produce a smaller image with little perceptible loss of image clarity
+ * (the human eye is more sensitive to small changes in brightness than to
+ * small changes in color.)  This is called "chrominance subsampling".
+ */
+enum TJSAMP {
+  /**
+   * 4:4:4 chrominance subsampling (no chrominance subsampling).  The JPEG or
+   * YUV image will contain one chrominance component for every pixel in the
+   * source image.
+   */
+  TJSAMP_444 = 0,
+  /**
+   * 4:2:2 chrominance subsampling.  The JPEG or YUV image will contain one
+   * chrominance component for every 2x1 block of pixels in the source image.
+   */
+  TJSAMP_422,
+  /**
+   * 4:2:0 chrominance subsampling.  The JPEG or YUV image will contain one
+   * chrominance component for every 2x2 block of pixels in the source image.
+   */
+  TJSAMP_420,
+  /**
+   * Grayscale.  The JPEG or YUV image will contain no chrominance components.
+   */
+  TJSAMP_GRAY,
+  /**
+   * 4:4:0 chrominance subsampling.  The JPEG or YUV image will contain one
+   * chrominance component for every 1x2 block of pixels in the source image.
+   *
+   * @note 4:4:0 subsampling is not fully accelerated in libjpeg-turbo.
+   */
+  TJSAMP_440,
+  /**
+   * 4:1:1 chrominance subsampling.  The JPEG or YUV image will contain one
+   * chrominance component for every 4x1 block of pixels in the source image.
+   * JPEG images compressed with 4:1:1 subsampling will be almost exactly the
+   * same size as those compressed with 4:2:0 subsampling, and in the
+   * aggregate, both subsampling methods produce approximately the same
+   * perceptual quality.  However, 4:1:1 is better able to reproduce sharp
+   * horizontal features.
+   *
+   * @note 4:1:1 subsampling is not fully accelerated in libjpeg-turbo.
+   */
+  TJSAMP_411
+};
+
+/**
+ * MCU block width (in pixels) for a given level of chrominance subsampling.
+ * MCU block sizes:
+ * - 8x8 for no subsampling or grayscale
+ * - 16x8 for 4:2:2
+ * - 8x16 for 4:4:0
+ * - 16x16 for 4:2:0
+ * - 32x8 for 4:1:1
+ */
+static const int tjMCUWidth[TJ_NUMSAMP]  = { 8, 16, 16, 8, 8, 32 };
+
+/**
+ * MCU block height (in pixels) for a given level of chrominance subsampling.
+ * MCU block sizes:
+ * - 8x8 for no subsampling or grayscale
+ * - 16x8 for 4:2:2
+ * - 8x16 for 4:4:0
+ * - 16x16 for 4:2:0
+ * - 32x8 for 4:1:1
+ */
+static const int tjMCUHeight[TJ_NUMSAMP] = { 8, 8, 16, 8, 16, 8 };
+
+
+/**
+ * The number of pixel formats
+ */
+#define TJ_NUMPF  12
+
+/**
+ * Pixel formats
+ */
+enum TJPF {
+  /**
+   * RGB pixel format.  The red, green, and blue components in the image are
+   * stored in 3-byte pixels in the order R, G, B from lowest to highest byte
+   * address within each pixel.
+   */
+  TJPF_RGB = 0,
+  /**
+   * BGR pixel format.  The red, green, and blue components in the image are
+   * stored in 3-byte pixels in the order B, G, R from lowest to highest byte
+   * address within each pixel.
+   */
+  TJPF_BGR,
+  /**
+   * RGBX pixel format.  The red, green, and blue components in the image are
+   * stored in 4-byte pixels in the order R, G, B from lowest to highest byte
+   * address within each pixel.  The X component is ignored when compressing
+   * and undefined when decompressing.
+   */
+  TJPF_RGBX,
+  /**
+   * BGRX pixel format.  The red, green, and blue components in the image are
+   * stored in 4-byte pixels in the order B, G, R from lowest to highest byte
+   * address within each pixel.  The X component is ignored when compressing
+   * and undefined when decompressing.
+   */
+  TJPF_BGRX,
+  /**
+   * XBGR pixel format.  The red, green, and blue components in the image are
+   * stored in 4-byte pixels in the order R, G, B from highest to lowest byte
+   * address within each pixel.  The X component is ignored when compressing
+   * and undefined when decompressing.
+   */
+  TJPF_XBGR,
+  /**
+   * XRGB pixel format.  The red, green, and blue components in the image are
+   * stored in 4-byte pixels in the order B, G, R from highest to lowest byte
+   * address within each pixel.  The X component is ignored when compressing
+   * and undefined when decompressing.
+   */
+  TJPF_XRGB,
+  /**
+   * Grayscale pixel format.  Each 1-byte pixel represents a luminance
+   * (brightness) level from 0 to 255.
+   */
+  TJPF_GRAY,
+  /**
+   * RGBA pixel format.  This is the same as @ref TJPF_RGBX, except that when
+   * decompressing, the X component is guaranteed to be 0xFF, which can be
+   * interpreted as an opaque alpha channel.
+   */
+  TJPF_RGBA,
+  /**
+   * BGRA pixel format.  This is the same as @ref TJPF_BGRX, except that when
+   * decompressing, the X component is guaranteed to be 0xFF, which can be
+   * interpreted as an opaque alpha channel.
+   */
+  TJPF_BGRA,
+  /**
+   * ABGR pixel format.  This is the same as @ref TJPF_XBGR, except that when
+   * decompressing, the X component is guaranteed to be 0xFF, which can be
+   * interpreted as an opaque alpha channel.
+   */
+  TJPF_ABGR,
+  /**
+   * ARGB pixel format.  This is the same as @ref TJPF_XRGB, except that when
+   * decompressing, the X component is guaranteed to be 0xFF, which can be
+   * interpreted as an opaque alpha channel.
+   */
+  TJPF_ARGB,
+  /**
+   * CMYK pixel format.  Unlike RGB, which is an additive color model used
+   * primarily for display, CMYK (Cyan/Magenta/Yellow/Key) is a subtractive
+   * color model used primarily for printing.  In the CMYK color model, the
+   * value of each color component typically corresponds to an amount of cyan,
+   * magenta, yellow, or black ink that is applied to a white background.  In
+   * order to convert between CMYK and RGB, it is necessary to use a color
+   * management system (CMS.)  A CMS will attempt to map colors within the
+   * printer's gamut to perceptually similar colors in the display's gamut and
+   * vice versa, but the mapping is typically not 1:1 or reversible, nor can it
+   * be defined with a simple formula.  Thus, such a conversion is out of scope
+   * for a codec library.  However, the TurboJPEG API allows for compressing
+   * CMYK pixels into a YCCK JPEG image (see #TJCS_YCCK) and decompressing YCCK
+   * JPEG images into CMYK pixels.
+   */
+  TJPF_CMYK,
+  /**
+   * Unknown pixel format.  Currently this is only used by #tjLoadImage().
+   */
+  TJPF_UNKNOWN = -1
+};
+
+/**
+ * Red offset (in bytes) for a given pixel format.  This specifies the number
+ * of bytes that the red component is offset from the start of the pixel.  For
+ * instance, if a pixel of format TJ_BGRX is stored in <tt>char pixel[]</tt>,
+ * then the red component will be <tt>pixel[tjRedOffset[TJ_BGRX]]</tt>.  This
+ * will be -1 if the pixel format does not have a red component.
+ */
+static const int tjRedOffset[TJ_NUMPF] = {
+  0, 2, 0, 2, 3, 1, -1, 0, 2, 3, 1, -1
+};
+/**
+ * Green offset (in bytes) for a given pixel format.  This specifies the number
+ * of bytes that the green component is offset from the start of the pixel.
+ * For instance, if a pixel of format TJ_BGRX is stored in
+ * <tt>char pixel[]</tt>, then the green component will be
+ * <tt>pixel[tjGreenOffset[TJ_BGRX]]</tt>.  This will be -1 if the pixel format
+ * does not have a green component.
+ */
+static const int tjGreenOffset[TJ_NUMPF] = {
+  1, 1, 1, 1, 2, 2, -1, 1, 1, 2, 2, -1
+};
+/**
+ * Blue offset (in bytes) for a given pixel format.  This specifies the number
+ * of bytes that the Blue component is offset from the start of the pixel.  For
+ * instance, if a pixel of format TJ_BGRX is stored in <tt>char pixel[]</tt>,
+ * then the blue component will be <tt>pixel[tjBlueOffset[TJ_BGRX]]</tt>.  This
+ * will be -1 if the pixel format does not have a blue component.
+ */
+static const int tjBlueOffset[TJ_NUMPF] = {
+  2, 0, 2, 0, 1, 3, -1, 2, 0, 1, 3, -1
+};
+/**
+ * Alpha offset (in bytes) for a given pixel format.  This specifies the number
+ * of bytes that the Alpha component is offset from the start of the pixel.
+ * For instance, if a pixel of format TJ_BGRA is stored in
+ * <tt>char pixel[]</tt>, then the alpha component will be
+ * <tt>pixel[tjAlphaOffset[TJ_BGRA]]</tt>.  This will be -1 if the pixel format
+ * does not have an alpha component.
+ */
+static const int tjAlphaOffset[TJ_NUMPF] = {
+  -1, -1, -1, -1, -1, -1, -1, 3, 3, 0, 0, -1
+};
+/**
+ * Pixel size (in bytes) for a given pixel format
+ */
+static const int tjPixelSize[TJ_NUMPF] = {
+  3, 3, 4, 4, 4, 4, 1, 4, 4, 4, 4, 4
+};
+
+
+/**
+ * The number of JPEG colorspaces
+ */
+#define TJ_NUMCS  5
+
+/**
+ * JPEG colorspaces
+ */
+enum TJCS {
+  /**
+   * RGB colorspace.  When compressing the JPEG image, the R, G, and B
+   * components in the source image are reordered into image planes, but no
+   * colorspace conversion or subsampling is performed.  RGB JPEG images can be
+   * decompressed to any of the extended RGB pixel formats or grayscale, but
+   * they cannot be decompressed to YUV images.
+   */
+  TJCS_RGB = 0,
+  /**
+   * YCbCr colorspace.  YCbCr is not an absolute colorspace but rather a
+   * mathematical transformation of RGB designed solely for storage and
+   * transmission.  YCbCr images must be converted to RGB before they can
+   * actually be displayed.  In the YCbCr colorspace, the Y (luminance)
+   * component represents the black & white portion of the original image, and
+   * the Cb and Cr (chrominance) components represent the color portion of the
+   * original image.  Originally, the analog equivalent of this transformation
+   * allowed the same signal to drive both black & white and color televisions,
+   * but JPEG images use YCbCr primarily because it allows the color data to be
+   * optionally subsampled for the purposes of reducing bandwidth or disk
+   * space.  YCbCr is the most common JPEG colorspace, and YCbCr JPEG images
+   * can be compressed from and decompressed to any of the extended RGB pixel
+   * formats or grayscale, or they can be decompressed to YUV planar images.
+   */
+  TJCS_YCbCr,
+  /**
+   * Grayscale colorspace.  The JPEG image retains only the luminance data (Y
+   * component), and any color data from the source image is discarded.
+   * Grayscale JPEG images can be compressed from and decompressed to any of
+   * the extended RGB pixel formats or grayscale, or they can be decompressed
+   * to YUV planar images.
+   */
+  TJCS_GRAY,
+  /**
+   * CMYK colorspace.  When compressing the JPEG image, the C, M, Y, and K
+   * components in the source image are reordered into image planes, but no
+   * colorspace conversion or subsampling is performed.  CMYK JPEG images can
+   * only be decompressed to CMYK pixels.
+   */
+  TJCS_CMYK,
+  /**
+   * YCCK colorspace.  YCCK (AKA "YCbCrK") is not an absolute colorspace but
+   * rather a mathematical transformation of CMYK designed solely for storage
+   * and transmission.  It is to CMYK as YCbCr is to RGB.  CMYK pixels can be
+   * reversibly transformed into YCCK, and as with YCbCr, the chrominance
+   * components in the YCCK pixels can be subsampled without incurring major
+   * perceptual loss.  YCCK JPEG images can only be compressed from and
+   * decompressed to CMYK pixels.
+   */
+  TJCS_YCCK
+};
+
+
+/**
+ * The uncompressed source/destination image is stored in bottom-up (Windows,
+ * OpenGL) order, not top-down (X11) order.
+ */
+#define TJFLAG_BOTTOMUP  2
+/**
+ * When decompressing an image that was compressed using chrominance
+ * subsampling, use the fastest chrominance upsampling algorithm available in
+ * the underlying codec.  The default is to use smooth upsampling, which
+ * creates a smooth transition between neighboring chrominance components in
+ * order to reduce upsampling artifacts in the decompressed image.
+ */
+#define TJFLAG_FASTUPSAMPLE  256
+/**
+ * Disable buffer (re)allocation.  If passed to one of the JPEG compression or
+ * transform functions, this flag will cause those functions to generate an
+ * error if the JPEG image buffer is invalid or too small rather than
+ * attempting to allocate or reallocate that buffer.  This reproduces the
+ * behavior of earlier versions of TurboJPEG.
+ */
+#define TJFLAG_NOREALLOC  1024
+/**
+ * Use the fastest DCT/IDCT algorithm available in the underlying codec.  The
+ * default if this flag is not specified is implementation-specific.  For
+ * example, the implementation of TurboJPEG for libjpeg[-turbo] uses the fast
+ * algorithm by default when compressing, because this has been shown to have
+ * only a very slight effect on accuracy, but it uses the accurate algorithm
+ * when decompressing, because this has been shown to have a larger effect.
+ */
+#define TJFLAG_FASTDCT  2048
+/**
+ * Use the most accurate DCT/IDCT algorithm available in the underlying codec.
+ * The default if this flag is not specified is implementation-specific.  For
+ * example, the implementation of TurboJPEG for libjpeg[-turbo] uses the fast
+ * algorithm by default when compressing, because this has been shown to have
+ * only a very slight effect on accuracy, but it uses the accurate algorithm
+ * when decompressing, because this has been shown to have a larger effect.
+ */
+#define TJFLAG_ACCURATEDCT  4096
+/**
+ * Immediately discontinue the current compression/decompression/transform
+ * operation if the underlying codec throws a warning (non-fatal error).  The
+ * default behavior is to allow the operation to complete unless a fatal error
+ * is encountered.
+ */
+#define TJFLAG_STOPONWARNING  8192
+/**
+ * Use progressive entropy coding in JPEG images generated by the compression
+ * and transform functions.  Progressive entropy coding will generally improve
+ * compression relative to baseline entropy coding (the default), but it will
+ * reduce compression and decompression performance considerably.
+ */
+#define TJFLAG_PROGRESSIVE  16384
+
+
+/**
+ * The number of error codes
+ */
+#define TJ_NUMERR  2
+
+/**
+ * Error codes
+ */
+enum TJERR {
+  /**
+   * The error was non-fatal and recoverable, but the image may still be
+   * corrupt.
+   */
+  TJERR_WARNING = 0,
+  /**
+   * The error was fatal and non-recoverable.
+   */
+  TJERR_FATAL
+};
+
+
+/**
+ * The number of transform operations
+ */
+#define TJ_NUMXOP  8
+
+/**
+ * Transform operations for #tjTransform()
+ */
+enum TJXOP {
+  /**
+   * Do not transform the position of the image pixels
+   */
+  TJXOP_NONE = 0,
+  /**
+   * Flip (mirror) image horizontally.  This transform is imperfect if there
+   * are any partial MCU blocks on the right edge (see #TJXOPT_PERFECT.)
+   */
+  TJXOP_HFLIP,
+  /**
+   * Flip (mirror) image vertically.  This transform is imperfect if there are
+   * any partial MCU blocks on the bottom edge (see #TJXOPT_PERFECT.)
+   */
+  TJXOP_VFLIP,
+  /**
+   * Transpose image (flip/mirror along upper left to lower right axis.)  This
+   * transform is always perfect.
+   */
+  TJXOP_TRANSPOSE,
+  /**
+   * Transverse transpose image (flip/mirror along upper right to lower left
+   * axis.)  This transform is imperfect if there are any partial MCU blocks in
+   * the image (see #TJXOPT_PERFECT.)
+   */
+  TJXOP_TRANSVERSE,
+  /**
+   * Rotate image clockwise by 90 degrees.  This transform is imperfect if
+   * there are any partial MCU blocks on the bottom edge (see
+   * #TJXOPT_PERFECT.)
+   */
+  TJXOP_ROT90,
+  /**
+   * Rotate image 180 degrees.  This transform is imperfect if there are any
+   * partial MCU blocks in the image (see #TJXOPT_PERFECT.)
+   */
+  TJXOP_ROT180,
+  /**
+   * Rotate image counter-clockwise by 90 degrees.  This transform is imperfect
+   * if there are any partial MCU blocks on the right edge (see
+   * #TJXOPT_PERFECT.)
+   */
+  TJXOP_ROT270
+};
+
+
+/**
+ * This option will cause #tjTransform() to return an error if the transform is
+ * not perfect.  Lossless transforms operate on MCU blocks, whose size depends
+ * on the level of chrominance subsampling used (see #tjMCUWidth
+ * and #tjMCUHeight.)  If the image's width or height is not evenly divisible
+ * by the MCU block size, then there will be partial MCU blocks on the right
+ * and/or bottom edges.  It is not possible to move these partial MCU blocks to
+ * the top or left of the image, so any transform that would require that is
+ * "imperfect."  If this option is not specified, then any partial MCU blocks
+ * that cannot be transformed will be left in place, which will create
+ * odd-looking strips on the right or bottom edge of the image.
+ */
+#define TJXOPT_PERFECT  1
+/**
+ * This option will cause #tjTransform() to discard any partial MCU blocks that
+ * cannot be transformed.
+ */
+#define TJXOPT_TRIM  2
+/**
+ * This option will enable lossless cropping.  See #tjTransform() for more
+ * information.
+ */
+#define TJXOPT_CROP  4
+/**
+ * This option will discard the color data in the input image and produce
+ * a grayscale output image.
+ */
+#define TJXOPT_GRAY  8
+/**
+ * This option will prevent #tjTransform() from outputting a JPEG image for
+ * this particular transform (this can be used in conjunction with a custom
+ * filter to capture the transformed DCT coefficients without transcoding
+ * them.)
+ */
+#define TJXOPT_NOOUTPUT  16
+/**
+ * This option will enable progressive entropy coding in the output image
+ * generated by this particular transform.  Progressive entropy coding will
+ * generally improve compression relative to baseline entropy coding (the
+ * default), but it will reduce compression and decompression performance
+ * considerably.
+ */
+#define TJXOPT_PROGRESSIVE  32
+/**
+ * This option will prevent #tjTransform() from copying any extra markers
+ * (including EXIF and ICC profile data) from the source image to the output
+ * image.
+ */
+#define TJXOPT_COPYNONE  64
+
+
+/**
+ * Scaling factor
+ */
+typedef struct {
+  /**
+   * Numerator
+   */
+  int num;
+  /**
+   * Denominator
+   */
+  int denom;
+} tjscalingfactor;
+
+/**
+ * Cropping region
+ */
+typedef struct {
+  /**
+   * The left boundary of the cropping region.  This must be evenly divisible
+   * by the MCU block width (see #tjMCUWidth.)
+   */
+  int x;
+  /**
+   * The upper boundary of the cropping region.  This must be evenly divisible
+   * by the MCU block height (see #tjMCUHeight.)
+   */
+  int y;
+  /**
+   * The width of the cropping region. Setting this to 0 is the equivalent of
+   * setting it to the width of the source JPEG image - x.
+   */
+  int w;
+  /**
+   * The height of the cropping region. Setting this to 0 is the equivalent of
+   * setting it to the height of the source JPEG image - y.
+   */
+  int h;
+} tjregion;
+
+/**
+ * Lossless transform
+ */
+typedef struct tjtransform {
+  /**
+   * Cropping region
+   */
+  tjregion r;
+  /**
+   * One of the @ref TJXOP "transform operations"
+   */
+  int op;
+  /**
+   * The bitwise OR of one of more of the @ref TJXOPT_CROP "transform options"
+   */
+  int options;
+  /**
+   * Arbitrary data that can be accessed within the body of the callback
+   * function
+   */
+  void *data;
+  /**
+   * A callback function that can be used to modify the DCT coefficients
+   * after they are losslessly transformed but before they are transcoded to a
+   * new JPEG image.  This allows for custom filters or other transformations
+   * to be applied in the frequency domain.
+   *
+   * @param coeffs pointer to an array of transformed DCT coefficients.  (NOTE:
+   * this pointer is not guaranteed to be valid once the callback returns, so
+   * applications wishing to hand off the DCT coefficients to another function
+   * or library should make a copy of them within the body of the callback.)
+   *
+   * @param arrayRegion #tjregion structure containing the width and height of
+   * the array pointed to by <tt>coeffs</tt> as well as its offset relative to
+   * the component plane.  TurboJPEG implementations may choose to split each
+   * component plane into multiple DCT coefficient arrays and call the callback
+   * function once for each array.
+   *
+   * @param planeRegion #tjregion structure containing the width and height of
+   * the component plane to which <tt>coeffs</tt> belongs
+   *
+   * @param componentID ID number of the component plane to which
+   * <tt>coeffs</tt> belongs (Y, Cb, and Cr have, respectively, ID's of 0, 1,
+   * and 2 in typical JPEG images.)
+   *
+   * @param transformID ID number of the transformed image to which
+   * <tt>coeffs</tt> belongs.  This is the same as the index of the transform
+   * in the <tt>transforms</tt> array that was passed to #tjTransform().
+   *
+   * @param transform a pointer to a #tjtransform structure that specifies the
+   * parameters and/or cropping region for this transform
+   *
+   * @return 0 if the callback was successful, or -1 if an error occurred.
+   */
+  int (*customFilter) (short *coeffs, tjregion arrayRegion,
+                       tjregion planeRegion, int componentIndex,
+                       int transformIndex, struct tjtransform *transform);
+} tjtransform;
+
+/**
+ * TurboJPEG instance handle
+ */
+typedef void *tjhandle;
+
+
+/**
+ * Pad the given width to the nearest 32-bit boundary
+ */
+#define TJPAD(width)  (((width) + 3) & (~3))
+
+/**
+ * Compute the scaled value of <tt>dimension</tt> using the given scaling
+ * factor.  This macro performs the integer equivalent of <tt>ceil(dimension *
+ * scalingFactor)</tt>.
+ */
+#define TJSCALED(dimension, scalingFactor) \
+  ((dimension * scalingFactor.num + scalingFactor.denom - 1) / \
+   scalingFactor.denom)
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/**
+ * Create a TurboJPEG compressor instance.
+ *
+ * @return a handle to the newly-created instance, or NULL if an error
+ * occurred (see #tjGetErrorStr2().)
+ */
+DLLEXPORT tjhandle tjInitCompress(void);
+
+
+/**
+ * Compress an RGB, grayscale, or CMYK image into a JPEG image.
+ *
+ * @param handle a handle to a TurboJPEG compressor or transformer instance
+ *
+ * @param srcBuf pointer to an image buffer containing RGB, grayscale, or
+ * CMYK pixels to be compressed
+ *
+ * @param width width (in pixels) of the source image
+ *
+ * @param pitch bytes per line in the source image.  Normally, this should be
+ * <tt>width * #tjPixelSize[pixelFormat]</tt> if the image is unpadded, or
+ * <tt>#TJPAD(width * #tjPixelSize[pixelFormat])</tt> if each line of the image
+ * is padded to the nearest 32-bit boundary, as is the case for Windows
+ * bitmaps.  You can also be clever and use this parameter to skip lines, etc.
+ * Setting this parameter to 0 is the equivalent of setting it to
+ * <tt>width * #tjPixelSize[pixelFormat]</tt>.
+ *
+ * @param height height (in pixels) of the source image
+ *
+ * @param pixelFormat pixel format of the source image (see @ref TJPF
+ * "Pixel formats".)
+ *
+ * @param jpegBuf address of a pointer to an image buffer that will receive the
+ * JPEG image.  TurboJPEG has the ability to reallocate the JPEG buffer
+ * to accommodate the size of the JPEG image.  Thus, you can choose to:
+ * -# pre-allocate the JPEG buffer with an arbitrary size using #tjAlloc() and
+ * let TurboJPEG grow the buffer as needed,
+ * -# set <tt>*jpegBuf</tt> to NULL to tell TurboJPEG to allocate the buffer
+ * for you, or
+ * -# pre-allocate the buffer to a "worst case" size determined by calling
+ * #tjBufSize().  This should ensure that the buffer never has to be
+ * re-allocated (setting #TJFLAG_NOREALLOC guarantees that it won't be.)
+ * .
+ * If you choose option 1, <tt>*jpegSize</tt> should be set to the size of your
+ * pre-allocated buffer.  In any case, unless you have set #TJFLAG_NOREALLOC,
+ * you should always check <tt>*jpegBuf</tt> upon return from this function, as
+ * it may have changed.
+ *
+ * @param jpegSize pointer to an unsigned long variable that holds the size of
+ * the JPEG image buffer.  If <tt>*jpegBuf</tt> points to a pre-allocated
+ * buffer, then <tt>*jpegSize</tt> should be set to the size of the buffer.
+ * Upon return, <tt>*jpegSize</tt> will contain the size of the JPEG image (in
+ * bytes.)  If <tt>*jpegBuf</tt> points to a JPEG image buffer that is being
+ * reused from a previous call to one of the JPEG compression functions, then
+ * <tt>*jpegSize</tt> is ignored.
+ *
+ * @param jpegSubsamp the level of chrominance subsampling to be used when
+ * generating the JPEG image (see @ref TJSAMP
+ * "Chrominance subsampling options".)
+ *
+ * @param jpegQual the image quality of the generated JPEG image (1 = worst,
+ * 100 = best)
+ *
+ * @param flags the bitwise OR of one or more of the @ref TJFLAG_ACCURATEDCT
+ * "flags"
+ *
+ * @return 0 if successful, or -1 if an error occurred (see #tjGetErrorStr2()
+ * and #tjGetErrorCode().)
+*/
+DLLEXPORT int tjCompress2(tjhandle handle, const unsigned char *srcBuf,
+                          int width, int pitch, int height, int pixelFormat,
+                          unsigned char **jpegBuf, unsigned long *jpegSize,
+                          int jpegSubsamp, int jpegQual, int flags);
+
+
+/**
+ * Compress a YUV planar image into a JPEG image.
+ *
+ * @param handle a handle to a TurboJPEG compressor or transformer instance
+ *
+ * @param srcBuf pointer to an image buffer containing a YUV planar image to be
+ * compressed.  The size of this buffer should match the value returned by
+ * #tjBufSizeYUV2() for the given image width, height, padding, and level of
+ * chrominance subsampling.  The Y, U (Cb), and V (Cr) image planes should be
+ * stored sequentially in the source buffer (refer to @ref YUVnotes
+ * "YUV Image Format Notes".)
+ *
+ * @param width width (in pixels) of the source image.  If the width is not an
+ * even multiple of the MCU block width (see #tjMCUWidth), then an intermediate
+ * buffer copy will be performed within TurboJPEG.
+ *
+ * @param pad the line padding used in the source image.  For instance, if each
+ * line in each plane of the YUV image is padded to the nearest multiple of 4
+ * bytes, then <tt>pad</tt> should be set to 4.
+ *
+ * @param height height (in pixels) of the source image.  If the height is not
+ * an even multiple of the MCU block height (see #tjMCUHeight), then an
+ * intermediate buffer copy will be performed within TurboJPEG.
+ *
+ * @param subsamp the level of chrominance subsampling used in the source
+ * image (see @ref TJSAMP "Chrominance subsampling options".)
+ *
+ * @param jpegBuf address of a pointer to an image buffer that will receive the
+ * JPEG image.  TurboJPEG has the ability to reallocate the JPEG buffer to
+ * accommodate the size of the JPEG image.  Thus, you can choose to:
+ * -# pre-allocate the JPEG buffer with an arbitrary size using #tjAlloc() and
+ * let TurboJPEG grow the buffer as needed,
+ * -# set <tt>*jpegBuf</tt> to NULL to tell TurboJPEG to allocate the buffer
+ * for you, or
+ * -# pre-allocate the buffer to a "worst case" size determined by calling
+ * #tjBufSize().  This should ensure that the buffer never has to be
+ * re-allocated (setting #TJFLAG_NOREALLOC guarantees that it won't be.)
+ * .
+ * If you choose option 1, <tt>*jpegSize</tt> should be set to the size of your
+ * pre-allocated buffer.  In any case, unless you have set #TJFLAG_NOREALLOC,
+ * you should always check <tt>*jpegBuf</tt> upon return from this function, as
+ * it may have changed.
+ *
+ * @param jpegSize pointer to an unsigned long variable that holds the size of
+ * the JPEG image buffer.  If <tt>*jpegBuf</tt> points to a pre-allocated
+ * buffer, then <tt>*jpegSize</tt> should be set to the size of the buffer.
+ * Upon return, <tt>*jpegSize</tt> will contain the size of the JPEG image (in
+ * bytes.)  If <tt>*jpegBuf</tt> points to a JPEG image buffer that is being
+ * reused from a previous call to one of the JPEG compression functions, then
+ * <tt>*jpegSize</tt> is ignored.
+ *
+ * @param jpegQual the image quality of the generated JPEG image (1 = worst,
+ * 100 = best)
+ *
+ * @param flags the bitwise OR of one or more of the @ref TJFLAG_ACCURATEDCT
+ * "flags"
+ *
+ * @return 0 if successful, or -1 if an error occurred (see #tjGetErrorStr2()
+ * and #tjGetErrorCode().)
+*/
+DLLEXPORT int tjCompressFromYUV(tjhandle handle, const unsigned char *srcBuf,
+                                int width, int pad, int height, int subsamp,
+                                unsigned char **jpegBuf,
+                                unsigned long *jpegSize, int jpegQual,
+                                int flags);
+
+
+/**
+ * Compress a set of Y, U (Cb), and V (Cr) image planes into a JPEG image.
+ *
+ * @param handle a handle to a TurboJPEG compressor or transformer instance
+ *
+ * @param srcPlanes an array of pointers to Y, U (Cb), and V (Cr) image planes
+ * (or just a Y plane, if compressing a grayscale image) that contain a YUV
+ * image to be compressed.  These planes can be contiguous or non-contiguous in
+ * memory.  The size of each plane should match the value returned by
+ * #tjPlaneSizeYUV() for the given image width, height, strides, and level of
+ * chrominance subsampling.  Refer to @ref YUVnotes "YUV Image Format Notes"
+ * for more details.
+ *
+ * @param width width (in pixels) of the source image.  If the width is not an
+ * even multiple of the MCU block width (see #tjMCUWidth), then an intermediate
+ * buffer copy will be performed within TurboJPEG.
+ *
+ * @param strides an array of integers, each specifying the number of bytes per
+ * line in the corresponding plane of the YUV source image.  Setting the stride
+ * for any plane to 0 is the same as setting it to the plane width (see
+ * @ref YUVnotes "YUV Image Format Notes".)  If <tt>strides</tt> is NULL, then
+ * the strides for all planes will be set to their respective plane widths.
+ * You can adjust the strides in order to specify an arbitrary amount of line
+ * padding in each plane or to create a JPEG image from a subregion of a larger
+ * YUV planar image.
+ *
+ * @param height height (in pixels) of the source image.  If the height is not
+ * an even multiple of the MCU block height (see #tjMCUHeight), then an
+ * intermediate buffer copy will be performed within TurboJPEG.
+ *
+ * @param subsamp the level of chrominance subsampling used in the source
+ * image (see @ref TJSAMP "Chrominance subsampling options".)
+ *
+ * @param jpegBuf address of a pointer to an image buffer that will receive the
+ * JPEG image.  TurboJPEG has the ability to reallocate the JPEG buffer to
+ * accommodate the size of the JPEG image.  Thus, you can choose to:
+ * -# pre-allocate the JPEG buffer with an arbitrary size using #tjAlloc() and
+ * let TurboJPEG grow the buffer as needed,
+ * -# set <tt>*jpegBuf</tt> to NULL to tell TurboJPEG to allocate the buffer
+ * for you, or
+ * -# pre-allocate the buffer to a "worst case" size determined by calling
+ * #tjBufSize().  This should ensure that the buffer never has to be
+ * re-allocated (setting #TJFLAG_NOREALLOC guarantees that it won't be.)
+ * .
+ * If you choose option 1, <tt>*jpegSize</tt> should be set to the size of your
+ * pre-allocated buffer.  In any case, unless you have set #TJFLAG_NOREALLOC,
+ * you should always check <tt>*jpegBuf</tt> upon return from this function, as
+ * it may have changed.
+ *
+ * @param jpegSize pointer to an unsigned long variable that holds the size of
+ * the JPEG image buffer.  If <tt>*jpegBuf</tt> points to a pre-allocated
+ * buffer, then <tt>*jpegSize</tt> should be set to the size of the buffer.
+ * Upon return, <tt>*jpegSize</tt> will contain the size of the JPEG image (in
+ * bytes.)  If <tt>*jpegBuf</tt> points to a JPEG image buffer that is being
+ * reused from a previous call to one of the JPEG compression functions, then
+ * <tt>*jpegSize</tt> is ignored.
+ *
+ * @param jpegQual the image quality of the generated JPEG image (1 = worst,
+ * 100 = best)
+ *
+ * @param flags the bitwise OR of one or more of the @ref TJFLAG_ACCURATEDCT
+ * "flags"
+ *
+ * @return 0 if successful, or -1 if an error occurred (see #tjGetErrorStr2()
+ * and #tjGetErrorCode().)
+*/
+DLLEXPORT int tjCompressFromYUVPlanes(tjhandle handle,
+                                      const unsigned char **srcPlanes,
+                                      int width, const int *strides,
+                                      int height, int subsamp,
+                                      unsigned char **jpegBuf,
+                                      unsigned long *jpegSize, int jpegQual,
+                                      int flags);
+
+
+/**
+ * The maximum size of the buffer (in bytes) required to hold a JPEG image with
+ * the given parameters.  The number of bytes returned by this function is
+ * larger than the size of the uncompressed source image.  The reason for this
+ * is that the JPEG format uses 16-bit coefficients, and it is thus possible
+ * for a very high-quality JPEG image with very high-frequency content to
+ * expand rather than compress when converted to the JPEG format.  Such images
+ * represent a very rare corner case, but since there is no way to predict the
+ * size of a JPEG image prior to compression, the corner case has to be
+ * handled.
+ *
+ * @param width width (in pixels) of the image
+ *
+ * @param height height (in pixels) of the image
+ *
+ * @param jpegSubsamp the level of chrominance subsampling to be used when
+ * generating the JPEG image (see @ref TJSAMP
+ * "Chrominance subsampling options".)
+ *
+ * @return the maximum size of the buffer (in bytes) required to hold the
+ * image, or -1 if the arguments are out of bounds.
+ */
+DLLEXPORT unsigned long tjBufSize(int width, int height, int jpegSubsamp);
+
+
+/**
+ * The size of the buffer (in bytes) required to hold a YUV planar image with
+ * the given parameters.
+ *
+ * @param width width (in pixels) of the image
+ *
+ * @param pad the width of each line in each plane of the image is padded to
+ * the nearest multiple of this number of bytes (must be a power of 2.)
+ *
+ * @param height height (in pixels) of the image
+ *
+ * @param subsamp level of chrominance subsampling in the image (see
+ * @ref TJSAMP "Chrominance subsampling options".)
+ *
+ * @return the size of the buffer (in bytes) required to hold the image, or
+ * -1 if the arguments are out of bounds.
+ */
+DLLEXPORT unsigned long tjBufSizeYUV2(int width, int pad, int height,
+                                      int subsamp);
+
+
+/**
+ * The size of the buffer (in bytes) required to hold a YUV image plane with
+ * the given parameters.
+ *
+ * @param componentID ID number of the image plane (0 = Y, 1 = U/Cb, 2 = V/Cr)
+ *
+ * @param width width (in pixels) of the YUV image.  NOTE: this is the width of
+ * the whole image, not the plane width.
+ *
+ * @param stride bytes per line in the image plane.  Setting this to 0 is the
+ * equivalent of setting it to the plane width.
+ *
+ * @param height height (in pixels) of the YUV image.  NOTE: this is the height
+ * of the whole image, not the plane height.
+ *
+ * @param subsamp level of chrominance subsampling in the image (see
+ * @ref TJSAMP "Chrominance subsampling options".)
+ *
+ * @return the size of the buffer (in bytes) required to hold the YUV image
+ * plane, or -1 if the arguments are out of bounds.
+ */
+DLLEXPORT unsigned long tjPlaneSizeYUV(int componentID, int width, int stride,
+                                       int height, int subsamp);
+
+
+/**
+ * The plane width of a YUV image plane with the given parameters.  Refer to
+ * @ref YUVnotes "YUV Image Format Notes" for a description of plane width.
+ *
+ * @param componentID ID number of the image plane (0 = Y, 1 = U/Cb, 2 = V/Cr)
+ *
+ * @param width width (in pixels) of the YUV image
+ *
+ * @param subsamp level of chrominance subsampling in the image (see
+ * @ref TJSAMP "Chrominance subsampling options".)
+ *
+ * @return the plane width of a YUV image plane with the given parameters, or
+ * -1 if the arguments are out of bounds.
+ */
+DLLEXPORT int tjPlaneWidth(int componentID, int width, int subsamp);
+
+
+/**
+ * The plane height of a YUV image plane with the given parameters.  Refer to
+ * @ref YUVnotes "YUV Image Format Notes" for a description of plane height.
+ *
+ * @param componentID ID number of the image plane (0 = Y, 1 = U/Cb, 2 = V/Cr)
+ *
+ * @param height height (in pixels) of the YUV image
+ *
+ * @param subsamp level of chrominance subsampling in the image (see
+ * @ref TJSAMP "Chrominance subsampling options".)
+ *
+ * @return the plane height of a YUV image plane with the given parameters, or
+ * -1 if the arguments are out of bounds.
+ */
+DLLEXPORT int tjPlaneHeight(int componentID, int height, int subsamp);
+
+
+/**
+ * Encode an RGB or grayscale image into a YUV planar image.  This function
+ * uses the accelerated color conversion routines in the underlying
+ * codec but does not execute any of the other steps in the JPEG compression
+ * process.
+ *
+ * @param handle a handle to a TurboJPEG compressor or transformer instance
+ *
+ * @param srcBuf pointer to an image buffer containing RGB or grayscale pixels
+ * to be encoded
+ *
+ * @param width width (in pixels) of the source image
+ *
+ * @param pitch bytes per line in the source image.  Normally, this should be
+ * <tt>width * #tjPixelSize[pixelFormat]</tt> if the image is unpadded, or
+ * <tt>#TJPAD(width * #tjPixelSize[pixelFormat])</tt> if each line of the image
+ * is padded to the nearest 32-bit boundary, as is the case for Windows
+ * bitmaps.  You can also be clever and use this parameter to skip lines, etc.
+ * Setting this parameter to 0 is the equivalent of setting it to
+ * <tt>width * #tjPixelSize[pixelFormat]</tt>.
+ *
+ * @param height height (in pixels) of the source image
+ *
+ * @param pixelFormat pixel format of the source image (see @ref TJPF
+ * "Pixel formats".)
+ *
+ * @param dstBuf pointer to an image buffer that will receive the YUV image.
+ * Use #tjBufSizeYUV2() to determine the appropriate size for this buffer based
+ * on the image width, height, padding, and level of chrominance subsampling.
+ * The Y, U (Cb), and V (Cr) image planes will be stored sequentially in the
+ * buffer (refer to @ref YUVnotes "YUV Image Format Notes".)
+ *
+ * @param pad the width of each line in each plane of the YUV image will be
+ * padded to the nearest multiple of this number of bytes (must be a power of
+ * 2.)  To generate images suitable for X Video, <tt>pad</tt> should be set to
+ * 4.
+ *
+ * @param subsamp the level of chrominance subsampling to be used when
+ * generating the YUV image (see @ref TJSAMP
+ * "Chrominance subsampling options".)  To generate images suitable for X
+ * Video, <tt>subsamp</tt> should be set to @ref TJSAMP_420.  This produces an
+ * image compatible with the I420 (AKA "YUV420P") format.
+ *
+ * @param flags the bitwise OR of one or more of the @ref TJFLAG_ACCURATEDCT
+ * "flags"
+ *
+ * @return 0 if successful, or -1 if an error occurred (see #tjGetErrorStr2()
+ * and #tjGetErrorCode().)
+*/
+DLLEXPORT int tjEncodeYUV3(tjhandle handle, const unsigned char *srcBuf,
+                           int width, int pitch, int height, int pixelFormat,
+                           unsigned char *dstBuf, int pad, int subsamp,
+                           int flags);
+
+
+/**
+ * Encode an RGB or grayscale image into separate Y, U (Cb), and V (Cr) image
+ * planes.  This function uses the accelerated color conversion routines in the
+ * underlying codec but does not execute any of the other steps in the JPEG
+ * compression process.
+ *
+ * @param handle a handle to a TurboJPEG compressor or transformer instance
+ *
+ * @param srcBuf pointer to an image buffer containing RGB or grayscale pixels
+ * to be encoded
+ *
+ * @param width width (in pixels) of the source image
+ *
+ * @param pitch bytes per line in the source image.  Normally, this should be
+ * <tt>width * #tjPixelSize[pixelFormat]</tt> if the image is unpadded, or
+ * <tt>#TJPAD(width * #tjPixelSize[pixelFormat])</tt> if each line of the image
+ * is padded to the nearest 32-bit boundary, as is the case for Windows
+ * bitmaps.  You can also be clever and use this parameter to skip lines, etc.
+ * Setting this parameter to 0 is the equivalent of setting it to
+ * <tt>width * #tjPixelSize[pixelFormat]</tt>.
+ *
+ * @param height height (in pixels) of the source image
+ *
+ * @param pixelFormat pixel format of the source image (see @ref TJPF
+ * "Pixel formats".)
+ *
+ * @param dstPlanes an array of pointers to Y, U (Cb), and V (Cr) image planes
+ * (or just a Y plane, if generating a grayscale image) that will receive the
+ * encoded image.  These planes can be contiguous or non-contiguous in memory.
+ * Use #tjPlaneSizeYUV() to determine the appropriate size for each plane based
+ * on the image width, height, strides, and level of chrominance subsampling.
+ * Refer to @ref YUVnotes "YUV Image Format Notes" for more details.
+ *
+ * @param strides an array of integers, each specifying the number of bytes per
+ * line in the corresponding plane of the output image.  Setting the stride for
+ * any plane to 0 is the same as setting it to the plane width (see
+ * @ref YUVnotes "YUV Image Format Notes".)  If <tt>strides</tt> is NULL, then
+ * the strides for all planes will be set to their respective plane widths.
+ * You can adjust the strides in order to add an arbitrary amount of line
+ * padding to each plane or to encode an RGB or grayscale image into a
+ * subregion of a larger YUV planar image.
+ *
+ * @param subsamp the level of chrominance subsampling to be used when
+ * generating the YUV image (see @ref TJSAMP
+ * "Chrominance subsampling options".)  To generate images suitable for X
+ * Video, <tt>subsamp</tt> should be set to @ref TJSAMP_420.  This produces an
+ * image compatible with the I420 (AKA "YUV420P") format.
+ *
+ * @param flags the bitwise OR of one or more of the @ref TJFLAG_ACCURATEDCT
+ * "flags"
+ *
+ * @return 0 if successful, or -1 if an error occurred (see #tjGetErrorStr2()
+ * and #tjGetErrorCode().)
+*/
+DLLEXPORT int tjEncodeYUVPlanes(tjhandle handle, const unsigned char *srcBuf,
+                                int width, int pitch, int height,
+                                int pixelFormat, unsigned char **dstPlanes,
+                                int *strides, int subsamp, int flags);
+
+
+/**
+ * Create a TurboJPEG decompressor instance.
+ *
+ * @return a handle to the newly-created instance, or NULL if an error
+ * occurred (see #tjGetErrorStr2().)
+*/
+DLLEXPORT tjhandle tjInitDecompress(void);
+
+
+/**
+ * Retrieve information about a JPEG image without decompressing it.
+ *
+ * @param handle a handle to a TurboJPEG decompressor or transformer instance
+ *
+ * @param jpegBuf pointer to a buffer containing a JPEG image
+ *
+ * @param jpegSize size of the JPEG image (in bytes)
+ *
+ * @param width pointer to an integer variable that will receive the width (in
+ * pixels) of the JPEG image
+ *
+ * @param height pointer to an integer variable that will receive the height
+ * (in pixels) of the JPEG image
+ *
+ * @param jpegSubsamp pointer to an integer variable that will receive the
+ * level of chrominance subsampling used when the JPEG image was compressed
+ * (see @ref TJSAMP "Chrominance subsampling options".)
+ *
+ * @param jpegColorspace pointer to an integer variable that will receive one
+ * of the JPEG colorspace constants, indicating the colorspace of the JPEG
+ * image (see @ref TJCS "JPEG colorspaces".)
+ *
+ * @return 0 if successful, or -1 if an error occurred (see #tjGetErrorStr2()
+ * and #tjGetErrorCode().)
+*/
+DLLEXPORT int tjDecompressHeader3(tjhandle handle,
+                                  const unsigned char *jpegBuf,
+                                  unsigned long jpegSize, int *width,
+                                  int *height, int *jpegSubsamp,
+                                  int *jpegColorspace);
+
+
+/**
+ * Returns a list of fractional scaling factors that the JPEG decompressor in
+ * this implementation of TurboJPEG supports.
+ *
+ * @param numscalingfactors pointer to an integer variable that will receive
+ * the number of elements in the list
+ *
+ * @return a pointer to a list of fractional scaling factors, or NULL if an
+ * error is encountered (see #tjGetErrorStr2().)
+*/
+DLLEXPORT tjscalingfactor *tjGetScalingFactors(int *numscalingfactors);
+
+
+/**
+ * Decompress a JPEG image to an RGB, grayscale, or CMYK image.
+ *
+ * @param handle a handle to a TurboJPEG decompressor or transformer instance
+ *
+ * @param jpegBuf pointer to a buffer containing the JPEG image to decompress
+ *
+ * @param jpegSize size of the JPEG image (in bytes)
+ *
+ * @param dstBuf pointer to an image buffer that will receive the decompressed
+ * image.  This buffer should normally be <tt>pitch * scaledHeight</tt> bytes
+ * in size, where <tt>scaledHeight</tt> can be determined by calling
+ * #TJSCALED() with the JPEG image height and one of the scaling factors
+ * returned by #tjGetScalingFactors().  The <tt>dstBuf</tt> pointer may also be
+ * used to decompress into a specific region of a larger buffer.
+ *
+ * @param width desired width (in pixels) of the destination image.  If this is
+ * different than the width of the JPEG image being decompressed, then
+ * TurboJPEG will use scaling in the JPEG decompressor to generate the largest
+ * possible image that will fit within the desired width.  If <tt>width</tt> is
+ * set to 0, then only the height will be considered when determining the
+ * scaled image size.
+ *
+ * @param pitch bytes per line in the destination image.  Normally, this is
+ * <tt>scaledWidth * #tjPixelSize[pixelFormat]</tt> if the decompressed image
+ * is unpadded, else <tt>#TJPAD(scaledWidth * #tjPixelSize[pixelFormat])</tt>
+ * if each line of the decompressed image is padded to the nearest 32-bit
+ * boundary, as is the case for Windows bitmaps.  (NOTE: <tt>scaledWidth</tt>
+ * can be determined by calling #TJSCALED() with the JPEG image width and one
+ * of the scaling factors returned by #tjGetScalingFactors().)  You can also be
+ * clever and use the pitch parameter to skip lines, etc.  Setting this
+ * parameter to 0 is the equivalent of setting it to
+ * <tt>scaledWidth * #tjPixelSize[pixelFormat]</tt>.
+ *
+ * @param height desired height (in pixels) of the destination image.  If this
+ * is different than the height of the JPEG image being decompressed, then
+ * TurboJPEG will use scaling in the JPEG decompressor to generate the largest
+ * possible image that will fit within the desired height.  If <tt>height</tt>
+ * is set to 0, then only the width will be considered when determining the
+ * scaled image size.
+ *
+ * @param pixelFormat pixel format of the destination image (see @ref
+ * TJPF "Pixel formats".)
+ *
+ * @param flags the bitwise OR of one or more of the @ref TJFLAG_ACCURATEDCT
+ * "flags"
+ *
+ * @return 0 if successful, or -1 if an error occurred (see #tjGetErrorStr2()
+ * and #tjGetErrorCode().)
+ */
+DLLEXPORT int tjDecompress2(tjhandle handle, const unsigned char *jpegBuf,
+                            unsigned long jpegSize, unsigned char *dstBuf,
+                            int width, int pitch, int height, int pixelFormat,
+                            int flags);
+
+
+/**
+ * Decompress a JPEG image to a YUV planar image.  This function performs JPEG
+ * decompression but leaves out the color conversion step, so a planar YUV
+ * image is generated instead of an RGB image.
+ *
+ * @param handle a handle to a TurboJPEG decompressor or transformer instance
+ *
+ * @param jpegBuf pointer to a buffer containing the JPEG image to decompress
+ *
+ * @param jpegSize size of the JPEG image (in bytes)
+ *
+ * @param dstBuf pointer to an image buffer that will receive the YUV image.
+ * Use #tjBufSizeYUV2() to determine the appropriate size for this buffer based
+ * on the image width, height, padding, and level of subsampling.  The Y,
+ * U (Cb), and V (Cr) image planes will be stored sequentially in the buffer
+ * (refer to @ref YUVnotes "YUV Image Format Notes".)
+ *
+ * @param width desired width (in pixels) of the YUV image.  If this is
+ * different than the width of the JPEG image being decompressed, then
+ * TurboJPEG will use scaling in the JPEG decompressor to generate the largest
+ * possible image that will fit within the desired width.  If <tt>width</tt> is
+ * set to 0, then only the height will be considered when determining the
+ * scaled image size.  If the scaled width is not an even multiple of the MCU
+ * block width (see #tjMCUWidth), then an intermediate buffer copy will be
+ * performed within TurboJPEG.
+ *
+ * @param pad the width of each line in each plane of the YUV image will be
+ * padded to the nearest multiple of this number of bytes (must be a power of
+ * 2.)  To generate images suitable for X Video, <tt>pad</tt> should be set to
+ * 4.
+ *
+ * @param height desired height (in pixels) of the YUV image.  If this is
+ * different than the height of the JPEG image being decompressed, then
+ * TurboJPEG will use scaling in the JPEG decompressor to generate the largest
+ * possible image that will fit within the desired height.  If <tt>height</tt>
+ * is set to 0, then only the width will be considered when determining the
+ * scaled image size.  If the scaled height is not an even multiple of the MCU
+ * block height (see #tjMCUHeight), then an intermediate buffer copy will be
+ * performed within TurboJPEG.
+ *
+ * @param flags the bitwise OR of one or more of the @ref TJFLAG_ACCURATEDCT
+ * "flags"
+ *
+ * @return 0 if successful, or -1 if an error occurred (see #tjGetErrorStr2()
+ * and #tjGetErrorCode().)
+ */
+DLLEXPORT int tjDecompressToYUV2(tjhandle handle, const unsigned char *jpegBuf,
+                                 unsigned long jpegSize, unsigned char *dstBuf,
+                                 int width, int pad, int height, int flags);
+
+
+/**
+ * Decompress a JPEG image into separate Y, U (Cb), and V (Cr) image
+ * planes.  This function performs JPEG decompression but leaves out the color
+ * conversion step, so a planar YUV image is generated instead of an RGB image.
+ *
+ * @param handle a handle to a TurboJPEG decompressor or transformer instance
+ *
+ * @param jpegBuf pointer to a buffer containing the JPEG image to decompress
+ *
+ * @param jpegSize size of the JPEG image (in bytes)
+ *
+ * @param dstPlanes an array of pointers to Y, U (Cb), and V (Cr) image planes
+ * (or just a Y plane, if decompressing a grayscale image) that will receive
+ * the YUV image.  These planes can be contiguous or non-contiguous in memory.
+ * Use #tjPlaneSizeYUV() to determine the appropriate size for each plane based
+ * on the scaled image width, scaled image height, strides, and level of
+ * chrominance subsampling.  Refer to @ref YUVnotes "YUV Image Format Notes"
+ * for more details.
+ *
+ * @param width desired width (in pixels) of the YUV image.  If this is
+ * different than the width of the JPEG image being decompressed, then
+ * TurboJPEG will use scaling in the JPEG decompressor to generate the largest
+ * possible image that will fit within the desired width.  If <tt>width</tt> is
+ * set to 0, then only the height will be considered when determining the
+ * scaled image size.  If the scaled width is not an even multiple of the MCU
+ * block width (see #tjMCUWidth), then an intermediate buffer copy will be
+ * performed within TurboJPEG.
+ *
+ * @param strides an array of integers, each specifying the number of bytes per
+ * line in the corresponding plane of the output image.  Setting the stride for
+ * any plane to 0 is the same as setting it to the scaled plane width (see
+ * @ref YUVnotes "YUV Image Format Notes".)  If <tt>strides</tt> is NULL, then
+ * the strides for all planes will be set to their respective scaled plane
+ * widths.  You can adjust the strides in order to add an arbitrary amount of
+ * line padding to each plane or to decompress the JPEG image into a subregion
+ * of a larger YUV planar image.
+ *
+ * @param height desired height (in pixels) of the YUV image.  If this is
+ * different than the height of the JPEG image being decompressed, then
+ * TurboJPEG will use scaling in the JPEG decompressor to generate the largest
+ * possible image that will fit within the desired height.  If <tt>height</tt>
+ * is set to 0, then only the width will be considered when determining the
+ * scaled image size.  If the scaled height is not an even multiple of the MCU
+ * block height (see #tjMCUHeight), then an intermediate buffer copy will be
+ * performed within TurboJPEG.
+ *
+ * @param flags the bitwise OR of one or more of the @ref TJFLAG_ACCURATEDCT
+ * "flags"
+ *
+ * @return 0 if successful, or -1 if an error occurred (see #tjGetErrorStr2()
+ * and #tjGetErrorCode().)
+ */
+DLLEXPORT int tjDecompressToYUVPlanes(tjhandle handle,
+                                      const unsigned char *jpegBuf,
+                                      unsigned long jpegSize,
+                                      unsigned char **dstPlanes, int width,
+                                      int *strides, int height, int flags);
+
+
+/**
+ * Decode a YUV planar image into an RGB or grayscale image.  This function
+ * uses the accelerated color conversion routines in the underlying
+ * codec but does not execute any of the other steps in the JPEG decompression
+ * process.
+ *
+ * @param handle a handle to a TurboJPEG decompressor or transformer instance
+ *
+ * @param srcBuf pointer to an image buffer containing a YUV planar image to be
+ * decoded.  The size of this buffer should match the value returned by
+ * #tjBufSizeYUV2() for the given image width, height, padding, and level of
+ * chrominance subsampling.  The Y, U (Cb), and V (Cr) image planes should be
+ * stored sequentially in the source buffer (refer to @ref YUVnotes
+ * "YUV Image Format Notes".)
+ *
+ * @param pad Use this parameter to specify that the width of each line in each
+ * plane of the YUV source image is padded to the nearest multiple of this
+ * number of bytes (must be a power of 2.)
+ *
+ * @param subsamp the level of chrominance subsampling used in the YUV source
+ * image (see @ref TJSAMP "Chrominance subsampling options".)
+ *
+ * @param dstBuf pointer to an image buffer that will receive the decoded
+ * image.  This buffer should normally be <tt>pitch * height</tt> bytes in
+ * size, but the <tt>dstBuf</tt> pointer can also be used to decode into a
+ * specific region of a larger buffer.
+ *
+ * @param width width (in pixels) of the source and destination images
+ *
+ * @param pitch bytes per line in the destination image.  Normally, this should
+ * be <tt>width * #tjPixelSize[pixelFormat]</tt> if the destination image is
+ * unpadded, or <tt>#TJPAD(width * #tjPixelSize[pixelFormat])</tt> if each line
+ * of the destination image should be padded to the nearest 32-bit boundary, as
+ * is the case for Windows bitmaps.  You can also be clever and use the pitch
+ * parameter to skip lines, etc.  Setting this parameter to 0 is the equivalent
+ * of setting it to <tt>width * #tjPixelSize[pixelFormat]</tt>.
+ *
+ * @param height height (in pixels) of the source and destination images
+ *
+ * @param pixelFormat pixel format of the destination image (see @ref TJPF
+ * "Pixel formats".)
+ *
+ * @param flags the bitwise OR of one or more of the @ref TJFLAG_ACCURATEDCT
+ * "flags"
+ *
+ * @return 0 if successful, or -1 if an error occurred (see #tjGetErrorStr2()
+ * and #tjGetErrorCode().)
+ */
+DLLEXPORT int tjDecodeYUV(tjhandle handle, const unsigned char *srcBuf,
+                          int pad, int subsamp, unsigned char *dstBuf,
+                          int width, int pitch, int height, int pixelFormat,
+                          int flags);
+
+
+/**
+ * Decode a set of Y, U (Cb), and V (Cr) image planes into an RGB or grayscale
+ * image.  This function uses the accelerated color conversion routines in the
+ * underlying codec but does not execute any of the other steps in the JPEG
+ * decompression process.
+ *
+ * @param handle a handle to a TurboJPEG decompressor or transformer instance
+ *
+ * @param srcPlanes an array of pointers to Y, U (Cb), and V (Cr) image planes
+ * (or just a Y plane, if decoding a grayscale image) that contain a YUV image
+ * to be decoded.  These planes can be contiguous or non-contiguous in memory.
+ * The size of each plane should match the value returned by #tjPlaneSizeYUV()
+ * for the given image width, height, strides, and level of chrominance
+ * subsampling.  Refer to @ref YUVnotes "YUV Image Format Notes" for more
+ * details.
+ *
+ * @param strides an array of integers, each specifying the number of bytes per
+ * line in the corresponding plane of the YUV source image.  Setting the stride
+ * for any plane to 0 is the same as setting it to the plane width (see
+ * @ref YUVnotes "YUV Image Format Notes".)  If <tt>strides</tt> is NULL, then
+ * the strides for all planes will be set to their respective plane widths.
+ * You can adjust the strides in order to specify an arbitrary amount of line
+ * padding in each plane or to decode a subregion of a larger YUV planar image.
+ *
+ * @param subsamp the level of chrominance subsampling used in the YUV source
+ * image (see @ref TJSAMP "Chrominance subsampling options".)
+ *
+ * @param dstBuf pointer to an image buffer that will receive the decoded
+ * image.  This buffer should normally be <tt>pitch * height</tt> bytes in
+ * size, but the <tt>dstBuf</tt> pointer can also be used to decode into a
+ * specific region of a larger buffer.
+ *
+ * @param width width (in pixels) of the source and destination images
+ *
+ * @param pitch bytes per line in the destination image.  Normally, this should
+ * be <tt>width * #tjPixelSize[pixelFormat]</tt> if the destination image is
+ * unpadded, or <tt>#TJPAD(width * #tjPixelSize[pixelFormat])</tt> if each line
+ * of the destination image should be padded to the nearest 32-bit boundary, as
+ * is the case for Windows bitmaps.  You can also be clever and use the pitch
+ * parameter to skip lines, etc.  Setting this parameter to 0 is the equivalent
+ * of setting it to <tt>width * #tjPixelSize[pixelFormat]</tt>.
+ *
+ * @param height height (in pixels) of the source and destination images
+ *
+ * @param pixelFormat pixel format of the destination image (see @ref TJPF
+ * "Pixel formats".)
+ *
+ * @param flags the bitwise OR of one or more of the @ref TJFLAG_ACCURATEDCT
+ * "flags"
+ *
+ * @return 0 if successful, or -1 if an error occurred (see #tjGetErrorStr2()
+ * and #tjGetErrorCode().)
+ */
+DLLEXPORT int tjDecodeYUVPlanes(tjhandle handle,
+                                const unsigned char **srcPlanes,
+                                const int *strides, int subsamp,
+                                unsigned char *dstBuf, int width, int pitch,
+                                int height, int pixelFormat, int flags);
+
+
+/**
+ * Create a new TurboJPEG transformer instance.
+ *
+ * @return a handle to the newly-created instance, or NULL if an error
+ * occurred (see #tjGetErrorStr2().)
+ */
+DLLEXPORT tjhandle tjInitTransform(void);
+
+
+/**
+ * Losslessly transform a JPEG image into another JPEG image.  Lossless
+ * transforms work by moving the raw DCT coefficients from one JPEG image
+ * structure to another without altering the values of the coefficients.  While
+ * this is typically faster than decompressing the image, transforming it, and
+ * re-compressing it, lossless transforms are not free.  Each lossless
+ * transform requires reading and performing Huffman decoding on all of the
+ * coefficients in the source image, regardless of the size of the destination
+ * image.  Thus, this function provides a means of generating multiple
+ * transformed images from the same source or  applying multiple
+ * transformations simultaneously, in order to eliminate the need to read the
+ * source coefficients multiple times.
+ *
+ * @param handle a handle to a TurboJPEG transformer instance
+ *
+ * @param jpegBuf pointer to a buffer containing the JPEG source image to
+ * transform
+ *
+ * @param jpegSize size of the JPEG source image (in bytes)
+ *
+ * @param n the number of transformed JPEG images to generate
+ *
+ * @param dstBufs pointer to an array of n image buffers.  <tt>dstBufs[i]</tt>
+ * will receive a JPEG image that has been transformed using the parameters in
+ * <tt>transforms[i]</tt>.  TurboJPEG has the ability to reallocate the JPEG
+ * buffer to accommodate the size of the JPEG image.  Thus, you can choose to:
+ * -# pre-allocate the JPEG buffer with an arbitrary size using #tjAlloc() and
+ * let TurboJPEG grow the buffer as needed,
+ * -# set <tt>dstBufs[i]</tt> to NULL to tell TurboJPEG to allocate the buffer
+ * for you, or
+ * -# pre-allocate the buffer to a "worst case" size determined by calling
+ * #tjBufSize() with the transformed or cropped width and height.  Under normal
+ * circumstances, this should ensure that the buffer never has to be
+ * re-allocated (setting #TJFLAG_NOREALLOC guarantees that it won't be.)  Note,
+ * however, that there are some rare cases (such as transforming images with a
+ * large amount of embedded EXIF or ICC profile data) in which the output image
+ * will be larger than the worst-case size, and #TJFLAG_NOREALLOC cannot be
+ * used in those cases.
+ * .
+ * If you choose option 1, <tt>dstSizes[i]</tt> should be set to the size of
+ * your pre-allocated buffer.  In any case, unless you have set
+ * #TJFLAG_NOREALLOC, you should always check <tt>dstBufs[i]</tt> upon return
+ * from this function, as it may have changed.
+ *
+ * @param dstSizes pointer to an array of n unsigned long variables that will
+ * receive the actual sizes (in bytes) of each transformed JPEG image.  If
+ * <tt>dstBufs[i]</tt> points to a pre-allocated buffer, then
+ * <tt>dstSizes[i]</tt> should be set to the size of the buffer.  Upon return,
+ * <tt>dstSizes[i]</tt> will contain the size of the JPEG image (in bytes.)
+ *
+ * @param transforms pointer to an array of n #tjtransform structures, each of
+ * which specifies the transform parameters and/or cropping region for the
+ * corresponding transformed output image.
+ *
+ * @param flags the bitwise OR of one or more of the @ref TJFLAG_ACCURATEDCT
+ * "flags"
+ *
+ * @return 0 if successful, or -1 if an error occurred (see #tjGetErrorStr2()
+ * and #tjGetErrorCode().)
+ */
+DLLEXPORT int tjTransform(tjhandle handle, const unsigned char *jpegBuf,
+                          unsigned long jpegSize, int n,
+                          unsigned char **dstBufs, unsigned long *dstSizes,
+                          tjtransform *transforms, int flags);
+
+
+/**
+ * Destroy a TurboJPEG compressor, decompressor, or transformer instance.
+ *
+ * @param handle a handle to a TurboJPEG compressor, decompressor or
+ * transformer instance
+ *
+ * @return 0 if successful, or -1 if an error occurred (see #tjGetErrorStr2().)
+ */
+DLLEXPORT int tjDestroy(tjhandle handle);
+
+
+/**
+ * Allocate an image buffer for use with TurboJPEG.  You should always use
+ * this function to allocate the JPEG destination buffer(s) for the compression
+ * and transform functions unless you are disabling automatic buffer
+ * (re)allocation (by setting #TJFLAG_NOREALLOC.)
+ *
+ * @param bytes the number of bytes to allocate
+ *
+ * @return a pointer to a newly-allocated buffer with the specified number of
+ * bytes.
+ *
+ * @sa tjFree()
+ */
+DLLEXPORT unsigned char *tjAlloc(int bytes);
+
+
+/**
+ * Load an uncompressed image from disk into memory.
+ *
+ * @param filename name of a file containing an uncompressed image in Windows
+ * BMP or PBMPLUS (PPM/PGM) format
+ *
+ * @param width pointer to an integer variable that will receive the width (in
+ * pixels) of the uncompressed image
+ *
+ * @param align row alignment of the image buffer to be returned (must be a
+ * power of 2.)  For instance, setting this parameter to 4 will cause all rows
+ * in the image buffer to be padded to the nearest 32-bit boundary, and setting
+ * this parameter to 1 will cause all rows in the image buffer to be unpadded.
+ *
+ * @param height pointer to an integer variable that will receive the height
+ * (in pixels) of the uncompressed image
+ *
+ * @param pixelFormat pointer to an integer variable that specifies or will
+ * receive the pixel format of the uncompressed image buffer.  The behavior of
+ * #tjLoadImage() will vary depending on the value of <tt>*pixelFormat</tt>
+ * passed to the function:
+ * - @ref TJPF_UNKNOWN : The uncompressed image buffer returned by the function
+ * will use the most optimal pixel format for the file type, and
+ * <tt>*pixelFormat</tt> will contain the ID of this pixel format upon
+ * successful return from the function.
+ * - @ref TJPF_GRAY : Only PGM files and 8-bit BMP files with a grayscale
+ * colormap can be loaded.
+ * - @ref TJPF_CMYK : The RGB or grayscale pixels stored in the file will be
+ * converted using a quick & dirty algorithm that is suitable only for testing
+ * purposes (proper conversion between CMYK and other formats requires a color
+ * management system.)
+ * - Other @ref TJPF "pixel formats" : The uncompressed image buffer will use
+ * the specified pixel format, and pixel format conversion will be performed if
+ * necessary.
+ *
+ * @param flags the bitwise OR of one or more of the @ref TJFLAG_BOTTOMUP
+ * "flags".
+ *
+ * @return a pointer to a newly-allocated buffer containing the uncompressed
+ * image, converted to the chosen pixel format and with the chosen row
+ * alignment, or NULL if an error occurred (see #tjGetErrorStr2().)  This
+ * buffer should be freed using #tjFree().
+ */
+DLLEXPORT unsigned char *tjLoadImage(const char *filename, int *width,
+                                     int align, int *height, int *pixelFormat,
+                                     int flags);
+
+
+/**
+ * Save an uncompressed image from memory to disk.
+ *
+ * @param filename name of a file to which to save the uncompressed image.
+ * The image will be stored in Windows BMP or PBMPLUS (PPM/PGM) format,
+ * depending on the file extension.
+ *
+ * @param buffer pointer to an image buffer containing RGB, grayscale, or
+ * CMYK pixels to be saved
+ *
+ * @param width width (in pixels) of the uncompressed image
+ *
+ * @param pitch bytes per line in the image buffer.  Setting this parameter to
+ * 0 is the equivalent of setting it to
+ * <tt>width * #tjPixelSize[pixelFormat]</tt>.
+ *
+ * @param height height (in pixels) of the uncompressed image
+ *
+ * @param pixelFormat pixel format of the image buffer (see @ref TJPF
+ * "Pixel formats".)  If this parameter is set to @ref TJPF_GRAY, then the
+ * image will be stored in PGM or 8-bit (indexed color) BMP format.  Otherwise,
+ * the image will be stored in PPM or 24-bit BMP format.  If this parameter
+ * is set to @ref TJPF_CMYK, then the CMYK pixels will be converted to RGB
+ * using a quick & dirty algorithm that is suitable only for testing (proper
+ * conversion between CMYK and other formats requires a color management
+ * system.)
+ *
+ * @param flags the bitwise OR of one or more of the @ref TJFLAG_BOTTOMUP
+ * "flags".
+ *
+ * @return 0 if successful, or -1 if an error occurred (see #tjGetErrorStr2().)
+ */
+DLLEXPORT int tjSaveImage(const char *filename, unsigned char *buffer,
+                          int width, int pitch, int height, int pixelFormat,
+                          int flags);
+
+
+/**
+ * Free an image buffer previously allocated by TurboJPEG.  You should always
+ * use this function to free JPEG destination buffer(s) that were automatically
+ * (re)allocated by the compression and transform functions or that were
+ * manually allocated using #tjAlloc().
+ *
+ * @param buffer address of the buffer to free.  If the address is NULL, then
+ * this function has no effect.
+ *
+ * @sa tjAlloc()
+ */
+DLLEXPORT void tjFree(unsigned char *buffer);
+
+
+/**
+ * Returns a descriptive error message explaining why the last command failed.
+ *
+ * @param handle a handle to a TurboJPEG compressor, decompressor, or
+ * transformer instance, or NULL if the error was generated by a global
+ * function (but note that retrieving the error message for a global function
+ * is thread-safe only on platforms that support thread-local storage.)
+ *
+ * @return a descriptive error message explaining why the last command failed.
+ */
+DLLEXPORT char *tjGetErrorStr2(tjhandle handle);
+
+
+/**
+ * Returns a code indicating the severity of the last error.  See
+ * @ref TJERR "Error codes".
+ *
+ * @param handle a handle to a TurboJPEG compressor, decompressor or
+ * transformer instance
+ *
+ * @return a code indicating the severity of the last error.  See
+ * @ref TJERR "Error codes".
+ */
+DLLEXPORT int tjGetErrorCode(tjhandle handle);
+
+
+/* Deprecated functions and macros */
+#define TJFLAG_FORCEMMX  8
+#define TJFLAG_FORCESSE  16
+#define TJFLAG_FORCESSE2  32
+#define TJFLAG_FORCESSE3  128
+
+
+/* Backward compatibility functions and macros (nothing to see here) */
+#define NUMSUBOPT  TJ_NUMSAMP
+#define TJ_444  TJSAMP_444
+#define TJ_422  TJSAMP_422
+#define TJ_420  TJSAMP_420
+#define TJ_411  TJSAMP_420
+#define TJ_GRAYSCALE  TJSAMP_GRAY
+
+#define TJ_BGR  1
+#define TJ_BOTTOMUP  TJFLAG_BOTTOMUP
+#define TJ_FORCEMMX  TJFLAG_FORCEMMX
+#define TJ_FORCESSE  TJFLAG_FORCESSE
+#define TJ_FORCESSE2  TJFLAG_FORCESSE2
+#define TJ_ALPHAFIRST  64
+#define TJ_FORCESSE3  TJFLAG_FORCESSE3
+#define TJ_FASTUPSAMPLE  TJFLAG_FASTUPSAMPLE
+#define TJ_YUV  512
+
+DLLEXPORT unsigned long TJBUFSIZE(int width, int height);
+
+DLLEXPORT unsigned long TJBUFSIZEYUV(int width, int height, int jpegSubsamp);
+
+DLLEXPORT unsigned long tjBufSizeYUV(int width, int height, int subsamp);
+
+DLLEXPORT int tjCompress(tjhandle handle, unsigned char *srcBuf, int width,
+                         int pitch, int height, int pixelSize,
+                         unsigned char *dstBuf, unsigned long *compressedSize,
+                         int jpegSubsamp, int jpegQual, int flags);
+
+DLLEXPORT int tjEncodeYUV(tjhandle handle, unsigned char *srcBuf, int width,
+                          int pitch, int height, int pixelSize,
+                          unsigned char *dstBuf, int subsamp, int flags);
+
+DLLEXPORT int tjEncodeYUV2(tjhandle handle, unsigned char *srcBuf, int width,
+                           int pitch, int height, int pixelFormat,
+                           unsigned char *dstBuf, int subsamp, int flags);
+
+DLLEXPORT int tjDecompressHeader(tjhandle handle, unsigned char *jpegBuf,
+                                 unsigned long jpegSize, int *width,
+                                 int *height);
+
+DLLEXPORT int tjDecompressHeader2(tjhandle handle, unsigned char *jpegBuf,
+                                  unsigned long jpegSize, int *width,
+                                  int *height, int *jpegSubsamp);
+
+DLLEXPORT int tjDecompress(tjhandle handle, unsigned char *jpegBuf,
+                           unsigned long jpegSize, unsigned char *dstBuf,
+                           int width, int pitch, int height, int pixelSize,
+                           int flags);
+
+DLLEXPORT int tjDecompressToYUV(tjhandle handle, unsigned char *jpegBuf,
+                                unsigned long jpegSize, unsigned char *dstBuf,
+                                int flags);
+
+DLLEXPORT char *tjGetErrorStr(void);
+
+
+/**
+ * @}
+ */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/3rdparty/libjpeg/src/usage.txt b/3rdparty/libjpeg/src/usage.txt
new file mode 100644
index 00000000..f7fa3c08
--- /dev/null
+++ b/3rdparty/libjpeg/src/usage.txt
@@ -0,0 +1,683 @@
+NOTE:  This file was modified by The libjpeg-turbo Project to include only
+information relevant to libjpeg-turbo and to wordsmith certain sections.
+
+USAGE instructions for the Independent JPEG Group's JPEG software
+=================================================================
+
+This file describes usage of the JPEG conversion programs cjpeg and djpeg,
+as well as the utility programs jpegtran, rdjpgcom and wrjpgcom.  (See
+the other documentation files if you wish to use the JPEG library within
+your own programs.)
+
+If you are on a Unix machine you may prefer to read the Unix-style manual
+pages in files cjpeg.1, djpeg.1, jpegtran.1, rdjpgcom.1, wrjpgcom.1.
+
+
+INTRODUCTION
+
+These programs implement JPEG image encoding, decoding, and transcoding.
+JPEG (pronounced "jay-peg") is a standardized compression method for
+full-color and grayscale images.
+
+
+GENERAL USAGE
+
+We provide two programs, cjpeg to compress an image file into JPEG format,
+and djpeg to decompress a JPEG file back into a conventional image format.
+
+On Unix-like systems, you say:
+        cjpeg [switches] [imagefile] >jpegfile
+or
+        djpeg [switches] [jpegfile]  >imagefile
+The programs read the specified input file, or standard input if none is
+named.  They always write to standard output (with trace/error messages to
+standard error).  These conventions are handy for piping images between
+programs.
+
+On most non-Unix systems, you say:
+        cjpeg [switches] imagefile jpegfile
+or
+        djpeg [switches] jpegfile  imagefile
+i.e., both the input and output files are named on the command line.  This
+style is a little more foolproof, and it loses no functionality if you don't
+have pipes.  (You can get this style on Unix too, if you prefer, by defining
+TWO_FILE_COMMANDLINE when you compile the programs; see install.txt.)
+
+You can also say:
+        cjpeg [switches] -outfile jpegfile  imagefile
+or
+        djpeg [switches] -outfile imagefile  jpegfile
+This syntax works on all systems, so it is useful for scripts.
+
+The currently supported image file formats are: PPM (PBMPLUS color format),
+PGM (PBMPLUS grayscale format), BMP, GIF, and Targa.  cjpeg recognizes the
+input image format automatically, with the exception of some Targa files.  You
+have to tell djpeg which format to generate.
+
+JPEG files are in the defacto standard JFIF file format.  There are other,
+less widely used JPEG-based file formats, but we don't support them.
+
+All switch names may be abbreviated; for example, -grayscale may be written
+-gray or -gr.  Most of the "basic" switches can be abbreviated to as little as
+one letter.  Upper and lower case are equivalent (-BMP is the same as -bmp).
+British spellings are also accepted (e.g., -greyscale), though for brevity
+these are not mentioned below.
+
+
+CJPEG DETAILS
+
+The basic command line switches for cjpeg are:
+
+        -quality N[,...]  Scale quantization tables to adjust image quality.
+                          Quality is 0 (worst) to 100 (best); default is 75.
+                          (See below for more info.)
+
+        -grayscale      Create monochrome JPEG file from color input.
+                        Be sure to use this switch when compressing a grayscale
+                        BMP or GIF file, because cjpeg isn't bright enough to
+                        notice whether a BMP or GIF file uses only shades of
+                        gray.  By saying -grayscale, you'll get a smaller JPEG
+                        file that takes less time to process.
+
+        -rgb            Create RGB JPEG file.
+                        Using this switch suppresses the conversion from RGB
+                        colorspace input to the default YCbCr JPEG colorspace.
+
+        -optimize       Perform optimization of entropy encoding parameters.
+                        Without this, default encoding parameters are used.
+                        -optimize usually makes the JPEG file a little smaller,
+                        but cjpeg runs somewhat slower and needs much more
+                        memory.  Image quality and speed of decompression are
+                        unaffected by -optimize.
+
+        -progressive    Create progressive JPEG file (see below).
+
+        -targa          Input file is Targa format.  Targa files that contain
+                        an "identification" field will not be automatically
+                        recognized by cjpeg; for such files you must specify
+                        -targa to make cjpeg treat the input as Targa format.
+                        For most Targa files, you won't need this switch.
+
+The -quality switch lets you trade off compressed file size against quality of
+the reconstructed image: the higher the quality setting, the larger the JPEG
+file, and the closer the output image will be to the original input.  Normally
+you want to use the lowest quality setting (smallest file) that decompresses
+into something visually indistinguishable from the original image.  For this
+purpose the quality setting should generally be between 50 and 95 (the default
+is 75) for photographic images.  If you see defects at -quality 75, then go up
+5 or 10 counts at a time until you are happy with the output image.  (The
+optimal setting will vary from one image to another.)
+
+-quality 100 will generate a quantization table of all 1's, minimizing loss
+in the quantization step (but there is still information loss in subsampling,
+as well as roundoff error.)  For most images, specifying a quality value above
+about 95 will increase the size of the compressed file dramatically, and while
+the quality gain from these higher quality values is measurable (using metrics
+such as PSNR or SSIM), it is rarely perceivable by human vision.
+
+In the other direction, quality values below 50 will produce very small files
+of low image quality.  Settings around 5 to 10 might be useful in preparing an
+index of a large image library, for example.  Try -quality 2 (or so) for some
+amusing Cubist effects.  (Note: quality values below about 25 generate 2-byte
+quantization tables, which are considered optional in the JPEG standard.
+cjpeg emits a warning message when you give such a quality value, because some
+other JPEG programs may be unable to decode the resulting file.  Use -baseline
+if you need to ensure compatibility at low quality values.)
+
+The -quality option has been extended in this version of cjpeg to support
+separate quality settings for luminance and chrominance (or, in general,
+separate settings for every quantization table slot.)  The principle is the
+same as chrominance subsampling:  since the human eye is more sensitive to
+spatial changes in brightness than spatial changes in color, the chrominance
+components can be quantized more than the luminance components without
+incurring any visible image quality loss.  However, unlike subsampling, this
+feature reduces data in the frequency domain instead of the spatial domain,
+which allows for more fine-grained control.  This option is useful in
+quality-sensitive applications, for which the artifacts generated by
+subsampling may be unacceptable.
+
+The -quality option accepts a comma-separated list of parameters, which
+respectively refer to the quality levels that should be assigned to the
+quantization table slots.  If there are more q-table slots than parameters,
+then the last parameter is replicated.  Thus, if only one quality parameter is
+given, this is used for both luminance and chrominance (slots 0 and 1,
+respectively), preserving the legacy behavior of cjpeg v6b and prior.  More (or
+customized) quantization tables can be set with the -qtables option and
+assigned to components with the -qslots option (see the "wizard" switches
+below.)
+
+JPEG  files  generated  with separate luminance and chrominance quality are
+fully compliant with standard JPEG decoders.
+
+CAUTION: For this setting to be useful, be sure to pass an argument of
+-sample 1x1 to cjpeg to disable chrominance subsampling.  Otherwise, the
+default subsampling level (2x2, AKA "4:2:0") will be used.
+
+The -progressive switch creates a "progressive JPEG" file.  In this type of
+JPEG file, the data is stored in multiple scans of increasing quality.  If the
+file is being transmitted over a slow communications link, the decoder can use
+the first scan to display a low-quality image very quickly, and can then
+improve the display with each subsequent scan.  The final image is exactly
+equivalent to a standard JPEG file of the same quality setting, and the total
+file size is about the same --- often a little smaller.
+
+Switches for advanced users:
+
+        -arithmetic     Use arithmetic coding.  CAUTION: arithmetic coded JPEG
+                        is not yet widely implemented, so many decoders will
+                        be unable to view an arithmetic coded JPEG file at
+                        all.
+
+        -dct int        Use accurate integer DCT method (default).
+        -dct fast       Use less accurate integer DCT method [legacy feature].
+                        When the Independent JPEG Group's software was first
+                        released in 1991, the compression time for a
+                        1-megapixel JPEG image on a mainstream PC was measured
+                        in minutes.  Thus, the fast integer DCT algorithm
+                        provided noticeable performance benefits.  On modern
+                        CPUs running libjpeg-turbo, however, the compression
+                        time for a 1-megapixel JPEG image is measured in
+                        milliseconds, and thus the performance benefits of the
+                        fast algorithm are much less noticeable.  On modern
+                        x86/x86-64 CPUs that support AVX2 instructions, the
+                        fast and int methods have similar performance.  On
+                        other types of CPUs, the fast method is generally about
+                        5-15% faster than the int method.
+
+                        For quality levels of 90 and below, there should be
+                        little or no perceptible quality difference between the
+                        two algorithms.  For quality levels above 90, however,
+                        the difference between the fast and int methods becomes
+                        more pronounced.  With quality=97, for instance, the
+                        fast method incurs generally about a 1-3 dB loss in
+                        PSNR relative to the int method, but this can be larger
+                        for some images.  Do not use the fast method with
+                        quality levels above 97.  The algorithm often
+                        degenerates at quality=98 and above and can actually
+                        produce a more lossy image than if lower quality levels
+                        had been used.  Also, in libjpeg-turbo, the fast method
+                        is not fully accelerated for quality levels above 97,
+                        so it will be slower than the int method.
+        -dct float      Use floating-point DCT method [legacy feature].
+                        The float method does not produce significantly more
+                        accurate results than the int method, and it is much
+                        slower.  The float method may also give different
+                        results on different machines due to varying roundoff
+                        behavior, whereas the integer methods should give the
+                        same results on all machines.
+
+        -restart N      Emit a JPEG restart marker every N MCU rows, or every
+                        N MCU blocks if "B" is attached to the number.
+                        -restart 0 (the default) means no restart markers.
+
+        -smooth N       Smooth the input image to eliminate dithering noise.
+                        N, ranging from 1 to 100, indicates the strength of
+                        smoothing.  0 (the default) means no smoothing.
+
+        -maxmemory N    Set limit for amount of memory to use in processing
+                        large images.  Value is in thousands of bytes, or
+                        millions of bytes if "M" is attached to the number.
+                        For example, -max 4m selects 4000000 bytes.  If more
+                        space is needed, an error will occur.
+
+        -verbose        Enable debug printout.  More -v's give more printout.
+        or  -debug      Also, version information is printed at startup.
+
+The -restart option inserts extra markers that allow a JPEG decoder to
+resynchronize after a transmission error.  Without restart markers, any damage
+to a compressed file will usually ruin the image from the point of the error
+to the end of the image; with restart markers, the damage is usually confined
+to the portion of the image up to the next restart marker.  Of course, the
+restart markers occupy extra space.  We recommend -restart 1 for images that
+will be transmitted across unreliable networks such as Usenet.
+
+The -smooth option filters the input to eliminate fine-scale noise.  This is
+often useful when converting dithered images to JPEG: a moderate smoothing
+factor of 10 to 50 gets rid of dithering patterns in the input file, resulting
+in a smaller JPEG file and a better-looking image.  Too large a smoothing
+factor will visibly blur the image, however.
+
+Switches for wizards:
+
+        -baseline       Force baseline-compatible quantization tables to be
+                        generated.  This clamps quantization values to 8 bits
+                        even at low quality settings.  (This switch is poorly
+                        named, since it does not ensure that the output is
+                        actually baseline JPEG.  For example, you can use
+                        -baseline and -progressive together.)
+
+        -qtables file   Use the quantization tables given in the specified
+                        text file.
+
+        -qslots N[,...] Select which quantization table to use for each color
+                        component.
+
+        -sample HxV[,...]  Set JPEG sampling factors for each color component.
+
+        -scans file     Use the scan script given in the specified text file.
+
+The "wizard" switches are intended for experimentation with JPEG.  If you
+don't know what you are doing, DON'T USE THEM.  These switches are documented
+further in the file wizard.txt.
+
+
+DJPEG DETAILS
+
+The basic command line switches for djpeg are:
+
+        -colors N       Reduce image to at most N colors.  This reduces the
+        or -quantize N  number of colors used in the output image, so that it
+                        can be displayed on a colormapped display or stored in
+                        a colormapped file format.  For example, if you have
+                        an 8-bit display, you'd need to reduce to 256 or fewer
+                        colors.  (-colors is the recommended name, -quantize
+                        is provided only for backwards compatibility.)
+
+        -fast           Select recommended processing options for fast, low
+                        quality output.  (The default options are chosen for
+                        highest quality output.)  Currently, this is equivalent
+                        to "-dct fast -nosmooth -onepass -dither ordered".
+
+        -grayscale      Force grayscale output even if JPEG file is color.
+                        Useful for viewing on monochrome displays; also,
+                        djpeg runs noticeably faster in this mode.
+
+        -rgb            Force RGB output even if JPEG file is grayscale.
+
+        -scale M/N      Scale the output image by a factor M/N.  Currently
+                        the scale factor must be M/8, where M is an integer
+                        between 1 and 16 inclusive, or any reduced fraction
+                        thereof (such as 1/2, 3/4, etc.  Scaling is handy if
+                        the image is larger than your screen; also, djpeg runs
+                        much faster when scaling down the output.
+
+        -bmp            Select BMP output format (Windows flavor).  8-bit
+                        colormapped format is emitted if -colors or -grayscale
+                        is specified, or if the JPEG file is grayscale;
+                        otherwise, 24-bit full-color format is emitted.
+
+        -gif            Select GIF output format (LZW-compressed).  Since GIF
+                        does not support more than 256 colors, -colors 256 is
+                        assumed (unless you specify a smaller number of
+                        colors).  If you specify -fast, the default number of
+                        colors is 216.
+
+        -gif0           Select GIF output format (uncompressed).  Since GIF
+                        does not support more than 256 colors, -colors 256 is
+                        assumed (unless you specify a smaller number of
+                        colors).  If you specify -fast, the default number of
+                        colors is 216.
+
+        -os2            Select BMP output format (OS/2 1.x flavor).  8-bit
+                        colormapped format is emitted if -colors or -grayscale
+                        is specified, or if the JPEG file is grayscale;
+                        otherwise, 24-bit full-color format is emitted.
+
+        -pnm            Select PBMPLUS (PPM/PGM) output format (this is the
+                        default format).  PGM is emitted if the JPEG file is
+                        grayscale or if -grayscale is specified; otherwise
+                        PPM is emitted.
+
+        -targa          Select Targa output format.  Grayscale format is
+                        emitted if the JPEG file is grayscale or if
+                        -grayscale is specified; otherwise, colormapped format
+                        is emitted if -colors is specified; otherwise, 24-bit
+                        full-color format is emitted.
+
+Switches for advanced users:
+
+        -dct int        Use accurate integer DCT method (default).
+        -dct fast       Use less accurate integer DCT method [legacy feature].
+                        When the Independent JPEG Group's software was first
+                        released in 1991, the decompression time for a
+                        1-megapixel JPEG image on a mainstream PC was measured
+                        in minutes.  Thus, the fast integer DCT algorithm
+                        provided noticeable performance benefits.  On modern
+                        CPUs running libjpeg-turbo, however, the decompression
+                        time for a 1-megapixel JPEG image is measured in
+                        milliseconds, and thus the performance benefits of the
+                        fast algorithm are much less noticeable.  On modern
+                        x86/x86-64 CPUs that support AVX2 instructions, the
+                        fast and int methods have similar performance.  On
+                        other types of CPUs, the fast method is generally about
+                        5-15% faster than the int method.
+
+                        If the JPEG image was compressed using a quality level
+                        of 85 or below, then there should be little or no
+                        perceptible quality difference between the two
+                        algorithms.  When decompressing images that were
+                        compressed using quality levels above 85, however, the
+                        difference between the fast and int methods becomes
+                        more pronounced.  With images compressed using
+                        quality=97, for instance, the fast method incurs
+                        generally about a 4-6 dB loss in PSNR relative to the
+                        int method, but this can be larger for some images.  If
+                        you can avoid it, do not use the fast method when
+                        decompressing images that were compressed using quality
+                        levels above 97.  The algorithm often degenerates for
+                        such images and can actually produce a more lossy
+                        output image than if the JPEG image had been compressed
+                        using lower quality levels.
+        -dct float      Use floating-point DCT method [legacy feature].
+                        The float method does not produce significantly more
+                        accurate results than the int method, and it is much
+                        slower.  The float method may also give different
+                        results on different machines due to varying roundoff
+                        behavior, whereas the integer methods should give the
+                        same results on all machines.
+
+        -dither fs      Use Floyd-Steinberg dithering in color quantization.
+        -dither ordered Use ordered dithering in color quantization.
+        -dither none    Do not use dithering in color quantization.
+                        By default, Floyd-Steinberg dithering is applied when
+                        quantizing colors; this is slow but usually produces
+                        the best results.  Ordered dither is a compromise
+                        between speed and quality; no dithering is fast but
+                        usually looks awful.  Note that these switches have
+                        no effect unless color quantization is being done.
+                        Ordered dither is only available in -onepass mode.
+
+        -map FILE       Quantize to the colors used in the specified image
+                        file.  This is useful for producing multiple files
+                        with identical color maps, or for forcing a predefined
+                        set of colors to be used.  The FILE must be a GIF
+                        or PPM file.  This option overrides -colors and
+                        -onepass.
+
+        -nosmooth       Use a faster, lower-quality upsampling routine.
+
+        -onepass        Use one-pass instead of two-pass color quantization.
+                        The one-pass method is faster and needs less memory,
+                        but it produces a lower-quality image.  -onepass is
+                        ignored unless you also say -colors N.  Also,
+                        the one-pass method is always used for grayscale
+                        output (the two-pass method is no improvement then).
+
+        -maxmemory N    Set limit for amount of memory to use in processing
+                        large images.  Value is in thousands of bytes, or
+                        millions of bytes if "M" is attached to the number.
+                        For example, -max 4m selects 4000000 bytes.  If more
+                        space is needed, an error will occur.
+
+        -verbose        Enable debug printout.  More -v's give more printout.
+        or  -debug      Also, version information is printed at startup.
+
+
+HINTS FOR CJPEG
+
+Color GIF files are not the ideal input for JPEG; JPEG is really intended for
+compressing full-color (24-bit) images.  In particular, don't try to convert
+cartoons, line drawings, and other images that have only a few distinct
+colors.  GIF works great on these, JPEG does not.  If you want to convert a
+GIF to JPEG, you should experiment with cjpeg's -quality and -smooth options
+to get a satisfactory conversion.  -smooth 10 or so is often helpful.
+
+Avoid running an image through a series of JPEG compression/decompression
+cycles.  Image quality loss will accumulate; after ten or so cycles the image
+may be noticeably worse than it was after one cycle.  It's best to use a
+lossless format while manipulating an image, then convert to JPEG format when
+you are ready to file the image away.
+
+The -optimize option to cjpeg is worth using when you are making a "final"
+version for posting or archiving.  It's also a win when you are using low
+quality settings to make very small JPEG files; the percentage improvement
+is often a lot more than it is on larger files.  (At present, -optimize
+mode is always selected when generating progressive JPEG files.)
+
+
+HINTS FOR DJPEG
+
+To get a quick preview of an image, use the -grayscale and/or -scale switches.
+"-grayscale -scale 1/8" is the fastest case.
+
+Several options are available that trade off image quality to gain speed.
+"-fast" turns on the recommended settings.
+
+"-dct fast" and/or "-nosmooth" gain speed at a small sacrifice in quality.
+When producing a color-quantized image, "-onepass -dither ordered" is fast but
+much lower quality than the default behavior.  "-dither none" may give
+acceptable results in two-pass mode, but is seldom tolerable in one-pass mode.
+
+
+HINTS FOR BOTH PROGRAMS
+
+If the memory needed by cjpeg or djpeg exceeds the limit specified by
+-maxmemory, an error will occur.  You can leave out -progressive and -optimize
+(for cjpeg) or specify -onepass (for djpeg) to reduce memory usage.
+
+On machines that have "environment" variables, you can define the environment
+variable JPEGMEM to set the default memory limit.  The value is specified as
+described for the -maxmemory switch.  JPEGMEM overrides the default value
+specified when the program was compiled, and itself is overridden by an
+explicit -maxmemory switch.
+
+
+JPEGTRAN
+
+jpegtran performs various useful transformations of JPEG files.
+It can translate the coded representation from one variant of JPEG to another,
+for example from baseline JPEG to progressive JPEG or vice versa.  It can also
+perform some rearrangements of the image data, for example turning an image
+from landscape to portrait format by rotation.  For EXIF files and JPEG files
+containing Exif data, you may prefer to use exiftran instead.
+
+jpegtran works by rearranging the compressed data (DCT coefficients), without
+ever fully decoding the image.  Therefore, its transformations are lossless:
+there is no image degradation at all, which would not be true if you used
+djpeg followed by cjpeg to accomplish the same conversion.  But by the same
+token, jpegtran cannot perform lossy operations such as changing the image
+quality.  However, while the image data is losslessly transformed, metadata
+can be removed.  See the -copy option for specifics.
+
+jpegtran uses a command line syntax similar to cjpeg or djpeg.
+On Unix-like systems, you say:
+        jpegtran [switches] [inputfile] >outputfile
+On most non-Unix systems, you say:
+        jpegtran [switches] inputfile outputfile
+where both the input and output files are JPEG files.
+
+To specify the coded JPEG representation used in the output file,
+jpegtran accepts a subset of the switches recognized by cjpeg:
+        -optimize       Perform optimization of entropy encoding parameters.
+        -progressive    Create progressive JPEG file.
+        -arithmetic     Use arithmetic coding.
+        -restart N      Emit a JPEG restart marker every N MCU rows, or every
+                        N MCU blocks if "B" is attached to the number.
+        -scans file     Use the scan script given in the specified text file.
+See the previous discussion of cjpeg for more details about these switches.
+If you specify none of these switches, you get a plain baseline-JPEG output
+file.  The quality setting and so forth are determined by the input file.
+
+The image can be losslessly transformed by giving one of these switches:
+        -flip horizontal        Mirror image horizontally (left-right).
+        -flip vertical          Mirror image vertically (top-bottom).
+        -rotate 90              Rotate image 90 degrees clockwise.
+        -rotate 180             Rotate image 180 degrees.
+        -rotate 270             Rotate image 270 degrees clockwise (or 90 ccw).
+        -transpose              Transpose image (across UL-to-LR axis).
+        -transverse             Transverse transpose (across UR-to-LL axis).
+
+The transpose transformation has no restrictions regarding image dimensions.
+The other transformations operate rather oddly if the image dimensions are not
+a multiple of the iMCU size (usually 8 or 16 pixels), because they can only
+transform complete blocks of DCT coefficient data in the desired way.
+
+jpegtran's default behavior when transforming an odd-size image is designed
+to preserve exact reversibility and mathematical consistency of the
+transformation set.  As stated, transpose is able to flip the entire image
+area.  Horizontal mirroring leaves any partial iMCU column at the right edge
+untouched, but is able to flip all rows of the image.  Similarly, vertical
+mirroring leaves any partial iMCU row at the bottom edge untouched, but is
+able to flip all columns.  The other transforms can be built up as sequences
+of transpose and flip operations; for consistency, their actions on edge
+pixels are defined to be the same as the end result of the corresponding
+transpose-and-flip sequence.
+
+For practical use, you may prefer to discard any untransformable edge pixels
+rather than having a strange-looking strip along the right and/or bottom edges
+of a transformed image.  To do this, add the -trim switch:
+        -trim           Drop non-transformable edge blocks.
+Obviously, a transformation with -trim is not reversible, so strictly speaking
+jpegtran with this switch is not lossless.  Also, the expected mathematical
+equivalences between the transformations no longer hold.  For example,
+"-rot 270 -trim" trims only the bottom edge, but "-rot 90 -trim" followed by
+"-rot 180 -trim" trims both edges.
+
+If you are only interested in perfect transformations, add the -perfect switch:
+        -perfect        Fail with an error if the transformation is not
+                        perfect.
+For example, you may want to do
+  jpegtran -rot 90 -perfect foo.jpg || djpeg foo.jpg | pnmflip -r90 | cjpeg
+to do a perfect rotation, if available, or an approximated one if not.
+
+This version of jpegtran also offers a lossless crop option, which discards
+data outside of a given image region but losslessly preserves what is inside.
+Like the rotate and flip transforms, lossless crop is restricted by the current
+JPEG format; the upper left corner of the selected region must fall on an iMCU
+boundary.  If it doesn't, then it is silently moved up and/or left to the
+nearest iMCU boundary (the lower right corner is unchanged.)  Thus, the output
+image covers at least the requested region, but it may cover more.  The
+adjustment of the region dimensions may be optionally disabled by attaching an
+'f' character ("force") to the width or height number.
+
+The image can be losslessly cropped by giving the switch:
+        -crop WxH+X+Y   Crop to a rectangular region of width W and height H,
+                        starting at point X,Y.
+
+If W or H is larger than the width/height of the input image, then the output
+image is expanded in size, and the expanded region is filled in with zeros
+(neutral gray).  Attaching an 'f' character ("flatten") to the width number
+will cause each block in the expanded region to be filled in with the DC
+coefficient of the nearest block in the input image rather than grayed out.
+Attaching an 'r' character ("reflect") to the width number will cause the
+expanded region to be filled in with repeated reflections of the input image
+rather than grayed out.
+
+A complementary lossless wipe option is provided to discard (gray out) data
+inside a given image region while losslessly preserving what is outside:
+        -wipe WxH+X+Y   Wipe (gray out) a rectangular region of width W and
+                        height H from the input image, starting at point X,Y.
+
+Attaching an 'f' character ("flatten") to the width number will cause the
+region to be filled with the average of adjacent blocks rather than grayed out.
+If the wipe region and the region outside the wipe region, when adjusted to the
+nearest iMCU boundary, form two horizontally adjacent rectangles, then
+attaching an 'r' character ("reflect") to the width number will cause the wipe
+region to be filled with repeated reflections of the outside region rather than
+grayed out.
+
+A lossless drop option is also provided, which allows another JPEG image to be
+inserted ("dropped") into the input image data at a given position, replacing
+the existing image data at that position:
+        -drop +X+Y filename     Drop (insert) another image at point X,Y
+
+Both the input image and the drop image must have the same subsampling level.
+It is best if they also have the same quantization (quality.)  Otherwise, the
+quantization of the output image will be adapted to accommodate the higher of
+the input image quality and the drop image quality.  The trim option can be
+used with the drop option to requantize the drop image to match the input
+image.  Note that a grayscale image can be dropped into a full-color image or
+vice versa, as long as the full-color image has no vertical subsampling.  If
+the input image is grayscale and the drop image is full-color, then the
+chrominance channels from the drop image will be discarded.
+
+Other not-strictly-lossless transformation switches are:
+
+        -grayscale      Force grayscale output.
+This option discards the chrominance channels if the input image is YCbCr
+(ie, a standard color JPEG), resulting in a grayscale JPEG file.  The
+luminance channel is preserved exactly, so this is a better method of reducing
+to grayscale than decompression, conversion, and recompression.  This switch
+is particularly handy for fixing a monochrome picture that was mistakenly
+encoded as a color JPEG.  (In such a case, the space savings from getting rid
+of the near-empty chroma channels won't be large; but the decoding time for
+a grayscale JPEG is substantially less than that for a color JPEG.)
+
+jpegtran also recognizes these switches that control what to do with "extra"
+markers, such as comment blocks:
+        -copy none      Copy no extra markers from source file.  This setting
+                        suppresses all comments and other metadata in the
+                        source file.
+        -copy comments  Copy only comment markers.  This setting copies
+                        comments from the source file but discards any other
+                        metadata.
+        -copy all       Copy all extra markers.  This setting preserves
+                        miscellaneous markers found in the source file, such
+                        as JFIF thumbnails, Exif data, and Photoshop settings.
+                        In some files, these extra markers can be sizable.
+                        Note that this option will copy thumbnails as-is;
+                        they will not be transformed.
+The default behavior is -copy comments.  (Note: in IJG releases v6 and v6a,
+jpegtran always did the equivalent of -copy none.)
+
+Additional switches recognized by jpegtran are:
+        -outfile filename
+        -maxmemory N
+        -verbose
+        -debug
+These work the same as in cjpeg or djpeg.
+
+
+THE COMMENT UTILITIES
+
+The JPEG standard allows "comment" (COM) blocks to occur within a JPEG file.
+Although the standard doesn't actually define what COM blocks are for, they
+are widely used to hold user-supplied text strings.  This lets you add
+annotations, titles, index terms, etc to your JPEG files, and later retrieve
+them as text.  COM blocks do not interfere with the image stored in the JPEG
+file.  The maximum size of a COM block is 64K, but you can have as many of
+them as you like in one JPEG file.
+
+We provide two utility programs to display COM block contents and add COM
+blocks to a JPEG file.
+
+rdjpgcom searches a JPEG file and prints the contents of any COM blocks on
+standard output.  The command line syntax is
+        rdjpgcom [-raw] [-verbose] [inputfilename]
+The switch "-raw" (or just "-r") causes rdjpgcom to output non-printable
+characters in JPEG comments.  These characters are normally escaped for
+security reasons.
+The switch "-verbose" (or just "-v") causes rdjpgcom to also display the JPEG
+image dimensions.  If you omit the input file name from the command line,
+the JPEG file is read from standard input.  (This may not work on some
+operating systems, if binary data can't be read from stdin.)
+
+wrjpgcom adds a COM block, containing text you provide, to a JPEG file.
+Ordinarily, the COM block is added after any existing COM blocks, but you
+can delete the old COM blocks if you wish.  wrjpgcom produces a new JPEG
+file; it does not modify the input file.  DO NOT try to overwrite the input
+file by directing wrjpgcom's output back into it; on most systems this will
+just destroy your file.
+
+The command line syntax for wrjpgcom is similar to cjpeg's.  On Unix-like
+systems, it is
+        wrjpgcom [switches] [inputfilename]
+The output file is written to standard output.  The input file comes from
+the named file, or from standard input if no input file is named.
+
+On most non-Unix systems, the syntax is
+        wrjpgcom [switches] inputfilename outputfilename
+where both input and output file names must be given explicitly.
+
+wrjpgcom understands three switches:
+        -replace                 Delete any existing COM blocks from the file.
+        -comment "Comment text"  Supply new COM text on command line.
+        -cfile name              Read text for new COM block from named file.
+(Switch names can be abbreviated.)  If you have only one line of comment text
+to add, you can provide it on the command line with -comment.  The comment
+text must be surrounded with quotes so that it is treated as a single
+argument.  Longer comments can be read from a text file.
+
+If you give neither -comment nor -cfile, then wrjpgcom will read the comment
+text from standard input.  (In this case an input image file name MUST be
+supplied, so that the source JPEG file comes from somewhere else.)  You can
+enter multiple lines, up to 64KB worth.  Type an end-of-file indicator
+(usually control-D or control-Z) to terminate the comment text entry.
+
+wrjpgcom will not add a COM block if the provided comment string is empty.
+Therefore -replace -comment "" can be used to delete all COM blocks from a
+file.
+
+These utility programs do not depend on the IJG JPEG library.  In
+particular, the source code for rdjpgcom is intended as an illustration of
+the minimum amount of code required to parse a JPEG file header correctly.
diff --git a/3rdparty/libjpeg/src/win/gcc/projectTargets-release.cmake.in b/3rdparty/libjpeg/src/win/gcc/projectTargets-release.cmake.in
new file mode 100644
index 00000000..1e1a8a34
--- /dev/null
+++ b/3rdparty/libjpeg/src/win/gcc/projectTargets-release.cmake.in
@@ -0,0 +1,49 @@
+#----------------------------------------------------------------
+# Generated CMake target import file for configuration "Release".
+#----------------------------------------------------------------
+
+# Commands may need to know the format version.
+set(CMAKE_IMPORT_FILE_VERSION 1)
+
+# Import target "@CMAKE_PROJECT_NAME@::jpeg" for configuration "Release"
+set_property(TARGET @CMAKE_PROJECT_NAME@::jpeg APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(@CMAKE_PROJECT_NAME@::jpeg PROPERTIES
+  IMPORTED_IMPLIB_RELEASE "${_IMPORT_PREFIX}/lib/libjpeg.dll.a"
+  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/bin/libjpeg-62.dll"
+  )
+
+list(APPEND _IMPORT_CHECK_TARGETS @CMAKE_PROJECT_NAME@::jpeg )
+list(APPEND _IMPORT_CHECK_FILES_FOR_@CMAKE_PROJECT_NAME@::jpeg "${_IMPORT_PREFIX}/lib/libjpeg.dll.a" "${_IMPORT_PREFIX}/bin/libjpeg-62.dll" )
+
+# Import target "@CMAKE_PROJECT_NAME@::turbojpeg" for configuration "Release"
+set_property(TARGET @CMAKE_PROJECT_NAME@::turbojpeg APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(@CMAKE_PROJECT_NAME@::turbojpeg PROPERTIES
+  IMPORTED_IMPLIB_RELEASE "${_IMPORT_PREFIX}/lib/libturbojpeg.dll.a"
+  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/bin/libturbojpeg.dll"
+  )
+
+list(APPEND _IMPORT_CHECK_TARGETS @CMAKE_PROJECT_NAME@::turbojpeg )
+list(APPEND _IMPORT_CHECK_FILES_FOR_@CMAKE_PROJECT_NAME@::turbojpeg "${_IMPORT_PREFIX}/lib/libturbojpeg.dll.a" "${_IMPORT_PREFIX}/bin/libturbojpeg.dll" )
+
+# Import target "@CMAKE_PROJECT_NAME@::turbojpeg-static" for configuration "Release"
+set_property(TARGET @CMAKE_PROJECT_NAME@::turbojpeg-static APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(@CMAKE_PROJECT_NAME@::turbojpeg-static PROPERTIES
+  IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "ASM_NASM;C"
+  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib/libturbojpeg.a"
+  )
+
+list(APPEND _IMPORT_CHECK_TARGETS @CMAKE_PROJECT_NAME@::turbojpeg-static )
+list(APPEND _IMPORT_CHECK_FILES_FOR_@CMAKE_PROJECT_NAME@::turbojpeg-static "${_IMPORT_PREFIX}/lib/libturbojpeg.a" )
+
+# Import target "@CMAKE_PROJECT_NAME@::jpeg-static" for configuration "Release"
+set_property(TARGET @CMAKE_PROJECT_NAME@::jpeg-static APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(@CMAKE_PROJECT_NAME@::jpeg-static PROPERTIES
+  IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "ASM_NASM;C"
+  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib/libjpeg.a"
+  )
+
+list(APPEND _IMPORT_CHECK_TARGETS @CMAKE_PROJECT_NAME@::jpeg-static )
+list(APPEND _IMPORT_CHECK_FILES_FOR_@CMAKE_PROJECT_NAME@::jpeg-static "${_IMPORT_PREFIX}/lib/libjpeg.a" )
+
+# Commands beyond this point should not need to know the version.
+set(CMAKE_IMPORT_FILE_VERSION)
diff --git a/3rdparty/libjpeg/src/win/jconfig.h.in b/3rdparty/libjpeg/src/win/jconfig.h.in
new file mode 100644
index 00000000..13cceef0
--- /dev/null
+++ b/3rdparty/libjpeg/src/win/jconfig.h.in
@@ -0,0 +1,33 @@
+#define JPEG_LIB_VERSION  @JPEG_LIB_VERSION@
+#define LIBJPEG_TURBO_VERSION  @VERSION@
+#define LIBJPEG_TURBO_VERSION_NUMBER  @LIBJPEG_TURBO_VERSION_NUMBER@
+
+#cmakedefine C_ARITH_CODING_SUPPORTED
+#cmakedefine D_ARITH_CODING_SUPPORTED
+#cmakedefine MEM_SRCDST_SUPPORTED
+#cmakedefine WITH_SIMD
+
+#define BITS_IN_JSAMPLE  @BITS_IN_JSAMPLE@      /* use 8 or 12 */
+
+#define HAVE_STDDEF_H
+#define HAVE_STDLIB_H
+#undef NEED_SYS_TYPES_H
+#undef NEED_BSD_STRINGS
+
+#define HAVE_UNSIGNED_CHAR
+#define HAVE_UNSIGNED_SHORT
+#undef INCOMPLETE_TYPES_BROKEN
+#undef RIGHT_SHIFT_IS_UNSIGNED
+
+/* Define "boolean" as unsigned char, not int, per Windows custom */
+#ifndef __RPCNDR_H__            /* don't conflict if rpcndr.h already read */
+typedef unsigned char boolean;
+#endif
+#define HAVE_BOOLEAN            /* prevent jmorecfg.h from redefining it */
+
+/* Define "INT32" as int, not long, per Windows custom */
+#if !(defined(_BASETSD_H_) || defined(_BASETSD_H))   /* don't conflict if basetsd.h already read */
+typedef short INT16;
+typedef signed int INT32;
+#endif
+#define XMD_H                   /* prevent jmorecfg.h from redefining it */
diff --git a/3rdparty/libjpeg/src/win/jpeg62-memsrcdst.def b/3rdparty/libjpeg/src/win/jpeg62-memsrcdst.def
new file mode 100644
index 00000000..4d24a149
--- /dev/null
+++ b/3rdparty/libjpeg/src/win/jpeg62-memsrcdst.def
@@ -0,0 +1,108 @@
+EXPORTS
+  jcopy_block_row @ 1 ;
+  jcopy_sample_rows @ 2 ;
+  jdiv_round_up @ 3 ;
+  jinit_1pass_quantizer @ 4 ;
+  jinit_2pass_quantizer @ 5 ;
+  jinit_c_coef_controller @ 6 ;
+  jinit_c_main_controller @ 7 ;
+  jinit_c_master_control @ 8 ;
+  jinit_c_prep_controller @ 9 ;
+  jinit_color_converter @ 10 ;
+  jinit_color_deconverter @ 11 ;
+  jinit_compress_master @ 12 ;
+  jinit_d_coef_controller @ 13 ;
+  jinit_d_main_controller @ 14 ;
+  jinit_d_post_controller @ 15 ;
+  jinit_downsampler @ 16 ;
+  jinit_forward_dct @ 17 ;
+  jinit_huff_decoder @ 18 ;
+  jinit_huff_encoder @ 19 ;
+  jinit_input_controller @ 20 ;
+  jinit_inverse_dct @ 21 ;
+  jinit_marker_reader @ 22 ;
+  jinit_marker_writer @ 23 ;
+  jinit_master_decompress @ 24 ;
+  jinit_memory_mgr @ 25 ;
+  jinit_merged_upsampler @ 26 ;
+  jinit_phuff_decoder @ 27 ;
+  jinit_phuff_encoder @ 28 ;
+  jinit_upsampler @ 29 ;
+  jpeg_CreateCompress @ 30 ;
+  jpeg_CreateDecompress @ 31 ;
+  jpeg_abort @ 32 ;
+  jpeg_abort_compress @ 33 ;
+  jpeg_abort_decompress @ 34 ;
+  jpeg_add_quant_table @ 35 ;
+  jpeg_alloc_huff_table @ 36 ;
+  jpeg_alloc_quant_table @ 37 ;
+  jpeg_calc_output_dimensions @ 38 ;
+  jpeg_consume_input @ 39 ;
+  jpeg_copy_critical_parameters @ 40 ;
+  jpeg_default_colorspace @ 41 ;
+  jpeg_destroy @ 42 ;
+  jpeg_destroy_compress @ 43 ;
+  jpeg_destroy_decompress @ 44 ;
+  jpeg_fdct_float @ 45 ;
+  jpeg_fdct_ifast @ 46 ;
+  jpeg_fdct_islow @ 47 ;
+  jpeg_fill_bit_buffer @ 48 ;
+  jpeg_finish_compress @ 49 ;
+  jpeg_finish_decompress @ 50 ;
+  jpeg_finish_output @ 51 ;
+  jpeg_free_large @ 52 ;
+  jpeg_free_small @ 53 ;
+  jpeg_gen_optimal_table @ 54 ;
+  jpeg_get_large @ 55 ;
+  jpeg_get_small @ 56 ;
+  jpeg_has_multiple_scans @ 57 ;
+  jpeg_huff_decode @ 58 ;
+  jpeg_idct_1x1 @ 59 ;
+  jpeg_idct_2x2 @ 60 ;
+  jpeg_idct_4x4 @ 61 ;
+  jpeg_idct_float @ 62 ;
+  jpeg_idct_ifast @ 63 ;
+  jpeg_idct_islow @ 64 ;
+  jpeg_input_complete @ 65 ;
+  jpeg_make_c_derived_tbl @ 66 ;
+  jpeg_make_d_derived_tbl @ 67 ;
+  jpeg_mem_available @ 68 ;
+  jpeg_mem_init @ 69 ;
+  jpeg_mem_term @ 70 ;
+  jpeg_new_colormap @ 71 ;
+  jpeg_open_backing_store @ 72 ;
+  jpeg_quality_scaling @ 73 ;
+  jpeg_read_coefficients @ 74 ;
+  jpeg_read_header @ 75 ;
+  jpeg_read_raw_data @ 76 ;
+  jpeg_read_scanlines @ 77 ;
+  jpeg_resync_to_restart @ 78 ;
+  jpeg_save_markers @ 79 ;
+  jpeg_set_colorspace @ 80 ;
+  jpeg_set_defaults @ 81 ;
+  jpeg_set_linear_quality @ 82 ;
+  jpeg_set_marker_processor @ 83 ;
+  jpeg_set_quality @ 84 ;
+  jpeg_simple_progression @ 85 ;
+  jpeg_start_compress @ 86 ;
+  jpeg_start_decompress @ 87 ;
+  jpeg_start_output @ 88 ;
+  jpeg_std_error @ 89 ;
+  jpeg_stdio_dest @ 90 ;
+  jpeg_stdio_src @ 91 ;
+  jpeg_suppress_tables @ 92 ;
+  jpeg_write_coefficients @ 93 ;
+  jpeg_write_m_byte @ 94 ;
+  jpeg_write_m_header @ 95 ;
+  jpeg_write_marker @ 96 ;
+  jpeg_write_raw_data @ 97 ;
+  jpeg_write_scanlines @ 98 ;
+  jpeg_write_tables @ 99 ;
+  jround_up @ 100 ;
+  jzero_far @ 101 ;
+  jpeg_mem_dest @ 102 ;
+  jpeg_mem_src @ 103 ;
+  jpeg_skip_scanlines @ 104 ;
+  jpeg_crop_scanline @ 105 ;
+  jpeg_read_icc_profile @ 106 ;
+  jpeg_write_icc_profile @ 107 ;
diff --git a/3rdparty/libjpeg/src/win/jpeg62.def b/3rdparty/libjpeg/src/win/jpeg62.def
new file mode 100644
index 00000000..f3c69b26
--- /dev/null
+++ b/3rdparty/libjpeg/src/win/jpeg62.def
@@ -0,0 +1,106 @@
+EXPORTS
+  jcopy_block_row @ 1 ;
+  jcopy_sample_rows @ 2 ;
+  jdiv_round_up @ 3 ;
+  jinit_1pass_quantizer @ 4 ;
+  jinit_2pass_quantizer @ 5 ;
+  jinit_c_coef_controller @ 6 ;
+  jinit_c_main_controller @ 7 ;
+  jinit_c_master_control @ 8 ;
+  jinit_c_prep_controller @ 9 ;
+  jinit_color_converter @ 10 ;
+  jinit_color_deconverter @ 11 ;
+  jinit_compress_master @ 12 ;
+  jinit_d_coef_controller @ 13 ;
+  jinit_d_main_controller @ 14 ;
+  jinit_d_post_controller @ 15 ;
+  jinit_downsampler @ 16 ;
+  jinit_forward_dct @ 17 ;
+  jinit_huff_decoder @ 18 ;
+  jinit_huff_encoder @ 19 ;
+  jinit_input_controller @ 20 ;
+  jinit_inverse_dct @ 21 ;
+  jinit_marker_reader @ 22 ;
+  jinit_marker_writer @ 23 ;
+  jinit_master_decompress @ 24 ;
+  jinit_memory_mgr @ 25 ;
+  jinit_merged_upsampler @ 26 ;
+  jinit_phuff_decoder @ 27 ;
+  jinit_phuff_encoder @ 28 ;
+  jinit_upsampler @ 29 ;
+  jpeg_CreateCompress @ 30 ;
+  jpeg_CreateDecompress @ 31 ;
+  jpeg_abort @ 32 ;
+  jpeg_abort_compress @ 33 ;
+  jpeg_abort_decompress @ 34 ;
+  jpeg_add_quant_table @ 35 ;
+  jpeg_alloc_huff_table @ 36 ;
+  jpeg_alloc_quant_table @ 37 ;
+  jpeg_calc_output_dimensions @ 38 ;
+  jpeg_consume_input @ 39 ;
+  jpeg_copy_critical_parameters @ 40 ;
+  jpeg_default_colorspace @ 41 ;
+  jpeg_destroy @ 42 ;
+  jpeg_destroy_compress @ 43 ;
+  jpeg_destroy_decompress @ 44 ;
+  jpeg_fdct_float @ 45 ;
+  jpeg_fdct_ifast @ 46 ;
+  jpeg_fdct_islow @ 47 ;
+  jpeg_fill_bit_buffer @ 48 ;
+  jpeg_finish_compress @ 49 ;
+  jpeg_finish_decompress @ 50 ;
+  jpeg_finish_output @ 51 ;
+  jpeg_free_large @ 52 ;
+  jpeg_free_small @ 53 ;
+  jpeg_gen_optimal_table @ 54 ;
+  jpeg_get_large @ 55 ;
+  jpeg_get_small @ 56 ;
+  jpeg_has_multiple_scans @ 57 ;
+  jpeg_huff_decode @ 58 ;
+  jpeg_idct_1x1 @ 59 ;
+  jpeg_idct_2x2 @ 60 ;
+  jpeg_idct_4x4 @ 61 ;
+  jpeg_idct_float @ 62 ;
+  jpeg_idct_ifast @ 63 ;
+  jpeg_idct_islow @ 64 ;
+  jpeg_input_complete @ 65 ;
+  jpeg_make_c_derived_tbl @ 66 ;
+  jpeg_make_d_derived_tbl @ 67 ;
+  jpeg_mem_available @ 68 ;
+  jpeg_mem_init @ 69 ;
+  jpeg_mem_term @ 70 ;
+  jpeg_new_colormap @ 71 ;
+  jpeg_open_backing_store @ 72 ;
+  jpeg_quality_scaling @ 73 ;
+  jpeg_read_coefficients @ 74 ;
+  jpeg_read_header @ 75 ;
+  jpeg_read_raw_data @ 76 ;
+  jpeg_read_scanlines @ 77 ;
+  jpeg_resync_to_restart @ 78 ;
+  jpeg_save_markers @ 79 ;
+  jpeg_set_colorspace @ 80 ;
+  jpeg_set_defaults @ 81 ;
+  jpeg_set_linear_quality @ 82 ;
+  jpeg_set_marker_processor @ 83 ;
+  jpeg_set_quality @ 84 ;
+  jpeg_simple_progression @ 85 ;
+  jpeg_start_compress @ 86 ;
+  jpeg_start_decompress @ 87 ;
+  jpeg_start_output @ 88 ;
+  jpeg_std_error @ 89 ;
+  jpeg_stdio_dest @ 90 ;
+  jpeg_stdio_src @ 91 ;
+  jpeg_suppress_tables @ 92 ;
+  jpeg_write_coefficients @ 93 ;
+  jpeg_write_m_byte @ 94 ;
+  jpeg_write_m_header @ 95 ;
+  jpeg_write_marker @ 96 ;
+  jpeg_write_raw_data @ 97 ;
+  jpeg_write_scanlines @ 98 ;
+  jpeg_write_tables @ 99 ;
+  jround_up @ 100 ;
+  jzero_far @ 101 ;
+  jpeg_skip_scanlines @ 102 ;
+  jpeg_crop_scanline @ 103 ;
+  jpeg_read_icc_profile @ 104 ;
+  jpeg_write_icc_profile @ 105 ;
diff --git a/3rdparty/libjpeg/src/win/jpeg7-memsrcdst.def b/3rdparty/libjpeg/src/win/jpeg7-memsrcdst.def
new file mode 100644
index 00000000..a005aff0
--- /dev/null
+++ b/3rdparty/libjpeg/src/win/jpeg7-memsrcdst.def
@@ -0,0 +1,110 @@
+EXPORTS
+  jcopy_block_row @ 1 ;
+  jcopy_sample_rows @ 2 ;
+  jdiv_round_up @ 3 ;
+  jinit_1pass_quantizer @ 4 ;
+  jinit_2pass_quantizer @ 5 ;
+  jinit_c_coef_controller @ 6 ;
+  jinit_c_main_controller @ 7 ;
+  jinit_c_master_control @ 8 ;
+  jinit_c_prep_controller @ 9 ;
+  jinit_color_converter @ 10 ;
+  jinit_color_deconverter @ 11 ;
+  jinit_compress_master @ 12 ;
+  jinit_d_coef_controller @ 13 ;
+  jinit_d_main_controller @ 14 ;
+  jinit_d_post_controller @ 15 ;
+  jinit_downsampler @ 16 ;
+  jinit_forward_dct @ 17 ;
+  jinit_huff_decoder @ 18 ;
+  jinit_huff_encoder @ 19 ;
+  jinit_input_controller @ 20 ;
+  jinit_inverse_dct @ 21 ;
+  jinit_marker_reader @ 22 ;
+  jinit_marker_writer @ 23 ;
+  jinit_master_decompress @ 24 ;
+  jinit_memory_mgr @ 25 ;
+  jinit_merged_upsampler @ 26 ;
+  jinit_phuff_decoder @ 27 ;
+  jinit_phuff_encoder @ 28 ;
+  jinit_upsampler @ 29 ;
+  jpeg_CreateCompress @ 30 ;
+  jpeg_CreateDecompress @ 31 ;
+  jpeg_abort @ 32 ;
+  jpeg_abort_compress @ 33 ;
+  jpeg_abort_decompress @ 34 ;
+  jpeg_add_quant_table @ 35 ;
+  jpeg_alloc_huff_table @ 36 ;
+  jpeg_alloc_quant_table @ 37 ;
+  jpeg_calc_jpeg_dimensions @ 38 ;
+  jpeg_calc_output_dimensions @ 39 ;
+  jpeg_consume_input @ 40 ;
+  jpeg_copy_critical_parameters @ 41 ;
+  jpeg_default_colorspace @ 42 ;
+  jpeg_default_qtables @ 43 ;
+  jpeg_destroy @ 44 ;
+  jpeg_destroy_compress @ 45 ;
+  jpeg_destroy_decompress @ 46 ;
+  jpeg_fdct_float @ 47 ;
+  jpeg_fdct_ifast @ 48 ;
+  jpeg_fdct_islow @ 49 ;
+  jpeg_fill_bit_buffer @ 50 ;
+  jpeg_finish_compress @ 51 ;
+  jpeg_finish_decompress @ 52 ;
+  jpeg_finish_output @ 53 ;
+  jpeg_free_large @ 54 ;
+  jpeg_free_small @ 55 ;
+  jpeg_gen_optimal_table @ 56 ;
+  jpeg_get_large @ 57 ;
+  jpeg_get_small @ 58 ;
+  jpeg_has_multiple_scans @ 59 ;
+  jpeg_huff_decode @ 60 ;
+  jpeg_idct_1x1 @ 61 ;
+  jpeg_idct_2x2 @ 62 ;
+  jpeg_idct_4x4 @ 63 ;
+  jpeg_idct_float @ 64 ;
+  jpeg_idct_ifast @ 65 ;
+  jpeg_idct_islow @ 66 ;
+  jpeg_input_complete @ 67 ;
+  jpeg_make_c_derived_tbl @ 68 ;
+  jpeg_make_d_derived_tbl @ 69 ;
+  jpeg_mem_available @ 70 ;
+  jpeg_mem_init @ 71 ;
+  jpeg_mem_term @ 72 ;
+  jpeg_new_colormap @ 73 ;
+  jpeg_open_backing_store @ 74 ;
+  jpeg_quality_scaling @ 75 ;
+  jpeg_read_coefficients @ 76 ;
+  jpeg_read_header @ 77 ;
+  jpeg_read_raw_data @ 78 ;
+  jpeg_read_scanlines @ 79 ;
+  jpeg_resync_to_restart @ 80 ;
+  jpeg_save_markers @ 81 ;
+  jpeg_set_colorspace @ 82 ;
+  jpeg_set_defaults @ 83 ;
+  jpeg_set_linear_quality @ 84 ;
+  jpeg_set_marker_processor @ 85 ;
+  jpeg_set_quality @ 86 ;
+  jpeg_simple_progression @ 87 ;
+  jpeg_start_compress @ 88 ;
+  jpeg_start_decompress @ 89 ;
+  jpeg_start_output @ 90 ;
+  jpeg_std_error @ 91 ;
+  jpeg_stdio_dest @ 92 ;
+  jpeg_stdio_src @ 93 ;
+  jpeg_suppress_tables @ 94 ;
+  jpeg_write_coefficients @ 95 ;
+  jpeg_write_m_byte @ 96 ;
+  jpeg_write_m_header @ 97 ;
+  jpeg_write_marker @ 98 ;
+  jpeg_write_raw_data @ 99 ;
+  jpeg_write_scanlines @ 100 ;
+  jpeg_write_tables @ 101 ;
+  jround_up @ 102 ;
+  jzero_far @ 103 ;
+  jpeg_mem_dest @ 104 ;
+  jpeg_mem_src @ 105 ;
+  jpeg_skip_scanlines @ 106 ;
+  jpeg_crop_scanline @ 107 ;
+  jpeg_read_icc_profile @ 108 ;
+  jpeg_write_icc_profile @ 109 ;
diff --git a/3rdparty/libjpeg/src/win/jpeg7.def b/3rdparty/libjpeg/src/win/jpeg7.def
new file mode 100644
index 00000000..49f4c02d
--- /dev/null
+++ b/3rdparty/libjpeg/src/win/jpeg7.def
@@ -0,0 +1,108 @@
+EXPORTS
+  jcopy_block_row @ 1 ;
+  jcopy_sample_rows @ 2 ;
+  jdiv_round_up @ 3 ;
+  jinit_1pass_quantizer @ 4 ;
+  jinit_2pass_quantizer @ 5 ;
+  jinit_c_coef_controller @ 6 ;
+  jinit_c_main_controller @ 7 ;
+  jinit_c_master_control @ 8 ;
+  jinit_c_prep_controller @ 9 ;
+  jinit_color_converter @ 10 ;
+  jinit_color_deconverter @ 11 ;
+  jinit_compress_master @ 12 ;
+  jinit_d_coef_controller @ 13 ;
+  jinit_d_main_controller @ 14 ;
+  jinit_d_post_controller @ 15 ;
+  jinit_downsampler @ 16 ;
+  jinit_forward_dct @ 17 ;
+  jinit_huff_decoder @ 18 ;
+  jinit_huff_encoder @ 19 ;
+  jinit_input_controller @ 20 ;
+  jinit_inverse_dct @ 21 ;
+  jinit_marker_reader @ 22 ;
+  jinit_marker_writer @ 23 ;
+  jinit_master_decompress @ 24 ;
+  jinit_memory_mgr @ 25 ;
+  jinit_merged_upsampler @ 26 ;
+  jinit_phuff_decoder @ 27 ;
+  jinit_phuff_encoder @ 28 ;
+  jinit_upsampler @ 29 ;
+  jpeg_CreateCompress @ 30 ;
+  jpeg_CreateDecompress @ 31 ;
+  jpeg_abort @ 32 ;
+  jpeg_abort_compress @ 33 ;
+  jpeg_abort_decompress @ 34 ;
+  jpeg_add_quant_table @ 35 ;
+  jpeg_alloc_huff_table @ 36 ;
+  jpeg_alloc_quant_table @ 37 ;
+  jpeg_calc_jpeg_dimensions @ 38 ;
+  jpeg_calc_output_dimensions @ 39 ;
+  jpeg_consume_input @ 40 ;
+  jpeg_copy_critical_parameters @ 41 ;
+  jpeg_default_colorspace @ 42 ;
+  jpeg_default_qtables @ 43 ;
+  jpeg_destroy @ 44 ;
+  jpeg_destroy_compress @ 45 ;
+  jpeg_destroy_decompress @ 46 ;
+  jpeg_fdct_float @ 47 ;
+  jpeg_fdct_ifast @ 48 ;
+  jpeg_fdct_islow @ 49 ;
+  jpeg_fill_bit_buffer @ 50 ;
+  jpeg_finish_compress @ 51 ;
+  jpeg_finish_decompress @ 52 ;
+  jpeg_finish_output @ 53 ;
+  jpeg_free_large @ 54 ;
+  jpeg_free_small @ 55 ;
+  jpeg_gen_optimal_table @ 56 ;
+  jpeg_get_large @ 57 ;
+  jpeg_get_small @ 58 ;
+  jpeg_has_multiple_scans @ 59 ;
+  jpeg_huff_decode @ 60 ;
+  jpeg_idct_1x1 @ 61 ;
+  jpeg_idct_2x2 @ 62 ;
+  jpeg_idct_4x4 @ 63 ;
+  jpeg_idct_float @ 64 ;
+  jpeg_idct_ifast @ 65 ;
+  jpeg_idct_islow @ 66 ;
+  jpeg_input_complete @ 67 ;
+  jpeg_make_c_derived_tbl @ 68 ;
+  jpeg_make_d_derived_tbl @ 69 ;
+  jpeg_mem_available @ 70 ;
+  jpeg_mem_init @ 71 ;
+  jpeg_mem_term @ 72 ;
+  jpeg_new_colormap @ 73 ;
+  jpeg_open_backing_store @ 74 ;
+  jpeg_quality_scaling @ 75 ;
+  jpeg_read_coefficients @ 76 ;
+  jpeg_read_header @ 77 ;
+  jpeg_read_raw_data @ 78 ;
+  jpeg_read_scanlines @ 79 ;
+  jpeg_resync_to_restart @ 80 ;
+  jpeg_save_markers @ 81 ;
+  jpeg_set_colorspace @ 82 ;
+  jpeg_set_defaults @ 83 ;
+  jpeg_set_linear_quality @ 84 ;
+  jpeg_set_marker_processor @ 85 ;
+  jpeg_set_quality @ 86 ;
+  jpeg_simple_progression @ 87 ;
+  jpeg_start_compress @ 88 ;
+  jpeg_start_decompress @ 89 ;
+  jpeg_start_output @ 90 ;
+  jpeg_std_error @ 91 ;
+  jpeg_stdio_dest @ 92 ;
+  jpeg_stdio_src @ 93 ;
+  jpeg_suppress_tables @ 94 ;
+  jpeg_write_coefficients @ 95 ;
+  jpeg_write_m_byte @ 96 ;
+  jpeg_write_m_header @ 97 ;
+  jpeg_write_marker @ 98 ;
+  jpeg_write_raw_data @ 99 ;
+  jpeg_write_scanlines @ 100 ;
+  jpeg_write_tables @ 101 ;
+  jround_up @ 102 ;
+  jzero_far @ 103 ;
+  jpeg_skip_scanlines @ 104 ;
+  jpeg_crop_scanline @ 105 ;
+  jpeg_read_icc_profile @ 106 ;
+  jpeg_write_icc_profile @ 107 ;
diff --git a/3rdparty/libjpeg/src/win/jpeg8.def b/3rdparty/libjpeg/src/win/jpeg8.def
new file mode 100644
index 00000000..0a531256
--- /dev/null
+++ b/3rdparty/libjpeg/src/win/jpeg8.def
@@ -0,0 +1,111 @@
+EXPORTS
+  jcopy_block_row @ 1 ;
+  jcopy_sample_rows @ 2 ;
+  jdiv_round_up @ 3 ;
+  jinit_1pass_quantizer @ 4 ;
+  jinit_2pass_quantizer @ 5 ;
+  jinit_c_coef_controller @ 6 ;
+  jinit_c_main_controller @ 7 ;
+  jinit_c_master_control @ 8 ;
+  jinit_c_prep_controller @ 9 ;
+  jinit_color_converter @ 10 ;
+  jinit_color_deconverter @ 11 ;
+  jinit_compress_master @ 12 ;
+  jinit_d_coef_controller @ 13 ;
+  jinit_d_main_controller @ 14 ;
+  jinit_d_post_controller @ 15 ;
+  jinit_downsampler @ 16 ;
+  jinit_forward_dct @ 17 ;
+  jinit_huff_decoder @ 18 ;
+  jinit_huff_encoder @ 19 ;
+  jinit_input_controller @ 20 ;
+  jinit_inverse_dct @ 21 ;
+  jinit_marker_reader @ 22 ;
+  jinit_marker_writer @ 23 ;
+  jinit_master_decompress @ 24 ;
+  jinit_memory_mgr @ 25 ;
+  jinit_merged_upsampler @ 26 ;
+  jinit_phuff_decoder @ 27 ;
+  jinit_phuff_encoder @ 28 ;
+  jinit_upsampler @ 29 ;
+  jpeg_CreateCompress @ 30 ;
+  jpeg_CreateDecompress @ 31 ;
+  jpeg_abort @ 32 ;
+  jpeg_abort_compress @ 33 ;
+  jpeg_abort_decompress @ 34 ;
+  jpeg_add_quant_table @ 35 ;
+  jpeg_alloc_huff_table @ 36 ;
+  jpeg_alloc_quant_table @ 37 ;
+  jpeg_calc_jpeg_dimensions @ 38 ;
+  jpeg_calc_output_dimensions @ 39 ;
+  jpeg_consume_input @ 40 ;
+  jpeg_copy_critical_parameters @ 41 ;
+  jpeg_core_output_dimensions @ 42 ;
+  jpeg_default_colorspace @ 43 ;
+  jpeg_default_qtables @ 44 ;
+  jpeg_destroy @ 45 ;
+  jpeg_destroy_compress @ 46 ;
+  jpeg_destroy_decompress @ 47 ;
+  jpeg_fdct_float @ 48 ;
+  jpeg_fdct_ifast @ 49 ;
+  jpeg_fdct_islow @ 50 ;
+  jpeg_fill_bit_buffer @ 51 ;
+  jpeg_finish_compress @ 52 ;
+  jpeg_finish_decompress @ 53 ;
+  jpeg_finish_output @ 54 ;
+  jpeg_free_large @ 55 ;
+  jpeg_free_small @ 56 ;
+  jpeg_gen_optimal_table @ 57 ;
+  jpeg_get_large @ 58 ;
+  jpeg_get_small @ 59 ;
+  jpeg_has_multiple_scans @ 60 ;
+  jpeg_huff_decode @ 61 ;
+  jpeg_idct_1x1 @ 62 ;
+  jpeg_idct_2x2 @ 63 ;
+  jpeg_idct_4x4 @ 64 ;
+  jpeg_idct_float @ 65 ;
+  jpeg_idct_ifast @ 66 ;
+  jpeg_idct_islow @ 67 ;
+  jpeg_input_complete @ 68 ;
+  jpeg_make_c_derived_tbl @ 69 ;
+  jpeg_make_d_derived_tbl @ 70 ;
+  jpeg_mem_available @ 71 ;
+  jpeg_mem_dest @ 72 ;
+  jpeg_mem_init @ 73 ;
+  jpeg_mem_src @ 74 ;
+  jpeg_mem_term @ 75 ;
+  jpeg_new_colormap @ 76 ;
+  jpeg_open_backing_store @ 77 ;
+  jpeg_quality_scaling @ 78 ;
+  jpeg_read_coefficients @ 79 ;
+  jpeg_read_header @ 80 ;
+  jpeg_read_raw_data @ 81 ;
+  jpeg_read_scanlines @ 82 ;
+  jpeg_resync_to_restart @ 83 ;
+  jpeg_save_markers @ 84 ;
+  jpeg_set_colorspace @ 85 ;
+  jpeg_set_defaults @ 86 ;
+  jpeg_set_linear_quality @ 87 ;
+  jpeg_set_marker_processor @ 88 ;
+  jpeg_set_quality @ 89 ;
+  jpeg_simple_progression @ 90 ;
+  jpeg_start_compress @ 91 ;
+  jpeg_start_decompress @ 92 ;
+  jpeg_start_output @ 93 ;
+  jpeg_std_error @ 94 ;
+  jpeg_stdio_dest @ 95 ;
+  jpeg_stdio_src @ 96 ;
+  jpeg_suppress_tables @ 97 ;
+  jpeg_write_coefficients @ 98 ;
+  jpeg_write_m_byte @ 99 ;
+  jpeg_write_m_header @ 100 ;
+  jpeg_write_marker @ 101 ;
+  jpeg_write_raw_data @ 102 ;
+  jpeg_write_scanlines @ 103 ;
+  jpeg_write_tables @ 104 ;
+  jround_up @ 105 ;
+  jzero_far @ 106 ;
+  jpeg_skip_scanlines @ 107 ;
+  jpeg_crop_scanline @ 108 ;
+  jpeg_read_icc_profile @ 109 ;
+  jpeg_write_icc_profile @ 110 ;
diff --git a/3rdparty/libjpeg/src/win/projectTargets.cmake.in b/3rdparty/libjpeg/src/win/projectTargets.cmake.in
new file mode 100644
index 00000000..05ab4984
--- /dev/null
+++ b/3rdparty/libjpeg/src/win/projectTargets.cmake.in
@@ -0,0 +1,115 @@
+# Generated by CMake
+
+if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.5)
+   message(FATAL_ERROR "CMake >= 2.6.0 required")
+endif()
+cmake_policy(PUSH)
+cmake_policy(VERSION 2.6)
+#----------------------------------------------------------------
+# Generated CMake target import file.
+#----------------------------------------------------------------
+
+# Commands may need to know the format version.
+set(CMAKE_IMPORT_FILE_VERSION 1)
+
+# Protect against multiple inclusion, which would fail when already imported targets are added once more.
+set(_targetsDefined)
+set(_targetsNotDefined)
+set(_expectedTargets)
+foreach(_expectedTarget @CMAKE_PROJECT_NAME@::jpeg @CMAKE_PROJECT_NAME@::turbojpeg @CMAKE_PROJECT_NAME@::turbojpeg-static @CMAKE_PROJECT_NAME@::jpeg-static)
+  list(APPEND _expectedTargets ${_expectedTarget})
+  if(NOT TARGET ${_expectedTarget})
+    list(APPEND _targetsNotDefined ${_expectedTarget})
+  endif()
+  if(TARGET ${_expectedTarget})
+    list(APPEND _targetsDefined ${_expectedTarget})
+  endif()
+endforeach()
+if("${_targetsDefined}" STREQUAL "${_expectedTargets}")
+  unset(_targetsDefined)
+  unset(_targetsNotDefined)
+  unset(_expectedTargets)
+  set(CMAKE_IMPORT_FILE_VERSION)
+  cmake_policy(POP)
+  return()
+endif()
+if(NOT "${_targetsDefined}" STREQUAL "")
+  message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_targetsDefined}\nTargets not yet defined: ${_targetsNotDefined}\n")
+endif()
+unset(_targetsDefined)
+unset(_targetsNotDefined)
+unset(_expectedTargets)
+
+
+# Compute the installation prefix relative to this file.
+get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH)
+get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH)
+get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH)
+get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH)
+if(_IMPORT_PREFIX STREQUAL "/")
+  set(_IMPORT_PREFIX "")
+endif()
+
+# Create imported target @CMAKE_PROJECT_NAME@::jpeg
+add_library(@CMAKE_PROJECT_NAME@::jpeg SHARED IMPORTED)
+
+set_target_properties(@CMAKE_PROJECT_NAME@::jpeg PROPERTIES
+  INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include"
+)
+
+# Create imported target @CMAKE_PROJECT_NAME@::turbojpeg
+add_library(@CMAKE_PROJECT_NAME@::turbojpeg SHARED IMPORTED)
+
+set_target_properties(@CMAKE_PROJECT_NAME@::turbojpeg PROPERTIES
+  INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include"
+)
+
+# Create imported target @CMAKE_PROJECT_NAME@::turbojpeg-static
+add_library(@CMAKE_PROJECT_NAME@::turbojpeg-static STATIC IMPORTED)
+
+set_target_properties(@CMAKE_PROJECT_NAME@::turbojpeg-static PROPERTIES
+  INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include"
+)
+
+# Create imported target @CMAKE_PROJECT_NAME@::jpeg-static
+add_library(@CMAKE_PROJECT_NAME@::jpeg-static STATIC IMPORTED)
+
+set_target_properties(@CMAKE_PROJECT_NAME@::jpeg-static PROPERTIES
+  INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include"
+)
+
+# Load information for each installed configuration.
+get_filename_component(_DIR "${CMAKE_CURRENT_LIST_FILE}" PATH)
+file(GLOB CONFIG_FILES "${_DIR}/@CMAKE_PROJECT_NAME@Targets-*.cmake")
+foreach(f ${CONFIG_FILES})
+  include(${f})
+endforeach()
+
+# Cleanup temporary variables.
+set(_IMPORT_PREFIX)
+
+# Loop over all imported files and verify that they actually exist
+foreach(target ${_IMPORT_CHECK_TARGETS} )
+  foreach(file ${_IMPORT_CHECK_FILES_FOR_${target}} )
+    if(NOT EXISTS "${file}" )
+      message(FATAL_ERROR "The imported target \"${target}\" references the file
+   \"${file}\"
+but this file does not exist.  Possible reasons include:
+* The file was deleted, renamed, or moved to another location.
+* An install or uninstall procedure did not complete successfully.
+* The installation package was faulty and contained
+   \"${CMAKE_CURRENT_LIST_FILE}\"
+but not all the files it references.
+")
+    endif()
+  endforeach()
+  unset(_IMPORT_CHECK_FILES_FOR_${target})
+endforeach()
+unset(_IMPORT_CHECK_TARGETS)
+
+# This file does not depend on other imported targets which have
+# been exported from the same project but in a separate export set.
+
+# Commands beyond this point should not need to know the version.
+set(CMAKE_IMPORT_FILE_VERSION)
+cmake_policy(POP)
diff --git a/3rdparty/libjpeg/src/win/vc/projectTargets-release.cmake.in b/3rdparty/libjpeg/src/win/vc/projectTargets-release.cmake.in
new file mode 100644
index 00000000..7abb281b
--- /dev/null
+++ b/3rdparty/libjpeg/src/win/vc/projectTargets-release.cmake.in
@@ -0,0 +1,49 @@
+#----------------------------------------------------------------
+# Generated CMake target import file for configuration "Release".
+#----------------------------------------------------------------
+
+# Commands may need to know the format version.
+set(CMAKE_IMPORT_FILE_VERSION 1)
+
+# Import target "@CMAKE_PROJECT_NAME@::jpeg" for configuration "Release"
+set_property(TARGET @CMAKE_PROJECT_NAME@::jpeg APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(@CMAKE_PROJECT_NAME@::jpeg PROPERTIES
+  IMPORTED_IMPLIB_RELEASE "${_IMPORT_PREFIX}/lib/jpeg.lib"
+  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/bin/jpeg62.dll"
+  )
+
+list(APPEND _IMPORT_CHECK_TARGETS @CMAKE_PROJECT_NAME@::jpeg )
+list(APPEND _IMPORT_CHECK_FILES_FOR_@CMAKE_PROJECT_NAME@::jpeg "${_IMPORT_PREFIX}/lib/jpeg.lib" "${_IMPORT_PREFIX}/bin/jpeg62.dll" )
+
+# Import target "@CMAKE_PROJECT_NAME@::turbojpeg" for configuration "Release"
+set_property(TARGET @CMAKE_PROJECT_NAME@::turbojpeg APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(@CMAKE_PROJECT_NAME@::turbojpeg PROPERTIES
+  IMPORTED_IMPLIB_RELEASE "${_IMPORT_PREFIX}/lib/turbojpeg.lib"
+  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/bin/turbojpeg.dll"
+  )
+
+list(APPEND _IMPORT_CHECK_TARGETS @CMAKE_PROJECT_NAME@::turbojpeg )
+list(APPEND _IMPORT_CHECK_FILES_FOR_@CMAKE_PROJECT_NAME@::turbojpeg "${_IMPORT_PREFIX}/lib/turbojpeg.lib" "${_IMPORT_PREFIX}/bin/turbojpeg.dll" )
+
+# Import target "@CMAKE_PROJECT_NAME@::turbojpeg-static" for configuration "Release"
+set_property(TARGET @CMAKE_PROJECT_NAME@::turbojpeg-static APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(@CMAKE_PROJECT_NAME@::turbojpeg-static PROPERTIES
+  IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "ASM_NASM;C"
+  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib/turbojpeg-static.lib"
+  )
+
+list(APPEND _IMPORT_CHECK_TARGETS @CMAKE_PROJECT_NAME@::turbojpeg-static )
+list(APPEND _IMPORT_CHECK_FILES_FOR_@CMAKE_PROJECT_NAME@::turbojpeg-static "${_IMPORT_PREFIX}/lib/turbojpeg-static.lib" )
+
+# Import target "@CMAKE_PROJECT_NAME@::jpeg-static" for configuration "Release"
+set_property(TARGET @CMAKE_PROJECT_NAME@::jpeg-static APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(@CMAKE_PROJECT_NAME@::jpeg-static PROPERTIES
+  IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "ASM_NASM;C"
+  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib/jpeg-static.lib"
+  )
+
+list(APPEND _IMPORT_CHECK_TARGETS @CMAKE_PROJECT_NAME@::jpeg-static )
+list(APPEND _IMPORT_CHECK_FILES_FOR_@CMAKE_PROJECT_NAME@::jpeg-static "${_IMPORT_PREFIX}/lib/jpeg-static.lib" )
+
+# Commands beyond this point should not need to know the version.
+set(CMAKE_IMPORT_FILE_VERSION)
diff --git a/3rdparty/libjpeg/src/wizard.txt b/3rdparty/libjpeg/src/wizard.txt
new file mode 100644
index 00000000..c57fe38a
--- /dev/null
+++ b/3rdparty/libjpeg/src/wizard.txt
@@ -0,0 +1,212 @@
+Advanced usage instructions for the Independent JPEG Group's JPEG software
+==========================================================================
+
+This file describes cjpeg's "switches for wizards".
+
+The "wizard" switches are intended for experimentation with JPEG by persons
+who are reasonably knowledgeable about the JPEG standard.  If you don't know
+what you are doing, DON'T USE THESE SWITCHES.  You'll likely produce files
+with worse image quality and/or poorer compression than you'd get from the
+default settings.  Furthermore, these switches must be used with caution
+when making files intended for general use, because not all JPEG decoders
+will support unusual JPEG parameter settings.
+
+
+Quantization Table Adjustment
+-----------------------------
+
+Ordinarily, cjpeg starts with a default set of tables (the same ones given
+as examples in the JPEG standard) and scales them up or down according to
+the -quality setting.  The details of the scaling algorithm can be found in
+jcparam.c.  At very low quality settings, some quantization table entries
+can get scaled up to values exceeding 255.  Although 2-byte quantization
+values are supported by the IJG software, this feature is not in baseline
+JPEG and is not supported by all implementations.  If you need to ensure
+wide compatibility of low-quality files, you can constrain the scaled
+quantization values to no more than 255 by giving the -baseline switch.
+Note that use of -baseline will result in poorer quality for the same file
+size, since more bits than necessary are expended on higher AC coefficients.
+
+You can substitute a different set of quantization values by using the
+-qtables switch:
+
+        -qtables file   Use the quantization tables given in the named file.
+
+The specified file should be a text file containing decimal quantization
+values.  The file should contain one to four tables, each of 64 elements.
+The tables are implicitly numbered 0,1,etc. in order of appearance.  Table
+entries appear in normal array order (NOT in the zigzag order in which they
+will be stored in the JPEG file).
+
+Quantization table files are free format, in that arbitrary whitespace can
+appear between numbers.  Also, comments can be included: a comment starts
+with '#' and extends to the end of the line.  Here is an example file that
+duplicates the default quantization tables:
+
+        # Quantization tables given in Annex K (Clause K.1) of
+        # Recommendation ITU-T T.81 (1992) | ISO/IEC 10918-1:1994.
+
+        # This is table 0 (the luminance table):
+          16  11  10  16  24  40  51  61
+          12  12  14  19  26  58  60  55
+          14  13  16  24  40  57  69  56
+          14  17  22  29  51  87  80  62
+          18  22  37  56  68 109 103  77
+          24  35  55  64  81 104 113  92
+          49  64  78  87 103 121 120 101
+          72  92  95  98 112 100 103  99
+
+        # This is table 1 (the chrominance table):
+          17  18  24  47  99  99  99  99
+          18  21  26  66  99  99  99  99
+          24  26  56  99  99  99  99  99
+          47  66  99  99  99  99  99  99
+          99  99  99  99  99  99  99  99
+          99  99  99  99  99  99  99  99
+          99  99  99  99  99  99  99  99
+          99  99  99  99  99  99  99  99
+
+If the -qtables switch is used without -quality, then the specified tables
+are used exactly as-is.  If both -qtables and -quality are used, then the
+tables taken from the file are scaled in the same fashion that the default
+tables would be scaled for that quality setting.  If -baseline appears, then
+the quantization values are constrained to the range 1-255.
+
+By default, cjpeg will use quantization table 0 for luminance components and
+table 1 for chrominance components.  To override this choice, use the -qslots
+switch:
+
+        -qslots N[,...]         Select which quantization table to use for
+                                each color component.
+
+The -qslots switch specifies a quantization table number for each color
+component, in the order in which the components appear in the JPEG SOF marker.
+For example, to create a separate table for each of Y,Cb,Cr, you could
+provide a -qtables file that defines three quantization tables and say
+"-qslots 0,1,2".  If -qslots gives fewer table numbers than there are color
+components, then the last table number is repeated as necessary.
+
+
+Sampling Factor Adjustment
+--------------------------
+
+By default, cjpeg uses 2:1 horizontal and vertical downsampling when
+compressing YCbCr data, and no downsampling for all other color spaces.
+You can override this default with the -sample switch:
+
+        -sample HxV[,...]       Set JPEG sampling factors for each color
+                                component.
+
+The -sample switch specifies the JPEG sampling factors for each color
+component, in the order in which they appear in the JPEG SOF marker.
+If you specify fewer HxV pairs than there are components, the remaining
+components are set to 1x1 sampling.  For example, the default YCbCr setting
+is equivalent to "-sample 2x2,1x1,1x1", which can be abbreviated to
+"-sample 2x2".
+
+There are still some JPEG decoders in existence that support only 2x1
+sampling (also called 4:2:2 sampling).  Compatibility with such decoders can
+be achieved by specifying "-sample 2x1".  This is not recommended unless
+really necessary, since it increases file size and encoding/decoding time
+with very little quality gain.
+
+
+Multiple Scan / Progression Control
+-----------------------------------
+
+By default, cjpeg emits a single-scan sequential JPEG file.  The
+-progressive switch generates a progressive JPEG file using a default series
+of progression parameters.  You can create multiple-scan sequential JPEG
+files or progressive JPEG files with custom progression parameters by using
+the -scans switch:
+
+        -scans file     Use the scan sequence given in the named file.
+
+The specified file should be a text file containing a "scan script".
+The script specifies the contents and ordering of the scans to be emitted.
+Each entry in the script defines one scan.  A scan definition specifies
+the components to be included in the scan, and for progressive JPEG it also
+specifies the progression parameters Ss,Se,Ah,Al for the scan.  Scan
+definitions are separated by semicolons (';').  A semicolon after the last
+scan definition is optional.
+
+Each scan definition contains one to four component indexes, optionally
+followed by a colon (':') and the four progressive-JPEG parameters.  The
+component indexes denote which color component(s) are to be transmitted in
+the scan.  Components are numbered in the order in which they appear in the
+JPEG SOF marker, with the first component being numbered 0.  (Note that these
+indexes are not the "component ID" codes assigned to the components, just
+positional indexes.)
+
+The progression parameters for each scan are:
+        Ss      Zigzag index of first coefficient included in scan
+        Se      Zigzag index of last coefficient included in scan
+        Ah      Zero for first scan of a coefficient, else Al of prior scan
+        Al      Successive approximation low bit position for scan
+If the progression parameters are omitted, the values 0,63,0,0 are used,
+producing a sequential JPEG file.  cjpeg automatically determines whether
+the script represents a progressive or sequential file, by observing whether
+Ss and Se values other than 0 and 63 appear.  (The -progressive switch is
+not needed to specify this; in fact, it is ignored when -scans appears.)
+The scan script must meet the JPEG restrictions on progression sequences.
+(cjpeg checks that the spec's requirements are obeyed.)
+
+Scan script files are free format, in that arbitrary whitespace can appear
+between numbers and around punctuation.  Also, comments can be included: a
+comment starts with '#' and extends to the end of the line.  For additional
+legibility, commas or dashes can be placed between values.  (Actually, any
+single punctuation character other than ':' or ';' can be inserted.)  For
+example, the following two scan definitions are equivalent:
+        0 1 2: 0 63 0 0;
+        0,1,2 : 0-63, 0,0 ;
+
+Here is an example of a scan script that generates a partially interleaved
+sequential JPEG file:
+
+        0;                      # Y only in first scan
+        1 2;                    # Cb and Cr in second scan
+
+Here is an example of a progressive scan script using only spectral selection
+(no successive approximation):
+
+        # Interleaved DC scan for Y,Cb,Cr:
+        0,1,2: 0-0,   0, 0 ;
+        # AC scans:
+        0:     1-2,   0, 0 ;    # First two Y AC coefficients
+        0:     3-5,   0, 0 ;    # Three more
+        1:     1-63,  0, 0 ;    # All AC coefficients for Cb
+        2:     1-63,  0, 0 ;    # All AC coefficients for Cr
+        0:     6-9,   0, 0 ;    # More Y coefficients
+        0:     10-63, 0, 0 ;    # Remaining Y coefficients
+
+Here is an example of a successive-approximation script.  This is equivalent
+to the default script used by "cjpeg -progressive" for YCbCr images:
+
+        # Initial DC scan for Y,Cb,Cr (lowest bit not sent)
+        0,1,2: 0-0,   0, 1 ;
+        # First AC scan: send first 5 Y AC coefficients, minus 2 lowest bits:
+        0:     1-5,   0, 2 ;
+        # Send all Cr,Cb AC coefficients, minus lowest bit:
+        # (chroma data is usually too small to be worth subdividing further;
+        #  but note we send Cr first since eye is least sensitive to Cb)
+        2:     1-63,  0, 1 ;
+        1:     1-63,  0, 1 ;
+        # Send remaining Y AC coefficients, minus 2 lowest bits:
+        0:     6-63,  0, 2 ;
+        # Send next-to-lowest bit of all Y AC coefficients:
+        0:     1-63,  2, 1 ;
+        # At this point we've sent all but the lowest bit of all coefficients.
+        # Send lowest bit of DC coefficients
+        0,1,2: 0-0,   1, 0 ;
+        # Send lowest bit of AC coefficients
+        2:     1-63,  1, 0 ;
+        1:     1-63,  1, 0 ;
+        # Y AC lowest bit scan is last; it's usually the largest scan
+        0:     1-63,  1, 0 ;
+
+It may be worth pointing out that this script is tuned for quality settings
+of around 50 to 75.  For lower quality settings, you'd probably want to use
+a script with fewer stages of successive approximation (otherwise the
+initial scans will be really bad).  For higher quality settings, you might
+want to use more stages of successive approximation (so that the initial
+scans are not too large).
diff --git a/3rdparty/libjpeg/src/wrbmp.c b/3rdparty/libjpeg/src/wrbmp.c
new file mode 100644
index 00000000..408a722a
--- /dev/null
+++ b/3rdparty/libjpeg/src/wrbmp.c
@@ -0,0 +1,552 @@
+/*
+ * wrbmp.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1994-1996, Thomas G. Lane.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2013, Linaro Limited.
+ * Copyright (C) 2014-2015, 2017, 2019, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains routines to write output images in Microsoft "BMP"
+ * format (MS Windows 3.x and OS/2 1.x flavors).
+ * Either 8-bit colormapped or 24-bit full-color format can be written.
+ * No compression is supported.
+ *
+ * These routines may need modification for non-Unix environments or
+ * specialized applications.  As they stand, they assume output to
+ * an ordinary stdio stream.
+ *
+ * This code contributed by James Arthur Boucher.
+ */
+
+#include "cmyk.h"
+#include "cdjpeg.h"             /* Common decls for cjpeg/djpeg applications */
+#include "jconfigint.h"
+
+#ifdef BMP_SUPPORTED
+
+
+/*
+ * To support 12-bit JPEG data, we'd have to scale output down to 8 bits.
+ * This is not yet implemented.
+ */
+
+#if BITS_IN_JSAMPLE != 8
+  Sorry, this code only copes with 8-bit JSAMPLEs. /* deliberate syntax err */
+#endif
+
+/*
+ * Since BMP stores scanlines bottom-to-top, we have to invert the image
+ * from JPEG's top-to-bottom order.  To do this, we save the outgoing data
+ * in a virtual array during put_pixel_row calls, then actually emit the
+ * BMP file during finish_output.  The virtual array contains one JSAMPLE per
+ * pixel if the output is grayscale or colormapped, three if it is full color.
+ */
+
+/* Private version of data destination object */
+
+typedef struct {
+  struct djpeg_dest_struct pub; /* public fields */
+
+  boolean is_os2;               /* saves the OS2 format request flag */
+
+  jvirt_sarray_ptr whole_image; /* needed to reverse row order */
+  JDIMENSION data_width;        /* JSAMPLEs per row */
+  JDIMENSION row_width;         /* physical width of one row in the BMP file */
+  int pad_bytes;                /* number of padding bytes needed per row */
+  JDIMENSION cur_output_row;    /* next row# to write to virtual array */
+
+  boolean use_inversion_array;  /* TRUE = buffer the whole image, which is
+                                   stored to disk in bottom-up order, and
+                                   receive rows from the calling program in
+                                   top-down order
+
+                                   FALSE = the calling program will maintain
+                                   its own image buffer and write the rows in
+                                   bottom-up order */
+
+  JSAMPLE *iobuffer;            /* I/O buffer (used to buffer a single row to
+                                   disk if use_inversion_array == FALSE) */
+} bmp_dest_struct;
+
+typedef bmp_dest_struct *bmp_dest_ptr;
+
+
+/* Forward declarations */
+LOCAL(void) write_colormap(j_decompress_ptr cinfo, bmp_dest_ptr dest,
+                           int map_colors, int map_entry_size);
+
+
+static INLINE boolean is_big_endian(void)
+{
+  int test_value = 1;
+  if (*(char *)&test_value != 1)
+    return TRUE;
+  return FALSE;
+}
+
+
+/*
+ * Write some pixel data.
+ * In this module rows_supplied will always be 1.
+ */
+
+METHODDEF(void)
+put_pixel_rows(j_decompress_ptr cinfo, djpeg_dest_ptr dinfo,
+               JDIMENSION rows_supplied)
+/* This version is for writing 24-bit pixels */
+{
+  bmp_dest_ptr dest = (bmp_dest_ptr)dinfo;
+  JSAMPARRAY image_ptr;
+  register JSAMPROW inptr, outptr;
+  register JDIMENSION col;
+  int pad;
+
+  if (dest->use_inversion_array) {
+    /* Access next row in virtual array */
+    image_ptr = (*cinfo->mem->access_virt_sarray)
+      ((j_common_ptr)cinfo, dest->whole_image,
+       dest->cur_output_row, (JDIMENSION)1, TRUE);
+    dest->cur_output_row++;
+    outptr = image_ptr[0];
+  } else {
+    outptr = dest->iobuffer;
+  }
+
+  /* Transfer data.  Note destination values must be in BGR order
+   * (even though Microsoft's own documents say the opposite).
+   */
+  inptr = dest->pub.buffer[0];
+
+  if (cinfo->out_color_space == JCS_EXT_BGR) {
+    MEMCOPY(outptr, inptr, dest->row_width);
+    outptr += cinfo->output_width * 3;
+  } else if (cinfo->out_color_space == JCS_RGB565) {
+    boolean big_endian = is_big_endian();
+    unsigned short *inptr2 = (unsigned short *)inptr;
+    for (col = cinfo->output_width; col > 0; col--) {
+      if (big_endian) {
+        outptr[0] = (*inptr2 >> 5) & 0xF8;
+        outptr[1] = ((*inptr2 << 5) & 0xE0) | ((*inptr2 >> 11) & 0x1C);
+        outptr[2] = *inptr2 & 0xF8;
+      } else {
+        outptr[0] = (*inptr2 << 3) & 0xF8;
+        outptr[1] = (*inptr2 >> 3) & 0xFC;
+        outptr[2] = (*inptr2 >> 8) & 0xF8;
+      }
+      outptr += 3;
+      inptr2++;
+    }
+  } else if (cinfo->out_color_space == JCS_CMYK) {
+    for (col = cinfo->output_width; col > 0; col--) {
+      JSAMPLE c = *inptr++, m = *inptr++, y = *inptr++, k = *inptr++;
+      cmyk_to_rgb(c, m, y, k, outptr + 2, outptr + 1, outptr);
+      outptr += 3;
+    }
+  } else {
+    register int rindex = rgb_red[cinfo->out_color_space];
+    register int gindex = rgb_green[cinfo->out_color_space];
+    register int bindex = rgb_blue[cinfo->out_color_space];
+    register int ps = rgb_pixelsize[cinfo->out_color_space];
+
+    for (col = cinfo->output_width; col > 0; col--) {
+      outptr[0] = inptr[bindex];
+      outptr[1] = inptr[gindex];
+      outptr[2] = inptr[rindex];
+      outptr += 3;  inptr += ps;
+    }
+  }
+
+  /* Zero out the pad bytes. */
+  pad = dest->pad_bytes;
+  while (--pad >= 0)
+    *outptr++ = 0;
+
+  if (!dest->use_inversion_array)
+    (void)JFWRITE(dest->pub.output_file, dest->iobuffer, dest->row_width);
+}
+
+METHODDEF(void)
+put_gray_rows(j_decompress_ptr cinfo, djpeg_dest_ptr dinfo,
+              JDIMENSION rows_supplied)
+/* This version is for grayscale OR quantized color output */
+{
+  bmp_dest_ptr dest = (bmp_dest_ptr)dinfo;
+  JSAMPARRAY image_ptr;
+  register JSAMPROW inptr, outptr;
+  int pad;
+
+  if (dest->use_inversion_array) {
+    /* Access next row in virtual array */
+    image_ptr = (*cinfo->mem->access_virt_sarray)
+      ((j_common_ptr)cinfo, dest->whole_image,
+       dest->cur_output_row, (JDIMENSION)1, TRUE);
+    dest->cur_output_row++;
+    outptr = image_ptr[0];
+  } else {
+    outptr = dest->iobuffer;
+  }
+
+  /* Transfer data. */
+  inptr = dest->pub.buffer[0];
+  MEMCOPY(outptr, inptr, cinfo->output_width);
+  outptr += cinfo->output_width;
+
+  /* Zero out the pad bytes. */
+  pad = dest->pad_bytes;
+  while (--pad >= 0)
+    *outptr++ = 0;
+
+  if (!dest->use_inversion_array)
+    (void)JFWRITE(dest->pub.output_file, dest->iobuffer, dest->row_width);
+}
+
+
+/*
+ * Finish up at the end of the file.
+ *
+ * Here is where we really output the BMP file.
+ *
+ * First, routines to write the Windows and OS/2 variants of the file header.
+ */
+
+LOCAL(void)
+write_bmp_header(j_decompress_ptr cinfo, bmp_dest_ptr dest)
+/* Write a Windows-style BMP file header, including colormap if needed */
+{
+  char bmpfileheader[14];
+  char bmpinfoheader[40];
+
+#define PUT_2B(array, offset, value) \
+  (array[offset] = (char)((value) & 0xFF), \
+   array[offset + 1] = (char)(((value) >> 8) & 0xFF))
+#define PUT_4B(array, offset, value) \
+  (array[offset] = (char)((value) & 0xFF), \
+   array[offset + 1] = (char)(((value) >> 8) & 0xFF), \
+   array[offset + 2] = (char)(((value) >> 16) & 0xFF), \
+   array[offset + 3] = (char)(((value) >> 24) & 0xFF))
+
+  long headersize, bfSize;
+  int bits_per_pixel, cmap_entries;
+
+  /* Compute colormap size and total file size */
+  if (IsExtRGB(cinfo->out_color_space)) {
+    if (cinfo->quantize_colors) {
+      /* Colormapped RGB */
+      bits_per_pixel = 8;
+      cmap_entries = 256;
+    } else {
+      /* Unquantized, full color RGB */
+      bits_per_pixel = 24;
+      cmap_entries = 0;
+    }
+  } else if (cinfo->out_color_space == JCS_RGB565 ||
+             cinfo->out_color_space == JCS_CMYK) {
+    bits_per_pixel = 24;
+    cmap_entries   = 0;
+  } else {
+    /* Grayscale output.  We need to fake a 256-entry colormap. */
+    bits_per_pixel = 8;
+    cmap_entries = 256;
+  }
+  /* File size */
+  headersize = 14 + 40 + cmap_entries * 4; /* Header and colormap */
+  bfSize = headersize + (long)dest->row_width * (long)cinfo->output_height;
+
+  /* Set unused fields of header to 0 */
+  MEMZERO(bmpfileheader, sizeof(bmpfileheader));
+  MEMZERO(bmpinfoheader, sizeof(bmpinfoheader));
+
+  /* Fill the file header */
+  bmpfileheader[0] = 0x42;      /* first 2 bytes are ASCII 'B', 'M' */
+  bmpfileheader[1] = 0x4D;
+  PUT_4B(bmpfileheader, 2, bfSize); /* bfSize */
+  /* we leave bfReserved1 & bfReserved2 = 0 */
+  PUT_4B(bmpfileheader, 10, headersize); /* bfOffBits */
+
+  /* Fill the info header (Microsoft calls this a BITMAPINFOHEADER) */
+  PUT_2B(bmpinfoheader, 0, 40); /* biSize */
+  PUT_4B(bmpinfoheader, 4, cinfo->output_width); /* biWidth */
+  PUT_4B(bmpinfoheader, 8, cinfo->output_height); /* biHeight */
+  PUT_2B(bmpinfoheader, 12, 1); /* biPlanes - must be 1 */
+  PUT_2B(bmpinfoheader, 14, bits_per_pixel); /* biBitCount */
+  /* we leave biCompression = 0, for none */
+  /* we leave biSizeImage = 0; this is correct for uncompressed data */
+  if (cinfo->density_unit == 2) { /* if have density in dots/cm, then */
+    PUT_4B(bmpinfoheader, 24, (long)(cinfo->X_density * 100)); /* XPels/M */
+    PUT_4B(bmpinfoheader, 28, (long)(cinfo->Y_density * 100)); /* XPels/M */
+  }
+  PUT_2B(bmpinfoheader, 32, cmap_entries); /* biClrUsed */
+  /* we leave biClrImportant = 0 */
+
+  if (JFWRITE(dest->pub.output_file, bmpfileheader, 14) != (size_t)14)
+    ERREXIT(cinfo, JERR_FILE_WRITE);
+  if (JFWRITE(dest->pub.output_file, bmpinfoheader, 40) != (size_t)40)
+    ERREXIT(cinfo, JERR_FILE_WRITE);
+
+  if (cmap_entries > 0)
+    write_colormap(cinfo, dest, cmap_entries, 4);
+}
+
+
+LOCAL(void)
+write_os2_header(j_decompress_ptr cinfo, bmp_dest_ptr dest)
+/* Write an OS2-style BMP file header, including colormap if needed */
+{
+  char bmpfileheader[14];
+  char bmpcoreheader[12];
+  long headersize, bfSize;
+  int bits_per_pixel, cmap_entries;
+
+  /* Compute colormap size and total file size */
+  if (IsExtRGB(cinfo->out_color_space)) {
+    if (cinfo->quantize_colors) {
+      /* Colormapped RGB */
+      bits_per_pixel = 8;
+      cmap_entries = 256;
+    } else {
+      /* Unquantized, full color RGB */
+      bits_per_pixel = 24;
+      cmap_entries = 0;
+    }
+  } else if (cinfo->out_color_space == JCS_RGB565 ||
+             cinfo->out_color_space == JCS_CMYK) {
+    bits_per_pixel = 24;
+    cmap_entries   = 0;
+  } else {
+    /* Grayscale output.  We need to fake a 256-entry colormap. */
+    bits_per_pixel = 8;
+    cmap_entries = 256;
+  }
+  /* File size */
+  headersize = 14 + 12 + cmap_entries * 3; /* Header and colormap */
+  bfSize = headersize + (long)dest->row_width * (long)cinfo->output_height;
+
+  /* Set unused fields of header to 0 */
+  MEMZERO(bmpfileheader, sizeof(bmpfileheader));
+  MEMZERO(bmpcoreheader, sizeof(bmpcoreheader));
+
+  /* Fill the file header */
+  bmpfileheader[0] = 0x42;      /* first 2 bytes are ASCII 'B', 'M' */
+  bmpfileheader[1] = 0x4D;
+  PUT_4B(bmpfileheader, 2, bfSize); /* bfSize */
+  /* we leave bfReserved1 & bfReserved2 = 0 */
+  PUT_4B(bmpfileheader, 10, headersize); /* bfOffBits */
+
+  /* Fill the info header (Microsoft calls this a BITMAPCOREHEADER) */
+  PUT_2B(bmpcoreheader, 0, 12); /* bcSize */
+  PUT_2B(bmpcoreheader, 4, cinfo->output_width); /* bcWidth */
+  PUT_2B(bmpcoreheader, 6, cinfo->output_height); /* bcHeight */
+  PUT_2B(bmpcoreheader, 8, 1);  /* bcPlanes - must be 1 */
+  PUT_2B(bmpcoreheader, 10, bits_per_pixel); /* bcBitCount */
+
+  if (JFWRITE(dest->pub.output_file, bmpfileheader, 14) != (size_t)14)
+    ERREXIT(cinfo, JERR_FILE_WRITE);
+  if (JFWRITE(dest->pub.output_file, bmpcoreheader, 12) != (size_t)12)
+    ERREXIT(cinfo, JERR_FILE_WRITE);
+
+  if (cmap_entries > 0)
+    write_colormap(cinfo, dest, cmap_entries, 3);
+}
+
+
+/*
+ * Write the colormap.
+ * Windows uses BGR0 map entries; OS/2 uses BGR entries.
+ */
+
+LOCAL(void)
+write_colormap(j_decompress_ptr cinfo, bmp_dest_ptr dest, int map_colors,
+               int map_entry_size)
+{
+  JSAMPARRAY colormap = cinfo->colormap;
+  int num_colors = cinfo->actual_number_of_colors;
+  FILE *outfile = dest->pub.output_file;
+  int i;
+
+  if (colormap != NULL) {
+    if (cinfo->out_color_components == 3) {
+      /* Normal case with RGB colormap */
+      for (i = 0; i < num_colors; i++) {
+        putc(colormap[2][i], outfile);
+        putc(colormap[1][i], outfile);
+        putc(colormap[0][i], outfile);
+        if (map_entry_size == 4)
+          putc(0, outfile);
+      }
+    } else {
+      /* Grayscale colormap (only happens with grayscale quantization) */
+      for (i = 0; i < num_colors; i++) {
+        putc(colormap[0][i], outfile);
+        putc(colormap[0][i], outfile);
+        putc(colormap[0][i], outfile);
+        if (map_entry_size == 4)
+          putc(0, outfile);
+      }
+    }
+  } else {
+    /* If no colormap, must be grayscale data.  Generate a linear "map". */
+    for (i = 0; i < 256; i++) {
+      putc(i, outfile);
+      putc(i, outfile);
+      putc(i, outfile);
+      if (map_entry_size == 4)
+        putc(0, outfile);
+    }
+  }
+  /* Pad colormap with zeros to ensure specified number of colormap entries */
+  if (i > map_colors)
+    ERREXIT1(cinfo, JERR_TOO_MANY_COLORS, i);
+  for (; i < map_colors; i++) {
+    putc(0, outfile);
+    putc(0, outfile);
+    putc(0, outfile);
+    if (map_entry_size == 4)
+      putc(0, outfile);
+  }
+}
+
+
+/*
+ * Startup: write the file header unless the inversion array is being used.
+ */
+
+METHODDEF(void)
+start_output_bmp(j_decompress_ptr cinfo, djpeg_dest_ptr dinfo)
+{
+  bmp_dest_ptr dest = (bmp_dest_ptr)dinfo;
+
+  if (!dest->use_inversion_array) {
+    /* Write the header and colormap */
+    if (dest->is_os2)
+      write_os2_header(cinfo, dest);
+    else
+      write_bmp_header(cinfo, dest);
+  }
+}
+
+
+METHODDEF(void)
+finish_output_bmp(j_decompress_ptr cinfo, djpeg_dest_ptr dinfo)
+{
+  bmp_dest_ptr dest = (bmp_dest_ptr)dinfo;
+  register FILE *outfile = dest->pub.output_file;
+  JSAMPARRAY image_ptr;
+  register JSAMPROW data_ptr;
+  JDIMENSION row;
+  cd_progress_ptr progress = (cd_progress_ptr)cinfo->progress;
+
+  if (dest->use_inversion_array) {
+    /* Write the header and colormap */
+    if (dest->is_os2)
+      write_os2_header(cinfo, dest);
+    else
+      write_bmp_header(cinfo, dest);
+
+    /* Write the file body from our virtual array */
+    for (row = cinfo->output_height; row > 0; row--) {
+      if (progress != NULL) {
+        progress->pub.pass_counter = (long)(cinfo->output_height - row);
+        progress->pub.pass_limit = (long)cinfo->output_height;
+        (*progress->pub.progress_monitor) ((j_common_ptr)cinfo);
+      }
+      image_ptr = (*cinfo->mem->access_virt_sarray)
+        ((j_common_ptr)cinfo, dest->whole_image, row - 1, (JDIMENSION)1,
+         FALSE);
+      data_ptr = image_ptr[0];
+      (void)JFWRITE(outfile, data_ptr, dest->row_width);
+    }
+    if (progress != NULL)
+      progress->completed_extra_passes++;
+  }
+
+  /* Make sure we wrote the output file OK */
+  fflush(outfile);
+  if (ferror(outfile))
+    ERREXIT(cinfo, JERR_FILE_WRITE);
+}
+
+
+/*
+ * The module selection routine for BMP format output.
+ */
+
+GLOBAL(djpeg_dest_ptr)
+jinit_write_bmp(j_decompress_ptr cinfo, boolean is_os2,
+                boolean use_inversion_array)
+{
+  bmp_dest_ptr dest;
+  JDIMENSION row_width;
+
+  /* Create module interface object, fill in method pointers */
+  dest = (bmp_dest_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+                                sizeof(bmp_dest_struct));
+  dest->pub.start_output = start_output_bmp;
+  dest->pub.finish_output = finish_output_bmp;
+  dest->pub.calc_buffer_dimensions = NULL;
+  dest->is_os2 = is_os2;
+
+  if (cinfo->out_color_space == JCS_GRAYSCALE) {
+    dest->pub.put_pixel_rows = put_gray_rows;
+  } else if (IsExtRGB(cinfo->out_color_space)) {
+    if (cinfo->quantize_colors)
+      dest->pub.put_pixel_rows = put_gray_rows;
+    else
+      dest->pub.put_pixel_rows = put_pixel_rows;
+  } else if (!cinfo->quantize_colors &&
+             (cinfo->out_color_space == JCS_RGB565 ||
+              cinfo->out_color_space == JCS_CMYK)) {
+    dest->pub.put_pixel_rows = put_pixel_rows;
+  } else {
+    ERREXIT(cinfo, JERR_BMP_COLORSPACE);
+  }
+
+  /* Calculate output image dimensions so we can allocate space */
+  jpeg_calc_output_dimensions(cinfo);
+
+  /* Determine width of rows in the BMP file (padded to 4-byte boundary). */
+  if (cinfo->out_color_space == JCS_RGB565) {
+    row_width = cinfo->output_width * 2;
+    dest->row_width = dest->data_width = cinfo->output_width * 3;
+    while ((row_width & 3) != 0) row_width++;
+  } else if (!cinfo->quantize_colors &&
+             (IsExtRGB(cinfo->out_color_space) ||
+              cinfo->out_color_space == JCS_CMYK)) {
+    row_width = cinfo->output_width * cinfo->output_components;
+    dest->row_width = dest->data_width = cinfo->output_width * 3;
+  } else {
+    row_width = cinfo->output_width * cinfo->output_components;
+    dest->row_width = dest->data_width = row_width;
+  }
+  while ((dest->row_width & 3) != 0) dest->row_width++;
+  dest->pad_bytes = (int)(dest->row_width - dest->data_width);
+
+
+  if (use_inversion_array) {
+    /* Allocate space for inversion array, prepare for write pass */
+    dest->whole_image = (*cinfo->mem->request_virt_sarray)
+      ((j_common_ptr)cinfo, JPOOL_IMAGE, FALSE,
+       dest->row_width, cinfo->output_height, (JDIMENSION)1);
+    dest->cur_output_row = 0;
+    if (cinfo->progress != NULL) {
+      cd_progress_ptr progress = (cd_progress_ptr)cinfo->progress;
+      progress->total_extra_passes++; /* count file input as separate pass */
+    }
+  } else {
+    dest->iobuffer = (JSAMPLE *)(*cinfo->mem->alloc_small)
+      ((j_common_ptr)cinfo, JPOOL_IMAGE, dest->row_width);
+  }
+  dest->use_inversion_array = use_inversion_array;
+
+  /* Create decompressor output buffer. */
+  dest->pub.buffer = (*cinfo->mem->alloc_sarray)
+    ((j_common_ptr)cinfo, JPOOL_IMAGE, row_width, (JDIMENSION)1);
+  dest->pub.buffer_height = 1;
+
+  return (djpeg_dest_ptr)dest;
+}
+
+#endif /* BMP_SUPPORTED */
diff --git a/3rdparty/libjpeg/src/wrgif.c b/3rdparty/libjpeg/src/wrgif.c
new file mode 100644
index 00000000..82a24291
--- /dev/null
+++ b/3rdparty/libjpeg/src/wrgif.c
@@ -0,0 +1,580 @@
+/*
+ * wrgif.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1991-1997, Thomas G. Lane.
+ * Modified 2015-2019 by Guido Vollbeding.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2015, 2017, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains routines to write output images in GIF format.
+ *
+ * These routines may need modification for non-Unix environments or
+ * specialized applications.  As they stand, they assume output to
+ * an ordinary stdio stream.
+ */
+
+/*
+ * This code is loosely based on ppmtogif from the PBMPLUS distribution
+ * of Feb. 1991.  That file contains the following copyright notice:
+ *    Based on GIFENCODE by David Rowley <mgardi@watdscu.waterloo.edu>.
+ *    Lempel-Ziv compression based on "compress" by Spencer W. Thomas et al.
+ *    Copyright (C) 1989 by Jef Poskanzer.
+ *    Permission to use, copy, modify, and distribute this software and its
+ *    documentation for any purpose and without fee is hereby granted, provided
+ *    that the above copyright notice appear in all copies and that both that
+ *    copyright notice and this permission notice appear in supporting
+ *    documentation.  This software is provided "as is" without express or
+ *    implied warranty.
+ */
+
+#include "cdjpeg.h"             /* Common decls for cjpeg/djpeg applications */
+
+#ifdef GIF_SUPPORTED
+
+
+#define MAX_LZW_BITS     12     /* maximum LZW code size (4096 symbols) */
+
+typedef INT16 code_int;         /* must hold -1 .. 2**MAX_LZW_BITS */
+
+#define LZW_TABLE_SIZE   ((code_int)1 << MAX_LZW_BITS)
+
+#define HSIZE            5003   /* hash table size for 80% occupancy */
+
+typedef int hash_int;           /* must hold -2*HSIZE..2*HSIZE */
+
+#define MAXCODE(n_bits)  (((code_int)1 << (n_bits)) - 1)
+
+
+/*
+ * The LZW hash table consists of two parallel arrays:
+ *   hash_code[i]       code of symbol in slot i, or 0 if empty slot
+ *   hash_value[i]      symbol's value; undefined if empty slot
+ * where slot values (i) range from 0 to HSIZE-1.  The symbol value is
+ * its prefix symbol's code concatenated with its suffix character.
+ *
+ * Algorithm:  use open addressing double hashing (no chaining) on the
+ * prefix code / suffix character combination.  We do a variant of Knuth's
+ * algorithm D (vol. 3, sec. 6.4) along with G. Knott's relatively-prime
+ * secondary probe.
+ */
+
+typedef int hash_entry;         /* must hold (code_int << 8) | byte */
+
+#define HASH_ENTRY(prefix, suffix)  ((((hash_entry)(prefix)) << 8) | (suffix))
+
+
+/* Private version of data destination object */
+
+typedef struct {
+  struct djpeg_dest_struct pub; /* public fields */
+
+  j_decompress_ptr cinfo;       /* back link saves passing separate parm */
+
+  /* State for packing variable-width codes into a bitstream */
+  int n_bits;                   /* current number of bits/code */
+  code_int maxcode;             /* maximum code, given n_bits */
+  int init_bits;                /* initial n_bits ... restored after clear */
+  int cur_accum;                /* holds bits not yet output */
+  int cur_bits;                 /* # of bits in cur_accum */
+
+  /* LZW string construction */
+  code_int waiting_code;        /* symbol not yet output; may be extendable */
+  boolean first_byte;           /* if TRUE, waiting_code is not valid */
+
+  /* State for GIF code assignment */
+  code_int ClearCode;           /* clear code (doesn't change) */
+  code_int EOFCode;             /* EOF code (ditto) */
+  code_int free_code;           /* LZW: first not-yet-used symbol code */
+  code_int code_counter;        /* not LZW: counts output symbols */
+
+  /* LZW hash table */
+  code_int *hash_code;          /* => hash table of symbol codes */
+  hash_entry *hash_value;       /* => hash table of symbol values */
+
+  /* GIF data packet construction buffer */
+  int bytesinpkt;               /* # of bytes in current packet */
+  char packetbuf[256];          /* workspace for accumulating packet */
+
+} gif_dest_struct;
+
+typedef gif_dest_struct *gif_dest_ptr;
+
+
+/*
+ * Routines to package finished data bytes into GIF data blocks.
+ * A data block consists of a count byte (1..255) and that many data bytes.
+ */
+
+LOCAL(void)
+flush_packet(gif_dest_ptr dinfo)
+/* flush any accumulated data */
+{
+  if (dinfo->bytesinpkt > 0) {  /* never write zero-length packet */
+    dinfo->packetbuf[0] = (char)dinfo->bytesinpkt++;
+    if (JFWRITE(dinfo->pub.output_file, dinfo->packetbuf, dinfo->bytesinpkt) !=
+        (size_t)dinfo->bytesinpkt)
+      ERREXIT(dinfo->cinfo, JERR_FILE_WRITE);
+    dinfo->bytesinpkt = 0;
+  }
+}
+
+
+/* Add a character to current packet; flush to disk if necessary */
+#define CHAR_OUT(dinfo, c) { \
+  (dinfo)->packetbuf[++(dinfo)->bytesinpkt] = (char)(c); \
+  if ((dinfo)->bytesinpkt >= 255) \
+    flush_packet(dinfo); \
+}
+
+
+/* Routine to convert variable-width codes into a byte stream */
+
+LOCAL(void)
+output(gif_dest_ptr dinfo, code_int code)
+/* Emit a code of n_bits bits */
+/* Uses cur_accum and cur_bits to reblock into 8-bit bytes */
+{
+  dinfo->cur_accum |= ((long)code) << dinfo->cur_bits;
+  dinfo->cur_bits += dinfo->n_bits;
+
+  while (dinfo->cur_bits >= 8) {
+    CHAR_OUT(dinfo, dinfo->cur_accum & 0xFF);
+    dinfo->cur_accum >>= 8;
+    dinfo->cur_bits -= 8;
+  }
+
+  /*
+   * If the next entry is going to be too big for the code size,
+   * then increase it, if possible.  We do this here to ensure
+   * that it's done in sync with the decoder's codesize increases.
+   */
+  if (dinfo->free_code > dinfo->maxcode) {
+    dinfo->n_bits++;
+    if (dinfo->n_bits == MAX_LZW_BITS)
+      dinfo->maxcode = LZW_TABLE_SIZE; /* free_code will never exceed this */
+    else
+      dinfo->maxcode = MAXCODE(dinfo->n_bits);
+  }
+}
+
+
+/* Compression initialization & termination */
+
+
+LOCAL(void)
+clear_hash(gif_dest_ptr dinfo)
+/* Fill the hash table with empty entries */
+{
+  /* It's sufficient to zero hash_code[] */
+  MEMZERO(dinfo->hash_code, HSIZE * sizeof(code_int));
+}
+
+
+LOCAL(void)
+clear_block(gif_dest_ptr dinfo)
+/* Reset compressor and issue a Clear code */
+{
+  clear_hash(dinfo);                    /* delete all the symbols */
+  dinfo->free_code = dinfo->ClearCode + 2;
+  output(dinfo, dinfo->ClearCode);      /* inform decoder */
+  dinfo->n_bits = dinfo->init_bits;     /* reset code size */
+  dinfo->maxcode = MAXCODE(dinfo->n_bits);
+}
+
+
+LOCAL(void)
+compress_init(gif_dest_ptr dinfo, int i_bits)
+/* Initialize compressor */
+{
+  /* init all the state variables */
+  dinfo->n_bits = dinfo->init_bits = i_bits;
+  dinfo->maxcode = MAXCODE(dinfo->n_bits);
+  dinfo->ClearCode = ((code_int) 1 << (i_bits - 1));
+  dinfo->EOFCode = dinfo->ClearCode + 1;
+  dinfo->code_counter = dinfo->free_code = dinfo->ClearCode + 2;
+  dinfo->first_byte = TRUE;     /* no waiting symbol yet */
+  /* init output buffering vars */
+  dinfo->bytesinpkt = 0;
+  dinfo->cur_accum = 0;
+  dinfo->cur_bits = 0;
+  /* clear hash table */
+  if (dinfo->hash_code != NULL)
+    clear_hash(dinfo);
+  /* GIF specifies an initial Clear code */
+  output(dinfo, dinfo->ClearCode);
+}
+
+
+LOCAL(void)
+compress_term(gif_dest_ptr dinfo)
+/* Clean up at end */
+{
+  /* Flush out the buffered LZW code */
+  if (!dinfo->first_byte)
+    output(dinfo, dinfo->waiting_code);
+  /* Send an EOF code */
+  output(dinfo, dinfo->EOFCode);
+  /* Flush the bit-packing buffer */
+  if (dinfo->cur_bits > 0) {
+    CHAR_OUT(dinfo, dinfo->cur_accum & 0xFF);
+  }
+  /* Flush the packet buffer */
+  flush_packet(dinfo);
+}
+
+
+/* GIF header construction */
+
+
+LOCAL(void)
+put_word(gif_dest_ptr dinfo, unsigned int w)
+/* Emit a 16-bit word, LSB first */
+{
+  putc(w & 0xFF, dinfo->pub.output_file);
+  putc((w >> 8) & 0xFF, dinfo->pub.output_file);
+}
+
+
+LOCAL(void)
+put_3bytes(gif_dest_ptr dinfo, int val)
+/* Emit 3 copies of same byte value --- handy subr for colormap construction */
+{
+  putc(val, dinfo->pub.output_file);
+  putc(val, dinfo->pub.output_file);
+  putc(val, dinfo->pub.output_file);
+}
+
+
+LOCAL(void)
+emit_header(gif_dest_ptr dinfo, int num_colors, JSAMPARRAY colormap)
+/* Output the GIF file header, including color map */
+/* If colormap == NULL, synthesize a grayscale colormap */
+{
+  int BitsPerPixel, ColorMapSize, InitCodeSize, FlagByte;
+  int cshift = dinfo->cinfo->data_precision - 8;
+  int i;
+
+  if (num_colors > 256)
+    ERREXIT1(dinfo->cinfo, JERR_TOO_MANY_COLORS, num_colors);
+  /* Compute bits/pixel and related values */
+  BitsPerPixel = 1;
+  while (num_colors > (1 << BitsPerPixel))
+    BitsPerPixel++;
+  ColorMapSize = 1 << BitsPerPixel;
+  if (BitsPerPixel <= 1)
+    InitCodeSize = 2;
+  else
+    InitCodeSize = BitsPerPixel;
+  /*
+   * Write the GIF header.
+   * Note that we generate a plain GIF87 header for maximum compatibility.
+   */
+  putc('G', dinfo->pub.output_file);
+  putc('I', dinfo->pub.output_file);
+  putc('F', dinfo->pub.output_file);
+  putc('8', dinfo->pub.output_file);
+  putc('7', dinfo->pub.output_file);
+  putc('a', dinfo->pub.output_file);
+  /* Write the Logical Screen Descriptor */
+  put_word(dinfo, (unsigned int)dinfo->cinfo->output_width);
+  put_word(dinfo, (unsigned int)dinfo->cinfo->output_height);
+  FlagByte = 0x80;              /* Yes, there is a global color table */
+  FlagByte |= (BitsPerPixel - 1) << 4; /* color resolution */
+  FlagByte |= (BitsPerPixel - 1); /* size of global color table */
+  putc(FlagByte, dinfo->pub.output_file);
+  putc(0, dinfo->pub.output_file); /* Background color index */
+  putc(0, dinfo->pub.output_file); /* Reserved (aspect ratio in GIF89) */
+  /* Write the Global Color Map */
+  /* If the color map is more than 8 bits precision, */
+  /* we reduce it to 8 bits by shifting */
+  for (i = 0; i < ColorMapSize; i++) {
+    if (i < num_colors) {
+      if (colormap != NULL) {
+        if (dinfo->cinfo->out_color_space == JCS_RGB) {
+          /* Normal case: RGB color map */
+          putc(colormap[0][i] >> cshift, dinfo->pub.output_file);
+          putc(colormap[1][i] >> cshift, dinfo->pub.output_file);
+          putc(colormap[2][i] >> cshift, dinfo->pub.output_file);
+        } else {
+          /* Grayscale "color map": possible if quantizing grayscale image */
+          put_3bytes(dinfo, colormap[0][i] >> cshift);
+        }
+      } else {
+        /* Create a grayscale map of num_colors values, range 0..255 */
+        put_3bytes(dinfo, (i * 255 + (num_colors - 1) / 2) / (num_colors - 1));
+      }
+    } else {
+      /* fill out the map to a power of 2 */
+      put_3bytes(dinfo, CENTERJSAMPLE >> cshift);
+    }
+  }
+  /* Write image separator and Image Descriptor */
+  putc(',', dinfo->pub.output_file); /* separator */
+  put_word(dinfo, 0);           /* left/top offset */
+  put_word(dinfo, 0);
+  put_word(dinfo, (unsigned int)dinfo->cinfo->output_width); /* image size */
+  put_word(dinfo, (unsigned int)dinfo->cinfo->output_height);
+  /* flag byte: not interlaced, no local color map */
+  putc(0x00, dinfo->pub.output_file);
+  /* Write Initial Code Size byte */
+  putc(InitCodeSize, dinfo->pub.output_file);
+
+  /* Initialize for compression of image data */
+  compress_init(dinfo, InitCodeSize + 1);
+}
+
+
+/*
+ * Startup: write the file header.
+ */
+
+METHODDEF(void)
+start_output_gif(j_decompress_ptr cinfo, djpeg_dest_ptr dinfo)
+{
+  gif_dest_ptr dest = (gif_dest_ptr)dinfo;
+
+  if (cinfo->quantize_colors)
+    emit_header(dest, cinfo->actual_number_of_colors, cinfo->colormap);
+  else
+    emit_header(dest, 256, (JSAMPARRAY)NULL);
+}
+
+
+/*
+ * Write some pixel data.
+ * In this module rows_supplied will always be 1.
+ */
+
+
+/*
+ * The LZW algorithm proper
+ */
+
+METHODDEF(void)
+put_LZW_pixel_rows(j_decompress_ptr cinfo, djpeg_dest_ptr dinfo,
+                   JDIMENSION rows_supplied)
+{
+  gif_dest_ptr dest = (gif_dest_ptr)dinfo;
+  register JSAMPROW ptr;
+  register JDIMENSION col;
+  code_int c;
+  register hash_int i;
+  register hash_int disp;
+  register hash_entry probe_value;
+
+  ptr = dest->pub.buffer[0];
+  for (col = cinfo->output_width; col > 0; col--) {
+    /* Accept and compress one 8-bit byte */
+    c = (code_int)(*ptr++);
+
+    if (dest->first_byte) {     /* need to initialize waiting_code */
+      dest->waiting_code = c;
+      dest->first_byte = FALSE;
+      continue;
+    }
+
+    /* Probe hash table to see if a symbol exists for
+     * waiting_code followed by c.
+     * If so, replace waiting_code by that symbol and continue.
+     */
+    i = ((hash_int)c << (MAX_LZW_BITS - 8)) + dest->waiting_code;
+    /* i is less than twice 2**MAX_LZW_BITS, therefore less than twice HSIZE */
+    if (i >= HSIZE)
+      i -= HSIZE;
+
+    probe_value = HASH_ENTRY(dest->waiting_code, c);
+
+    if (dest->hash_code[i] == 0) {
+      /* hit empty slot; desired symbol not in table */
+      output(dest, dest->waiting_code);
+      if (dest->free_code < LZW_TABLE_SIZE) {
+        dest->hash_code[i] = dest->free_code++; /* add symbol to hashtable */
+        dest->hash_value[i] = probe_value;
+      } else
+        clear_block(dest);
+      dest->waiting_code = c;
+      continue;
+    }
+    if (dest->hash_value[i] == probe_value) {
+      dest->waiting_code = dest->hash_code[i];
+      continue;
+    }
+
+    if (i == 0)                 /* secondary hash (after G. Knott) */
+      disp = 1;
+    else
+      disp = HSIZE - i;
+    for (;;) {
+      i -= disp;
+      if (i < 0)
+        i += HSIZE;
+      if (dest->hash_code[i] == 0) {
+        /* hit empty slot; desired symbol not in table */
+        output(dest, dest->waiting_code);
+        if (dest->free_code < LZW_TABLE_SIZE) {
+          dest->hash_code[i] = dest->free_code++; /* add symbol to hashtable */
+          dest->hash_value[i] = probe_value;
+        } else
+          clear_block(dest);
+        dest->waiting_code = c;
+        break;
+      }
+      if (dest->hash_value[i] == probe_value) {
+        dest->waiting_code = dest->hash_code[i];
+        break;
+      }
+    }
+  }
+}
+
+
+/*
+ * The pseudo-compression algorithm.
+ *
+ * In this version we simply output each pixel value as a separate symbol;
+ * thus, no compression occurs.  In fact, there is expansion of one bit per
+ * pixel, because we use a symbol width one bit wider than the pixel width.
+ *
+ * GIF ordinarily uses variable-width symbols, and the decoder will expect
+ * to ratchet up the symbol width after a fixed number of symbols.
+ * To simplify the logic and keep the expansion penalty down, we emit a
+ * GIF Clear code to reset the decoder just before the width would ratchet up.
+ * Thus, all the symbols in the output file will have the same bit width.
+ * Note that emitting the Clear codes at the right times is a mere matter of
+ * counting output symbols and is in no way dependent on the LZW algorithm.
+ *
+ * With a small basic pixel width (low color count), Clear codes will be
+ * needed very frequently, causing the file to expand even more.  So this
+ * simplistic approach wouldn't work too well on bilevel images, for example.
+ * But for output of JPEG conversions the pixel width will usually be 8 bits
+ * (129 to 256 colors), so the overhead added by Clear symbols is only about
+ * one symbol in every 256.
+ */
+
+METHODDEF(void)
+put_raw_pixel_rows(j_decompress_ptr cinfo, djpeg_dest_ptr dinfo,
+                   JDIMENSION rows_supplied)
+{
+  gif_dest_ptr dest = (gif_dest_ptr)dinfo;
+  register JSAMPROW ptr;
+  register JDIMENSION col;
+  code_int c;
+
+  ptr = dest->pub.buffer[0];
+  for (col = cinfo->output_width; col > 0; col--) {
+    c = (code_int)(*ptr++);
+    /* Accept and output one pixel value.
+     * The given value must be less than n_bits wide.
+     */
+
+    /* Output the given pixel value as a symbol. */
+    output(dest, c);
+    /* Issue Clear codes often enough to keep the reader from ratcheting up
+     * its symbol size.
+     */
+    if (dest->code_counter < dest->maxcode) {
+      dest->code_counter++;
+    } else {
+      output(dest, dest->ClearCode);
+      dest->code_counter = dest->ClearCode + 2; /* reset the counter */
+    }
+  }
+}
+
+
+/*
+ * Finish up at the end of the file.
+ */
+
+METHODDEF(void)
+finish_output_gif(j_decompress_ptr cinfo, djpeg_dest_ptr dinfo)
+{
+  gif_dest_ptr dest = (gif_dest_ptr)dinfo;
+
+  /* Flush compression mechanism */
+  compress_term(dest);
+  /* Write a zero-length data block to end the series */
+  putc(0, dest->pub.output_file);
+  /* Write the GIF terminator mark */
+  putc(';', dest->pub.output_file);
+  /* Make sure we wrote the output file OK */
+  fflush(dest->pub.output_file);
+  if (ferror(dest->pub.output_file))
+    ERREXIT(cinfo, JERR_FILE_WRITE);
+}
+
+
+/*
+ * Re-calculate buffer dimensions based on output dimensions.
+ */
+
+METHODDEF(void)
+calc_buffer_dimensions_gif(j_decompress_ptr cinfo, djpeg_dest_ptr dinfo)
+{
+}
+
+
+/*
+ * The module selection routine for GIF format output.
+ */
+
+GLOBAL(djpeg_dest_ptr)
+jinit_write_gif(j_decompress_ptr cinfo, boolean is_lzw)
+{
+  gif_dest_ptr dest;
+
+  /* Create module interface object, fill in method pointers */
+  dest = (gif_dest_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+                                sizeof(gif_dest_struct));
+  dest->cinfo = cinfo;          /* make back link for subroutines */
+  dest->pub.start_output = start_output_gif;
+  dest->pub.finish_output = finish_output_gif;
+  dest->pub.calc_buffer_dimensions = calc_buffer_dimensions_gif;
+
+  if (cinfo->out_color_space != JCS_GRAYSCALE &&
+      cinfo->out_color_space != JCS_RGB)
+    ERREXIT(cinfo, JERR_GIF_COLORSPACE);
+
+  /* Force quantization if color or if > 8 bits input */
+  if (cinfo->out_color_space != JCS_GRAYSCALE || cinfo->data_precision > 8) {
+    /* Force quantization to at most 256 colors */
+    cinfo->quantize_colors = TRUE;
+    if (cinfo->desired_number_of_colors > 256)
+      cinfo->desired_number_of_colors = 256;
+  }
+
+  /* Calculate output image dimensions so we can allocate space */
+  jpeg_calc_output_dimensions(cinfo);
+
+  if (cinfo->output_components != 1) /* safety check: just one component? */
+    ERREXIT(cinfo, JERR_GIF_BUG);
+
+  /* Create decompressor output buffer. */
+  dest->pub.buffer = (*cinfo->mem->alloc_sarray)
+    ((j_common_ptr)cinfo, JPOOL_IMAGE, cinfo->output_width, (JDIMENSION)1);
+  dest->pub.buffer_height = 1;
+
+  if (is_lzw) {
+    dest->pub.put_pixel_rows = put_LZW_pixel_rows;
+    /* Allocate space for hash table */
+    dest->hash_code = (code_int *)
+      (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+                                  HSIZE * sizeof(code_int));
+    dest->hash_value = (hash_entry *)
+      (*cinfo->mem->alloc_large) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+                                  HSIZE * sizeof(hash_entry));
+  } else {
+    dest->pub.put_pixel_rows = put_raw_pixel_rows;
+    /* Mark tables unused */
+    dest->hash_code = NULL;
+    dest->hash_value = NULL;
+  }
+
+  return (djpeg_dest_ptr)dest;
+}
+
+#endif /* GIF_SUPPORTED */
diff --git a/3rdparty/libjpeg/src/wrjpgcom.1 b/3rdparty/libjpeg/src/wrjpgcom.1
new file mode 100644
index 00000000..a255cab8
--- /dev/null
+++ b/3rdparty/libjpeg/src/wrjpgcom.1
@@ -0,0 +1,103 @@
+.TH WRJPGCOM 1 "15 June 1995"
+.SH NAME
+wrjpgcom \- insert text comments into a JPEG file
+.SH SYNOPSIS
+.B wrjpgcom
+[
+.B \-replace
+]
+[
+.BI \-comment " text"
+]
+[
+.BI \-cfile " name"
+]
+[
+.I filename
+]
+.LP
+.SH DESCRIPTION
+.LP
+.B wrjpgcom
+reads the named JPEG/JFIF file, or the standard input if no file is named,
+and generates a new JPEG/JFIF file on standard output.  A comment block is
+added to the file.
+.PP
+The JPEG standard allows "comment" (COM) blocks to occur within a JPEG file.
+Although the standard doesn't actually define what COM blocks are for, they
+are widely used to hold user-supplied text strings.  This lets you add
+annotations, titles, index terms, etc to your JPEG files, and later retrieve
+them as text.  COM blocks do not interfere with the image stored in the JPEG
+file.  The maximum size of a COM block is 64K, but you can have as many of
+them as you like in one JPEG file.
+.PP
+.B wrjpgcom
+adds a COM block, containing text you provide, to a JPEG file.
+Ordinarily, the COM block is added after any existing COM blocks; but you
+can delete the old COM blocks if you wish.
+.SH OPTIONS
+Switch names may be abbreviated, and are not case sensitive.
+.TP
+.B \-replace
+Delete any existing COM blocks from the file.
+.TP
+.BI \-comment " text"
+Supply text for new COM block on command line.
+.TP
+.BI \-cfile " name"
+Read text for new COM block from named file.
+.PP
+If you have only one line of comment text to add, you can provide it on the
+command line with
+.BR \-comment .
+The comment text must be surrounded with quotes so that it is treated as a
+single argument.  Longer comments can be read from a text file.
+.PP
+If you give neither
+.B \-comment
+nor
+.BR \-cfile,
+then
+.B wrjpgcom
+will read the comment text from standard input.  (In this case an input image
+file name MUST be supplied, so that the source JPEG file comes from somewhere
+else.)  You can enter multiple lines, up to 64KB worth.  Type an end-of-file
+indicator (usually control-D) to terminate the comment text entry.
+.PP
+.B wrjpgcom
+will not add a COM block if the provided comment string is empty.  Therefore
+\fB\-replace \-comment ""\fR can be used to delete all COM blocks from a file.
+.SH EXAMPLES
+.LP
+Add a short comment to in.jpg, producing out.jpg:
+.IP
+.B wrjpgcom \-c
+\fI"View of my back yard" in.jpg
+.B >
+.I out.jpg
+.PP
+Attach a long comment previously stored in comment.txt:
+.IP
+.B wrjpgcom
+.I in.jpg
+.B <
+.I comment.txt
+.B >
+.I out.jpg
+.PP
+or equivalently
+.IP
+.B wrjpgcom
+.B -cfile
+.I comment.txt
+.B <
+.I in.jpg
+.B >
+.I out.jpg
+.SH SEE ALSO
+.BR cjpeg (1),
+.BR djpeg (1),
+.BR jpegtran (1),
+.BR rdjpgcom (1)
+.SH AUTHOR
+Independent JPEG Group
diff --git a/3rdparty/libjpeg/src/wrjpgcom.c b/3rdparty/libjpeg/src/wrjpgcom.c
new file mode 100644
index 00000000..8a4e7416
--- /dev/null
+++ b/3rdparty/libjpeg/src/wrjpgcom.c
@@ -0,0 +1,591 @@
+/*
+ * wrjpgcom.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1994-1997, Thomas G. Lane.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2014, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains a very simple stand-alone application that inserts
+ * user-supplied text as a COM (comment) marker in a JFIF file.
+ * This may be useful as an example of the minimum logic needed to parse
+ * JPEG markers.
+ */
+
+#define JPEG_CJPEG_DJPEG        /* to get the command-line config symbols */
+#include "jinclude.h"           /* get auto-config symbols, <stdio.h> */
+
+#ifndef HAVE_STDLIB_H           /* <stdlib.h> should declare malloc() */
+extern void *malloc();
+#endif
+#include <ctype.h>              /* to declare isupper(), tolower() */
+#ifdef USE_SETMODE
+#include <fcntl.h>              /* to declare setmode()'s parameter macros */
+/* If you have setmode() but not <io.h>, just delete this line: */
+#include <io.h>                 /* to declare setmode() */
+#endif
+
+#ifdef USE_CCOMMAND             /* command-line reader for Macintosh */
+#ifdef __MWERKS__
+#include <SIOUX.h>              /* Metrowerks needs this */
+#include <console.h>            /* ... and this */
+#endif
+#ifdef THINK_C
+#include <console.h>            /* Think declares it here */
+#endif
+#endif
+
+#ifdef DONT_USE_B_MODE          /* define mode parameters for fopen() */
+#define READ_BINARY     "r"
+#define WRITE_BINARY    "w"
+#else
+#define READ_BINARY     "rb"
+#define WRITE_BINARY    "wb"
+#endif
+
+#ifndef EXIT_FAILURE            /* define exit() codes if not provided */
+#define EXIT_FAILURE  1
+#endif
+#ifndef EXIT_SUCCESS
+#define EXIT_SUCCESS  0
+#endif
+
+/* Reduce this value if your malloc() can't allocate blocks up to 64K.
+ * On DOS, compiling in large model is usually a better solution.
+ */
+
+#ifndef MAX_COM_LENGTH
+#define MAX_COM_LENGTH  65000L  /* must be <= 65533 in any case */
+#endif
+
+
+/*
+ * These macros are used to read the input file and write the output file.
+ * To reuse this code in another application, you might need to change these.
+ */
+
+static FILE *infile;            /* input JPEG file */
+
+/* Return next input byte, or EOF if no more */
+#define NEXTBYTE()  getc(infile)
+
+static FILE *outfile;           /* output JPEG file */
+
+/* Emit an output byte */
+#define PUTBYTE(x)  putc((x), outfile)
+
+
+/* Error exit handler */
+#define ERREXIT(msg)  (fprintf(stderr, "%s\n", msg), exit(EXIT_FAILURE))
+
+
+/* Read one byte, testing for EOF */
+static int
+read_1_byte(void)
+{
+  int c;
+
+  c = NEXTBYTE();
+  if (c == EOF)
+    ERREXIT("Premature EOF in JPEG file");
+  return c;
+}
+
+/* Read 2 bytes, convert to unsigned int */
+/* All 2-byte quantities in JPEG markers are MSB first */
+static unsigned int
+read_2_bytes(void)
+{
+  int c1, c2;
+
+  c1 = NEXTBYTE();
+  if (c1 == EOF)
+    ERREXIT("Premature EOF in JPEG file");
+  c2 = NEXTBYTE();
+  if (c2 == EOF)
+    ERREXIT("Premature EOF in JPEG file");
+  return (((unsigned int)c1) << 8) + ((unsigned int)c2);
+}
+
+
+/* Routines to write data to output file */
+
+static void
+write_1_byte(int c)
+{
+  PUTBYTE(c);
+}
+
+static void
+write_2_bytes(unsigned int val)
+{
+  PUTBYTE((val >> 8) & 0xFF);
+  PUTBYTE(val & 0xFF);
+}
+
+static void
+write_marker(int marker)
+{
+  PUTBYTE(0xFF);
+  PUTBYTE(marker);
+}
+
+static void
+copy_rest_of_file(void)
+{
+  int c;
+
+  while ((c = NEXTBYTE()) != EOF)
+    PUTBYTE(c);
+}
+
+
+/*
+ * JPEG markers consist of one or more 0xFF bytes, followed by a marker
+ * code byte (which is not an FF).  Here are the marker codes of interest
+ * in this program.  (See jdmarker.c for a more complete list.)
+ */
+
+#define M_SOF0   0xC0           /* Start Of Frame N */
+#define M_SOF1   0xC1           /* N indicates which compression process */
+#define M_SOF2   0xC2           /* Only SOF0-SOF2 are now in common use */
+#define M_SOF3   0xC3
+#define M_SOF5   0xC5           /* NB: codes C4 and CC are NOT SOF markers */
+#define M_SOF6   0xC6
+#define M_SOF7   0xC7
+#define M_SOF9   0xC9
+#define M_SOF10  0xCA
+#define M_SOF11  0xCB
+#define M_SOF13  0xCD
+#define M_SOF14  0xCE
+#define M_SOF15  0xCF
+#define M_SOI    0xD8           /* Start Of Image (beginning of datastream) */
+#define M_EOI    0xD9           /* End Of Image (end of datastream) */
+#define M_SOS    0xDA           /* Start Of Scan (begins compressed data) */
+#define M_COM    0xFE           /* COMment */
+
+
+/*
+ * Find the next JPEG marker and return its marker code.
+ * We expect at least one FF byte, possibly more if the compressor used FFs
+ * to pad the file.  (Padding FFs will NOT be replicated in the output file.)
+ * There could also be non-FF garbage between markers.  The treatment of such
+ * garbage is unspecified; we choose to skip over it but emit a warning msg.
+ * NB: this routine must not be used after seeing SOS marker, since it will
+ * not deal correctly with FF/00 sequences in the compressed image data...
+ */
+
+static int
+next_marker(void)
+{
+  int c;
+  int discarded_bytes = 0;
+
+  /* Find 0xFF byte; count and skip any non-FFs. */
+  c = read_1_byte();
+  while (c != 0xFF) {
+    discarded_bytes++;
+    c = read_1_byte();
+  }
+  /* Get marker code byte, swallowing any duplicate FF bytes.  Extra FFs
+   * are legal as pad bytes, so don't count them in discarded_bytes.
+   */
+  do {
+    c = read_1_byte();
+  } while (c == 0xFF);
+
+  if (discarded_bytes != 0) {
+    fprintf(stderr, "Warning: garbage data found in JPEG file\n");
+  }
+
+  return c;
+}
+
+
+/*
+ * Read the initial marker, which should be SOI.
+ * For a JFIF file, the first two bytes of the file should be literally
+ * 0xFF M_SOI.  To be more general, we could use next_marker, but if the
+ * input file weren't actually JPEG at all, next_marker might read the whole
+ * file and then return a misleading error message...
+ */
+
+static int
+first_marker(void)
+{
+  int c1, c2;
+
+  c1 = NEXTBYTE();
+  c2 = NEXTBYTE();
+  if (c1 != 0xFF || c2 != M_SOI)
+    ERREXIT("Not a JPEG file");
+  return c2;
+}
+
+
+/*
+ * Most types of marker are followed by a variable-length parameter segment.
+ * This routine skips over the parameters for any marker we don't otherwise
+ * want to process.
+ * Note that we MUST skip the parameter segment explicitly in order not to
+ * be fooled by 0xFF bytes that might appear within the parameter segment;
+ * such bytes do NOT introduce new markers.
+ */
+
+static void
+copy_variable(void)
+/* Copy an unknown or uninteresting variable-length marker */
+{
+  unsigned int length;
+
+  /* Get the marker parameter length count */
+  length = read_2_bytes();
+  write_2_bytes(length);
+  /* Length includes itself, so must be at least 2 */
+  if (length < 2)
+    ERREXIT("Erroneous JPEG marker length");
+  length -= 2;
+  /* Copy the remaining bytes */
+  while (length > 0) {
+    write_1_byte(read_1_byte());
+    length--;
+  }
+}
+
+static void
+skip_variable(void)
+/* Skip over an unknown or uninteresting variable-length marker */
+{
+  unsigned int length;
+
+  /* Get the marker parameter length count */
+  length = read_2_bytes();
+  /* Length includes itself, so must be at least 2 */
+  if (length < 2)
+    ERREXIT("Erroneous JPEG marker length");
+  length -= 2;
+  /* Skip over the remaining bytes */
+  while (length > 0) {
+    (void)read_1_byte();
+    length--;
+  }
+}
+
+
+/*
+ * Parse the marker stream until SOFn or EOI is seen;
+ * copy data to output, but discard COM markers unless keep_COM is true.
+ */
+
+static int
+scan_JPEG_header(int keep_COM)
+{
+  int marker;
+
+  /* Expect SOI at start of file */
+  if (first_marker() != M_SOI)
+    ERREXIT("Expected SOI marker first");
+  write_marker(M_SOI);
+
+  /* Scan miscellaneous markers until we reach SOFn. */
+  for (;;) {
+    marker = next_marker();
+    switch (marker) {
+      /* Note that marker codes 0xC4, 0xC8, 0xCC are not, and must not be,
+       * treated as SOFn.  C4 in particular is actually DHT.
+       */
+    case M_SOF0:                /* Baseline */
+    case M_SOF1:                /* Extended sequential, Huffman */
+    case M_SOF2:                /* Progressive, Huffman */
+    case M_SOF3:                /* Lossless, Huffman */
+    case M_SOF5:                /* Differential sequential, Huffman */
+    case M_SOF6:                /* Differential progressive, Huffman */
+    case M_SOF7:                /* Differential lossless, Huffman */
+    case M_SOF9:                /* Extended sequential, arithmetic */
+    case M_SOF10:               /* Progressive, arithmetic */
+    case M_SOF11:               /* Lossless, arithmetic */
+    case M_SOF13:               /* Differential sequential, arithmetic */
+    case M_SOF14:               /* Differential progressive, arithmetic */
+    case M_SOF15:               /* Differential lossless, arithmetic */
+      return marker;
+
+    case M_SOS:                 /* should not see compressed data before SOF */
+      ERREXIT("SOS without prior SOFn");
+      break;
+
+    case M_EOI:                 /* in case it's a tables-only JPEG stream */
+      return marker;
+
+    case M_COM:                 /* Existing COM: conditionally discard */
+      if (keep_COM) {
+        write_marker(marker);
+        copy_variable();
+      } else {
+        skip_variable();
+      }
+      break;
+
+    default:                    /* Anything else just gets copied */
+      write_marker(marker);
+      copy_variable();          /* we assume it has a parameter count... */
+      break;
+    }
+  } /* end loop */
+}
+
+
+/* Command line parsing code */
+
+static const char *progname;    /* program name for error messages */
+
+
+static void
+usage(void)
+/* complain about bad command line */
+{
+  fprintf(stderr, "wrjpgcom inserts a textual comment in a JPEG file.\n");
+  fprintf(stderr, "You can add to or replace any existing comment(s).\n");
+
+  fprintf(stderr, "Usage: %s [switches] ", progname);
+#ifdef TWO_FILE_COMMANDLINE
+  fprintf(stderr, "inputfile outputfile\n");
+#else
+  fprintf(stderr, "[inputfile]\n");
+#endif
+
+  fprintf(stderr, "Switches (names may be abbreviated):\n");
+  fprintf(stderr, "  -replace         Delete any existing comments\n");
+  fprintf(stderr, "  -comment \"text\"  Insert comment with given text\n");
+  fprintf(stderr, "  -cfile name      Read comment from named file\n");
+  fprintf(stderr, "Notice that you must put quotes around the comment text\n");
+  fprintf(stderr, "when you use -comment.\n");
+  fprintf(stderr, "If you do not give either -comment or -cfile on the command line,\n");
+  fprintf(stderr, "then the comment text is read from standard input.\n");
+  fprintf(stderr, "It can be multiple lines, up to %u characters total.\n",
+          (unsigned int)MAX_COM_LENGTH);
+#ifndef TWO_FILE_COMMANDLINE
+  fprintf(stderr, "You must specify an input JPEG file name when supplying\n");
+  fprintf(stderr, "comment text from standard input.\n");
+#endif
+
+  exit(EXIT_FAILURE);
+}
+
+
+static int
+keymatch(char *arg, const char *keyword, int minchars)
+/* Case-insensitive matching of (possibly abbreviated) keyword switches. */
+/* keyword is the constant keyword (must be lower case already), */
+/* minchars is length of minimum legal abbreviation. */
+{
+  register int ca, ck;
+  register int nmatched = 0;
+
+  while ((ca = *arg++) != '\0') {
+    if ((ck = *keyword++) == '\0')
+      return 0;                 /* arg longer than keyword, no good */
+    if (isupper(ca))            /* force arg to lcase (assume ck is already) */
+      ca = tolower(ca);
+    if (ca != ck)
+      return 0;                 /* no good */
+    nmatched++;                 /* count matched characters */
+  }
+  /* reached end of argument; fail if it's too short for unique abbrev */
+  if (nmatched < minchars)
+    return 0;
+  return 1;                     /* A-OK */
+}
+
+
+/*
+ * The main program.
+ */
+
+int
+main(int argc, char **argv)
+{
+  int argn;
+  char *arg;
+  int keep_COM = 1;
+  char *comment_arg = NULL;
+  FILE *comment_file = NULL;
+  unsigned int comment_length = 0;
+  int marker;
+
+  /* On Mac, fetch a command line. */
+#ifdef USE_CCOMMAND
+  argc = ccommand(&argv);
+#endif
+
+  progname = argv[0];
+  if (progname == NULL || progname[0] == 0)
+    progname = "wrjpgcom";      /* in case C library doesn't provide it */
+
+  /* Parse switches, if any */
+  for (argn = 1; argn < argc; argn++) {
+    arg = argv[argn];
+    if (arg[0] != '-')
+      break;                    /* not switch, must be file name */
+    arg++;                      /* advance over '-' */
+    if (keymatch(arg, "replace", 1)) {
+      keep_COM = 0;
+    } else if (keymatch(arg, "cfile", 2)) {
+      if (++argn >= argc) usage();
+      if ((comment_file = fopen(argv[argn], "r")) == NULL) {
+        fprintf(stderr, "%s: can't open %s\n", progname, argv[argn]);
+        exit(EXIT_FAILURE);
+      }
+    } else if (keymatch(arg, "comment", 1)) {
+      if (++argn >= argc) usage();
+      comment_arg = argv[argn];
+      /* If the comment text starts with '"', then we are probably running
+       * under MS-DOG and must parse out the quoted string ourselves.  Sigh.
+       */
+      if (comment_arg[0] == '"') {
+        comment_arg = (char *)malloc((size_t)MAX_COM_LENGTH);
+        if (comment_arg == NULL)
+          ERREXIT("Insufficient memory");
+        if (strlen(argv[argn]) + 2 >= (size_t)MAX_COM_LENGTH) {
+          fprintf(stderr, "Comment text may not exceed %u bytes\n",
+                  (unsigned int)MAX_COM_LENGTH);
+          exit(EXIT_FAILURE);
+        }
+        strcpy(comment_arg, argv[argn] + 1);
+        for (;;) {
+          comment_length = (unsigned int)strlen(comment_arg);
+          if (comment_length > 0 && comment_arg[comment_length - 1] == '"') {
+            comment_arg[comment_length - 1] = '\0'; /* zap terminating quote */
+            break;
+          }
+          if (++argn >= argc)
+            ERREXIT("Missing ending quote mark");
+          if (strlen(comment_arg) + strlen(argv[argn]) + 2 >=
+              (size_t)MAX_COM_LENGTH) {
+            fprintf(stderr, "Comment text may not exceed %u bytes\n",
+                    (unsigned int)MAX_COM_LENGTH);
+            exit(EXIT_FAILURE);
+          }
+          strcat(comment_arg, " ");
+          strcat(comment_arg, argv[argn]);
+        }
+      } else if (strlen(argv[argn]) >= (size_t)MAX_COM_LENGTH) {
+        fprintf(stderr, "Comment text may not exceed %u bytes\n",
+                (unsigned int)MAX_COM_LENGTH);
+        exit(EXIT_FAILURE);
+      }
+      comment_length = (unsigned int)strlen(comment_arg);
+    } else
+      usage();
+  }
+
+  /* Cannot use both -comment and -cfile. */
+  if (comment_arg != NULL && comment_file != NULL)
+    usage();
+  /* If there is neither -comment nor -cfile, we will read the comment text
+   * from stdin; in this case there MUST be an input JPEG file name.
+   */
+  if (comment_arg == NULL && comment_file == NULL && argn >= argc)
+    usage();
+
+  /* Open the input file. */
+  if (argn < argc) {
+    if ((infile = fopen(argv[argn], READ_BINARY)) == NULL) {
+      fprintf(stderr, "%s: can't open %s\n", progname, argv[argn]);
+      exit(EXIT_FAILURE);
+    }
+  } else {
+    /* default input file is stdin */
+#ifdef USE_SETMODE              /* need to hack file mode? */
+    setmode(fileno(stdin), O_BINARY);
+#endif
+#ifdef USE_FDOPEN               /* need to re-open in binary mode? */
+    if ((infile = fdopen(fileno(stdin), READ_BINARY)) == NULL) {
+      fprintf(stderr, "%s: can't open stdin\n", progname);
+      exit(EXIT_FAILURE);
+    }
+#else
+    infile = stdin;
+#endif
+  }
+
+  /* Open the output file. */
+#ifdef TWO_FILE_COMMANDLINE
+  /* Must have explicit output file name */
+  if (argn != argc - 2) {
+    fprintf(stderr, "%s: must name one input and one output file\n", progname);
+    usage();
+  }
+  if ((outfile = fopen(argv[argn + 1], WRITE_BINARY)) == NULL) {
+    fprintf(stderr, "%s: can't open %s\n", progname, argv[argn + 1]);
+    exit(EXIT_FAILURE);
+  }
+#else
+  /* Unix style: expect zero or one file name */
+  if (argn < argc - 1) {
+    fprintf(stderr, "%s: only one input file\n", progname);
+    usage();
+  }
+  /* default output file is stdout */
+#ifdef USE_SETMODE              /* need to hack file mode? */
+  setmode(fileno(stdout), O_BINARY);
+#endif
+#ifdef USE_FDOPEN               /* need to re-open in binary mode? */
+  if ((outfile = fdopen(fileno(stdout), WRITE_BINARY)) == NULL) {
+    fprintf(stderr, "%s: can't open stdout\n", progname);
+    exit(EXIT_FAILURE);
+  }
+#else
+  outfile = stdout;
+#endif
+#endif /* TWO_FILE_COMMANDLINE */
+
+  /* Collect comment text from comment_file or stdin, if necessary */
+  if (comment_arg == NULL) {
+    FILE *src_file;
+    int c;
+
+    comment_arg = (char *)malloc((size_t)MAX_COM_LENGTH);
+    if (comment_arg == NULL)
+      ERREXIT("Insufficient memory");
+    comment_length = 0;
+    src_file = (comment_file != NULL ? comment_file : stdin);
+    while ((c = getc(src_file)) != EOF) {
+      if (comment_length >= (unsigned int)MAX_COM_LENGTH) {
+        fprintf(stderr, "Comment text may not exceed %u bytes\n",
+                (unsigned int)MAX_COM_LENGTH);
+        exit(EXIT_FAILURE);
+      }
+      comment_arg[comment_length++] = (char)c;
+    }
+    if (comment_file != NULL)
+      fclose(comment_file);
+  }
+
+  /* Copy JPEG headers until SOFn marker;
+   * we will insert the new comment marker just before SOFn.
+   * This (a) causes the new comment to appear after, rather than before,
+   * existing comments; and (b) ensures that comments come after any JFIF
+   * or JFXX markers, as required by the JFIF specification.
+   */
+  marker = scan_JPEG_header(keep_COM);
+  /* Insert the new COM marker, but only if nonempty text has been supplied */
+  if (comment_length > 0) {
+    write_marker(M_COM);
+    write_2_bytes(comment_length + 2);
+    while (comment_length > 0) {
+      write_1_byte(*comment_arg++);
+      comment_length--;
+    }
+  }
+  /* Duplicate the remainder of the source file.
+   * Note that any COM markers occurring after SOF will not be touched.
+   */
+  write_marker(marker);
+  copy_rest_of_file();
+
+  /* All done. */
+  exit(EXIT_SUCCESS);
+  return 0;                     /* suppress no-return-value warnings */
+}
diff --git a/3rdparty/libjpeg/src/wrppm.c b/3rdparty/libjpeg/src/wrppm.c
new file mode 100644
index 00000000..3081ec33
--- /dev/null
+++ b/3rdparty/libjpeg/src/wrppm.c
@@ -0,0 +1,366 @@
+/*
+ * wrppm.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1991-1996, Thomas G. Lane.
+ * Modified 2009 by Guido Vollbeding.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2017, 2019-2020, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains routines to write output images in PPM/PGM format.
+ * The extended 2-byte-per-sample raw PPM/PGM formats are supported.
+ * The PBMPLUS library is NOT required to compile this software
+ * (but it is highly useful as a set of PPM image manipulation programs).
+ *
+ * These routines may need modification for non-Unix environments or
+ * specialized applications.  As they stand, they assume output to
+ * an ordinary stdio stream.
+ */
+
+#include "cmyk.h"
+#include "cdjpeg.h"             /* Common decls for cjpeg/djpeg applications */
+
+#ifdef PPM_SUPPORTED
+
+
+/*
+ * For 12-bit JPEG data, we either downscale the values to 8 bits
+ * (to write standard byte-per-sample PPM/PGM files), or output
+ * nonstandard word-per-sample PPM/PGM files.  Downscaling is done
+ * if PPM_NORAWWORD is defined (this can be done in the Makefile
+ * or in jconfig.h).
+ * (When the core library supports data precision reduction, a cleaner
+ * implementation will be to ask for that instead.)
+ */
+
+#if BITS_IN_JSAMPLE == 8
+#define PUTPPMSAMPLE(ptr, v)  *ptr++ = (char)(v)
+#define BYTESPERSAMPLE  1
+#define PPM_MAXVAL  255
+#else
+#ifdef PPM_NORAWWORD
+#define PUTPPMSAMPLE(ptr, v)  *ptr++ = (char)((v) >> (BITS_IN_JSAMPLE - 8))
+#define BYTESPERSAMPLE  1
+#define PPM_MAXVAL  255
+#else
+/* The word-per-sample format always puts the MSB first. */
+#define PUTPPMSAMPLE(ptr, v) { \
+  register int val_ = v; \
+  *ptr++ = (char)((val_ >> 8) & 0xFF); \
+  *ptr++ = (char)(val_ & 0xFF); \
+}
+#define BYTESPERSAMPLE  2
+#define PPM_MAXVAL  ((1 << BITS_IN_JSAMPLE) - 1)
+#endif
+#endif
+
+
+/*
+ * When JSAMPLE is the same size as char, we can just fwrite() the
+ * decompressed data to the PPM or PGM file.
+ */
+
+
+/* Private version of data destination object */
+
+typedef struct {
+  struct djpeg_dest_struct pub; /* public fields */
+
+  /* Usually these two pointers point to the same place: */
+  char *iobuffer;               /* fwrite's I/O buffer */
+  JSAMPROW pixrow;              /* decompressor output buffer */
+  size_t buffer_width;          /* width of I/O buffer */
+  JDIMENSION samples_per_row;   /* JSAMPLEs per output row */
+} ppm_dest_struct;
+
+typedef ppm_dest_struct *ppm_dest_ptr;
+
+
+/*
+ * Write some pixel data.
+ * In this module rows_supplied will always be 1.
+ *
+ * put_pixel_rows handles the "normal" 8-bit case where the decompressor
+ * output buffer is physically the same as the fwrite buffer.
+ */
+
+METHODDEF(void)
+put_pixel_rows(j_decompress_ptr cinfo, djpeg_dest_ptr dinfo,
+               JDIMENSION rows_supplied)
+{
+  ppm_dest_ptr dest = (ppm_dest_ptr)dinfo;
+
+  (void)JFWRITE(dest->pub.output_file, dest->iobuffer, dest->buffer_width);
+}
+
+
+/*
+ * This code is used when we have to copy the data and apply a pixel
+ * format translation.  Typically this only happens in 12-bit mode.
+ */
+
+METHODDEF(void)
+copy_pixel_rows(j_decompress_ptr cinfo, djpeg_dest_ptr dinfo,
+                JDIMENSION rows_supplied)
+{
+  ppm_dest_ptr dest = (ppm_dest_ptr)dinfo;
+  register char *bufferptr;
+  register JSAMPROW ptr;
+#if BITS_IN_JSAMPLE != 8
+  register JDIMENSION col;
+#endif
+
+  ptr = dest->pub.buffer[0];
+  bufferptr = dest->iobuffer;
+#if BITS_IN_JSAMPLE == 8
+  MEMCOPY(bufferptr, ptr, dest->samples_per_row);
+#else
+  for (col = dest->samples_per_row; col > 0; col--) {
+    PUTPPMSAMPLE(bufferptr, *ptr++);
+  }
+#endif
+  (void)JFWRITE(dest->pub.output_file, dest->iobuffer, dest->buffer_width);
+}
+
+
+/*
+ * Convert extended RGB to RGB.
+ */
+
+METHODDEF(void)
+put_rgb(j_decompress_ptr cinfo, djpeg_dest_ptr dinfo, JDIMENSION rows_supplied)
+{
+  ppm_dest_ptr dest = (ppm_dest_ptr)dinfo;
+  register char *bufferptr;
+  register JSAMPROW ptr;
+  register JDIMENSION col;
+  register int rindex = rgb_red[cinfo->out_color_space];
+  register int gindex = rgb_green[cinfo->out_color_space];
+  register int bindex = rgb_blue[cinfo->out_color_space];
+  register int ps = rgb_pixelsize[cinfo->out_color_space];
+
+  ptr = dest->pub.buffer[0];
+  bufferptr = dest->iobuffer;
+  for (col = cinfo->output_width; col > 0; col--) {
+    PUTPPMSAMPLE(bufferptr, ptr[rindex]);
+    PUTPPMSAMPLE(bufferptr, ptr[gindex]);
+    PUTPPMSAMPLE(bufferptr, ptr[bindex]);
+    ptr += ps;
+  }
+  (void)JFWRITE(dest->pub.output_file, dest->iobuffer, dest->buffer_width);
+}
+
+
+/*
+ * Convert CMYK to RGB.
+ */
+
+METHODDEF(void)
+put_cmyk(j_decompress_ptr cinfo, djpeg_dest_ptr dinfo,
+         JDIMENSION rows_supplied)
+{
+  ppm_dest_ptr dest = (ppm_dest_ptr)dinfo;
+  register char *bufferptr;
+  register JSAMPROW ptr;
+  register JDIMENSION col;
+
+  ptr = dest->pub.buffer[0];
+  bufferptr = dest->iobuffer;
+  for (col = cinfo->output_width; col > 0; col--) {
+    JSAMPLE r, g, b, c = *ptr++, m = *ptr++, y = *ptr++, k = *ptr++;
+    cmyk_to_rgb(c, m, y, k, &r, &g, &b);
+    PUTPPMSAMPLE(bufferptr, r);
+    PUTPPMSAMPLE(bufferptr, g);
+    PUTPPMSAMPLE(bufferptr, b);
+  }
+  (void)JFWRITE(dest->pub.output_file, dest->iobuffer, dest->buffer_width);
+}
+
+
+/*
+ * Write some pixel data when color quantization is in effect.
+ * We have to demap the color index values to straight data.
+ */
+
+METHODDEF(void)
+put_demapped_rgb(j_decompress_ptr cinfo, djpeg_dest_ptr dinfo,
+                 JDIMENSION rows_supplied)
+{
+  ppm_dest_ptr dest = (ppm_dest_ptr)dinfo;
+  register char *bufferptr;
+  register int pixval;
+  register JSAMPROW ptr;
+  register JSAMPROW color_map0 = cinfo->colormap[0];
+  register JSAMPROW color_map1 = cinfo->colormap[1];
+  register JSAMPROW color_map2 = cinfo->colormap[2];
+  register JDIMENSION col;
+
+  ptr = dest->pub.buffer[0];
+  bufferptr = dest->iobuffer;
+  for (col = cinfo->output_width; col > 0; col--) {
+    pixval = *ptr++;
+    PUTPPMSAMPLE(bufferptr, color_map0[pixval]);
+    PUTPPMSAMPLE(bufferptr, color_map1[pixval]);
+    PUTPPMSAMPLE(bufferptr, color_map2[pixval]);
+  }
+  (void)JFWRITE(dest->pub.output_file, dest->iobuffer, dest->buffer_width);
+}
+
+
+METHODDEF(void)
+put_demapped_gray(j_decompress_ptr cinfo, djpeg_dest_ptr dinfo,
+                  JDIMENSION rows_supplied)
+{
+  ppm_dest_ptr dest = (ppm_dest_ptr)dinfo;
+  register char *bufferptr;
+  register JSAMPROW ptr;
+  register JSAMPROW color_map = cinfo->colormap[0];
+  register JDIMENSION col;
+
+  ptr = dest->pub.buffer[0];
+  bufferptr = dest->iobuffer;
+  for (col = cinfo->output_width; col > 0; col--) {
+    PUTPPMSAMPLE(bufferptr, color_map[*ptr++]);
+  }
+  (void)JFWRITE(dest->pub.output_file, dest->iobuffer, dest->buffer_width);
+}
+
+
+/*
+ * Startup: write the file header.
+ */
+
+METHODDEF(void)
+start_output_ppm(j_decompress_ptr cinfo, djpeg_dest_ptr dinfo)
+{
+  ppm_dest_ptr dest = (ppm_dest_ptr)dinfo;
+
+  /* Emit file header */
+  switch (cinfo->out_color_space) {
+  case JCS_GRAYSCALE:
+    /* emit header for raw PGM format */
+    fprintf(dest->pub.output_file, "P5\n%ld %ld\n%d\n",
+            (long)cinfo->output_width, (long)cinfo->output_height, PPM_MAXVAL);
+    break;
+  case JCS_RGB:
+  case JCS_EXT_RGB:
+  case JCS_EXT_RGBX:
+  case JCS_EXT_BGR:
+  case JCS_EXT_BGRX:
+  case JCS_EXT_XBGR:
+  case JCS_EXT_XRGB:
+  case JCS_EXT_RGBA:
+  case JCS_EXT_BGRA:
+  case JCS_EXT_ABGR:
+  case JCS_EXT_ARGB:
+  case JCS_CMYK:
+    if (!IsExtRGB(cinfo->out_color_space) && cinfo->quantize_colors)
+      ERREXIT(cinfo, JERR_PPM_COLORSPACE);
+    /* emit header for raw PPM format */
+    fprintf(dest->pub.output_file, "P6\n%ld %ld\n%d\n",
+            (long)cinfo->output_width, (long)cinfo->output_height, PPM_MAXVAL);
+    break;
+  default:
+    ERREXIT(cinfo, JERR_PPM_COLORSPACE);
+  }
+}
+
+
+/*
+ * Finish up at the end of the file.
+ */
+
+METHODDEF(void)
+finish_output_ppm(j_decompress_ptr cinfo, djpeg_dest_ptr dinfo)
+{
+  /* Make sure we wrote the output file OK */
+  fflush(dinfo->output_file);
+  if (ferror(dinfo->output_file))
+    ERREXIT(cinfo, JERR_FILE_WRITE);
+}
+
+
+/*
+ * Re-calculate buffer dimensions based on output dimensions.
+ */
+
+METHODDEF(void)
+calc_buffer_dimensions_ppm(j_decompress_ptr cinfo, djpeg_dest_ptr dinfo)
+{
+  ppm_dest_ptr dest = (ppm_dest_ptr)dinfo;
+
+  if (cinfo->out_color_space == JCS_GRAYSCALE)
+    dest->samples_per_row = cinfo->output_width * cinfo->out_color_components;
+  else
+    dest->samples_per_row = cinfo->output_width * 3;
+  dest->buffer_width = dest->samples_per_row * (BYTESPERSAMPLE * sizeof(char));
+}
+
+
+/*
+ * The module selection routine for PPM format output.
+ */
+
+GLOBAL(djpeg_dest_ptr)
+jinit_write_ppm(j_decompress_ptr cinfo)
+{
+  ppm_dest_ptr dest;
+
+  /* Create module interface object, fill in method pointers */
+  dest = (ppm_dest_ptr)
+      (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+                                  sizeof(ppm_dest_struct));
+  dest->pub.start_output = start_output_ppm;
+  dest->pub.finish_output = finish_output_ppm;
+  dest->pub.calc_buffer_dimensions = calc_buffer_dimensions_ppm;
+
+  /* Calculate output image dimensions so we can allocate space */
+  jpeg_calc_output_dimensions(cinfo);
+
+  /* Create physical I/O buffer */
+  dest->pub.calc_buffer_dimensions(cinfo, (djpeg_dest_ptr)dest);
+  dest->iobuffer = (char *)(*cinfo->mem->alloc_small)
+    ((j_common_ptr)cinfo, JPOOL_IMAGE, dest->buffer_width);
+
+  if (cinfo->quantize_colors || BITS_IN_JSAMPLE != 8 ||
+      sizeof(JSAMPLE) != sizeof(char) ||
+#if RGB_RED == 0 && RGB_GREEN == 1 && RGB_BLUE == 2 && RGB_PIXELSIZE == 3
+      (cinfo->out_color_space != JCS_EXT_RGB &&
+       cinfo->out_color_space != JCS_RGB)) {
+#else
+      cinfo->out_color_space != JCS_EXT_RGB) {
+#endif
+    /* When quantizing, we need an output buffer for colormap indexes
+     * that's separate from the physical I/O buffer.  We also need a
+     * separate buffer if pixel format translation must take place.
+     */
+    dest->pub.buffer = (*cinfo->mem->alloc_sarray)
+      ((j_common_ptr)cinfo, JPOOL_IMAGE,
+       cinfo->output_width * cinfo->output_components, (JDIMENSION)1);
+    dest->pub.buffer_height = 1;
+    if (!cinfo->quantize_colors) {
+      if (IsExtRGB(cinfo->out_color_space))
+        dest->pub.put_pixel_rows = put_rgb;
+      else if (cinfo->out_color_space == JCS_CMYK)
+        dest->pub.put_pixel_rows = put_cmyk;
+      else
+        dest->pub.put_pixel_rows = copy_pixel_rows;
+    } else if (cinfo->out_color_space == JCS_GRAYSCALE)
+      dest->pub.put_pixel_rows = put_demapped_gray;
+    else
+      dest->pub.put_pixel_rows = put_demapped_rgb;
+  } else {
+    /* We will fwrite() directly from decompressor output buffer. */
+    /* Synthesize a JSAMPARRAY pointer structure */
+    dest->pixrow = (JSAMPROW)dest->iobuffer;
+    dest->pub.buffer = &dest->pixrow;
+    dest->pub.buffer_height = 1;
+    dest->pub.put_pixel_rows = put_pixel_rows;
+  }
+
+  return (djpeg_dest_ptr)dest;
+}
+
+#endif /* PPM_SUPPORTED */
diff --git a/3rdparty/libjpeg/src/wrtarga.c b/3rdparty/libjpeg/src/wrtarga.c
new file mode 100644
index 00000000..7a654ff5
--- /dev/null
+++ b/3rdparty/libjpeg/src/wrtarga.c
@@ -0,0 +1,258 @@
+/*
+ * wrtarga.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1991-1996, Thomas G. Lane.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2017, 2019, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains routines to write output images in Targa format.
+ *
+ * These routines may need modification for non-Unix environments or
+ * specialized applications.  As they stand, they assume output to
+ * an ordinary stdio stream.
+ *
+ * Based on code contributed by Lee Daniel Crocker.
+ */
+
+#include "cdjpeg.h"             /* Common decls for cjpeg/djpeg applications */
+
+#ifdef TARGA_SUPPORTED
+
+
+/*
+ * To support 12-bit JPEG data, we'd have to scale output down to 8 bits.
+ * This is not yet implemented.
+ */
+
+#if BITS_IN_JSAMPLE != 8
+  Sorry, this code only copes with 8-bit JSAMPLEs. /* deliberate syntax err */
+#endif
+
+
+/* Private version of data destination object */
+
+typedef struct {
+  struct djpeg_dest_struct pub; /* public fields */
+
+  char *iobuffer;               /* physical I/O buffer */
+  JDIMENSION buffer_width;      /* width of one row */
+} tga_dest_struct;
+
+typedef tga_dest_struct *tga_dest_ptr;
+
+
+LOCAL(void)
+write_header(j_decompress_ptr cinfo, djpeg_dest_ptr dinfo, int num_colors)
+/* Create and write a Targa header */
+{
+  char targaheader[18];
+
+  /* Set unused fields of header to 0 */
+  MEMZERO(targaheader, sizeof(targaheader));
+
+  if (num_colors > 0) {
+    targaheader[1] = 1;         /* color map type 1 */
+    targaheader[5] = (char)(num_colors & 0xFF);
+    targaheader[6] = (char)(num_colors >> 8);
+    targaheader[7] = 24;        /* 24 bits per cmap entry */
+  }
+
+  targaheader[12] = (char)(cinfo->output_width & 0xFF);
+  targaheader[13] = (char)(cinfo->output_width >> 8);
+  targaheader[14] = (char)(cinfo->output_height & 0xFF);
+  targaheader[15] = (char)(cinfo->output_height >> 8);
+  targaheader[17] = 0x20;       /* Top-down, non-interlaced */
+
+  if (cinfo->out_color_space == JCS_GRAYSCALE) {
+    targaheader[2] = 3;         /* image type = uncompressed grayscale */
+    targaheader[16] = 8;        /* bits per pixel */
+  } else {                      /* must be RGB */
+    if (num_colors > 0) {
+      targaheader[2] = 1;       /* image type = colormapped RGB */
+      targaheader[16] = 8;
+    } else {
+      targaheader[2] = 2;       /* image type = uncompressed RGB */
+      targaheader[16] = 24;
+    }
+  }
+
+  if (JFWRITE(dinfo->output_file, targaheader, 18) != (size_t)18)
+    ERREXIT(cinfo, JERR_FILE_WRITE);
+}
+
+
+/*
+ * Write some pixel data.
+ * In this module rows_supplied will always be 1.
+ */
+
+METHODDEF(void)
+put_pixel_rows(j_decompress_ptr cinfo, djpeg_dest_ptr dinfo,
+               JDIMENSION rows_supplied)
+/* used for unquantized full-color output */
+{
+  tga_dest_ptr dest = (tga_dest_ptr)dinfo;
+  register JSAMPROW inptr;
+  register char *outptr;
+  register JDIMENSION col;
+
+  inptr = dest->pub.buffer[0];
+  outptr = dest->iobuffer;
+  for (col = cinfo->output_width; col > 0; col--) {
+    outptr[0] = inptr[2]; /* RGB to BGR order */
+    outptr[1] = inptr[1];
+    outptr[2] = inptr[0];
+    inptr += 3, outptr += 3;
+  }
+  (void)JFWRITE(dest->pub.output_file, dest->iobuffer, dest->buffer_width);
+}
+
+METHODDEF(void)
+put_gray_rows(j_decompress_ptr cinfo, djpeg_dest_ptr dinfo,
+              JDIMENSION rows_supplied)
+/* used for grayscale OR quantized color output */
+{
+  tga_dest_ptr dest = (tga_dest_ptr)dinfo;
+  register JSAMPROW inptr;
+  register char *outptr;
+
+  inptr = dest->pub.buffer[0];
+  outptr = dest->iobuffer;
+  MEMCOPY(outptr, inptr, cinfo->output_width);
+  (void)JFWRITE(dest->pub.output_file, dest->iobuffer, dest->buffer_width);
+}
+
+
+/*
+ * Write some demapped pixel data when color quantization is in effect.
+ * For Targa, this is only applied to grayscale data.
+ */
+
+METHODDEF(void)
+put_demapped_gray(j_decompress_ptr cinfo, djpeg_dest_ptr dinfo,
+                  JDIMENSION rows_supplied)
+{
+  tga_dest_ptr dest = (tga_dest_ptr)dinfo;
+  register JSAMPROW inptr;
+  register char *outptr;
+  register JSAMPROW color_map0 = cinfo->colormap[0];
+  register JDIMENSION col;
+
+  inptr = dest->pub.buffer[0];
+  outptr = dest->iobuffer;
+  for (col = cinfo->output_width; col > 0; col--) {
+    *outptr++ = color_map0[*inptr++];
+  }
+  (void)JFWRITE(dest->pub.output_file, dest->iobuffer, dest->buffer_width);
+}
+
+
+/*
+ * Startup: write the file header.
+ */
+
+METHODDEF(void)
+start_output_tga(j_decompress_ptr cinfo, djpeg_dest_ptr dinfo)
+{
+  tga_dest_ptr dest = (tga_dest_ptr)dinfo;
+  int num_colors, i;
+  FILE *outfile;
+
+  if (cinfo->out_color_space == JCS_GRAYSCALE) {
+    /* Targa doesn't have a mapped grayscale format, so we will */
+    /* demap quantized gray output.  Never emit a colormap. */
+    write_header(cinfo, dinfo, 0);
+    if (cinfo->quantize_colors)
+      dest->pub.put_pixel_rows = put_demapped_gray;
+    else
+      dest->pub.put_pixel_rows = put_gray_rows;
+  } else if (cinfo->out_color_space == JCS_RGB) {
+    if (cinfo->quantize_colors) {
+      /* We only support 8-bit colormap indexes, so only 256 colors */
+      num_colors = cinfo->actual_number_of_colors;
+      if (num_colors > 256)
+        ERREXIT1(cinfo, JERR_TOO_MANY_COLORS, num_colors);
+      write_header(cinfo, dinfo, num_colors);
+      /* Write the colormap.  Note Targa uses BGR byte order */
+      outfile = dest->pub.output_file;
+      for (i = 0; i < num_colors; i++) {
+        putc(cinfo->colormap[2][i], outfile);
+        putc(cinfo->colormap[1][i], outfile);
+        putc(cinfo->colormap[0][i], outfile);
+      }
+      dest->pub.put_pixel_rows = put_gray_rows;
+    } else {
+      write_header(cinfo, dinfo, 0);
+      dest->pub.put_pixel_rows = put_pixel_rows;
+    }
+  } else {
+    ERREXIT(cinfo, JERR_TGA_COLORSPACE);
+  }
+}
+
+
+/*
+ * Finish up at the end of the file.
+ */
+
+METHODDEF(void)
+finish_output_tga(j_decompress_ptr cinfo, djpeg_dest_ptr dinfo)
+{
+  /* Make sure we wrote the output file OK */
+  fflush(dinfo->output_file);
+  if (ferror(dinfo->output_file))
+    ERREXIT(cinfo, JERR_FILE_WRITE);
+}
+
+
+/*
+ * Re-calculate buffer dimensions based on output dimensions.
+ */
+
+METHODDEF(void)
+calc_buffer_dimensions_tga(j_decompress_ptr cinfo, djpeg_dest_ptr dinfo)
+{
+  tga_dest_ptr dest = (tga_dest_ptr)dinfo;
+
+  dest->buffer_width = cinfo->output_width * cinfo->output_components;
+}
+
+
+/*
+ * The module selection routine for Targa format output.
+ */
+
+GLOBAL(djpeg_dest_ptr)
+jinit_write_targa(j_decompress_ptr cinfo)
+{
+  tga_dest_ptr dest;
+
+  /* Create module interface object, fill in method pointers */
+  dest = (tga_dest_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+                                sizeof(tga_dest_struct));
+  dest->pub.start_output = start_output_tga;
+  dest->pub.finish_output = finish_output_tga;
+  dest->pub.calc_buffer_dimensions = calc_buffer_dimensions_tga;
+
+  /* Calculate output image dimensions so we can allocate space */
+  jpeg_calc_output_dimensions(cinfo);
+
+  /* Create I/O buffer. */
+  dest->pub.calc_buffer_dimensions(cinfo, (djpeg_dest_ptr)dest);
+  dest->iobuffer = (char *)
+    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
+                                (size_t)(dest->buffer_width * sizeof(char)));
+
+  /* Create decompressor output buffer. */
+  dest->pub.buffer = (*cinfo->mem->alloc_sarray)
+    ((j_common_ptr)cinfo, JPOOL_IMAGE, dest->buffer_width, (JDIMENSION)1);
+  dest->pub.buffer_height = 1;
+
+  return (djpeg_dest_ptr)dest;
+}
+
+#endif /* TARGA_SUPPORTED */
diff --git a/3rdparty/libusb/CMakeLists.txt b/3rdparty/libusb/CMakeLists.txt
new file mode 100644
index 00000000..522c64e9
--- /dev/null
+++ b/3rdparty/libusb/CMakeLists.txt
@@ -0,0 +1,12 @@
+cmake_minimum_required(VERSION 3.5)
+
+add_subdirectory(src)
+
+# remove warning as error
+get_target_property(compile_options libusb_static COMPILE_OPTIONS)
+list(REMOVE_ITEM compile_options "-Werror" "/WX" "-Wpedantic")
+set_target_properties(libusb_static PROPERTIES COMPILE_OPTIONS "${compile_options}")
+
+add_library(libusb::libusb ALIAS libusb_static)
+ob_source_group(libusb::libusb)
+set_target_properties(libusb_static PROPERTIES FOLDER "dependencies")
diff --git a/3rdparty/libusb/src/.gitattributes b/3rdparty/libusb/src/.gitattributes
new file mode 100644
index 00000000..f93e0b6a
--- /dev/null
+++ b/3rdparty/libusb/src/.gitattributes
@@ -0,0 +1,7 @@
+*.ac            eol=lf
+*.am            eol=lf
+*.bat           eol=crlf
+*.sh            eol=lf
+.gitattributes  export-ignore
+.gitignore      export-ignore
+INSTALL_WIN.txt eol=crlf
diff --git a/3rdparty/libusb/src/.gitignore b/3rdparty/libusb/src/.gitignore
new file mode 100644
index 00000000..6eda9ef0
--- /dev/null
+++ b/3rdparty/libusb/src/.gitignore
@@ -0,0 +1,69 @@
+.deps
+.libs
+Makefile
+Makefile.in
+!doc/Makefile.in
+*.la
+*.lo
+*.o
+libtool
+ltmain.sh
+missing
+stamp-h1
+m4/
+autom4te.cache
+INSTALL
+install-sh
+depcomp
+configure
+aclocal.m4
+compile
+config.guess
+!msvc/config.h
+!msvc/libusb/config.h
+!android/libusb/config.h
+!Xcode/config.h
+!linux/config.h
+.vs
+config.log
+config.status
+config.sub
+*.swp
+doxygen.cfg
+examples/listdevs
+examples/xusb
+examples/dpfp
+examples/dpfp_threaded
+examples/fxload
+examples/hotplugtest
+examples/sam3u_benchmark
+examples/testlibusb
+tests/stress
+android/libs
+android/obj
+*.exe
+*.pc
+doc/api-1.0
+*.plg
+*.ncb
+*.opt
+Debug
+Release
+*.db
+*.user
+*.suo
+*.sdf
+*.opensdf
+*.patch
+*~
+*.orig
+.dirstamp
+.amend
+.DS_Store
+Xcode/build
+xcshareddata
+xcuserdata
+*.xcuserdatad
+*.xccheckout
+*.xcscmblueprint
+*.xcworkspace
diff --git a/3rdparty/libusb/src/.travis.yml b/3rdparty/libusb/src/.travis.yml
new file mode 100644
index 00000000..e92f0c45
--- /dev/null
+++ b/3rdparty/libusb/src/.travis.yml
@@ -0,0 +1,58 @@
+language: c
+
+git:
+    depth: 1
+
+matrix:
+    include:
+        - os: linux
+          dist: focal
+          compiler: clang
+        - os: linux
+          dist: focal
+          compiler: gcc
+        - os: linux
+          dist: bionic
+          compiler: clang
+        - os: linux
+          dist: bionic
+          compiler: gcc
+        - os: linux
+          dist: xenial
+          compiler: clang
+        - os: linux
+          dist: xenial
+          compiler: gcc
+        - os: osx
+          osx_image: xcode12.2
+          compiler: clang
+        - os: osx
+          osx_image: xcode11.3
+          compiler: clang
+        - os: osx
+          osx_image: xcode9.4
+          compiler: clang
+
+addons:
+    apt:
+        packages:
+            - autoconf
+            - automake
+            - libtool
+            - libudev-dev
+            - m4
+    homebrew:
+        packages:
+            - autoconf
+            - automake
+            - libtool
+            - m4
+
+before_script:
+    - ./bootstrap.sh
+
+script:
+    - if [ "$TRAVIS_OS_NAME" = "linux" ]; then .private/ci-build.sh --build-dir build-netlink -- --disable-udev; fi
+    - if [ "$TRAVIS_OS_NAME" = "linux" ]; then .private/ci-build.sh --build-dir build-udev -- --enable-udev; fi
+    - if [ "$TRAVIS_OS_NAME" = "osx" ]; then .private/ci-build.sh --build-dir build; fi
+    - if [ "$TRAVIS_OS_NAME" = "osx" ]; then cd Xcode && xcodebuild -project libusb.xcodeproj; fi
diff --git a/3rdparty/libusb/src/AUTHORS b/3rdparty/libusb/src/AUTHORS
new file mode 100644
index 00000000..8f91512a
--- /dev/null
+++ b/3rdparty/libusb/src/AUTHORS
@@ -0,0 +1,202 @@
+Copyright © 2001 Johannes Erdfelt <johannes@erdfelt.com>
+Copyright © 2007-2009 Daniel Drake <dsd@gentoo.org>
+Copyright © 2010-2012 Peter Stuge <peter@stuge.se>
+Copyright © 2008-2016 Nathan Hjelm <hjelmn@users.sourceforge.net>
+Copyright © 2009-2013 Pete Batard <pete@akeo.ie>
+Copyright © 2009-2013 Ludovic Rousseau <ludovic.rousseau@gmail.com>
+Copyright © 2010-2012 Michael Plante <michael.plante@gmail.com>
+Copyright © 2011-2013 Hans de Goede <hdegoede@redhat.com>
+Copyright © 2012-2013 Martin Pieuchot <mpi@openbsd.org>
+Copyright © 2012-2013 Toby Gray <toby.gray@realvnc.com>
+Copyright © 2013-2018 Chris Dickens <christopher.a.dickens@gmail.com>
+
+Other contributors:
+Aaron Luft
+Adam Korcz
+Adrian Bunk
+Adrien Destugues
+Akshay Jaggi
+Alan Ott
+Alan Stern
+Aleksandr Mezin
+Alexander Pyhalov
+Alexander Schlarb
+Alexander Stein
+Alex Vatchenko
+Andrew Aldridge
+Andrew Fernandes
+Andrew Goodney
+Andy Chunyu
+Andy McFadden
+Angus Gratton
+Anil Nair
+Ankur Verma
+Anthony Clay
+Antonio Ospite
+Artem Egorkine
+Aurelien Jarno
+Axel Gembe
+Aymeric Vincent
+Baruch Siach
+Bastien Nocera
+Bei Zhang
+Bence Csokas
+Benjamin Berg
+Benjamin Dobell
+Bohdan Tymkiv
+Brent Rector
+Bruno Harbulot
+Carl Karsten
+Christophe Zeitouny
+Chris Zhu
+Chunyu Xie
+Colin Walters
+Craig Hutchinson
+Dave Camarillo
+David Engraf
+Davidlohr Bueso
+David Moore
+Dmitry Fleytman
+Dmitry Kostjuchenko
+Dmitry Zakablukov
+Doug Johnston
+Evan Hunter
+Evan Miller
+Fabrice Fontaine
+Federico Manzan
+Felipe Balbi
+Florian Albrechtskirchinger
+Francesco Montorsi
+Francisco Facioni
+Frank Li
+Frederik Carlier
+Freek Dijkstra
+Gaurav Gupta
+Graeme Gill
+Greg Kroah-Hartman
+Gustavo Zacarias
+Haidong Zheng
+Hans Ulrich Niedermann
+Harry Mallon
+Hector Martin
+Hoi-Ho Chan
+Ido Yariv
+Igor Anokhin
+Ihor Dutchak
+Ilya Konstantinov
+Jakub Klama
+James Hanko
+Jeffrey Nichols
+Jie Zhang
+Jim Chen
+Johann Richard
+John Keeping
+John Sheu
+Jonas Malaco
+Jonathon Jongsma
+Joost Muller
+Josh Gao
+Joshua Blake
+Joshua Hou
+Juan Cruz Viotti
+Julian Scheel
+Justin Bischoff
+Karsten Koenig
+Keith Ahluwalia
+Kenjiro Tsuji
+Kimura Masaru
+Konrad Rzepecki
+Kuangye Guo
+Lars Kanis
+Lars Wirzenius
+Lei Chen
+Léo Lam
+Liang Yunwang
+Luca Longinotti
+Luz Paz
+Mac Wang
+Marco Trevisan (Treviño)
+Marcus Meissner
+Mark Kuo
+Markus Heidelberg
+Martin Ettl
+Martin Koegler
+Martin Ling
+Martin Thierer
+Mathias Hjärtström
+Matthew Stapleton
+Matthias Bolte
+Michael Dickens
+Michel Zou
+Mike Frysinger
+Mikhail Gusarov
+Mikolaj Kucharski
+Morgan Leborgne
+Moritz Fischer
+Nancy Li
+Nia Alarie
+Nicholas Corgan
+Omri Iluz
+Orin Eman
+Ozkan Sezer
+Patrick Stewart
+Paul Cercueil
+Paul Fertser
+Paul Qureshi
+Pekka Nikander
+Philémon Favrod
+Pino Toscano
+Rob Walker
+Romain Vimont
+Roman Kalashnikov
+Ryan Hileman
+Ryan Schmidt
+Saleem Rashid
+Sameeh Jubran
+Sean McBride
+Sebastian Pipping
+Sebastian von Ohr
+Sergey Serb
+Shawn Hoffman
+Simon Haggett
+Simon Newton
+Slash Gordon
+Stefan Agner
+Stefan Tauner
+Steinar H. Gunderson
+Stephen Groat
+Theo Buehler
+Thomas Röfer
+Tim Hutt
+Tim Roberts
+Tobias Klauser
+Toby Peterson
+Tormod Volden
+Trygve Laugstøl
+Uri Lublin
+Uwe Bonnes
+Vasily Khoruzhick
+Vegard Storheil Eriksen
+Venkatesh Shukla
+Vianney le Clément de Saint-Marcq
+Victor Toso
+Vinicius Tinti
+Vitali Lovich
+Vladimir Beloborodov
+William Orr
+William Skellenger
+Xiaofan Chen
+Yegor Yefremov
+Zhiqiang Liu
+Zoltán Kovács
+Сергей Валерьевич
+Ларионов Даниил
+Роман Донченко
+jonner
+orbitcowboy
+osy
+parafin
+RipleyTom
+Seneral
+saur0n
+winterrace
diff --git a/3rdparty/libusb/src/CMakeLists.txt b/3rdparty/libusb/src/CMakeLists.txt
new file mode 100644
index 00000000..23932091
--- /dev/null
+++ b/3rdparty/libusb/src/CMakeLists.txt
@@ -0,0 +1,59 @@
+cmake_minimum_required(VERSION 3.5)
+
+set(LIBUSB_C libusb/core.c libusb/descriptor.c libusb/hotplug.c libusb/io.c libusb/strerror.c libusb/sync.c)
+if(WIN32)
+    list(
+        APPEND
+        LIBUSB_C
+        libusb/os/threads_windows.c
+        libusb/os/threads_windows.c
+        libusb/os/events_windows.c
+        libusb/os/windows_winusb.c
+        libusb/os/windows_common.c
+        libusb/os/windows_usbdk.c)
+
+elseif(OB_BUILD_ANDROID)
+    list(APPEND LIBUSB_C libusb/os/linux_usbfs.c libusb/os/events_posix.c libusb/os/threads_posix.c
+         libusb/os/linux_netlink.c)
+elseif(OB_BUILD_MACOS)
+    list(APPEND LIBUSB_C libusb/os/darwin_usb.c libusb/os/events_posix.c libusb/os/threads_posix.c)
+else()
+    list(APPEND LIBUSB_C libusb/os/linux_usbfs.c libusb/os/events_posix.c libusb/os/threads_posix.c
+         libusb/os/linux_netlink.c)
+endif()
+
+set(LIBUSB_H libusb/libusb.h)
+
+add_library(libusb_static STATIC ${LIBUSB_C} ${LIBUSB_H})
+target_include_directories(libusb_static PUBLIC ${CMAKE_CURRENT_LIST_DIR}/libusb)
+target_include_directories(libusb_static PUBLIC ${CMAKE_CURRENT_LIST_DIR}/libusb/os)
+
+if(OB_BUILD_LINUX)
+    target_include_directories(libusb_static PUBLIC ${CMAKE_CURRENT_LIST_DIR}/linux)
+elseif(OB_BUILD_MACOS)
+    target_include_directories(libusb_static PUBLIC ${CMAKE_CURRENT_LIST_DIR}/Xcode)
+    target_link_libraries(libusb_static "-framework CoreFoundation -framework IOKit -framework Security")
+elseif(OB_BUILD_ANDROID)
+    target_include_directories(libusb_static PUBLIC ${CMAKE_CURRENT_LIST_DIR}/android)
+else(OB_BUILD_WIN32)
+    target_include_directories(libusb_static PUBLIC ${CMAKE_CURRENT_LIST_DIR}/msvc)
+    target_include_directories(libusb_static PUBLIC ${CMAKE_CURRENT_LIST_DIR}/msvc/getopt)
+    foreach(
+        flag_var
+        CMAKE_CXX_FLAGS
+        CMAKE_CXX_FLAGS_DEBUG
+        CMAKE_CXX_FLAGS_RELEASE
+        CMAKE_CXX_FLAGS_MINSIZEREL
+        CMAKE_CXX_FLAGS_RELWITHDEBINFO
+        CMAKE_C_FLAGS
+        CMAKE_C_FLAGS_DEBUG
+        CMAKE_C_FLAGS_RELEASE
+        CMAKE_C_FLAGS_MINSIZEREL
+        CMAKE_C_FLAGS_RELWITHDEBINFO)
+        if(${flag_var} MATCHES "/MD")
+            string(REGEX REPLACE "/MD" "/MT" ${flag_var} "${${flag_var}}")
+        endif(${flag_var} MATCHES "/MD")
+    endforeach(flag_var)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /utf-8")
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS}   /utf-8")
+endif()
diff --git a/3rdparty/libusb/src/COPYING b/3rdparty/libusb/src/COPYING
new file mode 100644
index 00000000..5ab7695a
--- /dev/null
+++ b/3rdparty/libusb/src/COPYING
@@ -0,0 +1,504 @@
+		  GNU LESSER GENERAL PUBLIC LICENSE
+		       Version 2.1, February 1999
+
+ Copyright (C) 1991, 1999 Free Software Foundation, Inc.
+ 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+[This is the first released version of the Lesser GPL.  It also counts
+ as the successor of the GNU Library Public License, version 2, hence
+ the version number 2.1.]
+
+			    Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+Licenses are intended to guarantee your freedom to share and change
+free software--to make sure the software is free for all its users.
+
+  This license, the Lesser General Public License, applies to some
+specially designated software packages--typically libraries--of the
+Free Software Foundation and other authors who decide to use it.  You
+can use it too, but we suggest you first think carefully about whether
+this license or the ordinary General Public License is the better
+strategy to use in any particular case, based on the explanations below.
+
+  When we speak of free software, we are referring to freedom of use,
+not price.  Our General Public Licenses are designed to make sure that
+you have the freedom to distribute copies of free software (and charge
+for this service if you wish); that you receive source code or can get
+it if you want it; that you can change the software and use pieces of
+it in new free programs; and that you are informed that you can do
+these things.
+
+  To protect your rights, we need to make restrictions that forbid
+distributors to deny you these rights or to ask you to surrender these
+rights.  These restrictions translate to certain responsibilities for
+you if you distribute copies of the library or if you modify it.
+
+  For example, if you distribute copies of the library, whether gratis
+or for a fee, you must give the recipients all the rights that we gave
+you.  You must make sure that they, too, receive or can get the source
+code.  If you link other code with the library, you must provide
+complete object files to the recipients, so that they can relink them
+with the library after making changes to the library and recompiling
+it.  And you must show them these terms so they know their rights.
+
+  We protect your rights with a two-step method: (1) we copyright the
+library, and (2) we offer you this license, which gives you legal
+permission to copy, distribute and/or modify the library.
+
+  To protect each distributor, we want to make it very clear that
+there is no warranty for the free library.  Also, if the library is
+modified by someone else and passed on, the recipients should know
+that what they have is not the original version, so that the original
+author's reputation will not be affected by problems that might be
+introduced by others.
+
+  Finally, software patents pose a constant threat to the existence of
+any free program.  We wish to make sure that a company cannot
+effectively restrict the users of a free program by obtaining a
+restrictive license from a patent holder.  Therefore, we insist that
+any patent license obtained for a version of the library must be
+consistent with the full freedom of use specified in this license.
+
+  Most GNU software, including some libraries, is covered by the
+ordinary GNU General Public License.  This license, the GNU Lesser
+General Public License, applies to certain designated libraries, and
+is quite different from the ordinary General Public License.  We use
+this license for certain libraries in order to permit linking those
+libraries into non-free programs.
+
+  When a program is linked with a library, whether statically or using
+a shared library, the combination of the two is legally speaking a
+combined work, a derivative of the original library.  The ordinary
+General Public License therefore permits such linking only if the
+entire combination fits its criteria of freedom.  The Lesser General
+Public License permits more lax criteria for linking other code with
+the library.
+
+  We call this license the "Lesser" General Public License because it
+does Less to protect the user's freedom than the ordinary General
+Public License.  It also provides other free software developers Less
+of an advantage over competing non-free programs.  These disadvantages
+are the reason we use the ordinary General Public License for many
+libraries.  However, the Lesser license provides advantages in certain
+special circumstances.
+
+  For example, on rare occasions, there may be a special need to
+encourage the widest possible use of a certain library, so that it becomes
+a de-facto standard.  To achieve this, non-free programs must be
+allowed to use the library.  A more frequent case is that a free
+library does the same job as widely used non-free libraries.  In this
+case, there is little to gain by limiting the free library to free
+software only, so we use the Lesser General Public License.
+
+  In other cases, permission to use a particular library in non-free
+programs enables a greater number of people to use a large body of
+free software.  For example, permission to use the GNU C Library in
+non-free programs enables many more people to use the whole GNU
+operating system, as well as its variant, the GNU/Linux operating
+system.
+
+  Although the Lesser General Public License is Less protective of the
+users' freedom, it does ensure that the user of a program that is
+linked with the Library has the freedom and the wherewithal to run
+that program using a modified version of the Library.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.  Pay close attention to the difference between a
+"work based on the library" and a "work that uses the library".  The
+former contains code derived from the library, whereas the latter must
+be combined with the library in order to run.
+
+		  GNU LESSER GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License Agreement applies to any software library or other
+program which contains a notice placed by the copyright holder or
+other authorized party saying it may be distributed under the terms of
+this Lesser General Public License (also called "this License").
+Each licensee is addressed as "you".
+
+  A "library" means a collection of software functions and/or data
+prepared so as to be conveniently linked with application programs
+(which use some of those functions and data) to form executables.
+
+  The "Library", below, refers to any such software library or work
+which has been distributed under these terms.  A "work based on the
+Library" means either the Library or any derivative work under
+copyright law: that is to say, a work containing the Library or a
+portion of it, either verbatim or with modifications and/or translated
+straightforwardly into another language.  (Hereinafter, translation is
+included without limitation in the term "modification".)
+
+  "Source code" for a work means the preferred form of the work for
+making modifications to it.  For a library, complete source code means
+all the source code for all modules it contains, plus any associated
+interface definition files, plus the scripts used to control compilation
+and installation of the library.
+
+  Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running a program using the Library is not restricted, and output from
+such a program is covered only if its contents constitute a work based
+on the Library (independent of the use of the Library in a tool for
+writing it).  Whether that is true depends on what the Library does
+and what the program that uses the Library does.
+  
+  1. You may copy and distribute verbatim copies of the Library's
+complete source code as you receive it, in any medium, provided that
+you conspicuously and appropriately publish on each copy an
+appropriate copyright notice and disclaimer of warranty; keep intact
+all the notices that refer to this License and to the absence of any
+warranty; and distribute a copy of this License along with the
+Library.
+
+  You may charge a fee for the physical act of transferring a copy,
+and you may at your option offer warranty protection in exchange for a
+fee.
+
+  2. You may modify your copy or copies of the Library or any portion
+of it, thus forming a work based on the Library, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) The modified work must itself be a software library.
+
+    b) You must cause the files modified to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    c) You must cause the whole of the work to be licensed at no
+    charge to all third parties under the terms of this License.
+
+    d) If a facility in the modified Library refers to a function or a
+    table of data to be supplied by an application program that uses
+    the facility, other than as an argument passed when the facility
+    is invoked, then you must make a good faith effort to ensure that,
+    in the event an application does not supply such function or
+    table, the facility still operates, and performs whatever part of
+    its purpose remains meaningful.
+
+    (For example, a function in a library to compute square roots has
+    a purpose that is entirely well-defined independent of the
+    application.  Therefore, Subsection 2d requires that any
+    application-supplied function or table used by this function must
+    be optional: if the application does not supply it, the square
+    root function must still compute square roots.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Library,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Library, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote
+it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Library.
+
+In addition, mere aggregation of another work not based on the Library
+with the Library (or with a work based on the Library) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may opt to apply the terms of the ordinary GNU General Public
+License instead of this License to a given copy of the Library.  To do
+this, you must alter all the notices that refer to this License, so
+that they refer to the ordinary GNU General Public License, version 2,
+instead of to this License.  (If a newer version than version 2 of the
+ordinary GNU General Public License has appeared, then you can specify
+that version instead if you wish.)  Do not make any other change in
+these notices.
+
+  Once this change is made in a given copy, it is irreversible for
+that copy, so the ordinary GNU General Public License applies to all
+subsequent copies and derivative works made from that copy.
+
+  This option is useful when you wish to copy part of the code of
+the Library into a program that is not a library.
+
+  4. You may copy and distribute the Library (or a portion or
+derivative of it, under Section 2) in object code or executable form
+under the terms of Sections 1 and 2 above provided that you accompany
+it with the complete corresponding machine-readable source code, which
+must be distributed under the terms of Sections 1 and 2 above on a
+medium customarily used for software interchange.
+
+  If distribution of object code is made by offering access to copy
+from a designated place, then offering equivalent access to copy the
+source code from the same place satisfies the requirement to
+distribute the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  5. A program that contains no derivative of any portion of the
+Library, but is designed to work with the Library by being compiled or
+linked with it, is called a "work that uses the Library".  Such a
+work, in isolation, is not a derivative work of the Library, and
+therefore falls outside the scope of this License.
+
+  However, linking a "work that uses the Library" with the Library
+creates an executable that is a derivative of the Library (because it
+contains portions of the Library), rather than a "work that uses the
+library".  The executable is therefore covered by this License.
+Section 6 states terms for distribution of such executables.
+
+  When a "work that uses the Library" uses material from a header file
+that is part of the Library, the object code for the work may be a
+derivative work of the Library even though the source code is not.
+Whether this is true is especially significant if the work can be
+linked without the Library, or if the work is itself a library.  The
+threshold for this to be true is not precisely defined by law.
+
+  If such an object file uses only numerical parameters, data
+structure layouts and accessors, and small macros and small inline
+functions (ten lines or less in length), then the use of the object
+file is unrestricted, regardless of whether it is legally a derivative
+work.  (Executables containing this object code plus portions of the
+Library will still fall under Section 6.)
+
+  Otherwise, if the work is a derivative of the Library, you may
+distribute the object code for the work under the terms of Section 6.
+Any executables containing that work also fall under Section 6,
+whether or not they are linked directly with the Library itself.
+
+  6. As an exception to the Sections above, you may also combine or
+link a "work that uses the Library" with the Library to produce a
+work containing portions of the Library, and distribute that work
+under terms of your choice, provided that the terms permit
+modification of the work for the customer's own use and reverse
+engineering for debugging such modifications.
+
+  You must give prominent notice with each copy of the work that the
+Library is used in it and that the Library and its use are covered by
+this License.  You must supply a copy of this License.  If the work
+during execution displays copyright notices, you must include the
+copyright notice for the Library among them, as well as a reference
+directing the user to the copy of this License.  Also, you must do one
+of these things:
+
+    a) Accompany the work with the complete corresponding
+    machine-readable source code for the Library including whatever
+    changes were used in the work (which must be distributed under
+    Sections 1 and 2 above); and, if the work is an executable linked
+    with the Library, with the complete machine-readable "work that
+    uses the Library", as object code and/or source code, so that the
+    user can modify the Library and then relink to produce a modified
+    executable containing the modified Library.  (It is understood
+    that the user who changes the contents of definitions files in the
+    Library will not necessarily be able to recompile the application
+    to use the modified definitions.)
+
+    b) Use a suitable shared library mechanism for linking with the
+    Library.  A suitable mechanism is one that (1) uses at run time a
+    copy of the library already present on the user's computer system,
+    rather than copying library functions into the executable, and (2)
+    will operate properly with a modified version of the library, if
+    the user installs one, as long as the modified version is
+    interface-compatible with the version that the work was made with.
+
+    c) Accompany the work with a written offer, valid for at
+    least three years, to give the same user the materials
+    specified in Subsection 6a, above, for a charge no more
+    than the cost of performing this distribution.
+
+    d) If distribution of the work is made by offering access to copy
+    from a designated place, offer equivalent access to copy the above
+    specified materials from the same place.
+
+    e) Verify that the user has already received a copy of these
+    materials or that you have already sent this user a copy.
+
+  For an executable, the required form of the "work that uses the
+Library" must include any data and utility programs needed for
+reproducing the executable from it.  However, as a special exception,
+the materials to be distributed need not include anything that is
+normally distributed (in either source or binary form) with the major
+components (compiler, kernel, and so on) of the operating system on
+which the executable runs, unless that component itself accompanies
+the executable.
+
+  It may happen that this requirement contradicts the license
+restrictions of other proprietary libraries that do not normally
+accompany the operating system.  Such a contradiction means you cannot
+use both them and the Library together in an executable that you
+distribute.
+
+  7. You may place library facilities that are a work based on the
+Library side-by-side in a single library together with other library
+facilities not covered by this License, and distribute such a combined
+library, provided that the separate distribution of the work based on
+the Library and of the other library facilities is otherwise
+permitted, and provided that you do these two things:
+
+    a) Accompany the combined library with a copy of the same work
+    based on the Library, uncombined with any other library
+    facilities.  This must be distributed under the terms of the
+    Sections above.
+
+    b) Give prominent notice with the combined library of the fact
+    that part of it is a work based on the Library, and explaining
+    where to find the accompanying uncombined form of the same work.
+
+  8. You may not copy, modify, sublicense, link with, or distribute
+the Library except as expressly provided under this License.  Any
+attempt otherwise to copy, modify, sublicense, link with, or
+distribute the Library is void, and will automatically terminate your
+rights under this License.  However, parties who have received copies,
+or rights, from you under this License will not have their licenses
+terminated so long as such parties remain in full compliance.
+
+  9. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Library or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Library (or any work based on the
+Library), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Library or works based on it.
+
+  10. Each time you redistribute the Library (or any work based on the
+Library), the recipient automatically receives a license from the
+original licensor to copy, distribute, link with or modify the Library
+subject to these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties with
+this License.
+
+  11. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Library at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Library by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Library.
+
+If any portion of this section is held invalid or unenforceable under any
+particular circumstance, the balance of the section is intended to apply,
+and the section as a whole is intended to apply in other circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  12. If the distribution and/or use of the Library is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Library under this License may add
+an explicit geographical distribution limitation excluding those countries,
+so that distribution is permitted only in or among countries not thus
+excluded.  In such case, this License incorporates the limitation as if
+written in the body of this License.
+
+  13. The Free Software Foundation may publish revised and/or new
+versions of the Lesser General Public License from time to time.
+Such new versions will be similar in spirit to the present version,
+but may differ in detail to address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Library
+specifies a version number of this License which applies to it and
+"any later version", you have the option of following the terms and
+conditions either of that version or of any later version published by
+the Free Software Foundation.  If the Library does not specify a
+license version number, you may choose any version ever published by
+the Free Software Foundation.
+
+  14. If you wish to incorporate parts of the Library into other free
+programs whose distribution conditions are incompatible with these,
+write to the author to ask for permission.  For software which is
+copyrighted by the Free Software Foundation, write to the Free
+Software Foundation; we sometimes make exceptions for this.  Our
+decision will be guided by the two goals of preserving the free status
+of all derivatives of our free software and of promoting the sharing
+and reuse of software generally.
+
+			    NO WARRANTY
+
+  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
+OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
+KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
+LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
+AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
+FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
+CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
+LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
+RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
+FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES.
+
+		     END OF TERMS AND CONDITIONS
+
+           How to Apply These Terms to Your New Libraries
+
+  If you develop a new library, and you want it to be of the greatest
+possible use to the public, we recommend making it free software that
+everyone can redistribute and change.  You can do so by permitting
+redistribution under these terms (or, alternatively, under the terms of the
+ordinary General Public License).
+
+  To apply these terms, attach the following notices to the library.  It is
+safest to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least the
+"copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the library's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+Also add information on how to contact you by electronic and paper mail.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the library, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the
+  library `Frob' (a library for tweaking knobs) written by James Random Hacker.
+
+  <signature of Ty Coon>, 1 April 1990
+  Ty Coon, President of Vice
+
+That's all there is to it!
+
+
diff --git a/3rdparty/libusb/src/ChangeLog b/3rdparty/libusb/src/ChangeLog
new file mode 100644
index 00000000..326a9b3e
--- /dev/null
+++ b/3rdparty/libusb/src/ChangeLog
@@ -0,0 +1,334 @@
+For detailed information about the changes below, please see the git log or
+visit: http://log.libusb.info
+
+2022-04-10: v1.0.26
+* Fix regression with transfer free's after closing device
+* Fix regression with destroyed context if API is misused
+* Workaround for applications using missing default context
+* Fix hotplog enumeration regression
+* Fix Windows isochronous transfer regression since 1.0.24
+* Fix macOS exit crash in some multi-context cases
+* Build fixes for various platforms and configurations
+* Fix Windows HID multi-interface product string retrieval
+* Update isochronous OUT packet actual lengths on Windows
+* Add interface bound checking for broken devices
+* Add umockdev tests on Linux
+
+2022-01-31: v1.0.25
+* Linux: Fix regression with some particular devices
+* Linux: Fix regression with libusb_handle_events_timeout_completed()
+* Linux: Fix regression with cpu usage in libusb_bulk_transfer
+* Darwin (macOS): Add support for detaching kernel drivers with authorization.
+* Darwin (macOS): Do not drop partial data on timeout.
+* Darwin (macOS): Silence pipe error in set_interface_alt_setting().
+* Windows: Fix HID backend missing byte
+* Windows: Fix segfault with libusbk driver
+* Windows: Fix regression when using libusb0 driver
+* Windows: Support LIBUSB_TRANSFER_ADD_ZERO_PACKET on winusb
+* New NO_DEVICE_DISCOVERY option replaces WEAK_AUTHORITY option
+* Various other bug fixes and improvements
+
+2020-12-09: v1.0.24
+* Add new platform abstraction (#252)
+* Add Null POSIX backend
+* Add support for eventfd
+* Add support for thread IDs on Haiku, NetBSD and Solaris
+* New API libusb_hotplug_get_user_data()
+* Darwin (macOS): Fix race condition that results in segmentation fault (#701)
+* Darwin (macOS): Fix stale descriptor information post reset (#733)
+* Darwin (macOS): use IOUSBDevice as darwin_device_class explicitly (#693)
+* Linux: Drop support for kernel older than 2.6.32
+* Linux: Provide an event thread name (#689)
+* Linux: Wait until all URBs have been reaped before freeing them (#607)
+* NetBSD: Recognize device timeouts (#710)
+* OpenBSD: Allow opening ugen devices multiple times (#763)
+* OpenBSD: Support libusb_get_port_number() (#764)
+* SunOS: Fix a memory leak (#756)
+* SunOS: Various fixes (#627, #628, #629)
+* Windows: Add Visual Studio 2019 support
+* Windows: Drop support for WinCE and Visual Studio older than 2013
+* Windows: Drop support for Windows XP
+* Windows: Support building all examples using Visual Studio (#151)
+* Documentation fixes and improvements
+* Various other bug fixes and improvements
+
+2019-08-28: v1.0.23
+* Add German translation (#446)
+* Add Hungarian translation (#493)
+* Android: Improved support for Android
+* BSD: Remove infinite recursion in OpenBSD backend
+* configure.ac: Fix detection of clock_gettime library (#439)
+* Core: abandon synchronous transfers when device closure is detected.
+* Core: fix error in handling the removal of file descriptors while handling
+  events.
+* Darwin(macOS): Switch from using ResetDevice to USBDeviceReEnumerate (#455)
+* Darwin(macOS): Remove code that changed the device class used (#428)
+* Darwin(macOS): Reduce hotplug timeout to 1ms (from 5s)
+* New API libusb_set_log_cb() to redirect global and per context log
+  messages to the provided log handling function
+* New API libusb_wrap_sys_device to allow the user to specify the
+  usb device to use.
+* Solaris: Break infinite recursion in backend clock_gettime
+* Solaris: Enable timerfd on sunos when available
+* Windows: Add support for isochronous transfers with WinUSB
+* Various other bug fixes and improvements
+
+2018-03-24: v1.0.22
+* New libusb_set_option() API
+* Fix transfer timeout not being cleared upon resubmission
+* Report super speed plus devices on modern Linux and macOS
+* Darwin: Improve support for macOS Sierra and High Sierra
+* Darwin: SDK fixes and improvements
+* Linux: Let initialization succeed when no devices are present
+* Linux: Mark internal file descriptors with CLOEXEC flag
+* Solaris: Add support for attach/detach kernel driver
+* Windows: Add dynamic UsbDk backend selection
+* Windows: Add isochronous transfer support via libusbK
+* Windows: Add Visual Studio 2017 support
+* Windows: Fix enumeration problems on Windows 8 and later
+* Windows: Major rework of poll() emulation
+* Windows: Numerous HID API fixes
+* Windows: Support cancellation of individual transfers (Vista and later)
+* Various other bug fixes and improvements
+
+2016-10-01: v1.0.21
+* Core: Refactor code related to transfer flags and timeout handling
+* Darwin: Ignore root hub simulation devices
+* Darwin: Improved support for OS X El Capitan
+* Darwin: Work around devices with buggy endpoint descriptors
+* Darwin: Do not use objc_registerThreadWithCollector after its deprecation
+* Darwin: Use C11 atomics on 10.12+ as the OS atomics are now deprecated
+* Linux: Support preallocating kernel memory for zerocopy USB
+* Linux: Deal with receiving POLLERR before all transfers have completed
+* Solaris: Add solaris backend
+* Windows: Add Visual Studio 2015 support
+* Windows: Add usbdk backend
+* Prevent attempts to recursively handle events
+* Fix race condition in handle_timeout()
+* Allow transferred argument to be optional in bulk APIs
+* Various other bug fixes and improvements
+
+2015-09-13: v1.0.20
+* Add Haiku support
+* Fix multiple memory and resource leaks (#16, #52, #76, #81)
+* Fix possible deadlock when executing transfer callback
+* New libusb_free_pollfds() API
+* Darwin: Fix devices not being detected on OS X 10.8 (#48)
+* Linux: Allow larger isochronous transfer submission (#23)
+* Windows: Fix broken builds Cygwin/MinGW builds and compiler warnings
+* Windows: Fix broken bus number lookup
+* Windows: Improve submission of control requests for composite devices
+* Examples: Add two-stage load support to fxload (#12)
+* Correctly report cancellations due to timeouts
+* Improve efficiency of event handling
+* Improve speed of transfer submission in multi-threaded environments
+* Various other bug fixes and improvements
+The (#xx) numbers are libusb issue numbers, see ie:
+https://github.com/libusb/libusb/issues/16
+
+2014-05-30: v1.0.19
+* Add support for USB bulk streams on Linux and Mac OS X (#11)
+* Windows: Add AMD and Intel USB-3.0 root hub support
+* Windows: Fix USB 3.0 speed detection on Windows 8 or later (#10)
+* Added Russian translation for libusb_strerror strings
+* All: Various small fixes and cleanups
+
+2014-01-25: v1.0.18
+* Fix multiple memory leaks
+* Fix a crash when HID transfers return no data on Windows
+* Ensure all pending events are consumed
+* Improve Android and ucLinux support
+* Multiple Windows improvements (error logging, VS2013, VIA xHCI support)
+* Multiple OS X improvements (broken compilation, SIGFPE, 64bit support)
+
+2013-09-06: v1.0.17
+* Hotplug callbacks now always get passed a libusb_context, even if it is
+  the default context. Previously NULL would be passed for the default context,
+  but since the first context created is the default context, and most apps
+  use only 1 context, this meant that apps explicitly creating a context would
+  still get passed NULL
+* Android: Add .mk files to build with the Android NDK
+* Darwin: Add Xcode project
+* Darwin: Fix crash on unplug (#121)
+* Linux: Fix hang (deadlock) on libusb_exit
+* Linux: Fix libusb build failure with --disable-udev (#124)
+* Linux: Fix libusb_get_device_list() hang with --disable-udev (#130)
+* OpenBSD: Update OpenBSD backend with support for control transfers to
+  non-ugen(4) devices and make get_configuration() no longer generate I/O.
+  Note that using this libusb version on OpenBSD requires using
+  OpenBSD 5.3-current or later. Users of older OpenBSD versions are advised
+  to stay with the libusb shipped with OpenBSD (mpi)
+* Windows: fix libusb_dll_2010.vcxproj link errors (#129)
+* Various other bug fixes and improvements
+
+2013-07-11: v1.0.16
+* Add hotplug support for Darwin and Linux (#9)
+* Add superspeed endpoint companion descriptor support (#15)
+* Add BOS descriptor support (#15)
+* Make descriptor parsing code more robust
+* New libusb_get_port_numbers API, this is libusb_get_port_path without
+  the unnecessary context parameter, libusb_get_port_path is now deprecated
+* New libusb_strerror API (#14)
+* New libusb_set_auto_detach_kernel_driver API (#17)
+* Improve topology API docs (#95)
+* Logging now use a single write call per log-message, avoiding log-message
+  "interlacing" when using multiple threads.
+* Android: use Android logging when building on Android (#101)
+* Darwin: make libusb_reset reenumerate device on descriptors change (#89)
+* Darwin: add support for the LIBUSB_TRANSFER_ADD_ZERO_PACKET flag (#91)
+* Darwin: add a device cache (#112, #114)
+* Examples: Add sam3u_benchmark isochronous example by Harald Welte (#109)
+* Many other bug fixes and improvements
+The (#xx) numbers are libusbx issue numbers, see ie:
+https://github.com/libusbx/libusbx/issues/9
+
+2013-04-15: v1.0.15
+* Improve transfer cancellation and avoid short read failures on broken descriptors
+* Filter out 8-bit characters in libusb_get_string_descriptor_ascii()
+* Add WinCE support
+* Add library stress tests
+* Add Cypress FX3 firmware upload support for fxload sample
+* Add HID and kernel driver detach support capabilities detection
+* Add SuperSpeed detection on OS X
+* Fix bInterval value interpretation on OS X
+* Fix issues with autoclaim, composite HID devices, interface autoclaim and
+  early abort in libusb_close() on Windows. Also add VS2012 solution files.
+* Improve fd event handling on Linux
+* Other bug fixes and improvements
+
+2012-09-26: v1.0.14
+* Reverts the previous API change with regards to bMaxPower.
+  If this doesn't matter to you, you are encouraged to keep using v1.0.13,
+  as it will use the same attribute as v2.0, to be released soon.
+* Note that LIBUSB_API_VERSION is *decreased* to 0x010000FF and the previous
+  guidelines with regards to concurrent use of MaxPower/bMaxPower still apply.
+
+2012-09-20: v1.0.13
+* [MAJOR] Fix a typo in the API with struct libusb_config_descriptor where
+  MaxPower was used instead of bMaxPower, as defined in the specs. If your 
+  application was accessing the MaxPower attribute, and you need to maintain
+  compatibility with libusb or older versions, see APPENDIX A below.
+* Fix broken support for the 0.1 -> 1.0 libusb-compat layer
+* Fix unwanted cancellation of pending timeouts as well as major timeout related bugs
+* Fix handling of HID and composite devices on Windows
+* Introduce LIBUSB_API_VERSION macro
+* Add Cypress FX/FX2 firmware upload sample, based on fxload from
+  http://linux-hotplug.sourceforge.net
+* Add libusb0 (libusb-win32) and libusbK driver support on Windows. Note that while
+  the drivers allow it, isochronous transfers are not supported yet in libusb. Also
+  not supported yet is the use of libusb-win32 filter drivers on composite interfaces
+* Add support for the new get_capabilities ioctl on Linux and avoid unnecessary
+  splitting of bulk transfers
+* Improve support for newer Intel and Renesas USB 3.0 controllers on Windows
+* Harmonize the device number for root hubs across platforms
+* Other bug fixes and improvements
+
+2012-06-15: v1.0.12
+* Fix a potential major regression with pthread on Linux
+* Fix missing thread ID from debug log output on cygwin
+* Fix possible crash when using longjmp and MinGW's gcc 4.6
+* Add topology calls: libusb_get_port_number(), libusb_get_parent() & libusb_get_port_path()
+* Add toggleable debug, using libusb_set_debug() or the LIBUSB_DEBUG environment variable
+* Define log levels in libusb.h and set timestamp origin to first libusb_init() call
+* All logging is now sent to to stderr (info was sent to stdout previously)
+* Update log messages severity and avoid polluting log output on OS-X
+* Add HID driver support on Windows
+* Enable interchangeability of MSVC and MinGW DLLs
+* Additional bug fixes and improvements
+
+2012-05-08: v1.0.11
+* Revert removal of critical Windows event handling that was introduced in 1.0.10
+* Fix a possible deadlock in Windows when submitting transfers
+* Add timestamped logging
+* Add NetBSD support (experimental) and BSD libusb_get_device_speed() data
+* Add bootstrap.sh alongside autogen.sh (bootstrap.sh doesn't invoke configure)
+* Search for device nodes in /dev for Android support
+* Other bug fixes
+
+2012-04-17: v1.0.10
+* Public release
+* Add libusb_get_version
+* Add Visual Studio 2010 project files
+* Some Windows code cleanup
+* Fix xusb sample warnings 
+
+2012-04-02: v1.0.9
+* First libusbx release
+* Add libusb_get_device_speed (all, except BSD) and libusb_error_name
+* Add Windows support (WinUSB driver only)
+* Add OpenBSD support
+* Add xusb sample
+* Tons of bug fixes
+
+2010-05-07: v1.0.8
+* Bug fixes
+
+2010-04-19: v1.0.7
+* Bug fixes and documentation tweaks
+* Add more interface class definitions
+
+2009-11-22: v1.0.6
+* Bug fixes
+* Increase libusb_handle_events() timeout to 60s for powersaving
+
+2009-11-15: v1.0.5
+ * Use timerfd when available for timer management
+ * Small fixes/updates
+
+2009-11-06: v1.0.4 release
+ * Bug fixes including transfer locking to fix some potential threading races
+ * More flexibility with clock types on Linux
+ * Use new bulk continuation tracking in Linux 2.6.32 for improved handling
+   of short/failed transfers
+
+2009-08-27: v1.0.3 release
+ * Bug fixes
+ * Add libusb_get_max_iso_packet_size()
+
+2009-06-13: v1.0.2 release
+ * Bug fixes
+
+2009-05-12: v1.0.1 release
+ * Bug fixes
+ * Darwin backend
+
+2008-12-13: v1.0.0 release
+ * Bug fixes
+
+2008-11-21: v0.9.4 release
+ * Bug fixes
+ * Add libusb_attach_kernel_driver()
+
+2008-08-23: v0.9.3 release
+ * Bug fixes
+
+2008-07-19: v0.9.2 release
+ * Bug fixes
+
+2008-06-28: v0.9.1 release
+ * Bug fixes
+ * Introduce contexts to the API
+ * Compatibility with new Linux kernel features
+
+2008-05-25: v0.9.0 release
+ * First libusb-1.0 beta release
+
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+APPENDIX A - How to maintain code compatibility with versions of libusb and
+libusb that use MaxPower:
+
+If you must to maintain compatibility with versions of the library that aren't
+using the bMaxPower attribute in struct libusb_config_descriptor, the 
+recommended way is to use the new LIBUSB_API_VERSION macro with an #ifdef.
+For instance, if your code was written as follows:
+
+  if (dev->config[0].MaxPower < 250)
+
+Then you should modify it to have:
+
+#if defined(LIBUSB_API_VERSION) && (LIBUSB_API_VERSION >= 0x01000100)
+  if (dev->config[0].bMaxPower < 250)
+#else
+  if (dev->config[0].MaxPower < 250)
+#endif
diff --git a/3rdparty/libusb/src/INSTALL_WIN.txt b/3rdparty/libusb/src/INSTALL_WIN.txt
new file mode 100644
index 00000000..802e29a4
--- /dev/null
+++ b/3rdparty/libusb/src/INSTALL_WIN.txt
@@ -0,0 +1,52 @@
+Installation Instructions for Windows
+*************************************
+
+If you are compiling for MinGW or cygwin, please refer to the INSTALL file,
+which is automatically generated by autotools (e.g. running bootstrap.sh).
+
+If you are using Microsoft Visual Studio:
+- Using Visual Studio 2022, open /msvc/libusb.sln
+- If you want to debug the library, uncomment the ENABLE_DEBUG_LOGGING define
+  in msvc/config.h
+- Select your configuration and compile the project.
+- To target a specific toolset (previous version of Visual Studio), either
+  edit PlatformToolset in /msvc/Configuration.Base.props, or supply the value
+  to msbuild on the command line.
+- For example, to build for VS2015 (from a different version):
+  msbuild -p:PlatformToolset=v140,Platform=x64,Configuration=Release libusb.sln
+
+Installing and building libusb via vcpkg
+****************************************
+
+You can download and install libusb using the vcpkg dependency manager:
+
+    git clone https://github.com/Microsoft/vcpkg.git
+    cd vcpkg
+    ./bootstrap-vcpkg.bat
+    ./vcpkg integrate install
+    vcpkg install libusb
+
+The libusb 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.
+
+Destination directories
+***********************
+
+The binaries are located at:
+/build/<PlatformToolset>/<Platform>/<Configuration>/(lib|dll)/libusb-1.0.(lib|dll)
+For example: /build/v143/x64/Release/dll/libusb-1.0.dll
+
+Troubleshooting
+***************
+
+If the compilation process complains about missing libraries, ensure that the
+default library paths for your project points to the relevant directories.
+If needed, these libraries can be obtained by installing the latest Windows
+SDK.
+
+Links
+*****
+
+Additional information related to the Windows backend:
+  http://windows.libusb.info
diff --git a/3rdparty/libusb/src/Makefile.am b/3rdparty/libusb/src/Makefile.am
new file mode 100644
index 00000000..09d7cf52
--- /dev/null
+++ b/3rdparty/libusb/src/Makefile.am
@@ -0,0 +1,50 @@
+AUTOMAKE_OPTIONS = dist-bzip2 no-dist-gzip
+ACLOCAL_AMFLAGS = -I m4
+EXTRA_DIST = INSTALL_WIN.txt PORTING doc/libusb.png \
+	     android msvc Xcode
+SUBDIRS = libusb
+
+if BUILD_EXAMPLES
+SUBDIRS += examples
+endif
+
+if BUILD_TESTS
+SUBDIRS += tests
+endif
+
+pkgconfigdir = $(libdir)/pkgconfig
+pkgconfig_DATA = libusb-1.0.pc
+
+# The package name is libusb-1.0, but we want the distribution
+# to be created as libusb-x.y.z instead of libusb-1.0-x.y.z
+distdir = libusb-$(VERSION)
+
+# Ensure any generated docs are cleaned out
+# We need this here because make does not recurse into doc/
+clean-local:
+	rm -rf doc/$(DOXYGEN_HTMLDIR)
+
+# Use dist-hook to accomplish the following things for the dist recipe:
+#   1) Remove the GitHub Markdown from the README file
+#   2) Remove the .gitattributes file from the msvc directory
+dist-hook:
+	chmod u+w $(distdir)/README $(distdir)/msvc
+	$(SED) -i.orig -e '/Build Status/d' $(distdir)/README
+	$(SED) -i.orig -e '/^$$/N;/^\n$$/D' $(distdir)/README
+	$(SED) -i.orig -e 's/\[\([A-Z]*\)\](\1)/\1/' $(distdir)/README
+	rm -f $(distdir)/README.orig
+	rm -f $(distdir)/msvc/.gitattributes
+
+reldir = .release/$(distdir)
+sfurl = frs.sourceforge.net:/home/frs/project/libusb/libusb-1.0
+.PHONY: dist-upload
+dist-upload: dist
+	rm -rf $(reldir)
+	mkdir -p $(reldir)
+	cp $(distdir).tar.bz2 $(reldir)
+	if [ -z "$$SF_USER" ]; then \
+		rsync -rv $(reldir) $(sfurl); \
+	else \
+		rsync -rv $(reldir) $$SF_USER@$(sfurl); \
+	fi
+	rm -rf $(reldir)
diff --git a/3rdparty/libusb/src/NEWS b/3rdparty/libusb/src/NEWS
new file mode 100644
index 00000000..4fc85af1
--- /dev/null
+++ b/3rdparty/libusb/src/NEWS
@@ -0,0 +1,2 @@
+For the latest libusb news, please refer to the ChangeLog file, or visit:
+http://libusb.info
diff --git a/3rdparty/libusb/src/PORTING b/3rdparty/libusb/src/PORTING
new file mode 100644
index 00000000..fa9ec1e5
--- /dev/null
+++ b/3rdparty/libusb/src/PORTING
@@ -0,0 +1,94 @@
+PORTING LIBUSB TO OTHER PLATFORMS
+
+Introduction
+============
+
+This document is aimed at developers wishing to port libusb to unsupported
+platforms. I believe the libusb API is OS-independent, so by supporting
+multiple operating systems we pave the way for cross-platform USB device
+drivers.
+
+Implementation-wise, the basic idea is that you provide an interface to
+libusb's internal "backend" API, which performs the appropriate operations on
+your target platform.
+
+In terms of USB I/O, your backend provides functionality to submit
+asynchronous transfers (synchronous transfers are implemented in the higher
+layers, based on the async interface). Your backend must also provide
+functionality to cancel those transfers.
+
+Your backend must also provide an event handling function to "reap" ongoing
+transfers and process their results.
+
+The backend must also provide standard functions for other USB operations,
+e.g. setting configuration, obtaining descriptors, etc.
+
+
+File descriptors for I/O polling
+================================
+
+For libusb to work, your event handling function obviously needs to be called
+at various points in time. Your backend must provide a set of file descriptors
+which libusb and its users can pass to poll() or select() to determine when
+it is time to call the event handling function.
+
+On Linux, this is easy: the usbfs kernel interface exposes a file descriptor
+which can be passed to poll(). If something similar is not true for your
+platform, you can emulate this using an internal library thread to reap I/O as
+necessary, and a pipe() with the main library to raise events. The file
+descriptor of the pipe can then be provided to libusb as an event source.
+
+
+Interface semantics and documentation
+=====================================
+
+Documentation of the backend interface can be found in libusbi.h inside the
+usbi_os_backend structure definition.
+
+Your implementations of these functions will need to call various internal
+libusb functions, prefixed with "usbi_". Documentation for these functions
+can be found in the .c files where they are implemented.
+
+You probably want to skim over *all* the documentation before starting your
+implementation. For example, you probably need to allocate and store private
+OS-specific data for device handles, but the documentation for the mechanism
+for doing so is probably not the first thing you will see.
+
+The Linux backend acts as a good example - view it as a reference
+implementation which you should try to match the behaviour of.
+
+
+Getting started
+===============
+
+1. Modify configure.ac to detect your platform appropriately (see the OS_LINUX
+stuff for an example).
+
+2. Implement your backend in the libusb/os/ directory, modifying
+libusb/os/Makefile.am appropriately.
+
+3. Add preprocessor logic to the top of libusb/core.c to statically assign the
+right usbi_backend for your platform.
+
+4. Produce and test your implementation.
+
+5. Send your implementation to libusb-devel mailing list.
+
+
+Implementation difficulties? Questions?
+=======================================
+
+If you encounter difficulties porting libusb to your platform, please raise
+these issues on the libusb-devel mailing list. Where possible and sensible, I
+am interested in solving problems preventing libusb from operating on other
+platforms.
+
+The libusb-devel mailing list is also a good place to ask questions and
+make suggestions about the internal API. Hopefully we can produce some
+better documentation based on your questions and other input.
+
+You are encouraged to get involved in the process; if the library needs
+some infrastructure additions/modifications to better support your platform,
+you are encouraged to make such changes (in cleanly distinct patch
+submissions). Even if you do not make such changes yourself, please do raise
+the issues on the mailing list at the very minimum.
diff --git a/3rdparty/libusb/src/README b/3rdparty/libusb/src/README
new file mode 100644
index 00000000..bf24733c
--- /dev/null
+++ b/3rdparty/libusb/src/README
@@ -0,0 +1,33 @@
+# libusb
+
+[![Build Status](https://travis-ci.org/libusb/libusb.svg?branch=master)](https://travis-ci.org/libusb/libusb)
+[![Build Status](https://ci.appveyor.com/api/projects/status/xvrfam94jii4a6lw?svg=true)](https://ci.appveyor.com/project/LudovicRousseau/libusb)
+[![Coverity Scan Build Status](https://scan.coverity.com/projects/2180/badge.svg)](https://scan.coverity.com/projects/libusb-libusb)
+
+libusb is a library for USB device access from Linux, macOS,
+Windows, OpenBSD/NetBSD, Haiku, Solaris userspace, and WebAssembly
+via WebUSB.
+It is written in C (Haiku backend in C++) and licensed under the GNU
+Lesser General Public License version 2.1 or, at your option, any later
+version (see [COPYING](COPYING)).
+
+libusb is abstracted internally in such a way that it can hopefully
+be ported to other operating systems. Please see the [PORTING](PORTING)
+file for more information.
+
+libusb homepage:
+http://libusb.info/
+
+Developers will wish to consult the API documentation:
+http://api.libusb.info
+
+Use the mailing list for questions, comments, etc:
+http://mailing-list.libusb.info
+
+- Hans de Goede <hdegoede@redhat.com>
+- Xiaofan Chen <xiaofanc@gmail.com>
+- Ludovic Rousseau <ludovic.rousseau@gmail.com>
+- Nathan Hjelm <hjelmn@cs.unm.edu>
+- Chris Dickens <christopher.a.dickens@gmail.com>
+
+(Please use the mailing list rather than mailing developers directly)
diff --git a/3rdparty/libusb/src/README.git b/3rdparty/libusb/src/README.git
new file mode 100644
index 00000000..d67d3749
--- /dev/null
+++ b/3rdparty/libusb/src/README.git
@@ -0,0 +1,41 @@
+Notes related to git compilation:
+--------------------------------
+
+If you retrieved the libusb repository from git and are using a gcc based
+toolchain, be mindful that you should have the autotools installed (autoconf,
+automake) and will need to run either ./autogen.sh or ./bootstrap.sh to produce
+the configure file.
+
+The difference between autogen.sh and bootstrap.sh is that the former invokes
+configure with a default set of options, and will therefore generate a Makefile,
+whereas the latter does not invoke configure at all. If using autogen.sh, note
+that you can also append options, that will be passed as is to configure.
+
+OS X-specific notes:
+-------------------
+
+Starting with Xcode 4.3, neither Xcode.app nor the Xcode 'command line tools'
+includes autotools and so running either autogen.sh or bootstrap.sh will result
+in the message:
+
+libtoolize or glibtoolize was not found! Please install libtool.
+
+To proceed, you must find and install it from somewhere.
+
+Alternatively, you can use the Xcode project at Xcode/libusb.xcodeproj.
+
+Notes related to submitting new developments:
+--------------------------------------------
+
+If you submit a new development to libusb (eg: new backend), that is unlikely
+to fit in a couple of small patches, we would kindly suggest that you create a
+public account on github, if you don't have one already, and then fork a new
+libusb repository under this account from https://github.com/libusb/libusb.
+
+Then you can create a git branch for your work, that we will be able to better
+reference and test.
+
+We also suggest that, if you are planning to bring in a large development, you
+try to involve the libusb community early by letting the mailing list know, as
+you may find that other people might be eager to help you out.
+See http://mailing-list.libusb.info for details on how to join the mailing list.
diff --git a/3rdparty/libusb/src/README.md b/3rdparty/libusb/src/README.md
new file mode 100644
index 00000000..100b9382
--- /dev/null
+++ b/3rdparty/libusb/src/README.md
@@ -0,0 +1 @@
+README
\ No newline at end of file
diff --git a/3rdparty/libusb/src/TODO b/3rdparty/libusb/src/TODO
new file mode 100644
index 00000000..1e13760e
--- /dev/null
+++ b/3rdparty/libusb/src/TODO
@@ -0,0 +1,2 @@
+Please see the libusb roadmap by visiting:
+https://github.com/libusb/libusb/milestones?direction=asc&sort=due_date&state=open
diff --git a/3rdparty/libusb/src/Xcode/common.xcconfig b/3rdparty/libusb/src/Xcode/common.xcconfig
new file mode 100644
index 00000000..54e7fb20
--- /dev/null
+++ b/3rdparty/libusb/src/Xcode/common.xcconfig
@@ -0,0 +1,65 @@
+//
+// libusb Xcode configuration file
+// Copyright © 2012 Pete Batard <pete@akeo.ie>
+// For more information, please visit: <http://libusb.info>
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+
+// Use GNU11 dialect.
+GCC_C_LANGUAGE_STANDARD = gnu11
+
+// Don't search user paths with <> style #includes.
+ALWAYS_SEARCH_USER_PATHS = NO
+
+// Enable weak references for Objective-C
+CLANG_ENABLE_OBJC_WEAK = YES
+
+// Compiler errors.
+GCC_TREAT_IMPLICIT_FUNCTION_DECLARATIONS_AS_ERRORS = YES
+
+// Compiler warnings.
+GCC_WARN_64_TO_32_BIT_CONVERSION = YES
+GCC_WARN_ABOUT_MISSING_FIELD_INITIALIZERS = YES
+GCC_WARN_ABOUT_MISSING_NEWLINE = YES
+GCC_WARN_ABOUT_MISSING_PROTOTYPES = YES
+GCC_WARN_ABOUT_RETURN_TYPE = YES
+GCC_WARN_FOUR_CHARACTER_CONSTANTS = YES
+GCC_WARN_INITIALIZER_NOT_FULLY_BRACKETED = YES
+GCC_WARN_SHADOW = YES
+GCC_WARN_UNINITIALIZED_AUTOS = YES
+GCC_WARN_UNKNOWN_PRAGMAS = YES
+GCC_WARN_UNUSED_FUNCTION = YES
+GCC_WARN_UNUSED_LABEL = YES
+GCC_WARN_UNUSED_PARAMETER = YES
+GCC_WARN_UNUSED_VARIABLE = YES
+CLANG_WARN_ASSIGN_ENUM = YES
+CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES
+CLANG_WARN_BOOL_CONVERSION = YES
+CLANG_WARN_COMMA = YES
+CLANG_WARN_CONSTANT_CONVERSION = YES
+CLANG_WARN_DOCUMENTATION_COMMENTS = YES
+CLANG_WARN_EMPTY_BODY = YES
+CLANG_WARN_ENUM_CONVERSION = YES
+CLANG_WARN_FLOAT_CONVERSION = YES
+CLANG_WARN_INFINITE_RECURSION = YES
+CLANG_WARN_INT_CONVERSION = YES
+CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES
+CLANG_WARN_STRICT_PROTOTYPES = YES
+CLANG_WARN_SUSPICIOUS_IMPLICIT_CONVERSION = YES
+
+// Static analyzer warnings.
+CLANG_ANALYZER_NONNULL = YES
+CLANG_ANALYZER_SECURITY_FLOATLOOPCOUNTER = YES
+CLANG_ANALYZER_SECURITY_INSECUREAPI_RAND = YES
diff --git a/3rdparty/libusb/src/Xcode/debug.xcconfig b/3rdparty/libusb/src/Xcode/debug.xcconfig
new file mode 100644
index 00000000..e910ee8a
--- /dev/null
+++ b/3rdparty/libusb/src/Xcode/debug.xcconfig
@@ -0,0 +1,29 @@
+//
+// libusb Xcode configuration file
+// Copyright © 2012 Pete Batard <pete@akeo.ie>
+// For more information, please visit: <http://libusb.info>
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+
+#include "common.xcconfig"
+
+// Embed debug symbols in binary itself.
+DEBUG_INFORMATION_FORMAT = dwarf
+
+// No optimizations in debug.
+GCC_OPTIMIZATION_LEVEL = 0
+
+// 
+GCC_PREPROCESSOR_DEFINITIONS = $(inherited) DEBUG=1
diff --git a/3rdparty/libusb/src/Xcode/libusb.xcconfig b/3rdparty/libusb/src/Xcode/libusb.xcconfig
new file mode 100644
index 00000000..3840b835
--- /dev/null
+++ b/3rdparty/libusb/src/Xcode/libusb.xcconfig
@@ -0,0 +1,21 @@
+//
+// libusb Xcode configuration file
+// Copyright © 2012 Pete Batard <pete@akeo.ie>
+// For more information, please visit: <http://libusb.info>
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+
+PRODUCT_NAME = libusb-1.0.0
+LD_DYLIB_INSTALL_NAME = @rpath/libusb-1.0.0.Dylib
diff --git a/3rdparty/libusb/src/Xcode/libusb.xcodeproj/project.pbxproj b/3rdparty/libusb/src/Xcode/libusb.xcodeproj/project.pbxproj
new file mode 100644
index 00000000..ab41c3b1
--- /dev/null
+++ b/3rdparty/libusb/src/Xcode/libusb.xcodeproj/project.pbxproj
@@ -0,0 +1,1361 @@
+// !$*UTF8*$!
+{
+	archiveVersion = 1;
+	classes = {
+	};
+	objectVersion = 45;
+	objects = {
+
+/* Begin PBXAggregateTarget section */
+		008FC0321628BC9400BC5BE2 /* all */ = {
+			isa = PBXAggregateTarget;
+			buildConfigurationList = 008FC0331628BC9400BC5BE2 /* Build configuration list for PBXAggregateTarget "all" */;
+			buildPhases = (
+			);
+			dependencies = (
+				008FC0371628BC9A00BC5BE2 /* PBXTargetDependency */,
+				008FC03B1628BC9A00BC5BE2 /* PBXTargetDependency */,
+				008FC03D1628BC9A00BC5BE2 /* PBXTargetDependency */,
+				008FC03F1628BC9A00BC5BE2 /* PBXTargetDependency */,
+				006AD4281C8C5BBC007F8C6A /* PBXTargetDependency */,
+				008FC0411628BC9A00BC5BE2 /* PBXTargetDependency */,
+				20468D8E24329E3800650534 /* PBXTargetDependency */,
+				008A23DE236C8619004854AA /* PBXTargetDependency */,
+				20468D9024329E3F00650534 /* PBXTargetDependency */,
+				008FC0391628BC9A00BC5BE2 /* PBXTargetDependency */,
+			);
+			name = all;
+			productName = all;
+		};
+/* End PBXAggregateTarget section */
+
+/* Begin PBXBuildFile section */
+		006AD4251C8C5AC4007F8C6A /* hotplugtest.c in Sources */ = {isa = PBXBuildFile; fileRef = 006AD4231C8C5AAE007F8C6A /* hotplugtest.c */; };
+		006AD4261C8C5AD9007F8C6A /* libusb-1.0.0.Dylib in Frameworks */ = {isa = PBXBuildFile; fileRef = 008FBF311628B79300BC5BE2 /* libusb-1.0.0.Dylib */; };
+		008A23DA236C85AF004854AA /* stress.c in Sources */ = {isa = PBXBuildFile; fileRef = 008A23C6236C8445004854AA /* stress.c */; };
+		008A23DB236C85AF004854AA /* testlib.c in Sources */ = {isa = PBXBuildFile; fileRef = 008A23CB236C849A004854AA /* testlib.c */; };
+		008FBF861628B7E800BC5BE2 /* core.c in Sources */ = {isa = PBXBuildFile; fileRef = 008FBF541628B7E800BC5BE2 /* core.c */; };
+		008FBF871628B7E800BC5BE2 /* descriptor.c in Sources */ = {isa = PBXBuildFile; fileRef = 008FBF551628B7E800BC5BE2 /* descriptor.c */; };
+		008FBF881628B7E800BC5BE2 /* io.c in Sources */ = {isa = PBXBuildFile; fileRef = 008FBF561628B7E800BC5BE2 /* io.c */; };
+		008FBF891628B7E800BC5BE2 /* libusb.h in Headers */ = {isa = PBXBuildFile; fileRef = 008FBF5A1628B7E800BC5BE2 /* libusb.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		008FBF901628B7E800BC5BE2 /* libusbi.h in Headers */ = {isa = PBXBuildFile; fileRef = 008FBF671628B7E800BC5BE2 /* libusbi.h */; };
+		008FBF921628B7E800BC5BE2 /* darwin_usb.c in Sources */ = {isa = PBXBuildFile; fileRef = 008FBF6C1628B7E800BC5BE2 /* darwin_usb.c */; };
+		008FBF931628B7E800BC5BE2 /* darwin_usb.h in Headers */ = {isa = PBXBuildFile; fileRef = 008FBF6D1628B7E800BC5BE2 /* darwin_usb.h */; };
+		008FBF9A1628B7E800BC5BE2 /* threads_posix.c in Sources */ = {isa = PBXBuildFile; fileRef = 008FBF741628B7E800BC5BE2 /* threads_posix.c */; };
+		008FBF9B1628B7E800BC5BE2 /* threads_posix.h in Headers */ = {isa = PBXBuildFile; fileRef = 008FBF751628B7E800BC5BE2 /* threads_posix.h */; };
+		008FBFA01628B7E800BC5BE2 /* sync.c in Sources */ = {isa = PBXBuildFile; fileRef = 008FBF7A1628B7E800BC5BE2 /* sync.c */; };
+		008FBFA11628B7E800BC5BE2 /* version.h in Headers */ = {isa = PBXBuildFile; fileRef = 008FBF7B1628B7E800BC5BE2 /* version.h */; };
+		008FBFA21628B7E800BC5BE2 /* version_nano.h in Headers */ = {isa = PBXBuildFile; fileRef = 008FBF7C1628B7E800BC5BE2 /* version_nano.h */; };
+		008FBFA51628B84200BC5BE2 /* config.h in Headers */ = {isa = PBXBuildFile; fileRef = 008FBFA41628B84200BC5BE2 /* config.h */; };
+		008FBFA71628B87000BC5BE2 /* CoreFoundation.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 008FBFA61628B87000BC5BE2 /* CoreFoundation.framework */; };
+		008FBFA91628B88000BC5BE2 /* IOKit.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 008FBFA81628B88000BC5BE2 /* IOKit.framework */; };
+		008FBFAB1628B8CB00BC5BE2 /* libobjc.Dylib in Frameworks */ = {isa = PBXBuildFile; fileRef = 008FBFAA1628B8CB00BC5BE2 /* libobjc.Dylib */; };
+		008FBFEF1628BA3500BC5BE2 /* xusb.c in Sources */ = {isa = PBXBuildFile; fileRef = 008FBFED1628BA0E00BC5BE2 /* xusb.c */; };
+		008FBFFF1628BB9600BC5BE2 /* dpfp.c in Sources */ = {isa = PBXBuildFile; fileRef = 008FBFD71628BA0E00BC5BE2 /* dpfp.c */; };
+		008FC01F1628BC1500BC5BE2 /* fxload.c in Sources */ = {isa = PBXBuildFile; fileRef = 008FBFE11628BA0E00BC5BE2 /* fxload.c */; };
+		008FC0211628BC5200BC5BE2 /* ezusb.c in Sources */ = {isa = PBXBuildFile; fileRef = 008FBFDC1628BA0E00BC5BE2 /* ezusb.c */; };
+		008FC0301628BC7400BC5BE2 /* listdevs.c in Sources */ = {isa = PBXBuildFile; fileRef = 008FBFE71628BA0E00BC5BE2 /* listdevs.c */; };
+		1438D77A17A2ED9F00166101 /* hotplug.c in Sources */ = {isa = PBXBuildFile; fileRef = 1438D77817A2ED9F00166101 /* hotplug.c */; };
+		1438D77F17A2F0EA00166101 /* strerror.c in Sources */ = {isa = PBXBuildFile; fileRef = 1438D77E17A2F0EA00166101 /* strerror.c */; };
+		2018D95F24E453BA001589B2 /* events_posix.c in Sources */ = {isa = PBXBuildFile; fileRef = 2018D95E24E453BA001589B2 /* events_posix.c */; };
+		2018D96124E453D0001589B2 /* events_posix.h in Headers */ = {isa = PBXBuildFile; fileRef = 2018D96024E453D0001589B2 /* events_posix.h */; };
+		20468D70243298C100650534 /* sam3u_benchmark.c in Sources */ = {isa = PBXBuildFile; fileRef = 20468D6E243298C100650534 /* sam3u_benchmark.c */; };
+		20468D7E2432990100650534 /* testlibusb.c in Sources */ = {isa = PBXBuildFile; fileRef = 20468D7C2432990000650534 /* testlibusb.c */; };
+		20951C0325630F5F00ED6351 /* dpfp.c in Sources */ = {isa = PBXBuildFile; fileRef = 008FBFD71628BA0E00BC5BE2 /* dpfp.c */; settings = {COMPILER_FLAGS = "-DDPFP_THREADED"; }; };
+		20951C0625630F8F00ED6351 /* ezusb.h in Headers */ = {isa = PBXBuildFile; fileRef = 008FBFDD1628BA0E00BC5BE2 /* ezusb.h */; };
+		20951C0F25630FD300ED6351 /* libusb_testlib.h in Headers */ = {isa = PBXBuildFile; fileRef = 008A23CA236C849A004854AA /* libusb_testlib.h */; };
+		20951C152563125200ED6351 /* libusb.h in Headers */ = {isa = PBXBuildFile; fileRef = 008FBF5A1628B7E800BC5BE2 /* libusb.h */; };
+		CEA0F5EF26321FAA00ADF3EC /* config.h in Headers */ = {isa = PBXBuildFile; fileRef = 008FBFA41628B84200BC5BE2 /* config.h */; };
+		CEA0F5F026321FAA00ADF3EC /* config.h in Headers */ = {isa = PBXBuildFile; fileRef = 008FBFA41628B84200BC5BE2 /* config.h */; };
+		CEA0F5F126321FAA00ADF3EC /* libusb.h in Headers */ = {isa = PBXBuildFile; fileRef = 008FBF5A1628B7E800BC5BE2 /* libusb.h */; };
+		CEA0F5F226321FAA00ADF3EC /* libusb-1.0.0.Dylib in Frameworks */ = {isa = PBXBuildFile; fileRef = 008FBF311628B79300BC5BE2 /* libusb-1.0.0.Dylib */; };
+		CEA0F5F326321FAA00ADF3EC /* config.h in Headers */ = {isa = PBXBuildFile; fileRef = 008FBFA41628B84200BC5BE2 /* config.h */; };
+		CEA0F5F426321FAA00ADF3EC /* libusb.h in Headers */ = {isa = PBXBuildFile; fileRef = 008FBF5A1628B7E800BC5BE2 /* libusb.h */; };
+		CEA0F5F526321FAA00ADF3EC /* libusb-1.0.0.Dylib in Frameworks */ = {isa = PBXBuildFile; fileRef = 008FBF311628B79300BC5BE2 /* libusb-1.0.0.Dylib */; };
+		CEA0F5F626321FAA00ADF3EC /* config.h in Headers */ = {isa = PBXBuildFile; fileRef = 008FBFA41628B84200BC5BE2 /* config.h */; };
+		CEA0F5F726321FAA00ADF3EC /* libusb.h in Headers */ = {isa = PBXBuildFile; fileRef = 008FBF5A1628B7E800BC5BE2 /* libusb.h */; };
+		CEA0F5F826321FAA00ADF3EC /* libusb-1.0.0.Dylib in Frameworks */ = {isa = PBXBuildFile; fileRef = 008FBF311628B79300BC5BE2 /* libusb-1.0.0.Dylib */; };
+		CEA0F5F926321FAA00ADF3EC /* config.h in Headers */ = {isa = PBXBuildFile; fileRef = 008FBFA41628B84200BC5BE2 /* config.h */; };
+		CEA0F5FA26321FAA00ADF3EC /* libusb.h in Headers */ = {isa = PBXBuildFile; fileRef = 008FBF5A1628B7E800BC5BE2 /* libusb.h */; };
+		CEA0F5FB26321FAA00ADF3EC /* libusb-1.0.0.Dylib in Frameworks */ = {isa = PBXBuildFile; fileRef = 008FBF311628B79300BC5BE2 /* libusb-1.0.0.Dylib */; };
+		CEA0F5FC26321FAA00ADF3EC /* config.h in Headers */ = {isa = PBXBuildFile; fileRef = 008FBFA41628B84200BC5BE2 /* config.h */; };
+		CEA0F5FD26321FAA00ADF3EC /* libusb.h in Headers */ = {isa = PBXBuildFile; fileRef = 008FBF5A1628B7E800BC5BE2 /* libusb.h */; };
+		CEA0F5FE26321FAA00ADF3EC /* libusb-1.0.0.Dylib in Frameworks */ = {isa = PBXBuildFile; fileRef = 008FBF311628B79300BC5BE2 /* libusb-1.0.0.Dylib */; };
+		CEA0F5FF26321FAA00ADF3EC /* config.h in Headers */ = {isa = PBXBuildFile; fileRef = 008FBFA41628B84200BC5BE2 /* config.h */; };
+		CEA0F60026321FAA00ADF3EC /* libusb.h in Headers */ = {isa = PBXBuildFile; fileRef = 008FBF5A1628B7E800BC5BE2 /* libusb.h */; };
+		CEA0F60126321FAA00ADF3EC /* libusb-1.0.0.Dylib in Frameworks */ = {isa = PBXBuildFile; fileRef = 008FBF311628B79300BC5BE2 /* libusb-1.0.0.Dylib */; };
+		CEA0F60226321FAA00ADF3EC /* config.h in Headers */ = {isa = PBXBuildFile; fileRef = 008FBFA41628B84200BC5BE2 /* config.h */; };
+		CEA0F60326321FAA00ADF3EC /* libusb.h in Headers */ = {isa = PBXBuildFile; fileRef = 008FBF5A1628B7E800BC5BE2 /* libusb.h */; };
+		CEA0F60426321FAA00ADF3EC /* libusb-1.0.0.Dylib in Frameworks */ = {isa = PBXBuildFile; fileRef = 008FBF311628B79300BC5BE2 /* libusb-1.0.0.Dylib */; };
+		CEA0F60526321FAA00ADF3EC /* config.h in Headers */ = {isa = PBXBuildFile; fileRef = 008FBFA41628B84200BC5BE2 /* config.h */; };
+		CEA0F60626321FAA00ADF3EC /* libusb.h in Headers */ = {isa = PBXBuildFile; fileRef = 008FBF5A1628B7E800BC5BE2 /* libusb.h */; };
+		CEA0F60726321FAA00ADF3EC /* libusb-1.0.0.Dylib in Frameworks */ = {isa = PBXBuildFile; fileRef = 008FBF311628B79300BC5BE2 /* libusb-1.0.0.Dylib */; };
+		CEA45DFB2634CDFA002FA97D /* Security.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = CEDCEA6E2632200A00F7AA49 /* Security.framework */; };
+/* End PBXBuildFile section */
+
+/* Begin PBXContainerItemProxy section */
+		006AD4271C8C5BBC007F8C6A /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 008FBF281628B79300BC5BE2 /* Project object */;
+			proxyType = 1;
+			remoteGlobalIDString = 006AD41B1C8C5A90007F8C6A;
+			remoteInfo = hotplugtest;
+		};
+		008A23DD236C8619004854AA /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 008FBF281628B79300BC5BE2 /* Project object */;
+			proxyType = 1;
+			remoteGlobalIDString = 008A23D2236C8594004854AA;
+			remoteInfo = stress;
+		};
+		008FC0361628BC9A00BC5BE2 /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 008FBF281628B79300BC5BE2 /* Project object */;
+			proxyType = 1;
+			remoteGlobalIDString = 008FBF301628B79300BC5BE2;
+			remoteInfo = libusb;
+		};
+		008FC0381628BC9A00BC5BE2 /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 008FBF281628B79300BC5BE2 /* Project object */;
+			proxyType = 1;
+			remoteGlobalIDString = 008FBFBC1628B9FE00BC5BE2;
+			remoteInfo = xusb;
+		};
+		008FC03A1628BC9A00BC5BE2 /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 008FBF281628B79300BC5BE2 /* Project object */;
+			proxyType = 1;
+			remoteGlobalIDString = 008FBFF41628BB8B00BC5BE2;
+			remoteInfo = dpfp;
+		};
+		008FC03C1628BC9A00BC5BE2 /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 008FBF281628B79300BC5BE2 /* Project object */;
+			proxyType = 1;
+			remoteGlobalIDString = 008FC0041628BBDB00BC5BE2;
+			remoteInfo = dpfp_threaded;
+		};
+		008FC03E1628BC9A00BC5BE2 /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 008FBF281628B79300BC5BE2 /* Project object */;
+			proxyType = 1;
+			remoteGlobalIDString = 008FC0141628BC0300BC5BE2;
+			remoteInfo = fxload;
+		};
+		008FC0401628BC9A00BC5BE2 /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 008FBF281628B79300BC5BE2 /* Project object */;
+			proxyType = 1;
+			remoteGlobalIDString = 008FC0251628BC6B00BC5BE2;
+			remoteInfo = listdevs;
+		};
+		1443EE8B1641926D007E0579 /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 008FBF281628B79300BC5BE2 /* Project object */;
+			proxyType = 1;
+			remoteGlobalIDString = 008FBF301628B79300BC5BE2;
+			remoteInfo = libusb;
+		};
+		1443EE8D16419273007E0579 /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 008FBF281628B79300BC5BE2 /* Project object */;
+			proxyType = 1;
+			remoteGlobalIDString = 008FBF301628B79300BC5BE2;
+			remoteInfo = libusb;
+		};
+		1443EE8F16419276007E0579 /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 008FBF281628B79300BC5BE2 /* Project object */;
+			proxyType = 1;
+			remoteGlobalIDString = 008FBF301628B79300BC5BE2;
+			remoteInfo = libusb;
+		};
+		1443EE911641927A007E0579 /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 008FBF281628B79300BC5BE2 /* Project object */;
+			proxyType = 1;
+			remoteGlobalIDString = 008FBF301628B79300BC5BE2;
+			remoteInfo = libusb;
+		};
+		1443EE931641927D007E0579 /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 008FBF281628B79300BC5BE2 /* Project object */;
+			proxyType = 1;
+			remoteGlobalIDString = 008FBF301628B79300BC5BE2;
+			remoteInfo = libusb;
+		};
+		20468D812432999C00650534 /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 008FBF281628B79300BC5BE2 /* Project object */;
+			proxyType = 1;
+			remoteGlobalIDString = 008FBF301628B79300BC5BE2;
+			remoteInfo = libusb;
+		};
+		20468D83243299A900650534 /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 008FBF281628B79300BC5BE2 /* Project object */;
+			proxyType = 1;
+			remoteGlobalIDString = 008FBF301628B79300BC5BE2;
+			remoteInfo = libusb;
+		};
+		20468D85243299B200650534 /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 008FBF281628B79300BC5BE2 /* Project object */;
+			proxyType = 1;
+			remoteGlobalIDString = 008FBF301628B79300BC5BE2;
+			remoteInfo = libusb;
+		};
+		20468D87243299BA00650534 /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 008FBF281628B79300BC5BE2 /* Project object */;
+			proxyType = 1;
+			remoteGlobalIDString = 008FBF301628B79300BC5BE2;
+			remoteInfo = libusb;
+		};
+		20468D8D24329E3800650534 /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 008FBF281628B79300BC5BE2 /* Project object */;
+			proxyType = 1;
+			remoteGlobalIDString = 20468D66243298AE00650534;
+			remoteInfo = sam3u_benchmark;
+		};
+		20468D8F24329E3F00650534 /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 008FBF281628B79300BC5BE2 /* Project object */;
+			proxyType = 1;
+			remoteGlobalIDString = 20468D74243298D300650534;
+			remoteInfo = testlibusb;
+		};
+/* End PBXContainerItemProxy section */
+
+/* Begin PBXFileReference section */
+		006AD41C1C8C5A90007F8C6A /* hotplugtest */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = hotplugtest; sourceTree = BUILT_PRODUCTS_DIR; };
+		006AD4231C8C5AAE007F8C6A /* hotplugtest.c */ = {isa = PBXFileReference; fileEncoding = 4; indentWidth = 4; lastKnownFileType = sourcecode.c.c; path = hotplugtest.c; sourceTree = "<group>"; tabWidth = 4; usesTabs = 1; };
+		008A23C6236C8445004854AA /* stress.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = stress.c; sourceTree = "<group>"; usesTabs = 1; };
+		008A23CA236C849A004854AA /* libusb_testlib.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = libusb_testlib.h; sourceTree = "<group>"; usesTabs = 1; };
+		008A23CB236C849A004854AA /* testlib.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = testlib.c; sourceTree = "<group>"; usesTabs = 1; };
+		008A23D3236C8594004854AA /* stress */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = stress; sourceTree = BUILT_PRODUCTS_DIR; };
+		008FBF311628B79300BC5BE2 /* libusb-1.0.0.Dylib */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.Dylib"; includeInIndex = 0; path = "libusb-1.0.0.Dylib"; sourceTree = BUILT_PRODUCTS_DIR; };
+		008FBF541628B7E800BC5BE2 /* core.c */ = {isa = PBXFileReference; fileEncoding = 4; indentWidth = 4; lastKnownFileType = sourcecode.c.c; path = core.c; sourceTree = "<group>"; tabWidth = 4; usesTabs = 1; };
+		008FBF551628B7E800BC5BE2 /* descriptor.c */ = {isa = PBXFileReference; fileEncoding = 4; indentWidth = 4; lastKnownFileType = sourcecode.c.c; path = descriptor.c; sourceTree = "<group>"; tabWidth = 4; usesTabs = 1; };
+		008FBF561628B7E800BC5BE2 /* io.c */ = {isa = PBXFileReference; fileEncoding = 4; indentWidth = 4; lastKnownFileType = sourcecode.c.c; path = io.c; sourceTree = "<group>"; tabWidth = 4; usesTabs = 1; };
+		008FBF5A1628B7E800BC5BE2 /* libusb.h */ = {isa = PBXFileReference; fileEncoding = 4; indentWidth = 4; lastKnownFileType = sourcecode.c.h; path = libusb.h; sourceTree = "<group>"; tabWidth = 4; usesTabs = 1; };
+		008FBF671628B7E800BC5BE2 /* libusbi.h */ = {isa = PBXFileReference; fileEncoding = 4; indentWidth = 4; lastKnownFileType = sourcecode.c.h; path = libusbi.h; sourceTree = "<group>"; tabWidth = 4; usesTabs = 1; };
+		008FBF6C1628B7E800BC5BE2 /* darwin_usb.c */ = {isa = PBXFileReference; fileEncoding = 4; indentWidth = 2; lastKnownFileType = sourcecode.c.c; path = darwin_usb.c; sourceTree = "<group>"; tabWidth = 2; usesTabs = 0; };
+		008FBF6D1628B7E800BC5BE2 /* darwin_usb.h */ = {isa = PBXFileReference; fileEncoding = 4; indentWidth = 2; lastKnownFileType = sourcecode.c.h; path = darwin_usb.h; sourceTree = "<group>"; tabWidth = 2; usesTabs = 0; };
+		008FBF741628B7E800BC5BE2 /* threads_posix.c */ = {isa = PBXFileReference; fileEncoding = 4; indentWidth = 4; lastKnownFileType = sourcecode.c.c; path = threads_posix.c; sourceTree = "<group>"; tabWidth = 4; usesTabs = 1; };
+		008FBF751628B7E800BC5BE2 /* threads_posix.h */ = {isa = PBXFileReference; fileEncoding = 4; indentWidth = 4; lastKnownFileType = sourcecode.c.h; path = threads_posix.h; sourceTree = "<group>"; tabWidth = 4; usesTabs = 1; };
+		008FBF7A1628B7E800BC5BE2 /* sync.c */ = {isa = PBXFileReference; fileEncoding = 4; indentWidth = 4; lastKnownFileType = sourcecode.c.c; path = sync.c; sourceTree = "<group>"; tabWidth = 4; usesTabs = 1; };
+		008FBF7B1628B7E800BC5BE2 /* version.h */ = {isa = PBXFileReference; fileEncoding = 4; indentWidth = 4; lastKnownFileType = sourcecode.c.h; path = version.h; sourceTree = "<group>"; tabWidth = 4; usesTabs = 1; };
+		008FBF7C1628B7E800BC5BE2 /* version_nano.h */ = {isa = PBXFileReference; fileEncoding = 4; indentWidth = 4; lastKnownFileType = sourcecode.c.h; path = version_nano.h; sourceTree = "<group>"; tabWidth = 4; usesTabs = 1; };
+		008FBFA41628B84200BC5BE2 /* config.h */ = {isa = PBXFileReference; fileEncoding = 4; indentWidth = 4; lastKnownFileType = sourcecode.c.h; path = config.h; sourceTree = "<group>"; tabWidth = 4; usesTabs = 1; };
+		008FBFA61628B87000BC5BE2 /* CoreFoundation.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = CoreFoundation.framework; path = System/Library/Frameworks/CoreFoundation.framework; sourceTree = SDKROOT; };
+		008FBFA81628B88000BC5BE2 /* IOKit.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = IOKit.framework; path = System/Library/Frameworks/IOKit.framework; sourceTree = SDKROOT; };
+		008FBFAA1628B8CB00BC5BE2 /* libobjc.Dylib */ = {isa = PBXFileReference; lastKnownFileType = "compiled.mach-o.Dylib"; name = libobjc.Dylib; path = usr/lib/libobjc.Dylib; sourceTree = SDKROOT; };
+		008FBFBD1628B9FE00BC5BE2 /* xusb */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = xusb; sourceTree = BUILT_PRODUCTS_DIR; };
+		008FBFD71628BA0E00BC5BE2 /* dpfp.c */ = {isa = PBXFileReference; fileEncoding = 4; indentWidth = 4; lastKnownFileType = sourcecode.c.c; path = dpfp.c; sourceTree = "<group>"; tabWidth = 4; usesTabs = 1; };
+		008FBFDC1628BA0E00BC5BE2 /* ezusb.c */ = {isa = PBXFileReference; fileEncoding = 4; indentWidth = 4; lastKnownFileType = sourcecode.c.c; path = ezusb.c; sourceTree = "<group>"; tabWidth = 4; usesTabs = 1; };
+		008FBFDD1628BA0E00BC5BE2 /* ezusb.h */ = {isa = PBXFileReference; fileEncoding = 4; indentWidth = 4; lastKnownFileType = sourcecode.c.h; path = ezusb.h; sourceTree = "<group>"; tabWidth = 4; usesTabs = 1; };
+		008FBFE11628BA0E00BC5BE2 /* fxload.c */ = {isa = PBXFileReference; fileEncoding = 4; indentWidth = 4; lastKnownFileType = sourcecode.c.c; path = fxload.c; sourceTree = "<group>"; tabWidth = 4; usesTabs = 1; };
+		008FBFE71628BA0E00BC5BE2 /* listdevs.c */ = {isa = PBXFileReference; fileEncoding = 4; indentWidth = 4; lastKnownFileType = sourcecode.c.c; path = listdevs.c; sourceTree = "<group>"; tabWidth = 4; usesTabs = 1; };
+		008FBFED1628BA0E00BC5BE2 /* xusb.c */ = {isa = PBXFileReference; fileEncoding = 4; indentWidth = 4; lastKnownFileType = sourcecode.c.c; path = xusb.c; sourceTree = "<group>"; tabWidth = 4; usesTabs = 1; };
+		008FBFF51628BB8B00BC5BE2 /* dpfp */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = dpfp; sourceTree = BUILT_PRODUCTS_DIR; };
+		008FC0051628BBDB00BC5BE2 /* dpfp_threaded */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = dpfp_threaded; sourceTree = BUILT_PRODUCTS_DIR; };
+		008FC0151628BC0300BC5BE2 /* fxload */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = fxload; sourceTree = BUILT_PRODUCTS_DIR; };
+		008FC0261628BC6B00BC5BE2 /* listdevs */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = listdevs; sourceTree = BUILT_PRODUCTS_DIR; };
+		1438D77817A2ED9F00166101 /* hotplug.c */ = {isa = PBXFileReference; fileEncoding = 4; indentWidth = 4; lastKnownFileType = sourcecode.c.c; path = hotplug.c; sourceTree = "<group>"; tabWidth = 4; usesTabs = 1; };
+		1438D77E17A2F0EA00166101 /* strerror.c */ = {isa = PBXFileReference; fileEncoding = 4; indentWidth = 4; lastKnownFileType = sourcecode.c.c; path = strerror.c; sourceTree = "<group>"; tabWidth = 4; usesTabs = 1; };
+		1443EE8416417E63007E0579 /* common.xcconfig */ = {isa = PBXFileReference; indentWidth = 4; lastKnownFileType = text.xcconfig; path = common.xcconfig; sourceTree = SOURCE_ROOT; tabWidth = 4; usesTabs = 1; };
+		1443EE8516417E63007E0579 /* debug.xcconfig */ = {isa = PBXFileReference; indentWidth = 4; lastKnownFileType = text.xcconfig; path = debug.xcconfig; sourceTree = SOURCE_ROOT; tabWidth = 4; usesTabs = 1; };
+		1443EE8616417E63007E0579 /* libusb_debug.xcconfig */ = {isa = PBXFileReference; indentWidth = 4; lastKnownFileType = text.xcconfig; path = libusb_debug.xcconfig; sourceTree = SOURCE_ROOT; tabWidth = 4; usesTabs = 1; };
+		1443EE8716417E63007E0579 /* libusb.xcconfig */ = {isa = PBXFileReference; indentWidth = 4; lastKnownFileType = text.xcconfig; path = libusb.xcconfig; sourceTree = SOURCE_ROOT; tabWidth = 4; usesTabs = 1; };
+		1443EE8816417E63007E0579 /* release.xcconfig */ = {isa = PBXFileReference; indentWidth = 4; lastKnownFileType = text.xcconfig; path = release.xcconfig; sourceTree = SOURCE_ROOT; tabWidth = 4; usesTabs = 1; };
+		1443EE8916417EA6007E0579 /* libusb_release.xcconfig */ = {isa = PBXFileReference; indentWidth = 4; lastKnownFileType = text.xcconfig; path = libusb_release.xcconfig; sourceTree = SOURCE_ROOT; tabWidth = 4; usesTabs = 1; };
+		2018D95E24E453BA001589B2 /* events_posix.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = events_posix.c; sourceTree = "<group>"; };
+		2018D96024E453D0001589B2 /* events_posix.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = events_posix.h; sourceTree = "<group>"; };
+		20468D67243298AE00650534 /* sam3u_benchmark */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = sam3u_benchmark; sourceTree = BUILT_PRODUCTS_DIR; };
+		20468D6E243298C100650534 /* sam3u_benchmark.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = sam3u_benchmark.c; sourceTree = "<group>"; usesTabs = 1; };
+		20468D75243298D300650534 /* testlibusb */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = testlibusb; sourceTree = BUILT_PRODUCTS_DIR; };
+		20468D7C2432990000650534 /* testlibusb.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = testlibusb.c; sourceTree = "<group>"; usesTabs = 1; };
+		CEDCEA6E2632200A00F7AA49 /* Security.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = Security.framework; path = System/Library/Frameworks/Security.framework; sourceTree = SDKROOT; };
+/* End PBXFileReference section */
+
+/* Begin PBXFrameworksBuildPhase section */
+		006AD4191C8C5A90007F8C6A /* Frameworks */ = {
+			isa = PBXFrameworksBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				CEA0F5F826321FAA00ADF3EC /* libusb-1.0.0.Dylib in Frameworks */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		008A23D0236C8594004854AA /* Frameworks */ = {
+			isa = PBXFrameworksBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				CEA0F60126321FAA00ADF3EC /* libusb-1.0.0.Dylib in Frameworks */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		008FBF2E1628B79300BC5BE2 /* Frameworks */ = {
+			isa = PBXFrameworksBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				008FBFAB1628B8CB00BC5BE2 /* libobjc.Dylib in Frameworks */,
+				008FBFA91628B88000BC5BE2 /* IOKit.framework in Frameworks */,
+				CEA45DFB2634CDFA002FA97D /* Security.framework in Frameworks */,
+				008FBFA71628B87000BC5BE2 /* CoreFoundation.framework in Frameworks */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		008FBFBA1628B9FE00BC5BE2 /* Frameworks */ = {
+			isa = PBXFrameworksBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				CEA0F60726321FAA00ADF3EC /* libusb-1.0.0.Dylib in Frameworks */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		008FBFF21628BB8B00BC5BE2 /* Frameworks */ = {
+			isa = PBXFrameworksBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				006AD4261C8C5AD9007F8C6A /* libusb-1.0.0.Dylib in Frameworks */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		008FC0021628BBDB00BC5BE2 /* Frameworks */ = {
+			isa = PBXFrameworksBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				CEA0F5F226321FAA00ADF3EC /* libusb-1.0.0.Dylib in Frameworks */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		008FC0121628BC0300BC5BE2 /* Frameworks */ = {
+			isa = PBXFrameworksBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				CEA0F5F526321FAA00ADF3EC /* libusb-1.0.0.Dylib in Frameworks */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		008FC0231628BC6B00BC5BE2 /* Frameworks */ = {
+			isa = PBXFrameworksBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				CEA0F5FB26321FAA00ADF3EC /* libusb-1.0.0.Dylib in Frameworks */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		20468D64243298AE00650534 /* Frameworks */ = {
+			isa = PBXFrameworksBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				CEA0F5FE26321FAA00ADF3EC /* libusb-1.0.0.Dylib in Frameworks */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		20468D72243298D300650534 /* Frameworks */ = {
+			isa = PBXFrameworksBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				CEA0F60426321FAA00ADF3EC /* libusb-1.0.0.Dylib in Frameworks */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXFrameworksBuildPhase section */
+
+/* Begin PBXGroup section */
+		001B1F09236C836000F231DC /* tests */ = {
+			isa = PBXGroup;
+			children = (
+				008A23CA236C849A004854AA /* libusb_testlib.h */,
+				008A23C6236C8445004854AA /* stress.c */,
+				008A23CB236C849A004854AA /* testlib.c */,
+			);
+			name = tests;
+			path = ../tests;
+			sourceTree = "<group>";
+		};
+		008FBF261628B79300BC5BE2 = {
+			isa = PBXGroup;
+			children = (
+				1443EE8316417DE3007E0579 /* xcconfig */,
+				008FBFA41628B84200BC5BE2 /* config.h */,
+				008FBF3B1628B7E800BC5BE2 /* libusb */,
+				008FBFC81628BA0E00BC5BE2 /* examples */,
+				001B1F09236C836000F231DC /* tests */,
+				1443EE8A16419057007E0579 /* Apple */,
+				008FBF321628B79300BC5BE2 /* Products */,
+			);
+			sourceTree = "<group>";
+		};
+		008FBF321628B79300BC5BE2 /* Products */ = {
+			isa = PBXGroup;
+			children = (
+				008FBF311628B79300BC5BE2 /* libusb-1.0.0.Dylib */,
+				008FBFF51628BB8B00BC5BE2 /* dpfp */,
+				008FC0051628BBDB00BC5BE2 /* dpfp_threaded */,
+				008FC0151628BC0300BC5BE2 /* fxload */,
+				008FC0261628BC6B00BC5BE2 /* listdevs */,
+				006AD41C1C8C5A90007F8C6A /* hotplugtest */,
+				008A23D3236C8594004854AA /* stress */,
+				20468D67243298AE00650534 /* sam3u_benchmark */,
+				20468D75243298D300650534 /* testlibusb */,
+				008FBFBD1628B9FE00BC5BE2 /* xusb */,
+			);
+			name = Products;
+			sourceTree = "<group>";
+		};
+		008FBF3B1628B7E800BC5BE2 /* libusb */ = {
+			isa = PBXGroup;
+			children = (
+				008FBF541628B7E800BC5BE2 /* core.c */,
+				008FBF551628B7E800BC5BE2 /* descriptor.c */,
+				1438D77817A2ED9F00166101 /* hotplug.c */,
+				008FBF561628B7E800BC5BE2 /* io.c */,
+				008FBF5A1628B7E800BC5BE2 /* libusb.h */,
+				008FBF671628B7E800BC5BE2 /* libusbi.h */,
+				008FBF6B1628B7E800BC5BE2 /* os */,
+				1438D77E17A2F0EA00166101 /* strerror.c */,
+				008FBF7A1628B7E800BC5BE2 /* sync.c */,
+				008FBF7B1628B7E800BC5BE2 /* version.h */,
+				008FBF7C1628B7E800BC5BE2 /* version_nano.h */,
+			);
+			name = libusb;
+			path = ../libusb;
+			sourceTree = "<group>";
+		};
+		008FBF6B1628B7E800BC5BE2 /* os */ = {
+			isa = PBXGroup;
+			children = (
+				008FBF6C1628B7E800BC5BE2 /* darwin_usb.c */,
+				008FBF6D1628B7E800BC5BE2 /* darwin_usb.h */,
+				2018D95E24E453BA001589B2 /* events_posix.c */,
+				2018D96024E453D0001589B2 /* events_posix.h */,
+				008FBF741628B7E800BC5BE2 /* threads_posix.c */,
+				008FBF751628B7E800BC5BE2 /* threads_posix.h */,
+			);
+			path = os;
+			sourceTree = "<group>";
+		};
+		008FBFC81628BA0E00BC5BE2 /* examples */ = {
+			isa = PBXGroup;
+			children = (
+				008FBFD71628BA0E00BC5BE2 /* dpfp.c */,
+				008FBFDC1628BA0E00BC5BE2 /* ezusb.c */,
+				008FBFDD1628BA0E00BC5BE2 /* ezusb.h */,
+				008FBFE11628BA0E00BC5BE2 /* fxload.c */,
+				006AD4231C8C5AAE007F8C6A /* hotplugtest.c */,
+				008FBFE71628BA0E00BC5BE2 /* listdevs.c */,
+				20468D6E243298C100650534 /* sam3u_benchmark.c */,
+				20468D7C2432990000650534 /* testlibusb.c */,
+				008FBFED1628BA0E00BC5BE2 /* xusb.c */,
+			);
+			name = examples;
+			path = ../examples;
+			sourceTree = "<group>";
+		};
+		1443EE8316417DE3007E0579 /* xcconfig */ = {
+			isa = PBXGroup;
+			children = (
+				1443EE8416417E63007E0579 /* common.xcconfig */,
+				1443EE8516417E63007E0579 /* debug.xcconfig */,
+				1443EE8816417E63007E0579 /* release.xcconfig */,
+				1443EE8716417E63007E0579 /* libusb.xcconfig */,
+				1443EE8616417E63007E0579 /* libusb_debug.xcconfig */,
+				1443EE8916417EA6007E0579 /* libusb_release.xcconfig */,
+			);
+			name = xcconfig;
+			path = ../libusb;
+			sourceTree = "<group>";
+		};
+		1443EE8A16419057007E0579 /* Apple */ = {
+			isa = PBXGroup;
+			children = (
+				008FBFAA1628B8CB00BC5BE2 /* libobjc.Dylib */,
+				008FBFA81628B88000BC5BE2 /* IOKit.framework */,
+				008FBFA61628B87000BC5BE2 /* CoreFoundation.framework */,
+				CEDCEA6E2632200A00F7AA49 /* Security.framework */,
+			);
+			name = Apple;
+			path = ../libusb;
+			sourceTree = "<group>";
+		};
+/* End PBXGroup section */
+
+/* Begin PBXHeadersBuildPhase section */
+		008FBF2F1628B79300BC5BE2 /* Headers */ = {
+			isa = PBXHeadersBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				008FBF891628B7E800BC5BE2 /* libusb.h in Headers */,
+				008FBFA51628B84200BC5BE2 /* config.h in Headers */,
+				008FBF931628B7E800BC5BE2 /* darwin_usb.h in Headers */,
+				2018D96124E453D0001589B2 /* events_posix.h in Headers */,
+				008FBF901628B7E800BC5BE2 /* libusbi.h in Headers */,
+				008FBF9B1628B7E800BC5BE2 /* threads_posix.h in Headers */,
+				008FBFA11628B7E800BC5BE2 /* version.h in Headers */,
+				008FBFA21628B7E800BC5BE2 /* version_nano.h in Headers */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		20951BFF25630EBE00ED6351 /* Headers */ = {
+			isa = PBXHeadersBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				CEA0F5EF26321FAA00ADF3EC /* config.h in Headers */,
+				20951C152563125200ED6351 /* libusb.h in Headers */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		20951C0125630F4100ED6351 /* Headers */ = {
+			isa = PBXHeadersBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				CEA0F5F026321FAA00ADF3EC /* config.h in Headers */,
+				CEA0F5F126321FAA00ADF3EC /* libusb.h in Headers */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		20951C0425630F7600ED6351 /* Headers */ = {
+			isa = PBXHeadersBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				CEA0F5F326321FAA00ADF3EC /* config.h in Headers */,
+				20951C0625630F8F00ED6351 /* ezusb.h in Headers */,
+				CEA0F5F426321FAA00ADF3EC /* libusb.h in Headers */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		20951C0725630F9D00ED6351 /* Headers */ = {
+			isa = PBXHeadersBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				CEA0F5F626321FAA00ADF3EC /* config.h in Headers */,
+				CEA0F5F726321FAA00ADF3EC /* libusb.h in Headers */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		20951C0925630FA900ED6351 /* Headers */ = {
+			isa = PBXHeadersBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				CEA0F5F926321FAA00ADF3EC /* config.h in Headers */,
+				CEA0F5FA26321FAA00ADF3EC /* libusb.h in Headers */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		20951C0B25630FB400ED6351 /* Headers */ = {
+			isa = PBXHeadersBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				CEA0F5FC26321FAA00ADF3EC /* config.h in Headers */,
+				CEA0F5FD26321FAA00ADF3EC /* libusb.h in Headers */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		20951C0D25630FC000ED6351 /* Headers */ = {
+			isa = PBXHeadersBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				CEA0F5FF26321FAA00ADF3EC /* config.h in Headers */,
+				20951C0F25630FD300ED6351 /* libusb_testlib.h in Headers */,
+				CEA0F60026321FAA00ADF3EC /* libusb.h in Headers */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		20951C1025630FE300ED6351 /* Headers */ = {
+			isa = PBXHeadersBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				CEA0F60226321FAA00ADF3EC /* config.h in Headers */,
+				CEA0F60326321FAA00ADF3EC /* libusb.h in Headers */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		20951C1225630FEE00ED6351 /* Headers */ = {
+			isa = PBXHeadersBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				CEA0F60526321FAA00ADF3EC /* config.h in Headers */,
+				CEA0F60626321FAA00ADF3EC /* libusb.h in Headers */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXHeadersBuildPhase section */
+
+/* Begin PBXNativeTarget section */
+		006AD41B1C8C5A90007F8C6A /* hotplugtest */ = {
+			isa = PBXNativeTarget;
+			buildConfigurationList = 006AD4221C8C5A90007F8C6A /* Build configuration list for PBXNativeTarget "hotplugtest" */;
+			buildPhases = (
+				20951C0725630F9D00ED6351 /* Headers */,
+				006AD4181C8C5A90007F8C6A /* Sources */,
+				006AD4191C8C5A90007F8C6A /* Frameworks */,
+			);
+			buildRules = (
+			);
+			dependencies = (
+				20468D822432999C00650534 /* PBXTargetDependency */,
+			);
+			name = hotplugtest;
+			productName = hotplugtest;
+			productReference = 006AD41C1C8C5A90007F8C6A /* hotplugtest */;
+			productType = "com.apple.product-type.tool";
+		};
+		008A23D2236C8594004854AA /* stress */ = {
+			isa = PBXNativeTarget;
+			buildConfigurationList = 008A23D7236C8594004854AA /* Build configuration list for PBXNativeTarget "stress" */;
+			buildPhases = (
+				20951C0D25630FC000ED6351 /* Headers */,
+				008A23CF236C8594004854AA /* Sources */,
+				008A23D0236C8594004854AA /* Frameworks */,
+			);
+			buildRules = (
+			);
+			dependencies = (
+				20468D86243299B200650534 /* PBXTargetDependency */,
+			);
+			name = stress;
+			productName = stress;
+			productReference = 008A23D3236C8594004854AA /* stress */;
+			productType = "com.apple.product-type.tool";
+		};
+		008FBF301628B79300BC5BE2 /* libusb */ = {
+			isa = PBXNativeTarget;
+			buildConfigurationList = 008FBF351628B79300BC5BE2 /* Build configuration list for PBXNativeTarget "libusb" */;
+			buildPhases = (
+				008FBF2F1628B79300BC5BE2 /* Headers */,
+				008FBF2D1628B79300BC5BE2 /* Sources */,
+				008FBF2E1628B79300BC5BE2 /* Frameworks */,
+			);
+			buildRules = (
+			);
+			dependencies = (
+			);
+			name = libusb;
+			productName = libusb;
+			productReference = 008FBF311628B79300BC5BE2 /* libusb-1.0.0.Dylib */;
+			productType = "com.apple.product-type.library.dynamic";
+		};
+		008FBFBC1628B9FE00BC5BE2 /* xusb */ = {
+			isa = PBXNativeTarget;
+			buildConfigurationList = 008FBFC61628B9FE00BC5BE2 /* Build configuration list for PBXNativeTarget "xusb" */;
+			buildPhases = (
+				20951C1225630FEE00ED6351 /* Headers */,
+				008FBFB91628B9FE00BC5BE2 /* Sources */,
+				008FBFBA1628B9FE00BC5BE2 /* Frameworks */,
+			);
+			buildRules = (
+			);
+			dependencies = (
+				1443EE941641927D007E0579 /* PBXTargetDependency */,
+			);
+			name = xusb;
+			productName = xusb;
+			productReference = 008FBFBD1628B9FE00BC5BE2 /* xusb */;
+			productType = "com.apple.product-type.tool";
+		};
+		008FBFF41628BB8B00BC5BE2 /* dpfp */ = {
+			isa = PBXNativeTarget;
+			buildConfigurationList = 008FBFFC1628BB8C00BC5BE2 /* Build configuration list for PBXNativeTarget "dpfp" */;
+			buildPhases = (
+				20951BFF25630EBE00ED6351 /* Headers */,
+				008FBFF11628BB8B00BC5BE2 /* Sources */,
+				008FBFF21628BB8B00BC5BE2 /* Frameworks */,
+			);
+			buildRules = (
+			);
+			dependencies = (
+				1443EE921641927A007E0579 /* PBXTargetDependency */,
+			);
+			name = dpfp;
+			productName = dpfp;
+			productReference = 008FBFF51628BB8B00BC5BE2 /* dpfp */;
+			productType = "com.apple.product-type.tool";
+		};
+		008FC0041628BBDB00BC5BE2 /* dpfp_threaded */ = {
+			isa = PBXNativeTarget;
+			buildConfigurationList = 008FC00C1628BBDB00BC5BE2 /* Build configuration list for PBXNativeTarget "dpfp_threaded" */;
+			buildPhases = (
+				20951C0125630F4100ED6351 /* Headers */,
+				008FC0011628BBDB00BC5BE2 /* Sources */,
+				008FC0021628BBDB00BC5BE2 /* Frameworks */,
+			);
+			buildRules = (
+			);
+			dependencies = (
+				1443EE9016419276007E0579 /* PBXTargetDependency */,
+			);
+			name = dpfp_threaded;
+			productName = dpfp_threaded;
+			productReference = 008FC0051628BBDB00BC5BE2 /* dpfp_threaded */;
+			productType = "com.apple.product-type.tool";
+		};
+		008FC0141628BC0300BC5BE2 /* fxload */ = {
+			isa = PBXNativeTarget;
+			buildConfigurationList = 008FC01C1628BC0300BC5BE2 /* Build configuration list for PBXNativeTarget "fxload" */;
+			buildPhases = (
+				20951C0425630F7600ED6351 /* Headers */,
+				008FC0111628BC0300BC5BE2 /* Sources */,
+				008FC0121628BC0300BC5BE2 /* Frameworks */,
+			);
+			buildRules = (
+			);
+			dependencies = (
+				1443EE8E16419273007E0579 /* PBXTargetDependency */,
+			);
+			name = fxload;
+			productName = fxload;
+			productReference = 008FC0151628BC0300BC5BE2 /* fxload */;
+			productType = "com.apple.product-type.tool";
+		};
+		008FC0251628BC6B00BC5BE2 /* listdevs */ = {
+			isa = PBXNativeTarget;
+			buildConfigurationList = 008FC02D1628BC6B00BC5BE2 /* Build configuration list for PBXNativeTarget "listdevs" */;
+			buildPhases = (
+				20951C0925630FA900ED6351 /* Headers */,
+				008FC0221628BC6B00BC5BE2 /* Sources */,
+				008FC0231628BC6B00BC5BE2 /* Frameworks */,
+			);
+			buildRules = (
+			);
+			dependencies = (
+				1443EE8C1641926D007E0579 /* PBXTargetDependency */,
+			);
+			name = listdevs;
+			productName = listdevs;
+			productReference = 008FC0261628BC6B00BC5BE2 /* listdevs */;
+			productType = "com.apple.product-type.tool";
+		};
+		20468D66243298AE00650534 /* sam3u_benchmark */ = {
+			isa = PBXNativeTarget;
+			buildConfigurationList = 20468D6B243298AE00650534 /* Build configuration list for PBXNativeTarget "sam3u_benchmark" */;
+			buildPhases = (
+				20951C0B25630FB400ED6351 /* Headers */,
+				20468D63243298AE00650534 /* Sources */,
+				20468D64243298AE00650534 /* Frameworks */,
+			);
+			buildRules = (
+			);
+			dependencies = (
+				20468D84243299A900650534 /* PBXTargetDependency */,
+			);
+			name = sam3u_benchmark;
+			productName = sam3u_benchmark;
+			productReference = 20468D67243298AE00650534 /* sam3u_benchmark */;
+			productType = "com.apple.product-type.tool";
+		};
+		20468D74243298D300650534 /* testlibusb */ = {
+			isa = PBXNativeTarget;
+			buildConfigurationList = 20468D79243298D300650534 /* Build configuration list for PBXNativeTarget "testlibusb" */;
+			buildPhases = (
+				20951C1025630FE300ED6351 /* Headers */,
+				20468D71243298D300650534 /* Sources */,
+				20468D72243298D300650534 /* Frameworks */,
+			);
+			buildRules = (
+			);
+			dependencies = (
+				20468D88243299BA00650534 /* PBXTargetDependency */,
+			);
+			name = testlibusb;
+			productName = testlibusb;
+			productReference = 20468D75243298D300650534 /* testlibusb */;
+			productType = "com.apple.product-type.tool";
+		};
+/* End PBXNativeTarget section */
+
+/* Begin PBXProject section */
+		008FBF281628B79300BC5BE2 /* Project object */ = {
+			isa = PBXProject;
+			attributes = {
+				LastUpgradeCheck = 1120;
+				ORGANIZATIONNAME = libusb;
+				TargetAttributes = {
+					006AD41B1C8C5A90007F8C6A = {
+						CreatedOnToolsVersion = 7.2.1;
+					};
+					008A23D2236C8594004854AA = {
+						CreatedOnToolsVersion = 11.2;
+					};
+					20468D66243298AE00650534 = {
+						CreatedOnToolsVersion = 10.1;
+					};
+					20468D74243298D300650534 = {
+						CreatedOnToolsVersion = 10.1;
+					};
+				};
+			};
+			buildConfigurationList = 008FBF2B1628B79300BC5BE2 /* Build configuration list for PBXProject "libusb" */;
+			compatibilityVersion = "Xcode 3.1";
+			developmentRegion = en;
+			hasScannedForEncodings = 0;
+			knownRegions = (
+				en,
+				Base,
+			);
+			mainGroup = 008FBF261628B79300BC5BE2;
+			productRefGroup = 008FBF321628B79300BC5BE2 /* Products */;
+			projectDirPath = "";
+			projectRoot = "";
+			targets = (
+				008FBF301628B79300BC5BE2 /* libusb */,
+				008FBFF41628BB8B00BC5BE2 /* dpfp */,
+				008FC0041628BBDB00BC5BE2 /* dpfp_threaded */,
+				008FC0141628BC0300BC5BE2 /* fxload */,
+				006AD41B1C8C5A90007F8C6A /* hotplugtest */,
+				008FC0251628BC6B00BC5BE2 /* listdevs */,
+				20468D66243298AE00650534 /* sam3u_benchmark */,
+				008A23D2236C8594004854AA /* stress */,
+				20468D74243298D300650534 /* testlibusb */,
+				008FBFBC1628B9FE00BC5BE2 /* xusb */,
+				008FC0321628BC9400BC5BE2 /* all */,
+			);
+		};
+/* End PBXProject section */
+
+/* Begin PBXSourcesBuildPhase section */
+		006AD4181C8C5A90007F8C6A /* Sources */ = {
+			isa = PBXSourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				006AD4251C8C5AC4007F8C6A /* hotplugtest.c in Sources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		008A23CF236C8594004854AA /* Sources */ = {
+			isa = PBXSourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				008A23DA236C85AF004854AA /* stress.c in Sources */,
+				008A23DB236C85AF004854AA /* testlib.c in Sources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		008FBF2D1628B79300BC5BE2 /* Sources */ = {
+			isa = PBXSourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				008FBF861628B7E800BC5BE2 /* core.c in Sources */,
+				008FBF921628B7E800BC5BE2 /* darwin_usb.c in Sources */,
+				008FBF871628B7E800BC5BE2 /* descriptor.c in Sources */,
+				2018D95F24E453BA001589B2 /* events_posix.c in Sources */,
+				1438D77A17A2ED9F00166101 /* hotplug.c in Sources */,
+				008FBF881628B7E800BC5BE2 /* io.c in Sources */,
+				1438D77F17A2F0EA00166101 /* strerror.c in Sources */,
+				008FBFA01628B7E800BC5BE2 /* sync.c in Sources */,
+				008FBF9A1628B7E800BC5BE2 /* threads_posix.c in Sources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		008FBFB91628B9FE00BC5BE2 /* Sources */ = {
+			isa = PBXSourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				008FBFEF1628BA3500BC5BE2 /* xusb.c in Sources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		008FBFF11628BB8B00BC5BE2 /* Sources */ = {
+			isa = PBXSourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				008FBFFF1628BB9600BC5BE2 /* dpfp.c in Sources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		008FC0011628BBDB00BC5BE2 /* Sources */ = {
+			isa = PBXSourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				20951C0325630F5F00ED6351 /* dpfp.c in Sources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		008FC0111628BC0300BC5BE2 /* Sources */ = {
+			isa = PBXSourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				008FC0211628BC5200BC5BE2 /* ezusb.c in Sources */,
+				008FC01F1628BC1500BC5BE2 /* fxload.c in Sources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		008FC0221628BC6B00BC5BE2 /* Sources */ = {
+			isa = PBXSourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				008FC0301628BC7400BC5BE2 /* listdevs.c in Sources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		20468D63243298AE00650534 /* Sources */ = {
+			isa = PBXSourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				20468D70243298C100650534 /* sam3u_benchmark.c in Sources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		20468D71243298D300650534 /* Sources */ = {
+			isa = PBXSourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				20468D7E2432990100650534 /* testlibusb.c in Sources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXSourcesBuildPhase section */
+
+/* Begin PBXTargetDependency section */
+		006AD4281C8C5BBC007F8C6A /* PBXTargetDependency */ = {
+			isa = PBXTargetDependency;
+			target = 006AD41B1C8C5A90007F8C6A /* hotplugtest */;
+			targetProxy = 006AD4271C8C5BBC007F8C6A /* PBXContainerItemProxy */;
+		};
+		008A23DE236C8619004854AA /* PBXTargetDependency */ = {
+			isa = PBXTargetDependency;
+			target = 008A23D2236C8594004854AA /* stress */;
+			targetProxy = 008A23DD236C8619004854AA /* PBXContainerItemProxy */;
+		};
+		008FC0371628BC9A00BC5BE2 /* PBXTargetDependency */ = {
+			isa = PBXTargetDependency;
+			target = 008FBF301628B79300BC5BE2 /* libusb */;
+			targetProxy = 008FC0361628BC9A00BC5BE2 /* PBXContainerItemProxy */;
+		};
+		008FC0391628BC9A00BC5BE2 /* PBXTargetDependency */ = {
+			isa = PBXTargetDependency;
+			target = 008FBFBC1628B9FE00BC5BE2 /* xusb */;
+			targetProxy = 008FC0381628BC9A00BC5BE2 /* PBXContainerItemProxy */;
+		};
+		008FC03B1628BC9A00BC5BE2 /* PBXTargetDependency */ = {
+			isa = PBXTargetDependency;
+			target = 008FBFF41628BB8B00BC5BE2 /* dpfp */;
+			targetProxy = 008FC03A1628BC9A00BC5BE2 /* PBXContainerItemProxy */;
+		};
+		008FC03D1628BC9A00BC5BE2 /* PBXTargetDependency */ = {
+			isa = PBXTargetDependency;
+			target = 008FC0041628BBDB00BC5BE2 /* dpfp_threaded */;
+			targetProxy = 008FC03C1628BC9A00BC5BE2 /* PBXContainerItemProxy */;
+		};
+		008FC03F1628BC9A00BC5BE2 /* PBXTargetDependency */ = {
+			isa = PBXTargetDependency;
+			target = 008FC0141628BC0300BC5BE2 /* fxload */;
+			targetProxy = 008FC03E1628BC9A00BC5BE2 /* PBXContainerItemProxy */;
+		};
+		008FC0411628BC9A00BC5BE2 /* PBXTargetDependency */ = {
+			isa = PBXTargetDependency;
+			target = 008FC0251628BC6B00BC5BE2 /* listdevs */;
+			targetProxy = 008FC0401628BC9A00BC5BE2 /* PBXContainerItemProxy */;
+		};
+		1443EE8C1641926D007E0579 /* PBXTargetDependency */ = {
+			isa = PBXTargetDependency;
+			target = 008FBF301628B79300BC5BE2 /* libusb */;
+			targetProxy = 1443EE8B1641926D007E0579 /* PBXContainerItemProxy */;
+		};
+		1443EE8E16419273007E0579 /* PBXTargetDependency */ = {
+			isa = PBXTargetDependency;
+			target = 008FBF301628B79300BC5BE2 /* libusb */;
+			targetProxy = 1443EE8D16419273007E0579 /* PBXContainerItemProxy */;
+		};
+		1443EE9016419276007E0579 /* PBXTargetDependency */ = {
+			isa = PBXTargetDependency;
+			target = 008FBF301628B79300BC5BE2 /* libusb */;
+			targetProxy = 1443EE8F16419276007E0579 /* PBXContainerItemProxy */;
+		};
+		1443EE921641927A007E0579 /* PBXTargetDependency */ = {
+			isa = PBXTargetDependency;
+			target = 008FBF301628B79300BC5BE2 /* libusb */;
+			targetProxy = 1443EE911641927A007E0579 /* PBXContainerItemProxy */;
+		};
+		1443EE941641927D007E0579 /* PBXTargetDependency */ = {
+			isa = PBXTargetDependency;
+			target = 008FBF301628B79300BC5BE2 /* libusb */;
+			targetProxy = 1443EE931641927D007E0579 /* PBXContainerItemProxy */;
+		};
+		20468D822432999C00650534 /* PBXTargetDependency */ = {
+			isa = PBXTargetDependency;
+			target = 008FBF301628B79300BC5BE2 /* libusb */;
+			targetProxy = 20468D812432999C00650534 /* PBXContainerItemProxy */;
+		};
+		20468D84243299A900650534 /* PBXTargetDependency */ = {
+			isa = PBXTargetDependency;
+			target = 008FBF301628B79300BC5BE2 /* libusb */;
+			targetProxy = 20468D83243299A900650534 /* PBXContainerItemProxy */;
+		};
+		20468D86243299B200650534 /* PBXTargetDependency */ = {
+			isa = PBXTargetDependency;
+			target = 008FBF301628B79300BC5BE2 /* libusb */;
+			targetProxy = 20468D85243299B200650534 /* PBXContainerItemProxy */;
+		};
+		20468D88243299BA00650534 /* PBXTargetDependency */ = {
+			isa = PBXTargetDependency;
+			target = 008FBF301628B79300BC5BE2 /* libusb */;
+			targetProxy = 20468D87243299BA00650534 /* PBXContainerItemProxy */;
+		};
+		20468D8E24329E3800650534 /* PBXTargetDependency */ = {
+			isa = PBXTargetDependency;
+			target = 20468D66243298AE00650534 /* sam3u_benchmark */;
+			targetProxy = 20468D8D24329E3800650534 /* PBXContainerItemProxy */;
+		};
+		20468D9024329E3F00650534 /* PBXTargetDependency */ = {
+			isa = PBXTargetDependency;
+			target = 20468D74243298D300650534 /* testlibusb */;
+			targetProxy = 20468D8F24329E3F00650534 /* PBXContainerItemProxy */;
+		};
+/* End PBXTargetDependency section */
+
+/* Begin XCBuildConfiguration section */
+		006AD4201C8C5A90007F8C6A /* Debug */ = {
+			isa = XCBuildConfiguration;
+			baseConfigurationReference = 1443EE8516417E63007E0579 /* debug.xcconfig */;
+			buildSettings = {
+				CODE_SIGN_IDENTITY = "-";
+				PRODUCT_NAME = "$(TARGET_NAME)";
+			};
+			name = Debug;
+		};
+		006AD4211C8C5A90007F8C6A /* Release */ = {
+			isa = XCBuildConfiguration;
+			baseConfigurationReference = 1443EE8816417E63007E0579 /* release.xcconfig */;
+			buildSettings = {
+				CODE_SIGN_IDENTITY = "-";
+				PRODUCT_NAME = "$(TARGET_NAME)";
+			};
+			name = Release;
+		};
+		008A23D8236C8594004854AA /* Debug */ = {
+			isa = XCBuildConfiguration;
+			baseConfigurationReference = 1443EE8516417E63007E0579 /* debug.xcconfig */;
+			buildSettings = {
+				CODE_SIGN_IDENTITY = "-";
+				PRODUCT_NAME = "$(TARGET_NAME)";
+			};
+			name = Debug;
+		};
+		008A23D9236C8594004854AA /* Release */ = {
+			isa = XCBuildConfiguration;
+			baseConfigurationReference = 1443EE8816417E63007E0579 /* release.xcconfig */;
+			buildSettings = {
+				CODE_SIGN_IDENTITY = "-";
+				PRODUCT_NAME = "$(TARGET_NAME)";
+			};
+			name = Release;
+		};
+		008FBF331628B79300BC5BE2 /* Debug */ = {
+			isa = XCBuildConfiguration;
+			baseConfigurationReference = 1443EE8516417E63007E0579 /* debug.xcconfig */;
+			buildSettings = {
+				CLANG_ANALYZER_LOCALIZABILITY_NONLOCALIZED = YES;
+				CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES;
+				CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES;
+				CLANG_WARN_RANGE_LOOP_ANALYSIS = YES;
+				CLANG_WARN_SUSPICIOUS_MOVE = YES;
+				CLANG_WARN_UNREACHABLE_CODE = YES;
+				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
+				ENABLE_STRICT_OBJC_MSGSEND = YES;
+				ENABLE_TESTABILITY = YES;
+				GCC_NO_COMMON_BLOCKS = YES;
+				GCC_WARN_UNDECLARED_SELECTOR = YES;
+				ONLY_ACTIVE_ARCH = YES;
+			};
+			name = Debug;
+		};
+		008FBF341628B79300BC5BE2 /* Release */ = {
+			isa = XCBuildConfiguration;
+			baseConfigurationReference = 1443EE8816417E63007E0579 /* release.xcconfig */;
+			buildSettings = {
+				CLANG_ANALYZER_LOCALIZABILITY_NONLOCALIZED = YES;
+				CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES;
+				CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES;
+				CLANG_WARN_RANGE_LOOP_ANALYSIS = YES;
+				CLANG_WARN_SUSPICIOUS_MOVE = YES;
+				CLANG_WARN_UNREACHABLE_CODE = YES;
+				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
+				ENABLE_STRICT_OBJC_MSGSEND = YES;
+				GCC_NO_COMMON_BLOCKS = YES;
+				GCC_WARN_UNDECLARED_SELECTOR = YES;
+			};
+			name = Release;
+		};
+		008FBF361628B79300BC5BE2 /* Debug */ = {
+			isa = XCBuildConfiguration;
+			baseConfigurationReference = 1443EE8616417E63007E0579 /* libusb_debug.xcconfig */;
+			buildSettings = {
+				OTHER_CFLAGS = (
+					"-fvisibility=hidden",
+					"-pthread",
+				);
+			};
+			name = Debug;
+		};
+		008FBF371628B79300BC5BE2 /* Release */ = {
+			isa = XCBuildConfiguration;
+			baseConfigurationReference = 1443EE8916417EA6007E0579 /* libusb_release.xcconfig */;
+			buildSettings = {
+				OTHER_CFLAGS = (
+					"-fvisibility=hidden",
+					"-pthread",
+				);
+			};
+			name = Release;
+		};
+		008FBFC41628B9FE00BC5BE2 /* Debug */ = {
+			isa = XCBuildConfiguration;
+			baseConfigurationReference = 1443EE8516417E63007E0579 /* debug.xcconfig */;
+			buildSettings = {
+				CODE_SIGN_IDENTITY = "-";
+				PRODUCT_NAME = "$(TARGET_NAME)";
+			};
+			name = Debug;
+		};
+		008FBFC51628B9FE00BC5BE2 /* Release */ = {
+			isa = XCBuildConfiguration;
+			baseConfigurationReference = 1443EE8816417E63007E0579 /* release.xcconfig */;
+			buildSettings = {
+				CODE_SIGN_IDENTITY = "-";
+				PRODUCT_NAME = "$(TARGET_NAME)";
+			};
+			name = Release;
+		};
+		008FBFFD1628BB8C00BC5BE2 /* Debug */ = {
+			isa = XCBuildConfiguration;
+			baseConfigurationReference = 1443EE8516417E63007E0579 /* debug.xcconfig */;
+			buildSettings = {
+				CODE_SIGN_IDENTITY = "-";
+				PRODUCT_NAME = "$(TARGET_NAME)";
+			};
+			name = Debug;
+		};
+		008FBFFE1628BB8C00BC5BE2 /* Release */ = {
+			isa = XCBuildConfiguration;
+			baseConfigurationReference = 1443EE8816417E63007E0579 /* release.xcconfig */;
+			buildSettings = {
+				CODE_SIGN_IDENTITY = "-";
+				PRODUCT_NAME = "$(TARGET_NAME)";
+			};
+			name = Release;
+		};
+		008FC00D1628BBDB00BC5BE2 /* Debug */ = {
+			isa = XCBuildConfiguration;
+			baseConfigurationReference = 1443EE8516417E63007E0579 /* debug.xcconfig */;
+			buildSettings = {
+				CODE_SIGN_IDENTITY = "-";
+				OTHER_CFLAGS = "-pthread";
+				PRODUCT_NAME = "$(TARGET_NAME)";
+			};
+			name = Debug;
+		};
+		008FC00E1628BBDB00BC5BE2 /* Release */ = {
+			isa = XCBuildConfiguration;
+			baseConfigurationReference = 1443EE8816417E63007E0579 /* release.xcconfig */;
+			buildSettings = {
+				CODE_SIGN_IDENTITY = "-";
+				OTHER_CFLAGS = "-pthread";
+				PRODUCT_NAME = "$(TARGET_NAME)";
+			};
+			name = Release;
+		};
+		008FC01D1628BC0300BC5BE2 /* Debug */ = {
+			isa = XCBuildConfiguration;
+			baseConfigurationReference = 1443EE8516417E63007E0579 /* debug.xcconfig */;
+			buildSettings = {
+				CODE_SIGN_IDENTITY = "-";
+				PRODUCT_NAME = "$(TARGET_NAME)";
+			};
+			name = Debug;
+		};
+		008FC01E1628BC0300BC5BE2 /* Release */ = {
+			isa = XCBuildConfiguration;
+			baseConfigurationReference = 1443EE8816417E63007E0579 /* release.xcconfig */;
+			buildSettings = {
+				CODE_SIGN_IDENTITY = "-";
+				PRODUCT_NAME = "$(TARGET_NAME)";
+			};
+			name = Release;
+		};
+		008FC02E1628BC6B00BC5BE2 /* Debug */ = {
+			isa = XCBuildConfiguration;
+			baseConfigurationReference = 1443EE8516417E63007E0579 /* debug.xcconfig */;
+			buildSettings = {
+				CODE_SIGN_IDENTITY = "-";
+				PRODUCT_NAME = "$(TARGET_NAME)";
+			};
+			name = Debug;
+		};
+		008FC02F1628BC6B00BC5BE2 /* Release */ = {
+			isa = XCBuildConfiguration;
+			baseConfigurationReference = 1443EE8816417E63007E0579 /* release.xcconfig */;
+			buildSettings = {
+				CODE_SIGN_IDENTITY = "-";
+				PRODUCT_NAME = "$(TARGET_NAME)";
+			};
+			name = Release;
+		};
+		008FC0341628BC9400BC5BE2 /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+			};
+			name = Debug;
+		};
+		008FC0351628BC9400BC5BE2 /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+			};
+			name = Release;
+		};
+		20468D6C243298AE00650534 /* Debug */ = {
+			isa = XCBuildConfiguration;
+			baseConfigurationReference = 1443EE8516417E63007E0579 /* debug.xcconfig */;
+			buildSettings = {
+				CODE_SIGN_IDENTITY = "-";
+				PRODUCT_NAME = "$(TARGET_NAME)";
+			};
+			name = Debug;
+		};
+		20468D6D243298AE00650534 /* Release */ = {
+			isa = XCBuildConfiguration;
+			baseConfigurationReference = 1443EE8816417E63007E0579 /* release.xcconfig */;
+			buildSettings = {
+				CODE_SIGN_IDENTITY = "-";
+				PRODUCT_NAME = "$(TARGET_NAME)";
+			};
+			name = Release;
+		};
+		20468D7A243298D300650534 /* Debug */ = {
+			isa = XCBuildConfiguration;
+			baseConfigurationReference = 1443EE8516417E63007E0579 /* debug.xcconfig */;
+			buildSettings = {
+				CODE_SIGN_IDENTITY = "-";
+				PRODUCT_NAME = "$(TARGET_NAME)";
+			};
+			name = Debug;
+		};
+		20468D7B243298D300650534 /* Release */ = {
+			isa = XCBuildConfiguration;
+			baseConfigurationReference = 1443EE8816417E63007E0579 /* release.xcconfig */;
+			buildSettings = {
+				CODE_SIGN_IDENTITY = "-";
+				PRODUCT_NAME = "$(TARGET_NAME)";
+			};
+			name = Release;
+		};
+/* End XCBuildConfiguration section */
+
+/* Begin XCConfigurationList section */
+		006AD4221C8C5A90007F8C6A /* Build configuration list for PBXNativeTarget "hotplugtest" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				006AD4201C8C5A90007F8C6A /* Debug */,
+				006AD4211C8C5A90007F8C6A /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+		008A23D7236C8594004854AA /* Build configuration list for PBXNativeTarget "stress" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				008A23D8236C8594004854AA /* Debug */,
+				008A23D9236C8594004854AA /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+		008FBF2B1628B79300BC5BE2 /* Build configuration list for PBXProject "libusb" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				008FBF331628B79300BC5BE2 /* Debug */,
+				008FBF341628B79300BC5BE2 /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+		008FBF351628B79300BC5BE2 /* Build configuration list for PBXNativeTarget "libusb" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				008FBF361628B79300BC5BE2 /* Debug */,
+				008FBF371628B79300BC5BE2 /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+		008FBFC61628B9FE00BC5BE2 /* Build configuration list for PBXNativeTarget "xusb" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				008FBFC41628B9FE00BC5BE2 /* Debug */,
+				008FBFC51628B9FE00BC5BE2 /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+		008FBFFC1628BB8C00BC5BE2 /* Build configuration list for PBXNativeTarget "dpfp" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				008FBFFD1628BB8C00BC5BE2 /* Debug */,
+				008FBFFE1628BB8C00BC5BE2 /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+		008FC00C1628BBDB00BC5BE2 /* Build configuration list for PBXNativeTarget "dpfp_threaded" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				008FC00D1628BBDB00BC5BE2 /* Debug */,
+				008FC00E1628BBDB00BC5BE2 /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+		008FC01C1628BC0300BC5BE2 /* Build configuration list for PBXNativeTarget "fxload" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				008FC01D1628BC0300BC5BE2 /* Debug */,
+				008FC01E1628BC0300BC5BE2 /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+		008FC02D1628BC6B00BC5BE2 /* Build configuration list for PBXNativeTarget "listdevs" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				008FC02E1628BC6B00BC5BE2 /* Debug */,
+				008FC02F1628BC6B00BC5BE2 /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+		008FC0331628BC9400BC5BE2 /* Build configuration list for PBXAggregateTarget "all" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				008FC0341628BC9400BC5BE2 /* Debug */,
+				008FC0351628BC9400BC5BE2 /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+		20468D6B243298AE00650534 /* Build configuration list for PBXNativeTarget "sam3u_benchmark" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				20468D6C243298AE00650534 /* Debug */,
+				20468D6D243298AE00650534 /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+		20468D79243298D300650534 /* Build configuration list for PBXNativeTarget "testlibusb" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				20468D7A243298D300650534 /* Debug */,
+				20468D7B243298D300650534 /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+/* End XCConfigurationList section */
+	};
+	rootObject = 008FBF281628B79300BC5BE2 /* Project object */;
+}
diff --git a/3rdparty/libusb/src/Xcode/libusb/config.h b/3rdparty/libusb/src/Xcode/libusb/config.h
new file mode 100644
index 00000000..5f83b427
--- /dev/null
+++ b/3rdparty/libusb/src/Xcode/libusb/config.h
@@ -0,0 +1,31 @@
+/* config.h.  Manually generated for Xcode.  */
+
+#include <AvailabilityMacros.h>
+
+/* Define to the attribute for default visibility. */
+#define DEFAULT_VISIBILITY __attribute__((visibility("default")))
+
+/* Define to 1 to enable message logging. */
+#define ENABLE_LOGGING 1
+
+/* On 10.6 and later, use newly available pthread_threadid_np() function */
+#if MAC_OS_X_VERSION_MIN_REQUIRED >= 1060
+/* Define to 1 if you have the 'pthread_threadid_np' function. */
+#define HAVE_PTHREAD_THREADID_NP 1
+#endif
+
+/* Define to 1 if the system has the type `nfds_t'. */
+#define HAVE_NFDS_T 1
+
+/* Define to 1 if you have the <sys/time.h> header file. */
+#define HAVE_SYS_TIME_H 1
+
+/* Define to 1 if compiling for a POSIX platform. */
+#define PLATFORM_POSIX 1
+
+/* Define to the attribute for enabling parameter checks on printf-like
+   functions. */
+#define PRINTF_FORMAT(a, b) __attribute__((__format__(__printf__, a, b)))
+
+/* Enable GNU extensions. */
+#define _GNU_SOURCE 1
diff --git a/3rdparty/libusb/src/Xcode/libusb_debug.xcconfig b/3rdparty/libusb/src/Xcode/libusb_debug.xcconfig
new file mode 100644
index 00000000..11bc4c3b
--- /dev/null
+++ b/3rdparty/libusb/src/Xcode/libusb_debug.xcconfig
@@ -0,0 +1,21 @@
+//
+// libusb Xcode configuration file
+// Copyright © 2012 Pete Batard <pete@akeo.ie>
+// For more information, please visit: <http://libusb.info>
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+
+#include "debug.xcconfig"
+#include "libusb.xcconfig"
diff --git a/3rdparty/libusb/src/Xcode/libusb_release.xcconfig b/3rdparty/libusb/src/Xcode/libusb_release.xcconfig
new file mode 100644
index 00000000..3bd47bb2
--- /dev/null
+++ b/3rdparty/libusb/src/Xcode/libusb_release.xcconfig
@@ -0,0 +1,21 @@
+//
+// libusb Xcode configuration file
+// Copyright © 2012 Pete Batard <pete@akeo.ie>
+// For more information, please visit: <http://libusb.info>
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+
+#include "release.xcconfig"
+#include "libusb.xcconfig"
diff --git a/3rdparty/libusb/src/Xcode/release.xcconfig b/3rdparty/libusb/src/Xcode/release.xcconfig
new file mode 100644
index 00000000..ead284a7
--- /dev/null
+++ b/3rdparty/libusb/src/Xcode/release.xcconfig
@@ -0,0 +1,30 @@
+//
+// libusb Xcode configuration file
+// Copyright © 2012 Pete Batard <pete@akeo.ie>
+// For more information, please visit: <http://libusb.info>
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+
+#include "common.xcconfig"
+
+// Put debug symbols in separate .dym file.
+DEBUG_INFORMATION_FORMAT = dwarf-with-dsym
+
+// Optimizations in release.
+GCC_OPTIMIZATION_LEVEL = s
+LLVM_LTO = YES
+
+// Define NDEBUG so asserts go away in release.
+GCC_PREPROCESSOR_DEFINITIONS = $(inherited) NDEBUG=1
diff --git a/3rdparty/libusb/src/android/README b/3rdparty/libusb/src/android/README
new file mode 100644
index 00000000..4af4c3d4
--- /dev/null
+++ b/3rdparty/libusb/src/android/README
@@ -0,0 +1,152 @@
+libusb for Android
+==================
+
+Building:
+---------
+
+To build libusb for Android do the following:
+
+ 1. Download the latest NDK from:
+    http://developer.android.com/tools/sdk/ndk/index.html
+
+ 2. Extract the NDK.
+
+ 3. Open a shell and make sure there exist an NDK global variable
+    set to the directory where you extracted the NDK.
+
+ 4. Change directory to libusb's "android/jni"
+
+ 5. Run "$NDK/ndk-build".
+
+The libusb library, examples and tests can then be found in:
+    "android/libs/$ARCH"
+
+Where $ARCH is one of:
+    armeabi
+    armeabi-v7a
+    mips
+    mips64
+    x86
+    x86_64
+
+Installing:
+-----------
+
+If you wish to use libusb from native code in own Android application
+then you should add the following line to your Android.mk file:
+
+  include $(PATH_TO_LIBUSB_SRC)/android/jni/libusb.mk
+
+You will then need to add the following lines to the build
+configuration for each native binary which uses libusb:
+
+  LOCAL_C_INCLUDES += $(LIBUSB_ROOT_ABS)
+  LOCAL_SHARED_LIBRARIES += libusb1.0
+
+The Android build system will then correctly include libusb in the
+application package (APK) file, provided ndk-build is invoked before
+the package is built.
+
+
+Runtime Permissions:
+--------------------
+
+The Runtime Permissions on Android can be transferred from Java to Native
+over the following approach:
+
+  JAVA:
+
+   --> Obtain USB permissions over the android.hardware.usb.UsbManager class
+
+      usbManager = (UsbManager) getSystemService(Context.USB_SERVICE);
+      HashMap<String, UsbDevice> deviceList = usbManager.getDeviceList();
+      for (UsbDevice usbDevice : deviceList.values()) {
+          usbManager.requestPermission(usbDevice, mPermissionIntent);
+      }
+
+   --> Get the native FileDescriptor of the UsbDevice and transfer it to
+       Native over JNI or JNA
+
+      UsbDeviceConnection usbDeviceConnection = usbManager.openDevice(camDevice);
+      int fileDescriptor = usbDeviceConnection.getFileDescriptor();
+
+   --> JNA sample method:
+
+      JNA.INSTANCE.set_the_native_Descriptor(fileDescriptor);
+
+  NATIVE:
+
+   --> Initialize libusb on Android
+
+      set_the_native_Descriptor(int fileDescriptor) {
+          libusb_context *ctx;
+          libusb_device_handle *devh;
+          libusb_set_option(&ctx, LIBUSB_OPTION_NO_DEVICE_DISCOVERY, NULL);
+          libusb_init(&ctx);
+          libusb_wrap_sys_device(NULL, (intptr_t)fileDescriptor, &devh);
+      }
+      /* From this point you can regularly use all libusb functions as usual */
+
+   About LIBUSB_OPTION_NO_DEVICE_DISCOVERY:
+
+    The method libusb_set_option(&ctx, LIBUSB_OPTION_NO_DEVICE_DISCOVERY, NULL)
+    does not affect the ctx.
+    It allows initializing libusb on unrooted Android devices by skipping
+    the device enumeration.
+
+Rooted Devices:
+---------------
+
+    For rooted devices the code using libusb could be executed as root
+    using the "su" command. An alternative would be to use the "su" command
+    to change the permissions on the appropriate /dev/bus/usb/ files.
+
+    Users have reported success in using android.hardware.usb.UsbManager
+    to request permission to use the UsbDevice and then opening the
+    device. The difficulties in this method is that there is no guarantee
+    that it will continue to work in the future Android versions, it
+    requires invoking Java APIs and running code to match each
+    android.hardware.usb.UsbDevice to a libusb_device.
+
+    For a rooted device it is possible to install libusb into the system
+    image of a running device:
+
+     1. Enable ADB on the device.
+
+     2. Connect the device to a machine running ADB.
+
+     3. Execute the following commands on the machine
+        running ADB:
+
+        # Make the system partition writable
+        adb shell su -c "mount -o remount,rw /system"
+
+        # Install libusb
+        adb push obj/local/armeabi/libusb1.0.so /sdcard/
+        adb shell su -c "cat > /system/lib/libusb1.0.so < /sdcard/libusb1.0.so"
+        adb shell rm /sdcard/libusb1.0.so
+
+        # Install the samples and tests
+        for B in listdevs fxload xusb sam3u_benchmark hotplugtest stress
+        do
+          adb push "obj/local/armeabi/$B" /sdcard/
+          adb shell su -c "cat > /system/bin/$B < /sdcard/$B"
+          adb shell su -c "chmod 0755 /system/bin/$B"
+          adb shell rm "/sdcard/$B"
+        done
+
+        # Make the system partition read only again
+        adb shell su -c "mount -o remount,ro /system"
+
+        # Run listdevs to
+        adb shell su -c "listdevs"
+
+     4. If your device only has a single OTG port then ADB can generally
+        be switched to using Wifi with the following commands when connected
+        via USB:
+
+        adb shell netcfg
+        # Note the wifi IP address of the phone
+        adb tcpip 5555
+        # Use the IP address from netcfg
+        adb connect 192.168.1.123:5555
diff --git a/3rdparty/libusb/src/android/examples/unrooted_android.c b/3rdparty/libusb/src/android/examples/unrooted_android.c
new file mode 100644
index 00000000..840014ce
--- /dev/null
+++ b/3rdparty/libusb/src/android/examples/unrooted_android.c
@@ -0,0 +1,300 @@
+/*
+ *  libusb example program for reading out USB descriptors on unrooted Android
+ *  (based on testlibusb.c)
+ *
+ *  Copyright 2020-2021 Peter Stoiber
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2.1 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ *  Please contact the author if you need another license.
+ *  This Repository is provided "as is", without warranties of any kind.
+ */
+
+/*
+ * This example creates a shared object which can be accessed over JNA or JNI from Java or Kotlin in Android.
+ * Hint: If you are using Android Studio, set the "Debug type" to "Java Only" to receive debug messages.
+ */
+
+/*
+ * Usage:
+ * First, you have to connect your USB device from the Java side.
+ * Use the android.hardware.usb class to find the USB device, claim the interfaces, and open the usb_device_connection
+ * Obtain the native File Descriptor --> usb_device_connection.getFileDescriptor()
+ * Pass the received int value to the unrooted_usb_description method of this code (over JNA)
+ */
+
+/*
+ * libusb can only be included in Android projects using NDK for now. (CMake is not supported at the moment)
+ * Clone the libusb git repo into your Android project and include the Android.mk file in your build.gradle.
+ */
+
+/*
+ Example JNA Approach:
+    public interface unrooted_sample extends Library {
+        public static final unrooted_sample INSTANCE = Native.load("unrooted_android", unrooted_sample.class);
+        public int unrooted_usb_description (int fileDescriptor);
+    }
+    unrooted_sample.INSTANCE.unrooted_usb_description( usbDeviceConnection.getFileDescriptor());
+ */
+
+#include <jni.h>
+#include <string.h>
+#include "unrooted_android.h"
+#include "libusb.h"
+#include <android/log.h>
+#define LOG_TAG "LibUsb"
+#define LOGD(...) __android_log_print(ANDROID_LOG_DEBUG, LOG_TAG, __VA_ARGS__)
+
+int verbose = 0;
+
+static void print_endpoint_comp(const struct libusb_ss_endpoint_companion_descriptor *ep_comp) {
+    LOGD("      USB 3.0 Endpoint Companion:\n");
+    LOGD("        bMaxBurst:           %u\n", ep_comp->bMaxBurst);
+    LOGD("        bmAttributes:        %02xh\n", ep_comp->bmAttributes);
+    LOGD("        wBytesPerInterval:   %u\n", ep_comp->wBytesPerInterval);
+}
+
+static void print_endpoint(const struct libusb_endpoint_descriptor *endpoint) {
+    int i, ret;
+
+    LOGD("      Endpoint:\n");
+    LOGD("        bEndpointAddress:    %02xh\n", endpoint->bEndpointAddress);
+    LOGD("        bmAttributes:        %02xh\n", endpoint->bmAttributes);
+    LOGD("        wMaxPacketSize:      %u\n", endpoint->wMaxPacketSize);
+    LOGD("        bInterval:           %u\n", endpoint->bInterval);
+    LOGD("        bRefresh:            %u\n", endpoint->bRefresh);
+    LOGD("        bSynchAddress:       %u\n", endpoint->bSynchAddress);
+
+    for(i = 0; i < endpoint->extra_length;) {
+        if(LIBUSB_DT_SS_ENDPOINT_COMPANION == endpoint->extra[i + 1]) {
+            struct libusb_ss_endpoint_companion_descriptor *ep_comp;
+
+            ret = libusb_get_ss_endpoint_companion_descriptor(NULL, endpoint, &ep_comp);
+            if(LIBUSB_SUCCESS != ret)
+                continue;
+
+            print_endpoint_comp(ep_comp);
+
+            libusb_free_ss_endpoint_companion_descriptor(ep_comp);
+        }
+
+        i += endpoint->extra[i];
+    }
+}
+
+static void print_altsetting(const struct libusb_interface_descriptor *interface) {
+    uint8_t i;
+
+    LOGD("    Interface:\n");
+    LOGD("      bInterfaceNumber:      %u\n", interface->bInterfaceNumber);
+    LOGD("      bAlternateSetting:     %u\n", interface->bAlternateSetting);
+    LOGD("      bNumEndpoints:         %u\n", interface->bNumEndpoints);
+    LOGD("      bInterfaceClass:       %u\n", interface->bInterfaceClass);
+    LOGD("      bInterfaceSubClass:    %u\n", interface->bInterfaceSubClass);
+    LOGD("      bInterfaceProtocol:    %u\n", interface->bInterfaceProtocol);
+    LOGD("      iInterface:            %u\n", interface->iInterface);
+
+    for(i = 0; i < interface->bNumEndpoints; i++)
+        print_endpoint(&interface->endpoint[i]);
+}
+
+static void print_2_0_ext_cap(struct libusb_usb_2_0_extension_descriptor *usb_2_0_ext_cap) {
+    LOGD("    USB 2.0 Extension Capabilities:\n");
+    LOGD("      bDevCapabilityType:    %u\n", usb_2_0_ext_cap->bDevCapabilityType);
+    LOGD("      bmAttributes:          %08xh\n", usb_2_0_ext_cap->bmAttributes);
+}
+
+static void print_ss_usb_cap(struct libusb_ss_usb_device_capability_descriptor *ss_usb_cap) {
+    LOGD("    USB 3.0 Capabilities:\n");
+    LOGD("      bDevCapabilityType:    %u\n", ss_usb_cap->bDevCapabilityType);
+    LOGD("      bmAttributes:          %02xh\n", ss_usb_cap->bmAttributes);
+    LOGD("      wSpeedSupported:       %u\n", ss_usb_cap->wSpeedSupported);
+    LOGD("      bFunctionalitySupport: %u\n", ss_usb_cap->bFunctionalitySupport);
+    LOGD("      bU1devExitLat:         %u\n", ss_usb_cap->bU1DevExitLat);
+    LOGD("      bU2devExitLat:         %u\n", ss_usb_cap->bU2DevExitLat);
+}
+
+static void print_bos(libusb_device_handle *handle) {
+    struct libusb_bos_descriptor *bos;
+    uint8_t                       i;
+    int                           ret;
+
+    ret = libusb_get_bos_descriptor(handle, &bos);
+    if(ret < 0)
+        return;
+
+    LOGD("  Binary Object Store (BOS):\n");
+    LOGD("    wTotalLength:            %u\n", bos->wTotalLength);
+    LOGD("    bNumDeviceCaps:          %u\n", bos->bNumDeviceCaps);
+
+    for(i = 0; i < bos->bNumDeviceCaps; i++) {
+        struct libusb_bos_dev_capability_descriptor *dev_cap = bos->dev_capability[i];
+
+        if(dev_cap->bDevCapabilityType == LIBUSB_BT_USB_2_0_EXTENSION) {
+            struct libusb_usb_2_0_extension_descriptor *usb_2_0_extension;
+
+            ret = libusb_get_usb_2_0_extension_descriptor(NULL, dev_cap, &usb_2_0_extension);
+            if(ret < 0)
+                return;
+
+            print_2_0_ext_cap(usb_2_0_extension);
+            libusb_free_usb_2_0_extension_descriptor(usb_2_0_extension);
+        }
+        else if(dev_cap->bDevCapabilityType == LIBUSB_BT_SS_USB_DEVICE_CAPABILITY) {
+            struct libusb_ss_usb_device_capability_descriptor *ss_dev_cap;
+
+            ret = libusb_get_ss_usb_device_capability_descriptor(NULL, dev_cap, &ss_dev_cap);
+            if(ret < 0)
+                return;
+
+            print_ss_usb_cap(ss_dev_cap);
+            libusb_free_ss_usb_device_capability_descriptor(ss_dev_cap);
+        }
+    }
+
+    libusb_free_bos_descriptor(bos);
+}
+
+static void print_interface(const struct libusb_interface *interface) {
+    int i;
+
+    for(i = 0; i < interface->num_altsetting; i++)
+        print_altsetting(&interface->altsetting[i]);
+}
+
+static void print_configuration(struct libusb_config_descriptor *config) {
+    uint8_t i;
+
+    LOGD("  Configuration:\n");
+    LOGD("    wTotalLength:            %u\n", config->wTotalLength);
+    LOGD("    bNumInterfaces:          %u\n", config->bNumInterfaces);
+    LOGD("    bConfigurationValue:     %u\n", config->bConfigurationValue);
+    LOGD("    iConfiguration:          %u\n", config->iConfiguration);
+    LOGD("    bmAttributes:            %02xh\n", config->bmAttributes);
+    LOGD("    MaxPower:                %u\n", config->MaxPower);
+
+    for(i = 0; i < config->bNumInterfaces; i++)
+        print_interface(&config->interface[i]);
+}
+
+static void print_device(libusb_device *dev, libusb_device_handle *handle) {
+    struct libusb_device_descriptor desc;
+    unsigned char                   string[256];
+    const char                     *speed;
+    int                             ret;
+    uint8_t                         i;
+
+    switch(libusb_get_device_speed(dev)) {
+    case LIBUSB_SPEED_LOW:
+        speed = "1.5M";
+        break;
+    case LIBUSB_SPEED_FULL:
+        speed = "12M";
+        break;
+    case LIBUSB_SPEED_HIGH:
+        speed = "480M";
+        break;
+    case LIBUSB_SPEED_SUPER:
+        speed = "5G";
+        break;
+    case LIBUSB_SPEED_SUPER_PLUS:
+        speed = "10G";
+        break;
+    default:
+        speed = "Unknown";
+    }
+
+    ret = libusb_get_device_descriptor(dev, &desc);
+    if(ret < 0) {
+        LOGD("failed to get device descriptor");
+        return;
+    }
+
+    LOGD("Dev (bus %u, device %u): %04X - %04X speed: %s\n", libusb_get_bus_number(dev), libusb_get_device_address(dev), desc.idVendor, desc.idProduct, speed);
+
+    if(!handle)
+        libusb_open(dev, &handle);
+
+    if(handle) {
+        if(desc.iManufacturer) {
+            ret = libusb_get_string_descriptor_ascii(handle, desc.iManufacturer, string, sizeof(string));
+            if(ret > 0)
+                LOGD("  Manufacturer:              %s\n", (char *)string);
+        }
+
+        if(desc.iProduct) {
+            ret = libusb_get_string_descriptor_ascii(handle, desc.iProduct, string, sizeof(string));
+            if(ret > 0)
+                LOGD("  Product:                   %s\n", (char *)string);
+        }
+
+        if(desc.iSerialNumber && verbose) {
+            ret = libusb_get_string_descriptor_ascii(handle, desc.iSerialNumber, string, sizeof(string));
+            if(ret > 0)
+                LOGD("  Serial Number:             %s\n", (char *)string);
+        }
+    }
+
+    if(verbose) {
+        for(i = 0; i < desc.bNumConfigurations; i++) {
+            struct libusb_config_descriptor *config;
+
+            ret = libusb_get_config_descriptor(dev, i, &config);
+            if(LIBUSB_SUCCESS != ret) {
+                LOGD("  Couldn't retrieve descriptors\n");
+                continue;
+            }
+
+            print_configuration(config);
+
+            libusb_free_config_descriptor(config);
+        }
+
+        if(handle && desc.bcdUSB >= 0x0201)
+            print_bos(handle);
+    }
+
+    if(handle)
+        libusb_close(handle);
+}
+
+/* fileDescriptor = the native file descriptor obtained in Java and transferred to native over JNA, for example */
+int unrooted_usb_description(int fileDescriptor) {
+    libusb_context       *ctx  = NULL;
+    libusb_device_handle *devh = NULL;
+    int                   r    = 0;
+    verbose                    = 1;
+    r                          = libusb_set_option(NULL, LIBUSB_OPTION_NO_DEVICE_DISCOVERY, NULL);
+    if(r != LIBUSB_SUCCESS) {
+        LOGD("libusb_set_option failed: %d\n", r);
+        return -1;
+    }
+    r = libusb_init(&ctx);
+    if(r < 0) {
+        LOGD("libusb_init failed: %d\n", r);
+        return r;
+    }
+    r = libusb_wrap_sys_device(ctx, (intptr_t)fileDescriptor, &devh);
+    if(r < 0) {
+        LOGD("libusb_wrap_sys_device failed: %d\n", r);
+        return r;
+    }
+    else if(devh == NULL) {
+        LOGD("libusb_wrap_sys_device returned invalid handle\n");
+        return r;
+    }
+    print_device(libusb_get_device(devh), devh);
+    return r;
+}
diff --git a/3rdparty/libusb/src/android/examples/unrooted_android.h b/3rdparty/libusb/src/android/examples/unrooted_android.h
new file mode 100644
index 00000000..9eb84fa2
--- /dev/null
+++ b/3rdparty/libusb/src/android/examples/unrooted_android.h
@@ -0,0 +1,35 @@
+/*
+ *  Copyright 2021 Peter Stoiber
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2.1 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ *  Please contact the author if you need another license.
+ *  This Repository is provided "as is", without warranties of any kind.
+ */
+
+#ifndef unrooted_android_H
+#define unrooted_android_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern int unrooted_usb_description(int fileDescriptor);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/3rdparty/libusb/src/android/jni/Android.mk b/3rdparty/libusb/src/android/jni/Android.mk
new file mode 100644
index 00000000..29146b29
--- /dev/null
+++ b/3rdparty/libusb/src/android/jni/Android.mk
@@ -0,0 +1,23 @@
+# Android build config for libusb, examples and tests
+# Copyright © 2012-2013 RealVNC Ltd. <toby.gray@realvnc.com>
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+#
+
+LOCAL_PATH := $(call my-dir)
+
+include $(LOCAL_PATH)/libusb.mk
+include $(LOCAL_PATH)/examples.mk
+include $(LOCAL_PATH)/tests.mk
diff --git a/3rdparty/libusb/src/android/jni/Application.mk b/3rdparty/libusb/src/android/jni/Application.mk
new file mode 100644
index 00000000..c1137263
--- /dev/null
+++ b/3rdparty/libusb/src/android/jni/Application.mk
@@ -0,0 +1,40 @@
+# Android application build config for libusb
+# Copyright © 2012-2013 RealVNC Ltd. <toby.gray@realvnc.com>
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+#
+
+APP_ABI := all
+
+APP_CFLAGS := \
+  -std=gnu11 \
+  -Wall \
+  -Wextra \
+  -Wshadow \
+  -Wunused \
+  -Wwrite-strings \
+  -Werror=format-security \
+  -Werror=implicit-function-declaration \
+  -Werror=implicit-int \
+  -Werror=init-self \
+  -Werror=missing-prototypes \
+  -Werror=strict-prototypes \
+  -Werror=undef \
+  -Werror=uninitialized
+
+# Workaround for MIPS toolchain linker being unable to find liblog dependency
+# of shared object in NDK versions at least up to r9.
+#
+APP_LDFLAGS := -llog
diff --git a/3rdparty/libusb/src/android/jni/examples.mk b/3rdparty/libusb/src/android/jni/examples.mk
new file mode 100644
index 00000000..9e41d775
--- /dev/null
+++ b/3rdparty/libusb/src/android/jni/examples.mk
@@ -0,0 +1,168 @@
+# Android build config for libusb examples
+# Copyright © 2012-2013 RealVNC Ltd. <toby.gray@realvnc.com>
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+#
+
+LOCAL_PATH := $(call my-dir)
+LIBUSB_ROOT_REL := ../..
+LIBUSB_ROOT_ABS := $(LOCAL_PATH)/../..
+
+ifeq ($(USE_PC_NAME),1)
+  LIBUSB_MODULE := usb-1.0
+else
+  LIBUSB_MODULE := libusb1.0
+endif
+
+# dpfp
+
+include $(CLEAR_VARS)
+
+LOCAL_SRC_FILES := \
+  $(LIBUSB_ROOT_REL)/examples/dpfp.c
+
+LOCAL_C_INCLUDES += \
+  $(LOCAL_PATH)/.. \
+  $(LIBUSB_ROOT_ABS)
+
+LOCAL_SHARED_LIBRARIES += $(LIBUSB_MODULE)
+
+LOCAL_MODULE := dpfp
+
+include $(BUILD_EXECUTABLE)
+
+# dpfp_threaded
+
+include $(CLEAR_VARS)
+
+LOCAL_SRC_FILES := \
+  $(LIBUSB_ROOT_REL)/examples/dpfp.c
+
+LOCAL_C_INCLUDES += \
+  $(LOCAL_PATH)/.. \
+  $(LIBUSB_ROOT_ABS)
+
+LOCAL_CFLAGS := -DDPFP_THREADED -pthread
+
+LOCAL_SHARED_LIBRARIES += $(LIBUSB_MODULE)
+
+LOCAL_MODULE := dpfp_threaded
+
+include $(BUILD_EXECUTABLE)
+
+# fxload
+
+include $(CLEAR_VARS)
+
+LOCAL_SRC_FILES := \
+  $(LIBUSB_ROOT_REL)/examples/ezusb.c \
+  $(LIBUSB_ROOT_REL)/examples/fxload.c
+
+LOCAL_C_INCLUDES += \
+  $(LOCAL_PATH)/.. \
+  $(LIBUSB_ROOT_ABS)
+
+LOCAL_SHARED_LIBRARIES += $(LIBUSB_MODULE)
+
+LOCAL_MODULE := fxload
+
+include $(BUILD_EXECUTABLE)
+
+# hotplugtest
+
+include $(CLEAR_VARS)
+
+LOCAL_SRC_FILES := \
+  $(LIBUSB_ROOT_REL)/examples/hotplugtest.c
+
+LOCAL_C_INCLUDES += \
+  $(LOCAL_PATH)/.. \
+  $(LIBUSB_ROOT_ABS)
+
+LOCAL_SHARED_LIBRARIES += $(LIBUSB_MODULE)
+
+LOCAL_MODULE := hotplugtest
+
+include $(BUILD_EXECUTABLE)
+
+# listdevs
+
+include $(CLEAR_VARS)
+
+LOCAL_SRC_FILES := \
+  $(LIBUSB_ROOT_REL)/examples/listdevs.c
+
+LOCAL_C_INCLUDES += \
+  $(LOCAL_PATH)/.. \
+  $(LIBUSB_ROOT_ABS)
+
+LOCAL_SHARED_LIBRARIES += $(LIBUSB_MODULE)
+
+LOCAL_MODULE := listdevs
+
+include $(BUILD_EXECUTABLE)
+
+# sam3u_benchmark
+
+include $(CLEAR_VARS)
+
+LOCAL_SRC_FILES := \
+  $(LIBUSB_ROOT_REL)/examples/sam3u_benchmark.c
+
+LOCAL_C_INCLUDES += \
+  $(LOCAL_PATH)/.. \
+  $(LIBUSB_ROOT_ABS)
+
+LOCAL_SHARED_LIBRARIES += $(LIBUSB_MODULE)
+
+LOCAL_MODULE := sam3u_benchmark
+
+include $(BUILD_EXECUTABLE)
+
+# xusb
+
+include $(CLEAR_VARS)
+
+LOCAL_SRC_FILES := \
+  $(LIBUSB_ROOT_REL)/examples/xusb.c
+
+LOCAL_C_INCLUDES += \
+  $(LOCAL_PATH)/.. \
+  $(LIBUSB_ROOT_ABS)
+
+LOCAL_SHARED_LIBRARIES += $(LIBUSB_MODULE)
+
+LOCAL_MODULE := xusb
+
+include $(BUILD_EXECUTABLE)
+
+# unrooted_android
+
+include $(CLEAR_VARS)
+
+LOCAL_SRC_FILES := \
+  $(LIBUSB_ROOT_REL)/android/examples/unrooted_android.c
+
+LOCAL_C_INCLUDES += \
+  $(LOCAL_PATH)/.. \
+  $(LIBUSB_ROOT_ABS)
+
+LOCAL_SHARED_LIBRARIES += libusb1.0
+
+LOCAL_LDLIBS += -llog
+
+LOCAL_MODULE := unrooted_android
+
+include $(BUILD_SHARED_LIBRARY)
diff --git a/3rdparty/libusb/src/android/jni/libusb.mk b/3rdparty/libusb/src/android/jni/libusb.mk
new file mode 100644
index 00000000..8786626e
--- /dev/null
+++ b/3rdparty/libusb/src/android/jni/libusb.mk
@@ -0,0 +1,60 @@
+# Android build config for libusb
+# Copyright © 2012-2013 RealVNC Ltd. <toby.gray@realvnc.com>
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+#
+
+LOCAL_PATH := $(call my-dir)
+LIBUSB_ROOT_REL := ../..
+LIBUSB_ROOT_ABS := $(LOCAL_PATH)/../..
+
+# libusb
+
+include $(CLEAR_VARS)
+
+LOCAL_SRC_FILES := \
+  $(LIBUSB_ROOT_REL)/libusb/core.c \
+  $(LIBUSB_ROOT_REL)/libusb/descriptor.c \
+  $(LIBUSB_ROOT_REL)/libusb/hotplug.c \
+  $(LIBUSB_ROOT_REL)/libusb/io.c \
+  $(LIBUSB_ROOT_REL)/libusb/sync.c \
+  $(LIBUSB_ROOT_REL)/libusb/strerror.c \
+  $(LIBUSB_ROOT_REL)/libusb/os/linux_usbfs.c \
+  $(LIBUSB_ROOT_REL)/libusb/os/events_posix.c \
+  $(LIBUSB_ROOT_REL)/libusb/os/threads_posix.c \
+  $(LIBUSB_ROOT_REL)/libusb/os/linux_netlink.c
+
+LOCAL_C_INCLUDES += \
+  $(LOCAL_PATH)/.. \
+  $(LIBUSB_ROOT_ABS)/libusb \
+  $(LIBUSB_ROOT_ABS)/libusb/os
+
+LOCAL_EXPORT_C_INCLUDES := \
+  $(LIBUSB_ROOT_ABS)/libusb
+
+LOCAL_CFLAGS := -fvisibility=hidden -pthread
+
+LOCAL_LDLIBS := -llog
+
+ifeq ($(USE_PC_NAME),1)
+  LOCAL_MODULE := usb-1.0
+else
+  LOCAL_MODULE := libusb1.0
+  $(warning Building to legacy library name libusb1.0, which differs from pkg-config.)
+  $(warning Use ndk-build USE_PC_NAME=1 to change the module name to the compatible usb-1.0.)
+  $(warning USE_PC_NAME=1 may be the default in the future.)
+endif
+
+include $(BUILD_SHARED_LIBRARY)
diff --git a/3rdparty/libusb/src/android/jni/tests.mk b/3rdparty/libusb/src/android/jni/tests.mk
new file mode 100644
index 00000000..a32942a0
--- /dev/null
+++ b/3rdparty/libusb/src/android/jni/tests.mk
@@ -0,0 +1,45 @@
+# Android build config for libusb tests
+# Copyright © 2012-2013 RealVNC Ltd. <toby.gray@realvnc.com>
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+#
+
+LOCAL_PATH := $(call my-dir)
+LIBUSB_ROOT_REL := ../..
+LIBUSB_ROOT_ABS := $(LOCAL_PATH)/../..
+
+ifeq ($(USE_PC_NAME),1)
+  LIBUSB_MODULE := usb-1.0
+else
+  LIBUSB_MODULE := libusb1.0
+endif
+
+# stress
+
+include $(CLEAR_VARS)
+
+LOCAL_SRC_FILES := \
+  $(LIBUSB_ROOT_REL)/tests/stress.c \
+  $(LIBUSB_ROOT_REL)/tests/testlib.c
+
+LOCAL_C_INCLUDES += \
+  $(LOCAL_PATH)/.. \
+  $(LIBUSB_ROOT_ABS)
+
+LOCAL_SHARED_LIBRARIES += $(LIBUSB_MODULE)
+
+LOCAL_MODULE := stress
+
+include $(BUILD_EXECUTABLE)
diff --git a/3rdparty/libusb/src/android/libusb/config.h b/3rdparty/libusb/src/android/libusb/config.h
new file mode 100644
index 00000000..c710662f
--- /dev/null
+++ b/3rdparty/libusb/src/android/libusb/config.h
@@ -0,0 +1,55 @@
+/*
+ * Android build config for libusb
+ * Copyright © 2012-2013 RealVNC Ltd. <toby.gray@realvnc.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+/* Define to the attribute for default visibility. */
+#define DEFAULT_VISIBILITY __attribute__((visibility("default")))
+
+/* Define to 1 to start with debug message logging enabled. */
+/* #undef ENABLE_DEBUG_LOGGING */
+
+/* Define to 1 to enable message logging. */
+#define ENABLE_LOGGING 1
+
+/* Define to 1 if you have the <asm/types.h> header file. */
+#define HAVE_ASM_TYPES_H 1
+
+/* Define to 1 if you have the `clock_gettime' function. */
+#define HAVE_CLOCK_GETTIME 1
+
+/* Define to 1 if the system has the type `nfds_t'. */
+#define HAVE_NFDS_T 1
+
+/* Define to 1 if you have the `pipe2' function. */
+#define HAVE_PIPE2 1
+
+/* Define to 1 if you have the <sys/time.h> header file. */
+#define HAVE_SYS_TIME_H 1
+
+/* Define to 1 if compiling for a POSIX platform. */
+#define PLATFORM_POSIX 1
+
+/* Define to the attribute for enabling parameter checks on printf-like
+   functions. */
+#define PRINTF_FORMAT(a, b) __attribute__((__format__(__printf__, a, b)))
+
+/* Define to 1 to output logging messages to the systemwide log. */
+#define USE_SYSTEM_LOGGING_FACILITY 1
+
+/* Enable GNU extensions. */
+#define _GNU_SOURCE 1
diff --git a/3rdparty/libusb/src/appveyor.yml b/3rdparty/libusb/src/appveyor.yml
new file mode 100644
index 00000000..a03c62ba
--- /dev/null
+++ b/3rdparty/libusb/src/appveyor.yml
@@ -0,0 +1,108 @@
+version: 1.0.{build}
+image:
+  - Visual Studio 2013
+  - Visual Studio 2015
+  - Visual Studio 2017
+  - Visual Studio 2019
+  - Visual Studio 2022
+platform:
+  - Win32
+  - x64
+configuration:
+  - Debug
+  - Release
+environment:
+  toolset: UNK
+clone_depth: 1
+build:
+  parallel: true
+for:
+  -
+    matrix:
+      only:
+        - image: Visual Studio 2013
+    environment:
+      toolset: v120
+    build:
+      project: msvc\libusb.sln
+
+  -
+    matrix:
+      only:
+        - image: Visual Studio 2015
+          configuration: Debug
+    environment:
+      toolset: v140
+    build:
+      project: msvc\libusb.sln
+
+  -
+    matrix:
+      only:
+        - image: Visual Studio 2015
+          platform: Win32
+          configuration: Release
+    environment:
+      toolset: v140
+    install:
+      - cmd: xcopy /S /I "%APPVEYOR_BUILD_FOLDER%" C:\msys64\home\appveyor\libusb
+      - cmd: xcopy /S /I "%APPVEYOR_BUILD_FOLDER%" C:\cygwin\home\appveyor\libusb
+    build_script:
+      - cmd: msbuild "%APPVEYOR_BUILD_FOLDER%\msvc\libusb.sln" /m /logger:"C:\Program Files\AppVeyor\BuildAgent\Appveyor.MSBuildLogger.dll"
+      - cmd: C:\msys64\usr\bin\bash -l "%APPVEYOR_BUILD_FOLDER%\.private\appveyor_build.sh" MinGW
+      - cmd: C:\cygwin\bin\bash -l "%APPVEYOR_BUILD_FOLDER%\.private\appveyor_build.sh" cygwin
+    after_build:
+      - cmd: 7z a "libusb-build_%APPVEYOR_BUILD_WORKER_IMAGE%_%PLATFORM%_%CONFIGURATION%.7z" tag_* README-build.txt build\%TOOLSET%\%PLATFORM%\%CONFIGURATION%\dll build\%TOOLSET%\%PLATFORM%\%CONFIGURATION%\lib build\%TOOLSET%\%PLATFORM%\%CONFIGURATION%\*.exe C:\msys64\home\appveyor\libusb-MinGW-Win32 C:\cygwin\home\appveyor\libusb-cygwin-Win32
+
+  -
+    matrix:
+      only:
+        - image: Visual Studio 2015
+          platform: x64
+          configuration: Release
+    environment:
+      toolset: v140
+    install:
+      - cmd: xcopy /S /I "%APPVEYOR_BUILD_FOLDER%" C:\msys64\home\appveyor\libusb
+      - cmd: xcopy /S /I "%APPVEYOR_BUILD_FOLDER%" C:\cygwin64\home\appveyor\libusb
+    build_script:
+      - cmd: msbuild "%APPVEYOR_BUILD_FOLDER%\msvc\libusb.sln" /m /logger:"C:\Program Files\AppVeyor\BuildAgent\Appveyor.MSBuildLogger.dll"
+      - cmd: C:\msys64\usr\bin\bash -l "%APPVEYOR_BUILD_FOLDER%\.private\appveyor_build.sh" MinGW
+      - cmd: C:\cygwin64\bin\bash -l "%APPVEYOR_BUILD_FOLDER%\.private\appveyor_build.sh" cygwin
+    after_build:
+      - cmd: 7z a "libusb-build_%APPVEYOR_BUILD_WORKER_IMAGE%_%PLATFORM%_%CONFIGURATION%.7z" tag_* README-build.txt build\%TOOLSET%\%PLATFORM%\%CONFIGURATION%\dll build\%TOOLSET%\%PLATFORM%\%CONFIGURATION%\lib build\%TOOLSET%\%PLATFORM%\%CONFIGURATION%\*.exe C:\msys64\home\appveyor\libusb-MinGW-x64 C:\cygwin64\home\appveyor\libusb-cygwin-x64
+
+  -
+    matrix:
+      only:
+        - image: Visual Studio 2017
+    environment:
+      toolset: v141
+    build:
+      project: msvc\libusb.sln
+
+  -
+    matrix:
+      only:
+        - image: Visual Studio 2019
+    environment:
+      toolset: v142
+    build:
+      project: msvc\libusb.sln
+
+  -
+    matrix:
+      only:
+        - image: Visual Studio 2022
+    environment:
+      toolset: v143
+    build:
+      project: msvc\libusb.sln
+
+after_build:
+  - cmd: ECHO This was built by %APPVEYOR_BUILD_WORKER_IMAGE% from %APPVEYOR_REPO_NAME% commit %APPVEYOR_REPO_COMMIT% > README-build.txt
+  - cmd: ECHO > tag_%APPVEYOR_REPO_TAG_NAME%_commit_%APPVEYOR_REPO_COMMIT%
+  - cmd: 7z a "libusb-build_%APPVEYOR_BUILD_WORKER_IMAGE%_%PLATFORM%_%CONFIGURATION%.7z" tag_* README-build.txt build\%TOOLSET%\%PLATFORM%\%CONFIGURATION%\dll build\%TOOLSET%\%PLATFORM%\%CONFIGURATION%\lib build\%TOOLSET%\%PLATFORM%\%CONFIGURATION%\*.exe
+
+artifacts:
+  - path: "libusb-build_%APPVEYOR_BUILD_WORKER_IMAGE%_%PLATFORM%_%CONFIGURATION%.7z"
diff --git a/3rdparty/libusb/src/autogen.sh b/3rdparty/libusb/src/autogen.sh
new file mode 100644
index 00000000..2ffb10e0
--- /dev/null
+++ b/3rdparty/libusb/src/autogen.sh
@@ -0,0 +1,10 @@
+#!/bin/sh
+
+set -e
+
+srcdir="$(dirname "$0")"
+
+"$srcdir"/bootstrap.sh
+if [ -z "$NOCONFIGURE" ]; then
+    exec "$srcdir"/configure --enable-examples-build --enable-tests-build "$@"
+fi
diff --git a/3rdparty/libusb/src/bootstrap.sh b/3rdparty/libusb/src/bootstrap.sh
new file mode 100644
index 00000000..fc555d50
--- /dev/null
+++ b/3rdparty/libusb/src/bootstrap.sh
@@ -0,0 +1,10 @@
+#!/bin/sh
+
+set -e
+
+cd "$(dirname "$0")"
+
+if [ ! -d m4 ]; then
+    mkdir m4
+fi
+exec autoreconf -ivf
diff --git a/3rdparty/libusb/src/configure.ac b/3rdparty/libusb/src/configure.ac
new file mode 100644
index 00000000..d5b50ab9
--- /dev/null
+++ b/3rdparty/libusb/src/configure.ac
@@ -0,0 +1,443 @@
+dnl These m4 macros are whitespace sensitive and break if moved around much.
+m4_define([LU_VERSION_H], m4_include([libusb/version.h]))
+m4_define([LU_DEFINE_VERSION_ATOM],
+	[m4_define([$1], m4_bregexp(LU_VERSION_H,
+	[^#define\s*$1\s*\([0-9]*\).*], [\1]))])
+m4_define([LU_DEFINE_VERSION_RC_ATOM],
+	[m4_define([$1], m4_bregexp(LU_VERSION_H,
+	[^#define\s*$1\s*"\(-rc[0-9]*\)".*], [\1]))])
+dnl The m4_bregexp() returns (only) the numbers following the #define named
+dnl in the first macro parameter. m4_define() then defines the name for use
+dnl in AC_INIT.
+
+LU_DEFINE_VERSION_ATOM([LIBUSB_MAJOR])
+LU_DEFINE_VERSION_ATOM([LIBUSB_MINOR])
+LU_DEFINE_VERSION_ATOM([LIBUSB_MICRO])
+LU_DEFINE_VERSION_RC_ATOM([LIBUSB_RC])
+
+AC_PREREQ([2.69])
+AC_INIT([libusb-1.0], [LIBUSB_MAJOR[.]LIBUSB_MINOR[.]LIBUSB_MICRO[]LIBUSB_RC], [libusb-devel@lists.sourceforge.net], [libusb-1.0], [http://libusb.info])
+AC_CONFIG_HEADERS([config.h])
+AC_CONFIG_SRCDIR([libusb/core.c])
+AC_CONFIG_MACRO_DIR([m4])
+AC_PROG_CC
+AC_PROG_CXX
+AC_C_INLINE
+AM_INIT_AUTOMAKE
+LT_INIT
+LT_LANG([Windows Resource])
+
+dnl Library versioning
+dnl These numbers should be tweaked on every release. Read carefully:
+dnl http://www.gnu.org/software/libtool/manual/html_node/Updating-version-info.html
+dnl http://sourceware.org/autobook/autobook/autobook_91.html
+lt_current=3
+lt_revision=0
+lt_age=3
+LT_LDFLAGS="-version-info ${lt_current}:${lt_revision}:${lt_age} -no-undefined"
+
+m4_ifdef([AM_SILENT_RULES],[AM_SILENT_RULES([yes])])
+
+EXTRA_CPPFLAGS=
+EXTRA_CFLAGS=
+
+dnl check for -std=gnu11 compiler support (optional)
+dnl note that we don't just check if the compiler accepts '-std=x11'
+dnl but also that it supports the _Thread_local keyword because some compilers
+dnl (e.g. gcc 4.8) accept the command line option but do not implement TLS
+saved_CFLAGS="${CFLAGS}"
+CFLAGS="-std=gnu11"
+AC_MSG_CHECKING([if $CC supports -std=gnu11])
+AC_COMPILE_IFELSE([AC_LANG_PROGRAM([_Thread_local int x;], [x = 42;])],
+	[AC_MSG_RESULT([yes])
+	 c_dialect=gnu],
+	[AC_MSG_RESULT([no])
+	 c_dialect=])
+if test "x$c_dialect" != xgnu; then
+	dnl fallback check for -std=c11 compiler support (required)
+	CFLAGS="-std=c11"
+	AC_MSG_CHECKING([if $CC supports -std=c11])
+	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([_Thread_local int x;], [x = 42;])],
+		[AC_MSG_RESULT([yes])],
+		[AC_MSG_RESULT([no])
+		 AC_MSG_ERROR([compiler with C11 support is required to build libusb])])
+	c_dialect=c
+fi
+CFLAGS="${saved_CFLAGS}"
+
+AC_DEFINE([_GNU_SOURCE], [1], [Enable GNU extensions.])
+AC_DEFINE([DEFAULT_VISIBILITY], [__attribute__ ((visibility ("default")))], [Define to the attribute for default visibility.])
+AC_DEFINE([PRINTF_FORMAT(a, b)], [__attribute__ ((__format__ (__printf__, a, b)))], [Define to the attribute for enabling parameter checks on printf-like functions.])
+
+create_import_lib=
+is_android_linux=
+AC_MSG_CHECKING([operating system])
+case $host in
+*-darwin*)
+	AC_MSG_RESULT([Darwin/Mac OS X])
+	backend=darwin
+	platform=posix
+	;;
+*-haiku*)
+	AC_MSG_RESULT([Haiku])
+	backend=haiku
+	platform=posix
+	;;
+wasm32-**)
+	AC_MSG_RESULT([Emscripten])
+	backend=emscripten
+	platform=posix
+	;;
+*-linux* | *-uclinux*)
+	dnl on Android Linux, some functions are in different places
+	case $host in
+	*-linux-android*)
+		AC_MSG_RESULT([Android Linux])
+		is_android_linux=yes
+		;;
+	*)
+		AC_MSG_RESULT([Linux])
+		;;
+	esac
+	backend=linux
+	platform=posix
+	;;
+*-netbsd*)
+	AC_MSG_RESULT([NetBSD])
+	backend=netbsd
+	platform=posix
+	;;
+*-openbsd*)
+	AC_MSG_RESULT([OpenBSD])
+	backend=openbsd
+	platform=posix
+	;;
+*-solaris*)
+	AC_MSG_RESULT([SunOS])
+	backend=sunos
+	platform=posix
+	;;
+*-cygwin*)
+	AC_MSG_RESULT([Windows (using Cygwin)])
+	backend=windows
+	platform=windows
+	EXTRA_CFLAGS="-mwin32"
+	;;
+*-mingw* | *msys*)
+	AC_MSG_RESULT([Windows])
+	backend=windows
+	platform=windows
+	test "x$enable_shared" = xyes && create_import_lib=yes
+	EXTRA_CFLAGS="-fno-omit-frame-pointer"
+	EXTRA_LDFLAGS="-static-libgcc"
+	;;
+*)
+	AC_MSG_RESULT([Null])
+	AC_MSG_WARN([The host being compiled for is not supported.])
+	AC_MSG_WARN([The library may compile but will not function in any useful manner.])
+	backend=null
+	platform=posix
+	;;
+esac
+
+if test "x$platform" = xposix; then
+	AC_DEFINE([PLATFORM_POSIX], [1], [Define to 1 if compiling for a POSIX platform.])
+	AC_CHECK_TYPES([nfds_t], [], [], [[#include <poll.h>]])
+	if test "x$backend" != xemscripten; then
+		# pipe2 is detected as present on Emscripten, but it isn't actually ported and always
+		# returns an error. https://github.com/emscripten-core/emscripten/issues/14824
+		AC_CHECK_FUNCS([pipe2])
+	fi
+	dnl Some compilers do not support the '-pthread' option so check for it here
+	saved_CFLAGS="${CFLAGS}"
+	CFLAGS="-Wall -Werror -pthread"
+	AC_MSG_CHECKING([if $CC recognizes -pthread])
+	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], [])],
+		[AC_MSG_RESULT([yes])
+		 AC_SUBST(THREAD_CFLAGS, [-pthread])],
+		[AC_MSG_RESULT([no])])
+	CFLAGS="${saved_CFLAGS}"
+	dnl Android Linux and Darwin provide pthread functions directly in libc
+	dnl glibc also provides some pthread functions directly, so search for a thread-specific function
+	AC_SEARCH_LIBS([pthread_create], [pthread],
+		[test "x$ac_cv_search_pthread_create" != "xnone required" && AC_SUBST(THREAD_LIBS, [-lpthread])],
+		[], [])
+	dnl Check for new-style atomic builtins. We first check without linking to -latomic.
+	AC_MSG_CHECKING(whether __atomic_load_n is supported)
+	AC_LINK_IFELSE([AC_LANG_SOURCE([[
+	#include <stdint.h>
+	int main() {
+		struct {
+			uint64_t *v;
+		} x;
+		return (int)__atomic_load_n(x.v, __ATOMIC_ACQUIRE) &
+		       (int)__atomic_add_fetch(x.v, (uint64_t)1, __ATOMIC_ACQ_REL);
+	}]])], GCC_ATOMIC_BUILTINS_SUPPORTED=yes, GCC_ATOMIC_BUILTINS_SUPPORTED=no)
+	AC_MSG_RESULT($GCC_ATOMIC_BUILTINS_SUPPORTED)
+	if test "x$GCC_ATOMIC_BUILTINS_SUPPORTED" != xyes; then
+		AC_SEARCH_LIBS([__atomic_fetch_add_4], [atomic])
+	fi
+elif test "x$platform" = xwindows; then
+	AC_DEFINE([PLATFORM_WINDOWS], [1], [Define to 1 if compiling for a Windows platform.])
+else
+	AC_MSG_ERROR([Unknown platform])
+fi
+
+case $backend in
+darwin)
+	AC_CHECK_FUNCS([pthread_threadid_np])
+	LIBS="${LIBS} -lobjc -Wl,-framework,IOKit -Wl,-framework,CoreFoundation -Wl,-framework,Security"
+	AC_CHECK_HEADERS([IOKit/usb/IOUSBHostFamilyDefinitions.h])
+	;;
+haiku)
+	LIBS="${LIBS} -lbe"
+	;;
+linux)
+	AC_SEARCH_LIBS([clock_gettime], [rt], [], [], [])
+	AC_CHECK_FUNCS([pthread_setname_np])
+	AC_ARG_ENABLE([udev],
+		[AS_HELP_STRING([--enable-udev], [use udev for device enumeration and hotplug support (recommended) [default=yes]])],
+		[use_udev=$enableval], [use_udev=yes])
+	if test "x$use_udev" = xyes; then
+		dnl system has udev. use it or fail!
+		AC_CHECK_HEADER([libudev.h], [], [AC_MSG_ERROR([udev support requested but libudev header not installed])])
+		AC_CHECK_LIB([udev], [udev_new], [], [AC_MSG_ERROR([udev support requested but libudev not installed])])
+
+		# We can build umockdev tests (if available)
+		m4_ifdef([PKG_PROG_PKG_CONFIG],[
+			PKG_PROG_PKG_CONFIG
+		   	PKG_CHECK_MODULES([UMOCKDEV], [umockdev-1.0 >= 0.16.0], [ac_have_umockdev=yes], [ac_have_umockdev=no])
+		   	PKG_CHECK_MODULES([UMOCKDEV_HOTPLUG], [umockdev-1.0 >= 0.17.7], [ac_umockdev_hotplug=yes], [ac_umockdev_hotplug=no])
+			if test $ac_umockdev_hotplug = yes; then
+			   AC_DEFINE([UMOCKDEV_HOTPLUG], [1], [UMockdev hotplug code is not racy])
+			fi
+		], [])
+	else
+		AC_CHECK_HEADERS([asm/types.h])
+		AC_CHECK_HEADER([linux/netlink.h], [], [AC_MSG_ERROR([Linux netlink header not found])])
+		AC_CHECK_HEADER([sys/socket.h], [], [AC_MSG_ERROR([Linux socket header not found])])
+	fi
+	;;
+sunos)
+	LIBS="${LIBS} -ldevinfo"
+	;;
+windows)
+	AC_CHECK_TYPES([struct timespec], [], [], [[#include <time.h>]])
+	AC_DEFINE([_WIN32_WINNT], [_WIN32_WINNT_VISTA], [Define to the oldest supported Windows version.])
+	LT_LDFLAGS="${LT_LDFLAGS} -avoid-version"
+	;;
+emscripten)
+	AC_SUBST(EXEEXT, [.html])
+	# Note: LT_LDFLAGS is not enough here because we need link flags for executable.
+	AM_LDFLAGS="${AM_LDFLAGS} --bind -s ASYNCIFY -s ASSERTIONS -s ALLOW_MEMORY_GROWTH -s INVOKE_RUN=0 -s EXPORTED_RUNTIME_METHODS=['callMain']"
+	;;
+*)
+	dnl no special handling required
+	;;
+esac
+
+dnl headers not available on all platforms but required on others
+AC_CHECK_HEADERS([sys/time.h])
+
+dnl check availability of clock_gettime(), except don't bother on Darwin, because the result is not used.
+if test "x$platform" = xposix && test "x$backend" != xdarwin; then
+	AC_CHECK_FUNCS([clock_gettime], [have_clock_gettime=yes], [AC_MSG_ERROR([clock_gettime() is required on this platform])])
+
+	if test "x$have_clock_gettime" = xyes; then
+		dnl the clock_gettime() function needs certain clock IDs defined
+		AC_CHECK_DECL([CLOCK_MONOTONIC], [], [AC_MSG_ERROR([C library headers missing definition for CLOCK_MONOTONIC])], [[#include <time.h>]])
+		dnl use the monotonic clock for condition variable timed waits if possible
+		AC_CHECK_FUNCS([pthread_condattr_setclock], [need_clock_realtime=], [need_clock_realtime=yes])
+		if test "x$need_clock_realtime" = xyes; then
+			AC_CHECK_DECL([CLOCK_REALTIME], [], [AC_MSG_ERROR([C library headers missing definition for CLOCK_REALTIME])], [[#include <time.h>]])
+		fi
+	fi
+fi
+
+dnl eventfd support
+if test "x$backend" = xlinux || test "x$backend" = xsunos; then
+	AC_ARG_ENABLE([eventfd],
+		[AS_HELP_STRING([--enable-eventfd], [use eventfd for signalling [default=auto]])],
+		[use_eventfd=$enableval],
+		[use_eventfd=auto])
+	if test "x$use_eventfd" != xno; then
+		AC_CHECK_HEADER([sys/eventfd.h], [eventfd_h=yes], [eventfd_h=])
+		if test "x$eventfd_h" = xyes; then
+			AC_CHECK_DECLS([EFD_NONBLOCK, EFD_CLOEXEC], [eventfd_h_ok=yes], [eventfd_h_ok=], [[#include <sys/eventfd.h>]])
+			if test "x$eventfd_h_ok" = xyes; then
+				AC_CHECK_FUNC([eventfd], [eventfd_ok=yes], [eventfd_ok=])
+				if test "x$eventfd_ok" = xyes; then
+					AC_DEFINE([HAVE_EVENTFD], [1], [Define to 1 if the system has eventfd functionality.])
+				elif test "x$use_eventfd" = xyes; then
+					AC_MSG_ERROR([eventfd() function not found; glibc 2.9+ required])
+				fi
+			elif test "x$use_eventfd" = xyes; then
+				AC_MSG_ERROR([eventfd header not usable; glibc 2.9+ required])
+			fi
+		elif test "x$use_eventfd" = xyes; then
+			AC_MSG_ERROR([eventfd header not available; glibc 2.9+ required])
+		fi
+	fi
+	AC_MSG_CHECKING([whether to use eventfd for signalling])
+	if test "x$use_eventfd" = xno; then
+		AC_MSG_RESULT([no (disabled by user)])
+	elif test "x$eventfd_h" != xyes; then
+		AC_MSG_RESULT([no (header not available)])
+	elif test "x$eventfd_h_ok" != xyes; then
+		AC_MSG_RESULT([no (header not usable)])
+	elif test "x$eventfd_ok" != xyes; then
+		AC_MSG_RESULT([no (functions not available)])
+	else
+		AC_MSG_RESULT([yes])
+	fi
+fi
+
+dnl timerfd support
+if test "x$backend" = xlinux || test "x$backend" = xsunos; then
+	AC_ARG_ENABLE([timerfd],
+		[AS_HELP_STRING([--enable-timerfd], [use timerfd for timing [default=auto]])],
+		[use_timerfd=$enableval],
+		[use_timerfd=auto])
+	if test "x$use_timerfd" != xno; then
+		AC_CHECK_HEADER([sys/timerfd.h], [timerfd_h=yes], [timerfd_h=])
+		if test "x$timerfd_h" = xyes; then
+			AC_CHECK_DECLS([TFD_NONBLOCK, TFD_CLOEXEC], [timerfd_h_ok=yes], [timerfd_h_ok=], [[#include <sys/timerfd.h>]])
+			if test "x$timerfd_h_ok" = xyes; then
+				AC_CHECK_FUNC([timerfd_create], [timerfd_ok=yes], [timerfd_ok=])
+				if test "x$timerfd_ok" = xyes; then
+					AC_DEFINE([HAVE_TIMERFD], [1], [Define to 1 if the system has timerfd functionality.])
+				elif test "x$use_timerfd" = xyes; then
+					AC_MSG_ERROR([timerfd_create() function not found; glibc 2.9+ required])
+				fi
+			elif test "x$use_timerfd" = xyes; then
+				AC_MSG_ERROR([timerfd header not usable; glibc 2.9+ required])
+			fi
+		elif test "x$use_timerfd" = xyes; then
+			AC_MSG_ERROR([timerfd header not available; glibc 2.9+ required])
+		fi
+	fi
+	AC_MSG_CHECKING([whether to use timerfd for timing])
+	if test "x$use_timerfd" = xno; then
+		AC_MSG_RESULT([no (disabled by user)])
+	elif test "x$timerfd_h" != xyes; then
+		AC_MSG_RESULT([no (header not available)])
+	elif test "x$timerfd_h_ok" != xyes; then
+		AC_MSG_RESULT([no (header not usable)])
+	elif test "x$timerfd_ok" != xyes; then
+		AC_MSG_RESULT([no (functions not available)])
+	else
+		AC_MSG_RESULT([yes])
+	fi
+fi
+
+dnl Message logging
+AC_ARG_ENABLE([log],
+	[AS_HELP_STRING([--disable-log], [disable all logging])],
+	[log_enabled=$enableval],
+	[log_enabled=yes])
+if test "x$log_enabled" != xno; then
+	AC_DEFINE([ENABLE_LOGGING], [1], [Define to 1 to enable message logging.])
+fi
+
+AC_ARG_ENABLE([debug-log],
+	[AS_HELP_STRING([--enable-debug-log], [start with debug message logging enabled [default=no]])],
+	[debug_log_enabled=$enableval],
+	[debug_log_enabled=no])
+if test "x$debug_log_enabled" != xno; then
+	AC_DEFINE([ENABLE_DEBUG_LOGGING], [1], [Define to 1 to start with debug message logging enabled.])
+fi
+
+AC_ARG_ENABLE([system-log],
+	[AS_HELP_STRING([--enable-system-log], [output logging messages to the systemwide log, if supported by the OS [default=no]])],
+	[system_log_enabled=$enableval],
+	[system_log_enabled=no])
+if test "x$system_log_enabled" != xno; then
+	AC_DEFINE([USE_SYSTEM_LOGGING_FACILITY], [1], [Define to 1 to output logging messages to the systemwide log.])
+	if test "x$backend" != xwindows && test "x$is_android_linux" != xyes; then
+		dnl Check if syslog is available in standard C library
+		AC_CHECK_HEADER([syslog.h], [syslog_h=yes], [syslog_h=])
+		if test "x$syslog_h" = xyes; then
+			AC_CHECK_FUNCS([syslog])
+		fi
+	fi
+fi
+
+dnl Examples build
+AC_ARG_ENABLE([examples-build],
+	[AS_HELP_STRING([--enable-examples-build], [build example applications [default=no]])],
+	[build_examples=$enableval],
+	[build_examples=no])
+
+dnl Tests build
+AC_ARG_ENABLE([tests-build],
+	[AS_HELP_STRING([--enable-tests-build], [build test applications [default=no]])],
+	[build_tests=$enableval],
+	[build_tests=no])
+
+AM_CONDITIONAL([BUILD_EXAMPLES], [test "x$build_examples" != xno])
+AM_CONDITIONAL([BUILD_TESTS], [test "x$build_tests" != xno])
+AM_CONDITIONAL([BUILD_UMOCKDEV_TEST], [test "x$ac_have_umockdev" = xyes -a "x$log_enabled" != xno])
+AM_CONDITIONAL([CREATE_IMPORT_LIB], [test "x$create_import_lib" = xyes])
+AM_CONDITIONAL([OS_DARWIN], [test "x$backend" = xdarwin])
+AM_CONDITIONAL([OS_HAIKU], [test "x$backend" = xhaiku])
+AM_CONDITIONAL([OS_LINUX], [test "x$backend" = xlinux])
+AM_CONDITIONAL([OS_NETBSD], [test "x$backend" = xnetbsd])
+AM_CONDITIONAL([OS_NULL], [test "x$backend" = xnull])
+AM_CONDITIONAL([OS_OPENBSD], [test "x$backend" = xopenbsd])
+AM_CONDITIONAL([OS_SUNOS], [test "x$backend" = xsunos])
+AM_CONDITIONAL([OS_WINDOWS], [test "x$backend" = xwindows])
+AM_CONDITIONAL([OS_EMSCRIPTEN], [test "x$backend" = xemscripten])
+AM_CONDITIONAL([PLATFORM_POSIX], [test "x$platform" = xposix])
+AM_CONDITIONAL([PLATFORM_WINDOWS], [test "x$platform" = xwindows])
+AM_CONDITIONAL([USE_UDEV], [test "x$use_udev" = xyes])
+
+dnl The -Wcast-function-type warning causes a flurry of warnings when compiling
+dnl Windows with GCC 8 or later because of dynamically loaded functions
+if test "x$backend" = xwindows; then
+	saved_CFLAGS="${CFLAGS}"
+	CFLAGS="-Werror -Wcast-function-type"
+	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], [])],
+		[EXTRA_CFLAGS="${EXTRA_CFLAGS} -Wno-cast-function-type"],
+		[])
+	CFLAGS="${saved_CFLAGS}"
+fi
+
+dnl Some linkers do not support the '--add-stdcall-alias' option so check for it here
+if test "x$backend" = xwindows; then
+	saved_CFLAGS="${CFLAGS}"
+	CFLAGS="-Wl,--add-stdcall-alias"
+	AC_MSG_CHECKING([if linker supports --add-stdcall-alias])
+	AC_LINK_IFELSE([AC_LANG_PROGRAM([], [])],
+		[AC_MSG_RESULT([yes])
+		 LT_LDFLAGS="${LT_LDFLAGS} -Wl,--add-stdcall-alias"],
+		[AC_MSG_RESULT([no])])
+	CFLAGS="${saved_CFLAGS}"
+fi
+
+SHARED_CFLAGS="-Wall -Wextra -Wshadow -Wunused -Wwrite-strings -Werror=format-security -Werror=implicit-function-declaration -Werror=implicit-int -Werror=init-self -Werror=missing-prototypes -Werror=strict-prototypes -Werror=undef -Werror=uninitialized"
+
+AM_CPPFLAGS="${EXTRA_CPPFLAGS}"
+AC_SUBST(AM_CPPFLAGS)
+
+AM_CFLAGS="-std=${c_dialect}11 ${EXTRA_CFLAGS} ${SHARED_CFLAGS}"
+AC_SUBST(AM_CFLAGS)
+
+AM_CXXFLAGS="-std=${c_dialect}++11 ${EXTRA_CFLAGS} ${SHARED_CFLAGS} -Wmissing-declarations"
+AC_SUBST(AM_CXXFLAGS)
+
+AC_SUBST(LT_LDFLAGS)
+AC_SUBST(AM_LDFLAGS)
+
+AC_SUBST([EXTRA_LDFLAGS])
+
+dnl set name of html output directory for doxygen
+AC_SUBST(DOXYGEN_HTMLDIR, [api-1.0])
+
+AC_CONFIG_FILES([libusb-1.0.pc])
+AC_CONFIG_FILES([Makefile])
+AC_CONFIG_FILES([libusb/Makefile])
+AC_CONFIG_FILES([examples/Makefile])
+AC_CONFIG_FILES([tests/Makefile])
+AC_CONFIG_FILES([doc/Makefile])
+AC_CONFIG_FILES([doc/doxygen.cfg])
+AC_OUTPUT
diff --git a/3rdparty/libusb/src/doc/Makefile.in b/3rdparty/libusb/src/doc/Makefile.in
new file mode 100644
index 00000000..6568c4ff
--- /dev/null
+++ b/3rdparty/libusb/src/doc/Makefile.in
@@ -0,0 +1,22 @@
+LIBUSB_SRC_DIR = @top_srcdir@/libusb
+EXCLUDED_FILES = libusbi.h version.h version_nano.h
+LIBUSB_SRC = $(wildcard $(LIBUSB_SRC_DIR)/*.c) $(wildcard $(LIBUSB_SRC_DIR)/*.h)
+LIBUSB_DOC_SRC = $(filter-out $(addprefix $(LIBUSB_SRC_DIR)/,$(EXCLUDED_FILES)),$(LIBUSB_SRC))
+
+docs: @DOXYGEN_HTMLDIR@
+
+@DOXYGEN_HTMLDIR@: doxygen.cfg @top_srcdir@/doc/libusb.png $(LIBUSB_DOC_SRC)
+	doxygen $<
+
+sfurl = web.sourceforge.net:/home/project-web/libusb/htdocs
+docs-upload: @DOXYGEN_HTMLDIR@
+	if [ -z "$$SF_USER" ]; then \
+		rsync -rv --delete $< $(sfurl); \
+	else \
+		rsync -rv --delete $< $$SF_USER@$(sfurl); \
+	fi
+
+clean:
+	rm -rf @DOXYGEN_HTMLDIR@
+
+.PHONY: clean docs docs-upload
diff --git a/3rdparty/libusb/src/doc/doxygen.cfg.in b/3rdparty/libusb/src/doc/doxygen.cfg.in
new file mode 100644
index 00000000..b6e6219c
--- /dev/null
+++ b/3rdparty/libusb/src/doc/doxygen.cfg.in
@@ -0,0 +1,2571 @@
+# Doxyfile 1.9.0
+
+# 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           = libusb
+
+# 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         = @PACKAGE_VERSION@
+
+# 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          = "A cross-platform user library to access USB devices"
+
+# 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           = @top_srcdir@/doc/libusb.png
+
+# 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       =
+
+# 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
+
+# The OUTPUT_TEXT_DIRECTION tag is used to specify the direction in which all
+# documentation generated by doxygen is written. Doxygen will use this
+# information to generate all generated output in the proper direction.
+# Possible values are: None, LTR, RTL and Context.
+# The default value is: None.
+
+OUTPUT_TEXT_DIRECTION  = None
+
+# 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       =
+
+# 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        = NO
+
+# 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        =
+
+# 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            = NO
+
+# 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         = YES
+
+# 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       = NO
+
+# 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                  = @top_srcdir@/libusb
+
+# 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 \
+                         *.h
+
+# 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                = @top_srcdir@/libusb/libusbi.h \
+                         @top_srcdir@/libusb/version.h \
+                         @top_srcdir@/libusb/version_nano.h \
+                         @top_srcdir@/libusb/os
+
+# 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
+
+#---------------------------------------------------------------------------
+# 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            = @DOXYGEN_HTMLDIR@
+
+# 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_TIMESTAMP tag is set to YES then the footer of each generated HTML
+# page will contain the date and time when the page was generated. Setting this
+# to YES can help to show when doxygen was last run and thus if the
+# documentation is up to date.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_TIMESTAMP         = YES
+
+# 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  = YES
+
+# 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
+
+# Use the FORMULA_TRANSPARENT tag to determine whether or not the images
+# generated for formulas are transparent PNGs. Transparent PNGs are not
+# supported properly for IE 6.0, but are supported on all modern browsers.
+#
+# Note that when changing this option you need to delete any form_*.png files in
+# the HTML output directory before the changes have effect.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+FORMULA_TRANSPARENT    = YES
+
+# 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        = http://cdn.mathjax.org/mathjax/latest
+
+# 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           = NO
+
+# 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         = latex
+
+# 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         = NO
+
+# 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           = NO
+
+# 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
+
+# If the LATEX_SOURCE_CODE tag is set to YES then doxygen will include source
+# code with syntax highlighting in the LaTeX output.
+#
+# Note that which sources are shown also depends on other settings such as
+# SOURCE_BROWSER.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_SOURCE_CODE      = 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
+
+# If the LATEX_TIMESTAMP tag is set to YES then the footer of each generated
+# page will contain the date and time when the page was generated. Setting this
+# to NO can help when comparing the output of multiple runs.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_TIMESTAMP        = NO
+
+# 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    =
+
+# If the RTF_SOURCE_CODE tag is set to YES then doxygen will include source code
+# with syntax highlighting in the RTF output.
+#
+# Note that which sources are shown also depends on other settings such as
+# SOURCE_BROWSER.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_RTF is set to YES.
+
+RTF_SOURCE_CODE        = NO
+
+#---------------------------------------------------------------------------
+# 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           = NO
+
+# 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
+
+# If the DOCBOOK_PROGRAMLISTING tag is set to YES, doxygen will include the
+# program listings (including syntax highlighting and cross-referencing
+# information) to the DOCBOOK output. Note that enabling this will significantly
+# increase the size of the DOCBOOK output.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_DOCBOOK is set to YES.
+
+DOCBOOK_PROGRAMLISTING = NO
+
+#---------------------------------------------------------------------------
+# 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             = API_EXPORTED= \
+                         DEFAULT_VISIBILITY= \
+                         LIBUSB_CALL= \
+                         LIBUSB_PACKED=
+
+# 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
+#---------------------------------------------------------------------------
+
+# If the CLASS_DIAGRAMS tag is set to YES, doxygen will generate a class diagram
+# (in HTML and LaTeX) for classes with base or super classes. Setting the tag to
+# NO turns the diagrams off. Note that this option also works with HAVE_DOT
+# disabled, but it is recommended to install and use dot, since it yields more
+# powerful graphs.
+# The default value is: YES.
+
+CLASS_DIAGRAMS         = YES
+
+# 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: NO.
+
+HAVE_DOT               = NO
+
+# 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
+
+# When you want a differently looking font in the dot files that doxygen
+# generates you can specify the font name using DOT_FONTNAME. You need to make
+# sure dot is able to find the font, which can be done by putting it in a
+# standard location or by setting the DOTFONTPATH environment variable or by
+# setting DOT_FONTPATH to the directory containing the font.
+# The default value is: Helvetica.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_FONTNAME           = Helvetica
+
+# The DOT_FONTSIZE tag can be used to set the size (in points) of the font of
+# dot graphs.
+# Minimum value: 4, maximum value: 24, default value: 10.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_FONTSIZE           = 10
+
+# 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, jpg, gif, 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_TRANSPARENT tag to YES to generate images with a transparent
+# background. This is disabled by default, because dot on Windows does not seem
+# to support this out of the box.
+#
+# Warning: Depending on the platform used, enabling this option may lead to
+# badly anti-aliased labels on the edges of a graph (i.e. they become hard to
+# read).
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_TRANSPARENT        = NO
+
+# 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/3rdparty/libusb/src/doc/libusb.png b/3rdparty/libusb/src/doc/libusb.png
new file mode 100644
index 00000000..de69d1e2
Binary files /dev/null and b/3rdparty/libusb/src/doc/libusb.png differ
diff --git a/3rdparty/libusb/src/examples/Makefile.am b/3rdparty/libusb/src/examples/Makefile.am
new file mode 100644
index 00000000..540b0277
--- /dev/null
+++ b/3rdparty/libusb/src/examples/Makefile.am
@@ -0,0 +1,12 @@
+AM_CPPFLAGS = -I$(top_srcdir)/libusb
+LDADD = ../libusb/libusb-1.0.la
+LIBS =
+
+noinst_PROGRAMS = dpfp dpfp_threaded fxload hotplugtest listdevs sam3u_benchmark testlibusb xusb
+
+dpfp_threaded_CPPFLAGS = $(AM_CPPFLAGS) -DDPFP_THREADED
+dpfp_threaded_CFLAGS = $(AM_CFLAGS) $(THREAD_CFLAGS)
+dpfp_threaded_LDADD = $(LDADD) $(THREAD_LIBS)
+dpfp_threaded_SOURCES = dpfp.c
+
+fxload_SOURCES = ezusb.c ezusb.h fxload.c
diff --git a/3rdparty/libusb/src/examples/dpfp.c b/3rdparty/libusb/src/examples/dpfp.c
new file mode 100644
index 00000000..c06c3dd6
--- /dev/null
+++ b/3rdparty/libusb/src/examples/dpfp.c
@@ -0,0 +1,672 @@
+/*
+ * libusb example program to manipulate U.are.U 4000B fingerprint scanner.
+ * Copyright © 2007 Daniel Drake <dsd@gentoo.org>
+ * Copyright © 2016 Nathan Hjelm <hjelmn@mac.com>
+ * Copyright © 2020 Chris Dickens <christopher.a.dickens@gmail.com>
+ *
+ * Basic image capture program only, does not consider the powerup quirks or
+ * the fact that image encryption may be enabled. Not expected to work
+ * flawlessly all of the time.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <libusb/config.h>
+
+#include <errno.h>
+#include <signal.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "libusb.h"
+
+#if defined(_MSC_VER)
+#define snprintf _snprintf
+#endif
+
+#if defined(DPFP_THREADED)
+#if defined(PLATFORM_POSIX)
+#include <fcntl.h>
+#include <pthread.h>
+#include <semaphore.h>
+#include <unistd.h>
+
+#define THREAD_RETURN_VALUE NULL
+typedef sem_t    *semaphore_t;
+typedef pthread_t thread_t;
+
+static inline semaphore_t semaphore_create(void) {
+    sem_t *semaphore;
+    char   name[50];
+
+    snprintf(name, sizeof(name), "/org.libusb.example.dpfp_threaded:%d", (int)getpid());
+    semaphore = sem_open(name, O_CREAT | O_EXCL, 0, 0);
+    if(semaphore == SEM_FAILED)
+        return NULL;
+    /* Remove semaphore so that it does not persist after process exits */
+    (void)sem_unlink(name);
+    return semaphore;
+}
+
+static inline void semaphore_give(semaphore_t semaphore) {
+    (void)sem_post(semaphore);
+}
+
+static inline void semaphore_take(semaphore_t semaphore) {
+    (void)sem_wait(semaphore);
+}
+
+static inline void semaphore_destroy(semaphore_t semaphore) {
+    (void)sem_close(semaphore);
+}
+
+static inline int thread_create(thread_t *thread, void *(*thread_entry)(void *arg), void *arg) {
+    return pthread_create(thread, NULL, thread_entry, arg) == 0 ? 0 : -1;
+}
+
+static inline void thread_join(thread_t thread) {
+    (void)pthread_join(thread, NULL);
+}
+#elif defined(PLATFORM_WINDOWS)
+#define THREAD_RETURN_VALUE 0
+typedef HANDLE semaphore_t;
+typedef HANDLE thread_t;
+
+#if defined(__CYGWIN__)
+typedef DWORD  thread_return_t;
+#else
+#include <process.h>
+typedef unsigned thread_return_t;
+#endif
+
+static inline semaphore_t semaphore_create(void) {
+    return CreateSemaphore(NULL, 0, 1, NULL);
+}
+
+static inline void semaphore_give(semaphore_t semaphore) {
+    (void)ReleaseSemaphore(semaphore, 1, NULL);
+}
+
+static inline void semaphore_take(semaphore_t semaphore) {
+    (void)WaitForSingleObject(semaphore, INFINITE);
+}
+
+static inline void semaphore_destroy(semaphore_t semaphore) {
+    (void)CloseHandle(semaphore);
+}
+
+static inline int thread_create(thread_t *thread, thread_return_t(__stdcall *thread_entry)(void *arg), void *arg) {
+#if defined(__CYGWIN__)
+    *thread = CreateThread(NULL, 0, thread_entry, arg, 0, NULL);
+#else
+    *thread = (HANDLE)_beginthreadex(NULL, 0, thread_entry, arg, 0, NULL);
+#endif
+    return *thread != NULL ? 0 : -1;
+}
+
+static inline void thread_join(thread_t thread) {
+    (void)WaitForSingleObject(thread, INFINITE);
+    (void)CloseHandle(thread);
+}
+#endif
+#endif
+
+#define EP_INTR (1 | LIBUSB_ENDPOINT_IN)
+#define EP_DATA (2 | LIBUSB_ENDPOINT_IN)
+#define CTRL_IN (LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_ENDPOINT_IN)
+#define CTRL_OUT (LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_ENDPOINT_OUT)
+#define USB_RQ 0x04
+#define INTR_LENGTH 64
+
+enum {
+    MODE_INIT             = 0x00,
+    MODE_AWAIT_FINGER_ON  = 0x10,
+    MODE_AWAIT_FINGER_OFF = 0x12,
+    MODE_CAPTURE          = 0x20,
+    MODE_SHUT_UP          = 0x30,
+    MODE_READY            = 0x80,
+};
+
+static int next_state(void);
+
+enum {
+    STATE_AWAIT_MODE_CHANGE_AWAIT_FINGER_ON = 1,
+    STATE_AWAIT_IRQ_FINGER_DETECTED,
+    STATE_AWAIT_MODE_CHANGE_CAPTURE,
+    STATE_AWAIT_IMAGE,
+    STATE_AWAIT_MODE_CHANGE_AWAIT_FINGER_OFF,
+    STATE_AWAIT_IRQ_FINGER_REMOVED,
+};
+
+static int                     state = 0;
+static libusb_device_handle   *devh  = NULL;
+static unsigned char           imgbuf[0x1b340];
+static unsigned char           irqbuf[INTR_LENGTH];
+static struct libusb_transfer *img_transfer = NULL;
+static struct libusb_transfer *irq_transfer = NULL;
+static int                     img_idx      = 0;
+static volatile sig_atomic_t   do_exit      = 0;
+
+#if defined(DPFP_THREADED)
+static semaphore_t exit_semaphore;
+static thread_t    poll_thread;
+#endif
+
+static void request_exit(sig_atomic_t code) {
+    do_exit = code;
+#if defined(DPFP_THREADED)
+    semaphore_give(exit_semaphore);
+#endif
+}
+
+#if defined(DPFP_THREADED)
+#if defined(PLATFORM_POSIX)
+static void *poll_thread_main(void *arg)
+#elif defined(PLATFORM_WINDOWS)
+static thread_return_t __stdcall poll_thread_main(void *arg)
+#endif
+{
+    (void)arg;
+
+    printf("poll thread running\n");
+
+    while(!do_exit) {
+        struct timeval tv = { 1, 0 };
+        int            r;
+
+        r = libusb_handle_events_timeout(NULL, &tv);
+        if(r < 0) {
+            request_exit(2);
+            break;
+        }
+    }
+
+    printf("poll thread shutting down\n");
+    return THREAD_RETURN_VALUE;
+}
+#endif
+
+static int find_dpfp_device(void) {
+    devh = libusb_open_device_with_vid_pid(NULL, 0x05ba, 0x000a);
+    if(!devh) {
+        errno = ENODEV;
+        return -1;
+    }
+    return 0;
+}
+
+static int print_f0_data(void) {
+    unsigned char data[0x10];
+    size_t        i;
+    int           r;
+
+    r = libusb_control_transfer(devh, CTRL_IN, USB_RQ, 0xf0, 0, data, sizeof(data), 0);
+    if(r < 0) {
+        fprintf(stderr, "F0 error %d\n", r);
+        return r;
+    }
+    if(r < (int)sizeof(data)) {
+        fprintf(stderr, "short read (%d)\n", r);
+        return -1;
+    }
+
+    printf("F0 data:");
+    for(i = 0; i < sizeof(data); i++)
+        printf(" %02x", data[i]);
+    printf("\n");
+    return 0;
+}
+
+static int get_hwstat(unsigned char *status) {
+    int r;
+
+    r = libusb_control_transfer(devh, CTRL_IN, USB_RQ, 0x07, 0, status, 1, 0);
+    if(r < 0) {
+        fprintf(stderr, "read hwstat error %d\n", r);
+        return r;
+    }
+    if(r < 1) {
+        fprintf(stderr, "short read (%d)\n", r);
+        return -1;
+    }
+
+    printf("hwstat reads %02x\n", *status);
+    return 0;
+}
+
+static int set_hwstat(unsigned char data) {
+    int r;
+
+    printf("set hwstat to %02x\n", data);
+    r = libusb_control_transfer(devh, CTRL_OUT, USB_RQ, 0x07, 0, &data, 1, 0);
+    if(r < 0) {
+        fprintf(stderr, "set hwstat error %d\n", r);
+        return r;
+    }
+    if(r < 1) {
+        fprintf(stderr, "short write (%d)\n", r);
+        return -1;
+    }
+
+    return 0;
+}
+
+static int set_mode(unsigned char data) {
+    int r;
+
+    printf("set mode %02x\n", data);
+    r = libusb_control_transfer(devh, CTRL_OUT, USB_RQ, 0x4e, 0, &data, 1, 0);
+    if(r < 0) {
+        fprintf(stderr, "set mode error %d\n", r);
+        return r;
+    }
+    if(r < 1) {
+        fprintf(stderr, "short write (%d)\n", r);
+        return -1;
+    }
+
+    return 0;
+}
+
+static void LIBUSB_CALL cb_mode_changed(struct libusb_transfer *transfer) {
+    if(transfer->status != LIBUSB_TRANSFER_COMPLETED) {
+        fprintf(stderr, "mode change transfer not completed!\n");
+        request_exit(2);
+    }
+
+    printf("async cb_mode_changed length=%d actual_length=%d\n", transfer->length, transfer->actual_length);
+    if(next_state() < 0)
+        request_exit(2);
+}
+
+static int set_mode_async(unsigned char data) {
+    unsigned char          *buf = malloc(LIBUSB_CONTROL_SETUP_SIZE + 1);
+    struct libusb_transfer *transfer;
+
+    if(!buf) {
+        errno = ENOMEM;
+        return -1;
+    }
+
+    transfer = libusb_alloc_transfer(0);
+    if(!transfer) {
+        free(buf);
+        errno = ENOMEM;
+        return -1;
+    }
+
+    printf("async set mode %02x\n", data);
+    libusb_fill_control_setup(buf, CTRL_OUT, USB_RQ, 0x4e, 0, 1);
+    buf[LIBUSB_CONTROL_SETUP_SIZE] = data;
+    libusb_fill_control_transfer(transfer, devh, buf, cb_mode_changed, NULL, 1000);
+
+    transfer->flags = LIBUSB_TRANSFER_SHORT_NOT_OK | LIBUSB_TRANSFER_FREE_BUFFER | LIBUSB_TRANSFER_FREE_TRANSFER;
+    return libusb_submit_transfer(transfer);
+}
+
+static int do_sync_intr(unsigned char *data) {
+    int r;
+    int transferred;
+
+    r = libusb_interrupt_transfer(devh, EP_INTR, data, INTR_LENGTH, &transferred, 1000);
+    if(r < 0) {
+        fprintf(stderr, "intr error %d\n", r);
+        return r;
+    }
+    if(transferred < INTR_LENGTH) {
+        fprintf(stderr, "short read (%d)\n", r);
+        return -1;
+    }
+
+    printf("recv interrupt %04x\n", *((uint16_t *)data));
+    return 0;
+}
+
+static int sync_intr(unsigned char type) {
+    int           r;
+    unsigned char data[INTR_LENGTH];
+
+    while(1) {
+        r = do_sync_intr(data);
+        if(r < 0)
+            return r;
+        if(data[0] == type)
+            return 0;
+    }
+}
+
+static int save_to_file(unsigned char *data) {
+    FILE *f;
+    char  filename[64];
+
+    snprintf(filename, sizeof(filename), "finger%d.pgm", img_idx++);
+    f = fopen(filename, "w");
+    if(!f)
+        return -1;
+
+    fputs("P5 384 289 255 ", f);
+    (void)fwrite(data + 64, 1, 384 * 289, f);
+    fclose(f);
+    printf("saved image to %s\n", filename);
+    return 0;
+}
+
+static int next_state(void) {
+    int r = 0;
+
+    printf("old state: %d\n", state);
+    switch(state) {
+    case STATE_AWAIT_IRQ_FINGER_REMOVED:
+        state = STATE_AWAIT_MODE_CHANGE_AWAIT_FINGER_ON;
+        r     = set_mode_async(MODE_AWAIT_FINGER_ON);
+        break;
+    case STATE_AWAIT_MODE_CHANGE_AWAIT_FINGER_ON:
+        state = STATE_AWAIT_IRQ_FINGER_DETECTED;
+        break;
+    case STATE_AWAIT_IRQ_FINGER_DETECTED:
+        state = STATE_AWAIT_MODE_CHANGE_CAPTURE;
+        r     = set_mode_async(MODE_CAPTURE);
+        break;
+    case STATE_AWAIT_MODE_CHANGE_CAPTURE:
+        state = STATE_AWAIT_IMAGE;
+        break;
+    case STATE_AWAIT_IMAGE:
+        state = STATE_AWAIT_MODE_CHANGE_AWAIT_FINGER_OFF;
+        r     = set_mode_async(MODE_AWAIT_FINGER_OFF);
+        break;
+    case STATE_AWAIT_MODE_CHANGE_AWAIT_FINGER_OFF:
+        state = STATE_AWAIT_IRQ_FINGER_REMOVED;
+        break;
+    default:
+        printf("unrecognised state %d\n", state);
+    }
+    if(r < 0) {
+        fprintf(stderr, "error detected changing state\n");
+        return r;
+    }
+
+    printf("new state: %d\n", state);
+    return 0;
+}
+
+static void LIBUSB_CALL cb_irq(struct libusb_transfer *transfer) {
+    unsigned char irqtype = transfer->buffer[0];
+
+    if(transfer->status != LIBUSB_TRANSFER_COMPLETED) {
+        fprintf(stderr, "irq transfer status %d?\n", transfer->status);
+        goto err_free_transfer;
+    }
+
+    printf("IRQ callback %02x\n", irqtype);
+    switch(state) {
+    case STATE_AWAIT_IRQ_FINGER_DETECTED:
+        if(irqtype == 0x01) {
+            if(next_state() < 0)
+                goto err_free_transfer;
+        }
+        else {
+            printf("finger-on-sensor detected in wrong state!\n");
+        }
+        break;
+    case STATE_AWAIT_IRQ_FINGER_REMOVED:
+        if(irqtype == 0x02) {
+            if(next_state() < 0)
+                goto err_free_transfer;
+        }
+        else {
+            printf("finger-on-sensor detected in wrong state!\n");
+        }
+        break;
+    }
+    if(libusb_submit_transfer(irq_transfer) < 0)
+        goto err_free_transfer;
+
+    return;
+
+err_free_transfer:
+    libusb_free_transfer(transfer);
+    irq_transfer = NULL;
+    request_exit(2);
+}
+
+static void LIBUSB_CALL cb_img(struct libusb_transfer *transfer) {
+    if(transfer->status != LIBUSB_TRANSFER_COMPLETED) {
+        fprintf(stderr, "img transfer status %d?\n", transfer->status);
+        goto err_free_transfer;
+    }
+
+    printf("Image callback\n");
+    save_to_file(imgbuf);
+    if(next_state() < 0)
+        goto err_free_transfer;
+
+    if(libusb_submit_transfer(img_transfer) < 0)
+        goto err_free_transfer;
+
+    return;
+
+err_free_transfer:
+    libusb_free_transfer(transfer);
+    img_transfer = NULL;
+    request_exit(2);
+}
+
+static int init_capture(void) {
+    int r;
+
+    r = libusb_submit_transfer(irq_transfer);
+    if(r < 0)
+        return r;
+
+    r = libusb_submit_transfer(img_transfer);
+    if(r < 0) {
+        libusb_cancel_transfer(irq_transfer);
+        while(irq_transfer)
+            if(libusb_handle_events(NULL) < 0)
+                break;
+        return r;
+    }
+
+    /* start state machine */
+    state = STATE_AWAIT_IRQ_FINGER_REMOVED;
+    return next_state();
+}
+
+static int do_init(void) {
+    unsigned char status;
+    int           r;
+
+    r = get_hwstat(&status);
+    if(r < 0)
+        return r;
+
+    if(!(status & 0x80)) {
+        r = set_hwstat(status | 0x80);
+        if(r < 0)
+            return r;
+        r = get_hwstat(&status);
+        if(r < 0)
+            return r;
+    }
+
+    status &= ~0x80;
+    r = set_hwstat(status);
+    if(r < 0)
+        return r;
+
+    r = get_hwstat(&status);
+    if(r < 0)
+        return r;
+
+    r = sync_intr(0x56);
+    if(r < 0)
+        return r;
+
+    return 0;
+}
+
+static int alloc_transfers(void) {
+    img_transfer = libusb_alloc_transfer(0);
+    if(!img_transfer) {
+        errno = ENOMEM;
+        return -1;
+    }
+
+    irq_transfer = libusb_alloc_transfer(0);
+    if(!irq_transfer) {
+        errno = ENOMEM;
+        return -1;
+    }
+
+    libusb_fill_bulk_transfer(img_transfer, devh, EP_DATA, imgbuf, sizeof(imgbuf), cb_img, NULL, 0);
+    libusb_fill_interrupt_transfer(irq_transfer, devh, EP_INTR, irqbuf, sizeof(irqbuf), cb_irq, NULL, 0);
+
+    return 0;
+}
+
+static void sighandler(int signum) {
+    (void)signum;
+
+    request_exit(1);
+}
+
+static void setup_signals(void) {
+#if defined(PLATFORM_POSIX)
+    struct sigaction sigact;
+
+    sigact.sa_handler = sighandler;
+    sigemptyset(&sigact.sa_mask);
+    sigact.sa_flags = 0;
+    (void)sigaction(SIGINT, &sigact, NULL);
+    (void)sigaction(SIGTERM, &sigact, NULL);
+    (void)sigaction(SIGQUIT, &sigact, NULL);
+#else
+    (void)signal(SIGINT, sighandler);
+    (void)signal(SIGTERM, sighandler);
+#endif
+}
+
+int main(void) {
+    int r;
+
+    r = libusb_init_context(/*ctx=*/NULL, /*options=*/NULL, /*num_options=*/0);
+    if(r < 0) {
+        fprintf(stderr, "failed to initialise libusb %d - %s\n", r, libusb_strerror(r));
+        exit(1);
+    }
+
+    r = find_dpfp_device();
+    if(r < 0) {
+        fprintf(stderr, "Could not find/open device\n");
+        goto out;
+    }
+
+    r = libusb_claim_interface(devh, 0);
+    if(r < 0) {
+        fprintf(stderr, "claim interface error %d - %s\n", r, libusb_strerror(r));
+        goto out;
+    }
+    printf("claimed interface\n");
+
+    r = print_f0_data();
+    if(r < 0)
+        goto out_release;
+
+    r = do_init();
+    if(r < 0)
+        goto out_deinit;
+
+    /* async from here onwards */
+    setup_signals();
+
+    r = alloc_transfers();
+    if(r < 0)
+        goto out_deinit;
+
+#if defined(DPFP_THREADED)
+    exit_semaphore = semaphore_create();
+    if(!exit_semaphore) {
+        fprintf(stderr, "failed to initialise semaphore\n");
+        goto out_deinit;
+    }
+
+    r = thread_create(&poll_thread, poll_thread_main, NULL);
+    if(r) {
+        semaphore_destroy(exit_semaphore);
+        goto out_deinit;
+    }
+
+    r = init_capture();
+    if(r < 0)
+        request_exit(2);
+
+    while(!do_exit)
+        semaphore_take(exit_semaphore);
+#else
+    r = init_capture();
+    if(r < 0)
+        goto out_deinit;
+
+    while(!do_exit) {
+        r = libusb_handle_events(NULL);
+        if(r < 0)
+            request_exit(2);
+    }
+#endif
+
+    printf("shutting down...\n");
+
+#if defined(DPFP_THREADED)
+    thread_join(poll_thread);
+    semaphore_destroy(exit_semaphore);
+#endif
+
+    if(img_transfer) {
+        r = libusb_cancel_transfer(img_transfer);
+        if(r < 0)
+            fprintf(stderr, "failed to cancel transfer %d - %s\n", r, libusb_strerror(r));
+    }
+
+    if(irq_transfer) {
+        r = libusb_cancel_transfer(irq_transfer);
+        if(r < 0)
+            fprintf(stderr, "failed to cancel transfer %d - %s\n", r, libusb_strerror(r));
+    }
+
+    while(img_transfer || irq_transfer) {
+        if(libusb_handle_events(NULL) < 0)
+            break;
+    }
+
+    if(do_exit == 1)
+        r = 0;
+    else
+        r = 1;
+
+out_deinit:
+    if(img_transfer)
+        libusb_free_transfer(img_transfer);
+    if(irq_transfer)
+        libusb_free_transfer(irq_transfer);
+    set_mode(0);
+    set_hwstat(0x80);
+out_release:
+    libusb_release_interface(devh, 0);
+out:
+    libusb_close(devh);
+    libusb_exit(NULL);
+    return r >= 0 ? r : -r;
+}
diff --git a/3rdparty/libusb/src/examples/ezusb.c b/3rdparty/libusb/src/examples/ezusb.c
new file mode 100644
index 00000000..7679dbbb
--- /dev/null
+++ b/3rdparty/libusb/src/examples/ezusb.c
@@ -0,0 +1,803 @@
+/*
+ * Copyright © 2001 Stephen Williams (steve@icarus.com)
+ * Copyright © 2001-2002 David Brownell (dbrownell@users.sourceforge.net)
+ * Copyright © 2008 Roger Williams (rawqux@users.sourceforge.net)
+ * Copyright © 2012 Pete Batard (pete@akeo.ie)
+ * Copyright © 2013 Federico Manzan (f.manzan@gmail.com)
+ *
+ *    This source code is free software; you can redistribute it
+ *    and/or modify it in source code form under the terms of the GNU
+ *    General Public License as published by the Free Software
+ *    Foundation; either version 2 of the License, or (at your option)
+ *    any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program; if not, write to the Free Software
+ *    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
+ */
+
+#include <libusb/config.h>
+
+#include <stdio.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h>
+
+#include "libusb.h"
+#include "ezusb.h"
+
+/*
+ * This file contains functions for uploading firmware into Cypress
+ * EZ-USB microcontrollers. These chips use control endpoint 0 and vendor
+ * specific commands to support writing into the on-chip SRAM. They also
+ * support writing into the CPUCS register, which is how we reset the
+ * processor after loading firmware (including the reset vector).
+ *
+ * These Cypress devices are 8-bit 8051 based microcontrollers with
+ * special support for USB I/O.  They come in several packages, and
+ * some can be set up with external memory when device costs allow.
+ * Note that the design was originally by AnchorChips, so you may find
+ * references to that vendor (which was later merged into Cypress).
+ * The Cypress FX parts are largely compatible with the Anchorhip ones.
+ */
+
+int verbose = 1;
+
+/*
+ * return true if [addr,addr+len] includes external RAM
+ * for Anchorchips EZ-USB or Cypress EZ-USB FX
+ */
+static bool fx_is_external(uint32_t addr, size_t len) {
+    /* with 8KB RAM, 0x0000-0x1b3f can be written
+     * we can't tell if it's a 4KB device here
+     */
+    if(addr <= 0x1b3f)
+        return ((addr + len) > 0x1b40);
+
+    /* there may be more RAM; unclear if we can write it.
+     * some bulk buffers may be unused, 0x1b3f-0x1f3f
+     * firmware can set ISODISAB for 2KB at 0x2000-0x27ff
+     */
+    return true;
+}
+
+/*
+ * return true if [addr,addr+len] includes external RAM
+ * for Cypress EZ-USB FX2
+ */
+static bool fx2_is_external(uint32_t addr, size_t len) {
+    /* 1st 8KB for data/code, 0x0000-0x1fff */
+    if(addr <= 0x1fff)
+        return ((addr + len) > 0x2000);
+
+    /* and 512 for data, 0xe000-0xe1ff */
+    else if(addr >= 0xe000 && addr <= 0xe1ff)
+        return ((addr + len) > 0xe200);
+
+    /* otherwise, it's certainly external */
+    else
+        return true;
+}
+
+/*
+ * return true if [addr,addr+len] includes external RAM
+ * for Cypress EZ-USB FX2LP
+ */
+static bool fx2lp_is_external(uint32_t addr, size_t len) {
+    /* 1st 16KB for data/code, 0x0000-0x3fff */
+    if(addr <= 0x3fff)
+        return ((addr + len) > 0x4000);
+
+    /* and 512 for data, 0xe000-0xe1ff */
+    else if(addr >= 0xe000 && addr <= 0xe1ff)
+        return ((addr + len) > 0xe200);
+
+    /* otherwise, it's certainly external */
+    else
+        return true;
+}
+
+/*****************************************************************************/
+
+/*
+ * These are the requests (bRequest) that the bootstrap loader is expected
+ * to recognize.  The codes are reserved by Cypress, and these values match
+ * what EZ-USB hardware, or "Vend_Ax" firmware (2nd stage loader) uses.
+ * Cypress' "a3load" is nice because it supports both FX and FX2, although
+ * it doesn't have the EEPROM support (subset of "Vend_Ax").
+ */
+#define RW_INTERNAL 0xA0 /* hardware implements this one */
+#define RW_MEMORY 0xA3
+
+/*
+ * Issues the specified vendor-specific write request.
+ */
+static int ezusb_write(libusb_device_handle *device, const char *label, uint8_t opcode, uint32_t addr, const unsigned char *data, size_t len) {
+    int status;
+
+    if(verbose > 1)
+        logerror("%s, addr 0x%08x len %4u (0x%04x)\n", label, addr, (unsigned)len, (unsigned)len);
+    status = libusb_control_transfer(device, LIBUSB_ENDPOINT_OUT | LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE, opcode, addr & 0xFFFF, addr >> 16,
+                                     (unsigned char *)data, (uint16_t)len, 1000);
+    if(status != (signed)len) {
+        if(status < 0)
+            logerror("%s: %s\n", label, libusb_error_name(status));
+        else
+            logerror("%s ==> %d\n", label, status);
+    }
+    if(status < 0) {
+        errno = EIO;
+        return -1;
+    }
+    return 0;
+}
+
+/*
+ * Issues the specified vendor-specific read request.
+ */
+static int ezusb_read(libusb_device_handle *device, const char *label, uint8_t opcode, uint32_t addr, const unsigned char *data, size_t len) {
+    int status;
+
+    if(verbose > 1)
+        logerror("%s, addr 0x%08x len %4u (0x%04x)\n", label, addr, (unsigned)len, (unsigned)len);
+    status = libusb_control_transfer(device, LIBUSB_ENDPOINT_IN | LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE, opcode, addr & 0xFFFF, addr >> 16,
+                                     (unsigned char *)data, (uint16_t)len, 1000);
+    if(status != (signed)len) {
+        if(status < 0)
+            logerror("%s: %s\n", label, libusb_error_name(status));
+        else
+            logerror("%s ==> %d\n", label, status);
+    }
+    if(status < 0) {
+        errno = EIO;
+        return -1;
+    }
+    return 0;
+}
+
+/*
+ * Modifies the CPUCS register to stop or reset the CPU.
+ * Returns false on error.
+ */
+static bool ezusb_cpucs(libusb_device_handle *device, uint32_t addr, bool doRun) {
+    int     status;
+    uint8_t data = doRun ? 0x00 : 0x01;
+
+    if(verbose)
+        logerror("%s\n", data ? "stop CPU" : "reset CPU");
+    status = libusb_control_transfer(device, LIBUSB_ENDPOINT_OUT | LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE, RW_INTERNAL, addr & 0xFFFF, addr >> 16,
+                                     &data, 1, 1000);
+    if((status != 1) &&
+       /* We may get an I/O error from libusb as the device disappears */
+       ((!doRun) || (status != LIBUSB_ERROR_IO))) {
+        const char *mesg = "can't modify CPUCS";
+        if(status < 0)
+            logerror("%s: %s\n", mesg, libusb_error_name(status));
+        else
+            logerror("%s\n", mesg);
+        return false;
+    }
+    else
+        return true;
+}
+
+/*
+ * Send an FX3 jump to address command
+ * Returns false on error.
+ */
+static bool ezusb_fx3_jump(libusb_device_handle *device, uint32_t addr) {
+    int status;
+
+    if(verbose)
+        logerror("transfer execution to Program Entry at 0x%08x\n", addr);
+    status = libusb_control_transfer(device, LIBUSB_ENDPOINT_OUT | LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE, RW_INTERNAL, addr & 0xFFFF, addr >> 16,
+                                     NULL, 0, 1000);
+    /* We may get an I/O error from libusb as the device disappears */
+    if((status != 0) && (status != LIBUSB_ERROR_IO)) {
+        const char *mesg = "failed to send jump command";
+        if(status < 0)
+            logerror("%s: %s\n", mesg, libusb_error_name(status));
+        else
+            logerror("%s\n", mesg);
+        return false;
+    }
+    else
+        return true;
+}
+
+/*****************************************************************************/
+
+/*
+ * Parse an Intel HEX image file and invoke the poke() function on the
+ * various segments to implement policies such as writing to RAM (with
+ * a one or two stage loader setup, depending on the firmware) or to
+ * EEPROM (two stages required).
+ *
+ * image       - the hex image file
+ * context     - for use by poke()
+ * is_external - if non-null, used to check which segments go into
+ *               external memory (writable only by software loader)
+ * poke        - called with each memory segment; errors indicated
+ *               by returning negative values.
+ *
+ * Caller is responsible for halting CPU as needed, such as when
+ * overwriting a second stage loader.
+ */
+static int parse_ihex(FILE *image, void *context, bool (*is_external)(uint32_t addr, size_t len),
+                      int (*poke)(void *context, uint32_t addr, bool external, const unsigned char *data, size_t len)) {
+    unsigned char data[1023];
+    uint32_t      data_addr = 0;
+    size_t        data_len  = 0;
+    int           rc;
+    int           first_line = 1;
+    bool          external   = false;
+
+    /* Read the input file as an IHEX file, and report the memory segments
+     * as we go.  Each line holds a max of 16 bytes, but uploading is
+     * faster (and EEPROM space smaller) if we merge those lines into larger
+     * chunks.  Most hex files keep memory segments together, which makes
+     * such merging all but free.  (But it may still be worth sorting the
+     * hex files to make up for undesirable behavior from tools.)
+     *
+     * Note that EEPROM segments max out at 1023 bytes; the upload protocol
+     * allows segments of up to 64 KBytes (more than a loader could handle).
+     */
+    for(;;) {
+        char     buf[512], *cp;
+        char     tmp, type;
+        size_t   len;
+        unsigned idx, off;
+
+        cp = fgets(buf, sizeof(buf), image);
+        if(cp == NULL) {
+            logerror("EOF without EOF record!\n");
+            break;
+        }
+
+        /* EXTENSION: "# comment-till-end-of-line", for copyrights etc */
+        if(buf[0] == '#')
+            continue;
+
+        if(buf[0] != ':') {
+            logerror("not an ihex record: %s", buf);
+            return -2;
+        }
+
+        /* ignore any newline */
+        cp = strchr(buf, '\n');
+        if(cp)
+            *cp = 0;
+
+        if(verbose >= 3)
+            logerror("** LINE: %s\n", buf);
+
+        /* Read the length field (up to 16 bytes) */
+        tmp    = buf[3];
+        buf[3] = 0;
+        len    = strtoul(buf + 1, NULL, 16);
+        buf[3] = tmp;
+
+        /* Read the target offset (address up to 64KB) */
+        tmp    = buf[7];
+        buf[7] = 0;
+        off    = (unsigned int)strtoul(buf + 3, NULL, 16);
+        buf[7] = tmp;
+
+        /* Initialize data_addr */
+        if(first_line) {
+            data_addr  = off;
+            first_line = 0;
+        }
+
+        /* Read the record type */
+        tmp    = buf[9];
+        buf[9] = 0;
+        type   = (char)strtoul(buf + 7, NULL, 16);
+        buf[9] = tmp;
+
+        /* If this is an EOF record, then make it so. */
+        if(type == 1) {
+            if(verbose >= 2)
+                logerror("EOF on hexfile\n");
+            break;
+        }
+
+        if(type != 0) {
+            logerror("unsupported record type: %u\n", type);
+            return -3;
+        }
+
+        if((len * 2) + 11 > strlen(buf)) {
+            logerror("record too short?\n");
+            return -4;
+        }
+
+        /* FIXME check for _physically_ contiguous not just virtually
+         * e.g. on FX2 0x1f00-0x2100 includes both on-chip and external
+         * memory so it's not really contiguous */
+
+        /* flush the saved data if it's not contiguous,
+         * or when we've buffered as much as we can.
+         */
+        if(data_len != 0
+           && (off != (data_addr + data_len)
+               /* || !merge */
+               || (data_len + len) > sizeof(data))) {
+            if(is_external)
+                external = is_external(data_addr, data_len);
+            rc = poke(context, data_addr, external, data, data_len);
+            if(rc < 0)
+                return -1;
+            data_addr = off;
+            data_len  = 0;
+        }
+
+        /* append to saved data, flush later */
+        for(idx = 0, cp = buf + 9; idx < len; idx += 1, cp += 2) {
+            tmp                  = cp[2];
+            cp[2]                = 0;
+            data[data_len + idx] = (uint8_t)strtoul(cp, NULL, 16);
+            cp[2]                = tmp;
+        }
+        data_len += len;
+    }
+
+    /* flush any data remaining */
+    if(data_len != 0) {
+        if(is_external)
+            external = is_external(data_addr, data_len);
+        rc = poke(context, data_addr, external, data, data_len);
+        if(rc < 0)
+            return -1;
+    }
+    return 0;
+}
+
+/*
+ * Parse a binary image file and write it as is to the target.
+ * Applies to Cypress BIX images for RAM or Cypress IIC images
+ * for EEPROM.
+ *
+ * image       - the BIX image file
+ * context     - for use by poke()
+ * is_external - if non-null, used to check which segments go into
+ *               external memory (writable only by software loader)
+ * poke        - called with each memory segment; errors indicated
+ *               by returning negative values.
+ *
+ * Caller is responsible for halting CPU as needed, such as when
+ * overwriting a second stage loader.
+ */
+static int parse_bin(FILE *image, void *context, bool (*is_external)(uint32_t addr, size_t len),
+                     int (*poke)(void *context, uint32_t addr, bool external, const unsigned char *data, size_t len)) {
+    unsigned char data[4096];
+    uint32_t      data_addr = 0;
+    size_t        data_len  = 0;
+    int           rc;
+    bool          external = false;
+
+    for(;;) {
+        data_len = fread(data, 1, 4096, image);
+        if(data_len == 0)
+            break;
+        if(is_external)
+            external = is_external(data_addr, data_len);
+        rc = poke(context, data_addr, external, data, data_len);
+        if(rc < 0)
+            return -1;
+        data_addr += (uint32_t)data_len;
+    }
+    return feof(image) ? 0 : -1;
+}
+
+/*
+ * Parse a Cypress IIC image file and invoke the poke() function on the
+ * various segments for writing to RAM
+ *
+ * image       - the IIC image file
+ * context     - for use by poke()
+ * is_external - if non-null, used to check which segments go into
+ *               external memory (writable only by software loader)
+ * poke        - called with each memory segment; errors indicated
+ *               by returning negative values.
+ *
+ * Caller is responsible for halting CPU as needed, such as when
+ * overwriting a second stage loader.
+ */
+static int parse_iic(FILE *image, void *context, bool (*is_external)(uint32_t addr, size_t len),
+                     int (*poke)(void *context, uint32_t addr, bool external, const unsigned char *data, size_t len)) {
+    unsigned char data[4096];
+    uint32_t      data_addr = 0;
+    size_t        data_len  = 0, read_len;
+    uint8_t       block_header[4];
+    int           rc;
+    bool          external = false;
+    long          file_size, initial_pos;
+
+    initial_pos = ftell(image);
+    if(initial_pos < 0)
+        return -1;
+
+    if(fseek(image, 0L, SEEK_END) != 0)
+        return -1;
+    file_size = ftell(image);
+    if(fseek(image, initial_pos, SEEK_SET) != 0)
+        return -1;
+    for(;;) {
+        /* Ignore the trailing reset IIC data (5 bytes) */
+        if(ftell(image) >= (file_size - 5))
+            break;
+        if(fread(&block_header, 1, sizeof(block_header), image) != 4) {
+            logerror("unable to read IIC block header\n");
+            return -1;
+        }
+        data_len  = (block_header[0] << 8) + block_header[1];
+        data_addr = (block_header[2] << 8) + block_header[3];
+        if(data_len > sizeof(data)) {
+            /* If this is ever reported as an error, switch to using malloc/realloc */
+            logerror("IIC data block too small - please report this error to libusb.info\n");
+            return -1;
+        }
+        read_len = fread(data, 1, data_len, image);
+        if(read_len != data_len) {
+            logerror("read error\n");
+            return -1;
+        }
+        if(is_external)
+            external = is_external(data_addr, data_len);
+        rc = poke(context, data_addr, external, data, data_len);
+        if(rc < 0)
+            return -1;
+    }
+    return 0;
+}
+
+/* the parse call will be selected according to the image type */
+static int (*parse[IMG_TYPE_MAX])(FILE *image, void *context, bool (*is_external)(uint32_t addr, size_t len),
+                                  int (*poke)(void *context, uint32_t addr, bool external, const unsigned char *data, size_t len)) = { parse_ihex, parse_iic,
+                                                                                                                                       parse_bin };
+
+/*****************************************************************************/
+
+/*
+ * For writing to RAM using a first (hardware) or second (software)
+ * stage loader and 0xA0 or 0xA3 vendor requests
+ */
+typedef enum {
+    _undef = 0,
+    internal_only, /* hardware first-stage loader */
+    skip_internal, /* first phase, second-stage loader */
+    skip_external  /* second phase, second-stage loader */
+} ram_mode;
+
+struct ram_poke_context {
+    libusb_device_handle *device;
+    ram_mode              mode;
+    size_t                total, count;
+};
+
+#define RETRY_LIMIT 5
+
+static int ram_poke(void *context, uint32_t addr, bool external, const unsigned char *data, size_t len) {
+    struct ram_poke_context *ctx = (struct ram_poke_context *)context;
+    int                      rc;
+    unsigned                 retry = 0;
+
+    switch(ctx->mode) {
+    case internal_only: /* CPU should be stopped */
+        if(external) {
+            logerror("can't write %u bytes external memory at 0x%08x\n", (unsigned)len, addr);
+            errno = EINVAL;
+            return -1;
+        }
+        break;
+    case skip_internal: /* CPU must be running */
+        if(!external) {
+            if(verbose >= 2) {
+                logerror("SKIP on-chip RAM, %u bytes at 0x%08x\n", (unsigned)len, addr);
+            }
+            return 0;
+        }
+        break;
+    case skip_external: /* CPU should be stopped */
+        if(external) {
+            if(verbose >= 2) {
+                logerror("SKIP external RAM, %u bytes at 0x%08x\n", (unsigned)len, addr);
+            }
+            return 0;
+        }
+        break;
+    case _undef:
+    default:
+        logerror("bug\n");
+        errno = EDOM;
+        return -1;
+    }
+
+    ctx->total += len;
+    ctx->count++;
+
+    /* Retry this till we get a real error. Control messages are not
+     * NAKed (just dropped) so time out means is a real problem.
+     */
+    while((rc = ezusb_write(ctx->device, external ? "write external" : "write on-chip", external ? RW_MEMORY : RW_INTERNAL, addr, data, len)) < 0
+          && retry < RETRY_LIMIT) {
+        if(rc != LIBUSB_ERROR_TIMEOUT)
+            break;
+        retry += 1;
+    }
+    return rc;
+}
+
+/*
+ * Load a Cypress Image file into target RAM.
+ * See http://www.cypress.com/?docID=41351 (AN76405 PDF) for more info.
+ */
+static int fx3_load_ram(libusb_device_handle *device, const char *path) {
+    uint32_t       dCheckSum, dExpectedCheckSum, dAddress, i, dLen, dLength;
+    uint32_t      *dImageBuf;
+    unsigned char *bBuf, hBuf[4], blBuf[4], rBuf[4096];
+    FILE          *image;
+    int            ret = 0;
+
+    image = fopen(path, "rb");
+    if(image == NULL) {
+        logerror("unable to open '%s' for input\n", path);
+        return -2;
+    }
+    else if(verbose)
+        logerror("open firmware image %s for RAM upload\n", path);
+
+    // Read header
+    if(fread(hBuf, sizeof(char), sizeof(hBuf), image) != sizeof(hBuf)) {
+        logerror("could not read image header");
+        ret = -3;
+        goto exit;
+    }
+
+    // check "CY" signature byte and format
+    if((hBuf[0] != 'C') || (hBuf[1] != 'Y')) {
+        logerror("image doesn't have a CYpress signature\n");
+        ret = -3;
+        goto exit;
+    }
+
+    // Check bImageType
+    switch(hBuf[3]) {
+    case 0xB0:
+        if(verbose)
+            logerror("normal FW binary %s image with checksum\n", (hBuf[2] & 0x01) ? "data" : "executable");
+        break;
+    case 0xB1:
+        logerror("security binary image is not currently supported\n");
+        ret = -3;
+        goto exit;
+    case 0xB2:
+        logerror("VID:PID image is not currently supported\n");
+        ret = -3;
+        goto exit;
+    default:
+        logerror("invalid image type 0x%02X\n", hBuf[3]);
+        ret = -3;
+        goto exit;
+    }
+
+    // Read the bootloader version
+    if(verbose) {
+        if((ezusb_read(device, "read bootloader version", RW_INTERNAL, 0xFFFF0020, blBuf, 4) < 0)) {
+            logerror("Could not read bootloader version\n");
+            ret = -8;
+            goto exit;
+        }
+        logerror("FX3 bootloader version: 0x%02X%02X%02X%02X\n", blBuf[3], blBuf[2], blBuf[1], blBuf[0]);
+    }
+
+    dCheckSum = 0;
+    if(verbose)
+        logerror("writing image...\n");
+    while(1) {
+        if((fread(&dLength, sizeof(uint32_t), 1, image) != 1) ||   // read dLength
+           (fread(&dAddress, sizeof(uint32_t), 1, image) != 1)) {  // read dAddress
+            logerror("could not read image");
+            ret = -3;
+            goto exit;
+        }
+        if(dLength == 0)
+            break;  // done
+
+        // coverity[tainted_data]
+        dImageBuf = (uint32_t *)calloc(dLength, sizeof(uint32_t));
+        if(dImageBuf == NULL) {
+            logerror("could not allocate buffer for image chunk\n");
+            ret = -4;
+            goto exit;
+        }
+
+        // read sections
+        if(fread(dImageBuf, sizeof(uint32_t), dLength, image) != dLength) {
+            logerror("could not read image");
+            free(dImageBuf);
+            ret = -3;
+            goto exit;
+        }
+        for(i = 0; i < dLength; i++)
+            dCheckSum += dImageBuf[i];
+        dLength <<= 2;  // convert to Byte length
+        bBuf = (unsigned char *)dImageBuf;
+
+        while(dLength > 0) {
+            dLen = 4096;  // 4K max
+            if(dLen > dLength)
+                dLen = dLength;
+            if((ezusb_write(device, "write firmware", RW_INTERNAL, dAddress, bBuf, dLen) < 0)
+               || (ezusb_read(device, "read firmware", RW_INTERNAL, dAddress, rBuf, dLen) < 0)) {
+                logerror("R/W error\n");
+                free(dImageBuf);
+                ret = -5;
+                goto exit;
+            }
+            // Verify data: rBuf with bBuf
+            for(i = 0; i < dLen; i++) {
+                if(rBuf[i] != bBuf[i]) {
+                    logerror("verify error");
+                    free(dImageBuf);
+                    ret = -6;
+                    goto exit;
+                }
+            }
+
+            dLength -= dLen;
+            bBuf += dLen;
+            dAddress += dLen;
+        }
+        free(dImageBuf);
+    }
+
+    // read pre-computed checksum data
+    if((fread(&dExpectedCheckSum, sizeof(uint32_t), 1, image) != 1) || (dCheckSum != dExpectedCheckSum)) {
+        logerror("checksum error\n");
+        ret = -7;
+        goto exit;
+    }
+
+    // transfer execution to Program Entry
+    if(!ezusb_fx3_jump(device, dAddress)) {
+        ret = -6;
+    }
+
+exit:
+    fclose(image);
+    return ret;
+}
+
+/*
+ * Load a firmware file into target RAM. device is the open libusb
+ * device, and the path is the name of the source file. Open the file,
+ * parse the bytes, and write them in one or two phases.
+ *
+ * If stage == 0, this uses the first stage loader, built into EZ-USB
+ * hardware but limited to writing on-chip memory or CPUCS.  Everything
+ * is written during one stage, unless there's an error such as the image
+ * holding data that needs to be written to external memory.
+ *
+ * Otherwise, things are written in two stages.  First the external
+ * memory is written, expecting a second stage loader to have already
+ * been loaded.  Then file is re-parsed and on-chip memory is written.
+ */
+int ezusb_load_ram(libusb_device_handle *device, const char *path, int fx_type, int img_type, int stage) {
+    FILE    *image;
+    uint32_t cpucs_addr;
+    bool (*is_external)(uint32_t off, size_t len);
+    struct ram_poke_context ctx;
+    int                     status;
+    uint8_t                 iic_header[8] = { 0 };
+    int                     ret           = 0;
+
+    if(fx_type == FX_TYPE_FX3)
+        return fx3_load_ram(device, path);
+
+    image = fopen(path, "rb");
+    if(image == NULL) {
+        logerror("%s: unable to open for input.\n", path);
+        return -2;
+    }
+    else if(verbose > 1)
+        logerror("open firmware image %s for RAM upload\n", path);
+
+    if(img_type == IMG_TYPE_IIC) {
+        if((fread(iic_header, 1, sizeof(iic_header), image) != sizeof(iic_header))
+           || (((fx_type == FX_TYPE_FX2LP) || (fx_type == FX_TYPE_FX2)) && (iic_header[0] != 0xC2)) || ((fx_type == FX_TYPE_AN21) && (iic_header[0] != 0xB2))
+           || ((fx_type == FX_TYPE_FX1) && (iic_header[0] != 0xB6))) {
+            logerror("IIC image does not contain executable code - cannot load to RAM.\n");
+            ret = -1;
+            goto exit;
+        }
+    }
+
+    /* EZ-USB original/FX and FX2 devices differ, apart from the 8051 core */
+    switch(fx_type) {
+    case FX_TYPE_FX2LP:
+        cpucs_addr  = 0xe600;
+        is_external = fx2lp_is_external;
+        break;
+    case FX_TYPE_FX2:
+        cpucs_addr  = 0xe600;
+        is_external = fx2_is_external;
+        break;
+    default:
+        cpucs_addr  = 0x7f92;
+        is_external = fx_is_external;
+        break;
+    }
+
+    /* use only first stage loader? */
+    if(stage == 0) {
+        ctx.mode = internal_only;
+
+        /* if required, halt the CPU while we overwrite its code/data */
+        if(cpucs_addr && !ezusb_cpucs(device, cpucs_addr, false)) {
+            ret = -1;
+            goto exit;
+        }
+
+        /* 2nd stage, first part? loader was already uploaded */
+    }
+    else {
+        ctx.mode = skip_internal;
+
+        /* let CPU run; overwrite the 2nd stage loader later */
+        if(verbose)
+            logerror("2nd stage: write external memory\n");
+    }
+
+    /* scan the image, first (maybe only) time */
+    ctx.device = device;
+    ctx.total = ctx.count = 0;
+    status                = parse[img_type](image, &ctx, is_external, ram_poke);
+    if(status < 0) {
+        logerror("unable to upload %s\n", path);
+        ret = status;
+        goto exit;
+    }
+
+    /* second part of 2nd stage: rescan */
+    // TODO: what should we do for non HEX images there?
+    if(stage) {
+        ctx.mode = skip_external;
+
+        /* if needed, halt the CPU while we overwrite the 1st stage loader */
+        if(cpucs_addr && !ezusb_cpucs(device, cpucs_addr, false)) {
+            ret = -1;
+            goto exit;
+        }
+
+        /* at least write the interrupt vectors (at 0x0000) for reset! */
+        rewind(image);
+        if(verbose)
+            logerror("2nd stage: write on-chip memory\n");
+        status = parse_ihex(image, &ctx, is_external, ram_poke);
+        if(status < 0) {
+            logerror("unable to completely upload %s\n", path);
+            ret = status;
+            goto exit;
+        }
+    }
+
+    if(verbose && (ctx.count != 0)) {
+        logerror("... WROTE: %d bytes, %d segments, avg %d\n", (int)ctx.total, (int)ctx.count, (int)(ctx.total / ctx.count));
+    }
+
+    /* if required, reset the CPU so it runs what we just uploaded */
+    if(cpucs_addr && !ezusb_cpucs(device, cpucs_addr, true))
+        ret = -1;
+
+exit:
+    fclose(image);
+    return ret;
+}
diff --git a/3rdparty/libusb/src/examples/ezusb.h b/3rdparty/libusb/src/examples/ezusb.h
new file mode 100644
index 00000000..f0fba3ef
--- /dev/null
+++ b/3rdparty/libusb/src/examples/ezusb.h
@@ -0,0 +1,104 @@
+#ifndef ezusb_H
+#define ezusb_H
+/*
+ * Copyright © 2001 Stephen Williams (steve@icarus.com)
+ * Copyright © 2002 David Brownell (dbrownell@users.sourceforge.net)
+ * Copyright © 2013 Federico Manzan (f.manzan@gmail.com)
+ *
+ *    This source code is free software; you can redistribute it
+ *    and/or modify it in source code form under the terms of the GNU
+ *    General Public License as published by the Free Software
+ *    Foundation; either version 2 of the License, or (at your option)
+ *    any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program; if not, write to the Free Software
+ *    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
+ */
+
+#include <libusb/config.h>
+
+#include <stdbool.h>
+
+#define FX_TYPE_UNDEFINED -1
+#define FX_TYPE_AN21 0  /* Original AnchorChips parts */
+#define FX_TYPE_FX1 1   /* Updated Cypress versions */
+#define FX_TYPE_FX2 2   /* USB 2.0 versions */
+#define FX_TYPE_FX2LP 3 /* Updated FX2 */
+#define FX_TYPE_FX3 4   /* USB 3.0 versions */
+#define FX_TYPE_MAX 5
+#define FX_TYPE_NAMES \
+    { "an21", "fx", "fx2", "fx2lp", "fx3" }
+
+#define IMG_TYPE_UNDEFINED -1
+#define IMG_TYPE_HEX 0 /* Intel HEX */
+#define IMG_TYPE_IIC 1 /* Cypress 8051 IIC */
+#define IMG_TYPE_BIX 2 /* Cypress 8051 BIX */
+#define IMG_TYPE_IMG 3 /* Cypress IMG format */
+#define IMG_TYPE_MAX 4
+#define IMG_TYPE_NAMES \
+    { "Intel HEX", "Cypress 8051 IIC", "Cypress 8051 BIX", "Cypress IMG format" }
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * Automatically identified devices (VID, PID, type, designation).
+ * TODO: Could use some validation. Also where's the FX2?
+ */
+typedef struct {
+    uint16_t    vid;
+    uint16_t    pid;
+    int         type;
+    const char *designation;
+} fx_known_device;
+
+#define FX_KNOWN_DEVICES                                                                                                                             \
+    {                                                                                                                                                \
+        { 0x0547, 0x2122, FX_TYPE_AN21, "Cypress EZ-USB (2122S)" }, { 0x0547, 0x2125, FX_TYPE_AN21, "Cypress EZ-USB (2121S/2125S)" },                \
+            { 0x0547, 0x2126, FX_TYPE_AN21, "Cypress EZ-USB (2126S)" }, { 0x0547, 0x2131, FX_TYPE_AN21, "Cypress EZ-USB (2131Q/2131S/2135S)" },      \
+            { 0x0547, 0x2136, FX_TYPE_AN21, "Cypress EZ-USB (2136S)" }, { 0x0547, 0x2225, FX_TYPE_AN21, "Cypress EZ-USB (2225)" },                   \
+            { 0x0547, 0x2226, FX_TYPE_AN21, "Cypress EZ-USB (2226)" }, { 0x0547, 0x2235, FX_TYPE_AN21, "Cypress EZ-USB (2235)" },                    \
+            { 0x0547, 0x2236, FX_TYPE_AN21, "Cypress EZ-USB (2236)" }, { 0x04b4, 0x6473, FX_TYPE_FX1, "Cypress EZ-USB FX1" },                        \
+            { 0x04b4, 0x8613, FX_TYPE_FX2LP, "Cypress EZ-USB FX2LP (68013A/68014A/68015A/68016A)" }, { 0x04b4, 0x00f3, FX_TYPE_FX3, "Cypress FX3" }, \
+    }
+
+/*
+ * This function uploads the firmware from the given file into RAM.
+ * Stage == 0 means this is a single stage load (or the first of
+ * two stages).  Otherwise it's the second of two stages; the
+ * caller having preloaded the second stage loader.
+ *
+ * The target processor is reset at the end of this upload.
+ */
+extern int ezusb_load_ram(libusb_device_handle *device, const char *path, int fx_type, int img_type, int stage);
+
+/*
+ * This function uploads the firmware from the given file into EEPROM.
+ * This uses the right CPUCS address to terminate the EEPROM load with
+ * a reset command where FX parts behave differently than FX2 ones.
+ * The configuration byte is as provided here (zero for an21xx parts)
+ * and the EEPROM type is set so that the microcontroller will boot
+ * from it.
+ *
+ * The caller must have preloaded a second stage loader that knows
+ * how to respond to the EEPROM write request.
+ */
+extern int ezusb_load_eeprom(libusb_device_handle *device, const char *path, int fx_type, int img_type, int config);
+
+/* Verbosity level (default 1). Can be increased or decreased with options v/q  */
+extern int verbose;
+
+extern void logerror(const char *format, ...) PRINTF_FORMAT(1, 2);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/3rdparty/libusb/src/examples/fxload.c b/3rdparty/libusb/src/examples/fxload.c
new file mode 100644
index 00000000..c737ccca
--- /dev/null
+++ b/3rdparty/libusb/src/examples/fxload.c
@@ -0,0 +1,305 @@
+/*
+ * Copyright © 2001 Stephen Williams (steve@icarus.com)
+ * Copyright © 2001-2002 David Brownell (dbrownell@users.sourceforge.net)
+ * Copyright © 2008 Roger Williams (rawqux@users.sourceforge.net)
+ * Copyright © 2012 Pete Batard (pete@akeo.ie)
+ * Copyright © 2013 Federico Manzan (f.manzan@gmail.com)
+ *
+ *    This source code is free software; you can redistribute it
+ *    and/or modify it in source code form under the terms of the GNU
+ *    General Public License as published by the Free Software
+ *    Foundation; either version 2 of the License, or (at your option)
+ *    any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program; if not, write to the Free Software
+ *    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
+ */
+
+#include <libusb/config.h>
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdint.h>
+#include <stdarg.h>
+#include <sys/types.h>
+#include <getopt.h>
+
+#include "libusb.h"
+#include "ezusb.h"
+
+#if !defined(_WIN32) || defined(__CYGWIN__)
+#include <syslog.h>
+static bool dosyslog = false;
+#include <strings.h>
+#define _stricmp strcasecmp
+#endif
+
+#ifndef FXLOAD_VERSION
+#define FXLOAD_VERSION (__DATE__ " (libusb)")
+#endif
+
+#ifndef ARRAYSIZE
+#define ARRAYSIZE(A) (sizeof(A) / sizeof((A)[0]))
+#endif
+
+void logerror(const char *format, ...) {
+    va_list ap;
+    va_start(ap, format);
+
+#if !defined(_WIN32) || defined(__CYGWIN__)
+    if(dosyslog)
+        vsyslog(LOG_ERR, format, ap);
+    else
+#endif
+        vfprintf(stderr, format, ap);
+    va_end(ap);
+}
+
+static int print_usage(int error_code) {
+    fprintf(stderr, "\nUsage: fxload [-v] [-V] [-t type] [-d vid:pid] [-p bus,addr] [-s loader] -i firmware\n");
+    fprintf(stderr, "  -i <path>       -- Firmware to upload\n");
+    fprintf(stderr, "  -s <path>       -- Second stage loader\n");
+    fprintf(stderr, "  -t <type>       -- Target type: an21, fx, fx2, fx2lp, fx3\n");
+    fprintf(stderr, "  -d <vid:pid>    -- Target device, as an USB VID:PID\n");
+    fprintf(stderr, "  -p <bus,addr>   -- Target device, as a libusb bus number and device address path\n");
+    fprintf(stderr, "  -v              -- Increase verbosity\n");
+    fprintf(stderr, "  -q              -- Decrease verbosity (silent mode)\n");
+    fprintf(stderr, "  -V              -- Print program version\n");
+    return error_code;
+}
+
+#define FIRMWARE 0
+#define LOADER 1
+int main(int argc, char *argv[]) {
+    fx_known_device                 known_device[]       = FX_KNOWN_DEVICES;
+    const char                     *path[]               = { NULL, NULL };
+    const char                     *device_id            = NULL;
+    const char                     *device_path          = getenv("DEVICE");
+    const char                     *type                 = NULL;
+    const char                     *fx_name[FX_TYPE_MAX] = FX_TYPE_NAMES;
+    const char                     *ext, *img_name[] = IMG_TYPE_NAMES;
+    int                             fx_type = FX_TYPE_UNDEFINED, img_type[ARRAYSIZE(path)];
+    int                             opt, status;
+    unsigned int                    i, j;
+    unsigned                        vid = 0, pid = 0;
+    unsigned                        busnum = 0, devaddr = 0, _busnum, _devaddr;
+    libusb_device                  *dev, **devs;
+    libusb_device_handle           *device = NULL;
+    struct libusb_device_descriptor desc;
+
+    while((opt = getopt(argc, argv, "qvV?hd:p:i:I:s:S:t:")) != EOF)
+        switch(opt) {
+
+        case 'd':
+            device_id = optarg;
+            if(sscanf(device_id, "%x:%x", &vid, &pid) != 2) {
+                fputs("please specify VID & PID as \"vid:pid\" in hexadecimal format\n", stderr);
+                return -1;
+            }
+            break;
+
+        case 'p':
+            device_path = optarg;
+            if(sscanf(device_path, "%u,%u", &busnum, &devaddr) != 2) {
+                fputs("please specify bus number & device number as \"bus,dev\" in decimal format\n", stderr);
+                return -1;
+            }
+            break;
+
+        case 'i':
+        case 'I':
+            path[FIRMWARE] = optarg;
+            break;
+
+        case 's':
+        case 'S':
+            path[LOADER] = optarg;
+            break;
+
+        case 'V':
+            puts(FXLOAD_VERSION);
+            return 0;
+
+        case 't':
+            type = optarg;
+            break;
+
+        case 'v':
+            verbose++;
+            break;
+
+        case 'q':
+            verbose--;
+            break;
+
+        case '?':
+        case 'h':
+        default:
+            return print_usage(-1);
+        }
+
+    if(path[FIRMWARE] == NULL) {
+        logerror("no firmware specified!\n");
+        return print_usage(-1);
+    }
+    if((device_id != NULL) && (device_path != NULL)) {
+        logerror("only one of -d or -p can be specified\n");
+        return print_usage(-1);
+    }
+
+    /* determine the target type */
+    if(type != NULL) {
+        for(i = 0; i < FX_TYPE_MAX; i++) {
+            if(strcmp(type, fx_name[i]) == 0) {
+                fx_type = i;
+                break;
+            }
+        }
+        if(i >= FX_TYPE_MAX) {
+            logerror("illegal microcontroller type: %s\n", type);
+            return print_usage(-1);
+        }
+    }
+
+    /* open the device using libusb */
+    status = libusb_init_context(/*ctx=*/NULL, /*options=*/NULL, /*num_options=*/0);
+    if(status < 0) {
+        logerror("libusb_init_context() failed: %s\n", libusb_error_name(status));
+        return -1;
+    }
+    libusb_set_option(NULL, LIBUSB_OPTION_LOG_LEVEL, verbose);
+
+    /* try to pick up missing parameters from known devices */
+    if((type == NULL) || (device_id == NULL) || (device_path != NULL)) {
+        if(libusb_get_device_list(NULL, &devs) < 0) {
+            logerror("libusb_get_device_list() failed: %s\n", libusb_error_name(status));
+            goto err;
+        }
+        for(i = 0; (dev = devs[i]) != NULL; i++) {
+            _busnum  = libusb_get_bus_number(dev);
+            _devaddr = libusb_get_device_address(dev);
+            if((type != NULL) && (device_path != NULL)) {
+                // if both a type and bus,addr were specified, we just need to find our match
+                if((libusb_get_bus_number(dev) == busnum) && (libusb_get_device_address(dev) == devaddr))
+                    break;
+            }
+            else {
+                status = libusb_get_device_descriptor(dev, &desc);
+                if(status >= 0) {
+                    if(verbose >= 3) {
+                        logerror("examining %04x:%04x (%d,%d)\n", desc.idVendor, desc.idProduct, _busnum, _devaddr);
+                    }
+                    for(j = 0; j < ARRAYSIZE(known_device); j++) {
+                        if((desc.idVendor == known_device[j].vid) && (desc.idProduct == known_device[j].pid)) {
+                            if(  // nothing was specified
+                                ((type == NULL) && (device_id == NULL) && (device_path == NULL)) ||
+                                // vid:pid was specified and we have a match
+                                ((type == NULL) && (device_id != NULL) && (vid == desc.idVendor) && (pid == desc.idProduct)) ||
+                                // bus,addr was specified and we have a match
+                                ((type == NULL) && (device_path != NULL) && (busnum == _busnum) && (devaddr == _devaddr)) ||
+                                // type was specified and we have a match
+                                ((type != NULL) && (device_id == NULL) && (device_path == NULL) && (fx_type == known_device[j].type))) {
+                                fx_type = known_device[j].type;
+                                vid     = desc.idVendor;
+                                pid     = desc.idProduct;
+                                busnum  = _busnum;
+                                devaddr = _devaddr;
+                                break;
+                            }
+                        }
+                    }
+                    if(j < ARRAYSIZE(known_device)) {
+                        if(verbose)
+                            logerror("found device '%s' [%04x:%04x] (%d,%d)\n", known_device[j].designation, vid, pid, busnum, devaddr);
+                        break;
+                    }
+                }
+            }
+        }
+        if(dev == NULL) {
+            libusb_free_device_list(devs, 1);
+            libusb_exit(NULL);
+            logerror("could not find a known device - please specify type and/or vid:pid and/or bus,dev\n");
+            return print_usage(-1);
+        }
+        status = libusb_open(dev, &device);
+        libusb_free_device_list(devs, 1);
+        if(status < 0) {
+            logerror("libusb_open() failed: %s\n", libusb_error_name(status));
+            goto err;
+        }
+    }
+    else if(device_id != NULL) {
+        device = libusb_open_device_with_vid_pid(NULL, (uint16_t)vid, (uint16_t)pid);
+        if(device == NULL) {
+            logerror("libusb_open() failed\n");
+            goto err;
+        }
+    }
+
+    /* We need to claim the first interface */
+    libusb_set_auto_detach_kernel_driver(device, 1);
+    status = libusb_claim_interface(device, 0);
+    if(status != LIBUSB_SUCCESS) {
+        libusb_close(device);
+        logerror("libusb_claim_interface failed: %s\n", libusb_error_name(status));
+        goto err;
+    }
+
+    if(verbose)
+        logerror("microcontroller type: %s\n", fx_name[fx_type]);
+
+    for(i = 0; i < ARRAYSIZE(path); i++) {
+        if(path[i] != NULL) {
+            ext = path[i] + strlen(path[i]) - 4;
+            if((_stricmp(ext, ".hex") == 0) || (strcmp(ext, ".ihx") == 0))
+                img_type[i] = IMG_TYPE_HEX;
+            else if(_stricmp(ext, ".iic") == 0)
+                img_type[i] = IMG_TYPE_IIC;
+            else if(_stricmp(ext, ".bix") == 0)
+                img_type[i] = IMG_TYPE_BIX;
+            else if(_stricmp(ext, ".img") == 0)
+                img_type[i] = IMG_TYPE_IMG;
+            else {
+                logerror("%s is not a recognized image type\n", path[i]);
+                goto err;
+            }
+        }
+        if(verbose && path[i] != NULL)
+            logerror("%s: type %s\n", path[i], img_name[img_type[i]]);
+    }
+
+    if(path[LOADER] == NULL) {
+        /* single stage, put into internal memory */
+        if(verbose > 1)
+            logerror("single stage: load on-chip memory\n");
+        status = ezusb_load_ram(device, path[FIRMWARE], fx_type, img_type[FIRMWARE], 0);
+    }
+    else {
+        /* two-stage, put loader into internal memory */
+        if(verbose > 1)
+            logerror("1st stage: load 2nd stage loader\n");
+        status = ezusb_load_ram(device, path[LOADER], fx_type, img_type[LOADER], 0);
+        if(status == 0) {
+            /* two-stage, put firmware into internal memory */
+            if(verbose > 1)
+                logerror("2nd state: load on-chip memory\n");
+            status = ezusb_load_ram(device, path[FIRMWARE], fx_type, img_type[FIRMWARE], 1);
+        }
+    }
+
+    libusb_release_interface(device, 0);
+    libusb_close(device);
+    libusb_exit(NULL);
+    return status;
+err:
+    libusb_exit(NULL);
+    return -1;
+}
diff --git a/3rdparty/libusb/src/examples/hotplugtest.c b/3rdparty/libusb/src/examples/hotplugtest.c
new file mode 100644
index 00000000..94f37055
--- /dev/null
+++ b/3rdparty/libusb/src/examples/hotplugtest.c
@@ -0,0 +1,126 @@
+/* -*- Mode: C; indent-tabs-mode:t ; c-basic-offset:8 -*- */
+/*
+ * libusb example program for hotplug API
+ * Copyright © 2012-2013 Nathan Hjelm <hjelmn@mac.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+
+#include "libusb.h"
+
+int                   done   = 0;
+libusb_device_handle *handle = NULL;
+
+static int LIBUSB_CALL hotplug_callback(libusb_context *ctx, libusb_device *dev, libusb_hotplug_event event, void *user_data) {
+    struct libusb_device_descriptor desc;
+    int                             rc;
+
+    (void)ctx;
+    (void)dev;
+    (void)event;
+    (void)user_data;
+
+    rc = libusb_get_device_descriptor(dev, &desc);
+    if(LIBUSB_SUCCESS != rc) {
+        fprintf(stderr, "Error getting device descriptor\n");
+    }
+
+    printf("Device attached: %04x:%04x\n", desc.idVendor, desc.idProduct);
+
+    if(handle) {
+        libusb_close(handle);
+        handle = NULL;
+    }
+
+    rc = libusb_open(dev, &handle);
+    if(LIBUSB_SUCCESS != rc) {
+        fprintf(stderr, "Error opening device\n");
+    }
+
+    done++;
+
+    return 0;
+}
+
+static int LIBUSB_CALL hotplug_callback_detach(libusb_context *ctx, libusb_device *dev, libusb_hotplug_event event, void *user_data) {
+    (void)ctx;
+    (void)dev;
+    (void)event;
+    (void)user_data;
+
+    printf("Device detached\n");
+
+    if(handle) {
+        libusb_close(handle);
+        handle = NULL;
+    }
+
+    done++;
+
+    return 0;
+}
+
+int main(int argc, char *argv[]) {
+    libusb_hotplug_callback_handle hp[2];
+    int                            product_id, vendor_id, class_id;
+    int                            rc;
+
+    vendor_id  = (argc > 1) ? (int)strtol(argv[1], NULL, 0) : 0x045a;
+    product_id = (argc > 2) ? (int)strtol(argv[2], NULL, 0) : 0x5005;
+    class_id   = (argc > 3) ? (int)strtol(argv[3], NULL, 0) : LIBUSB_HOTPLUG_MATCH_ANY;
+
+    rc = libusb_init_context(/*ctx=*/NULL, /*options=*/NULL, /*num_options=*/0);
+    if(rc < 0) {
+        printf("failed to initialise libusb: %s\n", libusb_error_name(rc));
+        return EXIT_FAILURE;
+    }
+
+    if(!libusb_has_capability(LIBUSB_CAP_HAS_HOTPLUG)) {
+        printf("Hotplug capabilities are not supported on this platform\n");
+        libusb_exit(NULL);
+        return EXIT_FAILURE;
+    }
+
+    rc = libusb_hotplug_register_callback(NULL, LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED, 0, vendor_id, product_id, class_id, hotplug_callback, NULL, &hp[0]);
+    if(LIBUSB_SUCCESS != rc) {
+        fprintf(stderr, "Error registering callback 0\n");
+        libusb_exit(NULL);
+        return EXIT_FAILURE;
+    }
+
+    rc = libusb_hotplug_register_callback(NULL, LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT, 0, vendor_id, product_id, class_id, hotplug_callback_detach, NULL, &hp[1]);
+    if(LIBUSB_SUCCESS != rc) {
+        fprintf(stderr, "Error registering callback 1\n");
+        libusb_exit(NULL);
+        return EXIT_FAILURE;
+    }
+
+    while(done < 2) {
+        rc = libusb_handle_events(NULL);
+        if(rc < 0)
+            printf("libusb_handle_events() failed: %s\n", libusb_error_name(rc));
+    }
+
+    if(handle) {
+        libusb_close(handle);
+    }
+
+    libusb_exit(NULL);
+
+    return EXIT_SUCCESS;
+}
diff --git a/3rdparty/libusb/src/examples/listdevs.c b/3rdparty/libusb/src/examples/listdevs.c
new file mode 100644
index 00000000..835c4440
--- /dev/null
+++ b/3rdparty/libusb/src/examples/listdevs.c
@@ -0,0 +1,69 @@
+/*
+ * libusb example program to list devices on the bus
+ * Copyright © 2007 Daniel Drake <dsd@gentoo.org>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <stdio.h>
+
+#include "libusb.h"
+
+static void print_devs(libusb_device **devs) {
+    libusb_device *dev;
+    int            i = 0, j = 0;
+    uint8_t        path[8];
+
+    while((dev = devs[i++]) != NULL) {
+        struct libusb_device_descriptor desc;
+        int                             r = libusb_get_device_descriptor(dev, &desc);
+        if(r < 0) {
+            fprintf(stderr, "failed to get device descriptor");
+            return;
+        }
+
+        printf("%04x:%04x (bus %d, device %d)", desc.idVendor, desc.idProduct, libusb_get_bus_number(dev), libusb_get_device_address(dev));
+
+        r = libusb_get_port_numbers(dev, path, sizeof(path));
+        if(r > 0) {
+            printf(" path: %d", path[0]);
+            for(j = 1; j < r; j++)
+                printf(".%d", path[j]);
+        }
+        printf("\n");
+    }
+}
+
+int main(void) {
+    libusb_device **devs;
+    int             r;
+    ssize_t         cnt;
+
+    r = libusb_init_context(/*ctx=*/NULL, /*options=*/NULL, /*num_options=*/0);
+    if(r < 0)
+        return r;
+
+    cnt = libusb_get_device_list(NULL, &devs);
+    if(cnt < 0) {
+        libusb_exit(NULL);
+        return (int)cnt;
+    }
+
+    print_devs(devs);
+    libusb_free_device_list(devs, 1);
+
+    libusb_exit(NULL);
+    return 0;
+}
diff --git a/3rdparty/libusb/src/examples/sam3u_benchmark.c b/3rdparty/libusb/src/examples/sam3u_benchmark.c
new file mode 100644
index 00000000..0b2a122b
--- /dev/null
+++ b/3rdparty/libusb/src/examples/sam3u_benchmark.c
@@ -0,0 +1,220 @@
+/*
+ * libusb example program to measure Atmel SAM3U isochronous performance
+ * Copyright (C) 2012 Harald Welte <laforge@gnumonks.org>
+ *
+ * Copied with the author's permission under LGPL-2.1 from
+ * http://git.gnumonks.org/cgi-bin/gitweb.cgi?p=sam3u-tests.git;a=blob;f=usb-benchmark-project/host/benchmark.c;h=74959f7ee88f1597286cd435f312a8ff52c56b7e
+ *
+ * An Atmel SAM3U test firmware is also available in the above repository.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <libusb/config.h>
+
+#include <errno.h>
+#include <signal.h>
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef HAVE_SYS_TIME_H
+#include <sys/time.h>
+#endif
+#include <time.h>
+
+#include "libusb.h"
+
+#define EP_DATA_IN 0x82
+#define EP_ISO_IN 0x86
+
+static volatile sig_atomic_t        do_exit = 0;
+static struct libusb_device_handle *devh    = NULL;
+
+static unsigned long  num_bytes = 0, num_xfer = 0;
+static struct timeval tv_start;
+
+static void get_timestamp(struct timeval *tv) {
+#if defined(PLATFORM_WINDOWS)
+    static LARGE_INTEGER frequency;
+    LARGE_INTEGER        counter;
+
+    if(!frequency.QuadPart)
+        QueryPerformanceFrequency(&frequency);
+
+    QueryPerformanceCounter(&counter);
+    counter.QuadPart *= 1000000;
+    counter.QuadPart /= frequency.QuadPart;
+
+    tv->tv_sec  = (long)(counter.QuadPart / 1000000ULL);
+    tv->tv_usec = (long)(counter.QuadPart % 1000000ULL);
+#elif defined(HAVE_CLOCK_GETTIME)
+    struct timespec ts;
+
+    (void)clock_gettime(CLOCK_MONOTONIC, &ts);
+    tv->tv_sec  = ts.tv_sec;
+    tv->tv_usec = (int)(ts.tv_nsec / 1000L);
+#else
+    gettimeofday(tv, NULL);
+#endif
+}
+
+static void LIBUSB_CALL cb_xfr(struct libusb_transfer *xfr) {
+    int i;
+
+    if(xfr->status != LIBUSB_TRANSFER_COMPLETED) {
+        fprintf(stderr, "transfer status %d\n", xfr->status);
+        libusb_free_transfer(xfr);
+        exit(3);
+    }
+
+    if(xfr->type == LIBUSB_TRANSFER_TYPE_ISOCHRONOUS) {
+        for(i = 0; i < xfr->num_iso_packets; i++) {
+            struct libusb_iso_packet_descriptor *pack = &xfr->iso_packet_desc[i];
+
+            if(pack->status != LIBUSB_TRANSFER_COMPLETED) {
+                fprintf(stderr, "Error: pack %d status %d\n", i, pack->status);
+                exit(5);
+            }
+
+            printf("pack%d length:%u, actual_length:%u\n", i, pack->length, pack->actual_length);
+        }
+    }
+
+    printf("length:%u, actual_length:%u\n", xfr->length, xfr->actual_length);
+    for(i = 0; i < xfr->actual_length; i++) {
+        printf("%02x", xfr->buffer[i]);
+        if(i % 16)
+            printf("\n");
+        else if(i % 8)
+            printf("  ");
+        else
+            printf(" ");
+    }
+    num_bytes += xfr->actual_length;
+    num_xfer++;
+
+    if(libusb_submit_transfer(xfr) < 0) {
+        fprintf(stderr, "error re-submitting URB\n");
+        exit(1);
+    }
+}
+
+static int benchmark_in(uint8_t ep) {
+    static uint8_t                 buf[2048];
+    static struct libusb_transfer *xfr;
+    int                            num_iso_pack = 0;
+
+    if(ep == EP_ISO_IN)
+        num_iso_pack = 16;
+
+    xfr = libusb_alloc_transfer(num_iso_pack);
+    if(!xfr) {
+        errno = ENOMEM;
+        return -1;
+    }
+
+    if(ep == EP_ISO_IN) {
+        libusb_fill_iso_transfer(xfr, devh, ep, buf, sizeof(buf), num_iso_pack, cb_xfr, NULL, 0);
+        libusb_set_iso_packet_lengths(xfr, sizeof(buf) / num_iso_pack);
+    }
+    else
+        libusb_fill_bulk_transfer(xfr, devh, ep, buf, sizeof(buf), cb_xfr, NULL, 0);
+
+    get_timestamp(&tv_start);
+
+    /* NOTE: To reach maximum possible performance the program must
+     * submit *multiple* transfers here, not just one.
+     *
+     * When only one transfer is submitted there is a gap in the bus
+     * schedule from when the transfer completes until a new transfer
+     * is submitted by the callback. This causes some jitter for
+     * isochronous transfers and loss of throughput for bulk transfers.
+     *
+     * This is avoided by queueing multiple transfers in advance, so
+     * that the host controller is always kept busy, and will schedule
+     * more transfers on the bus while the callback is running for
+     * transfers which have completed on the bus.
+     */
+
+    return libusb_submit_transfer(xfr);
+}
+
+static void measure(void) {
+    struct timeval tv_stop;
+    unsigned long  diff_msec;
+
+    get_timestamp(&tv_stop);
+
+    diff_msec = (tv_stop.tv_sec - tv_start.tv_sec) * 1000L;
+    diff_msec += (tv_stop.tv_usec - tv_start.tv_usec) / 1000L;
+
+    printf("%lu transfers (total %lu bytes) in %lu milliseconds => %lu bytes/sec\n", num_xfer, num_bytes, diff_msec, (num_bytes * 1000L) / diff_msec);
+}
+
+static void sig_hdlr(int signum) {
+    (void)signum;
+
+    measure();
+    do_exit = 1;
+}
+
+int main(void) {
+    int rc;
+
+#if defined(PLATFORM_POSIX)
+    struct sigaction sigact;
+
+    sigact.sa_handler = sig_hdlr;
+    sigemptyset(&sigact.sa_mask);
+    sigact.sa_flags = 0;
+    (void)sigaction(SIGINT, &sigact, NULL);
+#else
+    (void)signal(SIGINT, sig_hdlr);
+#endif
+
+    rc = libusb_init_context(/*ctx=*/NULL, /*options=*/NULL, /*num_options=*/0);
+    if(rc < 0) {
+        fprintf(stderr, "Error initializing libusb: %s\n", libusb_error_name(rc));
+        exit(1);
+    }
+
+    devh = libusb_open_device_with_vid_pid(NULL, 0x16c0, 0x0763);
+    if(!devh) {
+        fprintf(stderr, "Error finding USB device\n");
+        goto out;
+    }
+
+    rc = libusb_claim_interface(devh, 2);
+    if(rc < 0) {
+        fprintf(stderr, "Error claiming interface: %s\n", libusb_error_name(rc));
+        goto out;
+    }
+
+    benchmark_in(EP_ISO_IN);
+
+    while(!do_exit) {
+        rc = libusb_handle_events(NULL);
+        if(rc != LIBUSB_SUCCESS)
+            break;
+    }
+
+    /* Measurement has already been done by the signal handler. */
+
+    libusb_release_interface(devh, 2);
+out:
+    if(devh)
+        libusb_close(devh);
+    libusb_exit(NULL);
+    return rc;
+}
diff --git a/3rdparty/libusb/src/examples/testlibusb.c b/3rdparty/libusb/src/examples/testlibusb.c
new file mode 100644
index 00000000..76878f25
--- /dev/null
+++ b/3rdparty/libusb/src/examples/testlibusb.c
@@ -0,0 +1,313 @@
+/*
+ * Test suite program based of libusb-0.1-compat testlibusb
+ * Copyright (c) 2013 Nathan Hjelm <hjelmn@mac.ccom>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include "libusb.h"
+
+int verbose = 0;
+
+static void print_endpoint_comp(const struct libusb_ss_endpoint_companion_descriptor *ep_comp) {
+    printf("      USB 3.0 Endpoint Companion:\n");
+    printf("        bMaxBurst:           %u\n", ep_comp->bMaxBurst);
+    printf("        bmAttributes:        %02xh\n", ep_comp->bmAttributes);
+    printf("        wBytesPerInterval:   %u\n", ep_comp->wBytesPerInterval);
+}
+
+static void print_endpoint(const struct libusb_endpoint_descriptor *endpoint) {
+    int i, ret;
+
+    printf("      Endpoint:\n");
+    printf("        bEndpointAddress:    %02xh\n", endpoint->bEndpointAddress);
+    printf("        bmAttributes:        %02xh\n", endpoint->bmAttributes);
+    printf("        wMaxPacketSize:      %u\n", endpoint->wMaxPacketSize);
+    printf("        bInterval:           %u\n", endpoint->bInterval);
+    printf("        bRefresh:            %u\n", endpoint->bRefresh);
+    printf("        bSynchAddress:       %u\n", endpoint->bSynchAddress);
+
+    for(i = 0; i < endpoint->extra_length;) {
+        if(LIBUSB_DT_SS_ENDPOINT_COMPANION == endpoint->extra[i + 1]) {
+            struct libusb_ss_endpoint_companion_descriptor *ep_comp;
+
+            ret = libusb_get_ss_endpoint_companion_descriptor(NULL, endpoint, &ep_comp);
+            if(LIBUSB_SUCCESS != ret)
+                continue;
+
+            print_endpoint_comp(ep_comp);
+
+            libusb_free_ss_endpoint_companion_descriptor(ep_comp);
+        }
+
+        i += endpoint->extra[i];
+    }
+}
+
+static void print_altsetting(const struct libusb_interface_descriptor *interface) {
+    uint8_t i;
+
+    printf("    Interface:\n");
+    printf("      bInterfaceNumber:      %u\n", interface->bInterfaceNumber);
+    printf("      bAlternateSetting:     %u\n", interface->bAlternateSetting);
+    printf("      bNumEndpoints:         %u\n", interface->bNumEndpoints);
+    printf("      bInterfaceClass:       %u\n", interface->bInterfaceClass);
+    printf("      bInterfaceSubClass:    %u\n", interface->bInterfaceSubClass);
+    printf("      bInterfaceProtocol:    %u\n", interface->bInterfaceProtocol);
+    printf("      iInterface:            %u\n", interface->iInterface);
+
+    for(i = 0; i < interface->bNumEndpoints; i++)
+        print_endpoint(&interface->endpoint[i]);
+}
+
+static void print_2_0_ext_cap(struct libusb_usb_2_0_extension_descriptor *usb_2_0_ext_cap) {
+    printf("    USB 2.0 Extension Capabilities:\n");
+    printf("      bDevCapabilityType:    %u\n", usb_2_0_ext_cap->bDevCapabilityType);
+    printf("      bmAttributes:          %08xh\n", usb_2_0_ext_cap->bmAttributes);
+}
+
+static void print_ss_usb_cap(struct libusb_ss_usb_device_capability_descriptor *ss_usb_cap) {
+    printf("    USB 3.0 Capabilities:\n");
+    printf("      bDevCapabilityType:    %u\n", ss_usb_cap->bDevCapabilityType);
+    printf("      bmAttributes:          %02xh\n", ss_usb_cap->bmAttributes);
+    printf("      wSpeedSupported:       %u\n", ss_usb_cap->wSpeedSupported);
+    printf("      bFunctionalitySupport: %u\n", ss_usb_cap->bFunctionalitySupport);
+    printf("      bU1devExitLat:         %u\n", ss_usb_cap->bU1DevExitLat);
+    printf("      bU2devExitLat:         %u\n", ss_usb_cap->bU2DevExitLat);
+}
+
+static void print_bos(libusb_device_handle *handle) {
+    struct libusb_bos_descriptor *bos;
+    uint8_t                       i;
+    int                           ret;
+
+    ret = libusb_get_bos_descriptor(handle, &bos);
+    if(ret < 0)
+        return;
+
+    printf("  Binary Object Store (BOS):\n");
+    printf("    wTotalLength:            %u\n", bos->wTotalLength);
+    printf("    bNumDeviceCaps:          %u\n", bos->bNumDeviceCaps);
+
+    for(i = 0; i < bos->bNumDeviceCaps; i++) {
+        struct libusb_bos_dev_capability_descriptor *dev_cap = bos->dev_capability[i];
+
+        if(dev_cap->bDevCapabilityType == LIBUSB_BT_USB_2_0_EXTENSION) {
+            struct libusb_usb_2_0_extension_descriptor *usb_2_0_extension;
+
+            ret = libusb_get_usb_2_0_extension_descriptor(NULL, dev_cap, &usb_2_0_extension);
+            if(ret < 0)
+                return;
+
+            print_2_0_ext_cap(usb_2_0_extension);
+            libusb_free_usb_2_0_extension_descriptor(usb_2_0_extension);
+        }
+        else if(dev_cap->bDevCapabilityType == LIBUSB_BT_SS_USB_DEVICE_CAPABILITY) {
+            struct libusb_ss_usb_device_capability_descriptor *ss_dev_cap;
+
+            ret = libusb_get_ss_usb_device_capability_descriptor(NULL, dev_cap, &ss_dev_cap);
+            if(ret < 0)
+                return;
+
+            print_ss_usb_cap(ss_dev_cap);
+            libusb_free_ss_usb_device_capability_descriptor(ss_dev_cap);
+        }
+    }
+
+    libusb_free_bos_descriptor(bos);
+}
+
+static void print_interface(const struct libusb_interface *interface) {
+    int i;
+
+    for(i = 0; i < interface->num_altsetting; i++)
+        print_altsetting(&interface->altsetting[i]);
+}
+
+static void print_configuration(struct libusb_config_descriptor *config) {
+    uint8_t i;
+
+    printf("  Configuration:\n");
+    printf("    wTotalLength:            %u\n", config->wTotalLength);
+    printf("    bNumInterfaces:          %u\n", config->bNumInterfaces);
+    printf("    bConfigurationValue:     %u\n", config->bConfigurationValue);
+    printf("    iConfiguration:          %u\n", config->iConfiguration);
+    printf("    bmAttributes:            %02xh\n", config->bmAttributes);
+    printf("    MaxPower:                %u\n", config->MaxPower);
+
+    for(i = 0; i < config->bNumInterfaces; i++)
+        print_interface(&config->interface[i]);
+}
+
+static void print_device(libusb_device *dev, libusb_device_handle *handle) {
+    struct libusb_device_descriptor desc;
+    unsigned char                   string[256];
+    const char                     *speed;
+    int                             ret;
+    uint8_t                         i;
+
+    switch(libusb_get_device_speed(dev)) {
+    case LIBUSB_SPEED_LOW:
+        speed = "1.5M";
+        break;
+    case LIBUSB_SPEED_FULL:
+        speed = "12M";
+        break;
+    case LIBUSB_SPEED_HIGH:
+        speed = "480M";
+        break;
+    case LIBUSB_SPEED_SUPER:
+        speed = "5G";
+        break;
+    case LIBUSB_SPEED_SUPER_PLUS:
+        speed = "10G";
+        break;
+    default:
+        speed = "Unknown";
+    }
+
+    ret = libusb_get_device_descriptor(dev, &desc);
+    if(ret < 0) {
+        fprintf(stderr, "failed to get device descriptor");
+        return;
+    }
+
+    printf("Dev (bus %u, device %u): %04X - %04X speed: %s\n", libusb_get_bus_number(dev), libusb_get_device_address(dev), desc.idVendor, desc.idProduct,
+           speed);
+
+    if(!handle)
+        libusb_open(dev, &handle);
+
+    if(handle) {
+        if(desc.iManufacturer) {
+            ret = libusb_get_string_descriptor_ascii(handle, desc.iManufacturer, string, sizeof(string));
+            if(ret > 0)
+                printf("  Manufacturer:              %s\n", (char *)string);
+        }
+
+        if(desc.iProduct) {
+            ret = libusb_get_string_descriptor_ascii(handle, desc.iProduct, string, sizeof(string));
+            if(ret > 0)
+                printf("  Product:                   %s\n", (char *)string);
+        }
+
+        if(desc.iSerialNumber && verbose) {
+            ret = libusb_get_string_descriptor_ascii(handle, desc.iSerialNumber, string, sizeof(string));
+            if(ret > 0)
+                printf("  Serial Number:             %s\n", (char *)string);
+        }
+    }
+
+    if(verbose) {
+        for(i = 0; i < desc.bNumConfigurations; i++) {
+            struct libusb_config_descriptor *config;
+
+            ret = libusb_get_config_descriptor(dev, i, &config);
+            if(LIBUSB_SUCCESS != ret) {
+                printf("  Couldn't retrieve descriptors\n");
+                continue;
+            }
+
+            print_configuration(config);
+
+            libusb_free_config_descriptor(config);
+        }
+
+        if(handle && desc.bcdUSB >= 0x0201)
+            print_bos(handle);
+    }
+
+    if(handle)
+        libusb_close(handle);
+}
+
+#ifdef __linux__
+#include <errno.h>
+#include <fcntl.h>
+#include <unistd.h>
+
+static int test_wrapped_device(const char *device_name) {
+    libusb_device_handle *handle;
+    int                   r, fd;
+
+    fd = open(device_name, O_RDWR);
+    if(fd < 0) {
+        printf("Error could not open %s: %s\n", device_name, strerror(errno));
+        return 1;
+    }
+    r = libusb_wrap_sys_device(NULL, fd, &handle);
+    if(r) {
+        printf("Error wrapping device: %s: %s\n", device_name, libusb_strerror(r));
+        close(fd);
+        return 1;
+    }
+    print_device(libusb_get_device(handle), handle);
+    close(fd);
+    return 0;
+}
+#else
+static int test_wrapped_device(const char *device_name) {
+    (void)device_name;
+    printf("Testing wrapped devices is not supported on your platform\n");
+    return 1;
+}
+#endif
+
+int main(int argc, char *argv[]) {
+    const char     *device_name = NULL;
+    libusb_device **devs;
+    ssize_t         cnt;
+    int             r, i;
+
+    for(i = 1; i < argc; i++) {
+        if(!strcmp(argv[i], "-v")) {
+            verbose = 1;
+        }
+        else if(!strcmp(argv[i], "-d") && (i + 1) < argc) {
+            i++;
+            device_name = argv[i];
+        }
+        else {
+            printf("Usage %s [-v] [-d </dev/bus/usb/...>]\n", argv[0]);
+            printf("Note use -d to test libusb_wrap_sys_device()\n");
+            return 1;
+        }
+    }
+
+    r = libusb_init_context(/*ctx=*/NULL, /*options=*/NULL, /*num_options=*/0);
+    if(r < 0)
+        return r;
+
+    if(device_name) {
+        r = test_wrapped_device(device_name);
+    }
+    else {
+        cnt = libusb_get_device_list(NULL, &devs);
+        if(cnt < 0) {
+            libusb_exit(NULL);
+            return 1;
+        }
+
+        for(i = 0; devs[i]; i++)
+            print_device(devs[i], NULL);
+
+        libusb_free_device_list(devs, 1);
+    }
+
+    libusb_exit(NULL);
+    return r;
+}
diff --git a/3rdparty/libusb/src/examples/xusb.c b/3rdparty/libusb/src/examples/xusb.c
new file mode 100644
index 00000000..bd22a7ff
--- /dev/null
+++ b/3rdparty/libusb/src/examples/xusb.c
@@ -0,0 +1,1196 @@
+/*
+ * xusb: Generic USB test program
+ * Copyright © 2009-2012 Pete Batard <pete@akeo.ie>
+ * Contributions to Mass Storage by Alan Stern.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+
+#include "libusb.h"
+
+#if defined(_MSC_VER)
+#define snprintf _snprintf
+#define putenv _putenv
+#endif
+
+// Future versions of libusb will use usb_interface instead of interface
+// in libusb_config_descriptor => catter for that
+#define usb_interface interface
+
+// Global variables
+static bool        binary_dump          = false;
+static bool        extra_info           = false;
+static bool        force_device_request = false;  // For WCID descriptor queries
+static const char *binary_name          = NULL;
+
+static inline void msleep(int msecs) {
+#if defined(_WIN32)
+    Sleep(msecs);
+#else
+    const struct timespec ts = { msecs / 1000, (msecs % 1000) * 1000000L };
+    nanosleep(&ts, NULL);
+#endif
+}
+
+static void perr(char const *format, ...) {
+    va_list args;
+
+    va_start(args, format);
+    vfprintf(stderr, format, args);
+    va_end(args);
+}
+
+#define ERR_EXIT(errcode)                                             \
+    do {                                                              \
+        perr("   %s\n", libusb_strerror((enum libusb_error)errcode)); \
+        return -1;                                                    \
+    } while(0)
+#define CALL_CHECK(fcall) \
+    do {                  \
+        int _r = fcall;   \
+        if(_r < 0)        \
+            ERR_EXIT(_r); \
+    } while(0)
+#define CALL_CHECK_CLOSE(fcall, hdl) \
+    do {                             \
+        int _r = fcall;              \
+        if(_r < 0) {                 \
+            libusb_close(hdl);       \
+            ERR_EXIT(_r);            \
+        }                            \
+    } while(0)
+#define B(x) (((x) != 0) ? 1 : 0)
+#define be_to_int32(buf) (((buf)[0] << 24) | ((buf)[1] << 16) | ((buf)[2] << 8) | (buf)[3])
+
+#define RETRY_MAX 5
+#define REQUEST_SENSE_LENGTH 0x12
+#define INQUIRY_LENGTH 0x24
+#define READ_CAPACITY_LENGTH 0x08
+
+// HID Class-Specific Requests values. See section 7.2 of the HID specifications
+#define HID_GET_REPORT 0x01
+#define HID_GET_IDLE 0x02
+#define HID_GET_PROTOCOL 0x03
+#define HID_SET_REPORT 0x09
+#define HID_SET_IDLE 0x0A
+#define HID_SET_PROTOCOL 0x0B
+#define HID_REPORT_TYPE_INPUT 0x01
+#define HID_REPORT_TYPE_OUTPUT 0x02
+#define HID_REPORT_TYPE_FEATURE 0x03
+
+// Mass Storage Requests values. See section 3 of the Bulk-Only Mass Storage Class specifications
+#define BOMS_RESET 0xFF
+#define BOMS_GET_MAX_LUN 0xFE
+
+// Microsoft OS Descriptor
+#define MS_OS_DESC_STRING_INDEX 0xEE
+#define MS_OS_DESC_STRING_LENGTH 0x12
+#define MS_OS_DESC_VENDOR_CODE_OFFSET 0x10
+static const uint8_t ms_os_desc_string[] = {
+    MS_OS_DESC_STRING_LENGTH, LIBUSB_DT_STRING, 'M', 0, 'S', 0, 'F', 0, 'T', 0, '1', 0, '0', 0, '0', 0,
+};
+
+// Section 5.1: Command Block Wrapper (CBW)
+struct command_block_wrapper {
+    uint8_t  dCBWSignature[4];
+    uint32_t dCBWTag;
+    uint32_t dCBWDataTransferLength;
+    uint8_t  bmCBWFlags;
+    uint8_t  bCBWLUN;
+    uint8_t  bCBWCBLength;
+    uint8_t  CBWCB[16];
+};
+
+// Section 5.2: Command Status Wrapper (CSW)
+struct command_status_wrapper {
+    uint8_t  dCSWSignature[4];
+    uint32_t dCSWTag;
+    uint32_t dCSWDataResidue;
+    uint8_t  bCSWStatus;
+};
+
+static const uint8_t cdb_length[256] = {
+    //	 0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
+    06, 06, 06, 06, 06, 06, 06, 06, 06, 06, 06, 06, 06, 06, 06, 06,  //  0
+    06, 06, 06, 06, 06, 06, 06, 06, 06, 06, 06, 06, 06, 06, 06, 06,  //  1
+    10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,  //  2
+    10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,  //  3
+    10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,  //  4
+    10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,  //  5
+    00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00,  //  6
+    00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00,  //  7
+    16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,  //  8
+    16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,  //  9
+    12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,  //  A
+    12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,  //  B
+    00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00,  //  C
+    00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00,  //  D
+    00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00,  //  E
+    00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00,  //  F
+};
+
+static enum test_type {
+    USE_GENERIC,
+    USE_PS3,
+    USE_XBOX,
+    USE_SCSI,
+    USE_HID,
+} test_mode;
+static uint16_t VID, PID;
+
+static void display_buffer_hex(unsigned char *buffer, unsigned size) {
+    unsigned i, j, k;
+
+    for(i = 0; i < size; i += 16) {
+        printf("\n  %08x  ", i);
+        for(j = 0, k = 0; k < 16; j++, k++) {
+            if(i + j < size) {
+                printf("%02x", buffer[i + j]);
+            }
+            else {
+                printf("  ");
+            }
+            printf(" ");
+        }
+        printf(" ");
+        for(j = 0, k = 0; k < 16; j++, k++) {
+            if(i + j < size) {
+                if((buffer[i + j] < 32) || (buffer[i + j] > 126)) {
+                    printf(".");
+                }
+                else {
+                    printf("%c", buffer[i + j]);
+                }
+            }
+        }
+    }
+    printf("\n");
+}
+
+static char *uuid_to_string(const uint8_t *uuid) {
+    static char uuid_string[40];
+    if(uuid == NULL)
+        return NULL;
+    snprintf(uuid_string, sizeof(uuid_string), "{%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x}", uuid[0], uuid[1], uuid[2], uuid[3],
+             uuid[4], uuid[5], uuid[6], uuid[7], uuid[8], uuid[9], uuid[10], uuid[11], uuid[12], uuid[13], uuid[14], uuid[15]);
+    return uuid_string;
+}
+
+// The PS3 Controller is really a HID device that got its HID Report Descriptors
+// removed by Sony
+static int display_ps3_status(libusb_device_handle *handle) {
+    uint8_t input_report[49];
+    uint8_t master_bt_address[8];
+    uint8_t device_bt_address[18];
+
+    // Get the controller's bluetooth address of its master device
+    CALL_CHECK(libusb_control_transfer(handle, LIBUSB_ENDPOINT_IN | LIBUSB_REQUEST_TYPE_CLASS | LIBUSB_RECIPIENT_INTERFACE, HID_GET_REPORT, 0x03f5, 0,
+                                       master_bt_address, sizeof(master_bt_address), 100));
+    printf("\nMaster's bluetooth address: %02X:%02X:%02X:%02X:%02X:%02X\n", master_bt_address[2], master_bt_address[3], master_bt_address[4],
+           master_bt_address[5], master_bt_address[6], master_bt_address[7]);
+
+    // Get the controller's bluetooth address
+    CALL_CHECK(libusb_control_transfer(handle, LIBUSB_ENDPOINT_IN | LIBUSB_REQUEST_TYPE_CLASS | LIBUSB_RECIPIENT_INTERFACE, HID_GET_REPORT, 0x03f2, 0,
+                                       device_bt_address, sizeof(device_bt_address), 100));
+    printf("\nMaster's bluetooth address: %02X:%02X:%02X:%02X:%02X:%02X\n", device_bt_address[4], device_bt_address[5], device_bt_address[6],
+           device_bt_address[7], device_bt_address[8], device_bt_address[9]);
+
+    // Get the status of the controller's buttons via its HID report
+    printf("\nReading PS3 Input Report...\n");
+    CALL_CHECK(libusb_control_transfer(handle, LIBUSB_ENDPOINT_IN | LIBUSB_REQUEST_TYPE_CLASS | LIBUSB_RECIPIENT_INTERFACE, HID_GET_REPORT,
+                                       (HID_REPORT_TYPE_INPUT << 8) | 0x01, 0, input_report, sizeof(input_report), 1000));
+    switch(input_report[2]) { /** Direction pad plus start, select, and joystick buttons */
+    case 0x01:
+        printf("\tSELECT pressed\n");
+        break;
+    case 0x02:
+        printf("\tLEFT 3 pressed\n");
+        break;
+    case 0x04:
+        printf("\tRIGHT 3 pressed\n");
+        break;
+    case 0x08:
+        printf("\tSTART pressed\n");
+        break;
+    case 0x10:
+        printf("\tUP pressed\n");
+        break;
+    case 0x20:
+        printf("\tRIGHT pressed\n");
+        break;
+    case 0x40:
+        printf("\tDOWN pressed\n");
+        break;
+    case 0x80:
+        printf("\tLEFT pressed\n");
+        break;
+    }
+    switch(input_report[3]) { /** Shapes plus top right and left buttons */
+    case 0x01:
+        printf("\tLEFT 2 pressed\n");
+        break;
+    case 0x02:
+        printf("\tRIGHT 2 pressed\n");
+        break;
+    case 0x04:
+        printf("\tLEFT 1 pressed\n");
+        break;
+    case 0x08:
+        printf("\tRIGHT 1 pressed\n");
+        break;
+    case 0x10:
+        printf("\tTRIANGLE pressed\n");
+        break;
+    case 0x20:
+        printf("\tCIRCLE pressed\n");
+        break;
+    case 0x40:
+        printf("\tCROSS pressed\n");
+        break;
+    case 0x80:
+        printf("\tSQUARE pressed\n");
+        break;
+    }
+    printf("\tPS button: %d\n", input_report[4]);
+    printf("\tLeft Analog (X,Y): (%d,%d)\n", input_report[6], input_report[7]);
+    printf("\tRight Analog (X,Y): (%d,%d)\n", input_report[8], input_report[9]);
+    printf("\tL2 Value: %d\tR2 Value: %d\n", input_report[18], input_report[19]);
+    printf("\tL1 Value: %d\tR1 Value: %d\n", input_report[20], input_report[21]);
+    printf("\tRoll (x axis): %d Yaw (y axis): %d Pitch (z axis) %d\n",
+           //(((input_report[42] + 128) % 256) - 128),
+           (int8_t)(input_report[42]), (int8_t)(input_report[44]), (int8_t)(input_report[46]));
+    printf("\tAcceleration: %d\n\n", (int8_t)(input_report[48]));
+    return 0;
+}
+// The XBOX Controller is really a HID device that got its HID Report Descriptors
+// removed by Microsoft.
+// Input/Output reports described at http://euc.jp/periphs/xbox-controller.ja.html
+static int display_xbox_status(libusb_device_handle *handle) {
+    uint8_t input_report[20];
+    printf("\nReading XBox Input Report...\n");
+    CALL_CHECK(libusb_control_transfer(handle, LIBUSB_ENDPOINT_IN | LIBUSB_REQUEST_TYPE_CLASS | LIBUSB_RECIPIENT_INTERFACE, HID_GET_REPORT,
+                                       (HID_REPORT_TYPE_INPUT << 8) | 0x00, 0, input_report, 20, 1000));
+    printf("   D-pad: %02X\n", input_report[2] & 0x0F);
+    printf("   Start:%d, Back:%d, Left Stick Press:%d, Right Stick Press:%d\n", B(input_report[2] & 0x10), B(input_report[2] & 0x20), B(input_report[2] & 0x40),
+           B(input_report[2] & 0x80));
+    // A, B, X, Y, Black, White are pressure sensitive
+    printf("   A:%d, B:%d, X:%d, Y:%d, White:%d, Black:%d\n", input_report[4], input_report[5], input_report[6], input_report[7], input_report[9],
+           input_report[8]);
+    printf("   Left Trigger: %d, Right Trigger: %d\n", input_report[10], input_report[11]);
+    printf("   Left Analog (X,Y): (%d,%d)\n", (int16_t)((input_report[13] << 8) | input_report[12]), (int16_t)((input_report[15] << 8) | input_report[14]));
+    printf("   Right Analog (X,Y): (%d,%d)\n", (int16_t)((input_report[17] << 8) | input_report[16]), (int16_t)((input_report[19] << 8) | input_report[18]));
+    return 0;
+}
+
+static int set_xbox_actuators(libusb_device_handle *handle, uint8_t left, uint8_t right) {
+    uint8_t output_report[6];
+
+    printf("\nWriting XBox Controller Output Report...\n");
+
+    memset(output_report, 0, sizeof(output_report));
+    output_report[1] = sizeof(output_report);
+    output_report[3] = left;
+    output_report[5] = right;
+
+    CALL_CHECK(libusb_control_transfer(handle, LIBUSB_ENDPOINT_OUT | LIBUSB_REQUEST_TYPE_CLASS | LIBUSB_RECIPIENT_INTERFACE, HID_SET_REPORT,
+                                       (HID_REPORT_TYPE_OUTPUT << 8) | 0x00, 0, output_report, 06, 1000));
+    return 0;
+}
+
+static int send_mass_storage_command(libusb_device_handle *handle, uint8_t endpoint, uint8_t lun, uint8_t *cdb, uint8_t direction, int data_length,
+                                     uint32_t *ret_tag) {
+    static uint32_t              tag = 1;
+    uint8_t                      cdb_len;
+    int                          i, r, size;
+    struct command_block_wrapper cbw;
+
+    if(cdb == NULL) {
+        return -1;
+    }
+
+    if(endpoint & LIBUSB_ENDPOINT_IN) {
+        perr("send_mass_storage_command: cannot send command on IN endpoint\n");
+        return -1;
+    }
+
+    cdb_len = cdb_length[cdb[0]];
+    if((cdb_len == 0) || (cdb_len > sizeof(cbw.CBWCB))) {
+        perr("send_mass_storage_command: don't know how to handle this command (%02X, length %d)\n", cdb[0], cdb_len);
+        return -1;
+    }
+
+    memset(&cbw, 0, sizeof(cbw));
+    cbw.dCBWSignature[0]       = 'U';
+    cbw.dCBWSignature[1]       = 'S';
+    cbw.dCBWSignature[2]       = 'B';
+    cbw.dCBWSignature[3]       = 'C';
+    *ret_tag                   = tag;
+    cbw.dCBWTag                = tag++;
+    cbw.dCBWDataTransferLength = data_length;
+    cbw.bmCBWFlags             = direction;
+    cbw.bCBWLUN                = lun;
+    // Subclass is 1 or 6 => cdb_len
+    cbw.bCBWCBLength = cdb_len;
+    memcpy(cbw.CBWCB, cdb, cdb_len);
+
+    i = 0;
+    do {
+        // The transfer length must always be exactly 31 bytes.
+        r = libusb_bulk_transfer(handle, endpoint, (unsigned char *)&cbw, 31, &size, 1000);
+        if(r == LIBUSB_ERROR_PIPE) {
+            libusb_clear_halt(handle, endpoint);
+        }
+        i++;
+    } while((r == LIBUSB_ERROR_PIPE) && (i < RETRY_MAX));
+    if(r != LIBUSB_SUCCESS) {
+        perr("   send_mass_storage_command: %s\n", libusb_strerror((enum libusb_error)r));
+        return -1;
+    }
+
+    printf("   sent %d CDB bytes\n", cdb_len);
+    return 0;
+}
+
+static int get_mass_storage_status(libusb_device_handle *handle, uint8_t endpoint, uint32_t expected_tag) {
+    int                           i, r, size;
+    struct command_status_wrapper csw;
+
+    // The device is allowed to STALL this transfer. If it does, you have to
+    // clear the stall and try again.
+    i = 0;
+    do {
+        r = libusb_bulk_transfer(handle, endpoint, (unsigned char *)&csw, 13, &size, 1000);
+        if(r == LIBUSB_ERROR_PIPE) {
+            libusb_clear_halt(handle, endpoint);
+        }
+        i++;
+    } while((r == LIBUSB_ERROR_PIPE) && (i < RETRY_MAX));
+    if(r != LIBUSB_SUCCESS) {
+        perr("   get_mass_storage_status: %s\n", libusb_strerror((enum libusb_error)r));
+        return -1;
+    }
+    if(size != 13) {
+        perr("   get_mass_storage_status: received %d bytes (expected 13)\n", size);
+        return -1;
+    }
+    if(csw.dCSWTag != expected_tag) {
+        perr("   get_mass_storage_status: mismatched tags (expected %08X, received %08X)\n", expected_tag, csw.dCSWTag);
+        return -1;
+    }
+    // For this test, we ignore the dCSWSignature check for validity...
+    printf("   Mass Storage Status: %02X (%s)\n", csw.bCSWStatus, csw.bCSWStatus ? "FAILED" : "Success");
+    if(csw.dCSWTag != expected_tag)
+        return -1;
+    if(csw.bCSWStatus) {
+        // REQUEST SENSE is appropriate only if bCSWStatus is 1, meaning that the
+        // command failed somehow.  Larger values (2 in particular) mean that
+        // the command couldn't be understood.
+        if(csw.bCSWStatus == 1)
+            return -2;  // request Get Sense
+        else
+            return -1;
+    }
+
+    // In theory we also should check dCSWDataResidue.  But lots of devices
+    // set it wrongly.
+    return 0;
+}
+
+static void get_sense(libusb_device_handle *handle, uint8_t endpoint_in, uint8_t endpoint_out) {
+    uint8_t  cdb[16];  // SCSI Command Descriptor Block
+    uint8_t  sense[18];
+    uint32_t expected_tag;
+    int      size;
+    int      rc;
+
+    // Request Sense
+    printf("Request Sense:\n");
+    memset(sense, 0, sizeof(sense));
+    memset(cdb, 0, sizeof(cdb));
+    cdb[0] = 0x03;  // Request Sense
+    cdb[4] = REQUEST_SENSE_LENGTH;
+
+    send_mass_storage_command(handle, endpoint_out, 0, cdb, LIBUSB_ENDPOINT_IN, REQUEST_SENSE_LENGTH, &expected_tag);
+    rc = libusb_bulk_transfer(handle, endpoint_in, (unsigned char *)&sense, REQUEST_SENSE_LENGTH, &size, 1000);
+    if(rc < 0) {
+        printf("libusb_bulk_transfer failed: %s\n", libusb_error_name(rc));
+        return;
+    }
+    printf("   received %d bytes\n", size);
+
+    if((sense[0] != 0x70) && (sense[0] != 0x71)) {
+        perr("   ERROR No sense data\n");
+    }
+    else {
+        perr("   ERROR Sense: %02X %02X %02X\n", sense[2] & 0x0F, sense[12], sense[13]);
+    }
+    // Strictly speaking, the get_mass_storage_status() call should come
+    // before these perr() lines.  If the status is nonzero then we must
+    // assume there's no data in the buffer.  For xusb it doesn't matter.
+    get_mass_storage_status(handle, endpoint_in, expected_tag);
+}
+
+// Mass Storage device to test bulk transfers (non destructive test)
+static int test_mass_storage(libusb_device_handle *handle, uint8_t endpoint_in, uint8_t endpoint_out) {
+    int            r, size;
+    uint8_t        lun;
+    uint32_t       expected_tag;
+    uint32_t       i, max_lba, block_size;
+    double         device_size;
+    uint8_t        cdb[16];  // SCSI Command Descriptor Block
+    uint8_t        buffer[64];
+    char           vid[9], pid[9], rev[5];
+    unsigned char *data;
+    FILE          *fd;
+
+    printf("\nReading Max LUN:\n");
+    r = libusb_control_transfer(handle, LIBUSB_ENDPOINT_IN | LIBUSB_REQUEST_TYPE_CLASS | LIBUSB_RECIPIENT_INTERFACE, BOMS_GET_MAX_LUN, 0, 0, &lun, 1, 1000);
+    // Some devices send a STALL instead of the actual value.
+    // In such cases we should set lun to 0.
+    if(r == LIBUSB_ERROR_PIPE) {
+        lun = 0;
+        printf("   Stalled, setting Max LUN to 0\n");
+    }
+    else if(r < 0) {
+        perr("   Failed.\n");
+        return r;
+    }
+    else {
+        printf("   Max LUN = %d\n", lun);
+    }
+
+    // Send Inquiry
+    printf("\nSending Inquiry:\n");
+    memset(buffer, 0, sizeof(buffer));
+    memset(cdb, 0, sizeof(cdb));
+    cdb[0] = 0x12;  // Inquiry
+    cdb[4] = INQUIRY_LENGTH;
+
+    send_mass_storage_command(handle, endpoint_out, lun, cdb, LIBUSB_ENDPOINT_IN, INQUIRY_LENGTH, &expected_tag);
+    CALL_CHECK(libusb_bulk_transfer(handle, endpoint_in, (unsigned char *)&buffer, INQUIRY_LENGTH, &size, 1000));
+    printf("   received %d bytes\n", size);
+    // The following strings are not zero terminated
+    for(i = 0; i < 8; i++) {
+        vid[i]     = buffer[8 + i];
+        pid[i]     = buffer[16 + i];
+        rev[i / 2] = buffer[32 + i / 2];  // instead of another loop
+    }
+    vid[8] = 0;
+    pid[8] = 0;
+    rev[4] = 0;
+    printf("   VID:PID:REV \"%8s\":\"%8s\":\"%4s\"\n", vid, pid, rev);
+    if(get_mass_storage_status(handle, endpoint_in, expected_tag) == -2) {
+        get_sense(handle, endpoint_in, endpoint_out);
+    }
+
+    // Read capacity
+    printf("\nReading Capacity:\n");
+    memset(buffer, 0, sizeof(buffer));
+    memset(cdb, 0, sizeof(cdb));
+    cdb[0] = 0x25;  // Read Capacity
+
+    send_mass_storage_command(handle, endpoint_out, lun, cdb, LIBUSB_ENDPOINT_IN, READ_CAPACITY_LENGTH, &expected_tag);
+    CALL_CHECK(libusb_bulk_transfer(handle, endpoint_in, (unsigned char *)&buffer, READ_CAPACITY_LENGTH, &size, 1000));
+    printf("   received %d bytes\n", size);
+    max_lba     = be_to_int32(&buffer[0]);
+    block_size  = be_to_int32(&buffer[4]);
+    device_size = ((double)(max_lba + 1)) * block_size / (1024 * 1024 * 1024);
+    printf("   Max LBA: %08X, Block Size: %08X (%.2f GB)\n", max_lba, block_size, device_size);
+    if(get_mass_storage_status(handle, endpoint_in, expected_tag) == -2) {
+        get_sense(handle, endpoint_in, endpoint_out);
+    }
+
+    // coverity[tainted_data]
+    data = (unsigned char *)calloc(1, block_size);
+    if(data == NULL) {
+        perr("   unable to allocate data buffer\n");
+        return -1;
+    }
+
+    // Send Read
+    printf("\nAttempting to read %u bytes:\n", block_size);
+    memset(cdb, 0, sizeof(cdb));
+
+    cdb[0] = 0x28;  // Read(10)
+    cdb[8] = 0x01;  // 1 block
+
+    send_mass_storage_command(handle, endpoint_out, lun, cdb, LIBUSB_ENDPOINT_IN, block_size, &expected_tag);
+    libusb_bulk_transfer(handle, endpoint_in, data, block_size, &size, 5000);
+    printf("   READ: received %d bytes\n", size);
+    if(get_mass_storage_status(handle, endpoint_in, expected_tag) == -2) {
+        get_sense(handle, endpoint_in, endpoint_out);
+    }
+    else {
+        display_buffer_hex(data, size);
+        if((binary_dump) && ((fd = fopen(binary_name, "w")) != NULL)) {
+            if(fwrite(data, 1, (size_t)size, fd) != (unsigned int)size) {
+                perr("   unable to write binary data\n");
+            }
+            fclose(fd);
+        }
+    }
+    free(data);
+
+    return 0;
+}
+
+// HID
+static int get_hid_record_size(uint8_t *hid_report_descriptor, int size, int type) {
+    uint8_t i, j = 0;
+    uint8_t offset;
+    int     record_size[3] = { 0, 0, 0 };
+    int     nb_bits = 0, nb_items = 0;
+    bool    found_record_marker;
+
+    found_record_marker = false;
+    for(i = hid_report_descriptor[0] + 1; i < size; i += offset) {
+        offset = (hid_report_descriptor[i] & 0x03) + 1;
+        if(offset == 4)
+            offset = 5;
+        switch(hid_report_descriptor[i] & 0xFC) {
+        case 0x74:  // bitsize
+            nb_bits = hid_report_descriptor[i + 1];
+            break;
+        case 0x94:  // count
+            nb_items = 0;
+            for(j = 1; j < offset; j++) {
+                nb_items = ((uint32_t)hid_report_descriptor[i + j]) << (8 * (j - 1));
+            }
+            break;
+        case 0x80:  // input
+            found_record_marker = true;
+            j                   = 0;
+            break;
+        case 0x90:  // output
+            found_record_marker = true;
+            j                   = 1;
+            break;
+        case 0xb0:  // feature
+            found_record_marker = true;
+            j                   = 2;
+            break;
+        case 0xC0:  // end of collection
+            nb_items = 0;
+            nb_bits  = 0;
+            break;
+        default:
+            continue;
+        }
+        if(found_record_marker) {
+            found_record_marker = false;
+            record_size[j] += nb_items * nb_bits;
+        }
+    }
+    if((type < HID_REPORT_TYPE_INPUT) || (type > HID_REPORT_TYPE_FEATURE)) {
+        return 0;
+    }
+    else {
+        return (record_size[type - HID_REPORT_TYPE_INPUT] + 7) / 8;
+    }
+}
+
+static int test_hid(libusb_device_handle *handle, uint8_t endpoint_in) {
+    int      r, size, descriptor_size;
+    uint8_t  hid_report_descriptor[256];
+    uint8_t *report_buffer;
+    FILE    *fd;
+
+    printf("\nReading HID Report Descriptors:\n");
+    descriptor_size =
+        libusb_control_transfer(handle, LIBUSB_ENDPOINT_IN | LIBUSB_REQUEST_TYPE_STANDARD | LIBUSB_RECIPIENT_INTERFACE, LIBUSB_REQUEST_GET_DESCRIPTOR,
+                                LIBUSB_DT_REPORT << 8, 0, hid_report_descriptor, sizeof(hid_report_descriptor), 1000);
+    if(descriptor_size < 0) {
+        printf("   Failed\n");
+        return -1;
+    }
+    display_buffer_hex(hid_report_descriptor, descriptor_size);
+    if((binary_dump) && ((fd = fopen(binary_name, "w")) != NULL)) {
+        if(fwrite(hid_report_descriptor, 1, descriptor_size, fd) != (size_t)descriptor_size) {
+            printf("   Error writing descriptor to file\n");
+        }
+        fclose(fd);
+    }
+
+    size = get_hid_record_size(hid_report_descriptor, descriptor_size, HID_REPORT_TYPE_FEATURE);
+    if(size <= 0) {
+        printf("\nSkipping Feature Report readout (None detected)\n");
+    }
+    else {
+        report_buffer = (uint8_t *)calloc(size, 1);
+        if(report_buffer == NULL) {
+            return -1;
+        }
+
+        printf("\nReading Feature Report (length %d)...\n", size);
+        r = libusb_control_transfer(handle, LIBUSB_ENDPOINT_IN | LIBUSB_REQUEST_TYPE_CLASS | LIBUSB_RECIPIENT_INTERFACE, HID_GET_REPORT,
+                                    (HID_REPORT_TYPE_FEATURE << 8) | 0, 0, report_buffer, (uint16_t)size, 5000);
+        if(r >= 0) {
+            display_buffer_hex(report_buffer, size);
+        }
+        else {
+            switch(r) {
+            case LIBUSB_ERROR_NOT_FOUND:
+                printf("   No Feature Report available for this device\n");
+                break;
+            case LIBUSB_ERROR_PIPE:
+                printf("   Detected stall - resetting pipe...\n");
+                libusb_clear_halt(handle, 0);
+                break;
+            default:
+                printf("   Error: %s\n", libusb_strerror((enum libusb_error)r));
+                break;
+            }
+        }
+        free(report_buffer);
+    }
+
+    size = get_hid_record_size(hid_report_descriptor, descriptor_size, HID_REPORT_TYPE_INPUT);
+    if(size <= 0) {
+        printf("\nSkipping Input Report readout (None detected)\n");
+    }
+    else {
+        report_buffer = (uint8_t *)calloc(size, 1);
+        if(report_buffer == NULL) {
+            return -1;
+        }
+
+        printf("\nReading Input Report (length %d)...\n", size);
+        r = libusb_control_transfer(handle, LIBUSB_ENDPOINT_IN | LIBUSB_REQUEST_TYPE_CLASS | LIBUSB_RECIPIENT_INTERFACE, HID_GET_REPORT,
+                                    (HID_REPORT_TYPE_INPUT << 8) | 0x00, 0, report_buffer, (uint16_t)size, 5000);
+        if(r >= 0) {
+            display_buffer_hex(report_buffer, size);
+        }
+        else {
+            switch(r) {
+            case LIBUSB_ERROR_TIMEOUT:
+                printf("   Timeout! Please make sure you act on the device within the 5 seconds allocated...\n");
+                break;
+            case LIBUSB_ERROR_PIPE:
+                printf("   Detected stall - resetting pipe...\n");
+                libusb_clear_halt(handle, 0);
+                break;
+            default:
+                printf("   Error: %s\n", libusb_strerror((enum libusb_error)r));
+                break;
+            }
+        }
+
+        // Attempt a bulk read from endpoint 0 (this should just return a raw input report)
+        printf("\nTesting interrupt read using endpoint %02X...\n", endpoint_in);
+        r = libusb_interrupt_transfer(handle, endpoint_in, report_buffer, size, &size, 5000);
+        if(r >= 0) {
+            display_buffer_hex(report_buffer, size);
+        }
+        else {
+            printf("   %s\n", libusb_strerror((enum libusb_error)r));
+        }
+
+        free(report_buffer);
+    }
+    return 0;
+}
+
+// Read the MS WinUSB Feature Descriptors, that are used on Windows 8 for automated driver installation
+static void read_ms_winsub_feature_descriptors(libusb_device_handle *handle, uint8_t bRequest, int iface_number) {
+#define MAX_OS_FD_LENGTH 256
+    int      i, r;
+    uint8_t  os_desc[MAX_OS_FD_LENGTH];
+    uint32_t length;
+    void    *le_type_punning_IS_fine;
+    struct {
+        const char *desc;
+        uint8_t     recipient;
+        uint16_t    index;
+        uint16_t    header_size;
+    } os_fd[2] = { { "Extended Compat ID", LIBUSB_RECIPIENT_DEVICE, 0x0004, 0x10 }, { "Extended Properties", LIBUSB_RECIPIENT_INTERFACE, 0x0005, 0x0A } };
+
+    if(iface_number < 0)
+        return;
+    // WinUSB has a limitation that forces wIndex to the interface number when issuing
+    // an Interface Request. To work around that, we can force a Device Request for
+    // the Extended Properties, assuming the device answers both equally.
+    if(force_device_request)
+        os_fd[1].recipient = LIBUSB_RECIPIENT_DEVICE;
+
+    for(i = 0; i < 2; i++) {
+        printf("\nReading %s OS Feature Descriptor (wIndex = 0x%04d):\n", os_fd[i].desc, os_fd[i].index);
+
+        // Read the header part
+        r = libusb_control_transfer(handle, (uint8_t)(LIBUSB_ENDPOINT_IN | LIBUSB_REQUEST_TYPE_VENDOR | os_fd[i].recipient), bRequest,
+                                    (uint16_t)(((iface_number) << 8) | 0x00), os_fd[i].index, os_desc, os_fd[i].header_size, 1000);
+        if(r < os_fd[i].header_size) {
+            perr("   Failed: %s", (r < 0) ? libusb_strerror((enum libusb_error)r) : "header size is too small");
+            return;
+        }
+        le_type_punning_IS_fine = (void *)os_desc;
+        length                  = *((uint32_t *)le_type_punning_IS_fine);
+        if(length > MAX_OS_FD_LENGTH) {
+            length = MAX_OS_FD_LENGTH;
+        }
+
+        // Read the full feature descriptor
+        r = libusb_control_transfer(handle, (uint8_t)(LIBUSB_ENDPOINT_IN | LIBUSB_REQUEST_TYPE_VENDOR | os_fd[i].recipient), bRequest,
+                                    (uint16_t)(((iface_number) << 8) | 0x00), os_fd[i].index, os_desc, (uint16_t)length, 1000);
+        if(r < 0) {
+            perr("   Failed: %s", libusb_strerror((enum libusb_error)r));
+            return;
+        }
+        else {
+            display_buffer_hex(os_desc, r);
+        }
+    }
+}
+
+static void print_device_cap(struct libusb_bos_dev_capability_descriptor *dev_cap) {
+    switch(dev_cap->bDevCapabilityType) {
+    case LIBUSB_BT_USB_2_0_EXTENSION: {
+        struct libusb_usb_2_0_extension_descriptor *usb_2_0_ext = NULL;
+        libusb_get_usb_2_0_extension_descriptor(NULL, dev_cap, &usb_2_0_ext);
+        if(usb_2_0_ext) {
+            printf("    USB 2.0 extension:\n");
+            printf("      attributes             : %02X\n", usb_2_0_ext->bmAttributes);
+            libusb_free_usb_2_0_extension_descriptor(usb_2_0_ext);
+        }
+        break;
+    }
+    case LIBUSB_BT_SS_USB_DEVICE_CAPABILITY: {
+        struct libusb_ss_usb_device_capability_descriptor *ss_usb_device_cap = NULL;
+        libusb_get_ss_usb_device_capability_descriptor(NULL, dev_cap, &ss_usb_device_cap);
+        if(ss_usb_device_cap) {
+            printf("    USB 3.0 capabilities:\n");
+            printf("      attributes             : %02X\n", ss_usb_device_cap->bmAttributes);
+            printf("      supported speeds       : %04X\n", ss_usb_device_cap->wSpeedSupported);
+            printf("      supported functionality: %02X\n", ss_usb_device_cap->bFunctionalitySupport);
+            libusb_free_ss_usb_device_capability_descriptor(ss_usb_device_cap);
+        }
+        break;
+    }
+    case LIBUSB_BT_CONTAINER_ID: {
+        struct libusb_container_id_descriptor *container_id = NULL;
+        libusb_get_container_id_descriptor(NULL, dev_cap, &container_id);
+        if(container_id) {
+            printf("    Container ID:\n      %s\n", uuid_to_string(container_id->ContainerID));
+            libusb_free_container_id_descriptor(container_id);
+        }
+        break;
+    }
+    case LIBUSB_BT_PLATFORM_DESCRIPTOR: {
+        struct libusb_platform_descriptor *platform_descriptor = NULL;
+        libusb_get_platform_descriptor(NULL, dev_cap, &platform_descriptor);
+        if(platform_descriptor) {
+            printf("    Platform descriptor:\n");
+            printf("      bLength                : %d\n", platform_descriptor->bLength);
+            printf("      PlatformCapabilityUUID : %s\n", uuid_to_string(platform_descriptor->PlatformCapabilityUUID));
+            display_buffer_hex(&platform_descriptor->CapabilityData[0], platform_descriptor->bLength - 20);
+            printf("\n");
+            libusb_free_platform_descriptor(platform_descriptor);
+        }
+        break;
+    }
+    default:
+        printf("    Unknown BOS device capability %02x:\n", dev_cap->bDevCapabilityType);
+    }
+}
+
+static int test_device(uint16_t vid, uint16_t pid) {
+    libusb_device_handle                    *handle;
+    libusb_device                           *dev;
+    uint8_t                                  bus, port_path[8];
+    struct libusb_bos_descriptor            *bos_desc;
+    struct libusb_config_descriptor         *conf_desc;
+    const struct libusb_endpoint_descriptor *endpoint;
+    int                                      i, j, k, r;
+    int                                      iface, nb_ifaces, first_iface = -1;
+    struct libusb_device_descriptor          dev_desc;
+    const char *const                        speed_name[6] = { "Unknown",
+                                                               "1.5 Mbit/s (USB LowSpeed)",
+                                                               "12 Mbit/s (USB FullSpeed)",
+                                                               "480 Mbit/s (USB HighSpeed)",
+                                                               "5000 Mbit/s (USB SuperSpeed)",
+                                                               "10000 Mbit/s (USB SuperSpeedPlus)" };
+    char                                     string[128];
+    uint8_t                                  string_index[3];                    // indexes of the string descriptors
+    uint8_t                                  endpoint_in = 0, endpoint_out = 0;  // default IN and OUT endpoints
+
+    printf("Opening device %04X:%04X...\n", vid, pid);
+    handle = libusb_open_device_with_vid_pid(NULL, vid, pid);
+
+    if(handle == NULL) {
+        perr("  Failed.\n");
+        return -1;
+    }
+
+    dev = libusb_get_device(handle);
+    bus = libusb_get_bus_number(dev);
+    if(extra_info) {
+        r = libusb_get_port_numbers(dev, port_path, sizeof(port_path));
+        if(r > 0) {
+            printf("\nDevice properties:\n");
+            printf("        bus number: %d\n", bus);
+            printf("         port path: %d", port_path[0]);
+            for(i = 1; i < r; i++) {
+                printf("->%d", port_path[i]);
+            }
+            printf(" (from root hub)\n");
+        }
+        r = libusb_get_device_speed(dev);
+        if((r < 0) || (r > 5))
+            r = 0;
+        printf("             speed: %s\n", speed_name[r]);
+    }
+
+    printf("\nReading device descriptor:\n");
+    CALL_CHECK_CLOSE(libusb_get_device_descriptor(dev, &dev_desc), handle);
+    printf("            length: %d\n", dev_desc.bLength);
+    printf("      device class: %d\n", dev_desc.bDeviceClass);
+    printf("               S/N: %d\n", dev_desc.iSerialNumber);
+    printf("           VID:PID: %04X:%04X\n", dev_desc.idVendor, dev_desc.idProduct);
+    printf("         bcdDevice: %04X\n", dev_desc.bcdDevice);
+    printf("   iMan:iProd:iSer: %d:%d:%d\n", dev_desc.iManufacturer, dev_desc.iProduct, dev_desc.iSerialNumber);
+    printf("          nb confs: %d\n", dev_desc.bNumConfigurations);
+    // Copy the string descriptors for easier parsing
+    string_index[0] = dev_desc.iManufacturer;
+    string_index[1] = dev_desc.iProduct;
+    string_index[2] = dev_desc.iSerialNumber;
+
+    printf("\nReading BOS descriptor: ");
+    if(libusb_get_bos_descriptor(handle, &bos_desc) == LIBUSB_SUCCESS) {
+        printf("%d caps\n", bos_desc->bNumDeviceCaps);
+        for(i = 0; i < bos_desc->bNumDeviceCaps; i++)
+            print_device_cap(bos_desc->dev_capability[i]);
+        libusb_free_bos_descriptor(bos_desc);
+    }
+    else {
+        printf("no descriptor\n");
+    }
+
+    printf("\nReading first configuration descriptor:\n");
+    CALL_CHECK_CLOSE(libusb_get_config_descriptor(dev, 0, &conf_desc), handle);
+    printf("              total length: %d\n", conf_desc->wTotalLength);
+    printf("         descriptor length: %d\n", conf_desc->bLength);
+    nb_ifaces = conf_desc->bNumInterfaces;
+    printf("             nb interfaces: %d\n", nb_ifaces);
+    if(nb_ifaces > 0)
+        first_iface = conf_desc->usb_interface[0].altsetting[0].bInterfaceNumber;
+    for(i = 0; i < nb_ifaces; i++) {
+        printf("              interface[%d]: id = %d\n", i, conf_desc->usb_interface[i].altsetting[0].bInterfaceNumber);
+        for(j = 0; j < conf_desc->usb_interface[i].num_altsetting; j++) {
+            printf("interface[%d].altsetting[%d]: num endpoints = %d\n", i, j, conf_desc->usb_interface[i].altsetting[j].bNumEndpoints);
+            printf("   Class.SubClass.Protocol: %02X.%02X.%02X\n", conf_desc->usb_interface[i].altsetting[j].bInterfaceClass,
+                   conf_desc->usb_interface[i].altsetting[j].bInterfaceSubClass, conf_desc->usb_interface[i].altsetting[j].bInterfaceProtocol);
+            if((conf_desc->usb_interface[i].altsetting[j].bInterfaceClass == LIBUSB_CLASS_MASS_STORAGE)
+               && ((conf_desc->usb_interface[i].altsetting[j].bInterfaceSubClass == 0x01)
+                   || (conf_desc->usb_interface[i].altsetting[j].bInterfaceSubClass == 0x06))
+               && (conf_desc->usb_interface[i].altsetting[j].bInterfaceProtocol == 0x50)) {
+                // Mass storage devices that can use basic SCSI commands
+                test_mode = USE_SCSI;
+            }
+            for(k = 0; k < conf_desc->usb_interface[i].altsetting[j].bNumEndpoints; k++) {
+                struct libusb_ss_endpoint_companion_descriptor *ep_comp = NULL;
+                endpoint                                                = &conf_desc->usb_interface[i].altsetting[j].endpoint[k];
+                printf("       endpoint[%d].address: %02X\n", k, endpoint->bEndpointAddress);
+                // Use the first interrupt or bulk IN/OUT endpoints as default for testing
+                if((endpoint->bmAttributes & LIBUSB_TRANSFER_TYPE_MASK) & (LIBUSB_TRANSFER_TYPE_BULK | LIBUSB_TRANSFER_TYPE_INTERRUPT)) {
+                    if(endpoint->bEndpointAddress & LIBUSB_ENDPOINT_IN) {
+                        if(!endpoint_in)
+                            endpoint_in = endpoint->bEndpointAddress;
+                    }
+                    else {
+                        if(!endpoint_out)
+                            endpoint_out = endpoint->bEndpointAddress;
+                    }
+                }
+                printf("           max packet size: %04X\n", endpoint->wMaxPacketSize);
+                printf("          polling interval: %02X\n", endpoint->bInterval);
+                libusb_get_ss_endpoint_companion_descriptor(NULL, endpoint, &ep_comp);
+                if(ep_comp) {
+                    printf("                 max burst: %02X   (USB 3.0)\n", ep_comp->bMaxBurst);
+                    printf("        bytes per interval: %04X (USB 3.0)\n", ep_comp->wBytesPerInterval);
+                    libusb_free_ss_endpoint_companion_descriptor(ep_comp);
+                }
+            }
+        }
+    }
+    libusb_free_config_descriptor(conf_desc);
+
+    libusb_set_auto_detach_kernel_driver(handle, 1);
+    for(iface = 0; iface < nb_ifaces; iface++) {
+        int ret;
+
+        printf("\nKernel driver attached for interface %d: ", iface);
+        ret = libusb_kernel_driver_active(handle, iface);
+        if(ret == 0)
+            printf("none\n");
+        else if(ret == 1)
+            printf("yes\n");
+        else if(ret == LIBUSB_ERROR_NOT_SUPPORTED)
+            printf("(not supported)\n");
+        else
+            perr("\n   Failed (error %d) %s\n", ret, libusb_strerror((enum libusb_error)ret));
+
+        printf("\nClaiming interface %d...\n", iface);
+        r = libusb_claim_interface(handle, iface);
+        if(r != LIBUSB_SUCCESS) {
+            perr("   Failed (error %d) %s\n", ret, libusb_strerror((enum libusb_error)ret));
+        }
+    }
+
+    printf("\nReading string descriptors:\n");
+    for(i = 0; i < 3; i++) {
+        if(string_index[i] == 0) {
+            continue;
+        }
+        if(libusb_get_string_descriptor_ascii(handle, string_index[i], (unsigned char *)string, sizeof(string)) > 0) {
+            printf("   String (0x%02X): \"%s\"\n", string_index[i], string);
+        }
+    }
+
+    printf("\nReading OS string descriptor:");
+    r = libusb_get_string_descriptor(handle, MS_OS_DESC_STRING_INDEX, 0, (unsigned char *)string, MS_OS_DESC_STRING_LENGTH);
+    if(r == MS_OS_DESC_STRING_LENGTH && memcmp(ms_os_desc_string, string, sizeof(ms_os_desc_string)) == 0) {
+        // If this is a Microsoft OS String Descriptor,
+        // attempt to read the WinUSB extended Feature Descriptors
+        printf("\n");
+        read_ms_winsub_feature_descriptors(handle, string[MS_OS_DESC_VENDOR_CODE_OFFSET], first_iface);
+    }
+    else {
+        printf(" no descriptor\n");
+    }
+
+    // Read IADs
+    printf("\nReading interface association descriptors (IADs) for first configuration:\n");
+    struct libusb_interface_association_descriptor_array *iad_array;
+    r = libusb_get_interface_association_descriptors(dev, 0, &iad_array);
+    if(r == LIBUSB_SUCCESS) {
+        printf("    nb IADs: %d\n", iad_array->length);
+        for(i = 0; i < iad_array->length; i++) {
+            const struct libusb_interface_association_descriptor *iad = &iad_array->iad[i];
+            printf("      IAD %d:\n", i);
+            printf("            bFirstInterface: %u\n", iad->bFirstInterface);
+            printf("            bInterfaceCount: %u\n", iad->bInterfaceCount);
+            printf("             bFunctionClass: %02X\n", iad->bFunctionClass);
+            printf("          bFunctionSubClass: %02X\n", iad->bFunctionSubClass);
+            printf("          bFunctionProtocol: %02X\n", iad->bFunctionProtocol);
+            if(iad->iFunction) {
+                if(libusb_get_string_descriptor_ascii(handle, iad->iFunction, (unsigned char *)string, sizeof(string)) > 0)
+                    printf("                  iFunction: %u (%s)\n", iad->iFunction, string);
+                else
+                    printf("                  iFunction: %u (libusb_get_string_descriptor_ascii failed!)\n", iad->iFunction);
+            }
+            else
+                printf("                  iFunction: 0\n");
+        }
+        libusb_free_interface_association_descriptors(iad_array);
+    }
+
+    switch(test_mode) {
+    case USE_PS3:
+        CALL_CHECK_CLOSE(display_ps3_status(handle), handle);
+        break;
+    case USE_XBOX:
+        CALL_CHECK_CLOSE(display_xbox_status(handle), handle);
+        CALL_CHECK_CLOSE(set_xbox_actuators(handle, 128, 222), handle);
+        msleep(2000);
+        CALL_CHECK_CLOSE(set_xbox_actuators(handle, 0, 0), handle);
+        break;
+    case USE_HID:
+        test_hid(handle, endpoint_in);
+        break;
+    case USE_SCSI:
+        CALL_CHECK_CLOSE(test_mass_storage(handle, endpoint_in, endpoint_out), handle);
+    case USE_GENERIC:
+        break;
+    }
+
+    printf("\n");
+    for(iface = 0; iface < nb_ifaces; iface++) {
+        printf("Releasing interface %d...\n", iface);
+        libusb_release_interface(handle, iface);
+    }
+
+    printf("Closing device...\n");
+    libusb_close(handle);
+
+    return 0;
+}
+
+int main(int argc, char **argv) {
+    static char                  debug_env_str[] = "LIBUSB_DEBUG=4";  // LIBUSB_LOG_LEVEL_DEBUG
+    bool                         show_help       = false;
+    bool                         debug_mode      = false;
+    const struct libusb_version *version;
+    int                          j, r;
+    size_t                       i, arglen;
+    unsigned                     tmp_vid, tmp_pid;
+    uint16_t                     endian_test = 0xBE00;
+    char                        *error_lang = NULL, *old_dbg_str = NULL, str[256];
+
+    // Default to generic, expecting VID:PID
+    VID       = 0;
+    PID       = 0;
+    test_mode = USE_GENERIC;
+
+    if(((uint8_t *)&endian_test)[0] == 0xBE) {
+        printf("Despite their natural superiority for end users, big endian\n"
+               "CPUs are not supported with this program, sorry.\n");
+        return 0;
+    }
+
+    if(argc >= 2) {
+        for(j = 1; j < argc; j++) {
+            arglen = strlen(argv[j]);
+            if(((argv[j][0] == '-') || (argv[j][0] == '/')) && (arglen >= 2)) {
+                switch(argv[j][1]) {
+                case 'd':
+                    debug_mode = true;
+                    break;
+                case 'i':
+                    extra_info = true;
+                    break;
+                case 'w':
+                    force_device_request = true;
+                    break;
+                case 'b':
+                    if((j + 1 >= argc) || (argv[j + 1][0] == '-') || (argv[j + 1][0] == '/')) {
+                        printf("   Option -b requires a file name\n");
+                        return 1;
+                    }
+                    binary_name = argv[++j];
+                    binary_dump = true;
+                    break;
+                case 'l':
+                    if((j + 1 >= argc) || (argv[j + 1][0] == '-') || (argv[j + 1][0] == '/')) {
+                        printf("   Option -l requires an ISO 639-1 language parameter\n");
+                        return 1;
+                    }
+                    error_lang = argv[++j];
+                    break;
+                case 'j':
+                    // OLIMEX ARM-USB-TINY JTAG, 2 channel composite device - 2 interfaces
+                    if(!VID && !PID) {
+                        VID = 0x15BA;
+                        PID = 0x0004;
+                    }
+                    break;
+                case 'k':
+                    // Generic 2 GB USB Key (SCSI Transparent/Bulk Only) - 1 interface
+                    if(!VID && !PID) {
+                        VID = 0x0204;
+                        PID = 0x6025;
+                    }
+                    break;
+                // The following tests will force VID:PID if already provided
+                case 'p':
+                    // Sony PS3 Controller - 1 interface
+                    VID       = 0x054C;
+                    PID       = 0x0268;
+                    test_mode = USE_PS3;
+                    break;
+                case 's':
+                    // Microsoft Sidewinder Precision Pro Joystick - 1 HID interface
+                    VID       = 0x045E;
+                    PID       = 0x0008;
+                    test_mode = USE_HID;
+                    break;
+                case 'x':
+                    // Microsoft XBox Controller Type S - 1 interface
+                    VID       = 0x045E;
+                    PID       = 0x0289;
+                    test_mode = USE_XBOX;
+                    break;
+                default:
+                    show_help = true;
+                    break;
+                }
+            }
+            else {
+                for(i = 0; i < arglen; i++) {
+                    if(argv[j][i] == ':')
+                        break;
+                }
+                if(i != arglen) {
+                    if(sscanf(argv[j], "%x:%x", &tmp_vid, &tmp_pid) != 2) {
+                        printf("   Please specify VID & PID as \"vid:pid\" in hexadecimal format\n");
+                        return 1;
+                    }
+                    VID = (uint16_t)tmp_vid;
+                    PID = (uint16_t)tmp_pid;
+                }
+                else {
+                    show_help = true;
+                }
+            }
+        }
+    }
+
+    if((show_help) || (argc == 1) || (argc > 7)) {
+        printf("usage: %s [-h] [-d] [-i] [-k] [-b file] [-l lang] [-j] [-x] [-s] [-p] [-w] [vid:pid]\n", argv[0]);
+        printf("   -h      : display usage\n");
+        printf("   -d      : enable debug output\n");
+        printf("   -i      : print topology and speed info\n");
+        printf("   -j      : test composite FTDI based JTAG device\n");
+        printf("   -k      : test Mass Storage device\n");
+        printf("   -b file : dump Mass Storage data to file 'file'\n");
+        printf("   -p      : test Sony PS3 SixAxis controller\n");
+        printf("   -s      : test Microsoft Sidewinder Precision Pro (HID)\n");
+        printf("   -x      : test Microsoft XBox Controller Type S\n");
+        printf("   -l lang : language to report errors in (ISO 639-1)\n");
+        printf("   -w      : force the use of device requests when querying WCID descriptors\n");
+        printf("If only the vid:pid is provided, xusb attempts to run the most appropriate test\n");
+        return 0;
+    }
+
+    // xusb is commonly used as a debug tool, so it's convenient to have debug output during libusb_init(),
+    // but since we can't call on libusb_set_option() before libusb_init(), we use the env variable method
+    old_dbg_str = getenv("LIBUSB_DEBUG");
+    if(debug_mode) {
+        if(putenv(debug_env_str) != 0)
+            printf("Unable to set debug level\n");
+    }
+
+    version = libusb_get_version();
+    printf("Using libusb v%d.%d.%d.%d\n\n", version->major, version->minor, version->micro, version->nano);
+    r = libusb_init_context(/*ctx=*/NULL, /*options=*/NULL, /*num_options=*/0);
+    if(r < 0)
+        return r;
+
+    // If not set externally, and no debug option was given, use info log level
+    if((old_dbg_str == NULL) && (!debug_mode))
+        libusb_set_option(NULL, LIBUSB_OPTION_LOG_LEVEL, LIBUSB_LOG_LEVEL_INFO);
+    if(error_lang != NULL) {
+        r = libusb_setlocale(error_lang);
+        if(r < 0)
+            printf("Invalid or unsupported locale '%s': %s\n", error_lang, libusb_strerror((enum libusb_error)r));
+    }
+
+    test_device(VID, PID);
+
+    libusb_exit(NULL);
+
+    if(debug_mode) {
+        snprintf(str, sizeof(str), "LIBUSB_DEBUG=%s", (old_dbg_str == NULL) ? "" : old_dbg_str);
+        str[sizeof(str) - 1] = 0;  // Windows may not NUL terminate the string
+    }
+
+    return 0;
+}
diff --git a/3rdparty/libusb/src/libusb-1.0.pc.in b/3rdparty/libusb/src/libusb-1.0.pc.in
new file mode 100644
index 00000000..4aba609e
--- /dev/null
+++ b/3rdparty/libusb/src/libusb-1.0.pc.in
@@ -0,0 +1,11 @@
+prefix=@prefix@
+exec_prefix=@exec_prefix@
+libdir=@libdir@
+includedir=@includedir@
+
+Name: libusb-1.0
+Description: C API for USB device access from Linux, Mac OS X, Windows, OpenBSD/NetBSD and Solaris userspace
+Version: @VERSION@
+Libs: -L${libdir} -lusb-1.0
+Libs.private: @LIBS@
+Cflags: -I${includedir}/libusb-1.0
diff --git a/3rdparty/libusb/src/libusb/Makefile.am b/3rdparty/libusb/src/libusb/Makefile.am
new file mode 100644
index 00000000..30d35476
--- /dev/null
+++ b/3rdparty/libusb/src/libusb/Makefile.am
@@ -0,0 +1,95 @@
+AUTOMAKE_OPTIONS = subdir-objects
+
+AM_CFLAGS += -fvisibility=hidden $(THREAD_CFLAGS)
+AM_CXXFLAGS += -fvisibility=hidden $(THREAD_CFLAGS)
+
+lib_LTLIBRARIES = libusb-1.0.la
+
+POSIX_PLATFORM_SRC = os/events_posix.h os/events_posix.c \
+		     os/threads_posix.h os/threads_posix.c
+WINDOWS_PLATFORM_SRC = os/events_windows.h os/events_windows.c \
+		       os/threads_windows.h os/threads_windows.c
+
+if PLATFORM_POSIX
+PLATFORM_SRC = $(POSIX_PLATFORM_SRC)
+else
+PLATFORM_SRC = $(WINDOWS_PLATFORM_SRC)
+endif
+
+OS_DARWIN_SRC = os/darwin_usb.h os/darwin_usb.c
+OS_HAIKU_SRC = os/haiku_usb.h os/haiku_usb_backend.cpp \
+	       os/haiku_pollfs.cpp os/haiku_usb_raw.h os/haiku_usb_raw.cpp
+OS_LINUX_SRC = os/linux_usbfs.h os/linux_usbfs.c
+OS_EMSCRIPTEN_SRC = os/emscripten_webusb.cpp
+OS_NETBSD_SRC = os/netbsd_usb.c
+OS_NULL_SRC = os/null_usb.c
+OS_OPENBSD_SRC = os/openbsd_usb.c
+OS_SUNOS_SRC = os/sunos_usb.h os/sunos_usb.c
+OS_WINDOWS_SRC = libusb-1.0.def libusb-1.0.rc \
+		 os/windows_common.h os/windows_common.c \
+		 os/windows_usbdk.h os/windows_usbdk.c \
+		 os/windows_winusb.h os/windows_winusb.c
+
+if OS_DARWIN
+OS_SRC = $(OS_DARWIN_SRC)
+endif
+
+if OS_HAIKU
+noinst_LTLIBRARIES = libusb_haiku.la
+libusb_haiku_la_SOURCES = $(OS_HAIKU_SRC)
+libusb_1_0_la_LIBADD = libusb_haiku.la
+endif
+
+if OS_LINUX
+OS_SRC = $(OS_LINUX_SRC)
+if USE_UDEV
+OS_SRC += os/linux_udev.c
+else
+OS_SRC += os/linux_netlink.c
+endif
+endif
+
+if OS_EMSCRIPTEN
+noinst_LTLIBRARIES = libusb_emscripten.la
+libusb_emscripten_la_SOURCES = $(OS_EMSCRIPTEN_SRC)
+libusb_1_0_la_LIBADD = libusb_emscripten.la
+endif
+
+if OS_NETBSD
+OS_SRC = $(OS_NETBSD_SRC)
+endif
+
+if OS_NULL
+OS_SRC = $(OS_NULL_SRC)
+endif
+
+if OS_OPENBSD
+OS_SRC = $(OS_OPENBSD_SRC)
+endif
+
+if OS_SUNOS
+OS_SRC = $(OS_SUNOS_SRC)
+endif
+
+if OS_WINDOWS
+OS_SRC = $(OS_WINDOWS_SRC)
+
+include Makefile.am.extra
+
+# Dependencies for compiling libusb-1.0.lo from libusb-1.0.rc
+-include ./$(DEPDIR)/libusb-1.0.Plo
+
+if CREATE_IMPORT_LIB
+all-local: .libs/libusb-1.0.dll.a
+# Rebuild the import lib from the .def so that MS and MinGW DLLs can be interchanged
+.libs/libusb-1.0.dll.a: libusb-1.0.def libusb-1.0.la
+	$(AM_V_DLLTOOL)$(DLLTOOL) $(DLLTOOLFLAGS) --kill-at --input-def $< --dllname libusb-1.0.dll --output-lib $@
+endif
+endif
+
+libusb_1_0_la_LDFLAGS = $(LT_LDFLAGS) $(EXTRA_LDFLAGS)
+libusb_1_0_la_SOURCES = libusbi.h version.h version_nano.h \
+	core.c descriptor.c hotplug.c io.c strerror.c sync.c \
+	$(PLATFORM_SRC) $(OS_SRC)
+
+pkginclude_HEADERS = libusb.h
diff --git a/3rdparty/libusb/src/libusb/Makefile.am.extra b/3rdparty/libusb/src/libusb/Makefile.am.extra
new file mode 100644
index 00000000..a5c14905
--- /dev/null
+++ b/3rdparty/libusb/src/libusb/Makefile.am.extra
@@ -0,0 +1,26 @@
+AM_V_DLLTOOL = $(am__v_DLLTOOL_$(V))
+am__v_DLLTOOL_ = $(am__v_DLLTOOL_$(AM_DEFAULT_VERBOSITY))
+am__v_DLLTOOL_0 = @echo "  DLLTOOL " $@;
+am__v_DLLTOOL_1 = 
+
+AM_V_RC = $(am__v_RC_$(V))
+am__v_RC_ = $(am__v_RC_$(AM_DEFAULT_VERBOSITY))
+am__v_RC_0 = @echo "  RC      " $@;
+am__v_RC_1 = 
+
+LTRC = $(LIBTOOL) $(AM_V_lt) --tag=RC $(AM_LIBTOOLFLAGS) \
+       $(LIBTOOLFLAGS) --mode=compile $(RC) $(AM_RCFLAGS) \
+       $(RCFLAGS)
+
+RCPPARGS = \
+	--preprocessor-arg -MT \
+	--preprocessor-arg $@ \
+	--preprocessor-arg -MD \
+	--preprocessor-arg -MP \
+	--preprocessor-arg -MF \
+	--preprocessor-arg $$depbase.Tpo
+
+.rc.lo:
+	$(AM_V_RC)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.lo$$||'`;\
+	$(LTRC) $(RCPPARGS) -i $< -o $@ &&\
+	$(am__mv) $$depbase.Tpo $$depbase.Plo
diff --git a/3rdparty/libusb/src/libusb/core.c b/3rdparty/libusb/src/libusb/core.c
new file mode 100644
index 00000000..57339979
--- /dev/null
+++ b/3rdparty/libusb/src/libusb/core.c
@@ -0,0 +1,2823 @@
+/* -*- Mode: C; indent-tabs-mode:t ; c-basic-offset:8 -*- */
+/*
+ * Core functions for libusb
+ * Copyright © 2012-2023 Nathan Hjelm <hjelmn@cs.unm.edu>
+ * Copyright © 2007-2008 Daniel Drake <dsd@gentoo.org>
+ * Copyright © 2001 Johannes Erdfelt <johannes@erdfelt.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "libusbi.h"
+#include "version.h"
+
+#ifdef __ANDROID__
+#include <android/log.h>
+#endif
+#include <stdio.h>
+#include <string.h>
+#ifdef HAVE_SYSLOG
+#include <syslog.h>
+#endif
+
+static const struct libusb_version libusb_version_internal = { LIBUSB_MAJOR, LIBUSB_MINOR, LIBUSB_MICRO, LIBUSB_NANO, LIBUSB_RC, "http://libusb.info" };
+static struct timespec             timestamp_origin;
+#if defined(ENABLE_LOGGING) && !defined(USE_SYSTEM_LOGGING_FACILITY)
+static libusb_log_cb log_handler;
+#endif
+
+struct libusb_context     *usbi_default_context;
+struct libusb_context     *usbi_fallback_context;
+static int                 default_context_refcnt;
+static usbi_mutex_static_t default_context_lock = USBI_MUTEX_INITIALIZER;
+static struct usbi_option  default_context_options[LIBUSB_OPTION_MAX];
+
+usbi_mutex_static_t active_contexts_lock = USBI_MUTEX_INITIALIZER;
+struct list_head    active_contexts_list;
+
+/**
+ * \mainpage libusb-1.0 API Reference
+ *
+ * \section intro Introduction
+ *
+ * libusb is an open source library that allows you to communicate with USB
+ * devices from user space. For more info, see the
+ * <a href="http://libusb.info">libusb homepage</a>.
+ *
+ * This documentation is aimed at application developers wishing to
+ * communicate with USB peripherals from their own software. After reviewing
+ * this documentation, feedback and questions can be sent to the
+ * <a href="http://mailing-list.libusb.info">libusb-devel mailing list</a>.
+ *
+ * This documentation assumes knowledge of how to operate USB devices from
+ * a software standpoint (descriptors, configurations, interfaces, endpoints,
+ * control/bulk/interrupt/isochronous transfers, etc). Full information
+ * can be found in the <a href="http://www.usb.org/developers/docs/">USB 3.0
+ * Specification</a> which is available for free download. You can probably
+ * find less verbose introductions by searching the web.
+ *
+ * \section API Application Programming Interface (API)
+ *
+ * See the \ref libusb_api page for a complete list of the libusb functions.
+ *
+ * \section features Library features
+ *
+ * - All transfer types supported (control/bulk/interrupt/isochronous)
+ * - 2 transfer interfaces:
+ *    -# Synchronous (simple)
+ *    -# Asynchronous (more complicated, but more powerful)
+ * - Thread safe (although the asynchronous interface means that you
+ *   usually won't need to thread)
+ * - Lightweight with lean API
+ * - Compatible with libusb-0.1 through the libusb-compat-0.1 translation layer
+ * - Hotplug support (on some platforms). See \ref libusb_hotplug.
+ *
+ * \section gettingstarted Getting Started
+ *
+ * To begin reading the API documentation, start with the Modules page which
+ * links to the different categories of libusb's functionality.
+ *
+ * One decision you will have to make is whether to use the synchronous
+ * or the asynchronous data transfer interface. The \ref libusb_io documentation
+ * provides some insight into this topic.
+ *
+ * Some example programs can be found in the libusb source distribution under
+ * the "examples" subdirectory. The libusb homepage includes a list of
+ * real-life project examples which use libusb.
+ *
+ * \section errorhandling Error handling
+ *
+ * libusb functions typically return 0 on success or a negative error code
+ * on failure. These negative error codes relate to LIBUSB_ERROR constants
+ * which are listed on the \ref libusb_misc "miscellaneous" documentation page.
+ *
+ * \section msglog Debug message logging
+ *
+ * libusb uses stderr for all logging. By default, logging is set to NONE,
+ * which means that no output will be produced. However, unless the library
+ * has been compiled with logging disabled, then any application calls to
+ * libusb_set_option(ctx, LIBUSB_OPTION_LOG_LEVEL, level),
+ * libusb_init_context, or the setting of the environmental variable
+ * LIBUSB_DEBUG outside of the application, can result in logging being
+ * produced. Your application should therefore not close stderr, but instead
+ * direct it to the null device if its output is undesirable.
+ *
+ * The libusb_set_option(ctx, LIBUSB_OPTION_LOG_LEVEL, level) or
+ * libusb_init_context functions can be used to enable logging of certain
+ * messages. With the default configuration, libusb will not log much so if
+ * you are advised to use one of these functions to enable all
+ * error/warning/informational messages. It will help debug problems with your
+ * software.
+ *
+ * The logged messages are unstructured. There is no one-to-one correspondence
+ * between messages being logged and success or failure return codes from
+ * libusb functions. There is no format to the messages, so you should not
+ * try to capture or parse them. They are not and will not be localized.
+ * These messages are not intended to being passed to your application user;
+ * instead, you should interpret the error codes returned from libusb functions
+ * and provide appropriate notification to the user. The messages are simply
+ * there to aid you as a programmer, and if you're confused because you're
+ * getting a strange error code from a libusb function, enabling message
+ * logging may give you a suitable explanation.
+ *
+ * The LIBUSB_DEBUG environment variable can be used to enable message logging
+ * at run-time. This environment variable should be set to a log level number,
+ * which is interpreted the same as the
+ * libusb_set_option(ctx, LIBUSB_OPTION_LOG_LEVEL, level), or
+ * libusb_init_context(&ctx, &(struct libusb_init_option){.option = LIBUSB_OPTION_LOG_LEVEL, .value = {.ival = level}}, 0).
+ * When the environment variable is set, the message logging verbosity level is
+ * fixed and setting the LIBUSB_OPTION_LOG_LEVEL option has no effect.
+ *
+ * libusb can be compiled without any logging functions, useful for embedded
+ * systems. In this case, neither the LIBUSB_OPTION_LOG_LEVEL option, nor the
+ * LIBUSB_DEBUG environment variable will have any effect.
+ *
+ * libusb can also be compiled with verbose debugging messages always. When
+ * the library is compiled in this way, all messages of all verbosities are
+ * always logged. Again, in this case, neither the LIBUSB_OPTION_LOG_LEVEL
+ * option, nor the LIBUSB_DEBUG environment variable will have any effect.
+ *
+ * \section remarks Other remarks
+ *
+ * libusb does have imperfections. The \ref libusb_caveats "caveats" page attempts
+ * to document these.
+ */
+
+/**
+ * \page libusb_caveats Caveats
+ *
+ * \section threadsafety Thread safety
+ *
+ * libusb is designed to be completely thread-safe, but as with any API it
+ * cannot prevent a user from sabotaging themselves, either intentionally or
+ * otherwise.
+ *
+ * Observe the following general guidelines:
+ *
+ * - Calls to functions that release a resource (e.g. libusb_close(),
+ *   libusb_free_config_descriptor()) should not be called concurrently on
+ *   the same resource. This is no different than concurrently calling free()
+ *   on the same allocated pointer.
+ * - Each individual \ref libusb_transfer should be prepared by a single
+ *   thread. In other words, no two threads should ever be concurrently
+ *   filling out the fields of a \ref libusb_transfer. You can liken this to
+ *   calling sprintf() with the same destination buffer from multiple threads.
+ *   The results will likely not be what you want unless the input parameters
+ *   are all the same, but its best to avoid this situation entirely.
+ * - Both the \ref libusb_transfer structure and its associated data buffer
+ *   should not be accessed between the time the transfer is submitted and the
+ *   time the completion callback is invoked. You can think of "ownership" of
+ *   these things as being transferred to libusb while the transfer is active.
+ * - The various "setter" functions (e.g. libusb_set_log_cb(),
+ *   libusb_set_pollfd_notifiers()) should not be called concurrently on the
+ *   resource. Though doing so will not lead to any undefined behavior, it
+ *   will likely produce results that the application does not expect.
+ *
+ * Rules for multiple threads and asynchronous I/O are detailed
+ * \ref libusb_mtasync "here".
+ *
+ * \section fork Fork considerations
+ *
+ * libusb is <em>not</em> designed to work across fork() calls. Depending on
+ * the platform, there may be resources in the parent process that are not
+ * available to the child (e.g. the hotplug monitor thread on Linux). In
+ * addition, since the parent and child will share libusb's internal file
+ * descriptors, using libusb in any way from the child could cause the parent
+ * process's \ref libusb_context to get into an inconsistent state.
+ *
+ * On Linux, libusb's file descriptors will be marked as CLOEXEC, which means
+ * that it is safe to fork() and exec() without worrying about the child
+ * process needing to clean up state or having access to these file descriptors.
+ * Other platforms may not be so forgiving, so consider yourself warned!
+ *
+ * \section devresets Device resets
+ *
+ * The libusb_reset_device() function allows you to reset a device. If your
+ * program has to call such a function, it should obviously be aware that
+ * the reset will cause device state to change (e.g. register values may be
+ * reset).
+ *
+ * The problem is that any other program could reset the device your program
+ * is working with, at any time. libusb does not offer a mechanism to inform
+ * you when this has happened, so if someone else resets your device it will
+ * not be clear to your own program why the device state has changed.
+ *
+ * Ultimately, this is a limitation of writing drivers in user space.
+ * Separation from the USB stack in the underlying kernel makes it difficult
+ * for the operating system to deliver such notifications to your program.
+ * The Linux kernel USB stack allows such reset notifications to be delivered
+ * to in-kernel USB drivers, but it is not clear how such notifications could
+ * be delivered to second-class drivers that live in user space.
+ *
+ * \section blockonly Blocking-only functionality
+ *
+ * The functionality listed below is only available through synchronous,
+ * blocking functions. There are no asynchronous/non-blocking alternatives,
+ * and no clear ways of implementing these.
+ *
+ * - Configuration activation (libusb_set_configuration())
+ * - Interface/alternate setting activation (libusb_set_interface_alt_setting())
+ * - Releasing of interfaces (libusb_release_interface())
+ * - Clearing of halt/stall condition (libusb_clear_halt())
+ * - Device resets (libusb_reset_device())
+ *
+ * \section configsel Configuration selection and handling
+ *
+ * When libusb presents a device handle to an application, there is a chance
+ * that the corresponding device may be in unconfigured state. For devices
+ * with multiple configurations, there is also a chance that the configuration
+ * currently selected is not the one that the application wants to use.
+ *
+ * The obvious solution is to add a call to libusb_set_configuration() early
+ * on during your device initialization routines, but there are caveats to
+ * be aware of:
+ * -# If the device is already in the desired configuration, calling
+ *    libusb_set_configuration() using the same configuration value will cause
+ *    a lightweight device reset. This may not be desirable behaviour.
+ * -# In the case where the desired configuration is already active, libusb
+ *    may not even be able to perform a lightweight device reset. For example,
+ *    take my USB keyboard with fingerprint reader: I'm interested in driving
+ *    the fingerprint reader interface through libusb, but the kernel's
+ *    USB-HID driver will almost always have claimed the keyboard interface.
+ *    Because the kernel has claimed an interface, it is not even possible to
+ *    perform the lightweight device reset, so libusb_set_configuration() will
+ *    fail. (Luckily the device in question only has a single configuration.)
+ * -# libusb will be unable to set a configuration if other programs or
+ *    drivers have claimed interfaces. In particular, this means that kernel
+ *    drivers must be detached from all the interfaces before
+ *    libusb_set_configuration() may succeed.
+ *
+ * One solution to some of the above problems is to consider the currently
+ * active configuration. If the configuration we want is already active, then
+ * we don't have to select any configuration:
+\code
+cfg = -1;
+libusb_get_configuration(dev, &cfg);
+if (cfg != desired)
+    libusb_set_configuration(dev, desired);
+\endcode
+ *
+ * This is probably suitable for most scenarios, but is inherently racy:
+ * another application or driver may change the selected configuration
+ * <em>after</em> the libusb_get_configuration() call.
+ *
+ * Even in cases where libusb_set_configuration() succeeds, consider that other
+ * applications or drivers may change configuration after your application
+ * calls libusb_set_configuration().
+ *
+ * One possible way to lock your device into a specific configuration is as
+ * follows:
+ * -# Set the desired configuration (or use the logic above to realise that
+ *    it is already in the desired configuration)
+ * -# Claim the interface that you wish to use
+ * -# Check that the currently active configuration is the one that you want
+ *    to use.
+ *
+ * The above method works because once an interface is claimed, no application
+ * or driver is able to select another configuration.
+ *
+ * \section earlycomp Early transfer completion
+ *
+ * NOTE: This section is currently Linux-centric. I am not sure if any of these
+ * considerations apply to Darwin or other platforms.
+ *
+ * When a transfer completes early (i.e. when less data is received/sent in
+ * any one packet than the transfer buffer allows for) then libusb is designed
+ * to terminate the transfer immediately, not transferring or receiving any
+ * more data unless other transfers have been queued by the user.
+ *
+ * On legacy platforms, libusb is unable to do this in all situations. After
+ * the incomplete packet occurs, "surplus" data may be transferred. For recent
+ * versions of libusb, this information is kept (the data length of the
+ * transfer is updated) and, for device-to-host transfers, any surplus data was
+ * added to the buffer. Still, this is not a nice solution because it loses the
+ * information about the end of the short packet, and the user probably wanted
+ * that surplus data to arrive in the next logical transfer.
+ *
+ * \section zlp Zero length packets
+ *
+ * - libusb is able to send a packet of zero length to an endpoint simply by
+ * submitting a transfer of zero length.
+ * - The \ref libusb_transfer_flags::LIBUSB_TRANSFER_ADD_ZERO_PACKET
+ * "LIBUSB_TRANSFER_ADD_ZERO_PACKET" flag is currently supported on Linux,
+ * Darwin and Windows (WinUSB).
+ */
+
+/**
+ * \page libusb_contexts Contexts
+ *
+ * It is possible that libusb may be used simultaneously from two independent
+ * libraries linked into the same executable. For example, if your application
+ * has a plugin-like system which allows the user to dynamically load a range
+ * of modules into your program, it is feasible that two independently
+ * developed modules may both use libusb.
+ *
+ * libusb is written to allow for these multiple user scenarios. The two
+ * "instances" of libusb will not interfere: an option set by one user will have
+ * no effect the same option for other users, other users can continue using
+ * libusb after one of them calls libusb_exit(), etc.
+ *
+ * This is made possible through libusb's <em>context</em> concept. When you
+ * call libusb_init(), you are (optionally) given a context. You can then pass
+ * this context pointer back into future libusb functions.
+ *
+ * In order to keep things simple for more simplistic applications, it is
+ * legal to pass NULL to all functions requiring a context pointer (as long as
+ * you're sure no other code will attempt to use libusb from the same process).
+ * When you pass NULL, the default context will be used. The default context
+ * is created the first time a process calls libusb_init() when no other
+ * context is alive. Contexts are destroyed during libusb_exit().
+ *
+ * The default context is reference-counted and can be shared. That means that
+ * if libusb_init(NULL) is called twice within the same process, the two
+ * users end up sharing the same context. The deinitialization and freeing of
+ * the default context will only happen when the last user calls libusb_exit().
+ * In other words, the default context is created and initialized when its
+ * reference count goes from 0 to 1, and is deinitialized and destroyed when
+ * its reference count goes from 1 to 0.
+ *
+ * You may be wondering why only a subset of libusb functions require a
+ * context pointer in their function definition. Internally, libusb stores
+ * context pointers in other objects (e.g. libusb_device instances) and hence
+ * can infer the context from those objects.
+ */
+
+/**
+ * \page libusb_api Application Programming Interface
+ *
+ * This is the complete list of libusb functions, structures and
+ * enumerations in alphabetical order.
+ *
+ * \section Functions
+ * - libusb_alloc_streams()
+ * - libusb_alloc_transfer()
+ * - libusb_attach_kernel_driver()
+ * - libusb_bulk_transfer()
+ * - libusb_cancel_transfer()
+ * - libusb_claim_interface()
+ * - libusb_clear_halt()
+ * - libusb_close()
+ * - libusb_control_transfer()
+ * - libusb_control_transfer_get_data()
+ * - libusb_control_transfer_get_setup()
+ * - libusb_cpu_to_le16()
+ * - libusb_detach_kernel_driver()
+ * - libusb_dev_mem_alloc()
+ * - libusb_dev_mem_free()
+ * - libusb_error_name()
+ * - libusb_event_handler_active()
+ * - libusb_event_handling_ok()
+ * - libusb_exit()
+ * - libusb_fill_bulk_stream_transfer()
+ * - libusb_fill_bulk_transfer()
+ * - libusb_fill_control_setup()
+ * - libusb_fill_control_transfer()
+ * - libusb_fill_interrupt_transfer()
+ * - libusb_fill_iso_transfer()
+ * - libusb_free_bos_descriptor()
+ * - libusb_free_config_descriptor()
+ * - libusb_free_container_id_descriptor()
+ * - libusb_free_device_list()
+ * - libusb_free_pollfds()
+ * - libusb_free_ss_endpoint_companion_descriptor()
+ * - libusb_free_ss_usb_device_capability_descriptor()
+ * - libusb_free_streams()
+ * - libusb_free_transfer()
+ * - libusb_free_usb_2_0_extension_descriptor()
+ * - libusb_get_active_config_descriptor()
+ * - libusb_get_bos_descriptor()
+ * - libusb_get_bus_number()
+ * - libusb_get_config_descriptor()
+ * - libusb_get_config_descriptor_by_value()
+ * - libusb_get_configuration()
+ * - libusb_get_container_id_descriptor()
+ * - libusb_get_descriptor()
+ * - libusb_get_device()
+ * - libusb_get_device_address()
+ * - libusb_get_device_descriptor()
+ * - libusb_get_device_list()
+ * - libusb_get_device_speed()
+ * - libusb_get_iso_packet_buffer()
+ * - libusb_get_iso_packet_buffer_simple()
+ * - libusb_get_max_alt_packet_size()
+ * - libusb_get_max_iso_packet_size()
+ * - libusb_get_max_packet_size()
+ * - libusb_get_next_timeout()
+ * - libusb_get_parent()
+ * - libusb_get_pollfds()
+ * - libusb_get_port_number()
+ * - libusb_get_port_numbers()
+ * - libusb_get_port_path()
+ * - libusb_get_ss_endpoint_companion_descriptor()
+ * - libusb_get_ss_usb_device_capability_descriptor()
+ * - libusb_get_string_descriptor()
+ * - libusb_get_string_descriptor_ascii()
+ * - libusb_get_usb_2_0_extension_descriptor()
+ * - libusb_get_version()
+ * - libusb_handle_events()
+ * - libusb_handle_events_completed()
+ * - libusb_handle_events_locked()
+ * - libusb_handle_events_timeout()
+ * - libusb_handle_events_timeout_completed()
+ * - libusb_has_capability()
+ * - libusb_hotplug_deregister_callback()
+ * - libusb_hotplug_register_callback()
+ * - libusb_init()
+ * - libusb_init_context()
+ * - libusb_interrupt_event_handler()
+ * - libusb_interrupt_transfer()
+ * - libusb_kernel_driver_active()
+ * - libusb_lock_events()
+ * - libusb_lock_event_waiters()
+ * - libusb_open()
+ * - libusb_open_device_with_vid_pid()
+ * - libusb_pollfds_handle_timeouts()
+ * - libusb_ref_device()
+ * - libusb_release_interface()
+ * - libusb_reset_device()
+ * - libusb_set_auto_detach_kernel_driver()
+ * - libusb_set_configuration()
+ * - libusb_set_debug()
+ * - libusb_set_log_cb()
+ * - libusb_set_interface_alt_setting()
+ * - libusb_set_iso_packet_lengths()
+ * - libusb_set_option()
+ * - libusb_setlocale()
+ * - libusb_set_pollfd_notifiers()
+ * - libusb_strerror()
+ * - libusb_submit_transfer()
+ * - libusb_transfer_get_stream_id()
+ * - libusb_transfer_set_stream_id()
+ * - libusb_try_lock_events()
+ * - libusb_unlock_events()
+ * - libusb_unlock_event_waiters()
+ * - libusb_unref_device()
+ * - libusb_wait_for_event()
+ * - libusb_wrap_sys_device()
+ *
+ * \section Structures
+ * - libusb_bos_descriptor
+ * - libusb_bos_dev_capability_descriptor
+ * - libusb_config_descriptor
+ * - libusb_container_id_descriptor
+ * - \ref libusb_context
+ * - libusb_control_setup
+ * - \ref libusb_device
+ * - libusb_device_descriptor
+ * - \ref libusb_device_handle
+ * - libusb_endpoint_descriptor
+ * - libusb_interface
+ * - libusb_interface_descriptor
+ * - libusb_iso_packet_descriptor
+ * - libusb_pollfd
+ * - libusb_ss_endpoint_companion_descriptor
+ * - libusb_ss_usb_device_capability_descriptor
+ * - libusb_transfer
+ * - libusb_usb_2_0_extension_descriptor
+ * - libusb_version
+ *
+ * \section Enums
+ * - \ref libusb_bos_type
+ * - \ref libusb_capability
+ * - \ref libusb_class_code
+ * - \ref libusb_descriptor_type
+ * - \ref libusb_endpoint_direction
+ * - \ref libusb_endpoint_transfer_type
+ * - \ref libusb_error
+ * - \ref libusb_iso_sync_type
+ * - \ref libusb_iso_usage_type
+ * - \ref libusb_log_level
+ * - \ref libusb_option
+ * - \ref libusb_request_recipient
+ * - \ref libusb_request_type
+ * - \ref libusb_speed
+ * - \ref libusb_ss_usb_device_capability_attributes
+ * - \ref libusb_standard_request
+ * - \ref libusb_supported_speed
+ * - \ref libusb_transfer_flags
+ * - \ref libusb_transfer_status
+ * - \ref libusb_transfer_type
+ * - \ref libusb_usb_2_0_extension_attributes
+ */
+
+/**
+ * @defgroup libusb_lib Library initialization/deinitialization
+ * This page details how to initialize and deinitialize libusb. Initialization
+ * must be performed before using any libusb functionality, and similarly you
+ * must not call any libusb functions after deinitialization.
+ */
+
+/**
+ * @defgroup libusb_dev Device handling and enumeration
+ * The functionality documented below is designed to help with the following
+ * operations:
+ * - Enumerating the USB devices currently attached to the system
+ * - Choosing a device to operate from your software
+ * - Opening and closing the chosen device
+ *
+ * \section nutshell In a nutshell...
+ *
+ * The description below really makes things sound more complicated than they
+ * actually are. The following sequence of function calls will be suitable
+ * for almost all scenarios and does not require you to have such a deep
+ * understanding of the resource management issues:
+ * \code
+// discover devices
+libusb_device **list;
+libusb_device *found = NULL;
+ssize_t cnt = libusb_get_device_list(NULL, &list);
+ssize_t i = 0;
+int err = 0;
+if (cnt < 0)
+    error();
+
+for (i = 0; i < cnt; i++) {
+    libusb_device *device = list[i];
+    if (is_interesting(device)) {
+        found = device;
+        break;
+    }
+}
+
+if (found) {
+    libusb_device_handle *handle;
+
+    err = libusb_open(found, &handle);
+    if (err)
+        error();
+    // etc
+}
+
+libusb_free_device_list(list, 1);
+\endcode
+ *
+ * The two important points:
+ * - You asked libusb_free_device_list() to unreference the devices (2nd
+ *   parameter)
+ * - You opened the device before freeing the list and unreferencing the
+ *   devices
+ *
+ * If you ended up with a handle, you can now proceed to perform I/O on the
+ * device.
+ *
+ * \section devshandles Devices and device handles
+ * libusb has a concept of a USB device, represented by the
+ * \ref libusb_device opaque type. A device represents a USB device that
+ * is currently or was previously connected to the system. Using a reference
+ * to a device, you can determine certain information about the device (e.g.
+ * you can read the descriptor data).
+ *
+ * The libusb_get_device_list() function can be used to obtain a list of
+ * devices currently connected to the system. This is known as device
+ * discovery. Devices can also be discovered with the hotplug mechanism,
+ * whereby a callback function registered with libusb_hotplug_register_callback()
+ * will be called when a device of interest is connected or disconnected.
+ *
+ * Just because you have a reference to a device does not mean it is
+ * necessarily usable. The device may have been unplugged, you may not have
+ * permission to operate such device, or another program or driver may be
+ * using the device.
+ *
+ * When you've found a device that you'd like to operate, you must ask
+ * libusb to open the device using the libusb_open() function. Assuming
+ * success, libusb then returns you a <em>device handle</em>
+ * (a \ref libusb_device_handle pointer). All "real" I/O operations then
+ * operate on the handle rather than the original device pointer.
+ *
+ * \section devref Device discovery and reference counting
+ *
+ * Device discovery (i.e. calling libusb_get_device_list()) returns a
+ * freshly-allocated list of devices. The list itself must be freed when
+ * you are done with it. libusb also needs to know when it is OK to free
+ * the contents of the list - the devices themselves.
+ *
+ * To handle these issues, libusb provides you with two separate items:
+ * - A function to free the list itself
+ * - A reference counting system for the devices inside
+ *
+ * New devices presented by the libusb_get_device_list() function all have a
+ * reference count of 1. You can increase and decrease reference count using
+ * libusb_ref_device() and libusb_unref_device(). A device is destroyed when
+ * its reference count reaches 0.
+ *
+ * With the above information in mind, the process of opening a device can
+ * be viewed as follows:
+ * -# Discover devices using libusb_get_device_list() or libusb_hotplug_register_callback().
+ * -# Choose the device that you want to operate, and call libusb_open().
+ * -# Unref all devices in the discovered device list.
+ * -# Free the discovered device list.
+ *
+ * The order is important - you must not unreference the device before
+ * attempting to open it, because unreferencing it may destroy the device.
+ *
+ * For convenience, the libusb_free_device_list() function includes a
+ * parameter to optionally unreference all the devices in the list before
+ * freeing the list itself. This combines steps 3 and 4 above.
+ *
+ * As an implementation detail, libusb_open() actually adds a reference to
+ * the device in question. This is because the device remains available
+ * through the handle via libusb_get_device(). The reference is deleted during
+ * libusb_close().
+ */
+
+/** @defgroup libusb_misc Miscellaneous */
+
+/* we traverse usbfs without knowing how many devices we are going to find.
+ * so we create this discovered_devs model which is similar to a linked-list
+ * which grows when required. it can be freed once discovery has completed,
+ * eliminating the need for a list node in the libusb_device structure
+ * itself. */
+#define DISCOVERED_DEVICES_SIZE_STEP 16
+
+static struct discovered_devs *discovered_devs_alloc(void) {
+    struct discovered_devs *ret = malloc(sizeof(*ret) + (sizeof(void *) * DISCOVERED_DEVICES_SIZE_STEP));
+
+    if(ret) {
+        ret->len      = 0;
+        ret->capacity = DISCOVERED_DEVICES_SIZE_STEP;
+    }
+    return ret;
+}
+
+static void discovered_devs_free(struct discovered_devs *discdevs) {
+    size_t i;
+
+    for(i = 0; i < discdevs->len; i++)
+        libusb_unref_device(discdevs->devices[i]);
+
+    free(discdevs);
+}
+
+/* append a device to the discovered devices collection. may realloc itself,
+ * returning new discdevs. returns NULL on realloc failure. */
+struct discovered_devs *discovered_devs_append(struct discovered_devs *discdevs, struct libusb_device *dev) {
+    size_t                  len = discdevs->len;
+    size_t                  capacity;
+    struct discovered_devs *new_discdevs;
+
+    /* if there is space, just append the device */
+    if(len < discdevs->capacity) {
+        discdevs->devices[len] = libusb_ref_device(dev);
+        discdevs->len++;
+        return discdevs;
+    }
+
+    /* exceeded capacity, need to grow */
+    usbi_dbg(DEVICE_CTX(dev), "need to increase capacity");
+    capacity = discdevs->capacity + DISCOVERED_DEVICES_SIZE_STEP;
+    /* can't use usbi_reallocf here because in failure cases it would
+     * free the existing discdevs without unreferencing its devices. */
+    new_discdevs = realloc(discdevs, sizeof(*discdevs) + (sizeof(void *) * capacity));
+    if(!new_discdevs) {
+        discovered_devs_free(discdevs);
+        return NULL;
+    }
+
+    discdevs               = new_discdevs;
+    discdevs->capacity     = capacity;
+    discdevs->devices[len] = libusb_ref_device(dev);
+    discdevs->len++;
+
+    return discdevs;
+}
+
+/* Allocate a new device with a specific session ID. The returned device has
+ * a reference count of 1. */
+struct libusb_device *usbi_alloc_device(struct libusb_context *ctx, unsigned long session_id) {
+    size_t                priv_size = usbi_backend.device_priv_size;
+    struct libusb_device *dev       = calloc(1, PTR_ALIGN(sizeof(*dev)) + priv_size);
+
+    if(!dev)
+        return NULL;
+
+    usbi_atomic_store(&dev->refcnt, 1);
+
+    dev->ctx          = ctx;
+    dev->session_data = session_id;
+    dev->speed        = LIBUSB_SPEED_UNKNOWN;
+
+    if(!libusb_has_capability(LIBUSB_CAP_HAS_HOTPLUG))
+        usbi_connect_device(dev);
+
+    return dev;
+}
+
+void usbi_connect_device(struct libusb_device *dev) {
+    struct libusb_context *ctx = DEVICE_CTX(dev);
+
+    usbi_atomic_store(&dev->attached, 1);
+
+    usbi_mutex_lock(&dev->ctx->usb_devs_lock);
+    list_add(&dev->list, &dev->ctx->usb_devs);
+    usbi_mutex_unlock(&dev->ctx->usb_devs_lock);
+
+    usbi_hotplug_notification(ctx, dev, LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED);
+}
+
+void usbi_disconnect_device(struct libusb_device *dev) {
+    struct libusb_context *ctx = DEVICE_CTX(dev);
+
+    usbi_atomic_store(&dev->attached, 0);
+
+    usbi_mutex_lock(&ctx->usb_devs_lock);
+    list_del(&dev->list);
+    usbi_mutex_unlock(&ctx->usb_devs_lock);
+
+    usbi_hotplug_notification(ctx, dev, LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT);
+}
+
+/* Perform some final sanity checks on a newly discovered device. If this
+ * function fails (negative return code), the device should not be added
+ * to the discovered device list. */
+int usbi_sanitize_device(struct libusb_device *dev) {
+    uint8_t num_configurations;
+
+    if(dev->device_descriptor.bLength != LIBUSB_DT_DEVICE_SIZE || dev->device_descriptor.bDescriptorType != LIBUSB_DT_DEVICE) {
+        usbi_err(DEVICE_CTX(dev), "invalid device descriptor");
+        return LIBUSB_ERROR_IO;
+    }
+
+    num_configurations = dev->device_descriptor.bNumConfigurations;
+    if(num_configurations > USB_MAXCONFIG) {
+        usbi_err(DEVICE_CTX(dev), "too many configurations");
+        return LIBUSB_ERROR_IO;
+    }
+    else if(0 == num_configurations) {
+        usbi_dbg(DEVICE_CTX(dev), "zero configurations, maybe an unauthorized device");
+    }
+
+    return 0;
+}
+
+/* Examine libusb's internal list of known devices, looking for one with
+ * a specific session ID. Returns the matching device if it was found, and
+ * NULL otherwise. */
+struct libusb_device *usbi_get_device_by_session_id(struct libusb_context *ctx, unsigned long session_id) {
+    struct libusb_device *dev;
+    struct libusb_device *ret = NULL;
+
+    usbi_mutex_lock(&ctx->usb_devs_lock);
+    for_each_device(ctx, dev) {
+        if(dev->session_data == session_id) {
+            ret = libusb_ref_device(dev);
+            break;
+        }
+    }
+    usbi_mutex_unlock(&ctx->usb_devs_lock);
+
+    return ret;
+}
+
+/** @ingroup libusb_dev
+ * Returns a list of USB devices currently attached to the system. This is
+ * your entry point into finding a USB device to operate.
+ *
+ * You are expected to unreference all the devices when you are done with
+ * them, and then free the list with libusb_free_device_list(). Note that
+ * libusb_free_device_list() can unref all the devices for you. Be careful
+ * not to unreference a device you are about to open until after you have
+ * opened it.
+ *
+ * This return value of this function indicates the number of devices in
+ * the resultant list. The list is actually one element larger, as it is
+ * NULL-terminated.
+ *
+ * \param ctx the context to operate on, or NULL for the default context
+ * \param list output location for a list of devices. Must be later freed with
+ * libusb_free_device_list().
+ * \returns the number of devices in the outputted list, or any
+ * \ref libusb_error according to errors encountered by the backend.
+ */
+ssize_t API_EXPORTED libusb_get_device_list(libusb_context *ctx, libusb_device ***list) {
+    struct discovered_devs *discdevs = discovered_devs_alloc();
+    struct libusb_device  **ret;
+    int                     r = 0;
+    ssize_t                 i, len;
+
+    usbi_dbg(ctx, " ");
+
+    if(!discdevs)
+        return LIBUSB_ERROR_NO_MEM;
+
+    ctx = usbi_get_context(ctx);
+
+    if(libusb_has_capability(LIBUSB_CAP_HAS_HOTPLUG)) {
+        /* backend provides hotplug support */
+        struct libusb_device *dev;
+
+        if(usbi_backend.hotplug_poll)
+            usbi_backend.hotplug_poll();
+
+        usbi_mutex_lock(&ctx->usb_devs_lock);
+        for_each_device(ctx, dev) {
+            discdevs = discovered_devs_append(discdevs, dev);
+
+            if(!discdevs) {
+                r = LIBUSB_ERROR_NO_MEM;
+                break;
+            }
+        }
+        usbi_mutex_unlock(&ctx->usb_devs_lock);
+    }
+    else {
+        /* backend does not provide hotplug support */
+        r = usbi_backend.get_device_list(ctx, &discdevs);
+    }
+
+    if(r < 0) {
+        len = r;
+        goto out;
+    }
+
+    /* convert discovered_devs into a list */
+    len = (ssize_t)discdevs->len;
+    ret = calloc((size_t)len + 1, sizeof(struct libusb_device *));
+    if(!ret) {
+        len = LIBUSB_ERROR_NO_MEM;
+        goto out;
+    }
+
+    ret[len] = NULL;
+    for(i = 0; i < len; i++) {
+        struct libusb_device *dev = discdevs->devices[i];
+        ret[i]                    = libusb_ref_device(dev);
+    }
+    *list = ret;
+
+out:
+    if(discdevs)
+        discovered_devs_free(discdevs);
+    return len;
+}
+
+/** \ingroup libusb_dev
+ * Frees a list of devices previously discovered using
+ * libusb_get_device_list(). If the unref_devices parameter is set, the
+ * reference count of each device in the list is decremented by 1.
+ * \param list the list to free
+ * \param unref_devices whether to unref the devices in the list
+ */
+void API_EXPORTED libusb_free_device_list(libusb_device **list, int unref_devices) {
+    if(!list)
+        return;
+
+    if(unref_devices) {
+        int                   i = 0;
+        struct libusb_device *dev;
+
+        while((dev = list[i++]) != NULL)
+            libusb_unref_device(dev);
+    }
+    free(list);
+}
+
+/** \ingroup libusb_dev
+ * Get the number of the bus that a device is connected to.
+ * \param dev a device
+ * \returns the bus number
+ */
+uint8_t API_EXPORTED libusb_get_bus_number(libusb_device *dev) {
+    return dev->bus_number;
+}
+
+/** \ingroup libusb_dev
+ * Get the number of the port that a device is connected to.
+ * Unless the OS does something funky, or you are hot-plugging USB extension cards,
+ * the port number returned by this call is usually guaranteed to be uniquely tied
+ * to a physical port, meaning that different devices plugged on the same physical
+ * port should return the same port number.
+ *
+ * But outside of this, there is no guarantee that the port number returned by this
+ * call will remain the same, or even match the order in which ports have been
+ * numbered by the HUB/HCD manufacturer.
+ *
+ * \param dev a device
+ * \returns the port number (0 if not available)
+ */
+uint8_t API_EXPORTED libusb_get_port_number(libusb_device *dev) {
+    return dev->port_number;
+}
+/** \ingroup libusb_dev
+ * Get the path of windows  that a device is connected to.
+ *
+ * \param dev a device
+ * \returns the windows path (0 if not available)
+ */
+char *API_EXPORTED libusb_get_windows_path(libusb_device *dev) {
+    return dev->dev_path;
+}
+
+/** \ingroup libusb_dev
+ * Get the path of windows  that a device is connected to.
+ *
+ * \param dev a device
+ * \param interface_index index of interface
+ * \returns the interface path
+ */
+char *API_EXPORTED libusb_get_interface_path(libusb_device *dev, uint8_t interface_index) {
+    return dev->interface_path[interface_index];
+}
+
+/** \ingroup libusb_dev
+ * Get the path of windows  that a device is connected to.
+ *
+ * \param dev a device
+ * \param interface_index index of interface
+ * \returns the sub composite device id
+ */
+char *LIBUSB_CALL libusb_get_sub_composite_device_id(libusb_device *dev, uint8_t index) {
+    return dev->sub_composite_device_id[index];
+}
+
+/** \ingroup libusb_dev
+ * Get the list of all port numbers from root for the specified device
+ *
+ * Since version 1.0.16, \ref LIBUSB_API_VERSION >= 0x01000102
+ * \param dev a device
+ * \param port_numbers the array that should contain the port numbers
+ * \param port_numbers_len the maximum length of the array. As per the USB 3.0
+ * specs, the current maximum limit for the depth is 7.
+ * \returns the number of elements filled
+ * \returns \ref LIBUSB_ERROR_OVERFLOW if the array is too small
+ */
+int API_EXPORTED libusb_get_port_numbers(libusb_device *dev, uint8_t *port_numbers, int port_numbers_len) {
+    int                    i   = port_numbers_len;
+    struct libusb_context *ctx = DEVICE_CTX(dev);
+
+    if(port_numbers_len <= 0)
+        return LIBUSB_ERROR_INVALID_PARAM;
+
+    // HCDs can be listed as devices with port #0
+    while((dev) && (dev->port_number != 0)) {
+        if(--i < 0) {
+            usbi_warn(ctx, "port numbers array is too small");
+            return LIBUSB_ERROR_OVERFLOW;
+        }
+        port_numbers[i] = dev->port_number;
+        dev             = dev->parent_dev;
+    }
+    if(i < port_numbers_len)
+        memmove(port_numbers, &port_numbers[i], port_numbers_len - i);
+    return port_numbers_len - i;
+}
+
+/** \ingroup libusb_dev
+ * \deprecated Please use \ref libusb_get_port_numbers() instead.
+ */
+int API_EXPORTED libusb_get_port_path(libusb_context *ctx, libusb_device *dev, uint8_t *port_numbers, uint8_t port_numbers_len) {
+    UNUSED(ctx);
+
+    return libusb_get_port_numbers(dev, port_numbers, port_numbers_len);
+}
+
+/** \ingroup libusb_dev
+ * Get the the parent from the specified device.
+ * \param dev a device
+ * \returns the device parent or NULL if not available
+ * You should issue a \ref libusb_get_device_list() before calling this
+ * function and make sure that you only access the parent before issuing
+ * \ref libusb_free_device_list(). The reason is that libusb currently does
+ * not maintain a permanent list of device instances, and therefore can
+ * only guarantee that parents are fully instantiated within a
+ * libusb_get_device_list() - libusb_free_device_list() block.
+ */
+DEFAULT_VISIBILITY
+libusb_device *LIBUSB_CALL libusb_get_parent(libusb_device *dev) {
+    return dev->parent_dev;
+}
+
+/** \ingroup libusb_dev
+ * Get the address of the device on the bus it is connected to.
+ * \param dev a device
+ * \returns the device address
+ */
+uint8_t API_EXPORTED libusb_get_device_address(libusb_device *dev) {
+    return dev->device_address;
+}
+
+/** \ingroup libusb_dev
+ * Get the negotiated connection speed for a device.
+ * \param dev a device
+ * \returns a \ref libusb_speed code, where LIBUSB_SPEED_UNKNOWN means that
+ * the OS doesn't know or doesn't support returning the negotiated speed.
+ */
+int API_EXPORTED libusb_get_device_speed(libusb_device *dev) {
+    return dev->speed;
+}
+
+static const struct libusb_endpoint_descriptor *find_endpoint(struct libusb_config_descriptor *config, unsigned char endpoint) {
+    int iface_idx;
+    for(iface_idx = 0; iface_idx < config->bNumInterfaces; iface_idx++) {
+        const struct libusb_interface *iface = &config->interface[iface_idx];
+        int                            altsetting_idx;
+
+        for(altsetting_idx = 0; altsetting_idx < iface->num_altsetting; altsetting_idx++) {
+            const struct libusb_interface_descriptor *altsetting = &iface->altsetting[altsetting_idx];
+            int                                       ep_idx;
+
+            for(ep_idx = 0; ep_idx < altsetting->bNumEndpoints; ep_idx++) {
+                const struct libusb_endpoint_descriptor *ep = &altsetting->endpoint[ep_idx];
+                if(ep->bEndpointAddress == endpoint)
+                    return ep;
+            }
+        }
+    }
+    return NULL;
+}
+
+/** \ingroup libusb_dev
+ * Convenience function to retrieve the wMaxPacketSize value for a particular
+ * endpoint in the active device configuration.
+ *
+ * This function was originally intended to be of assistance when setting up
+ * isochronous transfers, but a design mistake resulted in this function
+ * instead. It simply returns the wMaxPacketSize value without considering
+ * its contents. If you're dealing with isochronous transfers, you probably
+ * want libusb_get_max_iso_packet_size() instead.
+ *
+ * \param dev a device
+ * \param endpoint address of the endpoint in question
+ * \returns the wMaxPacketSize value
+ * \returns \ref LIBUSB_ERROR_NOT_FOUND if the endpoint does not exist
+ * \returns \ref LIBUSB_ERROR_OTHER on other failure
+ */
+int API_EXPORTED libusb_get_max_packet_size(libusb_device *dev, unsigned char endpoint) {
+    struct libusb_config_descriptor         *config;
+    const struct libusb_endpoint_descriptor *ep;
+    int                                      r;
+
+    r = libusb_get_active_config_descriptor(dev, &config);
+    if(r < 0) {
+        usbi_err(DEVICE_CTX(dev), "could not retrieve active config descriptor");
+        return LIBUSB_ERROR_OTHER;
+    }
+
+    ep = find_endpoint(config, endpoint);
+    if(!ep) {
+        r = LIBUSB_ERROR_NOT_FOUND;
+        goto out;
+    }
+
+    r = ep->wMaxPacketSize;
+
+out:
+    libusb_free_config_descriptor(config);
+    return r;
+}
+
+static const struct libusb_endpoint_descriptor *find_alt_endpoint(struct libusb_config_descriptor *config, int iface_idx, int altsetting_idx,
+                                                                  unsigned char endpoint) {
+    if(iface_idx >= config->bNumInterfaces) {
+        return NULL;
+    }
+
+    const struct libusb_interface *iface = &config->interface[iface_idx];
+
+    if(altsetting_idx >= iface->num_altsetting) {
+        return NULL;
+    }
+
+    const struct libusb_interface_descriptor *altsetting = &iface->altsetting[altsetting_idx];
+    int                                       ep_idx;
+
+    for(ep_idx = 0; ep_idx < altsetting->bNumEndpoints; ep_idx++) {
+        const struct libusb_endpoint_descriptor *ep = &altsetting->endpoint[ep_idx];
+        if(ep->bEndpointAddress == endpoint)
+            return ep;
+    }
+    return NULL;
+}
+
+static int get_endpoint_max_packet_size(libusb_device *dev, const struct libusb_endpoint_descriptor *ep) {
+    struct libusb_ss_endpoint_companion_descriptor *ss_ep_cmp;
+    enum libusb_endpoint_transfer_type              ep_type;
+    uint16_t                                        val;
+    int                                             r = 0;
+    int                                             speed;
+
+    speed = libusb_get_device_speed(dev);
+    if(speed >= LIBUSB_SPEED_SUPER) {
+        r = libusb_get_ss_endpoint_companion_descriptor(dev->ctx, ep, &ss_ep_cmp);
+        if(r == LIBUSB_SUCCESS) {
+            r = ss_ep_cmp->wBytesPerInterval;
+            libusb_free_ss_endpoint_companion_descriptor(ss_ep_cmp);
+        }
+    }
+
+    /* If the device isn't a SuperSpeed device or retrieving the SS endpoint didn't worked. */
+    if(speed < LIBUSB_SPEED_SUPER || r < 0) {
+        val     = ep->wMaxPacketSize;
+        ep_type = (enum libusb_endpoint_transfer_type)(ep->bmAttributes & 0x3);
+
+        r = val & 0x07ff;
+        if(ep_type == LIBUSB_ENDPOINT_TRANSFER_TYPE_ISOCHRONOUS || ep_type == LIBUSB_ENDPOINT_TRANSFER_TYPE_INTERRUPT)
+            r *= (1 + ((val >> 11) & 3));
+    }
+
+    return r;
+}
+
+/** \ingroup libusb_dev
+ * Calculate the maximum packet size which a specific endpoint is capable is
+ * sending or receiving in the duration of 1 microframe
+ *
+ * Only the active configuration is examined. The calculation is based on the
+ * wMaxPacketSize field in the endpoint descriptor as described in section
+ * 9.6.6 in the USB 2.0 specifications.
+ *
+ * If acting on an isochronous or interrupt endpoint, this function will
+ * multiply the value found in bits 0:10 by the number of transactions per
+ * microframe (determined by bits 11:12). Otherwise, this function just
+ * returns the numeric value found in bits 0:10. For USB 3.0 device, it
+ * will attempts to retrieve the Endpoint Companion Descriptor to return
+ * wBytesPerInterval.
+ *
+ * This function is useful for setting up isochronous transfers, for example
+ * you might pass the return value from this function to
+ * libusb_set_iso_packet_lengths() in order to set the length field of every
+ * isochronous packet in a transfer.
+ *
+ * This function only considers the first alternate setting of the interface.
+ * If the endpoint has different maximum packet sizes for different alternate
+ * settings, you probably want libusb_get_max_alt_packet_size() instead.
+ *
+ * Since v1.0.3.
+ *
+ * \param dev a device
+ * \param endpoint address of the endpoint in question
+ * \returns the maximum packet size which can be sent/received on this endpoint
+ * \returns \ref LIBUSB_ERROR_NOT_FOUND if the endpoint does not exist
+ * \returns \ref LIBUSB_ERROR_OTHER on other failure
+ * \see libusb_get_max_alt_packet_size
+ */
+int API_EXPORTED libusb_get_max_iso_packet_size(libusb_device *dev, unsigned char endpoint) {
+    struct libusb_config_descriptor         *config;
+    const struct libusb_endpoint_descriptor *ep;
+    int                                      r;
+
+    r = libusb_get_active_config_descriptor(dev, &config);
+    if(r < 0) {
+        usbi_err(DEVICE_CTX(dev), "could not retrieve active config descriptor");
+        return LIBUSB_ERROR_OTHER;
+    }
+
+    ep = find_endpoint(config, endpoint);
+    if(!ep) {
+        r = LIBUSB_ERROR_NOT_FOUND;
+        goto out;
+    }
+
+    r = get_endpoint_max_packet_size(dev, ep);
+
+out:
+    libusb_free_config_descriptor(config);
+    return r;
+}
+
+/** \ingroup libusb_dev
+ * Calculate the maximum packet size which a specific endpoint is capable of
+ * sending or receiving in the duration of 1 microframe
+ *
+ * Only the active configuration is examined. The calculation is based on the
+ * wMaxPacketSize field in the endpoint descriptor as described in section
+ * 9.6.6 in the USB 2.0 specifications.
+ *
+ * If acting on an isochronous or interrupt endpoint, this function will
+ * multiply the value found in bits 0:10 by the number of transactions per
+ * microframe (determined by bits 11:12). Otherwise, this function just
+ * returns the numeric value found in bits 0:10. For USB 3.0 device, it
+ * will attempts to retrieve the Endpoint Companion Descriptor to return
+ * wBytesPerInterval.
+ *
+ * This function is useful for setting up isochronous transfers, for example
+ * you might pass the return value from this function to
+ * libusb_set_iso_packet_lengths() in order to set the length field of every
+ * isochronous packet in a transfer.
+ *
+ * Since v1.0.27.
+ *
+ * \param dev a device
+ * \param interface_number the <tt>bInterfaceNumber</tt> of the interface
+ * the endpoint belongs to
+ * \param alternate_setting the <tt>bAlternateSetting</tt> of the interface
+ * \param endpoint address of the endpoint in question
+ * \returns the maximum packet size which can be sent/received on this endpoint
+ * \returns \ref LIBUSB_ERROR_NOT_FOUND if the endpoint does not exist
+ * \returns \ref LIBUSB_ERROR_OTHER on other failure
+ * \see libusb_get_max_iso_packet_size
+ */
+int API_EXPORTED libusb_get_max_alt_packet_size(libusb_device *dev, int interface_number, int alternate_setting, unsigned char endpoint) {
+    struct libusb_config_descriptor         *config;
+    const struct libusb_endpoint_descriptor *ep;
+    int                                      r;
+
+    r = libusb_get_active_config_descriptor(dev, &config);
+    if(r < 0) {
+        usbi_err(DEVICE_CTX(dev), "could not retrieve active config descriptor");
+        return LIBUSB_ERROR_OTHER;
+    }
+
+    ep = find_alt_endpoint(config, interface_number, alternate_setting, endpoint);
+    if(!ep) {
+        r = LIBUSB_ERROR_NOT_FOUND;
+        goto out;
+    }
+
+    r = get_endpoint_max_packet_size(dev, ep);
+
+out:
+    libusb_free_config_descriptor(config);
+    return r;
+}
+
+/** \ingroup libusb_dev
+ * Increment the reference count of a device.
+ * \param dev the device to reference
+ * \returns the same device
+ */
+DEFAULT_VISIBILITY
+libusb_device *LIBUSB_CALL libusb_ref_device(libusb_device *dev) {
+    long refcnt;
+
+    refcnt = usbi_atomic_inc(&dev->refcnt);
+    assert(refcnt >= 2);
+
+    return dev;
+}
+
+/** \ingroup libusb_dev
+ * Decrement the reference count of a device. If the decrement operation
+ * causes the reference count to reach zero, the device shall be destroyed.
+ * \param dev the device to unreference
+ */
+void API_EXPORTED libusb_unref_device(libusb_device *dev) {
+    long refcnt;
+
+    if(!dev)
+        return;
+
+    refcnt = usbi_atomic_dec(&dev->refcnt);
+    assert(refcnt >= 0);
+
+    if(refcnt == 0) {
+        usbi_dbg(DEVICE_CTX(dev), "destroy device %d.%d", dev->bus_number, dev->device_address);
+
+        libusb_unref_device(dev->parent_dev);
+
+        if(usbi_backend.destroy_device)
+            usbi_backend.destroy_device(dev);
+
+        if(!libusb_has_capability(LIBUSB_CAP_HAS_HOTPLUG)) {
+            /* backend does not support hotplug */
+            usbi_disconnect_device(dev);
+        }
+
+        free(dev);
+    }
+}
+
+/** \ingroup libusb_dev
+ * Wrap a platform-specific system device handle and obtain a libusb device
+ * handle for the underlying device. The handle allows you to use libusb to
+ * perform I/O on the device in question.
+ *
+ * Call libusb_init_context with the LIBUSB_OPTION_NO_DEVICE_DISCOVERY
+ * option if you want to skip enumeration of USB devices. In particular, this
+ * might be needed on Android if you don't have authority to access USB
+ * devices in general. Setting this option with libusb_set_option is deprecated.
+ *
+ * On Linux, the system device handle must be a valid file descriptor opened
+ * on the device node.
+ *
+ * The system device handle must remain open until libusb_close() is called.
+ * The system device handle will not be closed by libusb_close().
+ *
+ * Internally, this function creates a temporary device and makes it
+ * available to you through libusb_get_device(). This device is destroyed
+ * during libusb_close(). The device shall not be opened through libusb_open().
+ *
+ * This is a non-blocking function; no requests are sent over the bus.
+ *
+ * Since version 1.0.23, \ref LIBUSB_API_VERSION >= 0x01000107
+ *
+ * \param ctx the context to operate on, or NULL for the default context
+ * \param sys_dev the platform-specific system device handle
+ * \param dev_handle output location for the returned device handle pointer. Only
+ * populated when the return code is 0.
+ * \returns 0 on success
+ * \returns \ref LIBUSB_ERROR_NO_MEM on memory allocation failure
+ * \returns \ref LIBUSB_ERROR_ACCESS if the user has insufficient permissions
+ * \returns \ref LIBUSB_ERROR_NOT_SUPPORTED if the operation is not supported on this
+ * platform
+ * \returns another LIBUSB_ERROR code on other failure
+ */
+int API_EXPORTED libusb_wrap_sys_device(libusb_context *ctx, intptr_t sys_dev, libusb_device_handle **dev_handle) {
+    struct libusb_device_handle *_dev_handle;
+    size_t                       priv_size = usbi_backend.device_handle_priv_size;
+    int                          r;
+
+    usbi_dbg(ctx, "wrap_sys_device 0x%" PRIxPTR, (uintptr_t)sys_dev);
+
+    ctx = usbi_get_context(ctx);
+
+    if(!usbi_backend.wrap_sys_device)
+        return LIBUSB_ERROR_NOT_SUPPORTED;
+
+    _dev_handle = calloc(1, PTR_ALIGN(sizeof(*_dev_handle)) + priv_size);
+    if(!_dev_handle)
+        return LIBUSB_ERROR_NO_MEM;
+
+    usbi_mutex_init(&_dev_handle->lock);
+
+    r = usbi_backend.wrap_sys_device(ctx, _dev_handle, sys_dev);
+    if(r < 0) {
+        usbi_dbg(ctx, "wrap_sys_device 0x%" PRIxPTR " returns %d", (uintptr_t)sys_dev, r);
+        usbi_mutex_destroy(&_dev_handle->lock);
+        free(_dev_handle);
+        return r;
+    }
+
+    usbi_mutex_lock(&ctx->open_devs_lock);
+    list_add(&_dev_handle->list, &ctx->open_devs);
+    usbi_mutex_unlock(&ctx->open_devs_lock);
+    *dev_handle = _dev_handle;
+
+    return 0;
+}
+
+/** \ingroup libusb_dev
+ * Open a device and obtain a device handle. A handle allows you to perform
+ * I/O on the device in question.
+ *
+ * Internally, this function adds a reference to the device and makes it
+ * available to you through libusb_get_device(). This reference is removed
+ * during libusb_close().
+ *
+ * This is a non-blocking function; no requests are sent over the bus.
+ *
+ * \param dev the device to open
+ * \param dev_handle output location for the returned device handle pointer. Only
+ * populated when the return code is 0.
+ * \returns 0 on success
+ * \returns \ref LIBUSB_ERROR_NO_MEM on memory allocation failure
+ * \returns \ref LIBUSB_ERROR_ACCESS if the user has insufficient permissions
+ * \returns \ref LIBUSB_ERROR_NO_DEVICE if the device has been disconnected
+ * \returns another LIBUSB_ERROR code on other failure
+ */
+int API_EXPORTED libusb_open(libusb_device *dev, libusb_device_handle **dev_handle) {
+    struct libusb_context       *ctx = DEVICE_CTX(dev);
+    struct libusb_device_handle *_dev_handle;
+    size_t                       priv_size = usbi_backend.device_handle_priv_size;
+    int                          r;
+
+    usbi_dbg(DEVICE_CTX(dev), "open %d.%d", dev->bus_number, dev->device_address);
+
+    if(!usbi_atomic_load(&dev->attached))
+        return LIBUSB_ERROR_NO_DEVICE;
+
+    _dev_handle = calloc(1, PTR_ALIGN(sizeof(*_dev_handle)) + priv_size);
+    if(!_dev_handle)
+        return LIBUSB_ERROR_NO_MEM;
+
+    usbi_mutex_init(&_dev_handle->lock);
+
+    _dev_handle->dev = libusb_ref_device(dev);
+
+    r = usbi_backend.open(_dev_handle);
+    if(r < 0) {
+        usbi_dbg(DEVICE_CTX(dev), "open %d.%d returns %d", dev->bus_number, dev->device_address, r);
+        libusb_unref_device(dev);
+        usbi_mutex_destroy(&_dev_handle->lock);
+        free(_dev_handle);
+        return r;
+    }
+
+    usbi_mutex_lock(&ctx->open_devs_lock);
+    list_add(&_dev_handle->list, &ctx->open_devs);
+    usbi_mutex_unlock(&ctx->open_devs_lock);
+    *dev_handle = _dev_handle;
+
+    return 0;
+}
+
+/** \ingroup libusb_dev
+ * Convenience function for finding a device with a particular
+ * <tt>idVendor</tt>/<tt>idProduct</tt> combination. This function is intended
+ * for those scenarios where you are using libusb to knock up a quick test
+ * application - it allows you to avoid calling libusb_get_device_list() and
+ * worrying about traversing/freeing the list.
+ *
+ * This function has limitations and is hence not intended for use in real
+ * applications: if multiple devices have the same IDs it will only
+ * give you the first one, etc.
+ *
+ * \param ctx the context to operate on, or NULL for the default context
+ * \param vendor_id the idVendor value to search for
+ * \param product_id the idProduct value to search for
+ * \returns a device handle for the first found device, or NULL on error
+ * or if the device could not be found. */
+DEFAULT_VISIBILITY
+libusb_device_handle *LIBUSB_CALL libusb_open_device_with_vid_pid(libusb_context *ctx, uint16_t vendor_id, uint16_t product_id) {
+    struct libusb_device       **devs;
+    struct libusb_device        *found = NULL;
+    struct libusb_device        *dev;
+    struct libusb_device_handle *dev_handle = NULL;
+    size_t                       i          = 0;
+    int                          r;
+
+    if(libusb_get_device_list(ctx, &devs) < 0)
+        return NULL;
+
+    while((dev = devs[i++]) != NULL) {
+        struct libusb_device_descriptor desc;
+        r = libusb_get_device_descriptor(dev, &desc);
+        if(r < 0)
+            goto out;
+        if(desc.idVendor == vendor_id && desc.idProduct == product_id) {
+            found = dev;
+            break;
+        }
+    }
+
+    if(found) {
+        r = libusb_open(found, &dev_handle);
+        if(r < 0)
+            dev_handle = NULL;
+    }
+
+out:
+    libusb_free_device_list(devs, 1);
+    return dev_handle;
+}
+
+static void do_close(struct libusb_context *ctx, struct libusb_device_handle *dev_handle) {
+    struct usbi_transfer *itransfer;
+    struct usbi_transfer *tmp;
+
+    /* remove any transfers in flight that are for this device */
+    usbi_mutex_lock(&ctx->flying_transfers_lock);
+
+    /* safe iteration because transfers may be being deleted */
+    for_each_transfer_safe(ctx, itransfer, tmp) {
+        struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+        uint32_t                state_flags;
+
+        if(transfer->dev_handle != dev_handle)
+            continue;
+
+        usbi_mutex_lock(&itransfer->lock);
+        state_flags = itransfer->state_flags;
+        usbi_mutex_unlock(&itransfer->lock);
+        if(!(state_flags & USBI_TRANSFER_DEVICE_DISAPPEARED)) {
+            usbi_err(ctx, "Device handle closed while transfer was still being processed, but the device is still connected as far as we know");
+
+            if(state_flags & USBI_TRANSFER_CANCELLING)
+                usbi_warn(ctx, "A cancellation for an in-flight transfer hasn't completed but closing the device handle");
+            else
+                usbi_err(ctx, "A cancellation hasn't even been scheduled on the transfer for which the device is closing");
+        }
+
+        /* remove from the list of in-flight transfers and make sure
+         * we don't accidentally use the device handle in the future
+         * (or that such accesses will be easily caught and identified as a crash)
+         */
+        list_del(&itransfer->list);
+        transfer->dev_handle = NULL;
+
+        /* it is up to the user to free up the actual transfer struct.  this is
+         * just making sure that we don't attempt to process the transfer after
+         * the device handle is invalid
+         */
+        usbi_dbg(ctx, "Removed transfer %p from the in-flight list because device handle %p closed", (void *)transfer, (void *)dev_handle);
+    }
+    usbi_mutex_unlock(&ctx->flying_transfers_lock);
+
+    usbi_mutex_lock(&ctx->open_devs_lock);
+    list_del(&dev_handle->list);
+    usbi_mutex_unlock(&ctx->open_devs_lock);
+
+    usbi_backend.close(dev_handle);
+    libusb_unref_device(dev_handle->dev);
+    usbi_mutex_destroy(&dev_handle->lock);
+    free(dev_handle);
+}
+
+/** \ingroup libusb_dev
+ * Close a device handle. Should be called on all open handles before your
+ * application exits.
+ *
+ * Internally, this function destroys the reference that was added by
+ * libusb_open() on the given device.
+ *
+ * This is a non-blocking function; no requests are sent over the bus.
+ *
+ * \param dev_handle the device handle to close
+ */
+void API_EXPORTED libusb_close(libusb_device_handle *dev_handle) {
+    struct libusb_context *ctx;
+    unsigned int           event_flags;
+    int                    handling_events;
+
+    if(!dev_handle)
+        return;
+    ctx = HANDLE_CTX(dev_handle);
+    usbi_dbg(ctx, " ");
+
+    handling_events = usbi_handling_events(ctx);
+
+    /* Similarly to libusb_open(), we want to interrupt all event handlers
+     * at this point. More importantly, we want to perform the actual close of
+     * the device while holding the event handling lock (preventing any other
+     * thread from doing event handling) because we will be removing a file
+     * descriptor from the polling loop. If this is being called by the current
+     * event handler, we can bypass the interruption code because we already
+     * hold the event handling lock. */
+
+    if(!handling_events) {
+        /* Record that we are closing a device.
+         * Only signal an event if there are no prior pending events. */
+        usbi_mutex_lock(&ctx->event_data_lock);
+        event_flags = ctx->event_flags;
+        if(!ctx->device_close++)
+            ctx->event_flags |= USBI_EVENT_DEVICE_CLOSE;
+        if(!event_flags)
+            usbi_signal_event(&ctx->event);
+        usbi_mutex_unlock(&ctx->event_data_lock);
+
+        /* take event handling lock */
+        libusb_lock_events(ctx);
+    }
+
+    /* Close the device */
+    do_close(ctx, dev_handle);
+
+    if(!handling_events) {
+        /* We're done with closing this device.
+         * Clear the event pipe if there are no further pending events. */
+        usbi_mutex_lock(&ctx->event_data_lock);
+        if(!--ctx->device_close)
+            ctx->event_flags &= ~USBI_EVENT_DEVICE_CLOSE;
+        if(!ctx->event_flags)
+            usbi_clear_event(&ctx->event);
+        usbi_mutex_unlock(&ctx->event_data_lock);
+
+        /* Release event handling lock and wake up event waiters */
+        libusb_unlock_events(ctx);
+    }
+}
+
+/** \ingroup libusb_dev
+ * Get the underlying device for a device handle. This function does not modify
+ * the reference count of the returned device, so do not feel compelled to
+ * unreference it when you are done.
+ * \param dev_handle a device handle
+ * \returns the underlying device
+ */
+DEFAULT_VISIBILITY
+libusb_device *LIBUSB_CALL libusb_get_device(libusb_device_handle *dev_handle) {
+    return dev_handle->dev;
+}
+
+/** \ingroup libusb_dev
+ * Determine the bConfigurationValue of the currently active configuration.
+ *
+ * You could formulate your own control request to obtain this information,
+ * but this function has the advantage that it may be able to retrieve the
+ * information from operating system caches (no I/O involved).
+ *
+ * If the OS does not cache this information, then this function will block
+ * while a control transfer is submitted to retrieve the information.
+ *
+ * This function will return a value of 0 in the <tt>config</tt> output
+ * parameter if the device is in unconfigured state.
+ *
+ * \param dev_handle a device handle
+ * \param config output location for the bConfigurationValue of the active
+ * configuration (only valid for return code 0)
+ * \returns 0 on success
+ * \returns \ref LIBUSB_ERROR_NO_DEVICE if the device has been disconnected
+ * \returns another LIBUSB_ERROR code on other failure
+ */
+int API_EXPORTED libusb_get_configuration(libusb_device_handle *dev_handle, int *config) {
+    int                    r   = LIBUSB_ERROR_NOT_SUPPORTED;
+    uint8_t                tmp = 0;
+    struct libusb_context *ctx = HANDLE_CTX(dev_handle);
+
+    usbi_dbg(ctx, " ");
+    if(usbi_backend.get_configuration)
+        r = usbi_backend.get_configuration(dev_handle, &tmp);
+
+    if(r == LIBUSB_ERROR_NOT_SUPPORTED) {
+        usbi_dbg(ctx, "falling back to control message");
+        r = libusb_control_transfer(dev_handle, LIBUSB_ENDPOINT_IN, LIBUSB_REQUEST_GET_CONFIGURATION, 0, 0, &tmp, 1, 1000);
+        if(r == 1) {
+            r = 0;
+        }
+        else if(r == 0) {
+            usbi_err(ctx, "zero bytes returned in ctrl transfer?");
+            r = LIBUSB_ERROR_IO;
+        }
+        else {
+            usbi_dbg(ctx, "control failed, error %d", r);
+        }
+    }
+
+    if(r == 0) {
+        usbi_dbg(ctx, "active config %u", tmp);
+        *config = (int)tmp;
+    }
+
+    return r;
+}
+
+/** \ingroup libusb_dev
+ * Set the active configuration for a device.
+ *
+ * The operating system may or may not have already set an active
+ * configuration on the device. It is up to your application to ensure the
+ * correct configuration is selected before you attempt to claim interfaces
+ * and perform other operations.
+ *
+ * If you call this function on a device already configured with the selected
+ * configuration, then this function will act as a lightweight device reset:
+ * it will issue a SET_CONFIGURATION request using the current configuration,
+ * causing most USB-related device state to be reset (altsetting reset to zero,
+ * endpoint halts cleared, toggles reset).
+ *
+ * Not all backends support setting the configuration from user space, which
+ * will be indicated by the return code \ref LIBUSB_ERROR_NOT_SUPPORTED. As this
+ * suggests that the platform is handling the device configuration itself,
+ * this error should generally be safe to ignore.
+ *
+ * You cannot change/reset configuration if your application has claimed
+ * interfaces. It is advised to set the desired configuration before claiming
+ * interfaces.
+ *
+ * Alternatively you can call libusb_release_interface() first. Note if you
+ * do things this way you must ensure that auto_detach_kernel_driver for
+ * <tt>dev</tt> is 0, otherwise the kernel driver will be re-attached when you
+ * release the interface(s).
+ *
+ * You cannot change/reset configuration if other applications or drivers have
+ * claimed interfaces.
+ *
+ * A configuration value of -1 will put the device in unconfigured state.
+ * The USB specifications state that a configuration value of 0 does this,
+ * however buggy devices exist which actually have a configuration 0.
+ *
+ * You should always use this function rather than formulating your own
+ * SET_CONFIGURATION control request. This is because the underlying operating
+ * system needs to know when such changes happen.
+ *
+ * This is a blocking function.
+ *
+ * \param dev_handle a device handle
+ * \param configuration the bConfigurationValue of the configuration you
+ * wish to activate, or -1 if you wish to put the device in an unconfigured
+ * state
+ * \returns 0 on success
+ * \returns \ref LIBUSB_ERROR_NOT_FOUND if the requested configuration does not exist
+ * \returns \ref LIBUSB_ERROR_BUSY if interfaces are currently claimed
+ * \returns \ref LIBUSB_ERROR_NOT_SUPPORTED if setting or changing the configuration
+ * is not supported by the backend
+ * \returns \ref LIBUSB_ERROR_NO_DEVICE if the device has been disconnected
+ * \returns another LIBUSB_ERROR code on other failure
+ * \see libusb_set_auto_detach_kernel_driver()
+ */
+int API_EXPORTED libusb_set_configuration(libusb_device_handle *dev_handle, int configuration) {
+    usbi_dbg(HANDLE_CTX(dev_handle), "configuration %d", configuration);
+    if(configuration < -1 || configuration > (int)UINT8_MAX)
+        return LIBUSB_ERROR_INVALID_PARAM;
+    return usbi_backend.set_configuration(dev_handle, configuration);
+}
+
+/** \ingroup libusb_dev
+ * Claim an interface on a given device handle. You must claim the interface
+ * you wish to use before you can perform I/O on any of its endpoints.
+ *
+ * It is legal to attempt to claim an already-claimed interface, in which
+ * case libusb just returns 0 without doing anything.
+ *
+ * If auto_detach_kernel_driver is set to 1 for <tt>dev</tt>, the kernel driver
+ * will be detached if necessary, on failure the detach error is returned.
+ *
+ * Claiming of interfaces is a purely logical operation; it does not cause
+ * any requests to be sent over the bus. Interface claiming is used to
+ * instruct the underlying operating system that your application wishes
+ * to take ownership of the interface.
+ *
+ * This is a non-blocking function.
+ *
+ * \param dev_handle a device handle
+ * \param interface_number the <tt>bInterfaceNumber</tt> of the interface you
+ * wish to claim
+ * \returns 0 on success
+ * \returns \ref LIBUSB_ERROR_NOT_FOUND if the requested interface does not exist
+ * \returns \ref LIBUSB_ERROR_BUSY if another program or driver has claimed the
+ * interface
+ * \returns \ref LIBUSB_ERROR_NO_DEVICE if the device has been disconnected
+ * \returns a LIBUSB_ERROR code on other failure
+ * \see libusb_set_auto_detach_kernel_driver()
+ */
+int API_EXPORTED libusb_claim_interface(libusb_device_handle *dev_handle, int interface_number) {
+    int r = 0;
+
+    usbi_dbg(HANDLE_CTX(dev_handle), "interface %d", interface_number);
+    if(interface_number < 0 || interface_number >= USB_MAXINTERFACES)
+        return LIBUSB_ERROR_INVALID_PARAM;
+
+    if(!usbi_atomic_load(&dev_handle->dev->attached))
+        return LIBUSB_ERROR_NO_DEVICE;
+
+    usbi_mutex_lock(&dev_handle->lock);
+    if(dev_handle->claimed_interfaces & (1U << interface_number))
+        goto out;
+
+    r = usbi_backend.claim_interface(dev_handle, (uint8_t)interface_number);
+    if(r == 0)
+        dev_handle->claimed_interfaces |= 1U << interface_number;
+
+out:
+    usbi_mutex_unlock(&dev_handle->lock);
+    return r;
+}
+
+/** \ingroup libusb_dev
+ * Release an interface previously claimed with libusb_claim_interface(). You
+ * should release all claimed interfaces before closing a device handle.
+ *
+ * This is a blocking function. A SET_INTERFACE control request will be sent
+ * to the device, resetting interface state to the first alternate setting.
+ *
+ * If auto_detach_kernel_driver is set to 1 for <tt>dev</tt>, the kernel
+ * driver will be re-attached after releasing the interface.
+ *
+ * \param dev_handle a device handle
+ * \param interface_number the <tt>bInterfaceNumber</tt> of the
+ * previously-claimed interface
+ * \returns 0 on success
+ * \returns \ref LIBUSB_ERROR_NOT_FOUND if the interface was not claimed
+ * \returns \ref LIBUSB_ERROR_NO_DEVICE if the device has been disconnected
+ * \returns another LIBUSB_ERROR code on other failure
+ * \see libusb_set_auto_detach_kernel_driver()
+ */
+int API_EXPORTED libusb_release_interface(libusb_device_handle *dev_handle, int interface_number) {
+    int r;
+
+    usbi_dbg(HANDLE_CTX(dev_handle), "interface %d", interface_number);
+    if(interface_number < 0 || interface_number >= USB_MAXINTERFACES)
+        return LIBUSB_ERROR_INVALID_PARAM;
+
+    usbi_mutex_lock(&dev_handle->lock);
+    if(!(dev_handle->claimed_interfaces & (1U << interface_number))) {
+        r = LIBUSB_ERROR_NOT_FOUND;
+        goto out;
+    }
+
+    r = usbi_backend.release_interface(dev_handle, (uint8_t)interface_number);
+    if(r == 0)
+        dev_handle->claimed_interfaces &= ~(1U << interface_number);
+
+out:
+    usbi_mutex_unlock(&dev_handle->lock);
+    return r;
+}
+
+/** \ingroup libusb_dev
+ * Activate an alternate setting for an interface. The interface must have
+ * been previously claimed with libusb_claim_interface().
+ *
+ * You should always use this function rather than formulating your own
+ * SET_INTERFACE control request. This is because the underlying operating
+ * system needs to know when such changes happen.
+ *
+ * This is a blocking function.
+ *
+ * \param dev_handle a device handle
+ * \param interface_number the <tt>bInterfaceNumber</tt> of the
+ * previously-claimed interface
+ * \param alternate_setting the <tt>bAlternateSetting</tt> of the alternate
+ * setting to activate
+ * \returns 0 on success
+ * \returns \ref LIBUSB_ERROR_NOT_FOUND if the interface was not claimed, or the
+ * requested alternate setting does not exist
+ * \returns \ref LIBUSB_ERROR_NO_DEVICE if the device has been disconnected
+ * \returns another LIBUSB_ERROR code on other failure
+ */
+int API_EXPORTED libusb_set_interface_alt_setting(libusb_device_handle *dev_handle, int interface_number, int alternate_setting) {
+    usbi_dbg(HANDLE_CTX(dev_handle), "interface %d altsetting %d", interface_number, alternate_setting);
+    if(interface_number < 0 || interface_number >= USB_MAXINTERFACES)
+        return LIBUSB_ERROR_INVALID_PARAM;
+    if(alternate_setting < 0 || alternate_setting > (int)UINT8_MAX)
+        return LIBUSB_ERROR_INVALID_PARAM;
+
+    if(!usbi_atomic_load(&dev_handle->dev->attached)) {
+        return LIBUSB_ERROR_NO_DEVICE;
+    }
+
+    usbi_mutex_lock(&dev_handle->lock);
+    if(!(dev_handle->claimed_interfaces & (1U << interface_number))) {
+        usbi_mutex_unlock(&dev_handle->lock);
+        return LIBUSB_ERROR_NOT_FOUND;
+    }
+    usbi_mutex_unlock(&dev_handle->lock);
+
+    return usbi_backend.set_interface_altsetting(dev_handle, (uint8_t)interface_number, (uint8_t)alternate_setting);
+}
+
+/** \ingroup libusb_dev
+ * Clear the halt/stall condition for an endpoint. Endpoints with halt status
+ * are unable to receive or transmit data until the halt condition is stalled.
+ *
+ * You should cancel all pending transfers before attempting to clear the halt
+ * condition.
+ *
+ * This is a blocking function.
+ *
+ * \param dev_handle a device handle
+ * \param endpoint the endpoint to clear halt status
+ * \returns 0 on success
+ * \returns \ref LIBUSB_ERROR_NOT_FOUND if the endpoint does not exist
+ * \returns \ref LIBUSB_ERROR_NO_DEVICE if the device has been disconnected
+ * \returns another LIBUSB_ERROR code on other failure
+ */
+int API_EXPORTED libusb_clear_halt(libusb_device_handle *dev_handle, unsigned char endpoint) {
+    usbi_dbg(HANDLE_CTX(dev_handle), "endpoint 0x%x", endpoint);
+    if(!usbi_atomic_load(&dev_handle->dev->attached))
+        return LIBUSB_ERROR_NO_DEVICE;
+
+    return usbi_backend.clear_halt(dev_handle, endpoint);
+}
+
+/** \ingroup libusb_dev
+ * Perform a USB port reset to reinitialize a device. The system will attempt
+ * to restore the previous configuration and alternate settings after the
+ * reset has completed.
+ *
+ * If the reset fails, the descriptors change, or the previous state cannot be
+ * restored, the device will appear to be disconnected and reconnected. This
+ * means that the device handle is no longer valid (you should close it) and
+ * rediscover the device. A return code of \ref LIBUSB_ERROR_NOT_FOUND indicates
+ * when this is the case.
+ *
+ * This is a blocking function which usually incurs a noticeable delay.
+ *
+ * \param dev_handle a handle of the device to reset
+ * \returns 0 on success
+ * \returns \ref LIBUSB_ERROR_NOT_FOUND if re-enumeration is required, or if the
+ * device has been disconnected
+ * \returns another LIBUSB_ERROR code on other failure
+ */
+int API_EXPORTED libusb_reset_device(libusb_device_handle *dev_handle) {
+    usbi_dbg(HANDLE_CTX(dev_handle), " ");
+    if(!usbi_atomic_load(&dev_handle->dev->attached))
+        return LIBUSB_ERROR_NO_DEVICE;
+
+    if(usbi_backend.reset_device)
+        return usbi_backend.reset_device(dev_handle);
+    else
+        return LIBUSB_ERROR_NOT_SUPPORTED;
+}
+
+/** \ingroup libusb_asyncio
+ * Allocate up to num_streams usb bulk streams on the specified endpoints. This
+ * function takes an array of endpoints rather then a single endpoint because
+ * some protocols require that endpoints are setup with similar stream ids.
+ * All endpoints passed in must belong to the same interface.
+ *
+ * Note this function may return less streams then requested. Also note that the
+ * same number of streams are allocated for each endpoint in the endpoint array.
+ *
+ * Stream id 0 is reserved, and should not be used to communicate with devices.
+ * If libusb_alloc_streams() returns with a value of N, you may use stream ids
+ * 1 to N.
+ *
+ * Since version 1.0.19, \ref LIBUSB_API_VERSION >= 0x01000103
+ *
+ * \param dev_handle a device handle
+ * \param num_streams number of streams to try to allocate
+ * \param endpoints array of endpoints to allocate streams on
+ * \param num_endpoints length of the endpoints array
+ * \returns number of streams allocated, or a LIBUSB_ERROR code on failure
+ */
+int API_EXPORTED libusb_alloc_streams(libusb_device_handle *dev_handle, uint32_t num_streams, unsigned char *endpoints, int num_endpoints) {
+    usbi_dbg(HANDLE_CTX(dev_handle), "streams %u eps %d", (unsigned)num_streams, num_endpoints);
+
+    if(!num_streams || !endpoints || num_endpoints <= 0)
+        return LIBUSB_ERROR_INVALID_PARAM;
+
+    if(!usbi_atomic_load(&dev_handle->dev->attached))
+        return LIBUSB_ERROR_NO_DEVICE;
+
+    if(usbi_backend.alloc_streams)
+        return usbi_backend.alloc_streams(dev_handle, num_streams, endpoints, num_endpoints);
+    else
+        return LIBUSB_ERROR_NOT_SUPPORTED;
+}
+
+/** \ingroup libusb_asyncio
+ * Free usb bulk streams allocated with libusb_alloc_streams().
+ *
+ * Note streams are automatically free-ed when releasing an interface.
+ *
+ * Since version 1.0.19, \ref LIBUSB_API_VERSION >= 0x01000103
+ *
+ * \param dev_handle a device handle
+ * \param endpoints array of endpoints to free streams on
+ * \param num_endpoints length of the endpoints array
+ * \returns \ref LIBUSB_SUCCESS, or a LIBUSB_ERROR code on failure
+ */
+int API_EXPORTED libusb_free_streams(libusb_device_handle *dev_handle, unsigned char *endpoints, int num_endpoints) {
+    usbi_dbg(HANDLE_CTX(dev_handle), "eps %d", num_endpoints);
+
+    if(!endpoints || num_endpoints <= 0)
+        return LIBUSB_ERROR_INVALID_PARAM;
+
+    if(!usbi_atomic_load(&dev_handle->dev->attached))
+        return LIBUSB_ERROR_NO_DEVICE;
+
+    if(usbi_backend.free_streams)
+        return usbi_backend.free_streams(dev_handle, endpoints, num_endpoints);
+    else
+        return LIBUSB_ERROR_NOT_SUPPORTED;
+}
+
+/** \ingroup libusb_asyncio
+ * Attempts to allocate a block of persistent DMA memory suitable for transfers
+ * against the given device. If successful, will return a block of memory
+ * that is suitable for use as "buffer" in \ref libusb_transfer against this
+ * device. Using this memory instead of regular memory means that the host
+ * controller can use DMA directly into the buffer to increase performance, and
+ * also that transfers can no longer fail due to kernel memory fragmentation.
+ *
+ * Note that this means you should not modify this memory (or even data on
+ * the same cache lines) when a transfer is in progress, although it is legal
+ * to have several transfers going on within the same memory block.
+ *
+ * Will return NULL on failure. Many systems do not support such zero-copy
+ * and will always return NULL. Memory allocated with this function must be
+ * freed with \ref libusb_dev_mem_free. Specifically, this means that the
+ * flag \ref LIBUSB_TRANSFER_FREE_BUFFER cannot be used to free memory allocated
+ * with this function.
+ *
+ * Since version 1.0.21, \ref LIBUSB_API_VERSION >= 0x01000105
+ *
+ * \param dev_handle a device handle
+ * \param length size of desired data buffer
+ * \returns a pointer to the newly allocated memory, or NULL on failure
+ */
+DEFAULT_VISIBILITY
+unsigned char *LIBUSB_CALL libusb_dev_mem_alloc(libusb_device_handle *dev_handle, size_t length) {
+    if(!usbi_atomic_load(&dev_handle->dev->attached))
+        return NULL;
+
+    if(usbi_backend.dev_mem_alloc)
+        return usbi_backend.dev_mem_alloc(dev_handle, length);
+    else
+        return NULL;
+}
+
+/** \ingroup libusb_asyncio
+ * Free device memory allocated with libusb_dev_mem_alloc().
+ *
+ * \param dev_handle a device handle
+ * \param buffer pointer to the previously allocated memory
+ * \param length size of previously allocated memory
+ * \returns \ref LIBUSB_SUCCESS, or a LIBUSB_ERROR code on failure
+ */
+int API_EXPORTED libusb_dev_mem_free(libusb_device_handle *dev_handle, unsigned char *buffer, size_t length) {
+    if(usbi_backend.dev_mem_free)
+        return usbi_backend.dev_mem_free(dev_handle, buffer, length);
+    else
+        return LIBUSB_ERROR_NOT_SUPPORTED;
+}
+
+/** \ingroup libusb_dev
+ * Determine if a kernel driver is active on an interface. If a kernel driver
+ * is active, you cannot claim the interface, and libusb will be unable to
+ * perform I/O.
+ *
+ * This functionality is not available on Windows.
+ *
+ * \param dev_handle a device handle
+ * \param interface_number the interface to check
+ * \returns 0 if no kernel driver is active
+ * \returns 1 if a kernel driver is active
+ * \returns \ref LIBUSB_ERROR_NO_DEVICE if the device has been disconnected
+ * \returns \ref LIBUSB_ERROR_NOT_SUPPORTED on platforms where the functionality
+ * is not available
+ * \returns another LIBUSB_ERROR code on other failure
+ * \see libusb_detach_kernel_driver()
+ */
+int API_EXPORTED libusb_kernel_driver_active(libusb_device_handle *dev_handle, int interface_number) {
+    usbi_dbg(HANDLE_CTX(dev_handle), "interface %d", interface_number);
+
+    if(interface_number < 0 || interface_number >= USB_MAXINTERFACES)
+        return LIBUSB_ERROR_INVALID_PARAM;
+
+    if(!usbi_atomic_load(&dev_handle->dev->attached))
+        return LIBUSB_ERROR_NO_DEVICE;
+
+    if(usbi_backend.kernel_driver_active)
+        return usbi_backend.kernel_driver_active(dev_handle, (uint8_t)interface_number);
+    else
+        return LIBUSB_ERROR_NOT_SUPPORTED;
+}
+
+/** \ingroup libusb_dev
+ * Detach a kernel driver from an interface. If successful, you will then be
+ * able to claim the interface and perform I/O.
+ *
+ * This functionality is not available on Windows.
+ *
+ * Note that libusb itself also talks to the device through a special kernel
+ * driver, if this driver is already attached to the device, this call will
+ * not detach it and return \ref LIBUSB_ERROR_NOT_FOUND.
+ *
+ * \param dev_handle a device handle
+ * \param interface_number the interface to detach the driver from
+ * \returns 0 on success
+ * \returns \ref LIBUSB_ERROR_NOT_FOUND if no kernel driver was active
+ * \returns \ref LIBUSB_ERROR_INVALID_PARAM if the interface does not exist
+ * \returns \ref LIBUSB_ERROR_NO_DEVICE if the device has been disconnected
+ * \returns \ref LIBUSB_ERROR_NOT_SUPPORTED on platforms where the functionality
+ * is not available
+ * \returns another LIBUSB_ERROR code on other failure
+ * \see libusb_kernel_driver_active()
+ */
+int API_EXPORTED libusb_detach_kernel_driver(libusb_device_handle *dev_handle, int interface_number) {
+    usbi_dbg(HANDLE_CTX(dev_handle), "interface %d", interface_number);
+
+    if(interface_number < 0 || interface_number >= USB_MAXINTERFACES)
+        return LIBUSB_ERROR_INVALID_PARAM;
+
+    if(!usbi_atomic_load(&dev_handle->dev->attached))
+        return LIBUSB_ERROR_NO_DEVICE;
+
+    if(usbi_backend.detach_kernel_driver)
+        return usbi_backend.detach_kernel_driver(dev_handle, (uint8_t)interface_number);
+    else
+        return LIBUSB_ERROR_NOT_SUPPORTED;
+}
+
+/** \ingroup libusb_dev
+ * Re-attach an interface's kernel driver, which was previously detached
+ * using libusb_detach_kernel_driver().
+ *
+ * This functionality is not available on Windows.
+ *
+ * \param dev_handle a device handle
+ * \param interface_number the interface to attach the driver from
+ * \returns 0 on success
+ * \returns \ref LIBUSB_ERROR_NOT_FOUND if no kernel driver was active
+ * \returns \ref LIBUSB_ERROR_INVALID_PARAM if the interface does not exist
+ * \returns \ref LIBUSB_ERROR_NO_DEVICE if the device has been disconnected
+ * \returns \ref LIBUSB_ERROR_NOT_SUPPORTED on platforms where the functionality
+ * is not available
+ * \returns \ref LIBUSB_ERROR_BUSY if the driver cannot be attached because the
+ * interface is claimed by a program or driver
+ * \returns another LIBUSB_ERROR code on other failure
+ * \see libusb_kernel_driver_active()
+ */
+int API_EXPORTED libusb_attach_kernel_driver(libusb_device_handle *dev_handle, int interface_number) {
+    usbi_dbg(HANDLE_CTX(dev_handle), "interface %d", interface_number);
+
+    if(interface_number < 0 || interface_number >= USB_MAXINTERFACES)
+        return LIBUSB_ERROR_INVALID_PARAM;
+
+    if(!usbi_atomic_load(&dev_handle->dev->attached))
+        return LIBUSB_ERROR_NO_DEVICE;
+
+    if(usbi_backend.attach_kernel_driver)
+        return usbi_backend.attach_kernel_driver(dev_handle, (uint8_t)interface_number);
+    else
+        return LIBUSB_ERROR_NOT_SUPPORTED;
+}
+
+/** \ingroup libusb_dev
+ * Enable/disable libusb's automatic kernel driver detachment. When this is
+ * enabled libusb will automatically detach the kernel driver on an interface
+ * when claiming the interface, and attach it when releasing the interface.
+ *
+ * Automatic kernel driver detachment is disabled on newly opened device
+ * handles by default.
+ *
+ * On platforms which do not have LIBUSB_CAP_SUPPORTS_DETACH_KERNEL_DRIVER
+ * this function will return \ref LIBUSB_ERROR_NOT_SUPPORTED, and libusb will
+ * continue as if this function was never called.
+ *
+ * \param dev_handle a device handle
+ * \param enable whether to enable or disable auto kernel driver detachment
+ *
+ * \returns \ref LIBUSB_SUCCESS on success
+ * \returns \ref LIBUSB_ERROR_NOT_SUPPORTED on platforms where the functionality
+ * is not available
+ * \see libusb_claim_interface()
+ * \see libusb_release_interface()
+ * \see libusb_set_configuration()
+ */
+int API_EXPORTED libusb_set_auto_detach_kernel_driver(libusb_device_handle *dev_handle, int enable) {
+    if(!(usbi_backend.caps & USBI_CAP_SUPPORTS_DETACH_KERNEL_DRIVER))
+        return LIBUSB_ERROR_NOT_SUPPORTED;
+
+    dev_handle->auto_detach_kernel_driver = enable;
+    return LIBUSB_SUCCESS;
+}
+
+/** \ingroup libusb_lib
+ * \deprecated Use libusb_set_option() or libusb_init_context() instead
+ * using the \ref LIBUSB_OPTION_LOG_LEVEL option.
+ */
+void API_EXPORTED libusb_set_debug(libusb_context *ctx, int level) {
+#if defined(ENABLE_LOGGING) && !defined(ENABLE_DEBUG_LOGGING)
+    ctx = usbi_get_context(ctx);
+    if(!ctx->debug_fixed) {
+        level      = CLAMP(level, LIBUSB_LOG_LEVEL_NONE, LIBUSB_LOG_LEVEL_DEBUG);
+        ctx->debug = (enum libusb_log_level)level;
+    }
+#else
+    UNUSED(ctx);
+    UNUSED(level);
+#endif
+}
+
+/** \ingroup libusb_lib
+ * Set log handler.
+ *
+ * libusb will redirect its log messages to the provided callback function.
+ * libusb supports redirection of per context and global log messages.
+ * Log messages sent to the context will be sent to the global log handler too.
+ *
+ * If libusb is compiled without message logging or USE_SYSTEM_LOGGING_FACILITY
+ * is defined then global callback function will never be called.
+ * If ENABLE_DEBUG_LOGGING is defined then per context callback function will
+ * never be called.
+ *
+ * Since version 1.0.23, \ref LIBUSB_API_VERSION >= 0x01000107
+ *
+ * \param ctx context on which to assign log handler, or NULL for the default
+ * context. Parameter ignored if only LIBUSB_LOG_CB_GLOBAL mode is requested.
+ * \param cb pointer to the callback function, or NULL to stop log
+ * messages redirection
+ * \param mode mode of callback function operation. Several modes can be
+ * selected for a single callback function, see \ref libusb_log_cb_mode for
+ * a description.
+ * \see libusb_log_cb, libusb_log_cb_mode
+ */
+void API_EXPORTED libusb_set_log_cb(libusb_context *ctx, libusb_log_cb cb, int mode) {
+#if defined(ENABLE_LOGGING) && (!defined(ENABLE_DEBUG_LOGGING) || !defined(USE_SYSTEM_LOGGING_FACILITY))
+#if !defined(USE_SYSTEM_LOGGING_FACILITY)
+    if(mode & LIBUSB_LOG_CB_GLOBAL)
+        log_handler = cb;
+#endif
+#if !defined(ENABLE_DEBUG_LOGGING)
+    if(mode & LIBUSB_LOG_CB_CONTEXT) {
+        ctx              = usbi_get_context(ctx);
+        ctx->log_handler = cb;
+    }
+#else
+    UNUSED(ctx);
+#endif
+#else
+    UNUSED(ctx);
+    UNUSED(cb);
+    UNUSED(mode);
+#endif
+}
+
+/** \ingroup libusb_lib
+ * Set an option in the library.
+ *
+ * Use this function to configure a specific option within the library.
+ *
+ * Some options require one or more arguments to be provided. Consult each
+ * option's documentation for specific requirements.
+ *
+ * If the context ctx is NULL, the option will be added to a list of default
+ * options that will be applied to all subsequently created contexts.
+ *
+ * Since version 1.0.22, \ref LIBUSB_API_VERSION >= 0x01000106
+ *
+ * \param ctx context on which to operate
+ * \param option which option to set
+ * \param ... any required arguments for the specified option
+ *
+ * \returns \ref LIBUSB_SUCCESS on success
+ * \returns \ref LIBUSB_ERROR_INVALID_PARAM if the option or arguments are invalid
+ * \returns \ref LIBUSB_ERROR_NOT_SUPPORTED if the option is valid but not supported
+ * on this platform
+ * \returns \ref LIBUSB_ERROR_NOT_FOUND if LIBUSB_OPTION_USE_USBDK is valid on this platform but UsbDk is not available
+ */
+int API_EXPORTEDV libusb_set_option(libusb_context *ctx, enum libusb_option option, ...) {
+    int     arg = 0, r = LIBUSB_SUCCESS;
+    va_list ap;
+
+    va_start(ap, option);
+    if(LIBUSB_OPTION_LOG_LEVEL == option) {
+        arg = va_arg(ap, int);
+        if(arg < LIBUSB_LOG_LEVEL_NONE || arg > LIBUSB_LOG_LEVEL_DEBUG) {
+            r = LIBUSB_ERROR_INVALID_PARAM;
+        }
+    }
+    va_end(ap);
+
+    if(LIBUSB_SUCCESS != r) {
+        return r;
+    }
+
+    if(option >= LIBUSB_OPTION_MAX) {
+        return LIBUSB_ERROR_INVALID_PARAM;
+    }
+
+    if(NULL == ctx) {
+        usbi_mutex_static_lock(&default_context_lock);
+        default_context_options[option].is_set = 1;
+        if(LIBUSB_OPTION_LOG_LEVEL == option) {
+            default_context_options[option].arg.ival = arg;
+        }
+        usbi_mutex_static_unlock(&default_context_lock);
+    }
+
+    ctx = usbi_get_context(ctx);
+    if(NULL == ctx) {
+        return LIBUSB_SUCCESS;
+    }
+
+    switch(option) {
+    case LIBUSB_OPTION_LOG_LEVEL:
+#if defined(ENABLE_LOGGING) && !defined(ENABLE_DEBUG_LOGGING)
+        if(!ctx->debug_fixed)
+            ctx->debug = (enum libusb_log_level)arg;
+#endif
+        break;
+
+        /* Handle all backend-specific options here */
+    case LIBUSB_OPTION_USE_USBDK:
+    case LIBUSB_OPTION_NO_DEVICE_DISCOVERY:
+    case LIBUSB_OPTION_WINUSB_RAW_IO:
+        if(usbi_backend.set_option)
+            return usbi_backend.set_option(ctx, option, ap);
+
+        return LIBUSB_ERROR_NOT_SUPPORTED;
+        break;
+
+    default:
+        return LIBUSB_ERROR_INVALID_PARAM;
+    }
+
+    return LIBUSB_SUCCESS;
+    ;
+}
+
+#if defined(ENABLE_LOGGING) && !defined(ENABLE_DEBUG_LOGGING)
+/* returns the log level as defined in the LIBUSB_DEBUG environment variable.
+ * if LIBUSB_DEBUG is not present or not a number, returns LIBUSB_LOG_LEVEL_NONE.
+ * value is clamped to ensure it is within the valid range of possibilities.
+ */
+static enum libusb_log_level get_env_debug_level(void) {
+    const char           *dbg = getenv("LIBUSB_DEBUG");
+    enum libusb_log_level level;
+    if(dbg) {
+        int dbg_level = atoi(dbg);
+        dbg_level     = CLAMP(dbg_level, LIBUSB_LOG_LEVEL_NONE, LIBUSB_LOG_LEVEL_DEBUG);
+        level         = (enum libusb_log_level)dbg_level;
+    }
+    else {
+        level = LIBUSB_LOG_LEVEL_NONE;
+    }
+    return level;
+}
+#endif
+
+/** \ingroup libusb_lib
+ * Initialize libusb. This function must be called before calling any other
+ * libusb function.
+ *
+ * If you do not provide an output location for a context pointer, a default
+ * context will be created. If there was already a default context, it will
+ * be reused (and nothing will be initialized/reinitialized). Deprecated in
+ * favor of \ref libusb_init_context().
+ *
+ * \param ctx Optional output location for context pointer.
+ * Only valid on return code 0.
+ * \returns 0 on success, or a LIBUSB_ERROR code on failure
+ * \see libusb_contexts
+ */
+int API_EXPORTED libusb_init(libusb_context **ctx) {
+    return libusb_init_context(ctx, NULL, 0);
+}
+
+/** \ingroup libusb_lib
+ * Initialize libusb. This function must be called before calling any other
+ * libusb function.
+ *
+ * If you do not provide an output location for a context pointer, a default
+ * context will be created. If there was already a default context, it will
+ * be reused (and nothing will be initialized/reinitialized and options will
+ * be ignored). If num_options is 0 then options is ignored and may be NULL.
+ *
+ * \param ctx Optional output location for context pointer.
+ * Only valid on return code 0.
+ * \param options Optional array of options to set on the new context.
+ * \param num_options Number of elements in the options array.
+ * \returns 0 on success, or a LIBUSB_ERROR code on failure
+ * \see libusb_contexts
+ */
+int API_EXPORTED libusb_init_context(libusb_context **ctx, const struct libusb_init_option options[], int num_options) {
+    size_t                 priv_size = usbi_backend.context_priv_size;
+    struct libusb_context *_ctx;
+    int                    r;
+
+    usbi_mutex_static_lock(&default_context_lock);
+
+    if(!ctx && default_context_refcnt > 0) {
+        usbi_dbg(usbi_default_context, "reusing default context");
+        default_context_refcnt++;
+        usbi_mutex_static_unlock(&default_context_lock);
+        return 0;
+    }
+
+    /* check for first init */
+    if(!active_contexts_list.next) {
+        list_init(&active_contexts_list);
+        usbi_get_monotonic_time(&timestamp_origin);
+    }
+
+    _ctx = calloc(1, PTR_ALIGN(sizeof(*_ctx)) + priv_size);
+    if(!_ctx) {
+        usbi_mutex_static_unlock(&default_context_lock);
+        return LIBUSB_ERROR_NO_MEM;
+    }
+
+    _ctx->debug = LIBUSB_LOG_LEVEL_NONE;
+#if defined(ENABLE_LOGGING) && !defined(ENABLE_DEBUG_LOGGING)
+    if(getenv("LIBUSB_DEBUG")) {
+        _ctx->debug       = get_env_debug_level();
+        _ctx->debug_fixed = 1;
+    }
+    else if(default_context_options[LIBUSB_OPTION_LOG_LEVEL].is_set) {
+        _ctx->debug = default_context_options[LIBUSB_OPTION_LOG_LEVEL].arg.ival;
+    }
+#endif
+
+    usbi_mutex_init(&_ctx->usb_devs_lock);
+    usbi_mutex_init(&_ctx->open_devs_lock);
+    list_init(&_ctx->usb_devs);
+    list_init(&_ctx->open_devs);
+
+    /* apply default options to all new contexts */
+    for(enum libusb_option option = 0; option < LIBUSB_OPTION_MAX; option++) {
+        if(LIBUSB_OPTION_LOG_LEVEL == option || !default_context_options[option].is_set) {
+            continue;
+        }
+        r = libusb_set_option(_ctx, option);
+        if(LIBUSB_SUCCESS != r)
+            goto err_free_ctx;
+    }
+
+    /* apply any options provided by the user */
+    for(int i = 0; i < num_options; ++i) {
+        r = libusb_set_option(_ctx, options[i].option, options[i].value.ival);
+        if(LIBUSB_SUCCESS != r)
+            goto err_free_ctx;
+    }
+
+    /* default context must be initialized before calling usbi_dbg */
+    if(!ctx) {
+        usbi_default_context   = _ctx;
+        default_context_refcnt = 1;
+        usbi_dbg(usbi_default_context, "created default context");
+    }
+
+    usbi_dbg(_ctx, "libusb v%u.%u.%u.%u%s", libusb_version_internal.major, libusb_version_internal.minor, libusb_version_internal.micro,
+             libusb_version_internal.nano, libusb_version_internal.rc);
+
+    r = usbi_io_init(_ctx);
+    if(r < 0)
+        goto err_free_ctx;
+
+    usbi_mutex_static_lock(&active_contexts_lock);
+    list_add(&_ctx->list, &active_contexts_list);
+    usbi_mutex_static_unlock(&active_contexts_lock);
+
+    if(usbi_backend.init) {
+        r = usbi_backend.init(_ctx);
+        if(r)
+            goto err_io_exit;
+    }
+
+    /* Initialize hotplug after the initial enumeration is done. */
+    usbi_hotplug_init(_ctx);
+
+    if(ctx) {
+        *ctx = _ctx;
+
+        if(!usbi_fallback_context) {
+            usbi_fallback_context = _ctx;
+            usbi_dbg(usbi_fallback_context, "installing new context as implicit default");
+        }
+    }
+
+    usbi_mutex_static_unlock(&default_context_lock);
+
+    return 0;
+
+err_io_exit:
+    usbi_mutex_static_lock(&active_contexts_lock);
+    list_del(&_ctx->list);
+    usbi_mutex_static_unlock(&active_contexts_lock);
+
+    usbi_hotplug_exit(_ctx);
+    usbi_io_exit(_ctx);
+
+err_free_ctx:
+    if(!ctx) {
+        /* clear default context that was not fully initialized */
+        usbi_default_context   = NULL;
+        default_context_refcnt = 0;
+    }
+
+    usbi_mutex_destroy(&_ctx->open_devs_lock);
+    usbi_mutex_destroy(&_ctx->usb_devs_lock);
+
+    free(_ctx);
+
+    usbi_mutex_static_unlock(&default_context_lock);
+
+    return r;
+}
+
+/** \ingroup libusb_lib
+ * Deinitialize libusb. Should be called after closing all open devices and
+ * before your application terminates.
+ * \param ctx the context to deinitialize, or NULL for the default context
+ */
+void API_EXPORTED libusb_exit(libusb_context *ctx) {
+    struct libusb_context *_ctx;
+    struct libusb_device  *dev;
+
+    usbi_mutex_static_lock(&default_context_lock);
+
+    /* if working with default context, only actually do the deinitialization
+     * if we're the last user */
+    if(!ctx) {
+        if(!usbi_default_context) {
+            usbi_dbg(ctx, "no default context, not initialized?");
+            usbi_mutex_static_unlock(&default_context_lock);
+            return;
+        }
+
+        if(--default_context_refcnt > 0) {
+            usbi_dbg(ctx, "not destroying default context");
+            usbi_mutex_static_unlock(&default_context_lock);
+            return;
+        }
+
+        usbi_dbg(ctx, "destroying default context");
+        _ctx = usbi_default_context;
+    }
+    else {
+        usbi_dbg(ctx, " ");
+        _ctx = ctx;
+    }
+
+    usbi_mutex_static_lock(&active_contexts_lock);
+    list_del(&_ctx->list);
+    usbi_mutex_static_unlock(&active_contexts_lock);
+
+    /* Exit hotplug before backend dependency */
+    usbi_hotplug_exit(_ctx);
+
+    if(usbi_backend.exit)
+        usbi_backend.exit(_ctx);
+
+    if(!ctx)
+        usbi_default_context = NULL;
+    if(ctx == usbi_fallback_context)
+        usbi_fallback_context = NULL;
+
+    usbi_mutex_static_unlock(&default_context_lock);
+
+    /* Don't bother with locking after this point because unless there is
+     * an application bug, nobody will be accessing the context. */
+
+    usbi_io_exit(_ctx);
+
+    for_each_device(_ctx, dev) {
+        usbi_warn(_ctx, "device %d.%d still referenced", dev->bus_number, dev->device_address);
+        DEVICE_CTX(dev) = NULL;
+    }
+
+    if(!list_empty(&_ctx->open_devs))
+        usbi_warn(_ctx, "application left some devices open");
+
+    usbi_mutex_destroy(&_ctx->open_devs_lock);
+    usbi_mutex_destroy(&_ctx->usb_devs_lock);
+
+    free(_ctx);
+}
+
+/** \ingroup libusb_misc
+ * Check at runtime if the loaded library has a given capability.
+ * This call should be performed after \ref libusb_init(), to ensure the
+ * backend has updated its capability set.
+ *
+ * \param capability the \ref libusb_capability to check for
+ * \returns nonzero if the running library has the capability, 0 otherwise
+ */
+int API_EXPORTED libusb_has_capability(uint32_t capability) {
+    switch(capability) {
+    case LIBUSB_CAP_HAS_CAPABILITY:
+        return 1;
+    case LIBUSB_CAP_HAS_HOTPLUG:
+        return !(usbi_backend.get_device_list);
+    case LIBUSB_CAP_HAS_HID_ACCESS:
+        return (usbi_backend.caps & USBI_CAP_HAS_HID_ACCESS);
+    case LIBUSB_CAP_SUPPORTS_DETACH_KERNEL_DRIVER:
+        return (usbi_backend.caps & USBI_CAP_SUPPORTS_DETACH_KERNEL_DRIVER);
+    }
+    return 0;
+}
+
+#ifdef ENABLE_LOGGING
+
+/* this is defined in libusbi.h if needed */
+#ifdef LIBUSB_PRINTF_WIN32
+/*
+ * Prior to VS2015, Microsoft did not provide the snprintf() function and
+ * provided a vsnprintf() that did not guarantee NUL-terminated output.
+ * Microsoft did provide a _snprintf() function, but again it did not
+ * guarantee NULL-terminated output.
+ *
+ * The below implementations guarantee NUL-terminated output and are
+ * C99 compliant.
+ */
+
+int usbi_snprintf(char *str, size_t size, const char *format, ...) {
+    va_list args;
+    int     ret;
+
+    va_start(args, format);
+    ret = usbi_vsnprintf(str, size, format, args);
+    va_end(args);
+
+    return ret;
+}
+
+int usbi_vsnprintf(char *str, size_t size, const char *format, va_list args) {
+    int ret;
+
+    ret = _vsnprintf(str, size, format, args);
+    if(ret < 0 || ret == (int)size) {
+        /* Output is truncated, ensure buffer is NUL-terminated and
+         * determine how many characters would have been written. */
+        str[size - 1] = '\0';
+        if(ret < 0)
+            ret = _vsnprintf(NULL, 0, format, args);
+    }
+
+    return ret;
+}
+#endif /* LIBUSB_PRINTF_WIN32 */
+
+static void log_str(enum libusb_log_level level, const char *str) {
+#if defined(USE_SYSTEM_LOGGING_FACILITY)
+#if defined(__ANDROID__)
+    int priority;
+    switch(level) {
+    case LIBUSB_LOG_LEVEL_NONE:
+        return; /* Impossible, but keeps compiler happy */
+    case LIBUSB_LOG_LEVEL_ERROR:
+        priority = ANDROID_LOG_ERROR;
+        break;
+    case LIBUSB_LOG_LEVEL_WARNING:
+        priority = ANDROID_LOG_WARN;
+        break;
+    case LIBUSB_LOG_LEVEL_INFO:
+        priority = ANDROID_LOG_INFO;
+        break;
+    case LIBUSB_LOG_LEVEL_DEBUG:
+        priority = ANDROID_LOG_DEBUG;
+        break;
+    default:
+        priority = ANDROID_LOG_UNKNOWN;
+    }
+    __android_log_write(priority, "libusb", str);
+#elif defined(_WIN32)
+    UNUSED(level);
+    OutputDebugStringA(str);
+#elif defined(HAVE_SYSLOG)
+    int syslog_level;
+    switch(level) {
+    case LIBUSB_LOG_LEVEL_NONE:
+        return; /* Impossible, but keeps compiler happy */
+    case LIBUSB_LOG_LEVEL_ERROR:
+        syslog_level = LOG_ERR;
+        break;
+    case LIBUSB_LOG_LEVEL_WARNING:
+        syslog_level = LOG_WARNING;
+        break;
+    case LIBUSB_LOG_LEVEL_INFO:
+        syslog_level = LOG_INFO;
+        break;
+    case LIBUSB_LOG_LEVEL_DEBUG:
+        syslog_level = LOG_DEBUG;
+        break;
+    default:
+        syslog_level = LOG_INFO;
+    }
+    syslog(syslog_level, "%s", str);
+#else /* All of gcc, Clang, Xcode seem to use #warning */
+#warning System logging is not supported on this platform. Logging to stderr will be used instead.
+    UNUSED(level);
+    fputs(str, stderr);
+#endif
+#else
+    /* Global log handler */
+    if(log_handler)
+        log_handler(NULL, level, str);
+    else
+        fputs(str, stderr);
+#endif /* USE_SYSTEM_LOGGING_FACILITY */
+}
+
+static void log_v(struct libusb_context *ctx, enum libusb_log_level level, const char *function, const char *format, va_list args) {
+    const char *prefix;
+    char        buf[USBI_MAX_LOG_LEN];
+    int         global_debug, header_len, text_len;
+    static int  has_debug_header_been_displayed = 0;
+
+#ifdef ENABLE_DEBUG_LOGGING
+    global_debug = 1;
+    UNUSED(ctx);
+#else
+    enum libusb_log_level ctx_level;
+
+    ctx = ctx ? ctx : usbi_default_context;
+    ctx = ctx ? ctx : usbi_fallback_context;
+    if(ctx)
+        ctx_level = ctx->debug;
+    else
+        ctx_level = get_env_debug_level();
+
+    if(ctx_level < level)
+        return;
+
+    global_debug = (ctx_level == LIBUSB_LOG_LEVEL_DEBUG);
+#endif
+
+    switch(level) {
+    case LIBUSB_LOG_LEVEL_NONE: /* Impossible, but keeps compiler happy */
+        return;
+    case LIBUSB_LOG_LEVEL_ERROR:
+        prefix = "error";
+        break;
+    case LIBUSB_LOG_LEVEL_WARNING:
+        prefix = "warning";
+        break;
+    case LIBUSB_LOG_LEVEL_INFO:
+        prefix = "info";
+        break;
+    case LIBUSB_LOG_LEVEL_DEBUG:
+        prefix = "debug";
+        break;
+    default:
+        prefix = "unknown";
+        break;
+    }
+
+    if(global_debug) {
+        struct timespec timestamp;
+
+        if(!has_debug_header_been_displayed) {
+            has_debug_header_been_displayed = 1;
+            log_str(LIBUSB_LOG_LEVEL_DEBUG, "[timestamp] [threadID] facility level [function call] <message>" USBI_LOG_LINE_END);
+            log_str(LIBUSB_LOG_LEVEL_DEBUG, "--------------------------------------------------------------------------------" USBI_LOG_LINE_END);
+        }
+
+        usbi_get_monotonic_time(&timestamp);
+        TIMESPEC_SUB(&timestamp, &timestamp_origin, &timestamp);
+
+        header_len = snprintf(buf, sizeof(buf), "[%2ld.%06ld] [%08x] libusb: %s [%s] ", (long)timestamp.tv_sec, (long)(timestamp.tv_nsec / 1000L),
+                              usbi_get_tid(), prefix, function);
+    }
+    else {
+        header_len = snprintf(buf, sizeof(buf), "libusb: %s [%s] ", prefix, function);
+    }
+
+    if(header_len < 0 || header_len >= (int)sizeof(buf)) {
+        /* Somehow snprintf() failed to write to the buffer,
+         * remove the header so something useful is output. */
+        header_len = 0;
+    }
+
+    text_len = vsnprintf(buf + header_len, sizeof(buf) - (size_t)header_len, format, args);
+    if(text_len < 0 || text_len + header_len >= (int)sizeof(buf)) {
+        /* Truncated log output. On some platforms a -1 return value means
+         * that the output was truncated. */
+        text_len = (int)sizeof(buf) - header_len;
+    }
+    if(header_len + text_len + (int)sizeof(USBI_LOG_LINE_END) >= (int)sizeof(buf)) {
+        /* Need to truncate the text slightly to fit on the terminator. */
+        text_len -= (header_len + text_len + (int)sizeof(USBI_LOG_LINE_END)) - (int)sizeof(buf);
+    }
+    strcpy(buf + header_len + text_len, USBI_LOG_LINE_END);
+
+    log_str(level, buf);
+
+    /* Per-context log handler */
+#ifndef ENABLE_DEBUG_LOGGING
+    if(ctx && ctx->log_handler)
+        ctx->log_handler(ctx, level, buf);
+#endif
+}
+
+void usbi_log(struct libusb_context *ctx, enum libusb_log_level level, const char *function, const char *format, ...) {
+    va_list args;
+
+    va_start(args, format);
+    log_v(ctx, level, function, format, args);
+    va_end(args);
+}
+
+#endif /* ENABLE_LOGGING */
+
+/** \ingroup libusb_misc
+ * Returns a constant NULL-terminated string with the ASCII name of a libusb
+ * error or transfer status code. The caller must not free() the returned
+ * string.
+ *
+ * \param error_code The \ref libusb_error or libusb_transfer_status code to
+ * return the name of.
+ * \returns The error name, or the string **UNKNOWN** if the value of
+ * error_code is not a known error / status code.
+ */
+DEFAULT_VISIBILITY const char *LIBUSB_CALL libusb_error_name(int error_code) {
+    switch(error_code) {
+    case LIBUSB_ERROR_IO:
+        return "LIBUSB_ERROR_IO";
+    case LIBUSB_ERROR_INVALID_PARAM:
+        return "LIBUSB_ERROR_INVALID_PARAM";
+    case LIBUSB_ERROR_ACCESS:
+        return "LIBUSB_ERROR_ACCESS";
+    case LIBUSB_ERROR_NO_DEVICE:
+        return "LIBUSB_ERROR_NO_DEVICE";
+    case LIBUSB_ERROR_NOT_FOUND:
+        return "LIBUSB_ERROR_NOT_FOUND";
+    case LIBUSB_ERROR_BUSY:
+        return "LIBUSB_ERROR_BUSY";
+    case LIBUSB_ERROR_TIMEOUT:
+        return "LIBUSB_ERROR_TIMEOUT";
+    case LIBUSB_ERROR_OVERFLOW:
+        return "LIBUSB_ERROR_OVERFLOW";
+    case LIBUSB_ERROR_PIPE:
+        return "LIBUSB_ERROR_PIPE";
+    case LIBUSB_ERROR_INTERRUPTED:
+        return "LIBUSB_ERROR_INTERRUPTED";
+    case LIBUSB_ERROR_NO_MEM:
+        return "LIBUSB_ERROR_NO_MEM";
+    case LIBUSB_ERROR_NOT_SUPPORTED:
+        return "LIBUSB_ERROR_NOT_SUPPORTED";
+    case LIBUSB_ERROR_OTHER:
+        return "LIBUSB_ERROR_OTHER";
+
+    case LIBUSB_TRANSFER_ERROR:
+        return "LIBUSB_TRANSFER_ERROR";
+    case LIBUSB_TRANSFER_TIMED_OUT:
+        return "LIBUSB_TRANSFER_TIMED_OUT";
+    case LIBUSB_TRANSFER_CANCELLED:
+        return "LIBUSB_TRANSFER_CANCELLED";
+    case LIBUSB_TRANSFER_STALL:
+        return "LIBUSB_TRANSFER_STALL";
+    case LIBUSB_TRANSFER_NO_DEVICE:
+        return "LIBUSB_TRANSFER_NO_DEVICE";
+    case LIBUSB_TRANSFER_OVERFLOW:
+        return "LIBUSB_TRANSFER_OVERFLOW";
+
+    case 0:
+        return "LIBUSB_SUCCESS / LIBUSB_TRANSFER_COMPLETED";
+    default:
+        return "**UNKNOWN**";
+    }
+}
+
+/** \ingroup libusb_misc
+ * Returns a pointer to const struct libusb_version with the version
+ * (major, minor, micro, nano and rc) of the running library.
+ */
+DEFAULT_VISIBILITY
+const struct libusb_version *LIBUSB_CALL libusb_get_version(void) {
+    return &libusb_version_internal;
+}
diff --git a/3rdparty/libusb/src/libusb/descriptor.c b/3rdparty/libusb/src/libusb/descriptor.c
new file mode 100644
index 00000000..390d3908
--- /dev/null
+++ b/3rdparty/libusb/src/libusb/descriptor.c
@@ -0,0 +1,1273 @@
+/* -*- Mode: C; indent-tabs-mode:t ; c-basic-offset:8 -*- */
+/*
+ * USB descriptor handling functions for libusb
+ * Copyright © 2007 Daniel Drake <dsd@gentoo.org>
+ * Copyright © 2001 Johannes Erdfelt <johannes@erdfelt.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "libusbi.h"
+
+#include <string.h>
+
+#define DESC_HEADER_LENGTH 2
+
+/** @defgroup libusb_desc USB descriptors
+ * This page details how to examine the various standard USB descriptors
+ * for detected devices
+ */
+
+#define READ_LE16(p) ((uint16_t)(((uint16_t)((p)[1]) << 8) | ((uint16_t)((p)[0]))))
+
+#define READ_LE32(p) ((uint32_t)(((uint32_t)((p)[3]) << 24) | ((uint32_t)((p)[2]) << 16) | ((uint32_t)((p)[1]) << 8) | ((uint32_t)((p)[0]))))
+
+static void parse_descriptor(const void *source, const char *descriptor, void *dest) {
+    const uint8_t *sp = source;
+    uint8_t       *dp = dest;
+    char           field_type;
+
+    while(*descriptor) {
+        field_type = *descriptor++;
+        switch(field_type) {
+        case 'b': /* 8-bit byte */
+            *dp++ = *sp++;
+            break;
+        case 'w':                      /* 16-bit word, convert from little endian to CPU */
+            dp += ((uintptr_t)dp & 1); /* Align to 16-bit word boundary */
+
+            *((uint16_t *)dp) = READ_LE16(sp);
+            sp += 2;
+            dp += 2;
+            break;
+        case 'd':                          /* 32-bit word, convert from little endian to CPU */
+            dp += 4 - ((uintptr_t)dp & 3); /* Align to 32-bit word boundary */
+
+            *((uint32_t *)dp) = READ_LE32(sp);
+            sp += 4;
+            dp += 4;
+            break;
+        case 'u': /* 16 byte UUID */
+            memcpy(dp, sp, 16);
+            sp += 16;
+            dp += 16;
+            break;
+        }
+    }
+}
+
+static void clear_endpoint(struct libusb_endpoint_descriptor *endpoint) {
+    free((void *)endpoint->extra);
+}
+
+static int parse_endpoint(struct libusb_context *ctx, struct libusb_endpoint_descriptor *endpoint, const uint8_t *buffer, int size) {
+    const struct usbi_descriptor_header *header;
+    const uint8_t                       *begin;
+    void                                *extra;
+    int                                  parsed = 0;
+    int                                  len;
+
+    if(size < DESC_HEADER_LENGTH) {
+        usbi_err(ctx, "short endpoint descriptor read %d/%d", size, DESC_HEADER_LENGTH);
+        return LIBUSB_ERROR_IO;
+    }
+
+    header = (const struct usbi_descriptor_header *)buffer;
+    if(header->bDescriptorType != LIBUSB_DT_ENDPOINT) {
+        usbi_err(ctx, "unexpected descriptor 0x%x (expected 0x%x)", header->bDescriptorType, LIBUSB_DT_ENDPOINT);
+        return parsed;
+    }
+    else if(header->bLength < LIBUSB_DT_ENDPOINT_SIZE) {
+        usbi_err(ctx, "invalid endpoint bLength (%u)", header->bLength);
+        return LIBUSB_ERROR_IO;
+    }
+    else if(header->bLength > size) {
+        usbi_warn(ctx, "short endpoint descriptor read %d/%u", size, header->bLength);
+        return parsed;
+    }
+
+    if(header->bLength >= LIBUSB_DT_ENDPOINT_AUDIO_SIZE)
+        parse_descriptor(buffer, "bbbbwbbb", endpoint);
+    else
+        parse_descriptor(buffer, "bbbbwb", endpoint);
+
+    buffer += header->bLength;
+    size -= header->bLength;
+    parsed += header->bLength;
+
+    /* Skip over the rest of the Class Specific or Vendor Specific */
+    /*  descriptors */
+    begin = buffer;
+    while(size >= DESC_HEADER_LENGTH) {
+        header = (const struct usbi_descriptor_header *)buffer;
+        if(header->bLength < DESC_HEADER_LENGTH) {
+            usbi_err(ctx, "invalid extra ep desc len (%u)", header->bLength);
+            return LIBUSB_ERROR_IO;
+        }
+        else if(header->bLength > size) {
+            usbi_warn(ctx, "short extra ep desc read %d/%u", size, header->bLength);
+            return parsed;
+        }
+
+        /* If we find another "proper" descriptor then we're done  */
+        if(header->bDescriptorType == LIBUSB_DT_ENDPOINT || header->bDescriptorType == LIBUSB_DT_INTERFACE || header->bDescriptorType == LIBUSB_DT_CONFIG
+           || header->bDescriptorType == LIBUSB_DT_DEVICE)
+            break;
+
+        usbi_dbg(ctx, "skipping descriptor 0x%x", header->bDescriptorType);
+        buffer += header->bLength;
+        size -= header->bLength;
+        parsed += header->bLength;
+    }
+
+    /* Copy any unknown descriptors into a storage area for drivers */
+    /*  to later parse */
+    len = (int)(buffer - begin);
+    if(len <= 0)
+        return parsed;
+
+    extra = malloc((size_t)len);
+    if(!extra)
+        return LIBUSB_ERROR_NO_MEM;
+
+    memcpy(extra, begin, len);
+    endpoint->extra        = extra;
+    endpoint->extra_length = len;
+
+    return parsed;
+}
+
+static void clear_interface(struct libusb_interface *usb_interface) {
+    int i;
+
+    if(usb_interface->altsetting) {
+        for(i = 0; i < usb_interface->num_altsetting; i++) {
+            struct libusb_interface_descriptor *ifp = (struct libusb_interface_descriptor *)usb_interface->altsetting + i;
+
+            free((void *)ifp->extra);
+            if(ifp->endpoint) {
+                uint8_t j;
+
+                for(j = 0; j < ifp->bNumEndpoints; j++)
+                    clear_endpoint((struct libusb_endpoint_descriptor *)ifp->endpoint + j);
+            }
+            free((void *)ifp->endpoint);
+        }
+    }
+    free((void *)usb_interface->altsetting);
+    usb_interface->altsetting = NULL;
+}
+
+static int parse_interface(libusb_context *ctx, struct libusb_interface *usb_interface, const uint8_t *buffer, int size) {
+    int                                     len;
+    int                                     r;
+    int                                     parsed           = 0;
+    int                                     interface_number = -1;
+    const struct usbi_descriptor_header    *header;
+    const struct usbi_interface_descriptor *if_desc;
+    struct libusb_interface_descriptor     *ifp;
+    const uint8_t                          *begin;
+
+    while(size >= LIBUSB_DT_INTERFACE_SIZE) {
+        struct libusb_interface_descriptor *altsetting;
+
+        altsetting = realloc((void *)usb_interface->altsetting, sizeof(*altsetting) * (size_t)(usb_interface->num_altsetting + 1));
+        if(!altsetting) {
+            r = LIBUSB_ERROR_NO_MEM;
+            goto err;
+        }
+        usb_interface->altsetting = altsetting;
+
+        ifp = altsetting + usb_interface->num_altsetting;
+        parse_descriptor(buffer, "bbbbbbbbb", ifp);
+        if(ifp->bDescriptorType != LIBUSB_DT_INTERFACE) {
+            usbi_err(ctx, "unexpected descriptor 0x%x (expected 0x%x)", ifp->bDescriptorType, LIBUSB_DT_INTERFACE);
+            return parsed;
+        }
+        else if(ifp->bLength < LIBUSB_DT_INTERFACE_SIZE) {
+            usbi_err(ctx, "invalid interface bLength (%u)", ifp->bLength);
+            r = LIBUSB_ERROR_IO;
+            goto err;
+        }
+        else if(ifp->bLength > size) {
+            usbi_warn(ctx, "short intf descriptor read %d/%u", size, ifp->bLength);
+            return parsed;
+        }
+        else if(ifp->bNumEndpoints > USB_MAXENDPOINTS) {
+            usbi_err(ctx, "too many endpoints (%u)", ifp->bNumEndpoints);
+            r = LIBUSB_ERROR_IO;
+            goto err;
+        }
+
+        usb_interface->num_altsetting++;
+        ifp->extra        = NULL;
+        ifp->extra_length = 0;
+        ifp->endpoint     = NULL;
+
+        if(interface_number == -1)
+            interface_number = ifp->bInterfaceNumber;
+
+        /* Skip over the interface */
+        buffer += ifp->bLength;
+        parsed += ifp->bLength;
+        size -= ifp->bLength;
+
+        begin = buffer;
+
+        /* Skip over any interface, class or vendor descriptors */
+        while(size >= DESC_HEADER_LENGTH) {
+            header = (const struct usbi_descriptor_header *)buffer;
+            if(header->bLength < DESC_HEADER_LENGTH) {
+                usbi_err(ctx, "invalid extra intf desc len (%u)", header->bLength);
+                r = LIBUSB_ERROR_IO;
+                goto err;
+            }
+            else if(header->bLength > size) {
+                usbi_warn(ctx, "short extra intf desc read %d/%u", size, header->bLength);
+                return parsed;
+            }
+
+            /* If we find another "proper" descriptor then we're done */
+            if(header->bDescriptorType == LIBUSB_DT_INTERFACE || header->bDescriptorType == LIBUSB_DT_ENDPOINT || header->bDescriptorType == LIBUSB_DT_CONFIG
+               || header->bDescriptorType == LIBUSB_DT_DEVICE)
+                break;
+
+            buffer += header->bLength;
+            parsed += header->bLength;
+            size -= header->bLength;
+        }
+
+        /* Copy any unknown descriptors into a storage area for */
+        /*  drivers to later parse */
+        len = (int)(buffer - begin);
+        if(len > 0) {
+            void *extra = malloc((size_t)len);
+
+            if(!extra) {
+                r = LIBUSB_ERROR_NO_MEM;
+                goto err;
+            }
+
+            memcpy(extra, begin, len);
+            ifp->extra        = extra;
+            ifp->extra_length = len;
+        }
+
+        if(ifp->bNumEndpoints > 0) {
+            struct libusb_endpoint_descriptor *endpoint;
+            uint8_t                            i;
+
+            endpoint = calloc(ifp->bNumEndpoints, sizeof(*endpoint));
+            if(!endpoint) {
+                r = LIBUSB_ERROR_NO_MEM;
+                goto err;
+            }
+
+            ifp->endpoint = endpoint;
+            for(i = 0; i < ifp->bNumEndpoints; i++) {
+                r = parse_endpoint(ctx, endpoint + i, buffer, size);
+                if(r < 0)
+                    goto err;
+                if(r == 0) {
+                    ifp->bNumEndpoints = i;
+                    break;
+                }
+
+                buffer += r;
+                parsed += r;
+                size -= r;
+            }
+        }
+
+        /* We check to see if it's an alternate to this one */
+        if_desc = (const struct usbi_interface_descriptor *)buffer;
+        if(size < LIBUSB_DT_INTERFACE_SIZE || if_desc->bDescriptorType != LIBUSB_DT_INTERFACE || if_desc->bInterfaceNumber != interface_number)
+            return parsed;
+    }
+
+    return parsed;
+err:
+    clear_interface(usb_interface);
+    return r;
+}
+
+static void clear_configuration(struct libusb_config_descriptor *config) {
+    uint8_t i;
+
+    if(config->interface) {
+        for(i = 0; i < config->bNumInterfaces; i++)
+            clear_interface((struct libusb_interface *)config->interface + i);
+    }
+    free((void *)config->interface);
+    free((void *)config->extra);
+}
+
+static int parse_configuration(struct libusb_context *ctx, struct libusb_config_descriptor *config, const uint8_t *buffer, int size) {
+    uint8_t                              i;
+    int                                  r;
+    const struct usbi_descriptor_header *header;
+    struct libusb_interface             *usb_interface;
+
+    if(size < LIBUSB_DT_CONFIG_SIZE) {
+        usbi_err(ctx, "short config descriptor read %d/%d", size, LIBUSB_DT_CONFIG_SIZE);
+        return LIBUSB_ERROR_IO;
+    }
+
+    parse_descriptor(buffer, "bbwbbbbb", config);
+    if(config->bDescriptorType != LIBUSB_DT_CONFIG) {
+        usbi_err(ctx, "unexpected descriptor 0x%x (expected 0x%x)", config->bDescriptorType, LIBUSB_DT_CONFIG);
+        return LIBUSB_ERROR_IO;
+    }
+    else if(config->bLength < LIBUSB_DT_CONFIG_SIZE) {
+        usbi_err(ctx, "invalid config bLength (%u)", config->bLength);
+        return LIBUSB_ERROR_IO;
+    }
+    else if(config->bLength > size) {
+        usbi_err(ctx, "short config descriptor read %d/%u", size, config->bLength);
+        return LIBUSB_ERROR_IO;
+    }
+    else if(config->bNumInterfaces > USB_MAXINTERFACES) {
+        usbi_err(ctx, "too many interfaces (%u)", config->bNumInterfaces);
+        return LIBUSB_ERROR_IO;
+    }
+
+    usb_interface = calloc(config->bNumInterfaces, sizeof(*usb_interface));
+    if(!usb_interface)
+        return LIBUSB_ERROR_NO_MEM;
+
+    config->interface = usb_interface;
+
+    buffer += config->bLength;
+    size -= config->bLength;
+
+    for(i = 0; i < config->bNumInterfaces; i++) {
+        int            len;
+        const uint8_t *begin;
+
+        /* Skip over the rest of the Class Specific or Vendor */
+        /*  Specific descriptors */
+        begin = buffer;
+        while(size >= DESC_HEADER_LENGTH) {
+            header = (const struct usbi_descriptor_header *)buffer;
+            if(header->bLength < DESC_HEADER_LENGTH) {
+                usbi_err(ctx, "invalid extra config desc len (%u)", header->bLength);
+                r = LIBUSB_ERROR_IO;
+                goto err;
+            }
+            else if(header->bLength > size) {
+                usbi_warn(ctx, "short extra config desc read %d/%u", size, header->bLength);
+                config->bNumInterfaces = i;
+                return size;
+            }
+
+            /* If we find another "proper" descriptor then we're done */
+            if(header->bDescriptorType == LIBUSB_DT_ENDPOINT || header->bDescriptorType == LIBUSB_DT_INTERFACE || header->bDescriptorType == LIBUSB_DT_CONFIG
+               || header->bDescriptorType == LIBUSB_DT_DEVICE)
+                break;
+
+            usbi_dbg(ctx, "skipping descriptor 0x%x", header->bDescriptorType);
+            buffer += header->bLength;
+            size -= header->bLength;
+        }
+
+        /* Copy any unknown descriptors into a storage area for */
+        /*  drivers to later parse */
+        len = (int)(buffer - begin);
+        if(len > 0) {
+            uint8_t *extra = realloc((void *)config->extra, (size_t)(config->extra_length + len));
+
+            if(!extra) {
+                r = LIBUSB_ERROR_NO_MEM;
+                goto err;
+            }
+
+            memcpy(extra + config->extra_length, begin, len);
+            config->extra = extra;
+            config->extra_length += len;
+        }
+
+        r = parse_interface(ctx, usb_interface + i, buffer, size);
+        if(r < 0)
+            goto err;
+        if(r == 0) {
+            config->bNumInterfaces = i;
+            break;
+        }
+
+        buffer += r;
+        size -= r;
+    }
+
+    return size;
+
+err:
+    clear_configuration(config);
+    return r;
+}
+
+static int raw_desc_to_config(struct libusb_context *ctx, const uint8_t *buf, int size, struct libusb_config_descriptor **config) {
+    struct libusb_config_descriptor *_config = calloc(1, sizeof(*_config));
+    int                              r;
+
+    if(!_config)
+        return LIBUSB_ERROR_NO_MEM;
+
+    r = parse_configuration(ctx, _config, buf, size);
+    if(r < 0) {
+        usbi_err(ctx, "parse_configuration failed with error %d", r);
+        free(_config);
+        return r;
+    }
+    else if(r > 0) {
+        usbi_warn(ctx, "still %d bytes of descriptor data left", r);
+    }
+
+    *config = _config;
+    return LIBUSB_SUCCESS;
+}
+
+static int get_active_config_descriptor(struct libusb_device *dev, uint8_t *buffer, size_t size) {
+    int r = usbi_backend.get_active_config_descriptor(dev, buffer, size);
+
+    if(r < 0)
+        return r;
+
+    if(r < LIBUSB_DT_CONFIG_SIZE) {
+        usbi_err(DEVICE_CTX(dev), "short config descriptor read %d/%d", r, LIBUSB_DT_CONFIG_SIZE);
+        return LIBUSB_ERROR_IO;
+    }
+    else if(r != (int)size) {
+        usbi_warn(DEVICE_CTX(dev), "short config descriptor read %d/%d", r, (int)size);
+    }
+
+    return r;
+}
+
+static int get_config_descriptor(struct libusb_device *dev, uint8_t config_idx, uint8_t *buffer, size_t size) {
+    int r = usbi_backend.get_config_descriptor(dev, config_idx, buffer, size);
+
+    if(r < 0)
+        return r;
+    if(r < LIBUSB_DT_CONFIG_SIZE) {
+        usbi_err(DEVICE_CTX(dev), "short config descriptor read %d/%d", r, LIBUSB_DT_CONFIG_SIZE);
+        return LIBUSB_ERROR_IO;
+    }
+    else if(r != (int)size) {
+        usbi_warn(DEVICE_CTX(dev), "short config descriptor read %d/%d", r, (int)size);
+    }
+
+    return r;
+}
+
+/** \ingroup libusb_desc
+ * Get the USB device descriptor for a given device.
+ *
+ * This is a non-blocking function; the device descriptor is cached in memory.
+ *
+ * Note since libusb-1.0.16, \ref LIBUSB_API_VERSION >= 0x01000102, this
+ * function always succeeds.
+ *
+ * \param dev the device
+ * \param desc output location for the descriptor data
+ * \returns 0 on success or a LIBUSB_ERROR code on failure
+ */
+int API_EXPORTED libusb_get_device_descriptor(libusb_device *dev, struct libusb_device_descriptor *desc) {
+    usbi_dbg(DEVICE_CTX(dev), " ");
+    static_assert(sizeof(dev->device_descriptor) == LIBUSB_DT_DEVICE_SIZE, "struct libusb_device_descriptor is not expected size");
+    *desc = dev->device_descriptor;
+    return 0;
+}
+
+/** \ingroup libusb_desc
+ * Get the USB configuration descriptor for the currently active configuration.
+ * This is a non-blocking function which does not involve any requests being
+ * sent to the device.
+ *
+ * \param dev a device
+ * \param config output location for the USB configuration descriptor. Only
+ * valid if 0 was returned. Must be freed with libusb_free_config_descriptor()
+ * after use.
+ * \returns 0 on success
+ * \returns \ref LIBUSB_ERROR_NOT_FOUND if the device is in unconfigured state
+ * \returns another LIBUSB_ERROR code on error
+ * \see libusb_get_config_descriptor
+ */
+int API_EXPORTED libusb_get_active_config_descriptor(libusb_device *dev, struct libusb_config_descriptor **config) {
+    union usbi_config_desc_buf _config;
+    uint16_t                   config_len;
+    uint8_t                   *buf;
+    int                        r;
+
+    r = get_active_config_descriptor(dev, _config.buf, sizeof(_config.buf));
+    if(r < 0)
+        return r;
+
+    config_len = libusb_le16_to_cpu(_config.desc.wTotalLength);
+    buf        = malloc(config_len);
+    if(!buf)
+        return LIBUSB_ERROR_NO_MEM;
+
+    r = get_active_config_descriptor(dev, buf, config_len);
+    if(r >= 0)
+        r = raw_desc_to_config(DEVICE_CTX(dev), buf, r, config);
+
+    free(buf);
+    return r;
+}
+
+/** \ingroup libusb_desc
+ * Get a USB configuration descriptor based on its index.
+ * This is a non-blocking function which does not involve any requests being
+ * sent to the device.
+ *
+ * \param dev a device
+ * \param config_index the index of the configuration you wish to retrieve
+ * \param config output location for the USB configuration descriptor. Only
+ * valid if 0 was returned. Must be freed with libusb_free_config_descriptor()
+ * after use.
+ * \returns 0 on success
+ * \returns \ref LIBUSB_ERROR_NOT_FOUND if the configuration does not exist
+ * \returns another LIBUSB_ERROR code on error
+ * \see libusb_get_active_config_descriptor()
+ * \see libusb_get_config_descriptor_by_value()
+ */
+int API_EXPORTED libusb_get_config_descriptor(libusb_device *dev, uint8_t config_index, struct libusb_config_descriptor **config) {
+    union usbi_config_desc_buf _config;
+    uint16_t                   config_len;
+    uint8_t                   *buf;
+    int                        r;
+
+    usbi_dbg(DEVICE_CTX(dev), "index %u", config_index);
+    if(config_index >= dev->device_descriptor.bNumConfigurations)
+        return LIBUSB_ERROR_NOT_FOUND;
+
+    r = get_config_descriptor(dev, config_index, _config.buf, sizeof(_config.buf));
+    if(r < 0)
+        return r;
+
+    config_len = libusb_le16_to_cpu(_config.desc.wTotalLength);
+    buf        = malloc(config_len);
+    if(!buf)
+        return LIBUSB_ERROR_NO_MEM;
+
+    r = get_config_descriptor(dev, config_index, buf, config_len);
+    if(r >= 0)
+        r = raw_desc_to_config(DEVICE_CTX(dev), buf, r, config);
+
+    free(buf);
+    return r;
+}
+
+/** \ingroup libusb_desc
+ * Get a USB configuration descriptor with a specific bConfigurationValue.
+ * This is a non-blocking function which does not involve any requests being
+ * sent to the device.
+ *
+ * \param dev a device
+ * \param bConfigurationValue the bConfigurationValue of the configuration you
+ * wish to retrieve
+ * \param config output location for the USB configuration descriptor. Only
+ * valid if 0 was returned. Must be freed with libusb_free_config_descriptor()
+ * after use.
+ * \returns 0 on success
+ * \returns \ref LIBUSB_ERROR_NOT_FOUND if the configuration does not exist
+ * \returns another LIBUSB_ERROR code on error
+ * \see libusb_get_active_config_descriptor()
+ * \see libusb_get_config_descriptor()
+ */
+int API_EXPORTED libusb_get_config_descriptor_by_value(libusb_device *dev, uint8_t bConfigurationValue, struct libusb_config_descriptor **config) {
+    uint8_t idx;
+    int     r;
+
+    if(usbi_backend.get_config_descriptor_by_value) {
+        void *buf;
+
+        r = usbi_backend.get_config_descriptor_by_value(dev, bConfigurationValue, &buf);
+        if(r < 0)
+            return r;
+
+        return raw_desc_to_config(DEVICE_CTX(dev), buf, r, config);
+    }
+
+    usbi_dbg(DEVICE_CTX(dev), "value %u", bConfigurationValue);
+    for(idx = 0; idx < dev->device_descriptor.bNumConfigurations; idx++) {
+        union usbi_config_desc_buf _config;
+
+        r = get_config_descriptor(dev, idx, _config.buf, sizeof(_config.buf));
+        if(r < 0)
+            return r;
+
+        if(_config.desc.bConfigurationValue == bConfigurationValue)
+            return libusb_get_config_descriptor(dev, idx, config);
+    }
+
+    return LIBUSB_ERROR_NOT_FOUND;
+}
+
+/** \ingroup libusb_desc
+ * Free a configuration descriptor obtained from
+ * libusb_get_active_config_descriptor() or libusb_get_config_descriptor().
+ * It is safe to call this function with a NULL config parameter, in which
+ * case the function simply returns.
+ *
+ * \param config the configuration descriptor to free
+ */
+void API_EXPORTED libusb_free_config_descriptor(struct libusb_config_descriptor *config) {
+    if(!config)
+        return;
+
+    clear_configuration(config);
+    free(config);
+}
+
+/** \ingroup libusb_desc
+ * Get an endpoints superspeed endpoint companion descriptor (if any)
+ *
+ * \param ctx the context to operate on, or NULL for the default context
+ * \param endpoint endpoint descriptor from which to get the superspeed
+ * endpoint companion descriptor
+ * \param ep_comp output location for the superspeed endpoint companion
+ * descriptor. Only valid if 0 was returned. Must be freed with
+ * libusb_free_ss_endpoint_companion_descriptor() after use.
+ * \returns 0 on success
+ * \returns \ref LIBUSB_ERROR_NOT_FOUND if the configuration does not exist
+ * \returns another LIBUSB_ERROR code on error
+ */
+int API_EXPORTED libusb_get_ss_endpoint_companion_descriptor(libusb_context *ctx, const struct libusb_endpoint_descriptor *endpoint,
+                                                             struct libusb_ss_endpoint_companion_descriptor **ep_comp) {
+    struct usbi_descriptor_header *header;
+    const uint8_t                 *buffer = endpoint->extra;
+    int                            size   = endpoint->extra_length;
+
+    *ep_comp = NULL;
+
+    while(size >= DESC_HEADER_LENGTH) {
+        header = (struct usbi_descriptor_header *)buffer;
+        if(header->bDescriptorType != LIBUSB_DT_SS_ENDPOINT_COMPANION) {
+            if(header->bLength < DESC_HEADER_LENGTH) {
+                usbi_err(ctx, "invalid descriptor length %u", header->bLength);
+                return LIBUSB_ERROR_IO;
+            }
+            buffer += header->bLength;
+            size -= header->bLength;
+            continue;
+        }
+        else if(header->bLength < LIBUSB_DT_SS_ENDPOINT_COMPANION_SIZE) {
+            usbi_err(ctx, "invalid ss-ep-comp-desc length %u", header->bLength);
+            return LIBUSB_ERROR_IO;
+        }
+        else if(header->bLength > size) {
+            usbi_err(ctx, "short ss-ep-comp-desc read %d/%u", size, header->bLength);
+            return LIBUSB_ERROR_IO;
+        }
+
+        *ep_comp = malloc(sizeof(**ep_comp));
+        if(!*ep_comp)
+            return LIBUSB_ERROR_NO_MEM;
+        parse_descriptor(buffer, "bbbbw", *ep_comp);
+        return LIBUSB_SUCCESS;
+    }
+    return LIBUSB_ERROR_NOT_FOUND;
+}
+
+/** \ingroup libusb_desc
+ * Free a superspeed endpoint companion descriptor obtained from
+ * libusb_get_ss_endpoint_companion_descriptor().
+ * It is safe to call this function with a NULL ep_comp parameter, in which
+ * case the function simply returns.
+ *
+ * \param ep_comp the superspeed endpoint companion descriptor to free
+ */
+void API_EXPORTED libusb_free_ss_endpoint_companion_descriptor(struct libusb_ss_endpoint_companion_descriptor *ep_comp) {
+    free(ep_comp);
+}
+
+static int parse_bos(struct libusb_context *ctx, struct libusb_bos_descriptor **bos, const uint8_t *buffer, int size) {
+    struct libusb_bos_descriptor        *_bos;
+    const struct usbi_bos_descriptor    *bos_desc;
+    const struct usbi_descriptor_header *header;
+    uint8_t                              i;
+
+    if(size < LIBUSB_DT_BOS_SIZE) {
+        usbi_err(ctx, "short bos descriptor read %d/%d", size, LIBUSB_DT_BOS_SIZE);
+        return LIBUSB_ERROR_IO;
+    }
+
+    bos_desc = (const struct usbi_bos_descriptor *)buffer;
+    if(bos_desc->bDescriptorType != LIBUSB_DT_BOS) {
+        usbi_err(ctx, "unexpected descriptor 0x%x (expected 0x%x)", bos_desc->bDescriptorType, LIBUSB_DT_BOS);
+        return LIBUSB_ERROR_IO;
+    }
+    else if(bos_desc->bLength < LIBUSB_DT_BOS_SIZE) {
+        usbi_err(ctx, "invalid bos bLength (%u)", bos_desc->bLength);
+        return LIBUSB_ERROR_IO;
+    }
+    else if(bos_desc->bLength > size) {
+        usbi_err(ctx, "short bos descriptor read %d/%u", size, bos_desc->bLength);
+        return LIBUSB_ERROR_IO;
+    }
+
+    _bos = calloc(1, sizeof(*_bos) + bos_desc->bNumDeviceCaps * sizeof(void *));
+    if(!_bos)
+        return LIBUSB_ERROR_NO_MEM;
+
+    parse_descriptor(buffer, "bbwb", _bos);
+    buffer += _bos->bLength;
+    size -= _bos->bLength;
+
+    /* Get the device capability descriptors */
+    for(i = 0; i < _bos->bNumDeviceCaps; i++) {
+        if(size < LIBUSB_DT_DEVICE_CAPABILITY_SIZE) {
+            usbi_warn(ctx, "short dev-cap descriptor read %d/%d", size, LIBUSB_DT_DEVICE_CAPABILITY_SIZE);
+            break;
+        }
+        header = (const struct usbi_descriptor_header *)buffer;
+        if(header->bDescriptorType != LIBUSB_DT_DEVICE_CAPABILITY) {
+            usbi_warn(ctx, "unexpected descriptor 0x%x (expected 0x%x)", header->bDescriptorType, LIBUSB_DT_DEVICE_CAPABILITY);
+            break;
+        }
+        else if(header->bLength < LIBUSB_DT_DEVICE_CAPABILITY_SIZE) {
+            usbi_err(ctx, "invalid dev-cap bLength (%u)", header->bLength);
+            libusb_free_bos_descriptor(_bos);
+            return LIBUSB_ERROR_IO;
+        }
+        else if(header->bLength > size) {
+            usbi_warn(ctx, "short dev-cap descriptor read %d/%u", size, header->bLength);
+            break;
+        }
+
+        _bos->dev_capability[i] = malloc(header->bLength);
+        if(!_bos->dev_capability[i]) {
+            libusb_free_bos_descriptor(_bos);
+            return LIBUSB_ERROR_NO_MEM;
+        }
+        memcpy(_bos->dev_capability[i], buffer, header->bLength);
+        buffer += header->bLength;
+        size -= header->bLength;
+    }
+    _bos->bNumDeviceCaps = i;
+    *bos                 = _bos;
+
+    return LIBUSB_SUCCESS;
+}
+
+/** \ingroup libusb_desc
+ * Get a Binary Object Store (BOS) descriptor
+ * This is a BLOCKING function, which will send requests to the device.
+ *
+ * \param dev_handle the handle of an open libusb device
+ * \param bos output location for the BOS descriptor. Only valid if 0 was returned.
+ * Must be freed with \ref libusb_free_bos_descriptor() after use.
+ * \returns 0 on success
+ * \returns \ref LIBUSB_ERROR_NOT_FOUND if the device doesn't have a BOS descriptor
+ * \returns another LIBUSB_ERROR code on error
+ */
+int API_EXPORTED libusb_get_bos_descriptor(libusb_device_handle *dev_handle, struct libusb_bos_descriptor **bos) {
+    union usbi_bos_desc_buf _bos;
+    uint16_t                bos_len;
+    uint8_t                *bos_data;
+    int                     r;
+    struct libusb_context  *ctx = HANDLE_CTX(dev_handle);
+
+    /* Read the BOS. This generates 2 requests on the bus,
+     * one for the header, and one for the full BOS */
+    r = libusb_get_descriptor(dev_handle, LIBUSB_DT_BOS, 0, _bos.buf, sizeof(_bos.buf));
+    if(r < 0) {
+        if(r != LIBUSB_ERROR_PIPE)
+            usbi_err(ctx, "failed to read BOS (%d)", r);
+        return r;
+    }
+    if(r < LIBUSB_DT_BOS_SIZE) {
+        usbi_err(ctx, "short BOS read %d/%d", r, LIBUSB_DT_BOS_SIZE);
+        return LIBUSB_ERROR_IO;
+    }
+
+    bos_len = libusb_le16_to_cpu(_bos.desc.wTotalLength);
+    usbi_dbg(ctx, "found BOS descriptor: size %u bytes, %u capabilities", bos_len, _bos.desc.bNumDeviceCaps);
+    bos_data = calloc(1, bos_len);
+    if(!bos_data)
+        return LIBUSB_ERROR_NO_MEM;
+
+    r = libusb_get_descriptor(dev_handle, LIBUSB_DT_BOS, 0, bos_data, bos_len);
+    if(r >= 0) {
+        if(r != (int)bos_len)
+            usbi_warn(ctx, "short BOS read %d/%u", r, bos_len);
+        r = parse_bos(HANDLE_CTX(dev_handle), bos, bos_data, r);
+    }
+    else {
+        usbi_err(ctx, "failed to read BOS (%d)", r);
+    }
+
+    free(bos_data);
+    return r;
+}
+
+/** \ingroup libusb_desc
+ * Free a BOS descriptor obtained from libusb_get_bos_descriptor().
+ * It is safe to call this function with a NULL bos parameter, in which
+ * case the function simply returns.
+ *
+ * \param bos the BOS descriptor to free
+ */
+void API_EXPORTED libusb_free_bos_descriptor(struct libusb_bos_descriptor *bos) {
+    uint8_t i;
+
+    if(!bos)
+        return;
+
+    for(i = 0; i < bos->bNumDeviceCaps; i++)
+        free(bos->dev_capability[i]);
+    free(bos);
+}
+
+/** \ingroup libusb_desc
+ * Get an USB 2.0 Extension descriptor
+ *
+ * \param ctx the context to operate on, or NULL for the default context
+ * \param dev_cap Device Capability descriptor with a bDevCapabilityType of
+ * \ref libusb_capability_type::LIBUSB_BT_USB_2_0_EXTENSION
+ * LIBUSB_BT_USB_2_0_EXTENSION
+ * \param usb_2_0_extension output location for the USB 2.0 Extension
+ * descriptor. Only valid if 0 was returned. Must be freed with
+ * libusb_free_usb_2_0_extension_descriptor() after use.
+ * \returns 0 on success
+ * \returns a LIBUSB_ERROR code on error
+ */
+int API_EXPORTED libusb_get_usb_2_0_extension_descriptor(libusb_context *ctx, struct libusb_bos_dev_capability_descriptor *dev_cap,
+                                                         struct libusb_usb_2_0_extension_descriptor **usb_2_0_extension) {
+    struct libusb_usb_2_0_extension_descriptor *_usb_2_0_extension;
+
+    if(dev_cap->bDevCapabilityType != LIBUSB_BT_USB_2_0_EXTENSION) {
+        usbi_err(ctx, "unexpected bDevCapabilityType 0x%x (expected 0x%x)", dev_cap->bDevCapabilityType, LIBUSB_BT_USB_2_0_EXTENSION);
+        return LIBUSB_ERROR_INVALID_PARAM;
+    }
+    else if(dev_cap->bLength < LIBUSB_BT_USB_2_0_EXTENSION_SIZE) {
+        usbi_err(ctx, "short dev-cap descriptor read %u/%d", dev_cap->bLength, LIBUSB_BT_USB_2_0_EXTENSION_SIZE);
+        return LIBUSB_ERROR_IO;
+    }
+
+    _usb_2_0_extension = malloc(sizeof(*_usb_2_0_extension));
+    if(!_usb_2_0_extension)
+        return LIBUSB_ERROR_NO_MEM;
+
+    parse_descriptor(dev_cap, "bbbd", _usb_2_0_extension);
+
+    *usb_2_0_extension = _usb_2_0_extension;
+    return LIBUSB_SUCCESS;
+}
+
+/** \ingroup libusb_desc
+ * Free a USB 2.0 Extension descriptor obtained from
+ * libusb_get_usb_2_0_extension_descriptor().
+ * It is safe to call this function with a NULL usb_2_0_extension parameter,
+ * in which case the function simply returns.
+ *
+ * \param usb_2_0_extension the USB 2.0 Extension descriptor to free
+ */
+void API_EXPORTED libusb_free_usb_2_0_extension_descriptor(struct libusb_usb_2_0_extension_descriptor *usb_2_0_extension) {
+    free(usb_2_0_extension);
+}
+
+/** \ingroup libusb_desc
+ * Get a SuperSpeed USB Device Capability descriptor
+ *
+ * \param ctx the context to operate on, or NULL for the default context
+ * \param dev_cap Device Capability descriptor with a bDevCapabilityType of
+ * \ref libusb_capability_type::LIBUSB_BT_SS_USB_DEVICE_CAPABILITY
+ * LIBUSB_BT_SS_USB_DEVICE_CAPABILITY
+ * \param ss_usb_device_cap output location for the SuperSpeed USB Device
+ * Capability descriptor. Only valid if 0 was returned. Must be freed with
+ * libusb_free_ss_usb_device_capability_descriptor() after use.
+ * \returns 0 on success
+ * \returns a LIBUSB_ERROR code on error
+ */
+int API_EXPORTED libusb_get_ss_usb_device_capability_descriptor(libusb_context *ctx, struct libusb_bos_dev_capability_descriptor *dev_cap,
+                                                                struct libusb_ss_usb_device_capability_descriptor **ss_usb_device_cap) {
+    struct libusb_ss_usb_device_capability_descriptor *_ss_usb_device_cap;
+
+    if(dev_cap->bDevCapabilityType != LIBUSB_BT_SS_USB_DEVICE_CAPABILITY) {
+        usbi_err(ctx, "unexpected bDevCapabilityType 0x%x (expected 0x%x)", dev_cap->bDevCapabilityType, LIBUSB_BT_SS_USB_DEVICE_CAPABILITY);
+        return LIBUSB_ERROR_INVALID_PARAM;
+    }
+    else if(dev_cap->bLength < LIBUSB_BT_SS_USB_DEVICE_CAPABILITY_SIZE) {
+        usbi_err(ctx, "short dev-cap descriptor read %u/%d", dev_cap->bLength, LIBUSB_BT_SS_USB_DEVICE_CAPABILITY_SIZE);
+        return LIBUSB_ERROR_IO;
+    }
+
+    _ss_usb_device_cap = malloc(sizeof(*_ss_usb_device_cap));
+    if(!_ss_usb_device_cap)
+        return LIBUSB_ERROR_NO_MEM;
+
+    parse_descriptor(dev_cap, "bbbbwbbw", _ss_usb_device_cap);
+
+    *ss_usb_device_cap = _ss_usb_device_cap;
+    return LIBUSB_SUCCESS;
+}
+
+/** \ingroup libusb_desc
+ * Free a SuperSpeed USB Device Capability descriptor obtained from
+ * libusb_get_ss_usb_device_capability_descriptor().
+ * It is safe to call this function with a NULL ss_usb_device_cap
+ * parameter, in which case the function simply returns.
+ *
+ * \param ss_usb_device_cap the SuperSpeed USB Device Capability descriptor
+ * to free
+ */
+void API_EXPORTED libusb_free_ss_usb_device_capability_descriptor(struct libusb_ss_usb_device_capability_descriptor *ss_usb_device_cap) {
+    free(ss_usb_device_cap);
+}
+
+/** \ingroup libusb_desc
+ * Get a Container ID descriptor
+ *
+ * \param ctx the context to operate on, or NULL for the default context
+ * \param dev_cap Device Capability descriptor with a bDevCapabilityType of
+ * \ref libusb_capability_type::LIBUSB_BT_CONTAINER_ID
+ * LIBUSB_BT_CONTAINER_ID
+ * \param container_id output location for the Container ID descriptor.
+ * Only valid if 0 was returned. Must be freed with
+ * libusb_free_container_id_descriptor() after use.
+ * \returns 0 on success
+ * \returns a LIBUSB_ERROR code on error
+ */
+int API_EXPORTED libusb_get_container_id_descriptor(libusb_context *ctx, struct libusb_bos_dev_capability_descriptor *dev_cap,
+                                                    struct libusb_container_id_descriptor **container_id) {
+    struct libusb_container_id_descriptor *_container_id;
+
+    if(dev_cap->bDevCapabilityType != LIBUSB_BT_CONTAINER_ID) {
+        usbi_err(ctx, "unexpected bDevCapabilityType 0x%x (expected 0x%x)", dev_cap->bDevCapabilityType, LIBUSB_BT_CONTAINER_ID);
+        return LIBUSB_ERROR_INVALID_PARAM;
+    }
+    else if(dev_cap->bLength < LIBUSB_BT_CONTAINER_ID_SIZE) {
+        usbi_err(ctx, "short dev-cap descriptor read %u/%d", dev_cap->bLength, LIBUSB_BT_CONTAINER_ID_SIZE);
+        return LIBUSB_ERROR_IO;
+    }
+
+    _container_id = malloc(sizeof(*_container_id));
+    if(!_container_id)
+        return LIBUSB_ERROR_NO_MEM;
+
+    parse_descriptor(dev_cap, "bbbbu", _container_id);
+
+    *container_id = _container_id;
+    return LIBUSB_SUCCESS;
+}
+
+/** \ingroup libusb_desc
+ * Free a Container ID descriptor obtained from
+ * libusb_get_container_id_descriptor().
+ * It is safe to call this function with a NULL container_id parameter,
+ * in which case the function simply returns.
+ *
+ * \param container_id the Container ID descriptor to free
+ */
+void API_EXPORTED libusb_free_container_id_descriptor(struct libusb_container_id_descriptor *container_id) {
+    free(container_id);
+}
+
+/** \ingroup libusb_desc
+ * Get a platform descriptor
+ *
+ * \param ctx the context to operate on, or NULL for the default context
+ * \param dev_cap Device Capability descriptor with a bDevCapabilityType of
+ * \ref libusb_capability_type::LIBUSB_BT_PLATFORM_DESCRIPTOR
+ * LIBUSB_BT_PLATFORM_DESCRIPTOR
+ * \param platform_descriptor output location for the Platform descriptor.
+ * Only valid if 0 was returned. Must be freed with
+ * libusb_free_platform_descriptor() after use.
+ * \returns 0 on success
+ * \returns a LIBUSB_ERROR code on error
+ */
+int API_EXPORTED libusb_get_platform_descriptor(libusb_context *ctx, struct libusb_bos_dev_capability_descriptor *dev_cap,
+                                                struct libusb_platform_descriptor **platform_descriptor) {
+    struct libusb_platform_descriptor *_platform_descriptor;
+
+    if(dev_cap->bDevCapabilityType != LIBUSB_BT_PLATFORM_DESCRIPTOR) {
+        usbi_err(ctx, "unexpected bDevCapabilityType 0x%x (expected 0x%x)", dev_cap->bDevCapabilityType, LIBUSB_BT_PLATFORM_DESCRIPTOR);
+        return LIBUSB_ERROR_INVALID_PARAM;
+    }
+    else if(dev_cap->bLength < LIBUSB_BT_PLATFORM_DESCRIPTOR_MIN_SIZE) {
+        usbi_err(ctx, "short dev-cap descriptor read %u/%d", dev_cap->bLength, LIBUSB_BT_PLATFORM_DESCRIPTOR_MIN_SIZE);
+        return LIBUSB_ERROR_IO;
+    }
+
+    _platform_descriptor = malloc(dev_cap->bLength);
+    if(!_platform_descriptor)
+        return LIBUSB_ERROR_NO_MEM;
+
+    parse_descriptor(dev_cap, "bbbbu", _platform_descriptor);
+
+    /* Capability data is located after reserved byte and 128-bit UUID */
+    uint8_t *capability_data = dev_cap->dev_capability_data + 1 + 16;
+
+    /* Capability data length is total descriptor length minus initial fields */
+    size_t capability_data_length = _platform_descriptor->bLength - (16 + 4);
+
+    memcpy(_platform_descriptor->CapabilityData, capability_data, capability_data_length);
+
+    *platform_descriptor = _platform_descriptor;
+    return LIBUSB_SUCCESS;
+}
+
+/** \ingroup libusb_desc
+ * Free a platform descriptor obtained from
+ * libusb_get_platform_descriptor().
+ * It is safe to call this function with a NULL platform_descriptor parameter,
+ * in which case the function simply returns.
+ *
+ * \param platform_descriptor the Platform descriptor to free
+ */
+void API_EXPORTED libusb_free_platform_descriptor(struct libusb_platform_descriptor *platform_descriptor) {
+    free(platform_descriptor);
+}
+
+/** \ingroup libusb_desc
+ * Retrieve a string descriptor in C style ASCII.
+ *
+ * Wrapper around libusb_get_string_descriptor(). Uses the first language
+ * supported by the device.
+ *
+ * \param dev_handle a device handle
+ * \param desc_index the index of the descriptor to retrieve
+ * \param data output buffer for ASCII string descriptor
+ * \param length size of data buffer
+ * \returns number of bytes returned in data, or LIBUSB_ERROR code on failure
+ */
+int API_EXPORTED libusb_get_string_descriptor_ascii(libusb_device_handle *dev_handle, uint8_t desc_index, unsigned char *data, int length) {
+    union usbi_string_desc_buf str;
+    int                        r, si, di;
+    uint16_t                   langid, wdata;
+
+    /* Asking for the zero'th index is special - it returns a string
+     * descriptor that contains all the language IDs supported by the
+     * device. Typically there aren't many - often only one. Language
+     * IDs are 16 bit numbers, and they start at the third byte in the
+     * descriptor. There's also no point in trying to read descriptor 0
+     * with this function. See USB 2.0 specification section 9.6.7 for
+     * more information.
+     */
+
+    if(desc_index == 0)
+        return LIBUSB_ERROR_INVALID_PARAM;
+
+    r = libusb_get_string_descriptor(dev_handle, 0, 0, str.buf, 4);
+    if(r < 0)
+        return r;
+    else if(r != 4 || str.desc.bLength < 4)
+        return LIBUSB_ERROR_IO;
+    else if(str.desc.bDescriptorType != LIBUSB_DT_STRING)
+        return LIBUSB_ERROR_IO;
+    else if(str.desc.bLength & 1)
+        usbi_warn(HANDLE_CTX(dev_handle), "suspicious bLength %u for language ID string descriptor", str.desc.bLength);
+
+    langid = libusb_le16_to_cpu(str.desc.wData[0]);
+    r      = libusb_get_string_descriptor(dev_handle, desc_index, langid, str.buf, sizeof(str.buf));
+    if(r < 0)
+        return r;
+    else if(r < DESC_HEADER_LENGTH || str.desc.bLength > r)
+        return LIBUSB_ERROR_IO;
+    else if(str.desc.bDescriptorType != LIBUSB_DT_STRING)
+        return LIBUSB_ERROR_IO;
+    else if((str.desc.bLength & 1) || str.desc.bLength != r)
+        usbi_warn(HANDLE_CTX(dev_handle), "suspicious bLength %u for string descriptor (read %d)", str.desc.bLength, r);
+
+    di = 0;
+    for(si = 2; si < str.desc.bLength; si += 2) {
+        if(di >= (length - 1))
+            break;
+
+        wdata = libusb_le16_to_cpu(str.desc.wData[di]);
+        if(wdata < 0x80)
+            data[di++] = (unsigned char)wdata;
+        else
+            data[di++] = '?'; /* non-ASCII */
+    }
+
+    data[di] = 0;
+    return di;
+}
+
+static int parse_iad_array(struct libusb_context *ctx, struct libusb_interface_association_descriptor_array *iad_array, const uint8_t *buffer, int size) {
+    uint8_t                                         i;
+    struct usbi_descriptor_header                   header;
+    int                                             consumed = 0;
+    const uint8_t                                  *buf      = buffer;
+    struct libusb_interface_association_descriptor *iad;
+
+    if(size < LIBUSB_DT_CONFIG_SIZE) {
+        usbi_err(ctx, "short config descriptor read %d/%d", size, LIBUSB_DT_CONFIG_SIZE);
+        return LIBUSB_ERROR_IO;
+    }
+
+    // First pass: Iterate through desc list, count number of IADs
+    iad_array->length = 0;
+    while(consumed < size) {
+        parse_descriptor(buf, "bb", &header);
+        if(header.bDescriptorType == LIBUSB_DT_INTERFACE_ASSOCIATION)
+            iad_array->length++;
+        buf += header.bLength;
+        consumed += header.bLength;
+    }
+
+    iad_array->iad = NULL;
+    if(iad_array->length > 0) {
+        iad = calloc(iad_array->length, sizeof(*iad));
+        if(!iad)
+            return LIBUSB_ERROR_NO_MEM;
+
+        iad_array->iad = iad;
+
+        // Second pass: Iterate through desc list, fill IAD structures
+        consumed = 0;
+        i        = 0;
+        while(consumed < size) {
+            parse_descriptor(buffer, "bb", &header);
+            if(header.bDescriptorType == LIBUSB_DT_INTERFACE_ASSOCIATION)
+                parse_descriptor(buffer, "bbbbbbbb", &iad[i++]);
+            buffer += header.bLength;
+            consumed += header.bLength;
+        }
+    }
+
+    return LIBUSB_SUCCESS;
+}
+
+static int raw_desc_to_iad_array(struct libusb_context *ctx, const uint8_t *buf, int size, struct libusb_interface_association_descriptor_array **iad_array) {
+    struct libusb_interface_association_descriptor_array *_iad_array = calloc(1, sizeof(*_iad_array));
+    int                                                   r;
+
+    if(!_iad_array)
+        return LIBUSB_ERROR_NO_MEM;
+
+    r = parse_iad_array(ctx, _iad_array, buf, size);
+    if(r < 0) {
+        usbi_err(ctx, "parse_iad_array failed with error %d", r);
+        free(_iad_array);
+        return r;
+    }
+
+    *iad_array = _iad_array;
+    return LIBUSB_SUCCESS;
+}
+
+/** \ingroup libusb_desc
+ * Get an array of interface association descriptors (IAD) for a given
+ * configuration.
+ * This is a non-blocking function which does not involve any requests being
+ * sent to the device.
+ *
+ * \param dev a device
+ * \param config_index the index of the configuration you wish to retrieve the
+ * IADs for.
+ * \param iad_array output location for the array of IADs. Only valid if 0 was
+ * returned. Must be freed with libusb_free_interface_association_descriptors()
+ * after use. It's possible that a given configuration contains no IADs. In this
+ * case the iad_array is still output, but will have 'length' field set to 0, and
+ * iad field set to NULL.
+ * \returns 0 on success
+ * \returns LIBUSB_ERROR_NOT_FOUND if the configuration does not exist
+ * \returns another LIBUSB_ERROR code on error
+ * \see libusb_get_active_interface_association_descriptors()
+ */
+int API_EXPORTED libusb_get_interface_association_descriptors(libusb_device *dev, uint8_t config_index,
+                                                              struct libusb_interface_association_descriptor_array **iad_array) {
+    union usbi_config_desc_buf _config;
+    uint16_t                   config_len;
+    uint8_t                   *buf;
+    int                        r;
+
+    if(!iad_array)
+        return LIBUSB_ERROR_INVALID_PARAM;
+
+    usbi_dbg(DEVICE_CTX(dev), "IADs for config index %u", config_index);
+    if(config_index >= dev->device_descriptor.bNumConfigurations)
+        return LIBUSB_ERROR_NOT_FOUND;
+
+    r = get_config_descriptor(dev, config_index, _config.buf, sizeof(_config.buf));
+    if(r < 0)
+        return r;
+
+    config_len = libusb_le16_to_cpu(_config.desc.wTotalLength);
+    buf        = malloc(config_len);
+    if(!buf)
+        return LIBUSB_ERROR_NO_MEM;
+
+    r = get_config_descriptor(dev, config_index, buf, config_len);
+    if(r >= 0)
+        r = raw_desc_to_iad_array(DEVICE_CTX(dev), buf, r, iad_array);
+
+    free(buf);
+    return r;
+}
+
+/** \ingroup libusb_desc
+ * Get an array of interface association descriptors (IAD) for the currently
+ * active configuration.
+ * This is a non-blocking function which does not involve any requests being
+ * sent to the device.
+ *
+ * \param dev a device
+ * \param iad_array output location for the array of IADs. Only valid if 0 was
+ * returned. Must be freed with libusb_free_interface_association_descriptors()
+ * after use. It's possible that a given configuration contains no IADs. In this
+ * case the iad_array is still output, but will have 'length' field set to 0, and
+ * iad field set to NULL.
+ * \returns 0 on success
+ * \returns LIBUSB_ERROR_NOT_FOUND if the device is in unconfigured state
+ * \returns another LIBUSB_ERROR code on error
+ * \see libusb_get_interface_association_descriptors
+ */
+int API_EXPORTED libusb_get_active_interface_association_descriptors(libusb_device *dev, struct libusb_interface_association_descriptor_array **iad_array) {
+    union usbi_config_desc_buf _config;
+    uint16_t                   config_len;
+    uint8_t                   *buf;
+    int                        r;
+
+    if(!iad_array)
+        return LIBUSB_ERROR_INVALID_PARAM;
+
+    r = get_active_config_descriptor(dev, _config.buf, sizeof(_config.buf));
+    if(r < 0)
+        return r;
+
+    config_len = libusb_le16_to_cpu(_config.desc.wTotalLength);
+    buf        = malloc(config_len);
+    if(!buf)
+        return LIBUSB_ERROR_NO_MEM;
+
+    r = get_active_config_descriptor(dev, buf, config_len);
+    if(r >= 0)
+        r = raw_desc_to_iad_array(DEVICE_CTX(dev), buf, r, iad_array);
+    free(buf);
+    return r;
+}
+
+/** \ingroup libusb_desc
+ * Free an array of interface association descriptors (IADs) obtained from
+ * libusb_get_interface_association_descriptors() or
+ * libusb_get_active_interface_association_descriptors().
+ * It is safe to call this function with a NULL iad_array parameter, in which
+ * case the function simply returns.
+ *
+ * \param iad_array the IAD array to free
+ */
+void API_EXPORTED libusb_free_interface_association_descriptors(struct libusb_interface_association_descriptor_array *iad_array) {
+    if(!iad_array)
+        return;
+
+    if(iad_array->iad)
+        free((void *)iad_array->iad);
+    free(iad_array);
+}
diff --git a/3rdparty/libusb/src/libusb/hotplug.c b/3rdparty/libusb/src/libusb/hotplug.c
new file mode 100644
index 00000000..7b0d49fa
--- /dev/null
+++ b/3rdparty/libusb/src/libusb/hotplug.c
@@ -0,0 +1,441 @@
+/* -*- Mode: C; indent-tabs-mode:t ; c-basic-offset:8 -*- */
+/*
+ * Hotplug functions for libusb
+ * Copyright © 2012-2021 Nathan Hjelm <hjelmn@mac.com>
+ * Copyright © 2012-2013 Peter Stuge <peter@stuge.se>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "libusbi.h"
+
+/**
+ * @defgroup libusb_hotplug Device hotplug event notification
+ * This page details how to use the libusb hotplug interface, where available.
+ *
+ * Be mindful that not all platforms currently implement hotplug notification and
+ * that you should first call on \ref libusb_has_capability() with parameter
+ * \ref LIBUSB_CAP_HAS_HOTPLUG to confirm that hotplug support is available.
+ *
+ * \page libusb_hotplug Device hotplug event notification
+ *
+ * \section hotplug_intro Introduction
+ *
+ * Version 1.0.16, \ref LIBUSB_API_VERSION >= 0x01000102, has added support
+ * for hotplug events on <b>some</b> platforms (you should test if your platform
+ * supports hotplug notification by calling \ref libusb_has_capability() with
+ * parameter \ref LIBUSB_CAP_HAS_HOTPLUG).
+ *
+ * This interface allows you to request notification for the arrival and departure
+ * of matching USB devices.
+ *
+ * To receive hotplug notification you register a callback by calling
+ * \ref libusb_hotplug_register_callback(). This function will optionally return
+ * a callback handle that can be passed to \ref libusb_hotplug_deregister_callback().
+ *
+ * A callback function must return an int (0 or 1) indicating whether the callback is
+ * expecting additional events. Returning 0 will rearm the callback and 1 will cause
+ * the callback to be deregistered. Note that when callbacks are called from
+ * libusb_hotplug_register_callback() because of the \ref LIBUSB_HOTPLUG_ENUMERATE
+ * flag, the callback return value is ignored. In other words, you cannot cause a
+ * callback to be deregistered by returning 1 when it is called from
+ * libusb_hotplug_register_callback().
+ *
+ * Callbacks for a particular context are automatically deregistered by libusb_exit().
+ *
+ * As of 1.0.16 there are two supported hotplug events:
+ *  - LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED: A device has arrived and is ready to use
+ *  - LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT: A device has left and is no longer available
+ *
+ * A hotplug event can listen for either or both of these events.
+ *
+ * Note: If you receive notification that a device has left and you have any
+ * libusb_device_handles for the device it is up to you to call libusb_close()
+ * on each device handle to free up any remaining resources associated with the device.
+ * Once a device has left any libusb_device_handle associated with the device
+ * are invalid and will remain so even if the device comes back.
+ *
+ * When handling a LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED event it is considered
+ * safe to call any libusb function that takes a libusb_device. It also safe to
+ * open a device and submit asynchronous transfers. However, most other functions
+ * that take a libusb_device_handle are <b>not</b> safe to call. Examples of such
+ * functions are any of the \ref libusb_syncio "synchronous API" functions or the blocking
+ * functions that retrieve various \ref libusb_desc "USB descriptors". These functions must
+ * be used outside of the context of the hotplug callback.
+ *
+ * When handling a LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT event the only safe function
+ * is libusb_get_device_descriptor().
+ *
+ * The following code provides an example of the usage of the hotplug interface:
+\code
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include <libusb.h>
+
+static int count = 0;
+
+int hotplug_callback(struct libusb_context *ctx, struct libusb_device *dev,
+                     libusb_hotplug_event event, void *user_data) {
+  static libusb_device_handle *dev_handle = NULL;
+  struct libusb_device_descriptor desc;
+  int rc;
+
+  (void)libusb_get_device_descriptor(dev, &desc);
+
+  if (LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED == event) {
+    rc = libusb_open(dev, &dev_handle);
+    if (LIBUSB_SUCCESS != rc) {
+      printf("Could not open USB device\n");
+    }
+  } else if (LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT == event) {
+    if (dev_handle) {
+      libusb_close(dev_handle);
+      dev_handle = NULL;
+    }
+  } else {
+    printf("Unhandled event %d\n", event);
+  }
+  count++;
+
+  return 0;
+}
+
+int main (void) {
+  libusb_hotplug_callback_handle callback_handle;
+  int rc;
+
+  libusb_init(NULL);
+
+  rc = libusb_hotplug_register_callback(NULL, LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED |
+                                        LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT, 0, 0x045a, 0x5005,
+                                        LIBUSB_HOTPLUG_MATCH_ANY, hotplug_callback, NULL,
+                                        &callback_handle);
+  if (LIBUSB_SUCCESS != rc) {
+    printf("Error creating a hotplug callback\n");
+    libusb_exit(NULL);
+    return EXIT_FAILURE;
+  }
+
+  while (count < 2) {
+    libusb_handle_events_completed(NULL, NULL);
+    nanosleep(&(struct timespec){0, 10000000UL}, NULL);
+  }
+
+  libusb_hotplug_deregister_callback(NULL, callback_handle);
+  libusb_exit(NULL);
+
+  return 0;
+}
+\endcode
+ */
+
+#define VALID_HOTPLUG_EVENTS (LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED | LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT)
+
+#define VALID_HOTPLUG_FLAGS (LIBUSB_HOTPLUG_ENUMERATE)
+
+void usbi_hotplug_init(struct libusb_context *ctx) {
+    /* check for hotplug support */
+    if(!libusb_has_capability(LIBUSB_CAP_HAS_HOTPLUG))
+        return;
+
+    usbi_mutex_init(&ctx->hotplug_cbs_lock);
+    list_init(&ctx->hotplug_cbs);
+    ctx->next_hotplug_cb_handle = 1;
+    usbi_atomic_store(&ctx->hotplug_ready, 1);
+}
+
+void usbi_hotplug_exit(struct libusb_context *ctx) {
+    struct usbi_hotplug_callback *hotplug_cb, *next_cb;
+    struct usbi_hotplug_message  *msg;
+    struct libusb_device         *dev, *next_dev;
+
+    /* check for hotplug support */
+    if(!libusb_has_capability(LIBUSB_CAP_HAS_HOTPLUG))
+        return;
+
+    if(!usbi_atomic_load(&ctx->hotplug_ready))
+        return;
+
+    /* free all registered hotplug callbacks */
+    for_each_hotplug_cb_safe(ctx, hotplug_cb, next_cb) {
+        list_del(&hotplug_cb->list);
+        free(hotplug_cb);
+    }
+
+    /* free all pending hotplug messages */
+    while(!list_empty(&ctx->hotplug_msgs)) {
+        msg = list_first_entry(&ctx->hotplug_msgs, struct usbi_hotplug_message, list);
+
+        /* if the device left, the message holds a reference
+         * and we must drop it */
+        if(msg->event == LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT)
+            libusb_unref_device(msg->device);
+
+        list_del(&msg->list);
+        free(msg);
+    }
+
+    /* free all discovered devices. due to parent references loop until no devices are freed. */
+    for_each_device_safe(ctx, dev, next_dev) {
+        /* remove the device from the usb_devs list only if there are no
+         * references held, otherwise leave it on the list so that a
+         * warning message will be shown */
+        if(usbi_atomic_load(&dev->refcnt) == 1) {
+            list_del(&dev->list);
+        }
+        if(dev->parent_dev && usbi_atomic_load(&dev->parent_dev->refcnt) == 1) {
+            /* the parent was before this device in the list and will be released.
+               remove it from the list. this is safe as parent_dev can not be
+               equal to next_dev. */
+            assert(dev->parent_dev != next_dev);
+            list_del(&dev->parent_dev->list);
+        }
+        libusb_unref_device(dev);
+    }
+
+    usbi_mutex_destroy(&ctx->hotplug_cbs_lock);
+}
+
+static int usbi_hotplug_match_cb(struct libusb_device *dev, libusb_hotplug_event event, struct usbi_hotplug_callback *hotplug_cb) {
+    if(!(hotplug_cb->flags & event)) {
+        return 0;
+    }
+
+    if((hotplug_cb->flags & USBI_HOTPLUG_VENDOR_ID_VALID) && hotplug_cb->vendor_id != dev->device_descriptor.idVendor) {
+        return 0;
+    }
+
+    if((hotplug_cb->flags & USBI_HOTPLUG_PRODUCT_ID_VALID) && hotplug_cb->product_id != dev->device_descriptor.idProduct) {
+        return 0;
+    }
+
+    if((hotplug_cb->flags & USBI_HOTPLUG_DEV_CLASS_VALID) && hotplug_cb->dev_class != dev->device_descriptor.bDeviceClass) {
+        return 0;
+    }
+
+    return hotplug_cb->cb(DEVICE_CTX(dev), dev, event, hotplug_cb->user_data);
+}
+
+void usbi_hotplug_notification(struct libusb_context *ctx, struct libusb_device *dev, libusb_hotplug_event event) {
+    struct usbi_hotplug_message *msg;
+    unsigned int                 event_flags;
+
+    /* Only generate a notification if hotplug is ready. This prevents hotplug
+     * notifications from being generated during initial enumeration or if the
+     * backend does not support hotplug. */
+    if(!usbi_atomic_load(&ctx->hotplug_ready))
+        return;
+
+    msg = calloc(1, sizeof(*msg));
+    if(!msg) {
+        usbi_err(ctx, "error allocating hotplug message");
+        return;
+    }
+
+    msg->event  = event;
+    msg->device = dev;
+
+    /* Take the event data lock and add this message to the list.
+     * Only signal an event if there are no prior pending events. */
+    usbi_mutex_lock(&ctx->event_data_lock);
+    event_flags = ctx->event_flags;
+    ctx->event_flags |= USBI_EVENT_HOTPLUG_MSG_PENDING;
+    list_add_tail(&msg->list, &ctx->hotplug_msgs);
+    if(!event_flags)
+        usbi_signal_event(&ctx->event);
+    usbi_mutex_unlock(&ctx->event_data_lock);
+}
+
+void usbi_hotplug_process(struct libusb_context *ctx, struct list_head *hotplug_msgs) {
+    struct usbi_hotplug_callback *hotplug_cb, *next_cb;
+    struct usbi_hotplug_message  *msg;
+    int                           r;
+
+    usbi_mutex_lock(&ctx->hotplug_cbs_lock);
+
+    /* dispatch all pending hotplug messages */
+    while(!list_empty(hotplug_msgs)) {
+        msg = list_first_entry(hotplug_msgs, struct usbi_hotplug_message, list);
+
+        for_each_hotplug_cb_safe(ctx, hotplug_cb, next_cb) {
+            /* skip callbacks that have unregistered */
+            if(hotplug_cb->flags & USBI_HOTPLUG_NEEDS_FREE)
+                continue;
+
+            usbi_mutex_unlock(&ctx->hotplug_cbs_lock);
+            r = usbi_hotplug_match_cb(msg->device, msg->event, hotplug_cb);
+            usbi_mutex_lock(&ctx->hotplug_cbs_lock);
+
+            if(r) {
+                list_del(&hotplug_cb->list);
+                free(hotplug_cb);
+            }
+        }
+
+        /* if the device left, the message holds a reference
+         * and we must drop it */
+        if(msg->event == LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT)
+            libusb_unref_device(msg->device);
+
+        list_del(&msg->list);
+        free(msg);
+    }
+
+    /* free any callbacks that have unregistered */
+    for_each_hotplug_cb_safe(ctx, hotplug_cb, next_cb) {
+        if(hotplug_cb->flags & USBI_HOTPLUG_NEEDS_FREE) {
+            usbi_dbg(ctx, "freeing hotplug cb %p with handle %d", (void *)hotplug_cb, hotplug_cb->handle);
+            list_del(&hotplug_cb->list);
+            free(hotplug_cb);
+        }
+    }
+
+    usbi_mutex_unlock(&ctx->hotplug_cbs_lock);
+}
+
+int API_EXPORTED libusb_hotplug_register_callback(libusb_context *ctx, int events, int flags, int vendor_id, int product_id, int dev_class,
+                                                  libusb_hotplug_callback_fn cb_fn, void *user_data, libusb_hotplug_callback_handle *callback_handle) {
+    struct usbi_hotplug_callback *hotplug_cb;
+
+    /* check for sane values */
+    if(!events || (~VALID_HOTPLUG_EVENTS & events) || (~VALID_HOTPLUG_FLAGS & flags) || (LIBUSB_HOTPLUG_MATCH_ANY != vendor_id && (~0xffff & vendor_id))
+       || (LIBUSB_HOTPLUG_MATCH_ANY != product_id && (~0xffff & product_id)) || (LIBUSB_HOTPLUG_MATCH_ANY != dev_class && (~0xff & dev_class)) || !cb_fn) {
+        return LIBUSB_ERROR_INVALID_PARAM;
+    }
+
+    /* check for hotplug support */
+    if(!libusb_has_capability(LIBUSB_CAP_HAS_HOTPLUG))
+        return LIBUSB_ERROR_NOT_SUPPORTED;
+
+    ctx = usbi_get_context(ctx);
+
+    hotplug_cb = calloc(1, sizeof(*hotplug_cb));
+    if(!hotplug_cb)
+        return LIBUSB_ERROR_NO_MEM;
+
+    hotplug_cb->flags = (uint8_t)events;
+    if(LIBUSB_HOTPLUG_MATCH_ANY != vendor_id) {
+        hotplug_cb->flags |= USBI_HOTPLUG_VENDOR_ID_VALID;
+        hotplug_cb->vendor_id = (uint16_t)vendor_id;
+    }
+    if(LIBUSB_HOTPLUG_MATCH_ANY != product_id) {
+        hotplug_cb->flags |= USBI_HOTPLUG_PRODUCT_ID_VALID;
+        hotplug_cb->product_id = (uint16_t)product_id;
+    }
+    if(LIBUSB_HOTPLUG_MATCH_ANY != dev_class) {
+        hotplug_cb->flags |= USBI_HOTPLUG_DEV_CLASS_VALID;
+        hotplug_cb->dev_class = (uint8_t)dev_class;
+    }
+    hotplug_cb->cb        = cb_fn;
+    hotplug_cb->user_data = user_data;
+
+    usbi_mutex_lock(&ctx->hotplug_cbs_lock);
+
+    /* protect the handle by the context hotplug lock */
+    hotplug_cb->handle = ctx->next_hotplug_cb_handle++;
+
+    /* handle the unlikely case of overflow */
+    if(ctx->next_hotplug_cb_handle < 0)
+        ctx->next_hotplug_cb_handle = 1;
+
+    list_add(&hotplug_cb->list, &ctx->hotplug_cbs);
+
+    usbi_mutex_unlock(&ctx->hotplug_cbs_lock);
+
+    usbi_dbg(ctx, "new hotplug cb %p with handle %d", (void *)hotplug_cb, hotplug_cb->handle);
+
+    if((flags & LIBUSB_HOTPLUG_ENUMERATE) && (events & LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED)) {
+        ssize_t                i, len;
+        struct libusb_device **devs;
+
+        len = libusb_get_device_list(ctx, &devs);
+        if(len < 0) {
+            libusb_hotplug_deregister_callback(ctx, hotplug_cb->handle);
+            return (int)len;
+        }
+
+        for(i = 0; i < len; i++) {
+            usbi_hotplug_match_cb(devs[i], LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED, hotplug_cb);
+        }
+
+        libusb_free_device_list(devs, 1);
+    }
+
+    if(callback_handle)
+        *callback_handle = hotplug_cb->handle;
+
+    return LIBUSB_SUCCESS;
+}
+
+void API_EXPORTED libusb_hotplug_deregister_callback(libusb_context *ctx, libusb_hotplug_callback_handle callback_handle) {
+    struct usbi_hotplug_callback *hotplug_cb;
+    int                           deregistered = 0;
+
+    /* check for hotplug support */
+    if(!libusb_has_capability(LIBUSB_CAP_HAS_HOTPLUG))
+        return;
+
+    usbi_dbg(ctx, "deregister hotplug cb %d", callback_handle);
+
+    ctx = usbi_get_context(ctx);
+
+    usbi_mutex_lock(&ctx->hotplug_cbs_lock);
+    for_each_hotplug_cb(ctx, hotplug_cb) {
+        if(callback_handle == hotplug_cb->handle) {
+            /* mark this callback for deregistration */
+            hotplug_cb->flags |= USBI_HOTPLUG_NEEDS_FREE;
+            deregistered = 1;
+            break;
+        }
+    }
+    usbi_mutex_unlock(&ctx->hotplug_cbs_lock);
+
+    if(deregistered) {
+        unsigned int event_flags;
+
+        usbi_mutex_lock(&ctx->event_data_lock);
+        event_flags = ctx->event_flags;
+        ctx->event_flags |= USBI_EVENT_HOTPLUG_CB_DEREGISTERED;
+        if(!event_flags)
+            usbi_signal_event(&ctx->event);
+        usbi_mutex_unlock(&ctx->event_data_lock);
+    }
+}
+
+DEFAULT_VISIBILITY
+void *LIBUSB_CALL libusb_hotplug_get_user_data(libusb_context *ctx, libusb_hotplug_callback_handle callback_handle) {
+    struct usbi_hotplug_callback *hotplug_cb;
+    void                         *user_data = NULL;
+
+    /* check for hotplug support */
+    if(!libusb_has_capability(LIBUSB_CAP_HAS_HOTPLUG))
+        return NULL;
+
+    usbi_dbg(ctx, "get hotplug cb %d user data", callback_handle);
+
+    ctx = usbi_get_context(ctx);
+
+    usbi_mutex_lock(&ctx->hotplug_cbs_lock);
+    for_each_hotplug_cb(ctx, hotplug_cb) {
+        if(callback_handle == hotplug_cb->handle) {
+            user_data = hotplug_cb->user_data;
+            break;
+        }
+    }
+    usbi_mutex_unlock(&ctx->hotplug_cbs_lock);
+
+    return user_data;
+}
diff --git a/3rdparty/libusb/src/libusb/io.c b/3rdparty/libusb/src/libusb/io.c
new file mode 100644
index 00000000..0b7be942
--- /dev/null
+++ b/3rdparty/libusb/src/libusb/io.c
@@ -0,0 +1,2779 @@
+/* -*- Mode: C; indent-tabs-mode:t ; c-basic-offset:8 -*- */
+/*
+ * I/O functions for libusb
+ * Copyright © 2007-2009 Daniel Drake <dsd@gentoo.org>
+ * Copyright © 2001 Johannes Erdfelt <johannes@erdfelt.com>
+ * Copyright © 2019-2022 Nathan Hjelm <hjelmn@cs.unm.edu>
+ * Copyright © 2019-2022 Google LLC. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "libusbi.h"
+
+/**
+ * \page libusb_io Synchronous and asynchronous device I/O
+ *
+ * \section io_intro Introduction
+ *
+ * If you're using libusb in your application, you're probably wanting to
+ * perform I/O with devices - you want to perform USB data transfers.
+ *
+ * libusb offers two separate interfaces for device I/O. This page aims to
+ * introduce the two in order to help you decide which one is more suitable
+ * for your application. You can also choose to use both interfaces in your
+ * application by considering each transfer on a case-by-case basis.
+ *
+ * Once you have read through the following discussion, you should consult the
+ * detailed API documentation pages for the details:
+ * - \ref libusb_syncio
+ * - \ref libusb_asyncio
+ *
+ * \section theory Transfers at a logical level
+ *
+ * At a logical level, USB transfers typically happen in two parts. For
+ * example, when reading data from a endpoint:
+ * -# A request for data is sent to the device
+ * -# Some time later, the incoming data is received by the host
+ *
+ * or when writing data to an endpoint:
+ *
+ * -# The data is sent to the device
+ * -# Some time later, the host receives acknowledgement from the device that
+ *    the data has been transferred.
+ *
+ * There may be an indefinite delay between the two steps. Consider a
+ * fictional USB input device with a button that the user can press. In order
+ * to determine when the button is pressed, you would likely submit a request
+ * to read data on a bulk or interrupt endpoint and wait for data to arrive.
+ * Data will arrive when the button is pressed by the user, which is
+ * potentially hours later.
+ *
+ * libusb offers both a synchronous and an asynchronous interface to performing
+ * USB transfers. The main difference is that the synchronous interface
+ * combines both steps indicated above into a single function call, whereas
+ * the asynchronous interface separates them.
+ *
+ * \section sync The synchronous interface
+ *
+ * The synchronous I/O interface allows you to perform a USB transfer with
+ * a single function call. When the function call returns, the transfer has
+ * completed and you can parse the results.
+ *
+ * If you have used libusb-0.1 before, this I/O style will seem familiar to
+ * you. libusb-0.1 only offered a synchronous interface.
+ *
+ * In our input device example, to read button presses you might write code
+ * in the following style:
+\code
+unsigned char data[4];
+int actual_length;
+int r = libusb_bulk_transfer(dev_handle, LIBUSB_ENDPOINT_IN, data, sizeof(data), &actual_length, 0);
+if (r == 0 && actual_length == sizeof(data)) {
+    // results of the transaction can now be found in the data buffer
+    // parse them here and report button press
+} else {
+    error();
+}
+\endcode
+ *
+ * The main advantage of this model is simplicity: you did everything with
+ * a single simple function call.
+ *
+ * However, this interface has its limitations. Your application will sleep
+ * inside libusb_bulk_transfer() until the transaction has completed. If it
+ * takes the user 3 hours to press the button, your application will be
+ * sleeping for that long. Execution will be tied up inside the library -
+ * the entire thread will be useless for that duration.
+ *
+ * Another issue is that by tying up the thread with that single transaction
+ * there is no possibility of performing I/O with multiple endpoints and/or
+ * multiple devices simultaneously, unless you resort to creating one thread
+ * per transaction.
+ *
+ * Additionally, there is no opportunity to cancel the transfer after the
+ * request has been submitted.
+ *
+ * For details on how to use the synchronous API, see the
+ * \ref libusb_syncio "synchronous I/O API documentation" pages.
+ *
+ * \section async The asynchronous interface
+ *
+ * Asynchronous I/O is the most significant new feature in libusb-1.0.
+ * Although it is a more complex interface, it solves all the issues detailed
+ * above.
+ *
+ * Instead of providing which functions that block until the I/O has complete,
+ * libusb's asynchronous interface presents non-blocking functions which
+ * begin a transfer and then return immediately. Your application passes a
+ * callback function pointer to this non-blocking function, which libusb will
+ * call with the results of the transaction when it has completed.
+ *
+ * Transfers which have been submitted through the non-blocking functions
+ * can be cancelled with a separate function call.
+ *
+ * The non-blocking nature of this interface allows you to be simultaneously
+ * performing I/O to multiple endpoints on multiple devices, without having
+ * to use threads.
+ *
+ * This added flexibility does come with some complications though:
+ * - In the interest of being a lightweight library, libusb does not create
+ * threads and can only operate when your application is calling into it. Your
+ * application must call into libusb from it's main loop when events are ready
+ * to be handled, or you must use some other scheme to allow libusb to
+ * undertake whatever work needs to be done.
+ * - libusb also needs to be called into at certain fixed points in time in
+ * order to accurately handle transfer timeouts.
+ * - Memory handling becomes more complex. You cannot use stack memory unless
+ * the function with that stack is guaranteed not to return until the transfer
+ * callback has finished executing.
+ * - You generally lose some linearity from your code flow because submitting
+ * the transfer request is done in a separate function from where the transfer
+ * results are handled. This becomes particularly obvious when you want to
+ * submit a second transfer based on the results of an earlier transfer.
+ *
+ * Internally, libusb's synchronous interface is expressed in terms of function
+ * calls to the asynchronous interface.
+ *
+ * For details on how to use the asynchronous API, see the
+ * \ref libusb_asyncio "asynchronous I/O API" documentation pages.
+ */
+
+/**
+ * \page libusb_packetoverflow Packets and overflows
+ *
+ * \section packets Packet abstraction
+ *
+ * The USB specifications describe how data is transmitted in packets, with
+ * constraints on packet size defined by endpoint descriptors. The host must
+ * not send data payloads larger than the endpoint's maximum packet size.
+ *
+ * libusb and the underlying OS abstract out the packet concept, allowing you
+ * to request transfers of any size. Internally, the request will be divided
+ * up into correctly-sized packets. You do not have to be concerned with
+ * packet sizes, but there is one exception when considering overflows.
+ *
+ * \section overflow Bulk/interrupt transfer overflows
+ *
+ * When requesting data on a bulk endpoint, libusb requires you to supply a
+ * buffer and the maximum number of bytes of data that libusb can put in that
+ * buffer. However, the size of the buffer is not communicated to the device -
+ * the device is just asked to send any amount of data.
+ *
+ * There is no problem if the device sends an amount of data that is less than
+ * or equal to the buffer size. libusb reports this condition to you through
+ * the \ref libusb_transfer::actual_length "libusb_transfer.actual_length"
+ * field.
+ *
+ * Problems may occur if the device attempts to send more data than can fit in
+ * the buffer. libusb reports LIBUSB_TRANSFER_OVERFLOW for this condition but
+ * other behaviour is largely undefined: actual_length may or may not be
+ * accurate, the chunk of data that can fit in the buffer (before overflow)
+ * may or may not have been transferred.
+ *
+ * Overflows are nasty, but can be avoided. Even though you were told to
+ * ignore packets above, think about the lower level details: each transfer is
+ * split into packets (typically small, with a maximum size of 512 bytes).
+ * Overflows can only happen if the final packet in an incoming data transfer
+ * is smaller than the actual packet that the device wants to transfer.
+ * Therefore, you will never see an overflow if your transfer buffer size is a
+ * multiple of the endpoint's packet size: the final packet will either
+ * fill up completely or will be only partially filled.
+ */
+
+/**
+ * @defgroup libusb_asyncio Asynchronous device I/O
+ *
+ * This page details libusb's asynchronous (non-blocking) API for USB device
+ * I/O. This interface is very powerful but is also quite complex - you will
+ * need to read this page carefully to understand the necessary considerations
+ * and issues surrounding use of this interface. Simplistic applications
+ * may wish to consider the \ref libusb_syncio "synchronous I/O API" instead.
+ *
+ * The asynchronous interface is built around the idea of separating transfer
+ * submission and handling of transfer completion (the synchronous model
+ * combines both of these into one). There may be a long delay between
+ * submission and completion, however the asynchronous submission function
+ * is non-blocking so will return control to your application during that
+ * potentially long delay.
+ *
+ * \section asyncabstraction Transfer abstraction
+ *
+ * For the asynchronous I/O, libusb implements the concept of a generic
+ * transfer entity for all types of I/O (control, bulk, interrupt,
+ * isochronous). The generic transfer object must be treated slightly
+ * differently depending on which type of I/O you are performing with it.
+ *
+ * This is represented by the public libusb_transfer structure type.
+ *
+ * \section asynctrf Asynchronous transfers
+ *
+ * We can view asynchronous I/O as a 5 step process:
+ * -# <b>Allocation</b>: allocate a libusb_transfer
+ * -# <b>Filling</b>: populate the libusb_transfer instance with information
+ *    about the transfer you wish to perform
+ * -# <b>Submission</b>: ask libusb to submit the transfer
+ * -# <b>Completion handling</b>: examine transfer results in the
+ *    libusb_transfer structure
+ * -# <b>Deallocation</b>: clean up resources
+ *
+ *
+ * \subsection asyncalloc Allocation
+ *
+ * This step involves allocating memory for a USB transfer. This is the
+ * generic transfer object mentioned above. At this stage, the transfer
+ * is "blank" with no details about what type of I/O it will be used for.
+ *
+ * Allocation is done with the libusb_alloc_transfer() function. You must use
+ * this function rather than allocating your own transfers.
+ *
+ * \subsection asyncfill Filling
+ *
+ * This step is where you take a previously allocated transfer and fill it
+ * with information to determine the message type and direction, data buffer,
+ * callback function, etc.
+ *
+ * You can either fill the required fields yourself or you can use the
+ * helper functions: libusb_fill_control_transfer(), libusb_fill_bulk_transfer()
+ * and libusb_fill_interrupt_transfer().
+ *
+ * \subsection asyncsubmit Submission
+ *
+ * When you have allocated a transfer and filled it, you can submit it using
+ * libusb_submit_transfer(). This function returns immediately but can be
+ * regarded as firing off the I/O request in the background.
+ *
+ * \subsection asynccomplete Completion handling
+ *
+ * After a transfer has been submitted, one of four things can happen to it:
+ *
+ * - The transfer completes (i.e. some data was transferred)
+ * - The transfer has a timeout and the timeout expires before all data is
+ * transferred
+ * - The transfer fails due to an error
+ * - The transfer is cancelled
+ *
+ * Each of these will cause the user-specified transfer callback function to
+ * be invoked. It is up to the callback function to determine which of the
+ * above actually happened and to act accordingly.
+ *
+ * The user-specified callback is passed a pointer to the libusb_transfer
+ * structure which was used to setup and submit the transfer. At completion
+ * time, libusb has populated this structure with results of the transfer:
+ * success or failure reason, number of bytes of data transferred, etc. See
+ * the libusb_transfer structure documentation for more information.
+ *
+ * <b>Important Note</b>: The user-specified callback is called from an event
+ * handling context. It is therefore important that no calls are made into
+ * libusb that will attempt to perform any event handling. Examples of such
+ * functions are any listed in the \ref libusb_syncio "synchronous API" and any of
+ * the blocking functions that retrieve \ref libusb_desc "USB descriptors".
+ *
+ * \subsection Deallocation
+ *
+ * When a transfer has completed (i.e. the callback function has been invoked),
+ * you are advised to free the transfer (unless you wish to resubmit it, see
+ * below). Transfers are deallocated with libusb_free_transfer().
+ *
+ * It is undefined behaviour to free a transfer which has not completed.
+ *
+ * \section asyncresubmit Resubmission
+ *
+ * You may be wondering why allocation, filling, and submission are all
+ * separated above where they could reasonably be combined into a single
+ * operation.
+ *
+ * The reason for separation is to allow you to resubmit transfers without
+ * having to allocate new ones every time. This is especially useful for
+ * common situations dealing with interrupt endpoints - you allocate one
+ * transfer, fill and submit it, and when it returns with results you just
+ * resubmit it for the next interrupt.
+ *
+ * \section asynccancel Cancellation
+ *
+ * Another advantage of using the asynchronous interface is that you have
+ * the ability to cancel transfers which have not yet completed. This is
+ * done by calling the libusb_cancel_transfer() function.
+ *
+ * libusb_cancel_transfer() is asynchronous/non-blocking in itself. When the
+ * cancellation actually completes, the transfer's callback function will
+ * be invoked, and the callback function should check the transfer status to
+ * determine that it was cancelled.
+ *
+ * On macOS and iOS it is not possible to cancel a single transfer. In this
+ * case cancelling one transfer on an endpoint will cause all transfers on
+ * that endpoint to be cancelled.
+ *
+ * Freeing the transfer after it has been cancelled but before cancellation
+ * has completed will result in undefined behaviour.
+ *
+ * \attention
+ * When a transfer is cancelled, some of the data may have been transferred.
+ * libusb will communicate this to you in the transfer callback.
+ * <b>Do not assume that no data was transferred.</b>
+ *
+ * \section asyncpartial Partial data transfer resulting from cancellation
+ *
+ * As noted above, some of the data may have been transferred at the time a
+ * transfer is cancelled. It is helpful to see how this is possible if you
+ * consider a bulk transfer to an endpoint with a packet size of 64 bytes.
+ * Supposing you submit a 512-byte transfer to this endpoint, the operating
+ * system will divide this transfer up into 8 separate 64-byte frames that the
+ * host controller will schedule for the device to transfer data. If this
+ * transfer is cancelled while the device is transferring data, a subset of
+ * these frames may be descheduled from the host controller before the device
+ * has the opportunity to finish transferring data to the host.
+ *
+ * What your application should do with a partial data transfer is a policy
+ * decision; there is no single answer that satisfies the needs of every
+ * application. The data that was successfully transferred should be
+ * considered entirely valid, but your application must decide what to do with
+ * the remaining data that was not transferred. Some possible actions to take
+ * are:
+ * - Resubmit another transfer for the remaining data, possibly with a shorter
+ *   timeout
+ * - Discard the partially transferred data and report an error
+ *
+ * \section asynctimeout Timeouts
+ *
+ * When a transfer times out, libusb internally notes this and attempts to
+ * cancel the transfer. As noted in \ref asyncpartial "above", it is possible
+ * that some of the data may actually have been transferred. Your application
+ * should <b>always</b> check how much data was actually transferred once the
+ * transfer completes and act accordingly.
+ *
+ * \section bulk_overflows Overflows on device-to-host bulk/interrupt endpoints
+ *
+ * If your device does not have predictable transfer sizes (or it misbehaves),
+ * your application may submit a request for data on an IN endpoint which is
+ * smaller than the data that the device wishes to send. In some circumstances
+ * this will cause an overflow, which is a nasty condition to deal with. See
+ * the \ref libusb_packetoverflow page for discussion.
+ *
+ * \section asyncctrl Considerations for control transfers
+ *
+ * The <tt>libusb_transfer</tt> structure is generic and hence does not
+ * include specific fields for the control-specific setup packet structure.
+ *
+ * In order to perform a control transfer, you must place the 8-byte setup
+ * packet at the start of the data buffer. To simplify this, you could
+ * cast the buffer pointer to type struct libusb_control_setup, or you can
+ * use the helper function libusb_fill_control_setup().
+ *
+ * The wLength field placed in the setup packet must be the length you would
+ * expect to be sent in the setup packet: the length of the payload that
+ * follows (or the expected maximum number of bytes to receive). However,
+ * the length field of the libusb_transfer object must be the length of
+ * the data buffer - i.e. it should be wLength <em>plus</em> the size of
+ * the setup packet (LIBUSB_CONTROL_SETUP_SIZE).
+ *
+ * If you use the helper functions, this is simplified for you:
+ * -# Allocate a buffer of size LIBUSB_CONTROL_SETUP_SIZE plus the size of the
+ * data you are sending/requesting.
+ * -# Call libusb_fill_control_setup() on the data buffer, using the transfer
+ * request size as the wLength value (i.e. do not include the extra space you
+ * allocated for the control setup).
+ * -# If this is a host-to-device transfer, place the data to be transferred
+ * in the data buffer, starting at offset LIBUSB_CONTROL_SETUP_SIZE.
+ * -# Call libusb_fill_control_transfer() to associate the data buffer with
+ * the transfer (and to set the remaining details such as callback and timeout).
+ *   - Note that there is no parameter to set the length field of the transfer.
+ *     The length is automatically inferred from the wLength field of the setup
+ *     packet.
+ * -# Submit the transfer.
+ *
+ * The multi-byte control setup fields (wValue, wIndex and wLength) must
+ * be given in little-endian byte order (the endianness of the USB bus).
+ * Endianness conversion is transparently handled by
+ * libusb_fill_control_setup() which is documented to accept host-endian
+ * values.
+ *
+ * Further considerations are needed when handling transfer completion in
+ * your callback function:
+ * - As you might expect, the setup packet will still be sitting at the start
+ * of the data buffer.
+ * - If this was a device-to-host transfer, the received data will be sitting
+ * at offset LIBUSB_CONTROL_SETUP_SIZE into the buffer.
+ * - The actual_length field of the transfer structure is relative to the
+ * wLength of the setup packet, rather than the size of the data buffer. So,
+ * if your wLength was 4, your transfer's <tt>length</tt> was 12, then you
+ * should expect an <tt>actual_length</tt> of 4 to indicate that the data was
+ * transferred in entirety.
+ *
+ * To simplify parsing of setup packets and obtaining the data from the
+ * correct offset, you may wish to use the libusb_control_transfer_get_data()
+ * and libusb_control_transfer_get_setup() functions within your transfer
+ * callback.
+ *
+ * Even though control endpoints do not halt, a completed control transfer
+ * may have a LIBUSB_TRANSFER_STALL status code. This indicates the control
+ * request was not supported.
+ *
+ * \section asyncintr Considerations for interrupt transfers
+ *
+ * All interrupt transfers are performed using the polling interval presented
+ * by the bInterval value of the endpoint descriptor.
+ *
+ * \section asynciso Considerations for isochronous transfers
+ *
+ * Isochronous transfers are more complicated than transfers to
+ * non-isochronous endpoints.
+ *
+ * To perform I/O to an isochronous endpoint, allocate the transfer by calling
+ * libusb_alloc_transfer() with an appropriate number of isochronous packets.
+ *
+ * During filling, set \ref libusb_transfer::type "type" to
+ * \ref libusb_transfer_type::LIBUSB_TRANSFER_TYPE_ISOCHRONOUS
+ * "LIBUSB_TRANSFER_TYPE_ISOCHRONOUS", and set
+ * \ref libusb_transfer::num_iso_packets "num_iso_packets" to a value less than
+ * or equal to the number of packets you requested during allocation.
+ * libusb_alloc_transfer() does not set either of these fields for you, given
+ * that you might not even use the transfer on an isochronous endpoint.
+ *
+ * Next, populate the length field for the first num_iso_packets entries in
+ * the \ref libusb_transfer::iso_packet_desc "iso_packet_desc" array. Section
+ * 5.6.3 of the USB2 specifications describe how the maximum isochronous
+ * packet length is determined by the wMaxPacketSize field in the endpoint
+ * descriptor.
+ * Two functions can help you here:
+ *
+ * - libusb_get_max_iso_packet_size() is an easy way to determine the max
+ *   packet size for an isochronous endpoint. Note that the maximum packet
+ *   size is actually the maximum number of bytes that can be transmitted in
+ *   a single microframe, therefore this function multiplies the maximum number
+ *   of bytes per transaction by the number of transaction opportunities per
+ *   microframe.
+ * - libusb_set_iso_packet_lengths() assigns the same length to all packets
+ *   within a transfer, which is usually what you want.
+ *
+ * For outgoing transfers, you'll obviously fill the buffer and populate the
+ * packet descriptors in hope that all the data gets transferred. For incoming
+ * transfers, you must ensure the buffer has sufficient capacity for
+ * the situation where all packets transfer the full amount of requested data.
+ *
+ * Completion handling requires some extra consideration. The
+ * \ref libusb_transfer::actual_length "actual_length" field of the transfer
+ * is meaningless and should not be examined; instead you must refer to the
+ * \ref libusb_iso_packet_descriptor::actual_length "actual_length" field of
+ * each individual packet.
+ *
+ * The \ref libusb_transfer::status "status" field of the transfer is also a
+ * little misleading:
+ *  - If the packets were submitted and the isochronous data microframes
+ *    completed normally, status will have value
+ *    \ref libusb_transfer_status::LIBUSB_TRANSFER_COMPLETED
+ *    "LIBUSB_TRANSFER_COMPLETED". Note that bus errors and software-incurred
+ *    delays are not counted as transfer errors; the transfer.status field may
+ *    indicate COMPLETED even if some or all of the packets failed. Refer to
+ *    the \ref libusb_iso_packet_descriptor::status "status" field of each
+ *    individual packet to determine packet failures.
+ *  - The status field will have value
+ *    \ref libusb_transfer_status::LIBUSB_TRANSFER_ERROR
+ *    "LIBUSB_TRANSFER_ERROR" only when serious errors were encountered.
+ *  - Other transfer status codes occur with normal behaviour.
+ *
+ * The data for each packet will be found at an offset into the buffer that
+ * can be calculated as if each prior packet completed in full. The
+ * libusb_get_iso_packet_buffer() and libusb_get_iso_packet_buffer_simple()
+ * functions may help you here.
+ *
+ * \section asynclimits Transfer length limitations
+ *
+ * Some operating systems may impose limits on the length of the transfer data
+ * buffer or, in the case of isochronous transfers, the length of individual
+ * isochronous packets. Such limits can be difficult for libusb to detect, so
+ * in most cases the library will simply try and submit the transfer as set up
+ * by you. If the transfer fails to submit because it is too large,
+ * libusb_submit_transfer() will return
+ * \ref libusb_error::LIBUSB_ERROR_INVALID_PARAM "LIBUSB_ERROR_INVALID_PARAM".
+ *
+ * The following are known limits for control transfer lengths. Note that this
+ * length includes the 8-byte setup packet.
+ * - Linux (4,096 bytes)
+ * - Windows (4,096 bytes)
+ *
+ * \section asyncmem Memory caveats
+ *
+ * In most circumstances, it is not safe to use stack memory for transfer
+ * buffers. This is because the function that fired off the asynchronous
+ * transfer may return before libusb has finished using the buffer, and when
+ * the function returns it's stack gets destroyed. This is true for both
+ * host-to-device and device-to-host transfers.
+ *
+ * The only case in which it is safe to use stack memory is where you can
+ * guarantee that the function owning the stack space for the buffer does not
+ * return until after the transfer's callback function has completed. In every
+ * other case, you need to use heap memory instead.
+ *
+ * \section asyncflags Fine control
+ *
+ * Through using this asynchronous interface, you may find yourself repeating
+ * a few simple operations many times. You can apply a bitwise OR of certain
+ * flags to a transfer to simplify certain things:
+ * - \ref libusb_transfer_flags::LIBUSB_TRANSFER_SHORT_NOT_OK
+ *   "LIBUSB_TRANSFER_SHORT_NOT_OK" results in transfers which transferred
+ *   less than the requested amount of data being marked with status
+ *   \ref libusb_transfer_status::LIBUSB_TRANSFER_ERROR "LIBUSB_TRANSFER_ERROR"
+ *   (they would normally be regarded as COMPLETED)
+ * - \ref libusb_transfer_flags::LIBUSB_TRANSFER_FREE_BUFFER
+ *   "LIBUSB_TRANSFER_FREE_BUFFER" allows you to ask libusb to free the transfer
+ *   buffer when freeing the transfer.
+ * - \ref libusb_transfer_flags::LIBUSB_TRANSFER_FREE_TRANSFER
+ *   "LIBUSB_TRANSFER_FREE_TRANSFER" causes libusb to automatically free the
+ *   transfer after the transfer callback returns.
+ *
+ * \section asyncevent Event handling
+ *
+ * An asynchronous model requires that libusb perform work at various
+ * points in time - namely processing the results of previously-submitted
+ * transfers and invoking the user-supplied callback function.
+ *
+ * This gives rise to the libusb_handle_events() function which your
+ * application must call into when libusb has work do to. This gives libusb
+ * the opportunity to reap pending transfers, invoke callbacks, etc.
+ *
+ * \note
+ * All event handling is performed by whichever thread calls the
+ * libusb_handle_events() function. libusb does not invoke any callbacks
+ * outside of this context. Consequently, any callbacks will be run on the
+ * thread that calls the libusb_handle_events() function.
+ *
+ * When to call the libusb_handle_events() function depends on which model
+ * your application decides to use. The 2 different approaches:
+ *
+ * -# Repeatedly call libusb_handle_events() in blocking mode from a dedicated
+ *    thread.
+ * -# Integrate libusb with your application's main event loop. libusb
+ *    exposes a set of file descriptors which allow you to do this.
+ *
+ * The first approach has the big advantage that it will also work on Windows
+ * were libusb' poll API for select / poll integration is not available. So
+ * if you want to support Windows and use the async API, you must use this
+ * approach, see the \ref eventthread "Using an event handling thread" section
+ * below for details.
+ *
+ * If you prefer a single threaded approach with a single central event loop,
+ * see the \ref libusb_poll "polling and timing" section for how to integrate libusb
+ * into your application's main event loop.
+ *
+ * \section eventthread Using an event handling thread
+ *
+ * Lets begin with stating the obvious: If you're going to use a separate
+ * thread for libusb event handling, your callback functions MUST be
+ * thread-safe.
+ *
+ * Other then that doing event handling from a separate thread, is mostly
+ * simple. You can use an event thread function as follows:
+\code
+void *event_thread_func(void *ctx)
+{
+    while (event_thread_run)
+        libusb_handle_events(ctx);
+
+    return NULL;
+}
+\endcode
+ *
+ * There is one caveat though, stopping this thread requires setting the
+ * event_thread_run variable to 0, and after that libusb_handle_events() needs
+ * to return control to event_thread_func. But unless some event happens,
+ * libusb_handle_events() will not return.
+ *
+ * There are 2 different ways of dealing with this, depending on if your
+ * application uses libusb' \ref libusb_hotplug "hotplug" support or not.
+ *
+ * Applications which do not use hotplug support, should not start the event
+ * thread until after their first call to libusb_open(), and should stop the
+ * thread when closing the last open device as follows:
+\code
+void my_close_handle(libusb_device_handle *dev_handle)
+{
+    if (open_devs == 1)
+        event_thread_run = 0;
+
+    libusb_close(dev_handle); // This wakes up libusb_handle_events()
+
+    if (open_devs == 1)
+        pthread_join(event_thread);
+
+    open_devs--;
+}
+\endcode
+ *
+ * Applications using hotplug support should start the thread at program init,
+ * after having successfully called libusb_hotplug_register_callback(), and
+ * should stop the thread at program exit as follows:
+\code
+void my_libusb_exit(void)
+{
+    event_thread_run = 0;
+    libusb_hotplug_deregister_callback(ctx, hotplug_cb_handle); // This wakes up libusb_handle_events()
+    pthread_join(event_thread);
+    libusb_exit(ctx);
+}
+\endcode
+ */
+
+/**
+ * @defgroup libusb_poll Polling and timing
+ *
+ * This page documents libusb's functions for polling events and timing.
+ * These functions are only necessary for users of the
+ * \ref libusb_asyncio "asynchronous API". If you are only using the simpler
+ * \ref libusb_syncio "synchronous API" then you do not need to ever call these
+ * functions.
+ *
+ * The justification for the functionality described here has already been
+ * discussed in the \ref asyncevent "event handling" section of the
+ * asynchronous API documentation. In summary, libusb does not create internal
+ * threads for event processing and hence relies on your application calling
+ * into libusb at certain points in time so that pending events can be handled.
+ *
+ * Your main loop is probably already calling poll() or select() or a
+ * variant on a set of file descriptors for other event sources (e.g. keyboard
+ * button presses, mouse movements, network sockets, etc). You then add
+ * libusb's file descriptors to your poll()/select() calls, and when activity
+ * is detected on such descriptors you know it is time to call
+ * libusb_handle_events().
+ *
+ * There is one final event handling complication. libusb supports
+ * asynchronous transfers which time out after a specified time period.
+ *
+ * On some platforms a timerfd is used, so the timeout handling is just another
+ * fd, on other platforms this requires that libusb is called into at or after
+ * the timeout to handle it. So, in addition to considering libusb's file
+ * descriptors in your main event loop, you must also consider that libusb
+ * sometimes needs to be called into at fixed points in time even when there
+ * is no file descriptor activity, see \ref polltime details.
+ *
+ * In order to know precisely when libusb needs to be called into, libusb
+ * offers you a set of pollable file descriptors and information about when
+ * the next timeout expires.
+ *
+ * If you are using the asynchronous I/O API, you must take one of the two
+ * following options, otherwise your I/O will not complete.
+ *
+ * \section pollsimple The simple option
+ *
+ * If your application revolves solely around libusb and does not need to
+ * handle other event sources, you can have a program structure as follows:
+\code
+// initialize libusb
+// find and open device
+// maybe fire off some initial async I/O
+
+while (user_has_not_requested_exit)
+    libusb_handle_events(ctx);
+
+// clean up and exit
+\endcode
+ *
+ * With such a simple main loop, you do not have to worry about managing
+ * sets of file descriptors or handling timeouts. libusb_handle_events() will
+ * handle those details internally.
+ *
+ * \section libusb_pollmain The more advanced option
+ *
+ * \note This functionality is currently only available on Unix-like platforms.
+ * On Windows, libusb_get_pollfds() simply returns NULL. Applications which
+ * want to support Windows are advised to use an \ref eventthread
+ * "event handling thread" instead.
+ *
+ * In more advanced applications, you will already have a main loop which
+ * is monitoring other event sources: network sockets, X11 events, mouse
+ * movements, etc. Through exposing a set of file descriptors, libusb is
+ * designed to cleanly integrate into such main loops.
+ *
+ * In addition to polling file descriptors for the other event sources, you
+ * take a set of file descriptors from libusb and monitor those too. When you
+ * detect activity on libusb's file descriptors, you call
+ * libusb_handle_events_timeout() in non-blocking mode.
+ *
+ * What's more, libusb may also need to handle events at specific moments in
+ * time. No file descriptor activity is generated at these times, so your
+ * own application needs to be continually aware of when the next one of these
+ * moments occurs (through calling libusb_get_next_timeout()), and then it
+ * needs to call libusb_handle_events_timeout() in non-blocking mode when
+ * these moments occur. This means that you need to adjust your
+ * poll()/select() timeout accordingly.
+ *
+ * libusb provides you with a set of file descriptors to poll and expects you
+ * to poll all of them, treating them as a single entity. The meaning of each
+ * file descriptor in the set is an internal implementation detail,
+ * platform-dependent and may vary from release to release. Don't try and
+ * interpret the meaning of the file descriptors, just do as libusb indicates,
+ * polling all of them at once.
+ *
+ * In pseudo-code, you want something that looks like:
+\code
+// initialise libusb
+
+libusb_get_pollfds(ctx)
+while (user has not requested application exit) {
+    libusb_get_next_timeout(ctx);
+    poll(on libusb file descriptors plus any other event sources of interest,
+        using a timeout no larger than the value libusb just suggested)
+    if (poll() indicated activity on libusb file descriptors)
+        libusb_handle_events_timeout(ctx, &zero_tv);
+    if (time has elapsed to or beyond the libusb timeout)
+        libusb_handle_events_timeout(ctx, &zero_tv);
+    // handle events from other sources here
+}
+
+// clean up and exit
+\endcode
+ *
+ * \subsection polltime Notes on time-based events
+ *
+ * The above complication with having to track time and call into libusb at
+ * specific moments is a bit of a headache. For maximum compatibility, you do
+ * need to write your main loop as above, but you may decide that you can
+ * restrict the supported platforms of your application and get away with
+ * a more simplistic scheme.
+ *
+ * These time-based event complications are \b not required on the following
+ * platforms:
+ *  - Darwin
+ *  - Linux, provided that the following version requirements are satisfied:
+ *   - Linux v2.6.27 or newer, compiled with timerfd support
+ *   - glibc v2.9 or newer
+ *   - libusb v1.0.5 or newer
+ *
+ * Under these configurations, libusb_get_next_timeout() will \em always return
+ * 0, so your main loop can be simplified to:
+\code
+// initialise libusb
+
+libusb_get_pollfds(ctx)
+while (user has not requested application exit) {
+    poll(on libusb file descriptors plus any other event sources of interest,
+        using any timeout that you like)
+    if (poll() indicated activity on libusb file descriptors)
+        libusb_handle_events_timeout(ctx, &zero_tv);
+    // handle events from other sources here
+}
+
+// clean up and exit
+\endcode
+ *
+ * Do remember that if you simplify your main loop to the above, you will
+ * lose compatibility with some platforms (including legacy Linux platforms,
+ * and <em>any future platforms supported by libusb which may have time-based
+ * event requirements</em>). The resultant problems will likely appear as
+ * strange bugs in your application.
+ *
+ * You can use the libusb_pollfds_handle_timeouts() function to do a runtime
+ * check to see if it is safe to ignore the time-based event complications.
+ * If your application has taken the shortcut of ignoring libusb's next timeout
+ * in your main loop, then you are advised to check the return value of
+ * libusb_pollfds_handle_timeouts() during application startup, and to abort
+ * if the platform does suffer from these timing complications.
+ *
+ * \subsection fdsetchange Changes in the file descriptor set
+ *
+ * The set of file descriptors that libusb uses as event sources may change
+ * during the life of your application. Rather than having to repeatedly
+ * call libusb_get_pollfds(), you can set up notification functions for when
+ * the file descriptor set changes using libusb_set_pollfd_notifiers().
+ *
+ * \subsection mtissues Multi-threaded considerations
+ *
+ * Unfortunately, the situation is complicated further when multiple threads
+ * come into play. If two threads are monitoring the same file descriptors,
+ * the fact that only one thread will be woken up when an event occurs causes
+ * some headaches.
+ *
+ * The events lock, event waiters lock, and libusb_handle_events_locked()
+ * entities are added to solve these problems. You do not need to be concerned
+ * with these entities otherwise.
+ *
+ * See the extra documentation: \ref libusb_mtasync
+ */
+
+/** \page libusb_mtasync Multi-threaded applications and asynchronous I/O
+ *
+ * libusb is a thread-safe library, but extra considerations must be applied
+ * to applications which interact with libusb from multiple threads.
+ *
+ * The underlying issue that must be addressed is that all libusb I/O
+ * revolves around monitoring file descriptors through the poll()/select()
+ * system calls. This is directly exposed at the
+ * \ref libusb_asyncio "asynchronous interface" but it is important to note that the
+ * \ref libusb_syncio "synchronous interface" is implemented on top of the
+ * asynchronous interface, therefore the same considerations apply.
+ *
+ * The issue is that if two or more threads are concurrently calling poll()
+ * or select() on libusb's file descriptors then only one of those threads
+ * will be woken up when an event arrives. The others will be completely
+ * oblivious that anything has happened.
+ *
+ * Consider the following pseudo-code, which submits an asynchronous transfer
+ * then waits for its completion. This style is one way you could implement a
+ * synchronous interface on top of the asynchronous interface (and libusb
+ * does something similar, albeit more advanced due to the complications
+ * explained on this page).
+ *
+\code
+void cb(struct libusb_transfer *transfer)
+{
+    int *completed = transfer->user_data;
+    *completed = 1;
+}
+
+void myfunc() {
+    struct libusb_transfer *transfer;
+    unsigned char buffer[LIBUSB_CONTROL_SETUP_SIZE] __attribute__ ((aligned (2)));
+    int completed = 0;
+
+    transfer = libusb_alloc_transfer(0);
+    libusb_fill_control_setup(buffer,
+        LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_ENDPOINT_OUT, 0x04, 0x01, 0, 0);
+    libusb_fill_control_transfer(transfer, dev, buffer, cb, &completed, 1000);
+    libusb_submit_transfer(transfer);
+
+    while (!completed) {
+        poll(libusb file descriptors, 120*1000);
+        if (poll indicates activity)
+            libusb_handle_events_timeout(ctx, &zero_tv);
+    }
+    printf("completed!");
+    // other code here
+}
+\endcode
+ *
+ * Here we are <em>serializing</em> completion of an asynchronous event
+ * against a condition - the condition being completion of a specific transfer.
+ * The poll() loop has a long timeout to minimize CPU usage during situations
+ * when nothing is happening (it could reasonably be unlimited).
+ *
+ * If this is the only thread that is polling libusb's file descriptors, there
+ * is no problem: there is no danger that another thread will swallow up the
+ * event that we are interested in. On the other hand, if there is another
+ * thread polling the same descriptors, there is a chance that it will receive
+ * the event that we were interested in. In this situation, <tt>myfunc()</tt>
+ * will only realise that the transfer has completed on the next iteration of
+ * the loop, <em>up to 120 seconds later.</em> Clearly a two-minute delay is
+ * undesirable, and don't even think about using short timeouts to circumvent
+ * this issue!
+ *
+ * The solution here is to ensure that no two threads are ever polling the
+ * file descriptors at the same time. A naive implementation of this would
+ * impact the capabilities of the library, so libusb offers the scheme
+ * documented below to ensure no loss of functionality.
+ *
+ * Before we go any further, it is worth mentioning that all libusb-wrapped
+ * event handling procedures fully adhere to the scheme documented below.
+ * This includes libusb_handle_events() and its variants, and all the
+ * synchronous I/O functions - libusb hides this headache from you.
+ *
+ * \section Using libusb_handle_events() from multiple threads
+ *
+ * Even when only using libusb_handle_events() and synchronous I/O functions,
+ * you can still have a race condition. You might be tempted to solve the
+ * above with libusb_handle_events() like so:
+ *
+\code
+    libusb_submit_transfer(transfer);
+
+    while (!completed) {
+        libusb_handle_events(ctx);
+    }
+    printf("completed!");
+\endcode
+ *
+ * This however has a race between the checking of completed and
+ * libusb_handle_events() acquiring the events lock, so another thread
+ * could have completed the transfer, resulting in this thread hanging
+ * until either a timeout or another event occurs. See also commit
+ * 6696512aade99bb15d6792af90ae329af270eba6 which fixes this in the
+ * synchronous API implementation of libusb.
+ *
+ * Fixing this race requires checking the variable completed only after
+ * taking the event lock, which defeats the concept of just calling
+ * libusb_handle_events() without worrying about locking. This is why
+ * libusb-1.0.9 introduces the new libusb_handle_events_timeout_completed()
+ * and libusb_handle_events_completed() functions, which handles doing the
+ * completion check for you after they have acquired the lock:
+ *
+\code
+    libusb_submit_transfer(transfer);
+
+    while (!completed) {
+        libusb_handle_events_completed(ctx, &completed);
+    }
+    printf("completed!");
+\endcode
+ *
+ * This nicely fixes the race in our example. Note that if all you want to
+ * do is submit a single transfer and wait for its completion, then using
+ * one of the synchronous I/O functions is much easier.
+ *
+ * \note
+ * The `completed` variable must be modified while holding the event lock,
+ * otherwise a race condition can still exist. It is simplest to do so from
+ * within the transfer callback as shown above.
+ *
+ * \section eventlock The events lock
+ *
+ * The problem is when we consider the fact that libusb exposes file
+ * descriptors to allow for you to integrate asynchronous USB I/O into
+ * existing main loops, effectively allowing you to do some work behind
+ * libusb's back. If you do take libusb's file descriptors and pass them to
+ * poll()/select() yourself, you need to be aware of the associated issues.
+ *
+ * The first concept to be introduced is the events lock. The events lock
+ * is used to serialize threads that want to handle events, such that only
+ * one thread is handling events at any one time.
+ *
+ * You must take the events lock before polling libusb file descriptors,
+ * using libusb_lock_events(). You must release the lock as soon as you have
+ * aborted your poll()/select() loop, using libusb_unlock_events().
+ *
+ * \section threadwait Letting other threads do the work for you
+ *
+ * Although the events lock is a critical part of the solution, it is not
+ * enough on it's own. You might wonder if the following is sufficient...
+\code
+    libusb_lock_events(ctx);
+    while (!completed) {
+        poll(libusb file descriptors, 120*1000);
+        if (poll indicates activity)
+            libusb_handle_events_timeout(ctx, &zero_tv);
+    }
+    libusb_unlock_events(ctx);
+\endcode
+ * ...and the answer is that it is not. This is because the transfer in the
+ * code shown above may take a long time (say 30 seconds) to complete, and
+ * the lock is not released until the transfer is completed.
+ *
+ * Another thread with similar code that wants to do event handling may be
+ * working with a transfer that completes after a few milliseconds. Despite
+ * having such a quick completion time, the other thread cannot check that
+ * status of its transfer until the code above has finished (30 seconds later)
+ * due to contention on the lock.
+ *
+ * To solve this, libusb offers you a mechanism to determine when another
+ * thread is handling events. It also offers a mechanism to block your thread
+ * until the event handling thread has completed an event (and this mechanism
+ * does not involve polling of file descriptors).
+ *
+ * After determining that another thread is currently handling events, you
+ * obtain the <em>event waiters</em> lock using libusb_lock_event_waiters().
+ * You then re-check that some other thread is still handling events, and if
+ * so, you call libusb_wait_for_event().
+ *
+ * libusb_wait_for_event() puts your application to sleep until an event
+ * occurs, or until a thread releases the events lock. When either of these
+ * things happen, your thread is woken up, and should re-check the condition
+ * it was waiting on. It should also re-check that another thread is handling
+ * events, and if not, it should start handling events itself.
+ *
+ * This looks like the following, as pseudo-code:
+\code
+retry:
+if (libusb_try_lock_events(ctx) == 0) {
+    // we obtained the event lock: do our own event handling
+    while (!completed) {
+        if (!libusb_event_handling_ok(ctx)) {
+            libusb_unlock_events(ctx);
+            goto retry;
+        }
+        poll(libusb file descriptors, 120*1000);
+        if (poll indicates activity)
+            libusb_handle_events_locked(ctx, 0);
+    }
+    libusb_unlock_events(ctx);
+} else {
+    // another thread is doing event handling. wait for it to signal us that
+    // an event has completed
+    libusb_lock_event_waiters(ctx);
+
+    while (!completed) {
+        // now that we have the event waiters lock, double check that another
+        // thread is still handling events for us. (it may have ceased handling
+        // events in the time it took us to reach this point)
+        if (!libusb_event_handler_active(ctx)) {
+            // whoever was handling events is no longer doing so, try again
+            libusb_unlock_event_waiters(ctx);
+            goto retry;
+        }
+
+        libusb_wait_for_event(ctx, NULL);
+    }
+    libusb_unlock_event_waiters(ctx);
+}
+printf("completed!\n");
+\endcode
+ *
+ * A naive look at the above code may suggest that this can only support
+ * one event waiter (hence a total of 2 competing threads, the other doing
+ * event handling), because the event waiter seems to have taken the event
+ * waiters lock while waiting for an event. However, the system does support
+ * multiple event waiters, because libusb_wait_for_event() actually drops
+ * the lock while waiting, and reacquires it before continuing.
+ *
+ * We have now implemented code which can dynamically handle situations where
+ * nobody is handling events (so we should do it ourselves), and it can also
+ * handle situations where another thread is doing event handling (so we can
+ * piggyback onto them). It is also equipped to handle a combination of
+ * the two, for example, another thread is doing event handling, but for
+ * whatever reason it stops doing so before our condition is met, so we take
+ * over the event handling.
+ *
+ * Four functions were introduced in the above pseudo-code. Their importance
+ * should be apparent from the code shown above.
+ * -# libusb_try_lock_events() is a non-blocking function which attempts
+ *    to acquire the events lock but returns a failure code if it is contended.
+ * -# libusb_event_handling_ok() checks that libusb is still happy for your
+ *    thread to be performing event handling. Sometimes, libusb needs to
+ *    interrupt the event handler, and this is how you can check if you have
+ *    been interrupted. If this function returns 0, the correct behaviour is
+ *    for you to give up the event handling lock, and then to repeat the cycle.
+ *    The following libusb_try_lock_events() will fail, so you will become an
+ *    events waiter. For more information on this, read \ref fullstory below.
+ * -# libusb_handle_events_locked() is a variant of
+ *    libusb_handle_events_timeout() that you can call while holding the
+ *    events lock. libusb_handle_events_timeout() itself implements similar
+ *    logic to the above, so be sure not to call it when you are
+ *    "working behind libusb's back", as is the case here.
+ * -# libusb_event_handler_active() determines if someone is currently
+ *    holding the events lock
+ *
+ * You might be wondering why there is no function to wake up all threads
+ * blocked on libusb_wait_for_event(). This is because libusb can do this
+ * internally: it will wake up all such threads when someone calls
+ * libusb_unlock_events() or when a transfer completes (at the point after its
+ * callback has returned).
+ *
+ * \subsection fullstory The full story
+ *
+ * The above explanation should be enough to get you going, but if you're
+ * really thinking through the issues then you may be left with some more
+ * questions regarding libusb's internals. If you're curious, read on, and if
+ * not, skip to the next section to avoid confusing yourself!
+ *
+ * The immediate question that may spring to mind is: what if one thread
+ * modifies the set of file descriptors that need to be polled while another
+ * thread is doing event handling?
+ *
+ * There are 2 situations in which this may happen.
+ * -# libusb_open() will add another file descriptor to the poll set,
+ *    therefore it is desirable to interrupt the event handler so that it
+ *    restarts, picking up the new descriptor.
+ * -# libusb_close() will remove a file descriptor from the poll set. There
+ *    are all kinds of race conditions that could arise here, so it is
+ *    important that nobody is doing event handling at this time.
+ *
+ * libusb handles these issues internally, so application developers do not
+ * have to stop their event handlers while opening/closing devices. Here's how
+ * it works, focusing on the libusb_close() situation first:
+ *
+ * -# During initialization, libusb opens an internal pipe, and it adds the read
+ *    end of this pipe to the set of file descriptors to be polled.
+ * -# During libusb_close(), libusb writes some dummy data on this event pipe.
+ *    This immediately interrupts the event handler. libusb also records
+ *    internally that it is trying to interrupt event handlers for this
+ *    high-priority event.
+ * -# At this point, some of the functions described above start behaving
+ *    differently:
+ *   - libusb_event_handling_ok() starts returning 1, indicating that it is NOT
+ *     OK for event handling to continue.
+ *   - libusb_try_lock_events() starts returning 1, indicating that another
+ *     thread holds the event handling lock, even if the lock is uncontended.
+ *   - libusb_event_handler_active() starts returning 1, indicating that
+ *     another thread is doing event handling, even if that is not true.
+ * -# The above changes in behaviour result in the event handler stopping and
+ *    giving up the events lock very quickly, giving the high-priority
+ *    libusb_close() operation a "free ride" to acquire the events lock. All
+ *    threads that are competing to do event handling become event waiters.
+ * -# With the events lock held inside libusb_close(), libusb can safely remove
+ *    a file descriptor from the poll set, in the safety of knowledge that
+ *    nobody is polling those descriptors or trying to access the poll set.
+ * -# After obtaining the events lock, the close operation completes very
+ *    quickly (usually a matter of milliseconds) and then immediately releases
+ *    the events lock.
+ * -# At the same time, the behaviour of libusb_event_handling_ok() and friends
+ *    reverts to the original, documented behaviour.
+ * -# The release of the events lock causes the threads that are waiting for
+ *    events to be woken up and to start competing to become event handlers
+ *    again. One of them will succeed; it will then re-obtain the list of poll
+ *    descriptors, and USB I/O will then continue as normal.
+ *
+ * libusb_open() is similar, and is actually a more simplistic case. Upon a
+ * call to libusb_open():
+ *
+ * -# The device is opened and a file descriptor is added to the poll set.
+ * -# libusb sends some dummy data on the event pipe, and records that it
+ *    is trying to modify the poll descriptor set.
+ * -# The event handler is interrupted, and the same behaviour change as for
+ *    libusb_close() takes effect, causing all event handling threads to become
+ *    event waiters.
+ * -# The libusb_open() implementation takes its free ride to the events lock.
+ * -# Happy that it has successfully paused the events handler, libusb_open()
+ *    releases the events lock.
+ * -# The event waiter threads are all woken up and compete to become event
+ *    handlers again. The one that succeeds will obtain the list of poll
+ *    descriptors again, which will include the addition of the new device.
+ *
+ * \subsection concl Closing remarks
+ *
+ * The above may seem a little complicated, but hopefully I have made it clear
+ * why such complications are necessary. Also, do not forget that this only
+ * applies to applications that take libusb's file descriptors and integrate
+ * them into their own polling loops.
+ *
+ * You may decide that it is OK for your multi-threaded application to ignore
+ * some of the rules and locks detailed above, because you don't think that
+ * two threads can ever be polling the descriptors at the same time. If that
+ * is the case, then that's good news for you because you don't have to worry.
+ * But be careful here; remember that the synchronous I/O functions do event
+ * handling internally. If you have one thread doing event handling in a loop
+ * (without implementing the rules and locking semantics documented above)
+ * and another trying to send a synchronous USB transfer, you will end up with
+ * two threads monitoring the same descriptors, and the above-described
+ * undesirable behaviour occurring. The solution is for your polling thread to
+ * play by the rules; the synchronous I/O functions do so, and this will result
+ * in them getting along in perfect harmony.
+ *
+ * If you do have a dedicated thread doing event handling, it is perfectly
+ * legal for it to take the event handling lock for long periods of time. Any
+ * synchronous I/O functions you call from other threads will transparently
+ * fall back to the "event waiters" mechanism detailed above. The only
+ * consideration that your event handling thread must apply is the one related
+ * to libusb_event_handling_ok(): you must call this before every poll(), and
+ * give up the events lock if instructed.
+ */
+
+int usbi_io_init(struct libusb_context *ctx) {
+    int r;
+
+    usbi_mutex_init(&ctx->flying_transfers_lock);
+    usbi_mutex_init(&ctx->events_lock);
+    usbi_mutex_init(&ctx->event_waiters_lock);
+    usbi_cond_init(&ctx->event_waiters_cond);
+    usbi_mutex_init(&ctx->event_data_lock);
+    usbi_tls_key_create(&ctx->event_handling_key);
+    list_init(&ctx->flying_transfers);
+    list_init(&ctx->event_sources);
+    list_init(&ctx->removed_event_sources);
+    list_init(&ctx->hotplug_msgs);
+    list_init(&ctx->completed_transfers);
+
+    r = usbi_create_event(&ctx->event);
+    if(r < 0)
+        goto err;
+
+    r = usbi_add_event_source(ctx, USBI_EVENT_OS_HANDLE(&ctx->event), USBI_EVENT_POLL_EVENTS);
+    if(r < 0)
+        goto err_destroy_event;
+
+#ifdef HAVE_OS_TIMER
+    r = usbi_create_timer(&ctx->timer);
+    if(r == 0) {
+        usbi_dbg(ctx, "using timer for timeouts");
+        r = usbi_add_event_source(ctx, USBI_TIMER_OS_HANDLE(&ctx->timer), USBI_TIMER_POLL_EVENTS);
+        if(r < 0)
+            goto err_destroy_timer;
+    }
+    else {
+        usbi_dbg(ctx, "timer not available for timeouts");
+    }
+#endif
+
+    return 0;
+
+#ifdef HAVE_OS_TIMER
+err_destroy_timer:
+    usbi_destroy_timer(&ctx->timer);
+    usbi_remove_event_source(ctx, USBI_EVENT_OS_HANDLE(&ctx->event));
+#endif
+err_destroy_event:
+    usbi_destroy_event(&ctx->event);
+err:
+    usbi_mutex_destroy(&ctx->flying_transfers_lock);
+    usbi_mutex_destroy(&ctx->events_lock);
+    usbi_mutex_destroy(&ctx->event_waiters_lock);
+    usbi_cond_destroy(&ctx->event_waiters_cond);
+    usbi_mutex_destroy(&ctx->event_data_lock);
+    usbi_tls_key_delete(ctx->event_handling_key);
+    return r;
+}
+
+static void cleanup_removed_event_sources(struct libusb_context *ctx) {
+    struct usbi_event_source *ievent_source, *tmp;
+
+    for_each_removed_event_source_safe(ctx, ievent_source, tmp) {
+        list_del(&ievent_source->list);
+        free(ievent_source);
+    }
+}
+
+void usbi_io_exit(struct libusb_context *ctx) {
+#ifdef HAVE_OS_TIMER
+    if(usbi_using_timer(ctx)) {
+        usbi_remove_event_source(ctx, USBI_TIMER_OS_HANDLE(&ctx->timer));
+        usbi_destroy_timer(&ctx->timer);
+    }
+#endif
+    usbi_remove_event_source(ctx, USBI_EVENT_OS_HANDLE(&ctx->event));
+    usbi_destroy_event(&ctx->event);
+    usbi_mutex_destroy(&ctx->flying_transfers_lock);
+    usbi_mutex_destroy(&ctx->events_lock);
+    usbi_mutex_destroy(&ctx->event_waiters_lock);
+    usbi_cond_destroy(&ctx->event_waiters_cond);
+    usbi_mutex_destroy(&ctx->event_data_lock);
+    usbi_tls_key_delete(ctx->event_handling_key);
+    cleanup_removed_event_sources(ctx);
+    free(ctx->event_data);
+}
+
+static void calculate_timeout(struct usbi_transfer *itransfer) {
+    unsigned int timeout = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer)->timeout;
+
+    if(!timeout) {
+        TIMESPEC_CLEAR(&itransfer->timeout);
+        return;
+    }
+
+    usbi_get_monotonic_time(&itransfer->timeout);
+
+    itransfer->timeout.tv_sec += timeout / 1000U;
+    itransfer->timeout.tv_nsec += (timeout % 1000U) * 1000000L;
+    if(itransfer->timeout.tv_nsec >= NSEC_PER_SEC) {
+        ++itransfer->timeout.tv_sec;
+        itransfer->timeout.tv_nsec -= NSEC_PER_SEC;
+    }
+}
+
+/** \ingroup libusb_asyncio
+ * Allocate a libusb transfer with a specified number of isochronous packet
+ * descriptors. The returned transfer is pre-initialized for you. When the new
+ * transfer is no longer needed, it should be freed with
+ * libusb_free_transfer().
+ *
+ * Transfers intended for non-isochronous endpoints (e.g. control, bulk,
+ * interrupt) should specify an iso_packets count of zero.
+ *
+ * For transfers intended for isochronous endpoints, specify an appropriate
+ * number of packet descriptors to be allocated as part of the transfer.
+ * The returned transfer is not specially initialized for isochronous I/O;
+ * you are still required to set the
+ * \ref libusb_transfer::num_iso_packets "num_iso_packets" and
+ * \ref libusb_transfer::type "type" fields accordingly.
+ *
+ * It is safe to allocate a transfer with some isochronous packets and then
+ * use it on a non-isochronous endpoint. If you do this, ensure that at time
+ * of submission, num_iso_packets is 0 and that type is set appropriately.
+ *
+ * \param iso_packets number of isochronous packet descriptors to allocate. Must be non-negative.
+ * \returns a newly allocated transfer, or NULL on error
+ */
+DEFAULT_VISIBILITY
+struct libusb_transfer *LIBUSB_CALL libusb_alloc_transfer(int iso_packets) {
+    size_t                  priv_size;
+    size_t                  alloc_size;
+    unsigned char          *ptr;
+    struct usbi_transfer   *itransfer;
+    struct libusb_transfer *transfer;
+
+    assert(iso_packets >= 0);
+    if(iso_packets < 0)
+        return NULL;
+
+    priv_size = PTR_ALIGN(usbi_backend.transfer_priv_size);
+    alloc_size =
+        priv_size + sizeof(struct usbi_transfer) + sizeof(struct libusb_transfer) + (sizeof(struct libusb_iso_packet_descriptor) * (size_t)iso_packets);
+    ptr = calloc(1, alloc_size);
+    if(!ptr)
+        return NULL;
+
+    itransfer                  = (struct usbi_transfer *)(ptr + priv_size);
+    itransfer->num_iso_packets = iso_packets;
+    itransfer->priv            = ptr;
+    usbi_mutex_init(&itransfer->lock);
+    transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+    return transfer;
+}
+
+/** \ingroup libusb_asyncio
+ * Free a transfer structure. This should be called for all transfers
+ * allocated with libusb_alloc_transfer().
+ *
+ * If the \ref libusb_transfer_flags::LIBUSB_TRANSFER_FREE_BUFFER
+ * "LIBUSB_TRANSFER_FREE_BUFFER" flag is set and the transfer buffer is
+ * non-NULL, this function will also free the transfer buffer using the
+ * standard system memory allocator (e.g. free()).
+ *
+ * It is legal to call this function with a NULL transfer. In this case,
+ * the function will simply return safely.
+ *
+ * It is not legal to free an active transfer (one which has been submitted
+ * and has not yet completed).
+ *
+ * \param transfer the transfer to free
+ */
+void API_EXPORTED libusb_free_transfer(struct libusb_transfer *transfer) {
+    struct usbi_transfer *itransfer;
+    size_t                priv_size;
+    unsigned char        *ptr;
+
+    if(!transfer)
+        return;
+
+    usbi_dbg(TRANSFER_CTX(transfer), "transfer %p", (void *)transfer);
+    if(transfer->flags & LIBUSB_TRANSFER_FREE_BUFFER)
+        free(transfer->buffer);
+
+    itransfer = LIBUSB_TRANSFER_TO_USBI_TRANSFER(transfer);
+    usbi_mutex_destroy(&itransfer->lock);
+    if(itransfer->dev)
+        libusb_unref_device(itransfer->dev);
+
+    priv_size = PTR_ALIGN(usbi_backend.transfer_priv_size);
+    ptr       = (unsigned char *)itransfer - priv_size;
+    assert(ptr == itransfer->priv);
+    free(ptr);
+}
+
+/* iterates through the flying transfers, and rearms the timer based on the
+ * next upcoming timeout.
+ * must be called with flying_list locked.
+ * returns 0 on success or a LIBUSB_ERROR code on failure.
+ */
+#ifdef HAVE_OS_TIMER
+static int arm_timer_for_next_timeout(struct libusb_context *ctx) {
+    struct usbi_transfer *itransfer;
+
+    if(!usbi_using_timer(ctx))
+        return 0;
+
+    for_each_transfer(ctx, itransfer) {
+        struct timespec *cur_ts = &itransfer->timeout;
+
+        /* if we've reached transfers of infinite timeout, then we have no
+         * arming to do */
+        if(!TIMESPEC_IS_SET(cur_ts))
+            break;
+
+        /* act on first transfer that has not already been handled */
+        if(!(itransfer->timeout_flags & (USBI_TRANSFER_TIMEOUT_HANDLED | USBI_TRANSFER_OS_HANDLES_TIMEOUT))) {
+            usbi_dbg(ctx, "next timeout originally %ums", USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer)->timeout);
+            return usbi_arm_timer(&ctx->timer, cur_ts);
+        }
+    }
+
+    usbi_dbg(ctx, "no timeouts, disarming timer");
+    return usbi_disarm_timer(&ctx->timer);
+}
+#else
+static inline int arm_timer_for_next_timeout(struct libusb_context *ctx) {
+    UNUSED(ctx);
+    return 0;
+}
+#endif
+
+/* add a transfer to the (timeout-sorted) active transfers list.
+ * This function will return non 0 if fails to update the timer,
+ * in which case the transfer is *not* on the flying_transfers list. */
+static int add_to_flying_list(struct usbi_transfer *itransfer) {
+    struct usbi_transfer  *cur;
+    struct timespec       *timeout = &itransfer->timeout;
+    struct libusb_context *ctx     = ITRANSFER_CTX(itransfer);
+    int                    r       = 0;
+    int                    first   = 1;
+
+    calculate_timeout(itransfer);
+
+    /* if we have no other flying transfers, start the list with this one */
+    if(list_empty(&ctx->flying_transfers)) {
+        list_add(&itransfer->list, &ctx->flying_transfers);
+        goto out;
+    }
+
+    /* if we have infinite timeout, append to end of list */
+    if(!TIMESPEC_IS_SET(timeout)) {
+        list_add_tail(&itransfer->list, &ctx->flying_transfers);
+        /* first is irrelevant in this case */
+        goto out;
+    }
+
+    /* otherwise, find appropriate place in list */
+    for_each_transfer(ctx, cur) {
+        /* find first timeout that occurs after the transfer in question */
+        struct timespec *cur_ts = &cur->timeout;
+
+        if(!TIMESPEC_IS_SET(cur_ts) || TIMESPEC_CMP(cur_ts, timeout, >)) {
+            list_add_tail(&itransfer->list, &cur->list);
+            goto out;
+        }
+        first = 0;
+    }
+    /* first is 0 at this stage (list not empty) */
+
+    /* otherwise we need to be inserted at the end */
+    list_add_tail(&itransfer->list, &ctx->flying_transfers);
+out:
+#ifdef HAVE_OS_TIMER
+    if(first && usbi_using_timer(ctx) && TIMESPEC_IS_SET(timeout)) {
+        /* if this transfer has the lowest timeout of all active transfers,
+         * rearm the timer with this transfer's timeout */
+        usbi_dbg(ctx, "arm timer for timeout in %ums (first in line)", USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer)->timeout);
+        r = usbi_arm_timer(&ctx->timer, timeout);
+    }
+#else
+    UNUSED(first);
+#endif
+
+    if(r)
+        list_del(&itransfer->list);
+
+    return r;
+}
+
+/* remove a transfer from the active transfers list.
+ * This function will *always* remove the transfer from the
+ * flying_transfers list. It will return a LIBUSB_ERROR code
+ * if it fails to update the timer for the next timeout. */
+static int remove_from_flying_list(struct usbi_transfer *itransfer) {
+    struct libusb_context *ctx = ITRANSFER_CTX(itransfer);
+    int                    rearm_timer;
+    int                    r = 0;
+
+    usbi_mutex_lock(&ctx->flying_transfers_lock);
+    rearm_timer = (TIMESPEC_IS_SET(&itransfer->timeout) && list_first_entry(&ctx->flying_transfers, struct usbi_transfer, list) == itransfer);
+    list_del(&itransfer->list);
+    if(rearm_timer)
+        r = arm_timer_for_next_timeout(ctx);
+    usbi_mutex_unlock(&ctx->flying_transfers_lock);
+
+    return r;
+}
+
+/** \ingroup libusb_asyncio
+ * Submit a transfer. This function will fire off the USB transfer and then
+ * return immediately.
+ *
+ * \param transfer the transfer to submit
+ * \returns 0 on success
+ * \returns \ref LIBUSB_ERROR_NO_DEVICE if the device has been disconnected
+ * \returns \ref LIBUSB_ERROR_BUSY if the transfer has already been submitted.
+ * \returns \ref LIBUSB_ERROR_NOT_SUPPORTED if the transfer flags are not supported
+ * by the operating system.
+ * \returns \ref LIBUSB_ERROR_INVALID_PARAM if the transfer size is larger than
+ * the operating system and/or hardware can support (see \ref asynclimits)
+ * \returns another LIBUSB_ERROR code on other failure
+ */
+int API_EXPORTED libusb_submit_transfer(struct libusb_transfer *transfer) {
+    struct usbi_transfer  *itransfer = LIBUSB_TRANSFER_TO_USBI_TRANSFER(transfer);
+    struct libusb_context *ctx;
+    int                    r;
+
+    assert(transfer->dev_handle);
+    if(itransfer->dev)
+        libusb_unref_device(itransfer->dev);
+    itransfer->dev = libusb_ref_device(transfer->dev_handle->dev);
+
+    ctx = HANDLE_CTX(transfer->dev_handle);
+    usbi_dbg(ctx, "transfer %p", (void *)transfer);
+
+    /*
+     * Important note on locking, this function takes / releases locks
+     * in the following order:
+     *  take flying_transfers_lock
+     *  take itransfer->lock
+     *  clear transfer
+     *  add to flying_transfers list
+     *  release flying_transfers_lock
+     *  submit transfer
+     *  release itransfer->lock
+     *  if submit failed:
+     *   take flying_transfers_lock
+     *   remove from flying_transfers list
+     *   release flying_transfers_lock
+     *
+     * Note that it takes locks in the order a-b and then releases them
+     * in the same order a-b. This is somewhat unusual but not wrong,
+     * release order is not important as long as *all* locks are released
+     * before re-acquiring any locks.
+     *
+     * This means that the ordering of first releasing itransfer->lock
+     * and then re-acquiring the flying_transfers_list on error is
+     * important and must not be changed!
+     *
+     * This is done this way because when we take both locks we must always
+     * take flying_transfers_lock first to avoid ab-ba style deadlocks with
+     * the timeout handling and usbi_handle_disconnect paths.
+     *
+     * And we cannot release itransfer->lock before the submission is
+     * complete otherwise timeout handling for transfers with short
+     * timeouts may run before submission.
+     */
+    usbi_mutex_lock(&ctx->flying_transfers_lock);
+    usbi_mutex_lock(&itransfer->lock);
+    if(itransfer->state_flags & USBI_TRANSFER_IN_FLIGHT) {
+        usbi_mutex_unlock(&ctx->flying_transfers_lock);
+        usbi_mutex_unlock(&itransfer->lock);
+        return LIBUSB_ERROR_BUSY;
+    }
+    itransfer->transferred   = 0;
+    itransfer->state_flags   = 0;
+    itransfer->timeout_flags = 0;
+    r                        = add_to_flying_list(itransfer);
+    if(r) {
+        usbi_mutex_unlock(&ctx->flying_transfers_lock);
+        usbi_mutex_unlock(&itransfer->lock);
+        return r;
+    }
+    /*
+     * We must release the flying transfers lock here, because with
+     * some backends the submit_transfer method is synchronous.
+     */
+    usbi_mutex_unlock(&ctx->flying_transfers_lock);
+
+    r = usbi_backend.submit_transfer(itransfer);
+    if(r == LIBUSB_SUCCESS) {
+        itransfer->state_flags |= USBI_TRANSFER_IN_FLIGHT;
+    }
+    usbi_mutex_unlock(&itransfer->lock);
+
+    if(r != LIBUSB_SUCCESS)
+        remove_from_flying_list(itransfer);
+
+    return r;
+}
+
+/** \ingroup libusb_asyncio
+ * Asynchronously cancel a previously submitted transfer.
+ * This function returns immediately, but this does not indicate cancellation
+ * is complete. Your callback function will be invoked at some later time
+ * with a transfer status of
+ * \ref libusb_transfer_status::LIBUSB_TRANSFER_CANCELLED
+ * "LIBUSB_TRANSFER_CANCELLED."
+ *
+ * This function behaves differently on Darwin-based systems (macOS and iOS):
+ *
+ * - Calling this function for one transfer will cause all transfers on the
+ *   same endpoint to be cancelled. Your callback function will be invoked with
+ *   a transfer status of
+ *   \ref libusb_transfer_status::LIBUSB_TRANSFER_CANCELLED
+ *   "LIBUSB_TRANSFER_CANCELLED" for each transfer that was cancelled.
+
+ * - When built for macOS versions prior to 10.5, this function sends a
+ *   \c ClearFeature(ENDPOINT_HALT) request for the transfer's endpoint.
+ *   (Prior to libusb 1.0.27, this request was sent on all Darwin systems.)
+ *   If the device does not handle this request correctly, the data toggle
+ *   bits for the endpoint can be left out of sync between host and device,
+ *   which can have unpredictable results when the next data is sent on
+ *   the endpoint, including data being silently lost. A call to
+ *   \ref libusb_clear_halt will not resolve this situation, since that
+ *   function uses the same request. Therefore, if your program runs on
+ *   macOS < 10.5 (or libusb < 1.0.27), and uses a device that does not
+ *   correctly implement \c ClearFeature(ENDPOINT_HALT) requests, it may
+ *   only be safe to cancel transfers when followed by a device reset using
+ *   \ref libusb_reset_device.
+ *
+ * \param transfer the transfer to cancel
+ * \returns 0 on success
+ * \returns \ref LIBUSB_ERROR_NOT_FOUND if the transfer is not in progress,
+ * already complete, or already cancelled.
+ * \returns a LIBUSB_ERROR code on failure
+ */
+int API_EXPORTED libusb_cancel_transfer(struct libusb_transfer *transfer) {
+    struct usbi_transfer  *itransfer = LIBUSB_TRANSFER_TO_USBI_TRANSFER(transfer);
+    struct libusb_context *ctx       = ITRANSFER_CTX(itransfer);
+    int                    r;
+
+    usbi_dbg(ctx, "transfer %p", (void *)transfer);
+    usbi_mutex_lock(&itransfer->lock);
+    if(!(itransfer->state_flags & USBI_TRANSFER_IN_FLIGHT) || (itransfer->state_flags & USBI_TRANSFER_CANCELLING)) {
+        r = LIBUSB_ERROR_NOT_FOUND;
+        goto out;
+    }
+    r = usbi_backend.cancel_transfer(itransfer);
+    if(r < 0) {
+        if(r != LIBUSB_ERROR_NOT_FOUND && r != LIBUSB_ERROR_NO_DEVICE)
+            usbi_err(ctx, "cancel transfer failed error %d", r);
+        else
+            usbi_dbg(ctx, "cancel transfer failed error %d", r);
+
+        if(r == LIBUSB_ERROR_NO_DEVICE)
+            itransfer->state_flags |= USBI_TRANSFER_DEVICE_DISAPPEARED;
+    }
+
+    itransfer->state_flags |= USBI_TRANSFER_CANCELLING;
+
+out:
+    usbi_mutex_unlock(&itransfer->lock);
+    return r;
+}
+
+/** \ingroup libusb_asyncio
+ * Set a transfers bulk stream id. Note users are advised to use
+ * libusb_fill_bulk_stream_transfer() instead of calling this function
+ * directly.
+ *
+ * Since version 1.0.19, \ref LIBUSB_API_VERSION >= 0x01000103
+ *
+ * \param transfer the transfer to set the stream id for
+ * \param stream_id the stream id to set
+ * \see libusb_alloc_streams()
+ */
+void API_EXPORTED libusb_transfer_set_stream_id(struct libusb_transfer *transfer, uint32_t stream_id) {
+    struct usbi_transfer *itransfer = LIBUSB_TRANSFER_TO_USBI_TRANSFER(transfer);
+
+    itransfer->stream_id = stream_id;
+}
+
+/** \ingroup libusb_asyncio
+ * Get a transfers bulk stream id.
+ *
+ * Since version 1.0.19, \ref LIBUSB_API_VERSION >= 0x01000103
+ *
+ * \param transfer the transfer to get the stream id for
+ * \returns the stream id for the transfer
+ */
+uint32_t API_EXPORTED libusb_transfer_get_stream_id(struct libusb_transfer *transfer) {
+    struct usbi_transfer *itransfer = LIBUSB_TRANSFER_TO_USBI_TRANSFER(transfer);
+
+    return itransfer->stream_id;
+}
+
+/* Handle completion of a transfer (completion might be an error condition).
+ * This will invoke the user-supplied callback function, which may end up
+ * freeing the transfer. Therefore you cannot use the transfer structure
+ * after calling this function, and you should free all backend-specific
+ * data before calling it.
+ * Do not call this function with the usbi_transfer lock held. User-specified
+ * callback functions may attempt to directly resubmit the transfer, which
+ * will attempt to take the lock. */
+int usbi_handle_transfer_completion(struct usbi_transfer *itransfer, enum libusb_transfer_status status) {
+    struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+    struct libusb_context  *ctx      = ITRANSFER_CTX(itransfer);
+    uint8_t                 flags;
+    int                     r;
+
+    r = remove_from_flying_list(itransfer);
+    if(r < 0)
+        usbi_err(ctx, "failed to set timer for next timeout");
+
+    usbi_mutex_lock(&itransfer->lock);
+    itransfer->state_flags &= ~USBI_TRANSFER_IN_FLIGHT;
+    usbi_mutex_unlock(&itransfer->lock);
+
+    if(status == LIBUSB_TRANSFER_COMPLETED && transfer->flags & LIBUSB_TRANSFER_SHORT_NOT_OK) {
+        int rqlen = transfer->length;
+        if(transfer->type == LIBUSB_TRANSFER_TYPE_CONTROL)
+            rqlen -= LIBUSB_CONTROL_SETUP_SIZE;
+        if(rqlen != itransfer->transferred) {
+            usbi_dbg(ctx, "interpreting short transfer as error");
+            status = LIBUSB_TRANSFER_ERROR;
+        }
+    }
+
+    flags                   = transfer->flags;
+    transfer->status        = status;
+    transfer->actual_length = itransfer->transferred;
+    usbi_dbg(ctx, "transfer %p has callback %p", (void *)transfer, transfer->callback);
+    if(transfer->callback)
+        transfer->callback(transfer);
+    /* transfer might have been freed by the above call, do not use from
+     * this point. */
+    if(flags & LIBUSB_TRANSFER_FREE_TRANSFER)
+        libusb_free_transfer(transfer);
+    return r;
+}
+
+/* Similar to usbi_handle_transfer_completion() but exclusively for transfers
+ * that were asynchronously cancelled. The same concerns w.r.t. freeing of
+ * transfers exist here.
+ * Do not call this function with the usbi_transfer lock held. User-specified
+ * callback functions may attempt to directly resubmit the transfer, which
+ * will attempt to take the lock. */
+int usbi_handle_transfer_cancellation(struct usbi_transfer *itransfer) {
+    struct libusb_context *ctx = ITRANSFER_CTX(itransfer);
+    uint8_t                timed_out;
+
+    usbi_mutex_lock(&ctx->flying_transfers_lock);
+    timed_out = itransfer->timeout_flags & USBI_TRANSFER_TIMED_OUT;
+    usbi_mutex_unlock(&ctx->flying_transfers_lock);
+
+    /* if the URB was cancelled due to timeout, report timeout to the user */
+    if(timed_out) {
+        usbi_dbg(ctx, "detected timeout cancellation");
+        return usbi_handle_transfer_completion(itransfer, LIBUSB_TRANSFER_TIMED_OUT);
+    }
+
+    /* otherwise its a normal async cancel */
+    return usbi_handle_transfer_completion(itransfer, LIBUSB_TRANSFER_CANCELLED);
+}
+
+/* Add a completed transfer to the completed_transfers list of the
+ * context and signal the event. The backend's handle_transfer_completion()
+ * function will be called the next time an event handler runs. */
+void usbi_signal_transfer_completion(struct usbi_transfer *itransfer) {
+    struct libusb_device *dev = itransfer->dev;
+
+    if(dev) {
+        struct libusb_context *ctx = DEVICE_CTX(dev);
+        unsigned int           event_flags;
+
+        usbi_mutex_lock(&ctx->event_data_lock);
+        event_flags = ctx->event_flags;
+        ctx->event_flags |= USBI_EVENT_TRANSFER_COMPLETED;
+        list_add_tail(&itransfer->completed_list, &ctx->completed_transfers);
+        if(!event_flags)
+            usbi_signal_event(&ctx->event);
+        usbi_mutex_unlock(&ctx->event_data_lock);
+    }
+}
+
+/** \ingroup libusb_poll
+ * Attempt to acquire the event handling lock. This lock is used to ensure that
+ * only one thread is monitoring libusb event sources at any one time.
+ *
+ * You only need to use this lock if you are developing an application
+ * which calls poll() or select() on libusb's file descriptors directly.
+ * If you stick to libusb's event handling loop functions (e.g.
+ * libusb_handle_events()) then you do not need to be concerned with this
+ * locking.
+ *
+ * While holding this lock, you are trusted to actually be handling events.
+ * If you are no longer handling events, you must call libusb_unlock_events()
+ * as soon as possible.
+ *
+ * \param ctx the context to operate on, or NULL for the default context
+ * \returns 0 if the lock was obtained successfully
+ * \returns 1 if the lock was not obtained (i.e. another thread holds the lock)
+ * \ref libusb_mtasync
+ */
+int API_EXPORTED libusb_try_lock_events(libusb_context *ctx) {
+    int          r;
+    unsigned int ru;
+
+    ctx = usbi_get_context(ctx);
+
+    /* is someone else waiting to close a device? if so, don't let this thread
+     * start event handling */
+    usbi_mutex_lock(&ctx->event_data_lock);
+    ru = ctx->device_close;
+    usbi_mutex_unlock(&ctx->event_data_lock);
+    if(ru) {
+        usbi_dbg(ctx, "someone else is closing a device");
+        return 1;
+    }
+
+    r = usbi_mutex_trylock(&ctx->events_lock);
+    if(!r)
+        return 1;
+
+    ctx->event_handler_active = 1;
+    return 0;
+}
+
+/** \ingroup libusb_poll
+ * Acquire the event handling lock, blocking until successful acquisition if
+ * it is contended. This lock is used to ensure that only one thread is
+ * monitoring libusb event sources at any one time.
+ *
+ * You only need to use this lock if you are developing an application
+ * which calls poll() or select() on libusb's file descriptors directly.
+ * If you stick to libusb's event handling loop functions (e.g.
+ * libusb_handle_events()) then you do not need to be concerned with this
+ * locking.
+ *
+ * While holding this lock, you are trusted to actually be handling events.
+ * If you are no longer handling events, you must call libusb_unlock_events()
+ * as soon as possible.
+ *
+ * \param ctx the context to operate on, or NULL for the default context
+ * \ref libusb_mtasync
+ */
+void API_EXPORTED libusb_lock_events(libusb_context *ctx) {
+    ctx = usbi_get_context(ctx);
+    usbi_mutex_lock(&ctx->events_lock);
+    ctx->event_handler_active = 1;
+}
+
+/** \ingroup libusb_poll
+ * Release the lock previously acquired with libusb_try_lock_events() or
+ * libusb_lock_events(). Releasing this lock will wake up any threads blocked
+ * on libusb_wait_for_event().
+ *
+ * \param ctx the context to operate on, or NULL for the default context
+ * \ref libusb_mtasync
+ */
+void API_EXPORTED libusb_unlock_events(libusb_context *ctx) {
+    ctx                       = usbi_get_context(ctx);
+    ctx->event_handler_active = 0;
+    usbi_mutex_unlock(&ctx->events_lock);
+
+    /* FIXME: perhaps we should be a bit more efficient by not broadcasting
+     * the availability of the events lock when we are modifying pollfds
+     * (check ctx->device_close)? */
+    usbi_mutex_lock(&ctx->event_waiters_lock);
+    usbi_cond_broadcast(&ctx->event_waiters_cond);
+    usbi_mutex_unlock(&ctx->event_waiters_lock);
+}
+
+/** \ingroup libusb_poll
+ * Determine if it is still OK for this thread to be doing event handling.
+ *
+ * Sometimes, libusb needs to temporarily pause all event handlers, and this
+ * is the function you should use before polling file descriptors to see if
+ * this is the case.
+ *
+ * If this function instructs your thread to give up the events lock, you
+ * should just continue the usual logic that is documented in \ref libusb_mtasync.
+ * On the next iteration, your thread will fail to obtain the events lock,
+ * and will hence become an event waiter.
+ *
+ * This function should be called while the events lock is held: you don't
+ * need to worry about the results of this function if your thread is not
+ * the current event handler.
+ *
+ * \param ctx the context to operate on, or NULL for the default context
+ * \returns 1 if event handling can start or continue
+ * \returns 0 if this thread must give up the events lock
+ * \ref fullstory "Multi-threaded I/O: the full story"
+ */
+int API_EXPORTED libusb_event_handling_ok(libusb_context *ctx) {
+    unsigned int r;
+
+    ctx = usbi_get_context(ctx);
+
+    /* is someone else waiting to close a device? if so, don't let this thread
+     * continue event handling */
+    usbi_mutex_lock(&ctx->event_data_lock);
+    r = ctx->device_close;
+    usbi_mutex_unlock(&ctx->event_data_lock);
+    if(r) {
+        usbi_dbg(ctx, "someone else is closing a device");
+        return 0;
+    }
+
+    return 1;
+}
+
+/** \ingroup libusb_poll
+ * Determine if an active thread is handling events (i.e. if anyone is holding
+ * the event handling lock).
+ *
+ * \param ctx the context to operate on, or NULL for the default context
+ * \returns 1 if a thread is handling events
+ * \returns 0 if there are no threads currently handling events
+ * \ref libusb_mtasync
+ */
+int API_EXPORTED libusb_event_handler_active(libusb_context *ctx) {
+    unsigned int r;
+
+    ctx = usbi_get_context(ctx);
+
+    /* is someone else waiting to close a device? if so, don't let this thread
+     * start event handling -- indicate that event handling is happening */
+    usbi_mutex_lock(&ctx->event_data_lock);
+    r = ctx->device_close;
+    usbi_mutex_unlock(&ctx->event_data_lock);
+    if(r) {
+        usbi_dbg(ctx, "someone else is closing a device");
+        return 1;
+    }
+
+    return ctx->event_handler_active;
+}
+
+/** \ingroup libusb_poll
+ * Interrupt any active thread that is handling events. This is mainly useful
+ * for interrupting a dedicated event handling thread when an application
+ * wishes to call libusb_exit().
+ *
+ * Since version 1.0.21, \ref LIBUSB_API_VERSION >= 0x01000105
+ *
+ * \param ctx the context to operate on, or NULL for the default context
+ * \ref libusb_mtasync
+ */
+void API_EXPORTED libusb_interrupt_event_handler(libusb_context *ctx) {
+    unsigned int event_flags;
+
+    usbi_dbg(ctx, " ");
+
+    ctx = usbi_get_context(ctx);
+    usbi_mutex_lock(&ctx->event_data_lock);
+
+    event_flags = ctx->event_flags;
+    ctx->event_flags |= USBI_EVENT_USER_INTERRUPT;
+    if(!event_flags)
+        usbi_signal_event(&ctx->event);
+
+    usbi_mutex_unlock(&ctx->event_data_lock);
+}
+
+/** \ingroup libusb_poll
+ * Acquire the event waiters lock. This lock is designed to be obtained under
+ * the situation where you want to be aware when events are completed, but
+ * some other thread is event handling so calling libusb_handle_events() is not
+ * allowed.
+ *
+ * You then obtain this lock, re-check that another thread is still handling
+ * events, then call libusb_wait_for_event().
+ *
+ * You only need to use this lock if you are developing an application
+ * which calls poll() or select() on libusb's file descriptors directly,
+ * <b>and</b> may potentially be handling events from 2 threads simultaneously.
+ * If you stick to libusb's event handling loop functions (e.g.
+ * libusb_handle_events()) then you do not need to be concerned with this
+ * locking.
+ *
+ * \param ctx the context to operate on, or NULL for the default context
+ * \ref libusb_mtasync
+ */
+void API_EXPORTED libusb_lock_event_waiters(libusb_context *ctx) {
+    ctx = usbi_get_context(ctx);
+    usbi_mutex_lock(&ctx->event_waiters_lock);
+}
+
+/** \ingroup libusb_poll
+ * Release the event waiters lock.
+ * \param ctx the context to operate on, or NULL for the default context
+ * \ref libusb_mtasync
+ */
+void API_EXPORTED libusb_unlock_event_waiters(libusb_context *ctx) {
+    ctx = usbi_get_context(ctx);
+    usbi_mutex_unlock(&ctx->event_waiters_lock);
+}
+
+/** \ingroup libusb_poll
+ * Wait for another thread to signal completion of an event. Must be called
+ * with the event waiters lock held, see libusb_lock_event_waiters().
+ *
+ * This function will block until any of the following conditions are met:
+ * -# The timeout expires
+ * -# A transfer completes
+ * -# A thread releases the event handling lock through libusb_unlock_events()
+ *
+ * Condition 1 is obvious. Condition 2 unblocks your thread <em>after</em>
+ * the callback for the transfer has completed. Condition 3 is important
+ * because it means that the thread that was previously handling events is no
+ * longer doing so, so if any events are to complete, another thread needs to
+ * step up and start event handling.
+ *
+ * This function releases the event waiters lock before putting your thread
+ * to sleep, and reacquires the lock as it is being woken up.
+ *
+ * \param ctx the context to operate on, or NULL for the default context
+ * \param tv maximum timeout for this blocking function. A NULL value
+ * indicates unlimited timeout.
+ * \returns 0 after a transfer completes or another thread stops event handling
+ * \returns 1 if the timeout expired
+ * \returns \ref LIBUSB_ERROR_INVALID_PARAM if timeval is invalid
+ * \ref libusb_mtasync
+ */
+int API_EXPORTED libusb_wait_for_event(libusb_context *ctx, struct timeval *tv) {
+    int r;
+
+    ctx = usbi_get_context(ctx);
+    if(!tv) {
+        usbi_cond_wait(&ctx->event_waiters_cond, &ctx->event_waiters_lock);
+        return 0;
+    }
+
+    if(!TIMEVAL_IS_VALID(tv))
+        return LIBUSB_ERROR_INVALID_PARAM;
+
+    r = usbi_cond_timedwait(&ctx->event_waiters_cond, &ctx->event_waiters_lock, tv);
+    if(r < 0)
+        return r == LIBUSB_ERROR_TIMEOUT;
+
+    return 0;
+}
+
+static void handle_timeout(struct usbi_transfer *itransfer) {
+    struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+    int                     r;
+
+    itransfer->timeout_flags |= USBI_TRANSFER_TIMEOUT_HANDLED;
+    r = libusb_cancel_transfer(transfer);
+    if(r == LIBUSB_SUCCESS)
+        itransfer->timeout_flags |= USBI_TRANSFER_TIMED_OUT;
+    else
+        usbi_warn(TRANSFER_CTX(transfer), "async cancel failed %d", r);
+}
+
+static void handle_timeouts_locked(struct libusb_context *ctx) {
+    struct timespec       systime;
+    struct usbi_transfer *itransfer;
+
+    if(list_empty(&ctx->flying_transfers))
+        return;
+
+    /* get current time */
+    usbi_get_monotonic_time(&systime);
+
+    /* iterate through flying transfers list, finding all transfers that
+     * have expired timeouts */
+    for_each_transfer(ctx, itransfer) {
+        struct timespec *cur_ts = &itransfer->timeout;
+
+        /* if we've reached transfers of infinite timeout, we're all done */
+        if(!TIMESPEC_IS_SET(cur_ts))
+            return;
+
+        /* ignore timeouts we've already handled */
+        if(itransfer->timeout_flags & (USBI_TRANSFER_TIMEOUT_HANDLED | USBI_TRANSFER_OS_HANDLES_TIMEOUT))
+            continue;
+
+        /* if transfer has non-expired timeout, nothing more to do */
+        if(TIMESPEC_CMP(cur_ts, &systime, >))
+            return;
+
+        /* otherwise, we've got an expired timeout to handle */
+        handle_timeout(itransfer);
+    }
+}
+
+static void handle_timeouts(struct libusb_context *ctx) {
+    ctx = usbi_get_context(ctx);
+    usbi_mutex_lock(&ctx->flying_transfers_lock);
+    handle_timeouts_locked(ctx);
+    usbi_mutex_unlock(&ctx->flying_transfers_lock);
+}
+
+static int handle_event_trigger(struct libusb_context *ctx) {
+    struct list_head hotplug_msgs;
+    int              hotplug_event = 0;
+    int              r             = 0;
+
+    usbi_dbg(ctx, "event triggered");
+
+    list_init(&hotplug_msgs);
+
+    /* take the the event data lock while processing events */
+    usbi_mutex_lock(&ctx->event_data_lock);
+
+    /* check if someone modified the event sources */
+    if(ctx->event_flags & USBI_EVENT_EVENT_SOURCES_MODIFIED)
+        usbi_dbg(ctx, "someone updated the event sources");
+
+    if(ctx->event_flags & USBI_EVENT_USER_INTERRUPT) {
+        usbi_dbg(ctx, "someone purposefully interrupted");
+        ctx->event_flags &= ~USBI_EVENT_USER_INTERRUPT;
+    }
+
+    if(ctx->event_flags & USBI_EVENT_HOTPLUG_CB_DEREGISTERED) {
+        usbi_dbg(ctx, "someone unregistered a hotplug cb");
+        ctx->event_flags &= ~USBI_EVENT_HOTPLUG_CB_DEREGISTERED;
+        hotplug_event = 1;
+    }
+
+    /* check if someone is closing a device */
+    if(ctx->event_flags & USBI_EVENT_DEVICE_CLOSE)
+        usbi_dbg(ctx, "someone is closing a device");
+
+    /* check for any pending hotplug messages */
+    if(ctx->event_flags & USBI_EVENT_HOTPLUG_MSG_PENDING) {
+        usbi_dbg(ctx, "hotplug message received");
+        ctx->event_flags &= ~USBI_EVENT_HOTPLUG_MSG_PENDING;
+        hotplug_event = 1;
+        assert(!list_empty(&ctx->hotplug_msgs));
+        list_cut(&hotplug_msgs, &ctx->hotplug_msgs);
+    }
+
+    /* complete any pending transfers */
+    if(ctx->event_flags & USBI_EVENT_TRANSFER_COMPLETED) {
+        struct usbi_transfer *itransfer, *tmp;
+        struct list_head      completed_transfers;
+
+        assert(!list_empty(&ctx->completed_transfers));
+        list_cut(&completed_transfers, &ctx->completed_transfers);
+        usbi_mutex_unlock(&ctx->event_data_lock);
+
+        __for_each_completed_transfer_safe(&completed_transfers, itransfer, tmp) {
+            list_del(&itransfer->completed_list);
+            r = usbi_backend.handle_transfer_completion(itransfer);
+            if(r) {
+                usbi_err(ctx, "backend handle_transfer_completion failed with error %d", r);
+                break;
+            }
+        }
+
+        usbi_mutex_lock(&ctx->event_data_lock);
+        if(!list_empty(&completed_transfers)) {
+            /* an error occurred, put the remaining transfers back on the list */
+            list_splice_front(&completed_transfers, &ctx->completed_transfers);
+        }
+        else if(list_empty(&ctx->completed_transfers)) {
+            ctx->event_flags &= ~USBI_EVENT_TRANSFER_COMPLETED;
+        }
+    }
+
+    /* if no further pending events, clear the event */
+    if(!ctx->event_flags)
+        usbi_clear_event(&ctx->event);
+
+    usbi_mutex_unlock(&ctx->event_data_lock);
+
+    /* process the hotplug events, if any */
+    if(hotplug_event)
+        usbi_hotplug_process(ctx, &hotplug_msgs);
+
+    return r;
+}
+
+#ifdef HAVE_OS_TIMER
+static int handle_timer_trigger(struct libusb_context *ctx) {
+    int r;
+
+    usbi_mutex_lock(&ctx->flying_transfers_lock);
+
+    /* process the timeout that just happened */
+    handle_timeouts_locked(ctx);
+
+    /* arm for next timeout */
+    r = arm_timer_for_next_timeout(ctx);
+
+    usbi_mutex_unlock(&ctx->flying_transfers_lock);
+
+    return r;
+}
+#endif
+
+/* do the actual event handling. assumes that no other thread is concurrently
+ * doing the same thing. */
+static int handle_events(struct libusb_context *ctx, struct timeval *tv) {
+    struct usbi_reported_events reported_events;
+    int                         r, timeout_ms;
+
+    /* prevent attempts to recursively handle events (e.g. calling into
+     * libusb_handle_events() from within a hotplug or transfer callback) */
+    if(usbi_handling_events(ctx))
+        return LIBUSB_ERROR_BUSY;
+
+    /* only reallocate the event source data when the list of event sources has
+     * been modified since the last handle_events(), otherwise reuse them to
+     * save the additional overhead */
+    usbi_mutex_lock(&ctx->event_data_lock);
+    if(ctx->event_flags & USBI_EVENT_EVENT_SOURCES_MODIFIED) {
+        usbi_dbg(ctx, "event sources modified, reallocating event data");
+
+        /* free anything removed since we last ran */
+        cleanup_removed_event_sources(ctx);
+
+        r = usbi_alloc_event_data(ctx);
+        if(r) {
+            usbi_mutex_unlock(&ctx->event_data_lock);
+            return r;
+        }
+
+        /* reset the flag now that we have the updated list */
+        ctx->event_flags &= ~USBI_EVENT_EVENT_SOURCES_MODIFIED;
+
+        /* if no further pending events, clear the event so that we do
+         * not immediately return from the wait function */
+        if(!ctx->event_flags)
+            usbi_clear_event(&ctx->event);
+    }
+    usbi_mutex_unlock(&ctx->event_data_lock);
+
+    timeout_ms = (int)(tv->tv_sec * 1000) + (tv->tv_usec / 1000);
+
+    /* round up to next millisecond */
+    if(tv->tv_usec % 1000)
+        timeout_ms++;
+
+    reported_events.event_bits = 0;
+
+    usbi_start_event_handling(ctx);
+
+    r = usbi_wait_for_events(ctx, &reported_events, timeout_ms);
+    if(r != LIBUSB_SUCCESS) {
+        if(r == LIBUSB_ERROR_TIMEOUT) {
+            handle_timeouts(ctx);
+            r = LIBUSB_SUCCESS;
+        }
+        goto done;
+    }
+
+    if(reported_events.event_triggered) {
+        r = handle_event_trigger(ctx);
+        if(r) {
+            /* return error code */
+            goto done;
+        }
+    }
+
+#ifdef HAVE_OS_TIMER
+    if(reported_events.timer_triggered) {
+        r = handle_timer_trigger(ctx);
+        if(r) {
+            /* return error code */
+            goto done;
+        }
+    }
+#endif
+
+    if(!reported_events.num_ready)
+        goto done;
+
+    r = usbi_backend.handle_events(ctx, reported_events.event_data, reported_events.event_data_count, reported_events.num_ready);
+    if(r)
+        usbi_err(ctx, "backend handle_events failed with error %d", r);
+
+done:
+    usbi_end_event_handling(ctx);
+    return r;
+}
+
+/* returns the smallest of:
+ *  1. timeout of next URB
+ *  2. user-supplied timeout
+ * returns 1 if there is an already-expired timeout, otherwise returns 0
+ * and populates out
+ */
+static int get_next_timeout(libusb_context *ctx, struct timeval *tv, struct timeval *out) {
+    struct timeval timeout;
+    int            r = libusb_get_next_timeout(ctx, &timeout);
+    if(r) {
+        /* timeout already expired? */
+        if(!timerisset(&timeout))
+            return 1;
+
+        /* choose the smallest of next URB timeout or user specified timeout */
+        if(timercmp(&timeout, tv, <))
+            *out = timeout;
+        else
+            *out = *tv;
+    }
+    else {
+        *out = *tv;
+    }
+    return 0;
+}
+
+/** \ingroup libusb_poll
+ * Handle any pending events.
+ *
+ * libusb determines "pending events" by checking if any timeouts have expired
+ * and by checking the set of file descriptors for activity.
+ *
+ * If a zero timeval is passed, this function will handle any already-pending
+ * events and then immediately return in non-blocking style.
+ *
+ * If a non-zero timeval is passed and no events are currently pending, this
+ * function will block waiting for events to handle up until the specified
+ * timeout. If an event arrives or a signal is raised, this function will
+ * return early.
+ *
+ * If the parameter completed is not NULL then <em>after obtaining the event
+ * handling lock</em> this function will return immediately if the integer
+ * pointed to is not 0. This allows for race free waiting for the completion
+ * of a specific transfer.
+ *
+ * \param ctx the context to operate on, or NULL for the default context
+ * \param tv the maximum time to block waiting for events, or an all zero
+ * timeval struct for non-blocking mode
+ * \param completed pointer to completion integer to check, or NULL
+ * \returns 0 on success
+ * \returns \ref LIBUSB_ERROR_INVALID_PARAM if timeval is invalid
+ * \returns another LIBUSB_ERROR code on other failure
+ * \ref libusb_mtasync
+ */
+int API_EXPORTED libusb_handle_events_timeout_completed(libusb_context *ctx, struct timeval *tv, int *completed) {
+    int            r;
+    struct timeval poll_timeout;
+
+    if(!TIMEVAL_IS_VALID(tv))
+        return LIBUSB_ERROR_INVALID_PARAM;
+
+    ctx = usbi_get_context(ctx);
+    r   = get_next_timeout(ctx, tv, &poll_timeout);
+    if(r) {
+        /* timeout already expired */
+        handle_timeouts(ctx);
+        return 0;
+    }
+
+retry:
+    if(libusb_try_lock_events(ctx) == 0) {
+        if(completed == NULL || !*completed) {
+            /* we obtained the event lock: do our own event handling */
+            usbi_dbg(ctx, "doing our own event handling");
+            r = handle_events(ctx, &poll_timeout);
+        }
+        libusb_unlock_events(ctx);
+        return r;
+    }
+
+    /* another thread is doing event handling. wait for thread events that
+     * notify event completion. */
+    libusb_lock_event_waiters(ctx);
+
+    if(completed && *completed)
+        goto already_done;
+
+    if(!libusb_event_handler_active(ctx)) {
+        /* we hit a race: whoever was event handling earlier finished in the
+         * time it took us to reach this point. try the cycle again. */
+        libusb_unlock_event_waiters(ctx);
+        usbi_dbg(ctx, "event handler was active but went away, retrying");
+        goto retry;
+    }
+
+    usbi_dbg(ctx, "another thread is doing event handling");
+    r = libusb_wait_for_event(ctx, &poll_timeout);
+
+already_done:
+    libusb_unlock_event_waiters(ctx);
+
+    if(r < 0)
+        return r;
+    else if(r == 1)
+        handle_timeouts(ctx);
+    return 0;
+}
+
+/** \ingroup libusb_poll
+ * Handle any pending events
+ *
+ * Like libusb_handle_events_timeout_completed(), but without the completed
+ * parameter, calling this function is equivalent to calling
+ * libusb_handle_events_timeout_completed() with a NULL completed parameter.
+ *
+ * This function is kept primarily for backwards compatibility.
+ * All new code should call libusb_handle_events_completed() or
+ * libusb_handle_events_timeout_completed() to avoid race conditions.
+ *
+ * \param ctx the context to operate on, or NULL for the default context
+ * \param tv the maximum time to block waiting for events, or an all zero
+ * timeval struct for non-blocking mode
+ * \returns 0 on success, or a LIBUSB_ERROR code on failure
+ */
+int API_EXPORTED libusb_handle_events_timeout(libusb_context *ctx, struct timeval *tv) {
+    return libusb_handle_events_timeout_completed(ctx, tv, NULL);
+}
+
+/** \ingroup libusb_poll
+ * Handle any pending events in blocking mode. There is currently a timeout
+ * hard-coded at 60 seconds but we plan to make it unlimited in future. For
+ * finer control over whether this function is blocking or non-blocking, or
+ * for control over the timeout, use libusb_handle_events_timeout_completed()
+ * instead.
+ *
+ * This function is kept primarily for backwards compatibility.
+ * All new code should call libusb_handle_events_completed() or
+ * libusb_handle_events_timeout_completed() to avoid race conditions.
+ *
+ * \param ctx the context to operate on, or NULL for the default context
+ * \returns 0 on success, or a LIBUSB_ERROR code on failure
+ */
+int API_EXPORTED libusb_handle_events(libusb_context *ctx) {
+    struct timeval tv;
+    tv.tv_sec  = 60;
+    tv.tv_usec = 0;
+    return libusb_handle_events_timeout_completed(ctx, &tv, NULL);
+}
+
+/** \ingroup libusb_poll
+ * Handle any pending events in blocking mode.
+ *
+ * Like libusb_handle_events(), with the addition of a completed parameter
+ * to allow for race free waiting for the completion of a specific transfer.
+ *
+ * See libusb_handle_events_timeout_completed() for details on the completed
+ * parameter.
+ *
+ * \param ctx the context to operate on, or NULL for the default context
+ * \param completed pointer to completion integer to check, or NULL
+ * \returns 0 on success, or a LIBUSB_ERROR code on failure
+ * \ref libusb_mtasync
+ */
+int API_EXPORTED libusb_handle_events_completed(libusb_context *ctx, int *completed) {
+    struct timeval tv;
+    tv.tv_sec  = 60;
+    tv.tv_usec = 0;
+    return libusb_handle_events_timeout_completed(ctx, &tv, completed);
+}
+
+/** \ingroup libusb_poll
+ * Handle any pending events by polling file descriptors, without checking if
+ * any other threads are already doing so. Must be called with the event lock
+ * held, see libusb_lock_events().
+ *
+ * This function is designed to be called under the situation where you have
+ * taken the event lock and are calling poll()/select() directly on libusb's
+ * file descriptors (as opposed to using libusb_handle_events() or similar).
+ * You detect events on libusb's descriptors, so you then call this function
+ * with a zero timeout value (while still holding the event lock).
+ *
+ * \param ctx the context to operate on, or NULL for the default context
+ * \param tv the maximum time to block waiting for events, or zero for
+ * non-blocking mode
+ * \returns 0 on success
+ * \returns \ref LIBUSB_ERROR_INVALID_PARAM if timeval is invalid
+ * \returns another LIBUSB_ERROR code on other failure
+ * \ref libusb_mtasync
+ */
+int API_EXPORTED libusb_handle_events_locked(libusb_context *ctx, struct timeval *tv) {
+    int            r;
+    struct timeval poll_timeout;
+
+    if(!TIMEVAL_IS_VALID(tv))
+        return LIBUSB_ERROR_INVALID_PARAM;
+
+    ctx = usbi_get_context(ctx);
+    r   = get_next_timeout(ctx, tv, &poll_timeout);
+    if(r) {
+        /* timeout already expired */
+        handle_timeouts(ctx);
+        return 0;
+    }
+
+    return handle_events(ctx, &poll_timeout);
+}
+
+/** \ingroup libusb_poll
+ * Determines whether your application must apply special timing considerations
+ * when monitoring libusb's file descriptors.
+ *
+ * This function is only useful for applications which retrieve and poll
+ * libusb's file descriptors in their own main loop (\ref libusb_pollmain).
+ *
+ * Ordinarily, libusb's event handler needs to be called into at specific
+ * moments in time (in addition to times when there is activity on the file
+ * descriptor set). The usual approach is to use libusb_get_next_timeout()
+ * to learn about when the next timeout occurs, and to adjust your
+ * poll()/select() timeout accordingly so that you can make a call into the
+ * library at that time.
+ *
+ * Some platforms supported by libusb do not come with this baggage - any
+ * events relevant to timing will be represented by activity on the file
+ * descriptor set, and libusb_get_next_timeout() will always return 0.
+ * This function allows you to detect whether you are running on such a
+ * platform.
+ *
+ * Since v1.0.5.
+ *
+ * \param ctx the context to operate on, or NULL for the default context
+ * \returns 0 if you must call into libusb at times determined by
+ * libusb_get_next_timeout(), or 1 if all timeout events are handled internally
+ * or through regular activity on the file descriptors.
+ * \ref libusb_pollmain "Polling libusb file descriptors for event handling"
+ */
+int API_EXPORTED libusb_pollfds_handle_timeouts(libusb_context *ctx) {
+    ctx = usbi_get_context(ctx);
+    return usbi_using_timer(ctx);
+}
+
+/** \ingroup libusb_poll
+ * Determine the next internal timeout that libusb needs to handle. You only
+ * need to use this function if you are calling poll() or select() or similar
+ * on libusb's file descriptors yourself - you do not need to use it if you
+ * are calling libusb_handle_events() or a variant directly.
+ *
+ * You should call this function in your main loop in order to determine how
+ * long to wait for select() or poll() to return results. libusb needs to be
+ * called into at this timeout, so you should use it as an upper bound on
+ * your select() or poll() call.
+ *
+ * When the timeout has expired, call into libusb_handle_events_timeout()
+ * (perhaps in non-blocking mode) so that libusb can handle the timeout.
+ *
+ * This function may return 1 (success) and an all-zero timeval. If this is
+ * the case, it indicates that libusb has a timeout that has already expired
+ * so you should call libusb_handle_events_timeout() or similar immediately.
+ * A return code of 0 indicates that there are no pending timeouts.
+ *
+ * On some platforms, this function will always returns 0 (no pending
+ * timeouts). See \ref polltime.
+ *
+ * \param ctx the context to operate on, or NULL for the default context
+ * \param tv output location for a relative time against the current
+ * clock in which libusb must be called into in order to process timeout events
+ * \returns 0 if there are no pending timeouts, 1 if a timeout was returned,
+ * or \ref LIBUSB_ERROR_OTHER on failure
+ */
+int API_EXPORTED libusb_get_next_timeout(libusb_context *ctx, struct timeval *tv) {
+    struct usbi_transfer *itransfer;
+    struct timespec       systime;
+    struct timespec       next_timeout = { 0, 0 };
+
+    ctx = usbi_get_context(ctx);
+    if(usbi_using_timer(ctx))
+        return 0;
+
+    usbi_mutex_lock(&ctx->flying_transfers_lock);
+    if(list_empty(&ctx->flying_transfers)) {
+        usbi_mutex_unlock(&ctx->flying_transfers_lock);
+        usbi_dbg(ctx, "no URBs, no timeout!");
+        return 0;
+    }
+
+    /* find next transfer which hasn't already been processed as timed out */
+    for_each_transfer(ctx, itransfer) {
+        if(itransfer->timeout_flags & (USBI_TRANSFER_TIMEOUT_HANDLED | USBI_TRANSFER_OS_HANDLES_TIMEOUT))
+            continue;
+
+        /* if we've reached transfers of infinite timeout, we're done looking */
+        if(!TIMESPEC_IS_SET(&itransfer->timeout))
+            break;
+
+        next_timeout = itransfer->timeout;
+        break;
+    }
+    usbi_mutex_unlock(&ctx->flying_transfers_lock);
+
+    if(!TIMESPEC_IS_SET(&next_timeout)) {
+        usbi_dbg(ctx, "no URB with timeout or all handled by OS; no timeout!");
+        return 0;
+    }
+
+    usbi_get_monotonic_time(&systime);
+
+    if(!TIMESPEC_CMP(&systime, &next_timeout, <)) {
+        usbi_dbg(ctx, "first timeout already expired");
+        timerclear(tv);
+    }
+    else {
+        TIMESPEC_SUB(&next_timeout, &systime, &next_timeout);
+        TIMESPEC_TO_TIMEVAL(tv, &next_timeout);
+        usbi_dbg(ctx, "next timeout in %ld.%06lds", (long)tv->tv_sec, (long)tv->tv_usec);
+    }
+
+    return 1;
+}
+
+/** \ingroup libusb_poll
+ * Register notification functions for file descriptor additions/removals.
+ * These functions will be invoked for every new or removed file descriptor
+ * that libusb uses as an event source.
+ *
+ * To remove notifiers, pass NULL values for the function pointers.
+ *
+ * Note that file descriptors may have been added even before you register
+ * these notifiers (e.g. at libusb_init() time).
+ *
+ * Additionally, note that the removal notifier may be called during
+ * libusb_exit() (e.g. when it is closing file descriptors that were opened
+ * and added to the poll set at libusb_init() time). If you don't want this,
+ * remove the notifiers immediately before calling libusb_exit().
+ *
+ * \param ctx the context to operate on, or NULL for the default context
+ * \param added_cb pointer to function for addition notifications
+ * \param removed_cb pointer to function for removal notifications
+ * \param user_data User data to be passed back to callbacks (useful for
+ * passing context information)
+ */
+void API_EXPORTED libusb_set_pollfd_notifiers(libusb_context *ctx, libusb_pollfd_added_cb added_cb, libusb_pollfd_removed_cb removed_cb, void *user_data) {
+#if !defined(PLATFORM_WINDOWS)
+    ctx                  = usbi_get_context(ctx);
+    ctx->fd_added_cb     = added_cb;
+    ctx->fd_removed_cb   = removed_cb;
+    ctx->fd_cb_user_data = user_data;
+#else
+    usbi_err(ctx, "external polling of libusb's internal event sources "
+                  "is not yet supported on Windows");
+    UNUSED(added_cb);
+    UNUSED(removed_cb);
+    UNUSED(user_data);
+#endif
+}
+
+/*
+ * Interrupt the iteration of the event handling thread, so that it picks
+ * up the event source change. Callers of this function must hold the event_data_lock.
+ */
+static void usbi_event_source_notification(struct libusb_context *ctx) {
+    unsigned int event_flags;
+
+    /* Record that there is a new poll fd.
+     * Only signal an event if there are no prior pending events. */
+    event_flags = ctx->event_flags;
+    ctx->event_flags |= USBI_EVENT_EVENT_SOURCES_MODIFIED;
+    if(!event_flags)
+        usbi_signal_event(&ctx->event);
+}
+
+/* Add an event source to the list of event sources to be monitored.
+ * poll_events should be specified as a bitmask of events passed to poll(), e.g.
+ * POLLIN and/or POLLOUT. */
+int usbi_add_event_source(struct libusb_context *ctx, usbi_os_handle_t os_handle, short poll_events) {
+    struct usbi_event_source *ievent_source = malloc(sizeof(*ievent_source));
+
+    if(!ievent_source)
+        return LIBUSB_ERROR_NO_MEM;
+
+    usbi_dbg(ctx, "add " USBI_OS_HANDLE_FORMAT_STRING " events %d", os_handle, poll_events);
+    ievent_source->data.os_handle   = os_handle;
+    ievent_source->data.poll_events = poll_events;
+    usbi_mutex_lock(&ctx->event_data_lock);
+    list_add_tail(&ievent_source->list, &ctx->event_sources);
+    usbi_event_source_notification(ctx);
+    usbi_mutex_unlock(&ctx->event_data_lock);
+
+#if !defined(PLATFORM_WINDOWS)
+    if(ctx->fd_added_cb)
+        ctx->fd_added_cb(os_handle, poll_events, ctx->fd_cb_user_data);
+#endif
+
+    return 0;
+}
+
+/* Remove an event source from the list of event sources to be monitored. */
+void usbi_remove_event_source(struct libusb_context *ctx, usbi_os_handle_t os_handle) {
+    struct usbi_event_source *ievent_source;
+    int                       found = 0;
+
+    usbi_dbg(ctx, "remove " USBI_OS_HANDLE_FORMAT_STRING, os_handle);
+    usbi_mutex_lock(&ctx->event_data_lock);
+    for_each_event_source(ctx, ievent_source) {
+        if(ievent_source->data.os_handle == os_handle) {
+            found = 1;
+            break;
+        }
+    }
+
+    if(!found) {
+        usbi_dbg(ctx, "couldn't find " USBI_OS_HANDLE_FORMAT_STRING " to remove", os_handle);
+        usbi_mutex_unlock(&ctx->event_data_lock);
+        return;
+    }
+
+    list_del(&ievent_source->list);
+    list_add_tail(&ievent_source->list, &ctx->removed_event_sources);
+    usbi_event_source_notification(ctx);
+    usbi_mutex_unlock(&ctx->event_data_lock);
+
+#if !defined(PLATFORM_WINDOWS)
+    if(ctx->fd_removed_cb)
+        ctx->fd_removed_cb(os_handle, ctx->fd_cb_user_data);
+#endif
+}
+
+/** \ingroup libusb_poll
+ * Retrieve a list of file descriptors that should be polled by your main loop
+ * as libusb event sources.
+ *
+ * The returned list is NULL-terminated and should be freed with libusb_free_pollfds()
+ * when done. The actual list contents must not be touched.
+ *
+ * As file descriptors are a Unix-specific concept, this function is not
+ * available on Windows and will always return NULL.
+ *
+ * \param ctx the context to operate on, or NULL for the default context
+ * \returns a NULL-terminated list of libusb_pollfd structures
+ * \returns NULL on error
+ * \returns NULL on platforms where the functionality is not available
+ */
+DEFAULT_VISIBILITY
+const struct libusb_pollfd **LIBUSB_CALL libusb_get_pollfds(libusb_context *ctx) {
+#if !defined(PLATFORM_WINDOWS)
+    struct libusb_pollfd    **ret = NULL;
+    struct usbi_event_source *ievent_source;
+    size_t                    i;
+
+    static_assert(sizeof(struct usbi_event_source_data) == sizeof(struct libusb_pollfd), "mismatch between usbi_event_source_data and libusb_pollfd sizes");
+
+    ctx = usbi_get_context(ctx);
+
+    usbi_mutex_lock(&ctx->event_data_lock);
+
+    i = 0;
+    for_each_event_source(ctx, ievent_source) i++;
+
+    ret = calloc(i + 1, sizeof(struct libusb_pollfd *));
+    if(!ret)
+        goto out;
+
+    i                                                  = 0;
+    for_each_event_source(ctx, ievent_source) ret[i++] = (struct libusb_pollfd *)ievent_source;
+
+out:
+    usbi_mutex_unlock(&ctx->event_data_lock);
+    return (const struct libusb_pollfd **)ret;
+#else
+    usbi_err(ctx, "external polling of libusb's internal event sources "
+                  "is not yet supported on Windows");
+    return NULL;
+#endif
+}
+
+/** \ingroup libusb_poll
+ * Free a list of libusb_pollfd structures. This should be called for all
+ * pollfd lists allocated with libusb_get_pollfds().
+ *
+ * Since version 1.0.20, \ref LIBUSB_API_VERSION >= 0x01000104
+ *
+ * It is legal to call this function with a NULL pollfd list. In this case,
+ * the function will simply do nothing.
+ *
+ * \param pollfds the list of libusb_pollfd structures to free
+ */
+void API_EXPORTED libusb_free_pollfds(const struct libusb_pollfd **pollfds) {
+#if !defined(PLATFORM_WINDOWS)
+    free((void *)pollfds);
+#else
+    UNUSED(pollfds);
+#endif
+}
+
+/* Backends may call this from handle_events to report disconnection of a
+ * device. This function ensures transfers get cancelled appropriately.
+ * Callers of this function must hold the events_lock.
+ */
+void usbi_handle_disconnect(struct libusb_device_handle *dev_handle) {
+    struct libusb_context *ctx = HANDLE_CTX(dev_handle);
+    struct usbi_transfer  *cur;
+    struct usbi_transfer  *to_cancel;
+
+    usbi_dbg(ctx, "device %d.%d", dev_handle->dev->bus_number, dev_handle->dev->device_address);
+
+    /* terminate all pending transfers with the LIBUSB_TRANSFER_NO_DEVICE
+     * status code.
+     *
+     * when we find a transfer for this device on the list, there are two
+     * possible scenarios:
+     * 1. the transfer is currently in-flight, in which case we terminate the
+     *    transfer here
+     * 2. the transfer has been added to the flying transfer list by
+     *    libusb_submit_transfer, has failed to submit and
+     *    libusb_submit_transfer is waiting for us to release the
+     *    flying_transfers_lock to remove it, so we ignore it
+     */
+
+    while(1) {
+        to_cancel = NULL;
+        usbi_mutex_lock(&ctx->flying_transfers_lock);
+        for_each_transfer(ctx, cur) {
+            if(USBI_TRANSFER_TO_LIBUSB_TRANSFER(cur)->dev_handle == dev_handle) {
+                usbi_mutex_lock(&cur->lock);
+                if(cur->state_flags & USBI_TRANSFER_IN_FLIGHT)
+                    to_cancel = cur;
+                usbi_mutex_unlock(&cur->lock);
+
+                if(to_cancel)
+                    break;
+            }
+        }
+        usbi_mutex_unlock(&ctx->flying_transfers_lock);
+
+        if(!to_cancel)
+            break;
+
+        usbi_dbg(ctx, "cancelling transfer %p from disconnect", (void *)USBI_TRANSFER_TO_LIBUSB_TRANSFER(to_cancel));
+
+        usbi_mutex_lock(&to_cancel->lock);
+        usbi_backend.clear_transfer_priv(to_cancel);
+        usbi_mutex_unlock(&to_cancel->lock);
+        usbi_handle_transfer_completion(to_cancel, LIBUSB_TRANSFER_NO_DEVICE);
+    }
+}
diff --git a/3rdparty/libusb/src/libusb/libusb-1.0.def b/3rdparty/libusb/src/libusb/libusb-1.0.def
new file mode 100644
index 00000000..6d7caa7f
--- /dev/null
+++ b/3rdparty/libusb/src/libusb/libusb-1.0.def
@@ -0,0 +1,195 @@
+LIBRARY "libusb-1.0.dll"
+EXPORTS
+  libusb_alloc_streams
+  libusb_alloc_streams@16 = libusb_alloc_streams
+  libusb_alloc_transfer
+  libusb_alloc_transfer@4 = libusb_alloc_transfer
+  libusb_attach_kernel_driver
+  libusb_attach_kernel_driver@8 = libusb_attach_kernel_driver
+  libusb_bulk_transfer
+  libusb_bulk_transfer@24 = libusb_bulk_transfer
+  libusb_cancel_transfer
+  libusb_cancel_transfer@4 = libusb_cancel_transfer
+  libusb_claim_interface
+  libusb_claim_interface@8 = libusb_claim_interface
+  libusb_clear_halt
+  libusb_clear_halt@8 = libusb_clear_halt
+  libusb_close
+  libusb_close@4 = libusb_close
+  libusb_control_transfer
+  libusb_control_transfer@32 = libusb_control_transfer
+  libusb_detach_kernel_driver
+  libusb_detach_kernel_driver@8 = libusb_detach_kernel_driver
+  libusb_dev_mem_alloc
+  libusb_dev_mem_alloc@8 = libusb_dev_mem_alloc
+  libusb_dev_mem_free
+  libusb_dev_mem_free@12 = libusb_dev_mem_free
+  libusb_error_name
+  libusb_error_name@4 = libusb_error_name
+  libusb_event_handler_active
+  libusb_event_handler_active@4 = libusb_event_handler_active
+  libusb_event_handling_ok
+  libusb_event_handling_ok@4 = libusb_event_handling_ok
+  libusb_exit
+  libusb_exit@4 = libusb_exit
+  libusb_free_bos_descriptor
+  libusb_free_bos_descriptor@4 = libusb_free_bos_descriptor
+  libusb_free_config_descriptor
+  libusb_free_config_descriptor@4 = libusb_free_config_descriptor
+  libusb_free_container_id_descriptor
+  libusb_free_container_id_descriptor@4 = libusb_free_container_id_descriptor
+  libusb_free_device_list
+  libusb_free_device_list@8 = libusb_free_device_list
+  libusb_free_interface_association_descriptors
+  libusb_free_interface_association_descriptors@4 = libusb_free_interface_association_descriptors
+  libusb_free_platform_descriptor
+  libusb_free_platform_descriptor@4 = libusb_free_platform_descriptor
+  libusb_free_pollfds
+  libusb_free_pollfds@4 = libusb_free_pollfds
+  libusb_free_ss_endpoint_companion_descriptor
+  libusb_free_ss_endpoint_companion_descriptor@4 = libusb_free_ss_endpoint_companion_descriptor
+  libusb_free_ss_usb_device_capability_descriptor
+  libusb_free_ss_usb_device_capability_descriptor@4 = libusb_free_ss_usb_device_capability_descriptor
+  libusb_free_streams
+  libusb_free_streams@12 = libusb_free_streams
+  libusb_free_transfer
+  libusb_free_transfer@4 = libusb_free_transfer
+  libusb_free_usb_2_0_extension_descriptor
+  libusb_free_usb_2_0_extension_descriptor@4 = libusb_free_usb_2_0_extension_descriptor
+  libusb_get_active_config_descriptor
+  libusb_get_active_config_descriptor@8 = libusb_get_active_config_descriptor
+  libusb_get_active_interface_association_descriptors
+  libusb_get_active_interface_association_descriptors@8 = libusb_get_active_interface_association_descriptors
+  libusb_get_bos_descriptor
+  libusb_get_bos_descriptor@8 = libusb_get_bos_descriptor
+  libusb_get_bus_number
+  libusb_get_bus_number@4 = libusb_get_bus_number
+  libusb_get_config_descriptor
+  libusb_get_config_descriptor@12 = libusb_get_config_descriptor
+  libusb_get_config_descriptor_by_value
+  libusb_get_config_descriptor_by_value@12 = libusb_get_config_descriptor_by_value
+  libusb_get_configuration
+  libusb_get_configuration@8 = libusb_get_configuration
+  libusb_get_container_id_descriptor
+  libusb_get_container_id_descriptor@12 = libusb_get_container_id_descriptor
+  libusb_get_device
+  libusb_get_device@4 = libusb_get_device
+  libusb_get_device_address
+  libusb_get_device_address@4 = libusb_get_device_address
+  libusb_get_device_descriptor
+  libusb_get_device_descriptor@8 = libusb_get_device_descriptor
+  libusb_get_device_list
+  libusb_get_device_list@8 = libusb_get_device_list
+  libusb_get_device_speed
+  libusb_get_device_speed@4 = libusb_get_device_speed
+  libusb_get_interface_association_descriptors
+  libusb_get_interface_association_descriptors@12 = libusb_get_interface_association_descriptors
+  libusb_get_max_alt_packet_size
+  libusb_get_max_alt_packet_size@16 = libusb_get_max_alt_packet_size
+  libusb_get_max_iso_packet_size
+  libusb_get_max_iso_packet_size@8 = libusb_get_max_iso_packet_size
+  libusb_get_max_packet_size
+  libusb_get_max_packet_size@8 = libusb_get_max_packet_size
+  libusb_get_next_timeout
+  libusb_get_next_timeout@8 = libusb_get_next_timeout
+  libusb_get_parent
+  libusb_get_parent@4 = libusb_get_parent
+  libusb_get_platform_descriptor
+  libusb_get_platform_descriptor@12 = libusb_get_platform_descriptor
+  libusb_get_pollfds
+  libusb_get_pollfds@4 = libusb_get_pollfds
+  libusb_get_port_number
+  libusb_get_port_number@4 = libusb_get_port_number
+  libusb_get_port_numbers
+  libusb_get_port_numbers@12 = libusb_get_port_numbers
+  libusb_get_port_path
+  libusb_get_port_path@16 = libusb_get_port_path
+  libusb_get_ss_endpoint_companion_descriptor
+  libusb_get_ss_endpoint_companion_descriptor@12 = libusb_get_ss_endpoint_companion_descriptor
+  libusb_get_ss_usb_device_capability_descriptor
+  libusb_get_ss_usb_device_capability_descriptor@12 = libusb_get_ss_usb_device_capability_descriptor
+  libusb_get_string_descriptor_ascii
+  libusb_get_string_descriptor_ascii@16 = libusb_get_string_descriptor_ascii
+  libusb_get_usb_2_0_extension_descriptor
+  libusb_get_usb_2_0_extension_descriptor@12 = libusb_get_usb_2_0_extension_descriptor
+  libusb_get_version
+  libusb_get_version@0 = libusb_get_version
+  libusb_handle_events
+  libusb_handle_events@4 = libusb_handle_events
+  libusb_handle_events_completed
+  libusb_handle_events_completed@8 = libusb_handle_events_completed
+  libusb_handle_events_locked
+  libusb_handle_events_locked@8 = libusb_handle_events_locked
+  libusb_handle_events_timeout
+  libusb_handle_events_timeout@8 = libusb_handle_events_timeout
+  libusb_handle_events_timeout_completed
+  libusb_handle_events_timeout_completed@12 = libusb_handle_events_timeout_completed
+  libusb_has_capability
+  libusb_has_capability@4 = libusb_has_capability
+  libusb_hotplug_deregister_callback
+  libusb_hotplug_deregister_callback@8 = libusb_hotplug_deregister_callback
+  libusb_hotplug_get_user_data
+  libusb_hotplug_get_user_data@8 = libusb_hotplug_get_user_data
+  libusb_hotplug_register_callback
+  libusb_hotplug_register_callback@36 = libusb_hotplug_register_callback
+  libusb_init
+  libusb_init@4 = libusb_init
+  libusb_init_context
+  libusb_init_context@12 = libusb_init_context
+  libusb_interrupt_event_handler
+  libusb_interrupt_event_handler@4 = libusb_interrupt_event_handler
+  libusb_interrupt_transfer
+  libusb_interrupt_transfer@24 = libusb_interrupt_transfer
+  libusb_kernel_driver_active
+  libusb_kernel_driver_active@8 = libusb_kernel_driver_active
+  libusb_lock_event_waiters
+  libusb_lock_event_waiters@4 = libusb_lock_event_waiters
+  libusb_lock_events
+  libusb_lock_events@4 = libusb_lock_events
+  libusb_open
+  libusb_open@8 = libusb_open
+  libusb_open_device_with_vid_pid
+  libusb_open_device_with_vid_pid@12 = libusb_open_device_with_vid_pid
+  libusb_pollfds_handle_timeouts
+  libusb_pollfds_handle_timeouts@4 = libusb_pollfds_handle_timeouts
+  libusb_ref_device
+  libusb_ref_device@4 = libusb_ref_device
+  libusb_release_interface
+  libusb_release_interface@8 = libusb_release_interface
+  libusb_reset_device
+  libusb_reset_device@4 = libusb_reset_device
+  libusb_set_auto_detach_kernel_driver
+  libusb_set_auto_detach_kernel_driver@8 = libusb_set_auto_detach_kernel_driver
+  libusb_set_configuration
+  libusb_set_configuration@8 = libusb_set_configuration
+  libusb_set_debug
+  libusb_set_debug@8 = libusb_set_debug
+  libusb_set_interface_alt_setting
+  libusb_set_interface_alt_setting@12 = libusb_set_interface_alt_setting
+  libusb_set_log_cb
+  libusb_set_log_cb@12 = libusb_set_log_cb
+  libusb_set_option
+  libusb_set_pollfd_notifiers
+  libusb_set_pollfd_notifiers@16 = libusb_set_pollfd_notifiers
+  libusb_setlocale
+  libusb_setlocale@4 = libusb_setlocale
+  libusb_strerror
+  libusb_strerror@4 = libusb_strerror
+  libusb_submit_transfer
+  libusb_submit_transfer@4 = libusb_submit_transfer
+  libusb_transfer_get_stream_id
+  libusb_transfer_get_stream_id@4 = libusb_transfer_get_stream_id
+  libusb_transfer_set_stream_id
+  libusb_transfer_set_stream_id@8 = libusb_transfer_set_stream_id
+  libusb_try_lock_events
+  libusb_try_lock_events@4 = libusb_try_lock_events
+  libusb_unlock_event_waiters
+  libusb_unlock_event_waiters@4 = libusb_unlock_event_waiters
+  libusb_unlock_events
+  libusb_unlock_events@4 = libusb_unlock_events
+  libusb_unref_device
+  libusb_unref_device@4 = libusb_unref_device
+  libusb_wait_for_event
+  libusb_wait_for_event@8 = libusb_wait_for_event
+  libusb_wrap_sys_device
+  libusb_wrap_sys_device@12 = libusb_wrap_sys_device
diff --git a/3rdparty/libusb/src/libusb/libusb-1.0.rc b/3rdparty/libusb/src/libusb/libusb-1.0.rc
new file mode 100644
index 00000000..bcb10fac
--- /dev/null
+++ b/3rdparty/libusb/src/libusb/libusb-1.0.rc
@@ -0,0 +1,53 @@
+/*
+ * For Windows: input this file to the Resource Compiler to produce a binary
+ * .res file. This is then embedded in the resultant library (like any other
+ * compilation object).
+ * The information can then be queried using standard APIs and can also be
+ * viewed with utilities such as Windows Explorer.
+ */
+#include "winresrc.h"
+
+#include "version.h"
+#ifndef LIBUSB_VERSIONSTRING
+#define LU_STR(s) #s
+#define LU_XSTR(s) LU_STR(s)
+#define LIBUSB_VERSIONSTRING \
+	LU_XSTR(LIBUSB_MAJOR) "." LU_XSTR(LIBUSB_MINOR) "." \
+	LU_XSTR(LIBUSB_MICRO) "." LU_XSTR(LIBUSB_NANO) LIBUSB_RC "\0"
+#endif
+
+VS_VERSION_INFO VERSIONINFO
+ FILEVERSION LIBUSB_MAJOR,LIBUSB_MINOR,LIBUSB_MICRO,LIBUSB_NANO
+ PRODUCTVERSION LIBUSB_MAJOR,LIBUSB_MINOR,LIBUSB_MICRO,LIBUSB_NANO
+ FILEFLAGSMASK 0x3fL
+#ifdef _DEBUG
+ FILEFLAGS 0x1L
+#else
+ FILEFLAGS 0x0L
+#endif
+ FILEOS 0x40004L
+ FILETYPE 0x2L
+ FILESUBTYPE 0x0L
+BEGIN
+	BLOCK "StringFileInfo"
+	BEGIN
+		BLOCK "040904b0"
+		BEGIN
+			VALUE "CompanyName", "libusb.info\0"
+			VALUE "FileDescription", "C library for writing portable USB drivers in userspace\0"
+			VALUE "FileVersion", LIBUSB_VERSIONSTRING
+			VALUE "InternalName", "libusb\0"
+			VALUE "LegalCopyright", "See individual source files, GNU LGPL v2.1 or later.\0"
+			VALUE "LegalTrademarks", "http://www.gnu.org/licenses/lgpl-2.1.html\0"
+			VALUE "OriginalFilename", "libusb-1.0.dll\0"
+			VALUE "PrivateBuild", "\0"
+			VALUE "ProductName", "libusb-1.0\0"
+			VALUE "ProductVersion", LIBUSB_VERSIONSTRING
+			VALUE "SpecialBuild", "\0"
+		END
+	END
+	BLOCK "VarFileInfo"
+	BEGIN
+		VALUE "Translation", 0x409, 1200
+	END
+END
diff --git a/3rdparty/libusb/src/libusb/libusb.h b/3rdparty/libusb/src/libusb/libusb.h
new file mode 100644
index 00000000..30b0c436
--- /dev/null
+++ b/3rdparty/libusb/src/libusb/libusb.h
@@ -0,0 +1,2229 @@
+/*
+ * Public libusb header file
+ * Copyright © 2001 Johannes Erdfelt <johannes@erdfelt.com>
+ * Copyright © 2007-2008 Daniel Drake <dsd@gentoo.org>
+ * Copyright © 2012 Pete Batard <pete@akeo.ie>
+ * Copyright © 2012-2021 Nathan Hjelm <hjelmn@cs.unm.edu>
+ * Copyright © 2014-2020 Chris Dickens <christopher.a.dickens@gmail.com>
+ * For more information, please visit: http://libusb.info
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef LIBUSB_H
+#define LIBUSB_H
+
+#if defined(_MSC_VER)
+#pragma warning(push)
+/* Disable: warning C4200: nonstandard extension used : zero-sized array in struct/union */
+#pragma warning(disable : 4200)
+/* on MS environments, the inline keyword is available in C++ only */
+#if !defined(__cplusplus)
+#define inline __inline
+#endif
+/* ssize_t is also not available */
+#ifndef _SSIZE_T_DEFINED
+#define _SSIZE_T_DEFINED
+#include <basetsd.h>
+typedef SSIZE_T ssize_t;
+#endif /* _SSIZE_T_DEFINED */
+#endif /* _MSC_VER */
+
+#include <limits.h>
+#include <stdint.h>
+#include <sys/types.h>
+#if !defined(_MSC_VER)
+#include <sys/time.h>
+#endif
+#include <time.h>
+
+#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)
+#define ZERO_SIZED_ARRAY /* [] - valid C99 code */
+#else
+#define ZERO_SIZED_ARRAY 0 /* [0] - non-standard, but usually working code */
+#endif                     /* __STDC_VERSION__ */
+
+/* 'interface' might be defined as a macro on Windows, so we need to
+ * undefine it so as not to break the current libusb API, because
+ * libusb_config_descriptor has an 'interface' member
+ * As this can be problematic if you include windows.h after libusb.h
+ * in your sources, we force windows.h to be included first. */
+#if defined(_WIN32) || defined(__CYGWIN__)
+#include <windows.h>
+#if defined(interface)
+#undef interface
+#endif
+#if !defined(__CYGWIN__)
+#include <winsock.h>
+#endif
+#endif /* _WIN32 || __CYGWIN__ */
+
+#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5))
+#define LIBUSB_DEPRECATED_FOR(f) __attribute__((deprecated("Use " #f " instead")))
+#elif defined(__GNUC__) && (__GNUC__ >= 3)
+#define LIBUSB_DEPRECATED_FOR(f) __attribute__((deprecated))
+#elif defined(_MSC_VER)
+#define LIBUSB_DEPRECATED_FOR(f) __declspec(deprecated("Use " #f " instead"))
+#else
+#define LIBUSB_DEPRECATED_FOR(f)
+#endif /* __GNUC__ */
+
+#if defined(__GNUC__)
+#define LIBUSB_PACKED __attribute__((packed))
+#else
+#define LIBUSB_PACKED
+#endif /* __GNUC__ */
+
+/** \def LIBUSB_CALL
+ * \ingroup libusb_misc
+ * libusb's Windows calling convention.
+ *
+ * Under Windows, the selection of available compilers and configurations
+ * means that, unlike other platforms, there is not <em>one true calling
+ * convention</em> (calling convention: the manner in which parameters are
+ * passed to functions in the generated assembly code).
+ *
+ * Matching the Windows API itself, libusb uses the WINAPI convention (which
+ * translates to the <tt>stdcall</tt> convention) and guarantees that the
+ * library is compiled in this way. The public header file also includes
+ * appropriate annotations so that your own software will use the right
+ * convention, even if another convention is being used by default within
+ * your codebase.
+ *
+ * The one consideration that you must apply in your software is to mark
+ * all functions which you use as libusb callbacks with this LIBUSB_CALL
+ * annotation, so that they too get compiled for the correct calling
+ * convention.
+ *
+ * On non-Windows operating systems, this macro is defined as nothing. This
+ * means that you can apply it to your code without worrying about
+ * cross-platform compatibility.
+ */
+/* LIBUSB_CALL must be defined on both definition and declaration of libusb
+ * functions. You'd think that declaration would be enough, but cygwin will
+ * complain about conflicting types unless both are marked this way.
+ * The placement of this macro is important too; it must appear after the
+ * return type, before the function name. See internal documentation for
+ * API_EXPORTED.
+ */
+#if defined(_WIN32) || defined(__CYGWIN__)
+#define LIBUSB_CALL WINAPI
+#define LIBUSB_CALLV WINAPIV
+#else
+#define LIBUSB_CALL
+#define LIBUSB_CALLV
+#endif /* _WIN32 || __CYGWIN__ */
+
+/** \def LIBUSB_API_VERSION
+ * \ingroup libusb_misc
+ * libusb's API version.
+ *
+ * Since version 1.0.13, to help with feature detection, libusb defines
+ * a LIBUSB_API_VERSION macro that gets increased every time there is a
+ * significant change to the API, such as the introduction of a new call,
+ * the definition of a new macro/enum member, or any other element that
+ * libusb applications may want to detect at compilation time.
+ *
+ * The macro is typically used in an application as follows:
+ * \code
+ * #if defined(LIBUSB_API_VERSION) && (LIBUSB_API_VERSION >= 0x01001234)
+ * // Use one of the newer features from the libusb API
+ * #endif
+ * \endcode
+ *
+ * Internally, LIBUSB_API_VERSION is defined as follows:
+ * (libusb major << 24) | (libusb minor << 16) | (16 bit incremental)
+ */
+#define LIBUSB_API_VERSION 0x0100010A
+
+/* The following is kept for compatibility, but will be deprecated in the future */
+#define LIBUSBX_API_VERSION LIBUSB_API_VERSION
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+/**
+ * \ingroup libusb_misc
+ * Convert a 16-bit value from host-endian to little-endian format. On
+ * little endian systems, this function does nothing. On big endian systems,
+ * the bytes are swapped.
+ * \param x the host-endian value to convert
+ * \returns the value in little-endian byte order
+ */
+static inline uint16_t libusb_cpu_to_le16(const uint16_t x) {
+    union {
+        uint8_t  b8[2];
+        uint16_t b16;
+    } _tmp;
+    _tmp.b8[1] = (uint8_t)(x >> 8);
+    _tmp.b8[0] = (uint8_t)(x & 0xff);
+    return _tmp.b16;
+}
+
+/** \def libusb_le16_to_cpu
+ * \ingroup libusb_misc
+ * Convert a 16-bit value from little-endian to host-endian format. On
+ * little endian systems, this function does nothing. On big endian systems,
+ * the bytes are swapped.
+ * \param x the little-endian value to convert
+ * \returns the value in host-endian byte order
+ */
+#define libusb_le16_to_cpu libusb_cpu_to_le16
+
+/* standard USB stuff */
+
+/** \ingroup libusb_desc
+ * Device and/or Interface Class codes */
+enum libusb_class_code {
+    /** In the context of a \ref libusb_device_descriptor "device descriptor",
+     * this bDeviceClass value indicates that each interface specifies its
+     * own class information and all interfaces operate independently.
+     */
+    LIBUSB_CLASS_PER_INTERFACE = 0x00,
+
+    /** Audio class */
+    LIBUSB_CLASS_AUDIO = 0x01,
+
+    /** Communications class */
+    LIBUSB_CLASS_COMM = 0x02,
+
+    /** Human Interface Device class */
+    LIBUSB_CLASS_HID = 0x03,
+
+    /** Physical */
+    LIBUSB_CLASS_PHYSICAL = 0x05,
+
+    /** Image class */
+    LIBUSB_CLASS_IMAGE = 0x06,
+    LIBUSB_CLASS_PTP   = 0x06, /* legacy name from libusb-0.1 usb.h */
+
+    /** Printer class */
+    LIBUSB_CLASS_PRINTER = 0x07,
+
+    /** Mass storage class */
+    LIBUSB_CLASS_MASS_STORAGE = 0x08,
+
+    /** Hub class */
+    LIBUSB_CLASS_HUB = 0x09,
+
+    /** Data class */
+    LIBUSB_CLASS_DATA = 0x0a,
+
+    /** Smart Card */
+    LIBUSB_CLASS_SMART_CARD = 0x0b,
+
+    /** Content Security */
+    LIBUSB_CLASS_CONTENT_SECURITY = 0x0d,
+
+    /** Video */
+    LIBUSB_CLASS_VIDEO = 0x0e,
+
+    /** Personal Healthcare */
+    LIBUSB_CLASS_PERSONAL_HEALTHCARE = 0x0f,
+
+    /** Diagnostic Device */
+    LIBUSB_CLASS_DIAGNOSTIC_DEVICE = 0xdc,
+
+    /** Wireless class */
+    LIBUSB_CLASS_WIRELESS = 0xe0,
+
+    /** Miscellaneous class */
+    LIBUSB_CLASS_MISCELLANEOUS = 0xef,
+
+    /** Application class */
+    LIBUSB_CLASS_APPLICATION = 0xfe,
+
+    /** Class is vendor-specific */
+    LIBUSB_CLASS_VENDOR_SPEC = 0xff
+};
+
+/** \ingroup libusb_desc
+ * Descriptor types as defined by the USB specification. */
+enum libusb_descriptor_type {
+    /** Device descriptor. See libusb_device_descriptor. */
+    LIBUSB_DT_DEVICE = 0x01,
+
+    /** Configuration descriptor. See libusb_config_descriptor. */
+    LIBUSB_DT_CONFIG = 0x02,
+
+    /** String descriptor */
+    LIBUSB_DT_STRING = 0x03,
+
+    /** Interface descriptor. See libusb_interface_descriptor. */
+    LIBUSB_DT_INTERFACE = 0x04,
+
+    /** Endpoint descriptor. See libusb_endpoint_descriptor. */
+    LIBUSB_DT_ENDPOINT = 0x05,
+
+    /** Interface Association Descriptor.
+     * See libusb_interface_association_descriptor */
+    LIBUSB_DT_INTERFACE_ASSOCIATION = 0x0b,
+
+    /** BOS descriptor */
+    LIBUSB_DT_BOS = 0x0f,
+
+    /** Device Capability descriptor */
+    LIBUSB_DT_DEVICE_CAPABILITY = 0x10,
+
+    /** HID descriptor */
+    LIBUSB_DT_HID = 0x21,
+
+    /** HID report descriptor */
+    LIBUSB_DT_REPORT = 0x22,
+
+    /** Physical descriptor */
+    LIBUSB_DT_PHYSICAL = 0x23,
+
+    /** Hub descriptor */
+    LIBUSB_DT_HUB = 0x29,
+
+    /** SuperSpeed Hub descriptor */
+    LIBUSB_DT_SUPERSPEED_HUB = 0x2a,
+
+    /** SuperSpeed Endpoint Companion descriptor */
+    LIBUSB_DT_SS_ENDPOINT_COMPANION = 0x30
+};
+
+/* Descriptor sizes per descriptor type */
+#define LIBUSB_DT_DEVICE_SIZE 18
+#define LIBUSB_DT_CONFIG_SIZE 9
+#define LIBUSB_DT_INTERFACE_SIZE 9
+#define LIBUSB_DT_ENDPOINT_SIZE 7
+#define LIBUSB_DT_ENDPOINT_AUDIO_SIZE 9 /* Audio extension */
+#define LIBUSB_DT_HUB_NONVAR_SIZE 7
+#define LIBUSB_DT_SS_ENDPOINT_COMPANION_SIZE 6
+#define LIBUSB_DT_BOS_SIZE 5
+#define LIBUSB_DT_DEVICE_CAPABILITY_SIZE 3
+
+/* BOS descriptor sizes */
+#define LIBUSB_BT_USB_2_0_EXTENSION_SIZE 7
+#define LIBUSB_BT_SS_USB_DEVICE_CAPABILITY_SIZE 10
+#define LIBUSB_BT_CONTAINER_ID_SIZE 20
+#define LIBUSB_BT_PLATFORM_DESCRIPTOR_MIN_SIZE 20
+
+/* We unwrap the BOS => define its max size */
+#define LIBUSB_DT_BOS_MAX_SIZE (LIBUSB_DT_BOS_SIZE + LIBUSB_BT_USB_2_0_EXTENSION_SIZE + LIBUSB_BT_SS_USB_DEVICE_CAPABILITY_SIZE + LIBUSB_BT_CONTAINER_ID_SIZE)
+
+#define LIBUSB_ENDPOINT_ADDRESS_MASK 0x0f /* in bEndpointAddress */
+#define LIBUSB_ENDPOINT_DIR_MASK 0x80
+
+/** \ingroup libusb_desc
+ * Endpoint direction. Values for bit 7 of the
+ * \ref libusb_endpoint_descriptor::bEndpointAddress "endpoint address" scheme.
+ */
+enum libusb_endpoint_direction {
+    /** Out: host-to-device */
+    LIBUSB_ENDPOINT_OUT = 0x00,
+
+    /** In: device-to-host */
+    LIBUSB_ENDPOINT_IN = 0x80
+};
+
+#define LIBUSB_TRANSFER_TYPE_MASK 0x03 /* in bmAttributes */
+
+/** \ingroup libusb_desc
+ * Endpoint transfer type. Values for bits 0:1 of the
+ * \ref libusb_endpoint_descriptor::bmAttributes "endpoint attributes" field.
+ */
+enum libusb_endpoint_transfer_type {
+    /** Control endpoint */
+    LIBUSB_ENDPOINT_TRANSFER_TYPE_CONTROL = 0x0,
+
+    /** Isochronous endpoint */
+    LIBUSB_ENDPOINT_TRANSFER_TYPE_ISOCHRONOUS = 0x1,
+
+    /** Bulk endpoint */
+    LIBUSB_ENDPOINT_TRANSFER_TYPE_BULK = 0x2,
+
+    /** Interrupt endpoint */
+    LIBUSB_ENDPOINT_TRANSFER_TYPE_INTERRUPT = 0x3
+};
+
+/** \ingroup libusb_misc
+ * Standard requests, as defined in table 9-5 of the USB 3.0 specifications */
+enum libusb_standard_request {
+    /** Request status of the specific recipient */
+    LIBUSB_REQUEST_GET_STATUS = 0x00,
+
+    /** Clear or disable a specific feature */
+    LIBUSB_REQUEST_CLEAR_FEATURE = 0x01,
+
+    /* 0x02 is reserved */
+
+    /** Set or enable a specific feature */
+    LIBUSB_REQUEST_SET_FEATURE = 0x03,
+
+    /* 0x04 is reserved */
+
+    /** Set device address for all future accesses */
+    LIBUSB_REQUEST_SET_ADDRESS = 0x05,
+
+    /** Get the specified descriptor */
+    LIBUSB_REQUEST_GET_DESCRIPTOR = 0x06,
+
+    /** Used to update existing descriptors or add new descriptors */
+    LIBUSB_REQUEST_SET_DESCRIPTOR = 0x07,
+
+    /** Get the current device configuration value */
+    LIBUSB_REQUEST_GET_CONFIGURATION = 0x08,
+
+    /** Set device configuration */
+    LIBUSB_REQUEST_SET_CONFIGURATION = 0x09,
+
+    /** Return the selected alternate setting for the specified interface */
+    LIBUSB_REQUEST_GET_INTERFACE = 0x0a,
+
+    /** Select an alternate interface for the specified interface */
+    LIBUSB_REQUEST_SET_INTERFACE = 0x0b,
+
+    /** Set then report an endpoint's synchronization frame */
+    LIBUSB_REQUEST_SYNCH_FRAME = 0x0c,
+
+    /** Sets both the U1 and U2 Exit Latency */
+    LIBUSB_REQUEST_SET_SEL = 0x30,
+
+    /** Delay from the time a host transmits a packet to the time it is
+     * received by the device. */
+    LIBUSB_SET_ISOCH_DELAY = 0x31
+};
+
+/** \ingroup libusb_misc
+ * Request type bits of the
+ * \ref libusb_control_setup::bmRequestType "bmRequestType" field in control
+ * transfers. */
+enum libusb_request_type {
+    /** Standard */
+    LIBUSB_REQUEST_TYPE_STANDARD = (0x00 << 5),
+
+    /** Class */
+    LIBUSB_REQUEST_TYPE_CLASS = (0x01 << 5),
+
+    /** Vendor */
+    LIBUSB_REQUEST_TYPE_VENDOR = (0x02 << 5),
+
+    /** Reserved */
+    LIBUSB_REQUEST_TYPE_RESERVED = (0x03 << 5)
+};
+
+/** \ingroup libusb_misc
+ * Recipient bits of the
+ * \ref libusb_control_setup::bmRequestType "bmRequestType" field in control
+ * transfers. Values 4 through 31 are reserved. */
+enum libusb_request_recipient {
+    /** Device */
+    LIBUSB_RECIPIENT_DEVICE = 0x00,
+
+    /** Interface */
+    LIBUSB_RECIPIENT_INTERFACE = 0x01,
+
+    /** Endpoint */
+    LIBUSB_RECIPIENT_ENDPOINT = 0x02,
+
+    /** Other */
+    LIBUSB_RECIPIENT_OTHER = 0x03
+};
+
+#define LIBUSB_ISO_SYNC_TYPE_MASK 0x0c
+
+/** \ingroup libusb_desc
+ * Synchronization type for isochronous endpoints. Values for bits 2:3 of the
+ * \ref libusb_endpoint_descriptor::bmAttributes "bmAttributes" field in
+ * libusb_endpoint_descriptor.
+ */
+enum libusb_iso_sync_type {
+    /** No synchronization */
+    LIBUSB_ISO_SYNC_TYPE_NONE = 0x0,
+
+    /** Asynchronous */
+    LIBUSB_ISO_SYNC_TYPE_ASYNC = 0x1,
+
+    /** Adaptive */
+    LIBUSB_ISO_SYNC_TYPE_ADAPTIVE = 0x2,
+
+    /** Synchronous */
+    LIBUSB_ISO_SYNC_TYPE_SYNC = 0x3
+};
+
+#define LIBUSB_ISO_USAGE_TYPE_MASK 0x30
+
+/** \ingroup libusb_desc
+ * Usage type for isochronous endpoints. Values for bits 4:5 of the
+ * \ref libusb_endpoint_descriptor::bmAttributes "bmAttributes" field in
+ * libusb_endpoint_descriptor.
+ */
+enum libusb_iso_usage_type {
+    /** Data endpoint */
+    LIBUSB_ISO_USAGE_TYPE_DATA = 0x0,
+
+    /** Feedback endpoint */
+    LIBUSB_ISO_USAGE_TYPE_FEEDBACK = 0x1,
+
+    /** Implicit feedback Data endpoint */
+    LIBUSB_ISO_USAGE_TYPE_IMPLICIT = 0x2
+};
+
+/** \ingroup libusb_desc
+ * Supported speeds (wSpeedSupported) bitfield. Indicates what
+ * speeds the device supports.
+ */
+enum libusb_supported_speed {
+    /** Low speed operation supported (1.5MBit/s). */
+    LIBUSB_LOW_SPEED_OPERATION = (1 << 0),
+
+    /** Full speed operation supported (12MBit/s). */
+    LIBUSB_FULL_SPEED_OPERATION = (1 << 1),
+
+    /** High speed operation supported (480MBit/s). */
+    LIBUSB_HIGH_SPEED_OPERATION = (1 << 2),
+
+    /** Superspeed operation supported (5000MBit/s). */
+    LIBUSB_SUPER_SPEED_OPERATION = (1 << 3)
+};
+
+/** \ingroup libusb_desc
+ * Masks for the bits of the
+ * \ref libusb_usb_2_0_extension_descriptor::bmAttributes "bmAttributes" field
+ * of the USB 2.0 Extension descriptor.
+ */
+enum libusb_usb_2_0_extension_attributes {
+    /** Supports Link Power Management (LPM) */
+    LIBUSB_BM_LPM_SUPPORT = (1 << 1)
+};
+
+/** \ingroup libusb_desc
+ * Masks for the bits of the
+ * \ref libusb_ss_usb_device_capability_descriptor::bmAttributes "bmAttributes" field
+ * field of the SuperSpeed USB Device Capability descriptor.
+ */
+enum libusb_ss_usb_device_capability_attributes {
+    /** Supports Latency Tolerance Messages (LTM) */
+    LIBUSB_BM_LTM_SUPPORT = (1 << 1)
+};
+
+/** \ingroup libusb_desc
+ * USB capability types
+ */
+enum libusb_bos_type {
+    /** Wireless USB device capability */
+    LIBUSB_BT_WIRELESS_USB_DEVICE_CAPABILITY = 0x01,
+
+    /** USB 2.0 extensions */
+    LIBUSB_BT_USB_2_0_EXTENSION = 0x02,
+
+    /** SuperSpeed USB device capability */
+    LIBUSB_BT_SS_USB_DEVICE_CAPABILITY = 0x03,
+
+    /** Container ID type */
+    LIBUSB_BT_CONTAINER_ID = 0x04,
+
+    /** Platform descriptor */
+    LIBUSB_BT_PLATFORM_DESCRIPTOR = 0x05
+};
+
+/** \ingroup libusb_desc
+ * A structure representing the standard USB device descriptor. This
+ * descriptor is documented in section 9.6.1 of the USB 3.0 specification.
+ * All multiple-byte fields are represented in host-endian format.
+ */
+struct libusb_device_descriptor {
+    /** Size of this descriptor (in bytes) */
+    uint8_t bLength;
+
+    /** Descriptor type. Will have value
+     * \ref libusb_descriptor_type::LIBUSB_DT_DEVICE LIBUSB_DT_DEVICE in this
+     * context. */
+    uint8_t bDescriptorType;
+
+    /** USB specification release number in binary-coded decimal. A value of
+     * 0x0200 indicates USB 2.0, 0x0110 indicates USB 1.1, etc. */
+    uint16_t bcdUSB;
+
+    /** USB-IF class code for the device. See \ref libusb_class_code. */
+    uint8_t bDeviceClass;
+
+    /** USB-IF subclass code for the device, qualified by the bDeviceClass
+     * value */
+    uint8_t bDeviceSubClass;
+
+    /** USB-IF protocol code for the device, qualified by the bDeviceClass and
+     * bDeviceSubClass values */
+    uint8_t bDeviceProtocol;
+
+    /** Maximum packet size for endpoint 0 */
+    uint8_t bMaxPacketSize0;
+
+    /** USB-IF vendor ID */
+    uint16_t idVendor;
+
+    /** USB-IF product ID */
+    uint16_t idProduct;
+
+    /** Device release number in binary-coded decimal */
+    uint16_t bcdDevice;
+
+    /** Index of string descriptor describing manufacturer */
+    uint8_t iManufacturer;
+
+    /** Index of string descriptor describing product */
+    uint8_t iProduct;
+
+    /** Index of string descriptor containing device serial number */
+    uint8_t iSerialNumber;
+
+    /** Number of possible configurations */
+    uint8_t bNumConfigurations;
+};
+
+/** \ingroup libusb_desc
+ * A structure representing the standard USB endpoint descriptor. This
+ * descriptor is documented in section 9.6.6 of the USB 3.0 specification.
+ * All multiple-byte fields are represented in host-endian format.
+ */
+struct libusb_endpoint_descriptor {
+    /** Size of this descriptor (in bytes) */
+    uint8_t bLength;
+
+    /** Descriptor type. Will have value
+     * \ref libusb_descriptor_type::LIBUSB_DT_ENDPOINT LIBUSB_DT_ENDPOINT in
+     * this context. */
+    uint8_t bDescriptorType;
+
+    /** The address of the endpoint described by this descriptor. Bits 0:3 are
+     * the endpoint number. Bits 4:6 are reserved. Bit 7 indicates direction,
+     * see \ref libusb_endpoint_direction. */
+    uint8_t bEndpointAddress;
+
+    /** Attributes which apply to the endpoint when it is configured using
+     * the bConfigurationValue. Bits 0:1 determine the transfer type and
+     * correspond to \ref libusb_endpoint_transfer_type. Bits 2:3 are only used
+     * for isochronous endpoints and correspond to \ref libusb_iso_sync_type.
+     * Bits 4:5 are also only used for isochronous endpoints and correspond to
+     * \ref libusb_iso_usage_type. Bits 6:7 are reserved. */
+    uint8_t bmAttributes;
+
+    /** Maximum packet size this endpoint is capable of sending/receiving. */
+    uint16_t wMaxPacketSize;
+
+    /** Interval for polling endpoint for data transfers. */
+    uint8_t bInterval;
+
+    /** For audio devices only: the rate at which synchronization feedback
+     * is provided. */
+    uint8_t bRefresh;
+
+    /** For audio devices only: the address if the synch endpoint */
+    uint8_t bSynchAddress;
+
+    /** Extra descriptors. If libusb encounters unknown endpoint descriptors,
+     * it will store them here, should you wish to parse them. */
+    const unsigned char *extra;
+
+    /** Length of the extra descriptors, in bytes. Must be non-negative. */
+    int extra_length;
+};
+
+/** \ingroup libusb_desc
+ * A structure representing the standard USB interface association descriptor.
+ * This descriptor is documented in section 9.6.4 of the USB 3.0 specification.
+ * All multiple-byte fields are represented in host-endian format.
+ */
+struct libusb_interface_association_descriptor {
+    /** Size of this descriptor (in bytes) */
+    uint8_t bLength;
+
+    /** Descriptor type. Will have value
+     * \ref libusb_descriptor_type::LIBUSB_DT_INTERFACE_ASSOCIATION
+     * LIBUSB_DT_INTERFACE_ASSOCIATION in this context. */
+    uint8_t bDescriptorType;
+
+    /** Interface number of the first interface that is associated
+     * with this function */
+    uint8_t bFirstInterface;
+
+    /** Number of contiguous interfaces that are associated with
+     * this function */
+    uint8_t bInterfaceCount;
+
+    /** USB-IF class code for this function.
+     * A value of zero is not allowed in this descriptor.
+     * If this field is 0xff, the function class is vendor-specific.
+     * All other values are reserved for assignment by the USB-IF.
+     */
+    uint8_t bFunctionClass;
+
+    /** USB-IF subclass code for this function.
+     * If this field is not set to 0xff, all values are reserved
+     * for assignment by the USB-IF
+     */
+    uint8_t bFunctionSubClass;
+
+    /** USB-IF protocol code for this function.
+     * These codes are qualified by the values of the bFunctionClass
+     * and bFunctionSubClass fields.
+     */
+    uint8_t bFunctionProtocol;
+
+    /** Index of string descriptor describing this function */
+    uint8_t iFunction;
+};
+
+/** \ingroup libusb_desc
+ * Structure containing an array of 0 or more interface association
+ * descriptors
+ */
+struct libusb_interface_association_descriptor_array {
+    /** Array of interface association descriptors. The size of this array
+     * is determined by the length field.
+     */
+    const struct libusb_interface_association_descriptor *iad;
+
+    /** Number of interface association descriptors contained. Read-only. */
+    int length;
+};
+
+/** \ingroup libusb_desc
+ * A structure representing the standard USB interface descriptor. This
+ * descriptor is documented in section 9.6.5 of the USB 3.0 specification.
+ * All multiple-byte fields are represented in host-endian format.
+ */
+struct libusb_interface_descriptor {
+    /** Size of this descriptor (in bytes) */
+    uint8_t bLength;
+
+    /** Descriptor type. Will have value
+     * \ref libusb_descriptor_type::LIBUSB_DT_INTERFACE LIBUSB_DT_INTERFACE
+     * in this context. */
+    uint8_t bDescriptorType;
+
+    /** Number of this interface */
+    uint8_t bInterfaceNumber;
+
+    /** Value used to select this alternate setting for this interface */
+    uint8_t bAlternateSetting;
+
+    /** Number of endpoints used by this interface (excluding the control
+     * endpoint). */
+    uint8_t bNumEndpoints;
+
+    /** USB-IF class code for this interface. See \ref libusb_class_code. */
+    uint8_t bInterfaceClass;
+
+    /** USB-IF subclass code for this interface, qualified by the
+     * bInterfaceClass value */
+    uint8_t bInterfaceSubClass;
+
+    /** USB-IF protocol code for this interface, qualified by the
+     * bInterfaceClass and bInterfaceSubClass values */
+    uint8_t bInterfaceProtocol;
+
+    /** Index of string descriptor describing this interface */
+    uint8_t iInterface;
+
+    /** Array of endpoint descriptors. This length of this array is determined
+     * by the bNumEndpoints field. */
+    const struct libusb_endpoint_descriptor *endpoint;
+
+    /** Extra descriptors. If libusb encounters unknown interface descriptors,
+     * it will store them here, should you wish to parse them. */
+    const unsigned char *extra;
+
+    /** Length of the extra descriptors, in bytes. Must be non-negative. */
+    int extra_length;
+};
+
+/** \ingroup libusb_desc
+ * A collection of alternate settings for a particular USB interface.
+ */
+struct libusb_interface {
+    /** Array of interface descriptors. The length of this array is determined
+     * by the num_altsetting field. */
+    const struct libusb_interface_descriptor *altsetting;
+
+    /** The number of alternate settings that belong to this interface.
+     * Must be non-negative. */
+    int num_altsetting;
+};
+
+/** \ingroup libusb_desc
+ * A structure representing the standard USB configuration descriptor. This
+ * descriptor is documented in section 9.6.3 of the USB 3.0 specification.
+ * All multiple-byte fields are represented in host-endian format.
+ */
+struct libusb_config_descriptor {
+    /** Size of this descriptor (in bytes) */
+    uint8_t bLength;
+
+    /** Descriptor type. Will have value
+     * \ref libusb_descriptor_type::LIBUSB_DT_CONFIG LIBUSB_DT_CONFIG
+     * in this context. */
+    uint8_t bDescriptorType;
+
+    /** Total length of data returned for this configuration */
+    uint16_t wTotalLength;
+
+    /** Number of interfaces supported by this configuration */
+    uint8_t bNumInterfaces;
+
+    /** Identifier value for this configuration */
+    uint8_t bConfigurationValue;
+
+    /** Index of string descriptor describing this configuration */
+    uint8_t iConfiguration;
+
+    /** Configuration characteristics */
+    uint8_t bmAttributes;
+
+    /** Maximum power consumption of the USB device from this bus in this
+     * configuration when the device is fully operation. Expressed in units
+     * of 2 mA when the device is operating in high-speed mode and in units
+     * of 8 mA when the device is operating in super-speed mode. */
+    uint8_t MaxPower;
+
+    /** Array of interfaces supported by this configuration. The length of
+     * this array is determined by the bNumInterfaces field. */
+    const struct libusb_interface *interface;
+
+    /** Extra descriptors. If libusb encounters unknown configuration
+     * descriptors, it will store them here, should you wish to parse them. */
+    const unsigned char *extra;
+
+    /** Length of the extra descriptors, in bytes. Must be non-negative. */
+    int extra_length;
+};
+
+/** \ingroup libusb_desc
+ * A structure representing the superspeed endpoint companion
+ * descriptor. This descriptor is documented in section 9.6.7 of
+ * the USB 3.0 specification. All multiple-byte fields are represented in
+ * host-endian format.
+ */
+struct libusb_ss_endpoint_companion_descriptor {
+    /** Size of this descriptor (in bytes) */
+    uint8_t bLength;
+
+    /** Descriptor type. Will have value
+     * \ref libusb_descriptor_type::LIBUSB_DT_SS_ENDPOINT_COMPANION in
+     * this context. */
+    uint8_t bDescriptorType;
+
+    /** The maximum number of packets the endpoint can send or
+     *  receive as part of a burst. */
+    uint8_t bMaxBurst;
+
+    /** In bulk EP: bits 4:0 represents the maximum number of
+     *  streams the EP supports. In isochronous EP: bits 1:0
+     *  represents the Mult - a zero based value that determines
+     *  the maximum number of packets within a service interval  */
+    uint8_t bmAttributes;
+
+    /** The total number of bytes this EP will transfer every
+     *  service interval. Valid only for periodic EPs. */
+    uint16_t wBytesPerInterval;
+};
+
+/** \ingroup libusb_desc
+ * A generic representation of a BOS Device Capability descriptor. It is
+ * advised to check bDevCapabilityType and call the matching
+ * libusb_get_*_descriptor function to get a structure fully matching the type.
+ */
+struct libusb_bos_dev_capability_descriptor {
+    /** Size of this descriptor (in bytes) */
+    uint8_t bLength;
+
+    /** Descriptor type. Will have value
+     * \ref libusb_descriptor_type::LIBUSB_DT_DEVICE_CAPABILITY
+     * LIBUSB_DT_DEVICE_CAPABILITY in this context. */
+    uint8_t bDescriptorType;
+
+    /** Device Capability type */
+    uint8_t bDevCapabilityType;
+
+    /** Device Capability data (bLength - 3 bytes) */
+#if defined(__GNUC__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wpedantic"
+#endif
+    uint8_t dev_capability_data[ZERO_SIZED_ARRAY];
+#if defined(__GNUC__)
+#pragma GCC diagnostic pop
+#endif
+};
+
+/** \ingroup libusb_desc
+ * A structure representing the Binary Device Object Store (BOS) descriptor.
+ * This descriptor is documented in section 9.6.2 of the USB 3.0 specification.
+ * All multiple-byte fields are represented in host-endian format.
+ */
+struct libusb_bos_descriptor {
+    /** Size of this descriptor (in bytes) */
+    uint8_t bLength;
+
+    /** Descriptor type. Will have value
+     * \ref libusb_descriptor_type::LIBUSB_DT_BOS LIBUSB_DT_BOS
+     * in this context. */
+    uint8_t bDescriptorType;
+
+    /** Length of this descriptor and all of its sub descriptors */
+    uint16_t wTotalLength;
+
+    /** The number of separate device capability descriptors in
+     * the BOS */
+    uint8_t bNumDeviceCaps;
+
+    /** bNumDeviceCap Device Capability Descriptors */
+#if defined(__GNUC__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wpedantic"
+#endif
+    struct libusb_bos_dev_capability_descriptor *dev_capability[ZERO_SIZED_ARRAY];
+#if defined(__GNUC__)
+#pragma GCC diagnostic pop
+#endif
+};
+
+/** \ingroup libusb_desc
+ * A structure representing the USB 2.0 Extension descriptor
+ * This descriptor is documented in section 9.6.2.1 of the USB 3.0 specification.
+ * All multiple-byte fields are represented in host-endian format.
+ */
+struct libusb_usb_2_0_extension_descriptor {
+    /** Size of this descriptor (in bytes) */
+    uint8_t bLength;
+
+    /** Descriptor type. Will have value
+     * \ref libusb_descriptor_type::LIBUSB_DT_DEVICE_CAPABILITY
+     * LIBUSB_DT_DEVICE_CAPABILITY in this context. */
+    uint8_t bDescriptorType;
+
+    /** Capability type. Will have value
+     * \ref libusb_capability_type::LIBUSB_BT_USB_2_0_EXTENSION
+     * LIBUSB_BT_USB_2_0_EXTENSION in this context. */
+    uint8_t bDevCapabilityType;
+
+    /** Bitmap encoding of supported device level features.
+     * A value of one in a bit location indicates a feature is
+     * supported; a value of zero indicates it is not supported.
+     * See \ref libusb_usb_2_0_extension_attributes. */
+    uint32_t bmAttributes;
+};
+
+/** \ingroup libusb_desc
+ * A structure representing the SuperSpeed USB Device Capability descriptor
+ * This descriptor is documented in section 9.6.2.2 of the USB 3.0 specification.
+ * All multiple-byte fields are represented in host-endian format.
+ */
+struct libusb_ss_usb_device_capability_descriptor {
+    /** Size of this descriptor (in bytes) */
+    uint8_t bLength;
+
+    /** Descriptor type. Will have value
+     * \ref libusb_descriptor_type::LIBUSB_DT_DEVICE_CAPABILITY
+     * LIBUSB_DT_DEVICE_CAPABILITY in this context. */
+    uint8_t bDescriptorType;
+
+    /** Capability type. Will have value
+     * \ref libusb_capability_type::LIBUSB_BT_SS_USB_DEVICE_CAPABILITY
+     * LIBUSB_BT_SS_USB_DEVICE_CAPABILITY in this context. */
+    uint8_t bDevCapabilityType;
+
+    /** Bitmap encoding of supported device level features.
+     * A value of one in a bit location indicates a feature is
+     * supported; a value of zero indicates it is not supported.
+     * See \ref libusb_ss_usb_device_capability_attributes. */
+    uint8_t bmAttributes;
+
+    /** Bitmap encoding of the speed supported by this device when
+     * operating in SuperSpeed mode. See \ref libusb_supported_speed. */
+    uint16_t wSpeedSupported;
+
+    /** The lowest speed at which all the functionality supported
+     * by the device is available to the user. For example if the
+     * device supports all its functionality when connected at
+     * full speed and above then it sets this value to 1. */
+    uint8_t bFunctionalitySupport;
+
+    /** U1 Device Exit Latency. */
+    uint8_t bU1DevExitLat;
+
+    /** U2 Device Exit Latency. */
+    uint16_t bU2DevExitLat;
+};
+
+/** \ingroup libusb_desc
+ * A structure representing the Container ID descriptor.
+ * This descriptor is documented in section 9.6.2.3 of the USB 3.0 specification.
+ * All multiple-byte fields, except UUIDs, are represented in host-endian format.
+ */
+struct libusb_container_id_descriptor {
+    /** Size of this descriptor (in bytes) */
+    uint8_t bLength;
+
+    /** Descriptor type. Will have value
+     * \ref libusb_descriptor_type::LIBUSB_DT_DEVICE_CAPABILITY
+     * LIBUSB_DT_DEVICE_CAPABILITY in this context. */
+    uint8_t bDescriptorType;
+
+    /** Capability type. Will have value
+     * \ref libusb_capability_type::LIBUSB_BT_CONTAINER_ID
+     * LIBUSB_BT_CONTAINER_ID in this context. */
+    uint8_t bDevCapabilityType;
+
+    /** Reserved field */
+    uint8_t bReserved;
+
+    /** 128 bit UUID */
+    uint8_t ContainerID[16];
+};
+
+/** \ingroup libusb_desc
+ * A structure representing a Platform descriptor.
+ * This descriptor is documented in section 9.6.2.4 of the USB 3.2 specification.
+ */
+struct libusb_platform_descriptor {
+    /** Size of this descriptor (in bytes) */
+    uint8_t bLength;
+
+    /** Descriptor type. Will have value
+     * \ref libusb_descriptor_type::LIBUSB_DT_DEVICE_CAPABILITY
+     * LIBUSB_DT_DEVICE_CAPABILITY in this context. */
+    uint8_t bDescriptorType;
+
+    /** Capability type. Will have value
+     * \ref libusb_capability_type::LIBUSB_BT_PLATFORM_DESCRIPTOR
+     * LIBUSB_BT_CONTAINER_ID in this context. */
+    uint8_t bDevCapabilityType;
+
+    /** Reserved field */
+    uint8_t bReserved;
+
+    /** 128 bit UUID */
+    uint8_t PlatformCapabilityUUID[16];
+
+    /** Capability data (bLength - 20) */
+#if defined(__GNUC__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wpedantic"
+#endif
+    uint8_t CapabilityData[ZERO_SIZED_ARRAY];
+#if defined(__GNUC__)
+#pragma GCC diagnostic pop
+#endif
+};
+
+/** \ingroup libusb_asyncio
+ * Setup packet for control transfers. */
+#if defined(_MSC_VER) || defined(__WATCOMC__)
+#pragma pack(push, 1)
+#endif
+struct libusb_control_setup {
+    /** Request type. Bits 0:4 determine recipient, see
+     * \ref libusb_request_recipient. Bits 5:6 determine type, see
+     * \ref libusb_request_type. Bit 7 determines data transfer direction, see
+     * \ref libusb_endpoint_direction.
+     */
+    uint8_t bmRequestType;
+
+    /** Request. If the type bits of bmRequestType are equal to
+     * \ref libusb_request_type::LIBUSB_REQUEST_TYPE_STANDARD
+     * "LIBUSB_REQUEST_TYPE_STANDARD" then this field refers to
+     * \ref libusb_standard_request. For other cases, use of this field is
+     * application-specific. */
+    uint8_t bRequest;
+
+    /** Value. Varies according to request */
+    uint16_t wValue;
+
+    /** Index. Varies according to request, typically used to pass an index
+     * or offset */
+    uint16_t wIndex;
+
+    /** Number of bytes to transfer */
+    uint16_t wLength;
+} LIBUSB_PACKED;
+#if defined(_MSC_VER) || defined(__WATCOMC__)
+#pragma pack(pop)
+#endif
+
+#define LIBUSB_CONTROL_SETUP_SIZE (sizeof(struct libusb_control_setup))
+
+/* libusb */
+
+struct libusb_context;
+struct libusb_device;
+struct libusb_device_handle;
+
+/** \ingroup libusb_lib
+ * Structure providing the version of the libusb runtime
+ */
+struct libusb_version {
+    /** Library major version. */
+    const uint16_t major;
+
+    /** Library minor version. */
+    const uint16_t minor;
+
+    /** Library micro version. */
+    const uint16_t micro;
+
+    /** Library nano version. */
+    const uint16_t nano;
+
+    /** Library release candidate suffix string, e.g. "-rc4". */
+    const char *rc;
+
+    /** For ABI compatibility only. */
+    const char *describe;
+};
+
+/** \ingroup libusb_lib
+ * Structure representing a libusb session. The concept of individual libusb
+ * sessions allows for your program to use two libraries (or dynamically
+ * load two modules) which both independently use libusb. This will prevent
+ * interference between the individual libusb users - for example
+ * libusb_set_option() will not affect the other user of the library, and
+ * libusb_exit() will not destroy resources that the other user is still
+ * using.
+ *
+ * Sessions are created by libusb_init() and destroyed through libusb_exit().
+ * If your application is guaranteed to only ever include a single libusb
+ * user (i.e. you), you do not have to worry about contexts: pass NULL in
+ * every function call where a context is required, and the default context
+ * will be used. Note that libusb_set_option(NULL, ...) is special, and adds
+ * an option to a list of default options for new contexts.
+ *
+ * For more information, see \ref libusb_contexts.
+ */
+typedef struct libusb_context libusb_context;
+
+/** \ingroup libusb_dev
+ * Structure representing a USB device detected on the system. This is an
+ * opaque type for which you are only ever provided with a pointer, usually
+ * originating from libusb_get_device_list() or libusb_hotplug_register_callback().
+ *
+ * Certain operations can be performed on a device, but in order to do any
+ * I/O you will have to first obtain a device handle using libusb_open().
+ *
+ * Devices are reference counted with libusb_ref_device() and
+ * libusb_unref_device(), and are freed when the reference count reaches 0.
+ * New devices presented by libusb_get_device_list() have a reference count of
+ * 1, and libusb_free_device_list() can optionally decrease the reference count
+ * on all devices in the list. libusb_open() adds another reference which is
+ * later destroyed by libusb_close().
+ */
+typedef struct libusb_device libusb_device;
+
+/** \ingroup libusb_dev
+ * Structure representing a handle on a USB device. This is an opaque type for
+ * which you are only ever provided with a pointer, usually originating from
+ * libusb_open().
+ *
+ * A device handle is used to perform I/O and other operations. When finished
+ * with a device handle, you should call libusb_close().
+ */
+typedef struct libusb_device_handle libusb_device_handle;
+
+/** \ingroup libusb_dev
+ * Speed codes. Indicates the speed at which the device is operating.
+ */
+enum libusb_speed {
+    /** The OS doesn't report or know the device speed. */
+    LIBUSB_SPEED_UNKNOWN = 0,
+
+    /** The device is operating at low speed (1.5MBit/s). */
+    LIBUSB_SPEED_LOW = 1,
+
+    /** The device is operating at full speed (12MBit/s). */
+    LIBUSB_SPEED_FULL = 2,
+
+    /** The device is operating at high speed (480MBit/s). */
+    LIBUSB_SPEED_HIGH = 3,
+
+    /** The device is operating at super speed (5000MBit/s). */
+    LIBUSB_SPEED_SUPER = 4,
+
+    /** The device is operating at super speed plus (10000MBit/s). */
+    LIBUSB_SPEED_SUPER_PLUS = 5
+};
+
+/** \ingroup libusb_misc
+ * Error codes. Most libusb functions return 0 on success or one of these
+ * codes on failure.
+ * You can call libusb_error_name() to retrieve a string representation of an
+ * error code or libusb_strerror() to get an end-user suitable description of
+ * an error code.
+ */
+enum libusb_error {
+    /** Success (no error) */
+    LIBUSB_SUCCESS = 0,
+
+    /** Input/output error */
+    LIBUSB_ERROR_IO = -1,
+
+    /** Invalid parameter */
+    LIBUSB_ERROR_INVALID_PARAM = -2,
+
+    /** Access denied (insufficient permissions) */
+    LIBUSB_ERROR_ACCESS = -3,
+
+    /** No such device (it may have been disconnected) */
+    LIBUSB_ERROR_NO_DEVICE = -4,
+
+    /** Entity not found */
+    LIBUSB_ERROR_NOT_FOUND = -5,
+
+    /** Resource busy */
+    LIBUSB_ERROR_BUSY = -6,
+
+    /** Operation timed out */
+    LIBUSB_ERROR_TIMEOUT = -7,
+
+    /** Overflow */
+    LIBUSB_ERROR_OVERFLOW = -8,
+
+    /** Pipe error */
+    LIBUSB_ERROR_PIPE = -9,
+
+    /** System call interrupted (perhaps due to signal) */
+    LIBUSB_ERROR_INTERRUPTED = -10,
+
+    /** Insufficient memory */
+    LIBUSB_ERROR_NO_MEM = -11,
+
+    /** Operation not supported or unimplemented on this platform */
+    LIBUSB_ERROR_NOT_SUPPORTED = -12,
+
+    /* NB: Remember to update LIBUSB_ERROR_COUNT below as well as the
+       message strings in strerror.c when adding new error codes here. */
+
+    /** Other error */
+    LIBUSB_ERROR_OTHER = -99
+};
+
+/* Total number of error codes in enum libusb_error */
+#define LIBUSB_ERROR_COUNT 14
+
+/** \ingroup libusb_asyncio
+ * Transfer type */
+enum libusb_transfer_type {
+    /** Control transfer */
+    LIBUSB_TRANSFER_TYPE_CONTROL = 0U,
+
+    /** Isochronous transfer */
+    LIBUSB_TRANSFER_TYPE_ISOCHRONOUS = 1U,
+
+    /** Bulk transfer */
+    LIBUSB_TRANSFER_TYPE_BULK = 2U,
+
+    /** Interrupt transfer */
+    LIBUSB_TRANSFER_TYPE_INTERRUPT = 3U,
+
+    /** Bulk stream transfer */
+    LIBUSB_TRANSFER_TYPE_BULK_STREAM = 4U
+};
+
+/** \ingroup libusb_asyncio
+ * Transfer status codes */
+enum libusb_transfer_status {
+    /** Transfer completed without error. Note that this does not indicate
+     * that the entire amount of requested data was transferred. */
+    LIBUSB_TRANSFER_COMPLETED,
+
+    /** Transfer failed */
+    LIBUSB_TRANSFER_ERROR,
+
+    /** Transfer timed out */
+    LIBUSB_TRANSFER_TIMED_OUT,
+
+    /** Transfer was cancelled */
+    LIBUSB_TRANSFER_CANCELLED,
+
+    /** For bulk/interrupt endpoints: halt condition detected (endpoint
+     * stalled). For control endpoints: control request not supported. */
+    LIBUSB_TRANSFER_STALL,
+
+    /** Device was disconnected */
+    LIBUSB_TRANSFER_NO_DEVICE,
+
+    /** Device sent more data than requested */
+    LIBUSB_TRANSFER_OVERFLOW
+
+    /* NB! Remember to update libusb_error_name()
+       when adding new status codes here. */
+};
+
+/** \ingroup libusb_asyncio
+ * libusb_transfer.flags values */
+enum libusb_transfer_flags {
+    /** Report short frames as errors */
+    LIBUSB_TRANSFER_SHORT_NOT_OK = (1U << 0),
+
+    /** Automatically free() transfer buffer during libusb_free_transfer().
+     * Note that buffers allocated with libusb_dev_mem_alloc() should not
+     * be attempted freed in this way, since free() is not an appropriate
+     * way to release such memory. */
+    LIBUSB_TRANSFER_FREE_BUFFER = (1U << 1),
+
+    /** Automatically call libusb_free_transfer() after callback returns.
+     * If this flag is set, it is illegal to call libusb_free_transfer()
+     * from your transfer callback, as this will result in a double-free
+     * when this flag is acted upon. */
+    LIBUSB_TRANSFER_FREE_TRANSFER = (1U << 2),
+
+    /** Terminate transfers that are a multiple of the endpoint's
+     * wMaxPacketSize with an extra zero length packet. This is useful
+     * when a device protocol mandates that each logical request is
+     * terminated by an incomplete packet (i.e. the logical requests are
+     * not separated by other means).
+     *
+     * This flag only affects host-to-device transfers to bulk and interrupt
+     * endpoints. In other situations, it is ignored.
+     *
+     * This flag only affects transfers with a length that is a multiple of
+     * the endpoint's wMaxPacketSize. On transfers of other lengths, this
+     * flag has no effect. Therefore, if you are working with a device that
+     * needs a ZLP whenever the end of the logical request falls on a packet
+     * boundary, then it is sensible to set this flag on <em>every</em>
+     * transfer (you do not have to worry about only setting it on transfers
+     * that end on the boundary).
+     *
+     * This flag is currently only supported on Linux.
+     * On other systems, libusb_submit_transfer() will return
+     * \ref LIBUSB_ERROR_NOT_SUPPORTED for every transfer where this
+     * flag is set.
+     *
+     * Available since libusb-1.0.9.
+     */
+    LIBUSB_TRANSFER_ADD_ZERO_PACKET = (1U << 3)
+};
+
+/** \ingroup libusb_asyncio
+ * Isochronous packet descriptor. */
+struct libusb_iso_packet_descriptor {
+    /** Length of data to request in this packet */
+    unsigned int length;
+
+    /** Amount of data that was actually transferred */
+    unsigned int actual_length;
+
+    /** Status code for this packet */
+    enum libusb_transfer_status status;
+};
+
+struct libusb_transfer;
+
+/** \ingroup libusb_asyncio
+ * Asynchronous transfer callback function type. When submitting asynchronous
+ * transfers, you pass a pointer to a callback function of this type via the
+ * \ref libusb_transfer::callback "callback" member of the libusb_transfer
+ * structure. libusb will call this function later, when the transfer has
+ * completed or failed. See \ref libusb_asyncio for more information.
+ * \param transfer The libusb_transfer struct the callback function is being
+ * notified about.
+ */
+typedef void(LIBUSB_CALL *libusb_transfer_cb_fn)(struct libusb_transfer *transfer);
+
+/** \ingroup libusb_asyncio
+ * The generic USB transfer structure. The user populates this structure and
+ * then submits it in order to request a transfer. After the transfer has
+ * completed, the library populates the transfer with the results and passes
+ * it back to the user.
+ */
+struct libusb_transfer {
+    /** Handle of the device that this transfer will be submitted to */
+    libusb_device_handle *dev_handle;
+
+    /** A bitwise OR combination of \ref libusb_transfer_flags. */
+    uint8_t flags;
+
+    /** Address of the endpoint where this transfer will be sent. */
+    unsigned char endpoint;
+
+    /** Type of the transfer from \ref libusb_transfer_type */
+    unsigned char type;
+
+    /** Timeout for this transfer in milliseconds. A value of 0 indicates no
+     * timeout. */
+    unsigned int timeout;
+
+    /** The status of the transfer. Read-only, and only for use within
+     * transfer callback function.
+     *
+     * If this is an isochronous transfer, this field may read COMPLETED even
+     * if there were errors in the frames. Use the
+     * \ref libusb_iso_packet_descriptor::status "status" field in each packet
+     * to determine if errors occurred. */
+    enum libusb_transfer_status status;
+
+    /** Length of the data buffer. Must be non-negative. */
+    int length;
+
+    /** Actual length of data that was transferred. Read-only, and only for
+     * use within transfer callback function. Not valid for isochronous
+     * endpoint transfers. */
+    int actual_length;
+
+    /** Callback function. This will be invoked when the transfer completes,
+     * fails, or is cancelled. */
+    libusb_transfer_cb_fn callback;
+
+    /** User context data. Useful for associating specific data to a transfer
+     * that can be accessed from within the callback function.
+     *
+     * This field may be set manually or is taken as the `user_data` parameter
+     * of the following functions:
+     * - libusb_fill_bulk_transfer()
+     * - libusb_fill_bulk_stream_transfer()
+     * - libusb_fill_control_transfer()
+     * - libusb_fill_interrupt_transfer()
+     * - libusb_fill_iso_transfer() */
+    void *user_data;
+
+    /** Data buffer */
+    unsigned char *buffer;
+
+    /** Number of isochronous packets. Only used for I/O with isochronous
+     * endpoints. Must be non-negative. */
+    int num_iso_packets;
+
+    /** Isochronous packet descriptors, for isochronous transfers only. */
+#if defined(__GNUC__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wpedantic"
+#endif
+    struct libusb_iso_packet_descriptor iso_packet_desc[ZERO_SIZED_ARRAY];
+#if defined(__GNUC__)
+#pragma GCC diagnostic pop
+#endif
+};
+
+/** \ingroup libusb_misc
+ * Capabilities supported by an instance of libusb on the current running
+ * platform. Test if the loaded library supports a given capability by calling
+ * \ref libusb_has_capability().
+ */
+enum libusb_capability {
+    /** The libusb_has_capability() API is available. */
+    LIBUSB_CAP_HAS_CAPABILITY = 0x0000U,
+
+    /** Hotplug support is available on this platform. */
+    LIBUSB_CAP_HAS_HOTPLUG = 0x0001U,
+
+    /** The library can access HID devices without requiring user intervention.
+     * Note that before being able to actually access an HID device, you may
+     * still have to call additional libusb functions such as
+     * \ref libusb_detach_kernel_driver(). */
+    LIBUSB_CAP_HAS_HID_ACCESS = 0x0100U,
+
+    /** The library supports detaching of the default USB driver, using
+     * \ref libusb_detach_kernel_driver(), if one is set by the OS kernel */
+    LIBUSB_CAP_SUPPORTS_DETACH_KERNEL_DRIVER = 0x0101U
+};
+
+/** \ingroup libusb_lib
+ *  Log message levels.
+ */
+enum libusb_log_level {
+    /** (0) : No messages ever emitted by the library (default) */
+    LIBUSB_LOG_LEVEL_NONE = 0,
+
+    /** (1) : Error messages are emitted */
+    LIBUSB_LOG_LEVEL_ERROR = 1,
+
+    /** (2) : Warning and error messages are emitted */
+    LIBUSB_LOG_LEVEL_WARNING = 2,
+
+    /** (3) : Informational, warning and error messages are emitted */
+    LIBUSB_LOG_LEVEL_INFO = 3,
+
+    /** (4) : All messages are emitted */
+    LIBUSB_LOG_LEVEL_DEBUG = 4
+};
+
+/** \ingroup libusb_lib
+ *  Log callback mode.
+ *
+ *  Since version 1.0.23, \ref LIBUSB_API_VERSION >= 0x01000107
+ *
+ * \see libusb_set_log_cb()
+ */
+enum libusb_log_cb_mode {
+    /** Callback function handling all log messages. */
+    LIBUSB_LOG_CB_GLOBAL = (1 << 0),
+
+    /** Callback function handling context related log messages. */
+    LIBUSB_LOG_CB_CONTEXT = (1 << 1)
+};
+
+/** \ingroup libusb_lib
+ * Available option values for libusb_set_option() and libusb_init_context().
+ */
+enum libusb_option {
+    /** Set the log message verbosity.
+     *
+     * The default level is LIBUSB_LOG_LEVEL_NONE, which means no messages are ever
+     * printed. If you choose to increase the message verbosity level, ensure
+     * that your application does not close the stderr file descriptor.
+     *
+     * You are advised to use level LIBUSB_LOG_LEVEL_WARNING. libusb is conservative
+     * with its message logging and most of the time, will only log messages that
+     * explain error conditions and other oddities. This will help you debug
+     * your software.
+     *
+     * If the LIBUSB_DEBUG environment variable was set when libusb was
+     * initialized, this function does nothing: the message verbosity is fixed
+     * to the value in the environment variable.
+     *
+     * If libusb was compiled without any message logging, this function does
+     * nothing: you'll never get any messages.
+     *
+     * If libusb was compiled with verbose debug message logging, this function
+     * does nothing: you'll always get messages from all levels.
+     */
+    LIBUSB_OPTION_LOG_LEVEL = 0,
+
+    /** Use the UsbDk backend for a specific context, if available.
+     *
+     * This option should be set immediately after calling libusb_init(), or set at
+     * initialization with libusb_init_context() otherwise unspecified behavior
+     * may occur.
+     *
+     * Only valid on Windows. Ignored on all other platforms.
+     */
+    LIBUSB_OPTION_USE_USBDK = 1,
+
+    /** Do not scan for devices
+     *
+     * With this option set, libusb will skip scanning devices in
+     * libusb_init_context().
+     *
+     * Hotplug functionality will also be deactivated.
+     *
+     * The option is useful in combination with libusb_wrap_sys_device(),
+     * which can access a device directly without prior device scanning.
+     *
+     * This is typically needed on Android, where access to USB devices
+     * is limited.
+     *
+     * Only valid on Linux. Ignored on all other platforms.
+     */
+    LIBUSB_OPTION_NO_DEVICE_DISCOVERY = 2,
+
+#define LIBUSB_OPTION_WEAK_AUTHORITY LIBUSB_OPTION_NO_DEVICE_DISCOVERY
+
+    /** Enable or disable WinUSB RAW_IO mode on an endpoint
+     *
+     * Requires four additional arguments of:
+     *
+     *   libusb_device_handle *dev_handle
+     *   unsigned int endpoint_address
+     *   unsigned int enable
+     *   unsigned int *max_transfer_size_ptr
+     *
+     * The dev_handle and endpoint_address parameters must identify a valid
+     * IN endpoint on an open device. If enable is nonzero, RAW_IO is
+     * enabled, otherwise it is disabled. Unless max_transfer_size_ptr is
+     * NULL, then on a successful call to enable RAW_IO, it will be written
+     * with the MAXIMUM_TRANSFER_SIZE value for the endpoint.
+     *
+     * Whilst RAW_IO is enabled for an endpoint, all transfers on that endpoint
+     * must meet the following two requirements:
+     *
+     * * The buffer length must be a multiple of the maximum endpoint packet size.
+     *
+     * * The length must be less than or equal to the MAXIMUM_TRANSFER_SIZE value.
+     *
+     * This option should not be changed when any transfer is in progress on the
+     * specified endpoint.
+     *
+     * This option only affects the WinUSB backend. On other backends it is ignored
+     * and returns LIBUSB_OPTION_NOT_SUPPORTED, without modifying the value pointed
+     * to by max_transfer_size_ptr.
+     *
+     *  Since version 1.0.27, \ref LIBUSB_API_VERSION >= 0x0100010A
+     */
+    LIBUSB_OPTION_WINUSB_RAW_IO = 3,
+
+    LIBUSB_OPTION_MAX = 4
+};
+
+/** \ingroup libusb_lib
+ * Structure used for setting options through \ref libusb_init_context.
+ *
+ */
+struct libusb_init_option {
+    /** Which option to set */
+    enum libusb_option option;
+    /** An integer value used by the option (if applicable). */
+    union {
+        int64_t ival;
+    } value;
+};
+
+/** \ingroup libusb_lib
+ * Callback function for handling log messages.
+ * \param ctx the context which is related to the log message, or NULL if it
+ * is a global log message
+ * \param level the log level, see \ref libusb_log_level for a description
+ * \param str the log message
+ *
+ * Since version 1.0.23, \ref LIBUSB_API_VERSION >= 0x01000107
+ *
+ * \see libusb_set_log_cb()
+ */
+typedef void(LIBUSB_CALL *libusb_log_cb)(libusb_context *ctx, enum libusb_log_level level, const char *str);
+
+int LIBUSB_CALL                          libusb_init(libusb_context **ctx);
+int LIBUSB_CALL                          libusb_init_context(libusb_context **ctx, const struct libusb_init_option options[], int num_options);
+void LIBUSB_CALL                         libusb_exit(libusb_context *ctx);
+void LIBUSB_CALL                         libusb_set_debug(libusb_context *ctx, int level);
+void LIBUSB_CALL                         libusb_set_log_cb(libusb_context *ctx, libusb_log_cb cb, int mode);
+const struct libusb_version *LIBUSB_CALL libusb_get_version(void);
+int LIBUSB_CALL                          libusb_has_capability(uint32_t capability);
+const char *LIBUSB_CALL                  libusb_error_name(int errcode);
+int LIBUSB_CALL                          libusb_setlocale(const char *locale);
+const char *LIBUSB_CALL                  libusb_strerror(int errcode);
+
+ssize_t LIBUSB_CALL        libusb_get_device_list(libusb_context *ctx, libusb_device ***list);
+void LIBUSB_CALL           libusb_free_device_list(libusb_device **list, int unref_devices);
+libusb_device *LIBUSB_CALL libusb_ref_device(libusb_device *dev);
+void LIBUSB_CALL           libusb_unref_device(libusb_device *dev);
+
+int LIBUSB_CALL     libusb_get_configuration(libusb_device_handle *dev, int *config);
+int LIBUSB_CALL     libusb_get_device_descriptor(libusb_device *dev, struct libusb_device_descriptor *desc);
+int LIBUSB_CALL     libusb_get_active_config_descriptor(libusb_device *dev, struct libusb_config_descriptor **config);
+int LIBUSB_CALL     libusb_get_config_descriptor(libusb_device *dev, uint8_t config_index, struct libusb_config_descriptor **config);
+int LIBUSB_CALL     libusb_get_config_descriptor_by_value(libusb_device *dev, uint8_t bConfigurationValue, struct libusb_config_descriptor **config);
+void LIBUSB_CALL    libusb_free_config_descriptor(struct libusb_config_descriptor *config);
+int LIBUSB_CALL     libusb_get_ss_endpoint_companion_descriptor(libusb_context *ctx, const struct libusb_endpoint_descriptor *endpoint,
+                                                                struct libusb_ss_endpoint_companion_descriptor **ep_comp);
+void LIBUSB_CALL    libusb_free_ss_endpoint_companion_descriptor(struct libusb_ss_endpoint_companion_descriptor *ep_comp);
+int LIBUSB_CALL     libusb_get_bos_descriptor(libusb_device_handle *dev_handle, struct libusb_bos_descriptor **bos);
+void LIBUSB_CALL    libusb_free_bos_descriptor(struct libusb_bos_descriptor *bos);
+int LIBUSB_CALL     libusb_get_usb_2_0_extension_descriptor(libusb_context *ctx, struct libusb_bos_dev_capability_descriptor *dev_cap,
+                                                            struct libusb_usb_2_0_extension_descriptor **usb_2_0_extension);
+void LIBUSB_CALL    libusb_free_usb_2_0_extension_descriptor(struct libusb_usb_2_0_extension_descriptor *usb_2_0_extension);
+int LIBUSB_CALL     libusb_get_ss_usb_device_capability_descriptor(libusb_context *ctx, struct libusb_bos_dev_capability_descriptor *dev_cap,
+                                                                   struct libusb_ss_usb_device_capability_descriptor **ss_usb_device_cap);
+void LIBUSB_CALL    libusb_free_ss_usb_device_capability_descriptor(struct libusb_ss_usb_device_capability_descriptor *ss_usb_device_cap);
+int LIBUSB_CALL     libusb_get_container_id_descriptor(libusb_context *ctx, struct libusb_bos_dev_capability_descriptor *dev_cap,
+                                                       struct libusb_container_id_descriptor **container_id);
+void LIBUSB_CALL    libusb_free_container_id_descriptor(struct libusb_container_id_descriptor *container_id);
+int LIBUSB_CALL     libusb_get_platform_descriptor(libusb_context *ctx, struct libusb_bos_dev_capability_descriptor *dev_cap,
+                                                   struct libusb_platform_descriptor **platform_descriptor);
+void LIBUSB_CALL    libusb_free_platform_descriptor(struct libusb_platform_descriptor *platform_descriptor);
+uint8_t LIBUSB_CALL libusb_get_bus_number(libusb_device *dev);
+uint8_t LIBUSB_CALL libusb_get_port_number(libusb_device *dev);
+char *LIBUSB_CALL   libusb_get_windows_path(libusb_device *dev);
+char *LIBUSB_CALL   libusb_get_interface_path(libusb_device *dev, uint8_t interface_index);
+char *LIBUSB_CALL   libusb_get_sub_composite_device_id(libusb_device *dev, uint8_t index);
+int LIBUSB_CALL     libusb_get_port_numbers(libusb_device *dev, uint8_t *port_numbers, int port_numbers_len);
+LIBUSB_DEPRECATED_FOR(libusb_get_port_numbers)
+int LIBUSB_CALL            libusb_get_port_path(libusb_context *ctx, libusb_device *dev, uint8_t *path, uint8_t path_length);
+libusb_device *LIBUSB_CALL libusb_get_parent(libusb_device *dev);
+uint8_t LIBUSB_CALL        libusb_get_device_address(libusb_device *dev);
+int LIBUSB_CALL            libusb_get_device_speed(libusb_device *dev);
+int LIBUSB_CALL            libusb_get_max_packet_size(libusb_device *dev, unsigned char endpoint);
+int LIBUSB_CALL            libusb_get_max_iso_packet_size(libusb_device *dev, unsigned char endpoint);
+int LIBUSB_CALL            libusb_get_max_alt_packet_size(libusb_device *dev, int interface_number, int alternate_setting, unsigned char endpoint);
+
+int LIBUSB_CALL  libusb_get_interface_association_descriptors(libusb_device *dev, uint8_t config_index,
+                                                              struct libusb_interface_association_descriptor_array **iad_array);
+int LIBUSB_CALL  libusb_get_active_interface_association_descriptors(libusb_device *dev, struct libusb_interface_association_descriptor_array **iad_array);
+void LIBUSB_CALL libusb_free_interface_association_descriptors(struct libusb_interface_association_descriptor_array *iad_array);
+
+int LIBUSB_CALL            libusb_wrap_sys_device(libusb_context *ctx, intptr_t sys_dev, libusb_device_handle **dev_handle);
+int LIBUSB_CALL            libusb_open(libusb_device *dev, libusb_device_handle **dev_handle);
+void LIBUSB_CALL           libusb_close(libusb_device_handle *dev_handle);
+libusb_device *LIBUSB_CALL libusb_get_device(libusb_device_handle *dev_handle);
+
+int LIBUSB_CALL libusb_set_configuration(libusb_device_handle *dev_handle, int configuration);
+int LIBUSB_CALL libusb_claim_interface(libusb_device_handle *dev_handle, int interface_number);
+int LIBUSB_CALL libusb_release_interface(libusb_device_handle *dev_handle, int interface_number);
+
+libusb_device_handle *LIBUSB_CALL libusb_open_device_with_vid_pid(libusb_context *ctx, uint16_t vendor_id, uint16_t product_id);
+
+int LIBUSB_CALL libusb_set_interface_alt_setting(libusb_device_handle *dev_handle, int interface_number, int alternate_setting);
+int LIBUSB_CALL libusb_clear_halt(libusb_device_handle *dev_handle, unsigned char endpoint);
+int LIBUSB_CALL libusb_reset_device(libusb_device_handle *dev_handle);
+
+int LIBUSB_CALL libusb_alloc_streams(libusb_device_handle *dev_handle, uint32_t num_streams, unsigned char *endpoints, int num_endpoints);
+int LIBUSB_CALL libusb_free_streams(libusb_device_handle *dev_handle, unsigned char *endpoints, int num_endpoints);
+
+unsigned char *LIBUSB_CALL libusb_dev_mem_alloc(libusb_device_handle *dev_handle, size_t length);
+int LIBUSB_CALL            libusb_dev_mem_free(libusb_device_handle *dev_handle, unsigned char *buffer, size_t length);
+
+int LIBUSB_CALL libusb_kernel_driver_active(libusb_device_handle *dev_handle, int interface_number);
+int LIBUSB_CALL libusb_detach_kernel_driver(libusb_device_handle *dev_handle, int interface_number);
+int LIBUSB_CALL libusb_attach_kernel_driver(libusb_device_handle *dev_handle, int interface_number);
+int LIBUSB_CALL libusb_set_auto_detach_kernel_driver(libusb_device_handle *dev_handle, int enable);
+
+/* async I/O */
+
+/** \ingroup libusb_asyncio
+ * Get the data section of a control transfer. This convenience function is here
+ * to remind you that the data does not start until 8 bytes into the actual
+ * buffer, as the setup packet comes first.
+ *
+ * Calling this function only makes sense from a transfer callback function,
+ * or situations where you have already allocated a suitably sized buffer at
+ * transfer->buffer.
+ *
+ * \param transfer a transfer
+ * \returns pointer to the first byte of the data section
+ */
+static inline unsigned char *libusb_control_transfer_get_data(struct libusb_transfer *transfer) {
+    return transfer->buffer + LIBUSB_CONTROL_SETUP_SIZE;
+}
+
+/** \ingroup libusb_asyncio
+ * Get the control setup packet of a control transfer. This convenience
+ * function is here to remind you that the control setup occupies the first
+ * 8 bytes of the transfer data buffer.
+ *
+ * Calling this function only makes sense from a transfer callback function,
+ * or situations where you have already allocated a suitably sized buffer at
+ * transfer->buffer.
+ *
+ * \param transfer a transfer
+ * \returns a casted pointer to the start of the transfer data buffer
+ */
+static inline struct libusb_control_setup *libusb_control_transfer_get_setup(struct libusb_transfer *transfer) {
+    return (struct libusb_control_setup *)(void *)transfer->buffer;
+}
+
+/** \ingroup libusb_asyncio
+ * Helper function to populate the setup packet (first 8 bytes of the data
+ * buffer) for a control transfer. The wIndex, wValue and wLength values should
+ * be given in host-endian byte order.
+ *
+ * \param buffer buffer to output the setup packet into
+ * This pointer must be aligned to at least 2 bytes boundary.
+ * \param bmRequestType see the
+ * \ref libusb_control_setup::bmRequestType "bmRequestType" field of
+ * \ref libusb_control_setup
+ * \param bRequest see the
+ * \ref libusb_control_setup::bRequest "bRequest" field of
+ * \ref libusb_control_setup
+ * \param wValue see the
+ * \ref libusb_control_setup::wValue "wValue" field of
+ * \ref libusb_control_setup
+ * \param wIndex see the
+ * \ref libusb_control_setup::wIndex "wIndex" field of
+ * \ref libusb_control_setup
+ * \param wLength see the
+ * \ref libusb_control_setup::wLength "wLength" field of
+ * \ref libusb_control_setup
+ */
+static inline void libusb_fill_control_setup(unsigned char *buffer, uint8_t bmRequestType, uint8_t bRequest, uint16_t wValue, uint16_t wIndex,
+                                             uint16_t wLength) {
+    struct libusb_control_setup *setup = (struct libusb_control_setup *)(void *)buffer;
+    setup->bmRequestType               = bmRequestType;
+    setup->bRequest                    = bRequest;
+    setup->wValue                      = libusb_cpu_to_le16(wValue);
+    setup->wIndex                      = libusb_cpu_to_le16(wIndex);
+    setup->wLength                     = libusb_cpu_to_le16(wLength);
+}
+
+struct libusb_transfer *LIBUSB_CALL libusb_alloc_transfer(int iso_packets);
+int LIBUSB_CALL                     libusb_submit_transfer(struct libusb_transfer *transfer);
+int LIBUSB_CALL                     libusb_cancel_transfer(struct libusb_transfer *transfer);
+void LIBUSB_CALL                    libusb_free_transfer(struct libusb_transfer *transfer);
+void LIBUSB_CALL                    libusb_transfer_set_stream_id(struct libusb_transfer *transfer, uint32_t stream_id);
+uint32_t LIBUSB_CALL                libusb_transfer_get_stream_id(struct libusb_transfer *transfer);
+
+/** \ingroup libusb_asyncio
+ * Helper function to populate the required \ref libusb_transfer fields
+ * for a control transfer.
+ *
+ * If you pass a transfer buffer to this function, the first 8 bytes will
+ * be interpreted as a control setup packet, and the wLength field will be
+ * used to automatically populate the \ref libusb_transfer::length "length"
+ * field of the transfer. Therefore the recommended approach is:
+ * -# Allocate a suitably sized data buffer (including space for control setup)
+ * -# Call libusb_fill_control_setup()
+ * -# If this is a host-to-device transfer with a data stage, put the data
+ *    in place after the setup packet
+ * -# Call this function
+ * -# Call libusb_submit_transfer()
+ *
+ * It is also legal to pass a NULL buffer to this function, in which case this
+ * function will not attempt to populate the length field. Remember that you
+ * must then populate the buffer and length fields later.
+ *
+ * \param transfer the transfer to populate
+ * \param dev_handle handle of the device that will handle the transfer
+ * \param buffer data buffer. If provided, this function will interpret the
+ * first 8 bytes as a setup packet and infer the transfer length from that.
+ * This pointer must be aligned to at least 2 bytes boundary.
+ * \param callback callback function to be invoked on transfer completion
+ * \param user_data user data to pass to callback function
+ * \param timeout timeout for the transfer in milliseconds
+ */
+static inline void libusb_fill_control_transfer(struct libusb_transfer *transfer, libusb_device_handle *dev_handle, unsigned char *buffer,
+                                                libusb_transfer_cb_fn callback, void *user_data, unsigned int timeout) {
+    struct libusb_control_setup *setup = (struct libusb_control_setup *)(void *)buffer;
+    transfer->dev_handle               = dev_handle;
+    transfer->endpoint                 = 0;
+    transfer->type                     = LIBUSB_TRANSFER_TYPE_CONTROL;
+    transfer->timeout                  = timeout;
+    transfer->buffer                   = buffer;
+    if(setup)
+        transfer->length = (int)(LIBUSB_CONTROL_SETUP_SIZE + libusb_le16_to_cpu(setup->wLength));
+    transfer->user_data = user_data;
+    transfer->callback  = callback;
+}
+
+/** \ingroup libusb_asyncio
+ * Helper function to populate the required \ref libusb_transfer fields
+ * for a bulk transfer.
+ *
+ * \param transfer the transfer to populate
+ * \param dev_handle handle of the device that will handle the transfer
+ * \param endpoint address of the endpoint where this transfer will be sent
+ * \param buffer data buffer
+ * \param length length of data buffer
+ * \param callback callback function to be invoked on transfer completion
+ * \param user_data user data to pass to callback function
+ * \param timeout timeout for the transfer in milliseconds
+ */
+static inline void libusb_fill_bulk_transfer(struct libusb_transfer *transfer, libusb_device_handle *dev_handle, unsigned char endpoint, unsigned char *buffer,
+                                             int length, libusb_transfer_cb_fn callback, void *user_data, unsigned int timeout) {
+    transfer->dev_handle = dev_handle;
+    transfer->endpoint   = endpoint;
+    transfer->type       = LIBUSB_TRANSFER_TYPE_BULK;
+    transfer->timeout    = timeout;
+    transfer->buffer     = buffer;
+    transfer->length     = length;
+    transfer->user_data  = user_data;
+    transfer->callback   = callback;
+}
+
+/** \ingroup libusb_asyncio
+ * Helper function to populate the required \ref libusb_transfer fields
+ * for a bulk transfer using bulk streams.
+ *
+ * Since version 1.0.19, \ref LIBUSB_API_VERSION >= 0x01000103
+ *
+ * \param transfer the transfer to populate
+ * \param dev_handle handle of the device that will handle the transfer
+ * \param endpoint address of the endpoint where this transfer will be sent
+ * \param stream_id bulk stream id for this transfer
+ * \param buffer data buffer
+ * \param length length of data buffer
+ * \param callback callback function to be invoked on transfer completion
+ * \param user_data user data to pass to callback function
+ * \param timeout timeout for the transfer in milliseconds
+ */
+static inline void libusb_fill_bulk_stream_transfer(struct libusb_transfer *transfer, libusb_device_handle *dev_handle, unsigned char endpoint,
+                                                    uint32_t stream_id, unsigned char *buffer, int length, libusb_transfer_cb_fn callback, void *user_data,
+                                                    unsigned int timeout) {
+    libusb_fill_bulk_transfer(transfer, dev_handle, endpoint, buffer, length, callback, user_data, timeout);
+    transfer->type = LIBUSB_TRANSFER_TYPE_BULK_STREAM;
+    libusb_transfer_set_stream_id(transfer, stream_id);
+}
+
+/** \ingroup libusb_asyncio
+ * Helper function to populate the required \ref libusb_transfer fields
+ * for an interrupt transfer.
+ *
+ * \param transfer the transfer to populate
+ * \param dev_handle handle of the device that will handle the transfer
+ * \param endpoint address of the endpoint where this transfer will be sent
+ * \param buffer data buffer
+ * \param length length of data buffer
+ * \param callback callback function to be invoked on transfer completion
+ * \param user_data user data to pass to callback function
+ * \param timeout timeout for the transfer in milliseconds
+ */
+static inline void libusb_fill_interrupt_transfer(struct libusb_transfer *transfer, libusb_device_handle *dev_handle, unsigned char endpoint,
+                                                  unsigned char *buffer, int length, libusb_transfer_cb_fn callback, void *user_data, unsigned int timeout) {
+    transfer->dev_handle = dev_handle;
+    transfer->endpoint   = endpoint;
+    transfer->type       = LIBUSB_TRANSFER_TYPE_INTERRUPT;
+    transfer->timeout    = timeout;
+    transfer->buffer     = buffer;
+    transfer->length     = length;
+    transfer->user_data  = user_data;
+    transfer->callback   = callback;
+}
+
+/** \ingroup libusb_asyncio
+ * Helper function to populate the required \ref libusb_transfer fields
+ * for an isochronous transfer.
+ *
+ * \param transfer the transfer to populate
+ * \param dev_handle handle of the device that will handle the transfer
+ * \param endpoint address of the endpoint where this transfer will be sent
+ * \param buffer data buffer
+ * \param length length of data buffer
+ * \param num_iso_packets the number of isochronous packets
+ * \param callback callback function to be invoked on transfer completion
+ * \param user_data user data to pass to callback function
+ * \param timeout timeout for the transfer in milliseconds
+ */
+static inline void libusb_fill_iso_transfer(struct libusb_transfer *transfer, libusb_device_handle *dev_handle, unsigned char endpoint, unsigned char *buffer,
+                                            int length, int num_iso_packets, libusb_transfer_cb_fn callback, void *user_data, unsigned int timeout) {
+    transfer->dev_handle      = dev_handle;
+    transfer->endpoint        = endpoint;
+    transfer->type            = LIBUSB_TRANSFER_TYPE_ISOCHRONOUS;
+    transfer->timeout         = timeout;
+    transfer->buffer          = buffer;
+    transfer->length          = length;
+    transfer->num_iso_packets = num_iso_packets;
+    transfer->user_data       = user_data;
+    transfer->callback        = callback;
+}
+
+/** \ingroup libusb_asyncio
+ * Convenience function to set the length of all packets in an isochronous
+ * transfer, based on the num_iso_packets field in the transfer structure.
+ *
+ * \param transfer a transfer
+ * \param length the length to set in each isochronous packet descriptor
+ * \see libusb_get_max_packet_size()
+ */
+static inline void libusb_set_iso_packet_lengths(struct libusb_transfer *transfer, unsigned int length) {
+    int i;
+
+    for(i = 0; i < transfer->num_iso_packets; i++)
+        transfer->iso_packet_desc[i].length = length;
+}
+
+/** \ingroup libusb_asyncio
+ * Convenience function to locate the position of an isochronous packet
+ * within the buffer of an isochronous transfer.
+ *
+ * This is a thorough function which loops through all preceding packets,
+ * accumulating their lengths to find the position of the specified packet.
+ * Typically you will assign equal lengths to each packet in the transfer,
+ * and hence the above method is sub-optimal. You may wish to use
+ * libusb_get_iso_packet_buffer_simple() instead.
+ *
+ * \param transfer a transfer
+ * \param packet the packet to return the address of
+ * \returns the base address of the packet buffer inside the transfer buffer,
+ * or NULL if the packet does not exist.
+ * \see libusb_get_iso_packet_buffer_simple()
+ */
+static inline unsigned char *libusb_get_iso_packet_buffer(struct libusb_transfer *transfer, unsigned int packet) {
+    int    i;
+    size_t offset = 0;
+    int    _packet;
+
+    /* oops..slight bug in the API. packet is an unsigned int, but we use
+     * signed integers almost everywhere else. range-check and convert to
+     * signed to avoid compiler warnings. FIXME for libusb-2. */
+    if(packet > INT_MAX)
+        return NULL;
+    _packet = (int)packet;
+
+    if(_packet >= transfer->num_iso_packets)
+        return NULL;
+
+    for(i = 0; i < _packet; i++)
+        offset += transfer->iso_packet_desc[i].length;
+
+    return transfer->buffer + offset;
+}
+
+/** \ingroup libusb_asyncio
+ * Convenience function to locate the position of an isochronous packet
+ * within the buffer of an isochronous transfer, for transfers where each
+ * packet is of identical size.
+ *
+ * This function relies on the assumption that every packet within the transfer
+ * is of identical size to the first packet. Calculating the location of
+ * the packet buffer is then just a simple calculation:
+ * <tt>buffer + (packet_size * packet)</tt>
+ *
+ * Do not use this function on transfers other than those that have identical
+ * packet lengths for each packet.
+ *
+ * \param transfer a transfer
+ * \param packet the packet to return the address of
+ * \returns the base address of the packet buffer inside the transfer buffer,
+ * or NULL if the packet does not exist.
+ * \see libusb_get_iso_packet_buffer()
+ */
+static inline unsigned char *libusb_get_iso_packet_buffer_simple(struct libusb_transfer *transfer, unsigned int packet) {
+    int _packet;
+
+    /* oops..slight bug in the API. packet is an unsigned int, but we use
+     * signed integers almost everywhere else. range-check and convert to
+     * signed to avoid compiler warnings. FIXME for libusb-2. */
+    if(packet > INT_MAX)
+        return NULL;
+    _packet = (int)packet;
+
+    if(_packet >= transfer->num_iso_packets)
+        return NULL;
+
+    return transfer->buffer + ((int)transfer->iso_packet_desc[0].length * _packet);
+}
+
+/* sync I/O */
+
+int LIBUSB_CALL libusb_control_transfer(libusb_device_handle *dev_handle, uint8_t request_type, uint8_t bRequest, uint16_t wValue, uint16_t wIndex,
+                                        unsigned char *data, uint16_t wLength, unsigned int timeout);
+
+int LIBUSB_CALL libusb_bulk_transfer(libusb_device_handle *dev_handle, unsigned char endpoint, unsigned char *data, int length, int *actual_length,
+                                     unsigned int timeout);
+
+int LIBUSB_CALL libusb_interrupt_transfer(libusb_device_handle *dev_handle, unsigned char endpoint, unsigned char *data, int length, int *actual_length,
+                                          unsigned int timeout);
+
+/** \ingroup libusb_desc
+ * Retrieve a descriptor from the default control pipe.
+ * This is a convenience function which formulates the appropriate control
+ * message to retrieve the descriptor.
+ *
+ * \param dev_handle a device handle
+ * \param desc_type the descriptor type, see \ref libusb_descriptor_type
+ * \param desc_index the index of the descriptor to retrieve
+ * \param data output buffer for descriptor
+ * \param length size of data buffer
+ * \returns number of bytes returned in data, or LIBUSB_ERROR code on failure
+ */
+static inline int libusb_get_descriptor(libusb_device_handle *dev_handle, uint8_t desc_type, uint8_t desc_index, unsigned char *data, int length) {
+    return libusb_control_transfer(dev_handle, LIBUSB_ENDPOINT_IN, LIBUSB_REQUEST_GET_DESCRIPTOR, (uint16_t)((desc_type << 8) | desc_index), 0, data,
+                                   (uint16_t)length, 1000);
+}
+
+/** \ingroup libusb_desc
+ * Retrieve a descriptor from a device.
+ * This is a convenience function which formulates the appropriate control
+ * message to retrieve the descriptor. The string returned is Unicode, as
+ * detailed in the USB specifications.
+ *
+ * \param dev_handle a device handle
+ * \param desc_index the index of the descriptor to retrieve
+ * \param langid the language ID for the string descriptor
+ * \param data output buffer for descriptor
+ * \param length size of data buffer
+ * \returns number of bytes returned in data, or LIBUSB_ERROR code on failure
+ * \see libusb_get_string_descriptor_ascii()
+ */
+static inline int libusb_get_string_descriptor(libusb_device_handle *dev_handle, uint8_t desc_index, uint16_t langid, unsigned char *data, int length) {
+    return libusb_control_transfer(dev_handle, LIBUSB_ENDPOINT_IN, LIBUSB_REQUEST_GET_DESCRIPTOR, (uint16_t)((LIBUSB_DT_STRING << 8) | desc_index), langid,
+                                   data, (uint16_t)length, 1000);
+}
+
+int LIBUSB_CALL libusb_get_string_descriptor_ascii(libusb_device_handle *dev_handle, uint8_t desc_index, unsigned char *data, int length);
+
+/* polling and timeouts */
+
+int LIBUSB_CALL  libusb_try_lock_events(libusb_context *ctx);
+void LIBUSB_CALL libusb_lock_events(libusb_context *ctx);
+void LIBUSB_CALL libusb_unlock_events(libusb_context *ctx);
+int LIBUSB_CALL  libusb_event_handling_ok(libusb_context *ctx);
+int LIBUSB_CALL  libusb_event_handler_active(libusb_context *ctx);
+void LIBUSB_CALL libusb_interrupt_event_handler(libusb_context *ctx);
+void LIBUSB_CALL libusb_lock_event_waiters(libusb_context *ctx);
+void LIBUSB_CALL libusb_unlock_event_waiters(libusb_context *ctx);
+int LIBUSB_CALL  libusb_wait_for_event(libusb_context *ctx, struct timeval *tv);
+
+int LIBUSB_CALL libusb_handle_events_timeout(libusb_context *ctx, struct timeval *tv);
+int LIBUSB_CALL libusb_handle_events_timeout_completed(libusb_context *ctx, struct timeval *tv, int *completed);
+int LIBUSB_CALL libusb_handle_events(libusb_context *ctx);
+int LIBUSB_CALL libusb_handle_events_completed(libusb_context *ctx, int *completed);
+int LIBUSB_CALL libusb_handle_events_locked(libusb_context *ctx, struct timeval *tv);
+int LIBUSB_CALL libusb_pollfds_handle_timeouts(libusb_context *ctx);
+int LIBUSB_CALL libusb_get_next_timeout(libusb_context *ctx, struct timeval *tv);
+
+/** \ingroup libusb_poll
+ * File descriptor for polling
+ */
+struct libusb_pollfd {
+    /** Numeric file descriptor */
+    int fd;
+
+    /** Event flags to poll for from <poll.h>. POLLIN indicates that you
+     * should monitor this file descriptor for becoming ready to read from,
+     * and POLLOUT indicates that you should monitor this file descriptor for
+     * nonblocking write readiness. */
+    short events;
+};
+
+/** \ingroup libusb_poll
+ * Callback function, invoked when a new file descriptor should be added
+ * to the set of file descriptors monitored for events.
+ * \param fd the new file descriptor
+ * \param events events to monitor for, see \ref libusb_pollfd for a
+ * description
+ * \param user_data User data pointer specified in
+ * libusb_set_pollfd_notifiers() call
+ * \see libusb_set_pollfd_notifiers()
+ */
+typedef void(LIBUSB_CALL *libusb_pollfd_added_cb)(int fd, short events, void *user_data);
+
+/** \ingroup libusb_poll
+ * Callback function, invoked when a file descriptor should be removed from
+ * the set of file descriptors being monitored for events. After returning
+ * from this callback, do not use that file descriptor again.
+ * \param fd the file descriptor to stop monitoring
+ * \param user_data User data pointer specified in
+ * libusb_set_pollfd_notifiers() call
+ * \see libusb_set_pollfd_notifiers()
+ */
+typedef void(LIBUSB_CALL *libusb_pollfd_removed_cb)(int fd, void *user_data);
+
+const struct libusb_pollfd **LIBUSB_CALL libusb_get_pollfds(libusb_context *ctx);
+void LIBUSB_CALL                         libusb_free_pollfds(const struct libusb_pollfd **pollfds);
+void LIBUSB_CALL libusb_set_pollfd_notifiers(libusb_context *ctx, libusb_pollfd_added_cb added_cb, libusb_pollfd_removed_cb removed_cb, void *user_data);
+
+/** \ingroup libusb_hotplug
+ * Callback handle.
+ *
+ * Callbacks handles are generated by libusb_hotplug_register_callback()
+ * and can be used to deregister callbacks. Callback handles are unique
+ * per libusb_context and it is safe to call libusb_hotplug_deregister_callback()
+ * on an already deregistered callback.
+ *
+ * Since version 1.0.16, \ref LIBUSB_API_VERSION >= 0x01000102
+ *
+ * For more information, see \ref libusb_hotplug.
+ */
+typedef int libusb_hotplug_callback_handle;
+
+/** \ingroup libusb_hotplug
+ *
+ * Since version 1.0.16, \ref LIBUSB_API_VERSION >= 0x01000102
+ *
+ * Hotplug events */
+typedef enum {
+    /** A device has been plugged in and is ready to use */
+    LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED = (1 << 0),
+
+    /** A device has left and is no longer available.
+     * It is the user's responsibility to call libusb_close on any handle associated with a disconnected device.
+     * It is safe to call libusb_get_device_descriptor on a device that has left */
+    LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT = (1 << 1)
+} libusb_hotplug_event;
+
+/** \ingroup libusb_hotplug
+ *
+ * Since version 1.0.16, \ref LIBUSB_API_VERSION >= 0x01000102
+ *
+ * Hotplug flags */
+typedef enum {
+    /** Arm the callback and fire it for all matching currently attached devices. */
+    LIBUSB_HOTPLUG_ENUMERATE = (1 << 0)
+} libusb_hotplug_flag;
+
+/** \ingroup libusb_hotplug
+ * Convenience macro when not using any flags */
+#define LIBUSB_HOTPLUG_NO_FLAGS 0
+
+/** \ingroup libusb_hotplug
+ * Wildcard matching for hotplug events */
+#define LIBUSB_HOTPLUG_MATCH_ANY -1
+
+/** \ingroup libusb_hotplug
+ * Hotplug callback function type. When requesting hotplug event notifications,
+ * you pass a pointer to a callback function of this type.
+ *
+ * This callback may be called by an internal event thread and as such it is
+ * recommended the callback do minimal processing before returning.
+ *
+ * libusb will call this function later, when a matching event had happened on
+ * a matching device. See \ref libusb_hotplug for more information.
+ *
+ * It is safe to call either libusb_hotplug_register_callback() or
+ * libusb_hotplug_deregister_callback() from within a callback function.
+ *
+ * Since version 1.0.16, \ref LIBUSB_API_VERSION >= 0x01000102
+ *
+ * \param ctx            context of this notification
+ * \param device         libusb_device this event occurred on
+ * \param event          event that occurred
+ * \param user_data      user data provided when this callback was registered
+ * \returns bool whether this callback is finished processing events.
+ *                       returning 1 will cause this callback to be deregistered
+ */
+typedef int(LIBUSB_CALL *libusb_hotplug_callback_fn)(libusb_context *ctx, libusb_device *device, libusb_hotplug_event event, void *user_data);
+
+/** \ingroup libusb_hotplug
+ * Register a hotplug callback function
+ *
+ * Register a callback with the libusb_context. The callback will fire
+ * when a matching event occurs on a matching device. The callback is
+ * armed until either it is deregistered with libusb_hotplug_deregister_callback()
+ * or the supplied callback returns 1 to indicate it is finished processing events.
+ *
+ * If the \ref LIBUSB_HOTPLUG_ENUMERATE is passed the callback will be
+ * called with a \ref LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED for all devices
+ * already plugged into the machine. Note that libusb modifies its internal
+ * device list from a separate thread, while calling hotplug callbacks from
+ * libusb_handle_events(), so it is possible for a device to already be present
+ * on, or removed from, its internal device list, while the hotplug callbacks
+ * still need to be dispatched. This means that when using \ref
+ * LIBUSB_HOTPLUG_ENUMERATE, your callback may be called twice for the arrival
+ * of the same device, once from libusb_hotplug_register_callback() and once
+ * from libusb_handle_events(); and/or your callback may be called for the
+ * removal of a device for which an arrived call was never made.
+ *
+ * Since version 1.0.16, \ref LIBUSB_API_VERSION >= 0x01000102
+ *
+ * \param[in] ctx context to register this callback with
+ * \param[in] events bitwise or of hotplug events that will trigger this callback.
+ *            See \ref libusb_hotplug_event
+ * \param[in] flags bitwise or of hotplug flags that affect registration.
+ *            See \ref libusb_hotplug_flag
+ * \param[in] vendor_id the vendor id to match or \ref LIBUSB_HOTPLUG_MATCH_ANY
+ * \param[in] product_id the product id to match or \ref LIBUSB_HOTPLUG_MATCH_ANY
+ * \param[in] dev_class the device class to match or \ref LIBUSB_HOTPLUG_MATCH_ANY
+ * \param[in] cb_fn the function to be invoked on a matching event/device
+ * \param[in] user_data user data to pass to the callback function
+ * \param[out] callback_handle pointer to store the handle of the allocated callback (can be NULL)
+ * \returns \ref LIBUSB_SUCCESS on success LIBUSB_ERROR code on failure
+ */
+int LIBUSB_CALL libusb_hotplug_register_callback(libusb_context *ctx, int events, int flags, int vendor_id, int product_id, int dev_class,
+                                                 libusb_hotplug_callback_fn cb_fn, void *user_data, libusb_hotplug_callback_handle *callback_handle);
+
+/** \ingroup libusb_hotplug
+ * Deregisters a hotplug callback.
+ *
+ * Deregister a callback from a libusb_context. This function is safe to call from within
+ * a hotplug callback.
+ *
+ * Since version 1.0.16, \ref LIBUSB_API_VERSION >= 0x01000102
+ *
+ * \param[in] ctx context this callback is registered with
+ * \param[in] callback_handle the handle of the callback to deregister
+ */
+void LIBUSB_CALL libusb_hotplug_deregister_callback(libusb_context *ctx, libusb_hotplug_callback_handle callback_handle);
+
+/** \ingroup libusb_hotplug
+ * Gets the user_data associated with a hotplug callback.
+ *
+ * Since version v1.0.24 \ref LIBUSB_API_VERSION >= 0x01000108
+ *
+ * \param[in] ctx context this callback is registered with
+ * \param[in] callback_handle the handle of the callback to get the user_data of
+ */
+void *LIBUSB_CALL libusb_hotplug_get_user_data(libusb_context *ctx, libusb_hotplug_callback_handle callback_handle);
+
+int LIBUSB_CALLV libusb_set_option(libusb_context *ctx, enum libusb_option option, ...);
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+#if defined(__cplusplus)
+}
+#endif
+
+#endif
diff --git a/3rdparty/libusb/src/libusb/libusbi.h b/3rdparty/libusb/src/libusb/libusbi.h
new file mode 100644
index 00000000..f9ad1ed5
--- /dev/null
+++ b/3rdparty/libusb/src/libusb/libusbi.h
@@ -0,0 +1,1439 @@
+/*
+ * Internal header for libusb
+ * Copyright © 2007-2009 Daniel Drake <dsd@gentoo.org>
+ * Copyright © 2001 Johannes Erdfelt <johannes@erdfelt.com>
+ * Copyright © 2019 Nathan Hjelm <hjelmn@cs.umm.edu>
+ * Copyright © 2019-2020 Google LLC. All rights reserved.
+ * Copyright © 2020 Chris Dickens <christopher.a.dickens@gmail.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef LIBUSBI_H
+#define LIBUSBI_H
+
+#include <libusb/config.h>
+
+#include <assert.h>
+#include <inttypes.h>
+#include <stdarg.h>
+#include <stddef.h>
+#include <stdlib.h>
+#ifdef HAVE_SYS_TIME_H
+#include <sys/time.h>
+#endif
+
+#include "libusb.h"
+
+/* Not all C standard library headers define static_assert in assert.h
+ * Additionally, Visual Studio treats static_assert as a keyword.
+ */
+#if !defined(__cplusplus) && !defined(static_assert) && !defined(_MSC_VER)
+#define static_assert(cond, msg) _Static_assert(cond, msg)
+#endif
+
+#ifdef NDEBUG
+#define ASSERT_EQ(expression, value) (void)expression
+#define ASSERT_NE(expression, value) (void)expression
+#else
+#define ASSERT_EQ(expression, value) assert(expression == value)
+#define ASSERT_NE(expression, value) assert(expression != value)
+#endif
+
+#define container_of(ptr, type, member) ((type *)((uintptr_t)(ptr) - (uintptr_t)offsetof(type, member)))
+
+#ifndef ARRAYSIZE
+#define ARRAYSIZE(array) (sizeof(array) / sizeof(array[0]))
+#endif
+
+#ifndef CLAMP
+#define CLAMP(val, min, max) ((val) < (min) ? (min) : ((val) > (max) ? (max) : (val)))
+#endif
+
+#ifndef MIN
+#define MIN(a, b) ((a) < (b) ? (a) : (b))
+#endif
+
+#ifndef MAX
+#define MAX(a, b) ((a) > (b) ? (a) : (b))
+#endif
+
+/* The following is used to silence warnings for unused variables */
+#if defined(UNREFERENCED_PARAMETER)
+#define UNUSED(var) UNREFERENCED_PARAMETER(var)
+#else
+#define UNUSED(var)  \
+    do {             \
+        (void)(var); \
+    } while(0)
+#endif
+
+/* Macro to align a value up to the next multiple of the size of a pointer */
+#define PTR_ALIGN(v) (((v) + (sizeof(void *) - 1)) & ~(sizeof(void *) - 1))
+
+/* Atomic operations
+ *
+ * Useful for reference counting or when accessing a value without a lock
+ *
+ * The following atomic operations are defined:
+ *   usbi_atomic_load() - Atomically read a variable's value
+ *   usbi_atomic_store() - Atomically write a new value value to a variable
+ *   usbi_atomic_inc() - Atomically increment a variable's value and return the new value
+ *   usbi_atomic_dec() - Atomically decrement a variable's value and return the new value
+ *
+ * All of these operations are ordered with each other, thus the effects of
+ * any one operation is guaranteed to be seen by any other operation.
+ */
+#ifdef _MSC_VER
+typedef volatile LONG usbi_atomic_t;
+#define usbi_atomic_load(a) (*(a))
+#define usbi_atomic_store(a, v) (*(a)) = (v)
+#define usbi_atomic_inc(a) InterlockedIncrement((a))
+#define usbi_atomic_dec(a) InterlockedDecrement((a))
+#else
+#include <stdatomic.h>
+typedef atomic_long usbi_atomic_t;
+#define usbi_atomic_load(a) atomic_load((a))
+#define usbi_atomic_store(a, v) atomic_store((a), (v))
+#define usbi_atomic_inc(a) (atomic_fetch_add((a), 1) + 1)
+#define usbi_atomic_dec(a) (atomic_fetch_add((a), -1) - 1)
+#endif
+
+/* Internal abstractions for event handling and thread synchronization */
+#if defined(PLATFORM_POSIX)
+#include "os/events_posix.h"
+#include "os/threads_posix.h"
+#elif defined(PLATFORM_WINDOWS)
+#include "os/events_windows.h"
+#include "os/threads_windows.h"
+#endif
+
+/* Inside the libusb code, mark all public functions as follows:
+ *   return_type API_EXPORTED function_name(params) { ... }
+ * But if the function returns a pointer, mark it as follows:
+ *   DEFAULT_VISIBILITY return_type * LIBUSB_CALL function_name(params) { ... }
+ * In the libusb public header, mark all declarations as:
+ *   return_type LIBUSB_CALL function_name(params);
+ */
+#define API_EXPORTED LIBUSB_CALL DEFAULT_VISIBILITY
+#define API_EXPORTEDV LIBUSB_CALLV DEFAULT_VISIBILITY
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define USB_MAXENDPOINTS 32
+#define USB_MAXINTERFACES 32
+#define USB_MAXCONFIG 8
+
+/* Backend specific capabilities */
+#define USBI_CAP_HAS_HID_ACCESS 0x00010000
+#define USBI_CAP_SUPPORTS_DETACH_KERNEL_DRIVER 0x00020000
+
+/* Maximum number of bytes in a log line */
+#define USBI_MAX_LOG_LEN 1024
+/* Terminator for log lines */
+#define USBI_LOG_LINE_END "\n"
+
+struct list_head {
+    struct list_head *prev, *next;
+};
+
+/* Get an entry from the list
+ *  ptr - the address of this list_head element in "type"
+ *  type - the data type that contains "member"
+ *  member - the list_head element in "type"
+ */
+#define list_entry(ptr, type, member) container_of(ptr, type, member)
+
+#define list_first_entry(ptr, type, member) list_entry((ptr)->next, type, member)
+
+#define list_next_entry(ptr, type, member) list_entry((ptr)->member.next, type, member)
+
+/* Get each entry from a list
+ *  pos - A structure pointer has a "member" element
+ *  head - list head
+ *  member - the list_head element in "pos"
+ *  type - the type of the first parameter
+ */
+#define list_for_each_entry(pos, head, member, type) \
+    for(pos = list_first_entry(head, type, member); &pos->member != (head); pos = list_next_entry(pos, type, member))
+
+#define list_for_each_entry_safe(pos, n, head, member, type)                                                        \
+    for(pos = list_first_entry(head, type, member), n = list_next_entry(pos, type, member); &pos->member != (head); \
+        pos = n, n = list_next_entry(n, type, member))
+
+/* Helper macros to iterate over a list. The structure pointed
+ * to by "pos" must have a list_head member named "list".
+ */
+#define for_each_helper(pos, head, type) list_for_each_entry(pos, head, list, type)
+
+#define for_each_safe_helper(pos, n, head, type) list_for_each_entry_safe(pos, n, head, list, type)
+
+#define list_empty(entry) ((entry)->next == (entry))
+
+static inline void list_init(struct list_head *entry) {
+    entry->prev = entry->next = entry;
+}
+
+static inline void list_add(struct list_head *entry, struct list_head *head) {
+    entry->next = head->next;
+    entry->prev = head;
+
+    head->next->prev = entry;
+    head->next       = entry;
+}
+
+static inline void list_add_tail(struct list_head *entry, struct list_head *head) {
+    entry->next = head;
+    entry->prev = head->prev;
+
+    head->prev->next = entry;
+    head->prev       = entry;
+}
+
+static inline void list_del(struct list_head *entry) {
+    entry->next->prev = entry->prev;
+    entry->prev->next = entry->next;
+    entry->next = entry->prev = NULL;
+}
+
+static inline void list_cut(struct list_head *list, struct list_head *head) {
+    if(list_empty(head)) {
+        list_init(list);
+        return;
+    }
+
+    list->next       = head->next;
+    list->next->prev = list;
+    list->prev       = head->prev;
+    list->prev->next = list;
+
+    list_init(head);
+}
+
+static inline void list_splice_front(struct list_head *list, struct list_head *head) {
+    list->next->prev = head;
+    list->prev->next = head->next;
+    head->next->prev = list->prev;
+    head->next       = list->next;
+}
+
+static inline void *usbi_reallocf(void *ptr, size_t size) {
+    void *ret = realloc(ptr, size);
+
+    if(!ret)
+        free(ptr);
+    return ret;
+}
+
+#if !defined(USEC_PER_SEC)
+#define USEC_PER_SEC 1000000L
+#endif
+
+#if !defined(NSEC_PER_SEC)
+#define NSEC_PER_SEC 1000000000L
+#endif
+
+#define TIMEVAL_IS_VALID(tv) ((tv)->tv_sec >= 0 && (tv)->tv_usec >= 0 && (tv)->tv_usec < USEC_PER_SEC)
+
+#define TIMESPEC_IS_SET(ts) ((ts)->tv_sec || (ts)->tv_nsec)
+#define TIMESPEC_CLEAR(ts) (ts)->tv_sec = (ts)->tv_nsec = 0
+#define TIMESPEC_CMP(a, b, CMP) (((a)->tv_sec == (b)->tv_sec) ? ((a)->tv_nsec CMP(b)->tv_nsec) : ((a)->tv_sec CMP(b)->tv_sec))
+#define TIMESPEC_SUB(a, b, result)                       \
+    do {                                                 \
+        (result)->tv_sec  = (a)->tv_sec - (b)->tv_sec;   \
+        (result)->tv_nsec = (a)->tv_nsec - (b)->tv_nsec; \
+        if((result)->tv_nsec < 0L) {                     \
+            --(result)->tv_sec;                          \
+            (result)->tv_nsec += NSEC_PER_SEC;           \
+        }                                                \
+    } while(0)
+
+#if defined(PLATFORM_WINDOWS)
+#define TIMEVAL_TV_SEC_TYPE long
+#else
+#define TIMEVAL_TV_SEC_TYPE time_t
+#endif
+
+/* Some platforms don't have this define */
+#ifndef TIMESPEC_TO_TIMEVAL
+#define TIMESPEC_TO_TIMEVAL(tv, ts)                        \
+    do {                                                   \
+        (tv)->tv_sec  = (TIMEVAL_TV_SEC_TYPE)(ts)->tv_sec; \
+        (tv)->tv_usec = (ts)->tv_nsec / 1000L;             \
+    } while(0)
+#endif
+
+#ifdef ENABLE_LOGGING
+
+#if defined(_MSC_VER) && (_MSC_VER < 1900)
+#include <stdio.h>
+#define snprintf usbi_snprintf
+#define vsnprintf usbi_vsnprintf
+int usbi_snprintf(char *dst, size_t size, const char *format, ...);
+int usbi_vsnprintf(char *dst, size_t size, const char *format, va_list args);
+#define LIBUSB_PRINTF_WIN32
+#endif /* defined(_MSC_VER) && (_MSC_VER < 1900) */
+
+void usbi_log(struct libusb_context *ctx, enum libusb_log_level level, const char *function, const char *format, ...) PRINTF_FORMAT(4, 5);
+
+#define _usbi_log(ctx, level, ...) usbi_log(ctx, level, __func__, __VA_ARGS__)
+
+#define usbi_err(ctx, ...) _usbi_log(ctx, LIBUSB_LOG_LEVEL_ERROR, __VA_ARGS__)
+#define usbi_warn(ctx, ...) _usbi_log(ctx, LIBUSB_LOG_LEVEL_WARNING, __VA_ARGS__)
+#define usbi_info(ctx, ...) _usbi_log(ctx, LIBUSB_LOG_LEVEL_INFO, __VA_ARGS__)
+#define usbi_dbg(ctx, ...) _usbi_log(ctx, LIBUSB_LOG_LEVEL_DEBUG, __VA_ARGS__)
+
+#else /* ENABLE_LOGGING */
+
+#define usbi_err(ctx, ...) \
+    do {                   \
+        (void)(ctx);       \
+    } while(0)
+#define usbi_warn(ctx, ...) \
+    do {                    \
+        (void)(ctx);        \
+    } while(0)
+#define usbi_info(ctx, ...) \
+    do {                    \
+        (void)(ctx);        \
+    } while(0)
+#define usbi_dbg(ctx, ...) \
+    do {                   \
+        (void)(ctx);       \
+    } while(0)
+
+#endif /* ENABLE_LOGGING */
+
+#define DEVICE_CTX(dev) ((dev)->ctx)
+#define HANDLE_CTX(handle) ((handle) ? DEVICE_CTX((handle)->dev) : NULL)
+#define ITRANSFER_CTX(itransfer) ((itransfer)->dev ? DEVICE_CTX((itransfer)->dev) : NULL)
+#define TRANSFER_CTX(transfer) (ITRANSFER_CTX(LIBUSB_TRANSFER_TO_USBI_TRANSFER(transfer)))
+
+#define IS_EPIN(ep) (0 != ((ep)&LIBUSB_ENDPOINT_IN))
+#define IS_EPOUT(ep) (!IS_EPIN(ep))
+#define IS_XFERIN(xfer) (0 != ((xfer)->endpoint & LIBUSB_ENDPOINT_IN))
+#define IS_XFEROUT(xfer) (!IS_XFERIN(xfer))
+
+struct libusb_context {
+#if defined(ENABLE_LOGGING) && !defined(ENABLE_DEBUG_LOGGING)
+    enum libusb_log_level debug;
+    int                   debug_fixed;
+    libusb_log_cb         log_handler;
+#endif
+
+    /* used for signalling occurrence of an internal event. */
+    usbi_event_t event;
+
+#ifdef HAVE_OS_TIMER
+    /* used for timeout handling, if supported by OS.
+     * this timer is maintained to trigger on the next pending timeout */
+    usbi_timer_t timer;
+#endif
+
+    struct list_head usb_devs;
+    usbi_mutex_t     usb_devs_lock;
+
+    /* A list of open handles. Backends are free to traverse this if required.
+     */
+    struct list_head open_devs;
+    usbi_mutex_t     open_devs_lock;
+
+    /* A list of registered hotplug callbacks */
+    struct list_head               hotplug_cbs;
+    libusb_hotplug_callback_handle next_hotplug_cb_handle;
+    usbi_mutex_t                   hotplug_cbs_lock;
+
+    /* A flag to indicate that the context is ready for hotplug notifications */
+    usbi_atomic_t hotplug_ready;
+
+    /* this is a list of in-flight transfer handles, sorted by timeout
+     * expiration. URBs to timeout the soonest are placed at the beginning of
+     * the list, URBs that will time out later are placed after, and urbs with
+     * infinite timeout are always placed at the very end. */
+    struct list_head flying_transfers;
+    /* Note paths taking both this and usbi_transfer->lock must always
+     * take this lock first */
+    usbi_mutex_t flying_transfers_lock;
+
+#if !defined(PLATFORM_WINDOWS)
+    /* user callbacks for pollfd changes */
+    libusb_pollfd_added_cb   fd_added_cb;
+    libusb_pollfd_removed_cb fd_removed_cb;
+    void                    *fd_cb_user_data;
+#endif
+
+    /* ensures that only one thread is handling events at any one time */
+    usbi_mutex_t events_lock;
+
+    /* used to see if there is an active thread doing event handling */
+    int event_handler_active;
+
+    /* A thread-local storage key to track which thread is performing event
+     * handling */
+    usbi_tls_key_t event_handling_key;
+
+    /* used to wait for event completion in threads other than the one that is
+     * event handling */
+    usbi_mutex_t event_waiters_lock;
+    usbi_cond_t  event_waiters_cond;
+
+    /* A lock to protect internal context event data. */
+    usbi_mutex_t event_data_lock;
+
+    /* A bitmask of flags that are set to indicate specific events that need to
+     * be handled. Protected by event_data_lock. */
+    unsigned int event_flags;
+
+    /* A counter that is set when we want to interrupt and prevent event handling,
+     * in order to safely close a device. Protected by event_data_lock. */
+    unsigned int device_close;
+
+    /* A list of currently active event sources. Protected by event_data_lock. */
+    struct list_head event_sources;
+
+    /* A list of event sources that have been removed since the last time
+     * event sources were waited on. Protected by event_data_lock. */
+    struct list_head removed_event_sources;
+
+    /* A pointer and count to platform-specific data used for monitoring event
+     * sources. Only accessed during event handling. */
+    void        *event_data;
+    unsigned int event_data_cnt;
+
+    /* A list of pending hotplug messages. Protected by event_data_lock. */
+    struct list_head hotplug_msgs;
+
+    /* A list of pending completed transfers. Protected by event_data_lock. */
+    struct list_head completed_transfers;
+
+    struct list_head list;
+};
+
+extern struct libusb_context *usbi_default_context;
+extern struct libusb_context *usbi_fallback_context;
+
+extern struct list_head    active_contexts_list;
+extern usbi_mutex_static_t active_contexts_lock;
+
+static inline struct libusb_context *usbi_get_context(struct libusb_context *ctx) {
+    static int warned = 0;
+
+    if(!ctx) {
+        ctx = usbi_default_context;
+    }
+    if(!ctx) {
+        ctx = usbi_fallback_context;
+        if(ctx && warned == 0) {
+            usbi_err(ctx, "API misuse! Using non-default context as implicit default.");
+            warned = 1;
+        }
+    }
+    return ctx;
+}
+
+enum usbi_event_flags {
+    /* The list of event sources has been modified */
+    USBI_EVENT_EVENT_SOURCES_MODIFIED = 1U << 0,
+
+    /* The user has interrupted the event handler */
+    USBI_EVENT_USER_INTERRUPT = 1U << 1,
+
+    /* A hotplug callback deregistration is pending */
+    USBI_EVENT_HOTPLUG_CB_DEREGISTERED = 1U << 2,
+
+    /* One or more hotplug messages are pending */
+    USBI_EVENT_HOTPLUG_MSG_PENDING = 1U << 3,
+
+    /* One or more completed transfers are pending */
+    USBI_EVENT_TRANSFER_COMPLETED = 1U << 4,
+
+    /* A device is in the process of being closed */
+    USBI_EVENT_DEVICE_CLOSE = 1U << 5,
+};
+
+/* Macros for managing event handling state */
+static inline int usbi_handling_events(struct libusb_context *ctx) {
+    return usbi_tls_key_get(ctx->event_handling_key) != NULL;
+}
+
+static inline void usbi_start_event_handling(struct libusb_context *ctx) {
+    usbi_tls_key_set(ctx->event_handling_key, ctx);
+}
+
+static inline void usbi_end_event_handling(struct libusb_context *ctx) {
+    usbi_tls_key_set(ctx->event_handling_key, NULL);
+}
+
+struct libusb_device {
+    usbi_atomic_t refcnt;
+
+    struct libusb_context *ctx;
+    struct libusb_device  *parent_dev;
+
+    uint8_t           bus_number;
+    uint8_t           port_number;
+    uint8_t           device_address;
+    enum libusb_speed speed;
+
+    struct list_head list;
+    unsigned long    session_data;
+
+    struct libusb_device_descriptor device_descriptor;
+    usbi_atomic_t                   attached;
+    char                           *dev_path;
+
+    char *interface_path[32];
+    char *sub_composite_device_id[32];
+};
+
+struct libusb_device_handle {
+    /* lock protects claimed_interfaces */
+    usbi_mutex_t  lock;
+    unsigned long claimed_interfaces;
+
+    struct list_head      list;
+    struct libusb_device *dev;
+    int                   auto_detach_kernel_driver;
+};
+
+/* Function called by backend during device initialization to convert
+ * multi-byte fields in the device descriptor to host-endian format.
+ */
+static inline void usbi_localize_device_descriptor(struct libusb_device_descriptor *desc) {
+    desc->bcdUSB    = libusb_le16_to_cpu(desc->bcdUSB);
+    desc->idVendor  = libusb_le16_to_cpu(desc->idVendor);
+    desc->idProduct = libusb_le16_to_cpu(desc->idProduct);
+    desc->bcdDevice = libusb_le16_to_cpu(desc->bcdDevice);
+}
+
+#if defined(HAVE_CLOCK_GETTIME) && !defined(__APPLE__)
+static inline void usbi_get_monotonic_time(struct timespec *tp) {
+    ASSERT_EQ(clock_gettime(CLOCK_MONOTONIC, tp), 0);
+}
+static inline void usbi_get_real_time(struct timespec *tp) {
+    ASSERT_EQ(clock_gettime(CLOCK_REALTIME, tp), 0);
+}
+#else
+/* If the platform doesn't provide the clock_gettime() function, the backend
+ * must provide its own clock implementations.  Two clock functions are
+ * required:
+ *
+ *   usbi_get_monotonic_time(): returns the time since an unspecified starting
+ *                              point (usually boot) that is monotonically
+ *                              increasing.
+ *   usbi_get_real_time(): returns the time since system epoch.
+ */
+void usbi_get_monotonic_time(struct timespec *tp);
+void usbi_get_real_time(struct timespec *tp);
+#endif
+
+/* in-memory transfer layout:
+ *
+ * 1. os private data
+ * 2. struct usbi_transfer
+ * 3. struct libusb_transfer (which includes iso packets) [variable size]
+ *
+ * from a libusb_transfer, you can get the usbi_transfer by rewinding the
+ * appropriate number of bytes.
+ */
+
+struct usbi_transfer {
+    int              num_iso_packets;
+    struct list_head list;
+    struct list_head completed_list;
+    struct timespec  timeout;
+    int              transferred;
+    uint32_t         stream_id;
+    uint32_t         state_flags;   /* Protected by usbi_transfer->lock */
+    uint32_t         timeout_flags; /* Protected by the flying_stransfers_lock */
+
+    /* The device reference is held until destruction for logging
+     * even after dev_handle is set to NULL.  */
+    struct libusb_device *dev;
+
+    /* this lock is held during libusb_submit_transfer() and
+     * libusb_cancel_transfer() (allowing the OS backend to prevent duplicate
+     * cancellation, submission-during-cancellation, etc). the OS backend
+     * should also take this lock in the handle_events path, to prevent the user
+     * cancelling the transfer from another thread while you are processing
+     * its completion (presumably there would be races within your OS backend
+     * if this were possible).
+     * Note paths taking both this and the flying_transfers_lock must
+     * always take the flying_transfers_lock first */
+    usbi_mutex_t lock;
+
+    void *priv;
+};
+
+enum usbi_transfer_state_flags {
+    /* Transfer successfully submitted by backend */
+    USBI_TRANSFER_IN_FLIGHT = 1U << 0,
+
+    /* Cancellation was requested via libusb_cancel_transfer() */
+    USBI_TRANSFER_CANCELLING = 1U << 1,
+
+    /* Operation on the transfer failed because the device disappeared */
+    USBI_TRANSFER_DEVICE_DISAPPEARED = 1U << 2,
+};
+
+enum usbi_transfer_timeout_flags {
+    /* Set by backend submit_transfer() if the OS handles timeout */
+    USBI_TRANSFER_OS_HANDLES_TIMEOUT = 1U << 0,
+
+    /* The transfer timeout has been handled */
+    USBI_TRANSFER_TIMEOUT_HANDLED = 1U << 1,
+
+    /* The transfer timeout was successfully processed */
+    USBI_TRANSFER_TIMED_OUT = 1U << 2,
+};
+
+#define USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer) ((struct libusb_transfer *)((unsigned char *)(itransfer) + PTR_ALIGN(sizeof(struct usbi_transfer))))
+#define LIBUSB_TRANSFER_TO_USBI_TRANSFER(transfer) ((struct usbi_transfer *)((unsigned char *)(transfer)-PTR_ALIGN(sizeof(struct usbi_transfer))))
+
+#ifdef _MSC_VER
+#pragma pack(push, 1)
+#endif
+
+/* All standard descriptors have these 2 fields in common */
+struct usbi_descriptor_header {
+    uint8_t bLength;
+    uint8_t bDescriptorType;
+} LIBUSB_PACKED;
+
+struct usbi_device_descriptor {
+    uint8_t  bLength;
+    uint8_t  bDescriptorType;
+    uint16_t bcdUSB;
+    uint8_t  bDeviceClass;
+    uint8_t  bDeviceSubClass;
+    uint8_t  bDeviceProtocol;
+    uint8_t  bMaxPacketSize0;
+    uint16_t idVendor;
+    uint16_t idProduct;
+    uint16_t bcdDevice;
+    uint8_t  iManufacturer;
+    uint8_t  iProduct;
+    uint8_t  iSerialNumber;
+    uint8_t  bNumConfigurations;
+} LIBUSB_PACKED;
+
+struct usbi_configuration_descriptor {
+    uint8_t  bLength;
+    uint8_t  bDescriptorType;
+    uint16_t wTotalLength;
+    uint8_t  bNumInterfaces;
+    uint8_t  bConfigurationValue;
+    uint8_t  iConfiguration;
+    uint8_t  bmAttributes;
+    uint8_t  bMaxPower;
+} LIBUSB_PACKED;
+
+struct usbi_interface_descriptor {
+    uint8_t bLength;
+    uint8_t bDescriptorType;
+    uint8_t bInterfaceNumber;
+    uint8_t bAlternateSetting;
+    uint8_t bNumEndpoints;
+    uint8_t bInterfaceClass;
+    uint8_t bInterfaceSubClass;
+    uint8_t bInterfaceProtocol;
+    uint8_t iInterface;
+} LIBUSB_PACKED;
+
+struct usbi_string_descriptor {
+    uint8_t  bLength;
+    uint8_t  bDescriptorType;
+    uint16_t wData[ZERO_SIZED_ARRAY];
+} LIBUSB_PACKED;
+
+struct usbi_bos_descriptor {
+    uint8_t  bLength;
+    uint8_t  bDescriptorType;
+    uint16_t wTotalLength;
+    uint8_t  bNumDeviceCaps;
+} LIBUSB_PACKED;
+
+#ifdef _MSC_VER
+#pragma pack(pop)
+#endif
+
+union usbi_config_desc_buf {
+    struct usbi_configuration_descriptor desc;
+    uint8_t                              buf[LIBUSB_DT_CONFIG_SIZE];
+    uint16_t                             align; /* Force 2-byte alignment */
+};
+
+union usbi_string_desc_buf {
+    struct usbi_string_descriptor desc;
+    uint8_t                       buf[255]; /* Some devices choke on size > 255 */
+    uint16_t                      align;    /* Force 2-byte alignment */
+};
+
+union usbi_bos_desc_buf {
+    struct usbi_bos_descriptor desc;
+    uint8_t                    buf[LIBUSB_DT_BOS_SIZE];
+    uint16_t                   align; /* Force 2-byte alignment */
+};
+
+enum usbi_hotplug_flags {
+    /* This callback is interested in device arrivals */
+    USBI_HOTPLUG_DEVICE_ARRIVED = LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED,
+
+    /* This callback is interested in device removals */
+    USBI_HOTPLUG_DEVICE_LEFT = LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT,
+
+    /* IMPORTANT: The values for the below entries must start *after*
+     * the highest value of the above entries!!!
+     */
+
+    /* The vendor_id field is valid for matching */
+    USBI_HOTPLUG_VENDOR_ID_VALID = (1U << 3),
+
+    /* The product_id field is valid for matching */
+    USBI_HOTPLUG_PRODUCT_ID_VALID = (1U << 4),
+
+    /* The dev_class field is valid for matching */
+    USBI_HOTPLUG_DEV_CLASS_VALID = (1U << 5),
+
+    /* This callback has been unregistered and needs to be freed */
+    USBI_HOTPLUG_NEEDS_FREE = (1U << 6),
+};
+
+struct usbi_hotplug_callback {
+    /* Flags that control how this callback behaves */
+    uint8_t flags;
+
+    /* Vendor ID to match (if flags says this is valid) */
+    uint16_t vendor_id;
+
+    /* Product ID to match (if flags says this is valid) */
+    uint16_t product_id;
+
+    /* Device class to match (if flags says this is valid) */
+    uint8_t dev_class;
+
+    /* Callback function to invoke for matching event/device */
+    libusb_hotplug_callback_fn cb;
+
+    /* Handle for this callback (used to match on deregister) */
+    libusb_hotplug_callback_handle handle;
+
+    /* User data that will be passed to the callback function */
+    void *user_data;
+
+    /* List this callback is registered in (ctx->hotplug_cbs) */
+    struct list_head list;
+};
+
+struct usbi_hotplug_message {
+    /* The hotplug event that occurred */
+    libusb_hotplug_event event;
+
+    /* The device for which this hotplug event occurred */
+    struct libusb_device *device;
+
+    /* List this message is contained in (ctx->hotplug_msgs) */
+    struct list_head list;
+};
+
+/* shared data and functions */
+
+void usbi_hotplug_init(struct libusb_context *ctx);
+void usbi_hotplug_exit(struct libusb_context *ctx);
+void usbi_hotplug_notification(struct libusb_context *ctx, struct libusb_device *dev, libusb_hotplug_event event);
+void usbi_hotplug_process(struct libusb_context *ctx, struct list_head *hotplug_msgs);
+
+int  usbi_io_init(struct libusb_context *ctx);
+void usbi_io_exit(struct libusb_context *ctx);
+
+struct libusb_device *usbi_alloc_device(struct libusb_context *ctx, unsigned long session_id);
+struct libusb_device *usbi_get_device_by_session_id(struct libusb_context *ctx, unsigned long session_id);
+int                   usbi_sanitize_device(struct libusb_device *dev);
+void                  usbi_handle_disconnect(struct libusb_device_handle *dev_handle);
+
+int  usbi_handle_transfer_completion(struct usbi_transfer *itransfer, enum libusb_transfer_status status);
+int  usbi_handle_transfer_cancellation(struct usbi_transfer *itransfer);
+void usbi_signal_transfer_completion(struct usbi_transfer *itransfer);
+
+void usbi_connect_device(struct libusb_device *dev);
+void usbi_disconnect_device(struct libusb_device *dev);
+
+struct usbi_event_source {
+    struct usbi_event_source_data {
+        usbi_os_handle_t os_handle;
+        short            poll_events;
+    } data;
+    struct list_head list;
+};
+
+int  usbi_add_event_source(struct libusb_context *ctx, usbi_os_handle_t os_handle, short poll_events);
+void usbi_remove_event_source(struct libusb_context *ctx, usbi_os_handle_t os_handle);
+
+struct usbi_option {
+    int is_set;
+    union {
+        int ival;
+    } arg;
+};
+
+/* OS event abstraction */
+
+int  usbi_create_event(usbi_event_t *event);
+void usbi_destroy_event(usbi_event_t *event);
+void usbi_signal_event(usbi_event_t *event);
+void usbi_clear_event(usbi_event_t *event);
+
+#ifdef HAVE_OS_TIMER
+int  usbi_create_timer(usbi_timer_t *timer);
+void usbi_destroy_timer(usbi_timer_t *timer);
+int  usbi_arm_timer(usbi_timer_t *timer, const struct timespec *timeout);
+int  usbi_disarm_timer(usbi_timer_t *timer);
+#endif
+
+static inline int usbi_using_timer(struct libusb_context *ctx) {
+#ifdef HAVE_OS_TIMER
+    return usbi_timer_valid(&ctx->timer);
+#else
+    UNUSED(ctx);
+    return 0;
+#endif
+}
+
+struct usbi_reported_events {
+    union {
+        struct {
+            unsigned int event_triggered : 1;
+#ifdef HAVE_OS_TIMER
+            unsigned int timer_triggered : 1;
+#endif
+        };
+        unsigned int event_bits;
+    };
+    void        *event_data;
+    unsigned int event_data_count;
+    unsigned int num_ready;
+};
+
+int usbi_alloc_event_data(struct libusb_context *ctx);
+int usbi_wait_for_events(struct libusb_context *ctx, struct usbi_reported_events *reported_events, int timeout_ms);
+
+/* accessor functions for structure private data */
+
+static inline void *usbi_get_context_priv(struct libusb_context *ctx) {
+    return (unsigned char *)ctx + PTR_ALIGN(sizeof(*ctx));
+}
+
+static inline void *usbi_get_device_priv(struct libusb_device *dev) {
+    return (unsigned char *)dev + PTR_ALIGN(sizeof(*dev));
+}
+
+static inline void *usbi_get_device_handle_priv(struct libusb_device_handle *dev_handle) {
+    return (unsigned char *)dev_handle + PTR_ALIGN(sizeof(*dev_handle));
+}
+
+static inline void *usbi_get_transfer_priv(struct usbi_transfer *itransfer) {
+    return itransfer->priv;
+}
+
+/* device discovery */
+
+/* we traverse usbfs without knowing how many devices we are going to find.
+ * so we create this discovered_devs model which is similar to a linked-list
+ * which grows when required. it can be freed once discovery has completed,
+ * eliminating the need for a list node in the libusb_device structure
+ * itself. */
+struct discovered_devs {
+    size_t                len;
+    size_t                capacity;
+    struct libusb_device *devices[ZERO_SIZED_ARRAY];
+};
+
+struct discovered_devs *discovered_devs_append(struct discovered_devs *discdevs, struct libusb_device *dev);
+
+/* OS abstraction */
+
+/* This is the interface that OS backends need to implement.
+ * All fields are mandatory, except ones explicitly noted as optional. */
+struct usbi_os_backend {
+    /* A human-readable name for your backend, e.g. "Linux usbfs" */
+    const char *name;
+
+    /* Binary mask for backend specific capabilities */
+    uint32_t caps;
+
+    /* Perform initialization of your backend. You might use this function
+     * to determine specific capabilities of the system, allocate required
+     * data structures for later, etc.
+     *
+     * This function is called when a libusb user initializes the library
+     * prior to use. Mutual exclusion with other init and exit calls is
+     * guaranteed when this function is called.
+     *
+     * Return 0 on success, or a LIBUSB_ERROR code on failure.
+     */
+    int (*init)(struct libusb_context *ctx);
+
+    /* Deinitialization. Optional. This function should destroy anything
+     * that was set up by init.
+     *
+     * This function is called when the user deinitializes the library.
+     * Mutual exclusion with other init and exit calls is guaranteed when
+     * this function is called.
+     */
+    void (*exit)(struct libusb_context *ctx);
+
+    /* Set a backend-specific option. Optional.
+     *
+     * This function is called when the user calls libusb_set_option() and
+     * the option is not handled by the core library.
+     *
+     * Return 0 on success, or a LIBUSB_ERROR code on failure.
+     */
+    int (*set_option)(struct libusb_context *ctx, enum libusb_option option, va_list args);
+
+    /* Enumerate all the USB devices on the system, returning them in a list
+     * of discovered devices.
+     *
+     * Your implementation should enumerate all devices on the system,
+     * regardless of whether they have been seen before or not.
+     *
+     * When you have found a device, compute a session ID for it. The session
+     * ID should uniquely represent that particular device for that particular
+     * connection session since boot (i.e. if you disconnect and reconnect a
+     * device immediately after, it should be assigned a different session ID).
+     * If your OS cannot provide a unique session ID as described above,
+     * presenting a session ID of (bus_number << 8 | device_address) should
+     * be sufficient. Bus numbers and device addresses wrap and get reused,
+     * but that is an unlikely case.
+     *
+     * After computing a session ID for a device, call
+     * usbi_get_device_by_session_id(). This function checks if libusb already
+     * knows about the device, and if so, it provides you with a reference
+     * to a libusb_device structure for it.
+     *
+     * If usbi_get_device_by_session_id() returns NULL, it is time to allocate
+     * a new device structure for the device. Call usbi_alloc_device() to
+     * obtain a new libusb_device structure with reference count 1. Populate
+     * the bus_number and device_address attributes of the new device, and
+     * perform any other internal backend initialization you need to do. At
+     * this point, you should be ready to provide device descriptors and so
+     * on through the get_*_descriptor functions. Finally, call
+     * usbi_sanitize_device() to perform some final sanity checks on the
+     * device. Assuming all of the above succeeded, we can now continue.
+     * If any of the above failed, remember to unreference the device that
+     * was returned by usbi_alloc_device().
+     *
+     * At this stage we have a populated libusb_device structure (either one
+     * that was found earlier, or one that we have just allocated and
+     * populated). This can now be added to the discovered devices list
+     * using discovered_devs_append(). Note that discovered_devs_append()
+     * may reallocate the list, returning a new location for it, and also
+     * note that reallocation can fail. Your backend should handle these
+     * error conditions appropriately.
+     *
+     * This function should not generate any bus I/O and should not block.
+     * If I/O is required (e.g. reading the active configuration value), it is
+     * OK to ignore these suggestions :)
+     *
+     * This function is executed when the user wishes to retrieve a list
+     * of USB devices connected to the system.
+     *
+     * If the backend has hotplug support, this function is not used!
+     *
+     * Return 0 on success, or a LIBUSB_ERROR code on failure.
+     */
+    int (*get_device_list)(struct libusb_context *ctx, struct discovered_devs **discdevs);
+
+    /* Apps which were written before hotplug support, may listen for
+     * hotplug events on their own and call libusb_get_device_list on
+     * device addition. In this case libusb_get_device_list will likely
+     * return a list without the new device in there, as the hotplug
+     * event thread will still be busy enumerating the device, which may
+     * take a while, or may not even have seen the event yet.
+     *
+     * To avoid this libusb_get_device_list will call this optional
+     * function for backends with hotplug support before copying
+     * ctx->usb_devs to the user. In this function the backend should
+     * ensure any pending hotplug events are fully processed before
+     * returning.
+     *
+     * Optional, should be implemented by backends with hotplug support.
+     */
+    void (*hotplug_poll)(void);
+
+    /* Wrap a platform-specific device handle for I/O and other USB
+     * operations. The device handle is preallocated for you.
+     *
+     * Your backend should allocate any internal resources required for I/O
+     * and other operations so that those operations can happen (hopefully)
+     * without hiccup. This is also a good place to inform libusb that it
+     * should monitor certain file descriptors related to this device -
+     * see the usbi_add_event_source() function.
+     *
+     * Your backend should also initialize the device structure
+     * (dev_handle->dev), which is NULL at the beginning of the call.
+     *
+     * This function should not generate any bus I/O and should not block.
+     *
+     * This function is called when the user attempts to wrap an existing
+     * platform-specific device handle for a device.
+     *
+     * Return:
+     * - 0 on success
+     * - LIBUSB_ERROR_ACCESS if the user has insufficient permissions
+     * - another LIBUSB_ERROR code on other failure
+     *
+     * Do not worry about freeing the handle on failed open, the upper layers
+     * do this for you.
+     */
+    int (*wrap_sys_device)(struct libusb_context *ctx, struct libusb_device_handle *dev_handle, intptr_t sys_dev);
+
+    /* Open a device for I/O and other USB operations. The device handle
+     * is preallocated for you, you can retrieve the device in question
+     * through handle->dev.
+     *
+     * Your backend should allocate any internal resources required for I/O
+     * and other operations so that those operations can happen (hopefully)
+     * without hiccup. This is also a good place to inform libusb that it
+     * should monitor certain file descriptors related to this device -
+     * see the usbi_add_event_source() function.
+     *
+     * This function should not generate any bus I/O and should not block.
+     *
+     * This function is called when the user attempts to obtain a device
+     * handle for a device.
+     *
+     * Return:
+     * - 0 on success
+     * - LIBUSB_ERROR_ACCESS if the user has insufficient permissions
+     * - LIBUSB_ERROR_NO_DEVICE if the device has been disconnected since
+     *   discovery
+     * - another LIBUSB_ERROR code on other failure
+     *
+     * Do not worry about freeing the handle on failed open, the upper layers
+     * do this for you.
+     */
+    int (*open)(struct libusb_device_handle *dev_handle);
+
+    /* Close a device such that the handle cannot be used again. Your backend
+     * should destroy any resources that were allocated in the open path.
+     * This may also be a good place to call usbi_remove_event_source() to
+     * inform libusb of any event sources associated with this device that
+     * should no longer be monitored.
+     *
+     * This function is called when the user closes a device handle.
+     */
+    void (*close)(struct libusb_device_handle *dev_handle);
+
+    /* Get the ACTIVE configuration descriptor for a device.
+     *
+     * The descriptor should be retrieved from memory, NOT via bus I/O to the
+     * device. This means that you may have to cache it in a private structure
+     * during get_device_list enumeration. You may also have to keep track
+     * of which configuration is active when the user changes it.
+     *
+     * This function is expected to write len bytes of data into buffer, which
+     * is guaranteed to be big enough. If you can only do a partial write,
+     * return an error code.
+     *
+     * This function is expected to return the descriptor in bus-endian format
+     * (LE).
+     *
+     * Return:
+     * - 0 on success
+     * - LIBUSB_ERROR_NOT_FOUND if the device is in unconfigured state
+     * - another LIBUSB_ERROR code on other failure
+     */
+    int (*get_active_config_descriptor)(struct libusb_device *device, void *buffer, size_t len);
+
+    /* Get a specific configuration descriptor for a device.
+     *
+     * The descriptor should be retrieved from memory, NOT via bus I/O to the
+     * device. This means that you may have to cache it in a private structure
+     * during get_device_list enumeration.
+     *
+     * The requested descriptor is expressed as a zero-based index (i.e. 0
+     * indicates that we are requesting the first descriptor). The index does
+     * not (necessarily) equal the bConfigurationValue of the configuration
+     * being requested.
+     *
+     * This function is expected to write len bytes of data into buffer, which
+     * is guaranteed to be big enough. If you can only do a partial write,
+     * return an error code.
+     *
+     * This function is expected to return the descriptor in bus-endian format
+     * (LE).
+     *
+     * Return the length read on success or a LIBUSB_ERROR code on failure.
+     */
+    int (*get_config_descriptor)(struct libusb_device *device, uint8_t config_index, void *buffer, size_t len);
+
+    /* Like get_config_descriptor but then by bConfigurationValue instead
+     * of by index.
+     *
+     * Optional, if not present the core will call get_config_descriptor
+     * for all configs until it finds the desired bConfigurationValue.
+     *
+     * Returns a pointer to the raw-descriptor in *buffer, this memory
+     * is valid as long as device is valid.
+     *
+     * Returns the length of the returned raw-descriptor on success,
+     * or a LIBUSB_ERROR code on failure.
+     */
+    int (*get_config_descriptor_by_value)(struct libusb_device *device, uint8_t bConfigurationValue, void **buffer);
+
+    /* Get the bConfigurationValue for the active configuration for a device.
+     * Optional. This should only be implemented if you can retrieve it from
+     * cache (don't generate I/O).
+     *
+     * If you cannot retrieve this from cache, either do not implement this
+     * function, or return LIBUSB_ERROR_NOT_SUPPORTED. This will cause
+     * libusb to retrieve the information through a standard control transfer.
+     *
+     * This function must be non-blocking.
+     * Return:
+     * - 0 on success
+     * - LIBUSB_ERROR_NO_DEVICE if the device has been disconnected since it
+     *   was opened
+     * - LIBUSB_ERROR_NOT_SUPPORTED if the value cannot be retrieved without
+     *   blocking
+     * - another LIBUSB_ERROR code on other failure.
+     */
+    int (*get_configuration)(struct libusb_device_handle *dev_handle, uint8_t *config);
+
+    /* Set the active configuration for a device.
+     *
+     * A configuration value of -1 should put the device in unconfigured state.
+     *
+     * This function can block.
+     *
+     * Return:
+     * - 0 on success
+     * - LIBUSB_ERROR_NOT_FOUND if the configuration does not exist
+     * - LIBUSB_ERROR_BUSY if interfaces are currently claimed (and hence
+     *   configuration cannot be changed)
+     * - LIBUSB_ERROR_NO_DEVICE if the device has been disconnected since it
+     *   was opened
+     * - another LIBUSB_ERROR code on other failure.
+     */
+    int (*set_configuration)(struct libusb_device_handle *dev_handle, int config);
+
+    /* Claim an interface. When claimed, the application can then perform
+     * I/O to an interface's endpoints.
+     *
+     * This function should not generate any bus I/O and should not block.
+     * Interface claiming is a logical operation that simply ensures that
+     * no other drivers/applications are using the interface, and after
+     * claiming, no other drivers/applications can use the interface because
+     * we now "own" it.
+     *
+     * Return:
+     * - 0 on success
+     * - LIBUSB_ERROR_NOT_FOUND if the interface does not exist
+     * - LIBUSB_ERROR_BUSY if the interface is in use by another driver/app
+     * - LIBUSB_ERROR_NO_DEVICE if the device has been disconnected since it
+     *   was opened
+     * - another LIBUSB_ERROR code on other failure
+     */
+    int (*claim_interface)(struct libusb_device_handle *dev_handle, uint8_t interface_number);
+
+    /* Release a previously claimed interface.
+     *
+     * This function should also generate a SET_INTERFACE control request,
+     * resetting the alternate setting of that interface to 0. It's OK for
+     * this function to block as a result.
+     *
+     * You will only ever be asked to release an interface which was
+     * successfully claimed earlier.
+     *
+     * Return:
+     * - 0 on success
+     * - LIBUSB_ERROR_NO_DEVICE if the device has been disconnected since it
+     *   was opened
+     * - another LIBUSB_ERROR code on other failure
+     */
+    int (*release_interface)(struct libusb_device_handle *dev_handle, uint8_t interface_number);
+
+    /* Set the alternate setting for an interface.
+     *
+     * You will only ever be asked to set the alternate setting for an
+     * interface which was successfully claimed earlier.
+     *
+     * It's OK for this function to block.
+     *
+     * Return:
+     * - 0 on success
+     * - LIBUSB_ERROR_NOT_FOUND if the alternate setting does not exist
+     * - LIBUSB_ERROR_NO_DEVICE if the device has been disconnected since it
+     *   was opened
+     * - another LIBUSB_ERROR code on other failure
+     */
+    int (*set_interface_altsetting)(struct libusb_device_handle *dev_handle, uint8_t interface_number, uint8_t altsetting);
+
+    /* Clear a halt/stall condition on an endpoint.
+     *
+     * It's OK for this function to block.
+     *
+     * Return:
+     * - 0 on success
+     * - LIBUSB_ERROR_NOT_FOUND if the endpoint does not exist
+     * - LIBUSB_ERROR_NO_DEVICE if the device has been disconnected since it
+     *   was opened
+     * - another LIBUSB_ERROR code on other failure
+     */
+    int (*clear_halt)(struct libusb_device_handle *dev_handle, unsigned char endpoint);
+
+    /* Perform a USB port reset to reinitialize a device. Optional.
+     *
+     * If possible, the device handle should still be usable after the reset
+     * completes, assuming that the device descriptors did not change during
+     * reset and all previous interface state can be restored.
+     *
+     * If something changes, or you cannot easily locate/verify the reset
+     * device, return LIBUSB_ERROR_NOT_FOUND. This prompts the application
+     * to close the old handle and re-enumerate the device.
+     *
+     * Return:
+     * - 0 on success
+     * - LIBUSB_ERROR_NOT_FOUND if re-enumeration is required, or if the device
+     *   has been disconnected since it was opened
+     * - another LIBUSB_ERROR code on other failure
+     */
+    int (*reset_device)(struct libusb_device_handle *dev_handle);
+
+    /* Alloc num_streams usb3 bulk streams on the passed in endpoints */
+    int (*alloc_streams)(struct libusb_device_handle *dev_handle, uint32_t num_streams, unsigned char *endpoints, int num_endpoints);
+
+    /* Free usb3 bulk streams allocated with alloc_streams */
+    int (*free_streams)(struct libusb_device_handle *dev_handle, unsigned char *endpoints, int num_endpoints);
+
+    /* Allocate persistent DMA memory for the given device, suitable for
+     * zerocopy. May return NULL on failure. Optional to implement.
+     */
+    void *(*dev_mem_alloc)(struct libusb_device_handle *handle, size_t len);
+
+    /* Free memory allocated by dev_mem_alloc. */
+    int (*dev_mem_free)(struct libusb_device_handle *handle, void *buffer, size_t len);
+
+    /* Determine if a kernel driver is active on an interface. Optional.
+     *
+     * The presence of a kernel driver on an interface indicates that any
+     * calls to claim_interface would fail with the LIBUSB_ERROR_BUSY code.
+     *
+     * Return:
+     * - 0 if no driver is active
+     * - 1 if a driver is active
+     * - LIBUSB_ERROR_NO_DEVICE if the device has been disconnected since it
+     *   was opened
+     * - another LIBUSB_ERROR code on other failure
+     */
+    int (*kernel_driver_active)(struct libusb_device_handle *dev_handle, uint8_t interface_number);
+
+    /* Detach a kernel driver from an interface. Optional.
+     *
+     * After detaching a kernel driver, the interface should be available
+     * for claim.
+     *
+     * Return:
+     * - 0 on success
+     * - LIBUSB_ERROR_NOT_FOUND if no kernel driver was active
+     * - LIBUSB_ERROR_INVALID_PARAM if the interface does not exist
+     * - LIBUSB_ERROR_NO_DEVICE if the device has been disconnected since it
+     *   was opened
+     * - another LIBUSB_ERROR code on other failure
+     */
+    int (*detach_kernel_driver)(struct libusb_device_handle *dev_handle, uint8_t interface_number);
+
+    /* Attach a kernel driver to an interface. Optional.
+     *
+     * Reattach a kernel driver to the device.
+     *
+     * Return:
+     * - 0 on success
+     * - LIBUSB_ERROR_NOT_FOUND if no kernel driver was active
+     * - LIBUSB_ERROR_INVALID_PARAM if the interface does not exist
+     * - LIBUSB_ERROR_NO_DEVICE if the device has been disconnected since it
+     *   was opened
+     * - LIBUSB_ERROR_BUSY if a program or driver has claimed the interface,
+     *   preventing reattachment
+     * - another LIBUSB_ERROR code on other failure
+     */
+    int (*attach_kernel_driver)(struct libusb_device_handle *dev_handle, uint8_t interface_number);
+
+    /* Destroy a device. Optional.
+     *
+     * This function is called when the last reference to a device is
+     * destroyed. It should free any resources allocated in the get_device_list
+     * path.
+     */
+    void (*destroy_device)(struct libusb_device *dev);
+
+    /* Submit a transfer. Your implementation should take the transfer,
+     * morph it into whatever form your platform requires, and submit it
+     * asynchronously.
+     *
+     * This function must not block.
+     *
+     * This function gets called with the flying_transfers_lock locked!
+     *
+     * Return:
+     * - 0 on success
+     * - LIBUSB_ERROR_NO_DEVICE if the device has been disconnected
+     * - another LIBUSB_ERROR code on other failure
+     */
+    int (*submit_transfer)(struct usbi_transfer *itransfer);
+
+    /* Cancel a previously submitted transfer.
+     *
+     * This function must not block. The transfer cancellation must complete
+     * later, resulting in a call to usbi_handle_transfer_cancellation()
+     * from the context of handle_events.
+     */
+    int (*cancel_transfer)(struct usbi_transfer *itransfer);
+
+    /* Clear a transfer as if it has completed or cancelled, but do not
+     * report any completion/cancellation to the library. You should free
+     * all private data from the transfer as if you were just about to report
+     * completion or cancellation.
+     *
+     * This function might seem a bit out of place. It is used when libusb
+     * detects a disconnected device - it calls this function for all pending
+     * transfers before reporting completion (with the disconnect code) to
+     * the user. Maybe we can improve upon this internal interface in future.
+     */
+    void (*clear_transfer_priv)(struct usbi_transfer *itransfer);
+
+    /* Handle any pending events on event sources. Optional.
+     *
+     * Provide this function when event sources directly indicate device
+     * or transfer activity. If your backend does not have such event sources,
+     * implement the handle_transfer_completion function below.
+     *
+     * This involves monitoring any active transfers and processing their
+     * completion or cancellation.
+     *
+     * The function is passed a pointer that represents platform-specific
+     * data for monitoring event sources (size count). This data is to be
+     * (re)allocated as necessary when event sources are modified.
+     * The num_ready parameter indicates the number of event sources that
+     * have reported events. This should be enough information for you to
+     * determine which actions need to be taken on the currently active
+     * transfers.
+     *
+     * For any cancelled transfers, call usbi_handle_transfer_cancellation().
+     * For completed transfers, call usbi_handle_transfer_completion().
+     * For control/bulk/interrupt transfers, populate the "transferred"
+     * element of the appropriate usbi_transfer structure before calling the
+     * above functions. For isochronous transfers, populate the status and
+     * transferred fields of the iso packet descriptors of the transfer.
+     *
+     * This function should also be able to detect disconnection of the
+     * device, reporting that situation with usbi_handle_disconnect().
+     *
+     * When processing an event related to a transfer, you probably want to
+     * take usbi_transfer.lock to prevent races. See the documentation for
+     * the usbi_transfer structure.
+     *
+     * Return 0 on success, or a LIBUSB_ERROR code on failure.
+     */
+    int (*handle_events)(struct libusb_context *ctx, void *event_data, unsigned int count, unsigned int num_ready);
+
+    /* Handle transfer completion. Optional.
+     *
+     * Provide this function when there are no event sources available that
+     * directly indicate device or transfer activity. If your backend does
+     * have such event sources, implement the handle_events function above.
+     *
+     * Your backend must tell the library when a transfer has completed by
+     * calling usbi_signal_transfer_completion(). You should store any private
+     * information about the transfer and its completion status in the transfer's
+     * private backend data.
+     *
+     * During event handling, this function will be called on each transfer for
+     * which usbi_signal_transfer_completion() was called.
+     *
+     * For any cancelled transfers, call usbi_handle_transfer_cancellation().
+     * For completed transfers, call usbi_handle_transfer_completion().
+     * For control/bulk/interrupt transfers, populate the "transferred"
+     * element of the appropriate usbi_transfer structure before calling the
+     * above functions. For isochronous transfers, populate the status and
+     * transferred fields of the iso packet descriptors of the transfer.
+     *
+     * Return 0 on success, or a LIBUSB_ERROR code on failure.
+     */
+    int (*handle_transfer_completion)(struct usbi_transfer *itransfer);
+
+    /* Number of bytes to reserve for per-context private backend data.
+     * This private data area is accessible by calling
+     * usbi_get_context_priv() on the libusb_context instance.
+     */
+    size_t context_priv_size;
+
+    /* Number of bytes to reserve for per-device private backend data.
+     * This private data area is accessible by calling
+     * usbi_get_device_priv() on the libusb_device instance.
+     */
+    size_t device_priv_size;
+
+    /* Number of bytes to reserve for per-handle private backend data.
+     * This private data area is accessible by calling
+     * usbi_get_device_handle_priv() on the libusb_device_handle instance.
+     */
+    size_t device_handle_priv_size;
+
+    /* Number of bytes to reserve for per-transfer private backend data.
+     * This private data area is accessible by calling
+     * usbi_get_transfer_priv() on the usbi_transfer instance.
+     */
+    size_t transfer_priv_size;
+};
+
+extern const struct usbi_os_backend usbi_backend;
+
+#define for_each_context(c) for_each_helper(c, &active_contexts_list, struct libusb_context)
+
+#define for_each_device(ctx, d) for_each_helper(d, &(ctx)->usb_devs, struct libusb_device)
+
+#define for_each_device_safe(ctx, d, n) for_each_safe_helper(d, n, &(ctx)->usb_devs, struct libusb_device)
+
+#define for_each_open_device(ctx, h) for_each_helper(h, &(ctx)->open_devs, struct libusb_device_handle)
+
+#define __for_each_transfer(list, t) for_each_helper(t, (list), struct usbi_transfer)
+
+#define for_each_transfer(ctx, t) __for_each_transfer(&(ctx)->flying_transfers, t)
+
+#define __for_each_transfer_safe(list, t, n) for_each_safe_helper(t, n, (list), struct usbi_transfer)
+
+#define for_each_transfer_safe(ctx, t, n) __for_each_transfer_safe(&(ctx)->flying_transfers, t, n)
+
+#define __for_each_completed_transfer_safe(list, t, n) list_for_each_entry_safe(t, n, (list), completed_list, struct usbi_transfer)
+
+#define for_each_event_source(ctx, e) for_each_helper(e, &(ctx)->event_sources, struct usbi_event_source)
+
+#define for_each_removed_event_source(ctx, e) for_each_helper(e, &(ctx)->removed_event_sources, struct usbi_event_source)
+
+#define for_each_removed_event_source_safe(ctx, e, n) for_each_safe_helper(e, n, &(ctx)->removed_event_sources, struct usbi_event_source)
+
+#define for_each_hotplug_cb(ctx, c) for_each_helper(c, &(ctx)->hotplug_cbs, struct usbi_hotplug_callback)
+
+#define for_each_hotplug_cb_safe(ctx, c, n) for_each_safe_helper(c, n, &(ctx)->hotplug_cbs, struct usbi_hotplug_callback)
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/3rdparty/libusb/src/libusb/os/darwin_usb.c b/3rdparty/libusb/src/libusb/os/darwin_usb.c
new file mode 100644
index 00000000..0ac615c1
--- /dev/null
+++ b/3rdparty/libusb/src/libusb/os/darwin_usb.c
@@ -0,0 +1,2678 @@
+/* -*- Mode: C; indent-tabs-mode:nil -*- */
+/*
+ * darwin backend for libusb 1.0
+ * Copyright © 2008-2021 Nathan Hjelm <hjelmn@cs.unm.edu>
+ * Copyright © 2019-2022 Google LLC. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <libusb/config.h>
+#include <assert.h>
+#include <time.h>
+#include <ctype.h>
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/sysctl.h>
+
+#include <mach/mach_time.h>
+
+/* Suppress warnings about the use of the deprecated objc_registerThreadWithCollector
+ * function. Its use is also conditionalized to only older deployment targets. */
+#define OBJC_SILENCE_GC_DEPRECATIONS 1
+
+/* Default timeout to 10s for reenumerate. This is needed because USBDeviceReEnumerate
+ * does not return error status on macOS. */
+#define DARWIN_REENUMERATE_TIMEOUT_US (10 * USEC_PER_SEC)
+
+#include <AvailabilityMacros.h>
+#if MAC_OS_X_VERSION_MIN_REQUIRED >= 1060 && MAC_OS_X_VERSION_MIN_REQUIRED < 101200
+#include <objc/objc-auto.h>
+#endif
+
+#include "darwin_usb.h"
+
+static int init_count = 0;
+
+/* Both kIOMasterPortDefault or kIOMainPortDefault are synonyms for 0. */
+static const mach_port_t darwin_default_master_port = 0;
+
+/* async event thread */
+/* if both this mutex and darwin_cached_devices_mutex are to be acquired then
+   darwin_cached_devices_mutex must be acquired first. */
+static pthread_mutex_t libusb_darwin_at_mutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_cond_t  libusb_darwin_at_cond  = PTHREAD_COND_INITIALIZER;
+
+#define LIBUSB_DARWIN_STARTUP_FAILURE ((CFRunLoopRef)-1)
+
+static CFRunLoopRef       libusb_darwin_acfl  = NULL; /* event cf loop */
+static CFRunLoopSourceRef libusb_darwin_acfls = NULL; /* shutdown signal for event cf loop */
+
+static usbi_mutex_t     darwin_cached_devices_mutex = PTHREAD_MUTEX_INITIALIZER;
+static struct list_head darwin_cached_devices;
+static const char      *darwin_device_class = "IOUSBDevice";
+
+#define DARWIN_CACHED_DEVICE(a) (((struct darwin_device_priv *)usbi_get_device_priv((a)))->dev)
+
+/* async event thread */
+static pthread_t libusb_darwin_at;
+
+static void darwin_exit(struct libusb_context *ctx);
+static int  darwin_get_config_descriptor(struct libusb_device *dev, uint8_t config_index, void *buffer, size_t len);
+static int  darwin_claim_interface(struct libusb_device_handle *dev_handle, uint8_t iface);
+static int  darwin_release_interface(struct libusb_device_handle *dev_handle, uint8_t iface);
+static int  darwin_reenumerate_device(struct libusb_device_handle *dev_handle, bool capture);
+static int  darwin_clear_halt(struct libusb_device_handle *dev_handle, unsigned char endpoint);
+static int  darwin_reset_device(struct libusb_device_handle *dev_handle);
+static int  darwin_detach_kernel_driver(struct libusb_device_handle *dev_handle, uint8_t interface);
+static void darwin_async_io_callback(void *refcon, IOReturn result, void *arg0);
+
+static enum libusb_error darwin_scan_devices(struct libusb_context *ctx);
+static enum libusb_error process_new_device(struct libusb_context *ctx, struct darwin_cached_device *cached_device, UInt64 old_session_id);
+
+static enum libusb_error darwin_get_cached_device(struct libusb_context *ctx, io_service_t service, struct darwin_cached_device **cached_out,
+                                                  UInt64 *old_session_id);
+
+#if defined(ENABLE_LOGGING)
+static const char *darwin_error_str(IOReturn result) {
+    static char string_buffer[50];
+    switch(result) {
+    case kIOReturnSuccess:
+        return "no error";
+    case kIOReturnNotOpen:
+        return "device not opened for exclusive access";
+    case kIOReturnNoDevice:
+        return "no connection to an IOService";
+    case kIOUSBNoAsyncPortErr:
+        return "no async port has been opened for interface";
+    case kIOReturnExclusiveAccess:
+        return "another process has device opened for exclusive access";
+    case kIOUSBPipeStalled:
+#if defined(kUSBHostReturnPipeStalled)
+    case kUSBHostReturnPipeStalled:
+#endif
+        return "pipe is stalled";
+    case kIOReturnError:
+        return "could not establish a connection to the Darwin kernel";
+    case kIOUSBTransactionTimeout:
+        return "transaction timed out";
+    case kIOReturnBadArgument:
+        return "invalid argument";
+    case kIOReturnAborted:
+        return "transaction aborted";
+    case kIOReturnNotResponding:
+        return "device not responding";
+    case kIOReturnOverrun:
+        return "data overrun";
+    case kIOReturnCannotWire:
+        return "physical memory can not be wired down";
+    case kIOReturnNoResources:
+        return "out of resources";
+    case kIOUSBHighSpeedSplitError:
+        return "high speed split error";
+    case kIOUSBUnknownPipeErr:
+        return "pipe ref not recognized";
+    default:
+        snprintf(string_buffer, sizeof(string_buffer), "unknown error (0x%x)", result);
+        return string_buffer;
+    }
+}
+#endif
+
+static enum libusb_error darwin_to_libusb(IOReturn result) {
+    switch(result) {
+    case kIOReturnUnderrun:
+    case kIOReturnSuccess:
+        return LIBUSB_SUCCESS;
+    case kIOReturnNotOpen:
+    case kIOReturnNoDevice:
+        return LIBUSB_ERROR_NO_DEVICE;
+    case kIOReturnExclusiveAccess:
+        return LIBUSB_ERROR_ACCESS;
+    case kIOUSBPipeStalled:
+#if defined(kUSBHostReturnPipeStalled)
+    case kUSBHostReturnPipeStalled:
+#endif
+        return LIBUSB_ERROR_PIPE;
+    case kIOReturnBadArgument:
+        return LIBUSB_ERROR_INVALID_PARAM;
+    case kIOUSBTransactionTimeout:
+        return LIBUSB_ERROR_TIMEOUT;
+    case kIOUSBUnknownPipeErr:
+        return LIBUSB_ERROR_NOT_FOUND;
+    case kIOReturnNotResponding:
+    case kIOReturnAborted:
+    case kIOReturnError:
+    case kIOUSBNoAsyncPortErr:
+    default:
+        return LIBUSB_ERROR_OTHER;
+    }
+}
+
+/* this function must be called with the darwin_cached_devices_mutex held */
+static void darwin_deref_cached_device(struct darwin_cached_device *cached_dev) {
+    cached_dev->refcount--;
+    /* free the device and remove it from the cache */
+    if(0 == cached_dev->refcount) {
+        list_del(&cached_dev->list);
+
+        if(cached_dev->device) {
+            (*(cached_dev->device))->Release(cached_dev->device);
+            cached_dev->device = NULL;
+        }
+        IOObjectRelease(cached_dev->service);
+        free(cached_dev);
+    }
+}
+
+static void darwin_ref_cached_device(struct darwin_cached_device *cached_dev) {
+    cached_dev->refcount++;
+}
+
+static int ep_to_pipeRef(struct libusb_device_handle *dev_handle, uint8_t ep, uint8_t *pipep, uint8_t *ifcp, struct darwin_interface **interface_out) {
+    struct darwin_device_handle_priv *priv = usbi_get_device_handle_priv(dev_handle);
+
+    /* current interface */
+    struct darwin_interface *cInterface;
+
+    uint8_t i, iface;
+
+    struct libusb_context *ctx = HANDLE_CTX(dev_handle);
+
+    usbi_dbg(ctx, "converting ep address 0x%02x to pipeRef and interface", ep);
+
+    for(iface = 0; iface < USB_MAXINTERFACES; iface++) {
+        cInterface = &priv->interfaces[iface];
+
+        if(dev_handle->claimed_interfaces & (1U << iface)) {
+            for(i = 0; i < cInterface->num_endpoints; i++) {
+                if(cInterface->endpoint_addrs[i] == ep) {
+                    *pipep = i + 1;
+
+                    if(ifcp)
+                        *ifcp = iface;
+
+                    if(interface_out)
+                        *interface_out = cInterface;
+
+                    usbi_dbg(ctx, "pipe %d on interface %d matches", *pipep, iface);
+                    return LIBUSB_SUCCESS;
+                }
+            }
+        }
+    }
+
+    /* No pipe found with the correct endpoint address */
+    usbi_warn(HANDLE_CTX(dev_handle), "no pipeRef found with endpoint address 0x%02x.", ep);
+
+    return LIBUSB_ERROR_NOT_FOUND;
+}
+
+static IOReturn usb_setup_device_iterator(io_iterator_t *deviceIterator, UInt32 location) {
+    CFMutableDictionaryRef matchingDict = IOServiceMatching(darwin_device_class);
+
+    if(!matchingDict)
+        return kIOReturnError;
+
+    if(location) {
+        CFMutableDictionaryRef propertyMatchDict =
+            CFDictionaryCreateMutable(kCFAllocatorDefault, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
+
+        /* there are no unsigned CFNumber types so treat the value as signed. the OS seems to do this
+             internally (CFNumberType of locationID is kCFNumberSInt32Type) */
+        CFTypeRef locationCF = CFNumberCreate(NULL, kCFNumberSInt32Type, &location);
+
+        if(propertyMatchDict && locationCF) {
+            CFDictionarySetValue(propertyMatchDict, CFSTR(kUSBDevicePropertyLocationID), locationCF);
+            CFDictionarySetValue(matchingDict, CFSTR(kIOPropertyMatchKey), propertyMatchDict);
+        }
+        /* else we can still proceed as long as the caller accounts for the possibility of other devices in the iterator */
+
+        /* release our references as per the Create Rule */
+        if(propertyMatchDict)
+            CFRelease(propertyMatchDict);
+        if(locationCF)
+            CFRelease(locationCF);
+    }
+
+    return IOServiceGetMatchingServices(darwin_default_master_port, matchingDict, deviceIterator);
+}
+
+/* Returns 1 on success, 0 on failure. */
+static bool get_ioregistry_value_number(io_service_t service, CFStringRef property, CFNumberType type, void *p) {
+    CFTypeRef cfNumber = IORegistryEntryCreateCFProperty(service, property, kCFAllocatorDefault, 0);
+    Boolean   success  = 0;
+
+    if(cfNumber) {
+        if(CFGetTypeID(cfNumber) == CFNumberGetTypeID()) {
+            success = CFNumberGetValue(cfNumber, type, p);
+        }
+
+        CFRelease(cfNumber);
+    }
+
+    return (success != 0);
+}
+
+/* Returns 1 on success, 0 on failure. */
+static bool get_ioregistry_value_data(io_service_t service, CFStringRef property, ssize_t size, void *p) {
+    CFTypeRef cfData  = IORegistryEntryCreateCFProperty(service, property, kCFAllocatorDefault, 0);
+    bool      success = false;
+
+    if(cfData) {
+        if(CFGetTypeID(cfData) == CFDataGetTypeID()) {
+            CFIndex length = CFDataGetLength(cfData);
+            if(length < size) {
+                size = length;
+            }
+
+            CFDataGetBytes(cfData, CFRangeMake(0, size), p);
+            success = true;
+        }
+
+        CFRelease(cfData);
+    }
+
+    return success;
+}
+
+static usb_device_t **darwin_device_from_service(struct libusb_context *ctx, io_service_t service) {
+    io_cf_plugin_ref_t *plugInInterface = NULL;
+    usb_device_t      **device;
+    IOReturn            kresult;
+    SInt32              score;
+    const int           max_retries = 5;
+
+    /* The IOCreatePlugInInterfaceForService function might consistently return
+       an "out of resources" error with certain USB devices the first time we run
+       it. The reason is still unclear, but retrying fixes the problem */
+    for(int count = 0; count < max_retries; count++) {
+        kresult = IOCreatePlugInInterfaceForService(service, kIOUSBDeviceUserClientTypeID, kIOCFPlugInInterfaceID, &plugInInterface, &score);
+        if(kIOReturnSuccess == kresult && plugInInterface) {
+            break;
+        }
+
+        usbi_dbg(ctx, "set up plugin for service retry: %s", darwin_error_str(kresult));
+
+        /* sleep for a little while before trying again */
+        nanosleep(&(struct timespec){ .tv_sec = 0, .tv_nsec = 1000 }, NULL);
+    }
+
+    if(kIOReturnSuccess != kresult || !plugInInterface) {
+        usbi_dbg(ctx, "could not set up plugin for service: %s", darwin_error_str(kresult));
+        return NULL;
+    }
+
+    (void)(*plugInInterface)->QueryInterface(plugInInterface, CFUUIDGetUUIDBytes(DeviceInterfaceID), (LPVOID)&device);
+    /* Use release instead of IODestroyPlugInInterface to avoid stopping IOServices associated with this device */
+    (*plugInInterface)->Release(plugInInterface);
+
+    return device;
+}
+
+static void darwin_devices_attached(void *ptr, io_iterator_t add_devices) {
+    UNUSED(ptr);
+    struct darwin_cached_device *cached_device;
+    UInt64                       old_session_id;
+    struct libusb_context       *ctx;
+    io_service_t                 service;
+    int                          ret;
+
+    usbi_mutex_lock(&active_contexts_lock);
+
+    while((service = IOIteratorNext(add_devices))) {
+        ret = darwin_get_cached_device(NULL, service, &cached_device, &old_session_id);
+        if(ret < 0 || !cached_device->can_enumerate) {
+            continue;
+        }
+
+        /* add this device to each active context's device list */
+        for_each_context(ctx) {
+            process_new_device(ctx, cached_device, old_session_id);
+        }
+
+        if(cached_device->in_reenumerate) {
+            usbi_dbg(NULL, "cached device in reset state. reset complete...");
+            cached_device->in_reenumerate = false;
+        }
+
+        IOObjectRelease(service);
+    }
+
+    usbi_mutex_unlock(&active_contexts_lock);
+}
+
+static void darwin_devices_detached(void *ptr, io_iterator_t rem_devices) {
+    UNUSED(ptr);
+    struct libusb_device        *dev = NULL;
+    struct libusb_context       *ctx;
+    struct darwin_cached_device *old_device;
+
+    io_service_t device;
+    UInt64       session, locationID;
+    int          ret;
+
+    usbi_mutex_lock(&active_contexts_lock);
+
+    while((device = IOIteratorNext(rem_devices)) != 0) {
+        bool is_reenumerating = false;
+
+        /* get the location from the i/o registry */
+        ret = get_ioregistry_value_number(device, CFSTR("sessionID"), kCFNumberSInt64Type, &session);
+        (void)get_ioregistry_value_number(device, CFSTR("locationID"), kCFNumberSInt32Type, &locationID);
+        IOObjectRelease(device);
+        if(!ret)
+            continue;
+
+        /* we need to match darwin_ref_cached_device call made in darwin_get_cached_device function
+           otherwise no cached device will ever get freed */
+        usbi_mutex_lock(&darwin_cached_devices_mutex);
+        list_for_each_entry(old_device, &darwin_cached_devices, list, struct darwin_cached_device) {
+            if(old_device->session == session) {
+                if(old_device->in_reenumerate) {
+                    /* device is re-enumerating. do not dereference the device at this time. libusb_reset_device()
+                     * will deref if needed. */
+                    usbi_dbg(NULL, "detected device detached due to re-enumeration. sessionID: 0x%" PRIx64 ", locationID: 0x%" PRIx64, session, locationID);
+
+                    /* the device object is no longer usable so go ahead and release it */
+                    if(old_device->device) {
+                        (*(old_device->device))->Release(old_device->device);
+                        old_device->device = NULL;
+                    }
+
+                    is_reenumerating = true;
+                }
+                else {
+                    darwin_deref_cached_device(old_device);
+                }
+
+                break;
+            }
+        }
+
+        usbi_mutex_unlock(&darwin_cached_devices_mutex);
+        if(is_reenumerating) {
+            continue;
+        }
+
+        for_each_context(ctx) {
+            usbi_dbg(ctx, "notifying context %p of device disconnect", ctx);
+
+            dev = usbi_get_device_by_session_id(ctx, (unsigned long)session);
+            if(dev) {
+                /* signal the core that this device has been disconnected. the core will tear down this device
+                   when the reference count reaches 0 */
+                usbi_disconnect_device(dev);
+                libusb_unref_device(dev);
+            }
+        }
+    }
+
+    usbi_mutex_unlock(&active_contexts_lock);
+}
+
+static void darwin_hotplug_poll(void) {
+    /* not sure if 1 ms will be too long/short but it should work ok */
+    mach_timespec_t timeout = { .tv_sec = 0, .tv_nsec = 1000000ul };
+
+    /* since a kernel thread may notify the IOIterators used for
+     * hotplug notification we can't just clear the iterators.
+     * instead just wait until all IOService providers are quiet */
+    (void)IOKitWaitQuiet(darwin_default_master_port, &timeout);
+}
+
+static void darwin_clear_iterator(io_iterator_t iter) {
+    io_service_t device;
+
+    while((device = IOIteratorNext(iter)) != 0)
+        IOObjectRelease(device);
+}
+
+static void darwin_fail_startup(void) {
+    pthread_mutex_lock(&libusb_darwin_at_mutex);
+    libusb_darwin_acfl = LIBUSB_DARWIN_STARTUP_FAILURE;
+    pthread_cond_signal(&libusb_darwin_at_cond);
+    pthread_mutex_unlock(&libusb_darwin_at_mutex);
+    pthread_exit(NULL);
+}
+
+static void *darwin_event_thread_main(void *arg0) {
+    UNUSED(arg0);
+    IOReturn               kresult;
+    CFRunLoopRef           runloop;
+    CFRunLoopSourceRef     libusb_shutdown_cfsource;
+    CFRunLoopSourceContext libusb_shutdown_cfsourcectx;
+
+#if MAC_OS_X_VERSION_MIN_REQUIRED >= 1060
+    /* Set this thread's name, so it can be seen in the debugger
+       and crash reports. */
+    pthread_setname_np("org.libusb.device-hotplug");
+#endif
+
+#if MAC_OS_X_VERSION_MIN_REQUIRED >= 1060 && MAC_OS_X_VERSION_MIN_REQUIRED < 101200
+    /* Tell the Objective-C garbage collector about this thread.
+       This is required because, unlike NSThreads, pthreads are
+       not automatically registered. Although we don't use
+       Objective-C, we use CoreFoundation, which does.
+       Garbage collection support was entirely removed in 10.12,
+       so don't bother there. */
+    objc_registerThreadWithCollector();
+#endif
+
+    /* hotplug (device arrival/removal) sources */
+    CFRunLoopSourceRef     libusb_notification_cfsource;
+    io_notification_port_t libusb_notification_port;
+    io_iterator_t          libusb_rem_device_iterator;
+    io_iterator_t          libusb_add_device_iterator;
+
+    /* ctx must only be used for logging during thread startup */
+    usbi_dbg(NULL, "creating hotplug event source");
+
+    runloop = CFRunLoopGetCurrent();
+    CFRetain(runloop);
+
+    /* add the shutdown cfsource to the run loop */
+    memset(&libusb_shutdown_cfsourcectx, 0, sizeof(libusb_shutdown_cfsourcectx));
+    libusb_shutdown_cfsourcectx.info    = runloop;
+    libusb_shutdown_cfsourcectx.perform = (void (*)(void *))CFRunLoopStop;
+    libusb_shutdown_cfsource            = CFRunLoopSourceCreate(NULL, 0, &libusb_shutdown_cfsourcectx);
+    CFRunLoopAddSource(runloop, libusb_shutdown_cfsource, kCFRunLoopDefaultMode);
+
+    /* add the notification port to the run loop */
+    libusb_notification_port     = IONotificationPortCreate(darwin_default_master_port);
+    libusb_notification_cfsource = IONotificationPortGetRunLoopSource(libusb_notification_port);
+    CFRunLoopAddSource(runloop, libusb_notification_cfsource, kCFRunLoopDefaultMode);
+
+    /* create notifications for removed devices */
+    kresult = IOServiceAddMatchingNotification(libusb_notification_port, kIOTerminatedNotification, IOServiceMatching(darwin_device_class),
+                                               darwin_devices_detached, NULL, &libusb_rem_device_iterator);
+
+    if(kresult != kIOReturnSuccess) {
+        usbi_err(NULL, "could not add hotplug event source: %s", darwin_error_str(kresult));
+        CFRelease(libusb_shutdown_cfsource);
+        CFRelease(runloop);
+        darwin_fail_startup();
+    }
+
+    /* create notifications for attached devices */
+    kresult = IOServiceAddMatchingNotification(libusb_notification_port, kIOFirstMatchNotification, IOServiceMatching(darwin_device_class),
+                                               darwin_devices_attached, NULL, &libusb_add_device_iterator);
+
+    if(kresult != kIOReturnSuccess) {
+        usbi_err(NULL, "could not add hotplug event source: %s", darwin_error_str(kresult));
+        CFRelease(libusb_shutdown_cfsource);
+        CFRelease(runloop);
+        darwin_fail_startup();
+    }
+
+    /* arm notifiers */
+    darwin_clear_iterator(libusb_rem_device_iterator);
+    darwin_clear_iterator(libusb_add_device_iterator);
+
+    usbi_dbg(NULL, "darwin event thread ready to receive events");
+
+    /* signal the main thread that the hotplug runloop has been created. */
+    pthread_mutex_lock(&libusb_darwin_at_mutex);
+    libusb_darwin_acfl  = runloop;
+    libusb_darwin_acfls = libusb_shutdown_cfsource;
+    pthread_cond_signal(&libusb_darwin_at_cond);
+    pthread_mutex_unlock(&libusb_darwin_at_mutex);
+
+    /* run the runloop */
+    CFRunLoopRun();
+
+    usbi_dbg(NULL, "darwin event thread exiting");
+
+    /* signal the main thread that the hotplug runloop has finished. */
+    pthread_mutex_lock(&libusb_darwin_at_mutex);
+    libusb_darwin_acfls = NULL;
+    libusb_darwin_acfl  = NULL;
+    pthread_cond_signal(&libusb_darwin_at_cond);
+    pthread_mutex_unlock(&libusb_darwin_at_mutex);
+
+    /* remove the notification cfsource */
+    CFRunLoopRemoveSource(runloop, libusb_notification_cfsource, kCFRunLoopDefaultMode);
+
+    /* remove the shutdown cfsource */
+    CFRunLoopRemoveSource(runloop, libusb_shutdown_cfsource, kCFRunLoopDefaultMode);
+
+    /* delete notification port */
+    IONotificationPortDestroy(libusb_notification_port);
+
+    /* delete iterators */
+    IOObjectRelease(libusb_rem_device_iterator);
+    IOObjectRelease(libusb_add_device_iterator);
+
+    CFRelease(libusb_shutdown_cfsource);
+    CFRelease(runloop);
+
+    pthread_exit(NULL);
+}
+
+/* cleanup function to destroy cached devices. must be called with a lock on darwin_cached_devices_mutex */
+static void darwin_cleanup_devices(void) {
+    struct darwin_cached_device *dev, *next;
+
+    list_for_each_entry_safe(dev, next, &darwin_cached_devices, list, struct darwin_cached_device) {
+        if(dev->refcount > 1) {
+            usbi_err(NULL, "device still referenced at libusb_exit");
+        }
+        darwin_deref_cached_device(dev);
+    }
+}
+
+/* must be called with a lock on darwin_cached_devices_mutex */
+static int darwin_first_time_init(void) {
+    if(NULL == darwin_cached_devices.next) {
+        list_init(&darwin_cached_devices);
+    }
+
+    if(!list_empty(&darwin_cached_devices)) {
+        usbi_err(NULL, "libusb_device reference not released on last exit. will not continue");
+        return LIBUSB_ERROR_OTHER;
+    }
+
+    int rc = pthread_create(&libusb_darwin_at, NULL, darwin_event_thread_main, NULL);
+    if(0 != rc) {
+        usbi_err(NULL, "could not create event thread, error %d", rc);
+        return LIBUSB_ERROR_OTHER;
+    }
+
+    pthread_mutex_lock(&libusb_darwin_at_mutex);
+    while(NULL == libusb_darwin_acfl) {
+        pthread_cond_wait(&libusb_darwin_at_cond, &libusb_darwin_at_mutex);
+    }
+
+    if(libusb_darwin_acfl == LIBUSB_DARWIN_STARTUP_FAILURE) {
+        libusb_darwin_acfl = NULL;
+        rc                 = LIBUSB_ERROR_OTHER;
+    }
+    pthread_mutex_unlock(&libusb_darwin_at_mutex);
+
+    return rc;
+}
+
+static int darwin_init_context(struct libusb_context *ctx) {
+    usbi_mutex_lock(&darwin_cached_devices_mutex);
+
+    bool first_init = (1 == ++init_count);
+
+    if(first_init) {
+        int rc = darwin_first_time_init();
+        if(LIBUSB_SUCCESS != rc) {
+            usbi_mutex_unlock(&darwin_cached_devices_mutex);
+            return rc;
+        }
+    }
+    usbi_mutex_unlock(&darwin_cached_devices_mutex);
+
+    return darwin_scan_devices(ctx);
+}
+
+static int darwin_init(struct libusb_context *ctx) {
+    int rc = darwin_init_context(ctx);
+    if(LIBUSB_SUCCESS != rc) {
+        /* clean up any allocated resources */
+        darwin_exit(ctx);
+    }
+
+    return rc;
+}
+
+static void darwin_exit(struct libusb_context *ctx) {
+    UNUSED(ctx);
+
+    usbi_mutex_lock(&darwin_cached_devices_mutex);
+    if(0 == --init_count) {
+        /* stop the event runloop and wait for the thread to terminate. */
+        pthread_mutex_lock(&libusb_darwin_at_mutex);
+        CFRunLoopSourceSignal(libusb_darwin_acfls);
+        CFRunLoopWakeUp(libusb_darwin_acfl);
+        while(libusb_darwin_acfl)
+            pthread_cond_wait(&libusb_darwin_at_cond, &libusb_darwin_at_mutex);
+        pthread_mutex_unlock(&libusb_darwin_at_mutex);
+        pthread_join(libusb_darwin_at, NULL);
+
+        darwin_cleanup_devices();
+    }
+    usbi_mutex_unlock(&darwin_cached_devices_mutex);
+}
+
+static int get_configuration_index(struct libusb_device *dev, UInt8 config_value) {
+    struct darwin_cached_device    *priv = DARWIN_CACHED_DEVICE(dev);
+    UInt8                           i, numConfig;
+    IOUSBConfigurationDescriptorPtr desc;
+    IOReturn                        kresult;
+
+    /* is there a simpler way to determine the index? */
+    kresult = (*(priv->device))->GetNumberOfConfigurations(priv->device, &numConfig);
+    if(kresult != kIOReturnSuccess)
+        return darwin_to_libusb(kresult);
+
+    for(i = 0; i < numConfig; i++) {
+        (*(priv->device))->GetConfigurationDescriptorPtr(priv->device, i, &desc);
+
+        if(desc->bConfigurationValue == config_value)
+            return i;
+    }
+
+    /* configuration not found */
+    return LIBUSB_ERROR_NOT_FOUND;
+}
+
+static int darwin_get_active_config_descriptor(struct libusb_device *dev, void *buffer, size_t len) {
+    struct darwin_cached_device *priv = DARWIN_CACHED_DEVICE(dev);
+    int                          config_index;
+
+    if(0 == priv->active_config)
+        return LIBUSB_ERROR_NOT_FOUND;
+
+    config_index = get_configuration_index(dev, priv->active_config);
+    if(config_index < 0)
+        return config_index;
+
+    assert(config_index >= 0 && config_index <= UINT8_MAX);
+    return darwin_get_config_descriptor(dev, (UInt8)config_index, buffer, len);
+}
+
+static int darwin_get_config_descriptor(struct libusb_device *dev, uint8_t config_index, void *buffer, size_t len) {
+    struct darwin_cached_device    *priv = DARWIN_CACHED_DEVICE(dev);
+    IOUSBConfigurationDescriptorPtr desc;
+    IOReturn                        kresult;
+    int                             ret;
+
+    if(!priv || !priv->device)
+        return LIBUSB_ERROR_OTHER;
+
+    kresult = (*priv->device)->GetConfigurationDescriptorPtr(priv->device, config_index, &desc);
+    if(kresult == kIOReturnSuccess) {
+        /* copy descriptor */
+        if(libusb_le16_to_cpu(desc->wTotalLength) < len)
+            len = libusb_le16_to_cpu(desc->wTotalLength);
+
+        memmove(buffer, desc, len);
+    }
+
+    ret = darwin_to_libusb(kresult);
+    if(ret != LIBUSB_SUCCESS)
+        return ret;
+
+    return (int)len;
+}
+
+/* check whether the os has configured the device */
+static enum libusb_error darwin_check_configuration(struct libusb_context *ctx, struct darwin_cached_device *dev) {
+    usb_device_t **darwin_device = dev->device;
+
+    IOUSBConfigurationDescriptorPtr configDesc;
+    IOUSBFindInterfaceRequest       request;
+    IOReturn                        kresult;
+    io_iterator_t                   interface_iterator;
+    io_service_t                    firstInterface;
+
+    if(dev->dev_descriptor.bNumConfigurations < 1) {
+        usbi_err(ctx, "device has no configurations");
+        return LIBUSB_ERROR_OTHER; /* no configurations at this speed so we can't use it */
+    }
+
+    /* checking the configuration of a root hub simulation takes ~1 s in 10.11. the device is
+       not usable anyway */
+    if(0x05ac == libusb_le16_to_cpu(dev->dev_descriptor.idVendor) && 0x8005 == libusb_le16_to_cpu(dev->dev_descriptor.idProduct)) {
+        usbi_dbg(ctx, "ignoring configuration on root hub simulation");
+        dev->active_config = 0;
+        return LIBUSB_SUCCESS;
+    }
+
+    /* find the first configuration */
+    kresult           = (*darwin_device)->GetConfigurationDescriptorPtr(darwin_device, 0, &configDesc);
+    dev->first_config = (kIOReturnSuccess == kresult) ? configDesc->bConfigurationValue : 1;
+
+    /* check if the device is already configured. there is probably a better way than iterating over the
+       to accomplish this (the trick is we need to avoid a call to GetConfigurations since buggy devices
+       might lock up on the device request) */
+
+    /* Setup the Interface Request */
+    request.bInterfaceClass    = kIOUSBFindInterfaceDontCare;
+    request.bInterfaceSubClass = kIOUSBFindInterfaceDontCare;
+    request.bInterfaceProtocol = kIOUSBFindInterfaceDontCare;
+    request.bAlternateSetting  = kIOUSBFindInterfaceDontCare;
+
+    kresult = (*(darwin_device))->CreateInterfaceIterator(darwin_device, &request, &interface_iterator);
+    if(kresult != kIOReturnSuccess)
+        return darwin_to_libusb(kresult);
+
+    /* iterate once */
+    firstInterface = IOIteratorNext(interface_iterator);
+
+    /* done with the interface iterator */
+    IOObjectRelease(interface_iterator);
+
+    if(firstInterface) {
+        IOObjectRelease(firstInterface);
+
+        /* device is configured */
+        if(dev->dev_descriptor.bNumConfigurations == 1)
+            /* to avoid problems with some devices get the configurations value from the configuration descriptor */
+            dev->active_config = dev->first_config;
+        else
+            /* devices with more than one configuration should work with GetConfiguration */
+            (*darwin_device)->GetConfiguration(darwin_device, &dev->active_config);
+    }
+    else
+        /* not configured */
+        dev->active_config = 0;
+
+    usbi_dbg(ctx, "active config: %u, first config: %u", dev->active_config, dev->first_config);
+
+    return LIBUSB_SUCCESS;
+}
+
+static IOReturn darwin_request_descriptor(usb_device_t **device, UInt8 desc, UInt8 desc_index, void *buffer, size_t buffer_size) {
+    IOUSBDevRequestTO req;
+
+    assert(buffer_size <= UINT16_MAX);
+
+    memset(buffer, 0, buffer_size);
+
+    /* Set up request for descriptor/ */
+    req.bmRequestType     = USBmakebmRequestType(kUSBIn, kUSBStandard, kUSBDevice);
+    req.bRequest          = kUSBRqGetDescriptor;
+    req.wValue            = (UInt16)(desc << 8);
+    req.wIndex            = desc_index;
+    req.wLength           = (UInt16)buffer_size;
+    req.pData             = buffer;
+    req.noDataTimeout     = 20;
+    req.completionTimeout = 100;
+
+    return (*device)->DeviceRequestTO(device, &req);
+}
+
+static enum libusb_error darwin_cache_device_descriptor(struct libusb_context *ctx, struct darwin_cached_device *dev) {
+    usb_device_t **device      = dev->device;
+    int            retries     = 1;
+    long           delay       = 30000;  // microseconds
+    int            unsuspended = 0, try_unsuspend = 1, try_reconfigure = 1;
+    int            is_open = 0;
+    IOReturn       ret     = 0, ret2;
+    UInt8          bDeviceClass;
+    UInt16         idProduct, idVendor;
+
+    dev->can_enumerate = 0;
+
+    (*device)->GetDeviceClass(device, &bDeviceClass);
+    (*device)->GetDeviceProduct(device, &idProduct);
+    (*device)->GetDeviceVendor(device, &idVendor);
+
+    /* According to Apple's documentation the device must be open for DeviceRequest but we may not be able to open some
+     * devices and Apple's USB Prober doesn't bother to open the device before issuing a descriptor request.  Still,
+     * to follow the spec as closely as possible, try opening the device */
+    is_open = ((*device)->USBDeviceOpenSeize(device) == kIOReturnSuccess);
+
+    do {
+        /**** retrieve device descriptor ****/
+        ret = darwin_request_descriptor(device, kUSBDeviceDesc, 0, &dev->dev_descriptor, sizeof(dev->dev_descriptor));
+
+        if(kIOReturnOverrun == ret && kUSBDeviceDesc == dev->dev_descriptor.bDescriptorType)
+            /* received an overrun error but we still received a device descriptor */
+            ret = kIOReturnSuccess;
+
+        if(kIOUSBVendorIDAppleComputer == idVendor) {
+            /* NTH: don't bother retrying or unsuspending Apple devices */
+            break;
+        }
+
+        if(kIOReturnSuccess == ret && (0 == dev->dev_descriptor.bNumConfigurations || 0 == dev->dev_descriptor.bcdUSB)) {
+            /* work around for incorrectly configured devices */
+            if(try_reconfigure && is_open) {
+                usbi_dbg(ctx, "descriptor appears to be invalid. resetting configuration before trying again...");
+
+                /* set the first configuration */
+                (*device)->SetConfiguration(device, 1);
+
+                /* don't try to reconfigure again */
+                try_reconfigure = 0;
+            }
+
+            ret = kIOUSBPipeStalled;
+        }
+
+        if(kIOReturnSuccess != ret && is_open && try_unsuspend) {
+            /* device may be suspended. unsuspend it and try again */
+#if DeviceVersion >= 320
+            UInt32 info = 0;
+
+            /* IOUSBFamily 320+ provides a way to detect device suspension but earlier versions do not */
+            (void)(*device)->GetUSBDeviceInformation(device, &info);
+
+            /* note that the device was suspended */
+            if(info & (1U << kUSBInformationDeviceIsSuspendedBit) || 0 == info)
+                try_unsuspend = 1;
+#endif
+
+            if(try_unsuspend) {
+                /* try to unsuspend the device */
+                ret2 = (*device)->USBDeviceSuspend(device, 0);
+                if(kIOReturnSuccess != ret2) {
+                    /* prevent log spew from poorly behaving devices.  this indicates the
+                       os actually had trouble communicating with the device */
+                    usbi_dbg(ctx, "could not retrieve device descriptor. failed to unsuspend: %s", darwin_error_str(ret2));
+                }
+                else
+                    unsuspended = 1;
+
+                try_unsuspend = 0;
+            }
+        }
+
+        if(kIOReturnSuccess != ret) {
+            usbi_dbg(ctx, "kernel responded with code: 0x%08x. sleeping for %ld ms before trying again", ret, delay / 1000);
+            /* sleep for a little while before trying again */
+            nanosleep(&(struct timespec){ delay / 1000000, (delay * 1000) % 1000000000 }, NULL);
+        }
+    } while(kIOReturnSuccess != ret && retries--);
+
+    if(unsuspended)
+        /* resuspend the device */
+        (void)(*device)->USBDeviceSuspend(device, 1);
+
+    if(is_open)
+        (void)(*device)->USBDeviceClose(device);
+
+    if(ret != kIOReturnSuccess) {
+        /* a debug message was already printed out for this error */
+        if(LIBUSB_CLASS_HUB == bDeviceClass)
+            usbi_dbg(ctx, "could not retrieve device descriptor %.4x:%.4x: %s (%x). skipping device", idVendor, idProduct, darwin_error_str(ret), ret);
+        else
+            usbi_warn(ctx, "could not retrieve device descriptor %.4x:%.4x: %s (%x). skipping device", idVendor, idProduct, darwin_error_str(ret), ret);
+        return darwin_to_libusb(ret);
+    }
+
+    /* catch buggy hubs (which appear to be virtual). Apple's own USB prober has problems with these devices. */
+    if(libusb_le16_to_cpu(dev->dev_descriptor.idProduct) != idProduct) {
+        /* not a valid device */
+        usbi_warn(NULL, "idProduct from iokit (%04x) does not match idProduct in descriptor (%04x). skipping device", idProduct,
+                  libusb_le16_to_cpu(dev->dev_descriptor.idProduct));
+        return LIBUSB_ERROR_NO_DEVICE;
+    }
+
+    usbi_dbg(ctx, "cached device descriptor:");
+    usbi_dbg(ctx, "  bDescriptorType:    0x%02x", dev->dev_descriptor.bDescriptorType);
+    usbi_dbg(ctx, "  bcdUSB:             0x%04x", libusb_le16_to_cpu(dev->dev_descriptor.bcdUSB));
+    usbi_dbg(ctx, "  bDeviceClass:       0x%02x", dev->dev_descriptor.bDeviceClass);
+    usbi_dbg(ctx, "  bDeviceSubClass:    0x%02x", dev->dev_descriptor.bDeviceSubClass);
+    usbi_dbg(ctx, "  bDeviceProtocol:    0x%02x", dev->dev_descriptor.bDeviceProtocol);
+    usbi_dbg(ctx, "  bMaxPacketSize0:    0x%02x", dev->dev_descriptor.bMaxPacketSize0);
+    usbi_dbg(ctx, "  idVendor:           0x%04x", libusb_le16_to_cpu(dev->dev_descriptor.idVendor));
+    usbi_dbg(ctx, "  idProduct:          0x%04x", libusb_le16_to_cpu(dev->dev_descriptor.idProduct));
+    usbi_dbg(ctx, "  bcdDevice:          0x%04x", libusb_le16_to_cpu(dev->dev_descriptor.bcdDevice));
+    usbi_dbg(ctx, "  iManufacturer:      0x%02x", dev->dev_descriptor.iManufacturer);
+    usbi_dbg(ctx, "  iProduct:           0x%02x", dev->dev_descriptor.iProduct);
+    usbi_dbg(ctx, "  iSerialNumber:      0x%02x", dev->dev_descriptor.iSerialNumber);
+    usbi_dbg(ctx, "  bNumConfigurations: 0x%02x", dev->dev_descriptor.bNumConfigurations);
+
+    dev->can_enumerate = 1;
+
+    return LIBUSB_SUCCESS;
+}
+
+/* Returns 1 on success, 0 on failure. */
+static bool get_device_port(io_service_t service, UInt8 *port) {
+    IOReturn     kresult;
+    io_service_t parent;
+    bool         ret = false;
+
+    if(get_ioregistry_value_number(service, CFSTR("PortNum"), kCFNumberSInt8Type, port)) {
+        return true;
+    }
+
+    kresult = IORegistryEntryGetParentEntry(service, kIOServicePlane, &parent);
+    if(kIOReturnSuccess == kresult) {
+        ret = get_ioregistry_value_data(parent, CFSTR("port"), 1, port);
+        IOObjectRelease(parent);
+    }
+
+    return ret;
+}
+
+/* Returns 1 on success, 0 on failure. */
+static bool get_device_parent_sessionID(io_service_t service, UInt64 *parent_sessionID) {
+    IOReturn     kresult;
+    io_service_t parent;
+
+    /* Walk up the tree in the IOService plane until we find a parent that has a sessionID */
+    parent = service;
+    while((kresult = IORegistryEntryGetParentEntry(parent, kIOUSBPlane, &parent)) == kIOReturnSuccess) {
+        if(get_ioregistry_value_number(parent, CFSTR("sessionID"), kCFNumberSInt64Type, parent_sessionID)) {
+            /* Success */
+            return true;
+        }
+    }
+
+    /* We ran out of parents */
+    return false;
+}
+
+static enum libusb_error darwin_get_cached_device(struct libusb_context *ctx, io_service_t service, struct darwin_cached_device **cached_out,
+                                                  UInt64 *old_session_id) {
+    struct darwin_cached_device *new_device;
+    UInt64                       sessionID = 0, parent_sessionID = 0;
+    UInt32                       locationID = 0;
+    enum libusb_error            ret        = LIBUSB_SUCCESS;
+    usb_device_t               **device;
+    UInt8                        port = 0;
+
+    /* assuming sessionID != 0 normally (never seen it be 0) */
+    *old_session_id = 0;
+    *cached_out     = NULL;
+
+    /* get some info from the io registry */
+    (void)get_ioregistry_value_number(service, CFSTR("sessionID"), kCFNumberSInt64Type, &sessionID);
+    (void)get_ioregistry_value_number(service, CFSTR("locationID"), kCFNumberSInt32Type, &locationID);
+    if(!get_device_port(service, &port)) {
+        usbi_dbg(ctx, "could not get connected port number");
+    }
+
+    usbi_dbg(ctx, "finding cached device for sessionID 0x%" PRIx64, sessionID);
+
+    if(get_device_parent_sessionID(service, &parent_sessionID)) {
+        usbi_dbg(ctx, "parent sessionID: 0x%" PRIx64, parent_sessionID);
+    }
+
+    usbi_mutex_lock(&darwin_cached_devices_mutex);
+    do {
+        list_for_each_entry(new_device, &darwin_cached_devices, list, struct darwin_cached_device) {
+            usbi_dbg(ctx, "matching sessionID/locationID 0x%" PRIx64 "/0x%x against cached device with sessionID/locationID 0x%" PRIx64 "/0x%x", sessionID,
+                     locationID, new_device->session, new_device->location);
+            if(new_device->location == locationID && new_device->in_reenumerate) {
+                usbi_dbg(ctx, "found cached device with matching location that is being re-enumerated");
+                *old_session_id = new_device->session;
+                break;
+            }
+
+            if(new_device->session == sessionID) {
+                usbi_dbg(ctx, "using cached device for device");
+                *cached_out = new_device;
+                break;
+            }
+        }
+
+        if(*cached_out)
+            break;
+
+        usbi_dbg(ctx, "caching new device with sessionID 0x%" PRIx64, sessionID);
+
+        device = darwin_device_from_service(ctx, service);
+        if(!device) {
+            ret = LIBUSB_ERROR_NO_DEVICE;
+            break;
+        }
+
+        if(!(*old_session_id)) {
+            new_device = calloc(1, sizeof(*new_device));
+            if(!new_device) {
+                ret = LIBUSB_ERROR_NO_MEM;
+                break;
+            }
+
+            /* add this device to the cached device list */
+            list_add(&new_device->list, &darwin_cached_devices);
+
+            (*device)->GetDeviceAddress(device, (USBDeviceAddress *)&new_device->address);
+
+            /* keep a reference to this device */
+            darwin_ref_cached_device(new_device);
+
+            (*device)->GetLocationID(device, &new_device->location);
+            new_device->port           = port;
+            new_device->parent_session = parent_sessionID;
+        }
+        else {
+            /* release the ref to old device's service */
+            IOObjectRelease(new_device->service);
+        }
+
+        /* keep track of devices regardless of if we successfully enumerate them to
+           prevent them from being enumerated multiple times */
+        *cached_out = new_device;
+
+        new_device->session = sessionID;
+        new_device->device  = device;
+        new_device->service = service;
+
+        /* retain the service */
+        IOObjectRetain(service);
+
+        /* cache the device descriptor */
+        ret = darwin_cache_device_descriptor(ctx, new_device);
+        if(ret)
+            break;
+
+        if(new_device->can_enumerate) {
+            snprintf(new_device->sys_path, 20, "%03i-%04x-%04x-%02x-%02x", new_device->address, libusb_le16_to_cpu(new_device->dev_descriptor.idVendor),
+                     libusb_le16_to_cpu(new_device->dev_descriptor.idProduct), new_device->dev_descriptor.bDeviceClass,
+                     new_device->dev_descriptor.bDeviceSubClass);
+        }
+    } while(0);
+
+    usbi_mutex_unlock(&darwin_cached_devices_mutex);
+
+    return ret;
+}
+
+static enum libusb_error process_new_device(struct libusb_context *ctx, struct darwin_cached_device *cached_device, UInt64 old_session_id) {
+    struct darwin_device_priv *priv;
+    struct libusb_device      *dev = NULL;
+    UInt8                      devSpeed;
+    enum libusb_error          ret = LIBUSB_SUCCESS;
+
+    do {
+        /* check current active configuration (and cache the first configuration value--
+           which may be used by claim_interface) */
+        ret = darwin_check_configuration(ctx, cached_device);
+        if(ret)
+            break;
+
+        if(0 != old_session_id) {
+            usbi_dbg(ctx, "re-using existing device from context %p for with session 0x%" PRIx64 " new session 0x%" PRIx64, ctx, old_session_id,
+                     cached_device->session);
+            /* save the libusb device before the session id is updated */
+            dev = usbi_get_device_by_session_id(ctx, (unsigned long)old_session_id);
+        }
+
+        if(!dev) {
+            usbi_dbg(ctx, "allocating new device in context %p for with session 0x%" PRIx64, ctx, cached_device->session);
+
+            dev = usbi_alloc_device(ctx, (unsigned long)cached_device->session);
+            if(!dev) {
+                return LIBUSB_ERROR_NO_MEM;
+            }
+
+            priv = usbi_get_device_priv(dev);
+
+            priv->dev = cached_device;
+            darwin_ref_cached_device(priv->dev);
+            dev->port_number = cached_device->port;
+            /* the location ID encodes the path to the device. the top byte of the location ID contains the bus number
+               (numbered from 0). the remaining bytes can be used to construct the device tree for that bus. */
+            dev->bus_number = cached_device->location >> 24;
+            assert(cached_device->address <= UINT8_MAX);
+            dev->device_address = (uint8_t)cached_device->address;
+        }
+        else {
+            priv = usbi_get_device_priv(dev);
+        }
+
+        static_assert(sizeof(dev->device_descriptor) == sizeof(cached_device->dev_descriptor), "mismatch between libusb and IOKit device descriptor sizes");
+        memcpy(&dev->device_descriptor, &cached_device->dev_descriptor, LIBUSB_DT_DEVICE_SIZE);
+        usbi_localize_device_descriptor(&dev->device_descriptor);
+        dev->session_data = cached_device->session;
+
+        if(NULL != dev->parent_dev) {
+            libusb_unref_device(dev->parent_dev);
+            dev->parent_dev = NULL;
+        }
+
+        if(cached_device->parent_session > 0) {
+            dev->parent_dev = usbi_get_device_by_session_id(ctx, (unsigned long)cached_device->parent_session);
+        }
+
+        (*(priv->dev->device))->GetDeviceSpeed(priv->dev->device, &devSpeed);
+
+        switch(devSpeed) {
+        case kUSBDeviceSpeedLow:
+            dev->speed = LIBUSB_SPEED_LOW;
+            break;
+        case kUSBDeviceSpeedFull:
+            dev->speed = LIBUSB_SPEED_FULL;
+            break;
+        case kUSBDeviceSpeedHigh:
+            dev->speed = LIBUSB_SPEED_HIGH;
+            break;
+#if MAC_OS_X_VERSION_MAX_ALLOWED >= 1080
+        case kUSBDeviceSpeedSuper:
+            dev->speed = LIBUSB_SPEED_SUPER;
+            break;
+#endif
+#if MAC_OS_X_VERSION_MAX_ALLOWED >= 101200
+        case kUSBDeviceSpeedSuperPlus:
+            dev->speed = LIBUSB_SPEED_SUPER_PLUS;
+            break;
+#endif
+        default:
+            usbi_warn(ctx, "Got unknown device speed %d", devSpeed);
+        }
+
+        ret = usbi_sanitize_device(dev);
+        if(ret < 0)
+            break;
+
+        usbi_dbg(ctx, "found device with address %d port = %d parent = %p at %p", dev->device_address, dev->port_number, (void *)dev->parent_dev,
+                 priv->dev->sys_path);
+
+    } while(0);
+
+    if(!cached_device->in_reenumerate && 0 == ret) {
+        usbi_connect_device(dev);
+    }
+    else {
+        libusb_unref_device(dev);
+    }
+
+    return ret;
+}
+
+static enum libusb_error darwin_scan_devices(struct libusb_context *ctx) {
+    struct darwin_cached_device *cached_device;
+    UInt64                       old_session_id;
+    io_iterator_t                deviceIterator;
+    io_service_t                 service;
+    IOReturn                     kresult;
+    int                          ret;
+
+    kresult = usb_setup_device_iterator(&deviceIterator, 0);
+    if(kresult != kIOReturnSuccess)
+        return darwin_to_libusb(kresult);
+
+    while((service = IOIteratorNext(deviceIterator))) {
+        ret = darwin_get_cached_device(ctx, service, &cached_device, &old_session_id);
+        if(ret < 0 || !cached_device->can_enumerate) {
+            continue;
+        }
+
+        (void)process_new_device(ctx, cached_device, old_session_id);
+
+        IOObjectRelease(service);
+    }
+
+    IOObjectRelease(deviceIterator);
+
+    return LIBUSB_SUCCESS;
+}
+
+static int darwin_open(struct libusb_device_handle *dev_handle) {
+    struct darwin_device_handle_priv *priv  = usbi_get_device_handle_priv(dev_handle);
+    struct darwin_cached_device      *dpriv = DARWIN_CACHED_DEVICE(dev_handle->dev);
+    IOReturn                          kresult;
+
+    if(0 == dpriv->open_count) {
+        /* try to open the device */
+        kresult = (*(dpriv->device))->USBDeviceOpenSeize(dpriv->device);
+        if(kresult != kIOReturnSuccess) {
+            usbi_warn(HANDLE_CTX(dev_handle), "USBDeviceOpen: %s", darwin_error_str(kresult));
+
+            if(kIOReturnExclusiveAccess != kresult) {
+                return darwin_to_libusb(kresult);
+            }
+
+            /* it is possible to perform some actions on a device that is not open so do not return an error */
+            priv->is_open = false;
+        }
+        else {
+            priv->is_open = true;
+        }
+
+        /* create async event source */
+        kresult = (*(dpriv->device))->CreateDeviceAsyncEventSource(dpriv->device, &priv->cfSource);
+        if(kresult != kIOReturnSuccess) {
+            usbi_err(HANDLE_CTX(dev_handle), "CreateDeviceAsyncEventSource: %s", darwin_error_str(kresult));
+
+            if(priv->is_open) {
+                (*(dpriv->device))->USBDeviceClose(dpriv->device);
+            }
+
+            priv->is_open = false;
+
+            return darwin_to_libusb(kresult);
+        }
+
+        CFRetain(libusb_darwin_acfl);
+
+        /* add the cfSource to the async run loop */
+        CFRunLoopAddSource(libusb_darwin_acfl, priv->cfSource, kCFRunLoopCommonModes);
+    }
+
+    /* device opened successfully */
+    dpriv->open_count++;
+
+    usbi_dbg(HANDLE_CTX(dev_handle), "device open for access");
+
+    return 0;
+}
+
+static void darwin_close(struct libusb_device_handle *dev_handle) {
+    struct darwin_device_handle_priv *priv  = usbi_get_device_handle_priv(dev_handle);
+    struct darwin_cached_device      *dpriv = DARWIN_CACHED_DEVICE(dev_handle->dev);
+    IOReturn                          kresult;
+    int                               i;
+
+    if(dpriv->open_count == 0) {
+        /* something is probably very wrong if this is the case */
+        usbi_err(HANDLE_CTX(dev_handle), "Close called on a device that was not open!");
+        return;
+    }
+
+    dpriv->open_count--;
+    if(NULL == dpriv->device) {
+        usbi_warn(HANDLE_CTX(dev_handle), "darwin_close device missing IOService");
+        return;
+    }
+
+    /* make sure all interfaces are released */
+    for(i = 0; i < USB_MAXINTERFACES; i++)
+        if(dev_handle->claimed_interfaces & (1U << i))
+            libusb_release_interface(dev_handle, i);
+
+    if(0 == dpriv->open_count) {
+        /* delete the device's async event source */
+        if(priv->cfSource) {
+            CFRunLoopRemoveSource(libusb_darwin_acfl, priv->cfSource, kCFRunLoopDefaultMode);
+            CFRelease(priv->cfSource);
+            priv->cfSource = NULL;
+            CFRelease(libusb_darwin_acfl);
+        }
+
+        if(priv->is_open) {
+            /* close the device */
+            kresult = (*(dpriv->device))->USBDeviceClose(dpriv->device);
+            if(kresult != kIOReturnSuccess) {
+                /* Log the fact that we had a problem closing the file, however failing a
+                 * close isn't really an error, so return success anyway */
+                usbi_warn(HANDLE_CTX(dev_handle), "USBDeviceClose: %s", darwin_error_str(kresult));
+            }
+        }
+    }
+}
+
+static int darwin_get_configuration(struct libusb_device_handle *dev_handle, uint8_t *config) {
+    struct darwin_cached_device *dpriv = DARWIN_CACHED_DEVICE(dev_handle->dev);
+
+    *config = dpriv->active_config;
+
+    return LIBUSB_SUCCESS;
+}
+
+static enum libusb_error darwin_set_configuration(struct libusb_device_handle *dev_handle, int config) {
+    struct darwin_cached_device *dpriv = DARWIN_CACHED_DEVICE(dev_handle->dev);
+    IOReturn                     kresult;
+    uint8_t                      i;
+
+    if(config == -1)
+        config = 0;
+
+    /* Setting configuration will invalidate the interface, so we need
+       to reclaim it. First, dispose of existing interfaces, if any. */
+    for(i = 0; i < USB_MAXINTERFACES; i++)
+        if(dev_handle->claimed_interfaces & (1U << i))
+            darwin_release_interface(dev_handle, i);
+
+    kresult = (*(dpriv->device))->SetConfiguration(dpriv->device, (UInt8)config);
+    if(kresult != kIOReturnSuccess)
+        return darwin_to_libusb(kresult);
+
+    /* Reclaim any interfaces. */
+    for(i = 0; i < USB_MAXINTERFACES; i++)
+        if(dev_handle->claimed_interfaces & (1U << i))
+            darwin_claim_interface(dev_handle, i);
+
+    dpriv->active_config = (UInt8)config;
+
+    return LIBUSB_SUCCESS;
+}
+
+static IOReturn darwin_get_interface(usb_device_t **darwin_device, uint8_t ifc, io_service_t *usbInterfacep) {
+    IOUSBFindInterfaceRequest request;
+    IOReturn                  kresult;
+    io_iterator_t             interface_iterator;
+    UInt8                     bInterfaceNumber;
+    bool                      ret;
+
+    *usbInterfacep = IO_OBJECT_NULL;
+
+    /* Setup the Interface Request */
+    request.bInterfaceClass    = kIOUSBFindInterfaceDontCare;
+    request.bInterfaceSubClass = kIOUSBFindInterfaceDontCare;
+    request.bInterfaceProtocol = kIOUSBFindInterfaceDontCare;
+    request.bAlternateSetting  = kIOUSBFindInterfaceDontCare;
+
+    kresult = (*(darwin_device))->CreateInterfaceIterator(darwin_device, &request, &interface_iterator);
+    if(kresult != kIOReturnSuccess)
+        return kresult;
+
+    while((*usbInterfacep = IOIteratorNext(interface_iterator))) {
+        /* find the interface number */
+        ret = get_ioregistry_value_number(*usbInterfacep, CFSTR("bInterfaceNumber"), kCFNumberSInt8Type, &bInterfaceNumber);
+
+        if(ret && bInterfaceNumber == ifc) {
+            break;
+        }
+
+        (void)IOObjectRelease(*usbInterfacep);
+    }
+
+    /* done with the interface iterator */
+    IOObjectRelease(interface_iterator);
+
+    return kIOReturnSuccess;
+}
+
+static const struct libusb_interface_descriptor *get_interface_descriptor_by_number(struct libusb_device_handle     *dev_handle,
+                                                                                    struct libusb_config_descriptor *conf_desc, int iface, uint8_t altsetting) {
+    int i;
+
+    for(i = 0; i < conf_desc->bNumInterfaces; i++) {
+        if(altsetting < conf_desc->interface[i].num_altsetting && conf_desc->interface[i].altsetting[altsetting].bInterfaceNumber == iface) {
+            return &conf_desc->interface[i].altsetting[altsetting];
+        }
+    }
+
+    usbi_err(HANDLE_CTX(dev_handle), "interface %d with altsetting %d not found for device", iface, (int)altsetting);
+    return NULL;
+}
+
+static enum libusb_error get_endpoints(struct libusb_device_handle *dev_handle, uint8_t iface) {
+    struct darwin_device_handle_priv *priv = usbi_get_device_handle_priv(dev_handle);
+
+    /* current interface */
+    struct darwin_interface *cInterface = &priv->interfaces[iface];
+#if InterfaceVersion >= 550
+    IOUSBEndpointProperties pipeProperties = { .bVersion = kUSBEndpointPropertiesVersion3 };
+#else
+    UInt8  dont_care1, dont_care3;
+    UInt16 dont_care2;
+#endif
+
+    IOReturn kresult;
+
+    UInt8                  numep, direction, number;
+    int                    rc;
+    struct libusb_context *ctx = HANDLE_CTX(dev_handle);
+
+    usbi_dbg(ctx, "building table of endpoints.");
+
+    /* retrieve the total number of endpoints on this interface */
+    kresult = (*(cInterface->interface))->GetNumEndpoints(cInterface->interface, &numep);
+    if(kresult != kIOReturnSuccess) {
+        usbi_err(ctx, "can't get number of endpoints for interface: %s", darwin_error_str(kresult));
+        return darwin_to_libusb(kresult);
+    }
+
+    /* iterate through pipe references */
+    for(UInt8 i = 1; i <= numep; i++) {
+#if InterfaceVersion >= 550
+        kresult   = (*(cInterface->interface))->GetPipePropertiesV3(cInterface->interface, i, &pipeProperties);
+        number    = pipeProperties.bEndpointNumber;
+        direction = pipeProperties.bDirection;
+#else
+        kresult = (*(cInterface->interface))->GetPipeProperties(cInterface->interface, i, &direction, &number, &dont_care1, &dont_care2, &dont_care3);
+#endif
+        if(kresult != kIOReturnSuccess) {
+            /* probably a buggy device. try to get the endpoint address from the descriptors */
+            struct libusb_config_descriptor          *config;
+            const struct libusb_interface_descriptor *if_desc;
+            const struct libusb_endpoint_descriptor  *endpoint_desc;
+            UInt8                                     alt_setting;
+
+            kresult = (*(cInterface->interface))->GetAlternateSetting(cInterface->interface, &alt_setting);
+            if(kresult != kIOReturnSuccess) {
+                usbi_err(HANDLE_CTX(dev_handle), "can't get alternate setting for interface");
+                return darwin_to_libusb(kresult);
+            }
+
+            rc = libusb_get_active_config_descriptor(dev_handle->dev, &config);
+            if(LIBUSB_SUCCESS != rc) {
+                return rc;
+            }
+
+            if_desc = get_interface_descriptor_by_number(dev_handle, config, iface, alt_setting);
+            if(if_desc == NULL) {
+                libusb_free_config_descriptor(config);
+                return LIBUSB_ERROR_NOT_FOUND;
+            }
+
+            endpoint_desc = if_desc->endpoint + i - 1;
+
+            cInterface->endpoint_addrs[i - 1] = endpoint_desc->bEndpointAddress;
+            libusb_free_config_descriptor(config);
+        }
+        else {
+            cInterface->endpoint_addrs[i - 1] = (UInt8)(((kUSBIn == direction) << kUSBRqDirnShift) | (number & LIBUSB_ENDPOINT_ADDRESS_MASK));
+        }
+
+        usbi_dbg(ctx, "interface: %i pipe %i: dir: %i number: %i", iface, i, cInterface->endpoint_addrs[i - 1] >> kUSBRqDirnShift,
+                 cInterface->endpoint_addrs[i - 1] & LIBUSB_ENDPOINT_ADDRESS_MASK);
+    }
+
+    cInterface->num_endpoints = numep;
+
+    return LIBUSB_SUCCESS;
+}
+
+static int darwin_claim_interface(struct libusb_device_handle *dev_handle, uint8_t iface) {
+    struct darwin_cached_device      *dpriv        = DARWIN_CACHED_DEVICE(dev_handle->dev);
+    struct darwin_device_handle_priv *priv         = usbi_get_device_handle_priv(dev_handle);
+    io_service_t                      usbInterface = IO_OBJECT_NULL;
+    IOReturn                          kresult;
+    enum libusb_error                 ret;
+    IOCFPlugInInterface             **plugInInterface = NULL;
+    SInt32                            score;
+
+    /* current interface */
+    struct darwin_interface *cInterface = &priv->interfaces[iface];
+
+    struct libusb_context *ctx = HANDLE_CTX(dev_handle);
+
+    kresult = darwin_get_interface(dpriv->device, iface, &usbInterface);
+    if(kresult != kIOReturnSuccess)
+        return darwin_to_libusb(kresult);
+
+    /* make sure we have an interface */
+    if(!usbInterface && dpriv->first_config != 0) {
+        usbi_info(ctx, "no interface found; setting configuration: %d", dpriv->first_config);
+
+        /* set the configuration */
+        ret = darwin_set_configuration(dev_handle, (int)dpriv->first_config);
+        if(ret != LIBUSB_SUCCESS) {
+            usbi_err(ctx, "could not set configuration");
+            return ret;
+        }
+
+        kresult = darwin_get_interface(dpriv->device, iface, &usbInterface);
+        if(kresult != kIOReturnSuccess) {
+            usbi_err(ctx, "darwin_get_interface: %s", darwin_error_str(kresult));
+            return darwin_to_libusb(kresult);
+        }
+    }
+
+    if(!usbInterface) {
+        usbi_info(ctx, "interface not found");
+        return LIBUSB_ERROR_NOT_FOUND;
+    }
+
+    /* get an interface to the device's interface */
+    kresult = IOCreatePlugInInterfaceForService(usbInterface, kIOUSBInterfaceUserClientTypeID, kIOCFPlugInInterfaceID, &plugInInterface, &score);
+
+    /* ignore release error */
+    (void)IOObjectRelease(usbInterface);
+
+    if(kresult != kIOReturnSuccess) {
+        usbi_err(ctx, "IOCreatePlugInInterfaceForService: %s", darwin_error_str(kresult));
+        return darwin_to_libusb(kresult);
+    }
+
+    if(!plugInInterface) {
+        usbi_err(ctx, "plugin interface not found");
+        return LIBUSB_ERROR_NOT_FOUND;
+    }
+
+    /* Do the actual claim */
+    kresult = (*plugInInterface)->QueryInterface(plugInInterface, CFUUIDGetUUIDBytes(InterfaceInterfaceID), (LPVOID)&cInterface->interface);
+    /* We no longer need the intermediate plug-in */
+    /* Use release instead of IODestroyPlugInInterface to avoid stopping IOServices associated with this device */
+    (*plugInInterface)->Release(plugInInterface);
+    if(kresult != kIOReturnSuccess || !cInterface->interface) {
+        usbi_err(ctx, "QueryInterface: %s", darwin_error_str(kresult));
+        return darwin_to_libusb(kresult);
+    }
+
+    /* claim the interface */
+    kresult = (*(cInterface->interface))->USBInterfaceOpen(cInterface->interface);
+    if(kresult != kIOReturnSuccess) {
+        usbi_info(ctx, "USBInterfaceOpen: %s", darwin_error_str(kresult));
+        return darwin_to_libusb(kresult);
+    }
+
+    /* update list of endpoints */
+    ret = get_endpoints(dev_handle, iface);
+    if(ret) {
+        /* this should not happen */
+        darwin_release_interface(dev_handle, iface);
+        usbi_err(ctx, "could not build endpoint table");
+        return ret;
+    }
+
+    cInterface->cfSource = NULL;
+
+    /* create async event source */
+    kresult = (*(cInterface->interface))->CreateInterfaceAsyncEventSource(cInterface->interface, &cInterface->cfSource);
+    if(kresult != kIOReturnSuccess) {
+        usbi_err(ctx, "could not create async event source");
+
+        /* can't continue without an async event source */
+        (void)darwin_release_interface(dev_handle, iface);
+
+        return darwin_to_libusb(kresult);
+    }
+
+    /* add the cfSource to the async thread's run loop */
+    CFRunLoopAddSource(libusb_darwin_acfl, cInterface->cfSource, kCFRunLoopDefaultMode);
+
+    usbi_dbg(ctx, "interface opened");
+
+    return LIBUSB_SUCCESS;
+}
+
+static int darwin_release_interface(struct libusb_device_handle *dev_handle, uint8_t iface) {
+    struct darwin_device_handle_priv *priv = usbi_get_device_handle_priv(dev_handle);
+    IOReturn                          kresult;
+
+    /* current interface */
+    struct darwin_interface *cInterface = &priv->interfaces[iface];
+
+    /* Check to see if an interface is open */
+    if(!cInterface->interface)
+        return LIBUSB_SUCCESS;
+
+    /* clean up endpoint data */
+    cInterface->num_endpoints = 0;
+
+    /* delete the interface's async event source */
+    if(cInterface->cfSource) {
+        CFRunLoopRemoveSource(libusb_darwin_acfl, cInterface->cfSource, kCFRunLoopDefaultMode);
+        CFRelease(cInterface->cfSource);
+        cInterface->cfSource = NULL;
+    }
+
+    kresult = (*(cInterface->interface))->USBInterfaceClose(cInterface->interface);
+    if(kresult != kIOReturnSuccess)
+        usbi_warn(HANDLE_CTX(dev_handle), "USBInterfaceClose: %s", darwin_error_str(kresult));
+
+    kresult = (*(cInterface->interface))->Release(cInterface->interface);
+    if(kresult != kIOReturnSuccess)
+        usbi_warn(HANDLE_CTX(dev_handle), "Release: %s", darwin_error_str(kresult));
+
+    cInterface->interface = (usb_interface_t **)IO_OBJECT_NULL;
+
+    return darwin_to_libusb(kresult);
+}
+
+static int check_alt_setting_and_clear_halt(struct libusb_device_handle *dev_handle, uint8_t altsetting, struct darwin_interface *cInterface) {
+    enum libusb_error ret;
+    IOReturn          kresult;
+    uint8_t           current_alt_setting;
+
+    kresult = (*(cInterface->interface))->GetAlternateSetting(cInterface->interface, &current_alt_setting);
+    if(kresult == kIOReturnSuccess && altsetting != current_alt_setting) {
+        return LIBUSB_ERROR_PIPE;
+    }
+
+    for(int i = 0; i < cInterface->num_endpoints; i++) {
+        ret = darwin_clear_halt(dev_handle, cInterface->endpoint_addrs[i]);
+        if(LIBUSB_SUCCESS != ret) {
+            usbi_warn(HANDLE_CTX(dev_handle), "error clearing pipe halt for endpoint %d", i);
+            if(LIBUSB_ERROR_NOT_FOUND == ret) {
+                /* may need to re-open the interface */
+                return ret;
+            }
+        }
+    }
+
+    return LIBUSB_SUCCESS;
+}
+
+static int darwin_set_interface_altsetting(struct libusb_device_handle *dev_handle, uint8_t iface, uint8_t altsetting) {
+    struct darwin_device_handle_priv *priv = usbi_get_device_handle_priv(dev_handle);
+    IOReturn                          kresult;
+    enum libusb_error                 ret;
+
+    /* current interface */
+    struct darwin_interface *cInterface = &priv->interfaces[iface];
+
+    if(!cInterface->interface)
+        return LIBUSB_ERROR_NO_DEVICE;
+
+    kresult = (*(cInterface->interface))->SetAlternateInterface(cInterface->interface, altsetting);
+    if(kresult == kIOReturnSuccess) {
+        /* update the list of endpoints */
+        ret = get_endpoints(dev_handle, iface);
+        if(ret) {
+            /* this should not happen */
+            darwin_release_interface(dev_handle, iface);
+            usbi_err(HANDLE_CTX(dev_handle), "could not build endpoint table");
+        }
+        return ret;
+    }
+
+    usbi_warn(HANDLE_CTX(dev_handle), "SetAlternateInterface: %s", darwin_error_str(kresult));
+
+    ret = darwin_to_libusb(kresult);
+    if(ret != LIBUSB_ERROR_PIPE) {
+        return ret;
+    }
+
+    /* If a device only supports a default setting for the specified interface, then a STALL
+       (kIOUSBPipeStalled) may be returned. Ref: USB 2.0 specs 9.4.10.
+       Mimic the behaviour in e.g. the Linux kernel: in such case, reset all endpoints
+       of the interface (as would have been done per 9.1.1.5) and return success. */
+
+    ret = check_alt_setting_and_clear_halt(dev_handle, altsetting, cInterface);
+    if(LIBUSB_ERROR_NOT_FOUND == ret) {
+        /* For some reason we need to reclaim the interface after the pipe error with some versions of macOS */
+        ret = darwin_claim_interface(dev_handle, iface);
+        if(LIBUSB_SUCCESS != ret) {
+            darwin_release_interface(dev_handle, iface);
+            usbi_err(HANDLE_CTX(dev_handle), "could not reclaim interface: %s", darwin_error_str(kresult));
+        }
+        ret = check_alt_setting_and_clear_halt(dev_handle, altsetting, cInterface);
+    }
+
+    return ret;
+}
+
+static int darwin_clear_halt(struct libusb_device_handle *dev_handle, unsigned char endpoint) {
+    /* current interface */
+    struct darwin_interface *cInterface;
+    IOReturn                 kresult;
+    uint8_t                  pipeRef;
+
+    /* determine the interface/endpoint to use */
+    if(ep_to_pipeRef(dev_handle, endpoint, &pipeRef, NULL, &cInterface) != 0) {
+        usbi_err(HANDLE_CTX(dev_handle), "endpoint not found on any open interface");
+
+        return LIBUSB_ERROR_NOT_FOUND;
+    }
+
+    /* newer versions of darwin support clearing additional bits on the device's endpoint */
+    kresult = (*(cInterface->interface))->ClearPipeStallBothEnds(cInterface->interface, pipeRef);
+    if(kresult != kIOReturnSuccess)
+        usbi_warn(HANDLE_CTX(dev_handle), "ClearPipeStall: %s", darwin_error_str(kresult));
+
+    return darwin_to_libusb(kresult);
+}
+
+static int darwin_restore_state(struct libusb_device_handle *dev_handle, int8_t active_config, unsigned long claimed_interfaces) {
+    struct darwin_cached_device      *dpriv      = DARWIN_CACHED_DEVICE(dev_handle->dev);
+    struct darwin_device_handle_priv *priv       = usbi_get_device_handle_priv(dev_handle);
+    int                               open_count = dpriv->open_count;
+    int                               ret;
+
+    struct libusb_context *ctx = HANDLE_CTX(dev_handle);
+
+    /* clear claimed interfaces temporarily */
+    dev_handle->claimed_interfaces = 0;
+
+    /* close and re-open the device */
+    priv->is_open     = false;
+    dpriv->open_count = 1;
+
+    /* clean up open interfaces */
+    (void)darwin_close(dev_handle);
+
+    /* re-open the device */
+    ret               = darwin_open(dev_handle);
+    dpriv->open_count = open_count;
+    if(LIBUSB_SUCCESS != ret) {
+        /* could not restore configuration */
+        return LIBUSB_ERROR_NOT_FOUND;
+    }
+
+    if(dpriv->active_config != active_config) {
+        usbi_dbg(ctx, "darwin/restore_state: restoring configuration %d...", active_config);
+
+        ret = darwin_set_configuration(dev_handle, active_config);
+        if(LIBUSB_SUCCESS != ret) {
+            usbi_dbg(ctx, "darwin/restore_state: could not restore configuration");
+            return LIBUSB_ERROR_NOT_FOUND;
+        }
+    }
+
+    usbi_dbg(ctx, "darwin/restore_state: reclaiming interfaces");
+
+    if(claimed_interfaces) {
+        for(uint8_t iface = 0; iface < USB_MAXINTERFACES; ++iface) {
+            if(!(claimed_interfaces & (1U << iface))) {
+                continue;
+            }
+
+            usbi_dbg(ctx, "darwin/restore_state: re-claiming interface %u", iface);
+
+            ret = darwin_claim_interface(dev_handle, iface);
+            if(LIBUSB_SUCCESS != ret) {
+                usbi_dbg(ctx, "darwin/restore_state: could not claim interface %u", iface);
+                return LIBUSB_ERROR_NOT_FOUND;
+            }
+
+            dev_handle->claimed_interfaces |= 1U << iface;
+        }
+    }
+
+    usbi_dbg(ctx, "darwin/restore_state: device state restored");
+
+    return LIBUSB_SUCCESS;
+}
+
+static int darwin_reenumerate_device(struct libusb_device_handle *dev_handle, bool capture) {
+    struct darwin_cached_device    *dpriv              = DARWIN_CACHED_DEVICE(dev_handle->dev);
+    unsigned long                   claimed_interfaces = dev_handle->claimed_interfaces;
+    int8_t                          active_config      = dpriv->active_config;
+    UInt32                          options            = 0;
+    IOUSBDeviceDescriptor           descriptor;
+    IOUSBConfigurationDescriptorPtr cached_configuration;
+    IOUSBConfigurationDescriptor   *cached_configurations;
+    IOReturn                        kresult;
+    UInt8                           i;
+
+    struct libusb_context *ctx = HANDLE_CTX(dev_handle);
+
+    if(dpriv->in_reenumerate) {
+        /* ack, two (or more) threads are trying to reset the device! abort! */
+        return LIBUSB_ERROR_NOT_FOUND;
+    }
+
+    dpriv->in_reenumerate = true;
+
+    /* store copies of descriptors so they can be compared after the reset */
+    memcpy(&descriptor, &dpriv->dev_descriptor, sizeof(descriptor));
+    cached_configurations = alloca(sizeof(*cached_configurations) * descriptor.bNumConfigurations);
+
+    for(i = 0; i < descriptor.bNumConfigurations; ++i) {
+        (*(dpriv->device))->GetConfigurationDescriptorPtr(dpriv->device, i, &cached_configuration);
+        memcpy(cached_configurations + i, cached_configuration, sizeof(cached_configurations[i]));
+    }
+
+    /* if we need to release capture */
+    if(HAS_CAPTURE_DEVICE()) {
+        if(capture) {
+#if MAC_OS_X_VERSION_MAX_ALLOWED >= 101000
+            options |= kUSBReEnumerateCaptureDeviceMask;
+#endif
+        }
+    }
+    else {
+        capture = false;
+    }
+
+    /* from macOS 10.11 ResetDevice no longer does anything so just use USBDeviceReEnumerate */
+    kresult = (*(dpriv->device))->USBDeviceReEnumerate(dpriv->device, options);
+    if(kresult != kIOReturnSuccess) {
+        usbi_err(ctx, "USBDeviceReEnumerate: %s", darwin_error_str(kresult));
+        dpriv->in_reenumerate = false;
+        return darwin_to_libusb(kresult);
+    }
+
+    /* capture mode does not re-enumerate but it does require re-open */
+    if(capture) {
+        usbi_dbg(ctx, "darwin/reenumerate_device: restoring state...");
+        dpriv->in_reenumerate = false;
+        return darwin_restore_state(dev_handle, active_config, claimed_interfaces);
+    }
+
+    usbi_dbg(ctx, "darwin/reenumerate_device: waiting for re-enumeration to complete...");
+
+    struct timespec start;
+    usbi_get_monotonic_time(&start);
+
+    while(dpriv->in_reenumerate) {
+        struct timespec delay = { .tv_sec = 0, .tv_nsec = 1000 };
+        nanosleep(&delay, NULL);
+
+        struct timespec now;
+        usbi_get_monotonic_time(&now);
+        unsigned long elapsed_us = (now.tv_sec - start.tv_sec) * USEC_PER_SEC + (now.tv_nsec - start.tv_nsec) / 1000;
+
+        if(elapsed_us >= DARWIN_REENUMERATE_TIMEOUT_US) {
+            usbi_err(ctx, "darwin/reenumerate_device: timeout waiting for reenumerate");
+            dpriv->in_reenumerate = false;
+            return LIBUSB_ERROR_TIMEOUT;
+        }
+    }
+
+    /* compare descriptors */
+    usbi_dbg(ctx, "darwin/reenumerate_device: checking whether descriptors changed");
+
+    if(memcmp(&descriptor, &dpriv->dev_descriptor, sizeof(descriptor))) {
+        /* device descriptor changed. need to return not found. */
+        usbi_dbg(ctx, "darwin/reenumerate_device: device descriptor changed");
+        return LIBUSB_ERROR_NOT_FOUND;
+    }
+
+    for(i = 0; i < descriptor.bNumConfigurations; ++i) {
+        (void)(*(dpriv->device))->GetConfigurationDescriptorPtr(dpriv->device, i, &cached_configuration);
+        if(memcmp(cached_configuration, cached_configurations + i, sizeof(cached_configurations[i]))) {
+            usbi_dbg(ctx, "darwin/reenumerate_device: configuration descriptor %d changed", i);
+            return LIBUSB_ERROR_NOT_FOUND;
+        }
+    }
+
+    usbi_dbg(ctx, "darwin/reenumerate_device: device reset complete. restoring state...");
+
+    return darwin_restore_state(dev_handle, active_config, claimed_interfaces);
+}
+
+static int darwin_reset_device(struct libusb_device_handle *dev_handle) {
+    struct darwin_cached_device *dpriv = DARWIN_CACHED_DEVICE(dev_handle->dev);
+    IOReturn                     kresult;
+    enum libusb_error            ret;
+
+#if !defined(TARGET_OS_OSX) || TARGET_OS_OSX == 1
+    if(dpriv->capture_count > 0) {
+        /* we have to use ResetDevice as USBDeviceReEnumerate() loses the authorization for capture */
+        kresult = (*(dpriv->device))->ResetDevice(dpriv->device);
+        ret     = darwin_to_libusb(kresult);
+    }
+    else {
+        ret = darwin_reenumerate_device(dev_handle, false);
+    }
+#else
+    /* ResetDevice() is missing on non-macOS platforms */
+    ret = darwin_reenumerate_device(dev_handle, false);
+    if((ret == LIBUSB_SUCCESS || ret == LIBUSB_ERROR_NOT_FOUND) && dpriv->capture_count > 0) {
+        int           capture_count;
+        int8_t        active_config      = dpriv->active_config;
+        unsigned long claimed_interfaces = dev_handle->claimed_interfaces;
+
+        /* save old capture_count */
+        capture_count = dpriv->capture_count;
+        /* reset capture count */
+        dpriv->capture_count = 0;
+        /* attempt to detach kernel driver again as it is now re-attached */
+        ret = darwin_detach_kernel_driver(dev_handle, 0);
+        if(ret != LIBUSB_SUCCESS) {
+            return ret;
+        }
+        /* restore capture_count */
+        dpriv->capture_count = capture_count;
+        /* restore configuration */
+        ret = darwin_restore_state(dev_handle, active_config, claimed_interfaces);
+    }
+#endif
+    return ret;
+}
+
+static io_service_t usb_find_interface_matching_location(const io_name_t class_name, UInt8 interface_number, UInt32 location) {
+    CFMutableDictionaryRef matchingDict = IOServiceMatching(class_name);
+    CFMutableDictionaryRef propertyMatchDict =
+        CFDictionaryCreateMutable(kCFAllocatorDefault, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
+    CFTypeRef locationCF  = CFNumberCreate(NULL, kCFNumberSInt32Type, &location);
+    CFTypeRef interfaceCF = CFNumberCreate(NULL, kCFNumberSInt8Type, &interface_number);
+
+    CFDictionarySetValue(matchingDict, CFSTR(kIOPropertyMatchKey), propertyMatchDict);
+    CFDictionarySetValue(propertyMatchDict, CFSTR(kUSBDevicePropertyLocationID), locationCF);
+    CFDictionarySetValue(propertyMatchDict, CFSTR(kUSBHostMatchingPropertyInterfaceNumber), interfaceCF);
+
+    CFRelease(interfaceCF);
+    CFRelease(locationCF);
+    CFRelease(propertyMatchDict);
+
+    return IOServiceGetMatchingService(darwin_default_master_port, matchingDict);
+}
+
+static int darwin_kernel_driver_active(struct libusb_device_handle *dev_handle, uint8_t interface) {
+    struct darwin_cached_device *dpriv = DARWIN_CACHED_DEVICE(dev_handle->dev);
+    io_service_t                 usb_interface, child = IO_OBJECT_NULL;
+
+    /* locate the IO registry entry for this interface */
+    usb_interface = usb_find_interface_matching_location(kIOUSBHostInterfaceClassName, interface, dpriv->location);
+    if(0 == usb_interface) {
+        /* check for the legacy class entry */
+        usb_interface = usb_find_interface_matching_location(kIOUSBInterfaceClassName, interface, dpriv->location);
+        if(0 == usb_interface) {
+            return LIBUSB_ERROR_NOT_FOUND;
+        }
+    }
+
+    /* if the IO object has a child entry in the IO Registry it has a kernel driver attached */
+    (void)IORegistryEntryGetChildEntry(usb_interface, kIOServicePlane, &child);
+    IOObjectRelease(usb_interface);
+    if(IO_OBJECT_NULL != child) {
+        IOObjectRelease(child);
+        return 1;
+    }
+
+    /* no driver */
+    return 0;
+}
+
+static void darwin_destroy_device(struct libusb_device *dev) {
+    struct darwin_device_priv *dpriv = usbi_get_device_priv(dev);
+
+    if(dpriv->dev) {
+        /* need to hold the lock in case this is the last reference to the device */
+        usbi_mutex_lock(&darwin_cached_devices_mutex);
+        darwin_deref_cached_device(dpriv->dev);
+        dpriv->dev = NULL;
+        usbi_mutex_unlock(&darwin_cached_devices_mutex);
+    }
+}
+
+static int submit_bulk_transfer(struct usbi_transfer *itransfer) {
+    struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+
+    IOReturn ret;
+    uint8_t  transferType;
+    uint8_t  pipeRef;
+    uint16_t maxPacketSize;
+
+    struct darwin_interface *cInterface;
+#if InterfaceVersion >= 550
+    IOUSBEndpointProperties pipeProperties = { .bVersion = kUSBEndpointPropertiesVersion3 };
+#else
+    /* None of the values below are used in libusb for bulk transfers */
+    uint8_t direction, number, interval;
+#endif
+
+    if(ep_to_pipeRef(transfer->dev_handle, transfer->endpoint, &pipeRef, NULL, &cInterface) != 0) {
+        usbi_err(TRANSFER_CTX(transfer), "endpoint not found on any open interface");
+
+        return LIBUSB_ERROR_NOT_FOUND;
+    }
+
+#if InterfaceVersion >= 550
+    ret = (*(cInterface->interface))->GetPipePropertiesV3(cInterface->interface, pipeRef, &pipeProperties);
+
+    transferType  = pipeProperties.bTransferType;
+    maxPacketSize = pipeProperties.wMaxPacketSize;
+#else
+    ret = (*(cInterface->interface))->GetPipeProperties(cInterface->interface, pipeRef, &direction, &number, &transferType, &maxPacketSize, &interval);
+#endif
+
+    if(ret) {
+        usbi_err(TRANSFER_CTX(transfer), "bulk transfer failed (dir = %s): %s (code = 0x%08x)", IS_XFERIN(transfer) ? "In" : "Out", darwin_error_str(ret), ret);
+        return darwin_to_libusb(ret);
+    }
+
+    if(0 != (transfer->length % maxPacketSize)) {
+        /* do not need a zero packet */
+        transfer->flags &= ~LIBUSB_TRANSFER_ADD_ZERO_PACKET;
+    }
+
+    /* submit the request */
+    /* timeouts are unavailable on interrupt endpoints */
+    if(transferType == kUSBInterrupt) {
+        if(IS_XFERIN(transfer))
+            ret = (*(cInterface->interface))
+                      ->ReadPipeAsync(cInterface->interface, pipeRef, transfer->buffer, (UInt32)transfer->length, darwin_async_io_callback, itransfer);
+        else
+            ret = (*(cInterface->interface))
+                      ->WritePipeAsync(cInterface->interface, pipeRef, transfer->buffer, (UInt32)transfer->length, darwin_async_io_callback, itransfer);
+    }
+    else {
+        itransfer->timeout_flags |= USBI_TRANSFER_OS_HANDLES_TIMEOUT;
+
+        if(IS_XFERIN(transfer))
+            ret = (*(cInterface->interface))
+                      ->ReadPipeAsyncTO(cInterface->interface, pipeRef, transfer->buffer, (UInt32)transfer->length, transfer->timeout, transfer->timeout,
+                                        darwin_async_io_callback, itransfer);
+        else
+            ret = (*(cInterface->interface))
+                      ->WritePipeAsyncTO(cInterface->interface, pipeRef, transfer->buffer, (UInt32)transfer->length, transfer->timeout, transfer->timeout,
+                                         darwin_async_io_callback, itransfer);
+    }
+
+    if(ret)
+        usbi_err(TRANSFER_CTX(transfer), "bulk transfer failed (dir = %s): %s (code = 0x%08x)", IS_XFERIN(transfer) ? "In" : "Out", darwin_error_str(ret), ret);
+
+    return darwin_to_libusb(ret);
+}
+
+#if InterfaceVersion >= 550
+static int submit_stream_transfer(struct usbi_transfer *itransfer) {
+    struct libusb_transfer  *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+    struct darwin_interface *cInterface;
+    uint8_t                  pipeRef;
+    IOReturn                 ret;
+
+    if(ep_to_pipeRef(transfer->dev_handle, transfer->endpoint, &pipeRef, NULL, &cInterface) != 0) {
+        usbi_err(TRANSFER_CTX(transfer), "endpoint not found on any open interface");
+
+        return LIBUSB_ERROR_NOT_FOUND;
+    }
+
+    itransfer->timeout_flags |= USBI_TRANSFER_OS_HANDLES_TIMEOUT;
+
+    if(IS_XFERIN(transfer))
+        ret = (*(cInterface->interface))
+                  ->ReadStreamsPipeAsyncTO(cInterface->interface, pipeRef, itransfer->stream_id, transfer->buffer, (UInt32)transfer->length, transfer->timeout,
+                                           transfer->timeout, darwin_async_io_callback, itransfer);
+    else
+        ret = (*(cInterface->interface))
+                  ->WriteStreamsPipeAsyncTO(cInterface->interface, pipeRef, itransfer->stream_id, transfer->buffer, (UInt32)transfer->length, transfer->timeout,
+                                            transfer->timeout, darwin_async_io_callback, itransfer);
+
+    if(ret)
+        usbi_err(TRANSFER_CTX(transfer), "bulk stream transfer failed (dir = %s): %s (code = 0x%08x)", IS_XFERIN(transfer) ? "In" : "Out",
+                 darwin_error_str(ret), ret);
+
+    return darwin_to_libusb(ret);
+}
+#endif
+
+static int submit_iso_transfer(struct usbi_transfer *itransfer) {
+    struct libusb_transfer      *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+    struct darwin_transfer_priv *tpriv    = usbi_get_transfer_priv(itransfer);
+
+    IOReturn     kresult;
+    uint8_t      pipeRef, interval;
+    UInt64       frame;
+    AbsoluteTime atTime;
+    int          i;
+#if InterfaceVersion >= 550
+    IOUSBEndpointProperties pipeProperties = { .bVersion = kUSBEndpointPropertiesVersion3 };
+#else
+    /* None of the values below are used in libusb for iso transfers */
+    uint8_t  direction, number, transferType;
+    uint16_t maxPacketSize;
+#endif
+
+    struct darwin_interface *cInterface;
+
+    /* construct an array of IOUSBIsocFrames, reuse the old one if the sizes are the same */
+    if(tpriv->num_iso_packets != transfer->num_iso_packets) {
+        free(tpriv->isoc_framelist);
+        tpriv->isoc_framelist = NULL;
+    }
+
+    if(!tpriv->isoc_framelist) {
+        tpriv->num_iso_packets = transfer->num_iso_packets;
+        tpriv->isoc_framelist  = (IOUSBIsocFrame *)calloc((size_t)transfer->num_iso_packets, sizeof(IOUSBIsocFrame));
+        if(!tpriv->isoc_framelist)
+            return LIBUSB_ERROR_NO_MEM;
+    }
+
+    /* copy the frame list from the libusb descriptor (the structures differ only is member order) */
+    for(i = 0; i < transfer->num_iso_packets; i++) {
+        unsigned int length = transfer->iso_packet_desc[i].length;
+        assert(length <= UINT16_MAX);
+        tpriv->isoc_framelist[i].frReqCount = (UInt16)length;
+    }
+
+    /* determine the interface/endpoint to use */
+    if(ep_to_pipeRef(transfer->dev_handle, transfer->endpoint, &pipeRef, NULL, &cInterface) != 0) {
+        usbi_err(TRANSFER_CTX(transfer), "endpoint not found on any open interface");
+
+        return LIBUSB_ERROR_NOT_FOUND;
+    }
+
+    /* determine the properties of this endpoint and the speed of the device */
+#if InterfaceVersion >= 550
+    kresult  = (*(cInterface->interface))->GetPipePropertiesV3(cInterface->interface, pipeRef, &pipeProperties);
+    interval = pipeProperties.bInterval;
+#else
+    kresult = (*(cInterface->interface))->GetPipeProperties(cInterface->interface, pipeRef, &direction, &number, &transferType, &maxPacketSize, &interval);
+#endif
+    if(kresult != kIOReturnSuccess) {
+        usbi_err(TRANSFER_CTX(transfer), "failed to get pipe properties: %d", kresult);
+        free(tpriv->isoc_framelist);
+        tpriv->isoc_framelist = NULL;
+
+        return darwin_to_libusb(kresult);
+    }
+
+    /* Last but not least we need the bus frame number */
+    kresult = (*(cInterface->interface))->GetBusFrameNumber(cInterface->interface, &frame, &atTime);
+    if(kresult != kIOReturnSuccess) {
+        usbi_err(TRANSFER_CTX(transfer), "failed to get bus frame number: %d", kresult);
+        free(tpriv->isoc_framelist);
+        tpriv->isoc_framelist = NULL;
+
+        return darwin_to_libusb(kresult);
+    }
+
+    /* schedule for a frame a little in the future */
+    frame += 4;
+
+    if(cInterface->frames[transfer->endpoint] && frame < cInterface->frames[transfer->endpoint])
+        frame = cInterface->frames[transfer->endpoint];
+
+    /* submit the request */
+    if(IS_XFERIN(transfer))
+        kresult = (*(cInterface->interface))
+                      ->ReadIsochPipeAsync(cInterface->interface, pipeRef, transfer->buffer, frame, (UInt32)transfer->num_iso_packets, tpriv->isoc_framelist,
+                                           darwin_async_io_callback, itransfer);
+    else
+        kresult = (*(cInterface->interface))
+                      ->WriteIsochPipeAsync(cInterface->interface, pipeRef, transfer->buffer, frame, (UInt32)transfer->num_iso_packets, tpriv->isoc_framelist,
+                                            darwin_async_io_callback, itransfer);
+
+    if(LIBUSB_SPEED_FULL == transfer->dev_handle->dev->speed)
+        /* Full speed */
+        cInterface->frames[transfer->endpoint] = frame + (UInt32)transfer->num_iso_packets * (1U << (interval - 1));
+    else
+        /* High/super speed */
+        cInterface->frames[transfer->endpoint] = frame + (UInt32)transfer->num_iso_packets * (1U << (interval - 1)) / 8;
+
+    if(kresult != kIOReturnSuccess) {
+        usbi_err(TRANSFER_CTX(transfer), "isochronous transfer failed (dir: %s): %s", IS_XFERIN(transfer) ? "In" : "Out", darwin_error_str(kresult));
+        free(tpriv->isoc_framelist);
+        tpriv->isoc_framelist = NULL;
+    }
+
+    return darwin_to_libusb(kresult);
+}
+
+static int submit_control_transfer(struct usbi_transfer *itransfer) {
+    struct libusb_transfer      *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+    struct libusb_control_setup *setup    = (struct libusb_control_setup *)transfer->buffer;
+    struct darwin_cached_device *dpriv    = DARWIN_CACHED_DEVICE(transfer->dev_handle->dev);
+    struct darwin_transfer_priv *tpriv    = usbi_get_transfer_priv(itransfer);
+
+    IOReturn kresult;
+
+    memset(&tpriv->req, 0, sizeof(tpriv->req));
+
+    /* IOUSBDeviceInterface expects the request in cpu endianness */
+    tpriv->req.bmRequestType = setup->bmRequestType;
+    tpriv->req.bRequest      = setup->bRequest;
+    /* these values should be in bus order from libusb_fill_control_setup */
+    tpriv->req.wValue  = OSSwapLittleToHostInt16(setup->wValue);
+    tpriv->req.wIndex  = OSSwapLittleToHostInt16(setup->wIndex);
+    tpriv->req.wLength = OSSwapLittleToHostInt16(setup->wLength);
+    /* data is stored after the libusb control block */
+    tpriv->req.pData             = transfer->buffer + LIBUSB_CONTROL_SETUP_SIZE;
+    tpriv->req.completionTimeout = transfer->timeout;
+    tpriv->req.noDataTimeout     = transfer->timeout;
+
+    itransfer->timeout_flags |= USBI_TRANSFER_OS_HANDLES_TIMEOUT;
+
+    /* all transfers in libusb-1.0 are async */
+
+    if(transfer->endpoint) {
+        struct darwin_interface *cInterface;
+        uint8_t                  pipeRef;
+
+        if(ep_to_pipeRef(transfer->dev_handle, transfer->endpoint, &pipeRef, NULL, &cInterface) != 0) {
+            usbi_err(TRANSFER_CTX(transfer), "endpoint not found on any open interface");
+
+            return LIBUSB_ERROR_NOT_FOUND;
+        }
+
+        kresult = (*(cInterface->interface))->ControlRequestAsyncTO(cInterface->interface, pipeRef, &(tpriv->req), darwin_async_io_callback, itransfer);
+    }
+    else
+        /* control request on endpoint 0 */
+        kresult = (*(dpriv->device))->DeviceRequestAsyncTO(dpriv->device, &(tpriv->req), darwin_async_io_callback, itransfer);
+
+    if(kresult != kIOReturnSuccess)
+        usbi_err(TRANSFER_CTX(transfer), "control request failed: %s", darwin_error_str(kresult));
+
+    return darwin_to_libusb(kresult);
+}
+
+static int darwin_submit_transfer(struct usbi_transfer *itransfer) {
+    struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+
+    switch(transfer->type) {
+    case LIBUSB_TRANSFER_TYPE_CONTROL:
+        return submit_control_transfer(itransfer);
+    case LIBUSB_TRANSFER_TYPE_BULK:
+    case LIBUSB_TRANSFER_TYPE_INTERRUPT:
+        return submit_bulk_transfer(itransfer);
+    case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
+        return submit_iso_transfer(itransfer);
+    case LIBUSB_TRANSFER_TYPE_BULK_STREAM:
+#if InterfaceVersion >= 550
+        return submit_stream_transfer(itransfer);
+#else
+        usbi_err(TRANSFER_CTX(transfer), "IOUSBFamily version does not support bulk stream transfers");
+        return LIBUSB_ERROR_NOT_SUPPORTED;
+#endif
+    default:
+        usbi_err(TRANSFER_CTX(transfer), "unknown endpoint type %d", transfer->type);
+        return LIBUSB_ERROR_INVALID_PARAM;
+    }
+}
+
+static int cancel_control_transfer(struct usbi_transfer *itransfer) {
+    struct libusb_transfer      *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+    struct darwin_cached_device *dpriv    = DARWIN_CACHED_DEVICE(transfer->dev_handle->dev);
+    IOReturn                     kresult;
+
+    usbi_warn(ITRANSFER_CTX(itransfer), "aborting all transactions control pipe");
+
+    if(!dpriv->device)
+        return LIBUSB_ERROR_NO_DEVICE;
+
+    kresult = (*(dpriv->device))->USBDeviceAbortPipeZero(dpriv->device);
+
+    return darwin_to_libusb(kresult);
+}
+
+static int darwin_abort_transfers(struct usbi_transfer *itransfer) {
+    struct libusb_transfer      *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+    struct darwin_cached_device *dpriv    = DARWIN_CACHED_DEVICE(transfer->dev_handle->dev);
+    struct darwin_interface     *cInterface;
+    uint8_t                      pipeRef, iface;
+    IOReturn                     kresult;
+
+    struct libusb_context *ctx = ITRANSFER_CTX(itransfer);
+
+    if(ep_to_pipeRef(transfer->dev_handle, transfer->endpoint, &pipeRef, &iface, &cInterface) != 0) {
+        usbi_err(ctx, "endpoint not found on any open interface");
+
+        return LIBUSB_ERROR_NOT_FOUND;
+    }
+
+    if(!dpriv->device)
+        return LIBUSB_ERROR_NO_DEVICE;
+
+    usbi_warn(ctx, "aborting all transactions on interface %d pipe %d", iface, pipeRef);
+
+    /* abort transactions */
+#if InterfaceVersion >= 550
+    if(LIBUSB_TRANSFER_TYPE_BULK_STREAM == transfer->type)
+        kresult = (*(cInterface->interface))->AbortStreamsPipe(cInterface->interface, pipeRef, itransfer->stream_id);
+    else
+#endif
+        kresult = (*(cInterface->interface))->AbortPipe(cInterface->interface, pipeRef);
+
+#if InterfaceVersion <= 245
+    /* with older releases of IOUSBFamily the OS always clears the host side data toggle. for
+       consistency also clear the data toggle on the device. */
+    usbi_dbg(ctx, "calling ClearPipeStallBothEnds to clear the data toggle bit");
+    kresult = (*(cInterface->interface))->ClearPipeStallBothEnds(cInterface->interface, pipeRef);
+#endif
+
+    return darwin_to_libusb(kresult);
+}
+
+static int darwin_cancel_transfer(struct usbi_transfer *itransfer) {
+    struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+
+    switch(transfer->type) {
+    case LIBUSB_TRANSFER_TYPE_CONTROL:
+        return cancel_control_transfer(itransfer);
+    case LIBUSB_TRANSFER_TYPE_BULK:
+    case LIBUSB_TRANSFER_TYPE_INTERRUPT:
+    case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
+        return darwin_abort_transfers(itransfer);
+    default:
+        usbi_err(TRANSFER_CTX(transfer), "unknown endpoint type %d", transfer->type);
+        return LIBUSB_ERROR_INVALID_PARAM;
+    }
+}
+
+static void darwin_async_io_callback(void *refcon, IOReturn result, void *arg0) {
+    struct usbi_transfer        *itransfer = (struct usbi_transfer *)refcon;
+    struct libusb_transfer      *transfer  = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+    struct darwin_transfer_priv *tpriv     = usbi_get_transfer_priv(itransfer);
+
+    usbi_dbg(TRANSFER_CTX(transfer), "an async io operation has completed");
+
+    /* if requested write a zero packet */
+    if(kIOReturnSuccess == result && IS_XFEROUT(transfer) && transfer->flags & LIBUSB_TRANSFER_ADD_ZERO_PACKET) {
+        struct darwin_interface *cInterface;
+        uint8_t                  pipeRef;
+
+        (void)ep_to_pipeRef(transfer->dev_handle, transfer->endpoint, &pipeRef, NULL, &cInterface);
+
+        (*(cInterface->interface))->WritePipe(cInterface->interface, pipeRef, transfer->buffer, 0);
+    }
+
+    tpriv->result = result;
+    tpriv->size   = (UInt32)(uintptr_t)arg0;
+
+    /* signal the core that this transfer is complete */
+    usbi_signal_transfer_completion(itransfer);
+}
+
+static enum libusb_transfer_status darwin_transfer_status(struct usbi_transfer *itransfer, IOReturn result) {
+    if(itransfer->timeout_flags & USBI_TRANSFER_TIMED_OUT)
+        result = kIOUSBTransactionTimeout;
+
+    struct libusb_context *ctx = ITRANSFER_CTX(itransfer);
+
+    switch(result) {
+    case kIOReturnUnderrun:
+    case kIOReturnSuccess:
+        return LIBUSB_TRANSFER_COMPLETED;
+    case kIOReturnAborted:
+        return LIBUSB_TRANSFER_CANCELLED;
+    case kIOUSBPipeStalled:
+        usbi_dbg(ctx, "transfer error: pipe is stalled");
+        return LIBUSB_TRANSFER_STALL;
+    case kIOReturnOverrun:
+        usbi_warn(ctx, "transfer error: data overrun");
+        return LIBUSB_TRANSFER_OVERFLOW;
+    case kIOUSBTransactionTimeout:
+        usbi_warn(ctx, "transfer error: timed out");
+        itransfer->timeout_flags |= USBI_TRANSFER_TIMED_OUT;
+        return LIBUSB_TRANSFER_TIMED_OUT;
+    default:
+        usbi_warn(ctx, "transfer error: %s (value = 0x%08x)", darwin_error_str(result), result);
+        return LIBUSB_TRANSFER_ERROR;
+    }
+}
+
+static int darwin_handle_transfer_completion(struct usbi_transfer *itransfer) {
+    struct libusb_transfer      *transfer          = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+    struct darwin_transfer_priv *tpriv             = usbi_get_transfer_priv(itransfer);
+    const unsigned char          max_transfer_type = LIBUSB_TRANSFER_TYPE_BULK_STREAM;
+    const char                  *transfer_types[]  = { "control", "isoc", "bulk", "interrupt", "bulk-stream", NULL };
+    bool                         is_isoc           = LIBUSB_TRANSFER_TYPE_ISOCHRONOUS == transfer->type;
+    struct libusb_context       *ctx               = ITRANSFER_CTX(itransfer);
+
+    if(transfer->type > max_transfer_type) {
+        usbi_err(ctx, "unknown endpoint type %d", transfer->type);
+        return LIBUSB_ERROR_INVALID_PARAM;
+    }
+
+    if(NULL == tpriv) {
+        usbi_err(ctx, "malformed request is missing transfer priv");
+        return LIBUSB_ERROR_INVALID_PARAM;
+    }
+
+    usbi_dbg(ctx, "handling transfer completion type %s with kernel status %d", transfer_types[transfer->type], tpriv->result);
+
+    if(kIOReturnSuccess == tpriv->result || kIOReturnUnderrun == tpriv->result || kIOUSBTransactionTimeout == tpriv->result) {
+        if(is_isoc && tpriv->isoc_framelist) {
+            /* copy isochronous results back */
+
+            for(int i = 0; i < transfer->num_iso_packets; i++) {
+                struct libusb_iso_packet_descriptor *lib_desc = &transfer->iso_packet_desc[i];
+                lib_desc->status                              = darwin_transfer_status(itransfer, tpriv->isoc_framelist[i].frStatus);
+                lib_desc->actual_length                       = tpriv->isoc_framelist[i].frActCount;
+            }
+        }
+        else if(!is_isoc) {
+            itransfer->transferred += tpriv->size;
+        }
+    }
+
+    /* it is ok to handle cancelled transfers without calling usbi_handle_transfer_cancellation (we catch timeout transfers) */
+    return usbi_handle_transfer_completion(itransfer, darwin_transfer_status(itransfer, tpriv->result));
+}
+
+void usbi_get_monotonic_time(struct timespec *tp) {
+/* Check if the SDK is new enough to declare clock_gettime(), and the deployment target is at least 10.12. */
+#if((MAC_OS_X_VERSION_MAX_ALLOWED >= 101200) && (MAC_OS_X_VERSION_MIN_REQUIRED >= 101200))
+    clock_gettime(CLOCK_MONOTONIC, tp);
+#else
+    mach_timebase_info_data_t machTimeBaseInfo;
+    mach_timebase_info(&machTimeBaseInfo);
+
+    uint64_t uptime     = mach_absolute_time();
+    uint64_t uptimeNano = uptime * machTimeBaseInfo.numer / machTimeBaseInfo.denom;
+
+    uint64_t uptimeSeconds       = uptimeNano / NSEC_PER_SEC;
+    uint64_t uptimeNanoRemainder = uptimeNano - (uptimeSeconds * NSEC_PER_SEC);
+
+    tp->tv_sec  = uptimeSeconds;
+    tp->tv_nsec = uptimeNanoRemainder;
+#endif
+}
+
+void usbi_get_real_time(struct timespec *tp) {
+/* Check if the SDK is new enough to declare clock_gettime(), and the deployment target is at least 10.12. */
+#if((MAC_OS_X_VERSION_MAX_ALLOWED >= 101200) && (MAC_OS_X_VERSION_MIN_REQUIRED >= 101200))
+    clock_gettime(CLOCK_REALTIME, tp);
+#else
+    struct timeval tv;
+    gettimeofday(&tv, NULL);
+    tp->tv_sec  = tv.tv_sec;
+    tp->tv_nsec = tv.tv_usec * NSEC_PER_USEC;
+#endif
+}
+
+#if InterfaceVersion >= 550
+static int darwin_alloc_streams(struct libusb_device_handle *dev_handle, uint32_t num_streams, unsigned char *endpoints, int num_endpoints) {
+    struct darwin_interface *cInterface;
+    UInt32                   supportsStreams;
+    uint8_t                  pipeRef;
+    int                      rc, i;
+
+    /* find the minimum number of supported streams on the endpoint list */
+    for(i = 0; i < num_endpoints; ++i) {
+        if(0 != (rc = ep_to_pipeRef(dev_handle, endpoints[i], &pipeRef, NULL, &cInterface))) {
+            return rc;
+        }
+
+        (*(cInterface->interface))->SupportsStreams(cInterface->interface, pipeRef, &supportsStreams);
+        if(num_streams > supportsStreams)
+            num_streams = supportsStreams;
+    }
+
+    /* it is an error if any endpoint in endpoints does not support streams */
+    if(0 == num_streams)
+        return LIBUSB_ERROR_INVALID_PARAM;
+
+    /* create the streams */
+    for(i = 0; i < num_endpoints; ++i) {
+        (void)ep_to_pipeRef(dev_handle, endpoints[i], &pipeRef, NULL, &cInterface);
+
+        rc = (*(cInterface->interface))->CreateStreams(cInterface->interface, pipeRef, num_streams);
+        if(kIOReturnSuccess != rc)
+            return darwin_to_libusb(rc);
+    }
+
+    assert(num_streams <= INT_MAX);
+    return (int)num_streams;
+}
+
+static int darwin_free_streams(struct libusb_device_handle *dev_handle, unsigned char *endpoints, int num_endpoints) {
+    struct darwin_interface *cInterface;
+    UInt32                   supportsStreams;
+    uint8_t                  pipeRef;
+    int                      rc;
+
+    for(int i = 0; i < num_endpoints; ++i) {
+        if(0 != (rc = ep_to_pipeRef(dev_handle, endpoints[i], &pipeRef, NULL, &cInterface)))
+            return rc;
+
+        (*(cInterface->interface))->SupportsStreams(cInterface->interface, pipeRef, &supportsStreams);
+        if(0 == supportsStreams)
+            return LIBUSB_ERROR_INVALID_PARAM;
+
+        rc = (*(cInterface->interface))->CreateStreams(cInterface->interface, pipeRef, 0);
+        if(kIOReturnSuccess != rc)
+            return darwin_to_libusb(rc);
+    }
+
+    return LIBUSB_SUCCESS;
+}
+#endif
+
+#if InterfaceVersion >= 700
+
+/* macOS APIs for getting entitlement values */
+
+#if !defined(TARGET_OS_OSX) || TARGET_OS_OSX == 1
+#include <Security/Security.h>
+#else
+typedef struct __SecTask *SecTaskRef;
+extern SecTaskRef         SecTaskCreateFromSelf(CFAllocatorRef allocator);
+extern CFTypeRef          SecTaskCopyValueForEntitlement(SecTaskRef task, CFStringRef entitlement, CFErrorRef *error);
+#endif
+
+static bool darwin_has_capture_entitlements(void) {
+    SecTaskRef task;
+    CFTypeRef  value;
+    bool       entitled;
+
+    task = SecTaskCreateFromSelf(kCFAllocatorDefault);
+    if(task == NULL) {
+        return false;
+    }
+    value = SecTaskCopyValueForEntitlement(task, CFSTR("com.apple.vm.device-access"), NULL);
+    CFRelease(task);
+    entitled = value && (CFGetTypeID(value) == CFBooleanGetTypeID()) && CFBooleanGetValue(value);
+    if(value) {
+        CFRelease(value);
+    }
+    return entitled;
+}
+
+static int darwin_reload_device(struct libusb_device_handle *dev_handle) {
+    struct darwin_cached_device *dpriv = DARWIN_CACHED_DEVICE(dev_handle->dev);
+    enum libusb_error            err;
+
+    usbi_mutex_lock(&darwin_cached_devices_mutex);
+    (*(dpriv->device))->Release(dpriv->device);
+    dpriv->device = darwin_device_from_service(HANDLE_CTX(dev_handle), dpriv->service);
+    if(!dpriv->device) {
+        err = LIBUSB_ERROR_NO_DEVICE;
+    }
+    else {
+        err = LIBUSB_SUCCESS;
+    }
+    usbi_mutex_unlock(&darwin_cached_devices_mutex);
+
+    return err;
+}
+
+/* On macOS, we capture an entire device at once, not individual interfaces. */
+
+static int darwin_detach_kernel_driver(struct libusb_device_handle *dev_handle, uint8_t interface) {
+    UNUSED(interface);
+    struct darwin_cached_device *dpriv = DARWIN_CACHED_DEVICE(dev_handle->dev);
+    IOReturn                     kresult;
+    enum libusb_error            err;
+    struct libusb_context       *ctx = HANDLE_CTX(dev_handle);
+
+    if(HAS_CAPTURE_DEVICE()) {
+    }
+    else {
+        return LIBUSB_ERROR_NOT_SUPPORTED;
+    }
+
+    if(dpriv->capture_count == 0) {
+        usbi_dbg(ctx, "attempting to detach kernel driver from device");
+
+        if(darwin_has_capture_entitlements()) {
+            /* request authorization */
+            kresult = IOServiceAuthorize(dpriv->service, kIOServiceInteractionAllowed);
+            if(kresult != kIOReturnSuccess) {
+                usbi_warn(ctx, "IOServiceAuthorize: %s", darwin_error_str(kresult));
+                return darwin_to_libusb(kresult);
+            }
+
+            /* we need start() to be called again for authorization status to refresh */
+            err = darwin_reload_device(dev_handle);
+            if(err != LIBUSB_SUCCESS) {
+                return err;
+            }
+        }
+        else {
+            usbi_info(ctx, "no capture entitlements. may not be able to detach the kernel driver for this device");
+            if(0 != geteuid()) {
+                usbi_warn(ctx, "USB device capture requires either an entitlement (com.apple.vm.device-access) or root privilege");
+                return LIBUSB_ERROR_ACCESS;
+            }
+        }
+
+        /* reset device to release existing drivers */
+        err = darwin_reenumerate_device(dev_handle, true);
+        if(err != LIBUSB_SUCCESS) {
+            return err;
+        }
+    }
+    dpriv->capture_count++;
+    return LIBUSB_SUCCESS;
+}
+
+static int darwin_attach_kernel_driver(struct libusb_device_handle *dev_handle, uint8_t interface) {
+    UNUSED(interface);
+    struct darwin_cached_device *dpriv = DARWIN_CACHED_DEVICE(dev_handle->dev);
+
+    if(HAS_CAPTURE_DEVICE()) {
+    }
+    else {
+        return LIBUSB_ERROR_NOT_SUPPORTED;
+    }
+
+    dpriv->capture_count--;
+    if(dpriv->capture_count > 0) {
+        return LIBUSB_SUCCESS;
+    }
+
+    usbi_dbg(HANDLE_CTX(dev_handle), "reenumerating device for kernel driver attach");
+
+    /* reset device to attach kernel drivers */
+    return darwin_reenumerate_device(dev_handle, false);
+}
+
+static int darwin_capture_claim_interface(struct libusb_device_handle *dev_handle, uint8_t iface) {
+    enum libusb_error ret;
+    if(dev_handle->auto_detach_kernel_driver && darwin_kernel_driver_active(dev_handle, iface)) {
+        ret = darwin_detach_kernel_driver(dev_handle, iface);
+        if(ret != LIBUSB_SUCCESS) {
+            usbi_info(HANDLE_CTX(dev_handle), "failed to auto-detach the kernel driver for this device, ret=%d", ret);
+        }
+    }
+
+    return darwin_claim_interface(dev_handle, iface);
+}
+
+static int darwin_capture_release_interface(struct libusb_device_handle *dev_handle, uint8_t iface) {
+    enum libusb_error            ret;
+    struct darwin_cached_device *dpriv = DARWIN_CACHED_DEVICE(dev_handle->dev);
+
+    ret = darwin_release_interface(dev_handle, iface);
+    if(ret != LIBUSB_SUCCESS) {
+        return ret;
+    }
+
+    if(dev_handle->auto_detach_kernel_driver && dpriv->capture_count > 0) {
+        ret = darwin_attach_kernel_driver(dev_handle, iface);
+        if(LIBUSB_SUCCESS != ret) {
+            usbi_info(HANDLE_CTX(dev_handle), "on attempt to reattach the kernel driver got ret=%d", ret);
+        }
+        /* ignore the error as the interface was successfully released */
+    }
+
+    return LIBUSB_SUCCESS;
+}
+
+#endif
+
+const struct usbi_os_backend usbi_backend = {
+    .name                         = "Darwin",
+    .caps                         = USBI_CAP_SUPPORTS_DETACH_KERNEL_DRIVER,
+    .init                         = darwin_init,
+    .exit                         = darwin_exit,
+    .get_active_config_descriptor = darwin_get_active_config_descriptor,
+    .get_config_descriptor        = darwin_get_config_descriptor,
+    .hotplug_poll                 = darwin_hotplug_poll,
+
+    .open              = darwin_open,
+    .close             = darwin_close,
+    .get_configuration = darwin_get_configuration,
+    .set_configuration = darwin_set_configuration,
+
+    .set_interface_altsetting = darwin_set_interface_altsetting,
+    .clear_halt               = darwin_clear_halt,
+    .reset_device             = darwin_reset_device,
+
+#if InterfaceVersion >= 550
+    .alloc_streams = darwin_alloc_streams,
+    .free_streams  = darwin_free_streams,
+#endif
+
+    .kernel_driver_active = darwin_kernel_driver_active,
+
+#if InterfaceVersion >= 700
+    .detach_kernel_driver = darwin_detach_kernel_driver,
+    .attach_kernel_driver = darwin_attach_kernel_driver,
+    .claim_interface      = darwin_capture_claim_interface,
+    .release_interface    = darwin_capture_release_interface,
+#else
+    .claim_interface   = darwin_claim_interface,
+    .release_interface = darwin_release_interface,
+#endif
+
+    .destroy_device = darwin_destroy_device,
+
+    .submit_transfer = darwin_submit_transfer,
+    .cancel_transfer = darwin_cancel_transfer,
+
+    .handle_transfer_completion = darwin_handle_transfer_completion,
+
+    .device_priv_size        = sizeof(struct darwin_device_priv),
+    .device_handle_priv_size = sizeof(struct darwin_device_handle_priv),
+    .transfer_priv_size      = sizeof(struct darwin_transfer_priv),
+};
diff --git a/3rdparty/libusb/src/libusb/os/darwin_usb.h b/3rdparty/libusb/src/libusb/os/darwin_usb.h
new file mode 100644
index 00000000..b35f8da1
--- /dev/null
+++ b/3rdparty/libusb/src/libusb/os/darwin_usb.h
@@ -0,0 +1,227 @@
+/*
+ * darwin backend for libusb 1.0
+ * Copyright © 2008-2019 Nathan Hjelm <hjelmn@users.sourceforge.net>
+ * Copyright © 2019      Google LLC. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#if !defined(LIBUSB_DARWIN_H)
+#define LIBUSB_DARWIN_H
+
+#include <stdbool.h>
+
+#include "libusbi.h"
+
+#include <IOKit/IOTypes.h>
+#include <IOKit/IOCFBundle.h>
+#include <IOKit/usb/IOUSBLib.h>
+#include <IOKit/IOCFPlugIn.h>
+
+#if defined(HAVE_IOKIT_USB_IOUSBHOSTFAMILYDEFINITIONS_H)
+#include <IOKit/usb/IOUSBHostFamilyDefinitions.h>
+#endif
+
+/* IOUSBInterfaceInferface */
+
+/* New in OS 10.12.0. */
+#if defined(kIOUSBInterfaceInterfaceID800)
+
+#define usb_interface_t IOUSBInterfaceInterface800
+#define InterfaceInterfaceID kIOUSBInterfaceInterfaceID800
+#define InterfaceVersion 800
+
+/* New in OS 10.10.0. */
+#elif defined(kIOUSBInterfaceInterfaceID700)
+
+#define usb_interface_t IOUSBInterfaceInterface700
+#define InterfaceInterfaceID kIOUSBInterfaceInterfaceID700
+#define InterfaceVersion 700
+
+/* New in OS 10.9.0. */
+#elif defined(kIOUSBInterfaceInterfaceID650)
+
+#define usb_interface_t IOUSBInterfaceInterface650
+#define InterfaceInterfaceID kIOUSBInterfaceInterfaceID650
+#define InterfaceVersion 650
+
+/* New in OS 10.8.2 but can't test deployment target to that granularity, so round up. */
+#elif defined(kIOUSBInterfaceInterfaceID550)
+
+#define usb_interface_t IOUSBInterfaceInterface550
+#define InterfaceInterfaceID kIOUSBInterfaceInterfaceID550
+#define InterfaceVersion 550
+
+/* New in OS 10.7.3 but can't test deployment target to that granularity, so round up. */
+#elif defined(kIOUSBInterfaceInterfaceID500)
+
+#define usb_interface_t IOUSBInterfaceInterface500
+#define InterfaceInterfaceID kIOUSBInterfaceInterfaceID500
+#define InterfaceVersion 500
+
+/* New in OS 10.5.0. */
+#elif defined(kIOUSBInterfaceInterfaceID300)
+
+#define usb_interface_t IOUSBInterfaceInterface300
+#define InterfaceInterfaceID kIOUSBInterfaceInterfaceID300
+#define InterfaceVersion 300
+
+/* New in OS 10.4.5 (or 10.4.6?) but can't test deployment target to that granularity, so round up. */
+#elif defined(kIOUSBInterfaceInterfaceID245)
+
+#define usb_interface_t IOUSBInterfaceInterface245
+#define InterfaceInterfaceID kIOUSBInterfaceInterfaceID245
+#define InterfaceVersion 245
+
+/* New in OS 10.4.0. */
+#elif defined(kIOUSBInterfaceInterfaceID220)
+
+#define usb_interface_t IOUSBInterfaceInterface220
+#define InterfaceInterfaceID kIOUSBInterfaceInterfaceID220
+#define InterfaceVersion 220
+
+#else
+
+#error "IOUSBFamily is too old. Please upgrade your SDK and/or deployment target"
+
+#endif
+
+/* IOUSBDeviceInterface */
+
+/* New in OS 10.9.0. */
+#if defined(kIOUSBDeviceInterfaceID650)
+
+#define usb_device_t IOUSBDeviceInterface650
+#define DeviceInterfaceID kIOUSBDeviceInterfaceID650
+#define DeviceVersion 650
+
+/* New in OS 10.7.3 but can't test deployment target to that granularity, so round up. */
+#elif defined(kIOUSBDeviceInterfaceID500)
+
+#define usb_device_t IOUSBDeviceInterface500
+#define DeviceInterfaceID kIOUSBDeviceInterfaceID500
+#define DeviceVersion 500
+
+/* New in OS 10.5.4 but can't test deployment target to that granularity, so round up. */
+#elif defined(kIOUSBDeviceInterfaceID320)
+
+#define usb_device_t IOUSBDeviceInterface320
+#define DeviceInterfaceID kIOUSBDeviceInterfaceID320
+#define DeviceVersion 320
+
+/* New in OS 10.5.0. */
+#elif defined(kIOUSBDeviceInterfaceID300)
+
+#define usb_device_t IOUSBDeviceInterface300
+#define DeviceInterfaceID kIOUSBDeviceInterfaceID300
+#define DeviceVersion 300
+
+/* New in OS 10.4.5 (or 10.4.6?) but can't test deployment target to that granularity, so round up. */
+#elif defined(kIOUSBDeviceInterfaceID245)
+
+#define usb_device_t IOUSBDeviceInterface245
+#define DeviceInterfaceID kIOUSBDeviceInterfaceID245
+#define DeviceVersion 245
+
+/* New in OS 10.2.3 but can't test deployment target to that granularity, so round up. */
+#elif defined(kIOUSBDeviceInterfaceID197)
+
+#define usb_device_t IOUSBDeviceInterface197
+#define DeviceInterfaceID kIOUSBDeviceInterfaceID197
+#define DeviceVersion 197
+
+#else
+
+#error "IOUSBFamily is too old. Please upgrade your SDK and/or deployment target"
+
+#endif
+
+#if !defined(kIOUSBHostInterfaceClassName)
+#define kIOUSBHostInterfaceClassName "IOUSBHostInterface"
+#endif
+
+#if !defined(kUSBHostMatchingPropertyInterfaceNumber)
+#define kUSBHostMatchingPropertyInterfaceNumber "bInterfaceNumber"
+#endif
+
+#if !defined(IO_OBJECT_NULL)
+#define IO_OBJECT_NULL ((io_object_t)0)
+#endif
+
+/* Testing availability */
+#ifndef __has_builtin
+#define __has_builtin(x) 0  // Compatibility with non-clang compilers.
+#endif
+#if __has_builtin(__builtin_available)
+#define HAS_CAPTURE_DEVICE() __builtin_available(macOS 10.10, *)
+#else
+#define HAS_CAPTURE_DEVICE() 0
+#endif
+
+typedef IOCFPlugInInterface  *io_cf_plugin_ref_t;
+typedef IONotificationPortRef io_notification_port_t;
+
+/* private structures */
+struct darwin_cached_device {
+    struct list_head      list;
+    IOUSBDeviceDescriptor dev_descriptor;
+    UInt32                location;
+    UInt64                parent_session;
+    UInt64                session;
+    USBDeviceAddress      address;
+    char                  sys_path[21];
+    usb_device_t        **device;
+    io_service_t          service;
+    int                   open_count;
+    UInt8                 first_config, active_config, port;
+    int                   can_enumerate;
+    int                   refcount;
+    bool                  in_reenumerate;
+    int                   capture_count;
+};
+
+struct darwin_device_priv {
+    struct darwin_cached_device *dev;
+};
+
+struct darwin_device_handle_priv {
+    bool               is_open;
+    CFRunLoopSourceRef cfSource;
+
+    struct darwin_interface {
+        usb_interface_t  **interface;
+        uint8_t            num_endpoints;
+        CFRunLoopSourceRef cfSource;
+        uint64_t           frames[256];
+        uint8_t            endpoint_addrs[USB_MAXENDPOINTS];
+    } interfaces[USB_MAXINTERFACES];
+};
+
+struct darwin_transfer_priv {
+    /* Isoc */
+    IOUSBIsocFrame *isoc_framelist;
+    int             num_iso_packets;
+
+    /* Control */
+    IOUSBDevRequestTO req;
+
+    /* Bulk */
+
+    /* Completion status */
+    IOReturn result;
+    UInt32   size;
+};
+
+#endif
diff --git a/3rdparty/libusb/src/libusb/os/emscripten_webusb.cpp b/3rdparty/libusb/src/libusb/os/emscripten_webusb.cpp
new file mode 100644
index 00000000..e5ed60c2
--- /dev/null
+++ b/3rdparty/libusb/src/libusb/os/emscripten_webusb.cpp
@@ -0,0 +1,589 @@
+/*
+ * Copyright © 2021 Google LLC
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Authors:
+ *		Ingvar Stepanyan <me@rreverser.com>
+ */
+
+#include <emscripten.h>
+#include <emscripten/val.h>
+
+#include "libusbi.h"
+
+using namespace emscripten;
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wmissing-prototypes"
+#pragma clang diagnostic ignored "-Wunused-parameter"
+namespace {
+// clang-format off
+	EM_JS(EM_VAL, em_promise_catch_impl, (EM_VAL handle), {
+		let promise = Emval.toValue(handle);
+		promise = promise.then(
+			value => ({error : 0, value}),
+			error => {
+				const ERROR_CODES = {
+					// LIBUSB_ERROR_IO
+					NetworkError : -1,
+					// LIBUSB_ERROR_INVALID_PARAM
+					DataError : -2,
+					TypeMismatchError : -2,
+					IndexSizeError : -2,
+					// LIBUSB_ERROR_ACCESS
+					SecurityError : -3,
+					// LIBUSB_ERROR_NOT_FOUND
+					NotFoundError : -5,
+					// LIBUSB_ERROR_BUSY
+					InvalidStateError : -6,
+					// LIBUSB_ERROR_TIMEOUT
+					TimeoutError : -7,
+					// LIBUSB_ERROR_INTERRUPTED
+					AbortError : -10,
+					// LIBUSB_ERROR_NOT_SUPPORTED
+					NotSupportedError : -12,
+				};
+				console.error(error);
+        let errorCode = -99; // LIBUSB_ERROR_OTHER
+				if (error instanceof DOMException)
+				{
+					errorCode = ERROR_CODES[error.name] ?? errorCode;
+				}
+				else if ((error instanceof RangeError) || (error instanceof TypeError))
+				{
+					errorCode = -2; // LIBUSB_ERROR_INVALID_PARAM
+				}
+				return {error: errorCode, value: undefined};
+			}
+    );
+    return Emval.toHandle(promise);
+	});
+// clang-format on
+
+val em_promise_catch(val &&promise) {
+    EM_VAL handle = promise.as_handle();
+    handle        = em_promise_catch_impl(handle);
+    return val::take_ownership(handle);
+}
+
+// C++ struct representation for {value, error} object from above
+// (performs conversion in the constructor).
+struct promise_result {
+    libusb_error error;
+    val          value;
+
+    promise_result(val &&result) : error(static_cast<libusb_error>(result["error"].as<int>())), value(result["value"]) {}
+
+    // C++ counterpart of the promise helper above that takes a promise, catches
+    // its error, converts to a libusb status and returns the whole thing as
+    // `promise_result` struct for easier handling.
+    static promise_result await(val &&promise) {
+        promise = em_promise_catch(std::move(promise));
+        return { promise.await() };
+    }
+};
+
+// We store an Embind handle to WebUSB USBDevice in "priv" metadata of
+// libusb device, this helper returns a pointer to it.
+struct ValPtr {
+public:
+    void init_to(val &&value) {
+        new(ptr) val(std::move(value));
+    }
+
+    val &get() {
+        return *ptr;
+    }
+    val take() {
+        return std::move(get());
+    }
+
+protected:
+    ValPtr(val *ptr) : ptr(ptr) {}
+
+private:
+    val *ptr;
+};
+
+struct WebUsbDevicePtr : ValPtr {
+public:
+    WebUsbDevicePtr(libusb_device *dev) : ValPtr(static_cast<val *>(usbi_get_device_priv(dev))) {}
+};
+
+val &get_web_usb_device(libusb_device *dev) {
+    return WebUsbDevicePtr(dev).get();
+}
+
+struct WebUsbTransferPtr : ValPtr {
+public:
+    WebUsbTransferPtr(usbi_transfer *itransfer) : ValPtr(static_cast<val *>(usbi_get_transfer_priv(itransfer))) {}
+};
+
+void em_signal_transfer_completion_impl(usbi_transfer *itransfer, val &&result) {
+    WebUsbTransferPtr(itransfer).init_to(std::move(result));
+    usbi_signal_transfer_completion(itransfer);
+}
+
+// Store the global `navigator.usb` once upon initialisation.
+thread_local const val web_usb = val::global("navigator")["usb"];
+
+enum StringId : uint8_t {
+    Manufacturer = 1,
+    Product      = 2,
+    SerialNumber = 3,
+};
+
+int em_get_device_list(libusb_context *ctx, discovered_devs **devs) {
+    // C++ equivalent of `await navigator.usb.getDevices()`.
+    // Note: at this point we must already have some devices exposed -
+    // caller must have called `await navigator.usb.requestDevice(...)`
+    // in response to user interaction before going to LibUSB.
+    // Otherwise this list will be empty.
+    auto result = promise_result::await(web_usb.call<val>("getDevices"));
+    if(result.error) {
+        return result.error;
+    }
+    auto &web_usb_devices = result.value;
+    // Iterate over the exposed devices.
+    uint8_t devices_num = web_usb_devices["length"].as<uint8_t>();
+    for(uint8_t i = 0; i < devices_num; i++) {
+        auto web_usb_device = web_usb_devices[i];
+        auto vendor_id      = web_usb_device["vendorId"].as<uint16_t>();
+        auto product_id     = web_usb_device["productId"].as<uint16_t>();
+        // TODO: this has to be a unique ID for the device in libusb structs.
+        // We can't really rely on the index in the list, and otherwise
+        // I can't think of a good way to assign permanent IDs to those
+        // devices, so here goes best-effort attempt...
+        unsigned long session_id = (vendor_id << 16) | product_id;
+        // LibUSB uses that ID to check if this device is already in its own
+        // list. As long as there are no two instances of same device
+        // connected and exposed to the page, we should be fine...
+        auto dev = usbi_get_device_by_session_id(ctx, session_id);
+        if(dev == NULL) {
+            dev = usbi_alloc_device(ctx, session_id);
+            if(dev == NULL) {
+                usbi_err(ctx, "failed to allocate a new device structure");
+                continue;
+            }
+
+            dev->device_descriptor = {
+                .bLength         = LIBUSB_DT_DEVICE_SIZE,
+                .bDescriptorType = LIBUSB_DT_DEVICE,
+                .bcdUSB = static_cast<uint16_t>((web_usb_device["usbVersionMajor"].as<uint8_t>() << 8) | (web_usb_device["usbVersionMinor"].as<uint8_t>() << 4)
+                                                | web_usb_device["usbVersionSubminor"].as<uint8_t>()),
+                .bDeviceClass    = web_usb_device["deviceClass"].as<uint8_t>(),
+                .bDeviceSubClass = web_usb_device["deviceSubclass"].as<uint8_t>(),
+                .bDeviceProtocol = web_usb_device["deviceProtocol"].as<uint8_t>(),
+                .bMaxPacketSize0 = 64,  // yolo
+                .idVendor        = vendor_id,
+                .idProduct       = product_id,
+                .bcdDevice =
+                    static_cast<uint16_t>((web_usb_device["deviceVersionMajor"].as<uint8_t>() << 8) | (web_usb_device["deviceVersionMinor"].as<uint8_t>() << 4)
+                                          | web_usb_device["deviceVersionSubminor"].as<uint8_t>()),
+                // Those are supposed to be indices for USB string descriptors.
+                // Normally they're part of the raw USB descriptor structure, but in
+                // our case we don't have it. Luckily, libusb provides hooks for that
+                // (to accomodate for other systems in similar position) so we can
+                // just assign constant IDs we can recognise later and then handle
+                // them in `em_submit_transfer` when there is a request to get string
+                // descriptor value.
+                .iManufacturer      = StringId::Manufacturer,
+                .iProduct           = StringId::Product,
+                .iSerialNumber      = StringId::SerialNumber,
+                .bNumConfigurations = web_usb_device["configurations"]["length"].as<uint8_t>(),
+            };
+
+            if(usbi_sanitize_device(dev) < 0) {
+                libusb_unref_device(dev);
+                continue;
+            }
+
+            WebUsbDevicePtr(dev).init_to(std::move(web_usb_device));
+        }
+        *devs = discovered_devs_append(*devs, dev);
+    }
+    return LIBUSB_SUCCESS;
+}
+
+int em_open(libusb_device_handle *handle) {
+    auto web_usb_device = get_web_usb_device(handle->dev);
+    return promise_result::await(web_usb_device.call<val>("open")).error;
+}
+
+void em_close(libusb_device_handle *handle) {
+    // LibUSB API doesn't allow us to handle an error here, so ignore the Promise
+    // altogether.
+    return get_web_usb_device(handle->dev).call<void>("close");
+}
+
+int em_get_config_descriptor_impl(val &&web_usb_config, void *buf, size_t len) {
+    const auto buf_start          = static_cast<uint8_t *>(buf);
+    auto       web_usb_interfaces = web_usb_config["interfaces"];
+    auto       num_interfaces     = web_usb_interfaces["length"].as<uint8_t>();
+    auto       config             = static_cast<usbi_configuration_descriptor *>(buf);
+    *config                       = {
+                              .bLength             = LIBUSB_DT_CONFIG_SIZE,
+                              .bDescriptorType     = LIBUSB_DT_CONFIG,
+                              .wTotalLength        = LIBUSB_DT_CONFIG_SIZE,
+                              .bNumInterfaces      = num_interfaces,
+                              .bConfigurationValue = web_usb_config["configurationValue"].as<uint8_t>(),
+                              .iConfiguration      = 0,       // TODO: assign some index and handle `configurationName`
+                              .bmAttributes        = 1 << 7,  // bus powered (should be always set according to docs)
+                              .bMaxPower           = 0,       // yolo
+    };
+    buf = static_cast<uint8_t *>(buf) + LIBUSB_DT_CONFIG_SIZE;
+    for(uint8_t i = 0; i < num_interfaces; i++) {
+        auto web_usb_interface = web_usb_interfaces[i];
+        // TODO: update to `web_usb_interface["alternate"]` once
+        // fix for https://bugs.chromium.org/p/chromium/issues/detail?id=1093502 is
+        // stable.
+        auto web_usb_alternate = web_usb_interface["alternates"][0];
+        auto web_usb_endpoints = web_usb_alternate["endpoints"];
+        auto num_endpoints     = web_usb_endpoints["length"].as<uint8_t>();
+        config->wTotalLength += LIBUSB_DT_INTERFACE_SIZE + num_endpoints * LIBUSB_DT_ENDPOINT_SIZE;
+        if(config->wTotalLength > len) {
+            continue;
+        }
+        auto interface = static_cast<usbi_interface_descriptor *>(buf);
+        *interface     = {
+                .bLength            = LIBUSB_DT_INTERFACE_SIZE,
+                .bDescriptorType    = LIBUSB_DT_INTERFACE,
+                .bInterfaceNumber   = web_usb_interface["interfaceNumber"].as<uint8_t>(),
+                .bAlternateSetting  = web_usb_alternate["alternateSetting"].as<uint8_t>(),
+                .bNumEndpoints      = web_usb_endpoints["length"].as<uint8_t>(),
+                .bInterfaceClass    = web_usb_alternate["interfaceClass"].as<uint8_t>(),
+                .bInterfaceSubClass = web_usb_alternate["interfaceSubclass"].as<uint8_t>(),
+                .bInterfaceProtocol = web_usb_alternate["interfaceProtocol"].as<uint8_t>(),
+                .iInterface         = 0,  // Not exposed in WebUSB, don't assign any string.
+        };
+        buf = static_cast<uint8_t *>(buf) + LIBUSB_DT_INTERFACE_SIZE;
+        for(uint8_t j = 0; j < num_endpoints; j++) {
+            auto web_usb_endpoint = web_usb_endpoints[j];
+            auto endpoint         = static_cast<libusb_endpoint_descriptor *>(buf);
+
+            auto web_usb_endpoint_type = web_usb_endpoint["type"].as<std::string>();
+            auto transfer_type         = LIBUSB_ENDPOINT_TRANSFER_TYPE_CONTROL;
+
+            if(web_usb_endpoint_type == "bulk") {
+                transfer_type = LIBUSB_ENDPOINT_TRANSFER_TYPE_BULK;
+            }
+            else if(web_usb_endpoint_type == "interrupt") {
+                transfer_type = LIBUSB_ENDPOINT_TRANSFER_TYPE_INTERRUPT;
+            }
+            else if(web_usb_endpoint_type == "isochronous") {
+                transfer_type = LIBUSB_ENDPOINT_TRANSFER_TYPE_ISOCHRONOUS;
+            }
+
+            // Can't use struct-init syntax here because there is no
+            // `usbi_endpoint_descriptor` unlike for other descriptors, so we use
+            // `libusb_endpoint_descriptor` instead which has extra libusb-specific
+            // fields and might overflow the provided buffer.
+            endpoint->bLength          = LIBUSB_DT_ENDPOINT_SIZE;
+            endpoint->bDescriptorType  = LIBUSB_DT_ENDPOINT;
+            endpoint->bEndpointAddress = ((web_usb_endpoint["direction"].as<std::string>() == "in") << 7) | web_usb_endpoint["endpointNumber"].as<uint8_t>();
+            endpoint->bmAttributes     = transfer_type;
+            endpoint->wMaxPacketSize   = web_usb_endpoint["packetSize"].as<uint16_t>();
+            endpoint->bInterval        = 1;
+
+            buf = static_cast<uint8_t *>(buf) + LIBUSB_DT_ENDPOINT_SIZE;
+        }
+    }
+    return static_cast<uint8_t *>(buf) - buf_start;
+}
+
+int em_get_active_config_descriptor(libusb_device *dev, void *buf, size_t len) {
+    auto web_usb_config = get_web_usb_device(dev)["configuration"];
+    if(web_usb_config.isNull()) {
+        return LIBUSB_ERROR_NOT_FOUND;
+    }
+    return em_get_config_descriptor_impl(std::move(web_usb_config), buf, len);
+}
+
+int em_get_config_descriptor(libusb_device *dev, uint8_t idx, void *buf, size_t len) {
+    return em_get_config_descriptor_impl(get_web_usb_device(dev)["configurations"][idx], buf, len);
+}
+
+int em_get_configuration(libusb_device_handle *dev_handle, uint8_t *config) {
+    auto web_usb_config = get_web_usb_device(dev_handle->dev)["configuration"];
+    if(!web_usb_config.isNull()) {
+        *config = web_usb_config["configurationValue"].as<uint8_t>();
+    }
+    return LIBUSB_SUCCESS;
+}
+
+int em_set_configuration(libusb_device_handle *handle, int config) {
+    return promise_result::await(get_web_usb_device(handle->dev).call<val>("selectConfiguration", config)).error;
+}
+
+int em_claim_interface(libusb_device_handle *handle, uint8_t iface) {
+    return promise_result::await(get_web_usb_device(handle->dev).call<val>("claimInterface", iface)).error;
+}
+
+int em_release_interface(libusb_device_handle *handle, uint8_t iface) {
+    return promise_result::await(get_web_usb_device(handle->dev).call<val>("releaseInterface", iface)).error;
+}
+
+int em_set_interface_altsetting(libusb_device_handle *handle, uint8_t iface, uint8_t altsetting) {
+    return promise_result::await(get_web_usb_device(handle->dev).call<val>("selectAlternateInterface", iface, altsetting)).error;
+}
+
+int em_clear_halt(libusb_device_handle *handle, unsigned char endpoint) {
+    std::string direction = endpoint & LIBUSB_ENDPOINT_IN ? "in" : "out";
+    endpoint &= LIBUSB_ENDPOINT_ADDRESS_MASK;
+
+    return promise_result::await(get_web_usb_device(handle->dev).call<val>("clearHalt", direction, endpoint)).error;
+}
+
+int em_reset_device(libusb_device_handle *handle) {
+    return promise_result::await(get_web_usb_device(handle->dev).call<val>("reset")).error;
+}
+
+void em_destroy_device(libusb_device *dev) {
+    WebUsbDevicePtr(dev).take();
+}
+
+thread_local const val Uint8Array = val::global("Uint8Array");
+
+EMSCRIPTEN_KEEPALIVE
+extern "C" void em_signal_transfer_completion(usbi_transfer *itransfer, EM_VAL result_handle) {
+    em_signal_transfer_completion_impl(itransfer, val::take_ownership(result_handle));
+}
+
+// clang-format off
+EM_JS(void, em_start_transfer_impl, (usbi_transfer *transfer, EM_VAL handle), {
+  // Right now the handle value should be a `Promise<{value, error}>`.
+  // Subscribe to its result to unwrap the promise to `{value, error}`
+  // and signal transfer completion.
+  // Catch the error to transform promise of `value` into promise of `{value,
+  // error}`.
+  Emval.toValue(handle).then(result => {
+    _em_signal_transfer_completion(transfer, Emval.toHandle(result));
+  });
+});
+// clang-format on
+
+void em_start_transfer(usbi_transfer *itransfer, val &&promise) {
+    promise = em_promise_catch(std::move(promise));
+    em_start_transfer_impl(itransfer, promise.as_handle());
+}
+
+int em_submit_transfer(usbi_transfer *itransfer) {
+    auto transfer       = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+    auto web_usb_device = get_web_usb_device(transfer->dev_handle->dev);
+    switch(transfer->type) {
+    case LIBUSB_TRANSFER_TYPE_CONTROL: {
+        auto setup                           = libusb_control_transfer_get_setup(transfer);
+        auto web_usb_control_transfer_params = val::object();
+
+        const char *web_usb_request_type = "unknown";
+        // See LIBUSB_REQ_TYPE in windows_winusb.h (or docs for `bmRequestType`).
+        switch(setup->bmRequestType & (0x03 << 5)) {
+        case LIBUSB_REQUEST_TYPE_STANDARD:
+            if(setup->bRequest == LIBUSB_REQUEST_GET_DESCRIPTOR && setup->wValue >> 8 == LIBUSB_DT_STRING) {
+                // For string descriptors we provide custom implementation that
+                // doesn't require an actual transfer, but just retrieves the value
+                // from JS, stores that string handle as transfer data (instead of a
+                // Promise) and immediately signals completion.
+                const char *propName = nullptr;
+                switch(setup->wValue & 0xFF) {
+                case StringId::Manufacturer:
+                    propName = "manufacturerName";
+                    break;
+                case StringId::Product:
+                    propName = "productName";
+                    break;
+                case StringId::SerialNumber:
+                    propName = "serialNumber";
+                    break;
+                }
+                if(propName != nullptr) {
+                    val str = web_usb_device[propName];
+                    if(str.isNull()) {
+                        str = val("");
+                    }
+                    em_signal_transfer_completion_impl(itransfer, std::move(str));
+                    return LIBUSB_SUCCESS;
+                }
+            }
+            web_usb_request_type = "standard";
+            break;
+        case LIBUSB_REQUEST_TYPE_CLASS:
+            web_usb_request_type = "class";
+            break;
+        case LIBUSB_REQUEST_TYPE_VENDOR:
+            web_usb_request_type = "vendor";
+            break;
+        }
+        web_usb_control_transfer_params.set("requestType", web_usb_request_type);
+
+        const char *recipient = "other";
+        switch(setup->bmRequestType & 0x0f) {
+        case LIBUSB_RECIPIENT_DEVICE:
+            recipient = "device";
+            break;
+        case LIBUSB_RECIPIENT_INTERFACE:
+            recipient = "interface";
+            break;
+        case LIBUSB_RECIPIENT_ENDPOINT:
+            recipient = "endpoint";
+            break;
+        }
+        web_usb_control_transfer_params.set("recipient", recipient);
+
+        web_usb_control_transfer_params.set("request", setup->bRequest);
+        web_usb_control_transfer_params.set("value", setup->wValue);
+        web_usb_control_transfer_params.set("index", setup->wIndex);
+
+        if(setup->bmRequestType & LIBUSB_ENDPOINT_IN) {
+            em_start_transfer(itransfer, web_usb_device.call<val>("controlTransferIn", std::move(web_usb_control_transfer_params), setup->wLength));
+        }
+        else {
+            auto data = val(typed_memory_view(setup->wLength, libusb_control_transfer_get_data(transfer))).call<val>("slice");
+            em_start_transfer(itransfer, web_usb_device.call<val>("controlTransferOut", std::move(web_usb_control_transfer_params), data));
+        }
+
+        break;
+    }
+    case LIBUSB_TRANSFER_TYPE_BULK:
+    case LIBUSB_TRANSFER_TYPE_INTERRUPT: {
+        auto endpoint = transfer->endpoint & LIBUSB_ENDPOINT_ADDRESS_MASK;
+
+        if(IS_XFERIN(transfer)) {
+            em_start_transfer(itransfer, web_usb_device.call<val>("transferIn", endpoint, transfer->length));
+        }
+        else {
+            auto data = val(typed_memory_view(transfer->length, transfer->buffer)).call<val>("slice");
+            em_start_transfer(itransfer, web_usb_device.call<val>("transferOut", endpoint, data));
+        }
+
+        break;
+    }
+    // TODO: add implementation for isochronous transfers too.
+    default:
+        return LIBUSB_ERROR_NOT_SUPPORTED;
+    }
+    return LIBUSB_SUCCESS;
+}
+
+void em_clear_transfer_priv(usbi_transfer *itransfer) {
+    WebUsbTransferPtr(itransfer).take();
+}
+
+int em_cancel_transfer(usbi_transfer *itransfer) {
+    return LIBUSB_SUCCESS;
+}
+
+int em_handle_transfer_completion(usbi_transfer *itransfer) {
+    auto transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+
+    // Take ownership of the transfer result, as `em_clear_transfer_priv`
+    // is not called automatically for completed transfers and we must
+    // free it to avoid leaks.
+
+    auto result_val = WebUsbTransferPtr(itransfer).take();
+
+    if(itransfer->state_flags & USBI_TRANSFER_CANCELLING) {
+        return usbi_handle_transfer_cancellation(itransfer);
+    }
+
+    libusb_transfer_status status = LIBUSB_TRANSFER_ERROR;
+
+    // If this was a LIBUSB_DT_STRING request, then the value will be a string
+    // handle instead of a promise.
+    if(result_val.isString()) {
+        int written = EM_ASM_INT(
+            {
+                // There's no good way to get UTF-16 output directly from JS string,
+                // so again reach out to internals via JS snippet.
+                return stringToUTF16(Emval.toValue($0), $1, $2);
+            },
+            result_val.as_handle(), transfer->buffer + LIBUSB_CONTROL_SETUP_SIZE + 2, transfer->length - LIBUSB_CONTROL_SETUP_SIZE - 2);
+        itransfer->transferred = transfer->buffer[LIBUSB_CONTROL_SETUP_SIZE] = 2 + written;
+        transfer->buffer[LIBUSB_CONTROL_SETUP_SIZE + 1]                      = LIBUSB_DT_STRING;
+        status                                                               = LIBUSB_TRANSFER_COMPLETED;
+    }
+    else {
+        // Otherwise we should have a `{value, error}` object by now (see
+        // `em_start_transfer_impl` callback).
+        promise_result result(std::move(result_val));
+
+        if(!result.error) {
+            auto web_usb_transfer_status = result.value["status"].as<std::string>();
+            if(web_usb_transfer_status == "ok") {
+                status = LIBUSB_TRANSFER_COMPLETED;
+            }
+            else if(web_usb_transfer_status == "stall") {
+                status = LIBUSB_TRANSFER_STALL;
+            }
+            else if(web_usb_transfer_status == "babble") {
+                status = LIBUSB_TRANSFER_OVERFLOW;
+            }
+
+            int           skip;
+            unsigned char endpointDir;
+
+            if(transfer->type == LIBUSB_TRANSFER_TYPE_CONTROL) {
+                skip        = LIBUSB_CONTROL_SETUP_SIZE;
+                endpointDir = libusb_control_transfer_get_setup(transfer)->bmRequestType;
+            }
+            else {
+                skip        = 0;
+                endpointDir = transfer->endpoint;
+            }
+
+            if(endpointDir & LIBUSB_ENDPOINT_IN) {
+                auto data = result.value["data"];
+                if(!data.isNull()) {
+                    itransfer->transferred = data["byteLength"].as<int>();
+                    val(typed_memory_view(transfer->length - skip, transfer->buffer + skip)).call<void>("set", Uint8Array.new_(data["buffer"]));
+                }
+            }
+            else {
+                itransfer->transferred = result.value["bytesWritten"].as<int>();
+            }
+        }
+    }
+
+    return usbi_handle_transfer_completion(itransfer, status);
+}
+}  // namespace
+
+extern "C" {
+const usbi_os_backend usbi_backend = {
+    .name                         = "Emscripten + WebUSB backend",
+    .caps                         = LIBUSB_CAP_HAS_CAPABILITY,
+    .get_device_list              = em_get_device_list,
+    .open                         = em_open,
+    .close                        = em_close,
+    .get_active_config_descriptor = em_get_active_config_descriptor,
+    .get_config_descriptor        = em_get_config_descriptor,
+    .get_configuration            = em_get_configuration,
+    .set_configuration            = em_set_configuration,
+    .claim_interface              = em_claim_interface,
+    .release_interface            = em_release_interface,
+    .set_interface_altsetting     = em_set_interface_altsetting,
+    .clear_halt                   = em_clear_halt,
+    .reset_device                 = em_reset_device,
+    .destroy_device               = em_destroy_device,
+    .submit_transfer              = em_submit_transfer,
+    .cancel_transfer              = em_cancel_transfer,
+    .clear_transfer_priv          = em_clear_transfer_priv,
+    .handle_transfer_completion   = em_handle_transfer_completion,
+    .device_priv_size             = sizeof(val),
+    .transfer_priv_size           = sizeof(val),
+};
+}
+#pragma clang diagnostic pop
diff --git a/3rdparty/libusb/src/libusb/os/events_posix.c b/3rdparty/libusb/src/libusb/os/events_posix.c
new file mode 100644
index 00000000..e30f6814
--- /dev/null
+++ b/3rdparty/libusb/src/libusb/os/events_posix.c
@@ -0,0 +1,342 @@
+/*
+ * libusb event abstraction on POSIX platforms
+ *
+ * Copyright © 2020 Chris Dickens <christopher.a.dickens@gmail.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "libusbi.h"
+
+#include <errno.h>
+#include <fcntl.h>
+#ifdef HAVE_EVENTFD
+#include <sys/eventfd.h>
+#endif
+#ifdef HAVE_TIMERFD
+#include <sys/timerfd.h>
+#endif
+
+#ifdef __EMSCRIPTEN__
+/* On Emscripten `pipe` does not conform to the spec and does not block
+ * until events are available, which makes it unusable for event system
+ * and often results in deadlocks when `pipe` is in a loop like it is
+ * in libusb.
+ *
+ * Therefore use a custom event system based on browser event emitters. */
+#include <emscripten.h>
+
+EM_JS(void, em_libusb_notify, (void), { dispatchEvent(new Event("em-libusb")); });
+
+EM_ASYNC_JS(int, em_libusb_wait, (int timeout), {
+    let onEvent, timeoutId;
+
+    try {
+        return await new Promise(resolve = > {
+            onEvent = () = > resolve(0);
+            addEventListener('em-libusb', onEvent);
+
+            timeoutId = setTimeout(resolve, timeout, -1);
+        });
+    }
+    finally {
+        removeEventListener('em-libusb', onEvent);
+        clearTimeout(timeoutId);
+    }
+});
+#endif
+#include <unistd.h>
+
+#ifdef HAVE_EVENTFD
+#define EVENT_READ_FD(e) ((e)->eventfd)
+#define EVENT_WRITE_FD(e) ((e)->eventfd)
+#else
+#define EVENT_READ_FD(e) ((e)->pipefd[0])
+#define EVENT_WRITE_FD(e) ((e)->pipefd[1])
+#endif
+
+#ifdef HAVE_NFDS_T
+typedef nfds_t usbi_nfds_t;
+#else
+typedef unsigned int usbi_nfds_t;
+#endif
+
+int usbi_create_event(usbi_event_t *event) {
+#ifdef HAVE_EVENTFD
+    event->eventfd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
+    if(event->eventfd == -1) {
+        usbi_err(NULL, "failed to create eventfd, errno=%d", errno);
+        return LIBUSB_ERROR_OTHER;
+    }
+
+    return 0;
+#else
+#if defined(HAVE_PIPE2)
+    int ret = pipe2(event->pipefd, O_CLOEXEC);
+#else
+    int ret = pipe(event->pipefd);
+#endif
+
+    if(ret != 0) {
+        usbi_err(NULL, "failed to create pipe, errno=%d", errno);
+        return LIBUSB_ERROR_OTHER;
+    }
+
+#if !defined(HAVE_PIPE2) && defined(FD_CLOEXEC)
+    ret = fcntl(event->pipefd[0], F_GETFD);
+    if(ret == -1) {
+        usbi_err(NULL, "failed to get pipe fd flags, errno=%d", errno);
+        goto err_close_pipe;
+    }
+    ret = fcntl(event->pipefd[0], F_SETFD, ret | FD_CLOEXEC);
+    if(ret == -1) {
+        usbi_err(NULL, "failed to set pipe fd flags, errno=%d", errno);
+        goto err_close_pipe;
+    }
+
+    ret = fcntl(event->pipefd[1], F_GETFD);
+    if(ret == -1) {
+        usbi_err(NULL, "failed to get pipe fd flags, errno=%d", errno);
+        goto err_close_pipe;
+    }
+    ret = fcntl(event->pipefd[1], F_SETFD, ret | FD_CLOEXEC);
+    if(ret == -1) {
+        usbi_err(NULL, "failed to set pipe fd flags, errno=%d", errno);
+        goto err_close_pipe;
+    }
+#endif
+
+    ret = fcntl(event->pipefd[1], F_GETFL);
+    if(ret == -1) {
+        usbi_err(NULL, "failed to get pipe fd status flags, errno=%d", errno);
+        goto err_close_pipe;
+    }
+    ret = fcntl(event->pipefd[1], F_SETFL, ret | O_NONBLOCK);
+    if(ret == -1) {
+        usbi_err(NULL, "failed to set pipe fd status flags, errno=%d", errno);
+        goto err_close_pipe;
+    }
+
+    return 0;
+
+err_close_pipe:
+    close(event->pipefd[1]);
+    close(event->pipefd[0]);
+    return LIBUSB_ERROR_OTHER;
+#endif
+}
+
+void usbi_destroy_event(usbi_event_t *event) {
+#ifdef HAVE_EVENTFD
+    if(close(event->eventfd) == -1)
+        usbi_warn(NULL, "failed to close eventfd, errno=%d", errno);
+#else
+    if(close(event->pipefd[1]) == -1)
+        usbi_warn(NULL, "failed to close pipe write end, errno=%d", errno);
+    if(close(event->pipefd[0]) == -1)
+        usbi_warn(NULL, "failed to close pipe read end, errno=%d", errno);
+#endif
+}
+
+void usbi_signal_event(usbi_event_t *event) {
+    uint64_t dummy = 1;
+    ssize_t  r;
+
+    r = write(EVENT_WRITE_FD(event), &dummy, sizeof(dummy));
+    if(r != sizeof(dummy))
+        usbi_warn(NULL, "event write failed");
+#ifdef __EMSCRIPTEN__
+    em_libusb_notify();
+#endif
+}
+
+void usbi_clear_event(usbi_event_t *event) {
+    uint64_t dummy;
+    ssize_t  r;
+
+    r = read(EVENT_READ_FD(event), &dummy, sizeof(dummy));
+    if(r != sizeof(dummy))
+        usbi_warn(NULL, "event read failed");
+}
+
+#ifdef HAVE_TIMERFD
+int usbi_create_timer(usbi_timer_t *timer) {
+    timer->timerfd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK | TFD_CLOEXEC);
+    if(timer->timerfd == -1) {
+        usbi_warn(NULL, "failed to create timerfd, errno=%d", errno);
+        return LIBUSB_ERROR_OTHER;
+    }
+
+    return 0;
+}
+
+void usbi_destroy_timer(usbi_timer_t *timer) {
+    if(close(timer->timerfd) == -1)
+        usbi_warn(NULL, "failed to close timerfd, errno=%d", errno);
+}
+
+int usbi_arm_timer(usbi_timer_t *timer, const struct timespec *timeout) {
+    const struct itimerspec it = { { 0, 0 }, { timeout->tv_sec, timeout->tv_nsec } };
+
+    if(timerfd_settime(timer->timerfd, TFD_TIMER_ABSTIME, &it, NULL) == -1) {
+        usbi_warn(NULL, "failed to arm timerfd, errno=%d", errno);
+        return LIBUSB_ERROR_OTHER;
+    }
+
+    return 0;
+}
+
+int usbi_disarm_timer(usbi_timer_t *timer) {
+    const struct itimerspec it = { { 0, 0 }, { 0, 0 } };
+
+    if(timerfd_settime(timer->timerfd, 0, &it, NULL) == -1) {
+        usbi_warn(NULL, "failed to disarm timerfd, errno=%d", errno);
+        return LIBUSB_ERROR_OTHER;
+    }
+
+    return 0;
+}
+#endif
+
+int usbi_alloc_event_data(struct libusb_context *ctx) {
+    struct usbi_event_source *ievent_source;
+    struct pollfd            *fds;
+    size_t                    i = 0;
+
+    if(ctx->event_data) {
+        free(ctx->event_data);
+        ctx->event_data = NULL;
+    }
+
+    ctx->event_data_cnt = 0;
+    for_each_event_source(ctx, ievent_source) ctx->event_data_cnt++;
+
+    fds = calloc(ctx->event_data_cnt, sizeof(*fds));
+    if(!fds)
+        return LIBUSB_ERROR_NO_MEM;
+
+    for_each_event_source(ctx, ievent_source) {
+        fds[i].fd     = ievent_source->data.os_handle;
+        fds[i].events = ievent_source->data.poll_events;
+        i++;
+    }
+
+    ctx->event_data = fds;
+    return 0;
+}
+
+int usbi_wait_for_events(struct libusb_context *ctx, struct usbi_reported_events *reported_events, int timeout_ms) {
+    struct pollfd *fds  = ctx->event_data;
+    usbi_nfds_t    nfds = (usbi_nfds_t)ctx->event_data_cnt;
+    int            internal_fds, num_ready;
+
+    usbi_dbg(ctx, "poll() %u fds with timeout in %dms", (unsigned int)nfds, timeout_ms);
+#ifdef __EMSCRIPTEN__
+    /* TODO: improve event system to watch only for fd events we're interested in
+     * (although a scenario where we have multiple watchers in parallel is very rare
+     * in real world anyway). */
+    double until_time = emscripten_get_now() + timeout_ms;
+    for(;;) {
+        /* Emscripten `poll` ignores timeout param, but pass 0 explicitly just in case. */
+        num_ready = poll(fds, nfds, 0);
+        if(num_ready != 0)
+            break;
+        int timeout = until_time - emscripten_get_now();
+        if(timeout <= 0)
+            break;
+        int result = em_libusb_wait(timeout);
+        if(result != 0)
+            break;
+    }
+#else
+    num_ready = poll(fds, nfds, timeout_ms);
+#endif
+    usbi_dbg(ctx, "poll() returned %d", num_ready);
+    if(num_ready == 0) {
+        if(usbi_using_timer(ctx))
+            goto done;
+        return LIBUSB_ERROR_TIMEOUT;
+    }
+    else if(num_ready == -1) {
+        if(errno == EINTR)
+            return LIBUSB_ERROR_INTERRUPTED;
+        usbi_err(ctx, "poll() failed, errno=%d", errno);
+        return LIBUSB_ERROR_IO;
+    }
+
+    /* fds[0] is always the internal signalling event */
+    if(fds[0].revents) {
+        reported_events->event_triggered = 1;
+        num_ready--;
+    }
+    else {
+        reported_events->event_triggered = 0;
+    }
+
+#ifdef HAVE_OS_TIMER
+    /* on timer configurations, fds[1] is the timer */
+    if(usbi_using_timer(ctx) && fds[1].revents) {
+        reported_events->timer_triggered = 1;
+        num_ready--;
+    }
+    else {
+        reported_events->timer_triggered = 0;
+    }
+#endif
+
+    if(!num_ready)
+        goto done;
+
+    /* the backend will never need to attempt to handle events on the
+     * library's internal file descriptors, so we determine how many are
+     * in use internally for this context and skip these when passing any
+     * remaining pollfds to the backend. */
+    internal_fds = usbi_using_timer(ctx) ? 2 : 1;
+    fds += internal_fds;
+    nfds -= internal_fds;
+
+    usbi_mutex_lock(&ctx->event_data_lock);
+    if(ctx->event_flags & USBI_EVENT_EVENT_SOURCES_MODIFIED) {
+        struct usbi_event_source *ievent_source;
+
+        for_each_removed_event_source(ctx, ievent_source) {
+            usbi_nfds_t n;
+
+            for(n = 0; n < nfds; n++) {
+                if(ievent_source->data.os_handle != fds[n].fd)
+                    continue;
+                if(!fds[n].revents)
+                    continue;
+                /* pollfd was removed between the creation of the fds array and
+                 * here. remove triggered revent as it is no longer relevant. */
+                usbi_dbg(ctx, "fd %d was removed, ignoring raised events", fds[n].fd);
+                fds[n].revents = 0;
+                num_ready--;
+                break;
+            }
+        }
+    }
+    usbi_mutex_unlock(&ctx->event_data_lock);
+
+    if(num_ready) {
+        assert(num_ready > 0);
+        reported_events->event_data       = fds;
+        reported_events->event_data_count = (unsigned int)nfds;
+    }
+
+done:
+    reported_events->num_ready = num_ready;
+    return LIBUSB_SUCCESS;
+}
diff --git a/3rdparty/libusb/src/libusb/os/events_posix.h b/3rdparty/libusb/src/libusb/os/events_posix.h
new file mode 100644
index 00000000..d81b5c4d
--- /dev/null
+++ b/3rdparty/libusb/src/libusb/os/events_posix.h
@@ -0,0 +1,59 @@
+/*
+ * libusb event abstraction on POSIX platforms
+ *
+ * Copyright © 2020 Chris Dickens <christopher.a.dickens@gmail.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef LIBUSB_EVENTS_POSIX_H
+#define LIBUSB_EVENTS_POSIX_H
+
+#include <poll.h>
+
+typedef int usbi_os_handle_t;
+#define USBI_OS_HANDLE_FORMAT_STRING	"fd %d"
+
+#ifdef HAVE_EVENTFD
+typedef struct usbi_event {
+	int eventfd;
+} usbi_event_t;
+#define USBI_EVENT_OS_HANDLE(e)	((e)->eventfd)
+#define USBI_EVENT_POLL_EVENTS	POLLIN
+#define USBI_INVALID_EVENT	{ -1 }
+#else
+typedef struct usbi_event {
+	int pipefd[2];
+} usbi_event_t;
+#define USBI_EVENT_OS_HANDLE(e)	((e)->pipefd[0])
+#define USBI_EVENT_POLL_EVENTS	POLLIN
+#define USBI_INVALID_EVENT	{ { -1, -1 } }
+#endif
+
+#ifdef HAVE_TIMERFD
+#define HAVE_OS_TIMER 1
+typedef struct usbi_timer {
+	int timerfd;
+} usbi_timer_t;
+#define USBI_TIMER_OS_HANDLE(t)	((t)->timerfd)
+#define USBI_TIMER_POLL_EVENTS	POLLIN
+
+static inline int usbi_timer_valid(usbi_timer_t *timer)
+{
+	return timer->timerfd >= 0;
+}
+#endif
+
+#endif
diff --git a/3rdparty/libusb/src/libusb/os/events_windows.c b/3rdparty/libusb/src/libusb/os/events_windows.c
new file mode 100644
index 00000000..6f0555ef
--- /dev/null
+++ b/3rdparty/libusb/src/libusb/os/events_windows.c
@@ -0,0 +1,204 @@
+/*
+ * libusb event abstraction on Microsoft Windows
+ *
+ * Copyright © 2020 Chris Dickens <christopher.a.dickens@gmail.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <libusb/config.h>
+
+#include "libusbi.h"
+#include "windows_common.h"
+
+int usbi_create_event(usbi_event_t *event) {
+    event->hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
+    if(event->hEvent == NULL) {
+        usbi_err(NULL, "CreateEvent failed: %s", windows_error_str(0));
+        return LIBUSB_ERROR_OTHER;
+    }
+
+    return 0;
+}
+
+void usbi_destroy_event(usbi_event_t *event) {
+    if(!CloseHandle(event->hEvent))
+        usbi_warn(NULL, "CloseHandle failed: %s", windows_error_str(0));
+}
+
+void usbi_signal_event(usbi_event_t *event) {
+    if(!SetEvent(event->hEvent))
+        usbi_warn(NULL, "SetEvent failed: %s", windows_error_str(0));
+}
+
+void usbi_clear_event(usbi_event_t *event) {
+    if(!ResetEvent(event->hEvent))
+        usbi_warn(NULL, "ResetEvent failed: %s", windows_error_str(0));
+}
+
+#ifdef HAVE_OS_TIMER
+int usbi_create_timer(usbi_timer_t *timer) {
+    timer->hTimer = CreateWaitableTimer(NULL, TRUE, NULL);
+    if(timer->hTimer == NULL) {
+        usbi_warn(NULL, "CreateWaitableTimer failed: %s", windows_error_str(0));
+        return LIBUSB_ERROR_OTHER;
+    }
+
+    return 0;
+}
+
+void usbi_destroy_timer(usbi_timer_t *timer) {
+    if(!CloseHandle(timer->hTimer))
+        usbi_warn(NULL, "CloseHandle failed: %s", windows_error_str(0));
+}
+
+int usbi_arm_timer(usbi_timer_t *timer, const struct timespec *timeout) {
+    struct timespec systime, remaining;
+    FILETIME        filetime;
+    LARGE_INTEGER   dueTime;
+
+    /* Transfer timeouts are based on the monotonic clock and the waitable
+     * timers on the system clock. This requires a conversion between the
+     * two, so we calculate the remaining time relative to the monotonic
+     * clock and calculate an absolute system time for the timer expiration.
+     * Note that if the timeout has already passed, the remaining time will
+     * be negative and thus an absolute system time in the past will be set.
+     * This works just as intended because the timer becomes signalled
+     * immediately. */
+    usbi_get_monotonic_time(&systime);
+
+    TIMESPEC_SUB(timeout, &systime, &remaining);
+
+    GetSystemTimeAsFileTime(&filetime);
+    dueTime.LowPart  = filetime.dwLowDateTime;
+    dueTime.HighPart = filetime.dwHighDateTime;
+    dueTime.QuadPart += (remaining.tv_sec * 10000000LL) + (remaining.tv_nsec / 100LL);
+
+    if(!SetWaitableTimer(timer->hTimer, &dueTime, 0, NULL, NULL, FALSE)) {
+        usbi_warn(NULL, "SetWaitableTimer failed: %s", windows_error_str(0));
+        return LIBUSB_ERROR_OTHER;
+    }
+
+    return 0;
+}
+
+int usbi_disarm_timer(usbi_timer_t *timer) {
+    LARGE_INTEGER dueTime;
+
+    /* A manual-reset waitable timer will stay in the signalled state until
+     * another call to SetWaitableTimer() is made. It is possible that the
+     * timer has already expired by the time we come in to disarm it, so to
+     * be entirely sure the timer is disarmed and not in the signalled state,
+     * we will set it with an impossibly large expiration and immediately
+     * cancel. */
+    dueTime.QuadPart = LLONG_MAX;
+    if(!SetWaitableTimer(timer->hTimer, &dueTime, 0, NULL, NULL, FALSE)) {
+        usbi_warn(NULL, "SetWaitableTimer failed: %s", windows_error_str(0));
+        return LIBUSB_ERROR_OTHER;
+    }
+
+    if(!CancelWaitableTimer(timer->hTimer)) {
+        usbi_warn(NULL, "SetWaitableTimer failed: %s", windows_error_str(0));
+        return LIBUSB_ERROR_OTHER;
+    }
+
+    return 0;
+}
+#endif
+
+int usbi_alloc_event_data(struct libusb_context *ctx) {
+    struct usbi_event_source *ievent_source;
+    HANDLE                   *handles;
+    size_t                    i = 0;
+
+    /* Event sources are only added during usbi_io_init(). We should not
+     * be running this function again if the event data has already been
+     * allocated. */
+    if(ctx->event_data) {
+        usbi_warn(ctx, "program assertion failed - event data already allocated");
+        return LIBUSB_ERROR_OTHER;
+    }
+
+    ctx->event_data_cnt = 0;
+    for_each_event_source(ctx, ievent_source) ctx->event_data_cnt++;
+
+    /* We only expect up to two HANDLEs to wait on, one for the internal
+     * signalling event and the other for the timer. */
+    if(ctx->event_data_cnt != 1 && ctx->event_data_cnt != 2) {
+        usbi_err(ctx, "program assertion failed - expected exactly 1 or 2 HANDLEs");
+        return LIBUSB_ERROR_OTHER;
+    }
+
+    handles = calloc(ctx->event_data_cnt, sizeof(HANDLE));
+    if(!handles)
+        return LIBUSB_ERROR_NO_MEM;
+
+    for_each_event_source(ctx, ievent_source) {
+        handles[i] = ievent_source->data.os_handle;
+        i++;
+    }
+
+    ctx->event_data = handles;
+    return 0;
+}
+
+int usbi_wait_for_events(struct libusb_context *ctx, struct usbi_reported_events *reported_events, int timeout_ms) {
+    HANDLE *handles     = ctx->event_data;
+    DWORD   num_handles = (DWORD)ctx->event_data_cnt;
+    DWORD   result;
+
+    usbi_dbg(ctx, "WaitForMultipleObjects() for %lu HANDLEs with timeout in %dms", ULONG_CAST(num_handles), timeout_ms);
+    result = WaitForMultipleObjects(num_handles, handles, FALSE, (DWORD)timeout_ms);
+    usbi_dbg(ctx, "WaitForMultipleObjects() returned %lu", ULONG_CAST(result));
+    if(result == WAIT_TIMEOUT) {
+        if(usbi_using_timer(ctx))
+            goto done;
+        return LIBUSB_ERROR_TIMEOUT;
+    }
+    else if(result == WAIT_FAILED) {
+        usbi_err(ctx, "WaitForMultipleObjects() failed: %s", windows_error_str(0));
+        return LIBUSB_ERROR_IO;
+    }
+
+    result -= WAIT_OBJECT_0;
+
+    /* handles[0] is always the internal signalling event */
+    if(result == 0)
+        reported_events->event_triggered = 1;
+    else
+        reported_events->event_triggered = 0;
+
+#ifdef HAVE_OS_TIMER
+    /* on timer configurations, handles[1] is the timer */
+    if(usbi_using_timer(ctx)) {
+        /* The WaitForMultipleObjects() function reports the index of
+         * the first object that became signalled. If the internal
+         * signalling event was reported, we need to also check and
+         * report whether the timer is in the signalled state. */
+        if(result == 1 || WaitForSingleObject(handles[1], 0) == WAIT_OBJECT_0)
+            reported_events->timer_triggered = 1;
+        else
+            reported_events->timer_triggered = 0;
+    }
+    else {
+        reported_events->timer_triggered = 0;
+    }
+#endif
+
+done:
+    /* no events are ever reported to the backend */
+    reported_events->num_ready = 0;
+    return LIBUSB_SUCCESS;
+}
diff --git a/3rdparty/libusb/src/libusb/os/events_windows.h b/3rdparty/libusb/src/libusb/os/events_windows.h
new file mode 100644
index 00000000..0c5e0b03
--- /dev/null
+++ b/3rdparty/libusb/src/libusb/os/events_windows.h
@@ -0,0 +1,46 @@
+/*
+ * libusb event abstraction on Microsoft Windows
+ *
+ * Copyright © 2020 Chris Dickens <christopher.a.dickens@gmail.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef LIBUSB_EVENTS_WINDOWS_H
+#define LIBUSB_EVENTS_WINDOWS_H
+
+typedef HANDLE usbi_os_handle_t;
+#define USBI_OS_HANDLE_FORMAT_STRING	"HANDLE %p"
+
+typedef struct usbi_event {
+	HANDLE hEvent;
+} usbi_event_t;
+#define USBI_EVENT_OS_HANDLE(e)	((e)->hEvent)
+#define USBI_EVENT_POLL_EVENTS	0
+#define USBI_INVALID_EVENT	{ INVALID_HANDLE_VALUE }
+
+#define HAVE_OS_TIMER 1
+typedef struct usbi_timer {
+	HANDLE hTimer;
+} usbi_timer_t;
+#define USBI_TIMER_OS_HANDLE(t)	((t)->hTimer)
+#define USBI_TIMER_POLL_EVENTS	0
+
+static inline int usbi_timer_valid(usbi_timer_t *timer)
+{
+	return timer->hTimer != NULL;
+}
+
+#endif
diff --git a/3rdparty/libusb/src/libusb/os/haiku_pollfs.cpp b/3rdparty/libusb/src/libusb/os/haiku_pollfs.cpp
new file mode 100644
index 00000000..f287f1fd
--- /dev/null
+++ b/3rdparty/libusb/src/libusb/os/haiku_pollfs.cpp
@@ -0,0 +1,321 @@
+/*
+ * Copyright 2007-2008, Haiku Inc. All rights reserved.
+ * Distributed under the terms of the MIT License.
+ *
+ * Authors:
+ *		Michael Lotz <mmlr@mlotz.ch>
+ */
+
+#include "haiku_usb.h"
+#include <cstdio>
+#include <Directory.h>
+#include <Entry.h>
+#include <Looper.h>
+#include <Messenger.h>
+#include <Node.h>
+#include <NodeMonitor.h>
+#include <Path.h>
+#include <cstring>
+
+class WatchedEntry {
+public:
+    WatchedEntry(BMessenger *, entry_ref *);
+    ~WatchedEntry();
+    bool EntryCreated(entry_ref *ref);
+    bool EntryRemoved(ino_t node);
+    bool InitCheck();
+
+private:
+    BMessenger   *fMessenger;
+    node_ref      fNode;
+    bool          fIsDirectory;
+    USBDevice    *fDevice;
+    WatchedEntry *fEntries;
+    WatchedEntry *fLink;
+    bool          fInitCheck;
+};
+
+class RosterLooper : public BLooper {
+public:
+    RosterLooper(USBRoster *);
+    void         Stop();
+    virtual void MessageReceived(BMessage *);
+    bool         InitCheck();
+
+private:
+    USBRoster    *fRoster;
+    WatchedEntry *fRoot;
+    BMessenger   *fMessenger;
+    bool          fInitCheck;
+};
+
+WatchedEntry::WatchedEntry(BMessenger *messenger, entry_ref *ref)
+    : fMessenger(messenger), fIsDirectory(false), fDevice(NULL), fEntries(NULL), fLink(NULL), fInitCheck(false) {
+    BEntry entry(ref);
+    entry.GetNodeRef(&fNode);
+
+    BDirectory directory;
+    if(entry.IsDirectory() && directory.SetTo(ref) >= B_OK) {
+        fIsDirectory = true;
+
+        while(directory.GetNextEntry(&entry) >= B_OK) {
+            if(entry.GetRef(ref) < B_OK)
+                continue;
+
+            WatchedEntry *child = new(std::nothrow) WatchedEntry(fMessenger, ref);
+            if(child == NULL)
+                continue;
+            if(child->InitCheck() == false) {
+                delete child;
+                continue;
+            }
+
+            child->fLink = fEntries;
+            fEntries     = child;
+        }
+
+        watch_node(&fNode, B_WATCH_DIRECTORY, *fMessenger);
+    }
+    else {
+        if(strncmp(ref->name, "raw", 3) == 0)
+            return;
+
+        BPath path, parent_path;
+        entry.GetPath(&path);
+        fDevice = new(std::nothrow) USBDevice(path.Path());
+        if(fDevice != NULL && fDevice->InitCheck() == true) {
+            // Add this new device to each active context's device list
+            struct libusb_context *ctx;
+            unsigned long          session_id = (unsigned long)&fDevice;
+
+            usbi_mutex_lock(&active_contexts_lock);
+            for_each_context(ctx) {
+                struct libusb_device *dev = usbi_get_device_by_session_id(ctx, session_id);
+                if(dev) {
+                    usbi_dbg(NULL, "using previously allocated device with location %lu", session_id);
+                    libusb_unref_device(dev);
+                    continue;
+                }
+                usbi_dbg(NULL, "allocating new device with location %lu", session_id);
+                dev = usbi_alloc_device(ctx, session_id);
+                if(!dev) {
+                    usbi_dbg(NULL, "device allocation failed");
+                    continue;
+                }
+                *((USBDevice **)usbi_get_device_priv(dev)) = fDevice;
+
+                // Calculate pseudo-device-address
+                int addr, tmp;
+                if(strcmp(path.Leaf(), "hub") == 0)
+                    tmp = 100;  // Random Number
+                else
+                    sscanf(path.Leaf(), "%d", &tmp);
+                addr = tmp + 1;
+                path.GetParent(&parent_path);
+                while(strcmp(parent_path.Leaf(), "usb") != 0) {
+                    sscanf(parent_path.Leaf(), "%d", &tmp);
+                    addr += tmp + 1;
+                    parent_path.GetParent(&parent_path);
+                }
+                sscanf(path.Path(), "/dev/bus/usb/%hhu", &dev->bus_number);
+                dev->device_address = addr - (dev->bus_number + 1);
+
+                static_assert(sizeof(dev->device_descriptor) == sizeof(usb_device_descriptor), "mismatch between libusb and OS device descriptor sizes");
+                memcpy(&dev->device_descriptor, fDevice->Descriptor(), LIBUSB_DT_DEVICE_SIZE);
+                usbi_localize_device_descriptor(&dev->device_descriptor);
+
+                if(usbi_sanitize_device(dev) < 0) {
+                    usbi_dbg(NULL, "device sanitization failed");
+                    libusb_unref_device(dev);
+                    continue;
+                }
+                usbi_connect_device(dev);
+            }
+            usbi_mutex_unlock(&active_contexts_lock);
+        }
+        else if(fDevice) {
+            delete fDevice;
+            fDevice = NULL;
+            return;
+        }
+    }
+    fInitCheck = true;
+}
+
+WatchedEntry::~WatchedEntry() {
+    if(fIsDirectory) {
+        watch_node(&fNode, B_STOP_WATCHING, *fMessenger);
+
+        WatchedEntry *child = fEntries;
+        while(child) {
+            WatchedEntry *next = child->fLink;
+            delete child;
+            child = next;
+        }
+    }
+
+    if(fDevice) {
+        // Remove this device from each active context's device list
+        struct libusb_context *ctx;
+        struct libusb_device  *dev;
+        unsigned long          session_id = (unsigned long)&fDevice;
+
+        usbi_mutex_lock(&active_contexts_lock);
+        for_each_context(ctx) {
+            dev = usbi_get_device_by_session_id(ctx, session_id);
+            if(dev != NULL) {
+                usbi_disconnect_device(dev);
+                libusb_unref_device(dev);
+            }
+            else {
+                usbi_dbg(ctx, "device with location %lu not found", session_id);
+            }
+        }
+        usbi_mutex_static_unlock(&active_contexts_lock);
+        delete fDevice;
+    }
+}
+
+bool WatchedEntry::EntryCreated(entry_ref *ref) {
+    if(!fIsDirectory)
+        return false;
+
+    if(ref->directory != fNode.node) {
+        WatchedEntry *child = fEntries;
+        while(child) {
+            if(child->EntryCreated(ref))
+                return true;
+            child = child->fLink;
+        }
+        return false;
+    }
+
+    WatchedEntry *child = new(std::nothrow) WatchedEntry(fMessenger, ref);
+    if(child == NULL)
+        return false;
+    child->fLink = fEntries;
+    fEntries     = child;
+    return true;
+}
+
+bool WatchedEntry::EntryRemoved(ino_t node) {
+    if(!fIsDirectory)
+        return false;
+
+    WatchedEntry *child     = fEntries;
+    WatchedEntry *lastChild = NULL;
+    while(child) {
+        if(child->fNode.node == node) {
+            if(lastChild)
+                lastChild->fLink = child->fLink;
+            else
+                fEntries = child->fLink;
+            delete child;
+            return true;
+        }
+
+        if(child->EntryRemoved(node))
+            return true;
+
+        lastChild = child;
+        child     = child->fLink;
+    }
+    return false;
+}
+
+bool WatchedEntry::InitCheck() {
+    return fInitCheck;
+}
+
+RosterLooper::RosterLooper(USBRoster *roster) : BLooper("LibusbRoster Looper"), fRoster(roster), fRoot(NULL), fMessenger(NULL), fInitCheck(false) {
+    BEntry entry("/dev/bus/usb");
+    if(!entry.Exists()) {
+        usbi_err(NULL, "usb_raw not published");
+        return;
+    }
+
+    Run();
+    fMessenger = new(std::nothrow) BMessenger(this);
+    if(fMessenger == NULL) {
+        usbi_err(NULL, "error creating BMessenger object");
+        return;
+    }
+
+    if(Lock()) {
+        entry_ref ref;
+        entry.GetRef(&ref);
+        fRoot = new(std::nothrow) WatchedEntry(fMessenger, &ref);
+        Unlock();
+        if(fRoot == NULL)
+            return;
+        if(fRoot->InitCheck() == false) {
+            delete fRoot;
+            fRoot = NULL;
+            return;
+        }
+    }
+    fInitCheck = true;
+}
+
+void RosterLooper::Stop() {
+    Lock();
+    delete fRoot;
+    delete fMessenger;
+    Quit();
+}
+
+void RosterLooper::MessageReceived(BMessage *message) {
+    int32 opcode;
+    if(message->FindInt32("opcode", &opcode) < B_OK)
+        return;
+
+    switch(opcode) {
+    case B_ENTRY_CREATED: {
+        dev_t       device;
+        ino_t       directory;
+        const char *name;
+        if(message->FindInt32("device", &device) < B_OK || message->FindInt64("directory", &directory) < B_OK || message->FindString("name", &name) < B_OK)
+            break;
+
+        entry_ref ref(device, directory, name);
+        fRoot->EntryCreated(&ref);
+        break;
+    }
+    case B_ENTRY_REMOVED: {
+        ino_t node;
+        if(message->FindInt64("node", &node) < B_OK)
+            break;
+        fRoot->EntryRemoved(node);
+        break;
+    }
+    }
+}
+
+bool RosterLooper::InitCheck() {
+    return fInitCheck;
+}
+
+USBRoster::USBRoster() : fLooper(NULL) {}
+
+USBRoster::~USBRoster() {
+    Stop();
+}
+
+int USBRoster::Start() {
+    if(fLooper == NULL) {
+        fLooper = new(std::nothrow) RosterLooper(this);
+        if(fLooper == NULL || ((RosterLooper *)fLooper)->InitCheck() == false) {
+            if(fLooper)
+                fLooper = NULL;
+            return LIBUSB_ERROR_OTHER;
+        }
+    }
+    return LIBUSB_SUCCESS;
+}
+
+void USBRoster::Stop() {
+    if(fLooper) {
+        ((RosterLooper *)fLooper)->Stop();
+        fLooper = NULL;
+    }
+}
diff --git a/3rdparty/libusb/src/libusb/os/haiku_usb.h b/3rdparty/libusb/src/libusb/os/haiku_usb.h
new file mode 100644
index 00000000..2dd5177c
--- /dev/null
+++ b/3rdparty/libusb/src/libusb/os/haiku_usb.h
@@ -0,0 +1,113 @@
+/*
+ * Haiku Backend for libusb
+ * Copyright © 2014 Akshay Jaggi <akshay1994.leo@gmail.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <List.h>
+#include <Locker.h>
+#include <Autolock.h>
+#include <USBKit.h>
+#include <map>
+#include "libusbi.h"
+#include "haiku_usb_raw.h"
+
+using namespace std;
+
+class USBDevice;
+class USBDeviceHandle;
+class USBTransfer;
+
+class USBDevice {
+public:
+						USBDevice(const char *);
+	virtual					~USBDevice();
+	const char*				Location() const;
+	uint8					CountConfigurations() const;
+	const usb_device_descriptor*		Descriptor() const;
+	const usb_configuration_descriptor*	ConfigurationDescriptor(uint8) const;
+	const usb_configuration_descriptor*	ActiveConfiguration() const;
+	uint8					EndpointToIndex(uint8) const;
+	uint8					EndpointToInterface(uint8) const;
+	int					ClaimInterface(uint8);
+	int					ReleaseInterface(uint8);
+	int					CheckInterfacesFree(uint8);
+	void					SetActiveConfiguration(uint8);
+	uint8					ActiveConfigurationIndex() const;
+	bool					InitCheck();
+private:
+	int					Initialise();
+	unsigned int				fClaimedInterfaces;	// Max Interfaces can be 32. Using a bitmask
+	usb_device_descriptor			fDeviceDescriptor;
+	unsigned char**				fConfigurationDescriptors;
+	uint8					fActiveConfiguration;
+	char*					fPath;
+	map<uint8,uint8>			fConfigToIndex;
+	map<uint8,uint8>*			fEndpointToIndex;
+	map<uint8,uint8>*			fEndpointToInterface;
+	bool					fInitCheck;
+};
+
+class USBDeviceHandle {
+public:
+				USBDeviceHandle(USBDevice *dev);
+	virtual			~USBDeviceHandle();
+	int			ClaimInterface(uint8);
+	int			ReleaseInterface(uint8);
+	int			SetConfiguration(uint8);
+	int			SetAltSetting(uint8, uint8);
+	int			ClearHalt(uint8);
+	status_t		SubmitTransfer(struct usbi_transfer *);
+	status_t		CancelTransfer(USBTransfer *);
+	bool			InitCheck();
+private:
+	int			fRawFD;
+	static status_t		TransfersThread(void *);
+	void			TransfersWorker();
+	USBDevice*		fUSBDevice;
+	unsigned int		fClaimedInterfaces;
+	BList			fTransfers;
+	BLocker			fTransfersLock;
+	sem_id			fTransfersSem;
+	thread_id		fTransfersThread;
+	bool			fInitCheck;
+};
+
+class USBTransfer {
+public:
+					USBTransfer(struct usbi_transfer *, USBDevice *);
+	virtual				~USBTransfer();
+	void				Do(int);
+	struct usbi_transfer*		UsbiTransfer();
+	void				SetCancelled();
+	bool				IsCancelled();
+private:
+	struct usbi_transfer*		fUsbiTransfer;
+	struct libusb_transfer*		fLibusbTransfer;
+	USBDevice*			fUSBDevice;
+	BLocker				fStatusLock;
+	bool				fCancelled;
+};
+
+class USBRoster {
+public:
+			USBRoster();
+	virtual		~USBRoster();
+	int		Start();
+	void		Stop();
+private:
+	void*		fLooper;
+};
diff --git a/3rdparty/libusb/src/libusb/os/haiku_usb_backend.cpp b/3rdparty/libusb/src/libusb/os/haiku_usb_backend.cpp
new file mode 100644
index 00000000..a77d9ff6
--- /dev/null
+++ b/3rdparty/libusb/src/libusb/os/haiku_usb_backend.cpp
@@ -0,0 +1,447 @@
+/*
+ * Haiku Backend for libusb
+ * Copyright © 2014 Akshay Jaggi <akshay1994.leo@gmail.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <unistd.h>
+#include <string.h>
+#include <stdlib.h>
+#include <new>
+#include <vector>
+
+#include "haiku_usb.h"
+
+static int _errno_to_libusb(int status) {
+    return status;
+}
+
+USBTransfer::USBTransfer(struct usbi_transfer *itransfer, USBDevice *device) {
+    fUsbiTransfer   = itransfer;
+    fLibusbTransfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+    fUSBDevice      = device;
+    fCancelled      = false;
+}
+
+USBTransfer::~USBTransfer() {}
+
+struct usbi_transfer *USBTransfer::UsbiTransfer() {
+    return fUsbiTransfer;
+}
+
+void USBTransfer::SetCancelled() {
+    fCancelled = true;
+}
+
+bool USBTransfer::IsCancelled() {
+    return fCancelled;
+}
+
+void USBTransfer::Do(int fRawFD) {
+    switch(fLibusbTransfer->type) {
+    case LIBUSB_TRANSFER_TYPE_CONTROL: {
+        struct libusb_control_setup *setup = (struct libusb_control_setup *)fLibusbTransfer->buffer;
+        usb_raw_command              command;
+        command.control.request_type = setup->bmRequestType;
+        command.control.request      = setup->bRequest;
+        command.control.value        = setup->wValue;
+        command.control.index        = setup->wIndex;
+        command.control.length       = setup->wLength;
+        command.control.data         = fLibusbTransfer->buffer + LIBUSB_CONTROL_SETUP_SIZE;
+        if(fCancelled)
+            break;
+        if(ioctl(fRawFD, B_USB_RAW_COMMAND_CONTROL_TRANSFER, &command, sizeof(command)) || command.control.status != B_USB_RAW_STATUS_SUCCESS) {
+            fUsbiTransfer->transferred = -1;
+            usbi_err(TRANSFER_CTX(fLibusbTransfer), "failed control transfer");
+            break;
+        }
+        fUsbiTransfer->transferred = command.control.length;
+    } break;
+    case LIBUSB_TRANSFER_TYPE_BULK:
+    case LIBUSB_TRANSFER_TYPE_INTERRUPT: {
+        usb_raw_command command;
+        command.transfer.interface = fUSBDevice->EndpointToInterface(fLibusbTransfer->endpoint);
+        command.transfer.endpoint  = fUSBDevice->EndpointToIndex(fLibusbTransfer->endpoint);
+        command.transfer.data      = fLibusbTransfer->buffer;
+        command.transfer.length    = fLibusbTransfer->length;
+        if(fCancelled)
+            break;
+        if(fLibusbTransfer->type == LIBUSB_TRANSFER_TYPE_BULK) {
+            if(ioctl(fRawFD, B_USB_RAW_COMMAND_BULK_TRANSFER, &command, sizeof(command)) || command.transfer.status != B_USB_RAW_STATUS_SUCCESS) {
+                fUsbiTransfer->transferred = -1;
+                usbi_err(TRANSFER_CTX(fLibusbTransfer), "failed bulk transfer");
+                break;
+            }
+        }
+        else {
+            if(ioctl(fRawFD, B_USB_RAW_COMMAND_INTERRUPT_TRANSFER, &command, sizeof(command)) || command.transfer.status != B_USB_RAW_STATUS_SUCCESS) {
+                fUsbiTransfer->transferred = -1;
+                usbi_err(TRANSFER_CTX(fLibusbTransfer), "failed interrupt transfer");
+                break;
+            }
+        }
+        fUsbiTransfer->transferred = command.transfer.length;
+    } break;
+    // IsochronousTransfers not tested
+    case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS: {
+        usb_raw_command command;
+        command.isochronous.interface    = fUSBDevice->EndpointToInterface(fLibusbTransfer->endpoint);
+        command.isochronous.endpoint     = fUSBDevice->EndpointToIndex(fLibusbTransfer->endpoint);
+        command.isochronous.data         = fLibusbTransfer->buffer;
+        command.isochronous.length       = fLibusbTransfer->length;
+        command.isochronous.packet_count = fLibusbTransfer->num_iso_packets;
+        int                        i;
+        usb_iso_packet_descriptor *packetDescriptors = new usb_iso_packet_descriptor[fLibusbTransfer->num_iso_packets];
+        for(i = 0; i < fLibusbTransfer->num_iso_packets; i++) {
+            if((fLibusbTransfer->iso_packet_desc[i]).length > (unsigned int)INT16_MAX) {
+                fUsbiTransfer->transferred = -1;
+                usbi_err(TRANSFER_CTX(fLibusbTransfer), "failed isochronous transfer");
+                break;
+            }
+            packetDescriptors[i].request_length = (int16)(fLibusbTransfer->iso_packet_desc[i]).length;
+        }
+        if(i < fLibusbTransfer->num_iso_packets)
+            break;  // TODO Handle this error
+        command.isochronous.packet_descriptors = packetDescriptors;
+        if(fCancelled)
+            break;
+        if(ioctl(fRawFD, B_USB_RAW_COMMAND_ISOCHRONOUS_TRANSFER, &command, sizeof(command)) || command.isochronous.status != B_USB_RAW_STATUS_SUCCESS) {
+            fUsbiTransfer->transferred = -1;
+            usbi_err(TRANSFER_CTX(fLibusbTransfer), "failed isochronous transfer");
+            break;
+        }
+        for(i = 0; i < fLibusbTransfer->num_iso_packets; i++) {
+            (fLibusbTransfer->iso_packet_desc[i]).actual_length = packetDescriptors[i].actual_length;
+            switch(packetDescriptors[i].status) {
+            case B_OK:
+                (fLibusbTransfer->iso_packet_desc[i]).status = LIBUSB_TRANSFER_COMPLETED;
+                break;
+            default:
+                (fLibusbTransfer->iso_packet_desc[i]).status = LIBUSB_TRANSFER_ERROR;
+                break;
+            }
+        }
+        delete[] packetDescriptors;
+        // Do we put the length of transfer here, for isochronous transfers?
+        fUsbiTransfer->transferred = command.transfer.length;
+    } break;
+    default:
+        usbi_err(TRANSFER_CTX(fLibusbTransfer), "Unknown type of transfer");
+    }
+}
+
+bool USBDeviceHandle::InitCheck() {
+    return fInitCheck;
+}
+
+status_t USBDeviceHandle::TransfersThread(void *self) {
+    USBDeviceHandle *handle = (USBDeviceHandle *)self;
+    handle->TransfersWorker();
+    return B_OK;
+}
+
+void USBDeviceHandle::TransfersWorker() {
+    while(true) {
+        status_t status = acquire_sem(fTransfersSem);
+        if(status == B_BAD_SEM_ID)
+            break;
+        if(status == B_INTERRUPTED)
+            continue;
+        fTransfersLock.Lock();
+        USBTransfer *fPendingTransfer = (USBTransfer *)fTransfers.RemoveItem((int32)0);
+        fTransfersLock.Unlock();
+        fPendingTransfer->Do(fRawFD);
+        usbi_signal_transfer_completion(fPendingTransfer->UsbiTransfer());
+    }
+}
+
+status_t USBDeviceHandle::SubmitTransfer(struct usbi_transfer *itransfer) {
+    USBTransfer *transfer                                = new USBTransfer(itransfer, fUSBDevice);
+    *((USBTransfer **)usbi_get_transfer_priv(itransfer)) = transfer;
+    BAutolock locker(fTransfersLock);
+    fTransfers.AddItem(transfer);
+    release_sem(fTransfersSem);
+    return LIBUSB_SUCCESS;
+}
+
+status_t USBDeviceHandle::CancelTransfer(USBTransfer *transfer) {
+    transfer->SetCancelled();
+    fTransfersLock.Lock();
+    bool removed = fTransfers.RemoveItem(transfer);
+    fTransfersLock.Unlock();
+    if(removed)
+        usbi_signal_transfer_completion(transfer->UsbiTransfer());
+    return LIBUSB_SUCCESS;
+}
+
+USBDeviceHandle::USBDeviceHandle(USBDevice *dev) : fUSBDevice(dev), fClaimedInterfaces(0), fTransfersThread(-1), fInitCheck(false) {
+    fRawFD = open(dev->Location(), O_RDWR | O_CLOEXEC);
+    if(fRawFD < 0) {
+        usbi_err(NULL, "failed to open device");
+        return;
+    }
+    fTransfersSem    = create_sem(0, "Transfers Queue Sem");
+    fTransfersThread = spawn_thread(TransfersThread, "Transfer Worker", B_NORMAL_PRIORITY, this);
+    resume_thread(fTransfersThread);
+    fInitCheck = true;
+}
+
+USBDeviceHandle::~USBDeviceHandle() {
+    if(fRawFD > 0)
+        close(fRawFD);
+    for(int i = 0; i < 32; i++) {
+        if(fClaimedInterfaces & (1U << i))
+            ReleaseInterface(i);
+    }
+    delete_sem(fTransfersSem);
+    if(fTransfersThread > 0)
+        wait_for_thread(fTransfersThread, NULL);
+}
+
+int USBDeviceHandle::ClaimInterface(uint8 inumber) {
+    int status = fUSBDevice->ClaimInterface(inumber);
+    if(status == LIBUSB_SUCCESS)
+        fClaimedInterfaces |= (1U << inumber);
+    return status;
+}
+
+int USBDeviceHandle::ReleaseInterface(uint8 inumber) {
+    fUSBDevice->ReleaseInterface(inumber);
+    fClaimedInterfaces &= ~(1U << inumber);
+    return LIBUSB_SUCCESS;
+}
+
+int USBDeviceHandle::SetConfiguration(uint8 config) {
+    int config_index = fUSBDevice->CheckInterfacesFree(config);
+    if(config_index == LIBUSB_ERROR_BUSY || config_index == LIBUSB_ERROR_NOT_FOUND)
+        return config_index;
+    usb_raw_command command;
+    command.config.config_index = config_index;
+    if(ioctl(fRawFD, B_USB_RAW_COMMAND_SET_CONFIGURATION, &command, sizeof(command)) || command.config.status != B_USB_RAW_STATUS_SUCCESS) {
+        return _errno_to_libusb(command.config.status);
+    }
+    fUSBDevice->SetActiveConfiguration((uint8)config_index);
+    return LIBUSB_SUCCESS;
+}
+
+int USBDeviceHandle::SetAltSetting(uint8 inumber, uint8 alt) {
+    usb_raw_command command;
+    command.alternate.config_index    = fUSBDevice->ActiveConfigurationIndex();
+    command.alternate.interface_index = inumber;
+    if(ioctl(fRawFD, B_USB_RAW_COMMAND_GET_ACTIVE_ALT_INTERFACE_INDEX, &command, sizeof(command)) || command.alternate.status != B_USB_RAW_STATUS_SUCCESS) {
+        usbi_err(NULL, "Error retrieving active alternate interface");
+        return _errno_to_libusb(command.alternate.status);
+    }
+    if(command.alternate.alternate_info == (uint32)alt) {
+        usbi_dbg(NULL, "Setting alternate interface successful");
+        return LIBUSB_SUCCESS;
+    }
+    command.alternate.alternate_info = alt;
+    if(ioctl(fRawFD, B_USB_RAW_COMMAND_SET_ALT_INTERFACE, &command, sizeof(command))
+       || command.alternate.status != B_USB_RAW_STATUS_SUCCESS) {  // IF IOCTL FAILS DEVICE DISCONNECTED PROBABLY
+        usbi_err(NULL, "Error setting alternate interface");
+        return _errno_to_libusb(command.alternate.status);
+    }
+    usbi_dbg(NULL, "Setting alternate interface successful");
+    return LIBUSB_SUCCESS;
+}
+
+int USBDeviceHandle::ClearHalt(uint8 endpoint) {
+    usb_raw_command command;
+    command.control.request_type = USB_REQTYPE_ENDPOINT_OUT;
+    command.control.request      = USB_REQUEST_CLEAR_FEATURE;
+    command.control.value        = USB_FEATURE_ENDPOINT_HALT;
+    command.control.index        = endpoint;
+    command.control.length       = 0;
+
+    if(ioctl(fRawFD, B_USB_RAW_COMMAND_CONTROL_TRANSFER, &command, sizeof(command)) || command.control.status != B_USB_RAW_STATUS_SUCCESS) {
+        return _errno_to_libusb(command.control.status);
+    }
+    return LIBUSB_SUCCESS;
+}
+
+USBDevice::USBDevice(const char *path)
+    : fClaimedInterfaces(0),
+      fConfigurationDescriptors(NULL),
+      fActiveConfiguration(0),  // 0?
+      fPath(NULL),
+      fEndpointToIndex(NULL),
+      fEndpointToInterface(NULL),
+      fInitCheck(false) {
+    fPath = strdup(path);
+    Initialise();
+}
+
+USBDevice::~USBDevice() {
+    free(fPath);
+    if(fConfigurationDescriptors) {
+        for(uint8 i = 0; i < fDeviceDescriptor.num_configurations; i++) {
+            if(fConfigurationDescriptors[i])
+                delete fConfigurationDescriptors[i];
+        }
+        delete[] fConfigurationDescriptors;
+    }
+    if(fEndpointToIndex)
+        delete[] fEndpointToIndex;
+    if(fEndpointToInterface)
+        delete[] fEndpointToInterface;
+}
+
+bool USBDevice::InitCheck() {
+    return fInitCheck;
+}
+
+const char *USBDevice::Location() const {
+    return fPath;
+}
+
+uint8 USBDevice::CountConfigurations() const {
+    return fDeviceDescriptor.num_configurations;
+}
+
+const usb_device_descriptor *USBDevice::Descriptor() const {
+    return &fDeviceDescriptor;
+}
+
+const usb_configuration_descriptor *USBDevice::ConfigurationDescriptor(uint8 index) const {
+    if(index > CountConfigurations())
+        return NULL;
+    return (usb_configuration_descriptor *)fConfigurationDescriptors[index];
+}
+
+const usb_configuration_descriptor *USBDevice::ActiveConfiguration() const {
+    return (usb_configuration_descriptor *)fConfigurationDescriptors[fActiveConfiguration];
+}
+
+uint8 USBDevice::ActiveConfigurationIndex() const {
+    return fActiveConfiguration;
+}
+
+int USBDevice::ClaimInterface(uint8 interface) {
+    if(interface > ActiveConfiguration()->number_interfaces)
+        return LIBUSB_ERROR_NOT_FOUND;
+    if(fClaimedInterfaces & (1U << interface))
+        return LIBUSB_ERROR_BUSY;
+    fClaimedInterfaces |= (1U << interface);
+    return LIBUSB_SUCCESS;
+}
+
+int USBDevice::ReleaseInterface(uint8 interface) {
+    fClaimedInterfaces &= ~(1U << interface);
+    return LIBUSB_SUCCESS;
+}
+
+int USBDevice::CheckInterfacesFree(uint8 config) {
+    if(fConfigToIndex.count(config) == 0)
+        return LIBUSB_ERROR_NOT_FOUND;
+    if(fClaimedInterfaces == 0)
+        return fConfigToIndex[config];
+    return LIBUSB_ERROR_BUSY;
+}
+
+void USBDevice::SetActiveConfiguration(uint8 config_index) {
+    fActiveConfiguration = config_index;
+}
+
+uint8 USBDevice::EndpointToIndex(uint8 address) const {
+    return fEndpointToIndex[fActiveConfiguration][address];
+}
+
+uint8 USBDevice::EndpointToInterface(uint8 address) const {
+    return fEndpointToInterface[fActiveConfiguration][address];
+}
+
+int USBDevice::Initialise()  // Do we need more error checking, etc? How to report?
+{
+    int fRawFD = open(fPath, O_RDWR | O_CLOEXEC);
+    if(fRawFD < 0)
+        return B_ERROR;
+    usb_raw_command command;
+    command.device.descriptor = &fDeviceDescriptor;
+    if(ioctl(fRawFD, B_USB_RAW_COMMAND_GET_DEVICE_DESCRIPTOR, &command, sizeof(command)) || command.device.status != B_USB_RAW_STATUS_SUCCESS) {
+        close(fRawFD);
+        return B_ERROR;
+    }
+
+    fConfigurationDescriptors = new(std::nothrow) unsigned char *[fDeviceDescriptor.num_configurations];
+    fEndpointToIndex          = new(std::nothrow) map<uint8, uint8>[fDeviceDescriptor.num_configurations];
+    fEndpointToInterface      = new(std::nothrow) map<uint8, uint8>[fDeviceDescriptor.num_configurations];
+    for(uint8 i = 0; i < fDeviceDescriptor.num_configurations; i++) {
+        usb_configuration_descriptor tmp_config;
+        command.config.descriptor   = &tmp_config;
+        command.config.config_index = i;
+        if(ioctl(fRawFD, B_USB_RAW_COMMAND_GET_CONFIGURATION_DESCRIPTOR, &command, sizeof(command)) || command.config.status != B_USB_RAW_STATUS_SUCCESS) {
+            usbi_err(NULL, "failed retrieving configuration descriptor");
+            close(fRawFD);
+            return B_ERROR;
+        }
+        fConfigToIndex[tmp_config.configuration_value] = i;
+        fConfigurationDescriptors[i]                   = new(std::nothrow) unsigned char[tmp_config.total_length];
+
+        command.config_etc.descriptor   = (usb_configuration_descriptor *)fConfigurationDescriptors[i];
+        command.config_etc.length       = tmp_config.total_length;
+        command.config_etc.config_index = i;
+        if(ioctl(fRawFD, B_USB_RAW_COMMAND_GET_CONFIGURATION_DESCRIPTOR_ETC, &command, sizeof(command))
+           || command.config_etc.status != B_USB_RAW_STATUS_SUCCESS) {
+            usbi_err(NULL, "failed retrieving full configuration descriptor");
+            close(fRawFD);
+            return B_ERROR;
+        }
+
+        for(uint8 j = 0; j < tmp_config.number_interfaces; j++) {
+            command.alternate.config_index    = i;
+            command.alternate.interface_index = j;
+            if(ioctl(fRawFD, B_USB_RAW_COMMAND_GET_ALT_INTERFACE_COUNT, &command, sizeof(command)) || command.config.status != B_USB_RAW_STATUS_SUCCESS) {
+                usbi_err(NULL, "failed retrieving number of alternate interfaces");
+                close(fRawFD);
+                return B_ERROR;
+            }
+            uint8 num_alternate = (uint8)command.alternate.alternate_info;
+            for(uint8 k = 0; k < num_alternate; k++) {
+                usb_interface_descriptor tmp_interface;
+                command.interface_etc.config_index    = i;
+                command.interface_etc.interface_index = j;
+                command.interface_etc.alternate_index = k;
+                command.interface_etc.descriptor      = &tmp_interface;
+                if(ioctl(fRawFD, B_USB_RAW_COMMAND_GET_INTERFACE_DESCRIPTOR_ETC, &command, sizeof(command))
+                   || command.config.status != B_USB_RAW_STATUS_SUCCESS) {
+                    usbi_err(NULL, "failed retrieving interface descriptor");
+                    close(fRawFD);
+                    return B_ERROR;
+                }
+                for(uint8 l = 0; l < tmp_interface.num_endpoints; l++) {
+                    usb_endpoint_descriptor tmp_endpoint;
+                    command.endpoint_etc.config_index    = i;
+                    command.endpoint_etc.interface_index = j;
+                    command.endpoint_etc.alternate_index = k;
+                    command.endpoint_etc.endpoint_index  = l;
+                    command.endpoint_etc.descriptor      = &tmp_endpoint;
+                    if(ioctl(fRawFD, B_USB_RAW_COMMAND_GET_ENDPOINT_DESCRIPTOR_ETC, &command, sizeof(command))
+                       || command.config.status != B_USB_RAW_STATUS_SUCCESS) {
+                        usbi_err(NULL, "failed retrieving endpoint descriptor");
+                        close(fRawFD);
+                        return B_ERROR;
+                    }
+                    fEndpointToIndex[i][tmp_endpoint.endpoint_address]     = l;
+                    fEndpointToInterface[i][tmp_endpoint.endpoint_address] = j;
+                }
+            }
+        }
+    }
+    close(fRawFD);
+    fInitCheck = true;
+    return B_OK;
+}
diff --git a/3rdparty/libusb/src/libusb/os/haiku_usb_raw.cpp b/3rdparty/libusb/src/libusb/os/haiku_usb_raw.cpp
new file mode 100644
index 00000000..bce706cd
--- /dev/null
+++ b/3rdparty/libusb/src/libusb/os/haiku_usb_raw.cpp
@@ -0,0 +1,231 @@
+/*
+ * Haiku Backend for libusb
+ * Copyright © 2014 Akshay Jaggi <akshay1994.leo@gmail.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+
+#include <unistd.h>
+#include <string.h>
+#include <stdlib.h>
+#include <new>
+#include <vector>
+
+#include "haiku_usb.h"
+
+USBRoster gUsbRoster;
+int32 gInitCount = 0;
+
+static int haiku_get_config_descriptor(struct libusb_device *, uint8_t,
+    void *, size_t);
+
+static int
+haiku_init(struct libusb_context *ctx)
+{
+	UNUSED(ctx);
+	if (atomic_add(&gInitCount, 1) == 0)
+		return gUsbRoster.Start();
+	return LIBUSB_SUCCESS;
+}
+
+static void
+haiku_exit(struct libusb_context *ctx)
+{
+	UNUSED(ctx);
+	if (atomic_add(&gInitCount, -1) == 1)
+		gUsbRoster.Stop();
+}
+
+static int
+haiku_open(struct libusb_device_handle *dev_handle)
+{
+	USBDevice *dev = *((USBDevice **)usbi_get_device_priv(dev_handle->dev));
+	USBDeviceHandle *handle = new(std::nothrow) USBDeviceHandle(dev);
+	if (handle == NULL)
+		return LIBUSB_ERROR_NO_MEM;
+	if (handle->InitCheck() == false) {
+		delete handle;
+		return LIBUSB_ERROR_NO_DEVICE;
+	}
+	*((USBDeviceHandle **)usbi_get_device_handle_priv(dev_handle)) = handle;
+	return LIBUSB_SUCCESS;
+}
+
+static void
+haiku_close(struct libusb_device_handle *dev_handle)
+{
+	USBDeviceHandle **pHandle = (USBDeviceHandle **)usbi_get_device_handle_priv(dev_handle);
+	USBDeviceHandle *handle = *pHandle;
+	if (handle == NULL)
+		return;
+	delete handle;
+	*pHandle = NULL;
+}
+
+static int
+haiku_get_active_config_descriptor(struct libusb_device *device, void *buffer, size_t len)
+{
+	USBDevice *dev = *((USBDevice **)usbi_get_device_priv(device));
+	return haiku_get_config_descriptor(device, dev->ActiveConfigurationIndex(), buffer, len);
+}
+
+static int
+haiku_get_config_descriptor(struct libusb_device *device, uint8_t config_index, void *buffer, size_t len)
+{
+	USBDevice *dev = *((USBDevice **)usbi_get_device_priv(device));
+	const usb_configuration_descriptor *config = dev->ConfigurationDescriptor(config_index);
+	if (config == NULL) {
+		usbi_err(DEVICE_CTX(device), "failed getting configuration descriptor");
+		return LIBUSB_ERROR_IO;
+	}
+	if (len > config->total_length) {
+		len = config->total_length;
+	}
+	memcpy(buffer, config, len);
+	return len;
+}
+
+static int
+haiku_set_configuration(struct libusb_device_handle *dev_handle, int config)
+{
+	USBDeviceHandle *handle= *((USBDeviceHandle **)usbi_get_device_handle_priv(dev_handle));
+	if (config <= 0)
+		return LIBUSB_ERROR_NOT_SUPPORTED;	// cannot unconfigure
+	return handle->SetConfiguration((uint8)config);
+}
+
+static int
+haiku_claim_interface(struct libusb_device_handle *dev_handle, uint8_t interface_number)
+{
+	USBDeviceHandle *handle = *((USBDeviceHandle **)usbi_get_device_handle_priv(dev_handle));
+	return handle->ClaimInterface(interface_number);
+}
+
+static int
+haiku_set_altsetting(struct libusb_device_handle *dev_handle, uint8_t interface_number, uint8_t altsetting)
+{
+	USBDeviceHandle *handle = *((USBDeviceHandle **)usbi_get_device_handle_priv(dev_handle));
+	return handle->SetAltSetting(interface_number, altsetting);
+}
+
+static int
+haiku_clear_halt(struct libusb_device_handle *dev_handle, unsigned char endpoint)
+{
+	USBDeviceHandle *handle = *((USBDeviceHandle **)usbi_get_device_handle_priv(dev_handle));
+	return handle->ClearHalt(endpoint);
+}
+
+static int
+haiku_release_interface(struct libusb_device_handle *dev_handle, uint8_t interface_number)
+{
+	USBDeviceHandle *handle = *((USBDeviceHandle **)usbi_get_device_handle_priv(dev_handle));
+	haiku_set_altsetting(dev_handle, interface_number, 0);
+	return handle->ReleaseInterface(interface_number);
+}
+
+static int
+haiku_submit_transfer(struct usbi_transfer *itransfer)
+{
+	struct libusb_transfer *fLibusbTransfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+	USBDeviceHandle *fDeviceHandle = *((USBDeviceHandle **)usbi_get_device_handle_priv(fLibusbTransfer->dev_handle));
+	return fDeviceHandle->SubmitTransfer(itransfer);
+}
+
+static int
+haiku_cancel_transfer(struct usbi_transfer *itransfer)
+{
+	struct libusb_transfer *fLibusbTransfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+	USBDeviceHandle *fDeviceHandle = *((USBDeviceHandle **)usbi_get_device_handle_priv(fLibusbTransfer->dev_handle));
+	return fDeviceHandle->CancelTransfer(*((USBTransfer **)usbi_get_transfer_priv(itransfer)));
+}
+
+static int
+haiku_handle_transfer_completion(struct usbi_transfer *itransfer)
+{
+	USBTransfer **pTransfer = (USBTransfer **)usbi_get_transfer_priv(itransfer);
+	USBTransfer *transfer = *pTransfer;
+
+	usbi_mutex_lock(&itransfer->lock);
+	if (transfer->IsCancelled()) {
+		delete transfer;
+		*pTransfer = NULL;
+		usbi_mutex_unlock(&itransfer->lock);
+		if (itransfer->transferred < 0)
+			itransfer->transferred = 0;
+		return usbi_handle_transfer_cancellation(itransfer);
+	}
+	libusb_transfer_status status = LIBUSB_TRANSFER_COMPLETED;
+	if (itransfer->transferred < 0) {
+		usbi_err(ITRANSFER_CTX(itransfer), "error in transfer");
+		status = LIBUSB_TRANSFER_ERROR;
+		itransfer->transferred = 0;
+	}
+	delete transfer;
+	*pTransfer = NULL;
+	usbi_mutex_unlock(&itransfer->lock);
+	return usbi_handle_transfer_completion(itransfer, status);
+}
+
+const struct usbi_os_backend usbi_backend = {
+	/*.name =*/ "Haiku usbfs",
+	/*.caps =*/ 0,
+	/*.init =*/ haiku_init,
+	/*.exit =*/ haiku_exit,
+	/*.set_option =*/ NULL,
+	/*.get_device_list =*/ NULL,
+	/*.hotplug_poll =*/ NULL,
+	/*.wrap_sys_device =*/ NULL,
+	/*.open =*/ haiku_open,
+	/*.close =*/ haiku_close,
+
+	/*.get_active_config_descriptor =*/ haiku_get_active_config_descriptor,
+	/*.get_config_descriptor =*/ haiku_get_config_descriptor,
+	/*.get_config_descriptor_by_value =*/ NULL,
+
+	/*.get_configuration =*/ NULL,
+	/*.set_configuration =*/ haiku_set_configuration,
+
+	/*.claim_interface =*/ haiku_claim_interface,
+	/*.release_interface =*/ haiku_release_interface,
+	/*.set_interface_altsetting =*/ haiku_set_altsetting,
+
+	/*.clear_halt =*/ haiku_clear_halt,
+	/*.reset_device =*/ NULL,
+
+	/*.alloc_streams =*/ NULL,
+	/*.free_streams =*/ NULL,
+
+	/*.dev_mem_alloc =*/ NULL,
+	/*.dev_mem_free =*/ NULL,
+
+	/*.kernel_driver_active =*/ NULL,
+	/*.detach_kernel_driver =*/ NULL,
+	/*.attach_kernel_driver =*/ NULL,
+
+	/*.destroy_device =*/ NULL,
+
+	/*.submit_transfer =*/ haiku_submit_transfer,
+	/*.cancel_transfer =*/ haiku_cancel_transfer,
+	/*.clear_transfer_priv =*/ NULL,
+
+	/*.handle_events =*/ NULL,
+	/*.handle_transfer_completion =*/ haiku_handle_transfer_completion,
+
+	/*.context_priv_size =*/ 0,
+	/*.device_priv_size =*/ sizeof(USBDevice *),
+	/*.device_handle_priv_size =*/ sizeof(USBDeviceHandle *),
+	/*.transfer_priv_size =*/ sizeof(USBTransfer *),
+};
diff --git a/3rdparty/libusb/src/libusb/os/haiku_usb_raw.h b/3rdparty/libusb/src/libusb/os/haiku_usb_raw.h
new file mode 100644
index 00000000..d371f018
--- /dev/null
+++ b/3rdparty/libusb/src/libusb/os/haiku_usb_raw.h
@@ -0,0 +1,188 @@
+/*
+ * Copyright 2006-2008, Haiku Inc. All rights reserved.
+ * Distributed under the terms of the MIT License.
+ */
+
+#ifndef _USB_RAW_H_
+#define _USB_RAW_H_
+
+#include <USB3.h>
+
+#define B_USB_RAW_PROTOCOL_VERSION	0x0015
+#define B_USB_RAW_ACTIVE_ALTERNATE	0xffffffff
+
+typedef enum {
+	B_USB_RAW_COMMAND_GET_VERSION = 0x1000,
+
+	B_USB_RAW_COMMAND_GET_DEVICE_DESCRIPTOR = 0x2000,
+	B_USB_RAW_COMMAND_GET_CONFIGURATION_DESCRIPTOR,
+	B_USB_RAW_COMMAND_GET_INTERFACE_DESCRIPTOR,
+	B_USB_RAW_COMMAND_GET_ENDPOINT_DESCRIPTOR,
+	B_USB_RAW_COMMAND_GET_STRING_DESCRIPTOR,
+	B_USB_RAW_COMMAND_GET_GENERIC_DESCRIPTOR,
+	B_USB_RAW_COMMAND_GET_ALT_INTERFACE_COUNT,
+	B_USB_RAW_COMMAND_GET_ACTIVE_ALT_INTERFACE_INDEX,
+	B_USB_RAW_COMMAND_GET_INTERFACE_DESCRIPTOR_ETC,
+	B_USB_RAW_COMMAND_GET_ENDPOINT_DESCRIPTOR_ETC,
+	B_USB_RAW_COMMAND_GET_GENERIC_DESCRIPTOR_ETC,
+	B_USB_RAW_COMMAND_GET_CONFIGURATION_DESCRIPTOR_ETC,
+
+	B_USB_RAW_COMMAND_SET_CONFIGURATION = 0x3000,
+	B_USB_RAW_COMMAND_SET_FEATURE,
+	B_USB_RAW_COMMAND_CLEAR_FEATURE,
+	B_USB_RAW_COMMAND_GET_STATUS,
+	B_USB_RAW_COMMAND_GET_DESCRIPTOR,
+	B_USB_RAW_COMMAND_SET_ALT_INTERFACE,
+
+	B_USB_RAW_COMMAND_CONTROL_TRANSFER = 0x4000,
+	B_USB_RAW_COMMAND_INTERRUPT_TRANSFER,
+	B_USB_RAW_COMMAND_BULK_TRANSFER,
+	B_USB_RAW_COMMAND_ISOCHRONOUS_TRANSFER
+} usb_raw_command_id;
+
+
+typedef enum {
+	B_USB_RAW_STATUS_SUCCESS = 0,
+
+	B_USB_RAW_STATUS_FAILED,
+	B_USB_RAW_STATUS_ABORTED,
+	B_USB_RAW_STATUS_STALLED,
+	B_USB_RAW_STATUS_CRC_ERROR,
+	B_USB_RAW_STATUS_TIMEOUT,
+
+	B_USB_RAW_STATUS_INVALID_CONFIGURATION,
+	B_USB_RAW_STATUS_INVALID_INTERFACE,
+	B_USB_RAW_STATUS_INVALID_ENDPOINT,
+	B_USB_RAW_STATUS_INVALID_STRING,
+
+	B_USB_RAW_STATUS_NO_MEMORY
+} usb_raw_command_status;
+
+
+typedef union {
+	struct {
+		status_t status;
+	} version;
+
+	struct {
+		status_t status;
+		usb_device_descriptor *descriptor;
+	} device;
+
+	struct {
+		status_t status;
+		usb_configuration_descriptor *descriptor;
+		uint32 config_index;
+	} config;
+
+	struct {
+		status_t status;
+		usb_configuration_descriptor *descriptor;
+		uint32 config_index;
+		size_t length;
+	} config_etc;
+
+	struct {
+		status_t status;
+		uint32 alternate_info;
+		uint32 config_index;
+		uint32 interface_index;
+	} alternate;
+
+	struct {
+		status_t status;
+		usb_interface_descriptor *descriptor;
+		uint32 config_index;
+		uint32 interface_index;
+	} interface;
+
+	struct {
+		status_t status;
+		usb_interface_descriptor *descriptor;
+		uint32 config_index;
+		uint32 interface_index;
+		uint32 alternate_index;
+	} interface_etc;
+
+	struct {
+		status_t status;
+		usb_endpoint_descriptor *descriptor;
+		uint32 config_index;
+		uint32 interface_index;
+		uint32 endpoint_index;
+	} endpoint;
+
+	struct {
+		status_t status;
+		usb_endpoint_descriptor *descriptor;
+		uint32 config_index;
+		uint32 interface_index;
+		uint32 alternate_index;
+		uint32 endpoint_index;
+	} endpoint_etc;
+
+	struct {
+		status_t status;
+		usb_descriptor *descriptor;
+		uint32 config_index;
+		uint32 interface_index;
+		uint32 generic_index;
+		size_t length;
+	} generic;
+
+	struct {
+		status_t status;
+		usb_descriptor *descriptor;
+		uint32 config_index;
+		uint32 interface_index;
+		uint32 alternate_index;
+		uint32 generic_index;
+		size_t length;
+	} generic_etc;
+
+	struct {
+		status_t status;
+		usb_string_descriptor *descriptor;
+		uint32 string_index;
+		size_t length;
+	} string;
+
+	struct {
+		status_t status;
+		uint8 type;
+		uint8 index;
+		uint16 language_id;
+		void *data;
+		size_t length;
+	} descriptor;
+
+	struct {
+		status_t status;
+		uint8 request_type;
+		uint8 request;
+		uint16 value;
+		uint16 index;
+		uint16 length;
+		void *data;
+	} control;
+
+	struct {
+		status_t status;
+		uint32 interface;
+		uint32 endpoint;
+		void *data;
+		size_t length;
+	} transfer;
+
+	struct {
+		status_t status;
+		uint32 interface;
+		uint32 endpoint;
+		void *data;
+		size_t length;
+		usb_iso_packet_descriptor *packet_descriptors;
+		uint32 packet_count;
+	} isochronous;
+} usb_raw_command;
+
+#endif // _USB_RAW_H_
diff --git a/3rdparty/libusb/src/libusb/os/linux_netlink.c b/3rdparty/libusb/src/libusb/os/linux_netlink.c
new file mode 100644
index 00000000..6313af40
--- /dev/null
+++ b/3rdparty/libusb/src/libusb/os/linux_netlink.c
@@ -0,0 +1,389 @@
+/* -*- Mode: C; c-basic-offset:8 ; indent-tabs-mode:t -*- */
+/*
+ * Linux usbfs backend for libusb
+ * Copyright (C) 2007-2009 Daniel Drake <dsd@gentoo.org>
+ * Copyright (c) 2001 Johannes Erdfelt <johannes@erdfelt.com>
+ * Copyright (c) 2013 Nathan Hjelm <hjelmn@mac.com>
+ * Copyright (c) 2016 Chris Dickens <christopher.a.dickens@gmail.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "libusbi.h"
+#include "linux_usbfs.h"
+
+#include <errno.h>
+#include <fcntl.h>
+#include <poll.h>
+#include <pthread.h>
+#include <string.h>
+#include <unistd.h>
+
+#ifdef HAVE_ASM_TYPES_H
+#include <asm/types.h>
+#endif
+#include <sys/socket.h>
+#include <linux/netlink.h>
+
+#define NL_GROUP_KERNEL 1
+
+#ifndef SOCK_CLOEXEC
+#define SOCK_CLOEXEC 0
+#endif
+
+#ifndef SOCK_NONBLOCK
+#define SOCK_NONBLOCK 0
+#endif
+
+static int          linux_netlink_socket  = -1;
+static usbi_event_t netlink_control_event = USBI_INVALID_EVENT;
+static pthread_t    libusb_linux_event_thread;
+
+static void *linux_netlink_event_thread_main(void *arg);
+
+static int set_fd_cloexec_nb(int fd, int socktype) {
+    int flags;
+
+#if defined(FD_CLOEXEC)
+    /* Make sure the netlink socket file descriptor is marked as CLOEXEC */
+    if(!(socktype & SOCK_CLOEXEC)) {
+        flags = fcntl(fd, F_GETFD);
+        if(flags == -1) {
+            usbi_err(NULL, "failed to get netlink fd flags, errno=%d", errno);
+            return -1;
+        }
+
+        if(fcntl(fd, F_SETFD, flags | FD_CLOEXEC) == -1) {
+            usbi_err(NULL, "failed to set netlink fd flags, errno=%d", errno);
+            return -1;
+        }
+    }
+#endif
+
+    /* Make sure the netlink socket is non-blocking */
+    if(!(socktype & SOCK_NONBLOCK)) {
+        flags = fcntl(fd, F_GETFL);
+        if(flags == -1) {
+            usbi_err(NULL, "failed to get netlink fd status flags, errno=%d", errno);
+            return -1;
+        }
+
+        if(fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1) {
+            usbi_err(NULL, "failed to set netlink fd status flags, errno=%d", errno);
+            return -1;
+        }
+    }
+
+    return 0;
+}
+
+int linux_netlink_start_event_monitor(void) {
+    struct sockaddr_nl sa_nl    = { .nl_family = AF_NETLINK, .nl_groups = NL_GROUP_KERNEL };
+    int                socktype = SOCK_RAW | SOCK_NONBLOCK | SOCK_CLOEXEC;
+    int                opt      = 1;
+    int                ret;
+
+    linux_netlink_socket = socket(PF_NETLINK, socktype, NETLINK_KOBJECT_UEVENT);
+    if(linux_netlink_socket == -1 && errno == EINVAL) {
+        usbi_dbg(NULL, "failed to create netlink socket of type %d, attempting SOCK_RAW", socktype);
+        socktype             = SOCK_RAW;
+        linux_netlink_socket = socket(PF_NETLINK, socktype, NETLINK_KOBJECT_UEVENT);
+    }
+
+    if(linux_netlink_socket == -1) {
+        usbi_err(NULL, "failed to create netlink socket, errno=%d", errno);
+        goto err;
+    }
+
+    ret = set_fd_cloexec_nb(linux_netlink_socket, socktype);
+    if(ret == -1)
+        goto err_close_socket;
+
+    ret = bind(linux_netlink_socket, (struct sockaddr *)&sa_nl, sizeof(sa_nl));
+    if(ret == -1) {
+        usbi_err(NULL, "failed to bind netlink socket, errno=%d", errno);
+        goto err_close_socket;
+    }
+
+    ret = setsockopt(linux_netlink_socket, SOL_SOCKET, SO_PASSCRED, &opt, sizeof(opt));
+    if(ret == -1) {
+        usbi_err(NULL, "failed to set netlink socket SO_PASSCRED option, errno=%d", errno);
+        goto err_close_socket;
+    }
+
+    ret = usbi_create_event(&netlink_control_event);
+    if(ret) {
+        usbi_err(NULL, "failed to create netlink control event");
+        goto err_close_socket;
+    }
+
+    ret = pthread_create(&libusb_linux_event_thread, NULL, linux_netlink_event_thread_main, NULL);
+    if(ret != 0) {
+        usbi_err(NULL, "failed to create netlink event thread (%d)", ret);
+        goto err_destroy_event;
+    }
+
+    return LIBUSB_SUCCESS;
+
+err_destroy_event:
+    usbi_destroy_event(&netlink_control_event);
+    netlink_control_event = (usbi_event_t)USBI_INVALID_EVENT;
+err_close_socket:
+    close(linux_netlink_socket);
+    linux_netlink_socket = -1;
+err:
+    return LIBUSB_ERROR_OTHER;
+}
+
+int linux_netlink_stop_event_monitor(void) {
+    int ret;
+
+    assert(linux_netlink_socket != -1);
+
+    /* Signal the control event and wait for the thread to exit */
+    usbi_signal_event(&netlink_control_event);
+
+    ret = pthread_join(libusb_linux_event_thread, NULL);
+    if(ret)
+        usbi_warn(NULL, "failed to join netlink event thread (%d)", ret);
+
+    usbi_destroy_event(&netlink_control_event);
+    netlink_control_event = (usbi_event_t)USBI_INVALID_EVENT;
+
+    close(linux_netlink_socket);
+    linux_netlink_socket = -1;
+
+    return LIBUSB_SUCCESS;
+}
+
+static const char *netlink_message_parse(const char *buffer, size_t len, const char *key) {
+    const char *end    = buffer + len;
+    size_t      keylen = strlen(key);
+
+    while(buffer < end && *buffer) {
+        if(strncmp(buffer, key, keylen) == 0 && buffer[keylen] == '=')
+            return buffer + keylen + 1;
+        buffer += strlen(buffer) + 1;
+    }
+
+    return NULL;
+}
+
+/* parse parts of netlink message common to both libudev and the kernel */
+static int linux_netlink_parse(const char *buffer, size_t len, int *detached, const char **sys_name, uint8_t *busnum, uint8_t *devaddr) {
+    const char *tmp, *slash;
+
+    errno = 0;
+
+    *sys_name = NULL;
+    *detached = 0;
+    *busnum   = 0;
+    *devaddr  = 0;
+
+    tmp = netlink_message_parse(buffer, len, "ACTION");
+    if(!tmp) {
+        return -1;
+    }
+    else if(strcmp(tmp, "remove") == 0) {
+        *detached = 1;
+    }
+    else if(strcmp(tmp, "add") != 0) {
+        usbi_dbg(NULL, "unknown device action %s", tmp);
+        return -1;
+    }
+
+    /* check that this is a usb message */
+    tmp = netlink_message_parse(buffer, len, "SUBSYSTEM");
+    if(!tmp || strcmp(tmp, "usb") != 0) {
+        /* not usb. ignore */
+        return -1;
+    }
+
+    /* check that this is an actual usb device */
+    tmp = netlink_message_parse(buffer, len, "DEVTYPE");
+    if(!tmp || strcmp(tmp, "usb_device") != 0) {
+        /* not usb. ignore */
+        return -1;
+    }
+
+    tmp = netlink_message_parse(buffer, len, "BUSNUM");
+    if(tmp) {
+        *busnum = (uint8_t)(strtoul(tmp, NULL, 10) & 0xff);
+        if(errno) {
+            errno = 0;
+            return -1;
+        }
+
+        tmp = netlink_message_parse(buffer, len, "DEVNUM");
+        if(NULL == tmp)
+            return -1;
+
+        *devaddr = (uint8_t)(strtoul(tmp, NULL, 10) & 0xff);
+        if(errno) {
+            errno = 0;
+            return -1;
+        }
+    }
+    else {
+        /* no bus number. try "DEVICE" */
+        tmp = netlink_message_parse(buffer, len, "DEVICE");
+        if(!tmp) {
+            /* not usb. ignore */
+            return -1;
+        }
+
+        /* Parse a device path such as /dev/bus/usb/003/004 */
+        slash = strrchr(tmp, '/');
+        if(!slash)
+            return -1;
+
+        *busnum = (uint8_t)(strtoul(slash - 3, NULL, 10) & 0xff);
+        if(errno) {
+            errno = 0;
+            return -1;
+        }
+
+        *devaddr = (uint8_t)(strtoul(slash + 1, NULL, 10) & 0xff);
+        if(errno) {
+            errno = 0;
+            return -1;
+        }
+
+        return 0;
+    }
+
+    tmp = netlink_message_parse(buffer, len, "DEVPATH");
+    if(!tmp)
+        return -1;
+
+    slash = strrchr(tmp, '/');
+    if(slash)
+        *sys_name = slash + 1;
+
+    /* found a usb device */
+    return 0;
+}
+
+static int linux_netlink_read_message(void) {
+    char               cred_buffer[CMSG_SPACE(sizeof(struct ucred))];
+    char               msg_buffer[2048];
+    const char        *sys_name = NULL;
+    uint8_t            busnum, devaddr;
+    int                detached, r;
+    ssize_t            len;
+    struct cmsghdr    *cmsg;
+    struct ucred      *cred;
+    struct sockaddr_nl sa_nl;
+    struct iovec       iov = { .iov_base = msg_buffer, .iov_len = sizeof(msg_buffer) };
+    struct msghdr      msg = {
+             .msg_iov = &iov, .msg_iovlen = 1, .msg_control = cred_buffer, .msg_controllen = sizeof(cred_buffer), .msg_name = &sa_nl, .msg_namelen = sizeof(sa_nl)
+    };
+
+    /* read netlink message */
+    len = recvmsg(linux_netlink_socket, &msg, 0);
+    if(len == -1) {
+        if(errno != EAGAIN && errno != EINTR)
+            usbi_err(NULL, "error receiving message from netlink, errno=%d", errno);
+        return -1;
+    }
+
+    if(len < 32 || (msg.msg_flags & MSG_TRUNC)) {
+        usbi_err(NULL, "invalid netlink message length");
+        return -1;
+    }
+
+    if(sa_nl.nl_groups != NL_GROUP_KERNEL || sa_nl.nl_pid != 0) {
+        usbi_dbg(NULL, "ignoring netlink message from unknown group/PID (%u/%u)", (unsigned int)sa_nl.nl_groups, (unsigned int)sa_nl.nl_pid);
+        return -1;
+    }
+
+    cmsg = CMSG_FIRSTHDR(&msg);
+    if(!cmsg || cmsg->cmsg_type != SCM_CREDENTIALS) {
+        usbi_dbg(NULL, "ignoring netlink message with no sender credentials");
+        return -1;
+    }
+
+    cred = (struct ucred *)CMSG_DATA(cmsg);
+    if(cred->uid != 0) {
+        usbi_dbg(NULL, "ignoring netlink message with non-zero sender UID %u", (unsigned int)cred->uid);
+        return -1;
+    }
+
+    r = linux_netlink_parse(msg_buffer, (size_t)len, &detached, &sys_name, &busnum, &devaddr);
+    if(r)
+        return r;
+
+    usbi_dbg(NULL, "netlink hotplug found device busnum: %hhu, devaddr: %hhu, sys_name: %s, removed: %s", busnum, devaddr, sys_name, detached ? "yes" : "no");
+
+    /* signal device is available (or not) to all contexts */
+    if(detached)
+        linux_device_disconnected(busnum, devaddr);
+    else
+        linux_hotplug_enumerate(busnum, devaddr, sys_name);
+
+    return 0;
+}
+
+static void *linux_netlink_event_thread_main(void *arg) {
+    struct pollfd fds[] = {
+        { .fd = USBI_EVENT_OS_HANDLE(&netlink_control_event), .events = USBI_EVENT_POLL_EVENTS },
+        { .fd = linux_netlink_socket, .events = POLLIN },
+    };
+    int r;
+
+    UNUSED(arg);
+
+#if defined(HAVE_PTHREAD_SETNAME_NP)
+    r = pthread_setname_np(pthread_self(), "libusb_event");
+    if(r)
+        usbi_warn(NULL, "failed to set hotplug event thread name, error=%d", r);
+#endif
+
+    usbi_dbg(NULL, "netlink event thread entering");
+
+    while(1) {
+        r = poll(fds, 2, -1);
+        if(r == -1) {
+            /* check for temporary failure */
+            if(errno == EINTR)
+                continue;
+            usbi_err(NULL, "poll() failed, errno=%d", errno);
+            break;
+        }
+        if(fds[0].revents) {
+            /* activity on control event, exit */
+            break;
+        }
+        if(fds[1].revents) {
+            usbi_mutex_static_lock(&linux_hotplug_lock);
+            linux_netlink_read_message();
+            usbi_mutex_static_unlock(&linux_hotplug_lock);
+        }
+    }
+
+    usbi_dbg(NULL, "netlink event thread exiting");
+
+    return NULL;
+}
+
+void linux_netlink_hotplug_poll(void) {
+    int r;
+
+    usbi_mutex_static_lock(&linux_hotplug_lock);
+    do {
+        r = linux_netlink_read_message();
+    } while(r == 0);
+    usbi_mutex_static_unlock(&linux_hotplug_lock);
+}
diff --git a/3rdparty/libusb/src/libusb/os/linux_udev.c b/3rdparty/libusb/src/libusb/os/linux_udev.c
new file mode 100644
index 00000000..f5e8a092
--- /dev/null
+++ b/3rdparty/libusb/src/libusb/os/linux_udev.c
@@ -0,0 +1,313 @@
+/* -*- Mode: C; c-basic-offset:8 ; indent-tabs-mode:t -*- */
+/*
+ * Linux usbfs backend for libusb
+ * Copyright (C) 2007-2009 Daniel Drake <dsd@gentoo.org>
+ * Copyright (c) 2001 Johannes Erdfelt <johannes@erdfelt.com>
+ * Copyright (c) 2012-2013 Nathan Hjelm <hjelmn@mac.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "libusbi.h"
+#include "linux_usbfs.h"
+
+#include <errno.h>
+#include <fcntl.h>
+#include <libudev.h>
+#include <poll.h>
+#include <pthread.h>
+#include <string.h>
+#include <unistd.h>
+
+/* udev context */
+static struct udev         *udev_ctx           = NULL;
+static int                  udev_monitor_fd    = -1;
+static usbi_event_t         udev_control_event = USBI_INVALID_EVENT;
+static struct udev_monitor *udev_monitor       = NULL;
+static pthread_t            linux_event_thread;
+
+static void  udev_hotplug_event(struct udev_device *udev_dev);
+static void *linux_udev_event_thread_main(void *arg);
+
+int linux_udev_start_event_monitor(void) {
+    int r;
+
+    assert(udev_ctx == NULL);
+    udev_ctx = udev_new();
+    if(!udev_ctx) {
+        usbi_err(NULL, "could not create udev context");
+        goto err;
+    }
+
+    udev_monitor = udev_monitor_new_from_netlink(udev_ctx, "udev");
+    if(!udev_monitor) {
+        usbi_err(NULL, "could not initialize udev monitor");
+        goto err_free_ctx;
+    }
+
+    r = udev_monitor_filter_add_match_subsystem_devtype(udev_monitor, "usb", "usb_device");
+    if(r) {
+        usbi_err(NULL, "could not initialize udev monitor filter for \"usb\" subsystem");
+        goto err_free_monitor;
+    }
+
+    if(udev_monitor_enable_receiving(udev_monitor)) {
+        usbi_err(NULL, "failed to enable the udev monitor");
+        goto err_free_monitor;
+    }
+
+    udev_monitor_fd = udev_monitor_get_fd(udev_monitor);
+
+#if defined(FD_CLOEXEC)
+    /* Make sure the udev file descriptor is marked as CLOEXEC */
+    r = fcntl(udev_monitor_fd, F_GETFD);
+    if(r == -1) {
+        usbi_err(NULL, "failed to get udev monitor fd flags, errno=%d", errno);
+        goto err_free_monitor;
+    }
+    if(!(r & FD_CLOEXEC)) {
+        if(fcntl(udev_monitor_fd, F_SETFD, r | FD_CLOEXEC) == -1) {
+            usbi_err(NULL, "failed to set udev monitor fd flags, errno=%d", errno);
+            goto err_free_monitor;
+        }
+    }
+#endif
+
+    /* Some older versions of udev are not non-blocking by default,
+     * so make sure this is set */
+    r = fcntl(udev_monitor_fd, F_GETFL);
+    if(r == -1) {
+        usbi_err(NULL, "failed to get udev monitor fd status flags, errno=%d", errno);
+        goto err_free_monitor;
+    }
+    if(!(r & O_NONBLOCK)) {
+        if(fcntl(udev_monitor_fd, F_SETFL, r | O_NONBLOCK) == -1) {
+            usbi_err(NULL, "failed to set udev monitor fd status flags, errno=%d", errno);
+            goto err_free_monitor;
+        }
+    }
+
+    r = usbi_create_event(&udev_control_event);
+    if(r) {
+        usbi_err(NULL, "failed to create udev control event");
+        goto err_free_monitor;
+    }
+
+    r = pthread_create(&linux_event_thread, NULL, linux_udev_event_thread_main, NULL);
+    if(r) {
+        usbi_err(NULL, "failed to create hotplug event thread (%d)", r);
+        goto err_destroy_event;
+    }
+
+    return LIBUSB_SUCCESS;
+
+err_destroy_event:
+    usbi_destroy_event(&udev_control_event);
+    udev_control_event = (usbi_event_t)USBI_INVALID_EVENT;
+err_free_monitor:
+    udev_monitor_unref(udev_monitor);
+    udev_monitor    = NULL;
+    udev_monitor_fd = -1;
+err_free_ctx:
+    udev_unref(udev_ctx);
+err:
+    udev_ctx = NULL;
+    return LIBUSB_ERROR_OTHER;
+}
+
+int linux_udev_stop_event_monitor(void) {
+    int r;
+
+    assert(udev_ctx != NULL);
+    assert(udev_monitor != NULL);
+    assert(udev_monitor_fd != -1);
+
+    /* Signal the control event and wait for the thread to exit */
+    usbi_signal_event(&udev_control_event);
+
+    r = pthread_join(linux_event_thread, NULL);
+    if(r)
+        usbi_warn(NULL, "failed to join hotplug event thread (%d)", r);
+
+    usbi_destroy_event(&udev_control_event);
+    udev_control_event = (usbi_event_t)USBI_INVALID_EVENT;
+
+    /* Release the udev monitor */
+    udev_monitor_unref(udev_monitor);
+    udev_monitor    = NULL;
+    udev_monitor_fd = -1;
+
+    /* Clean up the udev context */
+    udev_unref(udev_ctx);
+    udev_ctx = NULL;
+
+    return LIBUSB_SUCCESS;
+}
+
+static void *linux_udev_event_thread_main(void *arg) {
+    struct pollfd fds[] = {
+        { .fd = USBI_EVENT_OS_HANDLE(&udev_control_event), .events = USBI_EVENT_POLL_EVENTS },
+        { .fd = udev_monitor_fd, .events = POLLIN },
+    };
+    struct udev_device *udev_dev;
+    int                 r;
+
+    UNUSED(arg);
+
+#if defined(HAVE_PTHREAD_SETNAME_NP)
+    r = pthread_setname_np(pthread_self(), "libusb_event");
+    if(r)
+        usbi_warn(NULL, "failed to set hotplug event thread name, error=%d", r);
+#endif
+
+    usbi_dbg(NULL, "udev event thread entering");
+
+    while(1) {
+        r = poll(fds, 2, -1);
+        if(r == -1) {
+            /* check for temporary failure */
+            if(errno == EINTR)
+                continue;
+            usbi_err(NULL, "poll() failed, errno=%d", errno);
+            break;
+        }
+        if(fds[0].revents) {
+            /* activity on control event, exit */
+            break;
+        }
+        if(fds[1].revents) {
+            usbi_mutex_static_lock(&linux_hotplug_lock);
+            udev_dev = udev_monitor_receive_device(udev_monitor);
+            if(udev_dev)
+                udev_hotplug_event(udev_dev);
+            usbi_mutex_static_unlock(&linux_hotplug_lock);
+        }
+    }
+
+    usbi_dbg(NULL, "udev event thread exiting");
+
+    return NULL;
+}
+
+static int udev_device_info(struct libusb_context *ctx, int detached, struct udev_device *udev_dev, uint8_t *busnum, uint8_t *devaddr, const char **sys_name) {
+    const char *dev_node;
+
+    dev_node = udev_device_get_devnode(udev_dev);
+    if(!dev_node) {
+        return LIBUSB_ERROR_OTHER;
+    }
+
+    *sys_name = udev_device_get_sysname(udev_dev);
+    if(!*sys_name) {
+        return LIBUSB_ERROR_OTHER;
+    }
+
+    return linux_get_device_address(ctx, detached, busnum, devaddr, dev_node, *sys_name, -1);
+}
+
+static void udev_hotplug_event(struct udev_device *udev_dev) {
+    const char *udev_action;
+    const char *sys_name = NULL;
+    uint8_t     busnum = 0, devaddr = 0;
+    int         detached;
+    int         r;
+
+    do {
+        udev_action = udev_device_get_action(udev_dev);
+        if(!udev_action) {
+            break;
+        }
+
+        detached = !strncmp(udev_action, "remove", 6);
+
+        r = udev_device_info(NULL, detached, udev_dev, &busnum, &devaddr, &sys_name);
+        if(LIBUSB_SUCCESS != r) {
+            break;
+        }
+
+        usbi_dbg(NULL, "udev hotplug event. action: %s.", udev_action);
+
+        if(strncmp(udev_action, "add", 3) == 0) {
+            linux_hotplug_enumerate(busnum, devaddr, sys_name);
+        }
+        else if(detached) {
+            linux_device_disconnected(busnum, devaddr);
+        }
+        else if(strncmp(udev_action, "bind", 4) == 0) {
+            /* silently ignore "known unhandled" action */
+        }
+        else {
+            usbi_err(NULL, "ignoring udev action %s", udev_action);
+        }
+    } while(0);
+
+    udev_device_unref(udev_dev);
+}
+
+int linux_udev_scan_devices(struct libusb_context *ctx) {
+    struct udev_enumerate  *enumerator;
+    struct udev_list_entry *devices, *entry;
+    struct udev_device     *udev_dev;
+    const char             *sys_name;
+    int                     r;
+
+    assert(udev_ctx != NULL);
+
+    enumerator = udev_enumerate_new(udev_ctx);
+    if(NULL == enumerator) {
+        usbi_err(ctx, "error creating udev enumerator");
+        return LIBUSB_ERROR_OTHER;
+    }
+
+    udev_enumerate_add_match_subsystem(enumerator, "usb");
+    udev_enumerate_add_match_property(enumerator, "DEVTYPE", "usb_device");
+    udev_enumerate_scan_devices(enumerator);
+    devices = udev_enumerate_get_list_entry(enumerator);
+
+    entry = NULL;
+    udev_list_entry_foreach(entry, devices) {
+        const char *path   = udev_list_entry_get_name(entry);
+        uint8_t     busnum = 0, devaddr = 0;
+
+        udev_dev = udev_device_new_from_syspath(udev_ctx, path);
+
+        r = udev_device_info(ctx, 0, udev_dev, &busnum, &devaddr, &sys_name);
+        if(r) {
+            udev_device_unref(udev_dev);
+            continue;
+        }
+
+        linux_enumerate_device(ctx, busnum, devaddr, sys_name);
+        udev_device_unref(udev_dev);
+    }
+
+    udev_enumerate_unref(enumerator);
+
+    return LIBUSB_SUCCESS;
+}
+
+void linux_udev_hotplug_poll(void) {
+    struct udev_device *udev_dev;
+
+    usbi_mutex_static_lock(&linux_hotplug_lock);
+    do {
+        udev_dev = udev_monitor_receive_device(udev_monitor);
+        if(udev_dev) {
+            usbi_dbg(NULL, "Handling hotplug event from hotplug_poll");
+            udev_hotplug_event(udev_dev);
+        }
+    } while(udev_dev);
+    usbi_mutex_static_unlock(&linux_hotplug_lock);
+}
diff --git a/3rdparty/libusb/src/libusb/os/linux_usbfs.c b/3rdparty/libusb/src/libusb/os/linux_usbfs.c
new file mode 100644
index 00000000..9f0e9ddc
--- /dev/null
+++ b/3rdparty/libusb/src/libusb/os/linux_usbfs.c
@@ -0,0 +1,2720 @@
+/* -*- Mode: C; c-basic-offset:8 ; indent-tabs-mode:t -*- */
+/*
+ * Linux usbfs backend for libusb
+ * Copyright © 2007-2009 Daniel Drake <dsd@gentoo.org>
+ * Copyright © 2001 Johannes Erdfelt <johannes@erdfelt.com>
+ * Copyright © 2013 Nathan Hjelm <hjelmn@mac.com>
+ * Copyright © 2012-2013 Hans de Goede <hdegoede@redhat.com>
+ * Copyright © 2020 Chris Dickens <christopher.a.dickens@gmail.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "libusbi.h"
+#include "linux_usbfs.h"
+
+#include <alloca.h>
+#include <ctype.h>
+#include <dirent.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <string.h>
+#include <sys/ioctl.h>
+#include <sys/mman.h>
+#include <sys/utsname.h>
+#include <sys/vfs.h>
+#include <unistd.h>
+
+/* sysfs vs usbfs:
+ * opening a usbfs node causes the device to be resumed, so we attempt to
+ * avoid this during enumeration.
+ *
+ * sysfs allows us to read the kernel's in-memory copies of device descriptors
+ * and so forth, avoiding the need to open the device:
+ *  - The binary "descriptors" file contains all config descriptors since
+ *    2.6.26, commit 217a9081d8e69026186067711131b77f0ce219ed
+ *  - The binary "descriptors" file was added in 2.6.23, commit
+ *    69d42a78f935d19384d1f6e4f94b65bb162b36df, but it only contains the
+ *    active config descriptors
+ *  - The "busnum" file was added in 2.6.22, commit
+ *    83f7d958eab2fbc6b159ee92bf1493924e1d0f72
+ *  - The "devnum" file has been present since pre-2.6.18
+ *  - the "bConfigurationValue" file has been present since pre-2.6.18
+ *
+ * If we have bConfigurationValue, busnum, and devnum, then we can determine
+ * the active configuration without having to open the usbfs node in RDWR mode.
+ * The busnum file is important as that is the only way we can relate sysfs
+ * devices to usbfs nodes.
+ *
+ * If we also have all descriptors, we can obtain the device descriptor and
+ * configuration without touching usbfs at all.
+ */
+
+/* endianness for multi-byte fields:
+ *
+ * Descriptors exposed by usbfs have the multi-byte fields in the device
+ * descriptor as host endian. Multi-byte fields in the other descriptors are
+ * bus-endian. The kernel documentation says otherwise, but it is wrong.
+ *
+ * In sysfs all descriptors are bus-endian.
+ */
+
+#define USBDEV_PATH "/dev"
+#define USB_DEVTMPFS_PATH "/dev/bus/usb"
+
+/* use usbdev*.* device names in /dev instead of the usbfs bus directories */
+static int usbdev_names = 0;
+
+/* Linux has changed the maximum length of an individual isochronous packet
+ * over time.  Initially this limit was 1,023 bytes, but Linux 2.6.18
+ * (commit 3612242e527eb47ee4756b5350f8bdf791aa5ede) increased this value to
+ * 8,192 bytes to support higher bandwidth devices.  Linux 3.10
+ * (commit e2e2f0ea1c935edcf53feb4c4c8fdb4f86d57dd9) further increased this
+ * value to 49,152 bytes to support super speed devices.  Linux 5.2
+ * (commit 8a1dbc8d91d3d1602282c7e6b4222c7759c916fa) even further increased
+ * this value to 98,304 bytes to support super speed plus devices.
+ */
+static unsigned int max_iso_packet_len = 0;
+
+/* is sysfs available (mounted) ? */
+static int sysfs_available = -1;
+
+/* how many times have we initted (and not exited) ? */
+static int init_count = 0;
+
+/* Serialize scan-devices, event-thread, and poll */
+usbi_mutex_static_t linux_hotplug_lock = USBI_MUTEX_INITIALIZER;
+
+static int linux_scan_devices(struct libusb_context *ctx);
+static int detach_kernel_driver_and_claim(struct libusb_device_handle *, uint8_t);
+
+#if !defined(HAVE_LIBUDEV)
+static int linux_default_scan_devices(struct libusb_context *ctx);
+#endif
+
+struct kernel_version {
+    int major;
+    int minor;
+    int sublevel;
+};
+
+struct config_descriptor {
+    struct usbi_configuration_descriptor *desc;
+    size_t                                actual_len;
+};
+
+struct linux_context_priv {
+    /* no enumeration or hot-plug detection */
+    int no_device_discovery;
+};
+
+struct linux_device_priv {
+    char                     *sysfs_dir;
+    void                     *descriptors;
+    size_t                    descriptors_len;
+    struct config_descriptor *config_descriptors;
+    int                       active_config; /* cache val for !sysfs_available  */
+};
+
+struct linux_device_handle_priv {
+    int      fd;
+    int      fd_removed;
+    int      fd_keep;
+    uint32_t caps;
+};
+
+enum reap_action {
+    NORMAL = 0,
+    /* submission failed after the first URB, so await cancellation/completion
+     * of all the others */
+    SUBMIT_FAILED,
+
+    /* cancelled by user or timeout */
+    CANCELLED,
+
+    /* completed multi-URB transfer in non-final URB */
+    COMPLETED_EARLY,
+
+    /* one or more urbs encountered a low-level error */
+    ERROR,
+};
+
+struct linux_transfer_priv {
+    union {
+        struct usbfs_urb  *urbs;
+        struct usbfs_urb **iso_urbs;
+    };
+
+    enum reap_action            reap_action;
+    int                         num_urbs;
+    int                         num_retired;
+    enum libusb_transfer_status reap_status;
+
+    /* next iso packet in user-supplied transfer to be populated */
+    int iso_packet_offset;
+};
+
+static int dev_has_config0(struct libusb_device *dev) {
+    struct linux_device_priv *priv = usbi_get_device_priv(dev);
+    struct config_descriptor *config;
+    uint8_t                   idx;
+
+    for(idx = 0; idx < dev->device_descriptor.bNumConfigurations; idx++) {
+        config = &priv->config_descriptors[idx];
+        if(config->desc->bConfigurationValue == 0)
+            return 1;
+    }
+
+    return 0;
+}
+
+static int get_usbfs_fd(struct libusb_device *dev, mode_t mode, int silent) {
+    struct libusb_context *ctx = DEVICE_CTX(dev);
+    char                   path[24];
+    int                    fd;
+
+    if(usbdev_names)
+        snprintf(path, sizeof(path), USBDEV_PATH "/usbdev%u.%u", dev->bus_number, dev->device_address);
+    else
+        snprintf(path, sizeof(path), USB_DEVTMPFS_PATH "/%03u/%03u", dev->bus_number, dev->device_address);
+
+    fd = open(path, mode | O_CLOEXEC);
+    if(fd != -1)
+        return fd; /* Success */
+
+    if(errno == ENOENT) {
+        const long            delay_ms = 10L;
+        const struct timespec delay_ts = { 0L, delay_ms * 1000L * 1000L };
+
+        if(!silent)
+            usbi_err(ctx, "File doesn't exist, wait %ld ms and try again", delay_ms);
+
+        /* Wait 10ms for USB device path creation.*/
+        nanosleep(&delay_ts, NULL);
+
+        fd = open(path, mode | O_CLOEXEC);
+        if(fd != -1)
+            return fd; /* Success */
+    }
+
+    if(!silent) {
+        usbi_err(ctx, "libusb couldn't open USB device %s, errno=%d", path, errno);
+        if(errno == EACCES && mode == O_RDWR)
+            usbi_err(ctx, "libusb requires write access to USB device nodes");
+    }
+
+    if(errno == EACCES)
+        return LIBUSB_ERROR_ACCESS;
+    if(errno == ENOENT)
+        return LIBUSB_ERROR_NO_DEVICE;
+    return LIBUSB_ERROR_IO;
+}
+
+/* check dirent for a /dev/usbdev%d.%d name
+ * optionally return bus/device on success */
+static int is_usbdev_entry(const char *name, uint8_t *bus_p, uint8_t *dev_p) {
+    int busnum, devnum;
+
+    if(sscanf(name, "usbdev%d.%d", &busnum, &devnum) != 2)
+        return 0;
+    if(busnum < 0 || busnum > UINT8_MAX || devnum < 0 || devnum > UINT8_MAX) {
+        usbi_dbg(NULL, "invalid usbdev format '%s'", name);
+        return 0;
+    }
+
+    usbi_dbg(NULL, "found: %s", name);
+    if(bus_p)
+        *bus_p = (uint8_t)busnum;
+    if(dev_p)
+        *dev_p = (uint8_t)devnum;
+    return 1;
+}
+
+static const char *find_usbfs_path(void) {
+    const char    *path;
+    DIR           *dir;
+    struct dirent *entry;
+
+    path = USB_DEVTMPFS_PATH;
+    dir  = opendir(path);
+    if(dir) {
+        while((entry = readdir(dir))) {
+            if(entry->d_name[0] == '.')
+                continue;
+
+            /* We assume if we find any files that it must be the right place */
+            break;
+        }
+
+        closedir(dir);
+
+        if(entry)
+            return path;
+    }
+
+    /* look for /dev/usbdev*.* if the normal place fails */
+    path = USBDEV_PATH;
+    dir  = opendir(path);
+    if(dir) {
+        while((entry = readdir(dir))) {
+            if(entry->d_name[0] == '.')
+                continue;
+
+            if(is_usbdev_entry(entry->d_name, NULL, NULL)) {
+                /* found one; that's enough */
+                break;
+            }
+        }
+
+        closedir(dir);
+
+        if(entry) {
+            usbdev_names = 1;
+            return path;
+        }
+    }
+
+/* On udev based systems without any usb-devices /dev/bus/usb will not
+ * exist. So if we've not found anything and we're using udev for hotplug
+ * simply assume /dev/bus/usb rather then making libusb_init fail.
+ * Make the same assumption for Android where SELinux policies might block us
+ * from reading /dev on newer devices. */
+#if defined(HAVE_LIBUDEV) || defined(__ANDROID__)
+    return USB_DEVTMPFS_PATH;
+#else
+    return NULL;
+#endif
+}
+
+static int get_kernel_version(struct libusb_context *ctx, struct kernel_version *ver) {
+    struct utsname uts;
+    int            atoms;
+
+    if(uname(&uts) < 0) {
+        usbi_err(ctx, "uname failed, errno=%d", errno);
+        return -1;
+    }
+
+    atoms = sscanf(uts.release, "%d.%d.%d", &ver->major, &ver->minor, &ver->sublevel);
+    if(atoms < 2) {
+        usbi_err(ctx, "failed to parse uname release '%s'", uts.release);
+        return -1;
+    }
+
+    if(atoms < 3)
+        ver->sublevel = -1;
+
+    usbi_dbg(ctx, "reported kernel version is %s", uts.release);
+
+    return 0;
+}
+
+static int kernel_version_ge(const struct kernel_version *ver, int major, int minor, int sublevel) {
+    if(ver->major > major)
+        return 1;
+    else if(ver->major < major)
+        return 0;
+
+    /* kmajor == major */
+    if(ver->minor > minor)
+        return 1;
+    else if(ver->minor < minor)
+        return 0;
+
+    /* kminor == minor */
+    if(ver->sublevel == -1)
+        return sublevel == 0;
+
+    return ver->sublevel >= sublevel;
+}
+
+static int op_init(struct libusb_context *ctx) {
+    struct kernel_version      kversion;
+    const char                *usbfs_path;
+    int                        r;
+    struct linux_context_priv *cpriv = usbi_get_context_priv(ctx);
+
+    if(get_kernel_version(ctx, &kversion) < 0)
+        return LIBUSB_ERROR_OTHER;
+
+    if(!kernel_version_ge(&kversion, 2, 6, 32)) {
+        usbi_err(ctx, "kernel version is too old (reported as %d.%d.%d)", kversion.major, kversion.minor, kversion.sublevel != -1 ? kversion.sublevel : 0);
+        return LIBUSB_ERROR_NOT_SUPPORTED;
+    }
+
+    usbfs_path = find_usbfs_path();
+    if(!usbfs_path) {
+        usbi_err(ctx, "could not find usbfs");
+        return LIBUSB_ERROR_OTHER;
+    }
+
+    usbi_dbg(ctx, "found usbfs at %s", usbfs_path);
+
+    if(!max_iso_packet_len) {
+        if(kernel_version_ge(&kversion, 5, 2, 0))
+            max_iso_packet_len = 98304;
+        else if(kernel_version_ge(&kversion, 3, 10, 0))
+            max_iso_packet_len = 49152;
+        else
+            max_iso_packet_len = 8192;
+    }
+
+    usbi_dbg(ctx, "max iso packet length is (likely) %u bytes", max_iso_packet_len);
+
+    if(sysfs_available == -1) {
+        struct statfs statfsbuf;
+
+        r = statfs(SYSFS_MOUNT_PATH, &statfsbuf);
+        if(r == 0 && statfsbuf.f_type == SYSFS_MAGIC) {
+            usbi_dbg(ctx, "sysfs is available");
+            sysfs_available = 1;
+        }
+        else {
+            usbi_warn(ctx, "sysfs not mounted");
+            sysfs_available = 0;
+        }
+    }
+
+    if(cpriv->no_device_discovery) {
+        return LIBUSB_SUCCESS;
+    }
+
+    r = LIBUSB_SUCCESS;
+    if(init_count == 0) {
+        /* start up hotplug event handler */
+        r = linux_start_event_monitor();
+    }
+    if(r == LIBUSB_SUCCESS) {
+        r = linux_scan_devices(ctx);
+        if(r == LIBUSB_SUCCESS)
+            init_count++;
+        else if(init_count == 0)
+            linux_stop_event_monitor();
+    }
+    else {
+        usbi_err(ctx, "error starting hotplug event monitor");
+    }
+
+    return r;
+}
+
+static void op_exit(struct libusb_context *ctx) {
+    struct linux_context_priv *cpriv = usbi_get_context_priv(ctx);
+
+    if(cpriv->no_device_discovery) {
+        return;
+    }
+
+    assert(init_count != 0);
+    if(!--init_count) {
+        /* tear down event handler */
+        linux_stop_event_monitor();
+    }
+}
+
+static int op_set_option(struct libusb_context *ctx, enum libusb_option option, va_list ap) {
+    UNUSED(ap);
+
+    if(option == LIBUSB_OPTION_NO_DEVICE_DISCOVERY) {
+        struct linux_context_priv *cpriv = usbi_get_context_priv(ctx);
+
+        usbi_dbg(ctx, "no device discovery will be performed");
+        cpriv->no_device_discovery = 1;
+        return LIBUSB_SUCCESS;
+    }
+
+    return LIBUSB_ERROR_NOT_SUPPORTED;
+}
+
+static int linux_scan_devices(struct libusb_context *ctx) {
+    int ret;
+
+    usbi_mutex_static_lock(&linux_hotplug_lock);
+
+#if defined(HAVE_LIBUDEV)
+    ret = linux_udev_scan_devices(ctx);
+#else
+    ret = linux_default_scan_devices(ctx);
+#endif
+
+    usbi_mutex_static_unlock(&linux_hotplug_lock);
+
+    return ret;
+}
+
+static void op_hotplug_poll(void) {
+    linux_hotplug_poll();
+}
+
+static int open_sysfs_attr(struct libusb_context *ctx, const char *sysfs_dir, const char *attr) {
+    char filename[256];
+    int  fd;
+
+    snprintf(filename, sizeof(filename), SYSFS_DEVICE_PATH "/%s/%s", sysfs_dir, attr);
+    fd = open(filename, O_RDONLY | O_CLOEXEC);
+    if(fd < 0) {
+        if(errno == ENOENT) {
+            /* File doesn't exist. Assume the device has been
+               disconnected (see trac ticket #70). */
+            return LIBUSB_ERROR_NO_DEVICE;
+        }
+        usbi_err(ctx, "open %s failed, errno=%d", filename, errno);
+        return LIBUSB_ERROR_IO;
+    }
+
+    return fd;
+}
+
+/* Note only suitable for attributes which always read >= 0, < 0 is error */
+static int read_sysfs_attr(struct libusb_context *ctx, const char *sysfs_dir, const char *attr, int max_value, int *value_p) {
+    char    buf[20], *endptr;
+    long    value;
+    ssize_t r;
+    int     fd;
+
+    fd = open_sysfs_attr(ctx, sysfs_dir, attr);
+    if(fd < 0)
+        return fd;
+
+    r = read(fd, buf, sizeof(buf) - 1);
+    if(r < 0) {
+        r = errno;
+        close(fd);
+        if(r == ENODEV)
+            return LIBUSB_ERROR_NO_DEVICE;
+        usbi_err(ctx, "attribute %s read failed, errno=%zd", attr, r);
+        return LIBUSB_ERROR_IO;
+    }
+    close(fd);
+
+    if(r == 0) {
+        /* Certain attributes (e.g. bConfigurationValue) are not
+         * populated if the device is not configured. */
+        *value_p = -1;
+        return 0;
+    }
+
+    /* The kernel does *not* NUL-terminate the string, but every attribute
+     * should be terminated with a newline character. */
+    if(!isdigit(buf[0])) {
+        usbi_err(ctx, "attribute %s doesn't have numeric value?", attr);
+        return LIBUSB_ERROR_IO;
+    }
+    else if(buf[r - 1] != '\n') {
+        usbi_warn(ctx, "attribute %s doesn't end with newline?", attr);
+    }
+    else {
+        /* Remove the terminating newline character */
+        r--;
+    }
+    buf[r] = '\0';
+
+    errno = 0;
+    value = strtol(buf, &endptr, 10);
+    if(value < 0 || value > (long)max_value || errno) {
+        usbi_err(ctx, "attribute %s contains an invalid value: '%s'", attr, buf);
+        return LIBUSB_ERROR_INVALID_PARAM;
+    }
+    else if(*endptr != '\0') {
+        /* Consider the value to be valid if the remainder is a '.'
+         * character followed by numbers.  This occurs, for example,
+         * when reading the "speed" attribute for a low-speed device
+         * (e.g. "1.5") */
+        if(*endptr == '.' && isdigit(*(endptr + 1))) {
+            endptr++;
+            while(isdigit(*endptr))
+                endptr++;
+        }
+        if(*endptr != '\0') {
+            usbi_err(ctx, "attribute %s contains an invalid value: '%s'", attr, buf);
+            return LIBUSB_ERROR_INVALID_PARAM;
+        }
+    }
+
+    *value_p = (int)value;
+    return 0;
+}
+
+static int sysfs_scan_device(struct libusb_context *ctx, const char *devname) {
+    uint8_t busnum, devaddr;
+    int     ret;
+
+    ret = linux_get_device_address(ctx, 0, &busnum, &devaddr, NULL, devname, -1);
+    if(ret != LIBUSB_SUCCESS)
+        return ret;
+
+    return linux_enumerate_device(ctx, busnum, devaddr, devname);
+}
+
+/* read the bConfigurationValue for a device */
+static int sysfs_get_active_config(struct libusb_device *dev, int *config) {
+    struct linux_device_priv *priv = usbi_get_device_priv(dev);
+
+    return read_sysfs_attr(DEVICE_CTX(dev), priv->sysfs_dir, "bConfigurationValue", UINT8_MAX, config);
+}
+
+int linux_get_device_address(struct libusb_context *ctx, int detached, uint8_t *busnum, uint8_t *devaddr, const char *dev_node, const char *sys_name, int fd) {
+    int sysfs_val;
+    int r;
+
+    usbi_dbg(ctx, "getting address for device: %s detached: %d", sys_name, detached);
+    /* can't use sysfs to read the bus and device number if the
+     * device has been detached */
+    if(!sysfs_available || detached || !sys_name) {
+        if(!dev_node && fd >= 0) {
+            char *fd_path = alloca(PATH_MAX);
+            char  proc_path[32];
+
+            /* try to retrieve the device node from fd */
+            snprintf(proc_path, sizeof(proc_path), "/proc/self/fd/%d", fd);
+            r = readlink(proc_path, fd_path, PATH_MAX - 1);
+            if(r > 0) {
+                fd_path[r] = '\0';
+                dev_node   = fd_path;
+            }
+        }
+
+        if(!dev_node)
+            return LIBUSB_ERROR_OTHER;
+
+        /* will this work with all supported kernel versions? */
+        if(!strncmp(dev_node, "/dev/bus/usb", 12))
+            sscanf(dev_node, "/dev/bus/usb/%hhu/%hhu", busnum, devaddr);
+        else
+            return LIBUSB_ERROR_OTHER;
+
+        return LIBUSB_SUCCESS;
+    }
+
+    usbi_dbg(ctx, "scan %s", sys_name);
+
+    r = read_sysfs_attr(ctx, sys_name, "busnum", UINT8_MAX, &sysfs_val);
+    if(r < 0)
+        return r;
+    *busnum = (uint8_t)sysfs_val;
+
+    r = read_sysfs_attr(ctx, sys_name, "devnum", UINT8_MAX, &sysfs_val);
+    if(r < 0)
+        return r;
+    *devaddr = (uint8_t)sysfs_val;
+
+    usbi_dbg(ctx, "bus=%u dev=%u", *busnum, *devaddr);
+
+    return LIBUSB_SUCCESS;
+}
+
+/* Return offset of the next config descriptor */
+static int seek_to_next_config(struct libusb_context *ctx, uint8_t *buffer, size_t len) {
+    struct usbi_descriptor_header *header;
+    int                            offset;
+
+    /* Start seeking past the config descriptor */
+    offset = LIBUSB_DT_CONFIG_SIZE;
+    buffer += LIBUSB_DT_CONFIG_SIZE;
+    len -= LIBUSB_DT_CONFIG_SIZE;
+
+    while(len > 0) {
+        if(len < 2) {
+            usbi_err(ctx, "short descriptor read %zu/2", len);
+            return LIBUSB_ERROR_IO;
+        }
+
+        header = (struct usbi_descriptor_header *)buffer;
+        if(header->bDescriptorType == LIBUSB_DT_CONFIG)
+            return offset;
+
+        if(len < header->bLength) {
+            usbi_err(ctx, "bLength overflow by %zu bytes", (size_t)header->bLength - len);
+            return LIBUSB_ERROR_IO;
+        }
+
+        offset += header->bLength;
+        buffer += header->bLength;
+        len -= header->bLength;
+    }
+
+    usbi_err(ctx, "config descriptor not found");
+    return LIBUSB_ERROR_IO;
+}
+
+static int parse_config_descriptors(struct libusb_device *dev) {
+    struct libusb_context         *ctx  = DEVICE_CTX(dev);
+    struct linux_device_priv      *priv = usbi_get_device_priv(dev);
+    struct usbi_device_descriptor *device_desc;
+    uint8_t                        idx, num_configs;
+    uint8_t                       *buffer;
+    size_t                         remaining;
+
+    device_desc = priv->descriptors;
+    num_configs = device_desc->bNumConfigurations;
+
+    if(num_configs == 0)
+        return 0; /* no configurations? */
+
+    priv->config_descriptors = malloc(num_configs * sizeof(priv->config_descriptors[0]));
+    if(!priv->config_descriptors)
+        return LIBUSB_ERROR_NO_MEM;
+
+    buffer    = (uint8_t *)priv->descriptors + LIBUSB_DT_DEVICE_SIZE;
+    remaining = priv->descriptors_len - LIBUSB_DT_DEVICE_SIZE;
+
+    for(idx = 0; idx < num_configs; idx++) {
+        struct usbi_configuration_descriptor *config_desc;
+        uint16_t                              config_len;
+
+        if(remaining < LIBUSB_DT_CONFIG_SIZE) {
+            usbi_err(ctx, "short descriptor read %zu/%d", remaining, LIBUSB_DT_CONFIG_SIZE);
+            return LIBUSB_ERROR_IO;
+        }
+
+        config_desc = (struct usbi_configuration_descriptor *)buffer;
+        if(config_desc->bDescriptorType != LIBUSB_DT_CONFIG) {
+            usbi_err(ctx, "descriptor is not a config desc (type 0x%02x)", config_desc->bDescriptorType);
+            return LIBUSB_ERROR_IO;
+        }
+        else if(config_desc->bLength < LIBUSB_DT_CONFIG_SIZE) {
+            usbi_err(ctx, "invalid descriptor bLength %u", config_desc->bLength);
+            return LIBUSB_ERROR_IO;
+        }
+
+        config_len = libusb_le16_to_cpu(config_desc->wTotalLength);
+        if(config_len < LIBUSB_DT_CONFIG_SIZE) {
+            usbi_err(ctx, "invalid wTotalLength %u", config_len);
+            return LIBUSB_ERROR_IO;
+        }
+
+        if(priv->sysfs_dir) {
+            /*
+             * In sysfs wTotalLength is ignored, instead the kernel returns a
+             * config descriptor with verified bLength fields, with descriptors
+             * with an invalid bLength removed.
+             */
+            uint16_t sysfs_config_len;
+            int      offset;
+
+            if(num_configs > 1 && idx < num_configs - 1) {
+                offset = seek_to_next_config(ctx, buffer, remaining);
+                if(offset < 0)
+                    return offset;
+                sysfs_config_len = (uint16_t)offset;
+            }
+            else {
+                sysfs_config_len = (uint16_t)remaining;
+            }
+
+            if(config_len != sysfs_config_len) {
+                usbi_warn(ctx, "config length mismatch wTotalLength %u real %u", config_len, sysfs_config_len);
+                config_len = sysfs_config_len;
+            }
+        }
+        else {
+            /*
+             * In usbfs the config descriptors are wTotalLength bytes apart,
+             * with any short reads from the device appearing as holes in the file.
+             */
+            if(config_len > remaining) {
+                usbi_warn(ctx, "short descriptor read %zu/%u", remaining, config_len);
+                config_len = (uint16_t)remaining;
+            }
+        }
+
+        if(config_desc->bConfigurationValue == 0)
+            usbi_warn(ctx, "device has configuration 0");
+
+        priv->config_descriptors[idx].desc       = config_desc;
+        priv->config_descriptors[idx].actual_len = config_len;
+
+        buffer += config_len;
+        remaining -= config_len;
+    }
+
+    return LIBUSB_SUCCESS;
+}
+
+static int op_get_config_descriptor_by_value(struct libusb_device *dev, uint8_t value, void **buffer) {
+    struct linux_device_priv *priv = usbi_get_device_priv(dev);
+    struct config_descriptor *config;
+    uint8_t                   idx;
+
+    for(idx = 0; idx < dev->device_descriptor.bNumConfigurations; idx++) {
+        config = &priv->config_descriptors[idx];
+        if(config->desc->bConfigurationValue == value) {
+            *buffer = config->desc;
+            return (int)config->actual_len;
+        }
+    }
+
+    return LIBUSB_ERROR_NOT_FOUND;
+}
+
+static int op_get_active_config_descriptor(struct libusb_device *dev, void *buffer, size_t len) {
+    struct linux_device_priv *priv = usbi_get_device_priv(dev);
+    void                     *config_desc;
+    int                       active_config;
+    int                       r;
+
+    if(priv->sysfs_dir) {
+        r = sysfs_get_active_config(dev, &active_config);
+        if(r < 0)
+            return r;
+    }
+    else {
+        /* Use cached bConfigurationValue */
+        active_config = priv->active_config;
+    }
+
+    if(active_config == -1) {
+        usbi_err(DEVICE_CTX(dev), "device unconfigured");
+        return LIBUSB_ERROR_NOT_FOUND;
+    }
+
+    r = op_get_config_descriptor_by_value(dev, (uint8_t)active_config, &config_desc);
+    if(r < 0)
+        return r;
+
+    len = MIN(len, (size_t)r);
+    memcpy(buffer, config_desc, len);
+    return len;
+}
+
+static int op_get_config_descriptor(struct libusb_device *dev, uint8_t config_index, void *buffer, size_t len) {
+    struct linux_device_priv *priv = usbi_get_device_priv(dev);
+    struct config_descriptor *config;
+
+    if(config_index >= dev->device_descriptor.bNumConfigurations)
+        return LIBUSB_ERROR_NOT_FOUND;
+
+    config = &priv->config_descriptors[config_index];
+    len    = MIN(len, config->actual_len);
+    memcpy(buffer, config->desc, len);
+    return len;
+}
+
+/* send a control message to retrieve active configuration */
+static int usbfs_get_active_config(struct libusb_device *dev, int fd) {
+    struct linux_device_priv *priv          = usbi_get_device_priv(dev);
+    uint8_t                   active_config = 0;
+    int                       r;
+
+    struct usbfs_ctrltransfer ctrl = { .bmRequestType = LIBUSB_ENDPOINT_IN,
+                                       .bRequest      = LIBUSB_REQUEST_GET_CONFIGURATION,
+                                       .wValue        = 0,
+                                       .wIndex        = 0,
+                                       .wLength       = 1,
+                                       .timeout       = 1000,
+                                       .data          = &active_config };
+
+    r = ioctl(fd, IOCTL_USBFS_CONTROL, &ctrl);
+    if(r < 0) {
+        if(errno == ENODEV)
+            return LIBUSB_ERROR_NO_DEVICE;
+
+        /* we hit this error path frequently with buggy devices :( */
+        usbi_warn(DEVICE_CTX(dev), "get configuration failed, errno=%d", errno);
+
+        /* assume the current configuration is the first one if we have
+         * the configuration descriptors, otherwise treat the device
+         * as unconfigured. */
+        if(priv->config_descriptors)
+            priv->active_config = (int)priv->config_descriptors[0].desc->bConfigurationValue;
+        else
+            priv->active_config = -1;
+    }
+    else if(active_config == 0) {
+        if(dev_has_config0(dev)) {
+            /* some buggy devices have a configuration 0, but we're
+             * reaching into the corner of a corner case here. */
+            priv->active_config = 0;
+        }
+        else {
+            priv->active_config = -1;
+        }
+    }
+    else {
+        priv->active_config = (int)active_config;
+    }
+
+    return LIBUSB_SUCCESS;
+}
+
+static enum libusb_speed usbfs_get_speed(struct libusb_context *ctx, int fd) {
+    int r;
+
+    r = ioctl(fd, IOCTL_USBFS_GET_SPEED, NULL);
+    switch(r) {
+    case USBFS_SPEED_UNKNOWN:
+        return LIBUSB_SPEED_UNKNOWN;
+    case USBFS_SPEED_LOW:
+        return LIBUSB_SPEED_LOW;
+    case USBFS_SPEED_FULL:
+        return LIBUSB_SPEED_FULL;
+    case USBFS_SPEED_HIGH:
+        return LIBUSB_SPEED_HIGH;
+    case USBFS_SPEED_WIRELESS:
+        return LIBUSB_SPEED_HIGH;
+    case USBFS_SPEED_SUPER:
+        return LIBUSB_SPEED_SUPER;
+    case USBFS_SPEED_SUPER_PLUS:
+        return LIBUSB_SPEED_SUPER_PLUS;
+    default:
+        usbi_warn(ctx, "Error getting device speed: %d", r);
+    }
+
+    return LIBUSB_SPEED_UNKNOWN;
+}
+
+static int initialize_device(struct libusb_device *dev, uint8_t busnum, uint8_t devaddr, const char *sysfs_dir, int wrapped_fd) {
+    struct linux_device_priv *priv = usbi_get_device_priv(dev);
+    struct libusb_context    *ctx  = DEVICE_CTX(dev);
+    size_t                    alloc_len;
+    int                       fd, speed, r;
+    ssize_t                   nb;
+
+    dev->bus_number     = busnum;
+    dev->device_address = devaddr;
+
+    if(sysfs_dir) {
+        priv->sysfs_dir = strdup(sysfs_dir);
+        if(!priv->sysfs_dir)
+            return LIBUSB_ERROR_NO_MEM;
+
+        /* Note speed can contain 1.5, in this case read_sysfs_attr()
+           will stop parsing at the '.' and return 1 */
+        if(read_sysfs_attr(ctx, sysfs_dir, "speed", INT_MAX, &speed) == 0) {
+            switch(speed) {
+            case 1:
+                dev->speed = LIBUSB_SPEED_LOW;
+                break;
+            case 12:
+                dev->speed = LIBUSB_SPEED_FULL;
+                break;
+            case 480:
+                dev->speed = LIBUSB_SPEED_HIGH;
+                break;
+            case 5000:
+                dev->speed = LIBUSB_SPEED_SUPER;
+                break;
+            case 10000:
+                dev->speed = LIBUSB_SPEED_SUPER_PLUS;
+                break;
+            default:
+                usbi_warn(ctx, "unknown device speed: %d Mbps", speed);
+            }
+        }
+    }
+    else if(wrapped_fd >= 0) {
+        dev->speed = usbfs_get_speed(ctx, wrapped_fd);
+    }
+
+    /* cache descriptors in memory */
+    if(sysfs_dir) {
+        fd = open_sysfs_attr(ctx, sysfs_dir, "descriptors");
+    }
+    else if(wrapped_fd < 0) {
+        fd = get_usbfs_fd(dev, O_RDONLY, 0);
+    }
+    else {
+        fd = wrapped_fd;
+        r  = lseek(fd, 0, SEEK_SET);
+        if(r < 0) {
+            usbi_err(ctx, "lseek failed, errno=%d", errno);
+            return LIBUSB_ERROR_IO;
+        }
+    }
+    if(fd < 0)
+        return fd;
+
+    alloc_len = 0;
+    do {
+        const size_t desc_read_length = 256;
+        uint8_t     *read_ptr;
+
+        alloc_len += desc_read_length;
+        priv->descriptors = usbi_reallocf(priv->descriptors, alloc_len);
+        if(!priv->descriptors) {
+            if(fd != wrapped_fd)
+                close(fd);
+            return LIBUSB_ERROR_NO_MEM;
+        }
+        read_ptr = (uint8_t *)priv->descriptors + priv->descriptors_len;
+        /* usbfs has holes in the file */
+        if(!sysfs_dir)
+            memset(read_ptr, 0, desc_read_length);
+        nb = read(fd, read_ptr, desc_read_length);
+        if(nb < 0) {
+            usbi_err(ctx, "read descriptor failed, errno=%d", errno);
+            if(fd != wrapped_fd)
+                close(fd);
+            return LIBUSB_ERROR_IO;
+        }
+        priv->descriptors_len += (size_t)nb;
+    } while(priv->descriptors_len == alloc_len);
+
+    if(fd != wrapped_fd)
+        close(fd);
+
+    if(priv->descriptors_len < LIBUSB_DT_DEVICE_SIZE) {
+        usbi_err(ctx, "short descriptor read (%zu)", priv->descriptors_len);
+        return LIBUSB_ERROR_IO;
+    }
+
+    r = parse_config_descriptors(dev);
+    if(r < 0)
+        return r;
+
+    memcpy(&dev->device_descriptor, priv->descriptors, LIBUSB_DT_DEVICE_SIZE);
+
+    if(sysfs_dir) {
+        /* sysfs descriptors are in bus-endian format */
+        usbi_localize_device_descriptor(&dev->device_descriptor);
+        return LIBUSB_SUCCESS;
+    }
+
+    /* cache active config */
+    if(wrapped_fd < 0)
+        fd = get_usbfs_fd(dev, O_RDWR, 1);
+    else
+        fd = wrapped_fd;
+    if(fd < 0) {
+        /* cannot send a control message to determine the active
+         * config. just assume the first one is active. */
+        usbi_warn(ctx, "Missing rw usbfs access; cannot determine "
+                       "active configuration descriptor");
+        if(priv->config_descriptors)
+            priv->active_config = (int)priv->config_descriptors[0].desc->bConfigurationValue;
+        else
+            priv->active_config = -1; /* No config dt */
+
+        return LIBUSB_SUCCESS;
+    }
+
+    r = usbfs_get_active_config(dev, fd);
+    if(fd != wrapped_fd)
+        close(fd);
+
+    return r;
+}
+
+static int linux_get_parent_info(struct libusb_device *dev, const char *sysfs_dir) {
+    struct libusb_context *ctx = DEVICE_CTX(dev);
+    struct libusb_device  *it;
+    char                  *parent_sysfs_dir, *tmp;
+    int                    ret, add_parent = 1;
+
+    /* XXX -- can we figure out the topology when using usbfs? */
+    if(!sysfs_dir || !strncmp(sysfs_dir, "usb", 3)) {
+        /* either using usbfs or finding the parent of a root hub */
+        return LIBUSB_SUCCESS;
+    }
+
+    parent_sysfs_dir = strdup(sysfs_dir);
+    if(!parent_sysfs_dir)
+        return LIBUSB_ERROR_NO_MEM;
+
+    if((tmp = strrchr(parent_sysfs_dir, '.')) || (tmp = strrchr(parent_sysfs_dir, '-'))) {
+        dev->port_number = atoi(tmp + 1);
+        *tmp             = '\0';
+    }
+    else {
+        usbi_warn(ctx, "Can not parse sysfs_dir: %s, no parent info", parent_sysfs_dir);
+        free(parent_sysfs_dir);
+        return LIBUSB_SUCCESS;
+    }
+
+    /* is the parent a root hub? */
+    if(!strchr(parent_sysfs_dir, '-')) {
+        tmp = parent_sysfs_dir;
+        ret = asprintf(&parent_sysfs_dir, "usb%s", tmp);
+        free(tmp);
+        if(ret < 0)
+            return LIBUSB_ERROR_NO_MEM;
+    }
+
+retry:
+    /* find the parent in the context */
+    usbi_mutex_lock(&ctx->usb_devs_lock);
+    for_each_device(ctx, it) {
+        struct linux_device_priv *priv = usbi_get_device_priv(it);
+
+        if(priv->sysfs_dir) {
+            if(!strcmp(priv->sysfs_dir, parent_sysfs_dir)) {
+                dev->parent_dev = libusb_ref_device(it);
+                break;
+            }
+        }
+    }
+    usbi_mutex_unlock(&ctx->usb_devs_lock);
+
+    if(!dev->parent_dev && add_parent) {
+        usbi_dbg(ctx, "parent_dev %s not enumerated yet, enumerating now", parent_sysfs_dir);
+        sysfs_scan_device(ctx, parent_sysfs_dir);
+        add_parent = 0;
+        goto retry;
+    }
+
+    usbi_dbg(ctx, "dev %p (%s) has parent %p (%s) port %u", (void *)dev, sysfs_dir, (void *)dev->parent_dev, parent_sysfs_dir, dev->port_number);
+
+    free(parent_sysfs_dir);
+
+    return LIBUSB_SUCCESS;
+}
+
+int linux_enumerate_device(struct libusb_context *ctx, uint8_t busnum, uint8_t devaddr, const char *sysfs_dir) {
+    unsigned long         session_id;
+    struct libusb_device *dev;
+    int                   r;
+
+    /* FIXME: session ID is not guaranteed unique as addresses can wrap and
+     * will be reused. instead we should add a simple sysfs attribute with
+     * a session ID. */
+    session_id = busnum << 8 | devaddr;
+    usbi_dbg(ctx, "busnum %u devaddr %u session_id %lu", busnum, devaddr, session_id);
+
+    dev = usbi_get_device_by_session_id(ctx, session_id);
+    if(dev) {
+        /* device already exists in the context */
+        usbi_dbg(ctx, "session_id %lu already exists", session_id);
+        libusb_unref_device(dev);
+        return LIBUSB_SUCCESS;
+    }
+
+    usbi_dbg(ctx, "allocating new device for %u/%u (session %lu)", busnum, devaddr, session_id);
+    dev = usbi_alloc_device(ctx, session_id);
+    if(!dev)
+        return LIBUSB_ERROR_NO_MEM;
+
+    r = initialize_device(dev, busnum, devaddr, sysfs_dir, -1);
+    if(r < 0)
+        goto out;
+    r = usbi_sanitize_device(dev);
+    if(r < 0)
+        goto out;
+
+    r = linux_get_parent_info(dev, sysfs_dir);
+    if(r < 0)
+        goto out;
+out:
+    if(r < 0)
+        libusb_unref_device(dev);
+    else
+        usbi_connect_device(dev);
+
+    return r;
+}
+
+void linux_hotplug_enumerate(uint8_t busnum, uint8_t devaddr, const char *sys_name) {
+    struct libusb_context *ctx;
+
+    usbi_mutex_static_lock(&active_contexts_lock);
+    for_each_context(ctx) {
+        linux_enumerate_device(ctx, busnum, devaddr, sys_name);
+    }
+    usbi_mutex_static_unlock(&active_contexts_lock);
+}
+
+void linux_device_disconnected(uint8_t busnum, uint8_t devaddr) {
+    struct libusb_context *ctx;
+    struct libusb_device  *dev;
+    unsigned long          session_id = busnum << 8 | devaddr;
+
+    usbi_mutex_static_lock(&active_contexts_lock);
+    for_each_context(ctx) {
+        dev = usbi_get_device_by_session_id(ctx, session_id);
+        if(dev) {
+            usbi_disconnect_device(dev);
+            libusb_unref_device(dev);
+        }
+        else {
+            usbi_dbg(ctx, "device not found for session %lx", session_id);
+        }
+    }
+    usbi_mutex_static_unlock(&active_contexts_lock);
+}
+
+#if !defined(HAVE_LIBUDEV)
+static int parse_u8(const char *str, uint8_t *val_p) {
+    char *endptr;
+    long  num;
+
+    errno = 0;
+    num   = strtol(str, &endptr, 10);
+    if(num < 0 || num > UINT8_MAX || errno)
+        return 0;
+    if(endptr == str || *endptr != '\0')
+        return 0;
+
+    *val_p = (uint8_t)num;
+    return 1;
+}
+
+/* open a bus directory and adds all discovered devices to the context */
+static int usbfs_scan_busdir(struct libusb_context *ctx, uint8_t busnum) {
+    DIR           *dir;
+    char           dirpath[20];
+    struct dirent *entry;
+    int            r = LIBUSB_ERROR_IO;
+
+    snprintf(dirpath, sizeof(dirpath), USB_DEVTMPFS_PATH "/%03u", busnum);
+    usbi_dbg(ctx, "%s", dirpath);
+    dir = opendir(dirpath);
+    if(!dir) {
+        usbi_err(ctx, "opendir '%s' failed, errno=%d", dirpath, errno);
+        /* FIXME: should handle valid race conditions like hub unplugged
+         * during directory iteration - this is not an error */
+        return r;
+    }
+
+    while((entry = readdir(dir))) {
+        uint8_t devaddr;
+
+        if(entry->d_name[0] == '.')
+            continue;
+
+        if(!parse_u8(entry->d_name, &devaddr)) {
+            usbi_dbg(ctx, "unknown dir entry %s", entry->d_name);
+            continue;
+        }
+
+        if(linux_enumerate_device(ctx, busnum, devaddr, NULL)) {
+            usbi_dbg(ctx, "failed to enumerate dir entry %s", entry->d_name);
+            continue;
+        }
+
+        r = 0;
+    }
+
+    closedir(dir);
+    return r;
+}
+
+static int usbfs_get_device_list(struct libusb_context *ctx) {
+    struct dirent *entry;
+    DIR           *buses;
+    uint8_t        busnum, devaddr;
+    int            r = 0;
+
+    if(usbdev_names)
+        buses = opendir(USBDEV_PATH);
+    else
+        buses = opendir(USB_DEVTMPFS_PATH);
+
+    if(!buses) {
+        usbi_err(ctx, "opendir buses failed, errno=%d", errno);
+        return LIBUSB_ERROR_IO;
+    }
+
+    while((entry = readdir(buses))) {
+        if(entry->d_name[0] == '.')
+            continue;
+
+        if(usbdev_names) {
+            if(!is_usbdev_entry(entry->d_name, &busnum, &devaddr))
+                continue;
+
+            r = linux_enumerate_device(ctx, busnum, devaddr, NULL);
+            if(r < 0) {
+                usbi_dbg(ctx, "failed to enumerate dir entry %s", entry->d_name);
+                continue;
+            }
+        }
+        else {
+            if(!parse_u8(entry->d_name, &busnum)) {
+                usbi_dbg(ctx, "unknown dir entry %s", entry->d_name);
+                continue;
+            }
+
+            r = usbfs_scan_busdir(ctx, busnum);
+            if(r < 0)
+                break;
+        }
+    }
+
+    closedir(buses);
+    return r;
+}
+
+static int sysfs_get_device_list(struct libusb_context *ctx) {
+    DIR           *devices = opendir(SYSFS_DEVICE_PATH);
+    struct dirent *entry;
+    int            num_devices    = 0;
+    int            num_enumerated = 0;
+
+    if(!devices) {
+        usbi_err(ctx, "opendir devices failed, errno=%d", errno);
+        return LIBUSB_ERROR_IO;
+    }
+
+    while((entry = readdir(devices))) {
+        if((!isdigit(entry->d_name[0]) && strncmp(entry->d_name, "usb", 3)) || strchr(entry->d_name, ':'))
+            continue;
+
+        num_devices++;
+
+        if(sysfs_scan_device(ctx, entry->d_name)) {
+            usbi_dbg(ctx, "failed to enumerate dir entry %s", entry->d_name);
+            continue;
+        }
+
+        num_enumerated++;
+    }
+
+    closedir(devices);
+
+    /* successful if at least one device was enumerated or no devices were found */
+    if(num_enumerated || !num_devices)
+        return LIBUSB_SUCCESS;
+    else
+        return LIBUSB_ERROR_IO;
+}
+
+static int linux_default_scan_devices(struct libusb_context *ctx) {
+    /* we can retrieve device list and descriptors from sysfs or usbfs.
+     * sysfs is preferable, because if we use usbfs we end up resuming
+     * any autosuspended USB devices. however, sysfs is not available
+     * everywhere, so we need a usbfs fallback too.
+     */
+    if(sysfs_available)
+        return sysfs_get_device_list(ctx);
+    else
+        return usbfs_get_device_list(ctx);
+}
+#endif
+
+static int initialize_handle(struct libusb_device_handle *handle, int fd) {
+    struct linux_device_handle_priv *hpriv = usbi_get_device_handle_priv(handle);
+    int                              r;
+
+    hpriv->fd = fd;
+
+    r = ioctl(fd, IOCTL_USBFS_GET_CAPABILITIES, &hpriv->caps);
+    if(r < 0) {
+        if(errno == ENOTTY)
+            usbi_dbg(HANDLE_CTX(handle), "getcap not available");
+        else
+            usbi_err(HANDLE_CTX(handle), "getcap failed, errno=%d", errno);
+        hpriv->caps = USBFS_CAP_BULK_CONTINUATION;
+    }
+
+    return usbi_add_event_source(HANDLE_CTX(handle), hpriv->fd, POLLOUT);
+}
+
+static int op_wrap_sys_device(struct libusb_context *ctx, struct libusb_device_handle *handle, intptr_t sys_dev) {
+    struct linux_device_handle_priv *hpriv = usbi_get_device_handle_priv(handle);
+    int                              fd    = (int)sys_dev;
+    uint8_t                          busnum, devaddr;
+    struct usbfs_connectinfo         ci;
+    struct libusb_device            *dev;
+    int                              r;
+
+    r = linux_get_device_address(ctx, 1, &busnum, &devaddr, NULL, NULL, fd);
+    if(r < 0) {
+        r = ioctl(fd, IOCTL_USBFS_CONNECTINFO, &ci);
+        if(r < 0) {
+            usbi_err(ctx, "connectinfo failed, errno=%d", errno);
+            return LIBUSB_ERROR_IO;
+        }
+        /* There is no ioctl to get the bus number. We choose 0 here
+         * as linux starts numbering buses from 1. */
+        busnum  = 0;
+        devaddr = ci.devnum;
+    }
+
+    /* Session id is unused as we do not add the device to the list of
+     * connected devices. */
+    usbi_dbg(ctx, "allocating new device for fd %d", fd);
+    dev = usbi_alloc_device(ctx, 0);
+    if(!dev)
+        return LIBUSB_ERROR_NO_MEM;
+
+    r = initialize_device(dev, busnum, devaddr, NULL, fd);
+    if(r < 0)
+        goto out;
+    r = usbi_sanitize_device(dev);
+    if(r < 0)
+        goto out;
+    /* Consider the device as connected, but do not add it to the managed
+     * device list. */
+    usbi_atomic_store(&dev->attached, 1);
+    handle->dev = dev;
+
+    r              = initialize_handle(handle, fd);
+    hpriv->fd_keep = 1;
+
+out:
+    if(r < 0)
+        libusb_unref_device(dev);
+    return r;
+}
+
+static int op_open(struct libusb_device_handle *handle) {
+    int fd, r;
+
+    fd = get_usbfs_fd(handle->dev, O_RDWR, 0);
+    if(fd < 0) {
+        if(fd == LIBUSB_ERROR_NO_DEVICE) {
+            /* device will still be marked as attached if hotplug monitor thread
+             * hasn't processed remove event yet */
+            usbi_mutex_static_lock(&linux_hotplug_lock);
+            if(usbi_atomic_load(&handle->dev->attached)) {
+                usbi_dbg(HANDLE_CTX(handle), "open failed with no device, but device still attached");
+                linux_device_disconnected(handle->dev->bus_number, handle->dev->device_address);
+            }
+            usbi_mutex_static_unlock(&linux_hotplug_lock);
+        }
+        return fd;
+    }
+
+    r = initialize_handle(handle, fd);
+    if(r < 0)
+        close(fd);
+
+    return r;
+}
+
+static void op_close(struct libusb_device_handle *dev_handle) {
+    struct linux_device_handle_priv *hpriv = usbi_get_device_handle_priv(dev_handle);
+
+    /* fd may have already been removed by POLLERR condition in op_handle_events() */
+    if(!hpriv->fd_removed)
+        usbi_remove_event_source(HANDLE_CTX(dev_handle), hpriv->fd);
+    if(!hpriv->fd_keep)
+        close(hpriv->fd);
+}
+
+static int op_get_configuration(struct libusb_device_handle *handle, uint8_t *config) {
+    struct linux_device_priv *priv          = usbi_get_device_priv(handle->dev);
+    int                       active_config = -1; /* to please compiler */
+    int                       r;
+
+    if(priv->sysfs_dir) {
+        r = sysfs_get_active_config(handle->dev, &active_config);
+    }
+    else {
+        struct linux_device_handle_priv *hpriv = usbi_get_device_handle_priv(handle);
+
+        r = usbfs_get_active_config(handle->dev, hpriv->fd);
+        if(r == LIBUSB_SUCCESS)
+            active_config = priv->active_config;
+    }
+    if(r < 0)
+        return r;
+
+    if(active_config == -1) {
+        usbi_warn(HANDLE_CTX(handle), "device unconfigured");
+        active_config = 0;
+    }
+
+    *config = (uint8_t)active_config;
+
+    return 0;
+}
+
+static int op_set_configuration(struct libusb_device_handle *handle, int config) {
+    struct linux_device_priv        *priv  = usbi_get_device_priv(handle->dev);
+    struct linux_device_handle_priv *hpriv = usbi_get_device_handle_priv(handle);
+    int                              fd    = hpriv->fd;
+    int                              r     = ioctl(fd, IOCTL_USBFS_SETCONFIGURATION, &config);
+
+    if(r < 0) {
+        if(errno == EINVAL)
+            return LIBUSB_ERROR_NOT_FOUND;
+        else if(errno == EBUSY)
+            return LIBUSB_ERROR_BUSY;
+        else if(errno == ENODEV)
+            return LIBUSB_ERROR_NO_DEVICE;
+
+        usbi_err(HANDLE_CTX(handle), "set configuration failed, errno=%d", errno);
+        return LIBUSB_ERROR_OTHER;
+    }
+
+    /* if necessary, update our cached active config descriptor */
+    if(!priv->sysfs_dir) {
+        if(config == 0 && !dev_has_config0(handle->dev))
+            config = -1;
+
+        priv->active_config = config;
+    }
+
+    return LIBUSB_SUCCESS;
+}
+
+static int claim_interface(struct libusb_device_handle *handle, unsigned int iface) {
+    struct linux_device_handle_priv *hpriv = usbi_get_device_handle_priv(handle);
+    int                              fd    = hpriv->fd;
+    int                              r     = ioctl(fd, IOCTL_USBFS_CLAIMINTERFACE, &iface);
+
+    if(r < 0) {
+        if(errno == ENOENT)
+            return LIBUSB_ERROR_NOT_FOUND;
+        else if(errno == EBUSY)
+            return LIBUSB_ERROR_BUSY;
+        else if(errno == ENODEV)
+            return LIBUSB_ERROR_NO_DEVICE;
+
+        usbi_err(HANDLE_CTX(handle), "claim interface failed, errno=%d", errno);
+        return LIBUSB_ERROR_OTHER;
+    }
+    return 0;
+}
+
+static int release_interface(struct libusb_device_handle *handle, unsigned int iface) {
+    struct linux_device_handle_priv *hpriv = usbi_get_device_handle_priv(handle);
+    int                              fd    = hpriv->fd;
+    int                              r     = ioctl(fd, IOCTL_USBFS_RELEASEINTERFACE, &iface);
+
+    if(r < 0) {
+        if(errno == ENODEV)
+            return LIBUSB_ERROR_NO_DEVICE;
+
+        usbi_err(HANDLE_CTX(handle), "release interface failed, errno=%d", errno);
+        return LIBUSB_ERROR_OTHER;
+    }
+    return 0;
+}
+
+static int op_set_interface(struct libusb_device_handle *handle, uint8_t interface, uint8_t altsetting) {
+    struct linux_device_handle_priv *hpriv = usbi_get_device_handle_priv(handle);
+    int                              fd    = hpriv->fd;
+    struct usbfs_setinterface        setintf;
+    int                              r;
+
+    setintf.interface  = interface;
+    setintf.altsetting = altsetting;
+    r                  = ioctl(fd, IOCTL_USBFS_SETINTERFACE, &setintf);
+    if(r < 0) {
+        if(errno == EINVAL)
+            return LIBUSB_ERROR_NOT_FOUND;
+        else if(errno == ENODEV)
+            return LIBUSB_ERROR_NO_DEVICE;
+
+        usbi_err(HANDLE_CTX(handle), "set interface failed, errno=%d", errno);
+        return LIBUSB_ERROR_OTHER;
+    }
+
+    return 0;
+}
+
+static int op_clear_halt(struct libusb_device_handle *handle, unsigned char endpoint) {
+    struct linux_device_handle_priv *hpriv     = usbi_get_device_handle_priv(handle);
+    int                              fd        = hpriv->fd;
+    unsigned int                     _endpoint = endpoint;
+    int                              r         = ioctl(fd, IOCTL_USBFS_CLEAR_HALT, &_endpoint);
+
+    if(r < 0) {
+        if(errno == ENOENT)
+            return LIBUSB_ERROR_NOT_FOUND;
+        else if(errno == ENODEV)
+            return LIBUSB_ERROR_NO_DEVICE;
+
+        usbi_err(HANDLE_CTX(handle), "clear halt failed, errno=%d", errno);
+        return LIBUSB_ERROR_OTHER;
+    }
+
+    return 0;
+}
+
+static int op_reset_device(struct libusb_device_handle *handle) {
+    struct linux_device_handle_priv *hpriv = usbi_get_device_handle_priv(handle);
+    int                              fd    = hpriv->fd;
+    int                              r, ret = 0;
+    uint8_t                          i;
+
+    /* Doing a device reset will cause the usbfs driver to get unbound
+     * from any interfaces it is bound to. By voluntarily unbinding
+     * the usbfs driver ourself, we stop the kernel from rebinding
+     * the interface after reset (which would end up with the interface
+     * getting bound to the in kernel driver if any). */
+    for(i = 0; i < USB_MAXINTERFACES; i++) {
+        if(handle->claimed_interfaces & (1UL << i))
+            release_interface(handle, i);
+    }
+
+    usbi_mutex_lock(&handle->lock);
+    r = ioctl(fd, IOCTL_USBFS_RESET, NULL);
+    if(r < 0) {
+        if(errno == ENODEV) {
+            ret = LIBUSB_ERROR_NOT_FOUND;
+            goto out;
+        }
+
+        usbi_err(HANDLE_CTX(handle), "reset failed, errno=%d", errno);
+        ret = LIBUSB_ERROR_OTHER;
+        goto out;
+    }
+
+    /* And re-claim any interfaces which were claimed before the reset */
+    for(i = 0; i < USB_MAXINTERFACES; i++) {
+        if(!(handle->claimed_interfaces & (1UL << i)))
+            continue;
+        /*
+         * A driver may have completed modprobing during
+         * IOCTL_USBFS_RESET, and bound itself as soon as
+         * IOCTL_USBFS_RESET released the device lock
+         */
+        r = detach_kernel_driver_and_claim(handle, i);
+        if(r) {
+            usbi_warn(HANDLE_CTX(handle), "failed to re-claim interface %u after reset: %s", i, libusb_error_name(r));
+            handle->claimed_interfaces &= ~(1UL << i);
+            ret = LIBUSB_ERROR_NOT_FOUND;
+        }
+    }
+out:
+    usbi_mutex_unlock(&handle->lock);
+    return ret;
+}
+
+static int do_streams_ioctl(struct libusb_device_handle *handle, long req, uint32_t num_streams, unsigned char *endpoints, int num_endpoints) {
+    struct linux_device_handle_priv *hpriv = usbi_get_device_handle_priv(handle);
+    int                              r, fd = hpriv->fd;
+    struct usbfs_streams            *streams;
+
+    if(num_endpoints > 30) /* Max 15 in + 15 out eps */
+        return LIBUSB_ERROR_INVALID_PARAM;
+
+    streams = malloc(sizeof(*streams) + num_endpoints);
+    if(!streams)
+        return LIBUSB_ERROR_NO_MEM;
+
+    streams->num_streams = num_streams;
+    streams->num_eps     = num_endpoints;
+    memcpy(streams->eps, endpoints, num_endpoints);
+
+    r = ioctl(fd, req, streams);
+
+    free(streams);
+
+    if(r < 0) {
+        if(errno == ENOTTY)
+            return LIBUSB_ERROR_NOT_SUPPORTED;
+        else if(errno == EINVAL)
+            return LIBUSB_ERROR_INVALID_PARAM;
+        else if(errno == ENODEV)
+            return LIBUSB_ERROR_NO_DEVICE;
+
+        usbi_err(HANDLE_CTX(handle), "streams-ioctl failed, errno=%d", errno);
+        return LIBUSB_ERROR_OTHER;
+    }
+    return r;
+}
+
+static int op_alloc_streams(struct libusb_device_handle *handle, uint32_t num_streams, unsigned char *endpoints, int num_endpoints) {
+    return do_streams_ioctl(handle, IOCTL_USBFS_ALLOC_STREAMS, num_streams, endpoints, num_endpoints);
+}
+
+static int op_free_streams(struct libusb_device_handle *handle, unsigned char *endpoints, int num_endpoints) {
+    return do_streams_ioctl(handle, IOCTL_USBFS_FREE_STREAMS, 0, endpoints, num_endpoints);
+}
+
+static void *op_dev_mem_alloc(struct libusb_device_handle *handle, size_t len) {
+    struct linux_device_handle_priv *hpriv = usbi_get_device_handle_priv(handle);
+    void                            *buffer;
+
+    buffer = mmap(NULL, len, PROT_READ | PROT_WRITE, MAP_SHARED, hpriv->fd, 0);
+    if(buffer == MAP_FAILED) {
+        usbi_err(HANDLE_CTX(handle), "alloc dev mem failed, errno=%d", errno);
+        return NULL;
+    }
+    return buffer;
+}
+
+static int op_dev_mem_free(struct libusb_device_handle *handle, void *buffer, size_t len) {
+    if(munmap(buffer, len) != 0) {
+        usbi_err(HANDLE_CTX(handle), "free dev mem failed, errno=%d", errno);
+        return LIBUSB_ERROR_OTHER;
+    }
+    else {
+        return LIBUSB_SUCCESS;
+    }
+}
+
+static int op_kernel_driver_active(struct libusb_device_handle *handle, uint8_t interface) {
+    struct linux_device_handle_priv *hpriv = usbi_get_device_handle_priv(handle);
+    int                              fd    = hpriv->fd;
+    struct usbfs_getdriver           getdrv;
+    int                              r;
+
+    getdrv.interface = interface;
+    r                = ioctl(fd, IOCTL_USBFS_GETDRIVER, &getdrv);
+    if(r < 0) {
+        if(errno == ENODATA)
+            return 0;
+        else if(errno == ENODEV)
+            return LIBUSB_ERROR_NO_DEVICE;
+
+        usbi_err(HANDLE_CTX(handle), "get driver failed, errno=%d", errno);
+        return LIBUSB_ERROR_OTHER;
+    }
+
+    return strcmp(getdrv.driver, "usbfs") != 0;
+}
+
+static int op_detach_kernel_driver(struct libusb_device_handle *handle, uint8_t interface) {
+    struct linux_device_handle_priv *hpriv = usbi_get_device_handle_priv(handle);
+    int                              fd    = hpriv->fd;
+    struct usbfs_ioctl               command;
+    struct usbfs_getdriver           getdrv;
+    int                              r;
+
+    command.ifno       = interface;
+    command.ioctl_code = IOCTL_USBFS_DISCONNECT;
+    command.data       = NULL;
+
+    getdrv.interface = interface;
+    r                = ioctl(fd, IOCTL_USBFS_GETDRIVER, &getdrv);
+    if(r == 0 && !strcmp(getdrv.driver, "usbfs"))
+        return LIBUSB_ERROR_NOT_FOUND;
+
+    r = ioctl(fd, IOCTL_USBFS_IOCTL, &command);
+    if(r < 0) {
+        if(errno == ENODATA)
+            return LIBUSB_ERROR_NOT_FOUND;
+        else if(errno == EINVAL)
+            return LIBUSB_ERROR_INVALID_PARAM;
+        else if(errno == ENODEV)
+            return LIBUSB_ERROR_NO_DEVICE;
+
+        usbi_err(HANDLE_CTX(handle), "detach failed, errno=%d", errno);
+        return LIBUSB_ERROR_OTHER;
+    }
+
+    return 0;
+}
+
+static int op_attach_kernel_driver(struct libusb_device_handle *handle, uint8_t interface) {
+    struct linux_device_handle_priv *hpriv = usbi_get_device_handle_priv(handle);
+    int                              fd    = hpriv->fd;
+    struct usbfs_ioctl               command;
+    int                              r;
+
+    command.ifno       = interface;
+    command.ioctl_code = IOCTL_USBFS_CONNECT;
+    command.data       = NULL;
+
+    r = ioctl(fd, IOCTL_USBFS_IOCTL, &command);
+    if(r < 0) {
+        if(errno == ENODATA)
+            return LIBUSB_ERROR_NOT_FOUND;
+        else if(errno == EINVAL)
+            return LIBUSB_ERROR_INVALID_PARAM;
+        else if(errno == ENODEV)
+            return LIBUSB_ERROR_NO_DEVICE;
+        else if(errno == EBUSY)
+            return LIBUSB_ERROR_BUSY;
+
+        usbi_err(HANDLE_CTX(handle), "attach failed, errno=%d", errno);
+        return LIBUSB_ERROR_OTHER;
+    }
+    else if(r == 0) {
+        return LIBUSB_ERROR_NOT_FOUND;
+    }
+
+    return 0;
+}
+
+static int detach_kernel_driver_and_claim(struct libusb_device_handle *handle, uint8_t interface) {
+    struct linux_device_handle_priv *hpriv = usbi_get_device_handle_priv(handle);
+    struct usbfs_disconnect_claim    dc;
+    int                              r, fd = hpriv->fd;
+
+    dc.interface = interface;
+    strcpy(dc.driver, "usbfs");
+    dc.flags = USBFS_DISCONNECT_CLAIM_EXCEPT_DRIVER;
+    r        = ioctl(fd, IOCTL_USBFS_DISCONNECT_CLAIM, &dc);
+    if(r == 0)
+        return 0;
+    switch(errno) {
+    case ENOTTY:
+        break;
+    case EBUSY:
+        return LIBUSB_ERROR_BUSY;
+    case EINVAL:
+        return LIBUSB_ERROR_INVALID_PARAM;
+    case ENODEV:
+        return LIBUSB_ERROR_NO_DEVICE;
+    default:
+        usbi_err(HANDLE_CTX(handle), "disconnect-and-claim failed, errno=%d", errno);
+        return LIBUSB_ERROR_OTHER;
+    }
+
+    /* Fallback code for kernels which don't support the
+       disconnect-and-claim ioctl */
+    r = op_detach_kernel_driver(handle, interface);
+    if(r != 0 && r != LIBUSB_ERROR_NOT_FOUND)
+        return r;
+
+    return claim_interface(handle, interface);
+}
+
+static int op_claim_interface(struct libusb_device_handle *handle, uint8_t interface) {
+    if(handle->auto_detach_kernel_driver)
+        return detach_kernel_driver_and_claim(handle, interface);
+    else
+        return claim_interface(handle, interface);
+}
+
+static int op_release_interface(struct libusb_device_handle *handle, uint8_t interface) {
+    int r;
+
+    r = release_interface(handle, interface);
+    if(r)
+        return r;
+
+    if(handle->auto_detach_kernel_driver)
+        op_attach_kernel_driver(handle, interface);
+
+    return 0;
+}
+
+static void op_destroy_device(struct libusb_device *dev) {
+    struct linux_device_priv *priv = usbi_get_device_priv(dev);
+
+    free(priv->config_descriptors);
+    free(priv->descriptors);
+    free(priv->sysfs_dir);
+}
+
+/* URBs are discarded in reverse order of submission to avoid races. */
+static int discard_urbs(struct usbi_transfer *itransfer, int first, int last_plus_one) {
+    struct libusb_transfer          *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+    struct linux_transfer_priv      *tpriv    = usbi_get_transfer_priv(itransfer);
+    struct linux_device_handle_priv *hpriv    = usbi_get_device_handle_priv(transfer->dev_handle);
+    int                              i, ret = 0;
+    struct usbfs_urb                *urb;
+
+    for(i = last_plus_one - 1; i >= first; i--) {
+        if(transfer->type == LIBUSB_TRANSFER_TYPE_ISOCHRONOUS)
+            urb = tpriv->iso_urbs[i];
+        else
+            urb = &tpriv->urbs[i];
+
+        if(ioctl(hpriv->fd, IOCTL_USBFS_DISCARDURB, urb) == 0)
+            continue;
+
+        if(errno == EINVAL) {
+            usbi_dbg(TRANSFER_CTX(transfer), "URB not found --> assuming ready to be reaped");
+            if(i == (last_plus_one - 1))
+                ret = LIBUSB_ERROR_NOT_FOUND;
+        }
+        else if(errno == ENODEV) {
+            usbi_dbg(TRANSFER_CTX(transfer), "Device not found for URB --> assuming ready to be reaped");
+            ret = LIBUSB_ERROR_NO_DEVICE;
+        }
+        else {
+            usbi_warn(TRANSFER_CTX(transfer), "unrecognised discard errno %d", errno);
+            ret = LIBUSB_ERROR_OTHER;
+        }
+    }
+    return ret;
+}
+
+static void free_iso_urbs(struct linux_transfer_priv *tpriv) {
+    int i;
+
+    for(i = 0; i < tpriv->num_urbs; i++) {
+        struct usbfs_urb *urb = tpriv->iso_urbs[i];
+
+        if(!urb)
+            break;
+        free(urb);
+    }
+
+    free(tpriv->iso_urbs);
+    tpriv->iso_urbs = NULL;
+}
+
+static int submit_bulk_transfer(struct usbi_transfer *itransfer) {
+    struct libusb_transfer          *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+    struct linux_transfer_priv      *tpriv    = usbi_get_transfer_priv(itransfer);
+    struct linux_device_handle_priv *hpriv    = usbi_get_device_handle_priv(transfer->dev_handle);
+    struct usbfs_urb                *urbs;
+    int                              is_out = IS_XFEROUT(transfer);
+    int                              bulk_buffer_len, use_bulk_continuation;
+    int                              num_urbs;
+    int                              last_urb_partial = 0;
+    int                              r;
+    int                              i;
+
+    /*
+     * Older versions of usbfs place a 16kb limit on bulk URBs. We work
+     * around this by splitting large transfers into 16k blocks, and then
+     * submit all urbs at once. it would be simpler to submit one urb at
+     * a time, but there is a big performance gain doing it this way.
+     *
+     * Newer versions lift the 16k limit (USBFS_CAP_NO_PACKET_SIZE_LIM),
+     * using arbitrary large transfers can still be a bad idea though, as
+     * the kernel needs to allocate physical contiguous memory for this,
+     * which may fail for large buffers.
+     *
+     * The kernel solves this problem by splitting the transfer into
+     * blocks itself when the host-controller is scatter-gather capable
+     * (USBFS_CAP_BULK_SCATTER_GATHER), which most controllers are.
+     *
+     * Last, there is the issue of short-transfers when splitting, for
+     * short split-transfers to work reliable USBFS_CAP_BULK_CONTINUATION
+     * is needed, but this is not always available.
+     */
+    if(hpriv->caps & USBFS_CAP_BULK_SCATTER_GATHER) {
+        /* Good! Just submit everything in one go */
+        bulk_buffer_len       = transfer->length ? transfer->length : 1;
+        use_bulk_continuation = 0;
+    }
+    else if(hpriv->caps & USBFS_CAP_BULK_CONTINUATION) {
+        /* Split the transfers and use bulk-continuation to
+           avoid issues with short-transfers */
+        bulk_buffer_len       = MAX_BULK_BUFFER_LENGTH;
+        use_bulk_continuation = 1;
+    }
+    else if(hpriv->caps & USBFS_CAP_NO_PACKET_SIZE_LIM) {
+        /* Don't split, assume the kernel can alloc the buffer
+           (otherwise the submit will fail with -ENOMEM) */
+        bulk_buffer_len       = transfer->length ? transfer->length : 1;
+        use_bulk_continuation = 0;
+    }
+    else {
+        /* Bad, splitting without bulk-continuation, short transfers
+           which end before the last urb will not work reliable! */
+        /* Note we don't warn here as this is "normal" on kernels <
+           2.6.32 and not a problem for most applications */
+        bulk_buffer_len       = MAX_BULK_BUFFER_LENGTH;
+        use_bulk_continuation = 0;
+    }
+
+    num_urbs = transfer->length / bulk_buffer_len;
+
+    if(transfer->length == 0) {
+        num_urbs = 1;
+    }
+    else if((transfer->length % bulk_buffer_len) > 0) {
+        last_urb_partial = 1;
+        num_urbs++;
+    }
+    usbi_dbg(TRANSFER_CTX(transfer), "need %d urbs for new transfer with length %d", num_urbs, transfer->length);
+    urbs = calloc(num_urbs, sizeof(*urbs));
+    if(!urbs)
+        return LIBUSB_ERROR_NO_MEM;
+    tpriv->urbs        = urbs;
+    tpriv->num_urbs    = num_urbs;
+    tpriv->num_retired = 0;
+    tpriv->reap_action = NORMAL;
+    tpriv->reap_status = LIBUSB_TRANSFER_COMPLETED;
+
+    for(i = 0; i < num_urbs; i++) {
+        struct usbfs_urb *urb = &urbs[i];
+
+        urb->usercontext = itransfer;
+        switch(transfer->type) {
+        case LIBUSB_TRANSFER_TYPE_BULK:
+            urb->type      = USBFS_URB_TYPE_BULK;
+            urb->stream_id = 0;
+            break;
+        case LIBUSB_TRANSFER_TYPE_BULK_STREAM:
+            urb->type      = USBFS_URB_TYPE_BULK;
+            urb->stream_id = itransfer->stream_id;
+            break;
+        case LIBUSB_TRANSFER_TYPE_INTERRUPT:
+            urb->type = USBFS_URB_TYPE_INTERRUPT;
+            break;
+        }
+        urb->endpoint = transfer->endpoint;
+        urb->buffer   = transfer->buffer + (i * bulk_buffer_len);
+
+        /* don't set the short not ok flag for the last URB */
+        if(use_bulk_continuation && !is_out && (i < num_urbs - 1))
+            urb->flags = USBFS_URB_SHORT_NOT_OK;
+
+        if(i == num_urbs - 1 && last_urb_partial)
+            urb->buffer_length = transfer->length % bulk_buffer_len;
+        else if(transfer->length == 0)
+            urb->buffer_length = 0;
+        else
+            urb->buffer_length = bulk_buffer_len;
+
+        if(i > 0 && use_bulk_continuation)
+            urb->flags |= USBFS_URB_BULK_CONTINUATION;
+
+        /* we have already checked that the flag is supported */
+        if(is_out && i == num_urbs - 1 && (transfer->flags & LIBUSB_TRANSFER_ADD_ZERO_PACKET))
+            urb->flags |= USBFS_URB_ZERO_PACKET;
+
+        r = ioctl(hpriv->fd, IOCTL_USBFS_SUBMITURB, urb);
+        if(r == 0)
+            continue;
+
+        if(errno == ENODEV) {
+            r = LIBUSB_ERROR_NO_DEVICE;
+        }
+        else if(errno == ENOMEM) {
+            r = LIBUSB_ERROR_NO_MEM;
+        }
+        else {
+            usbi_err(TRANSFER_CTX(transfer), "submiturb failed, errno=%d", errno);
+            r = LIBUSB_ERROR_IO;
+        }
+
+        /* if the first URB submission fails, we can simply free up and
+         * return failure immediately. */
+        if(i == 0) {
+            usbi_dbg(TRANSFER_CTX(transfer), "first URB failed, easy peasy");
+            free(urbs);
+            tpriv->urbs = NULL;
+            return r;
+        }
+
+        /* if it's not the first URB that failed, the situation is a bit
+         * tricky. we may need to discard all previous URBs. there are
+         * complications:
+         *  - discarding is asynchronous - discarded urbs will be reaped
+         *    later. the user must not have freed the transfer when the
+         *    discarded URBs are reaped, otherwise libusb will be using
+         *    freed memory.
+         *  - the earlier URBs may have completed successfully and we do
+         *    not want to throw away any data.
+         *  - this URB failing may be no error; EREMOTEIO means that
+         *    this transfer simply didn't need all the URBs we submitted
+         * so, we report that the transfer was submitted successfully and
+         * in case of error we discard all previous URBs. later when
+         * the final reap completes we can report error to the user,
+         * or success if an earlier URB was completed successfully.
+         */
+        tpriv->reap_action = errno == EREMOTEIO ? COMPLETED_EARLY : SUBMIT_FAILED;
+
+        /* The URBs we haven't submitted yet we count as already
+         * retired. */
+        tpriv->num_retired += num_urbs - i;
+
+        /* If we completed short then don't try to discard. */
+        if(tpriv->reap_action == COMPLETED_EARLY)
+            return 0;
+
+        discard_urbs(itransfer, 0, i);
+
+        usbi_dbg(TRANSFER_CTX(transfer),
+                 "reporting successful submission but waiting for %d "
+                 "discards before reporting error",
+                 i);
+        return 0;
+    }
+
+    return 0;
+}
+
+static int submit_iso_transfer(struct usbi_transfer *itransfer) {
+    struct libusb_transfer          *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+    struct linux_transfer_priv      *tpriv    = usbi_get_transfer_priv(itransfer);
+    struct linux_device_handle_priv *hpriv    = usbi_get_device_handle_priv(transfer->dev_handle);
+    struct usbfs_urb               **urbs;
+    int                              num_packets = transfer->num_iso_packets;
+    int                              num_packets_remaining;
+    int                              i, j;
+    int                              num_urbs;
+    unsigned int                     packet_len;
+    unsigned int                     total_len  = 0;
+    unsigned char                   *urb_buffer = transfer->buffer;
+
+    if(num_packets < 1)
+        return LIBUSB_ERROR_INVALID_PARAM;
+
+    /* usbfs places arbitrary limits on iso URBs. this limit has changed
+     * at least three times, but we attempt to detect this limit during
+     * init and check it here. if the kernel rejects the request due to
+     * its size, we return an error indicating such to the user.
+     */
+    for(i = 0; i < num_packets; i++) {
+        packet_len = transfer->iso_packet_desc[i].length;
+
+        if(packet_len > max_iso_packet_len) {
+            usbi_warn(TRANSFER_CTX(transfer), "iso packet length of %u bytes exceeds maximum of %u bytes", packet_len, max_iso_packet_len);
+            return LIBUSB_ERROR_INVALID_PARAM;
+        }
+
+        total_len += packet_len;
+    }
+
+    if(transfer->length < (int)total_len)
+        return LIBUSB_ERROR_INVALID_PARAM;
+
+    /* usbfs limits the number of iso packets per URB */
+    num_urbs = (num_packets + (MAX_ISO_PACKETS_PER_URB - 1)) / MAX_ISO_PACKETS_PER_URB;
+
+    usbi_dbg(TRANSFER_CTX(transfer), "need %d urbs for new transfer with length %d", num_urbs, transfer->length);
+
+    urbs = calloc(num_urbs, sizeof(*urbs));
+    if(!urbs)
+        return LIBUSB_ERROR_NO_MEM;
+
+    tpriv->iso_urbs          = urbs;
+    tpriv->num_urbs          = num_urbs;
+    tpriv->num_retired       = 0;
+    tpriv->reap_action       = NORMAL;
+    tpriv->iso_packet_offset = 0;
+
+    /* allocate + initialize each URB with the correct number of packets */
+    num_packets_remaining = num_packets;
+    for(i = 0, j = 0; i < num_urbs; i++) {
+        int               num_packets_in_urb = MIN(num_packets_remaining, MAX_ISO_PACKETS_PER_URB);
+        struct usbfs_urb *urb;
+        size_t            alloc_size;
+        int               k;
+
+        alloc_size = sizeof(*urb) + (num_packets_in_urb * sizeof(struct usbfs_iso_packet_desc));
+        urb        = calloc(1, alloc_size);
+        if(!urb) {
+            free_iso_urbs(tpriv);
+            return LIBUSB_ERROR_NO_MEM;
+        }
+        urbs[i] = urb;
+
+        /* populate packet lengths */
+        for(k = 0; k < num_packets_in_urb; j++, k++) {
+            packet_len = transfer->iso_packet_desc[j].length;
+            urb->buffer_length += packet_len;
+            urb->iso_frame_desc[k].length = packet_len;
+        }
+
+        urb->usercontext = itransfer;
+        urb->type        = USBFS_URB_TYPE_ISO;
+        /* FIXME: interface for non-ASAP data? */
+        urb->flags             = USBFS_URB_ISO_ASAP;
+        urb->endpoint          = transfer->endpoint;
+        urb->number_of_packets = num_packets_in_urb;
+        urb->buffer            = urb_buffer;
+
+        urb_buffer += urb->buffer_length;
+        num_packets_remaining -= num_packets_in_urb;
+    }
+
+    /* submit URBs */
+    for(i = 0; i < num_urbs; i++) {
+        int r = ioctl(hpriv->fd, IOCTL_USBFS_SUBMITURB, urbs[i]);
+
+        if(r == 0)
+            continue;
+
+        if(errno == ENODEV) {
+            r = LIBUSB_ERROR_NO_DEVICE;
+        }
+        else if(errno == EINVAL) {
+            usbi_warn(TRANSFER_CTX(transfer), "submiturb failed, transfer too large");
+            r = LIBUSB_ERROR_INVALID_PARAM;
+        }
+        else if(errno == EMSGSIZE) {
+            usbi_warn(TRANSFER_CTX(transfer), "submiturb failed, iso packet length too large");
+            r = LIBUSB_ERROR_INVALID_PARAM;
+        }
+        else {
+            usbi_err(TRANSFER_CTX(transfer), "submiturb failed, errno=%d", errno);
+            r = LIBUSB_ERROR_IO;
+        }
+
+        /* if the first URB submission fails, we can simply free up and
+         * return failure immediately. */
+        if(i == 0) {
+            usbi_dbg(TRANSFER_CTX(transfer), "first URB failed, easy peasy");
+            free_iso_urbs(tpriv);
+            return r;
+        }
+
+        /* if it's not the first URB that failed, the situation is a bit
+         * tricky. we must discard all previous URBs. there are
+         * complications:
+         *  - discarding is asynchronous - discarded urbs will be reaped
+         *    later. the user must not have freed the transfer when the
+         *    discarded URBs are reaped, otherwise libusb will be using
+         *    freed memory.
+         *  - the earlier URBs may have completed successfully and we do
+         *    not want to throw away any data.
+         * so, in this case we discard all the previous URBs BUT we report
+         * that the transfer was submitted successfully. then later when
+         * the final discard completes we can report error to the user.
+         */
+        tpriv->reap_action = SUBMIT_FAILED;
+
+        /* The URBs we haven't submitted yet we count as already
+         * retired. */
+        tpriv->num_retired = num_urbs - i;
+        discard_urbs(itransfer, 0, i);
+
+        usbi_dbg(TRANSFER_CTX(transfer),
+                 "reporting successful submission but waiting for %d "
+                 "discards before reporting error",
+                 i);
+        return 0;
+    }
+
+    return 0;
+}
+
+static int submit_control_transfer(struct usbi_transfer *itransfer) {
+    struct linux_transfer_priv      *tpriv    = usbi_get_transfer_priv(itransfer);
+    struct libusb_transfer          *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+    struct linux_device_handle_priv *hpriv    = usbi_get_device_handle_priv(transfer->dev_handle);
+    struct usbfs_urb                *urb;
+    int                              r;
+
+    if(transfer->length - LIBUSB_CONTROL_SETUP_SIZE > MAX_CTRL_BUFFER_LENGTH)
+        return LIBUSB_ERROR_INVALID_PARAM;
+
+    urb = calloc(1, sizeof(*urb));
+    if(!urb)
+        return LIBUSB_ERROR_NO_MEM;
+    tpriv->urbs        = urb;
+    tpriv->num_urbs    = 1;
+    tpriv->reap_action = NORMAL;
+
+    urb->usercontext   = itransfer;
+    urb->type          = USBFS_URB_TYPE_CONTROL;
+    urb->endpoint      = transfer->endpoint;
+    urb->buffer        = transfer->buffer;
+    urb->buffer_length = transfer->length;
+
+    r = ioctl(hpriv->fd, IOCTL_USBFS_SUBMITURB, urb);
+    if(r < 0) {
+        free(urb);
+        tpriv->urbs = NULL;
+        if(errno == ENODEV)
+            return LIBUSB_ERROR_NO_DEVICE;
+
+        usbi_err(TRANSFER_CTX(transfer), "submiturb failed, errno=%d", errno);
+        return LIBUSB_ERROR_IO;
+    }
+    return 0;
+}
+
+static int op_submit_transfer(struct usbi_transfer *itransfer) {
+    struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+
+    switch(transfer->type) {
+    case LIBUSB_TRANSFER_TYPE_CONTROL:
+        return submit_control_transfer(itransfer);
+    case LIBUSB_TRANSFER_TYPE_BULK:
+    case LIBUSB_TRANSFER_TYPE_BULK_STREAM:
+        return submit_bulk_transfer(itransfer);
+    case LIBUSB_TRANSFER_TYPE_INTERRUPT:
+        return submit_bulk_transfer(itransfer);
+    case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
+        return submit_iso_transfer(itransfer);
+    default:
+        usbi_err(TRANSFER_CTX(transfer), "unknown transfer type %u", transfer->type);
+        return LIBUSB_ERROR_INVALID_PARAM;
+    }
+}
+
+static int op_cancel_transfer(struct usbi_transfer *itransfer) {
+    struct linux_transfer_priv *tpriv    = usbi_get_transfer_priv(itransfer);
+    struct libusb_transfer     *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+    int                         r;
+
+    if(!tpriv->urbs)
+        return LIBUSB_ERROR_NOT_FOUND;
+
+    r = discard_urbs(itransfer, 0, tpriv->num_urbs);
+    if(r != 0)
+        return r;
+
+    switch(transfer->type) {
+    case LIBUSB_TRANSFER_TYPE_BULK:
+    case LIBUSB_TRANSFER_TYPE_BULK_STREAM:
+        if(tpriv->reap_action == ERROR)
+            break;
+        /* else, fall through */
+    default:
+        tpriv->reap_action = CANCELLED;
+    }
+
+    return 0;
+}
+
+static void op_clear_transfer_priv(struct usbi_transfer *itransfer) {
+    struct libusb_transfer     *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+    struct linux_transfer_priv *tpriv    = usbi_get_transfer_priv(itransfer);
+
+    switch(transfer->type) {
+    case LIBUSB_TRANSFER_TYPE_CONTROL:
+    case LIBUSB_TRANSFER_TYPE_BULK:
+    case LIBUSB_TRANSFER_TYPE_BULK_STREAM:
+    case LIBUSB_TRANSFER_TYPE_INTERRUPT:
+        if(tpriv->urbs) {
+            free(tpriv->urbs);
+            tpriv->urbs = NULL;
+        }
+        break;
+    case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
+        if(tpriv->iso_urbs) {
+            free_iso_urbs(tpriv);
+            tpriv->iso_urbs = NULL;
+        }
+        break;
+    default:
+        usbi_err(TRANSFER_CTX(transfer), "unknown transfer type %u", transfer->type);
+    }
+}
+
+static int handle_bulk_completion(struct usbi_transfer *itransfer, struct usbfs_urb *urb) {
+    struct linux_transfer_priv *tpriv    = usbi_get_transfer_priv(itransfer);
+    struct libusb_transfer     *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+    int                         urb_idx  = urb - tpriv->urbs;
+
+    usbi_mutex_lock(&itransfer->lock);
+    usbi_dbg(TRANSFER_CTX(transfer), "handling completion status %d of bulk urb %d/%d", urb->status, urb_idx + 1, tpriv->num_urbs);
+
+    tpriv->num_retired++;
+
+    if(tpriv->reap_action != NORMAL) {
+        /* cancelled, submit_fail, or completed early */
+        usbi_dbg(TRANSFER_CTX(transfer), "abnormal reap: urb status %d", urb->status);
+
+        /* even though we're in the process of cancelling, it's possible that
+         * we may receive some data in these URBs that we don't want to lose.
+         * examples:
+         * 1. while the kernel is cancelling all the packets that make up an
+         *    URB, a few of them might complete. so we get back a successful
+         *    cancellation *and* some data.
+         * 2. we receive a short URB which marks the early completion condition,
+         *    so we start cancelling the remaining URBs. however, we're too
+         *    slow and another URB completes (or at least completes partially).
+         *    (this can't happen since we always use BULK_CONTINUATION.)
+         *
+         * When this happens, our objectives are not to lose any "surplus" data,
+         * and also to stick it at the end of the previously-received data
+         * (closing any holes), so that libusb reports the total amount of
+         * transferred data and presents it in a contiguous chunk.
+         */
+        if(urb->actual_length > 0) {
+            unsigned char *target = transfer->buffer + itransfer->transferred;
+
+            usbi_dbg(TRANSFER_CTX(transfer), "received %d bytes of surplus data", urb->actual_length);
+            if(urb->buffer != target) {
+                usbi_dbg(TRANSFER_CTX(transfer), "moving surplus data from offset %zu to offset %zu", (unsigned char *)urb->buffer - transfer->buffer,
+                         target - transfer->buffer);
+                memmove(target, urb->buffer, urb->actual_length);
+            }
+            itransfer->transferred += urb->actual_length;
+        }
+
+        if(tpriv->num_retired == tpriv->num_urbs) {
+            usbi_dbg(TRANSFER_CTX(transfer), "abnormal reap: last URB handled, reporting");
+            if(tpriv->reap_action != COMPLETED_EARLY && tpriv->reap_status == LIBUSB_TRANSFER_COMPLETED)
+                tpriv->reap_status = LIBUSB_TRANSFER_ERROR;
+            goto completed;
+        }
+        goto out_unlock;
+    }
+
+    itransfer->transferred += urb->actual_length;
+
+    /* Many of these errors can occur on *any* urb of a multi-urb
+     * transfer.  When they do, we tear down the rest of the transfer.
+     */
+    switch(urb->status) {
+    case 0:
+        break;
+    case -EREMOTEIO: /* short transfer */
+        break;
+    case -ENOENT: /* cancelled */
+    case -ECONNRESET:
+        break;
+    case -ENODEV:
+    case -ESHUTDOWN:
+        usbi_dbg(TRANSFER_CTX(transfer), "device removed");
+        tpriv->reap_status = LIBUSB_TRANSFER_NO_DEVICE;
+        goto cancel_remaining;
+    case -EPIPE:
+        usbi_dbg(TRANSFER_CTX(transfer), "detected endpoint stall");
+        if(tpriv->reap_status == LIBUSB_TRANSFER_COMPLETED)
+            tpriv->reap_status = LIBUSB_TRANSFER_STALL;
+        goto cancel_remaining;
+    case -EOVERFLOW:
+        /* overflow can only ever occur in the last urb */
+        usbi_dbg(TRANSFER_CTX(transfer), "overflow, actual_length=%d", urb->actual_length);
+        if(tpriv->reap_status == LIBUSB_TRANSFER_COMPLETED)
+            tpriv->reap_status = LIBUSB_TRANSFER_OVERFLOW;
+        goto completed;
+    case -ETIME:
+    case -EPROTO:
+    case -EILSEQ:
+    case -ECOMM:
+    case -ENOSR:
+        usbi_dbg(TRANSFER_CTX(transfer), "low-level bus error %d", urb->status);
+        tpriv->reap_action = ERROR;
+        goto cancel_remaining;
+    default:
+        usbi_warn(ITRANSFER_CTX(itransfer), "unrecognised urb status %d", urb->status);
+        tpriv->reap_action = ERROR;
+        goto cancel_remaining;
+    }
+
+    /* if we've reaped all urbs or we got less data than requested then we're
+     * done */
+    if(tpriv->num_retired == tpriv->num_urbs) {
+        usbi_dbg(TRANSFER_CTX(transfer), "all URBs in transfer reaped --> complete!");
+        goto completed;
+    }
+    else if(urb->actual_length < urb->buffer_length) {
+        usbi_dbg(TRANSFER_CTX(transfer), "short transfer %d/%d --> complete!", urb->actual_length, urb->buffer_length);
+        if(tpriv->reap_action == NORMAL)
+            tpriv->reap_action = COMPLETED_EARLY;
+    }
+    else {
+        goto out_unlock;
+    }
+
+cancel_remaining:
+    if(tpriv->reap_action == ERROR && tpriv->reap_status == LIBUSB_TRANSFER_COMPLETED)
+        tpriv->reap_status = LIBUSB_TRANSFER_ERROR;
+
+    if(tpriv->num_retired == tpriv->num_urbs) /* nothing to cancel */
+        goto completed;
+
+    /* cancel remaining urbs and wait for their completion before
+     * reporting results */
+    discard_urbs(itransfer, urb_idx + 1, tpriv->num_urbs);
+
+out_unlock:
+    usbi_mutex_unlock(&itransfer->lock);
+    return 0;
+
+completed:
+    free(tpriv->urbs);
+    tpriv->urbs = NULL;
+    usbi_mutex_unlock(&itransfer->lock);
+    return tpriv->reap_action == CANCELLED ? usbi_handle_transfer_cancellation(itransfer) : usbi_handle_transfer_completion(itransfer, tpriv->reap_status);
+}
+
+static int handle_iso_completion(struct usbi_transfer *itransfer, struct usbfs_urb *urb) {
+    struct libusb_transfer     *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+    struct linux_transfer_priv *tpriv    = usbi_get_transfer_priv(itransfer);
+    int                         num_urbs = tpriv->num_urbs;
+    int                         urb_idx  = 0;
+    int                         i;
+    enum libusb_transfer_status status = LIBUSB_TRANSFER_COMPLETED;
+
+    usbi_mutex_lock(&itransfer->lock);
+    for(i = 0; i < num_urbs; i++) {
+        if(urb == tpriv->iso_urbs[i]) {
+            urb_idx = i + 1;
+            break;
+        }
+    }
+    if(urb_idx == 0) {
+        usbi_err(TRANSFER_CTX(transfer), "could not locate urb!");
+        usbi_mutex_unlock(&itransfer->lock);
+        return LIBUSB_ERROR_NOT_FOUND;
+    }
+
+    usbi_dbg(TRANSFER_CTX(transfer), "handling completion status %d of iso urb %d/%d", urb->status, urb_idx, num_urbs);
+
+    /* copy isochronous results back in */
+
+    for(i = 0; i < urb->number_of_packets; i++) {
+        struct usbfs_iso_packet_desc        *urb_desc = &urb->iso_frame_desc[i];
+        struct libusb_iso_packet_descriptor *lib_desc = &transfer->iso_packet_desc[tpriv->iso_packet_offset++];
+
+        lib_desc->status = LIBUSB_TRANSFER_COMPLETED;
+        switch(urb_desc->status) {
+        case 0:
+            break;
+        case -ENOENT: /* cancelled */
+        case -ECONNRESET:
+            break;
+        case -ENODEV:
+        case -ESHUTDOWN:
+            usbi_dbg(TRANSFER_CTX(transfer), "packet %d - device removed", i);
+            lib_desc->status = LIBUSB_TRANSFER_NO_DEVICE;
+            break;
+        case -EPIPE:
+            usbi_dbg(TRANSFER_CTX(transfer), "packet %d - detected endpoint stall", i);
+            lib_desc->status = LIBUSB_TRANSFER_STALL;
+            break;
+        case -EOVERFLOW:
+            usbi_dbg(TRANSFER_CTX(transfer), "packet %d - overflow error", i);
+            lib_desc->status = LIBUSB_TRANSFER_OVERFLOW;
+            break;
+        case -ETIME:
+        case -EPROTO:
+        case -EILSEQ:
+        case -ECOMM:
+        case -ENOSR:
+        case -EXDEV:
+            usbi_dbg(TRANSFER_CTX(transfer), "packet %d - low-level USB error %d", i, urb_desc->status);
+            lib_desc->status = LIBUSB_TRANSFER_ERROR;
+            break;
+        default:
+            usbi_warn(TRANSFER_CTX(transfer), "packet %d - unrecognised urb status %d", i, urb_desc->status);
+            lib_desc->status = LIBUSB_TRANSFER_ERROR;
+            break;
+        }
+        lib_desc->actual_length = urb_desc->actual_length;
+    }
+
+    tpriv->num_retired++;
+
+    if(tpriv->reap_action != NORMAL) { /* cancelled or submit_fail */
+        usbi_dbg(TRANSFER_CTX(transfer), "CANCEL: urb status %d", urb->status);
+
+        if(tpriv->num_retired == num_urbs) {
+            usbi_dbg(TRANSFER_CTX(transfer), "CANCEL: last URB handled, reporting");
+            free_iso_urbs(tpriv);
+            if(tpriv->reap_action == CANCELLED) {
+                usbi_mutex_unlock(&itransfer->lock);
+                return usbi_handle_transfer_cancellation(itransfer);
+            }
+            else {
+                usbi_mutex_unlock(&itransfer->lock);
+                return usbi_handle_transfer_completion(itransfer, LIBUSB_TRANSFER_ERROR);
+            }
+        }
+        goto out;
+    }
+
+    switch(urb->status) {
+    case 0:
+        break;
+    case -ENOENT: /* cancelled */
+    case -ECONNRESET:
+        break;
+    case -ESHUTDOWN:
+        usbi_dbg(TRANSFER_CTX(transfer), "device removed");
+        status = LIBUSB_TRANSFER_NO_DEVICE;
+        break;
+    default:
+        usbi_warn(TRANSFER_CTX(transfer), "unrecognised urb status %d", urb->status);
+        status = LIBUSB_TRANSFER_ERROR;
+        break;
+    }
+
+    /* if we've reaped all urbs then we're done */
+    if(tpriv->num_retired == num_urbs) {
+        usbi_dbg(TRANSFER_CTX(transfer), "all URBs in transfer reaped --> complete!");
+        free_iso_urbs(tpriv);
+        usbi_mutex_unlock(&itransfer->lock);
+        return usbi_handle_transfer_completion(itransfer, status);
+    }
+
+out:
+    usbi_mutex_unlock(&itransfer->lock);
+    return 0;
+}
+
+static int handle_control_completion(struct usbi_transfer *itransfer, struct usbfs_urb *urb) {
+    struct linux_transfer_priv *tpriv = usbi_get_transfer_priv(itransfer);
+    int                         status;
+
+    usbi_mutex_lock(&itransfer->lock);
+    usbi_dbg(ITRANSFER_CTX(itransfer), "handling completion status %d", urb->status);
+
+    itransfer->transferred += urb->actual_length;
+
+    if(tpriv->reap_action == CANCELLED) {
+        if(urb->status && urb->status != -ENOENT)
+            usbi_warn(ITRANSFER_CTX(itransfer), "cancel: unrecognised urb status %d", urb->status);
+        free(tpriv->urbs);
+        tpriv->urbs = NULL;
+        usbi_mutex_unlock(&itransfer->lock);
+        return usbi_handle_transfer_cancellation(itransfer);
+    }
+
+    switch(urb->status) {
+    case 0:
+        status = LIBUSB_TRANSFER_COMPLETED;
+        break;
+    case -ENOENT: /* cancelled */
+        status = LIBUSB_TRANSFER_CANCELLED;
+        break;
+    case -ENODEV:
+    case -ESHUTDOWN:
+        usbi_dbg(ITRANSFER_CTX(itransfer), "device removed");
+        status = LIBUSB_TRANSFER_NO_DEVICE;
+        break;
+    case -EPIPE:
+        usbi_dbg(ITRANSFER_CTX(itransfer), "unsupported control request");
+        status = LIBUSB_TRANSFER_STALL;
+        break;
+    case -EOVERFLOW:
+        usbi_dbg(ITRANSFER_CTX(itransfer), "overflow, actual_length=%d", urb->actual_length);
+        status = LIBUSB_TRANSFER_OVERFLOW;
+        break;
+    case -ETIME:
+    case -EPROTO:
+    case -EILSEQ:
+    case -ECOMM:
+    case -ENOSR:
+        usbi_dbg(ITRANSFER_CTX(itransfer), "low-level bus error %d", urb->status);
+        status = LIBUSB_TRANSFER_ERROR;
+        break;
+    default:
+        usbi_warn(ITRANSFER_CTX(itransfer), "unrecognised urb status %d", urb->status);
+        status = LIBUSB_TRANSFER_ERROR;
+        break;
+    }
+
+    free(tpriv->urbs);
+    tpriv->urbs = NULL;
+    usbi_mutex_unlock(&itransfer->lock);
+    return usbi_handle_transfer_completion(itransfer, status);
+}
+
+static int reap_for_handle(struct libusb_device_handle *handle) {
+    struct linux_device_handle_priv *hpriv = usbi_get_device_handle_priv(handle);
+    int                              r;
+    struct usbfs_urb                *urb = NULL;
+    struct usbi_transfer            *itransfer;
+    struct libusb_transfer          *transfer;
+
+    r = ioctl(hpriv->fd, IOCTL_USBFS_REAPURBNDELAY, &urb);
+    if(r < 0) {
+        if(errno == EAGAIN)
+            return 1;
+        if(errno == ENODEV)
+            return LIBUSB_ERROR_NO_DEVICE;
+
+        usbi_err(HANDLE_CTX(handle), "reap failed, errno=%d", errno);
+        return LIBUSB_ERROR_IO;
+    }
+
+    itransfer = urb->usercontext;
+    transfer  = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+
+    usbi_dbg(HANDLE_CTX(handle), "urb type=%u status=%d transferred=%d", urb->type, urb->status, urb->actual_length);
+
+    switch(transfer->type) {
+    case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
+        return handle_iso_completion(itransfer, urb);
+    case LIBUSB_TRANSFER_TYPE_BULK:
+    case LIBUSB_TRANSFER_TYPE_BULK_STREAM:
+    case LIBUSB_TRANSFER_TYPE_INTERRUPT:
+        return handle_bulk_completion(itransfer, urb);
+    case LIBUSB_TRANSFER_TYPE_CONTROL:
+        return handle_control_completion(itransfer, urb);
+    default:
+        usbi_err(HANDLE_CTX(handle), "unrecognised transfer type %u", transfer->type);
+        return LIBUSB_ERROR_OTHER;
+    }
+}
+
+static int op_handle_events(struct libusb_context *ctx, void *event_data, unsigned int count, unsigned int num_ready) {
+    struct pollfd *fds = event_data;
+    unsigned int   n;
+    int            r;
+
+    usbi_mutex_lock(&ctx->open_devs_lock);
+    for(n = 0; n < count && num_ready > 0; n++) {
+        struct pollfd                   *pollfd = &fds[n];
+        struct libusb_device_handle     *handle;
+        struct linux_device_handle_priv *hpriv = NULL;
+        int                              reap_count;
+
+        if(!pollfd->revents)
+            continue;
+
+        num_ready--;
+        for_each_open_device(ctx, handle) {
+            hpriv = usbi_get_device_handle_priv(handle);
+            if(hpriv->fd == pollfd->fd)
+                break;
+        }
+
+        if(!hpriv || hpriv->fd != pollfd->fd) {
+            usbi_err(ctx, "cannot find handle for fd %d", pollfd->fd);
+            continue;
+        }
+
+        if(pollfd->revents & POLLERR) {
+            /* remove the fd from the pollfd set so that it doesn't continuously
+             * trigger an event, and flag that it has been removed so op_close()
+             * doesn't try to remove it a second time */
+            usbi_remove_event_source(HANDLE_CTX(handle), hpriv->fd);
+            hpriv->fd_removed = 1;
+
+            /* device will still be marked as attached if hotplug monitor thread
+             * hasn't processed remove event yet */
+            usbi_mutex_static_lock(&linux_hotplug_lock);
+            if(usbi_atomic_load(&handle->dev->attached))
+                linux_device_disconnected(handle->dev->bus_number, handle->dev->device_address);
+            usbi_mutex_static_unlock(&linux_hotplug_lock);
+
+            if(hpriv->caps & USBFS_CAP_REAP_AFTER_DISCONNECT) {
+                do {
+                    r = reap_for_handle(handle);
+                } while(r == 0);
+            }
+
+            usbi_handle_disconnect(handle);
+            continue;
+        }
+
+        reap_count = 0;
+        do {
+            r = reap_for_handle(handle);
+        } while(r == 0 && ++reap_count <= 25);
+
+        if(r == 1 || r == LIBUSB_ERROR_NO_DEVICE)
+            continue;
+        else if(r < 0)
+            goto out;
+    }
+
+    r = 0;
+out:
+    usbi_mutex_unlock(&ctx->open_devs_lock);
+    return r;
+}
+
+const struct usbi_os_backend usbi_backend = {
+    .name                           = "Linux usbfs",
+    .caps                           = USBI_CAP_HAS_HID_ACCESS | USBI_CAP_SUPPORTS_DETACH_KERNEL_DRIVER,
+    .init                           = op_init,
+    .exit                           = op_exit,
+    .set_option                     = op_set_option,
+    .hotplug_poll                   = op_hotplug_poll,
+    .get_active_config_descriptor   = op_get_active_config_descriptor,
+    .get_config_descriptor          = op_get_config_descriptor,
+    .get_config_descriptor_by_value = op_get_config_descriptor_by_value,
+
+    .wrap_sys_device   = op_wrap_sys_device,
+    .open              = op_open,
+    .close             = op_close,
+    .get_configuration = op_get_configuration,
+    .set_configuration = op_set_configuration,
+    .claim_interface   = op_claim_interface,
+    .release_interface = op_release_interface,
+
+    .set_interface_altsetting = op_set_interface,
+    .clear_halt               = op_clear_halt,
+    .reset_device             = op_reset_device,
+
+    .alloc_streams = op_alloc_streams,
+    .free_streams  = op_free_streams,
+
+    .dev_mem_alloc = op_dev_mem_alloc,
+    .dev_mem_free  = op_dev_mem_free,
+
+    .kernel_driver_active = op_kernel_driver_active,
+    .detach_kernel_driver = op_detach_kernel_driver,
+    .attach_kernel_driver = op_attach_kernel_driver,
+
+    .destroy_device = op_destroy_device,
+
+    .submit_transfer     = op_submit_transfer,
+    .cancel_transfer     = op_cancel_transfer,
+    .clear_transfer_priv = op_clear_transfer_priv,
+
+    .handle_events = op_handle_events,
+
+    .context_priv_size       = sizeof(struct linux_context_priv),
+    .device_priv_size        = sizeof(struct linux_device_priv),
+    .device_handle_priv_size = sizeof(struct linux_device_handle_priv),
+    .transfer_priv_size      = sizeof(struct linux_transfer_priv),
+};
diff --git a/3rdparty/libusb/src/libusb/os/linux_usbfs.h b/3rdparty/libusb/src/libusb/os/linux_usbfs.h
new file mode 100644
index 00000000..f7680698
--- /dev/null
+++ b/3rdparty/libusb/src/libusb/os/linux_usbfs.h
@@ -0,0 +1,205 @@
+/*
+ * usbfs header structures
+ * Copyright © 2007 Daniel Drake <dsd@gentoo.org>
+ * Copyright © 2001 Johannes Erdfelt <johannes@erdfelt.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef LIBUSB_USBFS_H
+#define LIBUSB_USBFS_H
+
+#include <linux/magic.h>
+#include <linux/types.h>
+
+#define SYSFS_MOUNT_PATH "/sys"
+#define SYSFS_DEVICE_PATH SYSFS_MOUNT_PATH "/bus/usb/devices"
+
+struct usbfs_ctrltransfer {
+    /* keep in sync with usbdevice_fs.h:usbdevfs_ctrltransfer */
+    __u8  bmRequestType;
+    __u8  bRequest;
+    __u16 wValue;
+    __u16 wIndex;
+    __u16 wLength;
+    __u32 timeout; /* in milliseconds */
+
+    /* pointer to data */
+    void *data;
+};
+
+struct usbfs_setinterface {
+    /* keep in sync with usbdevice_fs.h:usbdevfs_setinterface */
+    unsigned int interface;
+    unsigned int altsetting;
+};
+
+#define USBFS_MAXDRIVERNAME 255
+
+struct usbfs_getdriver {
+    unsigned int interface;
+    char         driver[USBFS_MAXDRIVERNAME + 1];
+};
+
+#define USBFS_URB_SHORT_NOT_OK 0x01
+#define USBFS_URB_ISO_ASAP 0x02
+#define USBFS_URB_BULK_CONTINUATION 0x04
+#define USBFS_URB_QUEUE_BULK 0x10
+#define USBFS_URB_ZERO_PACKET 0x40
+
+#define USBFS_URB_TYPE_ISO 0
+#define USBFS_URB_TYPE_INTERRUPT 1
+#define USBFS_URB_TYPE_CONTROL 2
+#define USBFS_URB_TYPE_BULK 3
+
+struct usbfs_iso_packet_desc {
+    unsigned int length;
+    unsigned int actual_length;
+    unsigned int status;
+};
+
+#define MAX_BULK_BUFFER_LENGTH 16384
+#define MAX_CTRL_BUFFER_LENGTH 4096
+
+#define MAX_ISO_PACKETS_PER_URB 128
+
+struct usbfs_urb {
+    unsigned char type;
+    unsigned char endpoint;
+    int           status;
+    unsigned int  flags;
+    void         *buffer;
+    int           buffer_length;
+    int           actual_length;
+    int           start_frame;
+    union {
+        int          number_of_packets; /* Only used for isoc urbs */
+        unsigned int stream_id;         /* Only used with bulk streams */
+    };
+    int          error_count;
+    unsigned int signr;
+    void        *usercontext;
+    struct usbfs_iso_packet_desc iso_frame_desc[0];
+};
+
+struct usbfs_connectinfo {
+    unsigned int  devnum;
+    unsigned char slow;
+};
+
+struct usbfs_ioctl {
+    int ifno;       /* interface 0..N ; negative numbers reserved */
+    int ioctl_code; /* MUST encode size + direction of data so the
+                     * macros in <asm/ioctl.h> give correct values */
+    void *data;     /* param buffer (in, or out) */
+};
+
+#define USBFS_CAP_ZERO_PACKET 0x01
+#define USBFS_CAP_BULK_CONTINUATION 0x02
+#define USBFS_CAP_NO_PACKET_SIZE_LIM 0x04
+#define USBFS_CAP_BULK_SCATTER_GATHER 0x08
+#define USBFS_CAP_REAP_AFTER_DISCONNECT 0x10
+
+#define USBFS_DISCONNECT_CLAIM_IF_DRIVER 0x01
+#define USBFS_DISCONNECT_CLAIM_EXCEPT_DRIVER 0x02
+
+struct usbfs_disconnect_claim {
+    unsigned int interface;
+    unsigned int flags;
+    char         driver[USBFS_MAXDRIVERNAME + 1];
+};
+
+struct usbfs_streams {
+    unsigned int num_streams; /* Not used by USBDEVFS_FREE_STREAMS */
+    unsigned int num_eps;
+    unsigned char eps[0];
+};
+
+#define USBFS_SPEED_UNKNOWN 0
+#define USBFS_SPEED_LOW 1
+#define USBFS_SPEED_FULL 2
+#define USBFS_SPEED_HIGH 3
+#define USBFS_SPEED_WIRELESS 4
+#define USBFS_SPEED_SUPER 5
+#define USBFS_SPEED_SUPER_PLUS 6
+
+#define IOCTL_USBFS_CONTROL _IOWR('U', 0, struct usbfs_ctrltransfer)
+#define IOCTL_USBFS_SETINTERFACE _IOR('U', 4, struct usbfs_setinterface)
+#define IOCTL_USBFS_SETCONFIGURATION _IOR('U', 5, unsigned int)
+#define IOCTL_USBFS_GETDRIVER _IOW('U', 8, struct usbfs_getdriver)
+#define IOCTL_USBFS_SUBMITURB _IOR('U', 10, struct usbfs_urb)
+#define IOCTL_USBFS_DISCARDURB _IO('U', 11)
+#define IOCTL_USBFS_REAPURBNDELAY _IOW('U', 13, void *)
+#define IOCTL_USBFS_CLAIMINTERFACE _IOR('U', 15, unsigned int)
+#define IOCTL_USBFS_RELEASEINTERFACE _IOR('U', 16, unsigned int)
+#define IOCTL_USBFS_CONNECTINFO _IOW('U', 17, struct usbfs_connectinfo)
+#define IOCTL_USBFS_IOCTL _IOWR('U', 18, struct usbfs_ioctl)
+#define IOCTL_USBFS_RESET _IO('U', 20)
+#define IOCTL_USBFS_CLEAR_HALT _IOR('U', 21, unsigned int)
+#define IOCTL_USBFS_DISCONNECT _IO('U', 22)
+#define IOCTL_USBFS_CONNECT _IO('U', 23)
+#define IOCTL_USBFS_GET_CAPABILITIES _IOR('U', 26, __u32)
+#define IOCTL_USBFS_DISCONNECT_CLAIM _IOR('U', 27, struct usbfs_disconnect_claim)
+#define IOCTL_USBFS_ALLOC_STREAMS _IOR('U', 28, struct usbfs_streams)
+#define IOCTL_USBFS_FREE_STREAMS _IOR('U', 29, struct usbfs_streams)
+#define IOCTL_USBFS_DROP_PRIVILEGES _IOW('U', 30, __u32)
+#define IOCTL_USBFS_GET_SPEED _IO('U', 31)
+
+extern usbi_mutex_static_t linux_hotplug_lock;
+
+#ifdef HAVE_LIBUDEV
+int  linux_udev_start_event_monitor(void);
+int  linux_udev_stop_event_monitor(void);
+int  linux_udev_scan_devices(struct libusb_context *ctx);
+void linux_udev_hotplug_poll(void);
+#else
+int  linux_netlink_start_event_monitor(void);
+int  linux_netlink_stop_event_monitor(void);
+void linux_netlink_hotplug_poll(void);
+#endif
+
+static inline int linux_start_event_monitor(void) {
+#if defined(HAVE_LIBUDEV)
+    return linux_udev_start_event_monitor();
+#elif !defined(__ANDROID__)
+    return linux_netlink_start_event_monitor();
+#else
+    return LIBUSB_SUCCESS;
+#endif
+}
+
+static inline void linux_stop_event_monitor(void) {
+#if defined(HAVE_LIBUDEV)
+    linux_udev_stop_event_monitor();
+#elif !defined(__ANDROID__)
+    linux_netlink_stop_event_monitor();
+#endif
+}
+
+static inline void linux_hotplug_poll(void) {
+#if defined(HAVE_LIBUDEV)
+    linux_udev_hotplug_poll();
+#elif !defined(__ANDROID__)
+    linux_netlink_hotplug_poll();
+#endif
+}
+
+void linux_hotplug_enumerate(uint8_t busnum, uint8_t devaddr, const char *sys_name);
+void linux_device_disconnected(uint8_t busnum, uint8_t devaddr);
+
+int linux_get_device_address(struct libusb_context *ctx, int detached, uint8_t *busnum, uint8_t *devaddr, const char *dev_node, const char *sys_name, int fd);
+int linux_enumerate_device(struct libusb_context *ctx, uint8_t busnum, uint8_t devaddr, const char *sysfs_dir);
+
+#endif
diff --git a/3rdparty/libusb/src/libusb/os/netbsd_usb.c b/3rdparty/libusb/src/libusb/os/netbsd_usb.c
new file mode 100644
index 00000000..72dc4379
--- /dev/null
+++ b/3rdparty/libusb/src/libusb/os/netbsd_usb.c
@@ -0,0 +1,566 @@
+/*
+ * Copyright © 2011 Martin Pieuchot <mpi@openbsd.org>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <libusb/config.h>
+
+#include <sys/time.h>
+#include <sys/types.h>
+
+#include <errno.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#include <dev/usb/usb.h>
+
+#include "libusbi.h"
+
+struct device_priv {
+    char devnode[16];
+    int  fd;
+
+    usb_config_descriptor_t *cdesc; /* active config descriptor */
+};
+
+struct handle_priv {
+    int endpoints[USB_MAX_ENDPOINTS];
+};
+
+/*
+ * Backend functions
+ */
+static int  netbsd_get_device_list(struct libusb_context *, struct discovered_devs **);
+static int  netbsd_open(struct libusb_device_handle *);
+static void netbsd_close(struct libusb_device_handle *);
+
+static int netbsd_get_active_config_descriptor(struct libusb_device *, void *, size_t);
+static int netbsd_get_config_descriptor(struct libusb_device *, uint8_t, void *, size_t);
+
+static int netbsd_get_configuration(struct libusb_device_handle *, uint8_t *);
+static int netbsd_set_configuration(struct libusb_device_handle *, int);
+
+static int netbsd_claim_interface(struct libusb_device_handle *, uint8_t);
+static int netbsd_release_interface(struct libusb_device_handle *, uint8_t);
+
+static int  netbsd_set_interface_altsetting(struct libusb_device_handle *, uint8_t, uint8_t);
+static int  netbsd_clear_halt(struct libusb_device_handle *, unsigned char);
+static void netbsd_destroy_device(struct libusb_device *);
+
+static int netbsd_submit_transfer(struct usbi_transfer *);
+static int netbsd_cancel_transfer(struct usbi_transfer *);
+static int netbsd_handle_transfer_completion(struct usbi_transfer *);
+
+/*
+ * Private functions
+ */
+static int _errno_to_libusb(int);
+static int _cache_active_config_descriptor(struct libusb_device *, int);
+static int _sync_control_transfer(struct usbi_transfer *);
+static int _sync_gen_transfer(struct usbi_transfer *);
+static int _access_endpoint(struct libusb_transfer *);
+
+const struct usbi_os_backend usbi_backend = {
+    .name            = "Synchronous NetBSD backend",
+    .caps            = 0,
+    .get_device_list = netbsd_get_device_list,
+    .open            = netbsd_open,
+    .close           = netbsd_close,
+
+    .get_active_config_descriptor = netbsd_get_active_config_descriptor,
+    .get_config_descriptor        = netbsd_get_config_descriptor,
+
+    .get_configuration = netbsd_get_configuration,
+    .set_configuration = netbsd_set_configuration,
+
+    .claim_interface   = netbsd_claim_interface,
+    .release_interface = netbsd_release_interface,
+
+    .set_interface_altsetting = netbsd_set_interface_altsetting,
+    .clear_halt               = netbsd_clear_halt,
+
+    .destroy_device = netbsd_destroy_device,
+
+    .submit_transfer = netbsd_submit_transfer,
+    .cancel_transfer = netbsd_cancel_transfer,
+
+    .handle_transfer_completion = netbsd_handle_transfer_completion,
+
+    .device_priv_size        = sizeof(struct device_priv),
+    .device_handle_priv_size = sizeof(struct handle_priv),
+};
+
+int netbsd_get_device_list(struct libusb_context *ctx, struct discovered_devs **discdevs) {
+    struct libusb_device   *dev;
+    struct device_priv     *dpriv;
+    struct usb_device_info  di;
+    usb_device_descriptor_t ddesc;
+    unsigned long           session_id;
+    char                    devnode[16];
+    int                     fd, err, i;
+
+    usbi_dbg(ctx, " ");
+
+    /* Only ugen(4) is supported */
+    for(i = 0; i < USB_MAX_DEVICES; i++) {
+        /* Control endpoint is always .00 */
+        snprintf(devnode, sizeof(devnode), "/dev/ugen%d.00", i);
+
+        if((fd = open(devnode, O_RDONLY)) < 0) {
+            if(errno != ENOENT && errno != ENXIO)
+                usbi_err(ctx, "could not open %s", devnode);
+            continue;
+        }
+
+        if(ioctl(fd, USB_GET_DEVICEINFO, &di) < 0)
+            continue;
+
+        session_id = (di.udi_bus << 8 | di.udi_addr);
+        dev        = usbi_get_device_by_session_id(ctx, session_id);
+
+        if(dev == NULL) {
+            dev = usbi_alloc_device(ctx, session_id);
+            if(dev == NULL)
+                return (LIBUSB_ERROR_NO_MEM);
+
+            dev->bus_number     = 1 + di.udi_bus;
+            dev->device_address = 1 + di.udi_addr;
+            dev->speed          = di.udi_speed; /* NetBSD #define's happen to match libusb enum */
+
+            dpriv = usbi_get_device_priv(dev);
+            strlcpy(dpriv->devnode, devnode, sizeof(devnode));
+            dpriv->fd = -1;
+
+            if(ioctl(fd, USB_GET_DEVICE_DESC, &ddesc) < 0) {
+                err = errno;
+                goto error;
+            }
+
+            static_assert(sizeof(dev->device_descriptor) == sizeof(ddesc), "mismatch between libusb and OS device descriptor sizes");
+            memcpy(&dev->device_descriptor, &ddesc, LIBUSB_DT_DEVICE_SIZE);
+            usbi_localize_device_descriptor(&dev->device_descriptor);
+
+            if(_cache_active_config_descriptor(dev, fd)) {
+                err = errno;
+                goto error;
+            }
+
+            if((err = usbi_sanitize_device(dev)))
+                goto error;
+        }
+        close(fd);
+
+        if(discovered_devs_append(*discdevs, dev) == NULL)
+            return (LIBUSB_ERROR_NO_MEM);
+
+        libusb_unref_device(dev);
+    }
+
+    return (LIBUSB_SUCCESS);
+
+error:
+    close(fd);
+    libusb_unref_device(dev);
+    return _errno_to_libusb(err);
+}
+
+int netbsd_open(struct libusb_device_handle *handle) {
+    struct device_priv *dpriv = usbi_get_device_priv(handle->dev);
+    struct handle_priv *hpriv = usbi_get_device_handle_priv(handle);
+    int                 i;
+
+    dpriv->fd = open(dpriv->devnode, O_RDWR);
+    if(dpriv->fd < 0) {
+        dpriv->fd = open(dpriv->devnode, O_RDONLY);
+        if(dpriv->fd < 0)
+            return _errno_to_libusb(errno);
+    }
+
+    for(i = 0; i < USB_MAX_ENDPOINTS; i++)
+        hpriv->endpoints[i] = -1;
+
+    usbi_dbg(HANDLE_CTX(handle), "open %s: fd %d", dpriv->devnode, dpriv->fd);
+
+    return (LIBUSB_SUCCESS);
+}
+
+void netbsd_close(struct libusb_device_handle *handle) {
+    struct device_priv *dpriv = usbi_get_device_priv(handle->dev);
+
+    usbi_dbg(HANDLE_CTX(handle), "close: fd %d", dpriv->fd);
+
+    close(dpriv->fd);
+    dpriv->fd = -1;
+}
+
+int netbsd_get_active_config_descriptor(struct libusb_device *dev, void *buf, size_t len) {
+    struct device_priv *dpriv = usbi_get_device_priv(dev);
+
+    len = MIN(len, (size_t)UGETW(dpriv->cdesc->wTotalLength));
+
+    usbi_dbg(DEVICE_CTX(dev), "len %zu", len);
+
+    memcpy(buf, dpriv->cdesc, len);
+
+    return (int)len;
+}
+
+int netbsd_get_config_descriptor(struct libusb_device *dev, uint8_t idx, void *buf, size_t len) {
+    struct device_priv  *dpriv = usbi_get_device_priv(dev);
+    struct usb_full_desc ufd;
+    int                  fd, err;
+
+    usbi_dbg(DEVICE_CTX(dev), "index %u, len %zu", idx, len);
+
+    /* A config descriptor may be requested before opening the device */
+    if(dpriv->fd >= 0) {
+        fd = dpriv->fd;
+    }
+    else {
+        fd = open(dpriv->devnode, O_RDONLY);
+        if(fd < 0)
+            return _errno_to_libusb(errno);
+    }
+
+    ufd.ufd_config_index = idx;
+    ufd.ufd_size         = len;
+    ufd.ufd_data         = buf;
+
+    if((ioctl(fd, USB_GET_FULL_DESC, &ufd)) < 0) {
+        err = errno;
+        if(dpriv->fd < 0)
+            close(fd);
+        return _errno_to_libusb(err);
+    }
+
+    if(dpriv->fd < 0)
+        close(fd);
+
+    return (int)len;
+}
+
+int netbsd_get_configuration(struct libusb_device_handle *handle, uint8_t *config) {
+    struct device_priv *dpriv = usbi_get_device_priv(handle->dev);
+    int                 tmp;
+
+    usbi_dbg(HANDLE_CTX(handle), " ");
+
+    if(ioctl(dpriv->fd, USB_GET_CONFIG, &tmp) < 0)
+        return _errno_to_libusb(errno);
+
+    usbi_dbg(HANDLE_CTX(handle), "configuration %d", tmp);
+    *config = (uint8_t)tmp;
+
+    return (LIBUSB_SUCCESS);
+}
+
+int netbsd_set_configuration(struct libusb_device_handle *handle, int config) {
+    struct device_priv *dpriv = usbi_get_device_priv(handle->dev);
+
+    usbi_dbg(HANDLE_CTX(handle), "configuration %d", config);
+
+    if(ioctl(dpriv->fd, USB_SET_CONFIG, &config) < 0)
+        return _errno_to_libusb(errno);
+
+    return _cache_active_config_descriptor(handle->dev, dpriv->fd);
+}
+
+int netbsd_claim_interface(struct libusb_device_handle *handle, uint8_t iface) {
+    struct handle_priv *hpriv = usbi_get_device_handle_priv(handle);
+    int                 i;
+
+    UNUSED(iface);
+
+    for(i = 0; i < USB_MAX_ENDPOINTS; i++)
+        hpriv->endpoints[i] = -1;
+
+    return (LIBUSB_SUCCESS);
+}
+
+int netbsd_release_interface(struct libusb_device_handle *handle, uint8_t iface) {
+    struct handle_priv *hpriv = usbi_get_device_handle_priv(handle);
+    int                 i;
+
+    UNUSED(iface);
+
+    for(i = 0; i < USB_MAX_ENDPOINTS; i++)
+        if(hpriv->endpoints[i] >= 0)
+            close(hpriv->endpoints[i]);
+
+    return (LIBUSB_SUCCESS);
+}
+
+int netbsd_set_interface_altsetting(struct libusb_device_handle *handle, uint8_t iface, uint8_t altsetting) {
+    struct device_priv      *dpriv = usbi_get_device_priv(handle->dev);
+    struct usb_alt_interface intf;
+
+    usbi_dbg(HANDLE_CTX(handle), "iface %u, setting %u", iface, altsetting);
+
+    memset(&intf, 0, sizeof(intf));
+
+    intf.uai_interface_index = iface;
+    intf.uai_alt_no          = altsetting;
+
+    if(ioctl(dpriv->fd, USB_SET_ALTINTERFACE, &intf) < 0)
+        return _errno_to_libusb(errno);
+
+    return (LIBUSB_SUCCESS);
+}
+
+int netbsd_clear_halt(struct libusb_device_handle *handle, unsigned char endpoint) {
+    struct device_priv    *dpriv = usbi_get_device_priv(handle->dev);
+    struct usb_ctl_request req;
+
+    usbi_dbg(HANDLE_CTX(handle), " ");
+
+    req.ucr_request.bmRequestType = UT_WRITE_ENDPOINT;
+    req.ucr_request.bRequest      = UR_CLEAR_FEATURE;
+    USETW(req.ucr_request.wValue, UF_ENDPOINT_HALT);
+    USETW(req.ucr_request.wIndex, endpoint);
+    USETW(req.ucr_request.wLength, 0);
+
+    if(ioctl(dpriv->fd, USB_DO_REQUEST, &req) < 0)
+        return _errno_to_libusb(errno);
+
+    return (LIBUSB_SUCCESS);
+}
+
+void netbsd_destroy_device(struct libusb_device *dev) {
+    struct device_priv *dpriv = usbi_get_device_priv(dev);
+
+    usbi_dbg(DEVICE_CTX(dev), " ");
+
+    free(dpriv->cdesc);
+}
+
+int netbsd_submit_transfer(struct usbi_transfer *itransfer) {
+    struct libusb_transfer *transfer;
+    int                     err = 0;
+
+    usbi_dbg(ITRANSFER_CTX(itransfer), " ");
+
+    transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+
+    switch(transfer->type) {
+    case LIBUSB_TRANSFER_TYPE_CONTROL:
+        err = _sync_control_transfer(itransfer);
+        break;
+    case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
+        if(IS_XFEROUT(transfer)) {
+            /* Isochronous write is not supported */
+            err = LIBUSB_ERROR_NOT_SUPPORTED;
+            break;
+        }
+        err = _sync_gen_transfer(itransfer);
+        break;
+    case LIBUSB_TRANSFER_TYPE_BULK:
+    case LIBUSB_TRANSFER_TYPE_INTERRUPT:
+        if(IS_XFEROUT(transfer) && transfer->flags & LIBUSB_TRANSFER_ADD_ZERO_PACKET) {
+            err = LIBUSB_ERROR_NOT_SUPPORTED;
+            break;
+        }
+        err = _sync_gen_transfer(itransfer);
+        break;
+    case LIBUSB_TRANSFER_TYPE_BULK_STREAM:
+        err = LIBUSB_ERROR_NOT_SUPPORTED;
+        break;
+    }
+
+    if(err)
+        return (err);
+
+    usbi_signal_transfer_completion(itransfer);
+
+    return (LIBUSB_SUCCESS);
+}
+
+int netbsd_cancel_transfer(struct usbi_transfer *itransfer) {
+    UNUSED(itransfer);
+
+    usbi_dbg(ITRANSFER_CTX(itransfer), " ");
+
+    return (LIBUSB_ERROR_NOT_SUPPORTED);
+}
+
+int netbsd_handle_transfer_completion(struct usbi_transfer *itransfer) {
+    return usbi_handle_transfer_completion(itransfer, LIBUSB_TRANSFER_COMPLETED);
+}
+
+int _errno_to_libusb(int err) {
+    switch(err) {
+    case EIO:
+        return (LIBUSB_ERROR_IO);
+    case EACCES:
+        return (LIBUSB_ERROR_ACCESS);
+    case ENOENT:
+        return (LIBUSB_ERROR_NO_DEVICE);
+    case ENOMEM:
+        return (LIBUSB_ERROR_NO_MEM);
+    case EWOULDBLOCK:
+    case ETIMEDOUT:
+        return (LIBUSB_ERROR_TIMEOUT);
+    }
+
+    usbi_dbg(NULL, "error: %s", strerror(err));
+
+    return (LIBUSB_ERROR_OTHER);
+}
+
+int _cache_active_config_descriptor(struct libusb_device *dev, int fd) {
+    struct device_priv    *dpriv = usbi_get_device_priv(dev);
+    struct usb_config_desc ucd;
+    struct usb_full_desc   ufd;
+    void                  *buf;
+    int                    len;
+
+    usbi_dbg(DEVICE_CTX(dev), "fd %d", fd);
+
+    ucd.ucd_config_index = USB_CURRENT_CONFIG_INDEX;
+
+    if((ioctl(fd, USB_GET_CONFIG_DESC, &ucd)) < 0)
+        return _errno_to_libusb(errno);
+
+    usbi_dbg(DEVICE_CTX(dev), "active bLength %d", ucd.ucd_desc.bLength);
+
+    len = UGETW(ucd.ucd_desc.wTotalLength);
+    buf = malloc((size_t)len);
+    if(buf == NULL)
+        return (LIBUSB_ERROR_NO_MEM);
+
+    ufd.ufd_config_index = ucd.ucd_config_index;
+    ufd.ufd_size         = len;
+    ufd.ufd_data         = buf;
+
+    usbi_dbg(DEVICE_CTX(dev), "index %d, len %d", ufd.ufd_config_index, len);
+
+    if((ioctl(fd, USB_GET_FULL_DESC, &ufd)) < 0) {
+        free(buf);
+        return _errno_to_libusb(errno);
+    }
+
+    if(dpriv->cdesc)
+        free(dpriv->cdesc);
+    dpriv->cdesc = buf;
+
+    return (0);
+}
+
+int _sync_control_transfer(struct usbi_transfer *itransfer) {
+    struct libusb_transfer      *transfer;
+    struct libusb_control_setup *setup;
+    struct device_priv          *dpriv;
+    struct usb_ctl_request       req;
+
+    transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+    dpriv    = usbi_get_device_priv(transfer->dev_handle->dev);
+    setup    = (struct libusb_control_setup *)transfer->buffer;
+
+    usbi_dbg(ITRANSFER_CTX(itransfer), "type %d request %d value %d index %d length %d timeout %d", setup->bmRequestType, setup->bRequest,
+             libusb_le16_to_cpu(setup->wValue), libusb_le16_to_cpu(setup->wIndex), libusb_le16_to_cpu(setup->wLength), transfer->timeout);
+
+    req.ucr_request.bmRequestType = setup->bmRequestType;
+    req.ucr_request.bRequest      = setup->bRequest;
+    /* Don't use USETW, libusb already deals with the endianness */
+    (*(uint16_t *)req.ucr_request.wValue)  = setup->wValue;
+    (*(uint16_t *)req.ucr_request.wIndex)  = setup->wIndex;
+    (*(uint16_t *)req.ucr_request.wLength) = setup->wLength;
+    req.ucr_data                           = transfer->buffer + LIBUSB_CONTROL_SETUP_SIZE;
+
+    if((transfer->flags & LIBUSB_TRANSFER_SHORT_NOT_OK) == 0)
+        req.ucr_flags = USBD_SHORT_XFER_OK;
+
+    if((ioctl(dpriv->fd, USB_SET_TIMEOUT, &transfer->timeout)) < 0)
+        return _errno_to_libusb(errno);
+
+    if((ioctl(dpriv->fd, USB_DO_REQUEST, &req)) < 0)
+        return _errno_to_libusb(errno);
+
+    itransfer->transferred = req.ucr_actlen;
+
+    usbi_dbg(ITRANSFER_CTX(itransfer), "transferred %d", itransfer->transferred);
+
+    return (0);
+}
+
+int _access_endpoint(struct libusb_transfer *transfer) {
+    struct handle_priv *hpriv;
+    struct device_priv *dpriv;
+    char               *s, devnode[16];
+    int                 fd, endpt;
+    mode_t              mode;
+
+    hpriv = usbi_get_device_handle_priv(transfer->dev_handle);
+    dpriv = usbi_get_device_priv(transfer->dev_handle->dev);
+
+    endpt = UE_GET_ADDR(transfer->endpoint);
+    mode  = IS_XFERIN(transfer) ? O_RDONLY : O_WRONLY;
+
+    usbi_dbg(TRANSFER_CTX(transfer), "endpoint %d mode %d", endpt, mode);
+
+    if(hpriv->endpoints[endpt] < 0) {
+        /* Pick the right node given the control one */
+        strlcpy(devnode, dpriv->devnode, sizeof(devnode));
+        s = strchr(devnode, '.');
+        snprintf(s, 4, ".%02d", endpt);
+
+        /* We may need to read/write to the same endpoint later. */
+        if(((fd = open(devnode, O_RDWR)) < 0) && (errno == ENXIO))
+            if((fd = open(devnode, mode)) < 0)
+                return (-1);
+
+        hpriv->endpoints[endpt] = fd;
+    }
+
+    return (hpriv->endpoints[endpt]);
+}
+
+int _sync_gen_transfer(struct usbi_transfer *itransfer) {
+    struct libusb_transfer *transfer;
+    int                     fd, nr = 1;
+
+    transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+
+    /*
+     * Bulk, Interrupt or Isochronous transfer depends on the
+     * endpoint and thus the node to open.
+     */
+    if((fd = _access_endpoint(transfer)) < 0)
+        return _errno_to_libusb(errno);
+
+    if((ioctl(fd, USB_SET_TIMEOUT, &transfer->timeout)) < 0)
+        return _errno_to_libusb(errno);
+
+    if(IS_XFERIN(transfer)) {
+        if((transfer->flags & LIBUSB_TRANSFER_SHORT_NOT_OK) == 0)
+            if((ioctl(fd, USB_SET_SHORT_XFER, &nr)) < 0)
+                return _errno_to_libusb(errno);
+
+        nr = read(fd, transfer->buffer, transfer->length);
+    }
+    else {
+        nr = write(fd, transfer->buffer, transfer->length);
+    }
+
+    if(nr < 0)
+        return _errno_to_libusb(errno);
+
+    itransfer->transferred = nr;
+
+    return (0);
+}
diff --git a/3rdparty/libusb/src/libusb/os/null_usb.c b/3rdparty/libusb/src/libusb/os/null_usb.c
new file mode 100644
index 00000000..0cd531d7
--- /dev/null
+++ b/3rdparty/libusb/src/libusb/os/null_usb.c
@@ -0,0 +1,111 @@
+/*
+ * Copyright © 2019 Pino Toscano <toscano.pino@tiscali.it>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "libusbi.h"
+
+static int
+null_get_device_list(struct libusb_context * ctx,
+	struct discovered_devs **discdevs)
+{
+	return LIBUSB_SUCCESS;
+}
+
+static int
+null_open(struct libusb_device_handle *handle)
+{
+	return LIBUSB_ERROR_NOT_SUPPORTED;
+}
+
+static void
+null_close(struct libusb_device_handle *handle)
+{
+}
+
+static int
+null_get_active_config_descriptor(struct libusb_device *dev,
+    void *buf, size_t len)
+{
+	return LIBUSB_ERROR_NOT_SUPPORTED;
+}
+
+static int
+null_get_config_descriptor(struct libusb_device *dev, uint8_t idx,
+    void *buf, size_t len)
+{
+	return LIBUSB_ERROR_NOT_SUPPORTED;
+}
+
+static int
+null_set_configuration(struct libusb_device_handle *handle, int config)
+{
+	return LIBUSB_ERROR_NOT_SUPPORTED;
+}
+
+static int
+null_claim_interface(struct libusb_device_handle *handle, uint8_t iface)
+{
+	return LIBUSB_ERROR_NOT_SUPPORTED;
+}
+
+static int
+null_release_interface(struct libusb_device_handle *handle, uint8_t iface)
+{
+	return LIBUSB_ERROR_NOT_SUPPORTED;
+}
+
+static int
+null_set_interface_altsetting(struct libusb_device_handle *handle, uint8_t iface,
+    uint8_t altsetting)
+{
+	return LIBUSB_ERROR_NOT_SUPPORTED;
+}
+
+static int
+null_clear_halt(struct libusb_device_handle *handle, unsigned char endpoint)
+{
+	return LIBUSB_ERROR_NOT_SUPPORTED;
+}
+
+static int
+null_submit_transfer(struct usbi_transfer *itransfer)
+{
+	return LIBUSB_ERROR_NOT_SUPPORTED;
+}
+
+static int
+null_cancel_transfer(struct usbi_transfer *itransfer)
+{
+	return LIBUSB_ERROR_NOT_SUPPORTED;
+}
+
+const struct usbi_os_backend usbi_backend = {
+	.name = "Null backend",
+	.caps = 0,
+	.get_device_list = null_get_device_list,
+	.open = null_open,
+	.close = null_close,
+	.get_active_config_descriptor = null_get_active_config_descriptor,
+	.get_config_descriptor = null_get_config_descriptor,
+	.set_configuration = null_set_configuration,
+	.claim_interface = null_claim_interface,
+	.release_interface = null_release_interface,
+	.set_interface_altsetting = null_set_interface_altsetting,
+	.clear_halt = null_clear_halt,
+	.submit_transfer = null_submit_transfer,
+	.cancel_transfer = null_cancel_transfer,
+};
diff --git a/3rdparty/libusb/src/libusb/os/openbsd_usb.c b/3rdparty/libusb/src/libusb/os/openbsd_usb.c
new file mode 100644
index 00000000..0bb6a28c
--- /dev/null
+++ b/3rdparty/libusb/src/libusb/os/openbsd_usb.c
@@ -0,0 +1,644 @@
+/*
+ * Copyright © 2011-2013 Martin Pieuchot <mpi@openbsd.org>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <libusb/config.h>
+
+#include <sys/time.h>
+#include <sys/types.h>
+
+#include <errno.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#include <dev/usb/usb.h>
+
+#include "libusbi.h"
+
+struct device_priv {
+    char *devname; /* name of the ugen(4) node */
+    int   fd;      /* device file descriptor */
+
+    usb_config_descriptor_t *cdesc; /* active config descriptor */
+};
+
+struct handle_priv {
+    int endpoints[USB_MAX_ENDPOINTS];
+};
+
+/*
+ * Backend functions
+ */
+static int  obsd_get_device_list(struct libusb_context *, struct discovered_devs **);
+static int  obsd_open(struct libusb_device_handle *);
+static void obsd_close(struct libusb_device_handle *);
+
+static int obsd_get_active_config_descriptor(struct libusb_device *, void *, size_t);
+static int obsd_get_config_descriptor(struct libusb_device *, uint8_t, void *, size_t);
+
+static int obsd_get_configuration(struct libusb_device_handle *, uint8_t *);
+static int obsd_set_configuration(struct libusb_device_handle *, int);
+
+static int obsd_claim_interface(struct libusb_device_handle *, uint8_t);
+static int obsd_release_interface(struct libusb_device_handle *, uint8_t);
+
+static int  obsd_set_interface_altsetting(struct libusb_device_handle *, uint8_t, uint8_t);
+static int  obsd_clear_halt(struct libusb_device_handle *, unsigned char);
+static void obsd_destroy_device(struct libusb_device *);
+
+static int obsd_submit_transfer(struct usbi_transfer *);
+static int obsd_cancel_transfer(struct usbi_transfer *);
+static int obsd_handle_transfer_completion(struct usbi_transfer *);
+
+/*
+ * Private functions
+ */
+static int _errno_to_libusb(int);
+static int _cache_active_config_descriptor(struct libusb_device *);
+static int _sync_control_transfer(struct usbi_transfer *);
+static int _sync_gen_transfer(struct usbi_transfer *);
+static int _access_endpoint(struct libusb_transfer *);
+
+static int _bus_open(int);
+
+const struct usbi_os_backend usbi_backend = {
+    .name            = "Synchronous OpenBSD backend",
+    .get_device_list = obsd_get_device_list,
+    .open            = obsd_open,
+    .close           = obsd_close,
+
+    .get_active_config_descriptor = obsd_get_active_config_descriptor,
+    .get_config_descriptor        = obsd_get_config_descriptor,
+
+    .get_configuration = obsd_get_configuration,
+    .set_configuration = obsd_set_configuration,
+
+    .claim_interface   = obsd_claim_interface,
+    .release_interface = obsd_release_interface,
+
+    .set_interface_altsetting = obsd_set_interface_altsetting,
+    .clear_halt               = obsd_clear_halt,
+    .destroy_device           = obsd_destroy_device,
+
+    .submit_transfer = obsd_submit_transfer,
+    .cancel_transfer = obsd_cancel_transfer,
+
+    .handle_transfer_completion = obsd_handle_transfer_completion,
+
+    .device_priv_size        = sizeof(struct device_priv),
+    .device_handle_priv_size = sizeof(struct handle_priv),
+};
+
+#define DEVPATH "/dev/"
+#define USBDEV DEVPATH "usb"
+
+int obsd_get_device_list(struct libusb_context *ctx, struct discovered_devs **discdevs) {
+    struct discovered_devs *ddd;
+    struct libusb_device   *dev;
+    struct device_priv     *dpriv;
+    struct usb_device_info  di;
+    struct usb_device_ddesc dd;
+    unsigned long           session_id;
+    char                    devices[USB_MAX_DEVICES];
+    char                    busnode[16];
+    char                   *udevname;
+    int                     fd, addr, i, j;
+
+    usbi_dbg(ctx, " ");
+
+    for(i = 0; i < 8; i++) {
+        snprintf(busnode, sizeof(busnode), USBDEV "%d", i);
+
+        if((fd = open(busnode, O_RDWR)) < 0) {
+            if(errno != ENOENT && errno != ENXIO)
+                usbi_err(ctx, "could not open %s", busnode);
+            continue;
+        }
+
+        bzero(devices, sizeof(devices));
+        for(addr = 1; addr < USB_MAX_DEVICES; addr++) {
+            if(devices[addr])
+                continue;
+
+            di.udi_addr = addr;
+            if(ioctl(fd, USB_DEVICEINFO, &di) < 0)
+                continue;
+
+            /*
+             * XXX If ugen(4) is attached to the USB device
+             * it will be used.
+             */
+            udevname = NULL;
+            for(j = 0; j < USB_MAX_DEVNAMES; j++)
+                if(!strncmp("ugen", di.udi_devnames[j], 4)) {
+                    udevname = strdup(di.udi_devnames[j]);
+                    break;
+                }
+
+            session_id = (di.udi_bus << 8 | di.udi_addr);
+            dev        = usbi_get_device_by_session_id(ctx, session_id);
+
+            if(dev == NULL) {
+                dev = usbi_alloc_device(ctx, session_id);
+                if(dev == NULL) {
+                    close(fd);
+                    return (LIBUSB_ERROR_NO_MEM);
+                }
+
+                dev->bus_number     = di.udi_bus;
+                dev->device_address = di.udi_addr;
+                dev->speed          = di.udi_speed;
+                dev->port_number    = di.udi_port;
+
+                dpriv          = usbi_get_device_priv(dev);
+                dpriv->fd      = -1;
+                dpriv->devname = udevname;
+
+                dd.udd_bus  = di.udi_bus;
+                dd.udd_addr = di.udi_addr;
+                if(ioctl(fd, USB_DEVICE_GET_DDESC, &dd) < 0) {
+                    libusb_unref_device(dev);
+                    continue;
+                }
+
+                static_assert(sizeof(dev->device_descriptor) == sizeof(dd.udd_desc), "mismatch between libusb and OS device descriptor sizes");
+                memcpy(&dev->device_descriptor, &dd.udd_desc, LIBUSB_DT_DEVICE_SIZE);
+                usbi_localize_device_descriptor(&dev->device_descriptor);
+
+                if(_cache_active_config_descriptor(dev)) {
+                    libusb_unref_device(dev);
+                    continue;
+                }
+
+                if(usbi_sanitize_device(dev)) {
+                    libusb_unref_device(dev);
+                    continue;
+                }
+            }
+
+            ddd = discovered_devs_append(*discdevs, dev);
+            if(ddd == NULL) {
+                close(fd);
+                return (LIBUSB_ERROR_NO_MEM);
+            }
+            libusb_unref_device(dev);
+
+            *discdevs     = ddd;
+            devices[addr] = 1;
+        }
+
+        close(fd);
+    }
+
+    return (LIBUSB_SUCCESS);
+}
+
+int obsd_open(struct libusb_device_handle *handle) {
+    struct device_priv *dpriv = usbi_get_device_priv(handle->dev);
+    char                devnode[16];
+
+    if(dpriv->devname) {
+        int fd;
+        /*
+         * Only open ugen(4) attached devices read-write, all
+         * read-only operations are done through the bus node.
+         */
+        snprintf(devnode, sizeof(devnode), DEVPATH "%s.00", dpriv->devname);
+        fd = open(devnode, O_RDWR);
+        if(fd < 0)
+            return _errno_to_libusb(errno);
+        dpriv->fd = fd;
+
+        usbi_dbg(HANDLE_CTX(handle), "open %s: fd %d", devnode, dpriv->fd);
+    }
+
+    return (LIBUSB_SUCCESS);
+}
+
+void obsd_close(struct libusb_device_handle *handle) {
+    struct device_priv *dpriv = usbi_get_device_priv(handle->dev);
+
+    if(dpriv->devname) {
+        usbi_dbg(HANDLE_CTX(handle), "close: fd %d", dpriv->fd);
+
+        close(dpriv->fd);
+        dpriv->fd = -1;
+    }
+}
+
+int obsd_get_active_config_descriptor(struct libusb_device *dev, void *buf, size_t len) {
+    struct device_priv *dpriv = usbi_get_device_priv(dev);
+
+    len = MIN(len, (size_t)UGETW(dpriv->cdesc->wTotalLength));
+
+    usbi_dbg(DEVICE_CTX(dev), "len %zu", len);
+
+    memcpy(buf, dpriv->cdesc, len);
+
+    return ((int)len);
+}
+
+int obsd_get_config_descriptor(struct libusb_device *dev, uint8_t idx, void *buf, size_t len) {
+    struct usb_device_fdesc udf;
+    int                     fd, err;
+
+    if((fd = _bus_open(dev->bus_number)) < 0)
+        return _errno_to_libusb(errno);
+
+    udf.udf_bus          = dev->bus_number;
+    udf.udf_addr         = dev->device_address;
+    udf.udf_config_index = idx;
+    udf.udf_size         = len;
+    udf.udf_data         = buf;
+
+    usbi_dbg(DEVICE_CTX(dev), "index %d, len %zu", udf.udf_config_index, len);
+
+    if(ioctl(fd, USB_DEVICE_GET_FDESC, &udf) < 0) {
+        err = errno;
+        close(fd);
+        return _errno_to_libusb(err);
+    }
+    close(fd);
+
+    return ((int)len);
+}
+
+int obsd_get_configuration(struct libusb_device_handle *handle, uint8_t *config) {
+    struct device_priv *dpriv = usbi_get_device_priv(handle->dev);
+
+    *config = dpriv->cdesc->bConfigurationValue;
+
+    usbi_dbg(HANDLE_CTX(handle), "bConfigurationValue %u", *config);
+
+    return (LIBUSB_SUCCESS);
+}
+
+int obsd_set_configuration(struct libusb_device_handle *handle, int config) {
+    struct device_priv *dpriv = usbi_get_device_priv(handle->dev);
+
+    if(dpriv->devname == NULL)
+        return (LIBUSB_ERROR_NOT_SUPPORTED);
+
+    usbi_dbg(HANDLE_CTX(handle), "bConfigurationValue %d", config);
+
+    if(ioctl(dpriv->fd, USB_SET_CONFIG, &config) < 0)
+        return _errno_to_libusb(errno);
+
+    return _cache_active_config_descriptor(handle->dev);
+}
+
+int obsd_claim_interface(struct libusb_device_handle *handle, uint8_t iface) {
+    struct handle_priv *hpriv = usbi_get_device_handle_priv(handle);
+    int                 i;
+
+    UNUSED(iface);
+
+    for(i = 0; i < USB_MAX_ENDPOINTS; i++)
+        hpriv->endpoints[i] = -1;
+
+    return (LIBUSB_SUCCESS);
+}
+
+int obsd_release_interface(struct libusb_device_handle *handle, uint8_t iface) {
+    struct handle_priv *hpriv = usbi_get_device_handle_priv(handle);
+    int                 i;
+
+    UNUSED(iface);
+
+    for(i = 0; i < USB_MAX_ENDPOINTS; i++)
+        if(hpriv->endpoints[i] >= 0)
+            close(hpriv->endpoints[i]);
+
+    return (LIBUSB_SUCCESS);
+}
+
+int obsd_set_interface_altsetting(struct libusb_device_handle *handle, uint8_t iface, uint8_t altsetting) {
+    struct device_priv      *dpriv = usbi_get_device_priv(handle->dev);
+    struct usb_alt_interface intf;
+
+    if(dpriv->devname == NULL)
+        return (LIBUSB_ERROR_NOT_SUPPORTED);
+
+    usbi_dbg(HANDLE_CTX(handle), "iface %u, setting %u", iface, altsetting);
+
+    memset(&intf, 0, sizeof(intf));
+
+    intf.uai_interface_index = iface;
+    intf.uai_alt_no          = altsetting;
+
+    if(ioctl(dpriv->fd, USB_SET_ALTINTERFACE, &intf) < 0)
+        return _errno_to_libusb(errno);
+
+    return (LIBUSB_SUCCESS);
+}
+
+int obsd_clear_halt(struct libusb_device_handle *handle, unsigned char endpoint) {
+    struct usb_ctl_request req;
+    int                    fd, err;
+
+    if((fd = _bus_open(handle->dev->bus_number)) < 0)
+        return _errno_to_libusb(errno);
+
+    usbi_dbg(HANDLE_CTX(handle), " ");
+
+    req.ucr_addr                  = handle->dev->device_address;
+    req.ucr_request.bmRequestType = UT_WRITE_ENDPOINT;
+    req.ucr_request.bRequest      = UR_CLEAR_FEATURE;
+    USETW(req.ucr_request.wValue, UF_ENDPOINT_HALT);
+    USETW(req.ucr_request.wIndex, endpoint);
+    USETW(req.ucr_request.wLength, 0);
+
+    if(ioctl(fd, USB_REQUEST, &req) < 0) {
+        err = errno;
+        close(fd);
+        return _errno_to_libusb(err);
+    }
+    close(fd);
+
+    return (LIBUSB_SUCCESS);
+}
+
+void obsd_destroy_device(struct libusb_device *dev) {
+    struct device_priv *dpriv = usbi_get_device_priv(dev);
+
+    usbi_dbg(DEVICE_CTX(dev), " ");
+
+    free(dpriv->cdesc);
+    free(dpriv->devname);
+}
+
+int obsd_submit_transfer(struct usbi_transfer *itransfer) {
+    struct libusb_transfer *transfer;
+    int                     err = 0;
+
+    usbi_dbg(ITRANSFER_CTX(itransfer), " ");
+
+    transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+
+    switch(transfer->type) {
+    case LIBUSB_TRANSFER_TYPE_CONTROL:
+        err = _sync_control_transfer(itransfer);
+        break;
+    case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
+        if(IS_XFEROUT(transfer)) {
+            /* Isochronous write is not supported */
+            err = LIBUSB_ERROR_NOT_SUPPORTED;
+            break;
+        }
+        err = _sync_gen_transfer(itransfer);
+        break;
+    case LIBUSB_TRANSFER_TYPE_BULK:
+    case LIBUSB_TRANSFER_TYPE_INTERRUPT:
+        if(IS_XFEROUT(transfer) && transfer->flags & LIBUSB_TRANSFER_ADD_ZERO_PACKET) {
+            err = LIBUSB_ERROR_NOT_SUPPORTED;
+            break;
+        }
+        err = _sync_gen_transfer(itransfer);
+        break;
+    case LIBUSB_TRANSFER_TYPE_BULK_STREAM:
+        err = LIBUSB_ERROR_NOT_SUPPORTED;
+        break;
+    }
+
+    if(err)
+        return (err);
+
+    usbi_signal_transfer_completion(itransfer);
+
+    return (LIBUSB_SUCCESS);
+}
+
+int obsd_cancel_transfer(struct usbi_transfer *itransfer) {
+    UNUSED(itransfer);
+
+    usbi_dbg(ITRANSFER_CTX(itransfer), " ");
+
+    return (LIBUSB_ERROR_NOT_SUPPORTED);
+}
+
+int obsd_handle_transfer_completion(struct usbi_transfer *itransfer) {
+    return usbi_handle_transfer_completion(itransfer, LIBUSB_TRANSFER_COMPLETED);
+}
+
+int _errno_to_libusb(int err) {
+    usbi_dbg(NULL, "error: %s (%d)", strerror(err), err);
+
+    switch(err) {
+    case EIO:
+        return (LIBUSB_ERROR_IO);
+    case EACCES:
+        return (LIBUSB_ERROR_ACCESS);
+    case ENOENT:
+        return (LIBUSB_ERROR_NO_DEVICE);
+    case ENOMEM:
+        return (LIBUSB_ERROR_NO_MEM);
+    case ETIMEDOUT:
+        return (LIBUSB_ERROR_TIMEOUT);
+    }
+
+    return (LIBUSB_ERROR_OTHER);
+}
+
+int _cache_active_config_descriptor(struct libusb_device *dev) {
+    struct device_priv     *dpriv = usbi_get_device_priv(dev);
+    struct usb_device_cdesc udc;
+    struct usb_device_fdesc udf;
+    void                   *buf;
+    int                     fd, len, err;
+
+    if((fd = _bus_open(dev->bus_number)) < 0)
+        return _errno_to_libusb(errno);
+
+    usbi_dbg(DEVICE_CTX(dev), "fd %d, addr %d", fd, dev->device_address);
+
+    udc.udc_bus          = dev->bus_number;
+    udc.udc_addr         = dev->device_address;
+    udc.udc_config_index = USB_CURRENT_CONFIG_INDEX;
+    if(ioctl(fd, USB_DEVICE_GET_CDESC, &udc) < 0) {
+        err = errno;
+        close(fd);
+        return _errno_to_libusb(errno);
+    }
+
+    usbi_dbg(DEVICE_CTX(dev), "active bLength %d", udc.udc_desc.bLength);
+
+    len = UGETW(udc.udc_desc.wTotalLength);
+    buf = malloc((size_t)len);
+    if(buf == NULL)
+        return (LIBUSB_ERROR_NO_MEM);
+
+    udf.udf_bus          = dev->bus_number;
+    udf.udf_addr         = dev->device_address;
+    udf.udf_config_index = udc.udc_config_index;
+    udf.udf_size         = len;
+    udf.udf_data         = buf;
+
+    usbi_dbg(DEVICE_CTX(dev), "index %d, len %d", udf.udf_config_index, len);
+
+    if(ioctl(fd, USB_DEVICE_GET_FDESC, &udf) < 0) {
+        err = errno;
+        close(fd);
+        free(buf);
+        return _errno_to_libusb(err);
+    }
+    close(fd);
+
+    if(dpriv->cdesc)
+        free(dpriv->cdesc);
+    dpriv->cdesc = buf;
+
+    return (LIBUSB_SUCCESS);
+}
+
+int _sync_control_transfer(struct usbi_transfer *itransfer) {
+    struct libusb_transfer      *transfer;
+    struct libusb_control_setup *setup;
+    struct device_priv          *dpriv;
+    struct usb_ctl_request       req;
+
+    transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+    dpriv    = usbi_get_device_priv(transfer->dev_handle->dev);
+    setup    = (struct libusb_control_setup *)transfer->buffer;
+
+    usbi_dbg(ITRANSFER_CTX(itransfer), "type 0x%x request 0x%x value 0x%x index %d length %d timeout %d", setup->bmRequestType, setup->bRequest,
+             libusb_le16_to_cpu(setup->wValue), libusb_le16_to_cpu(setup->wIndex), libusb_le16_to_cpu(setup->wLength), transfer->timeout);
+
+    req.ucr_addr                  = transfer->dev_handle->dev->device_address;
+    req.ucr_request.bmRequestType = setup->bmRequestType;
+    req.ucr_request.bRequest      = setup->bRequest;
+    /* Don't use USETW, libusb already deals with the endianness */
+    (*(uint16_t *)req.ucr_request.wValue)  = setup->wValue;
+    (*(uint16_t *)req.ucr_request.wIndex)  = setup->wIndex;
+    (*(uint16_t *)req.ucr_request.wLength) = setup->wLength;
+    req.ucr_data                           = transfer->buffer + LIBUSB_CONTROL_SETUP_SIZE;
+
+    if((transfer->flags & LIBUSB_TRANSFER_SHORT_NOT_OK) == 0)
+        req.ucr_flags = USBD_SHORT_XFER_OK;
+
+    if(dpriv->devname == NULL) {
+        /*
+         * XXX If the device is not attached to ugen(4) it is
+         * XXX still possible to submit a control transfer but
+         * XXX with the default timeout only.
+         */
+        int fd, err;
+
+        if((fd = _bus_open(transfer->dev_handle->dev->bus_number)) < 0)
+            return _errno_to_libusb(errno);
+
+        if((ioctl(fd, USB_REQUEST, &req)) < 0) {
+            err = errno;
+            close(fd);
+            return _errno_to_libusb(err);
+        }
+        close(fd);
+    }
+    else {
+        if((ioctl(dpriv->fd, USB_SET_TIMEOUT, &transfer->timeout)) < 0)
+            return _errno_to_libusb(errno);
+
+        if((ioctl(dpriv->fd, USB_DO_REQUEST, &req)) < 0)
+            return _errno_to_libusb(errno);
+    }
+
+    itransfer->transferred = req.ucr_actlen;
+
+    usbi_dbg(ITRANSFER_CTX(itransfer), "transferred %d", itransfer->transferred);
+
+    return (0);
+}
+
+int _access_endpoint(struct libusb_transfer *transfer) {
+    struct handle_priv *hpriv;
+    struct device_priv *dpriv;
+    char                devnode[16];
+    int                 fd, endpt;
+    mode_t              mode;
+
+    hpriv = usbi_get_device_handle_priv(transfer->dev_handle);
+    dpriv = usbi_get_device_priv(transfer->dev_handle->dev);
+
+    endpt = UE_GET_ADDR(transfer->endpoint);
+    mode  = IS_XFERIN(transfer) ? O_RDONLY : O_WRONLY;
+
+    usbi_dbg(TRANSFER_CTX(transfer), "endpoint %d mode %d", endpt, mode);
+
+    if(hpriv->endpoints[endpt] < 0) {
+        /* Pick the right endpoint node */
+        snprintf(devnode, sizeof(devnode), DEVPATH "%s.%02d", dpriv->devname, endpt);
+
+        /* We may need to read/write to the same endpoint later. */
+        if(((fd = open(devnode, O_RDWR)) < 0) && (errno == ENXIO))
+            if((fd = open(devnode, mode)) < 0)
+                return (-1);
+
+        hpriv->endpoints[endpt] = fd;
+    }
+
+    return (hpriv->endpoints[endpt]);
+}
+
+int _sync_gen_transfer(struct usbi_transfer *itransfer) {
+    struct libusb_transfer *transfer;
+    struct device_priv     *dpriv;
+    int                     fd, nr = 1;
+
+    transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+    dpriv    = usbi_get_device_priv(transfer->dev_handle->dev);
+
+    if(dpriv->devname == NULL)
+        return (LIBUSB_ERROR_NOT_SUPPORTED);
+
+    /*
+     * Bulk, Interrupt or Isochronous transfer depends on the
+     * endpoint and thus the node to open.
+     */
+    if((fd = _access_endpoint(transfer)) < 0)
+        return _errno_to_libusb(errno);
+
+    if((ioctl(fd, USB_SET_TIMEOUT, &transfer->timeout)) < 0)
+        return _errno_to_libusb(errno);
+
+    if(IS_XFERIN(transfer)) {
+        if((transfer->flags & LIBUSB_TRANSFER_SHORT_NOT_OK) == 0)
+            if((ioctl(fd, USB_SET_SHORT_XFER, &nr)) < 0)
+                return _errno_to_libusb(errno);
+
+        nr = read(fd, transfer->buffer, transfer->length);
+    }
+    else {
+        nr = write(fd, transfer->buffer, transfer->length);
+    }
+
+    if(nr < 0)
+        return _errno_to_libusb(errno);
+
+    itransfer->transferred = nr;
+
+    return (0);
+}
+
+int _bus_open(int number) {
+    char busnode[16];
+
+    snprintf(busnode, sizeof(busnode), USBDEV "%d", number);
+
+    return open(busnode, O_RDWR);
+}
diff --git a/3rdparty/libusb/src/libusb/os/sunos_usb.c b/3rdparty/libusb/src/libusb/os/sunos_usb.c
new file mode 100644
index 00000000..37f39563
--- /dev/null
+++ b/3rdparty/libusb/src/libusb/os/sunos_usb.c
@@ -0,0 +1,1468 @@
+/*
+ *
+ * Copyright (c) 2016, Oracle and/or its affiliates.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <libusb/config.h>
+
+#include <sys/time.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <strings.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <wait.h>
+#include <unistd.h>
+#include <aio.h>
+#include <libdevinfo.h>
+#include <sys/nvpair.h>
+#include <sys/devctl.h>
+#include <sys/usb/clients/ugen/usb_ugen.h>
+#include <sys/usb/usba.h>
+#include <sys/pci.h>
+
+#include "libusbi.h"
+#include "sunos_usb.h"
+
+#define UPDATEDRV_PATH "/usr/sbin/update_drv"
+#define UPDATEDRV "update_drv"
+
+#define DEFAULT_LISTSIZE 6
+
+typedef struct {
+    int    nargs;
+    int    listsize;
+    char **string;
+} string_list_t;
+
+/*
+ * Backend functions
+ */
+static int  sunos_get_device_list(struct libusb_context *, struct discovered_devs **);
+static int  sunos_open(struct libusb_device_handle *);
+static void sunos_close(struct libusb_device_handle *);
+static int  sunos_get_active_config_descriptor(struct libusb_device *, void *, size_t);
+static int  sunos_get_config_descriptor(struct libusb_device *, uint8_t, void *, size_t);
+static int  sunos_get_configuration(struct libusb_device_handle *, uint8_t *);
+static int  sunos_set_configuration(struct libusb_device_handle *, int);
+static int  sunos_claim_interface(struct libusb_device_handle *, uint8_t);
+static int  sunos_release_interface(struct libusb_device_handle *, uint8_t);
+static int  sunos_set_interface_altsetting(struct libusb_device_handle *, uint8_t, uint8_t);
+static int  sunos_clear_halt(struct libusb_device_handle *, unsigned char);
+static void sunos_destroy_device(struct libusb_device *);
+static int  sunos_submit_transfer(struct usbi_transfer *);
+static int  sunos_cancel_transfer(struct usbi_transfer *);
+static int  sunos_handle_transfer_completion(struct usbi_transfer *);
+static int  sunos_kernel_driver_active(struct libusb_device_handle *, uint8_t);
+static int  sunos_detach_kernel_driver(struct libusb_device_handle *, uint8_t);
+static int  sunos_attach_kernel_driver(struct libusb_device_handle *, uint8_t);
+static int  sunos_usb_open_ep0(sunos_dev_handle_priv_t *hpriv, sunos_dev_priv_t *dpriv);
+static int  sunos_usb_ioctl(struct libusb_device *dev, int cmd);
+
+static int sunos_get_link(di_devlink_t devlink, void *arg) {
+    walk_link_t *larg = (walk_link_t *)arg;
+    const char  *p;
+    const char  *q;
+
+    if(larg->path) {
+        char *content = (char *)di_devlink_content(devlink);
+        char *start   = strstr(content, "/devices/");
+        start += strlen("/devices");
+        usbi_dbg(NULL, "%s", start);
+
+        /* line content must have minor node */
+        if(start == NULL || strncmp(start, larg->path, larg->len) != 0 || start[larg->len] != ':')
+            return (DI_WALK_CONTINUE);
+    }
+
+    p = di_devlink_path(devlink);
+    q = strrchr(p, '/');
+    usbi_dbg(NULL, "%s", q);
+
+    *(larg->linkpp) = strndup(p, strlen(p) - strlen(q));
+
+    return (DI_WALK_TERMINATE);
+}
+
+static int sunos_physpath_to_devlink(const char *node_path, const char *match, char **link_path) {
+    walk_link_t         larg;
+    di_devlink_handle_t hdl;
+
+    *link_path  = NULL;
+    larg.linkpp = link_path;
+    if((hdl = di_devlink_init(NULL, 0)) == NULL) {
+        usbi_dbg(NULL, "di_devlink_init failure");
+        return (-1);
+    }
+
+    larg.len  = strlen(node_path);
+    larg.path = (char *)node_path;
+
+    (void)di_devlink_walk(hdl, match, NULL, DI_PRIMARY_LINK, (void *)&larg, sunos_get_link);
+
+    (void)di_devlink_fini(&hdl);
+
+    if(*link_path == NULL) {
+        usbi_dbg(NULL, "there is no devlink for this path");
+        return (-1);
+    }
+
+    return 0;
+}
+
+static int sunos_usb_ioctl(struct libusb_device *dev, int cmd) {
+    int                   fd;
+    nvlist_t             *nvlist;
+    char                 *end;
+    char                 *phypath;
+    char                 *hubpath;
+    char                  path_arg[PATH_MAX];
+    sunos_dev_priv_t     *dpriv;
+    devctl_ap_state_t     devctl_ap_state;
+    struct devctl_iocdata iocdata;
+
+    dpriv   = usbi_get_device_priv(dev);
+    phypath = dpriv->phypath;
+
+    end = strrchr(phypath, '/');
+    if(end == NULL)
+        return (-1);
+    hubpath = strndup(phypath, end - phypath);
+    if(hubpath == NULL)
+        return (-1);
+
+    end = strrchr(hubpath, '@');
+    if(end == NULL) {
+        free(hubpath);
+        return (-1);
+    }
+    end++;
+    usbi_dbg(DEVICE_CTX(dev), "unitaddr: %s", end);
+
+    nvlist_alloc(&nvlist, NV_UNIQUE_NAME_TYPE, KM_NOSLEEP);
+    nvlist_add_int32(nvlist, "port", dev->port_number);
+    // find the hub path
+    snprintf(path_arg, sizeof(path_arg), "/devices%s:hubd", hubpath);
+    usbi_dbg(DEVICE_CTX(dev), "ioctl hub path: %s", path_arg);
+
+    fd = open(path_arg, O_RDONLY);
+    if(fd < 0) {
+        usbi_err(DEVICE_CTX(dev), "open failed: errno %d (%s)", errno, strerror(errno));
+        nvlist_free(nvlist);
+        free(hubpath);
+        return (-1);
+    }
+
+    memset(&iocdata, 0, sizeof(iocdata));
+    memset(&devctl_ap_state, 0, sizeof(devctl_ap_state));
+
+    nvlist_pack(nvlist, (char **)&iocdata.nvl_user, &iocdata.nvl_usersz, NV_ENCODE_NATIVE, 0);
+
+    iocdata.cmd        = DEVCTL_AP_GETSTATE;
+    iocdata.flags      = 0;
+    iocdata.c_nodename = (char *)"hub";
+    iocdata.c_unitaddr = end;
+    iocdata.cpyout_buf = &devctl_ap_state;
+    usbi_dbg(DEVICE_CTX(dev), "%p, %" PRIuPTR, iocdata.nvl_user, iocdata.nvl_usersz);
+
+    errno = 0;
+    if(ioctl(fd, DEVCTL_AP_GETSTATE, &iocdata) == -1) {
+        usbi_err(DEVICE_CTX(dev), "ioctl failed: fd %d, cmd %x, errno %d (%s)", fd, DEVCTL_AP_GETSTATE, errno, strerror(errno));
+    }
+    else {
+        usbi_dbg(DEVICE_CTX(dev), "dev rstate: %d", devctl_ap_state.ap_rstate);
+        usbi_dbg(DEVICE_CTX(dev), "dev ostate: %d", devctl_ap_state.ap_ostate);
+    }
+
+    errno       = 0;
+    iocdata.cmd = cmd;
+    if(ioctl(fd, (int)cmd, &iocdata) != 0) {
+        usbi_err(DEVICE_CTX(dev), "ioctl failed: fd %d, cmd %x, errno %d (%s)", fd, cmd, errno, strerror(errno));
+        sleep(2);
+    }
+
+    close(fd);
+    free(iocdata.nvl_user);
+    nvlist_free(nvlist);
+    free(hubpath);
+
+    return (-errno);
+}
+
+static int sunos_kernel_driver_active(struct libusb_device_handle *dev_handle, uint8_t interface) {
+    sunos_dev_priv_t *dpriv = usbi_get_device_priv(dev_handle->dev);
+
+    UNUSED(interface);
+
+    usbi_dbg(HANDLE_CTX(dev_handle), "%s", dpriv->ugenpath);
+
+    return (dpriv->ugenpath == NULL);
+}
+
+/*
+ * Private functions
+ */
+static int _errno_to_libusb(int);
+static int sunos_usb_get_status(struct libusb_context *ctx, int fd);
+
+static string_list_t *sunos_new_string_list(void) {
+    string_list_t *list;
+
+    list = calloc(1, sizeof(string_list_t));
+    if(list == NULL)
+        return (NULL);
+    list->string = calloc(DEFAULT_LISTSIZE, sizeof(char *));
+    if(list->string == NULL) {
+        free(list);
+        return (NULL);
+    }
+    list->nargs    = 0;
+    list->listsize = DEFAULT_LISTSIZE;
+
+    return (list);
+}
+
+static int sunos_append_to_string_list(string_list_t *list, const char *arg) {
+    char *str = strdup(arg);
+
+    if(str == NULL)
+        return (-1);
+
+    if((list->nargs + 1) == list->listsize) { /* +1 is for NULL */
+        char **tmp = realloc(list->string, sizeof(char *) * (list->listsize + 1));
+        if(tmp == NULL) {
+            free(str);
+            return (-1);
+        }
+        list->string                   = tmp;
+        list->string[list->listsize++] = NULL;
+    }
+    list->string[list->nargs++] = str;
+
+    return (0);
+}
+
+static void sunos_free_string_list(string_list_t *list) {
+    int i;
+
+    for(i = 0; i < list->nargs; i++) {
+        free(list->string[i]);
+    }
+
+    free(list->string);
+    free(list);
+}
+
+static char **sunos_build_argv_list(string_list_t *list) {
+    return (list->string);
+}
+
+static int sunos_exec_command(struct libusb_context *ctx, const char *path, string_list_t *list) {
+    pid_t  pid;
+    int    status;
+    int    waitstat;
+    int    exit_status;
+    char **argv_list;
+
+    argv_list = sunos_build_argv_list(list);
+    if(argv_list == NULL)
+        return (-1);
+
+    pid = fork();
+    if(pid == 0) {
+        /* child */
+        execv(path, argv_list);
+        _exit(127);
+    }
+    else if(pid > 0) {
+        /* parent */
+        do {
+            waitstat = waitpid(pid, &status, 0);
+        } while((waitstat == -1 && errno == EINTR) || (waitstat == 0 && !WIFEXITED(status) && !WIFSIGNALED(status)));
+
+        if(waitstat == 0) {
+            if(WIFEXITED(status))
+                exit_status = WEXITSTATUS(status);
+            else
+                exit_status = WTERMSIG(status);
+        }
+        else {
+            usbi_err(ctx, "waitpid failed: errno %d (%s)", errno, strerror(errno));
+            exit_status = -1;
+        }
+    }
+    else {
+        /* fork failed */
+        usbi_err(ctx, "fork failed: errno %d (%s)", errno, strerror(errno));
+        exit_status = -1;
+    }
+
+    return (exit_status);
+}
+
+static int sunos_detach_kernel_driver(struct libusb_device_handle *dev_handle, uint8_t interface_number) {
+    struct libusb_context *ctx = HANDLE_CTX(dev_handle);
+    string_list_t         *list;
+    char                   path_arg[PATH_MAX];
+    sunos_dev_priv_t      *dpriv;
+    int                    r;
+
+    UNUSED(interface_number);
+
+    dpriv = usbi_get_device_priv(dev_handle->dev);
+    snprintf(path_arg, sizeof(path_arg), "\'\"%s\"\'", dpriv->phypath);
+    usbi_dbg(HANDLE_CTX(dev_handle), "%s", path_arg);
+
+    list = sunos_new_string_list();
+    if(list == NULL)
+        return (LIBUSB_ERROR_NO_MEM);
+
+    /* attach ugen driver */
+    r = 0;
+    r |= sunos_append_to_string_list(list, UPDATEDRV);
+    r |= sunos_append_to_string_list(list, "-a");     /* add rule */
+    r |= sunos_append_to_string_list(list, "-i");     /* specific device */
+    r |= sunos_append_to_string_list(list, path_arg); /* physical path */
+    r |= sunos_append_to_string_list(list, "ugen");
+    if(r) {
+        sunos_free_string_list(list);
+        return (LIBUSB_ERROR_NO_MEM);
+    }
+
+    r = sunos_exec_command(ctx, UPDATEDRV_PATH, list);
+    sunos_free_string_list(list);
+    if(r < 0)
+        return (LIBUSB_ERROR_OTHER);
+
+    /* reconfigure the driver node */
+    r = 0;
+    r |= sunos_usb_ioctl(dev_handle->dev, DEVCTL_AP_DISCONNECT);
+    r |= sunos_usb_ioctl(dev_handle->dev, DEVCTL_AP_CONFIGURE);
+    if(r)
+        usbi_warn(HANDLE_CTX(dev_handle), "one or more ioctls failed");
+
+    snprintf(path_arg, sizeof(path_arg), "^usb/%x.%x", dev_handle->dev->device_descriptor.idVendor, dev_handle->dev->device_descriptor.idProduct);
+    sunos_physpath_to_devlink(dpriv->phypath, path_arg, &dpriv->ugenpath);
+
+    if(access(dpriv->ugenpath, F_OK) == -1) {
+        usbi_err(HANDLE_CTX(dev_handle), "fail to detach kernel driver");
+        return (LIBUSB_ERROR_IO);
+    }
+
+    return sunos_usb_open_ep0(usbi_get_device_handle_priv(dev_handle), dpriv);
+}
+
+static int sunos_attach_kernel_driver(struct libusb_device_handle *dev_handle, uint8_t interface_number) {
+    struct libusb_context *ctx = HANDLE_CTX(dev_handle);
+    string_list_t         *list;
+    char                   path_arg[PATH_MAX];
+    sunos_dev_priv_t      *dpriv;
+    int                    r;
+
+    UNUSED(interface_number);
+
+    /* we open the dev in detach driver, so we need close it first. */
+    sunos_close(dev_handle);
+
+    dpriv = usbi_get_device_priv(dev_handle->dev);
+    snprintf(path_arg, sizeof(path_arg), "\'\"%s\"\'", dpriv->phypath);
+    usbi_dbg(HANDLE_CTX(dev_handle), "%s", path_arg);
+
+    list = sunos_new_string_list();
+    if(list == NULL)
+        return (LIBUSB_ERROR_NO_MEM);
+
+    /* detach ugen driver */
+    r = 0;
+    r |= sunos_append_to_string_list(list, UPDATEDRV);
+    r |= sunos_append_to_string_list(list, "-d");     /* add rule */
+    r |= sunos_append_to_string_list(list, "-i");     /* specific device */
+    r |= sunos_append_to_string_list(list, path_arg); /* physical path */
+    r |= sunos_append_to_string_list(list, "ugen");
+    if(r) {
+        sunos_free_string_list(list);
+        return (LIBUSB_ERROR_NO_MEM);
+    }
+
+    r = sunos_exec_command(ctx, UPDATEDRV_PATH, list);
+    sunos_free_string_list(list);
+    if(r < 0)
+        return (LIBUSB_ERROR_OTHER);
+
+    /* reconfigure the driver node */
+    r = 0;
+    r |= sunos_usb_ioctl(dev_handle->dev, DEVCTL_AP_CONFIGURE);
+    r |= sunos_usb_ioctl(dev_handle->dev, DEVCTL_AP_DISCONNECT);
+    r |= sunos_usb_ioctl(dev_handle->dev, DEVCTL_AP_CONFIGURE);
+    if(r)
+        usbi_warn(HANDLE_CTX(dev_handle), "one or more ioctls failed");
+
+    return 0;
+}
+
+static int sunos_fill_in_dev_info(di_node_t node, struct libusb_device *dev) {
+    int               proplen;
+    int              *i, n, *addr, *port_prop;
+    char             *phypath;
+    uint8_t          *rdata;
+    sunos_dev_priv_t *dpriv = usbi_get_device_priv(dev);
+    char              match_str[PATH_MAX];
+
+    /* Device descriptors */
+    proplen = di_prop_lookup_bytes(DDI_DEV_T_ANY, node, "usb-dev-descriptor", &rdata);
+    if(proplen <= 0) {
+        return (LIBUSB_ERROR_IO);
+    }
+    bcopy(rdata, &dev->device_descriptor, LIBUSB_DT_DEVICE_SIZE);
+
+    /* Raw configuration descriptors */
+    proplen = di_prop_lookup_bytes(DDI_DEV_T_ANY, node, "usb-raw-cfg-descriptors", &rdata);
+    if(proplen <= 0) {
+        usbi_dbg(DEVICE_CTX(dev), "can't find raw config descriptors");
+
+        return (LIBUSB_ERROR_IO);
+    }
+    dpriv->raw_cfgdescr = calloc(1, proplen);
+    if(dpriv->raw_cfgdescr == NULL) {
+        return (LIBUSB_ERROR_NO_MEM);
+    }
+    else {
+        bcopy(rdata, dpriv->raw_cfgdescr, proplen);
+        dpriv->cfgvalue = ((struct libusb_config_descriptor *)rdata)->bConfigurationValue;
+    }
+
+    n = di_prop_lookup_ints(DDI_DEV_T_ANY, node, "reg", &port_prop);
+
+    if((n != 1) || (*port_prop <= 0)) {
+        return (LIBUSB_ERROR_IO);
+    }
+    dev->port_number = *port_prop;
+
+    /* device physical path */
+    phypath = di_devfs_path(node);
+    if(phypath) {
+        dpriv->phypath = strdup(phypath);
+        snprintf(match_str, sizeof(match_str), "^usb/%x.%x", dev->device_descriptor.idVendor, dev->device_descriptor.idProduct);
+        usbi_dbg(DEVICE_CTX(dev), "match is %s", match_str);
+        sunos_physpath_to_devlink(dpriv->phypath, match_str, &dpriv->ugenpath);
+        di_devfs_path_free(phypath);
+    }
+    else {
+        free(dpriv->raw_cfgdescr);
+
+        return (LIBUSB_ERROR_IO);
+    }
+
+    /* address */
+    n = di_prop_lookup_ints(DDI_DEV_T_ANY, node, "assigned-address", &addr);
+    if(n != 1 || *addr == 0) {
+        usbi_dbg(DEVICE_CTX(dev), "can't get address");
+    }
+    else {
+        dev->device_address = *addr;
+    }
+
+    /* speed */
+    if(di_prop_lookup_ints(DDI_DEV_T_ANY, node, "low-speed", &i) >= 0) {
+        dev->speed = LIBUSB_SPEED_LOW;
+    }
+    else if(di_prop_lookup_ints(DDI_DEV_T_ANY, node, "high-speed", &i) >= 0) {
+        dev->speed = LIBUSB_SPEED_HIGH;
+    }
+    else if(di_prop_lookup_ints(DDI_DEV_T_ANY, node, "full-speed", &i) >= 0) {
+        dev->speed = LIBUSB_SPEED_FULL;
+    }
+    else if(di_prop_lookup_ints(DDI_DEV_T_ANY, node, "super-speed", &i) >= 0) {
+        dev->speed = LIBUSB_SPEED_SUPER;
+    }
+
+    usbi_dbg(DEVICE_CTX(dev), "vid=%x pid=%x, path=%s, bus_nmber=0x%x, port_number=%d, speed=%d", dev->device_descriptor.idVendor,
+             dev->device_descriptor.idProduct, dpriv->phypath, dev->bus_number, dev->port_number, dev->speed);
+
+    return (LIBUSB_SUCCESS);
+}
+
+static int sunos_add_devices(di_devlink_t link, void *arg) {
+    struct devlink_cbarg *largs = (struct devlink_cbarg *)arg;
+    struct node_args     *nargs;
+    di_node_t             myself, dn;
+    uint64_t              session_id = 0;
+    uint64_t              sid        = 0;
+    uint64_t              bdf        = 0;
+    struct libusb_device *dev;
+    sunos_dev_priv_t     *devpriv;
+    int                   n, *j;
+    int                   i = 0;
+    int                  *addr_prop;
+    uint8_t               bus_number = 0;
+    uint32_t             *regbuf     = NULL;
+    uint32_t              reg;
+
+    UNUSED(link);
+
+    nargs  = (struct node_args *)largs->nargs;
+    myself = largs->myself;
+
+    /*
+     * Construct session ID.
+     * session ID = dev_addr | hub addr |parent hub addr|...|root hub bdf
+     * 		8 bits       8bits          8 bits               16bits
+     */
+    if(myself == DI_NODE_NIL)
+        return (DI_WALK_CONTINUE);
+
+    dn = myself;
+    /* find the root hub */
+    while(di_prop_lookup_ints(DDI_DEV_T_ANY, dn, "root-hub", &j) != 0) {
+        usbi_dbg(NULL, "find_root_hub:%s", di_devfs_path(dn));
+        n = di_prop_lookup_ints(DDI_DEV_T_ANY, dn, "assigned-address", &addr_prop);
+        session_id |= ((addr_prop[0] & 0xff) << i++ * 8);
+        dn = di_parent_node(dn);
+    }
+
+    /* dn is the root hub node */
+    n   = di_prop_lookup_ints(DDI_DEV_T_ANY, dn, "reg", (int **)&regbuf);
+    reg = regbuf[0];
+    bdf = (PCI_REG_BUS_G(reg) << 8) | (PCI_REG_DEV_G(reg) << 3) | PCI_REG_FUNC_G(reg);
+    /* bdf must larger than i*8 bits */
+    session_id |= (bdf << i * 8);
+    bus_number = (PCI_REG_DEV_G(reg) << 3) | PCI_REG_FUNC_G(reg);
+
+    usbi_dbg(NULL, "device bus address=%s:%x, name:%s", di_bus_addr(myself), bus_number, di_node_name(dn));
+    usbi_dbg(NULL, "session id org:%" PRIx64, session_id);
+
+    /* dn is the usb device */
+    for(dn = di_child_node(myself); dn != DI_NODE_NIL; dn = di_sibling_node(dn)) {
+        usbi_dbg(NULL, "device path:%s", di_devfs_path(dn));
+        /* skip hub devices, because its driver can not been unload */
+        if(di_prop_lookup_ints(DDI_DEV_T_ANY, dn, "usb-port-count", &addr_prop) != -1)
+            continue;
+        /* usb_addr */
+        n = di_prop_lookup_ints(DDI_DEV_T_ANY, dn, "assigned-address", &addr_prop);
+        if((n != 1) || (addr_prop[0] == 0)) {
+            usbi_dbg(NULL, "cannot get valid usb_addr");
+            continue;
+        }
+
+        sid = (session_id << 8) | (addr_prop[0] & 0xff);
+        usbi_dbg(NULL, "session id %" PRIX64, sid);
+
+        dev = usbi_get_device_by_session_id(nargs->ctx, sid);
+        if(dev == NULL) {
+            dev = usbi_alloc_device(nargs->ctx, sid);
+            if(dev == NULL) {
+                usbi_dbg(NULL, "can't alloc device");
+                continue;
+            }
+            devpriv         = usbi_get_device_priv(dev);
+            dev->bus_number = bus_number;
+
+            if(sunos_fill_in_dev_info(dn, dev) != LIBUSB_SUCCESS) {
+                libusb_unref_device(dev);
+                usbi_dbg(NULL, "get information fail");
+                continue;
+            }
+            if(usbi_sanitize_device(dev) < 0) {
+                libusb_unref_device(dev);
+                usbi_dbg(NULL, "sanatize failed: ");
+                return (DI_WALK_TERMINATE);
+            }
+        }
+        else {
+            devpriv = usbi_get_device_priv(dev);
+            usbi_dbg(NULL, "Dev %s exists", devpriv->ugenpath);
+        }
+
+        if(discovered_devs_append(*(nargs->discdevs), dev) == NULL) {
+            usbi_dbg(NULL, "cannot append device");
+        }
+
+        /*
+         * we alloc and hence ref this dev. We don't need to ref it
+         * hereafter. Front end or app should take care of their ref.
+         */
+        libusb_unref_device(dev);
+
+        usbi_dbg(NULL, "Device %s %s id=0x%" PRIx64 ", devcount:%" PRIuPTR ", bdf=%" PRIx64, devpriv->ugenpath, di_devfs_path(dn), (uint64_t)sid,
+                 (*nargs->discdevs)->len, bdf);
+    }
+
+    return (DI_WALK_CONTINUE);
+}
+
+static int sunos_walk_minor_node_link(di_node_t node, void *args) {
+    di_minor_t           minor = DI_MINOR_NIL;
+    char                *minor_path;
+    struct devlink_cbarg arg;
+    struct node_args    *nargs       = (struct node_args *)args;
+    di_devlink_handle_t  devlink_hdl = nargs->dlink_hdl;
+
+    /* walk each minor to find usb devices */
+    while((minor = di_minor_next(node, minor)) != DI_MINOR_NIL) {
+        minor_path = di_devfs_minor_path(minor);
+        arg.nargs  = args;
+        arg.myself = node;
+        arg.minor  = minor;
+        (void)di_devlink_walk(devlink_hdl, "^usb/hub[0-9]+", minor_path, DI_PRIMARY_LINK, (void *)&arg, sunos_add_devices);
+        di_devfs_path_free(minor_path);
+    }
+
+    /* switch to a different node */
+    nargs->last_ugenpath = NULL;
+
+    return (DI_WALK_CONTINUE);
+}
+
+int sunos_get_device_list(struct libusb_context *ctx, struct discovered_devs **discdevs) {
+    di_node_t           root_node;
+    struct node_args    args;
+    di_devlink_handle_t devlink_hdl;
+
+    args.ctx           = ctx;
+    args.discdevs      = discdevs;
+    args.last_ugenpath = NULL;
+    if((root_node = di_init("/", DINFOCPYALL)) == DI_NODE_NIL) {
+        usbi_dbg(ctx, "di_int() failed: errno %d (%s)", errno, strerror(errno));
+        return (LIBUSB_ERROR_IO);
+    }
+
+    if((devlink_hdl = di_devlink_init(NULL, 0)) == NULL) {
+        di_fini(root_node);
+        usbi_dbg(ctx, "di_devlink_init() failed: errno %d (%s)", errno, strerror(errno));
+
+        return (LIBUSB_ERROR_IO);
+    }
+    args.dlink_hdl = devlink_hdl;
+
+    /* walk each node to find USB devices */
+    if(di_walk_node(root_node, DI_WALK_SIBFIRST, &args, sunos_walk_minor_node_link) == -1) {
+        usbi_dbg(ctx, "di_walk_node() failed: errno %d (%s)", errno, strerror(errno));
+        di_fini(root_node);
+
+        return (LIBUSB_ERROR_IO);
+    }
+
+    di_fini(root_node);
+    di_devlink_fini(&devlink_hdl);
+
+    usbi_dbg(ctx, "%zu devices", (*discdevs)->len);
+
+    return ((*discdevs)->len);
+}
+
+static int sunos_usb_open_ep0(sunos_dev_handle_priv_t *hpriv, sunos_dev_priv_t *dpriv) {
+    char filename[PATH_MAX + 1];
+
+    if(hpriv->eps[0].datafd > 0) {
+        return (LIBUSB_SUCCESS);
+    }
+    snprintf(filename, PATH_MAX, "%s/cntrl0", dpriv->ugenpath);
+
+    usbi_dbg(NULL, "opening %s", filename);
+    hpriv->eps[0].datafd = open(filename, O_RDWR);
+    if(hpriv->eps[0].datafd < 0) {
+        return (_errno_to_libusb(errno));
+    }
+
+    snprintf(filename, PATH_MAX, "%s/cntrl0stat", dpriv->ugenpath);
+    hpriv->eps[0].statfd = open(filename, O_RDONLY);
+    if(hpriv->eps[0].statfd < 0) {
+        close(hpriv->eps[0].datafd);
+        hpriv->eps[0].datafd = -1;
+
+        return (_errno_to_libusb(errno));
+    }
+
+    return (LIBUSB_SUCCESS);
+}
+
+static void sunos_usb_close_all_eps(sunos_dev_handle_priv_t *hdev) {
+    int i;
+
+    /* not close ep0 */
+    for(i = 1; i < USB_MAXENDPOINTS; i++) {
+        if(hdev->eps[i].datafd != -1) {
+            (void)close(hdev->eps[i].datafd);
+            hdev->eps[i].datafd = -1;
+        }
+        if(hdev->eps[i].statfd != -1) {
+            (void)close(hdev->eps[i].statfd);
+            hdev->eps[i].statfd = -1;
+        }
+    }
+}
+
+static void sunos_usb_close_ep0(sunos_dev_handle_priv_t *hdev) {
+    if(hdev->eps[0].datafd >= 0) {
+        close(hdev->eps[0].datafd);
+        close(hdev->eps[0].statfd);
+        hdev->eps[0].datafd = -1;
+        hdev->eps[0].statfd = -1;
+    }
+}
+
+static uchar_t sunos_usb_ep_index(uint8_t ep_addr) {
+    return ((ep_addr & LIBUSB_ENDPOINT_ADDRESS_MASK) + ((ep_addr & LIBUSB_ENDPOINT_DIR_MASK) ? 16 : 0));
+}
+
+static int sunos_find_interface(struct libusb_device_handle *hdev, uint8_t endpoint, uint8_t *interface) {
+    struct libusb_config_descriptor *config;
+    int                              r;
+    int                              iface_idx;
+
+    r = libusb_get_active_config_descriptor(hdev->dev, &config);
+    if(r < 0) {
+        return (LIBUSB_ERROR_INVALID_PARAM);
+    }
+
+    for(iface_idx = 0; iface_idx < config->bNumInterfaces; iface_idx++) {
+        const struct libusb_interface *iface = &config->interface[iface_idx];
+        int                            altsetting_idx;
+
+        for(altsetting_idx = 0; altsetting_idx < iface->num_altsetting; altsetting_idx++) {
+            const struct libusb_interface_descriptor *altsetting = &iface->altsetting[altsetting_idx];
+            int                                       ep_idx;
+
+            for(ep_idx = 0; ep_idx < altsetting->bNumEndpoints; ep_idx++) {
+                const struct libusb_endpoint_descriptor *ep = &altsetting->endpoint[ep_idx];
+                if(ep->bEndpointAddress == endpoint) {
+                    *interface = iface_idx;
+                    libusb_free_config_descriptor(config);
+
+                    return (LIBUSB_SUCCESS);
+                }
+            }
+        }
+    }
+    libusb_free_config_descriptor(config);
+
+    return (LIBUSB_ERROR_INVALID_PARAM);
+}
+
+static int sunos_check_device_and_status_open(struct libusb_device_handle *hdl, uint8_t ep_addr, int ep_type) {
+    char                     filename[PATH_MAX + 1], statfilename[PATH_MAX + 1];
+    char                     cfg_num[16], alt_num[16];
+    int                      fd, fdstat, mode;
+    uint8_t                  ifc = 0;
+    uint8_t                  ep_index;
+    sunos_dev_handle_priv_t *hpriv;
+
+    usbi_dbg(HANDLE_CTX(hdl), "open ep 0x%02x", ep_addr);
+    hpriv    = usbi_get_device_handle_priv(hdl);
+    ep_index = sunos_usb_ep_index(ep_addr);
+    /* ep already opened */
+    if((hpriv->eps[ep_index].datafd > 0) && (hpriv->eps[ep_index].statfd > 0)) {
+        usbi_dbg(HANDLE_CTX(hdl), "ep 0x%02x already opened, return success", ep_addr);
+
+        return (0);
+    }
+
+    if(sunos_find_interface(hdl, ep_addr, &ifc) < 0) {
+        usbi_dbg(HANDLE_CTX(hdl), "can't find interface for endpoint 0x%02x", ep_addr);
+
+        return (EACCES);
+    }
+
+    /* create filename */
+    if(hpriv->config_index > 0) {
+        (void)snprintf(cfg_num, sizeof(cfg_num), "cfg%d", hpriv->config_index + 1);
+    }
+    else {
+        bzero(cfg_num, sizeof(cfg_num));
+    }
+
+    if(hpriv->altsetting[ifc] > 0) {
+        (void)snprintf(alt_num, sizeof(alt_num), ".%d", hpriv->altsetting[ifc]);
+    }
+    else {
+        bzero(alt_num, sizeof(alt_num));
+    }
+
+    (void)snprintf(filename, PATH_MAX, "%s/%sif%d%s%s%d", hpriv->dpriv->ugenpath, cfg_num, ifc, alt_num, (ep_addr & LIBUSB_ENDPOINT_DIR_MASK) ? "in" : "out",
+                   (ep_addr & LIBUSB_ENDPOINT_ADDRESS_MASK));
+    (void)snprintf(statfilename, PATH_MAX, "%sstat", filename);
+
+    /*
+     * In case configuration has been switched, the xfer endpoint needs
+     * to be opened before the status endpoint, due to a ugen issue.
+     * However, to enable the one transfer mode for an Interrupt-In pipe,
+     * the status endpoint needs to be opened before the xfer endpoint.
+     * So, open the xfer mode first and close it immediately
+     * as a workaround. This will handle the configuration switch.
+     * Then, open the status endpoint.  If for an Interrupt-in pipe,
+     * write the USB_EP_INTR_ONE_XFER control to the status endpoint
+     * to enable the one transfer mode.  Then, re-open the xfer mode.
+     */
+    if(ep_type == LIBUSB_TRANSFER_TYPE_ISOCHRONOUS) {
+        mode = O_RDWR;
+    }
+    else if(ep_addr & LIBUSB_ENDPOINT_IN) {
+        mode = O_RDONLY;
+    }
+    else {
+        mode = O_WRONLY;
+    }
+    /* Open the xfer endpoint first */
+    if((fd = open(filename, mode)) == -1) {
+        usbi_dbg(HANDLE_CTX(hdl), "can't open %s: errno %d (%s)", filename, errno, strerror(errno));
+
+        return (errno);
+    }
+    /* And immediately close the xfer endpoint */
+    (void)close(fd);
+
+    /*
+     * Open the status endpoint.
+     * If for an Interrupt-IN pipe, need to enable the one transfer mode
+     * by writing USB_EP_INTR_ONE_XFER control to the status endpoint
+     * before opening the xfer endpoint
+     */
+    if((ep_type == LIBUSB_TRANSFER_TYPE_INTERRUPT) && (ep_addr & LIBUSB_ENDPOINT_IN)) {
+        char    control = USB_EP_INTR_ONE_XFER;
+        ssize_t count;
+
+        /* Open the status endpoint with RDWR */
+        if((fdstat = open(statfilename, O_RDWR)) == -1) {
+            usbi_dbg(HANDLE_CTX(hdl), "can't open %s RDWR: errno %d (%s)", statfilename, errno, strerror(errno));
+
+            return (errno);
+        }
+        else {
+            count = write(fdstat, &control, sizeof(control));
+            if(count != 1) {
+                /* this should have worked */
+                usbi_dbg(HANDLE_CTX(hdl), "can't write to %s: errno %d (%s)", statfilename, errno, strerror(errno));
+                (void)close(fdstat);
+
+                return (errno);
+            }
+        }
+    }
+    else {
+        if((fdstat = open(statfilename, O_RDONLY)) == -1) {
+            usbi_dbg(HANDLE_CTX(hdl), "can't open %s: errno %d (%s)", statfilename, errno, strerror(errno));
+
+            return (errno);
+        }
+    }
+
+    /* Re-open the xfer endpoint */
+    if((fd = open(filename, mode)) == -1) {
+        usbi_dbg(HANDLE_CTX(hdl), "can't open %s: errno %d (%s)", filename, errno, strerror(errno));
+        (void)close(fdstat);
+
+        return (errno);
+    }
+
+    hpriv->eps[ep_index].datafd = fd;
+    hpriv->eps[ep_index].statfd = fdstat;
+    usbi_dbg(HANDLE_CTX(hdl), "ep=0x%02x datafd=%d, statfd=%d", ep_addr, fd, fdstat);
+
+    return (0);
+}
+
+int sunos_open(struct libusb_device_handle *handle) {
+    sunos_dev_handle_priv_t *hpriv;
+    sunos_dev_priv_t        *dpriv;
+    int                      i;
+    int                      ret;
+
+    hpriv        = usbi_get_device_handle_priv(handle);
+    dpriv        = usbi_get_device_priv(handle->dev);
+    hpriv->dpriv = dpriv;
+
+    /* set all file descriptors to "closed" */
+    for(i = 0; i < USB_MAXENDPOINTS; i++) {
+        hpriv->eps[i].datafd = -1;
+        hpriv->eps[i].statfd = -1;
+    }
+
+    if(sunos_kernel_driver_active(handle, 0)) {
+        /* pretend we can open the device */
+        return (LIBUSB_SUCCESS);
+    }
+
+    if((ret = sunos_usb_open_ep0(hpriv, dpriv)) != LIBUSB_SUCCESS) {
+        usbi_dbg(HANDLE_CTX(handle), "fail: %d", ret);
+        return (ret);
+    }
+
+    return (LIBUSB_SUCCESS);
+}
+
+void sunos_close(struct libusb_device_handle *handle) {
+    sunos_dev_handle_priv_t *hpriv;
+
+    usbi_dbg(HANDLE_CTX(handle), " ");
+
+    hpriv = usbi_get_device_handle_priv(handle);
+
+    sunos_usb_close_all_eps(hpriv);
+    sunos_usb_close_ep0(hpriv);
+}
+
+int sunos_get_active_config_descriptor(struct libusb_device *dev, void *buf, size_t len) {
+    sunos_dev_priv_t                *dpriv = usbi_get_device_priv(dev);
+    struct libusb_config_descriptor *cfg;
+    int                              proplen;
+    di_node_t                        node;
+    uint8_t                         *rdata;
+
+    /*
+     * Keep raw configuration descriptors updated, in case config
+     * has ever been changed through setCfg.
+     */
+    if((node = di_init(dpriv->phypath, DINFOCPYALL)) == DI_NODE_NIL) {
+        usbi_dbg(DEVICE_CTX(dev), "di_int() failed: errno %d (%s)", errno, strerror(errno));
+        return (LIBUSB_ERROR_IO);
+    }
+    proplen = di_prop_lookup_bytes(DDI_DEV_T_ANY, node, "usb-raw-cfg-descriptors", &rdata);
+    if(proplen <= 0) {
+        usbi_dbg(DEVICE_CTX(dev), "can't find raw config descriptors");
+
+        return (LIBUSB_ERROR_IO);
+    }
+    dpriv->raw_cfgdescr = realloc(dpriv->raw_cfgdescr, proplen);
+    if(dpriv->raw_cfgdescr == NULL) {
+        return (LIBUSB_ERROR_NO_MEM);
+    }
+    else {
+        bcopy(rdata, dpriv->raw_cfgdescr, proplen);
+        dpriv->cfgvalue = ((struct libusb_config_descriptor *)rdata)->bConfigurationValue;
+    }
+    di_fini(node);
+
+    cfg = (struct libusb_config_descriptor *)dpriv->raw_cfgdescr;
+    len = MIN(len, libusb_le16_to_cpu(cfg->wTotalLength));
+    memcpy(buf, dpriv->raw_cfgdescr, len);
+    usbi_dbg(DEVICE_CTX(dev), "path:%s len %zu", dpriv->phypath, len);
+
+    return (len);
+}
+
+int sunos_get_config_descriptor(struct libusb_device *dev, uint8_t idx, void *buf, size_t len) {
+    UNUSED(idx);
+    /* XXX */
+    return (sunos_get_active_config_descriptor(dev, buf, len));
+}
+
+int sunos_get_configuration(struct libusb_device_handle *handle, uint8_t *config) {
+    sunos_dev_priv_t *dpriv = usbi_get_device_priv(handle->dev);
+
+    *config = dpriv->cfgvalue;
+
+    usbi_dbg(HANDLE_CTX(handle), "bConfigurationValue %u", *config);
+
+    return (LIBUSB_SUCCESS);
+}
+
+int sunos_set_configuration(struct libusb_device_handle *handle, int config) {
+    sunos_dev_priv_t        *dpriv = usbi_get_device_priv(handle->dev);
+    sunos_dev_handle_priv_t *hpriv;
+
+    usbi_dbg(HANDLE_CTX(handle), "bConfigurationValue %d", config);
+    hpriv = usbi_get_device_handle_priv(handle);
+
+    if(dpriv->ugenpath == NULL)
+        return (LIBUSB_ERROR_NOT_SUPPORTED);
+
+    if(config < 1)
+        return (LIBUSB_ERROR_NOT_SUPPORTED);
+
+    dpriv->cfgvalue     = config;
+    hpriv->config_index = config - 1;
+
+    return (LIBUSB_SUCCESS);
+}
+
+int sunos_claim_interface(struct libusb_device_handle *handle, uint8_t iface) {
+    UNUSED(handle);
+
+    usbi_dbg(HANDLE_CTX(handle), "iface %u", iface);
+
+    return (LIBUSB_SUCCESS);
+}
+
+int sunos_release_interface(struct libusb_device_handle *handle, uint8_t iface) {
+    sunos_dev_handle_priv_t *hpriv = usbi_get_device_handle_priv(handle);
+
+    usbi_dbg(HANDLE_CTX(handle), "iface %u", iface);
+
+    /* XXX: can we release it? */
+    hpriv->altsetting[iface] = 0;
+
+    return (LIBUSB_SUCCESS);
+}
+
+int sunos_set_interface_altsetting(struct libusb_device_handle *handle, uint8_t iface, uint8_t altsetting) {
+    sunos_dev_priv_t        *dpriv = usbi_get_device_priv(handle->dev);
+    sunos_dev_handle_priv_t *hpriv = usbi_get_device_handle_priv(handle);
+
+    usbi_dbg(HANDLE_CTX(handle), "iface %u, setting %u", iface, altsetting);
+
+    if(dpriv->ugenpath == NULL)
+        return (LIBUSB_ERROR_NOT_FOUND);
+
+    /* XXX: can we switch altsetting? */
+    hpriv->altsetting[iface] = altsetting;
+
+    return (LIBUSB_SUCCESS);
+}
+
+static void usb_dump_data(const void *data, size_t size) {
+    const uint8_t *p = data;
+    size_t         i;
+
+    if(getenv("LIBUSB_DEBUG") == NULL) {
+        return;
+    }
+
+    (void)fprintf(stderr, "data dump:");
+    for(i = 0; i < size; i++) {
+        if(i % 16 == 0) {
+            (void)fprintf(stderr, "\n%08zx	", i);
+        }
+        (void)fprintf(stderr, "%02x ", p[i]);
+    }
+    (void)fprintf(stderr, "\n");
+}
+
+static void sunos_async_callback(union sigval arg) {
+    struct sunos_transfer_priv *tpriv = (struct sunos_transfer_priv *)arg.sival_ptr;
+    struct libusb_transfer     *xfer  = tpriv->transfer;
+    struct aiocb               *aiocb = &tpriv->aiocb;
+    int                         ret;
+    sunos_dev_handle_priv_t    *hpriv;
+    uint8_t                     ep;
+    libusb_device_handle       *dev_handle;
+
+    dev_handle = xfer->dev_handle;
+
+    /* libusb can forcibly interrupt transfer in do_close() */
+    if(dev_handle != NULL) {
+        hpriv = usbi_get_device_handle_priv(dev_handle);
+        ep    = sunos_usb_ep_index(xfer->endpoint);
+
+        ret = aio_error(aiocb);
+        if(ret != 0) {
+            xfer->status = sunos_usb_get_status(TRANSFER_CTX(xfer), hpriv->eps[ep].statfd);
+        }
+        else {
+            xfer->actual_length = LIBUSB_TRANSFER_TO_USBI_TRANSFER(xfer)->transferred = aio_return(aiocb);
+        }
+
+        usb_dump_data(xfer->buffer, xfer->actual_length);
+
+        usbi_dbg(TRANSFER_CTX(xfer), "ret=%d, len=%d, actual_len=%d", ret, xfer->length, xfer->actual_length);
+
+        /* async notification */
+        usbi_signal_transfer_completion(LIBUSB_TRANSFER_TO_USBI_TRANSFER(xfer));
+    }
+}
+
+static int sunos_do_async_io(struct libusb_transfer *transfer) {
+    int                         ret = -1;
+    struct aiocb               *aiocb;
+    sunos_dev_handle_priv_t    *hpriv;
+    uint8_t                     ep;
+    struct sunos_transfer_priv *tpriv;
+
+    usbi_dbg(TRANSFER_CTX(transfer), " ");
+
+    tpriv = usbi_get_transfer_priv(LIBUSB_TRANSFER_TO_USBI_TRANSFER(transfer));
+    hpriv = usbi_get_device_handle_priv(transfer->dev_handle);
+    ep    = sunos_usb_ep_index(transfer->endpoint);
+
+    tpriv->transfer = transfer;
+    aiocb           = &tpriv->aiocb;
+    bzero(aiocb, sizeof(*aiocb));
+    aiocb->aio_fildes                         = hpriv->eps[ep].datafd;
+    aiocb->aio_buf                            = transfer->buffer;
+    aiocb->aio_nbytes                         = transfer->length;
+    aiocb->aio_lio_opcode                     = ((transfer->endpoint & LIBUSB_ENDPOINT_DIR_MASK) == LIBUSB_ENDPOINT_IN) ? LIO_READ : LIO_WRITE;
+    aiocb->aio_sigevent.sigev_notify          = SIGEV_THREAD;
+    aiocb->aio_sigevent.sigev_value.sival_ptr = tpriv;
+    aiocb->aio_sigevent.sigev_notify_function = sunos_async_callback;
+
+    if(aiocb->aio_lio_opcode == LIO_READ) {
+        ret = aio_read(aiocb);
+    }
+    else {
+        ret = aio_write(aiocb);
+    }
+
+    return (ret);
+}
+
+/* return the number of bytes read/written */
+static ssize_t usb_do_io(struct libusb_context *ctx, int fd, int stat_fd, void *data, size_t size, int flag, int *status) {
+    int     error;
+    ssize_t ret = -1;
+
+    usbi_dbg(ctx, "usb_do_io(): datafd=%d statfd=%d size=0x%zx flag=%s", fd, stat_fd, size, flag ? "WRITE" : "READ");
+
+    switch(flag) {
+    case READ:
+        errno = 0;
+        ret   = read(fd, data, size);
+        usb_dump_data(data, size);
+        break;
+    case WRITE:
+        usb_dump_data(data, size);
+        errno = 0;
+        ret   = write(fd, data, size);
+        break;
+    }
+
+    usbi_dbg(ctx, "usb_do_io(): amount=%zd", ret);
+
+    if(ret < 0) {
+        int save_errno = errno;
+
+        usbi_dbg(ctx, "TID=%x io %s errno %d (%s)", pthread_self(), flag ? "WRITE" : "READ", errno, strerror(errno));
+
+        /* sunos_usb_get_status will do a read and overwrite errno */
+        error = sunos_usb_get_status(ctx, stat_fd);
+        usbi_dbg(ctx, "io status=%d errno %d (%s)", error, save_errno, strerror(save_errno));
+
+        if(status) {
+            *status = save_errno;
+        }
+
+        return (save_errno);
+    }
+    else if(status) {
+        *status = 0;
+    }
+
+    return (ret);
+}
+
+static int solaris_submit_ctrl_on_default(struct libusb_transfer *transfer) {
+    ssize_t                      ret = -1, setup_ret;
+    int                          status;
+    sunos_dev_handle_priv_t     *hpriv;
+    struct libusb_device_handle *hdl = transfer->dev_handle;
+    uint16_t                     wLength;
+    uint8_t                     *data = transfer->buffer;
+
+    hpriv   = usbi_get_device_handle_priv(hdl);
+    wLength = transfer->length - LIBUSB_CONTROL_SETUP_SIZE;
+
+    if(hpriv->eps[0].datafd == -1) {
+        usbi_dbg(TRANSFER_CTX(transfer), "ep0 not opened");
+
+        return (LIBUSB_ERROR_NOT_FOUND);
+    }
+
+    if((data[0] & LIBUSB_ENDPOINT_DIR_MASK) == LIBUSB_ENDPOINT_IN) {
+        usbi_dbg(TRANSFER_CTX(transfer), "IN request");
+        ret = usb_do_io(TRANSFER_CTX(transfer), hpriv->eps[0].datafd, hpriv->eps[0].statfd, data, LIBUSB_CONTROL_SETUP_SIZE, WRITE, &status);
+    }
+    else {
+        usbi_dbg(TRANSFER_CTX(transfer), "OUT request");
+        ret =
+            usb_do_io(TRANSFER_CTX(transfer), hpriv->eps[0].datafd, hpriv->eps[0].statfd, transfer->buffer, transfer->length, WRITE, (int *)&transfer->status);
+    }
+
+    setup_ret = ret;
+    if(ret < (ssize_t)LIBUSB_CONTROL_SETUP_SIZE) {
+        usbi_dbg(TRANSFER_CTX(transfer), "error sending control msg: %zd", ret);
+
+        return (LIBUSB_ERROR_IO);
+    }
+
+    ret = transfer->length - LIBUSB_CONTROL_SETUP_SIZE;
+
+    /* Read the remaining bytes for IN request */
+    if((wLength) && ((data[0] & LIBUSB_ENDPOINT_DIR_MASK) == LIBUSB_ENDPOINT_IN)) {
+        usbi_dbg(TRANSFER_CTX(transfer), "DATA: %d", transfer->length - (int)setup_ret);
+        ret = usb_do_io(TRANSFER_CTX(transfer), hpriv->eps[0].datafd, hpriv->eps[0].statfd, transfer->buffer + LIBUSB_CONTROL_SETUP_SIZE, wLength, READ,
+                        (int *)&transfer->status);
+    }
+
+    if(ret >= 0) {
+        LIBUSB_TRANSFER_TO_USBI_TRANSFER(transfer)->transferred = ret;
+    }
+    usbi_dbg(TRANSFER_CTX(transfer), "Done: ctrl data bytes %zd", ret);
+
+    /**
+     * Sync transfer handling.
+     * We should release transfer lock here and later get it back
+     * as usbi_handle_transfer_completion() takes its own transfer lock.
+     */
+    usbi_mutex_unlock(&LIBUSB_TRANSFER_TO_USBI_TRANSFER(transfer)->lock);
+    ret = usbi_handle_transfer_completion(LIBUSB_TRANSFER_TO_USBI_TRANSFER(transfer), transfer->status);
+    usbi_mutex_lock(&LIBUSB_TRANSFER_TO_USBI_TRANSFER(transfer)->lock);
+
+    return (ret);
+}
+
+int sunos_clear_halt(struct libusb_device_handle *handle, unsigned char endpoint) {
+    int ret;
+
+    usbi_dbg(HANDLE_CTX(handle), "endpoint=0x%02x", endpoint);
+
+    ret = libusb_control_transfer(handle, LIBUSB_ENDPOINT_OUT | LIBUSB_RECIPIENT_ENDPOINT | LIBUSB_REQUEST_TYPE_STANDARD, LIBUSB_REQUEST_CLEAR_FEATURE, 0,
+                                  endpoint, NULL, 0, 1000);
+
+    usbi_dbg(HANDLE_CTX(handle), "ret=%d", ret);
+
+    return (ret);
+}
+
+void sunos_destroy_device(struct libusb_device *dev) {
+    sunos_dev_priv_t *dpriv = usbi_get_device_priv(dev);
+
+    usbi_dbg(DEVICE_CTX(dev), "destroy everything");
+    free(dpriv->raw_cfgdescr);
+    free(dpriv->ugenpath);
+    free(dpriv->phypath);
+}
+
+int sunos_submit_transfer(struct usbi_transfer *itransfer) {
+    struct libusb_transfer      *transfer;
+    struct libusb_device_handle *hdl;
+    int                          err = 0;
+
+    transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+    hdl      = transfer->dev_handle;
+
+    err = sunos_check_device_and_status_open(hdl, transfer->endpoint, transfer->type);
+    if(err < 0) {
+
+        return (_errno_to_libusb(err));
+    }
+
+    switch(transfer->type) {
+    case LIBUSB_TRANSFER_TYPE_CONTROL:
+        /* sync transfer */
+        usbi_dbg(ITRANSFER_CTX(itransfer), "CTRL transfer: %d", transfer->length);
+        err = solaris_submit_ctrl_on_default(transfer);
+        break;
+
+    case LIBUSB_TRANSFER_TYPE_BULK:
+        /* fallthru */
+    case LIBUSB_TRANSFER_TYPE_INTERRUPT:
+        if(transfer->type == LIBUSB_TRANSFER_TYPE_BULK)
+            usbi_dbg(ITRANSFER_CTX(itransfer), "BULK transfer: %d", transfer->length);
+        else
+            usbi_dbg(ITRANSFER_CTX(itransfer), "INTR transfer: %d", transfer->length);
+        err = sunos_do_async_io(transfer);
+        break;
+
+    case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
+        /* Isochronous/Stream is not supported */
+
+        /* fallthru */
+    case LIBUSB_TRANSFER_TYPE_BULK_STREAM:
+        if(transfer->type == LIBUSB_TRANSFER_TYPE_ISOCHRONOUS)
+            usbi_dbg(ITRANSFER_CTX(itransfer), "ISOC transfer: %d", transfer->length);
+        else
+            usbi_dbg(ITRANSFER_CTX(itransfer), "BULK STREAM transfer: %d", transfer->length);
+        err = LIBUSB_ERROR_NOT_SUPPORTED;
+        break;
+    }
+
+    return (err);
+}
+
+int sunos_cancel_transfer(struct usbi_transfer *itransfer) {
+    sunos_xfer_priv_t       *tpriv;
+    sunos_dev_handle_priv_t *hpriv;
+    struct libusb_transfer  *transfer;
+    struct aiocb            *aiocb;
+    uint8_t                  ep;
+    int                      ret;
+
+    tpriv    = usbi_get_transfer_priv(itransfer);
+    aiocb    = &tpriv->aiocb;
+    transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+    hpriv    = usbi_get_device_handle_priv(transfer->dev_handle);
+    ep       = sunos_usb_ep_index(transfer->endpoint);
+
+    ret = aio_cancel(hpriv->eps[ep].datafd, aiocb);
+
+    usbi_dbg(ITRANSFER_CTX(itransfer), "aio->fd=%d fd=%d ret = %d, %s", aiocb->aio_fildes, hpriv->eps[ep].datafd, ret,
+             (ret == AIO_CANCELED) ? strerror(0) : strerror(errno));
+
+    if(ret != AIO_CANCELED) {
+        ret = _errno_to_libusb(errno);
+    }
+    else {
+        /*
+         * we don't need to call usbi_handle_transfer_cancellation(),
+         * because we'll handle everything in sunos_async_callback.
+         */
+        ret = LIBUSB_SUCCESS;
+    }
+
+    return (ret);
+}
+
+int sunos_handle_transfer_completion(struct usbi_transfer *itransfer) {
+    return usbi_handle_transfer_completion(itransfer, LIBUSB_TRANSFER_COMPLETED);
+}
+
+int _errno_to_libusb(int err) {
+    usbi_dbg(NULL, "error: %s (%d)", strerror(err), err);
+
+    switch(err) {
+    case EIO:
+        return (LIBUSB_ERROR_IO);
+    case EACCES:
+        return (LIBUSB_ERROR_ACCESS);
+    case ENOENT:
+        return (LIBUSB_ERROR_NO_DEVICE);
+    case ENOMEM:
+        return (LIBUSB_ERROR_NO_MEM);
+    case ETIMEDOUT:
+        return (LIBUSB_ERROR_TIMEOUT);
+    }
+
+    return (LIBUSB_ERROR_OTHER);
+}
+
+/*
+ * sunos_usb_get_status:
+ *	gets status of endpoint
+ *
+ * Returns: ugen's last cmd status
+ */
+static int sunos_usb_get_status(struct libusb_context *ctx, int fd) {
+    int     status;
+    ssize_t ret;
+
+    usbi_dbg(ctx, "sunos_usb_get_status(): fd=%d", fd);
+
+    ret = read(fd, &status, sizeof(status));
+    if(ret == sizeof(status)) {
+        switch(status) {
+        case USB_LC_STAT_NOERROR:
+            usbi_dbg(ctx, "No Error");
+            break;
+        case USB_LC_STAT_CRC:
+            usbi_dbg(ctx, "CRC Timeout Detected\n");
+            break;
+        case USB_LC_STAT_BITSTUFFING:
+            usbi_dbg(ctx, "Bit Stuffing Violation\n");
+            break;
+        case USB_LC_STAT_DATA_TOGGLE_MM:
+            usbi_dbg(ctx, "Data Toggle Mismatch\n");
+            break;
+        case USB_LC_STAT_STALL:
+            usbi_dbg(ctx, "End Point Stalled\n");
+            break;
+        case USB_LC_STAT_DEV_NOT_RESP:
+            usbi_dbg(ctx, "Device is Not Responding\n");
+            break;
+        case USB_LC_STAT_PID_CHECKFAILURE:
+            usbi_dbg(ctx, "PID Check Failure\n");
+            break;
+        case USB_LC_STAT_UNEXP_PID:
+            usbi_dbg(ctx, "Unexpected PID\n");
+            break;
+        case USB_LC_STAT_DATA_OVERRUN:
+            usbi_dbg(ctx, "Data Exceeded Size\n");
+            break;
+        case USB_LC_STAT_DATA_UNDERRUN:
+            usbi_dbg(ctx, "Less data received\n");
+            break;
+        case USB_LC_STAT_BUFFER_OVERRUN:
+            usbi_dbg(ctx, "Buffer Size Exceeded\n");
+            break;
+        case USB_LC_STAT_BUFFER_UNDERRUN:
+            usbi_dbg(ctx, "Buffer Underrun\n");
+            break;
+        case USB_LC_STAT_TIMEOUT:
+            usbi_dbg(ctx, "Command Timed Out\n");
+            break;
+        case USB_LC_STAT_NOT_ACCESSED:
+            usbi_dbg(ctx, "Not Accessed by h/w\n");
+            break;
+        case USB_LC_STAT_UNSPECIFIED_ERR:
+            usbi_dbg(ctx, "Unspecified Error\n");
+            break;
+        case USB_LC_STAT_NO_BANDWIDTH:
+            usbi_dbg(ctx, "No Bandwidth\n");
+            break;
+        case USB_LC_STAT_HW_ERR:
+            usbi_dbg(ctx, "Host Controller h/w Error\n");
+            break;
+        case USB_LC_STAT_SUSPENDED:
+            usbi_dbg(ctx, "Device was Suspended\n");
+            break;
+        case USB_LC_STAT_DISCONNECTED:
+            usbi_dbg(ctx, "Device was Disconnected\n");
+            break;
+        case USB_LC_STAT_INTR_BUF_FULL:
+            usbi_dbg(ctx, "Interrupt buffer was full\n");
+            break;
+        case USB_LC_STAT_INVALID_REQ:
+            usbi_dbg(ctx, "Request was Invalid\n");
+            break;
+        case USB_LC_STAT_INTERRUPTED:
+            usbi_dbg(ctx, "Request was Interrupted\n");
+            break;
+        case USB_LC_STAT_NO_RESOURCES:
+            usbi_dbg(ctx, "No resources available for "
+                          "request\n");
+            break;
+        case USB_LC_STAT_INTR_POLLING_FAILED:
+            usbi_dbg(ctx, "Failed to Restart Poll");
+            break;
+        default:
+            usbi_dbg(ctx, "Error Not Determined %d\n", status);
+            break;
+        }
+    }
+    else {
+        usbi_dbg(ctx, "read stat error: %s", strerror(errno));
+        status = -1;
+    }
+
+    return (status);
+}
+
+const struct usbi_os_backend usbi_backend = {
+    .name                         = "Solaris",
+    .caps                         = 0,
+    .get_device_list              = sunos_get_device_list,
+    .get_active_config_descriptor = sunos_get_active_config_descriptor,
+    .get_config_descriptor        = sunos_get_config_descriptor,
+    .open                         = sunos_open,
+    .close                        = sunos_close,
+    .get_configuration            = sunos_get_configuration,
+    .set_configuration            = sunos_set_configuration,
+    .claim_interface              = sunos_claim_interface,
+    .release_interface            = sunos_release_interface,
+    .set_interface_altsetting     = sunos_set_interface_altsetting,
+    .clear_halt                   = sunos_clear_halt,
+    .kernel_driver_active         = sunos_kernel_driver_active,
+    .detach_kernel_driver         = sunos_detach_kernel_driver,
+    .attach_kernel_driver         = sunos_attach_kernel_driver,
+    .destroy_device               = sunos_destroy_device,
+    .submit_transfer              = sunos_submit_transfer,
+    .cancel_transfer              = sunos_cancel_transfer,
+    .handle_transfer_completion   = sunos_handle_transfer_completion,
+    .device_priv_size             = sizeof(sunos_dev_priv_t),
+    .device_handle_priv_size      = sizeof(sunos_dev_handle_priv_t),
+    .transfer_priv_size           = sizeof(sunos_xfer_priv_t),
+};
diff --git a/3rdparty/libusb/src/libusb/os/sunos_usb.h b/3rdparty/libusb/src/libusb/os/sunos_usb.h
new file mode 100644
index 00000000..2988398d
--- /dev/null
+++ b/3rdparty/libusb/src/libusb/os/sunos_usb.h
@@ -0,0 +1,79 @@
+/*
+ *
+ * Copyright (c) 2016, Oracle and/or its affiliates.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef	LIBUSB_SUNOS_H
+#define	LIBUSB_SUNOS_H
+
+#include <libdevinfo.h>
+#include <pthread.h>
+#include "libusbi.h"
+
+#define	READ	0
+#define	WRITE	1
+
+typedef struct sunos_device_priv {
+	uint8_t	cfgvalue;		/* active config value */
+	uint8_t	*raw_cfgdescr;		/* active config descriptor */
+	char	*ugenpath;		/* name of the ugen(4) node */
+	char	*phypath;		/* physical path */
+} sunos_dev_priv_t;
+
+typedef	struct endpoint {
+	int datafd;	/* data file */
+	int statfd;	/* state file */
+} sunos_ep_priv_t;
+
+typedef struct sunos_device_handle_priv {
+	uint8_t			altsetting[USB_MAXINTERFACES];	/* a interface's alt */
+	uint8_t			config_index;
+	sunos_ep_priv_t		eps[USB_MAXENDPOINTS];
+	sunos_dev_priv_t	*dpriv; /* device private */
+} sunos_dev_handle_priv_t;
+
+typedef	struct sunos_transfer_priv {
+	struct aiocb		aiocb;
+	struct libusb_transfer	*transfer;
+} sunos_xfer_priv_t;
+
+struct node_args {
+	struct libusb_context	*ctx;
+	struct discovered_devs	**discdevs;
+	const char		*last_ugenpath;
+	di_devlink_handle_t	dlink_hdl;
+};
+
+struct devlink_cbarg {
+	struct node_args	*nargs;	/* di node walk arguments */
+	di_node_t		myself;	/* the di node */
+	di_minor_t		minor;
+};
+
+typedef struct walk_link {
+	char *path;
+	int len;
+	char **linkpp;
+} walk_link_t;
+
+/* AIO callback args */
+struct aio_callback_args{
+	struct libusb_transfer *transfer;
+	struct aiocb aiocb;
+};
+
+#endif /* LIBUSB_SUNOS_H */
diff --git a/3rdparty/libusb/src/libusb/os/threads_posix.c b/3rdparty/libusb/src/libusb/os/threads_posix.c
new file mode 100644
index 00000000..ae9e16c0
--- /dev/null
+++ b/3rdparty/libusb/src/libusb/os/threads_posix.c
@@ -0,0 +1,121 @@
+/*
+ * libusb synchronization using POSIX Threads
+ *
+ * Copyright © 2011 Vitali Lovich <vlovich@aliph.com>
+ * Copyright © 2011 Peter Stuge <peter@stuge.se>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "libusbi.h"
+
+#include <errno.h>
+#if defined(__ANDROID__)
+#include <unistd.h>
+#elif defined(__HAIKU__)
+#include <os/kernel/OS.h>
+#elif defined(__linux__)
+#include <sys/syscall.h>
+#include <unistd.h>
+#elif defined(__NetBSD__)
+#include <lwp.h>
+#elif defined(__OpenBSD__)
+#include <unistd.h>
+#elif defined(__sun__)
+#include <sys/lwp.h>
+#endif
+
+void usbi_cond_init(pthread_cond_t *cond) {
+#ifdef HAVE_PTHREAD_CONDATTR_SETCLOCK
+    pthread_condattr_t condattr;
+
+    PTHREAD_CHECK(pthread_condattr_init(&condattr));
+    PTHREAD_CHECK(pthread_condattr_setclock(&condattr, CLOCK_MONOTONIC));
+    PTHREAD_CHECK(pthread_cond_init(cond, &condattr));
+    PTHREAD_CHECK(pthread_condattr_destroy(&condattr));
+#else
+    PTHREAD_CHECK(pthread_cond_init(cond, NULL));
+#endif
+}
+
+int usbi_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex, const struct timeval *tv) {
+    struct timespec timeout;
+    int             r;
+
+#ifdef HAVE_PTHREAD_CONDATTR_SETCLOCK
+    usbi_get_monotonic_time(&timeout);
+#else
+    usbi_get_real_time(&timeout);
+#endif
+
+    timeout.tv_sec += tv->tv_sec;
+    timeout.tv_nsec += tv->tv_usec * 1000L;
+    if(timeout.tv_nsec >= NSEC_PER_SEC) {
+        timeout.tv_nsec -= NSEC_PER_SEC;
+        timeout.tv_sec++;
+    }
+
+    r = pthread_cond_timedwait(cond, mutex, &timeout);
+    if(r == 0)
+        return 0;
+    else if(r == ETIMEDOUT)
+        return LIBUSB_ERROR_TIMEOUT;
+    else
+        return LIBUSB_ERROR_OTHER;
+}
+
+unsigned int usbi_get_tid(void) {
+    static _Thread_local unsigned int tl_tid;
+    int                               tid;
+
+    if(tl_tid)
+        return tl_tid;
+
+#if defined(__ANDROID__)
+    tid = gettid();
+#elif defined(__APPLE__)
+#ifdef HAVE_PTHREAD_THREADID_NP
+    uint64_t thread_id;
+
+    if(pthread_threadid_np(NULL, &thread_id) == 0)
+        tid = (int)thread_id;
+    else
+        tid = -1;
+#else
+    tid = (int)pthread_mach_thread_np(pthread_self());
+#endif
+#elif defined(__HAIKU__)
+    tid = get_pthread_thread_id(pthread_self());
+#elif defined(__linux__)
+    tid = (int)syscall(SYS_gettid);
+#elif defined(__NetBSD__)
+    tid = _lwp_self();
+#elif defined(__OpenBSD__)
+    tid = getthrid();
+#elif defined(__sun__)
+    tid = _lwp_self();
+#else
+    tid = -1;
+#endif
+
+    if(tid == -1) {
+        /* If we don't have a thread ID, at least return a unique
+         * value that can be used to distinguish individual
+         * threads. */
+        tid = (int)(intptr_t)pthread_self();
+    }
+
+    return tl_tid = (unsigned int)tid;
+}
diff --git a/3rdparty/libusb/src/libusb/os/threads_posix.h b/3rdparty/libusb/src/libusb/os/threads_posix.h
new file mode 100644
index 00000000..53a3ac13
--- /dev/null
+++ b/3rdparty/libusb/src/libusb/os/threads_posix.h
@@ -0,0 +1,83 @@
+/*
+ * libusb synchronization using POSIX Threads
+ *
+ * Copyright © 2010 Peter Stuge <peter@stuge.se>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef LIBUSB_THREADS_POSIX_H
+#define LIBUSB_THREADS_POSIX_H
+
+#include <pthread.h>
+
+#define PTHREAD_CHECK(expression) ASSERT_EQ(expression, 0)
+
+#define USBI_MUTEX_INITIALIZER PTHREAD_MUTEX_INITIALIZER
+typedef pthread_mutex_t usbi_mutex_static_t;
+static inline void      usbi_mutex_static_lock(usbi_mutex_static_t *mutex) {
+    PTHREAD_CHECK(pthread_mutex_lock(mutex));
+}
+static inline void usbi_mutex_static_unlock(usbi_mutex_static_t *mutex) {
+    PTHREAD_CHECK(pthread_mutex_unlock(mutex));
+}
+
+typedef pthread_mutex_t usbi_mutex_t;
+static inline void      usbi_mutex_init(usbi_mutex_t *mutex) {
+    PTHREAD_CHECK(pthread_mutex_init(mutex, NULL));
+}
+static inline void usbi_mutex_lock(usbi_mutex_t *mutex) {
+    PTHREAD_CHECK(pthread_mutex_lock(mutex));
+}
+static inline void usbi_mutex_unlock(usbi_mutex_t *mutex) {
+    PTHREAD_CHECK(pthread_mutex_unlock(mutex));
+}
+static inline int usbi_mutex_trylock(usbi_mutex_t *mutex) {
+    return pthread_mutex_trylock(mutex) == 0;
+}
+static inline void usbi_mutex_destroy(usbi_mutex_t *mutex) {
+    PTHREAD_CHECK(pthread_mutex_destroy(mutex));
+}
+
+typedef pthread_cond_t usbi_cond_t;
+void                   usbi_cond_init(pthread_cond_t *cond);
+static inline void     usbi_cond_wait(usbi_cond_t *cond, usbi_mutex_t *mutex) {
+    PTHREAD_CHECK(pthread_cond_wait(cond, mutex));
+}
+int                usbi_cond_timedwait(usbi_cond_t *cond, usbi_mutex_t *mutex, const struct timeval *tv);
+static inline void usbi_cond_broadcast(usbi_cond_t *cond) {
+    PTHREAD_CHECK(pthread_cond_broadcast(cond));
+}
+static inline void usbi_cond_destroy(usbi_cond_t *cond) {
+    PTHREAD_CHECK(pthread_cond_destroy(cond));
+}
+
+typedef pthread_key_t usbi_tls_key_t;
+static inline void    usbi_tls_key_create(usbi_tls_key_t *key) {
+    PTHREAD_CHECK(pthread_key_create(key, NULL));
+}
+static inline void *usbi_tls_key_get(usbi_tls_key_t key) {
+    return pthread_getspecific(key);
+}
+static inline void usbi_tls_key_set(usbi_tls_key_t key, void *ptr) {
+    PTHREAD_CHECK(pthread_setspecific(key, ptr));
+}
+static inline void usbi_tls_key_delete(usbi_tls_key_t key) {
+    PTHREAD_CHECK(pthread_key_delete(key));
+}
+
+unsigned int usbi_get_tid(void);
+
+#endif /* LIBUSB_THREADS_POSIX_H */
diff --git a/3rdparty/libusb/src/libusb/os/threads_windows.c b/3rdparty/libusb/src/libusb/os/threads_windows.c
new file mode 100644
index 00000000..4a57f42e
--- /dev/null
+++ b/3rdparty/libusb/src/libusb/os/threads_windows.c
@@ -0,0 +1,40 @@
+/*
+ * libusb synchronization on Microsoft Windows
+ *
+ * Copyright © 2010 Michael Plante <michael.plante@gmail.com>
+ * Copyright © 2020 Chris Dickens <christopher.a.dickens@gmail.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "libusbi.h"
+
+int usbi_cond_timedwait(usbi_cond_t *cond,
+	usbi_mutex_t *mutex, const struct timeval *tv)
+{
+	DWORD millis;
+
+	millis = (DWORD)(tv->tv_sec * 1000L) + (tv->tv_usec / 1000L);
+	/* round up to next millisecond */
+	if (tv->tv_usec % 1000L)
+		millis++;
+
+	if (SleepConditionVariableCS(cond, mutex, millis))
+		return 0;
+	else if (GetLastError() == ERROR_TIMEOUT)
+		return LIBUSB_ERROR_TIMEOUT;
+	else
+		return LIBUSB_ERROR_OTHER;
+}
diff --git a/3rdparty/libusb/src/libusb/os/threads_windows.h b/3rdparty/libusb/src/libusb/os/threads_windows.h
new file mode 100644
index 00000000..dfef1588
--- /dev/null
+++ b/3rdparty/libusb/src/libusb/os/threads_windows.h
@@ -0,0 +1,113 @@
+/*
+ * libusb synchronization on Microsoft Windows
+ *
+ * Copyright © 2010 Michael Plante <michael.plante@gmail.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef LIBUSB_THREADS_WINDOWS_H
+#define LIBUSB_THREADS_WINDOWS_H
+
+#define WINAPI_CHECK(expression)	ASSERT_NE(expression, 0)
+
+#define USBI_MUTEX_INITIALIZER	0L
+typedef LONG usbi_mutex_static_t;
+static inline void usbi_mutex_static_lock(usbi_mutex_static_t *mutex)
+{
+	while (InterlockedExchange(mutex, 1L) == 1L)
+		SleepEx(0, TRUE);
+}
+static inline void usbi_mutex_static_unlock(usbi_mutex_static_t *mutex)
+{
+	InterlockedExchange(mutex, 0L);
+}
+
+typedef CRITICAL_SECTION usbi_mutex_t;
+static inline void usbi_mutex_init(usbi_mutex_t *mutex)
+{
+	InitializeCriticalSection(mutex);
+}
+static inline void usbi_mutex_lock(usbi_mutex_t *mutex)
+{
+	EnterCriticalSection(mutex);
+}
+static inline void usbi_mutex_unlock(usbi_mutex_t *mutex)
+{
+	LeaveCriticalSection(mutex);
+}
+static inline int usbi_mutex_trylock(usbi_mutex_t *mutex)
+{
+	return TryEnterCriticalSection(mutex) != 0;
+}
+static inline void usbi_mutex_destroy(usbi_mutex_t *mutex)
+{
+	DeleteCriticalSection(mutex);
+}
+
+#if !defined(HAVE_STRUCT_TIMESPEC) && !defined(_TIMESPEC_DEFINED)
+#define HAVE_STRUCT_TIMESPEC 1
+#define _TIMESPEC_DEFINED 1
+struct timespec {
+	long tv_sec;
+	long tv_nsec;
+};
+#endif /* HAVE_STRUCT_TIMESPEC || _TIMESPEC_DEFINED */
+
+typedef CONDITION_VARIABLE usbi_cond_t;
+static inline void usbi_cond_init(usbi_cond_t *cond)
+{
+	InitializeConditionVariable(cond);
+}
+static inline void usbi_cond_wait(usbi_cond_t *cond, usbi_mutex_t *mutex)
+{
+	WINAPI_CHECK(SleepConditionVariableCS(cond, mutex, INFINITE));
+}
+int usbi_cond_timedwait(usbi_cond_t *cond,
+	usbi_mutex_t *mutex, const struct timeval *tv);
+static inline void usbi_cond_broadcast(usbi_cond_t *cond)
+{
+	WakeAllConditionVariable(cond);
+}
+static inline void usbi_cond_destroy(usbi_cond_t *cond)
+{
+	UNUSED(cond);
+}
+
+typedef DWORD usbi_tls_key_t;
+static inline void usbi_tls_key_create(usbi_tls_key_t *key)
+{
+	*key = TlsAlloc();
+	assert(*key != TLS_OUT_OF_INDEXES);
+}
+static inline void *usbi_tls_key_get(usbi_tls_key_t key)
+{
+	return TlsGetValue(key);
+}
+static inline void usbi_tls_key_set(usbi_tls_key_t key, void *ptr)
+{
+	WINAPI_CHECK(TlsSetValue(key, ptr));
+}
+static inline void usbi_tls_key_delete(usbi_tls_key_t key)
+{
+	WINAPI_CHECK(TlsFree(key));
+}
+
+static inline unsigned int usbi_get_tid(void)
+{
+	return (unsigned int)GetCurrentThreadId();
+}
+
+#endif /* LIBUSB_THREADS_WINDOWS_H */
diff --git a/3rdparty/libusb/src/libusb/os/windows_common.c b/3rdparty/libusb/src/libusb/os/windows_common.c
new file mode 100644
index 00000000..8ab3bc60
--- /dev/null
+++ b/3rdparty/libusb/src/libusb/os/windows_common.c
@@ -0,0 +1,912 @@
+/*
+ * windows backend for libusb 1.0
+ * Copyright © 2009-2012 Pete Batard <pete@akeo.ie>
+ * With contributions from Michael Plante, Orin Eman et al.
+ * Parts of this code adapted from libusb-win32-v1 by Stephan Meyer
+ * HID Reports IOCTLs inspired from HIDAPI by Alan Ott, Signal 11 Software
+ * Hash table functions adapted from glibc, by Ulrich Drepper et al.
+ * Major code testing contribution by Xiaofan Chen
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <libusb/config.h>
+
+#include <stdio.h>
+
+#include "libusbi.h"
+#include "windows_common.h"
+
+#define EPOCH_TIME UINT64_C(116444736000000000)  // 1970.01.01 00:00:000 in MS Filetime
+
+#define STATUS_SUCCESS ((ULONG_PTR)0UL)
+
+// Public
+enum windows_version windows_version = WINDOWS_UNDEFINED;
+
+// Global variables for init/exit
+static unsigned int init_count;
+static bool         usbdk_available;
+
+/*
+ * Converts a windows error to human readable string
+ * uses retval as errorcode, or, if 0, use GetLastError()
+ */
+#if defined(ENABLE_LOGGING)
+const char *windows_error_str(DWORD error_code) {
+    static char err_string[256];
+
+    DWORD size;
+    int   len;
+
+    if(error_code == 0)
+        error_code = GetLastError();
+
+    len = sprintf(err_string, "[%lu] ", ULONG_CAST(error_code));
+
+    // Translate codes returned by SetupAPI. The ones we are dealing with are either
+    // in 0x0000xxxx or 0xE000xxxx and can be distinguished from standard error codes.
+    // See http://msdn.microsoft.com/en-us/library/windows/hardware/ff545011.aspx
+    switch(error_code & 0xE0000000) {
+    case 0:
+        error_code = HRESULT_FROM_WIN32(error_code);  // Still leaves ERROR_SUCCESS unmodified
+        break;
+    case 0xE0000000:
+        error_code = 0x80000000 | (FACILITY_SETUPAPI << 16) | (error_code & 0x0000FFFF);
+        break;
+    default:
+        break;
+    }
+
+    size = FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, error_code, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+                          &err_string[len], sizeof(err_string) - len, NULL);
+    if(size == 0) {
+        DWORD format_error = GetLastError();
+        if(format_error)
+            snprintf(err_string, sizeof(err_string), "Windows error code %lu (FormatMessage error code %lu)", ULONG_CAST(error_code), ULONG_CAST(format_error));
+        else
+            snprintf(err_string, sizeof(err_string), "Unknown error code %lu", ULONG_CAST(error_code));
+    }
+    else {
+        // Remove CRLF from end of message, if present
+        size_t pos = len + size - 2;
+        if(err_string[pos] == '\r')
+            err_string[pos] = '\0';
+    }
+
+    return err_string;
+}
+#endif
+
+/*
+ * Dynamically loads a DLL from the Windows system directory.  Unlike the
+ * LoadLibraryA() function, this function will not search through any
+ * directories to try and find the library.
+ */
+HMODULE load_system_library(struct libusb_context *ctx, const char *name) {
+    char  library_path[MAX_PATH];
+    char *filename_start;
+    UINT  length;
+
+    length = GetSystemDirectoryA(library_path, sizeof(library_path));
+    if((length == 0) || (length >= (UINT)sizeof(library_path))) {
+        usbi_err(ctx, "program assertion failed - could not get system directory");
+        return NULL;
+    }
+
+    filename_start = library_path + length;
+    // Append '\' + name + ".dll" + NUL
+    length += 1 + (UINT)strlen(name) + 4 + 1;
+    if(length >= (UINT)sizeof(library_path)) {
+        usbi_err(ctx, "program assertion failed - library path buffer overflow");
+        return NULL;
+    }
+
+    sprintf(filename_start, "\\%s.dll", name);
+    return LoadLibraryA(library_path);
+}
+
+/* Hash table functions - modified From glibc 2.3.2:
+   [Aho,Sethi,Ullman] Compilers: Principles, Techniques and Tools, 1986
+   [Knuth]            The Art of Computer Programming, part 3 (6.4)  */
+
+#define HTAB_SIZE 1021UL  // *MUST* be a prime number!!
+
+typedef struct htab_entry {
+    unsigned long used;
+    char         *str;
+} htab_entry;
+
+static htab_entry   *htab_table;
+static usbi_mutex_t  htab_mutex;
+static unsigned long htab_filled;
+
+/* Before using the hash table we must allocate memory for it.
+   We allocate one element more as the found prime number says.
+   This is done for more effective indexing as explained in the
+   comment for the hash function.  */
+static bool htab_create(struct libusb_context *ctx) {
+    if(htab_table != NULL) {
+        usbi_err(ctx, "program assertion failed - hash table already allocated");
+        return true;
+    }
+
+    // Create a mutex
+    usbi_mutex_init(&htab_mutex);
+
+    usbi_dbg(ctx, "using %lu entries hash table", HTAB_SIZE);
+    htab_filled = 0;
+
+    // allocate memory and zero out.
+    htab_table = calloc(HTAB_SIZE + 1, sizeof(htab_entry));
+    if(htab_table == NULL) {
+        usbi_err(ctx, "could not allocate space for hash table");
+        return false;
+    }
+
+    return true;
+}
+
+/* After using the hash table it has to be destroyed.  */
+static void htab_destroy(void) {
+    unsigned long i;
+
+    if(htab_table == NULL)
+        return;
+
+    for(i = 0; i < HTAB_SIZE; i++)
+        free(htab_table[i].str);
+
+    safe_free(htab_table);
+
+    usbi_mutex_destroy(&htab_mutex);
+}
+
+/* This is the search function. It uses double hashing with open addressing.
+   We use a trick to speed up the lookup. The table is created with one
+   more element available. This enables us to use the index zero special.
+   This index will never be used because we store the first hash index in
+   the field used where zero means not used. Every other value means used.
+   The used field can be used as a first fast comparison for equality of
+   the stored and the parameter value. This helps to prevent unnecessary
+   expensive calls of strcmp.  */
+unsigned long htab_hash(const char *str) {
+    unsigned long hval, hval2;
+    unsigned long idx;
+    unsigned long r = 5381UL;
+    int           c;
+    const char   *sz = str;
+
+    if(str == NULL)
+        return 0;
+
+    // Compute main hash value (algorithm suggested by Nokia)
+    while((c = *sz++) != 0)
+        r = ((r << 5) + r) + c;
+    if(r == 0)
+        ++r;
+
+    // compute table hash: simply take the modulus
+    hval = r % HTAB_SIZE;
+    if(hval == 0)
+        ++hval;
+
+    // Try the first index
+    idx = hval;
+
+    // Mutually exclusive access (R/W lock would be better)
+    usbi_mutex_lock(&htab_mutex);
+
+    if(htab_table[idx].used) {
+        if((htab_table[idx].used == hval) && (strcmp(str, htab_table[idx].str) == 0))
+            goto out_unlock;  // existing hash
+
+        usbi_dbg(NULL, "hash collision ('%s' vs '%s')", str, htab_table[idx].str);
+
+        // Second hash function, as suggested in [Knuth]
+        hval2 = 1UL + hval % (HTAB_SIZE - 2);
+
+        do {
+            // Because size is prime this guarantees to step through all available indexes
+            if(idx <= hval2)
+                idx = HTAB_SIZE + idx - hval2;
+            else
+                idx -= hval2;
+
+            // If we visited all entries leave the loop unsuccessfully
+            if(idx == hval)
+                break;
+
+            // If entry is found use it.
+            if((htab_table[idx].used == hval) && (strcmp(str, htab_table[idx].str) == 0))
+                goto out_unlock;
+        } while(htab_table[idx].used);
+    }
+
+    // Not found => New entry
+
+    // If the table is full return an error
+    if(htab_filled >= HTAB_SIZE) {
+        usbi_err(NULL, "hash table is full (%lu entries)", HTAB_SIZE);
+        idx = 0UL;
+        goto out_unlock;
+    }
+
+    htab_table[idx].str = _strdup(str);
+    if(htab_table[idx].str == NULL) {
+        usbi_err(NULL, "could not duplicate string for hash table");
+        idx = 0UL;
+        goto out_unlock;
+    }
+
+    htab_table[idx].used = hval;
+    ++htab_filled;
+
+out_unlock:
+    usbi_mutex_unlock(&htab_mutex);
+
+    return idx;
+}
+
+enum libusb_transfer_status usbd_status_to_libusb_transfer_status(USBD_STATUS status) {
+    if(USBD_SUCCESS(status))
+        return LIBUSB_TRANSFER_COMPLETED;
+
+    switch(status) {
+    case USBD_STATUS_TIMEOUT:
+        return LIBUSB_TRANSFER_TIMED_OUT;
+    case USBD_STATUS_CANCELED:
+        return LIBUSB_TRANSFER_CANCELLED;
+    case USBD_STATUS_ENDPOINT_HALTED:
+    case USBD_STATUS_STALL_PID:
+        return LIBUSB_TRANSFER_STALL;
+    case USBD_STATUS_DEVICE_GONE:
+        return LIBUSB_TRANSFER_NO_DEVICE;
+    default:
+        usbi_dbg(NULL, "USBD_STATUS 0x%08lx translated to LIBUSB_TRANSFER_ERROR", ULONG_CAST(status));
+        return LIBUSB_TRANSFER_ERROR;
+    }
+}
+
+/*
+ * Make a transfer complete synchronously
+ */
+void windows_force_sync_completion(struct usbi_transfer *itransfer, ULONG size) {
+    struct libusb_transfer       *transfer      = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+    struct windows_context_priv  *priv          = usbi_get_context_priv(TRANSFER_CTX(transfer));
+    struct windows_transfer_priv *transfer_priv = usbi_get_transfer_priv(itransfer);
+    OVERLAPPED                   *overlapped    = &transfer_priv->overlapped;
+
+    usbi_dbg(TRANSFER_CTX(transfer), "transfer %p, length %lu", transfer, ULONG_CAST(size));
+
+    overlapped->Internal     = (ULONG_PTR)STATUS_SUCCESS;
+    overlapped->InternalHigh = (ULONG_PTR)size;
+
+    if(!PostQueuedCompletionStatus(priv->completion_port, (DWORD)size, (ULONG_PTR)transfer->dev_handle, overlapped))
+        usbi_err(TRANSFER_CTX(transfer), "failed to post I/O completion: %s", windows_error_str(0));
+}
+
+/* Windows version detection */
+static BOOL is_x64(void) {
+    BOOL ret = FALSE;
+
+    // Detect if we're running a 32 or 64 bit system
+    if(sizeof(uintptr_t) < 8) {
+        IsWow64Process(GetCurrentProcess(), &ret);
+    }
+    else {
+        ret = TRUE;
+    }
+
+    return ret;
+}
+
+static enum windows_version get_windows_version(void) {
+    enum windows_version winver;
+    OSVERSIONINFOEXA     vi, vi2;
+    unsigned             major, minor, version;
+    ULONGLONG            major_equal, minor_equal;
+    const char          *w, *arch;
+    bool                 ws;
+
+#ifndef ENABLE_LOGGING
+    UNUSED(w);
+    UNUSED(arch);
+#endif
+    memset(&vi, 0, sizeof(vi));
+    vi.dwOSVersionInfoSize = sizeof(vi);
+    if(!GetVersionExA((OSVERSIONINFOA *)&vi)) {
+        memset(&vi, 0, sizeof(vi));
+        vi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOA);
+        if(!GetVersionExA((OSVERSIONINFOA *)&vi))
+            return WINDOWS_UNDEFINED;
+    }
+
+    if(vi.dwPlatformId != VER_PLATFORM_WIN32_NT)
+        return WINDOWS_UNDEFINED;
+
+    if((vi.dwMajorVersion > 6) || ((vi.dwMajorVersion == 6) && (vi.dwMinorVersion >= 2))) {
+        // Starting with Windows 8.1 Preview, GetVersionEx() does no longer report the actual OS version
+        // See: http://msdn.microsoft.com/en-us/library/windows/desktop/dn302074.aspx
+        // And starting with Windows 10 Preview 2, Windows enforces the use of the application/supportedOS
+        // manifest in order for VerSetConditionMask() to report the ACTUAL OS major and minor...
+
+        major_equal = VerSetConditionMask(0, VER_MAJORVERSION, VER_EQUAL);
+        for(major = vi.dwMajorVersion; major <= 9; major++) {
+            memset(&vi2, 0, sizeof(vi2));
+            vi2.dwOSVersionInfoSize = sizeof(vi2);
+            vi2.dwMajorVersion      = major;
+            if(!VerifyVersionInfoA(&vi2, VER_MAJORVERSION, major_equal))
+                continue;
+
+            if(vi.dwMajorVersion < major) {
+                vi.dwMajorVersion = major;
+                vi.dwMinorVersion = 0;
+            }
+
+            minor_equal = VerSetConditionMask(0, VER_MINORVERSION, VER_EQUAL);
+            for(minor = vi.dwMinorVersion; minor <= 9; minor++) {
+                memset(&vi2, 0, sizeof(vi2));
+                vi2.dwOSVersionInfoSize = sizeof(vi2);
+                vi2.dwMinorVersion      = minor;
+                if(!VerifyVersionInfoA(&vi2, VER_MINORVERSION, minor_equal))
+                    continue;
+
+                vi.dwMinorVersion = minor;
+                break;
+            }
+
+            break;
+        }
+    }
+
+    if((vi.dwMajorVersion > 0xf) || (vi.dwMinorVersion > 0xf))
+        return WINDOWS_UNDEFINED;
+
+    ws      = (vi.wProductType <= VER_NT_WORKSTATION);
+    version = vi.dwMajorVersion << 4 | vi.dwMinorVersion;
+
+    switch(version) {
+    case 0x50:
+        winver = WINDOWS_2000;
+        w      = "2000";
+        break;
+    case 0x51:
+        winver = WINDOWS_XP;
+        w      = "XP";
+        break;
+    case 0x52:
+        winver = WINDOWS_2003;
+        w      = "2003";
+        break;
+    case 0x60:
+        winver = WINDOWS_VISTA;
+        w      = (ws ? "Vista" : "2008");
+        break;
+    case 0x61:
+        winver = WINDOWS_7;
+        w      = (ws ? "7" : "2008_R2");
+        break;
+    case 0x62:
+        winver = WINDOWS_8;
+        w      = (ws ? "8" : "2012");
+        break;
+    case 0x63:
+        winver = WINDOWS_8_1;
+        w      = (ws ? "8.1" : "2012_R2");
+        break;
+    case 0x64:  // Early Windows 10 Insider Previews and Windows Server 2017 Technical Preview 1 used version 6.4
+    case 0xA0:
+        winver = WINDOWS_10;
+        w      = (ws ? "10" : "2016");
+        if(vi.dwBuildNumber < 20000)
+            break;
+        // fallthrough
+    case 0xB0:
+        winver = WINDOWS_11;
+        w      = (ws ? "11" : "2022");
+        break;
+    default:
+        if(version < 0x50)
+            return WINDOWS_UNDEFINED;
+        winver = WINDOWS_12_OR_LATER;
+        w      = "12 or later";
+    }
+
+    // We cannot tell if we are on 8, 10, or 11 without "app manifest"
+    if(version == 0x62 && vi.dwBuildNumber == 9200)
+        w = "8 (or later)";
+
+    arch = is_x64() ? "64-bit" : "32-bit";
+
+    if(vi.wServicePackMinor)
+        usbi_dbg(NULL, "Windows %s SP%u.%u %s", w, vi.wServicePackMajor, vi.wServicePackMinor, arch);
+    else if(vi.wServicePackMajor)
+        usbi_dbg(NULL, "Windows %s SP%u %s", w, vi.wServicePackMajor, arch);
+    else
+        usbi_dbg(NULL, "Windows %s %s", w, arch);
+
+    return winver;
+}
+
+static unsigned __stdcall windows_iocp_thread(void *arg) {
+    struct libusb_context             *ctx  = arg;
+    struct windows_context_priv       *priv = usbi_get_context_priv(ctx);
+    HANDLE                             iocp = priv->completion_port;
+    DWORD                              num_bytes;
+    ULONG_PTR                          completion_key;
+    OVERLAPPED                        *overlapped;
+    struct libusb_device_handle       *dev_handle;
+    struct libusb_device_handle       *opened_device_handle;
+    struct windows_device_handle_priv *handle_priv;
+    struct windows_transfer_priv      *transfer_priv;
+    struct usbi_transfer              *itransfer;
+    bool                               found;
+
+    usbi_dbg(ctx, "I/O completion thread started");
+
+    while(true) {
+        overlapped = NULL;
+        if(!GetQueuedCompletionStatus(iocp, &num_bytes, &completion_key, &overlapped, INFINITE) && (overlapped == NULL)) {
+            usbi_err(ctx, "GetQueuedCompletionStatus failed: %s", windows_error_str(0));
+            break;
+        }
+
+        if(overlapped == NULL) {
+            // Signal to quit
+            if(completion_key != (ULONG_PTR)ctx)
+                usbi_err(ctx, "program assertion failed - overlapped is NULL");
+            break;
+        }
+
+        // Find the transfer associated with the OVERLAPPED that just completed.
+        // If we cannot find a match, the I/O operation originated from outside of libusb
+        // (e.g. within libusbK) and we need to ignore it.
+        dev_handle = (struct libusb_device_handle *)completion_key;
+
+        found         = false;
+        transfer_priv = NULL;
+
+        // Issue 912: lock opened device handles in context to search the current device handle
+        // to avoid accessing unallocated memory after device has been closed
+        usbi_mutex_lock(&ctx->open_devs_lock);
+        for_each_open_device(ctx, opened_device_handle) {
+            if(dev_handle == opened_device_handle) {
+                handle_priv = usbi_get_device_handle_priv(dev_handle);
+
+                usbi_mutex_lock(&dev_handle->lock);
+                list_for_each_entry(transfer_priv, &handle_priv->active_transfers, list, struct windows_transfer_priv) {
+                    if(overlapped == &transfer_priv->overlapped) {
+                        // This OVERLAPPED belongs to us, remove the transfer from the device handle's list
+                        list_del(&transfer_priv->list);
+                        found = true;
+                        break;
+                    }
+                }
+                usbi_mutex_unlock(&dev_handle->lock);
+            }
+        }
+        usbi_mutex_unlock(&ctx->open_devs_lock);
+
+        if(!found) {
+            usbi_dbg(ctx, "ignoring overlapped %p for handle %p", overlapped, dev_handle);
+            continue;
+        }
+
+        itransfer = (struct usbi_transfer *)((unsigned char *)transfer_priv + PTR_ALIGN(sizeof(*transfer_priv)));
+        usbi_dbg(ctx, "transfer %p completed, length %lu", USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer), ULONG_CAST(num_bytes));
+        usbi_signal_transfer_completion(itransfer);
+    }
+
+    usbi_dbg(ctx, "I/O completion thread exiting");
+
+    return 0;
+}
+
+static int windows_init(struct libusb_context *ctx) {
+    struct windows_context_priv *priv                = usbi_get_context_priv(ctx);
+    bool                         winusb_backend_init = false;
+    int                          r;
+
+    // NB: concurrent usage supposes that init calls are equally balanced with
+    // exit calls. If init is called more than exit, we will not exit properly
+    if(++init_count == 1) {  // First init?
+        windows_version = get_windows_version();
+        if(windows_version == WINDOWS_UNDEFINED) {
+            usbi_err(ctx, "failed to detect Windows version");
+            r = LIBUSB_ERROR_NOT_SUPPORTED;
+            goto init_exit;
+        }
+        else if(windows_version < WINDOWS_VISTA) {
+            usbi_err(ctx, "Windows version is too old");
+            r = LIBUSB_ERROR_NOT_SUPPORTED;
+            goto init_exit;
+        }
+
+        if(!htab_create(ctx)) {
+            r = LIBUSB_ERROR_NO_MEM;
+            goto init_exit;
+        }
+
+        r = winusb_backend.init(ctx);
+        if(r != LIBUSB_SUCCESS)
+            goto init_exit;
+        winusb_backend_init = true;
+
+        r = usbdk_backend.init(ctx);
+        if(r == LIBUSB_SUCCESS) {
+            usbi_dbg(ctx, "UsbDk backend is available");
+            usbdk_available = true;
+        }
+        else {
+            usbi_info(ctx, "UsbDk backend is not available");
+            // Do not report this as an error
+        }
+    }
+
+    // By default, new contexts will use the WinUSB backend
+    priv->backend = &winusb_backend;
+
+    r = LIBUSB_ERROR_NO_MEM;
+
+    // Use an I/O completion port to manage all transfers for this context
+    priv->completion_port = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 1);
+    if(priv->completion_port == NULL) {
+        usbi_err(ctx, "failed to create I/O completion port: %s", windows_error_str(0));
+        goto init_exit;
+    }
+
+    // And a dedicated thread to wait for I/O completions
+    priv->completion_port_thread = (HANDLE)_beginthreadex(NULL, 0, windows_iocp_thread, ctx, 0, NULL);
+    if(priv->completion_port_thread == NULL) {
+        usbi_err(ctx, "failed to create I/O completion port thread");
+        CloseHandle(priv->completion_port);
+        goto init_exit;
+    }
+
+    r = LIBUSB_SUCCESS;
+
+init_exit:                                            // Holds semaphore here
+    if((init_count == 1) && (r != LIBUSB_SUCCESS)) {  // First init failed?
+        if(usbdk_available) {
+            usbdk_backend.exit(ctx);
+            usbdk_available = false;
+        }
+        if(winusb_backend_init)
+            winusb_backend.exit(ctx);
+        htab_destroy();
+        --init_count;
+    }
+
+    return r;
+}
+
+static void windows_exit(struct libusb_context *ctx) {
+    struct windows_context_priv *priv = usbi_get_context_priv(ctx);
+
+    // A NULL completion status will indicate to the thread that it is time to exit
+    if(!PostQueuedCompletionStatus(priv->completion_port, 0, (ULONG_PTR)ctx, NULL))
+        usbi_err(ctx, "failed to post I/O completion: %s", windows_error_str(0));
+
+    if(WaitForSingleObject(priv->completion_port_thread, INFINITE) == WAIT_FAILED)
+        usbi_err(ctx, "failed to wait for I/O completion port thread: %s", windows_error_str(0));
+
+    CloseHandle(priv->completion_port_thread);
+    CloseHandle(priv->completion_port);
+
+    // Only works if exits and inits are balanced exactly
+    if(--init_count == 0) {  // Last exit
+        if(usbdk_available) {
+            usbdk_backend.exit(ctx);
+            usbdk_available = false;
+        }
+        winusb_backend.exit(ctx);
+        htab_destroy();
+    }
+}
+
+static int windows_set_option(struct libusb_context *ctx, enum libusb_option option, va_list ap) {
+    struct windows_context_priv *priv = usbi_get_context_priv(ctx);
+
+    if(option == LIBUSB_OPTION_USE_USBDK) {
+        if(!usbdk_available) {
+            usbi_err(ctx, "UsbDk backend not available");
+            return LIBUSB_ERROR_NOT_FOUND;
+        }
+        usbi_dbg(ctx, "switching context %p to use UsbDk backend", ctx);
+        priv->backend = &usbdk_backend;
+        return LIBUSB_SUCCESS;
+    }
+
+    if(priv->backend->set_option) {
+        return priv->backend->set_option(ctx, option, ap);
+    }
+
+    return LIBUSB_ERROR_NOT_SUPPORTED;
+}
+
+static int windows_get_device_list(struct libusb_context *ctx, struct discovered_devs **discdevs) {
+    struct windows_context_priv *priv = usbi_get_context_priv(ctx);
+    return priv->backend->get_device_list(ctx, discdevs);
+}
+
+static int windows_open(struct libusb_device_handle *dev_handle) {
+    struct windows_context_priv       *priv        = usbi_get_context_priv(HANDLE_CTX(dev_handle));
+    struct windows_device_handle_priv *handle_priv = usbi_get_device_handle_priv(dev_handle);
+
+    list_init(&handle_priv->active_transfers);
+    return priv->backend->open(dev_handle);
+}
+
+static void windows_close(struct libusb_device_handle *dev_handle) {
+    struct windows_context_priv *priv = usbi_get_context_priv(HANDLE_CTX(dev_handle));
+    priv->backend->close(dev_handle);
+}
+
+static int windows_get_active_config_descriptor(struct libusb_device *dev, void *buffer, size_t len) {
+    struct windows_context_priv *priv = usbi_get_context_priv(DEVICE_CTX(dev));
+    return priv->backend->get_active_config_descriptor(dev, buffer, len);
+}
+
+static int windows_get_config_descriptor(struct libusb_device *dev, uint8_t config_index, void *buffer, size_t len) {
+    struct windows_context_priv *priv = usbi_get_context_priv(DEVICE_CTX(dev));
+    return priv->backend->get_config_descriptor(dev, config_index, buffer, len);
+}
+
+static int windows_get_config_descriptor_by_value(struct libusb_device *dev, uint8_t bConfigurationValue, void **buffer) {
+    struct windows_context_priv *priv = usbi_get_context_priv(DEVICE_CTX(dev));
+    return priv->backend->get_config_descriptor_by_value(dev, bConfigurationValue, buffer);
+}
+
+static int windows_get_configuration(struct libusb_device_handle *dev_handle, uint8_t *config) {
+    struct windows_context_priv *priv = usbi_get_context_priv(HANDLE_CTX(dev_handle));
+    return priv->backend->get_configuration(dev_handle, config);
+}
+
+static int windows_set_configuration(struct libusb_device_handle *dev_handle, int config) {
+    struct windows_context_priv *priv = usbi_get_context_priv(HANDLE_CTX(dev_handle));
+    if(config == -1)
+        config = 0;
+    return priv->backend->set_configuration(dev_handle, (uint8_t)config);
+}
+
+static int windows_claim_interface(struct libusb_device_handle *dev_handle, uint8_t interface_number) {
+    struct windows_context_priv *priv = usbi_get_context_priv(HANDLE_CTX(dev_handle));
+    return priv->backend->claim_interface(dev_handle, interface_number);
+}
+
+static int windows_release_interface(struct libusb_device_handle *dev_handle, uint8_t interface_number) {
+    struct windows_context_priv *priv = usbi_get_context_priv(HANDLE_CTX(dev_handle));
+    return priv->backend->release_interface(dev_handle, interface_number);
+}
+
+static int windows_set_interface_altsetting(struct libusb_device_handle *dev_handle, uint8_t interface_number, uint8_t altsetting) {
+    struct windows_context_priv *priv = usbi_get_context_priv(HANDLE_CTX(dev_handle));
+    return priv->backend->set_interface_altsetting(dev_handle, interface_number, altsetting);
+}
+
+static int windows_clear_halt(struct libusb_device_handle *dev_handle, unsigned char endpoint) {
+    struct windows_context_priv *priv = usbi_get_context_priv(HANDLE_CTX(dev_handle));
+    return priv->backend->clear_halt(dev_handle, endpoint);
+}
+
+static int windows_reset_device(struct libusb_device_handle *dev_handle) {
+    struct windows_context_priv *priv = usbi_get_context_priv(HANDLE_CTX(dev_handle));
+    return priv->backend->reset_device(dev_handle);
+}
+
+static void windows_destroy_device(struct libusb_device *dev) {
+    struct windows_context_priv *priv = usbi_get_context_priv(DEVICE_CTX(dev));
+    priv->backend->destroy_device(dev);
+}
+
+static int windows_submit_transfer(struct usbi_transfer *itransfer) {
+    struct libusb_transfer            *transfer      = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+    struct libusb_device_handle       *dev_handle    = transfer->dev_handle;
+    struct libusb_context             *ctx           = HANDLE_CTX(dev_handle);
+    struct windows_context_priv       *priv          = usbi_get_context_priv(ctx);
+    struct windows_device_handle_priv *handle_priv   = usbi_get_device_handle_priv(dev_handle);
+    struct windows_transfer_priv      *transfer_priv = usbi_get_transfer_priv(itransfer);
+    int                                r;
+
+    switch(transfer->type) {
+    case LIBUSB_TRANSFER_TYPE_CONTROL:
+    case LIBUSB_TRANSFER_TYPE_BULK:
+    case LIBUSB_TRANSFER_TYPE_INTERRUPT:
+    case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
+        break;
+    case LIBUSB_TRANSFER_TYPE_BULK_STREAM:
+        usbi_warn(ctx, "bulk stream transfers are not yet supported on this platform");
+        return LIBUSB_ERROR_NOT_SUPPORTED;
+    default:
+        usbi_err(ctx, "unknown endpoint type %d", transfer->type);
+        return LIBUSB_ERROR_INVALID_PARAM;
+    }
+
+    if(transfer_priv->handle != NULL) {
+        usbi_err(ctx, "program assertion failed - transfer HANDLE is not NULL");
+        transfer_priv->handle = NULL;
+    }
+
+    // Add transfer to the device handle's list
+    usbi_mutex_lock(&dev_handle->lock);
+    list_add_tail(&transfer_priv->list, &handle_priv->active_transfers);
+    usbi_mutex_unlock(&dev_handle->lock);
+
+    r = priv->backend->submit_transfer(itransfer);
+    if(r != LIBUSB_SUCCESS) {
+        // Remove the unsuccessful transfer from the device handle's list
+        usbi_mutex_lock(&dev_handle->lock);
+        list_del(&transfer_priv->list);
+        usbi_mutex_unlock(&dev_handle->lock);
+
+        // Always call the backend's clear_transfer_priv() function on failure
+        priv->backend->clear_transfer_priv(itransfer);
+        transfer_priv->handle = NULL;
+        return r;
+    }
+
+    // The backend should set the HANDLE used for each submitted transfer
+    // by calling set_transfer_priv_handle()
+    if(transfer_priv->handle == NULL)
+        usbi_err(ctx, "program assertion failed - transfer HANDLE is NULL after transfer was submitted");
+
+    return r;
+}
+
+static int windows_cancel_transfer(struct usbi_transfer *itransfer) {
+    struct windows_context_priv  *priv          = usbi_get_context_priv(ITRANSFER_CTX(itransfer));
+    struct windows_transfer_priv *transfer_priv = usbi_get_transfer_priv(itransfer);
+
+    // Try CancelIoEx() on the transfer
+    // If that fails, fall back to the backend's cancel_transfer()
+    // function if it is available
+    if(CancelIoEx(transfer_priv->handle, &transfer_priv->overlapped))
+        return LIBUSB_SUCCESS;
+    else if(GetLastError() == ERROR_NOT_FOUND)
+        return LIBUSB_ERROR_NOT_FOUND;
+
+    if(priv->backend->cancel_transfer)
+        return priv->backend->cancel_transfer(itransfer);
+
+    usbi_warn(ITRANSFER_CTX(itransfer), "cancellation not supported for this transfer's driver");
+    return LIBUSB_ERROR_NOT_SUPPORTED;
+}
+
+static int windows_handle_transfer_completion(struct usbi_transfer *itransfer) {
+    struct libusb_context        *ctx           = ITRANSFER_CTX(itransfer);
+    struct windows_context_priv  *priv          = usbi_get_context_priv(ctx);
+    const struct windows_backend *backend       = priv->backend;
+    struct windows_transfer_priv *transfer_priv = usbi_get_transfer_priv(itransfer);
+    enum libusb_transfer_status   status, istatus;
+    DWORD                         result, bytes_transferred;
+
+    if(GetOverlappedResult(transfer_priv->handle, &transfer_priv->overlapped, &bytes_transferred, FALSE))
+        result = NO_ERROR;
+    else
+        result = GetLastError();
+
+    usbi_dbg(ctx, "handling transfer %p completion with errcode %lu, length %lu", USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer), ULONG_CAST(result),
+             ULONG_CAST(bytes_transferred));
+
+    switch(result) {
+    case NO_ERROR:
+        status = backend->copy_transfer_data(itransfer, bytes_transferred);
+        break;
+    case ERROR_GEN_FAILURE:
+        usbi_dbg(ctx, "detected endpoint stall");
+        status = LIBUSB_TRANSFER_STALL;
+        break;
+    case ERROR_SEM_TIMEOUT:
+        usbi_dbg(ctx, "detected semaphore timeout");
+        status = LIBUSB_TRANSFER_TIMED_OUT;
+        break;
+    case ERROR_OPERATION_ABORTED:
+        istatus = backend->copy_transfer_data(itransfer, bytes_transferred);
+        if(istatus != LIBUSB_TRANSFER_COMPLETED)
+            usbi_dbg(ctx, "failed to copy partial data in aborted operation: %d", (int)istatus);
+
+        usbi_dbg(ctx, "detected operation aborted");
+        status = LIBUSB_TRANSFER_CANCELLED;
+        break;
+    case ERROR_FILE_NOT_FOUND:
+    case ERROR_DEVICE_NOT_CONNECTED:
+    case ERROR_NO_SUCH_DEVICE:
+        usbi_dbg(ctx, "detected device removed");
+        status = LIBUSB_TRANSFER_NO_DEVICE;
+        break;
+    default:
+        usbi_err(ctx, "detected I/O error %lu: %s", ULONG_CAST(result), windows_error_str(result));
+        status = LIBUSB_TRANSFER_ERROR;
+        break;
+    }
+
+    transfer_priv->handle = NULL;
+
+    // Backend-specific cleanup
+    backend->clear_transfer_priv(itransfer);
+
+    if(status == LIBUSB_TRANSFER_CANCELLED)
+        return usbi_handle_transfer_cancellation(itransfer);
+    else
+        return usbi_handle_transfer_completion(itransfer, status);
+}
+
+#ifndef HAVE_CLOCK_GETTIME
+void usbi_get_monotonic_time(struct timespec *tp) {
+    static LONG     hires_counter_init;
+    static uint64_t hires_ticks_to_ps;
+    static uint64_t hires_frequency;
+    LARGE_INTEGER   hires_counter;
+
+    if(InterlockedExchange(&hires_counter_init, 1L) == 0L) {
+        LARGE_INTEGER li_frequency;
+
+        // Microsoft says that the QueryPerformanceFrequency() and
+        // QueryPerformanceCounter() functions always succeed on XP and later
+        QueryPerformanceFrequency(&li_frequency);
+
+        // The hires frequency can go as high as 4 GHz, so we'll use a conversion
+        // to picoseconds to compute the tv_nsecs part
+        hires_frequency   = li_frequency.QuadPart;
+        hires_ticks_to_ps = UINT64_C(1000000000000) / hires_frequency;
+    }
+
+    QueryPerformanceCounter(&hires_counter);
+    tp->tv_sec  = (long)(hires_counter.QuadPart / hires_frequency);
+    tp->tv_nsec = (long)(((hires_counter.QuadPart % hires_frequency) * hires_ticks_to_ps) / UINT64_C(1000));
+}
+#endif
+
+// NB: MSVC6 does not support named initializers.
+const struct usbi_os_backend usbi_backend = {
+    "Windows",
+    USBI_CAP_HAS_HID_ACCESS,
+    windows_init,
+    windows_exit,
+    windows_set_option,
+    windows_get_device_list,
+    NULL, /* hotplug_poll */
+    NULL, /* wrap_sys_device */
+    windows_open,
+    windows_close,
+    windows_get_active_config_descriptor,
+    windows_get_config_descriptor,
+    windows_get_config_descriptor_by_value,
+    windows_get_configuration,
+    windows_set_configuration,
+    windows_claim_interface,
+    windows_release_interface,
+    windows_set_interface_altsetting,
+    windows_clear_halt,
+    windows_reset_device,
+    NULL, /* alloc_streams */
+    NULL, /* free_streams */
+    NULL, /* dev_mem_alloc */
+    NULL, /* dev_mem_free */
+    NULL, /* kernel_driver_active */
+    NULL, /* detach_kernel_driver */
+    NULL, /* attach_kernel_driver */
+    windows_destroy_device,
+    windows_submit_transfer,
+    windows_cancel_transfer,
+    NULL, /* clear_transfer_priv */
+    NULL, /* handle_events */
+    windows_handle_transfer_completion,
+    sizeof(struct windows_context_priv),
+    sizeof(union windows_device_priv),
+    sizeof(struct windows_device_handle_priv),
+    sizeof(struct windows_transfer_priv),
+};
diff --git a/3rdparty/libusb/src/libusb/os/windows_common.h b/3rdparty/libusb/src/libusb/os/windows_common.h
new file mode 100644
index 00000000..2ee652ae
--- /dev/null
+++ b/3rdparty/libusb/src/libusb/os/windows_common.h
@@ -0,0 +1,406 @@
+/*
+ * Windows backend common header for libusb 1.0
+ *
+ * This file brings together header code common between
+ * the desktop Windows backends.
+ * Copyright © 2012-2013 RealVNC Ltd.
+ * Copyright © 2009-2012 Pete Batard <pete@akeo.ie>
+ * Copyright © 2014-2020 Chris Dickens <christopher.a.dickens@gmail.com>
+ * With contributions from Michael Plante, Orin Eman et al.
+ * Parts of this code adapted from libusb-win32-v1 by Stephan Meyer
+ * Major code testing contribution by Xiaofan Chen
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef LIBUSB_WINDOWS_COMMON_H
+#define LIBUSB_WINDOWS_COMMON_H
+
+#include <stdbool.h>
+
+/*
+ * Workaround for the mess that exists with the DWORD and ULONG types.
+ * Visual Studio unconditionally defines these types as 'unsigned long'
+ * and a long is always 32-bits, even on 64-bit builds. GCC on the other
+ * hand varies the width of a long, matching it to the build. To make
+ * matters worse, the platform headers for these GCC builds define a
+ * DWORD/ULONG to be 'unsigned long' on 32-bit builds and 'unsigned int'
+ * on 64-bit builds. This creates a great deal of warnings for compilers
+ * that support printf format checking since it will never actually be
+ * an unsigned long.
+ */
+#if defined(_MSC_VER)
+#define ULONG_CAST(x) (x)
+#else
+#define ULONG_CAST(x) ((unsigned long)(x))
+#endif
+
+#if defined(__CYGWIN__)
+#define _stricmp strcasecmp
+#define _strdup strdup
+// _beginthreadex is MSVCRT => unavailable for cygwin. Fallback to using CreateThread
+#define _beginthreadex(a, b, c, d, e, f) CreateThread(a, b, (LPTHREAD_START_ROUTINE)c, d, e, (LPDWORD)f)
+#else
+#include <process.h>
+#endif
+
+#define safe_free(p)         \
+    do {                     \
+        if(p != NULL) {      \
+            free((void *)p); \
+            p = NULL;        \
+        }                    \
+    } while(0)
+
+/*
+ * API macros - leveraged from libusb-win32 1.x
+ */
+#define DLL_STRINGIFY(s) #s
+
+/*
+ * Macros for handling DLL themselves
+ */
+#define DLL_HANDLE_NAME(name) __dll_##name##_handle
+
+#define DLL_DECLARE_HANDLE(name) static HMODULE DLL_HANDLE_NAME(name)
+
+#define DLL_GET_HANDLE(ctx, name)                                              \
+    do {                                                                       \
+        DLL_HANDLE_NAME(name) = load_system_library(ctx, DLL_STRINGIFY(name)); \
+        if(!DLL_HANDLE_NAME(name))                                             \
+            return false;                                                      \
+    } while(0)
+
+#define DLL_FREE_HANDLE(name)                   \
+    do {                                        \
+        if(DLL_HANDLE_NAME(name)) {             \
+            FreeLibrary(DLL_HANDLE_NAME(name)); \
+            DLL_HANDLE_NAME(name) = NULL;       \
+        }                                       \
+    } while(0)
+
+/*
+ * Macros for handling functions within a DLL
+ */
+#define DLL_FUNC_NAME(name) __dll_##name##_func_t
+
+#define DLL_DECLARE_FUNC_PREFIXNAME(api, ret, prefixname, name, args) \
+    typedef ret(api *DLL_FUNC_NAME(name)) args;                       \
+    static DLL_FUNC_NAME(name) prefixname
+
+#define DLL_DECLARE_FUNC(api, ret, name, args) DLL_DECLARE_FUNC_PREFIXNAME(api, ret, name, name, args)
+#define DLL_DECLARE_FUNC_PREFIXED(api, ret, prefix, name, args) DLL_DECLARE_FUNC_PREFIXNAME(api, ret, prefix##name, name, args)
+
+#define DLL_LOAD_FUNC_PREFIXNAME(dll, prefixname, name, ret_on_failure)                            \
+    do {                                                                                           \
+        HMODULE h  = DLL_HANDLE_NAME(dll);                                                         \
+        prefixname = (DLL_FUNC_NAME(name))GetProcAddress(h, DLL_STRINGIFY(name));                  \
+        if(prefixname)                                                                             \
+            break;                                                                                 \
+        prefixname = (DLL_FUNC_NAME(name))GetProcAddress(h, DLL_STRINGIFY(name) DLL_STRINGIFY(A)); \
+        if(prefixname)                                                                             \
+            break;                                                                                 \
+        prefixname = (DLL_FUNC_NAME(name))GetProcAddress(h, DLL_STRINGIFY(name) DLL_STRINGIFY(W)); \
+        if(prefixname)                                                                             \
+            break;                                                                                 \
+        if(ret_on_failure)                                                                         \
+            return false;                                                                          \
+    } while(0)
+
+#define DLL_LOAD_FUNC(dll, name, ret_on_failure) DLL_LOAD_FUNC_PREFIXNAME(dll, name, name, ret_on_failure)
+#define DLL_LOAD_FUNC_PREFIXED(dll, prefix, name, ret_on_failure) DLL_LOAD_FUNC_PREFIXNAME(dll, prefix##name, name, ret_on_failure)
+
+// https://msdn.microsoft.com/en-us/library/windows/hardware/ff539136(v=vs.85).aspx
+#if !defined(USBD_SUCCESS)
+typedef LONG USBD_STATUS;
+
+#define USBD_SUCCESS(Status) ((USBD_STATUS)(Status) >= 0)
+
+#define USBD_STATUS_STALL_PID ((USBD_STATUS)0xC0000004L)
+#define USBD_STATUS_ENDPOINT_HALTED ((USBD_STATUS)0xC0000030L)
+#define USBD_STATUS_TIMEOUT ((USBD_STATUS)0xC0006000L)
+#define USBD_STATUS_DEVICE_GONE ((USBD_STATUS)0xC0007000L)
+#define USBD_STATUS_CANCELED ((USBD_STATUS)0xC0010000L)
+#endif
+
+// error code added with Windows SDK 10.0.18362
+#ifndef ERROR_NO_SUCH_DEVICE
+#define ERROR_NO_SUCH_DEVICE 433L
+#endif
+
+/* Windows versions */
+enum windows_version {
+    WINDOWS_UNDEFINED,
+    WINDOWS_2000,
+    WINDOWS_XP,
+    WINDOWS_2003,  // Also XP x64
+    WINDOWS_VISTA,
+    WINDOWS_7,
+    WINDOWS_8,
+    WINDOWS_8_1,
+    WINDOWS_10,
+    WINDOWS_11,
+    WINDOWS_12_OR_LATER
+};
+
+extern enum windows_version windows_version;
+
+#include <pshpack1.h>
+
+typedef struct USB_DEVICE_DESCRIPTOR {
+    UCHAR  bLength;
+    UCHAR  bDescriptorType;
+    USHORT bcdUSB;
+    UCHAR  bDeviceClass;
+    UCHAR  bDeviceSubClass;
+    UCHAR  bDeviceProtocol;
+    UCHAR  bMaxPacketSize0;
+    USHORT idVendor;
+    USHORT idProduct;
+    USHORT bcdDevice;
+    UCHAR  iManufacturer;
+    UCHAR  iProduct;
+    UCHAR  iSerialNumber;
+    UCHAR  bNumConfigurations;
+} USB_DEVICE_DESCRIPTOR, *PUSB_DEVICE_DESCRIPTOR;
+
+typedef struct USB_CONFIGURATION_DESCRIPTOR {
+    UCHAR  bLength;
+    UCHAR  bDescriptorType;
+    USHORT wTotalLength;
+    UCHAR  bNumInterfaces;
+    UCHAR  bConfigurationValue;
+    UCHAR  iConfiguration;
+    UCHAR  bmAttributes;
+    UCHAR  MaxPower;
+} USB_CONFIGURATION_DESCRIPTOR, *PUSB_CONFIGURATION_DESCRIPTOR;
+
+#include <poppack.h>
+
+#define MAX_DEVICE_ID_LEN 200
+
+typedef struct USB_DK_DEVICE_ID {
+    WCHAR DeviceID[MAX_DEVICE_ID_LEN];
+    WCHAR InstanceID[MAX_DEVICE_ID_LEN];
+} USB_DK_DEVICE_ID, *PUSB_DK_DEVICE_ID;
+
+typedef struct USB_DK_DEVICE_INFO {
+    USB_DK_DEVICE_ID      ID;
+    ULONG64               FilterID;
+    ULONG64               Port;
+    ULONG64               Speed;
+    USB_DEVICE_DESCRIPTOR DeviceDescriptor;
+} USB_DK_DEVICE_INFO, *PUSB_DK_DEVICE_INFO;
+
+typedef struct USB_DK_ISO_TRANSFER_RESULT {
+    ULONG64 ActualLength;
+    ULONG64 TransferResult;
+} USB_DK_ISO_TRANSFER_RESULT, *PUSB_DK_ISO_TRANSFER_RESULT;
+
+typedef struct USB_DK_GEN_TRANSFER_RESULT {
+    ULONG64 BytesTransferred;
+    ULONG64 UsbdStatus;  // USBD_STATUS code
+} USB_DK_GEN_TRANSFER_RESULT, *PUSB_DK_GEN_TRANSFER_RESULT;
+
+typedef struct USB_DK_TRANSFER_RESULT {
+    USB_DK_GEN_TRANSFER_RESULT GenResult;
+    PVOID64                    IsochronousResultsArray;  // array of USB_DK_ISO_TRANSFER_RESULT
+} USB_DK_TRANSFER_RESULT, *PUSB_DK_TRANSFER_RESULT;
+
+typedef struct USB_DK_TRANSFER_REQUEST {
+    ULONG64                EndpointAddress;
+    PVOID64                Buffer;
+    ULONG64                BufferLength;
+    ULONG64                TransferType;
+    ULONG64                IsochronousPacketsArraySize;
+    PVOID64                IsochronousPacketsArray;
+    USB_DK_TRANSFER_RESULT Result;
+} USB_DK_TRANSFER_REQUEST, *PUSB_DK_TRANSFER_REQUEST;
+
+struct usbdk_device_priv {
+    USB_DK_DEVICE_ID               ID;
+    PUSB_CONFIGURATION_DESCRIPTOR *config_descriptors;
+    HANDLE                         redirector_handle;
+    HANDLE                         system_handle;
+    uint8_t                        active_configuration;
+};
+
+struct winusb_device_priv {
+    bool                                  initialized;
+    bool                                  root_hub;
+    uint8_t                               active_config;
+    uint8_t                               depth;  // distance to HCD
+    const struct windows_usb_api_backend *apib;
+    char                                 *dev_id;
+    char                                 *path;     // device interface path
+    int                                   sub_api;  // for WinUSB-like APIs
+    struct {
+        char                                 *path;  // each interface needs a device interface path,
+        const struct windows_usb_api_backend *apib;  // an API backend (multiple drivers support),
+        int                                   sub_api;
+        int8_t                                nb_endpoints;  // and a set of endpoint addresses (USB_MAXENDPOINTS)
+        uint8_t                              *endpoint;
+        int                                   current_altsetting;
+        bool                                  restricted_functionality;  // indicates if the interface functionality is restricted
+                                                                         // by Windows (eg. HID keyboards or mice cannot do R/W)
+        uint8_t num_associated_interfaces;                               // If non-zero, the interface is part of a grouped
+                                                                         // set of associated interfaces (defined by an IAD)
+                                                                         // and this is the number of interfaces within the
+                                                                         // associated group (bInterfaceCount in IAD).
+        uint8_t first_associated_interface;                              // For associated interfaces, this is the index of
+                                                                         // the first interface (bFirstInterface in IAD) for
+                                                                         // the grouped set of associated interfaces.
+    } usb_interface[USB_MAXINTERFACES];
+    struct hid_device_priv        *hid;
+    PUSB_CONFIGURATION_DESCRIPTOR *config_descriptor;  // list of pointers to the cached config descriptors
+    GUID                           class_guid;         // checked for change during re-enumeration
+};
+
+struct usbdk_device_handle_priv {
+    // Not currently used
+    char dummy;
+};
+
+enum WINUSB_ZLP { WINUSB_ZLP_UNSET = 0, WINUSB_ZLP_OFF = 1, WINUSB_ZLP_ON = 2 };
+
+struct winusb_device_handle_priv {
+    int active_interface;
+    struct {
+        HANDLE  dev_handle;             // WinUSB needs an extra handle for the file
+        HANDLE  api_handle;             // used by the API to communicate with the device
+        uint8_t zlp[USB_MAXENDPOINTS];  // Current per-endpoint SHORT_PACKET_TERMINATE status (enum WINUSB_ZLP)
+    } interface_handle[USB_MAXINTERFACES];
+    int autoclaim_count[USB_MAXINTERFACES];  // For auto-release
+};
+
+struct usbdk_transfer_priv {
+    USB_DK_TRANSFER_REQUEST     request;
+    PULONG64                    IsochronousPacketsArray;
+    PUSB_DK_ISO_TRANSFER_RESULT IsochronousResultsArray;
+};
+
+struct winusb_transfer_priv {
+    uint8_t interface_number;
+
+    uint8_t *hid_buffer;  // 1 byte extended data buffer, required for HID
+    uint8_t *hid_dest;    // transfer buffer destination, required for HID
+    size_t   hid_expected_size;
+
+    // For isochronous transfers with LibUSBk driver:
+    void *iso_context;
+
+    // For isochronous transfers with Microsoft WinUSB driver:
+    void *isoch_buffer_handle;                // The isoch_buffer_handle to free at the end of the transfer
+    BOOL  iso_break_stream;                   // Whether the isoch. stream was to be continued in the last call of libusb_submit_transfer.
+                                              // As we this structure is zeroed out upon initialization, we need to use inverse logic here.
+    libusb_transfer_cb_fn iso_user_callback;  // Original transfer callback of the user. Might be used for isochronous transfers.
+};
+
+struct windows_backend {
+    int (*init)(struct libusb_context *ctx);
+    void (*exit)(struct libusb_context *ctx);
+    int (*get_device_list)(struct libusb_context *ctx, struct discovered_devs **discdevs);
+    int (*open)(struct libusb_device_handle *dev_handle);
+    void (*close)(struct libusb_device_handle *dev_handle);
+    int (*get_active_config_descriptor)(struct libusb_device *device, void *buffer, size_t len);
+    int (*get_config_descriptor)(struct libusb_device *device, uint8_t config_index, void *buffer, size_t len);
+    int (*get_config_descriptor_by_value)(struct libusb_device *device, uint8_t bConfigurationValue, void **buffer);
+    int (*get_configuration)(struct libusb_device_handle *dev_handle, uint8_t *config);
+    int (*set_configuration)(struct libusb_device_handle *dev_handle, uint8_t config);
+    int (*claim_interface)(struct libusb_device_handle *dev_handle, uint8_t interface_number);
+    int (*release_interface)(struct libusb_device_handle *dev_handle, uint8_t interface_number);
+    int (*set_interface_altsetting)(struct libusb_device_handle *dev_handle, uint8_t interface_number, uint8_t altsetting);
+    int (*clear_halt)(struct libusb_device_handle *dev_handle, unsigned char endpoint);
+    int (*reset_device)(struct libusb_device_handle *dev_handle);
+    void (*destroy_device)(struct libusb_device *dev);
+    int (*submit_transfer)(struct usbi_transfer *itransfer);
+    int (*cancel_transfer)(struct usbi_transfer *itransfer);
+    void (*clear_transfer_priv)(struct usbi_transfer *itransfer);
+    enum libusb_transfer_status (*copy_transfer_data)(struct usbi_transfer *itransfer, DWORD length);
+    int (*set_option)(struct libusb_context *ctx, enum libusb_option option, va_list args);
+};
+
+struct windows_context_priv {
+    const struct windows_backend *backend;
+    HANDLE                        completion_port;
+    HANDLE                        completion_port_thread;
+};
+
+union windows_device_priv {
+    struct usbdk_device_priv  usbdk_priv;
+    struct winusb_device_priv winusb_priv;
+};
+
+struct windows_device_handle_priv {
+    struct list_head active_transfers;
+    union {
+        struct usbdk_device_handle_priv  usbdk_priv;
+        struct winusb_device_handle_priv winusb_priv;
+    };
+};
+
+struct windows_transfer_priv {
+    OVERLAPPED       overlapped;
+    HANDLE           handle;
+    struct list_head list;
+    union {
+        struct usbdk_transfer_priv  usbdk_priv;
+        struct winusb_transfer_priv winusb_priv;
+    };
+};
+
+static inline struct usbdk_device_handle_priv *get_usbdk_device_handle_priv(struct libusb_device_handle *dev_handle) {
+    struct windows_device_handle_priv *handle_priv = usbi_get_device_handle_priv(dev_handle);
+    return &handle_priv->usbdk_priv;
+}
+
+static inline struct winusb_device_handle_priv *get_winusb_device_handle_priv(struct libusb_device_handle *dev_handle) {
+    struct windows_device_handle_priv *handle_priv = usbi_get_device_handle_priv(dev_handle);
+    return &handle_priv->winusb_priv;
+}
+
+static inline OVERLAPPED *get_transfer_priv_overlapped(struct usbi_transfer *itransfer) {
+    struct windows_transfer_priv *transfer_priv = usbi_get_transfer_priv(itransfer);
+    return &transfer_priv->overlapped;
+}
+
+static inline void set_transfer_priv_handle(struct usbi_transfer *itransfer, HANDLE handle) {
+    struct windows_transfer_priv *transfer_priv = usbi_get_transfer_priv(itransfer);
+    transfer_priv->handle                       = handle;
+}
+
+static inline struct usbdk_transfer_priv *get_usbdk_transfer_priv(struct usbi_transfer *itransfer) {
+    struct windows_transfer_priv *transfer_priv = usbi_get_transfer_priv(itransfer);
+    return &transfer_priv->usbdk_priv;
+}
+
+static inline struct winusb_transfer_priv *get_winusb_transfer_priv(struct usbi_transfer *itransfer) {
+    struct windows_transfer_priv *transfer_priv = usbi_get_transfer_priv(itransfer);
+    return &transfer_priv->winusb_priv;
+}
+
+extern const struct windows_backend usbdk_backend;
+extern const struct windows_backend winusb_backend;
+
+HMODULE                     load_system_library(struct libusb_context *ctx, const char *name);
+unsigned long               htab_hash(const char *str);
+enum libusb_transfer_status usbd_status_to_libusb_transfer_status(USBD_STATUS status);
+void                        windows_force_sync_completion(struct usbi_transfer *itransfer, ULONG size);
+
+#if defined(ENABLE_LOGGING)
+const char *windows_error_str(DWORD error_code);
+#endif
+
+#endif
diff --git a/3rdparty/libusb/src/libusb/os/windows_usbdk.c b/3rdparty/libusb/src/libusb/os/windows_usbdk.c
new file mode 100644
index 00000000..40aa7843
--- /dev/null
+++ b/3rdparty/libusb/src/libusb/os/windows_usbdk.c
@@ -0,0 +1,691 @@
+/*
+ * windows UsbDk backend for libusb 1.0
+ * Copyright © 2014 Red Hat, Inc.
+
+ * Authors:
+ * Dmitry Fleytman <dmitry@daynix.com>
+ * Pavel Gurvich <pavel@daynix.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <libusb/config.h>
+
+#include <windows.h>
+#include <stdio.h>
+
+#include "libusbi.h"
+#include "windows_usbdk.h"
+
+#if !defined(STATUS_SUCCESS)
+typedef LONG NTSTATUS;
+#define STATUS_SUCCESS ((NTSTATUS)0x00000000L)
+#endif
+
+#if !defined(STATUS_CANCELLED)
+#define STATUS_CANCELLED ((NTSTATUS)0xC0000120L)
+#endif
+
+#if !defined(STATUS_REQUEST_CANCELED)
+#define STATUS_REQUEST_CANCELED ((NTSTATUS)0xC0000703L)
+#endif
+
+static struct {
+    HMODULE module;
+
+    USBDK_GET_DEVICES_LIST                 GetDevicesList;
+    USBDK_RELEASE_DEVICES_LIST             ReleaseDevicesList;
+    USBDK_START_REDIRECT                   StartRedirect;
+    USBDK_STOP_REDIRECT                    StopRedirect;
+    USBDK_GET_CONFIGURATION_DESCRIPTOR     GetConfigurationDescriptor;
+    USBDK_RELEASE_CONFIGURATION_DESCRIPTOR ReleaseConfigurationDescriptor;
+    USBDK_READ_PIPE                        ReadPipe;
+    USBDK_WRITE_PIPE                       WritePipe;
+    USBDK_ABORT_PIPE                       AbortPipe;
+    USBDK_RESET_PIPE                       ResetPipe;
+    USBDK_SET_ALTSETTING                   SetAltsetting;
+    USBDK_RESET_DEVICE                     ResetDevice;
+    USBDK_GET_REDIRECTOR_SYSTEM_HANDLE     GetRedirectorSystemHandle;
+} usbdk_helper;
+
+static FARPROC get_usbdk_proc_addr(struct libusb_context *ctx, LPCSTR api_name) {
+    FARPROC api_ptr = GetProcAddress(usbdk_helper.module, api_name);
+
+    if(api_ptr == NULL)
+        usbi_err(ctx, "UsbDkHelper API %s not found: %s", api_name, windows_error_str(0));
+
+    return api_ptr;
+}
+
+static void unload_usbdk_helper_dll(void) {
+    if(usbdk_helper.module != NULL) {
+        FreeLibrary(usbdk_helper.module);
+        usbdk_helper.module = NULL;
+    }
+}
+
+static int load_usbdk_helper_dll(struct libusb_context *ctx) {
+    usbdk_helper.module = load_system_library(ctx, "UsbDkHelper");
+    if(usbdk_helper.module == NULL) {
+        usbi_err(ctx, "Failed to load UsbDkHelper.dll: %s", windows_error_str(0));
+        return LIBUSB_ERROR_NOT_FOUND;
+    }
+
+    usbdk_helper.GetDevicesList = (USBDK_GET_DEVICES_LIST)get_usbdk_proc_addr(ctx, "UsbDk_GetDevicesList");
+    if(usbdk_helper.GetDevicesList == NULL)
+        goto error_unload;
+
+    usbdk_helper.ReleaseDevicesList = (USBDK_RELEASE_DEVICES_LIST)get_usbdk_proc_addr(ctx, "UsbDk_ReleaseDevicesList");
+    if(usbdk_helper.ReleaseDevicesList == NULL)
+        goto error_unload;
+
+    usbdk_helper.StartRedirect = (USBDK_START_REDIRECT)get_usbdk_proc_addr(ctx, "UsbDk_StartRedirect");
+    if(usbdk_helper.StartRedirect == NULL)
+        goto error_unload;
+
+    usbdk_helper.StopRedirect = (USBDK_STOP_REDIRECT)get_usbdk_proc_addr(ctx, "UsbDk_StopRedirect");
+    if(usbdk_helper.StopRedirect == NULL)
+        goto error_unload;
+
+    usbdk_helper.GetConfigurationDescriptor = (USBDK_GET_CONFIGURATION_DESCRIPTOR)get_usbdk_proc_addr(ctx, "UsbDk_GetConfigurationDescriptor");
+    if(usbdk_helper.GetConfigurationDescriptor == NULL)
+        goto error_unload;
+
+    usbdk_helper.ReleaseConfigurationDescriptor = (USBDK_RELEASE_CONFIGURATION_DESCRIPTOR)get_usbdk_proc_addr(ctx, "UsbDk_ReleaseConfigurationDescriptor");
+    if(usbdk_helper.ReleaseConfigurationDescriptor == NULL)
+        goto error_unload;
+
+    usbdk_helper.ReadPipe = (USBDK_READ_PIPE)get_usbdk_proc_addr(ctx, "UsbDk_ReadPipe");
+    if(usbdk_helper.ReadPipe == NULL)
+        goto error_unload;
+
+    usbdk_helper.WritePipe = (USBDK_WRITE_PIPE)get_usbdk_proc_addr(ctx, "UsbDk_WritePipe");
+    if(usbdk_helper.WritePipe == NULL)
+        goto error_unload;
+
+    usbdk_helper.AbortPipe = (USBDK_ABORT_PIPE)get_usbdk_proc_addr(ctx, "UsbDk_AbortPipe");
+    if(usbdk_helper.AbortPipe == NULL)
+        goto error_unload;
+
+    usbdk_helper.ResetPipe = (USBDK_RESET_PIPE)get_usbdk_proc_addr(ctx, "UsbDk_ResetPipe");
+    if(usbdk_helper.ResetPipe == NULL)
+        goto error_unload;
+
+    usbdk_helper.SetAltsetting = (USBDK_SET_ALTSETTING)get_usbdk_proc_addr(ctx, "UsbDk_SetAltsetting");
+    if(usbdk_helper.SetAltsetting == NULL)
+        goto error_unload;
+
+    usbdk_helper.ResetDevice = (USBDK_RESET_DEVICE)get_usbdk_proc_addr(ctx, "UsbDk_ResetDevice");
+    if(usbdk_helper.ResetDevice == NULL)
+        goto error_unload;
+
+    usbdk_helper.GetRedirectorSystemHandle = (USBDK_GET_REDIRECTOR_SYSTEM_HANDLE)get_usbdk_proc_addr(ctx, "UsbDk_GetRedirectorSystemHandle");
+    if(usbdk_helper.GetRedirectorSystemHandle == NULL)
+        goto error_unload;
+
+    return LIBUSB_SUCCESS;
+
+error_unload:
+    FreeLibrary(usbdk_helper.module);
+    usbdk_helper.module = NULL;
+    return LIBUSB_ERROR_NOT_FOUND;
+}
+
+typedef SC_HANDLE(WINAPI *POPENSCMANAGERA)(LPCSTR, LPCSTR, DWORD);
+typedef SC_HANDLE(WINAPI *POPENSERVICEA)(SC_HANDLE, LPCSTR, DWORD);
+typedef BOOL(WINAPI *PCLOSESERVICEHANDLE)(SC_HANDLE);
+
+static int usbdk_init(struct libusb_context *ctx) {
+    POPENSCMANAGERA     pOpenSCManagerA;
+    POPENSERVICEA       pOpenServiceA;
+    PCLOSESERVICEHANDLE pCloseServiceHandle;
+    SC_HANDLE           managerHandle;
+    SC_HANDLE           serviceHandle;
+    HMODULE             h;
+
+    h = load_system_library(ctx, "Advapi32");
+    if(h == NULL) {
+        usbi_warn(ctx, "failed to open Advapi32\n");
+        return LIBUSB_ERROR_OTHER;
+    }
+
+    pOpenSCManagerA = (POPENSCMANAGERA)GetProcAddress(h, "OpenSCManagerA");
+    if(pOpenSCManagerA == NULL) {
+        usbi_warn(ctx, "failed to find %s in Advapi32\n", "OpenSCManagerA");
+        goto error_free_library;
+    }
+    pOpenServiceA = (POPENSERVICEA)GetProcAddress(h, "OpenServiceA");
+    if(pOpenServiceA == NULL) {
+        usbi_warn(ctx, "failed to find %s in Advapi32\n", "OpenServiceA");
+        goto error_free_library;
+    }
+    pCloseServiceHandle = (PCLOSESERVICEHANDLE)GetProcAddress(h, "CloseServiceHandle");
+    if(pCloseServiceHandle == NULL) {
+        usbi_warn(ctx, "failed to find %s in Advapi32\n", "CloseServiceHandle");
+        goto error_free_library;
+    }
+
+    managerHandle = pOpenSCManagerA(NULL, NULL, SC_MANAGER_CONNECT);
+    if(managerHandle == NULL) {
+        usbi_warn(ctx, "failed to open service control manager: %s", windows_error_str(0));
+        goto error_free_library;
+    }
+
+    serviceHandle = pOpenServiceA(managerHandle, "UsbDk", GENERIC_READ);
+    pCloseServiceHandle(managerHandle);
+
+    if(serviceHandle == NULL) {
+        if(GetLastError() != ERROR_SERVICE_DOES_NOT_EXIST)
+            usbi_warn(ctx, "failed to open UsbDk service: %s", windows_error_str(0));
+        FreeLibrary(h);
+        return LIBUSB_ERROR_NOT_FOUND;
+    }
+
+    pCloseServiceHandle(serviceHandle);
+    FreeLibrary(h);
+
+    return load_usbdk_helper_dll(ctx);
+
+error_free_library:
+    FreeLibrary(h);
+    return LIBUSB_ERROR_OTHER;
+}
+
+static void usbdk_exit(struct libusb_context *ctx) {
+    UNUSED(ctx);
+    unload_usbdk_helper_dll();
+}
+
+static int usbdk_get_session_id_for_device(struct libusb_context *ctx, PUSB_DK_DEVICE_ID id, unsigned long *session_id) {
+    char dev_identity[ARRAYSIZE(id->DeviceID) + ARRAYSIZE(id->InstanceID) + 1];
+
+    if(snprintf(dev_identity, sizeof(dev_identity), "%S%S", id->DeviceID, id->InstanceID) == -1) {
+        usbi_warn(ctx, "cannot form device identity");
+        return LIBUSB_ERROR_NOT_SUPPORTED;
+    }
+
+    *session_id = htab_hash(dev_identity);
+
+    return LIBUSB_SUCCESS;
+}
+
+static void usbdk_release_config_descriptors(struct usbdk_device_priv *priv, uint8_t count) {
+    uint8_t i;
+
+    for(i = 0; i < count; i++)
+        usbdk_helper.ReleaseConfigurationDescriptor(priv->config_descriptors[i]);
+
+    free(priv->config_descriptors);
+    priv->config_descriptors = NULL;
+}
+
+static int usbdk_cache_config_descriptors(struct libusb_context *ctx, struct usbdk_device_priv *priv, PUSB_DK_DEVICE_INFO info) {
+    uint8_t                          i;
+    USB_DK_CONFIG_DESCRIPTOR_REQUEST Request;
+    Request.ID = info->ID;
+
+    priv->config_descriptors = calloc(info->DeviceDescriptor.bNumConfigurations, sizeof(PUSB_CONFIGURATION_DESCRIPTOR));
+    if(priv->config_descriptors == NULL) {
+        usbi_err(ctx, "failed to allocate configuration descriptors holder");
+        return LIBUSB_ERROR_NO_MEM;
+    }
+
+    for(i = 0; i < info->DeviceDescriptor.bNumConfigurations; i++) {
+        ULONG Length;
+
+        Request.Index = i;
+        if(!usbdk_helper.GetConfigurationDescriptor(&Request, &priv->config_descriptors[i], &Length)) {
+            usbi_err(ctx, "failed to retrieve configuration descriptors");
+            usbdk_release_config_descriptors(priv, i);
+            return LIBUSB_ERROR_OTHER;
+        }
+    }
+
+    return LIBUSB_SUCCESS;
+}
+
+static inline int usbdk_device_priv_init(struct libusb_context *ctx, struct libusb_device *dev, PUSB_DK_DEVICE_INFO info) {
+    struct usbdk_device_priv *priv = usbi_get_device_priv(dev);
+
+    priv->ID                   = info->ID;
+    priv->active_configuration = 0;
+
+    return usbdk_cache_config_descriptors(ctx, priv, info);
+}
+
+static void usbdk_device_init(struct libusb_device *dev, PUSB_DK_DEVICE_INFO info) {
+    dev->bus_number  = (uint8_t)info->FilterID;
+    dev->port_number = (uint8_t)info->Port;
+    dev->parent_dev  = NULL;
+
+    // Addresses in libusb are 1-based
+    dev->device_address = (uint8_t)(info->Port + 1);
+
+    static_assert(sizeof(dev->device_descriptor) == sizeof(info->DeviceDescriptor), "mismatch between libusb and OS device descriptor sizes");
+    memcpy(&dev->device_descriptor, &info->DeviceDescriptor, LIBUSB_DT_DEVICE_SIZE);
+    usbi_localize_device_descriptor(&dev->device_descriptor);
+
+    switch(info->Speed) {
+    case LowSpeed:
+        dev->speed = LIBUSB_SPEED_LOW;
+        break;
+    case FullSpeed:
+        dev->speed = LIBUSB_SPEED_FULL;
+        break;
+    case HighSpeed:
+        dev->speed = LIBUSB_SPEED_HIGH;
+        break;
+    case SuperSpeed:
+        dev->speed = LIBUSB_SPEED_SUPER;
+        break;
+    case NoSpeed:
+    default:
+        dev->speed = LIBUSB_SPEED_UNKNOWN;
+        break;
+    }
+}
+
+static int usbdk_get_device_list(struct libusb_context *ctx, struct discovered_devs **_discdevs) {
+    int                     r = LIBUSB_SUCCESS;
+    ULONG                   i;
+    struct discovered_devs *discdevs = NULL;
+    ULONG                   dev_number;
+    PUSB_DK_DEVICE_INFO     devices;
+
+    if(!usbdk_helper.GetDevicesList(&devices, &dev_number))
+        return LIBUSB_ERROR_OTHER;
+
+    for(i = 0; i < dev_number; i++) {
+        unsigned long         session_id;
+        struct libusb_device *dev = NULL;
+
+        if(usbdk_get_session_id_for_device(ctx, &devices[i].ID, &session_id))
+            continue;
+
+        dev = usbi_get_device_by_session_id(ctx, session_id);
+        if(dev == NULL) {
+            dev = usbi_alloc_device(ctx, session_id);
+            if(dev == NULL) {
+                usbi_err(ctx, "failed to allocate a new device structure");
+                continue;
+            }
+
+            usbdk_device_init(dev, &devices[i]);
+            if(usbdk_device_priv_init(ctx, dev, &devices[i]) != LIBUSB_SUCCESS) {
+                libusb_unref_device(dev);
+                continue;
+            }
+        }
+
+        discdevs = discovered_devs_append(*_discdevs, dev);
+        libusb_unref_device(dev);
+        if(!discdevs) {
+            usbi_err(ctx, "cannot append new device to list");
+            r = LIBUSB_ERROR_NO_MEM;
+            goto func_exit;
+        }
+
+        *_discdevs = discdevs;
+    }
+
+func_exit:
+    usbdk_helper.ReleaseDevicesList(devices);
+    return r;
+}
+
+static int usbdk_get_config_descriptor(struct libusb_device *dev, uint8_t config_index, void *buffer, size_t len) {
+    struct usbdk_device_priv     *priv = usbi_get_device_priv(dev);
+    PUSB_CONFIGURATION_DESCRIPTOR config_header;
+    size_t                        size;
+
+    config_header = (PUSB_CONFIGURATION_DESCRIPTOR)priv->config_descriptors[config_index];
+
+    size = min(config_header->wTotalLength, len);
+    memcpy(buffer, config_header, size);
+    return (int)size;
+}
+
+static int usbdk_get_config_descriptor_by_value(struct libusb_device *dev, uint8_t bConfigurationValue, void **buffer) {
+    struct usbdk_device_priv     *priv = usbi_get_device_priv(dev);
+    PUSB_CONFIGURATION_DESCRIPTOR config_header;
+    uint8_t                       index;
+
+    for(index = 0; index < dev->device_descriptor.bNumConfigurations; index++) {
+        config_header = priv->config_descriptors[index];
+        if(config_header->bConfigurationValue == bConfigurationValue) {
+            *buffer = priv->config_descriptors[index];
+            return (int)config_header->wTotalLength;
+        }
+    }
+
+    return LIBUSB_ERROR_NOT_FOUND;
+}
+
+static int usbdk_get_active_config_descriptor(struct libusb_device *dev, void *buffer, size_t len) {
+    struct usbdk_device_priv *priv = usbi_get_device_priv(dev);
+
+    return usbdk_get_config_descriptor(dev, priv->active_configuration, buffer, len);
+}
+
+static int usbdk_open(struct libusb_device_handle *dev_handle) {
+    struct libusb_device        *dev         = dev_handle->dev;
+    struct libusb_context       *ctx         = DEVICE_CTX(dev);
+    struct windows_context_priv *priv        = usbi_get_context_priv(ctx);
+    struct usbdk_device_priv    *device_priv = usbi_get_device_priv(dev);
+
+    device_priv->redirector_handle = usbdk_helper.StartRedirect(&device_priv->ID);
+    if(device_priv->redirector_handle == INVALID_HANDLE_VALUE) {
+        usbi_err(ctx, "Redirector startup failed");
+        device_priv->redirector_handle = NULL;
+        return LIBUSB_ERROR_OTHER;
+    }
+
+    device_priv->system_handle = usbdk_helper.GetRedirectorSystemHandle(device_priv->redirector_handle);
+
+    if(CreateIoCompletionPort(device_priv->system_handle, priv->completion_port, (ULONG_PTR)dev_handle, 0) == NULL) {
+        usbi_err(ctx, "failed to associate handle to I/O completion port: %s", windows_error_str(0));
+        usbdk_helper.StopRedirect(device_priv->redirector_handle);
+        device_priv->system_handle     = NULL;
+        device_priv->redirector_handle = NULL;
+        return LIBUSB_ERROR_OTHER;
+    }
+
+    return LIBUSB_SUCCESS;
+}
+
+static void usbdk_close(struct libusb_device_handle *dev_handle) {
+    struct usbdk_device_priv *priv = usbi_get_device_priv(dev_handle->dev);
+
+    if(!usbdk_helper.StopRedirect(priv->redirector_handle))
+        usbi_err(HANDLE_CTX(dev_handle), "Redirector shutdown failed");
+
+    priv->system_handle     = NULL;
+    priv->redirector_handle = NULL;
+}
+
+static int usbdk_get_configuration(struct libusb_device_handle *dev_handle, uint8_t *config) {
+    struct usbdk_device_priv *priv = usbi_get_device_priv(dev_handle->dev);
+
+    *config = priv->active_configuration;
+
+    return LIBUSB_SUCCESS;
+}
+
+static int usbdk_set_configuration(struct libusb_device_handle *dev_handle, uint8_t config) {
+    UNUSED(dev_handle);
+    UNUSED(config);
+    return LIBUSB_SUCCESS;
+}
+
+static int usbdk_claim_interface(struct libusb_device_handle *dev_handle, uint8_t iface) {
+    UNUSED(dev_handle);
+    UNUSED(iface);
+    return LIBUSB_SUCCESS;
+}
+
+static int usbdk_set_interface_altsetting(struct libusb_device_handle *dev_handle, uint8_t iface, uint8_t altsetting) {
+    struct usbdk_device_priv *priv = usbi_get_device_priv(dev_handle->dev);
+
+    if(!usbdk_helper.SetAltsetting(priv->redirector_handle, iface, altsetting)) {
+        usbi_err(HANDLE_CTX(dev_handle), "SetAltsetting failed: %s", windows_error_str(0));
+        return LIBUSB_ERROR_NO_DEVICE;
+    }
+
+    return LIBUSB_SUCCESS;
+}
+
+static int usbdk_release_interface(struct libusb_device_handle *dev_handle, uint8_t iface) {
+    UNUSED(dev_handle);
+    UNUSED(iface);
+    return LIBUSB_SUCCESS;
+}
+
+static int usbdk_clear_halt(struct libusb_device_handle *dev_handle, unsigned char endpoint) {
+    struct usbdk_device_priv *priv = usbi_get_device_priv(dev_handle->dev);
+
+    if(!usbdk_helper.ResetPipe(priv->redirector_handle, endpoint)) {
+        usbi_err(HANDLE_CTX(dev_handle), "ResetPipe failed: %s", windows_error_str(0));
+        return LIBUSB_ERROR_NO_DEVICE;
+    }
+
+    return LIBUSB_SUCCESS;
+}
+
+static int usbdk_reset_device(struct libusb_device_handle *dev_handle) {
+    struct usbdk_device_priv *priv = usbi_get_device_priv(dev_handle->dev);
+
+    if(!usbdk_helper.ResetDevice(priv->redirector_handle)) {
+        usbi_err(HANDLE_CTX(dev_handle), "ResetDevice failed: %s", windows_error_str(0));
+        return LIBUSB_ERROR_NO_DEVICE;
+    }
+
+    return LIBUSB_SUCCESS;
+}
+
+static void usbdk_destroy_device(struct libusb_device *dev) {
+    struct usbdk_device_priv *priv = usbi_get_device_priv(dev);
+
+    if(priv->config_descriptors != NULL)
+        usbdk_release_config_descriptors(priv, dev->device_descriptor.bNumConfigurations);
+}
+
+static void usbdk_clear_transfer_priv(struct usbi_transfer *itransfer) {
+    struct usbdk_transfer_priv *transfer_priv = get_usbdk_transfer_priv(itransfer);
+    struct libusb_transfer     *transfer      = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+
+    if(transfer->type == LIBUSB_TRANSFER_TYPE_ISOCHRONOUS) {
+        safe_free(transfer_priv->IsochronousPacketsArray);
+        safe_free(transfer_priv->IsochronousResultsArray);
+    }
+}
+
+static int usbdk_do_control_transfer(struct usbi_transfer *itransfer) {
+    struct libusb_transfer     *transfer      = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+    struct usbdk_device_priv   *priv          = usbi_get_device_priv(transfer->dev_handle->dev);
+    struct usbdk_transfer_priv *transfer_priv = get_usbdk_transfer_priv(itransfer);
+    OVERLAPPED                 *overlapped    = get_transfer_priv_overlapped(itransfer);
+    TransferResult              transResult;
+
+    transfer_priv->request.Buffer       = (PVOID64)transfer->buffer;
+    transfer_priv->request.BufferLength = transfer->length;
+    transfer_priv->request.TransferType = ControlTransferType;
+
+    set_transfer_priv_handle(itransfer, priv->system_handle);
+
+    if(transfer->buffer[0] & LIBUSB_ENDPOINT_IN)
+        transResult = usbdk_helper.ReadPipe(priv->redirector_handle, &transfer_priv->request, overlapped);
+    else
+        transResult = usbdk_helper.WritePipe(priv->redirector_handle, &transfer_priv->request, overlapped);
+
+    switch(transResult) {
+    case TransferSuccess:
+        windows_force_sync_completion(itransfer, (ULONG)transfer_priv->request.Result.GenResult.BytesTransferred);
+        break;
+    case TransferSuccessAsync:
+        break;
+    case TransferFailure:
+        usbi_err(TRANSFER_CTX(transfer), "ControlTransfer failed: %s", windows_error_str(0));
+        return LIBUSB_ERROR_IO;
+    }
+
+    return LIBUSB_SUCCESS;
+}
+
+static int usbdk_do_bulk_transfer(struct usbi_transfer *itransfer) {
+    struct libusb_transfer     *transfer      = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+    struct usbdk_device_priv   *priv          = usbi_get_device_priv(transfer->dev_handle->dev);
+    struct usbdk_transfer_priv *transfer_priv = get_usbdk_transfer_priv(itransfer);
+    OVERLAPPED                 *overlapped    = get_transfer_priv_overlapped(itransfer);
+    TransferResult              transferRes;
+
+    transfer_priv->request.Buffer          = (PVOID64)transfer->buffer;
+    transfer_priv->request.BufferLength    = transfer->length;
+    transfer_priv->request.EndpointAddress = transfer->endpoint;
+
+    switch(transfer->type) {
+    case LIBUSB_TRANSFER_TYPE_BULK:
+        transfer_priv->request.TransferType = BulkTransferType;
+        break;
+    case LIBUSB_TRANSFER_TYPE_INTERRUPT:
+        transfer_priv->request.TransferType = InterruptTransferType;
+        break;
+    }
+
+    set_transfer_priv_handle(itransfer, priv->system_handle);
+
+    if(IS_XFERIN(transfer))
+        transferRes = usbdk_helper.ReadPipe(priv->redirector_handle, &transfer_priv->request, overlapped);
+    else
+        transferRes = usbdk_helper.WritePipe(priv->redirector_handle, &transfer_priv->request, overlapped);
+
+    switch(transferRes) {
+    case TransferSuccess:
+        windows_force_sync_completion(itransfer, (ULONG)transfer_priv->request.Result.GenResult.BytesTransferred);
+        break;
+    case TransferSuccessAsync:
+        break;
+    case TransferFailure:
+        usbi_err(TRANSFER_CTX(transfer), "ReadPipe/WritePipe failed: %s", windows_error_str(0));
+        return LIBUSB_ERROR_IO;
+    }
+
+    return LIBUSB_SUCCESS;
+}
+
+static int usbdk_do_iso_transfer(struct usbi_transfer *itransfer) {
+    struct libusb_transfer     *transfer      = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+    struct usbdk_device_priv   *priv          = usbi_get_device_priv(transfer->dev_handle->dev);
+    struct usbdk_transfer_priv *transfer_priv = get_usbdk_transfer_priv(itransfer);
+    OVERLAPPED                 *overlapped    = get_transfer_priv_overlapped(itransfer);
+    TransferResult              transferRes;
+    int                         i;
+
+    transfer_priv->request.Buffer                      = (PVOID64)transfer->buffer;
+    transfer_priv->request.BufferLength                = transfer->length;
+    transfer_priv->request.EndpointAddress             = transfer->endpoint;
+    transfer_priv->request.TransferType                = IsochronousTransferType;
+    transfer_priv->request.IsochronousPacketsArraySize = transfer->num_iso_packets;
+    transfer_priv->IsochronousPacketsArray             = malloc(transfer->num_iso_packets * sizeof(ULONG64));
+    transfer_priv->request.IsochronousPacketsArray     = (PVOID64)transfer_priv->IsochronousPacketsArray;
+    if(!transfer_priv->IsochronousPacketsArray) {
+        usbi_err(TRANSFER_CTX(transfer), "Allocation of IsochronousPacketsArray failed");
+        return LIBUSB_ERROR_NO_MEM;
+    }
+
+    transfer_priv->IsochronousResultsArray                = malloc(transfer->num_iso_packets * sizeof(USB_DK_ISO_TRANSFER_RESULT));
+    transfer_priv->request.Result.IsochronousResultsArray = (PVOID64)transfer_priv->IsochronousResultsArray;
+    if(!transfer_priv->IsochronousResultsArray) {
+        usbi_err(TRANSFER_CTX(transfer), "Allocation of isochronousResultsArray failed");
+        return LIBUSB_ERROR_NO_MEM;
+    }
+
+    for(i = 0; i < transfer->num_iso_packets; i++)
+        transfer_priv->IsochronousPacketsArray[i] = transfer->iso_packet_desc[i].length;
+
+    set_transfer_priv_handle(itransfer, priv->system_handle);
+
+    if(IS_XFERIN(transfer))
+        transferRes = usbdk_helper.ReadPipe(priv->redirector_handle, &transfer_priv->request, overlapped);
+    else
+        transferRes = usbdk_helper.WritePipe(priv->redirector_handle, &transfer_priv->request, overlapped);
+
+    switch(transferRes) {
+    case TransferSuccess:
+        windows_force_sync_completion(itransfer, (ULONG)transfer_priv->request.Result.GenResult.BytesTransferred);
+        break;
+    case TransferSuccessAsync:
+        break;
+    case TransferFailure:
+        return LIBUSB_ERROR_IO;
+    }
+
+    return LIBUSB_SUCCESS;
+}
+
+static int usbdk_submit_transfer(struct usbi_transfer *itransfer) {
+    struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+
+    switch(transfer->type) {
+    case LIBUSB_TRANSFER_TYPE_CONTROL:
+        return usbdk_do_control_transfer(itransfer);
+    case LIBUSB_TRANSFER_TYPE_BULK:
+    case LIBUSB_TRANSFER_TYPE_INTERRUPT:
+        if(IS_XFEROUT(transfer) && (transfer->flags & LIBUSB_TRANSFER_ADD_ZERO_PACKET))
+            return LIBUSB_ERROR_NOT_SUPPORTED;  // TODO: Check whether we can support this in UsbDk
+        return usbdk_do_bulk_transfer(itransfer);
+    case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
+        return usbdk_do_iso_transfer(itransfer);
+    default:
+        // Should not get here since windows_submit_transfer() validates
+        // the transfer->type field
+        usbi_err(TRANSFER_CTX(transfer), "unsupported endpoint type %d", transfer->type);
+        return LIBUSB_ERROR_NOT_SUPPORTED;
+    }
+}
+
+static enum libusb_transfer_status usbdk_copy_transfer_data(struct usbi_transfer *itransfer, DWORD length) {
+    struct libusb_transfer     *transfer      = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+    struct usbdk_transfer_priv *transfer_priv = get_usbdk_transfer_priv(itransfer);
+
+    UNUSED(length);
+
+    if(transfer->type == LIBUSB_TRANSFER_TYPE_ISOCHRONOUS) {
+        ULONG64 i;
+
+        for(i = 0; i < transfer_priv->request.IsochronousPacketsArraySize; i++) {
+            struct libusb_iso_packet_descriptor *lib_desc = &transfer->iso_packet_desc[i];
+
+            switch(transfer_priv->IsochronousResultsArray[i].TransferResult) {
+            case STATUS_SUCCESS:
+            case STATUS_CANCELLED:
+            case STATUS_REQUEST_CANCELED:
+                lib_desc->status = LIBUSB_TRANSFER_COMPLETED;  // == ERROR_SUCCESS
+                break;
+            default:
+                lib_desc->status = LIBUSB_TRANSFER_ERROR;  // ERROR_UNKNOWN_EXCEPTION;
+                break;
+            }
+
+            lib_desc->actual_length = (unsigned int)transfer_priv->IsochronousResultsArray[i].ActualLength;
+        }
+    }
+
+    itransfer->transferred += (int)transfer_priv->request.Result.GenResult.BytesTransferred;
+    return usbd_status_to_libusb_transfer_status((USBD_STATUS)transfer_priv->request.Result.GenResult.UsbdStatus);
+}
+
+const struct windows_backend usbdk_backend = {
+    usbdk_init,
+    usbdk_exit,
+    usbdk_get_device_list,
+    usbdk_open,
+    usbdk_close,
+    usbdk_get_active_config_descriptor,
+    usbdk_get_config_descriptor,
+    usbdk_get_config_descriptor_by_value,
+    usbdk_get_configuration,
+    usbdk_set_configuration,
+    usbdk_claim_interface,
+    usbdk_release_interface,
+    usbdk_set_interface_altsetting,
+    usbdk_clear_halt,
+    usbdk_reset_device,
+    usbdk_destroy_device,
+    usbdk_submit_transfer,
+    NULL, /* cancel_transfer */
+    usbdk_clear_transfer_priv,
+    usbdk_copy_transfer_data,
+    NULL /* usbdk_set_option */,
+};
diff --git a/3rdparty/libusb/src/libusb/os/windows_usbdk.h b/3rdparty/libusb/src/libusb/os/windows_usbdk.h
new file mode 100644
index 00000000..0eb3779a
--- /dev/null
+++ b/3rdparty/libusb/src/libusb/os/windows_usbdk.h
@@ -0,0 +1,106 @@
+/*
+* windows UsbDk backend for libusb 1.0
+* Copyright © 2014 Red Hat, Inc.
+
+* Authors:
+* Dmitry Fleytman <dmitry@daynix.com>
+* Pavel Gurvich <pavel@daynix.com>
+*
+* This library is free software; you can redistribute it and/or
+* modify it under the terms of the GNU Lesser General Public
+* License as published by the Free Software Foundation; either
+* version 2.1 of the License, or (at your option) any later version.
+*
+* This library is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+* Lesser General Public License for more details.
+*
+* You should have received a copy of the GNU Lesser General Public
+* License along with this library; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+*/
+
+#ifndef LIBUSB_WINDOWS_USBDK_H
+#define LIBUSB_WINDOWS_USBDK_H
+
+#include "windows_common.h"
+
+typedef struct USB_DK_CONFIG_DESCRIPTOR_REQUEST {
+	USB_DK_DEVICE_ID ID;
+	ULONG64 Index;
+} USB_DK_CONFIG_DESCRIPTOR_REQUEST, *PUSB_DK_CONFIG_DESCRIPTOR_REQUEST;
+
+typedef enum {
+	TransferFailure = 0,
+	TransferSuccess,
+	TransferSuccessAsync
+} TransferResult;
+
+typedef enum {
+	NoSpeed = 0,
+	LowSpeed,
+	FullSpeed,
+	HighSpeed,
+	SuperSpeed
+} USB_DK_DEVICE_SPEED;
+
+typedef enum {
+	ControlTransferType,
+	BulkTransferType,
+	InterruptTransferType,
+	IsochronousTransferType
+} USB_DK_TRANSFER_TYPE;
+
+typedef BOOL (__cdecl *USBDK_GET_DEVICES_LIST)(
+	PUSB_DK_DEVICE_INFO *DeviceInfo,
+	PULONG DeviceNumber
+);
+typedef void (__cdecl *USBDK_RELEASE_DEVICES_LIST)(
+	PUSB_DK_DEVICE_INFO DeviceInfo
+);
+typedef HANDLE (__cdecl *USBDK_START_REDIRECT)(
+	PUSB_DK_DEVICE_ID DeviceId
+);
+typedef BOOL (__cdecl *USBDK_STOP_REDIRECT)(
+	HANDLE DeviceHandle
+);
+typedef BOOL (__cdecl *USBDK_GET_CONFIGURATION_DESCRIPTOR)(
+	PUSB_DK_CONFIG_DESCRIPTOR_REQUEST Request,
+	PUSB_CONFIGURATION_DESCRIPTOR *Descriptor,
+	PULONG Length
+);
+typedef void (__cdecl *USBDK_RELEASE_CONFIGURATION_DESCRIPTOR)(
+	PUSB_CONFIGURATION_DESCRIPTOR Descriptor
+);
+typedef TransferResult (__cdecl *USBDK_WRITE_PIPE)(
+	HANDLE DeviceHandle,
+	PUSB_DK_TRANSFER_REQUEST Request,
+	LPOVERLAPPED lpOverlapped
+);
+typedef TransferResult (__cdecl *USBDK_READ_PIPE)(
+	HANDLE DeviceHandle,
+	PUSB_DK_TRANSFER_REQUEST Request,
+	LPOVERLAPPED lpOverlapped
+);
+typedef BOOL (__cdecl *USBDK_ABORT_PIPE)(
+	HANDLE DeviceHandle,
+	ULONG64 PipeAddress
+);
+typedef BOOL (__cdecl *USBDK_RESET_PIPE)(
+	HANDLE DeviceHandle,
+	ULONG64 PipeAddress
+);
+typedef BOOL (__cdecl *USBDK_SET_ALTSETTING)(
+	HANDLE DeviceHandle,
+	ULONG64 InterfaceIdx,
+	ULONG64 AltSettingIdx
+);
+typedef BOOL (__cdecl *USBDK_RESET_DEVICE)(
+	HANDLE DeviceHandle
+);
+typedef HANDLE (__cdecl *USBDK_GET_REDIRECTOR_SYSTEM_HANDLE)(
+	HANDLE DeviceHandle
+);
+
+#endif
diff --git a/3rdparty/libusb/src/libusb/os/windows_winusb.c b/3rdparty/libusb/src/libusb/os/windows_winusb.c
new file mode 100644
index 00000000..0c90b370
--- /dev/null
+++ b/3rdparty/libusb/src/libusb/os/windows_winusb.c
@@ -0,0 +1,4664 @@
+/*
+ * windows backend for libusb 1.0
+ * Copyright © 2009-2012 Pete Batard <pete@akeo.ie>
+ * Copyright © 2016-2018 Chris Dickens <christopher.a.dickens@gmail.com>
+ * With contributions from Michael Plante, Orin Eman et al.
+ * Parts of this code adapted from libusb-win32-v1 by Stephan Meyer
+ * HID Reports IOCTLs inspired from HIDAPI by Alan Ott, Signal 11 Software
+ * Hash table functions adapted from glibc, by Ulrich Drepper et al.
+ * Major code testing contribution by Xiaofan Chen
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <libusb/config.h>
+
+#include <windows.h>
+#include <setupapi.h>
+#include <ctype.h>
+#include <stdio.h>
+
+#include "libusbi.h"
+#include "windows_winusb.h"
+
+#define HANDLE_VALID(h) (((h) != NULL) && ((h) != INVALID_HANDLE_VALUE))
+
+// The below macro is used in conjunction with safe loops.
+#define LOOP_BREAK(err) \
+    {                   \
+        r = err;        \
+        continue;       \
+    }
+
+static int interface_by_endpoint(struct winusb_device_priv *priv, struct winusb_device_handle_priv *handle_priv, uint8_t endpoint_address);
+// WinUSB-like API prototypes
+static bool                        winusbx_init(struct libusb_context *ctx);
+static void                        winusbx_exit(void);
+static int                         winusbx_open(int sub_api, struct libusb_device_handle *dev_handle);
+static void                        winusbx_close(int sub_api, struct libusb_device_handle *dev_handle);
+static int                         winusbx_configure_endpoints(int sub_api, struct libusb_device_handle *dev_handle, uint8_t iface);
+static int                         winusbx_claim_interface(int sub_api, struct libusb_device_handle *dev_handle, uint8_t iface);
+static int                         winusbx_release_interface(int sub_api, struct libusb_device_handle *dev_handle, uint8_t iface);
+static int                         winusbx_submit_control_transfer(int sub_api, struct usbi_transfer *itransfer);
+static int                         winusbx_set_interface_altsetting(int sub_api, struct libusb_device_handle *dev_handle, uint8_t iface, uint8_t altsetting);
+static int                         winusbx_submit_iso_transfer(int sub_api, struct usbi_transfer *itransfer);
+static int                         winusbx_submit_bulk_transfer(int sub_api, struct usbi_transfer *itransfer);
+static int                         winusbx_clear_halt(int sub_api, struct libusb_device_handle *dev_handle, unsigned char endpoint);
+static int                         winusbx_cancel_transfer(int sub_api, struct usbi_transfer *itransfer);
+static int                         winusbx_reset_device(int sub_api, struct libusb_device_handle *dev_handle);
+static enum libusb_transfer_status winusbx_copy_transfer_data(int sub_api, struct usbi_transfer *itransfer, DWORD length);
+// HID API prototypes
+static bool                        hid_init(struct libusb_context *ctx);
+static void                        hid_exit(void);
+static int                         hid_open(int sub_api, struct libusb_device_handle *dev_handle);
+static void                        hid_close(int sub_api, struct libusb_device_handle *dev_handle);
+static int                         hid_claim_interface(int sub_api, struct libusb_device_handle *dev_handle, uint8_t iface);
+static int                         hid_release_interface(int sub_api, struct libusb_device_handle *dev_handle, uint8_t iface);
+static int                         hid_set_interface_altsetting(int sub_api, struct libusb_device_handle *dev_handle, uint8_t iface, uint8_t altsetting);
+static int                         hid_submit_control_transfer(int sub_api, struct usbi_transfer *itransfer);
+static int                         hid_submit_bulk_transfer(int sub_api, struct usbi_transfer *itransfer);
+static int                         hid_clear_halt(int sub_api, struct libusb_device_handle *dev_handle, unsigned char endpoint);
+static int                         hid_reset_device(int sub_api, struct libusb_device_handle *dev_handle);
+static enum libusb_transfer_status hid_copy_transfer_data(int sub_api, struct usbi_transfer *itransfer, DWORD length);
+// Composite API prototypes
+static int                         composite_open(int sub_api, struct libusb_device_handle *dev_handle);
+static void                        composite_close(int sub_api, struct libusb_device_handle *dev_handle);
+static int                         composite_claim_interface(int sub_api, struct libusb_device_handle *dev_handle, uint8_t iface);
+static int                         composite_set_interface_altsetting(int sub_api, struct libusb_device_handle *dev_handle, uint8_t iface, uint8_t altsetting);
+static int                         composite_release_interface(int sub_api, struct libusb_device_handle *dev_handle, uint8_t iface);
+static int                         composite_submit_control_transfer(int sub_api, struct usbi_transfer *itransfer);
+static int                         composite_submit_bulk_transfer(int sub_api, struct usbi_transfer *itransfer);
+static int                         composite_submit_iso_transfer(int sub_api, struct usbi_transfer *itransfer);
+static int                         composite_clear_halt(int sub_api, struct libusb_device_handle *dev_handle, unsigned char endpoint);
+static int                         composite_cancel_transfer(int sub_api, struct usbi_transfer *itransfer);
+static int                         composite_reset_device(int sub_api, struct libusb_device_handle *dev_handle);
+static enum libusb_transfer_status composite_copy_transfer_data(int sub_api, struct usbi_transfer *itransfer, DWORD length);
+
+static usbi_mutex_t autoclaim_lock;
+
+// API globals
+static struct winusb_interface WinUSBX[SUB_API_MAX];
+#define CHECK_WINUSBX_AVAILABLE(sub_api)  \
+    do {                                  \
+        if(sub_api == SUB_API_NOTSET)     \
+            sub_api = priv->sub_api;      \
+        if(WinUSBX[sub_api].hDll == NULL) \
+            return LIBUSB_ERROR_ACCESS;   \
+    } while(0)
+
+#define CHECK_HID_AVAILABLE              \
+    do {                                 \
+        if(DLL_HANDLE_NAME(hid) == NULL) \
+            return LIBUSB_ERROR_ACCESS;  \
+    } while(0)
+
+#if defined(ENABLE_LOGGING)
+static const char *guid_to_string(const GUID *guid, char guid_string[MAX_GUID_STRING_LENGTH]) {
+    if(guid == NULL) {
+        guid_string[0] = '\0';
+        return guid_string;
+    }
+
+    sprintf(guid_string, "{%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}", (unsigned int)guid->Data1, guid->Data2, guid->Data3, guid->Data4[0],
+            guid->Data4[1], guid->Data4[2], guid->Data4[3], guid->Data4[4], guid->Data4[5], guid->Data4[6], guid->Data4[7]);
+
+    return guid_string;
+}
+#endif
+
+static bool string_to_guid(const char guid_string[MAX_GUID_STRING_LENGTH], GUID *guid) {
+    unsigned short tmp[4];
+    int            num_chars = -1;
+    char           extra;
+    int            r;
+
+    // Unfortunately MinGW complains that '%hhx' is not a valid format specifier,
+    // even though Visual Studio 2013 and later support it. Rather than complicating
+    // the logic in this function with '#ifdef's, use a temporary array on the stack
+    // to store the conversions.
+    r = sscanf(guid_string, "{%8x-%4hx-%4hx-%4hx-%4hx%4hx%4hx}%n%c", (unsigned int *)&guid->Data1, &guid->Data2, &guid->Data3, &tmp[0], &tmp[1], &tmp[2],
+               &tmp[3], &num_chars, &extra);
+
+    if((r != 7) || (num_chars != 38))
+        return false;
+
+    // Extract the bytes from the 2-byte shorts
+    guid->Data4[0] = (unsigned char)((tmp[0] >> 8) & 0xFF);
+    guid->Data4[1] = (unsigned char)(tmp[0] & 0xFF);
+    guid->Data4[2] = (unsigned char)((tmp[1] >> 8) & 0xFF);
+    guid->Data4[3] = (unsigned char)(tmp[1] & 0xFF);
+    guid->Data4[4] = (unsigned char)((tmp[2] >> 8) & 0xFF);
+    guid->Data4[5] = (unsigned char)(tmp[2] & 0xFF);
+    guid->Data4[6] = (unsigned char)((tmp[3] >> 8) & 0xFF);
+    guid->Data4[7] = (unsigned char)(tmp[3] & 0xFF);
+
+    return true;
+}
+
+/*
+ * Normalize Microsoft's paths: return a duplicate of the given path
+ * with all characters converted to uppercase
+ */
+static char *normalize_path(const char *path) {
+    char *ret_path = _strdup(path);
+    char *p;
+
+    if(ret_path == NULL)
+        return NULL;
+
+    for(p = ret_path; *p != '\0'; p++)
+        *p = (char)toupper((unsigned char)*p);
+
+    return ret_path;
+}
+
+/*
+ * Cfgmgr32, AdvAPI32, OLE32 and SetupAPI DLL functions
+ */
+static bool init_dlls(struct libusb_context *ctx) {
+    DLL_GET_HANDLE(ctx, Cfgmgr32);
+    DLL_LOAD_FUNC(Cfgmgr32, CM_Get_Parent, true);
+    DLL_LOAD_FUNC(Cfgmgr32, CM_Get_Child, true);
+
+    // Prefixed to avoid conflict with header files
+    DLL_GET_HANDLE(ctx, AdvAPI32);
+    DLL_LOAD_FUNC_PREFIXED(AdvAPI32, p, RegQueryValueExA, true);
+    DLL_LOAD_FUNC_PREFIXED(AdvAPI32, p, RegCloseKey, true);
+
+    DLL_GET_HANDLE(ctx, SetupAPI);
+    DLL_LOAD_FUNC_PREFIXED(SetupAPI, p, SetupDiGetClassDevsA, true);
+    DLL_LOAD_FUNC_PREFIXED(SetupAPI, p, SetupDiEnumDeviceInfo, true);
+    DLL_LOAD_FUNC_PREFIXED(SetupAPI, p, SetupDiEnumDeviceInterfaces, true);
+    DLL_LOAD_FUNC_PREFIXED(SetupAPI, p, SetupDiGetDeviceInstanceIdA, true);
+    DLL_LOAD_FUNC_PREFIXED(SetupAPI, p, SetupDiGetDeviceInterfaceDetailA, true);
+    DLL_LOAD_FUNC_PREFIXED(SetupAPI, p, SetupDiGetDeviceRegistryPropertyA, true);
+    DLL_LOAD_FUNC_PREFIXED(SetupAPI, p, SetupDiDestroyDeviceInfoList, true);
+    DLL_LOAD_FUNC_PREFIXED(SetupAPI, p, SetupDiOpenDevRegKey, true);
+    DLL_LOAD_FUNC_PREFIXED(SetupAPI, p, SetupDiOpenDeviceInterfaceRegKey, true);
+
+    return true;
+}
+
+static void exit_dlls(void) {
+    DLL_FREE_HANDLE(SetupAPI);
+    DLL_FREE_HANDLE(AdvAPI32);
+    DLL_FREE_HANDLE(Cfgmgr32);
+}
+
+/*
+ * enumerate interfaces for the whole USB class
+ *
+ * Parameters:
+ * dev_info: a pointer to a dev_info list
+ * dev_info_data: a pointer to an SP_DEVINFO_DATA to be filled (or NULL if not needed)
+ * enumerator: the generic USB class for which to retrieve interface details
+ * index: zero based index of the interface in the device info list
+ *
+ * Note: it is the responsibility of the caller to free the DEVICE_INTERFACE_DETAIL_DATA
+ * structure returned and call this function repeatedly using the same guid (with an
+ * incremented index starting at zero) until all interfaces have been returned.
+ */
+static bool get_devinfo_data(struct libusb_context *ctx, HDEVINFO *dev_info, SP_DEVINFO_DATA *dev_info_data, const char *enumerator, unsigned _index) {
+    if(_index == 0) {
+        *dev_info = pSetupDiGetClassDevsA(NULL, enumerator, NULL, DIGCF_PRESENT | DIGCF_ALLCLASSES);
+        if(*dev_info == INVALID_HANDLE_VALUE) {
+            usbi_err(ctx, "could not obtain device info set for PnP enumerator '%s': %s", enumerator, windows_error_str(0));
+            return false;
+        }
+    }
+
+    dev_info_data->cbSize = sizeof(SP_DEVINFO_DATA);
+    if(!pSetupDiEnumDeviceInfo(*dev_info, _index, dev_info_data)) {
+        if(GetLastError() != ERROR_NO_MORE_ITEMS)
+            usbi_err(ctx, "could not obtain device info data for PnP enumerator '%s' index %u: %s", enumerator, _index, windows_error_str(0));
+
+        pSetupDiDestroyDeviceInfoList(*dev_info);
+        *dev_info = INVALID_HANDLE_VALUE;
+        return false;
+    }
+    return true;
+}
+
+/*
+ * enumerate interfaces for a specific GUID
+ *
+ * Parameters:
+ * dev_info: a pointer to a dev_info list
+ * dev_info_data: a pointer to an SP_DEVINFO_DATA to be filled (or NULL if not needed)
+ * guid: the GUID for which to retrieve interface details
+ * index: zero based index of the interface in the device info list
+ *
+ * Note: it is the responsibility of the caller to free the DEVICE_INTERFACE_DETAIL_DATA
+ * structure returned and call this function repeatedly using the same guid (with an
+ * incremented index starting at zero) until all interfaces have been returned.
+ */
+static int get_interface_details(struct libusb_context *ctx, HDEVINFO dev_info, PSP_DEVINFO_DATA dev_info_data, LPCGUID guid, DWORD *_index,
+                                 char **dev_interface_path) {
+    SP_DEVICE_INTERFACE_DATA           dev_interface_data;
+    PSP_DEVICE_INTERFACE_DETAIL_DATA_A dev_interface_details;
+    char                               guid_string[MAX_GUID_STRING_LENGTH];
+    DWORD                              size;
+
+#ifndef ENABLE_LOGGING
+    UNUSED(*guid_string);
+#endif
+    dev_info_data->cbSize     = sizeof(SP_DEVINFO_DATA);
+    dev_interface_data.cbSize = sizeof(SP_DEVICE_INTERFACE_DATA);
+    for(;;) {
+        if(!pSetupDiEnumDeviceInfo(dev_info, *_index, dev_info_data)) {
+            if(GetLastError() != ERROR_NO_MORE_ITEMS) {
+                usbi_err(ctx, "Could not obtain device info data for %s index %lu: %s", guid_to_string(guid, guid_string), ULONG_CAST(*_index),
+                         windows_error_str(0));
+                return LIBUSB_ERROR_OTHER;
+            }
+
+            // No more devices
+            return LIBUSB_SUCCESS;
+        }
+
+        // Always advance the index for the next iteration
+        (*_index)++;
+
+        if(pSetupDiEnumDeviceInterfaces(dev_info, dev_info_data, guid, 0, &dev_interface_data))
+            break;
+
+        if(GetLastError() != ERROR_NO_MORE_ITEMS) {
+            usbi_err(ctx, "Could not obtain interface data for %s devInst %lX: %s", guid_to_string(guid, guid_string), ULONG_CAST(dev_info_data->DevInst),
+                     windows_error_str(0));
+            return LIBUSB_ERROR_OTHER;
+        }
+
+        // Device does not have an interface matching this GUID, skip
+    }
+
+    // Read interface data (dummy + actual) to access the device path
+    if(!pSetupDiGetDeviceInterfaceDetailA(dev_info, &dev_interface_data, NULL, 0, &size, NULL)) {
+        // The dummy call should fail with ERROR_INSUFFICIENT_BUFFER
+        if(GetLastError() != ERROR_INSUFFICIENT_BUFFER) {
+            usbi_err(ctx, "could not access interface data (dummy) for %s devInst %lX: %s", guid_to_string(guid, guid_string),
+                     ULONG_CAST(dev_info_data->DevInst), windows_error_str(0));
+            return LIBUSB_ERROR_OTHER;
+        }
+    }
+    else {
+        usbi_err(ctx, "program assertion failed - http://msdn.microsoft.com/en-us/library/ms792901.aspx is wrong");
+        return LIBUSB_ERROR_OTHER;
+    }
+
+    dev_interface_details = malloc(size);
+    if(dev_interface_details == NULL) {
+        usbi_err(ctx, "could not allocate interface data for %s devInst %lX", guid_to_string(guid, guid_string), ULONG_CAST(dev_info_data->DevInst));
+        return LIBUSB_ERROR_NO_MEM;
+    }
+
+    dev_interface_details->cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA_A);
+    if(!pSetupDiGetDeviceInterfaceDetailA(dev_info, &dev_interface_data, dev_interface_details, size, NULL, NULL)) {
+        usbi_err(ctx, "could not access interface data (actual) for %s devInst %lX: %s", guid_to_string(guid, guid_string), ULONG_CAST(dev_info_data->DevInst),
+                 windows_error_str(0));
+        free(dev_interface_details);
+        return LIBUSB_ERROR_OTHER;
+    }
+
+    *dev_interface_path = normalize_path(dev_interface_details->DevicePath);
+    free(dev_interface_details);
+
+    if(*dev_interface_path == NULL) {
+        usbi_err(ctx, "could not allocate interface path for %s devInst %lX", guid_to_string(guid, guid_string), ULONG_CAST(dev_info_data->DevInst));
+        return LIBUSB_ERROR_NO_MEM;
+    }
+
+    return LIBUSB_SUCCESS;
+}
+
+/* For libusb0 filter */
+static int get_interface_details_filter(struct libusb_context *ctx, HDEVINFO *dev_info, DWORD _index, char *filter_path, char **dev_interface_path) {
+    const GUID                        *libusb0_guid = &GUID_DEVINTERFACE_LIBUSB0_FILTER;
+    SP_DEVICE_INTERFACE_DATA           dev_interface_data;
+    PSP_DEVICE_INTERFACE_DETAIL_DATA_A dev_interface_details;
+    HKEY                               hkey_dev_interface;
+    DWORD                              size;
+    int                                err = LIBUSB_ERROR_OTHER;
+
+    if(_index == 0) {
+        *dev_info = pSetupDiGetClassDevsA(libusb0_guid, NULL, NULL, DIGCF_PRESENT | DIGCF_DEVICEINTERFACE);
+        if(*dev_info == INVALID_HANDLE_VALUE) {
+            usbi_err(ctx, "could not obtain device info set: %s", windows_error_str(0));
+            return LIBUSB_ERROR_OTHER;
+        }
+    }
+
+    dev_interface_data.cbSize = sizeof(SP_DEVICE_INTERFACE_DATA);
+    if(!pSetupDiEnumDeviceInterfaces(*dev_info, NULL, libusb0_guid, _index, &dev_interface_data)) {
+        if(GetLastError() != ERROR_NO_MORE_ITEMS) {
+            usbi_err(ctx, "Could not obtain interface data for index %lu: %s", ULONG_CAST(_index), windows_error_str(0));
+            goto err_exit;
+        }
+
+        pSetupDiDestroyDeviceInfoList(*dev_info);
+        *dev_info = INVALID_HANDLE_VALUE;
+        return LIBUSB_SUCCESS;
+    }
+
+    // Read interface data (dummy + actual) to access the device path
+    if(!pSetupDiGetDeviceInterfaceDetailA(*dev_info, &dev_interface_data, NULL, 0, &size, NULL)) {
+        // The dummy call should fail with ERROR_INSUFFICIENT_BUFFER
+        if(GetLastError() != ERROR_INSUFFICIENT_BUFFER) {
+            usbi_err(ctx, "could not access interface data (dummy) for index %lu: %s", ULONG_CAST(_index), windows_error_str(0));
+            goto err_exit;
+        }
+    }
+    else {
+        usbi_err(ctx, "program assertion failed - http://msdn.microsoft.com/en-us/library/ms792901.aspx is wrong");
+        goto err_exit;
+    }
+
+    dev_interface_details = malloc(size);
+    if(dev_interface_details == NULL) {
+        usbi_err(ctx, "could not allocate interface data for index %lu", ULONG_CAST(_index));
+        err = LIBUSB_ERROR_NO_MEM;
+        goto err_exit;
+    }
+
+    dev_interface_details->cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA_A);
+    if(!pSetupDiGetDeviceInterfaceDetailA(*dev_info, &dev_interface_data, dev_interface_details, size, NULL, NULL)) {
+        usbi_err(ctx, "could not access interface data (actual) for index %lu: %s", ULONG_CAST(_index), windows_error_str(0));
+        free(dev_interface_details);
+        goto err_exit;
+    }
+
+    *dev_interface_path = normalize_path(dev_interface_details->DevicePath);
+    free(dev_interface_details);
+
+    if(*dev_interface_path == NULL) {
+        usbi_err(ctx, "could not allocate interface path for index %lu", ULONG_CAST(_index));
+        err = LIBUSB_ERROR_NO_MEM;
+        goto err_exit;
+    }
+
+    // [trobinso] lookup the libusb0 symbolic index.
+    hkey_dev_interface = pSetupDiOpenDeviceInterfaceRegKey(*dev_info, &dev_interface_data, 0, KEY_READ);
+    if(hkey_dev_interface != INVALID_HANDLE_VALUE) {
+        DWORD libusb0_symboliclink_index = 0;
+        DWORD value_length               = sizeof(DWORD);
+        LONG  status;
+
+        status = pRegQueryValueExA(hkey_dev_interface, "LUsb0", NULL, NULL, (LPBYTE)&libusb0_symboliclink_index, &value_length);
+        if(status == ERROR_SUCCESS) {
+            if(libusb0_symboliclink_index < 256) {
+                // libusb0.sys is connected to this device instance.
+                // If the the device interface guid is {F9F3FF14-AE21-48A0-8A25-8011A7A931D9} then it's a filter.
+                sprintf(filter_path, "\\\\.\\libusb0-%04u", (unsigned int)libusb0_symboliclink_index);
+                usbi_dbg(ctx, "assigned libusb0 symbolic link %s", filter_path);
+            }
+            else {
+                // libusb0.sys was connected to this device instance at one time; but not anymore.
+            }
+        }
+        pRegCloseKey(hkey_dev_interface);
+    }
+    else {
+        usbi_warn(ctx, "could not open device interface registry key for index %lu: %s", ULONG_CAST(_index), windows_error_str(0));
+        // TODO: should this be an error?
+    }
+
+    return LIBUSB_SUCCESS;
+
+err_exit:
+    pSetupDiDestroyDeviceInfoList(*dev_info);
+    *dev_info = INVALID_HANDLE_VALUE;
+    return err;
+}
+
+/*
+ * Returns the first known ancestor of a device
+ */
+static struct libusb_device *get_ancestor(struct libusb_context *ctx, DEVINST devinst, PDEVINST _parent_devinst) {
+    struct libusb_device *dev = NULL;
+    DEVINST               parent_devinst;
+
+    while(dev == NULL) {
+        if(CM_Get_Parent(&parent_devinst, devinst, 0) != CR_SUCCESS)
+            break;
+        devinst = parent_devinst;
+        dev     = usbi_get_device_by_session_id(ctx, (unsigned long)devinst);
+    }
+
+    if((dev != NULL) && (_parent_devinst != NULL))
+        *_parent_devinst = devinst;
+
+    return dev;
+}
+
+/*
+ * Determine which interface the given endpoint address belongs to
+ */
+static int get_interface_by_endpoint(struct libusb_config_descriptor *conf_desc, uint8_t ep) {
+    const struct libusb_interface            *intf;
+    const struct libusb_interface_descriptor *intf_desc;
+    uint8_t                                   i, k;
+    int                                       j;
+
+    for(i = 0; i < conf_desc->bNumInterfaces; i++) {
+        intf = &conf_desc->interface[i];
+        for(j = 0; j < intf->num_altsetting; j++) {
+            intf_desc = &intf->altsetting[j];
+            for(k = 0; k < intf_desc->bNumEndpoints; k++) {
+                if(intf_desc->endpoint[k].bEndpointAddress == ep) {
+                    usbi_dbg(NULL, "found endpoint %02X on interface %d", intf_desc->bInterfaceNumber, i);
+                    return intf_desc->bInterfaceNumber;
+                }
+            }
+        }
+    }
+
+    usbi_dbg(NULL, "endpoint %02X not found on any interface", ep);
+    return LIBUSB_ERROR_NOT_FOUND;
+}
+
+static const struct libusb_interface_descriptor *get_interface_descriptor_by_number(struct libusb_device_handle     *dev_handle,
+                                                                                    struct libusb_config_descriptor *conf_desc, int iface, uint8_t altsetting) {
+    int i;
+
+    for(i = 0; i < conf_desc->bNumInterfaces; i++) {
+        if(altsetting < conf_desc->interface[i].num_altsetting && conf_desc->interface[i].altsetting[altsetting].bInterfaceNumber == iface) {
+            return &conf_desc->interface[i].altsetting[altsetting];
+        }
+    }
+
+    usbi_err(HANDLE_CTX(dev_handle), "interface %d with altsetting %d not found for device", iface, (int)altsetting);
+    return NULL;
+}
+
+/*
+ * Open a device and associate the HANDLE with the context's I/O completion port
+ */
+static HANDLE windows_open(struct libusb_device_handle *dev_handle, const char *path, DWORD access) {
+    struct libusb_context       *ctx  = HANDLE_CTX(dev_handle);
+    struct windows_context_priv *priv = usbi_get_context_priv(ctx);
+    HANDLE                       handle;
+
+    handle = CreateFileA(path, access, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL);
+    if(handle == INVALID_HANDLE_VALUE)
+        return handle;
+
+    if(CreateIoCompletionPort(handle, priv->completion_port, (ULONG_PTR)dev_handle, 0) == NULL) {
+        usbi_err(ctx, "failed to associate handle to I/O completion port: %s", windows_error_str(0));
+        CloseHandle(handle);
+        return INVALID_HANDLE_VALUE;
+    }
+
+    return handle;
+}
+
+/*
+ * Populate the endpoints addresses of the device_priv interface helper structs
+ */
+static int windows_assign_endpoints(struct libusb_device_handle *dev_handle, uint8_t iface, uint8_t altsetting) {
+    struct winusb_device_priv                *priv = usbi_get_device_priv(dev_handle->dev);
+    struct libusb_config_descriptor          *conf_desc;
+    const struct libusb_interface_descriptor *if_desc;
+    int                                       i, r;
+
+    r = libusb_get_active_config_descriptor(dev_handle->dev, &conf_desc);
+    if(r != LIBUSB_SUCCESS) {
+        usbi_warn(HANDLE_CTX(dev_handle), "could not read config descriptor: error %d", r);
+        return r;
+    }
+
+    if_desc = get_interface_descriptor_by_number(dev_handle, conf_desc, iface, altsetting);
+    if(if_desc == NULL) {
+        r = LIBUSB_ERROR_NOT_FOUND;
+        goto end;
+    }
+
+    safe_free(priv->usb_interface[iface].endpoint);
+
+    if(if_desc->bNumEndpoints == 0) {
+        usbi_dbg(HANDLE_CTX(dev_handle), "no endpoints found for interface %u", iface);
+    }
+    else {
+        priv->usb_interface[iface].endpoint = malloc(if_desc->bNumEndpoints);
+        if(priv->usb_interface[iface].endpoint == NULL) {
+            r = LIBUSB_ERROR_NO_MEM;
+            goto end;
+        }
+        priv->usb_interface[iface].nb_endpoints = if_desc->bNumEndpoints;
+        for(i = 0; i < if_desc->bNumEndpoints; i++) {
+            priv->usb_interface[iface].endpoint[i] = if_desc->endpoint[i].bEndpointAddress;
+            usbi_dbg(HANDLE_CTX(dev_handle), "(re)assigned endpoint %02X to interface %u", priv->usb_interface[iface].endpoint[i], iface);
+        }
+    }
+
+    // Extra init may be required to configure endpoints
+    if(priv->apib->configure_endpoints)
+        r = priv->apib->configure_endpoints(SUB_API_NOTSET, dev_handle, iface);
+
+    if(r == LIBUSB_SUCCESS)
+        priv->usb_interface[iface].current_altsetting = altsetting;
+
+end:
+    libusb_free_config_descriptor(conf_desc);
+    return r;
+}
+
+// Lookup for a match in the list of API driver names
+// return -1 if not found, driver match number otherwise
+static int get_sub_api(char *driver, int api) {
+    const char sep_str[2] = { LIST_SEPARATOR, 0 };
+    char      *tok, *tmp_str;
+    size_t     len = strlen(driver);
+    int        i;
+
+    if(len == 0)
+        return SUB_API_NOTSET;
+
+    tmp_str = _strdup(driver);
+    if(tmp_str == NULL)
+        return SUB_API_NOTSET;
+
+    tok = strtok(tmp_str, sep_str);
+    while(tok != NULL) {
+        for(i = 0; i < usb_api_backend[api].nb_driver_names; i++) {
+            if(_stricmp(tok, usb_api_backend[api].driver_name_list[i]) == 0) {
+                free(tmp_str);
+                return i;
+            }
+        }
+        tok = strtok(NULL, sep_str);
+    }
+
+    free(tmp_str);
+    return SUB_API_NOTSET;
+}
+
+/*
+ * auto-claiming and auto-release helper functions
+ */
+static int auto_claim(struct libusb_transfer *transfer, int *interface_number, int api_type) {
+    struct winusb_device_handle_priv *handle_priv       = get_winusb_device_handle_priv(transfer->dev_handle);
+    struct winusb_device_priv        *priv              = usbi_get_device_priv(transfer->dev_handle->dev);
+    int                               current_interface = *interface_number;
+    int                               r                 = LIBUSB_SUCCESS;
+
+    switch(api_type) {
+    case USB_API_WINUSBX:
+    case USB_API_HID:
+        break;
+    default:
+        return LIBUSB_ERROR_INVALID_PARAM;
+    }
+
+    usbi_mutex_lock(&autoclaim_lock);
+    if(current_interface < 0) {  // No serviceable interface was found
+        for(current_interface = 0; current_interface < USB_MAXINTERFACES; current_interface++) {
+            // Must claim an interface of the same API type
+            if((priv->usb_interface[current_interface].apib->id == api_type)
+               && (libusb_claim_interface(transfer->dev_handle, current_interface) == LIBUSB_SUCCESS)) {
+                usbi_dbg(TRANSFER_CTX(transfer), "auto-claimed interface %d for control request", current_interface);
+                if(handle_priv->autoclaim_count[current_interface] != 0)
+                    usbi_err(TRANSFER_CTX(transfer), "program assertion failed - autoclaim_count was nonzero");
+                handle_priv->autoclaim_count[current_interface]++;
+                break;
+            }
+        }
+        if(current_interface == USB_MAXINTERFACES) {
+            usbi_err(TRANSFER_CTX(transfer), "could not auto-claim any interface");
+            r = LIBUSB_ERROR_NOT_FOUND;
+        }
+    }
+    else {
+        // If we have a valid interface that was autoclaimed, we must increment
+        // its autoclaim count so that we can prevent an early release.
+        if(handle_priv->autoclaim_count[current_interface] != 0)
+            handle_priv->autoclaim_count[current_interface]++;
+    }
+    usbi_mutex_unlock(&autoclaim_lock);
+
+    *interface_number = current_interface;
+    return r;
+}
+
+static void auto_release(struct usbi_transfer *itransfer) {
+    struct winusb_transfer_priv      *transfer_priv = get_winusb_transfer_priv(itransfer);
+    struct libusb_transfer           *transfer      = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+    libusb_device_handle             *dev_handle    = transfer->dev_handle;
+    struct winusb_device_handle_priv *handle_priv   = get_winusb_device_handle_priv(dev_handle);
+    int                               r;
+
+    usbi_mutex_lock(&autoclaim_lock);
+    if(handle_priv->autoclaim_count[transfer_priv->interface_number] > 0) {
+        handle_priv->autoclaim_count[transfer_priv->interface_number]--;
+        if(handle_priv->autoclaim_count[transfer_priv->interface_number] == 0) {
+            r = libusb_release_interface(dev_handle, transfer_priv->interface_number);
+            if(r == LIBUSB_SUCCESS)
+                usbi_dbg(ITRANSFER_CTX(itransfer), "auto-released interface %d", transfer_priv->interface_number);
+            else
+                usbi_dbg(ITRANSFER_CTX(itransfer), "failed to auto-release interface %d (%s)", transfer_priv->interface_number,
+                         libusb_error_name((enum libusb_error)r));
+        }
+    }
+    usbi_mutex_unlock(&autoclaim_lock);
+}
+
+/*
+ * init: libusb backend init function
+ */
+static int winusb_init(struct libusb_context *ctx) {
+    int i;
+
+    // Load DLL imports
+    if(!init_dlls(ctx)) {
+        usbi_err(ctx, "could not resolve DLL functions");
+        return LIBUSB_ERROR_OTHER;
+    }
+
+    // Initialize the low level APIs (we don't care about errors at this stage)
+    for(i = 0; i < USB_API_MAX; i++) {
+        if(usb_api_backend[i].init && !usb_api_backend[i].init(ctx))
+            usbi_warn(ctx, "error initializing %s backend", usb_api_backend[i].designation);
+    }
+
+    // We need a lock for proper auto-release
+    usbi_mutex_init(&autoclaim_lock);
+
+    return LIBUSB_SUCCESS;
+}
+
+/*
+ * exit: libusb backend deinitialization function
+ */
+static void winusb_exit(struct libusb_context *ctx) {
+    int i;
+
+    UNUSED(ctx);
+
+    usbi_mutex_destroy(&autoclaim_lock);
+
+    for(i = 0; i < USB_API_MAX; i++) {
+        if(usb_api_backend[i].exit)
+            usb_api_backend[i].exit();
+    }
+
+    exit_dlls();
+}
+
+/*
+ * fetch and cache all the config descriptors through I/O
+ */
+static void cache_config_descriptors(struct libusb_device *dev, HANDLE hub_handle) {
+    struct libusb_context     *ctx  = DEVICE_CTX(dev);
+    struct winusb_device_priv *priv = usbi_get_device_priv(dev);
+    DWORD                      size, ret_size;
+    uint8_t                    i, num_configurations;
+
+    USB_CONFIGURATION_DESCRIPTOR_SHORT cd_buf_short;          // dummy request
+    PUSB_DESCRIPTOR_REQUEST            cd_buf_actual = NULL;  // actual request
+    PUSB_CONFIGURATION_DESCRIPTOR      cd_data;
+
+    num_configurations = dev->device_descriptor.bNumConfigurations;
+    if(num_configurations == 0)
+        return;
+
+    assert(sizeof(USB_DESCRIPTOR_REQUEST) == USB_DESCRIPTOR_REQUEST_SIZE);
+
+    priv->config_descriptor = calloc(num_configurations, sizeof(PUSB_CONFIGURATION_DESCRIPTOR));
+    if(priv->config_descriptor == NULL) {
+        usbi_err(ctx, "could not allocate configuration descriptor array for '%s'", priv->dev_id);
+        return;
+    }
+
+    for(i = 0; i <= num_configurations; i++) {
+        safe_free(cd_buf_actual);
+
+        if(i == num_configurations)
+            break;
+
+        size = sizeof(cd_buf_short);
+        memset(&cd_buf_short.desc, 0, sizeof(cd_buf_short.desc));
+
+        cd_buf_short.req.ConnectionIndex       = (ULONG)dev->port_number;
+        cd_buf_short.req.SetupPacket.bmRequest = LIBUSB_ENDPOINT_IN;
+        cd_buf_short.req.SetupPacket.bRequest  = LIBUSB_REQUEST_GET_DESCRIPTOR;
+        cd_buf_short.req.SetupPacket.wValue    = (LIBUSB_DT_CONFIG << 8) | i;
+        cd_buf_short.req.SetupPacket.wIndex    = 0;
+        cd_buf_short.req.SetupPacket.wLength   = (USHORT)sizeof(USB_CONFIGURATION_DESCRIPTOR);
+
+        // Dummy call to get the required data size. Initial failures are reported as info rather
+        // than error as they can occur for non-penalizing situations, such as with some hubs.
+        // coverity[tainted_data_argument]
+        if(!DeviceIoControl(hub_handle, IOCTL_USB_GET_DESCRIPTOR_FROM_NODE_CONNECTION, &cd_buf_short, size, &cd_buf_short, size, &ret_size, NULL)) {
+            usbi_info(ctx, "could not access configuration descriptor %u (dummy) for '%s': %s", i, priv->dev_id, windows_error_str(0));
+            continue;
+        }
+
+        if((ret_size != size) || (cd_buf_short.desc.wTotalLength < sizeof(USB_CONFIGURATION_DESCRIPTOR))) {
+            usbi_info(ctx, "unexpected configuration descriptor %u size (dummy) for '%s'", i, priv->dev_id);
+            continue;
+        }
+
+        size          = sizeof(USB_DESCRIPTOR_REQUEST) + cd_buf_short.desc.wTotalLength;
+        cd_buf_actual = malloc(size);
+        if(cd_buf_actual == NULL) {
+            usbi_err(ctx, "could not allocate configuration descriptor %u buffer for '%s'", i, priv->dev_id);
+            continue;
+        }
+
+        // Actual call
+        cd_buf_actual->ConnectionIndex       = (ULONG)dev->port_number;
+        cd_buf_actual->SetupPacket.bmRequest = LIBUSB_ENDPOINT_IN;
+        cd_buf_actual->SetupPacket.bRequest  = LIBUSB_REQUEST_GET_DESCRIPTOR;
+        cd_buf_actual->SetupPacket.wValue    = (LIBUSB_DT_CONFIG << 8) | i;
+        cd_buf_actual->SetupPacket.wIndex    = 0;
+        cd_buf_actual->SetupPacket.wLength   = cd_buf_short.desc.wTotalLength;
+
+        if(!DeviceIoControl(hub_handle, IOCTL_USB_GET_DESCRIPTOR_FROM_NODE_CONNECTION, cd_buf_actual, size, cd_buf_actual, size, &ret_size, NULL)) {
+            usbi_err(ctx, "could not access configuration descriptor %u (actual) for '%s': %s", i, priv->dev_id, windows_error_str(0));
+            continue;
+        }
+
+        cd_data = (PUSB_CONFIGURATION_DESCRIPTOR)((UCHAR *)cd_buf_actual + USB_DESCRIPTOR_REQUEST_SIZE);
+
+        if((size != ret_size) || (cd_data->wTotalLength != cd_buf_short.desc.wTotalLength)) {
+            usbi_err(ctx, "unexpected configuration descriptor %u size (actual) for '%s'", i, priv->dev_id);
+            continue;
+        }
+
+        if(cd_data->bDescriptorType != LIBUSB_DT_CONFIG) {
+            usbi_err(ctx, "descriptor %u not a configuration descriptor for '%s'", i, priv->dev_id);
+            continue;
+        }
+
+        usbi_dbg(ctx, "cached config descriptor %u (bConfigurationValue=%u, %u bytes)", i, cd_data->bConfigurationValue, cd_data->wTotalLength);
+
+        // Cache the descriptor
+        priv->config_descriptor[i] = cd_data;
+        cd_buf_actual              = NULL;
+    }
+}
+
+#define ROOT_HUB_FS_CONFIG_DESC_LENGTH 0x19
+#define ROOT_HUB_HS_CONFIG_DESC_LENGTH 0x19
+#define ROOT_HUB_SS_CONFIG_DESC_LENGTH 0x1f
+#define CONFIG_DESC_WTOTAL_LENGTH_OFFSET 0x02
+#define CONFIG_DESC_EP_MAX_PACKET_OFFSET 0x16
+#define CONFIG_DESC_EP_BINTERVAL_OFFSET 0x18
+
+static const uint8_t root_hub_config_descriptor_template[] = {
+    // Configuration Descriptor
+    LIBUSB_DT_CONFIG_SIZE,  // bLength
+    LIBUSB_DT_CONFIG,       // bDescriptorType
+    0x00, 0x00,             // wTotalLength (filled in)
+    0x01,                   // bNumInterfaces
+    0x01,                   // bConfigurationValue
+    0x00,                   // iConfiguration
+    0xc0,                   // bmAttributes (reserved + self-powered)
+    0x00,                   // bMaxPower
+    // Interface Descriptor
+    LIBUSB_DT_INTERFACE_SIZE,  // bLength
+    LIBUSB_DT_INTERFACE,       // bDescriptorType
+    0x00,                      // bInterfaceNumber
+    0x00,                      // bAlternateSetting
+    0x01,                      // bNumEndpoints
+    LIBUSB_CLASS_HUB,          // bInterfaceClass
+    0x00,                      // bInterfaceSubClass
+    0x00,                      // bInterfaceProtocol
+    0x00,                      // iInterface
+    // Endpoint Descriptor
+    LIBUSB_DT_ENDPOINT_SIZE,  // bLength
+    LIBUSB_DT_ENDPOINT,       // bDescriptorType
+    0x81,                     // bEndpointAddress
+    0x03,                     // bmAttributes (Interrupt)
+    0x00, 0x00,               // wMaxPacketSize (filled in)
+    0x00,                     // bInterval (filled in)
+    // SuperSpeed Endpoint Companion Descriptor
+    LIBUSB_DT_SS_ENDPOINT_COMPANION_SIZE,  // bLength
+    LIBUSB_DT_SS_ENDPOINT_COMPANION,       // bDescriptorType
+    0x00,                                  // bMaxBurst
+    0x00,                                  // bmAttributes
+    0x02, 0x00                             // wBytesPerInterval
+};
+
+static int alloc_root_hub_config_desc(struct libusb_device *dev, ULONG num_ports, uint8_t config_desc_length, uint8_t ep_interval) {
+    struct winusb_device_priv *priv = usbi_get_device_priv(dev);
+    uint8_t                   *ptr;
+
+    priv->config_descriptor = malloc(sizeof(*priv->config_descriptor));
+    if(priv->config_descriptor == NULL)
+        return LIBUSB_ERROR_NO_MEM;
+
+    // Most config descriptors come from cache_config_descriptors() which obtains the
+    // descriptors from the hub using an allocated USB_DESCRIPTOR_REQUEST structure.
+    // To avoid an extra malloc + memcpy we just hold on to the USB_DESCRIPTOR_REQUEST
+    // structure we already have and back up the pointer in windows_device_priv_release()
+    // when freeing the descriptors. To keep a single execution path, we need to offset
+    // the pointer here by the same amount.
+    ptr = malloc(USB_DESCRIPTOR_REQUEST_SIZE + config_desc_length);
+    if(ptr == NULL)
+        return LIBUSB_ERROR_NO_MEM;
+
+    ptr += USB_DESCRIPTOR_REQUEST_SIZE;
+
+    memcpy(ptr, root_hub_config_descriptor_template, config_desc_length);
+    ptr[CONFIG_DESC_WTOTAL_LENGTH_OFFSET] = config_desc_length;
+    ptr[CONFIG_DESC_EP_MAX_PACKET_OFFSET] = (uint8_t)((num_ports + 7) / 8);
+    ptr[CONFIG_DESC_EP_BINTERVAL_OFFSET]  = ep_interval;
+
+    priv->config_descriptor[0] = (PUSB_CONFIGURATION_DESCRIPTOR)ptr;
+    priv->active_config        = 1;
+
+    return 0;
+}
+
+static int init_root_hub(struct libusb_device *dev) {
+    struct libusb_context                *ctx  = DEVICE_CTX(dev);
+    struct winusb_device_priv            *priv = usbi_get_device_priv(dev);
+    USB_NODE_CONNECTION_INFORMATION_EX    conn_info;
+    USB_NODE_CONNECTION_INFORMATION_EX_V2 conn_info_v2;
+    USB_NODE_INFORMATION                  hub_info;
+    enum libusb_speed                     speed = LIBUSB_SPEED_UNKNOWN;
+    uint8_t                               config_desc_length;
+    uint8_t                               ep_interval;
+    HANDLE                                handle;
+    ULONG                                 port_number, num_ports;
+    DWORD                                 size;
+    int                                   r;
+
+    // Determining the speed of a root hub is painful. Microsoft does not directly report the speed
+    // capabilities of the root hub itself, only its ports and/or connected devices. Therefore we
+    // are forced to query each individual port of the root hub to try and infer the root hub's
+    // speed. Note that we have to query all ports because the presence of a device on that port
+    // changes if/how Windows returns any useful speed information.
+    handle = CreateFileA(priv->path, GENERIC_WRITE, FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL);
+    if(handle == INVALID_HANDLE_VALUE) {
+        usbi_err(ctx, "could not open root hub %s: %s", priv->path, windows_error_str(0));
+        return LIBUSB_ERROR_ACCESS;
+    }
+
+    if(!DeviceIoControl(handle, IOCTL_USB_GET_NODE_INFORMATION, NULL, 0, &hub_info, sizeof(hub_info), &size, NULL)) {
+        usbi_warn(ctx, "could not get root hub info for '%s': %s", priv->dev_id, windows_error_str(0));
+        CloseHandle(handle);
+        return LIBUSB_ERROR_ACCESS;
+    }
+
+    num_ports = hub_info.u.HubInformation.HubDescriptor.bNumberOfPorts;
+    usbi_dbg(ctx, "root hub '%s' reports %lu ports", priv->dev_id, ULONG_CAST(num_ports));
+
+    if(windows_version >= WINDOWS_8) {
+        // Windows 8 and later is better at reporting the speed capabilities of the root hub,
+        // but it is not perfect. If no device is attached to the port being queried, the
+        // returned information will only indicate whether that port supports USB 3.0 signalling.
+        // That is not enough information to distinguish between SuperSpeed and SuperSpeed Plus.
+        for(port_number = 1; port_number <= num_ports; port_number++) {
+            conn_info_v2.ConnectionIndex              = port_number;
+            conn_info_v2.Length                       = sizeof(conn_info_v2);
+            conn_info_v2.SupportedUsbProtocols.Usb300 = 1;
+            if(!DeviceIoControl(handle, IOCTL_USB_GET_NODE_CONNECTION_INFORMATION_EX_V2, &conn_info_v2, sizeof(conn_info_v2), &conn_info_v2,
+                                sizeof(conn_info_v2), &size, NULL)) {
+                usbi_warn(ctx, "could not get node connection information (V2) for root hub '%s' port %lu: %s", priv->dev_id, ULONG_CAST(port_number),
+                          windows_error_str(0));
+                break;
+            }
+
+            if(conn_info_v2.Flags.DeviceIsSuperSpeedPlusCapableOrHigher)
+                speed = MAX(speed, LIBUSB_SPEED_SUPER_PLUS);
+            else if(conn_info_v2.Flags.DeviceIsSuperSpeedCapableOrHigher || conn_info_v2.SupportedUsbProtocols.Usb300)
+                speed = MAX(speed, LIBUSB_SPEED_SUPER);
+            else if(conn_info_v2.SupportedUsbProtocols.Usb200)
+                speed = MAX(speed, LIBUSB_SPEED_HIGH);
+            else
+                speed = MAX(speed, LIBUSB_SPEED_FULL);
+        }
+
+        if(speed != LIBUSB_SPEED_UNKNOWN)
+            goto make_descriptors;
+    }
+
+    // At this point the speed is still not known, most likely because we are executing on
+    // Windows 7 or earlier. The following hackery peeks into the root hub's Device ID and
+    // tries to extract speed information from it, based on observed naming conventions.
+    // If this does not work, we will query individual ports of the root hub.
+    if(strstr(priv->dev_id, "ROOT_HUB31") != NULL)
+        speed = LIBUSB_SPEED_SUPER_PLUS;
+    else if(strstr(priv->dev_id, "ROOT_HUB30") != NULL)
+        speed = LIBUSB_SPEED_SUPER;
+    else if(strstr(priv->dev_id, "ROOT_HUB20") != NULL)
+        speed = LIBUSB_SPEED_HIGH;
+
+    if(speed != LIBUSB_SPEED_UNKNOWN)
+        goto make_descriptors;
+
+    // Windows only reports speed information about a connected device. This means that a root
+    // hub with no connected devices or devices that are all operating at a speed less than the
+    // highest speed that the root hub supports will not give us the correct speed.
+    for(port_number = 1; port_number <= num_ports; port_number++) {
+        conn_info.ConnectionIndex = port_number;
+        if(!DeviceIoControl(handle, IOCTL_USB_GET_NODE_CONNECTION_INFORMATION_EX, &conn_info, sizeof(conn_info), &conn_info, sizeof(conn_info), &size, NULL)) {
+            usbi_warn(ctx, "could not get node connection information for root hub '%s' port %lu: %s", priv->dev_id, ULONG_CAST(port_number),
+                      windows_error_str(0));
+            continue;
+        }
+
+        if(conn_info.ConnectionStatus != DeviceConnected)
+            continue;
+
+        if(conn_info.Speed == UsbHighSpeed) {
+            speed = LIBUSB_SPEED_HIGH;
+            break;
+        }
+    }
+
+make_descriptors:
+    CloseHandle(handle);
+
+    dev->device_descriptor.bLength         = LIBUSB_DT_DEVICE_SIZE;
+    dev->device_descriptor.bDescriptorType = LIBUSB_DT_DEVICE;
+    dev->device_descriptor.bDeviceClass    = LIBUSB_CLASS_HUB;
+    if((dev->device_descriptor.idVendor == 0) && (dev->device_descriptor.idProduct == 0)) {
+        dev->device_descriptor.idVendor  = 0x1d6b;  // Linux Foundation
+        dev->device_descriptor.idProduct = (uint16_t)speed;
+    }
+    dev->device_descriptor.bcdDevice          = 0x0100;
+    dev->device_descriptor.bNumConfigurations = 1;
+
+    switch(speed) {
+    case LIBUSB_SPEED_SUPER_PLUS:
+        dev->device_descriptor.bcdUSB = 0x0310;
+        config_desc_length            = ROOT_HUB_SS_CONFIG_DESC_LENGTH;
+        ep_interval                   = 0x0c;  // 256ms
+        break;
+    case LIBUSB_SPEED_SUPER:
+        dev->device_descriptor.bcdUSB = 0x0300;
+        config_desc_length            = ROOT_HUB_SS_CONFIG_DESC_LENGTH;
+        ep_interval                   = 0x0c;  // 256ms
+        break;
+    case LIBUSB_SPEED_HIGH:
+        dev->device_descriptor.bcdUSB = 0x0200;
+        config_desc_length            = ROOT_HUB_HS_CONFIG_DESC_LENGTH;
+        ep_interval                   = 0x0c;  // 256ms
+        break;
+    case LIBUSB_SPEED_LOW:  // Not used, but keeps compiler happy
+    case LIBUSB_SPEED_UNKNOWN:
+        // This case means absolutely no information about this root hub was determined.
+        // There is not much choice than to be pessimistic and label this as a
+        // full-speed device.
+        speed = LIBUSB_SPEED_FULL;
+        // fallthrough
+    case LIBUSB_SPEED_FULL:
+        dev->device_descriptor.bcdUSB = 0x0110;
+        config_desc_length            = ROOT_HUB_FS_CONFIG_DESC_LENGTH;
+        ep_interval                   = 0xff;  // 255ms
+        break;
+    default:  // Impossible, buts keeps compiler happy
+        usbi_err(ctx, "program assertion failed - unknown root hub speed");
+        return LIBUSB_ERROR_INVALID_PARAM;
+    }
+
+    if(speed >= LIBUSB_SPEED_SUPER) {
+        dev->device_descriptor.bDeviceProtocol = 0x03;  // USB 3.0 Hub
+        dev->device_descriptor.bMaxPacketSize0 = 0x09;  // 2^9 bytes
+    }
+    else {
+        dev->device_descriptor.bMaxPacketSize0 = 0x40;  // 64 bytes
+    }
+
+    dev->speed = speed;
+
+    r = alloc_root_hub_config_desc(dev, num_ports, config_desc_length, ep_interval);
+    if(r)
+        usbi_err(ctx, "could not allocate config descriptor for root hub '%s'", priv->dev_id);
+
+    return r;
+}
+
+/*
+ * Populate a libusb device structure
+ */
+static int init_device(struct libusb_device *dev, struct libusb_device *parent_dev, uint8_t port_number, DEVINST devinst) {
+    struct libusb_context                *ctx = NULL;
+    struct libusb_device                 *tmp_dev;
+    struct winusb_device_priv            *priv, *parent_priv, *tmp_priv;
+    USB_NODE_CONNECTION_INFORMATION_EX    conn_info;
+    USB_NODE_CONNECTION_INFORMATION_EX_V2 conn_info_v2;
+    HANDLE                                hub_handle;
+    DWORD                                 size;
+    uint8_t                               bus_number, depth;
+    int                                   r;
+    int                                   ginfotimeout;
+
+    priv = usbi_get_device_priv(dev);
+
+    // If the device is already initialized, we can stop here
+    if(priv->initialized)
+        return LIBUSB_SUCCESS;
+
+    if(parent_dev != NULL) {  // Not a HCD root hub
+        ctx         = DEVICE_CTX(dev);
+        parent_priv = usbi_get_device_priv(parent_dev);
+        if(parent_priv->apib->id != USB_API_HUB) {
+            usbi_warn(ctx, "parent for device '%s' is not a hub", priv->dev_id);
+            return LIBUSB_ERROR_NOT_FOUND;
+        }
+
+        // Calculate depth and fetch bus number
+        bus_number = parent_dev->bus_number;
+        if(bus_number == 0) {
+            tmp_dev = get_ancestor(ctx, devinst, &devinst);
+            if(tmp_dev != parent_dev) {
+                usbi_err(ctx, "program assertion failed - first ancestor is not parent");
+                return LIBUSB_ERROR_NOT_FOUND;
+            }
+            libusb_unref_device(tmp_dev);
+
+            for(depth = 1; bus_number == 0; depth++) {
+                tmp_dev = get_ancestor(ctx, devinst, &devinst);
+                if(tmp_dev == NULL) {
+                    usbi_warn(ctx, "ancestor for device '%s' not found at depth %u", priv->dev_id, depth);
+                    return LIBUSB_ERROR_NO_DEVICE;
+                }
+                if(tmp_dev->bus_number != 0) {
+                    bus_number = tmp_dev->bus_number;
+                    tmp_priv   = usbi_get_device_priv(tmp_dev);
+                    depth += tmp_priv->depth;
+                }
+                libusb_unref_device(tmp_dev);
+            }
+        }
+        else {
+            depth = parent_priv->depth + 1;
+        }
+
+        if(bus_number == 0) {
+            usbi_err(ctx, "program assertion failed - bus number not found for '%s'", priv->dev_id);
+            return LIBUSB_ERROR_NOT_FOUND;
+        }
+
+        dev->bus_number  = bus_number;
+        dev->port_number = port_number;
+        dev->parent_dev  = parent_dev;
+        priv->depth      = depth;
+
+        hub_handle = CreateFileA(parent_priv->path, GENERIC_WRITE, FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL);
+        if(hub_handle == INVALID_HANDLE_VALUE) {
+            usbi_warn(ctx, "could not open hub %s: %s", parent_priv->path, windows_error_str(0));
+            return LIBUSB_ERROR_ACCESS;
+        }
+
+        conn_info.ConnectionIndex = (ULONG)port_number;
+        // coverity[tainted_data_argument]
+        ginfotimeout = 20;
+        do {
+            if(!DeviceIoControl(hub_handle, IOCTL_USB_GET_NODE_CONNECTION_INFORMATION_EX, &conn_info, sizeof(conn_info), &conn_info, sizeof(conn_info), &size,
+                                NULL)) {
+                usbi_warn(ctx, "could not get node connection information for device '%s': %s", priv->dev_id, windows_error_str(0));
+                CloseHandle(hub_handle);
+                return LIBUSB_ERROR_NO_DEVICE;
+            }
+
+            if(conn_info.ConnectionStatus == NoDeviceConnected) {
+                usbi_err(ctx, "device '%s' is no longer connected!", priv->dev_id);
+                CloseHandle(hub_handle);
+                return LIBUSB_ERROR_NO_DEVICE;
+            }
+
+            if((conn_info.DeviceDescriptor.bLength != LIBUSB_DT_DEVICE_SIZE) || (conn_info.DeviceDescriptor.bDescriptorType != LIBUSB_DT_DEVICE)) {
+                SleepEx(50, TRUE);
+                continue;
+            }
+
+            static_assert(sizeof(dev->device_descriptor) == sizeof(conn_info.DeviceDescriptor), "mismatch between libusb and OS device descriptor sizes");
+            memcpy(&dev->device_descriptor, &conn_info.DeviceDescriptor, LIBUSB_DT_DEVICE_SIZE);
+            usbi_localize_device_descriptor(&dev->device_descriptor);
+
+            priv->active_config = conn_info.CurrentConfigurationValue;
+            if(priv->active_config == 0) {
+                usbi_dbg(ctx, "0x%x:0x%x found %u configurations (not configured)", dev->device_descriptor.idVendor, dev->device_descriptor.idProduct,
+                         dev->device_descriptor.bNumConfigurations);
+                SleepEx(50, TRUE);
+            }
+        } while(priv->active_config == 0 && --ginfotimeout >= 0);
+
+        if((conn_info.DeviceDescriptor.bLength != LIBUSB_DT_DEVICE_SIZE) || (conn_info.DeviceDescriptor.bDescriptorType != LIBUSB_DT_DEVICE)) {
+            usbi_err(ctx, "device '%s' has invalid descriptor!", priv->dev_id);
+            CloseHandle(hub_handle);
+            return LIBUSB_ERROR_OTHER;
+        }
+
+        if(priv->active_config == 0) {
+            usbi_info(ctx,
+                      "0x%x:0x%x found %u configurations but device isn't configured, "
+                      "forcing current configuration to 1",
+                      dev->device_descriptor.idVendor, dev->device_descriptor.idProduct, dev->device_descriptor.bNumConfigurations);
+            priv->active_config = 1;
+        }
+        else {
+            usbi_dbg(ctx, "found %u configurations (current config: %u)", dev->device_descriptor.bNumConfigurations, priv->active_config);
+        }
+
+        // Cache as many config descriptors as we can
+        cache_config_descriptors(dev, hub_handle);
+
+        // In their great wisdom, Microsoft decided to BREAK the USB speed report between Windows 7 and Windows 8
+        if(windows_version >= WINDOWS_8) {
+            conn_info_v2.ConnectionIndex              = (ULONG)port_number;
+            conn_info_v2.Length                       = sizeof(USB_NODE_CONNECTION_INFORMATION_EX_V2);
+            conn_info_v2.SupportedUsbProtocols.Usb300 = 1;
+            if(!DeviceIoControl(hub_handle, IOCTL_USB_GET_NODE_CONNECTION_INFORMATION_EX_V2, &conn_info_v2, sizeof(conn_info_v2), &conn_info_v2,
+                                sizeof(conn_info_v2), &size, NULL)) {
+                usbi_warn(ctx, "could not get node connection information (V2) for device '%s': %s", priv->dev_id, windows_error_str(0));
+            }
+            else if(conn_info_v2.Flags.DeviceIsOperatingAtSuperSpeedPlusOrHigher) {
+                conn_info.Speed = UsbSuperSpeedPlus;
+            }
+            else if(conn_info_v2.Flags.DeviceIsOperatingAtSuperSpeedOrHigher) {
+                conn_info.Speed = UsbSuperSpeed;
+            }
+        }
+
+        CloseHandle(hub_handle);
+
+        if(conn_info.DeviceAddress > UINT8_MAX)
+            usbi_err(ctx, "program assertion failed - device address overflow");
+
+        dev->device_address = (uint8_t)conn_info.DeviceAddress;
+
+        switch(conn_info.Speed) {
+        case UsbLowSpeed:
+            dev->speed = LIBUSB_SPEED_LOW;
+            break;
+        case UsbFullSpeed:
+            dev->speed = LIBUSB_SPEED_FULL;
+            break;
+        case UsbHighSpeed:
+            dev->speed = LIBUSB_SPEED_HIGH;
+            break;
+        case UsbSuperSpeed:
+            dev->speed = LIBUSB_SPEED_SUPER;
+            break;
+        case UsbSuperSpeedPlus:
+            dev->speed = LIBUSB_SPEED_SUPER_PLUS;
+            break;
+        default:
+            usbi_warn(ctx, "unknown device speed %u", conn_info.Speed);
+            break;
+        }
+    }
+    else {
+        r = init_root_hub(dev);
+        if(r)
+            return r;
+    }
+
+    r = usbi_sanitize_device(dev);
+    if(r)
+        return r;
+
+    priv->initialized = true;
+    dev->dev_path     = priv->path;
+    usbi_dbg(ctx, "(bus: %u, addr: %u, depth: %u, port: %u): '%s'", dev->bus_number, dev->device_address, priv->depth, dev->port_number, priv->dev_id);
+
+    return LIBUSB_SUCCESS;
+}
+
+static bool get_dev_port_number(HDEVINFO dev_info, SP_DEVINFO_DATA *dev_info_data, DWORD *port_nr) {
+    char  buffer[MAX_KEY_LENGTH];
+    DWORD size;
+
+    // First try SPDRP_LOCATION_INFORMATION, which returns a REG_SZ. The string *may* have a format
+    // similar to "Port_#0002.Hub_#000D", in which case we can extract the port number. However, we
+    // cannot extract the port if the returned string does not follow this format.
+    if(pSetupDiGetDeviceRegistryPropertyA(dev_info, dev_info_data, SPDRP_LOCATION_INFORMATION, NULL, (PBYTE)buffer, sizeof(buffer), NULL)) {
+        // Check for the required format.
+        if(strncmp(buffer, "Port_#", 6) == 0) {
+            *port_nr = atoi(buffer + 6);
+            return true;
+        }
+    }
+
+    // Next try SPDRP_LOCATION_PATHS, which returns a REG_MULTI_SZ (but we only examine the first
+    // string in it). Each path has a format similar to,
+    // "PCIROOT(B2)#PCI(0300)#PCI(0000)#USBROOT(0)#USB(1)#USB(2)#USBMI(3)", and the port number is
+    // the number within the last "USB(x)" token.
+    if(pSetupDiGetDeviceRegistryPropertyA(dev_info, dev_info_data, SPDRP_LOCATION_PATHS, NULL, (PBYTE)buffer, sizeof(buffer), NULL)) {
+        // Find the last "#USB(x)" substring
+        for(char *token = strrchr(buffer, '#'); token != NULL; token = strrchr(buffer, '#')) {
+            if(strncmp(token, "#USB(", 5) == 0) {
+                *port_nr = atoi(token + 5);
+                return true;
+            }
+            // Shorten the string and try again.
+            *token = '\0';
+        }
+    }
+
+    // Lastly, try SPDRP_ADDRESS, which returns a REG_DWORD. The address *may* be the port number,
+    // which is true for the Microsoft driver but may not be true for other drivers. However, we
+    // have no other options here but to accept what it returns.
+    return pSetupDiGetDeviceRegistryPropertyA(dev_info, dev_info_data, SPDRP_ADDRESS, NULL, (PBYTE)port_nr, sizeof(*port_nr), &size)
+           && (size == sizeof(*port_nr));
+}
+
+static int enumerate_hcd_root_hub(struct libusb_context *ctx, const char *dev_id, uint8_t bus_number, DEVINST devinst) {
+    struct libusb_device      *dev;
+    struct winusb_device_priv *priv;
+    unsigned long              session_id;
+    DEVINST                    child_devinst;
+
+    if(CM_Get_Child(&child_devinst, devinst, 0) != CR_SUCCESS) {
+        usbi_warn(ctx, "could not get child devinst for '%s'", dev_id);
+        return LIBUSB_SUCCESS;
+    }
+
+    session_id = (unsigned long)child_devinst;
+    dev        = usbi_get_device_by_session_id(ctx, session_id);
+    if(dev == NULL) {
+        usbi_err(ctx, "program assertion failed - HCD '%s' child not found", dev_id);
+        return LIBUSB_SUCCESS;
+    }
+
+    if(dev->bus_number == 0) {
+        // Only do this once
+        usbi_dbg(ctx, "assigning HCD '%s' bus number %u", dev_id, bus_number);
+        dev->bus_number = bus_number;
+
+        if(sscanf(dev_id, "PCI\\VEN_%04hx&DEV_%04hx%*s", &dev->device_descriptor.idVendor, &dev->device_descriptor.idProduct) != 2)
+            usbi_warn(ctx, "could not infer VID/PID of HCD root hub from '%s'", dev_id);
+
+        priv           = usbi_get_device_priv(dev);
+        priv->root_hub = true;
+    }
+
+    libusb_unref_device(dev);
+    return LIBUSB_SUCCESS;
+}
+
+// Returns the api type, or 0 if not found/unsupported
+static void get_api_type(HDEVINFO *dev_info, SP_DEVINFO_DATA *dev_info_data, int *api, int *sub_api) {
+    // Precedence for filter drivers vs driver is in the order of this array
+    struct driver_lookup lookup[3] = { { "\0\0", SPDRP_SERVICE, "driver" },
+                                       { "\0\0", SPDRP_UPPERFILTERS, "upper filter driver" },
+                                       { "\0\0", SPDRP_LOWERFILTERS, "lower filter driver" } };
+    DWORD                size, reg_type;
+    unsigned             k, l;
+    int                  i, j;
+
+    // Check the service & filter names to know the API we should use
+    for(k = 0; k < 3; k++) {
+        if(pSetupDiGetDeviceRegistryPropertyA(*dev_info, dev_info_data, lookup[k].reg_prop, &reg_type, (PBYTE)lookup[k].list, MAX_KEY_LENGTH, &size)) {
+            // Turn the REG_SZ SPDRP_SERVICE into REG_MULTI_SZ
+            if(lookup[k].reg_prop == SPDRP_SERVICE)
+                // our buffers are MAX_KEY_LENGTH + 1 so we can overflow if needed
+                lookup[k].list[strlen(lookup[k].list) + 1] = 0;
+
+            // MULTI_SZ is a pain to work with. Turn it into something much more manageable
+            // NB: none of the driver names we check against contain LIST_SEPARATOR,
+            // (currently ';'), so even if an unsupported one does, it's not an issue
+            for(l = 0; (lookup[k].list[l] != 0) || (lookup[k].list[l + 1] != 0); l++) {
+                if(lookup[k].list[l] == 0)
+                    lookup[k].list[l] = LIST_SEPARATOR;
+            }
+            usbi_dbg(NULL, "%s(s): %s", lookup[k].designation, lookup[k].list);
+        }
+        else {
+            if(GetLastError() != ERROR_INVALID_DATA)
+                usbi_dbg(NULL, "could not access %s: %s", lookup[k].designation, windows_error_str(0));
+            lookup[k].list[0] = 0;
+        }
+    }
+
+    for(i = 2; i < USB_API_MAX; i++) {
+        for(k = 0; k < 3; k++) {
+            j = get_sub_api(lookup[k].list, i);
+            if(j >= 0) {
+                usbi_dbg(NULL, "matched %s name against %s", lookup[k].designation,
+                         (i != USB_API_WINUSBX) ? usb_api_backend[i].designation : usb_api_backend[i].driver_name_list[j]);
+                *api     = i;
+                *sub_api = j;
+                return;
+            }
+        }
+    }
+}
+
+static int set_composite_interface(struct libusb_context *ctx, struct libusb_device *dev, char *dev_interface_path, char *device_id, int api, int sub_api) {
+    struct winusb_device_priv                            *priv = usbi_get_device_priv(dev);
+    int                                                   interface_number;
+    const char                                           *mi_str;
+    int                                                   iadi, iadintfi;
+    struct libusb_interface_association_descriptor_array *iad_array;
+    const struct libusb_interface_association_descriptor *iad;
+
+    // Because MI_## are not necessarily in sequential order (some composite
+    // devices will have only MI_00 & MI_03 for instance), we retrieve the actual
+    // interface number from the path's MI value
+    mi_str = strstr(device_id, "MI_");
+    if((mi_str != NULL) && isdigit((unsigned char)mi_str[3]) && isdigit((unsigned char)mi_str[4])) {
+        interface_number = ((mi_str[3] - '0') * 10) + (mi_str[4] - '0');
+    }
+    else {
+        usbi_warn(ctx, "failure to read interface number for %s, using default value", device_id);
+        interface_number = 0;
+    }
+
+    if(interface_number >= USB_MAXINTERFACES) {
+        usbi_warn(ctx, "interface %d too large - ignoring interface path %s", interface_number, dev_interface_path);
+        return LIBUSB_ERROR_ACCESS;
+    }
+
+    if(priv->usb_interface[interface_number].path != NULL) {
+        if(api == USB_API_HID) {
+            // HID devices can have multiple collections (COL##) for each MI_## interface
+            usbi_dbg(ctx, "interface[%d] already set - ignoring HID collection: %s", interface_number, device_id);
+            return LIBUSB_ERROR_ACCESS;
+        }
+        // In other cases, just use the latest data
+        safe_free(priv->usb_interface[interface_number].path);
+    }
+
+    usbi_dbg(ctx, "interface[%d] = %s", interface_number, dev_interface_path);
+    priv->usb_interface[interface_number].path    = dev_interface_path;
+    priv->usb_interface[interface_number].apib    = &usb_api_backend[api];
+    priv->usb_interface[interface_number].sub_api = sub_api;
+
+    // printf("%d, %s, %s\n", interface_number,  priv->path, dev_interface_path);
+    dev->interface_path[interface_number] = dev_interface_path;
+
+    if((api == USB_API_HID) && (priv->hid == NULL)) {
+        priv->hid = calloc(1, sizeof(struct hid_device_priv));
+        if(priv->hid == NULL)
+            return LIBUSB_ERROR_NO_MEM;
+    }
+
+    // For WinUSBX, set up associations for interfaces grouped by an IAD
+    if((api == USB_API_WINUSBX) && !libusb_get_active_interface_association_descriptors(dev, &iad_array)) {
+        for(iadi = 0; iadi < iad_array->length; iadi++) {
+            iad = &iad_array->iad[iadi];
+            if(iad->bFirstInterface == interface_number) {
+                priv->usb_interface[interface_number].num_associated_interfaces  = iad->bInterfaceCount;
+                priv->usb_interface[interface_number].first_associated_interface = iad->bFirstInterface;
+                for(iadintfi = 1; iadintfi < iad->bInterfaceCount; iadintfi++) {
+                    usbi_dbg(ctx, "interface[%d] is associated with interface[%d]", interface_number + iadintfi, interface_number);
+                    priv->usb_interface[interface_number + iadintfi].apib                       = &usb_api_backend[api];
+                    priv->usb_interface[interface_number + iadintfi].sub_api                    = sub_api;
+                    priv->usb_interface[interface_number + iadintfi].num_associated_interfaces  = iad->bInterfaceCount;
+                    priv->usb_interface[interface_number + iadintfi].first_associated_interface = iad->bFirstInterface;
+                }
+                break;
+            }
+        }
+        libusb_free_interface_association_descriptors(iad_array);
+    }
+
+    return LIBUSB_SUCCESS;
+}
+
+static int set_hid_interface(struct libusb_context *ctx, struct libusb_device *dev, char *dev_interface_path) {
+    struct winusb_device_priv *priv = usbi_get_device_priv(dev);
+    uint8_t                    i;
+
+    if(priv->hid == NULL) {
+        usbi_err(ctx, "program assertion failed - parent is not HID");
+        return LIBUSB_ERROR_NO_DEVICE;
+    }
+    else if(priv->hid->nb_interfaces == USB_MAXINTERFACES) {
+        usbi_err(ctx, "program assertion failed - max USB interfaces reached for HID device");
+        return LIBUSB_ERROR_NO_DEVICE;
+    }
+
+    for(i = 0; i < priv->hid->nb_interfaces; i++) {
+        if((priv->usb_interface[i].path != NULL) && strcmp(priv->usb_interface[i].path, dev_interface_path) == 0) {
+            usbi_dbg(ctx, "interface[%u] already set to %s", i, dev_interface_path);
+            return LIBUSB_ERROR_ACCESS;
+        }
+    }
+
+    priv->usb_interface[priv->hid->nb_interfaces].path = dev_interface_path;
+    priv->usb_interface[priv->hid->nb_interfaces].apib = &usb_api_backend[USB_API_HID];
+    usbi_dbg(ctx, "interface[%u] = %s", priv->hid->nb_interfaces, dev_interface_path);
+    // printf("hid >> %d, %s, %s\n", priv->hid->nb_interfaces, priv->path, dev_interface_path);
+
+    dev->interface_path[priv->hid->nb_interfaces] = dev_interface_path;
+
+    priv->hid->nb_interfaces++;
+    return LIBUSB_SUCCESS;
+}
+
+/*
+ * get_device_list: libusb backend device enumeration function
+ */
+static int winusb_get_device_list(struct libusb_context *ctx, struct discovered_devs **_discdevs) {
+    struct discovered_devs    *discdevs;
+    HDEVINFO                  *dev_info, dev_info_intf, dev_info_enum;
+    SP_DEVINFO_DATA            dev_info_data;
+    DWORD                      _index = 0;
+    GUID                       hid_guid;
+    int                        r = LIBUSB_SUCCESS;
+    int                        api, sub_api;
+    unsigned int               pass, i, j;
+    char                       enumerator[16];
+    char                       dev_id[MAX_PATH_LENGTH];
+    struct libusb_device      *dev, *parent_dev;
+    struct winusb_device_priv *priv, *parent_priv;
+    char                      *dev_interface_path = NULL;
+    unsigned long              session_id;
+    DWORD                      size, port_nr, reg_type, install_state;
+    HKEY                       key;
+    char                       guid_string[MAX_GUID_STRING_LENGTH];
+    GUID                      *if_guid;
+    LONG                       s;
+#define HUB_PASS 0
+#define OPENNI_PASS 1
+#define DEV_PASS 2
+#define HCD_PASS 3
+#define GEN_PASS 4
+#define HID_PASS 5
+#define EXT_PASS 6
+    // Keep a list of guids that will be enumerated
+#define GUID_SIZE_STEP 8
+    const GUID **guid_list, **new_guid_list;
+    unsigned int guid_size = GUID_SIZE_STEP;
+    unsigned int nb_guids;
+    // Keep a list of PnP enumerator strings that are found
+    const char  *usb_enumerator[8]  = { "USB" };
+    unsigned int nb_usb_enumerators = 1;
+    unsigned int usb_enum_index     = 0;
+    // Keep a list of newly allocated devs to unref
+#define UNREF_SIZE_STEP 16
+    libusb_device **unref_list, **new_unref_list;
+    unsigned int    unref_size = UNREF_SIZE_STEP;
+    unsigned int    unref_cur  = 0;
+
+    // PASS 1 : (re)enumerate HCDs (allows for HCD hotplug)
+    // PASS 2 : (re)enumerate HUBS
+    // PASS 3 : (re)enumerate generic USB devices (including driverless)
+    //           and list additional USB device interface GUIDs to explore
+    // PASS 4 : (re)enumerate master USB devices that have a device interface
+    // PASS 5+: (re)enumerate device interfaced GUIDs (including HID) and
+    //           set the device interfaces.
+
+    // Init the GUID table
+    guid_list = malloc(guid_size * sizeof(void *));
+    if(guid_list == NULL) {
+        usbi_err(ctx, "failed to alloc guid list");
+        return LIBUSB_ERROR_NO_MEM;
+    }
+
+    guid_list[HUB_PASS]    = &GUID_DEVINTERFACE_USB_HUB;
+    guid_list[DEV_PASS]    = &GUID_DEVINTERFACE_USB_DEVICE;
+    guid_list[OPENNI_PASS] = &GUID_DEVINTERFACE_OPENNI_USB_DEVICE;
+    guid_list[HCD_PASS]    = &GUID_DEVINTERFACE_USB_HOST_CONTROLLER;
+    guid_list[GEN_PASS]    = NULL;
+    if(HidD_GetHidGuid != NULL) {
+        HidD_GetHidGuid(&hid_guid);
+        guid_list[HID_PASS] = &hid_guid;
+    }
+    else {
+        guid_list[HID_PASS] = NULL;
+    }
+    nb_guids = EXT_PASS;
+
+    unref_list = malloc(unref_size * sizeof(void *));
+    if(unref_list == NULL) {
+        usbi_err(ctx, "failed to alloc unref list");
+        free((void *)guid_list);
+        return LIBUSB_ERROR_NO_MEM;
+    }
+
+    dev_info_intf = pSetupDiGetClassDevsA(NULL, NULL, NULL, DIGCF_ALLCLASSES | DIGCF_PRESENT | DIGCF_DEVICEINTERFACE);
+    if(dev_info_intf == INVALID_HANDLE_VALUE) {
+        usbi_err(ctx, "failed to obtain device info list: %s", windows_error_str(0));
+        free(unref_list);
+        free((void *)guid_list);
+        return LIBUSB_ERROR_OTHER;
+    }
+
+    for(pass = 0; ((pass < nb_guids) && (r == LIBUSB_SUCCESS)); pass++) {
+// #define ENUM_DEBUG
+#if defined(ENABLE_LOGGING) && defined(ENUM_DEBUG)
+        const char *const passname[] = { "HUB", "DEV", "HCD", "GEN", "HID", "EXT" };
+        usbi_dbg(ctx, "#### PROCESSING %ss %s", passname[MIN(pass, EXT_PASS)], guid_to_string(guid_list[pass], guid_string));
+#endif
+        if((pass == HID_PASS) && (guid_list[HID_PASS] == NULL))
+            continue;
+
+        dev_info = (pass != GEN_PASS) ? &dev_info_intf : &dev_info_enum;
+
+        for(i = 0;; i++) {
+            // safe loop: free up any (unprotected) dynamic resource
+            // NB: this is always executed before breaking the loop
+            safe_free(dev_interface_path);
+            priv = parent_priv = NULL;
+            dev = parent_dev = NULL;
+
+            // Safe loop: end of loop conditions
+            if(r != LIBUSB_SUCCESS)
+                break;
+
+            if((pass == HCD_PASS) && (i == UINT8_MAX)) {
+                usbi_warn(ctx, "program assertion failed - found more than %u buses, skipping the rest", UINT8_MAX);
+                break;
+            }
+
+            if(pass != GEN_PASS) {
+                // Except for GEN, all passes deal with device interfaces
+                r = get_interface_details(ctx, *dev_info, &dev_info_data, guid_list[pass], &_index, &dev_interface_path);
+                if((r != LIBUSB_SUCCESS) || (dev_interface_path == NULL)) {
+                    _index = 0;
+                    break;
+                }
+            }
+            else {
+                // Workaround for a Nec/Renesas USB 3.0 driver bug where root hubs are
+                // being listed under the "NUSB3" PnP Symbolic Name rather than "USB".
+                // The Intel USB 3.0 driver behaves similar, but uses "IUSB3"
+                // The Intel Alpine Ridge USB 3.1 driver uses "IARUSB3"
+                for(; usb_enum_index < nb_usb_enumerators; usb_enum_index++) {
+                    if(get_devinfo_data(ctx, dev_info, &dev_info_data, usb_enumerator[usb_enum_index], i))
+                        break;
+                    i = 0;
+                }
+                if(usb_enum_index == nb_usb_enumerators)
+                    break;
+            }
+
+            // Read the Device ID path
+            if(!pSetupDiGetDeviceInstanceIdA(*dev_info, &dev_info_data, dev_id, sizeof(dev_id), NULL)) {
+                usbi_warn(ctx, "could not read the device instance ID for devInst %lX, skipping", ULONG_CAST(dev_info_data.DevInst));
+                continue;
+            }
+
+#ifdef ENUM_DEBUG
+            usbi_dbg(ctx, "PRO: %s", dev_id);
+#endif
+
+            // Set API to use or get additional data from generic pass
+            api     = USB_API_UNSUPPORTED;
+            sub_api = SUB_API_NOTSET;
+            switch(pass) {
+            case HCD_PASS:
+                break;
+            case HUB_PASS:
+                api = USB_API_HUB;
+                // Fetch the PnP enumerator class for this hub
+                // This will allow us to enumerate all classes during the GEN pass
+                if(!pSetupDiGetDeviceRegistryPropertyA(*dev_info, &dev_info_data, SPDRP_ENUMERATOR_NAME, NULL, (PBYTE)enumerator, sizeof(enumerator), NULL)) {
+                    usbi_err(ctx, "could not read enumerator string for device '%s': %s", dev_id, windows_error_str(0));
+                    LOOP_BREAK(LIBUSB_ERROR_OTHER);
+                }
+                for(j = 0; j < nb_usb_enumerators; j++) {
+                    if(strcmp(usb_enumerator[j], enumerator) == 0)
+                        break;
+                }
+                if(j == nb_usb_enumerators) {
+                    usbi_dbg(ctx, "found new PnP enumerator string '%s'", enumerator);
+                    if(nb_usb_enumerators < ARRAYSIZE(usb_enumerator)) {
+                        usb_enumerator[nb_usb_enumerators] = _strdup(enumerator);
+                        if(usb_enumerator[nb_usb_enumerators] != NULL) {
+                            nb_usb_enumerators++;
+                        }
+                        else {
+                            usbi_err(ctx, "could not allocate enumerator string '%s'", enumerator);
+                            LOOP_BREAK(LIBUSB_ERROR_NO_MEM);
+                        }
+                    }
+                    else {
+                        usbi_warn(ctx, "too many enumerator strings, some devices may not be accessible");
+                    }
+                }
+                break;
+            case GEN_PASS:
+                // We use the GEN pass to detect driverless devices...
+                if(!pSetupDiGetDeviceRegistryPropertyA(*dev_info, &dev_info_data, SPDRP_DRIVER, NULL, NULL, 0, NULL)
+                   && (GetLastError() != ERROR_INSUFFICIENT_BUFFER)) {
+                    usbi_info(ctx, "The following device has no driver: '%s'", dev_id);
+                    usbi_info(ctx, "libusb will not be able to access it");
+                }
+                // ...and to add the additional device interface GUIDs
+                key = pSetupDiOpenDevRegKey(*dev_info, &dev_info_data, DICS_FLAG_GLOBAL, 0, DIREG_DEV, KEY_READ);
+                if(key == INVALID_HANDLE_VALUE)
+                    break;
+                // Look for both DeviceInterfaceGUIDs *and* DeviceInterfaceGUID, in that order
+                // If multiple GUIDs just process the first and ignore the others
+                size = sizeof(guid_string);
+                s    = pRegQueryValueExA(key, "DeviceInterfaceGUIDs", NULL, &reg_type, (LPBYTE)guid_string, &size);
+                if(s == ERROR_FILE_NOT_FOUND)
+                    s = pRegQueryValueExA(key, "DeviceInterfaceGUID", NULL, &reg_type, (LPBYTE)guid_string, &size);
+                pRegCloseKey(key);
+                if(s == ERROR_FILE_NOT_FOUND) {
+                    break; /* no DeviceInterfaceGUID registered */
+                }
+                else if(s != ERROR_SUCCESS && s != ERROR_MORE_DATA) {
+                    usbi_warn(ctx, "unexpected error from pRegQueryValueExA for '%s'", dev_id);
+                    break;
+                }
+                // https://docs.microsoft.com/en-us/windows/win32/api/winreg/nf-winreg-regqueryvalueexa#remarks
+                // - "string may not have been stored with the proper terminating null characters"
+                // - "Note that REG_MULTI_SZ strings could have two terminating null characters"
+                if((reg_type == REG_SZ && size >= sizeof(guid_string) - sizeof(char))
+                   || (reg_type == REG_MULTI_SZ && size >= sizeof(guid_string) - 2 * sizeof(char))) {
+                    if(nb_guids == guid_size) {
+                        new_guid_list = realloc((void *)guid_list, (guid_size + GUID_SIZE_STEP) * sizeof(void *));
+                        if(new_guid_list == NULL) {
+                            usbi_err(ctx, "failed to realloc guid list");
+                            LOOP_BREAK(LIBUSB_ERROR_NO_MEM);
+                        }
+                        guid_list = new_guid_list;
+                        guid_size += GUID_SIZE_STEP;
+                    }
+                    if_guid = malloc(sizeof(*if_guid));
+                    if(if_guid == NULL) {
+                        usbi_err(ctx, "failed to alloc if_guid");
+                        LOOP_BREAK(LIBUSB_ERROR_NO_MEM);
+                    }
+                    if(!string_to_guid(guid_string, if_guid)) {
+                        usbi_warn(ctx, "device '%s' has malformed DeviceInterfaceGUID string '%s', skipping", dev_id, guid_string);
+                        free(if_guid);
+                    }
+                    else {
+                        // Check if we've already seen this GUID
+                        for(j = EXT_PASS; j < nb_guids; j++) {
+                            if(memcmp(guid_list[j], if_guid, sizeof(*if_guid)) == 0)
+                                break;
+                        }
+                        if(j == nb_guids) {
+                            usbi_dbg(ctx, "extra GUID: %s", guid_string);
+                            guid_list[nb_guids++] = if_guid;
+                        }
+                        else {
+                            // Duplicate, ignore
+                            free(if_guid);
+                        }
+                    }
+                }
+                else {
+                    usbi_warn(ctx, "unexpected type/size of DeviceInterfaceGUID for '%s'", dev_id);
+                }
+                break;
+            case HID_PASS:
+                api = USB_API_HID;
+                break;
+            default:
+                // Get the API type (after checking that the driver installation is OK)
+                if((!pSetupDiGetDeviceRegistryPropertyA(*dev_info, &dev_info_data, SPDRP_INSTALL_STATE, NULL, (PBYTE)&install_state, sizeof(install_state),
+                                                        &size))
+                   || (size != sizeof(install_state))) {
+                    usbi_warn(ctx, "could not detect installation state of driver for '%s': %s", dev_id, windows_error_str(0));
+                }
+                else if(install_state != 0) {
+                    usbi_warn(ctx, "driver for device '%s' is reporting an issue (code: %lu) - skipping", dev_id, ULONG_CAST(install_state));
+                    continue;
+                }
+                get_api_type(dev_info, &dev_info_data, &api, &sub_api);
+                break;
+            }
+
+            // Find parent device (for the passes that need it)
+            if(pass >= GEN_PASS) {
+                parent_dev = get_ancestor(ctx, dev_info_data.DevInst, NULL);
+                if(parent_dev == NULL) {
+                    // Root hubs will not have a parent
+                    dev = usbi_get_device_by_session_id(ctx, (unsigned long)dev_info_data.DevInst);
+                    if(dev != NULL) {
+                        priv = usbi_get_device_priv(dev);
+                        if(priv->root_hub)
+                            goto track_unref;
+                        libusb_unref_device(dev);
+                    }
+
+                    usbi_dbg(ctx, "unlisted ancestor for '%s' (non USB HID, newly connected, etc.) - ignoring", dev_id);
+                    continue;
+                }
+
+                parent_priv = usbi_get_device_priv(parent_dev);
+                // virtual USB devices are also listed during GEN - don't process these yet
+                if((pass == GEN_PASS) && (parent_priv->apib->id != USB_API_HUB)) {
+                    int         interface_number;
+                    const char *mi_str = strstr(dev_id, "MI_");
+                    if((mi_str != NULL) && isdigit((unsigned char)mi_str[3]) && isdigit((unsigned char)mi_str[4])) {
+                        interface_number = ((mi_str[3] - '0') * 10) + (mi_str[4] - '0');
+                    }
+                    else {
+                        interface_number = 0;
+                    }
+                    char *dev_id_out = malloc(MAX_PATH_LENGTH);
+                    memcpy(dev_id_out, dev_id, MAX_PATH_LENGTH);
+                    parent_dev->sub_composite_device_id[interface_number] = dev_id_out;
+                    // printf("sub_composite_device_id = %s \n",dev_id_out);
+
+                    libusb_unref_device(parent_dev);
+                    continue;
+                }
+            }
+
+            // Create new or match existing device, using the devInst as session id
+            if((pass <= GEN_PASS) && (pass != HCD_PASS)) {  // For subsequent passes, we'll lookup the parent
+                // These are the passes that create "new" devices
+                session_id = (unsigned long)dev_info_data.DevInst;
+                dev        = usbi_get_device_by_session_id(ctx, session_id);
+                if(dev == NULL) {
+                alloc_device:
+                    usbi_dbg(ctx, "allocating new device for session [%lX]", session_id);
+                    dev = usbi_alloc_device(ctx, session_id);
+                    if(dev == NULL)
+                        LOOP_BREAK(LIBUSB_ERROR_NO_MEM);
+
+                    priv             = winusb_device_priv_init(dev);
+                    priv->dev_id     = _strdup(dev_id);
+                    priv->class_guid = dev_info_data.ClassGuid;
+                    if(priv->dev_id == NULL) {
+                        libusb_unref_device(dev);
+                        LOOP_BREAK(LIBUSB_ERROR_NO_MEM);
+                    }
+                }
+                else {
+                    usbi_dbg(ctx, "found existing device for session [%lX]", session_id);
+
+                    priv = usbi_get_device_priv(dev);
+                    if(strcmp(priv->dev_id, dev_id) != 0) {
+                        usbi_dbg(ctx, "device instance ID for session [%lX] changed", session_id);
+                        usbi_disconnect_device(dev);
+                        libusb_unref_device(dev);
+                        goto alloc_device;
+                    }
+                    if(!IsEqualGUID(&priv->class_guid, &dev_info_data.ClassGuid)) {
+                        usbi_dbg(ctx, "device class GUID for session [%lX] changed", session_id);
+                        usbi_disconnect_device(dev);
+                        libusb_unref_device(dev);
+                        goto alloc_device;
+                    }
+                }
+
+            track_unref:
+                // Keep track of devices that need unref
+                if(unref_cur == unref_size) {
+                    new_unref_list = realloc(unref_list, (unref_size + UNREF_SIZE_STEP) * sizeof(void *));
+                    if(new_unref_list == NULL) {
+                        usbi_err(ctx, "could not realloc list for unref - aborting");
+                        LOOP_BREAK(LIBUSB_ERROR_NO_MEM);
+                    }
+                    unref_list = new_unref_list;
+                    unref_size += UNREF_SIZE_STEP;
+                }
+                unref_list[unref_cur++] = dev;
+            }
+
+            // Setup device
+            switch(pass) {
+            case HUB_PASS:
+            case DEV_PASS:
+            case OPENNI_PASS:
+                // If the device has already been setup, don't do it again
+                if(priv->path != NULL)
+                    break;
+                // Take care of API initialization
+                priv->path         = dev_interface_path;
+                dev_interface_path = NULL;
+                priv->apib         = &usb_api_backend[api];
+                priv->sub_api      = sub_api;
+                switch(api) {
+                case USB_API_COMPOSITE:
+                case USB_API_HUB:
+                    break;
+                case USB_API_HID:
+                    priv->hid = calloc(1, sizeof(struct hid_device_priv));
+                    if(priv->hid == NULL)
+                        LOOP_BREAK(LIBUSB_ERROR_NO_MEM);
+                    break;
+                default:
+                    // For other devices, the first interface is the same as the device
+                    priv->usb_interface[0].path = _strdup(priv->path);
+                    if(priv->usb_interface[0].path == NULL)
+                        LOOP_BREAK(LIBUSB_ERROR_NO_MEM);
+                    // The following is needed if we want API calls to work for both simple
+                    // and composite devices.
+                    for(j = 0; j < USB_MAXINTERFACES; j++)
+                        priv->usb_interface[j].apib = &usb_api_backend[api];
+                    break;
+                }
+                break;
+            case HCD_PASS:
+                r = enumerate_hcd_root_hub(ctx, dev_id, (uint8_t)(i + 1), dev_info_data.DevInst);
+                break;
+            case GEN_PASS:
+                port_nr = 0;
+                if(!get_dev_port_number(*dev_info, &dev_info_data, &port_nr))
+                    usbi_warn(ctx, "could not retrieve port number for device '%s': %s", dev_id, windows_error_str(0));
+                r = init_device(dev, parent_dev, (uint8_t)port_nr, dev_info_data.DevInst);
+                if(r == LIBUSB_SUCCESS) {
+                    // Append device to the list of discovered devices
+                    discdevs = discovered_devs_append(*_discdevs, dev);
+                    if(!discdevs)
+                        LOOP_BREAK(LIBUSB_ERROR_NO_MEM);
+
+                    *_discdevs = discdevs;
+                }
+                else {
+                    // Failed to initialize a single device doesn't stop us from enumerating all other devices,
+                    // but we skip it (don't add to list of discovered devices)
+                    usbi_warn(ctx, "failed to initialize device '%s'", priv->dev_id);
+                    r = LIBUSB_SUCCESS;
+                }
+                break;
+            default:  // HID_PASS and later
+                if(parent_priv->apib->id == USB_API_HID || parent_priv->apib->id == USB_API_COMPOSITE) {
+                    if(parent_priv->apib->id == USB_API_HID) {
+                        usbi_dbg(ctx, "setting HID interface for [%lX]:", parent_dev->session_data);
+                        r = set_hid_interface(ctx, parent_dev, dev_interface_path);
+                    }
+                    else {
+                        usbi_dbg(ctx, "setting composite interface for [%lX]:", parent_dev->session_data);
+                        r = set_composite_interface(ctx, parent_dev, dev_interface_path, dev_id, api, sub_api);
+                    }
+                    switch(r) {
+                    case LIBUSB_SUCCESS:
+                        dev_interface_path = NULL;
+                        break;
+                    case LIBUSB_ERROR_ACCESS:
+                        // interface has already been set => make sure dev_interface_path is freed then
+                        r = LIBUSB_SUCCESS;
+                        break;
+                    default:
+                        LOOP_BREAK(r);
+                        break;
+                    }
+                }
+                libusb_unref_device(parent_dev);
+                break;
+            }
+        }
+    }
+
+    pSetupDiDestroyDeviceInfoList(dev_info_intf);
+
+    // Free any additional GUIDs
+    for(pass = EXT_PASS; pass < nb_guids; pass++)
+        free((void *)guid_list[pass]);
+    free((void *)guid_list);
+
+    // Free any PnP enumerator strings
+    for(i = 1; i < nb_usb_enumerators; i++)
+        free((void *)usb_enumerator[i]);
+
+    // Unref newly allocated devs
+    for(i = 0; i < unref_cur; i++)
+        libusb_unref_device(unref_list[i]);
+    free(unref_list);
+
+    return r;
+}
+
+static int winusb_get_config_descriptor(struct libusb_device *dev, uint8_t config_index, void *buffer, size_t len) {
+    struct winusb_device_priv    *priv = usbi_get_device_priv(dev);
+    PUSB_CONFIGURATION_DESCRIPTOR config_header;
+
+    if((priv->config_descriptor == NULL) || (priv->config_descriptor[config_index] == NULL))
+        return LIBUSB_ERROR_NOT_FOUND;
+
+    config_header = priv->config_descriptor[config_index];
+
+    len = MIN(len, config_header->wTotalLength);
+    memcpy(buffer, config_header, len);
+    return (int)len;
+}
+
+static int winusb_get_config_descriptor_by_value(struct libusb_device *dev, uint8_t bConfigurationValue, void **buffer) {
+    struct winusb_device_priv    *priv = usbi_get_device_priv(dev);
+    PUSB_CONFIGURATION_DESCRIPTOR config_header;
+    uint8_t                       index;
+
+    if(priv->config_descriptor == NULL)
+        return LIBUSB_ERROR_NOT_FOUND;
+
+    for(index = 0; index < dev->device_descriptor.bNumConfigurations; index++) {
+        config_header = priv->config_descriptor[index];
+        if(config_header == NULL)
+            continue;
+        if(config_header->bConfigurationValue == bConfigurationValue) {
+            *buffer = config_header;
+            return (int)config_header->wTotalLength;
+        }
+    }
+
+    return LIBUSB_ERROR_NOT_FOUND;
+}
+
+/*
+ * return the cached copy of the active config descriptor
+ */
+static int winusb_get_active_config_descriptor(struct libusb_device *dev, void *buffer, size_t len) {
+    struct winusb_device_priv *priv = usbi_get_device_priv(dev);
+    void                      *config_desc;
+    int                        r;
+
+    if(priv->active_config == 0)
+        return LIBUSB_ERROR_NOT_FOUND;
+
+    r = winusb_get_config_descriptor_by_value(dev, priv->active_config, &config_desc);
+    if(r < 0)
+        return r;
+
+    len = MIN(len, (size_t)r);
+    memcpy(buffer, config_desc, len);
+    return (int)len;
+}
+
+static int winusb_open(struct libusb_device_handle *dev_handle) {
+    struct winusb_device_priv *priv = usbi_get_device_priv(dev_handle->dev);
+
+    CHECK_SUPPORTED_API(priv->apib, open);
+
+    return priv->apib->open(SUB_API_NOTSET, dev_handle);
+}
+
+static void winusb_close(struct libusb_device_handle *dev_handle) {
+    struct winusb_device_priv *priv = usbi_get_device_priv(dev_handle->dev);
+
+    if(priv->apib->close)
+        priv->apib->close(SUB_API_NOTSET, dev_handle);
+}
+
+static int winusb_get_configuration(struct libusb_device_handle *dev_handle, uint8_t *config) {
+    struct winusb_device_priv *priv = usbi_get_device_priv(dev_handle->dev);
+
+    *config = priv->active_config;
+    return LIBUSB_SUCCESS;
+}
+
+/*
+ * from http://msdn.microsoft.com/en-us/library/ms793522.aspx: "The port driver
+ * does not currently expose a service that allows higher-level drivers to set
+ * the configuration."
+ */
+static int winusb_set_configuration(struct libusb_device_handle *dev_handle, uint8_t config) {
+    struct winusb_device_priv *priv = usbi_get_device_priv(dev_handle->dev);
+    int                        r    = LIBUSB_SUCCESS;
+
+    r = libusb_control_transfer(dev_handle, LIBUSB_ENDPOINT_OUT | LIBUSB_REQUEST_TYPE_STANDARD | LIBUSB_RECIPIENT_DEVICE, LIBUSB_REQUEST_SET_CONFIGURATION,
+                                config, 0, NULL, 0, 1000);
+
+    if(r == LIBUSB_SUCCESS)
+        priv->active_config = config;
+
+    return r;
+}
+
+static int winusb_claim_interface(struct libusb_device_handle *dev_handle, uint8_t iface) {
+    struct winusb_device_priv *priv = usbi_get_device_priv(dev_handle->dev);
+    int                        r;
+
+    CHECK_SUPPORTED_API(priv->apib, claim_interface);
+
+    safe_free(priv->usb_interface[iface].endpoint);
+    priv->usb_interface[iface].nb_endpoints = 0;
+
+    r = priv->apib->claim_interface(SUB_API_NOTSET, dev_handle, iface);
+
+    if(r == LIBUSB_SUCCESS)
+        r = windows_assign_endpoints(dev_handle, iface, 0);
+
+    return r;
+}
+
+static int winusb_set_interface_altsetting(struct libusb_device_handle *dev_handle, uint8_t iface, uint8_t altsetting) {
+    struct winusb_device_priv *priv = usbi_get_device_priv(dev_handle->dev);
+    int                        r;
+
+    CHECK_SUPPORTED_API(priv->apib, set_interface_altsetting);
+
+    safe_free(priv->usb_interface[iface].endpoint);
+    priv->usb_interface[iface].nb_endpoints = 0;
+
+    r = priv->apib->set_interface_altsetting(SUB_API_NOTSET, dev_handle, iface, altsetting);
+
+    if(r == LIBUSB_SUCCESS)
+        r = windows_assign_endpoints(dev_handle, iface, altsetting);
+
+    return r;
+}
+
+static int winusb_release_interface(struct libusb_device_handle *dev_handle, uint8_t iface) {
+    struct winusb_device_priv *priv = usbi_get_device_priv(dev_handle->dev);
+
+    CHECK_SUPPORTED_API(priv->apib, release_interface);
+
+    return priv->apib->release_interface(SUB_API_NOTSET, dev_handle, iface);
+}
+
+static int winusb_clear_halt(struct libusb_device_handle *dev_handle, unsigned char endpoint) {
+    struct winusb_device_priv *priv = usbi_get_device_priv(dev_handle->dev);
+
+    CHECK_SUPPORTED_API(priv->apib, clear_halt);
+
+    return priv->apib->clear_halt(SUB_API_NOTSET, dev_handle, endpoint);
+}
+
+static int winusb_reset_device(struct libusb_device_handle *dev_handle) {
+    struct winusb_device_priv *priv = usbi_get_device_priv(dev_handle->dev);
+
+    CHECK_SUPPORTED_API(priv->apib, reset_device);
+
+    return priv->apib->reset_device(SUB_API_NOTSET, dev_handle);
+}
+
+static void winusb_destroy_device(struct libusb_device *dev) {
+    winusb_device_priv_release(dev);
+}
+
+static void winusb_clear_transfer_priv(struct usbi_transfer *itransfer) {
+    struct winusb_transfer_priv *transfer_priv = get_winusb_transfer_priv(itransfer);
+    struct libusb_transfer      *transfer      = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+    struct winusb_device_priv   *priv          = usbi_get_device_priv(transfer->dev_handle->dev);
+    int                          sub_api       = priv->sub_api;
+
+    safe_free(transfer_priv->hid_buffer);
+
+    if(transfer->type == LIBUSB_TRANSFER_TYPE_ISOCHRONOUS && sub_api == SUB_API_WINUSB) {
+        if(transfer_priv->isoch_buffer_handle != NULL) {
+            if(WinUSBX[sub_api].UnregisterIsochBuffer(transfer_priv->isoch_buffer_handle)) {
+                transfer_priv->isoch_buffer_handle = NULL;
+            }
+            else {
+                usbi_warn(TRANSFER_CTX(transfer), "failed to unregister WinUSB isoch buffer: %s", windows_error_str(0));
+            }
+        }
+    }
+
+    safe_free(transfer_priv->iso_context);
+
+    // When auto claim is in use, attempt to release the auto-claimed interface
+    auto_release(itransfer);
+}
+
+static int winusb_submit_transfer(struct usbi_transfer *itransfer) {
+    struct libusb_transfer    *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+    struct winusb_device_priv *priv     = usbi_get_device_priv(transfer->dev_handle->dev);
+    int (*transfer_fn)(int, struct usbi_transfer *);
+
+    switch(transfer->type) {
+    case LIBUSB_TRANSFER_TYPE_CONTROL:
+        transfer_fn = priv->apib->submit_control_transfer;
+        break;
+    case LIBUSB_TRANSFER_TYPE_BULK:
+    case LIBUSB_TRANSFER_TYPE_INTERRUPT:
+        transfer_fn = priv->apib->submit_bulk_transfer;
+        break;
+    case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
+        transfer_fn = priv->apib->submit_iso_transfer;
+        break;
+    default:
+        // Should not get here since windows_submit_transfer() validates
+        // the transfer->type field
+        usbi_err(TRANSFER_CTX(transfer), "unknown endpoint type %d", transfer->type);
+        return LIBUSB_ERROR_INVALID_PARAM;
+    }
+
+    if(transfer_fn == NULL) {
+        usbi_warn(TRANSFER_CTX(transfer), "unsupported transfer type %d (unrecognized device driver)", transfer->type);
+        return LIBUSB_ERROR_NOT_SUPPORTED;
+    }
+
+    return transfer_fn(SUB_API_NOTSET, itransfer);
+}
+
+static int winusb_cancel_transfer(struct usbi_transfer *itransfer) {
+    struct libusb_transfer    *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+    struct winusb_device_priv *priv     = usbi_get_device_priv(transfer->dev_handle->dev);
+
+    CHECK_SUPPORTED_API(priv->apib, cancel_transfer);
+
+    return priv->apib->cancel_transfer(SUB_API_NOTSET, itransfer);
+}
+
+static enum libusb_transfer_status winusb_copy_transfer_data(struct usbi_transfer *itransfer, DWORD length) {
+    struct libusb_transfer    *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+    struct winusb_device_priv *priv     = usbi_get_device_priv(transfer->dev_handle->dev);
+
+    if(priv->apib->copy_transfer_data == NULL) {
+        usbi_err(TRANSFER_CTX(transfer), "program assertion failed - no function to copy transfer data");
+        return LIBUSB_TRANSFER_ERROR;
+    }
+
+    return priv->apib->copy_transfer_data(SUB_API_NOTSET, itransfer, length);
+}
+
+static int winusb_set_option(struct libusb_context *ctx, enum libusb_option option, va_list ap) {
+    struct libusb_device_handle      *dev_handle;
+    unsigned int                      endpoint;
+    unsigned int                      enable;
+    unsigned int                     *max_transfer_size_ptr;
+    struct winusb_device_handle_priv *handle_priv;
+    struct winusb_device_priv        *priv;
+    UCHAR                             policy;
+    int                               current_interface;
+    HANDLE                            winusb_handle;
+    int                               sub_api           = SUB_API_NOTSET;
+    ULONG                             max_transfer_size = 0;
+
+    switch(option) {
+    case LIBUSB_OPTION_WINUSB_RAW_IO:
+        dev_handle            = va_arg(ap, struct libusb_device_handle *);
+        endpoint              = va_arg(ap, unsigned int);
+        enable                = va_arg(ap, unsigned int);
+        max_transfer_size_ptr = va_arg(ap, unsigned int *);
+
+        policy = enable != 0;
+
+        if(dev_handle == NULL) {
+            usbi_err(ctx, "device handle passed for RAW_IO was NULL");
+            return LIBUSB_ERROR_INVALID_PARAM;
+        }
+
+        if(HANDLE_CTX(dev_handle) != ctx) {
+            usbi_err(ctx, "device handle passed for RAW_IO has wrong context");
+            return LIBUSB_ERROR_INVALID_PARAM;
+        }
+
+        if(endpoint & ~(LIBUSB_ENDPOINT_DIR_MASK | LIBUSB_ENDPOINT_ADDRESS_MASK)) {
+            usbi_err(ctx, "invalid endpoint %X passed for RAW_IO", endpoint);
+            return LIBUSB_ERROR_INVALID_PARAM;
+        }
+
+        if(!(endpoint & LIBUSB_ENDPOINT_DIR_MASK)) {
+            usbi_err(ctx, "endpoint %02X passed for RAW_IO is OUT, not IN", endpoint);
+            return LIBUSB_ERROR_INVALID_PARAM;
+        }
+
+        handle_priv       = get_winusb_device_handle_priv(dev_handle);
+        priv              = usbi_get_device_priv(dev_handle->dev);
+        current_interface = interface_by_endpoint(priv, handle_priv, (uint8_t)endpoint);
+
+        if(current_interface < 0) {
+            usbi_err(ctx, "unable to match endpoint to an open interface for RAW_IO");
+            return LIBUSB_ERROR_NOT_FOUND;
+        }
+
+        if(priv->usb_interface[current_interface].apib->id != USB_API_WINUSBX) {
+            usbi_err(ctx, "interface is not winusb when setting RAW_IO");
+            return LIBUSB_ERROR_NOT_SUPPORTED;
+        }
+
+        winusb_handle = handle_priv->interface_handle[current_interface].api_handle;
+
+        if(!HANDLE_VALID(winusb_handle)) {
+            usbi_err(HANDLE_CTX(dev_handle), "WinUSB handle not valid when setting RAW_IO");
+            return LIBUSB_ERROR_NOT_FOUND;
+        }
+
+        CHECK_WINUSBX_AVAILABLE(sub_api);
+
+        if(enable && max_transfer_size_ptr != NULL) {
+            ULONG size = sizeof(ULONG);
+            if(!WinUSBX[sub_api].GetPipePolicy(winusb_handle, (UCHAR)endpoint, MAXIMUM_TRANSFER_SIZE, &size, &max_transfer_size)) {
+                usbi_err(ctx, "failed to get MAXIMUM_TRANSFER_SIZE for endpoint %02X", endpoint);
+                switch(GetLastError()) {
+                case ERROR_INVALID_HANDLE:
+                    return LIBUSB_ERROR_INVALID_PARAM;
+                default:
+                    return LIBUSB_ERROR_OTHER;
+                }
+            }
+        }
+
+        if(!WinUSBX[sub_api].SetPipePolicy(winusb_handle, (UCHAR)endpoint, RAW_IO, sizeof(UCHAR), &policy)) {
+            usbi_err(ctx, "failed to change RAW_IO for endpoint %02X", endpoint);
+            switch(GetLastError()) {
+            case ERROR_INVALID_HANDLE:
+            case ERROR_INVALID_PARAMETER:
+                return LIBUSB_ERROR_INVALID_PARAM;
+            case ERROR_NOT_ENOUGH_MEMORY:
+                return LIBUSB_ERROR_NO_MEM;
+            default:
+                return LIBUSB_ERROR_OTHER;
+            }
+        }
+
+        usbi_dbg(ctx, "%s RAW_IO for endpoint %02X", enable ? "enabled" : "disabled", endpoint);
+
+        if(enable && max_transfer_size_ptr != NULL)
+            *max_transfer_size_ptr = max_transfer_size;
+
+        return LIBUSB_SUCCESS;
+    default:
+        return LIBUSB_ERROR_NOT_SUPPORTED;
+    }
+}
+
+// NB: MSVC6 does not support named initializers.
+const struct windows_backend winusb_backend = {
+    winusb_init,
+    winusb_exit,
+    winusb_get_device_list,
+    winusb_open,
+    winusb_close,
+    winusb_get_active_config_descriptor,
+    winusb_get_config_descriptor,
+    winusb_get_config_descriptor_by_value,
+    winusb_get_configuration,
+    winusb_set_configuration,
+    winusb_claim_interface,
+    winusb_release_interface,
+    winusb_set_interface_altsetting,
+    winusb_clear_halt,
+    winusb_reset_device,
+    winusb_destroy_device,
+    winusb_submit_transfer,
+    winusb_cancel_transfer,
+    winusb_clear_transfer_priv,
+    winusb_copy_transfer_data,
+    winusb_set_option,
+};
+
+/*
+ * USB API backends
+ */
+
+static const char *const             composite_driver_names[]     = { "USBCCGP" };
+static const char *const             winusbx_driver_names[]       = { "libusbK", "libusb0", "WinUSB" };
+static const char *const             hid_driver_names[]           = { "HIDUSB", "MOUHID", "KBDHID" };
+const struct windows_usb_api_backend usb_api_backend[USB_API_MAX] = {
+    {
+        USB_API_UNSUPPORTED,
+        "Unsupported API",
+        NULL, /* driver_name_list */
+        0,    /* nb_driver_names */
+        NULL, /* init */
+        NULL, /* exit */
+        NULL, /* open */
+        NULL, /* close */
+        NULL, /* configure_endpoints */
+        NULL, /* claim_interface */
+        NULL, /* set_interface_altsetting */
+        NULL, /* release_interface */
+        NULL, /* clear_halt */
+        NULL, /* reset_device */
+        NULL, /* submit_bulk_transfer */
+        NULL, /* submit_iso_transfer */
+        NULL, /* submit_control_transfer */
+        NULL, /* cancel_transfer */
+        NULL, /* copy_transfer_data */
+    },
+    {
+        USB_API_HUB, "HUB API", NULL, /* driver_name_list */
+        0,                            /* nb_driver_names */
+        NULL,                         /* init */
+        NULL,                         /* exit */
+        NULL,                         /* open */
+        NULL,                         /* close */
+        NULL,                         /* configure_endpoints */
+        NULL,                         /* claim_interface */
+        NULL,                         /* set_interface_altsetting */
+        NULL,                         /* release_interface */
+        NULL,                         /* clear_halt */
+        NULL,                         /* reset_device */
+        NULL,                         /* submit_bulk_transfer */
+        NULL,                         /* submit_iso_transfer */
+        NULL,                         /* submit_control_transfer */
+        NULL,                         /* cancel_transfer */
+        NULL,                         /* copy_transfer_data */
+    },
+    {
+        USB_API_COMPOSITE,
+        "Composite API",
+        composite_driver_names,
+        ARRAYSIZE(composite_driver_names),
+        NULL, /* init */
+        NULL, /* exit */
+        composite_open,
+        composite_close,
+        NULL, /* configure_endpoints */
+        composite_claim_interface,
+        composite_set_interface_altsetting,
+        composite_release_interface,
+        composite_clear_halt,
+        composite_reset_device,
+        composite_submit_bulk_transfer,
+        composite_submit_iso_transfer,
+        composite_submit_control_transfer,
+        composite_cancel_transfer,
+        composite_copy_transfer_data,
+    },
+    {
+        USB_API_WINUSBX,
+        "WinUSB-like APIs",
+        winusbx_driver_names,
+        ARRAYSIZE(winusbx_driver_names),
+        winusbx_init,
+        winusbx_exit,
+        winusbx_open,
+        winusbx_close,
+        winusbx_configure_endpoints,
+        winusbx_claim_interface,
+        winusbx_set_interface_altsetting,
+        winusbx_release_interface,
+        winusbx_clear_halt,
+        winusbx_reset_device,
+        winusbx_submit_bulk_transfer,
+        winusbx_submit_iso_transfer,
+        winusbx_submit_control_transfer,
+        winusbx_cancel_transfer,
+        winusbx_copy_transfer_data,
+    },
+    {
+        USB_API_HID,
+        "HID API",
+        hid_driver_names,
+        ARRAYSIZE(hid_driver_names),
+        hid_init,
+        hid_exit,
+        hid_open,
+        hid_close,
+        NULL, /* configure_endpoints */
+        hid_claim_interface,
+        hid_set_interface_altsetting,
+        hid_release_interface,
+        hid_clear_halt,
+        hid_reset_device,
+        hid_submit_bulk_transfer,
+        NULL, /* submit_iso_transfer */
+        hid_submit_control_transfer,
+        NULL, /* cancel_transfer */
+        hid_copy_transfer_data,
+    },
+};
+
+/*
+ * WinUSB-like (WinUSB, libusb0/libusbK through libusbk DLL) API functions
+ */
+#define WinUSB_Set(h, fn, required)                                                     \
+    do {                                                                                \
+        WinUSBX[SUB_API_WINUSB].fn = (WinUsb_##fn##_t)GetProcAddress(h, "WinUsb_" #fn); \
+        if(required && (WinUSBX[SUB_API_WINUSB].fn == NULL)) {                          \
+            usbi_err(ctx, "GetProcAddress() failed for WinUsb_%s", #fn);                \
+            goto cleanup_winusb;                                                        \
+        }                                                                               \
+    } while(0)
+
+#define libusbK_Set(sub_api, fn, required)                                            \
+    do {                                                                              \
+        pLibK_GetProcAddress((PVOID *)&WinUSBX[sub_api].fn, sub_api, KUSB_FNID_##fn); \
+        if(required && (WinUSBX[sub_api].fn == NULL)) {                               \
+            usbi_err(ctx, "LibK_GetProcAddress() failed for LibK_%s", #fn);           \
+            goto cleanup_libusbk;                                                     \
+        }                                                                             \
+    } while(0)
+
+static bool winusbx_init(struct libusb_context *ctx) {
+    HMODULE hWinUSB, hlibusbK;
+
+    hWinUSB = load_system_library(ctx, "WinUSB");
+    if(hWinUSB != NULL) {
+        WinUSB_Set(hWinUSB, AbortPipe, true);
+        WinUSB_Set(hWinUSB, ControlTransfer, true);
+        WinUSB_Set(hWinUSB, FlushPipe, true);
+        WinUSB_Set(hWinUSB, Free, true);
+        WinUSB_Set(hWinUSB, GetAssociatedInterface, true);
+        WinUSB_Set(hWinUSB, Initialize, true);
+        WinUSB_Set(hWinUSB, ReadPipe, true);
+        WinUSB_Set(hWinUSB, ResetPipe, true);
+        WinUSB_Set(hWinUSB, SetCurrentAlternateSetting, true);
+        WinUSB_Set(hWinUSB, SetPipePolicy, true);
+        WinUSB_Set(hWinUSB, GetPipePolicy, true);
+        WinUSB_Set(hWinUSB, WritePipe, true);
+
+        // Check for isochronous transfers support (available starting with Windows 8.1)
+        WinUSB_Set(hWinUSB, ReadIsochPipeAsap, false);
+        if(WinUSBX[SUB_API_WINUSB].ReadIsochPipeAsap != NULL) {
+            WinUSB_Set(hWinUSB, QueryPipeEx, true);
+            WinUSB_Set(hWinUSB, RegisterIsochBuffer, true);
+            WinUSB_Set(hWinUSB, UnregisterIsochBuffer, true);
+            WinUSB_Set(hWinUSB, WriteIsochPipeAsap, true);
+        }
+
+        WinUSBX[SUB_API_WINUSB].hDll = hWinUSB;
+
+        usbi_info(ctx, "WinUSB DLL available (%s isoch support)", (WinUSBX[SUB_API_WINUSB].ReadIsochPipeAsap != NULL) ? "with" : "without");
+
+    cleanup_winusb:
+        if(WinUSBX[SUB_API_WINUSB].hDll == NULL) {
+            usbi_err(ctx, "failed to initialize WinUSB");
+            memset(&WinUSBX[SUB_API_WINUSB], 0, sizeof(WinUSBX[SUB_API_WINUSB]));
+            FreeLibrary(hWinUSB);
+            hWinUSB = NULL;
+        }
+    }
+    else {
+        usbi_info(ctx, "WinUSB DLL is not available");
+    }
+
+    hlibusbK = load_system_library(ctx, "libusbK");
+    if(hlibusbK != NULL) {
+        LibK_GetVersion_t     pLibK_GetVersion;
+        LibK_GetProcAddress_t pLibK_GetProcAddress;
+        int                   sub_api = 0;
+
+        pLibK_GetVersion = (LibK_GetVersion_t)GetProcAddress(hlibusbK, "LibK_GetVersion");
+        if(pLibK_GetVersion != NULL) {
+            KLIB_VERSION LibK_Version;
+
+            pLibK_GetVersion(&LibK_Version);
+            usbi_dbg(ctx, "libusbK DLL found, version: %d.%d.%d.%d", LibK_Version.Major, LibK_Version.Minor, LibK_Version.Micro, LibK_Version.Nano);
+        }
+        else {
+            usbi_dbg(ctx, "libusbK DLL found, version unknown");
+        }
+
+        pLibK_GetProcAddress = (LibK_GetProcAddress_t)GetProcAddress(hlibusbK, "LibK_GetProcAddress");
+        if(pLibK_GetProcAddress == NULL) {
+            usbi_err(ctx, "LibK_GetProcAddress() not found in libusbK DLL");
+            goto cleanup_libusbk;
+        }
+
+        // NB: The below for loop works because the sub_api value for WinUSB
+        // is a higher value than that of libusbK and libusb0
+        for(; sub_api < SUB_API_WINUSB; sub_api++) {
+            libusbK_Set(sub_api, AbortPipe, true);
+            libusbK_Set(sub_api, ControlTransfer, true);
+            libusbK_Set(sub_api, FlushPipe, true);
+            libusbK_Set(sub_api, Free, true);
+            libusbK_Set(sub_api, GetAssociatedInterface, true);
+            libusbK_Set(sub_api, Initialize, true);
+            libusbK_Set(sub_api, ReadPipe, true);
+            libusbK_Set(sub_api, ResetPipe, true);
+            libusbK_Set(sub_api, SetCurrentAlternateSetting, true);
+            libusbK_Set(sub_api, SetPipePolicy, true);
+            libusbK_Set(sub_api, WritePipe, true);
+
+            // Optional isochronous support
+            libusbK_Set(sub_api, IsoReadPipe, false);
+            if(WinUSBX[sub_api].IsoReadPipe != NULL)
+                libusbK_Set(sub_api, IsoWritePipe, true);
+
+            // Optional device reset support
+            libusbK_Set(sub_api, ResetDevice, false);
+
+            WinUSBX[sub_api].hDll = hlibusbK;
+        }
+
+    cleanup_libusbk:
+        if(sub_api < SUB_API_WINUSB) {
+            usbi_err(ctx, "failed to initialize libusbK");
+            while(sub_api >= 0) {
+                memset(&WinUSBX[sub_api], 0, sizeof(WinUSBX[sub_api]));
+                sub_api--;
+            }
+            FreeLibrary(hlibusbK);
+            hlibusbK = NULL;
+        }
+    }
+    else {
+        usbi_info(ctx, "libusbK DLL is not available");
+    }
+
+    if((hWinUSB == NULL) && (hlibusbK == NULL)) {
+        usbi_warn(ctx, "neither WinUSB nor libusbK DLLs were found, "
+                       "you will not be able to access devices outside of enumeration");
+        return false;
+    }
+
+    return true;
+}
+
+static void winusbx_exit(void) {
+    bool    loaded = false;
+    HMODULE hDll;
+
+    hDll = WinUSBX[SUB_API_LIBUSBK].hDll;
+    if(hDll != NULL) {
+        FreeLibrary(hDll);
+        loaded = true;
+    }
+
+    hDll = WinUSBX[SUB_API_WINUSB].hDll;
+    if(hDll != NULL) {
+        FreeLibrary(hDll);
+        loaded = true;
+    }
+
+    // Reset the WinUSBX API structures if something was loaded
+    if(loaded)
+        memset(&WinUSBX, 0, sizeof(WinUSBX));
+}
+
+// NB: open and close must ensure that they only handle interface of
+// the right API type, as these functions can be called wholesale from
+// composite_open(), with interfaces belonging to different APIs
+static int winusbx_open(int sub_api, struct libusb_device_handle *dev_handle) {
+    struct winusb_device_priv        *priv        = usbi_get_device_priv(dev_handle->dev);
+    struct winusb_device_handle_priv *handle_priv = get_winusb_device_handle_priv(dev_handle);
+    HANDLE                            file_handle;
+    int                               i;
+
+    CHECK_WINUSBX_AVAILABLE(sub_api);
+
+    // WinUSB requires a separate handle for each interface
+    for(i = 0; i < USB_MAXINTERFACES; i++) {
+        if((priv->usb_interface[i].path != NULL) && (priv->usb_interface[i].apib->id == USB_API_WINUSBX)) {
+            file_handle = windows_open(dev_handle, priv->usb_interface[i].path, GENERIC_READ | GENERIC_WRITE);
+            if(file_handle == INVALID_HANDLE_VALUE) {
+                usbi_err(HANDLE_CTX(dev_handle), "could not open device %s (interface %d): %s", priv->usb_interface[i].path, i, windows_error_str(0));
+                switch(GetLastError()) {
+                case ERROR_FILE_NOT_FOUND:  // The device was disconnected
+                    return LIBUSB_ERROR_NO_DEVICE;
+                case ERROR_ACCESS_DENIED:
+                    return LIBUSB_ERROR_ACCESS;
+                default:
+                    return LIBUSB_ERROR_IO;
+                }
+            }
+
+            handle_priv->interface_handle[i].dev_handle = file_handle;
+        }
+    }
+
+    return LIBUSB_SUCCESS;
+}
+
+static void winusbx_close(int sub_api, struct libusb_device_handle *dev_handle) {
+    struct winusb_device_handle_priv *handle_priv = get_winusb_device_handle_priv(dev_handle);
+    struct winusb_device_priv        *priv        = usbi_get_device_priv(dev_handle->dev);
+    HANDLE                            handle;
+    int                               i, ai;
+
+    if(sub_api == SUB_API_NOTSET)
+        sub_api = priv->sub_api;
+
+    if(WinUSBX[sub_api].hDll == NULL)
+        return;
+
+    if(priv->apib->id == USB_API_COMPOSITE) {
+        // If this is a composite device, just free and close any WinUSB-like
+        // interfaces that are not part of an associated group
+        // (each is independent and not associated with another).
+        // For associated interface groupings, free interfaces that
+        // are NOT the first within that group (i.e. not bFirstInterface),
+        // then free & close bFirstInterface last.
+        for(i = 0; i < USB_MAXINTERFACES; i++) {
+            if(priv->usb_interface[i].apib->id == USB_API_WINUSBX) {
+                if(priv->usb_interface[i].num_associated_interfaces == 0) {
+                    handle = handle_priv->interface_handle[i].api_handle;
+                    if(HANDLE_VALID(handle))
+                        WinUSBX[sub_api].Free(handle);
+
+                    handle = handle_priv->interface_handle[i].dev_handle;
+                    if(HANDLE_VALID(handle))
+                        CloseHandle(handle);
+                }
+                else {
+                    if(i == priv->usb_interface[i].first_associated_interface) {
+                        // first free all handles for all *other* associated interfaces
+                        for(ai = 1; ai < priv->usb_interface[i].num_associated_interfaces; ai++) {
+                            handle = handle_priv->interface_handle[i + ai].api_handle;
+                            if(HANDLE_VALID(handle))
+                                WinUSBX[sub_api].Free(handle);
+                        }
+
+                        // free & close bFirstInterface
+                        handle = handle_priv->interface_handle[i].api_handle;
+                        if(HANDLE_VALID(handle))
+                            WinUSBX[sub_api].Free(handle);
+
+                        handle = handle_priv->interface_handle[i].dev_handle;
+                        if(HANDLE_VALID(handle))
+                            CloseHandle(handle);
+                    }
+                }
+            }
+        }
+    }
+    else {
+        // If this is a WinUSB device, free all interfaces above interface 0,
+        // then free and close interface 0 last
+        for(i = 1; i < USB_MAXINTERFACES; i++) {
+            handle = handle_priv->interface_handle[i].api_handle;
+            if(HANDLE_VALID(handle))
+                WinUSBX[sub_api].Free(handle);
+        }
+        handle = handle_priv->interface_handle[0].api_handle;
+        if(HANDLE_VALID(handle))
+            WinUSBX[sub_api].Free(handle);
+
+        handle = handle_priv->interface_handle[0].dev_handle;
+        if(HANDLE_VALID(handle))
+            CloseHandle(handle);
+    }
+}
+
+static int winusbx_configure_endpoints(int sub_api, struct libusb_device_handle *dev_handle, uint8_t iface) {
+    struct winusb_device_handle_priv *handle_priv   = get_winusb_device_handle_priv(dev_handle);
+    struct winusb_device_priv        *priv          = usbi_get_device_priv(dev_handle->dev);
+    HANDLE                            winusb_handle = handle_priv->interface_handle[iface].api_handle;
+    UCHAR                             policy;
+    ULONG                             timeout = 0;
+    uint8_t                           endpoint_address;
+    int                               i;
+
+    CHECK_WINUSBX_AVAILABLE(sub_api);
+
+    // With handle and endpoints set (in parent), we can setup the default pipe properties
+    // see http://download.microsoft.com/download/D/1/D/D1DD7745-426B-4CC3-A269-ABBBE427C0EF/DVC-T705_DDC08.pptx
+    for(i = -1; i < priv->usb_interface[iface].nb_endpoints; i++) {
+        endpoint_address = (i == -1) ? 0 : priv->usb_interface[iface].endpoint[i];
+        if(!WinUSBX[sub_api].SetPipePolicy(winusb_handle, endpoint_address, PIPE_TRANSFER_TIMEOUT, sizeof(ULONG), &timeout))
+            usbi_dbg(HANDLE_CTX(dev_handle), "failed to set PIPE_TRANSFER_TIMEOUT for control endpoint %02X", endpoint_address);
+
+        if((i == -1) || (sub_api == SUB_API_LIBUSB0))
+            continue;  // Other policies don't apply to control endpoint or libusb0
+
+        policy                                                     = false;
+        handle_priv->interface_handle[iface].zlp[endpoint_address] = WINUSB_ZLP_UNSET;
+        if(!WinUSBX[sub_api].SetPipePolicy(winusb_handle, endpoint_address, SHORT_PACKET_TERMINATE, sizeof(UCHAR), &policy))
+            usbi_dbg(HANDLE_CTX(dev_handle), "failed to disable SHORT_PACKET_TERMINATE for endpoint %02X", endpoint_address);
+
+        if(!WinUSBX[sub_api].SetPipePolicy(winusb_handle, endpoint_address, IGNORE_SHORT_PACKETS, sizeof(UCHAR), &policy))
+            usbi_dbg(HANDLE_CTX(dev_handle), "failed to disable IGNORE_SHORT_PACKETS for endpoint %02X", endpoint_address);
+
+        policy = true;
+        /* ALLOW_PARTIAL_READS must be enabled due to likely libusbK bug. See:
+           https://sourceforge.net/mailarchive/message.php?msg_id=29736015 */
+        if(!WinUSBX[sub_api].SetPipePolicy(winusb_handle, endpoint_address, ALLOW_PARTIAL_READS, sizeof(UCHAR), &policy))
+            usbi_dbg(HANDLE_CTX(dev_handle), "failed to enable ALLOW_PARTIAL_READS for endpoint %02X", endpoint_address);
+
+        if(!WinUSBX[sub_api].SetPipePolicy(winusb_handle, endpoint_address, AUTO_CLEAR_STALL, sizeof(UCHAR), &policy))
+            usbi_dbg(HANDLE_CTX(dev_handle), "failed to enable AUTO_CLEAR_STALL for endpoint %02X", endpoint_address);
+
+        if(sub_api == SUB_API_LIBUSBK) {
+            if(!WinUSBX[sub_api].SetPipePolicy(winusb_handle, endpoint_address, ISO_ALWAYS_START_ASAP, sizeof(UCHAR), &policy))
+                usbi_dbg(HANDLE_CTX(dev_handle), "failed to enable ISO_ALWAYS_START_ASAP for endpoint %02X", endpoint_address);
+        }
+    }
+
+    return LIBUSB_SUCCESS;
+}
+
+static int winusbx_claim_interface(int sub_api, struct libusb_device_handle *dev_handle, uint8_t iface) {
+    struct libusb_context            *ctx                     = HANDLE_CTX(dev_handle);
+    struct winusb_device_handle_priv *handle_priv             = get_winusb_device_handle_priv(dev_handle);
+    struct winusb_device_priv        *priv                    = usbi_get_device_priv(dev_handle->dev);
+    bool                              is_using_usbccgp        = (priv->apib->id == USB_API_COMPOSITE);
+    bool                              is_associated_interface = (priv->usb_interface[iface].num_associated_interfaces != 0);
+    HDEVINFO                          dev_info;
+    char                             *dev_interface_path = NULL;
+    char                             *dev_interface_path_guid_start;
+    char                              filter_path[] = "\\\\.\\libusb0-0000";
+    bool                              found_filter  = false;
+    HANDLE                            file_handle, winusb_handle;
+    DWORD                             err, _index;
+    int                               r;
+    uint8_t                           initialized_iface;
+
+    CHECK_WINUSBX_AVAILABLE(sub_api);
+
+    // If the device is composite, but using the default Windows composite parent driver (usbccgp)
+    // or if it's the first WinUSB-like interface, we get a handle through Initialize().
+    // If it's an associated interface, and is the first one (iface==bFirstInterface), we also
+    // want to get the handle through Initialize(). If it's an associated interface, and NOT
+    // the first one, we want to direct control to the 'else' where the handle will be obtained
+    // via GetAssociatedInterface().
+    if(((is_using_usbccgp) || (iface == 0)) && (!is_associated_interface || (iface == priv->usb_interface[iface].first_associated_interface))) {
+        // composite device (independent interfaces) or interface 0
+        file_handle = handle_priv->interface_handle[iface].dev_handle;
+        if(!HANDLE_VALID(file_handle))
+            return LIBUSB_ERROR_NOT_FOUND;
+
+        if(!WinUSBX[sub_api].Initialize(file_handle, &winusb_handle)) {
+            handle_priv->interface_handle[iface].api_handle = INVALID_HANDLE_VALUE;
+            err                                             = GetLastError();
+            switch(err) {
+            case ERROR_BAD_COMMAND:
+                // The device was disconnected
+                usbi_err(ctx, "could not access interface %u: %s", iface, windows_error_str(0));
+                return LIBUSB_ERROR_NO_DEVICE;
+            default:
+                // it may be that we're using the libusb0 filter driver.
+                // TODO: can we move this whole business into the K/0 DLL?
+                r = LIBUSB_SUCCESS;
+                for(_index = 0;; _index++) {
+                    safe_free(dev_interface_path);
+
+                    if(found_filter)
+                        break;
+
+                    r = get_interface_details_filter(ctx, &dev_info, _index, filter_path, &dev_interface_path);
+                    if((r != LIBUSB_SUCCESS) || (dev_interface_path == NULL))
+                        break;
+
+                    // ignore GUID part
+                    dev_interface_path_guid_start = strchr(dev_interface_path, '{');
+                    if(dev_interface_path_guid_start == NULL)
+                        continue;
+                    *dev_interface_path_guid_start = '\0';
+
+                    if(strncmp(dev_interface_path, priv->usb_interface[iface].path, strlen(dev_interface_path)) == 0) {
+                        file_handle = windows_open(dev_handle, filter_path, GENERIC_READ | GENERIC_WRITE);
+                        if(file_handle != INVALID_HANDLE_VALUE) {
+                            if(WinUSBX[sub_api].Initialize(file_handle, &winusb_handle)) {
+                                // Replace the existing file handle with the working one
+                                CloseHandle(handle_priv->interface_handle[iface].dev_handle);
+                                handle_priv->interface_handle[iface].dev_handle = file_handle;
+                                found_filter                                    = true;
+                            }
+                            else {
+                                usbi_err(ctx, "could not initialize filter driver for %s", filter_path);
+                                CloseHandle(file_handle);
+                            }
+                        }
+                        else {
+                            usbi_err(ctx, "could not open device %s: %s", filter_path, windows_error_str(0));
+                        }
+                    }
+                }
+                if(r != LIBUSB_SUCCESS)
+                    return r;
+                if(!found_filter) {
+                    usbi_err(ctx, "could not access interface %u: %s", iface, windows_error_str(err));
+                    return LIBUSB_ERROR_ACCESS;
+                }
+            }
+        }
+        handle_priv->interface_handle[iface].api_handle = winusb_handle;
+    }
+    else {
+        if(is_associated_interface) {
+            initialized_iface = priv->usb_interface[iface].first_associated_interface;
+            if(iface <= initialized_iface) {
+                usbi_err(ctx, "invalid associated index. iface=%u, initialized iface=%u", iface, initialized_iface);
+                return LIBUSB_ERROR_NOT_FOUND;
+            }
+        }
+        else {
+            initialized_iface = 0;
+        }
+
+        // For all other interfaces, use GetAssociatedInterface()
+        winusb_handle = handle_priv->interface_handle[initialized_iface].api_handle;
+        // It is a requirement for multiple interface devices on Windows that, to you
+        // must first claim the first interface before you claim the others
+        if(!HANDLE_VALID(winusb_handle)) {
+            file_handle = handle_priv->interface_handle[initialized_iface].dev_handle;
+            if(WinUSBX[sub_api].Initialize(file_handle, &winusb_handle)) {
+                handle_priv->interface_handle[initialized_iface].api_handle = winusb_handle;
+                usbi_warn(ctx, "auto-claimed interface %u (required to claim %u with WinUSB)", initialized_iface, iface);
+            }
+            else {
+                usbi_warn(ctx, "failed to auto-claim interface %u (required to claim %u with WinUSB): %s", initialized_iface, iface, windows_error_str(0));
+                return LIBUSB_ERROR_ACCESS;
+            }
+        }
+        if(!WinUSBX[sub_api].GetAssociatedInterface(winusb_handle, (UCHAR)(iface - 1 - initialized_iface), &handle_priv->interface_handle[iface].api_handle)) {
+            handle_priv->interface_handle[iface].api_handle = INVALID_HANDLE_VALUE;
+            switch(GetLastError()) {
+            case ERROR_NO_MORE_ITEMS:  // invalid iface
+                return LIBUSB_ERROR_NOT_FOUND;
+            case ERROR_BAD_COMMAND:  // The device was disconnected
+                return LIBUSB_ERROR_NO_DEVICE;
+            case ERROR_ALREADY_EXISTS:  // already claimed
+                return LIBUSB_ERROR_BUSY;
+            default:
+                usbi_err(ctx, "could not claim interface %u: %s", iface, windows_error_str(0));
+                return LIBUSB_ERROR_ACCESS;
+            }
+        }
+        handle_priv->interface_handle[iface].dev_handle = handle_priv->interface_handle[initialized_iface].dev_handle;
+    }
+    usbi_dbg(ctx, "claimed interface %u", iface);
+    handle_priv->active_interface = iface;
+
+    return LIBUSB_SUCCESS;
+}
+
+static int winusbx_release_interface(int sub_api, struct libusb_device_handle *dev_handle, uint8_t iface) {
+    struct winusb_device_handle_priv *handle_priv = get_winusb_device_handle_priv(dev_handle);
+    struct winusb_device_priv        *priv        = usbi_get_device_priv(dev_handle->dev);
+    HANDLE                            winusb_handle;
+
+    CHECK_WINUSBX_AVAILABLE(sub_api);
+
+    winusb_handle = handle_priv->interface_handle[iface].api_handle;
+    if(!HANDLE_VALID(winusb_handle))
+        return LIBUSB_ERROR_NOT_FOUND;
+
+    WinUSBX[sub_api].Free(winusb_handle);
+    handle_priv->interface_handle[iface].api_handle = INVALID_HANDLE_VALUE;
+
+    return LIBUSB_SUCCESS;
+}
+
+/*
+ * Return the first valid interface (of the same API type), for control transfers
+ */
+static int get_valid_interface(struct libusb_device_handle *dev_handle, int api_id) {
+    struct winusb_device_handle_priv *handle_priv = get_winusb_device_handle_priv(dev_handle);
+    struct winusb_device_priv        *priv        = usbi_get_device_priv(dev_handle->dev);
+    int                               i;
+
+    if((api_id < USB_API_WINUSBX) || (api_id > USB_API_HID)) {
+        usbi_dbg(HANDLE_CTX(dev_handle), "unsupported API ID");
+        return -1;
+    }
+
+    for(i = 0; i < USB_MAXINTERFACES; i++) {
+        if(HANDLE_VALID(handle_priv->interface_handle[i].dev_handle) && HANDLE_VALID(handle_priv->interface_handle[i].api_handle)
+           && (priv->usb_interface[i].apib->id == api_id))
+            return i;
+    }
+
+    return -1;
+}
+
+/*
+ * Check a specific interface is valid (of the same API type), for control transfers
+ */
+static int check_valid_interface(struct libusb_device_handle *dev_handle, unsigned short interface, int api_id) {
+    struct winusb_device_handle_priv *handle_priv = get_winusb_device_handle_priv(dev_handle);
+    struct winusb_device_priv        *priv        = usbi_get_device_priv(dev_handle->dev);
+
+    if(interface >= USB_MAXINTERFACES)
+        return -1;
+
+    if((api_id < USB_API_WINUSBX) || (api_id > USB_API_HID)) {
+        usbi_dbg(HANDLE_CTX(dev_handle), "unsupported API ID");
+        return -1;
+    }
+
+    // try the requested interface
+    if(HANDLE_VALID(handle_priv->interface_handle[interface].dev_handle) && HANDLE_VALID(handle_priv->interface_handle[interface].api_handle)
+       && (priv->usb_interface[interface].apib->id == api_id))
+        return interface;
+
+    return -1;
+}
+
+/*
+ * Lookup interface by endpoint address. -1 if not found
+ */
+static int interface_by_endpoint(struct winusb_device_priv *priv, struct winusb_device_handle_priv *handle_priv, uint8_t endpoint_address) {
+    int i, j;
+
+    for(i = 0; i < USB_MAXINTERFACES; i++) {
+        if(!HANDLE_VALID(handle_priv->interface_handle[i].api_handle))
+            continue;
+        if(priv->usb_interface[i].endpoint == NULL)
+            continue;
+        for(j = 0; j < priv->usb_interface[i].nb_endpoints; j++) {
+            if(priv->usb_interface[i].endpoint[j] == endpoint_address)
+                return i;
+        }
+    }
+
+    return -1;
+}
+
+static int winusbx_submit_control_transfer(int sub_api, struct usbi_transfer *itransfer) {
+    struct libusb_transfer           *transfer      = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+    struct winusb_device_priv        *priv          = usbi_get_device_priv(transfer->dev_handle->dev);
+    struct winusb_transfer_priv      *transfer_priv = get_winusb_transfer_priv(itransfer);
+    struct winusb_device_handle_priv *handle_priv   = get_winusb_device_handle_priv(transfer->dev_handle);
+    PWINUSB_SETUP_PACKET              setup         = (PWINUSB_SETUP_PACKET)transfer->buffer;
+    ULONG                             size, transferred;
+    HANDLE                            winusb_handle;
+    OVERLAPPED                       *overlapped;
+    int                               current_interface;
+
+    CHECK_WINUSBX_AVAILABLE(sub_api);
+
+    size = transfer->length - LIBUSB_CONTROL_SETUP_SIZE;
+
+    // Windows places upper limits on the control transfer size
+    // See: https://docs.microsoft.com/en-us/windows-hardware/drivers/usbcon/usb-bandwidth-allocation#maximum-transfer-size
+    if(size > MAX_CTRL_BUFFER_LENGTH)
+        return LIBUSB_ERROR_INVALID_PARAM;
+
+    if((setup->RequestType & 0x1F) == LIBUSB_RECIPIENT_INTERFACE)
+        current_interface = check_valid_interface(transfer->dev_handle, setup->Index & 0xff, USB_API_WINUSBX);
+    else
+        current_interface = get_valid_interface(transfer->dev_handle, USB_API_WINUSBX);
+    if(current_interface < 0) {
+        if(auto_claim(transfer, &current_interface, USB_API_WINUSBX) != LIBUSB_SUCCESS)
+            return LIBUSB_ERROR_NOT_FOUND;
+    }
+
+    usbi_dbg(ITRANSFER_CTX(itransfer), "will use interface %d", current_interface);
+
+    transfer_priv->interface_number = (uint8_t)current_interface;
+    winusb_handle                   = handle_priv->interface_handle[current_interface].api_handle;
+    set_transfer_priv_handle(itransfer, handle_priv->interface_handle[current_interface].dev_handle);
+    overlapped = get_transfer_priv_overlapped(itransfer);
+
+    // Sending of set configuration control requests from WinUSB creates issues, except when using libusb0.sys
+    if(sub_api != SUB_API_LIBUSB0 && (LIBUSB_REQ_TYPE(setup->RequestType) == LIBUSB_REQUEST_TYPE_STANDARD)
+       && (setup->Request == LIBUSB_REQUEST_SET_CONFIGURATION)) {
+        if(setup->Value != priv->active_config) {
+            usbi_warn(TRANSFER_CTX(transfer), "cannot set configuration other than the default one");
+            return LIBUSB_ERROR_NOT_SUPPORTED;
+        }
+        windows_force_sync_completion(itransfer, 0);
+    }
+    else {
+        if(!WinUSBX[sub_api].ControlTransfer(winusb_handle, *setup, transfer->buffer + LIBUSB_CONTROL_SETUP_SIZE, size, &transferred, overlapped)) {
+            if(GetLastError() != ERROR_IO_PENDING) {
+                usbi_warn(TRANSFER_CTX(transfer), "ControlTransfer failed: %s", windows_error_str(0));
+                return LIBUSB_ERROR_IO;
+            }
+        }
+        else {
+            windows_force_sync_completion(itransfer, transferred);
+        }
+    }
+
+    return LIBUSB_SUCCESS;
+}
+
+static int winusbx_set_interface_altsetting(int sub_api, struct libusb_device_handle *dev_handle, uint8_t iface, uint8_t altsetting) {
+    struct winusb_device_handle_priv *handle_priv = get_winusb_device_handle_priv(dev_handle);
+    struct winusb_device_priv        *priv        = usbi_get_device_priv(dev_handle->dev);
+    HANDLE                            winusb_handle;
+
+    CHECK_WINUSBX_AVAILABLE(sub_api);
+
+    winusb_handle = handle_priv->interface_handle[iface].api_handle;
+    if(!HANDLE_VALID(winusb_handle)) {
+        usbi_err(HANDLE_CTX(dev_handle), "interface must be claimed first");
+        return LIBUSB_ERROR_NOT_FOUND;
+    }
+
+    if(!WinUSBX[sub_api].SetCurrentAlternateSetting(winusb_handle, altsetting)) {
+        usbi_err(HANDLE_CTX(dev_handle), "SetCurrentAlternateSetting failed: %s", windows_error_str(0));
+        return LIBUSB_ERROR_IO;
+    }
+
+    return LIBUSB_SUCCESS;
+}
+
+static void WINAPI winusbx_native_iso_transfer_continue_stream_callback(struct libusb_transfer *transfer) {
+    // If this callback is invoked, this means that we attempted to set ContinueStream
+    // to TRUE when calling Read/WriteIsochPipeAsap in winusbx_submit_iso_transfer().
+    // The role of this callback is to fallback to ContinueStream = FALSE if the transfer
+    // did not succeed.
+
+    struct winusb_transfer_priv *transfer_priv = get_winusb_transfer_priv(LIBUSB_TRANSFER_TO_USBI_TRANSFER(transfer));
+    bool                         fallback      = (transfer->status != LIBUSB_TRANSFER_COMPLETED);
+    int                          idx;
+
+    // Restore the user callback
+    transfer->callback = transfer_priv->iso_user_callback;
+
+    for(idx = 0; idx < transfer->num_iso_packets && !fallback; idx++) {
+        if(transfer->iso_packet_desc[idx].status != LIBUSB_TRANSFER_COMPLETED)
+            fallback = true;
+    }
+
+    if(!fallback) {
+        // If the transfer was successful, we restore the user callback and call it.
+        if(transfer->callback)
+            transfer->callback(transfer);
+    }
+    else {
+        // If the transfer wasn't successful we reschedule the transfer while forcing it
+        // not to continue the stream. This might results in a 5-ms delay.
+        transfer_priv->iso_break_stream = TRUE;
+        libusb_submit_transfer(transfer);
+    }
+}
+static int winusbx_submit_iso_transfer(int sub_api, struct usbi_transfer *itransfer) {
+    struct libusb_transfer           *transfer      = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+    struct winusb_transfer_priv      *transfer_priv = get_winusb_transfer_priv(itransfer);
+    struct winusb_device_handle_priv *handle_priv   = get_winusb_device_handle_priv(transfer->dev_handle);
+    struct winusb_device_priv        *priv          = usbi_get_device_priv(transfer->dev_handle->dev);
+    HANDLE                            winusb_handle;
+    OVERLAPPED                       *overlapped;
+    BOOL                              ret;
+    int                               current_interface;
+
+    CHECK_WINUSBX_AVAILABLE(sub_api);
+
+    current_interface = interface_by_endpoint(priv, handle_priv, transfer->endpoint);
+    if(current_interface < 0) {
+        usbi_err(TRANSFER_CTX(transfer), "unable to match endpoint to an open interface - cancelling transfer");
+        return LIBUSB_ERROR_NOT_FOUND;
+    }
+
+    usbi_dbg(TRANSFER_CTX(transfer), "matched endpoint %02X with interface %d", transfer->endpoint, current_interface);
+
+    transfer_priv->interface_number = (uint8_t)current_interface;
+    winusb_handle                   = handle_priv->interface_handle[current_interface].api_handle;
+    set_transfer_priv_handle(itransfer, handle_priv->interface_handle[current_interface].dev_handle);
+    overlapped = get_transfer_priv_overlapped(itransfer);
+
+    if((sub_api == SUB_API_LIBUSBK) || (sub_api == SUB_API_LIBUSB0)) {
+        int           i;
+        UINT          offset;
+        size_t        iso_ctx_size;
+        PKISO_CONTEXT iso_context;
+
+        if(WinUSBX[sub_api].IsoReadPipe == NULL) {
+            usbi_warn(TRANSFER_CTX(transfer), "libusbK DLL does not support isoch transfers");
+            return LIBUSB_ERROR_NOT_SUPPORTED;
+        }
+
+        iso_ctx_size               = sizeof(KISO_CONTEXT) + (transfer->num_iso_packets * sizeof(KISO_PACKET));
+        transfer_priv->iso_context = iso_context = calloc(1, iso_ctx_size);
+        if(transfer_priv->iso_context == NULL)
+            return LIBUSB_ERROR_NO_MEM;
+
+        // start ASAP
+        iso_context->StartFrame      = 0;
+        iso_context->NumberOfPackets = (SHORT)transfer->num_iso_packets;
+
+        // convert the transfer packet lengths to iso_packet offsets
+        offset = 0;
+        for(i = 0; i < transfer->num_iso_packets; i++) {
+            iso_context->IsoPackets[i].offset = offset;
+            offset += transfer->iso_packet_desc[i].length;
+        }
+
+        if(IS_XFERIN(transfer)) {
+            usbi_dbg(TRANSFER_CTX(transfer), "reading %d iso packets", transfer->num_iso_packets);
+            ret = WinUSBX[sub_api].IsoReadPipe(winusb_handle, transfer->endpoint, transfer->buffer, transfer->length, overlapped, iso_context);
+        }
+        else {
+            usbi_dbg(TRANSFER_CTX(transfer), "writing %d iso packets", transfer->num_iso_packets);
+            ret = WinUSBX[sub_api].IsoWritePipe(winusb_handle, transfer->endpoint, transfer->buffer, transfer->length, overlapped, iso_context);
+        }
+
+        if(!ret && GetLastError() != ERROR_IO_PENDING) {
+            usbi_err(TRANSFER_CTX(transfer), "IsoReadPipe/IsoWritePipe failed: %s", windows_error_str(0));
+            return LIBUSB_ERROR_IO;
+        }
+
+        return LIBUSB_SUCCESS;
+    }
+    else if(sub_api == SUB_API_WINUSB) {
+        WINUSB_PIPE_INFORMATION_EX pipe_info_ex = { 0 };
+        WINUSB_ISOCH_BUFFER_HANDLE buffer_handle;
+        ULONG                      iso_transfer_size_multiple;
+        int                        out_transfer_length = 0;
+        int                        idx;
+
+        // Depending on the version of Microsoft WinUSB, isochronous transfers may not be supported.
+        if(WinUSBX[sub_api].ReadIsochPipeAsap == NULL) {
+            usbi_warn(TRANSFER_CTX(transfer), "WinUSB DLL does not support isoch transfers");
+            return LIBUSB_ERROR_NOT_SUPPORTED;
+        }
+
+        if(sizeof(struct libusb_iso_packet_descriptor) != sizeof(USBD_ISO_PACKET_DESCRIPTOR)) {
+            usbi_err(TRANSFER_CTX(transfer), "size of WinUsb and libusb isoch packet descriptors don't match");
+            return LIBUSB_ERROR_NOT_SUPPORTED;
+        }
+
+        // Query the pipe extended information to find the pipe index corresponding to the endpoint.
+        for(idx = 0; idx < priv->usb_interface[current_interface].nb_endpoints; ++idx) {
+            ret = WinUSBX[sub_api].QueryPipeEx(winusb_handle, (UINT8)priv->usb_interface[current_interface].current_altsetting, (UCHAR)idx, &pipe_info_ex);
+            if(!ret) {
+                usbi_err(TRANSFER_CTX(transfer), "couldn't query interface settings for USB pipe with index %d. Error: %s", idx, windows_error_str(0));
+                return LIBUSB_ERROR_NOT_FOUND;
+            }
+
+            if(pipe_info_ex.PipeId == transfer->endpoint && pipe_info_ex.PipeType == UsbdPipeTypeIsochronous)
+                break;
+        }
+
+        // Make sure we found the index.
+        if(idx == priv->usb_interface[current_interface].nb_endpoints) {
+            usbi_err(TRANSFER_CTX(transfer), "couldn't find isoch endpoint 0x%02x", transfer->endpoint);
+            return LIBUSB_ERROR_NOT_FOUND;
+        }
+
+        if(IS_XFERIN(transfer)) {
+            int interval = pipe_info_ex.Interval;
+
+            // For high-speed and SuperSpeed device, the interval is 2**(bInterval-1).
+            if(transfer->dev_handle->dev->speed >= LIBUSB_SPEED_HIGH)
+                interval = (1 << (pipe_info_ex.Interval - 1));
+
+            // WinUSB only supports isoch transfers spanning a full USB frames. Later, we might be smarter about this
+            // and allocate a temporary buffer. However, this is harder than it seems as its destruction would depend on overlapped
+            // IO...
+            if(transfer->dev_handle->dev->speed >= LIBUSB_SPEED_HIGH)  // Microframes (125us)
+                iso_transfer_size_multiple = (pipe_info_ex.MaximumBytesPerInterval * 8) / interval;
+            else  // Normal Frames (1ms)
+                iso_transfer_size_multiple = pipe_info_ex.MaximumBytesPerInterval / interval;
+
+            if(transfer->length % iso_transfer_size_multiple != 0) {
+                usbi_err(TRANSFER_CTX(transfer), "length of isoch buffer must be a multiple of the MaximumBytesPerInterval * 8 / Interval");
+                return LIBUSB_ERROR_INVALID_PARAM;
+            }
+        }
+        else {
+            // If this is an OUT transfer, we make sure the isoch packets are contiguous as this isn't supported otherwise.
+            bool size_should_be_zero = false;
+
+            for(idx = 0; idx < transfer->num_iso_packets; ++idx) {
+                if((size_should_be_zero && transfer->iso_packet_desc[idx].length != 0)
+                   || (transfer->iso_packet_desc[idx].length != pipe_info_ex.MaximumBytesPerInterval && idx + 1 < transfer->num_iso_packets
+                       && transfer->iso_packet_desc[idx + 1].length > 0)) {
+                    usbi_err(TRANSFER_CTX(transfer), "isoch packets for OUT transfer with WinUSB must be contiguous in memory");
+                    return LIBUSB_ERROR_INVALID_PARAM;
+                }
+
+                size_should_be_zero = (transfer->iso_packet_desc[idx].length == 0);
+                out_transfer_length += transfer->iso_packet_desc[idx].length;
+            }
+        }
+
+        if(transfer_priv->isoch_buffer_handle != NULL) {
+            if(WinUSBX[sub_api].UnregisterIsochBuffer(transfer_priv->isoch_buffer_handle)) {
+                transfer_priv->isoch_buffer_handle = NULL;
+            }
+            else {
+                usbi_err(TRANSFER_CTX(transfer), "failed to unregister WinUSB isoch buffer: %s", windows_error_str(0));
+                return LIBUSB_ERROR_OTHER;
+            }
+        }
+
+        // Register the isoch buffer to the operating system.
+        ret = WinUSBX[sub_api].RegisterIsochBuffer(winusb_handle, transfer->endpoint, transfer->buffer, transfer->length, &buffer_handle);
+        if(!ret) {
+            usbi_err(TRANSFER_CTX(transfer), "failed to register WinUSB isoch buffer: %s", windows_error_str(0));
+            return LIBUSB_ERROR_NO_MEM;
+        }
+
+        // Important note: the WinUSB_Read/WriteIsochPipeAsap API requires a ContinueStream parameter that tells whether the isochronous
+        // stream must be continued or if the WinUSB driver can schedule the transfer at its convenience. Profiling subsequent transfers
+        // with ContinueStream = FALSE showed that 5 frames, i.e. about 5 milliseconds, were left empty between each transfer. This
+        // is critical as this greatly diminish the achievable isochronous bandwidth. We solved the problem using the following strategy:
+        // - Transfers are first scheduled with ContinueStream = TRUE and with winusbx_iso_transfer_continue_stream_callback as user callback.
+        // - If the transfer succeeds, winusbx_iso_transfer_continue_stream_callback restore the user callback and calls its.
+        // - If the transfer fails, winusbx_iso_transfer_continue_stream_callback reschedule the transfer and force ContinueStream = FALSE.
+        if(!transfer_priv->iso_break_stream) {
+            transfer_priv->iso_user_callback = transfer->callback;
+            transfer->callback               = winusbx_native_iso_transfer_continue_stream_callback;
+        }
+
+        // Initiate the transfers.
+        if(IS_XFERIN(transfer))
+            ret = WinUSBX[sub_api].ReadIsochPipeAsap(buffer_handle, 0, transfer->length, !transfer_priv->iso_break_stream, transfer->num_iso_packets,
+                                                     (PUSBD_ISO_PACKET_DESCRIPTOR)transfer->iso_packet_desc, overlapped);
+        else
+            ret = WinUSBX[sub_api].WriteIsochPipeAsap(buffer_handle, 0, out_transfer_length, !transfer_priv->iso_break_stream, overlapped);
+
+        if(!ret && GetLastError() != ERROR_IO_PENDING) {
+            usbi_err(TRANSFER_CTX(transfer), "ReadIsochPipeAsap/WriteIsochPipeAsap failed: %s", windows_error_str(0));
+            if(!WinUSBX[sub_api].UnregisterIsochBuffer(buffer_handle))
+                usbi_warn(TRANSFER_CTX(transfer), "failed to unregister WinUSB isoch buffer: %s", windows_error_str(0));
+            return LIBUSB_ERROR_IO;
+        }
+
+        // Restore the ContinueStream parameter to TRUE.
+        transfer_priv->iso_break_stream = FALSE;
+
+        transfer_priv->isoch_buffer_handle = buffer_handle;
+
+        return LIBUSB_SUCCESS;
+    }
+    else {
+        PRINT_UNSUPPORTED_API(winusbx_submit_iso_transfer);
+        return LIBUSB_ERROR_NOT_SUPPORTED;
+    }
+}
+
+static int winusbx_submit_bulk_transfer(int sub_api, struct usbi_transfer *itransfer) {
+    struct libusb_transfer           *transfer      = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+    struct winusb_transfer_priv      *transfer_priv = get_winusb_transfer_priv(itransfer);
+    struct winusb_device_handle_priv *handle_priv   = get_winusb_device_handle_priv(transfer->dev_handle);
+    struct winusb_device_priv        *priv          = usbi_get_device_priv(transfer->dev_handle->dev);
+    HANDLE                            winusb_handle;
+    OVERLAPPED                       *overlapped;
+    BOOL                              ret;
+    int                               current_interface;
+
+    CHECK_WINUSBX_AVAILABLE(sub_api);
+
+    current_interface = interface_by_endpoint(priv, handle_priv, transfer->endpoint);
+    if(current_interface < 0) {
+        usbi_err(TRANSFER_CTX(transfer), "unable to match endpoint to an open interface - cancelling transfer");
+        return LIBUSB_ERROR_NOT_FOUND;
+    }
+
+    usbi_dbg(TRANSFER_CTX(transfer), "matched endpoint %02X with interface %d", transfer->endpoint, current_interface);
+
+    transfer_priv->interface_number = (uint8_t)current_interface;
+    winusb_handle                   = handle_priv->interface_handle[current_interface].api_handle;
+    set_transfer_priv_handle(itransfer, handle_priv->interface_handle[current_interface].dev_handle);
+    overlapped = get_transfer_priv_overlapped(itransfer);
+
+    if(IS_XFERIN(transfer)) {
+        usbi_dbg(TRANSFER_CTX(transfer), "reading %d bytes", transfer->length);
+        ret = WinUSBX[sub_api].ReadPipe(winusb_handle, transfer->endpoint, transfer->buffer, transfer->length, NULL, overlapped);
+    }
+    else {
+        // Set SHORT_PACKET_TERMINATE if ZLP requested.
+        // Changing this can be a problem with packets in flight, so only allow on the first transfer.
+        UCHAR    policy      = (transfer->flags & LIBUSB_TRANSFER_ADD_ZERO_PACKET) != 0;
+        uint8_t *current_zlp = &handle_priv->interface_handle[current_interface].zlp[transfer->endpoint];
+        if(*current_zlp == WINUSB_ZLP_UNSET) {
+            if(policy && !WinUSBX[sub_api].SetPipePolicy(winusb_handle, transfer->endpoint, SHORT_PACKET_TERMINATE, sizeof(UCHAR), &policy)) {
+                usbi_err(TRANSFER_CTX(transfer), "failed to set SHORT_PACKET_TERMINATE for endpoint %02X", transfer->endpoint);
+                return LIBUSB_ERROR_NOT_SUPPORTED;
+            }
+            *current_zlp = policy ? WINUSB_ZLP_ON : WINUSB_ZLP_OFF;
+        }
+        else if(policy != (*current_zlp == WINUSB_ZLP_ON)) {
+            usbi_err(TRANSFER_CTX(transfer), "cannot change ZERO_PACKET for endpoint %02X on Windows", transfer->endpoint);
+            return LIBUSB_ERROR_NOT_SUPPORTED;
+        }
+
+        usbi_dbg(TRANSFER_CTX(transfer), "writing %d bytes", transfer->length);
+        ret = WinUSBX[sub_api].WritePipe(winusb_handle, transfer->endpoint, transfer->buffer, transfer->length, NULL, overlapped);
+    }
+
+    if(!ret && GetLastError() != ERROR_IO_PENDING) {
+        usbi_err(TRANSFER_CTX(transfer), "ReadPipe/WritePipe failed: %s", windows_error_str(0));
+        return LIBUSB_ERROR_IO;
+    }
+
+    return LIBUSB_SUCCESS;
+}
+
+static int winusbx_clear_halt(int sub_api, struct libusb_device_handle *dev_handle, unsigned char endpoint) {
+    struct winusb_device_handle_priv *handle_priv = get_winusb_device_handle_priv(dev_handle);
+    struct winusb_device_priv        *priv        = usbi_get_device_priv(dev_handle->dev);
+    HANDLE                            winusb_handle;
+    int                               current_interface;
+
+    CHECK_WINUSBX_AVAILABLE(sub_api);
+
+    current_interface = interface_by_endpoint(priv, handle_priv, endpoint);
+    if(current_interface < 0) {
+        usbi_err(HANDLE_CTX(dev_handle), "unable to match endpoint to an open interface - cannot clear");
+        return LIBUSB_ERROR_NOT_FOUND;
+    }
+
+    usbi_dbg(HANDLE_CTX(dev_handle), "matched endpoint %02X with interface %d", endpoint, current_interface);
+    winusb_handle = handle_priv->interface_handle[current_interface].api_handle;
+
+    if(!WinUSBX[sub_api].ResetPipe(winusb_handle, endpoint)) {
+        usbi_err(HANDLE_CTX(dev_handle), "ResetPipe failed: %s", windows_error_str(0));
+        return LIBUSB_ERROR_NO_DEVICE;
+    }
+
+    return LIBUSB_SUCCESS;
+}
+
+static int winusbx_cancel_transfer(int sub_api, struct usbi_transfer *itransfer) {
+    struct libusb_transfer           *transfer          = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+    struct winusb_device_handle_priv *handle_priv       = get_winusb_device_handle_priv(transfer->dev_handle);
+    struct winusb_transfer_priv      *transfer_priv     = get_winusb_transfer_priv(itransfer);
+    struct winusb_device_priv        *priv              = usbi_get_device_priv(transfer->dev_handle->dev);
+    int                               current_interface = transfer_priv->interface_number;
+    HANDLE                            handle;
+
+    CHECK_WINUSBX_AVAILABLE(sub_api);
+
+    usbi_dbg(TRANSFER_CTX(transfer), "will use interface %d", current_interface);
+
+    handle = handle_priv->interface_handle[current_interface].api_handle;
+    if(!WinUSBX[sub_api].AbortPipe(handle, transfer->endpoint)) {
+        usbi_err(TRANSFER_CTX(transfer), "AbortPipe failed: %s", windows_error_str(0));
+        return LIBUSB_ERROR_NO_DEVICE;
+    }
+
+    return LIBUSB_SUCCESS;
+}
+
+/*
+ * from the "How to Use WinUSB to Communicate with a USB Device" Microsoft white paper
+ * (http://www.microsoft.com/whdc/connect/usb/winusb_howto.mspx):
+ * "WinUSB does not support host-initiated reset port and cycle port operations" and
+ * IOCTL_INTERNAL_USB_CYCLE_PORT is only available in kernel mode and the
+ * IOCTL_USB_HUB_CYCLE_PORT ioctl was removed from Vista => the best we can do is
+ * cycle the pipes (and even then, the control pipe can not be reset using WinUSB)
+ */
+// TODO: (post hotplug): see if we can force eject the device and redetect it (reuse hotplug?)
+static int winusbx_reset_device(int sub_api, struct libusb_device_handle *dev_handle) {
+    struct winusb_device_handle_priv *handle_priv = get_winusb_device_handle_priv(dev_handle);
+    struct winusb_device_priv        *priv        = usbi_get_device_priv(dev_handle->dev);
+    HANDLE                            winusb_handle;
+    int                               i, j;
+
+    CHECK_WINUSBX_AVAILABLE(sub_api);
+
+    // Reset any available pipe (except control)
+    for(i = 0; i < USB_MAXINTERFACES; i++) {
+        winusb_handle = handle_priv->interface_handle[i].api_handle;
+        if(HANDLE_VALID(winusb_handle)) {
+            for(j = 0; j < priv->usb_interface[i].nb_endpoints; j++) {
+                usbi_dbg(HANDLE_CTX(dev_handle), "resetting ep %02X", priv->usb_interface[i].endpoint[j]);
+                if(!WinUSBX[sub_api].AbortPipe(winusb_handle, priv->usb_interface[i].endpoint[j]))
+                    usbi_err(HANDLE_CTX(dev_handle), "AbortPipe (pipe address %02X) failed: %s", priv->usb_interface[i].endpoint[j], windows_error_str(0));
+
+                // FlushPipe seems to fail on OUT pipes
+                if(IS_EPIN(priv->usb_interface[i].endpoint[j]) && (!WinUSBX[sub_api].FlushPipe(winusb_handle, priv->usb_interface[i].endpoint[j])))
+                    usbi_err(HANDLE_CTX(dev_handle), "FlushPipe (pipe address %02X) failed: %s", priv->usb_interface[i].endpoint[j], windows_error_str(0));
+
+                if(!WinUSBX[sub_api].ResetPipe(winusb_handle, priv->usb_interface[i].endpoint[j]))
+                    usbi_err(HANDLE_CTX(dev_handle), "ResetPipe (pipe address %02X) failed: %s", priv->usb_interface[i].endpoint[j], windows_error_str(0));
+            }
+        }
+    }
+
+    // libusbK & libusb0 have the ability to issue an actual device reset
+    if((sub_api != SUB_API_WINUSB) && (WinUSBX[sub_api].ResetDevice != NULL)) {
+        winusb_handle = handle_priv->interface_handle[0].api_handle;
+        if(HANDLE_VALID(winusb_handle))
+            WinUSBX[sub_api].ResetDevice(winusb_handle);
+    }
+
+    return LIBUSB_SUCCESS;
+}
+
+static enum libusb_transfer_status winusbx_copy_transfer_data(int sub_api, struct usbi_transfer *itransfer, DWORD length) {
+    struct libusb_transfer      *transfer      = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+    struct winusb_transfer_priv *transfer_priv = get_winusb_transfer_priv(itransfer);
+    int                          i;
+
+    if(transfer->type == LIBUSB_TRANSFER_TYPE_ISOCHRONOUS) {
+        struct winusb_device_priv *priv = usbi_get_device_priv(transfer->dev_handle->dev);
+
+        if(sub_api == SUB_API_NOTSET)
+            sub_api = priv->sub_api;
+        if(WinUSBX[sub_api].hDll == NULL)
+            return LIBUSB_TRANSFER_ERROR;
+
+        // for isochronous, need to copy the individual iso packet actual_lengths and statuses
+        if((sub_api == SUB_API_LIBUSBK) || (sub_api == SUB_API_LIBUSB0)) {
+            // iso only supported on libusbk-based backends for now
+            PKISO_CONTEXT iso_context = transfer_priv->iso_context;
+            for(i = 0; i < transfer->num_iso_packets; i++) {
+                if(IS_XFERIN(transfer)) {
+                    transfer->iso_packet_desc[i].actual_length = iso_context->IsoPackets[i].actual_length;
+                }
+                else {
+                    // On Windows the usbd Length field is not used for OUT transfers.
+                    // Copy the requested value back for consistency with other platforms.
+                    transfer->iso_packet_desc[i].actual_length = transfer->iso_packet_desc[i].length;
+                }
+                transfer->iso_packet_desc[i].status = usbd_status_to_libusb_transfer_status(iso_context->IsoPackets[i].status);
+            }
+        }
+        else if(sub_api == SUB_API_WINUSB) {
+            if(IS_XFERIN(transfer)) {
+                /* Convert isochronous packet descriptor between Windows and libusb representation.
+                 * Both representation are guaranteed to have the same length in bytes.*/
+                PUSBD_ISO_PACKET_DESCRIPTOR usbd_iso_packet_desc = (PUSBD_ISO_PACKET_DESCRIPTOR)transfer->iso_packet_desc;
+                for(i = 0; i < transfer->num_iso_packets; i++) {
+                    unsigned int packet_length = (i < transfer->num_iso_packets - 1) ? (usbd_iso_packet_desc[i + 1].Offset - usbd_iso_packet_desc[i].Offset)
+                                                                                     : usbd_iso_packet_desc[i].Length;
+                    unsigned int actual_length = usbd_iso_packet_desc[i].Length;
+                    USBD_STATUS  status        = usbd_iso_packet_desc[i].Status;
+
+                    transfer->iso_packet_desc[i].length        = packet_length;
+                    transfer->iso_packet_desc[i].actual_length = actual_length;
+                    transfer->iso_packet_desc[i].status        = usbd_status_to_libusb_transfer_status(status);
+                }
+            }
+            else {
+                for(i = 0; i < transfer->num_iso_packets; i++) {
+                    transfer->iso_packet_desc[i].status = LIBUSB_TRANSFER_COMPLETED;
+                    // On Windows the usbd Length field is not used for OUT transfers.
+                    // Copy the requested value back for consistency with other platforms.
+                    transfer->iso_packet_desc[i].actual_length = transfer->iso_packet_desc[i].length;
+                }
+            }
+        }
+        else {
+            // This should only occur if backend is not set correctly or other backend isoc is partially implemented
+            PRINT_UNSUPPORTED_API(copy_transfer_data);
+            return LIBUSB_TRANSFER_ERROR;
+        }
+    }
+
+    itransfer->transferred += (int)length;
+    return LIBUSB_TRANSFER_COMPLETED;
+}
+
+/*
+ * Internal HID Support functions (from libusb-win32)
+ * Note that functions that complete data transfer synchronously must return
+ * LIBUSB_COMPLETED instead of LIBUSB_SUCCESS
+ */
+static int _hid_get_hid_descriptor(struct hid_device_priv *dev, void *data, size_t *size);
+static int _hid_get_report_descriptor(struct hid_device_priv *dev, void *data, size_t *size);
+
+static int _hid_wcslen(WCHAR *str) {
+    int i = 0;
+
+    while(str[i] && (str[i] != 0x409))
+        i++;
+
+    return i;
+}
+
+static int _hid_get_device_descriptor(struct hid_device_priv *hid_priv, void *data, size_t *size) {
+    struct libusb_device_descriptor d;
+
+    d.bLength            = LIBUSB_DT_DEVICE_SIZE;
+    d.bDescriptorType    = LIBUSB_DT_DEVICE;
+    d.bcdUSB             = 0x0200; /* 2.00 */
+    d.bDeviceClass       = 0;
+    d.bDeviceSubClass    = 0;
+    d.bDeviceProtocol    = 0;
+    d.bMaxPacketSize0    = 64; /* fix this! */
+    d.idVendor           = (uint16_t)hid_priv->vid;
+    d.idProduct          = (uint16_t)hid_priv->pid;
+    d.bcdDevice          = 0x0100;
+    d.iManufacturer      = hid_priv->string_index[0];
+    d.iProduct           = hid_priv->string_index[1];
+    d.iSerialNumber      = hid_priv->string_index[2];
+    d.bNumConfigurations = 1;
+
+    if(*size > LIBUSB_DT_DEVICE_SIZE)
+        *size = LIBUSB_DT_DEVICE_SIZE;
+    memcpy(data, &d, *size);
+
+    return LIBUSB_COMPLETED;
+}
+
+static int _hid_get_config_descriptor(struct hid_device_priv *hid_priv, void *data, size_t *size) {
+    char                                num_endpoints    = 0;
+    size_t                              config_total_len = 0;
+    char                                tmp[HID_MAX_CONFIG_DESC_SIZE];
+    struct libusb_config_descriptor    *cd;
+    struct libusb_interface_descriptor *id;
+    struct libusb_hid_descriptor       *hd;
+    struct libusb_endpoint_descriptor  *ed;
+    size_t                              tmp_size;
+
+    if(hid_priv->input_report_size)
+        num_endpoints++;
+    if(hid_priv->output_report_size)
+        num_endpoints++;
+
+    config_total_len = LIBUSB_DT_CONFIG_SIZE + LIBUSB_DT_INTERFACE_SIZE + LIBUSB_DT_HID_SIZE + num_endpoints * LIBUSB_DT_ENDPOINT_SIZE;
+
+    cd = (struct libusb_config_descriptor *)tmp;
+    id = (struct libusb_interface_descriptor *)(tmp + LIBUSB_DT_CONFIG_SIZE);
+    hd = (struct libusb_hid_descriptor *)(tmp + LIBUSB_DT_CONFIG_SIZE + LIBUSB_DT_INTERFACE_SIZE);
+    ed = (struct libusb_endpoint_descriptor *)(tmp + LIBUSB_DT_CONFIG_SIZE + LIBUSB_DT_INTERFACE_SIZE + LIBUSB_DT_HID_SIZE);
+
+    cd->bLength             = LIBUSB_DT_CONFIG_SIZE;
+    cd->bDescriptorType     = LIBUSB_DT_CONFIG;
+    cd->wTotalLength        = (uint16_t)config_total_len;
+    cd->bNumInterfaces      = 1;
+    cd->bConfigurationValue = 1;
+    cd->iConfiguration      = 0;
+    cd->bmAttributes        = 1 << 7; /* bus powered */
+    cd->MaxPower            = 50;
+
+    id->bLength            = LIBUSB_DT_INTERFACE_SIZE;
+    id->bDescriptorType    = LIBUSB_DT_INTERFACE;
+    id->bInterfaceNumber   = 0;
+    id->bAlternateSetting  = 0;
+    id->bNumEndpoints      = num_endpoints;
+    id->bInterfaceClass    = 3;
+    id->bInterfaceSubClass = 0;
+    id->bInterfaceProtocol = 0;
+    id->iInterface         = 0;
+
+    tmp_size = LIBUSB_DT_HID_SIZE;
+    _hid_get_hid_descriptor(hid_priv, hd, &tmp_size);
+
+    if(hid_priv->input_report_size) {
+        ed->bLength          = LIBUSB_DT_ENDPOINT_SIZE;
+        ed->bDescriptorType  = LIBUSB_DT_ENDPOINT;
+        ed->bEndpointAddress = HID_IN_EP;
+        ed->bmAttributes     = 3;
+        ed->wMaxPacketSize   = hid_priv->input_report_size - 1;
+        ed->bInterval        = 10;
+        ed                   = (struct libusb_endpoint_descriptor *)((char *)ed + LIBUSB_DT_ENDPOINT_SIZE);
+    }
+
+    if(hid_priv->output_report_size) {
+        ed->bLength          = LIBUSB_DT_ENDPOINT_SIZE;
+        ed->bDescriptorType  = LIBUSB_DT_ENDPOINT;
+        ed->bEndpointAddress = HID_OUT_EP;
+        ed->bmAttributes     = 3;
+        ed->wMaxPacketSize   = hid_priv->output_report_size - 1;
+        ed->bInterval        = 10;
+    }
+
+    if(*size > config_total_len)
+        *size = config_total_len;
+    memcpy(data, tmp, *size);
+
+    return LIBUSB_COMPLETED;
+}
+
+static int _hid_get_string_descriptor(struct hid_device_priv *hid_priv, int _index, void *data, size_t *size, HANDLE hid_handle) {
+    void  *tmp = NULL;
+    WCHAR  string[MAX_USB_STRING_LENGTH];
+    size_t tmp_size = 0;
+    int    i;
+
+    /* language ID, EN-US */
+    char string_langid[] = { 0x09, 0x04 };
+
+    if(_index == 0) {
+        tmp      = string_langid;
+        tmp_size = sizeof(string_langid) + 2;
+    }
+    else {
+        for(i = 0; i < 3; i++) {
+            if(_index == (hid_priv->string_index[i])) {
+                tmp      = hid_priv->string[i];
+                tmp_size = (_hid_wcslen(hid_priv->string[i]) + 1) * sizeof(WCHAR);
+                break;
+            }
+        }
+
+        if(i == 3) {
+            if(!HidD_GetIndexedString(hid_handle, _index, string, sizeof(string)))
+                return LIBUSB_ERROR_INVALID_PARAM;
+            tmp      = string;
+            tmp_size = (_hid_wcslen(string) + 1) * sizeof(WCHAR);
+        }
+    }
+
+    if(!tmp_size)
+        return LIBUSB_ERROR_INVALID_PARAM;
+
+    if(tmp_size < *size)
+        *size = tmp_size;
+
+    // 2 byte header
+    if(*size)
+        ((uint8_t *)data)[0] = (uint8_t)tmp_size;
+    if(*size > 1)
+        ((uint8_t *)data)[1] = LIBUSB_DT_STRING;
+    if(*size > 2)
+        memcpy((uint8_t *)data + 2, tmp, *size - 2);
+
+    return LIBUSB_COMPLETED;
+}
+
+static int _hid_get_hid_descriptor(struct hid_device_priv *hid_priv, void *data, size_t *size) {
+    struct libusb_hid_descriptor d;
+    uint8_t                      tmp[MAX_HID_DESCRIPTOR_SIZE];
+    size_t                       report_len = MAX_HID_DESCRIPTOR_SIZE;
+
+    _hid_get_report_descriptor(hid_priv, tmp, &report_len);
+
+    d.bLength                = LIBUSB_DT_HID_SIZE;
+    d.bDescriptorType        = LIBUSB_DT_HID;
+    d.bcdHID                 = 0x0110; /* 1.10 */
+    d.bCountryCode           = 0;
+    d.bNumDescriptors        = 1;
+    d.bClassDescriptorType   = LIBUSB_DT_REPORT;
+    d.wClassDescriptorLength = (uint16_t)report_len;
+
+    if(*size > LIBUSB_DT_HID_SIZE)
+        *size = LIBUSB_DT_HID_SIZE;
+    memcpy(data, &d, *size);
+
+    return LIBUSB_COMPLETED;
+}
+
+static int _hid_get_report_descriptor(struct hid_device_priv *hid_priv, void *data, size_t *size) {
+    uint8_t d[MAX_HID_DESCRIPTOR_SIZE];
+    size_t  i = 0;
+
+    /* usage page */
+    d[i++] = 0x06;
+    d[i++] = hid_priv->usagePage & 0xFF;
+    d[i++] = hid_priv->usagePage >> 8;
+    /* usage */
+    d[i++] = 0x09;
+    d[i++] = (uint8_t)hid_priv->usage;
+    /* start collection (application) */
+    d[i++] = 0xA1;
+    d[i++] = 0x01;
+    /* input report */
+    if(hid_priv->input_report_size) {
+        /* usage (vendor defined) */
+        d[i++] = 0x09;
+        d[i++] = 0x01;
+        /* logical minimum (0) */
+        d[i++] = 0x15;
+        d[i++] = 0x00;
+        /* logical maximum (255) */
+        d[i++] = 0x25;
+        d[i++] = 0xFF;
+        /* report size (8 bits) */
+        d[i++] = 0x75;
+        d[i++] = 0x08;
+        /* report count */
+        d[i++] = 0x95;
+        d[i++] = (uint8_t)hid_priv->input_report_size - 1;
+        /* input (data, variable, absolute) */
+        d[i++] = 0x81;
+        d[i++] = 0x00;
+    }
+    /* output report */
+    if(hid_priv->output_report_size) {
+        /* usage (vendor defined) */
+        d[i++] = 0x09;
+        d[i++] = 0x02;
+        /* logical minimum (0) */
+        d[i++] = 0x15;
+        d[i++] = 0x00;
+        /* logical maximum (255) */
+        d[i++] = 0x25;
+        d[i++] = 0xFF;
+        /* report size (8 bits) */
+        d[i++] = 0x75;
+        d[i++] = 0x08;
+        /* report count */
+        d[i++] = 0x95;
+        d[i++] = (uint8_t)hid_priv->output_report_size - 1;
+        /* output (data, variable, absolute) */
+        d[i++] = 0x91;
+        d[i++] = 0x00;
+    }
+    /* feature report */
+    if(hid_priv->feature_report_size) {
+        /* usage (vendor defined) */
+        d[i++] = 0x09;
+        d[i++] = 0x03;
+        /* logical minimum (0) */
+        d[i++] = 0x15;
+        d[i++] = 0x00;
+        /* logical maximum (255) */
+        d[i++] = 0x25;
+        d[i++] = 0xFF;
+        /* report size (8 bits) */
+        d[i++] = 0x75;
+        d[i++] = 0x08;
+        /* report count */
+        d[i++] = 0x95;
+        d[i++] = (uint8_t)hid_priv->feature_report_size - 1;
+        /* feature (data, variable, absolute) */
+        d[i++] = 0xb2;
+        d[i++] = 0x02;
+        d[i++] = 0x01;
+    }
+
+    /* end collection */
+    d[i++] = 0xC0;
+
+    if(*size > i)
+        *size = i;
+    memcpy(data, d, *size);
+
+    return LIBUSB_COMPLETED;
+}
+
+static int _hid_get_descriptor(struct libusb_device *dev, HANDLE hid_handle, int recipient, int type, int _index, void *data, size_t *size) {
+    struct winusb_device_priv *priv = usbi_get_device_priv(dev);
+    UNUSED(recipient);
+
+    switch(type) {
+    case LIBUSB_DT_DEVICE:
+        usbi_dbg(DEVICE_CTX(dev), "LIBUSB_DT_DEVICE");
+        return _hid_get_device_descriptor(priv->hid, data, size);
+    case LIBUSB_DT_CONFIG:
+        usbi_dbg(DEVICE_CTX(dev), "LIBUSB_DT_CONFIG");
+        if(!_index)
+            return _hid_get_config_descriptor(priv->hid, data, size);
+        return LIBUSB_ERROR_INVALID_PARAM;
+    case LIBUSB_DT_STRING:
+        usbi_dbg(DEVICE_CTX(dev), "LIBUSB_DT_STRING");
+        return _hid_get_string_descriptor(priv->hid, _index, data, size, hid_handle);
+    case LIBUSB_DT_HID:
+        usbi_dbg(DEVICE_CTX(dev), "LIBUSB_DT_HID");
+        if(!_index)
+            return _hid_get_hid_descriptor(priv->hid, data, size);
+        return LIBUSB_ERROR_INVALID_PARAM;
+    case LIBUSB_DT_REPORT:
+        usbi_dbg(DEVICE_CTX(dev), "LIBUSB_DT_REPORT");
+        if(!_index)
+            return _hid_get_report_descriptor(priv->hid, data, size);
+        return LIBUSB_ERROR_INVALID_PARAM;
+    case LIBUSB_DT_PHYSICAL:
+        usbi_dbg(DEVICE_CTX(dev), "LIBUSB_DT_PHYSICAL");
+        if(HidD_GetPhysicalDescriptor(hid_handle, data, (ULONG)*size))
+            return LIBUSB_COMPLETED;
+        return LIBUSB_ERROR_OTHER;
+    }
+
+    usbi_warn(DEVICE_CTX(dev), "unsupported");
+    return LIBUSB_ERROR_NOT_SUPPORTED;
+}
+
+static int _hid_get_report(struct libusb_device *dev, HANDLE hid_handle, int id, void *data, struct winusb_transfer_priv *tp, size_t size,
+                           OVERLAPPED *overlapped, int report_type) {
+    DWORD    ioctl_code, expected_size = (DWORD)size;
+    uint8_t *buf;
+
+    if(tp->hid_buffer != NULL)
+        usbi_err(DEVICE_CTX(dev), "program assertion failed - hid_buffer is not NULL");
+
+    if((size == 0) || (size > MAX_HID_REPORT_SIZE)) {
+        usbi_warn(DEVICE_CTX(dev), "invalid size (%" PRIuPTR ")", (uintptr_t)size);
+        return LIBUSB_ERROR_INVALID_PARAM;
+    }
+
+    switch(report_type) {
+    case HID_REPORT_TYPE_INPUT:
+        ioctl_code = IOCTL_HID_GET_INPUT_REPORT;
+        break;
+    case HID_REPORT_TYPE_FEATURE:
+        ioctl_code = IOCTL_HID_GET_FEATURE;
+        break;
+    default:
+        usbi_warn(DEVICE_CTX(dev), "unknown HID report type %d", report_type);
+        return LIBUSB_ERROR_INVALID_PARAM;
+    }
+
+    // Add a trailing byte to detect overflows
+    buf = calloc(1, expected_size + 1);
+    if(buf == NULL)
+        return LIBUSB_ERROR_NO_MEM;
+
+    buf[0] = (uint8_t)id;  // Must be set always
+    usbi_dbg(DEVICE_CTX(dev), "report ID: 0x%02X", buf[0]);
+
+    // NB: The size returned by DeviceIoControl doesn't include report IDs when not in use (0)
+    if(!DeviceIoControl(hid_handle, ioctl_code, buf, expected_size + 1, buf, expected_size + 1, NULL, overlapped)) {
+        if(GetLastError() != ERROR_IO_PENDING) {
+            usbi_err(DEVICE_CTX(dev), "failed to read HID Report: %s", windows_error_str(0));
+            free(buf);
+            return LIBUSB_ERROR_IO;
+        }
+    }
+
+    // Asynchronous wait
+    tp->hid_buffer        = buf;
+    tp->hid_dest          = data;  // copy dest, as not necessarily the start of the transfer buffer
+    tp->hid_expected_size = expected_size;
+
+    return LIBUSB_SUCCESS;
+}
+
+static int _hid_set_report(struct libusb_device *dev, HANDLE hid_handle, int id, void *data, struct winusb_transfer_priv *tp, size_t size,
+                           OVERLAPPED *overlapped, int report_type) {
+    DWORD ioctl_code, write_size = (DWORD)size;
+    // If an id is reported, we must allow MAX_HID_REPORT_SIZE + 1
+    size_t   max_report_size = MAX_HID_REPORT_SIZE + (id ? 1 : 0);
+    uint8_t *buf;
+
+    if(tp->hid_buffer != NULL)
+        usbi_err(DEVICE_CTX(dev), "program assertion failed - hid_buffer is not NULL");
+
+    if((size == 0) || (size > max_report_size)) {
+        usbi_warn(DEVICE_CTX(dev), "invalid size (%" PRIuPTR ")", (uintptr_t)size);
+        return LIBUSB_ERROR_INVALID_PARAM;
+    }
+
+    switch(report_type) {
+    case HID_REPORT_TYPE_OUTPUT:
+        ioctl_code = IOCTL_HID_SET_OUTPUT_REPORT;
+        break;
+    case HID_REPORT_TYPE_FEATURE:
+        ioctl_code = IOCTL_HID_SET_FEATURE;
+        break;
+    default:
+        usbi_warn(DEVICE_CTX(dev), "unknown HID report type %d", report_type);
+        return LIBUSB_ERROR_INVALID_PARAM;
+    }
+
+    usbi_dbg(DEVICE_CTX(dev), "report ID: 0x%02X", id);
+    // When report IDs are not used (i.e. when id == 0), we must add
+    // a null report ID. Otherwise, we just use original data buffer
+    if(id == 0)
+        write_size++;
+
+    buf = malloc(write_size);
+    if(buf == NULL)
+        return LIBUSB_ERROR_NO_MEM;
+
+    if(id == 0) {
+        buf[0] = 0;
+        memcpy(buf + 1, data, size);
+    }
+    else {
+        // This seems like a waste, but if we don't duplicate the
+        // data, we'll get issues when freeing hid_buffer
+        memcpy(buf, data, size);
+        if(buf[0] != id)
+            usbi_warn(DEVICE_CTX(dev), "mismatched report ID (data is %02X, parameter is %02X)", buf[0], id);
+    }
+
+    // NB: The size returned by DeviceIoControl doesn't include report IDs when not in use (0)
+    if(!DeviceIoControl(hid_handle, ioctl_code, buf, write_size, buf, write_size, NULL, overlapped)) {
+        if(GetLastError() != ERROR_IO_PENDING) {
+            usbi_err(DEVICE_CTX(dev), "failed to write HID Output Report: %s", windows_error_str(0));
+            free(buf);
+            return LIBUSB_ERROR_IO;
+        }
+    }
+
+    tp->hid_buffer = buf;
+    tp->hid_dest   = NULL;
+    return LIBUSB_SUCCESS;
+}
+
+static int _hid_class_request(struct libusb_device *dev, HANDLE hid_handle, int request_type, int request, int value, int _index, void *data,
+                              struct winusb_transfer_priv *tp, size_t size, OVERLAPPED *overlapped) {
+    int report_type = (value >> 8) & 0xFF;
+    int report_id   = value & 0xFF;
+
+    UNUSED(_index);
+
+    if((LIBUSB_REQ_RECIPIENT(request_type) != LIBUSB_RECIPIENT_INTERFACE) && (LIBUSB_REQ_RECIPIENT(request_type) != LIBUSB_RECIPIENT_DEVICE))
+        return LIBUSB_ERROR_INVALID_PARAM;
+
+    if(LIBUSB_REQ_OUT(request_type) && request == HID_REQ_SET_REPORT)
+        return _hid_set_report(dev, hid_handle, report_id, data, tp, size, overlapped, report_type);
+
+    if(LIBUSB_REQ_IN(request_type) && request == HID_REQ_GET_REPORT)
+        return _hid_get_report(dev, hid_handle, report_id, data, tp, size, overlapped, report_type);
+
+    return LIBUSB_ERROR_INVALID_PARAM;
+}
+
+/*
+ * HID API functions
+ */
+static bool hid_init(struct libusb_context *ctx) {
+    DLL_GET_HANDLE(ctx, hid);
+
+    DLL_LOAD_FUNC(hid, HidD_GetAttributes, true);
+    DLL_LOAD_FUNC(hid, HidD_GetHidGuid, true);
+    DLL_LOAD_FUNC(hid, HidD_GetPreparsedData, true);
+    DLL_LOAD_FUNC(hid, HidD_FreePreparsedData, true);
+    DLL_LOAD_FUNC(hid, HidD_GetManufacturerString, true);
+    DLL_LOAD_FUNC(hid, HidD_GetProductString, true);
+    DLL_LOAD_FUNC(hid, HidD_GetSerialNumberString, true);
+    DLL_LOAD_FUNC(hid, HidD_GetIndexedString, true);
+    DLL_LOAD_FUNC(hid, HidP_GetCaps, true);
+    DLL_LOAD_FUNC(hid, HidD_SetNumInputBuffers, true);
+    DLL_LOAD_FUNC(hid, HidD_GetPhysicalDescriptor, true);
+    DLL_LOAD_FUNC(hid, HidD_FlushQueue, true);
+    DLL_LOAD_FUNC(hid, HidP_GetValueCaps, true);
+
+    return true;
+}
+
+static void hid_exit(void) {
+    DLL_FREE_HANDLE(hid);
+}
+
+// NB: open and close must ensure that they only handle interface of
+// the right API type, as these functions can be called wholesale from
+// composite_open(), with interfaces belonging to different APIs
+static int hid_open(int sub_api, struct libusb_device_handle *dev_handle) {
+    struct libusb_device             *dev         = dev_handle->dev;
+    struct winusb_device_priv        *priv        = usbi_get_device_priv(dev);
+    struct winusb_device_handle_priv *handle_priv = get_winusb_device_handle_priv(dev_handle);
+    HIDD_ATTRIBUTES                   hid_attributes;
+    PHIDP_PREPARSED_DATA              preparsed_data = NULL;
+    HIDP_CAPS                         capabilities;
+    HIDP_VALUE_CAPS                  *value_caps;
+    HANDLE                            hid_handle = INVALID_HANDLE_VALUE;
+    int                               i, j;
+    // report IDs handling
+    ULONG size[3];
+    int   nb_ids[2];  // zero and nonzero report IDs
+#if defined(ENABLE_LOGGING)
+    const char *const type[3] = { "input", "output", "feature" };
+#endif
+
+    UNUSED(sub_api);
+    CHECK_HID_AVAILABLE;
+
+    if(priv->hid == NULL) {
+        usbi_err(HANDLE_CTX(dev_handle), "program assertion failed - private HID structure is uninitialized");
+        return LIBUSB_ERROR_NOT_FOUND;
+    }
+
+    for(i = 0; i < USB_MAXINTERFACES; i++) {
+        if((priv->usb_interface[i].path != NULL) && (priv->usb_interface[i].apib->id == USB_API_HID)) {
+            hid_handle = windows_open(dev_handle, priv->usb_interface[i].path, GENERIC_READ | GENERIC_WRITE);
+            /*
+             * http://www.lvr.com/hidfaq.htm: Why do I receive "Access denied" when attempting to access my HID?
+             * "Windows 2000 and later have exclusive read/write access to HIDs that are configured as a system
+             * keyboards or mice. An application can obtain a handle to a system keyboard or mouse by not
+             * requesting READ or WRITE access with CreateFile. Applications can then use HidD_SetFeature and
+             * HidD_GetFeature (if the device supports Feature reports)."
+             */
+            if(hid_handle == INVALID_HANDLE_VALUE) {
+                usbi_warn(HANDLE_CTX(dev_handle), "could not open HID device in R/W mode (keyboard or mouse?) - trying without");
+                hid_handle = windows_open(dev_handle, priv->usb_interface[i].path, 0);
+                if(hid_handle == INVALID_HANDLE_VALUE) {
+                    usbi_err(HANDLE_CTX(dev_handle), "could not open device %s (interface %d): %s", priv->path, i, windows_error_str(0));
+                    switch(GetLastError()) {
+                    case ERROR_FILE_NOT_FOUND:  // The device was disconnected
+                        return LIBUSB_ERROR_NO_DEVICE;
+                    case ERROR_ACCESS_DENIED:
+                        return LIBUSB_ERROR_ACCESS;
+                    default:
+                        return LIBUSB_ERROR_IO;
+                    }
+                }
+                priv->usb_interface[i].restricted_functionality = true;
+            }
+            handle_priv->interface_handle[i].api_handle = hid_handle;
+        }
+    }
+
+    hid_attributes.Size = sizeof(hid_attributes);
+    do {
+        if(!HidD_GetAttributes(hid_handle, &hid_attributes)) {
+            usbi_err(HANDLE_CTX(dev_handle), "could not gain access to HID top collection (HidD_GetAttributes)");
+            break;
+        }
+
+        priv->hid->vid = hid_attributes.VendorID;
+        priv->hid->pid = hid_attributes.ProductID;
+
+        // Set the maximum available input buffer size
+        for(i = 32; HidD_SetNumInputBuffers(hid_handle, i); i *= 2)
+            ;
+        usbi_dbg(HANDLE_CTX(dev_handle), "set maximum input buffer size to %d", i / 2);
+
+        // Get the maximum input and output report size
+        if(!HidD_GetPreparsedData(hid_handle, &preparsed_data) || !preparsed_data) {
+            usbi_err(HANDLE_CTX(dev_handle), "could not read HID preparsed data (HidD_GetPreparsedData)");
+            break;
+        }
+        if(HidP_GetCaps(preparsed_data, &capabilities) != HIDP_STATUS_SUCCESS) {
+            usbi_err(HANDLE_CTX(dev_handle), "could not parse HID capabilities (HidP_GetCaps)");
+            break;
+        }
+
+        // Find out if interrupt will need report IDs
+        size[0] = capabilities.NumberInputValueCaps;
+        size[1] = capabilities.NumberOutputValueCaps;
+        size[2] = capabilities.NumberFeatureValueCaps;
+        for(j = HidP_Input; j <= HidP_Feature; j++) {
+            usbi_dbg(HANDLE_CTX(dev_handle), "%lu HID %s report value(s) found", ULONG_CAST(size[j]), type[j]);
+            priv->hid->uses_report_ids[j] = false;
+            if(size[j] > 0) {
+                value_caps = calloc(size[j], sizeof(HIDP_VALUE_CAPS));
+                if((value_caps != NULL) && (HidP_GetValueCaps((HIDP_REPORT_TYPE)j, value_caps, &size[j], preparsed_data) == HIDP_STATUS_SUCCESS)
+                   && (size[j] >= 1)) {
+                    nb_ids[0] = 0;
+                    nb_ids[1] = 0;
+                    for(i = 0; i < (int)size[j]; i++) {
+                        usbi_dbg(HANDLE_CTX(dev_handle), "  Report ID: 0x%02X", value_caps[i].ReportID);
+                        if(value_caps[i].ReportID != 0)
+                            nb_ids[1]++;
+                        else
+                            nb_ids[0]++;
+                    }
+                    if(nb_ids[1] != 0) {
+                        if(nb_ids[0] != 0)
+                            usbi_warn(HANDLE_CTX(dev_handle), "program assertion failed - zero and nonzero report IDs used for %s", type[j]);
+                        priv->hid->uses_report_ids[j] = true;
+                    }
+                }
+                else {
+                    usbi_warn(HANDLE_CTX(dev_handle), "  could not process %s report IDs", type[j]);
+                }
+                free(value_caps);
+            }
+        }
+
+        // Set the report sizes
+        priv->hid->input_report_size   = capabilities.InputReportByteLength;
+        priv->hid->output_report_size  = capabilities.OutputReportByteLength;
+        priv->hid->feature_report_size = capabilities.FeatureReportByteLength;
+
+        // Store usage and usagePage values
+        priv->hid->usage     = capabilities.Usage;
+        priv->hid->usagePage = capabilities.UsagePage;
+
+        // Fetch string descriptors
+        priv->hid->string_index[0] = dev->device_descriptor.iManufacturer;
+        if(priv->hid->string_index[0] != 0)
+            HidD_GetManufacturerString(hid_handle, priv->hid->string[0], sizeof(priv->hid->string[0]));
+        else
+            priv->hid->string[0][0] = 0;
+
+        priv->hid->string_index[1] = dev->device_descriptor.iProduct;
+        if(priv->hid->string_index[1] != 0)
+            // Using HidD_GetIndexedString() instead of HidD_GetProductString(), as the latter would otherwise return the name
+            // of the interface instead of the iProduct string whenever the iInterface member of the USB_INTERFACE_DESCRIPTOR
+            // structure for the interface is nonzero (see Remarks section in the documentation of the HID API routines)
+            HidD_GetIndexedString(hid_handle, priv->hid->string_index[1], priv->hid->string[1], sizeof(priv->hid->string[1]));
+        else
+            priv->hid->string[1][0] = 0;
+
+        priv->hid->string_index[2] = dev->device_descriptor.iSerialNumber;
+        if(priv->hid->string_index[2] != 0)
+            HidD_GetSerialNumberString(hid_handle, priv->hid->string[2], sizeof(priv->hid->string[2]));
+        else
+            priv->hid->string[2][0] = 0;
+    } while(0);
+
+    if(preparsed_data)
+        HidD_FreePreparsedData(preparsed_data);
+
+    return LIBUSB_SUCCESS;
+}
+
+static void hid_close(int sub_api, struct libusb_device_handle *dev_handle) {
+    struct winusb_device_priv        *priv        = usbi_get_device_priv(dev_handle->dev);
+    struct winusb_device_handle_priv *handle_priv = get_winusb_device_handle_priv(dev_handle);
+    HANDLE                            file_handle;
+    int                               i;
+
+    UNUSED(sub_api);
+
+    if(DLL_HANDLE_NAME(hid) == NULL)
+        return;
+
+    for(i = 0; i < USB_MAXINTERFACES; i++) {
+        if(priv->usb_interface[i].apib->id == USB_API_HID) {
+            file_handle = handle_priv->interface_handle[i].api_handle;
+            if(HANDLE_VALID(file_handle))
+                CloseHandle(file_handle);
+        }
+    }
+}
+
+static int hid_claim_interface(int sub_api, struct libusb_device_handle *dev_handle, uint8_t iface) {
+    struct winusb_device_handle_priv *handle_priv = get_winusb_device_handle_priv(dev_handle);
+    struct winusb_device_priv        *priv        = usbi_get_device_priv(dev_handle->dev);
+
+    UNUSED(sub_api);
+    CHECK_HID_AVAILABLE;
+
+    // NB: Disconnection detection is not possible in this function
+    if(priv->usb_interface[iface].path == NULL)
+        return LIBUSB_ERROR_NOT_FOUND;  // invalid iface
+
+    // We use dev_handle as a flag for interface claimed
+    if(handle_priv->interface_handle[iface].dev_handle == INTERFACE_CLAIMED)
+        return LIBUSB_ERROR_BUSY;  // already claimed
+
+    handle_priv->interface_handle[iface].dev_handle = INTERFACE_CLAIMED;
+
+    usbi_dbg(HANDLE_CTX(dev_handle), "claimed interface %u", iface);
+    handle_priv->active_interface = iface;
+
+    return LIBUSB_SUCCESS;
+}
+
+static int hid_release_interface(int sub_api, struct libusb_device_handle *dev_handle, uint8_t iface) {
+    struct winusb_device_handle_priv *handle_priv = get_winusb_device_handle_priv(dev_handle);
+    struct winusb_device_priv        *priv        = usbi_get_device_priv(dev_handle->dev);
+
+    UNUSED(sub_api);
+    CHECK_HID_AVAILABLE;
+
+    if(priv->usb_interface[iface].path == NULL)
+        return LIBUSB_ERROR_NOT_FOUND;  // invalid iface
+
+    if(handle_priv->interface_handle[iface].dev_handle != INTERFACE_CLAIMED)
+        return LIBUSB_ERROR_NOT_FOUND;  // invalid iface
+
+    handle_priv->interface_handle[iface].dev_handle = INVALID_HANDLE_VALUE;
+
+    return LIBUSB_SUCCESS;
+}
+
+static int hid_set_interface_altsetting(int sub_api, struct libusb_device_handle *dev_handle, uint8_t iface, uint8_t altsetting) {
+    UNUSED(sub_api);
+    UNUSED(iface);
+
+    CHECK_HID_AVAILABLE;
+
+    if(altsetting != 0) {
+        usbi_err(HANDLE_CTX(dev_handle), "set interface altsetting not supported for altsetting >0");
+        return LIBUSB_ERROR_NOT_SUPPORTED;
+    }
+
+    return LIBUSB_SUCCESS;
+}
+
+static int hid_submit_control_transfer(int sub_api, struct usbi_transfer *itransfer) {
+    struct libusb_transfer           *transfer      = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+    struct winusb_transfer_priv      *transfer_priv = get_winusb_transfer_priv(itransfer);
+    struct libusb_device_handle      *dev_handle    = transfer->dev_handle;
+    struct winusb_device_handle_priv *handle_priv   = get_winusb_device_handle_priv(dev_handle);
+    struct winusb_device_priv        *priv          = usbi_get_device_priv(transfer->dev_handle->dev);
+    WINUSB_SETUP_PACKET              *setup         = (WINUSB_SETUP_PACKET *)transfer->buffer;
+    HANDLE                            hid_handle;
+    OVERLAPPED                       *overlapped;
+    int                               current_interface;
+    uint8_t                           config;
+    size_t                            size;
+    int                               r;
+
+    UNUSED(sub_api);
+    CHECK_HID_AVAILABLE;
+
+    safe_free(transfer_priv->hid_buffer);
+    transfer_priv->hid_dest = NULL;
+    size                    = transfer->length - LIBUSB_CONTROL_SETUP_SIZE;
+
+    if(size > MAX_CTRL_BUFFER_LENGTH)
+        return LIBUSB_ERROR_INVALID_PARAM;
+
+    current_interface = get_valid_interface(dev_handle, USB_API_HID);
+    if(current_interface < 0) {
+        if(auto_claim(transfer, &current_interface, USB_API_HID) != LIBUSB_SUCCESS)
+            return LIBUSB_ERROR_NOT_FOUND;
+    }
+
+    usbi_dbg(ITRANSFER_CTX(itransfer), "will use interface %d", current_interface);
+
+    transfer_priv->interface_number = (uint8_t)current_interface;
+    hid_handle                      = handle_priv->interface_handle[current_interface].api_handle;
+    set_transfer_priv_handle(itransfer, hid_handle);
+    overlapped = get_transfer_priv_overlapped(itransfer);
+
+    switch(LIBUSB_REQ_TYPE(setup->RequestType)) {
+    case LIBUSB_REQUEST_TYPE_STANDARD:
+        switch(setup->Request) {
+        case LIBUSB_REQUEST_GET_DESCRIPTOR:
+            r = _hid_get_descriptor(dev_handle->dev, hid_handle, LIBUSB_REQ_RECIPIENT(setup->RequestType), (setup->Value >> 8) & 0xFF, setup->Value & 0xFF,
+                                    transfer->buffer + LIBUSB_CONTROL_SETUP_SIZE, &size);
+            break;
+        case LIBUSB_REQUEST_GET_CONFIGURATION:
+            r = winusb_get_configuration(dev_handle, &config);
+            if(r == LIBUSB_SUCCESS) {
+                size                                                     = 1;
+                ((uint8_t *)transfer->buffer)[LIBUSB_CONTROL_SETUP_SIZE] = config;
+                r                                                        = LIBUSB_COMPLETED;
+            }
+            break;
+        case LIBUSB_REQUEST_SET_CONFIGURATION:
+            if(setup->Value == priv->active_config) {
+                r = LIBUSB_COMPLETED;
+            }
+            else {
+                usbi_warn(TRANSFER_CTX(transfer), "cannot set configuration other than the default one");
+                r = LIBUSB_ERROR_NOT_SUPPORTED;
+            }
+            break;
+        case LIBUSB_REQUEST_GET_INTERFACE:
+            size                                                     = 1;
+            ((uint8_t *)transfer->buffer)[LIBUSB_CONTROL_SETUP_SIZE] = 0;
+            r                                                        = LIBUSB_COMPLETED;
+            break;
+        case LIBUSB_REQUEST_SET_INTERFACE:
+            r = hid_set_interface_altsetting(0, dev_handle, (uint8_t)setup->Index, (uint8_t)setup->Value);
+            if(r == LIBUSB_SUCCESS)
+                r = LIBUSB_COMPLETED;
+            break;
+        default:
+            usbi_warn(TRANSFER_CTX(transfer), "unsupported HID control request");
+            return LIBUSB_ERROR_NOT_SUPPORTED;
+        }
+        break;
+    case LIBUSB_REQUEST_TYPE_CLASS:
+        r = _hid_class_request(dev_handle->dev, hid_handle, setup->RequestType, setup->Request, setup->Value, setup->Index,
+                               transfer->buffer + LIBUSB_CONTROL_SETUP_SIZE, transfer_priv, size, overlapped);
+        break;
+    default:
+        usbi_warn(TRANSFER_CTX(transfer), "unsupported HID control request");
+        return LIBUSB_ERROR_NOT_SUPPORTED;
+    }
+
+    if(r < 0)
+        return r;
+
+    if(r == LIBUSB_COMPLETED) {
+        // Force request to be completed synchronously. Transferred size has been set by previous call
+        windows_force_sync_completion(itransfer, (ULONG)size);
+        r = LIBUSB_SUCCESS;
+    }
+
+    return LIBUSB_SUCCESS;
+}
+
+static int hid_submit_bulk_transfer(int sub_api, struct usbi_transfer *itransfer) {
+    struct libusb_transfer           *transfer      = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+    struct winusb_transfer_priv      *transfer_priv = get_winusb_transfer_priv(itransfer);
+    struct winusb_device_handle_priv *handle_priv   = get_winusb_device_handle_priv(transfer->dev_handle);
+    struct winusb_device_priv        *priv          = usbi_get_device_priv(transfer->dev_handle->dev);
+    HANDLE                            hid_handle;
+    OVERLAPPED                       *overlapped;
+    bool                              direction_in;
+    BOOL                              ret;
+    int                               current_interface, length;
+
+    UNUSED(sub_api);
+    CHECK_HID_AVAILABLE;
+
+    if(IS_XFEROUT(transfer) && (transfer->flags & LIBUSB_TRANSFER_ADD_ZERO_PACKET))
+        return LIBUSB_ERROR_NOT_SUPPORTED;
+
+    transfer_priv->hid_dest = NULL;
+    safe_free(transfer_priv->hid_buffer);
+
+    current_interface = interface_by_endpoint(priv, handle_priv, transfer->endpoint);
+    if(current_interface < 0) {
+        usbi_err(TRANSFER_CTX(transfer), "unable to match endpoint to an open interface - cancelling transfer");
+        return LIBUSB_ERROR_NOT_FOUND;
+    }
+
+    usbi_dbg(TRANSFER_CTX(transfer), "matched endpoint %02X with interface %d", transfer->endpoint, current_interface);
+
+    transfer_priv->interface_number = (uint8_t)current_interface;
+    hid_handle                      = handle_priv->interface_handle[current_interface].api_handle;
+    set_transfer_priv_handle(itransfer, hid_handle);
+    overlapped   = get_transfer_priv_overlapped(itransfer);
+    direction_in = IS_XFERIN(transfer);
+
+    // If report IDs are not in use, an extra prefix byte must be added
+    if(((direction_in) && (!priv->hid->uses_report_ids[0])) || ((!direction_in) && (!priv->hid->uses_report_ids[1])))
+        length = transfer->length + 1;
+    else
+        length = transfer->length;
+
+    // Add a trailing byte to detect overflows on input
+    transfer_priv->hid_buffer = calloc(1, length + 1);
+    if(transfer_priv->hid_buffer == NULL)
+        return LIBUSB_ERROR_NO_MEM;
+
+    transfer_priv->hid_expected_size = length;
+
+    if(direction_in) {
+        transfer_priv->hid_dest = transfer->buffer;
+        usbi_dbg(TRANSFER_CTX(transfer), "reading %d bytes (report ID: 0x00)", length);
+        ret = ReadFile(hid_handle, transfer_priv->hid_buffer, length + 1, NULL, overlapped);
+    }
+    else {
+        if(!priv->hid->uses_report_ids[1])
+            memcpy(transfer_priv->hid_buffer + 1, transfer->buffer, transfer->length);
+        else
+            // We could actually do without the calloc and memcpy in this case
+            memcpy(transfer_priv->hid_buffer, transfer->buffer, transfer->length);
+
+        usbi_dbg(TRANSFER_CTX(transfer), "writing %d bytes (report ID: 0x%02X)", length, transfer_priv->hid_buffer[0]);
+        ret = WriteFile(hid_handle, transfer_priv->hid_buffer, length, NULL, overlapped);
+    }
+
+    if(!ret && GetLastError() != ERROR_IO_PENDING) {
+        usbi_err(TRANSFER_CTX(transfer), "HID transfer failed: %s", windows_error_str(0));
+        safe_free(transfer_priv->hid_buffer);
+        return LIBUSB_ERROR_IO;
+    }
+
+    return LIBUSB_SUCCESS;
+}
+
+static int hid_reset_device(int sub_api, struct libusb_device_handle *dev_handle) {
+    struct winusb_device_handle_priv *handle_priv = get_winusb_device_handle_priv(dev_handle);
+    HANDLE                            hid_handle;
+    int                               current_interface;
+
+    UNUSED(sub_api);
+    CHECK_HID_AVAILABLE;
+
+    // Flushing the queues on all interfaces is the best we can achieve
+    for(current_interface = 0; current_interface < USB_MAXINTERFACES; current_interface++) {
+        hid_handle = handle_priv->interface_handle[current_interface].api_handle;
+        if(HANDLE_VALID(hid_handle))
+            HidD_FlushQueue(hid_handle);
+    }
+
+    return LIBUSB_SUCCESS;
+}
+
+static int hid_clear_halt(int sub_api, struct libusb_device_handle *dev_handle, unsigned char endpoint) {
+    struct winusb_device_handle_priv *handle_priv = get_winusb_device_handle_priv(dev_handle);
+    struct winusb_device_priv        *priv        = usbi_get_device_priv(dev_handle->dev);
+    HANDLE                            hid_handle;
+    int                               current_interface;
+
+    UNUSED(sub_api);
+    CHECK_HID_AVAILABLE;
+
+    current_interface = interface_by_endpoint(priv, handle_priv, endpoint);
+    if(current_interface < 0) {
+        usbi_err(HANDLE_CTX(dev_handle), "unable to match endpoint to an open interface - cannot clear");
+        return LIBUSB_ERROR_NOT_FOUND;
+    }
+
+    usbi_dbg(HANDLE_CTX(dev_handle), "matched endpoint %02X with interface %d", endpoint, current_interface);
+    hid_handle = handle_priv->interface_handle[current_interface].api_handle;
+
+    // No endpoint selection with Microsoft's implementation, so we try to flush the
+    // whole interface. Should be OK for most case scenarios
+    if(!HidD_FlushQueue(hid_handle)) {
+        usbi_err(HANDLE_CTX(dev_handle), "Flushing of HID queue failed: %s", windows_error_str(0));
+        // Device was probably disconnected
+        return LIBUSB_ERROR_NO_DEVICE;
+    }
+
+    return LIBUSB_SUCCESS;
+}
+
+// This extra function is only needed for HID
+static enum libusb_transfer_status hid_copy_transfer_data(int sub_api, struct usbi_transfer *itransfer, DWORD length) {
+    struct libusb_transfer      *transfer      = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+    struct winusb_transfer_priv *transfer_priv = get_winusb_transfer_priv(itransfer);
+    enum libusb_transfer_status  r             = LIBUSB_TRANSFER_COMPLETED;
+
+    UNUSED(sub_api);
+
+    if(transfer_priv->hid_buffer != NULL) {
+        // If we have a valid hid_buffer, it means the transfer was async
+        if(transfer_priv->hid_dest != NULL) {  // Data readout
+            if(length > 0) {
+                // First, check for overflow
+                if((size_t)length > transfer_priv->hid_expected_size) {
+                    usbi_err(TRANSFER_CTX(transfer), "OVERFLOW!");
+                    length = (DWORD)transfer_priv->hid_expected_size;
+                    r      = LIBUSB_TRANSFER_OVERFLOW;
+                }
+
+                if(transfer_priv->hid_buffer[0] == 0) {
+                    length--;
+                    memcpy(transfer_priv->hid_dest, transfer_priv->hid_buffer + 1, length);
+                }
+                else {
+                    memcpy(transfer_priv->hid_dest, transfer_priv->hid_buffer, length);
+                }
+            }
+            transfer_priv->hid_dest = NULL;
+        }
+        else if((length > 0) && (transfer_priv->hid_buffer[0] == 0)) {
+            length--;
+        }
+        // For write, we just need to free the hid buffer
+        safe_free(transfer_priv->hid_buffer);
+    }
+
+    itransfer->transferred += (int)length;
+    return r;
+}
+
+/*
+ * Composite API functions
+ */
+static int composite_open(int sub_api, struct libusb_device_handle *dev_handle) {
+    struct winusb_device_priv *priv = usbi_get_device_priv(dev_handle->dev);
+    int                        i, r = LIBUSB_ERROR_NOT_FOUND;
+    // SUB_API_MAX + 1 as the SUB_API_MAX pos is used to indicate availability of HID
+    bool available[SUB_API_MAX + 1];
+
+    UNUSED(sub_api);
+
+    for(i = 0; i < SUB_API_MAX + 1; i++)
+        available[i] = false;
+
+    for(i = 0; i < USB_MAXINTERFACES; i++) {
+        switch(priv->usb_interface[i].apib->id) {
+        case USB_API_WINUSBX:
+            if(priv->usb_interface[i].sub_api != SUB_API_NOTSET)
+                available[priv->usb_interface[i].sub_api] = true;
+            break;
+        case USB_API_HID:
+            available[SUB_API_MAX] = true;
+            break;
+        default:
+            break;
+        }
+    }
+
+    for(i = 0; i < SUB_API_MAX; i++) {  // WinUSB-like drivers
+        if(available[i]) {
+            r = usb_api_backend[USB_API_WINUSBX].open(i, dev_handle);
+            if(r != LIBUSB_SUCCESS)
+                return r;
+        }
+    }
+
+    if(available[SUB_API_MAX]) {  // HID driver
+        r = hid_open(SUB_API_NOTSET, dev_handle);
+
+        // On Windows 10 version 1903 (OS Build 18362) and later Windows blocks attempts to
+        // open HID devices with a U2F usage unless running as administrator. We ignore this
+        // failure and proceed without the HID device opened.
+        if(r == LIBUSB_ERROR_ACCESS) {
+            usbi_dbg(HANDLE_CTX(dev_handle), "ignoring access denied error while opening HID interface of composite device");
+            r = LIBUSB_SUCCESS;
+        }
+    }
+
+    return r;
+}
+
+static void composite_close(int sub_api, struct libusb_device_handle *dev_handle) {
+    struct winusb_device_priv *priv = usbi_get_device_priv(dev_handle->dev);
+    int                        i;
+    // SUB_API_MAX + 1 as the SUB_API_MAX pos is used to indicate availability of HID
+    bool available[SUB_API_MAX + 1];
+
+    UNUSED(sub_api);
+
+    for(i = 0; i < SUB_API_MAX + 1; i++)
+        available[i] = false;
+
+    for(i = 0; i < USB_MAXINTERFACES; i++) {
+        switch(priv->usb_interface[i].apib->id) {
+        case USB_API_WINUSBX:
+            if(priv->usb_interface[i].sub_api != SUB_API_NOTSET)
+                available[priv->usb_interface[i].sub_api] = true;
+            break;
+        case USB_API_HID:
+            available[SUB_API_MAX] = true;
+            break;
+        default:
+            break;
+        }
+    }
+
+    for(i = 0; i < SUB_API_MAX; i++) {  // WinUSB-like drivers
+        if(available[i])
+            usb_api_backend[USB_API_WINUSBX].close(i, dev_handle);
+    }
+
+    if(available[SUB_API_MAX])  // HID driver
+        hid_close(SUB_API_NOTSET, dev_handle);
+}
+
+static int composite_claim_interface(int sub_api, struct libusb_device_handle *dev_handle, uint8_t iface) {
+    struct winusb_device_priv *priv = usbi_get_device_priv(dev_handle->dev);
+
+    UNUSED(sub_api);
+    CHECK_SUPPORTED_API(priv->usb_interface[iface].apib, claim_interface);
+
+    return priv->usb_interface[iface].apib->claim_interface(priv->usb_interface[iface].sub_api, dev_handle, iface);
+}
+
+static int composite_set_interface_altsetting(int sub_api, struct libusb_device_handle *dev_handle, uint8_t iface, uint8_t altsetting) {
+    struct winusb_device_priv *priv = usbi_get_device_priv(dev_handle->dev);
+
+    UNUSED(sub_api);
+    CHECK_SUPPORTED_API(priv->usb_interface[iface].apib, set_interface_altsetting);
+
+    return priv->usb_interface[iface].apib->set_interface_altsetting(priv->usb_interface[iface].sub_api, dev_handle, iface, altsetting);
+}
+
+static int composite_release_interface(int sub_api, struct libusb_device_handle *dev_handle, uint8_t iface) {
+    struct winusb_device_priv *priv = usbi_get_device_priv(dev_handle->dev);
+
+    UNUSED(sub_api);
+    CHECK_SUPPORTED_API(priv->usb_interface[iface].apib, release_interface);
+
+    return priv->usb_interface[iface].apib->release_interface(priv->usb_interface[iface].sub_api, dev_handle, iface);
+}
+
+static int composite_submit_control_transfer(int sub_api, struct usbi_transfer *itransfer) {
+    struct libusb_transfer          *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+    struct winusb_device_priv       *priv     = usbi_get_device_priv(transfer->dev_handle->dev);
+    struct libusb_config_descriptor *conf_desc;
+    WINUSB_SETUP_PACKET             *setup = (WINUSB_SETUP_PACKET *)transfer->buffer;
+    int                              iface, pass, r;
+
+    UNUSED(sub_api);
+
+    // Interface shouldn't matter for control, but it does in practice, with Windows'
+    // restrictions with regards to accessing HID keyboards and mice. Try to target
+    // a specific interface first, if possible.
+    switch(LIBUSB_REQ_RECIPIENT(setup->RequestType)) {
+    case LIBUSB_RECIPIENT_INTERFACE:
+        iface = setup->Index & 0xFF;
+        break;
+    case LIBUSB_RECIPIENT_ENDPOINT:
+        r = libusb_get_active_config_descriptor(transfer->dev_handle->dev, &conf_desc);
+        if(r == LIBUSB_SUCCESS) {
+            iface = get_interface_by_endpoint(conf_desc, (setup->Index & 0xFF));
+            libusb_free_config_descriptor(conf_desc);
+            break;
+        }
+        // No break if not able to determine interface
+        // Fall through
+    default:
+        iface = -1;
+        break;
+    }
+
+    // Try and target a specific interface if the control setup indicates such
+    if((iface >= 0) && (iface < USB_MAXINTERFACES)) {
+        usbi_dbg(TRANSFER_CTX(transfer), "attempting control transfer targeted to interface %d", iface);
+        if((priv->usb_interface[iface].path != NULL) && (priv->usb_interface[iface].apib->submit_control_transfer != NULL)) {
+            r = priv->usb_interface[iface].apib->submit_control_transfer(priv->usb_interface[iface].sub_api, itransfer);
+            if(r == LIBUSB_SUCCESS)
+                return r;
+        }
+    }
+
+    // Either not targeted to a specific interface or no luck in doing so.
+    // Try a 2 pass approach with all interfaces.
+    for(pass = 0; pass < 2; pass++) {
+        for(iface = 0; iface < USB_MAXINTERFACES; iface++) {
+            if((priv->usb_interface[iface].path != NULL) && (priv->usb_interface[iface].apib->submit_control_transfer != NULL)) {
+                if((pass == 0) && (priv->usb_interface[iface].restricted_functionality)) {
+                    usbi_dbg(TRANSFER_CTX(transfer), "trying to skip restricted interface #%d (HID keyboard or mouse?)", iface);
+                    continue;
+                }
+                usbi_dbg(TRANSFER_CTX(transfer), "using interface %d", iface);
+                r = priv->usb_interface[iface].apib->submit_control_transfer(priv->usb_interface[iface].sub_api, itransfer);
+                // If not supported on this API, it may be supported on another, so don't give up yet!!
+                if(r == LIBUSB_ERROR_NOT_SUPPORTED)
+                    continue;
+                return r;
+            }
+        }
+    }
+
+    usbi_err(TRANSFER_CTX(transfer), "no libusb supported interfaces to complete request");
+    return LIBUSB_ERROR_NOT_FOUND;
+}
+
+static int composite_submit_bulk_transfer(int sub_api, struct usbi_transfer *itransfer) {
+    struct libusb_transfer           *transfer    = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+    struct winusb_device_handle_priv *handle_priv = get_winusb_device_handle_priv(transfer->dev_handle);
+    struct winusb_device_priv        *priv        = usbi_get_device_priv(transfer->dev_handle->dev);
+    int                               current_interface;
+
+    UNUSED(sub_api);
+
+    current_interface = interface_by_endpoint(priv, handle_priv, transfer->endpoint);
+    if(current_interface < 0) {
+        usbi_err(TRANSFER_CTX(transfer), "unable to match endpoint to an open interface - cancelling transfer");
+        return LIBUSB_ERROR_NOT_FOUND;
+    }
+
+    CHECK_SUPPORTED_API(priv->usb_interface[current_interface].apib, submit_bulk_transfer);
+
+    return priv->usb_interface[current_interface].apib->submit_bulk_transfer(priv->usb_interface[current_interface].sub_api, itransfer);
+}
+
+static int composite_submit_iso_transfer(int sub_api, struct usbi_transfer *itransfer) {
+    struct libusb_transfer           *transfer    = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+    struct winusb_device_handle_priv *handle_priv = get_winusb_device_handle_priv(transfer->dev_handle);
+    struct winusb_device_priv        *priv        = usbi_get_device_priv(transfer->dev_handle->dev);
+    int                               current_interface;
+
+    UNUSED(sub_api);
+
+    current_interface = interface_by_endpoint(priv, handle_priv, transfer->endpoint);
+    if(current_interface < 0) {
+        usbi_err(TRANSFER_CTX(transfer), "unable to match endpoint to an open interface - cancelling transfer");
+        return LIBUSB_ERROR_NOT_FOUND;
+    }
+
+    CHECK_SUPPORTED_API(priv->usb_interface[current_interface].apib, submit_iso_transfer);
+
+    return priv->usb_interface[current_interface].apib->submit_iso_transfer(priv->usb_interface[current_interface].sub_api, itransfer);
+}
+
+static int composite_clear_halt(int sub_api, struct libusb_device_handle *dev_handle, unsigned char endpoint) {
+    struct winusb_device_handle_priv *handle_priv = get_winusb_device_handle_priv(dev_handle);
+    struct winusb_device_priv        *priv        = usbi_get_device_priv(dev_handle->dev);
+    int                               current_interface;
+
+    UNUSED(sub_api);
+
+    current_interface = interface_by_endpoint(priv, handle_priv, endpoint);
+    if(current_interface < 0) {
+        usbi_err(HANDLE_CTX(dev_handle), "unable to match endpoint to an open interface - cannot clear");
+        return LIBUSB_ERROR_NOT_FOUND;
+    }
+
+    CHECK_SUPPORTED_API(priv->usb_interface[current_interface].apib, clear_halt);
+
+    return priv->usb_interface[current_interface].apib->clear_halt(priv->usb_interface[current_interface].sub_api, dev_handle, endpoint);
+}
+
+static int composite_cancel_transfer(int sub_api, struct usbi_transfer *itransfer) {
+    struct libusb_transfer      *transfer          = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+    struct winusb_transfer_priv *transfer_priv     = get_winusb_transfer_priv(itransfer);
+    struct winusb_device_priv   *priv              = usbi_get_device_priv(transfer->dev_handle->dev);
+    int                          current_interface = transfer_priv->interface_number;
+
+    UNUSED(sub_api);
+
+    if((current_interface < 0) || (current_interface >= USB_MAXINTERFACES)) {
+        usbi_err(TRANSFER_CTX(transfer), "program assertion failed - invalid interface_number");
+        return LIBUSB_ERROR_NOT_FOUND;
+    }
+
+    CHECK_SUPPORTED_API(priv->usb_interface[current_interface].apib, cancel_transfer);
+
+    return priv->usb_interface[current_interface].apib->cancel_transfer(priv->usb_interface[current_interface].sub_api, itransfer);
+}
+
+static int composite_reset_device(int sub_api, struct libusb_device_handle *dev_handle) {
+    struct winusb_device_priv *priv = usbi_get_device_priv(dev_handle->dev);
+    int                        i, r;
+    bool                       available[SUB_API_MAX];
+
+    UNUSED(sub_api);
+
+    for(i = 0; i < SUB_API_MAX; i++)
+        available[i] = false;
+
+    for(i = 0; i < USB_MAXINTERFACES; i++) {
+        if((priv->usb_interface[i].apib->id == USB_API_WINUSBX) && (priv->usb_interface[i].sub_api != SUB_API_NOTSET))
+            available[priv->usb_interface[i].sub_api] = true;
+    }
+
+    for(i = 0; i < SUB_API_MAX; i++) {
+        if(available[i]) {
+            r = usb_api_backend[USB_API_WINUSBX].reset_device(i, dev_handle);
+            if(r != LIBUSB_SUCCESS)
+                return r;
+        }
+    }
+
+    return LIBUSB_SUCCESS;
+}
+
+static enum libusb_transfer_status composite_copy_transfer_data(int sub_api, struct usbi_transfer *itransfer, DWORD length) {
+    struct libusb_transfer      *transfer          = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+    struct winusb_transfer_priv *transfer_priv     = get_winusb_transfer_priv(itransfer);
+    struct winusb_device_priv   *priv              = usbi_get_device_priv(transfer->dev_handle->dev);
+    int                          current_interface = transfer_priv->interface_number;
+
+    UNUSED(sub_api);
+    if(priv->usb_interface[current_interface].apib->copy_transfer_data == NULL) {
+        usbi_err(TRANSFER_CTX(transfer), "program assertion failed - no function to copy transfer data");
+        return LIBUSB_TRANSFER_ERROR;
+    }
+
+    return priv->usb_interface[current_interface].apib->copy_transfer_data(priv->usb_interface[current_interface].sub_api, itransfer, length);
+}
diff --git a/3rdparty/libusb/src/libusb/os/windows_winusb.h b/3rdparty/libusb/src/libusb/os/windows_winusb.h
new file mode 100644
index 00000000..248f78a3
--- /dev/null
+++ b/3rdparty/libusb/src/libusb/os/windows_winusb.h
@@ -0,0 +1,684 @@
+/*
+ * Windows backend for libusb 1.0
+ * Copyright © 2009-2012 Pete Batard <pete@akeo.ie>
+ * With contributions from Michael Plante, Orin Eman et al.
+ * Parts of this code adapted from libusb-win32-v1 by Stephan Meyer
+ * Major code testing contribution by Xiaofan Chen
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef LIBUSB_WINDOWS_WINUSB_H
+#define LIBUSB_WINDOWS_WINUSB_H
+
+#include <devioctl.h>
+#include <initguid.h>
+#include <usbiodef.h>
+
+#include "windows_common.h"
+
+#define MAX_CTRL_BUFFER_LENGTH 4096
+#define MAX_USB_STRING_LENGTH 128
+#define MAX_HID_REPORT_SIZE 1024
+#define MAX_HID_DESCRIPTOR_SIZE 256
+#define MAX_GUID_STRING_LENGTH 40
+#define MAX_PATH_LENGTH 256
+#define MAX_KEY_LENGTH 256
+#define LIST_SEPARATOR ';'
+
+// Handle code for HID interface that have been claimed ("dibs")
+#define INTERFACE_CLAIMED ((HANDLE)(intptr_t)0xD1B5)
+// Additional return code for HID operations that completed synchronously
+#define LIBUSB_COMPLETED (LIBUSB_SUCCESS + 1)
+
+// http://msdn.microsoft.com/en-us/library/ff545978.aspx
+// http://msdn.microsoft.com/en-us/library/ff545972.aspx
+// http://msdn.microsoft.com/en-us/library/ff545982.aspx
+// #ifndef GUID_DEVINTERFACE_USB_HOST_CONTROLLER
+// const GUID GUID_DEVINTERFACE_USB_HOST_CONTROLLER = { 0x3ABF6F2D, 0x71C4, 0x462A, { 0x8A, 0x92, 0x1E, 0x68, 0x61, 0xE6, 0xAF, 0x27 } };
+// #endif
+// #ifndef GUID_DEVINTERFACE_USB_DEVICE
+// const GUID GUID_DEVINTERFACE_USB_DEVICE = { 0xA5DCBF10, 0x6530, 0x11D2, { 0x90, 0x1F, 0x00, 0xC0, 0x4F, 0xB9, 0x51, 0xED } };
+// #endif
+#ifndef GUID_DEVINTERFACE_OPENNI_USB_DEVICE
+const GUID GUID_DEVINTERFACE_OPENNI_USB_DEVICE = { 0xc3b5f022, 0x5a42, 0x1980, { 0x19, 0x09, 0xea, 0x72, 0x09, 0x56, 0x01, 0xb1 } };
+#endif
+// #ifndef GUID_DEVINTERFACE_USB_HUB
+//  const GUID GUID_DEVINTERFACE_USB_HUB = { 0xF18A0E88, 0xC30C, 0x11D0, { 0x88, 0x15, 0x00, 0xA0, 0xC9, 0x06, 0xBE, 0xD8 } };
+// #endif
+#ifndef GUID_DEVINTERFACE_LIBUSB0_FILTER
+const GUID GUID_DEVINTERFACE_LIBUSB0_FILTER = { 0xF9F3FF14, 0xAE21, 0x48A0, { 0x8A, 0x25, 0x80, 0x11, 0xA7, 0xA9, 0x31, 0xD9 } };
+#endif
+
+// The following define MUST be == sizeof(USB_DESCRIPTOR_REQUEST)
+#define USB_DESCRIPTOR_REQUEST_SIZE 12U
+
+/*
+ * Multiple USB API backend support
+ */
+#define USB_API_UNSUPPORTED 0
+#define USB_API_HUB 1
+#define USB_API_COMPOSITE 2
+#define USB_API_WINUSBX 3
+#define USB_API_HID 4
+#define USB_API_MAX 5
+
+// Sub-APIs for WinUSB-like driver APIs (WinUSB, libusbK, libusb-win32 through the libusbK DLL)
+// Must have the same values as the KUSB_DRVID enum from libusbk.h
+#define SUB_API_NOTSET -1
+#define SUB_API_LIBUSBK 0
+#define SUB_API_LIBUSB0 1
+#define SUB_API_WINUSB 2
+#define SUB_API_MAX 3
+
+struct windows_usb_api_backend {
+    const uint8_t            id;
+    const char *const        designation;
+    const char *const *const driver_name_list;  // Driver name, without .sys, e.g. "usbccgp"
+    const uint8_t            nb_driver_names;
+    bool (*init)(struct libusb_context *ctx);
+    void (*exit)(void);
+    int (*open)(int sub_api, struct libusb_device_handle *dev_handle);
+    void (*close)(int sub_api, struct libusb_device_handle *dev_handle);
+    int (*configure_endpoints)(int sub_api, struct libusb_device_handle *dev_handle, uint8_t iface);
+    int (*claim_interface)(int sub_api, struct libusb_device_handle *dev_handle, uint8_t iface);
+    int (*set_interface_altsetting)(int sub_api, struct libusb_device_handle *dev_handle, uint8_t iface, uint8_t altsetting);
+    int (*release_interface)(int sub_api, struct libusb_device_handle *dev_handle, uint8_t iface);
+    int (*clear_halt)(int sub_api, struct libusb_device_handle *dev_handle, unsigned char endpoint);
+    int (*reset_device)(int sub_api, struct libusb_device_handle *dev_handle);
+    int (*submit_bulk_transfer)(int sub_api, struct usbi_transfer *itransfer);
+    int (*submit_iso_transfer)(int sub_api, struct usbi_transfer *itransfer);
+    int (*submit_control_transfer)(int sub_api, struct usbi_transfer *itransfer);
+    int (*cancel_transfer)(int sub_api, struct usbi_transfer *itransfer);
+    enum libusb_transfer_status (*copy_transfer_data)(int sub_api, struct usbi_transfer *itransfer, DWORD length);
+};
+
+extern const struct windows_usb_api_backend usb_api_backend[USB_API_MAX];
+
+#define PRINT_UNSUPPORTED_API(fname)          \
+    usbi_dbg(NULL,                            \
+             "unsupported API call for '%s' " \
+             "(unrecognized device driver)",  \
+             #fname)
+
+#define CHECK_SUPPORTED_API(apip, fname)       \
+    do {                                       \
+        if((apip)->fname == NULL) {            \
+            PRINT_UNSUPPORTED_API(fname);      \
+            return LIBUSB_ERROR_NOT_SUPPORTED; \
+        }                                      \
+    } while(0)
+
+/*
+ * private structures definition
+ * with inline pseudo constructors/destructors
+ */
+
+// TODO (v2+): move hid desc to libusb.h?
+struct libusb_hid_descriptor {
+    uint8_t  bLength;
+    uint8_t  bDescriptorType;
+    uint16_t bcdHID;
+    uint8_t  bCountryCode;
+    uint8_t  bNumDescriptors;
+    uint8_t  bClassDescriptorType;
+    uint16_t wClassDescriptorLength;
+};
+
+#define LIBUSB_DT_HID_SIZE 9
+#define HID_MAX_CONFIG_DESC_SIZE (LIBUSB_DT_CONFIG_SIZE + LIBUSB_DT_INTERFACE_SIZE + LIBUSB_DT_HID_SIZE + 2 * LIBUSB_DT_ENDPOINT_SIZE)
+#define HID_MAX_REPORT_SIZE 1024
+#define HID_IN_EP 0x81
+#define HID_OUT_EP 0x02
+#define LIBUSB_REQ_RECIPIENT(request_type) ((request_type)&0x1F)
+#define LIBUSB_REQ_TYPE(request_type) ((request_type) & (0x03 << 5))
+#define LIBUSB_REQ_IN(request_type) ((request_type)&LIBUSB_ENDPOINT_IN)
+#define LIBUSB_REQ_OUT(request_type) (!LIBUSB_REQ_IN(request_type))
+
+// The following are used for HID reports IOCTLs
+#define HID_IN_CTL_CODE(id) CTL_CODE(FILE_DEVICE_KEYBOARD, (id), METHOD_IN_DIRECT, FILE_ANY_ACCESS)
+#define HID_OUT_CTL_CODE(id) CTL_CODE(FILE_DEVICE_KEYBOARD, (id), METHOD_OUT_DIRECT, FILE_ANY_ACCESS)
+
+#define IOCTL_HID_GET_FEATURE HID_OUT_CTL_CODE(100)
+#define IOCTL_HID_GET_INPUT_REPORT HID_OUT_CTL_CODE(104)
+#define IOCTL_HID_SET_FEATURE HID_IN_CTL_CODE(100)
+#define IOCTL_HID_SET_OUTPUT_REPORT HID_IN_CTL_CODE(101)
+
+enum libusb_hid_request_type {
+    HID_REQ_GET_REPORT   = 0x01,
+    HID_REQ_GET_IDLE     = 0x02,
+    HID_REQ_GET_PROTOCOL = 0x03,
+    HID_REQ_SET_REPORT   = 0x09,
+    HID_REQ_SET_IDLE     = 0x0A,
+    HID_REQ_SET_PROTOCOL = 0x0B
+};
+
+enum libusb_hid_report_type { HID_REPORT_TYPE_INPUT = 0x01, HID_REPORT_TYPE_OUTPUT = 0x02, HID_REPORT_TYPE_FEATURE = 0x03 };
+
+struct hid_device_priv {
+    uint16_t vid;
+    uint16_t pid;
+    uint8_t  config;
+    uint8_t  nb_interfaces;
+    bool     uses_report_ids[3];  // input, ouptput, feature
+    uint16_t input_report_size;
+    uint16_t output_report_size;
+    uint16_t feature_report_size;
+    uint16_t usage;
+    uint16_t usagePage;
+    WCHAR    string[3][MAX_USB_STRING_LENGTH];
+    uint8_t  string_index[3];  // man, prod, ser
+};
+
+static inline struct winusb_device_priv *winusb_device_priv_init(struct libusb_device *dev) {
+    struct winusb_device_priv *priv = usbi_get_device_priv(dev);
+    int                        i;
+
+    priv->apib    = &usb_api_backend[USB_API_UNSUPPORTED];
+    priv->sub_api = SUB_API_NOTSET;
+    for(i = 0; i < USB_MAXINTERFACES; i++) {
+        priv->usb_interface[i].apib    = &usb_api_backend[USB_API_UNSUPPORTED];
+        priv->usb_interface[i].sub_api = SUB_API_NOTSET;
+    }
+
+    return priv;
+}
+
+static inline void winusb_device_priv_release(struct libusb_device *dev) {
+    struct winusb_device_priv *priv = usbi_get_device_priv(dev);
+    int                        i;
+
+    free(priv->dev_id);
+    free(priv->path);
+    if((dev->device_descriptor.bNumConfigurations > 0) && (priv->config_descriptor != NULL)) {
+        for(i = 0; i < dev->device_descriptor.bNumConfigurations; i++) {
+            if(priv->config_descriptor[i] == NULL)
+                continue;
+            free((UCHAR *)priv->config_descriptor[i] - USB_DESCRIPTOR_REQUEST_SIZE);
+        }
+    }
+    free(priv->config_descriptor);
+    free(priv->hid);
+    for(i = 0; i < USB_MAXINTERFACES; i++) {
+        free(priv->usb_interface[i].path);
+        free(priv->usb_interface[i].endpoint);
+        free(dev->sub_composite_device_id[i]);
+    }
+}
+
+// used to match a device driver (including filter drivers) against a supported API
+struct driver_lookup {
+    char        list[MAX_KEY_LENGTH + 1];  // REG_MULTI_SZ list of services (driver) names
+    const DWORD reg_prop;                  // SPDRP registry key to use to retrieve list
+    const char *designation;               // internal designation (for debug output)
+};
+
+/*
+ * Windows DDK API definitions. Most of it copied from MinGW's includes
+ */
+typedef DWORD       DEVNODE, DEVINST;
+typedef DEVNODE    *PDEVNODE, *PDEVINST;
+typedef DWORD       RETURN_TYPE;
+typedef RETURN_TYPE CONFIGRET;
+
+#define CR_SUCCESS 0x00000000
+
+/* Cfgmgr32 dependencies */
+DLL_DECLARE_HANDLE(Cfgmgr32);
+DLL_DECLARE_FUNC(WINAPI, CONFIGRET, CM_Get_Parent, (PDEVINST, DEVINST, ULONG));
+DLL_DECLARE_FUNC(WINAPI, CONFIGRET, CM_Get_Child, (PDEVINST, DEVINST, ULONG));
+
+/* AdvAPI32 dependencies */
+DLL_DECLARE_HANDLE(AdvAPI32);
+DLL_DECLARE_FUNC_PREFIXED(WINAPI, LONG, p, RegQueryValueExA, (HKEY, LPCSTR, LPDWORD, LPDWORD, LPBYTE, LPDWORD));
+DLL_DECLARE_FUNC_PREFIXED(WINAPI, LONG, p, RegCloseKey, (HKEY));
+
+/* SetupAPI dependencies */
+DLL_DECLARE_HANDLE(SetupAPI);
+DLL_DECLARE_FUNC_PREFIXED(WINAPI, HDEVINFO, p, SetupDiGetClassDevsA, (LPCGUID, PCSTR, HWND, DWORD));
+DLL_DECLARE_FUNC_PREFIXED(WINAPI, BOOL, p, SetupDiEnumDeviceInfo, (HDEVINFO, DWORD, PSP_DEVINFO_DATA));
+DLL_DECLARE_FUNC_PREFIXED(WINAPI, BOOL, p, SetupDiEnumDeviceInterfaces, (HDEVINFO, PSP_DEVINFO_DATA, LPCGUID, DWORD, PSP_DEVICE_INTERFACE_DATA));
+DLL_DECLARE_FUNC_PREFIXED(WINAPI, BOOL, p, SetupDiGetDeviceInstanceIdA, (HDEVINFO, PSP_DEVINFO_DATA, PCSTR, DWORD, PDWORD));
+DLL_DECLARE_FUNC_PREFIXED(WINAPI, BOOL, p, SetupDiGetDeviceInterfaceDetailA,
+                          (HDEVINFO, PSP_DEVICE_INTERFACE_DATA, PSP_DEVICE_INTERFACE_DETAIL_DATA_A, DWORD, PDWORD, PSP_DEVINFO_DATA));
+DLL_DECLARE_FUNC_PREFIXED(WINAPI, BOOL, p, SetupDiGetDeviceRegistryPropertyA, (HDEVINFO, PSP_DEVINFO_DATA, DWORD, PDWORD, PBYTE, DWORD, PDWORD));
+DLL_DECLARE_FUNC_PREFIXED(WINAPI, BOOL, p, SetupDiDestroyDeviceInfoList, (HDEVINFO));
+DLL_DECLARE_FUNC_PREFIXED(WINAPI, HKEY, p, SetupDiOpenDevRegKey, (HDEVINFO, PSP_DEVINFO_DATA, DWORD, DWORD, DWORD, REGSAM));
+DLL_DECLARE_FUNC_PREFIXED(WINAPI, HKEY, p, SetupDiOpenDeviceInterfaceRegKey, (HDEVINFO, PSP_DEVICE_INTERFACE_DATA, DWORD, DWORD));
+
+#define FILE_DEVICE_USB FILE_DEVICE_UNKNOWN
+
+#define USB_GET_NODE_INFORMATION 258
+#define USB_GET_DESCRIPTOR_FROM_NODE_CONNECTION 260
+#define USB_GET_NODE_CONNECTION_INFORMATION_EX 274
+#define USB_GET_NODE_CONNECTION_INFORMATION_EX_V2 279
+
+#define USB_CTL_CODE(id) CTL_CODE(FILE_DEVICE_USB, (id), METHOD_BUFFERED, FILE_ANY_ACCESS)
+
+#define IOCTL_USB_GET_NODE_INFORMATION USB_CTL_CODE(USB_GET_NODE_INFORMATION)
+
+#define IOCTL_USB_GET_DESCRIPTOR_FROM_NODE_CONNECTION USB_CTL_CODE(USB_GET_DESCRIPTOR_FROM_NODE_CONNECTION)
+
+#define IOCTL_USB_GET_NODE_CONNECTION_INFORMATION_EX USB_CTL_CODE(USB_GET_NODE_CONNECTION_INFORMATION_EX)
+
+#define IOCTL_USB_GET_NODE_CONNECTION_INFORMATION_EX_V2 USB_CTL_CODE(USB_GET_NODE_CONNECTION_INFORMATION_EX_V2)
+
+typedef enum _USB_CONNECTION_STATUS {
+    NoDeviceConnected,
+    DeviceConnected,
+    DeviceFailedEnumeration,
+    DeviceGeneralFailure,
+    DeviceCausedOvercurrent,
+    DeviceNotEnoughPower,
+    DeviceNotEnoughBandwidth,
+    DeviceHubNestedTooDeeply,
+    DeviceInLegacyHub,
+    DeviceEnumerating,
+    DeviceReset
+} USB_CONNECTION_STATUS;
+
+typedef enum _USB_DEVICE_SPEED {
+    UsbLowSpeed = 0,
+    UsbFullSpeed,
+    UsbHighSpeed,
+    UsbSuperSpeed,
+    UsbSuperSpeedPlus  // Not in Microsoft headers
+} USB_DEVICE_SPEED;
+
+typedef enum _USB_HUB_NODE { UsbHub, UsbMIParent } USB_HUB_NODE;
+
+#if defined(_MSC_VER)
+// disable /W4 MSVC warnings that are benign
+#pragma warning(push)
+#pragma warning(disable : 4214)  // bit field types other than int
+#endif
+
+// Most of the structures below need to be packed
+#include <pshpack1.h>
+
+typedef struct _USB_HUB_DESCRIPTOR {
+    UCHAR  bDescriptorLength;
+    UCHAR  bDescriptorType;
+    UCHAR  bNumberOfPorts;
+    USHORT wHubCharacteristics;
+    UCHAR  bPowerOnToPowerGood;
+    UCHAR  bHubControlCurrent;
+    UCHAR  bRemoveAndPowerMask[64];
+} USB_HUB_DESCRIPTOR, *PUSB_HUB_DESCRIPTOR;
+
+typedef struct _USB_HUB_INFORMATION {
+    USB_HUB_DESCRIPTOR HubDescriptor;
+    BOOLEAN            HubIsBusPowered;
+} USB_HUB_INFORMATION, *PUSB_HUB_INFORMATION;
+
+typedef struct _USB_NODE_INFORMATION {
+    USB_HUB_NODE NodeType;
+    union {
+        USB_HUB_INFORMATION HubInformation;
+        //		USB_MI_PARENT_INFORMATION MiParentInformation;
+    } u;
+} USB_NODE_INFORMATION, *PUSB_NODE_INFORMATION;
+
+typedef struct _USB_DESCRIPTOR_REQUEST {
+    ULONG ConnectionIndex;
+    struct {
+        UCHAR  bmRequest;
+        UCHAR  bRequest;
+        USHORT wValue;
+        USHORT wIndex;
+        USHORT wLength;
+    } SetupPacket;
+    //	UCHAR Data[0];
+} USB_DESCRIPTOR_REQUEST, *PUSB_DESCRIPTOR_REQUEST;
+
+typedef struct _USB_CONFIGURATION_DESCRIPTOR_SHORT {
+    USB_DESCRIPTOR_REQUEST       req;
+    USB_CONFIGURATION_DESCRIPTOR desc;
+} USB_CONFIGURATION_DESCRIPTOR_SHORT;
+
+typedef struct USB_INTERFACE_DESCRIPTOR {
+    UCHAR bLength;
+    UCHAR bDescriptorType;
+    UCHAR bInterfaceNumber;
+    UCHAR bAlternateSetting;
+    UCHAR bNumEndpoints;
+    UCHAR bInterfaceClass;
+    UCHAR bInterfaceSubClass;
+    UCHAR bInterfaceProtocol;
+    UCHAR iInterface;
+} USB_INTERFACE_DESCRIPTOR, *PUSB_INTERFACE_DESCRIPTOR;
+
+typedef struct _USB_NODE_CONNECTION_INFORMATION_EX {
+    ULONG                 ConnectionIndex;
+    USB_DEVICE_DESCRIPTOR DeviceDescriptor;
+    UCHAR                 CurrentConfigurationValue;
+    UCHAR                 Speed;
+    BOOLEAN               DeviceIsHub;
+    USHORT                DeviceAddress;
+    ULONG                 NumberOfOpenPipes;
+    USB_CONNECTION_STATUS ConnectionStatus;
+    //	USB_PIPE_INFO PipeList[0];
+} USB_NODE_CONNECTION_INFORMATION_EX, *PUSB_NODE_CONNECTION_INFORMATION_EX;
+
+typedef union _USB_PROTOCOLS {
+    ULONG ul;
+    struct {
+        ULONG Usb110 : 1;
+        ULONG Usb200 : 1;
+        ULONG Usb300 : 1;
+        ULONG ReservedMBZ : 29;
+    };
+} USB_PROTOCOLS, *PUSB_PROTOCOLS;
+
+typedef union _USB_NODE_CONNECTION_INFORMATION_EX_V2_FLAGS {
+    ULONG ul;
+    struct {
+        ULONG DeviceIsOperatingAtSuperSpeedOrHigher : 1;
+        ULONG DeviceIsSuperSpeedCapableOrHigher : 1;
+        ULONG DeviceIsOperatingAtSuperSpeedPlusOrHigher : 1;
+        ULONG DeviceIsSuperSpeedPlusCapableOrHigher : 1;
+        ULONG ReservedMBZ : 28;
+    };
+} USB_NODE_CONNECTION_INFORMATION_EX_V2_FLAGS, *PUSB_NODE_CONNECTION_INFORMATION_EX_V2_FLAGS;
+
+typedef struct _USB_NODE_CONNECTION_INFORMATION_EX_V2 {
+    ULONG                                       ConnectionIndex;
+    ULONG                                       Length;
+    USB_PROTOCOLS                               SupportedUsbProtocols;
+    USB_NODE_CONNECTION_INFORMATION_EX_V2_FLAGS Flags;
+} USB_NODE_CONNECTION_INFORMATION_EX_V2, *PUSB_NODE_CONNECTION_INFORMATION_EX_V2;
+
+#include <poppack.h>
+
+#if defined(_MSC_VER)
+// Restore original warnings
+#pragma warning(pop)
+#endif
+
+/* winusb.dll interface */
+
+/* pipe policies */
+#define SHORT_PACKET_TERMINATE 0x01
+#define AUTO_CLEAR_STALL 0x02
+#define PIPE_TRANSFER_TIMEOUT 0x03
+#define IGNORE_SHORT_PACKETS 0x04
+#define ALLOW_PARTIAL_READS 0x05
+#define AUTO_FLUSH 0x06
+#define RAW_IO 0x07
+#define MAXIMUM_TRANSFER_SIZE 0x08
+/* libusbK */
+#define ISO_ALWAYS_START_ASAP 0x21
+
+typedef struct _USBD_ISO_PACKET_DESCRIPTOR {
+    ULONG       Offset;
+    ULONG       Length;
+    USBD_STATUS Status;
+} USBD_ISO_PACKET_DESCRIPTOR, *PUSBD_ISO_PACKET_DESCRIPTOR;
+
+typedef enum _USBD_PIPE_TYPE { UsbdPipeTypeControl, UsbdPipeTypeIsochronous, UsbdPipeTypeBulk, UsbdPipeTypeInterrupt } USBD_PIPE_TYPE;
+
+typedef struct {
+    USBD_PIPE_TYPE PipeType;
+    UCHAR          PipeId;
+    USHORT         MaximumPacketSize;
+    UCHAR          Interval;
+    ULONG          MaximumBytesPerInterval;
+} WINUSB_PIPE_INFORMATION_EX, *PWINUSB_PIPE_INFORMATION_EX;
+
+#include <pshpack1.h>
+
+typedef struct _WINUSB_SETUP_PACKET {
+    UCHAR  RequestType;
+    UCHAR  Request;
+    USHORT Value;
+    USHORT Index;
+    USHORT Length;
+} WINUSB_SETUP_PACKET, *PWINUSB_SETUP_PACKET;
+
+#include <poppack.h>
+
+typedef PVOID WINUSB_INTERFACE_HANDLE, *PWINUSB_INTERFACE_HANDLE;
+typedef PVOID WINUSB_ISOCH_BUFFER_HANDLE, *PWINUSB_ISOCH_BUFFER_HANDLE;
+
+typedef BOOL(WINAPI *WinUsb_AbortPipe_t)(WINUSB_INTERFACE_HANDLE InterfaceHandle, UCHAR PipeID);
+typedef BOOL(WINAPI *WinUsb_ControlTransfer_t)(WINUSB_INTERFACE_HANDLE InterfaceHandle, WINUSB_SETUP_PACKET SetupPacket, PUCHAR Buffer, ULONG BufferLength,
+                                               PULONG LengthTransferred, LPOVERLAPPED Overlapped);
+typedef BOOL(WINAPI *WinUsb_FlushPipe_t)(WINUSB_INTERFACE_HANDLE InterfaceHandle, UCHAR PipeID);
+typedef BOOL(WINAPI *WinUsb_Free_t)(WINUSB_INTERFACE_HANDLE InterfaceHandle);
+typedef BOOL(WINAPI *WinUsb_GetAssociatedInterface_t)(WINUSB_INTERFACE_HANDLE InterfaceHandle, UCHAR AssociatedInterfaceIndex,
+                                                      PWINUSB_INTERFACE_HANDLE AssociatedInterfaceHandle);
+typedef BOOL(WINAPI *WinUsb_Initialize_t)(HANDLE DeviceHandle, PWINUSB_INTERFACE_HANDLE InterfaceHandle);
+typedef BOOL(WINAPI *WinUsb_QueryPipeEx_t)(WINUSB_INTERFACE_HANDLE InterfaceHandle, UCHAR AlternateInterfaceHandle, UCHAR PipeIndex,
+                                           PWINUSB_PIPE_INFORMATION_EX PipeInformationEx);
+typedef BOOL(WINAPI *WinUsb_ReadIsochPipeAsap_t)(PWINUSB_ISOCH_BUFFER_HANDLE BufferHandle, ULONG Offset, ULONG Length, BOOL ContinueStream,
+                                                 ULONG NumberOfPackets, PUSBD_ISO_PACKET_DESCRIPTOR IsoPacketDescriptors, LPOVERLAPPED Overlapped);
+typedef BOOL(WINAPI *WinUsb_ReadPipe_t)(WINUSB_INTERFACE_HANDLE InterfaceHandle, UCHAR PipeID, PUCHAR Buffer, ULONG BufferLength, PULONG LengthTransferred,
+                                        LPOVERLAPPED Overlapped);
+typedef BOOL(WINAPI *WinUsb_RegisterIsochBuffer_t)(WINUSB_INTERFACE_HANDLE InterfaceHandle, UCHAR PipeID, PVOID Buffer, ULONG BufferLength,
+                                                   PWINUSB_ISOCH_BUFFER_HANDLE BufferHandle);
+typedef BOOL(WINAPI *WinUsb_ResetPipe_t)(WINUSB_INTERFACE_HANDLE InterfaceHandle, UCHAR PipeID);
+typedef BOOL(WINAPI *WinUsb_SetCurrentAlternateSetting_t)(WINUSB_INTERFACE_HANDLE InterfaceHandle, UCHAR AlternateSetting);
+typedef BOOL(WINAPI *WinUsb_SetPipePolicy_t)(WINUSB_INTERFACE_HANDLE InterfaceHandle, UCHAR PipeID, ULONG PolicyType, ULONG ValueLength, PVOID Value);
+typedef BOOL(WINAPI *WinUsb_GetPipePolicy_t)(WINUSB_INTERFACE_HANDLE InterfaceHandle, UCHAR PipeID, ULONG PolicyType, PULONG ValueLength, PVOID Value);
+typedef BOOL(WINAPI *WinUsb_UnregisterIsochBuffer_t)(WINUSB_ISOCH_BUFFER_HANDLE BufferHandle);
+typedef BOOL(WINAPI *WinUsb_WriteIsochPipeAsap_t)(WINUSB_ISOCH_BUFFER_HANDLE BufferHandle, ULONG Offset, ULONG Length, BOOL ContinueStream,
+                                                  LPOVERLAPPED Overlapped);
+typedef BOOL(WINAPI *WinUsb_WritePipe_t)(WINUSB_INTERFACE_HANDLE InterfaceHandle, UCHAR PipeID, PUCHAR Buffer, ULONG BufferLength, PULONG LengthTransferred,
+                                         LPOVERLAPPED Overlapped);
+
+/* /!\ These must match the ones from the official libusbk.h */
+typedef enum _KUSB_FNID {
+    KUSB_FNID_Init,
+    KUSB_FNID_Free,
+    KUSB_FNID_ClaimInterface,
+    KUSB_FNID_ReleaseInterface,
+    KUSB_FNID_SetAltInterface,
+    KUSB_FNID_GetAltInterface,
+    KUSB_FNID_GetDescriptor,
+    KUSB_FNID_ControlTransfer,
+    KUSB_FNID_SetPowerPolicy,
+    KUSB_FNID_GetPowerPolicy,
+    KUSB_FNID_SetConfiguration,
+    KUSB_FNID_GetConfiguration,
+    KUSB_FNID_ResetDevice,
+    KUSB_FNID_Initialize,
+    KUSB_FNID_SelectInterface,
+    KUSB_FNID_GetAssociatedInterface,
+    KUSB_FNID_Clone,
+    KUSB_FNID_QueryInterfaceSettings,
+    KUSB_FNID_QueryDeviceInformation,
+    KUSB_FNID_SetCurrentAlternateSetting,
+    KUSB_FNID_GetCurrentAlternateSetting,
+    KUSB_FNID_QueryPipe,
+    KUSB_FNID_SetPipePolicy,
+    KUSB_FNID_GetPipePolicy,
+    KUSB_FNID_ReadPipe,
+    KUSB_FNID_WritePipe,
+    KUSB_FNID_ResetPipe,
+    KUSB_FNID_AbortPipe,
+    KUSB_FNID_FlushPipe,
+    KUSB_FNID_IsoReadPipe,
+    KUSB_FNID_IsoWritePipe,
+    KUSB_FNID_GetCurrentFrameNumber,
+    KUSB_FNID_GetOverlappedResult,
+    KUSB_FNID_GetProperty,
+    KUSB_FNID_COUNT,
+} KUSB_FNID;
+
+typedef struct _KLIB_VERSION {
+    INT Major;
+    INT Minor;
+    INT Micro;
+    INT Nano;
+} KLIB_VERSION, *PKLIB_VERSION;
+
+typedef BOOL(WINAPI *LibK_GetProcAddress_t)(PVOID ProcAddress, INT DriverID, INT FunctionID);
+
+typedef VOID(WINAPI *LibK_GetVersion_t)(PKLIB_VERSION Version);
+
+typedef BOOL(WINAPI *LibK_ResetDevice_t)(WINUSB_INTERFACE_HANDLE InterfaceHandle);
+
+// KISO_PACKET is equivalent of libusb_iso_packet_descriptor except uses absolute "offset" field instead of sequential Lengths
+typedef struct _KISO_PACKET {
+    UINT   offset;
+    USHORT actual_length;  // changed from libusbk_shared.h "Length" for clarity
+    USHORT status;
+} KISO_PACKET, *PKISO_PACKET;
+
+typedef enum _KISO_FLAG {
+    KISO_FLAG_NONE            = 0,
+    KISO_FLAG_SET_START_FRAME = 0x00000001,
+} KISO_FLAG;
+
+// KISO_CONTEXT is the conceptual equivalent of libusb_transfer except is isochronous-specific and must match libusbk's version
+typedef struct _KISO_CONTEXT {
+    KISO_FLAG   Flags;
+    UINT        StartFrame;
+    SHORT       ErrorCount;
+    SHORT       NumberOfPackets;
+    UINT        UrbHdrStatus;
+    KISO_PACKET IsoPackets[0];
+} KISO_CONTEXT, *PKISO_CONTEXT;
+
+typedef BOOL(WINAPI *LibK_IsoReadPipe_t)(WINUSB_INTERFACE_HANDLE InterfaceHandle, UCHAR PipeID, PUCHAR Buffer, ULONG BufferLength, LPOVERLAPPED Overlapped,
+                                         PKISO_CONTEXT IsoContext);
+
+typedef BOOL(WINAPI *LibK_IsoWritePipe_t)(WINUSB_INTERFACE_HANDLE InterfaceHandle, UCHAR PipeID, PUCHAR Buffer, ULONG BufferLength, LPOVERLAPPED Overlapped,
+                                          PKISO_CONTEXT IsoContext);
+
+struct winusb_interface {
+    HMODULE                             hDll;
+    WinUsb_AbortPipe_t                  AbortPipe;
+    WinUsb_ControlTransfer_t            ControlTransfer;
+    WinUsb_FlushPipe_t                  FlushPipe;
+    WinUsb_Free_t                       Free;
+    WinUsb_GetAssociatedInterface_t     GetAssociatedInterface;
+    WinUsb_Initialize_t                 Initialize;
+    WinUsb_ReadPipe_t                   ReadPipe;
+    WinUsb_ResetPipe_t                  ResetPipe;
+    WinUsb_SetCurrentAlternateSetting_t SetCurrentAlternateSetting;
+    WinUsb_SetPipePolicy_t              SetPipePolicy;
+    WinUsb_GetPipePolicy_t              GetPipePolicy;
+    WinUsb_WritePipe_t                  WritePipe;
+    union {
+        struct {
+            // Isochoronous functions for libusbK sub api:
+            LibK_IsoReadPipe_t  IsoReadPipe;
+            LibK_IsoWritePipe_t IsoWritePipe;
+            // Reset device function for libusbK sub api:
+            LibK_ResetDevice_t ResetDevice;
+        };
+        struct {
+            // Isochronous functions for WinUSB sub api:
+            WinUsb_QueryPipeEx_t           QueryPipeEx;
+            WinUsb_ReadIsochPipeAsap_t     ReadIsochPipeAsap;
+            WinUsb_RegisterIsochBuffer_t   RegisterIsochBuffer;
+            WinUsb_UnregisterIsochBuffer_t UnregisterIsochBuffer;
+            WinUsb_WriteIsochPipeAsap_t    WriteIsochPipeAsap;
+        };
+    };
+};
+
+/* hid.dll interface */
+
+#define HIDP_STATUS_SUCCESS 0x110000
+typedef void *PHIDP_PREPARSED_DATA;
+
+#include <pshpack1.h>
+
+typedef struct _HIDD_ATTIRBUTES {
+    ULONG  Size;
+    USHORT VendorID;
+    USHORT ProductID;
+    USHORT VersionNumber;
+} HIDD_ATTRIBUTES, *PHIDD_ATTRIBUTES;
+
+#include <poppack.h>
+
+typedef USHORT USAGE;
+typedef struct _HIDP_CAPS {
+    USAGE  Usage;
+    USAGE  UsagePage;
+    USHORT InputReportByteLength;
+    USHORT OutputReportByteLength;
+    USHORT FeatureReportByteLength;
+    USHORT Reserved[17];
+    USHORT NumberLinkCollectionNodes;
+    USHORT NumberInputButtonCaps;
+    USHORT NumberInputValueCaps;
+    USHORT NumberInputDataIndices;
+    USHORT NumberOutputButtonCaps;
+    USHORT NumberOutputValueCaps;
+    USHORT NumberOutputDataIndices;
+    USHORT NumberFeatureButtonCaps;
+    USHORT NumberFeatureValueCaps;
+    USHORT NumberFeatureDataIndices;
+} HIDP_CAPS, *PHIDP_CAPS;
+
+typedef enum _HIDP_REPORT_TYPE { HidP_Input, HidP_Output, HidP_Feature } HIDP_REPORT_TYPE;
+
+typedef struct _HIDP_VALUE_CAPS {
+    USAGE   UsagePage;
+    UCHAR   ReportID;
+    BOOLEAN IsAlias;
+    USHORT  BitField;
+    USHORT  LinkCollection;
+    USAGE   LinkUsage;
+    USAGE   LinkUsagePage;
+    BOOLEAN IsRange;
+    BOOLEAN IsStringRange;
+    BOOLEAN IsDesignatorRange;
+    BOOLEAN IsAbsolute;
+    BOOLEAN HasNull;
+    UCHAR   Reserved;
+    USHORT  BitSize;
+    USHORT  ReportCount;
+    USHORT  Reserved2[5];
+    ULONG   UnitsExp;
+    ULONG   Units;
+    LONG    LogicalMin, LogicalMax;
+    LONG    PhysicalMin, PhysicalMax;
+    union {
+        struct {
+            USAGE  UsageMin, UsageMax;
+            USHORT StringMin, StringMax;
+            USHORT DesignatorMin, DesignatorMax;
+            USHORT DataIndexMin, DataIndexMax;
+        } Range;
+        struct {
+            USAGE  Usage, Reserved1;
+            USHORT StringIndex, Reserved2;
+            USHORT DesignatorIndex, Reserved3;
+            USHORT DataIndex, Reserved4;
+        } NotRange;
+    } u;
+} HIDP_VALUE_CAPS, *PHIDP_VALUE_CAPS;
+
+DLL_DECLARE_HANDLE(hid);
+DLL_DECLARE_FUNC(WINAPI, VOID, HidD_GetHidGuid, (LPGUID));
+DLL_DECLARE_FUNC(WINAPI, BOOL, HidD_GetAttributes, (HANDLE, PHIDD_ATTRIBUTES));
+DLL_DECLARE_FUNC(WINAPI, BOOL, HidD_GetPreparsedData, (HANDLE, PHIDP_PREPARSED_DATA *));
+DLL_DECLARE_FUNC(WINAPI, BOOL, HidD_FreePreparsedData, (PHIDP_PREPARSED_DATA));
+DLL_DECLARE_FUNC(WINAPI, BOOL, HidD_GetManufacturerString, (HANDLE, PVOID, ULONG));
+DLL_DECLARE_FUNC(WINAPI, BOOL, HidD_GetProductString, (HANDLE, PVOID, ULONG));
+DLL_DECLARE_FUNC(WINAPI, BOOL, HidD_GetSerialNumberString, (HANDLE, PVOID, ULONG));
+DLL_DECLARE_FUNC(WINAPI, BOOL, HidD_GetIndexedString, (HANDLE, ULONG, PVOID, ULONG));
+DLL_DECLARE_FUNC(WINAPI, LONG, HidP_GetCaps, (PHIDP_PREPARSED_DATA, PHIDP_CAPS));
+DLL_DECLARE_FUNC(WINAPI, BOOL, HidD_SetNumInputBuffers, (HANDLE, ULONG));
+DLL_DECLARE_FUNC(WINAPI, BOOL, HidD_GetPhysicalDescriptor, (HANDLE, PVOID, ULONG));
+DLL_DECLARE_FUNC(WINAPI, BOOL, HidD_FlushQueue, (HANDLE));
+DLL_DECLARE_FUNC(WINAPI, BOOL, HidP_GetValueCaps, (HIDP_REPORT_TYPE, PHIDP_VALUE_CAPS, PULONG, PHIDP_PREPARSED_DATA));
+
+#endif
diff --git a/3rdparty/libusb/src/libusb/strerror.c b/3rdparty/libusb/src/libusb/strerror.c
new file mode 100644
index 00000000..47b4b35c
--- /dev/null
+++ b/3rdparty/libusb/src/libusb/strerror.c
@@ -0,0 +1,217 @@
+/*
+ * libusb strerror code
+ * Copyright © 2013 Hans de Goede <hdegoede@redhat.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "libusbi.h"
+
+#include <ctype.h>
+#include <string.h>
+
+/** \ingroup libusb_misc
+ * How to add a new \ref libusb_strerror() translation:
+ * <ol>
+ * <li> Download the latest \c strerror.c from:<br>
+ *      https://raw.github.com/libusb/libusb/master/libusb/strerror.c </li>
+ * <li> Open the file in an UTF-8 capable editor </li>
+ * <li> Add the 2 letter <a href="http://en.wikipedia.org/wiki/List_of_ISO_639-1_codes">ISO 639-1</a>
+ *      code for your locale at the end of \c usbi_locale_supported[]<br>
+ *    Eg. for Chinese, you would add "zh" so that:
+ *    \code... usbi_locale_supported[] = { "en", "nl", "fr" };\endcode
+ *    becomes:
+ *    \code... usbi_locale_supported[] = { "en", "nl", "fr", "zh" };\endcode </li>
+ * <li> Copy the <tt>{ / * English (en) * / ... }</tt> section and add it at the end of \c usbi_localized_errors<br>
+ *    Eg. for Chinese, the last section of \c usbi_localized_errors could look like:
+ *    \code
+ *     }, { / * Chinese (zh) * /
+ *         "Success",
+ *         ...
+ *         "Other error",
+ *     },
+ * };\endcode </li>
+ * <li> Translate each of the English messages from the section you copied into your language </li>
+ * <li> Save the file (in UTF-8 format) and send it to \c libusb-devel\@lists.sourceforge.net </li>
+ * </ol>
+ */
+
+static const char *const usbi_locale_supported[]                                                     = { "en", "nl", "fr", "ru", "de", "hu" };
+static const char *const usbi_localized_errors[ARRAYSIZE(usbi_locale_supported)][LIBUSB_ERROR_COUNT] = {
+    {
+        /* English (en) */
+        "Success",
+        "Input/Output Error",
+        "Invalid parameter",
+        "Access denied (insufficient permissions)",
+        "No such device (it may have been disconnected)",
+        "Entity not found",
+        "Resource busy",
+        "Operation timed out",
+        "Overflow",
+        "Pipe error",
+        "System call interrupted (perhaps due to signal)",
+        "Insufficient memory",
+        "Operation not supported or unimplemented on this platform",
+        "Other error",
+    },
+    {
+        /* Dutch (nl) */
+        "Gelukt",
+        "Invoer-/uitvoerfout",
+        "Ongeldig argument",
+        "Toegang geweigerd (onvoldoende toegangsrechten)",
+        "Apparaat bestaat niet (verbinding met apparaat verbroken?)",
+        "Niet gevonden",
+        "Apparaat of hulpbron is bezig",
+        "Bewerking verlopen",
+        "Waarde is te groot",
+        "Gebroken pijp",
+        "Onderbroken systeemaanroep",
+        "Onvoldoende geheugen beschikbaar",
+        "Bewerking wordt niet ondersteund",
+        "Andere fout",
+    },
+    {
+        /* French (fr) */
+        "Succès",
+        "Erreur d'entrée/sortie",
+        "Paramètre invalide",
+        "Accès refusé (permissions insuffisantes)",
+        "Périphérique introuvable (peut-être déconnecté)",
+        "Elément introuvable",
+        "Resource déjà occupée",
+        "Operation expirée",
+        "Débordement",
+        "Erreur de pipe",
+        "Appel système abandonné (peut-être à cause d’un signal)",
+        "Mémoire insuffisante",
+        "Opération non supportée or non implémentée sur cette plateforme",
+        "Autre erreur",
+    },
+    { /* Russian (ru) */
+      "Успех", "Ошибка ввода/вывода", "Неверный параметр", "Доступ запрещён (не хватает прав)", "Устройство отсутствует (возможно, оно было отсоединено)",
+      "Элемент не найден", "Ресурс занят", "Истекло время ожидания операции", "Переполнение", "Ошибка канала", "Системный вызов прерван (возможно, сигналом)",
+      "Память исчерпана", "Операция не поддерживается данной платформой", "Неизвестная ошибка" },
+    {
+        /* German (de) */
+        "Erfolgreich",
+        "Eingabe-/Ausgabefehler",
+        "Ungültiger Parameter",
+        "Keine Berechtigung (Zugriffsrechte fehlen)",
+        "Kein passendes Gerät gefunden (es könnte entfernt worden sein)",
+        "Entität nicht gefunden",
+        "Die Ressource ist belegt",
+        "Die Wartezeit für die Operation ist abgelaufen",
+        "Mehr Daten empfangen als erwartet",
+        "Datenübergabe unterbrochen (broken pipe)",
+        "Unterbrechung während des Betriebssystemaufrufs",
+        "Nicht genügend Hauptspeicher verfügbar",
+        "Die Operation wird nicht unterstützt oder ist auf dieser Platform nicht implementiert",
+        "Allgemeiner Fehler",
+    },
+    {
+        /* Hungarian (hu) */
+        "Sikeres",
+        "Be-/kimeneti hiba",
+        "Érvénytelen paraméter",
+        "Hozzáférés megtagadva",
+        "Az eszköz nem található (eltávolították?)",
+        "Nem található",
+        "Az erőforrás foglalt",
+        "Időtúllépés",
+        "Túlcsordulás",
+        "Törött adatcsatorna",
+        "Rendszerhívás megszakítva",
+        "Nincs elég memória",
+        "A művelet nem támogatott ezen a rendszeren",
+        "Általános hiba",
+    },
+};
+
+static const char *const (*usbi_error_strings)[LIBUSB_ERROR_COUNT] = &usbi_localized_errors[0];
+
+/** \ingroup libusb_misc
+ * Set the language, and only the language, not the encoding! used for
+ * translatable libusb messages.
+ *
+ * This takes a locale string in the default setlocale format: lang[-region]
+ * or lang[_country_region][.codeset]. Only the lang part of the string is
+ * used, and only 2 letter ISO 639-1 codes are accepted for it, such as "de".
+ * The optional region, country_region or codeset parts are ignored. This
+ * means that functions which return translatable strings will NOT honor the
+ * specified encoding.
+ * All strings returned are encoded as UTF-8 strings.
+ *
+ * If libusb_setlocale() is not called, all messages will be in English.
+ *
+ * The following functions return translatable strings: libusb_strerror().
+ * Note that the libusb log messages controlled through libusb_set_debug()
+ * are not translated, they are always in English.
+ *
+ * For POSIX UTF-8 environments if you want libusb to follow the standard
+ * locale settings, call libusb_setlocale(setlocale(LC_MESSAGES, NULL)),
+ * after your app has done its locale setup.
+ *
+ * \param locale locale-string in the form of lang[_country_region][.codeset]
+ * or lang[-region], where lang is a 2 letter ISO 639-1 code
+ * \returns \ref LIBUSB_SUCCESS on success
+ * \returns \ref LIBUSB_ERROR_INVALID_PARAM if the locale doesn't meet the requirements
+ * \returns \ref LIBUSB_ERROR_NOT_FOUND if the requested language is not supported
+ * \returns a LIBUSB_ERROR code on other errors
+ */
+
+int API_EXPORTED libusb_setlocale(const char *locale) {
+    size_t i;
+
+    if(!locale || strlen(locale) < 2 || (locale[2] != '\0' && locale[2] != '-' && locale[2] != '_' && locale[2] != '.'))
+        return LIBUSB_ERROR_INVALID_PARAM;
+
+    for(i = 0; i < ARRAYSIZE(usbi_locale_supported); i++) {
+        if(usbi_locale_supported[i][0] == tolower((unsigned char)locale[0]) && usbi_locale_supported[i][1] == tolower((unsigned char)locale[1]))
+            break;
+    }
+
+    if(i == ARRAYSIZE(usbi_locale_supported))
+        return LIBUSB_ERROR_NOT_FOUND;
+
+    usbi_error_strings = &usbi_localized_errors[i];
+
+    return LIBUSB_SUCCESS;
+}
+
+/** \ingroup libusb_misc
+ * Returns a constant string with a short description of the given error code,
+ * this description is intended for displaying to the end user and will be in
+ * the language set by libusb_setlocale().
+ *
+ * The returned string is encoded in UTF-8.
+ *
+ * The messages always start with a capital letter and end without any dot.
+ * The caller must not free() the returned string.
+ *
+ * \param errcode the error code whose description is desired
+ * \returns a short description of the error code in UTF-8 encoding
+ */
+DEFAULT_VISIBILITY const char *LIBUSB_CALL libusb_strerror(int errcode) {
+    int errcode_index = -errcode;
+
+    if(errcode_index < 0 || errcode_index >= LIBUSB_ERROR_COUNT) {
+        /* "Other Error", which should always be our last message, is returned */
+        errcode_index = LIBUSB_ERROR_COUNT - 1;
+    }
+
+    return (*usbi_error_strings)[errcode_index];
+}
diff --git a/3rdparty/libusb/src/libusb/sync.c b/3rdparty/libusb/src/libusb/sync.c
new file mode 100644
index 00000000..49723404
--- /dev/null
+++ b/3rdparty/libusb/src/libusb/sync.c
@@ -0,0 +1,315 @@
+/* -*- Mode: C; indent-tabs-mode:t ; c-basic-offset:8 -*- */
+/*
+ * Synchronous I/O functions for libusb
+ * Copyright © 2007-2008 Daniel Drake <dsd@gentoo.org>
+ * Copyright © 2019 Nathan Hjelm <hjelmn@cs.unm.edu>
+ * Copyright © 2019 Google LLC. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "libusbi.h"
+
+#include <string.h>
+
+/**
+ * @defgroup libusb_syncio Synchronous device I/O
+ *
+ * This page documents libusb's synchronous (blocking) API for USB device I/O.
+ * This interface is easy to use but has some limitations. More advanced users
+ * may wish to consider using the \ref libusb_asyncio "asynchronous I/O API" instead.
+ */
+
+static void LIBUSB_CALL sync_transfer_cb(struct libusb_transfer *transfer) {
+    int *completed = transfer->user_data;
+    *completed     = 1;
+    usbi_dbg(TRANSFER_CTX(transfer), "actual_length=%d", transfer->actual_length);
+    /* caller interprets result and frees transfer */
+}
+
+static void sync_transfer_wait_for_completion(struct libusb_transfer *transfer) {
+    int                    r, *completed = transfer->user_data;
+    struct libusb_context *ctx = HANDLE_CTX(transfer->dev_handle);
+
+    while(!*completed) {
+        r = libusb_handle_events_completed(ctx, completed);
+        if(r < 0) {
+            if(r == LIBUSB_ERROR_INTERRUPTED)
+                continue;
+            usbi_err(ctx, "libusb_handle_events failed: %s, cancelling transfer and retrying", libusb_error_name(r));
+            libusb_cancel_transfer(transfer);
+            continue;
+        }
+        if(NULL == transfer->dev_handle) {
+            /* transfer completion after libusb_close() */
+            transfer->status = LIBUSB_TRANSFER_NO_DEVICE;
+            *completed       = 1;
+        }
+    }
+}
+
+/** \ingroup libusb_syncio
+ * Perform a USB control transfer.
+ *
+ * The direction of the transfer is inferred from the bmRequestType field of
+ * the setup packet.
+ *
+ * The wValue, wIndex and wLength fields values should be given in host-endian
+ * byte order.
+ *
+ * \param dev_handle a handle for the device to communicate with
+ * \param bmRequestType the request type field for the setup packet
+ * \param bRequest the request field for the setup packet
+ * \param wValue the value field for the setup packet
+ * \param wIndex the index field for the setup packet
+ * \param data a suitably-sized data buffer for either input or output
+ * (depending on direction bits within bmRequestType)
+ * \param wLength the length field for the setup packet. The data buffer should
+ * be at least this size.
+ * \param timeout timeout (in milliseconds) that this function should wait
+ * before giving up due to no response being received. For an unlimited
+ * timeout, use value 0.
+ * \returns on success, the number of bytes actually transferred
+ * \returns \ref LIBUSB_ERROR_TIMEOUT if the transfer timed out
+ * \returns \ref LIBUSB_ERROR_PIPE if the control request was not supported by the
+ * device
+ * \returns \ref LIBUSB_ERROR_NO_DEVICE if the device has been disconnected
+ * \returns \ref LIBUSB_ERROR_BUSY if called from event handling context
+ * \returns \ref LIBUSB_ERROR_INVALID_PARAM if the transfer size is larger than
+ * the operating system and/or hardware can support (see \ref asynclimits)
+ * \returns another LIBUSB_ERROR code on other failures
+ */
+int API_EXPORTED libusb_control_transfer(libusb_device_handle *dev_handle, uint8_t bmRequestType, uint8_t bRequest, uint16_t wValue, uint16_t wIndex,
+                                         unsigned char *data, uint16_t wLength, unsigned int timeout) {
+    struct libusb_transfer *transfer;
+    unsigned char          *buffer;
+    int                     completed = 0;
+    int                     r;
+
+    if(usbi_handling_events(HANDLE_CTX(dev_handle)))
+        return LIBUSB_ERROR_BUSY;
+
+    transfer = libusb_alloc_transfer(0);
+    if(!transfer)
+        return LIBUSB_ERROR_NO_MEM;
+
+    buffer = malloc(LIBUSB_CONTROL_SETUP_SIZE + wLength);
+    if(!buffer) {
+        libusb_free_transfer(transfer);
+        return LIBUSB_ERROR_NO_MEM;
+    }
+
+    libusb_fill_control_setup(buffer, bmRequestType, bRequest, wValue, wIndex, wLength);
+    if((bmRequestType & LIBUSB_ENDPOINT_DIR_MASK) == LIBUSB_ENDPOINT_OUT)
+        memcpy(buffer + LIBUSB_CONTROL_SETUP_SIZE, data, wLength);
+
+    libusb_fill_control_transfer(transfer, dev_handle, buffer, sync_transfer_cb, &completed, timeout);
+    transfer->flags = LIBUSB_TRANSFER_FREE_BUFFER;
+    r               = libusb_submit_transfer(transfer);
+    if(r < 0) {
+        libusb_free_transfer(transfer);
+        return r;
+    }
+
+    sync_transfer_wait_for_completion(transfer);
+
+    if((bmRequestType & LIBUSB_ENDPOINT_DIR_MASK) == LIBUSB_ENDPOINT_IN)
+        memcpy(data, libusb_control_transfer_get_data(transfer), transfer->actual_length);
+
+    switch(transfer->status) {
+    case LIBUSB_TRANSFER_COMPLETED:
+        r = transfer->actual_length;
+        break;
+    case LIBUSB_TRANSFER_TIMED_OUT:
+        r = LIBUSB_ERROR_TIMEOUT;
+        break;
+    case LIBUSB_TRANSFER_STALL:
+        r = LIBUSB_ERROR_PIPE;
+        break;
+    case LIBUSB_TRANSFER_NO_DEVICE:
+        r = LIBUSB_ERROR_NO_DEVICE;
+        break;
+    case LIBUSB_TRANSFER_OVERFLOW:
+        r = LIBUSB_ERROR_OVERFLOW;
+        break;
+    case LIBUSB_TRANSFER_ERROR:
+    case LIBUSB_TRANSFER_CANCELLED:
+        r = LIBUSB_ERROR_IO;
+        break;
+    default:
+        usbi_warn(HANDLE_CTX(dev_handle), "unrecognised status code %d", transfer->status);
+        r = LIBUSB_ERROR_OTHER;
+    }
+
+    libusb_free_transfer(transfer);
+    return r;
+}
+
+static int do_sync_bulk_transfer(struct libusb_device_handle *dev_handle, unsigned char endpoint, unsigned char *buffer, int length, int *transferred,
+                                 unsigned int timeout, unsigned char type) {
+    struct libusb_transfer *transfer;
+    int                     completed = 0;
+    int                     r;
+
+    if(usbi_handling_events(HANDLE_CTX(dev_handle)))
+        return LIBUSB_ERROR_BUSY;
+
+    transfer = libusb_alloc_transfer(0);
+    if(!transfer)
+        return LIBUSB_ERROR_NO_MEM;
+
+    libusb_fill_bulk_transfer(transfer, dev_handle, endpoint, buffer, length, sync_transfer_cb, &completed, timeout);
+    transfer->type = type;
+
+    r = libusb_submit_transfer(transfer);
+    if(r < 0) {
+        libusb_free_transfer(transfer);
+        return r;
+    }
+
+    sync_transfer_wait_for_completion(transfer);
+
+    if(transferred)
+        *transferred = transfer->actual_length;
+
+    switch(transfer->status) {
+    case LIBUSB_TRANSFER_COMPLETED:
+        r = 0;
+        break;
+    case LIBUSB_TRANSFER_TIMED_OUT:
+        r = LIBUSB_ERROR_TIMEOUT;
+        break;
+    case LIBUSB_TRANSFER_STALL:
+        r = LIBUSB_ERROR_PIPE;
+        break;
+    case LIBUSB_TRANSFER_OVERFLOW:
+        r = LIBUSB_ERROR_OVERFLOW;
+        break;
+    case LIBUSB_TRANSFER_NO_DEVICE:
+        r = LIBUSB_ERROR_NO_DEVICE;
+        break;
+    case LIBUSB_TRANSFER_ERROR:
+    case LIBUSB_TRANSFER_CANCELLED:
+        r = LIBUSB_ERROR_IO;
+        break;
+    default:
+        usbi_warn(HANDLE_CTX(dev_handle), "unrecognised status code %d", transfer->status);
+        r = LIBUSB_ERROR_OTHER;
+    }
+
+    libusb_free_transfer(transfer);
+    return r;
+}
+
+/** \ingroup libusb_syncio
+ * Perform a USB bulk transfer. The direction of the transfer is inferred from
+ * the direction bits of the endpoint address.
+ *
+ * For bulk reads, the <tt>length</tt> field indicates the maximum length of
+ * data you are expecting to receive. If less data arrives than expected,
+ * this function will return that data, so be sure to check the
+ * <tt>transferred</tt> output parameter.
+ *
+ * You should also check the <tt>transferred</tt> parameter for bulk writes.
+ * Not all of the data may have been written.
+ *
+ * Also check <tt>transferred</tt> when dealing with a timeout error code.
+ * libusb may have to split your transfer into a number of chunks to satisfy
+ * underlying O/S requirements, meaning that the timeout may expire after
+ * the first few chunks have completed. libusb is careful not to lose any data
+ * that may have been transferred; do not assume that timeout conditions
+ * indicate a complete lack of I/O. See \ref asynctimeout for more details.
+ *
+ * \param dev_handle a handle for the device to communicate with
+ * \param endpoint the address of a valid endpoint to communicate with
+ * \param data a suitably-sized data buffer for either input or output
+ * (depending on endpoint)
+ * \param length for bulk writes, the number of bytes from data to be sent. for
+ * bulk reads, the maximum number of bytes to receive into the data buffer.
+ * \param transferred output location for the number of bytes actually
+ * transferred. Since version 1.0.21 (\ref LIBUSB_API_VERSION >= 0x01000105),
+ * it is legal to pass a NULL pointer if you do not wish to receive this
+ * information.
+ * \param timeout timeout (in milliseconds) that this function should wait
+ * before giving up due to no response being received. For an unlimited
+ * timeout, use value 0.
+ *
+ * \returns 0 on success (and populates <tt>transferred</tt>)
+ * \returns \ref LIBUSB_ERROR_TIMEOUT if the transfer timed out (and populates
+ * <tt>transferred</tt>)
+ * \returns \ref LIBUSB_ERROR_PIPE if the endpoint halted
+ * \returns \ref LIBUSB_ERROR_OVERFLOW if the device offered more data, see
+ * \ref libusb_packetoverflow
+ * \returns \ref LIBUSB_ERROR_NO_DEVICE if the device has been disconnected
+ * \returns \ref LIBUSB_ERROR_BUSY if called from event handling context
+ * \returns \ref LIBUSB_ERROR_INVALID_PARAM if the transfer size is larger than
+ * the operating system and/or hardware can support (see \ref asynclimits)
+ * \returns another LIBUSB_ERROR code on other failures
+ */
+int API_EXPORTED libusb_bulk_transfer(libusb_device_handle *dev_handle, unsigned char endpoint, unsigned char *data, int length, int *transferred,
+                                      unsigned int timeout) {
+    return do_sync_bulk_transfer(dev_handle, endpoint, data, length, transferred, timeout, LIBUSB_TRANSFER_TYPE_BULK);
+}
+
+/** \ingroup libusb_syncio
+ * Perform a USB interrupt transfer. The direction of the transfer is inferred
+ * from the direction bits of the endpoint address.
+ *
+ * For interrupt reads, the <tt>length</tt> field indicates the maximum length
+ * of data you are expecting to receive. If less data arrives than expected,
+ * this function will return that data, so be sure to check the
+ * <tt>transferred</tt> output parameter.
+ *
+ * You should also check the <tt>transferred</tt> parameter for interrupt
+ * writes. Not all of the data may have been written.
+ *
+ * Also check <tt>transferred</tt> when dealing with a timeout error code.
+ * libusb may have to split your transfer into a number of chunks to satisfy
+ * underlying O/S requirements, meaning that the timeout may expire after
+ * the first few chunks have completed. libusb is careful not to lose any data
+ * that may have been transferred; do not assume that timeout conditions
+ * indicate a complete lack of I/O. See \ref asynctimeout for more details.
+ *
+ * The default endpoint bInterval value is used as the polling interval.
+ *
+ * \param dev_handle a handle for the device to communicate with
+ * \param endpoint the address of a valid endpoint to communicate with
+ * \param data a suitably-sized data buffer for either input or output
+ * (depending on endpoint)
+ * \param length for bulk writes, the number of bytes from data to be sent. for
+ * bulk reads, the maximum number of bytes to receive into the data buffer.
+ * \param transferred output location for the number of bytes actually
+ * transferred. Since version 1.0.21 (\ref LIBUSB_API_VERSION >= 0x01000105),
+ * it is legal to pass a NULL pointer if you do not wish to receive this
+ * information.
+ * \param timeout timeout (in milliseconds) that this function should wait
+ * before giving up due to no response being received. For an unlimited
+ * timeout, use value 0.
+ *
+ * \returns 0 on success (and populates <tt>transferred</tt>)
+ * \returns \ref LIBUSB_ERROR_TIMEOUT if the transfer timed out
+ * \returns \ref LIBUSB_ERROR_PIPE if the endpoint halted
+ * \returns \ref LIBUSB_ERROR_OVERFLOW if the device offered more data, see
+ * \ref libusb_packetoverflow
+ * \returns \ref LIBUSB_ERROR_NO_DEVICE if the device has been disconnected
+ * \returns \ref LIBUSB_ERROR_BUSY if called from event handling context
+ * \returns \ref LIBUSB_ERROR_INVALID_PARAM if the transfer size is larger than
+ * the operating system and/or hardware can support (see \ref asynclimits)
+ * \returns another LIBUSB_ERROR code on other error
+ */
+int API_EXPORTED libusb_interrupt_transfer(libusb_device_handle *dev_handle, unsigned char endpoint, unsigned char *data, int length, int *transferred,
+                                           unsigned int timeout) {
+    return do_sync_bulk_transfer(dev_handle, endpoint, data, length, transferred, timeout, LIBUSB_TRANSFER_TYPE_INTERRUPT);
+}
diff --git a/3rdparty/libusb/src/libusb/version.h b/3rdparty/libusb/src/libusb/version.h
new file mode 100644
index 00000000..fe95d84b
--- /dev/null
+++ b/3rdparty/libusb/src/libusb/version.h
@@ -0,0 +1,18 @@
+/* This file is parsed by m4 and windres and RC.EXE so please keep it simple. */
+#include "version_nano.h"
+#ifndef LIBUSB_MAJOR
+#define LIBUSB_MAJOR 1
+#endif
+#ifndef LIBUSB_MINOR
+#define LIBUSB_MINOR 0
+#endif
+#ifndef LIBUSB_MICRO
+#define LIBUSB_MICRO 26
+#endif
+#ifndef LIBUSB_NANO
+#define LIBUSB_NANO 0
+#endif
+/* LIBUSB_RC is the release candidate suffix. Should normally be empty. */
+#ifndef LIBUSB_RC
+#define LIBUSB_RC ""
+#endif
diff --git a/3rdparty/libusb/src/libusb/version_nano.h b/3rdparty/libusb/src/libusb/version_nano.h
new file mode 100644
index 00000000..34620df0
--- /dev/null
+++ b/3rdparty/libusb/src/libusb/version_nano.h
@@ -0,0 +1 @@
+#define LIBUSB_NANO 11791
diff --git a/3rdparty/libusb/src/linux/libusb/config.h b/3rdparty/libusb/src/linux/libusb/config.h
new file mode 100644
index 00000000..895ca026
--- /dev/null
+++ b/3rdparty/libusb/src/linux/libusb/config.h
@@ -0,0 +1,151 @@
+/* config.h.  Generated from config.h.in by configure.  */
+/* config.h.in.  Generated from configure.ac by autoheader.  */
+
+/* Define to the attribute for default visibility. */
+#define DEFAULT_VISIBILITY __attribute__((visibility("default")))
+
+/* Define to 1 to start with debug message logging enabled. */
+/* #undef ENABLE_DEBUG_LOGGING */
+
+/* Define to 1 to enable message logging. */
+#define ENABLE_LOGGING 0
+
+/* Define to 1 if you have the <asm/types.h> header file. */
+/* #undef HAVE_ASM_TYPES_H */
+
+/* Define to 1 if you have the `clock_gettime' function. */
+#define HAVE_CLOCK_GETTIME 1
+
+/* Define to 1 if you have the declaration of `EFD_CLOEXEC', and to 0 if you
+   don't. */
+#define HAVE_DECL_EFD_CLOEXEC 1
+
+/* Define to 1 if you have the declaration of `EFD_NONBLOCK', and to 0 if you
+   don't. */
+#define HAVE_DECL_EFD_NONBLOCK 1
+
+/* Define to 1 if you have the declaration of `TFD_CLOEXEC', and to 0 if you
+   don't. */
+#define HAVE_DECL_TFD_CLOEXEC 1
+
+/* Define to 1 if you have the declaration of `TFD_NONBLOCK', and to 0 if you
+   don't. */
+#define HAVE_DECL_TFD_NONBLOCK 1
+
+/* Define to 1 if you have the <dlfcn.h> header file. */
+#define HAVE_DLFCN_H 1
+
+/* Define to 1 if the system has eventfd functionality. */
+#define HAVE_EVENTFD 1
+
+/* Define to 1 if you have the <inttypes.h> header file. */
+#define HAVE_INTTYPES_H 1
+
+/* Define to 1 if you have the `udev' library (-ludev). */
+/* #define HAVE_LIBUDEV 1 */
+
+/* Define to 1 if you have the <memory.h> header file. */
+#define HAVE_MEMORY_H 1
+
+/* Define to 1 if the system has the type `nfds_t'. */
+#define HAVE_NFDS_T 1
+
+/* Define to 1 if you have the `pipe2' function. */
+#define HAVE_PIPE2 1
+
+/* Define to 1 if you have the `pthread_condattr_setclock' function. */
+#define HAVE_PTHREAD_CONDATTR_SETCLOCK 1
+
+/* Define to 1 if you have the `pthread_setname_np' function. */
+#define HAVE_PTHREAD_SETNAME_NP 1
+
+/* Define to 1 if you have the `pthread_threadid_np' function. */
+/* #undef HAVE_PTHREAD_THREADID_NP */
+
+/* Define to 1 if you have the <stdint.h> header file. */
+#define HAVE_STDINT_H 1
+
+/* Define to 1 if you have the <stdlib.h> header file. */
+#define HAVE_STDLIB_H 1
+
+/* Define to 1 if you have the <strings.h> header file. */
+#define HAVE_STRINGS_H 1
+
+/* Define to 1 if you have the <string.h> header file. */
+#define HAVE_STRING_H 1
+
+/* Define to 1 if the system has the type `struct timespec'. */
+/* #undef HAVE_STRUCT_TIMESPEC */
+
+/* Define to 1 if you have the `syslog' function. */
+/* #undef HAVE_SYSLOG */
+
+/* Define to 1 if you have the <sys/stat.h> header file. */
+#define HAVE_SYS_STAT_H 1
+
+/* Define to 1 if you have the <sys/time.h> header file. */
+#define HAVE_SYS_TIME_H 1
+
+/* Define to 1 if you have the <sys/types.h> header file. */
+#define HAVE_SYS_TYPES_H 1
+
+/* Define to 1 if the system has timerfd functionality. */
+#define HAVE_TIMERFD 1
+
+/* Define to 1 if you have the <unistd.h> header file. */
+#define HAVE_UNISTD_H 1
+
+/* Define to the sub-directory where libtool stores uninstalled libraries. */
+#define LT_OBJDIR ".libs/"
+
+/* Name of package */
+#define PACKAGE "libusb-1.0"
+
+/* Define to the address where bug reports for this package should be sent. */
+#define PACKAGE_BUGREPORT "libusb-devel@lists.sourceforge.net"
+
+/* Define to the full name of this package. */
+#define PACKAGE_NAME "libusb-1.0"
+
+/* Define to the full name and version of this package. */
+#define PACKAGE_STRING "libusb-1.0 1.0.24"
+
+/* Define to the one symbol short name of this package. */
+#define PACKAGE_TARNAME "libusb-1.0"
+
+/* Define to the home page for this package. */
+#define PACKAGE_URL "http://libusb.info"
+
+/* Define to the version of this package. */
+#define PACKAGE_VERSION "1.0.24"
+
+/* Define to 1 if compiling for a POSIX platform. */
+#define PLATFORM_POSIX 1
+
+/* Define to 1 if compiling for a Windows platform. */
+/* #undef PLATFORM_WINDOWS */
+
+/* Define to the attribute for enabling parameter checks on printf-like
+   functions. */
+#define PRINTF_FORMAT(a, b) __attribute__((__format__(__printf__, a, b)))
+
+/* Define to 1 if you have the ANSI C header files. */
+#define STDC_HEADERS 1
+
+/* Define to 1 to output logging messages to the systemwide log. */
+/* #undef USE_SYSTEM_LOGGING_FACILITY */
+
+/* Version number of package */
+#define VERSION "1.0.24"
+
+/* Enable GNU extensions. */
+#define _GNU_SOURCE 1
+
+/* Define to the oldest supported Windows version. */
+/* #undef _WIN32_WINNT */
+
+/* Define to `__inline__' or `__inline' if that's what the C compiler
+   calls it, or to nothing if 'inline' is not supported under any name.  */
+#ifndef __cplusplus
+/* #undef inline */
+#endif
diff --git a/3rdparty/libusb/src/msvc/Base.props b/3rdparty/libusb/src/msvc/Base.props
new file mode 100644
index 00000000..d2ebf8ac
--- /dev/null
+++ b/3rdparty/libusb/src/msvc/Base.props
@@ -0,0 +1,60 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <LibusbRootDir>$([System.IO.Path]::GetFullPath('$(MSBuildThisFileDirectory)..'))\</LibusbRootDir>
+    <IntDir>$(LibusbRootDir)build\$(PlatformToolset)\$(Platform)\$(Configuration)\$(ProjectName)\</IntDir>
+    <OutDir>$(IntDir)..\</OutDir>
+  </PropertyGroup>
+  <ItemDefinitionGroup>
+    <!--ClCompile Base-->
+    <ClCompile>
+      <AdditionalIncludeDirectories>.;..\libusb;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <PreprocessorDefinitions>_WIN32_WINNT=_WIN32_WINNT_VISTA;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <WarningLevel>Level4</WarningLevel>
+      <TreatWarningAsError>true</TreatWarningAsError>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <MultiProcessorCompilation>true</MultiProcessorCompilation>
+      <!--Treat sources as utf-8-->
+      <AdditionalOptions Condition="'$(PlatformToolsetVersion)'&gt;'120'">/utf-8 %(AdditionalOptions)</AdditionalOptions>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+      <DiagnosticsFormat>Caret</DiagnosticsFormat>
+    </ClCompile>
+    <!--ClCompile Debug*-->
+    <ClCompile Condition="$(Configuration.StartsWith('Debug'))">
+      <Optimization>Disabled</Optimization>
+    </ClCompile>
+    <ClCompile Condition="$(Configuration.StartsWith('Debug')) And '$(EnableASAN)'=='true'">
+      <BasicRuntimeChecks>Default</BasicRuntimeChecks>
+    </ClCompile>
+    <!--ClCompile Release*-->
+    <ClCompile Condition="$(Configuration.StartsWith('Release'))">
+      <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <InlineFunctionExpansion>AnySuitable</InlineFunctionExpansion>
+      <FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>
+      <OmitFramePointers>true</OmitFramePointers>
+      <StringPooling>true</StringPooling>
+      <AdditionalOptions>/Gw %(AdditionalOptions)</AdditionalOptions>
+      <WholeProgramOptimization>true</WholeProgramOptimization>
+    </ClCompile>
+    <!--Link Base-->
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <TreatLinkerWarningAsErrors>true</TreatLinkerWarningAsErrors>
+    </Link>
+    <!--Link Release*-->
+    <Link Condition="$(Configuration.StartsWith('Release'))">
+      <LinkTimeCodeGeneration>UseLinkTimeCodeGeneration</LinkTimeCodeGeneration>
+      <OptimizeReferences>true</OptimizeReferences>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <AdditionalDependencies>kernel32.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+    <!--Link Base:Application-->
+    <Link Condition="'$(ConfigurationType)'=='Application'">
+      <SubSystem>Console</SubSystem>
+    </Link>
+    <Lib>
+      <TreatLibWarningAsErrors>true</TreatLibWarningAsErrors>
+      <LinkTimeCodeGeneration>true</LinkTimeCodeGeneration>
+    </Lib>
+  </ItemDefinitionGroup>
+</Project>
\ No newline at end of file
diff --git a/3rdparty/libusb/src/msvc/Configuration.Application.props b/3rdparty/libusb/src/msvc/Configuration.Application.props
new file mode 100644
index 00000000..8c41e29a
--- /dev/null
+++ b/3rdparty/libusb/src/msvc/Configuration.Application.props
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="Configuration.Base.props" />
+  <PropertyGroup Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+  </PropertyGroup>
+</Project>
\ No newline at end of file
diff --git a/3rdparty/libusb/src/msvc/Configuration.Base.props b/3rdparty/libusb/src/msvc/Configuration.Base.props
new file mode 100644
index 00000000..eb539d18
--- /dev/null
+++ b/3rdparty/libusb/src/msvc/Configuration.Base.props
@@ -0,0 +1,47 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup Label="Configuration">
+    <!--Will be overridden by value from command line, if provided-->
+    <PlatformToolset Condition="$(VisualStudioVersion)=='12.0'">v120</PlatformToolset>
+    <PlatformToolset Condition="$(VisualStudioVersion)=='14.0'">v140</PlatformToolset>
+    <PlatformToolset Condition="$(VisualStudioVersion)=='15.0'">v141</PlatformToolset>
+    <PlatformToolset Condition="$(VisualStudioVersion)=='16.0'">v142</PlatformToolset>
+    <PlatformToolset Condition="$(VisualStudioVersion)=='17.0'">v143</PlatformToolset>
+    <!--We may need the equivalent of PlatformToolsetVersion before it's ready, so create it ourself-->
+    <LibusbPlatformToolsetVersion>$(PlatformToolset.Substring(1))</LibusbPlatformToolsetVersion>
+    <CharacterSet>Unicode</CharacterSet>
+    <PreferredToolArchitecture>x64</PreferredToolArchitecture>
+    <!-- To use ASAN, just uncomment this. For simplicity, you should run VS/windbg/etc
+    (including the built executables themselves) after using vcvarsall or similar to setup
+    environment, as ASAN needs access to libs and executables in the toolchain paths.
+    -->
+    <!--<EnableASAN>true</EnableASAN>-->
+  </PropertyGroup>
+  <ItemDefinitionGroup>
+    <ClCompile Condition="$(Configuration.StartsWith('Debug'))">
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
+    </ClCompile>
+    <ClCompile Condition="$(Configuration.StartsWith('Release'))">
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <PropertyGroup Label="Globals" Condition="'$(LibusbPlatformToolsetVersion)'&lt;'142'">
+    <!--
+      WindowsSDKDesktopARMSupport and WindowsSDKDesktopARM64Support are
+      required to enable downlevel Windows SDKs to build "desktop" arm/arm64
+      binaries.
+      -->
+    <WindowsSDKDesktopARMSupport>true</WindowsSDKDesktopARMSupport>
+    <WindowsSDKDesktopARM64Support>true</WindowsSDKDesktopARM64Support>
+    <!--
+      WindowsTargetPlatformVersion must be set to explicit value for older
+      PlatformToolsets. Fetch it from environment variable.
+      vs2017/arm64 needs to be special cased to select 10.x SDK instead of 8.x
+    -->
+    <WindowsTargetPlatformVersion Condition="'$(LibusbPlatformToolsetVersion)'=='141' And $(Platform)=='ARM64'">10.0.19041.0</WindowsTargetPlatformVersion>
+    <WindowsTargetPlatformVersion Condition="'$(LibusbPlatformToolsetVersion)'!='141' Or $(Platform)!='ARM64'">$(WindowsSDKVersion)</WindowsTargetPlatformVersion>
+  </PropertyGroup>
+  <PropertyGroup Label="Globals" Condition="'$(LibusbPlatformToolsetVersion)'&gt;='142'">
+    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
+  </PropertyGroup>
+</Project>
\ No newline at end of file
diff --git a/3rdparty/libusb/src/msvc/Configuration.DynamicLibrary.props b/3rdparty/libusb/src/msvc/Configuration.DynamicLibrary.props
new file mode 100644
index 00000000..e93e6a8a
--- /dev/null
+++ b/3rdparty/libusb/src/msvc/Configuration.DynamicLibrary.props
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="Configuration.Base.props" />
+  <PropertyGroup Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+  </PropertyGroup>
+  <ItemDefinitionGroup>
+    <ClCompile Condition="'$(Configuration)'=='Debug'">
+      <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
+    </ClCompile>
+	<ClCompile Condition="'$(Configuration)'=='Debug-MT'">
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
+    </ClCompile>
+    <ClCompile Condition="'$(Configuration)'=='Release'">
+      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+    </ClCompile>
+	<ClCompile Condition="'$(Configuration)'=='Release-MT'">
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+    </ClCompile>
+  </ItemDefinitionGroup>
+</Project>
\ No newline at end of file
diff --git a/3rdparty/libusb/src/msvc/Configuration.StaticLibrary.props b/3rdparty/libusb/src/msvc/Configuration.StaticLibrary.props
new file mode 100644
index 00000000..162dd946
--- /dev/null
+++ b/3rdparty/libusb/src/msvc/Configuration.StaticLibrary.props
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="Configuration.Base.props" />
+  <PropertyGroup Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+  </PropertyGroup>
+</Project>
\ No newline at end of file
diff --git a/3rdparty/libusb/src/msvc/ProjectConfigurations.Base.props b/3rdparty/libusb/src/msvc/ProjectConfigurations.Base.props
new file mode 100644
index 00000000..186585bf
--- /dev/null
+++ b/3rdparty/libusb/src/msvc/ProjectConfigurations.Base.props
@@ -0,0 +1,69 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|ARM">
+      <Configuration>Debug</Configuration>
+      <Platform>ARM</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|ARM64">
+      <Configuration>Debug</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|ARM">
+      <Configuration>Release</Configuration>
+      <Platform>ARM</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|ARM64">
+      <Configuration>Release</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+	<ProjectConfiguration Include="Debug-MT|ARM">
+      <Configuration>Debug-MT</Configuration>
+      <Platform>ARM</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug-MT|ARM64">
+      <Configuration>Debug-MT</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug-MT|Win32">
+      <Configuration>Debug-MT</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug-MT|x64">
+      <Configuration>Debug-MT</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+	 <ProjectConfiguration Include="Release-MT|ARM">
+      <Configuration>Release-MT</Configuration>
+      <Platform>ARM</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release-MT|ARM64">
+      <Configuration>Release-MT</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release-MT|Win32">
+      <Configuration>Release-MT</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release-MT|x64">
+      <Configuration>Release-MT</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+</Project>
\ No newline at end of file
diff --git a/3rdparty/libusb/src/msvc/build_all.ps1 b/3rdparty/libusb/src/msvc/build_all.ps1
new file mode 100644
index 00000000..ffdbdc11
--- /dev/null
+++ b/3rdparty/libusb/src/msvc/build_all.ps1
@@ -0,0 +1,17 @@
+$toolsets = "v120", "v140", "v141", "v142", "v143"
+$platforms = "Win32", "x64", "ARM", "ARM64"
+$configurations = "Debug", "Release"
+
+foreach ($toolset in $toolsets) {
+    foreach ($plat in $platforms) {
+        if (("v120", "v140").contains($toolset) -and $plat -eq "ARM64") {
+            # VS2013,VS2015 don't support arm64
+            write-host ">>> PlatformToolset=$toolset,Platform=$plat SKIP"
+            continue
+        }
+        foreach ($conf in $configurations) {
+            write-host ">>> PlatformToolset=$toolset,Platform=$plat,Configuration=$conf"
+            msbuild -m -v:m -p:PlatformToolset=$toolset,Platform=$plat,Configuration=$conf $PSScriptRoot\libusb.sln
+        }
+    }
+}
\ No newline at end of file
diff --git a/3rdparty/libusb/src/msvc/config.h b/3rdparty/libusb/src/msvc/config.h
new file mode 100644
index 00000000..aad4817c
--- /dev/null
+++ b/3rdparty/libusb/src/msvc/config.h
@@ -0,0 +1,58 @@
+/* config.h.  Manual config for MSVC.  */
+
+#ifndef _MSC_VER
+#warn "msvc/config.h shouldn't be included for your development environment."
+#error "Please make sure the msvc/ directory is removed from your build path."
+#endif
+
+/* Visual Studio 2013 or later is required */
+#if(_MSC_VER < 1800)
+#error "Visual Studio 2013 or later is required."
+#endif
+
+/* Visual Studio 2013 and 2015 do not support __func__ */
+#if(_MSC_VER <= 1900)
+#define __func__ __FUNCTION__
+#endif
+
+/* Visual Studio 2015 and later defines timespec */
+#if(_MSC_VER >= 1900)
+#define _TIMESPEC_DEFINED 1
+#endif
+
+/* Disable: warning C4127: conditional expression is constant */
+#pragma warning(disable : 4127)
+/* Disable: warning C4200: nonstandard extension used : zero-sized array in struct/union */
+#pragma warning(disable : 4200)
+/* Disable: warning C4201: nonstandard extension used : nameless struct/union */
+#pragma warning(disable : 4201)
+/* Disable: warning C4324: structure was padded due to __declspec(align()) */
+#pragma warning(disable : 4324)
+/* Disable: warning C4996: 'GetVersionExA': was declared deprecated */
+#pragma warning(disable : 4996)
+
+#if defined(_PREFAST_)
+/* Disable "Banned API" errors when using the MS's WDK OACR/Prefast */
+#pragma warning(disable : 28719)
+/* Disable "The function 'InitializeCriticalSection' must be called from within a try/except block" */
+#pragma warning(disable : 28125)
+#endif
+
+/* Define to the attribute for default visibility. */
+#define DEFAULT_VISIBILITY /**/
+
+/* Define to 1 to start with debug message logging enabled. */
+/* #undef ENABLE_DEBUG_LOGGING */
+
+/* Define to 1 to enable message logging. */
+#define ENABLE_LOGGING 1
+
+/* Define to 1 if compiling for a Windows platform. */
+#define PLATFORM_WINDOWS 1
+
+/* Define to the attribute for enabling parameter checks on printf-like
+   functions. */
+#define PRINTF_FORMAT(a, b) /**/
+
+/* Define to 1 to output logging messages to the systemwide log. */
+/* #undef USE_SYSTEM_LOGGING_FACILITY */
diff --git a/3rdparty/libusb/src/msvc/dpfp.vcxproj b/3rdparty/libusb/src/msvc/dpfp.vcxproj
new file mode 100644
index 00000000..d2679df1
--- /dev/null
+++ b/3rdparty/libusb/src/msvc/dpfp.vcxproj
@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="ProjectConfigurations.Base.props" />
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{8c7814a1-fd6e-4185-9ea0-8208119756d4}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <Import Project="Configuration.Application.props" />
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="Base.props" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <ItemGroup>
+    <ClCompile Include="..\examples\dpfp.c" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include=".\config.h" />
+    <ClInclude Include="..\libusb\libusb.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include=".\libusb_static.vcxproj">
+      <Project>{349ee8f9-7d25-4909-aaf5-ff3fade72187}</Project>
+      <ReferenceOutputAssembly>false</ReferenceOutputAssembly>
+    </ProjectReference>
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>
\ No newline at end of file
diff --git a/3rdparty/libusb/src/msvc/dpfp_threaded.vcxproj b/3rdparty/libusb/src/msvc/dpfp_threaded.vcxproj
new file mode 100644
index 00000000..9e715583
--- /dev/null
+++ b/3rdparty/libusb/src/msvc/dpfp_threaded.vcxproj
@@ -0,0 +1,38 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="ProjectConfigurations.Base.props" />
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{8c7814a2-fd6e-4185-9ea0-8208119756d4}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <Import Project="Configuration.Application.props" />
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="Base.props" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <PreprocessorDefinitions>DPFP_THREADED;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include="..\examples\dpfp.c" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include=".\config.h" />
+    <ClInclude Include="..\libusb\libusb.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include=".\libusb_static.vcxproj">
+      <Project>{349ee8f9-7d25-4909-aaf5-ff3fade72187}</Project>
+      <ReferenceOutputAssembly>false</ReferenceOutputAssembly>
+    </ProjectReference>
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>
\ No newline at end of file
diff --git a/3rdparty/libusb/src/msvc/fxload.vcxproj b/3rdparty/libusb/src/msvc/fxload.vcxproj
new file mode 100644
index 00000000..96aa7dd4
--- /dev/null
+++ b/3rdparty/libusb/src/msvc/fxload.vcxproj
@@ -0,0 +1,46 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="ProjectConfigurations.Base.props" />
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{9E166F7A-A793-9FB6-0A67-F0AED8AE8C88}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <Import Project="Configuration.Application.props" />
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="Base.props" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <AdditionalIncludeDirectories>.\getopt;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <PreprocessorDefinitions>__GNU_LIBRARY__;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include="..\examples\ezusb.c" />
+    <ClCompile Include="..\examples\fxload.c" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include=".\config.h" />
+    <ClInclude Include=".\getopt\getopt.h" />
+    <ClInclude Include="..\examples\ezusb.h" />
+    <ClInclude Include="..\libusb\libusb.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include=".\getopt.vcxproj">
+      <Project>{ae83e1b4-ce06-47ee-b7a3-c3a1d7c2d71e}</Project>
+      <ReferenceOutputAssembly>false</ReferenceOutputAssembly>
+    </ProjectReference>
+    <ProjectReference Include=".\libusb_static.vcxproj">
+      <Project>{349ee8f9-7d25-4909-aaf5-ff3fade72187}</Project>
+      <ReferenceOutputAssembly>false</ReferenceOutputAssembly>
+    </ProjectReference>
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>
\ No newline at end of file
diff --git a/3rdparty/libusb/src/msvc/getopt.vcxproj b/3rdparty/libusb/src/msvc/getopt.vcxproj
new file mode 100644
index 00000000..d7b10887
--- /dev/null
+++ b/3rdparty/libusb/src/msvc/getopt.vcxproj
@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="ProjectConfigurations.Base.props" />
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{AE83E1B4-CE06-47EE-B7A3-C3A1D7C2D71E}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <Import Project="Configuration.StaticLibrary.props" />
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="Base.props" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <PreprocessorDefinitions>HAVE_STRING_H;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <DisableSpecificWarnings>4100;4131;%(DisableSpecificWarnings)</DisableSpecificWarnings>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include=".\getopt\getopt.c" />
+    <ClCompile Include=".\getopt\getopt1.c" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include=".\getopt\getopt.h" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>
\ No newline at end of file
diff --git a/3rdparty/libusb/src/msvc/getopt/getopt.c b/3rdparty/libusb/src/msvc/getopt/getopt.c
new file mode 100644
index 00000000..b7f26eb4
--- /dev/null
+++ b/3rdparty/libusb/src/msvc/getopt/getopt.c
@@ -0,0 +1,1060 @@
+/* Getopt for GNU.
+   NOTE: getopt is now part of the C library, so if you don't know what
+   "Keep this file name-space clean" means, talk to drepper@gnu.org
+   before changing it!
+   Copyright (C) 1987,88,89,90,91,92,93,94,95,96,98,99,2000,2001
+   	Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, write to the Free
+   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+   02111-1307 USA.  */
+
+/* This tells Alpha OSF/1 not to define a getopt prototype in <stdio.h>.
+   Ditto for AIX 3.2 and <stdlib.h>.  */
+#ifndef _NO_PROTO
+# define _NO_PROTO
+#endif
+
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#if !defined __STDC__ || !__STDC__
+/* This is a separate conditional since some stdc systems
+   reject `defined (const)'.  */
+# ifndef const
+#  define const
+# endif
+#endif
+
+#include <stdio.h>
+
+/* Comment out all this code if we are using the GNU C Library, and are not
+   actually compiling the library itself.  This code is part of the GNU C
+   Library, but also included in many other GNU distributions.  Compiling
+   and linking in this code is a waste when using the GNU C library
+   (especially if it is a shared library).  Rather than having every GNU
+   program understand `configure --with-gnu-libc' and omit the object files,
+   it is simpler to just do this in the source for each such file.  */
+
+#define GETOPT_INTERFACE_VERSION 2
+#if !defined _LIBC && defined __GLIBC__ && __GLIBC__ >= 2
+# include <gnu-versions.h>
+# if _GNU_GETOPT_INTERFACE_VERSION == GETOPT_INTERFACE_VERSION
+#  define ELIDE_CODE
+# endif
+#endif
+
+#ifndef ELIDE_CODE
+
+
+/* This needs to come after some library #include
+   to get __GNU_LIBRARY__ defined.  */
+#ifdef	__GNU_LIBRARY__
+/* Don't include stdlib.h for non-GNU C libraries because some of them
+   contain conflicting prototypes for getopt.  */
+# include <stdlib.h>
+# include <unistd.h>
+#endif	/* GNU C library.  */
+
+#ifdef VMS
+# include <unixlib.h>
+# if HAVE_STRING_H - 0
+#  include <string.h>
+# endif
+#endif
+
+#ifndef _
+/* This is for other GNU distributions with internationalized messages.  */
+# if (HAVE_LIBINTL_H && ENABLE_NLS) || defined _LIBC
+#  include <libintl.h>
+#  ifndef _
+#   define _(msgid)	gettext (msgid)
+#  endif
+# else
+#  define _(msgid)	(msgid)
+# endif
+#endif
+
+/* This version of `getopt' appears to the caller like standard Unix `getopt'
+   but it behaves differently for the user, since it allows the user
+   to intersperse the options with the other arguments.
+
+   As `getopt' works, it permutes the elements of ARGV so that,
+   when it is done, all the options precede everything else.  Thus
+   all application programs are extended to handle flexible argument order.
+
+   Setting the environment variable POSIXLY_CORRECT disables permutation.
+   Then the behavior is completely standard.
+
+   GNU application programs can use a third alternative mode in which
+   they can distinguish the relative order of options and other arguments.  */
+
+#include "getopt.h"
+
+/* For communication from `getopt' to the caller.
+   When `getopt' finds an option that takes an argument,
+   the argument value is returned here.
+   Also, when `ordering' is RETURN_IN_ORDER,
+   each non-option ARGV-element is returned here.  */
+
+char *optarg;
+
+/* Index in ARGV of the next element to be scanned.
+   This is used for communication to and from the caller
+   and for communication between successive calls to `getopt'.
+
+   On entry to `getopt', zero means this is the first call; initialize.
+
+   When `getopt' returns -1, this is the index of the first of the
+   non-option elements that the caller should itself scan.
+
+   Otherwise, `optind' communicates from one call to the next
+   how much of ARGV has been scanned so far.  */
+
+/* 1003.2 says this must be 1 before any call.  */
+int optind = 1;
+
+/* Formerly, initialization of getopt depended on optind==0, which
+   causes problems with re-calling getopt as programs generally don't
+   know that. */
+
+int __getopt_initialized;
+
+/* The next char to be scanned in the option-element
+   in which the last option character we returned was found.
+   This allows us to pick up the scan where we left off.
+
+   If this is zero, or a null string, it means resume the scan
+   by advancing to the next ARGV-element.  */
+
+static char *nextchar;
+
+/* Callers store zero here to inhibit the error message
+   for unrecognized options.  */
+
+int opterr = 1;
+
+/* Set to an option character which was unrecognized.
+   This must be initialized on some systems to avoid linking in the
+   system's own getopt implementation.  */
+
+int optopt = '?';
+
+/* Describe how to deal with options that follow non-option ARGV-elements.
+
+   If the caller did not specify anything,
+   the default is REQUIRE_ORDER if the environment variable
+   POSIXLY_CORRECT is defined, PERMUTE otherwise.
+
+   REQUIRE_ORDER means don't recognize them as options;
+   stop option processing when the first non-option is seen.
+   This is what Unix does.
+   This mode of operation is selected by either setting the environment
+   variable POSIXLY_CORRECT, or using `+' as the first character
+   of the list of option characters.
+
+   PERMUTE is the default.  We permute the contents of ARGV as we scan,
+   so that eventually all the non-options are at the end.  This allows options
+   to be given in any order, even with programs that were not written to
+   expect this.
+
+   RETURN_IN_ORDER is an option available to programs that were written
+   to expect options and other ARGV-elements in any order and that care about
+   the ordering of the two.  We describe each non-option ARGV-element
+   as if it were the argument of an option with character code 1.
+   Using `-' as the first character of the list of option characters
+   selects this mode of operation.
+
+   The special argument `--' forces an end of option-scanning regardless
+   of the value of `ordering'.  In the case of RETURN_IN_ORDER, only
+   `--' can cause `getopt' to return -1 with `optind' != ARGC.  */
+
+static enum
+{
+  REQUIRE_ORDER, PERMUTE, RETURN_IN_ORDER
+} ordering;
+
+/* Value of POSIXLY_CORRECT environment variable.  */
+static char *posixly_correct;
+
+#ifdef	__GNU_LIBRARY__
+/* We want to avoid inclusion of string.h with non-GNU libraries
+   because there are many ways it can cause trouble.
+   On some systems, it contains special magic macros that don't work
+   in GCC.  */
+# include <string.h>
+# define my_index	strchr
+#else
+
+# if HAVE_STRING_H
+#  include <string.h>
+# else
+#  include <strings.h>
+# endif
+
+/* Avoid depending on library functions or files
+   whose names are inconsistent.  */
+
+#ifndef getenv
+#ifdef _MSC_VER
+// DDK will complain if you don't use the stdlib defined getenv
+#include <stdlib.h>
+#else
+extern char *getenv ();
+#endif
+#endif
+
+static char *
+my_index (str, chr)
+     const char *str;
+     int chr;
+{
+  while (*str)
+    {
+      if (*str == chr)
+	return (char *) str;
+      str++;
+    }
+  return 0;
+}
+
+/* If using GCC, we can safely declare strlen this way.
+   If not using GCC, it is ok not to declare it.  */
+#ifdef __GNUC__
+/* Note that Motorola Delta 68k R3V7 comes with GCC but not stddef.h.
+   That was relevant to code that was here before.  */
+# if (!defined __STDC__ || !__STDC__) && !defined strlen
+/* gcc with -traditional declares the built-in strlen to return int,
+   and has done so at least since version 2.4.5. -- rms.  */
+extern int strlen (const char *);
+# endif /* not __STDC__ */
+#endif /* __GNUC__ */
+
+#endif /* not __GNU_LIBRARY__ */
+
+/* Handle permutation of arguments.  */
+
+/* Describe the part of ARGV that contains non-options that have
+   been skipped.  `first_nonopt' is the index in ARGV of the first of them;
+   `last_nonopt' is the index after the last of them.  */
+
+static int first_nonopt;
+static int last_nonopt;
+
+#ifdef _LIBC
+/* Stored original parameters.
+   XXX This is no good solution.  We should rather copy the args so
+   that we can compare them later.  But we must not use malloc(3).  */
+extern int __libc_argc;
+extern char **__libc_argv;
+
+/* Bash 2.0 gives us an environment variable containing flags
+   indicating ARGV elements that should not be considered arguments.  */
+
+# ifdef USE_NONOPTION_FLAGS
+/* Defined in getopt_init.c  */
+extern char *__getopt_nonoption_flags;
+
+static int nonoption_flags_max_len;
+static int nonoption_flags_len;
+# endif
+
+# ifdef USE_NONOPTION_FLAGS
+#  define SWAP_FLAGS(ch1, ch2) \
+  if (nonoption_flags_len > 0)						      \
+    {									      \
+      char __tmp = __getopt_nonoption_flags[ch1];			      \
+      __getopt_nonoption_flags[ch1] = __getopt_nonoption_flags[ch2];	      \
+      __getopt_nonoption_flags[ch2] = __tmp;				      \
+    }
+# else
+#  define SWAP_FLAGS(ch1, ch2)
+# endif
+#else	/* !_LIBC */
+# define SWAP_FLAGS(ch1, ch2)
+#endif	/* _LIBC */
+
+/* Exchange two adjacent subsequences of ARGV.
+   One subsequence is elements [first_nonopt,last_nonopt)
+   which contains all the non-options that have been skipped so far.
+   The other is elements [last_nonopt,optind), which contains all
+   the options processed since those non-options were skipped.
+
+   `first_nonopt' and `last_nonopt' are relocated so that they describe
+   the new indices of the non-options in ARGV after they are moved.  */
+
+#if defined __STDC__ && __STDC__
+static void exchange (char **);
+#endif
+
+static void
+exchange (argv)
+     char **argv;
+{
+  int bottom = first_nonopt;
+  int middle = last_nonopt;
+  int top = optind;
+  char *tem;
+
+  /* Exchange the shorter segment with the far end of the longer segment.
+     That puts the shorter segment into the right place.
+     It leaves the longer segment in the right place overall,
+     but it consists of two parts that need to be swapped next.  */
+
+#if defined _LIBC && defined USE_NONOPTION_FLAGS
+  /* First make sure the handling of the `__getopt_nonoption_flags'
+     string can work normally.  Our top argument must be in the range
+     of the string.  */
+  if (nonoption_flags_len > 0 && top >= nonoption_flags_max_len)
+    {
+      /* We must extend the array.  The user plays games with us and
+	 presents new arguments.  */
+      char *new_str = malloc (top + 1);
+      if (new_str == NULL)
+	nonoption_flags_len = nonoption_flags_max_len = 0;
+      else
+	{
+	  memset (__mempcpy (new_str, __getopt_nonoption_flags,
+			     nonoption_flags_max_len),
+		  '\0', top + 1 - nonoption_flags_max_len);
+	  nonoption_flags_max_len = top + 1;
+	  __getopt_nonoption_flags = new_str;
+	}
+    }
+#endif
+
+  while (top > middle && middle > bottom)
+    {
+      if (top - middle > middle - bottom)
+	{
+	  /* Bottom segment is the short one.  */
+	  int len = middle - bottom;
+	  register int i;
+
+	  /* Swap it with the top part of the top segment.  */
+	  for (i = 0; i < len; i++)
+	    {
+	      tem = argv[bottom + i];
+	      argv[bottom + i] = argv[top - (middle - bottom) + i];
+	      argv[top - (middle - bottom) + i] = tem;
+	      SWAP_FLAGS (bottom + i, top - (middle - bottom) + i);
+	    }
+	  /* Exclude the moved bottom segment from further swapping.  */
+	  top -= len;
+	}
+      else
+	{
+	  /* Top segment is the short one.  */
+	  int len = top - middle;
+	  register int i;
+
+	  /* Swap it with the bottom part of the bottom segment.  */
+	  for (i = 0; i < len; i++)
+	    {
+	      tem = argv[bottom + i];
+	      argv[bottom + i] = argv[middle + i];
+	      argv[middle + i] = tem;
+	      SWAP_FLAGS (bottom + i, middle + i);
+	    }
+	  /* Exclude the moved top segment from further swapping.  */
+	  bottom += len;
+	}
+    }
+
+  /* Update records for the slots the non-options now occupy.  */
+
+  first_nonopt += (optind - last_nonopt);
+  last_nonopt = optind;
+}
+
+/* Initialize the internal data when the first call is made.  */
+
+#if defined __STDC__ && __STDC__
+static const char *_getopt_initialize (int, char *const *, const char *);
+#endif
+static const char *
+_getopt_initialize (argc, argv, optstring)
+     int argc;
+     char *const *argv;
+     const char *optstring;
+{
+  /* Start processing options with ARGV-element 1 (since ARGV-element 0
+     is the program name); the sequence of previously skipped
+     non-option ARGV-elements is empty.  */
+
+  first_nonopt = last_nonopt = optind;
+
+  nextchar = NULL;
+
+  posixly_correct = getenv ("POSIXLY_CORRECT");
+
+  /* Determine how to handle the ordering of options and nonoptions.  */
+
+  if (optstring[0] == '-')
+    {
+      ordering = RETURN_IN_ORDER;
+      ++optstring;
+    }
+  else if (optstring[0] == '+')
+    {
+      ordering = REQUIRE_ORDER;
+      ++optstring;
+    }
+  else if (posixly_correct != NULL)
+    ordering = REQUIRE_ORDER;
+  else
+    ordering = PERMUTE;
+
+#if defined _LIBC && defined USE_NONOPTION_FLAGS
+  if (posixly_correct == NULL
+      && argc == __libc_argc && argv == __libc_argv)
+    {
+      if (nonoption_flags_max_len == 0)
+	{
+	  if (__getopt_nonoption_flags == NULL
+	      || __getopt_nonoption_flags[0] == '\0')
+	    nonoption_flags_max_len = -1;
+	  else
+	    {
+	      const char *orig_str = __getopt_nonoption_flags;
+	      int len = nonoption_flags_max_len = strlen (orig_str);
+	      if (nonoption_flags_max_len < argc)
+		nonoption_flags_max_len = argc;
+	      __getopt_nonoption_flags =
+		(char *) malloc (nonoption_flags_max_len);
+	      if (__getopt_nonoption_flags == NULL)
+		nonoption_flags_max_len = -1;
+	      else
+		memset (__mempcpy (__getopt_nonoption_flags, orig_str, len),
+			'\0', nonoption_flags_max_len - len);
+	    }
+	}
+      nonoption_flags_len = nonoption_flags_max_len;
+    }
+  else
+    nonoption_flags_len = 0;
+#endif
+
+  return optstring;
+}
+
+/* Scan elements of ARGV (whose length is ARGC) for option characters
+   given in OPTSTRING.
+
+   If an element of ARGV starts with '-', and is not exactly "-" or "--",
+   then it is an option element.  The characters of this element
+   (aside from the initial '-') are option characters.  If `getopt'
+   is called repeatedly, it returns successively each of the option characters
+   from each of the option elements.
+
+   If `getopt' finds another option character, it returns that character,
+   updating `optind' and `nextchar' so that the next call to `getopt' can
+   resume the scan with the following option character or ARGV-element.
+
+   If there are no more option characters, `getopt' returns -1.
+   Then `optind' is the index in ARGV of the first ARGV-element
+   that is not an option.  (The ARGV-elements have been permuted
+   so that those that are not options now come last.)
+
+   OPTSTRING is a string containing the legitimate option characters.
+   If an option character is seen that is not listed in OPTSTRING,
+   return '?' after printing an error message.  If you set `opterr' to
+   zero, the error message is suppressed but we still return '?'.
+
+   If a char in OPTSTRING is followed by a colon, that means it wants an arg,
+   so the following text in the same ARGV-element, or the text of the following
+   ARGV-element, is returned in `optarg'.  Two colons mean an option that
+   wants an optional arg; if there is text in the current ARGV-element,
+   it is returned in `optarg', otherwise `optarg' is set to zero.
+
+   If OPTSTRING starts with `-' or `+', it requests different methods of
+   handling the non-option ARGV-elements.
+   See the comments about RETURN_IN_ORDER and REQUIRE_ORDER, above.
+
+   Long-named options begin with `--' instead of `-'.
+   Their names may be abbreviated as long as the abbreviation is unique
+   or is an exact match for some defined option.  If they have an
+   argument, it follows the option name in the same ARGV-element, separated
+   from the option name by a `=', or else the in next ARGV-element.
+   When `getopt' finds a long-named option, it returns 0 if that option's
+   `flag' field is nonzero, the value of the option's `val' field
+   if the `flag' field is zero.
+
+   The elements of ARGV aren't really const, because we permute them.
+   But we pretend they're const in the prototype to be compatible
+   with other systems.
+
+   LONGOPTS is a vector of `struct option' terminated by an
+   element containing a name which is zero.
+
+   LONGIND returns the index in LONGOPT of the long-named option found.
+   It is only valid when a long-named option has been found by the most
+   recent call.
+
+   If LONG_ONLY is nonzero, '-' as well as '--' can introduce
+   long-named options.  */
+
+int
+_getopt_internal (argc, argv, optstring, longopts, longind, long_only)
+     int argc;
+     char *const *argv;
+     const char *optstring;
+     const struct option *longopts;
+     int *longind;
+     int long_only;
+{
+  int print_errors = opterr;
+  if (optstring[0] == ':')
+    print_errors = 0;
+
+  if (argc < 1)
+    return -1;
+
+  optarg = NULL;
+
+  if (optind == 0 || !__getopt_initialized)
+    {
+      if (optind == 0)
+	optind = 1;	/* Don't scan ARGV[0], the program name.  */
+      optstring = _getopt_initialize (argc, argv, optstring);
+      __getopt_initialized = 1;
+    }
+
+  /* Test whether ARGV[optind] points to a non-option argument.
+     Either it does not have option syntax, or there is an environment flag
+     from the shell indicating it is not an option.  The later information
+     is only used when the used in the GNU libc.  */
+#if defined _LIBC && defined USE_NONOPTION_FLAGS
+# define NONOPTION_P (argv[optind][0] != '-' || argv[optind][1] == '\0'	      \
+		      || (optind < nonoption_flags_len			      \
+			  && __getopt_nonoption_flags[optind] == '1'))
+#else
+# define NONOPTION_P (argv[optind][0] != '-' || argv[optind][1] == '\0')
+#endif
+
+  if (nextchar == NULL || *nextchar == '\0')
+    {
+      /* Advance to the next ARGV-element.  */
+
+      /* Give FIRST_NONOPT & LAST_NONOPT rational values if OPTIND has been
+	 moved back by the user (who may also have changed the arguments).  */
+      if (last_nonopt > optind)
+	last_nonopt = optind;
+      if (first_nonopt > optind)
+	first_nonopt = optind;
+
+      if (ordering == PERMUTE)
+	{
+	  /* If we have just processed some options following some non-options,
+	     exchange them so that the options come first.  */
+
+	  if (first_nonopt != last_nonopt && last_nonopt != optind)
+	    exchange ((char **) argv);
+	  else if (last_nonopt != optind)
+	    first_nonopt = optind;
+
+	  /* Skip any additional non-options
+	     and extend the range of non-options previously skipped.  */
+
+	  while (optind < argc && NONOPTION_P)
+	    optind++;
+	  last_nonopt = optind;
+	}
+
+      /* The special ARGV-element `--' means premature end of options.
+	 Skip it like a null option,
+	 then exchange with previous non-options as if it were an option,
+	 then skip everything else like a non-option.  */
+
+      if (optind != argc && !strcmp (argv[optind], "--"))
+	{
+	  optind++;
+
+	  if (first_nonopt != last_nonopt && last_nonopt != optind)
+	    exchange ((char **) argv);
+	  else if (first_nonopt == last_nonopt)
+	    first_nonopt = optind;
+	  last_nonopt = argc;
+
+	  optind = argc;
+	}
+
+      /* If we have done all the ARGV-elements, stop the scan
+	 and back over any non-options that we skipped and permuted.  */
+
+      if (optind == argc)
+	{
+	  /* Set the next-arg-index to point at the non-options
+	     that we previously skipped, so the caller will digest them.  */
+	  if (first_nonopt != last_nonopt)
+	    optind = first_nonopt;
+	  return -1;
+	}
+
+      /* If we have come to a non-option and did not permute it,
+	 either stop the scan or describe it to the caller and pass it by.  */
+
+      if (NONOPTION_P)
+	{
+	  if (ordering == REQUIRE_ORDER)
+	    return -1;
+	  optarg = argv[optind++];
+	  return 1;
+	}
+
+      /* We have found another option-ARGV-element.
+	 Skip the initial punctuation.  */
+
+      nextchar = (argv[optind] + 1
+		  + (longopts != NULL && argv[optind][1] == '-'));
+    }
+
+  /* Decode the current option-ARGV-element.  */
+
+  /* Check whether the ARGV-element is a long option.
+
+     If long_only and the ARGV-element has the form "-f", where f is
+     a valid short option, don't consider it an abbreviated form of
+     a long option that starts with f.  Otherwise there would be no
+     way to give the -f short option.
+
+     On the other hand, if there's a long option "fubar" and
+     the ARGV-element is "-fu", do consider that an abbreviation of
+     the long option, just like "--fu", and not "-f" with arg "u".
+
+     This distinction seems to be the most useful approach.  */
+
+  if (longopts != NULL
+      && (argv[optind][1] == '-'
+	  || (long_only && (argv[optind][2] || !my_index (optstring, argv[optind][1])))))
+    {
+      char *nameend;
+      const struct option *p;
+      const struct option *pfound = NULL;
+      int exact = 0;
+      int ambig = 0;
+      int indfound = -1;
+      int option_index;
+
+      for (nameend = nextchar; *nameend && *nameend != '='; nameend++)
+	/* Do nothing.  */ ;
+
+      /* Test all long options for either exact match
+	 or abbreviated matches.  */
+      for (p = longopts, option_index = 0; p->name; p++, option_index++)
+	if (!strncmp (p->name, nextchar, nameend - nextchar))
+	  {
+	    if ((unsigned int) (nameend - nextchar)
+		== (unsigned int) strlen (p->name))
+	      {
+		/* Exact match found.  */
+		pfound = p;
+		indfound = option_index;
+		exact = 1;
+		break;
+	      }
+	    else if (pfound == NULL)
+	      {
+		/* First nonexact match found.  */
+		pfound = p;
+		indfound = option_index;
+	      }
+	    else if (long_only
+		     || pfound->has_arg != p->has_arg
+		     || pfound->flag != p->flag
+		     || pfound->val != p->val)
+	      /* Second or later nonexact match found.  */
+	      ambig = 1;
+	  }
+
+      if (ambig && !exact)
+	{
+	  if (print_errors)
+	    fprintf (stderr, _("%s: option `%s' is ambiguous\n"),
+		     argv[0], argv[optind]);
+	  nextchar += strlen (nextchar);
+	  optind++;
+	  optopt = 0;
+	  return '?';
+	}
+
+      if (pfound != NULL)
+	{
+	  option_index = indfound;
+	  optind++;
+	  if (*nameend)
+	    {
+	      /* Don't test has_arg with >, because some C compilers don't
+		 allow it to be used on enums.  */
+	      if (pfound->has_arg)
+		optarg = nameend + 1;
+	      else
+		{
+		  if (print_errors)
+		    {
+		      if (argv[optind - 1][1] == '-')
+			/* --option */
+			fprintf (stderr,
+				 _("%s: option `--%s' doesn't allow an argument\n"),
+				 argv[0], pfound->name);
+		      else
+			/* +option or -option */
+			fprintf (stderr,
+				 _("%s: option `%c%s' doesn't allow an argument\n"),
+				 argv[0], argv[optind - 1][0], pfound->name);
+		    }
+
+		  nextchar += strlen (nextchar);
+
+		  optopt = pfound->val;
+		  return '?';
+		}
+	    }
+	  else if (pfound->has_arg == 1)
+	    {
+	      if (optind < argc)
+		optarg = argv[optind++];
+	      else
+		{
+		  if (print_errors)
+		    fprintf (stderr,
+			   _("%s: option `%s' requires an argument\n"),
+			   argv[0], argv[optind - 1]);
+		  nextchar += strlen (nextchar);
+		  optopt = pfound->val;
+		  return optstring[0] == ':' ? ':' : '?';
+		}
+	    }
+	  nextchar += strlen (nextchar);
+	  if (longind != NULL)
+	    *longind = option_index;
+	  if (pfound->flag)
+	    {
+	      *(pfound->flag) = pfound->val;
+	      return 0;
+	    }
+	  return pfound->val;
+	}
+
+      /* Can't find it as a long option.  If this is not getopt_long_only,
+	 or the option starts with '--' or is not a valid short
+	 option, then it's an error.
+	 Otherwise interpret it as a short option.  */
+      if (!long_only || argv[optind][1] == '-'
+	  || my_index (optstring, *nextchar) == NULL)
+	{
+	  if (print_errors)
+	    {
+	      if (argv[optind][1] == '-')
+		/* --option */
+		fprintf (stderr, _("%s: unrecognized option `--%s'\n"),
+			 argv[0], nextchar);
+	      else
+		/* +option or -option */
+		fprintf (stderr, _("%s: unrecognized option `%c%s'\n"),
+			 argv[0], argv[optind][0], nextchar);
+	    }
+	  nextchar = (char *) "";
+	  optind++;
+	  optopt = 0;
+	  return '?';
+	}
+    }
+
+  /* Look at and handle the next short option-character.  */
+
+  {
+    char c = *nextchar++;
+    char *temp = my_index (optstring, c);
+
+    /* Increment `optind' when we start to process its last character.  */
+    if (*nextchar == '\0')
+      ++optind;
+
+    if (temp == NULL || c == ':')
+      {
+	if (print_errors)
+	  {
+	    if (posixly_correct)
+	      /* 1003.2 specifies the format of this message.  */
+	      fprintf (stderr, _("%s: illegal option -- %c\n"),
+		       argv[0], c);
+	    else
+	      fprintf (stderr, _("%s: invalid option -- %c\n"),
+		       argv[0], c);
+	  }
+	optopt = c;
+	return '?';
+      }
+    /* Convenience. Treat POSIX -W foo same as long option --foo */
+    if (temp[0] == 'W' && temp[1] == ';')
+      {
+	char *nameend;
+	const struct option *p;
+	const struct option *pfound = NULL;
+	int exact = 0;
+	int ambig = 0;
+	int indfound = 0;
+	int option_index;
+
+	/* This is an option that requires an argument.  */
+	if (*nextchar != '\0')
+	  {
+	    optarg = nextchar;
+	    /* If we end this ARGV-element by taking the rest as an arg,
+	       we must advance to the next element now.  */
+	    optind++;
+	  }
+	else if (optind == argc)
+	  {
+	    if (print_errors)
+	      {
+		/* 1003.2 specifies the format of this message.  */
+		fprintf (stderr, _("%s: option requires an argument -- %c\n"),
+			 argv[0], c);
+	      }
+	    optopt = c;
+	    if (optstring[0] == ':')
+	      c = ':';
+	    else
+	      c = '?';
+	    return c;
+	  }
+	else
+	  /* We already incremented `optind' once;
+	     increment it again when taking next ARGV-elt as argument.  */
+	  optarg = argv[optind++];
+
+	/* optarg is now the argument, see if it's in the
+	   table of longopts.  */
+
+	for (nextchar = nameend = optarg; *nameend && *nameend != '='; nameend++)
+	  /* Do nothing.  */ ;
+
+	/* Test all long options for either exact match
+	   or abbreviated matches.  */
+	for (p = longopts, option_index = 0; p != NULL && p->name; p++, option_index++)
+	  if (!strncmp (p->name, nextchar, nameend - nextchar))
+	    {
+	      if ((unsigned int) (nameend - nextchar) == strlen (p->name))
+		{
+		  /* Exact match found.  */
+		  pfound = p;
+		  indfound = option_index;
+		  exact = 1;
+		  break;
+		}
+	      else if (pfound == NULL)
+		{
+		  /* First nonexact match found.  */
+		  pfound = p;
+		  indfound = option_index;
+		}
+	      else
+		/* Second or later nonexact match found.  */
+		ambig = 1;
+	    }
+	if (ambig && !exact)
+	  {
+	    if (print_errors)
+	      fprintf (stderr, _("%s: option `-W %s' is ambiguous\n"),
+		       argv[0], argv[optind]);
+	    nextchar += strlen (nextchar);
+	    optind++;
+	    return '?';
+	  }
+	if (pfound != NULL)
+	  {
+	    option_index = indfound;
+	    if (*nameend)
+	      {
+		/* Don't test has_arg with >, because some C compilers don't
+		   allow it to be used on enums.  */
+		if (pfound->has_arg)
+		  optarg = nameend + 1;
+		else
+		  {
+		    if (print_errors)
+		      fprintf (stderr, _("\
+%s: option `-W %s' doesn't allow an argument\n"),
+			       argv[0], pfound->name);
+
+		    nextchar += strlen (nextchar);
+		    return '?';
+		  }
+	      }
+	    else if (pfound->has_arg == 1)
+	      {
+		if (optind < argc)
+		  optarg = argv[optind++];
+		else
+		  {
+		    if (print_errors)
+		      fprintf (stderr,
+			       _("%s: option `%s' requires an argument\n"),
+			       argv[0], argv[optind - 1]);
+		    nextchar += strlen (nextchar);
+		    return optstring[0] == ':' ? ':' : '?';
+		  }
+	      }
+	    nextchar += strlen (nextchar);
+	    if (longind != NULL)
+	      *longind = option_index;
+	    if (pfound->flag)
+	      {
+		*(pfound->flag) = pfound->val;
+		return 0;
+	      }
+	    return pfound->val;
+	  }
+	  nextchar = NULL;
+	  return 'W';	/* Let the application handle it.   */
+      }
+    if (temp[1] == ':')
+      {
+	if (temp[2] == ':')
+	  {
+	    /* This is an option that accepts an argument optionally.  */
+	    if (*nextchar != '\0')
+	      {
+		optarg = nextchar;
+		optind++;
+	      }
+	    else
+	      optarg = NULL;
+	    nextchar = NULL;
+	  }
+	else
+	  {
+	    /* This is an option that requires an argument.  */
+	    if (*nextchar != '\0')
+	      {
+		optarg = nextchar;
+		/* If we end this ARGV-element by taking the rest as an arg,
+		   we must advance to the next element now.  */
+		optind++;
+	      }
+	    else if (optind == argc)
+	      {
+		if (print_errors)
+		  {
+		    /* 1003.2 specifies the format of this message.  */
+		    fprintf (stderr,
+			     _("%s: option requires an argument -- %c\n"),
+			     argv[0], c);
+		  }
+		optopt = c;
+		if (optstring[0] == ':')
+		  c = ':';
+		else
+		  c = '?';
+	      }
+	    else
+	      /* We already incremented `optind' once;
+		 increment it again when taking next ARGV-elt as argument.  */
+	      optarg = argv[optind++];
+	    nextchar = NULL;
+	  }
+      }
+    return c;
+  }
+}
+
+int
+getopt (argc, argv, optstring)
+     int argc;
+     char *const *argv;
+     const char *optstring;
+{
+  return _getopt_internal (argc, argv, optstring,
+			   (const struct option *) 0,
+			   (int *) 0,
+			   0);
+}
+
+#endif	/* Not ELIDE_CODE.  */
+
+#ifdef TEST
+
+/* Compile with -DTEST to make an executable for use in testing
+   the above definition of `getopt'.  */
+
+int
+main (argc, argv)
+     int argc;
+     char **argv;
+{
+  int c;
+  int digit_optind = 0;
+
+  while (1)
+    {
+      int this_option_optind = optind ? optind : 1;
+
+      c = getopt (argc, argv, "abc:d:0123456789");
+      if (c == -1)
+	break;
+
+      switch (c)
+	{
+	case '0':
+	case '1':
+	case '2':
+	case '3':
+	case '4':
+	case '5':
+	case '6':
+	case '7':
+	case '8':
+	case '9':
+	  if (digit_optind != 0 && digit_optind != this_option_optind)
+	    printf ("digits occur in two different argv-elements.\n");
+	  digit_optind = this_option_optind;
+	  printf ("option %c\n", c);
+	  break;
+
+	case 'a':
+	  printf ("option a\n");
+	  break;
+
+	case 'b':
+	  printf ("option b\n");
+	  break;
+
+	case 'c':
+	  printf ("option c with value `%s'\n", optarg);
+	  break;
+
+	case '?':
+	  break;
+
+	default:
+	  printf ("?? getopt returned character code 0%o ??\n", c);
+	}
+    }
+
+  if (optind < argc)
+    {
+      printf ("non-option ARGV-elements: ");
+      while (optind < argc)
+	printf ("%s ", argv[optind++]);
+      printf ("\n");
+    }
+
+  exit (0);
+}
+
+#endif /* TEST */
diff --git a/3rdparty/libusb/src/msvc/getopt/getopt.h b/3rdparty/libusb/src/msvc/getopt/getopt.h
new file mode 100644
index 00000000..a1b8dd66
--- /dev/null
+++ b/3rdparty/libusb/src/msvc/getopt/getopt.h
@@ -0,0 +1,180 @@
+/* Declarations for getopt.
+   Copyright (C) 1989-1994, 1996-1999, 2001 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, write to the Free
+   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+   02111-1307 USA.  */
+
+#ifndef _GETOPT_H
+
+#ifndef __need_getopt
+# define _GETOPT_H 1
+#endif
+
+/* If __GNU_LIBRARY__ is not already defined, either we are being used
+   standalone, or this is the first header included in the source file.
+   If we are being used with glibc, we need to include <features.h>, but
+   that does not exist if we are standalone.  So: if __GNU_LIBRARY__ is
+   not defined, include <ctype.h>, which will pull in <features.h> for us
+   if it's from glibc.  (Why ctype.h?  It's guaranteed to exist and it
+   doesn't flood the namespace with stuff the way some other headers do.)  */
+#if !defined __GNU_LIBRARY__
+# include <ctype.h>
+#endif
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+/* For communication from `getopt' to the caller.
+   When `getopt' finds an option that takes an argument,
+   the argument value is returned here.
+   Also, when `ordering' is RETURN_IN_ORDER,
+   each non-option ARGV-element is returned here.  */
+
+extern char *optarg;
+
+/* Index in ARGV of the next element to be scanned.
+   This is used for communication to and from the caller
+   and for communication between successive calls to `getopt'.
+
+   On entry to `getopt', zero means this is the first call; initialize.
+
+   When `getopt' returns -1, this is the index of the first of the
+   non-option elements that the caller should itself scan.
+
+   Otherwise, `optind' communicates from one call to the next
+   how much of ARGV has been scanned so far.  */
+
+extern int optind;
+
+/* Callers store zero here to inhibit the error message `getopt' prints
+   for unrecognized options.  */
+
+extern int opterr;
+
+/* Set to an option character which was unrecognized.  */
+
+extern int optopt;
+
+#ifndef __need_getopt
+/* Describe the long-named options requested by the application.
+   The LONG_OPTIONS argument to getopt_long or getopt_long_only is a vector
+   of `struct option' terminated by an element containing a name which is
+   zero.
+
+   The field `has_arg' is:
+   no_argument		(or 0) if the option does not take an argument,
+   required_argument	(or 1) if the option requires an argument,
+   optional_argument 	(or 2) if the option takes an optional argument.
+
+   If the field `flag' is not NULL, it points to a variable that is set
+   to the value given in the field `val' when the option is found, but
+   left unchanged if the option is not found.
+
+   To have a long-named option do something other than set an `int' to
+   a compiled-in constant, such as set a value from `optarg', set the
+   option's `flag' field to zero and its `val' field to a nonzero
+   value (the equivalent single-letter option character, if there is
+   one).  For long options that have a zero `flag' field, `getopt'
+   returns the contents of the `val' field.  */
+
+struct option
+{
+# if (defined __STDC__ && __STDC__) || defined __cplusplus
+  const char *name;
+# else
+  char *name;
+# endif
+  /* has_arg can't be an enum because some compilers complain about
+     type mismatches in all the code that assumes it is an int.  */
+  int has_arg;
+  int *flag;
+  int val;
+};
+
+/* Names for the values of the `has_arg' field of `struct option'.  */
+
+# define no_argument		0
+# define required_argument	1
+# define optional_argument	2
+#endif	/* need getopt */
+
+
+/* Get definitions and prototypes for functions to process the
+   arguments in ARGV (ARGC of them, minus the program name) for
+   options given in OPTS.
+
+   Return the option character from OPTS just read.  Return -1 when
+   there are no more options.  For unrecognized options, or options
+   missing arguments, `optopt' is set to the option letter, and '?' is
+   returned.
+
+   The OPTS string is a list of characters which are recognized option
+   letters, optionally followed by colons, specifying that that letter
+   takes an argument, to be placed in `optarg'.
+
+   If a letter in OPTS is followed by two colons, its argument is
+   optional.  This behavior is specific to the GNU `getopt'.
+
+   The argument `--' causes premature termination of argument
+   scanning, explicitly telling `getopt' that there are no more
+   options.
+
+   If OPTS begins with `--', then non-option arguments are treated as
+   arguments to the option '\0'.  This behavior is specific to the GNU
+   `getopt'.  */
+
+#if (defined __STDC__ && __STDC__) || defined __cplusplus
+# ifdef __GNU_LIBRARY__
+/* Many other libraries have conflicting prototypes for getopt, with
+   differences in the consts, in stdlib.h.  To avoid compilation
+   errors, only prototype getopt for the GNU C library.  */
+extern int getopt (int __argc, char *const *__argv, const char *__shortopts);
+# else /* not __GNU_LIBRARY__ */
+extern int getopt ();
+# endif /* __GNU_LIBRARY__ */
+
+# ifndef __need_getopt
+extern int getopt_long (int __argc, char *const *__argv, const char *__shortopts,
+		        const struct option *__longopts, int *__longind);
+extern int getopt_long_only (int __argc, char *const *__argv,
+			     const char *__shortopts,
+		             const struct option *__longopts, int *__longind);
+
+/* Internal only.  Users should not call this directly.  */
+extern int _getopt_internal (int __argc, char *const *__argv,
+			     const char *__shortopts,
+		             const struct option *__longopts, int *__longind,
+			     int __long_only);
+# endif
+#else /* not __STDC__ */
+extern int getopt ();
+# ifndef __need_getopt
+extern int getopt_long ();
+extern int getopt_long_only ();
+
+extern int _getopt_internal ();
+# endif
+#endif /* __STDC__ */
+
+#ifdef	__cplusplus
+}
+#endif
+
+/* Make sure we later can get all the definitions and declarations.  */
+#undef __need_getopt
+
+#endif /* getopt.h */
diff --git a/3rdparty/libusb/src/msvc/getopt/getopt1.c b/3rdparty/libusb/src/msvc/getopt/getopt1.c
new file mode 100644
index 00000000..7e41d466
--- /dev/null
+++ b/3rdparty/libusb/src/msvc/getopt/getopt1.c
@@ -0,0 +1,167 @@
+/* getopt_long and getopt_long_only entry points for GNU getopt.
+   Copyright (C) 1987,88,89,90,91,92,93,94,96,97,98
+     Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, write to the Free
+   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+   02111-1307 USA.  */
+
+#ifdef HAVE_CONFIG_H
+#include <libusb/config.h>
+#endif
+
+#include "getopt.h"
+
+#if !defined __STDC__ || !__STDC__
+/* This is a separate conditional since some stdc systems
+   reject `defined (const)'.  */
+#ifndef const
+#define const
+#endif
+#endif
+
+#include <stdio.h>
+
+/* Comment out all this code if we are using the GNU C Library, and are not
+   actually compiling the library itself.  This code is part of the GNU C
+   Library, but also included in many other GNU distributions.  Compiling
+   and linking in this code is a waste when using the GNU C library
+   (especially if it is a shared library).  Rather than having every GNU
+   program understand `configure --with-gnu-libc' and omit the object files,
+   it is simpler to just do this in the source for each such file.  */
+
+#define GETOPT_INTERFACE_VERSION 2
+#if !defined _LIBC && defined __GLIBC__ && __GLIBC__ >= 2
+#include <gnu-versions.h>
+#if _GNU_GETOPT_INTERFACE_VERSION == GETOPT_INTERFACE_VERSION
+#define ELIDE_CODE
+#endif
+#endif
+
+#ifndef ELIDE_CODE
+
+/* This needs to come after some library #include
+   to get __GNU_LIBRARY__ defined.  */
+#ifdef __GNU_LIBRARY__
+#include <stdlib.h>
+#endif
+
+#ifndef NULL
+#define NULL 0
+#endif
+
+int                  getopt_long(argc, argv, options, long_options, opt_index)
+int                  argc;
+char *const         *argv;
+const char          *options;
+const struct option *long_options;
+int                 *opt_index;
+{ return _getopt_internal(argc, argv, options, long_options, opt_index, 0); }
+
+/* Like getopt_long, but '-' as well as '--' can indicate a long option.
+   If an option that starts with '-' (not '--') doesn't match a long option,
+   but does match a short option, it is parsed as a short option
+   instead.  */
+
+int                  getopt_long_only(argc, argv, options, long_options, opt_index)
+int                  argc;
+char *const         *argv;
+const char          *options;
+const struct option *long_options;
+int                 *opt_index;
+{ return _getopt_internal(argc, argv, options, long_options, opt_index, 1); }
+
+#endif /* Not ELIDE_CODE.  */
+
+#ifdef TEST
+
+#include <stdio.h>
+
+int    main(argc, argv)
+int    argc;
+char **argv;
+{
+    int c;
+    int digit_optind = 0;
+
+    while(1) {
+        int                  this_option_optind = optind ? optind : 1;
+        int                  option_index       = 0;
+        static struct option long_options[]     = { { "add", 1, 0, 0 },    { "append", 0, 0, 0 }, { "delete", 1, 0, 0 }, { "verbose", 0, 0, 0 },
+                                                    { "create", 0, 0, 0 }, { "file", 1, 0, 0 },   { 0, 0, 0, 0 } };
+
+        c = getopt_long(argc, argv, "abc:d:0123456789", long_options, &option_index);
+        if(c == -1)
+            break;
+
+        switch(c) {
+        case 0:
+            printf("option %s", long_options[option_index].name);
+            if(optarg)
+                printf(" with arg %s", optarg);
+            printf("\n");
+            break;
+
+        case '0':
+        case '1':
+        case '2':
+        case '3':
+        case '4':
+        case '5':
+        case '6':
+        case '7':
+        case '8':
+        case '9':
+            if(digit_optind != 0 && digit_optind != this_option_optind)
+                printf("digits occur in two different argv-elements.\n");
+            digit_optind = this_option_optind;
+            printf("option %c\n", c);
+            break;
+
+        case 'a':
+            printf("option a\n");
+            break;
+
+        case 'b':
+            printf("option b\n");
+            break;
+
+        case 'c':
+            printf("option c with value `%s'\n", optarg);
+            break;
+
+        case 'd':
+            printf("option d with value `%s'\n", optarg);
+            break;
+
+        case '?':
+            break;
+
+        default:
+            printf("?? getopt returned character code 0%o ??\n", c);
+        }
+    }
+
+    if(optind < argc) {
+        printf("non-option ARGV-elements: ");
+        while(optind < argc)
+            printf("%s ", argv[optind++]);
+        printf("\n");
+    }
+
+    exit(0);
+}
+
+#endif /* TEST */
diff --git a/3rdparty/libusb/src/msvc/hotplugtest.vcxproj b/3rdparty/libusb/src/msvc/hotplugtest.vcxproj
new file mode 100644
index 00000000..1e6e08f0
--- /dev/null
+++ b/3rdparty/libusb/src/msvc/hotplugtest.vcxproj
@@ -0,0 +1,32 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="ProjectConfigurations.Base.props" />
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{99D2AC64-DC66-4422-91CE-6715C403C9E5}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <Import Project="Configuration.Application.props" />
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="Base.props" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <ItemGroup>
+    <ClCompile Include="..\examples\hotplugtest.c" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\libusb\libusb.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include=".\libusb_static.vcxproj">
+      <Project>{349ee8f9-7d25-4909-aaf5-ff3fade72187}</Project>
+      <ReferenceOutputAssembly>false</ReferenceOutputAssembly>
+    </ProjectReference>
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>
\ No newline at end of file
diff --git a/3rdparty/libusb/src/msvc/libusb.sln b/3rdparty/libusb/src/msvc/libusb.sln
new file mode 100644
index 00000000..c551fc80
--- /dev/null
+++ b/3rdparty/libusb/src/msvc/libusb.sln
@@ -0,0 +1,508 @@
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 17
+VisualStudioVersion = 17.0.32112.339
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "libusb_static", "libusb_static.vcxproj", "{349EE8F9-7D25-4909-AAF5-FF3FADE72187}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "libusb_dll", "libusb_dll.vcxproj", "{349EE8FA-7D25-4909-AAF5-FF3FADE72187}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "dpfp", "dpfp.vcxproj", "{8C7814A1-FD6E-4185-9EA0-8208119756D4}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "dpfp_threaded", "dpfp_threaded.vcxproj", "{8C7814A2-FD6E-4185-9EA0-8208119756D4}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "fxload", "fxload.vcxproj", "{9E166F7A-A793-9FB6-0A67-F0AED8AE8C88}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "getopt", "getopt.vcxproj", "{AE83E1B4-CE06-47EE-B7A3-C3A1D7C2D71E}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "hotplugtest", "hotplugtest.vcxproj", "{99D2AC64-DC66-4422-91CE-6715C403C9E5}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "listdevs", "listdevs.vcxproj", "{F4938DB0-3DE7-4737-9C5A-EAD1BE819F87}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "sam3u_benchmark", "sam3u_benchmark.vcxproj", "{861CDD5F-59A2-4F34-957E-5C1AF98BE0A4}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "stress", "stress.vcxproj", "{53942EFF-C810-458D-B3CB-EE5CE9F1E781}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "stress_mt", "stress_mt.vcxproj", "{9EAF1311-2BBB-4177-882B-DA7FA0AD7912}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "testlibusb", "testlibusb.vcxproj", "{70828935-325B-4749-B381-0E55EF31AEE8}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "xusb", "xusb.vcxproj", "{3F3138D0-7AB7-4268-9BF3-1A3EA5503A11}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "set_option", "set_option.vcxproj", "{35BD5D4B-5102-4A08-81C0-AAF3285FCB01}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|ARM = Debug|ARM
+		Debug|ARM64 = Debug|ARM64
+		Debug|Win32 = Debug|Win32
+		Debug|x64 = Debug|x64
+		Debug-MT|ARM = Debug-MT|ARM
+		Debug-MT|ARM64 = Debug-MT|ARM64
+		Debug-MT|Win32 = Debug-MT|Win32
+		Debug-MT|x64 = Debug-MT|x64
+		Release|ARM = Release|ARM
+		Release|ARM64 = Release|ARM64
+		Release|Win32 = Release|Win32
+		Release|x64 = Release|x64
+		Release-MT|ARM = Release-MT|ARM
+		Release-MT|ARM64 = Release-MT|ARM64
+		Release-MT|Win32 = Release-MT|Win32
+		Release-MT|x64 = Release-MT|x64
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{349EE8F9-7D25-4909-AAF5-FF3FADE72187}.Debug|ARM.ActiveCfg = Debug|ARM
+		{349EE8F9-7D25-4909-AAF5-FF3FADE72187}.Debug|ARM.Build.0 = Debug|ARM
+		{349EE8F9-7D25-4909-AAF5-FF3FADE72187}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{349EE8F9-7D25-4909-AAF5-FF3FADE72187}.Debug|ARM64.Build.0 = Debug|ARM64
+		{349EE8F9-7D25-4909-AAF5-FF3FADE72187}.Debug|Win32.ActiveCfg = Debug|Win32
+		{349EE8F9-7D25-4909-AAF5-FF3FADE72187}.Debug|Win32.Build.0 = Debug|Win32
+		{349EE8F9-7D25-4909-AAF5-FF3FADE72187}.Debug|x64.ActiveCfg = Debug|x64
+		{349EE8F9-7D25-4909-AAF5-FF3FADE72187}.Debug|x64.Build.0 = Debug|x64
+		{349EE8F9-7D25-4909-AAF5-FF3FADE72187}.Debug-MT|ARM.ActiveCfg = Debug-MT|ARM
+		{349EE8F9-7D25-4909-AAF5-FF3FADE72187}.Debug-MT|ARM.Build.0 = Debug-MT|ARM
+		{349EE8F9-7D25-4909-AAF5-FF3FADE72187}.Debug-MT|ARM64.ActiveCfg = Debug-MT|ARM64
+		{349EE8F9-7D25-4909-AAF5-FF3FADE72187}.Debug-MT|ARM64.Build.0 = Debug-MT|ARM64
+		{349EE8F9-7D25-4909-AAF5-FF3FADE72187}.Debug-MT|Win32.ActiveCfg = Debug-MT|Win32
+		{349EE8F9-7D25-4909-AAF5-FF3FADE72187}.Debug-MT|Win32.Build.0 = Debug-MT|Win32
+		{349EE8F9-7D25-4909-AAF5-FF3FADE72187}.Debug-MT|x64.ActiveCfg = Debug-MT|x64
+		{349EE8F9-7D25-4909-AAF5-FF3FADE72187}.Debug-MT|x64.Build.0 = Debug-MT|x64
+		{349EE8F9-7D25-4909-AAF5-FF3FADE72187}.Release|ARM.ActiveCfg = Release|ARM
+		{349EE8F9-7D25-4909-AAF5-FF3FADE72187}.Release|ARM.Build.0 = Release|ARM
+		{349EE8F9-7D25-4909-AAF5-FF3FADE72187}.Release|ARM64.ActiveCfg = Release|ARM64
+		{349EE8F9-7D25-4909-AAF5-FF3FADE72187}.Release|ARM64.Build.0 = Release|ARM64
+		{349EE8F9-7D25-4909-AAF5-FF3FADE72187}.Release|Win32.ActiveCfg = Release|Win32
+		{349EE8F9-7D25-4909-AAF5-FF3FADE72187}.Release|Win32.Build.0 = Release|Win32
+		{349EE8F9-7D25-4909-AAF5-FF3FADE72187}.Release|x64.ActiveCfg = Release|x64
+		{349EE8F9-7D25-4909-AAF5-FF3FADE72187}.Release|x64.Build.0 = Release|x64
+		{349EE8F9-7D25-4909-AAF5-FF3FADE72187}.Release-MT|ARM.ActiveCfg = Release-MT|ARM
+		{349EE8F9-7D25-4909-AAF5-FF3FADE72187}.Release-MT|ARM.Build.0 = Release-MT|ARM
+		{349EE8F9-7D25-4909-AAF5-FF3FADE72187}.Release-MT|ARM64.ActiveCfg = Release-MT|ARM64
+		{349EE8F9-7D25-4909-AAF5-FF3FADE72187}.Release-MT|ARM64.Build.0 = Release-MT|ARM64
+		{349EE8F9-7D25-4909-AAF5-FF3FADE72187}.Release-MT|Win32.ActiveCfg = Release-MT|Win32
+		{349EE8F9-7D25-4909-AAF5-FF3FADE72187}.Release-MT|Win32.Build.0 = Release-MT|Win32
+		{349EE8F9-7D25-4909-AAF5-FF3FADE72187}.Release-MT|x64.ActiveCfg = Release-MT|x64
+		{349EE8F9-7D25-4909-AAF5-FF3FADE72187}.Release-MT|x64.Build.0 = Release-MT|x64
+		{349EE8FA-7D25-4909-AAF5-FF3FADE72187}.Debug|ARM.ActiveCfg = Debug|ARM
+		{349EE8FA-7D25-4909-AAF5-FF3FADE72187}.Debug|ARM.Build.0 = Debug|ARM
+		{349EE8FA-7D25-4909-AAF5-FF3FADE72187}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{349EE8FA-7D25-4909-AAF5-FF3FADE72187}.Debug|ARM64.Build.0 = Debug|ARM64
+		{349EE8FA-7D25-4909-AAF5-FF3FADE72187}.Debug|Win32.ActiveCfg = Debug|Win32
+		{349EE8FA-7D25-4909-AAF5-FF3FADE72187}.Debug|Win32.Build.0 = Debug|Win32
+		{349EE8FA-7D25-4909-AAF5-FF3FADE72187}.Debug|x64.ActiveCfg = Debug|x64
+		{349EE8FA-7D25-4909-AAF5-FF3FADE72187}.Debug|x64.Build.0 = Debug|x64
+		{349EE8FA-7D25-4909-AAF5-FF3FADE72187}.Debug-MT|ARM.ActiveCfg = Debug-MT|ARM
+		{349EE8FA-7D25-4909-AAF5-FF3FADE72187}.Debug-MT|ARM.Build.0 = Debug-MT|ARM
+		{349EE8FA-7D25-4909-AAF5-FF3FADE72187}.Debug-MT|ARM64.ActiveCfg = Debug-MT|ARM64
+		{349EE8FA-7D25-4909-AAF5-FF3FADE72187}.Debug-MT|ARM64.Build.0 = Debug-MT|ARM64
+		{349EE8FA-7D25-4909-AAF5-FF3FADE72187}.Debug-MT|Win32.ActiveCfg = Debug-MT|Win32
+		{349EE8FA-7D25-4909-AAF5-FF3FADE72187}.Debug-MT|Win32.Build.0 = Debug-MT|Win32
+		{349EE8FA-7D25-4909-AAF5-FF3FADE72187}.Debug-MT|x64.ActiveCfg = Debug-MT|x64
+		{349EE8FA-7D25-4909-AAF5-FF3FADE72187}.Debug-MT|x64.Build.0 = Debug-MT|x64
+		{349EE8FA-7D25-4909-AAF5-FF3FADE72187}.Release|ARM.ActiveCfg = Release|ARM
+		{349EE8FA-7D25-4909-AAF5-FF3FADE72187}.Release|ARM.Build.0 = Release|ARM
+		{349EE8FA-7D25-4909-AAF5-FF3FADE72187}.Release|ARM64.ActiveCfg = Release|ARM64
+		{349EE8FA-7D25-4909-AAF5-FF3FADE72187}.Release|ARM64.Build.0 = Release|ARM64
+		{349EE8FA-7D25-4909-AAF5-FF3FADE72187}.Release|Win32.ActiveCfg = Release|Win32
+		{349EE8FA-7D25-4909-AAF5-FF3FADE72187}.Release|Win32.Build.0 = Release|Win32
+		{349EE8FA-7D25-4909-AAF5-FF3FADE72187}.Release|x64.ActiveCfg = Release|x64
+		{349EE8FA-7D25-4909-AAF5-FF3FADE72187}.Release|x64.Build.0 = Release|x64
+		{349EE8FA-7D25-4909-AAF5-FF3FADE72187}.Release-MT|ARM.ActiveCfg = Release-MT|ARM
+		{349EE8FA-7D25-4909-AAF5-FF3FADE72187}.Release-MT|ARM.Build.0 = Release-MT|ARM
+		{349EE8FA-7D25-4909-AAF5-FF3FADE72187}.Release-MT|ARM64.ActiveCfg = Release-MT|ARM64
+		{349EE8FA-7D25-4909-AAF5-FF3FADE72187}.Release-MT|ARM64.Build.0 = Release-MT|ARM64
+		{349EE8FA-7D25-4909-AAF5-FF3FADE72187}.Release-MT|Win32.ActiveCfg = Release-MT|Win32
+		{349EE8FA-7D25-4909-AAF5-FF3FADE72187}.Release-MT|Win32.Build.0 = Release-MT|Win32
+		{349EE8FA-7D25-4909-AAF5-FF3FADE72187}.Release-MT|x64.ActiveCfg = Release-MT|x64
+		{349EE8FA-7D25-4909-AAF5-FF3FADE72187}.Release-MT|x64.Build.0 = Release-MT|x64
+		{8C7814A1-FD6E-4185-9EA0-8208119756D4}.Debug|ARM.ActiveCfg = Debug|ARM
+		{8C7814A1-FD6E-4185-9EA0-8208119756D4}.Debug|ARM.Build.0 = Debug|ARM
+		{8C7814A1-FD6E-4185-9EA0-8208119756D4}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{8C7814A1-FD6E-4185-9EA0-8208119756D4}.Debug|ARM64.Build.0 = Debug|ARM64
+		{8C7814A1-FD6E-4185-9EA0-8208119756D4}.Debug|Win32.ActiveCfg = Debug|Win32
+		{8C7814A1-FD6E-4185-9EA0-8208119756D4}.Debug|Win32.Build.0 = Debug|Win32
+		{8C7814A1-FD6E-4185-9EA0-8208119756D4}.Debug|x64.ActiveCfg = Debug|x64
+		{8C7814A1-FD6E-4185-9EA0-8208119756D4}.Debug|x64.Build.0 = Debug|x64
+		{8C7814A1-FD6E-4185-9EA0-8208119756D4}.Debug-MT|ARM.ActiveCfg = Debug|ARM
+		{8C7814A1-FD6E-4185-9EA0-8208119756D4}.Debug-MT|ARM.Build.0 = Debug|ARM
+		{8C7814A1-FD6E-4185-9EA0-8208119756D4}.Debug-MT|ARM64.ActiveCfg = Debug|ARM64
+		{8C7814A1-FD6E-4185-9EA0-8208119756D4}.Debug-MT|ARM64.Build.0 = Debug|ARM64
+		{8C7814A1-FD6E-4185-9EA0-8208119756D4}.Debug-MT|Win32.ActiveCfg = Debug|Win32
+		{8C7814A1-FD6E-4185-9EA0-8208119756D4}.Debug-MT|Win32.Build.0 = Debug|Win32
+		{8C7814A1-FD6E-4185-9EA0-8208119756D4}.Debug-MT|x64.ActiveCfg = Debug|x64
+		{8C7814A1-FD6E-4185-9EA0-8208119756D4}.Debug-MT|x64.Build.0 = Debug|x64
+		{8C7814A1-FD6E-4185-9EA0-8208119756D4}.Release|ARM.ActiveCfg = Release|ARM
+		{8C7814A1-FD6E-4185-9EA0-8208119756D4}.Release|ARM.Build.0 = Release|ARM
+		{8C7814A1-FD6E-4185-9EA0-8208119756D4}.Release|ARM64.ActiveCfg = Release|ARM64
+		{8C7814A1-FD6E-4185-9EA0-8208119756D4}.Release|ARM64.Build.0 = Release|ARM64
+		{8C7814A1-FD6E-4185-9EA0-8208119756D4}.Release|Win32.ActiveCfg = Release|Win32
+		{8C7814A1-FD6E-4185-9EA0-8208119756D4}.Release|Win32.Build.0 = Release|Win32
+		{8C7814A1-FD6E-4185-9EA0-8208119756D4}.Release|x64.ActiveCfg = Release|x64
+		{8C7814A1-FD6E-4185-9EA0-8208119756D4}.Release|x64.Build.0 = Release|x64
+		{8C7814A1-FD6E-4185-9EA0-8208119756D4}.Release-MT|ARM.ActiveCfg = Release|ARM
+		{8C7814A1-FD6E-4185-9EA0-8208119756D4}.Release-MT|ARM.Build.0 = Release|ARM
+		{8C7814A1-FD6E-4185-9EA0-8208119756D4}.Release-MT|ARM64.ActiveCfg = Release|ARM64
+		{8C7814A1-FD6E-4185-9EA0-8208119756D4}.Release-MT|ARM64.Build.0 = Release|ARM64
+		{8C7814A1-FD6E-4185-9EA0-8208119756D4}.Release-MT|Win32.ActiveCfg = Release|Win32
+		{8C7814A1-FD6E-4185-9EA0-8208119756D4}.Release-MT|Win32.Build.0 = Release|Win32
+		{8C7814A1-FD6E-4185-9EA0-8208119756D4}.Release-MT|x64.ActiveCfg = Release|x64
+		{8C7814A1-FD6E-4185-9EA0-8208119756D4}.Release-MT|x64.Build.0 = Release|x64
+		{8C7814A2-FD6E-4185-9EA0-8208119756D4}.Debug|ARM.ActiveCfg = Debug|ARM
+		{8C7814A2-FD6E-4185-9EA0-8208119756D4}.Debug|ARM.Build.0 = Debug|ARM
+		{8C7814A2-FD6E-4185-9EA0-8208119756D4}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{8C7814A2-FD6E-4185-9EA0-8208119756D4}.Debug|ARM64.Build.0 = Debug|ARM64
+		{8C7814A2-FD6E-4185-9EA0-8208119756D4}.Debug|Win32.ActiveCfg = Debug|Win32
+		{8C7814A2-FD6E-4185-9EA0-8208119756D4}.Debug|Win32.Build.0 = Debug|Win32
+		{8C7814A2-FD6E-4185-9EA0-8208119756D4}.Debug|x64.ActiveCfg = Debug|x64
+		{8C7814A2-FD6E-4185-9EA0-8208119756D4}.Debug|x64.Build.0 = Debug|x64
+		{8C7814A2-FD6E-4185-9EA0-8208119756D4}.Debug-MT|ARM.ActiveCfg = Debug|ARM
+		{8C7814A2-FD6E-4185-9EA0-8208119756D4}.Debug-MT|ARM.Build.0 = Debug|ARM
+		{8C7814A2-FD6E-4185-9EA0-8208119756D4}.Debug-MT|ARM64.ActiveCfg = Debug|ARM64
+		{8C7814A2-FD6E-4185-9EA0-8208119756D4}.Debug-MT|ARM64.Build.0 = Debug|ARM64
+		{8C7814A2-FD6E-4185-9EA0-8208119756D4}.Debug-MT|Win32.ActiveCfg = Debug|Win32
+		{8C7814A2-FD6E-4185-9EA0-8208119756D4}.Debug-MT|Win32.Build.0 = Debug|Win32
+		{8C7814A2-FD6E-4185-9EA0-8208119756D4}.Debug-MT|x64.ActiveCfg = Debug|x64
+		{8C7814A2-FD6E-4185-9EA0-8208119756D4}.Debug-MT|x64.Build.0 = Debug|x64
+		{8C7814A2-FD6E-4185-9EA0-8208119756D4}.Release|ARM.ActiveCfg = Release|ARM
+		{8C7814A2-FD6E-4185-9EA0-8208119756D4}.Release|ARM.Build.0 = Release|ARM
+		{8C7814A2-FD6E-4185-9EA0-8208119756D4}.Release|ARM64.ActiveCfg = Release|ARM64
+		{8C7814A2-FD6E-4185-9EA0-8208119756D4}.Release|ARM64.Build.0 = Release|ARM64
+		{8C7814A2-FD6E-4185-9EA0-8208119756D4}.Release|Win32.ActiveCfg = Release|Win32
+		{8C7814A2-FD6E-4185-9EA0-8208119756D4}.Release|Win32.Build.0 = Release|Win32
+		{8C7814A2-FD6E-4185-9EA0-8208119756D4}.Release|x64.ActiveCfg = Release|x64
+		{8C7814A2-FD6E-4185-9EA0-8208119756D4}.Release|x64.Build.0 = Release|x64
+		{8C7814A2-FD6E-4185-9EA0-8208119756D4}.Release-MT|ARM.ActiveCfg = Release|ARM
+		{8C7814A2-FD6E-4185-9EA0-8208119756D4}.Release-MT|ARM.Build.0 = Release|ARM
+		{8C7814A2-FD6E-4185-9EA0-8208119756D4}.Release-MT|ARM64.ActiveCfg = Release|ARM64
+		{8C7814A2-FD6E-4185-9EA0-8208119756D4}.Release-MT|ARM64.Build.0 = Release|ARM64
+		{8C7814A2-FD6E-4185-9EA0-8208119756D4}.Release-MT|Win32.ActiveCfg = Release|Win32
+		{8C7814A2-FD6E-4185-9EA0-8208119756D4}.Release-MT|Win32.Build.0 = Release|Win32
+		{8C7814A2-FD6E-4185-9EA0-8208119756D4}.Release-MT|x64.ActiveCfg = Release|x64
+		{8C7814A2-FD6E-4185-9EA0-8208119756D4}.Release-MT|x64.Build.0 = Release|x64
+		{9E166F7A-A793-9FB6-0A67-F0AED8AE8C88}.Debug|ARM.ActiveCfg = Debug|ARM
+		{9E166F7A-A793-9FB6-0A67-F0AED8AE8C88}.Debug|ARM.Build.0 = Debug|ARM
+		{9E166F7A-A793-9FB6-0A67-F0AED8AE8C88}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{9E166F7A-A793-9FB6-0A67-F0AED8AE8C88}.Debug|ARM64.Build.0 = Debug|ARM64
+		{9E166F7A-A793-9FB6-0A67-F0AED8AE8C88}.Debug|Win32.ActiveCfg = Debug|Win32
+		{9E166F7A-A793-9FB6-0A67-F0AED8AE8C88}.Debug|Win32.Build.0 = Debug|Win32
+		{9E166F7A-A793-9FB6-0A67-F0AED8AE8C88}.Debug|x64.ActiveCfg = Debug|x64
+		{9E166F7A-A793-9FB6-0A67-F0AED8AE8C88}.Debug|x64.Build.0 = Debug|x64
+		{9E166F7A-A793-9FB6-0A67-F0AED8AE8C88}.Debug-MT|ARM.ActiveCfg = Debug|ARM
+		{9E166F7A-A793-9FB6-0A67-F0AED8AE8C88}.Debug-MT|ARM.Build.0 = Debug|ARM
+		{9E166F7A-A793-9FB6-0A67-F0AED8AE8C88}.Debug-MT|ARM64.ActiveCfg = Debug|ARM64
+		{9E166F7A-A793-9FB6-0A67-F0AED8AE8C88}.Debug-MT|ARM64.Build.0 = Debug|ARM64
+		{9E166F7A-A793-9FB6-0A67-F0AED8AE8C88}.Debug-MT|Win32.ActiveCfg = Debug|Win32
+		{9E166F7A-A793-9FB6-0A67-F0AED8AE8C88}.Debug-MT|Win32.Build.0 = Debug|Win32
+		{9E166F7A-A793-9FB6-0A67-F0AED8AE8C88}.Debug-MT|x64.ActiveCfg = Debug|x64
+		{9E166F7A-A793-9FB6-0A67-F0AED8AE8C88}.Debug-MT|x64.Build.0 = Debug|x64
+		{9E166F7A-A793-9FB6-0A67-F0AED8AE8C88}.Release|ARM.ActiveCfg = Release|ARM
+		{9E166F7A-A793-9FB6-0A67-F0AED8AE8C88}.Release|ARM.Build.0 = Release|ARM
+		{9E166F7A-A793-9FB6-0A67-F0AED8AE8C88}.Release|ARM64.ActiveCfg = Release|ARM64
+		{9E166F7A-A793-9FB6-0A67-F0AED8AE8C88}.Release|ARM64.Build.0 = Release|ARM64
+		{9E166F7A-A793-9FB6-0A67-F0AED8AE8C88}.Release|Win32.ActiveCfg = Release|Win32
+		{9E166F7A-A793-9FB6-0A67-F0AED8AE8C88}.Release|Win32.Build.0 = Release|Win32
+		{9E166F7A-A793-9FB6-0A67-F0AED8AE8C88}.Release|x64.ActiveCfg = Release|x64
+		{9E166F7A-A793-9FB6-0A67-F0AED8AE8C88}.Release|x64.Build.0 = Release|x64
+		{9E166F7A-A793-9FB6-0A67-F0AED8AE8C88}.Release-MT|ARM.ActiveCfg = Release|ARM
+		{9E166F7A-A793-9FB6-0A67-F0AED8AE8C88}.Release-MT|ARM.Build.0 = Release|ARM
+		{9E166F7A-A793-9FB6-0A67-F0AED8AE8C88}.Release-MT|ARM64.ActiveCfg = Release|ARM64
+		{9E166F7A-A793-9FB6-0A67-F0AED8AE8C88}.Release-MT|ARM64.Build.0 = Release|ARM64
+		{9E166F7A-A793-9FB6-0A67-F0AED8AE8C88}.Release-MT|Win32.ActiveCfg = Release|Win32
+		{9E166F7A-A793-9FB6-0A67-F0AED8AE8C88}.Release-MT|Win32.Build.0 = Release|Win32
+		{9E166F7A-A793-9FB6-0A67-F0AED8AE8C88}.Release-MT|x64.ActiveCfg = Release|x64
+		{9E166F7A-A793-9FB6-0A67-F0AED8AE8C88}.Release-MT|x64.Build.0 = Release|x64
+		{AE83E1B4-CE06-47EE-B7A3-C3A1D7C2D71E}.Debug|ARM.ActiveCfg = Debug|ARM
+		{AE83E1B4-CE06-47EE-B7A3-C3A1D7C2D71E}.Debug|ARM.Build.0 = Debug|ARM
+		{AE83E1B4-CE06-47EE-B7A3-C3A1D7C2D71E}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{AE83E1B4-CE06-47EE-B7A3-C3A1D7C2D71E}.Debug|ARM64.Build.0 = Debug|ARM64
+		{AE83E1B4-CE06-47EE-B7A3-C3A1D7C2D71E}.Debug|Win32.ActiveCfg = Debug|Win32
+		{AE83E1B4-CE06-47EE-B7A3-C3A1D7C2D71E}.Debug|Win32.Build.0 = Debug|Win32
+		{AE83E1B4-CE06-47EE-B7A3-C3A1D7C2D71E}.Debug|x64.ActiveCfg = Debug|x64
+		{AE83E1B4-CE06-47EE-B7A3-C3A1D7C2D71E}.Debug|x64.Build.0 = Debug|x64
+		{AE83E1B4-CE06-47EE-B7A3-C3A1D7C2D71E}.Debug-MT|ARM.ActiveCfg = Debug|ARM
+		{AE83E1B4-CE06-47EE-B7A3-C3A1D7C2D71E}.Debug-MT|ARM.Build.0 = Debug|ARM
+		{AE83E1B4-CE06-47EE-B7A3-C3A1D7C2D71E}.Debug-MT|ARM64.ActiveCfg = Debug|ARM64
+		{AE83E1B4-CE06-47EE-B7A3-C3A1D7C2D71E}.Debug-MT|ARM64.Build.0 = Debug|ARM64
+		{AE83E1B4-CE06-47EE-B7A3-C3A1D7C2D71E}.Debug-MT|Win32.ActiveCfg = Debug|Win32
+		{AE83E1B4-CE06-47EE-B7A3-C3A1D7C2D71E}.Debug-MT|Win32.Build.0 = Debug|Win32
+		{AE83E1B4-CE06-47EE-B7A3-C3A1D7C2D71E}.Debug-MT|x64.ActiveCfg = Debug|x64
+		{AE83E1B4-CE06-47EE-B7A3-C3A1D7C2D71E}.Debug-MT|x64.Build.0 = Debug|x64
+		{AE83E1B4-CE06-47EE-B7A3-C3A1D7C2D71E}.Release|ARM.ActiveCfg = Release|ARM
+		{AE83E1B4-CE06-47EE-B7A3-C3A1D7C2D71E}.Release|ARM.Build.0 = Release|ARM
+		{AE83E1B4-CE06-47EE-B7A3-C3A1D7C2D71E}.Release|ARM64.ActiveCfg = Release|ARM64
+		{AE83E1B4-CE06-47EE-B7A3-C3A1D7C2D71E}.Release|ARM64.Build.0 = Release|ARM64
+		{AE83E1B4-CE06-47EE-B7A3-C3A1D7C2D71E}.Release|Win32.ActiveCfg = Release|Win32
+		{AE83E1B4-CE06-47EE-B7A3-C3A1D7C2D71E}.Release|Win32.Build.0 = Release|Win32
+		{AE83E1B4-CE06-47EE-B7A3-C3A1D7C2D71E}.Release|x64.ActiveCfg = Release|x64
+		{AE83E1B4-CE06-47EE-B7A3-C3A1D7C2D71E}.Release|x64.Build.0 = Release|x64
+		{AE83E1B4-CE06-47EE-B7A3-C3A1D7C2D71E}.Release-MT|ARM.ActiveCfg = Release|ARM
+		{AE83E1B4-CE06-47EE-B7A3-C3A1D7C2D71E}.Release-MT|ARM.Build.0 = Release|ARM
+		{AE83E1B4-CE06-47EE-B7A3-C3A1D7C2D71E}.Release-MT|ARM64.ActiveCfg = Release|ARM64
+		{AE83E1B4-CE06-47EE-B7A3-C3A1D7C2D71E}.Release-MT|ARM64.Build.0 = Release|ARM64
+		{AE83E1B4-CE06-47EE-B7A3-C3A1D7C2D71E}.Release-MT|Win32.ActiveCfg = Release|Win32
+		{AE83E1B4-CE06-47EE-B7A3-C3A1D7C2D71E}.Release-MT|Win32.Build.0 = Release|Win32
+		{AE83E1B4-CE06-47EE-B7A3-C3A1D7C2D71E}.Release-MT|x64.ActiveCfg = Release|x64
+		{AE83E1B4-CE06-47EE-B7A3-C3A1D7C2D71E}.Release-MT|x64.Build.0 = Release|x64
+		{99D2AC64-DC66-4422-91CE-6715C403C9E5}.Debug|ARM.ActiveCfg = Debug|ARM
+		{99D2AC64-DC66-4422-91CE-6715C403C9E5}.Debug|ARM.Build.0 = Debug|ARM
+		{99D2AC64-DC66-4422-91CE-6715C403C9E5}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{99D2AC64-DC66-4422-91CE-6715C403C9E5}.Debug|ARM64.Build.0 = Debug|ARM64
+		{99D2AC64-DC66-4422-91CE-6715C403C9E5}.Debug|Win32.ActiveCfg = Debug|Win32
+		{99D2AC64-DC66-4422-91CE-6715C403C9E5}.Debug|Win32.Build.0 = Debug|Win32
+		{99D2AC64-DC66-4422-91CE-6715C403C9E5}.Debug|x64.ActiveCfg = Debug|x64
+		{99D2AC64-DC66-4422-91CE-6715C403C9E5}.Debug|x64.Build.0 = Debug|x64
+		{99D2AC64-DC66-4422-91CE-6715C403C9E5}.Debug-MT|ARM.ActiveCfg = Debug|ARM
+		{99D2AC64-DC66-4422-91CE-6715C403C9E5}.Debug-MT|ARM.Build.0 = Debug|ARM
+		{99D2AC64-DC66-4422-91CE-6715C403C9E5}.Debug-MT|ARM64.ActiveCfg = Debug|ARM64
+		{99D2AC64-DC66-4422-91CE-6715C403C9E5}.Debug-MT|ARM64.Build.0 = Debug|ARM64
+		{99D2AC64-DC66-4422-91CE-6715C403C9E5}.Debug-MT|Win32.ActiveCfg = Debug|Win32
+		{99D2AC64-DC66-4422-91CE-6715C403C9E5}.Debug-MT|Win32.Build.0 = Debug|Win32
+		{99D2AC64-DC66-4422-91CE-6715C403C9E5}.Debug-MT|x64.ActiveCfg = Debug|x64
+		{99D2AC64-DC66-4422-91CE-6715C403C9E5}.Debug-MT|x64.Build.0 = Debug|x64
+		{99D2AC64-DC66-4422-91CE-6715C403C9E5}.Release|ARM.ActiveCfg = Release|ARM
+		{99D2AC64-DC66-4422-91CE-6715C403C9E5}.Release|ARM.Build.0 = Release|ARM
+		{99D2AC64-DC66-4422-91CE-6715C403C9E5}.Release|ARM64.ActiveCfg = Release|ARM64
+		{99D2AC64-DC66-4422-91CE-6715C403C9E5}.Release|ARM64.Build.0 = Release|ARM64
+		{99D2AC64-DC66-4422-91CE-6715C403C9E5}.Release|Win32.ActiveCfg = Release|Win32
+		{99D2AC64-DC66-4422-91CE-6715C403C9E5}.Release|Win32.Build.0 = Release|Win32
+		{99D2AC64-DC66-4422-91CE-6715C403C9E5}.Release|x64.ActiveCfg = Release|x64
+		{99D2AC64-DC66-4422-91CE-6715C403C9E5}.Release|x64.Build.0 = Release|x64
+		{99D2AC64-DC66-4422-91CE-6715C403C9E5}.Release-MT|ARM.ActiveCfg = Release|ARM
+		{99D2AC64-DC66-4422-91CE-6715C403C9E5}.Release-MT|ARM.Build.0 = Release|ARM
+		{99D2AC64-DC66-4422-91CE-6715C403C9E5}.Release-MT|ARM64.ActiveCfg = Release|ARM64
+		{99D2AC64-DC66-4422-91CE-6715C403C9E5}.Release-MT|ARM64.Build.0 = Release|ARM64
+		{99D2AC64-DC66-4422-91CE-6715C403C9E5}.Release-MT|Win32.ActiveCfg = Release|Win32
+		{99D2AC64-DC66-4422-91CE-6715C403C9E5}.Release-MT|Win32.Build.0 = Release|Win32
+		{99D2AC64-DC66-4422-91CE-6715C403C9E5}.Release-MT|x64.ActiveCfg = Release|x64
+		{99D2AC64-DC66-4422-91CE-6715C403C9E5}.Release-MT|x64.Build.0 = Release|x64
+		{F4938DB0-3DE7-4737-9C5A-EAD1BE819F87}.Debug|ARM.ActiveCfg = Debug|ARM
+		{F4938DB0-3DE7-4737-9C5A-EAD1BE819F87}.Debug|ARM.Build.0 = Debug|ARM
+		{F4938DB0-3DE7-4737-9C5A-EAD1BE819F87}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{F4938DB0-3DE7-4737-9C5A-EAD1BE819F87}.Debug|ARM64.Build.0 = Debug|ARM64
+		{F4938DB0-3DE7-4737-9C5A-EAD1BE819F87}.Debug|Win32.ActiveCfg = Debug|Win32
+		{F4938DB0-3DE7-4737-9C5A-EAD1BE819F87}.Debug|Win32.Build.0 = Debug|Win32
+		{F4938DB0-3DE7-4737-9C5A-EAD1BE819F87}.Debug|x64.ActiveCfg = Debug|x64
+		{F4938DB0-3DE7-4737-9C5A-EAD1BE819F87}.Debug|x64.Build.0 = Debug|x64
+		{F4938DB0-3DE7-4737-9C5A-EAD1BE819F87}.Debug-MT|ARM.ActiveCfg = Debug|ARM
+		{F4938DB0-3DE7-4737-9C5A-EAD1BE819F87}.Debug-MT|ARM.Build.0 = Debug|ARM
+		{F4938DB0-3DE7-4737-9C5A-EAD1BE819F87}.Debug-MT|ARM64.ActiveCfg = Debug|ARM64
+		{F4938DB0-3DE7-4737-9C5A-EAD1BE819F87}.Debug-MT|ARM64.Build.0 = Debug|ARM64
+		{F4938DB0-3DE7-4737-9C5A-EAD1BE819F87}.Debug-MT|Win32.ActiveCfg = Debug|Win32
+		{F4938DB0-3DE7-4737-9C5A-EAD1BE819F87}.Debug-MT|Win32.Build.0 = Debug|Win32
+		{F4938DB0-3DE7-4737-9C5A-EAD1BE819F87}.Debug-MT|x64.ActiveCfg = Debug|x64
+		{F4938DB0-3DE7-4737-9C5A-EAD1BE819F87}.Debug-MT|x64.Build.0 = Debug|x64
+		{F4938DB0-3DE7-4737-9C5A-EAD1BE819F87}.Release|ARM.ActiveCfg = Release|ARM
+		{F4938DB0-3DE7-4737-9C5A-EAD1BE819F87}.Release|ARM.Build.0 = Release|ARM
+		{F4938DB0-3DE7-4737-9C5A-EAD1BE819F87}.Release|ARM64.ActiveCfg = Release|ARM64
+		{F4938DB0-3DE7-4737-9C5A-EAD1BE819F87}.Release|ARM64.Build.0 = Release|ARM64
+		{F4938DB0-3DE7-4737-9C5A-EAD1BE819F87}.Release|Win32.ActiveCfg = Release|Win32
+		{F4938DB0-3DE7-4737-9C5A-EAD1BE819F87}.Release|Win32.Build.0 = Release|Win32
+		{F4938DB0-3DE7-4737-9C5A-EAD1BE819F87}.Release|x64.ActiveCfg = Release|x64
+		{F4938DB0-3DE7-4737-9C5A-EAD1BE819F87}.Release|x64.Build.0 = Release|x64
+		{F4938DB0-3DE7-4737-9C5A-EAD1BE819F87}.Release-MT|ARM.ActiveCfg = Release|ARM
+		{F4938DB0-3DE7-4737-9C5A-EAD1BE819F87}.Release-MT|ARM.Build.0 = Release|ARM
+		{F4938DB0-3DE7-4737-9C5A-EAD1BE819F87}.Release-MT|ARM64.ActiveCfg = Release|ARM64
+		{F4938DB0-3DE7-4737-9C5A-EAD1BE819F87}.Release-MT|ARM64.Build.0 = Release|ARM64
+		{F4938DB0-3DE7-4737-9C5A-EAD1BE819F87}.Release-MT|Win32.ActiveCfg = Release|Win32
+		{F4938DB0-3DE7-4737-9C5A-EAD1BE819F87}.Release-MT|Win32.Build.0 = Release|Win32
+		{F4938DB0-3DE7-4737-9C5A-EAD1BE819F87}.Release-MT|x64.ActiveCfg = Release|x64
+		{F4938DB0-3DE7-4737-9C5A-EAD1BE819F87}.Release-MT|x64.Build.0 = Release|x64
+		{861CDD5F-59A2-4F34-957E-5C1AF98BE0A4}.Debug|ARM.ActiveCfg = Debug|ARM
+		{861CDD5F-59A2-4F34-957E-5C1AF98BE0A4}.Debug|ARM.Build.0 = Debug|ARM
+		{861CDD5F-59A2-4F34-957E-5C1AF98BE0A4}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{861CDD5F-59A2-4F34-957E-5C1AF98BE0A4}.Debug|ARM64.Build.0 = Debug|ARM64
+		{861CDD5F-59A2-4F34-957E-5C1AF98BE0A4}.Debug|Win32.ActiveCfg = Debug|Win32
+		{861CDD5F-59A2-4F34-957E-5C1AF98BE0A4}.Debug|Win32.Build.0 = Debug|Win32
+		{861CDD5F-59A2-4F34-957E-5C1AF98BE0A4}.Debug|x64.ActiveCfg = Debug|x64
+		{861CDD5F-59A2-4F34-957E-5C1AF98BE0A4}.Debug|x64.Build.0 = Debug|x64
+		{861CDD5F-59A2-4F34-957E-5C1AF98BE0A4}.Debug-MT|ARM.ActiveCfg = Debug|ARM
+		{861CDD5F-59A2-4F34-957E-5C1AF98BE0A4}.Debug-MT|ARM.Build.0 = Debug|ARM
+		{861CDD5F-59A2-4F34-957E-5C1AF98BE0A4}.Debug-MT|ARM64.ActiveCfg = Debug|ARM64
+		{861CDD5F-59A2-4F34-957E-5C1AF98BE0A4}.Debug-MT|ARM64.Build.0 = Debug|ARM64
+		{861CDD5F-59A2-4F34-957E-5C1AF98BE0A4}.Debug-MT|Win32.ActiveCfg = Debug|Win32
+		{861CDD5F-59A2-4F34-957E-5C1AF98BE0A4}.Debug-MT|Win32.Build.0 = Debug|Win32
+		{861CDD5F-59A2-4F34-957E-5C1AF98BE0A4}.Debug-MT|x64.ActiveCfg = Debug|x64
+		{861CDD5F-59A2-4F34-957E-5C1AF98BE0A4}.Debug-MT|x64.Build.0 = Debug|x64
+		{861CDD5F-59A2-4F34-957E-5C1AF98BE0A4}.Release|ARM.ActiveCfg = Release|ARM
+		{861CDD5F-59A2-4F34-957E-5C1AF98BE0A4}.Release|ARM.Build.0 = Release|ARM
+		{861CDD5F-59A2-4F34-957E-5C1AF98BE0A4}.Release|ARM64.ActiveCfg = Release|ARM64
+		{861CDD5F-59A2-4F34-957E-5C1AF98BE0A4}.Release|ARM64.Build.0 = Release|ARM64
+		{861CDD5F-59A2-4F34-957E-5C1AF98BE0A4}.Release|Win32.ActiveCfg = Release|Win32
+		{861CDD5F-59A2-4F34-957E-5C1AF98BE0A4}.Release|Win32.Build.0 = Release|Win32
+		{861CDD5F-59A2-4F34-957E-5C1AF98BE0A4}.Release|x64.ActiveCfg = Release|x64
+		{861CDD5F-59A2-4F34-957E-5C1AF98BE0A4}.Release|x64.Build.0 = Release|x64
+		{861CDD5F-59A2-4F34-957E-5C1AF98BE0A4}.Release-MT|ARM.ActiveCfg = Release|ARM
+		{861CDD5F-59A2-4F34-957E-5C1AF98BE0A4}.Release-MT|ARM.Build.0 = Release|ARM
+		{861CDD5F-59A2-4F34-957E-5C1AF98BE0A4}.Release-MT|ARM64.ActiveCfg = Release|ARM64
+		{861CDD5F-59A2-4F34-957E-5C1AF98BE0A4}.Release-MT|ARM64.Build.0 = Release|ARM64
+		{861CDD5F-59A2-4F34-957E-5C1AF98BE0A4}.Release-MT|Win32.ActiveCfg = Release|Win32
+		{861CDD5F-59A2-4F34-957E-5C1AF98BE0A4}.Release-MT|Win32.Build.0 = Release|Win32
+		{861CDD5F-59A2-4F34-957E-5C1AF98BE0A4}.Release-MT|x64.ActiveCfg = Release|x64
+		{861CDD5F-59A2-4F34-957E-5C1AF98BE0A4}.Release-MT|x64.Build.0 = Release|x64
+		{53942EFF-C810-458D-B3CB-EE5CE9F1E781}.Debug|ARM.ActiveCfg = Debug|ARM
+		{53942EFF-C810-458D-B3CB-EE5CE9F1E781}.Debug|ARM.Build.0 = Debug|ARM
+		{53942EFF-C810-458D-B3CB-EE5CE9F1E781}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{53942EFF-C810-458D-B3CB-EE5CE9F1E781}.Debug|ARM64.Build.0 = Debug|ARM64
+		{53942EFF-C810-458D-B3CB-EE5CE9F1E781}.Debug|Win32.ActiveCfg = Debug|Win32
+		{53942EFF-C810-458D-B3CB-EE5CE9F1E781}.Debug|Win32.Build.0 = Debug|Win32
+		{53942EFF-C810-458D-B3CB-EE5CE9F1E781}.Debug|x64.ActiveCfg = Debug|x64
+		{53942EFF-C810-458D-B3CB-EE5CE9F1E781}.Debug|x64.Build.0 = Debug|x64
+		{53942EFF-C810-458D-B3CB-EE5CE9F1E781}.Debug-MT|ARM.ActiveCfg = Debug|ARM
+		{53942EFF-C810-458D-B3CB-EE5CE9F1E781}.Debug-MT|ARM.Build.0 = Debug|ARM
+		{53942EFF-C810-458D-B3CB-EE5CE9F1E781}.Debug-MT|ARM64.ActiveCfg = Debug|ARM64
+		{53942EFF-C810-458D-B3CB-EE5CE9F1E781}.Debug-MT|ARM64.Build.0 = Debug|ARM64
+		{53942EFF-C810-458D-B3CB-EE5CE9F1E781}.Debug-MT|Win32.ActiveCfg = Debug|Win32
+		{53942EFF-C810-458D-B3CB-EE5CE9F1E781}.Debug-MT|Win32.Build.0 = Debug|Win32
+		{53942EFF-C810-458D-B3CB-EE5CE9F1E781}.Debug-MT|x64.ActiveCfg = Debug|x64
+		{53942EFF-C810-458D-B3CB-EE5CE9F1E781}.Debug-MT|x64.Build.0 = Debug|x64
+		{53942EFF-C810-458D-B3CB-EE5CE9F1E781}.Release|ARM.ActiveCfg = Release|ARM
+		{53942EFF-C810-458D-B3CB-EE5CE9F1E781}.Release|ARM.Build.0 = Release|ARM
+		{53942EFF-C810-458D-B3CB-EE5CE9F1E781}.Release|ARM64.ActiveCfg = Release|ARM64
+		{53942EFF-C810-458D-B3CB-EE5CE9F1E781}.Release|ARM64.Build.0 = Release|ARM64
+		{53942EFF-C810-458D-B3CB-EE5CE9F1E781}.Release|Win32.ActiveCfg = Release|Win32
+		{53942EFF-C810-458D-B3CB-EE5CE9F1E781}.Release|Win32.Build.0 = Release|Win32
+		{53942EFF-C810-458D-B3CB-EE5CE9F1E781}.Release|x64.ActiveCfg = Release|x64
+		{53942EFF-C810-458D-B3CB-EE5CE9F1E781}.Release|x64.Build.0 = Release|x64
+		{53942EFF-C810-458D-B3CB-EE5CE9F1E781}.Release-MT|ARM.ActiveCfg = Release|ARM
+		{53942EFF-C810-458D-B3CB-EE5CE9F1E781}.Release-MT|ARM.Build.0 = Release|ARM
+		{53942EFF-C810-458D-B3CB-EE5CE9F1E781}.Release-MT|ARM64.ActiveCfg = Release|ARM64
+		{53942EFF-C810-458D-B3CB-EE5CE9F1E781}.Release-MT|ARM64.Build.0 = Release|ARM64
+		{53942EFF-C810-458D-B3CB-EE5CE9F1E781}.Release-MT|Win32.ActiveCfg = Release|Win32
+		{53942EFF-C810-458D-B3CB-EE5CE9F1E781}.Release-MT|Win32.Build.0 = Release|Win32
+		{53942EFF-C810-458D-B3CB-EE5CE9F1E781}.Release-MT|x64.ActiveCfg = Release|x64
+		{53942EFF-C810-458D-B3CB-EE5CE9F1E781}.Release-MT|x64.Build.0 = Release|x64
+		{9EAF1311-2BBB-4177-882B-DA7FA0AD7912}.Debug|ARM.ActiveCfg = Debug|ARM
+		{9EAF1311-2BBB-4177-882B-DA7FA0AD7912}.Debug|ARM.Build.0 = Debug|ARM
+		{9EAF1311-2BBB-4177-882B-DA7FA0AD7912}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{9EAF1311-2BBB-4177-882B-DA7FA0AD7912}.Debug|ARM64.Build.0 = Debug|ARM64
+		{9EAF1311-2BBB-4177-882B-DA7FA0AD7912}.Debug|Win32.ActiveCfg = Debug|Win32
+		{9EAF1311-2BBB-4177-882B-DA7FA0AD7912}.Debug|Win32.Build.0 = Debug|Win32
+		{9EAF1311-2BBB-4177-882B-DA7FA0AD7912}.Debug|x64.ActiveCfg = Debug|x64
+		{9EAF1311-2BBB-4177-882B-DA7FA0AD7912}.Debug|x64.Build.0 = Debug|x64
+		{9EAF1311-2BBB-4177-882B-DA7FA0AD7912}.Debug-MT|ARM.ActiveCfg = Debug|ARM
+		{9EAF1311-2BBB-4177-882B-DA7FA0AD7912}.Debug-MT|ARM.Build.0 = Debug|ARM
+		{9EAF1311-2BBB-4177-882B-DA7FA0AD7912}.Debug-MT|ARM64.ActiveCfg = Debug|ARM64
+		{9EAF1311-2BBB-4177-882B-DA7FA0AD7912}.Debug-MT|ARM64.Build.0 = Debug|ARM64
+		{9EAF1311-2BBB-4177-882B-DA7FA0AD7912}.Debug-MT|Win32.ActiveCfg = Debug|Win32
+		{9EAF1311-2BBB-4177-882B-DA7FA0AD7912}.Debug-MT|Win32.Build.0 = Debug|Win32
+		{9EAF1311-2BBB-4177-882B-DA7FA0AD7912}.Debug-MT|x64.ActiveCfg = Debug|x64
+		{9EAF1311-2BBB-4177-882B-DA7FA0AD7912}.Debug-MT|x64.Build.0 = Debug|x64
+		{9EAF1311-2BBB-4177-882B-DA7FA0AD7912}.Release|ARM.ActiveCfg = Release|ARM
+		{9EAF1311-2BBB-4177-882B-DA7FA0AD7912}.Release|ARM.Build.0 = Release|ARM
+		{9EAF1311-2BBB-4177-882B-DA7FA0AD7912}.Release|ARM64.ActiveCfg = Release|ARM64
+		{9EAF1311-2BBB-4177-882B-DA7FA0AD7912}.Release|ARM64.Build.0 = Release|ARM64
+		{9EAF1311-2BBB-4177-882B-DA7FA0AD7912}.Release|Win32.ActiveCfg = Release|Win32
+		{9EAF1311-2BBB-4177-882B-DA7FA0AD7912}.Release|Win32.Build.0 = Release|Win32
+		{9EAF1311-2BBB-4177-882B-DA7FA0AD7912}.Release|x64.ActiveCfg = Release|x64
+		{9EAF1311-2BBB-4177-882B-DA7FA0AD7912}.Release|x64.Build.0 = Release|x64
+		{9EAF1311-2BBB-4177-882B-DA7FA0AD7912}.Release-MT|ARM.ActiveCfg = Release|ARM
+		{9EAF1311-2BBB-4177-882B-DA7FA0AD7912}.Release-MT|ARM.Build.0 = Release|ARM
+		{9EAF1311-2BBB-4177-882B-DA7FA0AD7912}.Release-MT|ARM64.ActiveCfg = Release|ARM64
+		{9EAF1311-2BBB-4177-882B-DA7FA0AD7912}.Release-MT|ARM64.Build.0 = Release|ARM64
+		{9EAF1311-2BBB-4177-882B-DA7FA0AD7912}.Release-MT|Win32.ActiveCfg = Release|Win32
+		{9EAF1311-2BBB-4177-882B-DA7FA0AD7912}.Release-MT|Win32.Build.0 = Release|Win32
+		{9EAF1311-2BBB-4177-882B-DA7FA0AD7912}.Release-MT|x64.ActiveCfg = Release|x64
+		{9EAF1311-2BBB-4177-882B-DA7FA0AD7912}.Release-MT|x64.Build.0 = Release|x64
+		{70828935-325B-4749-B381-0E55EF31AEE8}.Debug|ARM.ActiveCfg = Debug|ARM
+		{70828935-325B-4749-B381-0E55EF31AEE8}.Debug|ARM.Build.0 = Debug|ARM
+		{70828935-325B-4749-B381-0E55EF31AEE8}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{70828935-325B-4749-B381-0E55EF31AEE8}.Debug|ARM64.Build.0 = Debug|ARM64
+		{70828935-325B-4749-B381-0E55EF31AEE8}.Debug|Win32.ActiveCfg = Debug|Win32
+		{70828935-325B-4749-B381-0E55EF31AEE8}.Debug|Win32.Build.0 = Debug|Win32
+		{70828935-325B-4749-B381-0E55EF31AEE8}.Debug|x64.ActiveCfg = Debug|x64
+		{70828935-325B-4749-B381-0E55EF31AEE8}.Debug|x64.Build.0 = Debug|x64
+		{70828935-325B-4749-B381-0E55EF31AEE8}.Debug-MT|ARM.ActiveCfg = Debug|ARM
+		{70828935-325B-4749-B381-0E55EF31AEE8}.Debug-MT|ARM.Build.0 = Debug|ARM
+		{70828935-325B-4749-B381-0E55EF31AEE8}.Debug-MT|ARM64.ActiveCfg = Debug|ARM64
+		{70828935-325B-4749-B381-0E55EF31AEE8}.Debug-MT|ARM64.Build.0 = Debug|ARM64
+		{70828935-325B-4749-B381-0E55EF31AEE8}.Debug-MT|Win32.ActiveCfg = Debug|Win32
+		{70828935-325B-4749-B381-0E55EF31AEE8}.Debug-MT|Win32.Build.0 = Debug|Win32
+		{70828935-325B-4749-B381-0E55EF31AEE8}.Debug-MT|x64.ActiveCfg = Debug|x64
+		{70828935-325B-4749-B381-0E55EF31AEE8}.Debug-MT|x64.Build.0 = Debug|x64
+		{70828935-325B-4749-B381-0E55EF31AEE8}.Release|ARM.ActiveCfg = Release|ARM
+		{70828935-325B-4749-B381-0E55EF31AEE8}.Release|ARM.Build.0 = Release|ARM
+		{70828935-325B-4749-B381-0E55EF31AEE8}.Release|ARM64.ActiveCfg = Release|ARM64
+		{70828935-325B-4749-B381-0E55EF31AEE8}.Release|ARM64.Build.0 = Release|ARM64
+		{70828935-325B-4749-B381-0E55EF31AEE8}.Release|Win32.ActiveCfg = Release|Win32
+		{70828935-325B-4749-B381-0E55EF31AEE8}.Release|Win32.Build.0 = Release|Win32
+		{70828935-325B-4749-B381-0E55EF31AEE8}.Release|x64.ActiveCfg = Release|x64
+		{70828935-325B-4749-B381-0E55EF31AEE8}.Release|x64.Build.0 = Release|x64
+		{70828935-325B-4749-B381-0E55EF31AEE8}.Release-MT|ARM.ActiveCfg = Release|ARM
+		{70828935-325B-4749-B381-0E55EF31AEE8}.Release-MT|ARM.Build.0 = Release|ARM
+		{70828935-325B-4749-B381-0E55EF31AEE8}.Release-MT|ARM64.ActiveCfg = Release|ARM64
+		{70828935-325B-4749-B381-0E55EF31AEE8}.Release-MT|ARM64.Build.0 = Release|ARM64
+		{70828935-325B-4749-B381-0E55EF31AEE8}.Release-MT|Win32.ActiveCfg = Release|Win32
+		{70828935-325B-4749-B381-0E55EF31AEE8}.Release-MT|Win32.Build.0 = Release|Win32
+		{70828935-325B-4749-B381-0E55EF31AEE8}.Release-MT|x64.ActiveCfg = Release|x64
+		{70828935-325B-4749-B381-0E55EF31AEE8}.Release-MT|x64.Build.0 = Release|x64
+		{3F3138D0-7AB7-4268-9BF3-1A3EA5503A11}.Debug|ARM.ActiveCfg = Debug|ARM
+		{3F3138D0-7AB7-4268-9BF3-1A3EA5503A11}.Debug|ARM.Build.0 = Debug|ARM
+		{3F3138D0-7AB7-4268-9BF3-1A3EA5503A11}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{3F3138D0-7AB7-4268-9BF3-1A3EA5503A11}.Debug|ARM64.Build.0 = Debug|ARM64
+		{3F3138D0-7AB7-4268-9BF3-1A3EA5503A11}.Debug|Win32.ActiveCfg = Debug|Win32
+		{3F3138D0-7AB7-4268-9BF3-1A3EA5503A11}.Debug|Win32.Build.0 = Debug|Win32
+		{3F3138D0-7AB7-4268-9BF3-1A3EA5503A11}.Debug|x64.ActiveCfg = Debug|x64
+		{3F3138D0-7AB7-4268-9BF3-1A3EA5503A11}.Debug|x64.Build.0 = Debug|x64
+		{3F3138D0-7AB7-4268-9BF3-1A3EA5503A11}.Debug-MT|ARM.ActiveCfg = Debug|ARM
+		{3F3138D0-7AB7-4268-9BF3-1A3EA5503A11}.Debug-MT|ARM.Build.0 = Debug|ARM
+		{3F3138D0-7AB7-4268-9BF3-1A3EA5503A11}.Debug-MT|ARM64.ActiveCfg = Debug|ARM64
+		{3F3138D0-7AB7-4268-9BF3-1A3EA5503A11}.Debug-MT|ARM64.Build.0 = Debug|ARM64
+		{3F3138D0-7AB7-4268-9BF3-1A3EA5503A11}.Debug-MT|Win32.ActiveCfg = Debug|Win32
+		{3F3138D0-7AB7-4268-9BF3-1A3EA5503A11}.Debug-MT|Win32.Build.0 = Debug|Win32
+		{3F3138D0-7AB7-4268-9BF3-1A3EA5503A11}.Debug-MT|x64.ActiveCfg = Debug|x64
+		{3F3138D0-7AB7-4268-9BF3-1A3EA5503A11}.Debug-MT|x64.Build.0 = Debug|x64
+		{3F3138D0-7AB7-4268-9BF3-1A3EA5503A11}.Release|ARM.ActiveCfg = Release|ARM
+		{3F3138D0-7AB7-4268-9BF3-1A3EA5503A11}.Release|ARM.Build.0 = Release|ARM
+		{3F3138D0-7AB7-4268-9BF3-1A3EA5503A11}.Release|ARM64.ActiveCfg = Release|ARM64
+		{3F3138D0-7AB7-4268-9BF3-1A3EA5503A11}.Release|ARM64.Build.0 = Release|ARM64
+		{3F3138D0-7AB7-4268-9BF3-1A3EA5503A11}.Release|Win32.ActiveCfg = Release|Win32
+		{3F3138D0-7AB7-4268-9BF3-1A3EA5503A11}.Release|Win32.Build.0 = Release|Win32
+		{3F3138D0-7AB7-4268-9BF3-1A3EA5503A11}.Release|x64.ActiveCfg = Release|x64
+		{3F3138D0-7AB7-4268-9BF3-1A3EA5503A11}.Release|x64.Build.0 = Release|x64
+		{3F3138D0-7AB7-4268-9BF3-1A3EA5503A11}.Release-MT|ARM.ActiveCfg = Release|ARM
+		{3F3138D0-7AB7-4268-9BF3-1A3EA5503A11}.Release-MT|ARM.Build.0 = Release|ARM
+		{3F3138D0-7AB7-4268-9BF3-1A3EA5503A11}.Release-MT|ARM64.ActiveCfg = Release|ARM64
+		{3F3138D0-7AB7-4268-9BF3-1A3EA5503A11}.Release-MT|ARM64.Build.0 = Release|ARM64
+		{3F3138D0-7AB7-4268-9BF3-1A3EA5503A11}.Release-MT|Win32.ActiveCfg = Release|Win32
+		{3F3138D0-7AB7-4268-9BF3-1A3EA5503A11}.Release-MT|Win32.Build.0 = Release|Win32
+		{3F3138D0-7AB7-4268-9BF3-1A3EA5503A11}.Release-MT|x64.ActiveCfg = Release|x64
+		{3F3138D0-7AB7-4268-9BF3-1A3EA5503A11}.Release-MT|x64.Build.0 = Release|x64
+		{35BD5D4B-5102-4A08-81C0-AAF3285FCB01}.Debug|ARM.ActiveCfg = Debug|ARM
+		{35BD5D4B-5102-4A08-81C0-AAF3285FCB01}.Debug|ARM.Build.0 = Debug|ARM
+		{35BD5D4B-5102-4A08-81C0-AAF3285FCB01}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{35BD5D4B-5102-4A08-81C0-AAF3285FCB01}.Debug|ARM64.Build.0 = Debug|ARM64
+		{35BD5D4B-5102-4A08-81C0-AAF3285FCB01}.Debug|Win32.ActiveCfg = Debug|Win32
+		{35BD5D4B-5102-4A08-81C0-AAF3285FCB01}.Debug|Win32.Build.0 = Debug|Win32
+		{35BD5D4B-5102-4A08-81C0-AAF3285FCB01}.Debug|x64.ActiveCfg = Debug|x64
+		{35BD5D4B-5102-4A08-81C0-AAF3285FCB01}.Debug|x64.Build.0 = Debug|x64
+		{35BD5D4B-5102-4A08-81C0-AAF3285FCB01}.Debug-MT|ARM.ActiveCfg = Debug|ARM
+		{35BD5D4B-5102-4A08-81C0-AAF3285FCB01}.Debug-MT|ARM.Build.0 = Debug|ARM
+		{35BD5D4B-5102-4A08-81C0-AAF3285FCB01}.Debug-MT|ARM64.ActiveCfg = Debug|ARM64
+		{35BD5D4B-5102-4A08-81C0-AAF3285FCB01}.Debug-MT|ARM64.Build.0 = Debug|ARM64
+		{35BD5D4B-5102-4A08-81C0-AAF3285FCB01}.Debug-MT|Win32.ActiveCfg = Debug|Win32
+		{35BD5D4B-5102-4A08-81C0-AAF3285FCB01}.Debug-MT|Win32.Build.0 = Debug|Win32
+		{35BD5D4B-5102-4A08-81C0-AAF3285FCB01}.Debug-MT|x64.ActiveCfg = Debug|x64
+		{35BD5D4B-5102-4A08-81C0-AAF3285FCB01}.Debug-MT|x64.Build.0 = Debug|x64
+		{35BD5D4B-5102-4A08-81C0-AAF3285FCB01}.Release|ARM.ActiveCfg = Release|ARM
+		{35BD5D4B-5102-4A08-81C0-AAF3285FCB01}.Release|ARM.Build.0 = Release|ARM
+		{35BD5D4B-5102-4A08-81C0-AAF3285FCB01}.Release|ARM64.ActiveCfg = Release|ARM64
+		{35BD5D4B-5102-4A08-81C0-AAF3285FCB01}.Release|ARM64.Build.0 = Release|ARM64
+		{35BD5D4B-5102-4A08-81C0-AAF3285FCB01}.Release|Win32.ActiveCfg = Release|Win32
+		{35BD5D4B-5102-4A08-81C0-AAF3285FCB01}.Release|Win32.Build.0 = Release|Win32
+		{35BD5D4B-5102-4A08-81C0-AAF3285FCB01}.Release|x64.ActiveCfg = Release|x64
+		{35BD5D4B-5102-4A08-81C0-AAF3285FCB01}.Release|x64.Build.0 = Release|x64
+		{35BD5D4B-5102-4A08-81C0-AAF3285FCB01}.Release-MT|ARM.ActiveCfg = Release|ARM
+		{35BD5D4B-5102-4A08-81C0-AAF3285FCB01}.Release-MT|ARM.Build.0 = Release|ARM
+		{35BD5D4B-5102-4A08-81C0-AAF3285FCB01}.Release-MT|ARM64.ActiveCfg = Release|ARM64
+		{35BD5D4B-5102-4A08-81C0-AAF3285FCB01}.Release-MT|ARM64.Build.0 = Release|ARM64
+		{35BD5D4B-5102-4A08-81C0-AAF3285FCB01}.Release-MT|Win32.ActiveCfg = Release|Win32
+		{35BD5D4B-5102-4A08-81C0-AAF3285FCB01}.Release-MT|Win32.Build.0 = Release|Win32
+		{35BD5D4B-5102-4A08-81C0-AAF3285FCB01}.Release-MT|x64.ActiveCfg = Release|x64
+		{35BD5D4B-5102-4A08-81C0-AAF3285FCB01}.Release-MT|x64.Build.0 = Release|x64
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {AD8203A3-88DD-4212-A273-100DFAD69F6B}
+	EndGlobalSection
+EndGlobal
diff --git a/3rdparty/libusb/src/msvc/libusb/config.h b/3rdparty/libusb/src/msvc/libusb/config.h
new file mode 100644
index 00000000..3e3ce9f8
--- /dev/null
+++ b/3rdparty/libusb/src/msvc/libusb/config.h
@@ -0,0 +1,59 @@
+/* config.h.  Manual config for MSVC.  */
+
+#ifndef _MSC_VER
+#warn "msvc/config.h shouldn't be included for your development environment."
+#error "Please make sure the msvc/ directory is removed from your build path."
+#endif
+
+/* Visual Studio 2013 or later is required */
+#if(_MSC_VER < 1800)
+#error "Visual Studio 2013 or later is required."
+#endif
+
+/* Visual Studio 2013 does not support __func__ */
+#if(_MSC_VER < 1900)
+#define __func__ __FUNCTION__
+#endif
+
+/* Visual Studio 2015 and later defines timespec */
+#if(_MSC_VER >= 1900)
+#define _TIMESPEC_DEFINED 1
+#endif
+
+/* Disable: warning C4127: conditional expression is constant */
+#pragma warning(disable : 4127)
+/* Disable: warning C4200: nonstandard extension used : zero-sized array in struct/union */
+#pragma warning(disable : 4200)
+/* Disable: warning C4201: nonstandard extension used : nameless struct/union */
+#pragma warning(disable : 4201)
+/* Disable: warning C4324: structure was padded due to __declspec(align()) */
+#pragma warning(disable : 4324)
+/* Disable: warning C4996: 'GetVersionExA': was declared deprecated */
+#pragma warning(disable : 4996)
+
+#if defined(_PREFAST_)
+/* Disable "Banned API" errors when using the MS's WDK OACR/Prefast */
+#pragma warning(disable : 28719)
+/* Disable "The function 'InitializeCriticalSection' must be called from within a try/except block" */
+#pragma warning(disable : 28125)
+#endif
+
+/* Define to the attribute for default visibility. */
+#define DEFAULT_VISIBILITY /**/
+
+/* Define to 1 to start with debug message logging enabled. */
+/* #undef ENABLE_DEBUG_LOGGING */
+
+/* Define to 1 to enable message logging. */
+#define ENABLE_LOGGING 0
+
+/* Define to 1 if compiling for a Windows platform. */
+#define PLATFORM_WINDOWS 1
+
+/* Define to the attribute for enabling parameter checks on printf-like
+   functions. */
+#define PRINTF_FORMAT(a, b) /**/
+
+/* Define to 1 to output logging messages to the systemwide log. */
+/* #undef USE_SYSTEM_LOGGING_FACILITY */
+#define USE_SYSTEM_LOGGING_FACILITY 1
diff --git a/3rdparty/libusb/src/msvc/libusb_dll.vcxproj b/3rdparty/libusb/src/msvc/libusb_dll.vcxproj
new file mode 100644
index 00000000..6d6c7313
--- /dev/null
+++ b/3rdparty/libusb/src/msvc/libusb_dll.vcxproj
@@ -0,0 +1,61 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="ProjectConfigurations.Base.props" />
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{349EE8FA-7D25-4909-AAF5-FF3FADE72187}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <Import Project="Configuration.DynamicLibrary.props" />
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="Base.props" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup>
+    <OutDir>$(IntDir)..\dll\</OutDir>
+    <TargetName>libusb-1.0</TargetName>
+  </PropertyGroup>
+  <ItemDefinitionGroup>
+    <Link>
+      <EmbedManagedResourceFile>libusb-1.0.rc;%(EmbedManagedResourceFile)</EmbedManagedResourceFile>
+      <ModuleDefinitionFile>..\libusb\libusb-1.0.def</ModuleDefinitionFile>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include="..\libusb\core.c" />
+    <ClCompile Include="..\libusb\descriptor.c" />
+    <ClCompile Include="..\libusb\os\events_windows.c" />
+    <ClCompile Include="..\libusb\hotplug.c" />
+    <ClCompile Include="..\libusb\io.c" />
+    <ClCompile Include="..\libusb\strerror.c" />
+    <ClCompile Include="..\libusb\sync.c" />
+    <ClCompile Include="..\libusb\os\threads_windows.c" />
+    <ClCompile Include="..\libusb\os\windows_common.c" />
+    <ClCompile Include="..\libusb\os\windows_usbdk.c" />
+    <ClCompile Include="..\libusb\os\windows_winusb.c" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include=".\config.h" />
+    <ClInclude Include="..\libusb\os\events_windows.h" />
+    <ClInclude Include="..\libusb\libusb.h" />
+    <ClInclude Include="..\libusb\libusbi.h" />
+    <ClInclude Include="..\libusb\os\threads_windows.h" />
+    <ClInclude Include="..\libusb\version.h" />
+    <ClInclude Include="..\libusb\version_nano.h" />
+    <ClInclude Include="..\libusb\os\windows_common.h" />
+    <ClInclude Include="..\libusb\os\windows_usbdk.h" />
+    <ClInclude Include="..\libusb\os\windows_winusb.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="..\libusb\libusb-1.0.def" />
+  </ItemGroup>
+  <ItemGroup>
+    <ResourceCompile Include="..\libusb\libusb-1.0.rc" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>
\ No newline at end of file
diff --git a/3rdparty/libusb/src/msvc/libusb_static.vcxproj b/3rdparty/libusb/src/msvc/libusb_static.vcxproj
new file mode 100644
index 00000000..ad72d8c6
--- /dev/null
+++ b/3rdparty/libusb/src/msvc/libusb_static.vcxproj
@@ -0,0 +1,49 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="ProjectConfigurations.Base.props" />
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{349EE8F9-7D25-4909-AAF5-FF3FADE72187}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <Import Project="Configuration.StaticLibrary.props" />
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="Base.props" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup>
+    <OutDir>$(IntDir)..\lib\</OutDir>
+    <TargetName>libusb-1.0</TargetName>
+  </PropertyGroup>
+  <ItemGroup>
+    <ClCompile Include="..\libusb\core.c" />
+    <ClCompile Include="..\libusb\descriptor.c" />
+    <ClCompile Include="..\libusb\os\events_windows.c" />
+    <ClCompile Include="..\libusb\hotplug.c" />
+    <ClCompile Include="..\libusb\io.c" />
+    <ClCompile Include="..\libusb\strerror.c" />
+    <ClCompile Include="..\libusb\sync.c" />
+    <ClCompile Include="..\libusb\os\threads_windows.c" />
+    <ClCompile Include="..\libusb\os\windows_common.c" />
+    <ClCompile Include="..\libusb\os\windows_usbdk.c" />
+    <ClCompile Include="..\libusb\os\windows_winusb.c" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include=".\config.h" />
+    <ClInclude Include="..\libusb\os\events_windows.h" />
+    <ClInclude Include="..\libusb\libusb.h" />
+    <ClInclude Include="..\libusb\libusbi.h" />
+    <ClInclude Include="..\libusb\os\threads_windows.h" />
+    <ClInclude Include="..\libusb\version.h" />
+    <ClInclude Include="..\libusb\version_nano.h" />
+    <ClInclude Include="..\libusb\os\windows_common.h" />
+    <ClInclude Include="..\libusb\os\windows_usbdk.h" />
+    <ClInclude Include="..\libusb\os\windows_winusb.h" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>
\ No newline at end of file
diff --git a/3rdparty/libusb/src/msvc/listdevs.vcxproj b/3rdparty/libusb/src/msvc/listdevs.vcxproj
new file mode 100644
index 00000000..192805cf
--- /dev/null
+++ b/3rdparty/libusb/src/msvc/listdevs.vcxproj
@@ -0,0 +1,32 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="ProjectConfigurations.Base.props" />
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{F4938DB0-3DE7-4737-9C5A-EAD1BE819F87}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <Import Project="Configuration.Application.props" />
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="Base.props" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <ItemGroup>
+    <ClCompile Include="..\examples\listdevs.c" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\libusb\libusb.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include=".\libusb_static.vcxproj">
+      <Project>{349ee8f9-7d25-4909-aaf5-ff3fade72187}</Project>
+      <ReferenceOutputAssembly>false</ReferenceOutputAssembly>
+    </ProjectReference>
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>
\ No newline at end of file
diff --git a/3rdparty/libusb/src/msvc/sam3u_benchmark.vcxproj b/3rdparty/libusb/src/msvc/sam3u_benchmark.vcxproj
new file mode 100644
index 00000000..2e7543d0
--- /dev/null
+++ b/3rdparty/libusb/src/msvc/sam3u_benchmark.vcxproj
@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="ProjectConfigurations.Base.props" />
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{861cdd5f-59a2-4f34-957e-5c1af98be0a4}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <Import Project="Configuration.Application.props" />
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="Base.props" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <ItemGroup>
+    <ClCompile Include="..\examples\sam3u_benchmark.c" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include=".\config.h" />
+    <ClInclude Include="..\libusb\libusb.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include=".\libusb_static.vcxproj">
+      <Project>{349ee8f9-7d25-4909-aaf5-ff3fade72187}</Project>
+      <ReferenceOutputAssembly>false</ReferenceOutputAssembly>
+    </ProjectReference>
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>
\ No newline at end of file
diff --git a/3rdparty/libusb/src/msvc/set_option.vcxproj b/3rdparty/libusb/src/msvc/set_option.vcxproj
new file mode 100644
index 00000000..ecb86bbe
--- /dev/null
+++ b/3rdparty/libusb/src/msvc/set_option.vcxproj
@@ -0,0 +1,35 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="ProjectConfigurations.Base.props" />
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{35BD5D4B-5102-4A08-81C0-AAF3285FCB01}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <Import Project="Configuration.Application.props" />
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="Base.props" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <ItemGroup>
+    <ClCompile Include="..\tests\set_option.c" />
+    <ClCompile Include="..\tests\testlib.c" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include=".\config.h" />
+    <ClInclude Include="..\libusb\libusb.h" />
+    <ClInclude Include="..\tests\libusb_testlib.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include=".\libusb_static.vcxproj">
+      <Project>{349ee8f9-7d25-4909-aaf5-ff3fade72187}</Project>
+      <ReferenceOutputAssembly>false</ReferenceOutputAssembly>
+    </ProjectReference>
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>
\ No newline at end of file
diff --git a/3rdparty/libusb/src/msvc/stress.vcxproj b/3rdparty/libusb/src/msvc/stress.vcxproj
new file mode 100644
index 00000000..061226fb
--- /dev/null
+++ b/3rdparty/libusb/src/msvc/stress.vcxproj
@@ -0,0 +1,35 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="ProjectConfigurations.Base.props" />
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{53942EFF-C810-458D-B3CB-EE5CE9F1E781}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <Import Project="Configuration.Application.props" />
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="Base.props" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <ItemGroup>
+    <ClCompile Include="..\tests\stress.c" />
+    <ClCompile Include="..\tests\testlib.c" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include=".\config.h" />
+    <ClInclude Include="..\libusb\libusb.h" />
+    <ClInclude Include="..\tests\libusb_testlib.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include=".\libusb_static.vcxproj">
+      <Project>{349ee8f9-7d25-4909-aaf5-ff3fade72187}</Project>
+      <ReferenceOutputAssembly>false</ReferenceOutputAssembly>
+    </ProjectReference>
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>
\ No newline at end of file
diff --git a/3rdparty/libusb/src/msvc/stress_mt.vcxproj b/3rdparty/libusb/src/msvc/stress_mt.vcxproj
new file mode 100644
index 00000000..db0d3b6c
--- /dev/null
+++ b/3rdparty/libusb/src/msvc/stress_mt.vcxproj
@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="ProjectConfigurations.Base.props" />
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{9EAF1311-2BBB-4177-882B-DA7FA0AD7912}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <Import Project="Configuration.Application.props" />
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="Base.props" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <ItemGroup>
+    <ClCompile Include="..\tests\stress_mt.c" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include=".\config.h" />
+    <ClInclude Include="..\libusb\libusb.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include=".\libusb_static.vcxproj">
+      <Project>{349ee8f9-7d25-4909-aaf5-ff3fade72187}</Project>
+      <ReferenceOutputAssembly>false</ReferenceOutputAssembly>
+    </ProjectReference>
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>
\ No newline at end of file
diff --git a/3rdparty/libusb/src/msvc/testlibusb.vcxproj b/3rdparty/libusb/src/msvc/testlibusb.vcxproj
new file mode 100644
index 00000000..f991ddf0
--- /dev/null
+++ b/3rdparty/libusb/src/msvc/testlibusb.vcxproj
@@ -0,0 +1,32 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="ProjectConfigurations.Base.props" />
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{70828935-325B-4749-B381-0E55EF31AEE8}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <Import Project="Configuration.Application.props" />
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="Base.props" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <ItemGroup>
+    <ClCompile Include="..\examples\testlibusb.c" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\libusb\libusb.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include=".\libusb_static.vcxproj">
+      <Project>{349ee8f9-7d25-4909-aaf5-ff3fade72187}</Project>
+      <ReferenceOutputAssembly>false</ReferenceOutputAssembly>
+    </ProjectReference>
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>
\ No newline at end of file
diff --git a/3rdparty/libusb/src/msvc/xusb.vcxproj b/3rdparty/libusb/src/msvc/xusb.vcxproj
new file mode 100644
index 00000000..4ee9bbc0
--- /dev/null
+++ b/3rdparty/libusb/src/msvc/xusb.vcxproj
@@ -0,0 +1,38 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="ProjectConfigurations.Base.props" />
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{3F3138D0-7AB7-4268-9BF3-1A3EA5503A11}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <Import Project="Configuration.Application.props" />
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="Base.props" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <!--VS2013 complains about while(0)-->
+      <DisableSpecificWarnings Condition="'$(PlatformToolsetVersion)'&lt;='120'">4127;%(DisableSpecificWarnings)</DisableSpecificWarnings>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include="..\examples\xusb.c" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\libusb\libusb.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include=".\libusb_static.vcxproj">
+      <Project>{349ee8f9-7d25-4909-aaf5-ff3fade72187}</Project>
+      <ReferenceOutputAssembly>false</ReferenceOutputAssembly>
+    </ProjectReference>
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>
\ No newline at end of file
diff --git a/3rdparty/libusb/src/tests/Makefile.am b/3rdparty/libusb/src/tests/Makefile.am
new file mode 100644
index 00000000..7831494d
--- /dev/null
+++ b/3rdparty/libusb/src/tests/Makefile.am
@@ -0,0 +1,21 @@
+AM_CPPFLAGS = -I$(top_srcdir)/libusb
+LDADD = ../libusb/libusb-1.0.la
+LIBS =
+
+stress_SOURCES = stress.c testlib.c
+stress_mt_SOURCES = stress_mt.c
+set_option_SOURCES = set_option.c testlib.c
+
+noinst_HEADERS = libusb_testlib.h
+noinst_PROGRAMS = stress stress_mt set_option
+
+if BUILD_UMOCKDEV_TEST
+# NOTE: We add libumockdev-preload.so so that we can run tests in-process
+#       We also use -Wl,-lxxx as the compiler doesn't need it and libtool
+#       would reorder the flags otherwise.
+umockdev_CPPFLAGS = ${UMOCKDEV_CFLAGS} -I$(top_srcdir)/libusb
+umockdev_LDFLAGS = -Wl,--push-state,--no-as-needed -Wl,-lumockdev-preload -Wl,--pop-state ${UMOCKDEV_LIBS}
+umockdev_SOURCES = umockdev.c
+
+noinst_PROGRAMS += umockdev
+endif
diff --git a/3rdparty/libusb/src/tests/libusb_testlib.h b/3rdparty/libusb/src/tests/libusb_testlib.h
new file mode 100644
index 00000000..6071dec4
--- /dev/null
+++ b/3rdparty/libusb/src/tests/libusb_testlib.h
@@ -0,0 +1,76 @@
+/*
+ * libusb test library helper functions
+ * Copyright © 2012 Toby Gray <toby.gray@realvnc.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef LIBUSB_TESTLIB_H
+#define LIBUSB_TESTLIB_H
+
+#include <libusb/config.h>
+
+/** Values returned from a test function to indicate test result */
+typedef enum {
+    /** Indicates that the test ran successfully. */
+    TEST_STATUS_SUCCESS,
+    /** Indicates that the test failed one or more test. */
+    TEST_STATUS_FAILURE,
+    /** Indicates that an unexpected error occurred. */
+    TEST_STATUS_ERROR,
+    /** Indicates that the test can't be run. For example this may be
+     * due to no suitable device being connected to perform the tests. */
+    TEST_STATUS_SKIP
+} libusb_testlib_result;
+
+/**
+ * Logs some test information or state
+ */
+void libusb_testlib_logf(const char *fmt, ...) PRINTF_FORMAT(1, 2);
+
+/**
+ * Structure holding a test description.
+ */
+typedef struct {
+    /** Human readable name of the test. */
+    const char *name;
+    /** The test library will call this function to run the test.
+     *
+     * Should return TEST_STATUS_SUCCESS on success or another TEST_STATUS value.
+     */
+    libusb_testlib_result (*function)(void);
+} libusb_testlib_test;
+
+/**
+ * Value to use at the end of a test array to indicate the last
+ * element.
+ */
+#define LIBUSB_NULL_TEST \
+    { NULL, NULL }
+
+/**
+ * Runs the tests provided.
+ *
+ * Before running any tests argc and argv will be processed
+ * to determine the mode of operation.
+ *
+ * \param argc The argc from main
+ * \param argv The argv from main
+ * \param tests A NULL_TEST terminated array of tests
+ * \return 0 on success, non-zero on failure
+ */
+int libusb_testlib_run_tests(int argc, char *argv[], const libusb_testlib_test *tests);
+
+#endif  // LIBUSB_TESTLIB_H
diff --git a/3rdparty/libusb/src/tests/set_option.c b/3rdparty/libusb/src/tests/set_option.c
new file mode 100644
index 00000000..536ff1a1
--- /dev/null
+++ b/3rdparty/libusb/src/tests/set_option.c
@@ -0,0 +1,181 @@
+/* -*- Mode: C; indent-tabs-mode:nil -*- */
+/*
+ * Unit tests for libusb_set_option
+ * Copyright © 2023 Nathan Hjelm <hjelmn@cs.unm.edu>
+ * Copyright © 2023 Google, LLC. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "config.h"
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <inttypes.h>
+#include "libusbi.h"
+#include "libusb_testlib.h"
+
+#if defined(_WIN32) && !defined(__CYGWIN__)
+#include <winbase.h>
+
+static int unsetenv(const char *env) {
+    return _putenv_s(env, "");
+}
+
+static int setenv(const char *env, const char *value, int overwrite) {
+    if(getenv(env) && !overwrite)
+        return 0;
+    return _putenv_s(env, value);
+}
+#endif
+
+#define LIBUSB_TEST_CLEAN_EXIT(code) \
+    do {                             \
+        if(test_ctx != NULL) {       \
+            libusb_exit(test_ctx);   \
+        }                            \
+        unsetenv("LIBUSB_DEBUG");    \
+        return (code);               \
+    } while(0)
+
+/**
+ * Fail the test if the expression does not evaluate to LIBUSB_SUCCESS.
+ */
+#define LIBUSB_TEST_RETURN_ON_ERROR(expr)                                                \
+    do {                                                                                 \
+        int _result = (expr);                                                            \
+        if(LIBUSB_SUCCESS != _result) {                                                  \
+            libusb_testlib_logf("Not success (%s) at %s:%d", #expr, __FILE__, __LINE__); \
+            LIBUSB_TEST_CLEAN_EXIT(TEST_STATUS_FAILURE);                                 \
+        }                                                                                \
+    } while(0)
+
+/**
+ * Use relational operatator to compare two values and fail the test if the
+ * comparison is false. Intended to compare integer or pointer types.
+ *
+ * Example: LIBUSB_EXPECT(==, 0, 1) -> fail, LIBUSB_EXPECT(==, 0, 0) -> ok.
+ */
+#define LIBUSB_EXPECT(operator, lhs, rhs)                                                                                                \
+    do {                                                                                                                                 \
+        int64_t _lhs = (lhs), _rhs = (rhs);                                                                                              \
+        if(!(_lhs operator _rhs)) {                                                                                                      \
+            libusb_testlib_logf("Expected %s (%" PRId64 ") " #operator" %s (%" PRId64 ") at %s:%d", #lhs, (int64_t)(intptr_t)_lhs, #rhs, \
+                                (int64_t)(intptr_t)_rhs, __FILE__, __LINE__);                                                            \
+            LIBUSB_TEST_CLEAN_EXIT(TEST_STATUS_FAILURE);                                                                                 \
+        }                                                                                                                                \
+    } while(0)
+
+static libusb_testlib_result test_set_log_level_basic(void) {
+#if defined(ENABLE_LOGGING) && !defined(ENABLE_DEBUG_LOGGING)
+    libusb_context *test_ctx = NULL;
+
+    /* unset LIBUSB_DEBUG if it is set */
+    unsetenv("LIBUSB_DEBUG");
+
+    /* test basic functionality */
+    LIBUSB_TEST_RETURN_ON_ERROR(libusb_init_context(&test_ctx, /*options=*/NULL,
+                                                    /*num_options=*/0));
+    LIBUSB_TEST_RETURN_ON_ERROR(libusb_set_option(test_ctx, LIBUSB_OPTION_LOG_LEVEL, LIBUSB_LOG_LEVEL_ERROR));
+    LIBUSB_EXPECT(==, test_ctx->debug, LIBUSB_LOG_LEVEL_ERROR);
+    LIBUSB_TEST_RETURN_ON_ERROR(libusb_set_option(test_ctx, LIBUSB_OPTION_LOG_LEVEL, LIBUSB_LOG_LEVEL_NONE));
+    LIBUSB_EXPECT(==, test_ctx->debug, LIBUSB_LOG_LEVEL_NONE);
+
+    LIBUSB_TEST_CLEAN_EXIT(TEST_STATUS_SUCCESS);
+#else
+    return TEST_STATUS_SKIP;
+#endif
+}
+
+static libusb_testlib_result test_set_log_level_default(void) {
+#if defined(ENABLE_LOGGING) && !defined(ENABLE_DEBUG_LOGGING)
+    libusb_context *test_ctx = NULL;
+
+    /* set the default debug level */
+    LIBUSB_TEST_RETURN_ON_ERROR(libusb_set_option(NULL, LIBUSB_OPTION_LOG_LEVEL, LIBUSB_LOG_LEVEL_ERROR));
+
+    LIBUSB_TEST_RETURN_ON_ERROR(libusb_init_context(&test_ctx, /*options=*/NULL,
+                                                    /*num_options=*/0));
+    /* check that debug level came from the default */
+    LIBUSB_EXPECT(==, test_ctx->debug, LIBUSB_LOG_LEVEL_ERROR);
+
+    /* try to override the old log level. since this was set from the default it
+     * should be possible to change it */
+    LIBUSB_TEST_RETURN_ON_ERROR(libusb_set_option(test_ctx, LIBUSB_OPTION_LOG_LEVEL, LIBUSB_LOG_LEVEL_NONE));
+    LIBUSB_EXPECT(==, test_ctx->debug, LIBUSB_LOG_LEVEL_NONE);
+
+    LIBUSB_TEST_CLEAN_EXIT(TEST_STATUS_SUCCESS);
+#else
+    return TEST_STATUS_SKIP;
+#endif
+}
+
+static libusb_testlib_result test_set_log_level_env(void) {
+#if defined(ENABLE_LOGGING)
+    libusb_context *test_ctx = NULL;
+
+    /* check that libusb_set_option does not change the log level when it was set
+     * from the environment. */
+    setenv("LIBUSB_DEBUG", "4", /*overwrite=*/0);
+    LIBUSB_TEST_RETURN_ON_ERROR(libusb_init_context(&test_ctx, /*options=*/NULL,
+                                                    /*num_options=*/0));
+    LIBUSB_EXPECT(==, test_ctx->debug, 4);
+
+    LIBUSB_TEST_RETURN_ON_ERROR(libusb_set_option(test_ctx, LIBUSB_OPTION_LOG_LEVEL, LIBUSB_LOG_LEVEL_ERROR));
+    /* environment variable should always override LIBUSB_OPTION_LOG_LEVEL if set */
+    LIBUSB_EXPECT(==, test_ctx->debug, 4);
+
+    LIBUSB_TEST_CLEAN_EXIT(TEST_STATUS_SUCCESS);
+#else
+    return TEST_STATUS_SKIP;
+#endif
+}
+
+static libusb_testlib_result test_no_discovery(void) {
+#if defined(__linux__)
+    libusb_context *test_ctx;
+    LIBUSB_TEST_RETURN_ON_ERROR(libusb_init_context(&test_ctx, /*options=*/NULL,
+                                                    /*num_options=*/0));
+    libusb_device **device_list = NULL;
+    ssize_t         num_devices = libusb_get_device_list(test_ctx, &device_list);
+    libusb_free_device_list(device_list, /*unref_devices=*/1);
+    libusb_exit(test_ctx);
+
+    LIBUSB_EXPECT(>, num_devices, 0);
+
+    LIBUSB_TEST_RETURN_ON_ERROR(libusb_set_option(NULL, LIBUSB_OPTION_NO_DEVICE_DISCOVERY));
+    LIBUSB_TEST_RETURN_ON_ERROR(libusb_init_context(&test_ctx, /*options=*/NULL,
+                                                    /*num_options=*/0));
+    device_list = NULL;
+    num_devices = libusb_get_device_list(test_ctx, &device_list);
+    libusb_free_device_list(device_list, /*unref_devices=*/1);
+
+    LIBUSB_EXPECT(==, num_devices, 0);
+    LIBUSB_TEST_CLEAN_EXIT(TEST_STATUS_SUCCESS);
+#else
+    return TEST_STATUS_SKIP;
+#endif
+}
+
+static const libusb_testlib_test tests[] = { { "test_set_log_level_basic", &test_set_log_level_basic },
+                                             { "test_set_log_level_env", &test_set_log_level_env },
+                                             { "test_no_discovery", &test_no_discovery },
+                                             /* since default options can't be unset, run this one last */
+                                             { "test_set_log_level_default", &test_set_log_level_default },
+                                             LIBUSB_NULL_TEST };
+
+int main(int argc, char *argv[]) {
+    return libusb_testlib_run_tests(argc, argv, tests);
+}
diff --git a/3rdparty/libusb/src/tests/stress.c b/3rdparty/libusb/src/tests/stress.c
new file mode 100644
index 00000000..c1510e49
--- /dev/null
+++ b/3rdparty/libusb/src/tests/stress.c
@@ -0,0 +1,158 @@
+/*
+ * libusb stress test program to perform simple stress tests
+ * Copyright © 2012 Toby Gray <toby.gray@realvnc.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <libusb/config.h>
+
+#include <string.h>
+
+#include "libusb.h"
+#include "libusb_testlib.h"
+
+/** Test that creates and destroys a single concurrent context
+ * 10000 times. */
+static libusb_testlib_result test_init_and_exit(void) {
+    for(int i = 0; i < 10000; ++i) {
+        libusb_context *ctx = NULL;
+        int             r;
+
+        r = libusb_init_context(&ctx, /*options=*/NULL, /*num_options=*/0);
+        if(r != LIBUSB_SUCCESS) {
+            libusb_testlib_logf("Failed to init libusb on iteration %d: %d", i, r);
+            return TEST_STATUS_FAILURE;
+        }
+        libusb_exit(ctx);
+    }
+
+    return TEST_STATUS_SUCCESS;
+}
+
+/** Tests that devices can be listed 1000 times. */
+static libusb_testlib_result test_get_device_list(void) {
+    libusb_context *ctx;
+    int             r;
+
+    r = libusb_init_context(&ctx, /*options=*/NULL, /*num_options=*/0);
+    if(r != LIBUSB_SUCCESS) {
+        libusb_testlib_logf("Failed to init libusb: %d", r);
+        return TEST_STATUS_FAILURE;
+    }
+
+    for(int i = 0; i < 1000; ++i) {
+        libusb_device **device_list = NULL;
+        ssize_t         list_size   = libusb_get_device_list(ctx, &device_list);
+        if(list_size < 0 || !device_list) {
+            libusb_testlib_logf("Failed to get device list on iteration %d: %ld (%p)", i, (long)-list_size, (void *)device_list);
+            libusb_exit(ctx);
+            return TEST_STATUS_FAILURE;
+        }
+        libusb_free_device_list(device_list, 1);
+    }
+
+    libusb_exit(ctx);
+    return TEST_STATUS_SUCCESS;
+}
+
+/** Tests that 100 concurrent device lists can be open at a time. */
+static libusb_testlib_result test_many_device_lists(void) {
+#define LIST_COUNT 100
+    libusb_testlib_result result = TEST_STATUS_SUCCESS;
+    libusb_context       *ctx    = NULL;
+    libusb_device       **device_lists[LIST_COUNT];
+    int                   r;
+
+    r = libusb_init_context(&ctx, /*options=*/NULL, /*num_options=*/0);
+    if(r != LIBUSB_SUCCESS) {
+        libusb_testlib_logf("Failed to init libusb: %d", r);
+        return TEST_STATUS_FAILURE;
+    }
+
+    memset(device_lists, 0, sizeof(device_lists));
+
+    /* Create the 100 device lists. */
+    for(int i = 0; i < LIST_COUNT; ++i) {
+        ssize_t list_size = libusb_get_device_list(ctx, &device_lists[i]);
+        if(list_size < 0 || !device_lists[i]) {
+            libusb_testlib_logf("Failed to get device list on iteration %d: %ld (%p)", i, (long)-list_size, (void *)device_lists[i]);
+            result = TEST_STATUS_FAILURE;
+            break;
+        }
+    }
+
+    /* Destroy the 100 device lists. */
+    for(int i = 0; i < LIST_COUNT; ++i) {
+        if(device_lists[i])
+            libusb_free_device_list(device_lists[i], 1);
+    }
+
+    libusb_exit(ctx);
+    return result;
+#undef LIST_COUNT
+}
+
+/** Tests that the default context (used for various things including
+ * logging) works correctly when the first context created in a
+ * process is destroyed. */
+static libusb_testlib_result test_default_context_change(void) {
+    for(int i = 0; i < 100; ++i) {
+        libusb_context *ctx = NULL;
+        int             r;
+
+        /* Enable debug output on new context, to be sure to use the context */
+        struct libusb_init_option options[] = {
+            {
+                .option = LIBUSB_OPTION_LOG_LEVEL,
+                .value  = { .ival = LIBUSB_LOG_LEVEL_DEBUG },
+            },
+        };
+        int num_options = 1;
+
+        /* First create a new context */
+        r = libusb_init_context(&ctx, options, num_options);
+        if(r != LIBUSB_SUCCESS) {
+            libusb_testlib_logf("Failed to init libusb: %d", r);
+            return TEST_STATUS_FAILURE;
+        }
+
+        /* Now create a reference to the default context */
+        r = libusb_init_context(/*ctx=*/NULL, options, num_options);
+        if(r != LIBUSB_SUCCESS) {
+            libusb_testlib_logf("Failed to init libusb: %d", r);
+            libusb_exit(ctx);
+            return TEST_STATUS_FAILURE;
+        }
+
+        /* Destroy the first context */
+        libusb_exit(ctx);
+        /* Destroy the default context */
+        libusb_exit(NULL);
+    }
+
+    return TEST_STATUS_SUCCESS;
+}
+
+/* Fill in the list of tests. */
+static const libusb_testlib_test tests[] = { { "init_and_exit", &test_init_and_exit },
+                                             { "get_device_list", &test_get_device_list },
+                                             { "many_device_lists", &test_many_device_lists },
+                                             { "default_context_change", &test_default_context_change },
+                                             LIBUSB_NULL_TEST };
+
+int main(int argc, char *argv[]) {
+    return libusb_testlib_run_tests(argc, argv, tests);
+}
diff --git a/3rdparty/libusb/src/tests/stress_mt.c b/3rdparty/libusb/src/tests/stress_mt.c
new file mode 100644
index 00000000..43d77a73
--- /dev/null
+++ b/3rdparty/libusb/src/tests/stress_mt.c
@@ -0,0 +1,153 @@
+/*
+ * libusb multi-thread test program
+ * Copyright 2022-2023 Tormod Volden
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <libusb/config.h>
+
+#include <libusb.h>
+#include <stdio.h>
+
+#if defined(PLATFORM_POSIX)
+
+#include <pthread.h>
+typedef pthread_t thread_t;
+typedef void     *thread_return_t;
+#define THREAD_RETURN_VALUE NULL
+#define THREAD_CALL_TYPE
+
+static inline int thread_create(thread_t *thread, thread_return_t (*thread_entry)(void *arg), void *arg) {
+    return pthread_create(thread, NULL, thread_entry, arg) == 0 ? 0 : -1;
+}
+
+static inline void thread_join(thread_t thread) {
+    (void)pthread_join(thread, NULL);
+}
+
+#elif defined(PLATFORM_WINDOWS)
+
+typedef HANDLE thread_t;
+#define THREAD_RETURN_VALUE 0
+#define THREAD_CALL_TYPE __stdcall
+
+#if defined(__CYGWIN__)
+typedef DWORD  thread_return_t;
+#else
+#include <process.h>
+typedef unsigned thread_return_t;
+#endif
+
+static inline int thread_create(thread_t *thread, thread_return_t(__stdcall *thread_entry)(void *arg), void *arg) {
+#if defined(__CYGWIN__)
+    *thread = CreateThread(NULL, 0, thread_entry, arg, 0, NULL);
+#else
+    *thread = (HANDLE)_beginthreadex(NULL, 0, thread_entry, arg, 0, NULL);
+#endif
+    return *thread != NULL ? 0 : -1;
+}
+
+static inline void thread_join(thread_t thread) {
+    (void)WaitForSingleObject(thread, INFINITE);
+    (void)CloseHandle(thread);
+}
+#endif /* PLATFORM_WINDOWS */
+
+/* Test that creates and destroys contexts repeatedly */
+
+#define NTHREADS 8
+#define ITERS 64
+
+struct thread_info {
+    int     number;
+    int     enumerate;
+    ssize_t devcount;
+    int     err;
+    int     iteration;
+} tinfo[NTHREADS];
+
+static thread_return_t THREAD_CALL_TYPE init_and_exit(void *arg) {
+    struct thread_info *ti = (struct thread_info *)arg;
+
+    for(int i = 0; i < ITERS; ++i) {
+        libusb_context *ctx = NULL;
+        int             r;
+
+        r = libusb_init_context(&ctx, /*options=*/NULL, /*num_options=*/0);
+        if(r != LIBUSB_SUCCESS) {
+            ti->err       = r;
+            ti->iteration = i;
+            return (thread_return_t)THREAD_RETURN_VALUE;
+        }
+        if(ti->enumerate) {
+            libusb_device **devs;
+            ti->devcount = libusb_get_device_list(ctx, &devs);
+            if(ti->devcount < 0) {
+                libusb_free_device_list(devs, 1);
+                ti->iteration = i;
+                break;
+            }
+            libusb_free_device_list(devs, 1);
+        }
+
+        libusb_exit(ctx);
+    }
+    return (thread_return_t)THREAD_RETURN_VALUE;
+}
+
+static int test_multi_init(int enumerate) {
+    thread_t threadId[NTHREADS];
+    int      errs = 0;
+    int      t;
+
+    printf("Starting %d threads\n", NTHREADS);
+    for(t = 0; t < NTHREADS; t++) {
+        tinfo[t].number    = t;
+        tinfo[t].enumerate = enumerate;
+        thread_create(&threadId[t], &init_and_exit, (void *)&tinfo[t]);
+    }
+
+    for(t = 0; t < NTHREADS; t++) {
+        thread_join(threadId[t]);
+        if(tinfo[t].err) {
+            errs++;
+            fprintf(stderr, "Thread %d failed (iteration %d): %s\n", tinfo[t].number, tinfo[t].iteration, libusb_error_name(tinfo[t].err));
+        }
+        else if(enumerate) {
+            if(tinfo[t].devcount < 0) {
+                errs++;
+                fprintf(stderr, "Thread %d failed to enumerate devices (iteration %d)\n", tinfo[t].number, tinfo[t].iteration);
+            }
+            else {
+                printf("Thread %d discovered %ld devices\n", tinfo[t].number, (long int)tinfo[t].devcount);
+            }
+        }
+    }
+
+    return errs;
+}
+
+int main(void) {
+    int errs = 0;
+
+    printf("Running multithreaded init/exit test...\n");
+    errs += test_multi_init(0);
+    printf("Running multithreaded init/exit test with enumeration...\n");
+    errs += test_multi_init(1);
+    printf("All done, %d errors\n", errs);
+
+    return errs != 0;
+}
diff --git a/3rdparty/libusb/src/tests/testlib.c b/3rdparty/libusb/src/tests/testlib.c
new file mode 100644
index 00000000..4f5c1147
--- /dev/null
+++ b/3rdparty/libusb/src/tests/testlib.c
@@ -0,0 +1,188 @@
+/*
+ * libusb test library helper functions
+ * Copyright © 2012 Toby Gray <toby.gray@realvnc.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <libusb/config.h>
+
+#include <errno.h>
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "libusb_testlib.h"
+
+#if defined(PLATFORM_POSIX)
+#define NULL_PATH "/dev/null"
+#elif defined(PLATFORM_WINDOWS)
+#define NULL_PATH "nul"
+#endif
+
+/**
+ * Converts a test result code into a human readable string.
+ */
+static const char *test_result_to_str(libusb_testlib_result result) {
+    switch(result) {
+    case TEST_STATUS_SUCCESS:
+        return "Success";
+    case TEST_STATUS_FAILURE:
+        return "Failure";
+    case TEST_STATUS_ERROR:
+        return "Error";
+    case TEST_STATUS_SKIP:
+        return "Skip";
+    default:
+        return "Unknown";
+    }
+}
+
+static void print_usage(const char *progname) {
+    printf("Usage: %s [-l] [-v] [<test_name> ...]\n", progname);
+    printf("   -l   List available tests\n");
+    printf("   -v   Don't redirect STDERR before running tests\n");
+    printf("   -h   Display this help and exit\n");
+}
+
+void libusb_testlib_logf(const char *fmt, ...) {
+    va_list va;
+
+    va_start(va, fmt);
+    vfprintf(stdout, fmt, va);
+    va_end(va);
+    fputc('\n', stdout);
+    fflush(stdout);
+}
+
+int libusb_testlib_run_tests(int argc, char *argv[], const libusb_testlib_test *tests) {
+    int run_count   = 0;
+    int idx         = 0;
+    int pass_count  = 0;
+    int fail_count  = 0;
+    int error_count = 0;
+    int skip_count  = 0;
+
+    /* Setup default mode of operation */
+    char **test_names = NULL;
+    int    test_count = 0;
+    bool   list_tests = false;
+    bool   verbose    = false;
+
+    /* Parse command line options */
+    if(argc >= 2) {
+        for(int j = 1; j < argc; j++) {
+            const char *argstr = argv[j];
+            size_t      arglen = strlen(argstr);
+
+            if(argstr[0] == '-' || argstr[0] == '/') {
+                if(arglen == 2) {
+                    switch(argstr[1]) {
+                    case 'l':
+                        list_tests = true;
+                        continue;
+                    case 'v':
+                        verbose = true;
+                        continue;
+                    case 'h':
+                        print_usage(argv[0]);
+                        return 0;
+                    }
+                }
+
+                fprintf(stderr, "Unknown option: '%s'\n", argstr);
+                print_usage(argv[0]);
+                return 1;
+            }
+            else {
+                /* End of command line options, remaining must be list of tests to run */
+                test_names = argv + j;
+                test_count = argc - j;
+                break;
+            }
+        }
+    }
+
+    /* Validate command line options */
+    if(test_names && list_tests) {
+        fprintf(stderr, "List of tests requested but test list provided\n");
+        print_usage(argv[0]);
+        return 1;
+    }
+
+    /* Setup test log output */
+    if(!verbose) {
+        if(!freopen(NULL_PATH, "w", stderr)) {
+            printf("Failed to open null handle: %d\n", errno);
+            return 1;
+        }
+    }
+
+    /* Act on any options not related to running tests */
+    if(list_tests) {
+        while(tests[idx].function)
+            libusb_testlib_logf("%s", tests[idx++].name);
+        return 0;
+    }
+
+    /* Run any requested tests */
+    while(tests[idx].function) {
+        const libusb_testlib_test *test = &tests[idx++];
+        libusb_testlib_result      test_result;
+
+        if(test_count > 0) {
+            /* Filtering tests to run, check if this is one of them */
+            int i;
+
+            for(i = 0; i < test_count; i++) {
+                if(!strcmp(test_names[i], test->name))
+                    /* Matches a requested test name */
+                    break;
+            }
+            if(i == test_count) {
+                /* Failed to find a test match, so do the next loop iteration */
+                continue;
+            }
+        }
+        libusb_testlib_logf("Starting test run: %s...", test->name);
+        test_result = test->function();
+        libusb_testlib_logf("%s (%d)", test_result_to_str(test_result), test_result);
+        switch(test_result) {
+        case TEST_STATUS_SUCCESS:
+            pass_count++;
+            break;
+        case TEST_STATUS_FAILURE:
+            fail_count++;
+            break;
+        case TEST_STATUS_ERROR:
+            error_count++;
+            break;
+        case TEST_STATUS_SKIP:
+            skip_count++;
+            break;
+        }
+        run_count++;
+    }
+
+    libusb_testlib_logf("---");
+    libusb_testlib_logf("Ran %d tests", run_count);
+    libusb_testlib_logf("Passed %d tests", pass_count);
+    libusb_testlib_logf("Failed %d tests", fail_count);
+    libusb_testlib_logf("Error in %d tests", error_count);
+    libusb_testlib_logf("Skipped %d tests", skip_count);
+
+    return pass_count != run_count;
+}
diff --git a/3rdparty/libusb/src/tests/umockdev.c b/3rdparty/libusb/src/tests/umockdev.c
new file mode 100644
index 00000000..21e74c57
--- /dev/null
+++ b/3rdparty/libusb/src/tests/umockdev.c
@@ -0,0 +1,1010 @@
+/*
+ * libusb umockdev based tests
+ *
+ * Copyright (C) 2022 Benjamin Berg <bberg@redhat.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "config.h"
+#include <glib.h>
+#include <glib/gstdio.h>
+#include <unistd.h>
+#include <string.h>
+#include <errno.h>
+#include <linux/ioctl.h>
+#include <linux/usbdevice_fs.h>
+
+#include "libusb.h"
+
+#include "umockdev.h"
+
+#define UNUSED_DATA __attribute__((unused)) gconstpointer unused_data
+
+/* avoid leak reports inside assertions; leaking stuff on assertion failures does not matter in tests */
+#if !defined(__clang__)
+#pragma GCC diagnostic ignored "-Wanalyzer-malloc-leak"
+#pragma GCC diagnostic ignored "-Wanalyzer-file-leak"
+#endif
+
+typedef struct {
+    pid_t                 thread;
+    libusb_context       *ctx;
+    enum libusb_log_level level;
+    char                 *str;
+} LogMessage;
+
+static void log_message_free(LogMessage *msg) {
+    g_free(msg->str);
+    g_free(msg);
+}
+G_DEFINE_AUTOPTR_CLEANUP_FUNC(LogMessage, log_message_free)
+
+typedef struct _UsbChat UsbChat;
+
+struct _UsbChat {
+    gboolean submit;
+    gboolean reap;
+    UsbChat *reaps;
+    UsbChat *next;
+
+    /* struct usbdevfs_urb */
+    unsigned char        type;
+    unsigned char        endpoint;
+    int                  status;
+    unsigned int         flags;
+    const unsigned char *buffer;
+    int                  buffer_length;
+    int                  actual_length;
+
+    /* <submit urb> */
+    UMockdevIoctlData *submit_urb;
+};
+
+typedef struct {
+    UMockdevTestbed       *testbed;
+    UMockdevIoctlBase     *handler;
+    struct libusb_context *ctx;
+
+    gchar *root_dir;
+    gchar *sys_dir;
+
+    gboolean libusb_log_silence;
+    GList   *libusb_log;
+
+    UsbChat *chat;
+    GList   *flying_urbs;
+    GList   *discarded_urbs;
+
+    /* GMutex confuses tsan unecessarily */
+    pthread_mutex_t mutex;
+} UMockdevTestbedFixture;
+
+/* Global for log handler */
+static UMockdevTestbedFixture *cur_fixture = NULL;
+
+static void log_handler(libusb_context *ctx, enum libusb_log_level level, const char *str) {
+    /* May be called from different threads without synchronization! */
+    LogMessage *msg;
+    pid_t       tid = gettid();
+
+    g_assert(cur_fixture != NULL);
+    g_assert(pthread_mutex_lock(&cur_fixture->mutex) == 0);
+
+    msg         = g_new0(LogMessage, 1);
+    msg->ctx    = ctx;
+    msg->level  = level;
+    msg->str    = g_strchomp(g_strdup(str));
+    msg->thread = tid;
+
+    if(!cur_fixture->libusb_log_silence)
+        g_printerr("%s\n", msg->str);
+
+    cur_fixture->libusb_log = g_list_append(cur_fixture->libusb_log, msg);
+    pthread_mutex_unlock(&cur_fixture->mutex);
+}
+
+static void log_handler_null(libusb_context *ctx, enum libusb_log_level level, const char *str) {
+    (void)ctx;
+    (void)level;
+    (void)str;
+}
+
+static void clear_libusb_log(UMockdevTestbedFixture *fixture, enum libusb_log_level level) {
+    g_assert(pthread_mutex_lock(&fixture->mutex) == 0);
+
+    while(fixture->libusb_log) {
+        LogMessage *msg = fixture->libusb_log->data;
+
+        g_assert(msg->ctx == fixture->ctx);
+
+        if(msg->level < level) {
+            pthread_mutex_unlock(&fixture->mutex);
+            return;
+        }
+
+        fixture->libusb_log = g_list_delete_link(fixture->libusb_log, fixture->libusb_log);
+        log_message_free(msg);
+    }
+    pthread_mutex_unlock(&fixture->mutex);
+}
+
+static void assert_libusb_log_msg(UMockdevTestbedFixture *fixture, enum libusb_log_level level, const char *re) {
+    g_assert(pthread_mutex_lock(&fixture->mutex) == 0);
+
+    while(fixture->libusb_log) {
+        g_autoptr(LogMessage) msg = NULL;
+
+        if(fixture->libusb_log == NULL)
+            g_error("No level %d message found searching for %s", level, re);
+
+        msg                 = fixture->libusb_log->data;
+        fixture->libusb_log = g_list_delete_link(fixture->libusb_log, fixture->libusb_log);
+
+        if(msg->ctx != fixture->ctx)
+            g_error("Saw unexpected message \"%s\" from context %p while %p was expected", msg->str, msg->ctx, fixture->ctx);
+
+        if(msg->level == level && g_regex_match_simple(re, msg->str, 0, 0)) {
+            pthread_mutex_unlock(&fixture->mutex);
+            return;
+        }
+
+        /* Allow skipping INFO and DEBUG messages */
+        if(msg->level >= LIBUSB_LOG_LEVEL_INFO)
+            continue;
+
+        g_error("Searched for \"%s\" (%d) but found \"%s\" (%d)", re, level, msg->str, msg->level);
+    }
+
+    pthread_mutex_unlock(&fixture->mutex);
+    g_error("Searched for \"%s\" (%d) but no message matched", re, level);
+}
+
+static void assert_libusb_no_log_msg(UMockdevTestbedFixture *fixture, enum libusb_log_level level, const char *re) {
+    g_assert(pthread_mutex_lock(&fixture->mutex) == 0);
+
+    while(fixture->libusb_log) {
+        g_autoptr(LogMessage) msg = NULL;
+        gboolean matching;
+
+        msg                 = fixture->libusb_log->data;
+        fixture->libusb_log = g_list_delete_link(fixture->libusb_log, fixture->libusb_log);
+
+        g_assert(msg->ctx == fixture->ctx);
+
+        matching = (msg->level == level && g_regex_match_simple(re, msg->str, 0, 0));
+
+        /* Allow skipping INFO and DEBUG messages */
+        if(!matching && msg->level >= LIBUSB_LOG_LEVEL_INFO)
+            continue;
+
+        g_error("Asserting \"%s\" (%d) not logged and found \"%s\" (%d)", re, level, msg->str, msg->level);
+    }
+
+    pthread_mutex_unlock(&fixture->mutex);
+}
+
+static void dump_buffer(const unsigned char *buffer, int len) {
+    g_autoptr(GString) line = NULL;
+
+    line = g_string_new("");
+    for(gint i = 0; i < len; i++) {
+        g_string_append_printf(line, "%02x ", buffer[i]);
+        if((i + 1) % 16 == 0) {
+            g_printerr("    %s\n", line->str);
+            g_string_set_size(line, 0);
+        }
+    }
+
+    if(line->len)
+        g_printerr("    %s\n", line->str);
+}
+
+static gint cmp_ioctl_data_addr(const void *data, const void *addr) {
+    return ((const UMockdevIoctlData *)data)->client_addr != (gulong)addr;
+}
+
+static gboolean handle_ioctl_cb(UMockdevIoctlBase *handler, UMockdevIoctlClient *client, UMockdevTestbedFixture *fixture) {
+    UMockdevIoctlData   *ioctl_arg;
+    long int             request;
+    struct usbdevfs_urb *urb;
+
+    (void)handler;
+
+    request   = umockdev_ioctl_client_get_request(client);
+    ioctl_arg = umockdev_ioctl_client_get_arg(client);
+
+    /* NOTE: We share the address space, dereferencing pointers *will* work.
+     * However, to make tsan work, we still stick to the API that resolves
+     * the data into a local copy! */
+
+    switch(request) {
+    case USBDEVFS_GET_CAPABILITIES: {
+        g_autoptr(UMockdevIoctlData) d = NULL;
+        d                              = umockdev_ioctl_data_resolve(ioctl_arg, 0, sizeof(guint32), NULL);
+
+        *(guint32 *)d->data = USBDEVFS_CAP_BULK_SCATTER_GATHER | USBDEVFS_CAP_BULK_CONTINUATION | USBDEVFS_CAP_NO_PACKET_SIZE_LIM
+                              | USBDEVFS_CAP_REAP_AFTER_DISCONNECT | USBDEVFS_CAP_ZERO_PACKET;
+
+        umockdev_ioctl_client_complete(client, 0, 0);
+        return TRUE;
+    }
+
+    case USBDEVFS_CLAIMINTERFACE:
+    case USBDEVFS_RELEASEINTERFACE:
+    case USBDEVFS_CLEAR_HALT:
+    case USBDEVFS_RESET:
+    case USBDEVFS_RESETEP:
+        umockdev_ioctl_client_complete(client, 0, 0);
+        return TRUE;
+
+    case USBDEVFS_SUBMITURB: {
+        g_autoptr(UMockdevIoctlData) urb_buffer = NULL;
+        g_autoptr(UMockdevIoctlData) urb_data   = NULL;
+        gsize buflen;
+
+        if(!fixture->chat || !fixture->chat->submit)
+            return FALSE;
+
+        buflen = fixture->chat->buffer_length;
+        if(fixture->chat->type == USBDEVFS_URB_TYPE_CONTROL)
+            buflen = 8;
+
+        urb_data   = umockdev_ioctl_data_resolve(ioctl_arg, 0, sizeof(struct usbdevfs_urb), NULL);
+        urb        = (struct usbdevfs_urb *)urb_data->data;
+        urb_buffer = umockdev_ioctl_data_resolve(urb_data, G_STRUCT_OFFSET(struct usbdevfs_urb, buffer), urb->buffer_length, NULL);
+
+        if(fixture->chat->type == urb->type && fixture->chat->endpoint == urb->endpoint && fixture->chat->buffer_length == urb->buffer_length
+           && (fixture->chat->buffer == NULL || memcmp(fixture->chat->buffer, urb_buffer->data, buflen) == 0)) {
+            fixture->flying_urbs = g_list_append(fixture->flying_urbs, umockdev_ioctl_data_ref(urb_data));
+
+            if(fixture->chat->reaps)
+                fixture->chat->reaps->submit_urb = urb_data;
+
+            if(fixture->chat->status)
+                umockdev_ioctl_client_complete(client, -1, -fixture->chat->status);
+            else
+                umockdev_ioctl_client_complete(client, 0, 0);
+
+            if(fixture->chat->next)
+                fixture->chat = fixture->chat->next;
+            else
+                fixture->chat += 1;
+            return TRUE;
+        }
+
+        /* chat message didn't match, don't accept it */
+        g_printerr("Could not process submit urb:\n");
+        g_printerr(" t: %d, ep: %d, actual_length: %d, buffer_length: %d\n", urb->type, urb->endpoint, urb->actual_length, urb->buffer_length);
+        if(urb->type == USBDEVFS_URB_TYPE_CONTROL || urb->endpoint & LIBUSB_ENDPOINT_IN)
+            dump_buffer(urb->buffer, urb->buffer_length);
+        g_printerr("Looking for:\n");
+        g_printerr(" t: %d, ep: %d, actual_length: %d, buffer_length: %d\n", fixture->chat->type, fixture->chat->endpoint, fixture->chat->actual_length,
+                   fixture->chat->buffer_length);
+        if(fixture->chat->buffer)
+            dump_buffer(fixture->chat->buffer, buflen);
+
+        return FALSE;
+    }
+
+    case USBDEVFS_REAPURB:
+    case USBDEVFS_REAPURBNDELAY: {
+        g_autoptr(UMockdevIoctlData) urb_ptr  = NULL;
+        g_autoptr(UMockdevIoctlData) urb_data = NULL;
+
+        if(fixture->discarded_urbs) {
+            urb_data                = fixture->discarded_urbs->data;
+            urb                     = (struct usbdevfs_urb *)urb_data->data;
+            fixture->discarded_urbs = g_list_delete_link(fixture->discarded_urbs, fixture->discarded_urbs);
+            urb->status             = -ENOENT;
+
+            urb_ptr = umockdev_ioctl_data_resolve(ioctl_arg, 0, sizeof(gpointer), NULL);
+            umockdev_ioctl_data_set_ptr(urb_ptr, 0, urb_data);
+
+            umockdev_ioctl_client_complete(client, 0, 0);
+            return TRUE;
+        }
+
+        if(fixture->chat && fixture->chat->reap) {
+            GList *l = g_list_find(fixture->flying_urbs, fixture->chat->submit_urb);
+
+            if(l) {
+                fixture->flying_urbs = g_list_remove_link(fixture->flying_urbs, fixture->flying_urbs);
+
+                urb_data           = fixture->chat->submit_urb;
+                urb                = (struct usbdevfs_urb *)urb_data->data;
+                urb->actual_length = fixture->chat->actual_length;
+                if(urb->type == USBDEVFS_URB_TYPE_CONTROL && urb->actual_length)
+                    urb->actual_length -= 8;
+                if(fixture->chat->buffer)
+                    memcpy(urb->buffer, fixture->chat->buffer, fixture->chat->actual_length);
+                urb->status = fixture->chat->status;
+
+                urb_ptr = umockdev_ioctl_data_resolve(ioctl_arg, 0, sizeof(gpointer), NULL);
+                umockdev_ioctl_data_set_ptr(urb_ptr, 0, urb_data);
+                if(fixture->chat->next)
+                    fixture->chat = fixture->chat->next;
+                else
+                    fixture->chat += 1;
+                umockdev_ioctl_client_complete(client, 0, 0);
+                return TRUE;
+            }
+        }
+
+        /* Nothing to reap */
+        umockdev_ioctl_client_complete(client, -1, EAGAIN);
+        return TRUE;
+    }
+
+    case USBDEVFS_DISCARDURB: {
+        GList *l = g_list_find_custom(fixture->flying_urbs, *(void **)ioctl_arg->data, cmp_ioctl_data_addr);
+
+        if(l) {
+            fixture->discarded_urbs = g_list_append(fixture->discarded_urbs, l->data);
+            fixture->flying_urbs    = g_list_delete_link(fixture->flying_urbs, l);
+            umockdev_ioctl_client_complete(client, 0, 0);
+        }
+        else {
+            umockdev_ioctl_client_complete(client, -1, EINVAL);
+        }
+
+        return TRUE;
+    }
+
+    default:
+        return FALSE;
+    }
+}
+
+static void test_fixture_add_canon(UMockdevTestbedFixture *fixture) {
+    /* Setup first, so we can be sure libusb_open works when the add uevent
+     * happens.
+     */
+    g_assert_cmpint(umockdev_testbed_attach_ioctl(fixture->testbed, "/dev/bus/usb/001/001", fixture->handler, NULL), ==, 1);
+
+    /* NOTE: add_device would not create a file, needed for device emulation */
+    /* XXX: Racy, see https://github.com/martinpitt/umockdev/issues/173 */
+    umockdev_testbed_add_from_string(fixture->testbed,
+                                     "P: /devices/usb1\n"
+                                     "N: bus/usb/001/001\n"
+                                     "E: SUBSYSTEM=usb\n"
+                                     "E: DRIVER=usb\n"
+                                     "E: BUSNUM=001\n"
+                                     "E: DEVNUM=001\n"
+                                     "E: DEVNAME=/dev/bus/usb/001/001\n"
+                                     "E: DEVTYPE=usb_device\n"
+                                     "A: bConfigurationValue=1\\n\n"
+                                     "A: busnum=1\\n\n"
+                                     "A: devnum=1\\n\n"
+                                     "A: bConfigurationValue=1\\n\n"
+                                     "A: speed=480\\n\n"
+                                     /* descriptor from a Canon PowerShot SX200; VID 04a9 PID 31c0 */
+                                     "H: descriptors="
+                                     "1201000200000040a904c03102000102"
+                                     "030109022700010100c0010904000003"
+                                     "06010100070581020002000705020200"
+                                     "020007058303080009\n",
+                                     NULL);
+}
+
+static void test_fixture_setup_libusb(UMockdevTestbedFixture *fixture, int devcount) {
+    libusb_device **devs = NULL;
+
+    libusb_init_context(/*ctx=*/&fixture->ctx, /*options=*/NULL, /*num_options=*/0);
+
+    /* Supress global log messages completely
+     * (though, in some tests it might be interesting to check there are no real ones).
+     */
+    libusb_set_log_cb(NULL, log_handler_null, LIBUSB_LOG_CB_GLOBAL);
+    libusb_set_option(fixture->ctx, LIBUSB_OPTION_LOG_LEVEL, LIBUSB_LOG_LEVEL_DEBUG);
+    g_assert_cmpint(libusb_get_device_list(fixture->ctx, &devs), ==, devcount);
+    libusb_free_device_list(devs, TRUE);
+    libusb_set_log_cb(fixture->ctx, log_handler, LIBUSB_LOG_CB_CONTEXT);
+}
+
+static void test_fixture_setup_common(UMockdevTestbedFixture *fixture) {
+    g_assert(cur_fixture == NULL);
+    cur_fixture = fixture;
+
+    pthread_mutex_init(&fixture->mutex, NULL);
+
+    fixture->testbed = umockdev_testbed_new();
+    g_assert(fixture->testbed != NULL);
+    fixture->root_dir = umockdev_testbed_get_root_dir(fixture->testbed);
+    fixture->sys_dir  = umockdev_testbed_get_sys_dir(fixture->testbed);
+
+    fixture->handler = umockdev_ioctl_base_new();
+    g_object_connect(fixture->handler, "signal-after::handle-ioctl", handle_ioctl_cb, fixture, NULL);
+}
+
+static void test_fixture_setup_empty(UMockdevTestbedFixture *fixture, UNUSED_DATA) {
+    test_fixture_setup_common(fixture);
+
+    test_fixture_setup_libusb(fixture, 0);
+}
+
+static void test_fixture_setup_with_canon(UMockdevTestbedFixture *fixture, UNUSED_DATA) {
+    test_fixture_setup_common(fixture);
+
+    test_fixture_add_canon(fixture);
+
+    test_fixture_setup_libusb(fixture, 1);
+}
+
+static void test_fixture_teardown(UMockdevTestbedFixture *fixture, UNUSED_DATA) {
+    g_assert(cur_fixture == fixture);
+
+    /* Abort if there are any warnings/errors in the log */
+    clear_libusb_log(fixture, LIBUSB_LOG_LEVEL_INFO);
+
+    if(fixture->ctx) {
+        libusb_device **devs  = NULL;
+        int             count = libusb_get_device_list(fixture->ctx, &devs);
+        libusb_free_device_list(devs, TRUE);
+
+        libusb_exit(fixture->ctx);
+
+        /* libusb_exit should result in the correct number of devices being destroyed */
+        for(int i = 0; i < count; i++)
+            assert_libusb_log_msg(fixture, LIBUSB_LOG_LEVEL_DEBUG, "libusb_unref_device");
+
+        assert_libusb_no_log_msg(fixture, LIBUSB_LOG_LEVEL_DEBUG, "libusb_unref_device");
+    }
+    libusb_set_log_cb(NULL, NULL, LIBUSB_LOG_CB_GLOBAL);
+    cur_fixture = NULL;
+
+    /* Abort if there are any warnings/errors in the log */
+    clear_libusb_log(fixture, LIBUSB_LOG_LEVEL_INFO);
+    fixture->ctx = NULL;
+    g_assert_null(fixture->libusb_log);
+
+    g_clear_object(&fixture->handler);
+    g_clear_object(&fixture->testbed);
+
+    /* verify that temp dir gets cleaned up properly */
+    g_assert(!g_file_test(fixture->root_dir, G_FILE_TEST_EXISTS));
+    g_free(fixture->root_dir);
+    g_free(fixture->sys_dir);
+
+    while(fixture->flying_urbs) {
+        umockdev_ioctl_data_unref(fixture->flying_urbs->data);
+        fixture->flying_urbs = g_list_delete_link(fixture->flying_urbs, fixture->flying_urbs);
+    }
+
+    pthread_mutex_destroy(&fixture->mutex);
+}
+
+static void test_open_close(UMockdevTestbedFixture *fixture, UNUSED_DATA) {
+    libusb_device                 **devs = NULL;
+    struct libusb_device_descriptor desc;
+    libusb_device_handle           *handle = NULL;
+
+    g_assert_cmpint(libusb_get_device_list(fixture->ctx, &devs), ==, 1);
+    /* The linux_enumerate_device may happen from a different thread */
+    assert_libusb_log_msg(fixture, LIBUSB_LOG_LEVEL_DEBUG, "libusb_get_device_list");
+    /* We have exactly one device */
+    g_assert_cmpint(libusb_get_bus_number(devs[0]), ==, 1);
+    g_assert_cmpint(libusb_get_device_address(devs[0]), ==, 1);
+
+    /* Get/Check descriptor */
+    clear_libusb_log(fixture, LIBUSB_LOG_LEVEL_INFO);
+    libusb_get_device_descriptor(devs[0], &desc);
+    assert_libusb_log_msg(fixture, LIBUSB_LOG_LEVEL_DEBUG, "libusb_get_device_descriptor");
+    g_assert_cmpint(desc.idVendor, ==, 0x04a9);
+    g_assert_cmpint(desc.idProduct, ==, 0x31c0);
+
+    /* Open and close */
+    g_assert_cmpint(libusb_open(devs[0], &handle), ==, 0);
+    assert_libusb_log_msg(fixture, LIBUSB_LOG_LEVEL_DEBUG, "usbi_add_event_source");
+    g_assert_nonnull(handle);
+    libusb_close(handle);
+    assert_libusb_log_msg(fixture, LIBUSB_LOG_LEVEL_DEBUG, "usbi_remove_event_source");
+
+    libusb_free_device_list(devs, TRUE);
+
+    /* Open and close using vid/pid */
+    handle = libusb_open_device_with_vid_pid(fixture->ctx, 0x04a9, 0x31c0);
+    g_assert_nonnull(handle);
+    libusb_close(handle);
+}
+
+static void test_implicit_default(UMockdevTestbedFixture *fixture, UNUSED_DATA) {
+    libusb_device **devs = NULL;
+
+    clear_libusb_log(fixture, LIBUSB_LOG_LEVEL_INFO);
+    g_assert_cmpint(libusb_get_device_list(NULL, &devs), ==, 1);
+    libusb_free_device_list(devs, TRUE);
+    assert_libusb_log_msg(fixture, LIBUSB_LOG_LEVEL_ERROR, "\\[usbi_get_context\\].*implicit default");
+
+    /* Only warns once */
+    g_assert_cmpint(libusb_get_device_list(NULL, &devs), ==, 1);
+    libusb_free_device_list(devs, TRUE);
+    clear_libusb_log(fixture, LIBUSB_LOG_LEVEL_INFO);
+
+    libusb_init_context(/*ctx=*/NULL, /*options=*/NULL, /*num_options=*/0);
+    g_assert_cmpint(libusb_get_device_list(NULL, &devs), ==, 1);
+    libusb_exit(NULL);
+
+    /* We free late, causing a warning from libusb_exit. However,
+     * we never see this warning (i.e. test success) because it is on a
+     * different context.
+     */
+    libusb_free_device_list(devs, TRUE);
+}
+
+static void test_close_flying(UMockdevTestbedFixture *fixture, UNUSED_DATA) {
+    UsbChat                 chat[]   = { {
+                                             .submit        = TRUE,
+                                             .type          = USBDEVFS_URB_TYPE_BULK,
+                                             .endpoint      = LIBUSB_ENDPOINT_OUT,
+                                             .buffer        = (unsigned char[]){ 0x01, 0x02, 0x03, 0x04 },
+                                             .buffer_length = 4,
+                       },
+                                         { .submit = FALSE } };
+    libusb_device_handle   *handle   = NULL;
+    struct libusb_transfer *transfer = NULL;
+
+    fixture->chat = chat;
+
+    /* Open */
+    handle = libusb_open_device_with_vid_pid(fixture->ctx, 0x04a9, 0x31c0);
+    g_assert_nonnull(handle);
+
+    transfer = libusb_alloc_transfer(0);
+    libusb_fill_bulk_transfer(transfer, handle, LIBUSB_ENDPOINT_OUT, (unsigned char *)chat[0].buffer, chat[0].buffer_length, NULL, NULL, 1);
+
+    /* Submit */
+    libusb_submit_transfer(transfer);
+
+    /* Closing logs fat error (two lines) */
+    clear_libusb_log(fixture, LIBUSB_LOG_LEVEL_DEBUG);
+    libusb_close(handle);
+    assert_libusb_log_msg(fixture, LIBUSB_LOG_LEVEL_ERROR, "\\[do_close\\] .*connected as far as we know");
+    assert_libusb_log_msg(fixture, LIBUSB_LOG_LEVEL_ERROR, "\\[do_close\\] .*cancellation hasn't even been scheduled");
+    assert_libusb_log_msg(fixture, LIBUSB_LOG_LEVEL_DEBUG, "\\[do_close\\] Removed transfer");
+
+    /* Free'ing the transfer works, and logs to the right context */
+    libusb_free_transfer(transfer);
+    assert_libusb_log_msg(fixture, LIBUSB_LOG_LEVEL_DEBUG, "\\[libusb_free_transfer\\]");
+}
+
+static void test_close_cancelled(UMockdevTestbedFixture *fixture, UNUSED_DATA) {
+    UsbChat                 chat[]   = { {
+                                             .submit        = TRUE,
+                                             .type          = USBDEVFS_URB_TYPE_BULK,
+                                             .endpoint      = LIBUSB_ENDPOINT_OUT,
+                                             .buffer        = (unsigned char[]){ 0x01, 0x02, 0x03, 0x04 },
+                                             .buffer_length = 4,
+                       },
+                                         { .submit = FALSE } };
+    libusb_device_handle   *handle   = NULL;
+    struct libusb_transfer *transfer = NULL;
+
+    fixture->chat = chat;
+
+    /* Open */
+    handle = libusb_open_device_with_vid_pid(fixture->ctx, 0x04a9, 0x31c0);
+    g_assert_nonnull(handle);
+
+    transfer = libusb_alloc_transfer(0);
+    libusb_fill_bulk_transfer(transfer, handle, LIBUSB_ENDPOINT_OUT, (unsigned char *)chat[0].buffer, chat[0].buffer_length, NULL, NULL, 1);
+
+    /* Submit */
+    libusb_submit_transfer(transfer);
+    libusb_cancel_transfer(transfer);
+
+    /* Closing logs fat error (two lines) */
+    clear_libusb_log(fixture, LIBUSB_LOG_LEVEL_DEBUG);
+    libusb_close(handle);
+    assert_libusb_log_msg(fixture, LIBUSB_LOG_LEVEL_ERROR, "\\[do_close\\] .*connected as far as we know");
+    assert_libusb_log_msg(fixture, LIBUSB_LOG_LEVEL_WARNING, "\\[do_close\\] .*cancellation.*hasn't completed");
+    assert_libusb_log_msg(fixture, LIBUSB_LOG_LEVEL_DEBUG, "\\[do_close\\] Removed transfer");
+
+    libusb_free_transfer(transfer);
+}
+
+static void test_ctx_destroy(UMockdevTestbedFixture *fixture, UNUSED_DATA) {
+    UsbChat                 chat[]   = { {
+                                             .submit        = TRUE,
+                                             .type          = USBDEVFS_URB_TYPE_BULK,
+                                             .endpoint      = LIBUSB_ENDPOINT_OUT,
+                                             .buffer        = (unsigned char[]){ 0x01, 0x02, 0x03, 0x04 },
+                                             .buffer_length = 4,
+                       },
+                                         { .submit = FALSE } };
+    libusb_device_handle   *handle   = NULL;
+    struct libusb_transfer *transfer = NULL;
+
+    fixture->chat = chat;
+
+    /* Open */
+    handle = libusb_open_device_with_vid_pid(fixture->ctx, 0x04a9, 0x31c0);
+    g_assert_nonnull(handle);
+
+    transfer = libusb_alloc_transfer(0);
+    libusb_fill_bulk_transfer(transfer, handle, LIBUSB_ENDPOINT_OUT, (unsigned char *)chat[0].buffer, chat[0].buffer_length, NULL, NULL, 1);
+
+    /* Submit */
+    libusb_submit_transfer(transfer);
+
+    /* Now we are evil and destroy the ctx! */
+    libusb_exit(fixture->ctx);
+
+    assert_libusb_log_msg(fixture, LIBUSB_LOG_LEVEL_WARNING, "\\[libusb_exit\\] device.*still referenced");
+    assert_libusb_log_msg(fixture, LIBUSB_LOG_LEVEL_WARNING, "\\[libusb_exit\\] application left some devices open");
+
+    clear_libusb_log(fixture, LIBUSB_LOG_LEVEL_DEBUG);
+    fixture->ctx = NULL;
+
+    /* XXX: Closing crashes the application as it unref's the NULL pointer */
+    /* libusb_close(handle); */
+
+    libusb_free_transfer(transfer);
+}
+
+static void test_get_string_descriptor(UMockdevTestbedFixture *fixture, UNUSED_DATA) {
+    unsigned char data[255] = {
+        0,
+    };
+    libusb_device_handle *handle = NULL;
+    UsbChat               chat[] = { {
+                                         .submit        = TRUE,
+                                         .reaps         = &chat[1],
+                                         .type          = USBDEVFS_URB_TYPE_CONTROL,
+                                         .buffer_length = 12, /* 8 byte out*/
+                                         .buffer        = (const unsigned char *)"\x80\x06\x00\x03\x00\x00\x04\x00",
+                       },
+                                     {
+                           /* String with content 0x0409 (en_US) */
+                                         .reap          = TRUE,
+                                         .actual_length = 12,
+                                         .buffer        = (const unsigned char *)"\x80\x06\x00\x03\x00\x00\x04\x00\x04\x03\x09\x04",
+                       },
+                                     {
+                                         .submit        = TRUE,
+                                         .reaps         = &chat[3],
+                                         .type          = USBDEVFS_URB_TYPE_CONTROL,
+                                         .buffer_length = 263, /* 8 byte out*/
+                                         .buffer        = (const unsigned char *)"\x80\x06\x01\x03\x09\x04\xff\x00",
+                       },
+                                     {
+                           /* 4 byte string, "ab" */
+                                         .reap          = TRUE,
+                                         .actual_length = 14,
+                                         .buffer        = (const unsigned char *)"\x80\x06\x01\x03\x09\x04\xff\x00\x06\x03\x61\x00\x62\x00",
+                       },
+                                     {
+                                         .submit        = TRUE,
+                                         .reaps         = &chat[5],
+                                         .type          = USBDEVFS_URB_TYPE_CONTROL,
+                                         .buffer_length = 12, /* 8 byte out*/
+                                         .buffer        = (const unsigned char *)"\x80\x06\x00\x03\x00\x00\x04\x00",
+                       },
+                                     {
+                                         .reap   = TRUE,
+                                         .status = -ENOENT,
+                       },
+                                     {
+                                         .submit        = TRUE,
+                                         .status        = -ENOENT,
+                                         .type          = USBDEVFS_URB_TYPE_CONTROL,
+                                         .buffer_length = 12, /* 8 byte out*/
+                                         .buffer        = (const unsigned char *)"\x80\x06\x00\x03\x00\x00\x04\x00",
+                       },
+                                     {
+                                         .submit = FALSE,
+                       } };
+
+    fixture->chat = chat;
+
+    handle = libusb_open_device_with_vid_pid(fixture->ctx, 0x04a9, 0x31c0);
+    g_assert_nonnull(handle);
+
+    /* The chat allows us to fetch the descriptor */
+    g_assert_cmpint(libusb_get_string_descriptor_ascii(handle, 1, data, sizeof(data)), ==, 2);
+    g_assert_cmpint(memcmp(data, "ab", 2), ==, 0);
+    clear_libusb_log(fixture, LIBUSB_LOG_LEVEL_DEBUG);
+
+    /* Again, but the URB fails with ENOENT when reaping */
+    g_assert_cmpint(libusb_get_string_descriptor_ascii(handle, 1, data, sizeof(data)), ==, -1);
+    clear_libusb_log(fixture, LIBUSB_LOG_LEVEL_DEBUG);
+
+    /* Again, but the URB fails to submit with ENOENT */
+    g_assert_cmpint(libusb_get_string_descriptor_ascii(handle, 1, data, sizeof(data)), ==, -1);
+    assert_libusb_log_msg(fixture, LIBUSB_LOG_LEVEL_ERROR, "\\[submit_control_transfer\\] submiturb failed, errno=2");
+    clear_libusb_log(fixture, LIBUSB_LOG_LEVEL_DEBUG);
+
+    libusb_close(handle);
+}
+
+static void transfer_cb_inc_user_data(struct libusb_transfer *transfer) {
+    *(int *)transfer->user_data += 1;
+}
+
+static void test_timeout(UMockdevTestbedFixture *fixture, UNUSED_DATA) {
+    UsbChat                 chat[]    = { {
+                                              .submit        = TRUE,
+                                              .type          = USBDEVFS_URB_TYPE_BULK,
+                                              .endpoint      = LIBUSB_ENDPOINT_OUT,
+                                              .buffer        = (unsigned char[]){ 0x01, 0x02, 0x03, 0x04 },
+                                              .buffer_length = 4,
+                       },
+                                          {
+                                              .submit = FALSE,
+                       } };
+    int                     completed = 0;
+    libusb_device_handle   *handle    = NULL;
+    struct libusb_transfer *transfer  = NULL;
+
+    fixture->chat = chat;
+
+    handle = libusb_open_device_with_vid_pid(fixture->ctx, 0x04a9, 0x31c0);
+    g_assert_nonnull(handle);
+
+    transfer = libusb_alloc_transfer(0);
+    libusb_fill_bulk_transfer(transfer, handle, LIBUSB_ENDPOINT_OUT, (unsigned char *)chat[0].buffer, chat[0].buffer_length, transfer_cb_inc_user_data,
+                              &completed, 10);
+
+    libusb_submit_transfer(transfer);
+    while(!completed) {
+        g_assert_cmpint(libusb_handle_events_completed(fixture->ctx, &completed), ==, 0);
+        /* Silence after one iteration. */
+        fixture->libusb_log_silence = TRUE;
+    }
+    fixture->libusb_log_silence = FALSE;
+
+    g_assert_cmpint(transfer->status, ==, LIBUSB_TRANSFER_TIMED_OUT);
+    libusb_free_transfer(transfer);
+
+    libusb_close(handle);
+}
+
+#define THREADED_SUBMIT_URB_SETS 64
+#define THREADED_SUBMIT_URB_IN_FLIGHT 64
+typedef struct {
+    struct libusb_transfer *transfers[THREADED_SUBMIT_URB_IN_FLIGHT * THREADED_SUBMIT_URB_SETS];
+    int                     submitted;
+    int                     completed;
+    int                     done;
+    UMockdevTestbedFixture *fixture;
+} TestThreadedSubmit;
+
+static gpointer transfer_submit_all_retry(TestThreadedSubmit *data) {
+    for(guint i = 0; i < G_N_ELEMENTS(data->transfers); i++) {
+        while(libusb_submit_transfer(data->transfers[i]) < 0) {
+            assert_libusb_log_msg(data->fixture, LIBUSB_LOG_LEVEL_ERROR, "submit_bulk_transfer");
+            continue;
+        }
+
+        data->submitted += 1;
+    }
+
+    return NULL;
+}
+
+static void test_threaded_submit_transfer_cb(struct libusb_transfer *transfer) {
+    TestThreadedSubmit *data = transfer->user_data;
+
+    /* We should only be receiving packets in the main thread */
+    g_assert_cmpint(getpid(), ==, gettid());
+
+    /* Check that the transfer buffer has the expected value */
+    g_assert_cmpint(*(int *)transfer->buffer, ==, data->completed);
+    data->completed += 1;
+
+    if(data->completed == G_N_ELEMENTS(data->transfers))
+        data->done = TRUE;
+}
+
+static void test_threaded_submit(UMockdevTestbedFixture *fixture, UNUSED_DATA) {
+    GThread           *thread  = NULL;
+    TestThreadedSubmit data    = { .fixture = fixture };
+    UsbChat            out_msg = {
+                   .submit        = TRUE,
+                   .type          = USBDEVFS_URB_TYPE_BULK,
+                   .endpoint      = LIBUSB_ENDPOINT_IN,
+                   .buffer_length = sizeof(int),
+    };
+    UsbChat in_msg = {
+        .reap          = TRUE,
+        .actual_length = 4,
+    };
+    UsbChat              *c;
+    libusb_device_handle *handle = NULL;
+    int                   urb;
+
+    handle = libusb_open_device_with_vid_pid(fixture->ctx, 0x04a9, 0x31c0);
+    g_assert_nonnull(handle);
+
+    fixture->libusb_log_silence = TRUE;
+
+    c = fixture->chat = g_new0(UsbChat, G_N_ELEMENTS(data.transfers) * 2 + 1);
+    urb               = 0;
+    for(int i = 0; i < THREADED_SUBMIT_URB_SETS; i++) {
+        for(int j = 0; j < THREADED_SUBMIT_URB_IN_FLIGHT; j++) {
+            c[i * 2 * THREADED_SUBMIT_URB_IN_FLIGHT + j]                      = out_msg;
+            c[i * 2 * THREADED_SUBMIT_URB_IN_FLIGHT + j].reaps                = &c[(i * 2 + 1) * THREADED_SUBMIT_URB_IN_FLIGHT + j];
+            c[(i * 2 + 1) * THREADED_SUBMIT_URB_IN_FLIGHT + j]                = in_msg;
+            c[(i * 2 + 1) * THREADED_SUBMIT_URB_IN_FLIGHT + j].buffer         = (unsigned char *)g_new0(int, 1);
+            *(int *)c[(i * 2 + 1) * THREADED_SUBMIT_URB_IN_FLIGHT + j].buffer = urb;
+
+            data.transfers[urb] = libusb_alloc_transfer(0);
+            libusb_fill_bulk_transfer(data.transfers[urb], handle, LIBUSB_ENDPOINT_IN, g_malloc(out_msg.buffer_length), out_msg.buffer_length,
+                                      test_threaded_submit_transfer_cb, &data, G_MAXUINT);
+            data.transfers[urb]->flags = LIBUSB_TRANSFER_FREE_BUFFER | LIBUSB_TRANSFER_FREE_TRANSFER;
+            urb++;
+        }
+    }
+
+    thread = g_thread_new("transfer all", (GThreadFunc)transfer_submit_all_retry, &data);
+
+    while(!data.done)
+        g_assert_cmpint(libusb_handle_events_completed(fixture->ctx, &data.done), ==, 0);
+
+    g_thread_join(thread);
+
+    fixture->libusb_log_silence = FALSE;
+    libusb_close(handle);
+
+    for(int i = 0; i < 2 * THREADED_SUBMIT_URB_SETS * THREADED_SUBMIT_URB_SETS; i++)
+        g_clear_pointer((void **)&c->buffer, g_free);
+    g_free(c);
+}
+
+static int hotplug_count_arrival_cb(libusb_context *ctx, libusb_device *device, libusb_hotplug_event event, void *user_data) {
+    g_assert_cmpint(event, ==, LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED);
+
+    (void)ctx;
+    (void)device;
+
+    *(int *)user_data += 1;
+
+    return 0;
+}
+
+#ifdef UMOCKDEV_HOTPLUG
+static int hotplug_count_removal_cb(libusb_context *ctx, libusb_device *device, libusb_hotplug_event event, void *user_data) {
+    g_assert_cmpint(event, ==, LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT);
+
+    (void)ctx;
+    (void)device;
+
+    *(int *)user_data += 1;
+
+    return 0;
+}
+#endif
+
+static void test_hotplug_enumerate(UMockdevTestbedFixture *fixture, UNUSED_DATA) {
+    libusb_hotplug_callback_handle handle_enumerate;
+    libusb_hotplug_callback_handle handle_no_enumerate;
+    int                            event_count_enumerate    = 0;
+    int                            event_count_no_enumerate = 0;
+    struct timeval                 zero_tv                  = { 0 };
+    int                            r;
+
+    r = libusb_hotplug_register_callback(fixture->ctx, LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED | LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT, LIBUSB_HOTPLUG_ENUMERATE,
+                                         LIBUSB_HOTPLUG_MATCH_ANY, LIBUSB_HOTPLUG_MATCH_ANY, LIBUSB_HOTPLUG_MATCH_ANY, hotplug_count_arrival_cb,
+                                         &event_count_enumerate, &handle_enumerate);
+    g_assert_cmpint(r, ==, 0);
+
+    r = libusb_hotplug_register_callback(fixture->ctx, LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED | LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT, 0, LIBUSB_HOTPLUG_MATCH_ANY,
+                                         LIBUSB_HOTPLUG_MATCH_ANY, LIBUSB_HOTPLUG_MATCH_ANY, hotplug_count_arrival_cb, &event_count_no_enumerate,
+                                         &handle_no_enumerate);
+    g_assert_cmpint(r, ==, 0);
+
+    g_assert_cmpint(event_count_enumerate, ==, 1);
+    g_assert_cmpint(event_count_no_enumerate, ==, 0);
+
+    libusb_handle_events_timeout(fixture->ctx, &zero_tv);
+
+    g_assert_cmpint(event_count_enumerate, ==, 1);
+    g_assert_cmpint(event_count_no_enumerate, ==, 0);
+
+    libusb_hotplug_deregister_callback(fixture->ctx, handle_enumerate);
+    libusb_hotplug_deregister_callback(fixture->ctx, handle_no_enumerate);
+
+    libusb_handle_events_timeout(fixture->ctx, &zero_tv);
+
+    g_assert_cmpint(event_count_enumerate, ==, 1);
+    g_assert_cmpint(event_count_no_enumerate, ==, 0);
+}
+
+static void test_hotplug_add_remove(UMockdevTestbedFixture *fixture, UNUSED_DATA) {
+#ifdef UMOCKDEV_HOTPLUG
+    libusb_device                **devs = NULL;
+    libusb_hotplug_callback_handle handle_add;
+    libusb_hotplug_callback_handle handle_remove;
+    int                            event_count_add    = 0;
+    int                            event_count_remove = 0;
+    struct timeval                 zero_tv            = { 0 };
+    int                            r;
+
+    r = libusb_hotplug_register_callback(fixture->ctx, LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED, LIBUSB_HOTPLUG_ENUMERATE, LIBUSB_HOTPLUG_MATCH_ANY,
+                                         LIBUSB_HOTPLUG_MATCH_ANY, LIBUSB_HOTPLUG_MATCH_ANY, hotplug_count_arrival_cb, &event_count_add, &handle_add);
+    g_assert_cmpint(r, ==, 0);
+
+    r = libusb_hotplug_register_callback(fixture->ctx, LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT, LIBUSB_HOTPLUG_ENUMERATE, LIBUSB_HOTPLUG_MATCH_ANY,
+                                         LIBUSB_HOTPLUG_MATCH_ANY, LIBUSB_HOTPLUG_MATCH_ANY, hotplug_count_removal_cb, &event_count_remove, &handle_remove);
+    g_assert_cmpint(r, ==, 0);
+
+    /* No device, even going into the mainloop will not call cb. */
+    libusb_handle_events_timeout(fixture->ctx, &zero_tv);
+    g_assert_cmpint(event_count_add, ==, 0);
+    g_assert_cmpint(event_count_remove, ==, 0);
+
+    /* Add a device */
+    test_fixture_add_canon(fixture);
+
+    /* Either the thread has picked it up already, or we do so now. */
+    g_assert_cmpint(libusb_get_device_list(fixture->ctx, &devs), ==, 1);
+    libusb_free_device_list(devs, TRUE);
+
+    /* The hotplug event is pending now, but has not yet fired. */
+    g_assert_cmpint(event_count_add, ==, 0);
+    g_assert_cmpint(event_count_remove, ==, 0);
+
+    /* Fire hotplug event. */
+    libusb_handle_events_timeout(fixture->ctx, &zero_tv);
+    g_assert_cmpint(event_count_add, ==, 1);
+    g_assert_cmpint(event_count_remove, ==, 0);
+
+    umockdev_testbed_uevent(fixture->testbed, "/sys/devices/usb1", "remove");
+    // umockdev_testbed_remove_device(fixture->testbed, "/devices/usb1");
+
+    /* Either the thread has picked it up already, or we do so now. */
+    g_assert_cmpint(libusb_get_device_list(fixture->ctx, &devs), ==, 0);
+    libusb_free_device_list(devs, TRUE);
+
+    /* The hotplug event is pending now, but has not yet fired. */
+    g_assert_cmpint(event_count_add, ==, 1);
+    g_assert_cmpint(event_count_remove, ==, 0);
+
+    /* Fire hotplug event. */
+    libusb_handle_events_timeout(fixture->ctx, &zero_tv);
+    g_assert_cmpint(event_count_add, ==, 1);
+    g_assert_cmpint(event_count_remove, ==, 1);
+
+    libusb_hotplug_deregister_callback(fixture->ctx, handle_add);
+    libusb_hotplug_deregister_callback(fixture->ctx, handle_remove);
+#else
+    (void)fixture;
+    g_test_skip("UMockdev is too old to test hotplug");
+#endif
+}
+
+int main(int argc, char **argv) {
+    g_test_init(&argc, &argv, NULL);
+
+    g_test_add("/libusb/open-close", UMockdevTestbedFixture, NULL, test_fixture_setup_with_canon, test_open_close, test_fixture_teardown);
+
+    g_test_add("/libusb/implicit-default", UMockdevTestbedFixture, NULL, test_fixture_setup_with_canon, test_implicit_default, test_fixture_teardown);
+
+    g_test_add("/libusb/close-flying", UMockdevTestbedFixture, NULL, test_fixture_setup_with_canon, test_close_flying, test_fixture_teardown);
+    g_test_add("/libusb/close-cancelled", UMockdevTestbedFixture, NULL, test_fixture_setup_with_canon, test_close_cancelled, test_fixture_teardown);
+
+    g_test_add("/libusb/ctx-destroy", UMockdevTestbedFixture, NULL, test_fixture_setup_with_canon, test_ctx_destroy, test_fixture_teardown);
+
+    g_test_add("/libusb/string-descriptor", UMockdevTestbedFixture, NULL, test_fixture_setup_with_canon, test_get_string_descriptor, test_fixture_teardown);
+
+    g_test_add("/libusb/timeout", UMockdevTestbedFixture, NULL, test_fixture_setup_with_canon, test_timeout, test_fixture_teardown);
+
+    g_test_add("/libusb/threaded-submit", UMockdevTestbedFixture, NULL, test_fixture_setup_with_canon, test_threaded_submit, test_fixture_teardown);
+
+    g_test_add("/libusb/hotplug/enumerate", UMockdevTestbedFixture, NULL, test_fixture_setup_with_canon, test_hotplug_enumerate, test_fixture_teardown);
+
+    g_test_add("/libusb/hotplug/add-remove", UMockdevTestbedFixture, NULL, test_fixture_setup_empty, test_hotplug_add_remove, test_fixture_teardown);
+
+    return g_test_run();
+}
diff --git a/3rdparty/libuvc/CMakeLists.txt b/3rdparty/libuvc/CMakeLists.txt
new file mode 100644
index 00000000..ce7439a1
--- /dev/null
+++ b/3rdparty/libuvc/CMakeLists.txt
@@ -0,0 +1,12 @@
+cmake_minimum_required(VERSION 3.5)
+
+add_subdirectory(src)
+
+# remove warning as error
+get_target_property(compile_options uvc_static COMPILE_OPTIONS)
+list(REMOVE_ITEM compile_options "-Werror" "/WX" "-Wpedantic")
+set_target_properties(uvc_static PROPERTIES COMPILE_OPTIONS "${compile_options}")
+
+add_library(libuvc::libuvc ALIAS uvc_static)
+ob_source_group(libuvc::libuvc)
+set_target_properties(uvc_static PROPERTIES FOLDER "dependencies")
diff --git a/3rdparty/libuvc/src/CMakeLists.txt b/3rdparty/libuvc/src/CMakeLists.txt
new file mode 100644
index 00000000..696950e6
--- /dev/null
+++ b/3rdparty/libuvc/src/CMakeLists.txt
@@ -0,0 +1,196 @@
+cmake_minimum_required(VERSION 3.1)
+project(libuvc
+  VERSION 0.0.6
+  LANGUAGES C
+)
+# subdirectory_include(CORE_INC)
+# Additional search scripts path for libusb-1.0, libjpeg, OpenCV
+list(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_LIST_DIR}/cmake)
+# include(${CMAKE_MODULE_PATH}/FindLibUSB.cmake)
+
+# Xcode and Visual Studio do not using CMAKE_BUILD_TYPE cache variable
+# so we use Release build type only with single configuration generators.
+if (NOT CMAKE_CONFIGURATION_TYPES)
+  if(NOT CMAKE_BUILD_TYPE)
+    message(STATUS "No build type selected, default to Release")
+    set(CMAKE_BUILD_TYPE "Release" CACHE STRING "" FORCE)
+  endif()
+endif()
+
+if(NOT CMAKE_BUILD_TARGET)
+    message(STATUS "No target type selected, default to both shared and static library")
+    set(CMAKE_BUILD_TARGET "Static" CACHE STRING "" FORCE)
+endif()
+
+option(BUILD_EXAMPLE "Build example program" OFF)
+option(BUILD_TEST "Build test program" OFF)
+option(ENABLE_UVC_DEBUGGING "Enable UVC debugging" OFF)
+
+set(libuvc_DESCRIPTION "A cross-platform library for USB video devices")
+set(libuvc_URL "https://github.com/libuvc/libuvc")
+
+set(SOURCES
+  src/ctrl.c
+  src/ctrl-gen.c
+  src/device.c
+  src/diag.c
+  src/frame.c
+  src/init.c
+  src/stream.c
+  src/misc.c
+)
+
+set(JPEG_FOUND 0)
+if(JPEG_FOUND)
+  message(STATUS "Building libuvc with JPEG support.")
+  set(LIBUVC_HAS_JPEG TRUE)
+  list(APPEND SOURCES src/frame-mjpeg.c)
+else()
+  message(WARNING "JPEG not found. libuvc will not support JPEG decoding.")
+endif()
+
+if(${CMAKE_BUILD_TARGET} MATCHES "Shared")
+  set(BUILD_UVC_SHARED TRUE)
+elseif(${CMAKE_BUILD_TARGET} MATCHES "Static")
+  set(BUILD_UVC_STATIC TRUE)
+elseif(${CMAKE_BUILD_TARGET} MATCHES "Both")
+  set(BUILD_UVC_SHARED TRUE)
+  set(BUILD_UVC_STATIC TRUE)
+else()
+  message(FATAL_ERROR "Invalid build type ${CMAKE_BUILD_TARGET}" )
+endif()
+
+if(BUILD_UVC_SHARED)
+  add_library(uvc SHARED ${SOURCES})
+  set_target_properties(uvc PROPERTIES
+    VERSION ${libuvc_VERSION}
+    SOVERSION ${libuvc_VERSION_MAJOR}
+    # Exported name of target within namespace LibUVC
+    EXPORT_NAME UVCShared
+  )
+  list(APPEND UVC_TARGETS uvc)
+  if(NOT LibUVC_STATIC)
+    add_library(LibUVC::UVC ALIAS uvc)
+  endif()
+  # Aliases defined here available only if project included
+  # via addsubdirectory
+  add_library(LibUVC::UVCShared ALIAS uvc)
+endif()
+
+if(BUILD_UVC_STATIC)
+  add_library(uvc_static STATIC ${SOURCES})
+  set_target_properties(uvc_static PROPERTIES
+    OUTPUT_NAME uvc
+    # Exported name of target within namespace LibUVC
+    EXPORT_NAME UVCStatic
+  )
+  list(APPEND UVC_TARGETS uvc_static)
+  add_library(LibUVC::UVCStatic ALIAS uvc_static)
+  if(LibUVC_STATIC)
+    add_library(LibUVC::UVC ALIAS uvc_static)
+  endif()
+endif()
+
+configure_file(include/libuvc/libuvc_config.h.in
+  ${CMAKE_CURRENT_SOURCE_DIR}/include/libuvc/libuvc_config.h
+  @ONLY
+)
+
+foreach(target_name IN LISTS UVC_TARGETS)
+  target_include_directories(${target_name}
+    PUBLIC
+      # Different paths for includes for build and install phase supported
+      # via INSTALL_INTERFACE and BUILD_INTERFACE generator expressions.
+      $<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/include>
+      $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}/include>
+      $<INSTALL_INTERFACE:include>
+      ${LibUSB_INCLUDE_DIRS}
+  )
+
+  target_link_libraries(${target_name} libusb::libusb)
+
+  if(JPEG_FOUND)
+     include_directories( ${PROJECT_SOURCE_DIR}/../libjpeg/ )
+     include_directories( ${CMAKE_CURRENT_BINARY_DIR}/../libjpeg/ )
+    target_link_libraries(${target_name} turbojpeg_static)
+  endif()
+
+  set_target_properties(${target_name} PROPERTIES
+      PUBLIC_HEADER "include/libuvc/libuvc.h;${CMAKE_CURRENT_BINARY_DIR}/include/libuvc/libuvc_config.h"
+  )
+  if(ENABLE_UVC_DEBUGGING)
+    target_compile_definitions(${target_name}
+      PRIVATE
+        UVC_DEBUGGING
+    )
+  endif()
+endforeach()
+
+if(BUILD_EXAMPLE)
+  add_executable(example src/example.c)
+  find_package(Threads)
+  target_link_libraries(example
+    PRIVATE
+      LibUVC::UVC
+      Threads::Threads
+  )
+endif()
+
+
+
+# include(GNUInstallDirs)
+# set(CMAKE_INSTALL_CMAKEDIR ${CMAKE_INSTALL_LIBDIR}/cmake/libuvc)
+
+# install(
+#   TARGETS ${UVC_TARGETS}
+#   # EXPORT libuvcTargets
+#   LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+#   ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+#   RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+#   INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
+#   PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/libuvc
+# )
+
+# # install(EXPORT libuvcTargets
+# #   FILE libuvcTargets.cmake
+# #   NAMESPACE LibUVC::
+# #   DESTINATION ${CMAKE_INSTALL_CMAKEDIR}
+# # )
+
+# install(FILES
+#     cmake/FindLibUSB.cmake
+#     cmake/FindJpegPkg.cmake
+#   DESTINATION ${CMAKE_INSTALL_CMAKEDIR}
+# )
+
+# include(CMakePackageConfigHelpers)
+# write_basic_package_version_file(libuvcConfigVersion.cmake
+#   COMPATIBILITY AnyNewerVersion
+# )
+
+# install(FILES
+#   ${CMAKE_CURRENT_BINARY_DIR}/libuvcConfigVersion.cmake
+#   DESTINATION ${CMAKE_INSTALL_CMAKEDIR}
+# )
+
+# if(JPEG_FOUND)
+#   # If we have used JPEG library we need to
+#   # add linker flag for it in config file for pkgconfig
+#   set(PKGCONFIG_JPEG_LDFLAG "-ljpeg")
+# endif()
+
+# configure_file(libuvc.pc.in
+#   ${PROJECT_BINARY_DIR}/libuvc.pc
+#   @ONLY
+# )
+
+# install(FILES
+#   ${CMAKE_CURRENT_BINARY_DIR}/libuvc.pc
+#   DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig
+# )
+
+# install(FILES libuvcConfig.cmake
+#   DESTINATION ${CMAKE_INSTALL_CMAKEDIR}
+# )
+
+
diff --git a/3rdparty/libuvc/src/CMakeLists.txt.original b/3rdparty/libuvc/src/CMakeLists.txt.original
new file mode 100644
index 00000000..f3c8116c
--- /dev/null
+++ b/3rdparty/libuvc/src/CMakeLists.txt.original
@@ -0,0 +1,214 @@
+cmake_minimum_required(VERSION 3.1)
+project(libuvc
+  VERSION 0.0.6
+  LANGUAGES C
+)
+
+# Additional search scripts path for libusb-1.0, libjpeg, OpenCV
+list(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_LIST_DIR}/cmake)
+
+# Xcode and Visual Studio do not using CMAKE_BUILD_TYPE cache variable
+# so we use Release build type only with single configuration generators.
+if (NOT CMAKE_CONFIGURATION_TYPES)
+  if(NOT CMAKE_BUILD_TYPE)
+    message(STATUS "No build type selected, default to Release")
+    set(CMAKE_BUILD_TYPE "Release" CACHE STRING "" FORCE)
+  endif()
+endif()
+
+if(NOT CMAKE_BUILD_TARGET)
+    message(STATUS "No target type selected, default to both shared and static library")
+    set(CMAKE_BUILD_TARGET "Both" CACHE STRING "" FORCE)
+endif()
+
+option(BUILD_EXAMPLE "Build example program" ON)
+option(BUILD_TEST "Build test program" OFF)
+option(ENABLE_UVC_DEBUGGING "Enable UVC debugging" OFF)
+
+set(libuvc_DESCRIPTION "A cross-platform library for USB video devices")
+set(libuvc_URL "https://github.com/libuvc/libuvc")
+
+set(SOURCES 
+  src/ctrl.c
+  src/ctrl-gen.c
+  src/device.c
+  src/diag.c
+  src/frame.c
+  src/init.c
+  src/stream.c
+  src/misc.c
+)
+
+find_package(LibUSB)
+
+# JpegPkg name to differ from shipped with CMake
+find_package(JpegPkg QUIET)
+if(JPEG_FOUND)
+  message(STATUS "Building libuvc with JPEG support.")
+  set(LIBUVC_HAS_JPEG TRUE)
+  list(APPEND SOURCES src/frame-mjpeg.c)
+else()
+  message(WARNING "JPEG not found. libuvc will not support JPEG decoding.")
+endif()
+
+if(${CMAKE_BUILD_TARGET} MATCHES "Shared")
+  set(BUILD_UVC_SHARED TRUE)
+elseif(${CMAKE_BUILD_TARGET} MATCHES "Static")
+  set(BUILD_UVC_STATIC TRUE)
+elseif(${CMAKE_BUILD_TARGET} MATCHES "Both")
+  set(BUILD_UVC_SHARED TRUE)
+  set(BUILD_UVC_STATIC TRUE)
+else()
+  message(FATAL_ERROR "Invalid build type ${CMAKE_BUILD_TARGET}" )
+endif()
+
+if(BUILD_UVC_SHARED)
+  add_library(uvc SHARED ${SOURCES})
+  set_target_properties(uvc PROPERTIES
+    VERSION ${libuvc_VERSION}
+    SOVERSION ${libuvc_VERSION_MAJOR}
+    # Exported name of target within namespace LibUVC
+    EXPORT_NAME UVCShared
+  )
+  list(APPEND UVC_TARGETS uvc)
+  if(NOT LibUVC_STATIC)  
+    add_library(LibUVC::UVC ALIAS uvc)
+  endif()
+  # Aliases defined here available only if project included 
+  # via addsubdirectory
+  add_library(LibUVC::UVCShared ALIAS uvc)
+endif()
+
+if(BUILD_UVC_STATIC)
+  add_library(uvc_static STATIC ${SOURCES})
+  set_target_properties(uvc_static PROPERTIES
+    OUTPUT_NAME uvc
+    # Exported name of target within namespace LibUVC
+    EXPORT_NAME UVCStatic
+  )
+  list(APPEND UVC_TARGETS uvc_static)
+  add_library(LibUVC::UVCStatic ALIAS uvc_static)
+  if(LibUVC_STATIC)
+    add_library(LibUVC::UVC ALIAS uvc_static)
+  endif()
+endif()
+
+configure_file(include/libuvc/libuvc_config.h.in
+  include/libuvc/libuvc_config.h
+  @ONLY
+)
+
+foreach(target_name IN LISTS UVC_TARGETS)
+  target_include_directories(${target_name}
+    PUBLIC
+      # Different paths for includes for build and install phase supported 
+      # via INSTALL_INTERFACE and BUILD_INTERFACE generator expressions.
+      $<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/include>
+      $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}/include>
+      $<INSTALL_INTERFACE:include>
+  )
+  target_link_libraries(${target_name}
+    # libusb-1.0 used internally so we link to it privately.
+    PRIVATE LibUSB::LibUSB
+  )
+  if(JPEG_FOUND)
+    target_link_libraries(${target_name}
+      PRIVATE JPEG::JPEG
+    )
+  endif()
+  set_target_properties(${target_name} PROPERTIES
+      PUBLIC_HEADER "include/libuvc/libuvc.h;${CMAKE_CURRENT_BINARY_DIR}/include/libuvc/libuvc_config.h"
+  )
+  if(ENABLE_UVC_DEBUGGING)
+    target_compile_definitions(${target_name}
+      PRIVATE
+        UVC_DEBUGGING
+    )
+  endif()
+endforeach()
+
+if(BUILD_EXAMPLE)
+  add_executable(example src/example.c)
+  find_package(Threads)
+  target_link_libraries(example
+    PRIVATE
+      LibUVC::UVC
+      Threads::Threads
+  )
+endif()
+
+if(BUILD_TEST)
+  # OpenCV defines targets with transitive dependencies not with namespaces but using opencv_ prefix. 
+  # This targets provide necessary include directories and linked flags.
+  find_package(OpenCVPkg REQUIRED
+    COMPONENTS
+      opencv_core
+      opencv_highgui
+  )
+
+  add_executable(uvc_test src/test.c)
+  target_link_libraries(uvc_test
+    PRIVATE
+      LibUVC::UVC
+      opencv_core
+      opencv_highgui
+  )
+endif()
+
+
+include(GNUInstallDirs)
+set(CMAKE_INSTALL_CMAKEDIR ${CMAKE_INSTALL_LIBDIR}/cmake/libuvc)
+
+install(
+  TARGETS ${UVC_TARGETS}
+  EXPORT libuvcTargets
+  LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+  ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+  RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+  INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
+  PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/libuvc
+)
+
+install(EXPORT libuvcTargets
+  FILE libuvcTargets.cmake
+  NAMESPACE LibUVC::
+  DESTINATION ${CMAKE_INSTALL_CMAKEDIR}
+)
+
+install(FILES 
+    cmake/FindLibUSB.cmake
+    cmake/FindJpegPkg.cmake
+  DESTINATION ${CMAKE_INSTALL_CMAKEDIR}
+)
+
+include(CMakePackageConfigHelpers)
+write_basic_package_version_file(libuvcConfigVersion.cmake
+  COMPATIBILITY AnyNewerVersion
+)
+
+install(FILES
+  ${CMAKE_CURRENT_BINARY_DIR}/libuvcConfigVersion.cmake
+  DESTINATION ${CMAKE_INSTALL_CMAKEDIR}
+)
+
+if(JPEG_FOUND)
+  # If we have used JPEG library we need to 
+  # add linker flag for it in config file for pkgconfig
+  set(PKGCONFIG_JPEG_LDFLAG "-ljpeg")
+endif()
+
+configure_file(libuvc.pc.in
+  ${PROJECT_BINARY_DIR}/libuvc.pc
+  @ONLY
+)
+
+install(FILES
+  ${CMAKE_CURRENT_BINARY_DIR}/libuvc.pc
+  DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig
+)
+
+install(FILES libuvcConfig.cmake
+  DESTINATION ${CMAKE_INSTALL_CMAKEDIR}
+)
+
+
diff --git a/3rdparty/libuvc/src/LICENSE.txt b/3rdparty/libuvc/src/LICENSE.txt
new file mode 100644
index 00000000..4acc5dde
--- /dev/null
+++ b/3rdparty/libuvc/src/LICENSE.txt
@@ -0,0 +1,31 @@
+Software License Agreement (BSD License)
+
+Copyright (C) 2010-2015 Ken Tossell
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+ * Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above
+   copyright notice, this list of conditions and the following
+   disclaimer in the documentation and/or other materials provided
+   with the distribution.
+ * Neither the name of the author nor other contributors may be
+   used to endorse or promote products derived from this software
+   without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
diff --git a/3rdparty/libuvc/src/README.md b/3rdparty/libuvc/src/README.md
new file mode 100644
index 00000000..c6a6e381
--- /dev/null
+++ b/3rdparty/libuvc/src/README.md
@@ -0,0 +1,29 @@
+`libuvc` is a cross-platform library for USB video devices, built atop `libusb`.
+It enables fine-grained control over USB video devices exporting the standard USB Video Class
+(UVC) interface, enabling developers to write drivers for previously unsupported devices,
+or just access UVC devices in a generic fashion.
+
+## Getting and Building libuvc
+
+Prerequisites: You will need `libusb` and [CMake](http://www.cmake.org/) installed.
+
+To build, you can just run these shell commands:
+
+    git clone https://github.com/libuvc/libuvc
+    cd libuvc
+    mkdir build
+    cd build
+    cmake ..
+    make && sudo make install
+
+and you're set! If you want to change the build configuration, you can edit `CMakeCache.txt`
+in the build directory, or use a CMake GUI to make the desired changes.
+
+There is also `BUILD_EXAMPLE` and `BUILD_TEST` options to enable the compilation of `example` and `uvc_test` programs. To use them, replace the `cmake ..` command above with `cmake .. -DBUILD_TEST=ON -DBUILD_EXAMPLE=ON`.
+Then you can start them with `./example` and `./uvc_test` respectively. Note that you need OpenCV to build the later (for displaying image).
+
+## Developing with libuvc
+
+The documentation for `libuvc` can currently be found at https://int80k.com/libuvc/doc/.
+
+Happy hacking!
diff --git a/3rdparty/libuvc/src/cameras/isight_imac.txt b/3rdparty/libuvc/src/cameras/isight_imac.txt
new file mode 100644
index 00000000..e3670256
--- /dev/null
+++ b/3rdparty/libuvc/src/cameras/isight_imac.txt
@@ -0,0 +1,228 @@
+
+Bus 001 Device 007: ID 05ac:8501 Apple, Inc. Built-in iSight [Micron]
+Device Descriptor:
+  bLength                18
+  bDescriptorType         1
+  bcdUSB               2.00
+  bDeviceClass          239 Miscellaneous Device
+  bDeviceSubClass         2 ?
+  bDeviceProtocol         1 Interface Association
+  bMaxPacketSize0        64
+  idVendor           0x05ac Apple, Inc.
+  idProduct          0x8501 Built-in iSight [Micron]
+  bcdDevice            1.89
+  iManufacturer           1 Micron
+  iProduct                2 Built-in iSight
+  iSerial                 0 
+  bNumConfigurations      1
+  Configuration Descriptor:
+    bLength                 9
+    bDescriptorType         2
+    wTotalLength          267
+    bNumInterfaces          2
+    bConfigurationValue     1
+    iConfiguration          0 
+    bmAttributes         0x80
+      (Bus Powered)
+    MaxPower              100mA
+    Interface Association:
+      bLength                 8
+      bDescriptorType        11
+      bFirstInterface         0
+      bInterfaceCount         2
+      bFunctionClass         14 Video
+      bFunctionSubClass       3 Video Interface Collection
+      bFunctionProtocol       0 
+      iFunction               0 
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        0
+      bAlternateSetting       0
+      bNumEndpoints           1
+      bInterfaceClass        14 Video
+      bInterfaceSubClass      1 Video Control
+      bInterfaceProtocol      0 
+      iInterface              0 
+      VideoControl Interface Descriptor:
+        bLength                13
+        bDescriptorType        36
+        bDescriptorSubtype      1 (HEADER)
+        bcdUVC               1.00
+        wTotalLength           49
+        dwClockFrequency       13.500000MHz
+        bInCollection           1
+        baInterfaceNr( 0)       1
+      VideoControl Interface Descriptor:
+        bLength                16
+        bDescriptorType        36
+        bDescriptorSubtype      2 (INPUT_TERMINAL)
+        bTerminalID             1
+        wTerminalType      0x0201 Camera Sensor
+        bAssocTerminal          0
+        iTerminal               0 
+        wObjectiveFocalLengthMin      0
+        wObjectiveFocalLengthMax      0
+        wOcularFocalLength            0
+        bControlSize                  1
+        bmControls           0x00000000
+      VideoControl Interface Descriptor:
+        bLength                11
+        bDescriptorType        36
+        bDescriptorSubtype      5 (PROCESSING_UNIT)
+      Warning: Descriptor too short
+        bUnitID                 2
+        bSourceID               1
+        wMaxMultiplier          0
+        bControlSize            2
+        bmControls     0x00000039
+          Brightness
+          Saturation
+          Sharpness
+          Gamma
+        iProcessing             0 
+        bmVideoStandards     0x 9
+          None
+          SECAM - 625/50
+      VideoControl Interface Descriptor:
+        bLength                 9
+        bDescriptorType        36
+        bDescriptorSubtype      3 (OUTPUT_TERMINAL)
+        bTerminalID             3
+        wTerminalType      0x0101 USB Streaming
+        bAssocTerminal          0
+        bSourceID               2
+        iTerminal               0 
+      Endpoint Descriptor:
+        bLength                 7
+        bDescriptorType         5
+        bEndpointAddress     0x81  EP 1 IN
+        bmAttributes            3
+          Transfer Type            Interrupt
+          Synch Type               None
+          Usage Type               Data
+        wMaxPacketSize     0x0008  1x 8 bytes
+        bInterval              10
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        1
+      bAlternateSetting       0
+      bNumEndpoints           0
+      bInterfaceClass        14 Video
+      bInterfaceSubClass      2 Video Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+      VideoStreaming Interface Descriptor:
+        bLength                            14
+        bDescriptorType                    36
+        bDescriptorSubtype                  1 (INPUT_HEADER)
+        bNumFormats                         1
+        wTotalLength                      155
+        bEndPointAddress                  130
+        bmInfo                              0
+        bTerminalLink                       3
+        bStillCaptureMethod                 0
+        bTriggerSupport                     0
+        bTriggerUsage                       0
+        bControlSize                        1
+        bmaControls( 0)                    27
+      VideoStreaming Interface Descriptor:
+        bLength                            27
+        bDescriptorType                    36
+        bDescriptorSubtype                  4 (FORMAT_UNCOMPRESSED)
+        bFormatIndex                        1
+        bNumFrameDescriptors                3
+        guidFormat                            {55595659-0000-1000-8000-00aa00389b71}
+        bBitsPerPixel                      16
+        bDefaultFrameIndex                  1
+        bAspectRatioX                       0
+        bAspectRatioY                       0
+        bmInterlaceFlags                 0x00
+          Interlaced stream or variable: No
+          Fields per frame: 1 fields
+          Field 1 first: No
+          Field pattern: Field 1 only
+          bCopyProtect                      0
+      VideoStreaming Interface Descriptor:
+        bLength                            38
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                         1
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            640
+        wHeight                           480
+        dwMinBitRate                383976960
+        dwMaxBitRate                383976960
+        dwMaxVideoFrameBufferSize      614400
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  0
+        dwMinFrameInterval             333333
+        dwMaxFrameInterval             333333
+        dwFrameIntervalStep                 0
+      VideoStreaming Interface Descriptor:
+        bLength                            38
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                         2
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            352
+        wHeight                           288
+        dwMinBitRate                383976960
+        dwMaxBitRate                383976960
+        dwMaxVideoFrameBufferSize      202752
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  0
+        dwMinFrameInterval             333333
+        dwMaxFrameInterval             333333
+        dwFrameIntervalStep                 0
+      VideoStreaming Interface Descriptor:
+        bLength                            38
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                         3
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            320
+        wHeight                           240
+        dwMinBitRate                383976960
+        dwMaxBitRate                383976960
+        dwMaxVideoFrameBufferSize      153600
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  0
+        dwMinFrameInterval             333333
+        dwMaxFrameInterval             333333
+        dwFrameIntervalStep                 0
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        1
+      bAlternateSetting       1
+      bNumEndpoints           1
+      bInterfaceClass        14 Video
+      bInterfaceSubClass      2 Video Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+      Endpoint Descriptor:
+        bLength                 7
+        bDescriptorType         5
+        bEndpointAddress     0x82  EP 2 IN
+        bmAttributes            5
+          Transfer Type            Isochronous
+          Synch Type               Asynchronous
+          Usage Type               Data
+        wMaxPacketSize     0x1400  3x 1024 bytes
+        bInterval               1
+Device Qualifier (for other device speed):
+  bLength                10
+  bDescriptorType         6
+  bcdUSB               2.00
+  bDeviceClass           14 Video
+  bDeviceSubClass         2 Video Streaming
+  bDeviceProtocol         0 
+  bMaxPacketSize0         8
+  bNumConfigurations      1
+Device Status:     0x0000
+  (Bus Powered)
diff --git a/3rdparty/libuvc/src/cameras/isight_macbook.txt b/3rdparty/libuvc/src/cameras/isight_macbook.txt
new file mode 100644
index 00000000..62d03376
--- /dev/null
+++ b/3rdparty/libuvc/src/cameras/isight_macbook.txt
@@ -0,0 +1,228 @@
+
+Bus 001 Device 010: ID 05ac:8501 Apple, Inc. Built-in iSight [Micron]
+Device Descriptor:
+  bLength                18
+  bDescriptorType         1
+  bcdUSB               2.00
+  bDeviceClass          239 Miscellaneous Device
+  bDeviceSubClass         2 ?
+  bDeviceProtocol         1 Interface Association
+  bMaxPacketSize0        64
+  idVendor           0x05ac Apple, Inc.
+  idProduct          0x8501 Built-in iSight [Micron]
+  bcdDevice            1.89
+  iManufacturer           1 Micron
+  iProduct                2 Built-in iSight
+  iSerial                 0 
+  bNumConfigurations      1
+  Configuration Descriptor:
+    bLength                 9
+    bDescriptorType         2
+    wTotalLength          267
+    bNumInterfaces          2
+    bConfigurationValue     1
+    iConfiguration          0 
+    bmAttributes         0x80
+      (Bus Powered)
+    MaxPower              100mA
+    Interface Association:
+      bLength                 8
+      bDescriptorType        11
+      bFirstInterface         0
+      bInterfaceCount         2
+      bFunctionClass         14 Video
+      bFunctionSubClass       3 Video Interface Collection
+      bFunctionProtocol       0 
+      iFunction               0 
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        0
+      bAlternateSetting       0
+      bNumEndpoints           1
+      bInterfaceClass        14 Video
+      bInterfaceSubClass      1 Video Control
+      bInterfaceProtocol      0 
+      iInterface              0 
+      VideoControl Interface Descriptor:
+        bLength                13
+        bDescriptorType        36
+        bDescriptorSubtype      1 (HEADER)
+        bcdUVC               1.00
+        wTotalLength           49
+        dwClockFrequency       13.500000MHz
+        bInCollection           1
+        baInterfaceNr( 0)       1
+      VideoControl Interface Descriptor:
+        bLength                16
+        bDescriptorType        36
+        bDescriptorSubtype      2 (INPUT_TERMINAL)
+        bTerminalID             1
+        wTerminalType      0x0201 Camera Sensor
+        bAssocTerminal          0
+        iTerminal               0 
+        wObjectiveFocalLengthMin      0
+        wObjectiveFocalLengthMax      0
+        wOcularFocalLength            0
+        bControlSize                  1
+        bmControls           0x00000000
+      VideoControl Interface Descriptor:
+        bLength                11
+        bDescriptorType        36
+        bDescriptorSubtype      5 (PROCESSING_UNIT)
+      Warning: Descriptor too short
+        bUnitID                 2
+        bSourceID               1
+        wMaxMultiplier          0
+        bControlSize            2
+        bmControls     0x00000039
+          Brightness
+          Saturation
+          Sharpness
+          Gamma
+        iProcessing             0 
+        bmVideoStandards     0x 9
+          None
+          SECAM - 625/50
+      VideoControl Interface Descriptor:
+        bLength                 9
+        bDescriptorType        36
+        bDescriptorSubtype      3 (OUTPUT_TERMINAL)
+        bTerminalID             3
+        wTerminalType      0x0101 USB Streaming
+        bAssocTerminal          0
+        bSourceID               2
+        iTerminal               0 
+      Endpoint Descriptor:
+        bLength                 7
+        bDescriptorType         5
+        bEndpointAddress     0x81  EP 1 IN
+        bmAttributes            3
+          Transfer Type            Interrupt
+          Synch Type               None
+          Usage Type               Data
+        wMaxPacketSize     0x0008  1x 8 bytes
+        bInterval              10
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        1
+      bAlternateSetting       0
+      bNumEndpoints           0
+      bInterfaceClass        14 Video
+      bInterfaceSubClass      2 Video Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+      VideoStreaming Interface Descriptor:
+        bLength                            14
+        bDescriptorType                    36
+        bDescriptorSubtype                  1 (INPUT_HEADER)
+        bNumFormats                         1
+        wTotalLength                      155
+        bEndPointAddress                  130
+        bmInfo                              0
+        bTerminalLink                       3
+        bStillCaptureMethod                 0
+        bTriggerSupport                     0
+        bTriggerUsage                       0
+        bControlSize                        1
+        bmaControls( 0)                    27
+      VideoStreaming Interface Descriptor:
+        bLength                            27
+        bDescriptorType                    36
+        bDescriptorSubtype                  4 (FORMAT_UNCOMPRESSED)
+        bFormatIndex                        1
+        bNumFrameDescriptors                3
+        guidFormat                            {55595659-0000-1000-8000-00aa00389b71}
+        bBitsPerPixel                      16
+        bDefaultFrameIndex                  1
+        bAspectRatioX                       0
+        bAspectRatioY                       0
+        bmInterlaceFlags                 0x00
+          Interlaced stream or variable: No
+          Fields per frame: 1 fields
+          Field 1 first: No
+          Field pattern: Field 1 only
+          bCopyProtect                      0
+      VideoStreaming Interface Descriptor:
+        bLength                            38
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                         1
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            640
+        wHeight                           480
+        dwMinBitRate                383976960
+        dwMaxBitRate                383976960
+        dwMaxVideoFrameBufferSize      614400
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  0
+        dwMinFrameInterval             333333
+        dwMaxFrameInterval             333333
+        dwFrameIntervalStep                 0
+      VideoStreaming Interface Descriptor:
+        bLength                            38
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                         2
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            352
+        wHeight                           288
+        dwMinBitRate                383976960
+        dwMaxBitRate                383976960
+        dwMaxVideoFrameBufferSize      202752
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  0
+        dwMinFrameInterval             333333
+        dwMaxFrameInterval             333333
+        dwFrameIntervalStep                 0
+      VideoStreaming Interface Descriptor:
+        bLength                            38
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                         3
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            320
+        wHeight                           240
+        dwMinBitRate                383976960
+        dwMaxBitRate                383976960
+        dwMaxVideoFrameBufferSize      153600
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  0
+        dwMinFrameInterval             333333
+        dwMaxFrameInterval             333333
+        dwFrameIntervalStep                 0
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        1
+      bAlternateSetting       1
+      bNumEndpoints           1
+      bInterfaceClass        14 Video
+      bInterfaceSubClass      2 Video Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+      Endpoint Descriptor:
+        bLength                 7
+        bDescriptorType         5
+        bEndpointAddress     0x82  EP 2 IN
+        bmAttributes            5
+          Transfer Type            Isochronous
+          Synch Type               Asynchronous
+          Usage Type               Data
+        wMaxPacketSize     0x1400  3x 1024 bytes
+        bInterval               1
+Device Qualifier (for other device speed):
+  bLength                10
+  bDescriptorType         6
+  bcdUSB               2.00
+  bDeviceClass           14 Video
+  bDeviceSubClass         2 Video Streaming
+  bDeviceProtocol         0 
+  bMaxPacketSize0         8
+  bNumConfigurations      1
+Device Status:     0x0000
+  (Bus Powered)
diff --git a/3rdparty/libuvc/src/cameras/logitech_hd_pro_920.txt b/3rdparty/libuvc/src/cameras/logitech_hd_pro_920.txt
new file mode 100644
index 00000000..2fbe69c6
--- /dev/null
+++ b/3rdparty/libuvc/src/cameras/logitech_hd_pro_920.txt
@@ -0,0 +1,1817 @@
+
+Bus 001 Device 018: ID 046d:082d Logitech, Inc. HD Pro Webcam C920
+Device Descriptor:
+  bLength                18
+  bDescriptorType         1
+  bcdUSB               2.00
+  bDeviceClass          239 Miscellaneous Device
+  bDeviceSubClass         2 ?
+  bDeviceProtocol         1 Interface Association
+  bMaxPacketSize0        64
+  idVendor           0x046d Logitech, Inc.
+  idProduct          0x082d HD Pro Webcam C920
+  bcdDevice            0.11
+  iManufacturer           0 
+  iProduct                2 HD Pro Webcam C920
+  iSerial                 1 E1CA2A7F
+  bNumConfigurations      1
+  Configuration Descriptor:
+    bLength                 9
+    bDescriptorType         2
+    wTotalLength         3452
+    bNumInterfaces          4
+    bConfigurationValue     1
+    iConfiguration          0 
+    bmAttributes         0x80
+      (Bus Powered)
+    MaxPower              500mA
+    Interface Association:
+      bLength                 8
+      bDescriptorType        11
+      bFirstInterface         0
+      bInterfaceCount         2
+      bFunctionClass         14 Video
+      bFunctionSubClass       3 Video Interface Collection
+      bFunctionProtocol       0 
+      iFunction               0 
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        0
+      bAlternateSetting       0
+      bNumEndpoints           1
+      bInterfaceClass        14 Video
+      bInterfaceSubClass      1 Video Control
+      bInterfaceProtocol      0 
+      iInterface              0 
+      VideoControl Interface Descriptor:
+        bLength                13
+        bDescriptorType        36
+        bDescriptorSubtype      1 (HEADER)
+        bcdUVC               1.00
+        wTotalLength          214
+        dwClockFrequency      300.000000MHz
+        bInCollection           1
+        baInterfaceNr( 0)       1
+      VideoControl Interface Descriptor:
+        bLength                18
+        bDescriptorType        36
+        bDescriptorSubtype      2 (INPUT_TERMINAL)
+        bTerminalID             1
+        wTerminalType      0x0201 Camera Sensor
+        bAssocTerminal          0
+        iTerminal               0 
+        wObjectiveFocalLengthMin      0
+        wObjectiveFocalLengthMax      0
+        wOcularFocalLength            0
+        bControlSize                  3
+        bmControls           0x00020a2e
+          Auto-Exposure Mode
+          Auto-Exposure Priority
+          Exposure Time (Absolute)
+          Focus (Absolute)
+          Zoom (Absolute)
+          PanTilt (Absolute)
+          Focus, Auto
+      VideoControl Interface Descriptor:
+        bLength                11
+        bDescriptorType        36
+        bDescriptorSubtype      5 (PROCESSING_UNIT)
+      Warning: Descriptor too short
+        bUnitID                 3
+        bSourceID               1
+        wMaxMultiplier      16384
+        bControlSize            2
+        bmControls     0x0000175b
+          Brightness
+          Contrast
+          Saturation
+          Sharpness
+          White Balance Temperature
+          Backlight Compensation
+          Gain
+          Power Line Frequency
+          White Balance Temperature, Auto
+        iProcessing             0 
+        bmVideoStandards     0x1b
+          None
+          NTSC - 525/60
+          SECAM - 625/50
+          NTSC - 625/50
+      VideoControl Interface Descriptor:
+        bLength                27
+        bDescriptorType        36
+        bDescriptorSubtype      6 (EXTENSION_UNIT)
+        bUnitID                 6
+        guidExtensionCode         {d09ee423-7811-314f-ae52-d2fb8a8d3b48}
+        bNumControl            10
+        bNrPins                 1
+        baSourceID( 0)          3
+        bControlSize            2
+        bmControls( 0)       0xff
+        bmControls( 1)       0x03
+        iExtension              0 
+      VideoControl Interface Descriptor:
+        bLength                27
+        bDescriptorType        36
+        bDescriptorSubtype      6 (EXTENSION_UNIT)
+        bUnitID                 8
+        guidExtensionCode         {e48e6769-0f41-db40-a850-7420d7d8240e}
+        bNumControl             7
+        bNrPins                 1
+        baSourceID( 0)          1
+        bControlSize            2
+        bmControls( 0)       0x3b
+        bmControls( 1)       0x03
+        iExtension              0 
+      VideoControl Interface Descriptor:
+        bLength                28
+        bDescriptorType        36
+        bDescriptorSubtype      6 (EXTENSION_UNIT)
+        bUnitID                 9
+        guidExtensionCode         {a94c5d1f-11de-8744-840d-50933c8ec8d1}
+        bNumControl            17
+        bNrPins                 1
+        baSourceID( 0)          1
+        bControlSize            3
+        bmControls( 0)       0xf3
+        bmControls( 1)       0xff
+        bmControls( 2)       0x23
+        iExtension              0 
+      VideoControl Interface Descriptor:
+        bLength                27
+        bDescriptorType        36
+        bDescriptorSubtype      6 (EXTENSION_UNIT)
+        bUnitID                10
+        guidExtensionCode         {1502e449-34f4-fe47-b158-0e885023e51b}
+        bNumControl             7
+        bNrPins                 1
+        baSourceID( 0)          1
+        bControlSize            2
+        bmControls( 0)       0xaa
+        bmControls( 1)       0x07
+        iExtension              0 
+      VideoControl Interface Descriptor:
+        bLength                27
+        bDescriptorType        36
+        bDescriptorSubtype      6 (EXTENSION_UNIT)
+        bUnitID                11
+        guidExtensionCode         {212de5ff-3080-2c4e-82d9-f587d00540bd}
+        bNumControl             2
+        bNrPins                 1
+        baSourceID( 0)          1
+        bControlSize            2
+        bmControls( 0)       0x00
+        bmControls( 1)       0x41
+        iExtension              0 
+      VideoControl Interface Descriptor:
+        bLength                27
+        bDescriptorType        36
+        bDescriptorSubtype      6 (EXTENSION_UNIT)
+        bUnitID                12
+        guidExtensionCode         {41769ea2-04de-e347-8b2b-f4341aff003b}
+        bNumControl            11
+        bNrPins                 1
+        baSourceID( 0)          3
+        bControlSize            2
+        bmControls( 0)       0x07
+        bmControls( 1)       0x7f
+        iExtension              0 
+      VideoControl Interface Descriptor:
+        bLength                 9
+        bDescriptorType        36
+        bDescriptorSubtype      3 (OUTPUT_TERMINAL)
+        bTerminalID             4
+        wTerminalType      0x0101 USB Streaming
+        bAssocTerminal          0
+        bSourceID               3
+        iTerminal               0 
+      Endpoint Descriptor:
+        bLength                 7
+        bDescriptorType         5
+        bEndpointAddress     0x83  EP 3 IN
+        bmAttributes            3
+          Transfer Type            Interrupt
+          Synch Type               None
+          Usage Type               Data
+        wMaxPacketSize     0x0040  1x 64 bytes
+        bInterval               8
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        1
+      bAlternateSetting       0
+      bNumEndpoints           0
+      bInterfaceClass        14 Video
+      bInterfaceSubClass      2 Video Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+      VideoStreaming Interface Descriptor:
+        bLength                            16
+        bDescriptorType                    36
+        bDescriptorSubtype                  1 (INPUT_HEADER)
+        bNumFormats                         3
+        wTotalLength                     2822
+        bEndPointAddress                  129
+        bmInfo                              0
+        bTerminalLink                       4
+        bStillCaptureMethod                 0
+        bTriggerSupport                     0
+        bTriggerUsage                       0
+        bControlSize                        1
+        bmaControls( 0)                    27
+        bmaControls( 1)                    27
+        bmaControls( 2)                    27
+      VideoStreaming Interface Descriptor:
+        bLength                            27
+        bDescriptorType                    36
+        bDescriptorSubtype                  4 (FORMAT_UNCOMPRESSED)
+        bFormatIndex                        1
+        bNumFrameDescriptors               19
+        guidFormat                            {59555932-0000-1000-8000-00aa00389b71}
+        bBitsPerPixel                      16
+        bDefaultFrameIndex                  1
+        bAspectRatioX                       0
+        bAspectRatioY                       0
+        bmInterlaceFlags                 0x00
+          Interlaced stream or variable: No
+          Fields per frame: 2 fields
+          Field 1 first: No
+          Field pattern: Field 1 only
+          bCopyProtect                      0
+      VideoStreaming Interface Descriptor:
+        bLength                            54
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                         1
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            640
+        wHeight                           480
+        dwMinBitRate                 24576000
+        dwMaxBitRate                147456000
+        dwMaxVideoFrameBufferSize      614400
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  7
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            416666
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           1333333
+        dwFrameInterval( 6)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            54
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                         2
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            160
+        wHeight                            90
+        dwMinBitRate                  1152000
+        dwMaxBitRate                  6912000
+        dwMaxVideoFrameBufferSize       28800
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  7
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            416666
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           1333333
+        dwFrameInterval( 6)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            54
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                         3
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            160
+        wHeight                           120
+        dwMinBitRate                  1536000
+        dwMaxBitRate                  9216000
+        dwMaxVideoFrameBufferSize       38400
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  7
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            416666
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           1333333
+        dwFrameInterval( 6)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            54
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                         4
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            176
+        wHeight                           144
+        dwMinBitRate                  2027520
+        dwMaxBitRate                 12165120
+        dwMaxVideoFrameBufferSize       50688
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  7
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            416666
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           1333333
+        dwFrameInterval( 6)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            54
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                         5
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            320
+        wHeight                           180
+        dwMinBitRate                  4608000
+        dwMaxBitRate                 27648000
+        dwMaxVideoFrameBufferSize      115200
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  7
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            416666
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           1333333
+        dwFrameInterval( 6)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            54
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                         6
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            320
+        wHeight                           240
+        dwMinBitRate                  6144000
+        dwMaxBitRate                 36864000
+        dwMaxVideoFrameBufferSize      153600
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  7
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            416666
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           1333333
+        dwFrameInterval( 6)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            54
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                         7
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            352
+        wHeight                           288
+        dwMinBitRate                  8110080
+        dwMaxBitRate                 48660480
+        dwMaxVideoFrameBufferSize      202752
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  7
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            416666
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           1333333
+        dwFrameInterval( 6)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            54
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                         8
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            432
+        wHeight                           240
+        dwMinBitRate                  8294400
+        dwMaxBitRate                 49766400
+        dwMaxVideoFrameBufferSize      207360
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  7
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            416666
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           1333333
+        dwFrameInterval( 6)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            54
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                         9
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            640
+        wHeight                           360
+        dwMinBitRate                 18432000
+        dwMaxBitRate                110592000
+        dwMaxVideoFrameBufferSize      460800
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  7
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            416666
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           1333333
+        dwFrameInterval( 6)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            54
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                        10
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            800
+        wHeight                           448
+        dwMinBitRate                 28672000
+        dwMaxBitRate                172032000
+        dwMaxVideoFrameBufferSize      716800
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  7
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            416666
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           1333333
+        dwFrameInterval( 6)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            50
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                        11
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            800
+        wHeight                           600
+        dwMinBitRate                 38400000
+        dwMaxBitRate                184320000
+        dwMaxVideoFrameBufferSize      960000
+        dwDefaultFrameInterval         416666
+        bFrameIntervalType                  6
+        dwFrameInterval( 0)            416666
+        dwFrameInterval( 1)            500000
+        dwFrameInterval( 2)            666666
+        dwFrameInterval( 3)           1000000
+        dwFrameInterval( 4)           1333333
+        dwFrameInterval( 5)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            50
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                        12
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            864
+        wHeight                           480
+        dwMinBitRate                 33177600
+        dwMaxBitRate                159252480
+        dwMaxVideoFrameBufferSize      829440
+        dwDefaultFrameInterval         416666
+        bFrameIntervalType                  6
+        dwFrameInterval( 0)            416666
+        dwFrameInterval( 1)            500000
+        dwFrameInterval( 2)            666666
+        dwFrameInterval( 3)           1000000
+        dwFrameInterval( 4)           1333333
+        dwFrameInterval( 5)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            42
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                        13
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            960
+        wHeight                           720
+        dwMinBitRate                 55296000
+        dwMaxBitRate                165888000
+        dwMaxVideoFrameBufferSize     1382400
+        dwDefaultFrameInterval         666666
+        bFrameIntervalType                  4
+        dwFrameInterval( 0)            666666
+        dwFrameInterval( 1)           1000000
+        dwFrameInterval( 2)           1333333
+        dwFrameInterval( 3)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            42
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                        14
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                           1024
+        wHeight                           576
+        dwMinBitRate                 47185920
+        dwMaxBitRate                141557760
+        dwMaxVideoFrameBufferSize     1179648
+        dwDefaultFrameInterval         666666
+        bFrameIntervalType                  4
+        dwFrameInterval( 0)            666666
+        dwFrameInterval( 1)           1000000
+        dwFrameInterval( 2)           1333333
+        dwFrameInterval( 3)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            38
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                        15
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                           1280
+        wHeight                           720
+        dwMinBitRate                 73728000
+        dwMaxBitRate                147456000
+        dwMaxVideoFrameBufferSize     1843200
+        dwDefaultFrameInterval        1000000
+        bFrameIntervalType                  3
+        dwFrameInterval( 0)           1000000
+        dwFrameInterval( 1)           1333333
+        dwFrameInterval( 2)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            34
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                        16
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                           1600
+        wHeight                           896
+        dwMinBitRate                114688000
+        dwMaxBitRate                172032000
+        dwMaxVideoFrameBufferSize     2867200
+        dwDefaultFrameInterval        1333333
+        bFrameIntervalType                  2
+        dwFrameInterval( 0)           1333333
+        dwFrameInterval( 1)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            30
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                        17
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                           1920
+        wHeight                          1080
+        dwMinBitRate                165888000
+        dwMaxBitRate                165888000
+        dwMaxVideoFrameBufferSize     4147200
+        dwDefaultFrameInterval        2000000
+        bFrameIntervalType                  1
+        dwFrameInterval( 0)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            30
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                        18
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                           2304
+        wHeight                          1296
+        dwMinBitRate                238878720
+        dwMaxBitRate                238878720
+        dwMaxVideoFrameBufferSize     5971968
+        dwDefaultFrameInterval        4999998
+        bFrameIntervalType                  1
+        dwFrameInterval( 0)           4999998
+      VideoStreaming Interface Descriptor:
+        bLength                            30
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                        19
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                           2304
+        wHeight                          1536
+        dwMinBitRate                283115520
+        dwMaxBitRate                283115520
+        dwMaxVideoFrameBufferSize     7077888
+        dwDefaultFrameInterval        4999998
+        bFrameIntervalType                  1
+        dwFrameInterval( 0)           4999998
+      VideoStreaming Interface Descriptor:
+        bLength                             6
+        bDescriptorType                    36
+        bDescriptorSubtype                 13 (COLORFORMAT)
+        bColorPrimaries                     1 (BT.709,sRGB)
+        bTransferCharacteristics            1 (BT.709)
+        bMatrixCoefficients                 4 (SMPTE 170M (BT.601))
+      VideoStreaming Interface Descriptor:
+        bLength                            28
+        bDescriptorType                    36
+        bDescriptorSubtype                 16 (FORMAT_FRAME_BASED)
+        bFormatIndex                        2
+        bNumFrameDescriptors               17
+        guidFormat                            {48323634-0000-1000-8000-00aa00389b71}
+        bBitsPerPixel                      16
+        bDefaultFrameIndex                  1
+        bAspectRatioX                       0
+        bAspectRatioY                       0
+        bmInterlaceFlags                 0x00
+          Interlaced stream or variable: No
+          Fields per frame: 2 fields
+          Field 1 first: No
+          Field pattern: Field 1 only
+          bCopyProtect                      0
+          bVariableSize                     1
+      VideoStreaming Interface Descriptor:
+        bLength                            54
+        bDescriptorType                    36
+        bDescriptorSubtype                 17 (FRAME_FRAME_BASED)
+        bFrameIndex                         1
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            640
+        wHeight                           480
+        dwMinBitRate                 24576000
+        dwMaxBitRate                147456000
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  7
+        dwBytesPerLine                      0
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            416666
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           1333333
+        dwFrameInterval( 6)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            54
+        bDescriptorType                    36
+        bDescriptorSubtype                 17 (FRAME_FRAME_BASED)
+        bFrameIndex                         2
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            160
+        wHeight                            90
+        dwMinBitRate                  1152000
+        dwMaxBitRate                  6912000
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  7
+        dwBytesPerLine                      0
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            416666
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           1333333
+        dwFrameInterval( 6)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            54
+        bDescriptorType                    36
+        bDescriptorSubtype                 17 (FRAME_FRAME_BASED)
+        bFrameIndex                         3
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            160
+        wHeight                           120
+        dwMinBitRate                  1536000
+        dwMaxBitRate                  9216000
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  7
+        dwBytesPerLine                      0
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            416666
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           1333333
+        dwFrameInterval( 6)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            54
+        bDescriptorType                    36
+        bDescriptorSubtype                 17 (FRAME_FRAME_BASED)
+        bFrameIndex                         4
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            176
+        wHeight                           144
+        dwMinBitRate                  2027520
+        dwMaxBitRate                 12165120
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  7
+        dwBytesPerLine                      0
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            416666
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           1333333
+        dwFrameInterval( 6)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            54
+        bDescriptorType                    36
+        bDescriptorSubtype                 17 (FRAME_FRAME_BASED)
+        bFrameIndex                         5
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            320
+        wHeight                           180
+        dwMinBitRate                  4608000
+        dwMaxBitRate                 27648000
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  7
+        dwBytesPerLine                      0
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            416666
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           1333333
+        dwFrameInterval( 6)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            54
+        bDescriptorType                    36
+        bDescriptorSubtype                 17 (FRAME_FRAME_BASED)
+        bFrameIndex                         6
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            320
+        wHeight                           240
+        dwMinBitRate                  6144000
+        dwMaxBitRate                 36864000
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  7
+        dwBytesPerLine                      0
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            416666
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           1333333
+        dwFrameInterval( 6)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            54
+        bDescriptorType                    36
+        bDescriptorSubtype                 17 (FRAME_FRAME_BASED)
+        bFrameIndex                         7
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            352
+        wHeight                           288
+        dwMinBitRate                  8110080
+        dwMaxBitRate                 48660480
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  7
+        dwBytesPerLine                      0
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            416666
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           1333333
+        dwFrameInterval( 6)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            54
+        bDescriptorType                    36
+        bDescriptorSubtype                 17 (FRAME_FRAME_BASED)
+        bFrameIndex                         8
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            432
+        wHeight                           240
+        dwMinBitRate                  8294400
+        dwMaxBitRate                 49766400
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  7
+        dwBytesPerLine                      0
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            416666
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           1333333
+        dwFrameInterval( 6)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            54
+        bDescriptorType                    36
+        bDescriptorSubtype                 17 (FRAME_FRAME_BASED)
+        bFrameIndex                         9
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            640
+        wHeight                           360
+        dwMinBitRate                 18432000
+        dwMaxBitRate                110592000
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  7
+        dwBytesPerLine                      0
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            416666
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           1333333
+        dwFrameInterval( 6)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            54
+        bDescriptorType                    36
+        bDescriptorSubtype                 17 (FRAME_FRAME_BASED)
+        bFrameIndex                        10
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            800
+        wHeight                           448
+        dwMinBitRate                 28672000
+        dwMaxBitRate                172032000
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  7
+        dwBytesPerLine                      0
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            416666
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           1333333
+        dwFrameInterval( 6)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            54
+        bDescriptorType                    36
+        bDescriptorSubtype                 17 (FRAME_FRAME_BASED)
+        bFrameIndex                        11
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            800
+        wHeight                           600
+        dwMinBitRate                 38400000
+        dwMaxBitRate                230400000
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  7
+        dwBytesPerLine                      0
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            416666
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           1333333
+        dwFrameInterval( 6)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            54
+        bDescriptorType                    36
+        bDescriptorSubtype                 17 (FRAME_FRAME_BASED)
+        bFrameIndex                        12
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            864
+        wHeight                           480
+        dwMinBitRate                 33177600
+        dwMaxBitRate                199065600
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  7
+        dwBytesPerLine                      0
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            416666
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           1333333
+        dwFrameInterval( 6)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            54
+        bDescriptorType                    36
+        bDescriptorSubtype                 17 (FRAME_FRAME_BASED)
+        bFrameIndex                        13
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            960
+        wHeight                           720
+        dwMinBitRate                 55296000
+        dwMaxBitRate                331776000
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  7
+        dwBytesPerLine                      0
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            416666
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           1333333
+        dwFrameInterval( 6)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            54
+        bDescriptorType                    36
+        bDescriptorSubtype                 17 (FRAME_FRAME_BASED)
+        bFrameIndex                        14
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                           1024
+        wHeight                           576
+        dwMinBitRate                 47185920
+        dwMaxBitRate                283115520
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  7
+        dwBytesPerLine                      0
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            416666
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           1333333
+        dwFrameInterval( 6)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            54
+        bDescriptorType                    36
+        bDescriptorSubtype                 17 (FRAME_FRAME_BASED)
+        bFrameIndex                        15
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                           1280
+        wHeight                           720
+        dwMinBitRate                 73728000
+        dwMaxBitRate                442368000
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  7
+        dwBytesPerLine                      0
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            416666
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           1333333
+        dwFrameInterval( 6)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            54
+        bDescriptorType                    36
+        bDescriptorSubtype                 17 (FRAME_FRAME_BASED)
+        bFrameIndex                        16
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                           1600
+        wHeight                           896
+        dwMinBitRate                114688000
+        dwMaxBitRate                688128000
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  7
+        dwBytesPerLine                      0
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            416666
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           1333333
+        dwFrameInterval( 6)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            54
+        bDescriptorType                    36
+        bDescriptorSubtype                 17 (FRAME_FRAME_BASED)
+        bFrameIndex                        17
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                           1920
+        wHeight                          1080
+        dwMinBitRate                165888000
+        dwMaxBitRate                995328000
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  7
+        dwBytesPerLine                      0
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            416666
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           1333333
+        dwFrameInterval( 6)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                             6
+        bDescriptorType                    36
+        bDescriptorSubtype                 13 (COLORFORMAT)
+        bColorPrimaries                     1 (BT.709,sRGB)
+        bTransferCharacteristics            1 (BT.709)
+        bMatrixCoefficients                 4 (SMPTE 170M (BT.601))
+      VideoStreaming Interface Descriptor:
+        bLength                            11
+        bDescriptorType                    36
+        bDescriptorSubtype                  6 (FORMAT_MJPEG)
+        bFormatIndex                        3
+        bNumFrameDescriptors               17
+        bFlags                              1
+          Fixed-size samples: Yes
+        bDefaultFrameIndex                  1
+        bAspectRatioX                       0
+        bAspectRatioY                       0
+        bmInterlaceFlags                 0x00
+          Interlaced stream or variable: No
+          Fields per frame: 1 fields
+          Field 1 first: No
+          Field pattern: Field 1 only
+          bCopyProtect                      0
+      VideoStreaming Interface Descriptor:
+        bLength                            54
+        bDescriptorType                    36
+        bDescriptorSubtype                  7 (FRAME_MJPEG)
+        bFrameIndex                         1
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            640
+        wHeight                           480
+        dwMinBitRate                 24576000
+        dwMaxBitRate                147456000
+        dwMaxVideoFrameBufferSize      614400
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  7
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            416666
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           1333333
+        dwFrameInterval( 6)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            54
+        bDescriptorType                    36
+        bDescriptorSubtype                  7 (FRAME_MJPEG)
+        bFrameIndex                         2
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            160
+        wHeight                            90
+        dwMinBitRate                  1152000
+        dwMaxBitRate                  6912000
+        dwMaxVideoFrameBufferSize       28800
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  7
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            416666
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           1333333
+        dwFrameInterval( 6)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            54
+        bDescriptorType                    36
+        bDescriptorSubtype                  7 (FRAME_MJPEG)
+        bFrameIndex                         3
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            160
+        wHeight                           120
+        dwMinBitRate                  1536000
+        dwMaxBitRate                  9216000
+        dwMaxVideoFrameBufferSize       38400
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  7
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            416666
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           1333333
+        dwFrameInterval( 6)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            54
+        bDescriptorType                    36
+        bDescriptorSubtype                  7 (FRAME_MJPEG)
+        bFrameIndex                         4
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            176
+        wHeight                           144
+        dwMinBitRate                  2027520
+        dwMaxBitRate                 12165120
+        dwMaxVideoFrameBufferSize       50688
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  7
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            416666
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           1333333
+        dwFrameInterval( 6)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            54
+        bDescriptorType                    36
+        bDescriptorSubtype                  7 (FRAME_MJPEG)
+        bFrameIndex                         5
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            320
+        wHeight                           180
+        dwMinBitRate                  4608000
+        dwMaxBitRate                 27648000
+        dwMaxVideoFrameBufferSize      115200
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  7
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            416666
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           1333333
+        dwFrameInterval( 6)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            54
+        bDescriptorType                    36
+        bDescriptorSubtype                  7 (FRAME_MJPEG)
+        bFrameIndex                         6
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            320
+        wHeight                           240
+        dwMinBitRate                  6144000
+        dwMaxBitRate                 36864000
+        dwMaxVideoFrameBufferSize      153600
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  7
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            416666
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           1333333
+        dwFrameInterval( 6)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            54
+        bDescriptorType                    36
+        bDescriptorSubtype                  7 (FRAME_MJPEG)
+        bFrameIndex                         7
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            352
+        wHeight                           288
+        dwMinBitRate                  8110080
+        dwMaxBitRate                 48660480
+        dwMaxVideoFrameBufferSize      202752
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  7
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            416666
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           1333333
+        dwFrameInterval( 6)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            54
+        bDescriptorType                    36
+        bDescriptorSubtype                  7 (FRAME_MJPEG)
+        bFrameIndex                         8
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            432
+        wHeight                           240
+        dwMinBitRate                  8294400
+        dwMaxBitRate                 49766400
+        dwMaxVideoFrameBufferSize      207360
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  7
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            416666
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           1333333
+        dwFrameInterval( 6)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            54
+        bDescriptorType                    36
+        bDescriptorSubtype                  7 (FRAME_MJPEG)
+        bFrameIndex                         9
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            640
+        wHeight                           360
+        dwMinBitRate                 18432000
+        dwMaxBitRate                110592000
+        dwMaxVideoFrameBufferSize      460800
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  7
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            416666
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           1333333
+        dwFrameInterval( 6)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            54
+        bDescriptorType                    36
+        bDescriptorSubtype                  7 (FRAME_MJPEG)
+        bFrameIndex                        10
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            800
+        wHeight                           448
+        dwMinBitRate                 28672000
+        dwMaxBitRate                172032000
+        dwMaxVideoFrameBufferSize      716800
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  7
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            416666
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           1333333
+        dwFrameInterval( 6)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            54
+        bDescriptorType                    36
+        bDescriptorSubtype                  7 (FRAME_MJPEG)
+        bFrameIndex                        11
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            800
+        wHeight                           600
+        dwMinBitRate                 38400000
+        dwMaxBitRate                230400000
+        dwMaxVideoFrameBufferSize      960000
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  7
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            416666
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           1333333
+        dwFrameInterval( 6)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            54
+        bDescriptorType                    36
+        bDescriptorSubtype                  7 (FRAME_MJPEG)
+        bFrameIndex                        12
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            864
+        wHeight                           480
+        dwMinBitRate                 33177600
+        dwMaxBitRate                199065600
+        dwMaxVideoFrameBufferSize      829440
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  7
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            416666
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           1333333
+        dwFrameInterval( 6)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            54
+        bDescriptorType                    36
+        bDescriptorSubtype                  7 (FRAME_MJPEG)
+        bFrameIndex                        13
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            960
+        wHeight                           720
+        dwMinBitRate                 55296000
+        dwMaxBitRate                331776000
+        dwMaxVideoFrameBufferSize     1382400
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  7
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            416666
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           1333333
+        dwFrameInterval( 6)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            54
+        bDescriptorType                    36
+        bDescriptorSubtype                  7 (FRAME_MJPEG)
+        bFrameIndex                        14
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                           1024
+        wHeight                           576
+        dwMinBitRate                 47185920
+        dwMaxBitRate                283115520
+        dwMaxVideoFrameBufferSize     1179648
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  7
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            416666
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           1333333
+        dwFrameInterval( 6)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            54
+        bDescriptorType                    36
+        bDescriptorSubtype                  7 (FRAME_MJPEG)
+        bFrameIndex                        15
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                           1280
+        wHeight                           720
+        dwMinBitRate                 73728000
+        dwMaxBitRate                442368000
+        dwMaxVideoFrameBufferSize     1843200
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  7
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            416666
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           1333333
+        dwFrameInterval( 6)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            54
+        bDescriptorType                    36
+        bDescriptorSubtype                  7 (FRAME_MJPEG)
+        bFrameIndex                        16
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                           1600
+        wHeight                           896
+        dwMinBitRate                114688000
+        dwMaxBitRate                688128000
+        dwMaxVideoFrameBufferSize     2867200
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  7
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            416666
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           1333333
+        dwFrameInterval( 6)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            54
+        bDescriptorType                    36
+        bDescriptorSubtype                  7 (FRAME_MJPEG)
+        bFrameIndex                        17
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                           1920
+        wHeight                          1080
+        dwMinBitRate                165888000
+        dwMaxBitRate                995328000
+        dwMaxVideoFrameBufferSize     4147200
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  7
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            416666
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           1333333
+        dwFrameInterval( 6)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                             6
+        bDescriptorType                    36
+        bDescriptorSubtype                 13 (COLORFORMAT)
+        bColorPrimaries                     1 (BT.709,sRGB)
+        bTransferCharacteristics            1 (BT.709)
+        bMatrixCoefficients                 4 (SMPTE 170M (BT.601))
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        1
+      bAlternateSetting       1
+      bNumEndpoints           1
+      bInterfaceClass        14 Video
+      bInterfaceSubClass      2 Video Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+      Endpoint Descriptor:
+        bLength                 7
+        bDescriptorType         5
+        bEndpointAddress     0x81  EP 1 IN
+        bmAttributes            5
+          Transfer Type            Isochronous
+          Synch Type               Asynchronous
+          Usage Type               Data
+        wMaxPacketSize     0x00c0  1x 192 bytes
+        bInterval               1
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        1
+      bAlternateSetting       2
+      bNumEndpoints           1
+      bInterfaceClass        14 Video
+      bInterfaceSubClass      2 Video Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+      Endpoint Descriptor:
+        bLength                 7
+        bDescriptorType         5
+        bEndpointAddress     0x81  EP 1 IN
+        bmAttributes            5
+          Transfer Type            Isochronous
+          Synch Type               Asynchronous
+          Usage Type               Data
+        wMaxPacketSize     0x0180  1x 384 bytes
+        bInterval               1
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        1
+      bAlternateSetting       3
+      bNumEndpoints           1
+      bInterfaceClass        14 Video
+      bInterfaceSubClass      2 Video Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+      Endpoint Descriptor:
+        bLength                 7
+        bDescriptorType         5
+        bEndpointAddress     0x81  EP 1 IN
+        bmAttributes            5
+          Transfer Type            Isochronous
+          Synch Type               Asynchronous
+          Usage Type               Data
+        wMaxPacketSize     0x0200  1x 512 bytes
+        bInterval               1
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        1
+      bAlternateSetting       4
+      bNumEndpoints           1
+      bInterfaceClass        14 Video
+      bInterfaceSubClass      2 Video Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+      Endpoint Descriptor:
+        bLength                 7
+        bDescriptorType         5
+        bEndpointAddress     0x81  EP 1 IN
+        bmAttributes            5
+          Transfer Type            Isochronous
+          Synch Type               Asynchronous
+          Usage Type               Data
+        wMaxPacketSize     0x0280  1x 640 bytes
+        bInterval               1
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        1
+      bAlternateSetting       5
+      bNumEndpoints           1
+      bInterfaceClass        14 Video
+      bInterfaceSubClass      2 Video Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+      Endpoint Descriptor:
+        bLength                 7
+        bDescriptorType         5
+        bEndpointAddress     0x81  EP 1 IN
+        bmAttributes            5
+          Transfer Type            Isochronous
+          Synch Type               Asynchronous
+          Usage Type               Data
+        wMaxPacketSize     0x0320  1x 800 bytes
+        bInterval               1
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        1
+      bAlternateSetting       6
+      bNumEndpoints           1
+      bInterfaceClass        14 Video
+      bInterfaceSubClass      2 Video Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+      Endpoint Descriptor:
+        bLength                 7
+        bDescriptorType         5
+        bEndpointAddress     0x81  EP 1 IN
+        bmAttributes            5
+          Transfer Type            Isochronous
+          Synch Type               Asynchronous
+          Usage Type               Data
+        wMaxPacketSize     0x03b0  1x 944 bytes
+        bInterval               1
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        1
+      bAlternateSetting       7
+      bNumEndpoints           1
+      bInterfaceClass        14 Video
+      bInterfaceSubClass      2 Video Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+      Endpoint Descriptor:
+        bLength                 7
+        bDescriptorType         5
+        bEndpointAddress     0x81  EP 1 IN
+        bmAttributes            5
+          Transfer Type            Isochronous
+          Synch Type               Asynchronous
+          Usage Type               Data
+        wMaxPacketSize     0x0a80  2x 640 bytes
+        bInterval               1
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        1
+      bAlternateSetting       8
+      bNumEndpoints           1
+      bInterfaceClass        14 Video
+      bInterfaceSubClass      2 Video Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+      Endpoint Descriptor:
+        bLength                 7
+        bDescriptorType         5
+        bEndpointAddress     0x81  EP 1 IN
+        bmAttributes            5
+          Transfer Type            Isochronous
+          Synch Type               Asynchronous
+          Usage Type               Data
+        wMaxPacketSize     0x0b20  2x 800 bytes
+        bInterval               1
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        1
+      bAlternateSetting       9
+      bNumEndpoints           1
+      bInterfaceClass        14 Video
+      bInterfaceSubClass      2 Video Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+      Endpoint Descriptor:
+        bLength                 7
+        bDescriptorType         5
+        bEndpointAddress     0x81  EP 1 IN
+        bmAttributes            5
+          Transfer Type            Isochronous
+          Synch Type               Asynchronous
+          Usage Type               Data
+        wMaxPacketSize     0x0be0  2x 992 bytes
+        bInterval               1
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        1
+      bAlternateSetting      10
+      bNumEndpoints           1
+      bInterfaceClass        14 Video
+      bInterfaceSubClass      2 Video Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+      Endpoint Descriptor:
+        bLength                 7
+        bDescriptorType         5
+        bEndpointAddress     0x81  EP 1 IN
+        bmAttributes            5
+          Transfer Type            Isochronous
+          Synch Type               Asynchronous
+          Usage Type               Data
+        wMaxPacketSize     0x1380  3x 896 bytes
+        bInterval               1
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        1
+      bAlternateSetting      11
+      bNumEndpoints           1
+      bInterfaceClass        14 Video
+      bInterfaceSubClass      2 Video Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+      Endpoint Descriptor:
+        bLength                 7
+        bDescriptorType         5
+        bEndpointAddress     0x81  EP 1 IN
+        bmAttributes            5
+          Transfer Type            Isochronous
+          Synch Type               Asynchronous
+          Usage Type               Data
+        wMaxPacketSize     0x13fc  3x 1020 bytes
+        bInterval               1
+    Interface Association:
+      bLength                 8
+      bDescriptorType        11
+      bFirstInterface         2
+      bInterfaceCount         2
+      bFunctionClass          1 Audio
+      bFunctionSubClass       2 Streaming
+      bFunctionProtocol       0 
+      iFunction               0 
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        2
+      bAlternateSetting       0
+      bNumEndpoints           0
+      bInterfaceClass         1 Audio
+      bInterfaceSubClass      1 Control Device
+      bInterfaceProtocol      0 
+      iInterface              0 
+      AudioControl Interface Descriptor:
+        bLength                 9
+        bDescriptorType        36
+        bDescriptorSubtype      1 (HEADER)
+        bcdADC               1.00
+        wTotalLength           38
+        bInCollection           1
+        baInterfaceNr( 0)       3
+      AudioControl Interface Descriptor:
+        bLength                12
+        bDescriptorType        36
+        bDescriptorSubtype      2 (INPUT_TERMINAL)
+        bTerminalID             1
+        wTerminalType      0x0201 Microphone
+        bAssocTerminal          0
+        bNrChannels             1
+        wChannelConfig     0x0003
+          Left Front (L)
+          Right Front (R)
+        iChannelNames           0 
+        iTerminal               0 
+      AudioControl Interface Descriptor:
+        bLength                 9
+        bDescriptorType        36
+        bDescriptorSubtype      3 (OUTPUT_TERMINAL)
+        bTerminalID             3
+        wTerminalType      0x0101 USB Streaming
+        bAssocTerminal          0
+        bSourceID               5
+        iTerminal               0 
+      AudioControl Interface Descriptor:
+        bLength                 8
+        bDescriptorType        36
+        bDescriptorSubtype      6 (FEATURE_UNIT)
+        bUnitID                 5
+        bSourceID               1
+        bControlSize            1
+        bmaControls( 0)      0x03
+          Mute Control
+          Volume Control
+        iFeature                0 
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        3
+      bAlternateSetting       0
+      bNumEndpoints           0
+      bInterfaceClass         1 Audio
+      bInterfaceSubClass      2 Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        3
+      bAlternateSetting       1
+      bNumEndpoints           1
+      bInterfaceClass         1 Audio
+      bInterfaceSubClass      2 Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+      AudioStreaming Interface Descriptor:
+        bLength                 7
+        bDescriptorType        36
+        bDescriptorSubtype      1 (AS_GENERAL)
+        bTerminalLink           3
+        bDelay                255 frames
+        wFormatTag              1 PCM
+      AudioStreaming Interface Descriptor:
+        bLength                11
+        bDescriptorType        36
+        bDescriptorSubtype      2 (FORMAT_TYPE)
+        bFormatType             1 (FORMAT_TYPE_I)
+        bNrChannels             2
+        bSubframeSize           2
+        bBitResolution         16
+        bSamFreqType            1 Discrete
+        tSamFreq[ 0]        16000
+      Endpoint Descriptor:
+        bLength                 9
+        bDescriptorType         5
+        bEndpointAddress     0x82  EP 2 IN
+        bmAttributes            5
+          Transfer Type            Isochronous
+          Synch Type               Asynchronous
+          Usage Type               Data
+        wMaxPacketSize     0x0044  1x 68 bytes
+        bInterval               4
+        bRefresh                0
+        bSynchAddress           0
+        AudioControl Endpoint Descriptor:
+          bLength                 7
+          bDescriptorType        37
+          bDescriptorSubtype      1 (EP_GENERAL)
+          bmAttributes         0x01
+            Sampling Frequency
+          bLockDelayUnits         0 Undefined
+          wLockDelay              0 Undefined
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        3
+      bAlternateSetting       2
+      bNumEndpoints           1
+      bInterfaceClass         1 Audio
+      bInterfaceSubClass      2 Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+      AudioStreaming Interface Descriptor:
+        bLength                 7
+        bDescriptorType        36
+        bDescriptorSubtype      1 (AS_GENERAL)
+        bTerminalLink           3
+        bDelay                255 frames
+        wFormatTag              1 PCM
+      AudioStreaming Interface Descriptor:
+        bLength                11
+        bDescriptorType        36
+        bDescriptorSubtype      2 (FORMAT_TYPE)
+        bFormatType             1 (FORMAT_TYPE_I)
+        bNrChannels             2
+        bSubframeSize           2
+        bBitResolution         16
+        bSamFreqType            1 Discrete
+        tSamFreq[ 0]        24000
+      Endpoint Descriptor:
+        bLength                 9
+        bDescriptorType         5
+        bEndpointAddress     0x82  EP 2 IN
+        bmAttributes            5
+          Transfer Type            Isochronous
+          Synch Type               Asynchronous
+          Usage Type               Data
+        wMaxPacketSize     0x0064  1x 100 bytes
+        bInterval               4
+        bRefresh                0
+        bSynchAddress           0
+        AudioControl Endpoint Descriptor:
+          bLength                 7
+          bDescriptorType        37
+          bDescriptorSubtype      1 (EP_GENERAL)
+          bmAttributes         0x01
+            Sampling Frequency
+          bLockDelayUnits         0 Undefined
+          wLockDelay              0 Undefined
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        3
+      bAlternateSetting       3
+      bNumEndpoints           1
+      bInterfaceClass         1 Audio
+      bInterfaceSubClass      2 Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+      AudioStreaming Interface Descriptor:
+        bLength                 7
+        bDescriptorType        36
+        bDescriptorSubtype      1 (AS_GENERAL)
+        bTerminalLink           3
+        bDelay                255 frames
+        wFormatTag              1 PCM
+      AudioStreaming Interface Descriptor:
+        bLength                11
+        bDescriptorType        36
+        bDescriptorSubtype      2 (FORMAT_TYPE)
+        bFormatType             1 (FORMAT_TYPE_I)
+        bNrChannels             2
+        bSubframeSize           2
+        bBitResolution         16
+        bSamFreqType            1 Discrete
+        tSamFreq[ 0]        32000
+      Endpoint Descriptor:
+        bLength                 9
+        bDescriptorType         5
+        bEndpointAddress     0x82  EP 2 IN
+        bmAttributes            5
+          Transfer Type            Isochronous
+          Synch Type               Asynchronous
+          Usage Type               Data
+        wMaxPacketSize     0x0084  1x 132 bytes
+        bInterval               4
+        bRefresh                0
+        bSynchAddress           0
+        AudioControl Endpoint Descriptor:
+          bLength                 7
+          bDescriptorType        37
+          bDescriptorSubtype      1 (EP_GENERAL)
+          bmAttributes         0x01
+            Sampling Frequency
+          bLockDelayUnits         0 Undefined
+          wLockDelay              0 Undefined
+Device Qualifier (for other device speed):
+  bLength                10
+  bDescriptorType         6
+  bcdUSB               2.00
+  bDeviceClass          239 Miscellaneous Device
+  bDeviceSubClass         2 ?
+  bDeviceProtocol         1 Interface Association
+  bMaxPacketSize0        64
+  bNumConfigurations      1
+Device Status:     0x0000
+  (Bus Powered)
diff --git a/3rdparty/libuvc/src/cameras/ms_lifecam_show.txt b/3rdparty/libuvc/src/cameras/ms_lifecam_show.txt
new file mode 100644
index 00000000..d8f96501
--- /dev/null
+++ b/3rdparty/libuvc/src/cameras/ms_lifecam_show.txt
@@ -0,0 +1,767 @@
+
+Bus 001 Device 010: ID 045e:0729 Microsoft Corp. 
+Device Descriptor:
+  bLength                18
+  bDescriptorType         1
+  bcdUSB               2.00
+  bDeviceClass          239 Miscellaneous Device
+  bDeviceSubClass         2 ?
+  bDeviceProtocol         1 Interface Association
+  bMaxPacketSize0        64
+  idVendor           0x045e Microsoft Corp.
+  idProduct          0x0729 
+  bcdDevice            1.00
+  iManufacturer           1 Microsoft
+  iProduct                2 Microsoft� LifeCam Show(TM)
+  iSerial                 0 
+  bNumConfigurations      1
+  Configuration Descriptor:
+    bLength                 9
+    bDescriptorType         2
+    wTotalLength          961
+    bNumInterfaces          5
+    bConfigurationValue     1
+    iConfiguration          0 
+    bmAttributes         0x80
+      (Bus Powered)
+    MaxPower              320mA
+    Interface Association:
+      bLength                 8
+      bDescriptorType        11
+      bFirstInterface         0
+      bInterfaceCount         2
+      bFunctionClass         14 Video
+      bFunctionSubClass       3 Video Interface Collection
+      bFunctionProtocol       0 
+      iFunction               2 Microsoft� LifeCam Show(TM)
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        0
+      bAlternateSetting       0
+      bNumEndpoints           1
+      bInterfaceClass        14 Video
+      bInterfaceSubClass      1 Video Control
+      bInterfaceProtocol      0 
+      iInterface              2 Microsoft� LifeCam Show(TM)
+      VideoControl Interface Descriptor:
+        bLength                13
+        bDescriptorType        36
+        bDescriptorSubtype      1 (HEADER)
+        bcdUVC               1.00
+        wTotalLength           79
+        dwClockFrequency       24.000000MHz
+        bInCollection           1
+        baInterfaceNr( 0)       1
+      VideoControl Interface Descriptor:
+        bLength                18
+        bDescriptorType        36
+        bDescriptorSubtype      2 (INPUT_TERMINAL)
+        bTerminalID             1
+        wTerminalType      0x0201 Camera Sensor
+        bAssocTerminal          0
+        iTerminal               0 
+        wObjectiveFocalLengthMin      0
+        wObjectiveFocalLengthMax      0
+        wOcularFocalLength            0
+        bControlSize                  3
+        bmControls           0x00000a0a
+          Auto-Exposure Mode
+          Exposure Time (Absolute)
+          Zoom (Absolute)
+          PanTilt (Absolute)
+      VideoControl Interface Descriptor:
+        bLength                11
+        bDescriptorType        36
+        bDescriptorSubtype      5 (PROCESSING_UNIT)
+      Warning: Descriptor too short
+        bUnitID                 2
+        bSourceID               1
+        wMaxMultiplier          0
+        bControlSize            2
+        bmControls     0x0000073b
+          Brightness
+          Contrast
+          Saturation
+          Sharpness
+          Gamma
+          Backlight Compensation
+          Gain
+          Power Line Frequency
+        iProcessing             0 
+        bmVideoStandards     0x 9
+          None
+          SECAM - 625/50
+      VideoControl Interface Descriptor:
+        bLength                 9
+        bDescriptorType        36
+        bDescriptorSubtype      3 (OUTPUT_TERMINAL)
+        bTerminalID             3
+        wTerminalType      0x0101 USB Streaming
+        bAssocTerminal          0
+        bSourceID               2
+        iTerminal               0 
+      VideoControl Interface Descriptor:
+        bLength                28
+        bDescriptorType        36
+        bDescriptorSubtype      6 (EXTENSION_UNIT)
+        bUnitID                 4
+        guidExtensionCode         {5dc717a9-1941-da11-ae0e-000d56ac7b4c}
+        bNumControl             8
+        bNrPins                 1
+        baSourceID( 0)          1
+        bControlSize            3
+        bmControls( 0)       0xf9
+        bmControls( 1)       0x01
+        bmControls( 2)       0xc0
+        iExtension              0 
+      Endpoint Descriptor:
+        bLength                 7
+        bDescriptorType         5
+        bEndpointAddress     0x81  EP 1 IN
+        bmAttributes            3
+          Transfer Type            Interrupt
+          Synch Type               None
+          Usage Type               Data
+        wMaxPacketSize     0x000a  1x 10 bytes
+        bInterval               5
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        1
+      bAlternateSetting       0
+      bNumEndpoints           0
+      bInterfaceClass        14 Video
+      bInterfaceSubClass      2 Video Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+      VideoStreaming Interface Descriptor:
+        bLength                            15
+        bDescriptorType                    36
+        bDescriptorSubtype                  1 (INPUT_HEADER)
+        bNumFormats                         2
+        wTotalLength                      587
+        bEndPointAddress                  130
+        bmInfo                              0
+        bTerminalLink                       3
+        bStillCaptureMethod                 2
+        bTriggerSupport                     1
+        bTriggerUsage                       1
+        bControlSize                        1
+        bmaControls( 0)                    27
+        bmaControls( 1)                    27
+      VideoStreaming Interface Descriptor:
+        bLength                            27
+        bDescriptorType                    36
+        bDescriptorSubtype                  4 (FORMAT_UNCOMPRESSED)
+        bFormatIndex                        1
+        bNumFrameDescriptors                6
+        guidFormat                            {59555932-0000-1000-8000-00aa00389b71}
+        bBitsPerPixel                      16
+        bDefaultFrameIndex                  1
+        bAspectRatioX                       0
+        bAspectRatioY                       0
+        bmInterlaceFlags                 0x00
+          Interlaced stream or variable: No
+          Fields per frame: 1 fields
+          Field 1 first: No
+          Field pattern: Field 1 only
+          bCopyProtect                      0
+      VideoStreaming Interface Descriptor:
+        bLength                            30
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                         1
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            352
+        wHeight                           288
+        dwMinBitRate                196608000
+        dwMaxBitRate                196608000
+        dwMaxVideoFrameBufferSize     3840000
+        dwDefaultFrameInterval         666667
+        bFrameIntervalType                  1
+        dwFrameInterval( 0)            666667
+      VideoStreaming Interface Descriptor:
+        bLength                            30
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                         2
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            640
+        wHeight                           480
+        dwMinBitRate                196608000
+        dwMaxBitRate                196608000
+        dwMaxVideoFrameBufferSize     3840000
+        dwDefaultFrameInterval         666667
+        bFrameIntervalType                  1
+        dwFrameInterval( 0)            666667
+      VideoStreaming Interface Descriptor:
+        bLength                            30
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                         3
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            320
+        wHeight                           240
+        dwMinBitRate                196608000
+        dwMaxBitRate                196608000
+        dwMaxVideoFrameBufferSize     3840000
+        dwDefaultFrameInterval         666667
+        bFrameIntervalType                  1
+        dwFrameInterval( 0)            666667
+      VideoStreaming Interface Descriptor:
+        bLength                            30
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                         4
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            176
+        wHeight                           144
+        dwMinBitRate                196608000
+        dwMaxBitRate                196608000
+        dwMaxVideoFrameBufferSize     3840000
+        dwDefaultFrameInterval         666667
+        bFrameIntervalType                  1
+        dwFrameInterval( 0)            666667
+      VideoStreaming Interface Descriptor:
+        bLength                            30
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                         5
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            160
+        wHeight                           120
+        dwMinBitRate                196608000
+        dwMaxBitRate                196608000
+        dwMaxVideoFrameBufferSize     3840000
+        dwDefaultFrameInterval         666667
+        bFrameIntervalType                  1
+        dwFrameInterval( 0)            666667
+      VideoStreaming Interface Descriptor:
+        bLength                            30
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                         6
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            800
+        wHeight                           600
+        dwMinBitRate                196608000
+        dwMaxBitRate                196608000
+        dwMaxVideoFrameBufferSize     3840000
+        dwDefaultFrameInterval         666667
+        bFrameIntervalType                  1
+        dwFrameInterval( 0)            666667
+      VideoStreaming Interface Descriptor:
+        bLength                            30
+        bDescriptorType                    36
+        bDescriptorSubtype                  3 (STILL_IMAGE_FRAME)
+        bEndpointAddress                    0
+        bNumImageSizePatterns               6
+        wWidth( 0)                        352
+        wHeight( 0)                       288
+        wWidth( 1)                        640
+        wHeight( 1)                       480
+        wWidth( 2)                        320
+        wHeight( 2)                       240
+        wWidth( 3)                        176
+        wHeight( 3)                       144
+        wWidth( 4)                        160
+        wHeight( 4)                       120
+        wWidth( 5)                        800
+        wHeight( 5)                       600
+        bNumCompressionPatterns             6
+      VideoStreaming Interface Descriptor:
+        bLength                             6
+        bDescriptorType                    36
+        bDescriptorSubtype                 13 (COLORFORMAT)
+        bColorPrimaries                     0 (Unspecified)
+        bTransferCharacteristics            0 (Unspecified)
+        bMatrixCoefficients                 0 (Unspecified)
+      VideoStreaming Interface Descriptor:
+        bLength                            11
+        bDescriptorType                    36
+        bDescriptorSubtype                  6 (FORMAT_MJPEG)
+        bFormatIndex                        2
+        bNumFrameDescriptors                9
+        bFlags                              1
+          Fixed-size samples: Yes
+        bDefaultFrameIndex                  1
+        bAspectRatioX                       0
+        bAspectRatioY                       0
+        bmInterlaceFlags                 0x00
+          Interlaced stream or variable: No
+          Fields per frame: 1 fields
+          Field 1 first: No
+          Field pattern: Field 1 only
+          bCopyProtect                      0
+      VideoStreaming Interface Descriptor:
+        bLength                            30
+        bDescriptorType                    36
+        bDescriptorSubtype                  7 (FRAME_MJPEG)
+        bFrameIndex                         1
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            352
+        wHeight                           288
+        dwMinBitRate                196608000
+        dwMaxBitRate                196608000
+        dwMaxVideoFrameBufferSize     3840000
+        dwDefaultFrameInterval         666667
+        bFrameIntervalType                  1
+        dwFrameInterval( 0)            666667
+      VideoStreaming Interface Descriptor:
+        bLength                            30
+        bDescriptorType                    36
+        bDescriptorSubtype                  7 (FRAME_MJPEG)
+        bFrameIndex                         2
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            640
+        wHeight                           480
+        dwMinBitRate                196608000
+        dwMaxBitRate                196608000
+        dwMaxVideoFrameBufferSize     3840000
+        dwDefaultFrameInterval         666667
+        bFrameIntervalType                  1
+        dwFrameInterval( 0)            666667
+      VideoStreaming Interface Descriptor:
+        bLength                            30
+        bDescriptorType                    36
+        bDescriptorSubtype                  7 (FRAME_MJPEG)
+        bFrameIndex                         3
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            320
+        wHeight                           240
+        dwMinBitRate                196608000
+        dwMaxBitRate                196608000
+        dwMaxVideoFrameBufferSize     3840000
+        dwDefaultFrameInterval         666667
+        bFrameIntervalType                  1
+        dwFrameInterval( 0)            666667
+      VideoStreaming Interface Descriptor:
+        bLength                            30
+        bDescriptorType                    36
+        bDescriptorSubtype                  7 (FRAME_MJPEG)
+        bFrameIndex                         4
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            176
+        wHeight                           144
+        dwMinBitRate                196608000
+        dwMaxBitRate                196608000
+        dwMaxVideoFrameBufferSize     3840000
+        dwDefaultFrameInterval         666667
+        bFrameIntervalType                  1
+        dwFrameInterval( 0)            666667
+      VideoStreaming Interface Descriptor:
+        bLength                            30
+        bDescriptorType                    36
+        bDescriptorSubtype                  7 (FRAME_MJPEG)
+        bFrameIndex                         5
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            160
+        wHeight                           120
+        dwMinBitRate                196608000
+        dwMaxBitRate                196608000
+        dwMaxVideoFrameBufferSize     3840000
+        dwDefaultFrameInterval         666667
+        bFrameIntervalType                  1
+        dwFrameInterval( 0)            666667
+      VideoStreaming Interface Descriptor:
+        bLength                            30
+        bDescriptorType                    36
+        bDescriptorSubtype                  7 (FRAME_MJPEG)
+        bFrameIndex                         6
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            800
+        wHeight                           600
+        dwMinBitRate                196608000
+        dwMaxBitRate                196608000
+        dwMaxVideoFrameBufferSize     3840000
+        dwDefaultFrameInterval         666667
+        bFrameIntervalType                  1
+        dwFrameInterval( 0)            666667
+      VideoStreaming Interface Descriptor:
+        bLength                            30
+        bDescriptorType                    36
+        bDescriptorSubtype                  7 (FRAME_MJPEG)
+        bFrameIndex                         7
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                           1024
+        wHeight                           768
+        dwMinBitRate                196608000
+        dwMaxBitRate                196608000
+        dwMaxVideoFrameBufferSize     3840000
+        dwDefaultFrameInterval        1333333
+        bFrameIntervalType                  1
+        dwFrameInterval( 0)           1333333
+      VideoStreaming Interface Descriptor:
+        bLength                            30
+        bDescriptorType                    36
+        bDescriptorSubtype                  7 (FRAME_MJPEG)
+        bFrameIndex                         8
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                           1280
+        wHeight                           960
+        dwMinBitRate                196608000
+        dwMaxBitRate                196608000
+        dwMaxVideoFrameBufferSize     3840000
+        dwDefaultFrameInterval        1333333
+        bFrameIntervalType                  1
+        dwFrameInterval( 0)           1333333
+      VideoStreaming Interface Descriptor:
+        bLength                            30
+        bDescriptorType                    36
+        bDescriptorSubtype                  7 (FRAME_MJPEG)
+        bFrameIndex                         9
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                           1600
+        wHeight                          1200
+        dwMinBitRate                196608000
+        dwMaxBitRate                196608000
+        dwMaxVideoFrameBufferSize     3840000
+        dwDefaultFrameInterval        1333333
+        bFrameIntervalType                  1
+        dwFrameInterval( 0)           1333333
+      VideoStreaming Interface Descriptor:
+        bLength                            42
+        bDescriptorType                    36
+        bDescriptorSubtype                  3 (STILL_IMAGE_FRAME)
+        bEndpointAddress                    0
+        bNumImageSizePatterns               9
+        wWidth( 0)                        352
+        wHeight( 0)                       288
+        wWidth( 1)                        640
+        wHeight( 1)                       480
+        wWidth( 2)                        320
+        wHeight( 2)                       240
+        wWidth( 3)                        176
+        wHeight( 3)                       144
+        wWidth( 4)                        160
+        wHeight( 4)                       120
+        wWidth( 5)                        800
+        wHeight( 5)                       600
+        wWidth( 6)                       1024
+        wHeight( 6)                       768
+        wWidth( 7)                       1280
+        wHeight( 7)                       960
+        wWidth( 8)                       1600
+        wHeight( 8)                      1200
+        bNumCompressionPatterns             9
+      VideoStreaming Interface Descriptor:
+        bLength                             6
+        bDescriptorType                    36
+        bDescriptorSubtype                 13 (COLORFORMAT)
+        bColorPrimaries                     0 (Unspecified)
+        bTransferCharacteristics            0 (Unspecified)
+        bMatrixCoefficients                 0 (Unspecified)
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        1
+      bAlternateSetting       1
+      bNumEndpoints           1
+      bInterfaceClass        14 Video
+      bInterfaceSubClass      2 Video Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+      Endpoint Descriptor:
+        bLength                 7
+        bDescriptorType         5
+        bEndpointAddress     0x82  EP 2 IN
+        bmAttributes            5
+          Transfer Type            Isochronous
+          Synch Type               Asynchronous
+          Usage Type               Data
+        wMaxPacketSize     0x0080  1x 128 bytes
+        bInterval               1
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        1
+      bAlternateSetting       2
+      bNumEndpoints           1
+      bInterfaceClass        14 Video
+      bInterfaceSubClass      2 Video Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+      Endpoint Descriptor:
+        bLength                 7
+        bDescriptorType         5
+        bEndpointAddress     0x82  EP 2 IN
+        bmAttributes            5
+          Transfer Type            Isochronous
+          Synch Type               Asynchronous
+          Usage Type               Data
+        wMaxPacketSize     0x0200  1x 512 bytes
+        bInterval               1
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        1
+      bAlternateSetting       3
+      bNumEndpoints           1
+      bInterfaceClass        14 Video
+      bInterfaceSubClass      2 Video Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+      Endpoint Descriptor:
+        bLength                 7
+        bDescriptorType         5
+        bEndpointAddress     0x82  EP 2 IN
+        bmAttributes            5
+          Transfer Type            Isochronous
+          Synch Type               Asynchronous
+          Usage Type               Data
+        wMaxPacketSize     0x0400  1x 1024 bytes
+        bInterval               1
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        1
+      bAlternateSetting       4
+      bNumEndpoints           1
+      bInterfaceClass        14 Video
+      bInterfaceSubClass      2 Video Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+      Endpoint Descriptor:
+        bLength                 7
+        bDescriptorType         5
+        bEndpointAddress     0x82  EP 2 IN
+        bmAttributes            5
+          Transfer Type            Isochronous
+          Synch Type               Asynchronous
+          Usage Type               Data
+        wMaxPacketSize     0x0b00  2x 768 bytes
+        bInterval               1
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        1
+      bAlternateSetting       5
+      bNumEndpoints           1
+      bInterfaceClass        14 Video
+      bInterfaceSubClass      2 Video Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+      Endpoint Descriptor:
+        bLength                 7
+        bDescriptorType         5
+        bEndpointAddress     0x82  EP 2 IN
+        bmAttributes            5
+          Transfer Type            Isochronous
+          Synch Type               Asynchronous
+          Usage Type               Data
+        wMaxPacketSize     0x0c00  2x 1024 bytes
+        bInterval               1
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        1
+      bAlternateSetting       6
+      bNumEndpoints           1
+      bInterfaceClass        14 Video
+      bInterfaceSubClass      2 Video Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+      Endpoint Descriptor:
+        bLength                 7
+        bDescriptorType         5
+        bEndpointAddress     0x82  EP 2 IN
+        bmAttributes            5
+          Transfer Type            Isochronous
+          Synch Type               Asynchronous
+          Usage Type               Data
+        wMaxPacketSize     0x1380  3x 896 bytes
+        bInterval               1
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        1
+      bAlternateSetting       7
+      bNumEndpoints           1
+      bInterfaceClass        14 Video
+      bInterfaceSubClass      2 Video Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+      Endpoint Descriptor:
+        bLength                 7
+        bDescriptorType         5
+        bEndpointAddress     0x82  EP 2 IN
+        bmAttributes            5
+          Transfer Type            Isochronous
+          Synch Type               Asynchronous
+          Usage Type               Data
+        wMaxPacketSize     0x1400  3x 1024 bytes
+        bInterval               1
+    Interface Association:
+      bLength                 8
+      bDescriptorType        11
+      bFirstInterface         2
+      bInterfaceCount         2
+      bFunctionClass          1 Audio
+      bFunctionSubClass       2 Streaming
+      bFunctionProtocol       0 
+      iFunction               2 Microsoft� LifeCam Show(TM)
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        2
+      bAlternateSetting       0
+      bNumEndpoints           0
+      bInterfaceClass         1 Audio
+      bInterfaceSubClass      1 Control Device
+      bInterfaceProtocol      0 
+      iInterface              2 Microsoft� LifeCam Show(TM)
+      AudioControl Interface Descriptor:
+        bLength                 9
+        bDescriptorType        36
+        bDescriptorSubtype      1 (HEADER)
+        bcdADC               1.00
+        wTotalLength           39
+        bInCollection           1
+        baInterfaceNr( 0)       3
+      AudioControl Interface Descriptor:
+        bLength                12
+        bDescriptorType        36
+        bDescriptorSubtype      2 (INPUT_TERMINAL)
+        bTerminalID             1
+        wTerminalType      0x0201 Microphone
+        bAssocTerminal          0
+        bNrChannels             1
+        wChannelConfig     0x0000
+        iChannelNames           0 
+        iTerminal               0 
+      AudioControl Interface Descriptor:
+        bLength                 9
+        bDescriptorType        36
+        bDescriptorSubtype      6 (FEATURE_UNIT)
+        bUnitID                 2
+        bSourceID               1
+        bControlSize            1
+        bmaControls( 0)      0x00
+        bmaControls( 1)      0x03
+          Mute
+          Volume
+        iFeature                0 
+      AudioControl Interface Descriptor:
+        bLength                 9
+        bDescriptorType        36
+        bDescriptorSubtype      3 (OUTPUT_TERMINAL)
+        bTerminalID             3
+        wTerminalType      0x0101 USB Streaming
+        bAssocTerminal          1
+        bSourceID               2
+        iTerminal               0 
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        3
+      bAlternateSetting       0
+      bNumEndpoints           0
+      bInterfaceClass         1 Audio
+      bInterfaceSubClass      2 Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        3
+      bAlternateSetting       1
+      bNumEndpoints           1
+      bInterfaceClass         1 Audio
+      bInterfaceSubClass      2 Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+      AudioStreaming Interface Descriptor:
+        bLength                 7
+        bDescriptorType        36
+        bDescriptorSubtype      1 (AS_GENERAL)
+        bTerminalLink           3
+        bDelay                  1 frames
+        wFormatTag              1 PCM
+      AudioStreaming Interface Descriptor:
+        bLength                14
+        bDescriptorType        36
+        bDescriptorSubtype      2 (FORMAT_TYPE)
+        bFormatType             1 (FORMAT_TYPE_I)
+        bNrChannels             1
+        bSubframeSize           2
+        bBitResolution         16
+        bSamFreqType            2 Discrete
+        tSamFreq[ 0]        44100
+        tSamFreq[ 1]        48000
+      Endpoint Descriptor:
+        bLength                 9
+        bDescriptorType         5
+        bEndpointAddress     0x83  EP 3 IN
+        bmAttributes            1
+          Transfer Type            Isochronous
+          Synch Type               None
+          Usage Type               Data
+        wMaxPacketSize     0x0062  1x 98 bytes
+        bInterval               4
+        bRefresh                0
+        bSynchAddress           0
+        AudioControl Endpoint Descriptor:
+          bLength                 7
+          bDescriptorType        37
+          bDescriptorSubtype      1 (EP_GENERAL)
+          bmAttributes         0x01
+            Sampling Frequency
+          bLockDelayUnits         0 Undefined
+          wLockDelay              0 Undefined
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        4
+      bAlternateSetting       0
+      bNumEndpoints           1
+      bInterfaceClass         3 Human Interface Device
+      bInterfaceSubClass      1 Boot Interface Subclass
+      bInterfaceProtocol      1 Keyboard
+      iInterface              0 
+        HID Device Descriptor:
+          bLength                 9
+          bDescriptorType        33
+          bcdHID               1.10
+          bCountryCode            0 Not supported
+          bNumDescriptors         1
+          bDescriptorType        34 Report
+          wDescriptorLength      24
+         Report Descriptors: 
+           ** UNAVAILABLE **
+      Endpoint Descriptor:
+        bLength                 7
+        bDescriptorType         5
+        bEndpointAddress     0x85  EP 5 IN
+        bmAttributes            3
+          Transfer Type            Interrupt
+          Synch Type               None
+          Usage Type               Data
+        wMaxPacketSize     0x0001  1x 1 bytes
+        bInterval              10
+Device Qualifier (for other device speed):
+  bLength                10
+  bDescriptorType         6
+  bcdUSB               2.00
+  bDeviceClass          239 Miscellaneous Device
+  bDeviceSubClass         2 ?
+  bDeviceProtocol         1 Interface Association
+  bMaxPacketSize0        64
+  bNumConfigurations      1
+Device Status:     0x0000
+  (Bus Powered)
diff --git a/3rdparty/libuvc/src/cameras/quickcampro9000.txt b/3rdparty/libuvc/src/cameras/quickcampro9000.txt
new file mode 100644
index 00000000..5b859b39
--- /dev/null
+++ b/3rdparty/libuvc/src/cameras/quickcampro9000.txt
@@ -0,0 +1,1543 @@
+
+Bus 001 Device 009: ID 046d:0809 Logitech, Inc. Webcam Pro 9000
+Device Descriptor:
+  bLength                18
+  bDescriptorType         1
+  bcdUSB               2.00
+  bDeviceClass          239 Miscellaneous Device
+  bDeviceSubClass         2 ?
+  bDeviceProtocol         1 Interface Association
+  bMaxPacketSize0        64
+  idVendor           0x046d Logitech, Inc.
+  idProduct          0x0809 Webcam Pro 9000
+  bcdDevice            0.10
+  iManufacturer           0 
+  iProduct                0 
+  iSerial                 2 XXXXXXXX
+  bNumConfigurations      1
+  Configuration Descriptor:
+    bLength                 9
+    bDescriptorType         2
+    wTotalLength         2589
+    bNumInterfaces          4
+    bConfigurationValue     1
+    iConfiguration          0 
+    bmAttributes         0x80
+      (Bus Powered)
+    MaxPower              500mA
+    Interface Association:
+      bLength                 8
+      bDescriptorType        11
+      bFirstInterface         0
+      bInterfaceCount         2
+      bFunctionClass         14 Video
+      bFunctionSubClass       3 Video Interface Collection
+      bFunctionProtocol       0 
+      iFunction               0 
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        0
+      bAlternateSetting       0
+      bNumEndpoints           1
+      bInterfaceClass        14 Video
+      bInterfaceSubClass      1 Video Control
+      bInterfaceProtocol      0 
+      iInterface              0 
+      VideoControl Interface Descriptor:
+        bLength                13
+        bDescriptorType        36
+        bDescriptorSubtype      1 (HEADER)
+        bcdUVC               1.00
+        wTotalLength          245
+        dwClockFrequency       48.000000MHz
+        bInCollection           1
+        baInterfaceNr( 0)       1
+      VideoControl Interface Descriptor:
+        bLength                18
+        bDescriptorType        36
+        bDescriptorSubtype      2 (INPUT_TERMINAL)
+        bTerminalID             1
+        wTerminalType      0x0201 Camera Sensor
+        bAssocTerminal          0
+        iTerminal               0 
+        wObjectiveFocalLengthMin      0
+        wObjectiveFocalLengthMax      0
+        wOcularFocalLength            0
+        bControlSize                  3
+        bmControls           0x0000080e
+          Auto-Exposure Mode
+          Auto-Exposure Priority
+          Exposure Time (Absolute)
+          PanTilt (Absolute)
+      VideoControl Interface Descriptor:
+        bLength                11
+        bDescriptorType        36
+        bDescriptorSubtype      5 (PROCESSING_UNIT)
+      Warning: Descriptor too short
+        bUnitID                 2
+        bSourceID               1
+        wMaxMultiplier      16384
+        bControlSize            2
+        bmControls     0x0000175b
+          Brightness
+          Contrast
+          Saturation
+          Sharpness
+          White Balance Temperature
+          Backlight Compensation
+          Gain
+          Power Line Frequency
+          White Balance Temperature, Auto
+        iProcessing             0 
+        bmVideoStandards     0x1b
+          None
+          NTSC - 525/60
+          SECAM - 625/50
+          NTSC - 625/50
+      VideoControl Interface Descriptor:
+        bLength                27
+        bDescriptorType        36
+        bDescriptorSubtype      6 (EXTENSION_UNIT)
+        bUnitID                 4
+        guidExtensionCode         {82066163-7050-ab49-b8cc-b3855e8d221e}
+        bNumControl            10
+        bNrPins                 1
+        baSourceID( 0)          2
+        bControlSize            2
+        bmControls( 0)       0xff
+        bmControls( 1)       0x03
+        iExtension              0 
+      VideoControl Interface Descriptor:
+        bLength                27
+        bDescriptorType        36
+        bDescriptorSubtype      6 (EXTENSION_UNIT)
+        bUnitID                13
+        guidExtensionCode         {82066163-7050-ab49-b8cc-b3855e8d221f}
+        bNumControl             7
+        bNrPins                 1
+        baSourceID( 0)          2
+        bControlSize            2
+        bmControls( 0)       0x6f
+        bmControls( 1)       0x01
+        iExtension              0 
+      VideoControl Interface Descriptor:
+        bLength                28
+        bDescriptorType        36
+        bDescriptorSubtype      6 (EXTENSION_UNIT)
+        bUnitID                 8
+        guidExtensionCode         {82066163-7050-ab49-b8cc-b3855e8d2251}
+        bNumControl             3
+        bNrPins                 1
+        baSourceID( 0)          4
+        bControlSize            3
+        bmControls( 0)       0x19
+        bmControls( 1)       0x00
+        bmControls( 2)       0x00
+        iExtension              0 
+      VideoControl Interface Descriptor:
+        bLength                28
+        bDescriptorType        36
+        bDescriptorSubtype      6 (EXTENSION_UNIT)
+        bUnitID                10
+        guidExtensionCode         {82066163-7050-ab49-b8cc-b3855e8d2252}
+        bNumControl            24
+        bNrPins                 1
+        baSourceID( 0)          4
+        bControlSize            3
+        bmControls( 0)       0xff
+        bmControls( 1)       0xff
+        bmControls( 2)       0xff
+        iExtension              0 
+      VideoControl Interface Descriptor:
+        bLength                28
+        bDescriptorType        36
+        bDescriptorSubtype      6 (EXTENSION_UNIT)
+        bUnitID                14
+        guidExtensionCode         {b7935ba4-15c7-0245-90f4-532a3b311365}
+        bNumControl             4
+        bNrPins                 1
+        baSourceID( 0)          1
+        bControlSize            3
+        bmControls( 0)       0x0f
+        bmControls( 1)       0x00
+        bmControls( 2)       0x00
+        iExtension              0 
+      VideoControl Interface Descriptor:
+        bLength                28
+        bDescriptorType        36
+        bDescriptorSubtype      6 (EXTENSION_UNIT)
+        bUnitID                 9
+        guidExtensionCode         {82066163-7050-ab49-b8cc-b3855e8d2256}
+        bNumControl             5
+        bNrPins                 1
+        baSourceID( 0)          4
+        bControlSize            3
+        bmControls( 0)       0x0c
+        bmControls( 1)       0x00
+        bmControls( 2)       0x00
+        iExtension              0 
+      VideoControl Interface Descriptor:
+        bLength                28
+        bDescriptorType        36
+        bDescriptorSubtype      6 (EXTENSION_UNIT)
+        bUnitID                12
+        guidExtensionCode         {82066163-7050-ab49-b8cc-b3855e8d2250}
+        bNumControl            17
+        bNrPins                 1
+        baSourceID( 0)          4
+        bControlSize            3
+        bmControls( 0)       0xfe
+        bmControls( 1)       0x7f
+        bmControls( 2)       0x70
+        iExtension              0 
+      VideoControl Interface Descriptor:
+        bLength                 9
+        bDescriptorType        36
+        bDescriptorSubtype      3 (OUTPUT_TERMINAL)
+        bTerminalID             5
+        wTerminalType      0x0101 USB Streaming
+        bAssocTerminal          0
+        bSourceID               4
+        iTerminal               0 
+      ** UNRECOGNIZED:  20 41 01 0b 82 06 61 63 70 50 ab 49 b8 cc b3 85 5e 8d 22 55 01 01 04 03 01 00 00 00 00 00 00 00
+      Endpoint Descriptor:
+        bLength                 7
+        bDescriptorType         5
+        bEndpointAddress     0x87  EP 7 IN
+        bmAttributes            3
+          Transfer Type            Interrupt
+          Synch Type               None
+          Usage Type               Data
+        wMaxPacketSize     0x0010  1x 16 bytes
+        bInterval               8
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        1
+      bAlternateSetting       0
+      bNumEndpoints           0
+      bInterfaceClass        14 Video
+      bInterfaceSubClass      2 Video Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+      VideoStreaming Interface Descriptor:
+        bLength                            16
+        bDescriptorType                    36
+        bDescriptorSubtype                  1 (INPUT_HEADER)
+        bNumFormats                         3
+        wTotalLength                     1852
+        bEndPointAddress                  129
+        bmInfo                              0
+        bTerminalLink                       5
+        bStillCaptureMethod                 2
+        bTriggerSupport                     1
+        bTriggerUsage                       0
+        bControlSize                        1
+        bmaControls( 0)                    27
+        bmaControls( 1)                    27
+        bmaControls( 2)                    27
+      VideoStreaming Interface Descriptor:
+        bLength                            27
+        bDescriptorType                    36
+        bDescriptorSubtype                  4 (FORMAT_UNCOMPRESSED)
+        bFormatIndex                        1
+        bNumFrameDescriptors               18
+        guidFormat                            {59555932-0000-1000-8000-00aa00389b71}
+        bBitsPerPixel                      16
+        bDefaultFrameIndex                  1
+        bAspectRatioX                       0
+        bAspectRatioY                       0
+        bmInterlaceFlags                 0x00
+          Interlaced stream or variable: No
+          Fields per frame: 1 fields
+          Field 1 first: No
+          Field pattern: Field 1 only
+          bCopyProtect                      0
+      VideoStreaming Interface Descriptor:
+        bLength                            50
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                         1
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            640
+        wHeight                           480
+        dwMinBitRate                 24576000
+        dwMaxBitRate                147456000
+        dwMaxVideoFrameBufferSize      614400
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  6
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            400000
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            50
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                         2
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            160
+        wHeight                           120
+        dwMinBitRate                  1536000
+        dwMaxBitRate                  9216000
+        dwMaxVideoFrameBufferSize       38400
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  6
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            400000
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            50
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                         3
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            176
+        wHeight                           144
+        dwMinBitRate                  2027520
+        dwMaxBitRate                 12165120
+        dwMaxVideoFrameBufferSize       50688
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  6
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            400000
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            50
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                         4
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            320
+        wHeight                           240
+        dwMinBitRate                  6144000
+        dwMaxBitRate                 36864000
+        dwMaxVideoFrameBufferSize      153600
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  6
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            400000
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            50
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                         5
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            352
+        wHeight                           288
+        dwMinBitRate                  8110080
+        dwMaxBitRate                 48660480
+        dwMaxVideoFrameBufferSize      202752
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  6
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            400000
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            50
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                         6
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            640
+        wHeight                           360
+        dwMinBitRate                 18432000
+        dwMaxBitRate                110592000
+        dwMaxVideoFrameBufferSize      460800
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  6
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            400000
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            50
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                         7
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            640
+        wHeight                           400
+        dwMinBitRate                 20480000
+        dwMaxBitRate                122880000
+        dwMaxVideoFrameBufferSize      512000
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  6
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            400000
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            46
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                         8
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            768
+        wHeight                           480
+        dwMinBitRate                 29491200
+        dwMaxBitRate                147456000
+        dwMaxVideoFrameBufferSize      737280
+        dwDefaultFrameInterval         400000
+        bFrameIntervalType                  5
+        dwFrameInterval( 0)            400000
+        dwFrameInterval( 1)            500000
+        dwFrameInterval( 2)            666666
+        dwFrameInterval( 3)           1000000
+        dwFrameInterval( 4)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            46
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                         9
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            800
+        wHeight                           456
+        dwMinBitRate                 29184000
+        dwMaxBitRate                145920000
+        dwMaxVideoFrameBufferSize      729600
+        dwDefaultFrameInterval         400000
+        bFrameIntervalType                  5
+        dwFrameInterval( 0)            400000
+        dwFrameInterval( 1)            500000
+        dwFrameInterval( 2)            666666
+        dwFrameInterval( 3)           1000000
+        dwFrameInterval( 4)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            46
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                        10
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            800
+        wHeight                           504
+        dwMinBitRate                 32256000
+        dwMaxBitRate                161280000
+        dwMaxVideoFrameBufferSize      806400
+        dwDefaultFrameInterval         400000
+        bFrameIntervalType                  5
+        dwFrameInterval( 0)            400000
+        dwFrameInterval( 1)            500000
+        dwFrameInterval( 2)            666666
+        dwFrameInterval( 3)           1000000
+        dwFrameInterval( 4)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            46
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                        11
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            800
+        wHeight                           600
+        dwMinBitRate                 38400000
+        dwMaxBitRate                192000000
+        dwMaxVideoFrameBufferSize      960000
+        dwDefaultFrameInterval         400000
+        bFrameIntervalType                  5
+        dwFrameInterval( 0)            400000
+        dwFrameInterval( 1)            500000
+        dwFrameInterval( 2)            666666
+        dwFrameInterval( 3)           1000000
+        dwFrameInterval( 4)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            46
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                        12
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            864
+        wHeight                           480
+        dwMinBitRate                 33177600
+        dwMaxBitRate                165888000
+        dwMaxVideoFrameBufferSize      829440
+        dwDefaultFrameInterval         400000
+        bFrameIntervalType                  5
+        dwFrameInterval( 0)            400000
+        dwFrameInterval( 1)            500000
+        dwFrameInterval( 2)            666666
+        dwFrameInterval( 3)           1000000
+        dwFrameInterval( 4)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            38
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                        13
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            960
+        wHeight                           720
+        dwMinBitRate                 55296000
+        dwMaxBitRate                165888000
+        dwMaxVideoFrameBufferSize     1382400
+        dwDefaultFrameInterval        1000000
+        bFrameIntervalType                  3
+        dwFrameInterval( 0)            666666
+        dwFrameInterval( 1)           1000000
+        dwFrameInterval( 2)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            34
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                        14
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                           1280
+        wHeight                           720
+        dwMinBitRate                 73728000
+        dwMaxBitRate                147456000
+        dwMaxVideoFrameBufferSize     1843200
+        dwDefaultFrameInterval        2000000
+        bFrameIntervalType                  2
+        dwFrameInterval( 0)           1333333
+        dwFrameInterval( 1)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            34
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                        15
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                           1280
+        wHeight                           800
+        dwMinBitRate                 81920000
+        dwMaxBitRate                163840000
+        dwMaxVideoFrameBufferSize     2048000
+        dwDefaultFrameInterval        2000000
+        bFrameIntervalType                  2
+        dwFrameInterval( 0)           1333333
+        dwFrameInterval( 1)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            30
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                        16
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                           1600
+        wHeight                           904
+        dwMinBitRate                115712000
+        dwMaxBitRate                115712000
+        dwMaxVideoFrameBufferSize     2892800
+        dwDefaultFrameInterval        2000000
+        bFrameIntervalType                  1
+        dwFrameInterval( 0)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            30
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                        17
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                           1600
+        wHeight                          1000
+        dwMinBitRate                128000000
+        dwMaxBitRate                128000000
+        dwMaxVideoFrameBufferSize     3200000
+        dwDefaultFrameInterval        2000000
+        bFrameIntervalType                  1
+        dwFrameInterval( 0)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            30
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                        18
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                           1600
+        wHeight                          1200
+        dwMinBitRate                153600000
+        dwMaxBitRate                153600000
+        dwMaxVideoFrameBufferSize     3840000
+        dwDefaultFrameInterval        2000000
+        bFrameIntervalType                  1
+        dwFrameInterval( 0)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            79
+        bDescriptorType                    36
+        bDescriptorSubtype                  3 (STILL_IMAGE_FRAME)
+        bEndpointAddress                    0
+        bNumImageSizePatterns              18
+        wWidth( 0)                        640
+        wHeight( 0)                       480
+        wWidth( 1)                        160
+        wHeight( 1)                       120
+        wWidth( 2)                        176
+        wHeight( 2)                       144
+        wWidth( 3)                        320
+        wHeight( 3)                       240
+        wWidth( 4)                        352
+        wHeight( 4)                       288
+        wWidth( 5)                        640
+        wHeight( 5)                       360
+        wWidth( 6)                        640
+        wHeight( 6)                       400
+        wWidth( 7)                        768
+        wHeight( 7)                       480
+        wWidth( 8)                        800
+        wHeight( 8)                       456
+        wWidth( 9)                        800
+        wHeight( 9)                       504
+        wWidth(10)                        800
+        wHeight(10)                       600
+        wWidth(11)                        864
+        wHeight(11)                       480
+        wWidth(12)                        960
+        wHeight(12)                       720
+        wWidth(13)                       1280
+        wHeight(13)                       720
+        wWidth(14)                       1280
+        wHeight(14)                       800
+        wWidth(15)                       1600
+        wHeight(15)                       904
+        wWidth(16)                       1600
+        wHeight(16)                      1000
+        wWidth(17)                       1600
+        wHeight(17)                      1200
+        bNumCompressionPatterns            18
+        bCompression( 0)                    5
+      VideoStreaming Interface Descriptor:
+        bLength                             6
+        bDescriptorType                    36
+        bDescriptorSubtype                 13 (COLORFORMAT)
+        bColorPrimaries                     1 (BT.709,sRGB)
+        bTransferCharacteristics            1 (BT.709)
+        bMatrixCoefficients                 4 (SMPTE 170M (BT.601))
+      VideoStreaming Interface Descriptor:
+        bLength                            11
+        bDescriptorType                    36
+        bDescriptorSubtype                  6 (FORMAT_MJPEG)
+        bFormatIndex                        2
+        bNumFrameDescriptors               18
+        bFlags                              1
+          Fixed-size samples: Yes
+        bDefaultFrameIndex                  1
+        bAspectRatioX                       0
+        bAspectRatioY                       0
+        bmInterlaceFlags                 0x00
+          Interlaced stream or variable: No
+          Fields per frame: 1 fields
+          Field 1 first: No
+          Field pattern: Field 1 only
+          bCopyProtect                      0
+      VideoStreaming Interface Descriptor:
+        bLength                            50
+        bDescriptorType                    36
+        bDescriptorSubtype                  7 (FRAME_MJPEG)
+        bFrameIndex                         1
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            640
+        wHeight                           480
+        dwMinBitRate                 24576000
+        dwMaxBitRate                147456000
+        dwMaxVideoFrameBufferSize      614400
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  6
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            400000
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            50
+        bDescriptorType                    36
+        bDescriptorSubtype                  7 (FRAME_MJPEG)
+        bFrameIndex                         2
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            160
+        wHeight                           120
+        dwMinBitRate                  1536000
+        dwMaxBitRate                  9216000
+        dwMaxVideoFrameBufferSize       38400
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  6
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            400000
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            50
+        bDescriptorType                    36
+        bDescriptorSubtype                  7 (FRAME_MJPEG)
+        bFrameIndex                         3
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            176
+        wHeight                           144
+        dwMinBitRate                  2027520
+        dwMaxBitRate                 12165120
+        dwMaxVideoFrameBufferSize       50688
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  6
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            400000
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            50
+        bDescriptorType                    36
+        bDescriptorSubtype                  7 (FRAME_MJPEG)
+        bFrameIndex                         4
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            320
+        wHeight                           240
+        dwMinBitRate                  6144000
+        dwMaxBitRate                 36864000
+        dwMaxVideoFrameBufferSize      153600
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  6
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            400000
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            50
+        bDescriptorType                    36
+        bDescriptorSubtype                  7 (FRAME_MJPEG)
+        bFrameIndex                         5
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            352
+        wHeight                           288
+        dwMinBitRate                  8110080
+        dwMaxBitRate                 48660480
+        dwMaxVideoFrameBufferSize      202752
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  6
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            400000
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            50
+        bDescriptorType                    36
+        bDescriptorSubtype                  7 (FRAME_MJPEG)
+        bFrameIndex                         6
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            640
+        wHeight                           360
+        dwMinBitRate                 18432000
+        dwMaxBitRate                110592000
+        dwMaxVideoFrameBufferSize      460800
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  6
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            400000
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            50
+        bDescriptorType                    36
+        bDescriptorSubtype                  7 (FRAME_MJPEG)
+        bFrameIndex                         7
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            640
+        wHeight                           400
+        dwMinBitRate                 20480000
+        dwMaxBitRate                122880000
+        dwMaxVideoFrameBufferSize      512000
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  6
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            400000
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            50
+        bDescriptorType                    36
+        bDescriptorSubtype                  7 (FRAME_MJPEG)
+        bFrameIndex                         8
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            768
+        wHeight                           480
+        dwMinBitRate                 29491200
+        dwMaxBitRate                176947200
+        dwMaxVideoFrameBufferSize      737280
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  6
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            400000
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            50
+        bDescriptorType                    36
+        bDescriptorSubtype                  7 (FRAME_MJPEG)
+        bFrameIndex                         9
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            800
+        wHeight                           456
+        dwMinBitRate                 29184000
+        dwMaxBitRate                175104000
+        dwMaxVideoFrameBufferSize      729600
+        dwDefaultFrameInterval         666666
+        bFrameIntervalType                  6
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            400000
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            50
+        bDescriptorType                    36
+        bDescriptorSubtype                  7 (FRAME_MJPEG)
+        bFrameIndex                        10
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            800
+        wHeight                           504
+        dwMinBitRate                 32256000
+        dwMaxBitRate                193536000
+        dwMaxVideoFrameBufferSize      806400
+        dwDefaultFrameInterval         666666
+        bFrameIntervalType                  6
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            400000
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            50
+        bDescriptorType                    36
+        bDescriptorSubtype                  7 (FRAME_MJPEG)
+        bFrameIndex                        11
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            800
+        wHeight                           600
+        dwMinBitRate                 38400000
+        dwMaxBitRate                230400000
+        dwMaxVideoFrameBufferSize      960000
+        dwDefaultFrameInterval         666666
+        bFrameIntervalType                  6
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            400000
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            50
+        bDescriptorType                    36
+        bDescriptorSubtype                  7 (FRAME_MJPEG)
+        bFrameIndex                        12
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            864
+        wHeight                           480
+        dwMinBitRate                 33177600
+        dwMaxBitRate                199065600
+        dwMaxVideoFrameBufferSize      829440
+        dwDefaultFrameInterval         666666
+        bFrameIntervalType                  6
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            400000
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            50
+        bDescriptorType                    36
+        bDescriptorSubtype                  7 (FRAME_MJPEG)
+        bFrameIndex                        13
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            960
+        wHeight                           720
+        dwMinBitRate                 55296000
+        dwMaxBitRate                331776000
+        dwMaxVideoFrameBufferSize     1382400
+        dwDefaultFrameInterval        1000000
+        bFrameIntervalType                  6
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            400000
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            50
+        bDescriptorType                    36
+        bDescriptorSubtype                  7 (FRAME_MJPEG)
+        bFrameIndex                        14
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                           1280
+        wHeight                           720
+        dwMinBitRate                 73728000
+        dwMaxBitRate                442368000
+        dwMaxVideoFrameBufferSize     1843200
+        dwDefaultFrameInterval        1000000
+        bFrameIntervalType                  6
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            400000
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            46
+        bDescriptorType                    36
+        bDescriptorSubtype                  7 (FRAME_MJPEG)
+        bFrameIndex                        15
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                           1280
+        wHeight                           800
+        dwMinBitRate                 81920000
+        dwMaxBitRate                409600000
+        dwMaxVideoFrameBufferSize     2048000
+        dwDefaultFrameInterval        1000000
+        bFrameIntervalType                  5
+        dwFrameInterval( 0)            400000
+        dwFrameInterval( 1)            500000
+        dwFrameInterval( 2)            666666
+        dwFrameInterval( 3)           1000000
+        dwFrameInterval( 4)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            34
+        bDescriptorType                    36
+        bDescriptorSubtype                  7 (FRAME_MJPEG)
+        bFrameIndex                        16
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                           1600
+        wHeight                           904
+        dwMinBitRate                115712000
+        dwMaxBitRate                231424000
+        dwMaxVideoFrameBufferSize     2892800
+        dwDefaultFrameInterval        1000000
+        bFrameIntervalType                  2
+        dwFrameInterval( 0)           1000000
+        dwFrameInterval( 1)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            34
+        bDescriptorType                    36
+        bDescriptorSubtype                  7 (FRAME_MJPEG)
+        bFrameIndex                        17
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                           1600
+        wHeight                          1000
+        dwMinBitRate                128000000
+        dwMaxBitRate                256000000
+        dwMaxVideoFrameBufferSize     3200000
+        dwDefaultFrameInterval        1000000
+        bFrameIntervalType                  2
+        dwFrameInterval( 0)           1000000
+        dwFrameInterval( 1)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            34
+        bDescriptorType                    36
+        bDescriptorSubtype                  7 (FRAME_MJPEG)
+        bFrameIndex                        18
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                           1600
+        wHeight                          1200
+        dwMinBitRate                153600000
+        dwMaxBitRate                307200000
+        dwMaxVideoFrameBufferSize     3840000
+        dwDefaultFrameInterval        2000000
+        bFrameIntervalType                  2
+        dwFrameInterval( 0)           1000000
+        dwFrameInterval( 1)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            83
+        bDescriptorType                    36
+        bDescriptorSubtype                  3 (STILL_IMAGE_FRAME)
+        bEndpointAddress                    0
+        bNumImageSizePatterns              18
+        wWidth( 0)                        640
+        wHeight( 0)                       480
+        wWidth( 1)                        160
+        wHeight( 1)                       120
+        wWidth( 2)                        176
+        wHeight( 2)                       144
+        wWidth( 3)                        320
+        wHeight( 3)                       240
+        wWidth( 4)                        352
+        wHeight( 4)                       288
+        wWidth( 5)                        640
+        wHeight( 5)                       360
+        wWidth( 6)                        640
+        wHeight( 6)                       400
+        wWidth( 7)                        768
+        wHeight( 7)                       480
+        wWidth( 8)                        800
+        wHeight( 8)                       456
+        wWidth( 9)                        800
+        wHeight( 9)                       504
+        wWidth(10)                        800
+        wHeight(10)                       600
+        wWidth(11)                        864
+        wHeight(11)                       480
+        wWidth(12)                        960
+        wHeight(12)                       720
+        wWidth(13)                       1280
+        wHeight(13)                       720
+        wWidth(14)                       1280
+        wHeight(14)                       800
+        wWidth(15)                       1600
+        wHeight(15)                       904
+        wWidth(16)                       1600
+        wHeight(16)                      1000
+        wWidth(17)                       1600
+        wHeight(17)                      1200
+        bNumCompressionPatterns            18
+        bCompression( 0)                    5
+        bCompression( 1)                   10
+        bCompression( 2)                   15
+        bCompression( 3)                   20
+        bCompression( 4)                   25
+      VideoStreaming Interface Descriptor:
+        bLength                             6
+        bDescriptorType                    36
+        bDescriptorSubtype                 13 (COLORFORMAT)
+        bColorPrimaries                     1 (BT.709,sRGB)
+        bTransferCharacteristics            1 (BT.709)
+        bMatrixCoefficients                 4 (SMPTE 170M (BT.601))
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        1
+      bAlternateSetting       1
+      bNumEndpoints           1
+      bInterfaceClass        14 Video
+      bInterfaceSubClass      2 Video Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+      Endpoint Descriptor:
+        bLength                 7
+        bDescriptorType         5
+        bEndpointAddress     0x81  EP 1 IN
+        bmAttributes            5
+          Transfer Type            Isochronous
+          Synch Type               Asynchronous
+          Usage Type               Data
+        wMaxPacketSize     0x00c0  1x 192 bytes
+        bInterval               1
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        1
+      bAlternateSetting       2
+      bNumEndpoints           1
+      bInterfaceClass        14 Video
+      bInterfaceSubClass      2 Video Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+      Endpoint Descriptor:
+        bLength                 7
+        bDescriptorType         5
+        bEndpointAddress     0x81  EP 1 IN
+        bmAttributes            5
+          Transfer Type            Isochronous
+          Synch Type               Asynchronous
+          Usage Type               Data
+        wMaxPacketSize     0x0180  1x 384 bytes
+        bInterval               1
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        1
+      bAlternateSetting       3
+      bNumEndpoints           1
+      bInterfaceClass        14 Video
+      bInterfaceSubClass      2 Video Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+      Endpoint Descriptor:
+        bLength                 7
+        bDescriptorType         5
+        bEndpointAddress     0x81  EP 1 IN
+        bmAttributes            5
+          Transfer Type            Isochronous
+          Synch Type               Asynchronous
+          Usage Type               Data
+        wMaxPacketSize     0x0200  1x 512 bytes
+        bInterval               1
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        1
+      bAlternateSetting       4
+      bNumEndpoints           1
+      bInterfaceClass        14 Video
+      bInterfaceSubClass      2 Video Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+      Endpoint Descriptor:
+        bLength                 7
+        bDescriptorType         5
+        bEndpointAddress     0x81  EP 1 IN
+        bmAttributes            5
+          Transfer Type            Isochronous
+          Synch Type               Asynchronous
+          Usage Type               Data
+        wMaxPacketSize     0x0280  1x 640 bytes
+        bInterval               1
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        1
+      bAlternateSetting       5
+      bNumEndpoints           1
+      bInterfaceClass        14 Video
+      bInterfaceSubClass      2 Video Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+      Endpoint Descriptor:
+        bLength                 7
+        bDescriptorType         5
+        bEndpointAddress     0x81  EP 1 IN
+        bmAttributes            5
+          Transfer Type            Isochronous
+          Synch Type               Asynchronous
+          Usage Type               Data
+        wMaxPacketSize     0x0320  1x 800 bytes
+        bInterval               1
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        1
+      bAlternateSetting       6
+      bNumEndpoints           1
+      bInterfaceClass        14 Video
+      bInterfaceSubClass      2 Video Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+      Endpoint Descriptor:
+        bLength                 7
+        bDescriptorType         5
+        bEndpointAddress     0x81  EP 1 IN
+        bmAttributes            5
+          Transfer Type            Isochronous
+          Synch Type               Asynchronous
+          Usage Type               Data
+        wMaxPacketSize     0x03b0  1x 944 bytes
+        bInterval               1
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        1
+      bAlternateSetting       7
+      bNumEndpoints           1
+      bInterfaceClass        14 Video
+      bInterfaceSubClass      2 Video Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+      Endpoint Descriptor:
+        bLength                 7
+        bDescriptorType         5
+        bEndpointAddress     0x81  EP 1 IN
+        bmAttributes            5
+          Transfer Type            Isochronous
+          Synch Type               Asynchronous
+          Usage Type               Data
+        wMaxPacketSize     0x0a80  2x 640 bytes
+        bInterval               1
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        1
+      bAlternateSetting       8
+      bNumEndpoints           1
+      bInterfaceClass        14 Video
+      bInterfaceSubClass      2 Video Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+      Endpoint Descriptor:
+        bLength                 7
+        bDescriptorType         5
+        bEndpointAddress     0x81  EP 1 IN
+        bmAttributes            5
+          Transfer Type            Isochronous
+          Synch Type               Asynchronous
+          Usage Type               Data
+        wMaxPacketSize     0x0b20  2x 800 bytes
+        bInterval               1
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        1
+      bAlternateSetting       9
+      bNumEndpoints           1
+      bInterfaceClass        14 Video
+      bInterfaceSubClass      2 Video Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+      Endpoint Descriptor:
+        bLength                 7
+        bDescriptorType         5
+        bEndpointAddress     0x81  EP 1 IN
+        bmAttributes            5
+          Transfer Type            Isochronous
+          Synch Type               Asynchronous
+          Usage Type               Data
+        wMaxPacketSize     0x0be0  2x 992 bytes
+        bInterval               1
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        1
+      bAlternateSetting      10
+      bNumEndpoints           1
+      bInterfaceClass        14 Video
+      bInterfaceSubClass      2 Video Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+      Endpoint Descriptor:
+        bLength                 7
+        bDescriptorType         5
+        bEndpointAddress     0x81  EP 1 IN
+        bmAttributes            5
+          Transfer Type            Isochronous
+          Synch Type               Asynchronous
+          Usage Type               Data
+        wMaxPacketSize     0x1380  3x 896 bytes
+        bInterval               1
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        1
+      bAlternateSetting      11
+      bNumEndpoints           1
+      bInterfaceClass        14 Video
+      bInterfaceSubClass      2 Video Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+      Endpoint Descriptor:
+        bLength                 7
+        bDescriptorType         5
+        bEndpointAddress     0x81  EP 1 IN
+        bmAttributes            5
+          Transfer Type            Isochronous
+          Synch Type               Asynchronous
+          Usage Type               Data
+        wMaxPacketSize     0x13fc  3x 1020 bytes
+        bInterval               1
+    Interface Association:
+      bLength                 8
+      bDescriptorType        11
+      bFirstInterface         2
+      bInterfaceCount         2
+      bFunctionClass          1 Audio
+      bFunctionSubClass       2 Streaming
+      bFunctionProtocol       0 
+      iFunction               0 
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        2
+      bAlternateSetting       0
+      bNumEndpoints           0
+      bInterfaceClass         1 Audio
+      bInterfaceSubClass      1 Control Device
+      bInterfaceProtocol      0 
+      iInterface              0 
+      AudioControl Interface Descriptor:
+        bLength                 9
+        bDescriptorType        36
+        bDescriptorSubtype      1 (HEADER)
+        bcdADC               1.00
+        wTotalLength           38
+        bInCollection           1
+        baInterfaceNr( 0)       3
+      AudioControl Interface Descriptor:
+        bLength                12
+        bDescriptorType        36
+        bDescriptorSubtype      2 (INPUT_TERMINAL)
+        bTerminalID             1
+        wTerminalType      0x0201 Microphone
+        bAssocTerminal          0
+        bNrChannels             1
+        wChannelConfig     0x0000
+        iChannelNames           0 
+        iTerminal               0 
+      AudioControl Interface Descriptor:
+        bLength                 9
+        bDescriptorType        36
+        bDescriptorSubtype      3 (OUTPUT_TERMINAL)
+        bTerminalID             3
+        wTerminalType      0x0101 USB Streaming
+        bAssocTerminal          1
+        bSourceID               5
+        iTerminal               0 
+      AudioControl Interface Descriptor:
+        bLength                 9
+        bDescriptorType        36
+        bDescriptorSubtype      6 (FEATURE_UNIT)
+        bUnitID                 5
+        bSourceID               1
+        bControlSize            1
+        bmaControls( 0)      0x03
+          Mute
+          Volume
+        bmaControls( 1)      0x00
+        iFeature                0 
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        3
+      bAlternateSetting       0
+      bNumEndpoints           0
+      bInterfaceClass         1 Audio
+      bInterfaceSubClass      2 Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        3
+      bAlternateSetting       1
+      bNumEndpoints           1
+      bInterfaceClass         1 Audio
+      bInterfaceSubClass      2 Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+      AudioStreaming Interface Descriptor:
+        bLength                 7
+        bDescriptorType        36
+        bDescriptorSubtype      1 (AS_GENERAL)
+        bTerminalLink           3
+        bDelay                  1 frames
+        wFormatTag              1 PCM
+      AudioStreaming Interface Descriptor:
+        bLength                11
+        bDescriptorType        36
+        bDescriptorSubtype      2 (FORMAT_TYPE)
+        bFormatType             1 (FORMAT_TYPE_I)
+        bNrChannels             1
+        bSubframeSize           2
+        bBitResolution         16
+        bSamFreqType            1 Discrete
+        tSamFreq[ 0]        16000
+      Endpoint Descriptor:
+        bLength                 9
+        bDescriptorType         5
+        bEndpointAddress     0x86  EP 6 IN
+        bmAttributes            5
+          Transfer Type            Isochronous
+          Synch Type               Asynchronous
+          Usage Type               Data
+        wMaxPacketSize     0x0044  1x 68 bytes
+        bInterval               4
+        bRefresh                0
+        bSynchAddress           0
+        AudioControl Endpoint Descriptor:
+          bLength                 7
+          bDescriptorType        37
+          bDescriptorSubtype      1 (EP_GENERAL)
+          bmAttributes         0x01
+            Sampling Frequency
+          bLockDelayUnits         0 Undefined
+          wLockDelay              0 Undefined
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        3
+      bAlternateSetting       2
+      bNumEndpoints           1
+      bInterfaceClass         1 Audio
+      bInterfaceSubClass      2 Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+      AudioStreaming Interface Descriptor:
+        bLength                 7
+        bDescriptorType        36
+        bDescriptorSubtype      1 (AS_GENERAL)
+        bTerminalLink           3
+        bDelay                  1 frames
+        wFormatTag              1 PCM
+      AudioStreaming Interface Descriptor:
+        bLength                11
+        bDescriptorType        36
+        bDescriptorSubtype      2 (FORMAT_TYPE)
+        bFormatType             1 (FORMAT_TYPE_I)
+        bNrChannels             1
+        bSubframeSize           2
+        bBitResolution         16
+        bSamFreqType            1 Discrete
+        tSamFreq[ 0]        24000
+      Endpoint Descriptor:
+        bLength                 9
+        bDescriptorType         5
+        bEndpointAddress     0x86  EP 6 IN
+        bmAttributes            5
+          Transfer Type            Isochronous
+          Synch Type               Asynchronous
+          Usage Type               Data
+        wMaxPacketSize     0x0064  1x 100 bytes
+        bInterval               4
+        bRefresh                0
+        bSynchAddress           0
+        AudioControl Endpoint Descriptor:
+          bLength                 7
+          bDescriptorType        37
+          bDescriptorSubtype      1 (EP_GENERAL)
+          bmAttributes         0x01
+            Sampling Frequency
+          bLockDelayUnits         0 Undefined
+          wLockDelay              0 Undefined
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        3
+      bAlternateSetting       3
+      bNumEndpoints           1
+      bInterfaceClass         1 Audio
+      bInterfaceSubClass      2 Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+      AudioStreaming Interface Descriptor:
+        bLength                 7
+        bDescriptorType        36
+        bDescriptorSubtype      1 (AS_GENERAL)
+        bTerminalLink           3
+        bDelay                  1 frames
+        wFormatTag              1 PCM
+      AudioStreaming Interface Descriptor:
+        bLength                11
+        bDescriptorType        36
+        bDescriptorSubtype      2 (FORMAT_TYPE)
+        bFormatType             1 (FORMAT_TYPE_I)
+        bNrChannels             1
+        bSubframeSize           2
+        bBitResolution         16
+        bSamFreqType            1 Discrete
+        tSamFreq[ 0]        32000
+      Endpoint Descriptor:
+        bLength                 9
+        bDescriptorType         5
+        bEndpointAddress     0x86  EP 6 IN
+        bmAttributes            5
+          Transfer Type            Isochronous
+          Synch Type               Asynchronous
+          Usage Type               Data
+        wMaxPacketSize     0x0084  1x 132 bytes
+        bInterval               4
+        bRefresh                0
+        bSynchAddress           0
+        AudioControl Endpoint Descriptor:
+          bLength                 7
+          bDescriptorType        37
+          bDescriptorSubtype      1 (EP_GENERAL)
+          bmAttributes         0x01
+            Sampling Frequency
+          bLockDelayUnits         0 Undefined
+          wLockDelay              0 Undefined
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        3
+      bAlternateSetting       4
+      bNumEndpoints           1
+      bInterfaceClass         1 Audio
+      bInterfaceSubClass      2 Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+      AudioStreaming Interface Descriptor:
+        bLength                 7
+        bDescriptorType        36
+        bDescriptorSubtype      1 (AS_GENERAL)
+        bTerminalLink           3
+        bDelay                  1 frames
+        wFormatTag              1 PCM
+      AudioStreaming Interface Descriptor:
+        bLength                11
+        bDescriptorType        36
+        bDescriptorSubtype      2 (FORMAT_TYPE)
+        bFormatType             1 (FORMAT_TYPE_I)
+        bNrChannels             1
+        bSubframeSize           2
+        bBitResolution         16
+        bSamFreqType            1 Discrete
+        tSamFreq[ 0]        48000
+      Endpoint Descriptor:
+        bLength                 9
+        bDescriptorType         5
+        bEndpointAddress     0x86  EP 6 IN
+        bmAttributes            5
+          Transfer Type            Isochronous
+          Synch Type               Asynchronous
+          Usage Type               Data
+        wMaxPacketSize     0x00c4  1x 196 bytes
+        bInterval               4
+        bRefresh                0
+        bSynchAddress           0
+        AudioControl Endpoint Descriptor:
+          bLength                 7
+          bDescriptorType        37
+          bDescriptorSubtype      1 (EP_GENERAL)
+          bmAttributes         0x01
+            Sampling Frequency
+          bLockDelayUnits         0 Undefined
+          wLockDelay              0 Undefined
+Device Qualifier (for other device speed):
+  bLength                10
+  bDescriptorType         6
+  bcdUSB               2.00
+  bDeviceClass          239 Miscellaneous Device
+  bDeviceSubClass         2 ?
+  bDeviceProtocol         1 Interface Association
+  bMaxPacketSize0        64
+  bNumConfigurations      1
+Device Status:     0x0000
+  (Bus Powered)
diff --git a/3rdparty/libuvc/src/cameras/quickcampro9000_builtin_ctrls.txt b/3rdparty/libuvc/src/cameras/quickcampro9000_builtin_ctrls.txt
new file mode 100644
index 00000000..2b2969e9
--- /dev/null
+++ b/3rdparty/libuvc/src/cameras/quickcampro9000_builtin_ctrls.txt
@@ -0,0 +1,13 @@
+Listing available controls for device video0:
+  Exposure, Auto Priority
+  Exposure (Absolute)
+  Exposure, Auto
+  Backlight Compensation
+  Sharpness
+  White Balance Temperature
+  Power Line Frequency
+  Gain
+  White Balance Temperature, Auto
+  Saturation
+  Contrast
+  Brightness
diff --git a/3rdparty/libuvc/src/cameras/quickcampro9000_extra_ctrls.txt b/3rdparty/libuvc/src/cameras/quickcampro9000_extra_ctrls.txt
new file mode 100644
index 00000000..205aaf65
--- /dev/null
+++ b/3rdparty/libuvc/src/cameras/quickcampro9000_extra_ctrls.txt
@@ -0,0 +1,18 @@
+Listing available controls for device video0:
+  Raw bits per pixel
+  Disable video processing
+  LED1 Frequency
+  LED1 Mode
+  Focus
+  Exposure, Auto Priority
+  Exposure (Absolute)
+  Exposure, Auto
+  Backlight Compensation
+  Sharpness
+  White Balance Temperature
+  Power Line Frequency
+  Gain
+  White Balance Temperature, Auto
+  Saturation
+  Contrast
+  Brightness
diff --git a/3rdparty/libuvc/src/changelog.txt b/3rdparty/libuvc/src/changelog.txt
new file mode 100644
index 00000000..3501d4d2
--- /dev/null
+++ b/3rdparty/libuvc/src/changelog.txt
@@ -0,0 +1,114 @@
+Changes in 0.0.6 (2017-09-21)
+----------------
+
+New features:
+  - Added support for pkg-config.
+    - Silence pkg-config when searching for libjpeg
+    - Resolve pkg-config conflict, update CONF_LIBRARY #11
+    - Actually use pkg-config to find libjpeg, and set cflags and ldflags for it. #78
+    - Add a pkg-config file to allow build systems to identify the flags needed for compiling and linking against this library  #77
+  - Add support for 16-bit greyscale image format (Y16) #77
+  - Add support for 8-bit raw colour formats, specifically: BA81, GRBG, GBRG, RGGB and BGGR #77
+  - Improve detection of The Imaging Source Cameras that implement the UVC protocols but don't announce themselves as UVC cameras (and ignore similar cameras that appear to be UVC but are not). #77
+  - add routine for listing frame configs #76
+  - New Travis configuration
+  - Add uvc_find_devices function to support libuvc_ros index selection #36
+  - VideoStreaming status processing #30
+  - Add conversion from YUYV to Y (GRAY8) and UV (GRAY8) #27
+  - Add LICENSE.txt.
+  - Add Dw_clock_frequency field and populate acording to UVC1.0 or 1.1 spec. #19
+  - Changes to enable compilation with Windows MSVC #13
+    - Modify ABS_FMT macro to function correctly with MSVC.
+    - Implement gettimeofday for MSVC.
+    - Use portable memset instead of bzero for MSVC compatibility.
+    - Annotate libusb callback methods with LIBUSB_CALL for MSVC.
+
+  - Merge of bulk mode transfer support from Tridge, Mauricio and James (#8)
+    - Support for BY8 frames
+    - (Very basic) support for UVC1.1 camera data structures
+    - Support for frame-based video streams
+    - Support for TIS astro CCD cameras
+    - Squashed a few possible bugs
+    - Added section descriptions and control getter/setter documentation
+
+Bug fixes:
+  - update CMakeLists.txt
+    - Add missing include (for ${CMAKE_INSTALL_LIBDIR}), fix static-/shared-only build #15
+    - Allow both static and dynamic versions of library to be built to work more neatly when building into runtime and development packages #77
+
+  - Update device.c, reduce salience of the alert which end user perceives as more important than it actually is. #79
+  - Clean up transfer buffers when an error occurs #77
+  - Fixed the issue that camera control functions can not work well with some cameras #41
+   UVC specification says that low byte of wIndex (for camera control) is interface number for camera control interface but current implementation of libuvc expects it is always zero and sometimes cause trouble.
+   Fixed camera control issue when using uvc_get_ctrl_len/uvc_get_ctrl/uvc_set_ctrl with camera that interface number of camera control interface is not zero.
+  - In some (as yet unidentified) circumstances it is possible for an interface to be claimed more than once.  This can cause an error. #77
+  - A race allows queued transfers to arrive and be viable for resubmission even when a stream is no longer running. #77
+  - Querying stream controls before claiming the interface can fail, so claim the interface first, then do the query. #77
+  - Show error code in error message to help debugging #77
+  - Add specific error messages for unsupported frame formats to make failures clearer #77
+ - Clean up compiler warnings #77
+ - Remove libusb.h from the public header #62
+ - Fix the first captured image being dropped #51
+   The first frame generated by any camera was always lost in the libuvc layer, and not passed on to the listening application.
+   The start value of seq (thus hold_seq) could be arbitrary, but it must be non-zero. Both the callback listener and the polling function's last_seq / last_polled_seq start initialised to zero, which causes any image with hold_seq zero to be ignored.
+ - Build fix for Chromium #48, #58
+   Some platforms use different version of libusb. For instance, Chromium compiles libusb by itself. So hard coding of libuse version (i.e. <libusb-1.0/libusb.h>) causes compile failure.
+   Remove libusb.h from the public header, This should fix the include path problems seen when including libuvc.h into other programs
+ - pthread_cond_timedwait nanoseconds shouldn't be greater than 1 billion #47
+    While using the library and testing the timed poll with 500000 us wait time, I noticed that it often happened that the timedwait returned EINVAL.
+According to http://stackoverflow.com/questions/11319063/pthread-cond-timedwait-root-causes-of-einval
+this might happen for several reasons, and one of them is when the number of nanoseconds in the timespec is greater than 1 billion (1 billion = 1 second).
+    Thus, I added a check that correctly updates the seconds and nanoseconds, bringing the nanosecond values in the range 0-999999999.
+    In Issue #16 it is mentioned that code sometimes crashes on uvc_stream_get_frame with some specific timeout values, this might have been the cause.
+     Fix for wrong setting of pthread_cond_timedwait nanoseconds
+  - Fix control functions for processors and other devices #32
+    When using a control function that is pertinent to a particular device (such as a processing device), the id of that device needs to be passed to the camera, or the call will fail
+  - Added docs for some more controls and switched to yaml doc file
+  - Updated documentation index
+  - Enable uvc_mjpeg2rgb function, if JPEG is supported
+
+Changes in 0.0.5 (2014-07-19)
+----------------
+
+New features:
+ - Added support for all of the camera terminal and processing unit controls, including the controls
+   that appeared in UVC 1.1 and 1.5.
+ - Added LIBUVC_VERSION_GTE(major, minor, patch) macro.
+
+Bug fixes:
+ - Switching to explicit kernel driver detachment since auto_detach isn't available in libusb < 1.0.16.
+ - The cmake module now looks for libuvc.Dylib instead of libuvc.so on OS X.
+
+
+Changes in 0.0.4 (2014-06-26)
+----------------
+
+New features:
+ - Support devices with multiple streaming interfaces and multiple concurrent streams.
+   A new uvc_stream* API is added, along with a uvc_stream_handle type to encapsulate the
+   state of a single UVC stream. Multiple streams can run alongside each other, provided
+   your USB connection has enough bandwidth. Streams can be individually stopped and
+   resumed; the old uvc_start/stop_streaming API is still provided as a convenient way
+   to interact with the usual one-stream devices.
+ - Added support for MJPEG streams.
+ - Added functions for checking/setting autofocus mode.
+ - Added an interface to set/get arbitrary controls on units and terminals.
+ - Made the input, output, processing and extension units public.
+ - Implemented uvc_get_device and uvc_get_libusb_handle.
+ - Add a library-owned flag to uvc_frame_t so that users may allocate their own frame buffers.
+
+Bug fixes:
+ - Send frames as soon as they're received, not when the following frame arrives
+ - Fixed call to NULL when no status callback is provided.
+ - Fixed crash that occurred during shutdown if the USB device was disconnected during streaming.
+
+Miscellaneous improvements:
+ - Hid the transfer method (isochronous vs bulk) from the user. This was never really
+   selectable; the camera's streaming interface supports either bulk or isochronous
+   transfers, so now libuvc will figure out which one is appropriate. The `isochronous`
+   parameter has been converted to a `flags` parameter, which is currently unused but
+   could be used to convey up to 7 bits of stream mode information in the future.
+ - Improved the method for claiming the camera's interfaces.
+ - Renamed UVC_COLOR_FORMAT_* to UVC_FRAME_FORMAT_*. The old #defines are still available.
+ - Simplified format definition and lookup.
+ - Improved transfer status (error) handling.
diff --git a/3rdparty/libuvc/src/cmake/FindJpegPkg.cmake b/3rdparty/libuvc/src/cmake/FindJpegPkg.cmake
new file mode 100644
index 00000000..b533d9c2
--- /dev/null
+++ b/3rdparty/libuvc/src/cmake/FindJpegPkg.cmake
@@ -0,0 +1,82 @@
+#[==============================================[
+FindJpegPkg
+-----------
+
+Searching jpeg library library and creating imported
+target JPEG::JPEG (this is different from shipped one with CMake)
+
+#]==============================================]
+
+# TODO Append parts for Version compasion and REQUIRED support
+if (MSVC OR MINGW)
+  return()
+endif()
+
+# Try to find JPEG using a module or pkg-config. If that doesn't work, search for the header.
+if (NOT TARGET JPEG::JPEG)
+  find_package(JPEG)
+  if (JPEG_FOUND)
+    message(STATUS "Found JPEG library using standard module")
+    set(IMPORTED_JPEG_INCLUDE_DIRS ${JPEG_INCLUDE_DIR})
+    set(IMPORTED_JPEG_LIBRARIES ${JPEG_LIBRARIES})
+  else()
+    find_package(PkgConfig)
+    pkg_check_modules(JPEG libjpeg)
+    if(JPEG_FOUND)
+      message(STATUS "JPEG found by pkgconfig")
+
+      if (DEFINED JPEG_INCLUDE_DIRS)
+        set(IMPORTED_JPEG_INCLUDE_DIRS ${JPEG_INCLUDE_DIRS})
+      endif()
+
+      if(JPEG_LIBRARIES)
+        find_library(JPEG_LIBRARY
+          NAMES ${JPEG_LIBRARIES}
+          PATHS ${JPEG_LIBDIR} ${JPEG_LIBRARY_DIRS}
+        )
+        if(JPEG_LIBRARY)
+          set(IMPORTED_JPEG_LIBRARIES ${JPEG_LIBRARY})
+        else()
+          message(WARNING "Could not found libjpeg library file")
+        endif()
+      endif()
+    else()
+      message(STATUS "Searching library manually")
+      find_path(IMPORTED_JPEG_INCLUDE_DIRS
+        NAMES jpeglib.h
+      )
+
+      if (NOT IMPORTED_JPEG_LIBRARIES)
+        find_library(IMPORTED_JPEG_LIBRARIES
+            NAMES jpeg
+        )
+      endif()
+    endif()
+  endif()
+
+  include(FindPackageHandleStandardArgs)
+  find_package_handle_standard_args(JPEG
+      REQUIRED_VARS IMPORTED_JPEG_LIBRARIES IMPORTED_JPEG_INCLUDE_DIRS
+  )
+
+  if(JPEG_FOUND)
+    set(JpegPkg_FOUND TRUE)
+    if (NOT TARGET JPEG::JPEG)
+      add_library(JPEG::JPEG
+        UNKNOWN IMPORTED
+      )
+      if(IMPORTED_JPEG_INCLUDE_DIRS)
+        set_target_properties(JPEG::JPEG PROPERTIES
+          INTERFACE_INCLUDE_DIRECTORIES ${IMPORTED_JPEG_INCLUDE_DIRS}
+        )
+      endif()
+      if(IMPORTED_JPEG_LIBRARIES)
+        set_target_properties(JPEG::JPEG PROPERTIES
+          IMPORTED_LINK_INTERFACE_LANGUAGES "C" 
+          IMPORTED_LOCATION ${IMPORTED_JPEG_LIBRARIES}
+        )
+      endif()
+    endif()
+  endif()
+
+endif()
diff --git a/3rdparty/libuvc/src/cmake/FindLibUSB.cmake b/3rdparty/libuvc/src/cmake/FindLibUSB.cmake
new file mode 100644
index 00000000..ef9710ef
--- /dev/null
+++ b/3rdparty/libuvc/src/cmake/FindLibUSB.cmake
@@ -0,0 +1,51 @@
+#[==============================================[
+FindLibUSB
+-----------
+
+Searching libusb-1.0 library and creating imported 
+target LibUSB::LibUSB
+
+#]==============================================]
+
+# TODO Append parts for Version compasion and REQUIRED support
+
+if (MSVC OR MINGW)
+    return()
+endif()
+
+if (NOT TARGET LibUSB::LibUSB)
+  find_package(PkgConfig)
+  pkg_check_modules(LibUSB REQUIRED
+    libusb-1.0
+  )
+
+  if(LibUSB_FOUND)
+    message(STATUS "libusb-1.0 found using pkgconfig")
+
+    add_library(LibUSB::LibUSB
+      UNKNOWN IMPORTED
+    )
+    if (DEFINED LibUSB_INCLUDE_DIRS)
+      set_target_properties(LibUSB::LibUSB PROPERTIES
+        INTERFACE_INCLUDE_DIRECTORIES ${LibUSB_INCLUDE_DIRS}
+      )
+    endif()
+
+    if(LibUSB_LIBRARIES)
+      find_library(LibUSB_LIBRARY
+        NAMES ${LibUSB_LIBRARIES}
+        PATHS ${LibUSB_LIBDIR} ${LibUSB_LIBRARY_DIRS}
+      )
+      if(LibUSB_LIBRARY)
+        set_target_properties(LibUSB::LibUSB PROPERTIES
+          IMPORTED_LINK_INTERFACE_LANGUAGES "C"
+          IMPORTED_LOCATION ${LibUSB_LIBRARY}
+        )
+      else()
+        message(WARNING "Could not found libusb-1.0 library file")
+      endif()
+    endif()
+  endif()
+else()
+  message(WARNING "libusb-1.0 could not be found using pkgconfig")
+endif()
diff --git a/3rdparty/libuvc/src/cmake/FindOpenCVPkg.cmake b/3rdparty/libuvc/src/cmake/FindOpenCVPkg.cmake
new file mode 100644
index 00000000..9d12f8bd
--- /dev/null
+++ b/3rdparty/libuvc/src/cmake/FindOpenCVPkg.cmake
@@ -0,0 +1,86 @@
+#[==============================================[
+FindOpenCVPkg
+-----------
+
+Searching OpenCV components on systems which does not have fully installed OpenCV. 
+Such systems does not include OpenCVConfig.cmake and OpenCVConfigVersion.cmake files.
+Example of such system is Ubuntu 18.04.
+This package try to use OpenCV config file first if it exists.
+
+#]==============================================]
+
+if (${CMAKE_FIND_PACKAGE_NAME}_FIND_COMPONENTS)
+  set(comps ${${CMAKE_FIND_PACKAGE_NAME}_FIND_COMPONENTS})
+else()
+  set(comps)
+endif()
+
+list(LENGTH comps comps_count)
+message(STATUS "Components requested: ${comps}")
+
+# Try to find components using standard OpenCV config package
+if(comps_count GREATER 0)
+  find_package(OpenCV QUIET
+    COMPONENTS ${comps}
+  )
+  if(OpenCV_FOUND)
+    set(OpenCVPkg_FOUND TRUE)
+    return()    
+  endif()
+else()
+  find_package(OpenCV QUIET)
+  if(OpenCV_FOUND)
+    set(OpenCVPkg_FOUND TRUE)
+    return()    
+  endif()
+endif()
+
+if(comps_count EQUAL 0)
+  set(err_level)
+  if(${CMAKE_FIND_PACKAGE_NAME}_FIND_REQUIRED)
+    set(err_level FATAL_ERROR)
+  endif()
+  if (${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY)
+    set(err_level STATUS)
+  endif()
+  message(${err_level} "Without standart OpenCV config file you must list components you want")
+  return()
+endif()
+
+unset(required_comps_not_found)
+foreach(comp IN LISTS comps)
+  string(REPLACE "opencv_" "" comp_name ${comp})
+  set(include_rel_path "opencv2/${comp_name}.hpp" "opencv2/${comp_name}/${comp_name}.hpp")
+  find_path(OpenCV_${comp}_INCLUDE_DIR
+    NAMES ${include_rel_path}
+  )
+  find_library(OpenCV_${comp}_LIBRARY
+    NAMES ${comp}
+  )
+  if (${CMAKE_FIND_PACKAGE_NAME}_FIND_REQUIRED_${comp} AND 
+      (NOT OpenCV_${comp}_INCLUDE_DIR OR NOT OpenCV_${comp}_LIBRARY))
+    list(APPEND required_comps_not_found ${comp})
+  else()
+    message(STATUS "Found component ${comp}: ${OpenCV_${comp}_LIBRARY}")
+  endif()
+endforeach()
+
+if(required_comps_not_found)
+  message(FATAL_ERROR "Following required components not found: ${required_comps_not_found}")
+  return()
+endif()
+
+foreach(comp IN LISTS comps)
+  if(NOT TARGET ${comp})
+    message(STATUS "No target ${comp} yet. Creating it")
+    add_library(${comp}
+      UNKNOWN IMPORTED
+    )
+    set_target_properties(${comp} PROPERTIES
+      INTERFACE_INCLUDE_DIRECTORIES ${OpenCV_${comp}_INCLUDE_DIR}
+      IMPORTED_LOCATION ${OpenCV_${comp}_LIBRARY}
+    )
+  endif()
+endforeach()
+
+set(OpenCVPkg_FOUND TRUE)
diff --git a/3rdparty/libuvc/src/doxygen.conf b/3rdparty/libuvc/src/doxygen.conf
new file mode 100644
index 00000000..226134a2
--- /dev/null
+++ b/3rdparty/libuvc/src/doxygen.conf
@@ -0,0 +1,2284 @@
+# Doxyfile 1.8.5
+
+# 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 config 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 http://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           = libuvc
+
+# 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 an logo or 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       =
+
+# 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
+
+# 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, Brazilian, Catalan, Chinese, Chinese-
+# Traditional, Croatian, Czech, Danish, Dutch, English, Esperanto, Farsi,
+# Finnish, French, German, Greek, Hungarian, Italian, Japanese, Japanese-en,
+# Korean, Korean-en, Latvian, Norwegian, Macedonian, Persian, Polish,
+# Portuguese, Romanian, Russian, Serbian, 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       =
+
+# 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        = NO
+
+# 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        =
+
+# 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 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
+
+# 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.
+
+ALIASES                =
+
+# This tag can be used to specify a number of word-keyword mappings (TCL only).
+# A mapping has the form "name=value". For example adding "class=itcl::class"
+# will allow you to use the command class in the itcl::class meaning.
+
+TCL_SUBST              =
+
+# 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
+
+# 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,
+# C#, C, C++, D, PHP, Objective-C, Python, Fortran, VHDL. 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.
+
+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 http://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 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 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:
+# http://www.riverbankcomputing.co.uk/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
+
+# 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
+
+#---------------------------------------------------------------------------
+# 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            = NO
+
+# 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        = YES
+
+# 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         = YES
+
+# 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. When 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 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     = YES
+
+# 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     = YES
+
+# If the HIDE_FRIEND_COMPOUNDS tag is set to YES, doxygen will hide all friend
+# (class|struct|union) 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      = YES
+
+# 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
+
+# If the CASE_SENSE_NAMES tag is set to NO then doxygen will only generate file
+# names in lower-case letters. If set to YES upper-case letters are also
+# allowed. This is useful if you have classes or files whose names only differ
+# in case and if your file system supports case sensitive file names. Windows
+# and Mac users are advised to set this option to NO.
+# 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 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 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       = NO
+
+# 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.
+# 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      = NO
+
+# 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 http://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. Do not use file names with spaces, bibtex cannot handle them. 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                  = NO
+
+# 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.
+# The default value is: NO.
+
+WARN_NO_PARAMDOC       = 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.
+# Note: If this tag is empty the current directory is searched.
+
+INPUT                  = src \
+                         include/libuvc
+
+# 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: http://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. 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, *.py, *.f90, *.f, *.for, *.tcl, *.vhd, *.vhdl, *.ucf,
+# *.qsf, *.as and *.js.
+
+FILE_PATTERNS          =
+
+# 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                = include/libuvc/libuvc_internal.h \
+                         include/utlist.h
+
+# 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           = src
+
+# 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.
+
+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.
+
+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
+# function 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 http://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 config 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
+
+#---------------------------------------------------------------------------
+# 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
+
+# The COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns in
+# which the alphabetical index list will be split.
+# Minimum value: 1, maximum value: 20, default value: 5.
+# This tag requires that the tag ALPHABETICAL_INDEX is set to YES.
+
+COLS_IN_ALPHA_INDEX    = 5
+
+# 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            = doc
+
+# 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 an additional user-
+# defined cascading style sheet that is 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 therefor more robust against future updates.
+# Doxygen will copy the style sheet file to the output directory. 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 stylesheet and background images according to
+# this color. Hue is specified as an angle on a colorwheel, see
+# http://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_TIMESTAMP tag is set to YES then the footer of each generated HTML
+# page will contain the date and time when the page was generated. Setting this
+# to NO can help when comparing the output of multiple runs.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_TIMESTAMP         = 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  = YES
+
+# 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: http://developer.apple.com/tools/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 http://developer.apple.com/tools/creatingdocsetswithdoxygen.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: http://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 master .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.
+# 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: http://qt-project.org/doc/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: http://qt-project.org/doc/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: http://qt-project.org/doc/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: http://qt-project.org/doc/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:
+# http://qt-project.org/doc/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 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 stylesheets (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
+
+# When 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
+
+# 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
+
+# Use the FORMULA_TRANPARENT tag to determine whether or not the images
+# generated for formulas are transparent PNGs. Transparent PNGs are not
+# supported properly for IE 6.0, but are supported on all modern browsers.
+#
+# Note that when changing this option you need to delete any form_*.png files in
+# the HTML output directory before the changes have effect.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+FORMULA_TRANSPARENT    = YES
+
+# Enable the USE_MATHJAX option to render LaTeX formulas using MathJax (see
+# http://www.mathjax.org) which uses client side Javascript for the rendering
+# instead of using prerendered 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/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 http://www.mathjax.org before deployment.
+# The default value is: http://cdn.mathjax.org/mathjax/latest.
+# This tag requires that the tag USE_MATHJAX is set to YES.
+
+MATHJAX_RELPATH        = http://cdn.mathjax.org/mathjax/latest
+
+# 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/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           = NO
+
+# 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 flavours 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: http://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: http://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 enabling USE_PDFLATEX this option is only used for generating
+# bitmaps for formulas in the HTML output, but not in the Makefile that is
+# written to the output directory.
+# The default file is: latex.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_CMD_NAME         = latex
+
+# The MAKEINDEX_CMD_NAME tag can be used to specify the command name to generate
+# index for LaTeX.
+# The default file is: makeindex.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+MAKEINDEX_CMD_NAME     = 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             = a4wide
+
+# The EXTRA_PACKAGES tag can be used to specify one or more LaTeX package names
+# that should be included in the LaTeX output. To get the times font for
+# instance you can specify
+# EXTRA_PACKAGES=times
+# 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. Doxygen will
+# replace them by respectively the title of the page, the current date and time,
+# only the current date, the version number of doxygen, the project name (see
+# PROJECT_NAME), or the project number (see PROJECT_NUMBER).
+# 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.
+#
+# 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_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         = NO
+
+# If the LATEX_PDFLATEX tag is set to YES, doxygen will use pdflatex to generate
+# the PDF file directly from the LaTeX files. Set this option to YES to get a
+# higher quality PDF documentation.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+USE_PDFLATEX           = NO
+
+# 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
+
+# If the LATEX_SOURCE_CODE tag is set to YES then doxygen will include source
+# code with syntax highlighting in the LaTeX output.
+#
+# Note that which sources are shown also depends on other settings such as
+# SOURCE_BROWSER.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_SOURCE_CODE      = NO
+
+# The LATEX_BIB_STYLE tag can be used to specify the style to use for the
+# bibliography, e.g. plainnat, or ieeetr. See
+# http://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
+
+#---------------------------------------------------------------------------
+# 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 config
+# 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 config 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           = NO
+
+# 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
+
+# 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
+
+# The XML_SCHEMA tag can be used to specify a XML schema, which can be used by a
+# validating XML parser to check the syntax of the XML files.
+# This tag requires that the tag GENERATE_XML is set to YES.
+
+XML_SCHEMA             =
+
+# The XML_DTD tag can be used to specify a XML DTD, which can be used by a
+# validating XML parser to check the syntax of the XML files.
+# This tag requires that the tag GENERATE_XML is set to YES.
+
+XML_DTD                =
+
+# 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
+
+#---------------------------------------------------------------------------
+# 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.sf.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 includes 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             = API_EXPORTED= \
+                         LIBUSB_CALL= \
+                         DEFAULT_VISIBILITY=
+
+# 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 refrences 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 an 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
+
+# The PERL_PATH should be the absolute path and name of the perl script
+# interpreter (i.e. the result of 'which perl').
+# The default file (with absolute path) is: /usr/bin/perl.
+
+PERL_PATH              = /usr/bin/perl
+
+#---------------------------------------------------------------------------
+# Configuration options related to the dot tool
+#---------------------------------------------------------------------------
+
+# If the CLASS_DIAGRAMS tag is set to YES doxygen will generate a class diagram
+# (in HTML and LaTeX) for classes with base or super classes. Setting the tag to
+# NO turns the diagrams off. Note that this option also works with HAVE_DOT
+# disabled, but it is recommended to install and use dot, since it yields more
+# powerful graphs.
+# The default value is: YES.
+
+CLASS_DIAGRAMS         = YES
+
+# You can define message sequence charts within doxygen comments using the \msc
+# command. Doxygen will then run the mscgen tool (see:
+# http://www.mcternan.me.uk/mscgen/)) to produce the chart and insert it in the
+# documentation. The MSCGEN_PATH tag allows you to specify the directory where
+# the mscgen tool resides. If left empty the tool is assumed to be found in the
+# default search path.
+
+MSCGEN_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: NO.
+
+HAVE_DOT               = NO
+
+# 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
+
+# When you want a differently looking font n the dot files that doxygen
+# generates you can specify the font name using DOT_FONTNAME. You need to make
+# sure dot is able to find the font, which can be done by putting it in a
+# standard location or by setting the DOTFONTPATH environment variable or by
+# setting DOT_FONTPATH to the directory containing the font.
+# The default value is: Helvetica.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_FONTNAME           = FreeSans.ttf
+
+# The DOT_FONTSIZE tag can be used to set the size (in points) of the font of
+# dot graphs.
+# Minimum value: 4, maximum value: 24, default value: 10.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_FONTSIZE           = 10
+
+# 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 HAVE_DOT is set to YES.
+
+UML_LIMIT_NUM_FIELDS   = 10
+
+# 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.
+# 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.
+# 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.
+# 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, jpg, gif and svg.
+# 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 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_TRANSPARENT tag to YES to generate images with a transparent
+# background. This is disabled by default, because dot on Windows does not seem
+# to support this out of the box.
+#
+# Warning: Depending on the platform used, enabling this option may lead to
+# badly anti-aliased labels on the edges of a graph (i.e. they become hard to
+# read).
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_TRANSPARENT        = NO
+
+# Set the DOT_MULTI_TARGETS tag to YES 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 dot
+# files that are used to generate the various graphs.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_CLEANUP            = YES
diff --git a/3rdparty/libuvc/src/include/libuvc/libuvc.h b/3rdparty/libuvc/src/include/libuvc/libuvc.h
new file mode 100644
index 00000000..264a0c4c
--- /dev/null
+++ b/3rdparty/libuvc/src/include/libuvc/libuvc.h
@@ -0,0 +1,764 @@
+#ifndef LIBUVC_H
+#define LIBUVC_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdio.h>  // FILE
+#include <stdint.h>
+#include <sys/time.h>
+#include <libuvc/libuvc_config.h>
+
+struct libusb_context;
+struct libusb_device_handle;
+
+/** UVC error types, based on libusb errors
+ * @ingroup diag
+ */
+typedef enum uvc_error {
+    /** Success (no error) */
+    UVC_SUCCESS = 0,
+    /** Input/output error */
+    UVC_ERROR_IO = -1,
+    /** Invalid parameter */
+    UVC_ERROR_INVALID_PARAM = -2,
+    /** Access denied */
+    UVC_ERROR_ACCESS = -3,
+    /** No such device */
+    UVC_ERROR_NO_DEVICE = -4,
+    /** Entity not found */
+    UVC_ERROR_NOT_FOUND = -5,
+    /** Resource busy */
+    UVC_ERROR_BUSY = -6,
+    /** Operation timed out */
+    UVC_ERROR_TIMEOUT = -7,
+    /** Overflow */
+    UVC_ERROR_OVERFLOW = -8,
+    /** Pipe error */
+    UVC_ERROR_PIPE = -9,
+    /** System call interrupted */
+    UVC_ERROR_INTERRUPTED = -10,
+    /** Insufficient memory */
+    UVC_ERROR_NO_MEM = -11,
+    /** Operation not supported */
+    UVC_ERROR_NOT_SUPPORTED = -12,
+    /** Device is not UVC-compliant */
+    UVC_ERROR_INVALID_DEVICE = -50,
+    /** Mode not supported */
+    UVC_ERROR_INVALID_MODE = -51,
+    /** Resource has a callback (can't use polling and async) */
+    UVC_ERROR_CALLBACK_EXISTS = -52,
+    /** Undefined error */
+    UVC_ERROR_OTHER = -99
+} uvc_error_t;
+
+/** Color coding of stream, transport-independent
+ * @ingroup streaming
+ */
+enum uvc_frame_format {
+    UVC_FRAME_FORMAT_UNKNOWN = 0,
+    /** Any supported format */
+    UVC_FRAME_FORMAT_ANY = 0,
+    UVC_FRAME_FORMAT_UNCOMPRESSED,
+    UVC_FRAME_FORMAT_COMPRESSED,
+    /** YUYV/YUV2/YUV422: YUV encoding with one luminance value per pixel and
+     * one UV (chrominance) pair for every two pixels.
+     */
+    UVC_FRAME_FORMAT_YUYV,
+    UVC_FRAME_FORMAT_UYVY,
+    /** 24-bit RGB */
+    UVC_FRAME_FORMAT_RGB,
+    UVC_FRAME_FORMAT_BGR,
+    /** Motion-JPEG (or JPEG) encoded images */
+    UVC_FRAME_FORMAT_MJPEG,
+    UVC_FRAME_FORMAT_H264,
+    /** Greyscale images */
+    UVC_FRAME_FORMAT_GRAY8,
+    UVC_FRAME_FORMAT_GRAY16,
+    /* Raw colour mosaic images */
+    UVC_FRAME_FORMAT_BY8,
+    UVC_FRAME_FORMAT_BA81,
+    UVC_FRAME_FORMAT_SGRBG8,
+    UVC_FRAME_FORMAT_SGBRG8,
+    UVC_FRAME_FORMAT_SRGGB8,
+    UVC_FRAME_FORMAT_SBGGR8,
+    /** YUV420: NV12 */
+    UVC_FRAME_FORMAT_NV12,
+
+    /** Number of formats understood */
+    UVC_FRAME_FORMAT_HEVC,  // h265
+    UVC_FRAME_FORMAT_I420,  // i420
+    UVC_FRAME_FORMAT_NV21,  // nv12
+
+    // orbbec format
+    UVC_FRAME_FORMAT_Y8,
+    UVC_FRAME_FORMAT_Y10,
+    UVC_FRAME_FORMAT_Y11,
+    UVC_FRAME_FORMAT_Y12,
+    UVC_FRAME_FORMAT_Y14,
+    UVC_FRAME_FORMAT_RVL,
+    // UVC_FRAME_FORMAT_Y16, // as UVC_FRAME_FORMAT_GRAY16
+    UVC_FRAME_FORMAT_Z16,
+    UVC_FRAME_FORMAT_YV12,
+
+
+    UVC_FRAME_FORMAT_COUNT,
+};
+
+/* UVC_COLOR_FORMAT_* have been replaced with UVC_FRAME_FORMAT_*. Please use
+ * UVC_FRAME_FORMAT_* instead of using these. */
+#define UVC_COLOR_FORMAT_UNKNOWN UVC_FRAME_FORMAT_UNKNOWN
+#define UVC_COLOR_FORMAT_UNCOMPRESSED UVC_FRAME_FORMAT_UNCOMPRESSED
+#define UVC_COLOR_FORMAT_COMPRESSED UVC_FRAME_FORMAT_COMPRESSED
+#define UVC_COLOR_FORMAT_YUYV UVC_FRAME_FORMAT_YUYV
+#define UVC_COLOR_FORMAT_UYVY UVC_FRAME_FORMAT_UYVY
+#define UVC_COLOR_FORMAT_RGB UVC_FRAME_FORMAT_RGB
+#define UVC_COLOR_FORMAT_BGR UVC_FRAME_FORMAT_BGR
+#define UVC_COLOR_FORMAT_MJPEG UVC_FRAME_FORMAT_MJPEG
+#define UVC_COLOR_FORMAT_GRAY8 UVC_FRAME_FORMAT_GRAY8
+#define UVC_COLOR_FORMAT_GRAY16 UVC_FRAME_FORMAT_GRAY16
+#define UVC_COLOR_FORMAT_NV12 UVC_FRAME_FORMAT_NV12
+#define UVC_FRAME_FORMAT_Y16 UVC_FRAME_FORMAT_GRAY16
+
+/** VideoStreaming interface descriptor subtype (A.6) */
+enum uvc_vs_desc_subtype {
+    UVC_VS_UNDEFINED           = 0x00,
+    UVC_VS_INPUT_HEADER        = 0x01,
+    UVC_VS_OUTPUT_HEADER       = 0x02,
+    UVC_VS_STILL_IMAGE_FRAME   = 0x03,
+    UVC_VS_FORMAT_UNCOMPRESSED = 0x04,
+    UVC_VS_FRAME_UNCOMPRESSED  = 0x05,
+    UVC_VS_FORMAT_MJPEG        = 0x06,
+    UVC_VS_FRAME_MJPEG         = 0x07,
+    UVC_VS_FORMAT_MPEG2TS      = 0x0a,
+    UVC_VS_FORMAT_DV           = 0x0c,
+    UVC_VS_COLORFORMAT         = 0x0d,
+    UVC_VS_FORMAT_FRAME_BASED  = 0x10,
+    UVC_VS_FRAME_FRAME_BASED   = 0x11,
+    UVC_VS_FORMAT_STREAM_BASED = 0x12
+};
+
+struct uvc_format_desc;
+struct uvc_frame_desc;
+
+typedef struct uvc_still_frame_res {
+    struct uvc_still_frame_res *prev, *next;
+    uint8_t                     bResolutionIndex;
+    /** Image width */
+    uint16_t wWidth;
+    /** Image height */
+    uint16_t wHeight;
+} uvc_still_frame_res_t;
+
+typedef struct uvc_still_frame_desc {
+    struct uvc_format_desc      *parent;
+    struct uvc_still_frame_desc *prev, *next;
+    /** Type of frame, such as JPEG frame or uncompressed frme */
+    enum uvc_vs_desc_subtype bDescriptorSubtype;
+    /** Index of the frame within the list of specs available for this format */
+    uint8_t                bEndPointAddress;
+    uvc_still_frame_res_t *imageSizePatterns;
+    uint8_t                bNumCompressionPattern;
+    /* indication of compression level, the higher, the more compression is applied to image */
+    uint8_t *bCompression;
+} uvc_still_frame_desc_t;
+
+/** Frame descriptor
+ *
+ * A "frame" is a configuration of a streaming format
+ * for a particular image size at one of possibly several
+ * available frame rates.
+ */
+typedef struct uvc_frame_desc {
+    struct uvc_format_desc *parent;
+    struct uvc_frame_desc  *prev, *next;
+    /** Type of frame, such as JPEG frame or uncompressed frme */
+    enum uvc_vs_desc_subtype bDescriptorSubtype;
+    /** Index of the frame within the list of specs available for this format */
+    uint8_t bFrameIndex;
+    uint8_t bmCapabilities;
+    /** Image width */
+    uint16_t wWidth;
+    /** Image height */
+    uint16_t wHeight;
+    /** Bitrate of corresponding stream at minimal frame rate */
+    uint32_t dwMinBitRate;
+    /** Bitrate of corresponding stream at maximal frame rate */
+    uint32_t dwMaxBitRate;
+    /** Maximum number of bytes for a video frame */
+    uint32_t dwMaxVideoFrameBufferSize;
+    /** Default frame interval (in 100ns units) */
+    uint32_t dwDefaultFrameInterval;
+    /** Minimum frame interval for continuous mode (100ns units) */
+    uint32_t dwMinFrameInterval;
+    /** Maximum frame interval for continuous mode (100ns units) */
+    uint32_t dwMaxFrameInterval;
+    /** Granularity of frame interval range for continuous mode (100ns) */
+    uint32_t dwFrameIntervalStep;
+    /** Frame intervals */
+    uint8_t bFrameIntervalType;
+    /** number of bytes per line */
+    uint32_t dwBytesPerLine;
+    /** Available frame rates, zero-terminated (in 100ns units) */
+    uint32_t *intervals;
+} uvc_frame_desc_t;
+
+/** Format descriptor
+ *
+ * A "format" determines a stream's image type (e.g., raw YUYV or JPEG)
+ * and includes many "frame" configurations.
+ */
+typedef struct uvc_format_desc {
+    struct uvc_streaming_interface *parent;
+    struct uvc_format_desc         *prev, *next;
+    /** Type of image stream, such as JPEG or uncompressed. */
+    enum uvc_vs_desc_subtype bDescriptorSubtype;
+    /** Identifier of this format within the VS interface's format list */
+    uint8_t bFormatIndex;
+    uint8_t bNumFrameDescriptors;
+    /** Format specifier */
+    union {
+        uint8_t guidFormat[16];
+        uint8_t fourccFormat[4];
+    };
+    /** Format-specific data */
+    union {
+        /** BPP for uncompressed stream */
+        uint8_t bBitsPerPixel;
+        /** Flags for JPEG stream */
+        uint8_t bmFlags;
+    };
+    /** Default {uvc_frame_desc} to choose given this format */
+    uint8_t bDefaultFrameIndex;
+    uint8_t bAspectRatioX;
+    uint8_t bAspectRatioY;
+    uint8_t bmInterlaceFlags;
+    uint8_t bCopyProtect;
+    uint8_t bVariableSize;
+    /** Available frame specifications for this format */
+    struct uvc_frame_desc       *frame_descs;
+    struct uvc_still_frame_desc *still_frame_desc;
+} uvc_format_desc_t;
+
+/** UVC request code (A.8) */
+enum uvc_req_code {
+    UVC_RC_UNDEFINED = 0x00,
+    UVC_SET_CUR      = 0x01,
+    UVC_GET_CUR      = 0x81,
+    UVC_GET_MIN      = 0x82,
+    UVC_GET_MAX      = 0x83,
+    UVC_GET_RES      = 0x84,
+    UVC_GET_LEN      = 0x85,
+    UVC_GET_INFO     = 0x86,
+    UVC_GET_DEF      = 0x87
+};
+
+enum uvc_device_power_mode {
+    UVC_VC_VIDEO_POWER_MODE_FULL             = 0x000b,
+    UVC_VC_VIDEO_POWER_MODE_DEVICE_DEPENDENT = 0x001b,
+};
+
+/** Camera terminal control selector (A.9.4) */
+enum uvc_ct_ctrl_selector {
+    UVC_CT_CONTROL_UNDEFINED              = 0x00,
+    UVC_CT_SCANNING_MODE_CONTROL          = 0x01,
+    UVC_CT_AE_MODE_CONTROL                = 0x02,
+    UVC_CT_AE_PRIORITY_CONTROL            = 0x03,
+    UVC_CT_EXPOSURE_TIME_ABSOLUTE_CONTROL = 0x04,
+    UVC_CT_EXPOSURE_TIME_RELATIVE_CONTROL = 0x05,
+    UVC_CT_FOCUS_ABSOLUTE_CONTROL         = 0x06,
+    UVC_CT_FOCUS_RELATIVE_CONTROL         = 0x07,
+    UVC_CT_FOCUS_AUTO_CONTROL             = 0x08,
+    UVC_CT_IRIS_ABSOLUTE_CONTROL          = 0x09,
+    UVC_CT_IRIS_RELATIVE_CONTROL          = 0x0a,
+    UVC_CT_ZOOM_ABSOLUTE_CONTROL          = 0x0b,
+    UVC_CT_ZOOM_RELATIVE_CONTROL          = 0x0c,
+    UVC_CT_PANTILT_ABSOLUTE_CONTROL       = 0x0d,
+    UVC_CT_PANTILT_RELATIVE_CONTROL       = 0x0e,
+    UVC_CT_ROLL_ABSOLUTE_CONTROL          = 0x0f,
+    UVC_CT_ROLL_RELATIVE_CONTROL          = 0x10,
+    UVC_CT_PRIVACY_CONTROL                = 0x11,
+    UVC_CT_FOCUS_SIMPLE_CONTROL           = 0x12,
+    UVC_CT_DIGITAL_WINDOW_CONTROL         = 0x13,
+    UVC_CT_REGION_OF_INTEREST_CONTROL     = 0x14
+};
+
+/** Processing unit control selector (A.9.5) */
+enum uvc_pu_ctrl_selector {
+    UVC_PU_CONTROL_UNDEFINED                      = 0x00,
+    UVC_PU_BACKLIGHT_COMPENSATION_CONTROL         = 0x01,
+    UVC_PU_BRIGHTNESS_CONTROL                     = 0x02,
+    UVC_PU_CONTRAST_CONTROL                       = 0x03,
+    UVC_PU_GAIN_CONTROL                           = 0x04,
+    UVC_PU_POWER_LINE_FREQUENCY_CONTROL           = 0x05,
+    UVC_PU_HUE_CONTROL                            = 0x06,
+    UVC_PU_SATURATION_CONTROL                     = 0x07,
+    UVC_PU_SHARPNESS_CONTROL                      = 0x08,
+    UVC_PU_GAMMA_CONTROL                          = 0x09,
+    UVC_PU_WHITE_BALANCE_TEMPERATURE_CONTROL      = 0x0a,
+    UVC_PU_WHITE_BALANCE_TEMPERATURE_AUTO_CONTROL = 0x0b,
+    UVC_PU_WHITE_BALANCE_COMPONENT_CONTROL        = 0x0c,
+    UVC_PU_WHITE_BALANCE_COMPONENT_AUTO_CONTROL   = 0x0d,
+    UVC_PU_DIGITAL_MULTIPLIER_CONTROL             = 0x0e,
+    UVC_PU_DIGITAL_MULTIPLIER_LIMIT_CONTROL       = 0x0f,
+    UVC_PU_HUE_AUTO_CONTROL                       = 0x10,
+    UVC_PU_ANALOG_VIDEO_STANDARD_CONTROL          = 0x11,
+    UVC_PU_ANALOG_LOCK_STATUS_CONTROL             = 0x12,
+    UVC_PU_CONTRAST_AUTO_CONTROL                  = 0x13
+};
+
+/** USB terminal type (B.1) */
+enum uvc_term_type { UVC_TT_VENDOR_SPECIFIC = 0x0100, UVC_TT_STREAMING = 0x0101 };
+
+/** Input terminal type (B.2) */
+enum uvc_it_type { UVC_ITT_VENDOR_SPECIFIC = 0x0200, UVC_ITT_CAMERA = 0x0201, UVC_ITT_MEDIA_TRANSPORT_INPUT = 0x0202 };
+
+/** Output terminal type (B.3) */
+enum uvc_ot_type { UVC_OTT_VENDOR_SPECIFIC = 0x0300, UVC_OTT_DISPLAY = 0x0301, UVC_OTT_MEDIA_TRANSPORT_OUTPUT = 0x0302 };
+
+/** External terminal type (B.4) */
+enum uvc_et_type { UVC_EXTERNAL_VENDOR_SPECIFIC = 0x0400, UVC_COMPOSITE_CONNECTOR = 0x0401, UVC_SVIDEO_CONNECTOR = 0x0402, UVC_COMPONENT_CONNECTOR = 0x0403 };
+
+/** Context, equivalent to libusb's contexts.
+ *
+ * May either own a libusb context or use one that's already made.
+ *
+ * Always create these with uvc_get_context.
+ */
+struct uvc_context;
+typedef struct uvc_context uvc_context_t;
+
+/** UVC device.
+ *
+ * Get this from uvc_get_device_list() or uvc_find_device().
+ */
+struct uvc_device;
+typedef struct uvc_device uvc_device_t;
+
+/** Handle on an open UVC device.
+ *
+ * Get one of these from uvc_open(). Once you uvc_close()
+ * it, it's no longer valid.
+ */
+struct uvc_device_handle;
+typedef struct uvc_device_handle uvc_device_handle_t;
+
+/** Handle on an open UVC stream.
+ *
+ * Get one of these from uvc_stream_open*().
+ * Once you uvc_stream_close() it, it will no longer be valid.
+ */
+struct uvc_stream_handle;
+typedef struct uvc_stream_handle uvc_stream_handle_t;
+
+/** Representation of the interface that brings data into the UVC device */
+typedef struct uvc_input_terminal {
+    struct uvc_input_terminal *prev, *next;
+    /** Index of the terminal within the device */
+    uint8_t bTerminalID;
+    /** Type of terminal (e.g., camera) */
+    enum uvc_it_type wTerminalType;
+    uint16_t         wObjectiveFocalLengthMin;
+    uint16_t         wObjectiveFocalLengthMax;
+    uint16_t         wOcularFocalLength;
+    /** Camera controls (meaning of bits given in {uvc_ct_ctrl_selector}) */
+    uint64_t bmControls;
+} uvc_input_terminal_t;
+
+typedef struct uvc_output_terminal {
+    struct uvc_output_terminal *prev, *next;
+    /** @todo */
+} uvc_output_terminal_t;
+
+/** Represents post-capture processing functions */
+typedef struct uvc_processing_unit {
+    struct uvc_processing_unit *prev, *next;
+    /** Index of the processing unit within the device */
+    uint8_t bUnitID;
+    /** Index of the terminal from which the device accepts images */
+    uint8_t bSourceID;
+    /** Processing controls (meaning of bits given in {uvc_pu_ctrl_selector}) */
+    uint64_t bmControls;
+} uvc_processing_unit_t;
+
+/** Represents selector unit to connect other units */
+typedef struct uvc_selector_unit {
+    struct uvc_selector_unit *prev, *next;
+    /** Index of the selector unit within the device */
+    uint8_t bUnitID;
+} uvc_selector_unit_t;
+
+/** Custom processing or camera-control functions */
+typedef struct uvc_extension_unit {
+    struct uvc_extension_unit *prev, *next;
+    /** Index of the extension unit within the device */
+    uint8_t bUnitID;
+    /** GUID identifying the extension unit */
+    uint8_t guidExtensionCode[16];
+    /** Bitmap of available controls (manufacturer-dependent) */
+    uint64_t bmControls;
+} uvc_extension_unit_t;
+
+enum uvc_status_class {
+    UVC_STATUS_CLASS_CONTROL            = 0x10,
+    UVC_STATUS_CLASS_CONTROL_CAMERA     = 0x11,
+    UVC_STATUS_CLASS_CONTROL_PROCESSING = 0x12,
+};
+
+enum uvc_status_attribute {
+    UVC_STATUS_ATTRIBUTE_VALUE_CHANGE   = 0x00,
+    UVC_STATUS_ATTRIBUTE_INFO_CHANGE    = 0x01,
+    UVC_STATUS_ATTRIBUTE_FAILURE_CHANGE = 0x02,
+    UVC_STATUS_ATTRIBUTE_UNKNOWN        = 0xff
+};
+
+/** A callback function to accept status updates
+ * @ingroup device
+ */
+typedef void(uvc_status_callback_t)(enum uvc_status_class status_class, int event, int selector, enum uvc_status_attribute status_attribute, void *data,
+                                    size_t data_len, void *user_ptr);
+
+/** A callback function to accept button events
+ * @ingroup device
+ */
+typedef void(uvc_button_callback_t)(int button, int state, void *user_ptr);
+
+/** Structure representing a UVC device descriptor.
+ *
+ * (This isn't a standard structure.)
+ */
+typedef struct uvc_device_descriptor {
+    /** Vendor ID */
+    uint16_t idVendor;
+    /** Product ID */
+    uint16_t idProduct;
+    /** UVC compliance level, e.g. 0x0100 (1.0), 0x0110 */
+    uint16_t bcdUVC;
+    /** Serial number (null if unavailable) */
+    const char *serialNumber;
+    /** Device-reported manufacturer name (or null) */
+    const char *manufacturer;
+    /** Device-reporter product name (or null) */
+    const char *product;
+} uvc_device_descriptor_t;
+
+/** An image frame received from the UVC device
+ * @ingroup streaming
+ */
+typedef struct uvc_frame {
+    /** Image data for this frame */
+    void *data;
+    /** Size of image data buffer */
+    size_t data_bytes;
+    /** Width of image in pixels */
+    uint32_t width;
+    /** Height of image in pixels */
+    uint32_t height;
+    /** Pixel data format */
+    enum uvc_frame_format frame_format;
+    /** Number of bytes per horizontal line (undefined for compressed format) */
+    size_t step;
+    /** Frame number (may skip, but is strictly monotonically increasing) */
+    uint32_t sequence;
+    /** Estimate of system time when the device started capturing the image */
+    struct timeval capture_time;
+    /** Estimate of system time when the device finished receiving the image */
+    struct timespec capture_time_finished;
+    /** Handle on the device that produced the image.
+     * @warning You must not call any uvc_* functions during a callback. */
+    uvc_device_handle_t *source;
+    /** Is the data buffer owned by the library?
+     * If 1, the data buffer can be arbitrarily reallocated by frame conversion
+     * functions.
+     * If 0, the data buffer will not be reallocated or freed by the library.
+     * Set this field to zero if you are supplying the buffer.
+     */
+    uint8_t library_owns_data;
+
+    /** Metadata for this frame if available */
+    void *metadata;
+    /** Size of metadata buffer */
+    size_t metadata_bytes;
+
+    /** Payload header for this frame (payload header of first payload for this frame)*/
+    void *payload_header;
+    /** Size of metadata buffer */
+    size_t payload_header_bytes;
+
+    uint32_t pts;  // pts of frame
+
+    void  *headerdata;
+    size_t headerdata_bytes;
+} uvc_frame_t;
+
+/** A callback function to handle incoming assembled UVC frames
+ * @ingroup streaming
+ */
+typedef void(uvc_frame_callback_t)(struct uvc_frame *frame, void *user_ptr);
+
+/** Streaming mode, includes all information needed to select stream
+ * @ingroup streaming
+ */
+typedef struct uvc_stream_ctrl {
+    uint16_t bmHint;
+    uint8_t  bFormatIndex;
+    uint8_t  bFrameIndex;
+    uint32_t dwFrameInterval;
+    uint16_t wKeyFrameRate;
+    uint16_t wPFrameRate;
+    uint16_t wCompQuality;
+    uint16_t wCompWindowSize;
+    uint16_t wDelay;
+    uint32_t dwMaxVideoFrameSize;
+    uint32_t dwMaxPayloadTransferSize;
+    uint32_t dwClockFrequency;
+    uint8_t  bmFramingInfo;
+    uint8_t  bPreferredVersion;
+    uint8_t  bMinVersion;
+    uint8_t  bMaxVersion;
+    uint8_t  bInterfaceNumber;
+} uvc_stream_ctrl_t;
+
+typedef struct uvc_still_ctrl {
+    /* Video format index from a format descriptor */
+    uint8_t bFormatIndex;
+    /* Video frame index from a frame descriptor */
+    uint8_t bFrameIndex;
+    /* Compression index from a frame descriptor */
+    uint8_t bCompressionIndex;
+    /* Maximum still image size in bytes. */
+    uint32_t dwMaxVideoFrameSize;
+    /* Maximum number of byte per payload*/
+    uint32_t dwMaxPayloadTransferSize;
+    uint8_t  bInterfaceNumber;
+} uvc_still_ctrl_t;
+
+uvc_error_t uvc_init(uvc_context_t **ctx, struct libusb_context *usb_ctx);
+void        uvc_exit(uvc_context_t *ctx);
+
+uvc_error_t uvc_get_device_list(uvc_context_t *ctx, uvc_device_t ***list);
+void        uvc_free_device_list(uvc_device_t **list, uint8_t unref_devices);
+
+uvc_error_t uvc_get_device_descriptor(uvc_device_t *dev, uvc_device_descriptor_t **desc);
+void        uvc_free_device_descriptor(uvc_device_descriptor_t *desc);
+
+uint8_t uvc_get_bus_number(uvc_device_t *dev);
+uint8_t uvc_get_device_address(uvc_device_t *dev);
+
+uvc_error_t uvc_find_device(uvc_context_t *ctx, uvc_device_t **dev, int vid, int pid, const char *sn);
+
+uvc_error_t uvc_find_devices(uvc_context_t *ctx, uvc_device_t ***devs, int vid, int pid, const char *sn);
+
+uvc_error_t uvc_open(uvc_device_t *dev, uint16_t mi, uvc_device_handle_t **devh, struct libusb_device_handle *usbh);
+void        uvc_close(uvc_device_handle_t *devh);
+
+uvc_device_t                *uvc_get_device(uvc_device_handle_t *devh);
+struct libusb_device_handle *uvc_get_libusb_handle(uvc_device_handle_t *devh);
+
+void uvc_ref_device(uvc_device_t *dev);
+void uvc_unref_device(uvc_device_t *dev);
+
+void uvc_set_status_callback(uvc_device_handle_t *devh, uvc_status_callback_t cb, void *user_ptr);
+
+void uvc_set_button_callback(uvc_device_handle_t *devh, uvc_button_callback_t cb, void *user_ptr);
+
+const uvc_input_terminal_t  *uvc_get_camera_terminal(uvc_device_handle_t *devh);
+const uvc_input_terminal_t  *uvc_get_input_terminals(uvc_device_handle_t *devh);
+const uvc_output_terminal_t *uvc_get_output_terminals(uvc_device_handle_t *devh);
+const uvc_selector_unit_t   *uvc_get_selector_units(uvc_device_handle_t *devh);
+const uvc_processing_unit_t *uvc_get_processing_units(uvc_device_handle_t *devh);
+const uvc_extension_unit_t  *uvc_get_extension_units(uvc_device_handle_t *devh);
+
+uvc_error_t uvc_get_stream_ctrl_format_size(uvc_device_handle_t *devh, uvc_stream_ctrl_t *ctrl, enum uvc_frame_format format, int width, int height, int fps);
+
+uvc_error_t uvc_get_still_ctrl_format_size(uvc_device_handle_t *devh, uvc_stream_ctrl_t *ctrl, uvc_still_ctrl_t *still_ctrl, int width, int height);
+
+uvc_error_t uvc_trigger_still(uvc_device_handle_t *devh, uvc_still_ctrl_t *still_ctrl);
+
+const uvc_format_desc_t *uvc_get_format_descs(uvc_device_handle_t *);
+
+uvc_error_t uvc_probe_stream_ctrl(uvc_device_handle_t *devh, uvc_stream_ctrl_t *ctrl);
+
+uvc_error_t uvc_probe_still_ctrl(uvc_device_handle_t *devh, uvc_still_ctrl_t *still_ctrl);
+
+uvc_error_t uvc_start_streaming(uvc_device_handle_t *devh, uvc_stream_ctrl_t *ctrl, uvc_frame_callback_t *cb, void *user_ptr, uint8_t flags);
+uvc_error_t uvc_start_streaming_A(uvc_device_handle_t *devh, uvc_stream_ctrl_t *ctrl, uvc_frame_callback_t *cb, void *user_ptr, uint8_t flags, int32_t bufNum);
+
+uvc_error_t uvc_start_iso_streaming(uvc_device_handle_t *devh, uvc_stream_ctrl_t *ctrl, uvc_frame_callback_t *cb, void *user_ptr);
+
+void uvc_stop_streaming(uvc_device_handle_t *devh);
+
+uvc_error_t uvc_stream_open_ctrl(uvc_device_handle_t *devh, uvc_stream_handle_t **strmh, uvc_stream_ctrl_t *ctrl);
+uvc_error_t uvc_stream_ctrl(uvc_stream_handle_t *strmh, uvc_stream_ctrl_t *ctrl);
+uvc_error_t uvc_stream_start(uvc_stream_handle_t *strmh, uvc_frame_callback_t *cb, void *user_ptr, uint8_t flags);
+uvc_error_t uvc_stream_start_iso(uvc_stream_handle_t *strmh, uvc_frame_callback_t *cb, void *user_ptr);
+uvc_error_t uvc_stream_get_frame(uvc_stream_handle_t *strmh, uvc_frame_t **frame, int32_t timeout_us);
+uvc_error_t uvc_stream_stop(uvc_stream_handle_t *strmh);
+void        uvc_stream_close(uvc_stream_handle_t *strmh);
+
+int uvc_get_ctrl_len(uvc_device_handle_t *devh, uint8_t unit, uint8_t ctrl);
+int uvc_get_ctrl(uvc_device_handle_t *devh, uint8_t unit, uint8_t ctrl, void *data, int len, enum uvc_req_code req_code);
+int uvc_set_ctrl(uvc_device_handle_t *devh, uint8_t unit, uint8_t ctrl, void *data, int len);
+
+uvc_error_t uvc_get_power_mode(uvc_device_handle_t *devh, enum uvc_device_power_mode *mode, enum uvc_req_code req_code);
+uvc_error_t uvc_set_power_mode(uvc_device_handle_t *devh, enum uvc_device_power_mode mode);
+
+/* AUTO-GENERATED control accessors! Update them with the output of `ctrl-gen.py decl`. */
+uvc_error_t uvc_get_scanning_mode(uvc_device_handle_t *devh, uint8_t *mode, enum uvc_req_code req_code);
+uvc_error_t uvc_set_scanning_mode(uvc_device_handle_t *devh, uint8_t mode);
+
+uvc_error_t uvc_get_ae_mode(uvc_device_handle_t *devh, uint8_t *mode, enum uvc_req_code req_code);
+uvc_error_t uvc_set_ae_mode(uvc_device_handle_t *devh, uint8_t mode);
+
+uvc_error_t uvc_get_ae_priority(uvc_device_handle_t *devh, uint8_t *priority, enum uvc_req_code req_code);
+uvc_error_t uvc_set_ae_priority(uvc_device_handle_t *devh, uint8_t priority);
+
+uvc_error_t uvc_get_exposure_abs(uvc_device_handle_t *devh, uint32_t *time, enum uvc_req_code req_code);
+uvc_error_t uvc_set_exposure_abs(uvc_device_handle_t *devh, uint32_t time);
+
+uvc_error_t uvc_get_exposure_rel(uvc_device_handle_t *devh, int8_t *step, enum uvc_req_code req_code);
+uvc_error_t uvc_set_exposure_rel(uvc_device_handle_t *devh, int8_t step);
+
+uvc_error_t uvc_get_focus_abs(uvc_device_handle_t *devh, uint16_t *focus, enum uvc_req_code req_code);
+uvc_error_t uvc_set_focus_abs(uvc_device_handle_t *devh, uint16_t focus);
+
+uvc_error_t uvc_get_focus_rel(uvc_device_handle_t *devh, int8_t *focus_rel, uint8_t *speed, enum uvc_req_code req_code);
+uvc_error_t uvc_set_focus_rel(uvc_device_handle_t *devh, int8_t focus_rel, uint8_t speed);
+
+uvc_error_t uvc_get_focus_simple_range(uvc_device_handle_t *devh, uint8_t *focus, enum uvc_req_code req_code);
+uvc_error_t uvc_set_focus_simple_range(uvc_device_handle_t *devh, uint8_t focus);
+
+uvc_error_t uvc_get_focus_auto(uvc_device_handle_t *devh, uint8_t *state, enum uvc_req_code req_code);
+uvc_error_t uvc_set_focus_auto(uvc_device_handle_t *devh, uint8_t state);
+
+uvc_error_t uvc_get_iris_abs(uvc_device_handle_t *devh, uint16_t *iris, enum uvc_req_code req_code);
+uvc_error_t uvc_set_iris_abs(uvc_device_handle_t *devh, uint16_t iris);
+
+uvc_error_t uvc_get_iris_rel(uvc_device_handle_t *devh, uint8_t *iris_rel, enum uvc_req_code req_code);
+uvc_error_t uvc_set_iris_rel(uvc_device_handle_t *devh, uint8_t iris_rel);
+
+uvc_error_t uvc_get_zoom_abs(uvc_device_handle_t *devh, uint16_t *focal_length, enum uvc_req_code req_code);
+uvc_error_t uvc_set_zoom_abs(uvc_device_handle_t *devh, uint16_t focal_length);
+
+uvc_error_t uvc_get_zoom_rel(uvc_device_handle_t *devh, int8_t *zoom_rel, uint8_t *digital_zoom, uint8_t *speed, enum uvc_req_code req_code);
+uvc_error_t uvc_set_zoom_rel(uvc_device_handle_t *devh, int8_t zoom_rel, uint8_t digital_zoom, uint8_t speed);
+
+uvc_error_t uvc_get_pantilt_abs(uvc_device_handle_t *devh, int32_t *pan, int32_t *tilt, enum uvc_req_code req_code);
+uvc_error_t uvc_set_pantilt_abs(uvc_device_handle_t *devh, int32_t pan, int32_t tilt);
+
+uvc_error_t uvc_get_pantilt_rel(uvc_device_handle_t *devh, int8_t *pan_rel, uint8_t *pan_speed, int8_t *tilt_rel, uint8_t *tilt_speed,
+                                enum uvc_req_code req_code);
+uvc_error_t uvc_set_pantilt_rel(uvc_device_handle_t *devh, int8_t pan_rel, uint8_t pan_speed, int8_t tilt_rel, uint8_t tilt_speed);
+
+uvc_error_t uvc_get_roll_abs(uvc_device_handle_t *devh, int16_t *roll, enum uvc_req_code req_code);
+uvc_error_t uvc_set_roll_abs(uvc_device_handle_t *devh, int16_t roll);
+
+uvc_error_t uvc_get_roll_rel(uvc_device_handle_t *devh, int8_t *roll_rel, uint8_t *speed, enum uvc_req_code req_code);
+uvc_error_t uvc_set_roll_rel(uvc_device_handle_t *devh, int8_t roll_rel, uint8_t speed);
+
+uvc_error_t uvc_get_privacy(uvc_device_handle_t *devh, uint8_t *privacy, enum uvc_req_code req_code);
+uvc_error_t uvc_set_privacy(uvc_device_handle_t *devh, uint8_t privacy);
+
+uvc_error_t uvc_get_digital_window(uvc_device_handle_t *devh, uint16_t *window_top, uint16_t *window_left, uint16_t *window_bottom, uint16_t *window_right,
+                                   uint16_t *num_steps, uint16_t *num_steps_units, enum uvc_req_code req_code);
+uvc_error_t uvc_set_digital_window(uvc_device_handle_t *devh, uint16_t window_top, uint16_t window_left, uint16_t window_bottom, uint16_t window_right,
+                                   uint16_t num_steps, uint16_t num_steps_units);
+
+uvc_error_t uvc_get_digital_roi(uvc_device_handle_t *devh, uint16_t *roi_top, uint16_t *roi_left, uint16_t *roi_bottom, uint16_t *roi_right,
+                                uint16_t *auto_controls, enum uvc_req_code req_code);
+uvc_error_t uvc_set_digital_roi(uvc_device_handle_t *devh, uint16_t roi_top, uint16_t roi_left, uint16_t roi_bottom, uint16_t roi_right,
+                                uint16_t auto_controls);
+
+uvc_error_t uvc_get_backlight_compensation(uvc_device_handle_t *devh, uint16_t *backlight_compensation, enum uvc_req_code req_code);
+uvc_error_t uvc_set_backlight_compensation(uvc_device_handle_t *devh, uint16_t backlight_compensation);
+
+uvc_error_t uvc_get_brightness(uvc_device_handle_t *devh, int16_t *brightness, enum uvc_req_code req_code);
+uvc_error_t uvc_set_brightness(uvc_device_handle_t *devh, int16_t brightness);
+
+uvc_error_t uvc_get_contrast(uvc_device_handle_t *devh, uint16_t *contrast, enum uvc_req_code req_code);
+uvc_error_t uvc_set_contrast(uvc_device_handle_t *devh, uint16_t contrast);
+
+uvc_error_t uvc_get_contrast_auto(uvc_device_handle_t *devh, uint8_t *contrast_auto, enum uvc_req_code req_code);
+uvc_error_t uvc_set_contrast_auto(uvc_device_handle_t *devh, uint8_t contrast_auto);
+
+uvc_error_t uvc_get_gain(uvc_device_handle_t *devh, uint16_t *gain, enum uvc_req_code req_code);
+uvc_error_t uvc_set_gain(uvc_device_handle_t *devh, uint16_t gain);
+
+uvc_error_t uvc_get_power_line_frequency(uvc_device_handle_t *devh, uint8_t *power_line_frequency, enum uvc_req_code req_code);
+uvc_error_t uvc_set_power_line_frequency(uvc_device_handle_t *devh, uint8_t power_line_frequency);
+
+uvc_error_t uvc_get_hue(uvc_device_handle_t *devh, int16_t *hue, enum uvc_req_code req_code);
+uvc_error_t uvc_set_hue(uvc_device_handle_t *devh, int16_t hue);
+
+uvc_error_t uvc_get_hue_auto(uvc_device_handle_t *devh, uint8_t *hue_auto, enum uvc_req_code req_code);
+uvc_error_t uvc_set_hue_auto(uvc_device_handle_t *devh, uint8_t hue_auto);
+
+uvc_error_t uvc_get_saturation(uvc_device_handle_t *devh, uint16_t *saturation, enum uvc_req_code req_code);
+uvc_error_t uvc_set_saturation(uvc_device_handle_t *devh, uint16_t saturation);
+
+uvc_error_t uvc_get_sharpness(uvc_device_handle_t *devh, uint16_t *sharpness, enum uvc_req_code req_code);
+uvc_error_t uvc_set_sharpness(uvc_device_handle_t *devh, uint16_t sharpness);
+
+uvc_error_t uvc_get_gamma(uvc_device_handle_t *devh, uint16_t *gamma, enum uvc_req_code req_code);
+uvc_error_t uvc_set_gamma(uvc_device_handle_t *devh, uint16_t gamma);
+
+uvc_error_t uvc_get_white_balance_temperature(uvc_device_handle_t *devh, uint16_t *temperature, enum uvc_req_code req_code);
+uvc_error_t uvc_set_white_balance_temperature(uvc_device_handle_t *devh, uint16_t temperature);
+
+uvc_error_t uvc_get_white_balance_temperature_auto(uvc_device_handle_t *devh, uint8_t *temperature_auto, enum uvc_req_code req_code);
+uvc_error_t uvc_set_white_balance_temperature_auto(uvc_device_handle_t *devh, uint8_t temperature_auto);
+
+uvc_error_t uvc_get_white_balance_component(uvc_device_handle_t *devh, uint16_t *blue, uint16_t *red, enum uvc_req_code req_code);
+uvc_error_t uvc_set_white_balance_component(uvc_device_handle_t *devh, uint16_t blue, uint16_t red);
+
+uvc_error_t uvc_get_white_balance_component_auto(uvc_device_handle_t *devh, uint8_t *white_balance_component_auto, enum uvc_req_code req_code);
+uvc_error_t uvc_set_white_balance_component_auto(uvc_device_handle_t *devh, uint8_t white_balance_component_auto);
+
+uvc_error_t uvc_get_digital_multiplier(uvc_device_handle_t *devh, uint16_t *multiplier_step, enum uvc_req_code req_code);
+uvc_error_t uvc_set_digital_multiplier(uvc_device_handle_t *devh, uint16_t multiplier_step);
+
+uvc_error_t uvc_get_digital_multiplier_limit(uvc_device_handle_t *devh, uint16_t *multiplier_step, enum uvc_req_code req_code);
+uvc_error_t uvc_set_digital_multiplier_limit(uvc_device_handle_t *devh, uint16_t multiplier_step);
+
+uvc_error_t uvc_get_analog_video_standard(uvc_device_handle_t *devh, uint8_t *video_standard, enum uvc_req_code req_code);
+uvc_error_t uvc_set_analog_video_standard(uvc_device_handle_t *devh, uint8_t video_standard);
+
+uvc_error_t uvc_get_analog_video_lock_status(uvc_device_handle_t *devh, uint8_t *status, enum uvc_req_code req_code);
+uvc_error_t uvc_set_analog_video_lock_status(uvc_device_handle_t *devh, uint8_t status);
+
+uvc_error_t uvc_get_input_select(uvc_device_handle_t *devh, uint8_t *selector, enum uvc_req_code req_code);
+uvc_error_t uvc_set_input_select(uvc_device_handle_t *devh, uint8_t selector);
+/* end AUTO-GENERATED control accessors */
+
+void        uvc_perror(uvc_error_t err, const char *msg);
+const char *uvc_strerror(uvc_error_t err);
+void        uvc_print_diag(uvc_device_handle_t *devh, FILE *stream);
+void        uvc_print_stream_ctrl(uvc_stream_ctrl_t *ctrl, FILE *stream);
+
+uvc_frame_t *uvc_allocate_frame(size_t data_bytes);
+void         uvc_free_frame(uvc_frame_t *frame);
+
+uvc_error_t uvc_duplicate_frame(uvc_frame_t *in, uvc_frame_t *out);
+
+uvc_error_t uvc_yuyv2rgb(uvc_frame_t *in, uvc_frame_t *out);
+uvc_error_t uvc_uyvy2rgb(uvc_frame_t *in, uvc_frame_t *out);
+uvc_error_t uvc_any2rgb(uvc_frame_t *in, uvc_frame_t *out);
+
+uvc_error_t uvc_yuyv2bgr(uvc_frame_t *in, uvc_frame_t *out);
+uvc_error_t uvc_uyvy2bgr(uvc_frame_t *in, uvc_frame_t *out);
+uvc_error_t uvc_any2bgr(uvc_frame_t *in, uvc_frame_t *out);
+
+uvc_error_t uvc_yuyv2y(uvc_frame_t *in, uvc_frame_t *out);
+uvc_error_t uvc_yuyv2uv(uvc_frame_t *in, uvc_frame_t *out);
+
+#ifdef LIBUVC_HAS_JPEG
+uvc_error_t uvc_mjpeg2rgb(uvc_frame_t *in, uvc_frame_t *out);
+uvc_error_t uvc_mjpeg2gray(uvc_frame_t *in, uvc_frame_t *out);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // !def(LIBUVC_H)
diff --git a/3rdparty/libuvc/src/include/libuvc/libuvc.h.original b/3rdparty/libuvc/src/include/libuvc/libuvc.h.original
new file mode 100644
index 00000000..d5ada200
--- /dev/null
+++ b/3rdparty/libuvc/src/include/libuvc/libuvc.h.original
@@ -0,0 +1,803 @@
+#ifndef LIBUVC_H
+#define LIBUVC_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdio.h> // FILE
+#include <stdint.h>
+#include <sys/time.h>
+#include <libuvc/libuvc_config.h>
+
+struct libusb_context;
+struct libusb_device_handle;
+
+/** UVC error types, based on libusb errors
+ * @ingroup diag
+ */
+typedef enum uvc_error {
+  /** Success (no error) */
+  UVC_SUCCESS = 0,
+  /** Input/output error */
+  UVC_ERROR_IO = -1,
+  /** Invalid parameter */
+  UVC_ERROR_INVALID_PARAM = -2,
+  /** Access denied */
+  UVC_ERROR_ACCESS = -3,
+  /** No such device */
+  UVC_ERROR_NO_DEVICE = -4,
+  /** Entity not found */
+  UVC_ERROR_NOT_FOUND = -5,
+  /** Resource busy */
+  UVC_ERROR_BUSY = -6,
+  /** Operation timed out */
+  UVC_ERROR_TIMEOUT = -7,
+  /** Overflow */
+  UVC_ERROR_OVERFLOW = -8,
+  /** Pipe error */
+  UVC_ERROR_PIPE = -9,
+  /** System call interrupted */
+  UVC_ERROR_INTERRUPTED = -10,
+  /** Insufficient memory */
+  UVC_ERROR_NO_MEM = -11,
+  /** Operation not supported */
+  UVC_ERROR_NOT_SUPPORTED = -12,
+  /** Device is not UVC-compliant */
+  UVC_ERROR_INVALID_DEVICE = -50,
+  /** Mode not supported */
+  UVC_ERROR_INVALID_MODE = -51,
+  /** Resource has a callback (can't use polling and async) */
+  UVC_ERROR_CALLBACK_EXISTS = -52,
+  /** Undefined error */
+  UVC_ERROR_OTHER = -99
+} uvc_error_t;
+
+/** Color coding of stream, transport-independent
+ * @ingroup streaming
+ */
+enum uvc_frame_format {
+  UVC_FRAME_FORMAT_UNKNOWN = 0,
+  /** Any supported format */
+  UVC_FRAME_FORMAT_ANY = 0,
+  UVC_FRAME_FORMAT_UNCOMPRESSED,
+  UVC_FRAME_FORMAT_COMPRESSED,
+  /** YUYV/YUV2/YUV422: YUV encoding with one luminance value per pixel and
+   * one UV (chrominance) pair for every two pixels.
+   */
+  UVC_FRAME_FORMAT_YUYV,
+  UVC_FRAME_FORMAT_UYVY,
+  /** 24-bit RGB */
+  UVC_FRAME_FORMAT_RGB,
+  UVC_FRAME_FORMAT_BGR,
+  /** Motion-JPEG (or JPEG) encoded images */
+  UVC_FRAME_FORMAT_MJPEG,
+  UVC_FRAME_FORMAT_H264,
+  /** Greyscale images */
+  UVC_FRAME_FORMAT_GRAY8,
+  UVC_FRAME_FORMAT_GRAY16,
+  /* Raw colour mosaic images */
+  UVC_FRAME_FORMAT_BY8,
+  UVC_FRAME_FORMAT_BA81,
+  UVC_FRAME_FORMAT_SGRBG8,
+  UVC_FRAME_FORMAT_SGBRG8,
+  UVC_FRAME_FORMAT_SRGGB8,
+  UVC_FRAME_FORMAT_SBGGR8,
+  /** YUV420: NV12 */
+  UVC_FRAME_FORMAT_NV12,
+  /** Number of formats understood */
+  UVC_FRAME_FORMAT_COUNT,
+};
+
+/* UVC_COLOR_FORMAT_* have been replaced with UVC_FRAME_FORMAT_*. Please use
+ * UVC_FRAME_FORMAT_* instead of using these. */
+#define UVC_COLOR_FORMAT_UNKNOWN UVC_FRAME_FORMAT_UNKNOWN
+#define UVC_COLOR_FORMAT_UNCOMPRESSED UVC_FRAME_FORMAT_UNCOMPRESSED
+#define UVC_COLOR_FORMAT_COMPRESSED UVC_FRAME_FORMAT_COMPRESSED
+#define UVC_COLOR_FORMAT_YUYV UVC_FRAME_FORMAT_YUYV
+#define UVC_COLOR_FORMAT_UYVY UVC_FRAME_FORMAT_UYVY
+#define UVC_COLOR_FORMAT_RGB UVC_FRAME_FORMAT_RGB
+#define UVC_COLOR_FORMAT_BGR UVC_FRAME_FORMAT_BGR
+#define UVC_COLOR_FORMAT_MJPEG UVC_FRAME_FORMAT_MJPEG
+#define UVC_COLOR_FORMAT_GRAY8 UVC_FRAME_FORMAT_GRAY8
+#define UVC_COLOR_FORMAT_GRAY16 UVC_FRAME_FORMAT_GRAY16
+#define UVC_COLOR_FORMAT_NV12 UVC_FRAME_FORMAT_NV12
+
+/** VideoStreaming interface descriptor subtype (A.6) */
+enum uvc_vs_desc_subtype {
+  UVC_VS_UNDEFINED = 0x00,
+  UVC_VS_INPUT_HEADER = 0x01,
+  UVC_VS_OUTPUT_HEADER = 0x02,
+  UVC_VS_STILL_IMAGE_FRAME = 0x03,
+  UVC_VS_FORMAT_UNCOMPRESSED = 0x04,
+  UVC_VS_FRAME_UNCOMPRESSED = 0x05,
+  UVC_VS_FORMAT_MJPEG = 0x06,
+  UVC_VS_FRAME_MJPEG = 0x07,
+  UVC_VS_FORMAT_MPEG2TS = 0x0a,
+  UVC_VS_FORMAT_DV = 0x0c,
+  UVC_VS_COLORFORMAT = 0x0d,
+  UVC_VS_FORMAT_FRAME_BASED = 0x10,
+  UVC_VS_FRAME_FRAME_BASED = 0x11,
+  UVC_VS_FORMAT_STREAM_BASED = 0x12
+};
+
+struct uvc_format_desc;
+struct uvc_frame_desc;
+
+typedef struct uvc_still_frame_res {
+  struct uvc_still_frame_res *prev, *next;
+  uint8_t bResolutionIndex;
+  /** Image width */
+  uint16_t wWidth;
+  /** Image height */
+  uint16_t wHeight;
+} uvc_still_frame_res_t;
+
+typedef struct uvc_still_frame_desc {
+  struct uvc_format_desc *parent;
+  struct uvc_still_frame_desc *prev, *next;
+  /** Type of frame, such as JPEG frame or uncompressed frme */
+  enum uvc_vs_desc_subtype bDescriptorSubtype;
+  /** Index of the frame within the list of specs available for this format */
+  uint8_t bEndPointAddress;
+  uvc_still_frame_res_t* imageSizePatterns;
+  uint8_t bNumCompressionPattern;
+  /* indication of compression level, the higher, the more compression is applied to image */
+  uint8_t* bCompression;
+} uvc_still_frame_desc_t;
+
+/** Frame descriptor
+ *
+ * A "frame" is a configuration of a streaming format
+ * for a particular image size at one of possibly several
+ * available frame rates.
+ */
+typedef struct uvc_frame_desc {
+  struct uvc_format_desc *parent;
+  struct uvc_frame_desc *prev, *next;
+  /** Type of frame, such as JPEG frame or uncompressed frme */
+  enum uvc_vs_desc_subtype bDescriptorSubtype;
+  /** Index of the frame within the list of specs available for this format */
+  uint8_t bFrameIndex;
+  uint8_t bmCapabilities;
+  /** Image width */
+  uint16_t wWidth;
+  /** Image height */
+  uint16_t wHeight;
+  /** Bitrate of corresponding stream at minimal frame rate */
+  uint32_t dwMinBitRate;
+  /** Bitrate of corresponding stream at maximal frame rate */
+  uint32_t dwMaxBitRate;
+  /** Maximum number of bytes for a video frame */
+  uint32_t dwMaxVideoFrameBufferSize;
+  /** Default frame interval (in 100ns units) */
+  uint32_t dwDefaultFrameInterval;
+  /** Minimum frame interval for continuous mode (100ns units) */
+  uint32_t dwMinFrameInterval;
+  /** Maximum frame interval for continuous mode (100ns units) */
+  uint32_t dwMaxFrameInterval;
+  /** Granularity of frame interval range for continuous mode (100ns) */
+  uint32_t dwFrameIntervalStep;
+  /** Frame intervals */
+  uint8_t bFrameIntervalType;
+  /** number of bytes per line */
+  uint32_t dwBytesPerLine;
+  /** Available frame rates, zero-terminated (in 100ns units) */
+  uint32_t *intervals;
+} uvc_frame_desc_t;
+
+/** Format descriptor
+ *
+ * A "format" determines a stream's image type (e.g., raw YUYV or JPEG)
+ * and includes many "frame" configurations.
+ */
+typedef struct uvc_format_desc {
+  struct uvc_streaming_interface *parent;
+  struct uvc_format_desc *prev, *next;
+  /** Type of image stream, such as JPEG or uncompressed. */
+  enum uvc_vs_desc_subtype bDescriptorSubtype;
+  /** Identifier of this format within the VS interface's format list */
+  uint8_t bFormatIndex;
+  uint8_t bNumFrameDescriptors;
+  /** Format specifier */
+  union {
+    uint8_t guidFormat[16];
+    uint8_t fourccFormat[4];
+  };
+  /** Format-specific data */
+  union {
+    /** BPP for uncompressed stream */
+    uint8_t bBitsPerPixel;
+    /** Flags for JPEG stream */
+    uint8_t bmFlags;
+  };
+  /** Default {uvc_frame_desc} to choose given this format */
+  uint8_t bDefaultFrameIndex;
+  uint8_t bAspectRatioX;
+  uint8_t bAspectRatioY;
+  uint8_t bmInterlaceFlags;
+  uint8_t bCopyProtect;
+  uint8_t bVariableSize;
+  /** Available frame specifications for this format */
+  struct uvc_frame_desc *frame_descs;
+  struct uvc_still_frame_desc *still_frame_desc;
+} uvc_format_desc_t;
+
+/** UVC request code (A.8) */
+enum uvc_req_code {
+  UVC_RC_UNDEFINED = 0x00,
+  UVC_SET_CUR = 0x01,
+  UVC_GET_CUR = 0x81,
+  UVC_GET_MIN = 0x82,
+  UVC_GET_MAX = 0x83,
+  UVC_GET_RES = 0x84,
+  UVC_GET_LEN = 0x85,
+  UVC_GET_INFO = 0x86,
+  UVC_GET_DEF = 0x87
+};
+
+enum uvc_device_power_mode {
+  UVC_VC_VIDEO_POWER_MODE_FULL = 0x000b,
+  UVC_VC_VIDEO_POWER_MODE_DEVICE_DEPENDENT = 0x001b,
+};
+
+/** Camera terminal control selector (A.9.4) */
+enum uvc_ct_ctrl_selector {
+  UVC_CT_CONTROL_UNDEFINED = 0x00,
+  UVC_CT_SCANNING_MODE_CONTROL = 0x01,
+  UVC_CT_AE_MODE_CONTROL = 0x02,
+  UVC_CT_AE_PRIORITY_CONTROL = 0x03,
+  UVC_CT_EXPOSURE_TIME_ABSOLUTE_CONTROL = 0x04,
+  UVC_CT_EXPOSURE_TIME_RELATIVE_CONTROL = 0x05,
+  UVC_CT_FOCUS_ABSOLUTE_CONTROL = 0x06,
+  UVC_CT_FOCUS_RELATIVE_CONTROL = 0x07,
+  UVC_CT_FOCUS_AUTO_CONTROL = 0x08,
+  UVC_CT_IRIS_ABSOLUTE_CONTROL = 0x09,
+  UVC_CT_IRIS_RELATIVE_CONTROL = 0x0a,
+  UVC_CT_ZOOM_ABSOLUTE_CONTROL = 0x0b,
+  UVC_CT_ZOOM_RELATIVE_CONTROL = 0x0c,
+  UVC_CT_PANTILT_ABSOLUTE_CONTROL = 0x0d,
+  UVC_CT_PANTILT_RELATIVE_CONTROL = 0x0e,
+  UVC_CT_ROLL_ABSOLUTE_CONTROL = 0x0f,
+  UVC_CT_ROLL_RELATIVE_CONTROL = 0x10,
+  UVC_CT_PRIVACY_CONTROL = 0x11,
+  UVC_CT_FOCUS_SIMPLE_CONTROL = 0x12,
+  UVC_CT_DIGITAL_WINDOW_CONTROL = 0x13,
+  UVC_CT_REGION_OF_INTEREST_CONTROL = 0x14
+};
+
+/** Processing unit control selector (A.9.5) */
+enum uvc_pu_ctrl_selector {
+  UVC_PU_CONTROL_UNDEFINED = 0x00,
+  UVC_PU_BACKLIGHT_COMPENSATION_CONTROL = 0x01,
+  UVC_PU_BRIGHTNESS_CONTROL = 0x02,
+  UVC_PU_CONTRAST_CONTROL = 0x03,
+  UVC_PU_GAIN_CONTROL = 0x04,
+  UVC_PU_POWER_LINE_FREQUENCY_CONTROL = 0x05,
+  UVC_PU_HUE_CONTROL = 0x06,
+  UVC_PU_SATURATION_CONTROL = 0x07,
+  UVC_PU_SHARPNESS_CONTROL = 0x08,
+  UVC_PU_GAMMA_CONTROL = 0x09,
+  UVC_PU_WHITE_BALANCE_TEMPERATURE_CONTROL = 0x0a,
+  UVC_PU_WHITE_BALANCE_TEMPERATURE_AUTO_CONTROL = 0x0b,
+  UVC_PU_WHITE_BALANCE_COMPONENT_CONTROL = 0x0c,
+  UVC_PU_WHITE_BALANCE_COMPONENT_AUTO_CONTROL = 0x0d,
+  UVC_PU_DIGITAL_MULTIPLIER_CONTROL = 0x0e,
+  UVC_PU_DIGITAL_MULTIPLIER_LIMIT_CONTROL = 0x0f,
+  UVC_PU_HUE_AUTO_CONTROL = 0x10,
+  UVC_PU_ANALOG_VIDEO_STANDARD_CONTROL = 0x11,
+  UVC_PU_ANALOG_LOCK_STATUS_CONTROL = 0x12,
+  UVC_PU_CONTRAST_AUTO_CONTROL = 0x13
+};
+
+/** USB terminal type (B.1) */
+enum uvc_term_type {
+  UVC_TT_VENDOR_SPECIFIC = 0x0100,
+  UVC_TT_STREAMING = 0x0101
+};
+
+/** Input terminal type (B.2) */
+enum uvc_it_type {
+  UVC_ITT_VENDOR_SPECIFIC = 0x0200,
+  UVC_ITT_CAMERA = 0x0201,
+  UVC_ITT_MEDIA_TRANSPORT_INPUT = 0x0202
+};
+
+/** Output terminal type (B.3) */
+enum uvc_ot_type {
+  UVC_OTT_VENDOR_SPECIFIC = 0x0300,
+  UVC_OTT_DISPLAY = 0x0301,
+  UVC_OTT_MEDIA_TRANSPORT_OUTPUT = 0x0302
+};
+
+/** External terminal type (B.4) */
+enum uvc_et_type {
+  UVC_EXTERNAL_VENDOR_SPECIFIC = 0x0400,
+  UVC_COMPOSITE_CONNECTOR = 0x0401,
+  UVC_SVIDEO_CONNECTOR = 0x0402,
+  UVC_COMPONENT_CONNECTOR = 0x0403
+};
+
+/** Context, equivalent to libusb's contexts.
+ *
+ * May either own a libusb context or use one that's already made.
+ *
+ * Always create these with uvc_get_context.
+ */
+struct uvc_context;
+typedef struct uvc_context uvc_context_t;
+
+/** UVC device.
+ *
+ * Get this from uvc_get_device_list() or uvc_find_device().
+ */
+struct uvc_device;
+typedef struct uvc_device uvc_device_t;
+
+/** Handle on an open UVC device.
+ *
+ * Get one of these from uvc_open(). Once you uvc_close()
+ * it, it's no longer valid.
+ */
+struct uvc_device_handle;
+typedef struct uvc_device_handle uvc_device_handle_t;
+
+/** Handle on an open UVC stream.
+ *
+ * Get one of these from uvc_stream_open*().
+ * Once you uvc_stream_close() it, it will no longer be valid.
+ */
+struct uvc_stream_handle;
+typedef struct uvc_stream_handle uvc_stream_handle_t;
+
+/** Representation of the interface that brings data into the UVC device */
+typedef struct uvc_input_terminal {
+  struct uvc_input_terminal *prev, *next;
+  /** Index of the terminal within the device */
+  uint8_t bTerminalID;
+  /** Type of terminal (e.g., camera) */
+  enum uvc_it_type wTerminalType;
+  uint16_t wObjectiveFocalLengthMin;
+  uint16_t wObjectiveFocalLengthMax;
+  uint16_t wOcularFocalLength;
+  /** Camera controls (meaning of bits given in {uvc_ct_ctrl_selector}) */
+  uint64_t bmControls;
+} uvc_input_terminal_t;
+
+typedef struct uvc_output_terminal {
+  struct uvc_output_terminal *prev, *next;
+  /** @todo */
+} uvc_output_terminal_t;
+
+/** Represents post-capture processing functions */
+typedef struct uvc_processing_unit {
+  struct uvc_processing_unit *prev, *next;
+  /** Index of the processing unit within the device */
+  uint8_t bUnitID;
+  /** Index of the terminal from which the device accepts images */
+  uint8_t bSourceID;
+  /** Processing controls (meaning of bits given in {uvc_pu_ctrl_selector}) */
+  uint64_t bmControls;
+} uvc_processing_unit_t;
+
+/** Represents selector unit to connect other units */
+typedef struct uvc_selector_unit {
+  struct uvc_selector_unit *prev, *next;
+  /** Index of the selector unit within the device */
+  uint8_t bUnitID;
+} uvc_selector_unit_t;
+
+/** Custom processing or camera-control functions */
+typedef struct uvc_extension_unit {
+  struct uvc_extension_unit *prev, *next;
+  /** Index of the extension unit within the device */
+  uint8_t bUnitID;
+  /** GUID identifying the extension unit */
+  uint8_t guidExtensionCode[16];
+  /** Bitmap of available controls (manufacturer-dependent) */
+  uint64_t bmControls;
+} uvc_extension_unit_t;
+
+enum uvc_status_class {
+  UVC_STATUS_CLASS_CONTROL = 0x10,
+  UVC_STATUS_CLASS_CONTROL_CAMERA = 0x11,
+  UVC_STATUS_CLASS_CONTROL_PROCESSING = 0x12,
+};
+
+enum uvc_status_attribute {
+  UVC_STATUS_ATTRIBUTE_VALUE_CHANGE = 0x00,
+  UVC_STATUS_ATTRIBUTE_INFO_CHANGE = 0x01,
+  UVC_STATUS_ATTRIBUTE_FAILURE_CHANGE = 0x02,
+  UVC_STATUS_ATTRIBUTE_UNKNOWN = 0xff
+};
+
+/** A callback function to accept status updates
+ * @ingroup device
+ */
+typedef void(uvc_status_callback_t)(enum uvc_status_class status_class,
+                                    int event,
+                                    int selector,
+                                    enum uvc_status_attribute status_attribute,
+                                    void *data, size_t data_len,
+                                    void *user_ptr);
+
+/** A callback function to accept button events
+ * @ingroup device
+ */
+typedef void(uvc_button_callback_t)(int button,
+                                    int state,
+                                    void *user_ptr);
+
+/** Structure representing a UVC device descriptor.
+ *
+ * (This isn't a standard structure.)
+ */
+typedef struct uvc_device_descriptor {
+  /** Vendor ID */
+  uint16_t idVendor;
+  /** Product ID */
+  uint16_t idProduct;
+  /** UVC compliance level, e.g. 0x0100 (1.0), 0x0110 */
+  uint16_t bcdUVC;
+  /** Serial number (null if unavailable) */
+  const char *serialNumber;
+  /** Device-reported manufacturer name (or null) */
+  const char *manufacturer;
+  /** Device-reporter product name (or null) */
+  const char *product;
+} uvc_device_descriptor_t;
+
+/** An image frame received from the UVC device
+ * @ingroup streaming
+ */
+typedef struct uvc_frame {
+  /** Image data for this frame */
+  void *data;
+  /** Size of image data buffer */
+  size_t data_bytes;
+  /** Width of image in pixels */
+  uint32_t width;
+  /** Height of image in pixels */
+  uint32_t height;
+  /** Pixel data format */
+  enum uvc_frame_format frame_format;
+  /** Number of bytes per horizontal line (undefined for compressed format) */
+  size_t step;
+  /** Frame number (may skip, but is strictly monotonically increasing) */
+  uint32_t sequence;
+  /** Estimate of system time when the device started capturing the image */
+  struct timeval capture_time;
+  /** Estimate of system time when the device finished receiving the image */
+  struct timespec capture_time_finished;
+  /** Handle on the device that produced the image.
+   * @warning You must not call any uvc_* functions during a callback. */
+  uvc_device_handle_t *source;
+  /** Is the data buffer owned by the library?
+   * If 1, the data buffer can be arbitrarily reallocated by frame conversion
+   * functions.
+   * If 0, the data buffer will not be reallocated or freed by the library.
+   * Set this field to zero if you are supplying the buffer.
+   */
+  uint8_t library_owns_data;
+  /** Metadata for this frame if available */
+  void *metadata;
+  /** Size of metadata buffer */
+  size_t metadata_bytes;
+} uvc_frame_t;
+
+/** A callback function to handle incoming assembled UVC frames
+ * @ingroup streaming
+ */
+typedef void(uvc_frame_callback_t)(struct uvc_frame *frame, void *user_ptr);
+
+/** Streaming mode, includes all information needed to select stream
+ * @ingroup streaming
+ */
+typedef struct uvc_stream_ctrl {
+  uint16_t bmHint;
+  uint8_t bFormatIndex;
+  uint8_t bFrameIndex;
+  uint32_t dwFrameInterval;
+  uint16_t wKeyFrameRate;
+  uint16_t wPFrameRate;
+  uint16_t wCompQuality;
+  uint16_t wCompWindowSize;
+  uint16_t wDelay;
+  uint32_t dwMaxVideoFrameSize;
+  uint32_t dwMaxPayloadTransferSize;
+  uint32_t dwClockFrequency;
+  uint8_t bmFramingInfo;
+  uint8_t bPreferredVersion;
+  uint8_t bMinVersion;
+  uint8_t bMaxVersion;
+  uint8_t bInterfaceNumber;
+} uvc_stream_ctrl_t;
+
+typedef struct uvc_still_ctrl {
+  /* Video format index from a format descriptor */
+  uint8_t bFormatIndex;
+  /* Video frame index from a frame descriptor */
+  uint8_t bFrameIndex;
+  /* Compression index from a frame descriptor */
+  uint8_t bCompressionIndex;
+  /* Maximum still image size in bytes. */
+  uint32_t dwMaxVideoFrameSize;
+  /* Maximum number of byte per payload*/
+  uint32_t dwMaxPayloadTransferSize;
+  uint8_t bInterfaceNumber;
+} uvc_still_ctrl_t;
+
+uvc_error_t uvc_init(uvc_context_t **ctx, struct libusb_context *usb_ctx);
+void uvc_exit(uvc_context_t *ctx);
+
+uvc_error_t uvc_get_device_list(
+    uvc_context_t *ctx,
+    uvc_device_t ***list);
+void uvc_free_device_list(uvc_device_t **list, uint8_t unref_devices);
+
+uvc_error_t uvc_get_device_descriptor(
+    uvc_device_t *dev,
+    uvc_device_descriptor_t **desc);
+void uvc_free_device_descriptor(
+    uvc_device_descriptor_t *desc);
+
+uint8_t uvc_get_bus_number(uvc_device_t *dev);
+uint8_t uvc_get_device_address(uvc_device_t *dev);
+
+uvc_error_t uvc_find_device(
+    uvc_context_t *ctx,
+    uvc_device_t **dev,
+    int vid, int pid, const char *sn);
+
+uvc_error_t uvc_find_devices(
+    uvc_context_t *ctx,
+    uvc_device_t ***devs,
+    int vid, int pid, const char *sn);
+
+uvc_error_t uvc_open(
+    uvc_device_t *dev,
+    uvc_device_handle_t **devh);
+void uvc_close(uvc_device_handle_t *devh);
+
+uvc_device_t *uvc_get_device(uvc_device_handle_t *devh);
+struct libusb_device_handle *uvc_get_libusb_handle(uvc_device_handle_t *devh);
+
+void uvc_ref_device(uvc_device_t *dev);
+void uvc_unref_device(uvc_device_t *dev);
+
+void uvc_set_status_callback(uvc_device_handle_t *devh,
+                             uvc_status_callback_t cb,
+                             void *user_ptr);
+
+void uvc_set_button_callback(uvc_device_handle_t *devh,
+                             uvc_button_callback_t cb,
+                             void *user_ptr);
+
+const uvc_input_terminal_t *uvc_get_camera_terminal(uvc_device_handle_t *devh);
+const uvc_input_terminal_t *uvc_get_input_terminals(uvc_device_handle_t *devh);
+const uvc_output_terminal_t *uvc_get_output_terminals(uvc_device_handle_t *devh);
+const uvc_selector_unit_t *uvc_get_selector_units(uvc_device_handle_t *devh);
+const uvc_processing_unit_t *uvc_get_processing_units(uvc_device_handle_t *devh);
+const uvc_extension_unit_t *uvc_get_extension_units(uvc_device_handle_t *devh);
+
+uvc_error_t uvc_get_stream_ctrl_format_size(
+    uvc_device_handle_t *devh,
+    uvc_stream_ctrl_t *ctrl,
+    enum uvc_frame_format format,
+    int width, int height,
+    int fps
+    );
+
+uvc_error_t uvc_get_still_ctrl_format_size(
+    uvc_device_handle_t *devh,
+    uvc_stream_ctrl_t *ctrl,
+    uvc_still_ctrl_t *still_ctrl,
+    int width, int height);
+
+uvc_error_t uvc_trigger_still(
+    uvc_device_handle_t *devh,
+    uvc_still_ctrl_t *still_ctrl);
+
+const uvc_format_desc_t *uvc_get_format_descs(uvc_device_handle_t* );
+
+uvc_error_t uvc_probe_stream_ctrl(
+    uvc_device_handle_t *devh,
+    uvc_stream_ctrl_t *ctrl);
+
+uvc_error_t uvc_probe_still_ctrl(
+    uvc_device_handle_t *devh,
+    uvc_still_ctrl_t *still_ctrl);
+
+uvc_error_t uvc_start_streaming(
+    uvc_device_handle_t *devh,
+    uvc_stream_ctrl_t *ctrl,
+    uvc_frame_callback_t *cb,
+    void *user_ptr,
+    uint8_t flags);
+
+uvc_error_t uvc_start_iso_streaming(
+    uvc_device_handle_t *devh,
+    uvc_stream_ctrl_t *ctrl,
+    uvc_frame_callback_t *cb,
+    void *user_ptr);
+
+void uvc_stop_streaming(uvc_device_handle_t *devh);
+
+uvc_error_t uvc_stream_open_ctrl(uvc_device_handle_t *devh, uvc_stream_handle_t **strmh, uvc_stream_ctrl_t *ctrl);
+uvc_error_t uvc_stream_ctrl(uvc_stream_handle_t *strmh, uvc_stream_ctrl_t *ctrl);
+uvc_error_t uvc_stream_start(uvc_stream_handle_t *strmh,
+    uvc_frame_callback_t *cb,
+    void *user_ptr,
+    uint8_t flags);
+uvc_error_t uvc_stream_start_iso(uvc_stream_handle_t *strmh,
+    uvc_frame_callback_t *cb,
+    void *user_ptr);
+uvc_error_t uvc_stream_get_frame(
+    uvc_stream_handle_t *strmh,
+    uvc_frame_t **frame,
+    int32_t timeout_us
+);
+uvc_error_t uvc_stream_stop(uvc_stream_handle_t *strmh);
+void uvc_stream_close(uvc_stream_handle_t *strmh);
+
+int uvc_get_ctrl_len(uvc_device_handle_t *devh, uint8_t unit, uint8_t ctrl);
+int uvc_get_ctrl(uvc_device_handle_t *devh, uint8_t unit, uint8_t ctrl, void *data, int len, enum uvc_req_code req_code);
+int uvc_set_ctrl(uvc_device_handle_t *devh, uint8_t unit, uint8_t ctrl, void *data, int len);
+
+uvc_error_t uvc_get_power_mode(uvc_device_handle_t *devh, enum uvc_device_power_mode *mode, enum uvc_req_code req_code);
+uvc_error_t uvc_set_power_mode(uvc_device_handle_t *devh, enum uvc_device_power_mode mode);
+
+/* AUTO-GENERATED control accessors! Update them with the output of `ctrl-gen.py decl`. */
+uvc_error_t uvc_get_scanning_mode(uvc_device_handle_t *devh, uint8_t* mode, enum uvc_req_code req_code);
+uvc_error_t uvc_set_scanning_mode(uvc_device_handle_t *devh, uint8_t mode);
+
+uvc_error_t uvc_get_ae_mode(uvc_device_handle_t *devh, uint8_t* mode, enum uvc_req_code req_code);
+uvc_error_t uvc_set_ae_mode(uvc_device_handle_t *devh, uint8_t mode);
+
+uvc_error_t uvc_get_ae_priority(uvc_device_handle_t *devh, uint8_t* priority, enum uvc_req_code req_code);
+uvc_error_t uvc_set_ae_priority(uvc_device_handle_t *devh, uint8_t priority);
+
+uvc_error_t uvc_get_exposure_abs(uvc_device_handle_t *devh, uint32_t* time, enum uvc_req_code req_code);
+uvc_error_t uvc_set_exposure_abs(uvc_device_handle_t *devh, uint32_t time);
+
+uvc_error_t uvc_get_exposure_rel(uvc_device_handle_t *devh, int8_t* step, enum uvc_req_code req_code);
+uvc_error_t uvc_set_exposure_rel(uvc_device_handle_t *devh, int8_t step);
+
+uvc_error_t uvc_get_focus_abs(uvc_device_handle_t *devh, uint16_t* focus, enum uvc_req_code req_code);
+uvc_error_t uvc_set_focus_abs(uvc_device_handle_t *devh, uint16_t focus);
+
+uvc_error_t uvc_get_focus_rel(uvc_device_handle_t *devh, int8_t* focus_rel, uint8_t* speed, enum uvc_req_code req_code);
+uvc_error_t uvc_set_focus_rel(uvc_device_handle_t *devh, int8_t focus_rel, uint8_t speed);
+
+uvc_error_t uvc_get_focus_simple_range(uvc_device_handle_t *devh, uint8_t* focus, enum uvc_req_code req_code);
+uvc_error_t uvc_set_focus_simple_range(uvc_device_handle_t *devh, uint8_t focus);
+
+uvc_error_t uvc_get_focus_auto(uvc_device_handle_t *devh, uint8_t* state, enum uvc_req_code req_code);
+uvc_error_t uvc_set_focus_auto(uvc_device_handle_t *devh, uint8_t state);
+
+uvc_error_t uvc_get_iris_abs(uvc_device_handle_t *devh, uint16_t* iris, enum uvc_req_code req_code);
+uvc_error_t uvc_set_iris_abs(uvc_device_handle_t *devh, uint16_t iris);
+
+uvc_error_t uvc_get_iris_rel(uvc_device_handle_t *devh, uint8_t* iris_rel, enum uvc_req_code req_code);
+uvc_error_t uvc_set_iris_rel(uvc_device_handle_t *devh, uint8_t iris_rel);
+
+uvc_error_t uvc_get_zoom_abs(uvc_device_handle_t *devh, uint16_t* focal_length, enum uvc_req_code req_code);
+uvc_error_t uvc_set_zoom_abs(uvc_device_handle_t *devh, uint16_t focal_length);
+
+uvc_error_t uvc_get_zoom_rel(uvc_device_handle_t *devh, int8_t* zoom_rel, uint8_t* digital_zoom, uint8_t* speed, enum uvc_req_code req_code);
+uvc_error_t uvc_set_zoom_rel(uvc_device_handle_t *devh, int8_t zoom_rel, uint8_t digital_zoom, uint8_t speed);
+
+uvc_error_t uvc_get_pantilt_abs(uvc_device_handle_t *devh, int32_t* pan, int32_t* tilt, enum uvc_req_code req_code);
+uvc_error_t uvc_set_pantilt_abs(uvc_device_handle_t *devh, int32_t pan, int32_t tilt);
+
+uvc_error_t uvc_get_pantilt_rel(uvc_device_handle_t *devh, int8_t* pan_rel, uint8_t* pan_speed, int8_t* tilt_rel, uint8_t* tilt_speed, enum uvc_req_code req_code);
+uvc_error_t uvc_set_pantilt_rel(uvc_device_handle_t *devh, int8_t pan_rel, uint8_t pan_speed, int8_t tilt_rel, uint8_t tilt_speed);
+
+uvc_error_t uvc_get_roll_abs(uvc_device_handle_t *devh, int16_t* roll, enum uvc_req_code req_code);
+uvc_error_t uvc_set_roll_abs(uvc_device_handle_t *devh, int16_t roll);
+
+uvc_error_t uvc_get_roll_rel(uvc_device_handle_t *devh, int8_t* roll_rel, uint8_t* speed, enum uvc_req_code req_code);
+uvc_error_t uvc_set_roll_rel(uvc_device_handle_t *devh, int8_t roll_rel, uint8_t speed);
+
+uvc_error_t uvc_get_privacy(uvc_device_handle_t *devh, uint8_t* privacy, enum uvc_req_code req_code);
+uvc_error_t uvc_set_privacy(uvc_device_handle_t *devh, uint8_t privacy);
+
+uvc_error_t uvc_get_digital_window(uvc_device_handle_t *devh, uint16_t* window_top, uint16_t* window_left, uint16_t* window_bottom, uint16_t* window_right, uint16_t* num_steps, uint16_t* num_steps_units, enum uvc_req_code req_code);
+uvc_error_t uvc_set_digital_window(uvc_device_handle_t *devh, uint16_t window_top, uint16_t window_left, uint16_t window_bottom, uint16_t window_right, uint16_t num_steps, uint16_t num_steps_units);
+
+uvc_error_t uvc_get_digital_roi(uvc_device_handle_t *devh, uint16_t* roi_top, uint16_t* roi_left, uint16_t* roi_bottom, uint16_t* roi_right, uint16_t* auto_controls, enum uvc_req_code req_code);
+uvc_error_t uvc_set_digital_roi(uvc_device_handle_t *devh, uint16_t roi_top, uint16_t roi_left, uint16_t roi_bottom, uint16_t roi_right, uint16_t auto_controls);
+
+uvc_error_t uvc_get_backlight_compensation(uvc_device_handle_t *devh, uint16_t* backlight_compensation, enum uvc_req_code req_code);
+uvc_error_t uvc_set_backlight_compensation(uvc_device_handle_t *devh, uint16_t backlight_compensation);
+
+uvc_error_t uvc_get_brightness(uvc_device_handle_t *devh, int16_t* brightness, enum uvc_req_code req_code);
+uvc_error_t uvc_set_brightness(uvc_device_handle_t *devh, int16_t brightness);
+
+uvc_error_t uvc_get_contrast(uvc_device_handle_t *devh, uint16_t* contrast, enum uvc_req_code req_code);
+uvc_error_t uvc_set_contrast(uvc_device_handle_t *devh, uint16_t contrast);
+
+uvc_error_t uvc_get_contrast_auto(uvc_device_handle_t *devh, uint8_t* contrast_auto, enum uvc_req_code req_code);
+uvc_error_t uvc_set_contrast_auto(uvc_device_handle_t *devh, uint8_t contrast_auto);
+
+uvc_error_t uvc_get_gain(uvc_device_handle_t *devh, uint16_t* gain, enum uvc_req_code req_code);
+uvc_error_t uvc_set_gain(uvc_device_handle_t *devh, uint16_t gain);
+
+uvc_error_t uvc_get_power_line_frequency(uvc_device_handle_t *devh, uint8_t* power_line_frequency, enum uvc_req_code req_code);
+uvc_error_t uvc_set_power_line_frequency(uvc_device_handle_t *devh, uint8_t power_line_frequency);
+
+uvc_error_t uvc_get_hue(uvc_device_handle_t *devh, int16_t* hue, enum uvc_req_code req_code);
+uvc_error_t uvc_set_hue(uvc_device_handle_t *devh, int16_t hue);
+
+uvc_error_t uvc_get_hue_auto(uvc_device_handle_t *devh, uint8_t* hue_auto, enum uvc_req_code req_code);
+uvc_error_t uvc_set_hue_auto(uvc_device_handle_t *devh, uint8_t hue_auto);
+
+uvc_error_t uvc_get_saturation(uvc_device_handle_t *devh, uint16_t* saturation, enum uvc_req_code req_code);
+uvc_error_t uvc_set_saturation(uvc_device_handle_t *devh, uint16_t saturation);
+
+uvc_error_t uvc_get_sharpness(uvc_device_handle_t *devh, uint16_t* sharpness, enum uvc_req_code req_code);
+uvc_error_t uvc_set_sharpness(uvc_device_handle_t *devh, uint16_t sharpness);
+
+uvc_error_t uvc_get_gamma(uvc_device_handle_t *devh, uint16_t* gamma, enum uvc_req_code req_code);
+uvc_error_t uvc_set_gamma(uvc_device_handle_t *devh, uint16_t gamma);
+
+uvc_error_t uvc_get_white_balance_temperature(uvc_device_handle_t *devh, uint16_t* temperature, enum uvc_req_code req_code);
+uvc_error_t uvc_set_white_balance_temperature(uvc_device_handle_t *devh, uint16_t temperature);
+
+uvc_error_t uvc_get_white_balance_temperature_auto(uvc_device_handle_t *devh, uint8_t* temperature_auto, enum uvc_req_code req_code);
+uvc_error_t uvc_set_white_balance_temperature_auto(uvc_device_handle_t *devh, uint8_t temperature_auto);
+
+uvc_error_t uvc_get_white_balance_component(uvc_device_handle_t *devh, uint16_t* blue, uint16_t* red, enum uvc_req_code req_code);
+uvc_error_t uvc_set_white_balance_component(uvc_device_handle_t *devh, uint16_t blue, uint16_t red);
+
+uvc_error_t uvc_get_white_balance_component_auto(uvc_device_handle_t *devh, uint8_t* white_balance_component_auto, enum uvc_req_code req_code);
+uvc_error_t uvc_set_white_balance_component_auto(uvc_device_handle_t *devh, uint8_t white_balance_component_auto);
+
+uvc_error_t uvc_get_digital_multiplier(uvc_device_handle_t *devh, uint16_t* multiplier_step, enum uvc_req_code req_code);
+uvc_error_t uvc_set_digital_multiplier(uvc_device_handle_t *devh, uint16_t multiplier_step);
+
+uvc_error_t uvc_get_digital_multiplier_limit(uvc_device_handle_t *devh, uint16_t* multiplier_step, enum uvc_req_code req_code);
+uvc_error_t uvc_set_digital_multiplier_limit(uvc_device_handle_t *devh, uint16_t multiplier_step);
+
+uvc_error_t uvc_get_analog_video_standard(uvc_device_handle_t *devh, uint8_t* video_standard, enum uvc_req_code req_code);
+uvc_error_t uvc_set_analog_video_standard(uvc_device_handle_t *devh, uint8_t video_standard);
+
+uvc_error_t uvc_get_analog_video_lock_status(uvc_device_handle_t *devh, uint8_t* status, enum uvc_req_code req_code);
+uvc_error_t uvc_set_analog_video_lock_status(uvc_device_handle_t *devh, uint8_t status);
+
+uvc_error_t uvc_get_input_select(uvc_device_handle_t *devh, uint8_t* selector, enum uvc_req_code req_code);
+uvc_error_t uvc_set_input_select(uvc_device_handle_t *devh, uint8_t selector);
+/* end AUTO-GENERATED control accessors */
+
+void uvc_perror(uvc_error_t err, const char *msg);
+const char* uvc_strerror(uvc_error_t err);
+void uvc_print_diag(uvc_device_handle_t *devh, FILE *stream);
+void uvc_print_stream_ctrl(uvc_stream_ctrl_t *ctrl, FILE *stream);
+
+uvc_frame_t *uvc_allocate_frame(size_t data_bytes);
+void uvc_free_frame(uvc_frame_t *frame);
+
+uvc_error_t uvc_duplicate_frame(uvc_frame_t *in, uvc_frame_t *out);
+
+uvc_error_t uvc_yuyv2rgb(uvc_frame_t *in, uvc_frame_t *out);
+uvc_error_t uvc_uyvy2rgb(uvc_frame_t *in, uvc_frame_t *out);
+uvc_error_t uvc_any2rgb(uvc_frame_t *in, uvc_frame_t *out);
+
+uvc_error_t uvc_yuyv2bgr(uvc_frame_t *in, uvc_frame_t *out);
+uvc_error_t uvc_uyvy2bgr(uvc_frame_t *in, uvc_frame_t *out);
+uvc_error_t uvc_any2bgr(uvc_frame_t *in, uvc_frame_t *out);
+
+uvc_error_t uvc_yuyv2y(uvc_frame_t *in, uvc_frame_t *out);
+uvc_error_t uvc_yuyv2uv(uvc_frame_t *in, uvc_frame_t *out);
+
+#ifdef LIBUVC_HAS_JPEG
+uvc_error_t uvc_mjpeg2rgb(uvc_frame_t *in, uvc_frame_t *out);
+uvc_error_t uvc_mjpeg2gray(uvc_frame_t *in, uvc_frame_t *out);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // !def(LIBUVC_H)
+
diff --git a/3rdparty/libuvc/src/include/libuvc/libuvc_config.h b/3rdparty/libuvc/src/include/libuvc/libuvc_config.h
new file mode 100644
index 00000000..78aa322d
--- /dev/null
+++ b/3rdparty/libuvc/src/include/libuvc/libuvc_config.h
@@ -0,0 +1,22 @@
+#ifndef LIBUVC_CONFIG_H
+#define LIBUVC_CONFIG_H
+
+#define LIBUVC_VERSION_MAJOR 0
+#define LIBUVC_VERSION_MINOR 0
+#define LIBUVC_VERSION_PATCH 6
+#define LIBUVC_VERSION_STR "0.0.6"
+#define LIBUVC_VERSION_INT                      \
+  ((0 << 16) |             \
+   (0 << 8) |              \
+   (6))
+
+/** @brief Test whether libuvc is new enough
+ * This macro evaluates true if and only if the current version is
+ * at least as new as the version specified.
+ */
+#define LIBUVC_VERSION_GTE(major, minor, patch)                         \
+  (LIBUVC_VERSION_INT >= (((major) << 16) | ((minor) << 8) | (patch)))
+
+/* #undef LIBUVC_HAS_JPEG */
+
+#endif // !def(LIBUVC_CONFIG_H)
diff --git a/3rdparty/libuvc/src/include/libuvc/libuvc_config.h.in b/3rdparty/libuvc/src/include/libuvc/libuvc_config.h.in
new file mode 100644
index 00000000..e5d3d8c3
--- /dev/null
+++ b/3rdparty/libuvc/src/include/libuvc/libuvc_config.h.in
@@ -0,0 +1,22 @@
+#ifndef LIBUVC_CONFIG_H
+#define LIBUVC_CONFIG_H
+
+#define LIBUVC_VERSION_MAJOR @libuvc_VERSION_MAJOR@
+#define LIBUVC_VERSION_MINOR @libuvc_VERSION_MINOR@
+#define LIBUVC_VERSION_PATCH @libuvc_VERSION_PATCH@
+#define LIBUVC_VERSION_STR "@libuvc_VERSION@"
+#define LIBUVC_VERSION_INT                      \
+  ((@libuvc_VERSION_MAJOR@ << 16) |             \
+   (@libuvc_VERSION_MINOR@ << 8) |              \
+   (@libuvc_VERSION_PATCH@))
+
+/** @brief Test whether libuvc is new enough
+ * This macro evaluates true if and only if the current version is
+ * at least as new as the version specified.
+ */
+#define LIBUVC_VERSION_GTE(major, minor, patch)                         \
+  (LIBUVC_VERSION_INT >= (((major) << 16) | ((minor) << 8) | (patch)))
+
+#cmakedefine LIBUVC_HAS_JPEG 1
+
+#endif // !def(LIBUVC_CONFIG_H)
diff --git a/3rdparty/libuvc/src/include/libuvc/libuvc_internal.h b/3rdparty/libuvc/src/include/libuvc/libuvc_internal.h
new file mode 100644
index 00000000..e677f0e3
--- /dev/null
+++ b/3rdparty/libuvc/src/include/libuvc/libuvc_internal.h
@@ -0,0 +1,283 @@
+/** @file libuvc_internal.h
+ * @brief Implementation-specific UVC constants and structures.
+ * @cond include_hidden
+ */
+#ifndef LIBUVC_INTERNAL_H
+#define LIBUVC_INTERNAL_H
+
+#include <assert.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <pthread.h>
+#include <signal.h>
+#include <libusb.h>
+#include "utlist.h"
+
+/** Converts an unaligned four-byte little-endian integer into an int32 */
+#define DW_TO_INT(p) ((p)[0] | ((p)[1] << 8) | ((p)[2] << 16) | ((p)[3] << 24))
+/** Converts an unaligned two-byte little-endian integer into an int16 */
+#define SW_TO_SHORT(p) ((p)[0] | ((p)[1] << 8))
+/** Converts an int16 into an unaligned two-byte little-endian integer */
+#define SHORT_TO_SW(s, p) \
+    (p)[0] = (s);         \
+    (p)[1] = (s) >> 8;
+/** Converts an int32 into an unaligned four-byte little-endian integer */
+#define INT_TO_DW(i, p) \
+    (p)[0] = (i);       \
+    (p)[1] = (i) >> 8;  \
+    (p)[2] = (i) >> 16; \
+    (p)[3] = (i) >> 24;
+
+/** Selects the nth item in a doubly linked list. n=-1 selects the last item. */
+#define DL_NTH(head, out, n)                    \
+    do {                                        \
+        int dl_nth_i             = 0;           \
+        LDECLTYPE(head) dl_nth_p = (head);      \
+        if((n) < 0) {                           \
+            while(dl_nth_p && dl_nth_i > (n)) { \
+                dl_nth_p = dl_nth_p->prev;      \
+                dl_nth_i--;                     \
+            }                                   \
+        }                                       \
+        else {                                  \
+            while(dl_nth_p && dl_nth_i < (n)) { \
+                dl_nth_p = dl_nth_p->next;      \
+                dl_nth_i++;                     \
+            }                                   \
+        }                                       \
+        (out) = dl_nth_p;                       \
+    } while(0);
+
+#ifdef UVC_DEBUGGING
+#include <libgen.h>
+#define UVC_DEBUG(format, ...) fprintf(stderr, "[%s:%d/%s] " format "\n", basename(__FILE__), __LINE__, __FUNCTION__, ##__VA_ARGS__)
+#define UVC_ENTER() fprintf(stderr, "[%s:%d] begin %s\n", basename(__FILE__), __LINE__, __FUNCTION__)
+#define UVC_EXIT(code) fprintf(stderr, "[%s:%d] end %s (%d)\n", basename(__FILE__), __LINE__, __FUNCTION__, code)
+#define UVC_EXIT_VOID() fprintf(stderr, "[%s:%d] end %s\n", basename(__FILE__), __LINE__, __FUNCTION__)
+#else
+#define UVC_DEBUG(format, ...)
+#define UVC_ENTER()
+#define UVC_EXIT_VOID()
+#define UVC_EXIT(code)
+#endif
+
+/* http://stackoverflow.com/questions/19452971/array-size-macro-that-rejects-pointers */
+#define IS_INDEXABLE(arg) (sizeof(arg[0]))
+#define IS_ARRAY(arg) (IS_INDEXABLE(arg) && (((void *)&arg) == ((void *)arg)))
+#define ARRAYSIZE(arr) (sizeof(arr) / (IS_ARRAY(arr) ? sizeof(arr[0]) : 0))
+
+/** Video interface subclass code (A.2) */
+enum uvc_int_subclass_code { UVC_SC_UNDEFINED = 0x00, UVC_SC_VIDEOCONTROL = 0x01, UVC_SC_VIDEOSTREAMING = 0x02, UVC_SC_VIDEO_INTERFACE_COLLECTION = 0x03 };
+
+/** Video interface protocol code (A.3) */
+enum uvc_int_proto_code { UVC_PC_PROTOCOL_UNDEFINED = 0x00 };
+
+/** VideoControl interface descriptor subtype (A.5) */
+enum uvc_vc_desc_subtype {
+    UVC_VC_DESCRIPTOR_UNDEFINED = 0x00,
+    UVC_VC_HEADER               = 0x01,
+    UVC_VC_INPUT_TERMINAL       = 0x02,
+    UVC_VC_OUTPUT_TERMINAL      = 0x03,
+    UVC_VC_SELECTOR_UNIT        = 0x04,
+    UVC_VC_PROCESSING_UNIT      = 0x05,
+    UVC_VC_EXTENSION_UNIT       = 0x06
+};
+
+/** UVC endpoint descriptor subtype (A.7) */
+enum uvc_ep_desc_subtype { UVC_EP_UNDEFINED = 0x00, UVC_EP_GENERAL = 0x01, UVC_EP_ENDPOINT = 0x02, UVC_EP_INTERRUPT = 0x03 };
+
+/** VideoControl interface control selector (A.9.1) */
+enum uvc_vc_ctrl_selector { UVC_VC_CONTROL_UNDEFINED = 0x00, UVC_VC_VIDEO_POWER_MODE_CONTROL = 0x01, UVC_VC_REQUEST_ERROR_CODE_CONTROL = 0x02 };
+
+/** Terminal control selector (A.9.2) */
+enum uvc_term_ctrl_selector { UVC_TE_CONTROL_UNDEFINED = 0x00 };
+
+/** Selector unit control selector (A.9.3) */
+enum uvc_su_ctrl_selector { UVC_SU_CONTROL_UNDEFINED = 0x00, UVC_SU_INPUT_SELECT_CONTROL = 0x01 };
+
+/** Extension unit control selector (A.9.6) */
+enum uvc_xu_ctrl_selector { UVC_XU_CONTROL_UNDEFINED = 0x00 };
+
+/** VideoStreaming interface control selector (A.9.7) */
+enum uvc_vs_ctrl_selector {
+    UVC_VS_CONTROL_UNDEFINED            = 0x00,
+    UVC_VS_PROBE_CONTROL                = 0x01,
+    UVC_VS_COMMIT_CONTROL               = 0x02,
+    UVC_VS_STILL_PROBE_CONTROL          = 0x03,
+    UVC_VS_STILL_COMMIT_CONTROL         = 0x04,
+    UVC_VS_STILL_IMAGE_TRIGGER_CONTROL  = 0x05,
+    UVC_VS_STREAM_ERROR_CODE_CONTROL    = 0x06,
+    UVC_VS_GENERATE_KEY_FRAME_CONTROL   = 0x07,
+    UVC_VS_UPDATE_FRAME_SEGMENT_CONTROL = 0x08,
+    UVC_VS_SYNC_DELAY_CONTROL           = 0x09
+};
+
+/** Status packet type (2.4.2.2) */
+enum uvc_status_type { UVC_STATUS_TYPE_CONTROL = 1, UVC_STATUS_TYPE_STREAMING = 2 };
+
+/** Payload header flags (2.4.3.3) */
+#define UVC_STREAM_EOH (1 << 7)
+#define UVC_STREAM_ERR (1 << 6)
+#define UVC_STREAM_STI (1 << 5)
+#define UVC_STREAM_RES (1 << 4)
+#define UVC_STREAM_SCR (1 << 3)
+#define UVC_STREAM_PTS (1 << 2)
+#define UVC_STREAM_EOF (1 << 1)
+#define UVC_STREAM_FID (1 << 0)
+
+/** Control capabilities (4.1.2) */
+#define UVC_CONTROL_CAP_GET (1 << 0)
+#define UVC_CONTROL_CAP_SET (1 << 1)
+#define UVC_CONTROL_CAP_DISABLED (1 << 2)
+#define UVC_CONTROL_CAP_AUTOUPDATE (1 << 3)
+#define UVC_CONTROL_CAP_ASYNCHRONOUS (1 << 4)
+
+struct uvc_streaming_interface;
+struct uvc_device_info;
+
+/** VideoStream interface */
+typedef struct uvc_streaming_interface {
+    struct uvc_device_info         *parent;
+    struct uvc_streaming_interface *prev, *next;
+    /** Interface number */
+    uint8_t bInterfaceNumber;
+    /** Video formats that this interface provides */
+    struct uvc_format_desc *format_descs;
+    /** USB endpoint to use when communicating with this interface */
+    uint8_t bEndpointAddress;
+    uint8_t bTerminalLink;
+    uint8_t bStillCaptureMethod;
+} uvc_streaming_interface_t;
+
+/** VideoControl interface */
+typedef struct uvc_control_interface {
+    struct uvc_device_info    *parent;
+    struct uvc_input_terminal *input_term_descs;
+    // struct uvc_output_terminal *output_term_descs;
+    struct uvc_selector_unit   *selector_unit_descs;
+    struct uvc_processing_unit *processing_unit_descs;
+    struct uvc_extension_unit  *extension_unit_descs;
+    uint16_t                    bcdUVC;
+    uint32_t                    dwClockFrequency;
+    uint8_t                     bEndpointAddress;
+    /** Interface number */
+    uint8_t bInterfaceNumber;
+} uvc_control_interface_t;
+
+struct uvc_stream_ctrl;
+
+struct uvc_device {
+    struct uvc_context *ctx;
+    int                 ref;
+    libusb_device      *usb_dev;
+};
+
+typedef struct uvc_device_info {
+    /** Configuration descriptor for USB device */
+    struct libusb_config_descriptor *config;
+    /** VideoControl interface provided by device */
+    uvc_control_interface_t ctrl_if;
+    /** VideoStreaming interfaces on the device */
+    uvc_streaming_interface_t *stream_ifs;
+} uvc_device_info_t;
+
+/*
+  set a high number of transfer buffers. This uses a lot of ram, but
+  avoids problems with scheduling delays on slow boards causing missed
+  transfers. A better approach may be to make the transfer thread FIFO
+  scheduled (if we have root).
+  We could/should change this to allow reduce it to, say, 5 by default
+  and then allow the user to change the number of buffers as required.
+ */
+#define LIBUVC_NUM_TRANSFER_BUFS 100
+
+#define LIBUVC_XFER_BUF_SIZE (16 * 1024 * 1024)
+#define LIBUVC_XFER_META_BUF_SIZE (4 * 1024)
+#define LIBUVC_XFER_PAYLOAD_HEADER_BUF_SIZE (256)
+
+struct uvc_stream_handle {
+    struct uvc_device_handle       *devh;
+    struct uvc_stream_handle       *prev, *next;
+    struct uvc_streaming_interface *stream_if;
+
+    /** if true, stream is running (streaming video to host) */
+    uint8_t running;
+    /** Current control block */
+    struct uvc_stream_ctrl cur_ctrl;
+
+    /* listeners may only access hold*, and only when holding a
+     * lock on cb_mutex (probably signaled with cb_cond) */
+    uint8_t                 fid;
+    uint32_t                seq, hold_seq;
+    uint32_t                pts, hold_pts;
+    uint32_t                last_scr, hold_last_scr;
+    size_t                  got_bytes, hold_bytes;
+    uint8_t                *outbuf, *holdbuf;
+    pthread_mutex_t         cb_mutex;
+    pthread_cond_t          cb_cond;
+    pthread_t               cb_thread;
+    uint32_t                last_polled_seq;
+    uvc_frame_callback_t   *user_cb;
+    void                   *user_ptr;
+    uint32_t                actual_transfer_buff_num;
+    struct libusb_transfer *transfers[LIBUVC_NUM_TRANSFER_BUFS];
+    uint8_t                *transfer_bufs[LIBUVC_NUM_TRANSFER_BUFS];
+    struct uvc_frame        frame;
+    enum uvc_frame_format   frame_format;
+    struct timespec         capture_time_finished;
+
+    /* raw metadata buffer if available */
+    uint8_t *meta_outbuf, *meta_holdbuf;
+    size_t   meta_got_bytes, meta_hold_bytes;
+
+    /* payload header */
+    uint8_t *payload_header_outbuf, *payload_header_holdbuf;
+    size_t   payload_header_got_bytes, payload_header_hold_bytes;
+};
+
+/** Handle on an open UVC device
+ *
+ * @todo move most of this into a uvc_device struct?
+ */
+struct uvc_device_handle {
+    struct uvc_device        *dev;
+    struct uvc_device_handle *prev, *next;
+    /** Underlying USB device handle */
+    libusb_device_handle   *usb_devh;
+    struct uvc_device_info *info;
+    struct libusb_transfer *status_xfer;
+    uint8_t                 status_buf[32];
+    /** Function to call when we receive status updates from the camera */
+    uvc_status_callback_t *status_cb;
+    void                  *status_user_ptr;
+    /** Function to call when we receive button events from the camera */
+    uvc_button_callback_t *button_cb;
+    void                  *button_user_ptr;
+
+    uvc_stream_handle_t *streams;
+    /** Whether the camera is an iSight that sends one header per frame */
+    uint8_t  is_isight;
+    uint32_t claimed;
+};
+
+/** Context within which we communicate with devices */
+struct uvc_context {
+    /** Underlying context for USB communication */
+    struct libusb_context *usb_ctx;
+    /** True iff libuvc initialized the underlying USB context */
+    uint8_t own_usb_ctx;
+    /** List of open devices in this context */
+    uvc_device_handle_t *open_devices;
+    pthread_t            handler_thread;
+    int                  kill_handler_thread;
+};
+
+uvc_error_t uvc_query_stream_ctrl(uvc_device_handle_t *devh, uvc_stream_ctrl_t *ctrl, uint8_t probe, enum uvc_req_code req);
+
+void        uvc_start_handler_thread(uvc_context_t *ctx);
+uvc_error_t uvc_claim_if(uvc_device_handle_t *devh, int idx);
+uvc_error_t uvc_release_if(uvc_device_handle_t *devh, int idx);
+
+#endif  // !def(LIBUVC_INTERNAL_H)
+/** @endcond */
diff --git a/3rdparty/libuvc/src/include/utlist.h b/3rdparty/libuvc/src/include/utlist.h
new file mode 100644
index 00000000..34c725b9
--- /dev/null
+++ b/3rdparty/libuvc/src/include/utlist.h
@@ -0,0 +1,490 @@
+/*
+Copyright (c) 2007-2010, Troy D. Hanson   http://uthash.sourceforge.net
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
+OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#ifndef UTLIST_H
+#define UTLIST_H
+
+#define UTLIST_VERSION 1.9.1
+
+/* 
+ * This file contains macros to manipulate singly and doubly-linked lists.
+ *
+ * 1. LL_ macros:  singly-linked lists.
+ * 2. DL_ macros:  doubly-linked lists.
+ * 3. CDL_ macros: circular doubly-linked lists.
+ *
+ * To use singly-linked lists, your structure must have a "next" pointer.
+ * To use doubly-linked lists, your structure must "prev" and "next" pointers.
+ * Either way, the pointer to the head of the list must be initialized to NULL.
+ * 
+ * ----------------.EXAMPLE -------------------------
+ * struct item {
+ *      int id;
+ *      struct item *prev, *next;
+ * }
+ *
+ * struct item *list = NULL:
+ *
+ * int main() {
+ *      struct item *item;
+ *      ... allocate and populate item ...
+ *      DL_APPEND(list, item);
+ * }
+ * --------------------------------------------------
+ *
+ * For doubly-linked lists, the append and delete macros are O(1)
+ * For singly-linked lists, append and delete are O(n) but prepend is O(1)
+ * The sort macro is O(n log(n)) for all types of single/double/circular lists.
+ */
+
+/* These macros use decltype or the earlier __typeof GNU extension.
+   As decltype is only available in newer compilers (VS2010 or gcc 4.3+
+   when compiling c++ code), this code uses whatever method is needed
+   or, for VS2008 where neither is available, uses casting workarounds. */
+#ifdef _MSC_VER            /* MS compiler */
+#if _MSC_VER >= 1600 && defined(__cplusplus)  /* VS2010 or newer in C++ mode */
+#define LDECLTYPE(x) decltype(x)
+#else                     /* VS2008 or older (or VS2010 in C mode) */
+#define NO_DECLTYPE
+#define LDECLTYPE(x) char*
+#endif
+#else                      /* GNU, Sun and other compilers */
+#define LDECLTYPE(x) __typeof(x)
+#endif
+
+/* for VS2008 we use some workarounds to get around the lack of decltype,
+ * namely, we always reassign our tmp variable to the list head if we need
+ * to dereference its prev/next pointers, and save/restore the real head.*/
+#ifdef NO_DECLTYPE
+#define _SV(elt,list) _tmp = (char*)(list); {char **_alias = (char**)&(list); *_alias = (elt); }
+#define _NEXT(elt,list) ((char*)((list)->next))
+#define _NEXTASGN(elt,list,to) { char **_alias = (char**)&((list)->next); *_alias=(char*)(to); }
+#define _PREV(elt,list) ((char*)((list)->prev))
+#define _PREVASGN(elt,list,to) { char **_alias = (char**)&((list)->prev); *_alias=(char*)(to); }
+#define _RS(list) { char **_alias = (char**)&(list); *_alias=_tmp; }
+#define _CASTASGN(a,b) { char **_alias = (char**)&(a); *_alias=(char*)(b); }
+#else 
+#define _SV(elt,list)
+#define _NEXT(elt,list) ((elt)->next)
+#define _NEXTASGN(elt,list,to) ((elt)->next)=(to)
+#define _PREV(elt,list) ((elt)->prev)
+#define _PREVASGN(elt,list,to) ((elt)->prev)=(to)
+#define _RS(list)
+#define _CASTASGN(a,b) (a)=(b)
+#endif
+
+/******************************************************************************
+ * The sort macro is an adaptation of Simon Tatham's O(n log(n)) mergesort    *
+ * Unwieldy variable names used here to avoid shadowing passed-in variables.  *
+ *****************************************************************************/
+#define LL_SORT(list, cmp)                                                                     \
+do {                                                                                           \
+  LDECLTYPE(list) _ls_p;                                                                       \
+  LDECLTYPE(list) _ls_q;                                                                       \
+  LDECLTYPE(list) _ls_e;                                                                       \
+  LDECLTYPE(list) _ls_tail;                                                                    \
+  LDECLTYPE(list) _ls_oldhead;                                                                 \
+  LDECLTYPE(list) _tmp;                                                                        \
+  int _ls_insize, _ls_nmerges, _ls_psize, _ls_qsize, _ls_i, _ls_looping;                       \
+  if (list) {                                                                                  \
+    _ls_insize = 1;                                                                            \
+    _ls_looping = 1;                                                                           \
+    while (_ls_looping) {                                                                      \
+      _CASTASGN(_ls_p,list);                                                                   \
+      _CASTASGN(_ls_oldhead,list);                                                             \
+      list = NULL;                                                                             \
+      _ls_tail = NULL;                                                                         \
+      _ls_nmerges = 0;                                                                         \
+      while (_ls_p) {                                                                          \
+        _ls_nmerges++;                                                                         \
+        _ls_q = _ls_p;                                                                         \
+        _ls_psize = 0;                                                                         \
+        for (_ls_i = 0; _ls_i < _ls_insize; _ls_i++) {                                         \
+          _ls_psize++;                                                                         \
+          _SV(_ls_q,list); _ls_q = _NEXT(_ls_q,list); _RS(list);                               \
+          if (!_ls_q) break;                                                                   \
+        }                                                                                      \
+        _ls_qsize = _ls_insize;                                                                \
+        while (_ls_psize > 0 || (_ls_qsize > 0 && _ls_q)) {                                    \
+          if (_ls_psize == 0) {                                                                \
+            _ls_e = _ls_q; _SV(_ls_q,list); _ls_q = _NEXT(_ls_q,list); _RS(list); _ls_qsize--; \
+          } else if (_ls_qsize == 0 || !_ls_q) {                                               \
+            _ls_e = _ls_p; _SV(_ls_p,list); _ls_p = _NEXT(_ls_p,list); _RS(list); _ls_psize--; \
+          } else if (cmp(_ls_p,_ls_q) <= 0) {                                                  \
+            _ls_e = _ls_p; _SV(_ls_p,list); _ls_p = _NEXT(_ls_p,list); _RS(list); _ls_psize--; \
+          } else {                                                                             \
+            _ls_e = _ls_q; _SV(_ls_q,list); _ls_q = _NEXT(_ls_q,list); _RS(list); _ls_qsize--; \
+          }                                                                                    \
+          if (_ls_tail) {                                                                      \
+            _SV(_ls_tail,list); _NEXTASGN(_ls_tail,list,_ls_e); _RS(list);                     \
+          } else {                                                                             \
+            _CASTASGN(list,_ls_e);                                                             \
+          }                                                                                    \
+          _ls_tail = _ls_e;                                                                    \
+        }                                                                                      \
+        _ls_p = _ls_q;                                                                         \
+      }                                                                                        \
+      _SV(_ls_tail,list); _NEXTASGN(_ls_tail,list,NULL); _RS(list);                            \
+      if (_ls_nmerges <= 1) {                                                                  \
+        _ls_looping=0;                                                                         \
+      }                                                                                        \
+      _ls_insize *= 2;                                                                         \
+    }                                                                                          \
+  } else _tmp=NULL; /* quiet gcc unused variable warning */                                    \
+} while (0)
+
+#define DL_SORT(list, cmp)                                                                     \
+do {                                                                                           \
+  LDECLTYPE(list) _ls_p;                                                                       \
+  LDECLTYPE(list) _ls_q;                                                                       \
+  LDECLTYPE(list) _ls_e;                                                                       \
+  LDECLTYPE(list) _ls_tail;                                                                    \
+  LDECLTYPE(list) _ls_oldhead;                                                                 \
+  LDECLTYPE(list) _tmp;                                                                        \
+  int _ls_insize, _ls_nmerges, _ls_psize, _ls_qsize, _ls_i, _ls_looping;                       \
+  if (list) {                                                                                  \
+    _ls_insize = 1;                                                                            \
+    _ls_looping = 1;                                                                           \
+    while (_ls_looping) {                                                                      \
+      _CASTASGN(_ls_p,list);                                                                   \
+      _CASTASGN(_ls_oldhead,list);                                                             \
+      list = NULL;                                                                             \
+      _ls_tail = NULL;                                                                         \
+      _ls_nmerges = 0;                                                                         \
+      while (_ls_p) {                                                                          \
+        _ls_nmerges++;                                                                         \
+        _ls_q = _ls_p;                                                                         \
+        _ls_psize = 0;                                                                         \
+        for (_ls_i = 0; _ls_i < _ls_insize; _ls_i++) {                                         \
+          _ls_psize++;                                                                         \
+          _SV(_ls_q,list); _ls_q = _NEXT(_ls_q,list); _RS(list);                               \
+          if (!_ls_q) break;                                                                   \
+        }                                                                                      \
+        _ls_qsize = _ls_insize;                                                                \
+        while (_ls_psize > 0 || (_ls_qsize > 0 && _ls_q)) {                                    \
+          if (_ls_psize == 0) {                                                                \
+            _ls_e = _ls_q; _SV(_ls_q,list); _ls_q = _NEXT(_ls_q,list); _RS(list); _ls_qsize--; \
+          } else if (_ls_qsize == 0 || !_ls_q) {                                               \
+            _ls_e = _ls_p; _SV(_ls_p,list); _ls_p = _NEXT(_ls_p,list); _RS(list); _ls_psize--; \
+          } else if (cmp(_ls_p,_ls_q) <= 0) {                                                  \
+            _ls_e = _ls_p; _SV(_ls_p,list); _ls_p = _NEXT(_ls_p,list); _RS(list); _ls_psize--; \
+          } else {                                                                             \
+            _ls_e = _ls_q; _SV(_ls_q,list); _ls_q = _NEXT(_ls_q,list); _RS(list); _ls_qsize--; \
+          }                                                                                    \
+          if (_ls_tail) {                                                                      \
+            _SV(_ls_tail,list); _NEXTASGN(_ls_tail,list,_ls_e); _RS(list);                     \
+          } else {                                                                             \
+            _CASTASGN(list,_ls_e);                                                             \
+          }                                                                                    \
+          _SV(_ls_e,list); _PREVASGN(_ls_e,list,_ls_tail); _RS(list);                          \
+          _ls_tail = _ls_e;                                                                    \
+        }                                                                                      \
+        _ls_p = _ls_q;                                                                         \
+      }                                                                                        \
+      _CASTASGN(list->prev, _ls_tail);                                                         \
+      _SV(_ls_tail,list); _NEXTASGN(_ls_tail,list,NULL); _RS(list);                            \
+      if (_ls_nmerges <= 1) {                                                                  \
+        _ls_looping=0;                                                                         \
+      }                                                                                        \
+      _ls_insize *= 2;                                                                         \
+    }                                                                                          \
+  } else _tmp=NULL; /* quiet gcc unused variable warning */                                    \
+} while (0)
+
+#define CDL_SORT(list, cmp)                                                                    \
+do {                                                                                           \
+  LDECLTYPE(list) _ls_p;                                                                       \
+  LDECLTYPE(list) _ls_q;                                                                       \
+  LDECLTYPE(list) _ls_e;                                                                       \
+  LDECLTYPE(list) _ls_tail;                                                                    \
+  LDECLTYPE(list) _ls_oldhead;                                                                 \
+  LDECLTYPE(list) _tmp;                                                                        \
+  LDECLTYPE(list) _tmp2;                                                                       \
+  int _ls_insize, _ls_nmerges, _ls_psize, _ls_qsize, _ls_i, _ls_looping;                       \
+  if (list) {                                                                                  \
+    _ls_insize = 1;                                                                            \
+    _ls_looping = 1;                                                                           \
+    while (_ls_looping) {                                                                      \
+      _CASTASGN(_ls_p,list);                                                                   \
+      _CASTASGN(_ls_oldhead,list);                                                             \
+      list = NULL;                                                                             \
+      _ls_tail = NULL;                                                                         \
+      _ls_nmerges = 0;                                                                         \
+      while (_ls_p) {                                                                          \
+        _ls_nmerges++;                                                                         \
+        _ls_q = _ls_p;                                                                         \
+        _ls_psize = 0;                                                                         \
+        for (_ls_i = 0; _ls_i < _ls_insize; _ls_i++) {                                         \
+          _ls_psize++;                                                                         \
+          _SV(_ls_q,list);                                                                     \
+          if (_NEXT(_ls_q,list) == _ls_oldhead) {                                              \
+            _ls_q = NULL;                                                                      \
+          } else {                                                                             \
+            _ls_q = _NEXT(_ls_q,list);                                                         \
+          }                                                                                    \
+          _RS(list);                                                                           \
+          if (!_ls_q) break;                                                                   \
+        }                                                                                      \
+        _ls_qsize = _ls_insize;                                                                \
+        while (_ls_psize > 0 || (_ls_qsize > 0 && _ls_q)) {                                    \
+          if (_ls_psize == 0) {                                                                \
+            _ls_e = _ls_q; _SV(_ls_q,list); _ls_q = _NEXT(_ls_q,list); _RS(list); _ls_qsize--; \
+            if (_ls_q == _ls_oldhead) { _ls_q = NULL; }                                        \
+          } else if (_ls_qsize == 0 || !_ls_q) {                                               \
+            _ls_e = _ls_p; _SV(_ls_p,list); _ls_p = _NEXT(_ls_p,list); _RS(list); _ls_psize--; \
+            if (_ls_p == _ls_oldhead) { _ls_p = NULL; }                                        \
+          } else if (cmp(_ls_p,_ls_q) <= 0) {                                                  \
+            _ls_e = _ls_p; _SV(_ls_p,list); _ls_p = _NEXT(_ls_p,list); _RS(list); _ls_psize--; \
+            if (_ls_p == _ls_oldhead) { _ls_p = NULL; }                                        \
+          } else {                                                                             \
+            _ls_e = _ls_q; _SV(_ls_q,list); _ls_q = _NEXT(_ls_q,list); _RS(list); _ls_qsize--; \
+            if (_ls_q == _ls_oldhead) { _ls_q = NULL; }                                        \
+          }                                                                                    \
+          if (_ls_tail) {                                                                      \
+            _SV(_ls_tail,list); _NEXTASGN(_ls_tail,list,_ls_e); _RS(list);                     \
+          } else {                                                                             \
+            _CASTASGN(list,_ls_e);                                                             \
+          }                                                                                    \
+          _SV(_ls_e,list); _PREVASGN(_ls_e,list,_ls_tail); _RS(list);                          \
+          _ls_tail = _ls_e;                                                                    \
+        }                                                                                      \
+        _ls_p = _ls_q;                                                                         \
+      }                                                                                        \
+      _CASTASGN(list->prev,_ls_tail);                                                          \
+      _CASTASGN(_tmp2,list);                                                                   \
+      _SV(_ls_tail,list); _NEXTASGN(_ls_tail,list,_tmp2); _RS(list);                           \
+      if (_ls_nmerges <= 1) {                                                                  \
+        _ls_looping=0;                                                                         \
+      }                                                                                        \
+      _ls_insize *= 2;                                                                         \
+    }                                                                                          \
+  } else _tmp=NULL; /* quiet gcc unused variable warning */                                    \
+} while (0)
+
+/******************************************************************************
+ * singly linked list macros (non-circular)                                   *
+ *****************************************************************************/
+#define LL_PREPEND(head,add)                                                                   \
+do {                                                                                           \
+  (add)->next = head;                                                                          \
+  head = add;                                                                                  \
+} while (0)
+
+#define LL_APPEND(head,add)                                                                    \
+do {                                                                                           \
+  LDECLTYPE(head) _tmp;                                                                        \
+  (add)->next=NULL;                                                                            \
+  if (head) {                                                                                  \
+    _tmp = head;                                                                               \
+    while (_tmp->next) { _tmp = _tmp->next; }                                                  \
+    _tmp->next=(add);                                                                          \
+  } else {                                                                                     \
+    (head)=(add);                                                                              \
+  }                                                                                            \
+} while (0)
+
+#define LL_DELETE(head,del)                                                                    \
+do {                                                                                           \
+  LDECLTYPE(head) _tmp;                                                                        \
+  if ((head) == (del)) {                                                                       \
+    (head)=(head)->next;                                                                       \
+  } else {                                                                                     \
+    _tmp = head;                                                                               \
+    while (_tmp->next && (_tmp->next != (del))) {                                              \
+      _tmp = _tmp->next;                                                                       \
+    }                                                                                          \
+    if (_tmp->next) {                                                                          \
+      _tmp->next = ((del)->next);                                                              \
+    }                                                                                          \
+  }                                                                                            \
+} while (0)
+
+/* Here are VS2008 replacements for LL_APPEND and LL_DELETE */
+#define LL_APPEND_VS2008(head,add)                                                             \
+do {                                                                                           \
+  if (head) {                                                                                  \
+    (add)->next = head;     /* use add->next as a temp variable */                             \
+    while ((add)->next->next) { (add)->next = (add)->next->next; }                             \
+    (add)->next->next=(add);                                                                   \
+  } else {                                                                                     \
+    (head)=(add);                                                                              \
+  }                                                                                            \
+  (add)->next=NULL;                                                                            \
+} while (0)
+
+#define LL_DELETE_VS2008(head,del)                                                             \
+do {                                                                                           \
+  if ((head) == (del)) {                                                                       \
+    (head)=(head)->next;                                                                       \
+  } else {                                                                                     \
+    char *_tmp = (char*)(head);                                                                \
+    while (head->next && (head->next != (del))) {                                              \
+      head = head->next;                                                                       \
+    }                                                                                          \
+    if (head->next) {                                                                          \
+      head->next = ((del)->next);                                                              \
+    }                                                                                          \
+    {                                                                                          \
+      char **_head_alias = (char**)&(head);                                                    \
+      *_head_alias = _tmp;                                                                     \
+    }                                                                                          \
+  }                                                                                            \
+} while (0)
+#ifdef NO_DECLTYPE
+#undef LL_APPEND
+#define LL_APPEND LL_APPEND_VS2008
+#undef LL_DELETE
+#define LL_DELETE LL_DELETE_VS2008
+#endif
+/* end VS2008 replacements */
+
+#define LL_FOREACH(head,el)                                                                    \
+    for(el=head;el;el=el->next)
+
+#define LL_FOREACH_SAFE(head,el,tmp)                                                           \
+  for((el)=(head);(el) && (tmp = (el)->next, 1); (el) = tmp)
+
+#define LL_SEARCH_SCALAR(head,out,field,val)                                                   \
+do {                                                                                           \
+    LL_FOREACH(head,out) {                                                                     \
+      if ((out)->field == (val)) break;                                                        \
+    }                                                                                          \
+} while(0) 
+
+#define LL_SEARCH(head,out,elt,cmp)                                                            \
+do {                                                                                           \
+    LL_FOREACH(head,out) {                                                                     \
+      if ((cmp(out,elt))==0) break;                                                            \
+    }                                                                                          \
+} while(0) 
+
+/******************************************************************************
+ * doubly linked list macros (non-circular)                                   *
+ *****************************************************************************/
+#define DL_PREPEND(head,add)                                                                   \
+do {                                                                                           \
+ (add)->next = head;                                                                           \
+ if (head) {                                                                                   \
+   (add)->prev = (head)->prev;                                                                 \
+   (head)->prev = (add);                                                                       \
+ } else {                                                                                      \
+   (add)->prev = (add);                                                                        \
+ }                                                                                             \
+ (head) = (add);                                                                               \
+} while (0)
+
+#define DL_APPEND(head,add)                                                                    \
+do {                                                                                           \
+  if (head) {                                                                                  \
+      (add)->prev = (head)->prev;                                                              \
+      (head)->prev->next = (add);                                                              \
+      (head)->prev = (add);                                                                    \
+      (add)->next = NULL;                                                                      \
+  } else {                                                                                     \
+      (head)=(add);                                                                            \
+      (head)->prev = (head);                                                                   \
+      (head)->next = NULL;                                                                     \
+  }                                                                                            \
+} while (0);
+
+#define DL_DELETE(head,del)                                                                    \
+do {                                                                                           \
+  if ((del)->prev == (del)) {                                                                  \
+      (head)=NULL;                                                                             \
+  } else if ((del)==(head)) {                                                                  \
+      (del)->next->prev = (del)->prev;                                                         \
+      (head) = (del)->next;                                                                    \
+  } else {                                                                                     \
+      (del)->prev->next = (del)->next;                                                         \
+      if ((del)->next) {                                                                       \
+          (del)->next->prev = (del)->prev;                                                     \
+      } else {                                                                                 \
+          (head)->prev = (del)->prev;                                                          \
+      }                                                                                        \
+  }                                                                                            \
+} while (0);
+
+
+#define DL_FOREACH(head,el)                                                                    \
+    for(el=head;el;el=el->next)
+
+/* this version is safe for deleting the elements during iteration */
+#define DL_FOREACH_SAFE(head,el,tmp)                                                           \
+  for((el)=(head);(el) && (tmp = (el)->next, 1); (el) = tmp)
+
+/* these are identical to their singly-linked list counterparts */
+#define DL_SEARCH_SCALAR LL_SEARCH_SCALAR
+#define DL_SEARCH LL_SEARCH
+
+/******************************************************************************
+ * circular doubly linked list macros                                         *
+ *****************************************************************************/
+#define CDL_PREPEND(head,add)                                                                  \
+do {                                                                                           \
+ if (head) {                                                                                   \
+   (add)->prev = (head)->prev;                                                                 \
+   (add)->next = (head);                                                                       \
+   (head)->prev = (add);                                                                       \
+   (add)->prev->next = (add);                                                                  \
+ } else {                                                                                      \
+   (add)->prev = (add);                                                                        \
+   (add)->next = (add);                                                                        \
+ }                                                                                             \
+(head)=(add);                                                                                  \
+} while (0)
+
+#define CDL_DELETE(head,del)                                                                   \
+do {                                                                                           \
+  if ( ((head)==(del)) && ((head)->next == (head))) {                                          \
+      (head) = 0L;                                                                             \
+  } else {                                                                                     \
+     (del)->next->prev = (del)->prev;                                                          \
+     (del)->prev->next = (del)->next;                                                          \
+     if ((del) == (head)) (head)=(del)->next;                                                  \
+  }                                                                                            \
+} while (0);
+
+#define CDL_FOREACH(head,el)                                                                   \
+    for(el=head;el;el=(el->next==head ? 0L : el->next)) 
+
+#define CDL_FOREACH_SAFE(head,el,tmp1,tmp2)                                                    \
+  for((el)=(head), ((tmp1)=(head)?((head)->prev):NULL);                                        \
+      (el) && ((tmp2)=(el)->next, 1);                                                          \
+      ((el) = (((el)==(tmp1)) ? 0L : (tmp2))))
+
+#define CDL_SEARCH_SCALAR(head,out,field,val)                                                  \
+do {                                                                                           \
+    CDL_FOREACH(head,out) {                                                                    \
+      if ((out)->field == (val)) break;                                                        \
+    }                                                                                          \
+} while(0) 
+
+#define CDL_SEARCH(head,out,elt,cmp)                                                           \
+do {                                                                                           \
+    CDL_FOREACH(head,out) {                                                                    \
+      if ((cmp(out,elt))==0) break;                                                            \
+    }                                                                                          \
+} while(0) 
+
+#endif /* UTLIST_H */
+
diff --git a/3rdparty/libuvc/src/libuvc.pc.in b/3rdparty/libuvc/src/libuvc.pc.in
new file mode 100644
index 00000000..1407bb6f
--- /dev/null
+++ b/3rdparty/libuvc/src/libuvc.pc.in
@@ -0,0 +1,11 @@
+libdir=@CMAKE_INSTALL_PREFIX@/@CMAKE_INSTALL_LIBDIR@
+includedir=@CMAKE_INSTALL_PREFIX@/@CMAKE_INSTALL_INCLUDEDIR@
+
+Name: libuvc
+Description: @libuvc_DESCRIPTION@
+URL: @libuvc_URL@
+Version: @libuvc_VERSION@
+Libs: -L${libdir} -luvc
+Libs.private: -lusb-1.0 @PKGCONFIG_JPEG_LDFLAG@
+Cflags: -I${includedir}
+Requires: libusb-1.0
diff --git a/3rdparty/libuvc/src/libuvcConfig.cmake b/3rdparty/libuvc/src/libuvcConfig.cmake
new file mode 100644
index 00000000..b9887ea9
--- /dev/null
+++ b/3rdparty/libuvc/src/libuvcConfig.cmake
@@ -0,0 +1,17 @@
+list(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_LIST_DIR})
+
+# If find_package called with REQUIRED or QUIET we need to
+# forward down it
+unset(extraArgs)
+if(${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY)
+  list(APPEND extraArgs QUIET)
+endif()
+if(${CMAKE_FIND_PACKAGE_NAME}_FIND_REQUIRED)
+  list(APPEND extraArgs REQUIRED)
+endif()
+
+find_package(JpegPkg ${extraArgs})
+find_package(LibUSB ${extraArgs})
+include("${CMAKE_CURRENT_LIST_DIR}/libuvcTargets.cmake")
+
+set(libuvc_FOUND TRUE)
diff --git a/3rdparty/libuvc/src/src/ctrl-gen.c b/3rdparty/libuvc/src/src/ctrl-gen.c
new file mode 100644
index 00000000..30c0ab61
--- /dev/null
+++ b/3rdparty/libuvc/src/src/ctrl-gen.c
@@ -0,0 +1,2259 @@
+/* This is an AUTO-GENERATED file! Update it with the output of `ctrl-gen.py def`. */
+#include "libuvc/libuvc.h"
+#include "libuvc/libuvc_internal.h"
+
+static const int REQ_TYPE_SET = 0x21;
+static const int REQ_TYPE_GET = 0xa1;
+
+/** @ingroup ctrl
+ * @brief Reads the SCANNING_MODE control.
+ * @param devh UVC device handle
+ * @param[out] mode 0: interlaced, 1: progressive
+ * @param req_code UVC_GET_* request to execute
+ */
+uvc_error_t uvc_get_scanning_mode(uvc_device_handle_t *devh, uint8_t* mode, enum uvc_req_code req_code) {
+  uint8_t data[1];
+  uvc_error_t ret;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_GET, req_code,
+    UVC_CT_SCANNING_MODE_CONTROL << 8,
+    uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data)) {
+    *mode = data[0];
+    return UVC_SUCCESS;
+  } else {
+    return ret;
+  }
+}
+
+
+/** @ingroup ctrl
+ * @brief Sets the SCANNING_MODE control.
+ * @param devh UVC device handle
+ * @param mode 0: interlaced, 1: progressive
+ */
+uvc_error_t uvc_set_scanning_mode(uvc_device_handle_t *devh, uint8_t mode) {
+  uint8_t data[1];
+  uvc_error_t ret;
+
+  data[0] = mode;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_SET, UVC_SET_CUR,
+    UVC_CT_SCANNING_MODE_CONTROL << 8,
+    uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data))
+    return UVC_SUCCESS;
+  else
+    return ret;
+}
+
+/** @ingroup ctrl
+ * @brief Reads camera's auto-exposure mode.
+ * 
+ * See uvc_set_ae_mode() for a description of the available modes.
+ * @param devh UVC device handle
+ * @param[out] mode 1: manual mode; 2: auto mode; 4: shutter priority mode; 8: aperture priority mode
+ * @param req_code UVC_GET_* request to execute
+ */
+uvc_error_t uvc_get_ae_mode(uvc_device_handle_t *devh, uint8_t* mode, enum uvc_req_code req_code) {
+  uint8_t data[1];
+  uvc_error_t ret;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_GET, req_code,
+    UVC_CT_AE_MODE_CONTROL << 8,
+    uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data)) {
+    *mode = data[0];
+    return UVC_SUCCESS;
+  } else {
+    return ret;
+  }
+}
+
+
+/** @ingroup ctrl
+ * @brief Sets camera's auto-exposure mode.
+ * 
+ * Cameras may support any of the following AE modes:
+ *  * UVC_AUTO_EXPOSURE_MODE_MANUAL (1) - manual exposure time, manual iris
+ *  * UVC_AUTO_EXPOSURE_MODE_AUTO (2) - auto exposure time, auto iris
+ *  * UVC_AUTO_EXPOSURE_MODE_SHUTTER_PRIORITY (4) - manual exposure time, auto iris
+ *  * UVC_AUTO_EXPOSURE_MODE_APERTURE_PRIORITY (8) - auto exposure time, manual iris
+ * 
+ * Most cameras provide manual mode and aperture priority mode.
+ * @param devh UVC device handle
+ * @param mode 1: manual mode; 2: auto mode; 4: shutter priority mode; 8: aperture priority mode
+ */
+uvc_error_t uvc_set_ae_mode(uvc_device_handle_t *devh, uint8_t mode) {
+  uint8_t data[1];
+  uvc_error_t ret;
+
+  data[0] = mode;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_SET, UVC_SET_CUR,
+    UVC_CT_AE_MODE_CONTROL << 8,
+    uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data))
+    return UVC_SUCCESS;
+  else
+    return ret;
+}
+
+/** @ingroup ctrl
+ * @brief Checks whether the camera may vary the frame rate for exposure control reasons.
+ * See uvc_set_ae_priority() for a description of the `priority` field.
+ * @param devh UVC device handle
+ * @param[out] priority 0: frame rate must remain constant; 1: frame rate may be varied for AE purposes
+ * @param req_code UVC_GET_* request to execute
+ */
+uvc_error_t uvc_get_ae_priority(uvc_device_handle_t *devh, uint8_t* priority, enum uvc_req_code req_code) {
+  uint8_t data[1];
+  uvc_error_t ret;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_GET, req_code,
+    UVC_CT_AE_PRIORITY_CONTROL << 8,
+    uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data)) {
+    *priority = data[0];
+    return UVC_SUCCESS;
+  } else {
+    return ret;
+  }
+}
+
+
+/** @ingroup ctrl
+ * @brief Chooses whether the camera may vary the frame rate for exposure control reasons.
+ * A `priority` value of zero means the camera may not vary its frame rate. A value of 1
+ * means the frame rate is variable. This setting has no effect outside of the `auto` and
+ * `shutter_priority` auto-exposure modes.
+ * @param devh UVC device handle
+ * @param priority 0: frame rate must remain constant; 1: frame rate may be varied for AE purposes
+ */
+uvc_error_t uvc_set_ae_priority(uvc_device_handle_t *devh, uint8_t priority) {
+  uint8_t data[1];
+  uvc_error_t ret;
+
+  data[0] = priority;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_SET, UVC_SET_CUR,
+    UVC_CT_AE_PRIORITY_CONTROL << 8,
+    uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data))
+    return UVC_SUCCESS;
+  else
+    return ret;
+}
+
+/** @ingroup ctrl
+ * @brief Gets the absolute exposure time.
+ * 
+ * See uvc_set_exposure_abs() for a description of the `time` field.
+ * @param devh UVC device handle
+ * @param[out] time 
+ * @param req_code UVC_GET_* request to execute
+ */
+uvc_error_t uvc_get_exposure_abs(uvc_device_handle_t *devh, uint32_t* time, enum uvc_req_code req_code) {
+  uint8_t data[4];
+  uvc_error_t ret;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_GET, req_code,
+    UVC_CT_EXPOSURE_TIME_ABSOLUTE_CONTROL << 8,
+    uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data)) {
+    *time = DW_TO_INT(data + 0);
+    return UVC_SUCCESS;
+  } else {
+    return ret;
+  }
+}
+
+
+/** @ingroup ctrl
+ * @brief Sets the absolute exposure time.
+ * 
+ * The `time` parameter should be provided in units of 0.0001 seconds (e.g., use the value 100
+ * for a 10ms exposure period). Auto exposure should be set to `manual` or `shutter_priority`
+ * before attempting to change this setting.
+ * @param devh UVC device handle
+ * @param time 
+ */
+uvc_error_t uvc_set_exposure_abs(uvc_device_handle_t *devh, uint32_t time) {
+  uint8_t data[4];
+  uvc_error_t ret;
+
+  INT_TO_DW(time, data + 0);
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_SET, UVC_SET_CUR,
+    UVC_CT_EXPOSURE_TIME_ABSOLUTE_CONTROL << 8,
+    uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data))
+    return UVC_SUCCESS;
+  else
+    return ret;
+}
+
+/** @ingroup ctrl
+ * @brief Reads the exposure time relative to the current setting.
+ * @param devh UVC device handle
+ * @param[out] step number of steps by which to change the exposure time, or zero to set the default exposure time
+ * @param req_code UVC_GET_* request to execute
+ */
+uvc_error_t uvc_get_exposure_rel(uvc_device_handle_t *devh, int8_t* step, enum uvc_req_code req_code) {
+  uint8_t data[1];
+  uvc_error_t ret;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_GET, req_code,
+    UVC_CT_EXPOSURE_TIME_RELATIVE_CONTROL << 8,
+    uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data)) {
+    *step = data[0];
+    return UVC_SUCCESS;
+  } else {
+    return ret;
+  }
+}
+
+
+/** @ingroup ctrl
+ * @brief Sets the exposure time relative to the current setting.
+ * @param devh UVC device handle
+ * @param step number of steps by which to change the exposure time, or zero to set the default exposure time
+ */
+uvc_error_t uvc_set_exposure_rel(uvc_device_handle_t *devh, int8_t step) {
+  uint8_t data[1];
+  uvc_error_t ret;
+
+  data[0] = step;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_SET, UVC_SET_CUR,
+    UVC_CT_EXPOSURE_TIME_RELATIVE_CONTROL << 8,
+    uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data))
+    return UVC_SUCCESS;
+  else
+    return ret;
+}
+
+/** @ingroup ctrl
+ * @brief Reads the distance at which an object is optimally focused.
+ * @param devh UVC device handle
+ * @param[out] focus focal target distance in millimeters
+ * @param req_code UVC_GET_* request to execute
+ */
+uvc_error_t uvc_get_focus_abs(uvc_device_handle_t *devh, uint16_t* focus, enum uvc_req_code req_code) {
+  uint8_t data[2];
+  uvc_error_t ret;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_GET, req_code,
+    UVC_CT_FOCUS_ABSOLUTE_CONTROL << 8,
+    uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data)) {
+    *focus = SW_TO_SHORT(data + 0);
+    return UVC_SUCCESS;
+  } else {
+    return ret;
+  }
+}
+
+
+/** @ingroup ctrl
+ * @brief Sets the distance at which an object is optimally focused.
+ * @param devh UVC device handle
+ * @param focus focal target distance in millimeters
+ */
+uvc_error_t uvc_set_focus_abs(uvc_device_handle_t *devh, uint16_t focus) {
+  uint8_t data[2];
+  uvc_error_t ret;
+
+  SHORT_TO_SW(focus, data + 0);
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_SET, UVC_SET_CUR,
+    UVC_CT_FOCUS_ABSOLUTE_CONTROL << 8,
+    uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data))
+    return UVC_SUCCESS;
+  else
+    return ret;
+}
+
+/** @ingroup ctrl
+ * @brief Reads the FOCUS_RELATIVE control.
+ * @param devh UVC device handle
+ * @param[out] focus_rel TODO
+ * @param[out] speed TODO
+ * @param req_code UVC_GET_* request to execute
+ */
+uvc_error_t uvc_get_focus_rel(uvc_device_handle_t *devh, int8_t* focus_rel, uint8_t* speed, enum uvc_req_code req_code) {
+  uint8_t data[2];
+  uvc_error_t ret;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_GET, req_code,
+    UVC_CT_FOCUS_RELATIVE_CONTROL << 8,
+    uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data)) {
+    *focus_rel = data[0];
+    *speed = data[1];
+    return UVC_SUCCESS;
+  } else {
+    return ret;
+  }
+}
+
+
+/** @ingroup ctrl
+ * @brief Sets the FOCUS_RELATIVE control.
+ * @param devh UVC device handle
+ * @param focus_rel TODO
+ * @param speed TODO
+ */
+uvc_error_t uvc_set_focus_rel(uvc_device_handle_t *devh, int8_t focus_rel, uint8_t speed) {
+  uint8_t data[2];
+  uvc_error_t ret;
+
+  data[0] = focus_rel;
+  data[1] = speed;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_SET, UVC_SET_CUR,
+    UVC_CT_FOCUS_RELATIVE_CONTROL << 8,
+    uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data))
+    return UVC_SUCCESS;
+  else
+    return ret;
+}
+
+/** @ingroup ctrl
+ * @brief Reads the FOCUS_SIMPLE control.
+ * @param devh UVC device handle
+ * @param[out] focus TODO
+ * @param req_code UVC_GET_* request to execute
+ */
+uvc_error_t uvc_get_focus_simple_range(uvc_device_handle_t *devh, uint8_t* focus, enum uvc_req_code req_code) {
+  uint8_t data[1];
+  uvc_error_t ret;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_GET, req_code,
+    UVC_CT_FOCUS_SIMPLE_CONTROL << 8,
+    uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data)) {
+    *focus = data[0];
+    return UVC_SUCCESS;
+  } else {
+    return ret;
+  }
+}
+
+
+/** @ingroup ctrl
+ * @brief Sets the FOCUS_SIMPLE control.
+ * @param devh UVC device handle
+ * @param focus TODO
+ */
+uvc_error_t uvc_set_focus_simple_range(uvc_device_handle_t *devh, uint8_t focus) {
+  uint8_t data[1];
+  uvc_error_t ret;
+
+  data[0] = focus;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_SET, UVC_SET_CUR,
+    UVC_CT_FOCUS_SIMPLE_CONTROL << 8,
+    uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data))
+    return UVC_SUCCESS;
+  else
+    return ret;
+}
+
+/** @ingroup ctrl
+ * @brief Reads the FOCUS_AUTO control.
+ * @param devh UVC device handle
+ * @param[out] state TODO
+ * @param req_code UVC_GET_* request to execute
+ */
+uvc_error_t uvc_get_focus_auto(uvc_device_handle_t *devh, uint8_t* state, enum uvc_req_code req_code) {
+  uint8_t data[1];
+  uvc_error_t ret;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_GET, req_code,
+    UVC_CT_FOCUS_AUTO_CONTROL << 8,
+    uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data)) {
+    *state = data[0];
+    return UVC_SUCCESS;
+  } else {
+    return ret;
+  }
+}
+
+
+/** @ingroup ctrl
+ * @brief Sets the FOCUS_AUTO control.
+ * @param devh UVC device handle
+ * @param state TODO
+ */
+uvc_error_t uvc_set_focus_auto(uvc_device_handle_t *devh, uint8_t state) {
+  uint8_t data[1];
+  uvc_error_t ret;
+
+  data[0] = state;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_SET, UVC_SET_CUR,
+    UVC_CT_FOCUS_AUTO_CONTROL << 8,
+    uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data))
+    return UVC_SUCCESS;
+  else
+    return ret;
+}
+
+/** @ingroup ctrl
+ * @brief Reads the IRIS_ABSOLUTE control.
+ * @param devh UVC device handle
+ * @param[out] iris TODO
+ * @param req_code UVC_GET_* request to execute
+ */
+uvc_error_t uvc_get_iris_abs(uvc_device_handle_t *devh, uint16_t* iris, enum uvc_req_code req_code) {
+  uint8_t data[2];
+  uvc_error_t ret;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_GET, req_code,
+    UVC_CT_IRIS_ABSOLUTE_CONTROL << 8,
+    uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data)) {
+    *iris = SW_TO_SHORT(data + 0);
+    return UVC_SUCCESS;
+  } else {
+    return ret;
+  }
+}
+
+
+/** @ingroup ctrl
+ * @brief Sets the IRIS_ABSOLUTE control.
+ * @param devh UVC device handle
+ * @param iris TODO
+ */
+uvc_error_t uvc_set_iris_abs(uvc_device_handle_t *devh, uint16_t iris) {
+  uint8_t data[2];
+  uvc_error_t ret;
+
+  SHORT_TO_SW(iris, data + 0);
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_SET, UVC_SET_CUR,
+    UVC_CT_IRIS_ABSOLUTE_CONTROL << 8,
+    uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data))
+    return UVC_SUCCESS;
+  else
+    return ret;
+}
+
+/** @ingroup ctrl
+ * @brief Reads the IRIS_RELATIVE control.
+ * @param devh UVC device handle
+ * @param[out] iris_rel TODO
+ * @param req_code UVC_GET_* request to execute
+ */
+uvc_error_t uvc_get_iris_rel(uvc_device_handle_t *devh, uint8_t* iris_rel, enum uvc_req_code req_code) {
+  uint8_t data[1];
+  uvc_error_t ret;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_GET, req_code,
+    UVC_CT_IRIS_RELATIVE_CONTROL << 8,
+    uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data)) {
+    *iris_rel = data[0];
+    return UVC_SUCCESS;
+  } else {
+    return ret;
+  }
+}
+
+
+/** @ingroup ctrl
+ * @brief Sets the IRIS_RELATIVE control.
+ * @param devh UVC device handle
+ * @param iris_rel TODO
+ */
+uvc_error_t uvc_set_iris_rel(uvc_device_handle_t *devh, uint8_t iris_rel) {
+  uint8_t data[1];
+  uvc_error_t ret;
+
+  data[0] = iris_rel;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_SET, UVC_SET_CUR,
+    UVC_CT_IRIS_RELATIVE_CONTROL << 8,
+    uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data))
+    return UVC_SUCCESS;
+  else
+    return ret;
+}
+
+/** @ingroup ctrl
+ * @brief Reads the ZOOM_ABSOLUTE control.
+ * @param devh UVC device handle
+ * @param[out] focal_length TODO
+ * @param req_code UVC_GET_* request to execute
+ */
+uvc_error_t uvc_get_zoom_abs(uvc_device_handle_t *devh, uint16_t* focal_length, enum uvc_req_code req_code) {
+  uint8_t data[2];
+  uvc_error_t ret;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_GET, req_code,
+    UVC_CT_ZOOM_ABSOLUTE_CONTROL << 8,
+    uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data)) {
+    *focal_length = SW_TO_SHORT(data + 0);
+    return UVC_SUCCESS;
+  } else {
+    return ret;
+  }
+}
+
+
+/** @ingroup ctrl
+ * @brief Sets the ZOOM_ABSOLUTE control.
+ * @param devh UVC device handle
+ * @param focal_length TODO
+ */
+uvc_error_t uvc_set_zoom_abs(uvc_device_handle_t *devh, uint16_t focal_length) {
+  uint8_t data[2];
+  uvc_error_t ret;
+
+  SHORT_TO_SW(focal_length, data + 0);
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_SET, UVC_SET_CUR,
+    UVC_CT_ZOOM_ABSOLUTE_CONTROL << 8,
+    uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data))
+    return UVC_SUCCESS;
+  else
+    return ret;
+}
+
+/** @ingroup ctrl
+ * @brief Reads the ZOOM_RELATIVE control.
+ * @param devh UVC device handle
+ * @param[out] zoom_rel TODO
+ * @param[out] digital_zoom TODO
+ * @param[out] speed TODO
+ * @param req_code UVC_GET_* request to execute
+ */
+uvc_error_t uvc_get_zoom_rel(uvc_device_handle_t *devh, int8_t* zoom_rel, uint8_t* digital_zoom, uint8_t* speed, enum uvc_req_code req_code) {
+  uint8_t data[3];
+  uvc_error_t ret;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_GET, req_code,
+    UVC_CT_ZOOM_RELATIVE_CONTROL << 8,
+    uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data)) {
+    *zoom_rel = data[0];
+    *digital_zoom = data[1];
+    *speed = data[2];
+    return UVC_SUCCESS;
+  } else {
+    return ret;
+  }
+}
+
+
+/** @ingroup ctrl
+ * @brief Sets the ZOOM_RELATIVE control.
+ * @param devh UVC device handle
+ * @param zoom_rel TODO
+ * @param digital_zoom TODO
+ * @param speed TODO
+ */
+uvc_error_t uvc_set_zoom_rel(uvc_device_handle_t *devh, int8_t zoom_rel, uint8_t digital_zoom, uint8_t speed) {
+  uint8_t data[3];
+  uvc_error_t ret;
+
+  data[0] = zoom_rel;
+  data[1] = digital_zoom;
+  data[2] = speed;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_SET, UVC_SET_CUR,
+    UVC_CT_ZOOM_RELATIVE_CONTROL << 8,
+    uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data))
+    return UVC_SUCCESS;
+  else
+    return ret;
+}
+
+/** @ingroup ctrl
+ * @brief Reads the PANTILT_ABSOLUTE control.
+ * @param devh UVC device handle
+ * @param[out] pan TODO
+ * @param[out] tilt TODO
+ * @param req_code UVC_GET_* request to execute
+ */
+uvc_error_t uvc_get_pantilt_abs(uvc_device_handle_t *devh, int32_t* pan, int32_t* tilt, enum uvc_req_code req_code) {
+  uint8_t data[8];
+  uvc_error_t ret;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_GET, req_code,
+    UVC_CT_PANTILT_ABSOLUTE_CONTROL << 8,
+    uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data)) {
+    *pan = DW_TO_INT(data + 0);
+    *tilt = DW_TO_INT(data + 4);
+    return UVC_SUCCESS;
+  } else {
+    return ret;
+  }
+}
+
+
+/** @ingroup ctrl
+ * @brief Sets the PANTILT_ABSOLUTE control.
+ * @param devh UVC device handle
+ * @param pan TODO
+ * @param tilt TODO
+ */
+uvc_error_t uvc_set_pantilt_abs(uvc_device_handle_t *devh, int32_t pan, int32_t tilt) {
+  uint8_t data[8];
+  uvc_error_t ret;
+
+  INT_TO_DW(pan, data + 0);
+  INT_TO_DW(tilt, data + 4);
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_SET, UVC_SET_CUR,
+    UVC_CT_PANTILT_ABSOLUTE_CONTROL << 8,
+    uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data))
+    return UVC_SUCCESS;
+  else
+    return ret;
+}
+
+/** @ingroup ctrl
+ * @brief Reads the PANTILT_RELATIVE control.
+ * @param devh UVC device handle
+ * @param[out] pan_rel TODO
+ * @param[out] pan_speed TODO
+ * @param[out] tilt_rel TODO
+ * @param[out] tilt_speed TODO
+ * @param req_code UVC_GET_* request to execute
+ */
+uvc_error_t uvc_get_pantilt_rel(uvc_device_handle_t *devh, int8_t* pan_rel, uint8_t* pan_speed, int8_t* tilt_rel, uint8_t* tilt_speed, enum uvc_req_code req_code) {
+  uint8_t data[4];
+  uvc_error_t ret;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_GET, req_code,
+    UVC_CT_PANTILT_RELATIVE_CONTROL << 8,
+    uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data)) {
+    *pan_rel = data[0];
+    *pan_speed = data[1];
+    *tilt_rel = data[2];
+    *tilt_speed = data[3];
+    return UVC_SUCCESS;
+  } else {
+    return ret;
+  }
+}
+
+
+/** @ingroup ctrl
+ * @brief Sets the PANTILT_RELATIVE control.
+ * @param devh UVC device handle
+ * @param pan_rel TODO
+ * @param pan_speed TODO
+ * @param tilt_rel TODO
+ * @param tilt_speed TODO
+ */
+uvc_error_t uvc_set_pantilt_rel(uvc_device_handle_t *devh, int8_t pan_rel, uint8_t pan_speed, int8_t tilt_rel, uint8_t tilt_speed) {
+  uint8_t data[4];
+  uvc_error_t ret;
+
+  data[0] = pan_rel;
+  data[1] = pan_speed;
+  data[2] = tilt_rel;
+  data[3] = tilt_speed;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_SET, UVC_SET_CUR,
+    UVC_CT_PANTILT_RELATIVE_CONTROL << 8,
+    uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data))
+    return UVC_SUCCESS;
+  else
+    return ret;
+}
+
+/** @ingroup ctrl
+ * @brief Reads the ROLL_ABSOLUTE control.
+ * @param devh UVC device handle
+ * @param[out] roll TODO
+ * @param req_code UVC_GET_* request to execute
+ */
+uvc_error_t uvc_get_roll_abs(uvc_device_handle_t *devh, int16_t* roll, enum uvc_req_code req_code) {
+  uint8_t data[2];
+  uvc_error_t ret;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_GET, req_code,
+    UVC_CT_ROLL_ABSOLUTE_CONTROL << 8,
+    uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data)) {
+    *roll = SW_TO_SHORT(data + 0);
+    return UVC_SUCCESS;
+  } else {
+    return ret;
+  }
+}
+
+
+/** @ingroup ctrl
+ * @brief Sets the ROLL_ABSOLUTE control.
+ * @param devh UVC device handle
+ * @param roll TODO
+ */
+uvc_error_t uvc_set_roll_abs(uvc_device_handle_t *devh, int16_t roll) {
+  uint8_t data[2];
+  uvc_error_t ret;
+
+  SHORT_TO_SW(roll, data + 0);
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_SET, UVC_SET_CUR,
+    UVC_CT_ROLL_ABSOLUTE_CONTROL << 8,
+    uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data))
+    return UVC_SUCCESS;
+  else
+    return ret;
+}
+
+/** @ingroup ctrl
+ * @brief Reads the ROLL_RELATIVE control.
+ * @param devh UVC device handle
+ * @param[out] roll_rel TODO
+ * @param[out] speed TODO
+ * @param req_code UVC_GET_* request to execute
+ */
+uvc_error_t uvc_get_roll_rel(uvc_device_handle_t *devh, int8_t* roll_rel, uint8_t* speed, enum uvc_req_code req_code) {
+  uint8_t data[2];
+  uvc_error_t ret;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_GET, req_code,
+    UVC_CT_ROLL_RELATIVE_CONTROL << 8,
+    uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data)) {
+    *roll_rel = data[0];
+    *speed = data[1];
+    return UVC_SUCCESS;
+  } else {
+    return ret;
+  }
+}
+
+
+/** @ingroup ctrl
+ * @brief Sets the ROLL_RELATIVE control.
+ * @param devh UVC device handle
+ * @param roll_rel TODO
+ * @param speed TODO
+ */
+uvc_error_t uvc_set_roll_rel(uvc_device_handle_t *devh, int8_t roll_rel, uint8_t speed) {
+  uint8_t data[2];
+  uvc_error_t ret;
+
+  data[0] = roll_rel;
+  data[1] = speed;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_SET, UVC_SET_CUR,
+    UVC_CT_ROLL_RELATIVE_CONTROL << 8,
+    uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data))
+    return UVC_SUCCESS;
+  else
+    return ret;
+}
+
+/** @ingroup ctrl
+ * @brief Reads the PRIVACY control.
+ * @param devh UVC device handle
+ * @param[out] privacy TODO
+ * @param req_code UVC_GET_* request to execute
+ */
+uvc_error_t uvc_get_privacy(uvc_device_handle_t *devh, uint8_t* privacy, enum uvc_req_code req_code) {
+  uint8_t data[1];
+  uvc_error_t ret;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_GET, req_code,
+    UVC_CT_PRIVACY_CONTROL << 8,
+    uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data)) {
+    *privacy = data[0];
+    return UVC_SUCCESS;
+  } else {
+    return ret;
+  }
+}
+
+
+/** @ingroup ctrl
+ * @brief Sets the PRIVACY control.
+ * @param devh UVC device handle
+ * @param privacy TODO
+ */
+uvc_error_t uvc_set_privacy(uvc_device_handle_t *devh, uint8_t privacy) {
+  uint8_t data[1];
+  uvc_error_t ret;
+
+  data[0] = privacy;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_SET, UVC_SET_CUR,
+    UVC_CT_PRIVACY_CONTROL << 8,
+    uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data))
+    return UVC_SUCCESS;
+  else
+    return ret;
+}
+
+/** @ingroup ctrl
+ * @brief Reads the DIGITAL_WINDOW control.
+ * @param devh UVC device handle
+ * @param[out] window_top TODO
+ * @param[out] window_left TODO
+ * @param[out] window_bottom TODO
+ * @param[out] window_right TODO
+ * @param[out] num_steps TODO
+ * @param[out] num_steps_units TODO
+ * @param req_code UVC_GET_* request to execute
+ */
+uvc_error_t uvc_get_digital_window(uvc_device_handle_t *devh, uint16_t* window_top, uint16_t* window_left, uint16_t* window_bottom, uint16_t* window_right, uint16_t* num_steps, uint16_t* num_steps_units, enum uvc_req_code req_code) {
+  uint8_t data[12];
+  uvc_error_t ret;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_GET, req_code,
+    UVC_CT_DIGITAL_WINDOW_CONTROL << 8,
+    uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data)) {
+    *window_top = SW_TO_SHORT(data + 0);
+    *window_left = SW_TO_SHORT(data + 2);
+    *window_bottom = SW_TO_SHORT(data + 4);
+    *window_right = SW_TO_SHORT(data + 6);
+    *num_steps = SW_TO_SHORT(data + 8);
+    *num_steps_units = SW_TO_SHORT(data + 10);
+    return UVC_SUCCESS;
+  } else {
+    return ret;
+  }
+}
+
+
+/** @ingroup ctrl
+ * @brief Sets the DIGITAL_WINDOW control.
+ * @param devh UVC device handle
+ * @param window_top TODO
+ * @param window_left TODO
+ * @param window_bottom TODO
+ * @param window_right TODO
+ * @param num_steps TODO
+ * @param num_steps_units TODO
+ */
+uvc_error_t uvc_set_digital_window(uvc_device_handle_t *devh, uint16_t window_top, uint16_t window_left, uint16_t window_bottom, uint16_t window_right, uint16_t num_steps, uint16_t num_steps_units) {
+  uint8_t data[12];
+  uvc_error_t ret;
+
+  SHORT_TO_SW(window_top, data + 0);
+  SHORT_TO_SW(window_left, data + 2);
+  SHORT_TO_SW(window_bottom, data + 4);
+  SHORT_TO_SW(window_right, data + 6);
+  SHORT_TO_SW(num_steps, data + 8);
+  SHORT_TO_SW(num_steps_units, data + 10);
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_SET, UVC_SET_CUR,
+    UVC_CT_DIGITAL_WINDOW_CONTROL << 8,
+    uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data))
+    return UVC_SUCCESS;
+  else
+    return ret;
+}
+
+/** @ingroup ctrl
+ * @brief Reads the REGION_OF_INTEREST control.
+ * @param devh UVC device handle
+ * @param[out] roi_top TODO
+ * @param[out] roi_left TODO
+ * @param[out] roi_bottom TODO
+ * @param[out] roi_right TODO
+ * @param[out] auto_controls TODO
+ * @param req_code UVC_GET_* request to execute
+ */
+uvc_error_t uvc_get_digital_roi(uvc_device_handle_t *devh, uint16_t* roi_top, uint16_t* roi_left, uint16_t* roi_bottom, uint16_t* roi_right, uint16_t* auto_controls, enum uvc_req_code req_code) {
+  uint8_t data[10];
+  uvc_error_t ret;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_GET, req_code,
+    UVC_CT_REGION_OF_INTEREST_CONTROL << 8,
+    uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data)) {
+    *roi_top = SW_TO_SHORT(data + 0);
+    *roi_left = SW_TO_SHORT(data + 2);
+    *roi_bottom = SW_TO_SHORT(data + 4);
+    *roi_right = SW_TO_SHORT(data + 6);
+    *auto_controls = SW_TO_SHORT(data + 8);
+    return UVC_SUCCESS;
+  } else {
+    return ret;
+  }
+}
+
+
+/** @ingroup ctrl
+ * @brief Sets the REGION_OF_INTEREST control.
+ * @param devh UVC device handle
+ * @param roi_top TODO
+ * @param roi_left TODO
+ * @param roi_bottom TODO
+ * @param roi_right TODO
+ * @param auto_controls TODO
+ */
+uvc_error_t uvc_set_digital_roi(uvc_device_handle_t *devh, uint16_t roi_top, uint16_t roi_left, uint16_t roi_bottom, uint16_t roi_right, uint16_t auto_controls) {
+  uint8_t data[10];
+  uvc_error_t ret;
+
+  SHORT_TO_SW(roi_top, data + 0);
+  SHORT_TO_SW(roi_left, data + 2);
+  SHORT_TO_SW(roi_bottom, data + 4);
+  SHORT_TO_SW(roi_right, data + 6);
+  SHORT_TO_SW(auto_controls, data + 8);
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_SET, UVC_SET_CUR,
+    UVC_CT_REGION_OF_INTEREST_CONTROL << 8,
+    uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data))
+    return UVC_SUCCESS;
+  else
+    return ret;
+}
+
+/** @ingroup ctrl
+ * @brief Reads the BACKLIGHT_COMPENSATION control.
+ * @param devh UVC device handle
+ * @param[out] backlight_compensation device-dependent backlight compensation mode; zero means backlight compensation is disabled
+ * @param req_code UVC_GET_* request to execute
+ */
+uvc_error_t uvc_get_backlight_compensation(uvc_device_handle_t *devh, uint16_t* backlight_compensation, enum uvc_req_code req_code) {
+  uint8_t data[2];
+  uvc_error_t ret;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_GET, req_code,
+    UVC_PU_BACKLIGHT_COMPENSATION_CONTROL << 8,
+    uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data)) {
+    *backlight_compensation = SW_TO_SHORT(data + 0);
+    return UVC_SUCCESS;
+  } else {
+    return ret;
+  }
+}
+
+
+/** @ingroup ctrl
+ * @brief Sets the BACKLIGHT_COMPENSATION control.
+ * @param devh UVC device handle
+ * @param backlight_compensation device-dependent backlight compensation mode; zero means backlight compensation is disabled
+ */
+uvc_error_t uvc_set_backlight_compensation(uvc_device_handle_t *devh, uint16_t backlight_compensation) {
+  uint8_t data[2];
+  uvc_error_t ret;
+
+  SHORT_TO_SW(backlight_compensation, data + 0);
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_SET, UVC_SET_CUR,
+    UVC_PU_BACKLIGHT_COMPENSATION_CONTROL << 8,
+    uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data))
+    return UVC_SUCCESS;
+  else
+    return ret;
+}
+
+/** @ingroup ctrl
+ * @brief Reads the BRIGHTNESS control.
+ * @param devh UVC device handle
+ * @param[out] brightness TODO
+ * @param req_code UVC_GET_* request to execute
+ */
+uvc_error_t uvc_get_brightness(uvc_device_handle_t *devh, int16_t* brightness, enum uvc_req_code req_code) {
+  uint8_t data[2];
+  uvc_error_t ret;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_GET, req_code,
+    UVC_PU_BRIGHTNESS_CONTROL << 8,
+    uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data)) {
+    *brightness = SW_TO_SHORT(data + 0);
+    return UVC_SUCCESS;
+  } else {
+    return ret;
+  }
+}
+
+
+/** @ingroup ctrl
+ * @brief Sets the BRIGHTNESS control.
+ * @param devh UVC device handle
+ * @param brightness TODO
+ */
+uvc_error_t uvc_set_brightness(uvc_device_handle_t *devh, int16_t brightness) {
+  uint8_t data[2];
+  uvc_error_t ret;
+
+  SHORT_TO_SW(brightness, data + 0);
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_SET, UVC_SET_CUR,
+    UVC_PU_BRIGHTNESS_CONTROL << 8,
+    uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data))
+    return UVC_SUCCESS;
+  else
+    return ret;
+}
+
+/** @ingroup ctrl
+ * @brief Reads the CONTRAST control.
+ * @param devh UVC device handle
+ * @param[out] contrast TODO
+ * @param req_code UVC_GET_* request to execute
+ */
+uvc_error_t uvc_get_contrast(uvc_device_handle_t *devh, uint16_t* contrast, enum uvc_req_code req_code) {
+  uint8_t data[2];
+  uvc_error_t ret;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_GET, req_code,
+    UVC_PU_CONTRAST_CONTROL << 8,
+    uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data)) {
+    *contrast = SW_TO_SHORT(data + 0);
+    return UVC_SUCCESS;
+  } else {
+    return ret;
+  }
+}
+
+
+/** @ingroup ctrl
+ * @brief Sets the CONTRAST control.
+ * @param devh UVC device handle
+ * @param contrast TODO
+ */
+uvc_error_t uvc_set_contrast(uvc_device_handle_t *devh, uint16_t contrast) {
+  uint8_t data[2];
+  uvc_error_t ret;
+
+  SHORT_TO_SW(contrast, data + 0);
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_SET, UVC_SET_CUR,
+    UVC_PU_CONTRAST_CONTROL << 8,
+    uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data))
+    return UVC_SUCCESS;
+  else
+    return ret;
+}
+
+/** @ingroup ctrl
+ * @brief Reads the CONTRAST_AUTO control.
+ * @param devh UVC device handle
+ * @param[out] contrast_auto TODO
+ * @param req_code UVC_GET_* request to execute
+ */
+uvc_error_t uvc_get_contrast_auto(uvc_device_handle_t *devh, uint8_t* contrast_auto, enum uvc_req_code req_code) {
+  uint8_t data[1];
+  uvc_error_t ret;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_GET, req_code,
+    UVC_PU_CONTRAST_AUTO_CONTROL << 8,
+    uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data)) {
+    *contrast_auto = data[0];
+    return UVC_SUCCESS;
+  } else {
+    return ret;
+  }
+}
+
+
+/** @ingroup ctrl
+ * @brief Sets the CONTRAST_AUTO control.
+ * @param devh UVC device handle
+ * @param contrast_auto TODO
+ */
+uvc_error_t uvc_set_contrast_auto(uvc_device_handle_t *devh, uint8_t contrast_auto) {
+  uint8_t data[1];
+  uvc_error_t ret;
+
+  data[0] = contrast_auto;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_SET, UVC_SET_CUR,
+    UVC_PU_CONTRAST_AUTO_CONTROL << 8,
+    uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data))
+    return UVC_SUCCESS;
+  else
+    return ret;
+}
+
+/** @ingroup ctrl
+ * @brief Reads the GAIN control.
+ * @param devh UVC device handle
+ * @param[out] gain TODO
+ * @param req_code UVC_GET_* request to execute
+ */
+uvc_error_t uvc_get_gain(uvc_device_handle_t *devh, uint16_t* gain, enum uvc_req_code req_code) {
+  uint8_t data[2];
+  uvc_error_t ret;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_GET, req_code,
+    UVC_PU_GAIN_CONTROL << 8,
+    uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data)) {
+    *gain = SW_TO_SHORT(data + 0);
+    return UVC_SUCCESS;
+  } else {
+    return ret;
+  }
+}
+
+
+/** @ingroup ctrl
+ * @brief Sets the GAIN control.
+ * @param devh UVC device handle
+ * @param gain TODO
+ */
+uvc_error_t uvc_set_gain(uvc_device_handle_t *devh, uint16_t gain) {
+  uint8_t data[2];
+  uvc_error_t ret;
+
+  SHORT_TO_SW(gain, data + 0);
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_SET, UVC_SET_CUR,
+    UVC_PU_GAIN_CONTROL << 8,
+    uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data))
+    return UVC_SUCCESS;
+  else
+    return ret;
+}
+
+/** @ingroup ctrl
+ * @brief Reads the POWER_LINE_FREQUENCY control.
+ * @param devh UVC device handle
+ * @param[out] power_line_frequency TODO
+ * @param req_code UVC_GET_* request to execute
+ */
+uvc_error_t uvc_get_power_line_frequency(uvc_device_handle_t *devh, uint8_t* power_line_frequency, enum uvc_req_code req_code) {
+  uint8_t data[1];
+  uvc_error_t ret;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_GET, req_code,
+    UVC_PU_POWER_LINE_FREQUENCY_CONTROL << 8,
+    uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data)) {
+    *power_line_frequency = data[0];
+    return UVC_SUCCESS;
+  } else {
+    return ret;
+  }
+}
+
+
+/** @ingroup ctrl
+ * @brief Sets the POWER_LINE_FREQUENCY control.
+ * @param devh UVC device handle
+ * @param power_line_frequency TODO
+ */
+uvc_error_t uvc_set_power_line_frequency(uvc_device_handle_t *devh, uint8_t power_line_frequency) {
+  uint8_t data[1];
+  uvc_error_t ret;
+
+  data[0] = power_line_frequency;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_SET, UVC_SET_CUR,
+    UVC_PU_POWER_LINE_FREQUENCY_CONTROL << 8,
+    uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data))
+    return UVC_SUCCESS;
+  else
+    return ret;
+}
+
+/** @ingroup ctrl
+ * @brief Reads the HUE control.
+ * @param devh UVC device handle
+ * @param[out] hue TODO
+ * @param req_code UVC_GET_* request to execute
+ */
+uvc_error_t uvc_get_hue(uvc_device_handle_t *devh, int16_t* hue, enum uvc_req_code req_code) {
+  uint8_t data[2];
+  uvc_error_t ret;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_GET, req_code,
+    UVC_PU_HUE_CONTROL << 8,
+    uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data)) {
+    *hue = SW_TO_SHORT(data + 0);
+    return UVC_SUCCESS;
+  } else {
+    return ret;
+  }
+}
+
+
+/** @ingroup ctrl
+ * @brief Sets the HUE control.
+ * @param devh UVC device handle
+ * @param hue TODO
+ */
+uvc_error_t uvc_set_hue(uvc_device_handle_t *devh, int16_t hue) {
+  uint8_t data[2];
+  uvc_error_t ret;
+
+  SHORT_TO_SW(hue, data + 0);
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_SET, UVC_SET_CUR,
+    UVC_PU_HUE_CONTROL << 8,
+    uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data))
+    return UVC_SUCCESS;
+  else
+    return ret;
+}
+
+/** @ingroup ctrl
+ * @brief Reads the HUE_AUTO control.
+ * @param devh UVC device handle
+ * @param[out] hue_auto TODO
+ * @param req_code UVC_GET_* request to execute
+ */
+uvc_error_t uvc_get_hue_auto(uvc_device_handle_t *devh, uint8_t* hue_auto, enum uvc_req_code req_code) {
+  uint8_t data[1];
+  uvc_error_t ret;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_GET, req_code,
+    UVC_PU_HUE_AUTO_CONTROL << 8,
+    uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data)) {
+    *hue_auto = data[0];
+    return UVC_SUCCESS;
+  } else {
+    return ret;
+  }
+}
+
+
+/** @ingroup ctrl
+ * @brief Sets the HUE_AUTO control.
+ * @param devh UVC device handle
+ * @param hue_auto TODO
+ */
+uvc_error_t uvc_set_hue_auto(uvc_device_handle_t *devh, uint8_t hue_auto) {
+  uint8_t data[1];
+  uvc_error_t ret;
+
+  data[0] = hue_auto;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_SET, UVC_SET_CUR,
+    UVC_PU_HUE_AUTO_CONTROL << 8,
+    uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data))
+    return UVC_SUCCESS;
+  else
+    return ret;
+}
+
+/** @ingroup ctrl
+ * @brief Reads the SATURATION control.
+ * @param devh UVC device handle
+ * @param[out] saturation TODO
+ * @param req_code UVC_GET_* request to execute
+ */
+uvc_error_t uvc_get_saturation(uvc_device_handle_t *devh, uint16_t* saturation, enum uvc_req_code req_code) {
+  uint8_t data[2];
+  uvc_error_t ret;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_GET, req_code,
+    UVC_PU_SATURATION_CONTROL << 8,
+    uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data)) {
+    *saturation = SW_TO_SHORT(data + 0);
+    return UVC_SUCCESS;
+  } else {
+    return ret;
+  }
+}
+
+
+/** @ingroup ctrl
+ * @brief Sets the SATURATION control.
+ * @param devh UVC device handle
+ * @param saturation TODO
+ */
+uvc_error_t uvc_set_saturation(uvc_device_handle_t *devh, uint16_t saturation) {
+  uint8_t data[2];
+  uvc_error_t ret;
+
+  SHORT_TO_SW(saturation, data + 0);
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_SET, UVC_SET_CUR,
+    UVC_PU_SATURATION_CONTROL << 8,
+    uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data))
+    return UVC_SUCCESS;
+  else
+    return ret;
+}
+
+/** @ingroup ctrl
+ * @brief Reads the SHARPNESS control.
+ * @param devh UVC device handle
+ * @param[out] sharpness TODO
+ * @param req_code UVC_GET_* request to execute
+ */
+uvc_error_t uvc_get_sharpness(uvc_device_handle_t *devh, uint16_t* sharpness, enum uvc_req_code req_code) {
+  uint8_t data[2];
+  uvc_error_t ret;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_GET, req_code,
+    UVC_PU_SHARPNESS_CONTROL << 8,
+    uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data)) {
+    *sharpness = SW_TO_SHORT(data + 0);
+    return UVC_SUCCESS;
+  } else {
+    return ret;
+  }
+}
+
+
+/** @ingroup ctrl
+ * @brief Sets the SHARPNESS control.
+ * @param devh UVC device handle
+ * @param sharpness TODO
+ */
+uvc_error_t uvc_set_sharpness(uvc_device_handle_t *devh, uint16_t sharpness) {
+  uint8_t data[2];
+  uvc_error_t ret;
+
+  SHORT_TO_SW(sharpness, data + 0);
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_SET, UVC_SET_CUR,
+    UVC_PU_SHARPNESS_CONTROL << 8,
+    uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data))
+    return UVC_SUCCESS;
+  else
+    return ret;
+}
+
+/** @ingroup ctrl
+ * @brief Reads the GAMMA control.
+ * @param devh UVC device handle
+ * @param[out] gamma TODO
+ * @param req_code UVC_GET_* request to execute
+ */
+uvc_error_t uvc_get_gamma(uvc_device_handle_t *devh, uint16_t* gamma, enum uvc_req_code req_code) {
+  uint8_t data[2];
+  uvc_error_t ret;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_GET, req_code,
+    UVC_PU_GAMMA_CONTROL << 8,
+    uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data)) {
+    *gamma = SW_TO_SHORT(data + 0);
+    return UVC_SUCCESS;
+  } else {
+    return ret;
+  }
+}
+
+
+/** @ingroup ctrl
+ * @brief Sets the GAMMA control.
+ * @param devh UVC device handle
+ * @param gamma TODO
+ */
+uvc_error_t uvc_set_gamma(uvc_device_handle_t *devh, uint16_t gamma) {
+  uint8_t data[2];
+  uvc_error_t ret;
+
+  SHORT_TO_SW(gamma, data + 0);
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_SET, UVC_SET_CUR,
+    UVC_PU_GAMMA_CONTROL << 8,
+    uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data))
+    return UVC_SUCCESS;
+  else
+    return ret;
+}
+
+/** @ingroup ctrl
+ * @brief Reads the WHITE_BALANCE_TEMPERATURE control.
+ * @param devh UVC device handle
+ * @param[out] temperature TODO
+ * @param req_code UVC_GET_* request to execute
+ */
+uvc_error_t uvc_get_white_balance_temperature(uvc_device_handle_t *devh, uint16_t* temperature, enum uvc_req_code req_code) {
+  uint8_t data[2];
+  uvc_error_t ret;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_GET, req_code,
+    UVC_PU_WHITE_BALANCE_TEMPERATURE_CONTROL << 8,
+    uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data)) {
+    *temperature = SW_TO_SHORT(data + 0);
+    return UVC_SUCCESS;
+  } else {
+    return ret;
+  }
+}
+
+
+/** @ingroup ctrl
+ * @brief Sets the WHITE_BALANCE_TEMPERATURE control.
+ * @param devh UVC device handle
+ * @param temperature TODO
+ */
+uvc_error_t uvc_set_white_balance_temperature(uvc_device_handle_t *devh, uint16_t temperature) {
+  uint8_t data[2];
+  uvc_error_t ret;
+
+  SHORT_TO_SW(temperature, data + 0);
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_SET, UVC_SET_CUR,
+    UVC_PU_WHITE_BALANCE_TEMPERATURE_CONTROL << 8,
+    uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data))
+    return UVC_SUCCESS;
+  else
+    return ret;
+}
+
+/** @ingroup ctrl
+ * @brief Reads the WHITE_BALANCE_TEMPERATURE_AUTO control.
+ * @param devh UVC device handle
+ * @param[out] temperature_auto TODO
+ * @param req_code UVC_GET_* request to execute
+ */
+uvc_error_t uvc_get_white_balance_temperature_auto(uvc_device_handle_t *devh, uint8_t* temperature_auto, enum uvc_req_code req_code) {
+  uint8_t data[1];
+  uvc_error_t ret;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_GET, req_code,
+    UVC_PU_WHITE_BALANCE_TEMPERATURE_AUTO_CONTROL << 8,
+    uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data)) {
+    *temperature_auto = data[0];
+    return UVC_SUCCESS;
+  } else {
+    return ret;
+  }
+}
+
+
+/** @ingroup ctrl
+ * @brief Sets the WHITE_BALANCE_TEMPERATURE_AUTO control.
+ * @param devh UVC device handle
+ * @param temperature_auto TODO
+ */
+uvc_error_t uvc_set_white_balance_temperature_auto(uvc_device_handle_t *devh, uint8_t temperature_auto) {
+  uint8_t data[1];
+  uvc_error_t ret;
+
+  data[0] = temperature_auto;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_SET, UVC_SET_CUR,
+    UVC_PU_WHITE_BALANCE_TEMPERATURE_AUTO_CONTROL << 8,
+    uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data))
+    return UVC_SUCCESS;
+  else
+    return ret;
+}
+
+/** @ingroup ctrl
+ * @brief Reads the WHITE_BALANCE_COMPONENT control.
+ * @param devh UVC device handle
+ * @param[out] blue TODO
+ * @param[out] red TODO
+ * @param req_code UVC_GET_* request to execute
+ */
+uvc_error_t uvc_get_white_balance_component(uvc_device_handle_t *devh, uint16_t* blue, uint16_t* red, enum uvc_req_code req_code) {
+  uint8_t data[4];
+  uvc_error_t ret;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_GET, req_code,
+    UVC_PU_WHITE_BALANCE_COMPONENT_CONTROL << 8,
+    uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data)) {
+    *blue = SW_TO_SHORT(data + 0);
+    *red = SW_TO_SHORT(data + 2);
+    return UVC_SUCCESS;
+  } else {
+    return ret;
+  }
+}
+
+
+/** @ingroup ctrl
+ * @brief Sets the WHITE_BALANCE_COMPONENT control.
+ * @param devh UVC device handle
+ * @param blue TODO
+ * @param red TODO
+ */
+uvc_error_t uvc_set_white_balance_component(uvc_device_handle_t *devh, uint16_t blue, uint16_t red) {
+  uint8_t data[4];
+  uvc_error_t ret;
+
+  SHORT_TO_SW(blue, data + 0);
+  SHORT_TO_SW(red, data + 2);
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_SET, UVC_SET_CUR,
+    UVC_PU_WHITE_BALANCE_COMPONENT_CONTROL << 8,
+    uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data))
+    return UVC_SUCCESS;
+  else
+    return ret;
+}
+
+/** @ingroup ctrl
+ * @brief Reads the WHITE_BALANCE_COMPONENT_AUTO control.
+ * @param devh UVC device handle
+ * @param[out] white_balance_component_auto TODO
+ * @param req_code UVC_GET_* request to execute
+ */
+uvc_error_t uvc_get_white_balance_component_auto(uvc_device_handle_t *devh, uint8_t* white_balance_component_auto, enum uvc_req_code req_code) {
+  uint8_t data[1];
+  uvc_error_t ret;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_GET, req_code,
+    UVC_PU_WHITE_BALANCE_COMPONENT_AUTO_CONTROL << 8,
+    uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data)) {
+    *white_balance_component_auto = data[0];
+    return UVC_SUCCESS;
+  } else {
+    return ret;
+  }
+}
+
+
+/** @ingroup ctrl
+ * @brief Sets the WHITE_BALANCE_COMPONENT_AUTO control.
+ * @param devh UVC device handle
+ * @param white_balance_component_auto TODO
+ */
+uvc_error_t uvc_set_white_balance_component_auto(uvc_device_handle_t *devh, uint8_t white_balance_component_auto) {
+  uint8_t data[1];
+  uvc_error_t ret;
+
+  data[0] = white_balance_component_auto;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_SET, UVC_SET_CUR,
+    UVC_PU_WHITE_BALANCE_COMPONENT_AUTO_CONTROL << 8,
+    uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data))
+    return UVC_SUCCESS;
+  else
+    return ret;
+}
+
+/** @ingroup ctrl
+ * @brief Reads the DIGITAL_MULTIPLIER control.
+ * @param devh UVC device handle
+ * @param[out] multiplier_step TODO
+ * @param req_code UVC_GET_* request to execute
+ */
+uvc_error_t uvc_get_digital_multiplier(uvc_device_handle_t *devh, uint16_t* multiplier_step, enum uvc_req_code req_code) {
+  uint8_t data[2];
+  uvc_error_t ret;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_GET, req_code,
+    UVC_PU_DIGITAL_MULTIPLIER_CONTROL << 8,
+    uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data)) {
+    *multiplier_step = SW_TO_SHORT(data + 0);
+    return UVC_SUCCESS;
+  } else {
+    return ret;
+  }
+}
+
+
+/** @ingroup ctrl
+ * @brief Sets the DIGITAL_MULTIPLIER control.
+ * @param devh UVC device handle
+ * @param multiplier_step TODO
+ */
+uvc_error_t uvc_set_digital_multiplier(uvc_device_handle_t *devh, uint16_t multiplier_step) {
+  uint8_t data[2];
+  uvc_error_t ret;
+
+  SHORT_TO_SW(multiplier_step, data + 0);
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_SET, UVC_SET_CUR,
+    UVC_PU_DIGITAL_MULTIPLIER_CONTROL << 8,
+    uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data))
+    return UVC_SUCCESS;
+  else
+    return ret;
+}
+
+/** @ingroup ctrl
+ * @brief Reads the DIGITAL_MULTIPLIER_LIMIT control.
+ * @param devh UVC device handle
+ * @param[out] multiplier_step TODO
+ * @param req_code UVC_GET_* request to execute
+ */
+uvc_error_t uvc_get_digital_multiplier_limit(uvc_device_handle_t *devh, uint16_t* multiplier_step, enum uvc_req_code req_code) {
+  uint8_t data[2];
+  uvc_error_t ret;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_GET, req_code,
+    UVC_PU_DIGITAL_MULTIPLIER_LIMIT_CONTROL << 8,
+    uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data)) {
+    *multiplier_step = SW_TO_SHORT(data + 0);
+    return UVC_SUCCESS;
+  } else {
+    return ret;
+  }
+}
+
+
+/** @ingroup ctrl
+ * @brief Sets the DIGITAL_MULTIPLIER_LIMIT control.
+ * @param devh UVC device handle
+ * @param multiplier_step TODO
+ */
+uvc_error_t uvc_set_digital_multiplier_limit(uvc_device_handle_t *devh, uint16_t multiplier_step) {
+  uint8_t data[2];
+  uvc_error_t ret;
+
+  SHORT_TO_SW(multiplier_step, data + 0);
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_SET, UVC_SET_CUR,
+    UVC_PU_DIGITAL_MULTIPLIER_LIMIT_CONTROL << 8,
+    uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data))
+    return UVC_SUCCESS;
+  else
+    return ret;
+}
+
+/** @ingroup ctrl
+ * @brief Reads the ANALOG_VIDEO_STANDARD control.
+ * @param devh UVC device handle
+ * @param[out] video_standard TODO
+ * @param req_code UVC_GET_* request to execute
+ */
+uvc_error_t uvc_get_analog_video_standard(uvc_device_handle_t *devh, uint8_t* video_standard, enum uvc_req_code req_code) {
+  uint8_t data[1];
+  uvc_error_t ret;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_GET, req_code,
+    UVC_PU_ANALOG_VIDEO_STANDARD_CONTROL << 8,
+    uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data)) {
+    *video_standard = data[0];
+    return UVC_SUCCESS;
+  } else {
+    return ret;
+  }
+}
+
+
+/** @ingroup ctrl
+ * @brief Sets the ANALOG_VIDEO_STANDARD control.
+ * @param devh UVC device handle
+ * @param video_standard TODO
+ */
+uvc_error_t uvc_set_analog_video_standard(uvc_device_handle_t *devh, uint8_t video_standard) {
+  uint8_t data[1];
+  uvc_error_t ret;
+
+  data[0] = video_standard;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_SET, UVC_SET_CUR,
+    UVC_PU_ANALOG_VIDEO_STANDARD_CONTROL << 8,
+    uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data))
+    return UVC_SUCCESS;
+  else
+    return ret;
+}
+
+/** @ingroup ctrl
+ * @brief Reads the ANALOG_LOCK_STATUS control.
+ * @param devh UVC device handle
+ * @param[out] status TODO
+ * @param req_code UVC_GET_* request to execute
+ */
+uvc_error_t uvc_get_analog_video_lock_status(uvc_device_handle_t *devh, uint8_t* status, enum uvc_req_code req_code) {
+  uint8_t data[1];
+  uvc_error_t ret;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_GET, req_code,
+    UVC_PU_ANALOG_LOCK_STATUS_CONTROL << 8,
+    uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data)) {
+    *status = data[0];
+    return UVC_SUCCESS;
+  } else {
+    return ret;
+  }
+}
+
+
+/** @ingroup ctrl
+ * @brief Sets the ANALOG_LOCK_STATUS control.
+ * @param devh UVC device handle
+ * @param status TODO
+ */
+uvc_error_t uvc_set_analog_video_lock_status(uvc_device_handle_t *devh, uint8_t status) {
+  uint8_t data[1];
+  uvc_error_t ret;
+
+  data[0] = status;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_SET, UVC_SET_CUR,
+    UVC_PU_ANALOG_LOCK_STATUS_CONTROL << 8,
+    uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data))
+    return UVC_SUCCESS;
+  else
+    return ret;
+}
+
+/** @ingroup ctrl
+ * @brief Reads the INPUT_SELECT control.
+ * @param devh UVC device handle
+ * @param[out] selector TODO
+ * @param req_code UVC_GET_* request to execute
+ */
+uvc_error_t uvc_get_input_select(uvc_device_handle_t *devh, uint8_t* selector, enum uvc_req_code req_code) {
+  uint8_t data[1];
+  uvc_error_t ret;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_GET, req_code,
+    UVC_SU_INPUT_SELECT_CONTROL << 8,
+    uvc_get_selector_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data)) {
+    *selector = data[0];
+    return UVC_SUCCESS;
+  } else {
+    return ret;
+  }
+}
+
+
+/** @ingroup ctrl
+ * @brief Sets the INPUT_SELECT control.
+ * @param devh UVC device handle
+ * @param selector TODO
+ */
+uvc_error_t uvc_set_input_select(uvc_device_handle_t *devh, uint8_t selector) {
+  uint8_t data[1];
+  uvc_error_t ret;
+
+  data[0] = selector;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_SET, UVC_SET_CUR,
+    UVC_SU_INPUT_SELECT_CONTROL << 8,
+    uvc_get_selector_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data))
+    return UVC_SUCCESS;
+  else
+    return ret;
+}
+
diff --git a/3rdparty/libuvc/src/src/ctrl-gen.py b/3rdparty/libuvc/src/src/ctrl-gen.py
new file mode 100644
index 00000000..d349a73c
--- /dev/null
+++ b/3rdparty/libuvc/src/src/ctrl-gen.py
@@ -0,0 +1,302 @@
+#!/usr/bin/env python
+from __future__ import print_function
+from collections import OrderedDict
+import getopt
+import sys
+import yaml
+
+class quoted(str): pass
+
+def quoted_presenter(dumper, data):
+    return dumper.represent_scalar('tag:yaml.org,2002:str', data, style='"')
+yaml.add_representer(quoted, quoted_presenter)
+
+class literal(str): pass
+
+def literal_presenter(dumper, data):
+    return dumper.represent_scalar('tag:yaml.org,2002:str', data, style='|')
+yaml.add_representer(literal, literal_presenter)
+
+def ordered_dict_presenter(dumper, data):
+    return dumper.represent_dict(data.items())
+yaml.add_representer(OrderedDict, ordered_dict_presenter)
+
+def dict_constructor(loader, node):
+    return OrderedDict(loader.construct_pairs(node))
+_mapping_tag = yaml.resolver.BaseResolver.DEFAULT_MAPPING_TAG
+yaml.add_constructor(_mapping_tag, dict_constructor)
+
+class IntField(object):
+    def __init__(self, name, position, length, signed):
+        self.name = name
+        self.position = position
+        self.length = length
+        self.signed = signed
+
+        if not self.length in [1, 2, 4]:
+            raise Exception("bad length " + str(self.length))
+
+        self.user_type = ('u' if not signed else '') + 'int' + str(length * 8) + '_t'
+
+    def getter_sig(self):
+        return "{0}* {1}".format(self.user_type, self.name)
+
+    def unpack(self):
+        if self.length == 1:
+            return "*{0} = data[{1}];".format(self.name, self.position)
+        elif self.length == 2:
+            return "*{0} = SW_TO_SHORT(data + {1});".format(self.name, self.position)
+        elif self.length == 4:
+            return "*{0} = DW_TO_INT(data + {1});".format(self.name, self.position)
+
+    def setter_sig(self):
+        return "{0} {1}".format(self.user_type, self.name)
+
+    def pack(self):
+        if self.length == 1:
+            return "data[{0}] = {1};".format(self.position, self.name)
+        elif self.length == 2:
+            return "SHORT_TO_SW({0}, data + {1});".format(self.name, self.position)
+        elif self.length == 4:
+            return "INT_TO_DW({0}, data + {1});".format(self.name, self.position)
+
+    def spec(self):
+        rep = [('position', self.position), ('length', self.length)]
+        if self.signed:
+            rep.append(('signed', True))
+        return rep
+
+    @staticmethod
+    def load(spec):
+        return IntField(spec['name'], spec['position'], spec['length'], spec['signed'] if signed in spec else False)
+
+def load_field(name, spec):
+    if spec['type'] == 'int':
+        return IntField(name, spec['position'], spec['length'], spec.get('signed', False))
+    else:
+        raise Exception("unknown field type '{0}'".format(spec['type']))
+
+GETTER_TEMPLATE = """/** @ingroup ctrl
+ * {gen_doc}
+ * @param devh UVC device handle
+ * {args_doc}
+ * @param req_code UVC_GET_* request to execute
+ */
+uvc_error_t uvc_get_{control_name}(uvc_device_handle_t *devh, {args_signature}, enum uvc_req_code req_code) {{
+  uint8_t data[{control_length}];
+  uvc_error_t ret;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_GET, req_code,
+    {control_code} << 8,
+    {unit_fn} << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data)) {{
+    {unpack}
+    return UVC_SUCCESS;
+  }} else {{
+    return ret;
+  }}
+}}
+"""
+
+SETTER_TEMPLATE = """/** @ingroup ctrl
+ * {gen_doc}
+ * @param devh UVC device handle
+ * {args_doc}
+ */
+uvc_error_t uvc_set_{control_name}(uvc_device_handle_t *devh, {args_signature}) {{
+  uint8_t data[{control_length}];
+  uvc_error_t ret;
+
+  {pack}
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_SET, UVC_SET_CUR,
+    {control_code} << 8,
+    {unit_fn} << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data))
+    return UVC_SUCCESS;
+  else
+    return ret;
+}}
+"""
+
+def gen_decl(unit_name, unit, control_name, control):
+    fields = [(load_field(field_name, field_details), field_details['doc']) for field_name, field_details in control['fields'].items()] if 'fields' in control else []
+
+    get_args_signature = ', '.join([field.getter_sig() for (field, desc) in fields])
+    set_args_signature = ', '.join([field.setter_sig() for (field, desc) in fields])
+
+    return "uvc_error_t uvc_get_{function_name}(uvc_device_handle_t *devh, {args_signature}, enum uvc_req_code req_code);\n".format(**{
+        "function_name": control_name,
+        "args_signature": get_args_signature
+    }) + "uvc_error_t uvc_set_{function_name}(uvc_device_handle_t *devh, {args_signature});\n".format(**{
+        "function_name": control_name,
+        "args_signature": set_args_signature
+    })
+
+def gen_ctrl(unit_name, unit, control_name, control):
+    fields = [(load_field(field_name, field_details), field_details['doc']) for field_name, field_details in control['fields'].items()] if 'fields' in control else []
+
+    get_args_signature = ', '.join([field.getter_sig() for (field, desc) in fields])
+    set_args_signature = ', '.join([field.setter_sig() for (field, desc) in fields])
+    unpack = "\n    ".join([field.unpack() for (field, desc) in fields])
+    pack = "\n  ".join([field.pack() for (field, desc) in fields])
+
+    get_gen_doc_raw = None
+    set_gen_doc_raw = None
+
+    if 'doc' in control:
+        doc = control['doc']
+
+        if isinstance(doc, str):
+            get_gen_doc_raw = "\n * ".join(doc.splitlines())
+            set_gen_doc_raw = get_gen_doc_raw
+        else:
+            if 'get' in doc:
+                get_gen_doc_raw = "\n * ".join(doc['get'].splitlines())
+            if 'set' in doc:
+                set_gen_doc_raw = "\n * ".join(doc['set'].splitlines())
+
+    if get_gen_doc_raw is not None:
+        get_gen_doc = get_gen_doc_raw.format(gets_sets='Reads')
+    else:
+        get_gen_doc = '@brief Reads the ' + control['control'] + ' control.'
+
+    if set_gen_doc_raw is not None:
+        set_gen_doc = set_gen_doc_raw.format(gets_sets='Sets')
+    else:
+        set_gen_doc = '@brief Sets the ' + control['control'] + ' control.'
+
+    get_args_doc = "\n * ".join(["@param[out] {0} {1}".format(field.name, desc) for (field, desc) in fields])
+    set_args_doc = "\n * ".join(["@param {0} {1}".format(field.name, desc) for (field, desc) in fields])
+
+    control_code = 'UVC_' + unit['control_prefix'] + '_' + control['control'] + '_CONTROL'
+
+    unit_fn = "uvc_get_camera_terminal(devh)->bTerminalID" if (unit_name == "camera_terminal") else ("uvc_get_" + unit_name + "s(devh)->bUnitID")
+
+    return GETTER_TEMPLATE.format(
+        unit=unit,
+        unit_fn=unit_fn,
+        control_name=control_name,
+        control_code=control_code,
+        control_length=control['length'],
+        args_signature=get_args_signature,
+        args_doc=get_args_doc,
+        gen_doc=get_gen_doc,
+        unpack=unpack) + "\n\n" + SETTER_TEMPLATE.format(
+            unit=unit,
+            unit_fn=unit_fn,
+            control_name=control_name,
+            control_code=control_code,
+            control_length=control['length'],
+            args_signature=set_args_signature,
+            args_doc=set_args_doc,
+            gen_doc=set_gen_doc,
+            pack=pack
+        )
+
+def export_unit(unit):
+    def fmt_doc(doc):
+        def wrap_doc_entry(entry):
+            if "\n" in entry:
+                return literal(entry)
+            else:
+                return entry
+
+        if isinstance(doc, str):
+            return wrap_doc_entry(doc)
+        else:
+            return OrderedDict([(mode, wrap_doc_entry(text)) for mode, text in doc.items()])
+
+    def fmt_ctrl(control_name, control_details):
+        contents = OrderedDict()
+        contents['control'] = control_details['control']
+        contents['length'] = control_details['length']
+        contents['fields'] = control_details['fields']
+
+        if 'doc' in control_details:
+            contents['doc'] = fmt_doc(control_details['doc'])
+
+        return (control_name, contents)
+
+    unit_out = OrderedDict()
+    unit_out['type'] = unit['type']
+    if 'guid' in unit:
+        unit_out['guid'] = unit['guid']
+    if 'description' in unit:
+        unit_out['description'] = unit['description']
+    if 'control_prefix' in unit:
+        unit_out['control_prefix'] = unit['control_prefix']
+    unit_out['controls'] = OrderedDict([fmt_ctrl(ctrl_name, ctrl_details) for ctrl_name, ctrl_details in unit['controls'].items()])
+    return unit_out
+
+if __name__ == '__main__':
+    try:
+        opts, args = getopt.getopt(sys.argv[1:], "hi:", ["help", "input="])
+    except getopt.GetoptError as err:
+        print(str(err))
+        usage()
+        sys.exit(-1)
+
+    inputs = []
+
+    for opt, val in opts:
+        if opt in ('-h', '--help'):
+            usage()
+            sys.exit(0)
+        elif opt in ('-i', '--input'):
+            inputs.append(val)
+
+    mode = None
+    for arg in args:
+        if arg in ('def', 'decl', 'yaml'):
+            if mode is None:
+                mode = arg
+            else:
+                print("Can't specify more than one mode")
+                sys.exit(-1)
+        else:
+            print("Invalid mode '{0}'".format(arg))
+            sys.exit(-1)
+
+    def iterunits():
+        for input_file in inputs:
+            with open(input_file, "r") as fp:
+                units = yaml.load(fp)['units']
+                for unit_name, unit_details in units.iteritems():
+                    yield unit_name, unit_details
+
+    if mode == 'def':
+        print("""/* This is an AUTO-GENERATED file! Update it with the output of `ctrl-gen.py def`. */
+#include "libuvc/libuvc.h"
+#include "libuvc/libuvc_internal.h"
+
+static const int REQ_TYPE_SET = 0x21;
+static const int REQ_TYPE_GET = 0xa1;
+""")
+        fun = gen_ctrl
+    elif mode == 'decl':
+        fun = gen_decl
+    elif mode == 'yaml':
+        exported_units = OrderedDict()
+        for unit_name, unit_details in iterunits():
+            exported_units[unit_name] = export_unit(unit_details)
+
+        yaml.dump({'units': exported_units}, sys.stdout, default_flow_style=False)
+        sys.exit(0)
+
+    for unit_name, unit_details in iterunits():
+        for control_name, control_details in unit_details['controls'].iteritems():
+            code = fun(unit_name, unit_details, control_name, control_details)
+            print(code)
diff --git a/3rdparty/libuvc/src/src/ctrl.c b/3rdparty/libuvc/src/src/ctrl.c
new file mode 100644
index 00000000..3dffe790
--- /dev/null
+++ b/3rdparty/libuvc/src/src/ctrl.c
@@ -0,0 +1,165 @@
+/*********************************************************************
+* Software License Agreement (BSD License)
+*
+*  Copyright (C) 2010-2012 Ken Tossell
+*  All rights reserved.
+*
+*  Redistribution and use in source and binary forms, with or without
+*  modification, are permitted provided that the following conditions
+*  are met:
+*
+*   * Redistributions of source code must retain the above copyright
+*     notice, this list of conditions and the following disclaimer.
+*   * Redistributions in binary form must reproduce the above
+*     copyright notice, this list of conditions and the following
+*     disclaimer in the documentation and/or other materials provided
+*     with the distribution.
+*   * Neither the name of the author nor other contributors may be
+*     used to endorse or promote products derived from this software
+*     without specific prior written permission.
+*
+*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+*  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+*  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+*  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+*  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+*  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+*  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+*  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+*  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+*  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+*  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+*  POSSIBILITY OF SUCH DAMAGE.
+*********************************************************************/
+/**
+ * @defgroup ctrl Video capture and processing controls
+ * @brief Functions for manipulating device settings and stream parameters
+ *
+ * The `uvc_get_*` and `uvc_set_*` functions are used to read and write the settings associated
+ * with the device's input, processing and output units.
+ */
+
+#include "libuvc/libuvc.h"
+#include "libuvc/libuvc_internal.h"
+
+static const int REQ_TYPE_SET = 0x21;
+static const int REQ_TYPE_GET = 0xa1;
+
+/***** GENERIC CONTROLS *****/
+/**
+ * @brief Get the length of a control on a terminal or unit.
+ * 
+ * @param devh UVC device handle
+ * @param unit Unit or Terminal ID; obtain this from the uvc_extension_unit_t describing the extension unit
+ * @param ctrl Vendor-specific control number to query
+ * @return On success, the length of the control as reported by the device. Otherwise,
+ *   a uvc_error_t error describing the error encountered.
+ * @ingroup ctrl
+ */
+int uvc_get_ctrl_len(uvc_device_handle_t *devh, uint8_t unit, uint8_t ctrl) {
+  unsigned char buf[2];
+
+  int ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_GET, UVC_GET_LEN,
+    ctrl << 8,
+    unit << 8 | devh->info->ctrl_if.bInterfaceNumber,		// XXX saki
+    buf,
+    2,
+    0 /* timeout */);
+
+  if (ret < 0)
+    return ret;
+  else
+    return (unsigned short)SW_TO_SHORT(buf);
+}
+
+/**
+ * @brief Perform a GET_* request from an extension unit.
+ * 
+ * @param devh UVC device handle
+ * @param unit Unit ID; obtain this from the uvc_extension_unit_t describing the extension unit
+ * @param ctrl Control number to query
+ * @param data Data buffer to be filled by the device
+ * @param len Size of data buffer
+ * @param req_code GET_* request to execute
+ * @return On success, the number of bytes actually transferred. Otherwise,
+ *   a uvc_error_t error describing the error encountered.
+ * @ingroup ctrl
+ */
+int uvc_get_ctrl(uvc_device_handle_t *devh, uint8_t unit, uint8_t ctrl, void *data, int len, enum uvc_req_code req_code) {
+  return libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_GET, req_code,
+    ctrl << 8,
+    unit << 8 | devh->info->ctrl_if.bInterfaceNumber,		// XXX saki
+    data,
+    len,
+    0 /* timeout */);
+}
+
+/**
+ * @brief Perform a SET_CUR request to a terminal or unit.
+ * 
+ * @param devh UVC device handle
+ * @param unit Unit or Terminal ID
+ * @param ctrl Control number to set
+ * @param data Data buffer to be sent to the device
+ * @param len Size of data buffer
+ * @return On success, the number of bytes actually transferred. Otherwise,
+ *   a uvc_error_t error describing the error encountered.
+ * @ingroup ctrl
+ */
+int uvc_set_ctrl(uvc_device_handle_t *devh, uint8_t unit, uint8_t ctrl, void *data, int len) {
+  return libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_SET, UVC_SET_CUR,
+    ctrl << 8,
+    unit << 8 | devh->info->ctrl_if.bInterfaceNumber,		// XXX saki
+    data,
+    len,
+    0 /* timeout */);
+}
+
+/***** INTERFACE CONTROLS *****/
+uvc_error_t uvc_get_power_mode(uvc_device_handle_t *devh, enum uvc_device_power_mode *mode, enum uvc_req_code req_code) {
+  uint8_t mode_char;
+  uvc_error_t ret;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_GET, req_code,
+    UVC_VC_VIDEO_POWER_MODE_CONTROL << 8,
+    devh->info->ctrl_if.bInterfaceNumber,	// XXX saki
+    &mode_char,
+    sizeof(mode_char),
+    0);
+
+  if (ret == 1) {
+    *mode = mode_char;
+    return UVC_SUCCESS;
+  } else {
+    return ret;
+  }
+}
+
+uvc_error_t uvc_set_power_mode(uvc_device_handle_t *devh, enum uvc_device_power_mode mode) {
+  uint8_t mode_char = mode;
+  uvc_error_t ret;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_SET, UVC_SET_CUR,
+    UVC_VC_VIDEO_POWER_MODE_CONTROL << 8,
+    devh->info->ctrl_if.bInterfaceNumber,	// XXX saki
+    &mode_char,
+    sizeof(mode_char),
+    0);
+
+  if (ret == 1)
+    return UVC_SUCCESS;
+  else
+    return ret;
+}
+
+/** @todo Request Error Code Control (UVC 1.5, 4.2.1.2) */
diff --git a/3rdparty/libuvc/src/src/device.c b/3rdparty/libuvc/src/src/device.c
new file mode 100644
index 00000000..be1a1c05
--- /dev/null
+++ b/3rdparty/libuvc/src/src/device.c
@@ -0,0 +1,1803 @@
+/*********************************************************************
+ * Software License Agreement (BSD License)
+ *
+ *  Copyright (C) 2010-2012 Ken Tossell
+ *  All rights reserved.
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions
+ *  are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *   * Neither the name of the author nor other contributors may be
+ *     used to endorse or promote products derived from this software
+ *     without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ *  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ *  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ *  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ *  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ *  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ *  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ *  POSSIBILITY OF SUCH DAMAGE.
+ *********************************************************************/
+/**
+ * @defgroup device Device handling and enumeration
+ * @brief Support for finding, inspecting and opening UVC devices
+ */
+
+#include "libuvc/libuvc.h"
+#include "libuvc/libuvc_internal.h"
+
+int  uvc_already_open(uvc_context_t *ctx, struct libusb_device *usb_dev);
+void uvc_free_devh(uvc_device_handle_t *devh);
+
+uvc_error_t uvc_get_device_info(uvc_device_t *dev, uint16_t mi, uvc_device_info_t **info);
+void        uvc_free_device_info(uvc_device_info_t *info);
+
+uvc_error_t uvc_scan_control(uvc_device_t *dev, uint16_t mi, uvc_device_info_t *info);
+uvc_error_t uvc_parse_vc(uvc_device_t *dev, uvc_device_info_t *info, const unsigned char *block, size_t block_size);
+uvc_error_t uvc_parse_vc_selector_unit(uvc_device_t *dev, uvc_device_info_t *info, const unsigned char *block, size_t block_size);
+uvc_error_t uvc_parse_vc_extension_unit(uvc_device_t *dev, uvc_device_info_t *info, const unsigned char *block, size_t block_size);
+uvc_error_t uvc_parse_vc_header(uvc_device_t *dev, uvc_device_info_t *info, const unsigned char *block, size_t block_size);
+uvc_error_t uvc_parse_vc_input_terminal(uvc_device_t *dev, uvc_device_info_t *info, const unsigned char *block, size_t block_size);
+uvc_error_t uvc_parse_vc_processing_unit(uvc_device_t *dev, uvc_device_info_t *info, const unsigned char *block, size_t block_size);
+
+uvc_error_t uvc_scan_streaming(uvc_device_t *dev, uvc_device_info_t *info, int interface_idx);
+uvc_error_t uvc_parse_vs(uvc_device_t *dev, uvc_device_info_t *info, uvc_streaming_interface_t *stream_if, const unsigned char *block, size_t block_size);
+uvc_error_t uvc_parse_vs_format_uncompressed(uvc_streaming_interface_t *stream_if, const unsigned char *block, size_t block_size);
+uvc_error_t uvc_parse_vs_format_mjpeg(uvc_streaming_interface_t *stream_if, const unsigned char *block, size_t block_size);
+uvc_error_t uvc_parse_vs_frame_uncompressed(uvc_streaming_interface_t *stream_if, const unsigned char *block, size_t block_size);
+uvc_error_t uvc_parse_vs_frame_format(uvc_streaming_interface_t *stream_if, const unsigned char *block, size_t block_size);
+uvc_error_t uvc_parse_vs_frame_frame(uvc_streaming_interface_t *stream_if, const unsigned char *block, size_t block_size);
+uvc_error_t uvc_parse_vs_input_header(uvc_streaming_interface_t *stream_if, const unsigned char *block, size_t block_size);
+
+void LIBUSB_CALL _uvc_status_callback(struct libusb_transfer *transfer);
+
+/** @internal
+ * @brief Test whether the specified USB device has been opened as a UVC device
+ * @ingroup device
+ *
+ * @param ctx Context in which to search for the UVC device
+ * @param usb_dev USB device to find
+ * @return true if the device is open in this context
+ */
+int uvc_already_open(uvc_context_t *ctx, struct libusb_device *usb_dev) {
+    uvc_device_handle_t *devh;
+
+    DL_FOREACH(ctx->open_devices, devh) {
+        if(usb_dev == devh->dev->usb_dev)
+            return 1;
+    }
+
+    return 0;
+}
+
+/** @brief Finds a camera identified by vendor, product and/or serial number
+ * @ingroup device
+ *
+ * @param[in] ctx UVC context in which to search for the camera
+ * @param[out] dev Reference to the camera, or NULL if not found
+ * @param[in] vid Vendor ID number, optional
+ * @param[in] pid Product ID number, optional
+ * @param[in] sn Serial number or NULL
+ * @return Error finding device or UVC_SUCCESS
+ */
+uvc_error_t uvc_find_device(uvc_context_t *ctx, uvc_device_t **dev, int vid, int pid, const char *sn) {
+    uvc_error_t ret = UVC_SUCCESS;
+
+    uvc_device_t **list;
+    uvc_device_t  *test_dev;
+    int            dev_idx;
+    int            found_dev;
+
+    UVC_ENTER();
+
+    ret = uvc_get_device_list(ctx, &list);
+
+    if(ret != UVC_SUCCESS) {
+        UVC_EXIT(ret);
+        return ret;
+    }
+
+    dev_idx   = 0;
+    found_dev = 0;
+
+    while(!found_dev && (test_dev = list[dev_idx++]) != NULL) {
+        uvc_device_descriptor_t *desc;
+
+        if(uvc_get_device_descriptor(test_dev, &desc) != UVC_SUCCESS)
+            continue;
+
+        if((!vid || desc->idVendor == vid) && (!pid || desc->idProduct == pid) && (!sn || (desc->serialNumber && !strcmp(desc->serialNumber, sn))))
+            found_dev = 1;
+
+        uvc_free_device_descriptor(desc);
+    }
+
+    if(found_dev)
+        uvc_ref_device(test_dev);
+
+    uvc_free_device_list(list, 1);
+
+    if(found_dev) {
+        *dev = test_dev;
+        UVC_EXIT(UVC_SUCCESS);
+        return UVC_SUCCESS;
+    }
+    else {
+        UVC_EXIT(UVC_ERROR_NO_DEVICE);
+        return UVC_ERROR_NO_DEVICE;
+    }
+}
+
+/** @brief Finds all cameras identified by vendor, product and/or serial number
+ * @ingroup device
+ *
+ * @param[in] ctx UVC context in which to search for the camera
+ * @param[out] devs List of matching cameras
+ * @param[in] vid Vendor ID number, optional
+ * @param[in] pid Product ID number, optional
+ * @param[in] sn Serial number or NULL
+ * @return Error finding device or UVC_SUCCESS
+ */
+uvc_error_t uvc_find_devices(uvc_context_t *ctx, uvc_device_t ***devs, int vid, int pid, const char *sn) {
+    uvc_error_t ret = UVC_SUCCESS;
+
+    uvc_device_t **list;
+    uvc_device_t  *test_dev;
+    int            dev_idx;
+    int            found_dev;
+
+    uvc_device_t **list_internal;
+    int            num_uvc_devices;
+
+    UVC_ENTER();
+
+    ret = uvc_get_device_list(ctx, &list);
+
+    if(ret != UVC_SUCCESS) {
+        UVC_EXIT(ret);
+        return ret;
+    }
+
+    num_uvc_devices = 0;
+    dev_idx         = 0;
+    found_dev       = 0;
+
+    list_internal  = malloc(sizeof(*list_internal));
+    *list_internal = NULL;
+
+    while((test_dev = list[dev_idx++]) != NULL) {
+        uvc_device_descriptor_t *desc;
+
+        if(uvc_get_device_descriptor(test_dev, &desc) != UVC_SUCCESS)
+            continue;
+
+        if((!vid || desc->idVendor == vid) && (!pid || desc->idProduct == pid) && (!sn || (desc->serialNumber && !strcmp(desc->serialNumber, sn)))) {
+            found_dev = 1;
+            uvc_ref_device(test_dev);
+
+            num_uvc_devices++;
+            list_internal = realloc(list_internal, (num_uvc_devices + 1) * sizeof(*list_internal));
+
+            list_internal[num_uvc_devices - 1] = test_dev;
+            list_internal[num_uvc_devices]     = NULL;
+        }
+
+        uvc_free_device_descriptor(desc);
+    }
+
+    uvc_free_device_list(list, 1);
+
+    if(found_dev) {
+        *devs = list_internal;
+        UVC_EXIT(UVC_SUCCESS);
+        return UVC_SUCCESS;
+    }
+    else {
+        UVC_EXIT(UVC_ERROR_NO_DEVICE);
+        return UVC_ERROR_NO_DEVICE;
+    }
+}
+
+/** @brief Get the number of the bus to which the device is attached
+ * @ingroup device
+ */
+uint8_t uvc_get_bus_number(uvc_device_t *dev) {
+    return libusb_get_bus_number(dev->usb_dev);
+}
+
+/** @brief Get the number assigned to the device within its bus
+ * @ingroup device
+ */
+uint8_t uvc_get_device_address(uvc_device_t *dev) {
+    return libusb_get_device_address(dev->usb_dev);
+}
+
+/** @brief Open a UVC device
+ * @ingroup device
+ *
+ * @param dev Device to open
+ * @param[out] devh Handle on opened device
+ * @param[in] usb_devh Optional USB device handle to use or create a new one if NULL
+ * @return Error opening device or SUCCESS
+ */
+uvc_error_t uvc_open(uvc_device_t *dev, uint16_t mi, uvc_device_handle_t **devh, libusb_device_handle *usb_devh) {
+    uvc_error_t                     ret;
+    uvc_device_handle_t            *internal_devh;
+    struct libusb_device_descriptor desc;
+
+    UVC_ENTER();
+#ifndef __ANDROID__
+    ret = libusb_open(dev->usb_dev, &usb_devh);
+    UVC_DEBUG("libusb_open() = %d", ret);
+
+    if(ret != UVC_SUCCESS) {
+        UVC_EXIT(ret);
+        return ret;
+    }
+#endif
+    uvc_ref_device(dev);
+
+    internal_devh           = calloc(1, sizeof(*internal_devh));
+    internal_devh->dev      = dev;
+    internal_devh->usb_devh = usb_devh;
+
+    ret = uvc_get_device_info(dev, mi, &(internal_devh->info));
+
+    if(ret != UVC_SUCCESS)
+        goto fail;
+
+    UVC_DEBUG("claiming control interface %d", internal_devh->info->ctrl_if.bInterfaceNumber);
+    ret = uvc_claim_if(internal_devh, internal_devh->info->ctrl_if.bInterfaceNumber);
+    if(ret != UVC_SUCCESS)
+        goto fail;
+
+    libusb_get_device_descriptor(dev->usb_dev, &desc);
+    internal_devh->is_isight = (desc.idVendor == 0x05ac && desc.idProduct == 0x8501);
+
+    if(internal_devh->info->ctrl_if.bEndpointAddress) {
+        internal_devh->status_xfer = libusb_alloc_transfer(0);
+        if(!internal_devh->status_xfer) {
+            ret = UVC_ERROR_NO_MEM;
+            goto fail;
+        }
+
+        libusb_fill_interrupt_transfer(internal_devh->status_xfer, usb_devh, internal_devh->info->ctrl_if.bEndpointAddress, internal_devh->status_buf,
+                                       sizeof(internal_devh->status_buf), _uvc_status_callback, internal_devh, 0);
+        ret = libusb_submit_transfer(internal_devh->status_xfer);
+        UVC_DEBUG("libusb_submit_transfer() = %d", ret);
+
+        if(ret) {
+            fprintf(stderr, "uvc: device has a status interrupt endpoint, but unable to read from it\n");
+            goto fail;
+        }
+    }
+
+    if(dev->ctx->own_usb_ctx && dev->ctx->open_devices == NULL) {
+        /* Since this is our first device, we need to spawn the event handler thread */
+        uvc_start_handler_thread(dev->ctx);
+    }
+
+    DL_APPEND(dev->ctx->open_devices, internal_devh);
+    *devh = internal_devh;
+
+    UVC_EXIT(ret);
+
+    return ret;
+
+fail:
+    if(internal_devh->info) {
+        uvc_release_if(internal_devh, internal_devh->info->ctrl_if.bInterfaceNumber);
+    }
+    libusb_close(usb_devh);
+    uvc_unref_device(dev);
+    uvc_free_devh(internal_devh);
+
+    UVC_EXIT(ret);
+
+    return ret;
+}
+
+/**
+ * @internal
+ * @brief Parses the complete device descriptor for a device
+ * @ingroup device
+ * @note Free *info with uvc_free_device_info when you're done
+ *
+ * @param dev Device to parse descriptor for
+ * @param info Where to store a pointer to the new info struct
+ */
+uvc_error_t uvc_get_device_info(uvc_device_t *dev, uint16_t mi, uvc_device_info_t **info) {
+    uvc_error_t        ret;
+    uvc_device_info_t *internal_info;
+
+    UVC_ENTER();
+
+    internal_info = calloc(1, sizeof(*internal_info));
+    if(!internal_info) {
+        UVC_EXIT(UVC_ERROR_NO_MEM);
+        return UVC_ERROR_NO_MEM;
+    }
+
+    if(libusb_get_config_descriptor(dev->usb_dev, 0, &(internal_info->config)) != 0) {
+        free(internal_info);
+        UVC_EXIT(UVC_ERROR_IO);
+        return UVC_ERROR_IO;
+    }
+
+    ret = uvc_scan_control(dev, mi, internal_info);
+    if(ret != UVC_SUCCESS) {
+        uvc_free_device_info(internal_info);
+        UVC_EXIT(ret);
+        return ret;
+    }
+
+    *info = internal_info;
+
+    UVC_EXIT(ret);
+    return ret;
+}
+
+/**
+ * @internal
+ * @brief Frees the device descriptor for a device
+ * @ingroup device
+ *
+ * @param info Which device info block to free
+ */
+void uvc_free_device_info(uvc_device_info_t *info) {
+    uvc_input_terminal_t  *input_term, *input_term_tmp;
+    uvc_processing_unit_t *proc_unit, *proc_unit_tmp;
+    uvc_extension_unit_t  *ext_unit, *ext_unit_tmp;
+
+    uvc_streaming_interface_t *stream_if, *stream_if_tmp;
+    uvc_format_desc_t         *format, *format_tmp;
+    uvc_frame_desc_t          *frame, *frame_tmp;
+    uvc_still_frame_desc_t    *still_frame, *still_frame_tmp;
+    uvc_still_frame_res_t     *still_res, *still_res_tmp;
+
+    UVC_ENTER();
+
+    DL_FOREACH_SAFE(info->ctrl_if.input_term_descs, input_term, input_term_tmp) {
+        DL_DELETE(info->ctrl_if.input_term_descs, input_term);
+        free(input_term);
+    }
+
+    DL_FOREACH_SAFE(info->ctrl_if.processing_unit_descs, proc_unit, proc_unit_tmp) {
+        DL_DELETE(info->ctrl_if.processing_unit_descs, proc_unit);
+        free(proc_unit);
+    }
+
+    DL_FOREACH_SAFE(info->ctrl_if.extension_unit_descs, ext_unit, ext_unit_tmp) {
+        DL_DELETE(info->ctrl_if.extension_unit_descs, ext_unit);
+        free(ext_unit);
+    }
+
+    DL_FOREACH_SAFE(info->stream_ifs, stream_if, stream_if_tmp) {
+        DL_FOREACH_SAFE(stream_if->format_descs, format, format_tmp) {
+            DL_FOREACH_SAFE(format->frame_descs, frame, frame_tmp) {
+                if(frame->intervals)
+                    free(frame->intervals);
+
+                DL_DELETE(format->frame_descs, frame);
+                free(frame);
+            }
+
+            if(format->still_frame_desc) {
+                DL_FOREACH_SAFE(format->still_frame_desc, still_frame, still_frame_tmp) {
+                    DL_FOREACH_SAFE(still_frame->imageSizePatterns, still_res, still_res_tmp) {
+                        free(still_res);
+                    }
+
+                    if(still_frame->bCompression) {
+                        free(still_frame->bCompression);
+                    }
+                    free(still_frame);
+                }
+            }
+
+            DL_DELETE(stream_if->format_descs, format);
+            free(format);
+        }
+
+        DL_DELETE(info->stream_ifs, stream_if);
+        free(stream_if);
+    }
+
+    if(info->config)
+        libusb_free_config_descriptor(info->config);
+
+    free(info);
+
+    UVC_EXIT_VOID();
+}
+
+/**
+ * @brief Get a descriptor that contains the general information about
+ * a device
+ * @ingroup device
+ *
+ * Free *desc with uvc_free_device_descriptor when you're done.
+ *
+ * @param dev Device to fetch information about
+ * @param[out] desc Descriptor structure
+ * @return Error if unable to fetch information, else SUCCESS
+ */
+uvc_error_t uvc_get_device_descriptor(uvc_device_t *dev, uvc_device_descriptor_t **desc) {
+    uvc_device_descriptor_t        *desc_internal;
+    struct libusb_device_descriptor usb_desc;
+    struct libusb_device_handle    *usb_devh;
+    uvc_error_t                     ret;
+
+    UVC_ENTER();
+
+    ret = libusb_get_device_descriptor(dev->usb_dev, &usb_desc);
+
+    if(ret != UVC_SUCCESS) {
+        UVC_EXIT(ret);
+        return ret;
+    }
+
+    desc_internal            = calloc(1, sizeof(*desc_internal));
+    desc_internal->idVendor  = usb_desc.idVendor;
+    desc_internal->idProduct = usb_desc.idProduct;
+
+    if(libusb_open(dev->usb_dev, &usb_devh) == 0) {
+        unsigned char buf[64];
+
+        int bytes = libusb_get_string_descriptor_ascii(usb_devh, usb_desc.iSerialNumber, buf, sizeof(buf));
+
+        if(bytes > 0)
+            desc_internal->serialNumber = strdup((const char *)buf);
+
+        bytes = libusb_get_string_descriptor_ascii(usb_devh, usb_desc.iManufacturer, buf, sizeof(buf));
+
+        if(bytes > 0)
+            desc_internal->manufacturer = strdup((const char *)buf);
+
+        bytes = libusb_get_string_descriptor_ascii(usb_devh, usb_desc.iProduct, buf, sizeof(buf));
+
+        if(bytes > 0)
+            desc_internal->product = strdup((const char *)buf);
+
+        libusb_close(usb_devh);
+    }
+    else {
+        UVC_DEBUG("can't open device %04x:%04x, not fetching serial etc.", usb_desc.idVendor, usb_desc.idProduct);
+    }
+
+    *desc = desc_internal;
+
+    UVC_EXIT(ret);
+    return ret;
+}
+
+/**
+ * @brief Frees a device descriptor created with uvc_get_device_descriptor
+ * @ingroup device
+ *
+ * @param desc Descriptor to free
+ */
+void uvc_free_device_descriptor(uvc_device_descriptor_t *desc) {
+    UVC_ENTER();
+
+    if(desc->serialNumber)
+        free((void *)desc->serialNumber);
+
+    if(desc->manufacturer)
+        free((void *)desc->manufacturer);
+
+    if(desc->product)
+        free((void *)desc->product);
+
+    free(desc);
+
+    UVC_EXIT_VOID();
+}
+
+/**
+ * @brief Get a list of the UVC devices attached to the system
+ * @ingroup device
+ *
+ * @note Free the list with uvc_free_device_list when you're done.
+ *
+ * @param ctx UVC context in which to list devices
+ * @param list List of uvc_device structures
+ * @return Error if unable to list devices, else SUCCESS
+ */
+uvc_error_t uvc_get_device_list(uvc_context_t *ctx, uvc_device_t ***list) {
+    struct libusb_device **usb_dev_list;
+    struct libusb_device  *usb_dev;
+    int                    num_usb_devices;
+
+    uvc_device_t **list_internal;
+    int            num_uvc_devices;
+
+    /* per device */
+    int                              dev_idx;
+    struct libusb_config_descriptor *config;
+    struct libusb_device_descriptor  desc;
+    uint8_t                          got_interface;
+
+    /* per interface */
+    int                            interface_idx;
+    const struct libusb_interface *interface;
+
+    /* per altsetting */
+    int                                       altsetting_idx;
+    const struct libusb_interface_descriptor *if_desc;
+
+    UVC_ENTER();
+
+    num_usb_devices = libusb_get_device_list(ctx->usb_ctx, &usb_dev_list);
+
+    if(num_usb_devices < 0) {
+        UVC_EXIT(UVC_ERROR_IO);
+        return UVC_ERROR_IO;
+    }
+
+    list_internal  = malloc(sizeof(*list_internal));
+    *list_internal = NULL;
+
+    num_uvc_devices = 0;
+    dev_idx         = -1;
+
+    while((usb_dev = usb_dev_list[++dev_idx]) != NULL) {
+        got_interface = 0;
+
+        if(libusb_get_config_descriptor(usb_dev, 0, &config) != 0)
+            continue;
+
+        if(libusb_get_device_descriptor(usb_dev, &desc) != LIBUSB_SUCCESS)
+            continue;
+
+        for(interface_idx = 0; !got_interface && interface_idx < config->bNumInterfaces; ++interface_idx) {
+            interface = &config->interface[interface_idx];
+
+            for(altsetting_idx = 0; !got_interface && altsetting_idx < interface->num_altsetting; ++altsetting_idx) {
+                if_desc = &interface->altsetting[altsetting_idx];
+
+                // Skip TIS cameras that definitely aren't UVC even though they might
+                // look that way
+
+                if(0x199e == desc.idVendor && desc.idProduct >= 0x8201 && desc.idProduct <= 0x8208) {
+                    continue;
+                }
+
+                // Special case for Imaging Source cameras
+                /* Video, Streaming */
+                if(0x199e == desc.idVendor && (0x8101 == desc.idProduct || 0x8102 == desc.idProduct) && if_desc->bInterfaceClass == 255
+                   && if_desc->bInterfaceSubClass == 2) {
+                    got_interface = 1;
+                }
+
+                /* Video, Streaming */
+                if(if_desc->bInterfaceClass == 14 && if_desc->bInterfaceSubClass == 2) {
+                    got_interface = 1;
+                }
+            }
+        }
+
+        libusb_free_config_descriptor(config);
+
+        if(got_interface) {
+            uvc_device_t *uvc_dev = malloc(sizeof(*uvc_dev));
+            uvc_dev->ctx          = ctx;
+            uvc_dev->ref          = 0;
+            uvc_dev->usb_dev      = usb_dev;
+            uvc_ref_device(uvc_dev);
+
+            num_uvc_devices++;
+            list_internal = realloc(list_internal, (num_uvc_devices + 1) * sizeof(*list_internal));
+
+            list_internal[num_uvc_devices - 1] = uvc_dev;
+            list_internal[num_uvc_devices]     = NULL;
+
+            UVC_DEBUG("    UVC: %d", dev_idx);
+        }
+        else {
+            UVC_DEBUG("non-UVC: %d", dev_idx);
+        }
+    }
+
+    libusb_free_device_list(usb_dev_list, 1);
+
+    *list = list_internal;
+
+    UVC_EXIT(UVC_SUCCESS);
+    return UVC_SUCCESS;
+}
+
+/**
+ * @brief Frees a list of device structures created with uvc_get_device_list.
+ * @ingroup device
+ *
+ * @param list Device list to free
+ * @param unref_devices Decrement the reference counter for each device
+ * in the list, and destroy any entries that end up with zero references
+ */
+void uvc_free_device_list(uvc_device_t **list, uint8_t unref_devices) {
+    uvc_device_t *dev;
+    int           dev_idx = 0;
+
+    UVC_ENTER();
+
+    if(unref_devices) {
+        while((dev = list[dev_idx++]) != NULL) {
+            uvc_unref_device(dev);
+        }
+    }
+
+    free(list);
+
+    UVC_EXIT_VOID();
+}
+
+/**
+ * @brief Get the uvc_device_t corresponding to an open device
+ * @ingroup device
+ *
+ * @note Unref the uvc_device_t when you're done with it
+ *
+ * @param devh Device handle to an open UVC device
+ */
+uvc_device_t *uvc_get_device(uvc_device_handle_t *devh) {
+    uvc_ref_device(devh->dev);
+    return devh->dev;
+}
+
+/**
+ * @brief Get the underlying libusb device handle for an open device
+ * @ingroup device
+ *
+ * This can be used to access other interfaces on the same device, e.g.
+ * a webcam microphone.
+ *
+ * @note The libusb device handle is only valid while the UVC device is open;
+ * it will be invalidated upon calling uvc_close.
+ *
+ * @param devh UVC device handle to an open device
+ */
+libusb_device_handle *uvc_get_libusb_handle(uvc_device_handle_t *devh) {
+    return devh->usb_devh;
+}
+
+/**
+ * @brief Get camera terminal descriptor for the open device.
+ *
+ * @note Do not modify the returned structure.
+ * @note The returned structure is part of a linked list, but iterating through
+ * it will make it no longer the camera terminal
+ *
+ * @param devh Device handle to an open UVC device
+ */
+const uvc_input_terminal_t *uvc_get_camera_terminal(uvc_device_handle_t *devh) {
+    const uvc_input_terminal_t *term = uvc_get_input_terminals(devh);
+    while(term != NULL) {
+        if(term->wTerminalType == UVC_ITT_CAMERA) {
+            break;
+        }
+        else {
+            term = term->next;
+        }
+    }
+    return term;
+}
+
+/**
+ * @brief Get input terminal descriptors for the open device.
+ *
+ * @note Do not modify the returned structure.
+ * @note The returned structure is part of a linked list. Iterate through
+ *       it by using the 'next' pointers.
+ *
+ * @param devh Device handle to an open UVC device
+ */
+const uvc_input_terminal_t *uvc_get_input_terminals(uvc_device_handle_t *devh) {
+    return devh->info->ctrl_if.input_term_descs;
+}
+
+/**
+ * @brief Get output terminal descriptors for the open device.
+ *
+ * @note Do not modify the returned structure.
+ * @note The returned structure is part of a linked list. Iterate through
+ *       it by using the 'next' pointers.
+ *
+ * @param devh Device handle to an open UVC device
+ */
+const uvc_output_terminal_t *uvc_get_output_terminals(uvc_device_handle_t *devh) {
+    (void)devh;
+    return NULL; /* @todo */
+}
+
+/**
+ * @brief Get selector unit descriptors for the open device.
+ *
+ * @note Do not modify the returned structure.
+ * @note The returned structure is part of a linked list. Iterate through
+ *       it by using the 'next' pointers.
+ *
+ * @param devh Device handle to an open UVC device
+ */
+const uvc_selector_unit_t *uvc_get_selector_units(uvc_device_handle_t *devh) {
+    return devh->info->ctrl_if.selector_unit_descs;
+}
+
+/**
+ * @brief Get processing unit descriptors for the open device.
+ *
+ * @note Do not modify the returned structure.
+ * @note The returned structure is part of a linked list. Iterate through
+ *       it by using the 'next' pointers.
+ *
+ * @param devh Device handle to an open UVC device
+ */
+const uvc_processing_unit_t *uvc_get_processing_units(uvc_device_handle_t *devh) {
+    return devh->info->ctrl_if.processing_unit_descs;
+}
+
+/**
+ * @brief Get extension unit descriptors for the open device.
+ *
+ * @note Do not modify the returned structure.
+ * @note The returned structure is part of a linked list. Iterate through
+ *       it by using the 'next' pointers.
+ *
+ * @param devh Device handle to an open UVC device
+ */
+const uvc_extension_unit_t *uvc_get_extension_units(uvc_device_handle_t *devh) {
+    return devh->info->ctrl_if.extension_unit_descs;
+}
+
+/**
+ * @brief Increment the reference count for a device
+ * @ingroup device
+ *
+ * @param dev Device to reference
+ */
+void uvc_ref_device(uvc_device_t *dev) {
+    UVC_ENTER();
+
+    dev->ref++;
+    libusb_ref_device(dev->usb_dev);
+
+    UVC_EXIT_VOID();
+}
+
+/**
+ * @brief Decrement the reference count for a device
+ * @ingropu device
+ * @note If the count reaches zero, the device will be discarded
+ *
+ * @param dev Device to unreference
+ */
+void uvc_unref_device(uvc_device_t *dev) {
+    UVC_ENTER();
+
+    libusb_unref_device(dev->usb_dev);
+    dev->ref--;
+
+    if(dev->ref == 0)
+        free(dev);
+
+    UVC_EXIT_VOID();
+}
+
+/** @internal
+ * Claim a UVC interface, detaching the kernel driver if necessary.
+ * @ingroup device
+ *
+ * @param devh UVC device handle
+ * @param idx UVC interface index
+ */
+uvc_error_t uvc_claim_if(uvc_device_handle_t *devh, int idx) {
+    int ret = UVC_SUCCESS;
+
+    UVC_ENTER();
+
+    if(devh->claimed & (1 << idx)) {
+        UVC_DEBUG("attempt to claim already-claimed interface %d\n", idx);
+        UVC_EXIT(ret);
+        return ret;
+    }
+
+    /* Tell libusb to detach any active kernel drivers. libusb will keep track of whether
+     * it found a kernel driver for this interface. */
+    ret = libusb_detach_kernel_driver(devh->usb_devh, idx);
+
+    if(ret == UVC_SUCCESS || ret == LIBUSB_ERROR_NOT_FOUND || ret == LIBUSB_ERROR_NOT_SUPPORTED) {
+        UVC_DEBUG("claiming interface %d", idx);
+        if(!(ret = libusb_claim_interface(devh->usb_devh, idx))) {
+            devh->claimed |= (1 << idx);
+        }
+    }
+    else {
+        UVC_DEBUG("not claiming interface %d: unable to detach kernel driver (%s)", idx, uvc_strerror(ret));
+    }
+
+    UVC_EXIT(ret);
+    return ret;
+}
+
+/** @internal
+ * Release a UVC interface.
+ * @ingroup device
+ *
+ * @param devh UVC device handle
+ * @param idx UVC interface index
+ */
+uvc_error_t uvc_release_if(uvc_device_handle_t *devh, int idx) {
+    int ret = UVC_SUCCESS;
+
+    UVC_ENTER();
+    UVC_DEBUG("releasing interface %d", idx);
+    if(!(devh->claimed & (1 << idx))) {
+        UVC_DEBUG("attempt to release unclaimed interface %d\n", idx);
+        UVC_EXIT(ret);
+        return ret;
+    }
+
+    /* libusb_release_interface *should* reset the alternate setting to the first available,
+       but sometimes (e.g. on Darwin) it doesn't. Thus, we do it explicitly here.
+       This is needed to de-initialize certain cameras. */
+#ifdef OS_MACOS
+    libusb_set_interface_alt_setting(devh->usb_devh, idx, 0);
+#endif
+    ret = libusb_release_interface(devh->usb_devh, idx);
+
+    if(UVC_SUCCESS == ret) {
+        devh->claimed &= ~(1 << idx);
+        /* Reattach any kernel drivers that were disabled when we claimed this interface */
+
+        // bug fix: JDRN-1824, 解决贾维斯再linux、android 平台重连设备后depth、ir开流失败问题
+        ret = libusb_attach_kernel_driver(devh->usb_devh, idx);
+
+        if(ret == UVC_SUCCESS) {
+            UVC_DEBUG("reattached kernel driver to interface %d", idx);
+        }
+        else if(ret == LIBUSB_ERROR_NOT_FOUND || ret == LIBUSB_ERROR_NOT_SUPPORTED) {
+            ret = UVC_SUCCESS; /* NOT_FOUND and NOT_SUPPORTED are OK: nothing to do */
+        }
+        else {
+            UVC_DEBUG("error reattaching kernel driver to interface %d: %s", idx, uvc_strerror(ret));
+        }
+    }
+
+    UVC_EXIT(ret);
+    return ret;
+}
+
+/** @internal
+ * Find a device's VideoControl interface and process its descriptor
+ * @ingroup device
+ */
+uvc_error_t uvc_scan_control(uvc_device_t *dev, uint16_t mi, uvc_device_info_t *info) {
+    const struct libusb_interface_descriptor *if_desc;
+    uvc_error_t                               parse_ret, ret;
+    int                                       interface_idx;
+    const unsigned char                      *buffer;
+    size_t                                    buffer_left, block_size;
+
+    UVC_ENTER();
+
+    ret     = UVC_SUCCESS;
+    if_desc = NULL;
+
+    uvc_device_descriptor_t *dev_desc;
+    int                      haveTISCamera = 0;
+    uvc_get_device_descriptor(dev, &dev_desc);
+    if(0x199e == dev_desc->idVendor && (0x8101 == dev_desc->idProduct || 0x8102 == dev_desc->idProduct)) {
+        haveTISCamera = 1;
+    }
+    uvc_free_device_descriptor(dev_desc);
+
+    for(interface_idx = 0; interface_idx < info->config->bNumInterfaces; ++interface_idx) {
+        if_desc = &info->config->interface[interface_idx].altsetting[0];
+
+        if(haveTISCamera && if_desc->bInterfaceClass == 255 && if_desc->bInterfaceSubClass == 1)  // Video, Control
+            break;
+
+        if(if_desc->bInterfaceClass == 14 && if_desc->bInterfaceSubClass == 1)  // Video, Control
+        {
+            if(interface_idx == mi)
+                break;
+            else {
+                continue;
+            }
+        }
+
+        if_desc = NULL;
+    }
+
+    if(if_desc == NULL) {
+        UVC_EXIT(UVC_ERROR_INVALID_DEVICE);
+        return UVC_ERROR_INVALID_DEVICE;
+    }
+
+    info->ctrl_if.bInterfaceNumber = interface_idx;
+    if(if_desc->bNumEndpoints != 0) {
+        info->ctrl_if.bEndpointAddress = if_desc->endpoint[0].bEndpointAddress;
+    }
+
+    buffer      = if_desc->extra;
+    buffer_left = if_desc->extra_length;
+
+    while(buffer_left >= 3) {  // parseX needs to see buf[0,2] = length,type
+        block_size = buffer[0];
+        parse_ret  = uvc_parse_vc(dev, info, buffer, block_size);
+
+        if(parse_ret != UVC_SUCCESS) {
+            ret = parse_ret;
+            break;
+        }
+
+        buffer_left -= block_size;
+        buffer += block_size;
+    }
+
+    UVC_EXIT(ret);
+    return ret;
+}
+
+/** @internal
+ * @brief Parse a VideoControl header.
+ * @ingroup device
+ */
+uvc_error_t uvc_parse_vc_header(uvc_device_t *dev, uvc_device_info_t *info, const unsigned char *block, size_t block_size) {
+    size_t      i;
+    uvc_error_t scan_ret, ret = UVC_SUCCESS;
+
+    UVC_ENTER();
+
+    /*
+    int uvc_version;
+    uvc_version = (block[4] >> 4) * 1000 + (block[4] & 0x0f) * 100
+      + (block[3] >> 4) * 10 + (block[3] & 0x0f);
+    */
+
+    info->ctrl_if.bcdUVC = SW_TO_SHORT(&block[3]);
+
+    switch(info->ctrl_if.bcdUVC) {
+    case 0x0100:
+        info->ctrl_if.dwClockFrequency = DW_TO_INT(block + 7);
+        break;
+    case 0x010a:
+        info->ctrl_if.dwClockFrequency = DW_TO_INT(block + 7);
+        break;
+    case 0x0110:
+    case 0x0150:
+        info->ctrl_if.dwClockFrequency = 0;
+        break;
+    default:
+        UVC_EXIT(UVC_ERROR_NOT_SUPPORTED);
+        return UVC_ERROR_NOT_SUPPORTED;
+    }
+
+    for(i = 12; i < block_size; ++i) {
+        scan_ret = uvc_scan_streaming(dev, info, block[i]);
+        if(scan_ret != UVC_SUCCESS) {
+            ret = scan_ret;
+            break;
+        }
+    }
+
+    UVC_EXIT(ret);
+    return ret;
+}
+
+/** @internal
+ * @brief Parse a VideoControl input terminal.
+ * @ingroup device
+ */
+uvc_error_t uvc_parse_vc_input_terminal(uvc_device_t *dev, uvc_device_info_t *info, const unsigned char *block, size_t block_size) {
+    (void)dev;
+    (void)block_size;
+    uvc_input_terminal_t *term;
+    size_t                i;
+
+    UVC_ENTER();
+
+    /* only supporting camera-type input terminals */
+    if(SW_TO_SHORT(&block[4]) != UVC_ITT_CAMERA) {
+        UVC_EXIT(UVC_SUCCESS);
+        return UVC_SUCCESS;
+    }
+
+    term = calloc(1, sizeof(*term));
+
+    term->bTerminalID              = block[3];
+    term->wTerminalType            = SW_TO_SHORT(&block[4]);
+    term->wObjectiveFocalLengthMin = SW_TO_SHORT(&block[8]);
+    term->wObjectiveFocalLengthMax = SW_TO_SHORT(&block[10]);
+    term->wOcularFocalLength       = SW_TO_SHORT(&block[12]);
+
+    for(i = 14 + block[14]; i >= 15; --i)
+        term->bmControls = block[i] + (term->bmControls << 8);
+
+    DL_APPEND(info->ctrl_if.input_term_descs, term);
+
+    UVC_EXIT(UVC_SUCCESS);
+    return UVC_SUCCESS;
+}
+
+/** @internal
+ * @brief Parse a VideoControl processing unit.
+ * @ingroup device
+ */
+uvc_error_t uvc_parse_vc_processing_unit(uvc_device_t *dev, uvc_device_info_t *info, const unsigned char *block, size_t block_size) {
+    (void)dev;
+    (void)block_size;
+    uvc_processing_unit_t *unit;
+    size_t                 i;
+
+    UVC_ENTER();
+
+    unit            = calloc(1, sizeof(*unit));
+    unit->bUnitID   = block[3];
+    unit->bSourceID = block[4];
+
+    for(i = 7 + block[7]; i >= 8; --i)
+        unit->bmControls = block[i] + (unit->bmControls << 8);
+
+    DL_APPEND(info->ctrl_if.processing_unit_descs, unit);
+
+    UVC_EXIT(UVC_SUCCESS);
+    return UVC_SUCCESS;
+}
+
+/** @internal
+ * @brief Parse a VideoControl selector unit.
+ * @ingroup device
+ */
+uvc_error_t uvc_parse_vc_selector_unit(uvc_device_t *dev, uvc_device_info_t *info, const unsigned char *block, size_t block_size) {
+    (void)dev;
+    (void)block_size;
+    uvc_selector_unit_t *unit;
+
+    UVC_ENTER();
+
+    unit          = calloc(1, sizeof(*unit));
+    unit->bUnitID = block[3];
+
+    DL_APPEND(info->ctrl_if.selector_unit_descs, unit);
+
+    UVC_EXIT(UVC_SUCCESS);
+    return UVC_SUCCESS;
+}
+
+/** @internal
+ * @brief Parse a VideoControl extension unit.
+ * @ingroup device
+ */
+uvc_error_t uvc_parse_vc_extension_unit(uvc_device_t *dev, uvc_device_info_t *info, const unsigned char *block, size_t block_size) {
+    (void)dev;
+    (void)block_size;
+    uvc_extension_unit_t *unit = calloc(1, sizeof(*unit));
+    const uint8_t        *start_of_controls;
+    int                   size_of_controls, num_in_pins;
+    int                   i;
+
+    UVC_ENTER();
+
+    unit->bUnitID = block[3];
+    memcpy(unit->guidExtensionCode, &block[4], 16);
+
+    num_in_pins       = block[21];
+    size_of_controls  = block[22 + num_in_pins];
+    start_of_controls = &block[23 + num_in_pins];
+
+    for(i = size_of_controls - 1; i >= 0; --i)
+        unit->bmControls = start_of_controls[i] + (unit->bmControls << 8);
+
+    DL_APPEND(info->ctrl_if.extension_unit_descs, unit);
+
+    UVC_EXIT(UVC_SUCCESS);
+    return UVC_SUCCESS;
+}
+
+/** @internal
+ * Process a single VideoControl descriptor block
+ * @ingroup device
+ */
+uvc_error_t uvc_parse_vc(uvc_device_t *dev, uvc_device_info_t *info, const unsigned char *block, size_t block_size) {
+    int         descriptor_subtype;
+    uvc_error_t ret = UVC_SUCCESS;
+
+    UVC_ENTER();
+
+    if(block[1] != 36) {  // not a CS_INTERFACE descriptor??
+        UVC_EXIT(UVC_SUCCESS);
+        return UVC_SUCCESS;  // UVC_ERROR_INVALID_DEVICE;
+    }
+
+    descriptor_subtype = block[2];
+
+    switch(descriptor_subtype) {
+    case UVC_VC_HEADER:
+        ret = uvc_parse_vc_header(dev, info, block, block_size);
+        break;
+    case UVC_VC_INPUT_TERMINAL:
+        ret = uvc_parse_vc_input_terminal(dev, info, block, block_size);
+        break;
+    case UVC_VC_OUTPUT_TERMINAL:
+        break;
+    case UVC_VC_SELECTOR_UNIT:
+        ret = uvc_parse_vc_selector_unit(dev, info, block, block_size);
+        break;
+    case UVC_VC_PROCESSING_UNIT:
+        ret = uvc_parse_vc_processing_unit(dev, info, block, block_size);
+        break;
+    case UVC_VC_EXTENSION_UNIT:
+        ret = uvc_parse_vc_extension_unit(dev, info, block, block_size);
+        break;
+    default:
+        ret = UVC_ERROR_INVALID_DEVICE;
+    }
+
+    UVC_EXIT(ret);
+    return ret;
+}
+
+/** @internal
+ * Process a VideoStreaming interface
+ * @ingroup device
+ */
+uvc_error_t uvc_scan_streaming(uvc_device_t *dev, uvc_device_info_t *info, int interface_idx) {
+    const struct libusb_interface_descriptor *if_desc;
+    const unsigned char                      *buffer;
+    size_t                                    buffer_left, block_size;
+    uvc_error_t                               ret, parse_ret;
+    uvc_streaming_interface_t                *stream_if;
+
+    UVC_ENTER();
+
+    ret = UVC_SUCCESS;
+
+    if_desc     = &(info->config->interface[interface_idx].altsetting[0]);
+    buffer      = if_desc->extra;
+    buffer_left = if_desc->extra_length;
+
+    stream_if                   = calloc(1, sizeof(*stream_if));
+    stream_if->parent           = info;
+    stream_if->bInterfaceNumber = if_desc->bInterfaceNumber;
+    DL_APPEND(info->stream_ifs, stream_if);
+
+    while(buffer_left >= 3) {
+        block_size = buffer[0];
+        parse_ret  = uvc_parse_vs(dev, info, stream_if, buffer, block_size);
+
+        if(parse_ret != UVC_SUCCESS) {
+            ret = parse_ret;
+            break;
+        }
+
+        buffer_left -= block_size;
+        buffer += block_size;
+    }
+
+    UVC_EXIT(ret);
+    return ret;
+}
+
+/** @internal
+ * @brief Parse a VideoStreaming header block.
+ * @ingroup device
+ */
+uvc_error_t uvc_parse_vs_input_header(uvc_streaming_interface_t *stream_if, const unsigned char *block, size_t block_size) {
+    (void)block_size;
+    UVC_ENTER();
+
+    stream_if->bEndpointAddress    = block[6] & 0x8f;
+    stream_if->bTerminalLink       = block[8];
+    stream_if->bStillCaptureMethod = block[9];
+
+    UVC_EXIT(UVC_SUCCESS);
+    return UVC_SUCCESS;
+}
+
+/** @internal
+ * @brief Parse a VideoStreaming uncompressed format block.
+ * @ingroup device
+ */
+uvc_error_t uvc_parse_vs_format_uncompressed(uvc_streaming_interface_t *stream_if, const unsigned char *block, size_t block_size) {
+    (void)block_size;
+    UVC_ENTER();
+
+    uvc_format_desc_t *format = calloc(1, sizeof(*format));
+
+    format->parent             = stream_if;
+    format->bDescriptorSubtype = block[2];
+    format->bFormatIndex       = block[3];
+    // format->bmCapabilities = block[4];
+    // format->bmFlags = block[5];
+    memcpy(format->guidFormat, &block[5], 16);
+    format->bBitsPerPixel      = block[21];
+    format->bDefaultFrameIndex = block[22];
+    format->bAspectRatioX      = block[23];
+    format->bAspectRatioY      = block[24];
+    format->bmInterlaceFlags   = block[25];
+    format->bCopyProtect       = block[26];
+
+    DL_APPEND(stream_if->format_descs, format);
+
+    UVC_EXIT(UVC_SUCCESS);
+    return UVC_SUCCESS;
+}
+
+/** @internal
+ * @brief Parse a VideoStreaming frame format block.
+ * @ingroup device
+ */
+uvc_error_t uvc_parse_vs_frame_format(uvc_streaming_interface_t *stream_if, const unsigned char *block, size_t block_size) {
+    (void)block_size;
+    UVC_ENTER();
+
+    uvc_format_desc_t *format = calloc(1, sizeof(*format));
+
+    format->parent               = stream_if;
+    format->bDescriptorSubtype   = block[2];
+    format->bFormatIndex         = block[3];
+    format->bNumFrameDescriptors = block[4];
+    memcpy(format->guidFormat, &block[5], 16);
+    format->bBitsPerPixel      = block[21];
+    format->bDefaultFrameIndex = block[22];
+    format->bAspectRatioX      = block[23];
+    format->bAspectRatioY      = block[24];
+    format->bmInterlaceFlags   = block[25];
+    format->bCopyProtect       = block[26];
+    format->bVariableSize      = block[27];
+
+    DL_APPEND(stream_if->format_descs, format);
+
+    UVC_EXIT(UVC_SUCCESS);
+    return UVC_SUCCESS;
+}
+
+/** @internal
+ * @brief Parse a VideoStreaming MJPEG format block.
+ * @ingroup device
+ */
+uvc_error_t uvc_parse_vs_format_mjpeg(uvc_streaming_interface_t *stream_if, const unsigned char *block, size_t block_size) {
+    (void)block_size;
+    UVC_ENTER();
+
+    uvc_format_desc_t *format = calloc(1, sizeof(*format));
+
+    format->parent             = stream_if;
+    format->bDescriptorSubtype = block[2];
+    format->bFormatIndex       = block[3];
+    memcpy(format->fourccFormat, "MJPG", 4);
+    format->bmFlags            = block[5];
+    format->bBitsPerPixel      = 0;
+    format->bDefaultFrameIndex = block[6];
+    format->bAspectRatioX      = block[7];
+    format->bAspectRatioY      = block[8];
+    format->bmInterlaceFlags   = block[9];
+    format->bCopyProtect       = block[10];
+
+    DL_APPEND(stream_if->format_descs, format);
+
+    UVC_EXIT(UVC_SUCCESS);
+    return UVC_SUCCESS;
+}
+
+/** @internal
+ * @brief Parse a VideoStreaming uncompressed frame block.
+ * @ingroup device
+ */
+uvc_error_t uvc_parse_vs_frame_frame(uvc_streaming_interface_t *stream_if, const unsigned char *block, size_t block_size) {
+    (void)block_size;
+    uvc_format_desc_t *format;
+    uvc_frame_desc_t  *frame;
+
+    const unsigned char *p;
+    int                  i;
+
+    UVC_ENTER();
+
+    format = stream_if->format_descs->prev;
+    frame  = calloc(1, sizeof(*frame));
+
+    frame->parent = format;
+
+    frame->bDescriptorSubtype     = block[2];
+    frame->bFrameIndex            = block[3];
+    frame->bmCapabilities         = block[4];
+    frame->wWidth                 = block[5] + (block[6] << 8);
+    frame->wHeight                = block[7] + (block[8] << 8);
+    frame->dwMinBitRate           = DW_TO_INT(&block[9]);
+    frame->dwMaxBitRate           = DW_TO_INT(&block[13]);
+    frame->dwDefaultFrameInterval = DW_TO_INT(&block[17]);
+    frame->bFrameIntervalType     = block[21];
+    frame->dwBytesPerLine         = DW_TO_INT(&block[22]);
+
+    if(block[21] == 0) {
+        frame->dwMinFrameInterval  = DW_TO_INT(&block[26]);
+        frame->dwMaxFrameInterval  = DW_TO_INT(&block[30]);
+        frame->dwFrameIntervalStep = DW_TO_INT(&block[34]);
+    }
+    else {
+        frame->intervals = calloc(block[21] + 1, sizeof(frame->intervals[0]));
+        p                = &block[26];
+
+        for(i = 0; i < block[21]; ++i) {
+            frame->intervals[i] = DW_TO_INT(p);
+            p += 4;
+        }
+        frame->intervals[block[21]] = 0;
+    }
+
+    DL_APPEND(format->frame_descs, frame);
+
+    UVC_EXIT(UVC_SUCCESS);
+    return UVC_SUCCESS;
+}
+
+/** @internal
+ * @brief Parse a VideoStreaming uncompressed frame block.
+ * @ingroup device
+ */
+uvc_error_t uvc_parse_vs_frame_uncompressed(uvc_streaming_interface_t *stream_if, const unsigned char *block, size_t block_size) {
+    (void)block_size;
+    uvc_format_desc_t *format;
+    uvc_frame_desc_t  *frame;
+
+    const unsigned char *p;
+    int                  i;
+
+    UVC_ENTER();
+
+    format = stream_if->format_descs->prev;
+    frame  = calloc(1, sizeof(*frame));
+
+    frame->parent = format;
+
+    frame->bDescriptorSubtype        = block[2];
+    frame->bFrameIndex               = block[3];
+    frame->bmCapabilities            = block[4];
+    frame->wWidth                    = block[5] + (block[6] << 8);
+    frame->wHeight                   = block[7] + (block[8] << 8);
+    frame->dwMinBitRate              = DW_TO_INT(&block[9]);
+    frame->dwMaxBitRate              = DW_TO_INT(&block[13]);
+    frame->dwMaxVideoFrameBufferSize = DW_TO_INT(&block[17]);
+    frame->dwDefaultFrameInterval    = DW_TO_INT(&block[21]);
+    frame->bFrameIntervalType        = block[25];
+
+    if(block[25] == 0) {
+        frame->dwMinFrameInterval  = DW_TO_INT(&block[26]);
+        frame->dwMaxFrameInterval  = DW_TO_INT(&block[30]);
+        frame->dwFrameIntervalStep = DW_TO_INT(&block[34]);
+    }
+    else {
+        frame->intervals = calloc(block[25] + 1, sizeof(frame->intervals[0]));
+        p                = &block[26];
+
+        for(i = 0; i < block[25]; ++i) {
+            frame->intervals[i] = DW_TO_INT(p);
+            p += 4;
+        }
+        frame->intervals[block[25]] = 0;
+    }
+
+    DL_APPEND(format->frame_descs, frame);
+
+    UVC_EXIT(UVC_SUCCESS);
+    return UVC_SUCCESS;
+}
+
+/** @internal
+ * @brief Parse a VideoStreaming still iamge frame
+ * @ingroup device
+ */
+uvc_error_t uvc_parse_vs_still_image_frame(uvc_streaming_interface_t *stream_if, const unsigned char *block, size_t block_size) {
+    (void)block_size;
+    struct uvc_still_frame_desc *frame;
+    uvc_format_desc_t           *format;
+
+    const unsigned char *p;
+    int                  i;
+
+    UVC_ENTER();
+
+    format = stream_if->format_descs->prev;
+    frame  = calloc(1, sizeof(*frame));
+
+    frame->parent = format;
+
+    frame->bDescriptorSubtype    = block[2];
+    frame->bEndPointAddress      = block[3];
+    uint8_t numImageSizePatterns = block[4];
+
+    frame->imageSizePatterns = NULL;
+
+    p = &block[5];
+
+    for(i = 1; i <= numImageSizePatterns; ++i) {
+        uvc_still_frame_res_t *res = calloc(1, sizeof(uvc_still_frame_res_t));
+        res->bResolutionIndex      = i;
+        res->wWidth                = SW_TO_SHORT(p);
+        p += 2;
+        res->wHeight = SW_TO_SHORT(p);
+        p += 2;
+
+        DL_APPEND(frame->imageSizePatterns, res);
+    }
+
+    p                             = &block[5 + 4 * numImageSizePatterns];
+    frame->bNumCompressionPattern = *p;
+
+    if(frame->bNumCompressionPattern) {
+        frame->bCompression = calloc(frame->bNumCompressionPattern, sizeof(frame->bCompression[0]));
+        for(i = 0; i < frame->bNumCompressionPattern; ++i) {
+            ++p;
+            frame->bCompression[i] = *p;
+        }
+    }
+    else {
+        frame->bCompression = NULL;
+    }
+
+    DL_APPEND(format->still_frame_desc, frame);
+
+    UVC_EXIT(UVC_SUCCESS);
+    return UVC_SUCCESS;
+}
+
+/** @internal
+ * Process a single VideoStreaming descriptor block
+ * @ingroup device
+ */
+uvc_error_t uvc_parse_vs(uvc_device_t *dev, uvc_device_info_t *info, uvc_streaming_interface_t *stream_if, const unsigned char *block, size_t block_size) {
+    (void)dev;
+    (void)info;
+    uvc_error_t ret;
+    int         descriptor_subtype;
+
+    UVC_ENTER();
+
+    ret                = UVC_SUCCESS;
+    descriptor_subtype = block[2];
+
+    switch(descriptor_subtype) {
+    case UVC_VS_INPUT_HEADER:
+        ret = uvc_parse_vs_input_header(stream_if, block, block_size);
+        break;
+    case UVC_VS_OUTPUT_HEADER:
+        UVC_DEBUG("unsupported descriptor subtype VS_OUTPUT_HEADER");
+        break;
+    case UVC_VS_STILL_IMAGE_FRAME:
+        ret = uvc_parse_vs_still_image_frame(stream_if, block, block_size);
+        break;
+    case UVC_VS_FORMAT_UNCOMPRESSED:
+        ret = uvc_parse_vs_format_uncompressed(stream_if, block, block_size);
+        break;
+    case UVC_VS_FORMAT_MJPEG:
+        ret = uvc_parse_vs_format_mjpeg(stream_if, block, block_size);
+        break;
+    case UVC_VS_FRAME_UNCOMPRESSED:
+    case UVC_VS_FRAME_MJPEG:
+        ret = uvc_parse_vs_frame_uncompressed(stream_if, block, block_size);
+        break;
+    case UVC_VS_FORMAT_MPEG2TS:
+        UVC_DEBUG("unsupported descriptor subtype VS_FORMAT_MPEG2TS");
+        break;
+    case UVC_VS_FORMAT_DV:
+        UVC_DEBUG("unsupported descriptor subtype VS_FORMAT_DV");
+        break;
+    case UVC_VS_COLORFORMAT:
+        UVC_DEBUG("unsupported descriptor subtype VS_COLORFORMAT");
+        break;
+    case UVC_VS_FORMAT_FRAME_BASED:
+        ret = uvc_parse_vs_frame_format(stream_if, block, block_size);
+        break;
+    case UVC_VS_FRAME_FRAME_BASED:
+        ret = uvc_parse_vs_frame_frame(stream_if, block, block_size);
+        break;
+    case UVC_VS_FORMAT_STREAM_BASED:
+        UVC_DEBUG("unsupported descriptor subtype VS_FORMAT_STREAM_BASED");
+        break;
+    default:
+        /** @todo handle JPEG and maybe still frames or even DV... */
+        // UVC_DEBUG("unsupported descriptor subtype: %d",descriptor_subtype);
+        break;
+    }
+
+    UVC_EXIT(ret);
+    return ret;
+}
+
+/** @internal
+ * @brief Free memory associated with a UVC device
+ * @pre Streaming must be stopped, and threads must have died
+ */
+void uvc_free_devh(uvc_device_handle_t *devh) {
+    UVC_ENTER();
+
+    if(devh->info)
+        uvc_free_device_info(devh->info);
+
+    free(devh);
+
+    UVC_EXIT_VOID();
+}
+
+/** @brief Close a device
+ *
+ * @ingroup device
+ *
+ * Ends any stream that's in progress.
+ *
+ * The device handle and frame structures will be invalidated.
+ */
+void uvc_close(uvc_device_handle_t *devh) {
+    UVC_ENTER();
+    uvc_context_t *ctx = devh->dev->ctx;
+    if(devh->streams)
+        uvc_stop_streaming(devh);
+
+    uvc_release_if(devh, devh->info->ctrl_if.bInterfaceNumber);
+
+    if(devh->status_xfer) {
+        int res = libusb_cancel_transfer(devh->status_xfer);
+        // 增加LIBUSB_ERROR_NO_DEVICE状态的判断，解决Android7平台贾维斯设备开流状态下热拔插概率性
+        // 出现EventHandle线程无法退出的问题
+        if(res < 0 && res != LIBUSB_ERROR_NOT_FOUND && res != LIBUSB_ERROR_NO_DEVICE) {
+            // devh->status_xfer  指向devh->status_buf,会在uvc_free_devh(devh)时释放
+            // free(devh->status_xfer->buffer);
+
+            libusb_free_transfer(devh->status_xfer);
+            devh->status_xfer = NULL;
+        }
+    }
+
+    /* If we are managing the libusb context and this is the last open device,
+     * then we need to cancel the handler thread. When we call libusb_close,
+     * it'll cause a return from the thread's libusb_handle_events call, after
+     * which the handler thread will check the flag we set and then exit. */
+    if(ctx->own_usb_ctx && ctx->open_devices == devh && devh->next == NULL) {
+        ctx->kill_handler_thread = 1;
+#ifndef __ANDROID__
+        libusb_close(devh->usb_devh);
+#endif
+        pthread_join(ctx->handler_thread, NULL);
+    }
+    else {
+#ifndef __ANDROID__
+        libusb_close(devh->usb_devh);
+#endif
+    }
+
+    DL_DELETE(ctx->open_devices, devh);
+
+    uvc_unref_device(devh->dev);
+
+    uvc_free_devh(devh);
+
+    UVC_EXIT_VOID();
+}
+
+/** @internal
+ * @brief Get number of open devices
+ */
+size_t uvc_num_devices(uvc_context_t *ctx) {
+    size_t count = 0;
+
+    uvc_device_handle_t *devh;
+
+    UVC_ENTER();
+
+    DL_FOREACH(ctx->open_devices, devh) {
+        count++;
+    }
+
+    UVC_EXIT((int)count);
+    return count;
+}
+
+void uvc_process_control_status(uvc_device_handle_t *devh, unsigned char *data, int len) {
+    enum uvc_status_class       status_class;
+    uint8_t                     originator = 0, selector = 0, event = 0;
+    enum uvc_status_attribute   attribute    = UVC_STATUS_ATTRIBUTE_UNKNOWN;
+    void                       *content      = NULL;
+    size_t                      content_len  = 0;
+    int                         found_entity = 0;
+    struct uvc_input_terminal  *input_terminal;
+    struct uvc_processing_unit *processing_unit;
+
+    UVC_ENTER();
+
+    if(len < 5) {
+        UVC_DEBUG("Short read of VideoControl status update (%d bytes)", len);
+        UVC_EXIT_VOID();
+        return;
+    }
+
+    originator = data[1];
+    event      = data[2];
+    selector   = data[3];
+
+    if(originator == 0) {
+        UVC_DEBUG("Unhandled update from VC interface");
+        UVC_EXIT_VOID();
+        return; /* @todo VideoControl virtual entity interface updates */
+    }
+
+    if(event != 0) {
+        UVC_DEBUG("Unhandled VC event %d", (int)event);
+        UVC_EXIT_VOID();
+        return;
+    }
+
+    /* printf("bSelector: %d\n", selector); */
+
+    DL_FOREACH(devh->info->ctrl_if.input_term_descs, input_terminal) {
+        if(input_terminal->bTerminalID == originator) {
+            status_class = UVC_STATUS_CLASS_CONTROL_CAMERA;
+            found_entity = 1;
+            break;
+        }
+    }
+
+    if(!found_entity) {
+        DL_FOREACH(devh->info->ctrl_if.processing_unit_descs, processing_unit) {
+            if(processing_unit->bUnitID == originator) {
+                status_class = UVC_STATUS_CLASS_CONTROL_PROCESSING;
+                found_entity = 1;
+                break;
+            }
+        }
+    }
+
+    if(!found_entity) {
+        UVC_DEBUG("Got status update for unknown VideoControl entity %d", (int)originator);
+        UVC_EXIT_VOID();
+        return;
+    }
+
+    attribute   = data[4];
+    content     = data + 5;
+    content_len = len - 5;
+
+    UVC_DEBUG("Event: class=%d, event=%d, selector=%d, attribute=%d, content_len=%zd", status_class, event, selector, attribute, content_len);
+
+    if(devh->status_cb) {
+        UVC_DEBUG("Running user-supplied status callback");
+        devh->status_cb(status_class, event, selector, attribute, content, content_len, devh->status_user_ptr);
+    }
+
+    UVC_EXIT_VOID();
+}
+
+void uvc_process_streaming_status(uvc_device_handle_t *devh, unsigned char *data, int len) {
+
+    UVC_ENTER();
+
+    if(len < 3) {
+        UVC_DEBUG("Invalid streaming status event received.\n");
+        UVC_EXIT_VOID();
+        return;
+    }
+
+    if(data[2] == 0) {
+        if(len < 4) {
+            UVC_DEBUG("Short read of status update (%d bytes)", len);
+            UVC_EXIT_VOID();
+            return;
+        }
+        UVC_DEBUG("Button (intf %u) %s len %d\n", data[1], data[3] ? "pressed" : "released", len);
+
+        if(devh->button_cb) {
+            UVC_DEBUG("Running user-supplied button callback");
+            devh->button_cb(data[1], data[3], devh->button_user_ptr);
+        }
+    }
+    else {
+        UVC_DEBUG("Stream %u error event %02x %02x len %d.\n", data[1], data[2], data[3], len);
+    }
+
+    UVC_EXIT_VOID();
+}
+
+void uvc_process_status_xfer(uvc_device_handle_t *devh, struct libusb_transfer *transfer) {
+
+    UVC_ENTER();
+
+    /* printf("Got transfer of aLen = %d\n", transfer->actual_length); */
+
+    if(transfer->actual_length > 0) {
+        switch(transfer->buffer[0] & 0x0f) {
+        case 1: /* VideoControl interface */
+            uvc_process_control_status(devh, transfer->buffer, transfer->actual_length);
+            break;
+        case 2: /* VideoStreaming interface */
+            uvc_process_streaming_status(devh, transfer->buffer, transfer->actual_length);
+            break;
+        }
+    }
+
+    UVC_EXIT_VOID();
+}
+
+/** @internal
+ * @brief Process asynchronous status updates from the device.
+ */
+void LIBUSB_CALL _uvc_status_callback(struct libusb_transfer *transfer) {
+    UVC_ENTER();
+
+    uvc_device_handle_t *devh = (uvc_device_handle_t *)transfer->user_data;
+
+    switch(transfer->status) {
+    case LIBUSB_TRANSFER_ERROR:
+    case LIBUSB_TRANSFER_CANCELLED:
+    case LIBUSB_TRANSFER_NO_DEVICE:
+        UVC_DEBUG("not processing/resubmitting, status = %d", transfer->status);
+        UVC_EXIT_VOID();
+        return;
+    case LIBUSB_TRANSFER_COMPLETED:
+        uvc_process_status_xfer(devh, transfer);
+        break;
+    case LIBUSB_TRANSFER_TIMED_OUT:
+    case LIBUSB_TRANSFER_STALL:
+    case LIBUSB_TRANSFER_OVERFLOW:
+        UVC_DEBUG("retrying transfer, status = %d", transfer->status);
+        break;
+    }
+
+#ifdef UVC_DEBUGGING
+    uvc_error_t ret =
+#endif
+        libusb_submit_transfer(transfer);
+    UVC_DEBUG("libusb_submit_transfer() = %d", ret);
+
+    UVC_EXIT_VOID();
+}
+
+/** @brief Set a callback function to receive status updates
+ *
+ * @ingroup device
+ */
+void uvc_set_status_callback(uvc_device_handle_t *devh, uvc_status_callback_t cb, void *user_ptr) {
+    UVC_ENTER();
+
+    devh->status_cb       = cb;
+    devh->status_user_ptr = user_ptr;
+
+    UVC_EXIT_VOID();
+}
+
+/** @brief Set a callback function to receive button events
+ *
+ * @ingroup device
+ */
+void uvc_set_button_callback(uvc_device_handle_t *devh, uvc_button_callback_t cb, void *user_ptr) {
+    UVC_ENTER();
+
+    devh->button_cb       = cb;
+    devh->button_user_ptr = user_ptr;
+
+    UVC_EXIT_VOID();
+}
+
+/**
+ * @brief Get format descriptions for the open device.
+ *
+ * @note Do not modify the returned structure.
+ *
+ * @param devh Device handle to an open UVC device
+ */
+const uvc_format_desc_t *uvc_get_format_descs(uvc_device_handle_t *devh) {
+    return devh->info->stream_ifs->format_descs;
+}
diff --git a/3rdparty/libuvc/src/src/diag.c b/3rdparty/libuvc/src/src/diag.c
new file mode 100644
index 00000000..e9b836d3
--- /dev/null
+++ b/3rdparty/libuvc/src/src/diag.c
@@ -0,0 +1,333 @@
+/*********************************************************************
+ * Software License Agreement (BSD License)
+ *
+ *  Copyright (C) 2010-2012 Ken Tossell
+ *  All rights reserved.
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions
+ *  are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *   * Neither the name of the author nor other contributors may be
+ *     used to endorse or promote products derived from this software
+ *     without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ *  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ *  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ *  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ *  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ *  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ *  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ *  POSSIBILITY OF SUCH DAMAGE.
+ *********************************************************************/
+/**
+ * @defgroup diag Diagnostics
+ * @brief Interpretation of devices, error codes and negotiated stream parameters
+ */
+
+#include "libuvc/libuvc.h"
+#include "libuvc/libuvc_internal.h"
+
+/** @internal */
+typedef struct _uvc_error_msg {
+    uvc_error_t err;
+    const char *msg;
+} _uvc_error_msg_t;
+
+static const _uvc_error_msg_t uvc_error_msgs[] = { { UVC_SUCCESS, "Success" },
+                                                   { UVC_ERROR_IO, "I/O error" },
+                                                   { UVC_ERROR_INVALID_PARAM, "Invalid parameter" },
+                                                   { UVC_ERROR_ACCESS, "Access denied" },
+                                                   { UVC_ERROR_NO_DEVICE, "No such device" },
+                                                   { UVC_ERROR_NOT_FOUND, "Not found" },
+                                                   { UVC_ERROR_BUSY, "Busy" },
+                                                   { UVC_ERROR_TIMEOUT, "Timeout" },
+                                                   { UVC_ERROR_OVERFLOW, "Overflow" },
+                                                   { UVC_ERROR_PIPE, "Pipe" },
+                                                   { UVC_ERROR_INTERRUPTED, "Interrupted" },
+                                                   { UVC_ERROR_NO_MEM, "Out of memory" },
+                                                   { UVC_ERROR_NOT_SUPPORTED, "Not supported" },
+                                                   { UVC_ERROR_INVALID_DEVICE, "Invalid device" },
+                                                   { UVC_ERROR_INVALID_MODE, "Invalid mode" },
+                                                   { UVC_ERROR_CALLBACK_EXISTS, "Callback exists" } };
+
+/** @brief Print a message explaining an error in the UVC driver
+ * @ingroup diag
+ *
+ * @param err UVC error code
+ * @param msg Optional custom message, prepended to output
+ */
+void uvc_perror(uvc_error_t err, const char *msg) {
+    if(msg && *msg) {
+        fputs(msg, stderr);
+        fputs(": ", stderr);
+    }
+
+    fprintf(stderr, "%s (%d)\n", uvc_strerror(err), err);
+}
+
+/** @brief Return a string explaining an error in the UVC driver
+ * @ingroup diag
+ *
+ * @param err UVC error code
+ * @return error message
+ */
+const char *uvc_strerror(uvc_error_t err) {
+    size_t idx;
+
+    for(idx = 0; idx < sizeof(uvc_error_msgs) / sizeof(*uvc_error_msgs); ++idx) {
+        if(uvc_error_msgs[idx].err == err) {
+            return uvc_error_msgs[idx].msg;
+        }
+    }
+
+    return "Unknown error";
+}
+
+/** @brief Print the values in a stream control block
+ * @ingroup diag
+ *
+ * @param devh UVC device
+ * @param stream Output stream (stderr if NULL)
+ */
+void uvc_print_stream_ctrl(uvc_stream_ctrl_t *ctrl, FILE *stream) {
+    if(stream == NULL)
+        stream = stderr;
+
+    fprintf(stream, "bmHint: %04x\n", ctrl->bmHint);
+    fprintf(stream, "bFormatIndex: %d\n", ctrl->bFormatIndex);
+    fprintf(stream, "bFrameIndex: %d\n", ctrl->bFrameIndex);
+    fprintf(stream, "dwFrameInterval: %u\n", ctrl->dwFrameInterval);
+    fprintf(stream, "wKeyFrameRate: %d\n", ctrl->wKeyFrameRate);
+    fprintf(stream, "wPFrameRate: %d\n", ctrl->wPFrameRate);
+    fprintf(stream, "wCompQuality: %d\n", ctrl->wCompQuality);
+    fprintf(stream, "wCompWindowSize: %d\n", ctrl->wCompWindowSize);
+    fprintf(stream, "wDelay: %d\n", ctrl->wDelay);
+    fprintf(stream, "dwMaxVideoFrameSize: %u\n", ctrl->dwMaxVideoFrameSize);
+    fprintf(stream, "dwMaxPayloadTransferSize: %u\n", ctrl->dwMaxPayloadTransferSize);
+    fprintf(stream, "bInterfaceNumber: %d\n", ctrl->bInterfaceNumber);
+}
+
+static const char *_uvc_name_for_format_subtype(uint8_t subtype) {
+    switch(subtype) {
+    case UVC_VS_FORMAT_UNCOMPRESSED:
+        return "UncompressedFormat";
+    case UVC_VS_FORMAT_MJPEG:
+        return "MJPEGFormat";
+    case UVC_VS_FORMAT_FRAME_BASED:
+        return "FrameFormat";
+    default:
+        return "Unknown";
+    }
+}
+
+/** @brief Print camera capabilities and configuration.
+ * @ingroup diag
+ *
+ * @param devh UVC device
+ * @param stream Output stream (stderr if NULL)
+ */
+void uvc_print_diag(uvc_device_handle_t *devh, FILE *stream) {
+    if(stream == NULL)
+        stream = stderr;
+
+    if(devh->info->ctrl_if.bcdUVC) {
+        uvc_streaming_interface_t *stream_if;
+        int                        stream_idx = 0;
+
+        uvc_device_descriptor_t *desc;
+        uvc_get_device_descriptor(devh->dev, &desc);
+
+        fprintf(stream, "DEVICE CONFIGURATION (%04x:%04x/%s) ---\n", desc->idVendor, desc->idProduct, desc->serialNumber ? desc->serialNumber : "[none]");
+
+        uvc_free_device_descriptor(desc);
+
+        fprintf(stream, "Status: %s\n", devh->streams ? "streaming" : "idle");
+
+        fprintf(stream,
+                "VideoControl:\n"
+                "\tbcdUVC: 0x%04x\n",
+                devh->info->ctrl_if.bcdUVC);
+
+        DL_FOREACH(devh->info->stream_ifs, stream_if) {
+            uvc_format_desc_t *fmt_desc;
+
+            ++stream_idx;
+
+            fprintf(stream,
+                    "VideoStreaming(%d):\n"
+                    "\tbEndpointAddress: %d\n\tFormats:\n",
+                    stream_idx, stream_if->bEndpointAddress);
+
+            DL_FOREACH(stream_if->format_descs, fmt_desc) {
+                uvc_frame_desc_t *frame_desc;
+                int               i;
+
+                switch(fmt_desc->bDescriptorSubtype) {
+                case UVC_VS_FORMAT_UNCOMPRESSED:
+                case UVC_VS_FORMAT_MJPEG:
+                case UVC_VS_FORMAT_FRAME_BASED:
+                    fprintf(stream,
+                            "\t\t%s(%d)\n"
+                            "\t\t  bits per pixel: %d\n"
+                            "\t\t  GUID: ",
+                            _uvc_name_for_format_subtype(fmt_desc->bDescriptorSubtype), fmt_desc->bFormatIndex, fmt_desc->bBitsPerPixel);
+
+                    for(i = 0; i < 16; ++i)
+                        fprintf(stream, "%02x", fmt_desc->guidFormat[i]);
+
+                    fprintf(stream, " (%4s)\n", fmt_desc->fourccFormat);
+
+                    fprintf(stream,
+                            "\t\t  default frame: %d\n"
+                            "\t\t  aspect ratio: %dx%d\n"
+                            "\t\t  interlace flags: %02x\n"
+                            "\t\t  copy protect: %02x\n",
+                            fmt_desc->bDefaultFrameIndex, fmt_desc->bAspectRatioX, fmt_desc->bAspectRatioY, fmt_desc->bmInterlaceFlags, fmt_desc->bCopyProtect);
+
+                    DL_FOREACH(fmt_desc->frame_descs, frame_desc) {
+                        uint32_t *interval_ptr;
+
+                        fprintf(stream,
+                                "\t\t\tFrameDescriptor(%d)\n"
+                                "\t\t\t  capabilities: %02x\n"
+                                "\t\t\t  size: %dx%d\n"
+                                "\t\t\t  bit rate: %d-%d\n"
+                                "\t\t\t  max frame size: %d\n"
+                                "\t\t\t  default interval: 1/%d\n",
+                                frame_desc->bFrameIndex, frame_desc->bmCapabilities, frame_desc->wWidth, frame_desc->wHeight, frame_desc->dwMinBitRate,
+                                frame_desc->dwMaxBitRate, frame_desc->dwMaxVideoFrameBufferSize, 10000000 / frame_desc->dwDefaultFrameInterval);
+                        if(frame_desc->intervals) {
+                            for(interval_ptr = frame_desc->intervals; *interval_ptr; ++interval_ptr) {
+                                fprintf(stream, "\t\t\t  interval[%d]: 1/%d\n", (int)(interval_ptr - frame_desc->intervals), 10000000 / *interval_ptr);
+                            }
+                        }
+                        else {
+                            fprintf(stream,
+                                    "\t\t\t  min interval[%d] = 1/%d\n"
+                                    "\t\t\t  max interval[%d] = 1/%d\n",
+                                    frame_desc->dwMinFrameInterval, 10000000 / frame_desc->dwMinFrameInterval, frame_desc->dwMaxFrameInterval,
+                                    10000000 / frame_desc->dwMaxFrameInterval);
+                            if(frame_desc->dwFrameIntervalStep)
+                                fprintf(stream, "\t\t\t  interval step[%d] = 1/%d\n", frame_desc->dwFrameIntervalStep,
+                                        10000000 / frame_desc->dwFrameIntervalStep);
+                        }
+                    }
+                    if(fmt_desc->still_frame_desc) {
+                        uvc_still_frame_desc_t *still_frame_desc;
+                        DL_FOREACH(fmt_desc->still_frame_desc, still_frame_desc) {
+                            fprintf(stream,
+                                    "\t\t\tStillFrameDescriptor\n"
+                                    "\t\t\t  bEndPointAddress: %02x\n",
+                                    still_frame_desc->bEndPointAddress);
+                            uvc_still_frame_res_t *imageSizePattern;
+                            DL_FOREACH(still_frame_desc->imageSizePatterns, imageSizePattern) {
+                                fprintf(stream,
+                                        "\t\t\t  wWidth(%d) = %d\n"
+                                        "\t\t\t  wHeight(%d) = %d\n",
+                                        imageSizePattern->bResolutionIndex, imageSizePattern->wWidth, imageSizePattern->bResolutionIndex,
+                                        imageSizePattern->wHeight);
+                            }
+                        }
+                    }
+                    break;
+                default:
+                    fprintf(stream, "\t-UnknownFormat (%d)\n", fmt_desc->bDescriptorSubtype);
+                }
+            }
+        }
+
+        fprintf(stream, "END DEVICE CONFIGURATION\n");
+    }
+    else {
+        fprintf(stream, "uvc_print_diag: Device not configured!\n");
+    }
+}
+
+/** @brief Print all possible frame configuration.
+ * @ingroup diag
+ *
+ * @param devh UVC device
+ * @param stream Output stream (stderr if NULL)
+ */
+void uvc_print_frameformats(uvc_device_handle_t *devh) {
+
+    if(devh->info->ctrl_if.bcdUVC) {
+        uvc_streaming_interface_t *stream_if;
+        int                        stream_idx = 0;
+        DL_FOREACH(devh->info->stream_ifs, stream_if) {
+            uvc_format_desc_t *fmt_desc;
+            ++stream_idx;
+
+            DL_FOREACH(stream_if->format_descs, fmt_desc) {
+                uvc_frame_desc_t *frame_desc;
+                int               i;
+
+                switch(fmt_desc->bDescriptorSubtype) {
+                case UVC_VS_FORMAT_UNCOMPRESSED:
+                case UVC_VS_FORMAT_MJPEG:
+                case UVC_VS_FORMAT_FRAME_BASED:
+                    printf("         \\%s(%d)\n"
+                           "            bits per pixel: %d\n"
+                           "            GUID: ",
+                           _uvc_name_for_format_subtype(fmt_desc->bDescriptorSubtype), fmt_desc->bFormatIndex, fmt_desc->bBitsPerPixel);
+
+                    for(i = 0; i < 16; ++i)
+                        printf("%02x", fmt_desc->guidFormat[i]);
+
+                    printf(" (%4s)\n", fmt_desc->fourccFormat);
+
+                    printf("            default frame: %d\n"
+                           "            aspect ratio: %dx%d\n"
+                           "            interlace flags: %02x\n"
+                           "            copy protect: %02x\n",
+                           fmt_desc->bDefaultFrameIndex, fmt_desc->bAspectRatioX, fmt_desc->bAspectRatioY, fmt_desc->bmInterlaceFlags, fmt_desc->bCopyProtect);
+
+                    DL_FOREACH(fmt_desc->frame_descs, frame_desc) {
+                        uint32_t *interval_ptr;
+
+                        printf("               FrameDescriptor(%d)\n"
+                               "                  capabilities: %02x\n"
+                               "                  size: %dx%d\n"
+                               "                  bit rate: %d-%d\n"
+                               "                  max frame size: %d\n"
+                               "                  default interval: 1/%d\n",
+                               frame_desc->bFrameIndex, frame_desc->bmCapabilities, frame_desc->wWidth, frame_desc->wHeight, frame_desc->dwMinBitRate,
+                               frame_desc->dwMaxBitRate, frame_desc->dwMaxVideoFrameBufferSize, 10000000 / frame_desc->dwDefaultFrameInterval);
+                        if(frame_desc->intervals) {
+                            for(interval_ptr = frame_desc->intervals; *interval_ptr; ++interval_ptr) {
+                                printf("                  interval[%d]: 1/%d\n", (int)(interval_ptr - frame_desc->intervals), 10000000 / *interval_ptr);
+                            }
+                        }
+                        else {
+                            printf("                  min interval[%d] = 1/%d\n"
+                                   "                  max interval[%d] = 1/%d\n",
+                                   frame_desc->dwMinFrameInterval, 10000000 / frame_desc->dwMinFrameInterval, frame_desc->dwMaxFrameInterval,
+                                   10000000 / frame_desc->dwMaxFrameInterval);
+                            if(frame_desc->dwFrameIntervalStep)
+                                printf("                  interval step[%d] = 1/%d\n", frame_desc->dwFrameIntervalStep,
+                                       10000000 / frame_desc->dwFrameIntervalStep);
+                        }
+                    }
+                    break;
+                default:
+                    printf("\t-UnknownFormat (%d)\n", fmt_desc->bDescriptorSubtype);
+                }
+            }
+        }
+    }
+    else {
+        printf("uvc_print_frameformats: Device not configured!\n");
+    }
+}
diff --git a/3rdparty/libuvc/src/src/example.c b/3rdparty/libuvc/src/src/example.c
new file mode 100644
index 00000000..2e6feb9c
--- /dev/null
+++ b/3rdparty/libuvc/src/src/example.c
@@ -0,0 +1,203 @@
+#include "libuvc/libuvc.h"
+#include <stdio.h>
+#include <unistd.h>
+
+/* This callback function runs once per frame. Use it to perform any
+ * quick processing you need, or have it put the frame into your application's
+ * input queue. If this function takes too long, you'll start losing frames. */
+void cb(uvc_frame_t *frame, void *ptr) {
+  uvc_frame_t *bgr;
+  uvc_error_t ret;
+  enum uvc_frame_format *frame_format = (enum uvc_frame_format *)ptr;
+  /* FILE *fp;
+   * static int jpeg_count = 0;
+   * static const char *H264_FILE = "iOSDevLog.h264";
+   * static const char *MJPEG_FILE = ".jpeg";
+   * char filename[16]; */
+
+  /* We'll convert the image from YUV/JPEG to BGR, so allocate space */
+  bgr = uvc_allocate_frame(frame->width * frame->height * 3);
+  if (!bgr) {
+    printf("unable to allocate bgr frame!\n");
+    return;
+  }
+
+  printf("callback! frame_format = %d, width = %d, height = %d, length = %lu, ptr = %d\n",
+    frame->frame_format, frame->width, frame->height, frame->data_bytes, (int) ptr);
+
+  switch (frame->frame_format) {
+  case UVC_FRAME_FORMAT_H264:
+    /* use `ffplay H264_FILE` to play */
+    /* fp = fopen(H264_FILE, "a");
+     * fwrite(frame->data, 1, frame->data_bytes, fp);
+     * fclose(fp); */
+    break;
+  case UVC_COLOR_FORMAT_MJPEG:
+    /* sprintf(filename, "%d%s", jpeg_count++, MJPEG_FILE);
+     * fp = fopen(filename, "w");
+     * fwrite(frame->data, 1, frame->data_bytes, fp);
+     * fclose(fp); */
+    break;
+  case UVC_COLOR_FORMAT_YUYV:
+    /* Do the BGR conversion */
+    ret = uvc_any2bgr(frame, bgr);
+    if (ret) {
+      uvc_perror(ret, "uvc_any2bgr");
+      uvc_free_frame(bgr);
+      return;
+    }
+    break;
+  default:
+    break;
+  }
+
+  /* Call a user function:
+   *
+   * my_type *my_obj = (*my_type) ptr;
+   * my_user_function(ptr, bgr);
+   * my_other_function(ptr, bgr->data, bgr->width, bgr->height);
+   */
+
+  /* Call a C++ method:
+   *
+   * my_type *my_obj = (*my_type) ptr;
+   * my_obj->my_func(bgr);
+   */
+
+  /* Use opencv.highgui to display the image:
+   * 
+   * cvImg = cvCreateImageHeader(
+   *     cvSize(bgr->width, bgr->height),
+   *     IPL_DEPTH_8U,
+   *     3);
+   *
+   * cvSetData(cvImg, bgr->data, bgr->width * 3); 
+   *
+   * cvNamedWindow("Test", CV_WINDOW_AUTOSIZE);
+   * cvShowImage("Test", cvImg);
+   * cvWaitKey(10);
+   *
+   * cvReleaseImageHeader(&cvImg);
+   */
+
+  uvc_free_frame(bgr);
+}
+
+int main(int argc, char **argv) {
+  uvc_context_t *ctx;
+  uvc_device_t *dev;
+  uvc_device_handle_t *devh;
+  uvc_stream_ctrl_t ctrl;
+  uvc_error_t res;
+
+  /* Initialize a UVC service context. Libuvc will set up its own libusb
+   * context. Replace NULL with a libusb_context pointer to run libuvc
+   * from an existing libusb context. */
+  res = uvc_init(&ctx, NULL);
+
+  if (res < 0) {
+    uvc_perror(res, "uvc_init");
+    return res;
+  }
+
+  puts("UVC initialized");
+
+  /* Locates the first attached UVC device, stores in dev */
+  res = uvc_find_device(
+      ctx, &dev,
+      0, 0, NULL); /* filter devices: vendor_id, product_id, "serial_num" */
+
+  if (res < 0) {
+    uvc_perror(res, "uvc_find_device"); /* no devices found */
+  } else {
+    puts("Device found");
+
+    /* Try to open the device: requires exclusive access */
+    res = uvc_open(dev, &devh);
+
+    if (res < 0) {
+      uvc_perror(res, "uvc_open"); /* unable to open device */
+    } else {
+      puts("Device opened");
+
+      /* Print out a message containing all the information that libuvc
+       * knows about the device */
+      uvc_print_diag(devh, stderr);
+
+      const uvc_format_desc_t *format_desc = uvc_get_format_descs(devh);
+      const uvc_frame_desc_t *frame_desc = format_desc->frame_descs;
+      enum uvc_frame_format frame_format;
+      int width = 640;
+      int height = 480;
+      int fps = 30;
+
+      switch (format_desc->bDescriptorSubtype) {
+      case UVC_VS_FORMAT_MJPEG:
+        frame_format = UVC_COLOR_FORMAT_MJPEG;
+        break;
+      case UVC_VS_FORMAT_FRAME_BASED:
+        frame_format = UVC_FRAME_FORMAT_H264;
+        break;
+      default:
+        frame_format = UVC_FRAME_FORMAT_YUYV;
+        break;
+      }
+
+      if (frame_desc) {
+        width = frame_desc->wWidth;
+        height = frame_desc->wHeight;
+        fps = 10000000 / frame_desc->dwDefaultFrameInterval;
+      }
+
+      printf("\nFirst format: (%4s) %dx%d %dfps\n", format_desc->fourccFormat, width, height, fps);
+
+      /* Try to negotiate first stream profile */
+      res = uvc_get_stream_ctrl_format_size(
+          devh, &ctrl, /* result stored in ctrl */
+          frame_format,
+          width, height, fps /* width, height, fps */
+      );
+
+      /* Print out the result */
+      uvc_print_stream_ctrl(&ctrl, stderr);
+
+      if (res < 0) {
+        uvc_perror(res, "get_mode"); /* device doesn't provide a matching stream */
+      } else {
+        /* Start the video stream. The library will call user function cb:
+         *   cb(frame, (void *) 12345)
+         */
+        res = uvc_start_streaming(devh, &ctrl, cb, (void *) 12345, 0);
+
+        if (res < 0) {
+          uvc_perror(res, "start_streaming"); /* unable to start stream */
+        } else {
+          puts("Streaming...");
+
+          uvc_set_ae_mode(devh, 1); /* e.g., turn on auto exposure */
+
+          sleep(10); /* stream for 10 seconds */
+
+          /* End the stream. Blocks until last callback is serviced */
+          uvc_stop_streaming(devh);
+          puts("Done streaming.");
+        }
+      }
+
+      /* Release our handle on the device */
+      uvc_close(devh);
+      puts("Device closed");
+    }
+
+    /* Release the device descriptor */
+    uvc_unref_device(dev);
+  }
+
+  /* Close the UVC context. This closes and cleans up any existing device handles,
+   * and it closes the libusb context if one was not provided. */
+  uvc_exit(ctx);
+  puts("UVC exited");
+
+  return 0;
+}
+
diff --git a/3rdparty/libuvc/src/src/frame-mjpeg.c b/3rdparty/libuvc/src/src/frame-mjpeg.c
new file mode 100644
index 00000000..71cd1083
--- /dev/null
+++ b/3rdparty/libuvc/src/src/frame-mjpeg.c
@@ -0,0 +1,222 @@
+/*********************************************************************
+* Software License Agreement (BSD License)
+*
+*  Copyright (C) 2014 Robert Xiao
+*  All rights reserved.
+*
+*  Redistribution and use in source and binary forms, with or without
+*  modification, are permitted provided that the following conditions
+*  are met:
+*
+*   * Redistributions of source code must retain the above copyright
+*     notice, this list of conditions and the following disclaimer.
+*   * Redistributions in binary form must reproduce the above
+*     copyright notice, this list of conditions and the following
+*     disclaimer in the documentation and/or other materials provided
+*     with the distribution.
+*   * Neither the name of the author nor other contributors may be
+*     used to endorse or promote products derived from this software
+*     without specific prior written permission.
+*
+*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+*  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+*  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+*  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+*  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+*  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+*  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+*  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+*  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+*  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+*  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+*  POSSIBILITY OF SUCH DAMAGE.
+*********************************************************************/
+
+/**
+ * @defgroup frame Frame processing
+ */
+#include "libuvc/libuvc.h"
+#include "libuvc/libuvc_internal.h"
+#include <jpeglib.h>
+#include <setjmp.h>
+
+extern uvc_error_t uvc_ensure_frame_size(uvc_frame_t *frame, size_t need_bytes);
+
+struct error_mgr {
+  struct jpeg_error_mgr super;
+  jmp_buf jmp;
+};
+
+static void _error_exit(j_common_ptr dinfo) {
+  struct error_mgr *myerr = (struct error_mgr *)dinfo->err;
+  (*dinfo->err->output_message)(dinfo);
+  longjmp(myerr->jmp, 1);
+}
+
+/* ISO/IEC 10918-1:1993(E) K.3.3. Default Huffman tables used by MJPEG UVC devices
+   which don't specify a Huffman table in the JPEG stream. */
+static const unsigned char dc_lumi_len[] = 
+  {0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0};
+static const unsigned char dc_lumi_val[] = 
+  {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
+
+static const unsigned char dc_chromi_len[] = 
+  {0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0};
+static const unsigned char dc_chromi_val[] = 
+  {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
+
+static const unsigned char ac_lumi_len[] = 
+  {0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d};
+static const unsigned char ac_lumi_val[] = 
+  {0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12, 0x21,
+   0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07, 0x22, 0x71,
+   0x14, 0x32, 0x81, 0x91, 0xa1, 0x08, 0x23, 0x42, 0xb1,
+   0xc1, 0x15, 0x52, 0xd1, 0xf0, 0x24, 0x33, 0x62, 0x72,
+   0x82, 0x09, 0x0a, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x25,
+   0x26, 0x27, 0x28, 0x29, 0x2a, 0x34, 0x35, 0x36, 0x37,
+   0x38, 0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
+   0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
+   0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a,
+   0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x83,
+   0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x92, 0x93,
+   0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3,
+   0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3,
+   0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3,
+   0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3,
+   0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,
+   0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xf1,
+   0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa};
+static const unsigned char ac_chromi_len[] = 
+  {0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77};
+static const unsigned char ac_chromi_val[] = 
+  {0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21, 0x31,
+   0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71, 0x13, 0x22,
+   0x32, 0x81, 0x08, 0x14, 0x42, 0x91, 0xa1, 0xb1, 0xc1,
+   0x09, 0x23, 0x33, 0x52, 0xf0, 0x15, 0x62, 0x72, 0xd1,
+   0x0a, 0x16, 0x24, 0x34, 0xe1, 0x25, 0xf1, 0x17, 0x18,
+   0x19, 0x1a, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x35, 0x36,
+   0x37, 0x38, 0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47,
+   0x48, 0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
+   0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
+   0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a,
+   0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a,
+   0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a,
+   0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa,
+   0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba,
+   0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca,
+   0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda,
+   0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea,
+   0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa};
+
+#define COPY_HUFF_TABLE(dinfo,tbl,name) do { \
+  if(dinfo->tbl == NULL) dinfo->tbl = jpeg_alloc_huff_table((j_common_ptr)dinfo); \
+  memcpy(dinfo->tbl->bits, name##_len, sizeof(name##_len)); \
+  memset(dinfo->tbl->huffval, 0, sizeof(dinfo->tbl->huffval)); \
+  memcpy(dinfo->tbl->huffval, name##_val, sizeof(name##_val)); \
+} while(0)
+
+static void insert_huff_tables(j_decompress_ptr dinfo) {
+  COPY_HUFF_TABLE(dinfo, dc_huff_tbl_ptrs[0], dc_lumi);
+  COPY_HUFF_TABLE(dinfo, dc_huff_tbl_ptrs[1], dc_chromi);
+  COPY_HUFF_TABLE(dinfo, ac_huff_tbl_ptrs[0], ac_lumi);
+  COPY_HUFF_TABLE(dinfo, ac_huff_tbl_ptrs[1], ac_chromi);
+}
+
+static uvc_error_t uvc_mjpeg_convert(uvc_frame_t *in, uvc_frame_t *out) {
+  struct jpeg_decompress_struct dinfo;
+  struct error_mgr jerr;
+  size_t lines_read;
+  dinfo.err = jpeg_std_error(&jerr.super);
+  jerr.super.error_exit = _error_exit;
+
+  if (setjmp(jerr.jmp)) {
+    goto fail;
+  }
+
+  jpeg_create_decompress(&dinfo);
+  jpeg_mem_src(&dinfo, in->data, in->data_bytes);
+  jpeg_read_header(&dinfo, TRUE);
+
+  if (dinfo.dc_huff_tbl_ptrs[0] == NULL) {
+    /* This frame is missing the Huffman tables: fill in the standard ones */
+    insert_huff_tables(&dinfo);
+  }
+
+  if (out->frame_format == UVC_FRAME_FORMAT_RGB)
+    dinfo.out_color_space = JCS_RGB;
+  else if (out->frame_format == UVC_FRAME_FORMAT_GRAY8)
+    dinfo.out_color_space = JCS_GRAYSCALE;
+  else
+    goto fail;
+
+  dinfo.dct_method = JDCT_IFAST;
+
+  jpeg_start_decompress(&dinfo);
+
+  lines_read = 0;
+  while (dinfo.output_scanline < dinfo.output_height) {
+    unsigned char *buffer[1] = {( unsigned char*) out->data + lines_read * out->step };
+    int num_scanlines;
+
+    num_scanlines = jpeg_read_scanlines(&dinfo, buffer, 1);
+    lines_read += num_scanlines;
+  }
+
+  jpeg_finish_decompress(&dinfo);
+  jpeg_destroy_decompress(&dinfo);
+  return 0;
+
+fail:
+  jpeg_destroy_decompress(&dinfo);
+  return UVC_ERROR_OTHER;
+}
+
+/** @brief Convert an MJPEG frame to RGB
+ * @ingroup frame
+ *
+ * @param in MJPEG frame
+ * @param out RGB frame
+ */
+uvc_error_t uvc_mjpeg2rgb(uvc_frame_t *in, uvc_frame_t *out) {
+  if (in->frame_format != UVC_FRAME_FORMAT_MJPEG)
+    return UVC_ERROR_INVALID_PARAM;
+
+  if (uvc_ensure_frame_size(out, in->width * in->height * 3) < 0)
+    return UVC_ERROR_NO_MEM;
+
+  out->width = in->width;
+  out->height = in->height;
+  out->frame_format = UVC_FRAME_FORMAT_RGB;
+  out->step = in->width * 3;
+  out->sequence = in->sequence;
+  out->capture_time = in->capture_time;
+  out->capture_time_finished = in->capture_time_finished;
+  out->source = in->source;
+
+  return uvc_mjpeg_convert(in, out);
+}
+
+/** @brief Convert an MJPEG frame to GRAY8
+ * @ingroup frame
+ *
+ * @param in MJPEG frame
+ * @param out GRAY8 frame
+ */
+uvc_error_t uvc_mjpeg2gray(uvc_frame_t *in, uvc_frame_t *out) {
+  if (in->frame_format != UVC_FRAME_FORMAT_MJPEG)
+    return UVC_ERROR_INVALID_PARAM;
+
+  if (uvc_ensure_frame_size(out, in->width * in->height) < 0)
+    return UVC_ERROR_NO_MEM;
+
+  out->width = in->width;
+  out->height = in->height;
+  out->frame_format = UVC_FRAME_FORMAT_GRAY8;
+  out->step = in->width;
+  out->sequence = in->sequence;
+  out->capture_time = in->capture_time;
+  out->capture_time_finished = in->capture_time_finished;
+  out->source = in->source;
+
+  return uvc_mjpeg_convert(in, out);
+}
diff --git a/3rdparty/libuvc/src/src/frame.c b/3rdparty/libuvc/src/src/frame.c
new file mode 100644
index 00000000..0a0fe662
--- /dev/null
+++ b/3rdparty/libuvc/src/src/frame.c
@@ -0,0 +1,510 @@
+/*********************************************************************
+ * Software License Agreement (BSD License)
+ *
+ *  Copyright (C) 2010-2012 Ken Tossell
+ *  All rights reserved.
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions
+ *  are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *   * Neither the name of the author nor other contributors may be
+ *     used to endorse or promote products derived from this software
+ *     without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ *  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ *  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ *  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ *  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ *  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ *  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ *  POSSIBILITY OF SUCH DAMAGE.
+ *********************************************************************/
+/**
+ * @defgroup frame Frame processing
+ * @brief Tools for managing frame buffers and converting between image formats
+ */
+#include "libuvc/libuvc.h"
+#include "libuvc/libuvc_internal.h"
+
+/** @internal */
+uvc_error_t uvc_ensure_frame_size(uvc_frame_t *frame, size_t need_bytes) {
+    if(frame->library_owns_data) {
+        if(!frame->data || frame->data_bytes != need_bytes) {
+            frame->data_bytes = need_bytes;
+            frame->data       = realloc(frame->data, frame->data_bytes);
+        }
+        if(!frame->data)
+            return UVC_ERROR_NO_MEM;
+        return UVC_SUCCESS;
+    }
+    else {
+        if(!frame->data || frame->data_bytes < need_bytes)
+            return UVC_ERROR_NO_MEM;
+        return UVC_SUCCESS;
+    }
+}
+
+/** @brief Allocate a frame structure
+ * @ingroup frame
+ *
+ * @param data_bytes Number of bytes to allocate, or zero
+ * @return New frame, or NULL on error
+ */
+uvc_frame_t *uvc_allocate_frame(size_t data_bytes) {
+    uvc_frame_t *frame = malloc(sizeof(*frame));
+
+    if(!frame)
+        return NULL;
+
+    memset(frame, 0, sizeof(*frame));
+
+    frame->library_owns_data = 1;
+
+    if(data_bytes > 0) {
+        frame->data_bytes = data_bytes;
+        frame->data       = malloc(data_bytes);
+
+        if(!frame->data) {
+            free(frame);
+            return NULL;
+        }
+    }
+
+    return frame;
+}
+
+/** @brief Free a frame structure
+ * @ingroup frame
+ *
+ * @param frame Frame to destroy
+ */
+void uvc_free_frame(uvc_frame_t *frame) {
+    if(frame->library_owns_data) {
+        if(frame->data_bytes > 0)
+            free(frame->data);
+        if(frame->metadata_bytes > 0)
+            free(frame->metadata);
+        if(frame->headerdata_bytes > 0)
+            free(frame->headerdata);
+    }
+
+    free(frame);
+}
+
+static inline unsigned char sat(int i) {
+    return (unsigned char)(i >= 255 ? 255 : (i < 0 ? 0 : i));
+}
+
+/** @brief Duplicate a frame, preserving color format
+ * @ingroup frame
+ *
+ * @param in Original frame
+ * @param out Duplicate frame
+ */
+uvc_error_t uvc_duplicate_frame(uvc_frame_t *in, uvc_frame_t *out) {
+    if(uvc_ensure_frame_size(out, in->data_bytes) < 0)
+        return UVC_ERROR_NO_MEM;
+
+    out->width                 = in->width;
+    out->height                = in->height;
+    out->frame_format          = in->frame_format;
+    out->step                  = in->step;
+    out->sequence              = in->sequence;
+    out->capture_time          = in->capture_time;
+    out->capture_time_finished = in->capture_time_finished;
+    out->source                = in->source;
+
+    memcpy(out->data, in->data, in->data_bytes);
+
+    if(in->metadata && in->metadata_bytes > 0) {
+        if(out->metadata_bytes < in->metadata_bytes) {
+            out->metadata = realloc(out->metadata, in->metadata_bytes);
+        }
+        out->metadata_bytes = in->metadata_bytes;
+        memcpy(out->metadata, in->metadata, in->metadata_bytes);
+    }
+
+    if(in->headerdata && in->headerdata_bytes > 0) {
+        if(out->headerdata_bytes < in->headerdata_bytes) {
+            out->headerdata = realloc(out->headerdata, in->headerdata_bytes);
+        }
+        out->headerdata_bytes = in->headerdata_bytes;
+        memcpy(out->headerdata, in->headerdata, in->headerdata_bytes);
+    }
+
+    return UVC_SUCCESS;
+}
+
+#define YUYV2RGB_2(pyuv, prgb)                                                    \
+    {                                                                             \
+        float r   = 1.402f * ((pyuv)[3] - 128);                                   \
+        float g   = -0.34414f * ((pyuv)[1] - 128) - 0.71414f * ((pyuv)[3] - 128); \
+        float b   = 1.772f * ((pyuv)[1] - 128);                                   \
+        (prgb)[0] = sat(pyuv[0] + r);                                             \
+        (prgb)[1] = sat(pyuv[0] + g);                                             \
+        (prgb)[2] = sat(pyuv[0] + b);                                             \
+        (prgb)[3] = sat(pyuv[2] + r);                                             \
+        (prgb)[4] = sat(pyuv[2] + g);                                             \
+        (prgb)[5] = sat(pyuv[2] + b);                                             \
+    }
+#define IYUYV2RGB_2(pyuv, prgb)                                                    \
+    {                                                                              \
+        int r     = (22987 * ((pyuv)[3] - 128)) >> 14;                             \
+        int g     = (-5636 * ((pyuv)[1] - 128) - 11698 * ((pyuv)[3] - 128)) >> 14; \
+        int b     = (29049 * ((pyuv)[1] - 128)) >> 14;                             \
+        (prgb)[0] = sat(*(pyuv) + r);                                              \
+        (prgb)[1] = sat(*(pyuv) + g);                                              \
+        (prgb)[2] = sat(*(pyuv) + b);                                              \
+        (prgb)[3] = sat((pyuv)[2] + r);                                            \
+        (prgb)[4] = sat((pyuv)[2] + g);                                            \
+        (prgb)[5] = sat((pyuv)[2] + b);                                            \
+    }
+#define IYUYV2RGB_16(pyuv, prgb) \
+    IYUYV2RGB_8(pyuv, prgb);     \
+    IYUYV2RGB_8(pyuv + 16, prgb + 24);
+#define IYUYV2RGB_8(pyuv, prgb) \
+    IYUYV2RGB_4(pyuv, prgb);    \
+    IYUYV2RGB_4(pyuv + 8, prgb + 12);
+#define IYUYV2RGB_4(pyuv, prgb) \
+    IYUYV2RGB_2(pyuv, prgb);    \
+    IYUYV2RGB_2(pyuv + 4, prgb + 6);
+
+/** @brief Convert a frame from YUYV to RGB
+ * @ingroup frame
+ *
+ * @param in YUYV frame
+ * @param out RGB frame
+ */
+uvc_error_t uvc_yuyv2rgb(uvc_frame_t *in, uvc_frame_t *out) {
+    if(in->frame_format != UVC_FRAME_FORMAT_YUYV)
+        return UVC_ERROR_INVALID_PARAM;
+
+    if(uvc_ensure_frame_size(out, in->width * in->height * 3) < 0)
+        return UVC_ERROR_NO_MEM;
+
+    out->width                 = in->width;
+    out->height                = in->height;
+    out->frame_format          = UVC_FRAME_FORMAT_RGB;
+    out->step                  = in->width * 3;
+    out->sequence              = in->sequence;
+    out->capture_time          = in->capture_time;
+    out->capture_time_finished = in->capture_time_finished;
+    out->source                = in->source;
+
+    uint8_t *pyuv     = in->data;
+    uint8_t *prgb     = out->data;
+    uint8_t *prgb_end = prgb + out->data_bytes;
+
+    while(prgb < prgb_end) {
+        IYUYV2RGB_8(pyuv, prgb);
+
+        prgb += 3 * 8;
+        pyuv += 2 * 8;
+    }
+
+    return UVC_SUCCESS;
+}
+
+#define IYUYV2BGR_2(pyuv, pbgr)                                                    \
+    {                                                                              \
+        int r     = (22987 * ((pyuv)[3] - 128)) >> 14;                             \
+        int g     = (-5636 * ((pyuv)[1] - 128) - 11698 * ((pyuv)[3] - 128)) >> 14; \
+        int b     = (29049 * ((pyuv)[1] - 128)) >> 14;                             \
+        (pbgr)[0] = sat(*(pyuv) + b);                                              \
+        (pbgr)[1] = sat(*(pyuv) + g);                                              \
+        (pbgr)[2] = sat(*(pyuv) + r);                                              \
+        (pbgr)[3] = sat((pyuv)[2] + b);                                            \
+        (pbgr)[4] = sat((pyuv)[2] + g);                                            \
+        (pbgr)[5] = sat((pyuv)[2] + r);                                            \
+    }
+#define IYUYV2BGR_16(pyuv, pbgr) \
+    IYUYV2BGR_8(pyuv, pbgr);     \
+    IYUYV2BGR_8(pyuv + 16, pbgr + 24);
+#define IYUYV2BGR_8(pyuv, pbgr) \
+    IYUYV2BGR_4(pyuv, pbgr);    \
+    IYUYV2BGR_4(pyuv + 8, pbgr + 12);
+#define IYUYV2BGR_4(pyuv, pbgr) \
+    IYUYV2BGR_2(pyuv, pbgr);    \
+    IYUYV2BGR_2(pyuv + 4, pbgr + 6);
+
+/** @brief Convert a frame from YUYV to BGR
+ * @ingroup frame
+ *
+ * @param in YUYV frame
+ * @param out BGR frame
+ */
+uvc_error_t uvc_yuyv2bgr(uvc_frame_t *in, uvc_frame_t *out) {
+    if(in->frame_format != UVC_FRAME_FORMAT_YUYV)
+        return UVC_ERROR_INVALID_PARAM;
+
+    if(uvc_ensure_frame_size(out, in->width * in->height * 3) < 0)
+        return UVC_ERROR_NO_MEM;
+
+    out->width                 = in->width;
+    out->height                = in->height;
+    out->frame_format          = UVC_FRAME_FORMAT_BGR;
+    out->step                  = in->width * 3;
+    out->sequence              = in->sequence;
+    out->capture_time          = in->capture_time;
+    out->capture_time_finished = in->capture_time_finished;
+    out->source                = in->source;
+
+    uint8_t *pyuv     = in->data;
+    uint8_t *pbgr     = out->data;
+    uint8_t *pbgr_end = pbgr + out->data_bytes;
+
+    while(pbgr < pbgr_end) {
+        IYUYV2BGR_8(pyuv, pbgr);
+
+        pbgr += 3 * 8;
+        pyuv += 2 * 8;
+    }
+
+    return UVC_SUCCESS;
+}
+
+#define IYUYV2Y(pyuv, py) \
+    { (py)[0] = (pyuv[0]); }
+
+/** @brief Convert a frame from YUYV to Y (GRAY8)
+ * @ingroup frame
+ *
+ * @param in YUYV frame
+ * @param out GRAY8 frame
+ */
+uvc_error_t uvc_yuyv2y(uvc_frame_t *in, uvc_frame_t *out) {
+    if(in->frame_format != UVC_FRAME_FORMAT_YUYV)
+        return UVC_ERROR_INVALID_PARAM;
+
+    if(uvc_ensure_frame_size(out, in->width * in->height) < 0)
+        return UVC_ERROR_NO_MEM;
+
+    out->width                 = in->width;
+    out->height                = in->height;
+    out->frame_format          = UVC_FRAME_FORMAT_GRAY8;
+    out->step                  = in->width;
+    out->sequence              = in->sequence;
+    out->capture_time          = in->capture_time;
+    out->capture_time_finished = in->capture_time_finished;
+    out->source                = in->source;
+
+    uint8_t *pyuv   = in->data;
+    uint8_t *py     = out->data;
+    uint8_t *py_end = py + out->data_bytes;
+
+    while(py < py_end) {
+        IYUYV2Y(pyuv, py);
+
+        py += 1;
+        pyuv += 2;
+    }
+
+    return UVC_SUCCESS;
+}
+
+#define IYUYV2UV(pyuv, puv) \
+    { (puv)[0] = (pyuv[1]); }
+
+/** @brief Convert a frame from YUYV to UV (GRAY8)
+ * @ingroup frame
+ *
+ * @param in YUYV frame
+ * @param out GRAY8 frame
+ */
+uvc_error_t uvc_yuyv2uv(uvc_frame_t *in, uvc_frame_t *out) {
+    if(in->frame_format != UVC_FRAME_FORMAT_YUYV)
+        return UVC_ERROR_INVALID_PARAM;
+
+    if(uvc_ensure_frame_size(out, in->width * in->height) < 0)
+        return UVC_ERROR_NO_MEM;
+
+    out->width                 = in->width;
+    out->height                = in->height;
+    out->frame_format          = UVC_FRAME_FORMAT_GRAY8;
+    out->step                  = in->width;
+    out->sequence              = in->sequence;
+    out->capture_time          = in->capture_time;
+    out->capture_time_finished = in->capture_time_finished;
+    out->source                = in->source;
+
+    uint8_t *pyuv    = in->data;
+    uint8_t *puv     = out->data;
+    uint8_t *puv_end = puv + out->data_bytes;
+
+    while(puv < puv_end) {
+        IYUYV2UV(pyuv, puv);
+
+        puv += 1;
+        pyuv += 2;
+    }
+
+    return UVC_SUCCESS;
+}
+
+#define IUYVY2RGB_2(pyuv, prgb)                                                    \
+    {                                                                              \
+        int r     = (22987 * ((pyuv)[2] - 128)) >> 14;                             \
+        int g     = (-5636 * ((pyuv)[0] - 128) - 11698 * ((pyuv)[2] - 128)) >> 14; \
+        int b     = (29049 * ((pyuv)[0] - 128)) >> 14;                             \
+        (prgb)[0] = sat((pyuv)[1] + r);                                            \
+        (prgb)[1] = sat((pyuv)[1] + g);                                            \
+        (prgb)[2] = sat((pyuv)[1] + b);                                            \
+        (prgb)[3] = sat((pyuv)[3] + r);                                            \
+        (prgb)[4] = sat((pyuv)[3] + g);                                            \
+        (prgb)[5] = sat((pyuv)[3] + b);                                            \
+    }
+#define IUYVY2RGB_16(pyuv, prgb) \
+    IUYVY2RGB_8(pyuv, prgb);     \
+    IUYVY2RGB_8(pyuv + 16, prgb + 24);
+#define IUYVY2RGB_8(pyuv, prgb) \
+    IUYVY2RGB_4(pyuv, prgb);    \
+    IUYVY2RGB_4(pyuv + 8, prgb + 12);
+#define IUYVY2RGB_4(pyuv, prgb) \
+    IUYVY2RGB_2(pyuv, prgb);    \
+    IUYVY2RGB_2(pyuv + 4, prgb + 6);
+
+/** @brief Convert a frame from UYVY to RGB
+ * @ingroup frame
+ * @param ini UYVY frame
+ * @param out RGB frame
+ */
+uvc_error_t uvc_uyvy2rgb(uvc_frame_t *in, uvc_frame_t *out) {
+    if(in->frame_format != UVC_FRAME_FORMAT_UYVY)
+        return UVC_ERROR_INVALID_PARAM;
+
+    if(uvc_ensure_frame_size(out, in->width * in->height * 3) < 0)
+        return UVC_ERROR_NO_MEM;
+
+    out->width                 = in->width;
+    out->height                = in->height;
+    out->frame_format          = UVC_FRAME_FORMAT_RGB;
+    out->step                  = in->width * 3;
+    out->sequence              = in->sequence;
+    out->capture_time          = in->capture_time;
+    out->capture_time_finished = in->capture_time_finished;
+    out->source                = in->source;
+
+    uint8_t *pyuv     = in->data;
+    uint8_t *prgb     = out->data;
+    uint8_t *prgb_end = prgb + out->data_bytes;
+
+    while(prgb < prgb_end) {
+        IUYVY2RGB_8(pyuv, prgb);
+
+        prgb += 3 * 8;
+        pyuv += 2 * 8;
+    }
+
+    return UVC_SUCCESS;
+}
+
+#define IUYVY2BGR_2(pyuv, pbgr)                                                    \
+    {                                                                              \
+        int r     = (22987 * ((pyuv)[2] - 128)) >> 14;                             \
+        int g     = (-5636 * ((pyuv)[0] - 128) - 11698 * ((pyuv)[2] - 128)) >> 14; \
+        int b     = (29049 * ((pyuv)[0] - 128)) >> 14;                             \
+        (pbgr)[0] = sat((pyuv)[1] + b);                                            \
+        (pbgr)[1] = sat((pyuv)[1] + g);                                            \
+        (pbgr)[2] = sat((pyuv)[1] + r);                                            \
+        (pbgr)[3] = sat((pyuv)[3] + b);                                            \
+        (pbgr)[4] = sat((pyuv)[3] + g);                                            \
+        (pbgr)[5] = sat((pyuv)[3] + r);                                            \
+    }
+#define IUYVY2BGR_16(pyuv, pbgr) \
+    IUYVY2BGR_8(pyuv, pbgr);     \
+    IUYVY2BGR_8(pyuv + 16, pbgr + 24);
+#define IUYVY2BGR_8(pyuv, pbgr) \
+    IUYVY2BGR_4(pyuv, pbgr);    \
+    IUYVY2BGR_4(pyuv + 8, pbgr + 12);
+#define IUYVY2BGR_4(pyuv, pbgr) \
+    IUYVY2BGR_2(pyuv, pbgr);    \
+    IUYVY2BGR_2(pyuv + 4, pbgr + 6);
+
+/** @brief Convert a frame from UYVY to BGR
+ * @ingroup frame
+ * @param ini UYVY frame
+ * @param out BGR frame
+ */
+uvc_error_t uvc_uyvy2bgr(uvc_frame_t *in, uvc_frame_t *out) {
+    if(in->frame_format != UVC_FRAME_FORMAT_UYVY)
+        return UVC_ERROR_INVALID_PARAM;
+
+    if(uvc_ensure_frame_size(out, in->width * in->height * 3) < 0)
+        return UVC_ERROR_NO_MEM;
+
+    out->width                 = in->width;
+    out->height                = in->height;
+    out->frame_format          = UVC_FRAME_FORMAT_BGR;
+    out->step                  = in->width * 3;
+    out->sequence              = in->sequence;
+    out->capture_time          = in->capture_time;
+    out->capture_time_finished = in->capture_time_finished;
+    out->source                = in->source;
+
+    uint8_t *pyuv     = in->data;
+    uint8_t *pbgr     = out->data;
+    uint8_t *pbgr_end = pbgr + out->data_bytes;
+
+    while(pbgr < pbgr_end) {
+        IUYVY2BGR_8(pyuv, pbgr);
+
+        pbgr += 3 * 8;
+        pyuv += 2 * 8;
+    }
+
+    return UVC_SUCCESS;
+}
+
+/** @brief Convert a frame to RGB
+ * @ingroup frame
+ *
+ * @param in non-RGB frame
+ * @param out RGB frame
+ */
+uvc_error_t uvc_any2rgb(uvc_frame_t *in, uvc_frame_t *out) {
+    switch(in->frame_format) {
+#ifdef LIBUVC_HAS_JPEG
+    case UVC_FRAME_FORMAT_MJPEG:
+        return uvc_mjpeg2rgb(in, out);
+#endif
+    case UVC_FRAME_FORMAT_YUYV:
+        return uvc_yuyv2rgb(in, out);
+    case UVC_FRAME_FORMAT_UYVY:
+        return uvc_uyvy2rgb(in, out);
+    case UVC_FRAME_FORMAT_RGB:
+        return uvc_duplicate_frame(in, out);
+    default:
+        return UVC_ERROR_NOT_SUPPORTED;
+    }
+}
+
+/** @brief Convert a frame to BGR
+ * @ingroup frame
+ *
+ * @param in non-BGR frame
+ * @param out BGR frame
+ */
+uvc_error_t uvc_any2bgr(uvc_frame_t *in, uvc_frame_t *out) {
+    switch(in->frame_format) {
+    case UVC_FRAME_FORMAT_YUYV:
+        return uvc_yuyv2bgr(in, out);
+    case UVC_FRAME_FORMAT_UYVY:
+        return uvc_uyvy2bgr(in, out);
+    case UVC_FRAME_FORMAT_BGR:
+        return uvc_duplicate_frame(in, out);
+    default:
+        return UVC_ERROR_NOT_SUPPORTED;
+    }
+}
diff --git a/3rdparty/libuvc/src/src/init.c b/3rdparty/libuvc/src/src/init.c
new file mode 100644
index 00000000..041fe581
--- /dev/null
+++ b/3rdparty/libuvc/src/src/init.c
@@ -0,0 +1,163 @@
+/*********************************************************************
+* Software License Agreement (BSD License)
+*
+*  Copyright (C) 2010-2012 Ken Tossell
+*  All rights reserved.
+*
+*  Redistribution and use in source and binary forms, with or without
+*  modification, are permitted provided that the following conditions
+*  are met:
+*
+*   * Redistributions of source code must retain the above copyright
+*     notice, this list of conditions and the following disclaimer.
+*   * Redistributions in binary form must reproduce the above
+*     copyright notice, this list of conditions and the following
+*     disclaimer in the documentation and/or other materials provided
+*     with the distribution.
+*   * Neither the name of the author nor other contributors may be
+*     used to endorse or promote products derived from this software
+*     without specific prior written permission.
+*
+*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+*  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+*  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+*  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+*  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+*  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+*  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+*  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+*  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+*  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+*  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+*  POSSIBILITY OF SUCH DAMAGE.
+*********************************************************************/
+/**
+\mainpage libuvc: a cross-platform library for USB video devices
+
+\b libuvc is a library that supports enumeration, control and streaming
+for USB Video Class (UVC) devices, such as consumer webcams.
+
+\section features Features
+\li UVC device \ref device "discovery and management" API
+\li \ref streaming "Video streaming" (device to host) with asynchronous/callback and synchronous/polling modes
+\li Read/write access to standard \ref ctrl "device settings"
+\li \ref frame "Conversion" between various formats: RGB, YUV, JPEG, etc.
+\li Tested on Mac and Linux, portable to Windows and some BSDs
+
+\section roadmap Roadmap
+\li Bulk-mode image capture
+\li One-shot image capture
+\li Improved support for standard settings
+\li Support for "extended" (vendor-defined) settings
+
+\section misc Misc.
+\p The source code can be found at https://github.com/ktossell/libuvc. To build
+the library, install <a href="http://libusb.org/">libusb</a> 1.0+ and run:
+
+\code
+$ git clone https://github.com/ktossell/libuvc.git
+$ cd libuvc
+$ mkdir build
+$ cd build
+$ cmake -DCMAKE_BUILD_TYPE=Release ..
+$ make && make install
+\endcode
+
+\section Example
+In this example, libuvc is used to acquire images in a 30 fps, 640x480
+YUV stream from a UVC device such as a standard webcam.
+
+\include example.c
+
+*/
+
+/**
+ * @defgroup init Library initialization/deinitialization
+ * @brief Setup routines used to construct UVC access contexts
+ */
+#include "libuvc/libuvc.h"
+#include "libuvc/libuvc_internal.h"
+
+/** @internal
+ * @brief Event handler thread
+ * There's one of these per UVC context.
+ * @todo We shouldn't run this if we don't own the USB context
+ */
+void *_uvc_handle_events(void *arg) {
+  uvc_context_t *ctx = (uvc_context_t *) arg;
+
+  while (!ctx->kill_handler_thread)
+    libusb_handle_events_completed(ctx->usb_ctx, &ctx->kill_handler_thread);
+  return NULL;
+}
+
+/** @brief Initializes the UVC context
+ * @ingroup init
+ *
+ * @note If you provide your own USB context, you must handle
+ * libusb event processing using a function such as libusb_handle_events.
+ *
+ * @param[out] pctx The location where the context reference should be stored.
+ * @param[in]  usb_ctx Optional USB context to use
+ * @return Error opening context or UVC_SUCCESS
+ */
+uvc_error_t uvc_init(uvc_context_t **pctx, struct libusb_context *usb_ctx) {
+  uvc_error_t ret = UVC_SUCCESS;
+  uvc_context_t *ctx = calloc(1, sizeof(*ctx));
+
+  if (usb_ctx == NULL) {
+    ret = libusb_init(&ctx->usb_ctx);
+    ctx->own_usb_ctx = 1;
+    if (ret != UVC_SUCCESS) {
+      free(ctx);
+      ctx = NULL;
+    }
+  } else {
+    ctx->own_usb_ctx = 0;
+    ctx->usb_ctx = usb_ctx;
+  }
+
+  if (ctx != NULL)
+    *pctx = ctx;
+
+  return ret;
+}
+
+/**
+ * @brief Closes the UVC context, shutting down any active cameras.
+ * @ingroup init
+ *
+ * @note This function invalides any existing references to the context's
+ * cameras.
+ *
+ * If no USB context was provided to #uvc_init, the UVC-specific USB
+ * context will be destroyed.
+ *
+ * @param ctx UVC context to shut down
+ */
+void uvc_exit(uvc_context_t *ctx) {
+  uvc_device_handle_t *devh;
+
+  DL_FOREACH(ctx->open_devices, devh) {
+    uvc_close(devh);
+  }
+
+  if (ctx->own_usb_ctx)
+    libusb_exit(ctx->usb_ctx);
+
+  free(ctx);
+}
+
+/**
+ * @internal
+ * @brief Spawns a handler thread for the context
+ * @ingroup init
+ *
+ * This should be called at the end of a successful uvc_open if no devices
+ * are already open (and being handled).
+ */
+void uvc_start_handler_thread(uvc_context_t *ctx) {
+  if (ctx->own_usb_ctx)
+    pthread_create(&ctx->handler_thread, NULL, _uvc_handle_events, (void*) ctx);
+}
+
diff --git a/3rdparty/libuvc/src/src/misc.c b/3rdparty/libuvc/src/src/misc.c
new file mode 100644
index 00000000..8ce850fd
--- /dev/null
+++ b/3rdparty/libuvc/src/src/misc.c
@@ -0,0 +1,58 @@
+/*********************************************************************
+* Software License Agreement (BSD License)
+*
+*  Copyright (C) 2010-2012 Ken Tossell
+*  All rights reserved.
+*
+*  Redistribution and use in source and binary forms, with or without
+*  modification, are permitted provided that the following conditions
+*  are met:
+*
+*   * Redistributions of source code must retain the above copyright
+*     notice, this list of conditions and the following disclaimer.
+*   * Redistributions in binary form must reproduce the above
+*     copyright notice, this list of conditions and the following
+*     disclaimer in the documentation and/or other materials provided
+*     with the distribution.
+*   * Neither the name of the author nor other contributors may be
+*     used to endorse or promote products derived from this software
+*     without specific prior written permission.
+*
+*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+*  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+*  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+*  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+*  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+*  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+*  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+*  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+*  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+*  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+*  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+*  POSSIBILITY OF SUCH DAMAGE.
+*********************************************************************/
+#include <string.h>
+#include <stdlib.h>
+
+#if __APPLE__
+char *strndup(const char *s, size_t n) {
+  size_t src_n = 0;
+  const char *sp = s;
+  char *d;
+
+  while (*sp++)
+    src_n++;
+
+  if (src_n < n)
+    n = src_n;
+
+  d = malloc(n + 1);
+
+  memcpy(d, s, n);
+  
+  d[n] = '\0';
+
+  return d;
+}
+#endif
+
diff --git a/3rdparty/libuvc/src/src/stream.c b/3rdparty/libuvc/src/src/stream.c
new file mode 100644
index 00000000..52be1b9d
--- /dev/null
+++ b/3rdparty/libuvc/src/src/stream.c
@@ -0,0 +1,1535 @@
+/*********************************************************************
+ * Software License Agreement (BSD License)
+ *
+ *  Copyright (C) 2010-2012 Ken Tossell
+ *  All rights reserved.
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions
+ *  are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *   * Neither the name of the author nor other contributors may be
+ *     used to endorse or promote products derived from this software
+ *     without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ *  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ *  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ *  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ *  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ *  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ *  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ *  POSSIBILITY OF SUCH DAMAGE.
+ *********************************************************************/
+/**
+ * @defgroup streaming Streaming control functions
+ * @brief Tools for creating, managing and consuming video streams
+ */
+
+#include "libuvc/libuvc.h"
+#include "libuvc/libuvc_internal.h"
+#include "errno.h"
+
+#ifdef _MSC_VER
+
+#define DELTA_EPOCH_IN_MICROSECS 116444736000000000Ui64
+
+// gettimeofday - get time of day for Windows;
+// A gettimeofday implementation for Microsoft Windows;
+// Public domain code, author "ponnada";
+int gettimeofday(struct timeval *tv, struct timezone *tz) {
+    FILETIME         ft;
+    unsigned __int64 tmpres = 0;
+    static int       tzflag = 0;
+    if(NULL != tv) {
+        GetSystemTimeAsFileTime(&ft);
+        tmpres |= ft.dwHighDateTime;
+        tmpres <<= 32;
+        tmpres |= ft.dwLowDateTime;
+        tmpres /= 10;
+        tmpres -= DELTA_EPOCH_IN_MICROSECS;
+        tv->tv_sec  = (long)(tmpres / 1000000UL);
+        tv->tv_usec = (long)(tmpres % 1000000UL);
+    }
+    return 0;
+}
+#endif  // _MSC_VER
+uvc_frame_desc_t *uvc_find_frame_desc_stream(uvc_stream_handle_t *strmh, uint16_t format_id, uint16_t frame_id);
+uvc_frame_desc_t *uvc_find_frame_desc(uvc_device_handle_t *devh, uint16_t format_id, uint16_t frame_id);
+void             *_uvc_user_caller(void *arg);
+void              _uvc_populate_frame(uvc_stream_handle_t *strmh);
+
+static uvc_streaming_interface_t *_uvc_get_stream_if(uvc_device_handle_t *devh, int interface_idx);
+static uvc_stream_handle_t       *_uvc_get_stream_by_interface(uvc_device_handle_t *devh, int interface_idx);
+
+struct format_table_entry {
+    enum uvc_frame_format  format;
+    uint8_t                abstract_fmt;
+    uint8_t                guid[16];
+    int                    children_count;
+    enum uvc_frame_format *children;
+};
+
+struct format_table_entry *_get_format_entry(enum uvc_frame_format format) {
+#define ABS_FMT(_fmt, _num, ...)                                                                                                                     \
+    case _fmt: {                                                                                                                                     \
+        static enum uvc_frame_format     _fmt##_children[] = __VA_ARGS__;                                                                            \
+        static struct format_table_entry _fmt##_entry      = { _fmt, 0, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, _num, _fmt##_children }; \
+        return &_fmt##_entry;                                                                                                                        \
+    }
+
+#define FMT(_fmt, ...)                                                                     \
+    case _fmt: {                                                                           \
+        static struct format_table_entry _fmt##_entry = { _fmt, 0, __VA_ARGS__, 0, NULL }; \
+        return &_fmt##_entry;                                                              \
+    }
+
+    switch(format) {
+        /* Define new formats here */
+        ABS_FMT(UVC_FRAME_FORMAT_ANY, 2, { UVC_FRAME_FORMAT_UNCOMPRESSED, UVC_FRAME_FORMAT_COMPRESSED })
+
+        ABS_FMT(UVC_FRAME_FORMAT_UNCOMPRESSED, 15,
+                { UVC_FRAME_FORMAT_YUYV, UVC_FRAME_FORMAT_UYVY, UVC_FRAME_FORMAT_GRAY8, UVC_FRAME_FORMAT_GRAY16, UVC_FRAME_FORMAT_NV12, UVC_FRAME_FORMAT_BGR,
+                  UVC_FRAME_FORMAT_Y8, UVC_FRAME_FORMAT_Y10, UVC_FRAME_FORMAT_Y11, UVC_FRAME_FORMAT_Y12, UVC_FRAME_FORMAT_Y14, UVC_FRAME_FORMAT_Z16,
+                  UVC_FRAME_FORMAT_YV12, UVC_FRAME_FORMAT_BY8, UVC_FRAME_FORMAT_BA81 })
+        FMT(UVC_FRAME_FORMAT_YUYV, { 'Y', 'U', 'Y', '2', 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71 })
+        FMT(UVC_FRAME_FORMAT_UYVY, { 'U', 'Y', 'V', 'Y', 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71 })
+        FMT(UVC_FRAME_FORMAT_GRAY8, { 'Y', '8', '0', '0', 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71 })
+        FMT(UVC_FRAME_FORMAT_GRAY16, { 'Y', '1', '6', ' ', 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71 })
+        FMT(UVC_FRAME_FORMAT_Y8, { 'Y', '8', ' ', ' ', 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71 })
+        FMT(UVC_FRAME_FORMAT_Y10, { 'Y', '1', '0', ' ', 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71 })
+        FMT(UVC_FRAME_FORMAT_Y11, { 'Y', '1', '1', ' ', 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71 })
+        FMT(UVC_FRAME_FORMAT_Y12, { 'Y', '1', '2', ' ', 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71 })
+        FMT(UVC_FRAME_FORMAT_Y14, { 'Y', '1', '4', ' ', 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71 })
+        FMT(UVC_FRAME_FORMAT_Z16, { 'Z', '1', '6', ' ', 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71 })
+        FMT(UVC_FRAME_FORMAT_YV12, { 'Y', 'V', '1', '2', 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71 })
+        FMT(UVC_FRAME_FORMAT_NV12, { 'N', 'V', '1', '2', 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71 })
+        FMT(UVC_FRAME_FORMAT_BGR, { 0x7d, 0xeb, 0x36, 0xe4, 0x4f, 0x52, 0xce, 0x11, 0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70 })
+        FMT(UVC_FRAME_FORMAT_BY8, { 'B', 'Y', '8', ' ', 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71 })
+        FMT(UVC_FRAME_FORMAT_BA81, { 'B', 'A', '8', '1', 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71 })
+        FMT(UVC_FRAME_FORMAT_SGRBG8, { 'G', 'R', 'B', 'G', 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71 })
+        FMT(UVC_FRAME_FORMAT_SGBRG8, { 'G', 'B', 'R', 'G', 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71 })
+        FMT(UVC_FRAME_FORMAT_SRGGB8, { 'R', 'G', 'G', 'B', 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71 })
+        FMT(UVC_FRAME_FORMAT_SBGGR8, { 'B', 'G', 'G', 'R', 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71 })
+        ABS_FMT(UVC_FRAME_FORMAT_COMPRESSED, 3, { UVC_FRAME_FORMAT_MJPEG, UVC_FRAME_FORMAT_H264, UVC_FRAME_FORMAT_RVL })
+        FMT(UVC_FRAME_FORMAT_MJPEG, { 'M', 'J', 'P', 'G' })
+        FMT(UVC_FRAME_FORMAT_H264, { 'H', '2', '6', '4', 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71 })
+        FMT(UVC_FRAME_FORMAT_HEVC, { 'H', 'E', 'V', 'C', 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71 })
+        FMT(UVC_FRAME_FORMAT_I420, { 'I', '4', '2', '0', 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71 })
+        FMT(UVC_FRAME_FORMAT_RVL, { 'R', 'V', 'L', ' ', 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71 })
+    default:
+        return NULL;
+    }
+
+#undef ABS_FMT
+#undef FMT
+}
+
+static uint8_t _uvc_frame_format_matches_guid(enum uvc_frame_format fmt, uint8_t guid[16]) {
+    struct format_table_entry *format;
+    int                        child_idx;
+
+    format = _get_format_entry(fmt);
+    if(!format)
+        return 0;
+
+    if(!format->abstract_fmt && !memcmp(guid, format->guid, 16))
+        return 1;
+
+    for(child_idx = 0; child_idx < format->children_count; child_idx++) {
+        if(_uvc_frame_format_matches_guid(format->children[child_idx], guid))
+            return 1;
+    }
+
+    return 0;
+}
+
+static enum uvc_frame_format uvc_frame_format_for_guid(uint8_t guid[16]) {
+    struct format_table_entry *format;
+    enum uvc_frame_format      fmt;
+
+    for(fmt = 0; fmt < UVC_FRAME_FORMAT_COUNT; ++fmt) {
+        format = _get_format_entry(fmt);
+        if(!format || format->abstract_fmt)
+            continue;
+        if(!memcmp(format->guid, guid, 16))
+            return format->format;
+    }
+
+    return UVC_FRAME_FORMAT_UNKNOWN;
+}
+
+/** @internal
+ * Run a streaming control query
+ * @param[in] devh UVC device
+ * @param[in,out] ctrl Control block
+ * @param[in] probe Whether this is a probe query or a commit query
+ * @param[in] req Query type
+ */
+uvc_error_t uvc_query_stream_ctrl(uvc_device_handle_t *devh, uvc_stream_ctrl_t *ctrl, uint8_t probe, enum uvc_req_code req) {
+    uint8_t     buf[34];
+    size_t      len;
+    uvc_error_t err;
+
+    memset(buf, 0, sizeof(buf));
+
+    if(devh->info->ctrl_if.bcdUVC >= 0x0110)
+        len = 34;
+    else
+        len = 26;
+
+    /* prepare for a SET transfer */
+    if(req == UVC_SET_CUR) {
+        SHORT_TO_SW(ctrl->bmHint, buf);
+        buf[2] = ctrl->bFormatIndex;
+        buf[3] = ctrl->bFrameIndex;
+        INT_TO_DW(ctrl->dwFrameInterval, buf + 4);
+        SHORT_TO_SW(ctrl->wKeyFrameRate, buf + 8);
+        SHORT_TO_SW(ctrl->wPFrameRate, buf + 10);
+        SHORT_TO_SW(ctrl->wCompQuality, buf + 12);
+        SHORT_TO_SW(ctrl->wCompWindowSize, buf + 14);
+        SHORT_TO_SW(ctrl->wDelay, buf + 16);
+        INT_TO_DW(ctrl->dwMaxVideoFrameSize, buf + 18);
+        INT_TO_DW(ctrl->dwMaxPayloadTransferSize, buf + 22);
+
+        if(len == 34) {
+            INT_TO_DW(ctrl->dwClockFrequency, buf + 26);
+            buf[30] = ctrl->bmFramingInfo;
+            buf[31] = ctrl->bPreferredVersion;
+            buf[32] = ctrl->bMinVersion;
+            buf[33] = ctrl->bMaxVersion;
+            /** @todo support UVC 1.1 */
+        }
+    }
+
+    /* do the transfer */
+    err = libusb_control_transfer(devh->usb_devh, req == UVC_SET_CUR ? 0x21 : 0xA1, req, probe ? (UVC_VS_PROBE_CONTROL << 8) : (UVC_VS_COMMIT_CONTROL << 8),
+                                  ctrl->bInterfaceNumber, buf, len, 0);
+
+    if(err <= 0) {
+        return err;
+    }
+
+    /* now decode following a GET transfer */
+    if(req != UVC_SET_CUR) {
+        ctrl->bmHint                   = SW_TO_SHORT(buf);
+        ctrl->bFormatIndex             = buf[2];
+        ctrl->bFrameIndex              = buf[3];
+        ctrl->dwFrameInterval          = DW_TO_INT(buf + 4);
+        ctrl->wKeyFrameRate            = SW_TO_SHORT(buf + 8);
+        ctrl->wPFrameRate              = SW_TO_SHORT(buf + 10);
+        ctrl->wCompQuality             = SW_TO_SHORT(buf + 12);
+        ctrl->wCompWindowSize          = SW_TO_SHORT(buf + 14);
+        ctrl->wDelay                   = SW_TO_SHORT(buf + 16);
+        ctrl->dwMaxVideoFrameSize      = DW_TO_INT(buf + 18);
+        ctrl->dwMaxPayloadTransferSize = DW_TO_INT(buf + 22);
+
+        if(len == 34) {
+            ctrl->dwClockFrequency  = DW_TO_INT(buf + 26);
+            ctrl->bmFramingInfo     = buf[30];
+            ctrl->bPreferredVersion = buf[31];
+            ctrl->bMinVersion       = buf[32];
+            ctrl->bMaxVersion       = buf[33];
+            /** @todo support UVC 1.1 */
+        }
+        else
+            ctrl->dwClockFrequency = devh->info->ctrl_if.dwClockFrequency;
+
+        /* fix up block for cameras that fail to set dwMax* */
+        if(ctrl->dwMaxVideoFrameSize == 0) {
+            uvc_frame_desc_t *frame = uvc_find_frame_desc(devh, ctrl->bFormatIndex, ctrl->bFrameIndex);
+
+            if(frame) {
+                ctrl->dwMaxVideoFrameSize = frame->dwMaxVideoFrameBufferSize;
+            }
+        }
+    }
+
+    return UVC_SUCCESS;
+}
+
+/** @internal
+ * Run a streaming control query
+ * @param[in] devh UVC device
+ * @param[in,out] ctrl Control block
+ * @param[in] probe Whether this is a probe query or a commit query
+ * @param[in] req Query type
+ */
+uvc_error_t uvc_query_still_ctrl(uvc_device_handle_t *devh, uvc_still_ctrl_t *still_ctrl, uint8_t probe, enum uvc_req_code req) {
+
+    uint8_t      buf[11];
+    const size_t len = 11;
+    uvc_error_t  err;
+
+    memset(buf, 0, sizeof(buf));
+
+    if(req == UVC_SET_CUR) {
+        /* prepare for a SET transfer */
+        buf[0] = still_ctrl->bFormatIndex;
+        buf[1] = still_ctrl->bFrameIndex;
+        buf[2] = still_ctrl->bCompressionIndex;
+        INT_TO_DW(still_ctrl->dwMaxVideoFrameSize, buf + 3);
+        INT_TO_DW(still_ctrl->dwMaxPayloadTransferSize, buf + 7);
+    }
+
+    /* do the transfer */
+    err = libusb_control_transfer(devh->usb_devh, req == UVC_SET_CUR ? 0x21 : 0xA1, req,
+                                  probe ? (UVC_VS_STILL_PROBE_CONTROL << 8) : (UVC_VS_STILL_COMMIT_CONTROL << 8), still_ctrl->bInterfaceNumber, buf, len, 0);
+
+    if(err <= 0) {
+        return err;
+    }
+
+    /* now decode following a GET transfer */
+    if(req != UVC_SET_CUR) {
+        still_ctrl->bFormatIndex             = buf[0];
+        still_ctrl->bFrameIndex              = buf[1];
+        still_ctrl->bCompressionIndex        = buf[2];
+        still_ctrl->dwMaxVideoFrameSize      = DW_TO_INT(buf + 3);
+        still_ctrl->dwMaxPayloadTransferSize = DW_TO_INT(buf + 7);
+    }
+
+    return UVC_SUCCESS;
+}
+
+/** Initiate a method 2 (in stream) still capture
+ * @ingroup streaming
+ *
+ * @param[in] devh Device handle
+ * @param[in] still_ctrl Still capture control block
+ */
+uvc_error_t uvc_trigger_still(uvc_device_handle_t *devh, uvc_still_ctrl_t *still_ctrl) {
+    uvc_stream_handle_t       *stream;
+    uvc_streaming_interface_t *stream_if;
+    uint8_t                    buf;
+    uvc_error_t                err;
+
+    /* Stream must be running for method 2 to work */
+    stream = _uvc_get_stream_by_interface(devh, still_ctrl->bInterfaceNumber);
+    if(!stream || !stream->running)
+        return UVC_ERROR_NOT_SUPPORTED;
+
+    /* Only method 2 is supported */
+    stream_if = _uvc_get_stream_if(devh, still_ctrl->bInterfaceNumber);
+    if(!stream_if || stream_if->bStillCaptureMethod != 2)
+        return UVC_ERROR_NOT_SUPPORTED;
+
+    /* prepare for a SET transfer */
+    buf = 1;
+
+    /* do the transfer */
+    err = libusb_control_transfer(devh->usb_devh,
+                                  0x21,  // type set
+                                  UVC_SET_CUR, (UVC_VS_STILL_IMAGE_TRIGGER_CONTROL << 8), still_ctrl->bInterfaceNumber, &buf, 1, 0);
+
+    if(err <= 0) {
+        return err;
+    }
+
+    return UVC_SUCCESS;
+}
+
+/** @brief Reconfigure stream with a new stream format.
+ * @ingroup streaming
+ *
+ * This may be executed whether or not the stream is running.
+ *
+ * @param[in] strmh Stream handle
+ * @param[in] ctrl Control block, processed using {uvc_probe_stream_ctrl} or
+ *             {uvc_get_stream_ctrl_format_size}
+ */
+uvc_error_t uvc_stream_ctrl(uvc_stream_handle_t *strmh, uvc_stream_ctrl_t *ctrl) {
+    uvc_error_t ret;
+
+    if(strmh->stream_if->bInterfaceNumber != ctrl->bInterfaceNumber)
+        return UVC_ERROR_INVALID_PARAM;
+
+    /* @todo Allow the stream to be modified without restarting the stream */
+    if(strmh->running)
+        return UVC_ERROR_BUSY;
+
+    ret = uvc_query_stream_ctrl(strmh->devh, ctrl, 0, UVC_SET_CUR);
+    if(ret != UVC_SUCCESS)
+        return ret;
+
+    strmh->cur_ctrl = *ctrl;
+    return UVC_SUCCESS;
+}
+
+/** @internal
+ * @brief Find the descriptor for a specific frame configuration
+ * @param stream_if Stream interface
+ * @param format_id Index of format class descriptor
+ * @param frame_id Index of frame descriptor
+ */
+static uvc_frame_desc_t *_uvc_find_frame_desc_stream_if(uvc_streaming_interface_t *stream_if, uint16_t format_id, uint16_t frame_id) {
+
+    uvc_format_desc_t *format = NULL;
+    uvc_frame_desc_t  *frame  = NULL;
+
+    DL_FOREACH(stream_if->format_descs, format) {
+        if(format->bFormatIndex == format_id) {
+            DL_FOREACH(format->frame_descs, frame) {
+                if(frame->bFrameIndex == frame_id)
+                    return frame;
+            }
+        }
+    }
+
+    return NULL;
+}
+
+uvc_frame_desc_t *uvc_find_frame_desc_stream(uvc_stream_handle_t *strmh, uint16_t format_id, uint16_t frame_id) {
+    return _uvc_find_frame_desc_stream_if(strmh->stream_if, format_id, frame_id);
+}
+
+/** @internal
+ * @brief Find the descriptor for a specific frame configuration
+ * @param devh UVC device
+ * @param format_id Index of format class descriptor
+ * @param frame_id Index of frame descriptor
+ */
+uvc_frame_desc_t *uvc_find_frame_desc(uvc_device_handle_t *devh, uint16_t format_id, uint16_t frame_id) {
+
+    uvc_streaming_interface_t *stream_if;
+    uvc_frame_desc_t          *frame;
+
+    DL_FOREACH(devh->info->stream_ifs, stream_if) {
+        frame = _uvc_find_frame_desc_stream_if(stream_if, format_id, frame_id);
+        if(frame)
+            return frame;
+    }
+
+    return NULL;
+}
+
+/** Get a negotiated streaming control block for some common parameters.
+ * @ingroup streaming
+ *
+ * @param[in] devh Device handle
+ * @param[in,out] ctrl Control block
+ * @param[in] format_class Type of streaming format
+ * @param[in] width Desired frame width
+ * @param[in] height Desired frame height
+ * @param[in] fps Frame rate, frames per second
+ */
+uvc_error_t uvc_get_stream_ctrl_format_size(uvc_device_handle_t *devh, uvc_stream_ctrl_t *ctrl, enum uvc_frame_format cf, int width, int height, int fps) {
+    uvc_streaming_interface_t *stream_if;
+
+    /* find a matching frame descriptor and interval */
+    DL_FOREACH(devh->info->stream_ifs, stream_if) {
+        uvc_format_desc_t *format;
+
+        DL_FOREACH(stream_if->format_descs, format) {
+            uvc_frame_desc_t *frame;
+
+            if(!_uvc_frame_format_matches_guid(cf, format->guidFormat))
+                continue;
+
+            DL_FOREACH(format->frame_descs, frame) {
+                if(frame->wWidth != width || frame->wHeight != height)
+                    continue;
+
+                uint32_t *interval;
+
+                ctrl->bInterfaceNumber = stream_if->bInterfaceNumber;
+                UVC_DEBUG("claiming streaming interface %d", stream_if->bInterfaceNumber);
+                uvc_claim_if(devh, ctrl->bInterfaceNumber);
+                /* get the max values */
+                uvc_query_stream_ctrl(devh, ctrl, 1, UVC_GET_MAX);
+
+                if(frame->intervals) {
+                    for(interval = frame->intervals; *interval; ++interval) {
+                        // allow a fps rate of zero to mean "accept first rate available"
+                        if(10000000 / *interval == (unsigned int)fps || fps == 0) {
+
+                            ctrl->bmHint          = (1 << 0); /* don't negotiate interval */
+                            ctrl->bFormatIndex    = format->bFormatIndex;
+                            ctrl->bFrameIndex     = frame->bFrameIndex;
+                            ctrl->dwFrameInterval = *interval;
+
+                            goto found;
+                        }
+                    }
+                }
+                else {
+                    uint32_t interval_100ns  = 10000000 / fps;
+                    uint32_t interval_offset = interval_100ns - frame->dwMinFrameInterval;
+
+                    if(interval_100ns >= frame->dwMinFrameInterval && interval_100ns <= frame->dwMaxFrameInterval
+                       && !(interval_offset && (interval_offset % frame->dwFrameIntervalStep))) {
+
+                        ctrl->bmHint          = (1 << 0);
+                        ctrl->bFormatIndex    = format->bFormatIndex;
+                        ctrl->bFrameIndex     = frame->bFrameIndex;
+                        ctrl->dwFrameInterval = interval_100ns;
+
+                        goto found;
+                    }
+                }
+            }
+        }
+    }
+
+    return UVC_ERROR_INVALID_MODE;
+
+found:
+    return uvc_probe_stream_ctrl(devh, ctrl);
+}
+
+/** Get a negotiated still control block for some common parameters.
+ * @ingroup streaming
+ *
+ * @param[in] devh Device handle
+ * @param[in] ctrl Control block
+ * @param[in, out] still_ctrl Still capture control block
+ * @param[in] width Desired frame width
+ * @param[in] height Desired frame height
+ */
+uvc_error_t uvc_get_still_ctrl_format_size(uvc_device_handle_t *devh, uvc_stream_ctrl_t *ctrl, uvc_still_ctrl_t *still_ctrl, int width, int height) {
+    uvc_streaming_interface_t *stream_if;
+    uvc_still_frame_desc_t    *still;
+    uvc_format_desc_t         *format;
+    uvc_still_frame_res_t     *sizePattern;
+
+    stream_if = _uvc_get_stream_if(devh, ctrl->bInterfaceNumber);
+
+    /* Only method 2 is supported */
+    if(!stream_if || stream_if->bStillCaptureMethod != 2)
+        return UVC_ERROR_NOT_SUPPORTED;
+
+    DL_FOREACH(stream_if->format_descs, format) {
+
+        if(ctrl->bFormatIndex != format->bFormatIndex)
+            continue;
+
+        /* get the max values */
+        uvc_query_still_ctrl(devh, still_ctrl, 1, UVC_GET_MAX);
+
+        // look for still format
+        DL_FOREACH(format->still_frame_desc, still) {
+            DL_FOREACH(still->imageSizePatterns, sizePattern) {
+
+                if(sizePattern->wWidth != width || sizePattern->wHeight != height)
+                    continue;
+
+                still_ctrl->bInterfaceNumber  = ctrl->bInterfaceNumber;
+                still_ctrl->bFormatIndex      = format->bFormatIndex;
+                still_ctrl->bFrameIndex       = sizePattern->bResolutionIndex;
+                still_ctrl->bCompressionIndex = 0;  // TODO support compression index
+                goto found;
+            }
+        }
+    }
+
+    return UVC_ERROR_INVALID_MODE;
+
+found:
+    return uvc_probe_still_ctrl(devh, still_ctrl);
+}
+
+/** @internal
+ * Negotiate streaming parameters with the device
+ *
+ * @param[in] devh UVC device
+ * @param[in,out] ctrl Control block
+ */
+uvc_error_t uvc_probe_stream_ctrl(uvc_device_handle_t *devh, uvc_stream_ctrl_t *ctrl) {
+
+    uvc_query_stream_ctrl(devh, ctrl, 1, UVC_SET_CUR);
+
+    uvc_query_stream_ctrl(devh, ctrl, 1, UVC_GET_CUR);
+
+    /** @todo make sure that worked */
+    return UVC_SUCCESS;
+}
+
+/** @internal
+ * Negotiate still parameters with the device
+ *
+ * @param[in] devh UVC device
+ * @param[in,out] still_ctrl Still capture control block
+ */
+uvc_error_t uvc_probe_still_ctrl(uvc_device_handle_t *devh, uvc_still_ctrl_t *still_ctrl) {
+
+    int res = uvc_query_still_ctrl(devh, still_ctrl, 1, UVC_SET_CUR);
+
+    if(res == UVC_SUCCESS) {
+        res = uvc_query_still_ctrl(devh, still_ctrl, 1, UVC_GET_CUR);
+
+        if(res == UVC_SUCCESS) {
+            res = uvc_query_still_ctrl(devh, still_ctrl, 0, UVC_SET_CUR);
+        }
+    }
+
+    return res;
+}
+
+/** @internal
+ * @brief Swap the working buffer with the presented buffer and notify consumers
+ */
+void _uvc_swap_buffers(uvc_stream_handle_t *strmh) {
+    uint8_t *tmp_buf;
+
+    pthread_mutex_lock(&strmh->cb_mutex);
+
+    (void)clock_gettime(CLOCK_MONOTONIC, &strmh->capture_time_finished);
+
+    /* swap the buffers */
+    tmp_buf              = strmh->holdbuf;
+    strmh->hold_bytes    = strmh->got_bytes;
+    strmh->holdbuf       = strmh->outbuf;
+    strmh->outbuf        = tmp_buf;
+    strmh->hold_last_scr = strmh->last_scr;
+    strmh->hold_pts      = strmh->pts;
+    strmh->hold_seq      = strmh->seq;
+
+    /* swap metadata buffer */
+    tmp_buf                = strmh->meta_holdbuf;
+    strmh->meta_holdbuf    = strmh->meta_outbuf;
+    strmh->meta_outbuf     = tmp_buf;
+    strmh->meta_hold_bytes = strmh->meta_got_bytes;
+
+    /* swap pyload header buffer */
+    tmp_buf                          = strmh->payload_header_holdbuf;
+    strmh->payload_header_holdbuf    = strmh->payload_header_outbuf;
+    strmh->payload_header_outbuf     = tmp_buf;
+    strmh->payload_header_hold_bytes = strmh->payload_header_got_bytes;
+
+    pthread_cond_broadcast(&strmh->cb_cond);
+    pthread_mutex_unlock(&strmh->cb_mutex);
+
+    strmh->seq++;
+    strmh->got_bytes                = 0;
+    strmh->meta_got_bytes           = 0;
+    strmh->last_scr                 = 0;
+    strmh->pts                      = 0;
+    strmh->payload_header_got_bytes = 0;
+}
+
+/** @internal
+ * @brief Process a payload transfer
+ *
+ * Processes stream, places frames into buffer, signals listeners
+ * (such as user callback thread and any polling thread) on new frame
+ *
+ * @param payload Contents of the payload transfer, either a packet (isochronous) or a full
+ * transfer (bulk mode)
+ * @param payload_len Length of the payload transfer
+ */
+void _uvc_process_payload(uvc_stream_handle_t *strmh, uint8_t *payload, size_t payload_len) {
+    size_t  header_len;
+    uint8_t header_info;
+    size_t  data_len;
+
+    /* magic numbers for identifying header packets from some iSight cameras */
+    static uint8_t isight_tag[] = { 0x11, 0x22, 0x33, 0x44, 0xde, 0xad, 0xbe, 0xef, 0xde, 0xad, 0xfa, 0xce };
+
+    /* ignore empty payload transfers */
+    if(payload_len == 0)
+        return;
+
+    /* Certain iSight cameras have strange behavior: They send header
+     * information in a packet with no image data, and then the following
+     * packets have only image data, with no more headers until the next frame.
+     *
+     * The iSight header: len(1), flags(1 or 2), 0x11223344(4),
+     * 0xdeadbeefdeadface(8), ??(16)
+     */
+
+    if(strmh->devh->is_isight && (payload_len < 14 || memcmp(isight_tag, payload + 2, sizeof(isight_tag)))
+       && (payload_len < 15 || memcmp(isight_tag, payload + 3, sizeof(isight_tag)))) {
+        /* The payload transfer doesn't have any iSight magic, so it's all image data */
+        header_len = 0;
+        data_len   = payload_len;
+    }
+    else {
+        header_len = payload[0];
+
+        if(header_len > payload_len) {
+            UVC_DEBUG("bogus packet: actual_len=%zd, header_len=%zd\n", payload_len, header_len);
+            return;
+        }
+
+        if(strmh->devh->is_isight)
+            data_len = 0;
+        else
+            data_len = payload_len - header_len;
+    }
+
+    if(strmh->payload_header_got_bytes == 0) {
+        strmh->payload_header_got_bytes = header_len;
+        memcpy(strmh->payload_header_outbuf, payload, header_len);
+    }
+
+    if(header_len < 2) {
+        header_info = 0;
+    }
+    else {
+        /** @todo we should be checking the end-of-header bit */
+        size_t variable_offset = 2;
+
+        header_info = payload[1];
+
+        if(header_info & 0x40) {
+            UVC_DEBUG("bad packet: error bit set");
+            return;
+        }
+
+        if(strmh->fid != (header_info & 1) && strmh->got_bytes != 0) {
+            /* The frame ID bit was flipped, but we have image data sitting
+               around from prior transfers. This means the camera didn't send
+               an EOF for the last transfer of the previous frame. */
+            _uvc_swap_buffers(strmh);
+        }
+
+        strmh->fid = header_info & 1;
+
+        if(header_info & (1 << 2)) {
+            strmh->pts = DW_TO_INT(payload + variable_offset);
+            variable_offset += 4;
+        }
+
+        if(header_info & (1 << 3)) {
+            /** @todo read the SOF token counter */
+            strmh->last_scr = DW_TO_INT(payload + variable_offset);
+            variable_offset += 6;
+        }
+
+        if(header_len > variable_offset) {
+            // Metadata is attached to header
+            // JDRN-1846 解决linux 开关流metadata内存越界crash问题
+            size_t meta_size = strmh->meta_got_bytes + header_len - variable_offset;
+            if(meta_size < LIBUVC_XFER_META_BUF_SIZE) {
+                memcpy(strmh->meta_outbuf + strmh->meta_got_bytes, payload + variable_offset, header_len - variable_offset);
+                strmh->meta_got_bytes += header_len - variable_offset;
+            }
+        }
+    }
+
+    if(data_len > 0) {
+        // bugfix：USB不稳定或带宽不足时会丢包，有概率会丢到EOF包，导致strmh->got_bytes过大，memcpy越界
+        if(strmh->got_bytes + data_len < LIBUVC_XFER_BUF_SIZE) {
+            memcpy(strmh->outbuf + strmh->got_bytes, payload + header_len, data_len);
+            strmh->got_bytes += data_len;
+        }
+
+        if(header_info & (1 << 1) || strmh->got_bytes + data_len >= LIBUVC_XFER_BUF_SIZE) {
+            /* The EOF bit is set, so publish the complete frame */
+            _uvc_swap_buffers(strmh);
+        }
+    }
+}
+
+/** @internal
+ * @brief Stream transfer callback
+ *
+ * Processes stream, places frames into buffer, signals listeners
+ * (such as user callback thread and any polling thread) on new frame
+ *
+ * @param transfer Active transfer
+ */
+void LIBUSB_CALL _uvc_stream_callback(struct libusb_transfer *transfer) {
+    uvc_stream_handle_t *strmh = transfer->user_data;
+
+    int resubmit = 1;
+
+    switch(transfer->status) {
+    case LIBUSB_TRANSFER_COMPLETED:
+        if(transfer->num_iso_packets == 0) {
+            /* This is a bulk mode transfer, so it just has one payload transfer */
+            _uvc_process_payload(strmh, transfer->buffer, transfer->actual_length);
+        }
+        else {
+            /* This is an isochronous mode transfer, so each packet has a payload transfer */
+            int packet_id;
+
+            for(packet_id = 0; packet_id < transfer->num_iso_packets; ++packet_id) {
+                uint8_t                             *pktbuf;
+                struct libusb_iso_packet_descriptor *pkt;
+
+                pkt = transfer->iso_packet_desc + packet_id;
+
+                if(pkt->status != 0) {
+                    UVC_DEBUG("bad packet (isochronous transfer); status: %d", pkt->status);
+                    continue;
+                }
+
+                pktbuf = libusb_get_iso_packet_buffer_simple(transfer, packet_id);
+
+                _uvc_process_payload(strmh, pktbuf, pkt->actual_length);
+            }
+        }
+        break;
+    case LIBUSB_TRANSFER_CANCELLED:
+    case LIBUSB_TRANSFER_ERROR:
+    case LIBUSB_TRANSFER_NO_DEVICE: {
+        uint32_t i;
+        UVC_DEBUG("not retrying transfer, status = %d", transfer->status);
+        pthread_mutex_lock(&strmh->cb_mutex);
+
+        /* Mark transfer as deleted. */
+        for(i = 0; i < strmh->actual_transfer_buff_num; i++) {
+            if(strmh->transfers[i] == transfer) {
+                UVC_DEBUG("Freeing transfer %d (%p)", i, transfer);
+                free(transfer->buffer);
+                libusb_free_transfer(transfer);
+                strmh->transfers[i] = NULL;
+                break;
+            }
+        }
+        if(i == strmh->actual_transfer_buff_num) {
+            UVC_DEBUG("transfer %p not found; not freeing!", transfer);
+        }
+
+        resubmit = 0;
+
+        pthread_cond_broadcast(&strmh->cb_cond);
+        pthread_mutex_unlock(&strmh->cb_mutex);
+
+        break;
+    }
+    case LIBUSB_TRANSFER_TIMED_OUT:
+    case LIBUSB_TRANSFER_STALL:
+    case LIBUSB_TRANSFER_OVERFLOW:
+        UVC_DEBUG("retrying transfer, status = %d", transfer->status);
+        break;
+    }
+
+    if(resubmit) {
+        if(strmh->running) {
+            int libusbRet = libusb_submit_transfer(transfer);
+            if(libusbRet < 0) {
+                uint32_t i;
+                pthread_mutex_lock(&strmh->cb_mutex);
+
+                /* Mark transfer as deleted. */
+                for(i = 0; i < strmh->actual_transfer_buff_num; i++) {
+                    if(strmh->transfers[i] == transfer) {
+                        UVC_DEBUG("Freeing failed transfer %d (%p)", i, transfer);
+                        free(transfer->buffer);
+                        libusb_free_transfer(transfer);
+                        strmh->transfers[i] = NULL;
+                        break;
+                    }
+                }
+                if(i == strmh->actual_transfer_buff_num) {
+                    UVC_DEBUG("failed transfer %p not found; not freeing!", transfer);
+                }
+
+                pthread_cond_broadcast(&strmh->cb_cond);
+                pthread_mutex_unlock(&strmh->cb_mutex);
+            }
+        }
+        else {
+            uint32_t i;
+            pthread_mutex_lock(&strmh->cb_mutex);
+
+            /* Mark transfer as deleted. */
+            for(i = 0; i < strmh->actual_transfer_buff_num; i++) {
+                if(strmh->transfers[i] == transfer) {
+                    UVC_DEBUG("Freeing orphan transfer %d (%p)", i, transfer);
+                    free(transfer->buffer);
+                    libusb_free_transfer(transfer);
+                    strmh->transfers[i] = NULL;
+                    break;
+                }
+            }
+            if(i == strmh->actual_transfer_buff_num) {
+                UVC_DEBUG("orphan transfer %p not found; not freeing!", transfer);
+            }
+
+            pthread_cond_broadcast(&strmh->cb_cond);
+            pthread_mutex_unlock(&strmh->cb_mutex);
+        }
+    }
+}
+
+/** Begin streaming video from the camera into the callback function.
+ * @ingroup streaming
+ *
+ * @param devh UVC device
+ * @param ctrl Control block, processed using {uvc_probe_stream_ctrl} or
+ *             {uvc_get_stream_ctrl_format_size}
+ * @param cb   User callback function. See {uvc_frame_callback_t} for restrictions.
+ * @param flags Stream setup flags, currently undefined. Set this to zero. The lower bit
+ * is reserved for backward compatibility.
+ */
+uvc_error_t uvc_start_streaming(uvc_device_handle_t *devh, uvc_stream_ctrl_t *ctrl, uvc_frame_callback_t *cb, void *user_ptr, uint8_t flags) {
+    uvc_error_t          ret;
+    uvc_stream_handle_t *strmh;
+
+    ret = uvc_stream_open_ctrl(devh, &strmh, ctrl);
+    if(ret != UVC_SUCCESS)
+        return ret;
+
+    strmh->actual_transfer_buff_num = LIBUVC_NUM_TRANSFER_BUFS;
+
+    ret = uvc_stream_start(strmh, cb, user_ptr, flags);
+
+    if(ret == UVC_ERROR_NO_MEM) {
+        for(uint32_t i = 0; i < strmh->actual_transfer_buff_num; i++) {
+            if(strmh->transfers[i] != NULL) {
+                free(strmh->transfers[i]->buffer);
+                libusb_free_transfer(strmh->transfers[i]);
+                strmh->transfers[i] = NULL;
+            }
+        }
+        return ret;
+    }
+    else if(ret != UVC_SUCCESS) {
+        uvc_stream_close(strmh);
+        return ret;
+    }
+
+    return UVC_SUCCESS;
+}
+
+uvc_error_t uvc_start_streaming_A(uvc_device_handle_t *devh, uvc_stream_ctrl_t *ctrl, uvc_frame_callback_t *cb, void *user_ptr, uint8_t flags, int32_t bufNum) {
+    uvc_error_t          ret;
+    uvc_stream_handle_t *strmh;
+
+    ret = uvc_stream_open_ctrl(devh, &strmh, ctrl);
+    if(ret != UVC_SUCCESS)
+        return ret;
+
+    strmh->actual_transfer_buff_num = LIBUVC_NUM_TRANSFER_BUFS;
+    if(bufNum > 0 && bufNum <= LIBUVC_NUM_TRANSFER_BUFS) {
+        strmh->actual_transfer_buff_num = bufNum;
+    }
+
+    ret = uvc_stream_start(strmh, cb, user_ptr, flags);
+    if(ret == UVC_ERROR_NO_MEM) {
+        for(uint32_t i = 0; i < strmh->actual_transfer_buff_num; i++) {
+            if(strmh->transfers[i] != NULL) {
+                free(strmh->transfers[i]->buffer);
+                libusb_free_transfer(strmh->transfers[i]);
+                strmh->transfers[i] = NULL;
+            }
+        }
+        return ret;
+    }
+    else if(ret != UVC_SUCCESS) {
+        uvc_stream_close(strmh);
+        return ret;
+    }
+
+    return UVC_SUCCESS;
+}
+
+/** Begin streaming video from the camera into the callback function.
+ * @ingroup streaming
+ *
+ * @deprecated The stream type (bulk vs. isochronous) will be determined by the
+ * type of interface associated with the uvc_stream_ctrl_t parameter, regardless
+ * of whether the caller requests isochronous streaming. Please switch to
+ * uvc_start_streaming().
+ *
+ * @param devh UVC device
+ * @param ctrl Control block, processed using {uvc_probe_stream_ctrl} or
+ *             {uvc_get_stream_ctrl_format_size}
+ * @param cb   User callback function. See {uvc_frame_callback_t} for restrictions.
+ */
+uvc_error_t uvc_start_iso_streaming(uvc_device_handle_t *devh, uvc_stream_ctrl_t *ctrl, uvc_frame_callback_t *cb, void *user_ptr) {
+    return uvc_start_streaming(devh, ctrl, cb, user_ptr, 0);
+}
+
+static uvc_stream_handle_t *_uvc_get_stream_by_interface(uvc_device_handle_t *devh, int interface_idx) {
+    uvc_stream_handle_t *strmh;
+
+    DL_FOREACH(devh->streams, strmh) {
+        if(strmh->stream_if->bInterfaceNumber == interface_idx)
+            return strmh;
+    }
+
+    return NULL;
+}
+
+static uvc_streaming_interface_t *_uvc_get_stream_if(uvc_device_handle_t *devh, int interface_idx) {
+    uvc_streaming_interface_t *stream_if;
+
+    DL_FOREACH(devh->info->stream_ifs, stream_if) {
+        if(stream_if->bInterfaceNumber == interface_idx)
+            return stream_if;
+    }
+
+    return NULL;
+}
+
+/** Open a new video stream.
+ * @ingroup streaming
+ *
+ * @param devh UVC device
+ * @param ctrl Control block, processed using {uvc_probe_stream_ctrl} or
+ *             {uvc_get_stream_ctrl_format_size}
+ */
+uvc_error_t uvc_stream_open_ctrl(uvc_device_handle_t *devh, uvc_stream_handle_t **strmhp, uvc_stream_ctrl_t *ctrl) {
+    /* Chosen frame and format descriptors */
+    uvc_stream_handle_t       *strmh = NULL;
+    uvc_streaming_interface_t *stream_if;
+    uvc_error_t                ret;
+
+    UVC_ENTER();
+
+    if(_uvc_get_stream_by_interface(devh, ctrl->bInterfaceNumber) != NULL) {
+        ret = UVC_ERROR_BUSY; /* Stream is already opened */
+        goto fail;
+    }
+
+    stream_if = _uvc_get_stream_if(devh, ctrl->bInterfaceNumber);
+    if(!stream_if) {
+        ret = UVC_ERROR_INVALID_PARAM;
+        goto fail;
+    }
+
+    strmh = calloc(1, sizeof(*strmh));
+    if(!strmh) {
+        ret = UVC_ERROR_NO_MEM;
+        goto fail;
+    }
+    strmh->devh                    = devh;
+    strmh->stream_if               = stream_if;
+    strmh->frame.library_owns_data = 1;
+
+    ret = uvc_claim_if(strmh->devh, strmh->stream_if->bInterfaceNumber);
+    if(ret != UVC_SUCCESS)
+        goto fail;
+
+    ret = uvc_stream_ctrl(strmh, ctrl);
+    if(ret != UVC_SUCCESS)
+        goto fail;
+
+    // Set up the streaming status and data space
+    strmh->running = 0;
+    /** @todo take only what we need */
+    strmh->outbuf  = malloc(LIBUVC_XFER_BUF_SIZE);
+    strmh->holdbuf = malloc(LIBUVC_XFER_BUF_SIZE);
+
+    strmh->meta_outbuf  = malloc(LIBUVC_XFER_META_BUF_SIZE);
+    strmh->meta_holdbuf = malloc(LIBUVC_XFER_META_BUF_SIZE);
+
+    strmh->payload_header_outbuf  = malloc(LIBUVC_XFER_PAYLOAD_HEADER_BUF_SIZE);
+    strmh->payload_header_holdbuf = malloc(LIBUVC_XFER_PAYLOAD_HEADER_BUF_SIZE);
+
+    pthread_mutex_init(&strmh->cb_mutex, NULL);
+    pthread_cond_init(&strmh->cb_cond, NULL);
+
+    DL_APPEND(devh->streams, strmh);
+
+    *strmhp = strmh;
+
+    UVC_EXIT(0);
+    return UVC_SUCCESS;
+
+fail:
+    if(strmh)
+        free(strmh);
+    UVC_EXIT(ret);
+    return ret;
+}
+
+/** Begin streaming video from the stream into the callback function.
+ * @ingroup streaming
+ *
+ * @param strmh UVC stream
+ * @param cb   User callback function. See {uvc_frame_callback_t} for restrictions.
+ * @param flags Stream setup flags, currently undefined. Set this to zero. The lower bit
+ * is reserved for backward compatibility.
+ */
+uvc_error_t uvc_stream_start(uvc_stream_handle_t *strmh, uvc_frame_callback_t *cb, void *user_ptr, uint8_t flags) {
+    (void)flags;
+    /* USB interface we'll be using */
+    const struct libusb_interface *interface;
+    int                            interface_id;
+    char                           isochronous;
+    uvc_frame_desc_t              *frame_desc;
+    uvc_format_desc_t             *format_desc;
+    uvc_stream_ctrl_t             *ctrl;
+    uvc_error_t                    ret;
+    /* Total amount of data per transfer */
+    size_t                  total_transfer_size = 0;
+    struct libusb_transfer *transfer;
+    uint32_t                    transfer_id;
+
+    ctrl = &strmh->cur_ctrl;
+
+    UVC_ENTER();
+
+    if(strmh->running) {
+        UVC_EXIT(UVC_ERROR_BUSY);
+        return UVC_ERROR_BUSY;
+    }
+
+    strmh->running  = 1;
+    strmh->seq      = 1;
+    strmh->fid      = 0;
+    strmh->pts      = 0;
+    strmh->last_scr = 0;
+
+    frame_desc = uvc_find_frame_desc_stream(strmh, ctrl->bFormatIndex, ctrl->bFrameIndex);
+    if(!frame_desc) {
+        ret = UVC_ERROR_INVALID_PARAM;
+        goto fail;
+    }
+    format_desc = frame_desc->parent;
+
+    strmh->frame_format = uvc_frame_format_for_guid(format_desc->guidFormat);
+    if(strmh->frame_format == UVC_FRAME_FORMAT_UNKNOWN) {
+        ret = UVC_ERROR_NOT_SUPPORTED;
+        goto fail;
+    }
+
+    // Get the interface that provides the chosen format and frame configuration
+    interface_id = strmh->stream_if->bInterfaceNumber;
+    interface    = &strmh->devh->info->config->interface[interface_id];
+
+    /* A VS interface uses isochronous transfers iff it has multiple altsettings.
+     * (UVC 1.5: 2.4.3. VideoStreaming Interface) */
+    isochronous = interface->num_altsetting > 1;
+
+    if(isochronous) {
+        /* For isochronous streaming, we choose an appropriate altsetting for the endpoint
+         * and set up several transfers */
+        const struct libusb_interface_descriptor *altsetting = 0;
+        const struct libusb_endpoint_descriptor  *endpoint   = 0;
+        /* The greatest number of bytes that the device might provide, per packet, in this
+         * configuration */
+        size_t config_bytes_per_packet;
+        /* Number of packets per transfer */
+        size_t packets_per_transfer = 0;
+        /* Size of packet transferable from the chosen endpoint */
+        size_t endpoint_bytes_per_packet = 0;
+        /* Index of the altsetting */
+        int alt_idx, ep_idx;
+
+        config_bytes_per_packet = strmh->cur_ctrl.dwMaxPayloadTransferSize;
+
+        /* Go through the altsettings and find one whose packets are at least
+         * as big as our format's maximum per-packet usage. Assume that the
+         * packet sizes are increasing. */
+        for(alt_idx = 0; alt_idx < interface->num_altsetting; alt_idx++) {
+            altsetting                = interface->altsetting + alt_idx;
+            endpoint_bytes_per_packet = 0;
+
+            /* Find the endpoint with the number specified in the VS header */
+            for(ep_idx = 0; ep_idx < altsetting->bNumEndpoints; ep_idx++) {
+                endpoint = altsetting->endpoint + ep_idx;
+
+                struct libusb_ss_endpoint_companion_descriptor *ep_comp = 0;
+                libusb_get_ss_endpoint_companion_descriptor(NULL, endpoint, &ep_comp);
+                if(ep_comp) {
+                    endpoint_bytes_per_packet = ep_comp->wBytesPerInterval;
+                    libusb_free_ss_endpoint_companion_descriptor(ep_comp);
+                    break;
+                }
+                else {
+                    if(endpoint->bEndpointAddress == format_desc->parent->bEndpointAddress) {
+                        endpoint_bytes_per_packet = endpoint->wMaxPacketSize;
+                        // wMaxPacketSize: [unused:2 (multiplier-1):3 size:11]
+                        endpoint_bytes_per_packet = (endpoint_bytes_per_packet & 0x07ff) * (((endpoint_bytes_per_packet >> 11) & 3) + 1);
+                        break;
+                    }
+                }
+            }
+
+            if(endpoint_bytes_per_packet >= config_bytes_per_packet) {
+                /* Transfers will be at most one frame long: Divide the maximum frame size
+                 * by the size of the endpoint and round up */
+                packets_per_transfer = (ctrl->dwMaxVideoFrameSize + endpoint_bytes_per_packet - 1) / endpoint_bytes_per_packet;
+
+                /* But keep a reasonable limit: Otherwise we start dropping data */
+                if(packets_per_transfer > 32)
+                    packets_per_transfer = 32;
+
+                total_transfer_size = packets_per_transfer * endpoint_bytes_per_packet;
+                break;
+            }
+        }
+
+        /* If we searched through all the altsettings and found nothing usable */
+        if(alt_idx == interface->num_altsetting) {
+            ret = UVC_ERROR_INVALID_MODE;
+            goto fail;
+        }
+
+        /* Select the altsetting */
+        ret = libusb_set_interface_alt_setting(strmh->devh->usb_devh, altsetting->bInterfaceNumber, altsetting->bAlternateSetting);
+        if(ret != UVC_SUCCESS) {
+            UVC_DEBUG("libusb_set_interface_alt_setting failed");
+            goto fail;
+        }
+
+        /* Set up the transfers */
+        for(transfer_id = 0; transfer_id < strmh->actual_transfer_buff_num; ++transfer_id) {
+            transfer                          = libusb_alloc_transfer(packets_per_transfer);
+            strmh->transfers[transfer_id]     = transfer;
+            strmh->transfer_bufs[transfer_id] = malloc(total_transfer_size);
+
+            libusb_fill_iso_transfer(transfer, strmh->devh->usb_devh, format_desc->parent->bEndpointAddress, strmh->transfer_bufs[transfer_id],
+                                     total_transfer_size, packets_per_transfer, _uvc_stream_callback, (void *)strmh, 6000);
+
+            libusb_set_iso_packet_lengths(transfer, endpoint_bytes_per_packet);
+        }
+    }
+    else {
+        for(transfer_id = 0; transfer_id < strmh->actual_transfer_buff_num; ++transfer_id) {
+            transfer                          = libusb_alloc_transfer(0);
+            strmh->transfers[transfer_id]     = transfer;
+            strmh->transfer_bufs[transfer_id] = malloc(strmh->cur_ctrl.dwMaxPayloadTransferSize);
+            libusb_fill_bulk_transfer(transfer, strmh->devh->usb_devh, format_desc->parent->bEndpointAddress, strmh->transfer_bufs[transfer_id],
+                                      strmh->cur_ctrl.dwMaxPayloadTransferSize, _uvc_stream_callback, (void *)strmh, 6000);
+        }
+    }
+
+    strmh->user_cb  = cb;
+    strmh->user_ptr = user_ptr;
+
+    /* If the user wants it, set up a thread that calls the user's function
+     * with the contents of each frame.
+     */
+    if(cb) {
+        pthread_create(&strmh->cb_thread, NULL, _uvc_user_caller, (void *)strmh);
+    }
+
+    for(transfer_id = 0; transfer_id < strmh->actual_transfer_buff_num; transfer_id++) {
+        ret = libusb_submit_transfer(strmh->transfers[transfer_id]);
+        if(ret != UVC_SUCCESS) {
+            UVC_DEBUG("libusb_submit_transfer failed: %d", ret);
+            break;
+        }
+    }
+
+    if(ret != UVC_SUCCESS && transfer_id > 0) {
+        for(; transfer_id < strmh->actual_transfer_buff_num; transfer_id++) {
+            free(strmh->transfers[transfer_id]->buffer);
+            libusb_free_transfer(strmh->transfers[transfer_id]);
+            strmh->transfers[transfer_id] = 0;
+        }
+        ret = UVC_SUCCESS;
+    }
+
+    UVC_EXIT(ret);
+    return ret;
+fail:
+    strmh->running = 0;
+    UVC_EXIT(ret);
+    return ret;
+}
+
+/** Begin streaming video from the stream into the callback function.
+ * @ingroup streaming
+ *
+ * @deprecated The stream type (bulk vs. isochronous) will be determined by the
+ * type of interface associated with the uvc_stream_ctrl_t parameter, regardless
+ * of whether the caller requests isochronous streaming. Please switch to
+ * uvc_stream_start().
+ *
+ * @param strmh UVC stream
+ * @param cb   User callback function. See {uvc_frame_callback_t} for restrictions.
+ */
+uvc_error_t uvc_stream_start_iso(uvc_stream_handle_t *strmh, uvc_frame_callback_t *cb, void *user_ptr) {
+    return uvc_stream_start(strmh, cb, user_ptr, 0);
+}
+
+/** @internal
+ * @brief User callback runner thread
+ * @note There should be at most one of these per currently streaming device
+ * @param arg Device handle
+ */
+void *_uvc_user_caller(void *arg) {
+    uvc_stream_handle_t *strmh = (uvc_stream_handle_t *)arg;
+
+    uint32_t last_seq = 0;
+
+    do {
+        pthread_mutex_lock(&strmh->cb_mutex);
+
+        while(strmh->running && last_seq == strmh->hold_seq) {
+            pthread_cond_wait(&strmh->cb_cond, &strmh->cb_mutex);
+        }
+
+        if(!strmh->running) {
+            pthread_mutex_unlock(&strmh->cb_mutex);
+            break;
+        }
+
+        last_seq = strmh->hold_seq;
+        _uvc_populate_frame(strmh);
+
+        pthread_mutex_unlock(&strmh->cb_mutex);
+        // add pts
+        strmh->frame.pts = strmh->hold_pts;
+
+        strmh->user_cb(&strmh->frame, strmh->user_ptr);
+    } while(1);
+
+    return NULL;  // return value ignored
+}
+
+/** @internal
+ * @brief Populate the fields of a frame to be handed to user code
+ * must be called with stream cb lock held!
+ */
+void _uvc_populate_frame(uvc_stream_handle_t *strmh) {
+    uvc_frame_t      *frame = &strmh->frame;
+    uvc_frame_desc_t *frame_desc;
+
+    /** @todo this stuff that hits the main config cache should really happen
+     * in start() so that only one thread hits these data. all of this stuff
+     * is going to be reopen_on_change anyway
+     */
+
+    frame_desc = uvc_find_frame_desc(strmh->devh, strmh->cur_ctrl.bFormatIndex, strmh->cur_ctrl.bFrameIndex);
+
+    frame->frame_format = strmh->frame_format;
+
+    frame->width  = frame_desc->wWidth;
+    frame->height = frame_desc->wHeight;
+
+    switch(frame->frame_format) {
+    case UVC_FRAME_FORMAT_BGR:
+        frame->step = frame->width * 3;
+        break;
+    case UVC_FRAME_FORMAT_YUYV:
+        frame->step = frame->width * 2;
+        break;
+    case UVC_FRAME_FORMAT_NV12:
+        frame->step = frame->width;
+        break;
+    case UVC_FRAME_FORMAT_MJPEG:
+        frame->step = 0;
+        break;
+    case UVC_FRAME_FORMAT_H264:
+        frame->step = 0;
+        break;
+    default:
+        frame->step = 0;
+        break;
+    }
+
+    frame->sequence              = strmh->hold_seq;
+    frame->capture_time_finished = strmh->capture_time_finished;
+
+    /* copy the image data from the hold buffer to the frame (unnecessary extra buf?) */
+    if(frame->data_bytes < strmh->hold_bytes) {
+        frame->data = realloc(frame->data, strmh->hold_bytes);
+    }
+    frame->data_bytes = strmh->hold_bytes;
+    memcpy(frame->data, strmh->holdbuf, frame->data_bytes);
+
+    if(strmh->meta_hold_bytes > 0) {
+        if(frame->metadata_bytes < strmh->meta_hold_bytes) {
+            frame->metadata = realloc(frame->metadata, strmh->meta_hold_bytes);
+        }
+        frame->metadata_bytes = strmh->meta_hold_bytes;
+        memcpy(frame->metadata, strmh->meta_holdbuf, frame->metadata_bytes);
+    }
+
+    if(strmh->payload_header_hold_bytes > 0) {
+        if(frame->payload_header_bytes < strmh->payload_header_hold_bytes) {
+            frame->payload_header = realloc(frame->payload_header, strmh->payload_header_hold_bytes);
+        }
+        frame->payload_header_bytes = strmh->payload_header_hold_bytes;
+        memcpy(frame->payload_header, strmh->payload_header_holdbuf, frame->payload_header_bytes);
+    }
+    // else {
+    //     printf("strmh->payload_header_hold_bytes is invalid,size:%ld\n", strmh->payload_header_hold_bytes);
+    // }
+}
+
+/** Poll for a frame
+ * @ingroup streaming
+ *
+ * @param devh UVC device
+ * @param[out] frame Location to store pointer to captured frame (NULL on error)
+ * @param timeout_us >0: Wait at most N microseconds; 0: Wait indefinitely; -1: return immediately
+ */
+uvc_error_t uvc_stream_get_frame(uvc_stream_handle_t *strmh, uvc_frame_t **frame, int32_t timeout_us) {
+    time_t          add_secs;
+    time_t          add_nsecs;
+    struct timespec ts;
+    struct timeval  tv;
+
+    if(!strmh->running)
+        return UVC_ERROR_INVALID_PARAM;
+
+    if(strmh->user_cb)
+        return UVC_ERROR_CALLBACK_EXISTS;
+
+    pthread_mutex_lock(&strmh->cb_mutex);
+
+    if(strmh->last_polled_seq < strmh->hold_seq) {
+        _uvc_populate_frame(strmh);
+        *frame                 = &strmh->frame;
+        strmh->last_polled_seq = strmh->hold_seq;
+    }
+    else if(timeout_us != -1) {
+        if(timeout_us == 0) {
+            pthread_cond_wait(&strmh->cb_cond, &strmh->cb_mutex);
+        }
+        else {
+            add_secs   = timeout_us / 1000000;
+            add_nsecs  = (timeout_us % 1000000) * 1000;
+            ts.tv_sec  = 0;
+            ts.tv_nsec = 0;
+
+#if _POSIX_TIMERS > 0
+            clock_gettime(CLOCK_REALTIME, &ts);
+#else
+            gettimeofday(&tv, NULL);
+            ts.tv_sec  = tv.tv_sec;
+            ts.tv_nsec = tv.tv_usec * 1000;
+#endif
+
+            ts.tv_sec += add_secs;
+            ts.tv_nsec += add_nsecs;
+
+            /* pthread_cond_timedwait FAILS with EINVAL if ts.tv_nsec > 1000000000 (1 billion)
+             * Since we are just adding values to the timespec, we have to increment the seconds if nanoseconds is greater than 1 billion,
+             * and then re-adjust the nanoseconds in the correct range.
+             * */
+            ts.tv_sec += ts.tv_nsec / 1000000000;
+            ts.tv_nsec = ts.tv_nsec % 1000000000;
+
+            int err = pthread_cond_timedwait(&strmh->cb_cond, &strmh->cb_mutex, &ts);
+
+            // TODO: How should we handle EINVAL?
+            switch(err) {
+            case EINVAL:
+                *frame = NULL;
+                return UVC_ERROR_OTHER;
+            case ETIMEDOUT:
+                *frame = NULL;
+                return UVC_ERROR_TIMEOUT;
+            }
+        }
+
+        if(strmh->last_polled_seq < strmh->hold_seq) {
+            _uvc_populate_frame(strmh);
+            *frame                 = &strmh->frame;
+            strmh->last_polled_seq = strmh->hold_seq;
+        }
+        else {
+            *frame = NULL;
+        }
+    }
+    else {
+        *frame = NULL;
+    }
+
+    pthread_mutex_unlock(&strmh->cb_mutex);
+
+    return UVC_SUCCESS;
+}
+
+/** @brief Stop streaming video
+ * @ingroup streaming
+ *
+ * Closes all streams, ends threads and cancels pollers
+ *
+ * @param devh UVC device
+ */
+void uvc_stop_streaming(uvc_device_handle_t *devh) {
+    uvc_stream_handle_t *strmh, *strmh_tmp;
+
+    DL_FOREACH_SAFE(devh->streams, strmh, strmh_tmp) {
+        uvc_stream_close(strmh);
+    }
+}
+
+/** @brief Stop stream.
+ * @ingroup streaming
+ *
+ * Stops stream, ends threads and cancels pollers
+ *
+ * @param devh UVC device
+ */
+uvc_error_t uvc_stream_stop(uvc_stream_handle_t *strmh) {
+    uint32_t i;
+
+    if(!strmh->running)
+        return UVC_ERROR_INVALID_PARAM;
+
+    strmh->running = 0;
+
+    pthread_mutex_lock(&strmh->cb_mutex);
+
+    for(i = 0; i < strmh->actual_transfer_buff_num; i++) {
+        if(strmh->transfers[i] != NULL) {
+            int res = libusb_cancel_transfer(strmh->transfers[i]);
+            // 增加LIBUSB_ERROR_NO_DEVICE状态的判断，解决Android7平台贾维斯设备开流状态下热拔插概率性
+            // 出现EventHandle线程无法退出的问题
+            if(res < 0 && res != LIBUSB_ERROR_NOT_FOUND && res != LIBUSB_ERROR_NO_DEVICE && res != LIBUSB_ERROR_OTHER) {
+                free(strmh->transfers[i]->buffer);
+                libusb_free_transfer(strmh->transfers[i]);
+                strmh->transfers[i] = NULL;
+            }
+        }
+    }
+
+    /* Wait for transfers to complete/cancel */
+    do {
+        for(i = 0; i < strmh->actual_transfer_buff_num; i++) {
+            if(strmh->transfers[i] != NULL)
+                break;
+        }
+        if(i == strmh->actual_transfer_buff_num)
+            break;
+        pthread_cond_wait(&strmh->cb_cond, &strmh->cb_mutex);
+    } while(1);
+    // Kick the user thread awake
+    pthread_cond_broadcast(&strmh->cb_cond);
+    pthread_mutex_unlock(&strmh->cb_mutex);
+
+    /** @todo stop the actual stream, camera side? */
+
+    if(strmh->user_cb) {
+        /* wait for the thread to stop (triggered by
+         * LIBUSB_TRANSFER_CANCELLED transfer) */
+        pthread_join(strmh->cb_thread, NULL);
+    }
+
+    return UVC_SUCCESS;
+}
+
+/** @brief Close stream.
+ * @ingroup streaming
+ *
+ * Closes stream, frees handle and all streaming resources.
+ *
+ * @param strmh UVC stream handle
+ */
+void uvc_stream_close(uvc_stream_handle_t *strmh) {
+    if(strmh->running)
+        uvc_stream_stop(strmh);
+
+    uvc_release_if(strmh->devh, strmh->stream_if->bInterfaceNumber);
+
+    if(strmh->frame.data)
+        free(strmh->frame.data);
+
+    free(strmh->outbuf);
+    free(strmh->holdbuf);
+
+    free(strmh->meta_outbuf);
+    free(strmh->meta_holdbuf);
+
+    free(strmh->payload_header_outbuf);
+    free(strmh->payload_header_holdbuf);
+
+    pthread_cond_destroy(&strmh->cb_cond);
+    pthread_mutex_destroy(&strmh->cb_mutex);
+
+    DL_DELETE(strmh->devh->streams, strmh);
+    free(strmh);
+}
diff --git a/3rdparty/libuvc/src/src/test.c b/3rdparty/libuvc/src/src/test.c
new file mode 100644
index 00000000..47fe0964
--- /dev/null
+++ b/3rdparty/libuvc/src/src/test.c
@@ -0,0 +1,153 @@
+/*********************************************************************
+* Software License Agreement (BSD License)
+*
+*  Copyright (C) 2010-2012 Ken Tossell
+*  All rights reserved.
+*
+*  Redistribution and use in source and binary forms, with or without
+*  modification, are permitted provided that the following conditions
+*  are met:
+*
+*   * Redistributions of source code must retain the above copyright
+*     notice, this list of conditions and the following disclaimer.
+*   * Redistributions in binary form must reproduce the above
+*     copyright notice, this list of conditions and the following
+*     disclaimer in the documentation and/or other materials provided
+*     with the distribution.
+*   * Neither the name of the author nor other contributors may be
+*     used to endorse or promote products derived from this software
+*     without specific prior written permission.
+*
+*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+*  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+*  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+*  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+*  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+*  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+*  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+*  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+*  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+*  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+*  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+*  POSSIBILITY OF SUCH DAMAGE.
+*********************************************************************/
+#include <stdio.h>
+#include <opencv2/highgui/highgui_c.h>
+
+#include "libuvc/libuvc.h"
+
+void cb(uvc_frame_t *frame, void *ptr) {
+  uvc_frame_t *bgr;
+  uvc_error_t ret;
+  IplImage* cvImg;
+
+  printf("callback! length = %u, ptr = %d\n", frame->data_bytes, (int) ptr);
+
+  bgr = uvc_allocate_frame(frame->width * frame->height * 3);
+  if (!bgr) {
+    printf("unable to allocate bgr frame!");
+    return;
+  }
+
+  ret = uvc_any2bgr(frame, bgr);
+  if (ret) {
+    uvc_perror(ret, "uvc_any2bgr");
+    uvc_free_frame(bgr);
+    return;
+  }
+
+  cvImg = cvCreateImageHeader(
+      cvSize(bgr->width, bgr->height),
+      IPL_DEPTH_8U,
+      3);
+
+  cvSetData(cvImg, bgr->data, bgr->width * 3); 
+
+  cvNamedWindow("Test", CV_WINDOW_AUTOSIZE);
+  cvShowImage("Test", cvImg);
+  cvWaitKey(10);
+
+  cvReleaseImageHeader(&cvImg);
+
+  uvc_free_frame(bgr);
+}
+
+int main(int argc, char **argv) {
+  uvc_context_t *ctx;
+  uvc_error_t res;
+  uvc_device_t *dev;
+  uvc_device_handle_t *devh;
+  uvc_stream_ctrl_t ctrl;
+
+  res = uvc_init(&ctx, NULL);
+
+  if (res < 0) {
+    uvc_perror(res, "uvc_init");
+    return res;
+  }
+
+  puts("UVC initialized");
+
+  res = uvc_find_device(
+      ctx, &dev,
+      0, 0, NULL);
+
+  if (res < 0) {
+    uvc_perror(res, "uvc_find_device");
+  } else {
+    puts("Device found");
+
+    res = uvc_open(dev, &devh);
+
+    if (res < 0) {
+      uvc_perror(res, "uvc_open");
+    } else {
+      puts("Device opened");
+
+      uvc_print_diag(devh, stderr);
+
+      res = uvc_get_stream_ctrl_format_size(
+          devh, &ctrl, UVC_FRAME_FORMAT_YUYV, 640, 480, 30
+      );
+
+      uvc_print_stream_ctrl(&ctrl, stderr);
+
+      if (res < 0) {
+        uvc_perror(res, "get_mode");
+      } else {
+        res = uvc_start_streaming(devh, &ctrl, cb, 12345, 0);
+
+        if (res < 0) {
+          uvc_perror(res, "start_streaming");
+        } else {
+          puts("Streaming for 10 seconds...");
+          uvc_error_t resAEMODE = uvc_set_ae_mode(devh, 1);
+          uvc_perror(resAEMODE, "set_ae_mode");
+          int i;
+          for (i = 1; i <= 10; i++) {
+            /* uvc_error_t resPT = uvc_set_pantilt_abs(devh, i * 20 * 3600, 0); */
+            /* uvc_perror(resPT, "set_pt_abs"); */
+            uvc_error_t resEXP = uvc_set_exposure_abs(devh, 20 + i * 5);
+            uvc_perror(resEXP, "set_exp_abs");
+            
+            sleep(1);
+          }
+          sleep(10);
+          uvc_stop_streaming(devh);
+	  puts("Done streaming.");
+        }
+      }
+
+      uvc_close(devh);
+      puts("Device closed");
+    }
+
+    uvc_unref_device(dev);
+  }
+
+  uvc_exit(ctx);
+  puts("UVC exited");
+
+  return 0;
+}
+
diff --git a/3rdparty/libuvc/src/standard-units.yaml b/3rdparty/libuvc/src/standard-units.yaml
new file mode 100644
index 00000000..198c4016
--- /dev/null
+++ b/3rdparty/libuvc/src/standard-units.yaml
@@ -0,0 +1,518 @@
+units:
+  camera_terminal:
+    type: standard
+    description: Standard camera input terminal (captures images from sensor)
+    control_prefix: CT
+    controls:
+      scanning_mode:
+        control: SCANNING_MODE
+        length: 1
+        fields:
+          mode:
+            type: int
+            position: 0
+            length: 1
+            doc: '0: interlaced, 1: progressive'
+      ae_mode:
+        control: AE_MODE
+        length: 1
+        fields:
+          mode:
+            type: int
+            position: 0
+            length: 1
+            doc: '1: manual mode; 2: auto mode; 4: shutter priority mode; 8: aperture
+              priority mode'
+        doc:
+          get: |-
+            @brief Reads camera's auto-exposure mode.
+
+            See uvc_set_ae_mode() for a description of the available modes.
+          set: |-
+            @brief Sets camera's auto-exposure mode.
+
+            Cameras may support any of the following AE modes:
+             * UVC_AUTO_EXPOSURE_MODE_MANUAL (1) - manual exposure time, manual iris
+             * UVC_AUTO_EXPOSURE_MODE_AUTO (2) - auto exposure time, auto iris
+             * UVC_AUTO_EXPOSURE_MODE_SHUTTER_PRIORITY (4) - manual exposure time, auto iris
+             * UVC_AUTO_EXPOSURE_MODE_APERTURE_PRIORITY (8) - auto exposure time, manual iris
+
+            Most cameras provide manual mode and aperture priority mode.
+      ae_priority:
+        control: AE_PRIORITY
+        length: 1
+        fields:
+          priority:
+            type: int
+            position: 0
+            length: 1
+            doc: '0: frame rate must remain constant; 1: frame rate may be varied
+              for AE purposes'
+        doc:
+          get: |-
+            @brief Checks whether the camera may vary the frame rate for exposure control reasons.
+            See uvc_set_ae_priority() for a description of the `priority` field.
+          set: |-
+            @brief Chooses whether the camera may vary the frame rate for exposure control reasons.
+            A `priority` value of zero means the camera may not vary its frame rate. A value of 1
+            means the frame rate is variable. This setting has no effect outside of the `auto` and
+            `shutter_priority` auto-exposure modes.
+      exposure_abs:
+        control: EXPOSURE_TIME_ABSOLUTE
+        length: 4
+        fields:
+          time:
+            type: int
+            position: 0
+            length: 4
+            doc: ''
+        doc:
+          get: |-
+            @brief Gets the absolute exposure time.
+
+            See uvc_set_exposure_abs() for a description of the `time` field.
+          set: |-
+            @brief Sets the absolute exposure time.
+
+            The `time` parameter should be provided in units of 0.0001 seconds (e.g., use the value 100
+            for a 10ms exposure period). Auto exposure should be set to `manual` or `shutter_priority`
+            before attempting to change this setting.
+      exposure_rel:
+        control: EXPOSURE_TIME_RELATIVE
+        length: 1
+        fields:
+          step:
+            type: int
+            position: 0
+            length: 1
+            signed: true
+            doc: number of steps by which to change the exposure time, or zero to
+              set the default exposure time
+        doc: '@brief {gets_sets} the exposure time relative to the current setting.'
+      focus_abs:
+        control: FOCUS_ABSOLUTE
+        length: 2
+        fields:
+          focus:
+            type: int
+            position: 0
+            length: 2
+            doc: focal target distance in millimeters
+        doc: '@brief {gets_sets} the distance at which an object is optimally focused.'
+      focus_rel:
+        control: FOCUS_RELATIVE
+        length: 2
+        fields:
+          focus_rel:
+            type: int
+            position: 0
+            length: 1
+            signed: true
+            doc: TODO
+          speed:
+            type: int
+            position: 1
+            length: 1
+            doc: TODO
+      focus_simple_range:
+        control: FOCUS_SIMPLE
+        length: 1
+        fields:
+          focus:
+            type: int
+            position: 0
+            length: 1
+            doc: TODO
+      focus_auto:
+        control: FOCUS_AUTO
+        length: 1
+        fields:
+          state:
+            type: int
+            position: 0
+            length: 1
+            doc: TODO
+      iris_abs:
+        control: IRIS_ABSOLUTE
+        length: 2
+        fields:
+          iris:
+            type: int
+            position: 0
+            length: 2
+            doc: TODO
+      iris_rel:
+        control: IRIS_RELATIVE
+        length: 1
+        fields:
+          iris_rel:
+            type: int
+            position: 0
+            length: 1
+            doc: TODO
+      zoom_abs:
+        control: ZOOM_ABSOLUTE
+        length: 2
+        fields:
+          focal_length:
+            type: int
+            position: 0
+            length: 2
+            doc: TODO
+      zoom_rel:
+        control: ZOOM_RELATIVE
+        length: 3
+        fields:
+          zoom_rel:
+            type: int
+            position: 0
+            length: 1
+            signed: true
+            doc: TODO
+          digital_zoom:
+            type: int
+            position: 1
+            length: 1
+            doc: TODO
+          speed:
+            type: int
+            position: 2
+            length: 1
+            doc: TODO
+      pantilt_abs:
+        control: PANTILT_ABSOLUTE
+        length: 8
+        fields:
+          pan:
+            type: int
+            position: 0
+            length: 4
+            signed: true
+            doc: TODO
+          tilt:
+            type: int
+            position: 4
+            length: 4
+            signed: true
+            doc: TODO
+      pantilt_rel:
+        control: PANTILT_RELATIVE
+        length: 4
+        fields:
+          pan_rel:
+            type: int
+            position: 0
+            length: 1
+            signed: true
+            doc: TODO
+          pan_speed:
+            type: int
+            position: 1
+            length: 1
+            doc: TODO
+          tilt_rel:
+            type: int
+            position: 2
+            length: 1
+            signed: true
+            doc: TODO
+          tilt_speed:
+            type: int
+            position: 3
+            length: 1
+            doc: TODO
+      roll_abs:
+        control: ROLL_ABSOLUTE
+        length: 2
+        fields:
+          roll:
+            type: int
+            position: 0
+            length: 2
+            signed: true
+            doc: TODO
+      roll_rel:
+        control: ROLL_RELATIVE
+        length: 2
+        fields:
+          roll_rel:
+            type: int
+            position: 0
+            length: 1
+            signed: true
+            doc: TODO
+          speed:
+            type: int
+            position: 1
+            length: 1
+            doc: TODO
+      privacy:
+        control: PRIVACY
+        length: 1
+        fields:
+          privacy:
+            type: int
+            position: 0
+            length: 1
+            doc: TODO
+      digital_window:
+        control: DIGITAL_WINDOW
+        length: 12
+        fields:
+          window_top:
+            type: int
+            position: 0
+            length: 2
+            doc: TODO
+          window_left:
+            type: int
+            position: 2
+            length: 2
+            doc: TODO
+          window_bottom:
+            type: int
+            position: 4
+            length: 2
+            doc: TODO
+          window_right:
+            type: int
+            position: 6
+            length: 2
+            doc: TODO
+          num_steps:
+            type: int
+            position: 8
+            length: 2
+            doc: TODO
+          num_steps_units:
+            type: int
+            position: 10
+            length: 2
+            doc: TODO
+      digital_roi:
+        control: REGION_OF_INTEREST
+        length: 10
+        fields:
+          roi_top:
+            type: int
+            position: 0
+            length: 2
+            doc: TODO
+          roi_left:
+            type: int
+            position: 2
+            length: 2
+            doc: TODO
+          roi_bottom:
+            type: int
+            position: 4
+            length: 2
+            doc: TODO
+          roi_right:
+            type: int
+            position: 6
+            length: 2
+            doc: TODO
+          auto_controls:
+            type: int
+            position: 8
+            length: 2
+            doc: TODO
+  processing_unit:
+    type: standard
+    description: Standard processing unit (processes images between other units)
+    control_prefix: PU
+    controls:
+      backlight_compensation:
+        control: BACKLIGHT_COMPENSATION
+        length: 2
+        fields:
+          backlight_compensation:
+            type: int
+            position: 0
+            length: 2
+            doc: device-dependent backlight compensation mode; zero means backlight
+              compensation is disabled
+      brightness:
+        control: BRIGHTNESS
+        length: 2
+        fields:
+          brightness:
+            type: int
+            position: 0
+            length: 2
+            signed: true
+            doc: TODO
+      contrast:
+        control: CONTRAST
+        length: 2
+        fields:
+          contrast:
+            type: int
+            position: 0
+            length: 2
+            doc: TODO
+      contrast_auto:
+        control: CONTRAST_AUTO
+        length: 1
+        fields:
+          contrast_auto:
+            type: int
+            position: 0
+            length: 1
+            doc: TODO
+      gain:
+        control: GAIN
+        length: 2
+        fields:
+          gain:
+            type: int
+            position: 0
+            length: 2
+            doc: TODO
+      power_line_frequency:
+        control: POWER_LINE_FREQUENCY
+        length: 1
+        fields:
+          power_line_frequency:
+            type: int
+            position: 0
+            length: 1
+            doc: TODO
+      hue:
+        control: HUE
+        length: 2
+        fields:
+          hue:
+            type: int
+            position: 0
+            length: 2
+            signed: true
+            doc: TODO
+      hue_auto:
+        control: HUE_AUTO
+        length: 1
+        fields:
+          hue_auto:
+            type: int
+            position: 0
+            length: 1
+            doc: TODO
+      saturation:
+        control: SATURATION
+        length: 2
+        fields:
+          saturation:
+            type: int
+            position: 0
+            length: 2
+            doc: TODO
+      sharpness:
+        control: SHARPNESS
+        length: 2
+        fields:
+          sharpness:
+            type: int
+            position: 0
+            length: 2
+            doc: TODO
+      gamma:
+        control: GAMMA
+        length: 2
+        fields:
+          gamma:
+            type: int
+            position: 0
+            length: 2
+            doc: TODO
+      white_balance_temperature:
+        control: WHITE_BALANCE_TEMPERATURE
+        length: 2
+        fields:
+          temperature:
+            type: int
+            position: 0
+            length: 2
+            doc: TODO
+      white_balance_temperature_auto:
+        control: WHITE_BALANCE_TEMPERATURE_AUTO
+        length: 1
+        fields:
+          temperature_auto:
+            type: int
+            position: 0
+            length: 1
+            doc: TODO
+      white_balance_component:
+        control: WHITE_BALANCE_COMPONENT
+        length: 4
+        fields:
+          blue:
+            type: int
+            position: 0
+            length: 2
+            doc: TODO
+          red:
+            type: int
+            position: 2
+            length: 2
+            doc: TODO
+      white_balance_component_auto:
+        control: WHITE_BALANCE_COMPONENT_AUTO
+        length: 1
+        fields:
+          white_balance_component_auto:
+            type: int
+            position: 0
+            length: 1
+            doc: TODO
+      digital_multiplier:
+        control: DIGITAL_MULTIPLIER
+        length: 2
+        fields:
+          multiplier_step:
+            type: int
+            position: 0
+            length: 2
+            doc: TODO
+      digital_multiplier_limit:
+        control: DIGITAL_MULTIPLIER_LIMIT
+        length: 2
+        fields:
+          multiplier_step:
+            type: int
+            position: 0
+            length: 2
+            doc: TODO
+      analog_video_standard:
+        control: ANALOG_VIDEO_STANDARD
+        length: 1
+        fields:
+          video_standard:
+            type: int
+            position: 0
+            length: 1
+            doc: TODO
+      analog_video_lock_status:
+        control: ANALOG_LOCK_STATUS
+        length: 1
+        fields:
+          status:
+            type: int
+            position: 0
+            length: 1
+            doc: TODO
+  selector_unit:
+    type: standard
+    description: Standard selector unit (controls connectivity between other units)
+    control_prefix: SU
+    controls:
+      input_select:
+        control: INPUT_SELECT
+        length: 1
+        fields:
+          selector:
+            type: int
+            position: 0
+            length: 1
+            doc: TODO
diff --git a/3rdparty/libyuv/CMakeLists.txt b/3rdparty/libyuv/CMakeLists.txt
new file mode 100644
index 00000000..11519eb3
--- /dev/null
+++ b/3rdparty/libyuv/CMakeLists.txt
@@ -0,0 +1,13 @@
+cmake_minimum_required(VERSION 3.5)
+
+add_subdirectory(src)
+
+get_target_property(compile_options yuv COMPILE_OPTIONS)
+list(REMOVE_ITEM compile_options "-Werror" "/WX")
+set_target_properties(yuv PROPERTIES COMPILE_OPTIONS "${compile_options}")
+
+target_include_directories(yuv PUBLIC ${CMAKE_CURRENT_LIST_DIR}/src/include)
+
+add_library(libyuv::libyuv ALIAS yuv)
+ob_source_group(libyuv::libyuv)
+set_target_properties(yuv PROPERTIES FOLDER "dependencies")
diff --git a/3rdparty/libyuv/src/.clang-format b/3rdparty/libyuv/src/.clang-format
new file mode 100644
index 00000000..59d48705
--- /dev/null
+++ b/3rdparty/libyuv/src/.clang-format
@@ -0,0 +1,6 @@
+# Defines the Chromium style for automatic reformatting.
+# http://clang.llvm.org/docs/ClangFormatStyleOptions.html
+BasedOnStyle: Chromium
+---
+Language: Java
+BasedOnStyle: Google
diff --git a/3rdparty/libyuv/src/.gitignore b/3rdparty/libyuv/src/.gitignore
new file mode 100644
index 00000000..20d679b7
--- /dev/null
+++ b/3rdparty/libyuv/src/.gitignore
@@ -0,0 +1,37 @@
+*.pyc
+.landmines
+pin-log.txt
+/base
+/build
+/buildtools
+/google_apis
+/links
+/links.db
+/ios
+/mojo
+/native_client
+/net
+/out
+/unit_test/out
+/source/out
+/sde-avx-sse-transition-out.txt
+/testing
+/third_party
+/tools
+
+# Files generated by CMake build
+cmake_install.cmake
+CMakeCache.txt
+CMakeFiles/
+yuvconvert
+libgtest.a
+libyuv.a
+libyuv_unittest
+
+# Files generated by winarm.mk build
+libyuv_arm.lib
+source/*.o
+
+# Files generated by perf
+perf.data
+perf.data.old
diff --git a/3rdparty/libyuv/src/.gn b/3rdparty/libyuv/src/.gn
new file mode 100644
index 00000000..a765caa5
--- /dev/null
+++ b/3rdparty/libyuv/src/.gn
@@ -0,0 +1,40 @@
+# Copyright 2015 The LibYuv Project Authors. All rights reserved.
+#
+# Use of this source code is governed by a BSD-style license
+# that can be found in the LICENSE file in the root of the source
+# tree. An additional intellectual property rights grant can be found
+# in the file PATENTS. All contributing project authors may
+# be found in the AUTHORS file in the root of the source tree.
+
+import("//build/dotfile_settings.gni")
+
+# The location of the build configuration file.
+buildconfig = "//build/config/BUILDCONFIG.gn"
+
+# The python interpreter to use by default. On Windows, this will look
+# for python3.exe and python3.bat.
+script_executable = "python3"
+
+# The secondary source root is a parallel directory tree where
+# GN build files are placed when they can not be placed directly
+# in the source tree, e.g. for third party source trees.
+secondary_source = "//build/secondary/"
+
+# These are the targets to check headers for by default. The files in targets
+# matching these patterns (see "gn help label_pattern" for format) will have
+# their includes checked for proper dependencies when you run either
+# "gn check" or "gn gen --check".
+check_targets = [ "//libyuv/*" ]
+
+# These are the list of GN files that run exec_script. This whitelist exists
+# to force additional review for new uses of exec_script, which is strongly
+# discouraged except for gypi_to_gn calls.
+exec_script_whitelist = build_dotfile_settings.exec_script_whitelist +
+                        [ "//build_overrides/build.gni" ]
+
+default_args = {
+  mac_sdk_min = "10.12"
+
+  # https://bugs.chromium.org/p/libyuv/issues/detail?id=826
+  ios_deployment_target = "10.0"
+}
diff --git a/3rdparty/libyuv/src/.vpython b/3rdparty/libyuv/src/.vpython
new file mode 100644
index 00000000..4a64fd21
--- /dev/null
+++ b/3rdparty/libyuv/src/.vpython
@@ -0,0 +1,52 @@
+# This is a vpython "spec" file.
+#
+# It describes patterns for python wheel dependencies of the python scripts in
+# the chromium repo, particularly for dependencies that have compiled components
+# (since pure-python dependencies can be easily vendored into third_party).
+#
+# When vpython is invoked, it finds this file and builds a python VirtualEnv,
+# containing all of the dependencies described in this file, fetching them from
+# CIPD (the "Chrome Infrastructure Package Deployer" service). Unlike `pip`,
+# this never requires the end-user machine to have a working python extension
+# compilation environment. All of these packages are built using:
+#   https://chromium.googlesource.com/infra/infra/+/master/infra/tools/dockerbuild/
+#
+# All python scripts in the repo share this same spec, to avoid dependency
+# fragmentation.
+#
+# If you have depot_tools installed in your $PATH, you can invoke python scripts
+# in this repo by running them as you normally would run them, except
+# substituting `vpython` instead of `python` on the command line, e.g.:
+#   vpython path/to/script.py some --arguments
+#
+# Read more about `vpython` and how to modify this file here:
+#   https://chromium.googlesource.com/infra/infra/+/master/doc/users/vpython.md
+
+python_version: "2.7"
+
+# Used by:
+#   third_party/catapult
+wheel: <
+  name: "infra/python/wheels/psutil/${platform}_${py_python}_${py_abi}"
+  version: "version:5.2.2"
+>
+
+# Used by:
+#   third_party/catapult
+wheel: <
+  name: "infra/python/wheels/pypiwin32/${vpython_platform}"
+  version: "version:219"
+  match_tag: <
+    platform: "win32"
+  >
+  match_tag: <
+    platform: "win_amd64"
+  >
+>
+
+# Used by:
+#   build/android
+wheel: <
+  name: "infra/python/wheels/requests-py2_py3"
+  version: "version:2.13.0"
+>
diff --git a/3rdparty/libyuv/src/AUTHORS b/3rdparty/libyuv/src/AUTHORS
new file mode 100644
index 00000000..28c08956
--- /dev/null
+++ b/3rdparty/libyuv/src/AUTHORS
@@ -0,0 +1,6 @@
+# Names should be added to this file like so:
+# Name or Organization <email address>
+
+Google Inc.
+
+Ivan Pavlotskiy <ivan.pavlotskiy@lgepartner.com>
diff --git a/3rdparty/libyuv/src/Android.bp b/3rdparty/libyuv/src/Android.bp
new file mode 100644
index 00000000..f510daa1
--- /dev/null
+++ b/3rdparty/libyuv/src/Android.bp
@@ -0,0 +1,197 @@
+package {
+    default_applicable_licenses: ["external_libyuv_files_license"],
+}
+
+// Added automatically by a large-scale-change
+//
+// large-scale-change included anything that looked like it might be a license
+// text as a license_text. e.g. LICENSE, NOTICE, COPYING etc.
+//
+// Please consider removing redundant or irrelevant files from 'license_text:'.
+// See: http://go/android-license-faq
+license {
+    name: "external_libyuv_files_license",
+    visibility: [":__subpackages__"],
+    license_kinds: [
+        "SPDX-license-identifier-BSD",
+    ],
+    license_text: [
+        "LICENSE",
+        "LICENSE_THIRD_PARTY",
+        "PATENTS",
+    ],
+}
+
+cc_library {
+    name: "libyuv",
+    vendor_available: true,
+    product_available: true,
+    host_supported: true,
+    vndk: {
+        enabled: true,
+    },
+
+    srcs: [
+        "source/compare.cc",
+        "source/compare_common.cc",
+        "source/compare_gcc.cc",
+        "source/compare_msa.cc",
+        "source/compare_neon.cc",
+        "source/compare_neon64.cc",
+        "source/convert.cc",
+        "source/convert_argb.cc",
+        "source/convert_from.cc",
+        "source/convert_from_argb.cc",
+        "source/convert_jpeg.cc",
+        "source/convert_to_argb.cc",
+        "source/convert_to_i420.cc",
+        "source/cpu_id.cc",
+        "source/mjpeg_decoder.cc",
+        "source/mjpeg_validate.cc",
+        "source/planar_functions.cc",
+        "source/rotate.cc",
+        "source/rotate_any.cc",
+        "source/rotate_argb.cc",
+        "source/rotate_common.cc",
+        "source/rotate_gcc.cc",
+        "source/rotate_msa.cc",
+        "source/rotate_neon.cc",
+        "source/rotate_neon64.cc",
+        "source/row_any.cc",
+        "source/row_common.cc",
+        "source/row_gcc.cc",
+        "source/row_msa.cc",
+        "source/row_neon.cc",
+        "source/row_neon64.cc",
+        "source/scale.cc",
+        "source/scale_any.cc",
+        "source/scale_argb.cc",
+        "source/scale_common.cc",
+        "source/scale_gcc.cc",
+        "source/scale_msa.cc",
+        "source/scale_neon.cc",
+        "source/scale_neon64.cc",
+        "source/scale_rgb.cc",
+        "source/scale_uv.cc",
+        "source/video_common.cc",
+    ],
+
+    cflags: [
+        "-Wall",
+        "-Werror",
+        "-Wno-unused-parameter",
+        "-fexceptions",
+        "-DHAVE_JPEG",
+    ],
+
+    arch: {
+        arm: {
+            cflags: ["-mfpu=neon"],
+        },
+    },
+
+    shared_libs: ["libjpeg"],
+
+    export_include_dirs: ["include"],
+
+    apex_available: [
+        "//apex_available:platform",
+        "com.android.media.swcodec",
+    ],
+    min_sdk_version: "29",
+}
+
+// compatibilty static library until all uses of libyuv_static are replaced
+// with libyuv (b/37646797)
+cc_library_static {
+    name: "libyuv_static",
+    vendor_available: true,
+    whole_static_libs: ["libyuv"],
+    apex_available: [
+        "//apex_available:platform",
+        "com.android.media.swcodec",
+    ],
+    min_sdk_version: "29",
+}
+
+cc_test {
+    name: "libyuv_unittest",
+    static_libs: ["libyuv"],
+    shared_libs: ["libjpeg"],
+    cflags: ["-Wall", "-Werror"],
+    srcs: [
+        "unit_test/basictypes_test.cc",
+        "unit_test/color_test.cc",
+        "unit_test/compare_test.cc",
+        "unit_test/convert_test.cc",
+        "unit_test/cpu_test.cc",
+        "unit_test/cpu_thread_test.cc",
+        "unit_test/math_test.cc",
+        "unit_test/planar_test.cc",
+        "unit_test/rotate_argb_test.cc",
+        "unit_test/rotate_test.cc",
+        "unit_test/scale_argb_test.cc",
+        "unit_test/scale_rgb_test.cc",
+        "unit_test/scale_test.cc",
+        "unit_test/scale_uv_test.cc",
+        "unit_test/unit_test.cc",
+        "unit_test/video_common_test.cc",
+    ],
+}
+
+cc_test {
+    name: "compare",
+    gtest: false,
+    srcs: [
+        "util/compare.cc",
+    ],
+    static_libs: ["libyuv"],
+}
+
+cc_test {
+    name: "cpuid",
+    gtest: false,
+    srcs: [
+        "util/cpuid.c",
+    ],
+    static_libs: ["libyuv"],
+}
+
+cc_test {
+    name: "i444tonv12_eg",
+    gtest: false,
+    srcs: [
+        "util/i444tonv12_eg.cc",
+    ],
+    static_libs: ["libyuv"],
+}
+
+cc_test {
+    name: "psnr",
+    gtest: false,
+    srcs: [
+        "util/psnr_main.cc",
+        "util/psnr.cc",
+        "util/ssim.cc",
+    ],
+    static_libs: ["libyuv"],
+}
+
+cc_test {
+    name: "yuvconstants",
+    gtest: false,
+    srcs: [
+        "util/yuvconstants.c",
+    ],
+    static_libs: ["libyuv"],
+}
+
+cc_test {
+    name: "yuvconvert",
+    gtest: false,
+    srcs: [
+        "util/yuvconvert.cc",
+    ],
+    static_libs: ["libyuv"],
+    shared_libs: ["libjpeg"],
+}
diff --git a/3rdparty/libyuv/src/Android.mk b/3rdparty/libyuv/src/Android.mk
new file mode 100644
index 00000000..45d9daa8
--- /dev/null
+++ b/3rdparty/libyuv/src/Android.mk
@@ -0,0 +1,108 @@
+# This is the Android makefile for libyuv for NDK.
+LOCAL_PATH:= $(call my-dir)
+
+include $(CLEAR_VARS)
+
+LOCAL_CPP_EXTENSION := .cc
+
+LOCAL_SRC_FILES := \
+    source/compare.cc           \
+    source/compare_common.cc    \
+    source/compare_gcc.cc       \
+    source/compare_msa.cc       \
+    source/compare_neon.cc      \
+    source/compare_neon64.cc    \
+    source/compare_win.cc       \
+    source/convert.cc           \
+    source/convert_argb.cc      \
+    source/convert_from.cc      \
+    source/convert_from_argb.cc \
+    source/convert_to_argb.cc   \
+    source/convert_to_i420.cc   \
+    source/cpu_id.cc            \
+    source/planar_functions.cc  \
+    source/rotate.cc            \
+    source/rotate_any.cc        \
+    source/rotate_argb.cc       \
+    source/rotate_common.cc     \
+    source/rotate_gcc.cc        \
+    source/rotate_msa.cc        \
+    source/rotate_neon.cc       \
+    source/rotate_neon64.cc     \
+    source/rotate_win.cc        \
+    source/row_any.cc           \
+    source/row_common.cc        \
+    source/row_gcc.cc           \
+    source/row_msa.cc           \
+    source/row_neon.cc          \
+    source/row_neon64.cc        \
+    source/row_win.cc           \
+    source/scale.cc             \
+    source/scale_any.cc         \
+    source/scale_argb.cc        \
+    source/scale_common.cc      \
+    source/scale_gcc.cc         \
+    source/scale_msa.cc         \
+    source/scale_neon.cc        \
+    source/scale_neon64.cc      \
+    source/scale_rgb.cc         \
+    source/scale_uv.cc          \
+    source/scale_win.cc         \
+    source/video_common.cc
+
+common_CFLAGS := -Wall -fexceptions
+ifneq ($(LIBYUV_DISABLE_JPEG), "yes")
+LOCAL_SRC_FILES += \
+    source/convert_jpeg.cc      \
+    source/mjpeg_decoder.cc     \
+    source/mjpeg_validate.cc
+common_CFLAGS += -DHAVE_JPEG
+LOCAL_SHARED_LIBRARIES := libjpeg
+endif
+
+LOCAL_CFLAGS += $(common_CFLAGS)
+LOCAL_EXPORT_C_INCLUDES := $(LOCAL_PATH)/include
+LOCAL_C_INCLUDES += $(LOCAL_PATH)/include
+LOCAL_EXPORT_C_INCLUDE_DIRS := $(LOCAL_PATH)/include
+
+LOCAL_MODULE := libyuv_static
+LOCAL_MODULE_TAGS := optional
+
+include $(BUILD_STATIC_LIBRARY)
+
+include $(CLEAR_VARS)
+
+LOCAL_WHOLE_STATIC_LIBRARIES := libyuv_static
+LOCAL_MODULE := libyuv
+ifneq ($(LIBYUV_DISABLE_JPEG), "yes")
+LOCAL_SHARED_LIBRARIES := libjpeg
+endif
+
+include $(BUILD_SHARED_LIBRARY)
+
+include $(CLEAR_VARS)
+LOCAL_STATIC_LIBRARIES := libyuv_static
+LOCAL_SHARED_LIBRARIES := libjpeg
+LOCAL_MODULE_TAGS := tests
+LOCAL_CPP_EXTENSION := .cc
+LOCAL_C_INCLUDES += $(LOCAL_PATH)/include
+LOCAL_SRC_FILES := \
+    unit_test/basictypes_test.cc  \
+    unit_test/color_test.cc       \
+    unit_test/compare_test.cc     \
+    unit_test/convert_test.cc     \
+    unit_test/cpu_test.cc         \
+    unit_test/cpu_thread_test.cc  \
+    unit_test/math_test.cc        \
+    unit_test/planar_test.cc      \
+    unit_test/rotate_argb_test.cc \
+    unit_test/rotate_test.cc      \
+    unit_test/scale_argb_test.cc  \
+    unit_test/scale_rgb_test.cc   \
+    unit_test/scale_test.cc       \
+    unit_test/scale_uv_test.cc    \
+    unit_test/unit_test.cc        \
+    unit_test/video_common_test.cc
+
+LOCAL_MODULE := libyuv_unittest
+include $(BUILD_NATIVE_TEST)
diff --git a/3rdparty/libyuv/src/BUILD.gn b/3rdparty/libyuv/src/BUILD.gn
new file mode 100644
index 00000000..a72ff065
--- /dev/null
+++ b/3rdparty/libyuv/src/BUILD.gn
@@ -0,0 +1,388 @@
+# Copyright 2014 The LibYuv Project Authors. All rights reserved.
+#
+# Use of this source code is governed by a BSD-style license
+# that can be found in the LICENSE file in the root of the source
+# tree. An additional intellectual property rights grant can be found
+# in the file PATENTS. All contributing project authors may
+# be found in the AUTHORS file in the root of the source tree.
+
+import("//testing/test.gni")
+import("libyuv.gni")
+
+declare_args() {
+  # Set to false to disable building with absl flags.
+  libyuv_use_absl_flags = true
+
+  # When building a shared library using a target in WebRTC or
+  # Chromium projects that depends on libyuv, setting this flag
+  # to true makes libyuv symbols visible inside that library.
+  libyuv_symbols_visible = false
+}
+
+config("libyuv_config") {
+  include_dirs = [ "include" ]
+  if (is_android && current_cpu == "arm64") {
+    ldflags = [ "-Wl,--dynamic-linker,/system/bin/linker64" ]
+  }
+  if (is_android && current_cpu != "arm64") {
+    ldflags = [ "-Wl,--dynamic-linker,/system/bin/linker" ]
+  }
+
+  if (!libyuv_use_neon) {
+    defines = [ "LIBYUV_DISABLE_NEON" ]
+  }
+}
+
+# This target is built when no specific target is specified on the command line.
+group("default") {
+  testonly = true
+  deps = [ ":libyuv" ]
+  if (libyuv_include_tests) {
+    deps += [
+      ":compare",
+      ":cpuid",
+      ":i444tonv12_eg",
+      ":libyuv_unittest",
+      ":psnr",
+      ":yuvconstants",
+      ":yuvconvert",
+    ]
+  }
+}
+
+group("libyuv") {
+  all_dependent_configs = [ ":libyuv_config" ]
+  deps = []
+
+  if (is_win && target_cpu == "x64") {
+    # Compile with clang in order to get inline assembly
+    public_deps = [ ":libyuv_internal(//build/toolchain/win:win_clang_x64)" ]
+  } else {
+    public_deps = [ ":libyuv_internal" ]
+  }
+
+  if (libyuv_use_neon) {
+    deps += [ ":libyuv_neon" ]
+  }
+
+  if (libyuv_use_msa) {
+    deps += [ ":libyuv_msa" ]
+  }
+
+  if (!is_ios && !libyuv_disable_jpeg) {
+    # Make sure that clients of libyuv link with libjpeg. This can't go in
+    # libyuv_internal because in Windows x64 builds that will generate a clang
+    # build of libjpeg, and we don't want two copies.
+    deps += [ "//third_party:jpeg" ]
+  }
+}
+
+static_library("libyuv_internal") {
+  visibility = [ ":*" ]
+
+  sources = [
+    # Headers
+    "include/libyuv.h",
+    "include/libyuv/basic_types.h",
+    "include/libyuv/compare.h",
+    "include/libyuv/convert.h",
+    "include/libyuv/convert_argb.h",
+    "include/libyuv/convert_from.h",
+    "include/libyuv/convert_from_argb.h",
+    "include/libyuv/cpu_id.h",
+    "include/libyuv/mjpeg_decoder.h",
+    "include/libyuv/planar_functions.h",
+    "include/libyuv/rotate.h",
+    "include/libyuv/rotate_argb.h",
+    "include/libyuv/rotate_row.h",
+    "include/libyuv/row.h",
+    "include/libyuv/scale.h",
+    "include/libyuv/scale_argb.h",
+    "include/libyuv/scale_rgb.h",
+    "include/libyuv/scale_row.h",
+    "include/libyuv/scale_uv.h",
+    "include/libyuv/version.h",
+    "include/libyuv/video_common.h",
+
+    # Source Files
+    "source/compare.cc",
+    "source/compare_common.cc",
+    "source/compare_gcc.cc",
+    "source/compare_win.cc",
+    "source/convert.cc",
+    "source/convert_argb.cc",
+    "source/convert_from.cc",
+    "source/convert_from_argb.cc",
+    "source/convert_jpeg.cc",
+    "source/convert_to_argb.cc",
+    "source/convert_to_i420.cc",
+    "source/cpu_id.cc",
+    "source/mjpeg_decoder.cc",
+    "source/mjpeg_validate.cc",
+    "source/planar_functions.cc",
+    "source/rotate.cc",
+    "source/rotate_any.cc",
+    "source/rotate_argb.cc",
+    "source/rotate_common.cc",
+    "source/rotate_gcc.cc",
+    "source/rotate_win.cc",
+    "source/row_any.cc",
+    "source/row_common.cc",
+    "source/row_gcc.cc",
+    "source/row_win.cc",
+    "source/scale.cc",
+    "source/scale_any.cc",
+    "source/scale_argb.cc",
+    "source/scale_common.cc",
+    "source/scale_gcc.cc",
+    "source/scale_rgb.cc",
+    "source/scale_uv.cc",
+    "source/scale_win.cc",
+    "source/video_common.cc",
+  ]
+
+  configs += [ ":libyuv_config" ]
+  defines = []
+  deps = []
+
+  if (libyuv_symbols_visible) {
+    configs -= [ "//build/config/gcc:symbol_visibility_hidden" ]
+    configs += [ "//build/config/gcc:symbol_visibility_default" ]
+  }
+
+  if (!is_ios && !libyuv_disable_jpeg) {
+    defines += [ "HAVE_JPEG" ]
+
+    # Needed to pull in libjpeg headers. Can't add //third_party:jpeg to deps
+    # because in Windows x64 build it will get compiled with clang.
+    deps += [ "//third_party:jpeg_includes" ]
+  }
+
+  # Always enable optimization for Release and NaCl builds (to workaround
+  # crbug.com/538243).
+  if (!is_debug || is_nacl) {
+    configs -= [ "//build/config/compiler:default_optimization" ]
+
+    # Enable optimize for speed (-O2) over size (-Os).
+    configs += [ "//build/config/compiler:optimize_max" ]
+  }
+
+  # To enable AVX2 or other cpu optimization, pass flag here
+  if (!is_win) {
+    cflags = [
+      # "-mpopcnt",
+      # "-mavx2",
+      # "-mfma",
+      "-ffp-contract=fast",  # Enable fma vectorization for NEON.
+    ]
+  }
+}
+
+if (libyuv_use_neon) {
+  static_library("libyuv_neon") {
+    sources = [
+      # ARM Source Files
+      "source/compare_neon.cc",
+      "source/compare_neon64.cc",
+      "source/rotate_neon.cc",
+      "source/rotate_neon64.cc",
+      "source/row_neon.cc",
+      "source/row_neon64.cc",
+      "source/scale_neon.cc",
+      "source/scale_neon64.cc",
+    ]
+
+    deps = [ ":libyuv_internal" ]
+
+    public_configs = [ ":libyuv_config" ]
+
+    # Always enable optimization for Release and NaCl builds (to workaround
+    # crbug.com/538243).
+    if (!is_debug) {
+      configs -= [ "//build/config/compiler:default_optimization" ]
+
+      # Enable optimize for speed (-O2) over size (-Os).
+      # TODO(fbarchard): Consider optimize_speed which is O3.
+      configs += [ "//build/config/compiler:optimize_max" ]
+    }
+
+    if (current_cpu != "arm64") {
+      configs -= [ "//build/config/compiler:compiler_arm_fpu" ]
+      cflags = [ "-mfpu=neon" ]
+    }
+  }
+}
+
+if (libyuv_use_msa) {
+  static_library("libyuv_msa") {
+    sources = [
+      # MSA Source Files
+      "source/compare_msa.cc",
+      "source/rotate_msa.cc",
+      "source/row_msa.cc",
+      "source/scale_msa.cc",
+    ]
+
+    deps = [ ":libyuv_internal" ]
+
+    public_configs = [ ":libyuv_config" ]
+  }
+}
+
+if (libyuv_include_tests) {
+  config("libyuv_unittest_warnings_config") {
+    if (!is_win) {
+      cflags = [
+        # TODO(fbarchard): Fix sign and unused variable warnings.
+        "-Wno-sign-compare",
+        "-Wno-unused-variable",
+      ]
+    }
+    if (is_win) {
+      cflags = [
+        "/wd4245",  # signed/unsigned mismatch
+        "/wd4189",  # local variable is initialized but not referenced
+      ]
+    }
+  }
+  config("libyuv_unittest_config") {
+    defines = [ "GTEST_RELATIVE_PATH" ]
+  }
+
+  test("libyuv_unittest") {
+    testonly = true
+
+    sources = [
+      "unit_test/basictypes_test.cc",
+      "unit_test/color_test.cc",
+      "unit_test/compare_test.cc",
+      "unit_test/convert_test.cc",
+      "unit_test/cpu_test.cc",
+      "unit_test/cpu_thread_test.cc",
+      "unit_test/math_test.cc",
+      "unit_test/planar_test.cc",
+      "unit_test/rotate_argb_test.cc",
+      "unit_test/rotate_test.cc",
+      "unit_test/scale_argb_test.cc",
+      "unit_test/scale_rgb_test.cc",
+      "unit_test/scale_test.cc",
+      "unit_test/scale_uv_test.cc",
+      "unit_test/unit_test.cc",
+      "unit_test/unit_test.h",
+      "unit_test/video_common_test.cc",
+    ]
+
+    deps = [
+      ":libyuv",
+      "//testing/gtest",
+    ]
+
+    defines = []
+    if (libyuv_use_absl_flags) {
+      defines += [ "LIBYUV_USE_ABSL_FLAGS" ]
+      deps += [
+        "//third_party/abseil-cpp/absl/flags:flag",
+        "//third_party/abseil-cpp/absl/flags:parse",
+      ]
+    }
+
+    configs += [ ":libyuv_unittest_warnings_config" ]
+
+    public_deps = [ "//testing/gtest" ]
+    public_configs = [ ":libyuv_unittest_config" ]
+
+    if (is_linux || is_chromeos) {
+      cflags = [ "-fexceptions" ]
+    }
+    if (is_ios) {
+      configs -= [ "//build/config/compiler:default_symbols" ]
+      configs += [ "//build/config/compiler:symbols" ]
+      cflags = [ "-Wno-sometimes-uninitialized" ]
+    }
+    if (!is_ios && !libyuv_disable_jpeg) {
+      defines += [ "HAVE_JPEG" ]
+    }
+    if (is_android) {
+      deps += [ "//testing/android/native_test:native_test_native_code" ]
+    }
+
+    # TODO(YangZhang): These lines can be removed when high accuracy
+    # YUV to RGB to Neon is ported.
+    if ((target_cpu == "armv7" || target_cpu == "armv7s" ||
+         (target_cpu == "arm" && arm_version >= 7) || target_cpu == "arm64") &&
+        (arm_use_neon || arm_optionally_use_neon)) {
+      defines += [ "LIBYUV_NEON" ]
+    }
+
+    defines += [
+      # Enable the following 3 macros to turn off assembly for specified CPU.
+      # "LIBYUV_DISABLE_X86",
+      # "LIBYUV_DISABLE_NEON",
+      # Enable the following macro to build libyuv as a shared library (dll).
+      # "LIBYUV_USING_SHARED_LIBRARY"
+    ]
+  }
+
+  executable("compare") {
+    sources = [
+      # sources
+      "util/compare.cc",
+    ]
+    deps = [ ":libyuv" ]
+    if (is_linux || is_chromeos) {
+      cflags = [ "-fexceptions" ]
+    }
+  }
+
+  executable("yuvconvert") {
+    sources = [
+      # sources
+      "util/yuvconvert.cc",
+    ]
+    deps = [ ":libyuv" ]
+    if (is_linux || is_chromeos) {
+      cflags = [ "-fexceptions" ]
+    }
+  }
+
+  executable("yuvconstants") {
+    sources = [
+      # sources
+      "util/yuvconstants.c",
+    ]
+    deps = [ ":libyuv" ]
+    if (is_linux || is_chromeos) {
+      cflags = [ "-fexceptions" ]
+    }
+  }
+
+  executable("psnr") {
+    sources = [
+      # sources
+      "util/psnr.cc",
+      "util/psnr_main.cc",
+      "util/ssim.cc",
+    ]
+    deps = [ ":libyuv" ]
+
+    if (!is_ios && !libyuv_disable_jpeg) {
+      defines = [ "HAVE_JPEG" ]
+    }
+  }
+
+  executable("i444tonv12_eg") {
+    sources = [
+      # sources
+      "util/i444tonv12_eg.cc",
+    ]
+    deps = [ ":libyuv" ]
+  }
+
+  executable("cpuid") {
+    sources = [
+      # sources
+      "util/cpuid.c",
+    ]
+    deps = [ ":libyuv" ]
+  }
+}
diff --git a/3rdparty/libyuv/src/CM_linux_packages.cmake b/3rdparty/libyuv/src/CM_linux_packages.cmake
new file mode 100644
index 00000000..5f676f89
--- /dev/null
+++ b/3rdparty/libyuv/src/CM_linux_packages.cmake
@@ -0,0 +1,69 @@
+# determine the version number from the #define in libyuv/version.h
+EXECUTE_PROCESS (
+	COMMAND grep --perl-regex --only-matching "(?<=LIBYUV_VERSION )[0-9]+" include/libyuv/version.h
+	WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
+	OUTPUT_VARIABLE YUV_VERSION_NUMBER
+	OUTPUT_STRIP_TRAILING_WHITESPACE )
+SET ( YUV_VER_MAJOR 0 )
+SET ( YUV_VER_MINOR 0 )
+SET ( YUV_VER_PATCH ${YUV_VERSION_NUMBER} )
+SET ( YUV_VERSION ${YUV_VER_MAJOR}.${YUV_VER_MINOR}.${YUV_VER_PATCH} )
+MESSAGE ( "Building ver.: ${YUV_VERSION}" )
+
+# is this a 32-bit or 64-bit build?
+IF ( CMAKE_SIZEOF_VOID_P EQUAL 8 )
+	SET ( YUV_BIT_SIZE 64 )
+ELSEIF ( CMAKE_SIZEOF_VOID_P EQUAL 4 )
+	SET ( YUV_BIT_SIZE 32 )
+ELSE ()
+	MESSAGE ( FATAL_ERROR "CMAKE_SIZEOF_VOID_P=${CMAKE_SIZEOF_VOID_P}" )
+ENDIF ()
+
+# detect if this is a ARM build
+STRING (FIND "${CMAKE_CXX_COMPILER}" "arm-linux-gnueabihf-g++" pos)
+IF ( ${pos} EQUAL -1 )
+	SET ( YUV_CROSS_COMPILE_FOR_ARM7 FALSE )
+ELSE ()
+	MESSAGE ( "Cross compiling for ARM7" )
+	SET ( YUV_CROSS_COMPILE_FOR_ARM7 TRUE )
+ENDIF ()
+STRING (FIND "${CMAKE_SYSTEM_PROCESSOR}" "arm" pos)
+IF ( ${pos} EQUAL -1 )
+	SET ( YUV_COMPILE_FOR_ARM7 FALSE )
+ELSE ()
+	MESSAGE ( "Compiling for ARM" )
+	SET ( YUV_COMPILE_FOR_ARM7 TRUE )
+ENDIF ()
+
+# setup the sytem name, such as "x86-32", "amd-64", and "arm-32
+IF ( ${YUV_CROSS_COMPILE_FOR_ARM7} OR ${YUV_COMPILE_FOR_ARM7} )
+	SET ( YUV_SYSTEM_NAME "armhf-${YUV_BIT_SIZE}" )
+ELSE ()
+	IF ( YUV_BIT_SIZE EQUAL 32 )
+		SET ( YUV_SYSTEM_NAME "x86-${YUV_BIT_SIZE}" )
+	ELSE ()
+		SET ( YUV_SYSTEM_NAME "amd-${YUV_BIT_SIZE}" )
+	ENDIF ()
+ENDIF ()
+MESSAGE ( "Packaging for: ${YUV_SYSTEM_NAME}" )
+
+# define all the variables needed by CPack to create .deb and .rpm packages
+SET ( CPACK_PACKAGE_VENDOR					"Frank Barchard" )
+SET ( CPACK_PACKAGE_CONTACT					"fbarchard@chromium.org" )
+SET ( CPACK_PACKAGE_VERSION					${YUV_VERSION} )
+SET ( CPACK_PACKAGE_VERSION_MAJOR			${YUV_VER_MAJOR} )
+SET ( CPACK_PACKAGE_VERSION_MINOR			${YUV_VER_MINOR} )
+SET ( CPACK_PACKAGE_VERSION_PATCH			${YUV_VER_PATCH} )
+SET ( CPACK_RESOURCE_FILE_LICENSE			${PROJECT_SOURCE_DIR}/LICENSE )
+SET ( CPACK_SYSTEM_NAME						"linux-${YUV_SYSTEM_NAME}" )
+SET ( CPACK_PACKAGE_NAME					"libyuv" )
+SET ( CPACK_PACKAGE_DESCRIPTION_SUMMARY		"YUV library" )
+SET ( CPACK_PACKAGE_DESCRIPTION				"YUV library and YUV conversion tool" )
+SET ( CPACK_DEBIAN_PACKAGE_SECTION			"other" )
+SET ( CPACK_DEBIAN_PACKAGE_PRIORITY			"optional" )
+SET ( CPACK_DEBIAN_PACKAGE_MAINTAINER		"Frank Barchard <fbarchard@chromium.org>" )
+SET ( CPACK_GENERATOR						"DEB;RPM" )
+
+# create the .deb and .rpm files (you'll need build-essential and rpm tools)
+INCLUDE( CPack )
+
diff --git a/3rdparty/libyuv/src/CMakeLists.txt b/3rdparty/libyuv/src/CMakeLists.txt
new file mode 100644
index 00000000..acfad8ee
--- /dev/null
+++ b/3rdparty/libyuv/src/CMakeLists.txt
@@ -0,0 +1,90 @@
+# CMakeLists for libyuv
+# Originally created for "roxlu build system" to compile libyuv on windows
+# Run with -DTEST=ON to build unit tests
+
+PROJECT ( YUV C CXX )	# "C" is required even for C++ projects
+CMAKE_MINIMUM_REQUIRED( VERSION 2.8 )
+OPTION( TEST "Built unit tests" OFF )
+
+SET ( ly_base_dir	${PROJECT_SOURCE_DIR} )
+SET ( ly_src_dir	${ly_base_dir}/source )
+SET ( ly_inc_dir	${ly_base_dir}/include )
+SET ( ly_tst_dir	${ly_base_dir}/unit_test )
+SET ( ly_lib_name	yuv )
+SET ( ly_lib_static	${ly_lib_name} )
+SET ( ly_lib_shared	${ly_lib_name}_shared )
+
+FILE ( GLOB_RECURSE	ly_source_files ${ly_src_dir}/*.cc )
+LIST ( SORT			ly_source_files )
+
+FILE ( GLOB_RECURSE	ly_unittest_sources ${ly_tst_dir}/*.cc )
+LIST ( SORT			ly_unittest_sources )
+
+INCLUDE_DIRECTORIES( BEFORE ${ly_inc_dir} )
+
+# this creates the static library (.a)
+ADD_LIBRARY				( ${ly_lib_static} STATIC ${ly_source_files} )
+
+# this creates the shared library (.so)
+# ADD_LIBRARY				( ${ly_lib_shared} SHARED ${ly_source_files} )
+# SET_TARGET_PROPERTIES	( ${ly_lib_shared} PROPERTIES OUTPUT_NAME "${ly_lib_name}" )
+# SET_TARGET_PROPERTIES	( ${ly_lib_shared} PROPERTIES PREFIX "lib" )
+
+# this creates the conversion tool
+# ADD_EXECUTABLE			( yuvconvert ${ly_base_dir}/util/yuvconvert.cc )
+# TARGET_LINK_LIBRARIES	( yuvconvert ${ly_lib_static} )
+
+
+set(JPEG_FOUND 1)
+
+if (JPEG_FOUND)
+  include_directories( ${PROJECT_SOURCE_DIR}/../../libjpeg/src/ )
+  include_directories( ${CMAKE_CURRENT_BINARY_DIR}/../../libjpeg/src/ )
+  add_definitions(-DHAVE_JPEG )
+  message ("DHAVE_JPEG jpeg done")
+  target_link_libraries(${ly_lib_static} turbojpeg_static)
+endif()
+
+if(TEST)
+  find_library(GTEST_LIBRARY gtest)
+  if(GTEST_LIBRARY STREQUAL "GTEST_LIBRARY-NOTFOUND")
+    set(GTEST_SRC_DIR /usr/src/gtest CACHE STRING "Location of gtest sources")
+    if(EXISTS ${GTEST_SRC_DIR}/src/gtest-all.cc)
+      message(STATUS "building gtest from sources in ${GTEST_SRC_DIR}")
+      set(gtest_sources ${GTEST_SRC_DIR}/src/gtest-all.cc)
+      add_library(gtest STATIC ${gtest_sources})
+      include_directories(${GTEST_SRC_DIR})
+      include_directories(${GTEST_SRC_DIR}/include)
+      set(GTEST_LIBRARY gtest)
+    else()
+      message(FATAL_ERROR "TEST is set but unable to find gtest library")
+    endif()
+  endif()
+
+  add_executable(libyuv_unittest ${ly_unittest_sources})
+  target_link_libraries(libyuv_unittest ${ly_lib_name} ${GTEST_LIBRARY})
+  find_library(PTHREAD_LIBRARY pthread)
+  if(NOT PTHREAD_LIBRARY STREQUAL "PTHREAD_LIBRARY-NOTFOUND")
+    target_link_libraries(libyuv_unittest pthread)
+  endif()
+  if (JPEG_FOUND)
+    target_link_libraries(libyuv_unittest ${JPEG_LIBRARY})
+  endif()
+
+  if(NACL AND NACL_LIBC STREQUAL "newlib")
+    target_link_libraries(libyuv_unittest glibc-compat)
+  endif()
+endif()
+
+
+# install the conversion tool, .so, .a, and all the header files
+# INSTALL ( PROGRAMS ${CMAKE_BINARY_DIR}/yuvconvert			DESTINATION bin )
+# INSTALL ( TARGETS ${ly_lib_static}						DESTINATION lib )
+# ob_add_target_property(${ly_lib_static} Module SDKLIB)
+#ob_add_library(${ly_lib_static} ${LIB_INSTALL_DIR})
+# INSTALL ( TARGETS ${ly_lib_shared} LIBRARY				DESTINATION lib RUNTIME DESTINATION bin )
+# INSTALL ( DIRECTORY ${PROJECT_SOURCE_DIR}/include/		DESTINATION include )
+
+# create the .deb and .rpm packages using cpack
+INCLUDE ( CM_linux_packages.cmake )
+
diff --git a/3rdparty/libyuv/src/DEPS b/3rdparty/libyuv/src/DEPS
new file mode 100644
index 00000000..7fb094d0
--- /dev/null
+++ b/3rdparty/libyuv/src/DEPS
@@ -0,0 +1,2330 @@
+gclient_gn_args_file = 'src/build/config/gclient_args.gni'
+gclient_gn_args = [
+  'generate_location_tags',
+]
+
+vars = {
+  'chromium_git': 'https://chromium.googlesource.com',
+  'chromium_revision': '829c6df33dce1085a61d8fd44209fc84bbf9a6a7',
+  'gn_version': 'git_revision:6f13aaac55a977e1948910942675c69f2b4f7a94',
+
+  # Keep the Chromium default of generating location tags.
+  'generate_location_tags': True,
+}
+
+deps = {
+  'src/build':
+    Var('chromium_git') + '/chromium/src/build' + '@' + 'dcea3443035f48d58193788e0bc56daca4e5db33',
+  'src/buildtools':
+    Var('chromium_git') + '/chromium/src/buildtools' + '@' + '075dd7e22837a69189003e4fa84499acf63188cf',
+  'src/testing':
+    Var('chromium_git') + '/chromium/src/testing' + '@' + 'f4e42be13265ec304b0f3085eee2b15f30f44077',
+  'src/third_party':
+    Var('chromium_git') + '/chromium/src/third_party' + '@' + '42c249feeb71bc0cd184849f0509aefef599343d',
+
+  'src/buildtools/linux64': {
+    'packages': [
+      {
+        'package': 'gn/gn/linux-amd64',
+        'version': Var('gn_version'),
+      }
+    ],
+    'dep_type': 'cipd',
+    'condition': 'checkout_linux',
+  },
+  'src/buildtools/mac': {
+    'packages': [
+      {
+        'package': 'gn/gn/mac-amd64',
+        'version': Var('gn_version'),
+      }
+    ],
+    'dep_type': 'cipd',
+    'condition': 'checkout_mac',
+  },
+  'src/buildtools/win': {
+    'packages': [
+      {
+        'package': 'gn/gn/windows-amd64',
+        'version': Var('gn_version'),
+      }
+    ],
+    'dep_type': 'cipd',
+    'condition': 'checkout_win',
+  },
+
+  'src/buildtools/clang_format/script':
+    Var('chromium_git') + '/external/github.com/llvm/llvm-project/clang/tools/clang-format.git' + '@' + '99876cacf78329e5f99c244dbe42ccd1654517a0',
+  'src/buildtools/third_party/libc++/trunk':
+    Var('chromium_git') + '/external/github.com/llvm/llvm-project/libcxx.git' + '@' + '79a2e924d96e2fc1e4b937c42efd08898fa472d7',
+  'src/buildtools/third_party/libc++abi/trunk':
+    Var('chromium_git') + '/external/github.com/llvm/llvm-project/libcxxabi.git' + '@' + '665b74f7d1b3bb295cd6ba7d8fcec1acd3d2ac84',
+  'src/buildtools/third_party/libunwind/trunk':
+    Var('chromium_git') + '/external/github.com/llvm/llvm-project/libunwind.git' + '@' + 'f51a154281bdfe746c46c07cd4fb05be97f9441d',
+
+  'src/third_party/catapult':
+    Var('chromium_git') + '/catapult.git' + '@' + '75423c310eb303d28978be892fcf7b9c2c824909',
+  'src/third_party/colorama/src':
+    Var('chromium_git') + '/external/colorama.git' + '@' + '799604a1041e9b3bc5d2789ecbd7e8db2e18e6b8',
+  'src/third_party/depot_tools':
+    Var('chromium_git') + '/chromium/tools/depot_tools.git' + '@' + '2ffa1bde797a8127c0f72908d0bd74051fd65d0d',
+  'src/third_party/freetype/src':
+    Var('chromium_git') + '/chromium/src/third_party/freetype2.git' + '@' + 'cff026d41599945498044d2f4dcc0e610ffb6929',
+  'src/third_party/googletest/src':
+    Var('chromium_git') + '/external/github.com/google/googletest.git' + '@' + 'e2f3978937c0244508135f126e2617a7734a68be',
+  'src/third_party/harfbuzz-ng/src':
+    Var('chromium_git') + '/external/github.com/harfbuzz/harfbuzz.git' + '@' + '64b29dbd5994a511acee69cb9b45ad650ef88359',
+  'src/third_party/libjpeg_turbo':
+    Var('chromium_git') + '/chromium/deps/libjpeg_turbo.git' + '@' + '02959c3ee17abacfd1339ec22ea93301292ffd56',
+  'src/third_party/nasm':
+    Var('chromium_git') + '/chromium/deps/nasm.git' + '@' + '9215e8e1d0fe474ffd3e16c1a07a0f97089e6224',
+  'src/tools':
+    Var('chromium_git') + '/chromium/src/tools' + '@' + '198dc879529652b39ba6e223bcc0bcad5f1facd6',
+
+  # libyuv-only dependencies (not present in Chromium).
+  'src/third_party/gtest-parallel':
+    Var('chromium_git') + '/external/webrtc/deps/third_party/gtest-parallel' + '@' + '1dad0e9f6d82ff994130b529d7d814b40eb32b0e',
+
+  'src/third_party/lss': {
+    'url': Var('chromium_git') + '/linux-syscall-support.git' + '@' + '92a65a8f5d705d1928874420c8d0d15bde8c89e5',
+    'condition': 'checkout_android or checkout_linux',
+  },
+
+  # Android deps:
+  'src/third_party/accessibility_test_framework': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/accessibility-test-framework',
+              'version': 'b5ec1e56e58e56bc1a0c77d43111c37f9b512c8a',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/auto/src': {
+    'url': Var('chromium_git') + '/external/github.com/google/auto.git' + '@' + 'fe67d853d6356943dc79541c892ab6d3e6a7b61a',
+    'condition': 'checkout_android',
+  },
+  'src/third_party/boringssl/src':
+    'https://boringssl.googlesource.com/boringssl.git' + '@' + '3a667d10e94186fd503966f5638e134fe9fb4080',
+  'src/base': {
+    'url': Var('chromium_git') + '/chromium/src/base' + '@' + 'e9e639622449a893a1b5e32781d072cec08ead72',
+    'condition': 'checkout_android',
+  },
+  'src/third_party/bazel': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/bazel',
+              'version': 'VjMsf48QUWw8n7XtJP2AuSjIGmbQeYdWdwyxVvIRLmAC',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/bouncycastle': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/bouncycastle',
+              'version': 'c078e87552ba26e776566fdaf0f22cd8712743d0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_ndk': {
+    'url': Var('chromium_git') + '/android_ndk.git' + '@' + '401019bf85744311b26c88ced255cd53401af8b7',
+    'condition': 'checkout_android',
+  },
+  'src/third_party/androidx': {
+    'packages': [
+      {
+          'package': 'chromium/third_party/androidx',
+          'version': '6d8ij5pzYh29WWjPbdbAWFBJSA1nUgkWf2p6wCVZKIsC',
+      },
+    ],
+    'condition': 'checkout_android',
+    'dep_type': 'cipd',
+  },
+  'src/third_party/android_support_test_runner': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_support_test_runner',
+              'version': '96d4bf848cd210fdcbca6bcc8c1b4b39cbd93141',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_sdk/public': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_sdk/public/build-tools/31.0.0',
+              'version': 'tRoD45SCi7UleQqSV7MrMQO1_e5P8ysphkCcj6z_cCQC',
+          },
+          {
+              'package': 'chromium/third_party/android_sdk/public/emulator',
+              'version': 'gMHhUuoQRKfxr-MBn3fNNXZtkAVXtOwMwT7kfx8jkIgC',
+          },
+          {
+              'package': 'chromium/third_party/android_sdk/public/extras',
+              'version': 'ppQ4TnqDvBHQ3lXx5KPq97egzF5X2FFyOrVHkGmiTMQC',
+          },
+          {
+              'package': 'chromium/third_party/android_sdk/public/patcher',
+              'version': 'I6FNMhrXlpB-E1lOhMlvld7xt9lBVNOO83KIluXDyA0C',
+          },
+          {
+              'package': 'chromium/third_party/android_sdk/public/platform-tools',
+              'version': 'g7n_-r6yJd_SGRklujGB1wEt8iyr77FZTUJVS9w6O34C',
+          },
+          {
+              'package': 'chromium/third_party/android_sdk/public/platforms/android-31',
+              'version': 'lL3IGexKjYlwjO_1Ga-xwxgwbE_w-lmi2Zi1uOlWUIAC',
+          },
+          {
+              'package': 'chromium/third_party/android_sdk/public/sources/android-31',
+              'version': '_a_BcnANjPYw5mSKlNHa7GFY8yc1kdqj2rmQgac7yUcC',
+          },
+          {
+              'package': 'chromium/third_party/android_sdk/public/cmdline-tools',
+              'version': 'Ez2NWws2SJYCF6qw2O-mSCqK6424l3ZdSTpppLyVR_cC',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/tools/clang/dsymutil': {
+    'packages': [
+      {
+        'package': 'chromium/llvm-build-tools/dsymutil',
+        'version': 'OWlhXkmj18li3yhJk59Kmjbc5KdgLh56TwCd1qBdzlIC',
+      }
+    ],
+    'condition': 'checkout_mac',
+    'dep_type': 'cipd',
+  },
+  'src/third_party/android_build_tools/aapt2': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_build_tools/aapt2',
+              'version': 'version:3.6.0-alpha03-5516695-cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/byte_buddy': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/byte_buddy',
+              'version': 'c9b53316603fc2d997c899c7ca1707f809b918cd',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/ced/src': {
+    'url': Var('chromium_git') + '/external/github.com/google/compact_enc_det.git' + '@' + 'ba412eaaacd3186085babcd901679a48863c7dd5',
+    'condition': 'checkout_android',
+  },
+  'src/third_party/errorprone/lib': {
+      'url': Var('chromium_git') + '/chromium/third_party/errorprone.git' + '@' + '980d49e839aa4984015efed34b0134d4b2c9b6d7',
+      'condition': 'checkout_android',
+  },
+  'src/third_party/findbugs': {
+    'url': Var('chromium_git') + '/chromium/deps/findbugs.git' + '@' + '4275d9ac8610db6b1bc9a5e887f97e41b33fac67',
+    'condition': 'checkout_android',
+  },
+  'src/third_party/gson': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/gson',
+              'version': '681931c9778045903a0ed59856ce2dd8dd7bf7ca',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/guava': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/guava',
+              'version': 'a6fba501f3a0de88b9be1daa2052632de5b96a46',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/hamcrest': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/hamcrest',
+              'version': '37eccfc658fe79695d6abb6dd497463c4372032f',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+
+  'src/third_party/icu': {
+    'url': Var('chromium_git') + '/chromium/deps/icu.git' + '@' + 'bf66d373ae781a3498f2babe7b61d933dd774b82',
+  },
+  'src/third_party/icu4j': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/icu4j',
+              'version': 'e87e5bed2b4935913ee26a3ebd0b723ee2344354',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/intellij': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/intellij',
+              'version': '77c2721b024b36ee073402c08e6d8428c0295336',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/jdk': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/jdk',
+              'version': 'PfRSnxe8Od6WU4zBXomq-zsgcJgWmm3z4gMQNB-r2QcC',
+          },
+          {
+              'package': 'chromium/third_party/jdk/extras',
+              'version': 'fkhuOQ3r-zKtWEdKplpo6k0vKkjl-LY_rJTmtzFCQN4C',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/jsr-305/src': {
+    'url': Var('chromium_git') + '/external/jsr-305.git' + '@' + '642c508235471f7220af6d5df2d3210e3bfc0919',
+    'condition': 'checkout_android',
+  },
+  'src/third_party/junit/src': {
+    'url': Var('chromium_git') + '/external/junit.git' + '@' + '64155f8a9babcfcf4263cf4d08253a1556e75481',
+    'condition': 'checkout_android',
+  },
+  'src/third_party/libunwindstack': {
+      'url': Var('chromium_git') + '/chromium/src/third_party/libunwindstack.git' + '@' + '6868358481bb1e5e20d155c1084dc436c88b5e6b',
+      'condition': 'checkout_android',
+  },
+  'src/third_party/mockito/src': {
+    'url': Var('chromium_git') + '/external/mockito/mockito.git' + '@' + '04a2a289a4222f80ad20717c25144981210d2eac',
+    'condition': 'checkout_android',
+  },
+  'src/third_party/objenesis': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/objenesis',
+              'version': '9e367f55e5a65781ee77bfcbaa88fb82b30e75c0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/ow2_asm': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/ow2_asm',
+              'version': 'NNAhdJzMdnutUVqfSJm5v0tVazA9l3Dd6CRwH6N4Q5kC',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/r8': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/r8',
+              'version': 'Nu_mvQJe34CotIXadFlA3w732CJ9EvQGuVs4udcZedAC',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/proguard': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/proguard',
+              'version': 'Fd91BJFVlmiO6c46YMTsdy7n2f5Sk2hVVGlzPLvqZPsC',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/requests/src': {
+    'url': Var('chromium_git') + '/external/github.com/kennethreitz/requests.git' + '@' + 'refs/tags/v2.23.0',
+    'condition': 'checkout_android',
+  },
+  'src/third_party/robolectric': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/robolectric',
+              'version': 'iC6RDM5EH3GEAzR-1shW_Mg0FeeNE5shq1okkFfuuNQC',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/sqlite4java': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/sqlite4java',
+              'version': '889660698187baa7c8b0d79f7bf58563125fbd66',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/turbine': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/turbine',
+              'version': 'Om6yIEXgJxuqghErK29h9RcMH6VaymMbxwScwXmcN6EC',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/ub-uiautomator/lib': {
+    'url': Var('chromium_git') + '/chromium/third_party/ub-uiautomator.git' + '@' + '00270549ce3161ae72ceb24712618ea28b4f9434',
+    'condition': 'checkout_android',
+  },
+
+  # iOS deps:
+  'src/ios': {
+    'url': Var('chromium_git') + '/chromium/src/ios' + '@' + '81826d980c159f949c2c7901f4dbec9a09788964',
+    'condition': 'checkout_ios'
+  },
+
+  # Everything coming after this is automatically updated by the auto-roller.
+  # === ANDROID_DEPS Generated Code Start ===
+
+  'src/third_party/android_deps/libs/android_arch_core_common': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/android_arch_core_common',
+              'version': 'version:2@1.1.1.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/android_arch_core_runtime': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/android_arch_core_runtime',
+              'version': 'version:2@1.1.1.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/android_arch_lifecycle_common': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/android_arch_lifecycle_common',
+              'version': 'version:2@1.1.1.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/android_arch_lifecycle_common_java8': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/android_arch_lifecycle_common_java8',
+              'version': 'version:2@1.1.1.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/android_arch_lifecycle_livedata': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/android_arch_lifecycle_livedata',
+              'version': 'version:2@1.1.1.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/android_arch_lifecycle_livedata_core': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/android_arch_lifecycle_livedata_core',
+              'version': 'version:2@1.1.1.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/android_arch_lifecycle_runtime': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/android_arch_lifecycle_runtime',
+              'version': 'version:2@1.1.1.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/android_arch_lifecycle_viewmodel': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/android_arch_lifecycle_viewmodel',
+              'version': 'version:2@1.1.1.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/backport_util_concurrent_backport_util_concurrent': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/backport_util_concurrent_backport_util_concurrent',
+              'version': 'version:2@3.1.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/classworlds_classworlds': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/classworlds_classworlds',
+              'version': 'version:2@1.1-alpha-2.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_android_support_animated_vector_drawable': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_android_support_animated_vector_drawable',
+              'version': 'version:2@28.0.0.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_android_support_appcompat_v7': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_android_support_appcompat_v7',
+              'version': 'version:2@28.0.0.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_android_support_asynclayoutinflater': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_android_support_asynclayoutinflater',
+              'version': 'version:2@28.0.0.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_android_support_cardview_v7': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_android_support_cardview_v7',
+              'version': 'version:2@28.0.0.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_android_support_collections': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_android_support_collections',
+              'version': 'version:2@28.0.0.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_android_support_coordinatorlayout': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_android_support_coordinatorlayout',
+              'version': 'version:2@28.0.0.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_android_support_cursoradapter': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_android_support_cursoradapter',
+              'version': 'version:2@28.0.0.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_android_support_customview': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_android_support_customview',
+              'version': 'version:2@28.0.0.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_android_support_design': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_android_support_design',
+              'version': 'version:2@28.0.0.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_android_support_documentfile': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_android_support_documentfile',
+              'version': 'version:2@28.0.0.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_android_support_drawerlayout': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_android_support_drawerlayout',
+              'version': 'version:2@28.0.0.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_android_support_interpolator': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_android_support_interpolator',
+              'version': 'version:2@28.0.0.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_android_support_loader': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_android_support_loader',
+              'version': 'version:2@28.0.0.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_android_support_localbroadcastmanager': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_android_support_localbroadcastmanager',
+              'version': 'version:2@28.0.0.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_android_support_multidex': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_android_support_multidex',
+              'version': 'version:2@1.0.0.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_android_support_print': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_android_support_print',
+              'version': 'version:2@28.0.0.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_android_support_recyclerview_v7': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_android_support_recyclerview_v7',
+              'version': 'version:2@28.0.0.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_android_support_slidingpanelayout': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_android_support_slidingpanelayout',
+              'version': 'version:2@28.0.0.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_android_support_support_annotations': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_android_support_support_annotations',
+              'version': 'version:2@28.0.0.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_android_support_support_compat': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_android_support_support_compat',
+              'version': 'version:2@28.0.0.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_android_support_support_core_ui': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_android_support_support_core_ui',
+              'version': 'version:2@28.0.0.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_android_support_support_core_utils': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_android_support_support_core_utils',
+              'version': 'version:2@28.0.0.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_android_support_support_fragment': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_android_support_support_fragment',
+              'version': 'version:2@28.0.0.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_android_support_support_media_compat': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_android_support_support_media_compat',
+              'version': 'version:2@28.0.0.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_android_support_support_v4': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_android_support_support_v4',
+              'version': 'version:2@28.0.0.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_android_support_support_vector_drawable': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_android_support_support_vector_drawable',
+              'version': 'version:2@28.0.0.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_android_support_swiperefreshlayout': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_android_support_swiperefreshlayout',
+              'version': 'version:2@28.0.0.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_android_support_transition': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_android_support_transition',
+              'version': 'version:2@28.0.0.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_android_support_versionedparcelable': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_android_support_versionedparcelable',
+              'version': 'version:2@28.0.0.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_android_support_viewpager': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_android_support_viewpager',
+              'version': 'version:2@28.0.0.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_android_tools_common': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_android_tools_common',
+              'version': 'version:2@30.0.0-alpha10.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_android_tools_desugar_jdk_libs': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_android_tools_desugar_jdk_libs',
+              'version': 'version:2@1.1.1.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_android_tools_desugar_jdk_libs_configuration': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_android_tools_desugar_jdk_libs_configuration',
+              'version': 'version:2@1.1.1.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_android_tools_layoutlib_layoutlib_api': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_android_tools_layoutlib_layoutlib_api',
+              'version': 'version:2@30.0.0-alpha10.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_android_tools_sdk_common': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_android_tools_sdk_common',
+              'version': 'version:2@30.0.0-alpha10.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_github_ben_manes_caffeine_caffeine': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_github_ben_manes_caffeine_caffeine',
+              'version': 'version:2@2.8.8.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_github_kevinstern_software_and_algorithms': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_github_kevinstern_software_and_algorithms',
+              'version': 'version:2@1.0.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_google_android_datatransport_transport_api': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_google_android_datatransport_transport_api',
+              'version': 'version:2@2.2.1.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_google_android_gms_play_services_auth': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_google_android_gms_play_services_auth',
+              'version': 'version:2@17.0.0.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_google_android_gms_play_services_auth_api_phone': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_google_android_gms_play_services_auth_api_phone',
+              'version': 'version:2@17.5.0.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_google_android_gms_play_services_auth_base': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_google_android_gms_play_services_auth_base',
+              'version': 'version:2@17.0.0.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_google_android_gms_play_services_base': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_google_android_gms_play_services_base',
+              'version': 'version:2@17.5.0.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_google_android_gms_play_services_basement': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_google_android_gms_play_services_basement',
+              'version': 'version:2@17.5.0.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_google_android_gms_play_services_cast': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_google_android_gms_play_services_cast',
+              'version': 'version:2@17.0.0.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_google_android_gms_play_services_cast_framework': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_google_android_gms_play_services_cast_framework',
+              'version': 'version:2@17.0.0.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_google_android_gms_play_services_clearcut': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_google_android_gms_play_services_clearcut',
+              'version': 'version:2@17.0.0.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_google_android_gms_play_services_cloud_messaging': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_google_android_gms_play_services_cloud_messaging',
+              'version': 'version:2@16.0.0.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_google_android_gms_play_services_fido': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_google_android_gms_play_services_fido',
+              'version': 'version:2@19.0.0-beta.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_google_android_gms_play_services_flags': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_google_android_gms_play_services_flags',
+              'version': 'version:2@17.0.0.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_google_android_gms_play_services_gcm': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_google_android_gms_play_services_gcm',
+              'version': 'version:2@17.0.0.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_google_android_gms_play_services_iid': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_google_android_gms_play_services_iid',
+              'version': 'version:2@17.0.0.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_google_android_gms_play_services_instantapps': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_google_android_gms_play_services_instantapps',
+              'version': 'version:2@17.0.0.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_google_android_gms_play_services_location': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_google_android_gms_play_services_location',
+              'version': 'version:2@17.0.0.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_google_android_gms_play_services_phenotype': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_google_android_gms_play_services_phenotype',
+              'version': 'version:2@17.0.0.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_google_android_gms_play_services_places_placereport': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_google_android_gms_play_services_places_placereport',
+              'version': 'version:2@17.0.0.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_google_android_gms_play_services_stats': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_google_android_gms_play_services_stats',
+              'version': 'version:2@17.0.0.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_google_android_gms_play_services_tasks': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_google_android_gms_play_services_tasks',
+              'version': 'version:2@17.2.0.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_google_android_gms_play_services_vision': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_google_android_gms_play_services_vision',
+              'version': 'version:2@18.0.0.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_google_android_gms_play_services_vision_common': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_google_android_gms_play_services_vision_common',
+              'version': 'version:2@18.0.0.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_google_android_material_material': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_google_android_material_material',
+              'version': 'version:2@1.6.0-alpha01.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_google_android_play_core': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_google_android_play_core',
+              'version': 'version:2@1.10.0.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_google_auto_auto_common': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_google_auto_auto_common',
+              'version': 'version:2@1.1.2.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_google_auto_service_auto_service': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_google_auto_service_auto_service',
+              'version': 'version:2@1.0-rc6.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_google_auto_service_auto_service_annotations': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_google_auto_service_auto_service_annotations',
+              'version': 'version:2@1.0-rc6.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_google_auto_value_auto_value_annotations': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_google_auto_value_auto_value_annotations',
+              'version': 'version:2@1.7.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_google_code_findbugs_jformatstring': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_google_code_findbugs_jformatstring',
+              'version': 'version:2@3.0.0.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_google_code_findbugs_jsr305': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_google_code_findbugs_jsr305',
+              'version': 'version:2@3.0.2.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_google_code_gson_gson': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_google_code_gson_gson',
+              'version': 'version:2@2.8.0.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_google_dagger_dagger': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_google_dagger_dagger',
+              'version': 'version:2@2.30.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_google_dagger_dagger_compiler': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_google_dagger_dagger_compiler',
+              'version': 'version:2@2.30.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_google_dagger_dagger_producers': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_google_dagger_dagger_producers',
+              'version': 'version:2@2.30.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_google_dagger_dagger_spi': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_google_dagger_dagger_spi',
+              'version': 'version:2@2.30.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_google_errorprone_error_prone_annotation': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_google_errorprone_error_prone_annotation',
+              'version': 'version:2@2.10.0.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_google_errorprone_error_prone_annotations': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_google_errorprone_error_prone_annotations',
+              'version': 'version:2@2.10.0.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_google_errorprone_error_prone_check_api': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_google_errorprone_error_prone_check_api',
+              'version': 'version:2@2.10.0.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_google_errorprone_error_prone_core': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_google_errorprone_error_prone_core',
+              'version': 'version:2@2.10.0.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_google_errorprone_error_prone_type_annotations': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_google_errorprone_error_prone_type_annotations',
+              'version': 'version:2@2.10.0.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_google_errorprone_javac': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_google_errorprone_javac',
+              'version': 'version:2@9+181-r4173-1.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_google_errorprone_javac_shaded': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_google_errorprone_javac_shaded',
+              'version': 'version:2@9-dev-r4023-3.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_google_firebase_firebase_annotations': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_google_firebase_firebase_annotations',
+              'version': 'version:2@16.0.0.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_google_firebase_firebase_common': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_google_firebase_firebase_common',
+              'version': 'version:2@19.5.0.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_google_firebase_firebase_components': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_google_firebase_firebase_components',
+              'version': 'version:2@16.1.0.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_google_firebase_firebase_encoders': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_google_firebase_firebase_encoders',
+              'version': 'version:2@16.1.0.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_google_firebase_firebase_encoders_json': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_google_firebase_firebase_encoders_json',
+              'version': 'version:2@17.1.0.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_google_firebase_firebase_iid': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_google_firebase_firebase_iid',
+              'version': 'version:2@21.0.1.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_google_firebase_firebase_iid_interop': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_google_firebase_firebase_iid_interop',
+              'version': 'version:2@17.0.0.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_google_firebase_firebase_installations': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_google_firebase_firebase_installations',
+              'version': 'version:2@16.3.5.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_google_firebase_firebase_installations_interop': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_google_firebase_firebase_installations_interop',
+              'version': 'version:2@16.0.1.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_google_firebase_firebase_measurement_connector': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_google_firebase_firebase_measurement_connector',
+              'version': 'version:2@18.0.0.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_google_firebase_firebase_messaging': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_google_firebase_firebase_messaging',
+              'version': 'version:2@21.0.1.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_google_flatbuffers_flatbuffers_java': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_google_flatbuffers_flatbuffers_java',
+              'version': 'version:2@2.0.3.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_google_googlejavaformat_google_java_format': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_google_googlejavaformat_google_java_format',
+              'version': 'version:2@1.5.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_google_guava_failureaccess': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_google_guava_failureaccess',
+              'version': 'version:2@1.0.1.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_google_guava_guava': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_google_guava_guava',
+              'version': 'version:2@31.0-jre.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_google_guava_guava_android': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_google_guava_guava_android',
+              'version': 'version:2@31.0-android.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_google_guava_listenablefuture': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_google_guava_listenablefuture',
+              'version': 'version:2@1.0.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_google_j2objc_j2objc_annotations': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_google_j2objc_j2objc_annotations',
+              'version': 'version:2@1.3.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_google_protobuf_protobuf_java': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_google_protobuf_protobuf_java',
+              'version': 'version:2@3.4.0.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_google_protobuf_protobuf_javalite': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_google_protobuf_protobuf_javalite',
+              'version': 'version:2@3.13.0.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_googlecode_java_diff_utils_diffutils': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_googlecode_java_diff_utils_diffutils',
+              'version': 'version:2@1.3.0.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_squareup_javapoet': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_squareup_javapoet',
+              'version': 'version:2@1.13.0.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/com_squareup_javawriter': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/com_squareup_javawriter',
+              'version': 'version:2@2.1.1.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/io_github_java_diff_utils_java_diff_utils': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/io_github_java_diff_utils_java_diff_utils',
+              'version': 'version:2@4.0.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/javax_annotation_javax_annotation_api': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/javax_annotation_javax_annotation_api',
+              'version': 'version:2@1.3.2.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/javax_annotation_jsr250_api': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/javax_annotation_jsr250_api',
+              'version': 'version:2@1.0.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/javax_inject_javax_inject': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/javax_inject_javax_inject',
+              'version': 'version:2@1.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/nekohtml_nekohtml': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/nekohtml_nekohtml',
+              'version': 'version:2@1.9.6.2.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/nekohtml_xercesminimal': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/nekohtml_xercesminimal',
+              'version': 'version:2@1.9.6.2.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/net_ltgt_gradle_incap_incap': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/net_ltgt_gradle_incap_incap',
+              'version': 'version:2@0.2.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/net_sf_kxml_kxml2': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/net_sf_kxml_kxml2',
+              'version': 'version:2@2.3.0.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/org_apache_ant_ant': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/org_apache_ant_ant',
+              'version': 'version:2@1.8.0.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/org_apache_ant_ant_launcher': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/org_apache_ant_ant_launcher',
+              'version': 'version:2@1.8.0.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/org_apache_maven_maven_ant_tasks': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/org_apache_maven_maven_ant_tasks',
+              'version': 'version:2@2.1.3.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/org_apache_maven_maven_artifact': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/org_apache_maven_maven_artifact',
+              'version': 'version:2@2.2.1.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/org_apache_maven_maven_artifact_manager': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/org_apache_maven_maven_artifact_manager',
+              'version': 'version:2@2.2.1.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/org_apache_maven_maven_error_diagnostics': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/org_apache_maven_maven_error_diagnostics',
+              'version': 'version:2@2.2.1.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/org_apache_maven_maven_model': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/org_apache_maven_maven_model',
+              'version': 'version:2@2.2.1.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/org_apache_maven_maven_plugin_registry': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/org_apache_maven_maven_plugin_registry',
+              'version': 'version:2@2.2.1.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/org_apache_maven_maven_profile': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/org_apache_maven_maven_profile',
+              'version': 'version:2@2.2.1.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/org_apache_maven_maven_project': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/org_apache_maven_maven_project',
+              'version': 'version:2@2.2.1.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/org_apache_maven_maven_repository_metadata': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/org_apache_maven_maven_repository_metadata',
+              'version': 'version:2@2.2.1.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/org_apache_maven_maven_settings': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/org_apache_maven_maven_settings',
+              'version': 'version:2@2.2.1.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/org_apache_maven_wagon_wagon_file': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/org_apache_maven_wagon_wagon_file',
+              'version': 'version:2@1.0-beta-6.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/org_apache_maven_wagon_wagon_http_lightweight': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/org_apache_maven_wagon_wagon_http_lightweight',
+              'version': 'version:2@1.0-beta-6.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/org_apache_maven_wagon_wagon_http_shared': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/org_apache_maven_wagon_wagon_http_shared',
+              'version': 'version:2@1.0-beta-6.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/org_apache_maven_wagon_wagon_provider_api': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/org_apache_maven_wagon_wagon_provider_api',
+              'version': 'version:2@1.0-beta-6.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/org_ccil_cowan_tagsoup_tagsoup': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/org_ccil_cowan_tagsoup_tagsoup',
+              'version': 'version:2@1.2.1.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/org_checkerframework_checker_compat_qual': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/org_checkerframework_checker_compat_qual',
+              'version': 'version:2@2.5.5.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/org_checkerframework_checker_qual': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/org_checkerframework_checker_qual',
+              'version': 'version:2@3.12.0.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/org_checkerframework_dataflow_errorprone': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/org_checkerframework_dataflow_errorprone',
+              'version': 'version:2@3.15.0.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/org_codehaus_mojo_animal_sniffer_annotations': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/org_codehaus_mojo_animal_sniffer_annotations',
+              'version': 'version:2@1.17.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/org_codehaus_plexus_plexus_container_default': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/org_codehaus_plexus_plexus_container_default',
+              'version': 'version:2@1.0-alpha-9-stable-1.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/org_codehaus_plexus_plexus_interpolation': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/org_codehaus_plexus_plexus_interpolation',
+              'version': 'version:2@1.11.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/org_codehaus_plexus_plexus_utils': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/org_codehaus_plexus_plexus_utils',
+              'version': 'version:2@1.5.15.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/org_eclipse_jgit_org_eclipse_jgit': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/org_eclipse_jgit_org_eclipse_jgit',
+              'version': 'version:2@4.4.1.201607150455-r.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/org_jetbrains_annotations': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/org_jetbrains_annotations',
+              'version': 'version:2@13.0.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/org_jetbrains_kotlin_kotlin_stdlib': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/org_jetbrains_kotlin_kotlin_stdlib',
+              'version': 'version:2@1.6.0.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/org_jetbrains_kotlin_kotlin_stdlib_common': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/org_jetbrains_kotlin_kotlin_stdlib_common',
+              'version': 'version:2@1.6.0.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/org_jetbrains_kotlin_kotlin_stdlib_jdk7': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/org_jetbrains_kotlin_kotlin_stdlib_jdk7',
+              'version': 'version:2@1.5.0.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/org_jetbrains_kotlin_kotlin_stdlib_jdk8': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/org_jetbrains_kotlin_kotlin_stdlib_jdk8',
+              'version': 'version:2@1.5.0.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/org_jetbrains_kotlinx_kotlinx_coroutines_android': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/org_jetbrains_kotlinx_kotlinx_coroutines_android',
+              'version': 'version:2@1.5.0.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/org_jetbrains_kotlinx_kotlinx_coroutines_core_jvm': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/org_jetbrains_kotlinx_kotlinx_coroutines_core_jvm',
+              'version': 'version:2@1.5.0.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/org_jetbrains_kotlinx_kotlinx_metadata_jvm': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/org_jetbrains_kotlinx_kotlinx_metadata_jvm',
+              'version': 'version:2@0.1.0.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/org_ow2_asm_asm': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/org_ow2_asm_asm',
+              'version': 'version:2@7.0.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/org_ow2_asm_asm_analysis': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/org_ow2_asm_asm_analysis',
+              'version': 'version:2@7.0.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/org_ow2_asm_asm_commons': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/org_ow2_asm_asm_commons',
+              'version': 'version:2@7.0.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/org_ow2_asm_asm_tree': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/org_ow2_asm_asm_tree',
+              'version': 'version:2@7.0.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/org_ow2_asm_asm_util': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/org_ow2_asm_asm_util',
+              'version': 'version:2@7.0.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/org_pcollections_pcollections': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/org_pcollections_pcollections',
+              'version': 'version:2@2.1.2.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/org_robolectric_annotations': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/org_robolectric_annotations',
+              'version': 'version:2@4.3.1.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/org_robolectric_junit': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/org_robolectric_junit',
+              'version': 'version:2@4.3.1.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/org_robolectric_pluginapi': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/org_robolectric_pluginapi',
+              'version': 'version:2@4.3.1.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/org_robolectric_plugins_maven_dependency_resolver': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/org_robolectric_plugins_maven_dependency_resolver',
+              'version': 'version:2@4.3.1.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/org_robolectric_resources': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/org_robolectric_resources',
+              'version': 'version:2@4.3.1.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/org_robolectric_robolectric': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/org_robolectric_robolectric',
+              'version': 'version:2@4.3.1.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/org_robolectric_sandbox': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/org_robolectric_sandbox',
+              'version': 'version:2@4.3.1.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/org_robolectric_shadowapi': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/org_robolectric_shadowapi',
+              'version': 'version:2@4.3.1.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/org_robolectric_shadows_framework': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/org_robolectric_shadows_framework',
+              'version': 'version:2@4.3.1.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/org_robolectric_shadows_playservices': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/org_robolectric_shadows_playservices',
+              'version': 'version:2@4.3.1.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/org_robolectric_utils': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/org_robolectric_utils',
+              'version': 'version:2@4.3.1.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+  'src/third_party/android_deps/libs/org_robolectric_utils_reflector': {
+      'packages': [
+          {
+              'package': 'chromium/third_party/android_deps/libs/org_robolectric_utils_reflector',
+              'version': 'version:2@4.3.1.cr0',
+          },
+      ],
+      'condition': 'checkout_android',
+      'dep_type': 'cipd',
+  },
+
+  # === ANDROID_DEPS Generated Code End ===
+}
+
+pre_deps_hooks = [
+  {
+    # Remove any symlinks from before 177567c518b121731e507e9b9c4049c4dc96e4c8.
+    # TODO(kjellander): Remove this in March 2017.
+    'name': 'cleanup_links',
+    'pattern': '.',
+    'action': ['python3', 'src/cleanup_links.py'],
+  },
+]
+
+hooks = [
+  {
+    # This clobbers when necessary (based on get_landmines.py). It should be
+    # an early hook but it will need to be run after syncing Chromium and
+    # setting up the links, so the script actually exists.
+    'name': 'landmines',
+    'pattern': '.',
+    'action': [
+        'python3',
+        'src/build/landmines.py',
+        '--landmine-scripts',
+        'src/tools_libyuv/get_landmines.py',
+        '--src-dir',
+        'src',
+    ],
+  },
+  # Downloads the current stable linux sysroot to build/linux/ if needed.
+  {
+    'name': 'sysroot_arm',
+    'pattern': '.',
+    'condition': 'checkout_linux and checkout_arm',
+    'action': ['python3', 'src/build/linux/sysroot_scripts/install-sysroot.py',
+               '--arch=arm'],
+  },
+  {
+    'name': 'sysroot_arm64',
+    'pattern': '.',
+    'condition': 'checkout_linux and checkout_arm64',
+    'action': ['python3', 'src/build/linux/sysroot_scripts/install-sysroot.py',
+               '--arch=arm64'],
+  },
+  {
+    'name': 'sysroot_x86',
+    'pattern': '.',
+    'condition': 'checkout_linux and (checkout_x86 or checkout_x64)',
+    'action': ['python3', 'src/build/linux/sysroot_scripts/install-sysroot.py',
+               '--arch=x86'],
+  },
+  {
+    'name': 'sysroot_mips',
+    'pattern': '.',
+    'condition': 'checkout_linux and checkout_mips',
+    'action': ['python3', 'src/build/linux/sysroot_scripts/install-sysroot.py',
+               '--arch=mips'],
+  },
+  {
+    'name': 'sysroot_x64',
+    'pattern': '.',
+    'condition': 'checkout_linux and checkout_x64',
+    'action': ['python3', 'src/build/linux/sysroot_scripts/install-sysroot.py',
+               '--arch=x64'],
+  },
+  {
+    # Update the Windows toolchain if necessary.
+    'name': 'win_toolchain',
+    'pattern': '.',
+    'action': ['python3', 'src/build/vs_toolchain.py', 'update'],
+  },
+  {
+    # Update the Mac toolchain if necessary.
+    'name': 'mac_toolchain',
+    'pattern': '.',
+    'action': ['python3', 'src/build/mac_toolchain.py'],
+    'condition': 'checkout_mac',
+  },
+  {
+    'name': 'msan_chained_origins',
+    'pattern': '.',
+    'condition': 'checkout_instrumented_libraries',
+    'action': [ 'python',
+                'src/third_party/depot_tools/download_from_google_storage.py',
+                "--no_resume",
+                "--no_auth",
+                "--bucket", "chromium-instrumented-libraries",
+                "-s", "src/third_party/instrumented_libraries/binaries/msan-chained-origins.tgz.sha1",
+              ],
+  },
+  {
+    'name': 'msan_no_origins',
+    'pattern': '.',
+    'condition': 'checkout_instrumented_libraries',
+    'action': [ 'python',
+                'src/third_party/depot_tools/download_from_google_storage.py',
+                "--no_resume",
+                "--no_auth",
+                "--bucket", "chromium-instrumented-libraries",
+                "-s", "src/third_party/instrumented_libraries/binaries/msan-no-origins.tgz.sha1",
+              ],
+  },
+  {
+    # Pull clang if needed or requested via GYP_DEFINES.
+    # Note: On Win, this should run after win_toolchain, as it may use it.
+    'name': 'clang',
+    'pattern': '.',
+    'action': ['python3', 'src/tools/clang/scripts/update.py'],
+  },
+  {
+    # Update LASTCHANGE.
+    'name': 'lastchange',
+    'pattern': '.',
+    'action': ['python3', 'src/build/util/lastchange.py',
+               '-o', 'src/build/util/LASTCHANGE'],
+  },
+  # Pull clang-format binaries using checked-in hashes.
+  {
+    'name': 'clang_format_win',
+    'pattern': '.',
+    'action': [ 'download_from_google_storage',
+                '--no_resume',
+                '--platform=win32',
+                '--no_auth',
+                '--bucket', 'chromium-clang-format',
+                '-s', 'src/buildtools/win/clang-format.exe.sha1',
+    ],
+  },
+  {
+    'name': 'clang_format_mac',
+    'pattern': '.',
+    'action': [ 'download_from_google_storage',
+                '--no_resume',
+                '--platform=darwin',
+                '--no_auth',
+                '--bucket', 'chromium-clang-format',
+                '-s', 'src/buildtools/mac/clang-format.sha1',
+    ],
+  },
+  {
+    'name': 'clang_format_linux',
+    'pattern': '.',
+    'condition': 'host_os == "linux"',
+    'action': [ 'download_from_google_storage',
+                '--no_resume',
+                '--platform=linux*',
+                '--no_auth',
+                '--bucket', 'chromium-clang-format',
+                '-s', 'src/buildtools/linux64/clang-format.sha1',
+    ],
+  },
+  # Pull luci-go binaries (isolate, swarming) using checked-in hashes.
+  {
+    'name': 'luci-go_win',
+    'pattern': '.',
+    'action': [ 'download_from_google_storage',
+                '--no_resume',
+                '--platform=win32',
+                '--no_auth',
+                '--bucket', 'chromium-luci',
+                '-d', 'src/tools/luci-go/win64',
+    ],
+  },
+  {
+    'name': 'luci-go_mac',
+    'pattern': '.',
+    'action': [ 'download_from_google_storage',
+                '--no_resume',
+                '--platform=darwin',
+                '--no_auth',
+                '--bucket', 'chromium-luci',
+                '-d', 'src/tools/luci-go/mac64',
+    ],
+  },
+  {
+    'name': 'luci-go_linux',
+    'pattern': '.',
+    'action': [ 'download_from_google_storage',
+                '--no_resume',
+                '--platform=linux*',
+                '--no_auth',
+                '--bucket', 'chromium-luci',
+                '-d', 'src/tools/luci-go/linux64',
+    ],
+  },
+  {
+    # We used to use src as a CIPD root. We moved it to a different directory
+    # in crrev.com/c/930178 but left the clobber here to ensure that that CL
+    # could be reverted safely. This can be safely removed once crbug.com/794764
+    # is resolved.
+    'name': 'Android Clobber Deprecated CIPD Root',
+    'pattern': '.',
+    'condition': 'checkout_android',
+    'action': ['src/build/cipd/clobber_cipd_root.py',
+               '--root', 'src',
+    ],
+  },
+  {
+    'name': 'Generate component metadata for tests',
+    'pattern': '.',
+    'action': [
+      'vpython3',
+      'src/testing/generate_location_tags.py',
+      '--out',
+      'src/testing/location_tags.json',
+    ],
+  },
+]
+
+recursedeps = []
diff --git a/3rdparty/libyuv/src/DIR_METADATA b/3rdparty/libyuv/src/DIR_METADATA
new file mode 100644
index 00000000..8bc04f15
--- /dev/null
+++ b/3rdparty/libyuv/src/DIR_METADATA
@@ -0,0 +1,3 @@
+monorail {
+  component: "Internals>Images>Codecs"
+}
diff --git a/3rdparty/libyuv/src/LICENSE b/3rdparty/libyuv/src/LICENSE
new file mode 100644
index 00000000..c911747a
--- /dev/null
+++ b/3rdparty/libyuv/src/LICENSE
@@ -0,0 +1,29 @@
+Copyright 2011 The LibYuv Project Authors. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+  * Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+
+  * Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in
+    the documentation and/or other materials provided with the
+    distribution.
+
+  * Neither the name of Google nor the names of its contributors may
+    be used to endorse or promote products derived from this software
+    without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE 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.
diff --git a/3rdparty/libyuv/src/OWNERS b/3rdparty/libyuv/src/OWNERS
new file mode 100644
index 00000000..73d115dd
--- /dev/null
+++ b/3rdparty/libyuv/src/OWNERS
@@ -0,0 +1,10 @@
+mbonadei@chromium.org
+fbarchard@chromium.org
+magjed@chromium.org
+wtc@google.com
+
+per-file *.gn=mbonadei@chromium.org
+per-file .gitignore=*
+per-file AUTHORS=*
+per-file DEPS=*
+per-file PRESUBMIT.py=mbonadei@chromium.org
diff --git a/3rdparty/libyuv/src/PATENTS b/3rdparty/libyuv/src/PATENTS
new file mode 100644
index 00000000..64aa5c90
--- /dev/null
+++ b/3rdparty/libyuv/src/PATENTS
@@ -0,0 +1,24 @@
+Additional IP Rights Grant (Patents)
+
+"This implementation" means the copyrightable works distributed by
+Google as part of the LibYuv code package.
+
+Google hereby grants to you a perpetual, worldwide, non-exclusive,
+no-charge, irrevocable (except as stated in this section) patent
+license to make, have made, use, offer to sell, sell, import,
+transfer, and otherwise run, modify and propagate the contents of this
+implementation of the LibYuv code package, where such license applies
+only to those patent claims, both currently owned by Google and
+acquired in the future, licensable by Google that are necessarily
+infringed by this implementation of the LibYuv code package. This
+grant does not include claims that would be infringed only as a
+consequence of further modification of this implementation. If you or
+your agent or exclusive licensee institute or order or agree to the
+institution of patent litigation against any entity (including a
+cross-claim or counterclaim in a lawsuit) alleging that this
+implementation of the LibYuv code package or any code incorporated
+within this implementation of the LibYuv code package constitutes
+direct or contributory patent infringement, or inducement of patent
+infringement, then any patent rights granted to you under this License
+for this implementation of the LibYuv code package shall terminate as
+of the date such litigation is filed.
\ No newline at end of file
diff --git a/3rdparty/libyuv/src/PRESUBMIT.py b/3rdparty/libyuv/src/PRESUBMIT.py
new file mode 100644
index 00000000..d3901caf
--- /dev/null
+++ b/3rdparty/libyuv/src/PRESUBMIT.py
@@ -0,0 +1,52 @@
+# Copyright 2017 The LibYuv Project Authors. All rights reserved.
+#
+# Use of this source code is governed by a BSD-style license
+# that can be found in the LICENSE file in the root of the source
+# tree. An additional intellectual property rights grant can be found
+# in the file PATENTS. All contributing project authors may
+# be found in the AUTHORS file in the root of the source tree.
+
+# Runs PRESUBMIT.py in py3 mode by git cl presubmit.
+USE_PYTHON3 = True
+
+def _CommonChecks(input_api, output_api):
+  """Checks common to both upload and commit."""
+  results = []
+  results.extend(input_api.canned_checks.RunPylint(input_api, output_api,
+      files_to_skip=(r'^base[\\\/].*\.py$',
+                     r'^build[\\\/].*\.py$',
+                     r'^buildtools[\\\/].*\.py$',
+                     r'^ios[\\\/].*\.py$',
+                     r'^out.*[\\\/].*\.py$',
+                     r'^testing[\\\/].*\.py$',
+                     r'^third_party[\\\/].*\.py$',
+                     r'^tools[\\\/].*\.py$',
+                     # TODO(kjellander): should arguably be checked.
+                     r'^tools_libyuv[\\\/]valgrind[\\\/].*\.py$',
+                     r'^xcodebuild.*[\\\/].*\.py$',),
+      disabled_warnings=['F0401',  # Failed to import x
+                         'E0611',  # No package y in x
+                         'W0232',  # Class has no __init__ method
+                        ],
+      pylintrc='pylintrc',
+      version='2.7'))
+  return results
+
+
+def CheckChangeOnUpload(input_api, output_api):
+  results = []
+  results.extend(_CommonChecks(input_api, output_api))
+  results.extend(
+      input_api.canned_checks.CheckGNFormatted(input_api, output_api))
+  return results
+
+
+def CheckChangeOnCommit(input_api, output_api):
+  results = []
+  results.extend(_CommonChecks(input_api, output_api))
+  results.extend(input_api.canned_checks.CheckOwners(input_api, output_api))
+  results.extend(input_api.canned_checks.CheckChangeWasUploaded(
+      input_api, output_api))
+  results.extend(input_api.canned_checks.CheckChangeHasDescription(
+      input_api, output_api))
+  return results
diff --git a/3rdparty/libyuv/src/README.chromium b/3rdparty/libyuv/src/README.chromium
new file mode 100644
index 00000000..56dd4cba
--- /dev/null
+++ b/3rdparty/libyuv/src/README.chromium
@@ -0,0 +1,9 @@
+Name: libyuv
+URL: http://code.google.com/p/libyuv/
+Version: 1832
+License: BSD
+License File: LICENSE
+
+Description:
+libyuv is an open source project that includes YUV conversion and scaling functionality.
+
diff --git a/3rdparty/libyuv/src/README.md b/3rdparty/libyuv/src/README.md
new file mode 100644
index 00000000..db70b7f0
--- /dev/null
+++ b/3rdparty/libyuv/src/README.md
@@ -0,0 +1,18 @@
+**libyuv** is an open source project that includes YUV scaling and conversion functionality.
+
+* Scale YUV to prepare content for compression, with point, bilinear or box filter.
+* Convert to YUV from webcam formats for compression.
+* Convert to RGB formats for rendering/effects.
+* Rotate by 90/180/270 degrees to adjust for mobile devices in portrait mode.
+* Optimized for SSSE3/AVX2 on x86/x64.
+* Optimized for Neon on Arm.
+* Optimized for MSA on Mips.
+
+### Development
+
+See [Getting started][1] for instructions on how to get started developing.
+
+You can also browse the [docs directory][2] for more documentation.
+
+[1]: ./docs/getting_started.md
+[2]: ./docs/
diff --git a/3rdparty/libyuv/src/build_overrides/build.gni b/3rdparty/libyuv/src/build_overrides/build.gni
new file mode 100644
index 00000000..c8490313
--- /dev/null
+++ b/3rdparty/libyuv/src/build_overrides/build.gni
@@ -0,0 +1,60 @@
+# Copyright 2016 The LibYuv Project Authors. All rights reserved.
+#
+# Use of this source code is governed by a BSD-style license
+# that can be found in the LICENSE file in the root of the source
+# tree. An additional intellectual property rights grant can be found
+# in the file PATENTS. All contributing project authors may
+# be found in the AUTHORS file in the root of the source tree.
+
+# Variable that can be used to support multiple build scenarios, like having
+# Chromium specific targets in a client project's GN file etc.
+build_with_chromium = false
+
+# Some non-Chromium builds don't support building java targets.
+enable_java_templates = true
+
+# Allow using custom suppressions files (currently not used by libyuv).
+asan_suppressions_file = "//build/sanitizers/asan_suppressions.cc"
+lsan_suppressions_file = "//build/sanitizers/lsan_suppressions.cc"
+tsan_suppressions_file = "//build/sanitizers/tsan_suppressions.cc"
+
+msan_blacklist_path =
+    rebase_path("//tools_libyuv/msan/blacklist.txt", root_build_dir)
+ubsan_blacklist_path =
+    rebase_path("//tools_libyuv/ubsan/blacklist.txt", root_build_dir)
+ubsan_vptr_blacklist_path =
+    rebase_path("//tools_libyuv/ubsan/vptr_blacklist.txt", root_build_dir)
+
+# For Chromium, Android 32-bit non-component, non-clang builds hit a 4GiB size
+# limit, making them requiring symbol_level=2. WebRTC doesn't hit that problem
+# so we just ignore that assert. See https://crbug.com/648948 for more info.
+ignore_elf32_limitations = true
+
+# Use bundled hermetic Xcode installation maintained by Chromium,
+# except for local iOS builds where it is unsupported.
+if (host_os == "mac") {
+  _result = exec_script("//build/mac/should_use_hermetic_xcode.py",
+                        [ target_os ],
+                        "value")
+  assert(_result != 2,
+         "Do not allow building targets with the default" +
+             "hermetic toolchain if the minimum OS version is not met.")
+  use_system_xcode = _result == 0
+}
+
+declare_args() {
+  # Tracing support requires //third_party/perfetto.
+  enable_base_tracing = false
+  use_perfetto_client_library = false
+
+  # Limits the defined //third_party/android_deps targets to only "buildCompile"
+  # and "buildCompileNoDeps" targets. This is useful for third-party
+  # repositories which do not use JUnit tests. For instance,
+  # limit_android_deps == true removes "gn gen" requirement for
+  # //third_party/robolectric .
+  limit_android_deps = false
+
+  # Allows googletest to pretty-print various absl types.
+  # Defined here rather than in gtest.gni to match chromium.
+  gtest_enable_absl_printers = true
+}
diff --git a/3rdparty/libyuv/src/build_overrides/gtest.gni b/3rdparty/libyuv/src/build_overrides/gtest.gni
new file mode 100644
index 00000000..d3c3f68c
--- /dev/null
+++ b/3rdparty/libyuv/src/build_overrides/gtest.gni
@@ -0,0 +1,19 @@
+# Copyright (c) 2016 The LibYuv project authors. All Rights Reserved.
+#
+# Use of this source code is governed by a BSD-style license
+# that can be found in the LICENSE file in the root of the source
+# tree. An additional intellectual property rights grant can be found
+# in the file PATENTS.  All contributing project authors may
+# be found in the AUTHORS file in the root of the source tree.
+
+# Include support for registering main function in multi-process tests.
+gtest_include_multiprocess = true
+
+# Include support for platform-specific operations across unit tests.
+gtest_include_platform_test = true
+
+# Exclude support for testing Objective C code on OS X and iOS.
+gtest_include_objc_support = true
+
+# Exclude support for flushing coverage files on iOS.
+gtest_include_ios_coverage = true
diff --git a/3rdparty/libyuv/src/cleanup_links.py b/3rdparty/libyuv/src/cleanup_links.py
new file mode 100644
index 00000000..7d1eba9b
--- /dev/null
+++ b/3rdparty/libyuv/src/cleanup_links.py
@@ -0,0 +1,108 @@
+#!/usr/bin/env vpython3
+
+# Copyright 2017 The LibYuv Project Authors. All rights reserved.
+#
+# Use of this source code is governed by a BSD-style license
+# that can be found in the LICENSE file in the root of the source
+# tree. An additional intellectual property rights grant can be found
+# in the file PATENTS. All contributing project authors may
+# be found in the AUTHORS file in the root of the source tree.
+
+# This is a copy of the file from WebRTC in:
+# https://chromium.googlesource.com/external/webrtc/+/master/cleanup_links.py
+
+"""Script to cleanup symlinks created from setup_links.py.
+
+Before 177567c518b121731e507e9b9c4049c4dc96e4c8 (#15754) we had a Chromium
+checkout which we created symlinks into. In order to do clean syncs after
+landing that change, this script cleans up any old symlinks, avoiding annoying
+manual cleanup needed in order to complete gclient sync.
+"""
+
+import argparse
+import logging
+import os
+import shelve
+import subprocess
+import sys
+
+
+ROOT_DIR = os.path.dirname(os.path.abspath(__file__))
+LINKS_DB = 'links'
+
+# Version management to make future upgrades/downgrades easier to support.
+SCHEMA_VERSION = 1
+
+class WebRTCLinkSetup():
+  def __init__(self, links_db, dry_run=False):
+    self._dry_run = dry_run
+    self._links_db = links_db
+
+  def CleanupLinks(self):
+    logging.debug('CleanupLinks')
+    for source, link_path  in self._links_db.tems():
+      if source == 'SCHEMA_VERSION':
+        continue
+      if os.path.islink(link_path) or sys.platform.startswith('win'):
+        # os.path.islink() always returns false on Windows
+        # See http://bugs.python.org/issue13143.
+        logging.debug('Removing link to %s at %s', source, link_path)
+        if not self._dry_run:
+          if os.path.exists(link_path):
+            if sys.platform.startswith('win') and os.path.isdir(link_path):
+              subprocess.check_call(['rmdir', '/q', '/s', link_path],
+                                    shell=True)
+            else:
+              os.remove(link_path)
+          del self._links_db[source]
+
+
+def _initialize_database(filename):
+  links_database = shelve.open(filename)
+  # Wipe the database if this version of the script ends up looking at a
+  # newer (future) version of the links db, just to be sure.
+  version = links_database.get('SCHEMA_VERSION')
+  if version and version != SCHEMA_VERSION:
+    logging.info('Found database with schema version %s while this script only '
+                 'supports %s. Wiping previous database contents.', version,
+                 SCHEMA_VERSION)
+    links_database.clear()
+  links_database['SCHEMA_VERSION'] = SCHEMA_VERSION
+  return links_database
+
+
+def main():
+  p = argparse.ArgumentParser()
+  p.add_argument('-d', '--dry-run', action='store_true', default=False,
+                 help='Print what would be done, but don\'t perform any '
+                      'operations. This will automatically set logging to '
+                      'verbose.')
+  p.add_argument('-v', '--verbose', action='store_const',
+                 const=logging.DEBUG, default=logging.INFO,
+                 help='Print verbose output for debugging.')
+  options = p.parse_args()
+
+  if options.dry_run:
+    options.verbose = logging.DEBUG
+  logging.basicConfig(format='%(message)s', level=options.verbose)
+
+  # Work from the root directory of the checkout.
+  script_dir = os.path.dirname(os.path.abspath(__file__))
+  os.chdir(script_dir)
+
+  # The database file gets .db appended on some platforms.
+  db_filenames = [LINKS_DB, LINKS_DB + '.db']
+  if any(os.path.isfile(f) for f in db_filenames):
+    links_database = _initialize_database(LINKS_DB)
+    try:
+      symlink_creator = WebRTCLinkSetup(links_database, options.dry_run)
+      symlink_creator.CleanupLinks()
+    finally:
+      for f in db_filenames:
+        if os.path.isfile(f):
+          os.remove(f)
+  return 0
+
+
+if __name__ == '__main__':
+  sys.exit(main())
diff --git a/3rdparty/libyuv/src/codereview.settings b/3rdparty/libyuv/src/codereview.settings
new file mode 100644
index 00000000..b226fae5
--- /dev/null
+++ b/3rdparty/libyuv/src/codereview.settings
@@ -0,0 +1,5 @@
+# This file is used by `git cl` to get repository specific information.
+CODE_REVIEW_SERVER: codereview.chromium.org
+GERRIT_HOST: True
+PROJECT: libyuv
+VIEW_VC: https://chromium.googlesource.com/libyuv/libyuv/+/
diff --git a/3rdparty/libyuv/src/docs/deprecated_builds.md b/3rdparty/libyuv/src/docs/deprecated_builds.md
new file mode 100644
index 00000000..ba42966c
--- /dev/null
+++ b/3rdparty/libyuv/src/docs/deprecated_builds.md
@@ -0,0 +1,441 @@
+# Deprecated Builds
+
+Older documentation on build configs which are no longer supported.
+
+## Pre-requisites
+
+You'll need to have depot tools installed: https://www.chromium.org/developers/how-tos/install-depot-tools
+Refer to chromium instructions for each platform for other prerequisites.
+
+## Getting the Code
+
+Create a working directory, enter it, and run:
+
+    gclient config https://chromium.googlesource.com/libyuv/libyuv
+    gclient sync
+
+
+Then you'll get a .gclient file like:
+
+    solutions = [
+      { "name"        : "libyuv",
+        "url"         : "https://chromium.googlesource.com/libyuv/libyuv",
+        "deps_file"   : "DEPS",
+        "managed"     : True,
+        "custom_deps" : {
+        },
+        "safesync_url": "",
+      },
+    ];
+
+
+For iOS add `;target_os=['ios'];` to your OSX .gclient and run `GYP_DEFINES="OS=ios" gclient sync.`
+
+Browse the Git reprository: https://chromium.googlesource.com/libyuv/libyuv/+/master
+
+### Android
+For Android add `;target_os=['android'];` to your Linux .gclient
+
+
+    solutions = [
+      { "name"        : "libyuv",
+        "url"         : "https://chromium.googlesource.com/libyuv/libyuv",
+        "deps_file"   : "DEPS",
+        "managed"     : True,
+        "custom_deps" : {
+        },
+        "safesync_url": "",
+      },
+    ];
+    target_os = ["android", "unix"];
+
+Then run:
+
+    export GYP_DEFINES="OS=android"
+    gclient sync
+
+Caveat: Theres an error with Google Play services updates.  If you get the error "Your version of the Google Play services library is not up to date", run the following:
+
+    cd chromium/src
+    ./build/android/play_services/update.py download
+    cd ../..
+
+For Windows the gclient sync must be done from an Administrator command prompt.
+
+The sync will generate native build files for your environment using gyp (Windows: Visual Studio, OSX: XCode, Linux: make). This generation can also be forced manually: `gclient runhooks`
+
+To get just the source (not buildable):
+
+    git clone https://chromium.googlesource.com/libyuv/libyuv
+
+
+## Building the Library and Unittests
+
+### Windows
+
+    set GYP_DEFINES=target_arch=ia32
+    call python gyp_libyuv -fninja -G msvs_version=2013
+    ninja -j7 -C out\Release
+    ninja -j7 -C out\Debug
+
+    set GYP_DEFINES=target_arch=x64
+    call python gyp_libyuv -fninja -G msvs_version=2013
+    ninja -C out\Debug_x64
+    ninja -C out\Release_x64
+
+#### Building with clangcl
+    set GYP_DEFINES=clang=1 target_arch=ia32
+    call python tools\clang\scripts\update.py
+    call python gyp_libyuv -fninja libyuv_test.gyp
+    ninja -C out\Debug
+    ninja -C out\Release
+
+### OSX
+
+Clang 64 bit shown. Remove `clang=1` for GCC and change x64 to ia32 for 32 bit.
+
+    GYP_DEFINES="clang=1 target_arch=x64" ./gyp_libyuv
+    ninja -j7 -C out/Debug
+    ninja -j7 -C out/Release
+
+    GYP_DEFINES="clang=1 target_arch=ia32" ./gyp_libyuv
+    ninja -j7 -C out/Debug
+    ninja -j7 -C out/Release
+
+### iOS
+http://www.chromium.org/developers/how-tos/build-instructions-ios
+
+Add to .gclient last line: `target_os=['ios'];`
+
+armv7
+
+    GYP_DEFINES="OS=ios target_arch=armv7 target_subarch=arm32" GYP_CROSSCOMPILE=1 GYP_GENERATOR_FLAGS="output_dir=out_ios" ./gyp_libyuv
+    ninja -j7 -C out_ios/Debug-iphoneos libyuv_unittest
+    ninja -j7 -C out_ios/Release-iphoneos libyuv_unittest
+
+arm64
+
+    GYP_DEFINES="OS=ios target_arch=arm64 target_subarch=arm64" GYP_CROSSCOMPILE=1 GYP_GENERATOR_FLAGS="output_dir=out_ios" ./gyp_libyuv
+    ninja -j7 -C out_ios/Debug-iphoneos libyuv_unittest
+    ninja -j7 -C out_ios/Release-iphoneos libyuv_unittest
+
+both armv7 and arm64 (fat)
+
+    GYP_DEFINES="OS=ios target_arch=armv7 target_subarch=both" GYP_CROSSCOMPILE=1 GYP_GENERATOR_FLAGS="output_dir=out_ios" ./gyp_libyuv
+    ninja -j7 -C out_ios/Debug-iphoneos libyuv_unittest
+    ninja -j7 -C out_ios/Release-iphoneos libyuv_unittest
+
+simulator
+
+    GYP_DEFINES="OS=ios target_arch=ia32 target_subarch=arm32" GYP_CROSSCOMPILE=1 GYP_GENERATOR_FLAGS="output_dir=out_sim" ./gyp_libyuv
+    ninja -j7 -C out_sim/Debug-iphonesimulator libyuv_unittest
+    ninja -j7 -C out_sim/Release-iphonesimulator libyuv_unittest
+
+### Android
+https://code.google.com/p/chromium/wiki/AndroidBuildInstructions
+
+Add to .gclient last line: `target_os=['android'];`
+
+armv7
+
+    GYP_DEFINES="OS=android" GYP_CROSSCOMPILE=1 ./gyp_libyuv
+    ninja -j7 -C out/Debug yuv_unittest_apk
+    ninja -j7 -C out/Release yuv_unittest_apk
+
+arm64
+
+    GYP_DEFINES="OS=android target_arch=arm64 target_subarch=arm64" GYP_CROSSCOMPILE=1 ./gyp_libyuv
+    ninja -j7 -C out/Debug yuv_unittest_apk
+    ninja -j7 -C out/Release yuv_unittest_apk
+
+ia32
+
+    GYP_DEFINES="OS=android target_arch=ia32" GYP_CROSSCOMPILE=1 ./gyp_libyuv
+    ninja -j7 -C out/Debug yuv_unittest_apk
+    ninja -j7 -C out/Release yuv_unittest_apk
+
+    GYP_DEFINES="OS=android target_arch=ia32 android_full_debug=1" GYP_CROSSCOMPILE=1 ./gyp_libyuv
+    ninja -j7 -C out/Debug yuv_unittest_apk
+
+mipsel
+
+    GYP_DEFINES="OS=android target_arch=mipsel" GYP_CROSSCOMPILE=1 ./gyp_libyuv
+    ninja -j7 -C out/Debug yuv_unittest_apk
+    ninja -j7 -C out/Release yuv_unittest_apk
+
+arm32 disassembly:
+
+    third_party/android_ndk/toolchains/arm-linux-androideabi-4.9/prebuilt/linux-x86_64/bin/arm-linux-androideabi-objdump -d out/Release/obj/source/libyuv.row_neon.o
+
+arm64 disassembly:
+
+    third_party/android_ndk/toolchains/aarch64-linux-android-4.9/prebuilt/linux-x86_64/bin/aarch64-linux-android-objdump -d out/Release/obj/source/libyuv.row_neon64.o
+
+Running tests:
+
+    build/android/test_runner.py gtest -s libyuv_unittest -t 7200 --verbose --release --gtest_filter=*
+
+Running test as benchmark:
+
+    build/android/test_runner.py gtest -s libyuv_unittest -t 7200 --verbose --release --gtest_filter=* -a "--libyuv_width=1280 --libyuv_height=720 --libyuv_repeat=999 --libyuv_flags=-1"
+
+Running test with C code:
+
+    build/android/test_runner.py gtest -s libyuv_unittest -t 7200 --verbose --release --gtest_filter=* -a "--libyuv_width=1280 --libyuv_height=720 --libyuv_repeat=999 --libyuv_flags=1 --libyuv_cpu_info=1"
+
+#### Building with GN
+
+    gn gen out/Release "--args=is_debug=false target_cpu=\"x86\""
+    gn gen out/Debug "--args=is_debug=true target_cpu=\"x86\""
+    ninja -C out/Release
+    ninja -C out/Debug
+
+### Building Offical with GN
+
+    gn gen out/Official "--args=is_debug=false is_official_build=true is_chrome_branded=true"
+    ninja -C out/Official
+
+#### Building mips with GN
+
+mipsel
+    gn gen out/Default "--args=is_debug=false target_cpu=\"mipsel\" target_os = \"android\" mips_arch_variant = \"r6\" mips_use_msa = true is_component_build = true is_clang = false"
+    ninja -C out/Default
+
+mips64el
+    gn gen out/Default "--args=is_debug=false target_cpu=\"mips64el\" target_os = \"android\" mips_arch_variant = \"r6\" mips_use_msa = true is_component_build = true is_clang = false"
+    ninja -C out/Default
+
+### Linux
+
+    GYP_DEFINES="target_arch=x64" ./gyp_libyuv
+    ninja -j7 -C out/Debug
+    ninja -j7 -C out/Release
+
+    GYP_DEFINES="target_arch=ia32" ./gyp_libyuv
+    ninja -j7 -C out/Debug
+    ninja -j7 -C out/Release
+
+#### CentOS
+
+On CentOS 32 bit the following work around allows a sync:
+
+    export GYP_DEFINES="host_arch=ia32"
+    gclient sync
+
+### Windows Shared Library
+
+Modify libyuv.gyp from 'static_library' to 'shared_library', and add 'LIBYUV_BUILDING_SHARED_LIBRARY' to 'defines'.
+
+    gclient runhooks
+
+After this command follow the building the library instructions above.
+
+If you get a compile error for atlthunk.lib on Windows, read http://www.chromium.org/developers/how-tos/build-instructions-windows
+
+
+### Build targets
+
+    ninja -C out/Debug libyuv
+    ninja -C out/Debug libyuv_unittest
+    ninja -C out/Debug compare
+    ninja -C out/Debug yuvconvert
+    ninja -C out/Debug yuvconstants
+    ninja -C out/Debug psnr
+    ninja -C out/Debug cpuid
+
+
+## Building the Library with make
+
+### Linux
+
+    make -j7 V=1 -f linux.mk
+    make -j7 V=1 -f linux.mk clean
+    make -j7 V=1 -f linux.mk CXX=clang++
+
+## Building the Library with cmake
+
+Install cmake: http://www.cmake.org/
+
+Default debug build:
+
+    mkdir out
+    cd out
+    cmake ..
+    cmake --build .
+
+Release build/install
+
+    mkdir out
+    cd out
+    cmake -DCMAKE_INSTALL_PREFIX="/usr/lib" -DCMAKE_BUILD_TYPE="Release" ..
+    cmake --build . --config Release
+    sudo cmake --build . --target install --config Release
+
+### Windows 8 Phone
+
+Pre-requisite:
+
+* Install Visual Studio 2012 and Arm to your environment.<br>
+
+Then:
+
+    call "c:\Program Files (x86)\Microsoft Visual Studio 11.0\VC\bin\x86_arm\vcvarsx86_arm.bat"
+
+or with Visual Studio 2013:
+
+    call "c:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\bin\x86_arm\vcvarsx86_arm.bat"
+    nmake /f winarm.mk clean
+    nmake /f winarm.mk
+
+### Windows Shared Library
+
+Modify libyuv.gyp from 'static_library' to 'shared_library', and add 'LIBYUV_BUILDING_SHARED_LIBRARY' to 'defines'. Then run this.
+
+    gclient runhooks
+
+After this command follow the building the library instructions above.
+
+If you get a compile error for atlthunk.lib on Windows, read http://www.chromium.org/developers/how-tos/build-instructions-windows
+
+### 64 bit Windows
+
+    set GYP_DEFINES=target_arch=x64
+    gclient runhooks V=1
+
+### ARM Linux
+
+    export GYP_DEFINES="target_arch=arm"
+    export CROSSTOOL=`<path>`/arm-none-linux-gnueabi
+    export CXX=$CROSSTOOL-g++
+    export CC=$CROSSTOOL-gcc
+    export AR=$CROSSTOOL-ar
+    export AS=$CROSSTOOL-as
+    export RANLIB=$CROSSTOOL-ranlib
+    gclient runhooks
+
+## Running Unittests
+
+### Windows
+
+    out\Release\libyuv_unittest.exe --gtest_catch_exceptions=0 --gtest_filter="*"
+
+### OSX
+
+    out/Release/libyuv_unittest --gtest_filter="*"
+
+### Linux
+
+    out/Release/libyuv_unittest --gtest_filter="*"
+
+Replace --gtest_filter="*" with specific unittest to run.  May include wildcards. e.g.
+
+    out/Release/libyuv_unittest --gtest_filter=libyuvTest.I420ToARGB_Opt
+
+## CPU Emulator tools
+
+### Intel SDE (Software Development Emulator)
+
+Pre-requisite: Install IntelSDE for Windows: http://software.intel.com/en-us/articles/intel-software-development-emulator
+
+Then run:
+
+    c:\intelsde\sde -hsw -- out\release\libyuv_unittest.exe --gtest_filter=*
+
+
+## Memory tools
+
+### Running Dr Memory memcheck for Windows
+
+Pre-requisite: Install Dr Memory for Windows and add it to your path: http://www.drmemory.org/docs/page_install_windows.html
+
+    set GYP_DEFINES=build_for_tool=drmemory target_arch=ia32
+    call python gyp_libyuv -fninja -G msvs_version=2013
+    ninja -C out\Debug
+    drmemory out\Debug\libyuv_unittest.exe --gtest_catch_exceptions=0 --gtest_filter=*
+
+### Running UBSan
+
+See Chromium instructions for sanitizers: https://www.chromium.org/developers/testing/undefinedbehaviorsanitizer
+
+Sanitizers available: TSan, MSan, ASan, UBSan, LSan
+
+    GYP_DEFINES='ubsan=1' gclient runhooks
+    ninja -C out/Release
+
+### Running Valgrind memcheck
+
+Memory errors and race conditions can be found by running tests under special memory tools. [Valgrind] [1] is an instrumentation framework for building dynamic analysis tools. Various tests and profilers are built upon it to find memory handling errors and memory leaks, for instance.
+
+[1]: http://valgrind.org
+
+    solutions = [
+      { "name"        : "libyuv",
+        "url"         : "https://chromium.googlesource.com/libyuv/libyuv",
+        "deps_file"   : "DEPS",
+        "managed"     : True,
+        "custom_deps" : {
+           "libyuv/chromium/src/third_party/valgrind": "https://chromium.googlesource.com/chromium/deps/valgrind/binaries",
+        },
+        "safesync_url": "",
+      },
+    ]
+
+Then run:
+
+    GYP_DEFINES="clang=0 target_arch=x64 build_for_tool=memcheck" python gyp_libyuv
+    ninja -C out/Debug
+    valgrind out/Debug/libyuv_unittest
+
+
+For more information, see http://www.chromium.org/developers/how-tos/using-valgrind
+
+### Running Thread Sanitizer (TSan)
+
+    GYP_DEFINES="clang=0 target_arch=x64 build_for_tool=tsan" python gyp_libyuv
+    ninja -C out/Debug
+    valgrind out/Debug/libyuv_unittest
+
+For more info, see http://www.chromium.org/developers/how-tos/using-valgrind/threadsanitizer
+
+### Running Address Sanitizer (ASan)
+
+    GYP_DEFINES="clang=0 target_arch=x64 build_for_tool=asan" python gyp_libyuv
+    ninja -C out/Debug
+    valgrind out/Debug/libyuv_unittest
+
+For more info, see http://dev.chromium.org/developers/testing/addresssanitizer
+
+## Benchmarking
+
+The unittests can be used to benchmark.
+
+### Windows
+
+    set LIBYUV_WIDTH=1280
+    set LIBYUV_HEIGHT=720
+    set LIBYUV_REPEAT=999
+    set LIBYUV_FLAGS=-1
+    out\Release\libyuv_unittest.exe --gtest_filter=*I420ToARGB_Opt
+
+
+### Linux and Mac
+
+    LIBYUV_WIDTH=1280 LIBYUV_HEIGHT=720 LIBYUV_REPEAT=1000 out/Release/libyuv_unittest --gtest_filter=*I420ToARGB_Opt
+
+    libyuvTest.I420ToARGB_Opt (547 ms)
+
+Indicates 0.547 ms/frame for 1280 x 720.
+
+## Making a change
+
+    gclient sync
+    git checkout -b mycl -t origin/master
+    git pull
+    <edit files>
+    git add -u
+    git commit -m "my change"
+    git cl lint
+    git cl try
+    git cl upload -r a-reviewer@chomium.org -s
+    <once approved..>
+    git cl land
diff --git a/3rdparty/libyuv/src/docs/environment_variables.md b/3rdparty/libyuv/src/docs/environment_variables.md
new file mode 100644
index 00000000..dd5d59fb
--- /dev/null
+++ b/3rdparty/libyuv/src/docs/environment_variables.md
@@ -0,0 +1,52 @@
+# Introduction
+
+For test purposes, environment variables can be set to control libyuv behavior.  These should only be used for testing, to narrow down bugs or to test performance.
+
+# CPU
+
+By default the cpu is detected and the most advanced form of SIMD is used.  But you can disable instruction sets selectively, or completely, falling back on C code.  Set the variable to 1 to disable the specified instruction set.
+
+## All CPUs
+    LIBYUV_DISABLE_ASM
+
+## Intel CPUs
+    LIBYUV_DISABLE_X86
+    LIBYUV_DISABLE_SSE2
+    LIBYUV_DISABLE_SSSE3
+    LIBYUV_DISABLE_SSE41
+    LIBYUV_DISABLE_SSE42
+    LIBYUV_DISABLE_AVX
+    LIBYUV_DISABLE_AVX2
+    LIBYUV_DISABLE_ERMS
+    LIBYUV_DISABLE_FMA3
+    LIBYUV_DISABLE_F16C
+    LIBYUV_DISABLE_AVX512BW
+    LIBYUV_DISABLE_AVX512VL
+    LIBYUV_DISABLE_AVX512VNNI
+    LIBYUV_DISABLE_AVX512VBMI
+    LIBYUV_DISABLE_AVX512VBMI2
+    LIBYUV_DISABLE_AVX512VBITALG
+    LIBYUV_DISABLE_AVX512VPOPCNTDQ
+    LIBYUV_DISABLE_GFNI
+
+## ARM CPUs
+
+    LIBYUV_DISABLE_NEON
+
+## MIPS CPUs
+    LIBYUV_DISABLE_MSA
+
+## LOONGARCH CPUs
+    LIBYUV_DISABLE_LSX
+    LIBYUV_DISABLE_LASX
+
+# Test Width/Height/Repeat
+
+The unittests default to a small image (128x72) to run fast.  This can be set by environment variable to test a specific resolutions.
+You can also repeat the test a specified number of iterations, allowing benchmarking and profiling.
+
+    set LIBYUV_WIDTH=1280
+    set LIBYUV_HEIGHT=720
+    set LIBYUV_REPEAT=999
+    set LIBYUV_FLAGS=-1
+    set LIBYUV_CPU_INFO=-1
diff --git a/3rdparty/libyuv/src/docs/filtering.md b/3rdparty/libyuv/src/docs/filtering.md
new file mode 100644
index 00000000..8696976e
--- /dev/null
+++ b/3rdparty/libyuv/src/docs/filtering.md
@@ -0,0 +1,196 @@
+# Introduction
+
+This document discusses the current state of filtering in libyuv. An emphasis on maximum performance while avoiding memory exceptions, and minimal amount of code/complexity.  See future work at end.
+
+# LibYuv Filter Subsampling
+
+There are 2 challenges with subsampling
+
+1. centering of samples, which involves clamping on edges
+2. clipping a source region
+
+Centering depends on scale factor and filter mode.
+
+# Down Sampling
+
+If scaling down, the stepping rate is always src_width / dst_width.
+
+    dx = src_width / dst_width;
+
+e.g. If scaling from 1280x720 to 640x360, the step thru the source will be 2.0, stepping over 2 pixels of source for each pixel of destination.
+
+Centering, depends on filter mode.
+
+*Point* downsampling takes the middle pixel.
+
+    x = dx >> 1;
+
+For odd scale factors (e.g. 3x down) this is exactly the middle.  For even scale factors, this rounds up and takes the pixel to the right of center.  e.g. scale of 4x down will take pixel 2.
+
+**Bilinear** filter, uses the 2x2 pixels in the middle.
+
+    x = dx / 2 - 0.5;
+
+For odd scale factors (e.g. 3x down) this is exactly the middle, and point sampling is used.
+For even scale factors, this evenly filters the middle 2x2 pixels.  e.g. 4x down will filter pixels 1,2 at 50% in both directions.
+
+**Box** filter averages the entire box so sampling starts at 0.
+
+    x = 0;
+
+For a scale factor of 2x down, this is equivalent to bilinear.
+
+# Up Sampling
+
+**Point** upsampling use stepping rate of src_width / dst_width and a starting coordinate of 0.
+
+    x = 0;
+    dx = src_width / dst_width;
+
+e.g. If scaling from 640x360 to 1280x720 the step thru the source will be 0.0, stepping half a pixel of source for each pixel of destination. Each pixel is replicated by the scale factor.
+
+**Bilinear** filter stretches such that the first pixel of source maps to the first pixel of destination, and the last pixel of source maps to the last pixel of destination.
+
+    x = 0;
+    dx = (src_width - 1) / (dst_width - 1);
+
+This method is not technically correct, and will likely change in the future.
+
+* It is inconsistent with the bilinear down sampler.  The same method could be used for down sampling, and then it would be more reversible, but that would prevent specialized 2x down sampling.
+* Although centered, the image is slightly magnified.
+* The filtering was changed in early 2013 - previously it used:
+
+        x = 0;
+        dx = (src_width - 1) / (dst_width - 1);
+
+Which is the correct scale factor, but shifted the image left, and extruded the last pixel.  The reason for the change was to remove the extruding code from the low level row functions, allowing 3 functions to sshare the same row functions - ARGBScale, I420Scale, and ARGBInterpolate.  Then the one function was ported to many cpu variations: SSE2, SSSE3, AVX2, Neon and 'Any' version for any number of pixels and alignment.  The function is also specialized for 0,25,50,75%.
+
+The above goes still has the potential to read the last pixel 100% and last pixel + 1 0%, which may cause a memory exception.  So the left pixel goes to a fraction less than the last pixel, but filters in the minimum amount of it, and the maximum of the last pixel.
+
+    dx = FixedDiv((src_width << 16) - 0x00010001, (dst << 16) - 0x00010000);
+
+**Box** filter for upsampling switches over to Bilinear.
+
+# Scale snippet:
+
+    #define CENTERSTART(dx, s) (dx < 0) ? -((-dx >> 1) + s) : ((dx >> 1) + s)
+    #define FIXEDDIV1(src, dst) FixedDiv((src << 16) - 0x00010001, \
+                                         (dst << 16) - 0x00010000);
+
+    // Compute slope values for stepping.
+    void ScaleSlope(int src_width, int src_height,
+                    int dst_width, int dst_height,
+                    FilterMode filtering,
+                    int* x, int* y, int* dx, int* dy) {
+      assert(x != NULL);
+      assert(y != NULL);
+      assert(dx != NULL);
+      assert(dy != NULL);
+      assert(src_width != 0);
+      assert(src_height != 0);
+      assert(dst_width > 0);
+      assert(dst_height > 0);
+      if (filtering == kFilterBox) {
+        // Scale step for point sampling duplicates all pixels equally.
+        *dx = FixedDiv(Abs(src_width), dst_width);
+        *dy = FixedDiv(src_height, dst_height);
+        *x = 0;
+        *y = 0;
+      } else if (filtering == kFilterBilinear) {
+        // Scale step for bilinear sampling renders last pixel once for upsample.
+        if (dst_width <= Abs(src_width)) {
+          *dx = FixedDiv(Abs(src_width), dst_width);
+          *x = CENTERSTART(*dx, -32768);
+        } else if (dst_width > 1) {
+          *dx = FIXEDDIV1(Abs(src_width), dst_width);
+          *x = 0;
+        }
+        if (dst_height <= src_height) {
+          *dy = FixedDiv(src_height,  dst_height);
+          *y = CENTERSTART(*dy, -32768);  // 32768 = -0.5 to center bilinear.
+        } else if (dst_height > 1) {
+          *dy = FIXEDDIV1(src_height, dst_height);
+          *y = 0;
+        }
+      } else if (filtering == kFilterLinear) {
+        // Scale step for bilinear sampling renders last pixel once for upsample.
+        if (dst_width <= Abs(src_width)) {
+          *dx = FixedDiv(Abs(src_width), dst_width);
+          *x = CENTERSTART(*dx, -32768);
+        } else if (dst_width > 1) {
+          *dx = FIXEDDIV1(Abs(src_width), dst_width);
+          *x = 0;
+        }
+        *dy = FixedDiv(src_height, dst_height);
+        *y = *dy >> 1;
+      } else {
+        // Scale step for point sampling duplicates all pixels equally.
+        *dx = FixedDiv(Abs(src_width), dst_width);
+        *dy = FixedDiv(src_height, dst_height);
+        *x = CENTERSTART(*dx, 0);
+        *y = CENTERSTART(*dy, 0);
+      }
+      // Negative src_width means horizontally mirror.
+      if (src_width < 0) {
+        *x += (dst_width - 1) * *dx;
+        *dx = -*dx;
+        src_width = -src_width;
+      }
+    }
+
+# Future Work
+
+Point sampling should ideally be the same as bilinear, but pixel by pixel, round to nearest neighbor.  But as is, it is reversible and exactly matches ffmpeg at all scale factors, both up and down.  The scale factor is
+
+    dx = src_width / dst_width;
+
+The step value is centered for down sample:
+
+    x = dx / 2;
+
+Or starts at 0 for upsample.
+
+    x = 0;
+
+Bilinear filtering is currently correct for down sampling, but not for upsampling.
+Upsampling is stretching the first and last pixel of source, to the first and last pixel of destination.
+
+    dx = (src_width - 1) / (dst_width - 1);<br>
+    x = 0;
+
+It should be stretching such that the first pixel is centered in the middle of the scale factor, to match the pixel that would be sampled for down sampling by the same amount.  And same on last pixel.
+
+    dx = src_width / dst_width;<br>
+    x = dx / 2 - 0.5;
+
+This would start at -0.5 and go to last pixel + 0.5, sampling 50% from last pixel + 1.
+Then clamping would be needed.  On GPUs there are numerous ways to clamp.
+
+1. Clamp the coordinate to the edge of the texture, duplicating the first and last pixel.
+2. Blend with a constant color, such as transparent black.  Typically best for fonts.
+3. Mirror the UV coordinate, which is similar to clamping.  Good for continuous tone images.
+4. Wrap the coordinate, for texture tiling.
+5. Allow the coordinate to index beyond the image, which may be the correct data if sampling a subimage.
+6. Extrapolate the edge based on the previous pixel.  pixel -0.5 is computed from slope of pixel 0 and 1.
+
+Some of these are computational, even for a GPU, which is one reason textures are sometimes limited to power of 2 sizes.
+We do care about the clipping case, where allowing coordinates to become negative and index pixels before the image is the correct data.  But normally for simple scaling, we want to clamp to the edge pixel.  For example, if bilinear scaling from 3x3 to 30x30, we’d essentially want 10 pixels of each of the original 3 pixels.  But we want the original pixels to land in the middle of each 10 pixels, at offsets 5, 15 and 25.  There would be filtering between 5 and 15 between the original pixels 0 and 1.  And filtering between 15 and 25 from original pixels 1 and 2.  The first 5 pixels are clamped to pixel 0 and the last 5 pixels are clamped to pixel 2.
+The easiest way to implement this is copy the original 3 pixels to a buffer, and duplicate the first and last pixels.  0,1,2 becomes 0, 0,1,2, 2.  Then implement a filtering without clamping.  We call this source extruding.  Its only necessary on up sampling, since down sampler will always have valid surrounding pixels.
+Extruding is practical when the image is already copied to a temporary buffer.   It could be done to the original image, as long as the original memory is restored, but valgrind and/or memory protection would disallow this, so it requires a memcpy to a temporary buffer, which may hurt performance.  The memcpy has a performance advantage, from a cache point of view, that can actually make this technique faster, depending on hardware characteristics.
+Vertical extrusion can be done with a memcpy of the first/last row, or clamping a pointer.
+
+
+The other way to implement clamping is handle the edges with a memset.  e.g. Read first source pixel and memset the first 5 pixels.  Filter pixels 0,1,2 to 5 to 25.  Read last pixel and memset the last 5 pixels.  Blur is implemented with this method like this, which has 3 loops per row - left, middle and right.
+
+Box filter is only used for 2x down sample or more.  Its based on integer sized boxes.  Technically it should be filtered edges, but thats substantially slower (roughly 100x), and at that point you may as well do a cubic filter which is more correct.
+
+Box filter currently sums rows into a row buffer.  It does this with
+
+Mirroring will use the same slope as normal, but with a negative.
+The starting coordinate needs to consider the scale factor and filter.  e.g. box filter of 30x30 to 3x3 with mirroring would use -10 for step, but x = 20.  width (30) - dx.
+
+Step needs to be accurate, so it uses an integer divide.  This is as much as 5% of the profile.  An approximated divide is substantially faster, but the inaccuracy causes stepping beyond the original image boundaries.  3 general solutions:
+
+1. copy image to buffer with padding.  allows for small errors in stepping.
+2. hash the divide, so common values are quickly found.
+3. change api so caller provides the slope.
diff --git a/3rdparty/libyuv/src/docs/formats.md b/3rdparty/libyuv/src/docs/formats.md
new file mode 100644
index 00000000..12ea9465
--- /dev/null
+++ b/3rdparty/libyuv/src/docs/formats.md
@@ -0,0 +1,208 @@
+# Introduction
+
+Formats (FOURCC) supported by libyuv are detailed here.
+
+# Core Formats
+
+There are 2 core formats supported by libyuv - I420 and ARGB.
+  All YUV formats can be converted to/from I420.
+  All RGB formats can be converted to/from ARGB.
+
+Filtering functions such as scaling and planar functions work on I420 and/or ARGB.
+
+# OSX Core Media Pixel Formats
+
+This is how OSX formats map to libyuv
+
+    enum {
+      kCMPixelFormat_32ARGB          = 32,      FOURCC_BGRA
+      kCMPixelFormat_32BGRA          = 'BGRA',  FOURCC_ARGB
+      kCMPixelFormat_24RGB           = 24,      FOURCC_RAW
+      kCMPixelFormat_16BE555         = 16,      Not supported.
+      kCMPixelFormat_16BE565         = 'B565',  Not supported.
+      kCMPixelFormat_16LE555         = 'L555',  FOURCC_RGBO
+      kCMPixelFormat_16LE565         = 'L565',  FOURCC_RGBP
+      kCMPixelFormat_16LE5551        = '5551',  FOURCC_RGBO
+      kCMPixelFormat_422YpCbCr8      = '2vuy',  FOURCC_UYVY
+      kCMPixelFormat_422YpCbCr8_yuvs = 'yuvs',  FOURCC_YUY2
+      kCMPixelFormat_444YpCbCr8      = 'v308',  FOURCC_I444 ?
+      kCMPixelFormat_4444YpCbCrA8    = 'v408',  Not supported.
+      kCMPixelFormat_422YpCbCr16     = 'v216',  Not supported.
+      kCMPixelFormat_422YpCbCr10     = 'v210',  FOURCC_V210 previously.  Removed now.
+      kCMPixelFormat_444YpCbCr10     = 'v410',  Not supported.
+      kCMPixelFormat_8IndexedGray_WhiteIsZero = 0x00000028,  Not supported.
+    };
+
+
+# FOURCC (Four Charactacter Code) List
+
+The following is extracted from video_common.h as a complete list of formats supported by libyuv.
+    enum FourCC {
+      // 10 Primary YUV formats: 5 planar, 2 biplanar, 2 packed.
+      FOURCC_I420 = FOURCC('I', '4', '2', '0'),
+      FOURCC_I422 = FOURCC('I', '4', '2', '2'),
+      FOURCC_I444 = FOURCC('I', '4', '4', '4'),
+      FOURCC_I400 = FOURCC('I', '4', '0', '0'),
+      FOURCC_NV21 = FOURCC('N', 'V', '2', '1'),
+      FOURCC_NV12 = FOURCC('N', 'V', '1', '2'),
+      FOURCC_YUY2 = FOURCC('Y', 'U', 'Y', '2'),
+      FOURCC_UYVY = FOURCC('U', 'Y', 'V', 'Y'),
+      FOURCC_H010 = FOURCC('H', '0', '1', '0'),  // unofficial fourcc. 10 bit lsb
+      FOURCC_U010 = FOURCC('U', '0', '1', '0'),  // bt.2020, unofficial fourcc.
+                                                 // 10 bit lsb
+
+      // 1 Secondary YUV format: row biplanar.
+      FOURCC_M420 = FOURCC('M', '4', '2', '0'),  // deprecated.
+
+      // 13 Primary RGB formats: 4 32 bpp, 2 24 bpp, 3 16 bpp, 1 10 bpc, 2 64 bpp
+      FOURCC_ARGB = FOURCC('A', 'R', 'G', 'B'),
+      FOURCC_BGRA = FOURCC('B', 'G', 'R', 'A'),
+      FOURCC_ABGR = FOURCC('A', 'B', 'G', 'R'),
+      FOURCC_AR30 = FOURCC('A', 'R', '3', '0'),  // 10 bit per channel. 2101010.
+      FOURCC_AB30 = FOURCC('A', 'B', '3', '0'),  // ABGR version of 10 bit
+      FOURCC_AR64 = FOURCC('A', 'R', '6', '4'),  // 16 bit per channel.
+      FOURCC_AB64 = FOURCC('A', 'B', '6', '4'),  // ABGR version of 16 bit
+      FOURCC_24BG = FOURCC('2', '4', 'B', 'G'),
+      FOURCC_RAW = FOURCC('r', 'a', 'w', ' '),
+      FOURCC_RGBA = FOURCC('R', 'G', 'B', 'A'),
+      FOURCC_RGBP = FOURCC('R', 'G', 'B', 'P'),  // rgb565 LE.
+      FOURCC_RGBO = FOURCC('R', 'G', 'B', 'O'),  // argb1555 LE.
+      FOURCC_R444 = FOURCC('R', '4', '4', '4'),  // argb4444 LE.
+
+      // 1 Primary Compressed YUV format.
+      FOURCC_MJPG = FOURCC('M', 'J', 'P', 'G'),
+
+      // 11 Auxiliary YUV variations: 3 with U and V planes are swapped, 1 Alias.
+      FOURCC_YV12 = FOURCC('Y', 'V', '1', '2'),
+      FOURCC_YV16 = FOURCC('Y', 'V', '1', '6'),
+      FOURCC_YV24 = FOURCC('Y', 'V', '2', '4'),
+      FOURCC_YU12 = FOURCC('Y', 'U', '1', '2'),  // Linux version of I420.
+      FOURCC_J420 = FOURCC('J', '4', '2', '0'),
+      FOURCC_J400 = FOURCC('J', '4', '0', '0'),  // unofficial fourcc
+      FOURCC_H420 = FOURCC('H', '4', '2', '0'),  // unofficial fourcc
+      FOURCC_H422 = FOURCC('H', '4', '2', '2'),  // unofficial fourcc
+      FOURCC_U420 = FOURCC('U', '4', '2', '0'),  // bt.2020, unofficial fourcc
+      FOURCC_U422 = FOURCC('U', '4', '2', '2'),  // bt.2020, unofficial fourcc
+      FOURCC_U444 = FOURCC('U', '4', '4', '4'),  // bt.2020, unofficial fourcc
+
+      // 14 Auxiliary aliases.  CanonicalFourCC() maps these to canonical fourcc.
+      FOURCC_IYUV = FOURCC('I', 'Y', 'U', 'V'),  // Alias for I420.
+      FOURCC_YU16 = FOURCC('Y', 'U', '1', '6'),  // Alias for I422.
+      FOURCC_YU24 = FOURCC('Y', 'U', '2', '4'),  // Alias for I444.
+      FOURCC_YUYV = FOURCC('Y', 'U', 'Y', 'V'),  // Alias for YUY2.
+      FOURCC_YUVS = FOURCC('y', 'u', 'v', 's'),  // Alias for YUY2 on Mac.
+      FOURCC_HDYC = FOURCC('H', 'D', 'Y', 'C'),  // Alias for UYVY.
+      FOURCC_2VUY = FOURCC('2', 'v', 'u', 'y'),  // Alias for UYVY on Mac.
+      FOURCC_JPEG = FOURCC('J', 'P', 'E', 'G'),  // Alias for MJPG.
+      FOURCC_DMB1 = FOURCC('d', 'm', 'b', '1'),  // Alias for MJPG on Mac.
+      FOURCC_BA81 = FOURCC('B', 'A', '8', '1'),  // Alias for BGGR.
+      FOURCC_RGB3 = FOURCC('R', 'G', 'B', '3'),  // Alias for RAW.
+      FOURCC_BGR3 = FOURCC('B', 'G', 'R', '3'),  // Alias for 24BG.
+      FOURCC_CM32 = FOURCC(0, 0, 0, 32),  // Alias for BGRA kCMPixelFormat_32ARGB
+      FOURCC_CM24 = FOURCC(0, 0, 0, 24),  // Alias for RAW kCMPixelFormat_24RGB
+      FOURCC_L555 = FOURCC('L', '5', '5', '5'),  // Alias for RGBO.
+      FOURCC_L565 = FOURCC('L', '5', '6', '5'),  // Alias for RGBP.
+      FOURCC_5551 = FOURCC('5', '5', '5', '1'),  // Alias for RGBO.
+
+# Planar YUV
+      The following formats contains a full size Y plane followed by 1 or 2
+        planes for UV: I420, I422, I444, I400, NV21, NV12, I400
+      The size (subsampling) of the UV varies.
+        I420, NV12 and NV21 are half width, half height
+        I422, NV16 and NV61 are half width, full height
+        I444, NV24 and NV42 are full width, full height
+        I400 and J400 have no chroma channel.
+
+# Color space
+      The YUV formats start with a letter to specify the color space. e.g. I420
+        I = BT.601 limited range
+        J = BT.601 full range     (J = JPEG that uses this)
+        H = BT.709 limited range  (H for HD)
+        F = BT.709 full range     (F for Full range)
+        U = BT.2020 limited range (U for UHD)
+        V = BT.2020 full range
+        For YUV to RGB conversions, a matrix can be passed.  See also convert_argh.h
+
+# HDR formats
+      Planar formats with 10 or 12 bits use the following fourcc:
+        I010, I012, P010, P012 are half width, half height
+        I210, I212, P210, P212 are half width, full height
+        I410, I412, P410, P412 are full width, full height
+      where
+        I is the color space (see above) and 3 planes: Y, U and V.
+        P is a biplanar format, similar to NV12 but 16 bits, with the valid bits in the high bits.  There is a Y plane and a UV plane.
+        0, 2 or 4 is the last digit of subsampling: 4:2:0, 4:2:2, or 4:4:4
+        10 or 12 is the bits per channel.  The bits are in the low bits of a 16 bit channel.
+
+# The ARGB FOURCC
+
+There are 4 ARGB layouts - ARGB, BGRA, ABGR and RGBA.  ARGB is most common by far, used for screen formats, and windows webcam drivers.
+
+The fourcc describes the order of channels in a ***register***.
+
+A fourcc provided by capturer, can be thought of string, e.g. "ARGB".
+
+On little endian machines, as an int, this would have 'A' in the lowest byte.  The FOURCC macro reverses the order:
+
+    #define FOURCC(a, b, c, d) (((uint32)(a)) | ((uint32)(b) << 8) | ((uint32)(c) << 16) | ((uint32)(d) << 24))
+
+So the "ARGB" string, read as an uint32, is
+
+    FOURCC_ARGB = FOURCC('A', 'R', 'G', 'B')
+
+If you were to read ARGB pixels as uint32's, the alpha would be in the high byte, and the blue in the lowest byte.  In memory, these are stored little endian, so 'B' is first, then 'G', 'R' and 'A' last.
+
+When calling conversion functions, the names match the FOURCC, so in this case it would be I420ToARGB().
+
+All formats can be converted to/from ARGB.
+
+Most 'planar_functions' work on ARGB (e.g. ARGBBlend).
+
+Some are channel order agnostic (e.g. ARGBScale).
+
+Some functions are symmetric (e.g. ARGBToBGRA is the same as BGRAToARGB, so its a macro).
+
+ARGBBlend expects preattenuated ARGB. The R,G,B are premultiplied by alpha.  Other functions don't care.
+
+# RGB24 and RAW
+
+There are 2 RGB layouts - RGB24 (aka 24BG) and RAW
+
+RGB24 is B,G,R in memory
+RAW is R,G,B in memory
+
+# AR30 and XR30
+
+AR30 is 2 10 10 10 ARGB stored in little endian order.
+The 2 bit alpha has 4 values.  Here are the comparable 8 bit alpha values.
+0 - 0.    00000000b = 0x00 = 0
+1 - 33%.  01010101b = 0x55 = 85
+2 - 66%.  10101010b = 0xaa = 170
+3 - 100%. 11111111b = 0xff = 255
+The 10 bit RGB values range from 0 to 1023.
+XR30 is the same as AR30 but with no alpha channel.
+
+# AB64 and AR64
+
+AB64 is similar to ABGR, with 16 bit (2 bytes) per channel. Each channel stores an unsigned short.
+In memory R is the lowest and A is the highest.
+Each channel has value ranges from 0 to 65535.
+AR64 is similar to ARGB.
+
+# NV12 and NV21
+
+NV12 is a biplanar format with a full sized Y plane followed by a single
+chroma plane with weaved U and V values.
+NV21 is the same but with weaved V and U values.
+The 12 in NV12 refers to 12 bits per pixel.  NV12 has a half width and half
+height chroma channel, and therefore is a 420 subsampling.
+NV16 is 16 bits per pixel, with half width and full height.  aka 422.
+NV24 is 24 bits per pixel with full sized chroma channel. aka 444.
+Most NV12 functions allow the destination Y pointer to be NULL.
+
+# YUY2 and UYVY
+
+YUY2 is a packed YUV format with half width, full height.
+
+YUY2 is YUYV in memory
+UYVY is UYVY in memory
diff --git a/3rdparty/libyuv/src/docs/getting_started.md b/3rdparty/libyuv/src/docs/getting_started.md
new file mode 100644
index 00000000..15b19ab2
--- /dev/null
+++ b/3rdparty/libyuv/src/docs/getting_started.md
@@ -0,0 +1,285 @@
+# Getting Started
+
+How to get and build the libyuv code.
+
+## Pre-requisites
+
+You'll need to have depot tools installed: https://www.chromium.org/developers/how-tos/install-depot-tools
+Refer to chromium instructions for each platform for other prerequisites.
+
+## Getting the Code
+
+Create a working directory, enter it, and run:
+
+    gclient config --name src https://chromium.googlesource.com/libyuv/libyuv
+    gclient sync
+
+Then you'll get a .gclient file like:
+
+    solutions = [
+      { "name"        : "src",
+        "url"         : "https://chromium.googlesource.com/libyuv/libyuv",
+        "deps_file"   : "DEPS",
+        "managed"     : True,
+        "custom_deps" : {
+        },
+        "safesync_url": "",
+      },
+    ];
+
+For iOS add `;target_os=['ios'];` to your OSX .gclient and run `gclient sync.`
+
+Browse the Git reprository: https://chromium.googlesource.com/libyuv/libyuv/+/master
+
+### Android
+For Android add `;target_os=['android'];` to your Linux .gclient
+
+    solutions = [
+      { "name"        : "src",
+        "url"         : "https://chromium.googlesource.com/libyuv/libyuv",
+        "deps_file"   : "DEPS",
+        "managed"     : True,
+        "custom_deps" : {
+        },
+        "safesync_url": "",
+      },
+    ];
+    target_os = ["android", "linux"];
+
+Then run:
+
+    gclient sync
+
+To get just the source (not buildable):
+
+    git clone https://chromium.googlesource.com/libyuv/libyuv
+
+
+## Building the Library and Unittests
+
+### Windows
+
+    call gn gen out\Release "--args=is_debug=false target_cpu=\"x64\""
+    call gn gen out\Debug "--args=is_debug=true target_cpu=\"x64\""
+    ninja -v -C out\Release
+    ninja -v -C out\Debug
+
+    call gn gen out\Release "--args=is_debug=false target_cpu=\"x86\""
+    call gn gen out\Debug "--args=is_debug=true target_cpu=\"x86\""
+    ninja -v -C out\Release
+    ninja -v -C out\Debug
+
+### macOS and Linux
+
+    gn gen out/Release "--args=is_debug=false"
+    gn gen out/Debug "--args=is_debug=true"
+    ninja -v -C out/Release
+    ninja -v -C out/Debug
+
+### Building Offical with GN
+
+    gn gen out/Official "--args=is_debug=false is_official_build=true is_chrome_branded=true"
+    ninja -C out/Official
+
+### iOS
+http://www.chromium.org/developers/how-tos/build-instructions-ios
+
+Add to .gclient last line: `target_os=['ios'];`
+
+arm64
+
+    gn gen out/Release "--args=is_debug=false target_os=\"ios\" ios_enable_code_signing=false target_cpu=\"arm64\""
+    gn gen out/Debug "--args=is_debug=true target_os=\"ios\" ios_enable_code_signing=false target_cpu=\"arm64\""
+    ninja -v -C out/Debug libyuv_unittest
+    ninja -v -C out/Release libyuv_unittest
+
+ios simulator
+
+    gn gen out/Release "--args=is_debug=false target_os=\"ios\" ios_enable_code_signing=false use_xcode_clang=true target_cpu=\"x86\""
+    gn gen out/Debug "--args=is_debug=true target_os=\"ios\" ios_enable_code_signing=false use_xcode_clang=true target_cpu=\"x86\""
+    ninja -v -C out/Debug libyuv_unittest
+    ninja -v -C out/Release libyuv_unittest
+
+ios disassembly
+
+    otool -tV ./out/Release/obj/libyuv_neon/row_neon64.o >row_neon64.txt
+
+### Android
+https://code.google.com/p/chromium/wiki/AndroidBuildInstructions
+
+Add to .gclient last line: `target_os=['android'];`
+
+arm64
+
+    gn gen out/Release "--args=is_debug=false target_os=\"android\" target_cpu=\"arm64\""
+    gn gen out/Debug "--args=is_debug=true target_os=\"android\" target_cpu=\"arm64\""
+    ninja -v -C out/Debug libyuv_unittest
+    ninja -v -C out/Release libyuv_unittest
+
+armv7
+
+    gn gen out/Release "--args=is_debug=false target_os=\"android\" target_cpu=\"arm\""
+    gn gen out/Debug "--args=is_debug=true target_os=\"android\" target_cpu=\"arm\""
+    ninja -v -C out/Debug libyuv_unittest
+    ninja -v -C out/Release libyuv_unittest
+
+ia32
+
+    gn gen out/Release "--args=is_debug=false target_os=\"android\" target_cpu=\"x86\""
+    gn gen out/Debug "--args=is_debug=true target_os=\"android\" target_cpu=\"x86\""
+    ninja -v -C out/Debug libyuv_unittest
+    ninja -v -C out/Release libyuv_unittest
+
+mips
+
+    gn gen out/Release "--args=is_debug=false target_os=\"android\" target_cpu=\"mips64el\" mips_arch_variant=\"r6\" mips_use_msa=true is_component_build=true"
+    gn gen out/Debug "--args=is_debug=true target_os=\"android\" target_cpu=\"mips64el\" mips_arch_variant=\"r6\" mips_use_msa=true is_component_build=true"
+    ninja -v -C out/Debug libyuv_unittest
+    ninja -v -C out/Release libyuv_unittest
+
+arm disassembly:
+
+    third_party/android_ndk/toolchains/aarch64-linux-android-4.9/prebuilt/linux-x86_64/bin/aarch64-linux-android-objdump -d ./out/Release/obj/libyuv/row_common.o >row_common.txt
+
+    third_party/android_ndk/toolchains/aarch64-linux-android-4.9/prebuilt/linux-x86_64/bin/aarch64-linux-android-objdump -d ./out/Release/obj/libyuv_neon/row_neon.o >row_neon.txt
+
+    third_party/android_ndk/toolchains/aarch64-linux-android-4.9/prebuilt/linux-x86_64/bin/aarch64-linux-android-objdump -d ./out/Release/obj/libyuv_neon/row_neon64.o >row_neon64.txt
+
+    Caveat: Disassembly may require optimize_max be disabled in BUILD.gn
+
+Running tests:
+
+    out/Release/bin/run_libyuv_unittest -vv --gtest_filter=*
+
+Running test as benchmark:
+
+    out/Release/bin/run_libyuv_unittest -vv --gtest_filter=* --libyuv_width=1280 --libyuv_height=720 --libyuv_repeat=999 --libyuv_flags=-1  --libyuv_cpu_info=-1
+
+Running test with C code:
+
+    out/Release/bin/run_libyuv_unittest -vv --gtest_filter=* --libyuv_width=1280 --libyuv_height=720 --libyuv_repeat=999 --libyuv_flags=1 --libyuv_cpu_info=1
+
+### Build targets
+
+    ninja -C out/Debug libyuv
+    ninja -C out/Debug libyuv_unittest
+    ninja -C out/Debug compare
+    ninja -C out/Debug yuvconvert
+    ninja -C out/Debug yuvconstants
+    ninja -C out/Debug psnr
+    ninja -C out/Debug cpuid
+
+### ARM Linux
+
+    gn gen out/Release "--args=is_debug=false target_cpu=\"arm64\""
+    gn gen out/Debug "--args=is_debug=true target_cpu=\"arm64\""
+    ninja -v -C out/Debug libyuv_unittest
+    ninja -v -C out/Release libyuv_unittest
+
+### MIPS Linux
+
+mips
+
+   gn gen out/Release "--args=is_debug=false target_os=\"linux\" target_cpu=\"mips64el\" mips_arch_variant=\"loongson3\" is_component_build=false use_sysroot=false use_gold=false"
+   gn gen out/Debug "--args=is_debug=true target_os=\"linux\" target_cpu=\"mips64el\" mips_arch_variant=\"loongson3\" is_component_build=false use_sysroot=false use_gold=false"
+   ninja -v -C out/Debug libyuv_unittest
+   ninja -v -C out/Release libyuv_unittest
+
+## Building the Library with make
+
+### Linux
+
+    make V=1 -f linux.mk
+    make V=1 -f linux.mk clean
+    make V=1 -f linux.mk CXX=clang++ CC=clang
+
+## Building the library with cmake
+
+Install cmake: http://www.cmake.org/
+
+### Default debug build:
+
+    mkdir out
+    cd out
+    cmake ..
+    cmake --build .
+
+### Release build/install
+
+    mkdir out
+    cd out
+    cmake -DCMAKE_INSTALL_PREFIX="/usr/lib" -DCMAKE_BUILD_TYPE="Release" ..
+    cmake --build . --config Release
+    sudo cmake --build . --target install --config Release
+
+### Build RPM/DEB packages
+
+    mkdir out
+    cd out
+    cmake -DCMAKE_BUILD_TYPE=Release ..
+    make -j4
+    make package
+
+## Setup for Arm Cross compile
+
+See also https://www.ccoderun.ca/programming/2015-12-20_CrossCompiling/index.html
+
+    sudo apt-get install ssh dkms build-essential linux-headers-generic
+    sudo apt-get install kdevelop cmake git subversion
+    sudo apt-get install graphviz doxygen doxygen-gui
+    sudo apt-get install manpages manpages-dev manpages-posix manpages-posix-dev
+    sudo apt-get install libboost-all-dev libboost-dev libssl-dev
+    sudo apt-get install rpm terminator fish
+    sudo apt-get install g++-arm-linux-gnueabihf gcc-arm-linux-gnueabihf
+
+### Build psnr tool
+
+    cd util
+    arm-linux-gnueabihf-g++ psnr_main.cc psnr.cc ssim.cc -o psnr
+    arm-linux-gnueabihf-objdump -d psnr
+
+## Running Unittests
+
+### Windows
+
+    out\Release\libyuv_unittest.exe --gtest_catch_exceptions=0 --gtest_filter="*"
+
+### macOS and Linux
+
+    out/Release/libyuv_unittest --gtest_filter="*"
+
+Replace --gtest_filter="*" with specific unittest to run.  May include wildcards.
+    out/Release/libyuv_unittest --gtest_filter=*I420ToARGB_Opt
+
+## CPU Emulator tools
+
+### Intel SDE (Software Development Emulator)
+
+Pre-requisite: Install IntelSDE: http://software.intel.com/en-us/articles/intel-software-development-emulator
+
+Then run:
+
+    c:\intelsde\sde -hsw -- out\Release\libyuv_unittest.exe --gtest_filter=*
+
+    ~/intelsde/sde -skx -- out/Release/libyuv_unittest --gtest_filter=**I420ToARGB_Opt
+
+### Intel Architecture Code Analyzer
+
+Inset these 2 macros into assembly code to be analyzed:
+    IACA_ASM_START
+    IACA_ASM_END
+Build the code as usual, then run iaca on the object file.
+    ~/iaca-lin64/bin/iaca.sh -reduceout -arch HSW out/Release/obj/libyuv_internal/compare_gcc.o
+
+## Sanitizers
+
+    gn gen out/Release "--args=is_debug=false is_msan=true"
+    ninja -v -C out/Release
+
+Sanitizers available: asan, msan, tsan, ubsan, lsan, ubsan_vptr
+
+### Running Dr Memory memcheck for Windows
+
+Pre-requisite: Install Dr Memory for Windows and add it to your path: http://www.drmemory.org/docs/page_install_windows.html
+
+    drmemory out\Debug\libyuv_unittest.exe --gtest_catch_exceptions=0 --gtest_filter=*
diff --git a/3rdparty/libyuv/src/docs/rotation.md b/3rdparty/libyuv/src/docs/rotation.md
new file mode 100644
index 00000000..a08430fd
--- /dev/null
+++ b/3rdparty/libyuv/src/docs/rotation.md
@@ -0,0 +1,107 @@
+# Introduction
+
+Rotation by multiplies of 90 degrees allows mobile devices to rotate webcams from landscape to portrait.  The higher level functions ConvertToI420 and ConvertToARGB allow rotation of any format.  Optimized functionality is supported for I420, ARGB, NV12 and NV21.
+
+# ConvertToI420
+
+    int ConvertToI420(const uint8* src_frame, size_t src_size,
+                      uint8* dst_y, int dst_stride_y,
+                      uint8* dst_u, int dst_stride_u,
+                      uint8* dst_v, int dst_stride_v,
+                      int crop_x, int crop_y,
+                      int src_width, int src_height,
+                      int crop_width, int crop_height,
+                      enum RotationMode rotation,
+                      uint32 format);
+
+This function crops, converts, and rotates.  You should think of it in that order.
+  * Crops the original image, which is src_width x src_height, to crop_width x crop_height.  At this point the image is still not rotated.
+  * Converts the cropped region to I420.  Supports inverted source for src_height negative.
+  * Rotates by 90, 180 or 270 degrees.
+The buffer the caller provides should account for rotation.  Be especially important to get stride of the destination correct.
+
+e.g.
+640 x 480 NV12 captured<br>
+Crop to 640 x 360<br>
+Rotate by 90 degrees to 360 x 640.<br>
+Caller passes stride of 360 for Y and 360 / 2 for U and V.<br>
+Caller passes crop_width of 640, crop_height of 360.<br>
+
+# ConvertToARGB
+
+    int ConvertToARGB(const uint8* src_frame, size_t src_size,
+                      uint8* dst_argb, int dst_stride_argb,
+                      int crop_x, int crop_y,
+                      int src_width, int src_height,
+                      int crop_width, int crop_height,
+                      enum RotationMode rotation,
+                      uint32 format);
+
+Same as I420, but implementation is less optimized - reads columns and writes rows, 16 bytes at a time.
+
+# I420Rotate
+
+    int I420Rotate(const uint8* src_y, int src_stride_y,
+                   const uint8* src_u, int src_stride_u,
+                   const uint8* src_v, int src_stride_v,
+                   uint8* dst_y, int dst_stride_y,
+                   uint8* dst_u, int dst_stride_u,
+                   uint8* dst_v, int dst_stride_v,
+                   int src_width, int src_height, enum RotationMode mode);
+
+Destination is rotated, so pass dst_stride_y etc that consider rotation.<br>
+Rotate by 180 can be done in place, but 90 and 270 can not.
+
+Implementation (Neon/SSE2) uses 8 x 8 block transpose, so best efficiency is with sizes and pointers that are aligned to 8.
+
+Cropping can be achieved by adjusting the src_y/u/v pointers and src_width, src_height.
+
+Lower level plane functions are provided, allowing other planar formats to be rotated.  (e.g. I444)
+
+For other planar YUV formats (I444, I422, I411, I400, NV16, NV24), the planar functions are exposed and can be called directly
+
+
+    // Rotate a plane by 0, 90, 180, or 270.
+    int RotatePlane(const uint8* src, int src_stride,
+                    uint8* dst, int dst_stride,
+                    int src_width, int src_height, enum RotationMode mode);
+
+# ARGBRotate
+
+    LIBYUV_API
+    int ARGBRotate(const uint8* src_argb, int src_stride_argb,
+                   uint8* dst_argb, int dst_stride_argb,
+                   int src_width, int src_height, enum RotationMode mode);
+
+Same as I420, but implementation is less optimized - reads columns and writes rows.
+
+Rotate by 90, or any angle, can be achieved using ARGBAffine.
+
+# Mirror - Horizontal Flip
+
+Mirror functions for horizontally flipping an image, which can be useful for 'self view' of a webcam.
+
+    int I420Mirror(const uint8* src_y, int src_stride_y,
+                   const uint8* src_u, int src_stride_u,
+                   const uint8* src_v, int src_stride_v,
+                   uint8* dst_y, int dst_stride_y,
+                   uint8* dst_u, int dst_stride_u,
+                   uint8* dst_v, int dst_stride_v,
+                   int width, int height);
+    int ARGBMirror(const uint8* src_argb, int src_stride_argb,
+                   uint8* dst_argb, int dst_stride_argb,
+                   int width, int height);
+
+Mirror functionality can also be achieved with the I420Scale and ARGBScale functions by passing negative width and/or height.
+
+# Invert - Vertical Flip
+
+Inverting can be achieved with almost any libyuv function by passing a negative source height.
+
+I420Mirror and ARGBMirror can also be used to rotate by 180 degrees by passing a negative height.
+
+# Cropping - Vertical Flip
+
+When cropping from a subsampled format like NV21, the method of setting the start pointers wont work for odd crop start y on the UV plane.
+If the height after cropping will be odd, invert the source - point to the last row, negate the strides, and pass negative height, which
+will re-invert the image as the conversion outputs.
diff --git a/3rdparty/libyuv/src/download_vs_toolchain.py b/3rdparty/libyuv/src/download_vs_toolchain.py
new file mode 100644
index 00000000..6bc086d6
--- /dev/null
+++ b/3rdparty/libyuv/src/download_vs_toolchain.py
@@ -0,0 +1,29 @@
+#!/usr/bin/env vpython3
+
+# Copyright 2014 The LibYuv Project Authors. All rights reserved.
+#
+# Use of this source code is governed by a BSD-style license
+# that can be found in the LICENSE file in the root of the source
+# tree. An additional intellectual property rights grant can be found
+# in the file PATENTS. All contributing project authors may
+# be found in the AUTHORS file in the root of the source tree.
+
+# This script is used to run the vs_toolchain.py script to download the
+# Visual Studio toolchain. It's just a temporary measure while waiting for the
+# Chrome team to move find_depot_tools into src/build to get rid of these
+# workarounds (similar one in gyp_libyuv).
+
+import os
+import sys
+
+
+checkout_root = os.path.dirname(os.path.realpath(__file__))
+sys.path.insert(0, os.path.join(checkout_root, 'build'))
+sys.path.insert(0, os.path.join(checkout_root, 'tools', 'find_depot_tools'))
+
+
+import vs_toolchain  # pylint: disable=wrong-import-position
+
+
+if __name__ == '__main__':
+  sys.exit(vs_toolchain.main())
diff --git a/3rdparty/libyuv/src/include/libyuv.h b/3rdparty/libyuv/src/include/libyuv.h
new file mode 100644
index 00000000..a06e1233
--- /dev/null
+++ b/3rdparty/libyuv/src/include/libyuv.h
@@ -0,0 +1,33 @@
+/*
+ *  Copyright 2011 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#ifndef INCLUDE_LIBYUV_H_
+#define INCLUDE_LIBYUV_H_
+
+#include "libyuv/basic_types.h"
+#include "libyuv/compare.h"
+#include "libyuv/convert.h"
+#include "libyuv/convert_argb.h"
+#include "libyuv/convert_from.h"
+#include "libyuv/convert_from_argb.h"
+#include "libyuv/cpu_id.h"
+#include "libyuv/mjpeg_decoder.h"
+#include "libyuv/planar_functions.h"
+#include "libyuv/rotate.h"
+#include "libyuv/rotate_argb.h"
+#include "libyuv/row.h"
+#include "libyuv/scale.h"
+#include "libyuv/scale_argb.h"
+#include "libyuv/scale_row.h"
+#include "libyuv/scale_uv.h"
+#include "libyuv/version.h"
+#include "libyuv/video_common.h"
+
+#endif  // INCLUDE_LIBYUV_H_
diff --git a/3rdparty/libyuv/src/include/libyuv/basic_types.h b/3rdparty/libyuv/src/include/libyuv/basic_types.h
new file mode 100644
index 00000000..1bea67f2
--- /dev/null
+++ b/3rdparty/libyuv/src/include/libyuv/basic_types.h
@@ -0,0 +1,68 @@
+/*
+ *  Copyright 2011 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#ifndef INCLUDE_LIBYUV_BASIC_TYPES_H_
+#define INCLUDE_LIBYUV_BASIC_TYPES_H_
+
+#include <stddef.h>  // For size_t and NULL
+
+#if !defined(INT_TYPES_DEFINED) && !defined(GG_LONGLONG)
+#define INT_TYPES_DEFINED
+
+#if defined(_MSC_VER) && (_MSC_VER < 1600)
+#include <sys/types.h>  // for uintptr_t on x86
+typedef unsigned __int64 uint64_t;
+typedef __int64 int64_t;
+typedef unsigned int uint32_t;
+typedef int int32_t;
+typedef unsigned short uint16_t;
+typedef short int16_t;
+typedef unsigned char uint8_t;
+typedef signed char int8_t;
+#else
+#include <stdint.h>  // for uintptr_t and C99 types
+#endif               // defined(_MSC_VER) && (_MSC_VER < 1600)
+// Types are deprecated.  Enable this macro for legacy types.
+#ifdef LIBYUV_LEGACY_TYPES
+typedef uint64_t uint64;
+typedef int64_t int64;
+typedef uint32_t uint32;
+typedef int32_t int32;
+typedef uint16_t uint16;
+typedef int16_t int16;
+typedef uint8_t uint8;
+typedef int8_t int8;
+#endif  // LIBYUV_LEGACY_TYPES
+#endif  // INT_TYPES_DEFINED
+
+#if !defined(LIBYUV_API)
+#if defined(_WIN32) || defined(__CYGWIN__)
+#if defined(LIBYUV_BUILDING_SHARED_LIBRARY)
+#define LIBYUV_API __declspec(dllexport)
+#elif defined(LIBYUV_USING_SHARED_LIBRARY)
+#define LIBYUV_API __declspec(dllimport)
+#else
+#define LIBYUV_API
+#endif  // LIBYUV_BUILDING_SHARED_LIBRARY
+#elif defined(__GNUC__) && (__GNUC__ >= 4) && !defined(__APPLE__) && \
+    (defined(LIBYUV_BUILDING_SHARED_LIBRARY) ||                      \
+     defined(LIBYUV_USING_SHARED_LIBRARY))
+#define LIBYUV_API __attribute__((visibility("default")))
+#else
+#define LIBYUV_API
+#endif  // __GNUC__
+#endif  // LIBYUV_API
+
+// TODO(fbarchard): Remove bool macros.
+#define LIBYUV_BOOL int
+#define LIBYUV_FALSE 0
+#define LIBYUV_TRUE 1
+
+#endif  // INCLUDE_LIBYUV_BASIC_TYPES_H_
diff --git a/3rdparty/libyuv/src/include/libyuv/compare.h b/3rdparty/libyuv/src/include/libyuv/compare.h
new file mode 100644
index 00000000..3353ad71
--- /dev/null
+++ b/3rdparty/libyuv/src/include/libyuv/compare.h
@@ -0,0 +1,111 @@
+/*
+ *  Copyright 2011 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#ifndef INCLUDE_LIBYUV_COMPARE_H_
+#define INCLUDE_LIBYUV_COMPARE_H_
+
+#include "libyuv/basic_types.h"
+
+#ifdef __cplusplus
+namespace libyuv {
+extern "C" {
+#endif
+
+// Compute a hash for specified memory. Seed of 5381 recommended.
+LIBYUV_API
+uint32_t HashDjb2(const uint8_t* src, uint64_t count, uint32_t seed);
+
+// Hamming Distance
+LIBYUV_API
+uint64_t ComputeHammingDistance(const uint8_t* src_a,
+                                const uint8_t* src_b,
+                                int count);
+
+// Scan an opaque argb image and return fourcc based on alpha offset.
+// Returns FOURCC_ARGB, FOURCC_BGRA, or 0 if unknown.
+LIBYUV_API
+uint32_t ARGBDetect(const uint8_t* argb,
+                    int stride_argb,
+                    int width,
+                    int height);
+
+// Sum Square Error - used to compute Mean Square Error or PSNR.
+LIBYUV_API
+uint64_t ComputeSumSquareError(const uint8_t* src_a,
+                               const uint8_t* src_b,
+                               int count);
+
+LIBYUV_API
+uint64_t ComputeSumSquareErrorPlane(const uint8_t* src_a,
+                                    int stride_a,
+                                    const uint8_t* src_b,
+                                    int stride_b,
+                                    int width,
+                                    int height);
+
+static const int kMaxPsnr = 128;
+
+LIBYUV_API
+double SumSquareErrorToPsnr(uint64_t sse, uint64_t count);
+
+LIBYUV_API
+double CalcFramePsnr(const uint8_t* src_a,
+                     int stride_a,
+                     const uint8_t* src_b,
+                     int stride_b,
+                     int width,
+                     int height);
+
+LIBYUV_API
+double I420Psnr(const uint8_t* src_y_a,
+                int stride_y_a,
+                const uint8_t* src_u_a,
+                int stride_u_a,
+                const uint8_t* src_v_a,
+                int stride_v_a,
+                const uint8_t* src_y_b,
+                int stride_y_b,
+                const uint8_t* src_u_b,
+                int stride_u_b,
+                const uint8_t* src_v_b,
+                int stride_v_b,
+                int width,
+                int height);
+
+LIBYUV_API
+double CalcFrameSsim(const uint8_t* src_a,
+                     int stride_a,
+                     const uint8_t* src_b,
+                     int stride_b,
+                     int width,
+                     int height);
+
+LIBYUV_API
+double I420Ssim(const uint8_t* src_y_a,
+                int stride_y_a,
+                const uint8_t* src_u_a,
+                int stride_u_a,
+                const uint8_t* src_v_a,
+                int stride_v_a,
+                const uint8_t* src_y_b,
+                int stride_y_b,
+                const uint8_t* src_u_b,
+                int stride_u_b,
+                const uint8_t* src_v_b,
+                int stride_v_b,
+                int width,
+                int height);
+
+#ifdef __cplusplus
+}  // extern "C"
+}  // namespace libyuv
+#endif
+
+#endif  // INCLUDE_LIBYUV_COMPARE_H_
diff --git a/3rdparty/libyuv/src/include/libyuv/compare_row.h b/3rdparty/libyuv/src/include/libyuv/compare_row.h
new file mode 100644
index 00000000..d8e82d72
--- /dev/null
+++ b/3rdparty/libyuv/src/include/libyuv/compare_row.h
@@ -0,0 +1,130 @@
+/*
+ *  Copyright 2013 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#ifndef INCLUDE_LIBYUV_COMPARE_ROW_H_
+#define INCLUDE_LIBYUV_COMPARE_ROW_H_
+
+#include "libyuv/basic_types.h"
+
+#ifdef __cplusplus
+namespace libyuv {
+extern "C" {
+#endif
+
+#if defined(__pnacl__) || defined(__CLR_VER) ||            \
+    (defined(__native_client__) && defined(__x86_64__)) || \
+    (defined(__i386__) && !defined(__SSE__) && !defined(__clang__))
+#define LIBYUV_DISABLE_X86
+#endif
+#if defined(__native_client__)
+#define LIBYUV_DISABLE_NEON
+#endif
+// MemorySanitizer does not support assembly code yet. http://crbug.com/344505
+#if defined(__has_feature)
+#if __has_feature(memory_sanitizer)
+#define LIBYUV_DISABLE_X86
+#endif
+#endif
+// Visual C 2012 required for AVX2.
+#if defined(_M_IX86) && !defined(__clang__) && defined(_MSC_VER) && \
+    _MSC_VER >= 1700
+#define VISUALC_HAS_AVX2 1
+#endif  // VisualStudio >= 2012
+
+// clang >= 3.4.0 required for AVX2.
+#if defined(__clang__) && (defined(__x86_64__) || defined(__i386__))
+#if (__clang_major__ > 3) || (__clang_major__ == 3 && (__clang_minor__ >= 4))
+#define CLANG_HAS_AVX2 1
+#endif  // clang >= 3.4
+#endif  // __clang__
+
+// The following are available for Visual C and GCC:
+#if !defined(LIBYUV_DISABLE_X86) && \
+    (defined(__x86_64__) || defined(__i386__) || defined(_M_IX86))
+#define HAS_HASHDJB2_SSE41
+#define HAS_SUMSQUAREERROR_SSE2
+#define HAS_HAMMINGDISTANCE_SSE42
+#endif
+
+// The following are available for Visual C and clangcl 32 bit:
+#if !defined(LIBYUV_DISABLE_X86) && defined(_M_IX86) && defined(_MSC_VER) && \
+    !defined(__clang__) &&                                                   \
+    (defined(VISUALC_HAS_AVX2) || defined(CLANG_HAS_AVX2))
+#define HAS_HASHDJB2_AVX2
+#define HAS_SUMSQUAREERROR_AVX2
+#endif
+
+// The following are available for GCC and clangcl:
+#if !defined(LIBYUV_DISABLE_X86) && (defined(__x86_64__) || defined(__i386__))
+#define HAS_HAMMINGDISTANCE_SSSE3
+#endif
+
+// The following are available for GCC and clangcl:
+#if !defined(LIBYUV_DISABLE_X86) && defined(CLANG_HAS_AVX2) && \
+    (defined(__x86_64__) || defined(__i386__))
+#define HAS_HAMMINGDISTANCE_AVX2
+#endif
+
+// The following are available for Neon:
+#if !defined(LIBYUV_DISABLE_NEON) && \
+    (defined(__ARM_NEON__) || defined(LIBYUV_NEON) || defined(__aarch64__))
+#define HAS_SUMSQUAREERROR_NEON
+#define HAS_HAMMINGDISTANCE_NEON
+#endif
+
+#if !defined(LIBYUV_DISABLE_MSA) && defined(__mips_msa)
+#define HAS_HAMMINGDISTANCE_MSA
+#define HAS_SUMSQUAREERROR_MSA
+#endif
+
+uint32_t HammingDistance_C(const uint8_t* src_a,
+                           const uint8_t* src_b,
+                           int count);
+uint32_t HammingDistance_SSE42(const uint8_t* src_a,
+                               const uint8_t* src_b,
+                               int count);
+uint32_t HammingDistance_SSSE3(const uint8_t* src_a,
+                               const uint8_t* src_b,
+                               int count);
+uint32_t HammingDistance_AVX2(const uint8_t* src_a,
+                              const uint8_t* src_b,
+                              int count);
+uint32_t HammingDistance_NEON(const uint8_t* src_a,
+                              const uint8_t* src_b,
+                              int count);
+uint32_t HammingDistance_MSA(const uint8_t* src_a,
+                             const uint8_t* src_b,
+                             int count);
+uint32_t SumSquareError_C(const uint8_t* src_a,
+                          const uint8_t* src_b,
+                          int count);
+uint32_t SumSquareError_SSE2(const uint8_t* src_a,
+                             const uint8_t* src_b,
+                             int count);
+uint32_t SumSquareError_AVX2(const uint8_t* src_a,
+                             const uint8_t* src_b,
+                             int count);
+uint32_t SumSquareError_NEON(const uint8_t* src_a,
+                             const uint8_t* src_b,
+                             int count);
+uint32_t SumSquareError_MSA(const uint8_t* src_a,
+                            const uint8_t* src_b,
+                            int count);
+
+uint32_t HashDjb2_C(const uint8_t* src, int count, uint32_t seed);
+uint32_t HashDjb2_SSE41(const uint8_t* src, int count, uint32_t seed);
+uint32_t HashDjb2_AVX2(const uint8_t* src, int count, uint32_t seed);
+
+#ifdef __cplusplus
+}  // extern "C"
+}  // namespace libyuv
+#endif
+
+#endif  // INCLUDE_LIBYUV_COMPARE_ROW_H_
diff --git a/3rdparty/libyuv/src/include/libyuv/convert.h b/3rdparty/libyuv/src/include/libyuv/convert.h
new file mode 100644
index 00000000..46d37159
--- /dev/null
+++ b/3rdparty/libyuv/src/include/libyuv/convert.h
@@ -0,0 +1,922 @@
+/*
+ *  Copyright 2011 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#ifndef INCLUDE_LIBYUV_CONVERT_H_
+#define INCLUDE_LIBYUV_CONVERT_H_
+
+#include "libyuv/basic_types.h"
+
+#include "libyuv/rotate.h"  // For enum RotationMode.
+
+// TODO(fbarchard): fix WebRTC source to include following libyuv headers:
+#include "libyuv/convert_argb.h"      // For WebRTC I420ToARGB. b/620
+#include "libyuv/convert_from.h"      // For WebRTC ConvertFromI420. b/620
+#include "libyuv/planar_functions.h"  // For WebRTC I420Rect, CopyPlane. b/618
+
+#ifdef __cplusplus
+namespace libyuv {
+extern "C" {
+#endif
+
+// Convert I444 to I420.
+LIBYUV_API
+int I444ToI420(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_u,
+               int dst_stride_u,
+               uint8_t* dst_v,
+               int dst_stride_v,
+               int width,
+               int height);
+
+// Convert I444 to NV12.
+LIBYUV_API
+int I444ToNV12(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_uv,
+               int dst_stride_uv,
+               int width,
+               int height);
+
+// Convert I444 to NV21.
+LIBYUV_API
+int I444ToNV21(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_vu,
+               int dst_stride_vu,
+               int width,
+               int height);
+
+// Convert I422 to I420.
+LIBYUV_API
+int I422ToI420(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_u,
+               int dst_stride_u,
+               uint8_t* dst_v,
+               int dst_stride_v,
+               int width,
+               int height);
+
+// Convert I422 to I444.
+LIBYUV_API
+int I422ToI444(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_u,
+               int dst_stride_u,
+               uint8_t* dst_v,
+               int dst_stride_v,
+               int width,
+               int height);
+
+// Convert I422 to I210.
+LIBYUV_API
+int I422ToI210(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint16_t* dst_y,
+               int dst_stride_y,
+               uint16_t* dst_u,
+               int dst_stride_u,
+               uint16_t* dst_v,
+               int dst_stride_v,
+               int width,
+               int height);
+
+// Convert MM21 to NV12.
+LIBYUV_API
+int MM21ToNV12(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_uv,
+               int src_stride_uv,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_uv,
+               int dst_stride_uv,
+               int width,
+               int height);
+
+// Convert MM21 to I420.
+LIBYUV_API
+int MM21ToI420(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_uv,
+               int src_stride_uv,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_u,
+               int dst_stride_u,
+               uint8_t* dst_v,
+               int dst_stride_v,
+               int width,
+               int height);
+
+// Convert I422 to NV21.
+LIBYUV_API
+int I422ToNV21(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_vu,
+               int dst_stride_vu,
+               int width,
+               int height);
+
+// Copy I420 to I420.
+#define I420ToI420 I420Copy
+LIBYUV_API
+int I420Copy(const uint8_t* src_y,
+             int src_stride_y,
+             const uint8_t* src_u,
+             int src_stride_u,
+             const uint8_t* src_v,
+             int src_stride_v,
+             uint8_t* dst_y,
+             int dst_stride_y,
+             uint8_t* dst_u,
+             int dst_stride_u,
+             uint8_t* dst_v,
+             int dst_stride_v,
+             int width,
+             int height);
+
+// Convert I420 to I444.
+LIBYUV_API
+int I420ToI444(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_u,
+               int dst_stride_u,
+               uint8_t* dst_v,
+               int dst_stride_v,
+               int width,
+               int height);
+
+// Copy I010 to I010
+#define I010ToI010 I010Copy
+#define H010ToH010 I010Copy
+LIBYUV_API
+int I010Copy(const uint16_t* src_y,
+             int src_stride_y,
+             const uint16_t* src_u,
+             int src_stride_u,
+             const uint16_t* src_v,
+             int src_stride_v,
+             uint16_t* dst_y,
+             int dst_stride_y,
+             uint16_t* dst_u,
+             int dst_stride_u,
+             uint16_t* dst_v,
+             int dst_stride_v,
+             int width,
+             int height);
+
+// Convert 10 bit YUV to 8 bit
+#define H010ToH420 I010ToI420
+LIBYUV_API
+int I010ToI420(const uint16_t* src_y,
+               int src_stride_y,
+               const uint16_t* src_u,
+               int src_stride_u,
+               const uint16_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_u,
+               int dst_stride_u,
+               uint8_t* dst_v,
+               int dst_stride_v,
+               int width,
+               int height);
+
+#define H210ToH420 I210ToI420
+LIBYUV_API
+int I210ToI420(const uint16_t* src_y,
+               int src_stride_y,
+               const uint16_t* src_u,
+               int src_stride_u,
+               const uint16_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_u,
+               int dst_stride_u,
+               uint8_t* dst_v,
+               int dst_stride_v,
+               int width,
+               int height);
+
+#define H210ToH422 I210ToI422
+LIBYUV_API
+int I210ToI422(const uint16_t* src_y,
+               int src_stride_y,
+               const uint16_t* src_u,
+               int src_stride_u,
+               const uint16_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_u,
+               int dst_stride_u,
+               uint8_t* dst_v,
+               int dst_stride_v,
+               int width,
+               int height);
+
+#define H410ToH444 I410ToI444
+LIBYUV_API
+int I410ToI444(const uint16_t* src_y,
+               int src_stride_y,
+               const uint16_t* src_u,
+               int src_stride_u,
+               const uint16_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_u,
+               int dst_stride_u,
+               uint8_t* dst_v,
+               int dst_stride_v,
+               int width,
+               int height);
+
+#define H012ToH420 I012ToI420
+LIBYUV_API
+int I012ToI420(const uint16_t* src_y,
+               int src_stride_y,
+               const uint16_t* src_u,
+               int src_stride_u,
+               const uint16_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_u,
+               int dst_stride_u,
+               uint8_t* dst_v,
+               int dst_stride_v,
+               int width,
+               int height);
+
+#define H212ToH422 I212ToI422
+LIBYUV_API
+int I212ToI422(const uint16_t* src_y,
+               int src_stride_y,
+               const uint16_t* src_u,
+               int src_stride_u,
+               const uint16_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_u,
+               int dst_stride_u,
+               uint8_t* dst_v,
+               int dst_stride_v,
+               int width,
+               int height);
+
+#define H412ToH444 I412ToI444
+LIBYUV_API
+int I412ToI444(const uint16_t* src_y,
+               int src_stride_y,
+               const uint16_t* src_u,
+               int src_stride_u,
+               const uint16_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_u,
+               int dst_stride_u,
+               uint8_t* dst_v,
+               int dst_stride_v,
+               int width,
+               int height);
+
+#define I412ToI012 I410ToI010
+#define H410ToH010 I410ToI010
+#define H412ToH012 I410ToI010
+LIBYUV_API
+int I410ToI010(const uint16_t* src_y,
+               int src_stride_y,
+               const uint16_t* src_u,
+               int src_stride_u,
+               const uint16_t* src_v,
+               int src_stride_v,
+               uint16_t* dst_y,
+               int dst_stride_y,
+               uint16_t* dst_u,
+               int dst_stride_u,
+               uint16_t* dst_v,
+               int dst_stride_v,
+               int width,
+               int height);
+
+#define I212ToI012 I210ToI010
+#define H210ToH010 I210ToI010
+#define H212ToH012 I210ToI010
+LIBYUV_API
+int I210ToI010(const uint16_t* src_y,
+               int src_stride_y,
+               const uint16_t* src_u,
+               int src_stride_u,
+               const uint16_t* src_v,
+               int src_stride_v,
+               uint16_t* dst_y,
+               int dst_stride_y,
+               uint16_t* dst_u,
+               int dst_stride_u,
+               uint16_t* dst_v,
+               int dst_stride_v,
+               int width,
+               int height);
+
+// Convert I010 to I410
+LIBYUV_API
+int I010ToI410(const uint16_t* src_y,
+               int src_stride_y,
+               const uint16_t* src_u,
+               int src_stride_u,
+               const uint16_t* src_v,
+               int src_stride_v,
+               uint16_t* dst_y,
+               int dst_stride_y,
+               uint16_t* dst_u,
+               int dst_stride_u,
+               uint16_t* dst_v,
+               int dst_stride_v,
+               int width,
+               int height);
+
+// Convert I012 to I412
+#define I012ToI412 I010ToI410
+
+// Convert I210 to I410
+LIBYUV_API
+int I210ToI410(const uint16_t* src_y,
+               int src_stride_y,
+               const uint16_t* src_u,
+               int src_stride_u,
+               const uint16_t* src_v,
+               int src_stride_v,
+               uint16_t* dst_y,
+               int dst_stride_y,
+               uint16_t* dst_u,
+               int dst_stride_u,
+               uint16_t* dst_v,
+               int dst_stride_v,
+               int width,
+               int height);
+
+// Convert I212 to I412
+#define I212ToI412 I210ToI410
+
+// Convert I010 to P010
+LIBYUV_API
+int I010ToP010(const uint16_t* src_y,
+               int src_stride_y,
+               const uint16_t* src_u,
+               int src_stride_u,
+               const uint16_t* src_v,
+               int src_stride_v,
+               uint16_t* dst_y,
+               int dst_stride_y,
+               uint16_t* dst_uv,
+               int dst_stride_uv,
+               int width,
+               int height);
+
+// Convert I210 to P210
+LIBYUV_API
+int I210ToP210(const uint16_t* src_y,
+               int src_stride_y,
+               const uint16_t* src_u,
+               int src_stride_u,
+               const uint16_t* src_v,
+               int src_stride_v,
+               uint16_t* dst_y,
+               int dst_stride_y,
+               uint16_t* dst_uv,
+               int dst_stride_uv,
+               int width,
+               int height);
+
+// Convert I012 to P012
+LIBYUV_API
+int I012ToP012(const uint16_t* src_y,
+               int src_stride_y,
+               const uint16_t* src_u,
+               int src_stride_u,
+               const uint16_t* src_v,
+               int src_stride_v,
+               uint16_t* dst_y,
+               int dst_stride_y,
+               uint16_t* dst_uv,
+               int dst_stride_uv,
+               int width,
+               int height);
+
+// Convert I212 to P212
+LIBYUV_API
+int I212ToP212(const uint16_t* src_y,
+               int src_stride_y,
+               const uint16_t* src_u,
+               int src_stride_u,
+               const uint16_t* src_v,
+               int src_stride_v,
+               uint16_t* dst_y,
+               int dst_stride_y,
+               uint16_t* dst_uv,
+               int dst_stride_uv,
+               int width,
+               int height);
+
+// Convert I400 (grey) to I420.
+LIBYUV_API
+int I400ToI420(const uint8_t* src_y,
+               int src_stride_y,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_u,
+               int dst_stride_u,
+               uint8_t* dst_v,
+               int dst_stride_v,
+               int width,
+               int height);
+
+// Convert I400 (grey) to NV21.
+LIBYUV_API
+int I400ToNV21(const uint8_t* src_y,
+               int src_stride_y,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_vu,
+               int dst_stride_vu,
+               int width,
+               int height);
+
+#define J400ToJ420 I400ToI420
+
+// Convert NV12 to I420.
+LIBYUV_API
+int NV12ToI420(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_uv,
+               int src_stride_uv,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_u,
+               int dst_stride_u,
+               uint8_t* dst_v,
+               int dst_stride_v,
+               int width,
+               int height);
+
+// Convert NV21 to I420.
+LIBYUV_API
+int NV21ToI420(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_vu,
+               int src_stride_vu,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_u,
+               int dst_stride_u,
+               uint8_t* dst_v,
+               int dst_stride_v,
+               int width,
+               int height);
+
+// Convert NV12 to NV24.
+LIBYUV_API
+int NV12ToNV24(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_uv,
+               int src_stride_uv,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_uv,
+               int dst_stride_uv,
+               int width,
+               int height);
+
+// Convert NV16 to NV24.
+LIBYUV_API
+int NV16ToNV24(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_uv,
+               int src_stride_uv,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_uv,
+               int dst_stride_uv,
+               int width,
+               int height);
+
+// Convert P010 to P410.
+LIBYUV_API
+int P010ToP410(const uint16_t* src_y,
+               int src_stride_y,
+               const uint16_t* src_uv,
+               int src_stride_uv,
+               uint16_t* dst_y,
+               int dst_stride_y,
+               uint16_t* dst_uv,
+               int dst_stride_uv,
+               int width,
+               int height);
+
+// Convert P012 to P412.
+#define P012ToP412 P010ToP410
+
+// Convert P016 to P416.
+#define P016ToP416 P010ToP410
+
+// Convert P210 to P410.
+LIBYUV_API
+int P210ToP410(const uint16_t* src_y,
+               int src_stride_y,
+               const uint16_t* src_uv,
+               int src_stride_uv,
+               uint16_t* dst_y,
+               int dst_stride_y,
+               uint16_t* dst_uv,
+               int dst_stride_uv,
+               int width,
+               int height);
+
+// Convert P212 to P412.
+#define P212ToP412 P210ToP410
+
+// Convert P216 to P416.
+#define P216ToP416 P210ToP410
+
+// Convert YUY2 to I420.
+LIBYUV_API
+int YUY2ToI420(const uint8_t* src_yuy2,
+               int src_stride_yuy2,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_u,
+               int dst_stride_u,
+               uint8_t* dst_v,
+               int dst_stride_v,
+               int width,
+               int height);
+
+// Convert UYVY to I420.
+LIBYUV_API
+int UYVYToI420(const uint8_t* src_uyvy,
+               int src_stride_uyvy,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_u,
+               int dst_stride_u,
+               uint8_t* dst_v,
+               int dst_stride_v,
+               int width,
+               int height);
+
+// Convert AYUV to NV12.
+LIBYUV_API
+int AYUVToNV12(const uint8_t* src_ayuv,
+               int src_stride_ayuv,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_uv,
+               int dst_stride_uv,
+               int width,
+               int height);
+
+// Convert AYUV to NV21.
+LIBYUV_API
+int AYUVToNV21(const uint8_t* src_ayuv,
+               int src_stride_ayuv,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_vu,
+               int dst_stride_vu,
+               int width,
+               int height);
+
+// Convert Android420 to I420.
+LIBYUV_API
+int Android420ToI420(const uint8_t* src_y,
+                     int src_stride_y,
+                     const uint8_t* src_u,
+                     int src_stride_u,
+                     const uint8_t* src_v,
+                     int src_stride_v,
+                     int src_pixel_stride_uv,
+                     uint8_t* dst_y,
+                     int dst_stride_y,
+                     uint8_t* dst_u,
+                     int dst_stride_u,
+                     uint8_t* dst_v,
+                     int dst_stride_v,
+                     int width,
+                     int height);
+
+// ARGB little endian (bgra in memory) to I420.
+LIBYUV_API
+int ARGBToI420(const uint8_t* src_argb,
+               int src_stride_argb,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_u,
+               int dst_stride_u,
+               uint8_t* dst_v,
+               int dst_stride_v,
+               int width,
+               int height);
+
+// BGRA little endian (argb in memory) to I420.
+LIBYUV_API
+int BGRAToI420(const uint8_t* src_bgra,
+               int src_stride_bgra,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_u,
+               int dst_stride_u,
+               uint8_t* dst_v,
+               int dst_stride_v,
+               int width,
+               int height);
+
+// ABGR little endian (rgba in memory) to I420.
+LIBYUV_API
+int ABGRToI420(const uint8_t* src_abgr,
+               int src_stride_abgr,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_u,
+               int dst_stride_u,
+               uint8_t* dst_v,
+               int dst_stride_v,
+               int width,
+               int height);
+
+// RGBA little endian (abgr in memory) to I420.
+LIBYUV_API
+int RGBAToI420(const uint8_t* src_rgba,
+               int src_stride_rgba,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_u,
+               int dst_stride_u,
+               uint8_t* dst_v,
+               int dst_stride_v,
+               int width,
+               int height);
+
+// RGB little endian (bgr in memory) to I420.
+LIBYUV_API
+int RGB24ToI420(const uint8_t* src_rgb24,
+                int src_stride_rgb24,
+                uint8_t* dst_y,
+                int dst_stride_y,
+                uint8_t* dst_u,
+                int dst_stride_u,
+                uint8_t* dst_v,
+                int dst_stride_v,
+                int width,
+                int height);
+
+// RGB little endian (bgr in memory) to J420.
+LIBYUV_API
+int RGB24ToJ420(const uint8_t* src_rgb24,
+                int src_stride_rgb24,
+                uint8_t* dst_y,
+                int dst_stride_y,
+                uint8_t* dst_u,
+                int dst_stride_u,
+                uint8_t* dst_v,
+                int dst_stride_v,
+                int width,
+                int height);
+
+// RGB big endian (rgb in memory) to I420.
+LIBYUV_API
+int RAWToI420(const uint8_t* src_raw,
+              int src_stride_raw,
+              uint8_t* dst_y,
+              int dst_stride_y,
+              uint8_t* dst_u,
+              int dst_stride_u,
+              uint8_t* dst_v,
+              int dst_stride_v,
+              int width,
+              int height);
+
+// RGB big endian (rgb in memory) to J420.
+LIBYUV_API
+int RAWToJ420(const uint8_t* src_raw,
+              int src_stride_raw,
+              uint8_t* dst_y,
+              int dst_stride_y,
+              uint8_t* dst_u,
+              int dst_stride_u,
+              uint8_t* dst_v,
+              int dst_stride_v,
+              int width,
+              int height);
+
+// RGB16 (RGBP fourcc) little endian to I420.
+LIBYUV_API
+int RGB565ToI420(const uint8_t* src_rgb565,
+                 int src_stride_rgb565,
+                 uint8_t* dst_y,
+                 int dst_stride_y,
+                 uint8_t* dst_u,
+                 int dst_stride_u,
+                 uint8_t* dst_v,
+                 int dst_stride_v,
+                 int width,
+                 int height);
+
+// RGB15 (RGBO fourcc) little endian to I420.
+LIBYUV_API
+int ARGB1555ToI420(const uint8_t* src_argb1555,
+                   int src_stride_argb1555,
+                   uint8_t* dst_y,
+                   int dst_stride_y,
+                   uint8_t* dst_u,
+                   int dst_stride_u,
+                   uint8_t* dst_v,
+                   int dst_stride_v,
+                   int width,
+                   int height);
+
+// RGB12 (R444 fourcc) little endian to I420.
+LIBYUV_API
+int ARGB4444ToI420(const uint8_t* src_argb4444,
+                   int src_stride_argb4444,
+                   uint8_t* dst_y,
+                   int dst_stride_y,
+                   uint8_t* dst_u,
+                   int dst_stride_u,
+                   uint8_t* dst_v,
+                   int dst_stride_v,
+                   int width,
+                   int height);
+
+// RGB little endian (bgr in memory) to J400.
+LIBYUV_API
+int RGB24ToJ400(const uint8_t* src_rgb24,
+                int src_stride_rgb24,
+                uint8_t* dst_yj,
+                int dst_stride_yj,
+                int width,
+                int height);
+
+// RGB big endian (rgb in memory) to J400.
+LIBYUV_API
+int RAWToJ400(const uint8_t* src_raw,
+              int src_stride_raw,
+              uint8_t* dst_yj,
+              int dst_stride_yj,
+              int width,
+              int height);
+
+// src_width/height provided by capture.
+// dst_width/height for clipping determine final size.
+LIBYUV_API
+int MJPGToI420(const uint8_t* sample,
+               size_t sample_size,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_u,
+               int dst_stride_u,
+               uint8_t* dst_v,
+               int dst_stride_v,
+               int src_width,
+               int src_height,
+               int dst_width,
+               int dst_height);
+
+// JPEG to NV21
+LIBYUV_API
+int MJPGToNV21(const uint8_t* sample,
+               size_t sample_size,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_vu,
+               int dst_stride_vu,
+               int src_width,
+               int src_height,
+               int dst_width,
+               int dst_height);
+
+// JPEG to NV12
+LIBYUV_API
+int MJPGToNV12(const uint8_t* sample,
+               size_t sample_size,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_uv,
+               int dst_stride_uv,
+               int src_width,
+               int src_height,
+               int dst_width,
+               int dst_height);
+
+// Query size of MJPG in pixels.
+LIBYUV_API
+int MJPGSize(const uint8_t* sample,
+             size_t sample_size,
+             int* width,
+             int* height);
+
+// Convert camera sample to I420 with cropping, rotation and vertical flip.
+// "src_size" is needed to parse MJPG.
+// "dst_stride_y" number of bytes in a row of the dst_y plane.
+//   Normally this would be the same as dst_width, with recommended alignment
+//   to 16 bytes for better efficiency.
+//   If rotation of 90 or 270 is used, stride is affected. The caller should
+//   allocate the I420 buffer according to rotation.
+// "dst_stride_u" number of bytes in a row of the dst_u plane.
+//   Normally this would be the same as (dst_width + 1) / 2, with
+//   recommended alignment to 16 bytes for better efficiency.
+//   If rotation of 90 or 270 is used, stride is affected.
+// "crop_x" and "crop_y" are starting position for cropping.
+//   To center, crop_x = (src_width - dst_width) / 2
+//              crop_y = (src_height - dst_height) / 2
+// "src_width" / "src_height" is size of src_frame in pixels.
+//   "src_height" can be negative indicating a vertically flipped image source.
+// "crop_width" / "crop_height" is the size to crop the src to.
+//    Must be less than or equal to src_width/src_height
+//    Cropping parameters are pre-rotation.
+// "rotation" can be 0, 90, 180 or 270.
+// "fourcc" is a fourcc. ie 'I420', 'YUY2'
+// Returns 0 for successful; -1 for invalid parameter. Non-zero for failure.
+LIBYUV_API
+int ConvertToI420(const uint8_t* sample,
+                  size_t sample_size,
+                  uint8_t* dst_y,
+                  int dst_stride_y,
+                  uint8_t* dst_u,
+                  int dst_stride_u,
+                  uint8_t* dst_v,
+                  int dst_stride_v,
+                  int crop_x,
+                  int crop_y,
+                  int src_width,
+                  int src_height,
+                  int crop_width,
+                  int crop_height,
+                  enum RotationMode rotation,
+                  uint32_t fourcc);
+
+#ifdef __cplusplus
+}  // extern "C"
+}  // namespace libyuv
+#endif
+
+#endif  // INCLUDE_LIBYUV_CONVERT_H_
diff --git a/3rdparty/libyuv/src/include/libyuv/convert_argb.h b/3rdparty/libyuv/src/include/libyuv/convert_argb.h
new file mode 100644
index 00000000..f66d20ce
--- /dev/null
+++ b/3rdparty/libyuv/src/include/libyuv/convert_argb.h
@@ -0,0 +1,2189 @@
+/*
+ *  Copyright 2012 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#ifndef INCLUDE_LIBYUV_CONVERT_ARGB_H_
+#define INCLUDE_LIBYUV_CONVERT_ARGB_H_
+
+#include "libyuv/basic_types.h"
+
+#include "libyuv/rotate.h"  // For enum RotationMode.
+#include "libyuv/scale.h"   // For enum FilterMode.
+
+#ifdef __cplusplus
+namespace libyuv {
+extern "C" {
+#endif
+
+// Conversion matrix for YUV to RGB
+LIBYUV_API extern const struct YuvConstants kYuvI601Constants;   // BT.601
+LIBYUV_API extern const struct YuvConstants kYuvJPEGConstants;   // BT.601 full
+LIBYUV_API extern const struct YuvConstants kYuvH709Constants;   // BT.709
+LIBYUV_API extern const struct YuvConstants kYuvF709Constants;   // BT.709 full
+LIBYUV_API extern const struct YuvConstants kYuv2020Constants;   // BT.2020
+LIBYUV_API extern const struct YuvConstants kYuvV2020Constants;  // BT.2020 full
+
+// Conversion matrix for YVU to BGR
+LIBYUV_API extern const struct YuvConstants kYvuI601Constants;   // BT.601
+LIBYUV_API extern const struct YuvConstants kYvuJPEGConstants;   // BT.601 full
+LIBYUV_API extern const struct YuvConstants kYvuH709Constants;   // BT.709
+LIBYUV_API extern const struct YuvConstants kYvuF709Constants;   // BT.709 full
+LIBYUV_API extern const struct YuvConstants kYvu2020Constants;   // BT.2020
+LIBYUV_API extern const struct YuvConstants kYvuV2020Constants;  // BT.2020 full
+
+// Macros for end swapped destination Matrix conversions.
+// Swap UV and pass mirrored kYvuJPEGConstants matrix.
+// TODO(fbarchard): Add macro for each Matrix function.
+#define kYuvI601ConstantsVU kYvuI601Constants
+#define kYuvJPEGConstantsVU kYvuJPEGConstants
+#define kYuvH709ConstantsVU kYvuH709Constants
+#define kYuvF709ConstantsVU kYvuF709Constants
+#define kYuv2020ConstantsVU kYvu2020Constants
+#define kYuvV2020ConstantsVU kYvuV2020Constants
+
+#define NV12ToABGRMatrix(a, b, c, d, e, f, g, h, i) \
+  NV21ToARGBMatrix(a, b, c, d, e, f, g##VU, h, i)
+#define NV21ToABGRMatrix(a, b, c, d, e, f, g, h, i) \
+  NV12ToARGBMatrix(a, b, c, d, e, f, g##VU, h, i)
+#define NV12ToRAWMatrix(a, b, c, d, e, f, g, h, i) \
+  NV21ToRGB24Matrix(a, b, c, d, e, f, g##VU, h, i)
+#define NV21ToRAWMatrix(a, b, c, d, e, f, g, h, i) \
+  NV12ToRGB24Matrix(a, b, c, d, e, f, g##VU, h, i)
+#define I010ToABGRMatrix(a, b, c, d, e, f, g, h, i, j, k) \
+  I010ToARGBMatrix(a, b, e, f, c, d, g, h, i##VU, j, k)
+#define I210ToABGRMatrix(a, b, c, d, e, f, g, h, i, j, k) \
+  I210ToARGBMatrix(a, b, e, f, c, d, g, h, i##VU, j, k)
+#define I410ToABGRMatrix(a, b, c, d, e, f, g, h, i, j, k) \
+  I410ToARGBMatrix(a, b, e, f, c, d, g, h, i##VU, j, k)
+#define I010ToAB30Matrix(a, b, c, d, e, f, g, h, i, j, k) \
+  I010ToAR30Matrix(a, b, e, f, c, d, g, h, i##VU, j, k)
+#define I210ToAB30Matrix(a, b, c, d, e, f, g, h, i, j, k) \
+  I210ToAR30Matrix(a, b, e, f, c, d, g, h, i##VU, j, k)
+#define I410ToAB30Matrix(a, b, c, d, e, f, g, h, i, j, k) \
+  I410ToAR30Matrix(a, b, e, f, c, d, g, h, i##VU, j, k)
+#define I420AlphaToABGRMatrix(a, b, c, d, e, f, g, h, i, j, k, l, m, n) \
+  I420AlphaToARGBMatrix(a, b, e, f, c, d, g, h, i, j, k##VU, l, m, n)
+#define I422AlphaToABGRMatrix(a, b, c, d, e, f, g, h, i, j, k, l, m, n) \
+  I422AlphaToARGBMatrix(a, b, e, f, c, d, g, h, i, j, k##VU, l, m, n)
+#define I444AlphaToABGRMatrix(a, b, c, d, e, f, g, h, i, j, k, l, m, n) \
+  I444AlphaToARGBMatrix(a, b, e, f, c, d, g, h, i, j, k##VU, l, m, n)
+#define I010AlphaToABGRMatrix(a, b, c, d, e, f, g, h, i, j, k, l, m, n) \
+  I010AlphaToARGBMatrix(a, b, e, f, c, d, g, h, i, j, k##VU, l, m, n)
+#define I210AlphaToABGRMatrix(a, b, c, d, e, f, g, h, i, j, k, l, m, n) \
+  I210AlphaToARGBMatrix(a, b, e, f, c, d, g, h, i, j, k##VU, l, m, n)
+#define I410AlphaToABGRMatrix(a, b, c, d, e, f, g, h, i, j, k, l, m, n) \
+  I410AlphaToARGBMatrix(a, b, e, f, c, d, g, h, i, j, k##VU, l, m, n)
+
+// Alias.
+#define ARGBToARGB ARGBCopy
+
+// Copy ARGB to ARGB.
+LIBYUV_API
+int ARGBCopy(const uint8_t* src_argb,
+             int src_stride_argb,
+             uint8_t* dst_argb,
+             int dst_stride_argb,
+             int width,
+             int height);
+
+// Convert I420 to ARGB.
+LIBYUV_API
+int I420ToARGB(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_argb,
+               int dst_stride_argb,
+               int width,
+               int height);
+
+// Convert I420 to ABGR.
+LIBYUV_API
+int I420ToABGR(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_abgr,
+               int dst_stride_abgr,
+               int width,
+               int height);
+
+// Convert J420 to ARGB.
+LIBYUV_API
+int J420ToARGB(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_argb,
+               int dst_stride_argb,
+               int width,
+               int height);
+
+// Convert J420 to ABGR.
+LIBYUV_API
+int J420ToABGR(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_abgr,
+               int dst_stride_abgr,
+               int width,
+               int height);
+
+// Convert H420 to ARGB.
+LIBYUV_API
+int H420ToARGB(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_argb,
+               int dst_stride_argb,
+               int width,
+               int height);
+
+// Convert H420 to ABGR.
+LIBYUV_API
+int H420ToABGR(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_abgr,
+               int dst_stride_abgr,
+               int width,
+               int height);
+
+// Convert U420 to ARGB.
+LIBYUV_API
+int U420ToARGB(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_argb,
+               int dst_stride_argb,
+               int width,
+               int height);
+
+// Convert U420 to ABGR.
+LIBYUV_API
+int U420ToABGR(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_abgr,
+               int dst_stride_abgr,
+               int width,
+               int height);
+
+// Convert I422 to ARGB.
+LIBYUV_API
+int I422ToARGB(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_argb,
+               int dst_stride_argb,
+               int width,
+               int height);
+
+// Convert I422 to ABGR.
+LIBYUV_API
+int I422ToABGR(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_abgr,
+               int dst_stride_abgr,
+               int width,
+               int height);
+
+// Convert J422 to ARGB.
+LIBYUV_API
+int J422ToARGB(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_argb,
+               int dst_stride_argb,
+               int width,
+               int height);
+
+// Convert J422 to ABGR.
+LIBYUV_API
+int J422ToABGR(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_abgr,
+               int dst_stride_abgr,
+               int width,
+               int height);
+
+// Convert H422 to ARGB.
+LIBYUV_API
+int H422ToARGB(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_argb,
+               int dst_stride_argb,
+               int width,
+               int height);
+
+// Convert H422 to ABGR.
+LIBYUV_API
+int H422ToABGR(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_abgr,
+               int dst_stride_abgr,
+               int width,
+               int height);
+
+// Convert U422 to ARGB.
+LIBYUV_API
+int U422ToARGB(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_argb,
+               int dst_stride_argb,
+               int width,
+               int height);
+
+// Convert U422 to ABGR.
+LIBYUV_API
+int U422ToABGR(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_abgr,
+               int dst_stride_abgr,
+               int width,
+               int height);
+
+// Convert I444 to ARGB.
+LIBYUV_API
+int I444ToARGB(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_argb,
+               int dst_stride_argb,
+               int width,
+               int height);
+
+// Convert I444 to ABGR.
+LIBYUV_API
+int I444ToABGR(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_abgr,
+               int dst_stride_abgr,
+               int width,
+               int height);
+
+// Convert J444 to ARGB.
+LIBYUV_API
+int J444ToARGB(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_argb,
+               int dst_stride_argb,
+               int width,
+               int height);
+
+// Convert J444 to ABGR.
+LIBYUV_API
+int J444ToABGR(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_abgr,
+               int dst_stride_abgr,
+               int width,
+               int height);
+
+// Convert H444 to ARGB.
+LIBYUV_API
+int H444ToARGB(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_argb,
+               int dst_stride_argb,
+               int width,
+               int height);
+
+// Convert H444 to ABGR.
+LIBYUV_API
+int H444ToABGR(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_abgr,
+               int dst_stride_abgr,
+               int width,
+               int height);
+
+// Convert U444 to ARGB.
+LIBYUV_API
+int U444ToARGB(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_argb,
+               int dst_stride_argb,
+               int width,
+               int height);
+
+// Convert U444 to ABGR.
+LIBYUV_API
+int U444ToABGR(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_abgr,
+               int dst_stride_abgr,
+               int width,
+               int height);
+
+// Convert I010 to ARGB.
+LIBYUV_API
+int I010ToARGB(const uint16_t* src_y,
+               int src_stride_y,
+               const uint16_t* src_u,
+               int src_stride_u,
+               const uint16_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_argb,
+               int dst_stride_argb,
+               int width,
+               int height);
+
+// Convert I010 to ABGR.
+LIBYUV_API
+int I010ToABGR(const uint16_t* src_y,
+               int src_stride_y,
+               const uint16_t* src_u,
+               int src_stride_u,
+               const uint16_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_abgr,
+               int dst_stride_abgr,
+               int width,
+               int height);
+
+// Convert H010 to ARGB.
+LIBYUV_API
+int H010ToARGB(const uint16_t* src_y,
+               int src_stride_y,
+               const uint16_t* src_u,
+               int src_stride_u,
+               const uint16_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_argb,
+               int dst_stride_argb,
+               int width,
+               int height);
+
+// Convert H010 to ABGR.
+LIBYUV_API
+int H010ToABGR(const uint16_t* src_y,
+               int src_stride_y,
+               const uint16_t* src_u,
+               int src_stride_u,
+               const uint16_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_abgr,
+               int dst_stride_abgr,
+               int width,
+               int height);
+
+// Convert U010 to ARGB.
+LIBYUV_API
+int U010ToARGB(const uint16_t* src_y,
+               int src_stride_y,
+               const uint16_t* src_u,
+               int src_stride_u,
+               const uint16_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_argb,
+               int dst_stride_argb,
+               int width,
+               int height);
+
+// Convert U010 to ABGR.
+LIBYUV_API
+int U010ToABGR(const uint16_t* src_y,
+               int src_stride_y,
+               const uint16_t* src_u,
+               int src_stride_u,
+               const uint16_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_abgr,
+               int dst_stride_abgr,
+               int width,
+               int height);
+
+// Convert I210 to ARGB.
+LIBYUV_API
+int I210ToARGB(const uint16_t* src_y,
+               int src_stride_y,
+               const uint16_t* src_u,
+               int src_stride_u,
+               const uint16_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_argb,
+               int dst_stride_argb,
+               int width,
+               int height);
+
+// Convert I210 to ABGR.
+LIBYUV_API
+int I210ToABGR(const uint16_t* src_y,
+               int src_stride_y,
+               const uint16_t* src_u,
+               int src_stride_u,
+               const uint16_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_abgr,
+               int dst_stride_abgr,
+               int width,
+               int height);
+
+// Convert H210 to ARGB.
+LIBYUV_API
+int H210ToARGB(const uint16_t* src_y,
+               int src_stride_y,
+               const uint16_t* src_u,
+               int src_stride_u,
+               const uint16_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_argb,
+               int dst_stride_argb,
+               int width,
+               int height);
+
+// Convert H210 to ABGR.
+LIBYUV_API
+int H210ToABGR(const uint16_t* src_y,
+               int src_stride_y,
+               const uint16_t* src_u,
+               int src_stride_u,
+               const uint16_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_abgr,
+               int dst_stride_abgr,
+               int width,
+               int height);
+
+// Convert U210 to ARGB.
+LIBYUV_API
+int U210ToARGB(const uint16_t* src_y,
+               int src_stride_y,
+               const uint16_t* src_u,
+               int src_stride_u,
+               const uint16_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_argb,
+               int dst_stride_argb,
+               int width,
+               int height);
+
+// Convert U210 to ABGR.
+LIBYUV_API
+int U210ToABGR(const uint16_t* src_y,
+               int src_stride_y,
+               const uint16_t* src_u,
+               int src_stride_u,
+               const uint16_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_abgr,
+               int dst_stride_abgr,
+               int width,
+               int height);
+
+// Convert I420 with Alpha to preattenuated ARGB.
+LIBYUV_API
+int I420AlphaToARGB(const uint8_t* src_y,
+                    int src_stride_y,
+                    const uint8_t* src_u,
+                    int src_stride_u,
+                    const uint8_t* src_v,
+                    int src_stride_v,
+                    const uint8_t* src_a,
+                    int src_stride_a,
+                    uint8_t* dst_argb,
+                    int dst_stride_argb,
+                    int width,
+                    int height,
+                    int attenuate);
+
+// Convert I420 with Alpha to preattenuated ABGR.
+LIBYUV_API
+int I420AlphaToABGR(const uint8_t* src_y,
+                    int src_stride_y,
+                    const uint8_t* src_u,
+                    int src_stride_u,
+                    const uint8_t* src_v,
+                    int src_stride_v,
+                    const uint8_t* src_a,
+                    int src_stride_a,
+                    uint8_t* dst_abgr,
+                    int dst_stride_abgr,
+                    int width,
+                    int height,
+                    int attenuate);
+
+// Convert I422 with Alpha to preattenuated ARGB.
+LIBYUV_API
+int I422AlphaToARGB(const uint8_t* src_y,
+                    int src_stride_y,
+                    const uint8_t* src_u,
+                    int src_stride_u,
+                    const uint8_t* src_v,
+                    int src_stride_v,
+                    const uint8_t* src_a,
+                    int src_stride_a,
+                    uint8_t* dst_argb,
+                    int dst_stride_argb,
+                    int width,
+                    int height,
+                    int attenuate);
+
+// Convert I422 with Alpha to preattenuated ABGR.
+LIBYUV_API
+int I422AlphaToABGR(const uint8_t* src_y,
+                    int src_stride_y,
+                    const uint8_t* src_u,
+                    int src_stride_u,
+                    const uint8_t* src_v,
+                    int src_stride_v,
+                    const uint8_t* src_a,
+                    int src_stride_a,
+                    uint8_t* dst_abgr,
+                    int dst_stride_abgr,
+                    int width,
+                    int height,
+                    int attenuate);
+
+// Convert I444 with Alpha to preattenuated ARGB.
+LIBYUV_API
+int I444AlphaToARGB(const uint8_t* src_y,
+                    int src_stride_y,
+                    const uint8_t* src_u,
+                    int src_stride_u,
+                    const uint8_t* src_v,
+                    int src_stride_v,
+                    const uint8_t* src_a,
+                    int src_stride_a,
+                    uint8_t* dst_argb,
+                    int dst_stride_argb,
+                    int width,
+                    int height,
+                    int attenuate);
+
+// Convert I444 with Alpha to preattenuated ABGR.
+LIBYUV_API
+int I444AlphaToABGR(const uint8_t* src_y,
+                    int src_stride_y,
+                    const uint8_t* src_u,
+                    int src_stride_u,
+                    const uint8_t* src_v,
+                    int src_stride_v,
+                    const uint8_t* src_a,
+                    int src_stride_a,
+                    uint8_t* dst_abgr,
+                    int dst_stride_abgr,
+                    int width,
+                    int height,
+                    int attenuate);
+
+// Convert I400 (grey) to ARGB.  Reverse of ARGBToI400.
+LIBYUV_API
+int I400ToARGB(const uint8_t* src_y,
+               int src_stride_y,
+               uint8_t* dst_argb,
+               int dst_stride_argb,
+               int width,
+               int height);
+
+// Convert J400 (jpeg grey) to ARGB.
+LIBYUV_API
+int J400ToARGB(const uint8_t* src_y,
+               int src_stride_y,
+               uint8_t* dst_argb,
+               int dst_stride_argb,
+               int width,
+               int height);
+
+// Alias.
+#define YToARGB I400ToARGB
+
+// Convert NV12 to ARGB.
+LIBYUV_API
+int NV12ToARGB(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_uv,
+               int src_stride_uv,
+               uint8_t* dst_argb,
+               int dst_stride_argb,
+               int width,
+               int height);
+
+// Convert NV21 to ARGB.
+LIBYUV_API
+int NV21ToARGB(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_vu,
+               int src_stride_vu,
+               uint8_t* dst_argb,
+               int dst_stride_argb,
+               int width,
+               int height);
+
+// Convert NV12 to ABGR.
+LIBYUV_API
+int NV12ToABGR(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_uv,
+               int src_stride_uv,
+               uint8_t* dst_abgr,
+               int dst_stride_abgr,
+               int width,
+               int height);
+
+// Convert NV21 to ABGR.
+LIBYUV_API
+int NV21ToABGR(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_vu,
+               int src_stride_vu,
+               uint8_t* dst_abgr,
+               int dst_stride_abgr,
+               int width,
+               int height);
+
+// Convert NV12 to RGB24.
+LIBYUV_API
+int NV12ToRGB24(const uint8_t* src_y,
+                int src_stride_y,
+                const uint8_t* src_uv,
+                int src_stride_uv,
+                uint8_t* dst_rgb24,
+                int dst_stride_rgb24,
+                int width,
+                int height);
+
+// Convert NV21 to RGB24.
+LIBYUV_API
+int NV21ToRGB24(const uint8_t* src_y,
+                int src_stride_y,
+                const uint8_t* src_vu,
+                int src_stride_vu,
+                uint8_t* dst_rgb24,
+                int dst_stride_rgb24,
+                int width,
+                int height);
+
+// Convert NV21 to YUV24.
+LIBYUV_API
+int NV21ToYUV24(const uint8_t* src_y,
+                int src_stride_y,
+                const uint8_t* src_vu,
+                int src_stride_vu,
+                uint8_t* dst_yuv24,
+                int dst_stride_yuv24,
+                int width,
+                int height);
+
+// Convert NV12 to RAW.
+LIBYUV_API
+int NV12ToRAW(const uint8_t* src_y,
+              int src_stride_y,
+              const uint8_t* src_uv,
+              int src_stride_uv,
+              uint8_t* dst_raw,
+              int dst_stride_raw,
+              int width,
+              int height);
+
+// Convert NV21 to RAW.
+LIBYUV_API
+int NV21ToRAW(const uint8_t* src_y,
+              int src_stride_y,
+              const uint8_t* src_vu,
+              int src_stride_vu,
+              uint8_t* dst_raw,
+              int dst_stride_raw,
+              int width,
+              int height);
+
+// Convert YUY2 to ARGB.
+LIBYUV_API
+int YUY2ToARGB(const uint8_t* src_yuy2,
+               int src_stride_yuy2,
+               uint8_t* dst_argb,
+               int dst_stride_argb,
+               int width,
+               int height);
+
+// Convert UYVY to ARGB.
+LIBYUV_API
+int UYVYToARGB(const uint8_t* src_uyvy,
+               int src_stride_uyvy,
+               uint8_t* dst_argb,
+               int dst_stride_argb,
+               int width,
+               int height);
+
+// Convert I010 to AR30.
+LIBYUV_API
+int I010ToAR30(const uint16_t* src_y,
+               int src_stride_y,
+               const uint16_t* src_u,
+               int src_stride_u,
+               const uint16_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_ar30,
+               int dst_stride_ar30,
+               int width,
+               int height);
+
+// Convert H010 to AR30.
+LIBYUV_API
+int H010ToAR30(const uint16_t* src_y,
+               int src_stride_y,
+               const uint16_t* src_u,
+               int src_stride_u,
+               const uint16_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_ar30,
+               int dst_stride_ar30,
+               int width,
+               int height);
+
+// Convert I010 to AB30.
+LIBYUV_API
+int I010ToAB30(const uint16_t* src_y,
+               int src_stride_y,
+               const uint16_t* src_u,
+               int src_stride_u,
+               const uint16_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_ab30,
+               int dst_stride_ab30,
+               int width,
+               int height);
+
+// Convert H010 to AB30.
+LIBYUV_API
+int H010ToAB30(const uint16_t* src_y,
+               int src_stride_y,
+               const uint16_t* src_u,
+               int src_stride_u,
+               const uint16_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_ab30,
+               int dst_stride_ab30,
+               int width,
+               int height);
+
+// Convert U010 to AR30.
+LIBYUV_API
+int U010ToAR30(const uint16_t* src_y,
+               int src_stride_y,
+               const uint16_t* src_u,
+               int src_stride_u,
+               const uint16_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_ar30,
+               int dst_stride_ar30,
+               int width,
+               int height);
+
+// Convert U010 to AB30.
+LIBYUV_API
+int U010ToAB30(const uint16_t* src_y,
+               int src_stride_y,
+               const uint16_t* src_u,
+               int src_stride_u,
+               const uint16_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_ab30,
+               int dst_stride_ab30,
+               int width,
+               int height);
+
+// Convert I210 to AR30.
+LIBYUV_API
+int I210ToAR30(const uint16_t* src_y,
+               int src_stride_y,
+               const uint16_t* src_u,
+               int src_stride_u,
+               const uint16_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_ar30,
+               int dst_stride_ar30,
+               int width,
+               int height);
+
+// Convert I210 to AB30.
+LIBYUV_API
+int I210ToAB30(const uint16_t* src_y,
+               int src_stride_y,
+               const uint16_t* src_u,
+               int src_stride_u,
+               const uint16_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_ab30,
+               int dst_stride_ab30,
+               int width,
+               int height);
+
+// Convert H210 to AR30.
+LIBYUV_API
+int H210ToAR30(const uint16_t* src_y,
+               int src_stride_y,
+               const uint16_t* src_u,
+               int src_stride_u,
+               const uint16_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_ar30,
+               int dst_stride_ar30,
+               int width,
+               int height);
+
+// Convert H210 to AB30.
+LIBYUV_API
+int H210ToAB30(const uint16_t* src_y,
+               int src_stride_y,
+               const uint16_t* src_u,
+               int src_stride_u,
+               const uint16_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_ab30,
+               int dst_stride_ab30,
+               int width,
+               int height);
+
+// Convert U210 to AR30.
+LIBYUV_API
+int U210ToAR30(const uint16_t* src_y,
+               int src_stride_y,
+               const uint16_t* src_u,
+               int src_stride_u,
+               const uint16_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_ar30,
+               int dst_stride_ar30,
+               int width,
+               int height);
+
+// Convert U210 to AB30.
+LIBYUV_API
+int U210ToAB30(const uint16_t* src_y,
+               int src_stride_y,
+               const uint16_t* src_u,
+               int src_stride_u,
+               const uint16_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_ab30,
+               int dst_stride_ab30,
+               int width,
+               int height);
+
+// BGRA little endian (argb in memory) to ARGB.
+LIBYUV_API
+int BGRAToARGB(const uint8_t* src_bgra,
+               int src_stride_bgra,
+               uint8_t* dst_argb,
+               int dst_stride_argb,
+               int width,
+               int height);
+
+// ABGR little endian (rgba in memory) to ARGB.
+LIBYUV_API
+int ABGRToARGB(const uint8_t* src_abgr,
+               int src_stride_abgr,
+               uint8_t* dst_argb,
+               int dst_stride_argb,
+               int width,
+               int height);
+
+// RGBA little endian (abgr in memory) to ARGB.
+LIBYUV_API
+int RGBAToARGB(const uint8_t* src_rgba,
+               int src_stride_rgba,
+               uint8_t* dst_argb,
+               int dst_stride_argb,
+               int width,
+               int height);
+
+// Deprecated function name.
+#define BG24ToARGB RGB24ToARGB
+
+// RGB little endian (bgr in memory) to ARGB.
+LIBYUV_API
+int RGB24ToARGB(const uint8_t* src_rgb24,
+                int src_stride_rgb24,
+                uint8_t* dst_argb,
+                int dst_stride_argb,
+                int width,
+                int height);
+
+// RGB big endian (rgb in memory) to ARGB.
+LIBYUV_API
+int RAWToARGB(const uint8_t* src_raw,
+              int src_stride_raw,
+              uint8_t* dst_argb,
+              int dst_stride_argb,
+              int width,
+              int height);
+
+// RGB big endian (rgb in memory) to RGBA.
+LIBYUV_API
+int RAWToRGBA(const uint8_t* src_raw,
+              int src_stride_raw,
+              uint8_t* dst_rgba,
+              int dst_stride_rgba,
+              int width,
+              int height);
+
+// RGB16 (RGBP fourcc) little endian to ARGB.
+LIBYUV_API
+int RGB565ToARGB(const uint8_t* src_rgb565,
+                 int src_stride_rgb565,
+                 uint8_t* dst_argb,
+                 int dst_stride_argb,
+                 int width,
+                 int height);
+
+// RGB15 (RGBO fourcc) little endian to ARGB.
+LIBYUV_API
+int ARGB1555ToARGB(const uint8_t* src_argb1555,
+                   int src_stride_argb1555,
+                   uint8_t* dst_argb,
+                   int dst_stride_argb,
+                   int width,
+                   int height);
+
+// RGB12 (R444 fourcc) little endian to ARGB.
+LIBYUV_API
+int ARGB4444ToARGB(const uint8_t* src_argb4444,
+                   int src_stride_argb4444,
+                   uint8_t* dst_argb,
+                   int dst_stride_argb,
+                   int width,
+                   int height);
+
+// Aliases
+#define AB30ToARGB AR30ToABGR
+#define AB30ToABGR AR30ToARGB
+#define AB30ToAR30 AR30ToAB30
+
+// Convert AR30 To ARGB.
+LIBYUV_API
+int AR30ToARGB(const uint8_t* src_ar30,
+               int src_stride_ar30,
+               uint8_t* dst_argb,
+               int dst_stride_argb,
+               int width,
+               int height);
+
+// Convert AR30 To ABGR.
+LIBYUV_API
+int AR30ToABGR(const uint8_t* src_ar30,
+               int src_stride_ar30,
+               uint8_t* dst_abgr,
+               int dst_stride_abgr,
+               int width,
+               int height);
+
+// Convert AR30 To AB30.
+LIBYUV_API
+int AR30ToAB30(const uint8_t* src_ar30,
+               int src_stride_ar30,
+               uint8_t* dst_ab30,
+               int dst_stride_ab30,
+               int width,
+               int height);
+
+// Convert AR64 to ARGB.
+LIBYUV_API
+int AR64ToARGB(const uint16_t* src_ar64,
+               int src_stride_ar64,
+               uint8_t* dst_argb,
+               int dst_stride_argb,
+               int width,
+               int height);
+
+// Convert AB64 to ABGR.
+#define AB64ToABGR AR64ToARGB
+
+// Convert AB64 to ARGB.
+LIBYUV_API
+int AB64ToARGB(const uint16_t* src_ab64,
+               int src_stride_ab64,
+               uint8_t* dst_argb,
+               int dst_stride_argb,
+               int width,
+               int height);
+
+// Convert AR64 to ABGR.
+#define AR64ToABGR AB64ToARGB
+
+// Convert AR64 To AB64.
+LIBYUV_API
+int AR64ToAB64(const uint16_t* src_ar64,
+               int src_stride_ar64,
+               uint16_t* dst_ab64,
+               int dst_stride_ab64,
+               int width,
+               int height);
+
+// Convert AB64 To AR64.
+#define AB64ToAR64 AR64ToAB64
+
+// src_width/height provided by capture
+// dst_width/height for clipping determine final size.
+LIBYUV_API
+int MJPGToARGB(const uint8_t* sample,
+               size_t sample_size,
+               uint8_t* dst_argb,
+               int dst_stride_argb,
+               int src_width,
+               int src_height,
+               int dst_width,
+               int dst_height);
+
+// Convert Android420 to ARGB.
+LIBYUV_API
+int Android420ToARGB(const uint8_t* src_y,
+                     int src_stride_y,
+                     const uint8_t* src_u,
+                     int src_stride_u,
+                     const uint8_t* src_v,
+                     int src_stride_v,
+                     int src_pixel_stride_uv,
+                     uint8_t* dst_argb,
+                     int dst_stride_argb,
+                     int width,
+                     int height);
+
+// Convert Android420 to ABGR.
+LIBYUV_API
+int Android420ToABGR(const uint8_t* src_y,
+                     int src_stride_y,
+                     const uint8_t* src_u,
+                     int src_stride_u,
+                     const uint8_t* src_v,
+                     int src_stride_v,
+                     int src_pixel_stride_uv,
+                     uint8_t* dst_abgr,
+                     int dst_stride_abgr,
+                     int width,
+                     int height);
+
+// Convert NV12 to RGB565.
+LIBYUV_API
+int NV12ToRGB565(const uint8_t* src_y,
+                 int src_stride_y,
+                 const uint8_t* src_uv,
+                 int src_stride_uv,
+                 uint8_t* dst_rgb565,
+                 int dst_stride_rgb565,
+                 int width,
+                 int height);
+
+// Convert I422 to BGRA.
+LIBYUV_API
+int I422ToBGRA(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_bgra,
+               int dst_stride_bgra,
+               int width,
+               int height);
+
+// Convert I422 to ABGR.
+LIBYUV_API
+int I422ToABGR(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_abgr,
+               int dst_stride_abgr,
+               int width,
+               int height);
+
+// Convert I422 to RGBA.
+LIBYUV_API
+int I422ToRGBA(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_rgba,
+               int dst_stride_rgba,
+               int width,
+               int height);
+
+LIBYUV_API
+int I420ToARGB(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_argb,
+               int dst_stride_argb,
+               int width,
+               int height);
+
+LIBYUV_API
+int I420ToBGRA(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_bgra,
+               int dst_stride_bgra,
+               int width,
+               int height);
+
+LIBYUV_API
+int I420ToABGR(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_abgr,
+               int dst_stride_abgr,
+               int width,
+               int height);
+
+LIBYUV_API
+int I420ToRGBA(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_rgba,
+               int dst_stride_rgba,
+               int width,
+               int height);
+
+LIBYUV_API
+int I420ToRGB24(const uint8_t* src_y,
+                int src_stride_y,
+                const uint8_t* src_u,
+                int src_stride_u,
+                const uint8_t* src_v,
+                int src_stride_v,
+                uint8_t* dst_rgb24,
+                int dst_stride_rgb24,
+                int width,
+                int height);
+
+LIBYUV_API
+int I420ToRAW(const uint8_t* src_y,
+              int src_stride_y,
+              const uint8_t* src_u,
+              int src_stride_u,
+              const uint8_t* src_v,
+              int src_stride_v,
+              uint8_t* dst_raw,
+              int dst_stride_raw,
+              int width,
+              int height);
+
+LIBYUV_API
+int H420ToRGB24(const uint8_t* src_y,
+                int src_stride_y,
+                const uint8_t* src_u,
+                int src_stride_u,
+                const uint8_t* src_v,
+                int src_stride_v,
+                uint8_t* dst_rgb24,
+                int dst_stride_rgb24,
+                int width,
+                int height);
+
+LIBYUV_API
+int H420ToRAW(const uint8_t* src_y,
+              int src_stride_y,
+              const uint8_t* src_u,
+              int src_stride_u,
+              const uint8_t* src_v,
+              int src_stride_v,
+              uint8_t* dst_raw,
+              int dst_stride_raw,
+              int width,
+              int height);
+
+LIBYUV_API
+int J420ToRGB24(const uint8_t* src_y,
+                int src_stride_y,
+                const uint8_t* src_u,
+                int src_stride_u,
+                const uint8_t* src_v,
+                int src_stride_v,
+                uint8_t* dst_rgb24,
+                int dst_stride_rgb24,
+                int width,
+                int height);
+
+LIBYUV_API
+int J420ToRAW(const uint8_t* src_y,
+              int src_stride_y,
+              const uint8_t* src_u,
+              int src_stride_u,
+              const uint8_t* src_v,
+              int src_stride_v,
+              uint8_t* dst_raw,
+              int dst_stride_raw,
+              int width,
+              int height);
+
+LIBYUV_API
+int I420ToRGB565(const uint8_t* src_y,
+                 int src_stride_y,
+                 const uint8_t* src_u,
+                 int src_stride_u,
+                 const uint8_t* src_v,
+                 int src_stride_v,
+                 uint8_t* dst_rgb565,
+                 int dst_stride_rgb565,
+                 int width,
+                 int height);
+
+LIBYUV_API
+int J420ToRGB565(const uint8_t* src_y,
+                 int src_stride_y,
+                 const uint8_t* src_u,
+                 int src_stride_u,
+                 const uint8_t* src_v,
+                 int src_stride_v,
+                 uint8_t* dst_rgb565,
+                 int dst_stride_rgb565,
+                 int width,
+                 int height);
+
+LIBYUV_API
+int H420ToRGB565(const uint8_t* src_y,
+                 int src_stride_y,
+                 const uint8_t* src_u,
+                 int src_stride_u,
+                 const uint8_t* src_v,
+                 int src_stride_v,
+                 uint8_t* dst_rgb565,
+                 int dst_stride_rgb565,
+                 int width,
+                 int height);
+
+LIBYUV_API
+int I422ToRGB565(const uint8_t* src_y,
+                 int src_stride_y,
+                 const uint8_t* src_u,
+                 int src_stride_u,
+                 const uint8_t* src_v,
+                 int src_stride_v,
+                 uint8_t* dst_rgb565,
+                 int dst_stride_rgb565,
+                 int width,
+                 int height);
+
+// Convert I420 To RGB565 with 4x4 dither matrix (16 bytes).
+// Values in dither matrix from 0 to 7 recommended.
+// The order of the dither matrix is first byte is upper left.
+
+LIBYUV_API
+int I420ToRGB565Dither(const uint8_t* src_y,
+                       int src_stride_y,
+                       const uint8_t* src_u,
+                       int src_stride_u,
+                       const uint8_t* src_v,
+                       int src_stride_v,
+                       uint8_t* dst_rgb565,
+                       int dst_stride_rgb565,
+                       const uint8_t* dither4x4,
+                       int width,
+                       int height);
+
+LIBYUV_API
+int I420ToARGB1555(const uint8_t* src_y,
+                   int src_stride_y,
+                   const uint8_t* src_u,
+                   int src_stride_u,
+                   const uint8_t* src_v,
+                   int src_stride_v,
+                   uint8_t* dst_argb1555,
+                   int dst_stride_argb1555,
+                   int width,
+                   int height);
+
+LIBYUV_API
+int I420ToARGB4444(const uint8_t* src_y,
+                   int src_stride_y,
+                   const uint8_t* src_u,
+                   int src_stride_u,
+                   const uint8_t* src_v,
+                   int src_stride_v,
+                   uint8_t* dst_argb4444,
+                   int dst_stride_argb4444,
+                   int width,
+                   int height);
+
+// Convert I420 to AR30.
+LIBYUV_API
+int I420ToAR30(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_ar30,
+               int dst_stride_ar30,
+               int width,
+               int height);
+
+// Convert I420 to AB30.
+LIBYUV_API
+int I420ToAB30(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_ab30,
+               int dst_stride_ab30,
+               int width,
+               int height);
+
+// Convert H420 to AR30.
+LIBYUV_API
+int H420ToAR30(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_ar30,
+               int dst_stride_ar30,
+               int width,
+               int height);
+
+// Convert H420 to AB30.
+LIBYUV_API
+int H420ToAB30(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_ab30,
+               int dst_stride_ab30,
+               int width,
+               int height);
+
+// Convert I420 to ARGB with matrix.
+LIBYUV_API
+int I420ToARGBMatrix(const uint8_t* src_y,
+                     int src_stride_y,
+                     const uint8_t* src_u,
+                     int src_stride_u,
+                     const uint8_t* src_v,
+                     int src_stride_v,
+                     uint8_t* dst_argb,
+                     int dst_stride_argb,
+                     const struct YuvConstants* yuvconstants,
+                     int width,
+                     int height);
+
+// Convert I422 to ARGB with matrix.
+LIBYUV_API
+int I422ToARGBMatrix(const uint8_t* src_y,
+                     int src_stride_y,
+                     const uint8_t* src_u,
+                     int src_stride_u,
+                     const uint8_t* src_v,
+                     int src_stride_v,
+                     uint8_t* dst_argb,
+                     int dst_stride_argb,
+                     const struct YuvConstants* yuvconstants,
+                     int width,
+                     int height);
+
+// Convert I444 to ARGB with matrix.
+LIBYUV_API
+int I444ToARGBMatrix(const uint8_t* src_y,
+                     int src_stride_y,
+                     const uint8_t* src_u,
+                     int src_stride_u,
+                     const uint8_t* src_v,
+                     int src_stride_v,
+                     uint8_t* dst_argb,
+                     int dst_stride_argb,
+                     const struct YuvConstants* yuvconstants,
+                     int width,
+                     int height);
+
+// Convert 10 bit 420 YUV to ARGB with matrix.
+LIBYUV_API
+int I010ToAR30Matrix(const uint16_t* src_y,
+                     int src_stride_y,
+                     const uint16_t* src_u,
+                     int src_stride_u,
+                     const uint16_t* src_v,
+                     int src_stride_v,
+                     uint8_t* dst_ar30,
+                     int dst_stride_ar30,
+                     const struct YuvConstants* yuvconstants,
+                     int width,
+                     int height);
+
+// Convert 10 bit 420 YUV to ARGB with matrix.
+LIBYUV_API
+int I210ToAR30Matrix(const uint16_t* src_y,
+                     int src_stride_y,
+                     const uint16_t* src_u,
+                     int src_stride_u,
+                     const uint16_t* src_v,
+                     int src_stride_v,
+                     uint8_t* dst_ar30,
+                     int dst_stride_ar30,
+                     const struct YuvConstants* yuvconstants,
+                     int width,
+                     int height);
+
+// Convert 10 bit 444 YUV to ARGB with matrix.
+LIBYUV_API
+int I410ToAR30Matrix(const uint16_t* src_y,
+                     int src_stride_y,
+                     const uint16_t* src_u,
+                     int src_stride_u,
+                     const uint16_t* src_v,
+                     int src_stride_v,
+                     uint8_t* dst_ar30,
+                     int dst_stride_ar30,
+                     const struct YuvConstants* yuvconstants,
+                     int width,
+                     int height);
+
+// Convert 10 bit YUV to ARGB with matrix.
+LIBYUV_API
+int I010ToARGBMatrix(const uint16_t* src_y,
+                     int src_stride_y,
+                     const uint16_t* src_u,
+                     int src_stride_u,
+                     const uint16_t* src_v,
+                     int src_stride_v,
+                     uint8_t* dst_argb,
+                     int dst_stride_argb,
+                     const struct YuvConstants* yuvconstants,
+                     int width,
+                     int height);
+
+// multiply 12 bit yuv into high bits to allow any number of bits.
+LIBYUV_API
+int I012ToAR30Matrix(const uint16_t* src_y,
+                     int src_stride_y,
+                     const uint16_t* src_u,
+                     int src_stride_u,
+                     const uint16_t* src_v,
+                     int src_stride_v,
+                     uint8_t* dst_ar30,
+                     int dst_stride_ar30,
+                     const struct YuvConstants* yuvconstants,
+                     int width,
+                     int height);
+
+// Convert 12 bit YUV to ARGB with matrix.
+LIBYUV_API
+int I012ToARGBMatrix(const uint16_t* src_y,
+                     int src_stride_y,
+                     const uint16_t* src_u,
+                     int src_stride_u,
+                     const uint16_t* src_v,
+                     int src_stride_v,
+                     uint8_t* dst_argb,
+                     int dst_stride_argb,
+                     const struct YuvConstants* yuvconstants,
+                     int width,
+                     int height);
+
+// Convert 10 bit 422 YUV to ARGB with matrix.
+LIBYUV_API
+int I210ToARGBMatrix(const uint16_t* src_y,
+                     int src_stride_y,
+                     const uint16_t* src_u,
+                     int src_stride_u,
+                     const uint16_t* src_v,
+                     int src_stride_v,
+                     uint8_t* dst_argb,
+                     int dst_stride_argb,
+                     const struct YuvConstants* yuvconstants,
+                     int width,
+                     int height);
+
+// Convert 10 bit 444 YUV to ARGB with matrix.
+LIBYUV_API
+int I410ToARGBMatrix(const uint16_t* src_y,
+                     int src_stride_y,
+                     const uint16_t* src_u,
+                     int src_stride_u,
+                     const uint16_t* src_v,
+                     int src_stride_v,
+                     uint8_t* dst_argb,
+                     int dst_stride_argb,
+                     const struct YuvConstants* yuvconstants,
+                     int width,
+                     int height);
+
+// Convert P010 to ARGB with matrix.
+LIBYUV_API
+int P010ToARGBMatrix(const uint16_t* src_y,
+                     int src_stride_y,
+                     const uint16_t* src_uv,
+                     int src_stride_uv,
+                     uint8_t* dst_argb,
+                     int dst_stride_argb,
+                     const struct YuvConstants* yuvconstants,
+                     int width,
+                     int height);
+
+// Convert P210 to ARGB with matrix.
+LIBYUV_API
+int P210ToARGBMatrix(const uint16_t* src_y,
+                     int src_stride_y,
+                     const uint16_t* src_uv,
+                     int src_stride_uv,
+                     uint8_t* dst_argb,
+                     int dst_stride_argb,
+                     const struct YuvConstants* yuvconstants,
+                     int width,
+                     int height);
+
+// Convert P010 to AR30 with matrix.
+LIBYUV_API
+int P010ToAR30Matrix(const uint16_t* src_y,
+                     int src_stride_y,
+                     const uint16_t* src_uv,
+                     int src_stride_uv,
+                     uint8_t* dst_ar30,
+                     int dst_stride_ar30,
+                     const struct YuvConstants* yuvconstants,
+                     int width,
+                     int height);
+
+// Convert P210 to AR30 with matrix.
+LIBYUV_API
+int P210ToAR30Matrix(const uint16_t* src_y,
+                     int src_stride_y,
+                     const uint16_t* src_uv,
+                     int src_stride_uv,
+                     uint8_t* dst_ar30,
+                     int dst_stride_ar30,
+                     const struct YuvConstants* yuvconstants,
+                     int width,
+                     int height);
+
+// P012 and P010 use most significant bits so the conversion is the same.
+// Convert P012 to ARGB with matrix.
+#define P012ToARGBMatrix P010ToARGBMatrix
+// Convert P012 to AR30 with matrix.
+#define P012ToAR30Matrix P010ToAR30Matrix
+// Convert P212 to ARGB with matrix.
+#define P212ToARGBMatrix P210ToARGBMatrix
+// Convert P212 to AR30 with matrix.
+#define P212ToAR30Matrix P210ToAR30Matrix
+
+// Convert P016 to ARGB with matrix.
+#define P016ToARGBMatrix P010ToARGBMatrix
+// Convert P016 to AR30 with matrix.
+#define P016ToAR30Matrix P010ToAR30Matrix
+// Convert P216 to ARGB with matrix.
+#define P216ToARGBMatrix P210ToARGBMatrix
+// Convert P216 to AR30 with matrix.
+#define P216ToAR30Matrix P210ToAR30Matrix
+
+// Convert I420 with Alpha to preattenuated ARGB with matrix.
+LIBYUV_API
+int I420AlphaToARGBMatrix(const uint8_t* src_y,
+                          int src_stride_y,
+                          const uint8_t* src_u,
+                          int src_stride_u,
+                          const uint8_t* src_v,
+                          int src_stride_v,
+                          const uint8_t* src_a,
+                          int src_stride_a,
+                          uint8_t* dst_argb,
+                          int dst_stride_argb,
+                          const struct YuvConstants* yuvconstants,
+                          int width,
+                          int height,
+                          int attenuate);
+
+// Convert I422 with Alpha to preattenuated ARGB with matrix.
+LIBYUV_API
+int I422AlphaToARGBMatrix(const uint8_t* src_y,
+                          int src_stride_y,
+                          const uint8_t* src_u,
+                          int src_stride_u,
+                          const uint8_t* src_v,
+                          int src_stride_v,
+                          const uint8_t* src_a,
+                          int src_stride_a,
+                          uint8_t* dst_argb,
+                          int dst_stride_argb,
+                          const struct YuvConstants* yuvconstants,
+                          int width,
+                          int height,
+                          int attenuate);
+
+// Convert I444 with Alpha to preattenuated ARGB with matrix.
+LIBYUV_API
+int I444AlphaToARGBMatrix(const uint8_t* src_y,
+                          int src_stride_y,
+                          const uint8_t* src_u,
+                          int src_stride_u,
+                          const uint8_t* src_v,
+                          int src_stride_v,
+                          const uint8_t* src_a,
+                          int src_stride_a,
+                          uint8_t* dst_argb,
+                          int dst_stride_argb,
+                          const struct YuvConstants* yuvconstants,
+                          int width,
+                          int height,
+                          int attenuate);
+
+// Convert I010 with Alpha to preattenuated ARGB with matrix.
+LIBYUV_API
+int I010AlphaToARGBMatrix(const uint16_t* src_y,
+                          int src_stride_y,
+                          const uint16_t* src_u,
+                          int src_stride_u,
+                          const uint16_t* src_v,
+                          int src_stride_v,
+                          const uint16_t* src_a,
+                          int src_stride_a,
+                          uint8_t* dst_argb,
+                          int dst_stride_argb,
+                          const struct YuvConstants* yuvconstants,
+                          int width,
+                          int height,
+                          int attenuate);
+
+// Convert I210 with Alpha to preattenuated ARGB with matrix.
+LIBYUV_API
+int I210AlphaToARGBMatrix(const uint16_t* src_y,
+                          int src_stride_y,
+                          const uint16_t* src_u,
+                          int src_stride_u,
+                          const uint16_t* src_v,
+                          int src_stride_v,
+                          const uint16_t* src_a,
+                          int src_stride_a,
+                          uint8_t* dst_argb,
+                          int dst_stride_argb,
+                          const struct YuvConstants* yuvconstants,
+                          int width,
+                          int height,
+                          int attenuate);
+
+// Convert I410 with Alpha to preattenuated ARGB with matrix.
+LIBYUV_API
+int I410AlphaToARGBMatrix(const uint16_t* src_y,
+                          int src_stride_y,
+                          const uint16_t* src_u,
+                          int src_stride_u,
+                          const uint16_t* src_v,
+                          int src_stride_v,
+                          const uint16_t* src_a,
+                          int src_stride_a,
+                          uint8_t* dst_argb,
+                          int dst_stride_argb,
+                          const struct YuvConstants* yuvconstants,
+                          int width,
+                          int height,
+                          int attenuate);
+
+// Convert NV12 to ARGB with matrix.
+LIBYUV_API
+int NV12ToARGBMatrix(const uint8_t* src_y,
+                     int src_stride_y,
+                     const uint8_t* src_uv,
+                     int src_stride_uv,
+                     uint8_t* dst_argb,
+                     int dst_stride_argb,
+                     const struct YuvConstants* yuvconstants,
+                     int width,
+                     int height);
+
+// Convert NV21 to ARGB with matrix.
+LIBYUV_API
+int NV21ToARGBMatrix(const uint8_t* src_y,
+                     int src_stride_y,
+                     const uint8_t* src_vu,
+                     int src_stride_vu,
+                     uint8_t* dst_argb,
+                     int dst_stride_argb,
+                     const struct YuvConstants* yuvconstants,
+                     int width,
+                     int height);
+
+// Convert NV12 to RGB565 with matrix.
+LIBYUV_API
+int NV12ToRGB565Matrix(const uint8_t* src_y,
+                       int src_stride_y,
+                       const uint8_t* src_uv,
+                       int src_stride_uv,
+                       uint8_t* dst_rgb565,
+                       int dst_stride_rgb565,
+                       const struct YuvConstants* yuvconstants,
+                       int width,
+                       int height);
+
+// Convert NV12 to RGB24 with matrix.
+LIBYUV_API
+int NV12ToRGB24Matrix(const uint8_t* src_y,
+                      int src_stride_y,
+                      const uint8_t* src_uv,
+                      int src_stride_uv,
+                      uint8_t* dst_rgb24,
+                      int dst_stride_rgb24,
+                      const struct YuvConstants* yuvconstants,
+                      int width,
+                      int height);
+
+// Convert NV21 to RGB24 with matrix.
+LIBYUV_API
+int NV21ToRGB24Matrix(const uint8_t* src_y,
+                      int src_stride_y,
+                      const uint8_t* src_vu,
+                      int src_stride_vu,
+                      uint8_t* dst_rgb24,
+                      int dst_stride_rgb24,
+                      const struct YuvConstants* yuvconstants,
+                      int width,
+                      int height);
+
+// Convert Android420 to ARGB with matrix.
+LIBYUV_API
+int Android420ToARGBMatrix(const uint8_t* src_y,
+                           int src_stride_y,
+                           const uint8_t* src_u,
+                           int src_stride_u,
+                           const uint8_t* src_v,
+                           int src_stride_v,
+                           int src_pixel_stride_uv,
+                           uint8_t* dst_argb,
+                           int dst_stride_argb,
+                           const struct YuvConstants* yuvconstants,
+                           int width,
+                           int height);
+
+// Convert I422 to RGBA with matrix.
+LIBYUV_API
+int I422ToRGBAMatrix(const uint8_t* src_y,
+                     int src_stride_y,
+                     const uint8_t* src_u,
+                     int src_stride_u,
+                     const uint8_t* src_v,
+                     int src_stride_v,
+                     uint8_t* dst_rgba,
+                     int dst_stride_rgba,
+                     const struct YuvConstants* yuvconstants,
+                     int width,
+                     int height);
+
+// Convert I420 to RGBA with matrix.
+LIBYUV_API
+int I420ToRGBAMatrix(const uint8_t* src_y,
+                     int src_stride_y,
+                     const uint8_t* src_u,
+                     int src_stride_u,
+                     const uint8_t* src_v,
+                     int src_stride_v,
+                     uint8_t* dst_rgba,
+                     int dst_stride_rgba,
+                     const struct YuvConstants* yuvconstants,
+                     int width,
+                     int height);
+
+// Convert I420 to RGB24 with matrix.
+LIBYUV_API
+int I420ToRGB24Matrix(const uint8_t* src_y,
+                      int src_stride_y,
+                      const uint8_t* src_u,
+                      int src_stride_u,
+                      const uint8_t* src_v,
+                      int src_stride_v,
+                      uint8_t* dst_rgb24,
+                      int dst_stride_rgb24,
+                      const struct YuvConstants* yuvconstants,
+                      int width,
+                      int height);
+
+// Convert I420 to RGB565 with specified color matrix.
+LIBYUV_API
+int I420ToRGB565Matrix(const uint8_t* src_y,
+                       int src_stride_y,
+                       const uint8_t* src_u,
+                       int src_stride_u,
+                       const uint8_t* src_v,
+                       int src_stride_v,
+                       uint8_t* dst_rgb565,
+                       int dst_stride_rgb565,
+                       const struct YuvConstants* yuvconstants,
+                       int width,
+                       int height);
+
+// Convert I420 to AR30 with matrix.
+LIBYUV_API
+int I420ToAR30Matrix(const uint8_t* src_y,
+                     int src_stride_y,
+                     const uint8_t* src_u,
+                     int src_stride_u,
+                     const uint8_t* src_v,
+                     int src_stride_v,
+                     uint8_t* dst_ar30,
+                     int dst_stride_ar30,
+                     const struct YuvConstants* yuvconstants,
+                     int width,
+                     int height);
+
+// Convert I400 (grey) to ARGB.  Reverse of ARGBToI400.
+LIBYUV_API
+int I400ToARGBMatrix(const uint8_t* src_y,
+                     int src_stride_y,
+                     uint8_t* dst_argb,
+                     int dst_stride_argb,
+                     const struct YuvConstants* yuvconstants,
+                     int width,
+                     int height);
+
+// Convert I420 to ARGB with matrix and UV filter mode.
+LIBYUV_API
+int I420ToARGBMatrixFilter(const uint8_t* src_y,
+                           int src_stride_y,
+                           const uint8_t* src_u,
+                           int src_stride_u,
+                           const uint8_t* src_v,
+                           int src_stride_v,
+                           uint8_t* dst_argb,
+                           int dst_stride_argb,
+                           const struct YuvConstants* yuvconstants,
+                           int width,
+                           int height,
+                           enum FilterMode filter);
+
+// Convert I422 to ARGB with matrix and UV filter mode.
+LIBYUV_API
+int I422ToARGBMatrixFilter(const uint8_t* src_y,
+                           int src_stride_y,
+                           const uint8_t* src_u,
+                           int src_stride_u,
+                           const uint8_t* src_v,
+                           int src_stride_v,
+                           uint8_t* dst_argb,
+                           int dst_stride_argb,
+                           const struct YuvConstants* yuvconstants,
+                           int width,
+                           int height,
+                           enum FilterMode filter);
+
+// Convert I010 to AR30 with matrix and UV filter mode.
+LIBYUV_API
+int I010ToAR30MatrixFilter(const uint16_t* src_y,
+                           int src_stride_y,
+                           const uint16_t* src_u,
+                           int src_stride_u,
+                           const uint16_t* src_v,
+                           int src_stride_v,
+                           uint8_t* dst_ar30,
+                           int dst_stride_ar30,
+                           const struct YuvConstants* yuvconstants,
+                           int width,
+                           int height,
+                           enum FilterMode filter);
+
+// Convert I210 to AR30 with matrix and UV filter mode.
+LIBYUV_API
+int I210ToAR30MatrixFilter(const uint16_t* src_y,
+                           int src_stride_y,
+                           const uint16_t* src_u,
+                           int src_stride_u,
+                           const uint16_t* src_v,
+                           int src_stride_v,
+                           uint8_t* dst_ar30,
+                           int dst_stride_ar30,
+                           const struct YuvConstants* yuvconstants,
+                           int width,
+                           int height,
+                           enum FilterMode filter);
+
+// Convert I010 to ARGB with matrix and UV filter mode.
+LIBYUV_API
+int I010ToARGBMatrixFilter(const uint16_t* src_y,
+                           int src_stride_y,
+                           const uint16_t* src_u,
+                           int src_stride_u,
+                           const uint16_t* src_v,
+                           int src_stride_v,
+                           uint8_t* dst_argb,
+                           int dst_stride_argb,
+                           const struct YuvConstants* yuvconstants,
+                           int width,
+                           int height,
+                           enum FilterMode filter);
+
+// Convert I210 to ARGB with matrix and UV filter mode.
+LIBYUV_API
+int I210ToARGBMatrixFilter(const uint16_t* src_y,
+                           int src_stride_y,
+                           const uint16_t* src_u,
+                           int src_stride_u,
+                           const uint16_t* src_v,
+                           int src_stride_v,
+                           uint8_t* dst_argb,
+                           int dst_stride_argb,
+                           const struct YuvConstants* yuvconstants,
+                           int width,
+                           int height,
+                           enum FilterMode filter);
+
+// Convert I420 with Alpha to attenuated ARGB with matrix and UV filter mode.
+LIBYUV_API
+int I420AlphaToARGBMatrixFilter(const uint8_t* src_y,
+                                int src_stride_y,
+                                const uint8_t* src_u,
+                                int src_stride_u,
+                                const uint8_t* src_v,
+                                int src_stride_v,
+                                const uint8_t* src_a,
+                                int src_stride_a,
+                                uint8_t* dst_argb,
+                                int dst_stride_argb,
+                                const struct YuvConstants* yuvconstants,
+                                int width,
+                                int height,
+                                int attenuate,
+                                enum FilterMode filter);
+
+// Convert I422 with Alpha to attenuated ARGB with matrix and UV filter mode.
+LIBYUV_API
+int I422AlphaToARGBMatrixFilter(const uint8_t* src_y,
+                                int src_stride_y,
+                                const uint8_t* src_u,
+                                int src_stride_u,
+                                const uint8_t* src_v,
+                                int src_stride_v,
+                                const uint8_t* src_a,
+                                int src_stride_a,
+                                uint8_t* dst_argb,
+                                int dst_stride_argb,
+                                const struct YuvConstants* yuvconstants,
+                                int width,
+                                int height,
+                                int attenuate,
+                                enum FilterMode filter);
+
+// Convert I010 with Alpha to attenuated ARGB with matrix and UV filter mode.
+LIBYUV_API
+int I010AlphaToARGBMatrixFilter(const uint16_t* src_y,
+                                int src_stride_y,
+                                const uint16_t* src_u,
+                                int src_stride_u,
+                                const uint16_t* src_v,
+                                int src_stride_v,
+                                const uint16_t* src_a,
+                                int src_stride_a,
+                                uint8_t* dst_argb,
+                                int dst_stride_argb,
+                                const struct YuvConstants* yuvconstants,
+                                int width,
+                                int height,
+                                int attenuate,
+                                enum FilterMode filter);
+
+// Convert I210 with Alpha to attenuated ARGB with matrix and UV filter mode.
+LIBYUV_API
+int I210AlphaToARGBMatrixFilter(const uint16_t* src_y,
+                                int src_stride_y,
+                                const uint16_t* src_u,
+                                int src_stride_u,
+                                const uint16_t* src_v,
+                                int src_stride_v,
+                                const uint16_t* src_a,
+                                int src_stride_a,
+                                uint8_t* dst_argb,
+                                int dst_stride_argb,
+                                const struct YuvConstants* yuvconstants,
+                                int width,
+                                int height,
+                                int attenuate,
+                                enum FilterMode filter);
+
+// Convert P010 to ARGB with matrix and UV filter mode.
+LIBYUV_API
+int P010ToARGBMatrixFilter(const uint16_t* src_y,
+                           int src_stride_y,
+                           const uint16_t* src_uv,
+                           int src_stride_uv,
+                           uint8_t* dst_argb,
+                           int dst_stride_argb,
+                           const struct YuvConstants* yuvconstants,
+                           int width,
+                           int height,
+                           enum FilterMode filter);
+
+// Convert P210 to ARGB with matrix and UV filter mode.
+LIBYUV_API
+int P210ToARGBMatrixFilter(const uint16_t* src_y,
+                           int src_stride_y,
+                           const uint16_t* src_uv,
+                           int src_stride_uv,
+                           uint8_t* dst_argb,
+                           int dst_stride_argb,
+                           const struct YuvConstants* yuvconstants,
+                           int width,
+                           int height,
+                           enum FilterMode filter);
+
+// Convert P010 to AR30 with matrix and UV filter mode.
+LIBYUV_API
+int P010ToAR30MatrixFilter(const uint16_t* src_y,
+                           int src_stride_y,
+                           const uint16_t* src_uv,
+                           int src_stride_uv,
+                           uint8_t* dst_ar30,
+                           int dst_stride_ar30,
+                           const struct YuvConstants* yuvconstants,
+                           int width,
+                           int height,
+                           enum FilterMode filter);
+
+// Convert P210 to AR30 with matrix and UV filter mode.
+LIBYUV_API
+int P210ToAR30MatrixFilter(const uint16_t* src_y,
+                           int src_stride_y,
+                           const uint16_t* src_uv,
+                           int src_stride_uv,
+                           uint8_t* dst_ar30,
+                           int dst_stride_ar30,
+                           const struct YuvConstants* yuvconstants,
+                           int width,
+                           int height,
+                           enum FilterMode filter);
+
+// Convert camera sample to ARGB with cropping, rotation and vertical flip.
+// "sample_size" is needed to parse MJPG.
+// "dst_stride_argb" number of bytes in a row of the dst_argb plane.
+//   Normally this would be the same as dst_width, with recommended alignment
+//   to 16 bytes for better efficiency.
+//   If rotation of 90 or 270 is used, stride is affected. The caller should
+//   allocate the I420 buffer according to rotation.
+// "dst_stride_u" number of bytes in a row of the dst_u plane.
+//   Normally this would be the same as (dst_width + 1) / 2, with
+//   recommended alignment to 16 bytes for better efficiency.
+//   If rotation of 90 or 270 is used, stride is affected.
+// "crop_x" and "crop_y" are starting position for cropping.
+//   To center, crop_x = (src_width - dst_width) / 2
+//              crop_y = (src_height - dst_height) / 2
+// "src_width" / "src_height" is size of src_frame in pixels.
+//   "src_height" can be negative indicating a vertically flipped image source.
+// "crop_width" / "crop_height" is the size to crop the src to.
+//    Must be less than or equal to src_width/src_height
+//    Cropping parameters are pre-rotation.
+// "rotation" can be 0, 90, 180 or 270.
+// "fourcc" is a fourcc. ie 'I420', 'YUY2'
+// Returns 0 for successful; -1 for invalid parameter. Non-zero for failure.
+LIBYUV_API
+int ConvertToARGB(const uint8_t* sample,
+                  size_t sample_size,
+                  uint8_t* dst_argb,
+                  int dst_stride_argb,
+                  int crop_x,
+                  int crop_y,
+                  int src_width,
+                  int src_height,
+                  int crop_width,
+                  int crop_height,
+                  enum RotationMode rotation,
+                  uint32_t fourcc);
+
+#ifdef __cplusplus
+}  // extern "C"
+}  // namespace libyuv
+#endif
+
+#endif  // INCLUDE_LIBYUV_CONVERT_ARGB_H_
diff --git a/3rdparty/libyuv/src/include/libyuv/convert_from.h b/3rdparty/libyuv/src/include/libyuv/convert_from.h
new file mode 100644
index 00000000..32f42a63
--- /dev/null
+++ b/3rdparty/libyuv/src/include/libyuv/convert_from.h
@@ -0,0 +1,203 @@
+/*
+ *  Copyright 2011 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#ifndef INCLUDE_LIBYUV_CONVERT_FROM_H_
+#define INCLUDE_LIBYUV_CONVERT_FROM_H_
+
+#include "libyuv/basic_types.h"
+#include "libyuv/rotate.h"
+
+#ifdef __cplusplus
+namespace libyuv {
+extern "C" {
+#endif
+
+// See Also convert.h for conversions from formats to I420.
+
+// Convert 8 bit YUV to 10 bit.
+#define H420ToH010 I420ToI010
+LIBYUV_API
+int I420ToI010(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint16_t* dst_y,
+               int dst_stride_y,
+               uint16_t* dst_u,
+               int dst_stride_u,
+               uint16_t* dst_v,
+               int dst_stride_v,
+               int width,
+               int height);
+
+// Convert 8 bit YUV to 12 bit.
+#define H420ToH012 I420ToI012
+LIBYUV_API
+int I420ToI012(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint16_t* dst_y,
+               int dst_stride_y,
+               uint16_t* dst_u,
+               int dst_stride_u,
+               uint16_t* dst_v,
+               int dst_stride_v,
+               int width,
+               int height);
+
+LIBYUV_API
+int I420ToI422(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_u,
+               int dst_stride_u,
+               uint8_t* dst_v,
+               int dst_stride_v,
+               int width,
+               int height);
+
+LIBYUV_API
+int I420ToI444(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_u,
+               int dst_stride_u,
+               uint8_t* dst_v,
+               int dst_stride_v,
+               int width,
+               int height);
+
+// Copy to I400. Source can be I420, I422, I444, I400, NV12 or NV21.
+LIBYUV_API
+int I400Copy(const uint8_t* src_y,
+             int src_stride_y,
+             uint8_t* dst_y,
+             int dst_stride_y,
+             int width,
+             int height);
+
+LIBYUV_API
+int I420ToNV12(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_uv,
+               int dst_stride_uv,
+               int width,
+               int height);
+
+LIBYUV_API
+int I420ToNV21(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_vu,
+               int dst_stride_vu,
+               int width,
+               int height);
+
+LIBYUV_API
+int I420ToYUY2(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_yuy2,
+               int dst_stride_yuy2,
+               int width,
+               int height);
+
+LIBYUV_API
+int I420ToUYVY(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_uyvy,
+               int dst_stride_uyvy,
+               int width,
+               int height);
+
+// The following are from convert_argb.h
+// DEPRECATED: The prototypes will be removed in future.  Use convert_argb.h
+
+// Convert I420 to ARGB.
+LIBYUV_API
+int I420ToARGB(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_argb,
+               int dst_stride_argb,
+               int width,
+               int height);
+
+// Convert I420 to ABGR.
+LIBYUV_API
+int I420ToABGR(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_abgr,
+               int dst_stride_abgr,
+               int width,
+               int height);
+
+// Convert I420 to specified format.
+// "dst_sample_stride" is bytes in a row for the destination. Pass 0 if the
+//    buffer has contiguous rows. Can be negative. A multiple of 16 is optimal.
+LIBYUV_API
+int ConvertFromI420(const uint8_t* y,
+                    int y_stride,
+                    const uint8_t* u,
+                    int u_stride,
+                    const uint8_t* v,
+                    int v_stride,
+                    uint8_t* dst_sample,
+                    int dst_sample_stride,
+                    int width,
+                    int height,
+                    uint32_t fourcc);
+
+#ifdef __cplusplus
+}  // extern "C"
+}  // namespace libyuv
+#endif
+
+#endif  // INCLUDE_LIBYUV_CONVERT_FROM_H_
diff --git a/3rdparty/libyuv/src/include/libyuv/convert_from_argb.h b/3rdparty/libyuv/src/include/libyuv/convert_from_argb.h
new file mode 100644
index 00000000..2a488838
--- /dev/null
+++ b/3rdparty/libyuv/src/include/libyuv/convert_from_argb.h
@@ -0,0 +1,346 @@
+/*
+ *  Copyright 2012 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#ifndef INCLUDE_LIBYUV_CONVERT_FROM_ARGB_H_
+#define INCLUDE_LIBYUV_CONVERT_FROM_ARGB_H_
+
+#include "libyuv/basic_types.h"
+
+#ifdef __cplusplus
+namespace libyuv {
+extern "C" {
+#endif
+
+// Copy ARGB to ARGB.
+#define ARGBToARGB ARGBCopy
+LIBYUV_API
+int ARGBCopy(const uint8_t* src_argb,
+             int src_stride_argb,
+             uint8_t* dst_argb,
+             int dst_stride_argb,
+             int width,
+             int height);
+
+// Convert ARGB To BGRA.
+LIBYUV_API
+int ARGBToBGRA(const uint8_t* src_argb,
+               int src_stride_argb,
+               uint8_t* dst_bgra,
+               int dst_stride_bgra,
+               int width,
+               int height);
+
+// Convert ARGB To ABGR.
+LIBYUV_API
+int ARGBToABGR(const uint8_t* src_argb,
+               int src_stride_argb,
+               uint8_t* dst_abgr,
+               int dst_stride_abgr,
+               int width,
+               int height);
+
+// Convert ARGB To RGBA.
+LIBYUV_API
+int ARGBToRGBA(const uint8_t* src_argb,
+               int src_stride_argb,
+               uint8_t* dst_rgba,
+               int dst_stride_rgba,
+               int width,
+               int height);
+
+// Aliases
+#define ARGBToAB30 ABGRToAR30
+#define ABGRToAB30 ARGBToAR30
+
+// Convert ABGR To AR30.
+LIBYUV_API
+int ABGRToAR30(const uint8_t* src_abgr,
+               int src_stride_abgr,
+               uint8_t* dst_ar30,
+               int dst_stride_ar30,
+               int width,
+               int height);
+
+// Convert ARGB To AR30.
+LIBYUV_API
+int ARGBToAR30(const uint8_t* src_argb,
+               int src_stride_argb,
+               uint8_t* dst_ar30,
+               int dst_stride_ar30,
+               int width,
+               int height);
+
+// Aliases
+#define ABGRToRGB24 ARGBToRAW
+#define ABGRToRAW ARGBToRGB24
+
+// Convert ARGB To RGB24.
+LIBYUV_API
+int ARGBToRGB24(const uint8_t* src_argb,
+                int src_stride_argb,
+                uint8_t* dst_rgb24,
+                int dst_stride_rgb24,
+                int width,
+                int height);
+
+// Convert ARGB To RAW.
+LIBYUV_API
+int ARGBToRAW(const uint8_t* src_argb,
+              int src_stride_argb,
+              uint8_t* dst_raw,
+              int dst_stride_raw,
+              int width,
+              int height);
+
+// Convert ARGB To RGB565.
+LIBYUV_API
+int ARGBToRGB565(const uint8_t* src_argb,
+                 int src_stride_argb,
+                 uint8_t* dst_rgb565,
+                 int dst_stride_rgb565,
+                 int width,
+                 int height);
+
+// Convert ARGB To RGB565 with 4x4 dither matrix (16 bytes).
+// Values in dither matrix from 0 to 7 recommended.
+// The order of the dither matrix is first byte is upper left.
+// TODO(fbarchard): Consider pointer to 2d array for dither4x4.
+// const uint8_t(*dither)[4][4];
+LIBYUV_API
+int ARGBToRGB565Dither(const uint8_t* src_argb,
+                       int src_stride_argb,
+                       uint8_t* dst_rgb565,
+                       int dst_stride_rgb565,
+                       const uint8_t* dither4x4,
+                       int width,
+                       int height);
+
+// Convert ARGB To ARGB1555.
+LIBYUV_API
+int ARGBToARGB1555(const uint8_t* src_argb,
+                   int src_stride_argb,
+                   uint8_t* dst_argb1555,
+                   int dst_stride_argb1555,
+                   int width,
+                   int height);
+
+// Convert ARGB To ARGB4444.
+LIBYUV_API
+int ARGBToARGB4444(const uint8_t* src_argb,
+                   int src_stride_argb,
+                   uint8_t* dst_argb4444,
+                   int dst_stride_argb4444,
+                   int width,
+                   int height);
+
+// Convert ARGB To I444.
+LIBYUV_API
+int ARGBToI444(const uint8_t* src_argb,
+               int src_stride_argb,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_u,
+               int dst_stride_u,
+               uint8_t* dst_v,
+               int dst_stride_v,
+               int width,
+               int height);
+
+// Convert ARGB to AR64.
+LIBYUV_API
+int ARGBToAR64(const uint8_t* src_argb,
+               int src_stride_argb,
+               uint16_t* dst_ar64,
+               int dst_stride_ar64,
+               int width,
+               int height);
+
+// Convert ABGR to AB64.
+#define ABGRToAB64 ARGBToAR64
+
+// Convert ARGB to AB64.
+LIBYUV_API
+int ARGBToAB64(const uint8_t* src_argb,
+               int src_stride_argb,
+               uint16_t* dst_ab64,
+               int dst_stride_ab64,
+               int width,
+               int height);
+
+// Convert ABGR to AR64.
+#define ABGRToAR64 ARGBToAB64
+
+// Convert ARGB To I422.
+LIBYUV_API
+int ARGBToI422(const uint8_t* src_argb,
+               int src_stride_argb,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_u,
+               int dst_stride_u,
+               uint8_t* dst_v,
+               int dst_stride_v,
+               int width,
+               int height);
+
+// Convert ARGB To I420. (also in convert.h)
+LIBYUV_API
+int ARGBToI420(const uint8_t* src_argb,
+               int src_stride_argb,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_u,
+               int dst_stride_u,
+               uint8_t* dst_v,
+               int dst_stride_v,
+               int width,
+               int height);
+
+// Convert ARGB to J420. (JPeg full range I420).
+LIBYUV_API
+int ARGBToJ420(const uint8_t* src_argb,
+               int src_stride_argb,
+               uint8_t* dst_yj,
+               int dst_stride_yj,
+               uint8_t* dst_u,
+               int dst_stride_u,
+               uint8_t* dst_v,
+               int dst_stride_v,
+               int width,
+               int height);
+
+// Convert ARGB to J422.
+LIBYUV_API
+int ARGBToJ422(const uint8_t* src_argb,
+               int src_stride_argb,
+               uint8_t* dst_yj,
+               int dst_stride_yj,
+               uint8_t* dst_u,
+               int dst_stride_u,
+               uint8_t* dst_v,
+               int dst_stride_v,
+               int width,
+               int height);
+
+// Convert ARGB to J400. (JPeg full range).
+LIBYUV_API
+int ARGBToJ400(const uint8_t* src_argb,
+               int src_stride_argb,
+               uint8_t* dst_yj,
+               int dst_stride_yj,
+               int width,
+               int height);
+
+// Convert RGBA to J400. (JPeg full range).
+LIBYUV_API
+int RGBAToJ400(const uint8_t* src_rgba,
+               int src_stride_rgba,
+               uint8_t* dst_yj,
+               int dst_stride_yj,
+               int width,
+               int height);
+
+// Convert ARGB to I400.
+LIBYUV_API
+int ARGBToI400(const uint8_t* src_argb,
+               int src_stride_argb,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               int width,
+               int height);
+
+// Convert ARGB to G. (Reverse of J400toARGB, which replicates G back to ARGB)
+LIBYUV_API
+int ARGBToG(const uint8_t* src_argb,
+            int src_stride_argb,
+            uint8_t* dst_g,
+            int dst_stride_g,
+            int width,
+            int height);
+
+// Convert ARGB To NV12.
+LIBYUV_API
+int ARGBToNV12(const uint8_t* src_argb,
+               int src_stride_argb,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_uv,
+               int dst_stride_uv,
+               int width,
+               int height);
+
+// Convert ARGB To NV21.
+LIBYUV_API
+int ARGBToNV21(const uint8_t* src_argb,
+               int src_stride_argb,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_vu,
+               int dst_stride_vu,
+               int width,
+               int height);
+
+// Convert ABGR To NV12.
+LIBYUV_API
+int ABGRToNV12(const uint8_t* src_abgr,
+               int src_stride_abgr,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_uv,
+               int dst_stride_uv,
+               int width,
+               int height);
+
+// Convert ABGR To NV21.
+LIBYUV_API
+int ABGRToNV21(const uint8_t* src_abgr,
+               int src_stride_abgr,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_vu,
+               int dst_stride_vu,
+               int width,
+               int height);
+
+// Convert ARGB To YUY2.
+LIBYUV_API
+int ARGBToYUY2(const uint8_t* src_argb,
+               int src_stride_argb,
+               uint8_t* dst_yuy2,
+               int dst_stride_yuy2,
+               int width,
+               int height);
+
+// Convert ARGB To UYVY.
+LIBYUV_API
+int ARGBToUYVY(const uint8_t* src_argb,
+               int src_stride_argb,
+               uint8_t* dst_uyvy,
+               int dst_stride_uyvy,
+               int width,
+               int height);
+
+// RAW to JNV21 full range NV21
+LIBYUV_API
+int RAWToJNV21(const uint8_t* src_raw,
+               int src_stride_raw,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_vu,
+               int dst_stride_vu,
+               int width,
+               int height);
+
+#ifdef __cplusplus
+}  // extern "C"
+}  // namespace libyuv
+#endif
+
+#endif  // INCLUDE_LIBYUV_CONVERT_FROM_ARGB_H_
diff --git a/3rdparty/libyuv/src/include/libyuv/cpu_id.h b/3rdparty/libyuv/src/include/libyuv/cpu_id.h
new file mode 100644
index 00000000..fb90c6c7
--- /dev/null
+++ b/3rdparty/libyuv/src/include/libyuv/cpu_id.h
@@ -0,0 +1,127 @@
+/*
+ *  Copyright 2011 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#ifndef INCLUDE_LIBYUV_CPU_ID_H_
+#define INCLUDE_LIBYUV_CPU_ID_H_
+
+#include "libyuv/basic_types.h"
+
+#ifdef __cplusplus
+namespace libyuv {
+extern "C" {
+#endif
+
+// Internal flag to indicate cpuid requires initialization.
+static const int kCpuInitialized = 0x1;
+
+// These flags are only valid on ARM processors.
+static const int kCpuHasARM = 0x2;
+static const int kCpuHasNEON = 0x4;
+// 0x8 reserved for future ARM flag.
+
+// These flags are only valid on x86 processors.
+static const int kCpuHasX86 = 0x10;
+static const int kCpuHasSSE2 = 0x20;
+static const int kCpuHasSSSE3 = 0x40;
+static const int kCpuHasSSE41 = 0x80;
+static const int kCpuHasSSE42 = 0x100;  // unused at this time.
+static const int kCpuHasAVX = 0x200;
+static const int kCpuHasAVX2 = 0x400;
+static const int kCpuHasERMS = 0x800;
+static const int kCpuHasFMA3 = 0x1000;
+static const int kCpuHasF16C = 0x2000;
+static const int kCpuHasGFNI = 0x4000;
+static const int kCpuHasAVX512BW = 0x8000;
+static const int kCpuHasAVX512VL = 0x10000;
+static const int kCpuHasAVX512VNNI = 0x20000;
+static const int kCpuHasAVX512VBMI = 0x40000;
+static const int kCpuHasAVX512VBMI2 = 0x80000;
+static const int kCpuHasAVX512VBITALG = 0x100000;
+static const int kCpuHasAVX512VPOPCNTDQ = 0x200000;
+
+// These flags are only valid on MIPS processors.
+static const int kCpuHasMIPS = 0x400000;
+static const int kCpuHasMSA = 0x800000;
+
+// These flags are only valid on LOONGARCH processors.
+static const int kCpuHasLOONGARCH = 0x2000000;
+static const int kCpuHasLSX = 0x4000000;
+static const int kCpuHasLASX = 0x8000000;
+
+// Optional init function. TestCpuFlag does an auto-init.
+// Returns cpu_info flags.
+LIBYUV_API
+int InitCpuFlags(void);
+
+// Detect CPU has SSE2 etc.
+// Test_flag parameter should be one of kCpuHas constants above.
+// Returns non-zero if instruction set is detected
+static __inline int TestCpuFlag(int test_flag) {
+  LIBYUV_API extern int cpu_info_;
+#ifdef __ATOMIC_RELAXED
+  int cpu_info = __atomic_load_n(&cpu_info_, __ATOMIC_RELAXED);
+#else
+  int cpu_info = cpu_info_;
+#endif
+  return (!cpu_info ? InitCpuFlags() : cpu_info) & test_flag;
+}
+
+// Internal function for parsing /proc/cpuinfo.
+LIBYUV_API
+int ArmCpuCaps(const char* cpuinfo_name);
+LIBYUV_API
+int MipsCpuCaps(const char* cpuinfo_name);
+
+// For testing, allow CPU flags to be disabled.
+// ie MaskCpuFlags(~kCpuHasSSSE3) to disable SSSE3.
+// MaskCpuFlags(-1) to enable all cpu specific optimizations.
+// MaskCpuFlags(1) to disable all cpu specific optimizations.
+// MaskCpuFlags(0) to reset state so next call will auto init.
+// Returns cpu_info flags.
+LIBYUV_API
+int MaskCpuFlags(int enable_flags);
+
+// Sets the CPU flags to |cpu_flags|, bypassing the detection code. |cpu_flags|
+// should be a valid combination of the kCpuHas constants above and include
+// kCpuInitialized. Use this method when running in a sandboxed process where
+// the detection code might fail (as it might access /proc/cpuinfo). In such
+// cases the cpu_info can be obtained from a non sandboxed process by calling
+// InitCpuFlags() and passed to the sandboxed process (via command line
+// parameters, IPC...) which can then call this method to initialize the CPU
+// flags.
+// Notes:
+// - when specifying 0 for |cpu_flags|, the auto initialization is enabled
+//   again.
+// - enabling CPU features that are not supported by the CPU will result in
+//   undefined behavior.
+// TODO(fbarchard): consider writing a helper function that translates from
+// other library CPU info to libyuv CPU info and add a .md doc that explains
+// CPU detection.
+static __inline void SetCpuFlags(int cpu_flags) {
+  LIBYUV_API extern int cpu_info_;
+#ifdef __ATOMIC_RELAXED
+  __atomic_store_n(&cpu_info_, cpu_flags, __ATOMIC_RELAXED);
+#else
+  cpu_info_ = cpu_flags;
+#endif
+}
+
+// Low level cpuid for X86. Returns zeros on other CPUs.
+// eax is the info type that you want.
+// ecx is typically the cpu number, and should normally be zero.
+LIBYUV_API
+void CpuId(int info_eax, int info_ecx, int* cpu_info);
+
+#ifdef __cplusplus
+}  // extern "C"
+}  // namespace libyuv
+#endif
+
+#endif  // INCLUDE_LIBYUV_CPU_ID_H_
diff --git a/3rdparty/libyuv/src/include/libyuv/loongson_intrinsics.h b/3rdparty/libyuv/src/include/libyuv/loongson_intrinsics.h
new file mode 100644
index 00000000..1d613def
--- /dev/null
+++ b/3rdparty/libyuv/src/include/libyuv/loongson_intrinsics.h
@@ -0,0 +1,1949 @@
+/*
+ *  Copyright 2022 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#ifndef INCLUDE_LIBYUV_LOONGSON_INTRINSICS_H
+#define INCLUDE_LIBYUV_LOONGSON_INTRINSICS_H
+
+/*
+ * Copyright (c) 2022 Loongson Technology Corporation Limited
+ * All rights reserved.
+ * Contributed by Shiyou Yin <yinshiyou-hf@loongson.cn>
+ *                Xiwei Gu   <guxiwei-hf@loongson.cn>
+ *                Lu Wang    <wanglu@loongson.cn>
+ *
+ * This file is a header file for loongarch builtin extension.
+ *
+ */
+
+#ifndef LOONGSON_INTRINSICS_H
+#define LOONGSON_INTRINSICS_H
+
+/**
+ * MAJOR version: Macro usage changes.
+ * MINOR version: Add new functions, or bug fixes.
+ * MICRO version: Comment changes or implementation changes.
+ */
+#define LSOM_VERSION_MAJOR 1
+#define LSOM_VERSION_MINOR 1
+#define LSOM_VERSION_MICRO 0
+
+#define DUP2_ARG1(_INS, _IN0, _IN1, _OUT0, _OUT1) \
+  {                                               \
+    _OUT0 = _INS(_IN0);                           \
+    _OUT1 = _INS(_IN1);                           \
+  }
+
+#define DUP2_ARG2(_INS, _IN0, _IN1, _IN2, _IN3, _OUT0, _OUT1) \
+  {                                                           \
+    _OUT0 = _INS(_IN0, _IN1);                                 \
+    _OUT1 = _INS(_IN2, _IN3);                                 \
+  }
+
+#define DUP2_ARG3(_INS, _IN0, _IN1, _IN2, _IN3, _IN4, _IN5, _OUT0, _OUT1) \
+  {                                                                       \
+    _OUT0 = _INS(_IN0, _IN1, _IN2);                                       \
+    _OUT1 = _INS(_IN3, _IN4, _IN5);                                       \
+  }
+
+#define DUP4_ARG1(_INS, _IN0, _IN1, _IN2, _IN3, _OUT0, _OUT1, _OUT2, _OUT3) \
+  {                                                                         \
+    DUP2_ARG1(_INS, _IN0, _IN1, _OUT0, _OUT1);                              \
+    DUP2_ARG1(_INS, _IN2, _IN3, _OUT2, _OUT3);                              \
+  }
+
+#define DUP4_ARG2(_INS, _IN0, _IN1, _IN2, _IN3, _IN4, _IN5, _IN6, _IN7, _OUT0, \
+                  _OUT1, _OUT2, _OUT3)                                         \
+  {                                                                            \
+    DUP2_ARG2(_INS, _IN0, _IN1, _IN2, _IN3, _OUT0, _OUT1);                     \
+    DUP2_ARG2(_INS, _IN4, _IN5, _IN6, _IN7, _OUT2, _OUT3);                     \
+  }
+
+#define DUP4_ARG3(_INS, _IN0, _IN1, _IN2, _IN3, _IN4, _IN5, _IN6, _IN7, _IN8, \
+                  _IN9, _IN10, _IN11, _OUT0, _OUT1, _OUT2, _OUT3)             \
+  {                                                                           \
+    DUP2_ARG3(_INS, _IN0, _IN1, _IN2, _IN3, _IN4, _IN5, _OUT0, _OUT1);        \
+    DUP2_ARG3(_INS, _IN6, _IN7, _IN8, _IN9, _IN10, _IN11, _OUT2, _OUT3);      \
+  }
+
+#ifdef __loongarch_sx
+#include <lsxintrin.h>
+/*
+ * =============================================================================
+ * Description : Dot product & addition of byte vector elements
+ * Arguments   : Inputs  - in_c, in_h, in_l
+ *               Outputs - out
+ *               Return Type - halfword
+ * Details     : Signed byte elements from in_h are multiplied by
+ *               signed byte elements from in_l, and then added adjacent to
+ *               each other to get results with the twice size of input.
+ *               Then the results plus to signed half-word elements from in_c.
+ * Example     : out = __lsx_vdp2add_h_b(in_c, in_h, in_l)
+ *        in_c : 1,2,3,4, 1,2,3,4
+ *        in_h : 1,2,3,4, 5,6,7,8, 1,2,3,4, 5,6,7,8
+ *        in_l : 8,7,6,5, 4,3,2,1, 8,7,6,5, 4,3,2,1
+ *         out : 23,40,41,26, 23,40,41,26
+ * =============================================================================
+ */
+static inline __m128i __lsx_vdp2add_h_b(__m128i in_c,
+                                        __m128i in_h,
+                                        __m128i in_l) {
+  __m128i out;
+
+  out = __lsx_vmaddwev_h_b(in_c, in_h, in_l);
+  out = __lsx_vmaddwod_h_b(out, in_h, in_l);
+  return out;
+}
+
+/*
+ * =============================================================================
+ * Description : Dot product & addition of byte vector elements
+ * Arguments   : Inputs  - in_c, in_h, in_l
+ *               Outputs - out
+ *               Return Type - halfword
+ * Details     : Unsigned byte elements from in_h are multiplied by
+ *               unsigned byte elements from in_l, and then added adjacent to
+ *               each other to get results with the twice size of input.
+ *               The results plus to signed half-word elements from in_c.
+ * Example     : out = __lsx_vdp2add_h_bu(in_c, in_h, in_l)
+ *        in_c : 1,2,3,4, 1,2,3,4
+ *        in_h : 1,2,3,4, 5,6,7,8, 1,2,3,4, 5,6,7,8
+ *        in_l : 8,7,6,5, 4,3,2,1, 8,7,6,5, 4,3,2,1
+ *         out : 23,40,41,26, 23,40,41,26
+ * =============================================================================
+ */
+static inline __m128i __lsx_vdp2add_h_bu(__m128i in_c,
+                                         __m128i in_h,
+                                         __m128i in_l) {
+  __m128i out;
+
+  out = __lsx_vmaddwev_h_bu(in_c, in_h, in_l);
+  out = __lsx_vmaddwod_h_bu(out, in_h, in_l);
+  return out;
+}
+
+/*
+ * =============================================================================
+ * Description : Dot product & addition of byte vector elements
+ * Arguments   : Inputs  - in_c, in_h, in_l
+ *               Outputs - out
+ *               Return Type - halfword
+ * Details     : Unsigned byte elements from in_h are multiplied by
+ *               signed byte elements from in_l, and then added adjacent to
+ *               each other to get results with the twice size of input.
+ *               The results plus to signed half-word elements from in_c.
+ * Example     : out = __lsx_vdp2add_h_bu_b(in_c, in_h, in_l)
+ *        in_c : 1,1,1,1, 1,1,1,1
+ *        in_h : 1,2,3,4, 5,6,7,8, 1,2,3,4, 5,6,7,8
+ *        in_l : -1,-2,-3,-4, -5,-6,-7,-8, 1,2,3,4, 5,6,7,8
+ *         out : -4,-24,-60,-112, 6,26,62,114
+ * =============================================================================
+ */
+static inline __m128i __lsx_vdp2add_h_bu_b(__m128i in_c,
+                                           __m128i in_h,
+                                           __m128i in_l) {
+  __m128i out;
+
+  out = __lsx_vmaddwev_h_bu_b(in_c, in_h, in_l);
+  out = __lsx_vmaddwod_h_bu_b(out, in_h, in_l);
+  return out;
+}
+
+/*
+ * =============================================================================
+ * Description : Dot product & addition of half-word vector elements
+ * Arguments   : Inputs  - in_c, in_h, in_l
+ *               Outputs - out
+ *               Return Type - __m128i
+ * Details     : Signed half-word elements from in_h are multiplied by
+ *               signed half-word elements from in_l, and then added adjacent to
+ *               each other to get results with the twice size of input.
+ *               Then the results plus to signed word elements from in_c.
+ * Example     : out = __lsx_vdp2add_h_b(in_c, in_h, in_l)
+ *        in_c : 1,2,3,4
+ *        in_h : 1,2,3,4, 5,6,7,8
+ *        in_l : 8,7,6,5, 4,3,2,1
+ *         out : 23,40,41,26
+ * =============================================================================
+ */
+static inline __m128i __lsx_vdp2add_w_h(__m128i in_c,
+                                        __m128i in_h,
+                                        __m128i in_l) {
+  __m128i out;
+
+  out = __lsx_vmaddwev_w_h(in_c, in_h, in_l);
+  out = __lsx_vmaddwod_w_h(out, in_h, in_l);
+  return out;
+}
+
+/*
+ * =============================================================================
+ * Description : Dot product of byte vector elements
+ * Arguments   : Inputs  - in_h, in_l
+ *               Outputs - out
+ *               Return Type - halfword
+ * Details     : Signed byte elements from in_h are multiplied by
+ *               signed byte elements from in_l, and then added adjacent to
+ *               each other to get results with the twice size of input.
+ * Example     : out = __lsx_vdp2_h_b(in_h, in_l)
+ *        in_h : 1,2,3,4, 5,6,7,8, 1,2,3,4, 5,6,7,8
+ *        in_l : 8,7,6,5, 4,3,2,1, 8,7,6,5, 4,3,2,1
+ *         out : 22,38,38,22, 22,38,38,22
+ * =============================================================================
+ */
+static inline __m128i __lsx_vdp2_h_b(__m128i in_h, __m128i in_l) {
+  __m128i out;
+
+  out = __lsx_vmulwev_h_b(in_h, in_l);
+  out = __lsx_vmaddwod_h_b(out, in_h, in_l);
+  return out;
+}
+
+/*
+ * =============================================================================
+ * Description : Dot product of byte vector elements
+ * Arguments   : Inputs  - in_h, in_l
+ *               Outputs - out
+ *               Return Type - halfword
+ * Details     : Unsigned byte elements from in_h are multiplied by
+ *               unsigned byte elements from in_l, and then added adjacent to
+ *               each other to get results with the twice size of input.
+ * Example     : out = __lsx_vdp2_h_bu(in_h, in_l)
+ *        in_h : 1,2,3,4, 5,6,7,8, 1,2,3,4, 5,6,7,8
+ *        in_l : 8,7,6,5, 4,3,2,1, 8,7,6,5, 4,3,2,1
+ *         out : 22,38,38,22, 22,38,38,22
+ * =============================================================================
+ */
+static inline __m128i __lsx_vdp2_h_bu(__m128i in_h, __m128i in_l) {
+  __m128i out;
+
+  out = __lsx_vmulwev_h_bu(in_h, in_l);
+  out = __lsx_vmaddwod_h_bu(out, in_h, in_l);
+  return out;
+}
+
+/*
+ * =============================================================================
+ * Description : Dot product of byte vector elements
+ * Arguments   : Inputs  - in_h, in_l
+ *               Outputs - out
+ *               Return Type - halfword
+ * Details     : Unsigned byte elements from in_h are multiplied by
+ *               signed byte elements from in_l, and then added adjacent to
+ *               each other to get results with the twice size of input.
+ * Example     : out = __lsx_vdp2_h_bu_b(in_h, in_l)
+ *        in_h : 1,2,3,4, 5,6,7,8, 1,2,3,4, 5,6,7,8
+ *        in_l : 8,7,6,5, 4,3,2,1, 8,7,6,5, 4,3,2,-1
+ *         out : 22,38,38,22, 22,38,38,6
+ * =============================================================================
+ */
+static inline __m128i __lsx_vdp2_h_bu_b(__m128i in_h, __m128i in_l) {
+  __m128i out;
+
+  out = __lsx_vmulwev_h_bu_b(in_h, in_l);
+  out = __lsx_vmaddwod_h_bu_b(out, in_h, in_l);
+  return out;
+}
+
+/*
+ * =============================================================================
+ * Description : Dot product of byte vector elements
+ * Arguments   : Inputs  - in_h, in_l
+ *               Outputs - out
+ *               Return Type - halfword
+ * Details     : Signed byte elements from in_h are multiplied by
+ *               signed byte elements from in_l, and then added adjacent to
+ *               each other to get results with the twice size of input.
+ * Example     : out = __lsx_vdp2_w_h(in_h, in_l)
+ *        in_h : 1,2,3,4, 5,6,7,8
+ *        in_l : 8,7,6,5, 4,3,2,1
+ *         out : 22,38,38,22
+ * =============================================================================
+ */
+static inline __m128i __lsx_vdp2_w_h(__m128i in_h, __m128i in_l) {
+  __m128i out;
+
+  out = __lsx_vmulwev_w_h(in_h, in_l);
+  out = __lsx_vmaddwod_w_h(out, in_h, in_l);
+  return out;
+}
+
+/*
+ * =============================================================================
+ * Description : Clip all halfword elements of input vector between min & max
+ *               out = ((_in) < (min)) ? (min) : (((_in) > (max)) ? (max) :
+ *               (_in))
+ * Arguments   : Inputs  - _in  (input vector)
+ *                       - min  (min threshold)
+ *                       - max  (max threshold)
+ *               Outputs - out  (output vector with clipped elements)
+ *               Return Type - signed halfword
+ * Example     : out = __lsx_vclip_h(_in)
+ *         _in : -8,2,280,249, -8,255,280,249
+ *         min : 1,1,1,1, 1,1,1,1
+ *         max : 9,9,9,9, 9,9,9,9
+ *         out : 1,2,9,9, 1,9,9,9
+ * =============================================================================
+ */
+static inline __m128i __lsx_vclip_h(__m128i _in, __m128i min, __m128i max) {
+  __m128i out;
+
+  out = __lsx_vmax_h(min, _in);
+  out = __lsx_vmin_h(max, out);
+  return out;
+}
+
+/*
+ * =============================================================================
+ * Description : Set each element of vector between 0 and 255
+ * Arguments   : Inputs  - _in
+ *               Outputs - out
+ *               Return Type - halfword
+ * Details     : Signed byte elements from _in are clamped between 0 and 255.
+ * Example     : out = __lsx_vclip255_h(_in)
+ *         _in : -8,255,280,249, -8,255,280,249
+ *         out : 0,255,255,249, 0,255,255,249
+ * =============================================================================
+ */
+static inline __m128i __lsx_vclip255_h(__m128i _in) {
+  __m128i out;
+
+  out = __lsx_vmaxi_h(_in, 0);
+  out = __lsx_vsat_hu(out, 7);
+  return out;
+}
+
+/*
+ * =============================================================================
+ * Description : Set each element of vector between 0 and 255
+ * Arguments   : Inputs  - _in
+ *               Outputs - out
+ *               Return Type - word
+ * Details     : Signed byte elements from _in are clamped between 0 and 255.
+ * Example     : out = __lsx_vclip255_w(_in)
+ *         _in : -8,255,280,249
+ *         out : 0,255,255,249
+ * =============================================================================
+ */
+static inline __m128i __lsx_vclip255_w(__m128i _in) {
+  __m128i out;
+
+  out = __lsx_vmaxi_w(_in, 0);
+  out = __lsx_vsat_wu(out, 7);
+  return out;
+}
+
+/*
+ * =============================================================================
+ * Description : Swap two variables
+ * Arguments   : Inputs  - _in0, _in1
+ *               Outputs - _in0, _in1 (in-place)
+ * Details     : Swapping of two input variables using xor
+ * Example     : LSX_SWAP(_in0, _in1)
+ *        _in0 : 1,2,3,4
+ *        _in1 : 5,6,7,8
+ *   _in0(out) : 5,6,7,8
+ *   _in1(out) : 1,2,3,4
+ * =============================================================================
+ */
+#define LSX_SWAP(_in0, _in1)         \
+  {                                  \
+    _in0 = __lsx_vxor_v(_in0, _in1); \
+    _in1 = __lsx_vxor_v(_in0, _in1); \
+    _in0 = __lsx_vxor_v(_in0, _in1); \
+  }
+
+/*
+ * =============================================================================
+ * Description : Transpose 4x4 block with word elements in vectors
+ * Arguments   : Inputs  - in0, in1, in2, in3
+ *               Outputs - out0, out1, out2, out3
+ * Details     :
+ * Example     :
+ *               1, 2, 3, 4            1, 5, 9,13
+ *               5, 6, 7, 8    to      2, 6,10,14
+ *               9,10,11,12  =====>    3, 7,11,15
+ *              13,14,15,16            4, 8,12,16
+ * =============================================================================
+ */
+#define LSX_TRANSPOSE4x4_W(_in0, _in1, _in2, _in3, _out0, _out1, _out2, _out3) \
+  {                                                                            \
+    __m128i _t0, _t1, _t2, _t3;                                                \
+                                                                               \
+    _t0 = __lsx_vilvl_w(_in1, _in0);                                           \
+    _t1 = __lsx_vilvh_w(_in1, _in0);                                           \
+    _t2 = __lsx_vilvl_w(_in3, _in2);                                           \
+    _t3 = __lsx_vilvh_w(_in3, _in2);                                           \
+    _out0 = __lsx_vilvl_d(_t2, _t0);                                           \
+    _out1 = __lsx_vilvh_d(_t2, _t0);                                           \
+    _out2 = __lsx_vilvl_d(_t3, _t1);                                           \
+    _out3 = __lsx_vilvh_d(_t3, _t1);                                           \
+  }
+
+/*
+ * =============================================================================
+ * Description : Transpose 8x8 block with byte elements in vectors
+ * Arguments   : Inputs  - _in0, _in1, _in2, _in3, _in4, _in5, _in6, _in7
+ *               Outputs - _out0, _out1, _out2, _out3, _out4, _out5, _out6,
+ *               _out7
+ * Details     : The rows of the matrix become columns, and the columns
+ *               become rows.
+ * Example     : LSX_TRANSPOSE8x8_B
+ *        _in0 : 00,01,02,03,04,05,06,07, 00,00,00,00,00,00,00,00
+ *        _in1 : 10,11,12,13,14,15,16,17, 00,00,00,00,00,00,00,00
+ *        _in2 : 20,21,22,23,24,25,26,27, 00,00,00,00,00,00,00,00
+ *        _in3 : 30,31,32,33,34,35,36,37, 00,00,00,00,00,00,00,00
+ *        _in4 : 40,41,42,43,44,45,46,47, 00,00,00,00,00,00,00,00
+ *        _in5 : 50,51,52,53,54,55,56,57, 00,00,00,00,00,00,00,00
+ *        _in6 : 60,61,62,63,64,65,66,67, 00,00,00,00,00,00,00,00
+ *        _in7 : 70,71,72,73,74,75,76,77, 00,00,00,00,00,00,00,00
+ *
+ *      _ out0 : 00,10,20,30,40,50,60,70, 00,00,00,00,00,00,00,00
+ *      _ out1 : 01,11,21,31,41,51,61,71, 00,00,00,00,00,00,00,00
+ *      _ out2 : 02,12,22,32,42,52,62,72, 00,00,00,00,00,00,00,00
+ *      _ out3 : 03,13,23,33,43,53,63,73, 00,00,00,00,00,00,00,00
+ *      _ out4 : 04,14,24,34,44,54,64,74, 00,00,00,00,00,00,00,00
+ *      _ out5 : 05,15,25,35,45,55,65,75, 00,00,00,00,00,00,00,00
+ *      _ out6 : 06,16,26,36,46,56,66,76, 00,00,00,00,00,00,00,00
+ *      _ out7 : 07,17,27,37,47,57,67,77, 00,00,00,00,00,00,00,00
+ * =============================================================================
+ */
+#define LSX_TRANSPOSE8x8_B(_in0, _in1, _in2, _in3, _in4, _in5, _in6, _in7,  \
+                           _out0, _out1, _out2, _out3, _out4, _out5, _out6, \
+                           _out7)                                           \
+  {                                                                         \
+    __m128i zero = {0};                                                     \
+    __m128i shuf8 = {0x0F0E0D0C0B0A0908, 0x1716151413121110};               \
+    __m128i _t0, _t1, _t2, _t3, _t4, _t5, _t6, _t7;                         \
+                                                                            \
+    _t0 = __lsx_vilvl_b(_in2, _in0);                                        \
+    _t1 = __lsx_vilvl_b(_in3, _in1);                                        \
+    _t2 = __lsx_vilvl_b(_in6, _in4);                                        \
+    _t3 = __lsx_vilvl_b(_in7, _in5);                                        \
+    _t4 = __lsx_vilvl_b(_t1, _t0);                                          \
+    _t5 = __lsx_vilvh_b(_t1, _t0);                                          \
+    _t6 = __lsx_vilvl_b(_t3, _t2);                                          \
+    _t7 = __lsx_vilvh_b(_t3, _t2);                                          \
+    _out0 = __lsx_vilvl_w(_t6, _t4);                                        \
+    _out2 = __lsx_vilvh_w(_t6, _t4);                                        \
+    _out4 = __lsx_vilvl_w(_t7, _t5);                                        \
+    _out6 = __lsx_vilvh_w(_t7, _t5);                                        \
+    _out1 = __lsx_vshuf_b(zero, _out0, shuf8);                              \
+    _out3 = __lsx_vshuf_b(zero, _out2, shuf8);                              \
+    _out5 = __lsx_vshuf_b(zero, _out4, shuf8);                              \
+    _out7 = __lsx_vshuf_b(zero, _out6, shuf8);                              \
+  }
+
+/*
+ * =============================================================================
+ * Description : Transpose 8x8 block with half-word elements in vectors
+ * Arguments   : Inputs  - in0, in1, in2, in3, in4, in5, in6, in7
+ *               Outputs - out0, out1, out2, out3, out4, out5, out6, out7
+ * Details     :
+ * Example     :
+ *              00,01,02,03,04,05,06,07           00,10,20,30,40,50,60,70
+ *              10,11,12,13,14,15,16,17           01,11,21,31,41,51,61,71
+ *              20,21,22,23,24,25,26,27           02,12,22,32,42,52,62,72
+ *              30,31,32,33,34,35,36,37    to     03,13,23,33,43,53,63,73
+ *              40,41,42,43,44,45,46,47  ======>  04,14,24,34,44,54,64,74
+ *              50,51,52,53,54,55,56,57           05,15,25,35,45,55,65,75
+ *              60,61,62,63,64,65,66,67           06,16,26,36,46,56,66,76
+ *              70,71,72,73,74,75,76,77           07,17,27,37,47,57,67,77
+ * =============================================================================
+ */
+#define LSX_TRANSPOSE8x8_H(_in0, _in1, _in2, _in3, _in4, _in5, _in6, _in7,  \
+                           _out0, _out1, _out2, _out3, _out4, _out5, _out6, \
+                           _out7)                                           \
+  {                                                                         \
+    __m128i _s0, _s1, _t0, _t1, _t2, _t3, _t4, _t5, _t6, _t7;               \
+                                                                            \
+    _s0 = __lsx_vilvl_h(_in6, _in4);                                        \
+    _s1 = __lsx_vilvl_h(_in7, _in5);                                        \
+    _t0 = __lsx_vilvl_h(_s1, _s0);                                          \
+    _t1 = __lsx_vilvh_h(_s1, _s0);                                          \
+    _s0 = __lsx_vilvh_h(_in6, _in4);                                        \
+    _s1 = __lsx_vilvh_h(_in7, _in5);                                        \
+    _t2 = __lsx_vilvl_h(_s1, _s0);                                          \
+    _t3 = __lsx_vilvh_h(_s1, _s0);                                          \
+    _s0 = __lsx_vilvl_h(_in2, _in0);                                        \
+    _s1 = __lsx_vilvl_h(_in3, _in1);                                        \
+    _t4 = __lsx_vilvl_h(_s1, _s0);                                          \
+    _t5 = __lsx_vilvh_h(_s1, _s0);                                          \
+    _s0 = __lsx_vilvh_h(_in2, _in0);                                        \
+    _s1 = __lsx_vilvh_h(_in3, _in1);                                        \
+    _t6 = __lsx_vilvl_h(_s1, _s0);                                          \
+    _t7 = __lsx_vilvh_h(_s1, _s0);                                          \
+                                                                            \
+    _out0 = __lsx_vpickev_d(_t0, _t4);                                      \
+    _out2 = __lsx_vpickev_d(_t1, _t5);                                      \
+    _out4 = __lsx_vpickev_d(_t2, _t6);                                      \
+    _out6 = __lsx_vpickev_d(_t3, _t7);                                      \
+    _out1 = __lsx_vpickod_d(_t0, _t4);                                      \
+    _out3 = __lsx_vpickod_d(_t1, _t5);                                      \
+    _out5 = __lsx_vpickod_d(_t2, _t6);                                      \
+    _out7 = __lsx_vpickod_d(_t3, _t7);                                      \
+  }
+
+/*
+ * =============================================================================
+ * Description : Transpose input 8x4 byte block into 4x8
+ * Arguments   : Inputs  - _in0, _in1, _in2, _in3      (input 8x4 byte block)
+ *               Outputs - _out0, _out1, _out2, _out3  (output 4x8 byte block)
+ *               Return Type - as per RTYPE
+ * Details     : The rows of the matrix become columns, and the columns become
+ *               rows.
+ * Example     : LSX_TRANSPOSE8x4_B
+ *        _in0 : 00,01,02,03,00,00,00,00, 00,00,00,00,00,00,00,00
+ *        _in1 : 10,11,12,13,00,00,00,00, 00,00,00,00,00,00,00,00
+ *        _in2 : 20,21,22,23,00,00,00,00, 00,00,00,00,00,00,00,00
+ *        _in3 : 30,31,32,33,00,00,00,00, 00,00,00,00,00,00,00,00
+ *        _in4 : 40,41,42,43,00,00,00,00, 00,00,00,00,00,00,00,00
+ *        _in5 : 50,51,52,53,00,00,00,00, 00,00,00,00,00,00,00,00
+ *        _in6 : 60,61,62,63,00,00,00,00, 00,00,00,00,00,00,00,00
+ *        _in7 : 70,71,72,73,00,00,00,00, 00,00,00,00,00,00,00,00
+ *
+ *       _out0 : 00,10,20,30,40,50,60,70, 00,00,00,00,00,00,00,00
+ *       _out1 : 01,11,21,31,41,51,61,71, 00,00,00,00,00,00,00,00
+ *       _out2 : 02,12,22,32,42,52,62,72, 00,00,00,00,00,00,00,00
+ *       _out3 : 03,13,23,33,43,53,63,73, 00,00,00,00,00,00,00,00
+ * =============================================================================
+ */
+#define LSX_TRANSPOSE8x4_B(_in0, _in1, _in2, _in3, _in4, _in5, _in6, _in7, \
+                           _out0, _out1, _out2, _out3)                     \
+  {                                                                        \
+    __m128i _tmp0_m, _tmp1_m, _tmp2_m, _tmp3_m;                            \
+                                                                           \
+    _tmp0_m = __lsx_vpackev_w(_in4, _in0);                                 \
+    _tmp1_m = __lsx_vpackev_w(_in5, _in1);                                 \
+    _tmp2_m = __lsx_vilvl_b(_tmp1_m, _tmp0_m);                             \
+    _tmp0_m = __lsx_vpackev_w(_in6, _in2);                                 \
+    _tmp1_m = __lsx_vpackev_w(_in7, _in3);                                 \
+                                                                           \
+    _tmp3_m = __lsx_vilvl_b(_tmp1_m, _tmp0_m);                             \
+    _tmp0_m = __lsx_vilvl_h(_tmp3_m, _tmp2_m);                             \
+    _tmp1_m = __lsx_vilvh_h(_tmp3_m, _tmp2_m);                             \
+                                                                           \
+    _out0 = __lsx_vilvl_w(_tmp1_m, _tmp0_m);                               \
+    _out2 = __lsx_vilvh_w(_tmp1_m, _tmp0_m);                               \
+    _out1 = __lsx_vilvh_d(_out2, _out0);                                   \
+    _out3 = __lsx_vilvh_d(_out0, _out2);                                   \
+  }
+
+/*
+ * =============================================================================
+ * Description : Transpose 16x8 block with byte elements in vectors
+ * Arguments   : Inputs  - in0, in1, in2, in3, in4, in5, in6, in7, in8
+ *                         in9, in10, in11, in12, in13, in14, in15
+ *               Outputs - out0, out1, out2, out3, out4, out5, out6, out7
+ * Details     :
+ * Example     :
+ *              000,001,002,003,004,005,006,007
+ *              008,009,010,011,012,013,014,015
+ *              016,017,018,019,020,021,022,023
+ *              024,025,026,027,028,029,030,031
+ *              032,033,034,035,036,037,038,039
+ *              040,041,042,043,044,045,046,047        000,008,...,112,120
+ *              048,049,050,051,052,053,054,055        001,009,...,113,121
+ *              056,057,058,059,060,061,062,063   to   002,010,...,114,122
+ *              064,068,066,067,068,069,070,071 =====> 003,011,...,115,123
+ *              072,073,074,075,076,077,078,079        004,012,...,116,124
+ *              080,081,082,083,084,085,086,087        005,013,...,117,125
+ *              088,089,090,091,092,093,094,095        006,014,...,118,126
+ *              096,097,098,099,100,101,102,103        007,015,...,119,127
+ *              104,105,106,107,108,109,110,111
+ *              112,113,114,115,116,117,118,119
+ *              120,121,122,123,124,125,126,127
+ * =============================================================================
+ */
+#define LSX_TRANSPOSE16x8_B(_in0, _in1, _in2, _in3, _in4, _in5, _in6, _in7,  \
+                            _in8, _in9, _in10, _in11, _in12, _in13, _in14,   \
+                            _in15, _out0, _out1, _out2, _out3, _out4, _out5, \
+                            _out6, _out7)                                    \
+  {                                                                          \
+    __m128i _tmp0, _tmp1, _tmp2, _tmp3, _tmp4, _tmp5, _tmp6, _tmp7;          \
+    __m128i _t0, _t1, _t2, _t3, _t4, _t5, _t6, _t7;                          \
+    DUP4_ARG2(__lsx_vilvl_b, _in2, _in0, _in3, _in1, _in6, _in4, _in7, _in5, \
+              _tmp0, _tmp1, _tmp2, _tmp3);                                   \
+    DUP4_ARG2(__lsx_vilvl_b, _in10, _in8, _in11, _in9, _in14, _in12, _in15,  \
+              _in13, _tmp4, _tmp5, _tmp6, _tmp7);                            \
+    DUP2_ARG2(__lsx_vilvl_b, _tmp1, _tmp0, _tmp3, _tmp2, _t0, _t2);          \
+    DUP2_ARG2(__lsx_vilvh_b, _tmp1, _tmp0, _tmp3, _tmp2, _t1, _t3);          \
+    DUP2_ARG2(__lsx_vilvl_b, _tmp5, _tmp4, _tmp7, _tmp6, _t4, _t6);          \
+    DUP2_ARG2(__lsx_vilvh_b, _tmp5, _tmp4, _tmp7, _tmp6, _t5, _t7);          \
+    DUP2_ARG2(__lsx_vilvl_w, _t2, _t0, _t3, _t1, _tmp0, _tmp4);              \
+    DUP2_ARG2(__lsx_vilvh_w, _t2, _t0, _t3, _t1, _tmp2, _tmp6);              \
+    DUP2_ARG2(__lsx_vilvl_w, _t6, _t4, _t7, _t5, _tmp1, _tmp5);              \
+    DUP2_ARG2(__lsx_vilvh_w, _t6, _t4, _t7, _t5, _tmp3, _tmp7);              \
+    DUP2_ARG2(__lsx_vilvl_d, _tmp1, _tmp0, _tmp3, _tmp2, _out0, _out2);      \
+    DUP2_ARG2(__lsx_vilvh_d, _tmp1, _tmp0, _tmp3, _tmp2, _out1, _out3);      \
+    DUP2_ARG2(__lsx_vilvl_d, _tmp5, _tmp4, _tmp7, _tmp6, _out4, _out6);      \
+    DUP2_ARG2(__lsx_vilvh_d, _tmp5, _tmp4, _tmp7, _tmp6, _out5, _out7);      \
+  }
+
+/*
+ * =============================================================================
+ * Description : Butterfly of 4 input vectors
+ * Arguments   : Inputs  - in0, in1, in2, in3
+ *               Outputs - out0, out1, out2, out3
+ * Details     : Butterfly operation
+ * Example     :
+ *               out0 = in0 + in3;
+ *               out1 = in1 + in2;
+ *               out2 = in1 - in2;
+ *               out3 = in0 - in3;
+ * =============================================================================
+ */
+#define LSX_BUTTERFLY_4_B(_in0, _in1, _in2, _in3, _out0, _out1, _out2, _out3) \
+  {                                                                           \
+    _out0 = __lsx_vadd_b(_in0, _in3);                                         \
+    _out1 = __lsx_vadd_b(_in1, _in2);                                         \
+    _out2 = __lsx_vsub_b(_in1, _in2);                                         \
+    _out3 = __lsx_vsub_b(_in0, _in3);                                         \
+  }
+#define LSX_BUTTERFLY_4_H(_in0, _in1, _in2, _in3, _out0, _out1, _out2, _out3) \
+  {                                                                           \
+    _out0 = __lsx_vadd_h(_in0, _in3);                                         \
+    _out1 = __lsx_vadd_h(_in1, _in2);                                         \
+    _out2 = __lsx_vsub_h(_in1, _in2);                                         \
+    _out3 = __lsx_vsub_h(_in0, _in3);                                         \
+  }
+#define LSX_BUTTERFLY_4_W(_in0, _in1, _in2, _in3, _out0, _out1, _out2, _out3) \
+  {                                                                           \
+    _out0 = __lsx_vadd_w(_in0, _in3);                                         \
+    _out1 = __lsx_vadd_w(_in1, _in2);                                         \
+    _out2 = __lsx_vsub_w(_in1, _in2);                                         \
+    _out3 = __lsx_vsub_w(_in0, _in3);                                         \
+  }
+#define LSX_BUTTERFLY_4_D(_in0, _in1, _in2, _in3, _out0, _out1, _out2, _out3) \
+  {                                                                           \
+    _out0 = __lsx_vadd_d(_in0, _in3);                                         \
+    _out1 = __lsx_vadd_d(_in1, _in2);                                         \
+    _out2 = __lsx_vsub_d(_in1, _in2);                                         \
+    _out3 = __lsx_vsub_d(_in0, _in3);                                         \
+  }
+
+/*
+ * =============================================================================
+ * Description : Butterfly of 8 input vectors
+ * Arguments   : Inputs  - _in0, _in1, _in2, _in3, ~
+ *               Outputs - _out0, _out1, _out2, _out3, ~
+ * Details     : Butterfly operation
+ * Example     :
+ *              _out0 = _in0 + _in7;
+ *              _out1 = _in1 + _in6;
+ *              _out2 = _in2 + _in5;
+ *              _out3 = _in3 + _in4;
+ *              _out4 = _in3 - _in4;
+ *              _out5 = _in2 - _in5;
+ *              _out6 = _in1 - _in6;
+ *              _out7 = _in0 - _in7;
+ * =============================================================================
+ */
+#define LSX_BUTTERFLY_8_B(_in0, _in1, _in2, _in3, _in4, _in5, _in6, _in7,  \
+                          _out0, _out1, _out2, _out3, _out4, _out5, _out6, \
+                          _out7)                                           \
+  {                                                                        \
+    _out0 = __lsx_vadd_b(_in0, _in7);                                      \
+    _out1 = __lsx_vadd_b(_in1, _in6);                                      \
+    _out2 = __lsx_vadd_b(_in2, _in5);                                      \
+    _out3 = __lsx_vadd_b(_in3, _in4);                                      \
+    _out4 = __lsx_vsub_b(_in3, _in4);                                      \
+    _out5 = __lsx_vsub_b(_in2, _in5);                                      \
+    _out6 = __lsx_vsub_b(_in1, _in6);                                      \
+    _out7 = __lsx_vsub_b(_in0, _in7);                                      \
+  }
+
+#define LSX_BUTTERFLY_8_H(_in0, _in1, _in2, _in3, _in4, _in5, _in6, _in7,  \
+                          _out0, _out1, _out2, _out3, _out4, _out5, _out6, \
+                          _out7)                                           \
+  {                                                                        \
+    _out0 = __lsx_vadd_h(_in0, _in7);                                      \
+    _out1 = __lsx_vadd_h(_in1, _in6);                                      \
+    _out2 = __lsx_vadd_h(_in2, _in5);                                      \
+    _out3 = __lsx_vadd_h(_in3, _in4);                                      \
+    _out4 = __lsx_vsub_h(_in3, _in4);                                      \
+    _out5 = __lsx_vsub_h(_in2, _in5);                                      \
+    _out6 = __lsx_vsub_h(_in1, _in6);                                      \
+    _out7 = __lsx_vsub_h(_in0, _in7);                                      \
+  }
+
+#define LSX_BUTTERFLY_8_W(_in0, _in1, _in2, _in3, _in4, _in5, _in6, _in7,  \
+                          _out0, _out1, _out2, _out3, _out4, _out5, _out6, \
+                          _out7)                                           \
+  {                                                                        \
+    _out0 = __lsx_vadd_w(_in0, _in7);                                      \
+    _out1 = __lsx_vadd_w(_in1, _in6);                                      \
+    _out2 = __lsx_vadd_w(_in2, _in5);                                      \
+    _out3 = __lsx_vadd_w(_in3, _in4);                                      \
+    _out4 = __lsx_vsub_w(_in3, _in4);                                      \
+    _out5 = __lsx_vsub_w(_in2, _in5);                                      \
+    _out6 = __lsx_vsub_w(_in1, _in6);                                      \
+    _out7 = __lsx_vsub_w(_in0, _in7);                                      \
+  }
+
+#define LSX_BUTTERFLY_8_D(_in0, _in1, _in2, _in3, _in4, _in5, _in6, _in7,  \
+                          _out0, _out1, _out2, _out3, _out4, _out5, _out6, \
+                          _out7)                                           \
+  {                                                                        \
+    _out0 = __lsx_vadd_d(_in0, _in7);                                      \
+    _out1 = __lsx_vadd_d(_in1, _in6);                                      \
+    _out2 = __lsx_vadd_d(_in2, _in5);                                      \
+    _out3 = __lsx_vadd_d(_in3, _in4);                                      \
+    _out4 = __lsx_vsub_d(_in3, _in4);                                      \
+    _out5 = __lsx_vsub_d(_in2, _in5);                                      \
+    _out6 = __lsx_vsub_d(_in1, _in6);                                      \
+    _out7 = __lsx_vsub_d(_in0, _in7);                                      \
+  }
+
+#endif  // LSX
+
+#ifdef __loongarch_asx
+#include <lasxintrin.h>
+/*
+ * =============================================================================
+ * Description : Dot product of byte vector elements
+ * Arguments   : Inputs - in_h, in_l
+ *               Output - out
+ *               Return Type - signed halfword
+ * Details     : Unsigned byte elements from in_h are multiplied with
+ *               unsigned byte elements from in_l producing a result
+ *               twice the size of input i.e. signed halfword.
+ *               Then this multiplied results of adjacent odd-even elements
+ *               are added to the out vector
+ * Example     : See out = __lasx_xvdp2_w_h(in_h, in_l)
+ * =============================================================================
+ */
+static inline __m256i __lasx_xvdp2_h_bu(__m256i in_h, __m256i in_l) {
+  __m256i out;
+
+  out = __lasx_xvmulwev_h_bu(in_h, in_l);
+  out = __lasx_xvmaddwod_h_bu(out, in_h, in_l);
+  return out;
+}
+
+/*
+ * =============================================================================
+ * Description : Dot product of byte vector elements
+ * Arguments   : Inputs - in_h, in_l
+ *               Output - out
+ *               Return Type - signed halfword
+ * Details     : Signed byte elements from in_h are multiplied with
+ *               signed byte elements from in_l producing a result
+ *               twice the size of input i.e. signed halfword.
+ *               Then this multiplication results of adjacent odd-even elements
+ *               are added to the out vector
+ * Example     : See out = __lasx_xvdp2_w_h(in_h, in_l)
+ * =============================================================================
+ */
+static inline __m256i __lasx_xvdp2_h_b(__m256i in_h, __m256i in_l) {
+  __m256i out;
+
+  out = __lasx_xvmulwev_h_b(in_h, in_l);
+  out = __lasx_xvmaddwod_h_b(out, in_h, in_l);
+  return out;
+}
+
+/*
+ * =============================================================================
+ * Description : Dot product of halfword vector elements
+ * Arguments   : Inputs - in_h, in_l
+ *               Output - out
+ *               Return Type - signed word
+ * Details     : Signed halfword elements from in_h are multiplied with
+ *               signed halfword elements from in_l producing a result
+ *               twice the size of input i.e. signed word.
+ *               Then this multiplied results of adjacent odd-even elements
+ *               are added to the out vector.
+ * Example     : out = __lasx_xvdp2_w_h(in_h, in_l)
+ *        in_h : 1,2,3,4, 5,6,7,8, 1,2,3,4, 5,6,7,8
+ *        in_l : 8,7,6,5, 4,3,2,1, 8,7,6,5, 4,3,2,1
+ *         out : 22,38,38,22, 22,38,38,22
+ * =============================================================================
+ */
+static inline __m256i __lasx_xvdp2_w_h(__m256i in_h, __m256i in_l) {
+  __m256i out;
+
+  out = __lasx_xvmulwev_w_h(in_h, in_l);
+  out = __lasx_xvmaddwod_w_h(out, in_h, in_l);
+  return out;
+}
+
+/*
+ * =============================================================================
+ * Description : Dot product of word vector elements
+ * Arguments   : Inputs - in_h, in_l
+ *               Output - out
+ *               Return Type - signed double
+ * Details     : Signed word elements from in_h are multiplied with
+ *               signed word elements from in_l producing a result
+ *               twice the size of input i.e. signed double-word.
+ *               Then this multiplied results of adjacent odd-even elements
+ *               are added to the out vector.
+ * Example     : See out = __lasx_xvdp2_w_h(in_h, in_l)
+ * =============================================================================
+ */
+static inline __m256i __lasx_xvdp2_d_w(__m256i in_h, __m256i in_l) {
+  __m256i out;
+
+  out = __lasx_xvmulwev_d_w(in_h, in_l);
+  out = __lasx_xvmaddwod_d_w(out, in_h, in_l);
+  return out;
+}
+
+/*
+ * =============================================================================
+ * Description : Dot product of halfword vector elements
+ * Arguments   : Inputs - in_h, in_l
+ *               Output - out
+ *               Return Type - signed word
+ * Details     : Unsigned halfword elements from in_h are multiplied with
+ *               signed halfword elements from in_l producing a result
+ *               twice the size of input i.e. unsigned word.
+ *               Multiplication result of adjacent odd-even elements
+ *               are added to the out vector
+ * Example     : See out = __lasx_xvdp2_w_h(in_h, in_l)
+ * =============================================================================
+ */
+static inline __m256i __lasx_xvdp2_w_hu_h(__m256i in_h, __m256i in_l) {
+  __m256i out;
+
+  out = __lasx_xvmulwev_w_hu_h(in_h, in_l);
+  out = __lasx_xvmaddwod_w_hu_h(out, in_h, in_l);
+  return out;
+}
+
+/*
+ * =============================================================================
+ * Description : Dot product & addition of byte vector elements
+ * Arguments   : Inputs - in_h, in_l
+ *               Output - out
+ *               Return Type - halfword
+ * Details     : Signed byte elements from in_h are multiplied with
+ *               signed byte elements from in_l producing a result
+ *               twice the size of input i.e. signed halfword.
+ *               Then this multiplied results of adjacent odd-even elements
+ *               are added to the in_c vector.
+ * Example     : See out = __lasx_xvdp2add_w_h(in_c, in_h, in_l)
+ * =============================================================================
+ */
+static inline __m256i __lasx_xvdp2add_h_b(__m256i in_c,
+                                          __m256i in_h,
+                                          __m256i in_l) {
+  __m256i out;
+
+  out = __lasx_xvmaddwev_h_b(in_c, in_h, in_l);
+  out = __lasx_xvmaddwod_h_b(out, in_h, in_l);
+  return out;
+}
+
+/*
+ * =============================================================================
+ * Description : Dot product & addition of byte vector elements
+ * Arguments   : Inputs - in_h, in_l
+ *               Output - out
+ *               Return Type - halfword
+ * Details     : Unsigned byte elements from in_h are multiplied with
+ *               unsigned byte elements from in_l producing a result
+ *               twice the size of input i.e. signed halfword.
+ *               Then this multiplied results of adjacent odd-even elements
+ *               are added to the in_c vector.
+ * Example     : See out = __lasx_xvdp2add_w_h(in_c, in_h, in_l)
+ * =============================================================================
+ */
+static inline __m256i __lasx_xvdp2add_h_bu(__m256i in_c,
+                                           __m256i in_h,
+                                           __m256i in_l) {
+  __m256i out;
+
+  out = __lasx_xvmaddwev_h_bu(in_c, in_h, in_l);
+  out = __lasx_xvmaddwod_h_bu(out, in_h, in_l);
+  return out;
+}
+
+/*
+ * =============================================================================
+ * Description : Dot product & addition of byte vector elements
+ * Arguments   : Inputs - in_h, in_l
+ *               Output - out
+ *               Return Type - halfword
+ * Details     : Unsigned byte elements from in_h are multiplied with
+ *               signed byte elements from in_l producing a result
+ *               twice the size of input i.e. signed halfword.
+ *               Then this multiplied results of adjacent odd-even elements
+ *               are added to the in_c vector.
+ * Example     : See out = __lasx_xvdp2add_w_h(in_c, in_h, in_l)
+ * =============================================================================
+ */
+static inline __m256i __lasx_xvdp2add_h_bu_b(__m256i in_c,
+                                             __m256i in_h,
+                                             __m256i in_l) {
+  __m256i out;
+
+  out = __lasx_xvmaddwev_h_bu_b(in_c, in_h, in_l);
+  out = __lasx_xvmaddwod_h_bu_b(out, in_h, in_l);
+  return out;
+}
+
+/*
+ * =============================================================================
+ * Description : Dot product of halfword vector elements
+ * Arguments   : Inputs - in_c, in_h, in_l
+ *               Output - out
+ *               Return Type - per RTYPE
+ * Details     : Signed halfword elements from in_h are multiplied with
+ *               signed halfword elements from in_l producing a result
+ *               twice the size of input i.e. signed word.
+ *               Multiplication result of adjacent odd-even elements
+ *               are added to the in_c vector.
+ * Example     : out = __lasx_xvdp2add_w_h(in_c, in_h, in_l)
+ *        in_c : 1,2,3,4, 1,2,3,4
+ *        in_h : 1,2,3,4, 5,6,7,8, 1,2,3,4, 5,6,7,8,
+ *        in_l : 8,7,6,5, 4,3,2,1, 8,7,6,5, 4,3,2,1,
+ *         out : 23,40,41,26, 23,40,41,26
+ * =============================================================================
+ */
+static inline __m256i __lasx_xvdp2add_w_h(__m256i in_c,
+                                          __m256i in_h,
+                                          __m256i in_l) {
+  __m256i out;
+
+  out = __lasx_xvmaddwev_w_h(in_c, in_h, in_l);
+  out = __lasx_xvmaddwod_w_h(out, in_h, in_l);
+  return out;
+}
+
+/*
+ * =============================================================================
+ * Description : Dot product of halfword vector elements
+ * Arguments   : Inputs - in_c, in_h, in_l
+ *               Output - out
+ *               Return Type - signed word
+ * Details     : Unsigned halfword elements from in_h are multiplied with
+ *               unsigned halfword elements from in_l producing a result
+ *               twice the size of input i.e. signed word.
+ *               Multiplication result of adjacent odd-even elements
+ *               are added to the in_c vector.
+ * Example     : See out = __lasx_xvdp2add_w_h(in_c, in_h, in_l)
+ * =============================================================================
+ */
+static inline __m256i __lasx_xvdp2add_w_hu(__m256i in_c,
+                                           __m256i in_h,
+                                           __m256i in_l) {
+  __m256i out;
+
+  out = __lasx_xvmaddwev_w_hu(in_c, in_h, in_l);
+  out = __lasx_xvmaddwod_w_hu(out, in_h, in_l);
+  return out;
+}
+
+/*
+ * =============================================================================
+ * Description : Dot product of halfword vector elements
+ * Arguments   : Inputs - in_c, in_h, in_l
+ *               Output - out
+ *               Return Type - signed word
+ * Details     : Unsigned halfword elements from in_h are multiplied with
+ *               signed halfword elements from in_l producing a result
+ *               twice the size of input i.e. signed word.
+ *               Multiplication result of adjacent odd-even elements
+ *               are added to the in_c vector
+ * Example     : See out = __lasx_xvdp2add_w_h(in_c, in_h, in_l)
+ * =============================================================================
+ */
+static inline __m256i __lasx_xvdp2add_w_hu_h(__m256i in_c,
+                                             __m256i in_h,
+                                             __m256i in_l) {
+  __m256i out;
+
+  out = __lasx_xvmaddwev_w_hu_h(in_c, in_h, in_l);
+  out = __lasx_xvmaddwod_w_hu_h(out, in_h, in_l);
+  return out;
+}
+
+/*
+ * =============================================================================
+ * Description : Vector Unsigned Dot Product and Subtract
+ * Arguments   : Inputs - in_c, in_h, in_l
+ *               Output - out
+ *               Return Type - signed halfword
+ * Details     : Unsigned byte elements from in_h are multiplied with
+ *               unsigned byte elements from in_l producing a result
+ *               twice the size of input i.e. signed halfword.
+ *               Multiplication result of adjacent odd-even elements
+ *               are added together and subtracted from double width elements
+ *               in_c vector.
+ * Example     : See out = __lasx_xvdp2sub_w_h(in_c, in_h, in_l)
+ * =============================================================================
+ */
+static inline __m256i __lasx_xvdp2sub_h_bu(__m256i in_c,
+                                           __m256i in_h,
+                                           __m256i in_l) {
+  __m256i out;
+
+  out = __lasx_xvmulwev_h_bu(in_h, in_l);
+  out = __lasx_xvmaddwod_h_bu(out, in_h, in_l);
+  out = __lasx_xvsub_h(in_c, out);
+  return out;
+}
+
+/*
+ * =============================================================================
+ * Description : Vector Signed Dot Product and Subtract
+ * Arguments   : Inputs - in_c, in_h, in_l
+ *               Output - out
+ *               Return Type - signed word
+ * Details     : Signed halfword elements from in_h are multiplied with
+ *               Signed halfword elements from in_l producing a result
+ *               twice the size of input i.e. signed word.
+ *               Multiplication result of adjacent odd-even elements
+ *               are added together and subtracted from double width elements
+ *               in_c vector.
+ * Example     : out = __lasx_xvdp2sub_w_h(in_c, in_h, in_l)
+ *        in_c : 0,0,0,0, 0,0,0,0
+ *        in_h : 3,1,3,0, 0,0,0,1, 0,0,1,1, 0,0,0,1
+ *        in_l : 2,1,1,0, 1,0,0,0, 0,0,1,0, 1,0,0,1
+ *         out : -7,-3,0,0, 0,-1,0,-1
+ * =============================================================================
+ */
+static inline __m256i __lasx_xvdp2sub_w_h(__m256i in_c,
+                                          __m256i in_h,
+                                          __m256i in_l) {
+  __m256i out;
+
+  out = __lasx_xvmulwev_w_h(in_h, in_l);
+  out = __lasx_xvmaddwod_w_h(out, in_h, in_l);
+  out = __lasx_xvsub_w(in_c, out);
+  return out;
+}
+
+/*
+ * =============================================================================
+ * Description : Dot product of halfword vector elements
+ * Arguments   : Inputs - in_h, in_l
+ *               Output - out
+ *               Return Type - signed word
+ * Details     : Signed halfword elements from in_h are multiplied with
+ *               signed halfword elements from in_l producing a result
+ *               four times the size of input i.e. signed doubleword.
+ *               Then this multiplication results of four adjacent elements
+ *               are added together and stored to the out vector.
+ * Example     : out = __lasx_xvdp4_d_h(in_h, in_l)
+ *        in_h :  3,1,3,0, 0,0,0,1, 0,0,1,-1, 0,0,0,1
+ *        in_l : -2,1,1,0, 1,0,0,0, 0,0,1, 0, 1,0,0,1
+ *         out : -2,0,1,1
+ * =============================================================================
+ */
+static inline __m256i __lasx_xvdp4_d_h(__m256i in_h, __m256i in_l) {
+  __m256i out;
+
+  out = __lasx_xvmulwev_w_h(in_h, in_l);
+  out = __lasx_xvmaddwod_w_h(out, in_h, in_l);
+  out = __lasx_xvhaddw_d_w(out, out);
+  return out;
+}
+
+/*
+ * =============================================================================
+ * Description : The high half of the vector elements are expanded and
+ *               added after being doubled.
+ * Arguments   : Inputs - in_h, in_l
+ *               Output - out
+ * Details     : The in_h vector and the in_l vector are added after the
+ *               higher half of the two-fold sign extension (signed byte
+ *               to signed halfword) and stored to the out vector.
+ * Example     : See out = __lasx_xvaddwh_w_h(in_h, in_l)
+ * =============================================================================
+ */
+static inline __m256i __lasx_xvaddwh_h_b(__m256i in_h, __m256i in_l) {
+  __m256i out;
+
+  out = __lasx_xvilvh_b(in_h, in_l);
+  out = __lasx_xvhaddw_h_b(out, out);
+  return out;
+}
+
+/*
+ * =============================================================================
+ * Description : The high half of the vector elements are expanded and
+ *               added after being doubled.
+ * Arguments   : Inputs - in_h, in_l
+ *               Output - out
+ * Details     : The in_h vector and the in_l vector are added after the
+ *               higher half of the two-fold sign extension (signed halfword
+ *               to signed word) and stored to the out vector.
+ * Example     : out = __lasx_xvaddwh_w_h(in_h, in_l)
+ *        in_h : 3, 0,3,0, 0,0,0,-1, 0,0,1,-1, 0,0,0,1
+ *        in_l : 2,-1,1,2, 1,0,0, 0, 1,0,1, 0, 1,0,0,1
+ *         out : 1,0,0,-1, 1,0,0, 2
+ * =============================================================================
+ */
+static inline __m256i __lasx_xvaddwh_w_h(__m256i in_h, __m256i in_l) {
+  __m256i out;
+
+  out = __lasx_xvilvh_h(in_h, in_l);
+  out = __lasx_xvhaddw_w_h(out, out);
+  return out;
+}
+
+/*
+ * =============================================================================
+ * Description : The low half of the vector elements are expanded and
+ *               added after being doubled.
+ * Arguments   : Inputs - in_h, in_l
+ *               Output - out
+ * Details     : The in_h vector and the in_l vector are added after the
+ *               lower half of the two-fold sign extension (signed byte
+ *               to signed halfword) and stored to the out vector.
+ * Example     : See out = __lasx_xvaddwl_w_h(in_h, in_l)
+ * =============================================================================
+ */
+static inline __m256i __lasx_xvaddwl_h_b(__m256i in_h, __m256i in_l) {
+  __m256i out;
+
+  out = __lasx_xvilvl_b(in_h, in_l);
+  out = __lasx_xvhaddw_h_b(out, out);
+  return out;
+}
+
+/*
+ * =============================================================================
+ * Description : The low half of the vector elements are expanded and
+ *               added after being doubled.
+ * Arguments   : Inputs - in_h, in_l
+ *               Output - out
+ * Details     : The in_h vector and the in_l vector are added after the
+ *               lower half of the two-fold sign extension (signed halfword
+ *               to signed word) and stored to the out vector.
+ * Example     : out = __lasx_xvaddwl_w_h(in_h, in_l)
+ *        in_h : 3, 0,3,0, 0,0,0,-1, 0,0,1,-1, 0,0,0,1
+ *        in_l : 2,-1,1,2, 1,0,0, 0, 1,0,1, 0, 1,0,0,1
+ *         out : 5,-1,4,2, 1,0,2,-1
+ * =============================================================================
+ */
+static inline __m256i __lasx_xvaddwl_w_h(__m256i in_h, __m256i in_l) {
+  __m256i out;
+
+  out = __lasx_xvilvl_h(in_h, in_l);
+  out = __lasx_xvhaddw_w_h(out, out);
+  return out;
+}
+
+/*
+ * =============================================================================
+ * Description : The low half of the vector elements are expanded and
+ *               added after being doubled.
+ * Arguments   : Inputs - in_h, in_l
+ *               Output - out
+ * Details     : The out vector and the out vector are added after the
+ *               lower half of the two-fold zero extension (unsigned byte
+ *               to unsigned halfword) and stored to the out vector.
+ * Example     : See out = __lasx_xvaddwl_w_h(in_h, in_l)
+ * =============================================================================
+ */
+static inline __m256i __lasx_xvaddwl_h_bu(__m256i in_h, __m256i in_l) {
+  __m256i out;
+
+  out = __lasx_xvilvl_b(in_h, in_l);
+  out = __lasx_xvhaddw_hu_bu(out, out);
+  return out;
+}
+
+/*
+ * =============================================================================
+ * Description : The low half of the vector elements are expanded and
+ *               added after being doubled.
+ * Arguments   : Inputs - in_h, in_l
+ *               Output - out
+ * Details     : The in_l vector after double zero extension (unsigned byte to
+ *               signed halfword)，added to the in_h vector.
+ * Example     : See out = __lasx_xvaddw_w_w_h(in_h, in_l)
+ * =============================================================================
+ */
+static inline __m256i __lasx_xvaddw_h_h_bu(__m256i in_h, __m256i in_l) {
+  __m256i out;
+
+  out = __lasx_xvsllwil_hu_bu(in_l, 0);
+  out = __lasx_xvadd_h(in_h, out);
+  return out;
+}
+
+/*
+ * =============================================================================
+ * Description : The low half of the vector elements are expanded and
+ *               added after being doubled.
+ * Arguments   : Inputs - in_h, in_l
+ *               Output - out
+ * Details     : The in_l vector after double sign extension (signed halfword to
+ *               signed word), added to the in_h vector.
+ * Example     : out = __lasx_xvaddw_w_w_h(in_h, in_l)
+ *        in_h : 0, 1,0,0, -1,0,0,1,
+ *        in_l : 2,-1,1,2,  1,0,0,0, 0,0,1,0, 1,0,0,1,
+ *         out : 2, 0,1,2, -1,0,1,1,
+ * =============================================================================
+ */
+static inline __m256i __lasx_xvaddw_w_w_h(__m256i in_h, __m256i in_l) {
+  __m256i out;
+
+  out = __lasx_xvsllwil_w_h(in_l, 0);
+  out = __lasx_xvadd_w(in_h, out);
+  return out;
+}
+
+/*
+ * =============================================================================
+ * Description : Multiplication and addition calculation after expansion
+ *               of the lower half of the vector.
+ * Arguments   : Inputs - in_c, in_h, in_l
+ *               Output - out
+ * Details     : The in_h vector and the in_l vector are multiplied after
+ *               the lower half of the two-fold sign extension (signed halfword
+ *               to signed word), and the result is added to the vector in_c,
+ *               then stored to the out vector.
+ * Example     : out = __lasx_xvmaddwl_w_h(in_c, in_h, in_l)
+ *        in_c : 1,2,3,4, 5,6,7,8
+ *        in_h : 1,2,3,4, 1,2,3,4, 5,6,7,8, 5,6,7,8
+ *        in_l : 200, 300, 400, 500,  2000, 3000, 4000, 5000,
+ *              -200,-300,-400,-500, -2000,-3000,-4000,-5000
+ *         out : 201, 602,1203,2004, -995, -1794,-2793,-3992
+ * =============================================================================
+ */
+static inline __m256i __lasx_xvmaddwl_w_h(__m256i in_c,
+                                          __m256i in_h,
+                                          __m256i in_l) {
+  __m256i tmp0, tmp1, out;
+
+  tmp0 = __lasx_xvsllwil_w_h(in_h, 0);
+  tmp1 = __lasx_xvsllwil_w_h(in_l, 0);
+  tmp0 = __lasx_xvmul_w(tmp0, tmp1);
+  out = __lasx_xvadd_w(tmp0, in_c);
+  return out;
+}
+
+/*
+ * =============================================================================
+ * Description : Multiplication and addition calculation after expansion
+ *               of the higher half of the vector.
+ * Arguments   : Inputs - in_c, in_h, in_l
+ *               Output - out
+ * Details     : The in_h vector and the in_l vector are multiplied after
+ *               the higher half of the two-fold sign extension (signed
+ *               halfword to signed word), and the result is added to
+ *               the vector in_c, then stored to the out vector.
+ * Example     : See out = __lasx_xvmaddwl_w_h(in_c, in_h, in_l)
+ * =============================================================================
+ */
+static inline __m256i __lasx_xvmaddwh_w_h(__m256i in_c,
+                                          __m256i in_h,
+                                          __m256i in_l) {
+  __m256i tmp0, tmp1, out;
+
+  tmp0 = __lasx_xvilvh_h(in_h, in_h);
+  tmp1 = __lasx_xvilvh_h(in_l, in_l);
+  tmp0 = __lasx_xvmulwev_w_h(tmp0, tmp1);
+  out = __lasx_xvadd_w(tmp0, in_c);
+  return out;
+}
+
+/*
+ * =============================================================================
+ * Description : Multiplication calculation after expansion of the lower
+ *               half of the vector.
+ * Arguments   : Inputs - in_h, in_l
+ *               Output - out
+ * Details     : The in_h vector and the in_l vector are multiplied after
+ *               the lower half of the two-fold sign extension (signed
+ *               halfword to signed word), then stored to the out vector.
+ * Example     : out = __lasx_xvmulwl_w_h(in_h, in_l)
+ *        in_h : 3,-1,3,0, 0,0,0,-1, 0,0,1,-1, 0,0,0,1
+ *        in_l : 2,-1,1,2, 1,0,0, 0, 0,0,1, 0, 1,0,0,1
+ *         out : 6,1,3,0, 0,0,1,0
+ * =============================================================================
+ */
+static inline __m256i __lasx_xvmulwl_w_h(__m256i in_h, __m256i in_l) {
+  __m256i tmp0, tmp1, out;
+
+  tmp0 = __lasx_xvsllwil_w_h(in_h, 0);
+  tmp1 = __lasx_xvsllwil_w_h(in_l, 0);
+  out = __lasx_xvmul_w(tmp0, tmp1);
+  return out;
+}
+
+/*
+ * =============================================================================
+ * Description : Multiplication calculation after expansion of the lower
+ *               half of the vector.
+ * Arguments   : Inputs - in_h, in_l
+ *               Output - out
+ * Details     : The in_h vector and the in_l vector are multiplied after
+ *               the lower half of the two-fold sign extension (signed
+ *               halfword to signed word), then stored to the out vector.
+ * Example     : out = __lasx_xvmulwh_w_h(in_h, in_l)
+ *        in_h : 3,-1,3,0, 0,0,0,-1, 0,0,1,-1, 0,0,0,1
+ *        in_l : 2,-1,1,2, 1,0,0, 0, 0,0,1, 0, 1,0,0,1
+ *         out : 0,0,0,0, 0,0,0,1
+ * =============================================================================
+ */
+static inline __m256i __lasx_xvmulwh_w_h(__m256i in_h, __m256i in_l) {
+  __m256i tmp0, tmp1, out;
+
+  tmp0 = __lasx_xvilvh_h(in_h, in_h);
+  tmp1 = __lasx_xvilvh_h(in_l, in_l);
+  out = __lasx_xvmulwev_w_h(tmp0, tmp1);
+  return out;
+}
+
+/*
+ * =============================================================================
+ * Description : The low half of the vector elements are added to the high half
+ *               after being doubled, then saturated.
+ * Arguments   : Inputs - in_h, in_l
+ *               Output - out
+ * Details     : The in_h vector adds the in_l vector after the lower half of
+ *               the two-fold zero extension (unsigned byte to unsigned
+ *               halfword) and then saturated. The results are stored to the out
+ *               vector.
+ * Example     : out = __lasx_xvsaddw_hu_hu_bu(in_h, in_l)
+ *        in_h : 2,65532,1,2, 1,0,0,0, 0,0,1,0, 1,0,0,1
+ *        in_l : 3,6,3,0, 0,0,0,1, 0,0,1,1, 0,0,0,1, 3,18,3,0, 0,0,0,1, 0,0,1,1,
+ *               0,0,0,1
+ *        out  : 5,65535,4,2, 1,0,0,1, 3,18,4,0, 1,0,0,2,
+ * =============================================================================
+ */
+static inline __m256i __lasx_xvsaddw_hu_hu_bu(__m256i in_h, __m256i in_l) {
+  __m256i tmp1, out;
+  __m256i zero = {0};
+
+  tmp1 = __lasx_xvilvl_b(zero, in_l);
+  out = __lasx_xvsadd_hu(in_h, tmp1);
+  return out;
+}
+
+/*
+ * =============================================================================
+ * Description : Clip all halfword elements of input vector between min & max
+ *               out = ((in) < (min)) ? (min) : (((in) > (max)) ? (max) : (in))
+ * Arguments   : Inputs  - in    (input vector)
+ *                       - min   (min threshold)
+ *                       - max   (max threshold)
+ *               Outputs - in    (output vector with clipped elements)
+ *               Return Type - signed halfword
+ * Example     : out = __lasx_xvclip_h(in, min, max)
+ *          in : -8,2,280,249, -8,255,280,249, 4,4,4,4, 5,5,5,5
+ *         min : 1,1,1,1, 1,1,1,1, 1,1,1,1, 1,1,1,1
+ *         max : 9,9,9,9, 9,9,9,9, 9,9,9,9, 9,9,9,9
+ *         out : 1,2,9,9, 1,9,9,9, 4,4,4,4, 5,5,5,5
+ * =============================================================================
+ */
+static inline __m256i __lasx_xvclip_h(__m256i in, __m256i min, __m256i max) {
+  __m256i out;
+
+  out = __lasx_xvmax_h(min, in);
+  out = __lasx_xvmin_h(max, out);
+  return out;
+}
+
+/*
+ * =============================================================================
+ * Description : Clip all signed halfword elements of input vector
+ *               between 0 & 255
+ * Arguments   : Inputs  - in   (input vector)
+ *               Outputs - out  (output vector with clipped elements)
+ *               Return Type - signed halfword
+ * Example     : See out = __lasx_xvclip255_w(in)
+ * =============================================================================
+ */
+static inline __m256i __lasx_xvclip255_h(__m256i in) {
+  __m256i out;
+
+  out = __lasx_xvmaxi_h(in, 0);
+  out = __lasx_xvsat_hu(out, 7);
+  return out;
+}
+
+/*
+ * =============================================================================
+ * Description : Clip all signed word elements of input vector
+ *               between 0 & 255
+ * Arguments   : Inputs - in   (input vector)
+ *               Output - out  (output vector with clipped elements)
+ *               Return Type - signed word
+ * Example     : out = __lasx_xvclip255_w(in)
+ *          in : -8,255,280,249, -8,255,280,249
+ *         out :  0,255,255,249,  0,255,255,249
+ * =============================================================================
+ */
+static inline __m256i __lasx_xvclip255_w(__m256i in) {
+  __m256i out;
+
+  out = __lasx_xvmaxi_w(in, 0);
+  out = __lasx_xvsat_wu(out, 7);
+  return out;
+}
+
+/*
+ * =============================================================================
+ * Description : Indexed halfword element values are replicated to all
+ *               elements in output vector. If 'idx < 8' use xvsplati_l_*,
+ *               if 'idx >= 8' use xvsplati_h_*.
+ * Arguments   : Inputs - in, idx
+ *               Output - out
+ * Details     : Idx element value from in vector is replicated to all
+ *               elements in out vector.
+ *               Valid index range for halfword operation is 0-7
+ * Example     : out = __lasx_xvsplati_l_h(in, idx)
+ *          in : 20,10,11,12, 13,14,15,16, 0,0,2,0, 0,0,0,0
+ *         idx : 0x02
+ *         out : 11,11,11,11, 11,11,11,11, 11,11,11,11, 11,11,11,11
+ * =============================================================================
+ */
+static inline __m256i __lasx_xvsplati_l_h(__m256i in, int idx) {
+  __m256i out;
+
+  out = __lasx_xvpermi_q(in, in, 0x02);
+  out = __lasx_xvreplve_h(out, idx);
+  return out;
+}
+
+/*
+ * =============================================================================
+ * Description : Indexed halfword element values are replicated to all
+ *               elements in output vector. If 'idx < 8' use xvsplati_l_*,
+ *               if 'idx >= 8' use xvsplati_h_*.
+ * Arguments   : Inputs - in, idx
+ *               Output - out
+ * Details     : Idx element value from in vector is replicated to all
+ *               elements in out vector.
+ *               Valid index range for halfword operation is 0-7
+ * Example     : out = __lasx_xvsplati_h_h(in, idx)
+ *          in : 20,10,11,12, 13,14,15,16, 0,2,0,0, 0,0,0,0
+ *         idx : 0x09
+ *         out : 2,2,2,2, 2,2,2,2, 2,2,2,2, 2,2,2,2
+ * =============================================================================
+ */
+static inline __m256i __lasx_xvsplati_h_h(__m256i in, int idx) {
+  __m256i out;
+
+  out = __lasx_xvpermi_q(in, in, 0x13);
+  out = __lasx_xvreplve_h(out, idx);
+  return out;
+}
+
+/*
+ * =============================================================================
+ * Description : Transpose 4x4 block with double-word elements in vectors
+ * Arguments   : Inputs  - _in0, _in1, _in2, _in3
+ *               Outputs - _out0, _out1, _out2, _out3
+ * Example     : LASX_TRANSPOSE4x4_D
+ *        _in0 : 1,2,3,4
+ *        _in1 : 1,2,3,4
+ *        _in2 : 1,2,3,4
+ *        _in3 : 1,2,3,4
+ *
+ *       _out0 : 1,1,1,1
+ *       _out1 : 2,2,2,2
+ *       _out2 : 3,3,3,3
+ *       _out3 : 4,4,4,4
+ * =============================================================================
+ */
+#define LASX_TRANSPOSE4x4_D(_in0, _in1, _in2, _in3, _out0, _out1, _out2, \
+                            _out3)                                       \
+  {                                                                      \
+    __m256i _tmp0, _tmp1, _tmp2, _tmp3;                                  \
+    _tmp0 = __lasx_xvilvl_d(_in1, _in0);                                 \
+    _tmp1 = __lasx_xvilvh_d(_in1, _in0);                                 \
+    _tmp2 = __lasx_xvilvl_d(_in3, _in2);                                 \
+    _tmp3 = __lasx_xvilvh_d(_in3, _in2);                                 \
+    _out0 = __lasx_xvpermi_q(_tmp2, _tmp0, 0x20);                        \
+    _out2 = __lasx_xvpermi_q(_tmp2, _tmp0, 0x31);                        \
+    _out1 = __lasx_xvpermi_q(_tmp3, _tmp1, 0x20);                        \
+    _out3 = __lasx_xvpermi_q(_tmp3, _tmp1, 0x31);                        \
+  }
+
+/*
+ * =============================================================================
+ * Description : Transpose 8x8 block with word elements in vectors
+ * Arguments   : Inputs  - _in0, _in1, _in2, _in3, _in4, _in5, _in6, _in7
+ *               Outputs - _out0, _out1, _out2, _out3, _out4, _out5, _out6,
+ *               _out7
+ * Example     : LASX_TRANSPOSE8x8_W
+ *        _in0 : 1,2,3,4,5,6,7,8
+ *        _in1 : 2,2,3,4,5,6,7,8
+ *        _in2 : 3,2,3,4,5,6,7,8
+ *        _in3 : 4,2,3,4,5,6,7,8
+ *        _in4 : 5,2,3,4,5,6,7,8
+ *        _in5 : 6,2,3,4,5,6,7,8
+ *        _in6 : 7,2,3,4,5,6,7,8
+ *        _in7 : 8,2,3,4,5,6,7,8
+ *
+ *       _out0 : 1,2,3,4,5,6,7,8
+ *       _out1 : 2,2,2,2,2,2,2,2
+ *       _out2 : 3,3,3,3,3,3,3,3
+ *       _out3 : 4,4,4,4,4,4,4,4
+ *       _out4 : 5,5,5,5,5,5,5,5
+ *       _out5 : 6,6,6,6,6,6,6,6
+ *       _out6 : 7,7,7,7,7,7,7,7
+ *       _out7 : 8,8,8,8,8,8,8,8
+ * =============================================================================
+ */
+#define LASX_TRANSPOSE8x8_W(_in0, _in1, _in2, _in3, _in4, _in5, _in6, _in7,  \
+                            _out0, _out1, _out2, _out3, _out4, _out5, _out6, \
+                            _out7)                                           \
+  {                                                                          \
+    __m256i _s0_m, _s1_m;                                                    \
+    __m256i _tmp0_m, _tmp1_m, _tmp2_m, _tmp3_m;                              \
+    __m256i _tmp4_m, _tmp5_m, _tmp6_m, _tmp7_m;                              \
+                                                                             \
+    _s0_m = __lasx_xvilvl_w(_in2, _in0);                                     \
+    _s1_m = __lasx_xvilvl_w(_in3, _in1);                                     \
+    _tmp0_m = __lasx_xvilvl_w(_s1_m, _s0_m);                                 \
+    _tmp1_m = __lasx_xvilvh_w(_s1_m, _s0_m);                                 \
+    _s0_m = __lasx_xvilvh_w(_in2, _in0);                                     \
+    _s1_m = __lasx_xvilvh_w(_in3, _in1);                                     \
+    _tmp2_m = __lasx_xvilvl_w(_s1_m, _s0_m);                                 \
+    _tmp3_m = __lasx_xvilvh_w(_s1_m, _s0_m);                                 \
+    _s0_m = __lasx_xvilvl_w(_in6, _in4);                                     \
+    _s1_m = __lasx_xvilvl_w(_in7, _in5);                                     \
+    _tmp4_m = __lasx_xvilvl_w(_s1_m, _s0_m);                                 \
+    _tmp5_m = __lasx_xvilvh_w(_s1_m, _s0_m);                                 \
+    _s0_m = __lasx_xvilvh_w(_in6, _in4);                                     \
+    _s1_m = __lasx_xvilvh_w(_in7, _in5);                                     \
+    _tmp6_m = __lasx_xvilvl_w(_s1_m, _s0_m);                                 \
+    _tmp7_m = __lasx_xvilvh_w(_s1_m, _s0_m);                                 \
+    _out0 = __lasx_xvpermi_q(_tmp4_m, _tmp0_m, 0x20);                        \
+    _out1 = __lasx_xvpermi_q(_tmp5_m, _tmp1_m, 0x20);                        \
+    _out2 = __lasx_xvpermi_q(_tmp6_m, _tmp2_m, 0x20);                        \
+    _out3 = __lasx_xvpermi_q(_tmp7_m, _tmp3_m, 0x20);                        \
+    _out4 = __lasx_xvpermi_q(_tmp4_m, _tmp0_m, 0x31);                        \
+    _out5 = __lasx_xvpermi_q(_tmp5_m, _tmp1_m, 0x31);                        \
+    _out6 = __lasx_xvpermi_q(_tmp6_m, _tmp2_m, 0x31);                        \
+    _out7 = __lasx_xvpermi_q(_tmp7_m, _tmp3_m, 0x31);                        \
+  }
+
+/*
+ * =============================================================================
+ * Description : Transpose input 16x8 byte block
+ * Arguments   : Inputs  - _in0, _in1, _in2, _in3, _in4, _in5, _in6, _in7,
+ *                         _in8, _in9, _in10, _in11, _in12, _in13, _in14, _in15
+ *                         (input 16x8 byte block)
+ *               Outputs - _out0, _out1, _out2, _out3, _out4, _out5, _out6,
+ *                         _out7 (output 8x16 byte block)
+ * Details     : The rows of the matrix become columns, and the columns become
+ *               rows.
+ * Example     : See LASX_TRANSPOSE16x8_H
+ * =============================================================================
+ */
+#define LASX_TRANSPOSE16x8_B(_in0, _in1, _in2, _in3, _in4, _in5, _in6, _in7,  \
+                             _in8, _in9, _in10, _in11, _in12, _in13, _in14,   \
+                             _in15, _out0, _out1, _out2, _out3, _out4, _out5, \
+                             _out6, _out7)                                    \
+  {                                                                           \
+    __m256i _tmp0_m, _tmp1_m, _tmp2_m, _tmp3_m;                               \
+    __m256i _tmp4_m, _tmp5_m, _tmp6_m, _tmp7_m;                               \
+                                                                              \
+    _tmp0_m = __lasx_xvilvl_b(_in2, _in0);                                    \
+    _tmp1_m = __lasx_xvilvl_b(_in3, _in1);                                    \
+    _tmp2_m = __lasx_xvilvl_b(_in6, _in4);                                    \
+    _tmp3_m = __lasx_xvilvl_b(_in7, _in5);                                    \
+    _tmp4_m = __lasx_xvilvl_b(_in10, _in8);                                   \
+    _tmp5_m = __lasx_xvilvl_b(_in11, _in9);                                   \
+    _tmp6_m = __lasx_xvilvl_b(_in14, _in12);                                  \
+    _tmp7_m = __lasx_xvilvl_b(_in15, _in13);                                  \
+    _out0 = __lasx_xvilvl_b(_tmp1_m, _tmp0_m);                                \
+    _out1 = __lasx_xvilvh_b(_tmp1_m, _tmp0_m);                                \
+    _out2 = __lasx_xvilvl_b(_tmp3_m, _tmp2_m);                                \
+    _out3 = __lasx_xvilvh_b(_tmp3_m, _tmp2_m);                                \
+    _out4 = __lasx_xvilvl_b(_tmp5_m, _tmp4_m);                                \
+    _out5 = __lasx_xvilvh_b(_tmp5_m, _tmp4_m);                                \
+    _out6 = __lasx_xvilvl_b(_tmp7_m, _tmp6_m);                                \
+    _out7 = __lasx_xvilvh_b(_tmp7_m, _tmp6_m);                                \
+    _tmp0_m = __lasx_xvilvl_w(_out2, _out0);                                  \
+    _tmp2_m = __lasx_xvilvh_w(_out2, _out0);                                  \
+    _tmp4_m = __lasx_xvilvl_w(_out3, _out1);                                  \
+    _tmp6_m = __lasx_xvilvh_w(_out3, _out1);                                  \
+    _tmp1_m = __lasx_xvilvl_w(_out6, _out4);                                  \
+    _tmp3_m = __lasx_xvilvh_w(_out6, _out4);                                  \
+    _tmp5_m = __lasx_xvilvl_w(_out7, _out5);                                  \
+    _tmp7_m = __lasx_xvilvh_w(_out7, _out5);                                  \
+    _out0 = __lasx_xvilvl_d(_tmp1_m, _tmp0_m);                                \
+    _out1 = __lasx_xvilvh_d(_tmp1_m, _tmp0_m);                                \
+    _out2 = __lasx_xvilvl_d(_tmp3_m, _tmp2_m);                                \
+    _out3 = __lasx_xvilvh_d(_tmp3_m, _tmp2_m);                                \
+    _out4 = __lasx_xvilvl_d(_tmp5_m, _tmp4_m);                                \
+    _out5 = __lasx_xvilvh_d(_tmp5_m, _tmp4_m);                                \
+    _out6 = __lasx_xvilvl_d(_tmp7_m, _tmp6_m);                                \
+    _out7 = __lasx_xvilvh_d(_tmp7_m, _tmp6_m);                                \
+  }
+
+/*
+ * =============================================================================
+ * Description : Transpose input 16x8 byte block
+ * Arguments   : Inputs  - _in0, _in1, _in2, _in3, _in4, _in5, _in6, _in7,
+ *                         _in8, _in9, _in10, _in11, _in12, _in13, _in14, _in15
+ *                         (input 16x8 byte block)
+ *               Outputs - _out0, _out1, _out2, _out3, _out4, _out5, _out6,
+ *                         _out7 (output 8x16 byte block)
+ * Details     : The rows of the matrix become columns, and the columns become
+ *               rows.
+ * Example     : LASX_TRANSPOSE16x8_H
+ *        _in0 : 1,2,3,4,5,6,7,8,0,0,0,0,0,0,0,0
+ *        _in1 : 2,2,3,4,5,6,7,8,0,0,0,0,0,0,0,0
+ *        _in2 : 3,2,3,4,5,6,7,8,0,0,0,0,0,0,0,0
+ *        _in3 : 4,2,3,4,5,6,7,8,0,0,0,0,0,0,0,0
+ *        _in4 : 5,2,3,4,5,6,7,8,0,0,0,0,0,0,0,0
+ *        _in5 : 6,2,3,4,5,6,7,8,0,0,0,0,0,0,0,0
+ *        _in6 : 7,2,3,4,5,6,7,8,0,0,0,0,0,0,0,0
+ *        _in7 : 8,2,3,4,5,6,7,8,0,0,0,0,0,0,0,0
+ *        _in8 : 9,2,3,4,5,6,7,8,0,0,0,0,0,0,0,0
+ *        _in9 : 1,2,3,4,5,6,7,8,0,0,0,0,0,0,0,0
+ *       _in10 : 0,2,3,4,5,6,7,8,0,0,0,0,0,0,0,0
+ *       _in11 : 2,2,3,4,5,6,7,8,0,0,0,0,0,0,0,0
+ *       _in12 : 3,2,3,4,5,6,7,8,0,0,0,0,0,0,0,0
+ *       _in13 : 7,2,3,4,5,6,7,8,0,0,0,0,0,0,0,0
+ *       _in14 : 5,2,3,4,5,6,7,8,0,0,0,0,0,0,0,0
+ *       _in15 : 6,2,3,4,5,6,7,8,0,0,0,0,0,0,0,0
+ *
+ *       _out0 : 1,2,3,4,5,6,7,8,9,1,0,2,3,7,5,6
+ *       _out1 : 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2
+ *       _out2 : 3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3
+ *       _out3 : 4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4
+ *       _out4 : 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5
+ *       _out5 : 6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6
+ *       _out6 : 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7
+ *       _out7 : 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8
+ * =============================================================================
+ */
+#define LASX_TRANSPOSE16x8_H(_in0, _in1, _in2, _in3, _in4, _in5, _in6, _in7,  \
+                             _in8, _in9, _in10, _in11, _in12, _in13, _in14,   \
+                             _in15, _out0, _out1, _out2, _out3, _out4, _out5, \
+                             _out6, _out7)                                    \
+  {                                                                           \
+    __m256i _tmp0_m, _tmp1_m, _tmp2_m, _tmp3_m;                               \
+    __m256i _tmp4_m, _tmp5_m, _tmp6_m, _tmp7_m;                               \
+    __m256i _t0, _t1, _t2, _t3, _t4, _t5, _t6, _t7;                           \
+                                                                              \
+    _tmp0_m = __lasx_xvilvl_h(_in2, _in0);                                    \
+    _tmp1_m = __lasx_xvilvl_h(_in3, _in1);                                    \
+    _tmp2_m = __lasx_xvilvl_h(_in6, _in4);                                    \
+    _tmp3_m = __lasx_xvilvl_h(_in7, _in5);                                    \
+    _tmp4_m = __lasx_xvilvl_h(_in10, _in8);                                   \
+    _tmp5_m = __lasx_xvilvl_h(_in11, _in9);                                   \
+    _tmp6_m = __lasx_xvilvl_h(_in14, _in12);                                  \
+    _tmp7_m = __lasx_xvilvl_h(_in15, _in13);                                  \
+    _t0 = __lasx_xvilvl_h(_tmp1_m, _tmp0_m);                                  \
+    _t1 = __lasx_xvilvh_h(_tmp1_m, _tmp0_m);                                  \
+    _t2 = __lasx_xvilvl_h(_tmp3_m, _tmp2_m);                                  \
+    _t3 = __lasx_xvilvh_h(_tmp3_m, _tmp2_m);                                  \
+    _t4 = __lasx_xvilvl_h(_tmp5_m, _tmp4_m);                                  \
+    _t5 = __lasx_xvilvh_h(_tmp5_m, _tmp4_m);                                  \
+    _t6 = __lasx_xvilvl_h(_tmp7_m, _tmp6_m);                                  \
+    _t7 = __lasx_xvilvh_h(_tmp7_m, _tmp6_m);                                  \
+    _tmp0_m = __lasx_xvilvl_d(_t2, _t0);                                      \
+    _tmp2_m = __lasx_xvilvh_d(_t2, _t0);                                      \
+    _tmp4_m = __lasx_xvilvl_d(_t3, _t1);                                      \
+    _tmp6_m = __lasx_xvilvh_d(_t3, _t1);                                      \
+    _tmp1_m = __lasx_xvilvl_d(_t6, _t4);                                      \
+    _tmp3_m = __lasx_xvilvh_d(_t6, _t4);                                      \
+    _tmp5_m = __lasx_xvilvl_d(_t7, _t5);                                      \
+    _tmp7_m = __lasx_xvilvh_d(_t7, _t5);                                      \
+    _out0 = __lasx_xvpermi_q(_tmp1_m, _tmp0_m, 0x20);                         \
+    _out1 = __lasx_xvpermi_q(_tmp3_m, _tmp2_m, 0x20);                         \
+    _out2 = __lasx_xvpermi_q(_tmp5_m, _tmp4_m, 0x20);                         \
+    _out3 = __lasx_xvpermi_q(_tmp7_m, _tmp6_m, 0x20);                         \
+                                                                              \
+    _tmp0_m = __lasx_xvilvh_h(_in2, _in0);                                    \
+    _tmp1_m = __lasx_xvilvh_h(_in3, _in1);                                    \
+    _tmp2_m = __lasx_xvilvh_h(_in6, _in4);                                    \
+    _tmp3_m = __lasx_xvilvh_h(_in7, _in5);                                    \
+    _tmp4_m = __lasx_xvilvh_h(_in10, _in8);                                   \
+    _tmp5_m = __lasx_xvilvh_h(_in11, _in9);                                   \
+    _tmp6_m = __lasx_xvilvh_h(_in14, _in12);                                  \
+    _tmp7_m = __lasx_xvilvh_h(_in15, _in13);                                  \
+    _t0 = __lasx_xvilvl_h(_tmp1_m, _tmp0_m);                                  \
+    _t1 = __lasx_xvilvh_h(_tmp1_m, _tmp0_m);                                  \
+    _t2 = __lasx_xvilvl_h(_tmp3_m, _tmp2_m);                                  \
+    _t3 = __lasx_xvilvh_h(_tmp3_m, _tmp2_m);                                  \
+    _t4 = __lasx_xvilvl_h(_tmp5_m, _tmp4_m);                                  \
+    _t5 = __lasx_xvilvh_h(_tmp5_m, _tmp4_m);                                  \
+    _t6 = __lasx_xvilvl_h(_tmp7_m, _tmp6_m);                                  \
+    _t7 = __lasx_xvilvh_h(_tmp7_m, _tmp6_m);                                  \
+    _tmp0_m = __lasx_xvilvl_d(_t2, _t0);                                      \
+    _tmp2_m = __lasx_xvilvh_d(_t2, _t0);                                      \
+    _tmp4_m = __lasx_xvilvl_d(_t3, _t1);                                      \
+    _tmp6_m = __lasx_xvilvh_d(_t3, _t1);                                      \
+    _tmp1_m = __lasx_xvilvl_d(_t6, _t4);                                      \
+    _tmp3_m = __lasx_xvilvh_d(_t6, _t4);                                      \
+    _tmp5_m = __lasx_xvilvl_d(_t7, _t5);                                      \
+    _tmp7_m = __lasx_xvilvh_d(_t7, _t5);                                      \
+    _out4 = __lasx_xvpermi_q(_tmp1_m, _tmp0_m, 0x20);                         \
+    _out5 = __lasx_xvpermi_q(_tmp3_m, _tmp2_m, 0x20);                         \
+    _out6 = __lasx_xvpermi_q(_tmp5_m, _tmp4_m, 0x20);                         \
+    _out7 = __lasx_xvpermi_q(_tmp7_m, _tmp6_m, 0x20);                         \
+  }
+
+/*
+ * =============================================================================
+ * Description : Transpose 4x4 block with halfword elements in vectors
+ * Arguments   : Inputs  - _in0, _in1, _in2, _in3
+ *               Outputs - _out0, _out1, _out2, _out3
+ *               Return Type - signed halfword
+ * Details     : The rows of the matrix become columns, and the columns become
+ *               rows.
+ * Example     : See LASX_TRANSPOSE8x8_H
+ * =============================================================================
+ */
+#define LASX_TRANSPOSE4x4_H(_in0, _in1, _in2, _in3, _out0, _out1, _out2, \
+                            _out3)                                       \
+  {                                                                      \
+    __m256i _s0_m, _s1_m;                                                \
+                                                                         \
+    _s0_m = __lasx_xvilvl_h(_in1, _in0);                                 \
+    _s1_m = __lasx_xvilvl_h(_in3, _in2);                                 \
+    _out0 = __lasx_xvilvl_w(_s1_m, _s0_m);                               \
+    _out2 = __lasx_xvilvh_w(_s1_m, _s0_m);                               \
+    _out1 = __lasx_xvilvh_d(_out0, _out0);                               \
+    _out3 = __lasx_xvilvh_d(_out2, _out2);                               \
+  }
+
+/*
+ * =============================================================================
+ * Description : Transpose input 8x8 byte block
+ * Arguments   : Inputs  - _in0, _in1, _in2, _in3, _in4, _in5, _in6, _in7
+ *                         (input 8x8 byte block)
+ *               Outputs - _out0, _out1, _out2, _out3, _out4, _out5, _out6,
+ *                         _out7 (output 8x8 byte block)
+ * Example     : See LASX_TRANSPOSE8x8_H
+ * =============================================================================
+ */
+#define LASX_TRANSPOSE8x8_B(_in0, _in1, _in2, _in3, _in4, _in5, _in6, _in7,  \
+                            _out0, _out1, _out2, _out3, _out4, _out5, _out6, \
+                            _out7)                                           \
+  {                                                                          \
+    __m256i _tmp0_m, _tmp1_m, _tmp2_m, _tmp3_m;                              \
+    __m256i _tmp4_m, _tmp5_m, _tmp6_m, _tmp7_m;                              \
+    _tmp0_m = __lasx_xvilvl_b(_in2, _in0);                                   \
+    _tmp1_m = __lasx_xvilvl_b(_in3, _in1);                                   \
+    _tmp2_m = __lasx_xvilvl_b(_in6, _in4);                                   \
+    _tmp3_m = __lasx_xvilvl_b(_in7, _in5);                                   \
+    _tmp4_m = __lasx_xvilvl_b(_tmp1_m, _tmp0_m);                             \
+    _tmp5_m = __lasx_xvilvh_b(_tmp1_m, _tmp0_m);                             \
+    _tmp6_m = __lasx_xvilvl_b(_tmp3_m, _tmp2_m);                             \
+    _tmp7_m = __lasx_xvilvh_b(_tmp3_m, _tmp2_m);                             \
+    _out0 = __lasx_xvilvl_w(_tmp6_m, _tmp4_m);                               \
+    _out2 = __lasx_xvilvh_w(_tmp6_m, _tmp4_m);                               \
+    _out4 = __lasx_xvilvl_w(_tmp7_m, _tmp5_m);                               \
+    _out6 = __lasx_xvilvh_w(_tmp7_m, _tmp5_m);                               \
+    _out1 = __lasx_xvbsrl_v(_out0, 8);                                       \
+    _out3 = __lasx_xvbsrl_v(_out2, 8);                                       \
+    _out5 = __lasx_xvbsrl_v(_out4, 8);                                       \
+    _out7 = __lasx_xvbsrl_v(_out6, 8);                                       \
+  }
+
+/*
+ * =============================================================================
+ * Description : Transpose 8x8 block with halfword elements in vectors.
+ * Arguments   : Inputs  - _in0, _in1, ~
+ *               Outputs - _out0, _out1, ~
+ * Details     : The rows of the matrix become columns, and the columns become
+ *               rows.
+ * Example     : LASX_TRANSPOSE8x8_H
+ *        _in0 : 1,2,3,4, 5,6,7,8, 1,2,3,4, 5,6,7,8
+ *        _in1 : 8,2,3,4, 5,6,7,8, 8,2,3,4, 5,6,7,8
+ *        _in2 : 8,2,3,4, 5,6,7,8, 8,2,3,4, 5,6,7,8
+ *        _in3 : 1,2,3,4, 5,6,7,8, 1,2,3,4, 5,6,7,8
+ *        _in4 : 9,2,3,4, 5,6,7,8, 9,2,3,4, 5,6,7,8
+ *        _in5 : 1,2,3,4, 5,6,7,8, 1,2,3,4, 5,6,7,8
+ *        _in6 : 1,2,3,4, 5,6,7,8, 1,2,3,4, 5,6,7,8
+ *        _in7 : 9,2,3,4, 5,6,7,8, 9,2,3,4, 5,6,7,8
+ *
+ *       _out0 : 1,8,8,1, 9,1,1,9, 1,8,8,1, 9,1,1,9
+ *       _out1 : 2,2,2,2, 2,2,2,2, 2,2,2,2, 2,2,2,2
+ *       _out2 : 3,3,3,3, 3,3,3,3, 3,3,3,3, 3,3,3,3
+ *       _out3 : 4,4,4,4, 4,4,4,4, 4,4,4,4, 4,4,4,4
+ *       _out4 : 5,5,5,5, 5,5,5,5, 5,5,5,5, 5,5,5,5
+ *       _out5 : 6,6,6,6, 6,6,6,6, 6,6,6,6, 6,6,6,6
+ *       _out6 : 7,7,7,7, 7,7,7,7, 7,7,7,7, 7,7,7,7
+ *       _out7 : 8,8,8,8, 8,8,8,8, 8,8,8,8, 8,8,8,8
+ * =============================================================================
+ */
+#define LASX_TRANSPOSE8x8_H(_in0, _in1, _in2, _in3, _in4, _in5, _in6, _in7,  \
+                            _out0, _out1, _out2, _out3, _out4, _out5, _out6, \
+                            _out7)                                           \
+  {                                                                          \
+    __m256i _s0_m, _s1_m;                                                    \
+    __m256i _tmp0_m, _tmp1_m, _tmp2_m, _tmp3_m;                              \
+    __m256i _tmp4_m, _tmp5_m, _tmp6_m, _tmp7_m;                              \
+                                                                             \
+    _s0_m = __lasx_xvilvl_h(_in6, _in4);                                     \
+    _s1_m = __lasx_xvilvl_h(_in7, _in5);                                     \
+    _tmp0_m = __lasx_xvilvl_h(_s1_m, _s0_m);                                 \
+    _tmp1_m = __lasx_xvilvh_h(_s1_m, _s0_m);                                 \
+    _s0_m = __lasx_xvilvh_h(_in6, _in4);                                     \
+    _s1_m = __lasx_xvilvh_h(_in7, _in5);                                     \
+    _tmp2_m = __lasx_xvilvl_h(_s1_m, _s0_m);                                 \
+    _tmp3_m = __lasx_xvilvh_h(_s1_m, _s0_m);                                 \
+                                                                             \
+    _s0_m = __lasx_xvilvl_h(_in2, _in0);                                     \
+    _s1_m = __lasx_xvilvl_h(_in3, _in1);                                     \
+    _tmp4_m = __lasx_xvilvl_h(_s1_m, _s0_m);                                 \
+    _tmp5_m = __lasx_xvilvh_h(_s1_m, _s0_m);                                 \
+    _s0_m = __lasx_xvilvh_h(_in2, _in0);                                     \
+    _s1_m = __lasx_xvilvh_h(_in3, _in1);                                     \
+    _tmp6_m = __lasx_xvilvl_h(_s1_m, _s0_m);                                 \
+    _tmp7_m = __lasx_xvilvh_h(_s1_m, _s0_m);                                 \
+                                                                             \
+    _out0 = __lasx_xvpickev_d(_tmp0_m, _tmp4_m);                             \
+    _out2 = __lasx_xvpickev_d(_tmp1_m, _tmp5_m);                             \
+    _out4 = __lasx_xvpickev_d(_tmp2_m, _tmp6_m);                             \
+    _out6 = __lasx_xvpickev_d(_tmp3_m, _tmp7_m);                             \
+    _out1 = __lasx_xvpickod_d(_tmp0_m, _tmp4_m);                             \
+    _out3 = __lasx_xvpickod_d(_tmp1_m, _tmp5_m);                             \
+    _out5 = __lasx_xvpickod_d(_tmp2_m, _tmp6_m);                             \
+    _out7 = __lasx_xvpickod_d(_tmp3_m, _tmp7_m);                             \
+  }
+
+/*
+ * =============================================================================
+ * Description : Butterfly of 4 input vectors
+ * Arguments   : Inputs  - _in0, _in1, _in2, _in3
+ *               Outputs - _out0, _out1, _out2, _out3
+ * Details     : Butterfly operation
+ * Example     : LASX_BUTTERFLY_4
+ *               _out0 = _in0 + _in3;
+ *               _out1 = _in1 + _in2;
+ *               _out2 = _in1 - _in2;
+ *               _out3 = _in0 - _in3;
+ * =============================================================================
+ */
+#define LASX_BUTTERFLY_4_B(_in0, _in1, _in2, _in3, _out0, _out1, _out2, _out3) \
+  {                                                                            \
+    _out0 = __lasx_xvadd_b(_in0, _in3);                                        \
+    _out1 = __lasx_xvadd_b(_in1, _in2);                                        \
+    _out2 = __lasx_xvsub_b(_in1, _in2);                                        \
+    _out3 = __lasx_xvsub_b(_in0, _in3);                                        \
+  }
+#define LASX_BUTTERFLY_4_H(_in0, _in1, _in2, _in3, _out0, _out1, _out2, _out3) \
+  {                                                                            \
+    _out0 = __lasx_xvadd_h(_in0, _in3);                                        \
+    _out1 = __lasx_xvadd_h(_in1, _in2);                                        \
+    _out2 = __lasx_xvsub_h(_in1, _in2);                                        \
+    _out3 = __lasx_xvsub_h(_in0, _in3);                                        \
+  }
+#define LASX_BUTTERFLY_4_W(_in0, _in1, _in2, _in3, _out0, _out1, _out2, _out3) \
+  {                                                                            \
+    _out0 = __lasx_xvadd_w(_in0, _in3);                                        \
+    _out1 = __lasx_xvadd_w(_in1, _in2);                                        \
+    _out2 = __lasx_xvsub_w(_in1, _in2);                                        \
+    _out3 = __lasx_xvsub_w(_in0, _in3);                                        \
+  }
+#define LASX_BUTTERFLY_4_D(_in0, _in1, _in2, _in3, _out0, _out1, _out2, _out3) \
+  {                                                                            \
+    _out0 = __lasx_xvadd_d(_in0, _in3);                                        \
+    _out1 = __lasx_xvadd_d(_in1, _in2);                                        \
+    _out2 = __lasx_xvsub_d(_in1, _in2);                                        \
+    _out3 = __lasx_xvsub_d(_in0, _in3);                                        \
+  }
+
+/*
+ * =============================================================================
+ * Description : Butterfly of 8 input vectors
+ * Arguments   : Inputs  - _in0, _in1, _in2, _in3, ~
+ *               Outputs - _out0, _out1, _out2, _out3, ~
+ * Details     : Butterfly operation
+ * Example     : LASX_BUTTERFLY_8
+ *               _out0 = _in0 + _in7;
+ *               _out1 = _in1 + _in6;
+ *               _out2 = _in2 + _in5;
+ *               _out3 = _in3 + _in4;
+ *               _out4 = _in3 - _in4;
+ *               _out5 = _in2 - _in5;
+ *               _out6 = _in1 - _in6;
+ *               _out7 = _in0 - _in7;
+ * =============================================================================
+ */
+#define LASX_BUTTERFLY_8_B(_in0, _in1, _in2, _in3, _in4, _in5, _in6, _in7,  \
+                           _out0, _out1, _out2, _out3, _out4, _out5, _out6, \
+                           _out7)                                           \
+  {                                                                         \
+    _out0 = __lasx_xvadd_b(_in0, _in7);                                     \
+    _out1 = __lasx_xvadd_b(_in1, _in6);                                     \
+    _out2 = __lasx_xvadd_b(_in2, _in5);                                     \
+    _out3 = __lasx_xvadd_b(_in3, _in4);                                     \
+    _out4 = __lasx_xvsub_b(_in3, _in4);                                     \
+    _out5 = __lasx_xvsub_b(_in2, _in5);                                     \
+    _out6 = __lasx_xvsub_b(_in1, _in6);                                     \
+    _out7 = __lasx_xvsub_b(_in0, _in7);                                     \
+  }
+
+#define LASX_BUTTERFLY_8_H(_in0, _in1, _in2, _in3, _in4, _in5, _in6, _in7,  \
+                           _out0, _out1, _out2, _out3, _out4, _out5, _out6, \
+                           _out7)                                           \
+  {                                                                         \
+    _out0 = __lasx_xvadd_h(_in0, _in7);                                     \
+    _out1 = __lasx_xvadd_h(_in1, _in6);                                     \
+    _out2 = __lasx_xvadd_h(_in2, _in5);                                     \
+    _out3 = __lasx_xvadd_h(_in3, _in4);                                     \
+    _out4 = __lasx_xvsub_h(_in3, _in4);                                     \
+    _out5 = __lasx_xvsub_h(_in2, _in5);                                     \
+    _out6 = __lasx_xvsub_h(_in1, _in6);                                     \
+    _out7 = __lasx_xvsub_h(_in0, _in7);                                     \
+  }
+
+#define LASX_BUTTERFLY_8_W(_in0, _in1, _in2, _in3, _in4, _in5, _in6, _in7,  \
+                           _out0, _out1, _out2, _out3, _out4, _out5, _out6, \
+                           _out7)                                           \
+  {                                                                         \
+    _out0 = __lasx_xvadd_w(_in0, _in7);                                     \
+    _out1 = __lasx_xvadd_w(_in1, _in6);                                     \
+    _out2 = __lasx_xvadd_w(_in2, _in5);                                     \
+    _out3 = __lasx_xvadd_w(_in3, _in4);                                     \
+    _out4 = __lasx_xvsub_w(_in3, _in4);                                     \
+    _out5 = __lasx_xvsub_w(_in2, _in5);                                     \
+    _out6 = __lasx_xvsub_w(_in1, _in6);                                     \
+    _out7 = __lasx_xvsub_w(_in0, _in7);                                     \
+  }
+
+#define LASX_BUTTERFLY_8_D(_in0, _in1, _in2, _in3, _in4, _in5, _in6, _in7,  \
+                           _out0, _out1, _out2, _out3, _out4, _out5, _out6, \
+                           _out7)                                           \
+  {                                                                         \
+    _out0 = __lasx_xvadd_d(_in0, _in7);                                     \
+    _out1 = __lasx_xvadd_d(_in1, _in6);                                     \
+    _out2 = __lasx_xvadd_d(_in2, _in5);                                     \
+    _out3 = __lasx_xvadd_d(_in3, _in4);                                     \
+    _out4 = __lasx_xvsub_d(_in3, _in4);                                     \
+    _out5 = __lasx_xvsub_d(_in2, _in5);                                     \
+    _out6 = __lasx_xvsub_d(_in1, _in6);                                     \
+    _out7 = __lasx_xvsub_d(_in0, _in7);                                     \
+  }
+
+#endif  // LASX
+
+/*
+ * =============================================================================
+ * Description : Print out elements in vector.
+ * Arguments   : Inputs  - RTYPE, _element_num, _in0, _enter
+ *               Outputs -
+ * Details     : Print out '_element_num' elements in 'RTYPE' vector '_in0', if
+ *               '_enter' is TRUE, prefix "\nVP:" will be added first.
+ * Example     : VECT_PRINT(v4i32,4,in0,1); // in0: 1,2,3,4
+ *               VP:1,2,3,4,
+ * =============================================================================
+ */
+#define VECT_PRINT(RTYPE, element_num, in0, enter) \
+  {                                                \
+    RTYPE _tmp0 = (RTYPE)in0;                      \
+    int _i = 0;                                    \
+    if (enter)                                     \
+      printf("\nVP:");                             \
+    for (_i = 0; _i < element_num; _i++)           \
+      printf("%d,", _tmp0[_i]);                    \
+  }
+
+#endif /* LOONGSON_INTRINSICS_H */
+#endif /* INCLUDE_LIBYUV_LOONGSON_INTRINSICS_H */
diff --git a/3rdparty/libyuv/src/include/libyuv/macros_msa.h b/3rdparty/libyuv/src/include/libyuv/macros_msa.h
new file mode 100644
index 00000000..b9a44fcc
--- /dev/null
+++ b/3rdparty/libyuv/src/include/libyuv/macros_msa.h
@@ -0,0 +1,246 @@
+/*
+ *  Copyright 2016 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#ifndef INCLUDE_LIBYUV_MACROS_MSA_H_
+#define INCLUDE_LIBYUV_MACROS_MSA_H_
+
+#if !defined(LIBYUV_DISABLE_MSA) && defined(__mips_msa)
+#include <msa.h>
+#include <stdint.h>
+
+#if (__mips_isa_rev >= 6)
+#define LW(psrc)                                       \
+  ({                                                   \
+    const uint8_t* psrc_lw_m = (const uint8_t*)(psrc); \
+    uint32_t val_m;                                    \
+    asm volatile("lw  %[val_m],  %[psrc_lw_m]  \n"     \
+                 : [val_m] "=r"(val_m)                 \
+                 : [psrc_lw_m] "m"(*psrc_lw_m));       \
+    val_m;                                             \
+  })
+
+#if (__mips == 64)
+#define LD(psrc)                                       \
+  ({                                                   \
+    const uint8_t* psrc_ld_m = (const uint8_t*)(psrc); \
+    uint64_t val_m = 0;                                \
+    asm volatile("ld  %[val_m],  %[psrc_ld_m]  \n"     \
+                 : [val_m] "=r"(val_m)                 \
+                 : [psrc_ld_m] "m"(*psrc_ld_m));       \
+    val_m;                                             \
+  })
+#else  // !(__mips == 64)
+#define LD(psrc)                                                         \
+  ({                                                                     \
+    const uint8_t* psrc_ld_m = (const uint8_t*)(psrc);                   \
+    uint32_t val0_m, val1_m;                                             \
+    uint64_t val_m = 0;                                                  \
+    val0_m = LW(psrc_ld_m);                                              \
+    val1_m = LW(psrc_ld_m + 4);                                          \
+    val_m = (uint64_t)(val1_m);                             /* NOLINT */ \
+    val_m = (uint64_t)((val_m << 32) & 0xFFFFFFFF00000000); /* NOLINT */ \
+    val_m = (uint64_t)(val_m | (uint64_t)val0_m);           /* NOLINT */ \
+    val_m;                                                               \
+  })
+#endif  // (__mips == 64)
+
+#define SW(val, pdst)                                   \
+  ({                                                    \
+    uint8_t* pdst_sw_m = (uint8_t*)(pdst); /* NOLINT */ \
+    uint32_t val_m = (val);                             \
+    asm volatile("sw  %[val_m],  %[pdst_sw_m]  \n"      \
+                 : [pdst_sw_m] "=m"(*pdst_sw_m)         \
+                 : [val_m] "r"(val_m));                 \
+  })
+
+#if (__mips == 64)
+#define SD(val, pdst)                                   \
+  ({                                                    \
+    uint8_t* pdst_sd_m = (uint8_t*)(pdst); /* NOLINT */ \
+    uint64_t val_m = (val);                             \
+    asm volatile("sd  %[val_m],  %[pdst_sd_m]  \n"      \
+                 : [pdst_sd_m] "=m"(*pdst_sd_m)         \
+                 : [val_m] "r"(val_m));                 \
+  })
+#else  // !(__mips == 64)
+#define SD(val, pdst)                                        \
+  ({                                                         \
+    uint8_t* pdst_sd_m = (uint8_t*)(pdst); /* NOLINT */      \
+    uint32_t val0_m, val1_m;                                 \
+    val0_m = (uint32_t)((val)&0x00000000FFFFFFFF);           \
+    val1_m = (uint32_t)(((val) >> 32) & 0x00000000FFFFFFFF); \
+    SW(val0_m, pdst_sd_m);                                   \
+    SW(val1_m, pdst_sd_m + 4);                               \
+  })
+#endif  // !(__mips == 64)
+#else   // !(__mips_isa_rev >= 6)
+#define LW(psrc)                                \
+  ({                                            \
+    uint8_t* psrc_lw_m = (uint8_t*)(psrc);      \
+    uint32_t val_lw_m;                          \
+                                                \
+    __asm__ volatile(                           \
+        "lwr %[val_lw_m], 0(%[psrc_lw_m]) \n\t" \
+        "lwl %[val_lw_m], 3(%[psrc_lw_m]) \n\t" \
+                                                \
+        : [val_lw_m] "=&r"(val_lw_m)            \
+        : [psrc_lw_m] "r"(psrc_lw_m));          \
+                                                \
+    val_lw_m;                                   \
+  })
+
+#if (__mips == 64)
+#define LD(psrc)                                \
+  ({                                            \
+    uint8_t* psrc_ld_m = (uint8_t*)(psrc);      \
+    uint64_t val_ld_m = 0;                      \
+                                                \
+    __asm__ volatile(                           \
+        "ldr %[val_ld_m], 0(%[psrc_ld_m]) \n\t" \
+        "ldl %[val_ld_m], 7(%[psrc_ld_m]) \n\t" \
+                                                \
+        : [val_ld_m] "=&r"(val_ld_m)            \
+        : [psrc_ld_m] "r"(psrc_ld_m));          \
+                                                \
+    val_ld_m;                                   \
+  })
+#else  // !(__mips == 64)
+#define LD(psrc)                                                         \
+  ({                                                                     \
+    const uint8_t* psrc_ld_m = (const uint8_t*)(psrc);                   \
+    uint32_t val0_m, val1_m;                                             \
+    uint64_t val_m = 0;                                                  \
+    val0_m = LW(psrc_ld_m);                                              \
+    val1_m = LW(psrc_ld_m + 4);                                          \
+    val_m = (uint64_t)(val1_m);                             /* NOLINT */ \
+    val_m = (uint64_t)((val_m << 32) & 0xFFFFFFFF00000000); /* NOLINT */ \
+    val_m = (uint64_t)(val_m | (uint64_t)val0_m);           /* NOLINT */ \
+    val_m;                                                               \
+  })
+#endif  // (__mips == 64)
+
+#define SW(val, pdst)                                   \
+  ({                                                    \
+    uint8_t* pdst_sw_m = (uint8_t*)(pdst); /* NOLINT */ \
+    uint32_t val_m = (val);                             \
+    asm volatile("usw  %[val_m],  %[pdst_sw_m]  \n"     \
+                 : [pdst_sw_m] "=m"(*pdst_sw_m)         \
+                 : [val_m] "r"(val_m));                 \
+  })
+
+#define SD(val, pdst)                                        \
+  ({                                                         \
+    uint8_t* pdst_sd_m = (uint8_t*)(pdst); /* NOLINT */      \
+    uint32_t val0_m, val1_m;                                 \
+    val0_m = (uint32_t)((val)&0x00000000FFFFFFFF);           \
+    val1_m = (uint32_t)(((val) >> 32) & 0x00000000FFFFFFFF); \
+    SW(val0_m, pdst_sd_m);                                   \
+    SW(val1_m, pdst_sd_m + 4);                               \
+  })
+#endif  // (__mips_isa_rev >= 6)
+
+// TODO(fbarchard): Consider removing __VAR_ARGS versions.
+#define LD_B(RTYPE, psrc) *((RTYPE*)(psrc)) /* NOLINT */
+#define LD_UB(...) LD_B(const v16u8, __VA_ARGS__)
+
+#define LD_H(RTYPE, psrc) *((RTYPE*)(psrc)) /* NOLINT */
+#define LD_UH(...) LD_H(const v8u16, __VA_ARGS__)
+
+#define ST_B(RTYPE, in, pdst) *((RTYPE*)(pdst)) = (in) /* NOLINT */
+#define ST_UB(...) ST_B(v16u8, __VA_ARGS__)
+
+#define ST_H(RTYPE, in, pdst) *((RTYPE*)(pdst)) = (in) /* NOLINT */
+#define ST_UH(...) ST_H(v8u16, __VA_ARGS__)
+
+/* Description : Load two vectors with 16 'byte' sized elements
+   Arguments   : Inputs  - psrc, stride
+                 Outputs - out0, out1
+                 Return Type - as per RTYPE
+   Details     : Load 16 byte elements in 'out0' from (psrc)
+                 Load 16 byte elements in 'out1' from (psrc + stride)
+*/
+#define LD_B2(RTYPE, psrc, stride, out0, out1) \
+  {                                            \
+    out0 = LD_B(RTYPE, (psrc));                \
+    out1 = LD_B(RTYPE, (psrc) + stride);       \
+  }
+#define LD_UB2(...) LD_B2(const v16u8, __VA_ARGS__)
+
+#define LD_B4(RTYPE, psrc, stride, out0, out1, out2, out3) \
+  {                                                        \
+    LD_B2(RTYPE, (psrc), stride, out0, out1);              \
+    LD_B2(RTYPE, (psrc) + 2 * stride, stride, out2, out3); \
+  }
+#define LD_UB4(...) LD_B4(const v16u8, __VA_ARGS__)
+
+/* Description : Store two vectors with stride each having 16 'byte' sized
+                 elements
+   Arguments   : Inputs - in0, in1, pdst, stride
+   Details     : Store 16 byte elements from 'in0' to (pdst)
+                 Store 16 byte elements from 'in1' to (pdst + stride)
+*/
+#define ST_B2(RTYPE, in0, in1, pdst, stride) \
+  {                                          \
+    ST_B(RTYPE, in0, (pdst));                \
+    ST_B(RTYPE, in1, (pdst) + stride);       \
+  }
+#define ST_UB2(...) ST_B2(v16u8, __VA_ARGS__)
+
+#define ST_B4(RTYPE, in0, in1, in2, in3, pdst, stride)   \
+  {                                                      \
+    ST_B2(RTYPE, in0, in1, (pdst), stride);              \
+    ST_B2(RTYPE, in2, in3, (pdst) + 2 * stride, stride); \
+  }
+#define ST_UB4(...) ST_B4(v16u8, __VA_ARGS__)
+
+/* Description : Store vectors of 8 halfword elements with stride
+   Arguments   : Inputs - in0, in1, pdst, stride
+   Details     : Store 8 halfword elements from 'in0' to (pdst)
+                 Store 8 halfword elements from 'in1' to (pdst + stride)
+*/
+#define ST_H2(RTYPE, in0, in1, pdst, stride) \
+  {                                          \
+    ST_H(RTYPE, in0, (pdst));                \
+    ST_H(RTYPE, in1, (pdst) + stride);       \
+  }
+#define ST_UH2(...) ST_H2(v8u16, __VA_ARGS__)
+
+// TODO(fbarchard): Consider using __msa_vshf_b and __msa_ilvr_b directly.
+/* Description : Shuffle byte vector elements as per mask vector
+   Arguments   : Inputs  - in0, in1, in2, in3, mask0, mask1
+                 Outputs - out0, out1
+                 Return Type - as per RTYPE
+   Details     : Byte elements from 'in0' & 'in1' are copied selectively to
+                 'out0' as per control vector 'mask0'
+*/
+#define VSHF_B2(RTYPE, in0, in1, in2, in3, mask0, mask1, out0, out1)  \
+  {                                                                   \
+    out0 = (RTYPE)__msa_vshf_b((v16i8)mask0, (v16i8)in1, (v16i8)in0); \
+    out1 = (RTYPE)__msa_vshf_b((v16i8)mask1, (v16i8)in3, (v16i8)in2); \
+  }
+#define VSHF_B2_UB(...) VSHF_B2(v16u8, __VA_ARGS__)
+
+/* Description : Interleave both left and right half of input vectors
+   Arguments   : Inputs  - in0, in1
+                 Outputs - out0, out1
+                 Return Type - as per RTYPE
+   Details     : Right half of byte elements from 'in0' and 'in1' are
+                 interleaved and written to 'out0'
+*/
+#define ILVRL_B2(RTYPE, in0, in1, out0, out1)           \
+  {                                                     \
+    out0 = (RTYPE)__msa_ilvr_b((v16i8)in0, (v16i8)in1); \
+    out1 = (RTYPE)__msa_ilvl_b((v16i8)in0, (v16i8)in1); \
+  }
+#define ILVRL_B2_UB(...) ILVRL_B2(v16u8, __VA_ARGS__)
+
+#endif /* !defined(LIBYUV_DISABLE_MSA) && defined(__mips_msa) */
+
+#endif  // INCLUDE_LIBYUV_MACROS_MSA_H_
diff --git a/3rdparty/libyuv/src/include/libyuv/mjpeg_decoder.h b/3rdparty/libyuv/src/include/libyuv/mjpeg_decoder.h
new file mode 100644
index 00000000..275f8d4c
--- /dev/null
+++ b/3rdparty/libyuv/src/include/libyuv/mjpeg_decoder.h
@@ -0,0 +1,195 @@
+/*
+ *  Copyright 2012 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#ifndef INCLUDE_LIBYUV_MJPEG_DECODER_H_
+#define INCLUDE_LIBYUV_MJPEG_DECODER_H_
+
+#include "libyuv/basic_types.h"
+
+#ifdef __cplusplus
+// NOTE: For a simplified public API use convert.h MJPGToI420().
+
+struct jpeg_common_struct;
+struct jpeg_decompress_struct;
+struct jpeg_source_mgr;
+
+namespace libyuv {
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+LIBYUV_BOOL ValidateJpeg(const uint8_t* sample, size_t sample_size);
+
+#ifdef __cplusplus
+}  // extern "C"
+#endif
+
+static const uint32_t kUnknownDataSize = 0xFFFFFFFF;
+
+enum JpegSubsamplingType {
+  kJpegYuv420,
+  kJpegYuv422,
+  kJpegYuv444,
+  kJpegYuv400,
+  kJpegUnknown
+};
+
+struct Buffer {
+  const uint8_t* data;
+  int len;
+};
+
+struct BufferVector {
+  Buffer* buffers;
+  int len;
+  int pos;
+};
+
+struct SetJmpErrorMgr;
+
+// MJPEG ("Motion JPEG") is a pseudo-standard video codec where the frames are
+// simply independent JPEG images with a fixed huffman table (which is omitted).
+// It is rarely used in video transmission, but is common as a camera capture
+// format, especially in Logitech devices. This class implements a decoder for
+// MJPEG frames.
+//
+// See http://tools.ietf.org/html/rfc2435
+class LIBYUV_API MJpegDecoder {
+ public:
+  typedef void (*CallbackFunction)(void* opaque,
+                                   const uint8_t* const* data,
+                                   const int* strides,
+                                   int rows);
+
+  static const int kColorSpaceUnknown;
+  static const int kColorSpaceGrayscale;
+  static const int kColorSpaceRgb;
+  static const int kColorSpaceYCbCr;
+  static const int kColorSpaceCMYK;
+  static const int kColorSpaceYCCK;
+
+  MJpegDecoder();
+  ~MJpegDecoder();
+
+  // Loads a new frame, reads its headers, and determines the uncompressed
+  // image format.
+  // Returns LIBYUV_TRUE if image looks valid and format is supported.
+  // If return value is LIBYUV_TRUE, then the values for all the following
+  // getters are populated.
+  // src_len is the size of the compressed mjpeg frame in bytes.
+  LIBYUV_BOOL LoadFrame(const uint8_t* src, size_t src_len);
+
+  // Returns width of the last loaded frame in pixels.
+  int GetWidth();
+
+  // Returns height of the last loaded frame in pixels.
+  int GetHeight();
+
+  // Returns format of the last loaded frame. The return value is one of the
+  // kColorSpace* constants.
+  int GetColorSpace();
+
+  // Number of color components in the color space.
+  int GetNumComponents();
+
+  // Sample factors of the n-th component.
+  int GetHorizSampFactor(int component);
+
+  int GetVertSampFactor(int component);
+
+  int GetHorizSubSampFactor(int component);
+
+  int GetVertSubSampFactor(int component);
+
+  // Public for testability.
+  int GetImageScanlinesPerImcuRow();
+
+  // Public for testability.
+  int GetComponentScanlinesPerImcuRow(int component);
+
+  // Width of a component in bytes.
+  int GetComponentWidth(int component);
+
+  // Height of a component.
+  int GetComponentHeight(int component);
+
+  // Width of a component in bytes with padding for DCTSIZE. Public for testing.
+  int GetComponentStride(int component);
+
+  // Size of a component in bytes.
+  int GetComponentSize(int component);
+
+  // Call this after LoadFrame() if you decide you don't want to decode it
+  // after all.
+  LIBYUV_BOOL UnloadFrame();
+
+  // Decodes the entire image into a one-buffer-per-color-component format.
+  // dst_width must match exactly. dst_height must be <= to image height; if
+  // less, the image is cropped. "planes" must have size equal to at least
+  // GetNumComponents() and they must point to non-overlapping buffers of size
+  // at least GetComponentSize(i). The pointers in planes are incremented
+  // to point to after the end of the written data.
+  // TODO(fbarchard): Add dst_x, dst_y to allow specific rect to be decoded.
+  LIBYUV_BOOL DecodeToBuffers(uint8_t** planes, int dst_width, int dst_height);
+
+  // Decodes the entire image and passes the data via repeated calls to a
+  // callback function. Each call will get the data for a whole number of
+  // image scanlines.
+  // TODO(fbarchard): Add dst_x, dst_y to allow specific rect to be decoded.
+  LIBYUV_BOOL DecodeToCallback(CallbackFunction fn,
+                               void* opaque,
+                               int dst_width,
+                               int dst_height);
+
+  // The helper function which recognizes the jpeg sub-sampling type.
+  static JpegSubsamplingType JpegSubsamplingTypeHelper(
+      int* subsample_x,
+      int* subsample_y,
+      int number_of_components);
+
+ private:
+  void AllocOutputBuffers(int num_outbufs);
+  void DestroyOutputBuffers();
+
+  LIBYUV_BOOL StartDecode();
+  LIBYUV_BOOL FinishDecode();
+
+  void SetScanlinePointers(uint8_t** data);
+  LIBYUV_BOOL DecodeImcuRow();
+
+  int GetComponentScanlinePadding(int component);
+
+  // A buffer holding the input data for a frame.
+  Buffer buf_;
+  BufferVector buf_vec_;
+
+  jpeg_decompress_struct* decompress_struct_;
+  jpeg_source_mgr* source_mgr_;
+  SetJmpErrorMgr* error_mgr_;
+
+  // LIBYUV_TRUE iff at least one component has scanline padding. (i.e.,
+  // GetComponentScanlinePadding() != 0.)
+  LIBYUV_BOOL has_scanline_padding_;
+
+  // Temporaries used to point to scanline outputs.
+  int num_outbufs_;  // Outermost size of all arrays below.
+  uint8_t*** scanlines_;
+  int* scanlines_sizes_;
+  // Temporary buffer used for decoding when we can't decode directly to the
+  // output buffers. Large enough for just one iMCU row.
+  uint8_t** databuf_;
+  int* databuf_strides_;
+};
+
+}  // namespace libyuv
+
+#endif  //  __cplusplus
+#endif  // INCLUDE_LIBYUV_MJPEG_DECODER_H_
diff --git a/3rdparty/libyuv/src/include/libyuv/planar_functions.h b/3rdparty/libyuv/src/include/libyuv/planar_functions.h
new file mode 100644
index 00000000..1ef2256b
--- /dev/null
+++ b/3rdparty/libyuv/src/include/libyuv/planar_functions.h
@@ -0,0 +1,1118 @@
+/*
+ *  Copyright 2011 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#ifndef INCLUDE_LIBYUV_PLANAR_FUNCTIONS_H_
+#define INCLUDE_LIBYUV_PLANAR_FUNCTIONS_H_
+
+#include "libyuv/basic_types.h"
+
+// TODO(fbarchard): Remove the following headers includes.
+#include "libyuv/convert.h"
+#include "libyuv/convert_argb.h"
+
+#ifdef __cplusplus
+namespace libyuv {
+extern "C" {
+#endif
+
+// TODO(fbarchard): Move cpu macros to row.h
+#if defined(__pnacl__) || defined(__CLR_VER) ||            \
+    (defined(__native_client__) && defined(__x86_64__)) || \
+    (defined(__i386__) && !defined(__SSE__) && !defined(__clang__))
+#define LIBYUV_DISABLE_X86
+#endif
+// MemorySanitizer does not support assembly code yet. http://crbug.com/344505
+#if defined(__has_feature)
+#if __has_feature(memory_sanitizer)
+#define LIBYUV_DISABLE_X86
+#endif
+#endif
+// The following are available on all x86 platforms:
+#if !defined(LIBYUV_DISABLE_X86) && \
+    (defined(_M_IX86) || defined(__x86_64__) || defined(__i386__))
+#define HAS_ARGBAFFINEROW_SSE2
+#endif
+
+// Copy a plane of data.
+LIBYUV_API
+void CopyPlane(const uint8_t* src_y,
+               int src_stride_y,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               int width,
+               int height);
+
+LIBYUV_API
+void CopyPlane_16(const uint16_t* src_y,
+                  int src_stride_y,
+                  uint16_t* dst_y,
+                  int dst_stride_y,
+                  int width,
+                  int height);
+
+LIBYUV_API
+void Convert16To8Plane(const uint16_t* src_y,
+                       int src_stride_y,
+                       uint8_t* dst_y,
+                       int dst_stride_y,
+                       int scale,  // 16384 for 10 bits
+                       int width,
+                       int height);
+
+LIBYUV_API
+void Convert8To16Plane(const uint8_t* src_y,
+                       int src_stride_y,
+                       uint16_t* dst_y,
+                       int dst_stride_y,
+                       int scale,  // 1024 for 10 bits
+                       int width,
+                       int height);
+
+// Set a plane of data to a 32 bit value.
+LIBYUV_API
+void SetPlane(uint8_t* dst_y,
+              int dst_stride_y,
+              int width,
+              int height,
+              uint32_t value);
+
+// Convert a plane of tiles of 16 x H to linear.
+LIBYUV_API
+void DetilePlane(const uint8_t* src_y,
+                 int src_stride_y,
+                 uint8_t* dst_y,
+                 int dst_stride_y,
+                 int width,
+                 int height,
+                 int tile_height);
+
+// Convert a UV plane of tiles of 16 x H into linear U and V planes.
+LIBYUV_API
+void DetileSplitUVPlane(const uint8_t* src_uv,
+                        int src_stride_uv,
+                        uint8_t* dst_u,
+                        int dst_stride_u,
+                        uint8_t* dst_v,
+                        int dst_stride_v,
+                        int width,
+                        int height,
+                        int tile_height);
+
+// Split interleaved UV plane into separate U and V planes.
+LIBYUV_API
+void SplitUVPlane(const uint8_t* src_uv,
+                  int src_stride_uv,
+                  uint8_t* dst_u,
+                  int dst_stride_u,
+                  uint8_t* dst_v,
+                  int dst_stride_v,
+                  int width,
+                  int height);
+
+// Merge separate U and V planes into one interleaved UV plane.
+LIBYUV_API
+void MergeUVPlane(const uint8_t* src_u,
+                  int src_stride_u,
+                  const uint8_t* src_v,
+                  int src_stride_v,
+                  uint8_t* dst_uv,
+                  int dst_stride_uv,
+                  int width,
+                  int height);
+
+// Split interleaved msb UV plane into separate lsb U and V planes.
+LIBYUV_API
+void SplitUVPlane_16(const uint16_t* src_uv,
+                     int src_stride_uv,
+                     uint16_t* dst_u,
+                     int dst_stride_u,
+                     uint16_t* dst_v,
+                     int dst_stride_v,
+                     int width,
+                     int height,
+                     int depth);
+
+// Merge separate lsb U and V planes into one interleaved msb UV plane.
+LIBYUV_API
+void MergeUVPlane_16(const uint16_t* src_u,
+                     int src_stride_u,
+                     const uint16_t* src_v,
+                     int src_stride_v,
+                     uint16_t* dst_uv,
+                     int dst_stride_uv,
+                     int width,
+                     int height,
+                     int depth);
+
+// Convert lsb plane to msb plane
+LIBYUV_API
+void ConvertToMSBPlane_16(const uint16_t* src_y,
+                          int src_stride_y,
+                          uint16_t* dst_y,
+                          int dst_stride_y,
+                          int width,
+                          int height,
+                          int depth);
+
+// Convert msb plane to lsb plane
+LIBYUV_API
+void ConvertToLSBPlane_16(const uint16_t* src_y,
+                          int src_stride_y,
+                          uint16_t* dst_y,
+                          int dst_stride_y,
+                          int width,
+                          int height,
+                          int depth);
+
+// Scale U and V to half width and height and merge into interleaved UV plane.
+// width and height are source size, allowing odd sizes.
+// Use for converting I444 or I422 to NV12.
+LIBYUV_API
+void HalfMergeUVPlane(const uint8_t* src_u,
+                      int src_stride_u,
+                      const uint8_t* src_v,
+                      int src_stride_v,
+                      uint8_t* dst_uv,
+                      int dst_stride_uv,
+                      int width,
+                      int height);
+
+// Swap U and V channels in interleaved UV plane.
+LIBYUV_API
+void SwapUVPlane(const uint8_t* src_uv,
+                 int src_stride_uv,
+                 uint8_t* dst_vu,
+                 int dst_stride_vu,
+                 int width,
+                 int height);
+
+// Split interleaved RGB plane into separate R, G and B planes.
+LIBYUV_API
+void SplitRGBPlane(const uint8_t* src_rgb,
+                   int src_stride_rgb,
+                   uint8_t* dst_r,
+                   int dst_stride_r,
+                   uint8_t* dst_g,
+                   int dst_stride_g,
+                   uint8_t* dst_b,
+                   int dst_stride_b,
+                   int width,
+                   int height);
+
+// Merge separate R, G and B planes into one interleaved RGB plane.
+LIBYUV_API
+void MergeRGBPlane(const uint8_t* src_r,
+                   int src_stride_r,
+                   const uint8_t* src_g,
+                   int src_stride_g,
+                   const uint8_t* src_b,
+                   int src_stride_b,
+                   uint8_t* dst_rgb,
+                   int dst_stride_rgb,
+                   int width,
+                   int height);
+
+// Split interleaved ARGB plane into separate R, G, B and A planes.
+// dst_a can be NULL to discard alpha plane.
+LIBYUV_API
+void SplitARGBPlane(const uint8_t* src_argb,
+                    int src_stride_argb,
+                    uint8_t* dst_r,
+                    int dst_stride_r,
+                    uint8_t* dst_g,
+                    int dst_stride_g,
+                    uint8_t* dst_b,
+                    int dst_stride_b,
+                    uint8_t* dst_a,
+                    int dst_stride_a,
+                    int width,
+                    int height);
+
+// Merge separate R, G, B and A planes into one interleaved ARGB plane.
+// src_a can be NULL to fill opaque value to alpha.
+LIBYUV_API
+void MergeARGBPlane(const uint8_t* src_r,
+                    int src_stride_r,
+                    const uint8_t* src_g,
+                    int src_stride_g,
+                    const uint8_t* src_b,
+                    int src_stride_b,
+                    const uint8_t* src_a,
+                    int src_stride_a,
+                    uint8_t* dst_argb,
+                    int dst_stride_argb,
+                    int width,
+                    int height);
+
+// Merge separate 'depth' bit R, G and B planes stored in lsb
+// into one interleaved XR30 plane.
+// depth should in range [10, 16]
+LIBYUV_API
+void MergeXR30Plane(const uint16_t* src_r,
+                    int src_stride_r,
+                    const uint16_t* src_g,
+                    int src_stride_g,
+                    const uint16_t* src_b,
+                    int src_stride_b,
+                    uint8_t* dst_ar30,
+                    int dst_stride_ar30,
+                    int width,
+                    int height,
+                    int depth);
+
+// Merge separate 'depth' bit R, G, B and A planes stored in lsb
+// into one interleaved AR64 plane.
+// src_a can be NULL to fill opaque value to alpha.
+// depth should in range [1, 16]
+LIBYUV_API
+void MergeAR64Plane(const uint16_t* src_r,
+                    int src_stride_r,
+                    const uint16_t* src_g,
+                    int src_stride_g,
+                    const uint16_t* src_b,
+                    int src_stride_b,
+                    const uint16_t* src_a,
+                    int src_stride_a,
+                    uint16_t* dst_ar64,
+                    int dst_stride_ar64,
+                    int width,
+                    int height,
+                    int depth);
+
+// Merge separate 'depth' bit R, G, B and A planes stored in lsb
+// into one interleaved ARGB plane.
+// src_a can be NULL to fill opaque value to alpha.
+// depth should in range [8, 16]
+LIBYUV_API
+void MergeARGB16To8Plane(const uint16_t* src_r,
+                         int src_stride_r,
+                         const uint16_t* src_g,
+                         int src_stride_g,
+                         const uint16_t* src_b,
+                         int src_stride_b,
+                         const uint16_t* src_a,
+                         int src_stride_a,
+                         uint8_t* dst_argb,
+                         int dst_stride_argb,
+                         int width,
+                         int height,
+                         int depth);
+
+// Copy I400.  Supports inverting.
+LIBYUV_API
+int I400ToI400(const uint8_t* src_y,
+               int src_stride_y,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               int width,
+               int height);
+
+#define J400ToJ400 I400ToI400
+
+// Copy I422 to I422.
+#define I422ToI422 I422Copy
+LIBYUV_API
+int I422Copy(const uint8_t* src_y,
+             int src_stride_y,
+             const uint8_t* src_u,
+             int src_stride_u,
+             const uint8_t* src_v,
+             int src_stride_v,
+             uint8_t* dst_y,
+             int dst_stride_y,
+             uint8_t* dst_u,
+             int dst_stride_u,
+             uint8_t* dst_v,
+             int dst_stride_v,
+             int width,
+             int height);
+
+// Copy I444 to I444.
+#define I444ToI444 I444Copy
+LIBYUV_API
+int I444Copy(const uint8_t* src_y,
+             int src_stride_y,
+             const uint8_t* src_u,
+             int src_stride_u,
+             const uint8_t* src_v,
+             int src_stride_v,
+             uint8_t* dst_y,
+             int dst_stride_y,
+             uint8_t* dst_u,
+             int dst_stride_u,
+             uint8_t* dst_v,
+             int dst_stride_v,
+             int width,
+             int height);
+
+// Copy I210 to I210.
+#define I210ToI210 I210Copy
+LIBYUV_API
+int I210Copy(const uint16_t* src_y,
+             int src_stride_y,
+             const uint16_t* src_u,
+             int src_stride_u,
+             const uint16_t* src_v,
+             int src_stride_v,
+             uint16_t* dst_y,
+             int dst_stride_y,
+             uint16_t* dst_u,
+             int dst_stride_u,
+             uint16_t* dst_v,
+             int dst_stride_v,
+             int width,
+             int height);
+
+// Copy NV12. Supports inverting.
+int NV12Copy(const uint8_t* src_y,
+             int src_stride_y,
+             const uint8_t* src_uv,
+             int src_stride_uv,
+             uint8_t* dst_y,
+             int dst_stride_y,
+             uint8_t* dst_uv,
+             int dst_stride_uv,
+             int width,
+             int height);
+
+// Copy NV21. Supports inverting.
+int NV21Copy(const uint8_t* src_y,
+             int src_stride_y,
+             const uint8_t* src_vu,
+             int src_stride_vu,
+             uint8_t* dst_y,
+             int dst_stride_y,
+             uint8_t* dst_vu,
+             int dst_stride_vu,
+             int width,
+             int height);
+
+// Convert YUY2 to I422.
+LIBYUV_API
+int YUY2ToI422(const uint8_t* src_yuy2,
+               int src_stride_yuy2,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_u,
+               int dst_stride_u,
+               uint8_t* dst_v,
+               int dst_stride_v,
+               int width,
+               int height);
+
+// Convert UYVY to I422.
+LIBYUV_API
+int UYVYToI422(const uint8_t* src_uyvy,
+               int src_stride_uyvy,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_u,
+               int dst_stride_u,
+               uint8_t* dst_v,
+               int dst_stride_v,
+               int width,
+               int height);
+
+LIBYUV_API
+int YUY2ToNV12(const uint8_t* src_yuy2,
+               int src_stride_yuy2,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_uv,
+               int dst_stride_uv,
+               int width,
+               int height);
+
+LIBYUV_API
+int UYVYToNV12(const uint8_t* src_uyvy,
+               int src_stride_uyvy,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_uv,
+               int dst_stride_uv,
+               int width,
+               int height);
+
+// Convert NV21 to NV12.
+LIBYUV_API
+int NV21ToNV12(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_vu,
+               int src_stride_vu,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_uv,
+               int dst_stride_uv,
+               int width,
+               int height);
+
+LIBYUV_API
+int YUY2ToY(const uint8_t* src_yuy2,
+            int src_stride_yuy2,
+            uint8_t* dst_y,
+            int dst_stride_y,
+            int width,
+            int height);
+
+LIBYUV_API
+int UYVYToY(const uint8_t* src_uyvy,
+            int src_stride_uyvy,
+            uint8_t* dst_y,
+            int dst_stride_y,
+            int width,
+            int height);
+
+// Convert I420 to I400. (calls CopyPlane ignoring u/v).
+LIBYUV_API
+int I420ToI400(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               int width,
+               int height);
+
+// Alias
+#define J420ToJ400 I420ToI400
+#define I420ToI420Mirror I420Mirror
+
+// I420 mirror.
+LIBYUV_API
+int I420Mirror(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_u,
+               int dst_stride_u,
+               uint8_t* dst_v,
+               int dst_stride_v,
+               int width,
+               int height);
+
+// Alias
+#define I400ToI400Mirror I400Mirror
+
+// I400 mirror.  A single plane is mirrored horizontally.
+// Pass negative height to achieve 180 degree rotation.
+LIBYUV_API
+int I400Mirror(const uint8_t* src_y,
+               int src_stride_y,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               int width,
+               int height);
+
+// Alias
+#define NV12ToNV12Mirror NV12Mirror
+
+// NV12 mirror.
+LIBYUV_API
+int NV12Mirror(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_uv,
+               int src_stride_uv,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_uv,
+               int dst_stride_uv,
+               int width,
+               int height);
+
+// Alias
+#define ARGBToARGBMirror ARGBMirror
+
+// ARGB mirror.
+LIBYUV_API
+int ARGBMirror(const uint8_t* src_argb,
+               int src_stride_argb,
+               uint8_t* dst_argb,
+               int dst_stride_argb,
+               int width,
+               int height);
+
+// Alias
+#define RGB24ToRGB24Mirror RGB24Mirror
+
+// RGB24 mirror.
+LIBYUV_API
+int RGB24Mirror(const uint8_t* src_rgb24,
+                int src_stride_rgb24,
+                uint8_t* dst_rgb24,
+                int dst_stride_rgb24,
+                int width,
+                int height);
+
+// Mirror a plane of data.
+LIBYUV_API
+void MirrorPlane(const uint8_t* src_y,
+                 int src_stride_y,
+                 uint8_t* dst_y,
+                 int dst_stride_y,
+                 int width,
+                 int height);
+
+// Mirror a plane of UV data.
+LIBYUV_API
+void MirrorUVPlane(const uint8_t* src_uv,
+                   int src_stride_uv,
+                   uint8_t* dst_uv,
+                   int dst_stride_uv,
+                   int width,
+                   int height);
+
+// Alias
+#define RGB24ToRAW RAWToRGB24
+
+LIBYUV_API
+int RAWToRGB24(const uint8_t* src_raw,
+               int src_stride_raw,
+               uint8_t* dst_rgb24,
+               int dst_stride_rgb24,
+               int width,
+               int height);
+
+// Draw a rectangle into I420.
+LIBYUV_API
+int I420Rect(uint8_t* dst_y,
+             int dst_stride_y,
+             uint8_t* dst_u,
+             int dst_stride_u,
+             uint8_t* dst_v,
+             int dst_stride_v,
+             int x,
+             int y,
+             int width,
+             int height,
+             int value_y,
+             int value_u,
+             int value_v);
+
+// Draw a rectangle into ARGB.
+LIBYUV_API
+int ARGBRect(uint8_t* dst_argb,
+             int dst_stride_argb,
+             int dst_x,
+             int dst_y,
+             int width,
+             int height,
+             uint32_t value);
+
+// Convert ARGB to gray scale ARGB.
+LIBYUV_API
+int ARGBGrayTo(const uint8_t* src_argb,
+               int src_stride_argb,
+               uint8_t* dst_argb,
+               int dst_stride_argb,
+               int width,
+               int height);
+
+// Make a rectangle of ARGB gray scale.
+LIBYUV_API
+int ARGBGray(uint8_t* dst_argb,
+             int dst_stride_argb,
+             int dst_x,
+             int dst_y,
+             int width,
+             int height);
+
+// Make a rectangle of ARGB Sepia tone.
+LIBYUV_API
+int ARGBSepia(uint8_t* dst_argb,
+              int dst_stride_argb,
+              int dst_x,
+              int dst_y,
+              int width,
+              int height);
+
+// Apply a matrix rotation to each ARGB pixel.
+// matrix_argb is 4 signed ARGB values. -128 to 127 representing -2 to 2.
+// The first 4 coefficients apply to B, G, R, A and produce B of the output.
+// The next 4 coefficients apply to B, G, R, A and produce G of the output.
+// The next 4 coefficients apply to B, G, R, A and produce R of the output.
+// The last 4 coefficients apply to B, G, R, A and produce A of the output.
+LIBYUV_API
+int ARGBColorMatrix(const uint8_t* src_argb,
+                    int src_stride_argb,
+                    uint8_t* dst_argb,
+                    int dst_stride_argb,
+                    const int8_t* matrix_argb,
+                    int width,
+                    int height);
+
+// Deprecated. Use ARGBColorMatrix instead.
+// Apply a matrix rotation to each ARGB pixel.
+// matrix_argb is 3 signed ARGB values. -128 to 127 representing -1 to 1.
+// The first 4 coefficients apply to B, G, R, A and produce B of the output.
+// The next 4 coefficients apply to B, G, R, A and produce G of the output.
+// The last 4 coefficients apply to B, G, R, A and produce R of the output.
+LIBYUV_API
+int RGBColorMatrix(uint8_t* dst_argb,
+                   int dst_stride_argb,
+                   const int8_t* matrix_rgb,
+                   int dst_x,
+                   int dst_y,
+                   int width,
+                   int height);
+
+// Apply a color table each ARGB pixel.
+// Table contains 256 ARGB values.
+LIBYUV_API
+int ARGBColorTable(uint8_t* dst_argb,
+                   int dst_stride_argb,
+                   const uint8_t* table_argb,
+                   int dst_x,
+                   int dst_y,
+                   int width,
+                   int height);
+
+// Apply a color table each ARGB pixel but preserve destination alpha.
+// Table contains 256 ARGB values.
+LIBYUV_API
+int RGBColorTable(uint8_t* dst_argb,
+                  int dst_stride_argb,
+                  const uint8_t* table_argb,
+                  int dst_x,
+                  int dst_y,
+                  int width,
+                  int height);
+
+// Apply a luma/color table each ARGB pixel but preserve destination alpha.
+// Table contains 32768 values indexed by [Y][C] where 7 it 7 bit luma from
+// RGB (YJ style) and C is an 8 bit color component (R, G or B).
+LIBYUV_API
+int ARGBLumaColorTable(const uint8_t* src_argb,
+                       int src_stride_argb,
+                       uint8_t* dst_argb,
+                       int dst_stride_argb,
+                       const uint8_t* luma,
+                       int width,
+                       int height);
+
+// Apply a 3 term polynomial to ARGB values.
+// poly points to a 4x4 matrix.  The first row is constants.  The 2nd row is
+// coefficients for b, g, r and a.  The 3rd row is coefficients for b squared,
+// g squared, r squared and a squared.  The 4rd row is coefficients for b to
+// the 3, g to the 3, r to the 3 and a to the 3.  The values are summed and
+// result clamped to 0 to 255.
+// A polynomial approximation can be dirived using software such as 'R'.
+
+LIBYUV_API
+int ARGBPolynomial(const uint8_t* src_argb,
+                   int src_stride_argb,
+                   uint8_t* dst_argb,
+                   int dst_stride_argb,
+                   const float* poly,
+                   int width,
+                   int height);
+
+// Convert plane of 16 bit shorts to half floats.
+// Source values are multiplied by scale before storing as half float.
+LIBYUV_API
+int HalfFloatPlane(const uint16_t* src_y,
+                   int src_stride_y,
+                   uint16_t* dst_y,
+                   int dst_stride_y,
+                   float scale,
+                   int width,
+                   int height);
+
+// Convert a buffer of bytes to floats, scale the values and store as floats.
+LIBYUV_API
+int ByteToFloat(const uint8_t* src_y, float* dst_y, float scale, int width);
+
+// Quantize a rectangle of ARGB. Alpha unaffected.
+// scale is a 16 bit fractional fixed point scaler between 0 and 65535.
+// interval_size should be a value between 1 and 255.
+// interval_offset should be a value between 0 and 255.
+LIBYUV_API
+int ARGBQuantize(uint8_t* dst_argb,
+                 int dst_stride_argb,
+                 int scale,
+                 int interval_size,
+                 int interval_offset,
+                 int dst_x,
+                 int dst_y,
+                 int width,
+                 int height);
+
+// Copy ARGB to ARGB.
+LIBYUV_API
+int ARGBCopy(const uint8_t* src_argb,
+             int src_stride_argb,
+             uint8_t* dst_argb,
+             int dst_stride_argb,
+             int width,
+             int height);
+
+// Copy Alpha channel of ARGB to alpha of ARGB.
+LIBYUV_API
+int ARGBCopyAlpha(const uint8_t* src_argb,
+                  int src_stride_argb,
+                  uint8_t* dst_argb,
+                  int dst_stride_argb,
+                  int width,
+                  int height);
+
+// Extract the alpha channel from ARGB.
+LIBYUV_API
+int ARGBExtractAlpha(const uint8_t* src_argb,
+                     int src_stride_argb,
+                     uint8_t* dst_a,
+                     int dst_stride_a,
+                     int width,
+                     int height);
+
+// Copy Y channel to Alpha of ARGB.
+LIBYUV_API
+int ARGBCopyYToAlpha(const uint8_t* src_y,
+                     int src_stride_y,
+                     uint8_t* dst_argb,
+                     int dst_stride_argb,
+                     int width,
+                     int height);
+
+typedef void (*ARGBBlendRow)(const uint8_t* src_argb0,
+                             const uint8_t* src_argb1,
+                             uint8_t* dst_argb,
+                             int width);
+
+// Get function to Alpha Blend ARGB pixels and store to destination.
+LIBYUV_API
+ARGBBlendRow GetARGBBlend();
+
+// Alpha Blend ARGB images and store to destination.
+// Source is pre-multiplied by alpha using ARGBAttenuate.
+// Alpha of destination is set to 255.
+LIBYUV_API
+int ARGBBlend(const uint8_t* src_argb0,
+              int src_stride_argb0,
+              const uint8_t* src_argb1,
+              int src_stride_argb1,
+              uint8_t* dst_argb,
+              int dst_stride_argb,
+              int width,
+              int height);
+
+// Alpha Blend plane and store to destination.
+// Source is not pre-multiplied by alpha.
+LIBYUV_API
+int BlendPlane(const uint8_t* src_y0,
+               int src_stride_y0,
+               const uint8_t* src_y1,
+               int src_stride_y1,
+               const uint8_t* alpha,
+               int alpha_stride,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               int width,
+               int height);
+
+// Alpha Blend YUV images and store to destination.
+// Source is not pre-multiplied by alpha.
+// Alpha is full width x height and subsampled to half size to apply to UV.
+LIBYUV_API
+int I420Blend(const uint8_t* src_y0,
+              int src_stride_y0,
+              const uint8_t* src_u0,
+              int src_stride_u0,
+              const uint8_t* src_v0,
+              int src_stride_v0,
+              const uint8_t* src_y1,
+              int src_stride_y1,
+              const uint8_t* src_u1,
+              int src_stride_u1,
+              const uint8_t* src_v1,
+              int src_stride_v1,
+              const uint8_t* alpha,
+              int alpha_stride,
+              uint8_t* dst_y,
+              int dst_stride_y,
+              uint8_t* dst_u,
+              int dst_stride_u,
+              uint8_t* dst_v,
+              int dst_stride_v,
+              int width,
+              int height);
+
+// Multiply ARGB image by ARGB image. Shifted down by 8. Saturates to 255.
+LIBYUV_API
+int ARGBMultiply(const uint8_t* src_argb0,
+                 int src_stride_argb0,
+                 const uint8_t* src_argb1,
+                 int src_stride_argb1,
+                 uint8_t* dst_argb,
+                 int dst_stride_argb,
+                 int width,
+                 int height);
+
+// Add ARGB image with ARGB image. Saturates to 255.
+LIBYUV_API
+int ARGBAdd(const uint8_t* src_argb0,
+            int src_stride_argb0,
+            const uint8_t* src_argb1,
+            int src_stride_argb1,
+            uint8_t* dst_argb,
+            int dst_stride_argb,
+            int width,
+            int height);
+
+// Subtract ARGB image (argb1) from ARGB image (argb0). Saturates to 0.
+LIBYUV_API
+int ARGBSubtract(const uint8_t* src_argb0,
+                 int src_stride_argb0,
+                 const uint8_t* src_argb1,
+                 int src_stride_argb1,
+                 uint8_t* dst_argb,
+                 int dst_stride_argb,
+                 int width,
+                 int height);
+
+// Convert I422 to YUY2.
+LIBYUV_API
+int I422ToYUY2(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_yuy2,
+               int dst_stride_yuy2,
+               int width,
+               int height);
+
+// Convert I422 to UYVY.
+LIBYUV_API
+int I422ToUYVY(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_uyvy,
+               int dst_stride_uyvy,
+               int width,
+               int height);
+
+// Convert unattentuated ARGB to preattenuated ARGB.
+LIBYUV_API
+int ARGBAttenuate(const uint8_t* src_argb,
+                  int src_stride_argb,
+                  uint8_t* dst_argb,
+                  int dst_stride_argb,
+                  int width,
+                  int height);
+
+// Convert preattentuated ARGB to unattenuated ARGB.
+LIBYUV_API
+int ARGBUnattenuate(const uint8_t* src_argb,
+                    int src_stride_argb,
+                    uint8_t* dst_argb,
+                    int dst_stride_argb,
+                    int width,
+                    int height);
+
+// Internal function - do not call directly.
+// Computes table of cumulative sum for image where the value is the sum
+// of all values above and to the left of the entry. Used by ARGBBlur.
+LIBYUV_API
+int ARGBComputeCumulativeSum(const uint8_t* src_argb,
+                             int src_stride_argb,
+                             int32_t* dst_cumsum,
+                             int dst_stride32_cumsum,
+                             int width,
+                             int height);
+
+// Blur ARGB image.
+// dst_cumsum table of width * (height + 1) * 16 bytes aligned to
+//   16 byte boundary.
+// dst_stride32_cumsum is number of ints in a row (width * 4).
+// radius is number of pixels around the center.  e.g. 1 = 3x3. 2=5x5.
+// Blur is optimized for radius of 5 (11x11) or less.
+LIBYUV_API
+int ARGBBlur(const uint8_t* src_argb,
+             int src_stride_argb,
+             uint8_t* dst_argb,
+             int dst_stride_argb,
+             int32_t* dst_cumsum,
+             int dst_stride32_cumsum,
+             int width,
+             int height,
+             int radius);
+
+// Gaussian 5x5 blur a float plane.
+// Coefficients of 1, 4, 6, 4, 1.
+// Each destination pixel is a blur of the 5x5
+// pixels from the source.
+// Source edges are clamped.
+LIBYUV_API
+int GaussPlane_F32(const float* src,
+                   int src_stride,
+                   float* dst,
+                   int dst_stride,
+                   int width,
+                   int height);
+
+// Multiply ARGB image by ARGB value.
+LIBYUV_API
+int ARGBShade(const uint8_t* src_argb,
+              int src_stride_argb,
+              uint8_t* dst_argb,
+              int dst_stride_argb,
+              int width,
+              int height,
+              uint32_t value);
+
+// Interpolate between two images using specified amount of interpolation
+// (0 to 255) and store to destination.
+// 'interpolation' is specified as 8 bit fraction where 0 means 100% src0
+// and 255 means 1% src0 and 99% src1.
+LIBYUV_API
+int InterpolatePlane(const uint8_t* src0,
+                     int src_stride0,
+                     const uint8_t* src1,
+                     int src_stride1,
+                     uint8_t* dst,
+                     int dst_stride,
+                     int width,
+                     int height,
+                     int interpolation);
+
+// Interpolate between two images using specified amount of interpolation
+// (0 to 255) and store to destination.
+// 'interpolation' is specified as 8 bit fraction where 0 means 100% src0
+// and 255 means 1% src0 and 99% src1.
+LIBYUV_API
+int InterpolatePlane_16(const uint16_t* src0,
+                        int src_stride0,  // measured in 16 bit pixels
+                        const uint16_t* src1,
+                        int src_stride1,
+                        uint16_t* dst,
+                        int dst_stride,
+                        int width,
+                        int height,
+                        int interpolation);
+
+// Interpolate between two ARGB images using specified amount of interpolation
+// Internally calls InterpolatePlane with width * 4 (bpp).
+LIBYUV_API
+int ARGBInterpolate(const uint8_t* src_argb0,
+                    int src_stride_argb0,
+                    const uint8_t* src_argb1,
+                    int src_stride_argb1,
+                    uint8_t* dst_argb,
+                    int dst_stride_argb,
+                    int width,
+                    int height,
+                    int interpolation);
+
+// Interpolate between two YUV images using specified amount of interpolation
+// Internally calls InterpolatePlane on each plane where the U and V planes
+// are half width and half height.
+LIBYUV_API
+int I420Interpolate(const uint8_t* src0_y,
+                    int src0_stride_y,
+                    const uint8_t* src0_u,
+                    int src0_stride_u,
+                    const uint8_t* src0_v,
+                    int src0_stride_v,
+                    const uint8_t* src1_y,
+                    int src1_stride_y,
+                    const uint8_t* src1_u,
+                    int src1_stride_u,
+                    const uint8_t* src1_v,
+                    int src1_stride_v,
+                    uint8_t* dst_y,
+                    int dst_stride_y,
+                    uint8_t* dst_u,
+                    int dst_stride_u,
+                    uint8_t* dst_v,
+                    int dst_stride_v,
+                    int width,
+                    int height,
+                    int interpolation);
+
+// Row function for copying pixels from a source with a slope to a row
+// of destination. Useful for scaling, rotation, mirror, texture mapping.
+LIBYUV_API
+void ARGBAffineRow_C(const uint8_t* src_argb,
+                     int src_argb_stride,
+                     uint8_t* dst_argb,
+                     const float* uv_dudv,
+                     int width);
+// TODO(fbarchard): Move ARGBAffineRow_SSE2 to row.h
+LIBYUV_API
+void ARGBAffineRow_SSE2(const uint8_t* src_argb,
+                        int src_argb_stride,
+                        uint8_t* dst_argb,
+                        const float* uv_dudv,
+                        int width);
+
+// Shuffle ARGB channel order.  e.g. BGRA to ARGB.
+// shuffler is 16 bytes.
+LIBYUV_API
+int ARGBShuffle(const uint8_t* src_bgra,
+                int src_stride_bgra,
+                uint8_t* dst_argb,
+                int dst_stride_argb,
+                const uint8_t* shuffler,
+                int width,
+                int height);
+
+// Shuffle AR64 channel order.  e.g. AR64 to AB64.
+// shuffler is 16 bytes.
+LIBYUV_API
+int AR64Shuffle(const uint16_t* src_ar64,
+                int src_stride_ar64,
+                uint16_t* dst_ar64,
+                int dst_stride_ar64,
+                const uint8_t* shuffler,
+                int width,
+                int height);
+
+// Sobel ARGB effect with planar output.
+LIBYUV_API
+int ARGBSobelToPlane(const uint8_t* src_argb,
+                     int src_stride_argb,
+                     uint8_t* dst_y,
+                     int dst_stride_y,
+                     int width,
+                     int height);
+
+// Sobel ARGB effect.
+LIBYUV_API
+int ARGBSobel(const uint8_t* src_argb,
+              int src_stride_argb,
+              uint8_t* dst_argb,
+              int dst_stride_argb,
+              int width,
+              int height);
+
+// Sobel ARGB effect w/ Sobel X, Sobel, Sobel Y in ARGB.
+LIBYUV_API
+int ARGBSobelXY(const uint8_t* src_argb,
+                int src_stride_argb,
+                uint8_t* dst_argb,
+                int dst_stride_argb,
+                int width,
+                int height);
+
+#ifdef __cplusplus
+}  // extern "C"
+}  // namespace libyuv
+#endif
+
+#endif  // INCLUDE_LIBYUV_PLANAR_FUNCTIONS_H_
diff --git a/3rdparty/libyuv/src/include/libyuv/rotate.h b/3rdparty/libyuv/src/include/libyuv/rotate.h
new file mode 100644
index 00000000..684ed5e6
--- /dev/null
+++ b/3rdparty/libyuv/src/include/libyuv/rotate.h
@@ -0,0 +1,232 @@
+/*
+ *  Copyright 2011 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#ifndef INCLUDE_LIBYUV_ROTATE_H_
+#define INCLUDE_LIBYUV_ROTATE_H_
+
+#include "libyuv/basic_types.h"
+
+#ifdef __cplusplus
+namespace libyuv {
+extern "C" {
+#endif
+
+// Supported rotation.
+typedef enum RotationMode {
+  kRotate0 = 0,      // No rotation.
+  kRotate90 = 90,    // Rotate 90 degrees clockwise.
+  kRotate180 = 180,  // Rotate 180 degrees.
+  kRotate270 = 270,  // Rotate 270 degrees clockwise.
+
+  // Deprecated.
+  kRotateNone = 0,
+  kRotateClockwise = 90,
+  kRotateCounterClockwise = 270,
+} RotationModeEnum;
+
+// Rotate I420 frame.
+LIBYUV_API
+int I420Rotate(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_u,
+               int dst_stride_u,
+               uint8_t* dst_v,
+               int dst_stride_v,
+               int width,
+               int height,
+               enum RotationMode mode);
+
+// Rotate I422 frame.
+LIBYUV_API
+int I422Rotate(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_u,
+               int dst_stride_u,
+               uint8_t* dst_v,
+               int dst_stride_v,
+               int width,
+               int height,
+               enum RotationMode mode);
+
+// Rotate I444 frame.
+LIBYUV_API
+int I444Rotate(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_u,
+               int dst_stride_u,
+               uint8_t* dst_v,
+               int dst_stride_v,
+               int width,
+               int height,
+               enum RotationMode mode);
+
+// Rotate NV12 input and store in I420.
+LIBYUV_API
+int NV12ToI420Rotate(const uint8_t* src_y,
+                     int src_stride_y,
+                     const uint8_t* src_uv,
+                     int src_stride_uv,
+                     uint8_t* dst_y,
+                     int dst_stride_y,
+                     uint8_t* dst_u,
+                     int dst_stride_u,
+                     uint8_t* dst_v,
+                     int dst_stride_v,
+                     int width,
+                     int height,
+                     enum RotationMode mode);
+
+// Convert Android420 to I420 with rotation.
+// "rotation" can be 0, 90, 180 or 270.
+LIBYUV_API
+int Android420ToI420Rotate(const uint8_t* src_y,
+                           int src_stride_y,
+                           const uint8_t* src_u,
+                           int src_stride_u,
+                           const uint8_t* src_v,
+                           int src_stride_v,
+                           int src_pixel_stride_uv,
+                           uint8_t* dst_y,
+                           int dst_stride_y,
+                           uint8_t* dst_u,
+                           int dst_stride_u,
+                           uint8_t* dst_v,
+                           int dst_stride_v,
+                           int width,
+                           int height,
+                           enum RotationMode rotation);
+
+// Rotate a plane by 0, 90, 180, or 270.
+LIBYUV_API
+int RotatePlane(const uint8_t* src,
+                int src_stride,
+                uint8_t* dst,
+                int dst_stride,
+                int width,
+                int height,
+                enum RotationMode mode);
+
+// Rotate planes by 90, 180, 270. Deprecated.
+LIBYUV_API
+void RotatePlane90(const uint8_t* src,
+                   int src_stride,
+                   uint8_t* dst,
+                   int dst_stride,
+                   int width,
+                   int height);
+
+LIBYUV_API
+void RotatePlane180(const uint8_t* src,
+                    int src_stride,
+                    uint8_t* dst,
+                    int dst_stride,
+                    int width,
+                    int height);
+
+LIBYUV_API
+void RotatePlane270(const uint8_t* src,
+                    int src_stride,
+                    uint8_t* dst,
+                    int dst_stride,
+                    int width,
+                    int height);
+
+// Rotations for when U and V are interleaved.
+// These functions take one UV input pointer and
+// split the data into two buffers while
+// rotating them.
+// width and height expected to be half size for NV12.
+LIBYUV_API
+int SplitRotateUV(const uint8_t* src_uv,
+                  int src_stride_uv,
+                  uint8_t* dst_u,
+                  int dst_stride_u,
+                  uint8_t* dst_v,
+                  int dst_stride_v,
+                  int width,
+                  int height,
+                  enum RotationMode mode);
+
+LIBYUV_API
+void SplitRotateUV90(const uint8_t* src,
+                     int src_stride,
+                     uint8_t* dst_a,
+                     int dst_stride_a,
+                     uint8_t* dst_b,
+                     int dst_stride_b,
+                     int width,
+                     int height);
+
+LIBYUV_API
+void SplitRotateUV180(const uint8_t* src,
+                      int src_stride,
+                      uint8_t* dst_a,
+                      int dst_stride_a,
+                      uint8_t* dst_b,
+                      int dst_stride_b,
+                      int width,
+                      int height);
+
+LIBYUV_API
+void SplitRotateUV270(const uint8_t* src,
+                      int src_stride,
+                      uint8_t* dst_a,
+                      int dst_stride_a,
+                      uint8_t* dst_b,
+                      int dst_stride_b,
+                      int width,
+                      int height);
+
+// The 90 and 270 functions are based on transposes.
+// Doing a transpose with reversing the read/write
+// order will result in a rotation by +- 90 degrees.
+// Deprecated.
+LIBYUV_API
+void TransposePlane(const uint8_t* src,
+                    int src_stride,
+                    uint8_t* dst,
+                    int dst_stride,
+                    int width,
+                    int height);
+
+LIBYUV_API
+void SplitTransposeUV(const uint8_t* src,
+                      int src_stride,
+                      uint8_t* dst_a,
+                      int dst_stride_a,
+                      uint8_t* dst_b,
+                      int dst_stride_b,
+                      int width,
+                      int height);
+
+#ifdef __cplusplus
+}  // extern "C"
+}  // namespace libyuv
+#endif
+
+#endif  // INCLUDE_LIBYUV_ROTATE_H_
diff --git a/3rdparty/libyuv/src/include/libyuv/rotate_argb.h b/3rdparty/libyuv/src/include/libyuv/rotate_argb.h
new file mode 100644
index 00000000..20432949
--- /dev/null
+++ b/3rdparty/libyuv/src/include/libyuv/rotate_argb.h
@@ -0,0 +1,37 @@
+/*
+ *  Copyright 2012 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#ifndef INCLUDE_LIBYUV_ROTATE_ARGB_H_
+#define INCLUDE_LIBYUV_ROTATE_ARGB_H_
+
+#include "libyuv/basic_types.h"
+#include "libyuv/rotate.h"  // For RotationMode.
+
+#ifdef __cplusplus
+namespace libyuv {
+extern "C" {
+#endif
+
+// Rotate ARGB frame
+LIBYUV_API
+int ARGBRotate(const uint8_t* src_argb,
+               int src_stride_argb,
+               uint8_t* dst_argb,
+               int dst_stride_argb,
+               int src_width,
+               int src_height,
+               enum RotationMode mode);
+
+#ifdef __cplusplus
+}  // extern "C"
+}  // namespace libyuv
+#endif
+
+#endif  // INCLUDE_LIBYUV_ROTATE_ARGB_H_
diff --git a/3rdparty/libyuv/src/include/libyuv/rotate_row.h b/3rdparty/libyuv/src/include/libyuv/rotate_row.h
new file mode 100644
index 00000000..aa8528a9
--- /dev/null
+++ b/3rdparty/libyuv/src/include/libyuv/rotate_row.h
@@ -0,0 +1,224 @@
+/*
+ *  Copyright 2013 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#ifndef INCLUDE_LIBYUV_ROTATE_ROW_H_
+#define INCLUDE_LIBYUV_ROTATE_ROW_H_
+
+#include "libyuv/basic_types.h"
+
+#ifdef __cplusplus
+namespace libyuv {
+extern "C" {
+#endif
+
+#if defined(__pnacl__) || defined(__CLR_VER) ||            \
+    (defined(__native_client__) && defined(__x86_64__)) || \
+    (defined(__i386__) && !defined(__SSE__) && !defined(__clang__))
+#define LIBYUV_DISABLE_X86
+#endif
+#if defined(__native_client__)
+#define LIBYUV_DISABLE_NEON
+#endif
+// MemorySanitizer does not support assembly code yet. http://crbug.com/344505
+#if defined(__has_feature)
+#if __has_feature(memory_sanitizer)
+#define LIBYUV_DISABLE_X86
+#endif
+#endif
+// The following are available for Visual C 32 bit:
+#if !defined(LIBYUV_DISABLE_X86) && defined(_M_IX86) && defined(_MSC_VER) && \
+    !defined(__clang__)
+#define HAS_TRANSPOSEWX8_SSSE3
+#define HAS_TRANSPOSEUVWX8_SSE2
+#endif
+
+// The following are available for GCC 32 or 64 bit:
+#if !defined(LIBYUV_DISABLE_X86) && (defined(__i386__) || defined(__x86_64__))
+#define HAS_TRANSPOSEWX8_SSSE3
+#endif
+
+// The following are available for 64 bit GCC:
+#if !defined(LIBYUV_DISABLE_X86) && defined(__x86_64__)
+#define HAS_TRANSPOSEWX8_FAST_SSSE3
+#define HAS_TRANSPOSEUVWX8_SSE2
+#endif
+
+#if !defined(LIBYUV_DISABLE_NEON) && \
+    (defined(__ARM_NEON__) || defined(LIBYUV_NEON) || defined(__aarch64__))
+#define HAS_TRANSPOSEWX8_NEON
+#define HAS_TRANSPOSEUVWX8_NEON
+#endif
+
+#if !defined(LIBYUV_DISABLE_MSA) && defined(__mips_msa)
+#define HAS_TRANSPOSEWX16_MSA
+#define HAS_TRANSPOSEUVWX16_MSA
+#endif
+
+#if !defined(LIBYUV_DISABLE_LSX) && defined(__loongarch_sx)
+#define HAS_TRANSPOSEWX16_LSX
+#define HAS_TRANSPOSEUVWX16_LSX
+#endif
+
+void TransposeWxH_C(const uint8_t* src,
+                    int src_stride,
+                    uint8_t* dst,
+                    int dst_stride,
+                    int width,
+                    int height);
+
+void TransposeWx8_C(const uint8_t* src,
+                    int src_stride,
+                    uint8_t* dst,
+                    int dst_stride,
+                    int width);
+void TransposeWx16_C(const uint8_t* src,
+                     int src_stride,
+                     uint8_t* dst,
+                     int dst_stride,
+                     int width);
+void TransposeWx8_NEON(const uint8_t* src,
+                       int src_stride,
+                       uint8_t* dst,
+                       int dst_stride,
+                       int width);
+void TransposeWx8_SSSE3(const uint8_t* src,
+                        int src_stride,
+                        uint8_t* dst,
+                        int dst_stride,
+                        int width);
+void TransposeWx8_Fast_SSSE3(const uint8_t* src,
+                             int src_stride,
+                             uint8_t* dst,
+                             int dst_stride,
+                             int width);
+void TransposeWx16_MSA(const uint8_t* src,
+                       int src_stride,
+                       uint8_t* dst,
+                       int dst_stride,
+                       int width);
+void TransposeWx16_LSX(const uint8_t* src,
+                       int src_stride,
+                       uint8_t* dst,
+                       int dst_stride,
+                       int width);
+
+void TransposeWx8_Any_NEON(const uint8_t* src,
+                           int src_stride,
+                           uint8_t* dst,
+                           int dst_stride,
+                           int width);
+void TransposeWx8_Any_SSSE3(const uint8_t* src,
+                            int src_stride,
+                            uint8_t* dst,
+                            int dst_stride,
+                            int width);
+void TransposeWx8_Fast_Any_SSSE3(const uint8_t* src,
+                                 int src_stride,
+                                 uint8_t* dst,
+                                 int dst_stride,
+                                 int width);
+void TransposeWx16_Any_MSA(const uint8_t* src,
+                           int src_stride,
+                           uint8_t* dst,
+                           int dst_stride,
+                           int width);
+void TransposeWx16_Any_LSX(const uint8_t* src,
+                           int src_stride,
+                           uint8_t* dst,
+                           int dst_stride,
+                           int width);
+
+void TransposeUVWxH_C(const uint8_t* src,
+                      int src_stride,
+                      uint8_t* dst_a,
+                      int dst_stride_a,
+                      uint8_t* dst_b,
+                      int dst_stride_b,
+                      int width,
+                      int height);
+
+void TransposeUVWx8_C(const uint8_t* src,
+                      int src_stride,
+                      uint8_t* dst_a,
+                      int dst_stride_a,
+                      uint8_t* dst_b,
+                      int dst_stride_b,
+                      int width);
+void TransposeUVWx16_C(const uint8_t* src,
+                       int src_stride,
+                       uint8_t* dst_a,
+                       int dst_stride_a,
+                       uint8_t* dst_b,
+                       int dst_stride_b,
+                       int width);
+void TransposeUVWx8_SSE2(const uint8_t* src,
+                         int src_stride,
+                         uint8_t* dst_a,
+                         int dst_stride_a,
+                         uint8_t* dst_b,
+                         int dst_stride_b,
+                         int width);
+void TransposeUVWx8_NEON(const uint8_t* src,
+                         int src_stride,
+                         uint8_t* dst_a,
+                         int dst_stride_a,
+                         uint8_t* dst_b,
+                         int dst_stride_b,
+                         int width);
+void TransposeUVWx16_MSA(const uint8_t* src,
+                         int src_stride,
+                         uint8_t* dst_a,
+                         int dst_stride_a,
+                         uint8_t* dst_b,
+                         int dst_stride_b,
+                         int width);
+void TransposeUVWx16_LSX(const uint8_t* src,
+                         int src_stride,
+                         uint8_t* dst_a,
+                         int dst_stride_a,
+                         uint8_t* dst_b,
+                         int dst_stride_b,
+                         int width);
+
+void TransposeUVWx8_Any_SSE2(const uint8_t* src,
+                             int src_stride,
+                             uint8_t* dst_a,
+                             int dst_stride_a,
+                             uint8_t* dst_b,
+                             int dst_stride_b,
+                             int width);
+void TransposeUVWx8_Any_NEON(const uint8_t* src,
+                             int src_stride,
+                             uint8_t* dst_a,
+                             int dst_stride_a,
+                             uint8_t* dst_b,
+                             int dst_stride_b,
+                             int width);
+void TransposeUVWx16_Any_MSA(const uint8_t* src,
+                             int src_stride,
+                             uint8_t* dst_a,
+                             int dst_stride_a,
+                             uint8_t* dst_b,
+                             int dst_stride_b,
+                             int width);
+void TransposeUVWx16_Any_LSX(const uint8_t* src,
+                             int src_stride,
+                             uint8_t* dst_a,
+                             int dst_stride_a,
+                             uint8_t* dst_b,
+                             int dst_stride_b,
+                             int width);
+
+#ifdef __cplusplus
+}  // extern "C"
+}  // namespace libyuv
+#endif
+
+#endif  // INCLUDE_LIBYUV_ROTATE_ROW_H_
diff --git a/3rdparty/libyuv/src/include/libyuv/row.h b/3rdparty/libyuv/src/include/libyuv/row.h
new file mode 100644
index 00000000..1a1cf4b6
--- /dev/null
+++ b/3rdparty/libyuv/src/include/libyuv/row.h
@@ -0,0 +1,5534 @@
+/*
+ *  Copyright 2011 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#ifndef INCLUDE_LIBYUV_ROW_H_
+#define INCLUDE_LIBYUV_ROW_H_
+
+#include <stdlib.h>  // For malloc.
+
+#include "libyuv/basic_types.h"
+
+#ifdef __cplusplus
+namespace libyuv {
+extern "C" {
+#endif
+
+#if defined(__pnacl__) || defined(__CLR_VER) ||            \
+    (defined(__native_client__) && defined(__x86_64__)) || \
+    (defined(__i386__) && !defined(__SSE__) && !defined(__clang__))
+#define LIBYUV_DISABLE_X86
+#endif
+#if defined(__native_client__)
+#define LIBYUV_DISABLE_NEON
+#endif
+// MemorySanitizer does not support assembly code yet. http://crbug.com/344505
+#if defined(__has_feature)
+#if __has_feature(memory_sanitizer)
+#define LIBYUV_DISABLE_X86
+#endif
+#endif
+// clang >= 3.5.0 required for Arm64.
+#if defined(__clang__) && defined(__aarch64__) && !defined(LIBYUV_DISABLE_NEON)
+#if (__clang_major__ < 3) || (__clang_major__ == 3 && (__clang_minor__ < 5))
+#define LIBYUV_DISABLE_NEON
+#endif  // clang >= 3.5
+#endif  // __clang__
+
+// GCC >= 4.7.0 required for AVX2.
+#if defined(__GNUC__) && (defined(__x86_64__) || defined(__i386__))
+#if (__GNUC__ > 4) || (__GNUC__ == 4 && (__GNUC_MINOR__ >= 7))
+#define GCC_HAS_AVX2 1
+#endif  // GNUC >= 4.7
+#endif  // __GNUC__
+
+// clang >= 3.4.0 required for AVX2.
+#if defined(__clang__) && (defined(__x86_64__) || defined(__i386__))
+#if (__clang_major__ > 3) || (__clang_major__ == 3 && (__clang_minor__ >= 4))
+#define CLANG_HAS_AVX2 1
+#endif  // clang >= 3.4
+#endif  // __clang__
+
+// clang >= 6.0.0 required for AVX512.
+#if defined(__clang__) && (defined(__x86_64__) || defined(__i386__))
+// clang in xcode follows a different versioning scheme.
+// TODO(fbarchard): fix xcode 9 ios b/789.
+#if (__clang_major__ >= 7) && !defined(__APPLE__)
+#define CLANG_HAS_AVX512 1
+#endif  // clang >= 7
+#endif  // __clang__
+
+// Visual C 2012 required for AVX2.
+#if defined(_M_IX86) && !defined(__clang__) && defined(_MSC_VER) && \
+    _MSC_VER >= 1700
+#define VISUALC_HAS_AVX2 1
+#endif  // VisualStudio >= 2012
+
+// The following are available on all x86 platforms:
+#if !defined(LIBYUV_DISABLE_X86) && \
+    (defined(_M_IX86) || defined(__x86_64__) || defined(__i386__))
+// Conversions:
+#define HAS_ABGRTOYROW_SSSE3
+#if !defined(LIBYUV_BIT_EXACT)
+#define HAS_ABGRTOUVROW_SSSE3
+#endif
+#define HAS_ARGB1555TOARGBROW_SSE2
+#define HAS_ARGB4444TOARGBROW_SSE2
+#define HAS_ARGBEXTRACTALPHAROW_SSE2
+#define HAS_ARGBSETROW_X86
+#define HAS_ARGBSHUFFLEROW_SSSE3
+#define HAS_ARGBTOARGB1555ROW_SSE2
+#define HAS_ARGBTOARGB4444ROW_SSE2
+#define HAS_ARGBTORAWROW_SSSE3
+#define HAS_ARGBTORGB24ROW_SSSE3
+#define HAS_ARGBTORGB565DITHERROW_SSE2
+#define HAS_ARGBTORGB565ROW_SSE2
+#define HAS_ARGBTOYJROW_SSSE3
+#define HAS_ARGBTOYROW_SSSE3
+#define HAS_BGRATOYROW_SSSE3
+#if !defined(LIBYUV_BIT_EXACT)
+#define HAS_ARGBTOUV444ROW_SSSE3
+#define HAS_ARGBTOUVJROW_SSSE3
+#define HAS_ARGBTOUVROW_SSSE3
+#define HAS_BGRATOUVROW_SSSE3
+#endif
+#define HAS_COPYROW_ERMS
+#define HAS_COPYROW_SSE2
+#define HAS_H422TOARGBROW_SSSE3
+#define HAS_HALFFLOATROW_SSE2
+#define HAS_I422TOARGB1555ROW_SSSE3
+#define HAS_I422TOARGB4444ROW_SSSE3
+#define HAS_I422TOARGBROW_SSSE3
+#define HAS_I422TORGB24ROW_SSSE3
+#define HAS_I422TORGB565ROW_SSSE3
+#define HAS_I422TORGBAROW_SSSE3
+#define HAS_I422TOUYVYROW_SSE2
+#define HAS_I422TOYUY2ROW_SSE2
+#define HAS_I444TOARGBROW_SSSE3
+#define HAS_INTERPOLATEROW_SSSE3
+#define HAS_J400TOARGBROW_SSE2
+#define HAS_J422TOARGBROW_SSSE3
+#define HAS_MERGEUVROW_SSE2
+#define HAS_MIRRORROW_SSSE3
+#define HAS_MIRRORSPLITUVROW_SSSE3
+#define HAS_NV12TOARGBROW_SSSE3
+#define HAS_NV12TORGB24ROW_SSSE3
+#define HAS_NV12TORGB565ROW_SSSE3
+#define HAS_NV21TOARGBROW_SSSE3
+#define HAS_NV21TORGB24ROW_SSSE3
+#define HAS_RAWTOARGBROW_SSSE3
+#define HAS_RAWTORGB24ROW_SSSE3
+#define HAS_RAWTOYROW_SSSE3
+#define HAS_RGB24TOARGBROW_SSSE3
+#define HAS_RGB24TOYROW_SSSE3
+#define HAS_RGB565TOARGBROW_SSE2
+#define HAS_RGBATOYROW_SSSE3
+#if !defined(LIBYUV_BIT_EXACT)
+#define HAS_RGB24TOYJROW_SSSE3
+#define HAS_RAWTOYJROW_SSSE3
+#define HAS_RGBATOUVROW_SSSE3
+#endif
+#define HAS_SETROW_ERMS
+#define HAS_SETROW_X86
+#define HAS_SPLITUVROW_SSE2
+#define HAS_UYVYTOARGBROW_SSSE3
+#define HAS_UYVYTOUV422ROW_SSE2
+#define HAS_UYVYTOUVROW_SSE2
+#define HAS_UYVYTOYROW_SSE2
+#define HAS_YUY2TOARGBROW_SSSE3
+#define HAS_YUY2TOUV422ROW_SSE2
+#define HAS_YUY2TOUVROW_SSE2
+#define HAS_YUY2TOYROW_SSE2
+
+// Effects:
+#define HAS_ARGBADDROW_SSE2
+#define HAS_ARGBAFFINEROW_SSE2
+#if !defined(LIBYUV_BIT_EXACT)
+#define HAS_ARGBATTENUATEROW_SSSE3
+#endif
+#define HAS_ARGBBLENDROW_SSSE3
+#define HAS_ARGBCOLORMATRIXROW_SSSE3
+#define HAS_ARGBCOLORTABLEROW_X86
+#define HAS_ARGBCOPYALPHAROW_SSE2
+#define HAS_ARGBCOPYYTOALPHAROW_SSE2
+#define HAS_ARGBGRAYROW_SSSE3
+#define HAS_ARGBLUMACOLORTABLEROW_SSSE3
+#define HAS_ARGBMIRRORROW_SSE2
+#define HAS_ARGBMULTIPLYROW_SSE2
+#define HAS_ARGBPOLYNOMIALROW_SSE2
+#define HAS_ARGBQUANTIZEROW_SSE2
+#define HAS_ARGBSEPIAROW_SSSE3
+#define HAS_ARGBSHADEROW_SSE2
+#define HAS_ARGBSUBTRACTROW_SSE2
+#define HAS_ARGBUNATTENUATEROW_SSE2
+#define HAS_BLENDPLANEROW_SSSE3
+#define HAS_COMPUTECUMULATIVESUMROW_SSE2
+#define HAS_CUMULATIVESUMTOAVERAGEROW_SSE2
+#define HAS_RGBCOLORTABLEROW_X86
+#define HAS_SOBELROW_SSE2
+#define HAS_SOBELTOPLANEROW_SSE2
+#define HAS_SOBELXROW_SSE2
+#define HAS_SOBELXYROW_SSE2
+#define HAS_SOBELYROW_SSE2
+
+// The following functions fail on gcc/clang 32 bit with fpic and framepointer.
+// caveat: clangcl uses row_win.cc which works.
+#if defined(__x86_64__) || !defined(__pic__) || defined(__clang__) || \
+    defined(_MSC_VER)
+// TODO(fbarchard): fix build error on android_full_debug=1
+// https://code.google.com/p/libyuv/issues/detail?id=517
+#define HAS_I422ALPHATOARGBROW_SSSE3
+#define HAS_I444ALPHATOARGBROW_SSSE3
+#endif
+#endif
+
+// The following are available on all x86 platforms, but
+// require VS2012, clang 3.4 or gcc 4.7.
+#if !defined(LIBYUV_DISABLE_X86) &&                          \
+    (defined(VISUALC_HAS_AVX2) || defined(CLANG_HAS_AVX2) || \
+     defined(GCC_HAS_AVX2))
+#define HAS_ARGBCOPYALPHAROW_AVX2
+#define HAS_ARGBCOPYYTOALPHAROW_AVX2
+#define HAS_ARGBEXTRACTALPHAROW_AVX2
+#define HAS_ARGBMIRRORROW_AVX2
+#define HAS_ARGBPOLYNOMIALROW_AVX2
+#define HAS_ARGBSHUFFLEROW_AVX2
+#define HAS_ARGBTORGB565DITHERROW_AVX2
+#define HAS_ARGBTOYJROW_AVX2
+#define HAS_RAWTOYJROW_AVX2
+#define HAS_RGB24TOYJROW_AVX2
+#define HAS_ARGBTOYROW_AVX2
+#if !defined(LIBYUV_BIT_EXACT)
+#define HAS_ARGBTOUVJROW_AVX2
+#define HAS_ARGBTOUVROW_AVX2
+#endif
+#define HAS_COPYROW_AVX
+#define HAS_H422TOARGBROW_AVX2
+#define HAS_HALFFLOATROW_AVX2
+//  #define HAS_HALFFLOATROW_F16C  // Enable to test halffloat cast
+#define HAS_I422TOARGB1555ROW_AVX2
+#define HAS_I422TOARGB4444ROW_AVX2
+#define HAS_I422TOARGBROW_AVX2
+#define HAS_I422TORGB24ROW_AVX2
+#define HAS_I422TORGB565ROW_AVX2
+#define HAS_I422TORGBAROW_AVX2
+#define HAS_I444TOARGBROW_AVX2
+#define HAS_INTERPOLATEROW_AVX2
+#define HAS_J422TOARGBROW_AVX2
+#define HAS_MERGEUVROW_AVX2
+#define HAS_MIRRORROW_AVX2
+#define HAS_NV12TOARGBROW_AVX2
+#define HAS_NV12TORGB24ROW_AVX2
+#define HAS_NV12TORGB565ROW_AVX2
+#define HAS_NV21TOARGBROW_AVX2
+#define HAS_NV21TORGB24ROW_AVX2
+#define HAS_SPLITUVROW_AVX2
+#define HAS_UYVYTOARGBROW_AVX2
+#define HAS_UYVYTOUV422ROW_AVX2
+#define HAS_UYVYTOUVROW_AVX2
+#define HAS_UYVYTOYROW_AVX2
+#define HAS_YUY2TOARGBROW_AVX2
+#define HAS_YUY2TOUV422ROW_AVX2
+#define HAS_YUY2TOUVROW_AVX2
+#define HAS_YUY2TOYROW_AVX2
+
+// Effects:
+#define HAS_ARGBADDROW_AVX2
+#if !defined(LIBYUV_BIT_EXACT)
+#define HAS_ARGBATTENUATEROW_AVX2
+#endif
+#define HAS_ARGBMULTIPLYROW_AVX2
+#define HAS_ARGBSUBTRACTROW_AVX2
+#define HAS_ARGBUNATTENUATEROW_AVX2
+#define HAS_BLENDPLANEROW_AVX2
+
+#if defined(__x86_64__) || !defined(__pic__) || defined(__clang__) || \
+    defined(_MSC_VER)
+// TODO(fbarchard): fix build error on android_full_debug=1
+// https://code.google.com/p/libyuv/issues/detail?id=517
+#define HAS_I422ALPHATOARGBROW_AVX2
+#define HAS_I444ALPHATOARGBROW_AVX2
+#endif
+#endif
+
+// The following are available for AVX2 Visual C 32 bit:
+// TODO(fbarchard): Port to gcc.
+#if !defined(LIBYUV_DISABLE_X86) && defined(_M_IX86) && defined(_MSC_VER) && \
+    !defined(__clang__) && defined(VISUALC_HAS_AVX2)
+#define HAS_ARGB1555TOARGBROW_AVX2
+#define HAS_ARGB4444TOARGBROW_AVX2
+#define HAS_ARGBTOARGB1555ROW_AVX2
+#define HAS_ARGBTOARGB4444ROW_AVX2
+#define HAS_ARGBTORGB565ROW_AVX2
+#define HAS_J400TOARGBROW_AVX2
+#define HAS_RGB565TOARGBROW_AVX2
+#endif
+
+// The following are also available on x64 Visual C.
+#if !defined(LIBYUV_DISABLE_X86) && defined(_MSC_VER) && defined(_M_X64) && \
+    (!defined(__clang__) || defined(__SSSE3__))
+#define HAS_I444ALPHATOARGBROW_SSSE3
+#define HAS_I444TOARGBROW_SSSE3
+#define HAS_I422ALPHATOARGBROW_SSSE3
+#define HAS_I422TOARGBROW_SSSE3
+#endif
+
+// The following are available for gcc/clang x86 platforms:
+// TODO(fbarchard): Port to Visual C
+#if !defined(LIBYUV_DISABLE_X86) && (defined(__x86_64__) || defined(__i386__))
+#define HAS_ABGRTOAR30ROW_SSSE3
+#define HAS_ARGBTOAR30ROW_SSSE3
+#define HAS_ARGBTOAR64ROW_SSSE3
+#define HAS_ARGBTOAB64ROW_SSSE3
+#define HAS_AR64TOARGBROW_SSSE3
+#define HAS_AB64TOARGBROW_SSSE3
+#define HAS_CONVERT16TO8ROW_SSSE3
+#define HAS_CONVERT8TO16ROW_SSE2
+#define HAS_DETILEROW_SSE2
+#define HAS_DETILESPLITUVROW_SSSE3
+#define HAS_HALFMERGEUVROW_SSSE3
+#define HAS_I210TOAR30ROW_SSSE3
+#define HAS_I210TOARGBROW_SSSE3
+#define HAS_I212TOAR30ROW_SSSE3
+#define HAS_I212TOARGBROW_SSSE3
+#define HAS_I400TOARGBROW_SSE2
+#define HAS_I422TOAR30ROW_SSSE3
+#define HAS_I410TOAR30ROW_SSSE3
+#define HAS_I410TOARGBROW_SSSE3
+#define HAS_MERGEARGBROW_SSE2
+#define HAS_MERGEXRGBROW_SSE2
+#define HAS_MERGERGBROW_SSSE3
+#define HAS_MIRRORUVROW_SSSE3
+#define HAS_NV21TOYUV24ROW_SSSE3
+#define HAS_P210TOAR30ROW_SSSE3
+#define HAS_P210TOARGBROW_SSSE3
+#define HAS_P410TOAR30ROW_SSSE3
+#define HAS_P410TOARGBROW_SSSE3
+#define HAS_RAWTORGBAROW_SSSE3
+#define HAS_RGB24MIRRORROW_SSSE3
+#if !defined(LIBYUV_BIT_EXACT)
+#define HAS_RGBATOYJROW_SSSE3
+#endif
+#define HAS_SPLITARGBROW_SSE2
+#define HAS_SPLITARGBROW_SSSE3
+#define HAS_SPLITXRGBROW_SSE2
+#define HAS_SPLITXRGBROW_SSSE3
+#define HAS_SPLITRGBROW_SSSE3
+#define HAS_SWAPUVROW_SSSE3
+
+#if defined(__x86_64__) || !defined(__pic__)
+// TODO(fbarchard): fix build error on android_full_debug=1
+// https://code.google.com/p/libyuv/issues/detail?id=517
+#define HAS_I210ALPHATOARGBROW_SSSE3
+#define HAS_I410ALPHATOARGBROW_SSSE3
+#endif
+#endif
+
+// The following are available for AVX2 gcc/clang x86 platforms:
+// TODO(fbarchard): Port to Visual C
+#if !defined(LIBYUV_DISABLE_X86) &&               \
+    (defined(__x86_64__) || defined(__i386__)) && \
+    (defined(CLANG_HAS_AVX2) || defined(GCC_HAS_AVX2))
+#define HAS_ABGRTOAR30ROW_AVX2
+#if !defined(LIBYUV_BIT_EXACT)
+#define HAS_ABGRTOUVROW_AVX2
+#define HAS_ABGRTOYROW_AVX2
+#endif
+#define HAS_ARGBTOAR30ROW_AVX2
+#define HAS_ARGBTORAWROW_AVX2
+#define HAS_ARGBTORGB24ROW_AVX2
+#define HAS_ARGBTOAR64ROW_AVX2
+#define HAS_ARGBTOAB64ROW_AVX2
+#define HAS_AR64TOARGBROW_AVX2
+#define HAS_AB64TOARGBROW_AVX2
+#define HAS_CONVERT16TO8ROW_AVX2
+#define HAS_INTERPOLATEROW_16TO8_AVX2
+#define HAS_CONVERT8TO16ROW_AVX2
+#define HAS_DIVIDEROW_16_AVX2
+#define HAS_HALFMERGEUVROW_AVX2
+#define HAS_MERGEAR64ROW_AVX2
+#define HAS_MERGEARGB16TO8ROW_AVX2
+#define HAS_MERGEARGBROW_AVX2
+#define HAS_MERGEXR30ROW_AVX2
+#define HAS_MERGEXR64ROW_AVX2
+#define HAS_MERGEXRGB16TO8ROW_AVX2
+#define HAS_MERGEXRGBROW_AVX2
+#define HAS_NV21TOYUV24ROW_AVX2
+#define HAS_I210TOAR30ROW_AVX2
+#define HAS_I210TOARGBROW_AVX2
+#define HAS_I212TOAR30ROW_AVX2
+#define HAS_I212TOARGBROW_AVX2
+#define HAS_I400TOARGBROW_AVX2
+#define HAS_I410TOAR30ROW_AVX2
+#define HAS_I410TOARGBROW_AVX2
+#define HAS_P210TOAR30ROW_AVX2
+#define HAS_P210TOARGBROW_AVX2
+#define HAS_P410TOAR30ROW_AVX2
+#define HAS_P410TOARGBROW_AVX2
+#define HAS_I422TOAR30ROW_AVX2
+#define HAS_I422TOUYVYROW_AVX2
+#define HAS_I422TOYUY2ROW_AVX2
+#define HAS_MERGEUVROW_16_AVX2
+#define HAS_MIRRORUVROW_AVX2
+#define HAS_MULTIPLYROW_16_AVX2
+#if !defined(LIBYUV_BIT_EXACT)
+#define HAS_RGBATOYJROW_AVX2
+#endif
+#define HAS_SPLITARGBROW_AVX2
+#define HAS_SPLITXRGBROW_AVX2
+#define HAS_SPLITUVROW_16_AVX2
+#define HAS_SWAPUVROW_AVX2
+
+#if defined(__x86_64__) || !defined(__pic__)
+// TODO(fbarchard): fix build error on android_full_debug=1
+// https://code.google.com/p/libyuv/issues/detail?id=517
+#define HAS_I210ALPHATOARGBROW_AVX2
+#define HAS_I410ALPHATOARGBROW_AVX2
+#endif
+#endif
+
+// The following are available for AVX512 clang x86 platforms:
+// TODO(fbarchard): Port to GCC and Visual C
+// TODO(fbarchard): re-enable HAS_ARGBTORGB24ROW_AVX512VBMI. Issue libyuv:789
+#if !defined(LIBYUV_DISABLE_X86) && \
+    (defined(__x86_64__) || defined(__i386__)) && (defined(CLANG_HAS_AVX512))
+#define HAS_ARGBTORGB24ROW_AVX512VBMI
+#endif
+
+// The following are available for AVX512 clang x64 platforms:
+// TODO(fbarchard): Port to x86
+#if !defined(LIBYUV_DISABLE_X86) && defined(__x86_64__) && \
+    (defined(CLANG_HAS_AVX512))
+#define HAS_I422TOARGBROW_AVX512BW
+#endif
+
+// The following are available on Neon platforms:
+#if !defined(LIBYUV_DISABLE_NEON) && \
+    (defined(__aarch64__) || defined(__ARM_NEON__) || defined(LIBYUV_NEON))
+#define HAS_AB64TOARGBROW_NEON
+#define HAS_ABGRTOUVROW_NEON
+#define HAS_ABGRTOYROW_NEON
+#define HAS_AR64TOARGBROW_NEON
+#define HAS_ARGB1555TOARGBROW_NEON
+#define HAS_ARGB1555TOUVROW_NEON
+#define HAS_ARGB1555TOYROW_NEON
+#define HAS_ARGB4444TOARGBROW_NEON
+#define HAS_ARGB4444TOUVROW_NEON
+#define HAS_ARGB4444TOYROW_NEON
+#define HAS_ARGBEXTRACTALPHAROW_NEON
+#define HAS_ARGBSETROW_NEON
+#define HAS_ARGBTOAB64ROW_NEON
+#define HAS_ARGBTOAR64ROW_NEON
+#define HAS_ARGBTOARGB1555ROW_NEON
+#define HAS_ARGBTOARGB4444ROW_NEON
+#define HAS_ARGBTORAWROW_NEON
+#define HAS_ARGBTORGB24ROW_NEON
+#define HAS_ARGBTORGB565DITHERROW_NEON
+#define HAS_ARGBTORGB565ROW_NEON
+#define HAS_ARGBTOUV444ROW_NEON
+#define HAS_ARGBTOUVJROW_NEON
+#define HAS_ARGBTOUVROW_NEON
+#define HAS_ARGBTOYJROW_NEON
+#define HAS_ARGBTOYROW_NEON
+#define HAS_AYUVTOUVROW_NEON
+#define HAS_AYUVTOVUROW_NEON
+#define HAS_AYUVTOYROW_NEON
+#define HAS_BGRATOUVROW_NEON
+#define HAS_BGRATOYROW_NEON
+#define HAS_BYTETOFLOATROW_NEON
+#define HAS_CONVERT16TO8ROW_NEON
+#define HAS_COPYROW_NEON
+#define HAS_DETILEROW_NEON
+#define HAS_DETILESPLITUVROW_NEON
+#define HAS_DIVIDEROW_16_NEON
+#define HAS_HALFFLOATROW_NEON
+#define HAS_HALFMERGEUVROW_NEON
+#define HAS_I400TOARGBROW_NEON
+#define HAS_I422ALPHATOARGBROW_NEON
+#define HAS_I422TOARGB1555ROW_NEON
+#define HAS_I422TOARGB4444ROW_NEON
+#define HAS_I422TOARGBROW_NEON
+#define HAS_I422TORGB24ROW_NEON
+#define HAS_I422TORGB565ROW_NEON
+#define HAS_I422TORGBAROW_NEON
+#define HAS_I422TOUYVYROW_NEON
+#define HAS_I422TOYUY2ROW_NEON
+#define HAS_I444ALPHATOARGBROW_NEON
+#define HAS_I444TOARGBROW_NEON
+#define HAS_INTERPOLATEROW_16_NEON
+#define HAS_INTERPOLATEROW_NEON
+#define HAS_J400TOARGBROW_NEON
+#define HAS_MERGEAR64ROW_NEON
+#define HAS_MERGEARGB16TO8ROW_NEON
+#define HAS_MERGEARGBROW_NEON
+#define HAS_MERGEUVROW_16_NEON
+#define HAS_MERGEUVROW_NEON
+#define HAS_MERGEXR30ROW_NEON
+#define HAS_MERGEXR64ROW_NEON
+#define HAS_MERGEXRGB16TO8ROW_NEON
+#define HAS_MERGEXRGBROW_NEON
+#define HAS_MIRRORROW_NEON
+#define HAS_MIRRORSPLITUVROW_NEON
+#define HAS_MIRRORUVROW_NEON
+#define HAS_MULTIPLYROW_16_NEON
+#define HAS_NV12TOARGBROW_NEON
+#define HAS_NV12TORGB24ROW_NEON
+#define HAS_NV12TORGB565ROW_NEON
+#define HAS_NV21TOARGBROW_NEON
+#define HAS_NV21TORGB24ROW_NEON
+#define HAS_NV21TOYUV24ROW_NEON
+#define HAS_RAWTOARGBROW_NEON
+#define HAS_RAWTORGB24ROW_NEON
+#define HAS_RAWTORGBAROW_NEON
+#define HAS_RAWTOUVJROW_NEON
+#define HAS_RAWTOUVROW_NEON
+#define HAS_RAWTOYJROW_NEON
+#define HAS_RAWTOYROW_NEON
+#define HAS_RGB24TOARGBROW_NEON
+#define HAS_RGB24TOUVJROW_NEON
+#define HAS_RGB24TOUVROW_NEON
+#define HAS_RGB24TOYJROW_NEON
+#define HAS_RGB24TOYROW_NEON
+#define HAS_RGB565TOARGBROW_NEON
+#define HAS_RGB565TOUVROW_NEON
+#define HAS_RGB565TOYROW_NEON
+#define HAS_RGBATOUVROW_NEON
+#define HAS_RGBATOYJROW_NEON
+#define HAS_RGBATOYROW_NEON
+#define HAS_SETROW_NEON
+#define HAS_SPLITARGBROW_NEON
+#define HAS_SPLITRGBROW_NEON
+#define HAS_SPLITUVROW_16_NEON
+#define HAS_SPLITUVROW_NEON
+#define HAS_SPLITXRGBROW_NEON
+#define HAS_SWAPUVROW_NEON
+#define HAS_UYVYTOARGBROW_NEON
+#define HAS_UYVYTOUV422ROW_NEON
+#define HAS_UYVYTOUVROW_NEON
+#define HAS_UYVYTOYROW_NEON
+#define HAS_YUY2TOARGBROW_NEON
+#define HAS_YUY2TOUV422ROW_NEON
+#define HAS_YUY2TOUVROW_NEON
+#define HAS_YUY2TOYROW_NEON
+
+// Effects:
+#define HAS_ARGBADDROW_NEON
+#define HAS_ARGBATTENUATEROW_NEON
+#define HAS_ARGBBLENDROW_NEON
+#define HAS_ARGBCOLORMATRIXROW_NEON
+#define HAS_ARGBGRAYROW_NEON
+#define HAS_ARGBMIRRORROW_NEON
+#define HAS_RGB24MIRRORROW_NEON
+#define HAS_ARGBMULTIPLYROW_NEON
+#define HAS_ARGBQUANTIZEROW_NEON
+#define HAS_ARGBSEPIAROW_NEON
+#define HAS_ARGBSHADEROW_NEON
+#define HAS_ARGBSHUFFLEROW_NEON
+#define HAS_ARGBSUBTRACTROW_NEON
+#define HAS_SOBELROW_NEON
+#define HAS_SOBELTOPLANEROW_NEON
+#define HAS_SOBELXROW_NEON
+#define HAS_SOBELXYROW_NEON
+#define HAS_SOBELYROW_NEON
+#endif
+
+// The following are available on AArch64 platforms:
+#if !defined(LIBYUV_DISABLE_NEON) && defined(__aarch64__)
+#define HAS_INTERPOLATEROW_16TO8_NEON
+#define HAS_SCALESUMSAMPLES_NEON
+#define HAS_GAUSSROW_F32_NEON
+#define HAS_GAUSSCOL_F32_NEON
+#endif
+#if !defined(LIBYUV_DISABLE_MSA) && defined(__mips_msa)
+#define HAS_ABGRTOUVROW_MSA
+#define HAS_ABGRTOYROW_MSA
+#define HAS_ARGB1555TOARGBROW_MSA
+#define HAS_ARGB1555TOUVROW_MSA
+#define HAS_ARGB1555TOYROW_MSA
+#define HAS_ARGB4444TOARGBROW_MSA
+#define HAS_ARGBADDROW_MSA
+#define HAS_ARGBATTENUATEROW_MSA
+#define HAS_ARGBBLENDROW_MSA
+#define HAS_ARGBCOLORMATRIXROW_MSA
+#define HAS_ARGBEXTRACTALPHAROW_MSA
+#define HAS_ARGBGRAYROW_MSA
+#define HAS_ARGBMIRRORROW_MSA
+#define HAS_ARGBMULTIPLYROW_MSA
+#define HAS_ARGBQUANTIZEROW_MSA
+#define HAS_ARGBSEPIAROW_MSA
+#define HAS_ARGBSETROW_MSA
+#define HAS_ARGBSHADEROW_MSA
+#define HAS_ARGBSHUFFLEROW_MSA
+#define HAS_ARGBSUBTRACTROW_MSA
+#define HAS_ARGBTOARGB1555ROW_MSA
+#define HAS_ARGBTOARGB4444ROW_MSA
+#define HAS_ARGBTORAWROW_MSA
+#define HAS_ARGBTORGB24ROW_MSA
+#define HAS_ARGBTORGB565DITHERROW_MSA
+#define HAS_ARGBTORGB565ROW_MSA
+#define HAS_ARGBTOUV444ROW_MSA
+#define HAS_ARGBTOUVJROW_MSA
+#define HAS_ARGBTOUVROW_MSA
+#define HAS_ARGBTOYJROW_MSA
+#define HAS_ARGBTOYROW_MSA
+#define HAS_BGRATOUVROW_MSA
+#define HAS_BGRATOYROW_MSA
+#define HAS_HALFFLOATROW_MSA
+#define HAS_I400TOARGBROW_MSA
+#define HAS_I422TOUYVYROW_MSA
+#define HAS_I422TOYUY2ROW_MSA
+#define HAS_I422TOARGBROW_MSA
+#define HAS_I422TORGBAROW_MSA
+#define HAS_I422ALPHATOARGBROW_MSA
+#define HAS_I422TORGB24ROW_MSA
+#define HAS_I422TORGB565ROW_MSA
+#define HAS_I422TOARGB4444ROW_MSA
+#define HAS_I422TOARGB1555ROW_MSA
+#define HAS_NV12TOARGBROW_MSA
+#define HAS_NV12TORGB565ROW_MSA
+#define HAS_NV21TOARGBROW_MSA
+#define HAS_YUY2TOARGBROW_MSA
+#define HAS_UYVYTOARGBROW_MSA
+#define HAS_I444TOARGBROW_MSA
+#define HAS_INTERPOLATEROW_MSA
+#define HAS_J400TOARGBROW_MSA
+#define HAS_MERGEUVROW_MSA
+#define HAS_MIRRORROW_MSA
+#define HAS_MIRRORUVROW_MSA
+#define HAS_MIRRORSPLITUVROW_MSA
+#define HAS_RAWTOARGBROW_MSA
+#define HAS_RAWTORGB24ROW_MSA
+#define HAS_RAWTOUVROW_MSA
+#define HAS_RAWTOYROW_MSA
+#define HAS_RGB24TOARGBROW_MSA
+#define HAS_RGB24TOUVROW_MSA
+#define HAS_RGB24TOYROW_MSA
+#define HAS_RGB565TOARGBROW_MSA
+#define HAS_RGB565TOUVROW_MSA
+#define HAS_RGB565TOYROW_MSA
+#define HAS_RGBATOUVROW_MSA
+#define HAS_RGBATOYROW_MSA
+#define HAS_SETROW_MSA
+#define HAS_SOBELROW_MSA
+#define HAS_SOBELTOPLANEROW_MSA
+#define HAS_SOBELXROW_MSA
+#define HAS_SOBELXYROW_MSA
+#define HAS_SOBELYROW_MSA
+#define HAS_SPLITUVROW_MSA
+#define HAS_UYVYTOUVROW_MSA
+#define HAS_UYVYTOYROW_MSA
+#define HAS_YUY2TOUV422ROW_MSA
+#define HAS_YUY2TOUVROW_MSA
+#define HAS_YUY2TOYROW_MSA
+#endif
+
+#if !defined(LIBYUV_DISABLE_LSX) && defined(__loongarch_sx)
+#define HAS_ARGB4444TOARGBROW_LSX
+#define HAS_ARGB1555TOARGBROW_LSX
+#define HAS_RGB565TOARGBROW_LSX
+#define HAS_RGB24TOARGBROW_LSX
+#define HAS_RAWTOARGBROW_LSX
+#define HAS_ARGB1555TOYROW_LSX
+#define HAS_ARGB1555TOUVROW_LSX
+#define HAS_RGB565TOYROW_LSX
+#define HAS_RGB565TOUVROW_LSX
+#define HAS_RGB24TOYROW_LSX
+#define HAS_RGB24TOUVROW_LSX
+#define HAS_RAWTOYROW_LSX
+#define HAS_RAWTOUVROW_LSX
+#define HAS_NV12TOARGBROW_LSX
+#define HAS_NV12TORGB565ROW_LSX
+#define HAS_NV21TOARGBROW_LSX
+#define HAS_SOBELROW_LSX
+#define HAS_SOBELTOPLANEROW_LSX
+#define HAS_SOBELXYROW_LSX
+#define HAS_ARGBTOYJROW_LSX
+#define HAS_BGRATOYROW_LSX
+#define HAS_BGRATOUVROW_LSX
+#define HAS_ABGRTOYROW_LSX
+#define HAS_ABGRTOUVROW_LSX
+#define HAS_RGBATOYROW_LSX
+#define HAS_RGBATOUVROW_LSX
+#define HAS_ARGBTOUVJROW_LSX
+#define HAS_I444TOARGBROW_LSX
+#define HAS_I400TOARGBROW_LSX
+#define HAS_J400TOARGBROW_LSX
+#define HAS_YUY2TOARGBROW_LSX
+#define HAS_UYVYTOARGBROW_LSX
+#define HAS_INTERPOLATEROW_LSX
+#define HAS_ARGBSETROW_LSX
+#define HAS_RAWTORGB24ROW_LSX
+#define HAS_MERGEUVROW_LSX
+#define HAS_ARGBEXTRACTALPHAROW_LSX
+#define HAS_ARGBBLENDROW_LSX
+#define HAS_ARGBQUANTIZEROW_LSX
+#define HAS_ARGBCOLORMATRIXROW_LSX
+#define HAS_SPLITUVROW_LSX
+#define HAS_SETROW_LSX
+#define HAS_MIRRORSPLITUVROW_LSX
+#endif
+
+#if !defined(LIBYUV_DISABLE_LASX) && defined(__loongarch_asx)
+#define HAS_I422TOARGBROW_LASX
+#define HAS_I422TORGBAROW_LASX
+#define HAS_I422ALPHATOARGBROW_LASX
+#define HAS_I422TOYUY2ROW_LASX
+#define HAS_I422TOUYVYROW_LASX
+#define HAS_MIRRORROW_LASX
+#define HAS_MIRRORUVROW_LASX
+#define HAS_ARGBMIRRORROW_LASX
+#define HAS_I422TORGB24ROW_LASX
+#define HAS_I422TORGB565ROW_LASX
+#define HAS_I422TOARGB4444ROW_LASX
+#define HAS_I422TOARGB1555ROW_LASX
+#define HAS_YUY2TOUVROW_LASX
+#define HAS_YUY2TOYROW_LASX
+#define HAS_YUY2TOUV422ROW_LASX
+#define HAS_UYVYTOYROW_LASX
+#define HAS_UYVYTOUVROW_LASX
+#define HAS_UYVYTOUV422ROW_LASX
+#define HAS_ARGBTOYROW_LASX
+#define HAS_ARGBTOUVROW_LASX
+#define HAS_ARGBTORGB24ROW_LASX
+#define HAS_ARGBTORAWROW_LASX
+#define HAS_ARGBTORGB565ROW_LASX
+#define HAS_ARGBTOARGB1555ROW_LASX
+#define HAS_ARGBTOARGB4444ROW_LASX
+#define HAS_ARGBTOUV444ROW_LASX
+#define HAS_ARGBMULTIPLYROW_LASX
+#define HAS_ARGBADDROW_LASX
+#define HAS_ARGBSUBTRACTROW_LASX
+#define HAS_ARGBATTENUATEROW_LASX
+#define HAS_ARGBTORGB565DITHERROW_LASX
+#define HAS_ARGBSHUFFLEROW_LASX
+#define HAS_ARGBSHADEROW_LASX
+#define HAS_ARGBGRAYROW_LASX
+#define HAS_ARGBSEPIAROW_LASX
+#define HAS_ARGB4444TOARGBROW_LASX
+#define HAS_ARGB1555TOARGBROW_LASX
+#define HAS_RGB565TOARGBROW_LASX
+#define HAS_RGB24TOARGBROW_LASX
+#define HAS_RAWTOARGBROW_LASX
+#define HAS_ARGB1555TOYROW_LASX
+#define HAS_ARGB1555TOUVROW_LASX
+#define HAS_RGB565TOYROW_LASX
+#define HAS_RGB565TOUVROW_LASX
+#define HAS_RGB24TOYROW_LASX
+#define HAS_RGB24TOUVROW_LASX
+#define HAS_RAWTOYROW_LASX
+#define HAS_RAWTOUVROW_LASX
+#define HAS_NV12TOARGBROW_LASX
+#define HAS_NV12TORGB565ROW_LASX
+#define HAS_NV21TOARGBROW_LASX
+#define HAS_ARGBTOYJROW_LASX
+#define HAS_ARGBTOUVJROW_LASX
+#endif
+
+#if defined(_MSC_VER) && !defined(__CLR_VER) && !defined(__clang__)
+#if defined(VISUALC_HAS_AVX2)
+#define SIMD_ALIGNED(var) __declspec(align(32)) var
+#else
+#define SIMD_ALIGNED(var) __declspec(align(16)) var
+#endif
+#define LIBYUV_NOINLINE __declspec(noinline)
+typedef __declspec(align(16)) int16_t vec16[8];
+typedef __declspec(align(16)) int32_t vec32[4];
+typedef __declspec(align(16)) float vecf32[4];
+typedef __declspec(align(16)) int8_t vec8[16];
+typedef __declspec(align(16)) uint16_t uvec16[8];
+typedef __declspec(align(16)) uint32_t uvec32[4];
+typedef __declspec(align(16)) uint8_t uvec8[16];
+typedef __declspec(align(32)) int16_t lvec16[16];
+typedef __declspec(align(32)) int32_t lvec32[8];
+typedef __declspec(align(32)) int8_t lvec8[32];
+typedef __declspec(align(32)) uint16_t ulvec16[16];
+typedef __declspec(align(32)) uint32_t ulvec32[8];
+typedef __declspec(align(32)) uint8_t ulvec8[32];
+#elif !defined(__pnacl__) && (defined(__GNUC__) || defined(__clang__))
+// Caveat GCC 4.2 to 4.7 have a known issue using vectors with const.
+#if defined(CLANG_HAS_AVX2) || defined(GCC_HAS_AVX2)
+#define SIMD_ALIGNED(var) var __attribute__((aligned(32)))
+#else
+#define SIMD_ALIGNED(var) var __attribute__((aligned(16)))
+#endif
+#define LIBYUV_NOINLINE __attribute__((noinline))
+typedef int16_t __attribute__((vector_size(16))) vec16;
+typedef int32_t __attribute__((vector_size(16))) vec32;
+typedef float __attribute__((vector_size(16))) vecf32;
+typedef int8_t __attribute__((vector_size(16))) vec8;
+typedef uint16_t __attribute__((vector_size(16))) uvec16;
+typedef uint32_t __attribute__((vector_size(16))) uvec32;
+typedef uint8_t __attribute__((vector_size(16))) uvec8;
+typedef int16_t __attribute__((vector_size(32))) lvec16;
+typedef int32_t __attribute__((vector_size(32))) lvec32;
+typedef int8_t __attribute__((vector_size(32))) lvec8;
+typedef uint16_t __attribute__((vector_size(32))) ulvec16;
+typedef uint32_t __attribute__((vector_size(32))) ulvec32;
+typedef uint8_t __attribute__((vector_size(32))) ulvec8;
+#else
+#define SIMD_ALIGNED(var) var
+#define LIBYUV_NOINLINE
+typedef int16_t vec16[8];
+typedef int32_t vec32[4];
+typedef float vecf32[4];
+typedef int8_t vec8[16];
+typedef uint16_t uvec16[8];
+typedef uint32_t uvec32[4];
+typedef uint8_t uvec8[16];
+typedef int16_t lvec16[16];
+typedef int32_t lvec32[8];
+typedef int8_t lvec8[32];
+typedef uint16_t ulvec16[16];
+typedef uint32_t ulvec32[8];
+typedef uint8_t ulvec8[32];
+#endif
+
+#if defined(__aarch64__) || defined(__arm__)
+// This struct is for ARM color conversion.
+struct YuvConstants {
+  uvec8 kUVCoeff;
+  vec16 kRGBCoeffBias;
+};
+#else
+// This struct is for Intel color conversion.
+struct YuvConstants {
+  uint8_t kUVToB[32];
+  uint8_t kUVToG[32];
+  uint8_t kUVToR[32];
+  int16_t kYToRgb[16];
+  int16_t kYBiasToRgb[16];
+};
+
+// Offsets into YuvConstants structure
+#define KUVTOB 0
+#define KUVTOG 32
+#define KUVTOR 64
+#define KYTORGB 96
+#define KYBIASTORGB 128
+
+#endif
+
+#define IS_ALIGNED(p, a) (!((uintptr_t)(p) & ((a)-1)))
+
+#define align_buffer_64(var, size)                                           \
+  uint8_t* var##_mem = (uint8_t*)(malloc((size) + 63));         /* NOLINT */ \
+  uint8_t* var = (uint8_t*)(((intptr_t)(var##_mem) + 63) & ~63) /* NOLINT */
+
+#define free_aligned_buffer_64(var) \
+  free(var##_mem);                  \
+  var = 0
+
+#if defined(__APPLE__) || defined(__x86_64__) || defined(__llvm__)
+#define OMITFP
+#else
+#define OMITFP __attribute__((optimize("omit-frame-pointer")))
+#endif
+
+// NaCL macros for GCC x86 and x64.
+#if defined(__native_client__)
+#define LABELALIGN ".p2align 5\n"
+#else
+#define LABELALIGN
+#endif
+
+// Intel Code Analizer markers.  Insert IACA_START IACA_END around code to be
+// measured and then run with iaca -64 libyuv_unittest.
+// IACA_ASM_START amd IACA_ASM_END are equivalents that can be used within
+// inline assembly blocks.
+// example of iaca:
+// ~/iaca-lin64/bin/iaca.sh -64 -analysis LATENCY out/Release/libyuv_unittest
+
+#if defined(__x86_64__) || defined(__i386__)
+
+#define IACA_ASM_START  \
+  ".byte 0x0F, 0x0B\n"  \
+  " movl $111, %%ebx\n" \
+  ".byte 0x64, 0x67, 0x90\n"
+
+#define IACA_ASM_END         \
+  " movl $222, %%ebx\n"      \
+  ".byte 0x64, 0x67, 0x90\n" \
+  ".byte 0x0F, 0x0B\n"
+
+#define IACA_SSC_MARK(MARK_ID)                        \
+  __asm__ __volatile__("\n\t  movl $" #MARK_ID        \
+                       ", %%ebx"                      \
+                       "\n\t  .byte 0x64, 0x67, 0x90" \
+                       :                              \
+                       :                              \
+                       : "memory");
+
+#define IACA_UD_BYTES __asm__ __volatile__("\n\t .byte 0x0F, 0x0B");
+
+#else /* Visual C */
+#define IACA_UD_BYTES \
+  { __asm _emit 0x0F __asm _emit 0x0B }
+
+#define IACA_SSC_MARK(x) \
+  { __asm mov ebx, x __asm _emit 0x64 __asm _emit 0x67 __asm _emit 0x90 }
+
+#define IACA_VC64_START __writegsbyte(111, 111);
+#define IACA_VC64_END __writegsbyte(222, 222);
+#endif
+
+#define IACA_START     \
+  {                    \
+    IACA_UD_BYTES      \
+    IACA_SSC_MARK(111) \
+  }
+#define IACA_END       \
+  {                    \
+    IACA_SSC_MARK(222) \
+    IACA_UD_BYTES      \
+  }
+
+void I444ToARGBRow_NEON(const uint8_t* src_y,
+                        const uint8_t* src_u,
+                        const uint8_t* src_v,
+                        uint8_t* dst_argb,
+                        const struct YuvConstants* yuvconstants,
+                        int width);
+void I422ToARGBRow_NEON(const uint8_t* src_y,
+                        const uint8_t* src_u,
+                        const uint8_t* src_v,
+                        uint8_t* dst_argb,
+                        const struct YuvConstants* yuvconstants,
+                        int width);
+void I444AlphaToARGBRow_NEON(const uint8_t* src_y,
+                             const uint8_t* src_u,
+                             const uint8_t* src_v,
+                             const uint8_t* src_a,
+                             uint8_t* dst_argb,
+                             const struct YuvConstants* yuvconstants,
+                             int width);
+void I422AlphaToARGBRow_NEON(const uint8_t* src_y,
+                             const uint8_t* src_u,
+                             const uint8_t* src_v,
+                             const uint8_t* src_a,
+                             uint8_t* dst_argb,
+                             const struct YuvConstants* yuvconstants,
+                             int width);
+void I422ToRGBARow_NEON(const uint8_t* src_y,
+                        const uint8_t* src_u,
+                        const uint8_t* src_v,
+                        uint8_t* dst_rgba,
+                        const struct YuvConstants* yuvconstants,
+                        int width);
+void I422ToRGB24Row_NEON(const uint8_t* src_y,
+                         const uint8_t* src_u,
+                         const uint8_t* src_v,
+                         uint8_t* dst_rgb24,
+                         const struct YuvConstants* yuvconstants,
+                         int width);
+void I422ToRGB565Row_NEON(const uint8_t* src_y,
+                          const uint8_t* src_u,
+                          const uint8_t* src_v,
+                          uint8_t* dst_rgb565,
+                          const struct YuvConstants* yuvconstants,
+                          int width);
+void I422ToARGB1555Row_NEON(const uint8_t* src_y,
+                            const uint8_t* src_u,
+                            const uint8_t* src_v,
+                            uint8_t* dst_argb1555,
+                            const struct YuvConstants* yuvconstants,
+                            int width);
+void I422ToARGB4444Row_NEON(const uint8_t* src_y,
+                            const uint8_t* src_u,
+                            const uint8_t* src_v,
+                            uint8_t* dst_argb4444,
+                            const struct YuvConstants* yuvconstants,
+                            int width);
+void NV12ToARGBRow_NEON(const uint8_t* src_y,
+                        const uint8_t* src_uv,
+                        uint8_t* dst_argb,
+                        const struct YuvConstants* yuvconstants,
+                        int width);
+void NV12ToRGB565Row_NEON(const uint8_t* src_y,
+                          const uint8_t* src_uv,
+                          uint8_t* dst_rgb565,
+                          const struct YuvConstants* yuvconstants,
+                          int width);
+void NV21ToARGBRow_NEON(const uint8_t* src_y,
+                        const uint8_t* src_vu,
+                        uint8_t* dst_argb,
+                        const struct YuvConstants* yuvconstants,
+                        int width);
+void NV12ToRGB24Row_NEON(const uint8_t* src_y,
+                         const uint8_t* src_uv,
+                         uint8_t* dst_rgb24,
+                         const struct YuvConstants* yuvconstants,
+                         int width);
+void NV21ToRGB24Row_NEON(const uint8_t* src_y,
+                         const uint8_t* src_vu,
+                         uint8_t* dst_rgb24,
+                         const struct YuvConstants* yuvconstants,
+                         int width);
+void NV21ToYUV24Row_NEON(const uint8_t* src_y,
+                         const uint8_t* src_vu,
+                         uint8_t* dst_yuv24,
+                         int width);
+void YUY2ToARGBRow_NEON(const uint8_t* src_yuy2,
+                        uint8_t* dst_argb,
+                        const struct YuvConstants* yuvconstants,
+                        int width);
+void UYVYToARGBRow_NEON(const uint8_t* src_uyvy,
+                        uint8_t* dst_argb,
+                        const struct YuvConstants* yuvconstants,
+                        int width);
+void I444ToARGBRow_MSA(const uint8_t* src_y,
+                       const uint8_t* src_u,
+                       const uint8_t* src_v,
+                       uint8_t* dst_argb,
+                       const struct YuvConstants* yuvconstants,
+                       int width);
+void I444ToARGBRow_LSX(const uint8_t* src_y,
+                       const uint8_t* src_u,
+                       const uint8_t* src_v,
+                       uint8_t* dst_argb,
+                       const struct YuvConstants* yuvconstants,
+                       int width);
+
+void I422ToARGBRow_MSA(const uint8_t* src_y,
+                       const uint8_t* src_u,
+                       const uint8_t* src_v,
+                       uint8_t* dst_argb,
+                       const struct YuvConstants* yuvconstants,
+                       int width);
+void I422ToARGBRow_LASX(const uint8_t* src_y,
+                        const uint8_t* src_u,
+                        const uint8_t* src_v,
+                        uint8_t* dst_argb,
+                        const struct YuvConstants* yuvconstants,
+                        int width);
+void I422ToRGBARow_MSA(const uint8_t* src_y,
+                       const uint8_t* src_u,
+                       const uint8_t* src_v,
+                       uint8_t* dst_argb,
+                       const struct YuvConstants* yuvconstants,
+                       int width);
+void I422ToRGBARow_LASX(const uint8_t* src_y,
+                        const uint8_t* src_u,
+                        const uint8_t* src_v,
+                        uint8_t* dst_argb,
+                        const struct YuvConstants* yuvconstants,
+                        int width);
+void I422AlphaToARGBRow_MSA(const uint8_t* src_y,
+                            const uint8_t* src_u,
+                            const uint8_t* src_v,
+                            const uint8_t* src_a,
+                            uint8_t* dst_argb,
+                            const struct YuvConstants* yuvconstants,
+                            int width);
+void I422AlphaToARGBRow_LASX(const uint8_t* src_y,
+                             const uint8_t* src_u,
+                             const uint8_t* src_v,
+                             const uint8_t* src_a,
+                             uint8_t* dst_argb,
+                             const struct YuvConstants* yuvconstants,
+                             int width);
+void I422ToRGB24Row_MSA(const uint8_t* src_y,
+                        const uint8_t* src_u,
+                        const uint8_t* src_v,
+                        uint8_t* dst_argb,
+                        const struct YuvConstants* yuvconstants,
+                        int width);
+void I422ToRGB24Row_LASX(const uint8_t* src_y,
+                         const uint8_t* src_u,
+                         const uint8_t* src_v,
+                         uint8_t* dst_argb,
+                         const struct YuvConstants* yuvconstants,
+                         int width);
+void I422ToRGB565Row_MSA(const uint8_t* src_y,
+                         const uint8_t* src_u,
+                         const uint8_t* src_v,
+                         uint8_t* dst_rgb565,
+                         const struct YuvConstants* yuvconstants,
+                         int width);
+void I422ToRGB565Row_LASX(const uint8_t* src_y,
+                          const uint8_t* src_u,
+                          const uint8_t* src_v,
+                          uint8_t* dst_rgb565,
+                          const struct YuvConstants* yuvconstants,
+                          int width);
+void I422ToARGB4444Row_MSA(const uint8_t* src_y,
+                           const uint8_t* src_u,
+                           const uint8_t* src_v,
+                           uint8_t* dst_argb4444,
+                           const struct YuvConstants* yuvconstants,
+                           int width);
+void I422ToARGB4444Row_LASX(const uint8_t* src_y,
+                            const uint8_t* src_u,
+                            const uint8_t* src_v,
+                            uint8_t* dst_argb4444,
+                            const struct YuvConstants* yuvconstants,
+                            int width);
+void I422ToARGB1555Row_MSA(const uint8_t* src_y,
+                           const uint8_t* src_u,
+                           const uint8_t* src_v,
+                           uint8_t* dst_argb1555,
+                           const struct YuvConstants* yuvconstants,
+                           int width);
+void I422ToARGB1555Row_LASX(const uint8_t* src_y,
+                            const uint8_t* src_u,
+                            const uint8_t* src_v,
+                            uint8_t* dst_argb1555,
+                            const struct YuvConstants* yuvconstants,
+                            int width);
+void NV12ToARGBRow_MSA(const uint8_t* src_y,
+                       const uint8_t* src_uv,
+                       uint8_t* dst_argb,
+                       const struct YuvConstants* yuvconstants,
+                       int width);
+void NV12ToRGB565Row_MSA(const uint8_t* src_y,
+                         const uint8_t* src_uv,
+                         uint8_t* dst_rgb565,
+                         const struct YuvConstants* yuvconstants,
+                         int width);
+void NV21ToARGBRow_MSA(const uint8_t* src_y,
+                       const uint8_t* src_vu,
+                       uint8_t* dst_argb,
+                       const struct YuvConstants* yuvconstants,
+                       int width);
+void YUY2ToARGBRow_MSA(const uint8_t* src_yuy2,
+                       uint8_t* dst_argb,
+                       const struct YuvConstants* yuvconstants,
+                       int width);
+void UYVYToARGBRow_MSA(const uint8_t* src_uyvy,
+                       uint8_t* dst_argb,
+                       const struct YuvConstants* yuvconstants,
+                       int width);
+
+void NV12ToARGBRow_LSX(const uint8_t* src_y,
+                       const uint8_t* src_uv,
+                       uint8_t* dst_argb,
+                       const struct YuvConstants* yuvconstants,
+                       int width);
+void NV12ToARGBRow_LASX(const uint8_t* src_y,
+                        const uint8_t* src_uv,
+                        uint8_t* dst_argb,
+                        const struct YuvConstants* yuvconstants,
+                        int width);
+void NV12ToRGB565Row_LSX(const uint8_t* src_y,
+                         const uint8_t* src_uv,
+                         uint8_t* dst_rgb565,
+                         const struct YuvConstants* yuvconstants,
+                         int width);
+void NV12ToRGB565Row_LASX(const uint8_t* src_y,
+                          const uint8_t* src_uv,
+                          uint8_t* dst_rgb565,
+                          const struct YuvConstants* yuvconstants,
+                          int width);
+void NV21ToARGBRow_LSX(const uint8_t* src_y,
+                       const uint8_t* src_vu,
+                       uint8_t* dst_argb,
+                       const struct YuvConstants* yuvconstants,
+                       int width);
+void NV21ToARGBRow_LASX(const uint8_t* src_y,
+                        const uint8_t* src_vu,
+                        uint8_t* dst_argb,
+                        const struct YuvConstants* yuvconstants,
+                        int width);
+void YUY2ToARGBRow_LSX(const uint8_t* src_yuy2,
+                       uint8_t* dst_argb,
+                       const struct YuvConstants* yuvconstants,
+                       int width);
+void UYVYToARGBRow_LSX(const uint8_t* src_uyvy,
+                       uint8_t* dst_argb,
+                       const struct YuvConstants* yuvconstants,
+                       int width);
+
+void ARGBToYRow_AVX2(const uint8_t* src_argb, uint8_t* dst_y, int width);
+void ARGBToYRow_Any_AVX2(const uint8_t* src_ptr, uint8_t* dst_ptr, int width);
+void ABGRToYRow_AVX2(const uint8_t* src_abgr, uint8_t* dst_y, int width);
+void ABGRToYRow_Any_AVX2(const uint8_t* src_ptr, uint8_t* dst_ptr, int width);
+void ARGBToYRow_SSSE3(const uint8_t* src_argb, uint8_t* dst_y, int width);
+void ARGBToYJRow_AVX2(const uint8_t* src_argb, uint8_t* dst_y, int width);
+void ARGBToYJRow_Any_AVX2(const uint8_t* src_ptr, uint8_t* dst_ptr, int width);
+void ARGBToYJRow_SSSE3(const uint8_t* src_argb, uint8_t* dst_y, int width);
+void RGBAToYJRow_AVX2(const uint8_t* src_rgba, uint8_t* dst_y, int width);
+void RGBAToYJRow_Any_AVX2(const uint8_t* src_ptr, uint8_t* dst_ptr, int width);
+void RGBAToYJRow_SSSE3(const uint8_t* src_rgba, uint8_t* dst_y, int width);
+void BGRAToYRow_SSSE3(const uint8_t* src_bgra, uint8_t* dst_y, int width);
+void ABGRToYRow_SSSE3(const uint8_t* src_abgr, uint8_t* dst_y, int width);
+void RGBAToYRow_SSSE3(const uint8_t* src_rgba, uint8_t* dst_y, int width);
+void RGB24ToYRow_SSSE3(const uint8_t* src_rgb24, uint8_t* dst_y, int width);
+void RGB24ToYJRow_SSSE3(const uint8_t* src_rgb24, uint8_t* dst_yj, int width);
+void RAWToYRow_SSSE3(const uint8_t* src_raw, uint8_t* dst_y, int width);
+void RAWToYJRow_SSSE3(const uint8_t* src_raw, uint8_t* dst_yj, int width);
+void RGB24ToYJRow_AVX2(const uint8_t* src_rgb24, uint8_t* dst_yj, int width);
+void RAWToYJRow_AVX2(const uint8_t* src_raw, uint8_t* dst_yj, int width);
+void ARGBToYRow_NEON(const uint8_t* src_argb, uint8_t* dst_y, int width);
+void ARGBToYJRow_NEON(const uint8_t* src_argb, uint8_t* dst_y, int width);
+void RGBAToYJRow_NEON(const uint8_t* src_rgba, uint8_t* dst_y, int width);
+void ARGBToYRow_MSA(const uint8_t* src_argb0, uint8_t* dst_y, int width);
+void ARGBToYJRow_MSA(const uint8_t* src_argb0, uint8_t* dst_y, int width);
+void ARGBToYRow_LASX(const uint8_t* src_argb0, uint8_t* dst_y, int width);
+void ARGBToYJRow_LSX(const uint8_t* src_argb0, uint8_t* dst_y, int width);
+void ARGBToYJRow_LASX(const uint8_t* src_argb0, uint8_t* dst_y, int width);
+void ARGBToUV444Row_NEON(const uint8_t* src_argb,
+                         uint8_t* dst_u,
+                         uint8_t* dst_v,
+                         int width);
+void ARGBToUVRow_NEON(const uint8_t* src_argb,
+                      int src_stride_argb,
+                      uint8_t* dst_u,
+                      uint8_t* dst_v,
+                      int width);
+void ARGBToUV444Row_MSA(const uint8_t* src_argb,
+                        uint8_t* dst_u,
+                        uint8_t* dst_v,
+                        int width);
+void ARGBToUVRow_MSA(const uint8_t* src_argb,
+                     int src_stride_argb,
+                     uint8_t* dst_u,
+                     uint8_t* dst_v,
+                     int width);
+void ARGBToUVRow_LASX(const uint8_t* src_argb,
+                      int src_stride_argb,
+                      uint8_t* dst_u,
+                      uint8_t* dst_v,
+                      int width);
+void ARGBToUV444Row_LASX(const uint8_t* src_argb,
+                         uint8_t* dst_u,
+                         uint8_t* dst_v,
+                         int width);
+void ARGBToUVJRow_NEON(const uint8_t* src_argb,
+                       int src_stride_argb,
+                       uint8_t* dst_u,
+                       uint8_t* dst_v,
+                       int width);
+void BGRAToUVRow_NEON(const uint8_t* src_bgra,
+                      int src_stride_bgra,
+                      uint8_t* dst_u,
+                      uint8_t* dst_v,
+                      int width);
+void ABGRToUVRow_NEON(const uint8_t* src_abgr,
+                      int src_stride_abgr,
+                      uint8_t* dst_u,
+                      uint8_t* dst_v,
+                      int width);
+void RGBAToUVRow_NEON(const uint8_t* src_rgba,
+                      int src_stride_rgba,
+                      uint8_t* dst_u,
+                      uint8_t* dst_v,
+                      int width);
+void RGB24ToUVRow_NEON(const uint8_t* src_rgb24,
+                       int src_stride_rgb24,
+                       uint8_t* dst_u,
+                       uint8_t* dst_v,
+                       int width);
+void RAWToUVRow_NEON(const uint8_t* src_raw,
+                     int src_stride_raw,
+                     uint8_t* dst_u,
+                     uint8_t* dst_v,
+                     int width);
+void RGB24ToUVJRow_NEON(const uint8_t* src_rgb24,
+                        int src_stride_rgb24,
+                        uint8_t* dst_u,
+                        uint8_t* dst_v,
+                        int width);
+void RAWToUVJRow_NEON(const uint8_t* src_raw,
+                      int src_stride_raw,
+                      uint8_t* dst_u,
+                      uint8_t* dst_v,
+                      int width);
+void RGB565ToUVRow_NEON(const uint8_t* src_rgb565,
+                        int src_stride_rgb565,
+                        uint8_t* dst_u,
+                        uint8_t* dst_v,
+                        int width);
+void ARGB1555ToUVRow_NEON(const uint8_t* src_argb1555,
+                          int src_stride_argb1555,
+                          uint8_t* dst_u,
+                          uint8_t* dst_v,
+                          int width);
+void ARGB4444ToUVRow_NEON(const uint8_t* src_argb4444,
+                          int src_stride_argb4444,
+                          uint8_t* dst_u,
+                          uint8_t* dst_v,
+                          int width);
+void ARGBToUVJRow_MSA(const uint8_t* src_rgb,
+                      int src_stride_rgb,
+                      uint8_t* dst_u,
+                      uint8_t* dst_v,
+                      int width);
+void BGRAToUVRow_MSA(const uint8_t* src_rgb,
+                     int src_stride_rgb,
+                     uint8_t* dst_u,
+                     uint8_t* dst_v,
+                     int width);
+void ABGRToUVRow_MSA(const uint8_t* src_rgb,
+                     int src_stride_rgb,
+                     uint8_t* dst_u,
+                     uint8_t* dst_v,
+                     int width);
+void RGBAToUVRow_MSA(const uint8_t* src_rgb,
+                     int src_stride_rgb,
+                     uint8_t* dst_u,
+                     uint8_t* dst_v,
+                     int width);
+void RGB24ToUVRow_MSA(const uint8_t* src_rgb,
+                      int src_stride_rgb,
+                      uint8_t* dst_u,
+                      uint8_t* dst_v,
+                      int width);
+void RAWToUVRow_MSA(const uint8_t* src_rgb,
+                    int src_stride_rgb,
+                    uint8_t* dst_u,
+                    uint8_t* dst_v,
+                    int width);
+void RGB565ToUVRow_MSA(const uint8_t* src_rgb565,
+                       int src_stride_rgb565,
+                       uint8_t* dst_u,
+                       uint8_t* dst_v,
+                       int width);
+void ARGB1555ToUVRow_MSA(const uint8_t* src_argb1555,
+                         int src_stride_argb1555,
+                         uint8_t* dst_u,
+                         uint8_t* dst_v,
+                         int width);
+void BGRAToUVRow_LSX(const uint8_t* src_bgra,
+                     int src_stride_bgra,
+                     uint8_t* dst_u,
+                     uint8_t* dst_v,
+                     int width);
+void ABGRToUVRow_LSX(const uint8_t* src_abgr,
+                     int src_stride_abgr,
+                     uint8_t* dst_u,
+                     uint8_t* dst_v,
+                     int width);
+void RGBAToUVRow_LSX(const uint8_t* src_rgba,
+                     int src_stride_rgba,
+                     uint8_t* dst_u,
+                     uint8_t* dst_v,
+                     int width);
+void ARGBToUVJRow_LSX(const uint8_t* src_argb,
+                      int src_stride_argb,
+                      uint8_t* dst_u,
+                      uint8_t* dst_v,
+                      int width);
+void ARGBToUVJRow_LASX(const uint8_t* src_argb,
+                       int src_stride_argb,
+                       uint8_t* dst_u,
+                       uint8_t* dst_v,
+                       int width);
+void ARGB1555ToUVRow_LSX(const uint8_t* src_argb1555,
+                         int src_stride_argb1555,
+                         uint8_t* dst_u,
+                         uint8_t* dst_v,
+                         int width);
+void ARGB1555ToUVRow_LASX(const uint8_t* src_argb1555,
+                          int src_stride_argb1555,
+                          uint8_t* dst_u,
+                          uint8_t* dst_v,
+                          int width);
+void RGB565ToUVRow_LSX(const uint8_t* src_rgb565,
+                       int src_stride_rgb565,
+                       uint8_t* dst_u,
+                       uint8_t* dst_v,
+                       int width);
+void RGB565ToUVRow_LASX(const uint8_t* src_rgb565,
+                        int src_stride_rgb565,
+                        uint8_t* dst_u,
+                        uint8_t* dst_v,
+                        int width);
+void RGB24ToUVRow_LSX(const uint8_t* src_rgb24,
+                      int src_stride_rgb24,
+                      uint8_t* dst_u,
+                      uint8_t* dst_v,
+                      int width);
+void RGB24ToUVRow_LASX(const uint8_t* src_rgb24,
+                       int src_stride_rgb24,
+                       uint8_t* dst_u,
+                       uint8_t* dst_v,
+                       int width);
+void RAWToUVRow_LSX(const uint8_t* src_raw,
+                    int src_stride_raw,
+                    uint8_t* dst_u,
+                    uint8_t* dst_v,
+                    int width);
+void RAWToUVRow_LASX(const uint8_t* src_raw,
+                     int src_stride_raw,
+                     uint8_t* dst_u,
+                     uint8_t* dst_v,
+                     int width);
+void BGRAToYRow_NEON(const uint8_t* src_bgra, uint8_t* dst_y, int width);
+void ABGRToYRow_NEON(const uint8_t* src_abgr, uint8_t* dst_y, int width);
+void RGBAToYRow_NEON(const uint8_t* src_rgba, uint8_t* dst_y, int width);
+void RGB24ToYRow_NEON(const uint8_t* src_rgb24, uint8_t* dst_y, int width);
+void RGB24ToYJRow_NEON(const uint8_t* src_rgb24, uint8_t* dst_yj, int width);
+void RAWToYRow_NEON(const uint8_t* src_raw, uint8_t* dst_y, int width);
+void RAWToYJRow_NEON(const uint8_t* src_raw, uint8_t* dst_yj, int width);
+void RGB565ToYRow_NEON(const uint8_t* src_rgb565, uint8_t* dst_y, int width);
+void ARGB1555ToYRow_NEON(const uint8_t* src_argb1555,
+                         uint8_t* dst_y,
+                         int width);
+void ARGB4444ToYRow_NEON(const uint8_t* src_argb4444,
+                         uint8_t* dst_y,
+                         int width);
+void BGRAToYRow_MSA(const uint8_t* src_argb, uint8_t* dst_y, int width);
+void ABGRToYRow_MSA(const uint8_t* src_argb, uint8_t* dst_y, int width);
+void RGBAToYRow_MSA(const uint8_t* src_argb, uint8_t* dst_y, int width);
+void RGB24ToYRow_MSA(const uint8_t* src_argb, uint8_t* dst_y, int width);
+void RAWToYRow_MSA(const uint8_t* src_argb, uint8_t* dst_y, int width);
+void RGB565ToYRow_MSA(const uint8_t* src_rgb565, uint8_t* dst_y, int width);
+void ARGB1555ToYRow_MSA(const uint8_t* src_argb1555, uint8_t* dst_y, int width);
+
+void BGRAToYRow_LSX(const uint8_t* src_bgra, uint8_t* dst_y, int width);
+void ABGRToYRow_LSX(const uint8_t* src_abgr, uint8_t* dst_y, int width);
+void RGBAToYRow_LSX(const uint8_t* src_rgba, uint8_t* dst_y, int width);
+void ARGB1555ToYRow_LSX(const uint8_t* src_argb1555, uint8_t* dst_y, int width);
+void ARGB1555ToYRow_LASX(const uint8_t* src_argb1555,
+                         uint8_t* dst_y,
+                         int width);
+void RGB565ToYRow_LSX(const uint8_t* src_rgb565, uint8_t* dst_y, int width);
+void RGB565ToYRow_LASX(const uint8_t* src_rgb565, uint8_t* dst_y, int width);
+void RGB24ToYRow_LSX(const uint8_t* src_rgb24, uint8_t* dst_y, int width);
+void RGB24ToYRow_LASX(const uint8_t* src_rgb24, uint8_t* dst_y, int width);
+void RAWToYRow_LSX(const uint8_t* src_raw, uint8_t* dst_y, int width);
+void RAWToYRow_LASX(const uint8_t* src_raw, uint8_t* dst_y, int width);
+
+void ARGBToYRow_C(const uint8_t* src_rgb, uint8_t* dst_y, int width);
+void ARGBToYJRow_C(const uint8_t* src_rgb, uint8_t* dst_y, int width);
+void RGBAToYJRow_C(const uint8_t* src_rgb, uint8_t* dst_y, int width);
+void BGRAToYRow_C(const uint8_t* src_rgb, uint8_t* dst_y, int width);
+void ABGRToYRow_C(const uint8_t* src_rgb, uint8_t* dst_y, int width);
+void RGBAToYRow_C(const uint8_t* src_rgb, uint8_t* dst_y, int width);
+void RGB24ToYRow_C(const uint8_t* src_rgb, uint8_t* dst_y, int width);
+void RGB24ToYJRow_C(const uint8_t* src_rgb, uint8_t* dst_y, int width);
+void RAWToYRow_C(const uint8_t* src_rgb, uint8_t* dst_y, int width);
+void RAWToYJRow_C(const uint8_t* src_rgb, uint8_t* dst_y, int width);
+void RGB565ToYRow_C(const uint8_t* src_rgb565, uint8_t* dst_y, int width);
+void ARGB1555ToYRow_C(const uint8_t* src_argb1555, uint8_t* dst_y, int width);
+void ARGB4444ToYRow_C(const uint8_t* src_argb4444, uint8_t* dst_y, int width);
+void ARGBToYRow_Any_SSSE3(const uint8_t* src_ptr, uint8_t* dst_ptr, int width);
+void ARGBToYJRow_Any_SSSE3(const uint8_t* src_ptr, uint8_t* dst_ptr, int width);
+void RGBAToYJRow_Any_SSSE3(const uint8_t* src_ptr, uint8_t* dst_ptr, int width);
+void BGRAToYRow_Any_SSSE3(const uint8_t* src_ptr, uint8_t* dst_ptr, int width);
+void ABGRToYRow_Any_SSSE3(const uint8_t* src_ptr, uint8_t* dst_ptr, int width);
+void RGBAToYRow_Any_SSSE3(const uint8_t* src_ptr, uint8_t* dst_ptr, int width);
+void RGB24ToYRow_Any_SSSE3(const uint8_t* src_ptr, uint8_t* dst_ptr, int width);
+void RGB24ToYJRow_Any_SSSE3(const uint8_t* src_ptr,
+                            uint8_t* dst_ptr,
+                            int width);
+void RAWToYRow_Any_SSSE3(const uint8_t* src_ptr, uint8_t* dst_ptr, int width);
+void RAWToYJRow_Any_SSSE3(const uint8_t* src_ptr, uint8_t* dst_ptr, int width);
+void RGB24ToYJRow_Any_AVX2(const uint8_t* src_ptr, uint8_t* dst_ptr, int width);
+void RAWToYJRow_Any_AVX2(const uint8_t* src_ptr, uint8_t* dst_ptr, int width);
+void ARGBToYRow_Any_NEON(const uint8_t* src_ptr, uint8_t* dst_ptr, int width);
+void ARGBToYJRow_Any_NEON(const uint8_t* src_ptr, uint8_t* dst_ptr, int width);
+void RGBAToYJRow_Any_NEON(const uint8_t* src_ptr, uint8_t* dst_ptr, int width);
+void BGRAToYRow_Any_NEON(const uint8_t* src_ptr, uint8_t* dst_ptr, int width);
+void ABGRToYRow_Any_NEON(const uint8_t* src_ptr, uint8_t* dst_ptr, int width);
+void RGBAToYRow_Any_NEON(const uint8_t* src_ptr, uint8_t* dst_ptr, int width);
+void RGB24ToYRow_Any_NEON(const uint8_t* src_ptr, uint8_t* dst_ptr, int width);
+void RGB24ToYJRow_Any_NEON(const uint8_t* src_ptr, uint8_t* dst_ptr, int width);
+void RAWToYRow_Any_NEON(const uint8_t* src_ptr, uint8_t* dst_ptr, int width);
+void RAWToYJRow_Any_NEON(const uint8_t* src_ptr, uint8_t* dst_ptr, int width);
+void RGB565ToYRow_Any_NEON(const uint8_t* src_ptr, uint8_t* dst_ptr, int width);
+void ARGB1555ToYRow_Any_NEON(const uint8_t* src_ptr,
+                             uint8_t* dst_ptr,
+                             int width);
+void ARGB4444ToYRow_Any_NEON(const uint8_t* src_ptr,
+                             uint8_t* dst_ptr,
+                             int width);
+void BGRAToYRow_Any_MSA(const uint8_t* src_ptr, uint8_t* dst_ptr, int width);
+void ABGRToYRow_Any_MSA(const uint8_t* src_ptr, uint8_t* dst_ptr, int width);
+void RGBAToYRow_Any_MSA(const uint8_t* src_ptr, uint8_t* dst_ptr, int width);
+void ARGBToYJRow_Any_MSA(const uint8_t* src_ptr, uint8_t* dst_ptr, int width);
+void ARGBToYRow_Any_MSA(const uint8_t* src_ptr, uint8_t* dst_ptr, int width);
+void RGB24ToYRow_Any_MSA(const uint8_t* src_ptr, uint8_t* dst_ptr, int width);
+void RAWToYRow_Any_MSA(const uint8_t* src_ptr, uint8_t* dst_ptr, int width);
+void RGB565ToYRow_Any_MSA(const uint8_t* src_ptr, uint8_t* dst_ptr, int width);
+void ARGB1555ToYRow_Any_MSA(const uint8_t* src_ptr,
+                            uint8_t* dst_ptr,
+                            int width);
+
+void BGRAToYRow_Any_LSX(const uint8_t* src_ptr, uint8_t* dst_ptr, int width);
+void ABGRToYRow_Any_LSX(const uint8_t* src_ptr, uint8_t* dst_ptr, int width);
+void RGBAToYRow_Any_LSX(const uint8_t* src_ptr, uint8_t* dst_ptr, int width);
+void ARGBToYJRow_Any_LSX(const uint8_t* src_ptr, uint8_t* dst_ptr, int width);
+void RGB24ToYRow_Any_LSX(const uint8_t* src_ptr, uint8_t* dst_ptr, int width);
+void RGB565ToYRow_Any_LSX(const uint8_t* src_ptr, uint8_t* dst_ptr, int width);
+void RAWToYRow_Any_LSX(const uint8_t* src_ptr, uint8_t* dst_ptr, int width);
+void ARGB1555ToYRow_Any_LSX(const uint8_t* src_ptr,
+                            uint8_t* dst_ptr,
+                            int width);
+
+void RGB565ToYRow_Any_LASX(const uint8_t* src_ptr, uint8_t* dst_ptr, int width);
+void RGB24ToYRow_Any_LASX(const uint8_t* src_ptr, uint8_t* dst_ptr, int width);
+void ARGBToYJRow_Any_LASX(const uint8_t* src_ptr, uint8_t* dst_ptr, int width);
+void ARGBToYRow_Any_LASX(const uint8_t* src_ptr, uint8_t* dst_ptr, int width);
+void RAWToYRow_Any_LASX(const uint8_t* src_ptr, uint8_t* dst_ptr, int width);
+void ARGB1555ToYRow_Any_LASX(const uint8_t* src_ptr,
+                             uint8_t* dst_ptr,
+                             int width);
+
+void ARGBToUVRow_AVX2(const uint8_t* src_argb,
+                      int src_stride_argb,
+                      uint8_t* dst_u,
+                      uint8_t* dst_v,
+                      int width);
+void ABGRToUVRow_AVX2(const uint8_t* src_abgr,
+                      int src_stride_abgr,
+                      uint8_t* dst_u,
+                      uint8_t* dst_v,
+                      int width);
+void ARGBToUVJRow_AVX2(const uint8_t* src_argb,
+                       int src_stride_argb,
+                       uint8_t* dst_u,
+                       uint8_t* dst_v,
+                       int width);
+void ARGBToUVRow_SSSE3(const uint8_t* src_argb,
+                       int src_stride_argb,
+                       uint8_t* dst_u,
+                       uint8_t* dst_v,
+                       int width);
+void ARGBToUVJRow_SSSE3(const uint8_t* src_argb,
+                        int src_stride_argb,
+                        uint8_t* dst_u,
+                        uint8_t* dst_v,
+                        int width);
+void BGRAToUVRow_SSSE3(const uint8_t* src_bgra,
+                       int src_stride_bgra,
+                       uint8_t* dst_u,
+                       uint8_t* dst_v,
+                       int width);
+void ABGRToUVRow_SSSE3(const uint8_t* src_abgr,
+                       int src_stride_abgr,
+                       uint8_t* dst_u,
+                       uint8_t* dst_v,
+                       int width);
+void RGBAToUVRow_SSSE3(const uint8_t* src_rgba,
+                       int src_stride_rgba,
+                       uint8_t* dst_u,
+                       uint8_t* dst_v,
+                       int width);
+void ARGBToUVRow_Any_AVX2(const uint8_t* src_ptr,
+                          int src_stride,
+                          uint8_t* dst_u,
+                          uint8_t* dst_v,
+                          int width);
+void ABGRToUVRow_Any_AVX2(const uint8_t* src_ptr,
+                          int src_stride,
+                          uint8_t* dst_u,
+                          uint8_t* dst_v,
+                          int width);
+void ARGBToUVJRow_Any_AVX2(const uint8_t* src_ptr,
+                           int src_stride,
+                           uint8_t* dst_u,
+                           uint8_t* dst_v,
+                           int width);
+void ARGBToUVRow_Any_SSSE3(const uint8_t* src_ptr,
+                           int src_stride,
+                           uint8_t* dst_u,
+                           uint8_t* dst_v,
+                           int width);
+void ARGBToUVJRow_Any_SSSE3(const uint8_t* src_ptr,
+                            int src_stride,
+                            uint8_t* dst_u,
+                            uint8_t* dst_v,
+                            int width);
+void BGRAToUVRow_Any_SSSE3(const uint8_t* src_ptr,
+                           int src_stride,
+                           uint8_t* dst_u,
+                           uint8_t* dst_v,
+                           int width);
+void ABGRToUVRow_Any_SSSE3(const uint8_t* src_ptr,
+                           int src_stride,
+                           uint8_t* dst_u,
+                           uint8_t* dst_v,
+                           int width);
+void RGBAToUVRow_Any_SSSE3(const uint8_t* src_ptr,
+                           int src_stride,
+                           uint8_t* dst_u,
+                           uint8_t* dst_v,
+                           int width);
+void ARGBToUV444Row_Any_NEON(const uint8_t* src_ptr,
+                             uint8_t* dst_u,
+                             uint8_t* dst_v,
+                             int width);
+void ARGBToUVRow_Any_NEON(const uint8_t* src_ptr,
+                          int src_stride,
+                          uint8_t* dst_u,
+                          uint8_t* dst_v,
+                          int width);
+void ARGBToUV444Row_Any_MSA(const uint8_t* src_ptr,
+                            uint8_t* dst_u,
+                            uint8_t* dst_v,
+                            int width);
+void ARGBToUVRow_Any_MSA(const uint8_t* src_ptr,
+                         int src_stride_ptr,
+                         uint8_t* dst_u,
+                         uint8_t* dst_v,
+                         int width);
+void ARGBToUVRow_Any_LASX(const uint8_t* src_ptr,
+                          int src_stride_ptr,
+                          uint8_t* dst_u,
+                          uint8_t* dst_v,
+                          int width);
+void ARGBToUV444Row_Any_LASX(const uint8_t* src_ptr,
+                             uint8_t* dst_u,
+                             uint8_t* dst_v,
+                             int width);
+void ARGBToUVJRow_Any_NEON(const uint8_t* src_ptr,
+                           int src_stride,
+                           uint8_t* dst_u,
+                           uint8_t* dst_v,
+                           int width);
+void BGRAToUVRow_Any_NEON(const uint8_t* src_ptr,
+                          int src_stride,
+                          uint8_t* dst_u,
+                          uint8_t* dst_v,
+                          int width);
+void ABGRToUVRow_Any_NEON(const uint8_t* src_ptr,
+                          int src_stride,
+                          uint8_t* dst_u,
+                          uint8_t* dst_v,
+                          int width);
+void RGBAToUVRow_Any_NEON(const uint8_t* src_ptr,
+                          int src_stride,
+                          uint8_t* dst_u,
+                          uint8_t* dst_v,
+                          int width);
+void RGB24ToUVRow_Any_NEON(const uint8_t* src_ptr,
+                           int src_stride,
+                           uint8_t* dst_u,
+                           uint8_t* dst_v,
+                           int width);
+void RAWToUVRow_Any_NEON(const uint8_t* src_ptr,
+                         int src_stride,
+                         uint8_t* dst_u,
+                         uint8_t* dst_v,
+                         int width);
+void RGB24ToUVJRow_Any_NEON(const uint8_t* src_ptr,
+                            int src_stride,
+                            uint8_t* dst_u,
+                            uint8_t* dst_v,
+                            int width);
+void RAWToUVJRow_Any_NEON(const uint8_t* src_ptr,
+                          int src_stride,
+                          uint8_t* dst_u,
+                          uint8_t* dst_v,
+                          int width);
+void RGB565ToUVRow_Any_NEON(const uint8_t* src_ptr,
+                            int src_stride,
+                            uint8_t* dst_u,
+                            uint8_t* dst_v,
+                            int width);
+void ARGB1555ToUVRow_Any_NEON(const uint8_t* src_ptr,
+                              int src_stride,
+                              uint8_t* dst_u,
+                              uint8_t* dst_v,
+                              int width);
+void ARGB4444ToUVRow_Any_NEON(const uint8_t* src_ptr,
+                              int src_stride,
+                              uint8_t* dst_u,
+                              uint8_t* dst_v,
+                              int width);
+void ARGBToUVJRow_Any_MSA(const uint8_t* src_ptr,
+                          int src_stride_ptr,
+                          uint8_t* dst_u,
+                          uint8_t* dst_v,
+                          int width);
+void BGRAToUVRow_Any_MSA(const uint8_t* src_ptr,
+                         int src_stride_ptr,
+                         uint8_t* dst_u,
+                         uint8_t* dst_v,
+                         int width);
+void ABGRToUVRow_Any_MSA(const uint8_t* src_ptr,
+                         int src_stride_ptr,
+                         uint8_t* dst_u,
+                         uint8_t* dst_v,
+                         int width);
+void RGBAToUVRow_Any_MSA(const uint8_t* src_ptr,
+                         int src_stride_ptr,
+                         uint8_t* dst_u,
+                         uint8_t* dst_v,
+                         int width);
+void RGB24ToUVRow_Any_MSA(const uint8_t* src_ptr,
+                          int src_stride_ptr,
+                          uint8_t* dst_u,
+                          uint8_t* dst_v,
+                          int width);
+void RAWToUVRow_Any_MSA(const uint8_t* src_ptr,
+                        int src_stride_ptr,
+                        uint8_t* dst_u,
+                        uint8_t* dst_v,
+                        int width);
+void RGB565ToUVRow_Any_MSA(const uint8_t* src_ptr,
+                           int src_stride_ptr,
+                           uint8_t* dst_u,
+                           uint8_t* dst_v,
+                           int width);
+void ARGB1555ToUVRow_Any_MSA(const uint8_t* src_ptr,
+                             int src_stride_ptr,
+                             uint8_t* dst_u,
+                             uint8_t* dst_v,
+                             int width);
+void ABGRToUVRow_Any_LSX(const uint8_t* src_ptr,
+                         int src_stride_ptr,
+                         uint8_t* dst_u,
+                         uint8_t* dst_v,
+                         int width);
+void BGRAToUVRow_Any_LSX(const uint8_t* src_ptr,
+                         int src_stride_ptr,
+                         uint8_t* dst_u,
+                         uint8_t* dst_v,
+                         int width);
+void RGBAToUVRow_Any_LSX(const uint8_t* src_ptr,
+                         int src_stride_ptr,
+                         uint8_t* dst_u,
+                         uint8_t* dst_v,
+                         int width);
+void ARGBToUVJRow_Any_LSX(const uint8_t* src_ptr,
+                          int src_stride_ptr,
+                          uint8_t* dst_u,
+                          uint8_t* dst_v,
+                          int width);
+void ARGBToUVJRow_Any_LASX(const uint8_t* src_ptr,
+                           int src_stride_ptr,
+                           uint8_t* dst_u,
+                           uint8_t* dst_v,
+                           int width);
+void ARGB1555ToUVRow_Any_LSX(const uint8_t* src_ptr,
+                             int src_stride_ptr,
+                             uint8_t* dst_u,
+                             uint8_t* dst_v,
+                             int width);
+void ARGB1555ToUVRow_Any_LASX(const uint8_t* src_ptr,
+                              int src_stride_ptr,
+                              uint8_t* dst_u,
+                              uint8_t* dst_v,
+                              int width);
+void RGB565ToUVRow_Any_LSX(const uint8_t* src_ptr,
+                           int src_stride_ptr,
+                           uint8_t* dst_u,
+                           uint8_t* dst_v,
+                           int width);
+void RGB565ToUVRow_Any_LASX(const uint8_t* src_ptr,
+                            int src_stride_ptr,
+                            uint8_t* dst_u,
+                            uint8_t* dst_v,
+                            int width);
+void RGB24ToUVRow_Any_LSX(const uint8_t* src_ptr,
+                          int src_stride_ptr,
+                          uint8_t* dst_u,
+                          uint8_t* dst_v,
+                          int width);
+void RGB24ToUVRow_Any_LASX(const uint8_t* src_ptr,
+                           int src_stride_ptr,
+                           uint8_t* dst_u,
+                           uint8_t* dst_v,
+                           int width);
+void RAWToUVRow_Any_LSX(const uint8_t* src_ptr,
+                        int src_stride_ptr,
+                        uint8_t* dst_u,
+                        uint8_t* dst_v,
+                        int width);
+void RAWToUVRow_Any_LASX(const uint8_t* src_ptr,
+                         int src_stride_ptr,
+                         uint8_t* dst_u,
+                         uint8_t* dst_v,
+                         int width);
+void ARGBToUVRow_C(const uint8_t* src_rgb,
+                   int src_stride_rgb,
+                   uint8_t* dst_u,
+                   uint8_t* dst_v,
+                   int width);
+void ARGBToUVJRow_C(const uint8_t* src_rgb,
+                    int src_stride_rgb,
+                    uint8_t* dst_u,
+                    uint8_t* dst_v,
+                    int width);
+void ARGBToUVRow_C(const uint8_t* src_rgb,
+                   int src_stride_rgb,
+                   uint8_t* dst_u,
+                   uint8_t* dst_v,
+                   int width);
+void ARGBToUVJRow_C(const uint8_t* src_rgb,
+                    int src_stride_rgb,
+                    uint8_t* dst_u,
+                    uint8_t* dst_v,
+                    int width);
+void BGRAToUVRow_C(const uint8_t* src_rgb,
+                   int src_stride_rgb,
+                   uint8_t* dst_u,
+                   uint8_t* dst_v,
+                   int width);
+void ABGRToUVRow_C(const uint8_t* src_rgb,
+                   int src_stride_rgb,
+                   uint8_t* dst_u,
+                   uint8_t* dst_v,
+                   int width);
+void RGBAToUVRow_C(const uint8_t* src_rgb,
+                   int src_stride_rgb,
+                   uint8_t* dst_u,
+                   uint8_t* dst_v,
+                   int width);
+void RGB24ToUVRow_C(const uint8_t* src_rgb,
+                    int src_stride_rgb,
+                    uint8_t* dst_u,
+                    uint8_t* dst_v,
+                    int width);
+void RAWToUVRow_C(const uint8_t* src_rgb,
+                  int src_stride_rgb,
+                  uint8_t* dst_u,
+                  uint8_t* dst_v,
+                  int width);
+void RGB24ToUVJRow_C(const uint8_t* src_rgb,
+                     int src_stride_rgb,
+                     uint8_t* dst_u,
+                     uint8_t* dst_v,
+                     int width);
+void RAWToUVJRow_C(const uint8_t* src_rgb,
+                   int src_stride_rgb,
+                   uint8_t* dst_u,
+                   uint8_t* dst_v,
+                   int width);
+void RGB565ToUVRow_C(const uint8_t* src_rgb565,
+                     int src_stride_rgb565,
+                     uint8_t* dst_u,
+                     uint8_t* dst_v,
+                     int width);
+void ARGB1555ToUVRow_C(const uint8_t* src_argb1555,
+                       int src_stride_argb1555,
+                       uint8_t* dst_u,
+                       uint8_t* dst_v,
+                       int width);
+void ARGB4444ToUVRow_C(const uint8_t* src_argb4444,
+                       int src_stride_argb4444,
+                       uint8_t* dst_u,
+                       uint8_t* dst_v,
+                       int width);
+
+void ARGBToUV444Row_SSSE3(const uint8_t* src_argb,
+                          uint8_t* dst_u,
+                          uint8_t* dst_v,
+                          int width);
+void ARGBToUV444Row_Any_SSSE3(const uint8_t* src_ptr,
+                              uint8_t* dst_u,
+                              uint8_t* dst_v,
+                              int width);
+
+void ARGBToUV444Row_C(const uint8_t* src_argb,
+                      uint8_t* dst_u,
+                      uint8_t* dst_v,
+                      int width);
+
+void MirrorRow_AVX2(const uint8_t* src, uint8_t* dst, int width);
+void MirrorRow_SSSE3(const uint8_t* src, uint8_t* dst, int width);
+void MirrorRow_NEON(const uint8_t* src, uint8_t* dst, int width);
+void MirrorRow_MSA(const uint8_t* src, uint8_t* dst, int width);
+void MirrorRow_LASX(const uint8_t* src, uint8_t* dst, int width);
+void MirrorRow_C(const uint8_t* src, uint8_t* dst, int width);
+void MirrorRow_Any_AVX2(const uint8_t* src_ptr, uint8_t* dst_ptr, int width);
+void MirrorRow_Any_SSSE3(const uint8_t* src_ptr, uint8_t* dst_ptr, int width);
+void MirrorRow_Any_SSE2(const uint8_t* src, uint8_t* dst, int width);
+void MirrorRow_Any_NEON(const uint8_t* src_ptr, uint8_t* dst_ptr, int width);
+void MirrorRow_Any_MSA(const uint8_t* src_ptr, uint8_t* dst_ptr, int width);
+void MirrorRow_Any_LASX(const uint8_t* src_ptr, uint8_t* dst_ptr, int width);
+void MirrorUVRow_AVX2(const uint8_t* src_uv, uint8_t* dst_uv, int width);
+void MirrorUVRow_SSSE3(const uint8_t* src_uv, uint8_t* dst_uv, int width);
+void MirrorUVRow_NEON(const uint8_t* src_uv, uint8_t* dst_uv, int width);
+void MirrorUVRow_MSA(const uint8_t* src_uv, uint8_t* dst_uv, int width);
+void MirrorUVRow_LASX(const uint8_t* src_uv, uint8_t* dst_uv, int width);
+void MirrorUVRow_C(const uint8_t* src_uv, uint8_t* dst_uv, int width);
+void MirrorUVRow_Any_AVX2(const uint8_t* src_ptr, uint8_t* dst_ptr, int width);
+void MirrorUVRow_Any_SSSE3(const uint8_t* src_ptr, uint8_t* dst_ptr, int width);
+void MirrorUVRow_Any_NEON(const uint8_t* src_ptr, uint8_t* dst_ptr, int width);
+void MirrorUVRow_Any_MSA(const uint8_t* src_ptr, uint8_t* dst_ptr, int width);
+void MirrorUVRow_Any_LASX(const uint8_t* src_ptr, uint8_t* dst_ptr, int width);
+
+void MirrorSplitUVRow_SSSE3(const uint8_t* src,
+                            uint8_t* dst_u,
+                            uint8_t* dst_v,
+                            int width);
+void MirrorSplitUVRow_NEON(const uint8_t* src_uv,
+                           uint8_t* dst_u,
+                           uint8_t* dst_v,
+                           int width);
+void MirrorSplitUVRow_MSA(const uint8_t* src_uv,
+                          uint8_t* dst_u,
+                          uint8_t* dst_v,
+                          int width);
+void MirrorSplitUVRow_LSX(const uint8_t* src_uv,
+                          uint8_t* dst_u,
+                          uint8_t* dst_v,
+                          int width);
+void MirrorSplitUVRow_C(const uint8_t* src_uv,
+                        uint8_t* dst_u,
+                        uint8_t* dst_v,
+                        int width);
+
+void ARGBMirrorRow_AVX2(const uint8_t* src, uint8_t* dst, int width);
+void ARGBMirrorRow_SSE2(const uint8_t* src, uint8_t* dst, int width);
+void ARGBMirrorRow_NEON(const uint8_t* src_argb, uint8_t* dst_argb, int width);
+void ARGBMirrorRow_MSA(const uint8_t* src, uint8_t* dst, int width);
+void ARGBMirrorRow_LASX(const uint8_t* src, uint8_t* dst, int width);
+void ARGBMirrorRow_C(const uint8_t* src, uint8_t* dst, int width);
+void ARGBMirrorRow_Any_AVX2(const uint8_t* src_ptr,
+                            uint8_t* dst_ptr,
+                            int width);
+void ARGBMirrorRow_Any_SSE2(const uint8_t* src_ptr,
+                            uint8_t* dst_ptr,
+                            int width);
+void ARGBMirrorRow_Any_NEON(const uint8_t* src_ptr,
+                            uint8_t* dst_ptr,
+                            int width);
+void ARGBMirrorRow_Any_MSA(const uint8_t* src_ptr, uint8_t* dst_ptr, int width);
+void ARGBMirrorRow_Any_LASX(const uint8_t* src_ptr,
+                            uint8_t* dst_ptr,
+                            int width);
+
+void RGB24MirrorRow_SSSE3(const uint8_t* src_rgb24,
+                          uint8_t* dst_rgb24,
+                          int width);
+void RGB24MirrorRow_NEON(const uint8_t* src_rgb24,
+                         uint8_t* dst_rgb24,
+                         int width);
+void RGB24MirrorRow_C(const uint8_t* src_rgb24, uint8_t* dst_rgb24, int width);
+void RGB24MirrorRow_Any_SSSE3(const uint8_t* src_ptr,
+                              uint8_t* dst_ptr,
+                              int width);
+void RGB24MirrorRow_Any_NEON(const uint8_t* src_ptr,
+                             uint8_t* dst_ptr,
+                             int width);
+
+void SplitUVRow_C(const uint8_t* src_uv,
+                  uint8_t* dst_u,
+                  uint8_t* dst_v,
+                  int width);
+void SplitUVRow_SSE2(const uint8_t* src_uv,
+                     uint8_t* dst_u,
+                     uint8_t* dst_v,
+                     int width);
+void SplitUVRow_AVX2(const uint8_t* src_uv,
+                     uint8_t* dst_u,
+                     uint8_t* dst_v,
+                     int width);
+void SplitUVRow_NEON(const uint8_t* src_uv,
+                     uint8_t* dst_u,
+                     uint8_t* dst_v,
+                     int width);
+void SplitUVRow_MSA(const uint8_t* src_uv,
+                    uint8_t* dst_u,
+                    uint8_t* dst_v,
+                    int width);
+void SplitUVRow_LSX(const uint8_t* src_uv,
+                    uint8_t* dst_u,
+                    uint8_t* dst_v,
+                    int width);
+void SplitUVRow_Any_SSE2(const uint8_t* src_ptr,
+                         uint8_t* dst_u,
+                         uint8_t* dst_v,
+                         int width);
+void SplitUVRow_Any_AVX2(const uint8_t* src_ptr,
+                         uint8_t* dst_u,
+                         uint8_t* dst_v,
+                         int width);
+void SplitUVRow_Any_NEON(const uint8_t* src_ptr,
+                         uint8_t* dst_u,
+                         uint8_t* dst_v,
+                         int width);
+void SplitUVRow_Any_MSA(const uint8_t* src_ptr,
+                        uint8_t* dst_u,
+                        uint8_t* dst_v,
+                        int width);
+void SplitUVRow_Any_LSX(const uint8_t* src_ptr,
+                        uint8_t* dst_u,
+                        uint8_t* dst_v,
+                        int width);
+void DetileRow_C(const uint8_t* src,
+                 ptrdiff_t src_tile_stride,
+                 uint8_t* dst,
+                 int width);
+
+void DetileRow_NEON(const uint8_t* src,
+                    ptrdiff_t src_tile_stride,
+                    uint8_t* dst,
+                    int width);
+void DetileRow_Any_NEON(const uint8_t* src,
+                        ptrdiff_t src_tile_stride,
+                        uint8_t* dst,
+                        int width);
+void DetileRow_SSE2(const uint8_t* src,
+                    ptrdiff_t src_tile_stride,
+                    uint8_t* dst,
+                    int width);
+void DetileRow_Any_SSE2(const uint8_t* src,
+                        ptrdiff_t src_tile_stride,
+                        uint8_t* dst,
+                        int width);
+void DetileSplitUVRow_C(const uint8_t* src_uv,
+                        ptrdiff_t src_tile_stride,
+                        uint8_t* dst_u,
+                        uint8_t* dst_v,
+                        int width);
+void DetileSplitUVRow_SSSE3(const uint8_t* src_uv,
+                            ptrdiff_t src_tile_stride,
+                            uint8_t* dst_u,
+                            uint8_t* dst_v,
+                            int width);
+void DetileSplitUVRow_Any_SSSE3(const uint8_t* src_uv,
+                                ptrdiff_t src_tile_stride,
+                                uint8_t* dst_u,
+                                uint8_t* dst_v,
+                                int width);
+void DetileSplitUVRow_NEON(const uint8_t* src_uv,
+                           ptrdiff_t src_tile_stride,
+                           uint8_t* dst_u,
+                           uint8_t* dst_v,
+                           int width);
+void DetileSplitUVRow_Any_NEON(const uint8_t* src_uv,
+                               ptrdiff_t src_tile_stride,
+                               uint8_t* dst_u,
+                               uint8_t* dst_v,
+                               int width);
+void MergeUVRow_C(const uint8_t* src_u,
+                  const uint8_t* src_v,
+                  uint8_t* dst_uv,
+                  int width);
+void MergeUVRow_SSE2(const uint8_t* src_u,
+                     const uint8_t* src_v,
+                     uint8_t* dst_uv,
+                     int width);
+void MergeUVRow_AVX2(const uint8_t* src_u,
+                     const uint8_t* src_v,
+                     uint8_t* dst_uv,
+                     int width);
+void MergeUVRow_NEON(const uint8_t* src_u,
+                     const uint8_t* src_v,
+                     uint8_t* dst_uv,
+                     int width);
+void MergeUVRow_MSA(const uint8_t* src_u,
+                    const uint8_t* src_v,
+                    uint8_t* dst_uv,
+                    int width);
+void MergeUVRow_LSX(const uint8_t* src_u,
+                    const uint8_t* src_v,
+                    uint8_t* dst_uv,
+                    int width);
+void MergeUVRow_Any_SSE2(const uint8_t* y_buf,
+                         const uint8_t* uv_buf,
+                         uint8_t* dst_ptr,
+                         int width);
+void MergeUVRow_Any_AVX2(const uint8_t* y_buf,
+                         const uint8_t* uv_buf,
+                         uint8_t* dst_ptr,
+                         int width);
+void MergeUVRow_Any_NEON(const uint8_t* y_buf,
+                         const uint8_t* uv_buf,
+                         uint8_t* dst_ptr,
+                         int width);
+void MergeUVRow_Any_MSA(const uint8_t* y_buf,
+                        const uint8_t* uv_buf,
+                        uint8_t* dst_ptr,
+                        int width);
+void MergeUVRow_Any_LSX(const uint8_t* y_buf,
+                        const uint8_t* uv_buf,
+                        uint8_t* dst_ptr,
+                        int width);
+
+void HalfMergeUVRow_C(const uint8_t* src_u,
+                      int src_stride_u,
+                      const uint8_t* src_v,
+                      int src_stride_v,
+                      uint8_t* dst_uv,
+                      int width);
+
+void HalfMergeUVRow_NEON(const uint8_t* src_u,
+                         int src_stride_u,
+                         const uint8_t* src_v,
+                         int src_stride_v,
+                         uint8_t* dst_uv,
+                         int width);
+
+void HalfMergeUVRow_SSSE3(const uint8_t* src_u,
+                          int src_stride_u,
+                          const uint8_t* src_v,
+                          int src_stride_v,
+                          uint8_t* dst_uv,
+                          int width);
+
+void HalfMergeUVRow_AVX2(const uint8_t* src_u,
+                         int src_stride_u,
+                         const uint8_t* src_v,
+                         int src_stride_v,
+                         uint8_t* dst_uv,
+                         int width);
+
+void SplitRGBRow_C(const uint8_t* src_rgb,
+                   uint8_t* dst_r,
+                   uint8_t* dst_g,
+                   uint8_t* dst_b,
+                   int width);
+void SplitRGBRow_SSSE3(const uint8_t* src_rgb,
+                       uint8_t* dst_r,
+                       uint8_t* dst_g,
+                       uint8_t* dst_b,
+                       int width);
+void SplitRGBRow_NEON(const uint8_t* src_rgb,
+                      uint8_t* dst_r,
+                      uint8_t* dst_g,
+                      uint8_t* dst_b,
+                      int width);
+void SplitRGBRow_Any_SSSE3(const uint8_t* src_ptr,
+                           uint8_t* dst_r,
+                           uint8_t* dst_g,
+                           uint8_t* dst_b,
+                           int width);
+void SplitRGBRow_Any_NEON(const uint8_t* src_ptr,
+                          uint8_t* dst_r,
+                          uint8_t* dst_g,
+                          uint8_t* dst_b,
+                          int width);
+
+void MergeRGBRow_C(const uint8_t* src_r,
+                   const uint8_t* src_g,
+                   const uint8_t* src_b,
+                   uint8_t* dst_rgb,
+                   int width);
+void MergeRGBRow_SSSE3(const uint8_t* src_r,
+                       const uint8_t* src_g,
+                       const uint8_t* src_b,
+                       uint8_t* dst_rgb,
+                       int width);
+void MergeRGBRow_NEON(const uint8_t* src_r,
+                      const uint8_t* src_g,
+                      const uint8_t* src_b,
+                      uint8_t* dst_rgb,
+                      int width);
+void MergeRGBRow_Any_SSSE3(const uint8_t* y_buf,
+                           const uint8_t* u_buf,
+                           const uint8_t* v_buf,
+                           uint8_t* dst_ptr,
+                           int width);
+void MergeRGBRow_Any_NEON(const uint8_t* src_r,
+                          const uint8_t* src_g,
+                          const uint8_t* src_b,
+                          uint8_t* dst_rgb,
+                          int width);
+void MergeARGBRow_C(const uint8_t* src_r,
+                    const uint8_t* src_g,
+                    const uint8_t* src_b,
+                    const uint8_t* src_a,
+                    uint8_t* dst_argb,
+                    int width);
+void MergeARGBRow_SSE2(const uint8_t* src_r,
+                       const uint8_t* src_g,
+                       const uint8_t* src_b,
+                       const uint8_t* src_a,
+                       uint8_t* dst_argb,
+                       int width);
+void MergeARGBRow_AVX2(const uint8_t* src_r,
+                       const uint8_t* src_g,
+                       const uint8_t* src_b,
+                       const uint8_t* src_a,
+                       uint8_t* dst_argb,
+                       int width);
+void MergeARGBRow_NEON(const uint8_t* src_r,
+                       const uint8_t* src_g,
+                       const uint8_t* src_b,
+                       const uint8_t* src_a,
+                       uint8_t* dst_argb,
+                       int width);
+void MergeARGBRow_Any_SSE2(const uint8_t* y_buf,
+                           const uint8_t* u_buf,
+                           const uint8_t* v_buf,
+                           const uint8_t* a_buf,
+                           uint8_t* dst_ptr,
+                           int width);
+void MergeARGBRow_Any_AVX2(const uint8_t* y_buf,
+                           const uint8_t* u_buf,
+                           const uint8_t* v_buf,
+                           const uint8_t* a_buf,
+                           uint8_t* dst_ptr,
+                           int width);
+void MergeARGBRow_Any_NEON(const uint8_t* y_buf,
+                           const uint8_t* u_buf,
+                           const uint8_t* v_buf,
+                           const uint8_t* a_buf,
+                           uint8_t* dst_ptr,
+                           int width);
+void SplitARGBRow_C(const uint8_t* src_argb,
+                    uint8_t* dst_r,
+                    uint8_t* dst_g,
+                    uint8_t* dst_b,
+                    uint8_t* dst_a,
+                    int width);
+void SplitARGBRow_SSE2(const uint8_t* src_argb,
+                       uint8_t* dst_r,
+                       uint8_t* dst_g,
+                       uint8_t* dst_b,
+                       uint8_t* dst_a,
+                       int width);
+void SplitARGBRow_SSSE3(const uint8_t* src_argb,
+                        uint8_t* dst_r,
+                        uint8_t* dst_g,
+                        uint8_t* dst_b,
+                        uint8_t* dst_a,
+                        int width);
+void SplitARGBRow_AVX2(const uint8_t* src_argb,
+                       uint8_t* dst_r,
+                       uint8_t* dst_g,
+                       uint8_t* dst_b,
+                       uint8_t* dst_a,
+                       int width);
+void SplitARGBRow_NEON(const uint8_t* src_rgba,
+                       uint8_t* dst_r,
+                       uint8_t* dst_g,
+                       uint8_t* dst_b,
+                       uint8_t* dst_a,
+                       int width);
+void SplitARGBRow_Any_SSE2(const uint8_t* src_ptr,
+                           uint8_t* dst_r,
+                           uint8_t* dst_g,
+                           uint8_t* dst_b,
+                           uint8_t* dst_a,
+                           int width);
+void SplitARGBRow_Any_SSSE3(const uint8_t* src_ptr,
+                            uint8_t* dst_r,
+                            uint8_t* dst_g,
+                            uint8_t* dst_b,
+                            uint8_t* dst_a,
+                            int width);
+void SplitARGBRow_Any_AVX2(const uint8_t* src_ptr,
+                           uint8_t* dst_r,
+                           uint8_t* dst_g,
+                           uint8_t* dst_b,
+                           uint8_t* dst_a,
+                           int width);
+void SplitARGBRow_Any_NEON(const uint8_t* src_ptr,
+                           uint8_t* dst_r,
+                           uint8_t* dst_g,
+                           uint8_t* dst_b,
+                           uint8_t* dst_a,
+                           int width);
+void MergeXRGBRow_C(const uint8_t* src_r,
+                    const uint8_t* src_g,
+                    const uint8_t* src_b,
+                    uint8_t* dst_argb,
+                    int width);
+void MergeXRGBRow_SSE2(const uint8_t* src_r,
+                       const uint8_t* src_g,
+                       const uint8_t* src_b,
+                       uint8_t* dst_argb,
+                       int width);
+void MergeXRGBRow_AVX2(const uint8_t* src_r,
+                       const uint8_t* src_g,
+                       const uint8_t* src_b,
+                       uint8_t* dst_argb,
+                       int width);
+void MergeXRGBRow_NEON(const uint8_t* src_r,
+                       const uint8_t* src_g,
+                       const uint8_t* src_b,
+                       uint8_t* dst_argb,
+                       int width);
+void MergeXRGBRow_Any_SSE2(const uint8_t* y_buf,
+                           const uint8_t* u_buf,
+                           const uint8_t* v_buf,
+                           uint8_t* dst_ptr,
+                           int width);
+void MergeXRGBRow_Any_AVX2(const uint8_t* y_buf,
+                           const uint8_t* u_buf,
+                           const uint8_t* v_buf,
+                           uint8_t* dst_ptr,
+                           int width);
+void MergeXRGBRow_Any_NEON(const uint8_t* y_buf,
+                           const uint8_t* u_buf,
+                           const uint8_t* v_buf,
+                           uint8_t* dst_ptr,
+                           int width);
+void SplitXRGBRow_C(const uint8_t* src_argb,
+                    uint8_t* dst_r,
+                    uint8_t* dst_g,
+                    uint8_t* dst_b,
+                    int width);
+void SplitXRGBRow_SSE2(const uint8_t* src_argb,
+                       uint8_t* dst_r,
+                       uint8_t* dst_g,
+                       uint8_t* dst_b,
+                       int width);
+void SplitXRGBRow_SSSE3(const uint8_t* src_argb,
+                        uint8_t* dst_r,
+                        uint8_t* dst_g,
+                        uint8_t* dst_b,
+                        int width);
+void SplitXRGBRow_AVX2(const uint8_t* src_argb,
+                       uint8_t* dst_r,
+                       uint8_t* dst_g,
+                       uint8_t* dst_b,
+                       int width);
+void SplitXRGBRow_NEON(const uint8_t* src_rgba,
+                       uint8_t* dst_r,
+                       uint8_t* dst_g,
+                       uint8_t* dst_b,
+                       int width);
+void SplitXRGBRow_Any_SSE2(const uint8_t* src_ptr,
+                           uint8_t* dst_r,
+                           uint8_t* dst_g,
+                           uint8_t* dst_b,
+                           int width);
+void SplitXRGBRow_Any_SSSE3(const uint8_t* src_ptr,
+                            uint8_t* dst_r,
+                            uint8_t* dst_g,
+                            uint8_t* dst_b,
+                            int width);
+void SplitXRGBRow_Any_AVX2(const uint8_t* src_ptr,
+                           uint8_t* dst_r,
+                           uint8_t* dst_g,
+                           uint8_t* dst_b,
+                           int width);
+void SplitXRGBRow_Any_NEON(const uint8_t* src_ptr,
+                           uint8_t* dst_r,
+                           uint8_t* dst_g,
+                           uint8_t* dst_b,
+                           int width);
+
+void MergeXR30Row_C(const uint16_t* src_r,
+                    const uint16_t* src_g,
+                    const uint16_t* src_b,
+                    uint8_t* dst_ar30,
+                    int depth,
+                    int width);
+void MergeAR64Row_C(const uint16_t* src_r,
+                    const uint16_t* src_g,
+                    const uint16_t* src_b,
+                    const uint16_t* src_a,
+                    uint16_t* dst_ar64,
+                    int depth,
+                    int width);
+void MergeARGB16To8Row_C(const uint16_t* src_r,
+                         const uint16_t* src_g,
+                         const uint16_t* src_b,
+                         const uint16_t* src_a,
+                         uint8_t* dst_argb,
+                         int depth,
+                         int width);
+void MergeXR64Row_C(const uint16_t* src_r,
+                    const uint16_t* src_g,
+                    const uint16_t* src_b,
+                    uint16_t* dst_ar64,
+                    int depth,
+                    int width);
+void MergeXRGB16To8Row_C(const uint16_t* src_r,
+                         const uint16_t* src_g,
+                         const uint16_t* src_b,
+                         uint8_t* dst_argb,
+                         int depth,
+                         int width);
+void MergeXR30Row_AVX2(const uint16_t* src_r,
+                       const uint16_t* src_g,
+                       const uint16_t* src_b,
+                       uint8_t* dst_ar30,
+                       int depth,
+                       int width);
+void MergeAR64Row_AVX2(const uint16_t* src_r,
+                       const uint16_t* src_g,
+                       const uint16_t* src_b,
+                       const uint16_t* src_a,
+                       uint16_t* dst_ar64,
+                       int depth,
+                       int width);
+void MergeARGB16To8Row_AVX2(const uint16_t* src_r,
+                            const uint16_t* src_g,
+                            const uint16_t* src_b,
+                            const uint16_t* src_a,
+                            uint8_t* dst_argb,
+                            int depth,
+                            int width);
+void MergeXR64Row_AVX2(const uint16_t* src_r,
+                       const uint16_t* src_g,
+                       const uint16_t* src_b,
+                       uint16_t* dst_ar64,
+                       int depth,
+                       int width);
+void MergeXRGB16To8Row_AVX2(const uint16_t* src_r,
+                            const uint16_t* src_g,
+                            const uint16_t* src_b,
+                            uint8_t* dst_argb,
+                            int depth,
+                            int width);
+void MergeXR30Row_NEON(const uint16_t* src_r,
+                       const uint16_t* src_g,
+                       const uint16_t* src_b,
+                       uint8_t* dst_ar30,
+                       int depth,
+                       int width);
+void MergeXR30Row_10_NEON(const uint16_t* src_r,
+                          const uint16_t* src_g,
+                          const uint16_t* src_b,
+                          uint8_t* dst_ar30,
+                          int /* depth */,
+                          int width);
+void MergeAR64Row_NEON(const uint16_t* src_r,
+                       const uint16_t* src_g,
+                       const uint16_t* src_b,
+                       const uint16_t* src_a,
+                       uint16_t* dst_ar64,
+                       int depth,
+                       int width);
+void MergeARGB16To8Row_NEON(const uint16_t* src_r,
+                            const uint16_t* src_g,
+                            const uint16_t* src_b,
+                            const uint16_t* src_a,
+                            uint8_t* dst_argb,
+                            int depth,
+                            int width);
+void MergeXR64Row_NEON(const uint16_t* src_r,
+                       const uint16_t* src_g,
+                       const uint16_t* src_b,
+                       uint16_t* dst_ar64,
+                       int depth,
+                       int width);
+void MergeXRGB16To8Row_NEON(const uint16_t* src_r,
+                            const uint16_t* src_g,
+                            const uint16_t* src_b,
+                            uint8_t* dst_argb,
+                            int depth,
+                            int width);
+void MergeXR30Row_Any_AVX2(const uint16_t* r_buf,
+                           const uint16_t* g_buf,
+                           const uint16_t* b_buf,
+                           uint8_t* dst_ptr,
+                           int depth,
+                           int width);
+void MergeAR64Row_Any_AVX2(const uint16_t* r_buf,
+                           const uint16_t* g_buf,
+                           const uint16_t* b_buf,
+                           const uint16_t* a_buf,
+                           uint16_t* dst_ptr,
+                           int depth,
+                           int width);
+void MergeXR64Row_Any_AVX2(const uint16_t* r_buf,
+                           const uint16_t* g_buf,
+                           const uint16_t* b_buf,
+                           uint16_t* dst_ptr,
+                           int depth,
+                           int width);
+void MergeARGB16To8Row_Any_AVX2(const uint16_t* r_buf,
+                                const uint16_t* g_buf,
+                                const uint16_t* b_buf,
+                                const uint16_t* a_buf,
+                                uint8_t* dst_ptr,
+                                int depth,
+                                int width);
+void MergeXRGB16To8Row_Any_AVX2(const uint16_t* r_buf,
+                                const uint16_t* g_buf,
+                                const uint16_t* b_buf,
+                                uint8_t* dst_ptr,
+                                int depth,
+                                int width);
+void MergeXR30Row_Any_NEON(const uint16_t* r_buf,
+                           const uint16_t* g_buf,
+                           const uint16_t* b_buf,
+                           uint8_t* dst_ptr,
+                           int depth,
+                           int width);
+void MergeXR30Row_10_Any_NEON(const uint16_t* r_buf,
+                              const uint16_t* g_buf,
+                              const uint16_t* b_buf,
+                              uint8_t* dst_ptr,
+                              int depth,
+                              int width);
+void MergeAR64Row_Any_NEON(const uint16_t* r_buf,
+                           const uint16_t* g_buf,
+                           const uint16_t* b_buf,
+                           const uint16_t* a_buf,
+                           uint16_t* dst_ptr,
+                           int depth,
+                           int width);
+void MergeARGB16To8Row_Any_NEON(const uint16_t* r_buf,
+                                const uint16_t* g_buf,
+                                const uint16_t* b_buf,
+                                const uint16_t* a_buf,
+                                uint8_t* dst_ptr,
+                                int depth,
+                                int width);
+void MergeXR64Row_Any_NEON(const uint16_t* r_buf,
+                           const uint16_t* g_buf,
+                           const uint16_t* b_buf,
+                           uint16_t* dst_ptr,
+                           int depth,
+                           int width);
+void MergeXRGB16To8Row_Any_NEON(const uint16_t* r_buf,
+                                const uint16_t* g_buf,
+                                const uint16_t* b_buf,
+                                uint8_t* dst_ptr,
+                                int depth,
+                                int width);
+
+void MergeUVRow_16_C(const uint16_t* src_u,
+                     const uint16_t* src_v,
+                     uint16_t* dst_uv,
+                     int depth,
+                     int width);
+void MergeUVRow_16_AVX2(const uint16_t* src_u,
+                        const uint16_t* src_v,
+                        uint16_t* dst_uv,
+                        int depth,
+                        int width);
+void MergeUVRow_16_Any_AVX2(const uint16_t* src_u,
+                            const uint16_t* src_v,
+                            uint16_t* dst_uv,
+                            int depth,
+                            int width);
+void MergeUVRow_16_NEON(const uint16_t* src_u,
+                        const uint16_t* src_v,
+                        uint16_t* dst_uv,
+                        int depth,
+                        int width);
+void MergeUVRow_16_Any_NEON(const uint16_t* src_u,
+                            const uint16_t* src_v,
+                            uint16_t* dst_uv,
+                            int depth,
+                            int width);
+
+void SplitUVRow_16_C(const uint16_t* src_uv,
+                     uint16_t* dst_u,
+                     uint16_t* dst_v,
+                     int depth,
+                     int width);
+void SplitUVRow_16_AVX2(const uint16_t* src_uv,
+                        uint16_t* dst_u,
+                        uint16_t* dst_v,
+                        int depth,
+                        int width);
+void SplitUVRow_16_Any_AVX2(const uint16_t* src_uv,
+                            uint16_t* dst_u,
+                            uint16_t* dst_v,
+                            int depth,
+                            int width);
+void SplitUVRow_16_NEON(const uint16_t* src_uv,
+                        uint16_t* dst_u,
+                        uint16_t* dst_v,
+                        int depth,
+                        int width);
+void SplitUVRow_16_Any_NEON(const uint16_t* src_uv,
+                            uint16_t* dst_u,
+                            uint16_t* dst_v,
+                            int depth,
+                            int width);
+
+void MultiplyRow_16_C(const uint16_t* src_y,
+                      uint16_t* dst_y,
+                      int scale,
+                      int width);
+void MultiplyRow_16_AVX2(const uint16_t* src_y,
+                         uint16_t* dst_y,
+                         int scale,
+                         int width);
+void MultiplyRow_16_Any_AVX2(const uint16_t* src_ptr,
+                             uint16_t* dst_ptr,
+                             int scale,
+                             int width);
+void MultiplyRow_16_NEON(const uint16_t* src_y,
+                         uint16_t* dst_y,
+                         int scale,
+                         int width);
+void MultiplyRow_16_Any_NEON(const uint16_t* src_ptr,
+                             uint16_t* dst_ptr,
+                             int scale,
+                             int width);
+
+void DivideRow_16_C(const uint16_t* src_y,
+                    uint16_t* dst_y,
+                    int scale,
+                    int width);
+void DivideRow_16_AVX2(const uint16_t* src_y,
+                       uint16_t* dst_y,
+                       int scale,
+                       int width);
+void DivideRow_16_Any_AVX2(const uint16_t* src_ptr,
+                           uint16_t* dst_ptr,
+                           int scale,
+                           int width);
+void DivideRow_16_NEON(const uint16_t* src_y,
+                       uint16_t* dst_y,
+                       int scale,
+                       int width);
+void DivideRow_16_Any_NEON(const uint16_t* src_ptr,
+                           uint16_t* dst_ptr,
+                           int scale,
+                           int width);
+
+void Convert8To16Row_C(const uint8_t* src_y,
+                       uint16_t* dst_y,
+                       int scale,
+                       int width);
+void Convert8To16Row_SSE2(const uint8_t* src_y,
+                          uint16_t* dst_y,
+                          int scale,
+                          int width);
+void Convert8To16Row_AVX2(const uint8_t* src_y,
+                          uint16_t* dst_y,
+                          int scale,
+                          int width);
+void Convert8To16Row_Any_SSE2(const uint8_t* src_ptr,
+                              uint16_t* dst_ptr,
+                              int scale,
+                              int width);
+void Convert8To16Row_Any_AVX2(const uint8_t* src_ptr,
+                              uint16_t* dst_ptr,
+                              int scale,
+                              int width);
+
+void Convert16To8Row_C(const uint16_t* src_y,
+                       uint8_t* dst_y,
+                       int scale,
+                       int width);
+void Convert16To8Row_SSSE3(const uint16_t* src_y,
+                           uint8_t* dst_y,
+                           int scale,
+                           int width);
+void Convert16To8Row_AVX2(const uint16_t* src_y,
+                          uint8_t* dst_y,
+                          int scale,
+                          int width);
+void Convert16To8Row_Any_SSSE3(const uint16_t* src_ptr,
+                               uint8_t* dst_ptr,
+                               int scale,
+                               int width);
+void Convert16To8Row_Any_AVX2(const uint16_t* src_ptr,
+                              uint8_t* dst_ptr,
+                              int scale,
+                              int width);
+void Convert16To8Row_NEON(const uint16_t* src_y,
+                          uint8_t* dst_y,
+                          int scale,
+                          int width);
+void Convert16To8Row_Any_NEON(const uint16_t* src_y,
+                              uint8_t* dst_y,
+                              int scale,
+                              int width);
+
+void CopyRow_SSE2(const uint8_t* src, uint8_t* dst, int width);
+void CopyRow_AVX(const uint8_t* src, uint8_t* dst, int width);
+void CopyRow_ERMS(const uint8_t* src, uint8_t* dst, int width);
+void CopyRow_NEON(const uint8_t* src, uint8_t* dst, int width);
+void CopyRow_MIPS(const uint8_t* src, uint8_t* dst, int count);
+void CopyRow_C(const uint8_t* src, uint8_t* dst, int count);
+void CopyRow_Any_SSE2(const uint8_t* src_ptr, uint8_t* dst_ptr, int width);
+void CopyRow_Any_AVX(const uint8_t* src_ptr, uint8_t* dst_ptr, int width);
+void CopyRow_Any_NEON(const uint8_t* src_ptr, uint8_t* dst_ptr, int width);
+
+void CopyRow_16_C(const uint16_t* src, uint16_t* dst, int count);
+
+void ARGBCopyAlphaRow_C(const uint8_t* src, uint8_t* dst, int width);
+void ARGBCopyAlphaRow_SSE2(const uint8_t* src, uint8_t* dst, int width);
+void ARGBCopyAlphaRow_AVX2(const uint8_t* src, uint8_t* dst, int width);
+void ARGBCopyAlphaRow_Any_SSE2(const uint8_t* src_ptr,
+                               uint8_t* dst_ptr,
+                               int width);
+void ARGBCopyAlphaRow_Any_AVX2(const uint8_t* src_ptr,
+                               uint8_t* dst_ptr,
+                               int width);
+
+void ARGBExtractAlphaRow_C(const uint8_t* src_argb, uint8_t* dst_a, int width);
+void ARGBExtractAlphaRow_SSE2(const uint8_t* src_argb,
+                              uint8_t* dst_a,
+                              int width);
+void ARGBExtractAlphaRow_AVX2(const uint8_t* src_argb,
+                              uint8_t* dst_a,
+                              int width);
+void ARGBExtractAlphaRow_NEON(const uint8_t* src_argb,
+                              uint8_t* dst_a,
+                              int width);
+void ARGBExtractAlphaRow_MSA(const uint8_t* src_argb,
+                             uint8_t* dst_a,
+                             int width);
+void ARGBExtractAlphaRow_LSX(const uint8_t* src_argb,
+                             uint8_t* dst_a,
+                             int width);
+void ARGBExtractAlphaRow_Any_SSE2(const uint8_t* src_ptr,
+                                  uint8_t* dst_ptr,
+                                  int width);
+void ARGBExtractAlphaRow_Any_AVX2(const uint8_t* src_ptr,
+                                  uint8_t* dst_ptr,
+                                  int width);
+void ARGBExtractAlphaRow_Any_NEON(const uint8_t* src_ptr,
+                                  uint8_t* dst_ptr,
+                                  int width);
+void ARGBExtractAlphaRow_Any_MSA(const uint8_t* src_ptr,
+                                 uint8_t* dst_ptr,
+                                 int width);
+void ARGBExtractAlphaRow_Any_LSX(const uint8_t* src_ptr,
+                                 uint8_t* dst_ptr,
+                                 int width);
+
+void ARGBCopyYToAlphaRow_C(const uint8_t* src, uint8_t* dst, int width);
+void ARGBCopyYToAlphaRow_SSE2(const uint8_t* src, uint8_t* dst, int width);
+void ARGBCopyYToAlphaRow_AVX2(const uint8_t* src, uint8_t* dst, int width);
+void ARGBCopyYToAlphaRow_Any_SSE2(const uint8_t* src_ptr,
+                                  uint8_t* dst_ptr,
+                                  int width);
+void ARGBCopyYToAlphaRow_Any_AVX2(const uint8_t* src_ptr,
+                                  uint8_t* dst_ptr,
+                                  int width);
+
+void SetRow_C(uint8_t* dst, uint8_t v8, int width);
+void SetRow_MSA(uint8_t* dst, uint8_t v8, int width);
+void SetRow_X86(uint8_t* dst, uint8_t v8, int width);
+void SetRow_ERMS(uint8_t* dst, uint8_t v8, int width);
+void SetRow_NEON(uint8_t* dst, uint8_t v8, int width);
+void SetRow_LSX(uint8_t* dst, uint8_t v8, int width);
+void SetRow_Any_X86(uint8_t* dst_ptr, uint8_t v32, int width);
+void SetRow_Any_NEON(uint8_t* dst_ptr, uint8_t v32, int width);
+void SetRow_Any_LSX(uint8_t* dst_ptr, uint8_t v32, int width);
+
+void ARGBSetRow_C(uint8_t* dst_argb, uint32_t v32, int width);
+void ARGBSetRow_X86(uint8_t* dst_argb, uint32_t v32, int width);
+void ARGBSetRow_NEON(uint8_t* dst, uint32_t v32, int width);
+void ARGBSetRow_Any_NEON(uint8_t* dst_ptr, uint32_t v32, int width);
+void ARGBSetRow_MSA(uint8_t* dst_argb, uint32_t v32, int width);
+void ARGBSetRow_Any_MSA(uint8_t* dst_ptr, uint32_t v32, int width);
+void ARGBSetRow_LSX(uint8_t* dst_argb, uint32_t v32, int width);
+void ARGBSetRow_Any_LSX(uint8_t* dst_ptr, uint32_t v32, int width);
+
+// ARGBShufflers for BGRAToARGB etc.
+void ARGBShuffleRow_C(const uint8_t* src_argb,
+                      uint8_t* dst_argb,
+                      const uint8_t* shuffler,
+                      int width);
+void ARGBShuffleRow_SSSE3(const uint8_t* src_argb,
+                          uint8_t* dst_argb,
+                          const uint8_t* shuffler,
+                          int width);
+void ARGBShuffleRow_AVX2(const uint8_t* src_argb,
+                         uint8_t* dst_argb,
+                         const uint8_t* shuffler,
+                         int width);
+void ARGBShuffleRow_NEON(const uint8_t* src_argb,
+                         uint8_t* dst_argb,
+                         const uint8_t* shuffler,
+                         int width);
+void ARGBShuffleRow_MSA(const uint8_t* src_argb,
+                        uint8_t* dst_argb,
+                        const uint8_t* shuffler,
+                        int width);
+void ARGBShuffleRow_LASX(const uint8_t* src_argb,
+                         uint8_t* dst_argb,
+                         const uint8_t* shuffler,
+                         int width);
+void ARGBShuffleRow_Any_SSSE3(const uint8_t* src_ptr,
+                              uint8_t* dst_ptr,
+                              const uint8_t* param,
+                              int width);
+void ARGBShuffleRow_Any_AVX2(const uint8_t* src_ptr,
+                             uint8_t* dst_ptr,
+                             const uint8_t* param,
+                             int width);
+void ARGBShuffleRow_Any_NEON(const uint8_t* src_ptr,
+                             uint8_t* dst_ptr,
+                             const uint8_t* param,
+                             int width);
+void ARGBShuffleRow_Any_MSA(const uint8_t* src_ptr,
+                            uint8_t* dst_ptr,
+                            const uint8_t* param,
+                            int width);
+void ARGBShuffleRow_Any_LASX(const uint8_t* src_ptr,
+                             uint8_t* dst_ptr,
+                             const uint8_t* param,
+                             int width);
+
+void RGB24ToARGBRow_SSSE3(const uint8_t* src_rgb24,
+                          uint8_t* dst_argb,
+                          int width);
+void RAWToARGBRow_SSSE3(const uint8_t* src_raw, uint8_t* dst_argb, int width);
+void RAWToRGBARow_SSSE3(const uint8_t* src_raw, uint8_t* dst_rgba, int width);
+void RAWToRGB24Row_SSSE3(const uint8_t* src_raw, uint8_t* dst_rgb24, int width);
+void RGB565ToARGBRow_SSE2(const uint8_t* src, uint8_t* dst, int width);
+void ARGB1555ToARGBRow_SSE2(const uint8_t* src, uint8_t* dst, int width);
+void ARGB4444ToARGBRow_SSE2(const uint8_t* src, uint8_t* dst, int width);
+void RGB565ToARGBRow_AVX2(const uint8_t* src_rgb565,
+                          uint8_t* dst_argb,
+                          int width);
+void ARGB1555ToARGBRow_AVX2(const uint8_t* src_argb1555,
+                            uint8_t* dst_argb,
+                            int width);
+void ARGB4444ToARGBRow_AVX2(const uint8_t* src_argb4444,
+                            uint8_t* dst_argb,
+                            int width);
+
+void RGB24ToARGBRow_NEON(const uint8_t* src_rgb24,
+                         uint8_t* dst_argb,
+                         int width);
+void RGB24ToARGBRow_MSA(const uint8_t* src_rgb24, uint8_t* dst_argb, int width);
+void RGB24ToARGBRow_LSX(const uint8_t* src_rgb24, uint8_t* dst_argb, int width);
+void RGB24ToARGBRow_LASX(const uint8_t* src_rgb24,
+                         uint8_t* dst_argb,
+                         int width);
+void RAWToARGBRow_NEON(const uint8_t* src_raw, uint8_t* dst_argb, int width);
+void RAWToRGBARow_NEON(const uint8_t* src_raw, uint8_t* dst_rgba, int width);
+void RAWToARGBRow_MSA(const uint8_t* src_raw, uint8_t* dst_argb, int width);
+void RAWToARGBRow_LSX(const uint8_t* src_raw, uint8_t* dst_argb, int width);
+void RAWToARGBRow_LASX(const uint8_t* src_raw, uint8_t* dst_argb, int width);
+void RAWToRGB24Row_NEON(const uint8_t* src_raw, uint8_t* dst_rgb24, int width);
+void RAWToRGB24Row_MSA(const uint8_t* src_raw, uint8_t* dst_rgb24, int width);
+void RAWToRGB24Row_LSX(const uint8_t* src_raw, uint8_t* dst_rgb24, int width);
+void RGB565ToARGBRow_NEON(const uint8_t* src_rgb565,
+                          uint8_t* dst_argb,
+                          int width);
+void RGB565ToARGBRow_MSA(const uint8_t* src_rgb565,
+                         uint8_t* dst_argb,
+                         int width);
+void RGB565ToARGBRow_LSX(const uint8_t* src_rgb565,
+                         uint8_t* dst_argb,
+                         int width);
+void RGB565ToARGBRow_LASX(const uint8_t* src_rgb565,
+                          uint8_t* dst_argb,
+                          int width);
+void ARGB1555ToARGBRow_NEON(const uint8_t* src_argb1555,
+                            uint8_t* dst_argb,
+                            int width);
+void ARGB1555ToARGBRow_MSA(const uint8_t* src_argb1555,
+                           uint8_t* dst_argb,
+                           int width);
+void ARGB1555ToARGBRow_LSX(const uint8_t* src_argb1555,
+                           uint8_t* dst_argb,
+                           int width);
+void ARGB1555ToARGBRow_LASX(const uint8_t* src_argb1555,
+                            uint8_t* dst_argb,
+                            int width);
+void ARGB4444ToARGBRow_NEON(const uint8_t* src_argb4444,
+                            uint8_t* dst_argb,
+                            int width);
+void ARGB4444ToARGBRow_MSA(const uint8_t* src_argb4444,
+                           uint8_t* dst_argb,
+                           int width);
+void ARGB4444ToARGBRow_LSX(const uint8_t* src_argb4444,
+                           uint8_t* dst_argb,
+                           int width);
+void ARGB4444ToARGBRow_LASX(const uint8_t* src_argb4444,
+                            uint8_t* dst_argb,
+                            int width);
+void RGB24ToARGBRow_C(const uint8_t* src_rgb24, uint8_t* dst_argb, int width);
+void RAWToARGBRow_C(const uint8_t* src_raw, uint8_t* dst_argb, int width);
+void RAWToRGBARow_C(const uint8_t* src_raw, uint8_t* dst_rgba, int width);
+void RAWToRGB24Row_C(const uint8_t* src_raw, uint8_t* dst_rgb24, int width);
+void RGB565ToARGBRow_C(const uint8_t* src_rgb565, uint8_t* dst_argb, int width);
+void ARGB1555ToARGBRow_C(const uint8_t* src_argb1555,
+                         uint8_t* dst_argb,
+                         int width);
+void ARGB4444ToARGBRow_C(const uint8_t* src_argb4444,
+                         uint8_t* dst_argb,
+                         int width);
+void AR30ToARGBRow_C(const uint8_t* src_ar30, uint8_t* dst_argb, int width);
+void AR30ToABGRRow_C(const uint8_t* src_ar30, uint8_t* dst_abgr, int width);
+void ARGBToAR30Row_C(const uint8_t* src_argb, uint8_t* dst_ar30, int width);
+void AR30ToAB30Row_C(const uint8_t* src_ar30, uint8_t* dst_ab30, int width);
+
+void RGB24ToARGBRow_Any_SSSE3(const uint8_t* src_ptr,
+                              uint8_t* dst_ptr,
+                              int width);
+void RAWToARGBRow_Any_SSSE3(const uint8_t* src_ptr,
+                            uint8_t* dst_ptr,
+                            int width);
+void RAWToRGBARow_Any_SSSE3(const uint8_t* src_ptr,
+                            uint8_t* dst_ptr,
+                            int width);
+void RAWToRGB24Row_Any_SSSE3(const uint8_t* src_ptr,
+                             uint8_t* dst_ptr,
+                             int width);
+
+void RGB565ToARGBRow_Any_SSE2(const uint8_t* src_ptr,
+                              uint8_t* dst_ptr,
+                              int width);
+void ARGB1555ToARGBRow_Any_SSE2(const uint8_t* src_ptr,
+                                uint8_t* dst_ptr,
+                                int width);
+void ARGB4444ToARGBRow_Any_SSE2(const uint8_t* src_ptr,
+                                uint8_t* dst_ptr,
+                                int width);
+void RGB565ToARGBRow_Any_AVX2(const uint8_t* src_ptr,
+                              uint8_t* dst_ptr,
+                              int width);
+void ARGB1555ToARGBRow_Any_AVX2(const uint8_t* src_ptr,
+                                uint8_t* dst_ptr,
+                                int width);
+void ARGB4444ToARGBRow_Any_AVX2(const uint8_t* src_ptr,
+                                uint8_t* dst_ptr,
+                                int width);
+
+void RGB24ToARGBRow_Any_NEON(const uint8_t* src_ptr,
+                             uint8_t* dst_ptr,
+                             int width);
+void RGB24ToARGBRow_Any_MSA(const uint8_t* src_ptr,
+                            uint8_t* dst_ptr,
+                            int width);
+void RGB24ToARGBRow_Any_LSX(const uint8_t* src_ptr,
+                            uint8_t* dst_ptr,
+                            int width);
+void RGB24ToARGBRow_Any_LASX(const uint8_t* src_ptr,
+                             uint8_t* dst_ptr,
+                             int width);
+void RAWToARGBRow_Any_NEON(const uint8_t* src_ptr, uint8_t* dst_ptr, int width);
+void RAWToRGBARow_Any_NEON(const uint8_t* src_ptr, uint8_t* dst_ptr, int width);
+void RAWToARGBRow_Any_MSA(const uint8_t* src_ptr, uint8_t* dst_ptr, int width);
+void RAWToARGBRow_Any_LSX(const uint8_t* src_ptr, uint8_t* dst_ptr, int width);
+void RAWToARGBRow_Any_LASX(const uint8_t* src_ptr, uint8_t* dst_ptr, int width);
+void RAWToRGB24Row_Any_NEON(const uint8_t* src_ptr,
+                            uint8_t* dst_ptr,
+                            int width);
+void RAWToRGB24Row_Any_MSA(const uint8_t* src_ptr, uint8_t* dst_ptr, int width);
+void RAWToRGB24Row_Any_LSX(const uint8_t* src_ptr, uint8_t* dst_ptr, int width);
+void RGB565ToARGBRow_Any_NEON(const uint8_t* src_ptr,
+                              uint8_t* dst_ptr,
+                              int width);
+void RGB565ToARGBRow_Any_MSA(const uint8_t* src_ptr,
+                             uint8_t* dst_ptr,
+                             int width);
+void RGB565ToARGBRow_Any_LSX(const uint8_t* src_ptr,
+                             uint8_t* dst_ptr,
+                             int width);
+void RGB565ToARGBRow_Any_LASX(const uint8_t* src_ptr,
+                              uint8_t* dst_ptr,
+                              int width);
+void ARGB1555ToARGBRow_Any_NEON(const uint8_t* src_ptr,
+                                uint8_t* dst_ptr,
+                                int width);
+void ARGB1555ToARGBRow_Any_MSA(const uint8_t* src_ptr,
+                               uint8_t* dst_ptr,
+                               int width);
+void ARGB4444ToARGBRow_Any_NEON(const uint8_t* src_ptr,
+                                uint8_t* dst_ptr,
+                                int width);
+void ARGB1555ToARGBRow_Any_LSX(const uint8_t* src_ptr,
+                               uint8_t* dst_ptr,
+                               int width);
+void ARGB1555ToARGBRow_Any_LASX(const uint8_t* src_ptr,
+                                uint8_t* dst_ptr,
+                                int width);
+
+void ARGB4444ToARGBRow_Any_MSA(const uint8_t* src_ptr,
+                               uint8_t* dst_ptr,
+                               int width);
+void ARGB4444ToARGBRow_Any_LSX(const uint8_t* src_ptr,
+                               uint8_t* dst_ptr,
+                               int width);
+void ARGB4444ToARGBRow_Any_LASX(const uint8_t* src_ptr,
+                                uint8_t* dst_ptr,
+                                int width);
+
+void ARGBToRGB24Row_SSSE3(const uint8_t* src, uint8_t* dst, int width);
+void ARGBToRAWRow_SSSE3(const uint8_t* src, uint8_t* dst, int width);
+void ARGBToRGB565Row_SSE2(const uint8_t* src, uint8_t* dst, int width);
+void ARGBToARGB1555Row_SSE2(const uint8_t* src, uint8_t* dst, int width);
+void ARGBToARGB4444Row_SSE2(const uint8_t* src, uint8_t* dst, int width);
+void ABGRToAR30Row_SSSE3(const uint8_t* src, uint8_t* dst, int width);
+void ARGBToAR30Row_SSSE3(const uint8_t* src, uint8_t* dst, int width);
+
+void ARGBToRAWRow_AVX2(const uint8_t* src, uint8_t* dst, int width);
+void ARGBToRGB24Row_AVX2(const uint8_t* src, uint8_t* dst, int width);
+
+void ARGBToRGB24Row_AVX512VBMI(const uint8_t* src, uint8_t* dst, int width);
+
+void ARGBToRGB565DitherRow_C(const uint8_t* src_argb,
+                             uint8_t* dst_rgb,
+                             const uint32_t dither4,
+                             int width);
+void ARGBToRGB565DitherRow_SSE2(const uint8_t* src,
+                                uint8_t* dst,
+                                const uint32_t dither4,
+                                int width);
+void ARGBToRGB565DitherRow_AVX2(const uint8_t* src,
+                                uint8_t* dst,
+                                const uint32_t dither4,
+                                int width);
+
+void ARGBToRGB565Row_AVX2(const uint8_t* src_argb, uint8_t* dst_rgb, int width);
+void ARGBToARGB1555Row_AVX2(const uint8_t* src_argb,
+                            uint8_t* dst_rgb,
+                            int width);
+void ARGBToARGB4444Row_AVX2(const uint8_t* src_argb,
+                            uint8_t* dst_rgb,
+                            int width);
+void ABGRToAR30Row_AVX2(const uint8_t* src, uint8_t* dst, int width);
+void ARGBToAR30Row_AVX2(const uint8_t* src, uint8_t* dst, int width);
+
+void ARGBToRGB24Row_NEON(const uint8_t* src_argb,
+                         uint8_t* dst_rgb24,
+                         int width);
+void ARGBToRAWRow_NEON(const uint8_t* src_argb, uint8_t* dst_raw, int width);
+void ARGBToRGB565Row_NEON(const uint8_t* src_argb,
+                          uint8_t* dst_rgb565,
+                          int width);
+void ARGBToARGB1555Row_NEON(const uint8_t* src_argb,
+                            uint8_t* dst_argb1555,
+                            int width);
+void ARGBToARGB4444Row_NEON(const uint8_t* src_argb,
+                            uint8_t* dst_argb4444,
+                            int width);
+void ARGBToRGB565DitherRow_NEON(const uint8_t* src_argb,
+                                uint8_t* dst_rgb,
+                                const uint32_t dither4,
+                                int width);
+void ARGBToRGB24Row_MSA(const uint8_t* src_argb, uint8_t* dst_rgb, int width);
+void ARGBToRAWRow_MSA(const uint8_t* src_argb, uint8_t* dst_rgb, int width);
+void ARGBToRGB565Row_MSA(const uint8_t* src_argb, uint8_t* dst_rgb, int width);
+void ARGBToARGB1555Row_MSA(const uint8_t* src_argb,
+                           uint8_t* dst_rgb,
+                           int width);
+void ARGBToARGB4444Row_MSA(const uint8_t* src_argb,
+                           uint8_t* dst_rgb,
+                           int width);
+void ARGBToRGB565DitherRow_MSA(const uint8_t* src_argb,
+                               uint8_t* dst_rgb,
+                               const uint32_t dither4,
+                               int width);
+void ARGBToRGB565DitherRow_LASX(const uint8_t* src_argb,
+                                uint8_t* dst_rgb,
+                                const uint32_t dither4,
+                                int width);
+
+void ARGBToRGB24Row_LASX(const uint8_t* src_argb, uint8_t* dst_rgb, int width);
+void ARGBToRAWRow_LASX(const uint8_t* src_argb, uint8_t* dst_rgb, int width);
+void ARGBToRGB565Row_LASX(const uint8_t* src_argb, uint8_t* dst_rgb, int width);
+void ARGBToARGB1555Row_LASX(const uint8_t* src_argb,
+                            uint8_t* dst_rgb,
+                            int width);
+void ARGBToARGB4444Row_LASX(const uint8_t* src_argb,
+                            uint8_t* dst_rgb,
+                            int width);
+
+void ARGBToRGBARow_C(const uint8_t* src_argb, uint8_t* dst_rgb, int width);
+void ARGBToRGB24Row_C(const uint8_t* src_argb, uint8_t* dst_rgb, int width);
+void ARGBToRAWRow_C(const uint8_t* src_argb, uint8_t* dst_rgb, int width);
+void ARGBToRGB565Row_C(const uint8_t* src_argb, uint8_t* dst_rgb, int width);
+void ARGBToARGB1555Row_C(const uint8_t* src_argb, uint8_t* dst_rgb, int width);
+void ARGBToARGB4444Row_C(const uint8_t* src_argb, uint8_t* dst_rgb, int width);
+void ABGRToAR30Row_C(const uint8_t* src_abgr, uint8_t* dst_ar30, int width);
+void ARGBToAR30Row_C(const uint8_t* src_argb, uint8_t* dst_ar30, int width);
+
+void ARGBToAR64Row_C(const uint8_t* src_argb, uint16_t* dst_ar64, int width);
+void ARGBToAB64Row_C(const uint8_t* src_argb, uint16_t* dst_ab64, int width);
+void AR64ToARGBRow_C(const uint16_t* src_ar64, uint8_t* dst_argb, int width);
+void AB64ToARGBRow_C(const uint16_t* src_ab64, uint8_t* dst_argb, int width);
+void AR64ShuffleRow_C(const uint8_t* src_ar64,
+                      uint8_t* dst_ar64,
+                      const uint8_t* shuffler,
+                      int width);
+void ARGBToAR64Row_SSSE3(const uint8_t* src_argb,
+                         uint16_t* dst_ar64,
+                         int width);
+void ARGBToAB64Row_SSSE3(const uint8_t* src_argb,
+                         uint16_t* dst_ab64,
+                         int width);
+void AR64ToARGBRow_SSSE3(const uint16_t* src_ar64,
+                         uint8_t* dst_argb,
+                         int width);
+void AB64ToARGBRow_SSSE3(const uint16_t* src_ab64,
+                         uint8_t* dst_argb,
+                         int width);
+void ARGBToAR64Row_AVX2(const uint8_t* src_argb, uint16_t* dst_ar64, int width);
+void ARGBToAB64Row_AVX2(const uint8_t* src_argb, uint16_t* dst_ab64, int width);
+void AR64ToARGBRow_AVX2(const uint16_t* src_ar64, uint8_t* dst_argb, int width);
+void AB64ToARGBRow_AVX2(const uint16_t* src_ab64, uint8_t* dst_argb, int width);
+void ARGBToAR64Row_NEON(const uint8_t* src_argb, uint16_t* dst_ar64, int width);
+void ARGBToAB64Row_NEON(const uint8_t* src_argb, uint16_t* dst_ab64, int width);
+void AR64ToARGBRow_NEON(const uint16_t* src_ar64, uint8_t* dst_argb, int width);
+void AB64ToARGBRow_NEON(const uint16_t* src_ab64, uint8_t* dst_argb, int width);
+void ARGBToAR64Row_Any_SSSE3(const uint8_t* src_ptr,
+                             uint16_t* dst_ptr,
+                             int width);
+void ARGBToAB64Row_Any_SSSE3(const uint8_t* src_ptr,
+                             uint16_t* dst_ptr,
+                             int width);
+void AR64ToARGBRow_Any_SSSE3(const uint16_t* src_ptr,
+                             uint8_t* dst_ptr,
+                             int width);
+void AB64ToARGBRow_Any_SSSE3(const uint16_t* src_ptr,
+                             uint8_t* dst_ptr,
+                             int width);
+void ARGBToAR64Row_Any_AVX2(const uint8_t* src_ptr,
+                            uint16_t* dst_ptr,
+                            int width);
+void ARGBToAB64Row_Any_AVX2(const uint8_t* src_ptr,
+                            uint16_t* dst_ptr,
+                            int width);
+void AR64ToARGBRow_Any_AVX2(const uint16_t* src_ptr,
+                            uint8_t* dst_ptr,
+                            int width);
+void AB64ToARGBRow_Any_AVX2(const uint16_t* src_ptr,
+                            uint8_t* dst_ptr,
+                            int width);
+void ARGBToAR64Row_Any_NEON(const uint8_t* src_ptr,
+                            uint16_t* dst_ptr,
+                            int width);
+void ARGBToAB64Row_Any_NEON(const uint8_t* src_ptr,
+                            uint16_t* dst_ptr,
+                            int width);
+void AR64ToARGBRow_Any_NEON(const uint16_t* src_ptr,
+                            uint8_t* dst_ptr,
+                            int width);
+void AB64ToARGBRow_Any_NEON(const uint16_t* src_ptr,
+                            uint8_t* dst_ptr,
+                            int width);
+
+void J400ToARGBRow_SSE2(const uint8_t* src_y, uint8_t* dst_argb, int width);
+void J400ToARGBRow_AVX2(const uint8_t* src_y, uint8_t* dst_argb, int width);
+void J400ToARGBRow_NEON(const uint8_t* src_y, uint8_t* dst_argb, int width);
+void J400ToARGBRow_MSA(const uint8_t* src_y, uint8_t* dst_argb, int width);
+void J400ToARGBRow_LSX(const uint8_t* src_y, uint8_t* dst_argb, int width);
+void J400ToARGBRow_C(const uint8_t* src_y, uint8_t* dst_argb, int width);
+void J400ToARGBRow_Any_SSE2(const uint8_t* src_ptr,
+                            uint8_t* dst_ptr,
+                            int width);
+void J400ToARGBRow_Any_AVX2(const uint8_t* src_ptr,
+                            uint8_t* dst_ptr,
+                            int width);
+void J400ToARGBRow_Any_NEON(const uint8_t* src_ptr,
+                            uint8_t* dst_ptr,
+                            int width);
+void J400ToARGBRow_Any_MSA(const uint8_t* src_ptr, uint8_t* dst_ptr, int width);
+void J400ToARGBRow_Any_LSX(const uint8_t* src_ptr, uint8_t* dst_ptr, int width);
+
+void I444ToARGBRow_C(const uint8_t* src_y,
+                     const uint8_t* src_u,
+                     const uint8_t* src_v,
+                     uint8_t* rgb_buf,
+                     const struct YuvConstants* yuvconstants,
+                     int width);
+void I422ToARGBRow_C(const uint8_t* src_y,
+                     const uint8_t* src_u,
+                     const uint8_t* src_v,
+                     uint8_t* rgb_buf,
+                     const struct YuvConstants* yuvconstants,
+                     int width);
+void I422ToAR30Row_C(const uint8_t* src_y,
+                     const uint8_t* src_u,
+                     const uint8_t* src_v,
+                     uint8_t* rgb_buf,
+                     const struct YuvConstants* yuvconstants,
+                     int width);
+void I210ToAR30Row_C(const uint16_t* src_y,
+                     const uint16_t* src_u,
+                     const uint16_t* src_v,
+                     uint8_t* rgb_buf,
+                     const struct YuvConstants* yuvconstants,
+                     int width);
+void I210ToARGBRow_C(const uint16_t* src_y,
+                     const uint16_t* src_u,
+                     const uint16_t* src_v,
+                     uint8_t* rgb_buf,
+                     const struct YuvConstants* yuvconstants,
+                     int width);
+void I212ToAR30Row_C(const uint16_t* src_y,
+                     const uint16_t* src_u,
+                     const uint16_t* src_v,
+                     uint8_t* rgb_buf,
+                     const struct YuvConstants* yuvconstants,
+                     int width);
+void I212ToARGBRow_C(const uint16_t* src_y,
+                     const uint16_t* src_u,
+                     const uint16_t* src_v,
+                     uint8_t* rgb_buf,
+                     const struct YuvConstants* yuvconstants,
+                     int width);
+void I410ToAR30Row_C(const uint16_t* src_y,
+                     const uint16_t* src_u,
+                     const uint16_t* src_v,
+                     uint8_t* rgb_buf,
+                     const struct YuvConstants* yuvconstants,
+                     int width);
+void I410ToARGBRow_C(const uint16_t* src_y,
+                     const uint16_t* src_u,
+                     const uint16_t* src_v,
+                     uint8_t* rgb_buf,
+                     const struct YuvConstants* yuvconstants,
+                     int width);
+void I210AlphaToARGBRow_C(const uint16_t* src_y,
+                          const uint16_t* src_u,
+                          const uint16_t* src_v,
+                          const uint16_t* src_a,
+                          uint8_t* rgb_buf,
+                          const struct YuvConstants* yuvconstants,
+                          int width);
+void I410AlphaToARGBRow_C(const uint16_t* src_y,
+                          const uint16_t* src_u,
+                          const uint16_t* src_v,
+                          const uint16_t* src_a,
+                          uint8_t* rgb_buf,
+                          const struct YuvConstants* yuvconstants,
+                          int width);
+void I444AlphaToARGBRow_C(const uint8_t* src_y,
+                          const uint8_t* src_u,
+                          const uint8_t* src_v,
+                          const uint8_t* src_a,
+                          uint8_t* rgb_buf,
+                          const struct YuvConstants* yuvconstants,
+                          int width);
+void I422AlphaToARGBRow_C(const uint8_t* src_y,
+                          const uint8_t* src_u,
+                          const uint8_t* src_v,
+                          const uint8_t* src_a,
+                          uint8_t* rgb_buf,
+                          const struct YuvConstants* yuvconstants,
+                          int width);
+void NV12ToARGBRow_C(const uint8_t* src_y,
+                     const uint8_t* src_uv,
+                     uint8_t* rgb_buf,
+                     const struct YuvConstants* yuvconstants,
+                     int width);
+void NV12ToRGB565Row_C(const uint8_t* src_y,
+                       const uint8_t* src_uv,
+                       uint8_t* dst_rgb565,
+                       const struct YuvConstants* yuvconstants,
+                       int width);
+void NV21ToARGBRow_C(const uint8_t* src_y,
+                     const uint8_t* src_vu,
+                     uint8_t* rgb_buf,
+                     const struct YuvConstants* yuvconstants,
+                     int width);
+void NV12ToRGB24Row_C(const uint8_t* src_y,
+                      const uint8_t* src_uv,
+                      uint8_t* rgb_buf,
+                      const struct YuvConstants* yuvconstants,
+                      int width);
+void NV21ToRGB24Row_C(const uint8_t* src_y,
+                      const uint8_t* src_vu,
+                      uint8_t* rgb_buf,
+                      const struct YuvConstants* yuvconstants,
+                      int width);
+void NV21ToYUV24Row_C(const uint8_t* src_y,
+                      const uint8_t* src_vu,
+                      uint8_t* dst_yuv24,
+                      int width);
+void YUY2ToARGBRow_C(const uint8_t* src_yuy2,
+                     uint8_t* rgb_buf,
+                     const struct YuvConstants* yuvconstants,
+                     int width);
+void UYVYToARGBRow_C(const uint8_t* src_uyvy,
+                     uint8_t* rgb_buf,
+                     const struct YuvConstants* yuvconstants,
+                     int width);
+void P210ToARGBRow_C(const uint16_t* src_y,
+                     const uint16_t* src_uv,
+                     uint8_t* dst_argb,
+                     const struct YuvConstants* yuvconstants,
+                     int width);
+void P410ToARGBRow_C(const uint16_t* src_y,
+                     const uint16_t* src_uv,
+                     uint8_t* dst_argb,
+                     const struct YuvConstants* yuvconstants,
+                     int width);
+void P210ToAR30Row_C(const uint16_t* src_y,
+                     const uint16_t* src_uv,
+                     uint8_t* dst_ar30,
+                     const struct YuvConstants* yuvconstants,
+                     int width);
+void P410ToAR30Row_C(const uint16_t* src_y,
+                     const uint16_t* src_uv,
+                     uint8_t* dst_ar30,
+                     const struct YuvConstants* yuvconstants,
+                     int width);
+
+void I422ToRGBARow_C(const uint8_t* src_y,
+                     const uint8_t* src_u,
+                     const uint8_t* src_v,
+                     uint8_t* rgb_buf,
+                     const struct YuvConstants* yuvconstants,
+                     int width);
+void I422ToRGB24Row_C(const uint8_t* src_y,
+                      const uint8_t* src_u,
+                      const uint8_t* src_v,
+                      uint8_t* rgb_buf,
+                      const struct YuvConstants* yuvconstants,
+                      int width);
+void I422ToARGB4444Row_C(const uint8_t* src_y,
+                         const uint8_t* src_u,
+                         const uint8_t* src_v,
+                         uint8_t* dst_argb4444,
+                         const struct YuvConstants* yuvconstants,
+                         int width);
+void I422ToARGB1555Row_C(const uint8_t* src_y,
+                         const uint8_t* src_u,
+                         const uint8_t* src_v,
+                         uint8_t* dst_argb1555,
+                         const struct YuvConstants* yuvconstants,
+                         int width);
+void I422ToRGB565Row_C(const uint8_t* src_y,
+                       const uint8_t* src_u,
+                       const uint8_t* src_v,
+                       uint8_t* dst_rgb565,
+                       const struct YuvConstants* yuvconstants,
+                       int width);
+void I422ToARGBRow_AVX2(const uint8_t* y_buf,
+                        const uint8_t* u_buf,
+                        const uint8_t* v_buf,
+                        uint8_t* dst_argb,
+                        const struct YuvConstants* yuvconstants,
+                        int width);
+void I422ToARGBRow_AVX512BW(const uint8_t* y_buf,
+                            const uint8_t* u_buf,
+                            const uint8_t* v_buf,
+                            uint8_t* dst_argb,
+                            const struct YuvConstants* yuvconstants,
+                            int width);
+void I422ToRGBARow_AVX2(const uint8_t* y_buf,
+                        const uint8_t* u_buf,
+                        const uint8_t* v_buf,
+                        uint8_t* dst_argb,
+                        const struct YuvConstants* yuvconstants,
+                        int width);
+void I444ToARGBRow_SSSE3(const uint8_t* y_buf,
+                         const uint8_t* u_buf,
+                         const uint8_t* v_buf,
+                         uint8_t* dst_argb,
+                         const struct YuvConstants* yuvconstants,
+                         int width);
+void I444ToARGBRow_AVX2(const uint8_t* y_buf,
+                        const uint8_t* u_buf,
+                        const uint8_t* v_buf,
+                        uint8_t* dst_argb,
+                        const struct YuvConstants* yuvconstants,
+                        int width);
+void I422ToARGBRow_SSSE3(const uint8_t* y_buf,
+                         const uint8_t* u_buf,
+                         const uint8_t* v_buf,
+                         uint8_t* dst_argb,
+                         const struct YuvConstants* yuvconstants,
+                         int width);
+
+void I422ToAR30Row_SSSE3(const uint8_t* y_buf,
+                         const uint8_t* u_buf,
+                         const uint8_t* v_buf,
+                         uint8_t* dst_ar30,
+                         const struct YuvConstants* yuvconstants,
+                         int width);
+void I210ToAR30Row_SSSE3(const uint16_t* y_buf,
+                         const uint16_t* u_buf,
+                         const uint16_t* v_buf,
+                         uint8_t* dst_ar30,
+                         const struct YuvConstants* yuvconstants,
+                         int width);
+void I210ToARGBRow_SSSE3(const uint16_t* y_buf,
+                         const uint16_t* u_buf,
+                         const uint16_t* v_buf,
+                         uint8_t* dst_argb,
+                         const struct YuvConstants* yuvconstants,
+                         int width);
+void I212ToAR30Row_SSSE3(const uint16_t* y_buf,
+                         const uint16_t* u_buf,
+                         const uint16_t* v_buf,
+                         uint8_t* dst_ar30,
+                         const struct YuvConstants* yuvconstants,
+                         int width);
+void I212ToARGBRow_SSSE3(const uint16_t* y_buf,
+                         const uint16_t* u_buf,
+                         const uint16_t* v_buf,
+                         uint8_t* dst_argb,
+                         const struct YuvConstants* yuvconstants,
+                         int width);
+void I410ToAR30Row_SSSE3(const uint16_t* y_buf,
+                         const uint16_t* u_buf,
+                         const uint16_t* v_buf,
+                         uint8_t* dst_ar30,
+                         const struct YuvConstants* yuvconstants,
+                         int width);
+void I410ToARGBRow_SSSE3(const uint16_t* y_buf,
+                         const uint16_t* u_buf,
+                         const uint16_t* v_buf,
+                         uint8_t* dst_argb,
+                         const struct YuvConstants* yuvconstants,
+                         int width);
+void I210AlphaToARGBRow_SSSE3(const uint16_t* y_buf,
+                              const uint16_t* u_buf,
+                              const uint16_t* v_buf,
+                              const uint16_t* a_buf,
+                              uint8_t* dst_argb,
+                              const struct YuvConstants* yuvconstants,
+                              int width);
+void I410AlphaToARGBRow_SSSE3(const uint16_t* y_buf,
+                              const uint16_t* u_buf,
+                              const uint16_t* v_buf,
+                              const uint16_t* a_buf,
+                              uint8_t* dst_argb,
+                              const struct YuvConstants* yuvconstants,
+                              int width);
+void I422ToAR30Row_AVX2(const uint8_t* y_buf,
+                        const uint8_t* u_buf,
+                        const uint8_t* v_buf,
+                        uint8_t* dst_ar30,
+                        const struct YuvConstants* yuvconstants,
+                        int width);
+void I210ToARGBRow_AVX2(const uint16_t* y_buf,
+                        const uint16_t* u_buf,
+                        const uint16_t* v_buf,
+                        uint8_t* dst_argb,
+                        const struct YuvConstants* yuvconstants,
+                        int width);
+void I210ToAR30Row_AVX2(const uint16_t* y_buf,
+                        const uint16_t* u_buf,
+                        const uint16_t* v_buf,
+                        uint8_t* dst_ar30,
+                        const struct YuvConstants* yuvconstants,
+                        int width);
+void I212ToARGBRow_AVX2(const uint16_t* y_buf,
+                        const uint16_t* u_buf,
+                        const uint16_t* v_buf,
+                        uint8_t* dst_argb,
+                        const struct YuvConstants* yuvconstants,
+                        int width);
+void I212ToAR30Row_AVX2(const uint16_t* y_buf,
+                        const uint16_t* u_buf,
+                        const uint16_t* v_buf,
+                        uint8_t* dst_ar30,
+                        const struct YuvConstants* yuvconstants,
+                        int width);
+void I410ToAR30Row_AVX2(const uint16_t* y_buf,
+                        const uint16_t* u_buf,
+                        const uint16_t* v_buf,
+                        uint8_t* dst_ar30,
+                        const struct YuvConstants* yuvconstants,
+                        int width);
+void I410ToARGBRow_AVX2(const uint16_t* y_buf,
+                        const uint16_t* u_buf,
+                        const uint16_t* v_buf,
+                        uint8_t* dst_argb,
+                        const struct YuvConstants* yuvconstants,
+                        int width);
+void I210AlphaToARGBRow_AVX2(const uint16_t* y_buf,
+                             const uint16_t* u_buf,
+                             const uint16_t* v_buf,
+                             const uint16_t* a_buf,
+                             uint8_t* dst_argb,
+                             const struct YuvConstants* yuvconstants,
+                             int width);
+void I410AlphaToARGBRow_AVX2(const uint16_t* y_buf,
+                             const uint16_t* u_buf,
+                             const uint16_t* v_buf,
+                             const uint16_t* a_buf,
+                             uint8_t* dst_argb,
+                             const struct YuvConstants* yuvconstants,
+                             int width);
+void I444AlphaToARGBRow_SSSE3(const uint8_t* y_buf,
+                              const uint8_t* u_buf,
+                              const uint8_t* v_buf,
+                              const uint8_t* a_buf,
+                              uint8_t* dst_argb,
+                              const struct YuvConstants* yuvconstants,
+                              int width);
+void I444AlphaToARGBRow_AVX2(const uint8_t* y_buf,
+                             const uint8_t* u_buf,
+                             const uint8_t* v_buf,
+                             const uint8_t* a_buf,
+                             uint8_t* dst_argb,
+                             const struct YuvConstants* yuvconstants,
+                             int width);
+void I422AlphaToARGBRow_SSSE3(const uint8_t* y_buf,
+                              const uint8_t* u_buf,
+                              const uint8_t* v_buf,
+                              const uint8_t* a_buf,
+                              uint8_t* dst_argb,
+                              const struct YuvConstants* yuvconstants,
+                              int width);
+void I422AlphaToARGBRow_AVX2(const uint8_t* y_buf,
+                             const uint8_t* u_buf,
+                             const uint8_t* v_buf,
+                             const uint8_t* a_buf,
+                             uint8_t* dst_argb,
+                             const struct YuvConstants* yuvconstants,
+                             int width);
+void NV12ToARGBRow_SSSE3(const uint8_t* y_buf,
+                         const uint8_t* uv_buf,
+                         uint8_t* dst_argb,
+                         const struct YuvConstants* yuvconstants,
+                         int width);
+void NV12ToARGBRow_AVX2(const uint8_t* y_buf,
+                        const uint8_t* uv_buf,
+                        uint8_t* dst_argb,
+                        const struct YuvConstants* yuvconstants,
+                        int width);
+void NV12ToRGB24Row_SSSE3(const uint8_t* src_y,
+                          const uint8_t* src_uv,
+                          uint8_t* dst_rgb24,
+                          const struct YuvConstants* yuvconstants,
+                          int width);
+void NV21ToRGB24Row_SSSE3(const uint8_t* src_y,
+                          const uint8_t* src_vu,
+                          uint8_t* dst_rgb24,
+                          const struct YuvConstants* yuvconstants,
+                          int width);
+void NV12ToRGB565Row_SSSE3(const uint8_t* src_y,
+                           const uint8_t* src_uv,
+                           uint8_t* dst_rgb565,
+                           const struct YuvConstants* yuvconstants,
+                           int width);
+void NV12ToRGB24Row_AVX2(const uint8_t* src_y,
+                         const uint8_t* src_uv,
+                         uint8_t* dst_rgb24,
+                         const struct YuvConstants* yuvconstants,
+                         int width);
+void NV21ToRGB24Row_AVX2(const uint8_t* src_y,
+                         const uint8_t* src_vu,
+                         uint8_t* dst_rgb24,
+                         const struct YuvConstants* yuvconstants,
+                         int width);
+void NV21ToYUV24Row_SSSE3(const uint8_t* src_y,
+                          const uint8_t* src_vu,
+                          uint8_t* dst_yuv24,
+                          int width);
+void NV21ToYUV24Row_AVX2(const uint8_t* src_y,
+                         const uint8_t* src_vu,
+                         uint8_t* dst_yuv24,
+                         int width);
+void NV12ToRGB565Row_AVX2(const uint8_t* src_y,
+                          const uint8_t* src_uv,
+                          uint8_t* dst_rgb565,
+                          const struct YuvConstants* yuvconstants,
+                          int width);
+void NV21ToARGBRow_SSSE3(const uint8_t* y_buf,
+                         const uint8_t* vu_buf,
+                         uint8_t* dst_argb,
+                         const struct YuvConstants* yuvconstants,
+                         int width);
+void NV21ToARGBRow_AVX2(const uint8_t* y_buf,
+                        const uint8_t* vu_buf,
+                        uint8_t* dst_argb,
+                        const struct YuvConstants* yuvconstants,
+                        int width);
+void YUY2ToARGBRow_SSSE3(const uint8_t* yuy2_buf,
+                         uint8_t* dst_argb,
+                         const struct YuvConstants* yuvconstants,
+                         int width);
+void UYVYToARGBRow_SSSE3(const uint8_t* uyvy_buf,
+                         uint8_t* dst_argb,
+                         const struct YuvConstants* yuvconstants,
+                         int width);
+void YUY2ToARGBRow_AVX2(const uint8_t* yuy2_buf,
+                        uint8_t* dst_argb,
+                        const struct YuvConstants* yuvconstants,
+                        int width);
+void UYVYToARGBRow_AVX2(const uint8_t* uyvy_buf,
+                        uint8_t* dst_argb,
+                        const struct YuvConstants* yuvconstants,
+                        int width);
+
+void P210ToARGBRow_SSSE3(const uint16_t* y_buf,
+                         const uint16_t* uv_buf,
+                         uint8_t* dst_argb,
+                         const struct YuvConstants* yuvconstants,
+                         int width);
+void P410ToARGBRow_SSSE3(const uint16_t* y_buf,
+                         const uint16_t* uv_buf,
+                         uint8_t* dst_argb,
+                         const struct YuvConstants* yuvconstants,
+                         int width);
+void P210ToAR30Row_SSSE3(const uint16_t* y_buf,
+                         const uint16_t* uv_buf,
+                         uint8_t* dst_ar30,
+                         const struct YuvConstants* yuvconstants,
+                         int width);
+void P410ToAR30Row_SSSE3(const uint16_t* y_buf,
+                         const uint16_t* uv_buf,
+                         uint8_t* dst_ar30,
+                         const struct YuvConstants* yuvconstants,
+                         int width);
+void P210ToARGBRow_AVX2(const uint16_t* y_buf,
+                        const uint16_t* uv_buf,
+                        uint8_t* dst_argb,
+                        const struct YuvConstants* yuvconstants,
+                        int width);
+void P410ToARGBRow_AVX2(const uint16_t* y_buf,
+                        const uint16_t* uv_buf,
+                        uint8_t* dst_argb,
+                        const struct YuvConstants* yuvconstants,
+                        int width);
+void P210ToAR30Row_AVX2(const uint16_t* y_buf,
+                        const uint16_t* uv_buf,
+                        uint8_t* dst_ar30,
+                        const struct YuvConstants* yuvconstants,
+                        int width);
+void P410ToAR30Row_AVX2(const uint16_t* y_buf,
+                        const uint16_t* uv_buf,
+                        uint8_t* dst_ar30,
+                        const struct YuvConstants* yuvconstants,
+                        int width);
+
+void I422ToRGBARow_SSSE3(const uint8_t* y_buf,
+                         const uint8_t* u_buf,
+                         const uint8_t* v_buf,
+                         uint8_t* dst_rgba,
+                         const struct YuvConstants* yuvconstants,
+                         int width);
+void I422ToARGB4444Row_SSSE3(const uint8_t* src_y,
+                             const uint8_t* src_u,
+                             const uint8_t* src_v,
+                             uint8_t* dst_argb4444,
+                             const struct YuvConstants* yuvconstants,
+                             int width);
+void I422ToARGB4444Row_AVX2(const uint8_t* src_y,
+                            const uint8_t* src_u,
+                            const uint8_t* src_v,
+                            uint8_t* dst_argb4444,
+                            const struct YuvConstants* yuvconstants,
+                            int width);
+void I422ToARGB1555Row_SSSE3(const uint8_t* src_y,
+                             const uint8_t* src_u,
+                             const uint8_t* src_v,
+                             uint8_t* dst_argb1555,
+                             const struct YuvConstants* yuvconstants,
+                             int width);
+void I422ToARGB1555Row_AVX2(const uint8_t* src_y,
+                            const uint8_t* src_u,
+                            const uint8_t* src_v,
+                            uint8_t* dst_argb1555,
+                            const struct YuvConstants* yuvconstants,
+                            int width);
+void I422ToRGB565Row_SSSE3(const uint8_t* src_y,
+                           const uint8_t* src_u,
+                           const uint8_t* src_v,
+                           uint8_t* dst_rgb565,
+                           const struct YuvConstants* yuvconstants,
+                           int width);
+void I422ToRGB565Row_AVX2(const uint8_t* src_y,
+                          const uint8_t* src_u,
+                          const uint8_t* src_v,
+                          uint8_t* dst_rgb565,
+                          const struct YuvConstants* yuvconstants,
+                          int width);
+void I422ToRGB24Row_SSSE3(const uint8_t* y_buf,
+                          const uint8_t* u_buf,
+                          const uint8_t* v_buf,
+                          uint8_t* dst_rgb24,
+                          const struct YuvConstants* yuvconstants,
+                          int width);
+void I422ToRGB24Row_AVX2(const uint8_t* src_y,
+                         const uint8_t* src_u,
+                         const uint8_t* src_v,
+                         uint8_t* dst_rgb24,
+                         const struct YuvConstants* yuvconstants,
+                         int width);
+void I422ToARGBRow_Any_AVX2(const uint8_t* y_buf,
+                            const uint8_t* u_buf,
+                            const uint8_t* v_buf,
+                            uint8_t* dst_ptr,
+                            const struct YuvConstants* yuvconstants,
+                            int width);
+void I422ToARGBRow_Any_AVX512BW(const uint8_t* y_buf,
+                                const uint8_t* u_buf,
+                                const uint8_t* v_buf,
+                                uint8_t* dst_ptr,
+                                const struct YuvConstants* yuvconstants,
+                                int width);
+void I422ToRGBARow_Any_AVX2(const uint8_t* y_buf,
+                            const uint8_t* u_buf,
+                            const uint8_t* v_buf,
+                            uint8_t* dst_ptr,
+                            const struct YuvConstants* yuvconstants,
+                            int width);
+void I444ToARGBRow_Any_SSSE3(const uint8_t* y_buf,
+                             const uint8_t* u_buf,
+                             const uint8_t* v_buf,
+                             uint8_t* dst_ptr,
+                             const struct YuvConstants* yuvconstants,
+                             int width);
+void I444ToARGBRow_Any_AVX2(const uint8_t* y_buf,
+                            const uint8_t* u_buf,
+                            const uint8_t* v_buf,
+                            uint8_t* dst_ptr,
+                            const struct YuvConstants* yuvconstants,
+                            int width);
+void I422ToARGBRow_Any_SSSE3(const uint8_t* y_buf,
+                             const uint8_t* u_buf,
+                             const uint8_t* v_buf,
+                             uint8_t* dst_ptr,
+                             const struct YuvConstants* yuvconstants,
+                             int width);
+void I422ToAR30Row_Any_SSSE3(const uint8_t* y_buf,
+                             const uint8_t* u_buf,
+                             const uint8_t* v_buf,
+                             uint8_t* dst_ptr,
+                             const struct YuvConstants* yuvconstants,
+                             int width);
+void I210ToAR30Row_Any_SSSE3(const uint16_t* y_buf,
+                             const uint16_t* u_buf,
+                             const uint16_t* v_buf,
+                             uint8_t* dst_ptr,
+                             const struct YuvConstants* yuvconstants,
+                             int width);
+void I210ToARGBRow_Any_SSSE3(const uint16_t* y_buf,
+                             const uint16_t* u_buf,
+                             const uint16_t* v_buf,
+                             uint8_t* dst_ptr,
+                             const struct YuvConstants* yuvconstants,
+                             int width);
+void I212ToAR30Row_Any_SSSE3(const uint16_t* y_buf,
+                             const uint16_t* u_buf,
+                             const uint16_t* v_buf,
+                             uint8_t* dst_ptr,
+                             const struct YuvConstants* yuvconstants,
+                             int width);
+void I212ToARGBRow_Any_SSSE3(const uint16_t* y_buf,
+                             const uint16_t* u_buf,
+                             const uint16_t* v_buf,
+                             uint8_t* dst_ptr,
+                             const struct YuvConstants* yuvconstants,
+                             int width);
+void I410ToAR30Row_Any_SSSE3(const uint16_t* y_buf,
+                             const uint16_t* u_buf,
+                             const uint16_t* v_buf,
+                             uint8_t* dst_ptr,
+                             const struct YuvConstants* yuvconstants,
+                             int width);
+void I410ToARGBRow_Any_SSSE3(const uint16_t* y_buf,
+                             const uint16_t* u_buf,
+                             const uint16_t* v_buf,
+                             uint8_t* dst_ptr,
+                             const struct YuvConstants* yuvconstants,
+                             int width);
+void I210AlphaToARGBRow_Any_SSSE3(const uint16_t* y_buf,
+                                  const uint16_t* u_buf,
+                                  const uint16_t* v_buf,
+                                  const uint16_t* a_buf,
+                                  uint8_t* dst_ptr,
+                                  const struct YuvConstants* yuvconstants,
+                                  int width);
+void I410AlphaToARGBRow_Any_SSSE3(const uint16_t* y_buf,
+                                  const uint16_t* u_buf,
+                                  const uint16_t* v_buf,
+                                  const uint16_t* a_buf,
+                                  uint8_t* dst_ptr,
+                                  const struct YuvConstants* yuvconstants,
+                                  int width);
+void I422ToAR30Row_Any_AVX2(const uint8_t* y_buf,
+                            const uint8_t* u_buf,
+                            const uint8_t* v_buf,
+                            uint8_t* dst_ptr,
+                            const struct YuvConstants* yuvconstants,
+                            int width);
+void I210ToARGBRow_Any_AVX2(const uint16_t* y_buf,
+                            const uint16_t* u_buf,
+                            const uint16_t* v_buf,
+                            uint8_t* dst_ptr,
+                            const struct YuvConstants* yuvconstants,
+                            int width);
+void I210ToAR30Row_Any_AVX2(const uint16_t* y_buf,
+                            const uint16_t* u_buf,
+                            const uint16_t* v_buf,
+                            uint8_t* dst_ptr,
+                            const struct YuvConstants* yuvconstants,
+                            int width);
+void I212ToARGBRow_Any_AVX2(const uint16_t* y_buf,
+                            const uint16_t* u_buf,
+                            const uint16_t* v_buf,
+                            uint8_t* dst_ptr,
+                            const struct YuvConstants* yuvconstants,
+                            int width);
+void I212ToAR30Row_Any_AVX2(const uint16_t* y_buf,
+                            const uint16_t* u_buf,
+                            const uint16_t* v_buf,
+                            uint8_t* dst_ptr,
+                            const struct YuvConstants* yuvconstants,
+                            int width);
+void I410ToAR30Row_Any_AVX2(const uint16_t* y_buf,
+                            const uint16_t* u_buf,
+                            const uint16_t* v_buf,
+                            uint8_t* dst_ptr,
+                            const struct YuvConstants* yuvconstants,
+                            int width);
+void I410ToARGBRow_Any_AVX2(const uint16_t* y_buf,
+                            const uint16_t* u_buf,
+                            const uint16_t* v_buf,
+                            uint8_t* dst_ptr,
+                            const struct YuvConstants* yuvconstants,
+                            int width);
+void I210AlphaToARGBRow_Any_AVX2(const uint16_t* y_buf,
+                                 const uint16_t* u_buf,
+                                 const uint16_t* v_buf,
+                                 const uint16_t* a_buf,
+                                 uint8_t* dst_ptr,
+                                 const struct YuvConstants* yuvconstants,
+                                 int width);
+void I410AlphaToARGBRow_Any_AVX2(const uint16_t* y_buf,
+                                 const uint16_t* u_buf,
+                                 const uint16_t* v_buf,
+                                 const uint16_t* a_buf,
+                                 uint8_t* dst_ptr,
+                                 const struct YuvConstants* yuvconstants,
+                                 int width);
+void I444AlphaToARGBRow_Any_SSSE3(const uint8_t* y_buf,
+                                  const uint8_t* u_buf,
+                                  const uint8_t* v_buf,
+                                  const uint8_t* a_buf,
+                                  uint8_t* dst_ptr,
+                                  const struct YuvConstants* yuvconstants,
+                                  int width);
+void I444AlphaToARGBRow_Any_AVX2(const uint8_t* y_buf,
+                                 const uint8_t* u_buf,
+                                 const uint8_t* v_buf,
+                                 const uint8_t* a_buf,
+                                 uint8_t* dst_ptr,
+                                 const struct YuvConstants* yuvconstants,
+                                 int width);
+void I422AlphaToARGBRow_Any_SSSE3(const uint8_t* y_buf,
+                                  const uint8_t* u_buf,
+                                  const uint8_t* v_buf,
+                                  const uint8_t* a_buf,
+                                  uint8_t* dst_ptr,
+                                  const struct YuvConstants* yuvconstants,
+                                  int width);
+void I422AlphaToARGBRow_Any_AVX2(const uint8_t* y_buf,
+                                 const uint8_t* u_buf,
+                                 const uint8_t* v_buf,
+                                 const uint8_t* a_buf,
+                                 uint8_t* dst_ptr,
+                                 const struct YuvConstants* yuvconstants,
+                                 int width);
+void NV12ToARGBRow_Any_SSSE3(const uint8_t* y_buf,
+                             const uint8_t* uv_buf,
+                             uint8_t* dst_ptr,
+                             const struct YuvConstants* yuvconstants,
+                             int width);
+void NV12ToARGBRow_Any_AVX2(const uint8_t* y_buf,
+                            const uint8_t* uv_buf,
+                            uint8_t* dst_ptr,
+                            const struct YuvConstants* yuvconstants,
+                            int width);
+void NV21ToARGBRow_Any_SSSE3(const uint8_t* y_buf,
+                             const uint8_t* uv_buf,
+                             uint8_t* dst_ptr,
+                             const struct YuvConstants* yuvconstants,
+                             int width);
+void NV21ToARGBRow_Any_AVX2(const uint8_t* y_buf,
+                            const uint8_t* uv_buf,
+                            uint8_t* dst_ptr,
+                            const struct YuvConstants* yuvconstants,
+                            int width);
+void NV12ToRGB24Row_Any_SSSE3(const uint8_t* y_buf,
+                              const uint8_t* uv_buf,
+                              uint8_t* dst_ptr,
+                              const struct YuvConstants* yuvconstants,
+                              int width);
+void NV21ToRGB24Row_Any_SSSE3(const uint8_t* y_buf,
+                              const uint8_t* uv_buf,
+                              uint8_t* dst_ptr,
+                              const struct YuvConstants* yuvconstants,
+                              int width);
+void NV12ToRGB24Row_Any_AVX2(const uint8_t* y_buf,
+                             const uint8_t* uv_buf,
+                             uint8_t* dst_ptr,
+                             const struct YuvConstants* yuvconstants,
+                             int width);
+void NV21ToRGB24Row_Any_AVX2(const uint8_t* y_buf,
+                             const uint8_t* uv_buf,
+                             uint8_t* dst_ptr,
+                             const struct YuvConstants* yuvconstants,
+                             int width);
+void NV21ToYUV24Row_Any_SSSE3(const uint8_t* src_y,
+                              const uint8_t* src_vu,
+                              uint8_t* dst_yuv24,
+                              int width);
+void NV21ToYUV24Row_Any_AVX2(const uint8_t* src_y,
+                             const uint8_t* src_vu,
+                             uint8_t* dst_yuv24,
+                             int width);
+void NV12ToRGB565Row_Any_SSSE3(const uint8_t* y_buf,
+                               const uint8_t* uv_buf,
+                               uint8_t* dst_ptr,
+                               const struct YuvConstants* yuvconstants,
+                               int width);
+void NV12ToRGB565Row_Any_AVX2(const uint8_t* y_buf,
+                              const uint8_t* uv_buf,
+                              uint8_t* dst_ptr,
+                              const struct YuvConstants* yuvconstants,
+                              int width);
+void YUY2ToARGBRow_Any_SSSE3(const uint8_t* src_ptr,
+                             uint8_t* dst_ptr,
+                             const struct YuvConstants* yuvconstants,
+                             int width);
+void UYVYToARGBRow_Any_SSSE3(const uint8_t* src_ptr,
+                             uint8_t* dst_ptr,
+                             const struct YuvConstants* yuvconstants,
+                             int width);
+void YUY2ToARGBRow_Any_AVX2(const uint8_t* src_ptr,
+                            uint8_t* dst_ptr,
+                            const struct YuvConstants* yuvconstants,
+                            int width);
+void UYVYToARGBRow_Any_AVX2(const uint8_t* src_ptr,
+                            uint8_t* dst_ptr,
+                            const struct YuvConstants* yuvconstants,
+                            int width);
+void P210ToARGBRow_Any_SSSE3(const uint16_t* y_buf,
+                             const uint16_t* uv_buf,
+                             uint8_t* dst_ptr,
+                             const struct YuvConstants* yuvconstants,
+                             int width);
+void P410ToARGBRow_Any_SSSE3(const uint16_t* y_buf,
+                             const uint16_t* uv_buf,
+                             uint8_t* dst_ptr,
+                             const struct YuvConstants* yuvconstants,
+                             int width);
+void P210ToAR30Row_Any_SSSE3(const uint16_t* y_buf,
+                             const uint16_t* uv_buf,
+                             uint8_t* dst_ptr,
+                             const struct YuvConstants* yuvconstants,
+                             int width);
+void P410ToAR30Row_Any_SSSE3(const uint16_t* y_buf,
+                             const uint16_t* uv_buf,
+                             uint8_t* dst_ptr,
+                             const struct YuvConstants* yuvconstants,
+                             int width);
+void P210ToARGBRow_Any_AVX2(const uint16_t* y_buf,
+                            const uint16_t* uv_buf,
+                            uint8_t* dst_ptr,
+                            const struct YuvConstants* yuvconstants,
+                            int width);
+void P410ToARGBRow_Any_AVX2(const uint16_t* y_buf,
+                            const uint16_t* uv_buf,
+                            uint8_t* dst_ptr,
+                            const struct YuvConstants* yuvconstants,
+                            int width);
+void P210ToAR30Row_Any_AVX2(const uint16_t* y_buf,
+                            const uint16_t* uv_buf,
+                            uint8_t* dst_ptr,
+                            const struct YuvConstants* yuvconstants,
+                            int width);
+void P410ToAR30Row_Any_AVX2(const uint16_t* y_buf,
+                            const uint16_t* uv_buf,
+                            uint8_t* dst_ptr,
+                            const struct YuvConstants* yuvconstants,
+                            int width);
+void I422ToRGBARow_Any_SSSE3(const uint8_t* y_buf,
+                             const uint8_t* u_buf,
+                             const uint8_t* v_buf,
+                             uint8_t* dst_ptr,
+                             const struct YuvConstants* yuvconstants,
+                             int width);
+void I422ToARGB4444Row_Any_SSSE3(const uint8_t* y_buf,
+                                 const uint8_t* u_buf,
+                                 const uint8_t* v_buf,
+                                 uint8_t* dst_ptr,
+                                 const struct YuvConstants* yuvconstants,
+                                 int width);
+void I422ToARGB4444Row_Any_AVX2(const uint8_t* y_buf,
+                                const uint8_t* u_buf,
+                                const uint8_t* v_buf,
+                                uint8_t* dst_ptr,
+                                const struct YuvConstants* yuvconstants,
+                                int width);
+void I422ToARGB1555Row_Any_SSSE3(const uint8_t* y_buf,
+                                 const uint8_t* u_buf,
+                                 const uint8_t* v_buf,
+                                 uint8_t* dst_ptr,
+                                 const struct YuvConstants* yuvconstants,
+                                 int width);
+void I422ToARGB1555Row_Any_AVX2(const uint8_t* y_buf,
+                                const uint8_t* u_buf,
+                                const uint8_t* v_buf,
+                                uint8_t* dst_ptr,
+                                const struct YuvConstants* yuvconstants,
+                                int width);
+void I422ToRGB565Row_Any_SSSE3(const uint8_t* y_buf,
+                               const uint8_t* u_buf,
+                               const uint8_t* v_buf,
+                               uint8_t* dst_ptr,
+                               const struct YuvConstants* yuvconstants,
+                               int width);
+void I422ToRGB565Row_Any_AVX2(const uint8_t* y_buf,
+                              const uint8_t* u_buf,
+                              const uint8_t* v_buf,
+                              uint8_t* dst_ptr,
+                              const struct YuvConstants* yuvconstants,
+                              int width);
+void I422ToRGB24Row_Any_SSSE3(const uint8_t* y_buf,
+                              const uint8_t* u_buf,
+                              const uint8_t* v_buf,
+                              uint8_t* dst_ptr,
+                              const struct YuvConstants* yuvconstants,
+                              int width);
+void I422ToRGB24Row_Any_AVX2(const uint8_t* y_buf,
+                             const uint8_t* u_buf,
+                             const uint8_t* v_buf,
+                             uint8_t* dst_ptr,
+                             const struct YuvConstants* yuvconstants,
+                             int width);
+
+void I400ToARGBRow_C(const uint8_t* src_y,
+                     uint8_t* rgb_buf,
+                     const struct YuvConstants* yuvconstants,
+                     int width);
+void I400ToARGBRow_SSE2(const uint8_t* y_buf,
+                        uint8_t* dst_argb,
+                        const struct YuvConstants* yuvconstants,
+                        int width);
+void I400ToARGBRow_AVX2(const uint8_t* y_buf,
+                        uint8_t* dst_argb,
+                        const struct YuvConstants* yuvconstants,
+                        int width);
+void I400ToARGBRow_NEON(const uint8_t* src_y,
+                        uint8_t* dst_argb,
+                        const struct YuvConstants* yuvconstants,
+                        int width);
+void I400ToARGBRow_MSA(const uint8_t* src_y,
+                       uint8_t* dst_argb,
+                       const struct YuvConstants* yuvconstants,
+                       int width);
+void I400ToARGBRow_LSX(const uint8_t* src_y,
+                       uint8_t* dst_argb,
+                       const struct YuvConstants* yuvconstants,
+                       int width);
+void I400ToARGBRow_Any_SSE2(const uint8_t* src_ptr,
+                            uint8_t* dst_ptr,
+                            const struct YuvConstants* param,
+                            int width);
+void I400ToARGBRow_Any_AVX2(const uint8_t* src_ptr,
+                            uint8_t* dst_ptr,
+                            const struct YuvConstants* param,
+                            int width);
+void I400ToARGBRow_Any_NEON(const uint8_t* src_ptr,
+                            uint8_t* dst_ptr,
+                            const struct YuvConstants* param,
+                            int width);
+void I400ToARGBRow_Any_MSA(const uint8_t* src_ptr,
+                           uint8_t* dst_ptr,
+                           const struct YuvConstants* yuvconstants,
+                           int width);
+void I400ToARGBRow_Any_LSX(const uint8_t* src_ptr,
+                           uint8_t* dst_ptr,
+                           const struct YuvConstants* yuvconstants,
+                           int width);
+
+// ARGB preattenuated alpha blend.
+void ARGBBlendRow_SSSE3(const uint8_t* src_argb,
+                        const uint8_t* src_argb1,
+                        uint8_t* dst_argb,
+                        int width);
+void ARGBBlendRow_NEON(const uint8_t* src_argb,
+                       const uint8_t* src_argb1,
+                       uint8_t* dst_argb,
+                       int width);
+void ARGBBlendRow_MSA(const uint8_t* src_argb0,
+                      const uint8_t* src_argb1,
+                      uint8_t* dst_argb,
+                      int width);
+void ARGBBlendRow_LSX(const uint8_t* src_argb0,
+                      const uint8_t* src_argb1,
+                      uint8_t* dst_argb,
+                      int width);
+void ARGBBlendRow_C(const uint8_t* src_argb,
+                    const uint8_t* src_argb1,
+                    uint8_t* dst_argb,
+                    int width);
+
+// Unattenuated planar alpha blend.
+void BlendPlaneRow_SSSE3(const uint8_t* src0,
+                         const uint8_t* src1,
+                         const uint8_t* alpha,
+                         uint8_t* dst,
+                         int width);
+void BlendPlaneRow_Any_SSSE3(const uint8_t* y_buf,
+                             const uint8_t* u_buf,
+                             const uint8_t* v_buf,
+                             uint8_t* dst_ptr,
+                             int width);
+void BlendPlaneRow_AVX2(const uint8_t* src0,
+                        const uint8_t* src1,
+                        const uint8_t* alpha,
+                        uint8_t* dst,
+                        int width);
+void BlendPlaneRow_Any_AVX2(const uint8_t* y_buf,
+                            const uint8_t* u_buf,
+                            const uint8_t* v_buf,
+                            uint8_t* dst_ptr,
+                            int width);
+void BlendPlaneRow_C(const uint8_t* src0,
+                     const uint8_t* src1,
+                     const uint8_t* alpha,
+                     uint8_t* dst,
+                     int width);
+
+// ARGB multiply images. Same API as Blend, but these require
+// pointer and width alignment for SSE2.
+void ARGBMultiplyRow_C(const uint8_t* src_argb,
+                       const uint8_t* src_argb1,
+                       uint8_t* dst_argb,
+                       int width);
+void ARGBMultiplyRow_SSE2(const uint8_t* src_argb,
+                          const uint8_t* src_argb1,
+                          uint8_t* dst_argb,
+                          int width);
+void ARGBMultiplyRow_Any_SSE2(const uint8_t* y_buf,
+                              const uint8_t* uv_buf,
+                              uint8_t* dst_ptr,
+                              int width);
+void ARGBMultiplyRow_AVX2(const uint8_t* src_argb,
+                          const uint8_t* src_argb1,
+                          uint8_t* dst_argb,
+                          int width);
+void ARGBMultiplyRow_Any_AVX2(const uint8_t* y_buf,
+                              const uint8_t* uv_buf,
+                              uint8_t* dst_ptr,
+                              int width);
+void ARGBMultiplyRow_NEON(const uint8_t* src_argb,
+                          const uint8_t* src_argb1,
+                          uint8_t* dst_argb,
+                          int width);
+void ARGBMultiplyRow_Any_NEON(const uint8_t* y_buf,
+                              const uint8_t* uv_buf,
+                              uint8_t* dst_ptr,
+                              int width);
+void ARGBMultiplyRow_MSA(const uint8_t* src_argb0,
+                         const uint8_t* src_argb1,
+                         uint8_t* dst_argb,
+                         int width);
+void ARGBMultiplyRow_Any_MSA(const uint8_t* y_buf,
+                             const uint8_t* uv_buf,
+                             uint8_t* dst_ptr,
+                             int width);
+void ARGBMultiplyRow_LASX(const uint8_t* src_argb0,
+                          const uint8_t* src_argb1,
+                          uint8_t* dst_argb,
+                          int width);
+void ARGBMultiplyRow_Any_LASX(const uint8_t* y_buf,
+                              const uint8_t* uv_buf,
+                              uint8_t* dst_ptr,
+                              int width);
+
+// ARGB add images.
+void ARGBAddRow_C(const uint8_t* src_argb,
+                  const uint8_t* src_argb1,
+                  uint8_t* dst_argb,
+                  int width);
+void ARGBAddRow_SSE2(const uint8_t* src_argb,
+                     const uint8_t* src_argb1,
+                     uint8_t* dst_argb,
+                     int width);
+void ARGBAddRow_Any_SSE2(const uint8_t* y_buf,
+                         const uint8_t* uv_buf,
+                         uint8_t* dst_ptr,
+                         int width);
+void ARGBAddRow_AVX2(const uint8_t* src_argb,
+                     const uint8_t* src_argb1,
+                     uint8_t* dst_argb,
+                     int width);
+void ARGBAddRow_Any_AVX2(const uint8_t* y_buf,
+                         const uint8_t* uv_buf,
+                         uint8_t* dst_ptr,
+                         int width);
+void ARGBAddRow_NEON(const uint8_t* src_argb,
+                     const uint8_t* src_argb1,
+                     uint8_t* dst_argb,
+                     int width);
+void ARGBAddRow_Any_NEON(const uint8_t* y_buf,
+                         const uint8_t* uv_buf,
+                         uint8_t* dst_ptr,
+                         int width);
+void ARGBAddRow_MSA(const uint8_t* src_argb0,
+                    const uint8_t* src_argb1,
+                    uint8_t* dst_argb,
+                    int width);
+void ARGBAddRow_Any_MSA(const uint8_t* y_buf,
+                        const uint8_t* uv_buf,
+                        uint8_t* dst_ptr,
+                        int width);
+void ARGBAddRow_LASX(const uint8_t* src_argb0,
+                     const uint8_t* src_argb1,
+                     uint8_t* dst_argb,
+                     int width);
+void ARGBAddRow_Any_LASX(const uint8_t* y_buf,
+                         const uint8_t* uv_buf,
+                         uint8_t* dst_ptr,
+                         int width);
+
+// ARGB subtract images. Same API as Blend, but these require
+// pointer and width alignment for SSE2.
+void ARGBSubtractRow_C(const uint8_t* src_argb,
+                       const uint8_t* src_argb1,
+                       uint8_t* dst_argb,
+                       int width);
+void ARGBSubtractRow_SSE2(const uint8_t* src_argb,
+                          const uint8_t* src_argb1,
+                          uint8_t* dst_argb,
+                          int width);
+void ARGBSubtractRow_Any_SSE2(const uint8_t* y_buf,
+                              const uint8_t* uv_buf,
+                              uint8_t* dst_ptr,
+                              int width);
+void ARGBSubtractRow_AVX2(const uint8_t* src_argb,
+                          const uint8_t* src_argb1,
+                          uint8_t* dst_argb,
+                          int width);
+void ARGBSubtractRow_Any_AVX2(const uint8_t* y_buf,
+                              const uint8_t* uv_buf,
+                              uint8_t* dst_ptr,
+                              int width);
+void ARGBSubtractRow_NEON(const uint8_t* src_argb,
+                          const uint8_t* src_argb1,
+                          uint8_t* dst_argb,
+                          int width);
+void ARGBSubtractRow_Any_NEON(const uint8_t* y_buf,
+                              const uint8_t* uv_buf,
+                              uint8_t* dst_ptr,
+                              int width);
+void ARGBSubtractRow_MSA(const uint8_t* src_argb0,
+                         const uint8_t* src_argb1,
+                         uint8_t* dst_argb,
+                         int width);
+void ARGBSubtractRow_Any_MSA(const uint8_t* y_buf,
+                             const uint8_t* uv_buf,
+                             uint8_t* dst_ptr,
+                             int width);
+void ARGBSubtractRow_LASX(const uint8_t* src_argb0,
+                          const uint8_t* src_argb1,
+                          uint8_t* dst_argb,
+                          int width);
+void ARGBSubtractRow_Any_LASX(const uint8_t* y_buf,
+                              const uint8_t* uv_buf,
+                              uint8_t* dst_ptr,
+                              int width);
+
+void ARGBToRGB24Row_Any_SSSE3(const uint8_t* src_ptr,
+                              uint8_t* dst_ptr,
+                              int width);
+void ARGBToRAWRow_Any_SSSE3(const uint8_t* src_ptr,
+                            uint8_t* dst_ptr,
+                            int width);
+void ARGBToRGB565Row_Any_SSE2(const uint8_t* src_ptr,
+                              uint8_t* dst_ptr,
+                              int width);
+void ARGBToARGB1555Row_Any_SSE2(const uint8_t* src_ptr,
+                                uint8_t* dst_ptr,
+                                int width);
+void ARGBToARGB4444Row_Any_SSE2(const uint8_t* src_ptr,
+                                uint8_t* dst_ptr,
+                                int width);
+void ABGRToAR30Row_Any_SSSE3(const uint8_t* src_ptr,
+                             uint8_t* dst_ptr,
+                             int width);
+void ARGBToAR30Row_Any_SSSE3(const uint8_t* src_ptr,
+                             uint8_t* dst_ptr,
+                             int width);
+void ARGBToRAWRow_Any_AVX2(const uint8_t* src_ptr, uint8_t* dst_ptr, int width);
+void ARGBToRGB24Row_Any_AVX2(const uint8_t* src_ptr,
+                             uint8_t* dst_ptr,
+                             int width);
+void ARGBToRGB24Row_Any_AVX512VBMI(const uint8_t* src_ptr,
+                                   uint8_t* dst_ptr,
+                                   int width);
+void ARGBToRGB565DitherRow_Any_SSE2(const uint8_t* src_ptr,
+                                    uint8_t* dst_ptr,
+                                    const uint32_t param,
+                                    int width);
+void ARGBToRGB565DitherRow_Any_AVX2(const uint8_t* src_ptr,
+                                    uint8_t* dst_ptr,
+                                    const uint32_t param,
+                                    int width);
+
+void ARGBToRGB565Row_Any_AVX2(const uint8_t* src_ptr,
+                              uint8_t* dst_ptr,
+                              int width);
+void ARGBToARGB1555Row_Any_AVX2(const uint8_t* src_ptr,
+                                uint8_t* dst_ptr,
+                                int width);
+void ARGBToARGB4444Row_Any_AVX2(const uint8_t* src_ptr,
+                                uint8_t* dst_ptr,
+                                int width);
+void ABGRToAR30Row_Any_AVX2(const uint8_t* src_ptr,
+                            uint8_t* dst_ptr,
+                            int width);
+void ARGBToAR30Row_Any_AVX2(const uint8_t* src_ptr,
+                            uint8_t* dst_ptr,
+                            int width);
+
+void ARGBToRGB24Row_Any_NEON(const uint8_t* src_ptr,
+                             uint8_t* dst_ptr,
+                             int width);
+void ARGBToRAWRow_Any_NEON(const uint8_t* src_ptr, uint8_t* dst_ptr, int width);
+void ARGBToRGB565Row_Any_NEON(const uint8_t* src_ptr,
+                              uint8_t* dst_ptr,
+                              int width);
+void ARGBToARGB1555Row_Any_NEON(const uint8_t* src_ptr,
+                                uint8_t* dst_ptr,
+                                int width);
+void ARGBToARGB4444Row_Any_NEON(const uint8_t* src_ptr,
+                                uint8_t* dst_ptr,
+                                int width);
+void ARGBToRGB565DitherRow_Any_NEON(const uint8_t* src_ptr,
+                                    uint8_t* dst_ptr,
+                                    const uint32_t param,
+                                    int width);
+void ARGBToRGB24Row_Any_MSA(const uint8_t* src_ptr,
+                            uint8_t* dst_ptr,
+                            int width);
+void ARGBToRAWRow_Any_MSA(const uint8_t* src_ptr, uint8_t* dst_ptr, int width);
+void ARGBToRGB565Row_Any_MSA(const uint8_t* src_ptr,
+                             uint8_t* dst_ptr,
+                             int width);
+void ARGBToARGB1555Row_Any_MSA(const uint8_t* src_ptr,
+                               uint8_t* dst_ptr,
+                               int width);
+void ARGBToARGB4444Row_Any_MSA(const uint8_t* src_ptr,
+                               uint8_t* dst_ptr,
+                               int width);
+void ARGBToRGB565DitherRow_Any_MSA(const uint8_t* src_ptr,
+                                   uint8_t* dst_ptr,
+                                   const uint32_t param,
+                                   int width);
+void ARGBToRGB565DitherRow_Any_LASX(const uint8_t* src_ptr,
+                                    uint8_t* dst_ptr,
+                                    const uint32_t param,
+                                    int width);
+
+void ARGBToRGB24Row_Any_LASX(const uint8_t* src_ptr,
+                             uint8_t* dst_ptr,
+                             int width);
+void ARGBToRAWRow_Any_LASX(const uint8_t* src_ptr, uint8_t* dst_ptr, int width);
+void ARGBToRGB565Row_Any_LASX(const uint8_t* src_ptr,
+                              uint8_t* dst_ptr,
+                              int width);
+void ARGBToARGB1555Row_Any_LASX(const uint8_t* src_ptr,
+                                uint8_t* dst_ptr,
+                                int width);
+void ARGBToARGB4444Row_Any_LASX(const uint8_t* src_ptr,
+                                uint8_t* dst_ptr,
+                                int width);
+
+void I444ToARGBRow_Any_NEON(const uint8_t* y_buf,
+                            const uint8_t* u_buf,
+                            const uint8_t* v_buf,
+                            uint8_t* dst_ptr,
+                            const struct YuvConstants* yuvconstants,
+                            int width);
+void I422ToARGBRow_Any_NEON(const uint8_t* y_buf,
+                            const uint8_t* u_buf,
+                            const uint8_t* v_buf,
+                            uint8_t* dst_ptr,
+                            const struct YuvConstants* yuvconstants,
+                            int width);
+void I444AlphaToARGBRow_Any_NEON(const uint8_t* y_buf,
+                                 const uint8_t* u_buf,
+                                 const uint8_t* v_buf,
+                                 const uint8_t* a_buf,
+                                 uint8_t* dst_ptr,
+                                 const struct YuvConstants* yuvconstants,
+                                 int width);
+void I422AlphaToARGBRow_Any_NEON(const uint8_t* y_buf,
+                                 const uint8_t* u_buf,
+                                 const uint8_t* v_buf,
+                                 const uint8_t* a_buf,
+                                 uint8_t* dst_ptr,
+                                 const struct YuvConstants* yuvconstants,
+                                 int width);
+void I422ToRGBARow_Any_NEON(const uint8_t* y_buf,
+                            const uint8_t* u_buf,
+                            const uint8_t* v_buf,
+                            uint8_t* dst_ptr,
+                            const struct YuvConstants* yuvconstants,
+                            int width);
+void I422ToRGB24Row_Any_NEON(const uint8_t* y_buf,
+                             const uint8_t* u_buf,
+                             const uint8_t* v_buf,
+                             uint8_t* dst_ptr,
+                             const struct YuvConstants* yuvconstants,
+                             int width);
+void I422ToARGB4444Row_Any_NEON(const uint8_t* y_buf,
+                                const uint8_t* u_buf,
+                                const uint8_t* v_buf,
+                                uint8_t* dst_ptr,
+                                const struct YuvConstants* yuvconstants,
+                                int width);
+void I422ToARGB1555Row_Any_NEON(const uint8_t* y_buf,
+                                const uint8_t* u_buf,
+                                const uint8_t* v_buf,
+                                uint8_t* dst_ptr,
+                                const struct YuvConstants* yuvconstants,
+                                int width);
+void I422ToRGB565Row_Any_NEON(const uint8_t* y_buf,
+                              const uint8_t* u_buf,
+                              const uint8_t* v_buf,
+                              uint8_t* dst_ptr,
+                              const struct YuvConstants* yuvconstants,
+                              int width);
+void NV12ToARGBRow_Any_NEON(const uint8_t* y_buf,
+                            const uint8_t* uv_buf,
+                            uint8_t* dst_ptr,
+                            const struct YuvConstants* yuvconstants,
+                            int width);
+void NV21ToARGBRow_Any_NEON(const uint8_t* y_buf,
+                            const uint8_t* uv_buf,
+                            uint8_t* dst_ptr,
+                            const struct YuvConstants* yuvconstants,
+                            int width);
+void NV12ToRGB24Row_Any_NEON(const uint8_t* y_buf,
+                             const uint8_t* uv_buf,
+                             uint8_t* dst_ptr,
+                             const struct YuvConstants* yuvconstants,
+                             int width);
+void NV21ToRGB24Row_Any_NEON(const uint8_t* y_buf,
+                             const uint8_t* uv_buf,
+                             uint8_t* dst_ptr,
+                             const struct YuvConstants* yuvconstants,
+                             int width);
+void NV21ToYUV24Row_Any_NEON(const uint8_t* y_buf,
+                             const uint8_t* uv_buf,
+                             uint8_t* dst_ptr,
+                             int width);
+void NV12ToRGB565Row_Any_NEON(const uint8_t* y_buf,
+                              const uint8_t* uv_buf,
+                              uint8_t* dst_ptr,
+                              const struct YuvConstants* yuvconstants,
+                              int width);
+void YUY2ToARGBRow_Any_NEON(const uint8_t* src_ptr,
+                            uint8_t* dst_ptr,
+                            const struct YuvConstants* yuvconstants,
+                            int width);
+void UYVYToARGBRow_Any_NEON(const uint8_t* src_ptr,
+                            uint8_t* dst_ptr,
+                            const struct YuvConstants* yuvconstants,
+                            int width);
+void P210ToARGBRow_NEON(const uint16_t* y_buf,
+                        const uint16_t* uv_buf,
+                        uint8_t* dst_argb,
+                        const struct YuvConstants* yuvconstants,
+                        int width);
+void P410ToARGBRow_NEON(const uint16_t* y_buf,
+                        const uint16_t* uv_buf,
+                        uint8_t* dst_argb,
+                        const struct YuvConstants* yuvconstants,
+                        int width);
+void P210ToAR30Row_NEON(const uint16_t* y_buf,
+                        const uint16_t* uv_buf,
+                        uint8_t* dst_ar30,
+                        const struct YuvConstants* yuvconstants,
+                        int width);
+void P410ToAR30Row_NEON(const uint16_t* y_buf,
+                        const uint16_t* uv_buf,
+                        uint8_t* dst_ar30,
+                        const struct YuvConstants* yuvconstants,
+                        int width);
+void P210ToARGBRow_Any_NEON(const uint16_t* y_buf,
+                            const uint16_t* uv_buf,
+                            uint8_t* dst_argb,
+                            const struct YuvConstants* yuvconstants,
+                            int width);
+void P410ToARGBRow_Any_NEON(const uint16_t* y_buf,
+                            const uint16_t* uv_buf,
+                            uint8_t* dst_argb,
+                            const struct YuvConstants* yuvconstants,
+                            int width);
+void P210ToAR30Row_Any_NEON(const uint16_t* y_buf,
+                            const uint16_t* uv_buf,
+                            uint8_t* dst_ar30,
+                            const struct YuvConstants* yuvconstants,
+                            int width);
+void P410ToAR30Row_Any_NEON(const uint16_t* y_buf,
+                            const uint16_t* uv_buf,
+                            uint8_t* dst_ar30,
+                            const struct YuvConstants* yuvconstants,
+                            int width);
+void I444ToARGBRow_Any_MSA(const uint8_t* y_buf,
+                           const uint8_t* u_buf,
+                           const uint8_t* v_buf,
+                           uint8_t* dst_ptr,
+                           const struct YuvConstants* yuvconstants,
+                           int width);
+void I444ToARGBRow_Any_LSX(const uint8_t* y_buf,
+                           const uint8_t* u_buf,
+                           const uint8_t* v_buf,
+                           uint8_t* dst_ptr,
+                           const struct YuvConstants* yuvconstants,
+                           int width);
+void I422ToARGBRow_Any_MSA(const uint8_t* y_buf,
+                           const uint8_t* u_buf,
+                           const uint8_t* v_buf,
+                           uint8_t* dst_ptr,
+                           const struct YuvConstants* yuvconstants,
+                           int width);
+void I422ToARGBRow_Any_LASX(const uint8_t* y_buf,
+                            const uint8_t* u_buf,
+                            const uint8_t* v_buf,
+                            uint8_t* dst_ptr,
+                            const struct YuvConstants* yuvconstants,
+                            int width);
+void I422ToRGBARow_Any_MSA(const uint8_t* y_buf,
+                           const uint8_t* u_buf,
+                           const uint8_t* v_buf,
+                           uint8_t* dst_ptr,
+                           const struct YuvConstants* yuvconstants,
+                           int width);
+void I422ToRGBARow_Any_LASX(const uint8_t* y_buf,
+                            const uint8_t* u_buf,
+                            const uint8_t* v_buf,
+                            uint8_t* dst_ptr,
+                            const struct YuvConstants* yuvconstants,
+                            int width);
+void I422AlphaToARGBRow_Any_MSA(const uint8_t* y_buf,
+                                const uint8_t* u_buf,
+                                const uint8_t* v_buf,
+                                const uint8_t* a_buf,
+                                uint8_t* dst_ptr,
+                                const struct YuvConstants* yuvconstants,
+                                int width);
+void I422AlphaToARGBRow_Any_LASX(const uint8_t* y_buf,
+                                 const uint8_t* u_buf,
+                                 const uint8_t* v_buf,
+                                 const uint8_t* a_buf,
+                                 uint8_t* dst_ptr,
+                                 const struct YuvConstants* yuvconstants,
+                                 int width);
+void I422ToRGB24Row_Any_MSA(const uint8_t* y_buf,
+                            const uint8_t* u_buf,
+                            const uint8_t* v_buf,
+                            uint8_t* dst_ptr,
+                            const struct YuvConstants* yuvconstants,
+                            int width);
+void I422ToRGB24Row_Any_LASX(const uint8_t* y_buf,
+                             const uint8_t* u_buf,
+                             const uint8_t* v_buf,
+                             uint8_t* dst_ptr,
+                             const struct YuvConstants* yuvconstants,
+                             int width);
+void I422ToRGB565Row_Any_MSA(const uint8_t* y_buf,
+                             const uint8_t* u_buf,
+                             const uint8_t* v_buf,
+                             uint8_t* dst_ptr,
+                             const struct YuvConstants* yuvconstants,
+                             int width);
+void I422ToRGB565Row_Any_LASX(const uint8_t* y_buf,
+                              const uint8_t* u_buf,
+                              const uint8_t* v_buf,
+                              uint8_t* dst_ptr,
+                              const struct YuvConstants* yuvconstants,
+                              int width);
+void I422ToARGB4444Row_Any_MSA(const uint8_t* y_buf,
+                               const uint8_t* u_buf,
+                               const uint8_t* v_buf,
+                               uint8_t* dst_ptr,
+                               const struct YuvConstants* yuvconstants,
+                               int width);
+void I422ToARGB4444Row_Any_LASX(const uint8_t* y_buf,
+                                const uint8_t* u_buf,
+                                const uint8_t* v_buf,
+                                uint8_t* dst_ptr,
+                                const struct YuvConstants* yuvconstants,
+                                int width);
+void I422ToARGB1555Row_Any_MSA(const uint8_t* y_buf,
+                               const uint8_t* u_buf,
+                               const uint8_t* v_buf,
+                               uint8_t* dst_ptr,
+                               const struct YuvConstants* yuvconstants,
+                               int width);
+void I422ToARGB1555Row_Any_LASX(const uint8_t* y_buf,
+                                const uint8_t* u_buf,
+                                const uint8_t* v_buf,
+                                uint8_t* dst_ptr,
+                                const struct YuvConstants* yuvconstants,
+                                int width);
+void NV12ToARGBRow_Any_MSA(const uint8_t* y_buf,
+                           const uint8_t* uv_buf,
+                           uint8_t* dst_ptr,
+                           const struct YuvConstants* yuvconstants,
+                           int width);
+void NV12ToRGB565Row_Any_MSA(const uint8_t* y_buf,
+                             const uint8_t* uv_buf,
+                             uint8_t* dst_ptr,
+                             const struct YuvConstants* yuvconstants,
+                             int width);
+void NV21ToARGBRow_Any_MSA(const uint8_t* y_buf,
+                           const uint8_t* uv_buf,
+                           uint8_t* dst_ptr,
+                           const struct YuvConstants* yuvconstants,
+                           int width);
+void YUY2ToARGBRow_Any_MSA(const uint8_t* src_ptr,
+                           uint8_t* dst_ptr,
+                           const struct YuvConstants* yuvconstants,
+                           int width);
+void UYVYToARGBRow_Any_MSA(const uint8_t* src_ptr,
+                           uint8_t* dst_ptr,
+                           const struct YuvConstants* yuvconstants,
+                           int width);
+
+void NV12ToARGBRow_Any_LSX(const uint8_t* y_buf,
+                           const uint8_t* uv_buf,
+                           uint8_t* dst_ptr,
+                           const struct YuvConstants* yuvconstants,
+                           int width);
+void NV12ToARGBRow_Any_LASX(const uint8_t* y_buf,
+                            const uint8_t* uv_buf,
+                            uint8_t* dst_ptr,
+                            const struct YuvConstants* yuvconstants,
+                            int width);
+void NV12ToRGB565Row_Any_LSX(const uint8_t* y_buf,
+                             const uint8_t* uv_buf,
+                             uint8_t* dst_ptr,
+                             const struct YuvConstants* yuvconstants,
+                             int width);
+void NV12ToRGB565Row_Any_LASX(const uint8_t* y_buf,
+                              const uint8_t* uv_buf,
+                              uint8_t* dst_ptr,
+                              const struct YuvConstants* yuvconstants,
+                              int width);
+void NV21ToARGBRow_Any_LSX(const uint8_t* y_buf,
+                           const uint8_t* uv_buf,
+                           uint8_t* dst_ptr,
+                           const struct YuvConstants* yuvconstants,
+                           int width);
+void NV21ToARGBRow_Any_LASX(const uint8_t* y_buf,
+                            const uint8_t* uv_buf,
+                            uint8_t* dst_ptr,
+                            const struct YuvConstants* yuvconstants,
+                            int width);
+void YUY2ToARGBRow_Any_LSX(const uint8_t* src_ptr,
+                           uint8_t* dst_ptr,
+                           const struct YuvConstants* yuvconstants,
+                           int width);
+void UYVYToARGBRow_Any_LSX(const uint8_t* src_ptr,
+                           uint8_t* dst_ptr,
+                           const struct YuvConstants* yuvconstants,
+                           int width);
+
+void YUY2ToYRow_AVX2(const uint8_t* src_yuy2, uint8_t* dst_y, int width);
+void YUY2ToUVRow_AVX2(const uint8_t* src_yuy2,
+                      int stride_yuy2,
+                      uint8_t* dst_u,
+                      uint8_t* dst_v,
+                      int width);
+void YUY2ToUV422Row_AVX2(const uint8_t* src_yuy2,
+                         uint8_t* dst_u,
+                         uint8_t* dst_v,
+                         int width);
+void YUY2ToYRow_SSE2(const uint8_t* src_yuy2, uint8_t* dst_y, int width);
+void YUY2ToUVRow_SSE2(const uint8_t* src_yuy2,
+                      int stride_yuy2,
+                      uint8_t* dst_u,
+                      uint8_t* dst_v,
+                      int width);
+void YUY2ToUV422Row_SSE2(const uint8_t* src_yuy2,
+                         uint8_t* dst_u,
+                         uint8_t* dst_v,
+                         int width);
+void YUY2ToYRow_NEON(const uint8_t* src_yuy2, uint8_t* dst_y, int width);
+void YUY2ToUVRow_NEON(const uint8_t* src_yuy2,
+                      int stride_yuy2,
+                      uint8_t* dst_u,
+                      uint8_t* dst_v,
+                      int width);
+void YUY2ToUV422Row_NEON(const uint8_t* src_yuy2,
+                         uint8_t* dst_u,
+                         uint8_t* dst_v,
+                         int width);
+void YUY2ToYRow_MSA(const uint8_t* src_yuy2, uint8_t* dst_y, int width);
+void YUY2ToYRow_LASX(const uint8_t* src_yuy2, uint8_t* dst_y, int width);
+void YUY2ToUVRow_MSA(const uint8_t* src_yuy2,
+                     int src_stride_yuy2,
+                     uint8_t* dst_u,
+                     uint8_t* dst_v,
+                     int width);
+void YUY2ToUVRow_LASX(const uint8_t* src_yuy2,
+                      int src_stride_yuy2,
+                      uint8_t* dst_u,
+                      uint8_t* dst_v,
+                      int width);
+void YUY2ToUV422Row_MSA(const uint8_t* src_yuy2,
+                        uint8_t* dst_u,
+                        uint8_t* dst_v,
+                        int width);
+void YUY2ToUV422Row_LASX(const uint8_t* src_yuy2,
+                         uint8_t* dst_u,
+                         uint8_t* dst_v,
+                         int width);
+void YUY2ToYRow_C(const uint8_t* src_yuy2, uint8_t* dst_y, int width);
+void YUY2ToUVRow_C(const uint8_t* src_yuy2,
+                   int src_stride_yuy2,
+                   uint8_t* dst_u,
+                   uint8_t* dst_v,
+                   int width);
+void YUY2ToUV422Row_C(const uint8_t* src_yuy2,
+                      uint8_t* dst_u,
+                      uint8_t* dst_v,
+                      int width);
+void YUY2ToYRow_Any_AVX2(const uint8_t* src_ptr, uint8_t* dst_ptr, int width);
+void YUY2ToUVRow_Any_AVX2(const uint8_t* src_ptr,
+                          int src_stride,
+                          uint8_t* dst_u,
+                          uint8_t* dst_v,
+                          int width);
+void YUY2ToUV422Row_Any_AVX2(const uint8_t* src_ptr,
+                             uint8_t* dst_u,
+                             uint8_t* dst_v,
+                             int width);
+void YUY2ToYRow_Any_SSE2(const uint8_t* src_ptr, uint8_t* dst_ptr, int width);
+void YUY2ToUVRow_Any_SSE2(const uint8_t* src_ptr,
+                          int src_stride,
+                          uint8_t* dst_u,
+                          uint8_t* dst_v,
+                          int width);
+void YUY2ToUV422Row_Any_SSE2(const uint8_t* src_ptr,
+                             uint8_t* dst_u,
+                             uint8_t* dst_v,
+                             int width);
+void YUY2ToYRow_Any_NEON(const uint8_t* src_ptr, uint8_t* dst_ptr, int width);
+void YUY2ToUVRow_Any_NEON(const uint8_t* src_ptr,
+                          int src_stride,
+                          uint8_t* dst_u,
+                          uint8_t* dst_v,
+                          int width);
+void YUY2ToUV422Row_Any_NEON(const uint8_t* src_ptr,
+                             uint8_t* dst_u,
+                             uint8_t* dst_v,
+                             int width);
+void YUY2ToYRow_Any_MSA(const uint8_t* src_ptr, uint8_t* dst_ptr, int width);
+void YUY2ToYRow_Any_LASX(const uint8_t* src_ptr, uint8_t* dst_ptr, int width);
+void YUY2ToUVRow_Any_MSA(const uint8_t* src_ptr,
+                         int src_stride_ptr,
+                         uint8_t* dst_u,
+                         uint8_t* dst_v,
+                         int width);
+void YUY2ToUVRow_Any_LASX(const uint8_t* src_ptr,
+                          int src_stride_ptr,
+                          uint8_t* dst_u,
+                          uint8_t* dst_v,
+                          int width);
+void YUY2ToUV422Row_Any_MSA(const uint8_t* src_ptr,
+                            uint8_t* dst_u,
+                            uint8_t* dst_v,
+                            int width);
+void YUY2ToUV422Row_Any_LASX(const uint8_t* src_ptr,
+                             uint8_t* dst_u,
+                             uint8_t* dst_v,
+                             int width);
+void UYVYToYRow_AVX2(const uint8_t* src_uyvy, uint8_t* dst_y, int width);
+void UYVYToUVRow_AVX2(const uint8_t* src_uyvy,
+                      int stride_uyvy,
+                      uint8_t* dst_u,
+                      uint8_t* dst_v,
+                      int width);
+void UYVYToUV422Row_AVX2(const uint8_t* src_uyvy,
+                         uint8_t* dst_u,
+                         uint8_t* dst_v,
+                         int width);
+void UYVYToYRow_SSE2(const uint8_t* src_uyvy, uint8_t* dst_y, int width);
+void UYVYToUVRow_SSE2(const uint8_t* src_uyvy,
+                      int stride_uyvy,
+                      uint8_t* dst_u,
+                      uint8_t* dst_v,
+                      int width);
+void UYVYToUV422Row_SSE2(const uint8_t* src_uyvy,
+                         uint8_t* dst_u,
+                         uint8_t* dst_v,
+                         int width);
+void UYVYToYRow_AVX2(const uint8_t* src_uyvy, uint8_t* dst_y, int width);
+void UYVYToUVRow_AVX2(const uint8_t* src_uyvy,
+                      int stride_uyvy,
+                      uint8_t* dst_u,
+                      uint8_t* dst_v,
+                      int width);
+void UYVYToUV422Row_AVX2(const uint8_t* src_uyvy,
+                         uint8_t* dst_u,
+                         uint8_t* dst_v,
+                         int width);
+void UYVYToYRow_NEON(const uint8_t* src_uyvy, uint8_t* dst_y, int width);
+void UYVYToUVRow_NEON(const uint8_t* src_uyvy,
+                      int stride_uyvy,
+                      uint8_t* dst_u,
+                      uint8_t* dst_v,
+                      int width);
+void UYVYToUV422Row_NEON(const uint8_t* src_uyvy,
+                         uint8_t* dst_u,
+                         uint8_t* dst_v,
+                         int width);
+void UYVYToYRow_MSA(const uint8_t* src_uyvy, uint8_t* dst_y, int width);
+void UYVYToYRow_LASX(const uint8_t* src_uyvy, uint8_t* dst_y, int width);
+void UYVYToUVRow_MSA(const uint8_t* src_uyvy,
+                     int src_stride_uyvy,
+                     uint8_t* dst_u,
+                     uint8_t* dst_v,
+                     int width);
+void UYVYToUVRow_LASX(const uint8_t* src_uyvy,
+                      int src_stride_uyvy,
+                      uint8_t* dst_u,
+                      uint8_t* dst_v,
+                      int width);
+void UYVYToUV422Row_MSA(const uint8_t* src_uyvy,
+                        uint8_t* dst_u,
+                        uint8_t* dst_v,
+                        int width);
+void UYVYToUV422Row_LASX(const uint8_t* src_uyvy,
+                         uint8_t* dst_u,
+                         uint8_t* dst_v,
+                         int width);
+
+void UYVYToYRow_C(const uint8_t* src_uyvy, uint8_t* dst_y, int width);
+void UYVYToUVRow_C(const uint8_t* src_uyvy,
+                   int src_stride_uyvy,
+                   uint8_t* dst_u,
+                   uint8_t* dst_v,
+                   int width);
+void UYVYToUV422Row_C(const uint8_t* src_uyvy,
+                      uint8_t* dst_u,
+                      uint8_t* dst_v,
+                      int width);
+void UYVYToYRow_Any_AVX2(const uint8_t* src_ptr, uint8_t* dst_ptr, int width);
+void UYVYToUVRow_Any_AVX2(const uint8_t* src_ptr,
+                          int src_stride,
+                          uint8_t* dst_u,
+                          uint8_t* dst_v,
+                          int width);
+void UYVYToUV422Row_Any_AVX2(const uint8_t* src_ptr,
+                             uint8_t* dst_u,
+                             uint8_t* dst_v,
+                             int width);
+void UYVYToYRow_Any_SSE2(const uint8_t* src_ptr, uint8_t* dst_ptr, int width);
+void UYVYToUVRow_Any_SSE2(const uint8_t* src_ptr,
+                          int src_stride,
+                          uint8_t* dst_u,
+                          uint8_t* dst_v,
+                          int width);
+void UYVYToUV422Row_Any_SSE2(const uint8_t* src_ptr,
+                             uint8_t* dst_u,
+                             uint8_t* dst_v,
+                             int width);
+void UYVYToYRow_Any_NEON(const uint8_t* src_ptr, uint8_t* dst_ptr, int width);
+void UYVYToUVRow_Any_NEON(const uint8_t* src_ptr,
+                          int src_stride,
+                          uint8_t* dst_u,
+                          uint8_t* dst_v,
+                          int width);
+void UYVYToUV422Row_Any_NEON(const uint8_t* src_ptr,
+                             uint8_t* dst_u,
+                             uint8_t* dst_v,
+                             int width);
+void UYVYToYRow_Any_MSA(const uint8_t* src_ptr, uint8_t* dst_ptr, int width);
+void UYVYToYRow_Any_LASX(const uint8_t* src_ptr, uint8_t* dst_ptr, int width);
+void UYVYToUVRow_Any_MSA(const uint8_t* src_ptr,
+                         int src_stride_ptr,
+                         uint8_t* dst_u,
+                         uint8_t* dst_v,
+                         int width);
+void UYVYToUVRow_Any_LASX(const uint8_t* src_ptr,
+                          int src_stride_ptr,
+                          uint8_t* dst_u,
+                          uint8_t* dst_v,
+                          int width);
+void UYVYToUV422Row_Any_MSA(const uint8_t* src_ptr,
+                            uint8_t* dst_u,
+                            uint8_t* dst_v,
+                            int width);
+void UYVYToUV422Row_Any_LASX(const uint8_t* src_ptr,
+                             uint8_t* dst_u,
+                             uint8_t* dst_v,
+                             int width);
+void SwapUVRow_C(const uint8_t* src_uv, uint8_t* dst_vu, int width);
+void SwapUVRow_NEON(const uint8_t* src_uv, uint8_t* dst_vu, int width);
+void SwapUVRow_Any_NEON(const uint8_t* src_ptr, uint8_t* dst_ptr, int width);
+void SwapUVRow_SSSE3(const uint8_t* src_uv, uint8_t* dst_vu, int width);
+void SwapUVRow_Any_SSSE3(const uint8_t* src_ptr, uint8_t* dst_ptr, int width);
+void SwapUVRow_AVX2(const uint8_t* src_uv, uint8_t* dst_vu, int width);
+void SwapUVRow_Any_AVX2(const uint8_t* src_ptr, uint8_t* dst_ptr, int width);
+void AYUVToYRow_C(const uint8_t* src_ayuv, uint8_t* dst_y, int width);
+void AYUVToUVRow_C(const uint8_t* src_ayuv,
+                   int src_stride_ayuv,
+                   uint8_t* dst_uv,
+                   int width);
+void AYUVToVURow_C(const uint8_t* src_ayuv,
+                   int src_stride_ayuv,
+                   uint8_t* dst_vu,
+                   int width);
+void AYUVToYRow_NEON(const uint8_t* src_ayuv, uint8_t* dst_y, int width);
+void AYUVToUVRow_NEON(const uint8_t* src_ayuv,
+                      int src_stride_ayuv,
+                      uint8_t* dst_uv,
+                      int width);
+void AYUVToVURow_NEON(const uint8_t* src_ayuv,
+                      int src_stride_ayuv,
+                      uint8_t* dst_vu,
+                      int width);
+void AYUVToYRow_Any_NEON(const uint8_t* src_ptr, uint8_t* dst_ptr, int width);
+void AYUVToUVRow_Any_NEON(const uint8_t* src_ptr,
+                          int src_stride,
+                          uint8_t* dst_vu,
+                          int width);
+void AYUVToVURow_Any_NEON(const uint8_t* src_ptr,
+                          int src_stride,
+                          uint8_t* dst_vu,
+                          int width);
+
+void I422ToYUY2Row_C(const uint8_t* src_y,
+                     const uint8_t* src_u,
+                     const uint8_t* src_v,
+                     uint8_t* dst_frame,
+                     int width);
+void I422ToUYVYRow_C(const uint8_t* src_y,
+                     const uint8_t* src_u,
+                     const uint8_t* src_v,
+                     uint8_t* dst_frame,
+                     int width);
+void I422ToYUY2Row_SSE2(const uint8_t* src_y,
+                        const uint8_t* src_u,
+                        const uint8_t* src_v,
+                        uint8_t* dst_yuy2,
+                        int width);
+void I422ToUYVYRow_SSE2(const uint8_t* src_y,
+                        const uint8_t* src_u,
+                        const uint8_t* src_v,
+                        uint8_t* dst_uyvy,
+                        int width);
+void I422ToYUY2Row_Any_SSE2(const uint8_t* y_buf,
+                            const uint8_t* u_buf,
+                            const uint8_t* v_buf,
+                            uint8_t* dst_ptr,
+                            int width);
+void I422ToUYVYRow_Any_SSE2(const uint8_t* y_buf,
+                            const uint8_t* u_buf,
+                            const uint8_t* v_buf,
+                            uint8_t* dst_ptr,
+                            int width);
+void I422ToYUY2Row_AVX2(const uint8_t* src_y,
+                        const uint8_t* src_u,
+                        const uint8_t* src_v,
+                        uint8_t* dst_yuy2,
+                        int width);
+void I422ToUYVYRow_AVX2(const uint8_t* src_y,
+                        const uint8_t* src_u,
+                        const uint8_t* src_v,
+                        uint8_t* dst_uyvy,
+                        int width);
+void I422ToYUY2Row_Any_AVX2(const uint8_t* y_buf,
+                            const uint8_t* u_buf,
+                            const uint8_t* v_buf,
+                            uint8_t* dst_ptr,
+                            int width);
+void I422ToUYVYRow_Any_AVX2(const uint8_t* y_buf,
+                            const uint8_t* u_buf,
+                            const uint8_t* v_buf,
+                            uint8_t* dst_ptr,
+                            int width);
+void I422ToYUY2Row_NEON(const uint8_t* src_y,
+                        const uint8_t* src_u,
+                        const uint8_t* src_v,
+                        uint8_t* dst_yuy2,
+                        int width);
+void I422ToUYVYRow_NEON(const uint8_t* src_y,
+                        const uint8_t* src_u,
+                        const uint8_t* src_v,
+                        uint8_t* dst_uyvy,
+                        int width);
+void I422ToYUY2Row_Any_NEON(const uint8_t* y_buf,
+                            const uint8_t* u_buf,
+                            const uint8_t* v_buf,
+                            uint8_t* dst_ptr,
+                            int width);
+void I422ToUYVYRow_Any_NEON(const uint8_t* y_buf,
+                            const uint8_t* u_buf,
+                            const uint8_t* v_buf,
+                            uint8_t* dst_ptr,
+                            int width);
+void I422ToYUY2Row_MSA(const uint8_t* src_y,
+                       const uint8_t* src_u,
+                       const uint8_t* src_v,
+                       uint8_t* dst_yuy2,
+                       int width);
+void I422ToYUY2Row_LASX(const uint8_t* src_y,
+                        const uint8_t* src_u,
+                        const uint8_t* src_v,
+                        uint8_t* dst_yuy2,
+                        int width);
+void I422ToUYVYRow_MSA(const uint8_t* src_y,
+                       const uint8_t* src_u,
+                       const uint8_t* src_v,
+                       uint8_t* dst_uyvy,
+                       int width);
+void I422ToUYVYRow_LASX(const uint8_t* src_y,
+                        const uint8_t* src_u,
+                        const uint8_t* src_v,
+                        uint8_t* dst_uyvy,
+                        int width);
+void I422ToYUY2Row_Any_MSA(const uint8_t* y_buf,
+                           const uint8_t* u_buf,
+                           const uint8_t* v_buf,
+                           uint8_t* dst_ptr,
+                           int width);
+void I422ToYUY2Row_Any_LASX(const uint8_t* y_buf,
+                            const uint8_t* u_buf,
+                            const uint8_t* v_buf,
+                            uint8_t* dst_ptr,
+                            int width);
+void I422ToUYVYRow_Any_MSA(const uint8_t* y_buf,
+                           const uint8_t* u_buf,
+                           const uint8_t* v_buf,
+                           uint8_t* dst_ptr,
+                           int width);
+void I422ToUYVYRow_Any_LASX(const uint8_t* y_buf,
+                            const uint8_t* u_buf,
+                            const uint8_t* v_buf,
+                            uint8_t* dst_ptr,
+                            int width);
+
+// Effects related row functions.
+void ARGBAttenuateRow_C(const uint8_t* src_argb, uint8_t* dst_argb, int width);
+void ARGBAttenuateRow_SSSE3(const uint8_t* src_argb,
+                            uint8_t* dst_argb,
+                            int width);
+void ARGBAttenuateRow_AVX2(const uint8_t* src_argb,
+                           uint8_t* dst_argb,
+                           int width);
+void ARGBAttenuateRow_NEON(const uint8_t* src_argb,
+                           uint8_t* dst_argb,
+                           int width);
+void ARGBAttenuateRow_MSA(const uint8_t* src_argb,
+                          uint8_t* dst_argb,
+                          int width);
+void ARGBAttenuateRow_LASX(const uint8_t* src_argb,
+                           uint8_t* dst_argb,
+                           int width);
+void ARGBAttenuateRow_Any_SSSE3(const uint8_t* src_ptr,
+                                uint8_t* dst_ptr,
+                                int width);
+void ARGBAttenuateRow_Any_AVX2(const uint8_t* src_ptr,
+                               uint8_t* dst_ptr,
+                               int width);
+void ARGBAttenuateRow_Any_NEON(const uint8_t* src_ptr,
+                               uint8_t* dst_ptr,
+                               int width);
+void ARGBAttenuateRow_Any_MSA(const uint8_t* src_ptr,
+                              uint8_t* dst_ptr,
+                              int width);
+void ARGBAttenuateRow_Any_LASX(const uint8_t* src_ptr,
+                               uint8_t* dst_ptr,
+                               int width);
+
+// Inverse table for unattenuate, shared by C and SSE2.
+extern const uint32_t fixed_invtbl8[256];
+void ARGBUnattenuateRow_C(const uint8_t* src_argb,
+                          uint8_t* dst_argb,
+                          int width);
+void ARGBUnattenuateRow_SSE2(const uint8_t* src_argb,
+                             uint8_t* dst_argb,
+                             int width);
+void ARGBUnattenuateRow_AVX2(const uint8_t* src_argb,
+                             uint8_t* dst_argb,
+                             int width);
+void ARGBUnattenuateRow_Any_SSE2(const uint8_t* src_ptr,
+                                 uint8_t* dst_ptr,
+                                 int width);
+void ARGBUnattenuateRow_Any_AVX2(const uint8_t* src_ptr,
+                                 uint8_t* dst_ptr,
+                                 int width);
+
+void ARGBGrayRow_C(const uint8_t* src_argb, uint8_t* dst_argb, int width);
+void ARGBGrayRow_SSSE3(const uint8_t* src_argb, uint8_t* dst_argb, int width);
+void ARGBGrayRow_NEON(const uint8_t* src_argb, uint8_t* dst_argb, int width);
+void ARGBGrayRow_MSA(const uint8_t* src_argb, uint8_t* dst_argb, int width);
+void ARGBGrayRow_LASX(const uint8_t* src_argb, uint8_t* dst_argb, int width);
+
+void ARGBSepiaRow_C(uint8_t* dst_argb, int width);
+void ARGBSepiaRow_SSSE3(uint8_t* dst_argb, int width);
+void ARGBSepiaRow_NEON(uint8_t* dst_argb, int width);
+void ARGBSepiaRow_MSA(uint8_t* dst_argb, int width);
+void ARGBSepiaRow_LASX(uint8_t* dst_argb, int width);
+
+void ARGBColorMatrixRow_C(const uint8_t* src_argb,
+                          uint8_t* dst_argb,
+                          const int8_t* matrix_argb,
+                          int width);
+void ARGBColorMatrixRow_SSSE3(const uint8_t* src_argb,
+                              uint8_t* dst_argb,
+                              const int8_t* matrix_argb,
+                              int width);
+void ARGBColorMatrixRow_NEON(const uint8_t* src_argb,
+                             uint8_t* dst_argb,
+                             const int8_t* matrix_argb,
+                             int width);
+void ARGBColorMatrixRow_MSA(const uint8_t* src_argb,
+                            uint8_t* dst_argb,
+                            const int8_t* matrix_argb,
+                            int width);
+void ARGBColorMatrixRow_LSX(const uint8_t* src_argb,
+                            uint8_t* dst_argb,
+                            const int8_t* matrix_argb,
+                            int width);
+
+void ARGBColorTableRow_C(uint8_t* dst_argb,
+                         const uint8_t* table_argb,
+                         int width);
+void ARGBColorTableRow_X86(uint8_t* dst_argb,
+                           const uint8_t* table_argb,
+                           int width);
+
+void RGBColorTableRow_C(uint8_t* dst_argb,
+                        const uint8_t* table_argb,
+                        int width);
+void RGBColorTableRow_X86(uint8_t* dst_argb,
+                          const uint8_t* table_argb,
+                          int width);
+
+void ARGBQuantizeRow_C(uint8_t* dst_argb,
+                       int scale,
+                       int interval_size,
+                       int interval_offset,
+                       int width);
+void ARGBQuantizeRow_SSE2(uint8_t* dst_argb,
+                          int scale,
+                          int interval_size,
+                          int interval_offset,
+                          int width);
+void ARGBQuantizeRow_NEON(uint8_t* dst_argb,
+                          int scale,
+                          int interval_size,
+                          int interval_offset,
+                          int width);
+void ARGBQuantizeRow_MSA(uint8_t* dst_argb,
+                         int scale,
+                         int interval_size,
+                         int interval_offset,
+                         int width);
+void ARGBQuantizeRow_LSX(uint8_t* dst_argb,
+                         int scale,
+                         int interval_size,
+                         int interval_offset,
+                         int width);
+
+void ARGBShadeRow_C(const uint8_t* src_argb,
+                    uint8_t* dst_argb,
+                    int width,
+                    uint32_t value);
+void ARGBShadeRow_SSE2(const uint8_t* src_argb,
+                       uint8_t* dst_argb,
+                       int width,
+                       uint32_t value);
+void ARGBShadeRow_NEON(const uint8_t* src_argb,
+                       uint8_t* dst_argb,
+                       int width,
+                       uint32_t value);
+void ARGBShadeRow_MSA(const uint8_t* src_argb,
+                      uint8_t* dst_argb,
+                      int width,
+                      uint32_t value);
+void ARGBShadeRow_LASX(const uint8_t* src_argb,
+                       uint8_t* dst_argb,
+                       int width,
+                       uint32_t value);
+
+// Used for blur.
+void CumulativeSumToAverageRow_SSE2(const int32_t* topleft,
+                                    const int32_t* botleft,
+                                    int width,
+                                    int area,
+                                    uint8_t* dst,
+                                    int count);
+void ComputeCumulativeSumRow_SSE2(const uint8_t* row,
+                                  int32_t* cumsum,
+                                  const int32_t* previous_cumsum,
+                                  int width);
+
+void CumulativeSumToAverageRow_C(const int32_t* tl,
+                                 const int32_t* bl,
+                                 int w,
+                                 int area,
+                                 uint8_t* dst,
+                                 int count);
+void ComputeCumulativeSumRow_C(const uint8_t* row,
+                               int32_t* cumsum,
+                               const int32_t* previous_cumsum,
+                               int width);
+
+LIBYUV_API
+void ARGBAffineRow_C(const uint8_t* src_argb,
+                     int src_argb_stride,
+                     uint8_t* dst_argb,
+                     const float* uv_dudv,
+                     int width);
+LIBYUV_API
+void ARGBAffineRow_SSE2(const uint8_t* src_argb,
+                        int src_argb_stride,
+                        uint8_t* dst_argb,
+                        const float* src_dudv,
+                        int width);
+
+// Used for I420Scale, ARGBScale, and ARGBInterpolate.
+void InterpolateRow_C(uint8_t* dst_ptr,
+                      const uint8_t* src_ptr,
+                      ptrdiff_t src_stride,
+                      int width,
+                      int source_y_fraction);
+void InterpolateRow_SSSE3(uint8_t* dst_ptr,
+                          const uint8_t* src_ptr,
+                          ptrdiff_t src_stride,
+                          int dst_width,
+                          int source_y_fraction);
+void InterpolateRow_AVX2(uint8_t* dst_ptr,
+                         const uint8_t* src_ptr,
+                         ptrdiff_t src_stride,
+                         int dst_width,
+                         int source_y_fraction);
+void InterpolateRow_NEON(uint8_t* dst_ptr,
+                         const uint8_t* src_ptr,
+                         ptrdiff_t src_stride,
+                         int dst_width,
+                         int source_y_fraction);
+void InterpolateRow_MSA(uint8_t* dst_ptr,
+                        const uint8_t* src_ptr,
+                        ptrdiff_t src_stride,
+                        int width,
+                        int source_y_fraction);
+void InterpolateRow_LSX(uint8_t* dst_ptr,
+                        const uint8_t* src_ptr,
+                        ptrdiff_t src_stride,
+                        int width,
+                        int source_y_fraction);
+void InterpolateRow_Any_NEON(uint8_t* dst_ptr,
+                             const uint8_t* src_ptr,
+                             ptrdiff_t src_stride_ptr,
+                             int width,
+                             int source_y_fraction);
+void InterpolateRow_Any_SSSE3(uint8_t* dst_ptr,
+                              const uint8_t* src_ptr,
+                              ptrdiff_t src_stride_ptr,
+                              int width,
+                              int source_y_fraction);
+void InterpolateRow_Any_AVX2(uint8_t* dst_ptr,
+                             const uint8_t* src_ptr,
+                             ptrdiff_t src_stride_ptr,
+                             int width,
+                             int source_y_fraction);
+void InterpolateRow_Any_MSA(uint8_t* dst_ptr,
+                            const uint8_t* src_ptr,
+                            ptrdiff_t src_stride_ptr,
+                            int width,
+                            int source_y_fraction);
+void InterpolateRow_Any_LSX(uint8_t* dst_ptr,
+                            const uint8_t* src_ptr,
+                            ptrdiff_t src_stride_ptr,
+                            int width,
+                            int source_y_fraction);
+
+void InterpolateRow_16_C(uint16_t* dst_ptr,
+                         const uint16_t* src_ptr,
+                         ptrdiff_t src_stride,
+                         int width,
+                         int source_y_fraction);
+void InterpolateRow_16_NEON(uint16_t* dst_ptr,
+                            const uint16_t* src_ptr,
+                            ptrdiff_t src_stride,
+                            int width,
+                            int source_y_fraction);
+void InterpolateRow_16_Any_NEON(uint16_t* dst_ptr,
+                                const uint16_t* src_ptr,
+                                ptrdiff_t src_stride,
+                                int width,
+                                int source_y_fraction);
+
+void InterpolateRow_16To8_C(uint8_t* dst_ptr,
+                            const uint16_t* src_ptr,
+                            ptrdiff_t src_stride,
+                            int scale,
+                            int width,
+                            int source_y_fraction);
+void InterpolateRow_16To8_NEON(uint8_t* dst_ptr,
+                               const uint16_t* src_ptr,
+                               ptrdiff_t src_stride,
+                               int scale,
+                               int width,
+                               int source_y_fraction);
+void InterpolateRow_16To8_Any_NEON(uint8_t* dst_ptr,
+                                   const uint16_t* src_ptr,
+                                   ptrdiff_t src_stride,
+                                   int scale,
+                                   int width,
+                                   int source_y_fraction);
+void InterpolateRow_16To8_AVX2(uint8_t* dst_ptr,
+                               const uint16_t* src_ptr,
+                               ptrdiff_t src_stride,
+                               int scale,
+                               int width,
+                               int source_y_fraction);
+void InterpolateRow_16To8_Any_AVX2(uint8_t* dst_ptr,
+                                   const uint16_t* src_ptr,
+                                   ptrdiff_t src_stride,
+                                   int scale,
+                                   int width,
+                                   int source_y_fraction);
+
+// Sobel images.
+void SobelXRow_C(const uint8_t* src_y0,
+                 const uint8_t* src_y1,
+                 const uint8_t* src_y2,
+                 uint8_t* dst_sobelx,
+                 int width);
+void SobelXRow_SSE2(const uint8_t* src_y0,
+                    const uint8_t* src_y1,
+                    const uint8_t* src_y2,
+                    uint8_t* dst_sobelx,
+                    int width);
+void SobelXRow_NEON(const uint8_t* src_y0,
+                    const uint8_t* src_y1,
+                    const uint8_t* src_y2,
+                    uint8_t* dst_sobelx,
+                    int width);
+void SobelXRow_MSA(const uint8_t* src_y0,
+                   const uint8_t* src_y1,
+                   const uint8_t* src_y2,
+                   uint8_t* dst_sobelx,
+                   int width);
+void SobelYRow_C(const uint8_t* src_y0,
+                 const uint8_t* src_y1,
+                 uint8_t* dst_sobely,
+                 int width);
+void SobelYRow_SSE2(const uint8_t* src_y0,
+                    const uint8_t* src_y1,
+                    uint8_t* dst_sobely,
+                    int width);
+void SobelYRow_NEON(const uint8_t* src_y0,
+                    const uint8_t* src_y1,
+                    uint8_t* dst_sobely,
+                    int width);
+void SobelYRow_MSA(const uint8_t* src_y0,
+                   const uint8_t* src_y1,
+                   uint8_t* dst_sobely,
+                   int width);
+void SobelRow_C(const uint8_t* src_sobelx,
+                const uint8_t* src_sobely,
+                uint8_t* dst_argb,
+                int width);
+void SobelRow_SSE2(const uint8_t* src_sobelx,
+                   const uint8_t* src_sobely,
+                   uint8_t* dst_argb,
+                   int width);
+void SobelRow_NEON(const uint8_t* src_sobelx,
+                   const uint8_t* src_sobely,
+                   uint8_t* dst_argb,
+                   int width);
+void SobelRow_MSA(const uint8_t* src_sobelx,
+                  const uint8_t* src_sobely,
+                  uint8_t* dst_argb,
+                  int width);
+void SobelRow_LSX(const uint8_t* src_sobelx,
+                  const uint8_t* src_sobely,
+                  uint8_t* dst_argb,
+                  int width);
+void SobelToPlaneRow_C(const uint8_t* src_sobelx,
+                       const uint8_t* src_sobely,
+                       uint8_t* dst_y,
+                       int width);
+void SobelToPlaneRow_SSE2(const uint8_t* src_sobelx,
+                          const uint8_t* src_sobely,
+                          uint8_t* dst_y,
+                          int width);
+void SobelToPlaneRow_NEON(const uint8_t* src_sobelx,
+                          const uint8_t* src_sobely,
+                          uint8_t* dst_y,
+                          int width);
+void SobelToPlaneRow_MSA(const uint8_t* src_sobelx,
+                         const uint8_t* src_sobely,
+                         uint8_t* dst_y,
+                         int width);
+void SobelToPlaneRow_LSX(const uint8_t* src_sobelx,
+                         const uint8_t* src_sobely,
+                         uint8_t* dst_y,
+                         int width);
+void SobelXYRow_C(const uint8_t* src_sobelx,
+                  const uint8_t* src_sobely,
+                  uint8_t* dst_argb,
+                  int width);
+void SobelXYRow_SSE2(const uint8_t* src_sobelx,
+                     const uint8_t* src_sobely,
+                     uint8_t* dst_argb,
+                     int width);
+void SobelXYRow_NEON(const uint8_t* src_sobelx,
+                     const uint8_t* src_sobely,
+                     uint8_t* dst_argb,
+                     int width);
+void SobelXYRow_MSA(const uint8_t* src_sobelx,
+                    const uint8_t* src_sobely,
+                    uint8_t* dst_argb,
+                    int width);
+void SobelXYRow_LSX(const uint8_t* src_sobelx,
+                    const uint8_t* src_sobely,
+                    uint8_t* dst_argb,
+                    int width);
+void SobelRow_Any_SSE2(const uint8_t* y_buf,
+                       const uint8_t* uv_buf,
+                       uint8_t* dst_ptr,
+                       int width);
+void SobelRow_Any_NEON(const uint8_t* y_buf,
+                       const uint8_t* uv_buf,
+                       uint8_t* dst_ptr,
+                       int width);
+void SobelRow_Any_MSA(const uint8_t* y_buf,
+                      const uint8_t* uv_buf,
+                      uint8_t* dst_ptr,
+                      int width);
+void SobelRow_Any_LSX(const uint8_t* y_buf,
+                      const uint8_t* uv_buf,
+                      uint8_t* dst_ptr,
+                      int width);
+void SobelToPlaneRow_Any_SSE2(const uint8_t* y_buf,
+                              const uint8_t* uv_buf,
+                              uint8_t* dst_ptr,
+                              int width);
+void SobelToPlaneRow_Any_NEON(const uint8_t* y_buf,
+                              const uint8_t* uv_buf,
+                              uint8_t* dst_ptr,
+                              int width);
+void SobelToPlaneRow_Any_MSA(const uint8_t* y_buf,
+                             const uint8_t* uv_buf,
+                             uint8_t* dst_ptr,
+                             int width);
+void SobelToPlaneRow_Any_LSX(const uint8_t* y_buf,
+                             const uint8_t* uv_buf,
+                             uint8_t* dst_ptr,
+                             int width);
+void SobelXYRow_Any_SSE2(const uint8_t* y_buf,
+                         const uint8_t* uv_buf,
+                         uint8_t* dst_ptr,
+                         int width);
+void SobelXYRow_Any_NEON(const uint8_t* y_buf,
+                         const uint8_t* uv_buf,
+                         uint8_t* dst_ptr,
+                         int width);
+void SobelXYRow_Any_MSA(const uint8_t* y_buf,
+                        const uint8_t* uv_buf,
+                        uint8_t* dst_ptr,
+                        int width);
+void SobelXYRow_Any_LSX(const uint8_t* y_buf,
+                        const uint8_t* uv_buf,
+                        uint8_t* dst_ptr,
+                        int width);
+
+void ARGBPolynomialRow_C(const uint8_t* src_argb,
+                         uint8_t* dst_argb,
+                         const float* poly,
+                         int width);
+void ARGBPolynomialRow_SSE2(const uint8_t* src_argb,
+                            uint8_t* dst_argb,
+                            const float* poly,
+                            int width);
+void ARGBPolynomialRow_AVX2(const uint8_t* src_argb,
+                            uint8_t* dst_argb,
+                            const float* poly,
+                            int width);
+
+// Scale and convert to half float.
+void HalfFloatRow_C(const uint16_t* src, uint16_t* dst, float scale, int width);
+void HalfFloatRow_SSE2(const uint16_t* src,
+                       uint16_t* dst,
+                       float scale,
+                       int width);
+void HalfFloatRow_Any_SSE2(const uint16_t* src_ptr,
+                           uint16_t* dst_ptr,
+                           float param,
+                           int width);
+void HalfFloatRow_AVX2(const uint16_t* src,
+                       uint16_t* dst,
+                       float scale,
+                       int width);
+void HalfFloatRow_Any_AVX2(const uint16_t* src_ptr,
+                           uint16_t* dst_ptr,
+                           float param,
+                           int width);
+void HalfFloatRow_F16C(const uint16_t* src,
+                       uint16_t* dst,
+                       float scale,
+                       int width);
+void HalfFloatRow_Any_F16C(const uint16_t* src,
+                           uint16_t* dst,
+                           float scale,
+                           int width);
+void HalfFloat1Row_F16C(const uint16_t* src,
+                        uint16_t* dst,
+                        float scale,
+                        int width);
+void HalfFloat1Row_Any_F16C(const uint16_t* src,
+                            uint16_t* dst,
+                            float scale,
+                            int width);
+void HalfFloatRow_NEON(const uint16_t* src,
+                       uint16_t* dst,
+                       float scale,
+                       int width);
+void HalfFloatRow_Any_NEON(const uint16_t* src_ptr,
+                           uint16_t* dst_ptr,
+                           float param,
+                           int width);
+void HalfFloat1Row_NEON(const uint16_t* src,
+                        uint16_t* dst,
+                        float scale,
+                        int width);
+void HalfFloat1Row_Any_NEON(const uint16_t* src_ptr,
+                            uint16_t* dst_ptr,
+                            float param,
+                            int width);
+void HalfFloatRow_MSA(const uint16_t* src,
+                      uint16_t* dst,
+                      float scale,
+                      int width);
+void HalfFloatRow_Any_MSA(const uint16_t* src_ptr,
+                          uint16_t* dst_ptr,
+                          float param,
+                          int width);
+void HalfFloatRow_LSX(const uint16_t* src,
+                      uint16_t* dst,
+                      float scale,
+                      int width);
+void HalfFloatRow_Any_LSX(const uint16_t* src_ptr,
+                          uint16_t* dst_ptr,
+                          float param,
+                          int width);
+void ByteToFloatRow_C(const uint8_t* src, float* dst, float scale, int width);
+void ByteToFloatRow_NEON(const uint8_t* src,
+                         float* dst,
+                         float scale,
+                         int width);
+void ByteToFloatRow_Any_NEON(const uint8_t* src_ptr,
+                             float* dst_ptr,
+                             float param,
+                             int width);
+
+void ARGBLumaColorTableRow_C(const uint8_t* src_argb,
+                             uint8_t* dst_argb,
+                             int width,
+                             const uint8_t* luma,
+                             uint32_t lumacoeff);
+void ARGBLumaColorTableRow_SSSE3(const uint8_t* src_argb,
+                                 uint8_t* dst_argb,
+                                 int width,
+                                 const uint8_t* luma,
+                                 uint32_t lumacoeff);
+
+float ScaleMaxSamples_C(const float* src, float* dst, float scale, int width);
+float ScaleMaxSamples_NEON(const float* src,
+                           float* dst,
+                           float scale,
+                           int width);
+float ScaleSumSamples_C(const float* src, float* dst, float scale, int width);
+float ScaleSumSamples_NEON(const float* src,
+                           float* dst,
+                           float scale,
+                           int width);
+void ScaleSamples_C(const float* src, float* dst, float scale, int width);
+void ScaleSamples_NEON(const float* src, float* dst, float scale, int width);
+
+void GaussRow_F32_NEON(const float* src, float* dst, int width);
+void GaussRow_F32_C(const float* src, float* dst, int width);
+
+void GaussCol_F32_NEON(const float* src0,
+                       const float* src1,
+                       const float* src2,
+                       const float* src3,
+                       const float* src4,
+                       float* dst,
+                       int width);
+
+void GaussCol_F32_C(const float* src0,
+                    const float* src1,
+                    const float* src2,
+                    const float* src3,
+                    const float* src4,
+                    float* dst,
+                    int width);
+
+#ifdef __cplusplus
+}  // extern "C"
+}  // namespace libyuv
+#endif
+
+#endif  // INCLUDE_LIBYUV_ROW_H_
diff --git a/3rdparty/libyuv/src/include/libyuv/scale.h b/3rdparty/libyuv/src/include/libyuv/scale.h
new file mode 100644
index 00000000..443f89c2
--- /dev/null
+++ b/3rdparty/libyuv/src/include/libyuv/scale.h
@@ -0,0 +1,320 @@
+/*
+ *  Copyright 2011 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#ifndef INCLUDE_LIBYUV_SCALE_H_
+#define INCLUDE_LIBYUV_SCALE_H_
+
+#include "libyuv/basic_types.h"
+
+#ifdef __cplusplus
+namespace libyuv {
+extern "C" {
+#endif
+
+// Supported filtering.
+typedef enum FilterMode {
+  kFilterNone = 0,      // Point sample; Fastest.
+  kFilterLinear = 1,    // Filter horizontally only.
+  kFilterBilinear = 2,  // Faster than box, but lower quality scaling down.
+  kFilterBox = 3        // Highest quality.
+} FilterModeEnum;
+
+// Scale a YUV plane.
+LIBYUV_API
+void ScalePlane(const uint8_t* src,
+                int src_stride,
+                int src_width,
+                int src_height,
+                uint8_t* dst,
+                int dst_stride,
+                int dst_width,
+                int dst_height,
+                enum FilterMode filtering);
+
+LIBYUV_API
+void ScalePlane_16(const uint16_t* src,
+                   int src_stride,
+                   int src_width,
+                   int src_height,
+                   uint16_t* dst,
+                   int dst_stride,
+                   int dst_width,
+                   int dst_height,
+                   enum FilterMode filtering);
+
+// Sample is expected to be in the low 12 bits.
+LIBYUV_API
+void ScalePlane_12(const uint16_t* src,
+                   int src_stride,
+                   int src_width,
+                   int src_height,
+                   uint16_t* dst,
+                   int dst_stride,
+                   int dst_width,
+                   int dst_height,
+                   enum FilterMode filtering);
+
+// Scales a YUV 4:2:0 image from the src width and height to the
+// dst width and height.
+// If filtering is kFilterNone, a simple nearest-neighbor algorithm is
+// used. This produces basic (blocky) quality at the fastest speed.
+// If filtering is kFilterBilinear, interpolation is used to produce a better
+// quality image, at the expense of speed.
+// If filtering is kFilterBox, averaging is used to produce ever better
+// quality image, at further expense of speed.
+// Returns 0 if successful.
+
+LIBYUV_API
+int I420Scale(const uint8_t* src_y,
+              int src_stride_y,
+              const uint8_t* src_u,
+              int src_stride_u,
+              const uint8_t* src_v,
+              int src_stride_v,
+              int src_width,
+              int src_height,
+              uint8_t* dst_y,
+              int dst_stride_y,
+              uint8_t* dst_u,
+              int dst_stride_u,
+              uint8_t* dst_v,
+              int dst_stride_v,
+              int dst_width,
+              int dst_height,
+              enum FilterMode filtering);
+
+LIBYUV_API
+int I420Scale_16(const uint16_t* src_y,
+                 int src_stride_y,
+                 const uint16_t* src_u,
+                 int src_stride_u,
+                 const uint16_t* src_v,
+                 int src_stride_v,
+                 int src_width,
+                 int src_height,
+                 uint16_t* dst_y,
+                 int dst_stride_y,
+                 uint16_t* dst_u,
+                 int dst_stride_u,
+                 uint16_t* dst_v,
+                 int dst_stride_v,
+                 int dst_width,
+                 int dst_height,
+                 enum FilterMode filtering);
+
+LIBYUV_API
+int I420Scale_12(const uint16_t* src_y,
+                 int src_stride_y,
+                 const uint16_t* src_u,
+                 int src_stride_u,
+                 const uint16_t* src_v,
+                 int src_stride_v,
+                 int src_width,
+                 int src_height,
+                 uint16_t* dst_y,
+                 int dst_stride_y,
+                 uint16_t* dst_u,
+                 int dst_stride_u,
+                 uint16_t* dst_v,
+                 int dst_stride_v,
+                 int dst_width,
+                 int dst_height,
+                 enum FilterMode filtering);
+
+// Scales a YUV 4:4:4 image from the src width and height to the
+// dst width and height.
+// If filtering is kFilterNone, a simple nearest-neighbor algorithm is
+// used. This produces basic (blocky) quality at the fastest speed.
+// If filtering is kFilterBilinear, interpolation is used to produce a better
+// quality image, at the expense of speed.
+// If filtering is kFilterBox, averaging is used to produce ever better
+// quality image, at further expense of speed.
+// Returns 0 if successful.
+
+LIBYUV_API
+int I444Scale(const uint8_t* src_y,
+              int src_stride_y,
+              const uint8_t* src_u,
+              int src_stride_u,
+              const uint8_t* src_v,
+              int src_stride_v,
+              int src_width,
+              int src_height,
+              uint8_t* dst_y,
+              int dst_stride_y,
+              uint8_t* dst_u,
+              int dst_stride_u,
+              uint8_t* dst_v,
+              int dst_stride_v,
+              int dst_width,
+              int dst_height,
+              enum FilterMode filtering);
+
+LIBYUV_API
+int I444Scale_16(const uint16_t* src_y,
+                 int src_stride_y,
+                 const uint16_t* src_u,
+                 int src_stride_u,
+                 const uint16_t* src_v,
+                 int src_stride_v,
+                 int src_width,
+                 int src_height,
+                 uint16_t* dst_y,
+                 int dst_stride_y,
+                 uint16_t* dst_u,
+                 int dst_stride_u,
+                 uint16_t* dst_v,
+                 int dst_stride_v,
+                 int dst_width,
+                 int dst_height,
+                 enum FilterMode filtering);
+
+LIBYUV_API
+int I444Scale_12(const uint16_t* src_y,
+                 int src_stride_y,
+                 const uint16_t* src_u,
+                 int src_stride_u,
+                 const uint16_t* src_v,
+                 int src_stride_v,
+                 int src_width,
+                 int src_height,
+                 uint16_t* dst_y,
+                 int dst_stride_y,
+                 uint16_t* dst_u,
+                 int dst_stride_u,
+                 uint16_t* dst_v,
+                 int dst_stride_v,
+                 int dst_width,
+                 int dst_height,
+                 enum FilterMode filtering);
+
+// Scales a YUV 4:2:2 image from the src width and height to the
+// dst width and height.
+// If filtering is kFilterNone, a simple nearest-neighbor algorithm is
+// used. This produces basic (blocky) quality at the fastest speed.
+// If filtering is kFilterBilinear, interpolation is used to produce a better
+// quality image, at the expense of speed.
+// If filtering is kFilterBox, averaging is used to produce ever better
+// quality image, at further expense of speed.
+// Returns 0 if successful.
+LIBYUV_API
+int I422Scale(const uint8_t* src_y,
+              int src_stride_y,
+              const uint8_t* src_u,
+              int src_stride_u,
+              const uint8_t* src_v,
+              int src_stride_v,
+              int src_width,
+              int src_height,
+              uint8_t* dst_y,
+              int dst_stride_y,
+              uint8_t* dst_u,
+              int dst_stride_u,
+              uint8_t* dst_v,
+              int dst_stride_v,
+              int dst_width,
+              int dst_height,
+              enum FilterMode filtering);
+
+LIBYUV_API
+int I422Scale_16(const uint16_t* src_y,
+                 int src_stride_y,
+                 const uint16_t* src_u,
+                 int src_stride_u,
+                 const uint16_t* src_v,
+                 int src_stride_v,
+                 int src_width,
+                 int src_height,
+                 uint16_t* dst_y,
+                 int dst_stride_y,
+                 uint16_t* dst_u,
+                 int dst_stride_u,
+                 uint16_t* dst_v,
+                 int dst_stride_v,
+                 int dst_width,
+                 int dst_height,
+                 enum FilterMode filtering);
+
+LIBYUV_API
+int I422Scale_12(const uint16_t* src_y,
+                 int src_stride_y,
+                 const uint16_t* src_u,
+                 int src_stride_u,
+                 const uint16_t* src_v,
+                 int src_stride_v,
+                 int src_width,
+                 int src_height,
+                 uint16_t* dst_y,
+                 int dst_stride_y,
+                 uint16_t* dst_u,
+                 int dst_stride_u,
+                 uint16_t* dst_v,
+                 int dst_stride_v,
+                 int dst_width,
+                 int dst_height,
+                 enum FilterMode filtering);
+
+// Scales an NV12 image from the src width and height to the
+// dst width and height.
+// If filtering is kFilterNone, a simple nearest-neighbor algorithm is
+// used. This produces basic (blocky) quality at the fastest speed.
+// If filtering is kFilterBilinear, interpolation is used to produce a better
+// quality image, at the expense of speed.
+// kFilterBox is not supported for the UV channel and will be treated as
+// bilinear.
+// Returns 0 if successful.
+
+LIBYUV_API
+int NV12Scale(const uint8_t* src_y,
+              int src_stride_y,
+              const uint8_t* src_uv,
+              int src_stride_uv,
+              int src_width,
+              int src_height,
+              uint8_t* dst_y,
+              int dst_stride_y,
+              uint8_t* dst_uv,
+              int dst_stride_uv,
+              int dst_width,
+              int dst_height,
+              enum FilterMode filtering);
+
+#ifdef __cplusplus
+// Legacy API.  Deprecated.
+LIBYUV_API
+int Scale(const uint8_t* src_y,
+          const uint8_t* src_u,
+          const uint8_t* src_v,
+          int src_stride_y,
+          int src_stride_u,
+          int src_stride_v,
+          int src_width,
+          int src_height,
+          uint8_t* dst_y,
+          uint8_t* dst_u,
+          uint8_t* dst_v,
+          int dst_stride_y,
+          int dst_stride_u,
+          int dst_stride_v,
+          int dst_width,
+          int dst_height,
+          LIBYUV_BOOL interpolate);
+
+// For testing, allow disabling of specialized scalers.
+LIBYUV_API
+void SetUseReferenceImpl(LIBYUV_BOOL use);
+#endif  // __cplusplus
+
+#ifdef __cplusplus
+}  // extern "C"
+}  // namespace libyuv
+#endif
+
+#endif  // INCLUDE_LIBYUV_SCALE_H_
diff --git a/3rdparty/libyuv/src/include/libyuv/scale_argb.h b/3rdparty/libyuv/src/include/libyuv/scale_argb.h
new file mode 100644
index 00000000..7641f18e
--- /dev/null
+++ b/3rdparty/libyuv/src/include/libyuv/scale_argb.h
@@ -0,0 +1,76 @@
+/*
+ *  Copyright 2012 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#ifndef INCLUDE_LIBYUV_SCALE_ARGB_H_
+#define INCLUDE_LIBYUV_SCALE_ARGB_H_
+
+#include "libyuv/basic_types.h"
+#include "libyuv/scale.h"  // For FilterMode
+
+#ifdef __cplusplus
+namespace libyuv {
+extern "C" {
+#endif
+
+LIBYUV_API
+int ARGBScale(const uint8_t* src_argb,
+              int src_stride_argb,
+              int src_width,
+              int src_height,
+              uint8_t* dst_argb,
+              int dst_stride_argb,
+              int dst_width,
+              int dst_height,
+              enum FilterMode filtering);
+
+// Clipped scale takes destination rectangle coordinates for clip values.
+LIBYUV_API
+int ARGBScaleClip(const uint8_t* src_argb,
+                  int src_stride_argb,
+                  int src_width,
+                  int src_height,
+                  uint8_t* dst_argb,
+                  int dst_stride_argb,
+                  int dst_width,
+                  int dst_height,
+                  int clip_x,
+                  int clip_y,
+                  int clip_width,
+                  int clip_height,
+                  enum FilterMode filtering);
+
+// Scale with YUV conversion to ARGB and clipping.
+LIBYUV_API
+int YUVToARGBScaleClip(const uint8_t* src_y,
+                       int src_stride_y,
+                       const uint8_t* src_u,
+                       int src_stride_u,
+                       const uint8_t* src_v,
+                       int src_stride_v,
+                       uint32_t src_fourcc,
+                       int src_width,
+                       int src_height,
+                       uint8_t* dst_argb,
+                       int dst_stride_argb,
+                       uint32_t dst_fourcc,
+                       int dst_width,
+                       int dst_height,
+                       int clip_x,
+                       int clip_y,
+                       int clip_width,
+                       int clip_height,
+                       enum FilterMode filtering);
+
+#ifdef __cplusplus
+}  // extern "C"
+}  // namespace libyuv
+#endif
+
+#endif  // INCLUDE_LIBYUV_SCALE_ARGB_H_
diff --git a/3rdparty/libyuv/src/include/libyuv/scale_rgb.h b/3rdparty/libyuv/src/include/libyuv/scale_rgb.h
new file mode 100644
index 00000000..d17c39fd
--- /dev/null
+++ b/3rdparty/libyuv/src/include/libyuv/scale_rgb.h
@@ -0,0 +1,42 @@
+/*
+ *  Copyright 2022 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#ifndef INCLUDE_LIBYUV_SCALE_RGB_H_
+#define INCLUDE_LIBYUV_SCALE_RGB_H_
+
+#include "libyuv/basic_types.h"
+#include "libyuv/scale.h"  // For FilterMode
+
+#ifdef __cplusplus
+namespace libyuv {
+extern "C" {
+#endif
+
+// RGB can be RAW, RGB24 or YUV24
+// RGB scales 24 bit images by converting a row at a time to ARGB
+// and using ARGB row functions to scale, then convert to RGB.
+// TODO(fbarchard): Allow input/output formats to be specified.
+LIBYUV_API
+int RGBScale(const uint8_t* src_rgb,
+             int src_stride_rgb,
+             int src_width,
+             int src_height,
+             uint8_t* dst_rgb,
+             int dst_stride_rgb,
+             int dst_width,
+             int dst_height,
+             enum FilterMode filtering);
+
+#ifdef __cplusplus
+}  // extern "C"
+}  // namespace libyuv
+#endif
+
+#endif  // INCLUDE_LIBYUV_SCALE_UV_H_
diff --git a/3rdparty/libyuv/src/include/libyuv/scale_row.h b/3rdparty/libyuv/src/include/libyuv/scale_row.h
new file mode 100644
index 00000000..5c474b0c
--- /dev/null
+++ b/3rdparty/libyuv/src/include/libyuv/scale_row.h
@@ -0,0 +1,1709 @@
+/*
+ *  Copyright 2013 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#ifndef INCLUDE_LIBYUV_SCALE_ROW_H_
+#define INCLUDE_LIBYUV_SCALE_ROW_H_
+
+#include "libyuv/basic_types.h"
+#include "libyuv/scale.h"
+
+#ifdef __cplusplus
+namespace libyuv {
+extern "C" {
+#endif
+
+#if defined(__pnacl__) || defined(__CLR_VER) ||            \
+    (defined(__native_client__) && defined(__x86_64__)) || \
+    (defined(__i386__) && !defined(__SSE__) && !defined(__clang__))
+#define LIBYUV_DISABLE_X86
+#endif
+#if defined(__native_client__)
+#define LIBYUV_DISABLE_NEON
+#endif
+// MemorySanitizer does not support assembly code yet. http://crbug.com/344505
+#if defined(__has_feature)
+#if __has_feature(memory_sanitizer)
+#define LIBYUV_DISABLE_X86
+#endif
+#endif
+// GCC >= 4.7.0 required for AVX2.
+#if defined(__GNUC__) && (defined(__x86_64__) || defined(__i386__))
+#if (__GNUC__ > 4) || (__GNUC__ == 4 && (__GNUC_MINOR__ >= 7))
+#define GCC_HAS_AVX2 1
+#endif  // GNUC >= 4.7
+#endif  // __GNUC__
+
+// clang >= 3.4.0 required for AVX2.
+#if defined(__clang__) && (defined(__x86_64__) || defined(__i386__))
+#if (__clang_major__ > 3) || (__clang_major__ == 3 && (__clang_minor__ >= 4))
+#define CLANG_HAS_AVX2 1
+#endif  // clang >= 3.4
+#endif  // __clang__
+
+// Visual C 2012 required for AVX2.
+#if defined(_M_IX86) && !defined(__clang__) && defined(_MSC_VER) && \
+    _MSC_VER >= 1700
+#define VISUALC_HAS_AVX2 1
+#endif  // VisualStudio >= 2012
+
+// The following are available on all x86 platforms:
+#if !defined(LIBYUV_DISABLE_X86) && \
+    (defined(_M_IX86) || defined(__x86_64__) || defined(__i386__))
+#define HAS_FIXEDDIV1_X86
+#define HAS_FIXEDDIV_X86
+#define HAS_SCALEADDROW_SSE2
+#define HAS_SCALEARGBCOLS_SSE2
+#define HAS_SCALEARGBCOLSUP2_SSE2
+#define HAS_SCALEARGBFILTERCOLS_SSSE3
+#define HAS_SCALEARGBROWDOWN2_SSE2
+#define HAS_SCALEARGBROWDOWNEVEN_SSE2
+#define HAS_SCALECOLSUP2_SSE2
+#define HAS_SCALEFILTERCOLS_SSSE3
+#define HAS_SCALEROWDOWN2_SSSE3
+#define HAS_SCALEROWDOWN34_SSSE3
+#define HAS_SCALEROWDOWN38_SSSE3
+#define HAS_SCALEROWDOWN4_SSSE3
+#endif
+
+// The following are available for gcc/clang x86 platforms:
+// TODO(fbarchard): Port to Visual C
+#if !defined(LIBYUV_DISABLE_X86) && (defined(__x86_64__) || defined(__i386__))
+#define HAS_SCALEUVROWDOWN2BOX_SSSE3
+#define HAS_SCALEROWUP2LINEAR_SSE2
+#define HAS_SCALEROWUP2LINEAR_SSSE3
+#define HAS_SCALEROWUP2BILINEAR_SSE2
+#define HAS_SCALEROWUP2BILINEAR_SSSE3
+#define HAS_SCALEROWUP2LINEAR_12_SSSE3
+#define HAS_SCALEROWUP2BILINEAR_12_SSSE3
+#define HAS_SCALEROWUP2LINEAR_16_SSE2
+#define HAS_SCALEROWUP2BILINEAR_16_SSE2
+#define HAS_SCALEUVROWUP2LINEAR_SSSE3
+#define HAS_SCALEUVROWUP2BILINEAR_SSSE3
+#define HAS_SCALEUVROWUP2LINEAR_16_SSE41
+#define HAS_SCALEUVROWUP2BILINEAR_16_SSE41
+#endif
+
+// The following are available for gcc/clang x86 platforms, but
+// require clang 3.4 or gcc 4.7.
+// TODO(fbarchard): Port to Visual C
+#if !defined(LIBYUV_DISABLE_X86) &&               \
+    (defined(__x86_64__) || defined(__i386__)) && \
+    (defined(CLANG_HAS_AVX2) || defined(GCC_HAS_AVX2))
+#define HAS_SCALEUVROWDOWN2BOX_AVX2
+#define HAS_SCALEROWUP2LINEAR_AVX2
+#define HAS_SCALEROWUP2BILINEAR_AVX2
+#define HAS_SCALEROWUP2LINEAR_12_AVX2
+#define HAS_SCALEROWUP2BILINEAR_12_AVX2
+#define HAS_SCALEROWUP2LINEAR_16_AVX2
+#define HAS_SCALEROWUP2BILINEAR_16_AVX2
+#define HAS_SCALEUVROWUP2LINEAR_AVX2
+#define HAS_SCALEUVROWUP2BILINEAR_AVX2
+#define HAS_SCALEUVROWUP2LINEAR_16_AVX2
+#define HAS_SCALEUVROWUP2BILINEAR_16_AVX2
+#endif
+
+// The following are available on all x86 platforms, but
+// require VS2012, clang 3.4 or gcc 4.7.
+// The code supports NaCL but requires a new compiler and validator.
+#if !defined(LIBYUV_DISABLE_X86) &&                          \
+    (defined(VISUALC_HAS_AVX2) || defined(CLANG_HAS_AVX2) || \
+     defined(GCC_HAS_AVX2))
+#define HAS_SCALEADDROW_AVX2
+#define HAS_SCALEROWDOWN2_AVX2
+#define HAS_SCALEROWDOWN4_AVX2
+#endif
+
+// The following are available on Neon platforms:
+#if !defined(LIBYUV_DISABLE_NEON) && \
+    (defined(__ARM_NEON__) || defined(LIBYUV_NEON) || defined(__aarch64__))
+#define HAS_SCALEADDROW_NEON
+#define HAS_SCALEARGBCOLS_NEON
+#define HAS_SCALEARGBFILTERCOLS_NEON
+#define HAS_SCALEARGBROWDOWN2_NEON
+#define HAS_SCALEARGBROWDOWNEVEN_NEON
+#define HAS_SCALEFILTERCOLS_NEON
+#define HAS_SCALEROWDOWN2_NEON
+#define HAS_SCALEROWDOWN34_NEON
+#define HAS_SCALEROWDOWN38_NEON
+#define HAS_SCALEROWDOWN4_NEON
+#define HAS_SCALEUVROWDOWN2BOX_NEON
+#define HAS_SCALEUVROWDOWNEVEN_NEON
+#define HAS_SCALEROWUP2LINEAR_NEON
+#define HAS_SCALEROWUP2BILINEAR_NEON
+#define HAS_SCALEROWUP2LINEAR_12_NEON
+#define HAS_SCALEROWUP2BILINEAR_12_NEON
+#define HAS_SCALEROWUP2LINEAR_16_NEON
+#define HAS_SCALEROWUP2BILINEAR_16_NEON
+#define HAS_SCALEUVROWUP2LINEAR_NEON
+#define HAS_SCALEUVROWUP2BILINEAR_NEON
+#define HAS_SCALEUVROWUP2LINEAR_16_NEON
+#define HAS_SCALEUVROWUP2BILINEAR_16_NEON
+#endif
+
+#if !defined(LIBYUV_DISABLE_MSA) && defined(__mips_msa)
+#define HAS_SCALEADDROW_MSA
+#define HAS_SCALEARGBCOLS_MSA
+#define HAS_SCALEARGBFILTERCOLS_MSA
+#define HAS_SCALEARGBROWDOWN2_MSA
+#define HAS_SCALEARGBROWDOWNEVEN_MSA
+#define HAS_SCALEFILTERCOLS_MSA
+#define HAS_SCALEROWDOWN2_MSA
+#define HAS_SCALEROWDOWN34_MSA
+#define HAS_SCALEROWDOWN38_MSA
+#define HAS_SCALEROWDOWN4_MSA
+#endif
+
+#if !defined(LIBYUV_DISABLE_LSX) && defined(__loongarch_sx)
+#define HAS_SCALEARGBROWDOWN2_LSX
+#define HAS_SCALEARGBROWDOWNEVEN_LSX
+#define HAS_SCALEROWDOWN2_LSX
+#define HAS_SCALEROWDOWN4_LSX
+#define HAS_SCALEROWDOWN38_LSX
+#define HAS_SCALEFILTERCOLS_LSX
+#define HAS_SCALEADDROW_LSX
+#define HAS_SCALEARGBCOLS_LSX
+#define HAS_SCALEARGBFILTERCOLS_LSX
+#define HAS_SCALEROWDOWN34_LSX
+#endif
+
+// Scale ARGB vertically with bilinear interpolation.
+void ScalePlaneVertical(int src_height,
+                        int dst_width,
+                        int dst_height,
+                        int src_stride,
+                        int dst_stride,
+                        const uint8_t* src_argb,
+                        uint8_t* dst_argb,
+                        int x,
+                        int y,
+                        int dy,
+                        int bpp,
+                        enum FilterMode filtering);
+
+void ScalePlaneVertical_16(int src_height,
+                           int dst_width,
+                           int dst_height,
+                           int src_stride,
+                           int dst_stride,
+                           const uint16_t* src_argb,
+                           uint16_t* dst_argb,
+                           int x,
+                           int y,
+                           int dy,
+                           int wpp,
+                           enum FilterMode filtering);
+
+void ScalePlaneVertical_16To8(int src_height,
+                              int dst_width,
+                              int dst_height,
+                              int src_stride,
+                              int dst_stride,
+                              const uint16_t* src_argb,
+                              uint8_t* dst_argb,
+                              int x,
+                              int y,
+                              int dy,
+                              int wpp,
+                              int scale,
+                              enum FilterMode filtering);
+
+// Simplify the filtering based on scale factors.
+enum FilterMode ScaleFilterReduce(int src_width,
+                                  int src_height,
+                                  int dst_width,
+                                  int dst_height,
+                                  enum FilterMode filtering);
+
+// Divide num by div and return as 16.16 fixed point result.
+int FixedDiv_C(int num, int div);
+int FixedDiv_X86(int num, int div);
+int FixedDiv_MIPS(int num, int div);
+// Divide num - 1 by div - 1 and return as 16.16 fixed point result.
+int FixedDiv1_C(int num, int div);
+int FixedDiv1_X86(int num, int div);
+int FixedDiv1_MIPS(int num, int div);
+#ifdef HAS_FIXEDDIV_X86
+#define FixedDiv FixedDiv_X86
+#define FixedDiv1 FixedDiv1_X86
+#elif defined HAS_FIXEDDIV_MIPS
+#define FixedDiv FixedDiv_MIPS
+#define FixedDiv1 FixedDiv1_MIPS
+#else
+#define FixedDiv FixedDiv_C
+#define FixedDiv1 FixedDiv1_C
+#endif
+
+// Compute slope values for stepping.
+void ScaleSlope(int src_width,
+                int src_height,
+                int dst_width,
+                int dst_height,
+                enum FilterMode filtering,
+                int* x,
+                int* y,
+                int* dx,
+                int* dy);
+
+void ScaleRowDown2_C(const uint8_t* src_ptr,
+                     ptrdiff_t src_stride,
+                     uint8_t* dst,
+                     int dst_width);
+void ScaleRowDown2_16_C(const uint16_t* src_ptr,
+                        ptrdiff_t src_stride,
+                        uint16_t* dst,
+                        int dst_width);
+void ScaleRowDown2Linear_C(const uint8_t* src_ptr,
+                           ptrdiff_t src_stride,
+                           uint8_t* dst,
+                           int dst_width);
+void ScaleRowDown2Linear_16_C(const uint16_t* src_ptr,
+                              ptrdiff_t src_stride,
+                              uint16_t* dst,
+                              int dst_width);
+void ScaleRowDown2Box_C(const uint8_t* src_ptr,
+                        ptrdiff_t src_stride,
+                        uint8_t* dst,
+                        int dst_width);
+void ScaleRowDown2Box_Odd_C(const uint8_t* src_ptr,
+                            ptrdiff_t src_stride,
+                            uint8_t* dst,
+                            int dst_width);
+void ScaleRowDown2Box_16_C(const uint16_t* src_ptr,
+                           ptrdiff_t src_stride,
+                           uint16_t* dst,
+                           int dst_width);
+void ScaleRowDown4_C(const uint8_t* src_ptr,
+                     ptrdiff_t src_stride,
+                     uint8_t* dst,
+                     int dst_width);
+void ScaleRowDown4_16_C(const uint16_t* src_ptr,
+                        ptrdiff_t src_stride,
+                        uint16_t* dst,
+                        int dst_width);
+void ScaleRowDown4Box_C(const uint8_t* src_ptr,
+                        ptrdiff_t src_stride,
+                        uint8_t* dst,
+                        int dst_width);
+void ScaleRowDown4Box_16_C(const uint16_t* src_ptr,
+                           ptrdiff_t src_stride,
+                           uint16_t* dst,
+                           int dst_width);
+void ScaleRowDown34_C(const uint8_t* src_ptr,
+                      ptrdiff_t src_stride,
+                      uint8_t* dst,
+                      int dst_width);
+void ScaleRowDown34_16_C(const uint16_t* src_ptr,
+                         ptrdiff_t src_stride,
+                         uint16_t* dst,
+                         int dst_width);
+void ScaleRowDown34_0_Box_C(const uint8_t* src_ptr,
+                            ptrdiff_t src_stride,
+                            uint8_t* d,
+                            int dst_width);
+void ScaleRowDown34_0_Box_16_C(const uint16_t* src_ptr,
+                               ptrdiff_t src_stride,
+                               uint16_t* d,
+                               int dst_width);
+void ScaleRowDown34_1_Box_C(const uint8_t* src_ptr,
+                            ptrdiff_t src_stride,
+                            uint8_t* d,
+                            int dst_width);
+void ScaleRowDown34_1_Box_16_C(const uint16_t* src_ptr,
+                               ptrdiff_t src_stride,
+                               uint16_t* d,
+                               int dst_width);
+
+void ScaleRowUp2_Linear_C(const uint8_t* src_ptr,
+                          uint8_t* dst_ptr,
+                          int dst_width);
+void ScaleRowUp2_Bilinear_C(const uint8_t* src_ptr,
+                            ptrdiff_t src_stride,
+                            uint8_t* dst_ptr,
+                            ptrdiff_t dst_stride,
+                            int dst_width);
+void ScaleRowUp2_Linear_16_C(const uint16_t* src_ptr,
+                             uint16_t* dst_ptr,
+                             int dst_width);
+void ScaleRowUp2_Bilinear_16_C(const uint16_t* src_ptr,
+                               ptrdiff_t src_stride,
+                               uint16_t* dst_ptr,
+                               ptrdiff_t dst_stride,
+                               int dst_width);
+void ScaleRowUp2_Linear_Any_C(const uint8_t* src_ptr,
+                              uint8_t* dst_ptr,
+                              int dst_width);
+void ScaleRowUp2_Bilinear_Any_C(const uint8_t* src_ptr,
+                                ptrdiff_t src_stride,
+                                uint8_t* dst_ptr,
+                                ptrdiff_t dst_stride,
+                                int dst_width);
+void ScaleRowUp2_Linear_16_Any_C(const uint16_t* src_ptr,
+                                 uint16_t* dst_ptr,
+                                 int dst_width);
+void ScaleRowUp2_Bilinear_16_Any_C(const uint16_t* src_ptr,
+                                   ptrdiff_t src_stride,
+                                   uint16_t* dst_ptr,
+                                   ptrdiff_t dst_stride,
+                                   int dst_width);
+
+void ScaleCols_C(uint8_t* dst_ptr,
+                 const uint8_t* src_ptr,
+                 int dst_width,
+                 int x,
+                 int dx);
+void ScaleCols_16_C(uint16_t* dst_ptr,
+                    const uint16_t* src_ptr,
+                    int dst_width,
+                    int x,
+                    int dx);
+void ScaleColsUp2_C(uint8_t* dst_ptr,
+                    const uint8_t* src_ptr,
+                    int dst_width,
+                    int,
+                    int);
+void ScaleColsUp2_16_C(uint16_t* dst_ptr,
+                       const uint16_t* src_ptr,
+                       int dst_width,
+                       int,
+                       int);
+void ScaleFilterCols_C(uint8_t* dst_ptr,
+                       const uint8_t* src_ptr,
+                       int dst_width,
+                       int x,
+                       int dx);
+void ScaleFilterCols_16_C(uint16_t* dst_ptr,
+                          const uint16_t* src_ptr,
+                          int dst_width,
+                          int x,
+                          int dx);
+void ScaleFilterCols64_C(uint8_t* dst_ptr,
+                         const uint8_t* src_ptr,
+                         int dst_width,
+                         int x32,
+                         int dx);
+void ScaleFilterCols64_16_C(uint16_t* dst_ptr,
+                            const uint16_t* src_ptr,
+                            int dst_width,
+                            int x32,
+                            int dx);
+void ScaleRowDown38_C(const uint8_t* src_ptr,
+                      ptrdiff_t src_stride,
+                      uint8_t* dst,
+                      int dst_width);
+void ScaleRowDown38_16_C(const uint16_t* src_ptr,
+                         ptrdiff_t src_stride,
+                         uint16_t* dst,
+                         int dst_width);
+void ScaleRowDown38_3_Box_C(const uint8_t* src_ptr,
+                            ptrdiff_t src_stride,
+                            uint8_t* dst_ptr,
+                            int dst_width);
+void ScaleRowDown38_3_Box_16_C(const uint16_t* src_ptr,
+                               ptrdiff_t src_stride,
+                               uint16_t* dst_ptr,
+                               int dst_width);
+void ScaleRowDown38_2_Box_C(const uint8_t* src_ptr,
+                            ptrdiff_t src_stride,
+                            uint8_t* dst_ptr,
+                            int dst_width);
+void ScaleRowDown38_2_Box_16_C(const uint16_t* src_ptr,
+                               ptrdiff_t src_stride,
+                               uint16_t* dst_ptr,
+                               int dst_width);
+void ScaleAddRow_C(const uint8_t* src_ptr, uint16_t* dst_ptr, int src_width);
+void ScaleAddRow_16_C(const uint16_t* src_ptr,
+                      uint32_t* dst_ptr,
+                      int src_width);
+void ScaleARGBRowDown2_C(const uint8_t* src_argb,
+                         ptrdiff_t src_stride,
+                         uint8_t* dst_argb,
+                         int dst_width);
+void ScaleARGBRowDown2Linear_C(const uint8_t* src_argb,
+                               ptrdiff_t src_stride,
+                               uint8_t* dst_argb,
+                               int dst_width);
+void ScaleARGBRowDown2Box_C(const uint8_t* src_argb,
+                            ptrdiff_t src_stride,
+                            uint8_t* dst_argb,
+                            int dst_width);
+void ScaleARGBRowDownEven_C(const uint8_t* src_argb,
+                            ptrdiff_t src_stride,
+                            int src_stepx,
+                            uint8_t* dst_argb,
+                            int dst_width);
+void ScaleARGBRowDownEvenBox_C(const uint8_t* src_argb,
+                               ptrdiff_t src_stride,
+                               int src_stepx,
+                               uint8_t* dst_argb,
+                               int dst_width);
+void ScaleARGBCols_C(uint8_t* dst_argb,
+                     const uint8_t* src_argb,
+                     int dst_width,
+                     int x,
+                     int dx);
+void ScaleARGBCols64_C(uint8_t* dst_argb,
+                       const uint8_t* src_argb,
+                       int dst_width,
+                       int x32,
+                       int dx);
+void ScaleARGBColsUp2_C(uint8_t* dst_argb,
+                        const uint8_t* src_argb,
+                        int dst_width,
+                        int,
+                        int);
+void ScaleARGBFilterCols_C(uint8_t* dst_argb,
+                           const uint8_t* src_argb,
+                           int dst_width,
+                           int x,
+                           int dx);
+void ScaleARGBFilterCols64_C(uint8_t* dst_argb,
+                             const uint8_t* src_argb,
+                             int dst_width,
+                             int x32,
+                             int dx);
+void ScaleUVRowDown2_C(const uint8_t* src_uv,
+                       ptrdiff_t src_stride,
+                       uint8_t* dst_uv,
+                       int dst_width);
+void ScaleUVRowDown2Linear_C(const uint8_t* src_uv,
+                             ptrdiff_t src_stride,
+                             uint8_t* dst_uv,
+                             int dst_width);
+void ScaleUVRowDown2Box_C(const uint8_t* src_uv,
+                          ptrdiff_t src_stride,
+                          uint8_t* dst_uv,
+                          int dst_width);
+void ScaleUVRowDownEven_C(const uint8_t* src_uv,
+                          ptrdiff_t src_stride,
+                          int src_stepx,
+                          uint8_t* dst_uv,
+                          int dst_width);
+void ScaleUVRowDownEvenBox_C(const uint8_t* src_uv,
+                             ptrdiff_t src_stride,
+                             int src_stepx,
+                             uint8_t* dst_uv,
+                             int dst_width);
+
+void ScaleUVRowUp2_Linear_C(const uint8_t* src_ptr,
+                            uint8_t* dst_ptr,
+                            int dst_width);
+void ScaleUVRowUp2_Bilinear_C(const uint8_t* src_ptr,
+                              ptrdiff_t src_stride,
+                              uint8_t* dst_ptr,
+                              ptrdiff_t dst_stride,
+                              int dst_width);
+void ScaleUVRowUp2_Linear_Any_C(const uint8_t* src_ptr,
+                                uint8_t* dst_ptr,
+                                int dst_width);
+void ScaleUVRowUp2_Bilinear_Any_C(const uint8_t* src_ptr,
+                                  ptrdiff_t src_stride,
+                                  uint8_t* dst_ptr,
+                                  ptrdiff_t dst_stride,
+                                  int dst_width);
+void ScaleUVRowUp2_Linear_16_C(const uint16_t* src_ptr,
+                               uint16_t* dst_ptr,
+                               int dst_width);
+void ScaleUVRowUp2_Bilinear_16_C(const uint16_t* src_ptr,
+                                 ptrdiff_t src_stride,
+                                 uint16_t* dst_ptr,
+                                 ptrdiff_t dst_stride,
+                                 int dst_width);
+void ScaleUVRowUp2_Linear_16_Any_C(const uint16_t* src_ptr,
+                                   uint16_t* dst_ptr,
+                                   int dst_width);
+void ScaleUVRowUp2_Bilinear_16_Any_C(const uint16_t* src_ptr,
+                                     ptrdiff_t src_stride,
+                                     uint16_t* dst_ptr,
+                                     ptrdiff_t dst_stride,
+                                     int dst_width);
+
+void ScaleUVCols_C(uint8_t* dst_uv,
+                   const uint8_t* src_uv,
+                   int dst_width,
+                   int x,
+                   int dx);
+void ScaleUVCols64_C(uint8_t* dst_uv,
+                     const uint8_t* src_uv,
+                     int dst_width,
+                     int x32,
+                     int dx);
+void ScaleUVColsUp2_C(uint8_t* dst_uv,
+                      const uint8_t* src_uv,
+                      int dst_width,
+                      int,
+                      int);
+void ScaleUVFilterCols_C(uint8_t* dst_uv,
+                         const uint8_t* src_uv,
+                         int dst_width,
+                         int x,
+                         int dx);
+void ScaleUVFilterCols64_C(uint8_t* dst_uv,
+                           const uint8_t* src_uv,
+                           int dst_width,
+                           int x32,
+                           int dx);
+
+// Specialized scalers for x86.
+void ScaleRowDown2_SSSE3(const uint8_t* src_ptr,
+                         ptrdiff_t src_stride,
+                         uint8_t* dst_ptr,
+                         int dst_width);
+void ScaleRowDown2Linear_SSSE3(const uint8_t* src_ptr,
+                               ptrdiff_t src_stride,
+                               uint8_t* dst_ptr,
+                               int dst_width);
+void ScaleRowDown2Box_SSSE3(const uint8_t* src_ptr,
+                            ptrdiff_t src_stride,
+                            uint8_t* dst_ptr,
+                            int dst_width);
+void ScaleRowDown2_AVX2(const uint8_t* src_ptr,
+                        ptrdiff_t src_stride,
+                        uint8_t* dst_ptr,
+                        int dst_width);
+void ScaleRowDown2Linear_AVX2(const uint8_t* src_ptr,
+                              ptrdiff_t src_stride,
+                              uint8_t* dst_ptr,
+                              int dst_width);
+void ScaleRowDown2Box_AVX2(const uint8_t* src_ptr,
+                           ptrdiff_t src_stride,
+                           uint8_t* dst_ptr,
+                           int dst_width);
+void ScaleRowDown4_SSSE3(const uint8_t* src_ptr,
+                         ptrdiff_t src_stride,
+                         uint8_t* dst_ptr,
+                         int dst_width);
+void ScaleRowDown4Box_SSSE3(const uint8_t* src_ptr,
+                            ptrdiff_t src_stride,
+                            uint8_t* dst_ptr,
+                            int dst_width);
+void ScaleRowDown4_AVX2(const uint8_t* src_ptr,
+                        ptrdiff_t src_stride,
+                        uint8_t* dst_ptr,
+                        int dst_width);
+void ScaleRowDown4Box_AVX2(const uint8_t* src_ptr,
+                           ptrdiff_t src_stride,
+                           uint8_t* dst_ptr,
+                           int dst_width);
+
+void ScaleRowDown34_SSSE3(const uint8_t* src_ptr,
+                          ptrdiff_t src_stride,
+                          uint8_t* dst_ptr,
+                          int dst_width);
+void ScaleRowDown34_1_Box_SSSE3(const uint8_t* src_ptr,
+                                ptrdiff_t src_stride,
+                                uint8_t* dst_ptr,
+                                int dst_width);
+void ScaleRowDown34_0_Box_SSSE3(const uint8_t* src_ptr,
+                                ptrdiff_t src_stride,
+                                uint8_t* dst_ptr,
+                                int dst_width);
+void ScaleRowDown38_SSSE3(const uint8_t* src_ptr,
+                          ptrdiff_t src_stride,
+                          uint8_t* dst_ptr,
+                          int dst_width);
+void ScaleRowDown38_3_Box_SSSE3(const uint8_t* src_ptr,
+                                ptrdiff_t src_stride,
+                                uint8_t* dst_ptr,
+                                int dst_width);
+void ScaleRowDown38_2_Box_SSSE3(const uint8_t* src_ptr,
+                                ptrdiff_t src_stride,
+                                uint8_t* dst_ptr,
+                                int dst_width);
+
+void ScaleRowUp2_Linear_SSE2(const uint8_t* src_ptr,
+                             uint8_t* dst_ptr,
+                             int dst_width);
+void ScaleRowUp2_Bilinear_SSE2(const uint8_t* src_ptr,
+                               ptrdiff_t src_stride,
+                               uint8_t* dst_ptr,
+                               ptrdiff_t dst_stride,
+                               int dst_width);
+void ScaleRowUp2_Linear_12_SSSE3(const uint16_t* src_ptr,
+                                 uint16_t* dst_ptr,
+                                 int dst_width);
+void ScaleRowUp2_Bilinear_12_SSSE3(const uint16_t* src_ptr,
+                                   ptrdiff_t src_stride,
+                                   uint16_t* dst_ptr,
+                                   ptrdiff_t dst_stride,
+                                   int dst_width);
+void ScaleRowUp2_Linear_16_SSE2(const uint16_t* src_ptr,
+                                uint16_t* dst_ptr,
+                                int dst_width);
+void ScaleRowUp2_Bilinear_16_SSE2(const uint16_t* src_ptr,
+                                  ptrdiff_t src_stride,
+                                  uint16_t* dst_ptr,
+                                  ptrdiff_t dst_stride,
+                                  int dst_width);
+void ScaleRowUp2_Linear_SSSE3(const uint8_t* src_ptr,
+                              uint8_t* dst_ptr,
+                              int dst_width);
+void ScaleRowUp2_Bilinear_SSSE3(const uint8_t* src_ptr,
+                                ptrdiff_t src_stride,
+                                uint8_t* dst_ptr,
+                                ptrdiff_t dst_stride,
+                                int dst_width);
+void ScaleRowUp2_Linear_AVX2(const uint8_t* src_ptr,
+                             uint8_t* dst_ptr,
+                             int dst_width);
+void ScaleRowUp2_Bilinear_AVX2(const uint8_t* src_ptr,
+                               ptrdiff_t src_stride,
+                               uint8_t* dst_ptr,
+                               ptrdiff_t dst_stride,
+                               int dst_width);
+void ScaleRowUp2_Linear_12_AVX2(const uint16_t* src_ptr,
+                                uint16_t* dst_ptr,
+                                int dst_width);
+void ScaleRowUp2_Bilinear_12_AVX2(const uint16_t* src_ptr,
+                                  ptrdiff_t src_stride,
+                                  uint16_t* dst_ptr,
+                                  ptrdiff_t dst_stride,
+                                  int dst_width);
+void ScaleRowUp2_Linear_16_AVX2(const uint16_t* src_ptr,
+                                uint16_t* dst_ptr,
+                                int dst_width);
+void ScaleRowUp2_Bilinear_16_AVX2(const uint16_t* src_ptr,
+                                  ptrdiff_t src_stride,
+                                  uint16_t* dst_ptr,
+                                  ptrdiff_t dst_stride,
+                                  int dst_width);
+void ScaleRowUp2_Linear_Any_SSE2(const uint8_t* src_ptr,
+                                 uint8_t* dst_ptr,
+                                 int dst_width);
+void ScaleRowUp2_Bilinear_Any_SSE2(const uint8_t* src_ptr,
+                                   ptrdiff_t src_stride,
+                                   uint8_t* dst_ptr,
+                                   ptrdiff_t dst_stride,
+                                   int dst_width);
+void ScaleRowUp2_Linear_12_Any_SSSE3(const uint16_t* src_ptr,
+                                     uint16_t* dst_ptr,
+                                     int dst_width);
+void ScaleRowUp2_Bilinear_12_Any_SSSE3(const uint16_t* src_ptr,
+                                       ptrdiff_t src_stride,
+                                       uint16_t* dst_ptr,
+                                       ptrdiff_t dst_stride,
+                                       int dst_width);
+void ScaleRowUp2_Linear_16_Any_SSE2(const uint16_t* src_ptr,
+                                    uint16_t* dst_ptr,
+                                    int dst_width);
+void ScaleRowUp2_Bilinear_16_Any_SSSE3(const uint16_t* src_ptr,
+                                       ptrdiff_t src_stride,
+                                       uint16_t* dst_ptr,
+                                       ptrdiff_t dst_stride,
+                                       int dst_width);
+void ScaleRowUp2_Linear_Any_SSSE3(const uint8_t* src_ptr,
+                                  uint8_t* dst_ptr,
+                                  int dst_width);
+void ScaleRowUp2_Bilinear_Any_SSSE3(const uint8_t* src_ptr,
+                                    ptrdiff_t src_stride,
+                                    uint8_t* dst_ptr,
+                                    ptrdiff_t dst_stride,
+                                    int dst_width);
+void ScaleRowUp2_Linear_Any_AVX2(const uint8_t* src_ptr,
+                                 uint8_t* dst_ptr,
+                                 int dst_width);
+void ScaleRowUp2_Bilinear_Any_AVX2(const uint8_t* src_ptr,
+                                   ptrdiff_t src_stride,
+                                   uint8_t* dst_ptr,
+                                   ptrdiff_t dst_stride,
+                                   int dst_width);
+void ScaleRowUp2_Linear_12_Any_AVX2(const uint16_t* src_ptr,
+                                    uint16_t* dst_ptr,
+                                    int dst_width);
+void ScaleRowUp2_Bilinear_12_Any_AVX2(const uint16_t* src_ptr,
+                                      ptrdiff_t src_stride,
+                                      uint16_t* dst_ptr,
+                                      ptrdiff_t dst_stride,
+                                      int dst_width);
+void ScaleRowUp2_Linear_16_Any_AVX2(const uint16_t* src_ptr,
+                                    uint16_t* dst_ptr,
+                                    int dst_width);
+void ScaleRowUp2_Bilinear_16_Any_AVX2(const uint16_t* src_ptr,
+                                      ptrdiff_t src_stride,
+                                      uint16_t* dst_ptr,
+                                      ptrdiff_t dst_stride,
+                                      int dst_width);
+
+void ScaleRowDown2_Any_SSSE3(const uint8_t* src_ptr,
+                             ptrdiff_t src_stride,
+                             uint8_t* dst_ptr,
+                             int dst_width);
+void ScaleRowDown2Linear_Any_SSSE3(const uint8_t* src_ptr,
+                                   ptrdiff_t src_stride,
+                                   uint8_t* dst_ptr,
+                                   int dst_width);
+void ScaleRowDown2Box_Any_SSSE3(const uint8_t* src_ptr,
+                                ptrdiff_t src_stride,
+                                uint8_t* dst_ptr,
+                                int dst_width);
+void ScaleRowDown2Box_Odd_SSSE3(const uint8_t* src_ptr,
+                                ptrdiff_t src_stride,
+                                uint8_t* dst_ptr,
+                                int dst_width);
+void ScaleRowDown2_Any_AVX2(const uint8_t* src_ptr,
+                            ptrdiff_t src_stride,
+                            uint8_t* dst_ptr,
+                            int dst_width);
+void ScaleRowDown2Linear_Any_AVX2(const uint8_t* src_ptr,
+                                  ptrdiff_t src_stride,
+                                  uint8_t* dst_ptr,
+                                  int dst_width);
+void ScaleRowDown2Box_Any_AVX2(const uint8_t* src_ptr,
+                               ptrdiff_t src_stride,
+                               uint8_t* dst_ptr,
+                               int dst_width);
+void ScaleRowDown2Box_Odd_AVX2(const uint8_t* src_ptr,
+                               ptrdiff_t src_stride,
+                               uint8_t* dst_ptr,
+                               int dst_width);
+void ScaleRowDown4_Any_SSSE3(const uint8_t* src_ptr,
+                             ptrdiff_t src_stride,
+                             uint8_t* dst_ptr,
+                             int dst_width);
+void ScaleRowDown4Box_Any_SSSE3(const uint8_t* src_ptr,
+                                ptrdiff_t src_stride,
+                                uint8_t* dst_ptr,
+                                int dst_width);
+void ScaleRowDown4_Any_AVX2(const uint8_t* src_ptr,
+                            ptrdiff_t src_stride,
+                            uint8_t* dst_ptr,
+                            int dst_width);
+void ScaleRowDown4Box_Any_AVX2(const uint8_t* src_ptr,
+                               ptrdiff_t src_stride,
+                               uint8_t* dst_ptr,
+                               int dst_width);
+
+void ScaleRowDown34_Any_SSSE3(const uint8_t* src_ptr,
+                              ptrdiff_t src_stride,
+                              uint8_t* dst_ptr,
+                              int dst_width);
+void ScaleRowDown34_1_Box_Any_SSSE3(const uint8_t* src_ptr,
+                                    ptrdiff_t src_stride,
+                                    uint8_t* dst_ptr,
+                                    int dst_width);
+void ScaleRowDown34_0_Box_Any_SSSE3(const uint8_t* src_ptr,
+                                    ptrdiff_t src_stride,
+                                    uint8_t* dst_ptr,
+                                    int dst_width);
+void ScaleRowDown38_Any_SSSE3(const uint8_t* src_ptr,
+                              ptrdiff_t src_stride,
+                              uint8_t* dst_ptr,
+                              int dst_width);
+void ScaleRowDown38_3_Box_Any_SSSE3(const uint8_t* src_ptr,
+                                    ptrdiff_t src_stride,
+                                    uint8_t* dst_ptr,
+                                    int dst_width);
+void ScaleRowDown38_2_Box_Any_SSSE3(const uint8_t* src_ptr,
+                                    ptrdiff_t src_stride,
+                                    uint8_t* dst_ptr,
+                                    int dst_width);
+
+void ScaleAddRow_SSE2(const uint8_t* src_ptr, uint16_t* dst_ptr, int src_width);
+void ScaleAddRow_AVX2(const uint8_t* src_ptr, uint16_t* dst_ptr, int src_width);
+void ScaleAddRow_Any_SSE2(const uint8_t* src_ptr,
+                          uint16_t* dst_ptr,
+                          int src_width);
+void ScaleAddRow_Any_AVX2(const uint8_t* src_ptr,
+                          uint16_t* dst_ptr,
+                          int src_width);
+
+void ScaleFilterCols_SSSE3(uint8_t* dst_ptr,
+                           const uint8_t* src_ptr,
+                           int dst_width,
+                           int x,
+                           int dx);
+void ScaleColsUp2_SSE2(uint8_t* dst_ptr,
+                       const uint8_t* src_ptr,
+                       int dst_width,
+                       int x,
+                       int dx);
+
+// ARGB Column functions
+void ScaleARGBCols_SSE2(uint8_t* dst_argb,
+                        const uint8_t* src_argb,
+                        int dst_width,
+                        int x,
+                        int dx);
+void ScaleARGBFilterCols_SSSE3(uint8_t* dst_argb,
+                               const uint8_t* src_argb,
+                               int dst_width,
+                               int x,
+                               int dx);
+void ScaleARGBColsUp2_SSE2(uint8_t* dst_argb,
+                           const uint8_t* src_argb,
+                           int dst_width,
+                           int x,
+                           int dx);
+void ScaleARGBFilterCols_NEON(uint8_t* dst_argb,
+                              const uint8_t* src_argb,
+                              int dst_width,
+                              int x,
+                              int dx);
+void ScaleARGBCols_NEON(uint8_t* dst_argb,
+                        const uint8_t* src_argb,
+                        int dst_width,
+                        int x,
+                        int dx);
+void ScaleARGBFilterCols_Any_NEON(uint8_t* dst_ptr,
+                                  const uint8_t* src_ptr,
+                                  int dst_width,
+                                  int x,
+                                  int dx);
+void ScaleARGBCols_Any_NEON(uint8_t* dst_ptr,
+                            const uint8_t* src_ptr,
+                            int dst_width,
+                            int x,
+                            int dx);
+void ScaleARGBFilterCols_MSA(uint8_t* dst_argb,
+                             const uint8_t* src_argb,
+                             int dst_width,
+                             int x,
+                             int dx);
+void ScaleARGBCols_MSA(uint8_t* dst_argb,
+                       const uint8_t* src_argb,
+                       int dst_width,
+                       int x,
+                       int dx);
+void ScaleARGBFilterCols_Any_MSA(uint8_t* dst_ptr,
+                                 const uint8_t* src_ptr,
+                                 int dst_width,
+                                 int x,
+                                 int dx);
+void ScaleARGBCols_Any_MSA(uint8_t* dst_ptr,
+                           const uint8_t* src_ptr,
+                           int dst_width,
+                           int x,
+                           int dx);
+
+// ARGB Row functions
+void ScaleARGBRowDown2_SSE2(const uint8_t* src_argb,
+                            ptrdiff_t src_stride,
+                            uint8_t* dst_argb,
+                            int dst_width);
+void ScaleARGBRowDown2Linear_SSE2(const uint8_t* src_argb,
+                                  ptrdiff_t src_stride,
+                                  uint8_t* dst_argb,
+                                  int dst_width);
+void ScaleARGBRowDown2Box_SSE2(const uint8_t* src_argb,
+                               ptrdiff_t src_stride,
+                               uint8_t* dst_argb,
+                               int dst_width);
+void ScaleARGBRowDown2_NEON(const uint8_t* src_ptr,
+                            ptrdiff_t src_stride,
+                            uint8_t* dst,
+                            int dst_width);
+void ScaleARGBRowDown2Linear_NEON(const uint8_t* src_argb,
+                                  ptrdiff_t src_stride,
+                                  uint8_t* dst_argb,
+                                  int dst_width);
+void ScaleARGBRowDown2Box_NEON(const uint8_t* src_ptr,
+                               ptrdiff_t src_stride,
+                               uint8_t* dst,
+                               int dst_width);
+void ScaleARGBRowDown2_MSA(const uint8_t* src_argb,
+                           ptrdiff_t src_stride,
+                           uint8_t* dst_argb,
+                           int dst_width);
+void ScaleARGBRowDown2Linear_MSA(const uint8_t* src_argb,
+                                 ptrdiff_t src_stride,
+                                 uint8_t* dst_argb,
+                                 int dst_width);
+void ScaleARGBRowDown2Box_MSA(const uint8_t* src_argb,
+                              ptrdiff_t src_stride,
+                              uint8_t* dst_argb,
+                              int dst_width);
+void ScaleARGBRowDown2_LSX(const uint8_t* src_argb,
+                           ptrdiff_t src_stride,
+                           uint8_t* dst_argb,
+                           int dst_width);
+void ScaleARGBRowDown2Linear_LSX(const uint8_t* src_argb,
+                                 ptrdiff_t src_stride,
+                                 uint8_t* dst_argb,
+                                 int dst_width);
+void ScaleARGBRowDown2Box_LSX(const uint8_t* src_argb,
+                              ptrdiff_t src_stride,
+                              uint8_t* dst_argb,
+                              int dst_width);
+void ScaleARGBRowDown2_Any_SSE2(const uint8_t* src_ptr,
+                                ptrdiff_t src_stride,
+                                uint8_t* dst_ptr,
+                                int dst_width);
+void ScaleARGBRowDown2Linear_Any_SSE2(const uint8_t* src_ptr,
+                                      ptrdiff_t src_stride,
+                                      uint8_t* dst_ptr,
+                                      int dst_width);
+void ScaleARGBRowDown2Box_Any_SSE2(const uint8_t* src_ptr,
+                                   ptrdiff_t src_stride,
+                                   uint8_t* dst_ptr,
+                                   int dst_width);
+void ScaleARGBRowDown2_Any_NEON(const uint8_t* src_ptr,
+                                ptrdiff_t src_stride,
+                                uint8_t* dst_ptr,
+                                int dst_width);
+void ScaleARGBRowDown2Linear_Any_NEON(const uint8_t* src_ptr,
+                                      ptrdiff_t src_stride,
+                                      uint8_t* dst_ptr,
+                                      int dst_width);
+void ScaleARGBRowDown2Box_Any_NEON(const uint8_t* src_ptr,
+                                   ptrdiff_t src_stride,
+                                   uint8_t* dst_ptr,
+                                   int dst_width);
+void ScaleARGBRowDown2_Any_MSA(const uint8_t* src_ptr,
+                               ptrdiff_t src_stride,
+                               uint8_t* dst_ptr,
+                               int dst_width);
+void ScaleARGBRowDown2Linear_Any_MSA(const uint8_t* src_ptr,
+                                     ptrdiff_t src_stride,
+                                     uint8_t* dst_ptr,
+                                     int dst_width);
+void ScaleARGBRowDown2Box_Any_MSA(const uint8_t* src_ptr,
+                                  ptrdiff_t src_stride,
+                                  uint8_t* dst_ptr,
+                                  int dst_width);
+void ScaleARGBRowDown2_Any_LSX(const uint8_t* src_ptr,
+                               ptrdiff_t src_stride,
+                               uint8_t* dst_ptr,
+                               int dst_width);
+void ScaleARGBRowDown2Linear_Any_LSX(const uint8_t* src_ptr,
+                                     ptrdiff_t src_stride,
+                                     uint8_t* dst_ptr,
+                                     int dst_width);
+void ScaleARGBRowDown2Box_Any_LSX(const uint8_t* src_ptr,
+                                  ptrdiff_t src_stride,
+                                  uint8_t* dst_ptr,
+                                  int dst_width);
+void ScaleARGBRowDownEven_SSE2(const uint8_t* src_argb,
+                               ptrdiff_t src_stride,
+                               int src_stepx,
+                               uint8_t* dst_argb,
+                               int dst_width);
+void ScaleARGBRowDownEvenBox_SSE2(const uint8_t* src_argb,
+                                  ptrdiff_t src_stride,
+                                  int src_stepx,
+                                  uint8_t* dst_argb,
+                                  int dst_width);
+void ScaleARGBRowDownEven_NEON(const uint8_t* src_argb,
+                               ptrdiff_t src_stride,
+                               int src_stepx,
+                               uint8_t* dst_argb,
+                               int dst_width);
+void ScaleARGBRowDownEvenBox_NEON(const uint8_t* src_argb,
+                                  ptrdiff_t src_stride,
+                                  int src_stepx,
+                                  uint8_t* dst_argb,
+                                  int dst_width);
+void ScaleARGBRowDownEven_MSA(const uint8_t* src_argb,
+                              ptrdiff_t src_stride,
+                              int32_t src_stepx,
+                              uint8_t* dst_argb,
+                              int dst_width);
+void ScaleARGBRowDownEvenBox_MSA(const uint8_t* src_argb,
+                                 ptrdiff_t src_stride,
+                                 int src_stepx,
+                                 uint8_t* dst_argb,
+                                 int dst_width);
+void ScaleARGBRowDownEven_LSX(const uint8_t* src_argb,
+                              ptrdiff_t src_stride,
+                              int32_t src_stepx,
+                              uint8_t* dst_argb,
+                              int dst_width);
+void ScaleARGBRowDownEvenBox_LSX(const uint8_t* src_argb,
+                                 ptrdiff_t src_stride,
+                                 int src_stepx,
+                                 uint8_t* dst_argb,
+                                 int dst_width);
+void ScaleARGBRowDownEven_Any_SSE2(const uint8_t* src_ptr,
+                                   ptrdiff_t src_stride,
+                                   int src_stepx,
+                                   uint8_t* dst_ptr,
+                                   int dst_width);
+void ScaleARGBRowDownEvenBox_Any_SSE2(const uint8_t* src_ptr,
+                                      ptrdiff_t src_stride,
+                                      int src_stepx,
+                                      uint8_t* dst_ptr,
+                                      int dst_width);
+void ScaleARGBRowDownEven_Any_NEON(const uint8_t* src_ptr,
+                                   ptrdiff_t src_stride,
+                                   int src_stepx,
+                                   uint8_t* dst_ptr,
+                                   int dst_width);
+void ScaleARGBRowDownEvenBox_Any_NEON(const uint8_t* src_ptr,
+                                      ptrdiff_t src_stride,
+                                      int src_stepx,
+                                      uint8_t* dst_ptr,
+                                      int dst_width);
+void ScaleARGBRowDownEven_Any_MSA(const uint8_t* src_ptr,
+                                  ptrdiff_t src_stride,
+                                  int32_t src_stepx,
+                                  uint8_t* dst_ptr,
+                                  int dst_width);
+void ScaleARGBRowDownEvenBox_Any_MSA(const uint8_t* src_ptr,
+                                     ptrdiff_t src_stride,
+                                     int src_stepx,
+                                     uint8_t* dst_ptr,
+                                     int dst_width);
+void ScaleARGBRowDownEven_Any_LSX(const uint8_t* src_ptr,
+                                  ptrdiff_t src_stride,
+                                  int32_t src_stepx,
+                                  uint8_t* dst_ptr,
+                                  int dst_width);
+void ScaleARGBRowDownEvenBox_Any_LSX(const uint8_t* src_ptr,
+                                     ptrdiff_t src_stride,
+                                     int src_stepx,
+                                     uint8_t* dst_ptr,
+                                     int dst_width);
+
+// UV Row functions
+void ScaleUVRowDown2_SSSE3(const uint8_t* src_ptr,
+                           ptrdiff_t src_stride,
+                           uint8_t* dst_uv,
+                           int dst_width);
+void ScaleUVRowDown2Linear_SSSE3(const uint8_t* src_ptr,
+                                 ptrdiff_t src_stride,
+                                 uint8_t* dst_uv,
+                                 int dst_width);
+void ScaleUVRowDown2Box_SSSE3(const uint8_t* src_ptr,
+                              ptrdiff_t src_stride,
+                              uint8_t* dst_uv,
+                              int dst_width);
+void ScaleUVRowDown2Box_AVX2(const uint8_t* src_ptr,
+                             ptrdiff_t src_stride,
+                             uint8_t* dst_uv,
+                             int dst_width);
+void ScaleUVRowDown2_NEON(const uint8_t* src_ptr,
+                          ptrdiff_t src_stride,
+                          uint8_t* dst,
+                          int dst_width);
+void ScaleUVRowDown2Linear_NEON(const uint8_t* src_ptr,
+                                ptrdiff_t src_stride,
+                                uint8_t* dst_uv,
+                                int dst_width);
+void ScaleUVRowDown2Box_NEON(const uint8_t* src_ptr,
+                             ptrdiff_t src_stride,
+                             uint8_t* dst,
+                             int dst_width);
+void ScaleUVRowDown2_MSA(const uint8_t* src_ptr,
+                         ptrdiff_t src_stride,
+                         uint8_t* dst_uv,
+                         int dst_width);
+void ScaleUVRowDown2Linear_MSA(const uint8_t* src_ptr,
+                               ptrdiff_t src_stride,
+                               uint8_t* dst_uv,
+                               int dst_width);
+void ScaleUVRowDown2Box_MSA(const uint8_t* src_ptr,
+                            ptrdiff_t src_stride,
+                            uint8_t* dst_uv,
+                            int dst_width);
+void ScaleUVRowDown2_Any_SSSE3(const uint8_t* src_ptr,
+                               ptrdiff_t src_stride,
+                               uint8_t* dst_ptr,
+                               int dst_width);
+void ScaleUVRowDown2Linear_Any_SSSE3(const uint8_t* src_ptr,
+                                     ptrdiff_t src_stride,
+                                     uint8_t* dst_ptr,
+                                     int dst_width);
+void ScaleUVRowDown2Box_Any_SSSE3(const uint8_t* src_ptr,
+                                  ptrdiff_t src_stride,
+                                  uint8_t* dst_ptr,
+                                  int dst_width);
+void ScaleUVRowDown2Box_Any_AVX2(const uint8_t* src_ptr,
+                                 ptrdiff_t src_stride,
+                                 uint8_t* dst_ptr,
+                                 int dst_width);
+void ScaleUVRowDown2_Any_NEON(const uint8_t* src_ptr,
+                              ptrdiff_t src_stride,
+                              uint8_t* dst_ptr,
+                              int dst_width);
+void ScaleUVRowDown2Linear_Any_NEON(const uint8_t* src_ptr,
+                                    ptrdiff_t src_stride,
+                                    uint8_t* dst_ptr,
+                                    int dst_width);
+void ScaleUVRowDown2Box_Any_NEON(const uint8_t* src_ptr,
+                                 ptrdiff_t src_stride,
+                                 uint8_t* dst_ptr,
+                                 int dst_width);
+void ScaleUVRowDown2_Any_MSA(const uint8_t* src_ptr,
+                             ptrdiff_t src_stride,
+                             uint8_t* dst_ptr,
+                             int dst_width);
+void ScaleUVRowDown2Linear_Any_MSA(const uint8_t* src_ptr,
+                                   ptrdiff_t src_stride,
+                                   uint8_t* dst_ptr,
+                                   int dst_width);
+void ScaleUVRowDown2Box_Any_MSA(const uint8_t* src_ptr,
+                                ptrdiff_t src_stride,
+                                uint8_t* dst_ptr,
+                                int dst_width);
+void ScaleUVRowDownEven_SSSE3(const uint8_t* src_ptr,
+                              ptrdiff_t src_stride,
+                              int src_stepx,
+                              uint8_t* dst_uv,
+                              int dst_width);
+void ScaleUVRowDownEvenBox_SSSE3(const uint8_t* src_ptr,
+                                 ptrdiff_t src_stride,
+                                 int src_stepx,
+                                 uint8_t* dst_uv,
+                                 int dst_width);
+void ScaleUVRowDownEven_NEON(const uint8_t* src_ptr,
+                             ptrdiff_t src_stride,
+                             int src_stepx,
+                             uint8_t* dst_uv,
+                             int dst_width);
+void ScaleUVRowDownEvenBox_NEON(const uint8_t* src_ptr,
+                                ptrdiff_t src_stride,
+                                int src_stepx,
+                                uint8_t* dst_uv,
+                                int dst_width);
+void ScaleUVRowDownEven_MSA(const uint8_t* src_ptr,
+                            ptrdiff_t src_stride,
+                            int32_t src_stepx,
+                            uint8_t* dst_uv,
+                            int dst_width);
+void ScaleUVRowDownEvenBox_MSA(const uint8_t* src_ptr,
+                               ptrdiff_t src_stride,
+                               int src_stepx,
+                               uint8_t* dst_uv,
+                               int dst_width);
+void ScaleUVRowDownEven_Any_SSSE3(const uint8_t* src_ptr,
+                                  ptrdiff_t src_stride,
+                                  int src_stepx,
+                                  uint8_t* dst_ptr,
+                                  int dst_width);
+void ScaleUVRowDownEvenBox_Any_SSSE3(const uint8_t* src_ptr,
+                                     ptrdiff_t src_stride,
+                                     int src_stepx,
+                                     uint8_t* dst_ptr,
+                                     int dst_width);
+void ScaleUVRowDownEven_Any_NEON(const uint8_t* src_ptr,
+                                 ptrdiff_t src_stride,
+                                 int src_stepx,
+                                 uint8_t* dst_ptr,
+                                 int dst_width);
+void ScaleUVRowDownEvenBox_Any_NEON(const uint8_t* src_ptr,
+                                    ptrdiff_t src_stride,
+                                    int src_stepx,
+                                    uint8_t* dst_ptr,
+                                    int dst_width);
+void ScaleUVRowDownEven_Any_MSA(const uint8_t* src_ptr,
+                                ptrdiff_t src_stride,
+                                int32_t src_stepx,
+                                uint8_t* dst_ptr,
+                                int dst_width);
+void ScaleUVRowDownEvenBox_Any_MSA(const uint8_t* src_ptr,
+                                   ptrdiff_t src_stride,
+                                   int src_stepx,
+                                   uint8_t* dst_ptr,
+                                   int dst_width);
+
+void ScaleUVRowUp2_Linear_SSSE3(const uint8_t* src_ptr,
+                                uint8_t* dst_ptr,
+                                int dst_width);
+void ScaleUVRowUp2_Bilinear_SSSE3(const uint8_t* src_ptr,
+                                  ptrdiff_t src_stride,
+                                  uint8_t* dst_ptr,
+                                  ptrdiff_t dst_stride,
+                                  int dst_width);
+void ScaleUVRowUp2_Linear_Any_SSSE3(const uint8_t* src_ptr,
+                                    uint8_t* dst_ptr,
+                                    int dst_width);
+void ScaleUVRowUp2_Bilinear_Any_SSSE3(const uint8_t* src_ptr,
+                                      ptrdiff_t src_stride,
+                                      uint8_t* dst_ptr,
+                                      ptrdiff_t dst_stride,
+                                      int dst_width);
+void ScaleUVRowUp2_Linear_AVX2(const uint8_t* src_ptr,
+                               uint8_t* dst_ptr,
+                               int dst_width);
+void ScaleUVRowUp2_Bilinear_AVX2(const uint8_t* src_ptr,
+                                 ptrdiff_t src_stride,
+                                 uint8_t* dst_ptr,
+                                 ptrdiff_t dst_stride,
+                                 int dst_width);
+void ScaleUVRowUp2_Linear_Any_AVX2(const uint8_t* src_ptr,
+                                   uint8_t* dst_ptr,
+                                   int dst_width);
+void ScaleUVRowUp2_Bilinear_Any_AVX2(const uint8_t* src_ptr,
+                                     ptrdiff_t src_stride,
+                                     uint8_t* dst_ptr,
+                                     ptrdiff_t dst_stride,
+                                     int dst_width);
+void ScaleUVRowUp2_Linear_NEON(const uint8_t* src_ptr,
+                               uint8_t* dst_ptr,
+                               int dst_width);
+void ScaleUVRowUp2_Bilinear_NEON(const uint8_t* src_ptr,
+                                 ptrdiff_t src_stride,
+                                 uint8_t* dst_ptr,
+                                 ptrdiff_t dst_stride,
+                                 int dst_width);
+void ScaleUVRowUp2_Linear_Any_NEON(const uint8_t* src_ptr,
+                                   uint8_t* dst_ptr,
+                                   int dst_width);
+void ScaleUVRowUp2_Bilinear_Any_NEON(const uint8_t* src_ptr,
+                                     ptrdiff_t src_stride,
+                                     uint8_t* dst_ptr,
+                                     ptrdiff_t dst_stride,
+                                     int dst_width);
+void ScaleUVRowUp2_Linear_16_SSE41(const uint16_t* src_ptr,
+                                   uint16_t* dst_ptr,
+                                   int dst_width);
+void ScaleUVRowUp2_Bilinear_16_SSE41(const uint16_t* src_ptr,
+                                     ptrdiff_t src_stride,
+                                     uint16_t* dst_ptr,
+                                     ptrdiff_t dst_stride,
+                                     int dst_width);
+void ScaleUVRowUp2_Linear_16_Any_SSE41(const uint16_t* src_ptr,
+                                       uint16_t* dst_ptr,
+                                       int dst_width);
+void ScaleUVRowUp2_Bilinear_16_Any_SSE41(const uint16_t* src_ptr,
+                                         ptrdiff_t src_stride,
+                                         uint16_t* dst_ptr,
+                                         ptrdiff_t dst_stride,
+                                         int dst_width);
+void ScaleUVRowUp2_Linear_16_AVX2(const uint16_t* src_ptr,
+                                  uint16_t* dst_ptr,
+                                  int dst_width);
+void ScaleUVRowUp2_Bilinear_16_AVX2(const uint16_t* src_ptr,
+                                    ptrdiff_t src_stride,
+                                    uint16_t* dst_ptr,
+                                    ptrdiff_t dst_stride,
+                                    int dst_width);
+void ScaleUVRowUp2_Linear_16_Any_AVX2(const uint16_t* src_ptr,
+                                      uint16_t* dst_ptr,
+                                      int dst_width);
+void ScaleUVRowUp2_Bilinear_16_Any_AVX2(const uint16_t* src_ptr,
+                                        ptrdiff_t src_stride,
+                                        uint16_t* dst_ptr,
+                                        ptrdiff_t dst_stride,
+                                        int dst_width);
+void ScaleUVRowUp2_Linear_16_NEON(const uint16_t* src_ptr,
+                                  uint16_t* dst_ptr,
+                                  int dst_width);
+void ScaleUVRowUp2_Bilinear_16_NEON(const uint16_t* src_ptr,
+                                    ptrdiff_t src_stride,
+                                    uint16_t* dst_ptr,
+                                    ptrdiff_t dst_stride,
+                                    int dst_width);
+void ScaleUVRowUp2_Linear_16_Any_NEON(const uint16_t* src_ptr,
+                                      uint16_t* dst_ptr,
+                                      int dst_width);
+void ScaleUVRowUp2_Bilinear_16_Any_NEON(const uint16_t* src_ptr,
+                                        ptrdiff_t src_stride,
+                                        uint16_t* dst_ptr,
+                                        ptrdiff_t dst_stride,
+                                        int dst_width);
+
+// ScaleRowDown2Box also used by planar functions
+// NEON downscalers with interpolation.
+
+// Note - not static due to reuse in convert for 444 to 420.
+void ScaleRowDown2_NEON(const uint8_t* src_ptr,
+                        ptrdiff_t src_stride,
+                        uint8_t* dst,
+                        int dst_width);
+void ScaleRowDown2Linear_NEON(const uint8_t* src_ptr,
+                              ptrdiff_t src_stride,
+                              uint8_t* dst,
+                              int dst_width);
+void ScaleRowDown2Box_NEON(const uint8_t* src_ptr,
+                           ptrdiff_t src_stride,
+                           uint8_t* dst,
+                           int dst_width);
+
+void ScaleRowDown4_NEON(const uint8_t* src_ptr,
+                        ptrdiff_t src_stride,
+                        uint8_t* dst_ptr,
+                        int dst_width);
+void ScaleRowDown4Box_NEON(const uint8_t* src_ptr,
+                           ptrdiff_t src_stride,
+                           uint8_t* dst_ptr,
+                           int dst_width);
+
+// Down scale from 4 to 3 pixels. Use the neon multilane read/write
+//  to load up the every 4th pixel into a 4 different registers.
+// Point samples 32 pixels to 24 pixels.
+void ScaleRowDown34_NEON(const uint8_t* src_ptr,
+                         ptrdiff_t src_stride,
+                         uint8_t* dst_ptr,
+                         int dst_width);
+void ScaleRowDown34_0_Box_NEON(const uint8_t* src_ptr,
+                               ptrdiff_t src_stride,
+                               uint8_t* dst_ptr,
+                               int dst_width);
+void ScaleRowDown34_1_Box_NEON(const uint8_t* src_ptr,
+                               ptrdiff_t src_stride,
+                               uint8_t* dst_ptr,
+                               int dst_width);
+
+// 32 -> 12
+void ScaleRowDown38_NEON(const uint8_t* src_ptr,
+                         ptrdiff_t src_stride,
+                         uint8_t* dst_ptr,
+                         int dst_width);
+// 32x3 -> 12x1
+void ScaleRowDown38_3_Box_NEON(const uint8_t* src_ptr,
+                               ptrdiff_t src_stride,
+                               uint8_t* dst_ptr,
+                               int dst_width);
+// 32x2 -> 12x1
+void ScaleRowDown38_2_Box_NEON(const uint8_t* src_ptr,
+                               ptrdiff_t src_stride,
+                               uint8_t* dst_ptr,
+                               int dst_width);
+
+void ScaleRowDown2_Any_NEON(const uint8_t* src_ptr,
+                            ptrdiff_t src_stride,
+                            uint8_t* dst_ptr,
+                            int dst_width);
+void ScaleRowDown2Linear_Any_NEON(const uint8_t* src_ptr,
+                                  ptrdiff_t src_stride,
+                                  uint8_t* dst_ptr,
+                                  int dst_width);
+void ScaleRowDown2Box_Any_NEON(const uint8_t* src_ptr,
+                               ptrdiff_t src_stride,
+                               uint8_t* dst_ptr,
+                               int dst_width);
+void ScaleRowDown2Box_Odd_NEON(const uint8_t* src_ptr,
+                               ptrdiff_t src_stride,
+                               uint8_t* dst_ptr,
+                               int dst_width);
+void ScaleRowDown4_Any_NEON(const uint8_t* src_ptr,
+                            ptrdiff_t src_stride,
+                            uint8_t* dst_ptr,
+                            int dst_width);
+void ScaleRowDown4Box_Any_NEON(const uint8_t* src_ptr,
+                               ptrdiff_t src_stride,
+                               uint8_t* dst_ptr,
+                               int dst_width);
+void ScaleRowDown34_Any_NEON(const uint8_t* src_ptr,
+                             ptrdiff_t src_stride,
+                             uint8_t* dst_ptr,
+                             int dst_width);
+void ScaleRowDown34_0_Box_Any_NEON(const uint8_t* src_ptr,
+                                   ptrdiff_t src_stride,
+                                   uint8_t* dst_ptr,
+                                   int dst_width);
+void ScaleRowDown34_1_Box_Any_NEON(const uint8_t* src_ptr,
+                                   ptrdiff_t src_stride,
+                                   uint8_t* dst_ptr,
+                                   int dst_width);
+// 32 -> 12
+void ScaleRowDown38_Any_NEON(const uint8_t* src_ptr,
+                             ptrdiff_t src_stride,
+                             uint8_t* dst_ptr,
+                             int dst_width);
+// 32x3 -> 12x1
+void ScaleRowDown38_3_Box_Any_NEON(const uint8_t* src_ptr,
+                                   ptrdiff_t src_stride,
+                                   uint8_t* dst_ptr,
+                                   int dst_width);
+// 32x2 -> 12x1
+void ScaleRowDown38_2_Box_Any_NEON(const uint8_t* src_ptr,
+                                   ptrdiff_t src_stride,
+                                   uint8_t* dst_ptr,
+                                   int dst_width);
+
+void ScaleRowUp2_Linear_NEON(const uint8_t* src_ptr,
+                             uint8_t* dst_ptr,
+                             int dst_width);
+void ScaleRowUp2_Bilinear_NEON(const uint8_t* src_ptr,
+                               ptrdiff_t src_stride,
+                               uint8_t* dst_ptr,
+                               ptrdiff_t dst_stride,
+                               int dst_width);
+void ScaleRowUp2_Linear_12_NEON(const uint16_t* src_ptr,
+                                uint16_t* dst_ptr,
+                                int dst_width);
+void ScaleRowUp2_Bilinear_12_NEON(const uint16_t* src_ptr,
+                                  ptrdiff_t src_stride,
+                                  uint16_t* dst_ptr,
+                                  ptrdiff_t dst_stride,
+                                  int dst_width);
+void ScaleRowUp2_Linear_16_NEON(const uint16_t* src_ptr,
+                                uint16_t* dst_ptr,
+                                int dst_width);
+void ScaleRowUp2_Bilinear_16_NEON(const uint16_t* src_ptr,
+                                  ptrdiff_t src_stride,
+                                  uint16_t* dst_ptr,
+                                  ptrdiff_t dst_stride,
+                                  int dst_width);
+void ScaleRowUp2_Linear_Any_NEON(const uint8_t* src_ptr,
+                                 uint8_t* dst_ptr,
+                                 int dst_width);
+void ScaleRowUp2_Bilinear_Any_NEON(const uint8_t* src_ptr,
+                                   ptrdiff_t src_stride,
+                                   uint8_t* dst_ptr,
+                                   ptrdiff_t dst_stride,
+                                   int dst_width);
+void ScaleRowUp2_Linear_12_Any_NEON(const uint16_t* src_ptr,
+                                    uint16_t* dst_ptr,
+                                    int dst_width);
+void ScaleRowUp2_Bilinear_12_Any_NEON(const uint16_t* src_ptr,
+                                      ptrdiff_t src_stride,
+                                      uint16_t* dst_ptr,
+                                      ptrdiff_t dst_stride,
+                                      int dst_width);
+void ScaleRowUp2_Linear_16_Any_NEON(const uint16_t* src_ptr,
+                                    uint16_t* dst_ptr,
+                                    int dst_width);
+void ScaleRowUp2_Bilinear_16_Any_NEON(const uint16_t* src_ptr,
+                                      ptrdiff_t src_stride,
+                                      uint16_t* dst_ptr,
+                                      ptrdiff_t dst_stride,
+                                      int dst_width);
+
+void ScaleAddRow_NEON(const uint8_t* src_ptr, uint16_t* dst_ptr, int src_width);
+void ScaleAddRow_Any_NEON(const uint8_t* src_ptr,
+                          uint16_t* dst_ptr,
+                          int src_width);
+
+void ScaleFilterCols_NEON(uint8_t* dst_ptr,
+                          const uint8_t* src_ptr,
+                          int dst_width,
+                          int x,
+                          int dx);
+
+void ScaleFilterCols_Any_NEON(uint8_t* dst_ptr,
+                              const uint8_t* src_ptr,
+                              int dst_width,
+                              int x,
+                              int dx);
+
+void ScaleRowDown2_MSA(const uint8_t* src_ptr,
+                       ptrdiff_t src_stride,
+                       uint8_t* dst,
+                       int dst_width);
+void ScaleRowDown2Linear_MSA(const uint8_t* src_ptr,
+                             ptrdiff_t src_stride,
+                             uint8_t* dst,
+                             int dst_width);
+void ScaleRowDown2Box_MSA(const uint8_t* src_ptr,
+                          ptrdiff_t src_stride,
+                          uint8_t* dst,
+                          int dst_width);
+void ScaleRowDown4_MSA(const uint8_t* src_ptr,
+                       ptrdiff_t src_stride,
+                       uint8_t* dst,
+                       int dst_width);
+void ScaleRowDown4Box_MSA(const uint8_t* src_ptr,
+                          ptrdiff_t src_stride,
+                          uint8_t* dst,
+                          int dst_width);
+void ScaleRowDown38_MSA(const uint8_t* src_ptr,
+                        ptrdiff_t src_stride,
+                        uint8_t* dst,
+                        int dst_width);
+void ScaleRowDown38_2_Box_MSA(const uint8_t* src_ptr,
+                              ptrdiff_t src_stride,
+                              uint8_t* dst_ptr,
+                              int dst_width);
+void ScaleRowDown38_3_Box_MSA(const uint8_t* src_ptr,
+                              ptrdiff_t src_stride,
+                              uint8_t* dst_ptr,
+                              int dst_width);
+void ScaleAddRow_MSA(const uint8_t* src_ptr, uint16_t* dst_ptr, int src_width);
+void ScaleFilterCols_MSA(uint8_t* dst_ptr,
+                         const uint8_t* src_ptr,
+                         int dst_width,
+                         int x,
+                         int dx);
+void ScaleRowDown34_MSA(const uint8_t* src_ptr,
+                        ptrdiff_t src_stride,
+                        uint8_t* dst,
+                        int dst_width);
+void ScaleRowDown34_0_Box_MSA(const uint8_t* src_ptr,
+                              ptrdiff_t src_stride,
+                              uint8_t* d,
+                              int dst_width);
+void ScaleRowDown34_1_Box_MSA(const uint8_t* src_ptr,
+                              ptrdiff_t src_stride,
+                              uint8_t* d,
+                              int dst_width);
+
+void ScaleRowDown2_Any_MSA(const uint8_t* src_ptr,
+                           ptrdiff_t src_stride,
+                           uint8_t* dst_ptr,
+                           int dst_width);
+void ScaleRowDown2Linear_Any_MSA(const uint8_t* src_ptr,
+                                 ptrdiff_t src_stride,
+                                 uint8_t* dst_ptr,
+                                 int dst_width);
+void ScaleRowDown2Box_Any_MSA(const uint8_t* src_ptr,
+                              ptrdiff_t src_stride,
+                              uint8_t* dst_ptr,
+                              int dst_width);
+void ScaleRowDown4_Any_MSA(const uint8_t* src_ptr,
+                           ptrdiff_t src_stride,
+                           uint8_t* dst_ptr,
+                           int dst_width);
+void ScaleRowDown4Box_Any_MSA(const uint8_t* src_ptr,
+                              ptrdiff_t src_stride,
+                              uint8_t* dst_ptr,
+                              int dst_width);
+void ScaleRowDown38_Any_MSA(const uint8_t* src_ptr,
+                            ptrdiff_t src_stride,
+                            uint8_t* dst_ptr,
+                            int dst_width);
+void ScaleRowDown38_2_Box_Any_MSA(const uint8_t* src_ptr,
+                                  ptrdiff_t src_stride,
+                                  uint8_t* dst_ptr,
+                                  int dst_width);
+void ScaleRowDown38_3_Box_Any_MSA(const uint8_t* src_ptr,
+                                  ptrdiff_t src_stride,
+                                  uint8_t* dst_ptr,
+                                  int dst_width);
+void ScaleAddRow_Any_MSA(const uint8_t* src_ptr,
+                         uint16_t* dst_ptr,
+                         int src_width);
+void ScaleFilterCols_Any_MSA(uint8_t* dst_ptr,
+                             const uint8_t* src_ptr,
+                             int dst_width,
+                             int x,
+                             int dx);
+void ScaleRowDown34_Any_MSA(const uint8_t* src_ptr,
+                            ptrdiff_t src_stride,
+                            uint8_t* dst_ptr,
+                            int dst_width);
+void ScaleRowDown34_0_Box_Any_MSA(const uint8_t* src_ptr,
+                                  ptrdiff_t src_stride,
+                                  uint8_t* dst_ptr,
+                                  int dst_width);
+void ScaleRowDown34_1_Box_Any_MSA(const uint8_t* src_ptr,
+                                  ptrdiff_t src_stride,
+                                  uint8_t* dst_ptr,
+                                  int dst_width);
+
+void ScaleRowDown2_LSX(const uint8_t* src_ptr,
+                       ptrdiff_t src_stride,
+                       uint8_t* dst,
+                       int dst_width);
+void ScaleRowDown2Linear_LSX(const uint8_t* src_ptr,
+                             ptrdiff_t src_stride,
+                             uint8_t* dst,
+                             int dst_width);
+void ScaleRowDown2Box_LSX(const uint8_t* src_ptr,
+                          ptrdiff_t src_stride,
+                          uint8_t* dst,
+                          int dst_width);
+void ScaleRowDown4_LSX(const uint8_t* src_ptr,
+                       ptrdiff_t src_stride,
+                       uint8_t* dst,
+                       int dst_width);
+void ScaleRowDown4Box_LSX(const uint8_t* src_ptr,
+                          ptrdiff_t src_stride,
+                          uint8_t* dst,
+                          int dst_width);
+void ScaleRowDown38_LSX(const uint8_t* src_ptr,
+                        ptrdiff_t src_stride,
+                        uint8_t* dst,
+                        int dst_width);
+void ScaleRowDown38_2_Box_LSX(const uint8_t* src_ptr,
+                              ptrdiff_t src_stride,
+                              uint8_t* dst_ptr,
+                              int dst_width);
+void ScaleRowDown38_3_Box_LSX(const uint8_t* src_ptr,
+                              ptrdiff_t src_stride,
+                              uint8_t* dst_ptr,
+                              int dst_width);
+void ScaleAddRow_LSX(const uint8_t* src_ptr, uint16_t* dst_ptr, int src_width);
+void ScaleFilterCols_LSX(uint8_t* dst_ptr,
+                         const uint8_t* src_ptr,
+                         int dst_width,
+                         int x,
+                         int dx);
+void ScaleARGBFilterCols_LSX(uint8_t* dst_argb,
+                             const uint8_t* src_argb,
+                             int dst_width,
+                             int x,
+                             int dx);
+void ScaleARGBCols_LSX(uint8_t* dst_argb,
+                       const uint8_t* src_argb,
+                       int dst_width,
+                       int x,
+                       int dx);
+void ScaleRowDown34_LSX(const uint8_t* src_ptr,
+                        ptrdiff_t src_stride,
+                        uint8_t* dst,
+                        int dst_width);
+void ScaleRowDown34_0_Box_LSX(const uint8_t* src_ptr,
+                              ptrdiff_t src_stride,
+                              uint8_t* d,
+                              int dst_width);
+void ScaleRowDown34_1_Box_LSX(const uint8_t* src_ptr,
+                              ptrdiff_t src_stride,
+                              uint8_t* d,
+                              int dst_width);
+void ScaleRowDown2_Any_LSX(const uint8_t* src_ptr,
+                           ptrdiff_t src_stride,
+                           uint8_t* dst_ptr,
+                           int dst_width);
+void ScaleRowDown2Linear_Any_LSX(const uint8_t* src_ptr,
+                                 ptrdiff_t src_stride,
+                                 uint8_t* dst_ptr,
+                                 int dst_width);
+void ScaleRowDown2Box_Any_LSX(const uint8_t* src_ptr,
+                              ptrdiff_t src_stride,
+                              uint8_t* dst_ptr,
+                              int dst_width);
+void ScaleRowDown4_Any_LSX(const uint8_t* src_ptr,
+                           ptrdiff_t src_stride,
+                           uint8_t* dst_ptr,
+                           int dst_width);
+void ScaleRowDown4Box_Any_LSX(const uint8_t* src_ptr,
+                              ptrdiff_t src_stride,
+                              uint8_t* dst_ptr,
+                              int dst_width);
+void ScaleRowDown38_Any_LSX(const uint8_t* src_ptr,
+                            ptrdiff_t src_stride,
+                            uint8_t* dst_ptr,
+                            int dst_width);
+void ScaleRowDown38_2_Box_Any_LSX(const uint8_t* src_ptr,
+                                  ptrdiff_t src_stride,
+                                  uint8_t* dst_ptr,
+                                  int dst_width);
+void ScaleRowDown38_3_Box_Any_LSX(const uint8_t* src_ptr,
+                                  ptrdiff_t src_stride,
+                                  uint8_t* dst_ptr,
+                                  int dst_width);
+void ScaleAddRow_Any_LSX(const uint8_t* src_ptr,
+                         uint16_t* dst_ptr,
+                         int src_width);
+void ScaleFilterCols_Any_LSX(uint8_t* dst_ptr,
+                             const uint8_t* src_ptr,
+                             int dst_width,
+                             int x,
+                             int dx);
+void ScaleARGBCols_Any_LSX(uint8_t* dst_ptr,
+                           const uint8_t* src_ptr,
+                           int dst_width,
+                           int x,
+                           int dx);
+void ScaleARGBFilterCols_Any_LSX(uint8_t* dst_ptr,
+                                 const uint8_t* src_ptr,
+                                 int dst_width,
+                                 int x,
+                                 int dx);
+void ScaleRowDown34_Any_LSX(const uint8_t* src_ptr,
+                            ptrdiff_t src_stride,
+                            uint8_t* dst_ptr,
+                            int dst_width);
+void ScaleRowDown34_0_Box_Any_LSX(const uint8_t* src_ptr,
+                                  ptrdiff_t src_stride,
+                                  uint8_t* dst_ptr,
+                                  int dst_width);
+void ScaleRowDown34_1_Box_Any_LSX(const uint8_t* src_ptr,
+                                  ptrdiff_t src_stride,
+                                  uint8_t* dst_ptr,
+                                  int dst_width);
+
+#ifdef __cplusplus
+}  // extern "C"
+}  // namespace libyuv
+#endif
+
+#endif  // INCLUDE_LIBYUV_SCALE_ROW_H_
diff --git a/3rdparty/libyuv/src/include/libyuv/scale_uv.h b/3rdparty/libyuv/src/include/libyuv/scale_uv.h
new file mode 100644
index 00000000..8e74e319
--- /dev/null
+++ b/3rdparty/libyuv/src/include/libyuv/scale_uv.h
@@ -0,0 +1,51 @@
+/*
+ *  Copyright 2020 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#ifndef INCLUDE_LIBYUV_SCALE_UV_H_
+#define INCLUDE_LIBYUV_SCALE_UV_H_
+
+#include "libyuv/basic_types.h"
+#include "libyuv/scale.h"  // For FilterMode
+
+#ifdef __cplusplus
+namespace libyuv {
+extern "C" {
+#endif
+
+LIBYUV_API
+int UVScale(const uint8_t* src_uv,
+            int src_stride_uv,
+            int src_width,
+            int src_height,
+            uint8_t* dst_uv,
+            int dst_stride_uv,
+            int dst_width,
+            int dst_height,
+            enum FilterMode filtering);
+
+// Scale a 16 bit UV image.
+// This function is currently incomplete, it can't handle all cases.
+LIBYUV_API
+int UVScale_16(const uint16_t* src_uv,
+               int src_stride_uv,
+               int src_width,
+               int src_height,
+               uint16_t* dst_uv,
+               int dst_stride_uv,
+               int dst_width,
+               int dst_height,
+               enum FilterMode filtering);
+
+#ifdef __cplusplus
+}  // extern "C"
+}  // namespace libyuv
+#endif
+
+#endif  // INCLUDE_LIBYUV_SCALE_UV_H_
diff --git a/3rdparty/libyuv/src/include/libyuv/version.h b/3rdparty/libyuv/src/include/libyuv/version.h
new file mode 100644
index 00000000..8ef3493b
--- /dev/null
+++ b/3rdparty/libyuv/src/include/libyuv/version.h
@@ -0,0 +1,16 @@
+/*
+ *  Copyright 2012 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#ifndef INCLUDE_LIBYUV_VERSION_H_
+#define INCLUDE_LIBYUV_VERSION_H_
+
+#define LIBYUV_VERSION 1832
+
+#endif  // INCLUDE_LIBYUV_VERSION_H_
diff --git a/3rdparty/libyuv/src/include/libyuv/video_common.h b/3rdparty/libyuv/src/include/libyuv/video_common.h
new file mode 100644
index 00000000..32b8a521
--- /dev/null
+++ b/3rdparty/libyuv/src/include/libyuv/video_common.h
@@ -0,0 +1,222 @@
+/*
+ *  Copyright 2011 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+// Common definitions for video, including fourcc and VideoFormat.
+
+#ifndef INCLUDE_LIBYUV_VIDEO_COMMON_H_
+#define INCLUDE_LIBYUV_VIDEO_COMMON_H_
+
+#include "libyuv/basic_types.h"
+
+#ifdef __cplusplus
+namespace libyuv {
+extern "C" {
+#endif
+
+//////////////////////////////////////////////////////////////////////////////
+// Definition of FourCC codes
+//////////////////////////////////////////////////////////////////////////////
+
+// Convert four characters to a FourCC code.
+// Needs to be a macro otherwise the OS X compiler complains when the kFormat*
+// constants are used in a switch.
+#ifdef __cplusplus
+#define FOURCC(a, b, c, d)                                        \
+  ((static_cast<uint32_t>(a)) | (static_cast<uint32_t>(b) << 8) | \
+   (static_cast<uint32_t>(c) << 16) | /* NOLINT */                \
+   (static_cast<uint32_t>(d) << 24))  /* NOLINT */
+#else
+#define FOURCC(a, b, c, d)                                     \
+  (((uint32_t)(a)) | ((uint32_t)(b) << 8) |       /* NOLINT */ \
+   ((uint32_t)(c) << 16) | ((uint32_t)(d) << 24)) /* NOLINT */
+#endif
+
+// Some pages discussing FourCC codes:
+//   http://www.fourcc.org/yuv.php
+//   http://v4l2spec.bytesex.org/spec/book1.htm
+//   http://developer.apple.com/quicktime/icefloe/dispatch020.html
+//   http://msdn.microsoft.com/library/windows/desktop/dd206750.aspx#nv12
+//   http://people.xiph.org/~xiphmont/containers/nut/nut4cc.txt
+
+// FourCC codes grouped according to implementation efficiency.
+// Primary formats should convert in 1 efficient step.
+// Secondary formats are converted in 2 steps.
+// Auxilliary formats call primary converters.
+enum FourCC {
+  // 10 Primary YUV formats: 5 planar, 2 biplanar, 2 packed.
+  FOURCC_I420 = FOURCC('I', '4', '2', '0'),
+  FOURCC_I422 = FOURCC('I', '4', '2', '2'),
+  FOURCC_I444 = FOURCC('I', '4', '4', '4'),
+  FOURCC_I400 = FOURCC('I', '4', '0', '0'),
+  FOURCC_NV21 = FOURCC('N', 'V', '2', '1'),
+  FOURCC_NV12 = FOURCC('N', 'V', '1', '2'),
+  FOURCC_YUY2 = FOURCC('Y', 'U', 'Y', '2'),
+  FOURCC_UYVY = FOURCC('U', 'Y', 'V', 'Y'),
+  FOURCC_I010 = FOURCC('I', '0', '1', '0'),  // bt.601 10 bit 420
+  FOURCC_I210 = FOURCC('I', '2', '1', '0'),  // bt.601 10 bit 422
+
+  // 1 Secondary YUV format: row biplanar.  deprecated.
+  FOURCC_M420 = FOURCC('M', '4', '2', '0'),
+
+  // 13 Primary RGB formats: 4 32 bpp, 2 24 bpp, 3 16 bpp, 1 10 bpc 2 64 bpp
+  FOURCC_ARGB = FOURCC('A', 'R', 'G', 'B'),
+  FOURCC_BGRA = FOURCC('B', 'G', 'R', 'A'),
+  FOURCC_ABGR = FOURCC('A', 'B', 'G', 'R'),
+  FOURCC_AR30 = FOURCC('A', 'R', '3', '0'),  // 10 bit per channel. 2101010.
+  FOURCC_AB30 = FOURCC('A', 'B', '3', '0'),  // ABGR version of 10 bit
+  FOURCC_AR64 = FOURCC('A', 'R', '6', '4'),  // 16 bit per channel.
+  FOURCC_AB64 = FOURCC('A', 'B', '6', '4'),  // ABGR version of 16 bit
+  FOURCC_24BG = FOURCC('2', '4', 'B', 'G'),
+  FOURCC_RAW = FOURCC('r', 'a', 'w', ' '),
+  FOURCC_RGBA = FOURCC('R', 'G', 'B', 'A'),
+  FOURCC_RGBP = FOURCC('R', 'G', 'B', 'P'),  // rgb565 LE.
+  FOURCC_RGBO = FOURCC('R', 'G', 'B', 'O'),  // argb1555 LE.
+  FOURCC_R444 = FOURCC('R', '4', '4', '4'),  // argb4444 LE.
+
+  // 1 Primary Compressed YUV format.
+  FOURCC_MJPG = FOURCC('M', 'J', 'P', 'G'),
+
+  // 14 Auxiliary YUV variations: 3 with U and V planes are swapped, 1 Alias.
+  FOURCC_YV12 = FOURCC('Y', 'V', '1', '2'),
+  FOURCC_YV16 = FOURCC('Y', 'V', '1', '6'),
+  FOURCC_YV24 = FOURCC('Y', 'V', '2', '4'),
+  FOURCC_YU12 = FOURCC('Y', 'U', '1', '2'),  // Linux version of I420.
+  FOURCC_J420 =
+      FOURCC('J', '4', '2', '0'),  // jpeg (bt.601 full), unofficial fourcc
+  FOURCC_J422 =
+      FOURCC('J', '4', '2', '2'),  // jpeg (bt.601 full), unofficial fourcc
+  FOURCC_J444 =
+      FOURCC('J', '4', '4', '4'),  // jpeg (bt.601 full), unofficial fourcc
+  FOURCC_J400 =
+      FOURCC('J', '4', '0', '0'),  // jpeg (bt.601 full), unofficial fourcc
+  FOURCC_F420 = FOURCC('F', '4', '2', '0'),  // bt.709 full, unofficial fourcc
+  FOURCC_F422 = FOURCC('F', '4', '2', '2'),  // bt.709 full, unofficial fourcc
+  FOURCC_F444 = FOURCC('F', '4', '4', '4'),  // bt.709 full, unofficial fourcc
+  FOURCC_H420 = FOURCC('H', '4', '2', '0'),  // bt.709, unofficial fourcc
+  FOURCC_H422 = FOURCC('H', '4', '2', '2'),  // bt.709, unofficial fourcc
+  FOURCC_H444 = FOURCC('H', '4', '4', '4'),  // bt.709, unofficial fourcc
+  FOURCC_U420 = FOURCC('U', '4', '2', '0'),  // bt.2020, unofficial fourcc
+  FOURCC_U422 = FOURCC('U', '4', '2', '2'),  // bt.2020, unofficial fourcc
+  FOURCC_U444 = FOURCC('U', '4', '4', '4'),  // bt.2020, unofficial fourcc
+  FOURCC_F010 = FOURCC('F', '0', '1', '0'),  // bt.709 full range 10 bit 420
+  FOURCC_H010 = FOURCC('H', '0', '1', '0'),  // bt.709 10 bit 420
+  FOURCC_U010 = FOURCC('U', '0', '1', '0'),  // bt.2020 10 bit 420
+  FOURCC_F210 = FOURCC('F', '2', '1', '0'),  // bt.709 full range 10 bit 422
+  FOURCC_H210 = FOURCC('H', '2', '1', '0'),  // bt.709 10 bit 422
+  FOURCC_U210 = FOURCC('U', '2', '1', '0'),  // bt.2020 10 bit 422
+  FOURCC_P010 = FOURCC('P', '0', '1', '0'),
+  FOURCC_P210 = FOURCC('P', '2', '1', '0'),
+
+  // 14 Auxiliary aliases.  CanonicalFourCC() maps these to canonical fourcc.
+  FOURCC_IYUV = FOURCC('I', 'Y', 'U', 'V'),  // Alias for I420.
+  FOURCC_YU16 = FOURCC('Y', 'U', '1', '6'),  // Alias for I422.
+  FOURCC_YU24 = FOURCC('Y', 'U', '2', '4'),  // Alias for I444.
+  FOURCC_YUYV = FOURCC('Y', 'U', 'Y', 'V'),  // Alias for YUY2.
+  FOURCC_YUVS = FOURCC('y', 'u', 'v', 's'),  // Alias for YUY2 on Mac.
+  FOURCC_HDYC = FOURCC('H', 'D', 'Y', 'C'),  // Alias for UYVY.
+  FOURCC_2VUY = FOURCC('2', 'v', 'u', 'y'),  // Alias for UYVY on Mac.
+  FOURCC_JPEG = FOURCC('J', 'P', 'E', 'G'),  // Alias for MJPG.
+  FOURCC_DMB1 = FOURCC('d', 'm', 'b', '1'),  // Alias for MJPG on Mac.
+  FOURCC_BA81 = FOURCC('B', 'A', '8', '1'),  // Alias for BGGR.
+  FOURCC_RGB3 = FOURCC('R', 'G', 'B', '3'),  // Alias for RAW.
+  FOURCC_BGR3 = FOURCC('B', 'G', 'R', '3'),  // Alias for 24BG.
+  FOURCC_CM32 = FOURCC(0, 0, 0, 32),  // Alias for BGRA kCMPixelFormat_32ARGB
+  FOURCC_CM24 = FOURCC(0, 0, 0, 24),  // Alias for RAW kCMPixelFormat_24RGB
+  FOURCC_L555 = FOURCC('L', '5', '5', '5'),  // Alias for RGBO.
+  FOURCC_L565 = FOURCC('L', '5', '6', '5'),  // Alias for RGBP.
+  FOURCC_5551 = FOURCC('5', '5', '5', '1'),  // Alias for RGBO.
+
+  // deprecated formats.  Not supported, but defined for backward compatibility.
+  FOURCC_I411 = FOURCC('I', '4', '1', '1'),
+  FOURCC_Q420 = FOURCC('Q', '4', '2', '0'),
+  FOURCC_RGGB = FOURCC('R', 'G', 'G', 'B'),
+  FOURCC_BGGR = FOURCC('B', 'G', 'G', 'R'),
+  FOURCC_GRBG = FOURCC('G', 'R', 'B', 'G'),
+  FOURCC_GBRG = FOURCC('G', 'B', 'R', 'G'),
+  FOURCC_H264 = FOURCC('H', '2', '6', '4'),
+
+  // Match any fourcc.
+  FOURCC_ANY = -1,
+};
+
+enum FourCCBpp {
+  // Canonical fourcc codes used in our code.
+  FOURCC_BPP_I420 = 12,
+  FOURCC_BPP_I422 = 16,
+  FOURCC_BPP_I444 = 24,
+  FOURCC_BPP_I411 = 12,
+  FOURCC_BPP_I400 = 8,
+  FOURCC_BPP_NV21 = 12,
+  FOURCC_BPP_NV12 = 12,
+  FOURCC_BPP_YUY2 = 16,
+  FOURCC_BPP_UYVY = 16,
+  FOURCC_BPP_M420 = 12,  // deprecated
+  FOURCC_BPP_Q420 = 12,
+  FOURCC_BPP_ARGB = 32,
+  FOURCC_BPP_BGRA = 32,
+  FOURCC_BPP_ABGR = 32,
+  FOURCC_BPP_RGBA = 32,
+  FOURCC_BPP_AR30 = 32,
+  FOURCC_BPP_AB30 = 32,
+  FOURCC_BPP_AR64 = 64,
+  FOURCC_BPP_AB64 = 64,
+  FOURCC_BPP_24BG = 24,
+  FOURCC_BPP_RAW = 24,
+  FOURCC_BPP_RGBP = 16,
+  FOURCC_BPP_RGBO = 16,
+  FOURCC_BPP_R444 = 16,
+  FOURCC_BPP_RGGB = 8,
+  FOURCC_BPP_BGGR = 8,
+  FOURCC_BPP_GRBG = 8,
+  FOURCC_BPP_GBRG = 8,
+  FOURCC_BPP_YV12 = 12,
+  FOURCC_BPP_YV16 = 16,
+  FOURCC_BPP_YV24 = 24,
+  FOURCC_BPP_YU12 = 12,
+  FOURCC_BPP_J420 = 12,
+  FOURCC_BPP_J400 = 8,
+  FOURCC_BPP_H420 = 12,
+  FOURCC_BPP_H422 = 16,
+  FOURCC_BPP_I010 = 15,
+  FOURCC_BPP_I210 = 20,
+  FOURCC_BPP_H010 = 15,
+  FOURCC_BPP_H210 = 20,
+  FOURCC_BPP_P010 = 15,
+  FOURCC_BPP_P210 = 20,
+  FOURCC_BPP_MJPG = 0,  // 0 means unknown.
+  FOURCC_BPP_H264 = 0,
+  FOURCC_BPP_IYUV = 12,
+  FOURCC_BPP_YU16 = 16,
+  FOURCC_BPP_YU24 = 24,
+  FOURCC_BPP_YUYV = 16,
+  FOURCC_BPP_YUVS = 16,
+  FOURCC_BPP_HDYC = 16,
+  FOURCC_BPP_2VUY = 16,
+  FOURCC_BPP_JPEG = 1,
+  FOURCC_BPP_DMB1 = 1,
+  FOURCC_BPP_BA81 = 8,
+  FOURCC_BPP_RGB3 = 24,
+  FOURCC_BPP_BGR3 = 24,
+  FOURCC_BPP_CM32 = 32,
+  FOURCC_BPP_CM24 = 24,
+
+  // Match any fourcc.
+  FOURCC_BPP_ANY = 0,  // 0 means unknown.
+};
+
+// Converts fourcc aliases into canonical ones.
+LIBYUV_API uint32_t CanonicalFourCC(uint32_t fourcc);
+
+#ifdef __cplusplus
+}  // extern "C"
+}  // namespace libyuv
+#endif
+
+#endif  // INCLUDE_LIBYUV_VIDEO_COMMON_H_
diff --git a/3rdparty/libyuv/src/infra/config/OWNERS b/3rdparty/libyuv/src/infra/config/OWNERS
new file mode 100644
index 00000000..31ec1368
--- /dev/null
+++ b/3rdparty/libyuv/src/infra/config/OWNERS
@@ -0,0 +1,3 @@
+fbarchard@chromium.org
+mbonadei@chromium.org
+nodir@chromium.org
diff --git a/3rdparty/libyuv/src/infra/config/PRESUBMIT.py b/3rdparty/libyuv/src/infra/config/PRESUBMIT.py
new file mode 100644
index 00000000..01ec0eed
--- /dev/null
+++ b/3rdparty/libyuv/src/infra/config/PRESUBMIT.py
@@ -0,0 +1,11 @@
+# Copyright 2018 The PDFium Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+
+def CheckChangeOnUpload(input_api, output_api):
+  return input_api.canned_checks.CheckChangedLUCIConfigs(input_api, output_api)
+
+
+def CheckChangeOnCommit(input_api, output_api):
+  return input_api.canned_checks.CheckChangedLUCIConfigs(input_api, output_api)
diff --git a/3rdparty/libyuv/src/infra/config/README.md b/3rdparty/libyuv/src/infra/config/README.md
new file mode 100644
index 00000000..e5e3b5f8
--- /dev/null
+++ b/3rdparty/libyuv/src/infra/config/README.md
@@ -0,0 +1,2 @@
+This folder contains libyuv project-wide configurations
+for chrome-infra services.
diff --git a/3rdparty/libyuv/src/infra/config/codereview.settings b/3rdparty/libyuv/src/infra/config/codereview.settings
new file mode 100644
index 00000000..6d742273
--- /dev/null
+++ b/3rdparty/libyuv/src/infra/config/codereview.settings
@@ -0,0 +1,6 @@
+# This file is used by gcl and git-cl to get repository specific information.
+CODE_REVIEW_SERVER: codereview.chromium.org
+PROJECT: libyuv
+GERRIT_HOST: True
+VIEW_VC: https://chromium.googlesource.com/libyuv/libyuv/+/
+
diff --git a/3rdparty/libyuv/src/infra/config/commit-queue.cfg b/3rdparty/libyuv/src/infra/config/commit-queue.cfg
new file mode 100644
index 00000000..4a8d77f4
--- /dev/null
+++ b/3rdparty/libyuv/src/infra/config/commit-queue.cfg
@@ -0,0 +1,143 @@
+# Auto-generated by lucicfg.
+# Do not modify manually.
+#
+# For the schema of this file, see Config message:
+#   https://luci-config.appspot.com/schemas/projects:commit-queue.cfg
+
+cq_status_host: "chromium-cq-status.appspot.com"
+submit_options {
+  max_burst: 4
+  burst_delay {
+    seconds: 480
+  }
+}
+config_groups {
+  name: "config"
+  gerrit {
+    url: "https://chromium-review.googlesource.com"
+    projects {
+      name: "libyuv/libyuv"
+      ref_regexp: "refs/heads/infra/config"
+    }
+  }
+  verifiers {
+    gerrit_cq_ability {
+      committer_list: "project-libyuv-committers"
+      dry_run_access_list: "project-libyuv-tryjob-access"
+    }
+    tryjob {
+      builders {
+        name: "libyuv/try/presubmit"
+      }
+      retry_config {
+        single_quota: 1
+        global_quota: 2
+        failure_weight: 1
+        transient_failure_weight: 1
+        timeout_weight: 2
+      }
+    }
+  }
+}
+config_groups {
+  name: "master"
+  gerrit {
+    url: "https://chromium-review.googlesource.com"
+    projects {
+      name: "libyuv/libyuv"
+      ref_regexp: "refs/heads/main"
+      ref_regexp: "refs/heads/master"
+    }
+  }
+  verifiers {
+    gerrit_cq_ability {
+      committer_list: "project-libyuv-committers"
+      dry_run_access_list: "project-libyuv-tryjob-access"
+    }
+    tryjob {
+      builders {
+        name: "libyuv/try/android"
+        experiment_percentage: 100
+      }
+      builders {
+        name: "libyuv/try/android_arm64"
+        experiment_percentage: 100
+      }
+      builders {
+        name: "libyuv/try/android_rel"
+        experiment_percentage: 100
+      }
+      builders {
+        name: "libyuv/try/android_x64"
+      }
+      builders {
+        name: "libyuv/try/android_x86"
+      }
+      builders {
+        name: "libyuv/try/ios_arm64"
+      }
+      builders {
+        name: "libyuv/try/ios_arm64_rel"
+      }
+      builders {
+        name: "libyuv/try/linux"
+      }
+      builders {
+        name: "libyuv/try/linux_asan"
+      }
+      builders {
+        name: "libyuv/try/linux_gcc"
+        experiment_percentage: 100
+      }
+      builders {
+        name: "libyuv/try/linux_msan"
+      }
+      builders {
+        name: "libyuv/try/linux_rel"
+      }
+      builders {
+        name: "libyuv/try/linux_tsan2"
+      }
+      builders {
+        name: "libyuv/try/linux_ubsan"
+      }
+      builders {
+        name: "libyuv/try/linux_ubsan_vptr"
+      }
+      builders {
+        name: "libyuv/try/mac"
+      }
+      builders {
+        name: "libyuv/try/mac_asan"
+      }
+      builders {
+        name: "libyuv/try/mac_rel"
+      }
+      builders {
+        name: "libyuv/try/win"
+      }
+      builders {
+        name: "libyuv/try/win_clang"
+      }
+      builders {
+        name: "libyuv/try/win_clang_rel"
+      }
+      builders {
+        name: "libyuv/try/win_rel"
+      }
+      builders {
+        name: "libyuv/try/win_x64_clang_rel"
+      }
+      builders {
+        name: "libyuv/try/win_x64_rel"
+      }
+      retry_config {
+        single_quota: 1
+        global_quota: 2
+        failure_weight: 1
+        transient_failure_weight: 1
+        timeout_weight: 2
+      }
+    }
+  }
+}
diff --git a/3rdparty/libyuv/src/infra/config/cr-buildbucket.cfg b/3rdparty/libyuv/src/infra/config/cr-buildbucket.cfg
new file mode 100644
index 00000000..061cf33b
--- /dev/null
+++ b/3rdparty/libyuv/src/infra/config/cr-buildbucket.cfg
@@ -0,0 +1,1743 @@
+# Auto-generated by lucicfg.
+# Do not modify manually.
+#
+# For the schema of this file, see BuildbucketCfg message:
+#   https://luci-config.appspot.com/schemas/projects:buildbucket.cfg
+
+buckets {
+  name: "ci"
+  acls {
+    role: WRITER
+    group: "project-libyuv-admins"
+  }
+  acls {
+    group: "all"
+  }
+  swarming {
+    builders {
+      name: "Android ARM64 Debug"
+      swarming_host: "chromium-swarm.appspot.com"
+      swarming_tags: "vpython:native-python-wrapper"
+      dimensions: "cores:8"
+      dimensions: "cpu:x86-64"
+      dimensions: "os:Ubuntu-18.04"
+      dimensions: "pool:luci.flex.ci"
+      exe {
+        cipd_package: "infra/recipe_bundles/chromium.googlesource.com/chromium/tools/build"
+        cipd_version: "refs/heads/main"
+        cmd: "luciexe"
+      }
+      properties:
+        '{'
+        '  "$build/goma": {'
+        '    "enable_ats": true,'
+        '    "server_host": "goma.chromium.org",'
+        '    "use_luci_auth": true'
+        '  },'
+        '  "builder_group": "client.libyuv",'
+        '  "recipe": "libyuv/libyuv"'
+        '}'
+      execution_timeout_secs: 10800
+      build_numbers: YES
+      service_account: "libyuv-ci-builder@chops-service-accounts.iam.gserviceaccount.com"
+      experiments {
+        key: "luci.recipes.use_python3"
+        value: 100
+      }
+    }
+    builders {
+      name: "Android Debug"
+      swarming_host: "chromium-swarm.appspot.com"
+      swarming_tags: "vpython:native-python-wrapper"
+      dimensions: "cores:8"
+      dimensions: "cpu:x86-64"
+      dimensions: "os:Ubuntu-18.04"
+      dimensions: "pool:luci.flex.ci"
+      exe {
+        cipd_package: "infra/recipe_bundles/chromium.googlesource.com/chromium/tools/build"
+        cipd_version: "refs/heads/main"
+        cmd: "luciexe"
+      }
+      properties:
+        '{'
+        '  "$build/goma": {'
+        '    "enable_ats": true,'
+        '    "server_host": "goma.chromium.org",'
+        '    "use_luci_auth": true'
+        '  },'
+        '  "builder_group": "client.libyuv",'
+        '  "recipe": "libyuv/libyuv"'
+        '}'
+      execution_timeout_secs: 10800
+      build_numbers: YES
+      service_account: "libyuv-ci-builder@chops-service-accounts.iam.gserviceaccount.com"
+      experiments {
+        key: "luci.recipes.use_python3"
+        value: 100
+      }
+    }
+    builders {
+      name: "Android Release"
+      swarming_host: "chromium-swarm.appspot.com"
+      swarming_tags: "vpython:native-python-wrapper"
+      dimensions: "cores:8"
+      dimensions: "cpu:x86-64"
+      dimensions: "os:Ubuntu-18.04"
+      dimensions: "pool:luci.flex.ci"
+      exe {
+        cipd_package: "infra/recipe_bundles/chromium.googlesource.com/chromium/tools/build"
+        cipd_version: "refs/heads/main"
+        cmd: "luciexe"
+      }
+      properties:
+        '{'
+        '  "$build/goma": {'
+        '    "enable_ats": true,'
+        '    "server_host": "goma.chromium.org",'
+        '    "use_luci_auth": true'
+        '  },'
+        '  "builder_group": "client.libyuv",'
+        '  "recipe": "libyuv/libyuv"'
+        '}'
+      execution_timeout_secs: 10800
+      build_numbers: YES
+      service_account: "libyuv-ci-builder@chops-service-accounts.iam.gserviceaccount.com"
+      experiments {
+        key: "luci.recipes.use_python3"
+        value: 100
+      }
+    }
+    builders {
+      name: "Android Tester ARM32 Debug (Nexus 5X)"
+      swarming_host: "chromium-swarm.appspot.com"
+      swarming_tags: "vpython:native-python-wrapper"
+      dimensions: "device_type:bullhead"
+      dimensions: "pool:luci.flex.ci"
+      exe {
+        cipd_package: "infra/recipe_bundles/chromium.googlesource.com/chromium/tools/build"
+        cipd_version: "refs/heads/main"
+        cmd: "luciexe"
+      }
+      properties:
+        '{'
+        '  "$build/goma": {'
+        '    "server_host": "goma.chromium.org",'
+        '    "use_luci_auth": true'
+        '  },'
+        '  "builder_group": "client.libyuv",'
+        '  "recipe": "libyuv/libyuv"'
+        '}'
+      execution_timeout_secs: 10800
+      build_numbers: YES
+      service_account: "libyuv-ci-builder@chops-service-accounts.iam.gserviceaccount.com"
+      experiments {
+        key: "luci.recipes.use_python3"
+        value: 100
+      }
+    }
+    builders {
+      name: "Android Tester ARM32 Release (Nexus 5X)"
+      swarming_host: "chromium-swarm.appspot.com"
+      swarming_tags: "vpython:native-python-wrapper"
+      dimensions: "device_type:bullhead"
+      dimensions: "pool:luci.flex.ci"
+      exe {
+        cipd_package: "infra/recipe_bundles/chromium.googlesource.com/chromium/tools/build"
+        cipd_version: "refs/heads/main"
+        cmd: "luciexe"
+      }
+      properties:
+        '{'
+        '  "$build/goma": {'
+        '    "server_host": "goma.chromium.org",'
+        '    "use_luci_auth": true'
+        '  },'
+        '  "builder_group": "client.libyuv",'
+        '  "recipe": "libyuv/libyuv"'
+        '}'
+      execution_timeout_secs: 10800
+      build_numbers: YES
+      service_account: "libyuv-ci-builder@chops-service-accounts.iam.gserviceaccount.com"
+      experiments {
+        key: "luci.recipes.use_python3"
+        value: 100
+      }
+    }
+    builders {
+      name: "Android Tester ARM64 Debug (Nexus 5X)"
+      swarming_host: "chromium-swarm.appspot.com"
+      swarming_tags: "vpython:native-python-wrapper"
+      dimensions: "device_type:bullhead"
+      dimensions: "pool:luci.flex.ci"
+      exe {
+        cipd_package: "infra/recipe_bundles/chromium.googlesource.com/chromium/tools/build"
+        cipd_version: "refs/heads/main"
+        cmd: "luciexe"
+      }
+      properties:
+        '{'
+        '  "$build/goma": {'
+        '    "server_host": "goma.chromium.org",'
+        '    "use_luci_auth": true'
+        '  },'
+        '  "builder_group": "client.libyuv",'
+        '  "recipe": "libyuv/libyuv"'
+        '}'
+      execution_timeout_secs: 10800
+      build_numbers: YES
+      service_account: "libyuv-ci-builder@chops-service-accounts.iam.gserviceaccount.com"
+      experiments {
+        key: "luci.recipes.use_python3"
+        value: 100
+      }
+    }
+    builders {
+      name: "Android32 x86 Debug"
+      swarming_host: "chromium-swarm.appspot.com"
+      swarming_tags: "vpython:native-python-wrapper"
+      dimensions: "cores:8"
+      dimensions: "cpu:x86-64"
+      dimensions: "os:Ubuntu-18.04"
+      dimensions: "pool:luci.flex.ci"
+      exe {
+        cipd_package: "infra/recipe_bundles/chromium.googlesource.com/chromium/tools/build"
+        cipd_version: "refs/heads/main"
+        cmd: "luciexe"
+      }
+      properties:
+        '{'
+        '  "$build/goma": {'
+        '    "enable_ats": true,'
+        '    "server_host": "goma.chromium.org",'
+        '    "use_luci_auth": true'
+        '  },'
+        '  "builder_group": "client.libyuv",'
+        '  "recipe": "libyuv/libyuv"'
+        '}'
+      execution_timeout_secs: 10800
+      build_numbers: YES
+      service_account: "libyuv-ci-builder@chops-service-accounts.iam.gserviceaccount.com"
+      experiments {
+        key: "luci.recipes.use_python3"
+        value: 100
+      }
+    }
+    builders {
+      name: "Android64 x64 Debug"
+      swarming_host: "chromium-swarm.appspot.com"
+      swarming_tags: "vpython:native-python-wrapper"
+      dimensions: "cores:8"
+      dimensions: "cpu:x86-64"
+      dimensions: "os:Ubuntu-18.04"
+      dimensions: "pool:luci.flex.ci"
+      exe {
+        cipd_package: "infra/recipe_bundles/chromium.googlesource.com/chromium/tools/build"
+        cipd_version: "refs/heads/main"
+        cmd: "luciexe"
+      }
+      properties:
+        '{'
+        '  "$build/goma": {'
+        '    "enable_ats": true,'
+        '    "server_host": "goma.chromium.org",'
+        '    "use_luci_auth": true'
+        '  },'
+        '  "builder_group": "client.libyuv",'
+        '  "recipe": "libyuv/libyuv"'
+        '}'
+      execution_timeout_secs: 10800
+      build_numbers: YES
+      service_account: "libyuv-ci-builder@chops-service-accounts.iam.gserviceaccount.com"
+      experiments {
+        key: "luci.recipes.use_python3"
+        value: 100
+      }
+    }
+    builders {
+      name: "Linux Asan"
+      swarming_host: "chromium-swarm.appspot.com"
+      swarming_tags: "vpython:native-python-wrapper"
+      dimensions: "cores:8"
+      dimensions: "cpu:x86-64"
+      dimensions: "os:Ubuntu-18.04"
+      dimensions: "pool:luci.flex.ci"
+      exe {
+        cipd_package: "infra/recipe_bundles/chromium.googlesource.com/chromium/tools/build"
+        cipd_version: "refs/heads/main"
+        cmd: "luciexe"
+      }
+      properties:
+        '{'
+        '  "$build/goma": {'
+        '    "enable_ats": true,'
+        '    "server_host": "goma.chromium.org",'
+        '    "use_luci_auth": true'
+        '  },'
+        '  "builder_group": "client.libyuv",'
+        '  "recipe": "libyuv/libyuv"'
+        '}'
+      execution_timeout_secs: 10800
+      build_numbers: YES
+      service_account: "libyuv-ci-builder@chops-service-accounts.iam.gserviceaccount.com"
+      experiments {
+        key: "luci.recipes.use_python3"
+        value: 100
+      }
+    }
+    builders {
+      name: "Linux MSan"
+      swarming_host: "chromium-swarm.appspot.com"
+      swarming_tags: "vpython:native-python-wrapper"
+      dimensions: "cores:8"
+      dimensions: "cpu:x86-64"
+      dimensions: "os:Ubuntu-18.04"
+      dimensions: "pool:luci.flex.ci"
+      exe {
+        cipd_package: "infra/recipe_bundles/chromium.googlesource.com/chromium/tools/build"
+        cipd_version: "refs/heads/main"
+        cmd: "luciexe"
+      }
+      properties:
+        '{'
+        '  "$build/goma": {'
+        '    "enable_ats": true,'
+        '    "server_host": "goma.chromium.org",'
+        '    "use_luci_auth": true'
+        '  },'
+        '  "builder_group": "client.libyuv",'
+        '  "recipe": "libyuv/libyuv"'
+        '}'
+      execution_timeout_secs: 10800
+      build_numbers: YES
+      service_account: "libyuv-ci-builder@chops-service-accounts.iam.gserviceaccount.com"
+      experiments {
+        key: "luci.recipes.use_python3"
+        value: 100
+      }
+    }
+    builders {
+      name: "Linux Tsan v2"
+      swarming_host: "chromium-swarm.appspot.com"
+      swarming_tags: "vpython:native-python-wrapper"
+      dimensions: "cores:8"
+      dimensions: "cpu:x86-64"
+      dimensions: "os:Ubuntu-18.04"
+      dimensions: "pool:luci.flex.ci"
+      exe {
+        cipd_package: "infra/recipe_bundles/chromium.googlesource.com/chromium/tools/build"
+        cipd_version: "refs/heads/main"
+        cmd: "luciexe"
+      }
+      properties:
+        '{'
+        '  "$build/goma": {'
+        '    "enable_ats": true,'
+        '    "server_host": "goma.chromium.org",'
+        '    "use_luci_auth": true'
+        '  },'
+        '  "builder_group": "client.libyuv",'
+        '  "recipe": "libyuv/libyuv"'
+        '}'
+      execution_timeout_secs: 10800
+      build_numbers: YES
+      service_account: "libyuv-ci-builder@chops-service-accounts.iam.gserviceaccount.com"
+      experiments {
+        key: "luci.recipes.use_python3"
+        value: 100
+      }
+    }
+    builders {
+      name: "Linux UBSan"
+      swarming_host: "chromium-swarm.appspot.com"
+      swarming_tags: "vpython:native-python-wrapper"
+      dimensions: "cores:8"
+      dimensions: "cpu:x86-64"
+      dimensions: "os:Ubuntu-18.04"
+      dimensions: "pool:luci.flex.ci"
+      exe {
+        cipd_package: "infra/recipe_bundles/chromium.googlesource.com/chromium/tools/build"
+        cipd_version: "refs/heads/main"
+        cmd: "luciexe"
+      }
+      properties:
+        '{'
+        '  "$build/goma": {'
+        '    "enable_ats": true,'
+        '    "server_host": "goma.chromium.org",'
+        '    "use_luci_auth": true'
+        '  },'
+        '  "builder_group": "client.libyuv",'
+        '  "recipe": "libyuv/libyuv"'
+        '}'
+      execution_timeout_secs: 10800
+      build_numbers: YES
+      service_account: "libyuv-ci-builder@chops-service-accounts.iam.gserviceaccount.com"
+      experiments {
+        key: "luci.recipes.use_python3"
+        value: 100
+      }
+    }
+    builders {
+      name: "Linux UBSan vptr"
+      swarming_host: "chromium-swarm.appspot.com"
+      swarming_tags: "vpython:native-python-wrapper"
+      dimensions: "cores:8"
+      dimensions: "cpu:x86-64"
+      dimensions: "os:Ubuntu-18.04"
+      dimensions: "pool:luci.flex.ci"
+      exe {
+        cipd_package: "infra/recipe_bundles/chromium.googlesource.com/chromium/tools/build"
+        cipd_version: "refs/heads/main"
+        cmd: "luciexe"
+      }
+      properties:
+        '{'
+        '  "$build/goma": {'
+        '    "enable_ats": true,'
+        '    "server_host": "goma.chromium.org",'
+        '    "use_luci_auth": true'
+        '  },'
+        '  "builder_group": "client.libyuv",'
+        '  "recipe": "libyuv/libyuv"'
+        '}'
+      execution_timeout_secs: 10800
+      build_numbers: YES
+      service_account: "libyuv-ci-builder@chops-service-accounts.iam.gserviceaccount.com"
+      experiments {
+        key: "luci.recipes.use_python3"
+        value: 100
+      }
+    }
+    builders {
+      name: "Linux32 Debug"
+      swarming_host: "chromium-swarm.appspot.com"
+      swarming_tags: "vpython:native-python-wrapper"
+      dimensions: "cores:8"
+      dimensions: "cpu:x86-64"
+      dimensions: "os:Ubuntu-18.04"
+      dimensions: "pool:luci.flex.ci"
+      exe {
+        cipd_package: "infra/recipe_bundles/chromium.googlesource.com/chromium/tools/build"
+        cipd_version: "refs/heads/main"
+        cmd: "luciexe"
+      }
+      properties:
+        '{'
+        '  "$build/goma": {'
+        '    "enable_ats": true,'
+        '    "server_host": "goma.chromium.org",'
+        '    "use_luci_auth": true'
+        '  },'
+        '  "builder_group": "client.libyuv",'
+        '  "recipe": "libyuv/libyuv"'
+        '}'
+      execution_timeout_secs: 10800
+      build_numbers: YES
+      service_account: "libyuv-ci-builder@chops-service-accounts.iam.gserviceaccount.com"
+      experiments {
+        key: "luci.recipes.use_python3"
+        value: 100
+      }
+    }
+    builders {
+      name: "Linux32 Release"
+      swarming_host: "chromium-swarm.appspot.com"
+      swarming_tags: "vpython:native-python-wrapper"
+      dimensions: "cores:8"
+      dimensions: "cpu:x86-64"
+      dimensions: "os:Ubuntu-18.04"
+      dimensions: "pool:luci.flex.ci"
+      exe {
+        cipd_package: "infra/recipe_bundles/chromium.googlesource.com/chromium/tools/build"
+        cipd_version: "refs/heads/main"
+        cmd: "luciexe"
+      }
+      properties:
+        '{'
+        '  "$build/goma": {'
+        '    "enable_ats": true,'
+        '    "server_host": "goma.chromium.org",'
+        '    "use_luci_auth": true'
+        '  },'
+        '  "builder_group": "client.libyuv",'
+        '  "recipe": "libyuv/libyuv"'
+        '}'
+      execution_timeout_secs: 10800
+      build_numbers: YES
+      service_account: "libyuv-ci-builder@chops-service-accounts.iam.gserviceaccount.com"
+      experiments {
+        key: "luci.recipes.use_python3"
+        value: 100
+      }
+    }
+    builders {
+      name: "Linux64 Debug"
+      swarming_host: "chromium-swarm.appspot.com"
+      swarming_tags: "vpython:native-python-wrapper"
+      dimensions: "cores:8"
+      dimensions: "cpu:x86-64"
+      dimensions: "os:Ubuntu-18.04"
+      dimensions: "pool:luci.flex.ci"
+      exe {
+        cipd_package: "infra/recipe_bundles/chromium.googlesource.com/chromium/tools/build"
+        cipd_version: "refs/heads/main"
+        cmd: "luciexe"
+      }
+      properties:
+        '{'
+        '  "$build/goma": {'
+        '    "enable_ats": true,'
+        '    "server_host": "goma.chromium.org",'
+        '    "use_luci_auth": true'
+        '  },'
+        '  "builder_group": "client.libyuv",'
+        '  "recipe": "libyuv/libyuv"'
+        '}'
+      execution_timeout_secs: 10800
+      build_numbers: YES
+      service_account: "libyuv-ci-builder@chops-service-accounts.iam.gserviceaccount.com"
+      experiments {
+        key: "luci.recipes.use_python3"
+        value: 100
+      }
+    }
+    builders {
+      name: "Linux64 Release"
+      swarming_host: "chromium-swarm.appspot.com"
+      swarming_tags: "vpython:native-python-wrapper"
+      dimensions: "cores:8"
+      dimensions: "cpu:x86-64"
+      dimensions: "os:Ubuntu-18.04"
+      dimensions: "pool:luci.flex.ci"
+      exe {
+        cipd_package: "infra/recipe_bundles/chromium.googlesource.com/chromium/tools/build"
+        cipd_version: "refs/heads/main"
+        cmd: "luciexe"
+      }
+      properties:
+        '{'
+        '  "$build/goma": {'
+        '    "enable_ats": true,'
+        '    "server_host": "goma.chromium.org",'
+        '    "use_luci_auth": true'
+        '  },'
+        '  "builder_group": "client.libyuv",'
+        '  "recipe": "libyuv/libyuv"'
+        '}'
+      execution_timeout_secs: 10800
+      build_numbers: YES
+      service_account: "libyuv-ci-builder@chops-service-accounts.iam.gserviceaccount.com"
+      experiments {
+        key: "luci.recipes.use_python3"
+        value: 100
+      }
+    }
+    builders {
+      name: "Mac Asan"
+      swarming_host: "chromium-swarm.appspot.com"
+      swarming_tags: "vpython:native-python-wrapper"
+      dimensions: "cpu:x86-64"
+      dimensions: "os:Mac-10.15"
+      dimensions: "pool:luci.flex.ci"
+      exe {
+        cipd_package: "infra/recipe_bundles/chromium.googlesource.com/chromium/tools/build"
+        cipd_version: "refs/heads/main"
+        cmd: "luciexe"
+      }
+      properties:
+        '{'
+        '  "$build/goma": {'
+        '    "server_host": "goma.chromium.org",'
+        '    "use_luci_auth": true'
+        '  },'
+        '  "builder_group": "client.libyuv",'
+        '  "recipe": "libyuv/libyuv"'
+        '}'
+      execution_timeout_secs: 10800
+      build_numbers: YES
+      service_account: "libyuv-ci-builder@chops-service-accounts.iam.gserviceaccount.com"
+      experiments {
+        key: "luci.recipes.use_python3"
+        value: 100
+      }
+    }
+    builders {
+      name: "Mac64 Debug"
+      swarming_host: "chromium-swarm.appspot.com"
+      swarming_tags: "vpython:native-python-wrapper"
+      dimensions: "cpu:x86-64"
+      dimensions: "os:Mac-10.15"
+      dimensions: "pool:luci.flex.ci"
+      exe {
+        cipd_package: "infra/recipe_bundles/chromium.googlesource.com/chromium/tools/build"
+        cipd_version: "refs/heads/main"
+        cmd: "luciexe"
+      }
+      properties:
+        '{'
+        '  "$build/goma": {'
+        '    "server_host": "goma.chromium.org",'
+        '    "use_luci_auth": true'
+        '  },'
+        '  "builder_group": "client.libyuv",'
+        '  "recipe": "libyuv/libyuv"'
+        '}'
+      execution_timeout_secs: 10800
+      build_numbers: YES
+      service_account: "libyuv-ci-builder@chops-service-accounts.iam.gserviceaccount.com"
+      experiments {
+        key: "luci.recipes.use_python3"
+        value: 100
+      }
+    }
+    builders {
+      name: "Mac64 Release"
+      swarming_host: "chromium-swarm.appspot.com"
+      swarming_tags: "vpython:native-python-wrapper"
+      dimensions: "cpu:x86-64"
+      dimensions: "os:Mac-10.15"
+      dimensions: "pool:luci.flex.ci"
+      exe {
+        cipd_package: "infra/recipe_bundles/chromium.googlesource.com/chromium/tools/build"
+        cipd_version: "refs/heads/main"
+        cmd: "luciexe"
+      }
+      properties:
+        '{'
+        '  "$build/goma": {'
+        '    "server_host": "goma.chromium.org",'
+        '    "use_luci_auth": true'
+        '  },'
+        '  "builder_group": "client.libyuv",'
+        '  "recipe": "libyuv/libyuv"'
+        '}'
+      execution_timeout_secs: 10800
+      build_numbers: YES
+      service_account: "libyuv-ci-builder@chops-service-accounts.iam.gserviceaccount.com"
+      experiments {
+        key: "luci.recipes.use_python3"
+        value: 100
+      }
+    }
+    builders {
+      name: "Win32 Debug"
+      swarming_host: "chromium-swarm.appspot.com"
+      swarming_tags: "vpython:native-python-wrapper"
+      dimensions: "cores:8"
+      dimensions: "cpu:x86-64"
+      dimensions: "os:Windows-10"
+      dimensions: "pool:luci.flex.ci"
+      exe {
+        cipd_package: "infra/recipe_bundles/chromium.googlesource.com/chromium/tools/build"
+        cipd_version: "refs/heads/main"
+        cmd: "luciexe"
+      }
+      properties:
+        '{'
+        '  "$build/goma": {'
+        '    "enable_ats": true,'
+        '    "server_host": "goma.chromium.org",'
+        '    "use_luci_auth": true'
+        '  },'
+        '  "builder_group": "client.libyuv",'
+        '  "recipe": "libyuv/libyuv"'
+        '}'
+      execution_timeout_secs: 10800
+      build_numbers: YES
+      service_account: "libyuv-ci-builder@chops-service-accounts.iam.gserviceaccount.com"
+      experiments {
+        key: "luci.recipes.use_python3"
+        value: 100
+      }
+    }
+    builders {
+      name: "Win32 Debug (Clang)"
+      swarming_host: "chromium-swarm.appspot.com"
+      swarming_tags: "vpython:native-python-wrapper"
+      dimensions: "cores:8"
+      dimensions: "cpu:x86-64"
+      dimensions: "os:Windows-10"
+      dimensions: "pool:luci.flex.ci"
+      exe {
+        cipd_package: "infra/recipe_bundles/chromium.googlesource.com/chromium/tools/build"
+        cipd_version: "refs/heads/main"
+        cmd: "luciexe"
+      }
+      properties:
+        '{'
+        '  "$build/goma": {'
+        '    "enable_ats": true,'
+        '    "server_host": "goma.chromium.org",'
+        '    "use_luci_auth": true'
+        '  },'
+        '  "builder_group": "client.libyuv",'
+        '  "recipe": "libyuv/libyuv"'
+        '}'
+      execution_timeout_secs: 10800
+      build_numbers: YES
+      service_account: "libyuv-ci-builder@chops-service-accounts.iam.gserviceaccount.com"
+      experiments {
+        key: "luci.recipes.use_python3"
+        value: 100
+      }
+    }
+    builders {
+      name: "Win32 Release"
+      swarming_host: "chromium-swarm.appspot.com"
+      swarming_tags: "vpython:native-python-wrapper"
+      dimensions: "cores:8"
+      dimensions: "cpu:x86-64"
+      dimensions: "os:Windows-10"
+      dimensions: "pool:luci.flex.ci"
+      exe {
+        cipd_package: "infra/recipe_bundles/chromium.googlesource.com/chromium/tools/build"
+        cipd_version: "refs/heads/main"
+        cmd: "luciexe"
+      }
+      properties:
+        '{'
+        '  "$build/goma": {'
+        '    "enable_ats": true,'
+        '    "server_host": "goma.chromium.org",'
+        '    "use_luci_auth": true'
+        '  },'
+        '  "builder_group": "client.libyuv",'
+        '  "recipe": "libyuv/libyuv"'
+        '}'
+      execution_timeout_secs: 10800
+      build_numbers: YES
+      service_account: "libyuv-ci-builder@chops-service-accounts.iam.gserviceaccount.com"
+      experiments {
+        key: "luci.recipes.use_python3"
+        value: 100
+      }
+    }
+    builders {
+      name: "Win32 Release (Clang)"
+      swarming_host: "chromium-swarm.appspot.com"
+      swarming_tags: "vpython:native-python-wrapper"
+      dimensions: "cores:8"
+      dimensions: "cpu:x86-64"
+      dimensions: "os:Windows-10"
+      dimensions: "pool:luci.flex.ci"
+      exe {
+        cipd_package: "infra/recipe_bundles/chromium.googlesource.com/chromium/tools/build"
+        cipd_version: "refs/heads/main"
+        cmd: "luciexe"
+      }
+      properties:
+        '{'
+        '  "$build/goma": {'
+        '    "enable_ats": true,'
+        '    "server_host": "goma.chromium.org",'
+        '    "use_luci_auth": true'
+        '  },'
+        '  "builder_group": "client.libyuv",'
+        '  "recipe": "libyuv/libyuv"'
+        '}'
+      execution_timeout_secs: 10800
+      build_numbers: YES
+      service_account: "libyuv-ci-builder@chops-service-accounts.iam.gserviceaccount.com"
+      experiments {
+        key: "luci.recipes.use_python3"
+        value: 100
+      }
+    }
+    builders {
+      name: "Win64 Debug"
+      swarming_host: "chromium-swarm.appspot.com"
+      swarming_tags: "vpython:native-python-wrapper"
+      dimensions: "cores:8"
+      dimensions: "cpu:x86-64"
+      dimensions: "os:Windows-10"
+      dimensions: "pool:luci.flex.ci"
+      exe {
+        cipd_package: "infra/recipe_bundles/chromium.googlesource.com/chromium/tools/build"
+        cipd_version: "refs/heads/main"
+        cmd: "luciexe"
+      }
+      properties:
+        '{'
+        '  "$build/goma": {'
+        '    "enable_ats": true,'
+        '    "server_host": "goma.chromium.org",'
+        '    "use_luci_auth": true'
+        '  },'
+        '  "builder_group": "client.libyuv",'
+        '  "recipe": "libyuv/libyuv"'
+        '}'
+      execution_timeout_secs: 10800
+      build_numbers: YES
+      service_account: "libyuv-ci-builder@chops-service-accounts.iam.gserviceaccount.com"
+      experiments {
+        key: "luci.recipes.use_python3"
+        value: 100
+      }
+    }
+    builders {
+      name: "Win64 Debug (Clang)"
+      swarming_host: "chromium-swarm.appspot.com"
+      swarming_tags: "vpython:native-python-wrapper"
+      dimensions: "cores:8"
+      dimensions: "cpu:x86-64"
+      dimensions: "os:Windows-10"
+      dimensions: "pool:luci.flex.ci"
+      exe {
+        cipd_package: "infra/recipe_bundles/chromium.googlesource.com/chromium/tools/build"
+        cipd_version: "refs/heads/main"
+        cmd: "luciexe"
+      }
+      properties:
+        '{'
+        '  "$build/goma": {'
+        '    "enable_ats": true,'
+        '    "server_host": "goma.chromium.org",'
+        '    "use_luci_auth": true'
+        '  },'
+        '  "builder_group": "client.libyuv",'
+        '  "recipe": "libyuv/libyuv"'
+        '}'
+      execution_timeout_secs: 10800
+      build_numbers: YES
+      service_account: "libyuv-ci-builder@chops-service-accounts.iam.gserviceaccount.com"
+      experiments {
+        key: "luci.recipes.use_python3"
+        value: 100
+      }
+    }
+    builders {
+      name: "Win64 Release"
+      swarming_host: "chromium-swarm.appspot.com"
+      swarming_tags: "vpython:native-python-wrapper"
+      dimensions: "cores:8"
+      dimensions: "cpu:x86-64"
+      dimensions: "os:Windows-10"
+      dimensions: "pool:luci.flex.ci"
+      exe {
+        cipd_package: "infra/recipe_bundles/chromium.googlesource.com/chromium/tools/build"
+        cipd_version: "refs/heads/main"
+        cmd: "luciexe"
+      }
+      properties:
+        '{'
+        '  "$build/goma": {'
+        '    "enable_ats": true,'
+        '    "server_host": "goma.chromium.org",'
+        '    "use_luci_auth": true'
+        '  },'
+        '  "builder_group": "client.libyuv",'
+        '  "recipe": "libyuv/libyuv"'
+        '}'
+      execution_timeout_secs: 10800
+      build_numbers: YES
+      service_account: "libyuv-ci-builder@chops-service-accounts.iam.gserviceaccount.com"
+      experiments {
+        key: "luci.recipes.use_python3"
+        value: 100
+      }
+    }
+    builders {
+      name: "Win64 Release (Clang)"
+      swarming_host: "chromium-swarm.appspot.com"
+      swarming_tags: "vpython:native-python-wrapper"
+      dimensions: "cores:8"
+      dimensions: "cpu:x86-64"
+      dimensions: "os:Windows-10"
+      dimensions: "pool:luci.flex.ci"
+      exe {
+        cipd_package: "infra/recipe_bundles/chromium.googlesource.com/chromium/tools/build"
+        cipd_version: "refs/heads/main"
+        cmd: "luciexe"
+      }
+      properties:
+        '{'
+        '  "$build/goma": {'
+        '    "enable_ats": true,'
+        '    "server_host": "goma.chromium.org",'
+        '    "use_luci_auth": true'
+        '  },'
+        '  "builder_group": "client.libyuv",'
+        '  "recipe": "libyuv/libyuv"'
+        '}'
+      execution_timeout_secs: 10800
+      build_numbers: YES
+      service_account: "libyuv-ci-builder@chops-service-accounts.iam.gserviceaccount.com"
+      experiments {
+        key: "luci.recipes.use_python3"
+        value: 100
+      }
+    }
+    builders {
+      name: "iOS ARM64 Debug"
+      swarming_host: "chromium-swarm.appspot.com"
+      swarming_tags: "vpython:native-python-wrapper"
+      dimensions: "cpu:x86-64"
+      dimensions: "os:Mac-10.15"
+      dimensions: "pool:luci.flex.ci"
+      exe {
+        cipd_package: "infra/recipe_bundles/chromium.googlesource.com/chromium/tools/build"
+        cipd_version: "refs/heads/main"
+        cmd: "luciexe"
+      }
+      properties:
+        '{'
+        '  "$build/goma": {'
+        '    "server_host": "goma.chromium.org",'
+        '    "use_luci_auth": true'
+        '  },'
+        '  "builder_group": "client.libyuv",'
+        '  "recipe": "libyuv/libyuv"'
+        '}'
+      execution_timeout_secs: 10800
+      build_numbers: YES
+      service_account: "libyuv-ci-builder@chops-service-accounts.iam.gserviceaccount.com"
+      experiments {
+        key: "luci.recipes.use_python3"
+        value: 100
+      }
+    }
+    builders {
+      name: "iOS ARM64 Release"
+      swarming_host: "chromium-swarm.appspot.com"
+      swarming_tags: "vpython:native-python-wrapper"
+      dimensions: "cpu:x86-64"
+      dimensions: "os:Mac-10.15"
+      dimensions: "pool:luci.flex.ci"
+      exe {
+        cipd_package: "infra/recipe_bundles/chromium.googlesource.com/chromium/tools/build"
+        cipd_version: "refs/heads/main"
+        cmd: "luciexe"
+      }
+      properties:
+        '{'
+        '  "$build/goma": {'
+        '    "server_host": "goma.chromium.org",'
+        '    "use_luci_auth": true'
+        '  },'
+        '  "builder_group": "client.libyuv",'
+        '  "recipe": "libyuv/libyuv"'
+        '}'
+      execution_timeout_secs: 10800
+      build_numbers: YES
+      service_account: "libyuv-ci-builder@chops-service-accounts.iam.gserviceaccount.com"
+      experiments {
+        key: "luci.recipes.use_python3"
+        value: 100
+      }
+    }
+  }
+}
+buckets {
+  name: "cron"
+  acls {
+    role: WRITER
+    group: "project-libyuv-admins"
+  }
+  acls {
+    group: "all"
+  }
+  swarming {
+    builders {
+      name: "DEPS Autoroller"
+      swarming_host: "chromium-swarm.appspot.com"
+      swarming_tags: "vpython:native-python-wrapper"
+      dimensions: "cpu:x86-64"
+      dimensions: "os:Linux"
+      dimensions: "pool:luci.webrtc.cron"
+      exe {
+        cipd_package: "infra/recipe_bundles/chromium.googlesource.com/chromium/tools/build"
+        cipd_version: "refs/heads/main"
+        cmd: "luciexe"
+      }
+      properties:
+        '{'
+        '  "recipe": "libyuv/roll_deps"'
+        '}'
+      execution_timeout_secs: 7200
+      build_numbers: YES
+      service_account: "libyuv-ci-autoroll-builder@chops-service-accounts.iam.gserviceaccount.com"
+      experiments {
+        key: "luci.recipes.use_python3"
+        value: 100
+      }
+    }
+  }
+}
+buckets {
+  name: "try"
+  acls {
+    role: WRITER
+    group: "project-libyuv-admins"
+  }
+  acls {
+    group: "all"
+  }
+  acls {
+    role: SCHEDULER
+    group: "project-libyuv-tryjob-access"
+  }
+  acls {
+    role: SCHEDULER
+    group: "service-account-cq"
+  }
+  swarming {
+    builders {
+      name: "android"
+      swarming_host: "chromium-swarm.appspot.com"
+      swarming_tags: "vpython:native-python-wrapper"
+      dimensions: "device_type:bullhead"
+      dimensions: "pool:luci.flex.try"
+      exe {
+        cipd_package: "infra/recipe_bundles/chromium.googlesource.com/chromium/tools/build"
+        cipd_version: "refs/heads/main"
+        cmd: "luciexe"
+      }
+      properties:
+        '{'
+        '  "$build/goma": {'
+        '    "server_host": "goma.chromium.org",'
+        '    "use_luci_auth": true'
+        '  },'
+        '  "builder_group": "tryserver.libyuv",'
+        '  "recipe": "libyuv/libyuv"'
+        '}'
+      execution_timeout_secs: 10800
+      build_numbers: YES
+      service_account: "libyuv-try-builder@chops-service-accounts.iam.gserviceaccount.com"
+      experiments {
+        key: "luci.recipes.use_python3"
+        value: 100
+      }
+    }
+    builders {
+      name: "android_arm64"
+      swarming_host: "chromium-swarm.appspot.com"
+      swarming_tags: "vpython:native-python-wrapper"
+      dimensions: "device_type:bullhead"
+      dimensions: "pool:luci.flex.try"
+      exe {
+        cipd_package: "infra/recipe_bundles/chromium.googlesource.com/chromium/tools/build"
+        cipd_version: "refs/heads/main"
+        cmd: "luciexe"
+      }
+      properties:
+        '{'
+        '  "$build/goma": {'
+        '    "server_host": "goma.chromium.org",'
+        '    "use_luci_auth": true'
+        '  },'
+        '  "builder_group": "tryserver.libyuv",'
+        '  "recipe": "libyuv/libyuv"'
+        '}'
+      execution_timeout_secs: 10800
+      build_numbers: YES
+      service_account: "libyuv-try-builder@chops-service-accounts.iam.gserviceaccount.com"
+      experiments {
+        key: "luci.recipes.use_python3"
+        value: 100
+      }
+    }
+    builders {
+      name: "android_rel"
+      swarming_host: "chromium-swarm.appspot.com"
+      swarming_tags: "vpython:native-python-wrapper"
+      dimensions: "device_type:bullhead"
+      dimensions: "pool:luci.flex.try"
+      exe {
+        cipd_package: "infra/recipe_bundles/chromium.googlesource.com/chromium/tools/build"
+        cipd_version: "refs/heads/main"
+        cmd: "luciexe"
+      }
+      properties:
+        '{'
+        '  "$build/goma": {'
+        '    "server_host": "goma.chromium.org",'
+        '    "use_luci_auth": true'
+        '  },'
+        '  "builder_group": "tryserver.libyuv",'
+        '  "recipe": "libyuv/libyuv"'
+        '}'
+      execution_timeout_secs: 10800
+      build_numbers: YES
+      service_account: "libyuv-try-builder@chops-service-accounts.iam.gserviceaccount.com"
+      experiments {
+        key: "luci.recipes.use_python3"
+        value: 100
+      }
+    }
+    builders {
+      name: "android_x64"
+      swarming_host: "chromium-swarm.appspot.com"
+      swarming_tags: "vpython:native-python-wrapper"
+      dimensions: "cores:8"
+      dimensions: "cpu:x86-64"
+      dimensions: "os:Ubuntu-18.04"
+      dimensions: "pool:luci.flex.try"
+      exe {
+        cipd_package: "infra/recipe_bundles/chromium.googlesource.com/chromium/tools/build"
+        cipd_version: "refs/heads/main"
+        cmd: "luciexe"
+      }
+      properties:
+        '{'
+        '  "$build/goma": {'
+        '    "enable_ats": true,'
+        '    "server_host": "goma.chromium.org",'
+        '    "use_luci_auth": true'
+        '  },'
+        '  "builder_group": "tryserver.libyuv",'
+        '  "recipe": "libyuv/libyuv"'
+        '}'
+      execution_timeout_secs: 10800
+      build_numbers: YES
+      service_account: "libyuv-try-builder@chops-service-accounts.iam.gserviceaccount.com"
+      experiments {
+        key: "luci.recipes.use_python3"
+        value: 100
+      }
+    }
+    builders {
+      name: "android_x86"
+      swarming_host: "chromium-swarm.appspot.com"
+      swarming_tags: "vpython:native-python-wrapper"
+      dimensions: "cores:8"
+      dimensions: "cpu:x86-64"
+      dimensions: "os:Ubuntu-18.04"
+      dimensions: "pool:luci.flex.try"
+      exe {
+        cipd_package: "infra/recipe_bundles/chromium.googlesource.com/chromium/tools/build"
+        cipd_version: "refs/heads/main"
+        cmd: "luciexe"
+      }
+      properties:
+        '{'
+        '  "$build/goma": {'
+        '    "enable_ats": true,'
+        '    "server_host": "goma.chromium.org",'
+        '    "use_luci_auth": true'
+        '  },'
+        '  "builder_group": "tryserver.libyuv",'
+        '  "recipe": "libyuv/libyuv"'
+        '}'
+      execution_timeout_secs: 10800
+      build_numbers: YES
+      service_account: "libyuv-try-builder@chops-service-accounts.iam.gserviceaccount.com"
+      experiments {
+        key: "luci.recipes.use_python3"
+        value: 100
+      }
+    }
+    builders {
+      name: "ios_arm64"
+      swarming_host: "chromium-swarm.appspot.com"
+      swarming_tags: "vpython:native-python-wrapper"
+      dimensions: "cpu:x86-64"
+      dimensions: "os:Mac-10.15"
+      dimensions: "pool:luci.flex.try"
+      exe {
+        cipd_package: "infra/recipe_bundles/chromium.googlesource.com/chromium/tools/build"
+        cipd_version: "refs/heads/main"
+        cmd: "luciexe"
+      }
+      properties:
+        '{'
+        '  "$build/goma": {'
+        '    "server_host": "goma.chromium.org",'
+        '    "use_luci_auth": true'
+        '  },'
+        '  "builder_group": "tryserver.libyuv",'
+        '  "recipe": "libyuv/libyuv"'
+        '}'
+      execution_timeout_secs: 10800
+      build_numbers: YES
+      service_account: "libyuv-try-builder@chops-service-accounts.iam.gserviceaccount.com"
+      experiments {
+        key: "luci.recipes.use_python3"
+        value: 100
+      }
+    }
+    builders {
+      name: "ios_arm64_rel"
+      swarming_host: "chromium-swarm.appspot.com"
+      swarming_tags: "vpython:native-python-wrapper"
+      dimensions: "cpu:x86-64"
+      dimensions: "os:Mac-10.15"
+      dimensions: "pool:luci.flex.try"
+      exe {
+        cipd_package: "infra/recipe_bundles/chromium.googlesource.com/chromium/tools/build"
+        cipd_version: "refs/heads/main"
+        cmd: "luciexe"
+      }
+      properties:
+        '{'
+        '  "$build/goma": {'
+        '    "server_host": "goma.chromium.org",'
+        '    "use_luci_auth": true'
+        '  },'
+        '  "builder_group": "tryserver.libyuv",'
+        '  "recipe": "libyuv/libyuv"'
+        '}'
+      execution_timeout_secs: 10800
+      build_numbers: YES
+      service_account: "libyuv-try-builder@chops-service-accounts.iam.gserviceaccount.com"
+      experiments {
+        key: "luci.recipes.use_python3"
+        value: 100
+      }
+    }
+    builders {
+      name: "linux"
+      swarming_host: "chromium-swarm.appspot.com"
+      swarming_tags: "vpython:native-python-wrapper"
+      dimensions: "cores:8"
+      dimensions: "cpu:x86-64"
+      dimensions: "os:Ubuntu-18.04"
+      dimensions: "pool:luci.flex.try"
+      exe {
+        cipd_package: "infra/recipe_bundles/chromium.googlesource.com/chromium/tools/build"
+        cipd_version: "refs/heads/main"
+        cmd: "luciexe"
+      }
+      properties:
+        '{'
+        '  "$build/goma": {'
+        '    "enable_ats": true,'
+        '    "server_host": "goma.chromium.org",'
+        '    "use_luci_auth": true'
+        '  },'
+        '  "builder_group": "tryserver.libyuv",'
+        '  "recipe": "libyuv/libyuv"'
+        '}'
+      execution_timeout_secs: 10800
+      build_numbers: YES
+      service_account: "libyuv-try-builder@chops-service-accounts.iam.gserviceaccount.com"
+      experiments {
+        key: "luci.recipes.use_python3"
+        value: 100
+      }
+    }
+    builders {
+      name: "linux_asan"
+      swarming_host: "chromium-swarm.appspot.com"
+      swarming_tags: "vpython:native-python-wrapper"
+      dimensions: "cores:8"
+      dimensions: "cpu:x86-64"
+      dimensions: "os:Ubuntu-18.04"
+      dimensions: "pool:luci.flex.try"
+      exe {
+        cipd_package: "infra/recipe_bundles/chromium.googlesource.com/chromium/tools/build"
+        cipd_version: "refs/heads/main"
+        cmd: "luciexe"
+      }
+      properties:
+        '{'
+        '  "$build/goma": {'
+        '    "enable_ats": true,'
+        '    "server_host": "goma.chromium.org",'
+        '    "use_luci_auth": true'
+        '  },'
+        '  "builder_group": "tryserver.libyuv",'
+        '  "recipe": "libyuv/libyuv"'
+        '}'
+      execution_timeout_secs: 10800
+      build_numbers: YES
+      service_account: "libyuv-try-builder@chops-service-accounts.iam.gserviceaccount.com"
+      experiments {
+        key: "luci.recipes.use_python3"
+        value: 100
+      }
+    }
+    builders {
+      name: "linux_gcc"
+      swarming_host: "chromium-swarm.appspot.com"
+      swarming_tags: "vpython:native-python-wrapper"
+      dimensions: "cores:8"
+      dimensions: "cpu:x86-64"
+      dimensions: "os:Ubuntu-18.04"
+      dimensions: "pool:luci.flex.try"
+      exe {
+        cipd_package: "infra/recipe_bundles/chromium.googlesource.com/chromium/tools/build"
+        cipd_version: "refs/heads/main"
+        cmd: "luciexe"
+      }
+      properties:
+        '{'
+        '  "$build/goma": {'
+        '    "enable_ats": true,'
+        '    "server_host": "goma.chromium.org",'
+        '    "use_luci_auth": true'
+        '  },'
+        '  "builder_group": "tryserver.libyuv",'
+        '  "recipe": "libyuv/libyuv"'
+        '}'
+      execution_timeout_secs: 10800
+      build_numbers: YES
+      service_account: "libyuv-try-builder@chops-service-accounts.iam.gserviceaccount.com"
+      experiments {
+        key: "luci.recipes.use_python3"
+        value: 100
+      }
+    }
+    builders {
+      name: "linux_msan"
+      swarming_host: "chromium-swarm.appspot.com"
+      swarming_tags: "vpython:native-python-wrapper"
+      dimensions: "cores:8"
+      dimensions: "cpu:x86-64"
+      dimensions: "os:Ubuntu-18.04"
+      dimensions: "pool:luci.flex.try"
+      exe {
+        cipd_package: "infra/recipe_bundles/chromium.googlesource.com/chromium/tools/build"
+        cipd_version: "refs/heads/main"
+        cmd: "luciexe"
+      }
+      properties:
+        '{'
+        '  "$build/goma": {'
+        '    "enable_ats": true,'
+        '    "server_host": "goma.chromium.org",'
+        '    "use_luci_auth": true'
+        '  },'
+        '  "builder_group": "tryserver.libyuv",'
+        '  "recipe": "libyuv/libyuv"'
+        '}'
+      execution_timeout_secs: 10800
+      build_numbers: YES
+      service_account: "libyuv-try-builder@chops-service-accounts.iam.gserviceaccount.com"
+      experiments {
+        key: "luci.recipes.use_python3"
+        value: 100
+      }
+    }
+    builders {
+      name: "linux_rel"
+      swarming_host: "chromium-swarm.appspot.com"
+      swarming_tags: "vpython:native-python-wrapper"
+      dimensions: "cores:8"
+      dimensions: "cpu:x86-64"
+      dimensions: "os:Ubuntu-18.04"
+      dimensions: "pool:luci.flex.try"
+      exe {
+        cipd_package: "infra/recipe_bundles/chromium.googlesource.com/chromium/tools/build"
+        cipd_version: "refs/heads/main"
+        cmd: "luciexe"
+      }
+      properties:
+        '{'
+        '  "$build/goma": {'
+        '    "enable_ats": true,'
+        '    "server_host": "goma.chromium.org",'
+        '    "use_luci_auth": true'
+        '  },'
+        '  "builder_group": "tryserver.libyuv",'
+        '  "recipe": "libyuv/libyuv"'
+        '}'
+      execution_timeout_secs: 10800
+      build_numbers: YES
+      service_account: "libyuv-try-builder@chops-service-accounts.iam.gserviceaccount.com"
+      experiments {
+        key: "luci.recipes.use_python3"
+        value: 100
+      }
+    }
+    builders {
+      name: "linux_tsan2"
+      swarming_host: "chromium-swarm.appspot.com"
+      swarming_tags: "vpython:native-python-wrapper"
+      dimensions: "cores:8"
+      dimensions: "cpu:x86-64"
+      dimensions: "os:Ubuntu-18.04"
+      dimensions: "pool:luci.flex.try"
+      exe {
+        cipd_package: "infra/recipe_bundles/chromium.googlesource.com/chromium/tools/build"
+        cipd_version: "refs/heads/main"
+        cmd: "luciexe"
+      }
+      properties:
+        '{'
+        '  "$build/goma": {'
+        '    "enable_ats": true,'
+        '    "server_host": "goma.chromium.org",'
+        '    "use_luci_auth": true'
+        '  },'
+        '  "builder_group": "tryserver.libyuv",'
+        '  "recipe": "libyuv/libyuv"'
+        '}'
+      execution_timeout_secs: 10800
+      build_numbers: YES
+      service_account: "libyuv-try-builder@chops-service-accounts.iam.gserviceaccount.com"
+      experiments {
+        key: "luci.recipes.use_python3"
+        value: 100
+      }
+    }
+    builders {
+      name: "linux_ubsan"
+      swarming_host: "chromium-swarm.appspot.com"
+      swarming_tags: "vpython:native-python-wrapper"
+      dimensions: "cores:8"
+      dimensions: "cpu:x86-64"
+      dimensions: "os:Ubuntu-18.04"
+      dimensions: "pool:luci.flex.try"
+      exe {
+        cipd_package: "infra/recipe_bundles/chromium.googlesource.com/chromium/tools/build"
+        cipd_version: "refs/heads/main"
+        cmd: "luciexe"
+      }
+      properties:
+        '{'
+        '  "$build/goma": {'
+        '    "enable_ats": true,'
+        '    "server_host": "goma.chromium.org",'
+        '    "use_luci_auth": true'
+        '  },'
+        '  "builder_group": "tryserver.libyuv",'
+        '  "recipe": "libyuv/libyuv"'
+        '}'
+      execution_timeout_secs: 10800
+      build_numbers: YES
+      service_account: "libyuv-try-builder@chops-service-accounts.iam.gserviceaccount.com"
+      experiments {
+        key: "luci.recipes.use_python3"
+        value: 100
+      }
+    }
+    builders {
+      name: "linux_ubsan_vptr"
+      swarming_host: "chromium-swarm.appspot.com"
+      swarming_tags: "vpython:native-python-wrapper"
+      dimensions: "cores:8"
+      dimensions: "cpu:x86-64"
+      dimensions: "os:Ubuntu-18.04"
+      dimensions: "pool:luci.flex.try"
+      exe {
+        cipd_package: "infra/recipe_bundles/chromium.googlesource.com/chromium/tools/build"
+        cipd_version: "refs/heads/main"
+        cmd: "luciexe"
+      }
+      properties:
+        '{'
+        '  "$build/goma": {'
+        '    "enable_ats": true,'
+        '    "server_host": "goma.chromium.org",'
+        '    "use_luci_auth": true'
+        '  },'
+        '  "builder_group": "tryserver.libyuv",'
+        '  "recipe": "libyuv/libyuv"'
+        '}'
+      execution_timeout_secs: 10800
+      build_numbers: YES
+      service_account: "libyuv-try-builder@chops-service-accounts.iam.gserviceaccount.com"
+      experiments {
+        key: "luci.recipes.use_python3"
+        value: 100
+      }
+    }
+    builders {
+      name: "mac"
+      swarming_host: "chromium-swarm.appspot.com"
+      swarming_tags: "vpython:native-python-wrapper"
+      dimensions: "cpu:x86-64"
+      dimensions: "os:Mac-10.15"
+      dimensions: "pool:luci.flex.try"
+      exe {
+        cipd_package: "infra/recipe_bundles/chromium.googlesource.com/chromium/tools/build"
+        cipd_version: "refs/heads/main"
+        cmd: "luciexe"
+      }
+      properties:
+        '{'
+        '  "$build/goma": {'
+        '    "server_host": "goma.chromium.org",'
+        '    "use_luci_auth": true'
+        '  },'
+        '  "builder_group": "tryserver.libyuv",'
+        '  "recipe": "libyuv/libyuv"'
+        '}'
+      execution_timeout_secs: 10800
+      build_numbers: YES
+      service_account: "libyuv-try-builder@chops-service-accounts.iam.gserviceaccount.com"
+      experiments {
+        key: "luci.recipes.use_python3"
+        value: 100
+      }
+    }
+    builders {
+      name: "mac_asan"
+      swarming_host: "chromium-swarm.appspot.com"
+      swarming_tags: "vpython:native-python-wrapper"
+      dimensions: "cpu:x86-64"
+      dimensions: "os:Mac-10.15"
+      dimensions: "pool:luci.flex.try"
+      exe {
+        cipd_package: "infra/recipe_bundles/chromium.googlesource.com/chromium/tools/build"
+        cipd_version: "refs/heads/main"
+        cmd: "luciexe"
+      }
+      properties:
+        '{'
+        '  "$build/goma": {'
+        '    "server_host": "goma.chromium.org",'
+        '    "use_luci_auth": true'
+        '  },'
+        '  "builder_group": "tryserver.libyuv",'
+        '  "recipe": "libyuv/libyuv"'
+        '}'
+      execution_timeout_secs: 10800
+      build_numbers: YES
+      service_account: "libyuv-try-builder@chops-service-accounts.iam.gserviceaccount.com"
+      experiments {
+        key: "luci.recipes.use_python3"
+        value: 100
+      }
+    }
+    builders {
+      name: "mac_rel"
+      swarming_host: "chromium-swarm.appspot.com"
+      swarming_tags: "vpython:native-python-wrapper"
+      dimensions: "cpu:x86-64"
+      dimensions: "os:Mac-10.15"
+      dimensions: "pool:luci.flex.try"
+      exe {
+        cipd_package: "infra/recipe_bundles/chromium.googlesource.com/chromium/tools/build"
+        cipd_version: "refs/heads/main"
+        cmd: "luciexe"
+      }
+      properties:
+        '{'
+        '  "$build/goma": {'
+        '    "server_host": "goma.chromium.org",'
+        '    "use_luci_auth": true'
+        '  },'
+        '  "builder_group": "tryserver.libyuv",'
+        '  "recipe": "libyuv/libyuv"'
+        '}'
+      execution_timeout_secs: 10800
+      build_numbers: YES
+      service_account: "libyuv-try-builder@chops-service-accounts.iam.gserviceaccount.com"
+      experiments {
+        key: "luci.recipes.use_python3"
+        value: 100
+      }
+    }
+    builders {
+      name: "presubmit"
+      swarming_host: "chromium-swarm.appspot.com"
+      swarming_tags: "vpython:native-python-wrapper"
+      dimensions: "cores:8"
+      dimensions: "cpu:x86-64"
+      dimensions: "os:Ubuntu-18.04"
+      dimensions: "pool:luci.flex.try"
+      exe {
+        cipd_package: "infra/recipe_bundles/chromium.googlesource.com/chromium/tools/build"
+        cipd_version: "refs/heads/main"
+        cmd: "luciexe"
+      }
+      properties:
+        '{'
+        '  "$build/goma": {'
+        '    "enable_ats": true,'
+        '    "server_host": "goma.chromium.org",'
+        '    "use_luci_auth": true'
+        '  },'
+        '  "builder_group": "tryserver.libyuv",'
+        '  "recipe": "run_presubmit",'
+        '  "repo_name": "libyuv",'
+        '  "runhooks": true'
+        '}'
+      execution_timeout_secs: 10800
+      build_numbers: YES
+      service_account: "libyuv-try-builder@chops-service-accounts.iam.gserviceaccount.com"
+      experiments {
+        key: "luci.recipes.use_python3"
+        value: 100
+      }
+    }
+    builders {
+      name: "win"
+      swarming_host: "chromium-swarm.appspot.com"
+      swarming_tags: "vpython:native-python-wrapper"
+      dimensions: "cores:8"
+      dimensions: "cpu:x86-64"
+      dimensions: "os:Windows-10"
+      dimensions: "pool:luci.flex.try"
+      exe {
+        cipd_package: "infra/recipe_bundles/chromium.googlesource.com/chromium/tools/build"
+        cipd_version: "refs/heads/main"
+        cmd: "luciexe"
+      }
+      properties:
+        '{'
+        '  "$build/goma": {'
+        '    "enable_ats": false,'
+        '    "server_host": "goma.chromium.org",'
+        '    "use_luci_auth": true'
+        '  },'
+        '  "builder_group": "tryserver.libyuv",'
+        '  "recipe": "libyuv/libyuv"'
+        '}'
+      execution_timeout_secs: 10800
+      build_numbers: YES
+      service_account: "libyuv-try-builder@chops-service-accounts.iam.gserviceaccount.com"
+      experiments {
+        key: "luci.recipes.use_python3"
+        value: 100
+      }
+    }
+    builders {
+      name: "win_clang"
+      swarming_host: "chromium-swarm.appspot.com"
+      swarming_tags: "vpython:native-python-wrapper"
+      dimensions: "cores:8"
+      dimensions: "cpu:x86-64"
+      dimensions: "os:Windows-10"
+      dimensions: "pool:luci.flex.try"
+      exe {
+        cipd_package: "infra/recipe_bundles/chromium.googlesource.com/chromium/tools/build"
+        cipd_version: "refs/heads/main"
+        cmd: "luciexe"
+      }
+      properties:
+        '{'
+        '  "$build/goma": {'
+        '    "enable_ats": false,'
+        '    "server_host": "goma.chromium.org",'
+        '    "use_luci_auth": true'
+        '  },'
+        '  "builder_group": "tryserver.libyuv",'
+        '  "recipe": "libyuv/libyuv"'
+        '}'
+      execution_timeout_secs: 10800
+      build_numbers: YES
+      service_account: "libyuv-try-builder@chops-service-accounts.iam.gserviceaccount.com"
+      experiments {
+        key: "luci.recipes.use_python3"
+        value: 100
+      }
+    }
+    builders {
+      name: "win_clang_rel"
+      swarming_host: "chromium-swarm.appspot.com"
+      swarming_tags: "vpython:native-python-wrapper"
+      dimensions: "cores:8"
+      dimensions: "cpu:x86-64"
+      dimensions: "os:Windows-10"
+      dimensions: "pool:luci.flex.try"
+      exe {
+        cipd_package: "infra/recipe_bundles/chromium.googlesource.com/chromium/tools/build"
+        cipd_version: "refs/heads/main"
+        cmd: "luciexe"
+      }
+      properties:
+        '{'
+        '  "$build/goma": {'
+        '    "enable_ats": false,'
+        '    "server_host": "goma.chromium.org",'
+        '    "use_luci_auth": true'
+        '  },'
+        '  "builder_group": "tryserver.libyuv",'
+        '  "recipe": "libyuv/libyuv"'
+        '}'
+      execution_timeout_secs: 10800
+      build_numbers: YES
+      service_account: "libyuv-try-builder@chops-service-accounts.iam.gserviceaccount.com"
+      experiments {
+        key: "luci.recipes.use_python3"
+        value: 100
+      }
+    }
+    builders {
+      name: "win_rel"
+      swarming_host: "chromium-swarm.appspot.com"
+      swarming_tags: "vpython:native-python-wrapper"
+      dimensions: "cores:8"
+      dimensions: "cpu:x86-64"
+      dimensions: "os:Windows-10"
+      dimensions: "pool:luci.flex.try"
+      exe {
+        cipd_package: "infra/recipe_bundles/chromium.googlesource.com/chromium/tools/build"
+        cipd_version: "refs/heads/main"
+        cmd: "luciexe"
+      }
+      properties:
+        '{'
+        '  "$build/goma": {'
+        '    "enable_ats": false,'
+        '    "server_host": "goma.chromium.org",'
+        '    "use_luci_auth": true'
+        '  },'
+        '  "builder_group": "tryserver.libyuv",'
+        '  "recipe": "libyuv/libyuv"'
+        '}'
+      execution_timeout_secs: 10800
+      build_numbers: YES
+      service_account: "libyuv-try-builder@chops-service-accounts.iam.gserviceaccount.com"
+      experiments {
+        key: "luci.recipes.use_python3"
+        value: 100
+      }
+    }
+    builders {
+      name: "win_x64_clang_rel"
+      swarming_host: "chromium-swarm.appspot.com"
+      swarming_tags: "vpython:native-python-wrapper"
+      dimensions: "cores:8"
+      dimensions: "cpu:x86-64"
+      dimensions: "os:Windows-10"
+      dimensions: "pool:luci.flex.try"
+      exe {
+        cipd_package: "infra/recipe_bundles/chromium.googlesource.com/chromium/tools/build"
+        cipd_version: "refs/heads/main"
+        cmd: "luciexe"
+      }
+      properties:
+        '{'
+        '  "$build/goma": {'
+        '    "enable_ats": false,'
+        '    "server_host": "goma.chromium.org",'
+        '    "use_luci_auth": true'
+        '  },'
+        '  "builder_group": "tryserver.libyuv",'
+        '  "recipe": "libyuv/libyuv"'
+        '}'
+      execution_timeout_secs: 10800
+      build_numbers: YES
+      service_account: "libyuv-try-builder@chops-service-accounts.iam.gserviceaccount.com"
+      experiments {
+        key: "luci.recipes.use_python3"
+        value: 100
+      }
+    }
+    builders {
+      name: "win_x64_rel"
+      swarming_host: "chromium-swarm.appspot.com"
+      swarming_tags: "vpython:native-python-wrapper"
+      dimensions: "cores:8"
+      dimensions: "cpu:x86-64"
+      dimensions: "os:Windows-10"
+      dimensions: "pool:luci.flex.try"
+      exe {
+        cipd_package: "infra/recipe_bundles/chromium.googlesource.com/chromium/tools/build"
+        cipd_version: "refs/heads/main"
+        cmd: "luciexe"
+      }
+      properties:
+        '{'
+        '  "$build/goma": {'
+        '    "enable_ats": false,'
+        '    "server_host": "goma.chromium.org",'
+        '    "use_luci_auth": true'
+        '  },'
+        '  "builder_group": "tryserver.libyuv",'
+        '  "recipe": "libyuv/libyuv"'
+        '}'
+      execution_timeout_secs: 10800
+      build_numbers: YES
+      service_account: "libyuv-try-builder@chops-service-accounts.iam.gserviceaccount.com"
+      experiments {
+        key: "luci.recipes.use_python3"
+        value: 100
+      }
+    }
+  }
+}
diff --git a/3rdparty/libyuv/src/infra/config/luci-logdog.cfg b/3rdparty/libyuv/src/infra/config/luci-logdog.cfg
new file mode 100644
index 00000000..adc75bef
--- /dev/null
+++ b/3rdparty/libyuv/src/infra/config/luci-logdog.cfg
@@ -0,0 +1,9 @@
+# Auto-generated by lucicfg.
+# Do not modify manually.
+#
+# For the schema of this file, see ProjectConfig message:
+#   https://luci-config.appspot.com/schemas/projects:luci-logdog.cfg
+
+reader_auth_groups: "all"
+writer_auth_groups: "luci-logdog-chromium-writers"
+archive_gs_bucket: "chromium-luci-logdog"
diff --git a/3rdparty/libyuv/src/infra/config/luci-milo.cfg b/3rdparty/libyuv/src/infra/config/luci-milo.cfg
new file mode 100644
index 00000000..baf786f2
--- /dev/null
+++ b/3rdparty/libyuv/src/infra/config/luci-milo.cfg
@@ -0,0 +1,246 @@
+# Auto-generated by lucicfg.
+# Do not modify manually.
+#
+# For the schema of this file, see Project message:
+#   https://luci-config.appspot.com/schemas/projects:luci-milo.cfg
+
+consoles {
+  id: "main"
+  name: "libyuv Main Console"
+  repo_url: "https://chromium.googlesource.com/libyuv/libyuv"
+  refs: "regexp:refs/heads/main"
+  manifest_name: "REVISION"
+  builders {
+    name: "buildbucket/luci.libyuv.ci/Android ARM64 Debug"
+    category: "Android|Builder"
+    short_name: "dbg"
+  }
+  builders {
+    name: "buildbucket/luci.libyuv.ci/Android Debug"
+    category: "Android|Builder"
+    short_name: "dbg"
+  }
+  builders {
+    name: "buildbucket/luci.libyuv.ci/Android Release"
+    category: "Android|Builder"
+    short_name: "rel"
+  }
+  builders {
+    name: "buildbucket/luci.libyuv.ci/Android32 x86 Debug"
+    category: "Android|Builder|x86"
+    short_name: "dbg"
+  }
+  builders {
+    name: "buildbucket/luci.libyuv.ci/Android64 x64 Debug"
+    category: "Android|Builder|x64"
+    short_name: "dbg"
+  }
+  builders {
+    name: "buildbucket/luci.libyuv.ci/Android Tester ARM32 Debug (Nexus 5X)"
+    category: "Android|Tester|ARM 32"
+    short_name: "dbg"
+  }
+  builders {
+    name: "buildbucket/luci.libyuv.ci/Android Tester ARM32 Release (Nexus 5X)"
+    category: "Android|Tester|ARM 32"
+    short_name: "rel"
+  }
+  builders {
+    name: "buildbucket/luci.libyuv.ci/Android Tester ARM64 Debug (Nexus 5X)"
+    category: "Android|Tester|ARM 64"
+    short_name: "dbg"
+  }
+  builders {
+    name: "buildbucket/luci.libyuv.ci/Linux Asan"
+    category: "Linux"
+    short_name: "asan"
+  }
+  builders {
+    name: "buildbucket/luci.libyuv.ci/Linux MSan"
+    category: "Linux"
+    short_name: "msan"
+  }
+  builders {
+    name: "buildbucket/luci.libyuv.ci/Linux Tsan v2"
+    category: "Linux"
+    short_name: "tsan"
+  }
+  builders {
+    name: "buildbucket/luci.libyuv.ci/Linux UBSan"
+    category: "Linux|UBSan"
+  }
+  builders {
+    name: "buildbucket/luci.libyuv.ci/Linux UBSan vptr"
+    category: "Linux|UBSan"
+    short_name: "vptr"
+  }
+  builders {
+    name: "buildbucket/luci.libyuv.ci/Linux32 Debug"
+    category: "Linux|32"
+    short_name: "dbg"
+  }
+  builders {
+    name: "buildbucket/luci.libyuv.ci/Linux32 Release"
+    category: "Linux|32"
+    short_name: "rel"
+  }
+  builders {
+    name: "buildbucket/luci.libyuv.ci/Linux64 Debug"
+    category: "Linux|64"
+    short_name: "dbg"
+  }
+  builders {
+    name: "buildbucket/luci.libyuv.ci/Linux64 Release"
+    category: "Linux|64"
+    short_name: "rel"
+  }
+  builders {
+    name: "buildbucket/luci.libyuv.ci/Mac Asan"
+    category: "Mac"
+    short_name: "asan"
+  }
+  builders {
+    name: "buildbucket/luci.libyuv.ci/Mac64 Debug"
+    category: "Mac"
+    short_name: "dbg"
+  }
+  builders {
+    name: "buildbucket/luci.libyuv.ci/Mac64 Release"
+    category: "Mac"
+    short_name: "rel"
+  }
+  builders {
+    name: "buildbucket/luci.libyuv.ci/Win32 Debug"
+    category: "Win|32|Debug"
+  }
+  builders {
+    name: "buildbucket/luci.libyuv.ci/Win32 Debug (Clang)"
+    category: "Win|32|Debug"
+    short_name: "clg"
+  }
+  builders {
+    name: "buildbucket/luci.libyuv.ci/Win32 Release"
+    category: "Win|32|Release"
+  }
+  builders {
+    name: "buildbucket/luci.libyuv.ci/Win32 Release (Clang)"
+    category: "Win|32|Release"
+    short_name: "clg"
+  }
+  builders {
+    name: "buildbucket/luci.libyuv.ci/Win64 Debug"
+    category: "Win|64|Debug"
+    short_name: "clg"
+  }
+  builders {
+    name: "buildbucket/luci.libyuv.ci/Win64 Debug (Clang)"
+    category: "Win|64|Debug"
+    short_name: "clg"
+  }
+  builders {
+    name: "buildbucket/luci.libyuv.ci/Win64 Release"
+    category: "Win|64|Release"
+  }
+  builders {
+    name: "buildbucket/luci.libyuv.ci/Win64 Release (Clang)"
+    category: "Win|64|Release"
+    short_name: "clg"
+  }
+  builders {
+    name: "buildbucket/luci.libyuv.ci/iOS ARM64 Debug"
+    category: "iOS|ARM64"
+    short_name: "dbg"
+  }
+  builders {
+    name: "buildbucket/luci.libyuv.ci/iOS ARM64 Release"
+    category: "iOS|ARM64"
+    short_name: "rel"
+  }
+  include_experimental_builds: true
+}
+consoles {
+  id: "cron"
+  name: "Cron"
+  builders {
+    name: "buildbucket/luci.libyuv.cron/DEPS Autoroller"
+  }
+  builder_view_only: true
+}
+consoles {
+  id: "try"
+  name: "libyuv Try Builders"
+  builders {
+    name: "buildbucket/luci.libyuv.try/android"
+  }
+  builders {
+    name: "buildbucket/luci.libyuv.try/android_arm64"
+  }
+  builders {
+    name: "buildbucket/luci.libyuv.try/android_rel"
+  }
+  builders {
+    name: "buildbucket/luci.libyuv.try/android_x64"
+  }
+  builders {
+    name: "buildbucket/luci.libyuv.try/android_x86"
+  }
+  builders {
+    name: "buildbucket/luci.libyuv.try/ios_arm64"
+  }
+  builders {
+    name: "buildbucket/luci.libyuv.try/ios_arm64_rel"
+  }
+  builders {
+    name: "buildbucket/luci.libyuv.try/linux"
+  }
+  builders {
+    name: "buildbucket/luci.libyuv.try/linux_asan"
+  }
+  builders {
+    name: "buildbucket/luci.libyuv.try/linux_gcc"
+  }
+  builders {
+    name: "buildbucket/luci.libyuv.try/linux_msan"
+  }
+  builders {
+    name: "buildbucket/luci.libyuv.try/linux_rel"
+  }
+  builders {
+    name: "buildbucket/luci.libyuv.try/linux_tsan2"
+  }
+  builders {
+    name: "buildbucket/luci.libyuv.try/linux_ubsan"
+  }
+  builders {
+    name: "buildbucket/luci.libyuv.try/linux_ubsan_vptr"
+  }
+  builders {
+    name: "buildbucket/luci.libyuv.try/mac"
+  }
+  builders {
+    name: "buildbucket/luci.libyuv.try/mac_asan"
+  }
+  builders {
+    name: "buildbucket/luci.libyuv.try/mac_rel"
+  }
+  builders {
+    name: "buildbucket/luci.libyuv.try/win"
+  }
+  builders {
+    name: "buildbucket/luci.libyuv.try/win_clang"
+  }
+  builders {
+    name: "buildbucket/luci.libyuv.try/win_clang_rel"
+  }
+  builders {
+    name: "buildbucket/luci.libyuv.try/win_rel"
+  }
+  builders {
+    name: "buildbucket/luci.libyuv.try/win_x64_clang_rel"
+  }
+  builders {
+    name: "buildbucket/luci.libyuv.try/win_x64_rel"
+  }
+  builder_view_only: true
+}
+logo_url: "https://storage.googleapis.com/chrome-infra-public/logo/libyuv-logo.png"
diff --git a/3rdparty/libyuv/src/infra/config/luci-scheduler.cfg b/3rdparty/libyuv/src/infra/config/luci-scheduler.cfg
new file mode 100644
index 00000000..0ec5dd0e
--- /dev/null
+++ b/3rdparty/libyuv/src/infra/config/luci-scheduler.cfg
@@ -0,0 +1,385 @@
+# Auto-generated by lucicfg.
+# Do not modify manually.
+#
+# For the schema of this file, see ProjectConfig message:
+#   https://luci-config.appspot.com/schemas/projects:luci-scheduler.cfg
+
+job {
+  id: "Android ARM64 Debug"
+  realm: "ci"
+  acl_sets: "ci"
+  buildbucket {
+    server: "cr-buildbucket.appspot.com"
+    bucket: "ci"
+    builder: "Android ARM64 Debug"
+  }
+}
+job {
+  id: "Android Debug"
+  realm: "ci"
+  acl_sets: "ci"
+  buildbucket {
+    server: "cr-buildbucket.appspot.com"
+    bucket: "ci"
+    builder: "Android Debug"
+  }
+}
+job {
+  id: "Android Release"
+  realm: "ci"
+  acl_sets: "ci"
+  buildbucket {
+    server: "cr-buildbucket.appspot.com"
+    bucket: "ci"
+    builder: "Android Release"
+  }
+}
+job {
+  id: "Android Tester ARM32 Debug (Nexus 5X)"
+  realm: "ci"
+  acls {
+    role: TRIGGERER
+    granted_to: "libyuv-ci-builder@chops-service-accounts.iam.gserviceaccount.com"
+  }
+  acl_sets: "ci"
+  buildbucket {
+    server: "cr-buildbucket.appspot.com"
+    bucket: "ci"
+    builder: "Android Tester ARM32 Debug (Nexus 5X)"
+  }
+}
+job {
+  id: "Android Tester ARM32 Release (Nexus 5X)"
+  realm: "ci"
+  acls {
+    role: TRIGGERER
+    granted_to: "libyuv-ci-builder@chops-service-accounts.iam.gserviceaccount.com"
+  }
+  acl_sets: "ci"
+  buildbucket {
+    server: "cr-buildbucket.appspot.com"
+    bucket: "ci"
+    builder: "Android Tester ARM32 Release (Nexus 5X)"
+  }
+}
+job {
+  id: "Android Tester ARM64 Debug (Nexus 5X)"
+  realm: "ci"
+  acls {
+    role: TRIGGERER
+    granted_to: "libyuv-ci-builder@chops-service-accounts.iam.gserviceaccount.com"
+  }
+  acl_sets: "ci"
+  buildbucket {
+    server: "cr-buildbucket.appspot.com"
+    bucket: "ci"
+    builder: "Android Tester ARM64 Debug (Nexus 5X)"
+  }
+}
+job {
+  id: "Android32 x86 Debug"
+  realm: "ci"
+  acl_sets: "ci"
+  buildbucket {
+    server: "cr-buildbucket.appspot.com"
+    bucket: "ci"
+    builder: "Android32 x86 Debug"
+  }
+}
+job {
+  id: "Android64 x64 Debug"
+  realm: "ci"
+  acl_sets: "ci"
+  buildbucket {
+    server: "cr-buildbucket.appspot.com"
+    bucket: "ci"
+    builder: "Android64 x64 Debug"
+  }
+}
+job {
+  id: "DEPS Autoroller"
+  realm: "cron"
+  schedule: "0 14 * * *"
+  acl_sets: "cron"
+  buildbucket {
+    server: "cr-buildbucket.appspot.com"
+    bucket: "cron"
+    builder: "DEPS Autoroller"
+  }
+}
+job {
+  id: "Linux Asan"
+  realm: "ci"
+  acl_sets: "ci"
+  buildbucket {
+    server: "cr-buildbucket.appspot.com"
+    bucket: "ci"
+    builder: "Linux Asan"
+  }
+}
+job {
+  id: "Linux MSan"
+  realm: "ci"
+  acl_sets: "ci"
+  buildbucket {
+    server: "cr-buildbucket.appspot.com"
+    bucket: "ci"
+    builder: "Linux MSan"
+  }
+}
+job {
+  id: "Linux Tsan v2"
+  realm: "ci"
+  acl_sets: "ci"
+  buildbucket {
+    server: "cr-buildbucket.appspot.com"
+    bucket: "ci"
+    builder: "Linux Tsan v2"
+  }
+}
+job {
+  id: "Linux UBSan"
+  realm: "ci"
+  acl_sets: "ci"
+  buildbucket {
+    server: "cr-buildbucket.appspot.com"
+    bucket: "ci"
+    builder: "Linux UBSan"
+  }
+}
+job {
+  id: "Linux UBSan vptr"
+  realm: "ci"
+  acl_sets: "ci"
+  buildbucket {
+    server: "cr-buildbucket.appspot.com"
+    bucket: "ci"
+    builder: "Linux UBSan vptr"
+  }
+}
+job {
+  id: "Linux32 Debug"
+  realm: "ci"
+  acl_sets: "ci"
+  buildbucket {
+    server: "cr-buildbucket.appspot.com"
+    bucket: "ci"
+    builder: "Linux32 Debug"
+  }
+}
+job {
+  id: "Linux32 Release"
+  realm: "ci"
+  acl_sets: "ci"
+  buildbucket {
+    server: "cr-buildbucket.appspot.com"
+    bucket: "ci"
+    builder: "Linux32 Release"
+  }
+}
+job {
+  id: "Linux64 Debug"
+  realm: "ci"
+  acl_sets: "ci"
+  buildbucket {
+    server: "cr-buildbucket.appspot.com"
+    bucket: "ci"
+    builder: "Linux64 Debug"
+  }
+}
+job {
+  id: "Linux64 Release"
+  realm: "ci"
+  acl_sets: "ci"
+  buildbucket {
+    server: "cr-buildbucket.appspot.com"
+    bucket: "ci"
+    builder: "Linux64 Release"
+  }
+}
+job {
+  id: "Mac Asan"
+  realm: "ci"
+  acl_sets: "ci"
+  buildbucket {
+    server: "cr-buildbucket.appspot.com"
+    bucket: "ci"
+    builder: "Mac Asan"
+  }
+}
+job {
+  id: "Mac64 Debug"
+  realm: "ci"
+  acl_sets: "ci"
+  buildbucket {
+    server: "cr-buildbucket.appspot.com"
+    bucket: "ci"
+    builder: "Mac64 Debug"
+  }
+}
+job {
+  id: "Mac64 Release"
+  realm: "ci"
+  acl_sets: "ci"
+  buildbucket {
+    server: "cr-buildbucket.appspot.com"
+    bucket: "ci"
+    builder: "Mac64 Release"
+  }
+}
+job {
+  id: "Win32 Debug"
+  realm: "ci"
+  acl_sets: "ci"
+  buildbucket {
+    server: "cr-buildbucket.appspot.com"
+    bucket: "ci"
+    builder: "Win32 Debug"
+  }
+}
+job {
+  id: "Win32 Debug (Clang)"
+  realm: "ci"
+  acl_sets: "ci"
+  buildbucket {
+    server: "cr-buildbucket.appspot.com"
+    bucket: "ci"
+    builder: "Win32 Debug (Clang)"
+  }
+}
+job {
+  id: "Win32 Release"
+  realm: "ci"
+  acl_sets: "ci"
+  buildbucket {
+    server: "cr-buildbucket.appspot.com"
+    bucket: "ci"
+    builder: "Win32 Release"
+  }
+}
+job {
+  id: "Win32 Release (Clang)"
+  realm: "ci"
+  acl_sets: "ci"
+  buildbucket {
+    server: "cr-buildbucket.appspot.com"
+    bucket: "ci"
+    builder: "Win32 Release (Clang)"
+  }
+}
+job {
+  id: "Win64 Debug"
+  realm: "ci"
+  acl_sets: "ci"
+  buildbucket {
+    server: "cr-buildbucket.appspot.com"
+    bucket: "ci"
+    builder: "Win64 Debug"
+  }
+}
+job {
+  id: "Win64 Debug (Clang)"
+  realm: "ci"
+  acl_sets: "ci"
+  buildbucket {
+    server: "cr-buildbucket.appspot.com"
+    bucket: "ci"
+    builder: "Win64 Debug (Clang)"
+  }
+}
+job {
+  id: "Win64 Release"
+  realm: "ci"
+  acl_sets: "ci"
+  buildbucket {
+    server: "cr-buildbucket.appspot.com"
+    bucket: "ci"
+    builder: "Win64 Release"
+  }
+}
+job {
+  id: "Win64 Release (Clang)"
+  realm: "ci"
+  acl_sets: "ci"
+  buildbucket {
+    server: "cr-buildbucket.appspot.com"
+    bucket: "ci"
+    builder: "Win64 Release (Clang)"
+  }
+}
+job {
+  id: "iOS ARM64 Debug"
+  realm: "ci"
+  acl_sets: "ci"
+  buildbucket {
+    server: "cr-buildbucket.appspot.com"
+    bucket: "ci"
+    builder: "iOS ARM64 Debug"
+  }
+}
+job {
+  id: "iOS ARM64 Release"
+  realm: "ci"
+  acl_sets: "ci"
+  buildbucket {
+    server: "cr-buildbucket.appspot.com"
+    bucket: "ci"
+    builder: "iOS ARM64 Release"
+  }
+}
+trigger {
+  id: "master-gitiles-trigger"
+  realm: "ci"
+  acl_sets: "ci"
+  triggers: "Android ARM64 Debug"
+  triggers: "Android Debug"
+  triggers: "Android Release"
+  triggers: "Android32 x86 Debug"
+  triggers: "Android64 x64 Debug"
+  triggers: "Linux Asan"
+  triggers: "Linux MSan"
+  triggers: "Linux Tsan v2"
+  triggers: "Linux UBSan"
+  triggers: "Linux UBSan vptr"
+  triggers: "Linux32 Debug"
+  triggers: "Linux32 Release"
+  triggers: "Linux64 Debug"
+  triggers: "Linux64 Release"
+  triggers: "Mac Asan"
+  triggers: "Mac64 Debug"
+  triggers: "Mac64 Release"
+  triggers: "Win32 Debug"
+  triggers: "Win32 Debug (Clang)"
+  triggers: "Win32 Release"
+  triggers: "Win32 Release (Clang)"
+  triggers: "Win64 Debug"
+  triggers: "Win64 Debug (Clang)"
+  triggers: "Win64 Release"
+  triggers: "Win64 Release (Clang)"
+  triggers: "iOS ARM64 Debug"
+  triggers: "iOS ARM64 Release"
+  gitiles {
+    repo: "https://chromium.googlesource.com/libyuv/libyuv"
+    refs: "regexp:refs/heads/main"
+  }
+}
+acl_sets {
+  name: "ci"
+  acls {
+    role: OWNER
+    granted_to: "group:project-libyuv-admins"
+  }
+  acls {
+    granted_to: "group:all"
+  }
+}
+acl_sets {
+  name: "cron"
+  acls {
+    role: OWNER
+    granted_to: "group:project-libyuv-admins"
+  }
+  acls {
+    granted_to: "group:all"
+  }
+}
diff --git a/3rdparty/libyuv/src/infra/config/main.star b/3rdparty/libyuv/src/infra/config/main.star
new file mode 100644
index 00000000..b922ca02
--- /dev/null
+++ b/3rdparty/libyuv/src/infra/config/main.star
@@ -0,0 +1,361 @@
+#!/usr/bin/env lucicfg
+# https://chromium.googlesource.com/infra/luci/luci-go/+/master/lucicfg/doc/
+
+"""LUCI project configuration for libyuv CQ and CI."""
+
+lucicfg.check_version("1.30.9")
+
+LIBYUV_GIT = "https://chromium.googlesource.com/libyuv/libyuv"
+LIBYUV_GERRIT = "https://chromium-review.googlesource.com/libyuv/libyuv"
+
+GOMA_BACKEND_RBE_PROD = {
+    "server_host": "goma.chromium.org",
+    "use_luci_auth": True,
+}
+
+GOMA_BACKEND_RBE_ATS_PROD = {
+    "server_host": "goma.chromium.org",
+    "use_luci_auth": True,
+    "enable_ats": True,
+}
+
+# Disable ATS on Windows CQ/try.
+GOMA_BACKEND_RBE_NO_ATS_PROD = {
+    "server_host": "goma.chromium.org",
+    "use_luci_auth": True,
+    "enable_ats": False,
+}
+
+# Use LUCI Scheduler BBv2 names and add Scheduler realms configs.
+lucicfg.enable_experiment("crbug.com/1182002")
+
+luci.builder.defaults.experiments.set(
+    {
+        "luci.recipes.use_python3": 100,
+    },
+)
+
+lucicfg.config(
+    lint_checks = ["default"],
+    config_dir = ".",
+    tracked_files = [
+        "commit-queue.cfg",
+        "cr-buildbucket.cfg",
+        "luci-logdog.cfg",
+        "luci-milo.cfg",
+        "luci-scheduler.cfg",
+        "project.cfg",
+        "realms.cfg",
+    ],
+)
+
+# Generates project.cfg
+
+luci.project(
+    name = "libyuv",
+    buildbucket = "cr-buildbucket.appspot.com",
+    logdog = "luci-logdog.appspot.com",
+    milo = "luci-milo.appspot.com",
+    notify = "luci-notify.appspot.com",
+    scheduler = "luci-scheduler.appspot.com",
+    swarming = "chromium-swarm.appspot.com",
+    acls = [
+        acl.entry(acl.PROJECT_CONFIGS_READER, groups = ["all"]),
+        acl.entry(acl.LOGDOG_READER, groups = ["all"]),
+        acl.entry(acl.LOGDOG_WRITER, groups = ["luci-logdog-chromium-writers"]),
+        acl.entry(acl.SCHEDULER_READER, groups = ["all"]),
+        acl.entry(acl.SCHEDULER_OWNER, groups = ["project-libyuv-admins"]),
+        acl.entry(acl.BUILDBUCKET_READER, groups = ["all"]),
+        acl.entry(acl.BUILDBUCKET_OWNER, groups = ["project-libyuv-admins"]),
+    ],
+    bindings = [
+        luci.binding(
+            roles = "role/configs.validator",
+            users = "libyuv-try-builder@chops-service-accounts.iam.gserviceaccount.com",
+        ),
+    ],
+)
+
+# Generates luci-logdog.cfg
+
+luci.logdog(
+    gs_bucket = "chromium-luci-logdog",
+)
+
+# Generates luci-scheduler.cfg
+
+luci.gitiles_poller(
+    name = "master-gitiles-trigger",
+    bucket = "ci",
+    repo = LIBYUV_GIT,
+)
+
+# Generates luci-milo.cfg
+
+luci.milo(
+    logo = "https://storage.googleapis.com/chrome-infra-public/logo/libyuv-logo.png",
+)
+
+def libyuv_ci_view(name, category, short_name):
+    return luci.console_view_entry(
+        console_view = "main",
+        builder = name,
+        category = category,
+        short_name = short_name,
+    )
+
+def libyuv_try_view(name):
+    return luci.list_view_entry(
+        list_view = "try",
+        builder = name,
+    )
+
+luci.console_view(
+    name = "main",
+    title = "libyuv Main Console",
+    include_experimental_builds = True,
+    repo = LIBYUV_GIT,
+)
+
+luci.list_view(
+    name = "cron",
+    title = "Cron",
+    entries = ["DEPS Autoroller"],
+)
+
+luci.list_view(
+    name = "try",
+    title = "libyuv Try Builders",
+)
+
+# Generates commit-queue.cfg
+
+def libyuv_try_job_verifier(name, cq_group, experiment_percentage):
+    return luci.cq_tryjob_verifier(
+        builder = name,
+        cq_group = cq_group,
+        experiment_percentage = experiment_percentage,
+    )
+
+luci.cq(
+    status_host = "chromium-cq-status.appspot.com",
+    submit_max_burst = 4,
+    submit_burst_delay = 8 * time.minute,
+)
+
+luci.cq_group(
+    name = "master",
+    watch = [
+        cq.refset(
+            repo = LIBYUV_GERRIT,
+            refs = ["refs/heads/main", "refs/heads/master"],
+        ),
+    ],
+    acls = [
+        acl.entry(acl.CQ_COMMITTER, groups = ["project-libyuv-committers"]),
+        acl.entry(acl.CQ_DRY_RUNNER, groups = ["project-libyuv-tryjob-access"]),
+    ],
+    retry_config = cq.RETRY_ALL_FAILURES,
+    cancel_stale_tryjobs = True,
+)
+
+luci.cq_group(
+    name = "config",
+    watch = [
+        cq.refset(
+            repo = LIBYUV_GERRIT,
+            refs = ["refs/heads/infra/config"],
+        ),
+    ],
+    acls = [
+        acl.entry(acl.CQ_COMMITTER, groups = ["project-libyuv-committers"]),
+        acl.entry(acl.CQ_DRY_RUNNER, groups = ["project-libyuv-tryjob-access"]),
+    ],
+    retry_config = cq.RETRY_ALL_FAILURES,
+    cancel_stale_tryjobs = True,
+)
+
+# Generates cr-buildbucket.cfg
+
+luci.bucket(
+    name = "ci",
+)
+luci.bucket(
+    name = "try",
+    acls = [
+        acl.entry(acl.BUILDBUCKET_TRIGGERER, groups = [
+            "project-libyuv-tryjob-access",
+            "service-account-cq",
+        ]),
+    ],
+)
+luci.bucket(
+    name = "cron",
+)
+
+def get_os_dimensions(os):
+    if os == "android":
+        return {"device_type": "bullhead"}
+    if os == "ios" or os == "mac":
+        return {"os": "Mac-10.15", "cpu": "x86-64"}
+    elif os == "win":
+        return {"os": "Windows-10", "cores": "8", "cpu": "x86-64"}
+    elif os == "linux":
+        return {"os": "Ubuntu-18.04", "cores": "8", "cpu": "x86-64"}
+    return {}
+
+def get_os_properties(os, try_builder = False):
+    if os == "android":
+        return {"$build/goma": GOMA_BACKEND_RBE_PROD}
+    elif os in ("ios", "mac"):
+        return {"$build/goma": GOMA_BACKEND_RBE_PROD}
+    elif os == "win" and try_builder:
+        return {"$build/goma": GOMA_BACKEND_RBE_NO_ATS_PROD}
+    elif os == "win":
+        return {"$build/goma": GOMA_BACKEND_RBE_ATS_PROD}
+    elif os == "linux":
+        return {"$build/goma": GOMA_BACKEND_RBE_ATS_PROD}
+    return {}
+
+def libyuv_ci_builder(name, dimensions, properties, triggered_by):
+    return luci.builder(
+        name = name,
+        dimensions = dimensions,
+        properties = properties,
+        bucket = "ci",
+        service_account = "libyuv-ci-builder@chops-service-accounts.iam.gserviceaccount.com",
+        triggered_by = triggered_by,
+        swarming_tags = ["vpython:native-python-wrapper"],
+        execution_timeout = 180 * time.minute,
+        build_numbers = True,
+        executable = luci.recipe(
+            name = "libyuv/libyuv",
+            cipd_package = "infra/recipe_bundles/chromium.googlesource.com/chromium/tools/build",
+            use_python3 = True,
+        ),
+    )
+
+def libyuv_try_builder(name, dimensions, properties, recipe_name = "libyuv/libyuv"):
+    return luci.builder(
+        name = name,
+        dimensions = dimensions,
+        properties = properties,
+        bucket = "try",
+        service_account = "libyuv-try-builder@chops-service-accounts.iam.gserviceaccount.com",
+        swarming_tags = ["vpython:native-python-wrapper"],
+        execution_timeout = 180 * time.minute,
+        build_numbers = True,
+        executable = luci.recipe(
+            name = recipe_name,
+            cipd_package = "infra/recipe_bundles/chromium.googlesource.com/chromium/tools/build",
+            use_python3 = True,
+        ),
+    )
+
+def ci_builder(name, os, category, short_name = None):
+    dimensions = get_os_dimensions(os)
+    properties = get_os_properties(os)
+
+    dimensions["pool"] = "luci.flex.ci"
+    properties["builder_group"] = "client.libyuv"
+
+    triggered_by = ["master-gitiles-trigger" if os != "android" else "Android Debug"]
+    libyuv_ci_view(name, category, short_name)
+    return libyuv_ci_builder(name, dimensions, properties, triggered_by)
+
+def try_builder(name, os, experiment_percentage = None):
+    dimensions = get_os_dimensions(os)
+    properties = get_os_properties(os, try_builder = True)
+
+    dimensions["pool"] = "luci.flex.try"
+    properties["builder_group"] = "tryserver.libyuv"
+
+    if name == "presubmit":
+        recipe_name = "run_presubmit"
+        properties["repo_name"] = "libyuv"
+        properties["runhooks"] = True
+        libyuv_try_job_verifier(name, "config", experiment_percentage)
+        return libyuv_try_builder(name, dimensions, properties, recipe_name)
+
+    libyuv_try_job_verifier(name, "master", experiment_percentage)
+    libyuv_try_view(name)
+    return libyuv_try_builder(name, dimensions, properties)
+
+luci.builder(
+    name = "DEPS Autoroller",
+    bucket = "cron",
+    service_account = "libyuv-ci-autoroll-builder@chops-service-accounts.iam.gserviceaccount.com",
+    dimensions = {
+        "pool": "luci.webrtc.cron",
+        "os": "Linux",
+        "cpu": "x86-64",
+    },
+    swarming_tags = ["vpython:native-python-wrapper"],
+    execution_timeout = 120 * time.minute,
+    build_numbers = True,
+    schedule = "0 14 * * *",  # Every 2 hours.
+    executable = luci.recipe(
+        name = "libyuv/roll_deps",
+        cipd_package = "infra/recipe_bundles/chromium.googlesource.com/chromium/tools/build",
+        use_python3 = True,
+    ),
+)
+
+ci_builder("Android ARM64 Debug", "linux", "Android|Builder", "dbg")
+ci_builder("Android Debug", "linux", "Android|Builder", "dbg")
+ci_builder("Android Release", "linux", "Android|Builder", "rel")
+ci_builder("Android32 x86 Debug", "linux", "Android|Builder|x86", "dbg")
+ci_builder("Android64 x64 Debug", "linux", "Android|Builder|x64", "dbg")
+ci_builder("Android Tester ARM32 Debug (Nexus 5X)", "android", "Android|Tester|ARM 32", "dbg")
+ci_builder("Android Tester ARM32 Release (Nexus 5X)", "android", "Android|Tester|ARM 32", "rel")
+ci_builder("Android Tester ARM64 Debug (Nexus 5X)", "android", "Android|Tester|ARM 64", "dbg")
+ci_builder("Linux Asan", "linux", "Linux", "asan")
+ci_builder("Linux MSan", "linux", "Linux", "msan")
+ci_builder("Linux Tsan v2", "linux", "Linux", "tsan")
+ci_builder("Linux UBSan", "linux", "Linux|UBSan")
+ci_builder("Linux UBSan vptr", "linux", "Linux|UBSan", "vptr")
+ci_builder("Linux32 Debug", "linux", "Linux|32", "dbg")
+ci_builder("Linux32 Release", "linux", "Linux|32", "rel")
+ci_builder("Linux64 Debug", "linux", "Linux|64", "dbg")
+ci_builder("Linux64 Release", "linux", "Linux|64", "rel")
+ci_builder("Mac Asan", "mac", "Mac", "asan")
+ci_builder("Mac64 Debug", "mac", "Mac", "dbg")
+ci_builder("Mac64 Release", "mac", "Mac", "rel")
+ci_builder("Win32 Debug", "win", "Win|32|Debug")
+ci_builder("Win32 Debug (Clang)", "win", "Win|32|Debug", "clg")
+ci_builder("Win32 Release", "win", "Win|32|Release")
+ci_builder("Win32 Release (Clang)", "win", "Win|32|Release", "clg")
+ci_builder("Win64 Debug", "win", "Win|64|Debug", "clg")
+ci_builder("Win64 Debug (Clang)", "win", "Win|64|Debug", "clg")
+ci_builder("Win64 Release", "win", "Win|64|Release")
+ci_builder("Win64 Release (Clang)", "win", "Win|64|Release", "clg")
+ci_builder("iOS ARM64 Debug", "ios", "iOS|ARM64", "dbg")
+ci_builder("iOS ARM64 Release", "ios", "iOS|ARM64", "rel")
+
+# TODO(crbug.com/1242847): make this not experimental.
+try_builder("android", "android", experiment_percentage = 100)
+try_builder("android_arm64", "android", experiment_percentage = 100)
+try_builder("android_rel", "android", experiment_percentage = 100)
+
+try_builder("android_x64", "linux")
+try_builder("android_x86", "linux")
+try_builder("ios_arm64", "ios")
+try_builder("ios_arm64_rel", "ios")
+try_builder("linux", "linux")
+try_builder("linux_asan", "linux")
+try_builder("linux_gcc", "linux", experiment_percentage = 100)
+try_builder("linux_msan", "linux")
+try_builder("linux_rel", "linux")
+try_builder("linux_tsan2", "linux")
+try_builder("linux_ubsan", "linux")
+try_builder("linux_ubsan_vptr", "linux")
+try_builder("mac", "mac")
+try_builder("mac_asan", "mac")
+try_builder("mac_rel", "mac")
+try_builder("win", "win")
+try_builder("win_clang", "win")
+try_builder("win_clang_rel", "win")
+try_builder("win_rel", "win")
+try_builder("win_x64_clang_rel", "win")
+try_builder("win_x64_rel", "win")
+try_builder("presubmit", "linux")
diff --git a/3rdparty/libyuv/src/infra/config/project.cfg b/3rdparty/libyuv/src/infra/config/project.cfg
new file mode 100644
index 00000000..700226ad
--- /dev/null
+++ b/3rdparty/libyuv/src/infra/config/project.cfg
@@ -0,0 +1,15 @@
+# Auto-generated by lucicfg.
+# Do not modify manually.
+#
+# For the schema of this file, see ProjectCfg message:
+#   https://luci-config.appspot.com/schemas/projects:project.cfg
+
+name: "libyuv"
+access: "group:all"
+lucicfg {
+  version: "1.30.9"
+  package_dir: "."
+  config_dir: "."
+  entry_point: "main.star"
+  experiments: "crbug.com/1182002"
+}
diff --git a/3rdparty/libyuv/src/infra/config/realms.cfg b/3rdparty/libyuv/src/infra/config/realms.cfg
new file mode 100644
index 00000000..ae04529e
--- /dev/null
+++ b/3rdparty/libyuv/src/infra/config/realms.cfg
@@ -0,0 +1,79 @@
+# Auto-generated by lucicfg.
+# Do not modify manually.
+#
+# For the schema of this file, see RealmsCfg message:
+#   https://luci-config.appspot.com/schemas/projects:realms.cfg
+
+realms {
+  name: "@root"
+  bindings {
+    role: "role/buildbucket.owner"
+    principals: "group:project-libyuv-admins"
+  }
+  bindings {
+    role: "role/buildbucket.reader"
+    principals: "group:all"
+  }
+  bindings {
+    role: "role/configs.reader"
+    principals: "group:all"
+  }
+  bindings {
+    role: "role/configs.validator"
+    principals: "user:libyuv-try-builder@chops-service-accounts.iam.gserviceaccount.com"
+  }
+  bindings {
+    role: "role/logdog.reader"
+    principals: "group:all"
+  }
+  bindings {
+    role: "role/logdog.writer"
+    principals: "group:luci-logdog-chromium-writers"
+  }
+  bindings {
+    role: "role/scheduler.owner"
+    principals: "group:project-libyuv-admins"
+  }
+  bindings {
+    role: "role/scheduler.reader"
+    principals: "group:all"
+  }
+}
+realms {
+  name: "ci"
+  bindings {
+    role: "role/buildbucket.builderServiceAccount"
+    principals: "user:libyuv-ci-builder@chops-service-accounts.iam.gserviceaccount.com"
+  }
+  bindings {
+    role: "role/scheduler.triggerer"
+    principals: "user:libyuv-ci-builder@chops-service-accounts.iam.gserviceaccount.com"
+    conditions {
+      restrict {
+        attribute: "scheduler.job.name"
+        values: "Android Tester ARM32 Debug (Nexus 5X)"
+        values: "Android Tester ARM32 Release (Nexus 5X)"
+        values: "Android Tester ARM64 Debug (Nexus 5X)"
+      }
+    }
+  }
+}
+realms {
+  name: "cron"
+  bindings {
+    role: "role/buildbucket.builderServiceAccount"
+    principals: "user:libyuv-ci-autoroll-builder@chops-service-accounts.iam.gserviceaccount.com"
+  }
+}
+realms {
+  name: "try"
+  bindings {
+    role: "role/buildbucket.builderServiceAccount"
+    principals: "user:libyuv-try-builder@chops-service-accounts.iam.gserviceaccount.com"
+  }
+  bindings {
+    role: "role/buildbucket.triggerer"
+    principals: "group:project-libyuv-tryjob-access"
+    principals: "group:service-account-cq"
+  }
+}
diff --git a/3rdparty/libyuv/src/libyuv.gni b/3rdparty/libyuv/src/libyuv.gni
new file mode 100644
index 00000000..8df40ba2
--- /dev/null
+++ b/3rdparty/libyuv/src/libyuv.gni
@@ -0,0 +1,23 @@
+# Copyright 2016 The LibYuv Project Authors. All rights reserved.
+#
+# Use of this source code is governed by a BSD-style license
+# that can be found in the LICENSE file in the root of the source
+# tree. An additional intellectual property rights grant can be found
+# in the file PATENTS. All contributing project authors may
+# be found in the AUTHORS file in the root of the source tree.
+
+import("//build_overrides/build.gni")
+import("//build/config/arm.gni")
+import("//build/config/mips.gni")
+
+declare_args() {
+  libyuv_include_tests = !build_with_chromium
+  libyuv_disable_jpeg = false
+  libyuv_use_neon =
+      current_cpu == "arm64" ||
+      (current_cpu == "arm" && (arm_use_neon || arm_optionally_use_neon))
+  libyuv_use_msa =
+      (current_cpu == "mips64el" || current_cpu == "mipsel") && mips_use_msa
+  libyuv_use_mmi =
+      (current_cpu == "mips64el" || current_cpu == "mipsel") && mips_use_mmi
+}
diff --git a/3rdparty/libyuv/src/libyuv.gyp b/3rdparty/libyuv/src/libyuv.gyp
new file mode 100644
index 00000000..f73a1a4b
--- /dev/null
+++ b/3rdparty/libyuv/src/libyuv.gyp
@@ -0,0 +1,162 @@
+# Copyright 2011 The LibYuv Project Authors. All rights reserved.
+#
+# Use of this source code is governed by a BSD-style license
+# that can be found in the LICENSE file in the root of the source
+# tree. An additional intellectual property rights grant can be found
+# in the file PATENTS. All contributing project authors may
+# be found in the AUTHORS file in the root of the source tree.
+
+{
+  'includes': [
+    'libyuv.gypi',
+  ],
+  # Make sure that if we are being compiled to an xcodeproj, nothing tries to
+  # include a .pch.
+  'xcode_settings': {
+    'GCC_PREFIX_HEADER': '',
+    'GCC_PRECOMPILE_PREFIX_HEADER': 'NO',
+  },
+  'variables': {
+    'use_system_libjpeg%': 0,
+    # Can be enabled if your jpeg has GYP support.
+    'libyuv_disable_jpeg%': 1,
+    # 'chromium_code' treats libyuv as internal and increases warning level.
+    'chromium_code': 1,
+    # clang compiler default variable usable by other apps that include libyuv.
+    'clang%': 0,
+    # Link-Time Optimizations.
+    'use_lto%': 0,
+    'mips_msa%': 0,  # Default to msa off.
+    'build_neon': 0,
+    'build_msa': 0,
+    'conditions': [
+       ['(target_arch == "armv7" or target_arch == "armv7s" or \
+       (target_arch == "arm" and arm_version >= 7) or target_arch == "arm64")\
+       and (arm_neon == 1 or arm_neon_optional == 1)', {
+         'build_neon': 1,
+       }],
+       ['(target_arch == "mipsel" or target_arch == "mips64el")\
+       and (mips_msa == 1)',
+       {
+         'build_msa': 1,
+       }],
+    ],
+  },
+
+  'targets': [
+    {
+      'target_name': 'libyuv',
+      # Change type to 'shared_library' to build .so or .dll files.
+      'type': 'static_library',
+      'variables': {
+        'optimize': 'max',  # enable O2 and ltcg.
+      },
+      # Allows libyuv.a redistributable library without external dependencies.
+      'standalone_static_library': 1,
+      'conditions': [
+       # Disable -Wunused-parameter
+        ['clang == 1', {
+          'cflags': [
+            '-Wno-unused-parameter',
+         ],
+        }],
+        ['build_neon != 0', {
+          'defines': [
+            'LIBYUV_NEON',
+          ],
+          'cflags!': [
+            '-mfpu=vfp',
+            '-mfpu=vfpv3',
+            '-mfpu=vfpv3-d16',
+            # '-mthumb',  # arm32 not thumb
+          ],
+          'conditions': [
+            # Disable LTO in libyuv_neon target due to gcc 4.9 compiler bug.
+            ['clang == 0 and use_lto == 1', {
+              'cflags!': [
+                '-flto',
+                '-ffat-lto-objects',
+              ],
+            }],
+            # arm64 does not need -mfpu=neon option as neon is not optional
+            ['target_arch != "arm64"', {
+              'cflags': [
+                '-mfpu=neon',
+                # '-marm',  # arm32 not thumb
+              ],
+            }],
+          ],
+        }],
+        ['build_msa != 0', {
+          'defines': [
+            'LIBYUV_MSA',
+          ],
+        }],
+        ['OS != "ios" and libyuv_disable_jpeg != 1', {
+          'defines': [
+            'HAVE_JPEG'
+          ],
+          'conditions': [
+            # Caveat system jpeg support may not support motion jpeg
+            [ 'use_system_libjpeg == 1', {
+              'dependencies': [
+                 '<(DEPTH)/third_party/libjpeg/libjpeg.gyp:libjpeg',
+              ],
+            }, {
+              'dependencies': [
+                 '<(DEPTH)/third_party/libjpeg_turbo/libjpeg.gyp:libjpeg',
+              ],
+            }],
+            [ 'use_system_libjpeg == 1', {
+              'link_settings': {
+                'libraries': [
+                  '-ljpeg',
+                ],
+              }
+            }],
+          ],
+        }],
+      ], #conditions
+      'defines': [
+        # Enable the following 3 macros to turn off assembly for specified CPU.
+        # 'LIBYUV_DISABLE_X86',
+        # 'LIBYUV_DISABLE_NEON',
+        # 'LIBYUV_DISABLE_DSPR2',
+        # Enable the following macro to build libyuv as a shared library (dll).
+        # 'LIBYUV_USING_SHARED_LIBRARY',
+        # TODO(fbarchard): Make these into gyp defines.
+      ],
+      'include_dirs': [
+        'include',
+        '.',
+      ],
+      'direct_dependent_settings': {
+        'include_dirs': [
+          'include',
+          '.',
+        ],
+        'conditions': [
+          ['OS == "android" and target_arch == "arm64"', {
+            'ldflags': [
+              '-Wl,--dynamic-linker,/system/bin/linker64',
+            ],
+          }],
+          ['OS == "android" and target_arch != "arm64"', {
+            'ldflags': [
+              '-Wl,--dynamic-linker,/system/bin/linker',
+            ],
+          }],
+        ], #conditions
+      },
+      'sources': [
+        '<@(libyuv_sources)',
+      ],
+    },
+  ], # targets.
+}
+
+# Local Variables:
+# tab-width:2
+# indent-tabs-mode:nil
+# End:
+# vim: set expandtab tabstop=2 shiftwidth=2:
diff --git a/3rdparty/libyuv/src/libyuv.gypi b/3rdparty/libyuv/src/libyuv.gypi
new file mode 100644
index 00000000..48936aa7
--- /dev/null
+++ b/3rdparty/libyuv/src/libyuv.gypi
@@ -0,0 +1,85 @@
+# Copyright 2014 The LibYuv Project Authors. All rights reserved.
+#
+# Use of this source code is governed by a BSD-style license
+# that can be found in the LICENSE file in the root of the source
+# tree. An additional intellectual property rights grant can be found
+# in the file PATENTS. All contributing project authors may
+# be found in the AUTHORS file in the root of the source tree.
+
+{
+  'variables': {
+    'libyuv_sources': [
+      # includes.
+      'include/libyuv.h',
+      'include/libyuv/basic_types.h',
+      'include/libyuv/compare.h',
+      'include/libyuv/convert.h',
+      'include/libyuv/convert_argb.h',
+      'include/libyuv/convert_from.h',
+      'include/libyuv/convert_from_argb.h',
+      'include/libyuv/cpu_id.h',
+      'include/libyuv/macros_msa.h',
+      'include/libyuv/mjpeg_decoder.h',
+      'include/libyuv/planar_functions.h',
+      'include/libyuv/rotate.h',
+      'include/libyuv/rotate_argb.h',
+      'include/libyuv/rotate_row.h',
+      'include/libyuv/row.h',
+      'include/libyuv/scale.h',
+      'include/libyuv/scale_argb.h',
+      'include/libyuv/scale_rgb.h',
+      'include/libyuv/scale_row.h',
+      'include/libyuv/scale_uv.h',
+      'include/libyuv/version.h',
+      'include/libyuv/video_common.h',
+
+      # sources.
+      'source/compare.cc',
+      'source/compare_common.cc',
+      'source/compare_gcc.cc',
+      'source/compare_msa.cc',
+      'source/compare_neon.cc',
+      'source/compare_neon64.cc',
+      'source/compare_win.cc',
+      'source/convert.cc',
+      'source/convert_argb.cc',
+      'source/convert_from.cc',
+      'source/convert_from_argb.cc',
+      'source/convert_jpeg.cc',
+      'source/convert_to_argb.cc',
+      'source/convert_to_i420.cc',
+      'source/cpu_id.cc',
+      'source/mjpeg_decoder.cc',
+      'source/mjpeg_validate.cc',
+      'source/planar_functions.cc',
+      'source/rotate.cc',
+      'source/rotate_any.cc',
+      'source/rotate_argb.cc',
+      'source/rotate_common.cc',
+      'source/rotate_gcc.cc',
+      'source/rotate_msa.cc',
+      'source/rotate_neon.cc',
+      'source/rotate_neon64.cc',
+      'source/rotate_win.cc',
+      'source/row_any.cc',
+      'source/row_common.cc',
+      'source/row_gcc.cc',
+      'source/row_msa.cc',
+      'source/row_neon.cc',
+      'source/row_neon64.cc',
+      'source/row_win.cc',
+      'source/scale.cc',
+      'source/scale_any.cc',
+      'source/scale_argb.cc',
+      'source/scale_common.cc',
+      'source/scale_gcc.cc',
+      'source/scale_msa.cc',
+      'source/scale_neon.cc',
+      'source/scale_neon64.cc',
+      'source/scale_rgb.cc',
+      'source/scale_uv.cc',
+      'source/scale_win.cc',
+      'source/video_common.cc',
+    ],
+  }
+}
diff --git a/3rdparty/libyuv/src/linux.mk b/3rdparty/libyuv/src/linux.mk
new file mode 100644
index 00000000..b541b47c
--- /dev/null
+++ b/3rdparty/libyuv/src/linux.mk
@@ -0,0 +1,94 @@
+# This is a generic makefile for libyuv for gcc.
+# make -f linux.mk CXX=clang++
+
+CC?=gcc
+CFLAGS?=-O2 -fomit-frame-pointer
+CFLAGS+=-Iinclude/
+
+CXX?=g++
+CXXFLAGS?=-O2 -fomit-frame-pointer
+CXXFLAGS+=-Iinclude/
+
+LOCAL_OBJ_FILES := \
+	source/compare.o           \
+	source/compare_common.o    \
+	source/compare_gcc.o       \
+	source/compare_msa.o       \
+	source/compare_neon.o      \
+	source/compare_neon64.o    \
+	source/compare_win.o       \
+	source/convert.o           \
+	source/convert_argb.o      \
+	source/convert_from.o      \
+	source/convert_from_argb.o \
+	source/convert_jpeg.o      \
+	source/convert_to_argb.o   \
+	source/convert_to_i420.o   \
+	source/cpu_id.o            \
+	source/mjpeg_decoder.o     \
+	source/mjpeg_validate.o    \
+	source/planar_functions.o  \
+	source/rotate.o            \
+	source/rotate_any.o        \
+	source/rotate_argb.o       \
+	source/rotate_common.o     \
+	source/rotate_gcc.o        \
+	source/rotate_msa.o        \
+	source/rotate_neon.o       \
+	source/rotate_neon64.o     \
+	source/rotate_win.o        \
+	source/row_any.o           \
+	source/row_common.o        \
+	source/row_gcc.o           \
+	source/row_msa.o           \
+	source/row_neon.o          \
+	source/row_neon64.o        \
+	source/row_win.o           \
+	source/scale.o             \
+	source/scale_any.o         \
+	source/scale_argb.o        \
+	source/scale_common.o      \
+	source/scale_gcc.o         \
+	source/scale_msa.o         \
+	source/scale_neon.o        \
+	source/scale_neon64.o      \
+	source/scale_rgb.o         \
+	source/scale_uv.o          \
+	source/scale_win.o         \
+	source/video_common.o
+
+.cc.o:
+	$(CXX) -c $(CXXFLAGS) $*.cc -o $*.o
+
+.c.o:
+	$(CC) -c $(CFLAGS) $*.c -o $*.o
+
+all: libyuv.a i444tonv12_eg yuvconvert yuvconstants cpuid psnr
+
+libyuv.a: $(LOCAL_OBJ_FILES)
+	$(AR) $(ARFLAGS) $@ $(LOCAL_OBJ_FILES)
+
+# A C++ test utility that uses libyuv conversion.
+yuvconvert: util/yuvconvert.cc libyuv.a
+	$(CXX) $(CXXFLAGS) -Iutil/ -o $@ util/yuvconvert.cc libyuv.a
+
+# A C test utility that generates yuvconstants for yuv to rgb.
+yuvconstants: util/yuvconstants.c libyuv.a
+	$(CXX) $(CXXFLAGS) -Iutil/ -lm -o $@ util/yuvconstants.c libyuv.a
+
+# A standalone test utility
+psnr: util/psnr.cc
+	$(CXX) $(CXXFLAGS) -Iutil/ -o $@ util/psnr.cc util/psnr_main.cc util/ssim.cc
+
+# A simple conversion example.
+i444tonv12_eg: util/i444tonv12_eg.cc libyuv.a
+	$(CXX) $(CXXFLAGS) -o $@ util/i444tonv12_eg.cc libyuv.a
+
+# A C test utility that uses libyuv conversion from C.
+# gcc 4.4 and older require -fno-exceptions to avoid link error on __gxx_personality_v0
+# CC=gcc-4.4 CXXFLAGS=-fno-exceptions CXX=g++-4.4 make -f linux.mk
+cpuid: util/cpuid.c libyuv.a
+	$(CC) $(CFLAGS) -o $@ util/cpuid.c libyuv.a
+
+clean:
+	/bin/rm -f source/*.o *.ii *.s libyuv.a i444tonv12_eg yuvconvert yuvconstants cpuid psnr
diff --git a/3rdparty/libyuv/src/public.mk b/3rdparty/libyuv/src/public.mk
new file mode 100644
index 00000000..1342307a
--- /dev/null
+++ b/3rdparty/libyuv/src/public.mk
@@ -0,0 +1,13 @@
+# This file contains all the common make variables which are useful for
+# anyone depending on this library.
+# Note that dependencies on NDK are not directly listed since NDK auto adds
+# them.
+
+LIBYUV_INCLUDES := $(LIBYUV_PATH)/include
+
+LIBYUV_C_FLAGS :=
+
+LIBYUV_CPP_FLAGS :=
+
+LIBYUV_LDLIBS :=
+LIBYUV_DEP_MODULES :=
diff --git a/3rdparty/libyuv/src/pylintrc b/3rdparty/libyuv/src/pylintrc
new file mode 100644
index 00000000..b8bea334
--- /dev/null
+++ b/3rdparty/libyuv/src/pylintrc
@@ -0,0 +1,17 @@
+[MESSAGES CONTROL]
+
+# Disable the message, report, category or checker with the given id(s).
+# TODO(kjellander): Reduce this list to as small as possible.
+disable=I0010,I0011,bad-continuation,broad-except,duplicate-code,eval-used,exec-used,fixme,invalid-name,missing-docstring,no-init,no-member,too-few-public-methods,too-many-ancestors,too-many-arguments,too-many-branches,too-many-function-args,too-many-instance-attributes,too-many-lines,too-many-locals,too-many-public-methods,too-many-return-statements,too-many-statements
+
+
+[REPORTS]
+
+# Don't write out full reports, just messages.
+reports=no
+
+
+[FORMAT]
+
+# We use two spaces for indents, instead of the usual four spaces or tab.
+indent-string='  '
diff --git a/3rdparty/libyuv/src/source/compare.cc b/3rdparty/libyuv/src/source/compare.cc
new file mode 100644
index 00000000..d4713b60
--- /dev/null
+++ b/3rdparty/libyuv/src/source/compare.cc
@@ -0,0 +1,430 @@
+/*
+ *  Copyright 2011 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include "libyuv/compare.h"
+
+#include <float.h>
+#include <math.h>
+#ifdef _OPENMP
+#include <omp.h>
+#endif
+
+#include "libyuv/basic_types.h"
+#include "libyuv/compare_row.h"
+#include "libyuv/cpu_id.h"
+#include "libyuv/row.h"
+#include "libyuv/video_common.h"
+
+#ifdef __cplusplus
+namespace libyuv {
+extern "C" {
+#endif
+
+// hash seed of 5381 recommended.
+LIBYUV_API
+uint32_t HashDjb2(const uint8_t* src, uint64_t count, uint32_t seed) {
+  const int kBlockSize = 1 << 15;  // 32768;
+  int remainder;
+  uint32_t (*HashDjb2_SSE)(const uint8_t* src, int count, uint32_t seed) =
+      HashDjb2_C;
+#if defined(HAS_HASHDJB2_SSE41)
+  if (TestCpuFlag(kCpuHasSSE41)) {
+    HashDjb2_SSE = HashDjb2_SSE41;
+  }
+#endif
+#if defined(HAS_HASHDJB2_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    HashDjb2_SSE = HashDjb2_AVX2;
+  }
+#endif
+
+  while (count >= (uint64_t)(kBlockSize)) {
+    seed = HashDjb2_SSE(src, kBlockSize, seed);
+    src += kBlockSize;
+    count -= kBlockSize;
+  }
+  remainder = (int)count & ~15;
+  if (remainder) {
+    seed = HashDjb2_SSE(src, remainder, seed);
+    src += remainder;
+    count -= remainder;
+  }
+  remainder = (int)count & 15;
+  if (remainder) {
+    seed = HashDjb2_C(src, remainder, seed);
+  }
+  return seed;
+}
+
+static uint32_t ARGBDetectRow_C(const uint8_t* argb, int width) {
+  int x;
+  for (x = 0; x < width - 1; x += 2) {
+    if (argb[0] != 255) {  // First byte is not Alpha of 255, so not ARGB.
+      return FOURCC_BGRA;
+    }
+    if (argb[3] != 255) {  // Fourth byte is not Alpha of 255, so not BGRA.
+      return FOURCC_ARGB;
+    }
+    if (argb[4] != 255) {  // Second pixel first byte is not Alpha of 255.
+      return FOURCC_BGRA;
+    }
+    if (argb[7] != 255) {  // Second pixel fourth byte is not Alpha of 255.
+      return FOURCC_ARGB;
+    }
+    argb += 8;
+  }
+  if (width & 1) {
+    if (argb[0] != 255) {  // First byte is not Alpha of 255, so not ARGB.
+      return FOURCC_BGRA;
+    }
+    if (argb[3] != 255) {  // 4th byte is not Alpha of 255, so not BGRA.
+      return FOURCC_ARGB;
+    }
+  }
+  return 0;
+}
+
+// Scan an opaque argb image and return fourcc based on alpha offset.
+// Returns FOURCC_ARGB, FOURCC_BGRA, or 0 if unknown.
+LIBYUV_API
+uint32_t ARGBDetect(const uint8_t* argb,
+                    int stride_argb,
+                    int width,
+                    int height) {
+  uint32_t fourcc = 0;
+  int h;
+
+  // Coalesce rows.
+  if (stride_argb == width * 4) {
+    width *= height;
+    height = 1;
+    stride_argb = 0;
+  }
+  for (h = 0; h < height && fourcc == 0; ++h) {
+    fourcc = ARGBDetectRow_C(argb, width);
+    argb += stride_argb;
+  }
+  return fourcc;
+}
+
+// NEON version accumulates in 16 bit shorts which overflow at 65536 bytes.
+// So actual maximum is 1 less loop, which is 64436 - 32 bytes.
+
+LIBYUV_API
+uint64_t ComputeHammingDistance(const uint8_t* src_a,
+                                const uint8_t* src_b,
+                                int count) {
+  const int kBlockSize = 1 << 15;  // 32768;
+  const int kSimdSize = 64;
+  // SIMD for multiple of 64, and C for remainder
+  int remainder = count & (kBlockSize - 1) & ~(kSimdSize - 1);
+  uint64_t diff = 0;
+  int i;
+  uint32_t (*HammingDistance)(const uint8_t* src_a, const uint8_t* src_b,
+                              int count) = HammingDistance_C;
+#if defined(HAS_HAMMINGDISTANCE_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    HammingDistance = HammingDistance_NEON;
+  }
+#endif
+#if defined(HAS_HAMMINGDISTANCE_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    HammingDistance = HammingDistance_SSSE3;
+  }
+#endif
+#if defined(HAS_HAMMINGDISTANCE_SSE42)
+  if (TestCpuFlag(kCpuHasSSE42)) {
+    HammingDistance = HammingDistance_SSE42;
+  }
+#endif
+#if defined(HAS_HAMMINGDISTANCE_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    HammingDistance = HammingDistance_AVX2;
+  }
+#endif
+#if defined(HAS_HAMMINGDISTANCE_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    HammingDistance = HammingDistance_MSA;
+  }
+#endif
+
+#ifdef _OPENMP
+#pragma omp parallel for reduction(+ : diff)
+#endif
+  for (i = 0; i < (count - (kBlockSize - 1)); i += kBlockSize) {
+    diff += HammingDistance(src_a + i, src_b + i, kBlockSize);
+  }
+  src_a += count & ~(kBlockSize - 1);
+  src_b += count & ~(kBlockSize - 1);
+  if (remainder) {
+    diff += HammingDistance(src_a, src_b, remainder);
+    src_a += remainder;
+    src_b += remainder;
+  }
+  remainder = count & (kSimdSize - 1);
+  if (remainder) {
+    diff += HammingDistance_C(src_a, src_b, remainder);
+  }
+  return diff;
+}
+
+// TODO(fbarchard): Refactor into row function.
+LIBYUV_API
+uint64_t ComputeSumSquareError(const uint8_t* src_a,
+                               const uint8_t* src_b,
+                               int count) {
+  // SumSquareError returns values 0 to 65535 for each squared difference.
+  // Up to 65536 of those can be summed and remain within a uint32_t.
+  // After each block of 65536 pixels, accumulate into a uint64_t.
+  const int kBlockSize = 65536;
+  int remainder = count & (kBlockSize - 1) & ~31;
+  uint64_t sse = 0;
+  int i;
+  uint32_t (*SumSquareError)(const uint8_t* src_a, const uint8_t* src_b,
+                             int count) = SumSquareError_C;
+#if defined(HAS_SUMSQUAREERROR_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    SumSquareError = SumSquareError_NEON;
+  }
+#endif
+#if defined(HAS_SUMSQUAREERROR_SSE2)
+  if (TestCpuFlag(kCpuHasSSE2)) {
+    // Note only used for multiples of 16 so count is not checked.
+    SumSquareError = SumSquareError_SSE2;
+  }
+#endif
+#if defined(HAS_SUMSQUAREERROR_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    // Note only used for multiples of 32 so count is not checked.
+    SumSquareError = SumSquareError_AVX2;
+  }
+#endif
+#if defined(HAS_SUMSQUAREERROR_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    SumSquareError = SumSquareError_MSA;
+  }
+#endif
+#ifdef _OPENMP
+#pragma omp parallel for reduction(+ : sse)
+#endif
+  for (i = 0; i < (count - (kBlockSize - 1)); i += kBlockSize) {
+    sse += SumSquareError(src_a + i, src_b + i, kBlockSize);
+  }
+  src_a += count & ~(kBlockSize - 1);
+  src_b += count & ~(kBlockSize - 1);
+  if (remainder) {
+    sse += SumSquareError(src_a, src_b, remainder);
+    src_a += remainder;
+    src_b += remainder;
+  }
+  remainder = count & 31;
+  if (remainder) {
+    sse += SumSquareError_C(src_a, src_b, remainder);
+  }
+  return sse;
+}
+
+LIBYUV_API
+uint64_t ComputeSumSquareErrorPlane(const uint8_t* src_a,
+                                    int stride_a,
+                                    const uint8_t* src_b,
+                                    int stride_b,
+                                    int width,
+                                    int height) {
+  uint64_t sse = 0;
+  int h;
+  // Coalesce rows.
+  if (stride_a == width && stride_b == width) {
+    width *= height;
+    height = 1;
+    stride_a = stride_b = 0;
+  }
+  for (h = 0; h < height; ++h) {
+    sse += ComputeSumSquareError(src_a, src_b, width);
+    src_a += stride_a;
+    src_b += stride_b;
+  }
+  return sse;
+}
+
+LIBYUV_API
+double SumSquareErrorToPsnr(uint64_t sse, uint64_t count) {
+  double psnr;
+  if (sse > 0) {
+    double mse = (double)count / (double)sse;
+    psnr = 10.0 * log10(255.0 * 255.0 * mse);
+  } else {
+    psnr = kMaxPsnr;  // Limit to prevent divide by 0
+  }
+
+  if (psnr > kMaxPsnr) {
+    psnr = kMaxPsnr;
+  }
+
+  return psnr;
+}
+
+LIBYUV_API
+double CalcFramePsnr(const uint8_t* src_a,
+                     int stride_a,
+                     const uint8_t* src_b,
+                     int stride_b,
+                     int width,
+                     int height) {
+  const uint64_t samples = (uint64_t)width * (uint64_t)height;
+  const uint64_t sse = ComputeSumSquareErrorPlane(src_a, stride_a, src_b,
+                                                  stride_b, width, height);
+  return SumSquareErrorToPsnr(sse, samples);
+}
+
+LIBYUV_API
+double I420Psnr(const uint8_t* src_y_a,
+                int stride_y_a,
+                const uint8_t* src_u_a,
+                int stride_u_a,
+                const uint8_t* src_v_a,
+                int stride_v_a,
+                const uint8_t* src_y_b,
+                int stride_y_b,
+                const uint8_t* src_u_b,
+                int stride_u_b,
+                const uint8_t* src_v_b,
+                int stride_v_b,
+                int width,
+                int height) {
+  const uint64_t sse_y = ComputeSumSquareErrorPlane(
+      src_y_a, stride_y_a, src_y_b, stride_y_b, width, height);
+  const int width_uv = (width + 1) >> 1;
+  const int height_uv = (height + 1) >> 1;
+  const uint64_t sse_u = ComputeSumSquareErrorPlane(
+      src_u_a, stride_u_a, src_u_b, stride_u_b, width_uv, height_uv);
+  const uint64_t sse_v = ComputeSumSquareErrorPlane(
+      src_v_a, stride_v_a, src_v_b, stride_v_b, width_uv, height_uv);
+  const uint64_t samples = (uint64_t)width * (uint64_t)height +
+                           2 * ((uint64_t)width_uv * (uint64_t)height_uv);
+  const uint64_t sse = sse_y + sse_u + sse_v;
+  return SumSquareErrorToPsnr(sse, samples);
+}
+
+static const int64_t cc1 = 26634;   // (64^2*(.01*255)^2
+static const int64_t cc2 = 239708;  // (64^2*(.03*255)^2
+
+static double Ssim8x8_C(const uint8_t* src_a,
+                        int stride_a,
+                        const uint8_t* src_b,
+                        int stride_b) {
+  int64_t sum_a = 0;
+  int64_t sum_b = 0;
+  int64_t sum_sq_a = 0;
+  int64_t sum_sq_b = 0;
+  int64_t sum_axb = 0;
+
+  int i;
+  for (i = 0; i < 8; ++i) {
+    int j;
+    for (j = 0; j < 8; ++j) {
+      sum_a += src_a[j];
+      sum_b += src_b[j];
+      sum_sq_a += src_a[j] * src_a[j];
+      sum_sq_b += src_b[j] * src_b[j];
+      sum_axb += src_a[j] * src_b[j];
+    }
+
+    src_a += stride_a;
+    src_b += stride_b;
+  }
+
+  {
+    const int64_t count = 64;
+    // scale the constants by number of pixels
+    const int64_t c1 = (cc1 * count * count) >> 12;
+    const int64_t c2 = (cc2 * count * count) >> 12;
+
+    const int64_t sum_a_x_sum_b = sum_a * sum_b;
+
+    const int64_t ssim_n = (2 * sum_a_x_sum_b + c1) *
+                           (2 * count * sum_axb - 2 * sum_a_x_sum_b + c2);
+
+    const int64_t sum_a_sq = sum_a * sum_a;
+    const int64_t sum_b_sq = sum_b * sum_b;
+
+    const int64_t ssim_d =
+        (sum_a_sq + sum_b_sq + c1) *
+        (count * sum_sq_a - sum_a_sq + count * sum_sq_b - sum_b_sq + c2);
+
+    if (ssim_d == 0.0) {
+      return DBL_MAX;
+    }
+    return ssim_n * 1.0 / ssim_d;
+  }
+}
+
+// We are using a 8x8 moving window with starting location of each 8x8 window
+// on the 4x4 pixel grid. Such arrangement allows the windows to overlap
+// block boundaries to penalize blocking artifacts.
+LIBYUV_API
+double CalcFrameSsim(const uint8_t* src_a,
+                     int stride_a,
+                     const uint8_t* src_b,
+                     int stride_b,
+                     int width,
+                     int height) {
+  int samples = 0;
+  double ssim_total = 0;
+  double (*Ssim8x8)(const uint8_t* src_a, int stride_a, const uint8_t* src_b,
+                    int stride_b) = Ssim8x8_C;
+
+  // sample point start with each 4x4 location
+  int i;
+  for (i = 0; i < height - 8; i += 4) {
+    int j;
+    for (j = 0; j < width - 8; j += 4) {
+      ssim_total += Ssim8x8(src_a + j, stride_a, src_b + j, stride_b);
+      samples++;
+    }
+
+    src_a += stride_a * 4;
+    src_b += stride_b * 4;
+  }
+
+  ssim_total /= samples;
+  return ssim_total;
+}
+
+LIBYUV_API
+double I420Ssim(const uint8_t* src_y_a,
+                int stride_y_a,
+                const uint8_t* src_u_a,
+                int stride_u_a,
+                const uint8_t* src_v_a,
+                int stride_v_a,
+                const uint8_t* src_y_b,
+                int stride_y_b,
+                const uint8_t* src_u_b,
+                int stride_u_b,
+                const uint8_t* src_v_b,
+                int stride_v_b,
+                int width,
+                int height) {
+  const double ssim_y =
+      CalcFrameSsim(src_y_a, stride_y_a, src_y_b, stride_y_b, width, height);
+  const int width_uv = (width + 1) >> 1;
+  const int height_uv = (height + 1) >> 1;
+  const double ssim_u = CalcFrameSsim(src_u_a, stride_u_a, src_u_b, stride_u_b,
+                                      width_uv, height_uv);
+  const double ssim_v = CalcFrameSsim(src_v_a, stride_v_a, src_v_b, stride_v_b,
+                                      width_uv, height_uv);
+  return ssim_y * 0.8 + 0.1 * (ssim_u + ssim_v);
+}
+
+#ifdef __cplusplus
+}  // extern "C"
+}  // namespace libyuv
+#endif
diff --git a/3rdparty/libyuv/src/source/compare_common.cc b/3rdparty/libyuv/src/source/compare_common.cc
new file mode 100644
index 00000000..d1cab8d2
--- /dev/null
+++ b/3rdparty/libyuv/src/source/compare_common.cc
@@ -0,0 +1,74 @@
+/*
+ *  Copyright 2012 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include "libyuv/basic_types.h"
+
+#include "libyuv/compare_row.h"
+
+#ifdef __cplusplus
+namespace libyuv {
+extern "C" {
+#endif
+
+// Hakmem method for hamming distance.
+uint32_t HammingDistance_C(const uint8_t* src_a,
+                           const uint8_t* src_b,
+                           int count) {
+  uint32_t diff = 0u;
+
+  int i;
+  for (i = 0; i < count - 3; i += 4) {
+    uint32_t x = *((const uint32_t*)src_a) ^ *((const uint32_t*)src_b);
+    uint32_t u = x - ((x >> 1) & 0x55555555);
+    u = ((u >> 2) & 0x33333333) + (u & 0x33333333);
+    diff += ((((u + (u >> 4)) & 0x0f0f0f0f) * 0x01010101) >> 24);
+    src_a += 4;
+    src_b += 4;
+  }
+
+  for (; i < count; ++i) {
+    uint32_t x = *src_a ^ *src_b;
+    uint32_t u = x - ((x >> 1) & 0x55);
+    u = ((u >> 2) & 0x33) + (u & 0x33);
+    diff += (u + (u >> 4)) & 0x0f;
+    src_a += 1;
+    src_b += 1;
+  }
+
+  return diff;
+}
+
+uint32_t SumSquareError_C(const uint8_t* src_a,
+                          const uint8_t* src_b,
+                          int count) {
+  uint32_t sse = 0u;
+  int i;
+  for (i = 0; i < count; ++i) {
+    int diff = src_a[i] - src_b[i];
+    sse += (uint32_t)(diff * diff);
+  }
+  return sse;
+}
+
+// hash seed of 5381 recommended.
+// Internal C version of HashDjb2 with int sized count for efficiency.
+uint32_t HashDjb2_C(const uint8_t* src, int count, uint32_t seed) {
+  uint32_t hash = seed;
+  int i;
+  for (i = 0; i < count; ++i) {
+    hash += (hash << 5) + src[i];
+  }
+  return hash;
+}
+
+#ifdef __cplusplus
+}  // extern "C"
+}  // namespace libyuv
+#endif
diff --git a/3rdparty/libyuv/src/source/compare_gcc.cc b/3rdparty/libyuv/src/source/compare_gcc.cc
new file mode 100644
index 00000000..b834b42a
--- /dev/null
+++ b/3rdparty/libyuv/src/source/compare_gcc.cc
@@ -0,0 +1,359 @@
+/*
+ *  Copyright 2012 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include "libyuv/basic_types.h"
+
+#include "libyuv/compare_row.h"
+#include "libyuv/row.h"
+
+#ifdef __cplusplus
+namespace libyuv {
+extern "C" {
+#endif
+
+// This module is for GCC x86 and x64.
+#if !defined(LIBYUV_DISABLE_X86) && (defined(__x86_64__) || defined(__i386__))
+
+#if defined(__x86_64__)
+uint32_t HammingDistance_SSE42(const uint8_t* src_a,
+                               const uint8_t* src_b,
+                               int count) {
+  uint64_t diff = 0u;
+
+  asm volatile(
+      "xor         %3,%3                         \n"
+      "xor         %%r8,%%r8                     \n"
+      "xor         %%r9,%%r9                     \n"
+      "xor         %%r10,%%r10                   \n"
+
+      // Process 32 bytes per loop.
+      LABELALIGN
+      "1:                                        \n"
+      "mov         (%0),%%rcx                    \n"
+      "mov         0x8(%0),%%rdx                 \n"
+      "xor         (%1),%%rcx                    \n"
+      "xor         0x8(%1),%%rdx                 \n"
+      "popcnt      %%rcx,%%rcx                   \n"
+      "popcnt      %%rdx,%%rdx                   \n"
+      "mov         0x10(%0),%%rsi                \n"
+      "mov         0x18(%0),%%rdi                \n"
+      "xor         0x10(%1),%%rsi                \n"
+      "xor         0x18(%1),%%rdi                \n"
+      "popcnt      %%rsi,%%rsi                   \n"
+      "popcnt      %%rdi,%%rdi                   \n"
+      "add         $0x20,%0                      \n"
+      "add         $0x20,%1                      \n"
+      "add         %%rcx,%3                      \n"
+      "add         %%rdx,%%r8                    \n"
+      "add         %%rsi,%%r9                    \n"
+      "add         %%rdi,%%r10                   \n"
+      "sub         $0x20,%2                      \n"
+      "jg          1b                            \n"
+
+      "add         %%r8, %3                      \n"
+      "add         %%r9, %3                      \n"
+      "add         %%r10, %3                     \n"
+      : "+r"(src_a),  // %0
+        "+r"(src_b),  // %1
+        "+r"(count),  // %2
+        "=r"(diff)    // %3
+      :
+      : "memory", "cc", "rcx", "rdx", "rsi", "rdi", "r8", "r9", "r10");
+
+  return static_cast<uint32_t>(diff);
+}
+#else
+uint32_t HammingDistance_SSE42(const uint8_t* src_a,
+                               const uint8_t* src_b,
+                               int count) {
+  uint32_t diff = 0u;
+
+  asm volatile(
+      // Process 16 bytes per loop.
+      LABELALIGN
+      "1:                                        \n"
+      "mov         (%0),%%ecx                    \n"
+      "mov         0x4(%0),%%edx                 \n"
+      "xor         (%1),%%ecx                    \n"
+      "xor         0x4(%1),%%edx                 \n"
+      "popcnt      %%ecx,%%ecx                   \n"
+      "add         %%ecx,%3                      \n"
+      "popcnt      %%edx,%%edx                   \n"
+      "add         %%edx,%3                      \n"
+      "mov         0x8(%0),%%ecx                 \n"
+      "mov         0xc(%0),%%edx                 \n"
+      "xor         0x8(%1),%%ecx                 \n"
+      "xor         0xc(%1),%%edx                 \n"
+      "popcnt      %%ecx,%%ecx                   \n"
+      "add         %%ecx,%3                      \n"
+      "popcnt      %%edx,%%edx                   \n"
+      "add         %%edx,%3                      \n"
+      "add         $0x10,%0                      \n"
+      "add         $0x10,%1                      \n"
+      "sub         $0x10,%2                      \n"
+      "jg          1b                            \n"
+      : "+r"(src_a),  // %0
+        "+r"(src_b),  // %1
+        "+r"(count),  // %2
+        "+r"(diff)    // %3
+      :
+      : "memory", "cc", "ecx", "edx");
+
+  return diff;
+}
+#endif
+
+static const vec8 kNibbleMask = {15, 15, 15, 15, 15, 15, 15, 15,
+                                 15, 15, 15, 15, 15, 15, 15, 15};
+static const vec8 kBitCount = {0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4};
+
+uint32_t HammingDistance_SSSE3(const uint8_t* src_a,
+                               const uint8_t* src_b,
+                               int count) {
+  uint32_t diff = 0u;
+
+  asm volatile(
+      "movdqa      %4,%%xmm2                     \n"
+      "movdqa      %5,%%xmm3                     \n"
+      "pxor        %%xmm0,%%xmm0                 \n"
+      "pxor        %%xmm1,%%xmm1                 \n"
+      "sub         %0,%1                         \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "movdqa      (%0),%%xmm4                   \n"
+      "movdqa      0x10(%0), %%xmm5              \n"
+      "pxor        (%0,%1), %%xmm4               \n"
+      "movdqa      %%xmm4,%%xmm6                 \n"
+      "pand        %%xmm2,%%xmm6                 \n"
+      "psrlw       $0x4,%%xmm4                   \n"
+      "movdqa      %%xmm3,%%xmm7                 \n"
+      "pshufb      %%xmm6,%%xmm7                 \n"
+      "pand        %%xmm2,%%xmm4                 \n"
+      "movdqa      %%xmm3,%%xmm6                 \n"
+      "pshufb      %%xmm4,%%xmm6                 \n"
+      "paddb       %%xmm7,%%xmm6                 \n"
+      "pxor        0x10(%0,%1),%%xmm5            \n"
+      "add         $0x20,%0                      \n"
+      "movdqa      %%xmm5,%%xmm4                 \n"
+      "pand        %%xmm2,%%xmm5                 \n"
+      "psrlw       $0x4,%%xmm4                   \n"
+      "movdqa      %%xmm3,%%xmm7                 \n"
+      "pshufb      %%xmm5,%%xmm7                 \n"
+      "pand        %%xmm2,%%xmm4                 \n"
+      "movdqa      %%xmm3,%%xmm5                 \n"
+      "pshufb      %%xmm4,%%xmm5                 \n"
+      "paddb       %%xmm7,%%xmm5                 \n"
+      "paddb       %%xmm5,%%xmm6                 \n"
+      "psadbw      %%xmm1,%%xmm6                 \n"
+      "paddd       %%xmm6,%%xmm0                 \n"
+      "sub         $0x20,%2                      \n"
+      "jg          1b                            \n"
+
+      "pshufd      $0xaa,%%xmm0,%%xmm1           \n"
+      "paddd       %%xmm1,%%xmm0                 \n"
+      "movd        %%xmm0, %3                    \n"
+      : "+r"(src_a),       // %0
+        "+r"(src_b),       // %1
+        "+r"(count),       // %2
+        "=r"(diff)         // %3
+      : "m"(kNibbleMask),  // %4
+        "m"(kBitCount)     // %5
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6",
+        "xmm7");
+
+  return diff;
+}
+
+#ifdef HAS_HAMMINGDISTANCE_AVX2
+uint32_t HammingDistance_AVX2(const uint8_t* src_a,
+                              const uint8_t* src_b,
+                              int count) {
+  uint32_t diff = 0u;
+
+  asm volatile(
+      "vbroadcastf128 %4,%%ymm2                  \n"
+      "vbroadcastf128 %5,%%ymm3                  \n"
+      "vpxor       %%ymm0,%%ymm0,%%ymm0          \n"
+      "vpxor       %%ymm1,%%ymm1,%%ymm1          \n"
+      "sub         %0,%1                         \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "vmovdqa     (%0),%%ymm4                   \n"
+      "vmovdqa     0x20(%0), %%ymm5              \n"
+      "vpxor       (%0,%1), %%ymm4, %%ymm4       \n"
+      "vpand       %%ymm2,%%ymm4,%%ymm6          \n"
+      "vpsrlw      $0x4,%%ymm4,%%ymm4            \n"
+      "vpshufb     %%ymm6,%%ymm3,%%ymm6          \n"
+      "vpand       %%ymm2,%%ymm4,%%ymm4          \n"
+      "vpshufb     %%ymm4,%%ymm3,%%ymm4          \n"
+      "vpaddb      %%ymm4,%%ymm6,%%ymm6          \n"
+      "vpxor       0x20(%0,%1),%%ymm5,%%ymm4     \n"
+      "add         $0x40,%0                      \n"
+      "vpand       %%ymm2,%%ymm4,%%ymm5          \n"
+      "vpsrlw      $0x4,%%ymm4,%%ymm4            \n"
+      "vpshufb     %%ymm5,%%ymm3,%%ymm5          \n"
+      "vpand       %%ymm2,%%ymm4,%%ymm4          \n"
+      "vpshufb     %%ymm4,%%ymm3,%%ymm4          \n"
+      "vpaddb      %%ymm5,%%ymm4,%%ymm4          \n"
+      "vpaddb      %%ymm6,%%ymm4,%%ymm4          \n"
+      "vpsadbw     %%ymm1,%%ymm4,%%ymm4          \n"
+      "vpaddd      %%ymm0,%%ymm4,%%ymm0          \n"
+      "sub         $0x40,%2                      \n"
+      "jg          1b                            \n"
+
+      "vpermq      $0xb1,%%ymm0,%%ymm1           \n"
+      "vpaddd      %%ymm1,%%ymm0,%%ymm0          \n"
+      "vpermq      $0xaa,%%ymm0,%%ymm1           \n"
+      "vpaddd      %%ymm1,%%ymm0,%%ymm0          \n"
+      "vmovd       %%xmm0, %3                    \n"
+      "vzeroupper                                \n"
+      : "+r"(src_a),       // %0
+        "+r"(src_b),       // %1
+        "+r"(count),       // %2
+        "=r"(diff)         // %3
+      : "m"(kNibbleMask),  // %4
+        "m"(kBitCount)     // %5
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6");
+
+  return diff;
+}
+#endif  // HAS_HAMMINGDISTANCE_AVX2
+
+uint32_t SumSquareError_SSE2(const uint8_t* src_a,
+                             const uint8_t* src_b,
+                             int count) {
+  uint32_t sse;
+  asm volatile(
+      "pxor        %%xmm0,%%xmm0                 \n"
+      "pxor        %%xmm5,%%xmm5                 \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "movdqu      (%0),%%xmm1                   \n"
+      "lea         0x10(%0),%0                   \n"
+      "movdqu      (%1),%%xmm2                   \n"
+      "lea         0x10(%1),%1                   \n"
+      "movdqa      %%xmm1,%%xmm3                 \n"
+      "psubusb     %%xmm2,%%xmm1                 \n"
+      "psubusb     %%xmm3,%%xmm2                 \n"
+      "por         %%xmm2,%%xmm1                 \n"
+      "movdqa      %%xmm1,%%xmm2                 \n"
+      "punpcklbw   %%xmm5,%%xmm1                 \n"
+      "punpckhbw   %%xmm5,%%xmm2                 \n"
+      "pmaddwd     %%xmm1,%%xmm1                 \n"
+      "pmaddwd     %%xmm2,%%xmm2                 \n"
+      "paddd       %%xmm1,%%xmm0                 \n"
+      "paddd       %%xmm2,%%xmm0                 \n"
+      "sub         $0x10,%2                      \n"
+      "jg          1b                            \n"
+
+      "pshufd      $0xee,%%xmm0,%%xmm1           \n"
+      "paddd       %%xmm1,%%xmm0                 \n"
+      "pshufd      $0x1,%%xmm0,%%xmm1            \n"
+      "paddd       %%xmm1,%%xmm0                 \n"
+      "movd        %%xmm0,%3                     \n"
+
+      : "+r"(src_a),  // %0
+        "+r"(src_b),  // %1
+        "+r"(count),  // %2
+        "=g"(sse)     // %3
+        ::"memory",
+        "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm5");
+  return sse;
+}
+
+static const uvec32 kHash16x33 = {0x92d9e201, 0, 0, 0};  // 33 ^ 16
+static const uvec32 kHashMul0 = {
+    0x0c3525e1,  // 33 ^ 15
+    0xa3476dc1,  // 33 ^ 14
+    0x3b4039a1,  // 33 ^ 13
+    0x4f5f0981,  // 33 ^ 12
+};
+static const uvec32 kHashMul1 = {
+    0x30f35d61,  // 33 ^ 11
+    0x855cb541,  // 33 ^ 10
+    0x040a9121,  // 33 ^ 9
+    0x747c7101,  // 33 ^ 8
+};
+static const uvec32 kHashMul2 = {
+    0xec41d4e1,  // 33 ^ 7
+    0x4cfa3cc1,  // 33 ^ 6
+    0x025528a1,  // 33 ^ 5
+    0x00121881,  // 33 ^ 4
+};
+static const uvec32 kHashMul3 = {
+    0x00008c61,  // 33 ^ 3
+    0x00000441,  // 33 ^ 2
+    0x00000021,  // 33 ^ 1
+    0x00000001,  // 33 ^ 0
+};
+
+uint32_t HashDjb2_SSE41(const uint8_t* src, int count, uint32_t seed) {
+  uint32_t hash;
+  asm volatile(
+      "movd        %2,%%xmm0                     \n"
+      "pxor        %%xmm7,%%xmm7                 \n"
+      "movdqa      %4,%%xmm6                     \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "movdqu      (%0),%%xmm1                   \n"
+      "lea         0x10(%0),%0                   \n"
+      "pmulld      %%xmm6,%%xmm0                 \n"
+      "movdqa      %5,%%xmm5                     \n"
+      "movdqa      %%xmm1,%%xmm2                 \n"
+      "punpcklbw   %%xmm7,%%xmm2                 \n"
+      "movdqa      %%xmm2,%%xmm3                 \n"
+      "punpcklwd   %%xmm7,%%xmm3                 \n"
+      "pmulld      %%xmm5,%%xmm3                 \n"
+      "movdqa      %6,%%xmm5                     \n"
+      "movdqa      %%xmm2,%%xmm4                 \n"
+      "punpckhwd   %%xmm7,%%xmm4                 \n"
+      "pmulld      %%xmm5,%%xmm4                 \n"
+      "movdqa      %7,%%xmm5                     \n"
+      "punpckhbw   %%xmm7,%%xmm1                 \n"
+      "movdqa      %%xmm1,%%xmm2                 \n"
+      "punpcklwd   %%xmm7,%%xmm2                 \n"
+      "pmulld      %%xmm5,%%xmm2                 \n"
+      "movdqa      %8,%%xmm5                     \n"
+      "punpckhwd   %%xmm7,%%xmm1                 \n"
+      "pmulld      %%xmm5,%%xmm1                 \n"
+      "paddd       %%xmm4,%%xmm3                 \n"
+      "paddd       %%xmm2,%%xmm1                 \n"
+      "paddd       %%xmm3,%%xmm1                 \n"
+      "pshufd      $0xe,%%xmm1,%%xmm2            \n"
+      "paddd       %%xmm2,%%xmm1                 \n"
+      "pshufd      $0x1,%%xmm1,%%xmm2            \n"
+      "paddd       %%xmm2,%%xmm1                 \n"
+      "paddd       %%xmm1,%%xmm0                 \n"
+      "sub         $0x10,%1                      \n"
+      "jg          1b                            \n"
+      "movd        %%xmm0,%3                     \n"
+      : "+r"(src),        // %0
+        "+r"(count),      // %1
+        "+rm"(seed),      // %2
+        "=g"(hash)        // %3
+      : "m"(kHash16x33),  // %4
+        "m"(kHashMul0),   // %5
+        "m"(kHashMul1),   // %6
+        "m"(kHashMul2),   // %7
+        "m"(kHashMul3)    // %8
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6",
+        "xmm7");
+  return hash;
+}
+#endif  // defined(__x86_64__) || (defined(__i386__) && !defined(__pic__)))
+
+#ifdef __cplusplus
+}  // extern "C"
+}  // namespace libyuv
+#endif
diff --git a/3rdparty/libyuv/src/source/compare_mmi.cc b/3rdparty/libyuv/src/source/compare_mmi.cc
new file mode 100644
index 00000000..7640d946
--- /dev/null
+++ b/3rdparty/libyuv/src/source/compare_mmi.cc
@@ -0,0 +1,123 @@
+/*
+ *  Copyright 2012 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include "libyuv/basic_types.h"
+
+#include "libyuv/compare_row.h"
+
+#ifdef __cplusplus
+namespace libyuv {
+extern "C" {
+#endif
+
+// This module is for Mips MMI.
+#if !defined(LIBYUV_DISABLE_MMI) && defined(_MIPS_ARCH_LOONGSON3A)
+
+// Hakmem method for hamming distance.
+uint32_t HammingDistance_MMI(const uint8_t* src_a,
+                             const uint8_t* src_b,
+                             int count) {
+  uint32_t diff = 0u;
+
+  uint64_t temp = 0, temp1 = 0, ta = 0, tb = 0;
+  uint64_t c1 = 0x5555555555555555;
+  uint64_t c2 = 0x3333333333333333;
+  uint64_t c3 = 0x0f0f0f0f0f0f0f0f;
+  uint32_t c4 = 0x01010101;
+  uint64_t s1 = 1, s2 = 2, s3 = 4;
+  __asm__ volatile(
+      "1:	\n\t"
+      "ldc1   %[ta],    0(%[src_a])          \n\t"
+      "ldc1   %[tb],    0(%[src_b])          \n\t"
+      "xor    %[temp],  %[ta],      %[tb]    \n\t"
+      "psrlw  %[temp1], %[temp],    %[s1]    \n\t"  // temp1=x>>1
+      "and    %[temp1], %[temp1],   %[c1]    \n\t"  // temp1&=c1
+      "psubw  %[temp1], %[temp],    %[temp1] \n\t"  // x-temp1
+      "and    %[temp],  %[temp1],   %[c2]    \n\t"  // t = (u&c2)
+      "psrlw  %[temp1], %[temp1],   %[s2]    \n\t"  // u>>2
+      "and    %[temp1], %[temp1],   %[c2]    \n\t"  // u>>2 & c2
+      "paddw  %[temp1], %[temp1],   %[temp]  \n\t"  // t1 = t1+t
+      "psrlw  %[temp],  %[temp1],   %[s3]    \n\t"  // u>>4
+      "paddw  %[temp1], %[temp1],   %[temp]  \n\t"  // u+(u>>4)
+      "and    %[temp1], %[temp1],   %[c3]    \n\t"  //&c3
+      "dmfc1  $t0,      %[temp1]             \n\t"
+      "dsrl32 $t0,      $t0,        0        \n\t "
+      "mul    $t0,      $t0,        %[c4]    \n\t"
+      "dsrl   $t0,      $t0,        24       \n\t"
+      "dadd   %[diff],  %[diff],    $t0      \n\t"
+      "dmfc1  $t0,      %[temp1]             \n\t"
+      "mul    $t0,      $t0,        %[c4]    \n\t"
+      "dsrl   $t0,      $t0,        24       \n\t"
+      "dadd   %[diff],  %[diff],    $t0      \n\t"
+      "daddiu %[src_a], %[src_a],   8        \n\t"
+      "daddiu %[src_b], %[src_b],   8        \n\t"
+      "addiu  %[count], %[count],  -8        \n\t"
+      "bgtz   %[count], 1b \n\t"
+      "nop                            \n\t"
+      : [diff] "+r"(diff), [src_a] "+r"(src_a), [src_b] "+r"(src_b),
+        [count] "+r"(count), [ta] "+f"(ta), [tb] "+f"(tb), [temp] "+f"(temp),
+        [temp1] "+f"(temp1)
+      : [c1] "f"(c1), [c2] "f"(c2), [c3] "f"(c3), [c4] "r"(c4), [s1] "f"(s1),
+        [s2] "f"(s2), [s3] "f"(s3)
+      : "memory");
+  return diff;
+}
+
+uint32_t SumSquareError_MMI(const uint8_t* src_a,
+                            const uint8_t* src_b,
+                            int count) {
+  uint32_t sse = 0u;
+  uint32_t sse_hi = 0u, sse_lo = 0u;
+
+  uint64_t src1, src2;
+  uint64_t diff, diff_hi, diff_lo;
+  uint64_t sse_sum, sse_tmp;
+
+  const uint64_t mask = 0x0ULL;
+
+  __asm__ volatile(
+      "xor        %[sse_sum],      %[sse_sum],        %[sse_sum]    \n\t"
+
+      "1:                                                           \n\t"
+      "ldc1       %[src1],         0x00(%[src_a])                   \n\t"
+      "ldc1       %[src2],         0x00(%[src_b])                   \n\t"
+      "pasubub    %[diff],         %[src1],           %[src2]       \n\t"
+      "punpcklbh  %[diff_lo],      %[diff],           %[mask]       \n\t"
+      "punpckhbh  %[diff_hi],      %[diff],           %[mask]       \n\t"
+      "pmaddhw    %[sse_tmp],      %[diff_lo],        %[diff_lo]    \n\t"
+      "paddw      %[sse_sum],      %[sse_sum],        %[sse_tmp]    \n\t"
+      "pmaddhw    %[sse_tmp],      %[diff_hi],        %[diff_hi]    \n\t"
+      "paddw      %[sse_sum],      %[sse_sum],        %[sse_tmp]    \n\t"
+
+      "daddiu     %[src_a],        %[src_a],          0x08          \n\t"
+      "daddiu     %[src_b],        %[src_b],          0x08          \n\t"
+      "daddiu     %[count],        %[count],         -0x08          \n\t"
+      "bnez       %[count],        1b                               \n\t"
+
+      "mfc1       %[sse_lo],       %[sse_sum]                       \n\t"
+      "mfhc1      %[sse_hi],       %[sse_sum]                       \n\t"
+      "daddu      %[sse],          %[sse_hi],         %[sse_lo]     \n\t"
+      : [sse] "+&r"(sse), [diff] "=&f"(diff), [src1] "=&f"(src1),
+        [src2] "=&f"(src2), [diff_lo] "=&f"(diff_lo), [diff_hi] "=&f"(diff_hi),
+        [sse_sum] "=&f"(sse_sum), [sse_tmp] "=&f"(sse_tmp),
+        [sse_hi] "+&r"(sse_hi), [sse_lo] "+&r"(sse_lo)
+      : [src_a] "r"(src_a), [src_b] "r"(src_b), [count] "r"(count),
+        [mask] "f"(mask)
+      : "memory");
+
+  return sse;
+}
+
+#endif  // !defined(LIBYUV_DISABLE_MMI) && defined(_MIPS_ARCH_LOONGSON3A)
+
+#ifdef __cplusplus
+}  // extern "C"
+}  // namespace libyuv
+#endif
diff --git a/3rdparty/libyuv/src/source/compare_msa.cc b/3rdparty/libyuv/src/source/compare_msa.cc
new file mode 100644
index 00000000..0b807d37
--- /dev/null
+++ b/3rdparty/libyuv/src/source/compare_msa.cc
@@ -0,0 +1,97 @@
+/*
+ *  Copyright 2017 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include "libyuv/basic_types.h"
+
+#include "libyuv/compare_row.h"
+#include "libyuv/row.h"
+
+// This module is for GCC MSA
+#if !defined(LIBYUV_DISABLE_MSA) && defined(__mips_msa)
+#include "libyuv/macros_msa.h"
+
+#ifdef __cplusplus
+namespace libyuv {
+extern "C" {
+#endif
+
+uint32_t HammingDistance_MSA(const uint8_t* src_a,
+                             const uint8_t* src_b,
+                             int count) {
+  uint32_t diff = 0u;
+  int i;
+  v16u8 src0, src1, src2, src3;
+  v2i64 vec0 = {0}, vec1 = {0};
+
+  for (i = 0; i < count; i += 32) {
+    src0 = (v16u8)__msa_ld_b((v16i8*)src_a, 0);
+    src1 = (v16u8)__msa_ld_b((v16i8*)src_a, 16);
+    src2 = (v16u8)__msa_ld_b((v16i8*)src_b, 0);
+    src3 = (v16u8)__msa_ld_b((v16i8*)src_b, 16);
+    src0 ^= src2;
+    src1 ^= src3;
+    vec0 += __msa_pcnt_d((v2i64)src0);
+    vec1 += __msa_pcnt_d((v2i64)src1);
+    src_a += 32;
+    src_b += 32;
+  }
+
+  vec0 += vec1;
+  diff = (uint32_t)__msa_copy_u_w((v4i32)vec0, 0);
+  diff += (uint32_t)__msa_copy_u_w((v4i32)vec0, 2);
+  return diff;
+}
+
+uint32_t SumSquareError_MSA(const uint8_t* src_a,
+                            const uint8_t* src_b,
+                            int count) {
+  uint32_t sse = 0u;
+  int i;
+  v16u8 src0, src1, src2, src3;
+  v8i16 vec0, vec1, vec2, vec3;
+  v4i32 reg0 = {0}, reg1 = {0}, reg2 = {0}, reg3 = {0};
+  v2i64 tmp0;
+
+  for (i = 0; i < count; i += 32) {
+    src0 = (v16u8)__msa_ld_b((v16i8*)src_a, 0);
+    src1 = (v16u8)__msa_ld_b((v16i8*)src_a, 16);
+    src2 = (v16u8)__msa_ld_b((v16i8*)src_b, 0);
+    src3 = (v16u8)__msa_ld_b((v16i8*)src_b, 16);
+    vec0 = (v8i16)__msa_ilvr_b((v16i8)src2, (v16i8)src0);
+    vec1 = (v8i16)__msa_ilvl_b((v16i8)src2, (v16i8)src0);
+    vec2 = (v8i16)__msa_ilvr_b((v16i8)src3, (v16i8)src1);
+    vec3 = (v8i16)__msa_ilvl_b((v16i8)src3, (v16i8)src1);
+    vec0 = __msa_hsub_u_h((v16u8)vec0, (v16u8)vec0);
+    vec1 = __msa_hsub_u_h((v16u8)vec1, (v16u8)vec1);
+    vec2 = __msa_hsub_u_h((v16u8)vec2, (v16u8)vec2);
+    vec3 = __msa_hsub_u_h((v16u8)vec3, (v16u8)vec3);
+    reg0 = __msa_dpadd_s_w(reg0, vec0, vec0);
+    reg1 = __msa_dpadd_s_w(reg1, vec1, vec1);
+    reg2 = __msa_dpadd_s_w(reg2, vec2, vec2);
+    reg3 = __msa_dpadd_s_w(reg3, vec3, vec3);
+    src_a += 32;
+    src_b += 32;
+  }
+
+  reg0 += reg1;
+  reg2 += reg3;
+  reg0 += reg2;
+  tmp0 = __msa_hadd_s_d(reg0, reg0);
+  sse = (uint32_t)__msa_copy_u_w((v4i32)tmp0, 0);
+  sse += (uint32_t)__msa_copy_u_w((v4i32)tmp0, 2);
+  return sse;
+}
+
+#ifdef __cplusplus
+}  // extern "C"
+}  // namespace libyuv
+#endif
+
+#endif  // !defined(LIBYUV_DISABLE_MSA) && defined(__mips_msa)
diff --git a/3rdparty/libyuv/src/source/compare_neon.cc b/3rdparty/libyuv/src/source/compare_neon.cc
new file mode 100644
index 00000000..afdd6012
--- /dev/null
+++ b/3rdparty/libyuv/src/source/compare_neon.cc
@@ -0,0 +1,96 @@
+/*
+ *  Copyright 2012 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include "libyuv/basic_types.h"
+
+#include "libyuv/compare_row.h"
+#include "libyuv/row.h"
+
+#ifdef __cplusplus
+namespace libyuv {
+extern "C" {
+#endif
+
+#if !defined(LIBYUV_DISABLE_NEON) && defined(__ARM_NEON__) && \
+    !defined(__aarch64__)
+
+// 256 bits at a time
+// uses short accumulator which restricts count to 131 KB
+uint32_t HammingDistance_NEON(const uint8_t* src_a,
+                              const uint8_t* src_b,
+                              int count) {
+  uint32_t diff;
+
+  asm volatile(
+      "vmov.u16    q4, #0                        \n"  // accumulator
+
+      "1:                                        \n"
+      "vld1.8      {q0, q1}, [%0]!               \n"
+      "vld1.8      {q2, q3}, [%1]!               \n"
+      "veor.32     q0, q0, q2                    \n"
+      "veor.32     q1, q1, q3                    \n"
+      "vcnt.i8     q0, q0                        \n"
+      "vcnt.i8     q1, q1                        \n"
+      "subs        %2, %2, #32                   \n"
+      "vadd.u8     q0, q0, q1                    \n"  // 16 byte counts
+      "vpadal.u8   q4, q0                        \n"  // 8 shorts
+      "bgt         1b                            \n"
+
+      "vpaddl.u16  q0, q4                        \n"  // 4 ints
+      "vpadd.u32   d0, d0, d1                    \n"
+      "vpadd.u32   d0, d0, d0                    \n"
+      "vmov.32     %3, d0[0]                     \n"
+
+      : "+r"(src_a), "+r"(src_b), "+r"(count), "=r"(diff)
+      :
+      : "cc", "q0", "q1", "q2", "q3", "q4");
+  return diff;
+}
+
+uint32_t SumSquareError_NEON(const uint8_t* src_a,
+                             const uint8_t* src_b,
+                             int count) {
+  uint32_t sse;
+  asm volatile(
+      "vmov.u8     q8, #0                        \n"
+      "vmov.u8     q10, #0                       \n"
+      "vmov.u8     q9, #0                        \n"
+      "vmov.u8     q11, #0                       \n"
+
+      "1:                                        \n"
+      "vld1.8      {q0}, [%0]!                   \n"
+      "vld1.8      {q1}, [%1]!                   \n"
+      "subs        %2, %2, #16                   \n"
+      "vsubl.u8    q2, d0, d2                    \n"
+      "vsubl.u8    q3, d1, d3                    \n"
+      "vmlal.s16   q8, d4, d4                    \n"
+      "vmlal.s16   q9, d6, d6                    \n"
+      "vmlal.s16   q10, d5, d5                   \n"
+      "vmlal.s16   q11, d7, d7                   \n"
+      "bgt         1b                            \n"
+
+      "vadd.u32    q8, q8, q9                    \n"
+      "vadd.u32    q10, q10, q11                 \n"
+      "vadd.u32    q11, q8, q10                  \n"
+      "vpaddl.u32  q1, q11                       \n"
+      "vadd.u64    d0, d2, d3                    \n"
+      "vmov.32     %3, d0[0]                     \n"
+      : "+r"(src_a), "+r"(src_b), "+r"(count), "=r"(sse)
+      :
+      : "memory", "cc", "q0", "q1", "q2", "q3", "q8", "q9", "q10", "q11");
+  return sse;
+}
+
+#endif  // defined(__ARM_NEON__) && !defined(__aarch64__)
+
+#ifdef __cplusplus
+}  // extern "C"
+}  // namespace libyuv
+#endif
diff --git a/3rdparty/libyuv/src/source/compare_neon64.cc b/3rdparty/libyuv/src/source/compare_neon64.cc
new file mode 100644
index 00000000..70fb9b91
--- /dev/null
+++ b/3rdparty/libyuv/src/source/compare_neon64.cc
@@ -0,0 +1,94 @@
+/*
+ *  Copyright 2012 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include "libyuv/basic_types.h"
+
+#include "libyuv/compare_row.h"
+#include "libyuv/row.h"
+
+#ifdef __cplusplus
+namespace libyuv {
+extern "C" {
+#endif
+
+#if !defined(LIBYUV_DISABLE_NEON) && defined(__aarch64__)
+
+// 256 bits at a time
+// uses short accumulator which restricts count to 131 KB
+uint32_t HammingDistance_NEON(const uint8_t* src_a,
+                              const uint8_t* src_b,
+                              int count) {
+  uint32_t diff;
+  asm volatile(
+      "movi        v4.8h, #0                     \n"
+
+      "1:                                        \n"
+      "ld1         {v0.16b, v1.16b}, [%0], #32   \n"
+      "ld1         {v2.16b, v3.16b}, [%1], #32   \n"
+      "eor         v0.16b, v0.16b, v2.16b        \n"
+      "prfm        pldl1keep, [%0, 448]          \n"  // prefetch 7 lines ahead
+      "eor         v1.16b, v1.16b, v3.16b        \n"
+      "cnt         v0.16b, v0.16b                \n"
+      "prfm        pldl1keep, [%1, 448]          \n"
+      "cnt         v1.16b, v1.16b                \n"
+      "subs        %w2, %w2, #32                 \n"
+      "add         v0.16b, v0.16b, v1.16b        \n"
+      "uadalp      v4.8h, v0.16b                 \n"
+      "b.gt        1b                            \n"
+
+      "uaddlv      s4, v4.8h                     \n"
+      "fmov        %w3, s4                       \n"
+      : "+r"(src_a), "+r"(src_b), "+r"(count), "=r"(diff)
+      :
+      : "cc", "v0", "v1", "v2", "v3", "v4");
+  return diff;
+}
+
+uint32_t SumSquareError_NEON(const uint8_t* src_a,
+                             const uint8_t* src_b,
+                             int count) {
+  uint32_t sse;
+  asm volatile(
+      "eor         v16.16b, v16.16b, v16.16b     \n"
+      "eor         v18.16b, v18.16b, v18.16b     \n"
+      "eor         v17.16b, v17.16b, v17.16b     \n"
+      "eor         v19.16b, v19.16b, v19.16b     \n"
+
+      "1:                                        \n"
+      "ld1         {v0.16b}, [%0], #16           \n"
+      "ld1         {v1.16b}, [%1], #16           \n"
+      "subs        %w2, %w2, #16                 \n"
+      "usubl       v2.8h, v0.8b, v1.8b           \n"
+      "usubl2      v3.8h, v0.16b, v1.16b         \n"
+      "prfm        pldl1keep, [%0, 448]          \n"  // prefetch 7 lines ahead
+      "smlal       v16.4s, v2.4h, v2.4h          \n"
+      "smlal       v17.4s, v3.4h, v3.4h          \n"
+      "prfm        pldl1keep, [%1, 448]          \n"
+      "smlal2      v18.4s, v2.8h, v2.8h          \n"
+      "smlal2      v19.4s, v3.8h, v3.8h          \n"
+      "b.gt        1b                            \n"
+
+      "add         v16.4s, v16.4s, v17.4s        \n"
+      "add         v18.4s, v18.4s, v19.4s        \n"
+      "add         v19.4s, v16.4s, v18.4s        \n"
+      "addv        s0, v19.4s                    \n"
+      "fmov        %w3, s0                       \n"
+      : "+r"(src_a), "+r"(src_b), "+r"(count), "=r"(sse)
+      :
+      : "cc", "v0", "v1", "v2", "v3", "v16", "v17", "v18", "v19");
+  return sse;
+}
+
+#endif  // !defined(LIBYUV_DISABLE_NEON) && defined(__aarch64__)
+
+#ifdef __cplusplus
+}  // extern "C"
+}  // namespace libyuv
+#endif
diff --git a/3rdparty/libyuv/src/source/compare_win.cc b/3rdparty/libyuv/src/source/compare_win.cc
new file mode 100644
index 00000000..9bb27f1d
--- /dev/null
+++ b/3rdparty/libyuv/src/source/compare_win.cc
@@ -0,0 +1,241 @@
+/*
+ *  Copyright 2012 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include "libyuv/basic_types.h"
+
+#include "libyuv/compare_row.h"
+#include "libyuv/row.h"
+
+#if defined(_MSC_VER)
+#include <intrin.h>  // For __popcnt
+#endif
+
+#ifdef __cplusplus
+namespace libyuv {
+extern "C" {
+#endif
+
+// This module is for 32 bit Visual C x86
+#if !defined(LIBYUV_DISABLE_X86) && defined(_MSC_VER) && \
+    !defined(__clang__) && defined(_M_IX86)
+
+uint32_t HammingDistance_SSE42(const uint8_t* src_a,
+                               const uint8_t* src_b,
+                               int count) {
+  uint32_t diff = 0u;
+
+  int i;
+  for (i = 0; i < count - 3; i += 4) {
+    uint32_t x = *((uint32_t*)src_a) ^ *((uint32_t*)src_b);  // NOLINT
+    src_a += 4;
+    src_b += 4;
+    diff += __popcnt(x);
+  }
+  return diff;
+}
+
+__declspec(naked) uint32_t
+    SumSquareError_SSE2(const uint8_t* src_a, const uint8_t* src_b, int count) {
+  __asm {
+    mov        eax, [esp + 4]  // src_a
+    mov        edx, [esp + 8]  // src_b
+    mov        ecx, [esp + 12]  // count
+    pxor       xmm0, xmm0
+    pxor       xmm5, xmm5
+
+  wloop:
+    movdqu     xmm1, [eax]
+    lea        eax,  [eax + 16]
+    movdqu     xmm2, [edx]
+    lea        edx,  [edx + 16]
+    movdqa     xmm3, xmm1  // abs trick
+    psubusb    xmm1, xmm2
+    psubusb    xmm2, xmm3
+    por        xmm1, xmm2
+    movdqa     xmm2, xmm1
+    punpcklbw  xmm1, xmm5
+    punpckhbw  xmm2, xmm5
+    pmaddwd    xmm1, xmm1
+    pmaddwd    xmm2, xmm2
+    paddd      xmm0, xmm1
+    paddd      xmm0, xmm2
+    sub        ecx, 16
+    jg         wloop
+
+    pshufd     xmm1, xmm0, 0xee
+    paddd      xmm0, xmm1
+    pshufd     xmm1, xmm0, 0x01
+    paddd      xmm0, xmm1
+    movd       eax, xmm0
+    ret
+  }
+}
+
+#ifdef HAS_SUMSQUAREERROR_AVX2
+// C4752: found Intel(R) Advanced Vector Extensions; consider using /arch:AVX.
+#pragma warning(disable : 4752)
+__declspec(naked) uint32_t
+    SumSquareError_AVX2(const uint8_t* src_a, const uint8_t* src_b, int count) {
+  __asm {
+    mov        eax, [esp + 4]  // src_a
+    mov        edx, [esp + 8]  // src_b
+    mov        ecx, [esp + 12]  // count
+    vpxor      ymm0, ymm0, ymm0  // sum
+    vpxor      ymm5, ymm5, ymm5  // constant 0 for unpck
+    sub        edx, eax
+
+  wloop:
+    vmovdqu    ymm1, [eax]
+    vmovdqu    ymm2, [eax + edx]
+    lea        eax,  [eax + 32]
+    vpsubusb   ymm3, ymm1, ymm2  // abs difference trick
+    vpsubusb   ymm2, ymm2, ymm1
+    vpor       ymm1, ymm2, ymm3
+    vpunpcklbw ymm2, ymm1, ymm5  // u16.  mutates order.
+    vpunpckhbw ymm1, ymm1, ymm5
+    vpmaddwd   ymm2, ymm2, ymm2  // square + hadd to u32.
+    vpmaddwd   ymm1, ymm1, ymm1
+    vpaddd     ymm0, ymm0, ymm1
+    vpaddd     ymm0, ymm0, ymm2
+    sub        ecx, 32
+    jg         wloop
+
+    vpshufd    ymm1, ymm0, 0xee  // 3, 2 + 1, 0 both lanes.
+    vpaddd     ymm0, ymm0, ymm1
+    vpshufd    ymm1, ymm0, 0x01  // 1 + 0 both lanes.
+    vpaddd     ymm0, ymm0, ymm1
+    vpermq     ymm1, ymm0, 0x02  // high + low lane.
+    vpaddd     ymm0, ymm0, ymm1
+    vmovd      eax, xmm0
+    vzeroupper
+    ret
+  }
+}
+#endif  // HAS_SUMSQUAREERROR_AVX2
+
+uvec32 kHash16x33 = {0x92d9e201, 0, 0, 0};  // 33 ^ 16
+uvec32 kHashMul0 = {
+    0x0c3525e1,  // 33 ^ 15
+    0xa3476dc1,  // 33 ^ 14
+    0x3b4039a1,  // 33 ^ 13
+    0x4f5f0981,  // 33 ^ 12
+};
+uvec32 kHashMul1 = {
+    0x30f35d61,  // 33 ^ 11
+    0x855cb541,  // 33 ^ 10
+    0x040a9121,  // 33 ^ 9
+    0x747c7101,  // 33 ^ 8
+};
+uvec32 kHashMul2 = {
+    0xec41d4e1,  // 33 ^ 7
+    0x4cfa3cc1,  // 33 ^ 6
+    0x025528a1,  // 33 ^ 5
+    0x00121881,  // 33 ^ 4
+};
+uvec32 kHashMul3 = {
+    0x00008c61,  // 33 ^ 3
+    0x00000441,  // 33 ^ 2
+    0x00000021,  // 33 ^ 1
+    0x00000001,  // 33 ^ 0
+};
+
+__declspec(naked) uint32_t
+    HashDjb2_SSE41(const uint8_t* src, int count, uint32_t seed) {
+  __asm {
+    mov        eax, [esp + 4]  // src
+    mov        ecx, [esp + 8]  // count
+    movd       xmm0, [esp + 12]  // seed
+
+    pxor       xmm7, xmm7  // constant 0 for unpck
+    movdqa     xmm6, xmmword ptr kHash16x33
+
+  wloop:
+    movdqu     xmm1, [eax]  // src[0-15]
+    lea        eax, [eax + 16]
+    pmulld     xmm0, xmm6  // hash *= 33 ^ 16
+    movdqa     xmm5, xmmword ptr kHashMul0
+    movdqa     xmm2, xmm1
+    punpcklbw  xmm2, xmm7  // src[0-7]
+    movdqa     xmm3, xmm2
+    punpcklwd  xmm3, xmm7  // src[0-3]
+    pmulld     xmm3, xmm5
+    movdqa     xmm5, xmmword ptr kHashMul1
+    movdqa     xmm4, xmm2
+    punpckhwd  xmm4, xmm7  // src[4-7]
+    pmulld     xmm4, xmm5
+    movdqa     xmm5, xmmword ptr kHashMul2
+    punpckhbw  xmm1, xmm7  // src[8-15]
+    movdqa     xmm2, xmm1
+    punpcklwd  xmm2, xmm7  // src[8-11]
+    pmulld     xmm2, xmm5
+    movdqa     xmm5, xmmword ptr kHashMul3
+    punpckhwd  xmm1, xmm7  // src[12-15]
+    pmulld     xmm1, xmm5
+    paddd      xmm3, xmm4  // add 16 results
+    paddd      xmm1, xmm2
+    paddd      xmm1, xmm3
+
+    pshufd     xmm2, xmm1, 0x0e  // upper 2 dwords
+    paddd      xmm1, xmm2
+    pshufd     xmm2, xmm1, 0x01
+    paddd      xmm1, xmm2
+    paddd      xmm0, xmm1
+    sub        ecx, 16
+    jg         wloop
+
+    movd       eax, xmm0  // return hash
+    ret
+  }
+}
+
+// Visual C 2012 required for AVX2.
+#ifdef HAS_HASHDJB2_AVX2
+__declspec(naked) uint32_t
+    HashDjb2_AVX2(const uint8_t* src, int count, uint32_t seed) {
+  __asm {
+    mov        eax, [esp + 4]  // src
+    mov        ecx, [esp + 8]  // count
+    vmovd      xmm0, [esp + 12]  // seed
+
+  wloop:
+    vpmovzxbd  xmm3, [eax]  // src[0-3]
+    vpmulld    xmm0, xmm0, xmmword ptr kHash16x33  // hash *= 33 ^ 16
+    vpmovzxbd  xmm4, [eax + 4]  // src[4-7]
+    vpmulld    xmm3, xmm3, xmmword ptr kHashMul0
+    vpmovzxbd  xmm2, [eax + 8]  // src[8-11]
+    vpmulld    xmm4, xmm4, xmmword ptr kHashMul1
+    vpmovzxbd  xmm1, [eax + 12]  // src[12-15]
+    vpmulld    xmm2, xmm2, xmmword ptr kHashMul2
+    lea        eax, [eax + 16]
+    vpmulld    xmm1, xmm1, xmmword ptr kHashMul3
+    vpaddd     xmm3, xmm3, xmm4  // add 16 results
+    vpaddd     xmm1, xmm1, xmm2
+    vpaddd     xmm1, xmm1, xmm3
+    vpshufd    xmm2, xmm1, 0x0e  // upper 2 dwords
+    vpaddd     xmm1, xmm1,xmm2
+    vpshufd    xmm2, xmm1, 0x01
+    vpaddd     xmm1, xmm1, xmm2
+    vpaddd     xmm0, xmm0, xmm1
+    sub        ecx, 16
+    jg         wloop
+
+    vmovd      eax, xmm0  // return hash
+    vzeroupper
+    ret
+  }
+}
+#endif  // HAS_HASHDJB2_AVX2
+
+#endif  // !defined(LIBYUV_DISABLE_X86) && defined(_M_IX86)
+
+#ifdef __cplusplus
+}  // extern "C"
+}  // namespace libyuv
+#endif
diff --git a/3rdparty/libyuv/src/source/convert.cc b/3rdparty/libyuv/src/source/convert.cc
new file mode 100644
index 00000000..162546e5
--- /dev/null
+++ b/3rdparty/libyuv/src/source/convert.cc
@@ -0,0 +1,3271 @@
+/*
+ *  Copyright 2011 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include "libyuv/convert.h"
+
+#include "libyuv/basic_types.h"
+#include "libyuv/cpu_id.h"
+#include "libyuv/planar_functions.h"
+#include "libyuv/rotate.h"
+#include "libyuv/row.h"
+#include "libyuv/scale.h"      // For ScalePlane()
+#include "libyuv/scale_row.h"  // For FixedDiv
+#include "libyuv/scale_uv.h"   // For UVScale()
+
+#ifdef __cplusplus
+namespace libyuv {
+extern "C" {
+#endif
+
+#define SUBSAMPLE(v, a, s) (v < 0) ? (-((-v + a) >> s)) : ((v + a) >> s)
+static __inline int Abs(int v) {
+  return v >= 0 ? v : -v;
+}
+
+// Any I4xx To I420 format with mirroring.
+static int I4xxToI420(const uint8_t* src_y,
+                      int src_stride_y,
+                      const uint8_t* src_u,
+                      int src_stride_u,
+                      const uint8_t* src_v,
+                      int src_stride_v,
+                      uint8_t* dst_y,
+                      int dst_stride_y,
+                      uint8_t* dst_u,
+                      int dst_stride_u,
+                      uint8_t* dst_v,
+                      int dst_stride_v,
+                      int src_y_width,
+                      int src_y_height,
+                      int src_uv_width,
+                      int src_uv_height) {
+  const int dst_y_width = Abs(src_y_width);
+  const int dst_y_height = Abs(src_y_height);
+  const int dst_uv_width = SUBSAMPLE(dst_y_width, 1, 1);
+  const int dst_uv_height = SUBSAMPLE(dst_y_height, 1, 1);
+  if (src_uv_width <= 0 || src_uv_height == 0) {
+    return -1;
+  }
+  if (dst_y) {
+    ScalePlane(src_y, src_stride_y, src_y_width, src_y_height, dst_y,
+               dst_stride_y, dst_y_width, dst_y_height, kFilterBilinear);
+  }
+  ScalePlane(src_u, src_stride_u, src_uv_width, src_uv_height, dst_u,
+             dst_stride_u, dst_uv_width, dst_uv_height, kFilterBilinear);
+  ScalePlane(src_v, src_stride_v, src_uv_width, src_uv_height, dst_v,
+             dst_stride_v, dst_uv_width, dst_uv_height, kFilterBilinear);
+  return 0;
+}
+
+// Copy I420 with optional flipping.
+// TODO(fbarchard): Use Scale plane which supports mirroring, but ensure
+// is does row coalescing.
+LIBYUV_API
+int I420Copy(const uint8_t* src_y,
+             int src_stride_y,
+             const uint8_t* src_u,
+             int src_stride_u,
+             const uint8_t* src_v,
+             int src_stride_v,
+             uint8_t* dst_y,
+             int dst_stride_y,
+             uint8_t* dst_u,
+             int dst_stride_u,
+             uint8_t* dst_v,
+             int dst_stride_v,
+             int width,
+             int height) {
+  int halfwidth = (width + 1) >> 1;
+  int halfheight = (height + 1) >> 1;
+  if ((!src_y && dst_y) || !src_u || !src_v || !dst_u || !dst_v || width <= 0 ||
+      height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    halfheight = (height + 1) >> 1;
+    src_y = src_y + (height - 1) * src_stride_y;
+    src_u = src_u + (halfheight - 1) * src_stride_u;
+    src_v = src_v + (halfheight - 1) * src_stride_v;
+    src_stride_y = -src_stride_y;
+    src_stride_u = -src_stride_u;
+    src_stride_v = -src_stride_v;
+  }
+
+  if (dst_y) {
+    CopyPlane(src_y, src_stride_y, dst_y, dst_stride_y, width, height);
+  }
+  // Copy UV planes.
+  CopyPlane(src_u, src_stride_u, dst_u, dst_stride_u, halfwidth, halfheight);
+  CopyPlane(src_v, src_stride_v, dst_v, dst_stride_v, halfwidth, halfheight);
+  return 0;
+}
+
+// Copy I010 with optional flipping.
+LIBYUV_API
+int I010Copy(const uint16_t* src_y,
+             int src_stride_y,
+             const uint16_t* src_u,
+             int src_stride_u,
+             const uint16_t* src_v,
+             int src_stride_v,
+             uint16_t* dst_y,
+             int dst_stride_y,
+             uint16_t* dst_u,
+             int dst_stride_u,
+             uint16_t* dst_v,
+             int dst_stride_v,
+             int width,
+             int height) {
+  int halfwidth = (width + 1) >> 1;
+  int halfheight = (height + 1) >> 1;
+  if ((!src_y && dst_y) || !src_u || !src_v || !dst_u || !dst_v || width <= 0 ||
+      height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    halfheight = (height + 1) >> 1;
+    src_y = src_y + (height - 1) * src_stride_y;
+    src_u = src_u + (halfheight - 1) * src_stride_u;
+    src_v = src_v + (halfheight - 1) * src_stride_v;
+    src_stride_y = -src_stride_y;
+    src_stride_u = -src_stride_u;
+    src_stride_v = -src_stride_v;
+  }
+
+  if (dst_y) {
+    CopyPlane_16(src_y, src_stride_y, dst_y, dst_stride_y, width, height);
+  }
+  // Copy UV planes.
+  CopyPlane_16(src_u, src_stride_u, dst_u, dst_stride_u, halfwidth, halfheight);
+  CopyPlane_16(src_v, src_stride_v, dst_v, dst_stride_v, halfwidth, halfheight);
+  return 0;
+}
+
+static int Planar16bitTo8bit(const uint16_t* src_y,
+                             int src_stride_y,
+                             const uint16_t* src_u,
+                             int src_stride_u,
+                             const uint16_t* src_v,
+                             int src_stride_v,
+                             uint8_t* dst_y,
+                             int dst_stride_y,
+                             uint8_t* dst_u,
+                             int dst_stride_u,
+                             uint8_t* dst_v,
+                             int dst_stride_v,
+                             int width,
+                             int height,
+                             int subsample_x,
+                             int subsample_y,
+                             int depth) {
+  int uv_width = SUBSAMPLE(width, subsample_x, subsample_x);
+  int uv_height = SUBSAMPLE(height, subsample_y, subsample_y);
+  int scale = 1 << (24 - depth);
+  if ((!src_y && dst_y) || !src_u || !src_v || !dst_u || !dst_v || width <= 0 ||
+      height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    uv_height = -uv_height;
+    src_y = src_y + (height - 1) * src_stride_y;
+    src_u = src_u + (uv_height - 1) * src_stride_u;
+    src_v = src_v + (uv_height - 1) * src_stride_v;
+    src_stride_y = -src_stride_y;
+    src_stride_u = -src_stride_u;
+    src_stride_v = -src_stride_v;
+  }
+
+  // Convert Y plane.
+  Convert16To8Plane(src_y, src_stride_y, dst_y, dst_stride_y, scale, width,
+                    height);
+  // Convert UV planes.
+  Convert16To8Plane(src_u, src_stride_u, dst_u, dst_stride_u, scale, uv_width,
+                    uv_height);
+  Convert16To8Plane(src_v, src_stride_v, dst_v, dst_stride_v, scale, uv_width,
+                    uv_height);
+  return 0;
+}
+
+// Convert 10 bit YUV to 8 bit.
+LIBYUV_API
+int I010ToI420(const uint16_t* src_y,
+               int src_stride_y,
+               const uint16_t* src_u,
+               int src_stride_u,
+               const uint16_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_u,
+               int dst_stride_u,
+               uint8_t* dst_v,
+               int dst_stride_v,
+               int width,
+               int height) {
+  return Planar16bitTo8bit(src_y, src_stride_y, src_u, src_stride_u, src_v,
+                           src_stride_v, dst_y, dst_stride_y, dst_u,
+                           dst_stride_u, dst_v, dst_stride_v, width, height, 1,
+                           1, 10);
+}
+
+LIBYUV_API
+int I210ToI420(const uint16_t* src_y,
+               int src_stride_y,
+               const uint16_t* src_u,
+               int src_stride_u,
+               const uint16_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_u,
+               int dst_stride_u,
+               uint8_t* dst_v,
+               int dst_stride_v,
+               int width,
+               int height) {
+  const int depth = 10;
+  const int scale = 1 << (24 - depth);
+
+  if (width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    src_y = src_y + (height - 1) * src_stride_y;
+    src_u = src_u + (height - 1) * src_stride_u;
+    src_v = src_v + (height - 1) * src_stride_v;
+    src_stride_y = -src_stride_y;
+    src_stride_u = -src_stride_u;
+    src_stride_v = -src_stride_v;
+  }
+
+  {
+    const int uv_width = SUBSAMPLE(width, 1, 1);
+    const int uv_height = SUBSAMPLE(height, 1, 1);
+    const int dy = FixedDiv(height, uv_height);
+
+    Convert16To8Plane(src_y, src_stride_y, dst_y, dst_stride_y, scale, width,
+                      height);
+    ScalePlaneVertical_16To8(height, uv_width, uv_height, src_stride_u,
+                             dst_stride_u, src_u, dst_u, 0, 32768, dy,
+                             /*bpp=*/1, scale, kFilterBilinear);
+    ScalePlaneVertical_16To8(height, uv_width, uv_height, src_stride_v,
+                             dst_stride_v, src_v, dst_v, 0, 32768, dy,
+                             /*bpp=*/1, scale, kFilterBilinear);
+  }
+  return 0;
+}
+
+LIBYUV_API
+int I210ToI422(const uint16_t* src_y,
+               int src_stride_y,
+               const uint16_t* src_u,
+               int src_stride_u,
+               const uint16_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_u,
+               int dst_stride_u,
+               uint8_t* dst_v,
+               int dst_stride_v,
+               int width,
+               int height) {
+  return Planar16bitTo8bit(src_y, src_stride_y, src_u, src_stride_u, src_v,
+                           src_stride_v, dst_y, dst_stride_y, dst_u,
+                           dst_stride_u, dst_v, dst_stride_v, width, height, 1,
+                           0, 10);
+}
+
+LIBYUV_API
+int I410ToI444(const uint16_t* src_y,
+               int src_stride_y,
+               const uint16_t* src_u,
+               int src_stride_u,
+               const uint16_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_u,
+               int dst_stride_u,
+               uint8_t* dst_v,
+               int dst_stride_v,
+               int width,
+               int height) {
+  return Planar16bitTo8bit(src_y, src_stride_y, src_u, src_stride_u, src_v,
+                           src_stride_v, dst_y, dst_stride_y, dst_u,
+                           dst_stride_u, dst_v, dst_stride_v, width, height, 0,
+                           0, 10);
+}
+
+LIBYUV_API
+int I012ToI420(const uint16_t* src_y,
+               int src_stride_y,
+               const uint16_t* src_u,
+               int src_stride_u,
+               const uint16_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_u,
+               int dst_stride_u,
+               uint8_t* dst_v,
+               int dst_stride_v,
+               int width,
+               int height) {
+  return Planar16bitTo8bit(src_y, src_stride_y, src_u, src_stride_u, src_v,
+                           src_stride_v, dst_y, dst_stride_y, dst_u,
+                           dst_stride_u, dst_v, dst_stride_v, width, height, 1,
+                           1, 12);
+}
+
+LIBYUV_API
+int I212ToI422(const uint16_t* src_y,
+               int src_stride_y,
+               const uint16_t* src_u,
+               int src_stride_u,
+               const uint16_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_u,
+               int dst_stride_u,
+               uint8_t* dst_v,
+               int dst_stride_v,
+               int width,
+               int height) {
+  return Planar16bitTo8bit(src_y, src_stride_y, src_u, src_stride_u, src_v,
+                           src_stride_v, dst_y, dst_stride_y, dst_u,
+                           dst_stride_u, dst_v, dst_stride_v, width, height, 1,
+                           0, 12);
+}
+
+LIBYUV_API
+int I412ToI444(const uint16_t* src_y,
+               int src_stride_y,
+               const uint16_t* src_u,
+               int src_stride_u,
+               const uint16_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_u,
+               int dst_stride_u,
+               uint8_t* dst_v,
+               int dst_stride_v,
+               int width,
+               int height) {
+  return Planar16bitTo8bit(src_y, src_stride_y, src_u, src_stride_u, src_v,
+                           src_stride_v, dst_y, dst_stride_y, dst_u,
+                           dst_stride_u, dst_v, dst_stride_v, width, height, 0,
+                           0, 12);
+}
+
+// Any Ix10 To I010 format with mirroring.
+static int Ix10ToI010(const uint16_t* src_y,
+                      int src_stride_y,
+                      const uint16_t* src_u,
+                      int src_stride_u,
+                      const uint16_t* src_v,
+                      int src_stride_v,
+                      uint16_t* dst_y,
+                      int dst_stride_y,
+                      uint16_t* dst_u,
+                      int dst_stride_u,
+                      uint16_t* dst_v,
+                      int dst_stride_v,
+                      int width,
+                      int height,
+                      int subsample_x,
+                      int subsample_y) {
+  const int dst_y_width = Abs(width);
+  const int dst_y_height = Abs(height);
+  const int src_uv_width = SUBSAMPLE(width, subsample_x, subsample_x);
+  const int src_uv_height = SUBSAMPLE(height, subsample_y, subsample_y);
+  const int dst_uv_width = SUBSAMPLE(dst_y_width, 1, 1);
+  const int dst_uv_height = SUBSAMPLE(dst_y_height, 1, 1);
+  if (width <= 0 || height == 0) {
+    return -1;
+  }
+  if (dst_y) {
+    ScalePlane_12(src_y, src_stride_y, width, height, dst_y, dst_stride_y,
+                  dst_y_width, dst_y_height, kFilterBilinear);
+  }
+  ScalePlane_12(src_u, src_stride_u, src_uv_width, src_uv_height, dst_u,
+                dst_stride_u, dst_uv_width, dst_uv_height, kFilterBilinear);
+  ScalePlane_12(src_v, src_stride_v, src_uv_width, src_uv_height, dst_v,
+                dst_stride_v, dst_uv_width, dst_uv_height, kFilterBilinear);
+  return 0;
+}
+
+LIBYUV_API
+int I410ToI010(const uint16_t* src_y,
+               int src_stride_y,
+               const uint16_t* src_u,
+               int src_stride_u,
+               const uint16_t* src_v,
+               int src_stride_v,
+               uint16_t* dst_y,
+               int dst_stride_y,
+               uint16_t* dst_u,
+               int dst_stride_u,
+               uint16_t* dst_v,
+               int dst_stride_v,
+               int width,
+               int height) {
+  return Ix10ToI010(src_y, src_stride_y, src_u, src_stride_u, src_v,
+                    src_stride_v, dst_y, dst_stride_y, dst_u, dst_stride_u,
+                    dst_v, dst_stride_v, width, height, 0, 0);
+}
+
+LIBYUV_API
+int I210ToI010(const uint16_t* src_y,
+               int src_stride_y,
+               const uint16_t* src_u,
+               int src_stride_u,
+               const uint16_t* src_v,
+               int src_stride_v,
+               uint16_t* dst_y,
+               int dst_stride_y,
+               uint16_t* dst_u,
+               int dst_stride_u,
+               uint16_t* dst_v,
+               int dst_stride_v,
+               int width,
+               int height) {
+  return Ix10ToI010(src_y, src_stride_y, src_u, src_stride_u, src_v,
+                    src_stride_v, dst_y, dst_stride_y, dst_u, dst_stride_u,
+                    dst_v, dst_stride_v, width, height, 1, 0);
+}
+
+// Any I[420]1[02] to P[420]1[02] format with mirroring.
+static int IxxxToPxxx(const uint16_t* src_y,
+                      int src_stride_y,
+                      const uint16_t* src_u,
+                      int src_stride_u,
+                      const uint16_t* src_v,
+                      int src_stride_v,
+                      uint16_t* dst_y,
+                      int dst_stride_y,
+                      uint16_t* dst_uv,
+                      int dst_stride_uv,
+                      int width,
+                      int height,
+                      int subsample_x,
+                      int subsample_y,
+                      int depth) {
+  const int uv_width = SUBSAMPLE(width, subsample_x, subsample_x);
+  const int uv_height = SUBSAMPLE(height, subsample_y, subsample_y);
+  if (width <= 0 || height == 0) {
+    return -1;
+  }
+
+  ConvertToMSBPlane_16(src_y, src_stride_y, dst_y, dst_stride_y, width, height,
+                       depth);
+  MergeUVPlane_16(src_u, src_stride_u, src_v, src_stride_v, dst_uv,
+                  dst_stride_uv, uv_width, uv_height, depth);
+  return 0;
+}
+
+LIBYUV_API
+int I010ToP010(const uint16_t* src_y,
+               int src_stride_y,
+               const uint16_t* src_u,
+               int src_stride_u,
+               const uint16_t* src_v,
+               int src_stride_v,
+               uint16_t* dst_y,
+               int dst_stride_y,
+               uint16_t* dst_uv,
+               int dst_stride_uv,
+               int width,
+               int height) {
+  return IxxxToPxxx(src_y, src_stride_y, src_u, src_stride_u, src_v,
+                    src_stride_v, dst_y, dst_stride_y, dst_uv, dst_stride_uv,
+                    width, height, 1, 1, 10);
+}
+
+LIBYUV_API
+int I210ToP210(const uint16_t* src_y,
+               int src_stride_y,
+               const uint16_t* src_u,
+               int src_stride_u,
+               const uint16_t* src_v,
+               int src_stride_v,
+               uint16_t* dst_y,
+               int dst_stride_y,
+               uint16_t* dst_uv,
+               int dst_stride_uv,
+               int width,
+               int height) {
+  return IxxxToPxxx(src_y, src_stride_y, src_u, src_stride_u, src_v,
+                    src_stride_v, dst_y, dst_stride_y, dst_uv, dst_stride_uv,
+                    width, height, 1, 0, 10);
+}
+
+LIBYUV_API
+int I012ToP012(const uint16_t* src_y,
+               int src_stride_y,
+               const uint16_t* src_u,
+               int src_stride_u,
+               const uint16_t* src_v,
+               int src_stride_v,
+               uint16_t* dst_y,
+               int dst_stride_y,
+               uint16_t* dst_uv,
+               int dst_stride_uv,
+               int width,
+               int height) {
+  return IxxxToPxxx(src_y, src_stride_y, src_u, src_stride_u, src_v,
+                    src_stride_v, dst_y, dst_stride_y, dst_uv, dst_stride_uv,
+                    width, height, 1, 1, 12);
+}
+
+LIBYUV_API
+int I212ToP212(const uint16_t* src_y,
+               int src_stride_y,
+               const uint16_t* src_u,
+               int src_stride_u,
+               const uint16_t* src_v,
+               int src_stride_v,
+               uint16_t* dst_y,
+               int dst_stride_y,
+               uint16_t* dst_uv,
+               int dst_stride_uv,
+               int width,
+               int height) {
+  return IxxxToPxxx(src_y, src_stride_y, src_u, src_stride_u, src_v,
+                    src_stride_v, dst_y, dst_stride_y, dst_uv, dst_stride_uv,
+                    width, height, 1, 0, 12);
+}
+
+// 422 chroma is 1/2 width, 1x height
+// 420 chroma is 1/2 width, 1/2 height
+LIBYUV_API
+int I422ToI420(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_u,
+               int dst_stride_u,
+               uint8_t* dst_v,
+               int dst_stride_v,
+               int width,
+               int height) {
+  const int src_uv_width = SUBSAMPLE(width, 1, 1);
+  return I4xxToI420(src_y, src_stride_y, src_u, src_stride_u, src_v,
+                    src_stride_v, dst_y, dst_stride_y, dst_u, dst_stride_u,
+                    dst_v, dst_stride_v, width, height, src_uv_width, height);
+}
+
+LIBYUV_API
+int I422ToI210(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint16_t* dst_y,
+               int dst_stride_y,
+               uint16_t* dst_u,
+               int dst_stride_u,
+               uint16_t* dst_v,
+               int dst_stride_v,
+               int width,
+               int height) {
+  int halfwidth = (width + 1) >> 1;
+  if ((!src_y && dst_y) || !src_u || !src_v || !dst_u || !dst_v || width <= 0 ||
+      height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    src_y = src_y + (height - 1) * src_stride_y;
+    src_u = src_u + (height - 1) * src_stride_u;
+    src_v = src_v + (height - 1) * src_stride_v;
+    src_stride_y = -src_stride_y;
+    src_stride_u = -src_stride_u;
+    src_stride_v = -src_stride_v;
+  }
+
+  // Convert Y plane.
+  Convert8To16Plane(src_y, src_stride_y, dst_y, dst_stride_y, 1024, width,
+                    height);
+  // Convert UV planes.
+  Convert8To16Plane(src_u, src_stride_u, dst_u, dst_stride_u, 1024, halfwidth,
+                    height);
+  Convert8To16Plane(src_v, src_stride_v, dst_v, dst_stride_v, 1024, halfwidth,
+                    height);
+  return 0;
+}
+
+// TODO(fbarchard): Implement row conversion.
+LIBYUV_API
+int I422ToNV21(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_vu,
+               int dst_stride_vu,
+               int width,
+               int height) {
+  int halfwidth = (width + 1) >> 1;
+  int halfheight = (height + 1) >> 1;
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    halfheight = (height + 1) >> 1;
+    src_y = src_y + (height - 1) * src_stride_y;
+    src_u = src_u + (height - 1) * src_stride_u;
+    src_v = src_v + (height - 1) * src_stride_v;
+    src_stride_y = -src_stride_y;
+    src_stride_u = -src_stride_u;
+    src_stride_v = -src_stride_v;
+  }
+
+  // Allocate u and v buffers
+  align_buffer_64(plane_u, halfwidth * halfheight * 2);
+  uint8_t* plane_v = plane_u + halfwidth * halfheight;
+
+  I422ToI420(src_y, src_stride_y, src_u, src_stride_u, src_v, src_stride_v,
+             dst_y, dst_stride_y, plane_u, halfwidth, plane_v, halfwidth, width,
+             height);
+  MergeUVPlane(plane_v, halfwidth, plane_u, halfwidth, dst_vu, dst_stride_vu,
+               halfwidth, halfheight);
+  free_aligned_buffer_64(plane_u);
+  return 0;
+}
+
+LIBYUV_API
+int MM21ToNV12(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_uv,
+               int src_stride_uv,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_uv,
+               int dst_stride_uv,
+               int width,
+               int height) {
+  if (!src_uv || !dst_uv || width <= 0) {
+    return -1;
+  }
+
+  int sign = height < 0 ? -1 : 1;
+
+  if (dst_y) {
+    DetilePlane(src_y, src_stride_y, dst_y, dst_stride_y, width, height, 32);
+  }
+  DetilePlane(src_uv, src_stride_uv, dst_uv, dst_stride_uv, (width + 1) & ~1,
+              (height + sign) / 2, 16);
+
+  return 0;
+}
+
+LIBYUV_API
+int MM21ToI420(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_uv,
+               int src_stride_uv,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_u,
+               int dst_stride_u,
+               uint8_t* dst_v,
+               int dst_stride_v,
+               int width,
+               int height) {
+  int sign = height < 0 ? -1 : 1;
+
+  if (!src_uv || !dst_u || !dst_v || width <= 0) {
+    return -1;
+  }
+
+  if (dst_y) {
+    DetilePlane(src_y, src_stride_y, dst_y, dst_stride_y, width, height, 32);
+  }
+  DetileSplitUVPlane(src_uv, src_stride_uv, dst_u, dst_stride_u, dst_v,
+                     dst_stride_v, (width + 1) & ~1, (height + sign) / 2, 16);
+
+  return 0;
+}
+
+#ifdef I422TONV21_ROW_VERSION
+// Unittest fails for this version.
+// 422 chroma is 1/2 width, 1x height
+// 420 chroma is 1/2 width, 1/2 height
+// Swap src_u and src_v to implement I422ToNV12
+LIBYUV_API
+int I422ToNV21(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_vu,
+               int dst_stride_vu,
+               int width,
+               int height) {
+  int y;
+  void (*MergeUVRow)(const uint8_t* src_u, const uint8_t* src_v,
+                     uint8_t* dst_uv, int width) = MergeUVRow_C;
+  void (*InterpolateRow)(uint8_t * dst_ptr, const uint8_t* src_ptr,
+                         ptrdiff_t src_stride, int dst_width,
+                         int source_y_fraction) = InterpolateRow_C;
+  int halfwidth = (width + 1) >> 1;
+  int halfheight = (height + 1) >> 1;
+  if (!src_u || !src_v || !dst_vu || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    halfheight = (height + 1) >> 1;
+    src_y = src_y + (height - 1) * src_stride_y;
+    src_u = src_u + (halfheight - 1) * src_stride_u;
+    src_v = src_v + (halfheight - 1) * src_stride_v;
+    src_stride_y = -src_stride_y;
+    src_stride_u = -src_stride_u;
+    src_stride_v = -src_stride_v;
+  }
+#if defined(HAS_MERGEUVROW_SSE2)
+  if (TestCpuFlag(kCpuHasSSE2)) {
+    MergeUVRow = MergeUVRow_Any_SSE2;
+    if (IS_ALIGNED(halfwidth, 16)) {
+      MergeUVRow = MergeUVRow_SSE2;
+    }
+  }
+#endif
+#if defined(HAS_MERGEUVROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    MergeUVRow = MergeUVRow_Any_AVX2;
+    if (IS_ALIGNED(halfwidth, 32)) {
+      MergeUVRow = MergeUVRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_MERGEUVROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    MergeUVRow = MergeUVRow_Any_NEON;
+    if (IS_ALIGNED(halfwidth, 16)) {
+      MergeUVRow = MergeUVRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_MERGEUVROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    MergeUVRow = MergeUVRow_Any_MSA;
+    if (IS_ALIGNED(halfwidth, 16)) {
+      MergeUVRow = MergeUVRow_MSA;
+    }
+  }
+#endif
+#if defined(HAS_MERGEUVROW_LSX)
+  if (TestCpuFlag(kCpuHasLSX)) {
+    MergeUVRow = MergeUVRow_Any_LSX;
+    if (IS_ALIGNED(halfwidth, 16)) {
+      MergeUVRow = MergeUVRow_LSX;
+    }
+  }
+#endif
+#if defined(HAS_INTERPOLATEROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    InterpolateRow = InterpolateRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 16)) {
+      InterpolateRow = InterpolateRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_INTERPOLATEROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    InterpolateRow = InterpolateRow_Any_AVX2;
+    if (IS_ALIGNED(width, 32)) {
+      InterpolateRow = InterpolateRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_INTERPOLATEROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    InterpolateRow = InterpolateRow_Any_NEON;
+    if (IS_ALIGNED(width, 16)) {
+      InterpolateRow = InterpolateRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_INTERPOLATEROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    InterpolateRow = InterpolateRow_Any_MSA;
+    if (IS_ALIGNED(width, 32)) {
+      InterpolateRow = InterpolateRow_MSA;
+    }
+  }
+#endif
+#if defined(HAS_INTERPOLATEROW_LSX)
+  if (TestCpuFlag(kCpuHasLSX)) {
+    InterpolateRow = InterpolateRow_Any_LSX;
+    if (IS_ALIGNED(width, 32)) {
+      InterpolateRow = InterpolateRow_LSX;
+    }
+  }
+#endif
+
+  if (dst_y) {
+    CopyPlane(src_y, src_stride_y, dst_y, dst_stride_y, halfwidth, height);
+  }
+  {
+    // Allocate 2 rows of vu.
+    int awidth = halfwidth * 2;
+    align_buffer_64(row_vu_0, awidth * 2);
+    uint8_t* row_vu_1 = row_vu_0 + awidth;
+
+    for (y = 0; y < height - 1; y += 2) {
+      MergeUVRow(src_v, src_u, row_vu_0, halfwidth);
+      MergeUVRow(src_v + src_stride_v, src_u + src_stride_u, row_vu_1,
+                 halfwidth);
+      InterpolateRow(dst_vu, row_vu_0, awidth, awidth, 128);
+      src_u += src_stride_u * 2;
+      src_v += src_stride_v * 2;
+      dst_vu += dst_stride_vu;
+    }
+    if (height & 1) {
+      MergeUVRow(src_v, src_u, dst_vu, halfwidth);
+    }
+    free_aligned_buffer_64(row_vu_0);
+  }
+  return 0;
+}
+#endif  // I422TONV21_ROW_VERSION
+
+// 444 chroma is 1x width, 1x height
+// 420 chroma is 1/2 width, 1/2 height
+LIBYUV_API
+int I444ToI420(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_u,
+               int dst_stride_u,
+               uint8_t* dst_v,
+               int dst_stride_v,
+               int width,
+               int height) {
+  return I4xxToI420(src_y, src_stride_y, src_u, src_stride_u, src_v,
+                    src_stride_v, dst_y, dst_stride_y, dst_u, dst_stride_u,
+                    dst_v, dst_stride_v, width, height, width, height);
+}
+
+LIBYUV_API
+int I444ToNV12(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_uv,
+               int dst_stride_uv,
+               int width,
+               int height) {
+  if (!src_y || !src_u || !src_v || !dst_uv || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    src_y = src_y + (height - 1) * src_stride_y;
+    src_u = src_u + (height - 1) * src_stride_u;
+    src_v = src_v + (height - 1) * src_stride_v;
+    src_stride_y = -src_stride_y;
+    src_stride_u = -src_stride_u;
+    src_stride_v = -src_stride_v;
+  }
+  if (dst_y) {
+    CopyPlane(src_y, src_stride_y, dst_y, dst_stride_y, width, height);
+  }
+  HalfMergeUVPlane(src_u, src_stride_u, src_v, src_stride_v, dst_uv,
+                   dst_stride_uv, width, height);
+  return 0;
+}
+
+LIBYUV_API
+int I444ToNV21(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_vu,
+               int dst_stride_vu,
+               int width,
+               int height) {
+  return I444ToNV12(src_y, src_stride_y, src_v, src_stride_v, src_u,
+                    src_stride_u, dst_y, dst_stride_y, dst_vu, dst_stride_vu,
+                    width, height);
+}
+
+// I400 is greyscale typically used in MJPG
+LIBYUV_API
+int I400ToI420(const uint8_t* src_y,
+               int src_stride_y,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_u,
+               int dst_stride_u,
+               uint8_t* dst_v,
+               int dst_stride_v,
+               int width,
+               int height) {
+  int halfwidth = (width + 1) >> 1;
+  int halfheight = (height + 1) >> 1;
+  if (!dst_u || !dst_v || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    halfheight = (height + 1) >> 1;
+    src_y = src_y + (height - 1) * src_stride_y;
+    src_stride_y = -src_stride_y;
+  }
+  if (dst_y) {
+    CopyPlane(src_y, src_stride_y, dst_y, dst_stride_y, width, height);
+  }
+  SetPlane(dst_u, dst_stride_u, halfwidth, halfheight, 128);
+  SetPlane(dst_v, dst_stride_v, halfwidth, halfheight, 128);
+  return 0;
+}
+
+// I400 is greyscale typically used in MJPG
+LIBYUV_API
+int I400ToNV21(const uint8_t* src_y,
+               int src_stride_y,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_vu,
+               int dst_stride_vu,
+               int width,
+               int height) {
+  int halfwidth = (width + 1) >> 1;
+  int halfheight = (height + 1) >> 1;
+  if (!dst_vu || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    halfheight = (height + 1) >> 1;
+    src_y = src_y + (height - 1) * src_stride_y;
+    src_stride_y = -src_stride_y;
+  }
+  if (dst_y) {
+    CopyPlane(src_y, src_stride_y, dst_y, dst_stride_y, width, height);
+  }
+  SetPlane(dst_vu, dst_stride_vu, halfwidth * 2, halfheight, 128);
+  return 0;
+}
+
+// Convert NV12 to I420.
+// TODO(fbarchard): Consider inverting destination. Faster on ARM with prfm.
+LIBYUV_API
+int NV12ToI420(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_uv,
+               int src_stride_uv,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_u,
+               int dst_stride_u,
+               uint8_t* dst_v,
+               int dst_stride_v,
+               int width,
+               int height) {
+  int halfwidth = (width + 1) >> 1;
+  int halfheight = (height + 1) >> 1;
+  if (!src_uv || !dst_u || !dst_v || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    halfheight = (height + 1) >> 1;
+    src_y = src_y + (height - 1) * src_stride_y;
+    src_uv = src_uv + (halfheight - 1) * src_stride_uv;
+    src_stride_y = -src_stride_y;
+    src_stride_uv = -src_stride_uv;
+  }
+  // Coalesce rows.
+  if (src_stride_y == width && dst_stride_y == width) {
+    width *= height;
+    height = 1;
+    src_stride_y = dst_stride_y = 0;
+  }
+  // Coalesce rows.
+  if (src_stride_uv == halfwidth * 2 && dst_stride_u == halfwidth &&
+      dst_stride_v == halfwidth) {
+    halfwidth *= halfheight;
+    halfheight = 1;
+    src_stride_uv = dst_stride_u = dst_stride_v = 0;
+  }
+
+  if (dst_y) {
+    CopyPlane(src_y, src_stride_y, dst_y, dst_stride_y, width, height);
+  }
+
+  // Split UV plane - NV12 / NV21
+  SplitUVPlane(src_uv, src_stride_uv, dst_u, dst_stride_u, dst_v, dst_stride_v,
+               halfwidth, halfheight);
+
+  return 0;
+}
+
+// Convert NV21 to I420.  Same as NV12 but u and v pointers swapped.
+LIBYUV_API
+int NV21ToI420(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_vu,
+               int src_stride_vu,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_u,
+               int dst_stride_u,
+               uint8_t* dst_v,
+               int dst_stride_v,
+               int width,
+               int height) {
+  return NV12ToI420(src_y, src_stride_y, src_vu, src_stride_vu, dst_y,
+                    dst_stride_y, dst_v, dst_stride_v, dst_u, dst_stride_u,
+                    width, height);
+}
+
+LIBYUV_API
+int NV12ToNV24(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_uv,
+               int src_stride_uv,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_uv,
+               int dst_stride_uv,
+               int width,
+               int height) {
+  if (width <= 0 || height == 0) {
+    return -1;
+  }
+
+  if (dst_y) {
+    ScalePlane(src_y, src_stride_y, width, height, dst_y, dst_stride_y,
+               Abs(width), Abs(height), kFilterBilinear);
+  }
+  UVScale(src_uv, src_stride_uv, SUBSAMPLE(width, 1, 1),
+          SUBSAMPLE(height, 1, 1), dst_uv, dst_stride_uv, Abs(width),
+          Abs(height), kFilterBilinear);
+  return 0;
+}
+
+LIBYUV_API
+int NV16ToNV24(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_uv,
+               int src_stride_uv,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_uv,
+               int dst_stride_uv,
+               int width,
+               int height) {
+  if (width <= 0 || height == 0) {
+    return -1;
+  }
+
+  if (dst_y) {
+    ScalePlane(src_y, src_stride_y, width, height, dst_y, dst_stride_y,
+               Abs(width), Abs(height), kFilterBilinear);
+  }
+  UVScale(src_uv, src_stride_uv, SUBSAMPLE(width, 1, 1), height, dst_uv,
+          dst_stride_uv, Abs(width), Abs(height), kFilterBilinear);
+  return 0;
+}
+
+LIBYUV_API
+int P010ToP410(const uint16_t* src_y,
+               int src_stride_y,
+               const uint16_t* src_uv,
+               int src_stride_uv,
+               uint16_t* dst_y,
+               int dst_stride_y,
+               uint16_t* dst_uv,
+               int dst_stride_uv,
+               int width,
+               int height) {
+  if (width <= 0 || height == 0) {
+    return -1;
+  }
+
+  if (dst_y) {
+    ScalePlane_16(src_y, src_stride_y, width, height, dst_y, dst_stride_y,
+                  Abs(width), Abs(height), kFilterBilinear);
+  }
+  UVScale_16(src_uv, src_stride_uv, SUBSAMPLE(width, 1, 1),
+             SUBSAMPLE(height, 1, 1), dst_uv, dst_stride_uv, Abs(width),
+             Abs(height), kFilterBilinear);
+  return 0;
+}
+
+LIBYUV_API
+int P210ToP410(const uint16_t* src_y,
+               int src_stride_y,
+               const uint16_t* src_uv,
+               int src_stride_uv,
+               uint16_t* dst_y,
+               int dst_stride_y,
+               uint16_t* dst_uv,
+               int dst_stride_uv,
+               int width,
+               int height) {
+  if (width <= 0 || height == 0) {
+    return -1;
+  }
+
+  if (dst_y) {
+    ScalePlane_16(src_y, src_stride_y, width, height, dst_y, dst_stride_y,
+                  Abs(width), Abs(height), kFilterBilinear);
+  }
+  UVScale_16(src_uv, src_stride_uv, SUBSAMPLE(width, 1, 1), height, dst_uv,
+             dst_stride_uv, Abs(width), Abs(height), kFilterBilinear);
+  return 0;
+}
+
+// Convert YUY2 to I420.
+LIBYUV_API
+int YUY2ToI420(const uint8_t* src_yuy2,
+               int src_stride_yuy2,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_u,
+               int dst_stride_u,
+               uint8_t* dst_v,
+               int dst_stride_v,
+               int width,
+               int height) {
+  int y;
+  void (*YUY2ToUVRow)(const uint8_t* src_yuy2, int src_stride_yuy2,
+                      uint8_t* dst_u, uint8_t* dst_v, int width) =
+      YUY2ToUVRow_C;
+  void (*YUY2ToYRow)(const uint8_t* src_yuy2, uint8_t* dst_y, int width) =
+      YUY2ToYRow_C;
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    src_yuy2 = src_yuy2 + (height - 1) * src_stride_yuy2;
+    src_stride_yuy2 = -src_stride_yuy2;
+  }
+#if defined(HAS_YUY2TOYROW_SSE2)
+  if (TestCpuFlag(kCpuHasSSE2)) {
+    YUY2ToUVRow = YUY2ToUVRow_Any_SSE2;
+    YUY2ToYRow = YUY2ToYRow_Any_SSE2;
+    if (IS_ALIGNED(width, 16)) {
+      YUY2ToUVRow = YUY2ToUVRow_SSE2;
+      YUY2ToYRow = YUY2ToYRow_SSE2;
+    }
+  }
+#endif
+#if defined(HAS_YUY2TOYROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    YUY2ToUVRow = YUY2ToUVRow_Any_AVX2;
+    YUY2ToYRow = YUY2ToYRow_Any_AVX2;
+    if (IS_ALIGNED(width, 32)) {
+      YUY2ToUVRow = YUY2ToUVRow_AVX2;
+      YUY2ToYRow = YUY2ToYRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_YUY2TOYROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    YUY2ToYRow = YUY2ToYRow_Any_NEON;
+    YUY2ToUVRow = YUY2ToUVRow_Any_NEON;
+    if (IS_ALIGNED(width, 16)) {
+      YUY2ToYRow = YUY2ToYRow_NEON;
+      YUY2ToUVRow = YUY2ToUVRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_YUY2TOYROW_MSA) && defined(HAS_YUY2TOUVROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    YUY2ToYRow = YUY2ToYRow_Any_MSA;
+    YUY2ToUVRow = YUY2ToUVRow_Any_MSA;
+    if (IS_ALIGNED(width, 32)) {
+      YUY2ToYRow = YUY2ToYRow_MSA;
+      YUY2ToUVRow = YUY2ToUVRow_MSA;
+    }
+  }
+#endif
+#if defined(HAS_YUY2TOYROW_LASX) && defined(HAS_YUY2TOUVROW_LASX)
+  if (TestCpuFlag(kCpuHasLASX)) {
+    YUY2ToYRow = YUY2ToYRow_Any_LASX;
+    YUY2ToUVRow = YUY2ToUVRow_Any_LASX;
+    if (IS_ALIGNED(width, 32)) {
+      YUY2ToYRow = YUY2ToYRow_LASX;
+      YUY2ToUVRow = YUY2ToUVRow_LASX;
+    }
+  }
+#endif
+
+  for (y = 0; y < height - 1; y += 2) {
+    YUY2ToUVRow(src_yuy2, src_stride_yuy2, dst_u, dst_v, width);
+    YUY2ToYRow(src_yuy2, dst_y, width);
+    YUY2ToYRow(src_yuy2 + src_stride_yuy2, dst_y + dst_stride_y, width);
+    src_yuy2 += src_stride_yuy2 * 2;
+    dst_y += dst_stride_y * 2;
+    dst_u += dst_stride_u;
+    dst_v += dst_stride_v;
+  }
+  if (height & 1) {
+    YUY2ToUVRow(src_yuy2, 0, dst_u, dst_v, width);
+    YUY2ToYRow(src_yuy2, dst_y, width);
+  }
+  return 0;
+}
+
+// Convert UYVY to I420.
+LIBYUV_API
+int UYVYToI420(const uint8_t* src_uyvy,
+               int src_stride_uyvy,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_u,
+               int dst_stride_u,
+               uint8_t* dst_v,
+               int dst_stride_v,
+               int width,
+               int height) {
+  int y;
+  void (*UYVYToUVRow)(const uint8_t* src_uyvy, int src_stride_uyvy,
+                      uint8_t* dst_u, uint8_t* dst_v, int width) =
+      UYVYToUVRow_C;
+  void (*UYVYToYRow)(const uint8_t* src_uyvy, uint8_t* dst_y, int width) =
+      UYVYToYRow_C;
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    src_uyvy = src_uyvy + (height - 1) * src_stride_uyvy;
+    src_stride_uyvy = -src_stride_uyvy;
+  }
+#if defined(HAS_UYVYTOYROW_SSE2)
+  if (TestCpuFlag(kCpuHasSSE2)) {
+    UYVYToUVRow = UYVYToUVRow_Any_SSE2;
+    UYVYToYRow = UYVYToYRow_Any_SSE2;
+    if (IS_ALIGNED(width, 16)) {
+      UYVYToUVRow = UYVYToUVRow_SSE2;
+      UYVYToYRow = UYVYToYRow_SSE2;
+    }
+  }
+#endif
+#if defined(HAS_UYVYTOYROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    UYVYToUVRow = UYVYToUVRow_Any_AVX2;
+    UYVYToYRow = UYVYToYRow_Any_AVX2;
+    if (IS_ALIGNED(width, 32)) {
+      UYVYToUVRow = UYVYToUVRow_AVX2;
+      UYVYToYRow = UYVYToYRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_UYVYTOYROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    UYVYToYRow = UYVYToYRow_Any_NEON;
+    UYVYToUVRow = UYVYToUVRow_Any_NEON;
+    if (IS_ALIGNED(width, 16)) {
+      UYVYToYRow = UYVYToYRow_NEON;
+      UYVYToUVRow = UYVYToUVRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_UYVYTOYROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    UYVYToYRow = UYVYToYRow_Any_MSA;
+    UYVYToUVRow = UYVYToUVRow_Any_MSA;
+    if (IS_ALIGNED(width, 32)) {
+      UYVYToYRow = UYVYToYRow_MSA;
+      UYVYToUVRow = UYVYToUVRow_MSA;
+    }
+  }
+#endif
+#if defined(HAS_UYVYTOYROW_LASX)
+  if (TestCpuFlag(kCpuHasLASX)) {
+    UYVYToYRow = UYVYToYRow_Any_LASX;
+    UYVYToUVRow = UYVYToUVRow_Any_LASX;
+    if (IS_ALIGNED(width, 32)) {
+      UYVYToYRow = UYVYToYRow_LASX;
+      UYVYToUVRow = UYVYToUVRow_LASX;
+    }
+  }
+#endif
+
+  for (y = 0; y < height - 1; y += 2) {
+    UYVYToUVRow(src_uyvy, src_stride_uyvy, dst_u, dst_v, width);
+    UYVYToYRow(src_uyvy, dst_y, width);
+    UYVYToYRow(src_uyvy + src_stride_uyvy, dst_y + dst_stride_y, width);
+    src_uyvy += src_stride_uyvy * 2;
+    dst_y += dst_stride_y * 2;
+    dst_u += dst_stride_u;
+    dst_v += dst_stride_v;
+  }
+  if (height & 1) {
+    UYVYToUVRow(src_uyvy, 0, dst_u, dst_v, width);
+    UYVYToYRow(src_uyvy, dst_y, width);
+  }
+  return 0;
+}
+
+// Convert AYUV to NV12.
+LIBYUV_API
+int AYUVToNV12(const uint8_t* src_ayuv,
+               int src_stride_ayuv,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_uv,
+               int dst_stride_uv,
+               int width,
+               int height) {
+  int y;
+  void (*AYUVToUVRow)(const uint8_t* src_ayuv, int src_stride_ayuv,
+                      uint8_t* dst_uv, int width) = AYUVToUVRow_C;
+  void (*AYUVToYRow)(const uint8_t* src_ayuv, uint8_t* dst_y, int width) =
+      AYUVToYRow_C;
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    src_ayuv = src_ayuv + (height - 1) * src_stride_ayuv;
+    src_stride_ayuv = -src_stride_ayuv;
+  }
+// place holders for future intel code
+#if defined(HAS_AYUVTOYROW_SSE2)
+  if (TestCpuFlag(kCpuHasSSE2)) {
+    AYUVToUVRow = AYUVToUVRow_Any_SSE2;
+    AYUVToYRow = AYUVToYRow_Any_SSE2;
+    if (IS_ALIGNED(width, 16)) {
+      AYUVToUVRow = AYUVToUVRow_SSE2;
+      AYUVToYRow = AYUVToYRow_SSE2;
+    }
+  }
+#endif
+#if defined(HAS_AYUVTOYROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    AYUVToUVRow = AYUVToUVRow_Any_AVX2;
+    AYUVToYRow = AYUVToYRow_Any_AVX2;
+    if (IS_ALIGNED(width, 32)) {
+      AYUVToUVRow = AYUVToUVRow_AVX2;
+      AYUVToYRow = AYUVToYRow_AVX2;
+    }
+  }
+#endif
+
+#if defined(HAS_AYUVTOYROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    AYUVToYRow = AYUVToYRow_Any_NEON;
+    AYUVToUVRow = AYUVToUVRow_Any_NEON;
+    if (IS_ALIGNED(width, 16)) {
+      AYUVToYRow = AYUVToYRow_NEON;
+      AYUVToUVRow = AYUVToUVRow_NEON;
+    }
+  }
+#endif
+
+  for (y = 0; y < height - 1; y += 2) {
+    AYUVToUVRow(src_ayuv, src_stride_ayuv, dst_uv, width);
+    AYUVToYRow(src_ayuv, dst_y, width);
+    AYUVToYRow(src_ayuv + src_stride_ayuv, dst_y + dst_stride_y, width);
+    src_ayuv += src_stride_ayuv * 2;
+    dst_y += dst_stride_y * 2;
+    dst_uv += dst_stride_uv;
+  }
+  if (height & 1) {
+    AYUVToUVRow(src_ayuv, 0, dst_uv, width);
+    AYUVToYRow(src_ayuv, dst_y, width);
+  }
+  return 0;
+}
+
+// Convert AYUV to NV21.
+LIBYUV_API
+int AYUVToNV21(const uint8_t* src_ayuv,
+               int src_stride_ayuv,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_vu,
+               int dst_stride_vu,
+               int width,
+               int height) {
+  int y;
+  void (*AYUVToVURow)(const uint8_t* src_ayuv, int src_stride_ayuv,
+                      uint8_t* dst_vu, int width) = AYUVToVURow_C;
+  void (*AYUVToYRow)(const uint8_t* src_ayuv, uint8_t* dst_y, int width) =
+      AYUVToYRow_C;
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    src_ayuv = src_ayuv + (height - 1) * src_stride_ayuv;
+    src_stride_ayuv = -src_stride_ayuv;
+  }
+// place holders for future intel code
+#if defined(HAS_AYUVTOYROW_SSE2)
+  if (TestCpuFlag(kCpuHasSSE2)) {
+    AYUVToVURow = AYUVToVURow_Any_SSE2;
+    AYUVToYRow = AYUVToYRow_Any_SSE2;
+    if (IS_ALIGNED(width, 16)) {
+      AYUVToVURow = AYUVToVURow_SSE2;
+      AYUVToYRow = AYUVToYRow_SSE2;
+    }
+  }
+#endif
+#if defined(HAS_AYUVTOYROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    AYUVToVURow = AYUVToVURow_Any_AVX2;
+    AYUVToYRow = AYUVToYRow_Any_AVX2;
+    if (IS_ALIGNED(width, 32)) {
+      AYUVToVURow = AYUVToVURow_AVX2;
+      AYUVToYRow = AYUVToYRow_AVX2;
+    }
+  }
+#endif
+
+#if defined(HAS_AYUVTOYROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    AYUVToYRow = AYUVToYRow_Any_NEON;
+    AYUVToVURow = AYUVToVURow_Any_NEON;
+    if (IS_ALIGNED(width, 16)) {
+      AYUVToYRow = AYUVToYRow_NEON;
+      AYUVToVURow = AYUVToVURow_NEON;
+    }
+  }
+#endif
+
+  for (y = 0; y < height - 1; y += 2) {
+    AYUVToVURow(src_ayuv, src_stride_ayuv, dst_vu, width);
+    AYUVToYRow(src_ayuv, dst_y, width);
+    AYUVToYRow(src_ayuv + src_stride_ayuv, dst_y + dst_stride_y, width);
+    src_ayuv += src_stride_ayuv * 2;
+    dst_y += dst_stride_y * 2;
+    dst_vu += dst_stride_vu;
+  }
+  if (height & 1) {
+    AYUVToVURow(src_ayuv, 0, dst_vu, width);
+    AYUVToYRow(src_ayuv, dst_y, width);
+  }
+  return 0;
+}
+
+// Convert ARGB to I420.
+LIBYUV_API
+int ARGBToI420(const uint8_t* src_argb,
+               int src_stride_argb,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_u,
+               int dst_stride_u,
+               uint8_t* dst_v,
+               int dst_stride_v,
+               int width,
+               int height) {
+  int y;
+  void (*ARGBToUVRow)(const uint8_t* src_argb0, int src_stride_argb,
+                      uint8_t* dst_u, uint8_t* dst_v, int width) =
+      ARGBToUVRow_C;
+  void (*ARGBToYRow)(const uint8_t* src_argb, uint8_t* dst_y, int width) =
+      ARGBToYRow_C;
+  if (!src_argb || !dst_y || !dst_u || !dst_v || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    src_argb = src_argb + (height - 1) * src_stride_argb;
+    src_stride_argb = -src_stride_argb;
+  }
+#if defined(HAS_ARGBTOYROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    ARGBToYRow = ARGBToYRow_Any_NEON;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBToYRow = ARGBToYRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOUVROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    ARGBToUVRow = ARGBToUVRow_Any_NEON;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBToUVRow = ARGBToUVRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOYROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    ARGBToYRow = ARGBToYRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBToYRow = ARGBToYRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOUVROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    ARGBToUVRow = ARGBToUVRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBToUVRow = ARGBToUVRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOYROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ARGBToYRow = ARGBToYRow_Any_AVX2;
+    if (IS_ALIGNED(width, 32)) {
+      ARGBToYRow = ARGBToYRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOUVROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ARGBToUVRow = ARGBToUVRow_Any_AVX2;
+    if (IS_ALIGNED(width, 32)) {
+      ARGBToUVRow = ARGBToUVRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOYROW_MSA) && defined(HAS_ARGBTOUVROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    ARGBToYRow = ARGBToYRow_Any_MSA;
+    ARGBToUVRow = ARGBToUVRow_Any_MSA;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBToYRow = ARGBToYRow_MSA;
+    }
+    if (IS_ALIGNED(width, 32)) {
+      ARGBToUVRow = ARGBToUVRow_MSA;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOYROW_LASX) && defined(HAS_ARGBTOUVROW_LASX)
+  if (TestCpuFlag(kCpuHasLASX)) {
+    ARGBToYRow = ARGBToYRow_Any_LASX;
+    ARGBToUVRow = ARGBToUVRow_Any_LASX;
+    if (IS_ALIGNED(width, 32)) {
+      ARGBToYRow = ARGBToYRow_LASX;
+      ARGBToUVRow = ARGBToUVRow_LASX;
+    }
+  }
+#endif
+
+  for (y = 0; y < height - 1; y += 2) {
+    ARGBToUVRow(src_argb, src_stride_argb, dst_u, dst_v, width);
+    ARGBToYRow(src_argb, dst_y, width);
+    ARGBToYRow(src_argb + src_stride_argb, dst_y + dst_stride_y, width);
+    src_argb += src_stride_argb * 2;
+    dst_y += dst_stride_y * 2;
+    dst_u += dst_stride_u;
+    dst_v += dst_stride_v;
+  }
+  if (height & 1) {
+    ARGBToUVRow(src_argb, 0, dst_u, dst_v, width);
+    ARGBToYRow(src_argb, dst_y, width);
+  }
+  return 0;
+}
+
+// Convert BGRA to I420.
+LIBYUV_API
+int BGRAToI420(const uint8_t* src_bgra,
+               int src_stride_bgra,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_u,
+               int dst_stride_u,
+               uint8_t* dst_v,
+               int dst_stride_v,
+               int width,
+               int height) {
+  int y;
+  void (*BGRAToUVRow)(const uint8_t* src_bgra0, int src_stride_bgra,
+                      uint8_t* dst_u, uint8_t* dst_v, int width) =
+      BGRAToUVRow_C;
+  void (*BGRAToYRow)(const uint8_t* src_bgra, uint8_t* dst_y, int width) =
+      BGRAToYRow_C;
+  if (!src_bgra || !dst_y || !dst_u || !dst_v || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    src_bgra = src_bgra + (height - 1) * src_stride_bgra;
+    src_stride_bgra = -src_stride_bgra;
+  }
+#if defined(HAS_BGRATOYROW_SSSE3) && defined(HAS_BGRATOUVROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    BGRAToUVRow = BGRAToUVRow_Any_SSSE3;
+    BGRAToYRow = BGRAToYRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 16)) {
+      BGRAToUVRow = BGRAToUVRow_SSSE3;
+      BGRAToYRow = BGRAToYRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_BGRATOYROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    BGRAToYRow = BGRAToYRow_Any_NEON;
+    if (IS_ALIGNED(width, 8)) {
+      BGRAToYRow = BGRAToYRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_BGRATOUVROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    BGRAToUVRow = BGRAToUVRow_Any_NEON;
+    if (IS_ALIGNED(width, 16)) {
+      BGRAToUVRow = BGRAToUVRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_BGRATOYROW_MSA) && defined(HAS_BGRATOUVROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    BGRAToYRow = BGRAToYRow_Any_MSA;
+    BGRAToUVRow = BGRAToUVRow_Any_MSA;
+    if (IS_ALIGNED(width, 16)) {
+      BGRAToYRow = BGRAToYRow_MSA;
+      BGRAToUVRow = BGRAToUVRow_MSA;
+    }
+  }
+#endif
+#if defined(HAS_BGRATOYROW_LSX) && defined(HAS_BGRATOUVROW_LSX)
+  if (TestCpuFlag(kCpuHasLSX)) {
+    BGRAToYRow = BGRAToYRow_Any_LSX;
+    BGRAToUVRow = BGRAToUVRow_Any_LSX;
+    if (IS_ALIGNED(width, 16)) {
+      BGRAToYRow = BGRAToYRow_LSX;
+      BGRAToUVRow = BGRAToUVRow_LSX;
+    }
+  }
+#endif
+
+  for (y = 0; y < height - 1; y += 2) {
+    BGRAToUVRow(src_bgra, src_stride_bgra, dst_u, dst_v, width);
+    BGRAToYRow(src_bgra, dst_y, width);
+    BGRAToYRow(src_bgra + src_stride_bgra, dst_y + dst_stride_y, width);
+    src_bgra += src_stride_bgra * 2;
+    dst_y += dst_stride_y * 2;
+    dst_u += dst_stride_u;
+    dst_v += dst_stride_v;
+  }
+  if (height & 1) {
+    BGRAToUVRow(src_bgra, 0, dst_u, dst_v, width);
+    BGRAToYRow(src_bgra, dst_y, width);
+  }
+  return 0;
+}
+
+// Convert ABGR to I420.
+LIBYUV_API
+int ABGRToI420(const uint8_t* src_abgr,
+               int src_stride_abgr,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_u,
+               int dst_stride_u,
+               uint8_t* dst_v,
+               int dst_stride_v,
+               int width,
+               int height) {
+  int y;
+  void (*ABGRToUVRow)(const uint8_t* src_abgr0, int src_stride_abgr,
+                      uint8_t* dst_u, uint8_t* dst_v, int width) =
+      ABGRToUVRow_C;
+  void (*ABGRToYRow)(const uint8_t* src_abgr, uint8_t* dst_y, int width) =
+      ABGRToYRow_C;
+  if (!src_abgr || !dst_y || !dst_u || !dst_v || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    src_abgr = src_abgr + (height - 1) * src_stride_abgr;
+    src_stride_abgr = -src_stride_abgr;
+  }
+#if defined(HAS_ABGRTOYROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    ABGRToYRow = ABGRToYRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 16)) {
+      ABGRToYRow = ABGRToYRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_ABGRTOUVROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    ABGRToUVRow = ABGRToUVRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 16)) {
+      ABGRToUVRow = ABGRToUVRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_ABGRTOYROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ABGRToYRow = ABGRToYRow_Any_AVX2;
+    if (IS_ALIGNED(width, 32)) {
+      ABGRToYRow = ABGRToYRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_ABGRTOUVROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ABGRToUVRow = ABGRToUVRow_Any_AVX2;
+    if (IS_ALIGNED(width, 32)) {
+      ABGRToUVRow = ABGRToUVRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_ABGRTOYROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    ABGRToYRow = ABGRToYRow_Any_NEON;
+    if (IS_ALIGNED(width, 16)) {
+      ABGRToYRow = ABGRToYRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_ABGRTOUVROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    ABGRToUVRow = ABGRToUVRow_Any_NEON;
+    if (IS_ALIGNED(width, 16)) {
+      ABGRToUVRow = ABGRToUVRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_ABGRTOYROW_MSA) && defined(HAS_ABGRTOUVROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    ABGRToYRow = ABGRToYRow_Any_MSA;
+    ABGRToUVRow = ABGRToUVRow_Any_MSA;
+    if (IS_ALIGNED(width, 16)) {
+      ABGRToYRow = ABGRToYRow_MSA;
+      ABGRToUVRow = ABGRToUVRow_MSA;
+    }
+  }
+#endif
+#if defined(HAS_ABGRTOYROW_LSX) && defined(HAS_ABGRTOUVROW_LSX)
+  if (TestCpuFlag(kCpuHasLSX)) {
+    ABGRToYRow = ABGRToYRow_Any_LSX;
+    ABGRToUVRow = ABGRToUVRow_Any_LSX;
+    if (IS_ALIGNED(width, 16)) {
+      ABGRToYRow = ABGRToYRow_LSX;
+      ABGRToUVRow = ABGRToUVRow_LSX;
+    }
+  }
+#endif
+
+  for (y = 0; y < height - 1; y += 2) {
+    ABGRToUVRow(src_abgr, src_stride_abgr, dst_u, dst_v, width);
+    ABGRToYRow(src_abgr, dst_y, width);
+    ABGRToYRow(src_abgr + src_stride_abgr, dst_y + dst_stride_y, width);
+    src_abgr += src_stride_abgr * 2;
+    dst_y += dst_stride_y * 2;
+    dst_u += dst_stride_u;
+    dst_v += dst_stride_v;
+  }
+  if (height & 1) {
+    ABGRToUVRow(src_abgr, 0, dst_u, dst_v, width);
+    ABGRToYRow(src_abgr, dst_y, width);
+  }
+  return 0;
+}
+
+// Convert RGBA to I420.
+LIBYUV_API
+int RGBAToI420(const uint8_t* src_rgba,
+               int src_stride_rgba,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_u,
+               int dst_stride_u,
+               uint8_t* dst_v,
+               int dst_stride_v,
+               int width,
+               int height) {
+  int y;
+  void (*RGBAToUVRow)(const uint8_t* src_rgba0, int src_stride_rgba,
+                      uint8_t* dst_u, uint8_t* dst_v, int width) =
+      RGBAToUVRow_C;
+  void (*RGBAToYRow)(const uint8_t* src_rgba, uint8_t* dst_y, int width) =
+      RGBAToYRow_C;
+  if (!src_rgba || !dst_y || !dst_u || !dst_v || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    src_rgba = src_rgba + (height - 1) * src_stride_rgba;
+    src_stride_rgba = -src_stride_rgba;
+  }
+#if defined(HAS_RGBATOYROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    RGBAToYRow = RGBAToYRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 16)) {
+      RGBAToYRow = RGBAToYRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_RGBATOUVROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    RGBAToUVRow = RGBAToUVRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 16)) {
+      RGBAToUVRow = RGBAToUVRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_RGBATOYROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    RGBAToYRow = RGBAToYRow_Any_NEON;
+    if (IS_ALIGNED(width, 16)) {
+      RGBAToYRow = RGBAToYRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_RGBATOUVROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    RGBAToUVRow = RGBAToUVRow_Any_NEON;
+    if (IS_ALIGNED(width, 16)) {
+      RGBAToUVRow = RGBAToUVRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_RGBATOYROW_MSA) && defined(HAS_RGBATOUVROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    RGBAToYRow = RGBAToYRow_Any_MSA;
+    RGBAToUVRow = RGBAToUVRow_Any_MSA;
+    if (IS_ALIGNED(width, 16)) {
+      RGBAToYRow = RGBAToYRow_MSA;
+      RGBAToUVRow = RGBAToUVRow_MSA;
+    }
+  }
+#endif
+#if defined(HAS_RGBATOYROW_LSX) && defined(HAS_RGBATOUVROW_LSX)
+  if (TestCpuFlag(kCpuHasLSX)) {
+    RGBAToYRow = RGBAToYRow_Any_LSX;
+    RGBAToUVRow = RGBAToUVRow_Any_LSX;
+    if (IS_ALIGNED(width, 16)) {
+      RGBAToYRow = RGBAToYRow_LSX;
+      RGBAToUVRow = RGBAToUVRow_LSX;
+    }
+  }
+#endif
+
+  for (y = 0; y < height - 1; y += 2) {
+    RGBAToUVRow(src_rgba, src_stride_rgba, dst_u, dst_v, width);
+    RGBAToYRow(src_rgba, dst_y, width);
+    RGBAToYRow(src_rgba + src_stride_rgba, dst_y + dst_stride_y, width);
+    src_rgba += src_stride_rgba * 2;
+    dst_y += dst_stride_y * 2;
+    dst_u += dst_stride_u;
+    dst_v += dst_stride_v;
+  }
+  if (height & 1) {
+    RGBAToUVRow(src_rgba, 0, dst_u, dst_v, width);
+    RGBAToYRow(src_rgba, dst_y, width);
+  }
+  return 0;
+}
+
+// Enabled if 1 pass is available
+#if (defined(HAS_RGB24TOYROW_NEON) || defined(HAS_RGB24TOYROW_MSA) || \
+     defined(HAS_RGB24TOYROW_LSX))
+#define HAS_RGB24TOYROW
+#endif
+
+// Convert RGB24 to I420.
+LIBYUV_API
+int RGB24ToI420(const uint8_t* src_rgb24,
+                int src_stride_rgb24,
+                uint8_t* dst_y,
+                int dst_stride_y,
+                uint8_t* dst_u,
+                int dst_stride_u,
+                uint8_t* dst_v,
+                int dst_stride_v,
+                int width,
+                int height) {
+  int y;
+#if defined(HAS_RGB24TOYROW)
+  void (*RGB24ToUVRow)(const uint8_t* src_rgb24, int src_stride_rgb24,
+                       uint8_t* dst_u, uint8_t* dst_v, int width) =
+      RGB24ToUVRow_C;
+  void (*RGB24ToYRow)(const uint8_t* src_rgb24, uint8_t* dst_y, int width) =
+      RGB24ToYRow_C;
+#else
+  void (*RGB24ToARGBRow)(const uint8_t* src_rgb, uint8_t* dst_argb, int width) =
+      RGB24ToARGBRow_C;
+  void (*ARGBToUVRow)(const uint8_t* src_argb0, int src_stride_argb,
+                      uint8_t* dst_u, uint8_t* dst_v, int width) =
+      ARGBToUVRow_C;
+  void (*ARGBToYRow)(const uint8_t* src_argb, uint8_t* dst_y, int width) =
+      ARGBToYRow_C;
+#endif
+  if (!src_rgb24 || !dst_y || !dst_u || !dst_v || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    src_rgb24 = src_rgb24 + (height - 1) * src_stride_rgb24;
+    src_stride_rgb24 = -src_stride_rgb24;
+  }
+
+#if defined(HAS_RGB24TOYROW)
+
+// Neon version does direct RGB24 to YUV.
+#if defined(HAS_RGB24TOYROW_NEON) && defined(HAS_RGB24TOUVROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    RGB24ToUVRow = RGB24ToUVRow_Any_NEON;
+    RGB24ToYRow = RGB24ToYRow_Any_NEON;
+    if (IS_ALIGNED(width, 16)) {
+      RGB24ToYRow = RGB24ToYRow_NEON;
+      RGB24ToUVRow = RGB24ToUVRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_RGB24TOYROW_MSA) && defined(HAS_RGB24TOUVROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    RGB24ToUVRow = RGB24ToUVRow_Any_MSA;
+    RGB24ToYRow = RGB24ToYRow_Any_MSA;
+    if (IS_ALIGNED(width, 16)) {
+      RGB24ToYRow = RGB24ToYRow_MSA;
+      RGB24ToUVRow = RGB24ToUVRow_MSA;
+    }
+  }
+#endif
+#if defined(HAS_RGB24TOYROW_LSX) && defined(HAS_RGB24TOUVROW_LSX)
+  if (TestCpuFlag(kCpuHasLSX)) {
+    RGB24ToUVRow = RGB24ToUVRow_Any_LSX;
+    RGB24ToYRow = RGB24ToYRow_Any_LSX;
+    if (IS_ALIGNED(width, 16)) {
+      RGB24ToYRow = RGB24ToYRow_LSX;
+      RGB24ToUVRow = RGB24ToUVRow_LSX;
+    }
+  }
+#endif
+#if defined(HAS_RGB24TOYROW_LASX) && defined(HAS_RGB24TOUVROW_LASX)
+  if (TestCpuFlag(kCpuHasLASX)) {
+    RGB24ToUVRow = RGB24ToUVRow_Any_LASX;
+    RGB24ToYRow = RGB24ToYRow_Any_LASX;
+    if (IS_ALIGNED(width, 32)) {
+      RGB24ToYRow = RGB24ToYRow_LASX;
+      RGB24ToUVRow = RGB24ToUVRow_LASX;
+    }
+  }
+#endif
+
+// Other platforms do intermediate conversion from RGB24 to ARGB.
+#else  // HAS_RGB24TOYROW
+
+#if defined(HAS_RGB24TOARGBROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    RGB24ToARGBRow = RGB24ToARGBRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 16)) {
+      RGB24ToARGBRow = RGB24ToARGBRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOYROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    ARGBToYRow = ARGBToYRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBToYRow = ARGBToYRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOYROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ARGBToYRow = ARGBToYRow_Any_AVX2;
+    if (IS_ALIGNED(width, 32)) {
+      ARGBToYRow = ARGBToYRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOUVROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    ARGBToUVRow = ARGBToUVRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBToUVRow = ARGBToUVRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOUVROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ARGBToUVRow = ARGBToUVRow_Any_AVX2;
+    if (IS_ALIGNED(width, 32)) {
+      ARGBToUVRow = ARGBToUVRow_AVX2;
+    }
+  }
+#endif
+#endif  // HAS_RGB24TOYROW
+
+  {
+#if !defined(HAS_RGB24TOYROW)
+    // Allocate 2 rows of ARGB.
+    const int kRowSize = (width * 4 + 31) & ~31;
+    align_buffer_64(row, kRowSize * 2);
+#endif
+
+    for (y = 0; y < height - 1; y += 2) {
+#if defined(HAS_RGB24TOYROW)
+      RGB24ToUVRow(src_rgb24, src_stride_rgb24, dst_u, dst_v, width);
+      RGB24ToYRow(src_rgb24, dst_y, width);
+      RGB24ToYRow(src_rgb24 + src_stride_rgb24, dst_y + dst_stride_y, width);
+#else
+      RGB24ToARGBRow(src_rgb24, row, width);
+      RGB24ToARGBRow(src_rgb24 + src_stride_rgb24, row + kRowSize, width);
+      ARGBToUVRow(row, kRowSize, dst_u, dst_v, width);
+      ARGBToYRow(row, dst_y, width);
+      ARGBToYRow(row + kRowSize, dst_y + dst_stride_y, width);
+#endif
+      src_rgb24 += src_stride_rgb24 * 2;
+      dst_y += dst_stride_y * 2;
+      dst_u += dst_stride_u;
+      dst_v += dst_stride_v;
+    }
+    if (height & 1) {
+#if defined(HAS_RGB24TOYROW)
+      RGB24ToUVRow(src_rgb24, 0, dst_u, dst_v, width);
+      RGB24ToYRow(src_rgb24, dst_y, width);
+#else
+      RGB24ToARGBRow(src_rgb24, row, width);
+      ARGBToUVRow(row, 0, dst_u, dst_v, width);
+      ARGBToYRow(row, dst_y, width);
+#endif
+    }
+#if !defined(HAS_RGB24TOYROW)
+    free_aligned_buffer_64(row);
+#endif
+  }
+  return 0;
+}
+#undef HAS_RGB24TOYROW
+
+// Enabled if 1 pass is available
+#if defined(HAS_RGB24TOYJROW_NEON) || defined(HAS_RGB24TOYJROW_MSA)
+#define HAS_RGB24TOYJROW
+#endif
+
+// Convert RGB24 to J420.
+LIBYUV_API
+int RGB24ToJ420(const uint8_t* src_rgb24,
+                int src_stride_rgb24,
+                uint8_t* dst_y,
+                int dst_stride_y,
+                uint8_t* dst_u,
+                int dst_stride_u,
+                uint8_t* dst_v,
+                int dst_stride_v,
+                int width,
+                int height) {
+  int y;
+#if defined(HAS_RGB24TOYJROW)
+  void (*RGB24ToUVJRow)(const uint8_t* src_rgb24, int src_stride_rgb24,
+                        uint8_t* dst_u, uint8_t* dst_v, int width) =
+      RGB24ToUVJRow_C;
+  void (*RGB24ToYJRow)(const uint8_t* src_rgb24, uint8_t* dst_y, int width) =
+      RGB24ToYJRow_C;
+#else
+  void (*RGB24ToARGBRow)(const uint8_t* src_rgb, uint8_t* dst_argb, int width) =
+      RGB24ToARGBRow_C;
+  void (*ARGBToUVJRow)(const uint8_t* src_argb0, int src_stride_argb,
+                       uint8_t* dst_u, uint8_t* dst_v, int width) =
+      ARGBToUVJRow_C;
+  void (*ARGBToYJRow)(const uint8_t* src_argb, uint8_t* dst_y, int width) =
+      ARGBToYJRow_C;
+#endif
+  if (!src_rgb24 || !dst_y || !dst_u || !dst_v || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    src_rgb24 = src_rgb24 + (height - 1) * src_stride_rgb24;
+    src_stride_rgb24 = -src_stride_rgb24;
+  }
+
+#if defined(HAS_RGB24TOYJROW)
+
+// Neon version does direct RGB24 to YUV.
+#if defined(HAS_RGB24TOYJROW_NEON) && defined(HAS_RGB24TOUVJROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    RGB24ToUVJRow = RGB24ToUVJRow_Any_NEON;
+    RGB24ToYJRow = RGB24ToYJRow_Any_NEON;
+    if (IS_ALIGNED(width, 16)) {
+      RGB24ToYJRow = RGB24ToYJRow_NEON;
+      RGB24ToUVJRow = RGB24ToUVJRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_RGB24TOYJROW_MSA) && defined(HAS_RGB24TOUVJROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    RGB24ToUVJRow = RGB24ToUVJRow_Any_MSA;
+    RGB24ToYJRow = RGB24ToYJRow_Any_MSA;
+    if (IS_ALIGNED(width, 16)) {
+      RGB24ToYJRow = RGB24ToYJRow_MSA;
+      RGB24ToUVJRow = RGB24ToUVJRow_MSA;
+    }
+  }
+#endif
+
+// Other platforms do intermediate conversion from RGB24 to ARGB.
+#else  // HAS_RGB24TOYJROW
+
+#if defined(HAS_RGB24TOARGBROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    RGB24ToARGBRow = RGB24ToARGBRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 16)) {
+      RGB24ToARGBRow = RGB24ToARGBRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOYJROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    ARGBToYJRow = ARGBToYJRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBToYJRow = ARGBToYJRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOYJROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ARGBToYJRow = ARGBToYJRow_Any_AVX2;
+    if (IS_ALIGNED(width, 32)) {
+      ARGBToYJRow = ARGBToYJRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOUVJROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    ARGBToUVJRow = ARGBToUVJRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBToUVJRow = ARGBToUVJRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOUVJROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ARGBToUVJRow = ARGBToUVJRow_Any_AVX2;
+    if (IS_ALIGNED(width, 32)) {
+      ARGBToUVJRow = ARGBToUVJRow_AVX2;
+    }
+  }
+#endif
+#endif  // HAS_RGB24TOYJROW
+
+  {
+#if !defined(HAS_RGB24TOYJROW)
+    // Allocate 2 rows of ARGB.
+    const int kRowSize = (width * 4 + 31) & ~31;
+    align_buffer_64(row, kRowSize * 2);
+#endif
+
+    for (y = 0; y < height - 1; y += 2) {
+#if defined(HAS_RGB24TOYJROW)
+      RGB24ToUVJRow(src_rgb24, src_stride_rgb24, dst_u, dst_v, width);
+      RGB24ToYJRow(src_rgb24, dst_y, width);
+      RGB24ToYJRow(src_rgb24 + src_stride_rgb24, dst_y + dst_stride_y, width);
+#else
+      RGB24ToARGBRow(src_rgb24, row, width);
+      RGB24ToARGBRow(src_rgb24 + src_stride_rgb24, row + kRowSize, width);
+      ARGBToUVJRow(row, kRowSize, dst_u, dst_v, width);
+      ARGBToYJRow(row, dst_y, width);
+      ARGBToYJRow(row + kRowSize, dst_y + dst_stride_y, width);
+#endif
+      src_rgb24 += src_stride_rgb24 * 2;
+      dst_y += dst_stride_y * 2;
+      dst_u += dst_stride_u;
+      dst_v += dst_stride_v;
+    }
+    if (height & 1) {
+#if defined(HAS_RGB24TOYJROW)
+      RGB24ToUVJRow(src_rgb24, 0, dst_u, dst_v, width);
+      RGB24ToYJRow(src_rgb24, dst_y, width);
+#else
+      RGB24ToARGBRow(src_rgb24, row, width);
+      ARGBToUVJRow(row, 0, dst_u, dst_v, width);
+      ARGBToYJRow(row, dst_y, width);
+#endif
+    }
+#if !defined(HAS_RGB24TOYJROW)
+    free_aligned_buffer_64(row);
+#endif
+  }
+  return 0;
+}
+#undef HAS_RGB24TOYJROW
+
+// Enabled if 1 pass is available
+#if (defined(HAS_RAWTOYROW_NEON) || defined(HAS_RAWTOYROW_MSA) || \
+     defined(HAS_RAWTOYROW_LSX))
+#define HAS_RAWTOYROW
+#endif
+
+// Convert RAW to I420.
+LIBYUV_API
+int RAWToI420(const uint8_t* src_raw,
+              int src_stride_raw,
+              uint8_t* dst_y,
+              int dst_stride_y,
+              uint8_t* dst_u,
+              int dst_stride_u,
+              uint8_t* dst_v,
+              int dst_stride_v,
+              int width,
+              int height) {
+  int y;
+#if defined(HAS_RAWTOYROW)
+  void (*RAWToUVRow)(const uint8_t* src_raw, int src_stride_raw, uint8_t* dst_u,
+                     uint8_t* dst_v, int width) = RAWToUVRow_C;
+  void (*RAWToYRow)(const uint8_t* src_raw, uint8_t* dst_y, int width) =
+      RAWToYRow_C;
+#else
+  void (*RAWToARGBRow)(const uint8_t* src_rgb, uint8_t* dst_argb, int width) =
+      RAWToARGBRow_C;
+  void (*ARGBToUVRow)(const uint8_t* src_argb0, int src_stride_argb,
+                      uint8_t* dst_u, uint8_t* dst_v, int width) =
+      ARGBToUVRow_C;
+  void (*ARGBToYRow)(const uint8_t* src_argb, uint8_t* dst_y, int width) =
+      ARGBToYRow_C;
+#endif
+  if (!src_raw || !dst_y || !dst_u || !dst_v || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    src_raw = src_raw + (height - 1) * src_stride_raw;
+    src_stride_raw = -src_stride_raw;
+  }
+
+#if defined(HAS_RAWTOYROW)
+
+// Neon version does direct RAW to YUV.
+#if defined(HAS_RAWTOYROW_NEON) && defined(HAS_RAWTOUVROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    RAWToUVRow = RAWToUVRow_Any_NEON;
+    RAWToYRow = RAWToYRow_Any_NEON;
+    if (IS_ALIGNED(width, 16)) {
+      RAWToYRow = RAWToYRow_NEON;
+      RAWToUVRow = RAWToUVRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_RAWTOYROW_MSA) && defined(HAS_RAWTOUVROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    RAWToUVRow = RAWToUVRow_Any_MSA;
+    RAWToYRow = RAWToYRow_Any_MSA;
+    if (IS_ALIGNED(width, 16)) {
+      RAWToYRow = RAWToYRow_MSA;
+      RAWToUVRow = RAWToUVRow_MSA;
+    }
+  }
+#endif
+#if defined(HAS_RAWTOYROW_LSX) && defined(HAS_RAWTOUVROW_LSX)
+  if (TestCpuFlag(kCpuHasLSX)) {
+    RAWToUVRow = RAWToUVRow_Any_LSX;
+    RAWToYRow = RAWToYRow_Any_LSX;
+    if (IS_ALIGNED(width, 16)) {
+      RAWToYRow = RAWToYRow_LSX;
+      RAWToUVRow = RAWToUVRow_LSX;
+    }
+  }
+#endif
+#if defined(HAS_RAWTOYROW_LASX) && defined(HAS_RAWTOUVROW_LASX)
+  if (TestCpuFlag(kCpuHasLASX)) {
+    RAWToUVRow = RAWToUVRow_Any_LASX;
+    RAWToYRow = RAWToYRow_Any_LASX;
+    if (IS_ALIGNED(width, 32)) {
+      RAWToYRow = RAWToYRow_LASX;
+      RAWToUVRow = RAWToUVRow_LASX;
+    }
+  }
+#endif
+
+// Other platforms do intermediate conversion from RAW to ARGB.
+#else  // HAS_RAWTOYROW
+
+#if defined(HAS_RAWTOARGBROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    RAWToARGBRow = RAWToARGBRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 16)) {
+      RAWToARGBRow = RAWToARGBRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOYROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    ARGBToYRow = ARGBToYRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBToYRow = ARGBToYRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOYROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ARGBToYRow = ARGBToYRow_Any_AVX2;
+    if (IS_ALIGNED(width, 32)) {
+      ARGBToYRow = ARGBToYRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOUVROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    ARGBToUVRow = ARGBToUVRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBToUVRow = ARGBToUVRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOUVROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ARGBToUVRow = ARGBToUVRow_Any_AVX2;
+    if (IS_ALIGNED(width, 32)) {
+      ARGBToUVRow = ARGBToUVRow_AVX2;
+    }
+  }
+#endif
+#endif  // HAS_RAWTOYROW
+
+  {
+#if !defined(HAS_RAWTOYROW)
+    // Allocate 2 rows of ARGB.
+    const int kRowSize = (width * 4 + 31) & ~31;
+    align_buffer_64(row, kRowSize * 2);
+#endif
+
+    for (y = 0; y < height - 1; y += 2) {
+#if defined(HAS_RAWTOYROW)
+      RAWToUVRow(src_raw, src_stride_raw, dst_u, dst_v, width);
+      RAWToYRow(src_raw, dst_y, width);
+      RAWToYRow(src_raw + src_stride_raw, dst_y + dst_stride_y, width);
+#else
+      RAWToARGBRow(src_raw, row, width);
+      RAWToARGBRow(src_raw + src_stride_raw, row + kRowSize, width);
+      ARGBToUVRow(row, kRowSize, dst_u, dst_v, width);
+      ARGBToYRow(row, dst_y, width);
+      ARGBToYRow(row + kRowSize, dst_y + dst_stride_y, width);
+#endif
+      src_raw += src_stride_raw * 2;
+      dst_y += dst_stride_y * 2;
+      dst_u += dst_stride_u;
+      dst_v += dst_stride_v;
+    }
+    if (height & 1) {
+#if defined(HAS_RAWTOYROW)
+      RAWToUVRow(src_raw, 0, dst_u, dst_v, width);
+      RAWToYRow(src_raw, dst_y, width);
+#else
+      RAWToARGBRow(src_raw, row, width);
+      ARGBToUVRow(row, 0, dst_u, dst_v, width);
+      ARGBToYRow(row, dst_y, width);
+#endif
+    }
+#if !defined(HAS_RAWTOYROW)
+    free_aligned_buffer_64(row);
+#endif
+  }
+  return 0;
+}
+#undef HAS_RAWTOYROW
+
+// Enabled if 1 pass is available
+#if defined(HAS_RAWTOYJROW_NEON) || defined(HAS_RAWTOYJROW_MSA)
+#define HAS_RAWTOYJROW
+#endif
+
+// Convert RAW to J420.
+LIBYUV_API
+int RAWToJ420(const uint8_t* src_raw,
+              int src_stride_raw,
+              uint8_t* dst_y,
+              int dst_stride_y,
+              uint8_t* dst_u,
+              int dst_stride_u,
+              uint8_t* dst_v,
+              int dst_stride_v,
+              int width,
+              int height) {
+  int y;
+#if defined(HAS_RAWTOYJROW)
+  void (*RAWToUVJRow)(const uint8_t* src_raw, int src_stride_raw,
+                      uint8_t* dst_u, uint8_t* dst_v, int width) =
+      RAWToUVJRow_C;
+  void (*RAWToYJRow)(const uint8_t* src_raw, uint8_t* dst_y, int width) =
+      RAWToYJRow_C;
+#else
+  void (*RAWToARGBRow)(const uint8_t* src_rgb, uint8_t* dst_argb, int width) =
+      RAWToARGBRow_C;
+  void (*ARGBToUVJRow)(const uint8_t* src_argb0, int src_stride_argb,
+                       uint8_t* dst_u, uint8_t* dst_v, int width) =
+      ARGBToUVJRow_C;
+  void (*ARGBToYJRow)(const uint8_t* src_argb, uint8_t* dst_y, int width) =
+      ARGBToYJRow_C;
+#endif
+  if (!src_raw || !dst_y || !dst_u || !dst_v || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    src_raw = src_raw + (height - 1) * src_stride_raw;
+    src_stride_raw = -src_stride_raw;
+  }
+
+#if defined(HAS_RAWTOYJROW)
+
+// Neon version does direct RAW to YUV.
+#if defined(HAS_RAWTOYJROW_NEON) && defined(HAS_RAWTOUVJROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    RAWToUVJRow = RAWToUVJRow_Any_NEON;
+    RAWToYJRow = RAWToYJRow_Any_NEON;
+    if (IS_ALIGNED(width, 16)) {
+      RAWToYJRow = RAWToYJRow_NEON;
+      RAWToUVJRow = RAWToUVJRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_RAWTOYJROW_MSA) && defined(HAS_RAWTOUVJROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    RAWToUVJRow = RAWToUVJRow_Any_MSA;
+    RAWToYJRow = RAWToYJRow_Any_MSA;
+    if (IS_ALIGNED(width, 16)) {
+      RAWToYJRow = RAWToYJRow_MSA;
+      RAWToUVJRow = RAWToUVJRow_MSA;
+    }
+  }
+#endif
+
+// Other platforms do intermediate conversion from RAW to ARGB.
+#else  // HAS_RAWTOYJROW
+
+#if defined(HAS_RAWTOARGBROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    RAWToARGBRow = RAWToARGBRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 16)) {
+      RAWToARGBRow = RAWToARGBRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOYJROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    ARGBToYJRow = ARGBToYJRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBToYJRow = ARGBToYJRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOYJROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ARGBToYJRow = ARGBToYJRow_Any_AVX2;
+    if (IS_ALIGNED(width, 32)) {
+      ARGBToYJRow = ARGBToYJRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOUVJROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    ARGBToUVJRow = ARGBToUVJRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBToUVJRow = ARGBToUVJRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOUVJROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ARGBToUVJRow = ARGBToUVJRow_Any_AVX2;
+    if (IS_ALIGNED(width, 32)) {
+      ARGBToUVJRow = ARGBToUVJRow_AVX2;
+    }
+  }
+#endif
+#endif  // HAS_RAWTOYJROW
+
+  {
+#if !defined(HAS_RAWTOYJROW)
+    // Allocate 2 rows of ARGB.
+    const int kRowSize = (width * 4 + 31) & ~31;
+    align_buffer_64(row, kRowSize * 2);
+#endif
+
+    for (y = 0; y < height - 1; y += 2) {
+#if defined(HAS_RAWTOYJROW)
+      RAWToUVJRow(src_raw, src_stride_raw, dst_u, dst_v, width);
+      RAWToYJRow(src_raw, dst_y, width);
+      RAWToYJRow(src_raw + src_stride_raw, dst_y + dst_stride_y, width);
+#else
+      RAWToARGBRow(src_raw, row, width);
+      RAWToARGBRow(src_raw + src_stride_raw, row + kRowSize, width);
+      ARGBToUVJRow(row, kRowSize, dst_u, dst_v, width);
+      ARGBToYJRow(row, dst_y, width);
+      ARGBToYJRow(row + kRowSize, dst_y + dst_stride_y, width);
+#endif
+      src_raw += src_stride_raw * 2;
+      dst_y += dst_stride_y * 2;
+      dst_u += dst_stride_u;
+      dst_v += dst_stride_v;
+    }
+    if (height & 1) {
+#if defined(HAS_RAWTOYJROW)
+      RAWToUVJRow(src_raw, 0, dst_u, dst_v, width);
+      RAWToYJRow(src_raw, dst_y, width);
+#else
+      RAWToARGBRow(src_raw, row, width);
+      ARGBToUVJRow(row, 0, dst_u, dst_v, width);
+      ARGBToYJRow(row, dst_y, width);
+#endif
+    }
+#if !defined(HAS_RAWTOYJROW)
+    free_aligned_buffer_64(row);
+#endif
+  }
+  return 0;
+}
+#undef HAS_RAWTOYJROW
+
+// Convert RGB565 to I420.
+LIBYUV_API
+int RGB565ToI420(const uint8_t* src_rgb565,
+                 int src_stride_rgb565,
+                 uint8_t* dst_y,
+                 int dst_stride_y,
+                 uint8_t* dst_u,
+                 int dst_stride_u,
+                 uint8_t* dst_v,
+                 int dst_stride_v,
+                 int width,
+                 int height) {
+  int y;
+#if (defined(HAS_RGB565TOYROW_NEON) || defined(HAS_RGB565TOYROW_MSA) || \
+     defined(HAS_RGB565TOYROW_LSX) || defined(HAS_RGB565TOYROW_LASX))
+  void (*RGB565ToUVRow)(const uint8_t* src_rgb565, int src_stride_rgb565,
+                        uint8_t* dst_u, uint8_t* dst_v, int width) =
+      RGB565ToUVRow_C;
+  void (*RGB565ToYRow)(const uint8_t* src_rgb565, uint8_t* dst_y, int width) =
+      RGB565ToYRow_C;
+#else
+  void (*RGB565ToARGBRow)(const uint8_t* src_rgb, uint8_t* dst_argb,
+                          int width) = RGB565ToARGBRow_C;
+  void (*ARGBToUVRow)(const uint8_t* src_argb0, int src_stride_argb,
+                      uint8_t* dst_u, uint8_t* dst_v, int width) =
+      ARGBToUVRow_C;
+  void (*ARGBToYRow)(const uint8_t* src_argb, uint8_t* dst_y, int width) =
+      ARGBToYRow_C;
+#endif
+  if (!src_rgb565 || !dst_y || !dst_u || !dst_v || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    src_rgb565 = src_rgb565 + (height - 1) * src_stride_rgb565;
+    src_stride_rgb565 = -src_stride_rgb565;
+  }
+
+// Neon version does direct RGB565 to YUV.
+#if defined(HAS_RGB565TOYROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    RGB565ToUVRow = RGB565ToUVRow_Any_NEON;
+    RGB565ToYRow = RGB565ToYRow_Any_NEON;
+    if (IS_ALIGNED(width, 8)) {
+      RGB565ToYRow = RGB565ToYRow_NEON;
+      if (IS_ALIGNED(width, 16)) {
+        RGB565ToUVRow = RGB565ToUVRow_NEON;
+      }
+    }
+  }
+// MSA version does direct RGB565 to YUV.
+#elif (defined(HAS_RGB565TOYROW_MSA) || defined(HAS_RGB565TOYROW_LSX) || \
+       defined(HAS_RGB565TOYROW_LASX))
+#if defined(HAS_RGB565TOYROW_MSA) && defined(HAS_RGB565TOUVROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    RGB565ToUVRow = RGB565ToUVRow_Any_MSA;
+    RGB565ToYRow = RGB565ToYRow_Any_MSA;
+    if (IS_ALIGNED(width, 16)) {
+      RGB565ToYRow = RGB565ToYRow_MSA;
+      RGB565ToUVRow = RGB565ToUVRow_MSA;
+    }
+  }
+#endif
+#if defined(HAS_RGB565TOYROW_LSX) && defined(HAS_RGB565TOUVROW_LSX)
+  if (TestCpuFlag(kCpuHasLSX)) {
+    RGB565ToUVRow = RGB565ToUVRow_Any_LSX;
+    RGB565ToYRow = RGB565ToYRow_Any_LSX;
+    if (IS_ALIGNED(width, 16)) {
+      RGB565ToYRow = RGB565ToYRow_LSX;
+      RGB565ToUVRow = RGB565ToUVRow_LSX;
+    }
+  }
+#endif
+#if defined(HAS_RGB565TOYROW_LASX) && defined(HAS_RGB565TOUVROW_LASX)
+  if (TestCpuFlag(kCpuHasLASX)) {
+    RGB565ToUVRow = RGB565ToUVRow_Any_LASX;
+    RGB565ToYRow = RGB565ToYRow_Any_LASX;
+    if (IS_ALIGNED(width, 32)) {
+      RGB565ToYRow = RGB565ToYRow_LASX;
+      RGB565ToUVRow = RGB565ToUVRow_LASX;
+    }
+  }
+#endif
+// Other platforms do intermediate conversion from RGB565 to ARGB.
+#else
+#if defined(HAS_RGB565TOARGBROW_SSE2)
+  if (TestCpuFlag(kCpuHasSSE2)) {
+    RGB565ToARGBRow = RGB565ToARGBRow_Any_SSE2;
+    if (IS_ALIGNED(width, 8)) {
+      RGB565ToARGBRow = RGB565ToARGBRow_SSE2;
+    }
+  }
+#endif
+#if defined(HAS_RGB565TOARGBROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    RGB565ToARGBRow = RGB565ToARGBRow_Any_AVX2;
+    if (IS_ALIGNED(width, 16)) {
+      RGB565ToARGBRow = RGB565ToARGBRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOYROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    ARGBToYRow = ARGBToYRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBToYRow = ARGBToYRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOUVROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    ARGBToUVRow = ARGBToUVRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBToUVRow = ARGBToUVRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOYROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ARGBToYRow = ARGBToYRow_Any_AVX2;
+    if (IS_ALIGNED(width, 32)) {
+      ARGBToYRow = ARGBToYRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOUVROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ARGBToUVRow = ARGBToUVRow_Any_AVX2;
+    if (IS_ALIGNED(width, 32)) {
+      ARGBToUVRow = ARGBToUVRow_AVX2;
+    }
+  }
+#endif
+#endif
+  {
+#if !(defined(HAS_RGB565TOYROW_NEON) || defined(HAS_RGB565TOYROW_MSA) || \
+      defined(HAS_RGB565TOYROW_LSX) || defined(HAS_RGB565TOYROW_LASX))
+    // Allocate 2 rows of ARGB.
+    const int kRowSize = (width * 4 + 31) & ~31;
+    align_buffer_64(row, kRowSize * 2);
+#endif
+    for (y = 0; y < height - 1; y += 2) {
+#if (defined(HAS_RGB565TOYROW_NEON) || defined(HAS_RGB565TOYROW_MSA) || \
+     defined(HAS_RGB565TOYROW_LSX) || defined(HAS_RGB565TOYROW_LASX))
+      RGB565ToUVRow(src_rgb565, src_stride_rgb565, dst_u, dst_v, width);
+      RGB565ToYRow(src_rgb565, dst_y, width);
+      RGB565ToYRow(src_rgb565 + src_stride_rgb565, dst_y + dst_stride_y, width);
+#else
+      RGB565ToARGBRow(src_rgb565, row, width);
+      RGB565ToARGBRow(src_rgb565 + src_stride_rgb565, row + kRowSize, width);
+      ARGBToUVRow(row, kRowSize, dst_u, dst_v, width);
+      ARGBToYRow(row, dst_y, width);
+      ARGBToYRow(row + kRowSize, dst_y + dst_stride_y, width);
+#endif
+      src_rgb565 += src_stride_rgb565 * 2;
+      dst_y += dst_stride_y * 2;
+      dst_u += dst_stride_u;
+      dst_v += dst_stride_v;
+    }
+    if (height & 1) {
+#if (defined(HAS_RGB565TOYROW_NEON) || defined(HAS_RGB565TOYROW_MSA) || \
+     defined(HAS_RGB565TOYROW_LSX) || defined(HAS_RGB565TOYROW_LASX))
+      RGB565ToUVRow(src_rgb565, 0, dst_u, dst_v, width);
+      RGB565ToYRow(src_rgb565, dst_y, width);
+#else
+      RGB565ToARGBRow(src_rgb565, row, width);
+      ARGBToUVRow(row, 0, dst_u, dst_v, width);
+      ARGBToYRow(row, dst_y, width);
+#endif
+    }
+#if !(defined(HAS_RGB565TOYROW_NEON) || defined(HAS_RGB565TOYROW_MSA) || \
+      defined(HAS_RGB565TOYROW_LSX) || defined(HAS_RGB565TOYROW_LASX))
+    free_aligned_buffer_64(row);
+#endif
+  }
+  return 0;
+}
+
+// Convert ARGB1555 to I420.
+LIBYUV_API
+int ARGB1555ToI420(const uint8_t* src_argb1555,
+                   int src_stride_argb1555,
+                   uint8_t* dst_y,
+                   int dst_stride_y,
+                   uint8_t* dst_u,
+                   int dst_stride_u,
+                   uint8_t* dst_v,
+                   int dst_stride_v,
+                   int width,
+                   int height) {
+  int y;
+#if (defined(HAS_ARGB1555TOYROW_NEON) || defined(HAS_ARGB1555TOYROW_MSA) || \
+     defined(HAS_ARGB1555TOYROW_LSX) || defined(HAS_ARGB1555TOYROW_LASX))
+  void (*ARGB1555ToUVRow)(const uint8_t* src_argb1555, int src_stride_argb1555,
+                          uint8_t* dst_u, uint8_t* dst_v, int width) =
+      ARGB1555ToUVRow_C;
+  void (*ARGB1555ToYRow)(const uint8_t* src_argb1555, uint8_t* dst_y,
+                         int width) = ARGB1555ToYRow_C;
+#else
+  void (*ARGB1555ToARGBRow)(const uint8_t* src_rgb, uint8_t* dst_argb,
+                            int width) = ARGB1555ToARGBRow_C;
+  void (*ARGBToUVRow)(const uint8_t* src_argb0, int src_stride_argb,
+                      uint8_t* dst_u, uint8_t* dst_v, int width) =
+      ARGBToUVRow_C;
+  void (*ARGBToYRow)(const uint8_t* src_argb, uint8_t* dst_y, int width) =
+      ARGBToYRow_C;
+#endif
+  if (!src_argb1555 || !dst_y || !dst_u || !dst_v || width <= 0 ||
+      height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    src_argb1555 = src_argb1555 + (height - 1) * src_stride_argb1555;
+    src_stride_argb1555 = -src_stride_argb1555;
+  }
+
+// Neon version does direct ARGB1555 to YUV.
+#if defined(HAS_ARGB1555TOYROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    ARGB1555ToUVRow = ARGB1555ToUVRow_Any_NEON;
+    ARGB1555ToYRow = ARGB1555ToYRow_Any_NEON;
+    if (IS_ALIGNED(width, 8)) {
+      ARGB1555ToYRow = ARGB1555ToYRow_NEON;
+      if (IS_ALIGNED(width, 16)) {
+        ARGB1555ToUVRow = ARGB1555ToUVRow_NEON;
+      }
+    }
+  }
+// MSA version does direct ARGB1555 to YUV.
+#elif (defined(HAS_ARGB1555TOYROW_MSA) || defined(HAS_ARGB1555TOYROW_LSX) || \
+       defined(HAS_ARGB1555TOYROW_LASX))
+#if defined(HAS_ARGB1555TOYROW_MSA) && defined(HAS_ARGB1555TOUVROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    ARGB1555ToUVRow = ARGB1555ToUVRow_Any_MSA;
+    ARGB1555ToYRow = ARGB1555ToYRow_Any_MSA;
+    if (IS_ALIGNED(width, 16)) {
+      ARGB1555ToYRow = ARGB1555ToYRow_MSA;
+      ARGB1555ToUVRow = ARGB1555ToUVRow_MSA;
+    }
+  }
+#endif
+#if defined(HAS_ARGB1555TOYROW_LSX) && defined(HAS_ARGB1555TOUVROW_LSX)
+  if (TestCpuFlag(kCpuHasLSX)) {
+    ARGB1555ToUVRow = ARGB1555ToUVRow_Any_LSX;
+    ARGB1555ToYRow = ARGB1555ToYRow_Any_LSX;
+    if (IS_ALIGNED(width, 16)) {
+      ARGB1555ToYRow = ARGB1555ToYRow_LSX;
+      ARGB1555ToUVRow = ARGB1555ToUVRow_LSX;
+    }
+  }
+#endif
+#if defined(HAS_ARGB1555TOYROW_LASX) && defined(HAS_ARGB1555TOUVROW_LASX)
+  if (TestCpuFlag(kCpuHasLASX)) {
+    ARGB1555ToUVRow = ARGB1555ToUVRow_Any_LASX;
+    ARGB1555ToYRow = ARGB1555ToYRow_Any_LASX;
+    if (IS_ALIGNED(width, 32)) {
+      ARGB1555ToYRow = ARGB1555ToYRow_LASX;
+      ARGB1555ToUVRow = ARGB1555ToUVRow_LASX;
+    }
+  }
+#endif
+// Other platforms do intermediate conversion from ARGB1555 to ARGB.
+#else
+#if defined(HAS_ARGB1555TOARGBROW_SSE2)
+  if (TestCpuFlag(kCpuHasSSE2)) {
+    ARGB1555ToARGBRow = ARGB1555ToARGBRow_Any_SSE2;
+    if (IS_ALIGNED(width, 8)) {
+      ARGB1555ToARGBRow = ARGB1555ToARGBRow_SSE2;
+    }
+  }
+#endif
+#if defined(HAS_ARGB1555TOARGBROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ARGB1555ToARGBRow = ARGB1555ToARGBRow_Any_AVX2;
+    if (IS_ALIGNED(width, 16)) {
+      ARGB1555ToARGBRow = ARGB1555ToARGBRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOYROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    ARGBToYRow = ARGBToYRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBToYRow = ARGBToYRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOUVROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    ARGBToUVRow = ARGBToUVRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBToUVRow = ARGBToUVRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOYROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ARGBToYRow = ARGBToYRow_Any_AVX2;
+    if (IS_ALIGNED(width, 32)) {
+      ARGBToYRow = ARGBToYRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOUVROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ARGBToUVRow = ARGBToUVRow_Any_AVX2;
+    if (IS_ALIGNED(width, 32)) {
+      ARGBToUVRow = ARGBToUVRow_AVX2;
+    }
+  }
+#endif
+#endif
+  {
+#if !(defined(HAS_ARGB1555TOYROW_NEON) || defined(HAS_ARGB1555TOYROW_MSA) || \
+      defined(HAS_ARGB1555TOYROW_LSX) || defined(HAS_ARGB1555TOYROW_LASX))
+    // Allocate 2 rows of ARGB.
+    const int kRowSize = (width * 4 + 31) & ~31;
+    align_buffer_64(row, kRowSize * 2);
+#endif
+
+    for (y = 0; y < height - 1; y += 2) {
+#if (defined(HAS_ARGB1555TOYROW_NEON) || defined(HAS_ARGB1555TOYROW_MSA) || \
+     defined(HAS_ARGB1555TOYROW_LSX) || defined(HAS_ARGB1555TOYROW_LASX))
+      ARGB1555ToUVRow(src_argb1555, src_stride_argb1555, dst_u, dst_v, width);
+      ARGB1555ToYRow(src_argb1555, dst_y, width);
+      ARGB1555ToYRow(src_argb1555 + src_stride_argb1555, dst_y + dst_stride_y,
+                     width);
+#else
+      ARGB1555ToARGBRow(src_argb1555, row, width);
+      ARGB1555ToARGBRow(src_argb1555 + src_stride_argb1555, row + kRowSize,
+                        width);
+      ARGBToUVRow(row, kRowSize, dst_u, dst_v, width);
+      ARGBToYRow(row, dst_y, width);
+      ARGBToYRow(row + kRowSize, dst_y + dst_stride_y, width);
+#endif
+      src_argb1555 += src_stride_argb1555 * 2;
+      dst_y += dst_stride_y * 2;
+      dst_u += dst_stride_u;
+      dst_v += dst_stride_v;
+    }
+    if (height & 1) {
+#if (defined(HAS_ARGB1555TOYROW_NEON) || defined(HAS_ARGB1555TOYROW_MSA) || \
+     defined(HAS_ARGB1555TOYROW_LSX) || defined(HAS_ARGB1555TOYROW_LASX))
+      ARGB1555ToUVRow(src_argb1555, 0, dst_u, dst_v, width);
+      ARGB1555ToYRow(src_argb1555, dst_y, width);
+#else
+      ARGB1555ToARGBRow(src_argb1555, row, width);
+      ARGBToUVRow(row, 0, dst_u, dst_v, width);
+      ARGBToYRow(row, dst_y, width);
+#endif
+    }
+#if !(defined(HAS_ARGB1555TOYROW_NEON) || defined(HAS_ARGB1555TOYROW_MSA) || \
+      defined(HAS_ARGB1555TOYROW_LSX) || defined(HAS_ARGB1555TOYROW_LASX))
+    free_aligned_buffer_64(row);
+#endif
+  }
+  return 0;
+}
+
+// Convert ARGB4444 to I420.
+LIBYUV_API
+int ARGB4444ToI420(const uint8_t* src_argb4444,
+                   int src_stride_argb4444,
+                   uint8_t* dst_y,
+                   int dst_stride_y,
+                   uint8_t* dst_u,
+                   int dst_stride_u,
+                   uint8_t* dst_v,
+                   int dst_stride_v,
+                   int width,
+                   int height) {
+  int y;
+#if defined(HAS_ARGB4444TOYROW_NEON)
+  void (*ARGB4444ToUVRow)(const uint8_t* src_argb4444, int src_stride_argb4444,
+                          uint8_t* dst_u, uint8_t* dst_v, int width) =
+      ARGB4444ToUVRow_C;
+  void (*ARGB4444ToYRow)(const uint8_t* src_argb4444, uint8_t* dst_y,
+                         int width) = ARGB4444ToYRow_C;
+#else
+  void (*ARGB4444ToARGBRow)(const uint8_t* src_rgb, uint8_t* dst_argb,
+                            int width) = ARGB4444ToARGBRow_C;
+  void (*ARGBToUVRow)(const uint8_t* src_argb0, int src_stride_argb,
+                      uint8_t* dst_u, uint8_t* dst_v, int width) =
+      ARGBToUVRow_C;
+  void (*ARGBToYRow)(const uint8_t* src_argb, uint8_t* dst_y, int width) =
+      ARGBToYRow_C;
+#endif
+  if (!src_argb4444 || !dst_y || !dst_u || !dst_v || width <= 0 ||
+      height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    src_argb4444 = src_argb4444 + (height - 1) * src_stride_argb4444;
+    src_stride_argb4444 = -src_stride_argb4444;
+  }
+
+// Neon version does direct ARGB4444 to YUV.
+#if defined(HAS_ARGB4444TOYROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    ARGB4444ToUVRow = ARGB4444ToUVRow_Any_NEON;
+    ARGB4444ToYRow = ARGB4444ToYRow_Any_NEON;
+    if (IS_ALIGNED(width, 8)) {
+      ARGB4444ToYRow = ARGB4444ToYRow_NEON;
+      if (IS_ALIGNED(width, 16)) {
+        ARGB4444ToUVRow = ARGB4444ToUVRow_NEON;
+      }
+    }
+  }
+// Other platforms do intermediate conversion from ARGB4444 to ARGB.
+#else
+#if defined(HAS_ARGB4444TOARGBROW_SSE2)
+  if (TestCpuFlag(kCpuHasSSE2)) {
+    ARGB4444ToARGBRow = ARGB4444ToARGBRow_Any_SSE2;
+    if (IS_ALIGNED(width, 8)) {
+      ARGB4444ToARGBRow = ARGB4444ToARGBRow_SSE2;
+    }
+  }
+#endif
+#if defined(HAS_ARGB4444TOARGBROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ARGB4444ToARGBRow = ARGB4444ToARGBRow_Any_AVX2;
+    if (IS_ALIGNED(width, 16)) {
+      ARGB4444ToARGBRow = ARGB4444ToARGBRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_ARGB4444TOARGBROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    ARGB4444ToARGBRow = ARGB4444ToARGBRow_Any_MSA;
+    if (IS_ALIGNED(width, 16)) {
+      ARGB4444ToARGBRow = ARGB4444ToARGBRow_MSA;
+    }
+  }
+#endif
+#if defined(HAS_ARGB4444TOARGBROW_LSX)
+  if (TestCpuFlag(kCpuHasLSX)) {
+    ARGB4444ToARGBRow = ARGB4444ToARGBRow_Any_LSX;
+    if (IS_ALIGNED(width, 16)) {
+      ARGB4444ToARGBRow = ARGB4444ToARGBRow_LSX;
+    }
+  }
+#endif
+#if defined(HAS_ARGB4444TOARGBROW_LASX)
+  if (TestCpuFlag(kCpuHasLASX)) {
+    ARGB4444ToARGBRow = ARGB4444ToARGBRow_Any_LASX;
+    if (IS_ALIGNED(width, 32)) {
+      ARGB4444ToARGBRow = ARGB4444ToARGBRow_LASX;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOYROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    ARGBToYRow = ARGBToYRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBToYRow = ARGBToYRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOUVROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    ARGBToUVRow = ARGBToUVRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBToUVRow = ARGBToUVRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOYROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ARGBToYRow = ARGBToYRow_Any_AVX2;
+    if (IS_ALIGNED(width, 32)) {
+      ARGBToYRow = ARGBToYRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOUVROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ARGBToUVRow = ARGBToUVRow_Any_AVX2;
+    if (IS_ALIGNED(width, 32)) {
+      ARGBToUVRow = ARGBToUVRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOYROW_MSA) && defined(HAS_ARGBTOUVROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    ARGBToUVRow = ARGBToUVRow_Any_MSA;
+    ARGBToYRow = ARGBToYRow_Any_MSA;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBToYRow = ARGBToYRow_MSA;
+      if (IS_ALIGNED(width, 32)) {
+        ARGBToUVRow = ARGBToUVRow_MSA;
+      }
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOYROW_LASX) && defined(HAS_ARGBTOUVROW_LASX)
+  if (TestCpuFlag(kCpuHasLASX)) {
+    ARGBToYRow = ARGBToYRow_Any_LASX;
+    ARGBToUVRow = ARGBToUVRow_Any_LASX;
+    if (IS_ALIGNED(width, 32)) {
+      ARGBToYRow = ARGBToYRow_LASX;
+      ARGBToUVRow = ARGBToUVRow_LASX;
+    }
+  }
+#endif
+#endif
+
+  {
+#if !(defined(HAS_ARGB4444TOYROW_NEON))
+    // Allocate 2 rows of ARGB.
+    const int kRowSize = (width * 4 + 31) & ~31;
+    align_buffer_64(row, kRowSize * 2);
+#endif
+
+    for (y = 0; y < height - 1; y += 2) {
+#if defined(HAS_ARGB4444TOYROW_NEON)
+      ARGB4444ToUVRow(src_argb4444, src_stride_argb4444, dst_u, dst_v, width);
+      ARGB4444ToYRow(src_argb4444, dst_y, width);
+      ARGB4444ToYRow(src_argb4444 + src_stride_argb4444, dst_y + dst_stride_y,
+                     width);
+#else
+      ARGB4444ToARGBRow(src_argb4444, row, width);
+      ARGB4444ToARGBRow(src_argb4444 + src_stride_argb4444, row + kRowSize,
+                        width);
+      ARGBToUVRow(row, kRowSize, dst_u, dst_v, width);
+      ARGBToYRow(row, dst_y, width);
+      ARGBToYRow(row + kRowSize, dst_y + dst_stride_y, width);
+#endif
+      src_argb4444 += src_stride_argb4444 * 2;
+      dst_y += dst_stride_y * 2;
+      dst_u += dst_stride_u;
+      dst_v += dst_stride_v;
+    }
+    if (height & 1) {
+#if defined(HAS_ARGB4444TOYROW_NEON)
+      ARGB4444ToUVRow(src_argb4444, 0, dst_u, dst_v, width);
+      ARGB4444ToYRow(src_argb4444, dst_y, width);
+#else
+      ARGB4444ToARGBRow(src_argb4444, row, width);
+      ARGBToUVRow(row, 0, dst_u, dst_v, width);
+      ARGBToYRow(row, dst_y, width);
+#endif
+    }
+#if !(defined(HAS_ARGB4444TOYROW_NEON))
+    free_aligned_buffer_64(row);
+#endif
+  }
+  return 0;
+}
+
+// Convert RGB24 to J400.
+LIBYUV_API
+int RGB24ToJ400(const uint8_t* src_rgb24,
+                int src_stride_rgb24,
+                uint8_t* dst_yj,
+                int dst_stride_yj,
+                int width,
+                int height) {
+  int y;
+  void (*RGB24ToYJRow)(const uint8_t* src_rgb24, uint8_t* dst_yj, int width) =
+      RGB24ToYJRow_C;
+  if (!src_rgb24 || !dst_yj || width <= 0 || height == 0) {
+    return -1;
+  }
+  if (height < 0) {
+    height = -height;
+    src_rgb24 = src_rgb24 + (height - 1) * src_stride_rgb24;
+    src_stride_rgb24 = -src_stride_rgb24;
+  }
+  // Coalesce rows.
+  if (src_stride_rgb24 == width * 3 && dst_stride_yj == width) {
+    width *= height;
+    height = 1;
+    src_stride_rgb24 = dst_stride_yj = 0;
+  }
+#if defined(HAS_RGB24TOYJROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    RGB24ToYJRow = RGB24ToYJRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 16)) {
+      RGB24ToYJRow = RGB24ToYJRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_RGB24TOYJROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    RGB24ToYJRow = RGB24ToYJRow_Any_AVX2;
+    if (IS_ALIGNED(width, 32)) {
+      RGB24ToYJRow = RGB24ToYJRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_RGB24TOYJROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    RGB24ToYJRow = RGB24ToYJRow_Any_NEON;
+    if (IS_ALIGNED(width, 16)) {
+      RGB24ToYJRow = RGB24ToYJRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_RGB24TOYJROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    RGB24ToYJRow = RGB24ToYJRow_Any_MSA;
+    if (IS_ALIGNED(width, 16)) {
+      RGB24ToYJRow = RGB24ToYJRow_MSA;
+    }
+  }
+#endif
+
+  for (y = 0; y < height; ++y) {
+    RGB24ToYJRow(src_rgb24, dst_yj, width);
+    src_rgb24 += src_stride_rgb24;
+    dst_yj += dst_stride_yj;
+  }
+  return 0;
+}
+
+// Convert RAW to J400.
+LIBYUV_API
+int RAWToJ400(const uint8_t* src_raw,
+              int src_stride_raw,
+              uint8_t* dst_yj,
+              int dst_stride_yj,
+              int width,
+              int height) {
+  int y;
+  void (*RAWToYJRow)(const uint8_t* src_raw, uint8_t* dst_yj, int width) =
+      RAWToYJRow_C;
+  if (!src_raw || !dst_yj || width <= 0 || height == 0) {
+    return -1;
+  }
+  if (height < 0) {
+    height = -height;
+    src_raw = src_raw + (height - 1) * src_stride_raw;
+    src_stride_raw = -src_stride_raw;
+  }
+  // Coalesce rows.
+  if (src_stride_raw == width * 3 && dst_stride_yj == width) {
+    width *= height;
+    height = 1;
+    src_stride_raw = dst_stride_yj = 0;
+  }
+#if defined(HAS_RAWTOYJROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    RAWToYJRow = RAWToYJRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 16)) {
+      RAWToYJRow = RAWToYJRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_RAWTOYJROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    RAWToYJRow = RAWToYJRow_Any_AVX2;
+    if (IS_ALIGNED(width, 32)) {
+      RAWToYJRow = RAWToYJRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_RAWTOYJROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    RAWToYJRow = RAWToYJRow_Any_NEON;
+    if (IS_ALIGNED(width, 8)) {
+      RAWToYJRow = RAWToYJRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_RAWTOYJROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    RAWToYJRow = RAWToYJRow_Any_MSA;
+    if (IS_ALIGNED(width, 16)) {
+      RAWToYJRow = RAWToYJRow_MSA;
+    }
+  }
+#endif
+
+  for (y = 0; y < height; ++y) {
+    RAWToYJRow(src_raw, dst_yj, width);
+    src_raw += src_stride_raw;
+    dst_yj += dst_stride_yj;
+  }
+  return 0;
+}
+
+// Convert Android420 to I420.
+LIBYUV_API
+int Android420ToI420(const uint8_t* src_y,
+                     int src_stride_y,
+                     const uint8_t* src_u,
+                     int src_stride_u,
+                     const uint8_t* src_v,
+                     int src_stride_v,
+                     int src_pixel_stride_uv,
+                     uint8_t* dst_y,
+                     int dst_stride_y,
+                     uint8_t* dst_u,
+                     int dst_stride_u,
+                     uint8_t* dst_v,
+                     int dst_stride_v,
+                     int width,
+                     int height) {
+  return Android420ToI420Rotate(src_y, src_stride_y, src_u, src_stride_u, src_v,
+                                src_stride_v, src_pixel_stride_uv, dst_y,
+                                dst_stride_y, dst_u, dst_stride_u, dst_v,
+                                dst_stride_v, width, height, kRotate0);
+}
+
+#ifdef __cplusplus
+}  // extern "C"
+}  // namespace libyuv
+#endif
diff --git a/3rdparty/libyuv/src/source/convert_argb.cc b/3rdparty/libyuv/src/source/convert_argb.cc
new file mode 100644
index 00000000..942df30a
--- /dev/null
+++ b/3rdparty/libyuv/src/source/convert_argb.cc
@@ -0,0 +1,7369 @@
+/*
+ *  Copyright 2011 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+#include "libyuv/convert_argb.h"
+
+#include "libyuv/cpu_id.h"
+#ifdef HAVE_JPEG
+#include "libyuv/mjpeg_decoder.h"
+#endif
+#include "libyuv/planar_functions.h"  // For CopyPlane and ARGBShuffle.
+#include "libyuv/rotate_argb.h"
+#include "libyuv/row.h"
+#include "libyuv/scale_row.h"  // For ScaleRowUp2_Linear and ScaleRowUp2_Bilinear
+#include "libyuv/video_common.h"
+
+#ifdef __cplusplus
+namespace libyuv {
+extern "C" {
+#endif
+
+// Copy ARGB with optional flipping
+LIBYUV_API
+int ARGBCopy(const uint8_t* src_argb,
+             int src_stride_argb,
+             uint8_t* dst_argb,
+             int dst_stride_argb,
+             int width,
+             int height) {
+  if (!src_argb || !dst_argb || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    src_argb = src_argb + (height - 1) * src_stride_argb;
+    src_stride_argb = -src_stride_argb;
+  }
+
+  CopyPlane(src_argb, src_stride_argb, dst_argb, dst_stride_argb, width * 4,
+            height);
+  return 0;
+}
+
+// Convert I420 to ARGB with matrix.
+LIBYUV_API
+int I420ToARGBMatrix(const uint8_t* src_y,
+                     int src_stride_y,
+                     const uint8_t* src_u,
+                     int src_stride_u,
+                     const uint8_t* src_v,
+                     int src_stride_v,
+                     uint8_t* dst_argb,
+                     int dst_stride_argb,
+                     const struct YuvConstants* yuvconstants,
+                     int width,
+                     int height) {
+  int y;
+  void (*I422ToARGBRow)(const uint8_t* y_buf, const uint8_t* u_buf,
+                        const uint8_t* v_buf, uint8_t* rgb_buf,
+                        const struct YuvConstants* yuvconstants, int width) =
+      I422ToARGBRow_C;
+  if (!src_y || !src_u || !src_v || !dst_argb || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    dst_argb = dst_argb + (height - 1) * dst_stride_argb;
+    dst_stride_argb = -dst_stride_argb;
+  }
+#if defined(HAS_I422TOARGBROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    I422ToARGBRow = I422ToARGBRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 8)) {
+      I422ToARGBRow = I422ToARGBRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_I422TOARGBROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    I422ToARGBRow = I422ToARGBRow_Any_AVX2;
+    if (IS_ALIGNED(width, 16)) {
+      I422ToARGBRow = I422ToARGBRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_I422TOARGBROW_AVX512BW)
+  if (TestCpuFlag(kCpuHasAVX512BW | kCpuHasAVX512VL) ==
+      (kCpuHasAVX512BW | kCpuHasAVX512VL)) {
+    I422ToARGBRow = I422ToARGBRow_Any_AVX512BW;
+    if (IS_ALIGNED(width, 32)) {
+      I422ToARGBRow = I422ToARGBRow_AVX512BW;
+    }
+  }
+#endif
+#if defined(HAS_I422TOARGBROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    I422ToARGBRow = I422ToARGBRow_Any_NEON;
+    if (IS_ALIGNED(width, 8)) {
+      I422ToARGBRow = I422ToARGBRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_I422TOARGBROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    I422ToARGBRow = I422ToARGBRow_Any_MSA;
+    if (IS_ALIGNED(width, 8)) {
+      I422ToARGBRow = I422ToARGBRow_MSA;
+    }
+  }
+#endif
+#if defined(HAS_I422TOARGBROW_LASX)
+  if (TestCpuFlag(kCpuHasLASX)) {
+    I422ToARGBRow = I422ToARGBRow_Any_LASX;
+    if (IS_ALIGNED(width, 32)) {
+      I422ToARGBRow = I422ToARGBRow_LASX;
+    }
+  }
+#endif
+
+  for (y = 0; y < height; ++y) {
+    I422ToARGBRow(src_y, src_u, src_v, dst_argb, yuvconstants, width);
+    dst_argb += dst_stride_argb;
+    src_y += src_stride_y;
+    if (y & 1) {
+      src_u += src_stride_u;
+      src_v += src_stride_v;
+    }
+  }
+  return 0;
+}
+
+// Convert I420 to ARGB.
+LIBYUV_API
+int I420ToARGB(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_argb,
+               int dst_stride_argb,
+               int width,
+               int height) {
+  return I420ToARGBMatrix(src_y, src_stride_y, src_u, src_stride_u, src_v,
+                          src_stride_v, dst_argb, dst_stride_argb,
+                          &kYuvI601Constants, width, height);
+}
+
+// Convert I420 to ABGR.
+LIBYUV_API
+int I420ToABGR(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_abgr,
+               int dst_stride_abgr,
+               int width,
+               int height) {
+  return I420ToARGBMatrix(src_y, src_stride_y, src_v,
+                          src_stride_v,  // Swap U and V
+                          src_u, src_stride_u, dst_abgr, dst_stride_abgr,
+                          &kYvuI601Constants,  // Use Yvu matrix
+                          width, height);
+}
+
+// Convert J420 to ARGB.
+LIBYUV_API
+int J420ToARGB(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_argb,
+               int dst_stride_argb,
+               int width,
+               int height) {
+  return I420ToARGBMatrix(src_y, src_stride_y, src_u, src_stride_u, src_v,
+                          src_stride_v, dst_argb, dst_stride_argb,
+                          &kYuvJPEGConstants, width, height);
+}
+
+// Convert J420 to ABGR.
+LIBYUV_API
+int J420ToABGR(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_abgr,
+               int dst_stride_abgr,
+               int width,
+               int height) {
+  return I420ToARGBMatrix(src_y, src_stride_y, src_v,
+                          src_stride_v,  // Swap U and V
+                          src_u, src_stride_u, dst_abgr, dst_stride_abgr,
+                          &kYvuJPEGConstants,  // Use Yvu matrix
+                          width, height);
+}
+
+// Convert H420 to ARGB.
+LIBYUV_API
+int H420ToARGB(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_argb,
+               int dst_stride_argb,
+               int width,
+               int height) {
+  return I420ToARGBMatrix(src_y, src_stride_y, src_u, src_stride_u, src_v,
+                          src_stride_v, dst_argb, dst_stride_argb,
+                          &kYuvH709Constants, width, height);
+}
+
+// Convert H420 to ABGR.
+LIBYUV_API
+int H420ToABGR(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_abgr,
+               int dst_stride_abgr,
+               int width,
+               int height) {
+  return I420ToARGBMatrix(src_y, src_stride_y, src_v,
+                          src_stride_v,  // Swap U and V
+                          src_u, src_stride_u, dst_abgr, dst_stride_abgr,
+                          &kYvuH709Constants,  // Use Yvu matrix
+                          width, height);
+}
+
+// Convert U420 to ARGB.
+LIBYUV_API
+int U420ToARGB(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_argb,
+               int dst_stride_argb,
+               int width,
+               int height) {
+  return I420ToARGBMatrix(src_y, src_stride_y, src_u, src_stride_u, src_v,
+                          src_stride_v, dst_argb, dst_stride_argb,
+                          &kYuv2020Constants, width, height);
+}
+
+// Convert U420 to ABGR.
+LIBYUV_API
+int U420ToABGR(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_abgr,
+               int dst_stride_abgr,
+               int width,
+               int height) {
+  return I420ToARGBMatrix(src_y, src_stride_y, src_v,
+                          src_stride_v,  // Swap U and V
+                          src_u, src_stride_u, dst_abgr, dst_stride_abgr,
+                          &kYvu2020Constants,  // Use Yvu matrix
+                          width, height);
+}
+
+// Convert I422 to ARGB with matrix.
+LIBYUV_API
+int I422ToARGBMatrix(const uint8_t* src_y,
+                     int src_stride_y,
+                     const uint8_t* src_u,
+                     int src_stride_u,
+                     const uint8_t* src_v,
+                     int src_stride_v,
+                     uint8_t* dst_argb,
+                     int dst_stride_argb,
+                     const struct YuvConstants* yuvconstants,
+                     int width,
+                     int height) {
+  int y;
+  void (*I422ToARGBRow)(const uint8_t* y_buf, const uint8_t* u_buf,
+                        const uint8_t* v_buf, uint8_t* rgb_buf,
+                        const struct YuvConstants* yuvconstants, int width) =
+      I422ToARGBRow_C;
+  if (!src_y || !src_u || !src_v || !dst_argb || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    dst_argb = dst_argb + (height - 1) * dst_stride_argb;
+    dst_stride_argb = -dst_stride_argb;
+  }
+  // Coalesce rows.
+  if (src_stride_y == width && src_stride_u * 2 == width &&
+      src_stride_v * 2 == width && dst_stride_argb == width * 4) {
+    width *= height;
+    height = 1;
+    src_stride_y = src_stride_u = src_stride_v = dst_stride_argb = 0;
+  }
+#if defined(HAS_I422TOARGBROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    I422ToARGBRow = I422ToARGBRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 8)) {
+      I422ToARGBRow = I422ToARGBRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_I422TOARGBROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    I422ToARGBRow = I422ToARGBRow_Any_AVX2;
+    if (IS_ALIGNED(width, 16)) {
+      I422ToARGBRow = I422ToARGBRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_I422TOARGBROW_AVX512BW)
+  if (TestCpuFlag(kCpuHasAVX512BW | kCpuHasAVX512VL) ==
+      (kCpuHasAVX512BW | kCpuHasAVX512VL)) {
+    I422ToARGBRow = I422ToARGBRow_Any_AVX512BW;
+    if (IS_ALIGNED(width, 32)) {
+      I422ToARGBRow = I422ToARGBRow_AVX512BW;
+    }
+  }
+#endif
+#if defined(HAS_I422TOARGBROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    I422ToARGBRow = I422ToARGBRow_Any_NEON;
+    if (IS_ALIGNED(width, 8)) {
+      I422ToARGBRow = I422ToARGBRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_I422TOARGBROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    I422ToARGBRow = I422ToARGBRow_Any_MSA;
+    if (IS_ALIGNED(width, 8)) {
+      I422ToARGBRow = I422ToARGBRow_MSA;
+    }
+  }
+#endif
+#if defined(HAS_I422TOARGBROW_LASX)
+  if (TestCpuFlag(kCpuHasLASX)) {
+    I422ToARGBRow = I422ToARGBRow_Any_LASX;
+    if (IS_ALIGNED(width, 32)) {
+      I422ToARGBRow = I422ToARGBRow_LASX;
+    }
+  }
+#endif
+
+  for (y = 0; y < height; ++y) {
+    I422ToARGBRow(src_y, src_u, src_v, dst_argb, yuvconstants, width);
+    dst_argb += dst_stride_argb;
+    src_y += src_stride_y;
+    src_u += src_stride_u;
+    src_v += src_stride_v;
+  }
+  return 0;
+}
+
+// Convert I422 to ARGB.
+LIBYUV_API
+int I422ToARGB(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_argb,
+               int dst_stride_argb,
+               int width,
+               int height) {
+  return I422ToARGBMatrix(src_y, src_stride_y, src_u, src_stride_u, src_v,
+                          src_stride_v, dst_argb, dst_stride_argb,
+                          &kYuvI601Constants, width, height);
+}
+
+// Convert I422 to ABGR.
+LIBYUV_API
+int I422ToABGR(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_abgr,
+               int dst_stride_abgr,
+               int width,
+               int height) {
+  return I422ToARGBMatrix(src_y, src_stride_y, src_v,
+                          src_stride_v,  // Swap U and V
+                          src_u, src_stride_u, dst_abgr, dst_stride_abgr,
+                          &kYvuI601Constants,  // Use Yvu matrix
+                          width, height);
+}
+
+// Convert J422 to ARGB.
+LIBYUV_API
+int J422ToARGB(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_argb,
+               int dst_stride_argb,
+               int width,
+               int height) {
+  return I422ToARGBMatrix(src_y, src_stride_y, src_u, src_stride_u, src_v,
+                          src_stride_v, dst_argb, dst_stride_argb,
+                          &kYuvJPEGConstants, width, height);
+}
+
+// Convert J422 to ABGR.
+LIBYUV_API
+int J422ToABGR(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_abgr,
+               int dst_stride_abgr,
+               int width,
+               int height) {
+  return I422ToARGBMatrix(src_y, src_stride_y, src_v,
+                          src_stride_v,  // Swap U and V
+                          src_u, src_stride_u, dst_abgr, dst_stride_abgr,
+                          &kYvuJPEGConstants,  // Use Yvu matrix
+                          width, height);
+}
+
+// Convert H422 to ARGB.
+LIBYUV_API
+int H422ToARGB(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_argb,
+               int dst_stride_argb,
+               int width,
+               int height) {
+  return I422ToARGBMatrix(src_y, src_stride_y, src_u, src_stride_u, src_v,
+                          src_stride_v, dst_argb, dst_stride_argb,
+                          &kYuvH709Constants, width, height);
+}
+
+// Convert H422 to ABGR.
+LIBYUV_API
+int H422ToABGR(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_abgr,
+               int dst_stride_abgr,
+               int width,
+               int height) {
+  return I422ToARGBMatrix(src_y, src_stride_y, src_v,
+                          src_stride_v,  // Swap U and V
+                          src_u, src_stride_u, dst_abgr, dst_stride_abgr,
+                          &kYvuH709Constants,  // Use Yvu matrix
+                          width, height);
+}
+
+// Convert U422 to ARGB.
+LIBYUV_API
+int U422ToARGB(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_argb,
+               int dst_stride_argb,
+               int width,
+               int height) {
+  return I422ToARGBMatrix(src_y, src_stride_y, src_u, src_stride_u, src_v,
+                          src_stride_v, dst_argb, dst_stride_argb,
+                          &kYuv2020Constants, width, height);
+}
+
+// Convert U422 to ABGR.
+LIBYUV_API
+int U422ToABGR(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_abgr,
+               int dst_stride_abgr,
+               int width,
+               int height) {
+  return I422ToARGBMatrix(src_y, src_stride_y, src_v,
+                          src_stride_v,  // Swap U and V
+                          src_u, src_stride_u, dst_abgr, dst_stride_abgr,
+                          &kYvu2020Constants,  // Use Yvu matrix
+                          width, height);
+}
+
+// Convert I444 to ARGB with matrix.
+LIBYUV_API
+int I444ToARGBMatrix(const uint8_t* src_y,
+                     int src_stride_y,
+                     const uint8_t* src_u,
+                     int src_stride_u,
+                     const uint8_t* src_v,
+                     int src_stride_v,
+                     uint8_t* dst_argb,
+                     int dst_stride_argb,
+                     const struct YuvConstants* yuvconstants,
+                     int width,
+                     int height) {
+  int y;
+  void (*I444ToARGBRow)(const uint8_t* y_buf, const uint8_t* u_buf,
+                        const uint8_t* v_buf, uint8_t* rgb_buf,
+                        const struct YuvConstants* yuvconstants, int width) =
+      I444ToARGBRow_C;
+  if (!src_y || !src_u || !src_v || !dst_argb || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    dst_argb = dst_argb + (height - 1) * dst_stride_argb;
+    dst_stride_argb = -dst_stride_argb;
+  }
+  // Coalesce rows.
+  if (src_stride_y == width && src_stride_u == width && src_stride_v == width &&
+      dst_stride_argb == width * 4) {
+    width *= height;
+    height = 1;
+    src_stride_y = src_stride_u = src_stride_v = dst_stride_argb = 0;
+  }
+#if defined(HAS_I444TOARGBROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    I444ToARGBRow = I444ToARGBRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 8)) {
+      I444ToARGBRow = I444ToARGBRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_I444TOARGBROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    I444ToARGBRow = I444ToARGBRow_Any_AVX2;
+    if (IS_ALIGNED(width, 16)) {
+      I444ToARGBRow = I444ToARGBRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_I444TOARGBROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    I444ToARGBRow = I444ToARGBRow_Any_NEON;
+    if (IS_ALIGNED(width, 8)) {
+      I444ToARGBRow = I444ToARGBRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_I444TOARGBROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    I444ToARGBRow = I444ToARGBRow_Any_MSA;
+    if (IS_ALIGNED(width, 8)) {
+      I444ToARGBRow = I444ToARGBRow_MSA;
+    }
+  }
+#endif
+#if defined(HAS_I444TOARGBROW_LSX)
+  if (TestCpuFlag(kCpuHasLSX)) {
+    I444ToARGBRow = I444ToARGBRow_Any_LSX;
+    if (IS_ALIGNED(width, 16)) {
+      I444ToARGBRow = I444ToARGBRow_LSX;
+    }
+  }
+#endif
+
+  for (y = 0; y < height; ++y) {
+    I444ToARGBRow(src_y, src_u, src_v, dst_argb, yuvconstants, width);
+    dst_argb += dst_stride_argb;
+    src_y += src_stride_y;
+    src_u += src_stride_u;
+    src_v += src_stride_v;
+  }
+  return 0;
+}
+
+// Convert I444 to ARGB.
+LIBYUV_API
+int I444ToARGB(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_argb,
+               int dst_stride_argb,
+               int width,
+               int height) {
+  return I444ToARGBMatrix(src_y, src_stride_y, src_u, src_stride_u, src_v,
+                          src_stride_v, dst_argb, dst_stride_argb,
+                          &kYuvI601Constants, width, height);
+}
+
+// Convert I444 to ABGR.
+LIBYUV_API
+int I444ToABGR(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_abgr,
+               int dst_stride_abgr,
+               int width,
+               int height) {
+  return I444ToARGBMatrix(src_y, src_stride_y, src_v,
+                          src_stride_v,  // Swap U and V
+                          src_u, src_stride_u, dst_abgr, dst_stride_abgr,
+                          &kYvuI601Constants,  // Use Yvu matrix
+                          width, height);
+}
+
+// Convert J444 to ARGB.
+LIBYUV_API
+int J444ToARGB(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_argb,
+               int dst_stride_argb,
+               int width,
+               int height) {
+  return I444ToARGBMatrix(src_y, src_stride_y, src_u, src_stride_u, src_v,
+                          src_stride_v, dst_argb, dst_stride_argb,
+                          &kYuvJPEGConstants, width, height);
+}
+
+// Convert J444 to ABGR.
+LIBYUV_API
+int J444ToABGR(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_abgr,
+               int dst_stride_abgr,
+               int width,
+               int height) {
+  return I444ToARGBMatrix(src_y, src_stride_y, src_v,
+                          src_stride_v,  // Swap U and V
+                          src_u, src_stride_u, dst_abgr, dst_stride_abgr,
+                          &kYvuJPEGConstants,  // Use Yvu matrix
+                          width, height);
+}
+
+// Convert H444 to ARGB.
+LIBYUV_API
+int H444ToARGB(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_argb,
+               int dst_stride_argb,
+               int width,
+               int height) {
+  return I444ToARGBMatrix(src_y, src_stride_y, src_u, src_stride_u, src_v,
+                          src_stride_v, dst_argb, dst_stride_argb,
+                          &kYuvH709Constants, width, height);
+}
+
+// Convert H444 to ABGR.
+LIBYUV_API
+int H444ToABGR(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_abgr,
+               int dst_stride_abgr,
+               int width,
+               int height) {
+  return I444ToARGBMatrix(src_y, src_stride_y, src_v,
+                          src_stride_v,  // Swap U and V
+                          src_u, src_stride_u, dst_abgr, dst_stride_abgr,
+                          &kYvuH709Constants,  // Use Yvu matrix
+                          width, height);
+}
+
+// Convert U444 to ARGB.
+LIBYUV_API
+int U444ToARGB(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_argb,
+               int dst_stride_argb,
+               int width,
+               int height) {
+  return I444ToARGBMatrix(src_y, src_stride_y, src_u, src_stride_u, src_v,
+                          src_stride_v, dst_argb, dst_stride_argb,
+                          &kYuv2020Constants, width, height);
+}
+
+// Convert U444 to ABGR.
+LIBYUV_API
+int U444ToABGR(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_abgr,
+               int dst_stride_abgr,
+               int width,
+               int height) {
+  return I444ToARGBMatrix(src_y, src_stride_y, src_v,
+                          src_stride_v,  // Swap U and V
+                          src_u, src_stride_u, dst_abgr, dst_stride_abgr,
+                          &kYvu2020Constants,  // Use Yvu matrix
+                          width, height);
+}
+
+// Convert 10 bit YUV to ARGB with matrix.
+// TODO(fbarchard): Consider passing scale multiplier to I210ToARGB to
+// multiply 10 bit yuv into high bits to allow any number of bits.
+LIBYUV_API
+int I010ToAR30Matrix(const uint16_t* src_y,
+                     int src_stride_y,
+                     const uint16_t* src_u,
+                     int src_stride_u,
+                     const uint16_t* src_v,
+                     int src_stride_v,
+                     uint8_t* dst_ar30,
+                     int dst_stride_ar30,
+                     const struct YuvConstants* yuvconstants,
+                     int width,
+                     int height) {
+  int y;
+  void (*I210ToAR30Row)(const uint16_t* y_buf, const uint16_t* u_buf,
+                        const uint16_t* v_buf, uint8_t* rgb_buf,
+                        const struct YuvConstants* yuvconstants, int width) =
+      I210ToAR30Row_C;
+  if (!src_y || !src_u || !src_v || !dst_ar30 || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    dst_ar30 = dst_ar30 + (height - 1) * dst_stride_ar30;
+    dst_stride_ar30 = -dst_stride_ar30;
+  }
+#if defined(HAS_I210TOAR30ROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    I210ToAR30Row = I210ToAR30Row_Any_SSSE3;
+    if (IS_ALIGNED(width, 8)) {
+      I210ToAR30Row = I210ToAR30Row_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_I210TOAR30ROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    I210ToAR30Row = I210ToAR30Row_Any_AVX2;
+    if (IS_ALIGNED(width, 16)) {
+      I210ToAR30Row = I210ToAR30Row_AVX2;
+    }
+  }
+#endif
+  for (y = 0; y < height; ++y) {
+    I210ToAR30Row(src_y, src_u, src_v, dst_ar30, yuvconstants, width);
+    dst_ar30 += dst_stride_ar30;
+    src_y += src_stride_y;
+    if (y & 1) {
+      src_u += src_stride_u;
+      src_v += src_stride_v;
+    }
+  }
+  return 0;
+}
+
+// Convert I010 to AR30.
+LIBYUV_API
+int I010ToAR30(const uint16_t* src_y,
+               int src_stride_y,
+               const uint16_t* src_u,
+               int src_stride_u,
+               const uint16_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_ar30,
+               int dst_stride_ar30,
+               int width,
+               int height) {
+  return I010ToAR30Matrix(src_y, src_stride_y, src_u, src_stride_u, src_v,
+                          src_stride_v, dst_ar30, dst_stride_ar30,
+                          &kYuvI601Constants, width, height);
+}
+
+// Convert H010 to AR30.
+LIBYUV_API
+int H010ToAR30(const uint16_t* src_y,
+               int src_stride_y,
+               const uint16_t* src_u,
+               int src_stride_u,
+               const uint16_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_ar30,
+               int dst_stride_ar30,
+               int width,
+               int height) {
+  return I010ToAR30Matrix(src_y, src_stride_y, src_u, src_stride_u, src_v,
+                          src_stride_v, dst_ar30, dst_stride_ar30,
+                          &kYuvH709Constants, width, height);
+}
+
+// Convert U010 to AR30.
+LIBYUV_API
+int U010ToAR30(const uint16_t* src_y,
+               int src_stride_y,
+               const uint16_t* src_u,
+               int src_stride_u,
+               const uint16_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_ar30,
+               int dst_stride_ar30,
+               int width,
+               int height) {
+  return I010ToAR30Matrix(src_y, src_stride_y, src_u, src_stride_u, src_v,
+                          src_stride_v, dst_ar30, dst_stride_ar30,
+                          &kYuv2020Constants, width, height);
+}
+
+// Convert I010 to AB30.
+LIBYUV_API
+int I010ToAB30(const uint16_t* src_y,
+               int src_stride_y,
+               const uint16_t* src_u,
+               int src_stride_u,
+               const uint16_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_ab30,
+               int dst_stride_ab30,
+               int width,
+               int height) {
+  return I010ToAR30Matrix(src_y, src_stride_y, src_v, src_stride_v, src_u,
+                          src_stride_u, dst_ab30, dst_stride_ab30,
+                          &kYvuI601Constants, width, height);
+}
+
+// Convert H010 to AB30.
+LIBYUV_API
+int H010ToAB30(const uint16_t* src_y,
+               int src_stride_y,
+               const uint16_t* src_u,
+               int src_stride_u,
+               const uint16_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_ab30,
+               int dst_stride_ab30,
+               int width,
+               int height) {
+  return I010ToAR30Matrix(src_y, src_stride_y, src_v, src_stride_v, src_u,
+                          src_stride_u, dst_ab30, dst_stride_ab30,
+                          &kYvuH709Constants, width, height);
+}
+
+// Convert U010 to AB30.
+LIBYUV_API
+int U010ToAB30(const uint16_t* src_y,
+               int src_stride_y,
+               const uint16_t* src_u,
+               int src_stride_u,
+               const uint16_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_ab30,
+               int dst_stride_ab30,
+               int width,
+               int height) {
+  return I010ToAR30Matrix(src_y, src_stride_y, src_v, src_stride_v, src_u,
+                          src_stride_u, dst_ab30, dst_stride_ab30,
+                          &kYuv2020Constants, width, height);
+}
+
+// Convert 12 bit YUV to ARGB with matrix.
+// TODO(fbarchard): Consider passing scale multiplier to I212ToARGB to
+// multiply 12 bit yuv into high bits to allow any number of bits.
+LIBYUV_API
+int I012ToAR30Matrix(const uint16_t* src_y,
+                     int src_stride_y,
+                     const uint16_t* src_u,
+                     int src_stride_u,
+                     const uint16_t* src_v,
+                     int src_stride_v,
+                     uint8_t* dst_ar30,
+                     int dst_stride_ar30,
+                     const struct YuvConstants* yuvconstants,
+                     int width,
+                     int height) {
+  int y;
+  void (*I212ToAR30Row)(const uint16_t* y_buf, const uint16_t* u_buf,
+                        const uint16_t* v_buf, uint8_t* rgb_buf,
+                        const struct YuvConstants* yuvconstants, int width) =
+      I212ToAR30Row_C;
+  if (!src_y || !src_u || !src_v || !dst_ar30 || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    dst_ar30 = dst_ar30 + (height - 1) * dst_stride_ar30;
+    dst_stride_ar30 = -dst_stride_ar30;
+  }
+#if defined(HAS_I212TOAR30ROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    I212ToAR30Row = I212ToAR30Row_Any_SSSE3;
+    if (IS_ALIGNED(width, 8)) {
+      I212ToAR30Row = I212ToAR30Row_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_I212TOAR30ROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    I212ToAR30Row = I212ToAR30Row_Any_AVX2;
+    if (IS_ALIGNED(width, 16)) {
+      I212ToAR30Row = I212ToAR30Row_AVX2;
+    }
+  }
+#endif
+  for (y = 0; y < height; ++y) {
+    I212ToAR30Row(src_y, src_u, src_v, dst_ar30, yuvconstants, width);
+    dst_ar30 += dst_stride_ar30;
+    src_y += src_stride_y;
+    if (y & 1) {
+      src_u += src_stride_u;
+      src_v += src_stride_v;
+    }
+  }
+  return 0;
+}
+
+// Convert 10 bit YUV to ARGB with matrix.
+// TODO(fbarchard): Consider passing scale multiplier to I210ToARGB to
+// multiply 10 bit yuv into high bits to allow any number of bits.
+LIBYUV_API
+int I210ToAR30Matrix(const uint16_t* src_y,
+                     int src_stride_y,
+                     const uint16_t* src_u,
+                     int src_stride_u,
+                     const uint16_t* src_v,
+                     int src_stride_v,
+                     uint8_t* dst_ar30,
+                     int dst_stride_ar30,
+                     const struct YuvConstants* yuvconstants,
+                     int width,
+                     int height) {
+  int y;
+  void (*I210ToAR30Row)(const uint16_t* y_buf, const uint16_t* u_buf,
+                        const uint16_t* v_buf, uint8_t* rgb_buf,
+                        const struct YuvConstants* yuvconstants, int width) =
+      I210ToAR30Row_C;
+  if (!src_y || !src_u || !src_v || !dst_ar30 || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    dst_ar30 = dst_ar30 + (height - 1) * dst_stride_ar30;
+    dst_stride_ar30 = -dst_stride_ar30;
+  }
+#if defined(HAS_I210TOAR30ROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    I210ToAR30Row = I210ToAR30Row_Any_SSSE3;
+    if (IS_ALIGNED(width, 8)) {
+      I210ToAR30Row = I210ToAR30Row_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_I210TOAR30ROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    I210ToAR30Row = I210ToAR30Row_Any_AVX2;
+    if (IS_ALIGNED(width, 16)) {
+      I210ToAR30Row = I210ToAR30Row_AVX2;
+    }
+  }
+#endif
+  for (y = 0; y < height; ++y) {
+    I210ToAR30Row(src_y, src_u, src_v, dst_ar30, yuvconstants, width);
+    dst_ar30 += dst_stride_ar30;
+    src_y += src_stride_y;
+    src_u += src_stride_u;
+    src_v += src_stride_v;
+  }
+  return 0;
+}
+
+// Convert I210 to AR30.
+LIBYUV_API
+int I210ToAR30(const uint16_t* src_y,
+               int src_stride_y,
+               const uint16_t* src_u,
+               int src_stride_u,
+               const uint16_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_ar30,
+               int dst_stride_ar30,
+               int width,
+               int height) {
+  return I210ToAR30Matrix(src_y, src_stride_y, src_u, src_stride_u, src_v,
+                          src_stride_v, dst_ar30, dst_stride_ar30,
+                          &kYuvI601Constants, width, height);
+}
+
+// Convert H210 to AR30.
+LIBYUV_API
+int H210ToAR30(const uint16_t* src_y,
+               int src_stride_y,
+               const uint16_t* src_u,
+               int src_stride_u,
+               const uint16_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_ar30,
+               int dst_stride_ar30,
+               int width,
+               int height) {
+  return I210ToAR30Matrix(src_y, src_stride_y, src_u, src_stride_u, src_v,
+                          src_stride_v, dst_ar30, dst_stride_ar30,
+                          &kYuvH709Constants, width, height);
+}
+
+// Convert U210 to AR30.
+LIBYUV_API
+int U210ToAR30(const uint16_t* src_y,
+               int src_stride_y,
+               const uint16_t* src_u,
+               int src_stride_u,
+               const uint16_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_ar30,
+               int dst_stride_ar30,
+               int width,
+               int height) {
+  return I210ToAR30Matrix(src_y, src_stride_y, src_u, src_stride_u, src_v,
+                          src_stride_v, dst_ar30, dst_stride_ar30,
+                          &kYuv2020Constants, width, height);
+}
+
+// Convert I210 to AB30.
+LIBYUV_API
+int I210ToAB30(const uint16_t* src_y,
+               int src_stride_y,
+               const uint16_t* src_u,
+               int src_stride_u,
+               const uint16_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_ab30,
+               int dst_stride_ab30,
+               int width,
+               int height) {
+  return I210ToAR30Matrix(src_y, src_stride_y, src_v, src_stride_v, src_u,
+                          src_stride_u, dst_ab30, dst_stride_ab30,
+                          &kYvuI601Constants, width, height);
+}
+
+// Convert H210 to AB30.
+LIBYUV_API
+int H210ToAB30(const uint16_t* src_y,
+               int src_stride_y,
+               const uint16_t* src_u,
+               int src_stride_u,
+               const uint16_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_ab30,
+               int dst_stride_ab30,
+               int width,
+               int height) {
+  return I210ToAR30Matrix(src_y, src_stride_y, src_v, src_stride_v, src_u,
+                          src_stride_u, dst_ab30, dst_stride_ab30,
+                          &kYvuH709Constants, width, height);
+}
+
+// Convert U210 to AB30.
+LIBYUV_API
+int U210ToAB30(const uint16_t* src_y,
+               int src_stride_y,
+               const uint16_t* src_u,
+               int src_stride_u,
+               const uint16_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_ab30,
+               int dst_stride_ab30,
+               int width,
+               int height) {
+  return I210ToAR30Matrix(src_y, src_stride_y, src_v, src_stride_v, src_u,
+                          src_stride_u, dst_ab30, dst_stride_ab30,
+                          &kYuv2020Constants, width, height);
+}
+
+LIBYUV_API
+int I410ToAR30Matrix(const uint16_t* src_y,
+                     int src_stride_y,
+                     const uint16_t* src_u,
+                     int src_stride_u,
+                     const uint16_t* src_v,
+                     int src_stride_v,
+                     uint8_t* dst_ar30,
+                     int dst_stride_ar30,
+                     const struct YuvConstants* yuvconstants,
+                     int width,
+                     int height) {
+  int y;
+  void (*I410ToAR30Row)(const uint16_t* y_buf, const uint16_t* u_buf,
+                        const uint16_t* v_buf, uint8_t* rgb_buf,
+                        const struct YuvConstants* yuvconstants, int width) =
+      I410ToAR30Row_C;
+  if (!src_y || !src_u || !src_v || !dst_ar30 || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    dst_ar30 = dst_ar30 + (height - 1) * dst_stride_ar30;
+    dst_stride_ar30 = -dst_stride_ar30;
+  }
+#if defined(HAS_I410TOAR30ROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    I410ToAR30Row = I410ToAR30Row_Any_SSSE3;
+    if (IS_ALIGNED(width, 8)) {
+      I410ToAR30Row = I410ToAR30Row_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_I410TOAR30ROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    I410ToAR30Row = I410ToAR30Row_Any_AVX2;
+    if (IS_ALIGNED(width, 16)) {
+      I410ToAR30Row = I410ToAR30Row_AVX2;
+    }
+  }
+#endif
+  for (y = 0; y < height; ++y) {
+    I410ToAR30Row(src_y, src_u, src_v, dst_ar30, yuvconstants, width);
+    dst_ar30 += dst_stride_ar30;
+    src_y += src_stride_y;
+    src_u += src_stride_u;
+    src_v += src_stride_v;
+  }
+  return 0;
+}
+
+// Convert 10 bit YUV to ARGB with matrix.
+LIBYUV_API
+int I010ToARGBMatrix(const uint16_t* src_y,
+                     int src_stride_y,
+                     const uint16_t* src_u,
+                     int src_stride_u,
+                     const uint16_t* src_v,
+                     int src_stride_v,
+                     uint8_t* dst_argb,
+                     int dst_stride_argb,
+                     const struct YuvConstants* yuvconstants,
+                     int width,
+                     int height) {
+  int y;
+  void (*I210ToARGBRow)(const uint16_t* y_buf, const uint16_t* u_buf,
+                        const uint16_t* v_buf, uint8_t* rgb_buf,
+                        const struct YuvConstants* yuvconstants, int width) =
+      I210ToARGBRow_C;
+  if (!src_y || !src_u || !src_v || !dst_argb || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    dst_argb = dst_argb + (height - 1) * dst_stride_argb;
+    dst_stride_argb = -dst_stride_argb;
+  }
+#if defined(HAS_I210TOARGBROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    I210ToARGBRow = I210ToARGBRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 8)) {
+      I210ToARGBRow = I210ToARGBRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_I210TOARGBROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    I210ToARGBRow = I210ToARGBRow_Any_AVX2;
+    if (IS_ALIGNED(width, 16)) {
+      I210ToARGBRow = I210ToARGBRow_AVX2;
+    }
+  }
+#endif
+  for (y = 0; y < height; ++y) {
+    I210ToARGBRow(src_y, src_u, src_v, dst_argb, yuvconstants, width);
+    dst_argb += dst_stride_argb;
+    src_y += src_stride_y;
+    if (y & 1) {
+      src_u += src_stride_u;
+      src_v += src_stride_v;
+    }
+  }
+  return 0;
+}
+
+// Convert I010 to ARGB.
+LIBYUV_API
+int I010ToARGB(const uint16_t* src_y,
+               int src_stride_y,
+               const uint16_t* src_u,
+               int src_stride_u,
+               const uint16_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_argb,
+               int dst_stride_argb,
+               int width,
+               int height) {
+  return I010ToARGBMatrix(src_y, src_stride_y, src_u, src_stride_u, src_v,
+                          src_stride_v, dst_argb, dst_stride_argb,
+                          &kYuvI601Constants, width, height);
+}
+
+// Convert I010 to ABGR.
+LIBYUV_API
+int I010ToABGR(const uint16_t* src_y,
+               int src_stride_y,
+               const uint16_t* src_u,
+               int src_stride_u,
+               const uint16_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_abgr,
+               int dst_stride_abgr,
+               int width,
+               int height) {
+  return I010ToARGBMatrix(src_y, src_stride_y, src_v,
+                          src_stride_v,  // Swap U and V
+                          src_u, src_stride_u, dst_abgr, dst_stride_abgr,
+                          &kYvuI601Constants,  // Use Yvu matrix
+                          width, height);
+}
+
+// Convert H010 to ARGB.
+LIBYUV_API
+int H010ToARGB(const uint16_t* src_y,
+               int src_stride_y,
+               const uint16_t* src_u,
+               int src_stride_u,
+               const uint16_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_argb,
+               int dst_stride_argb,
+               int width,
+               int height) {
+  return I010ToARGBMatrix(src_y, src_stride_y, src_u, src_stride_u, src_v,
+                          src_stride_v, dst_argb, dst_stride_argb,
+                          &kYuvH709Constants, width, height);
+}
+
+// Convert H010 to ABGR.
+LIBYUV_API
+int H010ToABGR(const uint16_t* src_y,
+               int src_stride_y,
+               const uint16_t* src_u,
+               int src_stride_u,
+               const uint16_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_abgr,
+               int dst_stride_abgr,
+               int width,
+               int height) {
+  return I010ToARGBMatrix(src_y, src_stride_y, src_v,
+                          src_stride_v,  // Swap U and V
+                          src_u, src_stride_u, dst_abgr, dst_stride_abgr,
+                          &kYvuH709Constants,  // Use Yvu matrix
+                          width, height);
+}
+
+// Convert U010 to ARGB.
+LIBYUV_API
+int U010ToARGB(const uint16_t* src_y,
+               int src_stride_y,
+               const uint16_t* src_u,
+               int src_stride_u,
+               const uint16_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_argb,
+               int dst_stride_argb,
+               int width,
+               int height) {
+  return I010ToARGBMatrix(src_y, src_stride_y, src_u, src_stride_u, src_v,
+                          src_stride_v, dst_argb, dst_stride_argb,
+                          &kYuv2020Constants, width, height);
+}
+
+// Convert U010 to ABGR.
+LIBYUV_API
+int U010ToABGR(const uint16_t* src_y,
+               int src_stride_y,
+               const uint16_t* src_u,
+               int src_stride_u,
+               const uint16_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_abgr,
+               int dst_stride_abgr,
+               int width,
+               int height) {
+  return I010ToARGBMatrix(src_y, src_stride_y, src_v,
+                          src_stride_v,  // Swap U and V
+                          src_u, src_stride_u, dst_abgr, dst_stride_abgr,
+                          &kYvu2020Constants,  // Use Yvu matrix
+                          width, height);
+}
+
+// Convert 12 bit YUV to ARGB with matrix.
+LIBYUV_API
+int I012ToARGBMatrix(const uint16_t* src_y,
+                     int src_stride_y,
+                     const uint16_t* src_u,
+                     int src_stride_u,
+                     const uint16_t* src_v,
+                     int src_stride_v,
+                     uint8_t* dst_argb,
+                     int dst_stride_argb,
+                     const struct YuvConstants* yuvconstants,
+                     int width,
+                     int height) {
+  int y;
+  void (*I212ToARGBRow)(const uint16_t* y_buf, const uint16_t* u_buf,
+                        const uint16_t* v_buf, uint8_t* rgb_buf,
+                        const struct YuvConstants* yuvconstants, int width) =
+      I212ToARGBRow_C;
+  if (!src_y || !src_u || !src_v || !dst_argb || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    dst_argb = dst_argb + (height - 1) * dst_stride_argb;
+    dst_stride_argb = -dst_stride_argb;
+  }
+#if defined(HAS_I212TOARGBROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    I212ToARGBRow = I212ToARGBRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 8)) {
+      I212ToARGBRow = I212ToARGBRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_I212TOARGBROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    I212ToARGBRow = I212ToARGBRow_Any_AVX2;
+    if (IS_ALIGNED(width, 16)) {
+      I212ToARGBRow = I212ToARGBRow_AVX2;
+    }
+  }
+#endif
+  for (y = 0; y < height; ++y) {
+    I212ToARGBRow(src_y, src_u, src_v, dst_argb, yuvconstants, width);
+    dst_argb += dst_stride_argb;
+    src_y += src_stride_y;
+    if (y & 1) {
+      src_u += src_stride_u;
+      src_v += src_stride_v;
+    }
+  }
+  return 0;
+}
+
+// Convert 10 bit 422 YUV to ARGB with matrix.
+LIBYUV_API
+int I210ToARGBMatrix(const uint16_t* src_y,
+                     int src_stride_y,
+                     const uint16_t* src_u,
+                     int src_stride_u,
+                     const uint16_t* src_v,
+                     int src_stride_v,
+                     uint8_t* dst_argb,
+                     int dst_stride_argb,
+                     const struct YuvConstants* yuvconstants,
+                     int width,
+                     int height) {
+  int y;
+  void (*I210ToARGBRow)(const uint16_t* y_buf, const uint16_t* u_buf,
+                        const uint16_t* v_buf, uint8_t* rgb_buf,
+                        const struct YuvConstants* yuvconstants, int width) =
+      I210ToARGBRow_C;
+  if (!src_y || !src_u || !src_v || !dst_argb || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    dst_argb = dst_argb + (height - 1) * dst_stride_argb;
+    dst_stride_argb = -dst_stride_argb;
+  }
+#if defined(HAS_I210TOARGBROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    I210ToARGBRow = I210ToARGBRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 8)) {
+      I210ToARGBRow = I210ToARGBRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_I210TOARGBROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    I210ToARGBRow = I210ToARGBRow_Any_AVX2;
+    if (IS_ALIGNED(width, 16)) {
+      I210ToARGBRow = I210ToARGBRow_AVX2;
+    }
+  }
+#endif
+  for (y = 0; y < height; ++y) {
+    I210ToARGBRow(src_y, src_u, src_v, dst_argb, yuvconstants, width);
+    dst_argb += dst_stride_argb;
+    src_y += src_stride_y;
+    src_u += src_stride_u;
+    src_v += src_stride_v;
+  }
+  return 0;
+}
+
+// Convert I210 to ARGB.
+LIBYUV_API
+int I210ToARGB(const uint16_t* src_y,
+               int src_stride_y,
+               const uint16_t* src_u,
+               int src_stride_u,
+               const uint16_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_argb,
+               int dst_stride_argb,
+               int width,
+               int height) {
+  return I210ToARGBMatrix(src_y, src_stride_y, src_u, src_stride_u, src_v,
+                          src_stride_v, dst_argb, dst_stride_argb,
+                          &kYuvI601Constants, width, height);
+}
+
+// Convert I210 to ABGR.
+LIBYUV_API
+int I210ToABGR(const uint16_t* src_y,
+               int src_stride_y,
+               const uint16_t* src_u,
+               int src_stride_u,
+               const uint16_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_abgr,
+               int dst_stride_abgr,
+               int width,
+               int height) {
+  return I210ToARGBMatrix(src_y, src_stride_y, src_v,
+                          src_stride_v,  // Swap U and V
+                          src_u, src_stride_u, dst_abgr, dst_stride_abgr,
+                          &kYvuI601Constants,  // Use Yvu matrix
+                          width, height);
+}
+
+// Convert H210 to ARGB.
+LIBYUV_API
+int H210ToARGB(const uint16_t* src_y,
+               int src_stride_y,
+               const uint16_t* src_u,
+               int src_stride_u,
+               const uint16_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_argb,
+               int dst_stride_argb,
+               int width,
+               int height) {
+  return I210ToARGBMatrix(src_y, src_stride_y, src_u, src_stride_u, src_v,
+                          src_stride_v, dst_argb, dst_stride_argb,
+                          &kYuvH709Constants, width, height);
+}
+
+// Convert H210 to ABGR.
+LIBYUV_API
+int H210ToABGR(const uint16_t* src_y,
+               int src_stride_y,
+               const uint16_t* src_u,
+               int src_stride_u,
+               const uint16_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_abgr,
+               int dst_stride_abgr,
+               int width,
+               int height) {
+  return I210ToARGBMatrix(src_y, src_stride_y, src_v,
+                          src_stride_v,  // Swap U and V
+                          src_u, src_stride_u, dst_abgr, dst_stride_abgr,
+                          &kYvuH709Constants,  // Use Yvu matrix
+                          width, height);
+}
+
+// Convert U210 to ARGB.
+LIBYUV_API
+int U210ToARGB(const uint16_t* src_y,
+               int src_stride_y,
+               const uint16_t* src_u,
+               int src_stride_u,
+               const uint16_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_argb,
+               int dst_stride_argb,
+               int width,
+               int height) {
+  return I210ToARGBMatrix(src_y, src_stride_y, src_u, src_stride_u, src_v,
+                          src_stride_v, dst_argb, dst_stride_argb,
+                          &kYuv2020Constants, width, height);
+}
+
+// Convert U210 to ABGR.
+LIBYUV_API
+int U210ToABGR(const uint16_t* src_y,
+               int src_stride_y,
+               const uint16_t* src_u,
+               int src_stride_u,
+               const uint16_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_abgr,
+               int dst_stride_abgr,
+               int width,
+               int height) {
+  return I210ToARGBMatrix(src_y, src_stride_y, src_v,
+                          src_stride_v,  // Swap U and V
+                          src_u, src_stride_u, dst_abgr, dst_stride_abgr,
+                          &kYvu2020Constants,  // Use Yvu matrix
+                          width, height);
+}
+
+LIBYUV_API
+int I410ToARGBMatrix(const uint16_t* src_y,
+                     int src_stride_y,
+                     const uint16_t* src_u,
+                     int src_stride_u,
+                     const uint16_t* src_v,
+                     int src_stride_v,
+                     uint8_t* dst_argb,
+                     int dst_stride_argb,
+                     const struct YuvConstants* yuvconstants,
+                     int width,
+                     int height) {
+  int y;
+  void (*I410ToARGBRow)(const uint16_t* y_buf, const uint16_t* u_buf,
+                        const uint16_t* v_buf, uint8_t* rgb_buf,
+                        const struct YuvConstants* yuvconstants, int width) =
+      I410ToARGBRow_C;
+  if (!src_y || !src_u || !src_v || !dst_argb || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    dst_argb = dst_argb + (height - 1) * dst_stride_argb;
+    dst_stride_argb = -dst_stride_argb;
+  }
+#if defined(HAS_I410TOARGBROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    I410ToARGBRow = I410ToARGBRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 8)) {
+      I410ToARGBRow = I410ToARGBRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_I410TOARGBROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    I410ToARGBRow = I410ToARGBRow_Any_AVX2;
+    if (IS_ALIGNED(width, 16)) {
+      I410ToARGBRow = I410ToARGBRow_AVX2;
+    }
+  }
+#endif
+  for (y = 0; y < height; ++y) {
+    I410ToARGBRow(src_y, src_u, src_v, dst_argb, yuvconstants, width);
+    dst_argb += dst_stride_argb;
+    src_y += src_stride_y;
+    src_u += src_stride_u;
+    src_v += src_stride_v;
+  }
+  return 0;
+}
+
+LIBYUV_API
+int P010ToARGBMatrix(const uint16_t* src_y,
+                     int src_stride_y,
+                     const uint16_t* src_uv,
+                     int src_stride_uv,
+                     uint8_t* dst_argb,
+                     int dst_stride_argb,
+                     const struct YuvConstants* yuvconstants,
+                     int width,
+                     int height) {
+  int y;
+  void (*P210ToARGBRow)(
+      const uint16_t* y_buf, const uint16_t* uv_buf, uint8_t* rgb_buf,
+      const struct YuvConstants* yuvconstants, int width) = P210ToARGBRow_C;
+  if (!src_y || !src_uv || !dst_argb || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    dst_argb = dst_argb + (height - 1) * dst_stride_argb;
+    dst_stride_argb = -dst_stride_argb;
+  }
+#if defined(HAS_P210TOARGBROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    P210ToARGBRow = P210ToARGBRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 8)) {
+      P210ToARGBRow = P210ToARGBRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_P210TOARGBROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    P210ToARGBRow = P210ToARGBRow_Any_AVX2;
+    if (IS_ALIGNED(width, 16)) {
+      P210ToARGBRow = P210ToARGBRow_AVX2;
+    }
+  }
+#endif
+  for (y = 0; y < height; ++y) {
+    P210ToARGBRow(src_y, src_uv, dst_argb, yuvconstants, width);
+    dst_argb += dst_stride_argb;
+    src_y += src_stride_y;
+    if (y & 1) {
+      src_uv += src_stride_uv;
+    }
+  }
+  return 0;
+}
+
+LIBYUV_API
+int P210ToARGBMatrix(const uint16_t* src_y,
+                     int src_stride_y,
+                     const uint16_t* src_uv,
+                     int src_stride_uv,
+                     uint8_t* dst_argb,
+                     int dst_stride_argb,
+                     const struct YuvConstants* yuvconstants,
+                     int width,
+                     int height) {
+  int y;
+  void (*P210ToARGBRow)(
+      const uint16_t* y_buf, const uint16_t* uv_buf, uint8_t* rgb_buf,
+      const struct YuvConstants* yuvconstants, int width) = P210ToARGBRow_C;
+  if (!src_y || !src_uv || !dst_argb || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    dst_argb = dst_argb + (height - 1) * dst_stride_argb;
+    dst_stride_argb = -dst_stride_argb;
+  }
+#if defined(HAS_P210TOARGBROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    P210ToARGBRow = P210ToARGBRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 8)) {
+      P210ToARGBRow = P210ToARGBRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_P210TOARGBROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    P210ToARGBRow = P210ToARGBRow_Any_AVX2;
+    if (IS_ALIGNED(width, 16)) {
+      P210ToARGBRow = P210ToARGBRow_AVX2;
+    }
+  }
+#endif
+  for (y = 0; y < height; ++y) {
+    P210ToARGBRow(src_y, src_uv, dst_argb, yuvconstants, width);
+    dst_argb += dst_stride_argb;
+    src_y += src_stride_y;
+    src_uv += src_stride_uv;
+  }
+  return 0;
+}
+
+LIBYUV_API
+int P010ToAR30Matrix(const uint16_t* src_y,
+                     int src_stride_y,
+                     const uint16_t* src_uv,
+                     int src_stride_uv,
+                     uint8_t* dst_ar30,
+                     int dst_stride_ar30,
+                     const struct YuvConstants* yuvconstants,
+                     int width,
+                     int height) {
+  int y;
+  void (*P210ToAR30Row)(
+      const uint16_t* y_buf, const uint16_t* uv_buf, uint8_t* rgb_buf,
+      const struct YuvConstants* yuvconstants, int width) = P210ToAR30Row_C;
+  if (!src_y || !src_uv || !dst_ar30 || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    dst_ar30 = dst_ar30 + (height - 1) * dst_stride_ar30;
+    dst_stride_ar30 = -dst_stride_ar30;
+  }
+#if defined(HAS_P210TOAR30ROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    P210ToAR30Row = P210ToAR30Row_Any_SSSE3;
+    if (IS_ALIGNED(width, 8)) {
+      P210ToAR30Row = P210ToAR30Row_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_P210TOAR30ROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    P210ToAR30Row = P210ToAR30Row_Any_AVX2;
+    if (IS_ALIGNED(width, 16)) {
+      P210ToAR30Row = P210ToAR30Row_AVX2;
+    }
+  }
+#endif
+  for (y = 0; y < height; ++y) {
+    P210ToAR30Row(src_y, src_uv, dst_ar30, yuvconstants, width);
+    dst_ar30 += dst_stride_ar30;
+    src_y += src_stride_y;
+    if (y & 1) {
+      src_uv += src_stride_uv;
+    }
+  }
+  return 0;
+}
+
+LIBYUV_API
+int P210ToAR30Matrix(const uint16_t* src_y,
+                     int src_stride_y,
+                     const uint16_t* src_uv,
+                     int src_stride_uv,
+                     uint8_t* dst_ar30,
+                     int dst_stride_ar30,
+                     const struct YuvConstants* yuvconstants,
+                     int width,
+                     int height) {
+  int y;
+  void (*P210ToAR30Row)(
+      const uint16_t* y_buf, const uint16_t* uv_buf, uint8_t* rgb_buf,
+      const struct YuvConstants* yuvconstants, int width) = P210ToAR30Row_C;
+  if (!src_y || !src_uv || !dst_ar30 || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    dst_ar30 = dst_ar30 + (height - 1) * dst_stride_ar30;
+    dst_stride_ar30 = -dst_stride_ar30;
+  }
+#if defined(HAS_P210TOAR30ROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    P210ToAR30Row = P210ToAR30Row_Any_SSSE3;
+    if (IS_ALIGNED(width, 8)) {
+      P210ToAR30Row = P210ToAR30Row_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_P210TOAR30ROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    P210ToAR30Row = P210ToAR30Row_Any_AVX2;
+    if (IS_ALIGNED(width, 16)) {
+      P210ToAR30Row = P210ToAR30Row_AVX2;
+    }
+  }
+#endif
+  for (y = 0; y < height; ++y) {
+    P210ToAR30Row(src_y, src_uv, dst_ar30, yuvconstants, width);
+    dst_ar30 += dst_stride_ar30;
+    src_y += src_stride_y;
+    src_uv += src_stride_uv;
+  }
+  return 0;
+}
+
+// Convert I420 with Alpha to preattenuated ARGB with matrix.
+LIBYUV_API
+int I420AlphaToARGBMatrix(const uint8_t* src_y,
+                          int src_stride_y,
+                          const uint8_t* src_u,
+                          int src_stride_u,
+                          const uint8_t* src_v,
+                          int src_stride_v,
+                          const uint8_t* src_a,
+                          int src_stride_a,
+                          uint8_t* dst_argb,
+                          int dst_stride_argb,
+                          const struct YuvConstants* yuvconstants,
+                          int width,
+                          int height,
+                          int attenuate) {
+  int y;
+  void (*I422AlphaToARGBRow)(const uint8_t* y_buf, const uint8_t* u_buf,
+                             const uint8_t* v_buf, const uint8_t* a_buf,
+                             uint8_t* dst_argb,
+                             const struct YuvConstants* yuvconstants,
+                             int width) = I422AlphaToARGBRow_C;
+  void (*ARGBAttenuateRow)(const uint8_t* src_argb, uint8_t* dst_argb,
+                           int width) = ARGBAttenuateRow_C;
+  if (!src_y || !src_u || !src_v || !src_a || !dst_argb || width <= 0 ||
+      height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    dst_argb = dst_argb + (height - 1) * dst_stride_argb;
+    dst_stride_argb = -dst_stride_argb;
+  }
+#if defined(HAS_I422ALPHATOARGBROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    I422AlphaToARGBRow = I422AlphaToARGBRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 8)) {
+      I422AlphaToARGBRow = I422AlphaToARGBRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_I422ALPHATOARGBROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    I422AlphaToARGBRow = I422AlphaToARGBRow_Any_AVX2;
+    if (IS_ALIGNED(width, 16)) {
+      I422AlphaToARGBRow = I422AlphaToARGBRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_I422ALPHATOARGBROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    I422AlphaToARGBRow = I422AlphaToARGBRow_Any_NEON;
+    if (IS_ALIGNED(width, 8)) {
+      I422AlphaToARGBRow = I422AlphaToARGBRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_I422ALPHATOARGBROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    I422AlphaToARGBRow = I422AlphaToARGBRow_Any_MSA;
+    if (IS_ALIGNED(width, 8)) {
+      I422AlphaToARGBRow = I422AlphaToARGBRow_MSA;
+    }
+  }
+#endif
+#if defined(HAS_I422ALPHATOARGBROW_LASX)
+  if (TestCpuFlag(kCpuHasLASX)) {
+    I422AlphaToARGBRow = I422AlphaToARGBRow_Any_LASX;
+    if (IS_ALIGNED(width, 16)) {
+      I422AlphaToARGBRow = I422AlphaToARGBRow_LASX;
+    }
+  }
+#endif
+#if defined(HAS_ARGBATTENUATEROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    ARGBAttenuateRow = ARGBAttenuateRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 4)) {
+      ARGBAttenuateRow = ARGBAttenuateRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_ARGBATTENUATEROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ARGBAttenuateRow = ARGBAttenuateRow_Any_AVX2;
+    if (IS_ALIGNED(width, 8)) {
+      ARGBAttenuateRow = ARGBAttenuateRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_ARGBATTENUATEROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    ARGBAttenuateRow = ARGBAttenuateRow_Any_NEON;
+    if (IS_ALIGNED(width, 8)) {
+      ARGBAttenuateRow = ARGBAttenuateRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_ARGBATTENUATEROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    ARGBAttenuateRow = ARGBAttenuateRow_Any_MSA;
+    if (IS_ALIGNED(width, 8)) {
+      ARGBAttenuateRow = ARGBAttenuateRow_MSA;
+    }
+  }
+#endif
+
+  for (y = 0; y < height; ++y) {
+    I422AlphaToARGBRow(src_y, src_u, src_v, src_a, dst_argb, yuvconstants,
+                       width);
+    if (attenuate) {
+      ARGBAttenuateRow(dst_argb, dst_argb, width);
+    }
+    dst_argb += dst_stride_argb;
+    src_a += src_stride_a;
+    src_y += src_stride_y;
+    if (y & 1) {
+      src_u += src_stride_u;
+      src_v += src_stride_v;
+    }
+  }
+  return 0;
+}
+
+// Convert I422 with Alpha to preattenuated ARGB with matrix.
+LIBYUV_API
+int I422AlphaToARGBMatrix(const uint8_t* src_y,
+                          int src_stride_y,
+                          const uint8_t* src_u,
+                          int src_stride_u,
+                          const uint8_t* src_v,
+                          int src_stride_v,
+                          const uint8_t* src_a,
+                          int src_stride_a,
+                          uint8_t* dst_argb,
+                          int dst_stride_argb,
+                          const struct YuvConstants* yuvconstants,
+                          int width,
+                          int height,
+                          int attenuate) {
+  int y;
+  void (*I422AlphaToARGBRow)(const uint8_t* y_buf, const uint8_t* u_buf,
+                             const uint8_t* v_buf, const uint8_t* a_buf,
+                             uint8_t* dst_argb,
+                             const struct YuvConstants* yuvconstants,
+                             int width) = I422AlphaToARGBRow_C;
+  void (*ARGBAttenuateRow)(const uint8_t* src_argb, uint8_t* dst_argb,
+                           int width) = ARGBAttenuateRow_C;
+  if (!src_y || !src_u || !src_v || !src_a || !dst_argb || width <= 0 ||
+      height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    dst_argb = dst_argb + (height - 1) * dst_stride_argb;
+    dst_stride_argb = -dst_stride_argb;
+  }
+#if defined(HAS_I422ALPHATOARGBROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    I422AlphaToARGBRow = I422AlphaToARGBRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 8)) {
+      I422AlphaToARGBRow = I422AlphaToARGBRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_I422ALPHATOARGBROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    I422AlphaToARGBRow = I422AlphaToARGBRow_Any_AVX2;
+    if (IS_ALIGNED(width, 16)) {
+      I422AlphaToARGBRow = I422AlphaToARGBRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_I422ALPHATOARGBROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    I422AlphaToARGBRow = I422AlphaToARGBRow_Any_NEON;
+    if (IS_ALIGNED(width, 8)) {
+      I422AlphaToARGBRow = I422AlphaToARGBRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_I422ALPHATOARGBROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    I422AlphaToARGBRow = I422AlphaToARGBRow_Any_MSA;
+    if (IS_ALIGNED(width, 8)) {
+      I422AlphaToARGBRow = I422AlphaToARGBRow_MSA;
+    }
+  }
+#endif
+#if defined(HAS_I422ALPHATOARGBROW_LASX)
+  if (TestCpuFlag(kCpuHasLASX)) {
+    I422AlphaToARGBRow = I422AlphaToARGBRow_Any_LASX;
+    if (IS_ALIGNED(width, 16)) {
+      I422AlphaToARGBRow = I422AlphaToARGBRow_LASX;
+    }
+  }
+#endif
+#if defined(HAS_ARGBATTENUATEROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    ARGBAttenuateRow = ARGBAttenuateRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 4)) {
+      ARGBAttenuateRow = ARGBAttenuateRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_ARGBATTENUATEROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ARGBAttenuateRow = ARGBAttenuateRow_Any_AVX2;
+    if (IS_ALIGNED(width, 8)) {
+      ARGBAttenuateRow = ARGBAttenuateRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_ARGBATTENUATEROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    ARGBAttenuateRow = ARGBAttenuateRow_Any_NEON;
+    if (IS_ALIGNED(width, 8)) {
+      ARGBAttenuateRow = ARGBAttenuateRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_ARGBATTENUATEROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    ARGBAttenuateRow = ARGBAttenuateRow_Any_MSA;
+    if (IS_ALIGNED(width, 8)) {
+      ARGBAttenuateRow = ARGBAttenuateRow_MSA;
+    }
+  }
+#endif
+
+  for (y = 0; y < height; ++y) {
+    I422AlphaToARGBRow(src_y, src_u, src_v, src_a, dst_argb, yuvconstants,
+                       width);
+    if (attenuate) {
+      ARGBAttenuateRow(dst_argb, dst_argb, width);
+    }
+    dst_argb += dst_stride_argb;
+    src_a += src_stride_a;
+    src_y += src_stride_y;
+    src_u += src_stride_u;
+    src_v += src_stride_v;
+  }
+  return 0;
+}
+
+// Convert I444 with Alpha to preattenuated ARGB with matrix.
+LIBYUV_API
+int I444AlphaToARGBMatrix(const uint8_t* src_y,
+                          int src_stride_y,
+                          const uint8_t* src_u,
+                          int src_stride_u,
+                          const uint8_t* src_v,
+                          int src_stride_v,
+                          const uint8_t* src_a,
+                          int src_stride_a,
+                          uint8_t* dst_argb,
+                          int dst_stride_argb,
+                          const struct YuvConstants* yuvconstants,
+                          int width,
+                          int height,
+                          int attenuate) {
+  int y;
+  void (*I444AlphaToARGBRow)(const uint8_t* y_buf, const uint8_t* u_buf,
+                             const uint8_t* v_buf, const uint8_t* a_buf,
+                             uint8_t* dst_argb,
+                             const struct YuvConstants* yuvconstants,
+                             int width) = I444AlphaToARGBRow_C;
+  void (*ARGBAttenuateRow)(const uint8_t* src_argb, uint8_t* dst_argb,
+                           int width) = ARGBAttenuateRow_C;
+  if (!src_y || !src_u || !src_v || !src_a || !dst_argb || width <= 0 ||
+      height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    dst_argb = dst_argb + (height - 1) * dst_stride_argb;
+    dst_stride_argb = -dst_stride_argb;
+  }
+#if defined(HAS_I444ALPHATOARGBROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    I444AlphaToARGBRow = I444AlphaToARGBRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 8)) {
+      I444AlphaToARGBRow = I444AlphaToARGBRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_I444ALPHATOARGBROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    I444AlphaToARGBRow = I444AlphaToARGBRow_Any_AVX2;
+    if (IS_ALIGNED(width, 16)) {
+      I444AlphaToARGBRow = I444AlphaToARGBRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_I444ALPHATOARGBROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    I444AlphaToARGBRow = I444AlphaToARGBRow_Any_NEON;
+    if (IS_ALIGNED(width, 8)) {
+      I444AlphaToARGBRow = I444AlphaToARGBRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_I444ALPHATOARGBROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    I444AlphaToARGBRow = I444AlphaToARGBRow_Any_MSA;
+    if (IS_ALIGNED(width, 8)) {
+      I444AlphaToARGBRow = I444AlphaToARGBRow_MSA;
+    }
+  }
+#endif
+#if defined(HAS_ARGBATTENUATEROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    ARGBAttenuateRow = ARGBAttenuateRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 4)) {
+      ARGBAttenuateRow = ARGBAttenuateRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_ARGBATTENUATEROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ARGBAttenuateRow = ARGBAttenuateRow_Any_AVX2;
+    if (IS_ALIGNED(width, 8)) {
+      ARGBAttenuateRow = ARGBAttenuateRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_ARGBATTENUATEROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    ARGBAttenuateRow = ARGBAttenuateRow_Any_NEON;
+    if (IS_ALIGNED(width, 8)) {
+      ARGBAttenuateRow = ARGBAttenuateRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_ARGBATTENUATEROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    ARGBAttenuateRow = ARGBAttenuateRow_Any_MSA;
+    if (IS_ALIGNED(width, 8)) {
+      ARGBAttenuateRow = ARGBAttenuateRow_MSA;
+    }
+  }
+#endif
+
+  for (y = 0; y < height; ++y) {
+    I444AlphaToARGBRow(src_y, src_u, src_v, src_a, dst_argb, yuvconstants,
+                       width);
+    if (attenuate) {
+      ARGBAttenuateRow(dst_argb, dst_argb, width);
+    }
+    dst_argb += dst_stride_argb;
+    src_a += src_stride_a;
+    src_y += src_stride_y;
+    src_u += src_stride_u;
+    src_v += src_stride_v;
+  }
+  return 0;
+}
+
+// Convert I420 with Alpha to ARGB.
+LIBYUV_API
+int I420AlphaToARGB(const uint8_t* src_y,
+                    int src_stride_y,
+                    const uint8_t* src_u,
+                    int src_stride_u,
+                    const uint8_t* src_v,
+                    int src_stride_v,
+                    const uint8_t* src_a,
+                    int src_stride_a,
+                    uint8_t* dst_argb,
+                    int dst_stride_argb,
+                    int width,
+                    int height,
+                    int attenuate) {
+  return I420AlphaToARGBMatrix(src_y, src_stride_y, src_u, src_stride_u, src_v,
+                               src_stride_v, src_a, src_stride_a, dst_argb,
+                               dst_stride_argb, &kYuvI601Constants, width,
+                               height, attenuate);
+}
+
+// Convert I420 with Alpha to ABGR.
+LIBYUV_API
+int I420AlphaToABGR(const uint8_t* src_y,
+                    int src_stride_y,
+                    const uint8_t* src_u,
+                    int src_stride_u,
+                    const uint8_t* src_v,
+                    int src_stride_v,
+                    const uint8_t* src_a,
+                    int src_stride_a,
+                    uint8_t* dst_abgr,
+                    int dst_stride_abgr,
+                    int width,
+                    int height,
+                    int attenuate) {
+  return I420AlphaToARGBMatrix(
+      src_y, src_stride_y, src_v, src_stride_v,  // Swap U and V
+      src_u, src_stride_u, src_a, src_stride_a, dst_abgr, dst_stride_abgr,
+      &kYvuI601Constants,  // Use Yvu matrix
+      width, height, attenuate);
+}
+
+// Convert I422 with Alpha to ARGB.
+LIBYUV_API
+int I422AlphaToARGB(const uint8_t* src_y,
+                    int src_stride_y,
+                    const uint8_t* src_u,
+                    int src_stride_u,
+                    const uint8_t* src_v,
+                    int src_stride_v,
+                    const uint8_t* src_a,
+                    int src_stride_a,
+                    uint8_t* dst_argb,
+                    int dst_stride_argb,
+                    int width,
+                    int height,
+                    int attenuate) {
+  return I422AlphaToARGBMatrix(src_y, src_stride_y, src_u, src_stride_u, src_v,
+                               src_stride_v, src_a, src_stride_a, dst_argb,
+                               dst_stride_argb, &kYuvI601Constants, width,
+                               height, attenuate);
+}
+
+// Convert I422 with Alpha to ABGR.
+LIBYUV_API
+int I422AlphaToABGR(const uint8_t* src_y,
+                    int src_stride_y,
+                    const uint8_t* src_u,
+                    int src_stride_u,
+                    const uint8_t* src_v,
+                    int src_stride_v,
+                    const uint8_t* src_a,
+                    int src_stride_a,
+                    uint8_t* dst_abgr,
+                    int dst_stride_abgr,
+                    int width,
+                    int height,
+                    int attenuate) {
+  return I422AlphaToARGBMatrix(
+      src_y, src_stride_y, src_v, src_stride_v,  // Swap U and V
+      src_u, src_stride_u, src_a, src_stride_a, dst_abgr, dst_stride_abgr,
+      &kYvuI601Constants,  // Use Yvu matrix
+      width, height, attenuate);
+}
+
+// Convert I444 with Alpha to ARGB.
+LIBYUV_API
+int I444AlphaToARGB(const uint8_t* src_y,
+                    int src_stride_y,
+                    const uint8_t* src_u,
+                    int src_stride_u,
+                    const uint8_t* src_v,
+                    int src_stride_v,
+                    const uint8_t* src_a,
+                    int src_stride_a,
+                    uint8_t* dst_argb,
+                    int dst_stride_argb,
+                    int width,
+                    int height,
+                    int attenuate) {
+  return I444AlphaToARGBMatrix(src_y, src_stride_y, src_u, src_stride_u, src_v,
+                               src_stride_v, src_a, src_stride_a, dst_argb,
+                               dst_stride_argb, &kYuvI601Constants, width,
+                               height, attenuate);
+}
+
+// Convert I444 with Alpha to ABGR.
+LIBYUV_API
+int I444AlphaToABGR(const uint8_t* src_y,
+                    int src_stride_y,
+                    const uint8_t* src_u,
+                    int src_stride_u,
+                    const uint8_t* src_v,
+                    int src_stride_v,
+                    const uint8_t* src_a,
+                    int src_stride_a,
+                    uint8_t* dst_abgr,
+                    int dst_stride_abgr,
+                    int width,
+                    int height,
+                    int attenuate) {
+  return I444AlphaToARGBMatrix(
+      src_y, src_stride_y, src_v, src_stride_v,  // Swap U and V
+      src_u, src_stride_u, src_a, src_stride_a, dst_abgr, dst_stride_abgr,
+      &kYvuI601Constants,  // Use Yvu matrix
+      width, height, attenuate);
+}
+
+// Convert I010 with Alpha to preattenuated ARGB with matrix.
+LIBYUV_API
+int I010AlphaToARGBMatrix(const uint16_t* src_y,
+                          int src_stride_y,
+                          const uint16_t* src_u,
+                          int src_stride_u,
+                          const uint16_t* src_v,
+                          int src_stride_v,
+                          const uint16_t* src_a,
+                          int src_stride_a,
+                          uint8_t* dst_argb,
+                          int dst_stride_argb,
+                          const struct YuvConstants* yuvconstants,
+                          int width,
+                          int height,
+                          int attenuate) {
+  int y;
+  void (*I210AlphaToARGBRow)(const uint16_t* y_buf, const uint16_t* u_buf,
+                             const uint16_t* v_buf, const uint16_t* a_buf,
+                             uint8_t* dst_argb,
+                             const struct YuvConstants* yuvconstants,
+                             int width) = I210AlphaToARGBRow_C;
+  void (*ARGBAttenuateRow)(const uint8_t* src_argb, uint8_t* dst_argb,
+                           int width) = ARGBAttenuateRow_C;
+  if (!src_y || !src_u || !src_v || !src_a || !dst_argb || width <= 0 ||
+      height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    dst_argb = dst_argb + (height - 1) * dst_stride_argb;
+    dst_stride_argb = -dst_stride_argb;
+  }
+#if defined(HAS_I210ALPHATOARGBROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    I210AlphaToARGBRow = I210AlphaToARGBRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 8)) {
+      I210AlphaToARGBRow = I210AlphaToARGBRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_I210ALPHATOARGBROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    I210AlphaToARGBRow = I210AlphaToARGBRow_Any_AVX2;
+    if (IS_ALIGNED(width, 16)) {
+      I210AlphaToARGBRow = I210AlphaToARGBRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_ARGBATTENUATEROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    ARGBAttenuateRow = ARGBAttenuateRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 4)) {
+      ARGBAttenuateRow = ARGBAttenuateRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_ARGBATTENUATEROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ARGBAttenuateRow = ARGBAttenuateRow_Any_AVX2;
+    if (IS_ALIGNED(width, 8)) {
+      ARGBAttenuateRow = ARGBAttenuateRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_ARGBATTENUATEROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    ARGBAttenuateRow = ARGBAttenuateRow_Any_NEON;
+    if (IS_ALIGNED(width, 8)) {
+      ARGBAttenuateRow = ARGBAttenuateRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_ARGBATTENUATEROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    ARGBAttenuateRow = ARGBAttenuateRow_Any_MSA;
+    if (IS_ALIGNED(width, 8)) {
+      ARGBAttenuateRow = ARGBAttenuateRow_MSA;
+    }
+  }
+#endif
+
+  for (y = 0; y < height; ++y) {
+    I210AlphaToARGBRow(src_y, src_u, src_v, src_a, dst_argb, yuvconstants,
+                       width);
+    if (attenuate) {
+      ARGBAttenuateRow(dst_argb, dst_argb, width);
+    }
+    dst_argb += dst_stride_argb;
+    src_a += src_stride_a;
+    src_y += src_stride_y;
+    if (y & 1) {
+      src_u += src_stride_u;
+      src_v += src_stride_v;
+    }
+  }
+  return 0;
+}
+
+// Convert I210 with Alpha to preattenuated ARGB with matrix.
+LIBYUV_API
+int I210AlphaToARGBMatrix(const uint16_t* src_y,
+                          int src_stride_y,
+                          const uint16_t* src_u,
+                          int src_stride_u,
+                          const uint16_t* src_v,
+                          int src_stride_v,
+                          const uint16_t* src_a,
+                          int src_stride_a,
+                          uint8_t* dst_argb,
+                          int dst_stride_argb,
+                          const struct YuvConstants* yuvconstants,
+                          int width,
+                          int height,
+                          int attenuate) {
+  int y;
+  void (*I210AlphaToARGBRow)(const uint16_t* y_buf, const uint16_t* u_buf,
+                             const uint16_t* v_buf, const uint16_t* a_buf,
+                             uint8_t* dst_argb,
+                             const struct YuvConstants* yuvconstants,
+                             int width) = I210AlphaToARGBRow_C;
+  void (*ARGBAttenuateRow)(const uint8_t* src_argb, uint8_t* dst_argb,
+                           int width) = ARGBAttenuateRow_C;
+  if (!src_y || !src_u || !src_v || !src_a || !dst_argb || width <= 0 ||
+      height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    dst_argb = dst_argb + (height - 1) * dst_stride_argb;
+    dst_stride_argb = -dst_stride_argb;
+  }
+#if defined(HAS_I210ALPHATOARGBROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    I210AlphaToARGBRow = I210AlphaToARGBRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 8)) {
+      I210AlphaToARGBRow = I210AlphaToARGBRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_I210ALPHATOARGBROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    I210AlphaToARGBRow = I210AlphaToARGBRow_Any_AVX2;
+    if (IS_ALIGNED(width, 16)) {
+      I210AlphaToARGBRow = I210AlphaToARGBRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_ARGBATTENUATEROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    ARGBAttenuateRow = ARGBAttenuateRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 4)) {
+      ARGBAttenuateRow = ARGBAttenuateRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_ARGBATTENUATEROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ARGBAttenuateRow = ARGBAttenuateRow_Any_AVX2;
+    if (IS_ALIGNED(width, 8)) {
+      ARGBAttenuateRow = ARGBAttenuateRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_ARGBATTENUATEROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    ARGBAttenuateRow = ARGBAttenuateRow_Any_NEON;
+    if (IS_ALIGNED(width, 8)) {
+      ARGBAttenuateRow = ARGBAttenuateRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_ARGBATTENUATEROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    ARGBAttenuateRow = ARGBAttenuateRow_Any_MSA;
+    if (IS_ALIGNED(width, 8)) {
+      ARGBAttenuateRow = ARGBAttenuateRow_MSA;
+    }
+  }
+#endif
+
+  for (y = 0; y < height; ++y) {
+    I210AlphaToARGBRow(src_y, src_u, src_v, src_a, dst_argb, yuvconstants,
+                       width);
+    if (attenuate) {
+      ARGBAttenuateRow(dst_argb, dst_argb, width);
+    }
+    dst_argb += dst_stride_argb;
+    src_a += src_stride_a;
+    src_y += src_stride_y;
+    src_u += src_stride_u;
+    src_v += src_stride_v;
+  }
+  return 0;
+}
+
+// Convert I410 with Alpha to preattenuated ARGB with matrix.
+LIBYUV_API
+int I410AlphaToARGBMatrix(const uint16_t* src_y,
+                          int src_stride_y,
+                          const uint16_t* src_u,
+                          int src_stride_u,
+                          const uint16_t* src_v,
+                          int src_stride_v,
+                          const uint16_t* src_a,
+                          int src_stride_a,
+                          uint8_t* dst_argb,
+                          int dst_stride_argb,
+                          const struct YuvConstants* yuvconstants,
+                          int width,
+                          int height,
+                          int attenuate) {
+  int y;
+  void (*I410AlphaToARGBRow)(const uint16_t* y_buf, const uint16_t* u_buf,
+                             const uint16_t* v_buf, const uint16_t* a_buf,
+                             uint8_t* dst_argb,
+                             const struct YuvConstants* yuvconstants,
+                             int width) = I410AlphaToARGBRow_C;
+  void (*ARGBAttenuateRow)(const uint8_t* src_argb, uint8_t* dst_argb,
+                           int width) = ARGBAttenuateRow_C;
+  if (!src_y || !src_u || !src_v || !src_a || !dst_argb || width <= 0 ||
+      height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    dst_argb = dst_argb + (height - 1) * dst_stride_argb;
+    dst_stride_argb = -dst_stride_argb;
+  }
+#if defined(HAS_I410ALPHATOARGBROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    I410AlphaToARGBRow = I410AlphaToARGBRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 8)) {
+      I410AlphaToARGBRow = I410AlphaToARGBRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_I410ALPHATOARGBROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    I410AlphaToARGBRow = I410AlphaToARGBRow_Any_AVX2;
+    if (IS_ALIGNED(width, 16)) {
+      I410AlphaToARGBRow = I410AlphaToARGBRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_ARGBATTENUATEROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    ARGBAttenuateRow = ARGBAttenuateRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 4)) {
+      ARGBAttenuateRow = ARGBAttenuateRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_ARGBATTENUATEROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ARGBAttenuateRow = ARGBAttenuateRow_Any_AVX2;
+    if (IS_ALIGNED(width, 8)) {
+      ARGBAttenuateRow = ARGBAttenuateRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_ARGBATTENUATEROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    ARGBAttenuateRow = ARGBAttenuateRow_Any_NEON;
+    if (IS_ALIGNED(width, 8)) {
+      ARGBAttenuateRow = ARGBAttenuateRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_ARGBATTENUATEROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    ARGBAttenuateRow = ARGBAttenuateRow_Any_MSA;
+    if (IS_ALIGNED(width, 8)) {
+      ARGBAttenuateRow = ARGBAttenuateRow_MSA;
+    }
+  }
+#endif
+
+  for (y = 0; y < height; ++y) {
+    I410AlphaToARGBRow(src_y, src_u, src_v, src_a, dst_argb, yuvconstants,
+                       width);
+    if (attenuate) {
+      ARGBAttenuateRow(dst_argb, dst_argb, width);
+    }
+    dst_argb += dst_stride_argb;
+    src_a += src_stride_a;
+    src_y += src_stride_y;
+    src_u += src_stride_u;
+    src_v += src_stride_v;
+  }
+  return 0;
+}
+
+// Convert I400 to ARGB with matrix.
+LIBYUV_API
+int I400ToARGBMatrix(const uint8_t* src_y,
+                     int src_stride_y,
+                     uint8_t* dst_argb,
+                     int dst_stride_argb,
+                     const struct YuvConstants* yuvconstants,
+                     int width,
+                     int height) {
+  int y;
+  void (*I400ToARGBRow)(const uint8_t* y_buf, uint8_t* rgb_buf,
+                        const struct YuvConstants* yuvconstants, int width) =
+      I400ToARGBRow_C;
+  if (!src_y || !dst_argb || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    dst_argb = dst_argb + (height - 1) * dst_stride_argb;
+    dst_stride_argb = -dst_stride_argb;
+  }
+  // Coalesce rows.
+  if (src_stride_y == width && dst_stride_argb == width * 4) {
+    width *= height;
+    height = 1;
+    src_stride_y = dst_stride_argb = 0;
+  }
+#if defined(HAS_I400TOARGBROW_SSE2)
+  if (TestCpuFlag(kCpuHasSSE2)) {
+    I400ToARGBRow = I400ToARGBRow_Any_SSE2;
+    if (IS_ALIGNED(width, 8)) {
+      I400ToARGBRow = I400ToARGBRow_SSE2;
+    }
+  }
+#endif
+#if defined(HAS_I400TOARGBROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    I400ToARGBRow = I400ToARGBRow_Any_AVX2;
+    if (IS_ALIGNED(width, 16)) {
+      I400ToARGBRow = I400ToARGBRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_I400TOARGBROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    I400ToARGBRow = I400ToARGBRow_Any_NEON;
+    if (IS_ALIGNED(width, 8)) {
+      I400ToARGBRow = I400ToARGBRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_I400TOARGBROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    I400ToARGBRow = I400ToARGBRow_Any_MSA;
+    if (IS_ALIGNED(width, 16)) {
+      I400ToARGBRow = I400ToARGBRow_MSA;
+    }
+  }
+#endif
+#if defined(HAS_I400TOARGBROW_LSX)
+  if (TestCpuFlag(kCpuHasLSX)) {
+    I400ToARGBRow = I400ToARGBRow_Any_LSX;
+    if (IS_ALIGNED(width, 16)) {
+      I400ToARGBRow = I400ToARGBRow_LSX;
+    }
+  }
+#endif
+
+  for (y = 0; y < height; ++y) {
+    I400ToARGBRow(src_y, dst_argb, yuvconstants, width);
+    dst_argb += dst_stride_argb;
+    src_y += src_stride_y;
+  }
+  return 0;
+}
+
+// Convert I400 to ARGB.
+LIBYUV_API
+int I400ToARGB(const uint8_t* src_y,
+               int src_stride_y,
+               uint8_t* dst_argb,
+               int dst_stride_argb,
+               int width,
+               int height) {
+  return I400ToARGBMatrix(src_y, src_stride_y, dst_argb, dst_stride_argb,
+                          &kYuvI601Constants, width, height);
+}
+
+// Convert J400 to ARGB.
+LIBYUV_API
+int J400ToARGB(const uint8_t* src_y,
+               int src_stride_y,
+               uint8_t* dst_argb,
+               int dst_stride_argb,
+               int width,
+               int height) {
+  int y;
+  void (*J400ToARGBRow)(const uint8_t* src_y, uint8_t* dst_argb, int width) =
+      J400ToARGBRow_C;
+  if (!src_y || !dst_argb || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    src_y = src_y + (height - 1) * src_stride_y;
+    src_stride_y = -src_stride_y;
+  }
+  // Coalesce rows.
+  if (src_stride_y == width && dst_stride_argb == width * 4) {
+    width *= height;
+    height = 1;
+    src_stride_y = dst_stride_argb = 0;
+  }
+#if defined(HAS_J400TOARGBROW_SSE2)
+  if (TestCpuFlag(kCpuHasSSE2)) {
+    J400ToARGBRow = J400ToARGBRow_Any_SSE2;
+    if (IS_ALIGNED(width, 8)) {
+      J400ToARGBRow = J400ToARGBRow_SSE2;
+    }
+  }
+#endif
+#if defined(HAS_J400TOARGBROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    J400ToARGBRow = J400ToARGBRow_Any_AVX2;
+    if (IS_ALIGNED(width, 16)) {
+      J400ToARGBRow = J400ToARGBRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_J400TOARGBROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    J400ToARGBRow = J400ToARGBRow_Any_NEON;
+    if (IS_ALIGNED(width, 8)) {
+      J400ToARGBRow = J400ToARGBRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_J400TOARGBROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    J400ToARGBRow = J400ToARGBRow_Any_MSA;
+    if (IS_ALIGNED(width, 16)) {
+      J400ToARGBRow = J400ToARGBRow_MSA;
+    }
+  }
+#endif
+#if defined(HAS_J400TOARGBROW_LSX)
+  if (TestCpuFlag(kCpuHasLSX)) {
+    J400ToARGBRow = J400ToARGBRow_Any_LSX;
+    if (IS_ALIGNED(width, 16)) {
+      J400ToARGBRow = J400ToARGBRow_LSX;
+    }
+  }
+#endif
+  for (y = 0; y < height; ++y) {
+    J400ToARGBRow(src_y, dst_argb, width);
+    src_y += src_stride_y;
+    dst_argb += dst_stride_argb;
+  }
+  return 0;
+}
+
+// Shuffle table for converting BGRA to ARGB.
+static const uvec8 kShuffleMaskBGRAToARGB = {
+    3u, 2u, 1u, 0u, 7u, 6u, 5u, 4u, 11u, 10u, 9u, 8u, 15u, 14u, 13u, 12u};
+
+// Shuffle table for converting ABGR to ARGB.
+static const uvec8 kShuffleMaskABGRToARGB = {
+    2u, 1u, 0u, 3u, 6u, 5u, 4u, 7u, 10u, 9u, 8u, 11u, 14u, 13u, 12u, 15u};
+
+// Shuffle table for converting RGBA to ARGB.
+static const uvec8 kShuffleMaskRGBAToARGB = {
+    1u, 2u, 3u, 0u, 5u, 6u, 7u, 4u, 9u, 10u, 11u, 8u, 13u, 14u, 15u, 12u};
+
+// Shuffle table for converting AR64 to AB64.
+static const uvec8 kShuffleMaskAR64ToAB64 = {
+    4u, 5u, 2u, 3u, 0u, 1u, 6u, 7u, 12u, 13u, 10u, 11u, 8u, 9u, 14u, 15u};
+
+// Convert BGRA to ARGB.
+LIBYUV_API
+int BGRAToARGB(const uint8_t* src_bgra,
+               int src_stride_bgra,
+               uint8_t* dst_argb,
+               int dst_stride_argb,
+               int width,
+               int height) {
+  return ARGBShuffle(src_bgra, src_stride_bgra, dst_argb, dst_stride_argb,
+                     (const uint8_t*)&kShuffleMaskBGRAToARGB, width, height);
+}
+
+// Convert ARGB to BGRA (same as BGRAToARGB).
+LIBYUV_API
+int ARGBToBGRA(const uint8_t* src_bgra,
+               int src_stride_bgra,
+               uint8_t* dst_argb,
+               int dst_stride_argb,
+               int width,
+               int height) {
+  return ARGBShuffle(src_bgra, src_stride_bgra, dst_argb, dst_stride_argb,
+                     (const uint8_t*)&kShuffleMaskBGRAToARGB, width, height);
+}
+
+// Convert ABGR to ARGB.
+LIBYUV_API
+int ABGRToARGB(const uint8_t* src_abgr,
+               int src_stride_abgr,
+               uint8_t* dst_argb,
+               int dst_stride_argb,
+               int width,
+               int height) {
+  return ARGBShuffle(src_abgr, src_stride_abgr, dst_argb, dst_stride_argb,
+                     (const uint8_t*)&kShuffleMaskABGRToARGB, width, height);
+}
+
+// Convert ARGB to ABGR to (same as ABGRToARGB).
+LIBYUV_API
+int ARGBToABGR(const uint8_t* src_abgr,
+               int src_stride_abgr,
+               uint8_t* dst_argb,
+               int dst_stride_argb,
+               int width,
+               int height) {
+  return ARGBShuffle(src_abgr, src_stride_abgr, dst_argb, dst_stride_argb,
+                     (const uint8_t*)&kShuffleMaskABGRToARGB, width, height);
+}
+
+// Convert RGBA to ARGB.
+LIBYUV_API
+int RGBAToARGB(const uint8_t* src_rgba,
+               int src_stride_rgba,
+               uint8_t* dst_argb,
+               int dst_stride_argb,
+               int width,
+               int height) {
+  return ARGBShuffle(src_rgba, src_stride_rgba, dst_argb, dst_stride_argb,
+                     (const uint8_t*)&kShuffleMaskRGBAToARGB, width, height);
+}
+
+// Convert AR64 To AB64.
+LIBYUV_API
+int AR64ToAB64(const uint16_t* src_ar64,
+               int src_stride_ar64,
+               uint16_t* dst_ab64,
+               int dst_stride_ab64,
+               int width,
+               int height) {
+  return AR64Shuffle(src_ar64, src_stride_ar64, dst_ab64, dst_stride_ab64,
+                     (const uint8_t*)&kShuffleMaskAR64ToAB64, width, height);
+}
+
+// Convert RGB24 to ARGB.
+LIBYUV_API
+int RGB24ToARGB(const uint8_t* src_rgb24,
+                int src_stride_rgb24,
+                uint8_t* dst_argb,
+                int dst_stride_argb,
+                int width,
+                int height) {
+  int y;
+  void (*RGB24ToARGBRow)(const uint8_t* src_rgb, uint8_t* dst_argb, int width) =
+      RGB24ToARGBRow_C;
+  if (!src_rgb24 || !dst_argb || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    src_rgb24 = src_rgb24 + (height - 1) * src_stride_rgb24;
+    src_stride_rgb24 = -src_stride_rgb24;
+  }
+  // Coalesce rows.
+  if (src_stride_rgb24 == width * 3 && dst_stride_argb == width * 4) {
+    width *= height;
+    height = 1;
+    src_stride_rgb24 = dst_stride_argb = 0;
+  }
+#if defined(HAS_RGB24TOARGBROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    RGB24ToARGBRow = RGB24ToARGBRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 16)) {
+      RGB24ToARGBRow = RGB24ToARGBRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_RGB24TOARGBROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    RGB24ToARGBRow = RGB24ToARGBRow_Any_NEON;
+    if (IS_ALIGNED(width, 8)) {
+      RGB24ToARGBRow = RGB24ToARGBRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_RGB24TOARGBROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    RGB24ToARGBRow = RGB24ToARGBRow_Any_MSA;
+    if (IS_ALIGNED(width, 16)) {
+      RGB24ToARGBRow = RGB24ToARGBRow_MSA;
+    }
+  }
+#endif
+#if defined(HAS_RGB24TOARGBROW_LSX)
+  if (TestCpuFlag(kCpuHasLSX)) {
+    RGB24ToARGBRow = RGB24ToARGBRow_Any_LSX;
+    if (IS_ALIGNED(width, 16)) {
+      RGB24ToARGBRow = RGB24ToARGBRow_LSX;
+    }
+  }
+#endif
+#if defined(HAS_RGB24TOARGBROW_LASX)
+  if (TestCpuFlag(kCpuHasLASX)) {
+    RGB24ToARGBRow = RGB24ToARGBRow_Any_LASX;
+    if (IS_ALIGNED(width, 32)) {
+      RGB24ToARGBRow = RGB24ToARGBRow_LASX;
+    }
+  }
+#endif
+
+  for (y = 0; y < height; ++y) {
+    RGB24ToARGBRow(src_rgb24, dst_argb, width);
+    src_rgb24 += src_stride_rgb24;
+    dst_argb += dst_stride_argb;
+  }
+  return 0;
+}
+
+// Convert RAW to ARGB.
+LIBYUV_API
+int RAWToARGB(const uint8_t* src_raw,
+              int src_stride_raw,
+              uint8_t* dst_argb,
+              int dst_stride_argb,
+              int width,
+              int height) {
+  int y;
+  void (*RAWToARGBRow)(const uint8_t* src_rgb, uint8_t* dst_argb, int width) =
+      RAWToARGBRow_C;
+  if (!src_raw || !dst_argb || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    src_raw = src_raw + (height - 1) * src_stride_raw;
+    src_stride_raw = -src_stride_raw;
+  }
+  // Coalesce rows.
+  if (src_stride_raw == width * 3 && dst_stride_argb == width * 4) {
+    width *= height;
+    height = 1;
+    src_stride_raw = dst_stride_argb = 0;
+  }
+#if defined(HAS_RAWTOARGBROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    RAWToARGBRow = RAWToARGBRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 16)) {
+      RAWToARGBRow = RAWToARGBRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_RAWTOARGBROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    RAWToARGBRow = RAWToARGBRow_Any_NEON;
+    if (IS_ALIGNED(width, 8)) {
+      RAWToARGBRow = RAWToARGBRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_RAWTOARGBROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    RAWToARGBRow = RAWToARGBRow_Any_MSA;
+    if (IS_ALIGNED(width, 16)) {
+      RAWToARGBRow = RAWToARGBRow_MSA;
+    }
+  }
+#endif
+#if defined(HAS_RAWTOARGBROW_LSX)
+  if (TestCpuFlag(kCpuHasLSX)) {
+    RAWToARGBRow = RAWToARGBRow_Any_LSX;
+    if (IS_ALIGNED(width, 16)) {
+      RAWToARGBRow = RAWToARGBRow_LSX;
+    }
+  }
+#endif
+#if defined(HAS_RAWTOARGBROW_LASX)
+  if (TestCpuFlag(kCpuHasLASX)) {
+    RAWToARGBRow = RAWToARGBRow_Any_LASX;
+    if (IS_ALIGNED(width, 32)) {
+      RAWToARGBRow = RAWToARGBRow_LASX;
+    }
+  }
+#endif
+
+  for (y = 0; y < height; ++y) {
+    RAWToARGBRow(src_raw, dst_argb, width);
+    src_raw += src_stride_raw;
+    dst_argb += dst_stride_argb;
+  }
+  return 0;
+}
+
+// Convert RAW to RGBA.
+LIBYUV_API
+int RAWToRGBA(const uint8_t* src_raw,
+              int src_stride_raw,
+              uint8_t* dst_rgba,
+              int dst_stride_rgba,
+              int width,
+              int height) {
+  int y;
+  void (*RAWToRGBARow)(const uint8_t* src_rgb, uint8_t* dst_rgba, int width) =
+      RAWToRGBARow_C;
+  if (!src_raw || !dst_rgba || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    src_raw = src_raw + (height - 1) * src_stride_raw;
+    src_stride_raw = -src_stride_raw;
+  }
+  // Coalesce rows.
+  if (src_stride_raw == width * 3 && dst_stride_rgba == width * 4) {
+    width *= height;
+    height = 1;
+    src_stride_raw = dst_stride_rgba = 0;
+  }
+#if defined(HAS_RAWTORGBAROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    RAWToRGBARow = RAWToRGBARow_Any_SSSE3;
+    if (IS_ALIGNED(width, 16)) {
+      RAWToRGBARow = RAWToRGBARow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_RAWTORGBAROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    RAWToRGBARow = RAWToRGBARow_Any_NEON;
+    if (IS_ALIGNED(width, 8)) {
+      RAWToRGBARow = RAWToRGBARow_NEON;
+    }
+  }
+#endif
+
+  for (y = 0; y < height; ++y) {
+    RAWToRGBARow(src_raw, dst_rgba, width);
+    src_raw += src_stride_raw;
+    dst_rgba += dst_stride_rgba;
+  }
+  return 0;
+}
+
+// Convert RGB565 to ARGB.
+LIBYUV_API
+int RGB565ToARGB(const uint8_t* src_rgb565,
+                 int src_stride_rgb565,
+                 uint8_t* dst_argb,
+                 int dst_stride_argb,
+                 int width,
+                 int height) {
+  int y;
+  void (*RGB565ToARGBRow)(const uint8_t* src_rgb565, uint8_t* dst_argb,
+                          int width) = RGB565ToARGBRow_C;
+  if (!src_rgb565 || !dst_argb || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    src_rgb565 = src_rgb565 + (height - 1) * src_stride_rgb565;
+    src_stride_rgb565 = -src_stride_rgb565;
+  }
+  // Coalesce rows.
+  if (src_stride_rgb565 == width * 2 && dst_stride_argb == width * 4) {
+    width *= height;
+    height = 1;
+    src_stride_rgb565 = dst_stride_argb = 0;
+  }
+#if defined(HAS_RGB565TOARGBROW_SSE2)
+  if (TestCpuFlag(kCpuHasSSE2)) {
+    RGB565ToARGBRow = RGB565ToARGBRow_Any_SSE2;
+    if (IS_ALIGNED(width, 8)) {
+      RGB565ToARGBRow = RGB565ToARGBRow_SSE2;
+    }
+  }
+#endif
+#if defined(HAS_RGB565TOARGBROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    RGB565ToARGBRow = RGB565ToARGBRow_Any_AVX2;
+    if (IS_ALIGNED(width, 16)) {
+      RGB565ToARGBRow = RGB565ToARGBRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_RGB565TOARGBROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    RGB565ToARGBRow = RGB565ToARGBRow_Any_NEON;
+    if (IS_ALIGNED(width, 8)) {
+      RGB565ToARGBRow = RGB565ToARGBRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_RGB565TOARGBROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    RGB565ToARGBRow = RGB565ToARGBRow_Any_MSA;
+    if (IS_ALIGNED(width, 16)) {
+      RGB565ToARGBRow = RGB565ToARGBRow_MSA;
+    }
+  }
+#endif
+#if defined(HAS_RGB565TOARGBROW_LSX)
+  if (TestCpuFlag(kCpuHasLSX)) {
+    RGB565ToARGBRow = RGB565ToARGBRow_Any_LSX;
+    if (IS_ALIGNED(width, 16)) {
+      RGB565ToARGBRow = RGB565ToARGBRow_LSX;
+    }
+  }
+#endif
+#if defined(HAS_RGB565TOARGBROW_LASX)
+  if (TestCpuFlag(kCpuHasLASX)) {
+    RGB565ToARGBRow = RGB565ToARGBRow_Any_LASX;
+    if (IS_ALIGNED(width, 32)) {
+      RGB565ToARGBRow = RGB565ToARGBRow_LASX;
+    }
+  }
+#endif
+
+  for (y = 0; y < height; ++y) {
+    RGB565ToARGBRow(src_rgb565, dst_argb, width);
+    src_rgb565 += src_stride_rgb565;
+    dst_argb += dst_stride_argb;
+  }
+  return 0;
+}
+
+// Convert ARGB1555 to ARGB.
+LIBYUV_API
+int ARGB1555ToARGB(const uint8_t* src_argb1555,
+                   int src_stride_argb1555,
+                   uint8_t* dst_argb,
+                   int dst_stride_argb,
+                   int width,
+                   int height) {
+  int y;
+  void (*ARGB1555ToARGBRow)(const uint8_t* src_argb1555, uint8_t* dst_argb,
+                            int width) = ARGB1555ToARGBRow_C;
+  if (!src_argb1555 || !dst_argb || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    src_argb1555 = src_argb1555 + (height - 1) * src_stride_argb1555;
+    src_stride_argb1555 = -src_stride_argb1555;
+  }
+  // Coalesce rows.
+  if (src_stride_argb1555 == width * 2 && dst_stride_argb == width * 4) {
+    width *= height;
+    height = 1;
+    src_stride_argb1555 = dst_stride_argb = 0;
+  }
+#if defined(HAS_ARGB1555TOARGBROW_SSE2)
+  if (TestCpuFlag(kCpuHasSSE2)) {
+    ARGB1555ToARGBRow = ARGB1555ToARGBRow_Any_SSE2;
+    if (IS_ALIGNED(width, 8)) {
+      ARGB1555ToARGBRow = ARGB1555ToARGBRow_SSE2;
+    }
+  }
+#endif
+#if defined(HAS_ARGB1555TOARGBROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ARGB1555ToARGBRow = ARGB1555ToARGBRow_Any_AVX2;
+    if (IS_ALIGNED(width, 16)) {
+      ARGB1555ToARGBRow = ARGB1555ToARGBRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_ARGB1555TOARGBROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    ARGB1555ToARGBRow = ARGB1555ToARGBRow_Any_NEON;
+    if (IS_ALIGNED(width, 8)) {
+      ARGB1555ToARGBRow = ARGB1555ToARGBRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_ARGB1555TOARGBROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    ARGB1555ToARGBRow = ARGB1555ToARGBRow_Any_MSA;
+    if (IS_ALIGNED(width, 16)) {
+      ARGB1555ToARGBRow = ARGB1555ToARGBRow_MSA;
+    }
+  }
+#endif
+#if defined(HAS_ARGB1555TOARGBROW_LSX)
+  if (TestCpuFlag(kCpuHasLSX)) {
+    ARGB1555ToARGBRow = ARGB1555ToARGBRow_Any_LSX;
+    if (IS_ALIGNED(width, 16)) {
+      ARGB1555ToARGBRow = ARGB1555ToARGBRow_LSX;
+    }
+  }
+#endif
+#if defined(HAS_ARGB1555TOARGBROW_LASX)
+  if (TestCpuFlag(kCpuHasLASX)) {
+    ARGB1555ToARGBRow = ARGB1555ToARGBRow_Any_LASX;
+    if (IS_ALIGNED(width, 32)) {
+      ARGB1555ToARGBRow = ARGB1555ToARGBRow_LASX;
+    }
+  }
+#endif
+
+  for (y = 0; y < height; ++y) {
+    ARGB1555ToARGBRow(src_argb1555, dst_argb, width);
+    src_argb1555 += src_stride_argb1555;
+    dst_argb += dst_stride_argb;
+  }
+  return 0;
+}
+
+// Convert ARGB4444 to ARGB.
+LIBYUV_API
+int ARGB4444ToARGB(const uint8_t* src_argb4444,
+                   int src_stride_argb4444,
+                   uint8_t* dst_argb,
+                   int dst_stride_argb,
+                   int width,
+                   int height) {
+  int y;
+  void (*ARGB4444ToARGBRow)(const uint8_t* src_argb4444, uint8_t* dst_argb,
+                            int width) = ARGB4444ToARGBRow_C;
+  if (!src_argb4444 || !dst_argb || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    src_argb4444 = src_argb4444 + (height - 1) * src_stride_argb4444;
+    src_stride_argb4444 = -src_stride_argb4444;
+  }
+  // Coalesce rows.
+  if (src_stride_argb4444 == width * 2 && dst_stride_argb == width * 4) {
+    width *= height;
+    height = 1;
+    src_stride_argb4444 = dst_stride_argb = 0;
+  }
+#if defined(HAS_ARGB4444TOARGBROW_SSE2)
+  if (TestCpuFlag(kCpuHasSSE2)) {
+    ARGB4444ToARGBRow = ARGB4444ToARGBRow_Any_SSE2;
+    if (IS_ALIGNED(width, 8)) {
+      ARGB4444ToARGBRow = ARGB4444ToARGBRow_SSE2;
+    }
+  }
+#endif
+#if defined(HAS_ARGB4444TOARGBROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ARGB4444ToARGBRow = ARGB4444ToARGBRow_Any_AVX2;
+    if (IS_ALIGNED(width, 16)) {
+      ARGB4444ToARGBRow = ARGB4444ToARGBRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_ARGB4444TOARGBROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    ARGB4444ToARGBRow = ARGB4444ToARGBRow_Any_NEON;
+    if (IS_ALIGNED(width, 8)) {
+      ARGB4444ToARGBRow = ARGB4444ToARGBRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_ARGB4444TOARGBROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    ARGB4444ToARGBRow = ARGB4444ToARGBRow_Any_MSA;
+    if (IS_ALIGNED(width, 16)) {
+      ARGB4444ToARGBRow = ARGB4444ToARGBRow_MSA;
+    }
+  }
+#endif
+#if defined(HAS_ARGB4444TOARGBROW_LSX)
+  if (TestCpuFlag(kCpuHasLSX)) {
+    ARGB4444ToARGBRow = ARGB4444ToARGBRow_Any_LSX;
+    if (IS_ALIGNED(width, 16)) {
+      ARGB4444ToARGBRow = ARGB4444ToARGBRow_LSX;
+    }
+  }
+#endif
+#if defined(HAS_ARGB4444TOARGBROW_LASX)
+  if (TestCpuFlag(kCpuHasLASX)) {
+    ARGB4444ToARGBRow = ARGB4444ToARGBRow_Any_LASX;
+    if (IS_ALIGNED(width, 32)) {
+      ARGB4444ToARGBRow = ARGB4444ToARGBRow_LASX;
+    }
+  }
+#endif
+
+  for (y = 0; y < height; ++y) {
+    ARGB4444ToARGBRow(src_argb4444, dst_argb, width);
+    src_argb4444 += src_stride_argb4444;
+    dst_argb += dst_stride_argb;
+  }
+  return 0;
+}
+
+// Convert AR30 to ARGB.
+LIBYUV_API
+int AR30ToARGB(const uint8_t* src_ar30,
+               int src_stride_ar30,
+               uint8_t* dst_argb,
+               int dst_stride_argb,
+               int width,
+               int height) {
+  int y;
+  if (!src_ar30 || !dst_argb || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    src_ar30 = src_ar30 + (height - 1) * src_stride_ar30;
+    src_stride_ar30 = -src_stride_ar30;
+  }
+  // Coalesce rows.
+  if (src_stride_ar30 == width * 4 && dst_stride_argb == width * 4) {
+    width *= height;
+    height = 1;
+    src_stride_ar30 = dst_stride_argb = 0;
+  }
+  for (y = 0; y < height; ++y) {
+    AR30ToARGBRow_C(src_ar30, dst_argb, width);
+    src_ar30 += src_stride_ar30;
+    dst_argb += dst_stride_argb;
+  }
+  return 0;
+}
+
+// Convert AR30 to ABGR.
+LIBYUV_API
+int AR30ToABGR(const uint8_t* src_ar30,
+               int src_stride_ar30,
+               uint8_t* dst_abgr,
+               int dst_stride_abgr,
+               int width,
+               int height) {
+  int y;
+  if (!src_ar30 || !dst_abgr || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    src_ar30 = src_ar30 + (height - 1) * src_stride_ar30;
+    src_stride_ar30 = -src_stride_ar30;
+  }
+  // Coalesce rows.
+  if (src_stride_ar30 == width * 4 && dst_stride_abgr == width * 4) {
+    width *= height;
+    height = 1;
+    src_stride_ar30 = dst_stride_abgr = 0;
+  }
+  for (y = 0; y < height; ++y) {
+    AR30ToABGRRow_C(src_ar30, dst_abgr, width);
+    src_ar30 += src_stride_ar30;
+    dst_abgr += dst_stride_abgr;
+  }
+  return 0;
+}
+
+// Convert AR30 to AB30.
+LIBYUV_API
+int AR30ToAB30(const uint8_t* src_ar30,
+               int src_stride_ar30,
+               uint8_t* dst_ab30,
+               int dst_stride_ab30,
+               int width,
+               int height) {
+  int y;
+  if (!src_ar30 || !dst_ab30 || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    src_ar30 = src_ar30 + (height - 1) * src_stride_ar30;
+    src_stride_ar30 = -src_stride_ar30;
+  }
+  // Coalesce rows.
+  if (src_stride_ar30 == width * 4 && dst_stride_ab30 == width * 4) {
+    width *= height;
+    height = 1;
+    src_stride_ar30 = dst_stride_ab30 = 0;
+  }
+  for (y = 0; y < height; ++y) {
+    AR30ToAB30Row_C(src_ar30, dst_ab30, width);
+    src_ar30 += src_stride_ar30;
+    dst_ab30 += dst_stride_ab30;
+  }
+  return 0;
+}
+
+// Convert AR64 to ARGB.
+LIBYUV_API
+int AR64ToARGB(const uint16_t* src_ar64,
+               int src_stride_ar64,
+               uint8_t* dst_argb,
+               int dst_stride_argb,
+               int width,
+               int height) {
+  int y;
+  void (*AR64ToARGBRow)(const uint16_t* src_ar64, uint8_t* dst_argb,
+                        int width) = AR64ToARGBRow_C;
+  if (!src_ar64 || !dst_argb || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    src_ar64 = src_ar64 + (height - 1) * src_stride_ar64;
+    src_stride_ar64 = -src_stride_ar64;
+  }
+  // Coalesce rows.
+  if (src_stride_ar64 == width * 4 && dst_stride_argb == width * 4) {
+    width *= height;
+    height = 1;
+    src_stride_ar64 = dst_stride_argb = 0;
+  }
+#if defined(HAS_AR64TOARGBROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    AR64ToARGBRow = AR64ToARGBRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 4)) {
+      AR64ToARGBRow = AR64ToARGBRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_AR64TOARGBROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    AR64ToARGBRow = AR64ToARGBRow_Any_AVX2;
+    if (IS_ALIGNED(width, 8)) {
+      AR64ToARGBRow = AR64ToARGBRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_AR64TOARGBROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    AR64ToARGBRow = AR64ToARGBRow_Any_NEON;
+    if (IS_ALIGNED(width, 8)) {
+      AR64ToARGBRow = AR64ToARGBRow_NEON;
+    }
+  }
+#endif
+
+  for (y = 0; y < height; ++y) {
+    AR64ToARGBRow(src_ar64, dst_argb, width);
+    src_ar64 += src_stride_ar64;
+    dst_argb += dst_stride_argb;
+  }
+  return 0;
+}
+
+// Convert AB64 to ARGB.
+LIBYUV_API
+int AB64ToARGB(const uint16_t* src_ab64,
+               int src_stride_ab64,
+               uint8_t* dst_argb,
+               int dst_stride_argb,
+               int width,
+               int height) {
+  int y;
+  void (*AB64ToARGBRow)(const uint16_t* src_ar64, uint8_t* dst_argb,
+                        int width) = AB64ToARGBRow_C;
+  if (!src_ab64 || !dst_argb || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    src_ab64 = src_ab64 + (height - 1) * src_stride_ab64;
+    src_stride_ab64 = -src_stride_ab64;
+  }
+  // Coalesce rows.
+  if (src_stride_ab64 == width * 4 && dst_stride_argb == width * 4) {
+    width *= height;
+    height = 1;
+    src_stride_ab64 = dst_stride_argb = 0;
+  }
+#if defined(HAS_AB64TOARGBROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    AB64ToARGBRow = AB64ToARGBRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 4)) {
+      AB64ToARGBRow = AB64ToARGBRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_AB64TOARGBROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    AB64ToARGBRow = AB64ToARGBRow_Any_AVX2;
+    if (IS_ALIGNED(width, 8)) {
+      AB64ToARGBRow = AB64ToARGBRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_AB64TOARGBROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    AB64ToARGBRow = AB64ToARGBRow_Any_NEON;
+    if (IS_ALIGNED(width, 8)) {
+      AB64ToARGBRow = AB64ToARGBRow_NEON;
+    }
+  }
+#endif
+
+  for (y = 0; y < height; ++y) {
+    AB64ToARGBRow(src_ab64, dst_argb, width);
+    src_ab64 += src_stride_ab64;
+    dst_argb += dst_stride_argb;
+  }
+  return 0;
+}
+
+// Convert NV12 to ARGB with matrix.
+LIBYUV_API
+int NV12ToARGBMatrix(const uint8_t* src_y,
+                     int src_stride_y,
+                     const uint8_t* src_uv,
+                     int src_stride_uv,
+                     uint8_t* dst_argb,
+                     int dst_stride_argb,
+                     const struct YuvConstants* yuvconstants,
+                     int width,
+                     int height) {
+  int y;
+  void (*NV12ToARGBRow)(
+      const uint8_t* y_buf, const uint8_t* uv_buf, uint8_t* rgb_buf,
+      const struct YuvConstants* yuvconstants, int width) = NV12ToARGBRow_C;
+  if (!src_y || !src_uv || !dst_argb || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    dst_argb = dst_argb + (height - 1) * dst_stride_argb;
+    dst_stride_argb = -dst_stride_argb;
+  }
+#if defined(HAS_NV12TOARGBROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    NV12ToARGBRow = NV12ToARGBRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 8)) {
+      NV12ToARGBRow = NV12ToARGBRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_NV12TOARGBROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    NV12ToARGBRow = NV12ToARGBRow_Any_AVX2;
+    if (IS_ALIGNED(width, 16)) {
+      NV12ToARGBRow = NV12ToARGBRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_NV12TOARGBROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    NV12ToARGBRow = NV12ToARGBRow_Any_NEON;
+    if (IS_ALIGNED(width, 8)) {
+      NV12ToARGBRow = NV12ToARGBRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_NV12TOARGBROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    NV12ToARGBRow = NV12ToARGBRow_Any_MSA;
+    if (IS_ALIGNED(width, 8)) {
+      NV12ToARGBRow = NV12ToARGBRow_MSA;
+    }
+  }
+#endif
+#if defined(HAS_NV12TOARGBROW_LSX)
+  if (TestCpuFlag(kCpuHasLSX)) {
+    NV12ToARGBRow = NV12ToARGBRow_Any_LSX;
+    if (IS_ALIGNED(width, 8)) {
+      NV12ToARGBRow = NV12ToARGBRow_LSX;
+    }
+  }
+#endif
+#if defined(HAS_NV12TOARGBROW_LASX)
+  if (TestCpuFlag(kCpuHasLASX)) {
+    NV12ToARGBRow = NV12ToARGBRow_Any_LASX;
+    if (IS_ALIGNED(width, 16)) {
+      NV12ToARGBRow = NV12ToARGBRow_LASX;
+    }
+  }
+#endif
+
+  for (y = 0; y < height; ++y) {
+    NV12ToARGBRow(src_y, src_uv, dst_argb, yuvconstants, width);
+    dst_argb += dst_stride_argb;
+    src_y += src_stride_y;
+    if (y & 1) {
+      src_uv += src_stride_uv;
+    }
+  }
+  return 0;
+}
+
+// Convert NV21 to ARGB with matrix.
+LIBYUV_API
+int NV21ToARGBMatrix(const uint8_t* src_y,
+                     int src_stride_y,
+                     const uint8_t* src_vu,
+                     int src_stride_vu,
+                     uint8_t* dst_argb,
+                     int dst_stride_argb,
+                     const struct YuvConstants* yuvconstants,
+                     int width,
+                     int height) {
+  int y;
+  void (*NV21ToARGBRow)(
+      const uint8_t* y_buf, const uint8_t* uv_buf, uint8_t* rgb_buf,
+      const struct YuvConstants* yuvconstants, int width) = NV21ToARGBRow_C;
+  if (!src_y || !src_vu || !dst_argb || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    dst_argb = dst_argb + (height - 1) * dst_stride_argb;
+    dst_stride_argb = -dst_stride_argb;
+  }
+#if defined(HAS_NV21TOARGBROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    NV21ToARGBRow = NV21ToARGBRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 8)) {
+      NV21ToARGBRow = NV21ToARGBRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_NV21TOARGBROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    NV21ToARGBRow = NV21ToARGBRow_Any_AVX2;
+    if (IS_ALIGNED(width, 16)) {
+      NV21ToARGBRow = NV21ToARGBRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_NV21TOARGBROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    NV21ToARGBRow = NV21ToARGBRow_Any_NEON;
+    if (IS_ALIGNED(width, 8)) {
+      NV21ToARGBRow = NV21ToARGBRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_NV21TOARGBROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    NV21ToARGBRow = NV21ToARGBRow_Any_MSA;
+    if (IS_ALIGNED(width, 8)) {
+      NV21ToARGBRow = NV21ToARGBRow_MSA;
+    }
+  }
+#endif
+#if defined(HAS_NV21TOARGBROW_LSX)
+  if (TestCpuFlag(kCpuHasLSX)) {
+    NV21ToARGBRow = NV21ToARGBRow_Any_LSX;
+    if (IS_ALIGNED(width, 8)) {
+      NV21ToARGBRow = NV21ToARGBRow_LSX;
+    }
+  }
+#endif
+#if defined(HAS_NV21TOARGBROW_LASX)
+  if (TestCpuFlag(kCpuHasLASX)) {
+    NV21ToARGBRow = NV21ToARGBRow_Any_LASX;
+    if (IS_ALIGNED(width, 16)) {
+      NV21ToARGBRow = NV21ToARGBRow_LASX;
+    }
+  }
+#endif
+
+  for (y = 0; y < height; ++y) {
+    NV21ToARGBRow(src_y, src_vu, dst_argb, yuvconstants, width);
+    dst_argb += dst_stride_argb;
+    src_y += src_stride_y;
+    if (y & 1) {
+      src_vu += src_stride_vu;
+    }
+  }
+  return 0;
+}
+
+// Convert NV12 to ARGB.
+LIBYUV_API
+int NV12ToARGB(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_uv,
+               int src_stride_uv,
+               uint8_t* dst_argb,
+               int dst_stride_argb,
+               int width,
+               int height) {
+  return NV12ToARGBMatrix(src_y, src_stride_y, src_uv, src_stride_uv, dst_argb,
+                          dst_stride_argb, &kYuvI601Constants, width, height);
+}
+
+// Convert NV21 to ARGB.
+LIBYUV_API
+int NV21ToARGB(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_vu,
+               int src_stride_vu,
+               uint8_t* dst_argb,
+               int dst_stride_argb,
+               int width,
+               int height) {
+  return NV21ToARGBMatrix(src_y, src_stride_y, src_vu, src_stride_vu, dst_argb,
+                          dst_stride_argb, &kYuvI601Constants, width, height);
+}
+
+// Convert NV12 to ABGR.
+// To output ABGR instead of ARGB swap the UV and use a mirrored yuv matrix.
+// To swap the UV use NV12 instead of NV21.LIBYUV_API
+LIBYUV_API
+int NV12ToABGR(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_uv,
+               int src_stride_uv,
+               uint8_t* dst_abgr,
+               int dst_stride_abgr,
+               int width,
+               int height) {
+  return NV21ToARGBMatrix(src_y, src_stride_y, src_uv, src_stride_uv, dst_abgr,
+                          dst_stride_abgr, &kYvuI601Constants, width, height);
+}
+
+// Convert NV21 to ABGR.
+LIBYUV_API
+int NV21ToABGR(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_vu,
+               int src_stride_vu,
+               uint8_t* dst_abgr,
+               int dst_stride_abgr,
+               int width,
+               int height) {
+  return NV12ToARGBMatrix(src_y, src_stride_y, src_vu, src_stride_vu, dst_abgr,
+                          dst_stride_abgr, &kYvuI601Constants, width, height);
+}
+
+// TODO(fbarchard): Consider SSSE3 2 step conversion.
+// Convert NV12 to RGB24 with matrix.
+LIBYUV_API
+int NV12ToRGB24Matrix(const uint8_t* src_y,
+                      int src_stride_y,
+                      const uint8_t* src_uv,
+                      int src_stride_uv,
+                      uint8_t* dst_rgb24,
+                      int dst_stride_rgb24,
+                      const struct YuvConstants* yuvconstants,
+                      int width,
+                      int height) {
+  int y;
+  void (*NV12ToRGB24Row)(
+      const uint8_t* y_buf, const uint8_t* uv_buf, uint8_t* rgb_buf,
+      const struct YuvConstants* yuvconstants, int width) = NV12ToRGB24Row_C;
+  if (!src_y || !src_uv || !dst_rgb24 || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    dst_rgb24 = dst_rgb24 + (height - 1) * dst_stride_rgb24;
+    dst_stride_rgb24 = -dst_stride_rgb24;
+  }
+#if defined(HAS_NV12TORGB24ROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    NV12ToRGB24Row = NV12ToRGB24Row_Any_NEON;
+    if (IS_ALIGNED(width, 8)) {
+      NV12ToRGB24Row = NV12ToRGB24Row_NEON;
+    }
+  }
+#endif
+#if defined(HAS_NV12TORGB24ROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    NV12ToRGB24Row = NV12ToRGB24Row_Any_SSSE3;
+    if (IS_ALIGNED(width, 16)) {
+      NV12ToRGB24Row = NV12ToRGB24Row_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_NV12TORGB24ROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    NV12ToRGB24Row = NV12ToRGB24Row_Any_AVX2;
+    if (IS_ALIGNED(width, 32)) {
+      NV12ToRGB24Row = NV12ToRGB24Row_AVX2;
+    }
+  }
+#endif
+
+  for (y = 0; y < height; ++y) {
+    NV12ToRGB24Row(src_y, src_uv, dst_rgb24, yuvconstants, width);
+    dst_rgb24 += dst_stride_rgb24;
+    src_y += src_stride_y;
+    if (y & 1) {
+      src_uv += src_stride_uv;
+    }
+  }
+  return 0;
+}
+
+// Convert NV21 to RGB24 with matrix.
+LIBYUV_API
+int NV21ToRGB24Matrix(const uint8_t* src_y,
+                      int src_stride_y,
+                      const uint8_t* src_vu,
+                      int src_stride_vu,
+                      uint8_t* dst_rgb24,
+                      int dst_stride_rgb24,
+                      const struct YuvConstants* yuvconstants,
+                      int width,
+                      int height) {
+  int y;
+  void (*NV21ToRGB24Row)(
+      const uint8_t* y_buf, const uint8_t* uv_buf, uint8_t* rgb_buf,
+      const struct YuvConstants* yuvconstants, int width) = NV21ToRGB24Row_C;
+  if (!src_y || !src_vu || !dst_rgb24 || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    dst_rgb24 = dst_rgb24 + (height - 1) * dst_stride_rgb24;
+    dst_stride_rgb24 = -dst_stride_rgb24;
+  }
+#if defined(HAS_NV21TORGB24ROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    NV21ToRGB24Row = NV21ToRGB24Row_Any_NEON;
+    if (IS_ALIGNED(width, 8)) {
+      NV21ToRGB24Row = NV21ToRGB24Row_NEON;
+    }
+  }
+#endif
+#if defined(HAS_NV21TORGB24ROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    NV21ToRGB24Row = NV21ToRGB24Row_Any_SSSE3;
+    if (IS_ALIGNED(width, 16)) {
+      NV21ToRGB24Row = NV21ToRGB24Row_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_NV21TORGB24ROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    NV21ToRGB24Row = NV21ToRGB24Row_Any_AVX2;
+    if (IS_ALIGNED(width, 32)) {
+      NV21ToRGB24Row = NV21ToRGB24Row_AVX2;
+    }
+  }
+#endif
+
+  for (y = 0; y < height; ++y) {
+    NV21ToRGB24Row(src_y, src_vu, dst_rgb24, yuvconstants, width);
+    dst_rgb24 += dst_stride_rgb24;
+    src_y += src_stride_y;
+    if (y & 1) {
+      src_vu += src_stride_vu;
+    }
+  }
+  return 0;
+}
+
+// Convert NV12 to RGB24.
+LIBYUV_API
+int NV12ToRGB24(const uint8_t* src_y,
+                int src_stride_y,
+                const uint8_t* src_uv,
+                int src_stride_uv,
+                uint8_t* dst_rgb24,
+                int dst_stride_rgb24,
+                int width,
+                int height) {
+  return NV12ToRGB24Matrix(src_y, src_stride_y, src_uv, src_stride_uv,
+                           dst_rgb24, dst_stride_rgb24, &kYuvI601Constants,
+                           width, height);
+}
+
+// Convert NV21 to RGB24.
+LIBYUV_API
+int NV21ToRGB24(const uint8_t* src_y,
+                int src_stride_y,
+                const uint8_t* src_vu,
+                int src_stride_vu,
+                uint8_t* dst_rgb24,
+                int dst_stride_rgb24,
+                int width,
+                int height) {
+  return NV21ToRGB24Matrix(src_y, src_stride_y, src_vu, src_stride_vu,
+                           dst_rgb24, dst_stride_rgb24, &kYuvI601Constants,
+                           width, height);
+}
+
+// Convert NV12 to RAW.
+LIBYUV_API
+int NV12ToRAW(const uint8_t* src_y,
+              int src_stride_y,
+              const uint8_t* src_uv,
+              int src_stride_uv,
+              uint8_t* dst_raw,
+              int dst_stride_raw,
+              int width,
+              int height) {
+  return NV21ToRGB24Matrix(src_y, src_stride_y, src_uv, src_stride_uv, dst_raw,
+                           dst_stride_raw, &kYvuI601Constants, width, height);
+}
+
+// Convert NV21 to RAW.
+LIBYUV_API
+int NV21ToRAW(const uint8_t* src_y,
+              int src_stride_y,
+              const uint8_t* src_vu,
+              int src_stride_vu,
+              uint8_t* dst_raw,
+              int dst_stride_raw,
+              int width,
+              int height) {
+  return NV12ToRGB24Matrix(src_y, src_stride_y, src_vu, src_stride_vu, dst_raw,
+                           dst_stride_raw, &kYvuI601Constants, width, height);
+}
+
+// Convert NV21 to YUV24
+int NV21ToYUV24(const uint8_t* src_y,
+                int src_stride_y,
+                const uint8_t* src_vu,
+                int src_stride_vu,
+                uint8_t* dst_yuv24,
+                int dst_stride_yuv24,
+                int width,
+                int height) {
+  int y;
+  void (*NV21ToYUV24Row)(const uint8_t* src_y, const uint8_t* src_vu,
+                         uint8_t* dst_yuv24, int width) = NV21ToYUV24Row_C;
+  if (!src_y || !src_vu || !dst_yuv24 || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    dst_yuv24 = dst_yuv24 + (height - 1) * dst_stride_yuv24;
+    dst_stride_yuv24 = -dst_stride_yuv24;
+  }
+#if defined(HAS_NV21TOYUV24ROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    NV21ToYUV24Row = NV21ToYUV24Row_Any_NEON;
+    if (IS_ALIGNED(width, 16)) {
+      NV21ToYUV24Row = NV21ToYUV24Row_NEON;
+    }
+  }
+#endif
+#if defined(HAS_NV21TOYUV24ROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    NV21ToYUV24Row = NV21ToYUV24Row_Any_SSSE3;
+    if (IS_ALIGNED(width, 16)) {
+      NV21ToYUV24Row = NV21ToYUV24Row_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_NV21TOYUV24ROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    NV21ToYUV24Row = NV21ToYUV24Row_Any_AVX2;
+    if (IS_ALIGNED(width, 32)) {
+      NV21ToYUV24Row = NV21ToYUV24Row_AVX2;
+    }
+  }
+#endif
+  for (y = 0; y < height; ++y) {
+    NV21ToYUV24Row(src_y, src_vu, dst_yuv24, width);
+    dst_yuv24 += dst_stride_yuv24;
+    src_y += src_stride_y;
+    if (y & 1) {
+      src_vu += src_stride_vu;
+    }
+  }
+  return 0;
+}
+
+// Convert YUY2 to ARGB.
+LIBYUV_API
+int YUY2ToARGB(const uint8_t* src_yuy2,
+               int src_stride_yuy2,
+               uint8_t* dst_argb,
+               int dst_stride_argb,
+               int width,
+               int height) {
+  int y;
+  void (*YUY2ToARGBRow)(const uint8_t* src_yuy2, uint8_t* dst_argb,
+                        const struct YuvConstants* yuvconstants, int width) =
+      YUY2ToARGBRow_C;
+  if (!src_yuy2 || !dst_argb || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    src_yuy2 = src_yuy2 + (height - 1) * src_stride_yuy2;
+    src_stride_yuy2 = -src_stride_yuy2;
+  }
+  // Coalesce rows.
+  if (src_stride_yuy2 == width * 2 && dst_stride_argb == width * 4) {
+    width *= height;
+    height = 1;
+    src_stride_yuy2 = dst_stride_argb = 0;
+  }
+#if defined(HAS_YUY2TOARGBROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    YUY2ToARGBRow = YUY2ToARGBRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 16)) {
+      YUY2ToARGBRow = YUY2ToARGBRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_YUY2TOARGBROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    YUY2ToARGBRow = YUY2ToARGBRow_Any_AVX2;
+    if (IS_ALIGNED(width, 32)) {
+      YUY2ToARGBRow = YUY2ToARGBRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_YUY2TOARGBROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    YUY2ToARGBRow = YUY2ToARGBRow_Any_NEON;
+    if (IS_ALIGNED(width, 8)) {
+      YUY2ToARGBRow = YUY2ToARGBRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_YUY2TOARGBROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    YUY2ToARGBRow = YUY2ToARGBRow_Any_MSA;
+    if (IS_ALIGNED(width, 8)) {
+      YUY2ToARGBRow = YUY2ToARGBRow_MSA;
+    }
+  }
+#endif
+#if defined(HAS_YUY2TOARGBROW_LSX)
+  if (TestCpuFlag(kCpuHasLSX)) {
+    YUY2ToARGBRow = YUY2ToARGBRow_Any_LSX;
+    if (IS_ALIGNED(width, 8)) {
+      YUY2ToARGBRow = YUY2ToARGBRow_LSX;
+    }
+  }
+#endif
+  for (y = 0; y < height; ++y) {
+    YUY2ToARGBRow(src_yuy2, dst_argb, &kYuvI601Constants, width);
+    src_yuy2 += src_stride_yuy2;
+    dst_argb += dst_stride_argb;
+  }
+  return 0;
+}
+
+// Convert UYVY to ARGB.
+LIBYUV_API
+int UYVYToARGB(const uint8_t* src_uyvy,
+               int src_stride_uyvy,
+               uint8_t* dst_argb,
+               int dst_stride_argb,
+               int width,
+               int height) {
+  int y;
+  void (*UYVYToARGBRow)(const uint8_t* src_uyvy, uint8_t* dst_argb,
+                        const struct YuvConstants* yuvconstants, int width) =
+      UYVYToARGBRow_C;
+  if (!src_uyvy || !dst_argb || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    src_uyvy = src_uyvy + (height - 1) * src_stride_uyvy;
+    src_stride_uyvy = -src_stride_uyvy;
+  }
+  // Coalesce rows.
+  if (src_stride_uyvy == width * 2 && dst_stride_argb == width * 4) {
+    width *= height;
+    height = 1;
+    src_stride_uyvy = dst_stride_argb = 0;
+  }
+#if defined(HAS_UYVYTOARGBROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    UYVYToARGBRow = UYVYToARGBRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 16)) {
+      UYVYToARGBRow = UYVYToARGBRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_UYVYTOARGBROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    UYVYToARGBRow = UYVYToARGBRow_Any_AVX2;
+    if (IS_ALIGNED(width, 32)) {
+      UYVYToARGBRow = UYVYToARGBRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_UYVYTOARGBROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    UYVYToARGBRow = UYVYToARGBRow_Any_NEON;
+    if (IS_ALIGNED(width, 8)) {
+      UYVYToARGBRow = UYVYToARGBRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_UYVYTOARGBROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    UYVYToARGBRow = UYVYToARGBRow_Any_MSA;
+    if (IS_ALIGNED(width, 8)) {
+      UYVYToARGBRow = UYVYToARGBRow_MSA;
+    }
+  }
+#endif
+#if defined(HAS_UYVYTOARGBROW_LSX)
+  if (TestCpuFlag(kCpuHasLSX)) {
+    UYVYToARGBRow = UYVYToARGBRow_Any_LSX;
+    if (IS_ALIGNED(width, 8)) {
+      UYVYToARGBRow = UYVYToARGBRow_LSX;
+    }
+  }
+#endif
+  for (y = 0; y < height; ++y) {
+    UYVYToARGBRow(src_uyvy, dst_argb, &kYuvI601Constants, width);
+    src_uyvy += src_stride_uyvy;
+    dst_argb += dst_stride_argb;
+  }
+  return 0;
+}
+static void WeavePixels(const uint8_t* src_u,
+                        const uint8_t* src_v,
+                        int src_pixel_stride_uv,
+                        uint8_t* dst_uv,
+                        int width) {
+  int i;
+  for (i = 0; i < width; ++i) {
+    dst_uv[0] = *src_u;
+    dst_uv[1] = *src_v;
+    dst_uv += 2;
+    src_u += src_pixel_stride_uv;
+    src_v += src_pixel_stride_uv;
+  }
+}
+
+// Convert Android420 to ARGB with matrix.
+LIBYUV_API
+int Android420ToARGBMatrix(const uint8_t* src_y,
+                           int src_stride_y,
+                           const uint8_t* src_u,
+                           int src_stride_u,
+                           const uint8_t* src_v,
+                           int src_stride_v,
+                           int src_pixel_stride_uv,
+                           uint8_t* dst_argb,
+                           int dst_stride_argb,
+                           const struct YuvConstants* yuvconstants,
+                           int width,
+                           int height) {
+  int y;
+  uint8_t* dst_uv;
+  const ptrdiff_t vu_off = src_v - src_u;
+  int halfwidth = (width + 1) >> 1;
+  int halfheight = (height + 1) >> 1;
+  if (!src_y || !src_u || !src_v || !dst_argb || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    halfheight = (height + 1) >> 1;
+    dst_argb = dst_argb + (height - 1) * dst_stride_argb;
+    dst_stride_argb = -dst_stride_argb;
+  }
+
+  // I420
+  if (src_pixel_stride_uv == 1) {
+    return I420ToARGBMatrix(src_y, src_stride_y, src_u, src_stride_u, src_v,
+                            src_stride_v, dst_argb, dst_stride_argb,
+                            yuvconstants, width, height);
+    // NV21
+  }
+  if (src_pixel_stride_uv == 2 && vu_off == -1 &&
+      src_stride_u == src_stride_v) {
+    return NV21ToARGBMatrix(src_y, src_stride_y, src_v, src_stride_v, dst_argb,
+                            dst_stride_argb, yuvconstants, width, height);
+    // NV12
+  }
+  if (src_pixel_stride_uv == 2 && vu_off == 1 && src_stride_u == src_stride_v) {
+    return NV12ToARGBMatrix(src_y, src_stride_y, src_u, src_stride_u, dst_argb,
+                            dst_stride_argb, yuvconstants, width, height);
+  }
+
+  // General case fallback creates NV12
+  align_buffer_64(plane_uv, halfwidth * 2 * halfheight);
+  dst_uv = plane_uv;
+  for (y = 0; y < halfheight; ++y) {
+    WeavePixels(src_u, src_v, src_pixel_stride_uv, dst_uv, halfwidth);
+    src_u += src_stride_u;
+    src_v += src_stride_v;
+    dst_uv += halfwidth * 2;
+  }
+  NV12ToARGBMatrix(src_y, src_stride_y, plane_uv, halfwidth * 2, dst_argb,
+                   dst_stride_argb, yuvconstants, width, height);
+  free_aligned_buffer_64(plane_uv);
+  return 0;
+}
+
+// Convert Android420 to ARGB.
+LIBYUV_API
+int Android420ToARGB(const uint8_t* src_y,
+                     int src_stride_y,
+                     const uint8_t* src_u,
+                     int src_stride_u,
+                     const uint8_t* src_v,
+                     int src_stride_v,
+                     int src_pixel_stride_uv,
+                     uint8_t* dst_argb,
+                     int dst_stride_argb,
+                     int width,
+                     int height) {
+  return Android420ToARGBMatrix(src_y, src_stride_y, src_u, src_stride_u, src_v,
+                                src_stride_v, src_pixel_stride_uv, dst_argb,
+                                dst_stride_argb, &kYuvI601Constants, width,
+                                height);
+}
+
+// Convert Android420 to ABGR.
+LIBYUV_API
+int Android420ToABGR(const uint8_t* src_y,
+                     int src_stride_y,
+                     const uint8_t* src_u,
+                     int src_stride_u,
+                     const uint8_t* src_v,
+                     int src_stride_v,
+                     int src_pixel_stride_uv,
+                     uint8_t* dst_abgr,
+                     int dst_stride_abgr,
+                     int width,
+                     int height) {
+  return Android420ToARGBMatrix(src_y, src_stride_y, src_v, src_stride_v, src_u,
+                                src_stride_u, src_pixel_stride_uv, dst_abgr,
+                                dst_stride_abgr, &kYvuI601Constants, width,
+                                height);
+}
+
+// Convert I422 to RGBA with matrix.
+LIBYUV_API
+int I422ToRGBAMatrix(const uint8_t* src_y,
+                     int src_stride_y,
+                     const uint8_t* src_u,
+                     int src_stride_u,
+                     const uint8_t* src_v,
+                     int src_stride_v,
+                     uint8_t* dst_rgba,
+                     int dst_stride_rgba,
+                     const struct YuvConstants* yuvconstants,
+                     int width,
+                     int height) {
+  int y;
+  void (*I422ToRGBARow)(const uint8_t* y_buf, const uint8_t* u_buf,
+                        const uint8_t* v_buf, uint8_t* rgb_buf,
+                        const struct YuvConstants* yuvconstants, int width) =
+      I422ToRGBARow_C;
+  if (!src_y || !src_u || !src_v || !dst_rgba || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    dst_rgba = dst_rgba + (height - 1) * dst_stride_rgba;
+    dst_stride_rgba = -dst_stride_rgba;
+  }
+#if defined(HAS_I422TORGBAROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    I422ToRGBARow = I422ToRGBARow_Any_SSSE3;
+    if (IS_ALIGNED(width, 8)) {
+      I422ToRGBARow = I422ToRGBARow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_I422TORGBAROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    I422ToRGBARow = I422ToRGBARow_Any_AVX2;
+    if (IS_ALIGNED(width, 16)) {
+      I422ToRGBARow = I422ToRGBARow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_I422TORGBAROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    I422ToRGBARow = I422ToRGBARow_Any_NEON;
+    if (IS_ALIGNED(width, 8)) {
+      I422ToRGBARow = I422ToRGBARow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_I422TORGBAROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    I422ToRGBARow = I422ToRGBARow_Any_MSA;
+    if (IS_ALIGNED(width, 8)) {
+      I422ToRGBARow = I422ToRGBARow_MSA;
+    }
+  }
+#endif
+#if defined(HAS_I422TORGBAROW_LASX)
+  if (TestCpuFlag(kCpuHasLASX)) {
+    I422ToRGBARow = I422ToRGBARow_Any_LASX;
+    if (IS_ALIGNED(width, 32)) {
+      I422ToRGBARow = I422ToRGBARow_LASX;
+    }
+  }
+#endif
+
+  for (y = 0; y < height; ++y) {
+    I422ToRGBARow(src_y, src_u, src_v, dst_rgba, yuvconstants, width);
+    dst_rgba += dst_stride_rgba;
+    src_y += src_stride_y;
+    src_u += src_stride_u;
+    src_v += src_stride_v;
+  }
+  return 0;
+}
+
+// Convert I422 to RGBA.
+LIBYUV_API
+int I422ToRGBA(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_rgba,
+               int dst_stride_rgba,
+               int width,
+               int height) {
+  return I422ToRGBAMatrix(src_y, src_stride_y, src_u, src_stride_u, src_v,
+                          src_stride_v, dst_rgba, dst_stride_rgba,
+                          &kYuvI601Constants, width, height);
+}
+
+// Convert I422 to BGRA.
+LIBYUV_API
+int I422ToBGRA(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_bgra,
+               int dst_stride_bgra,
+               int width,
+               int height) {
+  return I422ToRGBAMatrix(src_y, src_stride_y, src_v,
+                          src_stride_v,  // Swap U and V
+                          src_u, src_stride_u, dst_bgra, dst_stride_bgra,
+                          &kYvuI601Constants,  // Use Yvu matrix
+                          width, height);
+}
+
+// Convert NV12 to RGB565 with matrix.
+LIBYUV_API
+int NV12ToRGB565Matrix(const uint8_t* src_y,
+                       int src_stride_y,
+                       const uint8_t* src_uv,
+                       int src_stride_uv,
+                       uint8_t* dst_rgb565,
+                       int dst_stride_rgb565,
+                       const struct YuvConstants* yuvconstants,
+                       int width,
+                       int height) {
+  int y;
+  void (*NV12ToRGB565Row)(
+      const uint8_t* y_buf, const uint8_t* uv_buf, uint8_t* rgb_buf,
+      const struct YuvConstants* yuvconstants, int width) = NV12ToRGB565Row_C;
+  if (!src_y || !src_uv || !dst_rgb565 || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    dst_rgb565 = dst_rgb565 + (height - 1) * dst_stride_rgb565;
+    dst_stride_rgb565 = -dst_stride_rgb565;
+  }
+#if defined(HAS_NV12TORGB565ROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    NV12ToRGB565Row = NV12ToRGB565Row_Any_SSSE3;
+    if (IS_ALIGNED(width, 8)) {
+      NV12ToRGB565Row = NV12ToRGB565Row_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_NV12TORGB565ROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    NV12ToRGB565Row = NV12ToRGB565Row_Any_AVX2;
+    if (IS_ALIGNED(width, 16)) {
+      NV12ToRGB565Row = NV12ToRGB565Row_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_NV12TORGB565ROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    NV12ToRGB565Row = NV12ToRGB565Row_Any_NEON;
+    if (IS_ALIGNED(width, 8)) {
+      NV12ToRGB565Row = NV12ToRGB565Row_NEON;
+    }
+  }
+#endif
+#if defined(HAS_NV12TORGB565ROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    NV12ToRGB565Row = NV12ToRGB565Row_Any_MSA;
+    if (IS_ALIGNED(width, 8)) {
+      NV12ToRGB565Row = NV12ToRGB565Row_MSA;
+    }
+  }
+#endif
+#if defined(HAS_NV12TORGB565ROW_LSX)
+  if (TestCpuFlag(kCpuHasLSX)) {
+    NV12ToRGB565Row = NV12ToRGB565Row_Any_LSX;
+    if (IS_ALIGNED(width, 8)) {
+      NV12ToRGB565Row = NV12ToRGB565Row_LSX;
+    }
+  }
+#endif
+#if defined(HAS_NV12TORGB565ROW_LASX)
+  if (TestCpuFlag(kCpuHasLASX)) {
+    NV12ToRGB565Row = NV12ToRGB565Row_Any_LASX;
+    if (IS_ALIGNED(width, 16)) {
+      NV12ToRGB565Row = NV12ToRGB565Row_LASX;
+    }
+  }
+#endif
+
+  for (y = 0; y < height; ++y) {
+    NV12ToRGB565Row(src_y, src_uv, dst_rgb565, yuvconstants, width);
+    dst_rgb565 += dst_stride_rgb565;
+    src_y += src_stride_y;
+    if (y & 1) {
+      src_uv += src_stride_uv;
+    }
+  }
+  return 0;
+}
+
+// Convert NV12 to RGB565.
+LIBYUV_API
+int NV12ToRGB565(const uint8_t* src_y,
+                 int src_stride_y,
+                 const uint8_t* src_uv,
+                 int src_stride_uv,
+                 uint8_t* dst_rgb565,
+                 int dst_stride_rgb565,
+                 int width,
+                 int height) {
+  return NV12ToRGB565Matrix(src_y, src_stride_y, src_uv, src_stride_uv,
+                            dst_rgb565, dst_stride_rgb565, &kYuvI601Constants,
+                            width, height);
+}
+
+// Convert I422 to RGBA with matrix.
+LIBYUV_API
+int I420ToRGBAMatrix(const uint8_t* src_y,
+                     int src_stride_y,
+                     const uint8_t* src_u,
+                     int src_stride_u,
+                     const uint8_t* src_v,
+                     int src_stride_v,
+                     uint8_t* dst_rgba,
+                     int dst_stride_rgba,
+                     const struct YuvConstants* yuvconstants,
+                     int width,
+                     int height) {
+  int y;
+  void (*I422ToRGBARow)(const uint8_t* y_buf, const uint8_t* u_buf,
+                        const uint8_t* v_buf, uint8_t* rgb_buf,
+                        const struct YuvConstants* yuvconstants, int width) =
+      I422ToRGBARow_C;
+  if (!src_y || !src_u || !src_v || !dst_rgba || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    dst_rgba = dst_rgba + (height - 1) * dst_stride_rgba;
+    dst_stride_rgba = -dst_stride_rgba;
+  }
+#if defined(HAS_I422TORGBAROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    I422ToRGBARow = I422ToRGBARow_Any_SSSE3;
+    if (IS_ALIGNED(width, 8)) {
+      I422ToRGBARow = I422ToRGBARow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_I422TORGBAROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    I422ToRGBARow = I422ToRGBARow_Any_AVX2;
+    if (IS_ALIGNED(width, 16)) {
+      I422ToRGBARow = I422ToRGBARow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_I422TORGBAROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    I422ToRGBARow = I422ToRGBARow_Any_NEON;
+    if (IS_ALIGNED(width, 8)) {
+      I422ToRGBARow = I422ToRGBARow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_I422TORGBAROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    I422ToRGBARow = I422ToRGBARow_Any_MSA;
+    if (IS_ALIGNED(width, 8)) {
+      I422ToRGBARow = I422ToRGBARow_MSA;
+    }
+  }
+#endif
+#if defined(HAS_I422TORGBAROW_LASX)
+  if (TestCpuFlag(kCpuHasLASX)) {
+    I422ToRGBARow = I422ToRGBARow_Any_LASX;
+    if (IS_ALIGNED(width, 32)) {
+      I422ToRGBARow = I422ToRGBARow_LASX;
+    }
+  }
+#endif
+
+  for (y = 0; y < height; ++y) {
+    I422ToRGBARow(src_y, src_u, src_v, dst_rgba, yuvconstants, width);
+    dst_rgba += dst_stride_rgba;
+    src_y += src_stride_y;
+    if (y & 1) {
+      src_u += src_stride_u;
+      src_v += src_stride_v;
+    }
+  }
+  return 0;
+}
+
+// Convert I420 to RGBA.
+LIBYUV_API
+int I420ToRGBA(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_rgba,
+               int dst_stride_rgba,
+               int width,
+               int height) {
+  return I420ToRGBAMatrix(src_y, src_stride_y, src_u, src_stride_u, src_v,
+                          src_stride_v, dst_rgba, dst_stride_rgba,
+                          &kYuvI601Constants, width, height);
+}
+
+// Convert I420 to BGRA.
+LIBYUV_API
+int I420ToBGRA(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_bgra,
+               int dst_stride_bgra,
+               int width,
+               int height) {
+  return I420ToRGBAMatrix(src_y, src_stride_y, src_v,
+                          src_stride_v,  // Swap U and V
+                          src_u, src_stride_u, dst_bgra, dst_stride_bgra,
+                          &kYvuI601Constants,  // Use Yvu matrix
+                          width, height);
+}
+
+// Convert I420 to RGB24 with matrix.
+LIBYUV_API
+int I420ToRGB24Matrix(const uint8_t* src_y,
+                      int src_stride_y,
+                      const uint8_t* src_u,
+                      int src_stride_u,
+                      const uint8_t* src_v,
+                      int src_stride_v,
+                      uint8_t* dst_rgb24,
+                      int dst_stride_rgb24,
+                      const struct YuvConstants* yuvconstants,
+                      int width,
+                      int height) {
+  int y;
+  void (*I422ToRGB24Row)(const uint8_t* y_buf, const uint8_t* u_buf,
+                         const uint8_t* v_buf, uint8_t* rgb_buf,
+                         const struct YuvConstants* yuvconstants, int width) =
+      I422ToRGB24Row_C;
+  if (!src_y || !src_u || !src_v || !dst_rgb24 || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    dst_rgb24 = dst_rgb24 + (height - 1) * dst_stride_rgb24;
+    dst_stride_rgb24 = -dst_stride_rgb24;
+  }
+#if defined(HAS_I422TORGB24ROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    I422ToRGB24Row = I422ToRGB24Row_Any_SSSE3;
+    if (IS_ALIGNED(width, 16)) {
+      I422ToRGB24Row = I422ToRGB24Row_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_I422TORGB24ROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    I422ToRGB24Row = I422ToRGB24Row_Any_AVX2;
+    if (IS_ALIGNED(width, 32)) {
+      I422ToRGB24Row = I422ToRGB24Row_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_I422TORGB24ROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    I422ToRGB24Row = I422ToRGB24Row_Any_NEON;
+    if (IS_ALIGNED(width, 8)) {
+      I422ToRGB24Row = I422ToRGB24Row_NEON;
+    }
+  }
+#endif
+#if defined(HAS_I422TORGB24ROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    I422ToRGB24Row = I422ToRGB24Row_Any_MSA;
+    if (IS_ALIGNED(width, 16)) {
+      I422ToRGB24Row = I422ToRGB24Row_MSA;
+    }
+  }
+#endif
+#if defined(HAS_I422TORGB24ROW_LASX)
+  if (TestCpuFlag(kCpuHasLASX)) {
+    I422ToRGB24Row = I422ToRGB24Row_Any_LASX;
+    if (IS_ALIGNED(width, 32)) {
+      I422ToRGB24Row = I422ToRGB24Row_LASX;
+    }
+  }
+#endif
+
+  for (y = 0; y < height; ++y) {
+    I422ToRGB24Row(src_y, src_u, src_v, dst_rgb24, yuvconstants, width);
+    dst_rgb24 += dst_stride_rgb24;
+    src_y += src_stride_y;
+    if (y & 1) {
+      src_u += src_stride_u;
+      src_v += src_stride_v;
+    }
+  }
+  return 0;
+}
+
+// Convert I420 to RGB24.
+LIBYUV_API
+int I420ToRGB24(const uint8_t* src_y,
+                int src_stride_y,
+                const uint8_t* src_u,
+                int src_stride_u,
+                const uint8_t* src_v,
+                int src_stride_v,
+                uint8_t* dst_rgb24,
+                int dst_stride_rgb24,
+                int width,
+                int height) {
+  return I420ToRGB24Matrix(src_y, src_stride_y, src_u, src_stride_u, src_v,
+                           src_stride_v, dst_rgb24, dst_stride_rgb24,
+                           &kYuvI601Constants, width, height);
+}
+
+// Convert I420 to RAW.
+LIBYUV_API
+int I420ToRAW(const uint8_t* src_y,
+              int src_stride_y,
+              const uint8_t* src_u,
+              int src_stride_u,
+              const uint8_t* src_v,
+              int src_stride_v,
+              uint8_t* dst_raw,
+              int dst_stride_raw,
+              int width,
+              int height) {
+  return I420ToRGB24Matrix(src_y, src_stride_y, src_v,
+                           src_stride_v,  // Swap U and V
+                           src_u, src_stride_u, dst_raw, dst_stride_raw,
+                           &kYvuI601Constants,  // Use Yvu matrix
+                           width, height);
+}
+
+// Convert J420 to RGB24.
+LIBYUV_API
+int J420ToRGB24(const uint8_t* src_y,
+                int src_stride_y,
+                const uint8_t* src_u,
+                int src_stride_u,
+                const uint8_t* src_v,
+                int src_stride_v,
+                uint8_t* dst_rgb24,
+                int dst_stride_rgb24,
+                int width,
+                int height) {
+  return I420ToRGB24Matrix(src_y, src_stride_y, src_u, src_stride_u, src_v,
+                           src_stride_v, dst_rgb24, dst_stride_rgb24,
+                           &kYuvJPEGConstants, width, height);
+}
+
+// Convert J420 to RAW.
+LIBYUV_API
+int J420ToRAW(const uint8_t* src_y,
+              int src_stride_y,
+              const uint8_t* src_u,
+              int src_stride_u,
+              const uint8_t* src_v,
+              int src_stride_v,
+              uint8_t* dst_raw,
+              int dst_stride_raw,
+              int width,
+              int height) {
+  return I420ToRGB24Matrix(src_y, src_stride_y, src_v,
+                           src_stride_v,  // Swap U and V
+                           src_u, src_stride_u, dst_raw, dst_stride_raw,
+                           &kYvuJPEGConstants,  // Use Yvu matrix
+                           width, height);
+}
+
+// Convert H420 to RGB24.
+LIBYUV_API
+int H420ToRGB24(const uint8_t* src_y,
+                int src_stride_y,
+                const uint8_t* src_u,
+                int src_stride_u,
+                const uint8_t* src_v,
+                int src_stride_v,
+                uint8_t* dst_rgb24,
+                int dst_stride_rgb24,
+                int width,
+                int height) {
+  return I420ToRGB24Matrix(src_y, src_stride_y, src_u, src_stride_u, src_v,
+                           src_stride_v, dst_rgb24, dst_stride_rgb24,
+                           &kYuvH709Constants, width, height);
+}
+
+// Convert H420 to RAW.
+LIBYUV_API
+int H420ToRAW(const uint8_t* src_y,
+              int src_stride_y,
+              const uint8_t* src_u,
+              int src_stride_u,
+              const uint8_t* src_v,
+              int src_stride_v,
+              uint8_t* dst_raw,
+              int dst_stride_raw,
+              int width,
+              int height) {
+  return I420ToRGB24Matrix(src_y, src_stride_y, src_v,
+                           src_stride_v,  // Swap U and V
+                           src_u, src_stride_u, dst_raw, dst_stride_raw,
+                           &kYvuH709Constants,  // Use Yvu matrix
+                           width, height);
+}
+
+// Convert I420 to ARGB1555.
+LIBYUV_API
+int I420ToARGB1555(const uint8_t* src_y,
+                   int src_stride_y,
+                   const uint8_t* src_u,
+                   int src_stride_u,
+                   const uint8_t* src_v,
+                   int src_stride_v,
+                   uint8_t* dst_argb1555,
+                   int dst_stride_argb1555,
+                   int width,
+                   int height) {
+  int y;
+  void (*I422ToARGB1555Row)(const uint8_t* y_buf, const uint8_t* u_buf,
+                            const uint8_t* v_buf, uint8_t* rgb_buf,
+                            const struct YuvConstants* yuvconstants,
+                            int width) = I422ToARGB1555Row_C;
+  if (!src_y || !src_u || !src_v || !dst_argb1555 || width <= 0 ||
+      height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    dst_argb1555 = dst_argb1555 + (height - 1) * dst_stride_argb1555;
+    dst_stride_argb1555 = -dst_stride_argb1555;
+  }
+#if defined(HAS_I422TOARGB1555ROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    I422ToARGB1555Row = I422ToARGB1555Row_Any_SSSE3;
+    if (IS_ALIGNED(width, 8)) {
+      I422ToARGB1555Row = I422ToARGB1555Row_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_I422TOARGB1555ROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    I422ToARGB1555Row = I422ToARGB1555Row_Any_AVX2;
+    if (IS_ALIGNED(width, 16)) {
+      I422ToARGB1555Row = I422ToARGB1555Row_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_I422TOARGB1555ROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    I422ToARGB1555Row = I422ToARGB1555Row_Any_NEON;
+    if (IS_ALIGNED(width, 8)) {
+      I422ToARGB1555Row = I422ToARGB1555Row_NEON;
+    }
+  }
+#endif
+#if defined(HAS_I422TOARGB1555ROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    I422ToARGB1555Row = I422ToARGB1555Row_Any_MSA;
+    if (IS_ALIGNED(width, 8)) {
+      I422ToARGB1555Row = I422ToARGB1555Row_MSA;
+    }
+  }
+#endif
+#if defined(HAS_I422TOARGB1555ROW_LASX)
+  if (TestCpuFlag(kCpuHasLASX)) {
+    I422ToARGB1555Row = I422ToARGB1555Row_Any_LASX;
+    if (IS_ALIGNED(width, 8)) {
+      I422ToARGB1555Row = I422ToARGB1555Row_LASX;
+    }
+  }
+#endif
+
+  for (y = 0; y < height; ++y) {
+    I422ToARGB1555Row(src_y, src_u, src_v, dst_argb1555, &kYuvI601Constants,
+                      width);
+    dst_argb1555 += dst_stride_argb1555;
+    src_y += src_stride_y;
+    if (y & 1) {
+      src_u += src_stride_u;
+      src_v += src_stride_v;
+    }
+  }
+  return 0;
+}
+
+// Convert I420 to ARGB4444.
+LIBYUV_API
+int I420ToARGB4444(const uint8_t* src_y,
+                   int src_stride_y,
+                   const uint8_t* src_u,
+                   int src_stride_u,
+                   const uint8_t* src_v,
+                   int src_stride_v,
+                   uint8_t* dst_argb4444,
+                   int dst_stride_argb4444,
+                   int width,
+                   int height) {
+  int y;
+  void (*I422ToARGB4444Row)(const uint8_t* y_buf, const uint8_t* u_buf,
+                            const uint8_t* v_buf, uint8_t* rgb_buf,
+                            const struct YuvConstants* yuvconstants,
+                            int width) = I422ToARGB4444Row_C;
+  if (!src_y || !src_u || !src_v || !dst_argb4444 || width <= 0 ||
+      height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    dst_argb4444 = dst_argb4444 + (height - 1) * dst_stride_argb4444;
+    dst_stride_argb4444 = -dst_stride_argb4444;
+  }
+#if defined(HAS_I422TOARGB4444ROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    I422ToARGB4444Row = I422ToARGB4444Row_Any_SSSE3;
+    if (IS_ALIGNED(width, 8)) {
+      I422ToARGB4444Row = I422ToARGB4444Row_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_I422TOARGB4444ROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    I422ToARGB4444Row = I422ToARGB4444Row_Any_AVX2;
+    if (IS_ALIGNED(width, 16)) {
+      I422ToARGB4444Row = I422ToARGB4444Row_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_I422TOARGB4444ROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    I422ToARGB4444Row = I422ToARGB4444Row_Any_NEON;
+    if (IS_ALIGNED(width, 8)) {
+      I422ToARGB4444Row = I422ToARGB4444Row_NEON;
+    }
+  }
+#endif
+#if defined(HAS_I422TOARGB4444ROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    I422ToARGB4444Row = I422ToARGB4444Row_Any_MSA;
+    if (IS_ALIGNED(width, 8)) {
+      I422ToARGB4444Row = I422ToARGB4444Row_MSA;
+    }
+  }
+#endif
+#if defined(HAS_I422TOARGB4444ROW_LASX)
+  if (TestCpuFlag(kCpuHasLASX)) {
+    I422ToARGB4444Row = I422ToARGB4444Row_Any_LASX;
+    if (IS_ALIGNED(width, 8)) {
+      I422ToARGB4444Row = I422ToARGB4444Row_LASX;
+    }
+  }
+#endif
+
+  for (y = 0; y < height; ++y) {
+    I422ToARGB4444Row(src_y, src_u, src_v, dst_argb4444, &kYuvI601Constants,
+                      width);
+    dst_argb4444 += dst_stride_argb4444;
+    src_y += src_stride_y;
+    if (y & 1) {
+      src_u += src_stride_u;
+      src_v += src_stride_v;
+    }
+  }
+  return 0;
+}
+
+// Convert I420 to RGB565 with specified color matrix.
+LIBYUV_API
+int I420ToRGB565Matrix(const uint8_t* src_y,
+                       int src_stride_y,
+                       const uint8_t* src_u,
+                       int src_stride_u,
+                       const uint8_t* src_v,
+                       int src_stride_v,
+                       uint8_t* dst_rgb565,
+                       int dst_stride_rgb565,
+                       const struct YuvConstants* yuvconstants,
+                       int width,
+                       int height) {
+  int y;
+  void (*I422ToRGB565Row)(const uint8_t* y_buf, const uint8_t* u_buf,
+                          const uint8_t* v_buf, uint8_t* rgb_buf,
+                          const struct YuvConstants* yuvconstants, int width) =
+      I422ToRGB565Row_C;
+  if (!src_y || !src_u || !src_v || !dst_rgb565 || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    dst_rgb565 = dst_rgb565 + (height - 1) * dst_stride_rgb565;
+    dst_stride_rgb565 = -dst_stride_rgb565;
+  }
+#if defined(HAS_I422TORGB565ROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    I422ToRGB565Row = I422ToRGB565Row_Any_SSSE3;
+    if (IS_ALIGNED(width, 8)) {
+      I422ToRGB565Row = I422ToRGB565Row_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_I422TORGB565ROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    I422ToRGB565Row = I422ToRGB565Row_Any_AVX2;
+    if (IS_ALIGNED(width, 16)) {
+      I422ToRGB565Row = I422ToRGB565Row_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_I422TORGB565ROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    I422ToRGB565Row = I422ToRGB565Row_Any_NEON;
+    if (IS_ALIGNED(width, 8)) {
+      I422ToRGB565Row = I422ToRGB565Row_NEON;
+    }
+  }
+#endif
+#if defined(HAS_I422TORGB565ROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    I422ToRGB565Row = I422ToRGB565Row_Any_MSA;
+    if (IS_ALIGNED(width, 8)) {
+      I422ToRGB565Row = I422ToRGB565Row_MSA;
+    }
+  }
+#endif
+#if defined(HAS_I422TORGB565ROW_LASX)
+  if (TestCpuFlag(kCpuHasLASX)) {
+    I422ToRGB565Row = I422ToRGB565Row_Any_LASX;
+    if (IS_ALIGNED(width, 32)) {
+      I422ToRGB565Row = I422ToRGB565Row_LASX;
+    }
+  }
+#endif
+
+  for (y = 0; y < height; ++y) {
+    I422ToRGB565Row(src_y, src_u, src_v, dst_rgb565, yuvconstants, width);
+    dst_rgb565 += dst_stride_rgb565;
+    src_y += src_stride_y;
+    if (y & 1) {
+      src_u += src_stride_u;
+      src_v += src_stride_v;
+    }
+  }
+  return 0;
+}
+
+// Convert I420 to RGB565.
+LIBYUV_API
+int I420ToRGB565(const uint8_t* src_y,
+                 int src_stride_y,
+                 const uint8_t* src_u,
+                 int src_stride_u,
+                 const uint8_t* src_v,
+                 int src_stride_v,
+                 uint8_t* dst_rgb565,
+                 int dst_stride_rgb565,
+                 int width,
+                 int height) {
+  return I420ToRGB565Matrix(src_y, src_stride_y, src_u, src_stride_u, src_v,
+                            src_stride_v, dst_rgb565, dst_stride_rgb565,
+                            &kYuvI601Constants, width, height);
+}
+
+// Convert J420 to RGB565.
+LIBYUV_API
+int J420ToRGB565(const uint8_t* src_y,
+                 int src_stride_y,
+                 const uint8_t* src_u,
+                 int src_stride_u,
+                 const uint8_t* src_v,
+                 int src_stride_v,
+                 uint8_t* dst_rgb565,
+                 int dst_stride_rgb565,
+                 int width,
+                 int height) {
+  return I420ToRGB565Matrix(src_y, src_stride_y, src_u, src_stride_u, src_v,
+                            src_stride_v, dst_rgb565, dst_stride_rgb565,
+                            &kYuvJPEGConstants, width, height);
+}
+
+// Convert H420 to RGB565.
+LIBYUV_API
+int H420ToRGB565(const uint8_t* src_y,
+                 int src_stride_y,
+                 const uint8_t* src_u,
+                 int src_stride_u,
+                 const uint8_t* src_v,
+                 int src_stride_v,
+                 uint8_t* dst_rgb565,
+                 int dst_stride_rgb565,
+                 int width,
+                 int height) {
+  return I420ToRGB565Matrix(src_y, src_stride_y, src_u, src_stride_u, src_v,
+                            src_stride_v, dst_rgb565, dst_stride_rgb565,
+                            &kYuvH709Constants, width, height);
+}
+
+// Convert I422 to RGB565.
+LIBYUV_API
+int I422ToRGB565(const uint8_t* src_y,
+                 int src_stride_y,
+                 const uint8_t* src_u,
+                 int src_stride_u,
+                 const uint8_t* src_v,
+                 int src_stride_v,
+                 uint8_t* dst_rgb565,
+                 int dst_stride_rgb565,
+                 int width,
+                 int height) {
+  int y;
+  void (*I422ToRGB565Row)(const uint8_t* y_buf, const uint8_t* u_buf,
+                          const uint8_t* v_buf, uint8_t* rgb_buf,
+                          const struct YuvConstants* yuvconstants, int width) =
+      I422ToRGB565Row_C;
+  if (!src_y || !src_u || !src_v || !dst_rgb565 || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    dst_rgb565 = dst_rgb565 + (height - 1) * dst_stride_rgb565;
+    dst_stride_rgb565 = -dst_stride_rgb565;
+  }
+#if defined(HAS_I422TORGB565ROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    I422ToRGB565Row = I422ToRGB565Row_Any_SSSE3;
+    if (IS_ALIGNED(width, 8)) {
+      I422ToRGB565Row = I422ToRGB565Row_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_I422TORGB565ROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    I422ToRGB565Row = I422ToRGB565Row_Any_AVX2;
+    if (IS_ALIGNED(width, 16)) {
+      I422ToRGB565Row = I422ToRGB565Row_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_I422TORGB565ROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    I422ToRGB565Row = I422ToRGB565Row_Any_NEON;
+    if (IS_ALIGNED(width, 8)) {
+      I422ToRGB565Row = I422ToRGB565Row_NEON;
+    }
+  }
+#endif
+#if defined(HAS_I422TORGB565ROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    I422ToRGB565Row = I422ToRGB565Row_Any_MSA;
+    if (IS_ALIGNED(width, 8)) {
+      I422ToRGB565Row = I422ToRGB565Row_MSA;
+    }
+  }
+#endif
+#if defined(HAS_I422TORGB565ROW_LASX)
+  if (TestCpuFlag(kCpuHasLASX)) {
+    I422ToRGB565Row = I422ToRGB565Row_Any_LASX;
+    if (IS_ALIGNED(width, 32)) {
+      I422ToRGB565Row = I422ToRGB565Row_LASX;
+    }
+  }
+#endif
+
+  for (y = 0; y < height; ++y) {
+    I422ToRGB565Row(src_y, src_u, src_v, dst_rgb565, &kYuvI601Constants, width);
+    dst_rgb565 += dst_stride_rgb565;
+    src_y += src_stride_y;
+    src_u += src_stride_u;
+    src_v += src_stride_v;
+  }
+  return 0;
+}
+
+// Ordered 8x8 dither for 888 to 565.  Values from 0 to 7.
+static const uint8_t kDither565_4x4[16] = {
+    0, 4, 1, 5, 6, 2, 7, 3, 1, 5, 0, 4, 7, 3, 6, 2,
+};
+
+// Convert I420 to RGB565 with dithering.
+LIBYUV_API
+int I420ToRGB565Dither(const uint8_t* src_y,
+                       int src_stride_y,
+                       const uint8_t* src_u,
+                       int src_stride_u,
+                       const uint8_t* src_v,
+                       int src_stride_v,
+                       uint8_t* dst_rgb565,
+                       int dst_stride_rgb565,
+                       const uint8_t* dither4x4,
+                       int width,
+                       int height) {
+  int y;
+  void (*I422ToARGBRow)(const uint8_t* y_buf, const uint8_t* u_buf,
+                        const uint8_t* v_buf, uint8_t* rgb_buf,
+                        const struct YuvConstants* yuvconstants, int width) =
+      I422ToARGBRow_C;
+  void (*ARGBToRGB565DitherRow)(const uint8_t* src_argb, uint8_t* dst_rgb,
+                                const uint32_t dither4, int width) =
+      ARGBToRGB565DitherRow_C;
+  if (!src_y || !src_u || !src_v || !dst_rgb565 || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    dst_rgb565 = dst_rgb565 + (height - 1) * dst_stride_rgb565;
+    dst_stride_rgb565 = -dst_stride_rgb565;
+  }
+  if (!dither4x4) {
+    dither4x4 = kDither565_4x4;
+  }
+#if defined(HAS_I422TOARGBROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    I422ToARGBRow = I422ToARGBRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 8)) {
+      I422ToARGBRow = I422ToARGBRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_I422TOARGBROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    I422ToARGBRow = I422ToARGBRow_Any_AVX2;
+    if (IS_ALIGNED(width, 16)) {
+      I422ToARGBRow = I422ToARGBRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_I422TOARGBROW_AVX512BW)
+  if (TestCpuFlag(kCpuHasAVX512BW | kCpuHasAVX512VL) ==
+      (kCpuHasAVX512BW | kCpuHasAVX512VL)) {
+    I422ToARGBRow = I422ToARGBRow_Any_AVX512BW;
+    if (IS_ALIGNED(width, 32)) {
+      I422ToARGBRow = I422ToARGBRow_AVX512BW;
+    }
+  }
+#endif
+#if defined(HAS_I422TOARGBROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    I422ToARGBRow = I422ToARGBRow_Any_NEON;
+    if (IS_ALIGNED(width, 8)) {
+      I422ToARGBRow = I422ToARGBRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_I422TOARGBROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    I422ToARGBRow = I422ToARGBRow_Any_MSA;
+    if (IS_ALIGNED(width, 8)) {
+      I422ToARGBRow = I422ToARGBRow_MSA;
+    }
+  }
+#endif
+#if defined(HAS_I422TOARGBROW_LASX)
+  if (TestCpuFlag(kCpuHasLASX)) {
+    I422ToARGBRow = I422ToARGBRow_Any_LASX;
+    if (IS_ALIGNED(width, 32)) {
+      I422ToARGBRow = I422ToARGBRow_LASX;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTORGB565DITHERROW_SSE2)
+  if (TestCpuFlag(kCpuHasSSE2)) {
+    ARGBToRGB565DitherRow = ARGBToRGB565DitherRow_Any_SSE2;
+    if (IS_ALIGNED(width, 4)) {
+      ARGBToRGB565DitherRow = ARGBToRGB565DitherRow_SSE2;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTORGB565DITHERROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ARGBToRGB565DitherRow = ARGBToRGB565DitherRow_Any_AVX2;
+    if (IS_ALIGNED(width, 8)) {
+      ARGBToRGB565DitherRow = ARGBToRGB565DitherRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTORGB565DITHERROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    ARGBToRGB565DitherRow = ARGBToRGB565DitherRow_Any_NEON;
+    if (IS_ALIGNED(width, 8)) {
+      ARGBToRGB565DitherRow = ARGBToRGB565DitherRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTORGB565DITHERROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    ARGBToRGB565DitherRow = ARGBToRGB565DitherRow_Any_MSA;
+    if (IS_ALIGNED(width, 8)) {
+      ARGBToRGB565DitherRow = ARGBToRGB565DitherRow_MSA;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTORGB565DITHERROW_LASX)
+  if (TestCpuFlag(kCpuHasLASX)) {
+    ARGBToRGB565DitherRow = ARGBToRGB565DitherRow_Any_LASX;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBToRGB565DitherRow = ARGBToRGB565DitherRow_LASX;
+    }
+  }
+#endif
+  {
+    // Allocate a row of argb.
+    align_buffer_64(row_argb, width * 4);
+    for (y = 0; y < height; ++y) {
+      I422ToARGBRow(src_y, src_u, src_v, row_argb, &kYuvI601Constants, width);
+      ARGBToRGB565DitherRow(row_argb, dst_rgb565,
+                            *(const uint32_t*)(dither4x4 + ((y & 3) << 2)),
+                            width);
+      dst_rgb565 += dst_stride_rgb565;
+      src_y += src_stride_y;
+      if (y & 1) {
+        src_u += src_stride_u;
+        src_v += src_stride_v;
+      }
+    }
+    free_aligned_buffer_64(row_argb);
+  }
+  return 0;
+}
+
+// Convert I420 to AR30 with matrix.
+LIBYUV_API
+int I420ToAR30Matrix(const uint8_t* src_y,
+                     int src_stride_y,
+                     const uint8_t* src_u,
+                     int src_stride_u,
+                     const uint8_t* src_v,
+                     int src_stride_v,
+                     uint8_t* dst_ar30,
+                     int dst_stride_ar30,
+                     const struct YuvConstants* yuvconstants,
+                     int width,
+                     int height) {
+  int y;
+  void (*I422ToAR30Row)(const uint8_t* y_buf, const uint8_t* u_buf,
+                        const uint8_t* v_buf, uint8_t* rgb_buf,
+                        const struct YuvConstants* yuvconstants, int width) =
+      I422ToAR30Row_C;
+
+  if (!src_y || !src_u || !src_v || !dst_ar30 || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    dst_ar30 = dst_ar30 + (height - 1) * dst_stride_ar30;
+    dst_stride_ar30 = -dst_stride_ar30;
+  }
+
+#if defined(HAS_I422TOAR30ROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    I422ToAR30Row = I422ToAR30Row_Any_SSSE3;
+    if (IS_ALIGNED(width, 8)) {
+      I422ToAR30Row = I422ToAR30Row_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_I422TOAR30ROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    I422ToAR30Row = I422ToAR30Row_Any_AVX2;
+    if (IS_ALIGNED(width, 16)) {
+      I422ToAR30Row = I422ToAR30Row_AVX2;
+    }
+  }
+#endif
+
+  for (y = 0; y < height; ++y) {
+    I422ToAR30Row(src_y, src_u, src_v, dst_ar30, yuvconstants, width);
+    dst_ar30 += dst_stride_ar30;
+    src_y += src_stride_y;
+    if (y & 1) {
+      src_u += src_stride_u;
+      src_v += src_stride_v;
+    }
+  }
+  return 0;
+}
+
+// Convert I420 to AR30.
+LIBYUV_API
+int I420ToAR30(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_ar30,
+               int dst_stride_ar30,
+               int width,
+               int height) {
+  return I420ToAR30Matrix(src_y, src_stride_y, src_u, src_stride_u, src_v,
+                          src_stride_v, dst_ar30, dst_stride_ar30,
+                          &kYuvI601Constants, width, height);
+}
+
+// Convert H420 to AR30.
+LIBYUV_API
+int H420ToAR30(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_ar30,
+               int dst_stride_ar30,
+               int width,
+               int height) {
+  return I420ToAR30Matrix(src_y, src_stride_y, src_u, src_stride_u, src_v,
+                          src_stride_v, dst_ar30, dst_stride_ar30,
+                          &kYvuH709Constants, width, height);
+}
+
+// Convert I420 to AB30.
+LIBYUV_API
+int I420ToAB30(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_ab30,
+               int dst_stride_ab30,
+               int width,
+               int height) {
+  return I420ToAR30Matrix(src_y, src_stride_y, src_v, src_stride_v, src_u,
+                          src_stride_u, dst_ab30, dst_stride_ab30,
+                          &kYvuI601Constants, width, height);
+}
+
+// Convert H420 to AB30.
+LIBYUV_API
+int H420ToAB30(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_ab30,
+               int dst_stride_ab30,
+               int width,
+               int height) {
+  return I420ToAR30Matrix(src_y, src_stride_y, src_v, src_stride_v, src_u,
+                          src_stride_u, dst_ab30, dst_stride_ab30,
+                          &kYvuH709Constants, width, height);
+}
+
+static int I420ToARGBMatrixBilinear(const uint8_t* src_y,
+                                    int src_stride_y,
+                                    const uint8_t* src_u,
+                                    int src_stride_u,
+                                    const uint8_t* src_v,
+                                    int src_stride_v,
+                                    uint8_t* dst_argb,
+                                    int dst_stride_argb,
+                                    const struct YuvConstants* yuvconstants,
+                                    int width,
+                                    int height) {
+  int y;
+  void (*I444ToARGBRow)(const uint8_t* y_buf, const uint8_t* u_buf,
+                        const uint8_t* v_buf, uint8_t* rgb_buf,
+                        const struct YuvConstants* yuvconstants, int width) =
+      I444ToARGBRow_C;
+  void (*Scale2RowUp)(const uint8_t* src_ptr, ptrdiff_t src_stride,
+                      uint8_t* dst_ptr, ptrdiff_t dst_stride, int dst_width) =
+      ScaleRowUp2_Bilinear_Any_C;
+  if (!src_y || !src_u || !src_v || !dst_argb || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    dst_argb = dst_argb + (height - 1) * dst_stride_argb;
+    dst_stride_argb = -dst_stride_argb;
+  }
+#if defined(HAS_I444TOARGBROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    I444ToARGBRow = I444ToARGBRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 8)) {
+      I444ToARGBRow = I444ToARGBRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_I444TOARGBROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    I444ToARGBRow = I444ToARGBRow_Any_AVX2;
+    if (IS_ALIGNED(width, 16)) {
+      I444ToARGBRow = I444ToARGBRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_I444TOARGBROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    I444ToARGBRow = I444ToARGBRow_Any_NEON;
+    if (IS_ALIGNED(width, 8)) {
+      I444ToARGBRow = I444ToARGBRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_I444TOARGBROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    I444ToARGBRow = I444ToARGBRow_Any_MSA;
+    if (IS_ALIGNED(width, 8)) {
+      I444ToARGBRow = I444ToARGBRow_MSA;
+    }
+  }
+#endif
+#if defined(HAS_I444TOARGBROW_LASX)
+  if (TestCpuFlag(kCpuHasLASX)) {
+    I444ToARGBRow = I444ToARGBRow_Any_LASX;
+    if (IS_ALIGNED(width, 32)) {
+      I444ToARGBRow = I444ToARGBRow_LASX;
+    }
+  }
+#endif
+
+#if defined(HAS_SCALEROWUP2LINEAR_SSE2)
+  if (TestCpuFlag(kCpuHasSSE2)) {
+    Scale2RowUp = ScaleRowUp2_Bilinear_Any_SSE2;
+  }
+#endif
+
+#if defined(HAS_SCALEROWUP2LINEAR_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    Scale2RowUp = ScaleRowUp2_Bilinear_Any_SSSE3;
+  }
+#endif
+
+#if defined(HAS_SCALEROWUP2LINEAR_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    Scale2RowUp = ScaleRowUp2_Bilinear_Any_AVX2;
+  }
+#endif
+
+#if defined(HAS_SCALEROWUP2LINEAR_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    Scale2RowUp = ScaleRowUp2_Bilinear_Any_NEON;
+  }
+#endif
+
+  // alloc 4 lines temp
+  const int kRowSize = (width + 31) & ~31;
+  align_buffer_64(row, kRowSize * 4);
+  uint8_t* temp_u_1 = row;
+  uint8_t* temp_u_2 = row + kRowSize;
+  uint8_t* temp_v_1 = row + kRowSize * 2;
+  uint8_t* temp_v_2 = row + kRowSize * 3;
+
+  Scale2RowUp(src_u, 0, temp_u_1, kRowSize, width);
+  Scale2RowUp(src_v, 0, temp_v_1, kRowSize, width);
+  I444ToARGBRow(src_y, temp_u_1, temp_v_1, dst_argb, yuvconstants, width);
+  dst_argb += dst_stride_argb;
+  src_y += src_stride_y;
+
+  for (y = 0; y < height - 2; y += 2) {
+    Scale2RowUp(src_u, src_stride_u, temp_u_1, kRowSize, width);
+    Scale2RowUp(src_v, src_stride_v, temp_v_1, kRowSize, width);
+    I444ToARGBRow(src_y, temp_u_1, temp_v_1, dst_argb, yuvconstants, width);
+    dst_argb += dst_stride_argb;
+    src_y += src_stride_y;
+    I444ToARGBRow(src_y, temp_u_2, temp_v_2, dst_argb, yuvconstants, width);
+    dst_argb += dst_stride_argb;
+    src_y += src_stride_y;
+    src_u += src_stride_u;
+    src_v += src_stride_v;
+  }
+
+  if (!(height & 1)) {
+    Scale2RowUp(src_u, 0, temp_u_1, kRowSize, width);
+    Scale2RowUp(src_v, 0, temp_v_1, kRowSize, width);
+    I444ToARGBRow(src_y, temp_u_1, temp_v_1, dst_argb, yuvconstants, width);
+  }
+
+  free_aligned_buffer_64(row);
+  return 0;
+}
+
+static int I422ToARGBMatrixLinear(const uint8_t* src_y,
+                                  int src_stride_y,
+                                  const uint8_t* src_u,
+                                  int src_stride_u,
+                                  const uint8_t* src_v,
+                                  int src_stride_v,
+                                  uint8_t* dst_argb,
+                                  int dst_stride_argb,
+                                  const struct YuvConstants* yuvconstants,
+                                  int width,
+                                  int height) {
+  int y;
+  void (*I444ToARGBRow)(const uint8_t* y_buf, const uint8_t* u_buf,
+                        const uint8_t* v_buf, uint8_t* rgb_buf,
+                        const struct YuvConstants* yuvconstants, int width) =
+      I444ToARGBRow_C;
+  void (*ScaleRowUp)(const uint8_t* src_ptr, uint8_t* dst_ptr, int dst_width) =
+      ScaleRowUp2_Linear_Any_C;
+  if (!src_y || !src_u || !src_v || !dst_argb || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    dst_argb = dst_argb + (height - 1) * dst_stride_argb;
+    dst_stride_argb = -dst_stride_argb;
+  }
+#if defined(HAS_I444TOARGBROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    I444ToARGBRow = I444ToARGBRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 8)) {
+      I444ToARGBRow = I444ToARGBRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_I444TOARGBROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    I444ToARGBRow = I444ToARGBRow_Any_AVX2;
+    if (IS_ALIGNED(width, 16)) {
+      I444ToARGBRow = I444ToARGBRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_I444TOARGBROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    I444ToARGBRow = I444ToARGBRow_Any_NEON;
+    if (IS_ALIGNED(width, 8)) {
+      I444ToARGBRow = I444ToARGBRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_I444TOARGBROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    I444ToARGBRow = I444ToARGBRow_Any_MSA;
+    if (IS_ALIGNED(width, 8)) {
+      I444ToARGBRow = I444ToARGBRow_MSA;
+    }
+  }
+#endif
+#if defined(HAS_I444TOARGBROW_LASX)
+  if (TestCpuFlag(kCpuHasLASX)) {
+    I444ToARGBRow = I444ToARGBRow_Any_LASX;
+    if (IS_ALIGNED(width, 32)) {
+      I444ToARGBRow = I444ToARGBRow_LASX;
+    }
+  }
+#endif
+#if defined(HAS_SCALEROWUP2LINEAR_SSE2)
+  if (TestCpuFlag(kCpuHasSSE2)) {
+    ScaleRowUp = ScaleRowUp2_Linear_Any_SSE2;
+  }
+#endif
+#if defined(HAS_SCALEROWUP2LINEAR_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    ScaleRowUp = ScaleRowUp2_Linear_Any_SSSE3;
+  }
+#endif
+#if defined(HAS_SCALEROWUP2LINEAR_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ScaleRowUp = ScaleRowUp2_Linear_Any_AVX2;
+  }
+#endif
+#if defined(HAS_SCALEROWUP2LINEAR_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    ScaleRowUp = ScaleRowUp2_Linear_Any_NEON;
+  }
+#endif
+
+  // alloc 2 lines temp
+  const int kRowSize = (width + 31) & ~31;
+  align_buffer_64(row, kRowSize * 2);
+  uint8_t* temp_u = row;
+  uint8_t* temp_v = row + kRowSize;
+
+  for (y = 0; y < height; ++y) {
+    ScaleRowUp(src_u, temp_u, width);
+    ScaleRowUp(src_v, temp_v, width);
+    I444ToARGBRow(src_y, temp_u, temp_v, dst_argb, yuvconstants, width);
+    dst_argb += dst_stride_argb;
+    src_y += src_stride_y;
+    src_u += src_stride_u;
+    src_v += src_stride_v;
+  }
+
+  free_aligned_buffer_64(row);
+  return 0;
+}
+
+static int I010ToAR30MatrixBilinear(const uint16_t* src_y,
+                                    int src_stride_y,
+                                    const uint16_t* src_u,
+                                    int src_stride_u,
+                                    const uint16_t* src_v,
+                                    int src_stride_v,
+                                    uint8_t* dst_ar30,
+                                    int dst_stride_ar30,
+                                    const struct YuvConstants* yuvconstants,
+                                    int width,
+                                    int height) {
+  int y;
+  void (*I410ToAR30Row)(const uint16_t* y_buf, const uint16_t* u_buf,
+                        const uint16_t* v_buf, uint8_t* rgb_buf,
+                        const struct YuvConstants* yuvconstants, int width) =
+      I410ToAR30Row_C;
+  void (*Scale2RowUp)(const uint16_t* src_ptr, ptrdiff_t src_stride,
+                      uint16_t* dst_ptr, ptrdiff_t dst_stride, int dst_width) =
+      ScaleRowUp2_Bilinear_16_Any_C;
+  if (!src_y || !src_u || !src_v || !dst_ar30 || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    dst_ar30 = dst_ar30 + (height - 1) * dst_stride_ar30;
+    dst_stride_ar30 = -dst_stride_ar30;
+  }
+#if defined(HAS_I410TOAR30ROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    I410ToAR30Row = I410ToAR30Row_Any_SSSE3;
+    if (IS_ALIGNED(width, 8)) {
+      I410ToAR30Row = I410ToAR30Row_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_I410TOAR30ROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    I410ToAR30Row = I410ToAR30Row_Any_AVX2;
+    if (IS_ALIGNED(width, 16)) {
+      I410ToAR30Row = I410ToAR30Row_AVX2;
+    }
+  }
+#endif
+
+#if defined(HAS_SCALEROWUP2LINEAR_12_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    Scale2RowUp = ScaleRowUp2_Bilinear_12_Any_SSSE3;
+  }
+#endif
+
+#if defined(HAS_SCALEROWUP2LINEAR_12_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    Scale2RowUp = ScaleRowUp2_Bilinear_12_Any_AVX2;
+  }
+#endif
+
+#if defined(HAS_SCALEROWUP2LINEAR_12_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    Scale2RowUp = ScaleRowUp2_Bilinear_12_Any_NEON;
+  }
+#endif
+
+  // alloc 4 lines temp
+  const int kRowSize = (width + 31) & ~31;
+  align_buffer_64(row, kRowSize * 4 * sizeof(uint16_t));
+  uint16_t* temp_u_1 = (uint16_t*)(row);
+  uint16_t* temp_u_2 = (uint16_t*)(row) + kRowSize;
+  uint16_t* temp_v_1 = (uint16_t*)(row) + kRowSize * 2;
+  uint16_t* temp_v_2 = (uint16_t*)(row) + kRowSize * 3;
+
+  Scale2RowUp(src_u, 0, temp_u_1, kRowSize, width);
+  Scale2RowUp(src_v, 0, temp_v_1, kRowSize, width);
+  I410ToAR30Row(src_y, temp_u_1, temp_v_1, dst_ar30, yuvconstants, width);
+  dst_ar30 += dst_stride_ar30;
+  src_y += src_stride_y;
+
+  for (y = 0; y < height - 2; y += 2) {
+    Scale2RowUp(src_u, src_stride_u, temp_u_1, kRowSize, width);
+    Scale2RowUp(src_v, src_stride_v, temp_v_1, kRowSize, width);
+    I410ToAR30Row(src_y, temp_u_1, temp_v_1, dst_ar30, yuvconstants, width);
+    dst_ar30 += dst_stride_ar30;
+    src_y += src_stride_y;
+    I410ToAR30Row(src_y, temp_u_2, temp_v_2, dst_ar30, yuvconstants, width);
+    dst_ar30 += dst_stride_ar30;
+    src_y += src_stride_y;
+    src_u += src_stride_u;
+    src_v += src_stride_v;
+  }
+
+  if (!(height & 1)) {
+    Scale2RowUp(src_u, 0, temp_u_1, kRowSize, width);
+    Scale2RowUp(src_v, 0, temp_v_1, kRowSize, width);
+    I410ToAR30Row(src_y, temp_u_1, temp_v_1, dst_ar30, yuvconstants, width);
+  }
+
+  free_aligned_buffer_64(row);
+
+  return 0;
+}
+
+static int I210ToAR30MatrixLinear(const uint16_t* src_y,
+                                  int src_stride_y,
+                                  const uint16_t* src_u,
+                                  int src_stride_u,
+                                  const uint16_t* src_v,
+                                  int src_stride_v,
+                                  uint8_t* dst_ar30,
+                                  int dst_stride_ar30,
+                                  const struct YuvConstants* yuvconstants,
+                                  int width,
+                                  int height) {
+  int y;
+  void (*I410ToAR30Row)(const uint16_t* y_buf, const uint16_t* u_buf,
+                        const uint16_t* v_buf, uint8_t* rgb_buf,
+                        const struct YuvConstants* yuvconstants, int width) =
+      I410ToAR30Row_C;
+  void (*ScaleRowUp)(const uint16_t* src_ptr, uint16_t* dst_ptr,
+                     int dst_width) = ScaleRowUp2_Linear_16_Any_C;
+  if (!src_y || !src_u || !src_v || !dst_ar30 || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    dst_ar30 = dst_ar30 + (height - 1) * dst_stride_ar30;
+    dst_stride_ar30 = -dst_stride_ar30;
+  }
+#if defined(HAS_I410TOAR30ROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    I410ToAR30Row = I410ToAR30Row_Any_SSSE3;
+    if (IS_ALIGNED(width, 8)) {
+      I410ToAR30Row = I410ToAR30Row_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_I410TOAR30ROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    I410ToAR30Row = I410ToAR30Row_Any_AVX2;
+    if (IS_ALIGNED(width, 16)) {
+      I410ToAR30Row = I410ToAR30Row_AVX2;
+    }
+  }
+#endif
+
+#if defined(HAS_SCALEROWUP2LINEAR_12_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    ScaleRowUp = ScaleRowUp2_Linear_12_Any_SSSE3;
+  }
+#endif
+#if defined(HAS_SCALEROWUP2LINEAR_12_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ScaleRowUp = ScaleRowUp2_Linear_12_Any_AVX2;
+  }
+#endif
+#if defined(HAS_SCALEROWUP2LINEAR_12_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    ScaleRowUp = ScaleRowUp2_Linear_12_Any_NEON;
+  }
+#endif
+
+  // alloc 2 lines temp
+  const int kRowSize = (width + 31) & ~31;
+  align_buffer_64(row, kRowSize * 2 * sizeof(uint16_t));
+  uint16_t* temp_u = (uint16_t*)(row);
+  uint16_t* temp_v = (uint16_t*)(row) + kRowSize;
+
+  for (y = 0; y < height; ++y) {
+    ScaleRowUp(src_u, temp_u, width);
+    ScaleRowUp(src_v, temp_v, width);
+    I410ToAR30Row(src_y, temp_u, temp_v, dst_ar30, yuvconstants, width);
+    dst_ar30 += dst_stride_ar30;
+    src_y += src_stride_y;
+    src_u += src_stride_u;
+    src_v += src_stride_v;
+  }
+  free_aligned_buffer_64(row);
+  return 0;
+}
+
+static int I010ToARGBMatrixBilinear(const uint16_t* src_y,
+                                    int src_stride_y,
+                                    const uint16_t* src_u,
+                                    int src_stride_u,
+                                    const uint16_t* src_v,
+                                    int src_stride_v,
+                                    uint8_t* dst_argb,
+                                    int dst_stride_argb,
+                                    const struct YuvConstants* yuvconstants,
+                                    int width,
+                                    int height) {
+  int y;
+  void (*I410ToARGBRow)(const uint16_t* y_buf, const uint16_t* u_buf,
+                        const uint16_t* v_buf, uint8_t* rgb_buf,
+                        const struct YuvConstants* yuvconstants, int width) =
+      I410ToARGBRow_C;
+  void (*Scale2RowUp)(const uint16_t* src_ptr, ptrdiff_t src_stride,
+                      uint16_t* dst_ptr, ptrdiff_t dst_stride, int dst_width) =
+      ScaleRowUp2_Bilinear_16_Any_C;
+  if (!src_y || !src_u || !src_v || !dst_argb || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    dst_argb = dst_argb + (height - 1) * dst_stride_argb;
+    dst_stride_argb = -dst_stride_argb;
+  }
+#if defined(HAS_I410TOARGBROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    I410ToARGBRow = I410ToARGBRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 8)) {
+      I410ToARGBRow = I410ToARGBRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_I410TOARGBROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    I410ToARGBRow = I410ToARGBRow_Any_AVX2;
+    if (IS_ALIGNED(width, 16)) {
+      I410ToARGBRow = I410ToARGBRow_AVX2;
+    }
+  }
+#endif
+
+#if defined(HAS_SCALEROWUP2LINEAR_12_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    Scale2RowUp = ScaleRowUp2_Bilinear_12_Any_SSSE3;
+  }
+#endif
+
+#if defined(HAS_SCALEROWUP2LINEAR_12_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    Scale2RowUp = ScaleRowUp2_Bilinear_12_Any_AVX2;
+  }
+#endif
+
+#if defined(HAS_SCALEROWUP2LINEAR_12_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    Scale2RowUp = ScaleRowUp2_Bilinear_12_Any_NEON;
+  }
+#endif
+
+  // alloc 4 lines temp
+  const int kRowSize = (width + 31) & ~31;
+  align_buffer_64(row, kRowSize * 4 * sizeof(uint16_t));
+  uint16_t* temp_u_1 = (uint16_t*)(row);
+  uint16_t* temp_u_2 = (uint16_t*)(row) + kRowSize;
+  uint16_t* temp_v_1 = (uint16_t*)(row) + kRowSize * 2;
+  uint16_t* temp_v_2 = (uint16_t*)(row) + kRowSize * 3;
+
+  Scale2RowUp(src_u, 0, temp_u_1, kRowSize, width);
+  Scale2RowUp(src_v, 0, temp_v_1, kRowSize, width);
+  I410ToARGBRow(src_y, temp_u_1, temp_v_1, dst_argb, yuvconstants, width);
+  dst_argb += dst_stride_argb;
+  src_y += src_stride_y;
+
+  for (y = 0; y < height - 2; y += 2) {
+    Scale2RowUp(src_u, src_stride_u, temp_u_1, kRowSize, width);
+    Scale2RowUp(src_v, src_stride_v, temp_v_1, kRowSize, width);
+    I410ToARGBRow(src_y, temp_u_1, temp_v_1, dst_argb, yuvconstants, width);
+    dst_argb += dst_stride_argb;
+    src_y += src_stride_y;
+    I410ToARGBRow(src_y, temp_u_2, temp_v_2, dst_argb, yuvconstants, width);
+    dst_argb += dst_stride_argb;
+    src_y += src_stride_y;
+    src_u += src_stride_u;
+    src_v += src_stride_v;
+  }
+
+  if (!(height & 1)) {
+    Scale2RowUp(src_u, 0, temp_u_1, kRowSize, width);
+    Scale2RowUp(src_v, 0, temp_v_1, kRowSize, width);
+    I410ToARGBRow(src_y, temp_u_1, temp_v_1, dst_argb, yuvconstants, width);
+  }
+
+  free_aligned_buffer_64(row);
+  return 0;
+}
+
+static int I210ToARGBMatrixLinear(const uint16_t* src_y,
+                                  int src_stride_y,
+                                  const uint16_t* src_u,
+                                  int src_stride_u,
+                                  const uint16_t* src_v,
+                                  int src_stride_v,
+                                  uint8_t* dst_argb,
+                                  int dst_stride_argb,
+                                  const struct YuvConstants* yuvconstants,
+                                  int width,
+                                  int height) {
+  int y;
+  void (*I410ToARGBRow)(const uint16_t* y_buf, const uint16_t* u_buf,
+                        const uint16_t* v_buf, uint8_t* rgb_buf,
+                        const struct YuvConstants* yuvconstants, int width) =
+      I410ToARGBRow_C;
+  void (*ScaleRowUp)(const uint16_t* src_ptr, uint16_t* dst_ptr,
+                     int dst_width) = ScaleRowUp2_Linear_16_Any_C;
+  if (!src_y || !src_u || !src_v || !dst_argb || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    dst_argb = dst_argb + (height - 1) * dst_stride_argb;
+    dst_stride_argb = -dst_stride_argb;
+  }
+#if defined(HAS_I410TOARGBROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    I410ToARGBRow = I410ToARGBRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 8)) {
+      I410ToARGBRow = I410ToARGBRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_I410TOARGBROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    I410ToARGBRow = I410ToARGBRow_Any_AVX2;
+    if (IS_ALIGNED(width, 16)) {
+      I410ToARGBRow = I410ToARGBRow_AVX2;
+    }
+  }
+#endif
+
+#if defined(HAS_SCALEROWUP2LINEAR_12_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    ScaleRowUp = ScaleRowUp2_Linear_12_Any_SSSE3;
+  }
+#endif
+#if defined(HAS_SCALEROWUP2LINEAR_12_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ScaleRowUp = ScaleRowUp2_Linear_12_Any_AVX2;
+  }
+#endif
+#if defined(HAS_SCALEROWUP2LINEAR_12_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    ScaleRowUp = ScaleRowUp2_Linear_12_Any_NEON;
+  }
+#endif
+
+  // alloc 2 lines temp
+  const int kRowSize = (width + 31) & ~31;
+  align_buffer_64(row, kRowSize * 2 * sizeof(uint16_t));
+  uint16_t* temp_u = (uint16_t*)(row);
+  uint16_t* temp_v = (uint16_t*)(row) + kRowSize;
+
+  for (y = 0; y < height; ++y) {
+    ScaleRowUp(src_u, temp_u, width);
+    ScaleRowUp(src_v, temp_v, width);
+    I410ToARGBRow(src_y, temp_u, temp_v, dst_argb, yuvconstants, width);
+    dst_argb += dst_stride_argb;
+    src_y += src_stride_y;
+    src_u += src_stride_u;
+    src_v += src_stride_v;
+  }
+
+  free_aligned_buffer_64(row);
+  return 0;
+}
+
+static int I420AlphaToARGBMatrixBilinear(
+    const uint8_t* src_y,
+    int src_stride_y,
+    const uint8_t* src_u,
+    int src_stride_u,
+    const uint8_t* src_v,
+    int src_stride_v,
+    const uint8_t* src_a,
+    int src_stride_a,
+    uint8_t* dst_argb,
+    int dst_stride_argb,
+    const struct YuvConstants* yuvconstants,
+    int width,
+    int height,
+    int attenuate) {
+  int y;
+  void (*I444AlphaToARGBRow)(const uint8_t* y_buf, const uint8_t* u_buf,
+                             const uint8_t* v_buf, const uint8_t* a_buf,
+                             uint8_t* dst_argb,
+                             const struct YuvConstants* yuvconstants,
+                             int width) = I444AlphaToARGBRow_C;
+  void (*ARGBAttenuateRow)(const uint8_t* src_argb, uint8_t* dst_argb,
+                           int width) = ARGBAttenuateRow_C;
+  void (*Scale2RowUp)(const uint8_t* src_ptr, ptrdiff_t src_stride,
+                      uint8_t* dst_ptr, ptrdiff_t dst_stride, int dst_width) =
+      ScaleRowUp2_Bilinear_Any_C;
+  if (!src_y || !src_u || !src_v || !src_a || !dst_argb || width <= 0 ||
+      height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    dst_argb = dst_argb + (height - 1) * dst_stride_argb;
+    dst_stride_argb = -dst_stride_argb;
+  }
+#if defined(HAS_I444ALPHATOARGBROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    I444AlphaToARGBRow = I444AlphaToARGBRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 8)) {
+      I444AlphaToARGBRow = I444AlphaToARGBRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_I444ALPHATOARGBROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    I444AlphaToARGBRow = I444AlphaToARGBRow_Any_AVX2;
+    if (IS_ALIGNED(width, 16)) {
+      I444AlphaToARGBRow = I444AlphaToARGBRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_I444ALPHATOARGBROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    I444AlphaToARGBRow = I444AlphaToARGBRow_Any_NEON;
+    if (IS_ALIGNED(width, 8)) {
+      I444AlphaToARGBRow = I444AlphaToARGBRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_I444ALPHATOARGBROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    I444AlphaToARGBRow = I444AlphaToARGBRow_Any_MSA;
+    if (IS_ALIGNED(width, 8)) {
+      I444AlphaToARGBRow = I444AlphaToARGBRow_MSA;
+    }
+  }
+#endif
+#if defined(HAS_I444ALPHATOARGBROW_LASX)
+  if (TestCpuFlag(kCpuHasLASX)) {
+    I444AlphaToARGBRow = I444AlphaToARGBRow_Any_LASX;
+    if (IS_ALIGNED(width, 16)) {
+      I444AlphaToARGBRow = I444AlphaToARGBRow_LASX;
+    }
+  }
+#endif
+#if defined(HAS_ARGBATTENUATEROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    ARGBAttenuateRow = ARGBAttenuateRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 4)) {
+      ARGBAttenuateRow = ARGBAttenuateRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_ARGBATTENUATEROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ARGBAttenuateRow = ARGBAttenuateRow_Any_AVX2;
+    if (IS_ALIGNED(width, 8)) {
+      ARGBAttenuateRow = ARGBAttenuateRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_ARGBATTENUATEROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    ARGBAttenuateRow = ARGBAttenuateRow_Any_NEON;
+    if (IS_ALIGNED(width, 8)) {
+      ARGBAttenuateRow = ARGBAttenuateRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_ARGBATTENUATEROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    ARGBAttenuateRow = ARGBAttenuateRow_Any_MSA;
+    if (IS_ALIGNED(width, 8)) {
+      ARGBAttenuateRow = ARGBAttenuateRow_MSA;
+    }
+  }
+#endif
+#if defined(HAS_SCALEROWUP2LINEAR_SSE2)
+  if (TestCpuFlag(kCpuHasSSE2)) {
+    Scale2RowUp = ScaleRowUp2_Bilinear_Any_SSE2;
+  }
+#endif
+
+#if defined(HAS_SCALEROWUP2LINEAR_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    Scale2RowUp = ScaleRowUp2_Bilinear_Any_SSSE3;
+  }
+#endif
+
+#if defined(HAS_SCALEROWUP2LINEAR_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    Scale2RowUp = ScaleRowUp2_Bilinear_Any_AVX2;
+  }
+#endif
+
+#if defined(HAS_SCALEROWUP2LINEAR_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    Scale2RowUp = ScaleRowUp2_Bilinear_Any_NEON;
+  }
+#endif
+
+  // alloc 4 lines temp
+  const int kRowSize = (width + 31) & ~31;
+  align_buffer_64(row, kRowSize * 4);
+  uint8_t* temp_u_1 = row;
+  uint8_t* temp_u_2 = row + kRowSize;
+  uint8_t* temp_v_1 = row + kRowSize * 2;
+  uint8_t* temp_v_2 = row + kRowSize * 3;
+
+  Scale2RowUp(src_u, 0, temp_u_1, kRowSize, width);
+  Scale2RowUp(src_v, 0, temp_v_1, kRowSize, width);
+  I444AlphaToARGBRow(src_y, temp_u_1, temp_v_1, src_a, dst_argb, yuvconstants,
+                     width);
+  if (attenuate) {
+    ARGBAttenuateRow(dst_argb, dst_argb, width);
+  }
+  dst_argb += dst_stride_argb;
+  src_y += src_stride_y;
+  src_a += src_stride_a;
+
+  for (y = 0; y < height - 2; y += 2) {
+    Scale2RowUp(src_u, src_stride_u, temp_u_1, kRowSize, width);
+    Scale2RowUp(src_v, src_stride_v, temp_v_1, kRowSize, width);
+    I444AlphaToARGBRow(src_y, temp_u_1, temp_v_1, src_a, dst_argb, yuvconstants,
+                       width);
+    if (attenuate) {
+      ARGBAttenuateRow(dst_argb, dst_argb, width);
+    }
+    dst_argb += dst_stride_argb;
+    src_y += src_stride_y;
+    src_a += src_stride_a;
+    I444AlphaToARGBRow(src_y, temp_u_2, temp_v_2, src_a, dst_argb, yuvconstants,
+                       width);
+    if (attenuate) {
+      ARGBAttenuateRow(dst_argb, dst_argb, width);
+    }
+    dst_argb += dst_stride_argb;
+    src_y += src_stride_y;
+    src_u += src_stride_u;
+    src_v += src_stride_v;
+    src_a += src_stride_a;
+  }
+
+  if (!(height & 1)) {
+    Scale2RowUp(src_u, 0, temp_u_1, kRowSize, width);
+    Scale2RowUp(src_v, 0, temp_v_1, kRowSize, width);
+    I444AlphaToARGBRow(src_y, temp_u_1, temp_v_1, src_a, dst_argb, yuvconstants,
+                       width);
+    if (attenuate) {
+      ARGBAttenuateRow(dst_argb, dst_argb, width);
+    }
+  }
+
+  free_aligned_buffer_64(row);
+  return 0;
+}
+
+static int I422AlphaToARGBMatrixLinear(const uint8_t* src_y,
+                                       int src_stride_y,
+                                       const uint8_t* src_u,
+                                       int src_stride_u,
+                                       const uint8_t* src_v,
+                                       int src_stride_v,
+                                       const uint8_t* src_a,
+                                       int src_stride_a,
+                                       uint8_t* dst_argb,
+                                       int dst_stride_argb,
+                                       const struct YuvConstants* yuvconstants,
+                                       int width,
+                                       int height,
+                                       int attenuate) {
+  int y;
+  void (*I444AlphaToARGBRow)(const uint8_t* y_buf, const uint8_t* u_buf,
+                             const uint8_t* v_buf, const uint8_t* a_buf,
+                             uint8_t* dst_argb,
+                             const struct YuvConstants* yuvconstants,
+                             int width) = I444AlphaToARGBRow_C;
+  void (*ARGBAttenuateRow)(const uint8_t* src_argb, uint8_t* dst_argb,
+                           int width) = ARGBAttenuateRow_C;
+  void (*ScaleRowUp)(const uint8_t* src_ptr, uint8_t* dst_ptr, int dst_width) =
+      ScaleRowUp2_Linear_Any_C;
+  if (!src_y || !src_u || !src_v || !src_a || !dst_argb || width <= 0 ||
+      height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    dst_argb = dst_argb + (height - 1) * dst_stride_argb;
+    dst_stride_argb = -dst_stride_argb;
+  }
+#if defined(HAS_I444ALPHATOARGBROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    I444AlphaToARGBRow = I444AlphaToARGBRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 8)) {
+      I444AlphaToARGBRow = I444AlphaToARGBRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_I444ALPHATOARGBROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    I444AlphaToARGBRow = I444AlphaToARGBRow_Any_AVX2;
+    if (IS_ALIGNED(width, 16)) {
+      I444AlphaToARGBRow = I444AlphaToARGBRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_I444ALPHATOARGBROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    I444AlphaToARGBRow = I444AlphaToARGBRow_Any_NEON;
+    if (IS_ALIGNED(width, 8)) {
+      I444AlphaToARGBRow = I444AlphaToARGBRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_I444ALPHATOARGBROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    I444AlphaToARGBRow = I444AlphaToARGBRow_Any_MSA;
+    if (IS_ALIGNED(width, 8)) {
+      I444AlphaToARGBRow = I444AlphaToARGBRow_MSA;
+    }
+  }
+#endif
+#if defined(HAS_I444ALPHATOARGBROW_LASX)
+  if (TestCpuFlag(kCpuHasLASX)) {
+    I444AlphaToARGBRow = I444AlphaToARGBRow_Any_LASX;
+    if (IS_ALIGNED(width, 16)) {
+      I444AlphaToARGBRow = I444AlphaToARGBRow_LASX;
+    }
+  }
+#endif
+#if defined(HAS_ARGBATTENUATEROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    ARGBAttenuateRow = ARGBAttenuateRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 4)) {
+      ARGBAttenuateRow = ARGBAttenuateRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_ARGBATTENUATEROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ARGBAttenuateRow = ARGBAttenuateRow_Any_AVX2;
+    if (IS_ALIGNED(width, 8)) {
+      ARGBAttenuateRow = ARGBAttenuateRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_ARGBATTENUATEROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    ARGBAttenuateRow = ARGBAttenuateRow_Any_NEON;
+    if (IS_ALIGNED(width, 8)) {
+      ARGBAttenuateRow = ARGBAttenuateRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_ARGBATTENUATEROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    ARGBAttenuateRow = ARGBAttenuateRow_Any_MSA;
+    if (IS_ALIGNED(width, 8)) {
+      ARGBAttenuateRow = ARGBAttenuateRow_MSA;
+    }
+  }
+#endif
+#if defined(HAS_SCALEROWUP2LINEAR_SSE2)
+  if (TestCpuFlag(kCpuHasSSE2)) {
+    ScaleRowUp = ScaleRowUp2_Linear_Any_SSE2;
+  }
+#endif
+#if defined(HAS_SCALEROWUP2LINEAR_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    ScaleRowUp = ScaleRowUp2_Linear_Any_SSSE3;
+  }
+#endif
+#if defined(HAS_SCALEROWUP2LINEAR_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ScaleRowUp = ScaleRowUp2_Linear_Any_AVX2;
+  }
+#endif
+#if defined(HAS_SCALEROWUP2LINEAR_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    ScaleRowUp = ScaleRowUp2_Linear_Any_NEON;
+  }
+#endif
+
+  // alloc 2 lines temp
+  const int kRowSize = (width + 31) & ~31;
+  align_buffer_64(row, kRowSize * 2);
+  uint8_t* temp_u = row;
+  uint8_t* temp_v = row + kRowSize;
+
+  for (y = 0; y < height; ++y) {
+    ScaleRowUp(src_u, temp_u, width);
+    ScaleRowUp(src_v, temp_v, width);
+    I444AlphaToARGBRow(src_y, temp_u, temp_v, src_a, dst_argb, yuvconstants,
+                       width);
+    if (attenuate) {
+      ARGBAttenuateRow(dst_argb, dst_argb, width);
+    }
+    dst_argb += dst_stride_argb;
+    src_a += src_stride_a;
+    src_y += src_stride_y;
+    src_u += src_stride_u;
+    src_v += src_stride_v;
+  }
+
+  free_aligned_buffer_64(row);
+  return 0;
+}
+
+static int I010AlphaToARGBMatrixBilinear(
+    const uint16_t* src_y,
+    int src_stride_y,
+    const uint16_t* src_u,
+    int src_stride_u,
+    const uint16_t* src_v,
+    int src_stride_v,
+    const uint16_t* src_a,
+    int src_stride_a,
+    uint8_t* dst_argb,
+    int dst_stride_argb,
+    const struct YuvConstants* yuvconstants,
+    int width,
+    int height,
+    int attenuate) {
+  int y;
+  void (*I410AlphaToARGBRow)(const uint16_t* y_buf, const uint16_t* u_buf,
+                             const uint16_t* v_buf, const uint16_t* a_buf,
+                             uint8_t* dst_argb,
+                             const struct YuvConstants* yuvconstants,
+                             int width) = I410AlphaToARGBRow_C;
+  void (*ARGBAttenuateRow)(const uint8_t* src_argb, uint8_t* dst_argb,
+                           int width) = ARGBAttenuateRow_C;
+  void (*Scale2RowUp)(const uint16_t* src_ptr, ptrdiff_t src_stride,
+                      uint16_t* dst_ptr, ptrdiff_t dst_stride, int dst_width) =
+      ScaleRowUp2_Bilinear_16_Any_C;
+  if (!src_y || !src_u || !src_v || !src_a || !dst_argb || width <= 0 ||
+      height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    dst_argb = dst_argb + (height - 1) * dst_stride_argb;
+    dst_stride_argb = -dst_stride_argb;
+  }
+#if defined(HAS_I410ALPHATOARGBROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    I410AlphaToARGBRow = I410AlphaToARGBRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 8)) {
+      I410AlphaToARGBRow = I410AlphaToARGBRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_I410ALPHATOARGBROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    I410AlphaToARGBRow = I410AlphaToARGBRow_Any_AVX2;
+    if (IS_ALIGNED(width, 16)) {
+      I410AlphaToARGBRow = I410AlphaToARGBRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_ARGBATTENUATEROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    ARGBAttenuateRow = ARGBAttenuateRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 4)) {
+      ARGBAttenuateRow = ARGBAttenuateRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_ARGBATTENUATEROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ARGBAttenuateRow = ARGBAttenuateRow_Any_AVX2;
+    if (IS_ALIGNED(width, 8)) {
+      ARGBAttenuateRow = ARGBAttenuateRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_ARGBATTENUATEROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    ARGBAttenuateRow = ARGBAttenuateRow_Any_NEON;
+    if (IS_ALIGNED(width, 8)) {
+      ARGBAttenuateRow = ARGBAttenuateRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_ARGBATTENUATEROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    ARGBAttenuateRow = ARGBAttenuateRow_Any_MSA;
+    if (IS_ALIGNED(width, 8)) {
+      ARGBAttenuateRow = ARGBAttenuateRow_MSA;
+    }
+  }
+#endif
+
+#if defined(HAS_SCALEROWUP2LINEAR_12_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    Scale2RowUp = ScaleRowUp2_Bilinear_12_Any_SSSE3;
+  }
+#endif
+
+#if defined(HAS_SCALEROWUP2LINEAR_12_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    Scale2RowUp = ScaleRowUp2_Bilinear_12_Any_AVX2;
+  }
+#endif
+
+#if defined(HAS_SCALEROWUP2LINEAR_12_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    Scale2RowUp = ScaleRowUp2_Bilinear_12_Any_NEON;
+  }
+#endif
+
+  // alloc 4 lines temp
+  const int kRowSize = (width + 31) & ~31;
+  align_buffer_64(row, kRowSize * 4 * sizeof(uint16_t));
+  uint16_t* temp_u_1 = (uint16_t*)(row);
+  uint16_t* temp_u_2 = (uint16_t*)(row) + kRowSize;
+  uint16_t* temp_v_1 = (uint16_t*)(row) + kRowSize * 2;
+  uint16_t* temp_v_2 = (uint16_t*)(row) + kRowSize * 3;
+
+  Scale2RowUp(src_u, 0, temp_u_1, kRowSize, width);
+  Scale2RowUp(src_v, 0, temp_v_1, kRowSize, width);
+  I410AlphaToARGBRow(src_y, temp_u_1, temp_v_1, src_a, dst_argb, yuvconstants,
+                     width);
+  if (attenuate) {
+    ARGBAttenuateRow(dst_argb, dst_argb, width);
+  }
+  dst_argb += dst_stride_argb;
+  src_y += src_stride_y;
+  src_a += src_stride_a;
+
+  for (y = 0; y < height - 2; y += 2) {
+    Scale2RowUp(src_u, src_stride_u, temp_u_1, kRowSize, width);
+    Scale2RowUp(src_v, src_stride_v, temp_v_1, kRowSize, width);
+    I410AlphaToARGBRow(src_y, temp_u_1, temp_v_1, src_a, dst_argb, yuvconstants,
+                       width);
+    if (attenuate) {
+      ARGBAttenuateRow(dst_argb, dst_argb, width);
+    }
+    dst_argb += dst_stride_argb;
+    src_y += src_stride_y;
+    src_a += src_stride_a;
+    I410AlphaToARGBRow(src_y, temp_u_2, temp_v_2, src_a, dst_argb, yuvconstants,
+                       width);
+    if (attenuate) {
+      ARGBAttenuateRow(dst_argb, dst_argb, width);
+    }
+    dst_argb += dst_stride_argb;
+    src_y += src_stride_y;
+    src_a += src_stride_a;
+    src_u += src_stride_u;
+    src_v += src_stride_v;
+  }
+
+  if (!(height & 1)) {
+    Scale2RowUp(src_u, 0, temp_u_1, kRowSize, width);
+    Scale2RowUp(src_v, 0, temp_v_1, kRowSize, width);
+    I410AlphaToARGBRow(src_y, temp_u_1, temp_v_1, src_a, dst_argb, yuvconstants,
+                       width);
+    if (attenuate) {
+      ARGBAttenuateRow(dst_argb, dst_argb, width);
+    }
+  }
+
+  free_aligned_buffer_64(row);
+  return 0;
+}
+
+static int I210AlphaToARGBMatrixLinear(const uint16_t* src_y,
+                                       int src_stride_y,
+                                       const uint16_t* src_u,
+                                       int src_stride_u,
+                                       const uint16_t* src_v,
+                                       int src_stride_v,
+                                       const uint16_t* src_a,
+                                       int src_stride_a,
+                                       uint8_t* dst_argb,
+                                       int dst_stride_argb,
+                                       const struct YuvConstants* yuvconstants,
+                                       int width,
+                                       int height,
+                                       int attenuate) {
+  int y;
+  void (*I410AlphaToARGBRow)(const uint16_t* y_buf, const uint16_t* u_buf,
+                             const uint16_t* v_buf, const uint16_t* a_buf,
+                             uint8_t* dst_argb,
+                             const struct YuvConstants* yuvconstants,
+                             int width) = I410AlphaToARGBRow_C;
+  void (*ARGBAttenuateRow)(const uint8_t* src_argb, uint8_t* dst_argb,
+                           int width) = ARGBAttenuateRow_C;
+  void (*ScaleRowUp)(const uint16_t* src_ptr, uint16_t* dst_ptr,
+                     int dst_width) = ScaleRowUp2_Linear_16_Any_C;
+  if (!src_y || !src_u || !src_v || !src_a || !dst_argb || width <= 0 ||
+      height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    dst_argb = dst_argb + (height - 1) * dst_stride_argb;
+    dst_stride_argb = -dst_stride_argb;
+  }
+#if defined(HAS_I410ALPHATOARGBROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    I410AlphaToARGBRow = I410AlphaToARGBRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 8)) {
+      I410AlphaToARGBRow = I410AlphaToARGBRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_I410ALPHATOARGBROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    I410AlphaToARGBRow = I410AlphaToARGBRow_Any_AVX2;
+    if (IS_ALIGNED(width, 16)) {
+      I410AlphaToARGBRow = I410AlphaToARGBRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_ARGBATTENUATEROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    ARGBAttenuateRow = ARGBAttenuateRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 4)) {
+      ARGBAttenuateRow = ARGBAttenuateRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_ARGBATTENUATEROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ARGBAttenuateRow = ARGBAttenuateRow_Any_AVX2;
+    if (IS_ALIGNED(width, 8)) {
+      ARGBAttenuateRow = ARGBAttenuateRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_ARGBATTENUATEROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    ARGBAttenuateRow = ARGBAttenuateRow_Any_NEON;
+    if (IS_ALIGNED(width, 8)) {
+      ARGBAttenuateRow = ARGBAttenuateRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_ARGBATTENUATEROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    ARGBAttenuateRow = ARGBAttenuateRow_Any_MSA;
+    if (IS_ALIGNED(width, 8)) {
+      ARGBAttenuateRow = ARGBAttenuateRow_MSA;
+    }
+  }
+#endif
+
+#if defined(HAS_SCALEROWUP2LINEAR_12_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    ScaleRowUp = ScaleRowUp2_Linear_12_Any_SSSE3;
+  }
+#endif
+#if defined(HAS_SCALEROWUP2LINEAR_12_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ScaleRowUp = ScaleRowUp2_Linear_12_Any_AVX2;
+  }
+#endif
+#if defined(HAS_SCALEROWUP2LINEAR_12_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    ScaleRowUp = ScaleRowUp2_Linear_12_Any_NEON;
+  }
+#endif
+
+  // alloc 2 lines temp
+  const int kRowSize = (width + 31) & ~31;
+  align_buffer_64(row, kRowSize * 2 * sizeof(uint16_t));
+  uint16_t* temp_u = (uint16_t*)(row);
+  uint16_t* temp_v = (uint16_t*)(row) + kRowSize;
+
+  for (y = 0; y < height; ++y) {
+    ScaleRowUp(src_u, temp_u, width);
+    ScaleRowUp(src_v, temp_v, width);
+    I410AlphaToARGBRow(src_y, temp_u, temp_v, src_a, dst_argb, yuvconstants,
+                       width);
+    if (attenuate) {
+      ARGBAttenuateRow(dst_argb, dst_argb, width);
+    }
+    dst_argb += dst_stride_argb;
+    src_a += src_stride_a;
+    src_y += src_stride_y;
+    src_u += src_stride_u;
+    src_v += src_stride_v;
+  }
+  free_aligned_buffer_64(row);
+  return 0;
+}
+
+static int P010ToARGBMatrixBilinear(const uint16_t* src_y,
+                                    int src_stride_y,
+                                    const uint16_t* src_uv,
+                                    int src_stride_uv,
+                                    uint8_t* dst_argb,
+                                    int dst_stride_argb,
+                                    const struct YuvConstants* yuvconstants,
+                                    int width,
+                                    int height) {
+  int y;
+  void (*P410ToARGBRow)(
+      const uint16_t* y_buf, const uint16_t* uv_buf, uint8_t* rgb_buf,
+      const struct YuvConstants* yuvconstants, int width) = P410ToARGBRow_C;
+  void (*Scale2RowUp)(const uint16_t* src_ptr, ptrdiff_t src_stride,
+                      uint16_t* dst_ptr, ptrdiff_t dst_stride, int dst_width) =
+      ScaleUVRowUp2_Bilinear_16_Any_C;
+  if (!src_y || !src_uv || !dst_argb || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    dst_argb = dst_argb + (height - 1) * dst_stride_argb;
+    dst_stride_argb = -dst_stride_argb;
+  }
+#if defined(HAS_P410TOARGBROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    P410ToARGBRow = P410ToARGBRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 8)) {
+      P410ToARGBRow = P410ToARGBRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_P410TOARGBROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    P410ToARGBRow = P410ToARGBRow_Any_AVX2;
+    if (IS_ALIGNED(width, 16)) {
+      P410ToARGBRow = P410ToARGBRow_AVX2;
+    }
+  }
+#endif
+
+#ifdef HAS_SCALEUVROWUP2BILINEAR_16_SSE41
+  if (TestCpuFlag(kCpuHasSSE41)) {
+    Scale2RowUp = ScaleUVRowUp2_Bilinear_16_Any_SSE41;
+  }
+#endif
+
+#ifdef HAS_SCALEUVROWUP2BILINEAR_16_AVX2
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    Scale2RowUp = ScaleUVRowUp2_Bilinear_16_Any_AVX2;
+  }
+#endif
+
+#ifdef HAS_SCALEUVROWUP2BILINEAR_16_NEON
+  if (TestCpuFlag(kCpuHasNEON)) {
+    Scale2RowUp = ScaleUVRowUp2_Bilinear_16_Any_NEON;
+  }
+#endif
+
+  // alloc 2 lines temp
+  const int kRowSize = (2 * width + 31) & ~31;
+  align_buffer_64(row, kRowSize * 2 * sizeof(uint16_t));
+  uint16_t* temp_uv_1 = (uint16_t*)(row);
+  uint16_t* temp_uv_2 = (uint16_t*)(row) + kRowSize;
+
+  Scale2RowUp(src_uv, 0, temp_uv_1, kRowSize, width);
+  P410ToARGBRow(src_y, temp_uv_1, dst_argb, yuvconstants, width);
+  dst_argb += dst_stride_argb;
+  src_y += src_stride_y;
+
+  for (y = 0; y < height - 2; y += 2) {
+    Scale2RowUp(src_uv, src_stride_uv, temp_uv_1, kRowSize, width);
+    P410ToARGBRow(src_y, temp_uv_1, dst_argb, yuvconstants, width);
+    dst_argb += dst_stride_argb;
+    src_y += src_stride_y;
+    P410ToARGBRow(src_y, temp_uv_2, dst_argb, yuvconstants, width);
+    dst_argb += dst_stride_argb;
+    src_y += src_stride_y;
+    src_uv += src_stride_uv;
+  }
+
+  if (!(height & 1)) {
+    Scale2RowUp(src_uv, 0, temp_uv_1, kRowSize, width);
+    P410ToARGBRow(src_y, temp_uv_1, dst_argb, yuvconstants, width);
+  }
+
+  free_aligned_buffer_64(row);
+  return 0;
+}
+
+static int P210ToARGBMatrixLinear(const uint16_t* src_y,
+                                  int src_stride_y,
+                                  const uint16_t* src_uv,
+                                  int src_stride_uv,
+                                  uint8_t* dst_argb,
+                                  int dst_stride_argb,
+                                  const struct YuvConstants* yuvconstants,
+                                  int width,
+                                  int height) {
+  int y;
+  void (*P410ToARGBRow)(
+      const uint16_t* y_buf, const uint16_t* uv_buf, uint8_t* rgb_buf,
+      const struct YuvConstants* yuvconstants, int width) = P410ToARGBRow_C;
+  void (*ScaleRowUp)(const uint16_t* src_uv, uint16_t* dst_uv, int dst_width) =
+      ScaleUVRowUp2_Linear_16_Any_C;
+  if (!src_y || !src_uv || !dst_argb || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    dst_argb = dst_argb + (height - 1) * dst_stride_argb;
+    dst_stride_argb = -dst_stride_argb;
+  }
+#if defined(HAS_P410TOARGBROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    P410ToARGBRow = P410ToARGBRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 8)) {
+      P410ToARGBRow = P410ToARGBRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_P410TOARGBROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    P410ToARGBRow = P410ToARGBRow_Any_AVX2;
+    if (IS_ALIGNED(width, 16)) {
+      P410ToARGBRow = P410ToARGBRow_AVX2;
+    }
+  }
+#endif
+
+#ifdef HAS_SCALEUVROWUP2LINEAR_16_SSE41
+  if (TestCpuFlag(kCpuHasSSE41)) {
+    ScaleRowUp = ScaleUVRowUp2_Linear_16_Any_SSE41;
+  }
+#endif
+
+#ifdef HAS_SCALEUVROWUP2LINEAR_16_AVX2
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ScaleRowUp = ScaleUVRowUp2_Linear_16_Any_AVX2;
+  }
+#endif
+
+#ifdef HAS_SCALEUVROWUP2LINEAR_16_NEON
+  if (TestCpuFlag(kCpuHasNEON)) {
+    ScaleRowUp = ScaleUVRowUp2_Linear_16_Any_NEON;
+  }
+#endif
+
+  const int kRowSize = (2 * width + 31) & ~31;
+  align_buffer_64(row, kRowSize * sizeof(uint16_t));
+  uint16_t* temp_uv = (uint16_t*)(row);
+
+  for (y = 0; y < height; ++y) {
+    ScaleRowUp(src_uv, temp_uv, width);
+    P410ToARGBRow(src_y, temp_uv, dst_argb, yuvconstants, width);
+    dst_argb += dst_stride_argb;
+    src_y += src_stride_y;
+    src_uv += src_stride_uv;
+  }
+
+  free_aligned_buffer_64(row);
+  return 0;
+}
+
+static int P010ToAR30MatrixBilinear(const uint16_t* src_y,
+                                    int src_stride_y,
+                                    const uint16_t* src_uv,
+                                    int src_stride_uv,
+                                    uint8_t* dst_ar30,
+                                    int dst_stride_ar30,
+                                    const struct YuvConstants* yuvconstants,
+                                    int width,
+                                    int height) {
+  int y;
+  void (*P410ToAR30Row)(
+      const uint16_t* y_buf, const uint16_t* uv_buf, uint8_t* rgb_buf,
+      const struct YuvConstants* yuvconstants, int width) = P410ToAR30Row_C;
+  void (*Scale2RowUp)(const uint16_t* src_ptr, ptrdiff_t src_stride,
+                      uint16_t* dst_ptr, ptrdiff_t dst_stride, int dst_width) =
+      ScaleUVRowUp2_Bilinear_16_Any_C;
+  if (!src_y || !src_uv || !dst_ar30 || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    dst_ar30 = dst_ar30 + (height - 1) * dst_stride_ar30;
+    dst_stride_ar30 = -dst_stride_ar30;
+  }
+#if defined(HAS_P410TOAR30ROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    P410ToAR30Row = P410ToAR30Row_Any_SSSE3;
+    if (IS_ALIGNED(width, 8)) {
+      P410ToAR30Row = P410ToAR30Row_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_P410TOAR30ROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    P410ToAR30Row = P410ToAR30Row_Any_AVX2;
+    if (IS_ALIGNED(width, 16)) {
+      P410ToAR30Row = P410ToAR30Row_AVX2;
+    }
+  }
+#endif
+
+#ifdef HAS_SCALEUVROWUP2BILINEAR_16_SSE41
+  if (TestCpuFlag(kCpuHasSSE41)) {
+    Scale2RowUp = ScaleUVRowUp2_Bilinear_16_Any_SSE41;
+  }
+#endif
+
+#ifdef HAS_SCALEUVROWUP2BILINEAR_16_AVX2
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    Scale2RowUp = ScaleUVRowUp2_Bilinear_16_Any_AVX2;
+  }
+#endif
+
+#ifdef HAS_SCALEUVROWUP2BILINEAR_16_NEON
+  if (TestCpuFlag(kCpuHasNEON)) {
+    Scale2RowUp = ScaleUVRowUp2_Bilinear_16_Any_NEON;
+  }
+#endif
+
+  // alloc 2 lines temp
+  const int kRowSize = (2 * width + 31) & ~31;
+  align_buffer_64(row, kRowSize * 2 * sizeof(uint16_t));
+  uint16_t* temp_uv_1 = (uint16_t*)(row);
+  uint16_t* temp_uv_2 = (uint16_t*)(row) + kRowSize;
+
+  Scale2RowUp(src_uv, 0, temp_uv_1, kRowSize, width);
+  P410ToAR30Row(src_y, temp_uv_1, dst_ar30, yuvconstants, width);
+  dst_ar30 += dst_stride_ar30;
+  src_y += src_stride_y;
+
+  for (y = 0; y < height - 2; y += 2) {
+    Scale2RowUp(src_uv, src_stride_uv, temp_uv_1, kRowSize, width);
+    P410ToAR30Row(src_y, temp_uv_1, dst_ar30, yuvconstants, width);
+    dst_ar30 += dst_stride_ar30;
+    src_y += src_stride_y;
+    P410ToAR30Row(src_y, temp_uv_2, dst_ar30, yuvconstants, width);
+    dst_ar30 += dst_stride_ar30;
+    src_y += src_stride_y;
+    src_uv += src_stride_uv;
+  }
+
+  if (!(height & 1)) {
+    Scale2RowUp(src_uv, 0, temp_uv_1, kRowSize, width);
+    P410ToAR30Row(src_y, temp_uv_1, dst_ar30, yuvconstants, width);
+  }
+
+  free_aligned_buffer_64(row);
+  return 0;
+}
+
+static int P210ToAR30MatrixLinear(const uint16_t* src_y,
+                                  int src_stride_y,
+                                  const uint16_t* src_uv,
+                                  int src_stride_uv,
+                                  uint8_t* dst_ar30,
+                                  int dst_stride_ar30,
+                                  const struct YuvConstants* yuvconstants,
+                                  int width,
+                                  int height) {
+  int y;
+  void (*P410ToAR30Row)(
+      const uint16_t* y_buf, const uint16_t* uv_buf, uint8_t* rgb_buf,
+      const struct YuvConstants* yuvconstants, int width) = P410ToAR30Row_C;
+  void (*ScaleRowUp)(const uint16_t* src_uv, uint16_t* dst_uv, int dst_width) =
+      ScaleUVRowUp2_Linear_16_Any_C;
+  if (!src_y || !src_uv || !dst_ar30 || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    dst_ar30 = dst_ar30 + (height - 1) * dst_stride_ar30;
+    dst_stride_ar30 = -dst_stride_ar30;
+  }
+#if defined(HAS_P410TOAR30ROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    P410ToAR30Row = P410ToAR30Row_Any_SSSE3;
+    if (IS_ALIGNED(width, 8)) {
+      P410ToAR30Row = P410ToAR30Row_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_P410TOAR30ROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    P410ToAR30Row = P410ToAR30Row_Any_AVX2;
+    if (IS_ALIGNED(width, 16)) {
+      P410ToAR30Row = P410ToAR30Row_AVX2;
+    }
+  }
+#endif
+
+#ifdef HAS_SCALEUVROWUP2LINEAR_16_SSE41
+  if (TestCpuFlag(kCpuHasSSE41)) {
+    ScaleRowUp = ScaleUVRowUp2_Linear_16_Any_SSE41;
+  }
+#endif
+
+#ifdef HAS_SCALEUVROWUP2LINEAR_16_AVX2
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ScaleRowUp = ScaleUVRowUp2_Linear_16_Any_AVX2;
+  }
+#endif
+
+#ifdef HAS_SCALEUVROWUP2LINEAR_16_NEON
+  if (TestCpuFlag(kCpuHasNEON)) {
+    ScaleRowUp = ScaleUVRowUp2_Linear_16_Any_NEON;
+  }
+#endif
+
+  const int kRowSize = (2 * width + 31) & ~31;
+  align_buffer_64(row, kRowSize * sizeof(uint16_t));
+  uint16_t* temp_uv = (uint16_t*)(row);
+
+  for (y = 0; y < height; ++y) {
+    ScaleRowUp(src_uv, temp_uv, width);
+    P410ToAR30Row(src_y, temp_uv, dst_ar30, yuvconstants, width);
+    dst_ar30 += dst_stride_ar30;
+    src_y += src_stride_y;
+    src_uv += src_stride_uv;
+  }
+
+  free_aligned_buffer_64(row);
+  return 0;
+}
+
+LIBYUV_API
+int I420ToARGBMatrixFilter(const uint8_t* src_y,
+                           int src_stride_y,
+                           const uint8_t* src_u,
+                           int src_stride_u,
+                           const uint8_t* src_v,
+                           int src_stride_v,
+                           uint8_t* dst_argb,
+                           int dst_stride_argb,
+                           const struct YuvConstants* yuvconstants,
+                           int width,
+                           int height,
+                           enum FilterMode filter) {
+  switch (filter) {
+    case kFilterNone:
+      return I420ToARGBMatrix(src_y, src_stride_y, src_u, src_stride_u, src_v,
+                              src_stride_v, dst_argb, dst_stride_argb,
+                              yuvconstants, width, height);
+    case kFilterBilinear:
+    case kFilterBox:
+      return I420ToARGBMatrixBilinear(
+          src_y, src_stride_y, src_u, src_stride_u, src_v, src_stride_v,
+          dst_argb, dst_stride_argb, yuvconstants, width, height);
+    case kFilterLinear:
+      // Actually we can do this, but probably there's no usage.
+      return -1;
+  }
+
+  return -1;
+}
+
+LIBYUV_API
+int I422ToARGBMatrixFilter(const uint8_t* src_y,
+                           int src_stride_y,
+                           const uint8_t* src_u,
+                           int src_stride_u,
+                           const uint8_t* src_v,
+                           int src_stride_v,
+                           uint8_t* dst_argb,
+                           int dst_stride_argb,
+                           const struct YuvConstants* yuvconstants,
+                           int width,
+                           int height,
+                           enum FilterMode filter) {
+  switch (filter) {
+    case kFilterNone:
+      return I422ToARGBMatrix(src_y, src_stride_y, src_u, src_stride_u, src_v,
+                              src_stride_v, dst_argb, dst_stride_argb,
+                              yuvconstants, width, height);
+    case kFilterBilinear:
+    case kFilterBox:
+    case kFilterLinear:
+      return I422ToARGBMatrixLinear(
+          src_y, src_stride_y, src_u, src_stride_u, src_v, src_stride_v,
+          dst_argb, dst_stride_argb, yuvconstants, width, height);
+  }
+
+  return -1;
+}
+
+LIBYUV_API
+int I010ToAR30MatrixFilter(const uint16_t* src_y,
+                           int src_stride_y,
+                           const uint16_t* src_u,
+                           int src_stride_u,
+                           const uint16_t* src_v,
+                           int src_stride_v,
+                           uint8_t* dst_ar30,
+                           int dst_stride_ar30,
+                           const struct YuvConstants* yuvconstants,
+                           int width,
+                           int height,
+                           enum FilterMode filter) {
+  switch (filter) {
+    case kFilterNone:
+      return I010ToAR30Matrix(src_y, src_stride_y, src_u, src_stride_u, src_v,
+                              src_stride_v, dst_ar30, dst_stride_ar30,
+                              yuvconstants, width, height);
+    case kFilterBilinear:
+    case kFilterBox:
+      return I010ToAR30MatrixBilinear(
+          src_y, src_stride_y, src_u, src_stride_u, src_v, src_stride_v,
+          dst_ar30, dst_stride_ar30, yuvconstants, width, height);
+    case kFilterLinear:
+      return -1;
+  }
+
+  return -1;
+}
+
+LIBYUV_API
+int I210ToAR30MatrixFilter(const uint16_t* src_y,
+                           int src_stride_y,
+                           const uint16_t* src_u,
+                           int src_stride_u,
+                           const uint16_t* src_v,
+                           int src_stride_v,
+                           uint8_t* dst_ar30,
+                           int dst_stride_ar30,
+                           const struct YuvConstants* yuvconstants,
+                           int width,
+                           int height,
+                           enum FilterMode filter) {
+  switch (filter) {
+    case kFilterNone:
+      return I210ToAR30Matrix(src_y, src_stride_y, src_u, src_stride_u, src_v,
+                              src_stride_v, dst_ar30, dst_stride_ar30,
+                              yuvconstants, width, height);
+    case kFilterBilinear:
+    case kFilterBox:
+    case kFilterLinear:
+      return I210ToAR30MatrixLinear(
+          src_y, src_stride_y, src_u, src_stride_u, src_v, src_stride_v,
+          dst_ar30, dst_stride_ar30, yuvconstants, width, height);
+  }
+
+  return -1;
+}
+
+LIBYUV_API
+int I010ToARGBMatrixFilter(const uint16_t* src_y,
+                           int src_stride_y,
+                           const uint16_t* src_u,
+                           int src_stride_u,
+                           const uint16_t* src_v,
+                           int src_stride_v,
+                           uint8_t* dst_argb,
+                           int dst_stride_argb,
+                           const struct YuvConstants* yuvconstants,
+                           int width,
+                           int height,
+                           enum FilterMode filter) {
+  switch (filter) {
+    case kFilterNone:
+      return I010ToARGBMatrix(src_y, src_stride_y, src_u, src_stride_u, src_v,
+                              src_stride_v, dst_argb, dst_stride_argb,
+                              yuvconstants, width, height);
+    case kFilterBilinear:
+    case kFilterBox:
+      return I010ToARGBMatrixBilinear(
+          src_y, src_stride_y, src_u, src_stride_u, src_v, src_stride_v,
+          dst_argb, dst_stride_argb, yuvconstants, width, height);
+    case kFilterLinear:
+      return -1;
+  }
+
+  return -1;
+}
+
+LIBYUV_API
+int I210ToARGBMatrixFilter(const uint16_t* src_y,
+                           int src_stride_y,
+                           const uint16_t* src_u,
+                           int src_stride_u,
+                           const uint16_t* src_v,
+                           int src_stride_v,
+                           uint8_t* dst_argb,
+                           int dst_stride_argb,
+                           const struct YuvConstants* yuvconstants,
+                           int width,
+                           int height,
+                           enum FilterMode filter) {
+  switch (filter) {
+    case kFilterNone:
+      return I210ToARGBMatrix(src_y, src_stride_y, src_u, src_stride_u, src_v,
+                              src_stride_v, dst_argb, dst_stride_argb,
+                              yuvconstants, width, height);
+    case kFilterBilinear:
+    case kFilterBox:
+    case kFilterLinear:
+      return I210ToARGBMatrixLinear(
+          src_y, src_stride_y, src_u, src_stride_u, src_v, src_stride_v,
+          dst_argb, dst_stride_argb, yuvconstants, width, height);
+  }
+
+  return -1;
+}
+
+LIBYUV_API
+int I420AlphaToARGBMatrixFilter(const uint8_t* src_y,
+                                int src_stride_y,
+                                const uint8_t* src_u,
+                                int src_stride_u,
+                                const uint8_t* src_v,
+                                int src_stride_v,
+                                const uint8_t* src_a,
+                                int src_stride_a,
+                                uint8_t* dst_argb,
+                                int dst_stride_argb,
+                                const struct YuvConstants* yuvconstants,
+                                int width,
+                                int height,
+                                int attenuate,
+                                enum FilterMode filter) {
+  switch (filter) {
+    case kFilterNone:
+      return I420AlphaToARGBMatrix(src_y, src_stride_y, src_u, src_stride_u,
+                                   src_v, src_stride_v, src_a, src_stride_a,
+                                   dst_argb, dst_stride_argb, yuvconstants,
+                                   width, height, attenuate);
+    case kFilterBilinear:
+    case kFilterBox:
+      return I420AlphaToARGBMatrixBilinear(
+          src_y, src_stride_y, src_u, src_stride_u, src_v, src_stride_v, src_a,
+          src_stride_a, dst_argb, dst_stride_argb, yuvconstants, width, height,
+          attenuate);
+    case kFilterLinear:
+      return -1;
+  }
+
+  return -1;
+}
+
+LIBYUV_API
+int I422AlphaToARGBMatrixFilter(const uint8_t* src_y,
+                                int src_stride_y,
+                                const uint8_t* src_u,
+                                int src_stride_u,
+                                const uint8_t* src_v,
+                                int src_stride_v,
+                                const uint8_t* src_a,
+                                int src_stride_a,
+                                uint8_t* dst_argb,
+                                int dst_stride_argb,
+                                const struct YuvConstants* yuvconstants,
+                                int width,
+                                int height,
+                                int attenuate,
+                                enum FilterMode filter) {
+  switch (filter) {
+    case kFilterNone:
+      return I422AlphaToARGBMatrix(src_y, src_stride_y, src_u, src_stride_u,
+                                   src_v, src_stride_v, src_a, src_stride_a,
+                                   dst_argb, dst_stride_argb, yuvconstants,
+                                   width, height, attenuate);
+    case kFilterBilinear:
+    case kFilterBox:
+    case kFilterLinear:
+      return I422AlphaToARGBMatrixLinear(
+          src_y, src_stride_y, src_u, src_stride_u, src_v, src_stride_v, src_a,
+          src_stride_a, dst_argb, dst_stride_argb, yuvconstants, width, height,
+          attenuate);
+  }
+
+  return -1;
+}
+
+LIBYUV_API
+int I010AlphaToARGBMatrixFilter(const uint16_t* src_y,
+                                int src_stride_y,
+                                const uint16_t* src_u,
+                                int src_stride_u,
+                                const uint16_t* src_v,
+                                int src_stride_v,
+                                const uint16_t* src_a,
+                                int src_stride_a,
+                                uint8_t* dst_argb,
+                                int dst_stride_argb,
+                                const struct YuvConstants* yuvconstants,
+                                int width,
+                                int height,
+                                int attenuate,
+                                enum FilterMode filter) {
+  switch (filter) {
+    case kFilterNone:
+      return I010AlphaToARGBMatrix(src_y, src_stride_y, src_u, src_stride_u,
+                                   src_v, src_stride_v, src_a, src_stride_a,
+                                   dst_argb, dst_stride_argb, yuvconstants,
+                                   width, height, attenuate);
+    case kFilterBilinear:
+    case kFilterBox:
+      return I010AlphaToARGBMatrixBilinear(
+          src_y, src_stride_y, src_u, src_stride_u, src_v, src_stride_v, src_a,
+          src_stride_a, dst_argb, dst_stride_argb, yuvconstants, width, height,
+          attenuate);
+    case kFilterLinear:
+      return -1;
+  }
+
+  return -1;
+}
+
+LIBYUV_API
+int I210AlphaToARGBMatrixFilter(const uint16_t* src_y,
+                                int src_stride_y,
+                                const uint16_t* src_u,
+                                int src_stride_u,
+                                const uint16_t* src_v,
+                                int src_stride_v,
+                                const uint16_t* src_a,
+                                int src_stride_a,
+                                uint8_t* dst_argb,
+                                int dst_stride_argb,
+                                const struct YuvConstants* yuvconstants,
+                                int width,
+                                int height,
+                                int attenuate,
+                                enum FilterMode filter) {
+  switch (filter) {
+    case kFilterNone:
+      return I210AlphaToARGBMatrix(src_y, src_stride_y, src_u, src_stride_u,
+                                   src_v, src_stride_v, src_a, src_stride_a,
+                                   dst_argb, dst_stride_argb, yuvconstants,
+                                   width, height, attenuate);
+    case kFilterBilinear:
+    case kFilterBox:
+    case kFilterLinear:
+      return I210AlphaToARGBMatrixLinear(
+          src_y, src_stride_y, src_u, src_stride_u, src_v, src_stride_v, src_a,
+          src_stride_a, dst_argb, dst_stride_argb, yuvconstants, width, height,
+          attenuate);
+  }
+
+  return -1;
+}
+
+LIBYUV_API
+int P010ToARGBMatrixFilter(const uint16_t* src_y,
+                           int src_stride_y,
+                           const uint16_t* src_uv,
+                           int src_stride_uv,
+                           uint8_t* dst_argb,
+                           int dst_stride_argb,
+                           const struct YuvConstants* yuvconstants,
+                           int width,
+                           int height,
+                           enum FilterMode filter) {
+  switch (filter) {
+    case kFilterNone:
+      return P010ToARGBMatrix(src_y, src_stride_y, src_uv, src_stride_uv,
+                              dst_argb, dst_stride_argb, yuvconstants, width,
+                              height);
+    case kFilterBilinear:
+    case kFilterBox:
+      return P010ToARGBMatrixBilinear(src_y, src_stride_y, src_uv,
+                                      src_stride_uv, dst_argb, dst_stride_argb,
+                                      yuvconstants, width, height);
+    case kFilterLinear:
+      return -1;
+  }
+
+  return -1;
+}
+
+LIBYUV_API
+int P210ToARGBMatrixFilter(const uint16_t* src_y,
+                           int src_stride_y,
+                           const uint16_t* src_uv,
+                           int src_stride_uv,
+                           uint8_t* dst_argb,
+                           int dst_stride_argb,
+                           const struct YuvConstants* yuvconstants,
+                           int width,
+                           int height,
+                           enum FilterMode filter) {
+  switch (filter) {
+    case kFilterNone:
+      return P210ToARGBMatrix(src_y, src_stride_y, src_uv, src_stride_uv,
+                              dst_argb, dst_stride_argb, yuvconstants, width,
+                              height);
+    case kFilterBilinear:
+    case kFilterBox:
+    case kFilterLinear:
+      return P210ToARGBMatrixLinear(src_y, src_stride_y, src_uv, src_stride_uv,
+                                    dst_argb, dst_stride_argb, yuvconstants,
+                                    width, height);
+  }
+
+  return -1;
+}
+
+LIBYUV_API
+int P010ToAR30MatrixFilter(const uint16_t* src_y,
+                           int src_stride_y,
+                           const uint16_t* src_uv,
+                           int src_stride_uv,
+                           uint8_t* dst_ar30,
+                           int dst_stride_ar30,
+                           const struct YuvConstants* yuvconstants,
+                           int width,
+                           int height,
+                           enum FilterMode filter) {
+  switch (filter) {
+    case kFilterNone:
+      return P010ToAR30Matrix(src_y, src_stride_y, src_uv, src_stride_uv,
+                              dst_ar30, dst_stride_ar30, yuvconstants, width,
+                              height);
+    case kFilterBilinear:
+    case kFilterBox:
+      return P010ToAR30MatrixBilinear(src_y, src_stride_y, src_uv,
+                                      src_stride_uv, dst_ar30, dst_stride_ar30,
+                                      yuvconstants, width, height);
+    case kFilterLinear:
+      return -1;
+  }
+
+  return -1;
+}
+
+LIBYUV_API
+int P210ToAR30MatrixFilter(const uint16_t* src_y,
+                           int src_stride_y,
+                           const uint16_t* src_uv,
+                           int src_stride_uv,
+                           uint8_t* dst_ar30,
+                           int dst_stride_ar30,
+                           const struct YuvConstants* yuvconstants,
+                           int width,
+                           int height,
+                           enum FilterMode filter) {
+  switch (filter) {
+    case kFilterNone:
+      return P210ToAR30Matrix(src_y, src_stride_y, src_uv, src_stride_uv,
+                              dst_ar30, dst_stride_ar30, yuvconstants, width,
+                              height);
+    case kFilterBilinear:
+    case kFilterBox:
+    case kFilterLinear:
+      return P210ToAR30MatrixLinear(src_y, src_stride_y, src_uv, src_stride_uv,
+                                    dst_ar30, dst_stride_ar30, yuvconstants,
+                                    width, height);
+  }
+
+  return -1;
+}
+
+#ifdef __cplusplus
+}  // extern "C"
+}  // namespace libyuv
+#endif
diff --git a/3rdparty/libyuv/src/source/convert_from.cc b/3rdparty/libyuv/src/source/convert_from.cc
new file mode 100644
index 00000000..8bd07e4c
--- /dev/null
+++ b/3rdparty/libyuv/src/source/convert_from.cc
@@ -0,0 +1,858 @@
+/*
+ *  Copyright 2012 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include "libyuv/convert_from.h"
+
+#include "libyuv/basic_types.h"
+#include "libyuv/convert.h"  // For I420Copy
+#include "libyuv/cpu_id.h"
+#include "libyuv/planar_functions.h"
+#include "libyuv/rotate.h"
+#include "libyuv/row.h"
+#include "libyuv/scale.h"  // For ScalePlane()
+#include "libyuv/video_common.h"
+
+#ifdef __cplusplus
+namespace libyuv {
+extern "C" {
+#endif
+
+#define SUBSAMPLE(v, a, s) (v < 0) ? (-((-v + a) >> s)) : ((v + a) >> s)
+static __inline int Abs(int v) {
+  return v >= 0 ? v : -v;
+}
+
+// I420 To any I4xx YUV format with mirroring.
+// TODO(fbarchard): Consider kFilterNone for Y, or CopyPlane
+
+static int I420ToI4xx(const uint8_t* src_y,
+                      int src_stride_y,
+                      const uint8_t* src_u,
+                      int src_stride_u,
+                      const uint8_t* src_v,
+                      int src_stride_v,
+                      uint8_t* dst_y,
+                      int dst_stride_y,
+                      uint8_t* dst_u,
+                      int dst_stride_u,
+                      uint8_t* dst_v,
+                      int dst_stride_v,
+                      int src_y_width,
+                      int src_y_height,
+                      int dst_uv_width,
+                      int dst_uv_height) {
+  const int dst_y_width = Abs(src_y_width);
+  const int dst_y_height = Abs(src_y_height);
+  const int src_uv_width = SUBSAMPLE(src_y_width, 1, 1);
+  const int src_uv_height = SUBSAMPLE(src_y_height, 1, 1);
+  if (src_y_width == 0 || src_y_height == 0 || dst_uv_width <= 0 ||
+      dst_uv_height <= 0) {
+    return -1;
+  }
+  if (dst_y) {
+    ScalePlane(src_y, src_stride_y, src_y_width, src_y_height, dst_y,
+               dst_stride_y, dst_y_width, dst_y_height, kFilterBilinear);
+  }
+  ScalePlane(src_u, src_stride_u, src_uv_width, src_uv_height, dst_u,
+             dst_stride_u, dst_uv_width, dst_uv_height, kFilterBilinear);
+  ScalePlane(src_v, src_stride_v, src_uv_width, src_uv_height, dst_v,
+             dst_stride_v, dst_uv_width, dst_uv_height, kFilterBilinear);
+  return 0;
+}
+
+// Convert 8 bit YUV to 10 bit.
+LIBYUV_API
+int I420ToI010(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint16_t* dst_y,
+               int dst_stride_y,
+               uint16_t* dst_u,
+               int dst_stride_u,
+               uint16_t* dst_v,
+               int dst_stride_v,
+               int width,
+               int height) {
+  int halfwidth = (width + 1) >> 1;
+  int halfheight = (height + 1) >> 1;
+  if ((!src_y && dst_y) || !src_u || !src_v || !dst_u || !dst_v || width <= 0 ||
+      height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    halfheight = (height + 1) >> 1;
+    src_y = src_y + (height - 1) * src_stride_y;
+    src_u = src_u + (halfheight - 1) * src_stride_u;
+    src_v = src_v + (halfheight - 1) * src_stride_v;
+    src_stride_y = -src_stride_y;
+    src_stride_u = -src_stride_u;
+    src_stride_v = -src_stride_v;
+  }
+
+  // Convert Y plane.
+  Convert8To16Plane(src_y, src_stride_y, dst_y, dst_stride_y, 1024, width,
+                    height);
+  // Convert UV planes.
+  Convert8To16Plane(src_u, src_stride_u, dst_u, dst_stride_u, 1024, halfwidth,
+                    halfheight);
+  Convert8To16Plane(src_v, src_stride_v, dst_v, dst_stride_v, 1024, halfwidth,
+                    halfheight);
+  return 0;
+}
+
+// Convert 8 bit YUV to 12 bit.
+LIBYUV_API
+int I420ToI012(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint16_t* dst_y,
+               int dst_stride_y,
+               uint16_t* dst_u,
+               int dst_stride_u,
+               uint16_t* dst_v,
+               int dst_stride_v,
+               int width,
+               int height) {
+  int halfwidth = (width + 1) >> 1;
+  int halfheight = (height + 1) >> 1;
+  if ((!src_y && dst_y) || !src_u || !src_v || !dst_u || !dst_v || width <= 0 ||
+      height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    halfheight = (height + 1) >> 1;
+    src_y = src_y + (height - 1) * src_stride_y;
+    src_u = src_u + (halfheight - 1) * src_stride_u;
+    src_v = src_v + (halfheight - 1) * src_stride_v;
+    src_stride_y = -src_stride_y;
+    src_stride_u = -src_stride_u;
+    src_stride_v = -src_stride_v;
+  }
+
+  // Convert Y plane.
+  Convert8To16Plane(src_y, src_stride_y, dst_y, dst_stride_y, 4096, width,
+                    height);
+  // Convert UV planes.
+  Convert8To16Plane(src_u, src_stride_u, dst_u, dst_stride_u, 4096, halfwidth,
+                    halfheight);
+  Convert8To16Plane(src_v, src_stride_v, dst_v, dst_stride_v, 4096, halfwidth,
+                    halfheight);
+  return 0;
+}
+
+// 420 chroma is 1/2 width, 1/2 height
+// 422 chroma is 1/2 width, 1x height
+LIBYUV_API
+int I420ToI422(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_u,
+               int dst_stride_u,
+               uint8_t* dst_v,
+               int dst_stride_v,
+               int width,
+               int height) {
+  const int dst_uv_width = (Abs(width) + 1) >> 1;
+  const int dst_uv_height = Abs(height);
+  return I420ToI4xx(src_y, src_stride_y, src_u, src_stride_u, src_v,
+                    src_stride_v, dst_y, dst_stride_y, dst_u, dst_stride_u,
+                    dst_v, dst_stride_v, width, height, dst_uv_width,
+                    dst_uv_height);
+}
+
+// 420 chroma is 1/2 width, 1/2 height
+// 444 chroma is 1x width, 1x height
+LIBYUV_API
+int I420ToI444(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_u,
+               int dst_stride_u,
+               uint8_t* dst_v,
+               int dst_stride_v,
+               int width,
+               int height) {
+  const int dst_uv_width = Abs(width);
+  const int dst_uv_height = Abs(height);
+  return I420ToI4xx(src_y, src_stride_y, src_u, src_stride_u, src_v,
+                    src_stride_v, dst_y, dst_stride_y, dst_u, dst_stride_u,
+                    dst_v, dst_stride_v, width, height, dst_uv_width,
+                    dst_uv_height);
+}
+
+// 420 chroma to 444 chroma, 10/12 bit version
+LIBYUV_API
+int I010ToI410(const uint16_t* src_y,
+               int src_stride_y,
+               const uint16_t* src_u,
+               int src_stride_u,
+               const uint16_t* src_v,
+               int src_stride_v,
+               uint16_t* dst_y,
+               int dst_stride_y,
+               uint16_t* dst_u,
+               int dst_stride_u,
+               uint16_t* dst_v,
+               int dst_stride_v,
+               int width,
+               int height) {
+  if (width == 0 || height == 0) {
+    return -1;
+  }
+
+  if (dst_y) {
+    ScalePlane_12(src_y, src_stride_y, width, height, dst_y, dst_stride_y,
+                  Abs(width), Abs(height), kFilterBilinear);
+  }
+  ScalePlane_12(src_u, src_stride_u, SUBSAMPLE(width, 1, 1),
+                SUBSAMPLE(height, 1, 1), dst_u, dst_stride_u, Abs(width),
+                Abs(height), kFilterBilinear);
+  ScalePlane_12(src_v, src_stride_v, SUBSAMPLE(width, 1, 1),
+                SUBSAMPLE(height, 1, 1), dst_v, dst_stride_v, Abs(width),
+                Abs(height), kFilterBilinear);
+  return 0;
+}
+
+// 422 chroma to 444 chroma, 10/12 bit version
+LIBYUV_API
+int I210ToI410(const uint16_t* src_y,
+               int src_stride_y,
+               const uint16_t* src_u,
+               int src_stride_u,
+               const uint16_t* src_v,
+               int src_stride_v,
+               uint16_t* dst_y,
+               int dst_stride_y,
+               uint16_t* dst_u,
+               int dst_stride_u,
+               uint16_t* dst_v,
+               int dst_stride_v,
+               int width,
+               int height) {
+  if (width == 0 || height == 0) {
+    return -1;
+  }
+
+  if (dst_y) {
+    ScalePlane_12(src_y, src_stride_y, width, height, dst_y, dst_stride_y,
+                  Abs(width), Abs(height), kFilterBilinear);
+  }
+  ScalePlane_12(src_u, src_stride_u, SUBSAMPLE(width, 1, 1), height, dst_u,
+                dst_stride_u, Abs(width), Abs(height), kFilterBilinear);
+  ScalePlane_12(src_v, src_stride_v, SUBSAMPLE(width, 1, 1), height, dst_v,
+                dst_stride_v, Abs(width), Abs(height), kFilterBilinear);
+  return 0;
+}
+
+// 422 chroma is 1/2 width, 1x height
+// 444 chroma is 1x width, 1x height
+LIBYUV_API
+int I422ToI444(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_u,
+               int dst_stride_u,
+               uint8_t* dst_v,
+               int dst_stride_v,
+               int width,
+               int height) {
+  if (width == 0 || height == 0) {
+    return -1;
+  }
+
+  if (dst_y) {
+    ScalePlane(src_y, src_stride_y, width, height, dst_y, dst_stride_y,
+               Abs(width), Abs(height), kFilterBilinear);
+  }
+  ScalePlane(src_u, src_stride_u, SUBSAMPLE(width, 1, 1), height, dst_u,
+             dst_stride_u, Abs(width), Abs(height), kFilterBilinear);
+  ScalePlane(src_v, src_stride_v, SUBSAMPLE(width, 1, 1), height, dst_v,
+             dst_stride_v, Abs(width), Abs(height), kFilterBilinear);
+  return 0;
+}
+
+// Copy to I400. Source can be I420,422,444,400,NV12,NV21
+LIBYUV_API
+int I400Copy(const uint8_t* src_y,
+             int src_stride_y,
+             uint8_t* dst_y,
+             int dst_stride_y,
+             int width,
+             int height) {
+  if (!src_y || !dst_y || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    src_y = src_y + (height - 1) * src_stride_y;
+    src_stride_y = -src_stride_y;
+  }
+  CopyPlane(src_y, src_stride_y, dst_y, dst_stride_y, width, height);
+  return 0;
+}
+
+LIBYUV_API
+int I422ToYUY2(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_yuy2,
+               int dst_stride_yuy2,
+               int width,
+               int height) {
+  int y;
+  void (*I422ToYUY2Row)(const uint8_t* src_y, const uint8_t* src_u,
+                        const uint8_t* src_v, uint8_t* dst_yuy2, int width) =
+      I422ToYUY2Row_C;
+  if (!src_y || !src_u || !src_v || !dst_yuy2 || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    dst_yuy2 = dst_yuy2 + (height - 1) * dst_stride_yuy2;
+    dst_stride_yuy2 = -dst_stride_yuy2;
+  }
+  // Coalesce rows.
+  if (src_stride_y == width && src_stride_u * 2 == width &&
+      src_stride_v * 2 == width && dst_stride_yuy2 == width * 2) {
+    width *= height;
+    height = 1;
+    src_stride_y = src_stride_u = src_stride_v = dst_stride_yuy2 = 0;
+  }
+#if defined(HAS_I422TOYUY2ROW_SSE2)
+  if (TestCpuFlag(kCpuHasSSE2)) {
+    I422ToYUY2Row = I422ToYUY2Row_Any_SSE2;
+    if (IS_ALIGNED(width, 16)) {
+      I422ToYUY2Row = I422ToYUY2Row_SSE2;
+    }
+  }
+#endif
+#if defined(HAS_I422TOYUY2ROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    I422ToYUY2Row = I422ToYUY2Row_Any_AVX2;
+    if (IS_ALIGNED(width, 32)) {
+      I422ToYUY2Row = I422ToYUY2Row_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_I422TOYUY2ROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    I422ToYUY2Row = I422ToYUY2Row_Any_NEON;
+    if (IS_ALIGNED(width, 16)) {
+      I422ToYUY2Row = I422ToYUY2Row_NEON;
+    }
+  }
+#endif
+
+  for (y = 0; y < height; ++y) {
+    I422ToYUY2Row(src_y, src_u, src_v, dst_yuy2, width);
+    src_y += src_stride_y;
+    src_u += src_stride_u;
+    src_v += src_stride_v;
+    dst_yuy2 += dst_stride_yuy2;
+  }
+  return 0;
+}
+
+LIBYUV_API
+int I420ToYUY2(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_yuy2,
+               int dst_stride_yuy2,
+               int width,
+               int height) {
+  int y;
+  void (*I422ToYUY2Row)(const uint8_t* src_y, const uint8_t* src_u,
+                        const uint8_t* src_v, uint8_t* dst_yuy2, int width) =
+      I422ToYUY2Row_C;
+  if (!src_y || !src_u || !src_v || !dst_yuy2 || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    dst_yuy2 = dst_yuy2 + (height - 1) * dst_stride_yuy2;
+    dst_stride_yuy2 = -dst_stride_yuy2;
+  }
+#if defined(HAS_I422TOYUY2ROW_SSE2)
+  if (TestCpuFlag(kCpuHasSSE2)) {
+    I422ToYUY2Row = I422ToYUY2Row_Any_SSE2;
+    if (IS_ALIGNED(width, 16)) {
+      I422ToYUY2Row = I422ToYUY2Row_SSE2;
+    }
+  }
+#endif
+#if defined(HAS_I422TOYUY2ROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    I422ToYUY2Row = I422ToYUY2Row_Any_AVX2;
+    if (IS_ALIGNED(width, 32)) {
+      I422ToYUY2Row = I422ToYUY2Row_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_I422TOYUY2ROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    I422ToYUY2Row = I422ToYUY2Row_Any_NEON;
+    if (IS_ALIGNED(width, 16)) {
+      I422ToYUY2Row = I422ToYUY2Row_NEON;
+    }
+  }
+#endif
+#if defined(HAS_I422TOYUY2ROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    I422ToYUY2Row = I422ToYUY2Row_Any_MSA;
+    if (IS_ALIGNED(width, 32)) {
+      I422ToYUY2Row = I422ToYUY2Row_MSA;
+    }
+  }
+#endif
+#if defined(HAS_I422TOYUY2ROW_LASX)
+  if (TestCpuFlag(kCpuHasLASX)) {
+    I422ToYUY2Row = I422ToYUY2Row_Any_LASX;
+    if (IS_ALIGNED(width, 32)) {
+      I422ToYUY2Row = I422ToYUY2Row_LASX;
+    }
+  }
+#endif
+
+  for (y = 0; y < height - 1; y += 2) {
+    I422ToYUY2Row(src_y, src_u, src_v, dst_yuy2, width);
+    I422ToYUY2Row(src_y + src_stride_y, src_u, src_v,
+                  dst_yuy2 + dst_stride_yuy2, width);
+    src_y += src_stride_y * 2;
+    src_u += src_stride_u;
+    src_v += src_stride_v;
+    dst_yuy2 += dst_stride_yuy2 * 2;
+  }
+  if (height & 1) {
+    I422ToYUY2Row(src_y, src_u, src_v, dst_yuy2, width);
+  }
+  return 0;
+}
+
+LIBYUV_API
+int I422ToUYVY(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_uyvy,
+               int dst_stride_uyvy,
+               int width,
+               int height) {
+  int y;
+  void (*I422ToUYVYRow)(const uint8_t* src_y, const uint8_t* src_u,
+                        const uint8_t* src_v, uint8_t* dst_uyvy, int width) =
+      I422ToUYVYRow_C;
+  if (!src_y || !src_u || !src_v || !dst_uyvy || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    dst_uyvy = dst_uyvy + (height - 1) * dst_stride_uyvy;
+    dst_stride_uyvy = -dst_stride_uyvy;
+  }
+  // Coalesce rows.
+  if (src_stride_y == width && src_stride_u * 2 == width &&
+      src_stride_v * 2 == width && dst_stride_uyvy == width * 2) {
+    width *= height;
+    height = 1;
+    src_stride_y = src_stride_u = src_stride_v = dst_stride_uyvy = 0;
+  }
+#if defined(HAS_I422TOUYVYROW_SSE2)
+  if (TestCpuFlag(kCpuHasSSE2)) {
+    I422ToUYVYRow = I422ToUYVYRow_Any_SSE2;
+    if (IS_ALIGNED(width, 16)) {
+      I422ToUYVYRow = I422ToUYVYRow_SSE2;
+    }
+  }
+#endif
+#if defined(HAS_I422TOUYVYROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    I422ToUYVYRow = I422ToUYVYRow_Any_AVX2;
+    if (IS_ALIGNED(width, 32)) {
+      I422ToUYVYRow = I422ToUYVYRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_I422TOUYVYROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    I422ToUYVYRow = I422ToUYVYRow_Any_NEON;
+    if (IS_ALIGNED(width, 16)) {
+      I422ToUYVYRow = I422ToUYVYRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_I422TOUYVYROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    I422ToUYVYRow = I422ToUYVYRow_Any_MSA;
+    if (IS_ALIGNED(width, 32)) {
+      I422ToUYVYRow = I422ToUYVYRow_MSA;
+    }
+  }
+#endif
+#if defined(HAS_I422TOUYVYROW_LASX)
+  if (TestCpuFlag(kCpuHasLASX)) {
+    I422ToUYVYRow = I422ToUYVYRow_Any_LASX;
+    if (IS_ALIGNED(width, 32)) {
+      I422ToUYVYRow = I422ToUYVYRow_LASX;
+    }
+  }
+#endif
+
+  for (y = 0; y < height; ++y) {
+    I422ToUYVYRow(src_y, src_u, src_v, dst_uyvy, width);
+    src_y += src_stride_y;
+    src_u += src_stride_u;
+    src_v += src_stride_v;
+    dst_uyvy += dst_stride_uyvy;
+  }
+  return 0;
+}
+
+LIBYUV_API
+int I420ToUYVY(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_uyvy,
+               int dst_stride_uyvy,
+               int width,
+               int height) {
+  int y;
+  void (*I422ToUYVYRow)(const uint8_t* src_y, const uint8_t* src_u,
+                        const uint8_t* src_v, uint8_t* dst_uyvy, int width) =
+      I422ToUYVYRow_C;
+  if (!src_y || !src_u || !src_v || !dst_uyvy || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    dst_uyvy = dst_uyvy + (height - 1) * dst_stride_uyvy;
+    dst_stride_uyvy = -dst_stride_uyvy;
+  }
+#if defined(HAS_I422TOUYVYROW_SSE2)
+  if (TestCpuFlag(kCpuHasSSE2)) {
+    I422ToUYVYRow = I422ToUYVYRow_Any_SSE2;
+    if (IS_ALIGNED(width, 16)) {
+      I422ToUYVYRow = I422ToUYVYRow_SSE2;
+    }
+  }
+#endif
+#if defined(HAS_I422TOUYVYROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    I422ToUYVYRow = I422ToUYVYRow_Any_AVX2;
+    if (IS_ALIGNED(width, 32)) {
+      I422ToUYVYRow = I422ToUYVYRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_I422TOUYVYROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    I422ToUYVYRow = I422ToUYVYRow_Any_NEON;
+    if (IS_ALIGNED(width, 16)) {
+      I422ToUYVYRow = I422ToUYVYRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_I422TOUYVYROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    I422ToUYVYRow = I422ToUYVYRow_Any_MSA;
+    if (IS_ALIGNED(width, 32)) {
+      I422ToUYVYRow = I422ToUYVYRow_MSA;
+    }
+  }
+#endif
+#if defined(HAS_I422TOUYVYROW_LASX)
+  if (TestCpuFlag(kCpuHasLASX)) {
+    I422ToUYVYRow = I422ToUYVYRow_Any_LASX;
+    if (IS_ALIGNED(width, 32)) {
+      I422ToUYVYRow = I422ToUYVYRow_LASX;
+    }
+  }
+#endif
+
+  for (y = 0; y < height - 1; y += 2) {
+    I422ToUYVYRow(src_y, src_u, src_v, dst_uyvy, width);
+    I422ToUYVYRow(src_y + src_stride_y, src_u, src_v,
+                  dst_uyvy + dst_stride_uyvy, width);
+    src_y += src_stride_y * 2;
+    src_u += src_stride_u;
+    src_v += src_stride_v;
+    dst_uyvy += dst_stride_uyvy * 2;
+  }
+  if (height & 1) {
+    I422ToUYVYRow(src_y, src_u, src_v, dst_uyvy, width);
+  }
+  return 0;
+}
+
+LIBYUV_API
+int I420ToNV12(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_uv,
+               int dst_stride_uv,
+               int width,
+               int height) {
+  int halfwidth = (width + 1) / 2;
+  int halfheight = (height + 1) / 2;
+  if (!src_y || !src_u || !src_v || !dst_uv || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    halfheight = (height + 1) >> 1;
+    src_y = src_y + (height - 1) * src_stride_y;
+    src_u = src_u + (halfheight - 1) * src_stride_u;
+    src_v = src_v + (halfheight - 1) * src_stride_v;
+    src_stride_y = -src_stride_y;
+    src_stride_u = -src_stride_u;
+    src_stride_v = -src_stride_v;
+  }
+  if (dst_y) {
+    CopyPlane(src_y, src_stride_y, dst_y, dst_stride_y, width, height);
+  }
+  MergeUVPlane(src_u, src_stride_u, src_v, src_stride_v, dst_uv, dst_stride_uv,
+               halfwidth, halfheight);
+  return 0;
+}
+
+LIBYUV_API
+int I420ToNV21(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_vu,
+               int dst_stride_vu,
+               int width,
+               int height) {
+  return I420ToNV12(src_y, src_stride_y, src_v, src_stride_v, src_u,
+                    src_stride_u, dst_y, dst_stride_y, dst_vu, dst_stride_vu,
+                    width, height);
+}
+
+// Convert I420 to specified format
+LIBYUV_API
+int ConvertFromI420(const uint8_t* y,
+                    int y_stride,
+                    const uint8_t* u,
+                    int u_stride,
+                    const uint8_t* v,
+                    int v_stride,
+                    uint8_t* dst_sample,
+                    int dst_sample_stride,
+                    int width,
+                    int height,
+                    uint32_t fourcc) {
+  uint32_t format = CanonicalFourCC(fourcc);
+  int r = 0;
+  if (!y || !u || !v || !dst_sample || width <= 0 || height == 0) {
+    return -1;
+  }
+  switch (format) {
+    // Single plane formats
+    case FOURCC_YUY2:
+      r = I420ToYUY2(y, y_stride, u, u_stride, v, v_stride, dst_sample,
+                     dst_sample_stride ? dst_sample_stride : width * 2, width,
+                     height);
+      break;
+    case FOURCC_UYVY:
+      r = I420ToUYVY(y, y_stride, u, u_stride, v, v_stride, dst_sample,
+                     dst_sample_stride ? dst_sample_stride : width * 2, width,
+                     height);
+      break;
+    case FOURCC_RGBP:
+      r = I420ToRGB565(y, y_stride, u, u_stride, v, v_stride, dst_sample,
+                       dst_sample_stride ? dst_sample_stride : width * 2, width,
+                       height);
+      break;
+    case FOURCC_RGBO:
+      r = I420ToARGB1555(y, y_stride, u, u_stride, v, v_stride, dst_sample,
+                         dst_sample_stride ? dst_sample_stride : width * 2,
+                         width, height);
+      break;
+    case FOURCC_R444:
+      r = I420ToARGB4444(y, y_stride, u, u_stride, v, v_stride, dst_sample,
+                         dst_sample_stride ? dst_sample_stride : width * 2,
+                         width, height);
+      break;
+    case FOURCC_24BG:
+      r = I420ToRGB24(y, y_stride, u, u_stride, v, v_stride, dst_sample,
+                      dst_sample_stride ? dst_sample_stride : width * 3, width,
+                      height);
+      break;
+    case FOURCC_RAW:
+      r = I420ToRAW(y, y_stride, u, u_stride, v, v_stride, dst_sample,
+                    dst_sample_stride ? dst_sample_stride : width * 3, width,
+                    height);
+      break;
+    case FOURCC_ARGB:
+      r = I420ToARGB(y, y_stride, u, u_stride, v, v_stride, dst_sample,
+                     dst_sample_stride ? dst_sample_stride : width * 4, width,
+                     height);
+      break;
+    case FOURCC_BGRA:
+      r = I420ToBGRA(y, y_stride, u, u_stride, v, v_stride, dst_sample,
+                     dst_sample_stride ? dst_sample_stride : width * 4, width,
+                     height);
+      break;
+    case FOURCC_ABGR:
+      r = I420ToABGR(y, y_stride, u, u_stride, v, v_stride, dst_sample,
+                     dst_sample_stride ? dst_sample_stride : width * 4, width,
+                     height);
+      break;
+    case FOURCC_RGBA:
+      r = I420ToRGBA(y, y_stride, u, u_stride, v, v_stride, dst_sample,
+                     dst_sample_stride ? dst_sample_stride : width * 4, width,
+                     height);
+      break;
+    case FOURCC_AR30:
+      r = I420ToAR30(y, y_stride, u, u_stride, v, v_stride, dst_sample,
+                     dst_sample_stride ? dst_sample_stride : width * 4, width,
+                     height);
+      break;
+    case FOURCC_I400:
+      r = I400Copy(y, y_stride, dst_sample,
+                   dst_sample_stride ? dst_sample_stride : width, width,
+                   height);
+      break;
+    case FOURCC_NV12: {
+      int dst_y_stride = dst_sample_stride ? dst_sample_stride : width;
+      uint8_t* dst_uv = dst_sample + dst_y_stride * height;
+      r = I420ToNV12(y, y_stride, u, u_stride, v, v_stride, dst_sample,
+                     dst_sample_stride ? dst_sample_stride : width, dst_uv,
+                     dst_sample_stride ? dst_sample_stride : width, width,
+                     height);
+      break;
+    }
+    case FOURCC_NV21: {
+      int dst_y_stride = dst_sample_stride ? dst_sample_stride : width;
+      uint8_t* dst_vu = dst_sample + dst_y_stride * height;
+      r = I420ToNV21(y, y_stride, u, u_stride, v, v_stride, dst_sample,
+                     dst_sample_stride ? dst_sample_stride : width, dst_vu,
+                     dst_sample_stride ? dst_sample_stride : width, width,
+                     height);
+      break;
+    }
+    // Triplanar formats
+    case FOURCC_I420:
+    case FOURCC_YV12: {
+      dst_sample_stride = dst_sample_stride ? dst_sample_stride : width;
+      int halfstride = (dst_sample_stride + 1) / 2;
+      int halfheight = (height + 1) / 2;
+      uint8_t* dst_u;
+      uint8_t* dst_v;
+      if (format == FOURCC_YV12) {
+        dst_v = dst_sample + dst_sample_stride * height;
+        dst_u = dst_v + halfstride * halfheight;
+      } else {
+        dst_u = dst_sample + dst_sample_stride * height;
+        dst_v = dst_u + halfstride * halfheight;
+      }
+      r = I420Copy(y, y_stride, u, u_stride, v, v_stride, dst_sample,
+                   dst_sample_stride, dst_u, halfstride, dst_v, halfstride,
+                   width, height);
+      break;
+    }
+    case FOURCC_I422:
+    case FOURCC_YV16: {
+      dst_sample_stride = dst_sample_stride ? dst_sample_stride : width;
+      int halfstride = (dst_sample_stride + 1) / 2;
+      uint8_t* dst_u;
+      uint8_t* dst_v;
+      if (format == FOURCC_YV16) {
+        dst_v = dst_sample + dst_sample_stride * height;
+        dst_u = dst_v + halfstride * height;
+      } else {
+        dst_u = dst_sample + dst_sample_stride * height;
+        dst_v = dst_u + halfstride * height;
+      }
+      r = I420ToI422(y, y_stride, u, u_stride, v, v_stride, dst_sample,
+                     dst_sample_stride, dst_u, halfstride, dst_v, halfstride,
+                     width, height);
+      break;
+    }
+    case FOURCC_I444:
+    case FOURCC_YV24: {
+      dst_sample_stride = dst_sample_stride ? dst_sample_stride : width;
+      uint8_t* dst_u;
+      uint8_t* dst_v;
+      if (format == FOURCC_YV24) {
+        dst_v = dst_sample + dst_sample_stride * height;
+        dst_u = dst_v + dst_sample_stride * height;
+      } else {
+        dst_u = dst_sample + dst_sample_stride * height;
+        dst_v = dst_u + dst_sample_stride * height;
+      }
+      r = I420ToI444(y, y_stride, u, u_stride, v, v_stride, dst_sample,
+                     dst_sample_stride, dst_u, dst_sample_stride, dst_v,
+                     dst_sample_stride, width, height);
+      break;
+    }
+    // Formats not supported - MJPG, biplanar, some rgb formats.
+    default:
+      return -1;  // unknown fourcc - return failure code.
+  }
+  return r;
+}
+
+#ifdef __cplusplus
+}  // extern "C"
+}  // namespace libyuv
+#endif
diff --git a/3rdparty/libyuv/src/source/convert_from_argb.cc b/3rdparty/libyuv/src/source/convert_from_argb.cc
new file mode 100644
index 00000000..e50c2af3
--- /dev/null
+++ b/3rdparty/libyuv/src/source/convert_from_argb.cc
@@ -0,0 +1,2543 @@
+/*
+ *  Copyright 2012 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include "libyuv/convert_from_argb.h"
+
+#include "libyuv/basic_types.h"
+#include "libyuv/cpu_id.h"
+#include "libyuv/planar_functions.h"
+#include "libyuv/row.h"
+
+#ifdef __cplusplus
+namespace libyuv {
+extern "C" {
+#endif
+
+// ARGB little endian (bgra in memory) to I444
+LIBYUV_API
+int ARGBToI444(const uint8_t* src_argb,
+               int src_stride_argb,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_u,
+               int dst_stride_u,
+               uint8_t* dst_v,
+               int dst_stride_v,
+               int width,
+               int height) {
+  int y;
+  void (*ARGBToYRow)(const uint8_t* src_argb, uint8_t* dst_y, int width) =
+      ARGBToYRow_C;
+  void (*ARGBToUV444Row)(const uint8_t* src_argb, uint8_t* dst_u,
+                         uint8_t* dst_v, int width) = ARGBToUV444Row_C;
+  if (!src_argb || !dst_y || !dst_u || !dst_v || width <= 0 || height == 0) {
+    return -1;
+  }
+  if (height < 0) {
+    height = -height;
+    src_argb = src_argb + (height - 1) * src_stride_argb;
+    src_stride_argb = -src_stride_argb;
+  }
+  // Coalesce rows.
+  if (src_stride_argb == width * 4 && dst_stride_y == width &&
+      dst_stride_u == width && dst_stride_v == width) {
+    width *= height;
+    height = 1;
+    src_stride_argb = dst_stride_y = dst_stride_u = dst_stride_v = 0;
+  }
+#if defined(HAS_ARGBTOUV444ROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    ARGBToUV444Row = ARGBToUV444Row_Any_SSSE3;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBToUV444Row = ARGBToUV444Row_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOUV444ROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    ARGBToUV444Row = ARGBToUV444Row_Any_NEON;
+    if (IS_ALIGNED(width, 8)) {
+      ARGBToUV444Row = ARGBToUV444Row_NEON;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOUV444ROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    ARGBToUV444Row = ARGBToUV444Row_Any_MSA;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBToUV444Row = ARGBToUV444Row_MSA;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOUV444ROW_LASX)
+  if (TestCpuFlag(kCpuHasLASX)) {
+    ARGBToUV444Row = ARGBToUV444Row_Any_LASX;
+    if (IS_ALIGNED(width, 32)) {
+      ARGBToUV444Row = ARGBToUV444Row_LASX;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOYROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    ARGBToYRow = ARGBToYRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBToYRow = ARGBToYRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOYROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ARGBToYRow = ARGBToYRow_Any_AVX2;
+    if (IS_ALIGNED(width, 32)) {
+      ARGBToYRow = ARGBToYRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOYROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    ARGBToYRow = ARGBToYRow_Any_NEON;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBToYRow = ARGBToYRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOYROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    ARGBToYRow = ARGBToYRow_Any_MSA;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBToYRow = ARGBToYRow_MSA;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOYROW_LASX)
+  if (TestCpuFlag(kCpuHasLASX)) {
+    ARGBToYRow = ARGBToYRow_Any_LASX;
+    if (IS_ALIGNED(width, 32)) {
+      ARGBToYRow = ARGBToYRow_LASX;
+    }
+  }
+#endif
+
+  for (y = 0; y < height; ++y) {
+    ARGBToUV444Row(src_argb, dst_u, dst_v, width);
+    ARGBToYRow(src_argb, dst_y, width);
+    src_argb += src_stride_argb;
+    dst_y += dst_stride_y;
+    dst_u += dst_stride_u;
+    dst_v += dst_stride_v;
+  }
+  return 0;
+}
+
+// ARGB little endian (bgra in memory) to I422
+LIBYUV_API
+int ARGBToI422(const uint8_t* src_argb,
+               int src_stride_argb,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_u,
+               int dst_stride_u,
+               uint8_t* dst_v,
+               int dst_stride_v,
+               int width,
+               int height) {
+  int y;
+  void (*ARGBToUVRow)(const uint8_t* src_argb0, int src_stride_argb,
+                      uint8_t* dst_u, uint8_t* dst_v, int width) =
+      ARGBToUVRow_C;
+  void (*ARGBToYRow)(const uint8_t* src_argb, uint8_t* dst_y, int width) =
+      ARGBToYRow_C;
+  if (!src_argb || !dst_y || !dst_u || !dst_v || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    src_argb = src_argb + (height - 1) * src_stride_argb;
+    src_stride_argb = -src_stride_argb;
+  }
+  // Coalesce rows.
+  if (src_stride_argb == width * 4 && dst_stride_y == width &&
+      dst_stride_u * 2 == width && dst_stride_v * 2 == width) {
+    width *= height;
+    height = 1;
+    src_stride_argb = dst_stride_y = dst_stride_u = dst_stride_v = 0;
+  }
+#if defined(HAS_ARGBTOYROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    ARGBToYRow = ARGBToYRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBToYRow = ARGBToYRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOUVROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    ARGBToUVRow = ARGBToUVRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBToUVRow = ARGBToUVRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOYROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ARGBToYRow = ARGBToYRow_Any_AVX2;
+    if (IS_ALIGNED(width, 32)) {
+      ARGBToYRow = ARGBToYRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOUVROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ARGBToUVRow = ARGBToUVRow_Any_AVX2;
+    if (IS_ALIGNED(width, 32)) {
+      ARGBToUVRow = ARGBToUVRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOYROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    ARGBToYRow = ARGBToYRow_Any_NEON;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBToYRow = ARGBToYRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOUVROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    ARGBToUVRow = ARGBToUVRow_Any_NEON;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBToUVRow = ARGBToUVRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOYROW_MSA) && defined(HAS_ARGBTOUVROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    ARGBToYRow = ARGBToYRow_Any_MSA;
+    ARGBToUVRow = ARGBToUVRow_Any_MSA;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBToYRow = ARGBToYRow_MSA;
+    }
+    if (IS_ALIGNED(width, 32)) {
+      ARGBToUVRow = ARGBToUVRow_MSA;
+    }
+  }
+#endif
+
+#if defined(HAS_ARGBTOYROW_LASX) && defined(HAS_ARGBTOUVROW_LASX)
+  if (TestCpuFlag(kCpuHasLASX)) {
+    ARGBToYRow = ARGBToYRow_Any_LASX;
+    ARGBToUVRow = ARGBToUVRow_Any_LASX;
+    if (IS_ALIGNED(width, 32)) {
+      ARGBToYRow = ARGBToYRow_LASX;
+      ARGBToUVRow = ARGBToUVRow_LASX;
+    }
+  }
+#endif
+
+  for (y = 0; y < height; ++y) {
+    ARGBToUVRow(src_argb, 0, dst_u, dst_v, width);
+    ARGBToYRow(src_argb, dst_y, width);
+    src_argb += src_stride_argb;
+    dst_y += dst_stride_y;
+    dst_u += dst_stride_u;
+    dst_v += dst_stride_v;
+  }
+  return 0;
+}
+
+LIBYUV_API
+int ARGBToNV12(const uint8_t* src_argb,
+               int src_stride_argb,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_uv,
+               int dst_stride_uv,
+               int width,
+               int height) {
+  int y;
+  int halfwidth = (width + 1) >> 1;
+  void (*ARGBToUVRow)(const uint8_t* src_argb0, int src_stride_argb,
+                      uint8_t* dst_u, uint8_t* dst_v, int width) =
+      ARGBToUVRow_C;
+  void (*ARGBToYRow)(const uint8_t* src_argb, uint8_t* dst_y, int width) =
+      ARGBToYRow_C;
+  void (*MergeUVRow_)(const uint8_t* src_u, const uint8_t* src_v,
+                      uint8_t* dst_uv, int width) = MergeUVRow_C;
+  if (!src_argb || !dst_y || !dst_uv || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    src_argb = src_argb + (height - 1) * src_stride_argb;
+    src_stride_argb = -src_stride_argb;
+  }
+#if defined(HAS_ARGBTOYROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    ARGBToYRow = ARGBToYRow_Any_NEON;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBToYRow = ARGBToYRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOUVROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    ARGBToUVRow = ARGBToUVRow_Any_NEON;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBToUVRow = ARGBToUVRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOYROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    ARGBToYRow = ARGBToYRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBToYRow = ARGBToYRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOUVROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    ARGBToUVRow = ARGBToUVRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBToUVRow = ARGBToUVRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOYROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ARGBToYRow = ARGBToYRow_Any_AVX2;
+    if (IS_ALIGNED(width, 32)) {
+      ARGBToYRow = ARGBToYRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOUVROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ARGBToUVRow = ARGBToUVRow_Any_AVX2;
+    if (IS_ALIGNED(width, 32)) {
+      ARGBToUVRow = ARGBToUVRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOYROW_MSA) && defined(HAS_ARGBTOUVROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    ARGBToYRow = ARGBToYRow_Any_MSA;
+    ARGBToUVRow = ARGBToUVRow_Any_MSA;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBToYRow = ARGBToYRow_MSA;
+    }
+    if (IS_ALIGNED(width, 32)) {
+      ARGBToUVRow = ARGBToUVRow_MSA;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOYROW_LASX) && defined(HAS_ARGBTOUVROW_LASX)
+  if (TestCpuFlag(kCpuHasLASX)) {
+    ARGBToYRow = ARGBToYRow_Any_LASX;
+    ARGBToUVRow = ARGBToUVRow_Any_LASX;
+    if (IS_ALIGNED(width, 32)) {
+      ARGBToYRow = ARGBToYRow_LASX;
+      ARGBToUVRow = ARGBToUVRow_LASX;
+    }
+  }
+#endif
+#if defined(HAS_MERGEUVROW_SSE2)
+  if (TestCpuFlag(kCpuHasSSE2)) {
+    MergeUVRow_ = MergeUVRow_Any_SSE2;
+    if (IS_ALIGNED(halfwidth, 16)) {
+      MergeUVRow_ = MergeUVRow_SSE2;
+    }
+  }
+#endif
+#if defined(HAS_MERGEUVROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    MergeUVRow_ = MergeUVRow_Any_AVX2;
+    if (IS_ALIGNED(halfwidth, 32)) {
+      MergeUVRow_ = MergeUVRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_MERGEUVROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    MergeUVRow_ = MergeUVRow_Any_NEON;
+    if (IS_ALIGNED(halfwidth, 16)) {
+      MergeUVRow_ = MergeUVRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_MERGEUVROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    MergeUVRow_ = MergeUVRow_Any_MSA;
+    if (IS_ALIGNED(halfwidth, 16)) {
+      MergeUVRow_ = MergeUVRow_MSA;
+    }
+  }
+#endif
+#if defined(HAS_MERGEUVROW_LSX)
+  if (TestCpuFlag(kCpuHasLSX)) {
+    MergeUVRow_ = MergeUVRow_Any_LSX;
+    if (IS_ALIGNED(halfwidth, 16)) {
+      MergeUVRow_ = MergeUVRow_LSX;
+    }
+  }
+#endif
+  {
+    // Allocate a rows of uv.
+    align_buffer_64(row_u, ((halfwidth + 31) & ~31) * 2);
+    uint8_t* row_v = row_u + ((halfwidth + 31) & ~31);
+
+    for (y = 0; y < height - 1; y += 2) {
+      ARGBToUVRow(src_argb, src_stride_argb, row_u, row_v, width);
+      MergeUVRow_(row_u, row_v, dst_uv, halfwidth);
+      ARGBToYRow(src_argb, dst_y, width);
+      ARGBToYRow(src_argb + src_stride_argb, dst_y + dst_stride_y, width);
+      src_argb += src_stride_argb * 2;
+      dst_y += dst_stride_y * 2;
+      dst_uv += dst_stride_uv;
+    }
+    if (height & 1) {
+      ARGBToUVRow(src_argb, 0, row_u, row_v, width);
+      MergeUVRow_(row_u, row_v, dst_uv, halfwidth);
+      ARGBToYRow(src_argb, dst_y, width);
+    }
+    free_aligned_buffer_64(row_u);
+  }
+  return 0;
+}
+
+// Same as NV12 but U and V swapped.
+LIBYUV_API
+int ARGBToNV21(const uint8_t* src_argb,
+               int src_stride_argb,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_vu,
+               int dst_stride_vu,
+               int width,
+               int height) {
+  int y;
+  int halfwidth = (width + 1) >> 1;
+  void (*ARGBToUVRow)(const uint8_t* src_argb0, int src_stride_argb,
+                      uint8_t* dst_u, uint8_t* dst_v, int width) =
+      ARGBToUVRow_C;
+  void (*ARGBToYRow)(const uint8_t* src_argb, uint8_t* dst_y, int width) =
+      ARGBToYRow_C;
+  void (*MergeUVRow_)(const uint8_t* src_u, const uint8_t* src_v,
+                      uint8_t* dst_vu, int width) = MergeUVRow_C;
+  if (!src_argb || !dst_y || !dst_vu || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    src_argb = src_argb + (height - 1) * src_stride_argb;
+    src_stride_argb = -src_stride_argb;
+  }
+#if defined(HAS_ARGBTOYROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    ARGBToYRow = ARGBToYRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBToYRow = ARGBToYRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOUVROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    ARGBToUVRow = ARGBToUVRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBToUVRow = ARGBToUVRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOYROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ARGBToYRow = ARGBToYRow_Any_AVX2;
+    if (IS_ALIGNED(width, 32)) {
+      ARGBToYRow = ARGBToYRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOUVROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ARGBToUVRow = ARGBToUVRow_Any_AVX2;
+    if (IS_ALIGNED(width, 32)) {
+      ARGBToUVRow = ARGBToUVRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOYROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    ARGBToYRow = ARGBToYRow_Any_NEON;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBToYRow = ARGBToYRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOUVROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    ARGBToUVRow = ARGBToUVRow_Any_NEON;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBToUVRow = ARGBToUVRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOYROW_MSA) && defined(HAS_ARGBTOUVROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    ARGBToYRow = ARGBToYRow_Any_MSA;
+    ARGBToUVRow = ARGBToUVRow_Any_MSA;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBToYRow = ARGBToYRow_MSA;
+    }
+    if (IS_ALIGNED(width, 32)) {
+      ARGBToUVRow = ARGBToUVRow_MSA;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOYROW_LASX) && defined(HAS_ARGBTOUVROW_LASX)
+  if (TestCpuFlag(kCpuHasLASX)) {
+    ARGBToYRow = ARGBToYRow_Any_LASX;
+    ARGBToUVRow = ARGBToUVRow_Any_LASX;
+    if (IS_ALIGNED(width, 32)) {
+      ARGBToYRow = ARGBToYRow_LASX;
+      ARGBToUVRow = ARGBToUVRow_LASX;
+    }
+  }
+#endif
+#if defined(HAS_MERGEUVROW_SSE2)
+  if (TestCpuFlag(kCpuHasSSE2)) {
+    MergeUVRow_ = MergeUVRow_Any_SSE2;
+    if (IS_ALIGNED(halfwidth, 16)) {
+      MergeUVRow_ = MergeUVRow_SSE2;
+    }
+  }
+#endif
+#if defined(HAS_MERGEUVROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    MergeUVRow_ = MergeUVRow_Any_AVX2;
+    if (IS_ALIGNED(halfwidth, 32)) {
+      MergeUVRow_ = MergeUVRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_MERGEUVROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    MergeUVRow_ = MergeUVRow_Any_NEON;
+    if (IS_ALIGNED(halfwidth, 16)) {
+      MergeUVRow_ = MergeUVRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_MERGEUVROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    MergeUVRow_ = MergeUVRow_Any_MSA;
+    if (IS_ALIGNED(halfwidth, 16)) {
+      MergeUVRow_ = MergeUVRow_MSA;
+    }
+  }
+#endif
+#if defined(HAS_MERGEUVROW_LSX)
+  if (TestCpuFlag(kCpuHasLSX)) {
+    MergeUVRow_ = MergeUVRow_Any_LSX;
+    if (IS_ALIGNED(halfwidth, 16)) {
+      MergeUVRow_ = MergeUVRow_LSX;
+    }
+  }
+#endif
+  {
+    // Allocate a rows of uv.
+    align_buffer_64(row_u, ((halfwidth + 31) & ~31) * 2);
+    uint8_t* row_v = row_u + ((halfwidth + 31) & ~31);
+
+    for (y = 0; y < height - 1; y += 2) {
+      ARGBToUVRow(src_argb, src_stride_argb, row_u, row_v, width);
+      MergeUVRow_(row_v, row_u, dst_vu, halfwidth);
+      ARGBToYRow(src_argb, dst_y, width);
+      ARGBToYRow(src_argb + src_stride_argb, dst_y + dst_stride_y, width);
+      src_argb += src_stride_argb * 2;
+      dst_y += dst_stride_y * 2;
+      dst_vu += dst_stride_vu;
+    }
+    if (height & 1) {
+      ARGBToUVRow(src_argb, 0, row_u, row_v, width);
+      MergeUVRow_(row_v, row_u, dst_vu, halfwidth);
+      ARGBToYRow(src_argb, dst_y, width);
+    }
+    free_aligned_buffer_64(row_u);
+  }
+  return 0;
+}
+
+LIBYUV_API
+int ABGRToNV12(const uint8_t* src_abgr,
+               int src_stride_abgr,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_uv,
+               int dst_stride_uv,
+               int width,
+               int height) {
+  int y;
+  int halfwidth = (width + 1) >> 1;
+  void (*ABGRToUVRow)(const uint8_t* src_abgr0, int src_stride_abgr,
+                      uint8_t* dst_u, uint8_t* dst_v, int width) =
+      ABGRToUVRow_C;
+  void (*ABGRToYRow)(const uint8_t* src_abgr, uint8_t* dst_y, int width) =
+      ABGRToYRow_C;
+  void (*MergeUVRow_)(const uint8_t* src_u, const uint8_t* src_v,
+                      uint8_t* dst_uv, int width) = MergeUVRow_C;
+  if (!src_abgr || !dst_y || !dst_uv || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    src_abgr = src_abgr + (height - 1) * src_stride_abgr;
+    src_stride_abgr = -src_stride_abgr;
+  }
+#if defined(HAS_ABGRTOYROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    ABGRToYRow = ABGRToYRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 16)) {
+      ABGRToYRow = ABGRToYRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_ABGRTOUVROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    ABGRToUVRow = ABGRToUVRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 16)) {
+      ABGRToUVRow = ABGRToUVRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_ABGRTOYROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ABGRToYRow = ABGRToYRow_Any_AVX2;
+    if (IS_ALIGNED(width, 32)) {
+      ABGRToYRow = ABGRToYRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_ABGRTOUVROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ABGRToUVRow = ABGRToUVRow_Any_AVX2;
+    if (IS_ALIGNED(width, 32)) {
+      ABGRToUVRow = ABGRToUVRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_ABGRTOYROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    ABGRToYRow = ABGRToYRow_Any_NEON;
+    if (IS_ALIGNED(width, 16)) {
+      ABGRToYRow = ABGRToYRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_ABGRTOUVROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    ABGRToUVRow = ABGRToUVRow_Any_NEON;
+    if (IS_ALIGNED(width, 16)) {
+      ABGRToUVRow = ABGRToUVRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_ABGRTOYROW_MSA) && defined(HAS_ABGRTOUVROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    ABGRToYRow = ABGRToYRow_Any_MSA;
+    ABGRToUVRow = ABGRToUVRow_Any_MSA;
+    if (IS_ALIGNED(width, 16)) {
+      ABGRToYRow = ABGRToYRow_MSA;
+    }
+    if (IS_ALIGNED(width, 32)) {
+      ABGRToUVRow = ABGRToUVRow_MSA;
+    }
+  }
+#endif
+#if defined(HAS_MERGEUVROW_SSE2)
+  if (TestCpuFlag(kCpuHasSSE2)) {
+    MergeUVRow_ = MergeUVRow_Any_SSE2;
+    if (IS_ALIGNED(halfwidth, 16)) {
+      MergeUVRow_ = MergeUVRow_SSE2;
+    }
+  }
+#endif
+#if defined(HAS_MERGEUVROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    MergeUVRow_ = MergeUVRow_Any_AVX2;
+    if (IS_ALIGNED(halfwidth, 32)) {
+      MergeUVRow_ = MergeUVRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_MERGEUVROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    MergeUVRow_ = MergeUVRow_Any_NEON;
+    if (IS_ALIGNED(halfwidth, 16)) {
+      MergeUVRow_ = MergeUVRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_MERGEUVROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    MergeUVRow_ = MergeUVRow_Any_MSA;
+    if (IS_ALIGNED(halfwidth, 16)) {
+      MergeUVRow_ = MergeUVRow_MSA;
+    }
+  }
+#endif
+#if defined(HAS_MERGEUVROW_LSX)
+  if (TestCpuFlag(kCpuHasLSX)) {
+    MergeUVRow_ = MergeUVRow_Any_LSX;
+    if (IS_ALIGNED(halfwidth, 16)) {
+      MergeUVRow_ = MergeUVRow_LSX;
+    }
+  }
+#endif
+  {
+    // Allocate a rows of uv.
+    align_buffer_64(row_u, ((halfwidth + 31) & ~31) * 2);
+    uint8_t* row_v = row_u + ((halfwidth + 31) & ~31);
+
+    for (y = 0; y < height - 1; y += 2) {
+      ABGRToUVRow(src_abgr, src_stride_abgr, row_u, row_v, width);
+      MergeUVRow_(row_u, row_v, dst_uv, halfwidth);
+      ABGRToYRow(src_abgr, dst_y, width);
+      ABGRToYRow(src_abgr + src_stride_abgr, dst_y + dst_stride_y, width);
+      src_abgr += src_stride_abgr * 2;
+      dst_y += dst_stride_y * 2;
+      dst_uv += dst_stride_uv;
+    }
+    if (height & 1) {
+      ABGRToUVRow(src_abgr, 0, row_u, row_v, width);
+      MergeUVRow_(row_u, row_v, dst_uv, halfwidth);
+      ABGRToYRow(src_abgr, dst_y, width);
+    }
+    free_aligned_buffer_64(row_u);
+  }
+  return 0;
+}
+
+// Same as NV12 but U and V swapped.
+LIBYUV_API
+int ABGRToNV21(const uint8_t* src_abgr,
+               int src_stride_abgr,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_vu,
+               int dst_stride_vu,
+               int width,
+               int height) {
+  int y;
+  int halfwidth = (width + 1) >> 1;
+  void (*ABGRToUVRow)(const uint8_t* src_abgr0, int src_stride_abgr,
+                      uint8_t* dst_u, uint8_t* dst_v, int width) =
+      ABGRToUVRow_C;
+  void (*ABGRToYRow)(const uint8_t* src_abgr, uint8_t* dst_y, int width) =
+      ABGRToYRow_C;
+  void (*MergeUVRow_)(const uint8_t* src_u, const uint8_t* src_v,
+                      uint8_t* dst_vu, int width) = MergeUVRow_C;
+  if (!src_abgr || !dst_y || !dst_vu || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    src_abgr = src_abgr + (height - 1) * src_stride_abgr;
+    src_stride_abgr = -src_stride_abgr;
+  }
+#if defined(HAS_ABGRTOYROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    ABGRToYRow = ABGRToYRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 16)) {
+      ABGRToYRow = ABGRToYRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_ABGRTOUVROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    ABGRToUVRow = ABGRToUVRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 16)) {
+      ABGRToUVRow = ABGRToUVRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_ABGRTOYROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ABGRToYRow = ABGRToYRow_Any_AVX2;
+    if (IS_ALIGNED(width, 32)) {
+      ABGRToYRow = ABGRToYRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_ABGRTOUVROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ABGRToUVRow = ABGRToUVRow_Any_AVX2;
+    if (IS_ALIGNED(width, 32)) {
+      ABGRToUVRow = ABGRToUVRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_ABGRTOYROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    ABGRToYRow = ABGRToYRow_Any_NEON;
+    if (IS_ALIGNED(width, 16)) {
+      ABGRToYRow = ABGRToYRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_ABGRTOUVROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    ABGRToUVRow = ABGRToUVRow_Any_NEON;
+    if (IS_ALIGNED(width, 16)) {
+      ABGRToUVRow = ABGRToUVRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_ABGRTOYROW_MSA) && defined(HAS_ABGRTOUVROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    ABGRToYRow = ABGRToYRow_Any_MSA;
+    ABGRToUVRow = ABGRToUVRow_Any_MSA;
+    if (IS_ALIGNED(width, 16)) {
+      ABGRToYRow = ABGRToYRow_MSA;
+    }
+    if (IS_ALIGNED(width, 32)) {
+      ABGRToUVRow = ABGRToUVRow_MSA;
+    }
+  }
+#endif
+#if defined(HAS_MERGEUVROW_SSE2)
+  if (TestCpuFlag(kCpuHasSSE2)) {
+    MergeUVRow_ = MergeUVRow_Any_SSE2;
+    if (IS_ALIGNED(halfwidth, 16)) {
+      MergeUVRow_ = MergeUVRow_SSE2;
+    }
+  }
+#endif
+#if defined(HAS_MERGEUVROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    MergeUVRow_ = MergeUVRow_Any_AVX2;
+    if (IS_ALIGNED(halfwidth, 32)) {
+      MergeUVRow_ = MergeUVRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_MERGEUVROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    MergeUVRow_ = MergeUVRow_Any_NEON;
+    if (IS_ALIGNED(halfwidth, 16)) {
+      MergeUVRow_ = MergeUVRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_MERGEUVROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    MergeUVRow_ = MergeUVRow_Any_MSA;
+    if (IS_ALIGNED(halfwidth, 16)) {
+      MergeUVRow_ = MergeUVRow_MSA;
+    }
+  }
+#endif
+#if defined(HAS_MERGEUVROW_LSX)
+  if (TestCpuFlag(kCpuHasLSX)) {
+    MergeUVRow_ = MergeUVRow_Any_LSX;
+    if (IS_ALIGNED(halfwidth, 16)) {
+      MergeUVRow_ = MergeUVRow_LSX;
+    }
+  }
+#endif
+  {
+    // Allocate a rows of uv.
+    align_buffer_64(row_u, ((halfwidth + 31) & ~31) * 2);
+    uint8_t* row_v = row_u + ((halfwidth + 31) & ~31);
+
+    for (y = 0; y < height - 1; y += 2) {
+      ABGRToUVRow(src_abgr, src_stride_abgr, row_u, row_v, width);
+      MergeUVRow_(row_v, row_u, dst_vu, halfwidth);
+      ABGRToYRow(src_abgr, dst_y, width);
+      ABGRToYRow(src_abgr + src_stride_abgr, dst_y + dst_stride_y, width);
+      src_abgr += src_stride_abgr * 2;
+      dst_y += dst_stride_y * 2;
+      dst_vu += dst_stride_vu;
+    }
+    if (height & 1) {
+      ABGRToUVRow(src_abgr, 0, row_u, row_v, width);
+      MergeUVRow_(row_v, row_u, dst_vu, halfwidth);
+      ABGRToYRow(src_abgr, dst_y, width);
+    }
+    free_aligned_buffer_64(row_u);
+  }
+  return 0;
+}
+
+// Convert ARGB to YUY2.
+LIBYUV_API
+int ARGBToYUY2(const uint8_t* src_argb,
+               int src_stride_argb,
+               uint8_t* dst_yuy2,
+               int dst_stride_yuy2,
+               int width,
+               int height) {
+  int y;
+  void (*ARGBToUVRow)(const uint8_t* src_argb, int src_stride_argb,
+                      uint8_t* dst_u, uint8_t* dst_v, int width) =
+      ARGBToUVRow_C;
+  void (*ARGBToYRow)(const uint8_t* src_argb, uint8_t* dst_y, int width) =
+      ARGBToYRow_C;
+  void (*I422ToYUY2Row)(const uint8_t* src_y, const uint8_t* src_u,
+                        const uint8_t* src_v, uint8_t* dst_yuy2, int width) =
+      I422ToYUY2Row_C;
+
+  if (!src_argb || !dst_yuy2 || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    dst_yuy2 = dst_yuy2 + (height - 1) * dst_stride_yuy2;
+    dst_stride_yuy2 = -dst_stride_yuy2;
+  }
+  // Coalesce rows.
+  if (src_stride_argb == width * 4 && dst_stride_yuy2 == width * 2) {
+    width *= height;
+    height = 1;
+    src_stride_argb = dst_stride_yuy2 = 0;
+  }
+#if defined(HAS_ARGBTOYROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    ARGBToYRow = ARGBToYRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBToYRow = ARGBToYRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOUVROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    ARGBToUVRow = ARGBToUVRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBToUVRow = ARGBToUVRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOYROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ARGBToYRow = ARGBToYRow_Any_AVX2;
+    if (IS_ALIGNED(width, 32)) {
+      ARGBToYRow = ARGBToYRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOUVROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ARGBToUVRow = ARGBToUVRow_Any_AVX2;
+    if (IS_ALIGNED(width, 32)) {
+      ARGBToUVRow = ARGBToUVRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOYROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    ARGBToYRow = ARGBToYRow_Any_NEON;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBToYRow = ARGBToYRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOUVROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    ARGBToUVRow = ARGBToUVRow_Any_NEON;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBToUVRow = ARGBToUVRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOYROW_MSA) && defined(HAS_ARGBTOUVROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    ARGBToYRow = ARGBToYRow_Any_MSA;
+    ARGBToUVRow = ARGBToUVRow_Any_MSA;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBToYRow = ARGBToYRow_MSA;
+    }
+    if (IS_ALIGNED(width, 32)) {
+      ARGBToUVRow = ARGBToUVRow_MSA;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOYROW_LASX) && defined(HAS_ARGBTOUVROW_LASX)
+  if (TestCpuFlag(kCpuHasLASX)) {
+    ARGBToYRow = ARGBToYRow_Any_LASX;
+    ARGBToUVRow = ARGBToUVRow_Any_LASX;
+    if (IS_ALIGNED(width, 32)) {
+      ARGBToYRow = ARGBToYRow_LASX;
+      ARGBToUVRow = ARGBToUVRow_LASX;
+    }
+  }
+#endif
+#if defined(HAS_I422TOYUY2ROW_SSE2)
+  if (TestCpuFlag(kCpuHasSSE2)) {
+    I422ToYUY2Row = I422ToYUY2Row_Any_SSE2;
+    if (IS_ALIGNED(width, 16)) {
+      I422ToYUY2Row = I422ToYUY2Row_SSE2;
+    }
+  }
+#endif
+#if defined(HAS_I422TOYUY2ROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    I422ToYUY2Row = I422ToYUY2Row_Any_AVX2;
+    if (IS_ALIGNED(width, 32)) {
+      I422ToYUY2Row = I422ToYUY2Row_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_I422TOYUY2ROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    I422ToYUY2Row = I422ToYUY2Row_Any_NEON;
+    if (IS_ALIGNED(width, 16)) {
+      I422ToYUY2Row = I422ToYUY2Row_NEON;
+    }
+  }
+#endif
+#if defined(HAS_I422TOYUY2ROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    I422ToYUY2Row = I422ToYUY2Row_Any_MSA;
+    if (IS_ALIGNED(width, 32)) {
+      I422ToYUY2Row = I422ToYUY2Row_MSA;
+    }
+  }
+#endif
+#if defined(HAS_I422TOYUY2ROW_LASX)
+  if (TestCpuFlag(kCpuHasLASX)) {
+    I422ToYUY2Row = I422ToYUY2Row_Any_LASX;
+    if (IS_ALIGNED(width, 32)) {
+      I422ToYUY2Row = I422ToYUY2Row_LASX;
+    }
+  }
+#endif
+
+  {
+    // Allocate a rows of yuv.
+    align_buffer_64(row_y, ((width + 63) & ~63) * 2);
+    uint8_t* row_u = row_y + ((width + 63) & ~63);
+    uint8_t* row_v = row_u + ((width + 63) & ~63) / 2;
+
+    for (y = 0; y < height; ++y) {
+      ARGBToUVRow(src_argb, 0, row_u, row_v, width);
+      ARGBToYRow(src_argb, row_y, width);
+      I422ToYUY2Row(row_y, row_u, row_v, dst_yuy2, width);
+      src_argb += src_stride_argb;
+      dst_yuy2 += dst_stride_yuy2;
+    }
+
+    free_aligned_buffer_64(row_y);
+  }
+  return 0;
+}
+
+// Convert ARGB to UYVY.
+LIBYUV_API
+int ARGBToUYVY(const uint8_t* src_argb,
+               int src_stride_argb,
+               uint8_t* dst_uyvy,
+               int dst_stride_uyvy,
+               int width,
+               int height) {
+  int y;
+  void (*ARGBToUVRow)(const uint8_t* src_argb, int src_stride_argb,
+                      uint8_t* dst_u, uint8_t* dst_v, int width) =
+      ARGBToUVRow_C;
+  void (*ARGBToYRow)(const uint8_t* src_argb, uint8_t* dst_y, int width) =
+      ARGBToYRow_C;
+  void (*I422ToUYVYRow)(const uint8_t* src_y, const uint8_t* src_u,
+                        const uint8_t* src_v, uint8_t* dst_uyvy, int width) =
+      I422ToUYVYRow_C;
+
+  if (!src_argb || !dst_uyvy || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    dst_uyvy = dst_uyvy + (height - 1) * dst_stride_uyvy;
+    dst_stride_uyvy = -dst_stride_uyvy;
+  }
+  // Coalesce rows.
+  if (src_stride_argb == width * 4 && dst_stride_uyvy == width * 2) {
+    width *= height;
+    height = 1;
+    src_stride_argb = dst_stride_uyvy = 0;
+  }
+#if defined(HAS_ARGBTOYROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    ARGBToYRow = ARGBToYRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBToYRow = ARGBToYRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOUVROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    ARGBToUVRow = ARGBToUVRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBToUVRow = ARGBToUVRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOYROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ARGBToYRow = ARGBToYRow_Any_AVX2;
+    if (IS_ALIGNED(width, 32)) {
+      ARGBToYRow = ARGBToYRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOUVROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ARGBToUVRow = ARGBToUVRow_Any_AVX2;
+    if (IS_ALIGNED(width, 32)) {
+      ARGBToUVRow = ARGBToUVRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOYROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    ARGBToYRow = ARGBToYRow_Any_NEON;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBToYRow = ARGBToYRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOUVROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    ARGBToUVRow = ARGBToUVRow_Any_NEON;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBToUVRow = ARGBToUVRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOYROW_MSA) && defined(HAS_ARGBTOUVROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    ARGBToYRow = ARGBToYRow_Any_MSA;
+    ARGBToUVRow = ARGBToUVRow_Any_MSA;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBToYRow = ARGBToYRow_MSA;
+    }
+    if (IS_ALIGNED(width, 32)) {
+      ARGBToUVRow = ARGBToUVRow_MSA;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOYROW_LASX) && defined(HAS_ARGBTOUVROW_LASX)
+  if (TestCpuFlag(kCpuHasLASX)) {
+    ARGBToYRow = ARGBToYRow_Any_LASX;
+    ARGBToUVRow = ARGBToUVRow_Any_LASX;
+    if (IS_ALIGNED(width, 32)) {
+      ARGBToYRow = ARGBToYRow_LASX;
+      ARGBToUVRow = ARGBToUVRow_LASX;
+    }
+  }
+#endif
+#if defined(HAS_I422TOUYVYROW_SSE2)
+  if (TestCpuFlag(kCpuHasSSE2)) {
+    I422ToUYVYRow = I422ToUYVYRow_Any_SSE2;
+    if (IS_ALIGNED(width, 16)) {
+      I422ToUYVYRow = I422ToUYVYRow_SSE2;
+    }
+  }
+#endif
+#if defined(HAS_I422TOUYVYROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    I422ToUYVYRow = I422ToUYVYRow_Any_AVX2;
+    if (IS_ALIGNED(width, 32)) {
+      I422ToUYVYRow = I422ToUYVYRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_I422TOUYVYROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    I422ToUYVYRow = I422ToUYVYRow_Any_NEON;
+    if (IS_ALIGNED(width, 16)) {
+      I422ToUYVYRow = I422ToUYVYRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_I422TOUYVYROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    I422ToUYVYRow = I422ToUYVYRow_Any_MSA;
+    if (IS_ALIGNED(width, 32)) {
+      I422ToUYVYRow = I422ToUYVYRow_MSA;
+    }
+  }
+#endif
+#if defined(HAS_I422TOUYVYROW_LASX)
+  if (TestCpuFlag(kCpuHasLASX)) {
+    I422ToUYVYRow = I422ToUYVYRow_Any_LASX;
+    if (IS_ALIGNED(width, 32)) {
+      I422ToUYVYRow = I422ToUYVYRow_LASX;
+    }
+  }
+#endif
+
+  {
+    // Allocate a rows of yuv.
+    align_buffer_64(row_y, ((width + 63) & ~63) * 2);
+    uint8_t* row_u = row_y + ((width + 63) & ~63);
+    uint8_t* row_v = row_u + ((width + 63) & ~63) / 2;
+
+    for (y = 0; y < height; ++y) {
+      ARGBToUVRow(src_argb, 0, row_u, row_v, width);
+      ARGBToYRow(src_argb, row_y, width);
+      I422ToUYVYRow(row_y, row_u, row_v, dst_uyvy, width);
+      src_argb += src_stride_argb;
+      dst_uyvy += dst_stride_uyvy;
+    }
+
+    free_aligned_buffer_64(row_y);
+  }
+  return 0;
+}
+
+// Convert ARGB to I400.
+LIBYUV_API
+int ARGBToI400(const uint8_t* src_argb,
+               int src_stride_argb,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               int width,
+               int height) {
+  int y;
+  void (*ARGBToYRow)(const uint8_t* src_argb, uint8_t* dst_y, int width) =
+      ARGBToYRow_C;
+  if (!src_argb || !dst_y || width <= 0 || height == 0) {
+    return -1;
+  }
+  if (height < 0) {
+    height = -height;
+    src_argb = src_argb + (height - 1) * src_stride_argb;
+    src_stride_argb = -src_stride_argb;
+  }
+  // Coalesce rows.
+  if (src_stride_argb == width * 4 && dst_stride_y == width) {
+    width *= height;
+    height = 1;
+    src_stride_argb = dst_stride_y = 0;
+  }
+#if defined(HAS_ARGBTOYROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    ARGBToYRow = ARGBToYRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBToYRow = ARGBToYRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOYROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ARGBToYRow = ARGBToYRow_Any_AVX2;
+    if (IS_ALIGNED(width, 32)) {
+      ARGBToYRow = ARGBToYRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOYROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    ARGBToYRow = ARGBToYRow_Any_NEON;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBToYRow = ARGBToYRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOYROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    ARGBToYRow = ARGBToYRow_Any_MSA;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBToYRow = ARGBToYRow_MSA;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOYROW_LASX)
+  if (TestCpuFlag(kCpuHasLASX)) {
+    ARGBToYRow = ARGBToYRow_Any_LASX;
+    if (IS_ALIGNED(width, 32)) {
+      ARGBToYRow = ARGBToYRow_LASX;
+    }
+  }
+#endif
+
+  for (y = 0; y < height; ++y) {
+    ARGBToYRow(src_argb, dst_y, width);
+    src_argb += src_stride_argb;
+    dst_y += dst_stride_y;
+  }
+  return 0;
+}
+
+// Shuffle table for converting ARGB to RGBA.
+static const uvec8 kShuffleMaskARGBToRGBA = {
+    3u, 0u, 1u, 2u, 7u, 4u, 5u, 6u, 11u, 8u, 9u, 10u, 15u, 12u, 13u, 14u};
+
+// Convert ARGB to RGBA.
+LIBYUV_API
+int ARGBToRGBA(const uint8_t* src_argb,
+               int src_stride_argb,
+               uint8_t* dst_rgba,
+               int dst_stride_rgba,
+               int width,
+               int height) {
+  return ARGBShuffle(src_argb, src_stride_argb, dst_rgba, dst_stride_rgba,
+                     (const uint8_t*)(&kShuffleMaskARGBToRGBA), width, height);
+}
+
+// Convert ARGB To RGB24.
+LIBYUV_API
+int ARGBToRGB24(const uint8_t* src_argb,
+                int src_stride_argb,
+                uint8_t* dst_rgb24,
+                int dst_stride_rgb24,
+                int width,
+                int height) {
+  int y;
+  void (*ARGBToRGB24Row)(const uint8_t* src_argb, uint8_t* dst_rgb, int width) =
+      ARGBToRGB24Row_C;
+  if (!src_argb || !dst_rgb24 || width <= 0 || height == 0) {
+    return -1;
+  }
+  if (height < 0) {
+    height = -height;
+    src_argb = src_argb + (height - 1) * src_stride_argb;
+    src_stride_argb = -src_stride_argb;
+  }
+  // Coalesce rows.
+  if (src_stride_argb == width * 4 && dst_stride_rgb24 == width * 3) {
+    width *= height;
+    height = 1;
+    src_stride_argb = dst_stride_rgb24 = 0;
+  }
+#if defined(HAS_ARGBTORGB24ROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    ARGBToRGB24Row = ARGBToRGB24Row_Any_SSSE3;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBToRGB24Row = ARGBToRGB24Row_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTORGB24ROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ARGBToRGB24Row = ARGBToRGB24Row_Any_AVX2;
+    if (IS_ALIGNED(width, 32)) {
+      ARGBToRGB24Row = ARGBToRGB24Row_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTORGB24ROW_AVX512VBMI)
+  if (TestCpuFlag(kCpuHasAVX512VBMI)) {
+    ARGBToRGB24Row = ARGBToRGB24Row_Any_AVX512VBMI;
+    if (IS_ALIGNED(width, 32)) {
+      ARGBToRGB24Row = ARGBToRGB24Row_AVX512VBMI;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTORGB24ROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    ARGBToRGB24Row = ARGBToRGB24Row_Any_NEON;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBToRGB24Row = ARGBToRGB24Row_NEON;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTORGB24ROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    ARGBToRGB24Row = ARGBToRGB24Row_Any_MSA;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBToRGB24Row = ARGBToRGB24Row_MSA;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTORGB24ROW_LASX)
+  if (TestCpuFlag(kCpuHasLASX)) {
+    ARGBToRGB24Row = ARGBToRGB24Row_Any_LASX;
+    if (IS_ALIGNED(width, 32)) {
+      ARGBToRGB24Row = ARGBToRGB24Row_LASX;
+    }
+  }
+#endif
+
+  for (y = 0; y < height; ++y) {
+    ARGBToRGB24Row(src_argb, dst_rgb24, width);
+    src_argb += src_stride_argb;
+    dst_rgb24 += dst_stride_rgb24;
+  }
+  return 0;
+}
+
+// Convert ARGB To RAW.
+LIBYUV_API
+int ARGBToRAW(const uint8_t* src_argb,
+              int src_stride_argb,
+              uint8_t* dst_raw,
+              int dst_stride_raw,
+              int width,
+              int height) {
+  int y;
+  void (*ARGBToRAWRow)(const uint8_t* src_argb, uint8_t* dst_rgb, int width) =
+      ARGBToRAWRow_C;
+  if (!src_argb || !dst_raw || width <= 0 || height == 0) {
+    return -1;
+  }
+  if (height < 0) {
+    height = -height;
+    src_argb = src_argb + (height - 1) * src_stride_argb;
+    src_stride_argb = -src_stride_argb;
+  }
+  // Coalesce rows.
+  if (src_stride_argb == width * 4 && dst_stride_raw == width * 3) {
+    width *= height;
+    height = 1;
+    src_stride_argb = dst_stride_raw = 0;
+  }
+#if defined(HAS_ARGBTORAWROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    ARGBToRAWRow = ARGBToRAWRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBToRAWRow = ARGBToRAWRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTORAWROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ARGBToRAWRow = ARGBToRAWRow_Any_AVX2;
+    if (IS_ALIGNED(width, 32)) {
+      ARGBToRAWRow = ARGBToRAWRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTORAWROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    ARGBToRAWRow = ARGBToRAWRow_Any_NEON;
+    if (IS_ALIGNED(width, 8)) {
+      ARGBToRAWRow = ARGBToRAWRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTORAWROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    ARGBToRAWRow = ARGBToRAWRow_Any_MSA;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBToRAWRow = ARGBToRAWRow_MSA;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTORAWROW_LASX)
+  if (TestCpuFlag(kCpuHasLASX)) {
+    ARGBToRAWRow = ARGBToRAWRow_Any_LASX;
+    if (IS_ALIGNED(width, 32)) {
+      ARGBToRAWRow = ARGBToRAWRow_LASX;
+    }
+  }
+#endif
+
+  for (y = 0; y < height; ++y) {
+    ARGBToRAWRow(src_argb, dst_raw, width);
+    src_argb += src_stride_argb;
+    dst_raw += dst_stride_raw;
+  }
+  return 0;
+}
+
+// Ordered 8x8 dither for 888 to 565.  Values from 0 to 7.
+static const uint8_t kDither565_4x4[16] = {
+    0, 4, 1, 5, 6, 2, 7, 3, 1, 5, 0, 4, 7, 3, 6, 2,
+};
+
+// Convert ARGB To RGB565 with 4x4 dither matrix (16 bytes).
+LIBYUV_API
+int ARGBToRGB565Dither(const uint8_t* src_argb,
+                       int src_stride_argb,
+                       uint8_t* dst_rgb565,
+                       int dst_stride_rgb565,
+                       const uint8_t* dither4x4,
+                       int width,
+                       int height) {
+  int y;
+  void (*ARGBToRGB565DitherRow)(const uint8_t* src_argb, uint8_t* dst_rgb,
+                                const uint32_t dither4, int width) =
+      ARGBToRGB565DitherRow_C;
+  if (!src_argb || !dst_rgb565 || width <= 0 || height == 0) {
+    return -1;
+  }
+  if (height < 0) {
+    height = -height;
+    src_argb = src_argb + (height - 1) * src_stride_argb;
+    src_stride_argb = -src_stride_argb;
+  }
+  if (!dither4x4) {
+    dither4x4 = kDither565_4x4;
+  }
+#if defined(HAS_ARGBTORGB565DITHERROW_SSE2)
+  if (TestCpuFlag(kCpuHasSSE2)) {
+    ARGBToRGB565DitherRow = ARGBToRGB565DitherRow_Any_SSE2;
+    if (IS_ALIGNED(width, 4)) {
+      ARGBToRGB565DitherRow = ARGBToRGB565DitherRow_SSE2;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTORGB565DITHERROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ARGBToRGB565DitherRow = ARGBToRGB565DitherRow_Any_AVX2;
+    if (IS_ALIGNED(width, 8)) {
+      ARGBToRGB565DitherRow = ARGBToRGB565DitherRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTORGB565DITHERROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    ARGBToRGB565DitherRow = ARGBToRGB565DitherRow_Any_NEON;
+    if (IS_ALIGNED(width, 8)) {
+      ARGBToRGB565DitherRow = ARGBToRGB565DitherRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTORGB565DITHERROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    ARGBToRGB565DitherRow = ARGBToRGB565DitherRow_Any_MSA;
+    if (IS_ALIGNED(width, 8)) {
+      ARGBToRGB565DitherRow = ARGBToRGB565DitherRow_MSA;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTORGB565DITHERROW_LASX)
+  if (TestCpuFlag(kCpuHasLASX)) {
+    ARGBToRGB565DitherRow = ARGBToRGB565DitherRow_Any_LASX;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBToRGB565DitherRow = ARGBToRGB565DitherRow_LASX;
+    }
+  }
+#endif
+
+  for (y = 0; y < height; ++y) {
+    ARGBToRGB565DitherRow(src_argb, dst_rgb565,
+                          *(const uint32_t*)(dither4x4 + ((y & 3) << 2)),
+                          width);
+    src_argb += src_stride_argb;
+    dst_rgb565 += dst_stride_rgb565;
+  }
+  return 0;
+}
+
+// Convert ARGB To RGB565.
+// TODO(fbarchard): Consider using dither function low level with zeros.
+LIBYUV_API
+int ARGBToRGB565(const uint8_t* src_argb,
+                 int src_stride_argb,
+                 uint8_t* dst_rgb565,
+                 int dst_stride_rgb565,
+                 int width,
+                 int height) {
+  int y;
+  void (*ARGBToRGB565Row)(const uint8_t* src_argb, uint8_t* dst_rgb,
+                          int width) = ARGBToRGB565Row_C;
+  if (!src_argb || !dst_rgb565 || width <= 0 || height == 0) {
+    return -1;
+  }
+  if (height < 0) {
+    height = -height;
+    src_argb = src_argb + (height - 1) * src_stride_argb;
+    src_stride_argb = -src_stride_argb;
+  }
+  // Coalesce rows.
+  if (src_stride_argb == width * 4 && dst_stride_rgb565 == width * 2) {
+    width *= height;
+    height = 1;
+    src_stride_argb = dst_stride_rgb565 = 0;
+  }
+#if defined(HAS_ARGBTORGB565ROW_SSE2)
+  if (TestCpuFlag(kCpuHasSSE2)) {
+    ARGBToRGB565Row = ARGBToRGB565Row_Any_SSE2;
+    if (IS_ALIGNED(width, 4)) {
+      ARGBToRGB565Row = ARGBToRGB565Row_SSE2;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTORGB565ROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ARGBToRGB565Row = ARGBToRGB565Row_Any_AVX2;
+    if (IS_ALIGNED(width, 8)) {
+      ARGBToRGB565Row = ARGBToRGB565Row_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTORGB565ROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    ARGBToRGB565Row = ARGBToRGB565Row_Any_NEON;
+    if (IS_ALIGNED(width, 8)) {
+      ARGBToRGB565Row = ARGBToRGB565Row_NEON;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTORGB565ROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    ARGBToRGB565Row = ARGBToRGB565Row_Any_MSA;
+    if (IS_ALIGNED(width, 8)) {
+      ARGBToRGB565Row = ARGBToRGB565Row_MSA;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTORGB565ROW_LASX)
+  if (TestCpuFlag(kCpuHasLASX)) {
+    ARGBToRGB565Row = ARGBToRGB565Row_Any_LASX;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBToRGB565Row = ARGBToRGB565Row_LASX;
+    }
+  }
+#endif
+
+  for (y = 0; y < height; ++y) {
+    ARGBToRGB565Row(src_argb, dst_rgb565, width);
+    src_argb += src_stride_argb;
+    dst_rgb565 += dst_stride_rgb565;
+  }
+  return 0;
+}
+
+// Convert ARGB To ARGB1555.
+LIBYUV_API
+int ARGBToARGB1555(const uint8_t* src_argb,
+                   int src_stride_argb,
+                   uint8_t* dst_argb1555,
+                   int dst_stride_argb1555,
+                   int width,
+                   int height) {
+  int y;
+  void (*ARGBToARGB1555Row)(const uint8_t* src_argb, uint8_t* dst_rgb,
+                            int width) = ARGBToARGB1555Row_C;
+  if (!src_argb || !dst_argb1555 || width <= 0 || height == 0) {
+    return -1;
+  }
+  if (height < 0) {
+    height = -height;
+    src_argb = src_argb + (height - 1) * src_stride_argb;
+    src_stride_argb = -src_stride_argb;
+  }
+  // Coalesce rows.
+  if (src_stride_argb == width * 4 && dst_stride_argb1555 == width * 2) {
+    width *= height;
+    height = 1;
+    src_stride_argb = dst_stride_argb1555 = 0;
+  }
+#if defined(HAS_ARGBTOARGB1555ROW_SSE2)
+  if (TestCpuFlag(kCpuHasSSE2)) {
+    ARGBToARGB1555Row = ARGBToARGB1555Row_Any_SSE2;
+    if (IS_ALIGNED(width, 4)) {
+      ARGBToARGB1555Row = ARGBToARGB1555Row_SSE2;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOARGB1555ROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ARGBToARGB1555Row = ARGBToARGB1555Row_Any_AVX2;
+    if (IS_ALIGNED(width, 8)) {
+      ARGBToARGB1555Row = ARGBToARGB1555Row_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOARGB1555ROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    ARGBToARGB1555Row = ARGBToARGB1555Row_Any_NEON;
+    if (IS_ALIGNED(width, 8)) {
+      ARGBToARGB1555Row = ARGBToARGB1555Row_NEON;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOARGB1555ROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    ARGBToARGB1555Row = ARGBToARGB1555Row_Any_MSA;
+    if (IS_ALIGNED(width, 8)) {
+      ARGBToARGB1555Row = ARGBToARGB1555Row_MSA;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOARGB1555ROW_LASX)
+  if (TestCpuFlag(kCpuHasLASX)) {
+    ARGBToARGB1555Row = ARGBToARGB1555Row_Any_LASX;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBToARGB1555Row = ARGBToARGB1555Row_LASX;
+    }
+  }
+#endif
+
+  for (y = 0; y < height; ++y) {
+    ARGBToARGB1555Row(src_argb, dst_argb1555, width);
+    src_argb += src_stride_argb;
+    dst_argb1555 += dst_stride_argb1555;
+  }
+  return 0;
+}
+
+// Convert ARGB To ARGB4444.
+LIBYUV_API
+int ARGBToARGB4444(const uint8_t* src_argb,
+                   int src_stride_argb,
+                   uint8_t* dst_argb4444,
+                   int dst_stride_argb4444,
+                   int width,
+                   int height) {
+  int y;
+  void (*ARGBToARGB4444Row)(const uint8_t* src_argb, uint8_t* dst_rgb,
+                            int width) = ARGBToARGB4444Row_C;
+  if (!src_argb || !dst_argb4444 || width <= 0 || height == 0) {
+    return -1;
+  }
+  if (height < 0) {
+    height = -height;
+    src_argb = src_argb + (height - 1) * src_stride_argb;
+    src_stride_argb = -src_stride_argb;
+  }
+  // Coalesce rows.
+  if (src_stride_argb == width * 4 && dst_stride_argb4444 == width * 2) {
+    width *= height;
+    height = 1;
+    src_stride_argb = dst_stride_argb4444 = 0;
+  }
+#if defined(HAS_ARGBTOARGB4444ROW_SSE2)
+  if (TestCpuFlag(kCpuHasSSE2)) {
+    ARGBToARGB4444Row = ARGBToARGB4444Row_Any_SSE2;
+    if (IS_ALIGNED(width, 4)) {
+      ARGBToARGB4444Row = ARGBToARGB4444Row_SSE2;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOARGB4444ROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ARGBToARGB4444Row = ARGBToARGB4444Row_Any_AVX2;
+    if (IS_ALIGNED(width, 8)) {
+      ARGBToARGB4444Row = ARGBToARGB4444Row_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOARGB4444ROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    ARGBToARGB4444Row = ARGBToARGB4444Row_Any_NEON;
+    if (IS_ALIGNED(width, 8)) {
+      ARGBToARGB4444Row = ARGBToARGB4444Row_NEON;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOARGB4444ROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    ARGBToARGB4444Row = ARGBToARGB4444Row_Any_MSA;
+    if (IS_ALIGNED(width, 8)) {
+      ARGBToARGB4444Row = ARGBToARGB4444Row_MSA;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOARGB4444ROW_LASX)
+  if (TestCpuFlag(kCpuHasLASX)) {
+    ARGBToARGB4444Row = ARGBToARGB4444Row_Any_LASX;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBToARGB4444Row = ARGBToARGB4444Row_LASX;
+    }
+  }
+#endif
+
+  for (y = 0; y < height; ++y) {
+    ARGBToARGB4444Row(src_argb, dst_argb4444, width);
+    src_argb += src_stride_argb;
+    dst_argb4444 += dst_stride_argb4444;
+  }
+  return 0;
+}
+
+// Convert ABGR To AR30.
+LIBYUV_API
+int ABGRToAR30(const uint8_t* src_abgr,
+               int src_stride_abgr,
+               uint8_t* dst_ar30,
+               int dst_stride_ar30,
+               int width,
+               int height) {
+  int y;
+  void (*ABGRToAR30Row)(const uint8_t* src_abgr, uint8_t* dst_rgb, int width) =
+      ABGRToAR30Row_C;
+  if (!src_abgr || !dst_ar30 || width <= 0 || height == 0) {
+    return -1;
+  }
+  if (height < 0) {
+    height = -height;
+    src_abgr = src_abgr + (height - 1) * src_stride_abgr;
+    src_stride_abgr = -src_stride_abgr;
+  }
+  // Coalesce rows.
+  if (src_stride_abgr == width * 4 && dst_stride_ar30 == width * 4) {
+    width *= height;
+    height = 1;
+    src_stride_abgr = dst_stride_ar30 = 0;
+  }
+#if defined(HAS_ABGRTOAR30ROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    ABGRToAR30Row = ABGRToAR30Row_Any_SSSE3;
+    if (IS_ALIGNED(width, 4)) {
+      ABGRToAR30Row = ABGRToAR30Row_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_ABGRTOAR30ROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ABGRToAR30Row = ABGRToAR30Row_Any_AVX2;
+    if (IS_ALIGNED(width, 8)) {
+      ABGRToAR30Row = ABGRToAR30Row_AVX2;
+    }
+  }
+#endif
+  for (y = 0; y < height; ++y) {
+    ABGRToAR30Row(src_abgr, dst_ar30, width);
+    src_abgr += src_stride_abgr;
+    dst_ar30 += dst_stride_ar30;
+  }
+  return 0;
+}
+
+// Convert ARGB To AR30.
+LIBYUV_API
+int ARGBToAR30(const uint8_t* src_argb,
+               int src_stride_argb,
+               uint8_t* dst_ar30,
+               int dst_stride_ar30,
+               int width,
+               int height) {
+  int y;
+  void (*ARGBToAR30Row)(const uint8_t* src_argb, uint8_t* dst_rgb, int width) =
+      ARGBToAR30Row_C;
+  if (!src_argb || !dst_ar30 || width <= 0 || height == 0) {
+    return -1;
+  }
+  if (height < 0) {
+    height = -height;
+    src_argb = src_argb + (height - 1) * src_stride_argb;
+    src_stride_argb = -src_stride_argb;
+  }
+  // Coalesce rows.
+  if (src_stride_argb == width * 4 && dst_stride_ar30 == width * 4) {
+    width *= height;
+    height = 1;
+    src_stride_argb = dst_stride_ar30 = 0;
+  }
+#if defined(HAS_ARGBTOAR30ROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    ARGBToAR30Row = ARGBToAR30Row_Any_SSSE3;
+    if (IS_ALIGNED(width, 4)) {
+      ARGBToAR30Row = ARGBToAR30Row_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOAR30ROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ARGBToAR30Row = ARGBToAR30Row_Any_AVX2;
+    if (IS_ALIGNED(width, 8)) {
+      ARGBToAR30Row = ARGBToAR30Row_AVX2;
+    }
+  }
+#endif
+  for (y = 0; y < height; ++y) {
+    ARGBToAR30Row(src_argb, dst_ar30, width);
+    src_argb += src_stride_argb;
+    dst_ar30 += dst_stride_ar30;
+  }
+  return 0;
+}
+
+// Convert ARGB to J420. (JPeg full range I420).
+LIBYUV_API
+int ARGBToJ420(const uint8_t* src_argb,
+               int src_stride_argb,
+               uint8_t* dst_yj,
+               int dst_stride_yj,
+               uint8_t* dst_u,
+               int dst_stride_u,
+               uint8_t* dst_v,
+               int dst_stride_v,
+               int width,
+               int height) {
+  int y;
+  void (*ARGBToUVJRow)(const uint8_t* src_argb0, int src_stride_argb,
+                       uint8_t* dst_u, uint8_t* dst_v, int width) =
+      ARGBToUVJRow_C;
+  void (*ARGBToYJRow)(const uint8_t* src_argb, uint8_t* dst_yj, int width) =
+      ARGBToYJRow_C;
+  if (!src_argb || !dst_yj || !dst_u || !dst_v || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    src_argb = src_argb + (height - 1) * src_stride_argb;
+    src_stride_argb = -src_stride_argb;
+  }
+#if defined(HAS_ARGBTOYJROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    ARGBToYJRow = ARGBToYJRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBToYJRow = ARGBToYJRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOUVJROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    ARGBToUVJRow = ARGBToUVJRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBToUVJRow = ARGBToUVJRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOYJROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ARGBToYJRow = ARGBToYJRow_Any_AVX2;
+    if (IS_ALIGNED(width, 32)) {
+      ARGBToYJRow = ARGBToYJRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOYJROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    ARGBToYJRow = ARGBToYJRow_Any_NEON;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBToYJRow = ARGBToYJRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOUVJROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    ARGBToUVJRow = ARGBToUVJRow_Any_NEON;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBToUVJRow = ARGBToUVJRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOYJROW_MSA) && defined(HAS_ARGBTOUVJROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    ARGBToYJRow = ARGBToYJRow_Any_MSA;
+    ARGBToUVJRow = ARGBToUVJRow_Any_MSA;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBToYJRow = ARGBToYJRow_MSA;
+    }
+    if (IS_ALIGNED(width, 32)) {
+      ARGBToUVJRow = ARGBToUVJRow_MSA;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOYJROW_LSX) && defined(HAS_ARGBTOUVJROW_LSX)
+  if (TestCpuFlag(kCpuHasLSX)) {
+    ARGBToYJRow = ARGBToYJRow_Any_LSX;
+    ARGBToUVJRow = ARGBToUVJRow_Any_LSX;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBToYJRow = ARGBToYJRow_LSX;
+      ARGBToUVJRow = ARGBToUVJRow_LSX;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOYJROW_LASX) && defined(HAS_ARGBTOUVJROW_LASX)
+  if (TestCpuFlag(kCpuHasLASX)) {
+    ARGBToYJRow = ARGBToYJRow_Any_LASX;
+    ARGBToUVJRow = ARGBToUVJRow_Any_LASX;
+    if (IS_ALIGNED(width, 32)) {
+      ARGBToYJRow = ARGBToYJRow_LASX;
+      ARGBToUVJRow = ARGBToUVJRow_LASX;
+    }
+  }
+#endif
+
+  for (y = 0; y < height - 1; y += 2) {
+    ARGBToUVJRow(src_argb, src_stride_argb, dst_u, dst_v, width);
+    ARGBToYJRow(src_argb, dst_yj, width);
+    ARGBToYJRow(src_argb + src_stride_argb, dst_yj + dst_stride_yj, width);
+    src_argb += src_stride_argb * 2;
+    dst_yj += dst_stride_yj * 2;
+    dst_u += dst_stride_u;
+    dst_v += dst_stride_v;
+  }
+  if (height & 1) {
+    ARGBToUVJRow(src_argb, 0, dst_u, dst_v, width);
+    ARGBToYJRow(src_argb, dst_yj, width);
+  }
+  return 0;
+}
+
+// Convert ARGB to J422. (JPeg full range I422).
+LIBYUV_API
+int ARGBToJ422(const uint8_t* src_argb,
+               int src_stride_argb,
+               uint8_t* dst_yj,
+               int dst_stride_yj,
+               uint8_t* dst_u,
+               int dst_stride_u,
+               uint8_t* dst_v,
+               int dst_stride_v,
+               int width,
+               int height) {
+  int y;
+  void (*ARGBToUVJRow)(const uint8_t* src_argb0, int src_stride_argb,
+                       uint8_t* dst_u, uint8_t* dst_v, int width) =
+      ARGBToUVJRow_C;
+  void (*ARGBToYJRow)(const uint8_t* src_argb, uint8_t* dst_yj, int width) =
+      ARGBToYJRow_C;
+  if (!src_argb || !dst_yj || !dst_u || !dst_v || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    src_argb = src_argb + (height - 1) * src_stride_argb;
+    src_stride_argb = -src_stride_argb;
+  }
+  // Coalesce rows.
+  if (src_stride_argb == width * 4 && dst_stride_yj == width &&
+      dst_stride_u * 2 == width && dst_stride_v * 2 == width) {
+    width *= height;
+    height = 1;
+    src_stride_argb = dst_stride_yj = dst_stride_u = dst_stride_v = 0;
+  }
+#if defined(HAS_ARGBTOYJROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    ARGBToYJRow = ARGBToYJRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBToYJRow = ARGBToYJRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOUVJROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    ARGBToUVJRow = ARGBToUVJRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBToUVJRow = ARGBToUVJRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOYJROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ARGBToYJRow = ARGBToYJRow_Any_AVX2;
+    if (IS_ALIGNED(width, 32)) {
+      ARGBToYJRow = ARGBToYJRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOYJROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    ARGBToYJRow = ARGBToYJRow_Any_NEON;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBToYJRow = ARGBToYJRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOUVJROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    ARGBToUVJRow = ARGBToUVJRow_Any_NEON;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBToUVJRow = ARGBToUVJRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOYJROW_MSA) && defined(HAS_ARGBTOUVJROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    ARGBToYJRow = ARGBToYJRow_Any_MSA;
+    ARGBToUVJRow = ARGBToUVJRow_Any_MSA;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBToYJRow = ARGBToYJRow_MSA;
+    }
+    if (IS_ALIGNED(width, 32)) {
+      ARGBToUVJRow = ARGBToUVJRow_MSA;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOYJROW_LSX) && defined(HAS_ARGBTOUVJROW_LSX)
+  if (TestCpuFlag(kCpuHasLSX)) {
+    ARGBToYJRow = ARGBToYJRow_Any_LSX;
+    ARGBToUVJRow = ARGBToUVJRow_Any_LSX;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBToYJRow = ARGBToYJRow_LSX;
+      ARGBToUVJRow = ARGBToUVJRow_LSX;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOYJROW_LASX) && defined(HAS_ARGBTOUVJROW_LASX)
+  if (TestCpuFlag(kCpuHasLASX)) {
+    ARGBToYJRow = ARGBToYJRow_Any_LASX;
+    ARGBToUVJRow = ARGBToUVJRow_Any_LASX;
+    if (IS_ALIGNED(width, 32)) {
+      ARGBToYJRow = ARGBToYJRow_LASX;
+      ARGBToUVJRow = ARGBToUVJRow_LASX;
+    }
+  }
+#endif
+
+  for (y = 0; y < height; ++y) {
+    ARGBToUVJRow(src_argb, 0, dst_u, dst_v, width);
+    ARGBToYJRow(src_argb, dst_yj, width);
+    src_argb += src_stride_argb;
+    dst_yj += dst_stride_yj;
+    dst_u += dst_stride_u;
+    dst_v += dst_stride_v;
+  }
+  return 0;
+}
+
+// Convert ARGB to AR64.
+LIBYUV_API
+int ARGBToAR64(const uint8_t* src_argb,
+               int src_stride_argb,
+               uint16_t* dst_ar64,
+               int dst_stride_ar64,
+               int width,
+               int height) {
+  int y;
+  void (*ARGBToAR64Row)(const uint8_t* src_argb, uint16_t* dst_ar64,
+                        int width) = ARGBToAR64Row_C;
+  if (!src_argb || !dst_ar64 || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    src_argb = src_argb + (height - 1) * src_stride_argb;
+    src_stride_argb = -src_stride_argb;
+  }
+  // Coalesce rows.
+  if (src_stride_argb == width * 4 && dst_stride_ar64 == width * 4) {
+    width *= height;
+    height = 1;
+    src_stride_argb = dst_stride_ar64 = 0;
+  }
+#if defined(HAS_ARGBTOAR64ROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    ARGBToAR64Row = ARGBToAR64Row_Any_SSSE3;
+    if (IS_ALIGNED(width, 4)) {
+      ARGBToAR64Row = ARGBToAR64Row_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOAR64ROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ARGBToAR64Row = ARGBToAR64Row_Any_AVX2;
+    if (IS_ALIGNED(width, 8)) {
+      ARGBToAR64Row = ARGBToAR64Row_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOAR64ROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    ARGBToAR64Row = ARGBToAR64Row_Any_NEON;
+    if (IS_ALIGNED(width, 8)) {
+      ARGBToAR64Row = ARGBToAR64Row_NEON;
+    }
+  }
+#endif
+
+  for (y = 0; y < height; ++y) {
+    ARGBToAR64Row(src_argb, dst_ar64, width);
+    src_argb += src_stride_argb;
+    dst_ar64 += dst_stride_ar64;
+  }
+  return 0;
+}
+
+// Convert ARGB to AB64.
+LIBYUV_API
+int ARGBToAB64(const uint8_t* src_argb,
+               int src_stride_argb,
+               uint16_t* dst_ab64,
+               int dst_stride_ab64,
+               int width,
+               int height) {
+  int y;
+  void (*ARGBToAB64Row)(const uint8_t* src_argb, uint16_t* dst_ar64,
+                        int width) = ARGBToAB64Row_C;
+  if (!src_argb || !dst_ab64 || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    src_argb = src_argb + (height - 1) * src_stride_argb;
+    src_stride_argb = -src_stride_argb;
+  }
+  // Coalesce rows.
+  if (src_stride_argb == width * 4 && dst_stride_ab64 == width * 4) {
+    width *= height;
+    height = 1;
+    src_stride_argb = dst_stride_ab64 = 0;
+  }
+#if defined(HAS_ARGBTOAB64ROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    ARGBToAB64Row = ARGBToAB64Row_Any_SSSE3;
+    if (IS_ALIGNED(width, 4)) {
+      ARGBToAB64Row = ARGBToAB64Row_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOAB64ROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ARGBToAB64Row = ARGBToAB64Row_Any_AVX2;
+    if (IS_ALIGNED(width, 8)) {
+      ARGBToAB64Row = ARGBToAB64Row_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOAB64ROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    ARGBToAB64Row = ARGBToAB64Row_Any_NEON;
+    if (IS_ALIGNED(width, 8)) {
+      ARGBToAB64Row = ARGBToAB64Row_NEON;
+    }
+  }
+#endif
+
+  for (y = 0; y < height; ++y) {
+    ARGBToAB64Row(src_argb, dst_ab64, width);
+    src_argb += src_stride_argb;
+    dst_ab64 += dst_stride_ab64;
+  }
+  return 0;
+}
+
+// Convert ARGB to J400.
+LIBYUV_API
+int ARGBToJ400(const uint8_t* src_argb,
+               int src_stride_argb,
+               uint8_t* dst_yj,
+               int dst_stride_yj,
+               int width,
+               int height) {
+  int y;
+  void (*ARGBToYJRow)(const uint8_t* src_argb, uint8_t* dst_yj, int width) =
+      ARGBToYJRow_C;
+  if (!src_argb || !dst_yj || width <= 0 || height == 0) {
+    return -1;
+  }
+  if (height < 0) {
+    height = -height;
+    src_argb = src_argb + (height - 1) * src_stride_argb;
+    src_stride_argb = -src_stride_argb;
+  }
+  // Coalesce rows.
+  if (src_stride_argb == width * 4 && dst_stride_yj == width) {
+    width *= height;
+    height = 1;
+    src_stride_argb = dst_stride_yj = 0;
+  }
+#if defined(HAS_ARGBTOYJROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    ARGBToYJRow = ARGBToYJRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBToYJRow = ARGBToYJRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOYJROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ARGBToYJRow = ARGBToYJRow_Any_AVX2;
+    if (IS_ALIGNED(width, 32)) {
+      ARGBToYJRow = ARGBToYJRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOYJROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    ARGBToYJRow = ARGBToYJRow_Any_NEON;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBToYJRow = ARGBToYJRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOYJROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    ARGBToYJRow = ARGBToYJRow_Any_MSA;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBToYJRow = ARGBToYJRow_MSA;
+    }
+  }
+#endif
+
+  for (y = 0; y < height; ++y) {
+    ARGBToYJRow(src_argb, dst_yj, width);
+    src_argb += src_stride_argb;
+    dst_yj += dst_stride_yj;
+  }
+  return 0;
+}
+
+// Convert RGBA to J400.
+LIBYUV_API
+int RGBAToJ400(const uint8_t* src_rgba,
+               int src_stride_rgba,
+               uint8_t* dst_yj,
+               int dst_stride_yj,
+               int width,
+               int height) {
+  int y;
+  void (*RGBAToYJRow)(const uint8_t* src_rgba, uint8_t* dst_yj, int width) =
+      RGBAToYJRow_C;
+  if (!src_rgba || !dst_yj || width <= 0 || height == 0) {
+    return -1;
+  }
+  if (height < 0) {
+    height = -height;
+    src_rgba = src_rgba + (height - 1) * src_stride_rgba;
+    src_stride_rgba = -src_stride_rgba;
+  }
+  // Coalesce rows.
+  if (src_stride_rgba == width * 4 && dst_stride_yj == width) {
+    width *= height;
+    height = 1;
+    src_stride_rgba = dst_stride_yj = 0;
+  }
+#if defined(HAS_RGBATOYJROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    RGBAToYJRow = RGBAToYJRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 16)) {
+      RGBAToYJRow = RGBAToYJRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_RGBATOYJROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    RGBAToYJRow = RGBAToYJRow_Any_AVX2;
+    if (IS_ALIGNED(width, 32)) {
+      RGBAToYJRow = RGBAToYJRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_RGBATOYJROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    RGBAToYJRow = RGBAToYJRow_Any_NEON;
+    if (IS_ALIGNED(width, 16)) {
+      RGBAToYJRow = RGBAToYJRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_RGBATOYJROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    RGBAToYJRow = RGBAToYJRow_Any_MSA;
+    if (IS_ALIGNED(width, 16)) {
+      RGBAToYJRow = RGBAToYJRow_MSA;
+    }
+  }
+#endif
+
+  for (y = 0; y < height; ++y) {
+    RGBAToYJRow(src_rgba, dst_yj, width);
+    src_rgba += src_stride_rgba;
+    dst_yj += dst_stride_yj;
+  }
+  return 0;
+}
+
+// Enabled if 1 pass is available
+#if defined(HAS_RAWTOYJROW_NEON) || defined(HAS_RAWTOYJROW_MSA)
+#define HAS_RAWTOYJROW
+#endif
+
+// RAW to JNV21 full range NV21
+LIBYUV_API
+int RAWToJNV21(const uint8_t* src_raw,
+               int src_stride_raw,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_vu,
+               int dst_stride_vu,
+               int width,
+               int height) {
+  int y;
+  int halfwidth = (width + 1) >> 1;
+#if defined(HAS_RAWTOYJROW)
+  void (*RAWToUVJRow)(const uint8_t* src_raw, int src_stride_raw,
+                      uint8_t* dst_u, uint8_t* dst_v, int width) =
+      RAWToUVJRow_C;
+  void (*RAWToYJRow)(const uint8_t* src_raw, uint8_t* dst_y, int width) =
+      RAWToYJRow_C;
+#else
+  void (*RAWToARGBRow)(const uint8_t* src_rgb, uint8_t* dst_argb, int width) =
+      RAWToARGBRow_C;
+  void (*ARGBToUVJRow)(const uint8_t* src_argb0, int src_stride_argb,
+                       uint8_t* dst_u, uint8_t* dst_v, int width) =
+      ARGBToUVJRow_C;
+  void (*ARGBToYJRow)(const uint8_t* src_argb, uint8_t* dst_y, int width) =
+      ARGBToYJRow_C;
+#endif
+  void (*MergeUVRow_)(const uint8_t* src_u, const uint8_t* src_v,
+                      uint8_t* dst_vu, int width) = MergeUVRow_C;
+  if (!src_raw || !dst_y || !dst_vu || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    src_raw = src_raw + (height - 1) * src_stride_raw;
+    src_stride_raw = -src_stride_raw;
+  }
+
+#if defined(HAS_RAWTOYJROW)
+
+// Neon version does direct RAW to YUV.
+#if defined(HAS_RAWTOYJROW_NEON) && defined(HAS_RAWTOUVJROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    RAWToUVJRow = RAWToUVJRow_Any_NEON;
+    RAWToYJRow = RAWToYJRow_Any_NEON;
+    if (IS_ALIGNED(width, 16)) {
+      RAWToYJRow = RAWToYJRow_NEON;
+      RAWToUVJRow = RAWToUVJRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_RAWTOYJROW_MSA) && defined(HAS_RAWTOUVJROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    RAWToUVJRow = RAWToUVJRow_Any_MSA;
+    RAWToYJRow = RAWToYJRow_Any_MSA;
+    if (IS_ALIGNED(width, 16)) {
+      RAWToYJRow = RAWToYJRow_MSA;
+      RAWToUVJRow = RAWToUVJRow_MSA;
+    }
+  }
+#endif
+
+// Other platforms do intermediate conversion from RAW to ARGB.
+#else  // HAS_RAWTOYJROW
+
+#if defined(HAS_RAWTOARGBROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    RAWToARGBRow = RAWToARGBRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 16)) {
+      RAWToARGBRow = RAWToARGBRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOYJROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    ARGBToYJRow = ARGBToYJRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBToYJRow = ARGBToYJRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOYJROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ARGBToYJRow = ARGBToYJRow_Any_AVX2;
+    if (IS_ALIGNED(width, 32)) {
+      ARGBToYJRow = ARGBToYJRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOUVJROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    ARGBToUVJRow = ARGBToUVJRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBToUVJRow = ARGBToUVJRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOUVJROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ARGBToUVJRow = ARGBToUVJRow_Any_AVX2;
+    if (IS_ALIGNED(width, 32)) {
+      ARGBToUVJRow = ARGBToUVJRow_AVX2;
+    }
+  }
+#endif
+#endif  // HAS_RAWTOYJROW
+#if defined(HAS_MERGEUVROW_SSE2)
+  if (TestCpuFlag(kCpuHasSSE2)) {
+    MergeUVRow_ = MergeUVRow_Any_SSE2;
+    if (IS_ALIGNED(halfwidth, 16)) {
+      MergeUVRow_ = MergeUVRow_SSE2;
+    }
+  }
+#endif
+#if defined(HAS_MERGEUVROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    MergeUVRow_ = MergeUVRow_Any_AVX2;
+    if (IS_ALIGNED(halfwidth, 32)) {
+      MergeUVRow_ = MergeUVRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_MERGEUVROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    MergeUVRow_ = MergeUVRow_Any_NEON;
+    if (IS_ALIGNED(halfwidth, 16)) {
+      MergeUVRow_ = MergeUVRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_MERGEUVROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    MergeUVRow_ = MergeUVRow_Any_MSA;
+    if (IS_ALIGNED(halfwidth, 16)) {
+      MergeUVRow_ = MergeUVRow_MSA;
+    }
+  }
+#endif
+#if defined(HAS_MERGEUVROW_LSX)
+  if (TestCpuFlag(kCpuHasLSX)) {
+    MergeUVRow_ = MergeUVRow_Any_LSX;
+    if (IS_ALIGNED(halfwidth, 16)) {
+      MergeUVRow_ = MergeUVRow_LSX;
+    }
+  }
+#endif
+  {
+    // Allocate a row of uv.
+    align_buffer_64(row_u, ((halfwidth + 31) & ~31) * 2);
+    uint8_t* row_v = row_u + ((halfwidth + 31) & ~31);
+#if !defined(HAS_RAWTOYJROW)
+    // Allocate 2 rows of ARGB.
+    const int kRowSize = (width * 4 + 31) & ~31;
+    align_buffer_64(row, kRowSize * 2);
+#endif
+
+    for (y = 0; y < height - 1; y += 2) {
+#if defined(HAS_RAWTOYJROW)
+      RAWToUVJRow(src_raw, src_stride_raw, row_u, row_v, width);
+      MergeUVRow_(row_v, row_u, dst_vu, halfwidth);
+      RAWToYJRow(src_raw, dst_y, width);
+      RAWToYJRow(src_raw + src_stride_raw, dst_y + dst_stride_y, width);
+#else
+      RAWToARGBRow(src_raw, row, width);
+      RAWToARGBRow(src_raw + src_stride_raw, row + kRowSize, width);
+      ARGBToUVJRow(row, kRowSize, row_u, row_v, width);
+      MergeUVRow_(row_v, row_u, dst_vu, halfwidth);
+      ARGBToYJRow(row, dst_y, width);
+      ARGBToYJRow(row + kRowSize, dst_y + dst_stride_y, width);
+#endif
+      src_raw += src_stride_raw * 2;
+      dst_y += dst_stride_y * 2;
+      dst_vu += dst_stride_vu;
+    }
+    if (height & 1) {
+#if defined(HAS_RAWTOYJROW)
+      RAWToUVJRow(src_raw, 0, row_u, row_v, width);
+      MergeUVRow_(row_v, row_u, dst_vu, halfwidth);
+      RAWToYJRow(src_raw, dst_y, width);
+#else
+      RAWToARGBRow(src_raw, row, width);
+      ARGBToUVJRow(row, 0, row_u, row_v, width);
+      MergeUVRow_(row_v, row_u, dst_vu, halfwidth);
+      ARGBToYJRow(row, dst_y, width);
+#endif
+    }
+#if !defined(HAS_RAWTOYJROW)
+    free_aligned_buffer_64(row);
+#endif
+    free_aligned_buffer_64(row_u);
+  }
+  return 0;
+}
+#undef HAS_RAWTOYJROW
+
+#ifdef __cplusplus
+}  // extern "C"
+}  // namespace libyuv
+#endif
diff --git a/3rdparty/libyuv/src/source/convert_jpeg.cc b/3rdparty/libyuv/src/source/convert_jpeg.cc
new file mode 100644
index 00000000..d7556ee9
--- /dev/null
+++ b/3rdparty/libyuv/src/source/convert_jpeg.cc
@@ -0,0 +1,602 @@
+/*
+ *  Copyright 2011 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include "libyuv/convert.h"
+#include "libyuv/convert_argb.h"
+
+#ifdef HAVE_JPEG
+#include "libyuv/mjpeg_decoder.h"
+#endif
+
+#ifdef __cplusplus
+namespace libyuv {
+extern "C" {
+#endif
+
+#ifdef HAVE_JPEG
+struct I420Buffers {
+  uint8_t* y;
+  int y_stride;
+  uint8_t* u;
+  int u_stride;
+  uint8_t* v;
+  int v_stride;
+  int w;
+  int h;
+};
+
+static void JpegCopyI420(void* opaque,
+                         const uint8_t* const* data,
+                         const int* strides,
+                         int rows) {
+  I420Buffers* dest = (I420Buffers*)(opaque);
+  I420Copy(data[0], strides[0], data[1], strides[1], data[2], strides[2],
+           dest->y, dest->y_stride, dest->u, dest->u_stride, dest->v,
+           dest->v_stride, dest->w, rows);
+  dest->y += rows * dest->y_stride;
+  dest->u += ((rows + 1) >> 1) * dest->u_stride;
+  dest->v += ((rows + 1) >> 1) * dest->v_stride;
+  dest->h -= rows;
+}
+
+static void JpegI422ToI420(void* opaque,
+                           const uint8_t* const* data,
+                           const int* strides,
+                           int rows) {
+  I420Buffers* dest = (I420Buffers*)(opaque);
+  I422ToI420(data[0], strides[0], data[1], strides[1], data[2], strides[2],
+             dest->y, dest->y_stride, dest->u, dest->u_stride, dest->v,
+             dest->v_stride, dest->w, rows);
+  dest->y += rows * dest->y_stride;
+  dest->u += ((rows + 1) >> 1) * dest->u_stride;
+  dest->v += ((rows + 1) >> 1) * dest->v_stride;
+  dest->h -= rows;
+}
+
+static void JpegI444ToI420(void* opaque,
+                           const uint8_t* const* data,
+                           const int* strides,
+                           int rows) {
+  I420Buffers* dest = (I420Buffers*)(opaque);
+  I444ToI420(data[0], strides[0], data[1], strides[1], data[2], strides[2],
+             dest->y, dest->y_stride, dest->u, dest->u_stride, dest->v,
+             dest->v_stride, dest->w, rows);
+  dest->y += rows * dest->y_stride;
+  dest->u += ((rows + 1) >> 1) * dest->u_stride;
+  dest->v += ((rows + 1) >> 1) * dest->v_stride;
+  dest->h -= rows;
+}
+
+static void JpegI400ToI420(void* opaque,
+                           const uint8_t* const* data,
+                           const int* strides,
+                           int rows) {
+  I420Buffers* dest = (I420Buffers*)(opaque);
+  I400ToI420(data[0], strides[0], dest->y, dest->y_stride, dest->u,
+             dest->u_stride, dest->v, dest->v_stride, dest->w, rows);
+  dest->y += rows * dest->y_stride;
+  dest->u += ((rows + 1) >> 1) * dest->u_stride;
+  dest->v += ((rows + 1) >> 1) * dest->v_stride;
+  dest->h -= rows;
+}
+
+// Query size of MJPG in pixels.
+LIBYUV_API
+int MJPGSize(const uint8_t* src_mjpg,
+             size_t src_size_mjpg,
+             int* width,
+             int* height) {
+  MJpegDecoder mjpeg_decoder;
+  LIBYUV_BOOL ret = mjpeg_decoder.LoadFrame(src_mjpg, src_size_mjpg);
+  if (ret) {
+    *width = mjpeg_decoder.GetWidth();
+    *height = mjpeg_decoder.GetHeight();
+  }
+  mjpeg_decoder.UnloadFrame();
+  return ret ? 0 : -1;  // -1 for runtime failure.
+}
+
+// MJPG (Motion JPeg) to I420
+// TODO(fbarchard): review src_width and src_height requirement. dst_width and
+// dst_height may be enough.
+LIBYUV_API
+int MJPGToI420(const uint8_t* src_mjpg,
+               size_t src_size_mjpg,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_u,
+               int dst_stride_u,
+               uint8_t* dst_v,
+               int dst_stride_v,
+               int src_width,
+               int src_height,
+               int dst_width,
+               int dst_height) {
+  if (src_size_mjpg == kUnknownDataSize) {
+    // ERROR: MJPEG frame size unknown
+    return -1;
+  }
+
+  // TODO(fbarchard): Port MJpeg to C.
+  MJpegDecoder mjpeg_decoder;
+  LIBYUV_BOOL ret = mjpeg_decoder.LoadFrame(src_mjpg, src_size_mjpg);
+  if (ret && (mjpeg_decoder.GetWidth() != src_width ||
+              mjpeg_decoder.GetHeight() != src_height)) {
+    // ERROR: MJPEG frame has unexpected dimensions
+    mjpeg_decoder.UnloadFrame();
+    return 1;  // runtime failure
+  }
+  if (ret) {
+    I420Buffers bufs = {dst_y, dst_stride_y, dst_u,     dst_stride_u,
+                        dst_v, dst_stride_v, dst_width, dst_height};
+    // YUV420
+    if (mjpeg_decoder.GetColorSpace() == MJpegDecoder::kColorSpaceYCbCr &&
+        mjpeg_decoder.GetNumComponents() == 3 &&
+        mjpeg_decoder.GetVertSampFactor(0) == 2 &&
+        mjpeg_decoder.GetHorizSampFactor(0) == 2 &&
+        mjpeg_decoder.GetVertSampFactor(1) == 1 &&
+        mjpeg_decoder.GetHorizSampFactor(1) == 1 &&
+        mjpeg_decoder.GetVertSampFactor(2) == 1 &&
+        mjpeg_decoder.GetHorizSampFactor(2) == 1) {
+      ret = mjpeg_decoder.DecodeToCallback(&JpegCopyI420, &bufs, dst_width,
+                                           dst_height);
+      // YUV422
+    } else if (mjpeg_decoder.GetColorSpace() ==
+                   MJpegDecoder::kColorSpaceYCbCr &&
+               mjpeg_decoder.GetNumComponents() == 3 &&
+               mjpeg_decoder.GetVertSampFactor(0) == 1 &&
+               mjpeg_decoder.GetHorizSampFactor(0) == 2 &&
+               mjpeg_decoder.GetVertSampFactor(1) == 1 &&
+               mjpeg_decoder.GetHorizSampFactor(1) == 1 &&
+               mjpeg_decoder.GetVertSampFactor(2) == 1 &&
+               mjpeg_decoder.GetHorizSampFactor(2) == 1) {
+      ret = mjpeg_decoder.DecodeToCallback(&JpegI422ToI420, &bufs, dst_width,
+                                           dst_height);
+      // YUV444
+    } else if (mjpeg_decoder.GetColorSpace() ==
+                   MJpegDecoder::kColorSpaceYCbCr &&
+               mjpeg_decoder.GetNumComponents() == 3 &&
+               mjpeg_decoder.GetVertSampFactor(0) == 1 &&
+               mjpeg_decoder.GetHorizSampFactor(0) == 1 &&
+               mjpeg_decoder.GetVertSampFactor(1) == 1 &&
+               mjpeg_decoder.GetHorizSampFactor(1) == 1 &&
+               mjpeg_decoder.GetVertSampFactor(2) == 1 &&
+               mjpeg_decoder.GetHorizSampFactor(2) == 1) {
+      ret = mjpeg_decoder.DecodeToCallback(&JpegI444ToI420, &bufs, dst_width,
+                                           dst_height);
+      // YUV400
+    } else if (mjpeg_decoder.GetColorSpace() ==
+                   MJpegDecoder::kColorSpaceGrayscale &&
+               mjpeg_decoder.GetNumComponents() == 1 &&
+               mjpeg_decoder.GetVertSampFactor(0) == 1 &&
+               mjpeg_decoder.GetHorizSampFactor(0) == 1) {
+      ret = mjpeg_decoder.DecodeToCallback(&JpegI400ToI420, &bufs, dst_width,
+                                           dst_height);
+    } else {
+      // TODO(fbarchard): Implement conversion for any other
+      // colorspace/subsample factors that occur in practice. ERROR: Unable to
+      // convert MJPEG frame because format is not supported
+      mjpeg_decoder.UnloadFrame();
+      return 1;
+    }
+  }
+  return ret ? 0 : 1;
+}
+
+struct NV21Buffers {
+  uint8_t* y;
+  int y_stride;
+  uint8_t* vu;
+  int vu_stride;
+  int w;
+  int h;
+};
+
+static void JpegI420ToNV21(void* opaque,
+                           const uint8_t* const* data,
+                           const int* strides,
+                           int rows) {
+  NV21Buffers* dest = (NV21Buffers*)(opaque);
+  I420ToNV21(data[0], strides[0], data[1], strides[1], data[2], strides[2],
+             dest->y, dest->y_stride, dest->vu, dest->vu_stride, dest->w, rows);
+  dest->y += rows * dest->y_stride;
+  dest->vu += ((rows + 1) >> 1) * dest->vu_stride;
+  dest->h -= rows;
+}
+
+static void JpegI422ToNV21(void* opaque,
+                           const uint8_t* const* data,
+                           const int* strides,
+                           int rows) {
+  NV21Buffers* dest = (NV21Buffers*)(opaque);
+  I422ToNV21(data[0], strides[0], data[1], strides[1], data[2], strides[2],
+             dest->y, dest->y_stride, dest->vu, dest->vu_stride, dest->w, rows);
+  dest->y += rows * dest->y_stride;
+  dest->vu += ((rows + 1) >> 1) * dest->vu_stride;
+  dest->h -= rows;
+}
+
+static void JpegI444ToNV21(void* opaque,
+                           const uint8_t* const* data,
+                           const int* strides,
+                           int rows) {
+  NV21Buffers* dest = (NV21Buffers*)(opaque);
+  I444ToNV21(data[0], strides[0], data[1], strides[1], data[2], strides[2],
+             dest->y, dest->y_stride, dest->vu, dest->vu_stride, dest->w, rows);
+  dest->y += rows * dest->y_stride;
+  dest->vu += ((rows + 1) >> 1) * dest->vu_stride;
+  dest->h -= rows;
+}
+
+static void JpegI400ToNV21(void* opaque,
+                           const uint8_t* const* data,
+                           const int* strides,
+                           int rows) {
+  NV21Buffers* dest = (NV21Buffers*)(opaque);
+  I400ToNV21(data[0], strides[0], dest->y, dest->y_stride, dest->vu,
+             dest->vu_stride, dest->w, rows);
+  dest->y += rows * dest->y_stride;
+  dest->vu += ((rows + 1) >> 1) * dest->vu_stride;
+  dest->h -= rows;
+}
+
+// MJPG (Motion JPeg) to NV21
+LIBYUV_API
+int MJPGToNV21(const uint8_t* src_mjpg,
+               size_t src_size_mjpg,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_vu,
+               int dst_stride_vu,
+               int src_width,
+               int src_height,
+               int dst_width,
+               int dst_height) {
+  if (src_size_mjpg == kUnknownDataSize) {
+    // ERROR: MJPEG frame size unknown
+    return -1;
+  }
+
+  // TODO(fbarchard): Port MJpeg to C.
+  MJpegDecoder mjpeg_decoder;
+  LIBYUV_BOOL ret = mjpeg_decoder.LoadFrame(src_mjpg, src_size_mjpg);
+  if (ret && (mjpeg_decoder.GetWidth() != src_width ||
+              mjpeg_decoder.GetHeight() != src_height)) {
+    // ERROR: MJPEG frame has unexpected dimensions
+    mjpeg_decoder.UnloadFrame();
+    return 1;  // runtime failure
+  }
+  if (ret) {
+    NV21Buffers bufs = {dst_y,         dst_stride_y, dst_vu,
+                        dst_stride_vu, dst_width,    dst_height};
+    // YUV420
+    if (mjpeg_decoder.GetColorSpace() == MJpegDecoder::kColorSpaceYCbCr &&
+        mjpeg_decoder.GetNumComponents() == 3 &&
+        mjpeg_decoder.GetVertSampFactor(0) == 2 &&
+        mjpeg_decoder.GetHorizSampFactor(0) == 2 &&
+        mjpeg_decoder.GetVertSampFactor(1) == 1 &&
+        mjpeg_decoder.GetHorizSampFactor(1) == 1 &&
+        mjpeg_decoder.GetVertSampFactor(2) == 1 &&
+        mjpeg_decoder.GetHorizSampFactor(2) == 1) {
+      ret = mjpeg_decoder.DecodeToCallback(&JpegI420ToNV21, &bufs, dst_width,
+                                           dst_height);
+      // YUV422
+    } else if (mjpeg_decoder.GetColorSpace() ==
+                   MJpegDecoder::kColorSpaceYCbCr &&
+               mjpeg_decoder.GetNumComponents() == 3 &&
+               mjpeg_decoder.GetVertSampFactor(0) == 1 &&
+               mjpeg_decoder.GetHorizSampFactor(0) == 2 &&
+               mjpeg_decoder.GetVertSampFactor(1) == 1 &&
+               mjpeg_decoder.GetHorizSampFactor(1) == 1 &&
+               mjpeg_decoder.GetVertSampFactor(2) == 1 &&
+               mjpeg_decoder.GetHorizSampFactor(2) == 1) {
+      ret = mjpeg_decoder.DecodeToCallback(&JpegI422ToNV21, &bufs, dst_width,
+                                           dst_height);
+      // YUV444
+    } else if (mjpeg_decoder.GetColorSpace() ==
+                   MJpegDecoder::kColorSpaceYCbCr &&
+               mjpeg_decoder.GetNumComponents() == 3 &&
+               mjpeg_decoder.GetVertSampFactor(0) == 1 &&
+               mjpeg_decoder.GetHorizSampFactor(0) == 1 &&
+               mjpeg_decoder.GetVertSampFactor(1) == 1 &&
+               mjpeg_decoder.GetHorizSampFactor(1) == 1 &&
+               mjpeg_decoder.GetVertSampFactor(2) == 1 &&
+               mjpeg_decoder.GetHorizSampFactor(2) == 1) {
+      ret = mjpeg_decoder.DecodeToCallback(&JpegI444ToNV21, &bufs, dst_width,
+                                           dst_height);
+      // YUV400
+    } else if (mjpeg_decoder.GetColorSpace() ==
+                   MJpegDecoder::kColorSpaceGrayscale &&
+               mjpeg_decoder.GetNumComponents() == 1 &&
+               mjpeg_decoder.GetVertSampFactor(0) == 1 &&
+               mjpeg_decoder.GetHorizSampFactor(0) == 1) {
+      ret = mjpeg_decoder.DecodeToCallback(&JpegI400ToNV21, &bufs, dst_width,
+                                           dst_height);
+    } else {
+      // Unknown colorspace.
+      mjpeg_decoder.UnloadFrame();
+      return 1;
+    }
+  }
+  return ret ? 0 : 1;
+}
+
+static void JpegI420ToNV12(void* opaque,
+                           const uint8_t* const* data,
+                           const int* strides,
+                           int rows) {
+  NV21Buffers* dest = (NV21Buffers*)(opaque);
+  // Use NV21 with VU swapped.
+  I420ToNV21(data[0], strides[0], data[2], strides[2], data[1], strides[1],
+             dest->y, dest->y_stride, dest->vu, dest->vu_stride, dest->w, rows);
+  dest->y += rows * dest->y_stride;
+  dest->vu += ((rows + 1) >> 1) * dest->vu_stride;
+  dest->h -= rows;
+}
+
+static void JpegI422ToNV12(void* opaque,
+                           const uint8_t* const* data,
+                           const int* strides,
+                           int rows) {
+  NV21Buffers* dest = (NV21Buffers*)(opaque);
+  // Use NV21 with VU swapped.
+  I422ToNV21(data[0], strides[0], data[2], strides[2], data[1], strides[1],
+             dest->y, dest->y_stride, dest->vu, dest->vu_stride, dest->w, rows);
+  dest->y += rows * dest->y_stride;
+  dest->vu += ((rows + 1) >> 1) * dest->vu_stride;
+  dest->h -= rows;
+}
+
+static void JpegI444ToNV12(void* opaque,
+                           const uint8_t* const* data,
+                           const int* strides,
+                           int rows) {
+  NV21Buffers* dest = (NV21Buffers*)(opaque);
+  // Use NV21 with VU swapped.
+  I444ToNV21(data[0], strides[0], data[2], strides[2], data[1], strides[1],
+             dest->y, dest->y_stride, dest->vu, dest->vu_stride, dest->w, rows);
+  dest->y += rows * dest->y_stride;
+  dest->vu += ((rows + 1) >> 1) * dest->vu_stride;
+  dest->h -= rows;
+}
+
+static void JpegI400ToNV12(void* opaque,
+                           const uint8_t* const* data,
+                           const int* strides,
+                           int rows) {
+  NV21Buffers* dest = (NV21Buffers*)(opaque);
+  // Use NV21 since there is no UV plane.
+  I400ToNV21(data[0], strides[0], dest->y, dest->y_stride, dest->vu,
+             dest->vu_stride, dest->w, rows);
+  dest->y += rows * dest->y_stride;
+  dest->vu += ((rows + 1) >> 1) * dest->vu_stride;
+  dest->h -= rows;
+}
+
+// MJPG (Motion JPEG) to NV12.
+LIBYUV_API
+int MJPGToNV12(const uint8_t* sample,
+               size_t sample_size,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_uv,
+               int dst_stride_uv,
+               int src_width,
+               int src_height,
+               int dst_width,
+               int dst_height) {
+  if (sample_size == kUnknownDataSize) {
+    // ERROR: MJPEG frame size unknown
+    return -1;
+  }
+
+  // TODO(fbarchard): Port MJpeg to C.
+  MJpegDecoder mjpeg_decoder;
+  LIBYUV_BOOL ret = mjpeg_decoder.LoadFrame(sample, sample_size);
+  if (ret && (mjpeg_decoder.GetWidth() != src_width ||
+              mjpeg_decoder.GetHeight() != src_height)) {
+    // ERROR: MJPEG frame has unexpected dimensions
+    mjpeg_decoder.UnloadFrame();
+    return 1;  // runtime failure
+  }
+  if (ret) {
+    // Use NV21Buffers but with UV instead of VU.
+    NV21Buffers bufs = {dst_y,         dst_stride_y, dst_uv,
+                        dst_stride_uv, dst_width,    dst_height};
+    // YUV420
+    if (mjpeg_decoder.GetColorSpace() == MJpegDecoder::kColorSpaceYCbCr &&
+        mjpeg_decoder.GetNumComponents() == 3 &&
+        mjpeg_decoder.GetVertSampFactor(0) == 2 &&
+        mjpeg_decoder.GetHorizSampFactor(0) == 2 &&
+        mjpeg_decoder.GetVertSampFactor(1) == 1 &&
+        mjpeg_decoder.GetHorizSampFactor(1) == 1 &&
+        mjpeg_decoder.GetVertSampFactor(2) == 1 &&
+        mjpeg_decoder.GetHorizSampFactor(2) == 1) {
+      ret = mjpeg_decoder.DecodeToCallback(&JpegI420ToNV12, &bufs, dst_width,
+                                           dst_height);
+      // YUV422
+    } else if (mjpeg_decoder.GetColorSpace() ==
+                   MJpegDecoder::kColorSpaceYCbCr &&
+               mjpeg_decoder.GetNumComponents() == 3 &&
+               mjpeg_decoder.GetVertSampFactor(0) == 1 &&
+               mjpeg_decoder.GetHorizSampFactor(0) == 2 &&
+               mjpeg_decoder.GetVertSampFactor(1) == 1 &&
+               mjpeg_decoder.GetHorizSampFactor(1) == 1 &&
+               mjpeg_decoder.GetVertSampFactor(2) == 1 &&
+               mjpeg_decoder.GetHorizSampFactor(2) == 1) {
+      ret = mjpeg_decoder.DecodeToCallback(&JpegI422ToNV12, &bufs, dst_width,
+                                           dst_height);
+      // YUV444
+    } else if (mjpeg_decoder.GetColorSpace() ==
+                   MJpegDecoder::kColorSpaceYCbCr &&
+               mjpeg_decoder.GetNumComponents() == 3 &&
+               mjpeg_decoder.GetVertSampFactor(0) == 1 &&
+               mjpeg_decoder.GetHorizSampFactor(0) == 1 &&
+               mjpeg_decoder.GetVertSampFactor(1) == 1 &&
+               mjpeg_decoder.GetHorizSampFactor(1) == 1 &&
+               mjpeg_decoder.GetVertSampFactor(2) == 1 &&
+               mjpeg_decoder.GetHorizSampFactor(2) == 1) {
+      ret = mjpeg_decoder.DecodeToCallback(&JpegI444ToNV12, &bufs, dst_width,
+                                           dst_height);
+      // YUV400
+    } else if (mjpeg_decoder.GetColorSpace() ==
+                   MJpegDecoder::kColorSpaceGrayscale &&
+               mjpeg_decoder.GetNumComponents() == 1 &&
+               mjpeg_decoder.GetVertSampFactor(0) == 1 &&
+               mjpeg_decoder.GetHorizSampFactor(0) == 1) {
+      ret = mjpeg_decoder.DecodeToCallback(&JpegI400ToNV12, &bufs, dst_width,
+                                           dst_height);
+    } else {
+      // Unknown colorspace.
+      mjpeg_decoder.UnloadFrame();
+      return 1;
+    }
+  }
+  return ret ? 0 : 1;
+}
+
+struct ARGBBuffers {
+  uint8_t* argb;
+  int argb_stride;
+  int w;
+  int h;
+};
+
+static void JpegI420ToARGB(void* opaque,
+                           const uint8_t* const* data,
+                           const int* strides,
+                           int rows) {
+  ARGBBuffers* dest = (ARGBBuffers*)(opaque);
+  I420ToARGB(data[0], strides[0], data[1], strides[1], data[2], strides[2],
+             dest->argb, dest->argb_stride, dest->w, rows);
+  dest->argb += rows * dest->argb_stride;
+  dest->h -= rows;
+}
+
+static void JpegI422ToARGB(void* opaque,
+                           const uint8_t* const* data,
+                           const int* strides,
+                           int rows) {
+  ARGBBuffers* dest = (ARGBBuffers*)(opaque);
+  I422ToARGB(data[0], strides[0], data[1], strides[1], data[2], strides[2],
+             dest->argb, dest->argb_stride, dest->w, rows);
+  dest->argb += rows * dest->argb_stride;
+  dest->h -= rows;
+}
+
+static void JpegI444ToARGB(void* opaque,
+                           const uint8_t* const* data,
+                           const int* strides,
+                           int rows) {
+  ARGBBuffers* dest = (ARGBBuffers*)(opaque);
+  I444ToARGB(data[0], strides[0], data[1], strides[1], data[2], strides[2],
+             dest->argb, dest->argb_stride, dest->w, rows);
+  dest->argb += rows * dest->argb_stride;
+  dest->h -= rows;
+}
+
+static void JpegI400ToARGB(void* opaque,
+                           const uint8_t* const* data,
+                           const int* strides,
+                           int rows) {
+  ARGBBuffers* dest = (ARGBBuffers*)(opaque);
+  I400ToARGB(data[0], strides[0], dest->argb, dest->argb_stride, dest->w, rows);
+  dest->argb += rows * dest->argb_stride;
+  dest->h -= rows;
+}
+
+// MJPG (Motion JPeg) to ARGB
+// TODO(fbarchard): review src_width and src_height requirement. dst_width and
+// dst_height may be enough.
+LIBYUV_API
+int MJPGToARGB(const uint8_t* src_mjpg,
+               size_t src_size_mjpg,
+               uint8_t* dst_argb,
+               int dst_stride_argb,
+               int src_width,
+               int src_height,
+               int dst_width,
+               int dst_height) {
+  if (src_size_mjpg == kUnknownDataSize) {
+    // ERROR: MJPEG frame size unknown
+    return -1;
+  }
+
+  // TODO(fbarchard): Port MJpeg to C.
+  MJpegDecoder mjpeg_decoder;
+  LIBYUV_BOOL ret = mjpeg_decoder.LoadFrame(src_mjpg, src_size_mjpg);
+  if (ret && (mjpeg_decoder.GetWidth() != src_width ||
+              mjpeg_decoder.GetHeight() != src_height)) {
+    // ERROR: MJPEG frame has unexpected dimensions
+    mjpeg_decoder.UnloadFrame();
+    return 1;  // runtime failure
+  }
+  if (ret) {
+    ARGBBuffers bufs = {dst_argb, dst_stride_argb, dst_width, dst_height};
+    // YUV420
+    if (mjpeg_decoder.GetColorSpace() == MJpegDecoder::kColorSpaceYCbCr &&
+        mjpeg_decoder.GetNumComponents() == 3 &&
+        mjpeg_decoder.GetVertSampFactor(0) == 2 &&
+        mjpeg_decoder.GetHorizSampFactor(0) == 2 &&
+        mjpeg_decoder.GetVertSampFactor(1) == 1 &&
+        mjpeg_decoder.GetHorizSampFactor(1) == 1 &&
+        mjpeg_decoder.GetVertSampFactor(2) == 1 &&
+        mjpeg_decoder.GetHorizSampFactor(2) == 1) {
+      ret = mjpeg_decoder.DecodeToCallback(&JpegI420ToARGB, &bufs, dst_width,
+                                           dst_height);
+      // YUV422
+    } else if (mjpeg_decoder.GetColorSpace() ==
+                   MJpegDecoder::kColorSpaceYCbCr &&
+               mjpeg_decoder.GetNumComponents() == 3 &&
+               mjpeg_decoder.GetVertSampFactor(0) == 1 &&
+               mjpeg_decoder.GetHorizSampFactor(0) == 2 &&
+               mjpeg_decoder.GetVertSampFactor(1) == 1 &&
+               mjpeg_decoder.GetHorizSampFactor(1) == 1 &&
+               mjpeg_decoder.GetVertSampFactor(2) == 1 &&
+               mjpeg_decoder.GetHorizSampFactor(2) == 1) {
+      ret = mjpeg_decoder.DecodeToCallback(&JpegI422ToARGB, &bufs, dst_width,
+                                           dst_height);
+      // YUV444
+    } else if (mjpeg_decoder.GetColorSpace() ==
+                   MJpegDecoder::kColorSpaceYCbCr &&
+               mjpeg_decoder.GetNumComponents() == 3 &&
+               mjpeg_decoder.GetVertSampFactor(0) == 1 &&
+               mjpeg_decoder.GetHorizSampFactor(0) == 1 &&
+               mjpeg_decoder.GetVertSampFactor(1) == 1 &&
+               mjpeg_decoder.GetHorizSampFactor(1) == 1 &&
+               mjpeg_decoder.GetVertSampFactor(2) == 1 &&
+               mjpeg_decoder.GetHorizSampFactor(2) == 1) {
+      ret = mjpeg_decoder.DecodeToCallback(&JpegI444ToARGB, &bufs, dst_width,
+                                           dst_height);
+      // YUV400
+    } else if (mjpeg_decoder.GetColorSpace() ==
+                   MJpegDecoder::kColorSpaceGrayscale &&
+               mjpeg_decoder.GetNumComponents() == 1 &&
+               mjpeg_decoder.GetVertSampFactor(0) == 1 &&
+               mjpeg_decoder.GetHorizSampFactor(0) == 1) {
+      ret = mjpeg_decoder.DecodeToCallback(&JpegI400ToARGB, &bufs, dst_width,
+                                           dst_height);
+    } else {
+      // TODO(fbarchard): Implement conversion for any other
+      // colorspace/subsample factors that occur in practice. ERROR: Unable to
+      // convert MJPEG frame because format is not supported
+      mjpeg_decoder.UnloadFrame();
+      return 1;
+    }
+  }
+  return ret ? 0 : 1;
+}
+
+#endif  // HAVE_JPEG
+
+#ifdef __cplusplus
+}  // extern "C"
+}  // namespace libyuv
+#endif
diff --git a/3rdparty/libyuv/src/source/convert_to_argb.cc b/3rdparty/libyuv/src/source/convert_to_argb.cc
new file mode 100644
index 00000000..84df16c8
--- /dev/null
+++ b/3rdparty/libyuv/src/source/convert_to_argb.cc
@@ -0,0 +1,382 @@
+/*
+ *  Copyright 2011 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include "libyuv/convert_argb.h"
+
+#include "libyuv/cpu_id.h"
+#ifdef HAVE_JPEG
+#include "libyuv/mjpeg_decoder.h"
+#endif
+#include "libyuv/rotate_argb.h"
+#include "libyuv/row.h"
+#include "libyuv/video_common.h"
+
+#ifdef __cplusplus
+namespace libyuv {
+extern "C" {
+#endif
+
+// Convert camera sample to ARGB with cropping, rotation and vertical flip.
+// src_width is used for source stride computation
+// src_height is used to compute location of planes, and indicate inversion
+// sample_size is measured in bytes and is the size of the frame.
+//   With MJPEG it is the compressed size of the frame.
+
+// TODO(fbarchard): Add the following:
+// H010ToARGB
+// I010ToARGB
+
+LIBYUV_API
+int ConvertToARGB(const uint8_t* sample,
+                  size_t sample_size,
+                  uint8_t* dst_argb,
+                  int dst_stride_argb,
+                  int crop_x,
+                  int crop_y,
+                  int src_width,
+                  int src_height,
+                  int crop_width,
+                  int crop_height,
+                  enum RotationMode rotation,
+                  uint32_t fourcc) {
+  uint32_t format = CanonicalFourCC(fourcc);
+  int aligned_src_width = (src_width + 1) & ~1;
+  const uint8_t* src;
+  const uint8_t* src_uv;
+  int abs_src_height = (src_height < 0) ? -src_height : src_height;
+  int inv_crop_height = (crop_height < 0) ? -crop_height : crop_height;
+  int r = 0;
+
+  // One pass rotation is available for some formats. For the rest, convert
+  // to ARGB (with optional vertical flipping) into a temporary ARGB buffer,
+  // and then rotate the ARGB to the final destination buffer.
+  // For in-place conversion, if destination dst_argb is same as source sample,
+  // also enable temporary buffer.
+  LIBYUV_BOOL need_buf =
+      (rotation && format != FOURCC_ARGB) || dst_argb == sample;
+  uint8_t* dest_argb = dst_argb;
+  int dest_dst_stride_argb = dst_stride_argb;
+  uint8_t* rotate_buffer = NULL;
+  int abs_crop_height = (crop_height < 0) ? -crop_height : crop_height;
+
+  if (dst_argb == NULL || sample == NULL || src_width <= 0 || crop_width <= 0 ||
+      src_height == 0 || crop_height == 0) {
+    return -1;
+  }
+  if (src_height < 0) {
+    inv_crop_height = -inv_crop_height;
+  }
+
+  if (need_buf) {
+    int argb_size = crop_width * 4 * abs_crop_height;
+    rotate_buffer = (uint8_t*)malloc(argb_size); /* NOLINT */
+    if (!rotate_buffer) {
+      return 1;  // Out of memory runtime error.
+    }
+    dst_argb = rotate_buffer;
+    dst_stride_argb = crop_width * 4;
+  }
+
+  switch (format) {
+    // Single plane formats
+    case FOURCC_YUY2:
+      src = sample + (aligned_src_width * crop_y + crop_x) * 2;
+      r = YUY2ToARGB(src, aligned_src_width * 2, dst_argb, dst_stride_argb,
+                     crop_width, inv_crop_height);
+      break;
+    case FOURCC_UYVY:
+      src = sample + (aligned_src_width * crop_y + crop_x) * 2;
+      r = UYVYToARGB(src, aligned_src_width * 2, dst_argb, dst_stride_argb,
+                     crop_width, inv_crop_height);
+      break;
+    case FOURCC_24BG:
+      src = sample + (src_width * crop_y + crop_x) * 3;
+      r = RGB24ToARGB(src, src_width * 3, dst_argb, dst_stride_argb, crop_width,
+                      inv_crop_height);
+      break;
+    case FOURCC_RAW:
+      src = sample + (src_width * crop_y + crop_x) * 3;
+      r = RAWToARGB(src, src_width * 3, dst_argb, dst_stride_argb, crop_width,
+                    inv_crop_height);
+      break;
+    case FOURCC_ARGB:
+      if (!need_buf && !rotation) {
+        src = sample + (src_width * crop_y + crop_x) * 4;
+        r = ARGBToARGB(src, src_width * 4, dst_argb, dst_stride_argb,
+                       crop_width, inv_crop_height);
+      }
+      break;
+    case FOURCC_BGRA:
+      src = sample + (src_width * crop_y + crop_x) * 4;
+      r = BGRAToARGB(src, src_width * 4, dst_argb, dst_stride_argb, crop_width,
+                     inv_crop_height);
+      break;
+    case FOURCC_ABGR:
+      src = sample + (src_width * crop_y + crop_x) * 4;
+      r = ABGRToARGB(src, src_width * 4, dst_argb, dst_stride_argb, crop_width,
+                     inv_crop_height);
+      break;
+    case FOURCC_RGBA:
+      src = sample + (src_width * crop_y + crop_x) * 4;
+      r = RGBAToARGB(src, src_width * 4, dst_argb, dst_stride_argb, crop_width,
+                     inv_crop_height);
+      break;
+    case FOURCC_AR30:
+      src = sample + (src_width * crop_y + crop_x) * 4;
+      r = AR30ToARGB(src, src_width * 4, dst_argb, dst_stride_argb, crop_width,
+                     inv_crop_height);
+      break;
+    case FOURCC_AB30:
+      src = sample + (src_width * crop_y + crop_x) * 4;
+      r = AB30ToARGB(src, src_width * 4, dst_argb, dst_stride_argb, crop_width,
+                     inv_crop_height);
+      break;
+    case FOURCC_RGBP:
+      src = sample + (src_width * crop_y + crop_x) * 2;
+      r = RGB565ToARGB(src, src_width * 2, dst_argb, dst_stride_argb,
+                       crop_width, inv_crop_height);
+      break;
+    case FOURCC_RGBO:
+      src = sample + (src_width * crop_y + crop_x) * 2;
+      r = ARGB1555ToARGB(src, src_width * 2, dst_argb, dst_stride_argb,
+                         crop_width, inv_crop_height);
+      break;
+    case FOURCC_R444:
+      src = sample + (src_width * crop_y + crop_x) * 2;
+      r = ARGB4444ToARGB(src, src_width * 2, dst_argb, dst_stride_argb,
+                         crop_width, inv_crop_height);
+      break;
+    case FOURCC_I400:
+      src = sample + src_width * crop_y + crop_x;
+      r = I400ToARGB(src, src_width, dst_argb, dst_stride_argb, crop_width,
+                     inv_crop_height);
+      break;
+    case FOURCC_J400:
+      src = sample + src_width * crop_y + crop_x;
+      r = J400ToARGB(src, src_width, dst_argb, dst_stride_argb, crop_width,
+                     inv_crop_height);
+      break;
+
+    // Biplanar formats
+    case FOURCC_NV12:
+      src = sample + (src_width * crop_y + crop_x);
+      src_uv =
+          sample + aligned_src_width * (abs_src_height + crop_y / 2) + crop_x;
+      r = NV12ToARGB(src, src_width, src_uv, aligned_src_width, dst_argb,
+                     dst_stride_argb, crop_width, inv_crop_height);
+      break;
+    case FOURCC_NV21:
+      src = sample + (src_width * crop_y + crop_x);
+      src_uv =
+          sample + aligned_src_width * (abs_src_height + crop_y / 2) + crop_x;
+      // Call NV12 but with u and v parameters swapped.
+      r = NV21ToARGB(src, src_width, src_uv, aligned_src_width, dst_argb,
+                     dst_stride_argb, crop_width, inv_crop_height);
+      break;
+    // Triplanar formats
+    case FOURCC_I420:
+    case FOURCC_YV12: {
+      const uint8_t* src_y = sample + (src_width * crop_y + crop_x);
+      const uint8_t* src_u;
+      const uint8_t* src_v;
+      int halfwidth = (src_width + 1) / 2;
+      int halfheight = (abs_src_height + 1) / 2;
+      if (format == FOURCC_YV12) {
+        src_v = sample + src_width * abs_src_height +
+                (halfwidth * crop_y + crop_x) / 2;
+        src_u = sample + src_width * abs_src_height +
+                halfwidth * (halfheight + crop_y / 2) + crop_x / 2;
+      } else {
+        src_u = sample + src_width * abs_src_height +
+                (halfwidth * crop_y + crop_x) / 2;
+        src_v = sample + src_width * abs_src_height +
+                halfwidth * (halfheight + crop_y / 2) + crop_x / 2;
+      }
+      r = I420ToARGB(src_y, src_width, src_u, halfwidth, src_v, halfwidth,
+                     dst_argb, dst_stride_argb, crop_width, inv_crop_height);
+      break;
+    }
+
+    case FOURCC_J420: {
+      int halfwidth = (src_width + 1) / 2;
+      int halfheight = (abs_src_height + 1) / 2;
+      const uint8_t* src_y = sample + (src_width * crop_y + crop_x);
+      const uint8_t* src_u = sample + src_width * abs_src_height +
+                             (halfwidth * crop_y + crop_x) / 2;
+      const uint8_t* src_v = sample + src_width * abs_src_height +
+                             halfwidth * (halfheight + crop_y / 2) + crop_x / 2;
+      r = J420ToARGB(src_y, src_width, src_u, halfwidth, src_v, halfwidth,
+                     dst_argb, dst_stride_argb, crop_width, inv_crop_height);
+      break;
+    }
+
+    case FOURCC_H420: {
+      int halfwidth = (src_width + 1) / 2;
+      int halfheight = (abs_src_height + 1) / 2;
+      const uint8_t* src_y = sample + (src_width * crop_y + crop_x);
+      const uint8_t* src_u = sample + src_width * abs_src_height +
+                             (halfwidth * crop_y + crop_x) / 2;
+      const uint8_t* src_v = sample + src_width * abs_src_height +
+                             halfwidth * (halfheight + crop_y / 2) + crop_x / 2;
+      r = H420ToARGB(src_y, src_width, src_u, halfwidth, src_v, halfwidth,
+                     dst_argb, dst_stride_argb, crop_width, inv_crop_height);
+      break;
+    }
+
+    case FOURCC_U420: {
+      int halfwidth = (src_width + 1) / 2;
+      int halfheight = (abs_src_height + 1) / 2;
+      const uint8_t* src_y = sample + (src_width * crop_y + crop_x);
+      const uint8_t* src_u = sample + src_width * abs_src_height +
+                             (halfwidth * crop_y + crop_x) / 2;
+      const uint8_t* src_v = sample + src_width * abs_src_height +
+                             halfwidth * (halfheight + crop_y / 2) + crop_x / 2;
+      r = U420ToARGB(src_y, src_width, src_u, halfwidth, src_v, halfwidth,
+                     dst_argb, dst_stride_argb, crop_width, inv_crop_height);
+      break;
+    }
+
+    case FOURCC_I422:
+    case FOURCC_YV16: {
+      int halfwidth = (src_width + 1) / 2;
+      const uint8_t* src_y = sample + src_width * crop_y + crop_x;
+      const uint8_t* src_u;
+      const uint8_t* src_v;
+      if (format == FOURCC_YV16) {
+        src_v = sample + src_width * abs_src_height + halfwidth * crop_y +
+                crop_x / 2;
+        src_u = sample + src_width * abs_src_height +
+                halfwidth * (abs_src_height + crop_y) + crop_x / 2;
+      } else {
+        src_u = sample + src_width * abs_src_height + halfwidth * crop_y +
+                crop_x / 2;
+        src_v = sample + src_width * abs_src_height +
+                halfwidth * (abs_src_height + crop_y) + crop_x / 2;
+      }
+      r = I422ToARGB(src_y, src_width, src_u, halfwidth, src_v, halfwidth,
+                     dst_argb, dst_stride_argb, crop_width, inv_crop_height);
+      break;
+    }
+
+    case FOURCC_J422: {
+      int halfwidth = (src_width + 1) / 2;
+      const uint8_t* src_y = sample + src_width * crop_y + crop_x;
+      const uint8_t* src_u =
+          sample + src_width * abs_src_height + halfwidth * crop_y + crop_x / 2;
+      const uint8_t* src_v = sample + src_width * abs_src_height +
+                             halfwidth * (abs_src_height + crop_y) + crop_x / 2;
+      r = J422ToARGB(src_y, src_width, src_u, halfwidth, src_v, halfwidth,
+                     dst_argb, dst_stride_argb, crop_width, inv_crop_height);
+      break;
+    }
+
+    case FOURCC_H422: {
+      int halfwidth = (src_width + 1) / 2;
+      const uint8_t* src_y = sample + src_width * crop_y + crop_x;
+      const uint8_t* src_u =
+          sample + src_width * abs_src_height + halfwidth * crop_y + crop_x / 2;
+      const uint8_t* src_v = sample + src_width * abs_src_height +
+                             halfwidth * (abs_src_height + crop_y) + crop_x / 2;
+      r = H422ToARGB(src_y, src_width, src_u, halfwidth, src_v, halfwidth,
+                     dst_argb, dst_stride_argb, crop_width, inv_crop_height);
+      break;
+    }
+
+    case FOURCC_U422: {
+      int halfwidth = (src_width + 1) / 2;
+      const uint8_t* src_y = sample + src_width * crop_y + crop_x;
+      const uint8_t* src_u =
+          sample + src_width * abs_src_height + halfwidth * crop_y + crop_x / 2;
+      const uint8_t* src_v = sample + src_width * abs_src_height +
+                             halfwidth * (abs_src_height + crop_y) + crop_x / 2;
+      r = H422ToARGB(src_y, src_width, src_u, halfwidth, src_v, halfwidth,
+                     dst_argb, dst_stride_argb, crop_width, inv_crop_height);
+      break;
+    }
+
+    case FOURCC_I444:
+    case FOURCC_YV24: {
+      const uint8_t* src_y = sample + src_width * crop_y + crop_x;
+      const uint8_t* src_u;
+      const uint8_t* src_v;
+      if (format == FOURCC_YV24) {
+        src_v = sample + src_width * (abs_src_height + crop_y) + crop_x;
+        src_u = sample + src_width * (abs_src_height * 2 + crop_y) + crop_x;
+      } else {
+        src_u = sample + src_width * (abs_src_height + crop_y) + crop_x;
+        src_v = sample + src_width * (abs_src_height * 2 + crop_y) + crop_x;
+      }
+      r = I444ToARGB(src_y, src_width, src_u, src_width, src_v, src_width,
+                     dst_argb, dst_stride_argb, crop_width, inv_crop_height);
+      break;
+    }
+
+    case FOURCC_J444: {
+      const uint8_t* src_y = sample + src_width * crop_y + crop_x;
+      const uint8_t* src_u;
+      const uint8_t* src_v;
+      src_u = sample + src_width * (abs_src_height + crop_y) + crop_x;
+      src_v = sample + src_width * (abs_src_height * 2 + crop_y) + crop_x;
+      r = J444ToARGB(src_y, src_width, src_u, src_width, src_v, src_width,
+                     dst_argb, dst_stride_argb, crop_width, inv_crop_height);
+      break;
+    }
+
+    case FOURCC_H444: {
+      const uint8_t* src_y = sample + src_width * crop_y + crop_x;
+      const uint8_t* src_u;
+      const uint8_t* src_v;
+      src_u = sample + src_width * (abs_src_height + crop_y) + crop_x;
+      src_v = sample + src_width * (abs_src_height * 2 + crop_y) + crop_x;
+      r = H444ToARGB(src_y, src_width, src_u, src_width, src_v, src_width,
+                     dst_argb, dst_stride_argb, crop_width, inv_crop_height);
+      break;
+    }
+
+    case FOURCC_U444: {
+      const uint8_t* src_y = sample + src_width * crop_y + crop_x;
+      const uint8_t* src_u;
+      const uint8_t* src_v;
+      src_u = sample + src_width * (abs_src_height + crop_y) + crop_x;
+      src_v = sample + src_width * (abs_src_height * 2 + crop_y) + crop_x;
+      r = U444ToARGB(src_y, src_width, src_u, src_width, src_v, src_width,
+                     dst_argb, dst_stride_argb, crop_width, inv_crop_height);
+      break;
+    }
+
+#ifdef HAVE_JPEG
+    case FOURCC_MJPG:
+      r = MJPGToARGB(sample, sample_size, dst_argb, dst_stride_argb, src_width,
+                     abs_src_height, crop_width, inv_crop_height);
+      break;
+#endif
+    default:
+      r = -1;  // unknown fourcc - return failure code.
+  }
+
+  if (need_buf) {
+    if (!r) {
+      r = ARGBRotate(dst_argb, dst_stride_argb, dest_argb, dest_dst_stride_argb,
+                     crop_width, abs_crop_height, rotation);
+    }
+    free(rotate_buffer);
+  } else if (rotation) {
+    src = sample + (src_width * crop_y + crop_x) * 4;
+    r = ARGBRotate(src, src_width * 4, dst_argb, dst_stride_argb, crop_width,
+                   inv_crop_height, rotation);
+  }
+
+  return r;
+}
+
+#ifdef __cplusplus
+}  // extern "C"
+}  // namespace libyuv
+#endif
diff --git a/3rdparty/libyuv/src/source/convert_to_i420.cc b/3rdparty/libyuv/src/source/convert_to_i420.cc
new file mode 100644
index 00000000..5869ecd7
--- /dev/null
+++ b/3rdparty/libyuv/src/source/convert_to_i420.cc
@@ -0,0 +1,280 @@
+/*
+ *  Copyright 2011 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include <stdlib.h>
+
+#include "libyuv/convert.h"
+
+#include "libyuv/video_common.h"
+
+#ifdef __cplusplus
+namespace libyuv {
+extern "C" {
+#endif
+
+// Convert camera sample to I420 with cropping, rotation and vertical flip.
+// src_width is used for source stride computation
+// src_height is used to compute location of planes, and indicate inversion
+// sample_size is measured in bytes and is the size of the frame.
+//   With MJPEG it is the compressed size of the frame.
+LIBYUV_API
+int ConvertToI420(const uint8_t* sample,
+                  size_t sample_size,
+                  uint8_t* dst_y,
+                  int dst_stride_y,
+                  uint8_t* dst_u,
+                  int dst_stride_u,
+                  uint8_t* dst_v,
+                  int dst_stride_v,
+                  int crop_x,
+                  int crop_y,
+                  int src_width,
+                  int src_height,
+                  int crop_width,
+                  int crop_height,
+                  enum RotationMode rotation,
+                  uint32_t fourcc) {
+  uint32_t format = CanonicalFourCC(fourcc);
+  int aligned_src_width = (src_width + 1) & ~1;
+  const uint8_t* src;
+  const uint8_t* src_uv;
+  const int abs_src_height = (src_height < 0) ? -src_height : src_height;
+  // TODO(nisse): Why allow crop_height < 0?
+  const int abs_crop_height = (crop_height < 0) ? -crop_height : crop_height;
+  int r = 0;
+  LIBYUV_BOOL need_buf =
+      (rotation && format != FOURCC_I420 && format != FOURCC_NV12 &&
+       format != FOURCC_NV21 && format != FOURCC_YV12) ||
+      dst_y == sample;
+  uint8_t* tmp_y = dst_y;
+  uint8_t* tmp_u = dst_u;
+  uint8_t* tmp_v = dst_v;
+  int tmp_y_stride = dst_stride_y;
+  int tmp_u_stride = dst_stride_u;
+  int tmp_v_stride = dst_stride_v;
+  uint8_t* rotate_buffer = NULL;
+  const int inv_crop_height =
+      (src_height < 0) ? -abs_crop_height : abs_crop_height;
+
+  if (!dst_y || !dst_u || !dst_v || !sample || src_width <= 0 ||
+      crop_width <= 0 || src_height == 0 || crop_height == 0) {
+    return -1;
+  }
+
+  // One pass rotation is available for some formats. For the rest, convert
+  // to I420 (with optional vertical flipping) into a temporary I420 buffer,
+  // and then rotate the I420 to the final destination buffer.
+  // For in-place conversion, if destination dst_y is same as source sample,
+  // also enable temporary buffer.
+  if (need_buf) {
+    int y_size = crop_width * abs_crop_height;
+    int uv_size = ((crop_width + 1) / 2) * ((abs_crop_height + 1) / 2);
+    rotate_buffer = (uint8_t*)malloc(y_size + uv_size * 2); /* NOLINT */
+    if (!rotate_buffer) {
+      return 1;  // Out of memory runtime error.
+    }
+    dst_y = rotate_buffer;
+    dst_u = dst_y + y_size;
+    dst_v = dst_u + uv_size;
+    dst_stride_y = crop_width;
+    dst_stride_u = dst_stride_v = ((crop_width + 1) / 2);
+  }
+
+  switch (format) {
+    // Single plane formats
+    case FOURCC_YUY2: {  // TODO(fbarchard): Find better odd crop fix.
+      uint8_t* u = (crop_x & 1) ? dst_v : dst_u;
+      uint8_t* v = (crop_x & 1) ? dst_u : dst_v;
+      int stride_u = (crop_x & 1) ? dst_stride_v : dst_stride_u;
+      int stride_v = (crop_x & 1) ? dst_stride_u : dst_stride_v;
+      src = sample + (aligned_src_width * crop_y + crop_x) * 2;
+      r = YUY2ToI420(src, aligned_src_width * 2, dst_y, dst_stride_y, u,
+                     stride_u, v, stride_v, crop_width, inv_crop_height);
+      break;
+    }
+    case FOURCC_UYVY: {
+      uint8_t* u = (crop_x & 1) ? dst_v : dst_u;
+      uint8_t* v = (crop_x & 1) ? dst_u : dst_v;
+      int stride_u = (crop_x & 1) ? dst_stride_v : dst_stride_u;
+      int stride_v = (crop_x & 1) ? dst_stride_u : dst_stride_v;
+      src = sample + (aligned_src_width * crop_y + crop_x) * 2;
+      r = UYVYToI420(src, aligned_src_width * 2, dst_y, dst_stride_y, u,
+                     stride_u, v, stride_v, crop_width, inv_crop_height);
+      break;
+    }
+    case FOURCC_RGBP:
+      src = sample + (src_width * crop_y + crop_x) * 2;
+      r = RGB565ToI420(src, src_width * 2, dst_y, dst_stride_y, dst_u,
+                       dst_stride_u, dst_v, dst_stride_v, crop_width,
+                       inv_crop_height);
+      break;
+    case FOURCC_RGBO:
+      src = sample + (src_width * crop_y + crop_x) * 2;
+      r = ARGB1555ToI420(src, src_width * 2, dst_y, dst_stride_y, dst_u,
+                         dst_stride_u, dst_v, dst_stride_v, crop_width,
+                         inv_crop_height);
+      break;
+    case FOURCC_R444:
+      src = sample + (src_width * crop_y + crop_x) * 2;
+      r = ARGB4444ToI420(src, src_width * 2, dst_y, dst_stride_y, dst_u,
+                         dst_stride_u, dst_v, dst_stride_v, crop_width,
+                         inv_crop_height);
+      break;
+    case FOURCC_24BG:
+      src = sample + (src_width * crop_y + crop_x) * 3;
+      r = RGB24ToI420(src, src_width * 3, dst_y, dst_stride_y, dst_u,
+                      dst_stride_u, dst_v, dst_stride_v, crop_width,
+                      inv_crop_height);
+      break;
+    case FOURCC_RAW:
+      src = sample + (src_width * crop_y + crop_x) * 3;
+      r = RAWToI420(src, src_width * 3, dst_y, dst_stride_y, dst_u,
+                    dst_stride_u, dst_v, dst_stride_v, crop_width,
+                    inv_crop_height);
+      break;
+    case FOURCC_ARGB:
+      src = sample + (src_width * crop_y + crop_x) * 4;
+      r = ARGBToI420(src, src_width * 4, dst_y, dst_stride_y, dst_u,
+                     dst_stride_u, dst_v, dst_stride_v, crop_width,
+                     inv_crop_height);
+      break;
+    case FOURCC_BGRA:
+      src = sample + (src_width * crop_y + crop_x) * 4;
+      r = BGRAToI420(src, src_width * 4, dst_y, dst_stride_y, dst_u,
+                     dst_stride_u, dst_v, dst_stride_v, crop_width,
+                     inv_crop_height);
+      break;
+    case FOURCC_ABGR:
+      src = sample + (src_width * crop_y + crop_x) * 4;
+      r = ABGRToI420(src, src_width * 4, dst_y, dst_stride_y, dst_u,
+                     dst_stride_u, dst_v, dst_stride_v, crop_width,
+                     inv_crop_height);
+      break;
+    case FOURCC_RGBA:
+      src = sample + (src_width * crop_y + crop_x) * 4;
+      r = RGBAToI420(src, src_width * 4, dst_y, dst_stride_y, dst_u,
+                     dst_stride_u, dst_v, dst_stride_v, crop_width,
+                     inv_crop_height);
+      break;
+    // TODO(fbarchard): Add AR30 and AB30
+    case FOURCC_I400:
+      src = sample + src_width * crop_y + crop_x;
+      r = I400ToI420(src, src_width, dst_y, dst_stride_y, dst_u, dst_stride_u,
+                     dst_v, dst_stride_v, crop_width, inv_crop_height);
+      break;
+    // Biplanar formats
+    case FOURCC_NV12:
+      src = sample + (src_width * crop_y + crop_x);
+      src_uv = sample + (src_width * abs_src_height) +
+               ((crop_y / 2) * aligned_src_width) + ((crop_x / 2) * 2);
+      r = NV12ToI420Rotate(src, src_width, src_uv, aligned_src_width, dst_y,
+                           dst_stride_y, dst_u, dst_stride_u, dst_v,
+                           dst_stride_v, crop_width, inv_crop_height, rotation);
+      break;
+    case FOURCC_NV21:
+      src = sample + (src_width * crop_y + crop_x);
+      src_uv = sample + (src_width * abs_src_height) +
+               ((crop_y / 2) * aligned_src_width) + ((crop_x / 2) * 2);
+      // Call NV12 but with dst_u and dst_v parameters swapped.
+      r = NV12ToI420Rotate(src, src_width, src_uv, aligned_src_width, dst_y,
+                           dst_stride_y, dst_v, dst_stride_v, dst_u,
+                           dst_stride_u, crop_width, inv_crop_height, rotation);
+      break;
+    // Triplanar formats
+    case FOURCC_I420:
+    case FOURCC_YV12: {
+      const uint8_t* src_y = sample + (src_width * crop_y + crop_x);
+      const uint8_t* src_u;
+      const uint8_t* src_v;
+      int halfwidth = (src_width + 1) / 2;
+      int halfheight = (abs_src_height + 1) / 2;
+      if (format == FOURCC_YV12) {
+        src_v = sample + src_width * abs_src_height + halfwidth * (crop_y / 2) +
+                (crop_x / 2);
+        src_u = sample + src_width * abs_src_height +
+                halfwidth * (halfheight + (crop_y / 2)) + (crop_x / 2);
+      } else {
+        src_u = sample + src_width * abs_src_height + halfwidth * (crop_y / 2) +
+                (crop_x / 2);
+        src_v = sample + src_width * abs_src_height +
+                halfwidth * (halfheight + (crop_y / 2)) + (crop_x / 2);
+      }
+      r = I420Rotate(src_y, src_width, src_u, halfwidth, src_v, halfwidth,
+                     dst_y, dst_stride_y, dst_u, dst_stride_u, dst_v,
+                     dst_stride_v, crop_width, inv_crop_height, rotation);
+      break;
+    }
+    case FOURCC_I422:
+    case FOURCC_YV16: {
+      const uint8_t* src_y = sample + src_width * crop_y + crop_x;
+      const uint8_t* src_u;
+      const uint8_t* src_v;
+      int halfwidth = (src_width + 1) / 2;
+      if (format == FOURCC_YV16) {
+        src_v = sample + src_width * abs_src_height + halfwidth * crop_y +
+                (crop_x / 2);
+        src_u = sample + src_width * abs_src_height +
+                halfwidth * (abs_src_height + crop_y) + (crop_x / 2);
+      } else {
+        src_u = sample + src_width * abs_src_height + halfwidth * crop_y +
+                (crop_x / 2);
+        src_v = sample + src_width * abs_src_height +
+                halfwidth * (abs_src_height + crop_y) + (crop_x / 2);
+      }
+      r = I422ToI420(src_y, src_width, src_u, halfwidth, src_v, halfwidth,
+                     dst_y, dst_stride_y, dst_u, dst_stride_u, dst_v,
+                     dst_stride_v, crop_width, inv_crop_height);
+      break;
+    }
+    case FOURCC_I444:
+    case FOURCC_YV24: {
+      const uint8_t* src_y = sample + src_width * crop_y + crop_x;
+      const uint8_t* src_u;
+      const uint8_t* src_v;
+      if (format == FOURCC_YV24) {
+        src_v = sample + src_width * (abs_src_height + crop_y) + crop_x;
+        src_u = sample + src_width * (abs_src_height * 2 + crop_y) + crop_x;
+      } else {
+        src_u = sample + src_width * (abs_src_height + crop_y) + crop_x;
+        src_v = sample + src_width * (abs_src_height * 2 + crop_y) + crop_x;
+      }
+      r = I444ToI420(src_y, src_width, src_u, src_width, src_v, src_width,
+                     dst_y, dst_stride_y, dst_u, dst_stride_u, dst_v,
+                     dst_stride_v, crop_width, inv_crop_height);
+      break;
+    }
+#ifdef HAVE_JPEG
+    case FOURCC_MJPG:
+      r = MJPGToI420(sample, sample_size, dst_y, dst_stride_y, dst_u,
+                     dst_stride_u, dst_v, dst_stride_v, src_width,
+                     abs_src_height, crop_width, inv_crop_height);
+      break;
+#endif
+    default:
+      r = -1;  // unknown fourcc - return failure code.
+  }
+
+  if (need_buf) {
+    if (!r) {
+      r = I420Rotate(dst_y, dst_stride_y, dst_u, dst_stride_u, dst_v,
+                     dst_stride_v, tmp_y, tmp_y_stride, tmp_u, tmp_u_stride,
+                     tmp_v, tmp_v_stride, crop_width, abs_crop_height,
+                     rotation);
+    }
+    free(rotate_buffer);
+  }
+
+  return r;
+}
+
+#ifdef __cplusplus
+}  // extern "C"
+}  // namespace libyuv
+#endif
diff --git a/3rdparty/libyuv/src/source/cpu_id.cc b/3rdparty/libyuv/src/source/cpu_id.cc
new file mode 100644
index 00000000..56fe60e4
--- /dev/null
+++ b/3rdparty/libyuv/src/source/cpu_id.cc
@@ -0,0 +1,300 @@
+/*
+ *  Copyright 2011 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include "libyuv/cpu_id.h"
+
+#if defined(_MSC_VER)
+#include <intrin.h>  // For __cpuidex()
+#endif
+#if !defined(__pnacl__) && !defined(__CLR_VER) &&                           \
+    !defined(__native_client__) && (defined(_M_IX86) || defined(_M_X64)) && \
+    defined(_MSC_FULL_VER) && (_MSC_FULL_VER >= 160040219)
+#include <immintrin.h>  // For _xgetbv()
+#endif
+
+// For ArmCpuCaps() but unittested on all platforms
+#include <stdio.h>  // For fopen()
+#include <string.h>
+
+#ifdef __cplusplus
+namespace libyuv {
+extern "C" {
+#endif
+
+// For functions that use the stack and have runtime checks for overflow,
+// use SAFEBUFFERS to avoid additional check.
+#if defined(_MSC_FULL_VER) && (_MSC_FULL_VER >= 160040219) && \
+    !defined(__clang__)
+#define SAFEBUFFERS __declspec(safebuffers)
+#else
+#define SAFEBUFFERS
+#endif
+
+// cpu_info_ variable for SIMD instruction sets detected.
+LIBYUV_API int cpu_info_ = 0;
+
+// TODO(fbarchard): Consider using int for cpuid so casting is not needed.
+// Low level cpuid for X86.
+#if (defined(_M_IX86) || defined(_M_X64) || defined(__i386__) || \
+     defined(__x86_64__)) &&                                     \
+    !defined(__pnacl__) && !defined(__CLR_VER)
+LIBYUV_API
+void CpuId(int info_eax, int info_ecx, int* cpu_info) {
+#if defined(_MSC_VER)
+// Visual C version uses intrinsic or inline x86 assembly.
+#if defined(_MSC_FULL_VER) && (_MSC_FULL_VER >= 160040219)
+  __cpuidex(cpu_info, info_eax, info_ecx);
+#elif defined(_M_IX86)
+  __asm {
+    mov        eax, info_eax
+    mov        ecx, info_ecx
+    mov        edi, cpu_info
+    cpuid
+    mov        [edi], eax
+    mov        [edi + 4], ebx
+    mov        [edi + 8], ecx
+    mov        [edi + 12], edx
+  }
+#else  // Visual C but not x86
+  if (info_ecx == 0) {
+    __cpuid(cpu_info, info_eax);
+  } else {
+    cpu_info[3] = cpu_info[2] = cpu_info[1] = cpu_info[0] = 0u;
+  }
+#endif
+// GCC version uses inline x86 assembly.
+#else  // defined(_MSC_VER)
+  int info_ebx, info_edx;
+  asm volatile(
+#if defined(__i386__) && defined(__PIC__)
+      // Preserve ebx for fpic 32 bit.
+      "mov         %%ebx, %%edi                  \n"
+      "cpuid                                     \n"
+      "xchg        %%edi, %%ebx                  \n"
+      : "=D"(info_ebx),
+#else
+      "cpuid                                     \n"
+      : "=b"(info_ebx),
+#endif  //  defined( __i386__) && defined(__PIC__)
+        "+a"(info_eax), "+c"(info_ecx), "=d"(info_edx));
+  cpu_info[0] = info_eax;
+  cpu_info[1] = info_ebx;
+  cpu_info[2] = info_ecx;
+  cpu_info[3] = info_edx;
+#endif  // defined(_MSC_VER)
+}
+#else  // (defined(_M_IX86) || defined(_M_X64) ...
+LIBYUV_API
+void CpuId(int eax, int ecx, int* cpu_info) {
+  (void)eax;
+  (void)ecx;
+  cpu_info[0] = cpu_info[1] = cpu_info[2] = cpu_info[3] = 0;
+}
+#endif
+
+// For VS2010 and earlier emit can be used:
+//   _asm _emit 0x0f _asm _emit 0x01 _asm _emit 0xd0  // For VS2010 and earlier.
+//  __asm {
+//    xor        ecx, ecx    // xcr 0
+//    xgetbv
+//    mov        xcr0, eax
+//  }
+// For VS2013 and earlier 32 bit, the _xgetbv(0) optimizer produces bad code.
+// https://code.google.com/p/libyuv/issues/detail?id=529
+#if defined(_M_IX86) && (_MSC_VER < 1900)
+#pragma optimize("g", off)
+#endif
+#if (defined(_M_IX86) || defined(_M_X64) || defined(__i386__) || \
+     defined(__x86_64__)) &&                                     \
+    !defined(__pnacl__) && !defined(__CLR_VER) && !defined(__native_client__)
+// X86 CPUs have xgetbv to detect OS saves high parts of ymm registers.
+int GetXCR0() {
+  int xcr0 = 0;
+#if defined(_MSC_FULL_VER) && (_MSC_FULL_VER >= 160040219)
+  xcr0 = (int)_xgetbv(0);  // VS2010 SP1 required.  NOLINT
+#elif defined(__i386__) || defined(__x86_64__)
+  asm(".byte 0x0f, 0x01, 0xd0" : "=a"(xcr0) : "c"(0) : "%edx");
+#endif  // defined(__i386__) || defined(__x86_64__)
+  return xcr0;
+}
+#else
+// xgetbv unavailable to query for OSSave support.  Return 0.
+#define GetXCR0() 0
+#endif  // defined(_M_IX86) || defined(_M_X64) ..
+// Return optimization to previous setting.
+#if defined(_M_IX86) && (_MSC_VER < 1900)
+#pragma optimize("g", on)
+#endif
+
+// Based on libvpx arm_cpudetect.c
+// For Arm, but public to allow testing on any CPU
+LIBYUV_API SAFEBUFFERS int ArmCpuCaps(const char* cpuinfo_name) {
+  char cpuinfo_line[512];
+  FILE* f = fopen(cpuinfo_name, "r");
+  if (!f) {
+    // Assume Neon if /proc/cpuinfo is unavailable.
+    // This will occur for Chrome sandbox for Pepper or Render process.
+    return kCpuHasNEON;
+  }
+  while (fgets(cpuinfo_line, sizeof(cpuinfo_line) - 1, f)) {
+    if (memcmp(cpuinfo_line, "Features", 8) == 0) {
+      char* p = strstr(cpuinfo_line, " neon");
+      if (p && (p[5] == ' ' || p[5] == '\n')) {
+        fclose(f);
+        return kCpuHasNEON;
+      }
+      // aarch64 uses asimd for Neon.
+      p = strstr(cpuinfo_line, " asimd");
+      if (p) {
+        fclose(f);
+        return kCpuHasNEON;
+      }
+    }
+  }
+  fclose(f);
+  return 0;
+}
+
+// TODO(fbarchard): Consider read_msa_ir().
+LIBYUV_API SAFEBUFFERS int MipsCpuCaps(const char* cpuinfo_name) {
+  char cpuinfo_line[512];
+  int flag = 0x0;
+  FILE* f = fopen(cpuinfo_name, "r");
+  if (!f) {
+    // Assume nothing if /proc/cpuinfo is unavailable.
+    // This will occur for Chrome sandbox for Pepper or Render process.
+    return 0;
+  }
+  while (fgets(cpuinfo_line, sizeof(cpuinfo_line) - 1, f)) {
+    if (memcmp(cpuinfo_line, "cpu model", 9) == 0) {
+      // Workaround early kernel without MSA in ASEs line.
+      if (strstr(cpuinfo_line, "Loongson-2K")) {
+        flag |= kCpuHasMSA;
+      }
+    }
+    if (memcmp(cpuinfo_line, "ASEs implemented", 16) == 0) {
+      if (strstr(cpuinfo_line, "msa")) {
+        flag |= kCpuHasMSA;
+      }
+      // ASEs is the last line, so we can break here.
+      break;
+    }
+  }
+  fclose(f);
+  return flag;
+}
+
+// TODO(fbarchard): Consider read_loongarch_ir().
+#define LOONGARCH_CFG2 0x2
+#define LOONGARCH_CFG2_LSX (1 << 6)
+#define LOONGARCH_CFG2_LASX (1 << 7)
+
+#if defined(__loongarch__)
+LIBYUV_API SAFEBUFFERS int LoongarchCpuCaps(void) {
+  int flag = 0x0;
+  uint32_t cfg2 = 0;
+
+  __asm__ volatile("cpucfg %0, %1 \n\t" : "+&r"(cfg2) : "r"(LOONGARCH_CFG2));
+
+  if (cfg2 & LOONGARCH_CFG2_LSX)
+    flag |= kCpuHasLSX;
+
+  if (cfg2 & LOONGARCH_CFG2_LASX)
+    flag |= kCpuHasLASX;
+  return flag;
+}
+#endif
+
+static SAFEBUFFERS int GetCpuFlags(void) {
+  int cpu_info = 0;
+#if !defined(__pnacl__) && !defined(__CLR_VER) &&                   \
+    (defined(__x86_64__) || defined(_M_X64) || defined(__i386__) || \
+     defined(_M_IX86))
+  int cpu_info0[4] = {0, 0, 0, 0};
+  int cpu_info1[4] = {0, 0, 0, 0};
+  int cpu_info7[4] = {0, 0, 0, 0};
+  CpuId(0, 0, cpu_info0);
+  CpuId(1, 0, cpu_info1);
+  if (cpu_info0[0] >= 7) {
+    CpuId(7, 0, cpu_info7);
+  }
+  cpu_info = kCpuHasX86 | ((cpu_info1[3] & 0x04000000) ? kCpuHasSSE2 : 0) |
+             ((cpu_info1[2] & 0x00000200) ? kCpuHasSSSE3 : 0) |
+             ((cpu_info1[2] & 0x00080000) ? kCpuHasSSE41 : 0) |
+             ((cpu_info1[2] & 0x00100000) ? kCpuHasSSE42 : 0) |
+             ((cpu_info7[1] & 0x00000200) ? kCpuHasERMS : 0);
+
+  // AVX requires OS saves YMM registers.
+  if (((cpu_info1[2] & 0x1c000000) == 0x1c000000) &&  // AVX and OSXSave
+      ((GetXCR0() & 6) == 6)) {  // Test OS saves YMM registers
+    cpu_info |= kCpuHasAVX | ((cpu_info7[1] & 0x00000020) ? kCpuHasAVX2 : 0) |
+                ((cpu_info1[2] & 0x00001000) ? kCpuHasFMA3 : 0) |
+                ((cpu_info1[2] & 0x20000000) ? kCpuHasF16C : 0);
+
+    // Detect AVX512bw
+    if ((GetXCR0() & 0xe0) == 0xe0) {
+      cpu_info |= (cpu_info7[1] & 0x40000000) ? kCpuHasAVX512BW : 0;
+      cpu_info |= (cpu_info7[1] & 0x80000000) ? kCpuHasAVX512VL : 0;
+      cpu_info |= (cpu_info7[2] & 0x00000002) ? kCpuHasAVX512VBMI : 0;
+      cpu_info |= (cpu_info7[2] & 0x00000040) ? kCpuHasAVX512VBMI2 : 0;
+      cpu_info |= (cpu_info7[2] & 0x00000800) ? kCpuHasAVX512VNNI : 0;
+      cpu_info |= (cpu_info7[2] & 0x00001000) ? kCpuHasAVX512VBITALG : 0;
+      cpu_info |= (cpu_info7[2] & 0x00004000) ? kCpuHasAVX512VPOPCNTDQ : 0;
+      cpu_info |= (cpu_info7[2] & 0x00000100) ? kCpuHasGFNI : 0;
+    }
+  }
+#endif
+#if defined(__mips__) && defined(__linux__)
+  cpu_info = MipsCpuCaps("/proc/cpuinfo");
+  cpu_info |= kCpuHasMIPS;
+#endif
+#if defined(__loongarch__) && defined(__linux__)
+  cpu_info = LoongarchCpuCaps();
+  cpu_info |= kCpuHasLOONGARCH;
+#endif
+#if defined(__arm__) || defined(__aarch64__)
+// gcc -mfpu=neon defines __ARM_NEON__
+// __ARM_NEON__ generates code that requires Neon.  NaCL also requires Neon.
+// For Linux, /proc/cpuinfo can be tested but without that assume Neon.
+#if defined(__ARM_NEON__) || defined(__native_client__) || !defined(__linux__)
+  cpu_info = kCpuHasNEON;
+// For aarch64(arm64), /proc/cpuinfo's feature is not complete, e.g. no neon
+// flag in it.
+// So for aarch64, neon enabling is hard coded here.
+#endif
+#if defined(__aarch64__)
+  cpu_info = kCpuHasNEON;
+#else
+  // Linux arm parse text file for neon detect.
+  cpu_info = ArmCpuCaps("/proc/cpuinfo");
+#endif
+  cpu_info |= kCpuHasARM;
+#endif  // __arm__
+  cpu_info |= kCpuInitialized;
+  return cpu_info;
+}
+
+// Note that use of this function is not thread safe.
+LIBYUV_API
+int MaskCpuFlags(int enable_flags) {
+  int cpu_info = GetCpuFlags() & enable_flags;
+  SetCpuFlags(cpu_info);
+  return cpu_info;
+}
+
+LIBYUV_API
+int InitCpuFlags(void) {
+  return MaskCpuFlags(-1);
+}
+
+#ifdef __cplusplus
+}  // extern "C"
+}  // namespace libyuv
+#endif
diff --git a/3rdparty/libyuv/src/source/mjpeg_decoder.cc b/3rdparty/libyuv/src/source/mjpeg_decoder.cc
new file mode 100644
index 00000000..4ccf00a3
--- /dev/null
+++ b/3rdparty/libyuv/src/source/mjpeg_decoder.cc
@@ -0,0 +1,581 @@
+/*
+ *  Copyright 2012 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include "libyuv/mjpeg_decoder.h"
+
+#ifdef HAVE_JPEG
+#include <assert.h>
+
+#if !defined(__pnacl__) && !defined(__CLR_VER) && \
+    !defined(COVERAGE_ENABLED) && !defined(TARGET_IPHONE_SIMULATOR)
+// Must be included before jpeglib.
+#include <setjmp.h>
+#define HAVE_SETJMP
+
+#if defined(_MSC_VER)
+// disable warning 4324: structure was padded due to __declspec(align())
+#pragma warning(disable : 4324)
+#endif
+
+#endif
+
+#include <stdio.h>  // For jpeglib.h.
+
+// C++ build requires extern C for jpeg internals.
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <jpeglib.h>
+
+#ifdef __cplusplus
+}  // extern "C"
+#endif
+
+#include "libyuv/planar_functions.h"  // For CopyPlane().
+
+namespace libyuv {
+
+#ifdef HAVE_SETJMP
+struct SetJmpErrorMgr {
+  jpeg_error_mgr base;  // Must be at the top
+  jmp_buf setjmp_buffer;
+};
+#endif
+
+const int MJpegDecoder::kColorSpaceUnknown = JCS_UNKNOWN;
+const int MJpegDecoder::kColorSpaceGrayscale = JCS_GRAYSCALE;
+const int MJpegDecoder::kColorSpaceRgb = JCS_RGB;
+const int MJpegDecoder::kColorSpaceYCbCr = JCS_YCbCr;
+const int MJpegDecoder::kColorSpaceCMYK = JCS_CMYK;
+const int MJpegDecoder::kColorSpaceYCCK = JCS_YCCK;
+
+// Methods that are passed to jpeglib.
+boolean fill_input_buffer(jpeg_decompress_struct* cinfo);
+void init_source(jpeg_decompress_struct* cinfo);
+void skip_input_data(jpeg_decompress_struct* cinfo, long num_bytes);  // NOLINT
+void term_source(jpeg_decompress_struct* cinfo);
+void ErrorHandler(jpeg_common_struct* cinfo);
+void OutputHandler(jpeg_common_struct* cinfo);
+
+MJpegDecoder::MJpegDecoder()
+    : has_scanline_padding_(LIBYUV_FALSE),
+      num_outbufs_(0),
+      scanlines_(NULL),
+      scanlines_sizes_(NULL),
+      databuf_(NULL),
+      databuf_strides_(NULL) {
+  decompress_struct_ = new jpeg_decompress_struct;
+  source_mgr_ = new jpeg_source_mgr;
+#ifdef HAVE_SETJMP
+  error_mgr_ = new SetJmpErrorMgr;
+  decompress_struct_->err = jpeg_std_error(&error_mgr_->base);
+  // Override standard exit()-based error handler.
+  error_mgr_->base.error_exit = &ErrorHandler;
+  error_mgr_->base.output_message = &OutputHandler;
+#endif
+  decompress_struct_->client_data = NULL;
+  source_mgr_->init_source = &init_source;
+  source_mgr_->fill_input_buffer = &fill_input_buffer;
+  source_mgr_->skip_input_data = &skip_input_data;
+  source_mgr_->resync_to_restart = &jpeg_resync_to_restart;
+  source_mgr_->term_source = &term_source;
+  jpeg_create_decompress(decompress_struct_);
+  decompress_struct_->src = source_mgr_;
+  buf_vec_.buffers = &buf_;
+  buf_vec_.len = 1;
+}
+
+MJpegDecoder::~MJpegDecoder() {
+  jpeg_destroy_decompress(decompress_struct_);
+  delete decompress_struct_;
+  delete source_mgr_;
+#ifdef HAVE_SETJMP
+  delete error_mgr_;
+#endif
+  DestroyOutputBuffers();
+}
+
+LIBYUV_BOOL MJpegDecoder::LoadFrame(const uint8_t* src, size_t src_len) {
+  if (!ValidateJpeg(src, src_len)) {
+    return LIBYUV_FALSE;
+  }
+
+  buf_.data = src;
+  buf_.len = static_cast<int>(src_len);
+  buf_vec_.pos = 0;
+  decompress_struct_->client_data = &buf_vec_;
+#ifdef HAVE_SETJMP
+  if (setjmp(error_mgr_->setjmp_buffer)) {
+    // We called jpeg_read_header, it experienced an error, and we called
+    // longjmp() and rewound the stack to here. Return error.
+    return LIBYUV_FALSE;
+  }
+#endif
+  if (jpeg_read_header(decompress_struct_, TRUE) != JPEG_HEADER_OK) {
+    // ERROR: Bad MJPEG header
+    return LIBYUV_FALSE;
+  }
+  AllocOutputBuffers(GetNumComponents());
+  for (int i = 0; i < num_outbufs_; ++i) {
+    int scanlines_size = GetComponentScanlinesPerImcuRow(i);
+    if (scanlines_sizes_[i] != scanlines_size) {
+      if (scanlines_[i]) {
+        delete scanlines_[i];
+      }
+      scanlines_[i] = new uint8_t*[scanlines_size];
+      scanlines_sizes_[i] = scanlines_size;
+    }
+
+    // We allocate padding for the final scanline to pad it up to DCTSIZE bytes
+    // to avoid memory errors, since jpeglib only reads full MCUs blocks. For
+    // the preceding scanlines, the padding is not needed/wanted because the
+    // following addresses will already be valid (they are the initial bytes of
+    // the next scanline) and will be overwritten when jpeglib writes out that
+    // next scanline.
+    int databuf_stride = GetComponentStride(i);
+    int databuf_size = scanlines_size * databuf_stride;
+    if (databuf_strides_[i] != databuf_stride) {
+      if (databuf_[i]) {
+        delete databuf_[i];
+      }
+      databuf_[i] = new uint8_t[databuf_size];
+      databuf_strides_[i] = databuf_stride;
+    }
+
+    if (GetComponentStride(i) != GetComponentWidth(i)) {
+      has_scanline_padding_ = LIBYUV_TRUE;
+    }
+  }
+  return LIBYUV_TRUE;
+}
+
+static int DivideAndRoundUp(int numerator, int denominator) {
+  return (numerator + denominator - 1) / denominator;
+}
+
+static int DivideAndRoundDown(int numerator, int denominator) {
+  return numerator / denominator;
+}
+
+// Returns width of the last loaded frame.
+int MJpegDecoder::GetWidth() {
+  return decompress_struct_->image_width;
+}
+
+// Returns height of the last loaded frame.
+int MJpegDecoder::GetHeight() {
+  return decompress_struct_->image_height;
+}
+
+// Returns format of the last loaded frame. The return value is one of the
+// kColorSpace* constants.
+int MJpegDecoder::GetColorSpace() {
+  return decompress_struct_->jpeg_color_space;
+}
+
+// Number of color components in the color space.
+int MJpegDecoder::GetNumComponents() {
+  return decompress_struct_->num_components;
+}
+
+// Sample factors of the n-th component.
+int MJpegDecoder::GetHorizSampFactor(int component) {
+  return decompress_struct_->comp_info[component].h_samp_factor;
+}
+
+int MJpegDecoder::GetVertSampFactor(int component) {
+  return decompress_struct_->comp_info[component].v_samp_factor;
+}
+
+int MJpegDecoder::GetHorizSubSampFactor(int component) {
+  return decompress_struct_->max_h_samp_factor / GetHorizSampFactor(component);
+}
+
+int MJpegDecoder::GetVertSubSampFactor(int component) {
+  return decompress_struct_->max_v_samp_factor / GetVertSampFactor(component);
+}
+
+int MJpegDecoder::GetImageScanlinesPerImcuRow() {
+  return decompress_struct_->max_v_samp_factor * DCTSIZE;
+}
+
+int MJpegDecoder::GetComponentScanlinesPerImcuRow(int component) {
+  int vs = GetVertSubSampFactor(component);
+  return DivideAndRoundUp(GetImageScanlinesPerImcuRow(), vs);
+}
+
+int MJpegDecoder::GetComponentWidth(int component) {
+  int hs = GetHorizSubSampFactor(component);
+  return DivideAndRoundUp(GetWidth(), hs);
+}
+
+int MJpegDecoder::GetComponentHeight(int component) {
+  int vs = GetVertSubSampFactor(component);
+  return DivideAndRoundUp(GetHeight(), vs);
+}
+
+// Get width in bytes padded out to a multiple of DCTSIZE
+int MJpegDecoder::GetComponentStride(int component) {
+  return (GetComponentWidth(component) + DCTSIZE - 1) & ~(DCTSIZE - 1);
+}
+
+int MJpegDecoder::GetComponentSize(int component) {
+  return GetComponentWidth(component) * GetComponentHeight(component);
+}
+
+LIBYUV_BOOL MJpegDecoder::UnloadFrame() {
+#ifdef HAVE_SETJMP
+  if (setjmp(error_mgr_->setjmp_buffer)) {
+    // We called jpeg_abort_decompress, it experienced an error, and we called
+    // longjmp() and rewound the stack to here. Return error.
+    return LIBYUV_FALSE;
+  }
+#endif
+  jpeg_abort_decompress(decompress_struct_);
+  return LIBYUV_TRUE;
+}
+
+// TODO(fbarchard): Allow rectangle to be specified: x, y, width, height.
+LIBYUV_BOOL MJpegDecoder::DecodeToBuffers(uint8_t** planes,
+                                          int dst_width,
+                                          int dst_height) {
+  if (dst_width != GetWidth() || dst_height > GetHeight()) {
+    // ERROR: Bad dimensions
+    return LIBYUV_FALSE;
+  }
+#ifdef HAVE_SETJMP
+  if (setjmp(error_mgr_->setjmp_buffer)) {
+    // We called into jpeglib, it experienced an error sometime during this
+    // function call, and we called longjmp() and rewound the stack to here.
+    // Return error.
+    return LIBYUV_FALSE;
+  }
+#endif
+  if (!StartDecode()) {
+    return LIBYUV_FALSE;
+  }
+  SetScanlinePointers(databuf_);
+  int lines_left = dst_height;
+  // Compute amount of lines to skip to implement vertical crop.
+  // TODO(fbarchard): Ensure skip is a multiple of maximum component
+  // subsample. ie 2
+  int skip = (GetHeight() - dst_height) / 2;
+  if (skip > 0) {
+    // There is no API to skip lines in the output data, so we read them
+    // into the temp buffer.
+    while (skip >= GetImageScanlinesPerImcuRow()) {
+      if (!DecodeImcuRow()) {
+        FinishDecode();
+        return LIBYUV_FALSE;
+      }
+      skip -= GetImageScanlinesPerImcuRow();
+    }
+    if (skip > 0) {
+      // Have a partial iMCU row left over to skip. Must read it and then
+      // copy the parts we want into the destination.
+      if (!DecodeImcuRow()) {
+        FinishDecode();
+        return LIBYUV_FALSE;
+      }
+      for (int i = 0; i < num_outbufs_; ++i) {
+        // TODO(fbarchard): Compute skip to avoid this
+        assert(skip % GetVertSubSampFactor(i) == 0);
+        int rows_to_skip = DivideAndRoundDown(skip, GetVertSubSampFactor(i));
+        int scanlines_to_copy =
+            GetComponentScanlinesPerImcuRow(i) - rows_to_skip;
+        int data_to_skip = rows_to_skip * GetComponentStride(i);
+        CopyPlane(databuf_[i] + data_to_skip, GetComponentStride(i), planes[i],
+                  GetComponentWidth(i), GetComponentWidth(i),
+                  scanlines_to_copy);
+        planes[i] += scanlines_to_copy * GetComponentWidth(i);
+      }
+      lines_left -= (GetImageScanlinesPerImcuRow() - skip);
+    }
+  }
+
+  // Read full MCUs but cropped horizontally
+  for (; lines_left > GetImageScanlinesPerImcuRow();
+       lines_left -= GetImageScanlinesPerImcuRow()) {
+    if (!DecodeImcuRow()) {
+      FinishDecode();
+      return LIBYUV_FALSE;
+    }
+    for (int i = 0; i < num_outbufs_; ++i) {
+      int scanlines_to_copy = GetComponentScanlinesPerImcuRow(i);
+      CopyPlane(databuf_[i], GetComponentStride(i), planes[i],
+                GetComponentWidth(i), GetComponentWidth(i), scanlines_to_copy);
+      planes[i] += scanlines_to_copy * GetComponentWidth(i);
+    }
+  }
+
+  if (lines_left > 0) {
+    // Have a partial iMCU row left over to decode.
+    if (!DecodeImcuRow()) {
+      FinishDecode();
+      return LIBYUV_FALSE;
+    }
+    for (int i = 0; i < num_outbufs_; ++i) {
+      int scanlines_to_copy =
+          DivideAndRoundUp(lines_left, GetVertSubSampFactor(i));
+      CopyPlane(databuf_[i], GetComponentStride(i), planes[i],
+                GetComponentWidth(i), GetComponentWidth(i), scanlines_to_copy);
+      planes[i] += scanlines_to_copy * GetComponentWidth(i);
+    }
+  }
+  return FinishDecode();
+}
+
+LIBYUV_BOOL MJpegDecoder::DecodeToCallback(CallbackFunction fn,
+                                           void* opaque,
+                                           int dst_width,
+                                           int dst_height) {
+  if (dst_width != GetWidth() || dst_height > GetHeight()) {
+    // ERROR: Bad dimensions
+    return LIBYUV_FALSE;
+  }
+#ifdef HAVE_SETJMP
+  if (setjmp(error_mgr_->setjmp_buffer)) {
+    // We called into jpeglib, it experienced an error sometime during this
+    // function call, and we called longjmp() and rewound the stack to here.
+    // Return error.
+    return LIBYUV_FALSE;
+  }
+#endif
+  if (!StartDecode()) {
+    return LIBYUV_FALSE;
+  }
+  SetScanlinePointers(databuf_);
+  int lines_left = dst_height;
+  // TODO(fbarchard): Compute amount of lines to skip to implement vertical crop
+  int skip = (GetHeight() - dst_height) / 2;
+  if (skip > 0) {
+    while (skip >= GetImageScanlinesPerImcuRow()) {
+      if (!DecodeImcuRow()) {
+        FinishDecode();
+        return LIBYUV_FALSE;
+      }
+      skip -= GetImageScanlinesPerImcuRow();
+    }
+    if (skip > 0) {
+      // Have a partial iMCU row left over to skip.
+      if (!DecodeImcuRow()) {
+        FinishDecode();
+        return LIBYUV_FALSE;
+      }
+      for (int i = 0; i < num_outbufs_; ++i) {
+        // TODO(fbarchard): Compute skip to avoid this
+        assert(skip % GetVertSubSampFactor(i) == 0);
+        int rows_to_skip = DivideAndRoundDown(skip, GetVertSubSampFactor(i));
+        int data_to_skip = rows_to_skip * GetComponentStride(i);
+        // Change our own data buffer pointers so we can pass them to the
+        // callback.
+        databuf_[i] += data_to_skip;
+      }
+      int scanlines_to_copy = GetImageScanlinesPerImcuRow() - skip;
+      (*fn)(opaque, databuf_, databuf_strides_, scanlines_to_copy);
+      // Now change them back.
+      for (int i = 0; i < num_outbufs_; ++i) {
+        int rows_to_skip = DivideAndRoundDown(skip, GetVertSubSampFactor(i));
+        int data_to_skip = rows_to_skip * GetComponentStride(i);
+        databuf_[i] -= data_to_skip;
+      }
+      lines_left -= scanlines_to_copy;
+    }
+  }
+  // Read full MCUs until we get to the crop point.
+  for (; lines_left >= GetImageScanlinesPerImcuRow();
+       lines_left -= GetImageScanlinesPerImcuRow()) {
+    if (!DecodeImcuRow()) {
+      FinishDecode();
+      return LIBYUV_FALSE;
+    }
+    (*fn)(opaque, databuf_, databuf_strides_, GetImageScanlinesPerImcuRow());
+  }
+  if (lines_left > 0) {
+    // Have a partial iMCU row left over to decode.
+    if (!DecodeImcuRow()) {
+      FinishDecode();
+      return LIBYUV_FALSE;
+    }
+    (*fn)(opaque, databuf_, databuf_strides_, lines_left);
+  }
+  return FinishDecode();
+}
+
+void init_source(j_decompress_ptr cinfo) {
+  fill_input_buffer(cinfo);
+}
+
+boolean fill_input_buffer(j_decompress_ptr cinfo) {
+  BufferVector* buf_vec = reinterpret_cast<BufferVector*>(cinfo->client_data);
+  if (buf_vec->pos >= buf_vec->len) {
+    // ERROR: No more data
+    return FALSE;
+  }
+  cinfo->src->next_input_byte = buf_vec->buffers[buf_vec->pos].data;
+  cinfo->src->bytes_in_buffer = buf_vec->buffers[buf_vec->pos].len;
+  ++buf_vec->pos;
+  return TRUE;
+}
+
+void skip_input_data(j_decompress_ptr cinfo, long num_bytes) {  // NOLINT
+  jpeg_source_mgr* src = cinfo->src;
+  size_t bytes = static_cast<size_t>(num_bytes);
+  if (bytes > src->bytes_in_buffer) {
+    src->next_input_byte = nullptr;
+    src->bytes_in_buffer = 0;
+  } else {
+    src->next_input_byte += bytes;
+    src->bytes_in_buffer -= bytes;
+  }
+}
+
+void term_source(j_decompress_ptr cinfo) {
+  (void)cinfo;  // Nothing to do.
+}
+
+#ifdef HAVE_SETJMP
+void ErrorHandler(j_common_ptr cinfo) {
+// This is called when a jpeglib command experiences an error. Unfortunately
+// jpeglib's error handling model is not very flexible, because it expects the
+// error handler to not return--i.e., it wants the program to terminate. To
+// recover from errors we use setjmp() as shown in their example. setjmp() is
+// C's implementation for the "call with current continuation" functionality
+// seen in some functional programming languages.
+// A formatted message can be output, but is unsafe for release.
+#ifdef DEBUG
+  char buf[JMSG_LENGTH_MAX];
+  (*cinfo->err->format_message)(cinfo, buf);
+// ERROR: Error in jpeglib: buf
+#endif
+
+  SetJmpErrorMgr* mgr = reinterpret_cast<SetJmpErrorMgr*>(cinfo->err);
+  // This rewinds the call stack to the point of the corresponding setjmp()
+  // and causes it to return (for a second time) with value 1.
+  longjmp(mgr->setjmp_buffer, 1);
+}
+
+// Suppress fprintf warnings.
+void OutputHandler(j_common_ptr cinfo) {
+  (void)cinfo;
+}
+
+#endif  // HAVE_SETJMP
+
+void MJpegDecoder::AllocOutputBuffers(int num_outbufs) {
+  if (num_outbufs != num_outbufs_) {
+    // We could perhaps optimize this case to resize the output buffers without
+    // necessarily having to delete and recreate each one, but it's not worth
+    // it.
+    DestroyOutputBuffers();
+
+    scanlines_ = new uint8_t**[num_outbufs];
+    scanlines_sizes_ = new int[num_outbufs];
+    databuf_ = new uint8_t*[num_outbufs];
+    databuf_strides_ = new int[num_outbufs];
+
+    for (int i = 0; i < num_outbufs; ++i) {
+      scanlines_[i] = NULL;
+      scanlines_sizes_[i] = 0;
+      databuf_[i] = NULL;
+      databuf_strides_[i] = 0;
+    }
+
+    num_outbufs_ = num_outbufs;
+  }
+}
+
+void MJpegDecoder::DestroyOutputBuffers() {
+  for (int i = 0; i < num_outbufs_; ++i) {
+    delete[] scanlines_[i];
+    delete[] databuf_[i];
+  }
+  delete[] scanlines_;
+  delete[] databuf_;
+  delete[] scanlines_sizes_;
+  delete[] databuf_strides_;
+  scanlines_ = NULL;
+  databuf_ = NULL;
+  scanlines_sizes_ = NULL;
+  databuf_strides_ = NULL;
+  num_outbufs_ = 0;
+}
+
+// JDCT_IFAST and do_block_smoothing improve performance substantially.
+LIBYUV_BOOL MJpegDecoder::StartDecode() {
+  decompress_struct_->raw_data_out = TRUE;
+  decompress_struct_->dct_method = JDCT_IFAST;  // JDCT_ISLOW is default
+  decompress_struct_->dither_mode = JDITHER_NONE;
+  // Not applicable to 'raw':
+  decompress_struct_->do_fancy_upsampling = (boolean)(LIBYUV_FALSE);
+  // Only for buffered mode:
+  decompress_struct_->enable_2pass_quant = (boolean)(LIBYUV_FALSE);
+  // Blocky but fast:
+  decompress_struct_->do_block_smoothing = (boolean)(LIBYUV_FALSE);
+
+  if (!jpeg_start_decompress(decompress_struct_)) {
+    // ERROR: Couldn't start JPEG decompressor";
+    return LIBYUV_FALSE;
+  }
+  return LIBYUV_TRUE;
+}
+
+LIBYUV_BOOL MJpegDecoder::FinishDecode() {
+  // jpeglib considers it an error if we finish without decoding the whole
+  // image, so we call "abort" rather than "finish".
+  jpeg_abort_decompress(decompress_struct_);
+  return LIBYUV_TRUE;
+}
+
+void MJpegDecoder::SetScanlinePointers(uint8_t** data) {
+  for (int i = 0; i < num_outbufs_; ++i) {
+    uint8_t* data_i = data[i];
+    for (int j = 0; j < scanlines_sizes_[i]; ++j) {
+      scanlines_[i][j] = data_i;
+      data_i += GetComponentStride(i);
+    }
+  }
+}
+
+inline LIBYUV_BOOL MJpegDecoder::DecodeImcuRow() {
+  return (unsigned int)(GetImageScanlinesPerImcuRow()) ==
+         jpeg_read_raw_data(decompress_struct_, scanlines_,
+                            GetImageScanlinesPerImcuRow());
+}
+
+// The helper function which recognizes the jpeg sub-sampling type.
+JpegSubsamplingType MJpegDecoder::JpegSubsamplingTypeHelper(
+    int* subsample_x,
+    int* subsample_y,
+    int number_of_components) {
+  if (number_of_components == 3) {  // Color images.
+    if (subsample_x[0] == 1 && subsample_y[0] == 1 && subsample_x[1] == 2 &&
+        subsample_y[1] == 2 && subsample_x[2] == 2 && subsample_y[2] == 2) {
+      return kJpegYuv420;
+    }
+    if (subsample_x[0] == 1 && subsample_y[0] == 1 && subsample_x[1] == 2 &&
+        subsample_y[1] == 1 && subsample_x[2] == 2 && subsample_y[2] == 1) {
+      return kJpegYuv422;
+    }
+    if (subsample_x[0] == 1 && subsample_y[0] == 1 && subsample_x[1] == 1 &&
+        subsample_y[1] == 1 && subsample_x[2] == 1 && subsample_y[2] == 1) {
+      return kJpegYuv444;
+    }
+  } else if (number_of_components == 1) {  // Grey-scale images.
+    if (subsample_x[0] == 1 && subsample_y[0] == 1) {
+      return kJpegYuv400;
+    }
+  }
+  return kJpegUnknown;
+}
+
+}  // namespace libyuv
+#endif  // HAVE_JPEG
diff --git a/3rdparty/libyuv/src/source/mjpeg_validate.cc b/3rdparty/libyuv/src/source/mjpeg_validate.cc
new file mode 100644
index 00000000..ba0a03ab
--- /dev/null
+++ b/3rdparty/libyuv/src/source/mjpeg_validate.cc
@@ -0,0 +1,71 @@
+/*
+ *  Copyright 2012 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include "libyuv/mjpeg_decoder.h"
+
+#include <string.h>  // For memchr.
+
+#ifdef __cplusplus
+namespace libyuv {
+extern "C" {
+#endif
+
+// Helper function to scan for EOI marker (0xff 0xd9).
+static LIBYUV_BOOL ScanEOI(const uint8_t* src_mjpg, size_t src_size_mjpg) {
+  if (src_size_mjpg >= 2) {
+    const uint8_t* end = src_mjpg + src_size_mjpg - 1;
+    const uint8_t* it = src_mjpg;
+    while (it < end) {
+      // TODO(fbarchard): scan for 0xd9 instead.
+      it = (const uint8_t*)(memchr(it, 0xff, end - it));
+      if (it == NULL) {
+        break;
+      }
+      if (it[1] == 0xd9) {
+        return LIBYUV_TRUE;  // Success: Valid jpeg.
+      }
+      ++it;  // Skip over current 0xff.
+    }
+  }
+  // ERROR: Invalid jpeg end code not found. Size src_size_mjpg
+  return LIBYUV_FALSE;
+}
+
+// Helper function to validate the jpeg appears intact.
+LIBYUV_BOOL ValidateJpeg(const uint8_t* src_mjpg, size_t src_size_mjpg) {
+  // Maximum size that ValidateJpeg will consider valid.
+  const size_t kMaxJpegSize = 0x7fffffffull;
+  const size_t kBackSearchSize = 1024;
+  if (src_size_mjpg < 64 || src_size_mjpg > kMaxJpegSize || !src_mjpg) {
+    // ERROR: Invalid jpeg size: src_size_mjpg
+    return LIBYUV_FALSE;
+  }
+  // SOI marker
+  if (src_mjpg[0] != 0xff || src_mjpg[1] != 0xd8 || src_mjpg[2] != 0xff) {
+    // ERROR: Invalid jpeg initial start code
+    return LIBYUV_FALSE;
+  }
+
+  // Look for the End Of Image (EOI) marker near the end of the buffer.
+  if (src_size_mjpg > kBackSearchSize) {
+    if (ScanEOI(src_mjpg + src_size_mjpg - kBackSearchSize, kBackSearchSize)) {
+      return LIBYUV_TRUE;  // Success: Valid jpeg.
+    }
+    // Reduce search size for forward search.
+    src_size_mjpg = src_size_mjpg - kBackSearchSize + 1;
+  }
+  // Step over SOI marker and scan for EOI.
+  return ScanEOI(src_mjpg + 2, src_size_mjpg - 2);
+}
+
+#ifdef __cplusplus
+}  // extern "C"
+}  // namespace libyuv
+#endif
diff --git a/3rdparty/libyuv/src/source/planar_functions.cc b/3rdparty/libyuv/src/source/planar_functions.cc
new file mode 100644
index 00000000..169d4a8f
--- /dev/null
+++ b/3rdparty/libyuv/src/source/planar_functions.cc
@@ -0,0 +1,5354 @@
+/*
+ *  Copyright 2011 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include "libyuv/planar_functions.h"
+
+#include <assert.h>
+#include <string.h>  // for memset()
+
+#include "libyuv/cpu_id.h"
+#ifdef HAVE_JPEG
+#include "libyuv/mjpeg_decoder.h"
+#endif
+#include "libyuv/row.h"
+#include "libyuv/scale_row.h"  // for ScaleRowDown2
+
+#ifdef __cplusplus
+namespace libyuv {
+extern "C" {
+#endif
+
+// Copy a plane of data
+LIBYUV_API
+void CopyPlane(const uint8_t* src_y,
+               int src_stride_y,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               int width,
+               int height) {
+  int y;
+  void (*CopyRow)(const uint8_t* src, uint8_t* dst, int width) = CopyRow_C;
+  if (width <= 0 || height == 0) {
+    return;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    dst_y = dst_y + (height - 1) * dst_stride_y;
+    dst_stride_y = -dst_stride_y;
+  }
+  // Coalesce rows.
+  if (src_stride_y == width && dst_stride_y == width) {
+    width *= height;
+    height = 1;
+    src_stride_y = dst_stride_y = 0;
+  }
+  // Nothing to do.
+  if (src_y == dst_y && src_stride_y == dst_stride_y) {
+    return;
+  }
+
+#if defined(HAS_COPYROW_SSE2)
+  if (TestCpuFlag(kCpuHasSSE2)) {
+    CopyRow = IS_ALIGNED(width, 32) ? CopyRow_SSE2 : CopyRow_Any_SSE2;
+  }
+#endif
+#if defined(HAS_COPYROW_AVX)
+  if (TestCpuFlag(kCpuHasAVX)) {
+    CopyRow = IS_ALIGNED(width, 64) ? CopyRow_AVX : CopyRow_Any_AVX;
+  }
+#endif
+#if defined(HAS_COPYROW_ERMS)
+  if (TestCpuFlag(kCpuHasERMS)) {
+    CopyRow = CopyRow_ERMS;
+  }
+#endif
+#if defined(HAS_COPYROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    CopyRow = IS_ALIGNED(width, 32) ? CopyRow_NEON : CopyRow_Any_NEON;
+  }
+#endif
+
+  // Copy plane
+  for (y = 0; y < height; ++y) {
+    CopyRow(src_y, dst_y, width);
+    src_y += src_stride_y;
+    dst_y += dst_stride_y;
+  }
+}
+
+LIBYUV_API
+void CopyPlane_16(const uint16_t* src_y,
+                  int src_stride_y,
+                  uint16_t* dst_y,
+                  int dst_stride_y,
+                  int width,
+                  int height) {
+  CopyPlane((const uint8_t*)src_y, src_stride_y * 2, (uint8_t*)dst_y,
+            dst_stride_y * 2, width * 2, height);
+}
+
+// Convert a plane of 16 bit data to 8 bit
+LIBYUV_API
+void Convert16To8Plane(const uint16_t* src_y,
+                       int src_stride_y,
+                       uint8_t* dst_y,
+                       int dst_stride_y,
+                       int scale,  // 16384 for 10 bits
+                       int width,
+                       int height) {
+  int y;
+  void (*Convert16To8Row)(const uint16_t* src_y, uint8_t* dst_y, int scale,
+                          int width) = Convert16To8Row_C;
+
+  if (width <= 0 || height == 0) {
+    return;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    dst_y = dst_y + (height - 1) * dst_stride_y;
+    dst_stride_y = -dst_stride_y;
+  }
+  // Coalesce rows.
+  if (src_stride_y == width && dst_stride_y == width) {
+    width *= height;
+    height = 1;
+    src_stride_y = dst_stride_y = 0;
+  }
+#if defined(HAS_CONVERT16TO8ROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    Convert16To8Row = Convert16To8Row_Any_NEON;
+    if (IS_ALIGNED(width, 16)) {
+      Convert16To8Row = Convert16To8Row_NEON;
+    }
+  }
+#endif
+#if defined(HAS_CONVERT16TO8ROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    Convert16To8Row = Convert16To8Row_Any_SSSE3;
+    if (IS_ALIGNED(width, 16)) {
+      Convert16To8Row = Convert16To8Row_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_CONVERT16TO8ROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    Convert16To8Row = Convert16To8Row_Any_AVX2;
+    if (IS_ALIGNED(width, 32)) {
+      Convert16To8Row = Convert16To8Row_AVX2;
+    }
+  }
+#endif
+
+  // Convert plane
+  for (y = 0; y < height; ++y) {
+    Convert16To8Row(src_y, dst_y, scale, width);
+    src_y += src_stride_y;
+    dst_y += dst_stride_y;
+  }
+}
+
+// Convert a plane of 8 bit data to 16 bit
+LIBYUV_API
+void Convert8To16Plane(const uint8_t* src_y,
+                       int src_stride_y,
+                       uint16_t* dst_y,
+                       int dst_stride_y,
+                       int scale,  // 16384 for 10 bits
+                       int width,
+                       int height) {
+  int y;
+  void (*Convert8To16Row)(const uint8_t* src_y, uint16_t* dst_y, int scale,
+                          int width) = Convert8To16Row_C;
+
+  if (width <= 0 || height == 0) {
+    return;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    dst_y = dst_y + (height - 1) * dst_stride_y;
+    dst_stride_y = -dst_stride_y;
+  }
+  // Coalesce rows.
+  if (src_stride_y == width && dst_stride_y == width) {
+    width *= height;
+    height = 1;
+    src_stride_y = dst_stride_y = 0;
+  }
+#if defined(HAS_CONVERT8TO16ROW_SSE2)
+  if (TestCpuFlag(kCpuHasSSE2)) {
+    Convert8To16Row = Convert8To16Row_Any_SSE2;
+    if (IS_ALIGNED(width, 16)) {
+      Convert8To16Row = Convert8To16Row_SSE2;
+    }
+  }
+#endif
+#if defined(HAS_CONVERT8TO16ROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    Convert8To16Row = Convert8To16Row_Any_AVX2;
+    if (IS_ALIGNED(width, 32)) {
+      Convert8To16Row = Convert8To16Row_AVX2;
+    }
+  }
+#endif
+
+  // Convert plane
+  for (y = 0; y < height; ++y) {
+    Convert8To16Row(src_y, dst_y, scale, width);
+    src_y += src_stride_y;
+    dst_y += dst_stride_y;
+  }
+}
+
+// Copy I422.
+LIBYUV_API
+int I422Copy(const uint8_t* src_y,
+             int src_stride_y,
+             const uint8_t* src_u,
+             int src_stride_u,
+             const uint8_t* src_v,
+             int src_stride_v,
+             uint8_t* dst_y,
+             int dst_stride_y,
+             uint8_t* dst_u,
+             int dst_stride_u,
+             uint8_t* dst_v,
+             int dst_stride_v,
+             int width,
+             int height) {
+  int halfwidth = (width + 1) >> 1;
+
+  if ((!src_y && dst_y) || !src_u || !src_v || !dst_u || !dst_v || width <= 0 ||
+      height == 0) {
+    return -1;
+  }
+
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    src_y = src_y + (height - 1) * src_stride_y;
+    src_u = src_u + (height - 1) * src_stride_u;
+    src_v = src_v + (height - 1) * src_stride_v;
+    src_stride_y = -src_stride_y;
+    src_stride_u = -src_stride_u;
+    src_stride_v = -src_stride_v;
+  }
+
+  if (dst_y) {
+    CopyPlane(src_y, src_stride_y, dst_y, dst_stride_y, width, height);
+  }
+  CopyPlane(src_u, src_stride_u, dst_u, dst_stride_u, halfwidth, height);
+  CopyPlane(src_v, src_stride_v, dst_v, dst_stride_v, halfwidth, height);
+  return 0;
+}
+
+// Copy I444.
+LIBYUV_API
+int I444Copy(const uint8_t* src_y,
+             int src_stride_y,
+             const uint8_t* src_u,
+             int src_stride_u,
+             const uint8_t* src_v,
+             int src_stride_v,
+             uint8_t* dst_y,
+             int dst_stride_y,
+             uint8_t* dst_u,
+             int dst_stride_u,
+             uint8_t* dst_v,
+             int dst_stride_v,
+             int width,
+             int height) {
+  if ((!src_y && dst_y) || !src_u || !src_v || !dst_u || !dst_v || width <= 0 ||
+      height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    src_y = src_y + (height - 1) * src_stride_y;
+    src_u = src_u + (height - 1) * src_stride_u;
+    src_v = src_v + (height - 1) * src_stride_v;
+    src_stride_y = -src_stride_y;
+    src_stride_u = -src_stride_u;
+    src_stride_v = -src_stride_v;
+  }
+
+  if (dst_y) {
+    CopyPlane(src_y, src_stride_y, dst_y, dst_stride_y, width, height);
+  }
+  CopyPlane(src_u, src_stride_u, dst_u, dst_stride_u, width, height);
+  CopyPlane(src_v, src_stride_v, dst_v, dst_stride_v, width, height);
+  return 0;
+}
+
+// Copy I210.
+LIBYUV_API
+int I210Copy(const uint16_t* src_y,
+             int src_stride_y,
+             const uint16_t* src_u,
+             int src_stride_u,
+             const uint16_t* src_v,
+             int src_stride_v,
+             uint16_t* dst_y,
+             int dst_stride_y,
+             uint16_t* dst_u,
+             int dst_stride_u,
+             uint16_t* dst_v,
+             int dst_stride_v,
+             int width,
+             int height) {
+  int halfwidth = (width + 1) >> 1;
+
+  if ((!src_y && dst_y) || !src_u || !src_v || !dst_u || !dst_v || width <= 0 ||
+      height == 0) {
+    return -1;
+  }
+
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    src_y = src_y + (height - 1) * src_stride_y;
+    src_u = src_u + (height - 1) * src_stride_u;
+    src_v = src_v + (height - 1) * src_stride_v;
+    src_stride_y = -src_stride_y;
+    src_stride_u = -src_stride_u;
+    src_stride_v = -src_stride_v;
+  }
+
+  if (dst_y) {
+    CopyPlane_16(src_y, src_stride_y, dst_y, dst_stride_y, width, height);
+  }
+  // Copy UV planes.
+  CopyPlane_16(src_u, src_stride_u, dst_u, dst_stride_u, halfwidth, height);
+  CopyPlane_16(src_v, src_stride_v, dst_v, dst_stride_v, halfwidth, height);
+  return 0;
+}
+
+// Copy I400.
+LIBYUV_API
+int I400ToI400(const uint8_t* src_y,
+               int src_stride_y,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               int width,
+               int height) {
+  if (!src_y || !dst_y || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    src_y = src_y + (height - 1) * src_stride_y;
+    src_stride_y = -src_stride_y;
+  }
+  CopyPlane(src_y, src_stride_y, dst_y, dst_stride_y, width, height);
+  return 0;
+}
+
+// Convert I420 to I400.
+LIBYUV_API
+int I420ToI400(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               int width,
+               int height) {
+  (void)src_u;
+  (void)src_stride_u;
+  (void)src_v;
+  (void)src_stride_v;
+  if (!src_y || !dst_y || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    src_y = src_y + (height - 1) * src_stride_y;
+    src_stride_y = -src_stride_y;
+  }
+
+  CopyPlane(src_y, src_stride_y, dst_y, dst_stride_y, width, height);
+  return 0;
+}
+
+// Copy NV12. Supports inverting.
+int NV12Copy(const uint8_t* src_y,
+             int src_stride_y,
+             const uint8_t* src_uv,
+             int src_stride_uv,
+             uint8_t* dst_y,
+             int dst_stride_y,
+             uint8_t* dst_uv,
+             int dst_stride_uv,
+             int width,
+             int height) {
+  int halfwidth = (width + 1) >> 1;
+  int halfheight = (height + 1) >> 1;
+
+  if (!src_y || !dst_y || !src_uv || !dst_uv || width <= 0 || height == 0) {
+    return -1;
+  }
+
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    halfheight = (height + 1) >> 1;
+    src_y = src_y + (height - 1) * src_stride_y;
+    src_uv = src_uv + (halfheight - 1) * src_stride_uv;
+    src_stride_y = -src_stride_y;
+    src_stride_uv = -src_stride_uv;
+  }
+  CopyPlane(src_y, src_stride_y, dst_y, dst_stride_y, width, height);
+  CopyPlane(src_uv, src_stride_uv, dst_uv, dst_stride_uv, halfwidth * 2,
+            halfheight);
+  return 0;
+}
+
+// Copy NV21. Supports inverting.
+int NV21Copy(const uint8_t* src_y,
+             int src_stride_y,
+             const uint8_t* src_vu,
+             int src_stride_vu,
+             uint8_t* dst_y,
+             int dst_stride_y,
+             uint8_t* dst_vu,
+             int dst_stride_vu,
+             int width,
+             int height) {
+  return NV12Copy(src_y, src_stride_y, src_vu, src_stride_vu, dst_y,
+                  dst_stride_y, dst_vu, dst_stride_vu, width, height);
+}
+
+// Support function for NV12 etc UV channels.
+// Width and height are plane sizes (typically half pixel width).
+LIBYUV_API
+void SplitUVPlane(const uint8_t* src_uv,
+                  int src_stride_uv,
+                  uint8_t* dst_u,
+                  int dst_stride_u,
+                  uint8_t* dst_v,
+                  int dst_stride_v,
+                  int width,
+                  int height) {
+  int y;
+  void (*SplitUVRow)(const uint8_t* src_uv, uint8_t* dst_u, uint8_t* dst_v,
+                     int width) = SplitUVRow_C;
+  if (width <= 0 || height == 0) {
+    return;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    dst_u = dst_u + (height - 1) * dst_stride_u;
+    dst_v = dst_v + (height - 1) * dst_stride_v;
+    dst_stride_u = -dst_stride_u;
+    dst_stride_v = -dst_stride_v;
+  }
+  // Coalesce rows.
+  if (src_stride_uv == width * 2 && dst_stride_u == width &&
+      dst_stride_v == width) {
+    width *= height;
+    height = 1;
+    src_stride_uv = dst_stride_u = dst_stride_v = 0;
+  }
+#if defined(HAS_SPLITUVROW_SSE2)
+  if (TestCpuFlag(kCpuHasSSE2)) {
+    SplitUVRow = SplitUVRow_Any_SSE2;
+    if (IS_ALIGNED(width, 16)) {
+      SplitUVRow = SplitUVRow_SSE2;
+    }
+  }
+#endif
+#if defined(HAS_SPLITUVROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    SplitUVRow = SplitUVRow_Any_AVX2;
+    if (IS_ALIGNED(width, 32)) {
+      SplitUVRow = SplitUVRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_SPLITUVROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    SplitUVRow = SplitUVRow_Any_NEON;
+    if (IS_ALIGNED(width, 16)) {
+      SplitUVRow = SplitUVRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_SPLITUVROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    SplitUVRow = SplitUVRow_Any_MSA;
+    if (IS_ALIGNED(width, 32)) {
+      SplitUVRow = SplitUVRow_MSA;
+    }
+  }
+#endif
+#if defined(HAS_SPLITUVROW_LSX)
+  if (TestCpuFlag(kCpuHasLSX)) {
+    SplitUVRow = SplitUVRow_Any_LSX;
+    if (IS_ALIGNED(width, 32)) {
+      SplitUVRow = SplitUVRow_LSX;
+    }
+  }
+#endif
+
+  for (y = 0; y < height; ++y) {
+    // Copy a row of UV.
+    SplitUVRow(src_uv, dst_u, dst_v, width);
+    dst_u += dst_stride_u;
+    dst_v += dst_stride_v;
+    src_uv += src_stride_uv;
+  }
+}
+
+LIBYUV_API
+void MergeUVPlane(const uint8_t* src_u,
+                  int src_stride_u,
+                  const uint8_t* src_v,
+                  int src_stride_v,
+                  uint8_t* dst_uv,
+                  int dst_stride_uv,
+                  int width,
+                  int height) {
+  int y;
+  void (*MergeUVRow)(const uint8_t* src_u, const uint8_t* src_v,
+                     uint8_t* dst_uv, int width) = MergeUVRow_C;
+  if (width <= 0 || height == 0) {
+    return;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    dst_uv = dst_uv + (height - 1) * dst_stride_uv;
+    dst_stride_uv = -dst_stride_uv;
+  }
+  // Coalesce rows.
+  if (src_stride_u == width && src_stride_v == width &&
+      dst_stride_uv == width * 2) {
+    width *= height;
+    height = 1;
+    src_stride_u = src_stride_v = dst_stride_uv = 0;
+  }
+#if defined(HAS_MERGEUVROW_SSE2)
+  if (TestCpuFlag(kCpuHasSSE2)) {
+    MergeUVRow = MergeUVRow_Any_SSE2;
+    if (IS_ALIGNED(width, 16)) {
+      MergeUVRow = MergeUVRow_SSE2;
+    }
+  }
+#endif
+#if defined(HAS_MERGEUVROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    MergeUVRow = MergeUVRow_Any_AVX2;
+    if (IS_ALIGNED(width, 32)) {
+      MergeUVRow = MergeUVRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_MERGEUVROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    MergeUVRow = MergeUVRow_Any_NEON;
+    if (IS_ALIGNED(width, 16)) {
+      MergeUVRow = MergeUVRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_MERGEUVROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    MergeUVRow = MergeUVRow_Any_MSA;
+    if (IS_ALIGNED(width, 16)) {
+      MergeUVRow = MergeUVRow_MSA;
+    }
+  }
+#endif
+#if defined(HAS_MERGEUVROW_LSX)
+  if (TestCpuFlag(kCpuHasLSX)) {
+    MergeUVRow = MergeUVRow_Any_LSX;
+    if (IS_ALIGNED(width, 16)) {
+      MergeUVRow = MergeUVRow_LSX;
+    }
+  }
+#endif
+
+  for (y = 0; y < height; ++y) {
+    // Merge a row of U and V into a row of UV.
+    MergeUVRow(src_u, src_v, dst_uv, width);
+    src_u += src_stride_u;
+    src_v += src_stride_v;
+    dst_uv += dst_stride_uv;
+  }
+}
+
+// Support function for P010 etc UV channels.
+// Width and height are plane sizes (typically half pixel width).
+LIBYUV_API
+void SplitUVPlane_16(const uint16_t* src_uv,
+                     int src_stride_uv,
+                     uint16_t* dst_u,
+                     int dst_stride_u,
+                     uint16_t* dst_v,
+                     int dst_stride_v,
+                     int width,
+                     int height,
+                     int depth) {
+  int y;
+  void (*SplitUVRow_16)(const uint16_t* src_uv, uint16_t* dst_u,
+                        uint16_t* dst_v, int depth, int width) =
+      SplitUVRow_16_C;
+  if (width <= 0 || height == 0) {
+    return;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    dst_u = dst_u + (height - 1) * dst_stride_u;
+    dst_v = dst_v + (height - 1) * dst_stride_v;
+    dst_stride_u = -dst_stride_u;
+    dst_stride_v = -dst_stride_v;
+  }
+  // Coalesce rows.
+  if (src_stride_uv == width * 2 && dst_stride_u == width &&
+      dst_stride_v == width) {
+    width *= height;
+    height = 1;
+    src_stride_uv = dst_stride_u = dst_stride_v = 0;
+  }
+#if defined(HAS_SPLITUVROW_16_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    SplitUVRow_16 = SplitUVRow_16_Any_AVX2;
+    if (IS_ALIGNED(width, 16)) {
+      SplitUVRow_16 = SplitUVRow_16_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_SPLITUVROW_16_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    SplitUVRow_16 = SplitUVRow_16_Any_NEON;
+    if (IS_ALIGNED(width, 8)) {
+      SplitUVRow_16 = SplitUVRow_16_NEON;
+    }
+  }
+#endif
+
+  for (y = 0; y < height; ++y) {
+    // Copy a row of UV.
+    SplitUVRow_16(src_uv, dst_u, dst_v, depth, width);
+    dst_u += dst_stride_u;
+    dst_v += dst_stride_v;
+    src_uv += src_stride_uv;
+  }
+}
+
+LIBYUV_API
+void MergeUVPlane_16(const uint16_t* src_u,
+                     int src_stride_u,
+                     const uint16_t* src_v,
+                     int src_stride_v,
+                     uint16_t* dst_uv,
+                     int dst_stride_uv,
+                     int width,
+                     int height,
+                     int depth) {
+  int y;
+  void (*MergeUVRow_16)(const uint16_t* src_u, const uint16_t* src_v,
+                        uint16_t* dst_uv, int depth, int width) =
+      MergeUVRow_16_C;
+  assert(depth >= 8);
+  assert(depth <= 16);
+  if (width <= 0 || height == 0) {
+    return;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    dst_uv = dst_uv + (height - 1) * dst_stride_uv;
+    dst_stride_uv = -dst_stride_uv;
+  }
+  // Coalesce rows.
+  if (src_stride_u == width && src_stride_v == width &&
+      dst_stride_uv == width * 2) {
+    width *= height;
+    height = 1;
+    src_stride_u = src_stride_v = dst_stride_uv = 0;
+  }
+#if defined(HAS_MERGEUVROW_16_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    MergeUVRow_16 = MergeUVRow_16_Any_AVX2;
+    if (IS_ALIGNED(width, 16)) {
+      MergeUVRow_16 = MergeUVRow_16_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_MERGEUVROW_16_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    MergeUVRow_16 = MergeUVRow_16_Any_NEON;
+    if (IS_ALIGNED(width, 8)) {
+      MergeUVRow_16 = MergeUVRow_16_NEON;
+    }
+  }
+#endif
+
+  for (y = 0; y < height; ++y) {
+    // Merge a row of U and V into a row of UV.
+    MergeUVRow_16(src_u, src_v, dst_uv, depth, width);
+    src_u += src_stride_u;
+    src_v += src_stride_v;
+    dst_uv += dst_stride_uv;
+  }
+}
+
+// Convert plane from lsb to msb
+LIBYUV_API
+void ConvertToMSBPlane_16(const uint16_t* src_y,
+                          int src_stride_y,
+                          uint16_t* dst_y,
+                          int dst_stride_y,
+                          int width,
+                          int height,
+                          int depth) {
+  int y;
+  int scale = 1 << (16 - depth);
+  void (*MultiplyRow_16)(const uint16_t* src_y, uint16_t* dst_y, int scale,
+                         int width) = MultiplyRow_16_C;
+  if (width <= 0 || height == 0) {
+    return;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    dst_y = dst_y + (height - 1) * dst_stride_y;
+    dst_stride_y = -dst_stride_y;
+  }
+  // Coalesce rows.
+  if (src_stride_y == width && dst_stride_y == width) {
+    width *= height;
+    height = 1;
+    src_stride_y = dst_stride_y = 0;
+  }
+
+#if defined(HAS_MULTIPLYROW_16_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    MultiplyRow_16 = MultiplyRow_16_Any_AVX2;
+    if (IS_ALIGNED(width, 32)) {
+      MultiplyRow_16 = MultiplyRow_16_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_MULTIPLYROW_16_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    MultiplyRow_16 = MultiplyRow_16_Any_NEON;
+    if (IS_ALIGNED(width, 16)) {
+      MultiplyRow_16 = MultiplyRow_16_NEON;
+    }
+  }
+#endif
+
+  for (y = 0; y < height; ++y) {
+    MultiplyRow_16(src_y, dst_y, scale, width);
+    src_y += src_stride_y;
+    dst_y += dst_stride_y;
+  }
+}
+
+// Convert plane from msb to lsb
+LIBYUV_API
+void ConvertToLSBPlane_16(const uint16_t* src_y,
+                          int src_stride_y,
+                          uint16_t* dst_y,
+                          int dst_stride_y,
+                          int width,
+                          int height,
+                          int depth) {
+  int y;
+  int scale = 1 << depth;
+  void (*DivideRow)(const uint16_t* src_y, uint16_t* dst_y, int scale,
+                    int width) = DivideRow_16_C;
+  if (width <= 0 || height == 0) {
+    return;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    dst_y = dst_y + (height - 1) * dst_stride_y;
+    dst_stride_y = -dst_stride_y;
+  }
+  // Coalesce rows.
+  if (src_stride_y == width && dst_stride_y == width) {
+    width *= height;
+    height = 1;
+    src_stride_y = dst_stride_y = 0;
+  }
+
+#if defined(HAS_DIVIDEROW_16_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    DivideRow = DivideRow_16_Any_AVX2;
+    if (IS_ALIGNED(width, 32)) {
+      DivideRow = DivideRow_16_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_DIVIDEROW_16_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    DivideRow = DivideRow_16_Any_NEON;
+    if (IS_ALIGNED(width, 16)) {
+      DivideRow = DivideRow_16_NEON;
+    }
+  }
+#endif
+
+  for (y = 0; y < height; ++y) {
+    DivideRow(src_y, dst_y, scale, width);
+    src_y += src_stride_y;
+    dst_y += dst_stride_y;
+  }
+}
+
+// Swap U and V channels in interleaved UV plane.
+LIBYUV_API
+void SwapUVPlane(const uint8_t* src_uv,
+                 int src_stride_uv,
+                 uint8_t* dst_vu,
+                 int dst_stride_vu,
+                 int width,
+                 int height) {
+  int y;
+  void (*SwapUVRow)(const uint8_t* src_uv, uint8_t* dst_vu, int width) =
+      SwapUVRow_C;
+  if (width <= 0 || height == 0) {
+    return;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    src_uv = src_uv + (height - 1) * src_stride_uv;
+    src_stride_uv = -src_stride_uv;
+  }
+  // Coalesce rows.
+  if (src_stride_uv == width * 2 && dst_stride_vu == width * 2) {
+    width *= height;
+    height = 1;
+    src_stride_uv = dst_stride_vu = 0;
+  }
+
+#if defined(HAS_SWAPUVROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    SwapUVRow = SwapUVRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 16)) {
+      SwapUVRow = SwapUVRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_SWAPUVROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    SwapUVRow = SwapUVRow_Any_AVX2;
+    if (IS_ALIGNED(width, 32)) {
+      SwapUVRow = SwapUVRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_SWAPUVROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    SwapUVRow = SwapUVRow_Any_NEON;
+    if (IS_ALIGNED(width, 16)) {
+      SwapUVRow = SwapUVRow_NEON;
+    }
+  }
+#endif
+
+  for (y = 0; y < height; ++y) {
+    SwapUVRow(src_uv, dst_vu, width);
+    src_uv += src_stride_uv;
+    dst_vu += dst_stride_vu;
+  }
+}
+
+// Convert NV21 to NV12.
+LIBYUV_API
+int NV21ToNV12(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_vu,
+               int src_stride_vu,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_uv,
+               int dst_stride_uv,
+               int width,
+               int height) {
+  int halfwidth = (width + 1) >> 1;
+  int halfheight = (height + 1) >> 1;
+
+  if (!src_vu || !dst_uv || width <= 0 || height == 0) {
+    return -1;
+  }
+
+  if (dst_y) {
+    CopyPlane(src_y, src_stride_y, dst_y, dst_stride_y, width, height);
+  }
+
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    halfheight = (height + 1) >> 1;
+    src_vu = src_vu + (halfheight - 1) * src_stride_vu;
+    src_stride_vu = -src_stride_vu;
+  }
+
+  SwapUVPlane(src_vu, src_stride_vu, dst_uv, dst_stride_uv, halfwidth,
+              halfheight);
+  return 0;
+}
+
+// Detile a plane of data
+// tile width is 16 and assumed.
+// tile_height is 16 or 32 for MM21.
+// src_stride_y is bytes per row of source ignoring tiling. e.g. 640
+// TODO: More detile row functions.
+
+LIBYUV_API
+void DetilePlane(const uint8_t* src_y,
+                 int src_stride_y,
+                 uint8_t* dst_y,
+                 int dst_stride_y,
+                 int width,
+                 int height,
+                 int tile_height) {
+  const ptrdiff_t src_tile_stride = 16 * tile_height;
+  int y;
+  void (*DetileRow)(const uint8_t* src, ptrdiff_t src_tile_stride, uint8_t* dst,
+                    int width) = DetileRow_C;
+  assert(src_stride_y >= 0);
+  assert(tile_height > 0);
+  assert(src_stride_y > 0);
+
+  if (width <= 0 || height == 0) {
+    return;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    dst_y = dst_y + (height - 1) * dst_stride_y;
+    dst_stride_y = -dst_stride_y;
+  }
+
+#if defined(HAS_DETILEROW_SSE2)
+  if (TestCpuFlag(kCpuHasSSE2)) {
+    DetileRow = DetileRow_Any_SSE2;
+    if (IS_ALIGNED(width, 16)) {
+      DetileRow = DetileRow_SSE2;
+    }
+  }
+#endif
+#if defined(HAS_DETILEROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    DetileRow = DetileRow_Any_NEON;
+    if (IS_ALIGNED(width, 16)) {
+      DetileRow = DetileRow_NEON;
+    }
+  }
+#endif
+
+  // Detile plane
+  for (y = 0; y < height; ++y) {
+    DetileRow(src_y, src_tile_stride, dst_y, width);
+    dst_y += dst_stride_y;
+    src_y += 16;
+    // Advance to next row of tiles.
+    if ((y & (tile_height - 1)) == (tile_height - 1)) {
+      src_y = src_y - src_tile_stride + src_stride_y * tile_height;
+    }
+  }
+}
+
+LIBYUV_API
+void DetileSplitUVPlane(const uint8_t* src_uv,
+                        int src_stride_uv,
+                        uint8_t* dst_u,
+                        int dst_stride_u,
+                        uint8_t* dst_v,
+                        int dst_stride_v,
+                        int width,
+                        int height,
+                        int tile_height) {
+  const ptrdiff_t src_tile_stride = 16 * tile_height;
+  int y;
+  void (*DetileSplitUVRow)(const uint8_t* src, ptrdiff_t src_tile_stride,
+                           uint8_t* dst_u, uint8_t* dst_v, int width) =
+      DetileSplitUVRow_C;
+  assert(src_stride_uv >= 0);
+  assert(tile_height > 0);
+  assert(src_stride_uv > 0);
+
+  if (width <= 0 || height == 0) {
+    return;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    dst_u = dst_u + (height - 1) * dst_stride_u;
+    dst_stride_u = -dst_stride_u;
+    dst_v = dst_v + (height - 1) * dst_stride_v;
+    dst_stride_v = -dst_stride_v;
+  }
+
+#if defined(HAS_DETILESPLITUVROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    DetileSplitUVRow = DetileSplitUVRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 16)) {
+      DetileSplitUVRow = DetileSplitUVRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_DETILESPLITUVROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    DetileSplitUVRow = DetileSplitUVRow_Any_NEON;
+    if (IS_ALIGNED(width, 16)) {
+      DetileSplitUVRow = DetileSplitUVRow_NEON;
+    }
+  }
+#endif
+
+  // Detile plane
+  for (y = 0; y < height; ++y) {
+    DetileSplitUVRow(src_uv, src_tile_stride, dst_u, dst_v, width);
+    dst_u += dst_stride_u;
+    dst_v += dst_stride_v;
+    src_uv += 16;
+    // Advance to next row of tiles.
+    if ((y & (tile_height - 1)) == (tile_height - 1)) {
+      src_uv = src_uv - src_tile_stride + src_stride_uv * tile_height;
+    }
+  }
+}
+
+// Support function for NV12 etc RGB channels.
+// Width and height are plane sizes (typically half pixel width).
+LIBYUV_API
+void SplitRGBPlane(const uint8_t* src_rgb,
+                   int src_stride_rgb,
+                   uint8_t* dst_r,
+                   int dst_stride_r,
+                   uint8_t* dst_g,
+                   int dst_stride_g,
+                   uint8_t* dst_b,
+                   int dst_stride_b,
+                   int width,
+                   int height) {
+  int y;
+  void (*SplitRGBRow)(const uint8_t* src_rgb, uint8_t* dst_r, uint8_t* dst_g,
+                      uint8_t* dst_b, int width) = SplitRGBRow_C;
+  if (width <= 0 || height == 0) {
+    return;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    dst_r = dst_r + (height - 1) * dst_stride_r;
+    dst_g = dst_g + (height - 1) * dst_stride_g;
+    dst_b = dst_b + (height - 1) * dst_stride_b;
+    dst_stride_r = -dst_stride_r;
+    dst_stride_g = -dst_stride_g;
+    dst_stride_b = -dst_stride_b;
+  }
+  // Coalesce rows.
+  if (src_stride_rgb == width * 3 && dst_stride_r == width &&
+      dst_stride_g == width && dst_stride_b == width) {
+    width *= height;
+    height = 1;
+    src_stride_rgb = dst_stride_r = dst_stride_g = dst_stride_b = 0;
+  }
+#if defined(HAS_SPLITRGBROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    SplitRGBRow = SplitRGBRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 16)) {
+      SplitRGBRow = SplitRGBRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_SPLITRGBROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    SplitRGBRow = SplitRGBRow_Any_NEON;
+    if (IS_ALIGNED(width, 16)) {
+      SplitRGBRow = SplitRGBRow_NEON;
+    }
+  }
+#endif
+
+  for (y = 0; y < height; ++y) {
+    // Copy a row of RGB.
+    SplitRGBRow(src_rgb, dst_r, dst_g, dst_b, width);
+    dst_r += dst_stride_r;
+    dst_g += dst_stride_g;
+    dst_b += dst_stride_b;
+    src_rgb += src_stride_rgb;
+  }
+}
+
+LIBYUV_API
+void MergeRGBPlane(const uint8_t* src_r,
+                   int src_stride_r,
+                   const uint8_t* src_g,
+                   int src_stride_g,
+                   const uint8_t* src_b,
+                   int src_stride_b,
+                   uint8_t* dst_rgb,
+                   int dst_stride_rgb,
+                   int width,
+                   int height) {
+  int y;
+  void (*MergeRGBRow)(const uint8_t* src_r, const uint8_t* src_g,
+                      const uint8_t* src_b, uint8_t* dst_rgb, int width) =
+      MergeRGBRow_C;
+  if (width <= 0 || height == 0) {
+    return;
+  }
+  // Coalesce rows.
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    dst_rgb = dst_rgb + (height - 1) * dst_stride_rgb;
+    dst_stride_rgb = -dst_stride_rgb;
+  }
+  // Coalesce rows.
+  if (src_stride_r == width && src_stride_g == width && src_stride_b == width &&
+      dst_stride_rgb == width * 3) {
+    width *= height;
+    height = 1;
+    src_stride_r = src_stride_g = src_stride_b = dst_stride_rgb = 0;
+  }
+#if defined(HAS_MERGERGBROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    MergeRGBRow = MergeRGBRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 16)) {
+      MergeRGBRow = MergeRGBRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_MERGERGBROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    MergeRGBRow = MergeRGBRow_Any_NEON;
+    if (IS_ALIGNED(width, 16)) {
+      MergeRGBRow = MergeRGBRow_NEON;
+    }
+  }
+#endif
+
+  for (y = 0; y < height; ++y) {
+    // Merge a row of U and V into a row of RGB.
+    MergeRGBRow(src_r, src_g, src_b, dst_rgb, width);
+    src_r += src_stride_r;
+    src_g += src_stride_g;
+    src_b += src_stride_b;
+    dst_rgb += dst_stride_rgb;
+  }
+}
+
+LIBYUV_NOINLINE
+void SplitARGBPlaneAlpha(const uint8_t* src_argb,
+                         int src_stride_argb,
+                         uint8_t* dst_r,
+                         int dst_stride_r,
+                         uint8_t* dst_g,
+                         int dst_stride_g,
+                         uint8_t* dst_b,
+                         int dst_stride_b,
+                         uint8_t* dst_a,
+                         int dst_stride_a,
+                         int width,
+                         int height) {
+  int y;
+  void (*SplitARGBRow)(const uint8_t* src_rgb, uint8_t* dst_r, uint8_t* dst_g,
+                       uint8_t* dst_b, uint8_t* dst_a, int width) =
+      SplitARGBRow_C;
+
+  assert(height > 0);
+
+  if (src_stride_argb == width * 4 && dst_stride_r == width &&
+      dst_stride_g == width && dst_stride_b == width && dst_stride_a == width) {
+    width *= height;
+    height = 1;
+    src_stride_argb = dst_stride_r = dst_stride_g = dst_stride_b =
+        dst_stride_a = 0;
+  }
+
+#if defined(HAS_SPLITARGBROW_SSE2)
+  if (TestCpuFlag(kCpuHasSSE2)) {
+    SplitARGBRow = SplitARGBRow_Any_SSE2;
+    if (IS_ALIGNED(width, 8)) {
+      SplitARGBRow = SplitARGBRow_SSE2;
+    }
+  }
+#endif
+#if defined(HAS_SPLITARGBROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    SplitARGBRow = SplitARGBRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 8)) {
+      SplitARGBRow = SplitARGBRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_SPLITARGBROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    SplitARGBRow = SplitARGBRow_Any_AVX2;
+    if (IS_ALIGNED(width, 16)) {
+      SplitARGBRow = SplitARGBRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_SPLITARGBROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    SplitARGBRow = SplitARGBRow_Any_NEON;
+    if (IS_ALIGNED(width, 16)) {
+      SplitARGBRow = SplitARGBRow_NEON;
+    }
+  }
+#endif
+
+  for (y = 0; y < height; ++y) {
+    SplitARGBRow(src_argb, dst_r, dst_g, dst_b, dst_a, width);
+    dst_r += dst_stride_r;
+    dst_g += dst_stride_g;
+    dst_b += dst_stride_b;
+    dst_a += dst_stride_a;
+    src_argb += src_stride_argb;
+  }
+}
+
+LIBYUV_NOINLINE
+void SplitARGBPlaneOpaque(const uint8_t* src_argb,
+                          int src_stride_argb,
+                          uint8_t* dst_r,
+                          int dst_stride_r,
+                          uint8_t* dst_g,
+                          int dst_stride_g,
+                          uint8_t* dst_b,
+                          int dst_stride_b,
+                          int width,
+                          int height) {
+  int y;
+  void (*SplitXRGBRow)(const uint8_t* src_rgb, uint8_t* dst_r, uint8_t* dst_g,
+                       uint8_t* dst_b, int width) = SplitXRGBRow_C;
+  assert(height > 0);
+
+  if (src_stride_argb == width * 4 && dst_stride_r == width &&
+      dst_stride_g == width && dst_stride_b == width) {
+    width *= height;
+    height = 1;
+    src_stride_argb = dst_stride_r = dst_stride_g = dst_stride_b = 0;
+  }
+
+#if defined(HAS_SPLITXRGBROW_SSE2)
+  if (TestCpuFlag(kCpuHasSSE2)) {
+    SplitXRGBRow = SplitXRGBRow_Any_SSE2;
+    if (IS_ALIGNED(width, 8)) {
+      SplitXRGBRow = SplitXRGBRow_SSE2;
+    }
+  }
+#endif
+#if defined(HAS_SPLITXRGBROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    SplitXRGBRow = SplitXRGBRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 8)) {
+      SplitXRGBRow = SplitXRGBRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_SPLITXRGBROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    SplitXRGBRow = SplitXRGBRow_Any_AVX2;
+    if (IS_ALIGNED(width, 16)) {
+      SplitXRGBRow = SplitXRGBRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_SPLITXRGBROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    SplitXRGBRow = SplitXRGBRow_Any_NEON;
+    if (IS_ALIGNED(width, 16)) {
+      SplitXRGBRow = SplitXRGBRow_NEON;
+    }
+  }
+#endif
+
+  for (y = 0; y < height; ++y) {
+    SplitXRGBRow(src_argb, dst_r, dst_g, dst_b, width);
+    dst_r += dst_stride_r;
+    dst_g += dst_stride_g;
+    dst_b += dst_stride_b;
+    src_argb += src_stride_argb;
+  }
+}
+
+LIBYUV_API
+void SplitARGBPlane(const uint8_t* src_argb,
+                    int src_stride_argb,
+                    uint8_t* dst_r,
+                    int dst_stride_r,
+                    uint8_t* dst_g,
+                    int dst_stride_g,
+                    uint8_t* dst_b,
+                    int dst_stride_b,
+                    uint8_t* dst_a,
+                    int dst_stride_a,
+                    int width,
+                    int height) {
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    dst_r = dst_r + (height - 1) * dst_stride_r;
+    dst_g = dst_g + (height - 1) * dst_stride_g;
+    dst_b = dst_b + (height - 1) * dst_stride_b;
+    dst_a = dst_a + (height - 1) * dst_stride_a;
+    dst_stride_r = -dst_stride_r;
+    dst_stride_g = -dst_stride_g;
+    dst_stride_b = -dst_stride_b;
+    dst_stride_a = -dst_stride_a;
+  }
+
+  if (dst_a == NULL) {
+    SplitARGBPlaneOpaque(src_argb, src_stride_argb, dst_r, dst_stride_r, dst_g,
+                         dst_stride_g, dst_b, dst_stride_b, width, height);
+  } else {
+    SplitARGBPlaneAlpha(src_argb, src_stride_argb, dst_r, dst_stride_r, dst_g,
+                        dst_stride_g, dst_b, dst_stride_b, dst_a, dst_stride_a,
+                        width, height);
+  }
+}
+
+LIBYUV_NOINLINE
+void MergeARGBPlaneAlpha(const uint8_t* src_r,
+                         int src_stride_r,
+                         const uint8_t* src_g,
+                         int src_stride_g,
+                         const uint8_t* src_b,
+                         int src_stride_b,
+                         const uint8_t* src_a,
+                         int src_stride_a,
+                         uint8_t* dst_argb,
+                         int dst_stride_argb,
+                         int width,
+                         int height) {
+  int y;
+  void (*MergeARGBRow)(const uint8_t* src_r, const uint8_t* src_g,
+                       const uint8_t* src_b, const uint8_t* src_a,
+                       uint8_t* dst_argb, int width) = MergeARGBRow_C;
+
+  assert(height > 0);
+
+  if (src_stride_r == width && src_stride_g == width && src_stride_b == width &&
+      src_stride_a == width && dst_stride_argb == width * 4) {
+    width *= height;
+    height = 1;
+    src_stride_r = src_stride_g = src_stride_b = src_stride_a =
+        dst_stride_argb = 0;
+  }
+#if defined(HAS_MERGEARGBROW_SSE2)
+  if (TestCpuFlag(kCpuHasSSE2)) {
+    MergeARGBRow = MergeARGBRow_Any_SSE2;
+    if (IS_ALIGNED(width, 8)) {
+      MergeARGBRow = MergeARGBRow_SSE2;
+    }
+  }
+#endif
+#if defined(HAS_MERGEARGBROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    MergeARGBRow = MergeARGBRow_Any_AVX2;
+    if (IS_ALIGNED(width, 16)) {
+      MergeARGBRow = MergeARGBRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_MERGEARGBROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    MergeARGBRow = MergeARGBRow_Any_NEON;
+    if (IS_ALIGNED(width, 16)) {
+      MergeARGBRow = MergeARGBRow_NEON;
+    }
+  }
+#endif
+
+  for (y = 0; y < height; ++y) {
+    MergeARGBRow(src_r, src_g, src_b, src_a, dst_argb, width);
+    src_r += src_stride_r;
+    src_g += src_stride_g;
+    src_b += src_stride_b;
+    src_a += src_stride_a;
+    dst_argb += dst_stride_argb;
+  }
+}
+
+LIBYUV_NOINLINE
+void MergeARGBPlaneOpaque(const uint8_t* src_r,
+                          int src_stride_r,
+                          const uint8_t* src_g,
+                          int src_stride_g,
+                          const uint8_t* src_b,
+                          int src_stride_b,
+                          uint8_t* dst_argb,
+                          int dst_stride_argb,
+                          int width,
+                          int height) {
+  int y;
+  void (*MergeXRGBRow)(const uint8_t* src_r, const uint8_t* src_g,
+                       const uint8_t* src_b, uint8_t* dst_argb, int width) =
+      MergeXRGBRow_C;
+
+  assert(height > 0);
+
+  if (src_stride_r == width && src_stride_g == width && src_stride_b == width &&
+      dst_stride_argb == width * 4) {
+    width *= height;
+    height = 1;
+    src_stride_r = src_stride_g = src_stride_b = dst_stride_argb = 0;
+  }
+#if defined(HAS_MERGEXRGBROW_SSE2)
+  if (TestCpuFlag(kCpuHasSSE2)) {
+    MergeXRGBRow = MergeXRGBRow_Any_SSE2;
+    if (IS_ALIGNED(width, 8)) {
+      MergeXRGBRow = MergeXRGBRow_SSE2;
+    }
+  }
+#endif
+#if defined(HAS_MERGEXRGBROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    MergeXRGBRow = MergeXRGBRow_Any_AVX2;
+    if (IS_ALIGNED(width, 16)) {
+      MergeXRGBRow = MergeXRGBRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_MERGEXRGBROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    MergeXRGBRow = MergeXRGBRow_Any_NEON;
+    if (IS_ALIGNED(width, 16)) {
+      MergeXRGBRow = MergeXRGBRow_NEON;
+    }
+  }
+#endif
+
+  for (y = 0; y < height; ++y) {
+    MergeXRGBRow(src_r, src_g, src_b, dst_argb, width);
+    src_r += src_stride_r;
+    src_g += src_stride_g;
+    src_b += src_stride_b;
+    dst_argb += dst_stride_argb;
+  }
+}
+
+LIBYUV_API
+void MergeARGBPlane(const uint8_t* src_r,
+                    int src_stride_r,
+                    const uint8_t* src_g,
+                    int src_stride_g,
+                    const uint8_t* src_b,
+                    int src_stride_b,
+                    const uint8_t* src_a,
+                    int src_stride_a,
+                    uint8_t* dst_argb,
+                    int dst_stride_argb,
+                    int width,
+                    int height) {
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    dst_argb = dst_argb + (height - 1) * dst_stride_argb;
+    dst_stride_argb = -dst_stride_argb;
+  }
+
+  if (src_a == NULL) {
+    MergeARGBPlaneOpaque(src_r, src_stride_r, src_g, src_stride_g, src_b,
+                         src_stride_b, dst_argb, dst_stride_argb, width,
+                         height);
+  } else {
+    MergeARGBPlaneAlpha(src_r, src_stride_r, src_g, src_stride_g, src_b,
+                        src_stride_b, src_a, src_stride_a, dst_argb,
+                        dst_stride_argb, width, height);
+  }
+}
+
+// TODO(yuan): Support 2 bit alpha channel.
+LIBYUV_API
+void MergeXR30Plane(const uint16_t* src_r,
+                    int src_stride_r,
+                    const uint16_t* src_g,
+                    int src_stride_g,
+                    const uint16_t* src_b,
+                    int src_stride_b,
+                    uint8_t* dst_ar30,
+                    int dst_stride_ar30,
+                    int width,
+                    int height,
+                    int depth) {
+  int y;
+  void (*MergeXR30Row)(const uint16_t* src_r, const uint16_t* src_g,
+                       const uint16_t* src_b, uint8_t* dst_ar30, int depth,
+                       int width) = MergeXR30Row_C;
+
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    dst_ar30 = dst_ar30 + (height - 1) * dst_stride_ar30;
+    dst_stride_ar30 = -dst_stride_ar30;
+  }
+  // Coalesce rows.
+  if (src_stride_r == width && src_stride_g == width && src_stride_b == width &&
+      dst_stride_ar30 == width * 4) {
+    width *= height;
+    height = 1;
+    src_stride_r = src_stride_g = src_stride_b = dst_stride_ar30 = 0;
+  }
+#if defined(HAS_MERGEXR30ROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    MergeXR30Row = MergeXR30Row_Any_AVX2;
+    if (IS_ALIGNED(width, 16)) {
+      MergeXR30Row = MergeXR30Row_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_MERGEXR30ROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    if (depth == 10) {
+      MergeXR30Row = MergeXR30Row_10_Any_NEON;
+      if (IS_ALIGNED(width, 8)) {
+        MergeXR30Row = MergeXR30Row_10_NEON;
+      }
+    } else {
+      MergeXR30Row = MergeXR30Row_Any_NEON;
+      if (IS_ALIGNED(width, 8)) {
+        MergeXR30Row = MergeXR30Row_NEON;
+      }
+    }
+  }
+#endif
+
+  for (y = 0; y < height; ++y) {
+    MergeXR30Row(src_r, src_g, src_b, dst_ar30, depth, width);
+    src_r += src_stride_r;
+    src_g += src_stride_g;
+    src_b += src_stride_b;
+    dst_ar30 += dst_stride_ar30;
+  }
+}
+
+LIBYUV_NOINLINE
+static void MergeAR64PlaneAlpha(const uint16_t* src_r,
+                                int src_stride_r,
+                                const uint16_t* src_g,
+                                int src_stride_g,
+                                const uint16_t* src_b,
+                                int src_stride_b,
+                                const uint16_t* src_a,
+                                int src_stride_a,
+                                uint16_t* dst_ar64,
+                                int dst_stride_ar64,
+                                int width,
+                                int height,
+                                int depth) {
+  int y;
+  void (*MergeAR64Row)(const uint16_t* src_r, const uint16_t* src_g,
+                       const uint16_t* src_b, const uint16_t* src_a,
+                       uint16_t* dst_argb, int depth, int width) =
+      MergeAR64Row_C;
+
+  if (src_stride_r == width && src_stride_g == width && src_stride_b == width &&
+      src_stride_a == width && dst_stride_ar64 == width * 4) {
+    width *= height;
+    height = 1;
+    src_stride_r = src_stride_g = src_stride_b = src_stride_a =
+        dst_stride_ar64 = 0;
+  }
+#if defined(HAS_MERGEAR64ROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    MergeAR64Row = MergeAR64Row_Any_AVX2;
+    if (IS_ALIGNED(width, 16)) {
+      MergeAR64Row = MergeAR64Row_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_MERGEAR64ROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    MergeAR64Row = MergeAR64Row_Any_NEON;
+    if (IS_ALIGNED(width, 8)) {
+      MergeAR64Row = MergeAR64Row_NEON;
+    }
+  }
+#endif
+
+  for (y = 0; y < height; ++y) {
+    MergeAR64Row(src_r, src_g, src_b, src_a, dst_ar64, depth, width);
+    src_r += src_stride_r;
+    src_g += src_stride_g;
+    src_b += src_stride_b;
+    src_a += src_stride_a;
+    dst_ar64 += dst_stride_ar64;
+  }
+}
+
+LIBYUV_NOINLINE
+static void MergeAR64PlaneOpaque(const uint16_t* src_r,
+                                 int src_stride_r,
+                                 const uint16_t* src_g,
+                                 int src_stride_g,
+                                 const uint16_t* src_b,
+                                 int src_stride_b,
+                                 uint16_t* dst_ar64,
+                                 int dst_stride_ar64,
+                                 int width,
+                                 int height,
+                                 int depth) {
+  int y;
+  void (*MergeXR64Row)(const uint16_t* src_r, const uint16_t* src_g,
+                       const uint16_t* src_b, uint16_t* dst_argb, int depth,
+                       int width) = MergeXR64Row_C;
+
+  // Coalesce rows.
+  if (src_stride_r == width && src_stride_g == width && src_stride_b == width &&
+      dst_stride_ar64 == width * 4) {
+    width *= height;
+    height = 1;
+    src_stride_r = src_stride_g = src_stride_b = dst_stride_ar64 = 0;
+  }
+#if defined(HAS_MERGEXR64ROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    MergeXR64Row = MergeXR64Row_Any_AVX2;
+    if (IS_ALIGNED(width, 16)) {
+      MergeXR64Row = MergeXR64Row_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_MERGEXR64ROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    MergeXR64Row = MergeXR64Row_Any_NEON;
+    if (IS_ALIGNED(width, 8)) {
+      MergeXR64Row = MergeXR64Row_NEON;
+    }
+  }
+#endif
+
+  for (y = 0; y < height; ++y) {
+    MergeXR64Row(src_r, src_g, src_b, dst_ar64, depth, width);
+    src_r += src_stride_r;
+    src_g += src_stride_g;
+    src_b += src_stride_b;
+    dst_ar64 += dst_stride_ar64;
+  }
+}
+
+LIBYUV_API
+void MergeAR64Plane(const uint16_t* src_r,
+                    int src_stride_r,
+                    const uint16_t* src_g,
+                    int src_stride_g,
+                    const uint16_t* src_b,
+                    int src_stride_b,
+                    const uint16_t* src_a,
+                    int src_stride_a,
+                    uint16_t* dst_ar64,
+                    int dst_stride_ar64,
+                    int width,
+                    int height,
+                    int depth) {
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    dst_ar64 = dst_ar64 + (height - 1) * dst_stride_ar64;
+    dst_stride_ar64 = -dst_stride_ar64;
+  }
+
+  if (src_a == NULL) {
+    MergeAR64PlaneOpaque(src_r, src_stride_r, src_g, src_stride_g, src_b,
+                         src_stride_b, dst_ar64, dst_stride_ar64, width, height,
+                         depth);
+  } else {
+    MergeAR64PlaneAlpha(src_r, src_stride_r, src_g, src_stride_g, src_b,
+                        src_stride_b, src_a, src_stride_a, dst_ar64,
+                        dst_stride_ar64, width, height, depth);
+  }
+}
+
+LIBYUV_NOINLINE
+static void MergeARGB16To8PlaneAlpha(const uint16_t* src_r,
+                                     int src_stride_r,
+                                     const uint16_t* src_g,
+                                     int src_stride_g,
+                                     const uint16_t* src_b,
+                                     int src_stride_b,
+                                     const uint16_t* src_a,
+                                     int src_stride_a,
+                                     uint8_t* dst_argb,
+                                     int dst_stride_argb,
+                                     int width,
+                                     int height,
+                                     int depth) {
+  int y;
+  void (*MergeARGB16To8Row)(const uint16_t* src_r, const uint16_t* src_g,
+                            const uint16_t* src_b, const uint16_t* src_a,
+                            uint8_t* dst_argb, int depth, int width) =
+      MergeARGB16To8Row_C;
+
+  if (src_stride_r == width && src_stride_g == width && src_stride_b == width &&
+      src_stride_a == width && dst_stride_argb == width * 4) {
+    width *= height;
+    height = 1;
+    src_stride_r = src_stride_g = src_stride_b = src_stride_a =
+        dst_stride_argb = 0;
+  }
+#if defined(HAS_MERGEARGB16TO8ROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    MergeARGB16To8Row = MergeARGB16To8Row_Any_AVX2;
+    if (IS_ALIGNED(width, 16)) {
+      MergeARGB16To8Row = MergeARGB16To8Row_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_MERGEARGB16TO8ROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    MergeARGB16To8Row = MergeARGB16To8Row_Any_NEON;
+    if (IS_ALIGNED(width, 8)) {
+      MergeARGB16To8Row = MergeARGB16To8Row_NEON;
+    }
+  }
+#endif
+
+  for (y = 0; y < height; ++y) {
+    MergeARGB16To8Row(src_r, src_g, src_b, src_a, dst_argb, depth, width);
+    src_r += src_stride_r;
+    src_g += src_stride_g;
+    src_b += src_stride_b;
+    src_a += src_stride_a;
+    dst_argb += dst_stride_argb;
+  }
+}
+
+LIBYUV_NOINLINE
+static void MergeARGB16To8PlaneOpaque(const uint16_t* src_r,
+                                      int src_stride_r,
+                                      const uint16_t* src_g,
+                                      int src_stride_g,
+                                      const uint16_t* src_b,
+                                      int src_stride_b,
+                                      uint8_t* dst_argb,
+                                      int dst_stride_argb,
+                                      int width,
+                                      int height,
+                                      int depth) {
+  int y;
+  void (*MergeXRGB16To8Row)(const uint16_t* src_r, const uint16_t* src_g,
+                            const uint16_t* src_b, uint8_t* dst_argb, int depth,
+                            int width) = MergeXRGB16To8Row_C;
+
+  // Coalesce rows.
+  if (src_stride_r == width && src_stride_g == width && src_stride_b == width &&
+      dst_stride_argb == width * 4) {
+    width *= height;
+    height = 1;
+    src_stride_r = src_stride_g = src_stride_b = dst_stride_argb = 0;
+  }
+#if defined(HAS_MERGEXRGB16TO8ROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    MergeXRGB16To8Row = MergeXRGB16To8Row_Any_AVX2;
+    if (IS_ALIGNED(width, 16)) {
+      MergeXRGB16To8Row = MergeXRGB16To8Row_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_MERGEXRGB16TO8ROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    MergeXRGB16To8Row = MergeXRGB16To8Row_Any_NEON;
+    if (IS_ALIGNED(width, 8)) {
+      MergeXRGB16To8Row = MergeXRGB16To8Row_NEON;
+    }
+  }
+#endif
+
+  for (y = 0; y < height; ++y) {
+    MergeXRGB16To8Row(src_r, src_g, src_b, dst_argb, depth, width);
+    src_r += src_stride_r;
+    src_g += src_stride_g;
+    src_b += src_stride_b;
+    dst_argb += dst_stride_argb;
+  }
+}
+
+LIBYUV_API
+void MergeARGB16To8Plane(const uint16_t* src_r,
+                         int src_stride_r,
+                         const uint16_t* src_g,
+                         int src_stride_g,
+                         const uint16_t* src_b,
+                         int src_stride_b,
+                         const uint16_t* src_a,
+                         int src_stride_a,
+                         uint8_t* dst_argb,
+                         int dst_stride_argb,
+                         int width,
+                         int height,
+                         int depth) {
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    dst_argb = dst_argb + (height - 1) * dst_stride_argb;
+    dst_stride_argb = -dst_stride_argb;
+  }
+
+  if (src_a == NULL) {
+    MergeARGB16To8PlaneOpaque(src_r, src_stride_r, src_g, src_stride_g, src_b,
+                              src_stride_b, dst_argb, dst_stride_argb, width,
+                              height, depth);
+  } else {
+    MergeARGB16To8PlaneAlpha(src_r, src_stride_r, src_g, src_stride_g, src_b,
+                             src_stride_b, src_a, src_stride_a, dst_argb,
+                             dst_stride_argb, width, height, depth);
+  }
+}
+
+// Convert YUY2 to I422.
+LIBYUV_API
+int YUY2ToI422(const uint8_t* src_yuy2,
+               int src_stride_yuy2,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_u,
+               int dst_stride_u,
+               uint8_t* dst_v,
+               int dst_stride_v,
+               int width,
+               int height) {
+  int y;
+  void (*YUY2ToUV422Row)(const uint8_t* src_yuy2, uint8_t* dst_u,
+                         uint8_t* dst_v, int width) = YUY2ToUV422Row_C;
+  void (*YUY2ToYRow)(const uint8_t* src_yuy2, uint8_t* dst_y, int width) =
+      YUY2ToYRow_C;
+  if (!src_yuy2 || !dst_y || !dst_u || !dst_v || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    src_yuy2 = src_yuy2 + (height - 1) * src_stride_yuy2;
+    src_stride_yuy2 = -src_stride_yuy2;
+  }
+  // Coalesce rows.
+  if (src_stride_yuy2 == width * 2 && dst_stride_y == width &&
+      dst_stride_u * 2 == width && dst_stride_v * 2 == width &&
+      width * height <= 32768) {
+    width *= height;
+    height = 1;
+    src_stride_yuy2 = dst_stride_y = dst_stride_u = dst_stride_v = 0;
+  }
+#if defined(HAS_YUY2TOYROW_SSE2)
+  if (TestCpuFlag(kCpuHasSSE2)) {
+    YUY2ToUV422Row = YUY2ToUV422Row_Any_SSE2;
+    YUY2ToYRow = YUY2ToYRow_Any_SSE2;
+    if (IS_ALIGNED(width, 16)) {
+      YUY2ToUV422Row = YUY2ToUV422Row_SSE2;
+      YUY2ToYRow = YUY2ToYRow_SSE2;
+    }
+  }
+#endif
+#if defined(HAS_YUY2TOYROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    YUY2ToUV422Row = YUY2ToUV422Row_Any_AVX2;
+    YUY2ToYRow = YUY2ToYRow_Any_AVX2;
+    if (IS_ALIGNED(width, 32)) {
+      YUY2ToUV422Row = YUY2ToUV422Row_AVX2;
+      YUY2ToYRow = YUY2ToYRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_YUY2TOYROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    YUY2ToYRow = YUY2ToYRow_Any_NEON;
+    YUY2ToUV422Row = YUY2ToUV422Row_Any_NEON;
+    if (IS_ALIGNED(width, 16)) {
+      YUY2ToYRow = YUY2ToYRow_NEON;
+      YUY2ToUV422Row = YUY2ToUV422Row_NEON;
+    }
+  }
+#endif
+#if defined(HAS_YUY2TOYROW_MSA) && defined(HAS_YUY2TOUV422ROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    YUY2ToYRow = YUY2ToYRow_Any_MSA;
+    YUY2ToUV422Row = YUY2ToUV422Row_Any_MSA;
+    if (IS_ALIGNED(width, 32)) {
+      YUY2ToYRow = YUY2ToYRow_MSA;
+      YUY2ToUV422Row = YUY2ToUV422Row_MSA;
+    }
+  }
+#endif
+#if defined(HAS_YUY2TOYROW_LASX) && defined(HAS_YUY2TOUV422ROW_LASX)
+  if (TestCpuFlag(kCpuHasLASX)) {
+    YUY2ToYRow = YUY2ToYRow_Any_LASX;
+    YUY2ToUV422Row = YUY2ToUV422Row_Any_LASX;
+    if (IS_ALIGNED(width, 32)) {
+      YUY2ToYRow = YUY2ToYRow_LASX;
+      YUY2ToUV422Row = YUY2ToUV422Row_LASX;
+    }
+  }
+#endif
+
+  for (y = 0; y < height; ++y) {
+    YUY2ToUV422Row(src_yuy2, dst_u, dst_v, width);
+    YUY2ToYRow(src_yuy2, dst_y, width);
+    src_yuy2 += src_stride_yuy2;
+    dst_y += dst_stride_y;
+    dst_u += dst_stride_u;
+    dst_v += dst_stride_v;
+  }
+  return 0;
+}
+
+// Convert UYVY to I422.
+LIBYUV_API
+int UYVYToI422(const uint8_t* src_uyvy,
+               int src_stride_uyvy,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_u,
+               int dst_stride_u,
+               uint8_t* dst_v,
+               int dst_stride_v,
+               int width,
+               int height) {
+  int y;
+  void (*UYVYToUV422Row)(const uint8_t* src_uyvy, uint8_t* dst_u,
+                         uint8_t* dst_v, int width) = UYVYToUV422Row_C;
+  void (*UYVYToYRow)(const uint8_t* src_uyvy, uint8_t* dst_y, int width) =
+      UYVYToYRow_C;
+  if (!src_uyvy || !dst_y || !dst_u || !dst_v || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    src_uyvy = src_uyvy + (height - 1) * src_stride_uyvy;
+    src_stride_uyvy = -src_stride_uyvy;
+  }
+  // Coalesce rows.
+  if (src_stride_uyvy == width * 2 && dst_stride_y == width &&
+      dst_stride_u * 2 == width && dst_stride_v * 2 == width &&
+      width * height <= 32768) {
+    width *= height;
+    height = 1;
+    src_stride_uyvy = dst_stride_y = dst_stride_u = dst_stride_v = 0;
+  }
+#if defined(HAS_UYVYTOYROW_SSE2)
+  if (TestCpuFlag(kCpuHasSSE2)) {
+    UYVYToUV422Row = UYVYToUV422Row_Any_SSE2;
+    UYVYToYRow = UYVYToYRow_Any_SSE2;
+    if (IS_ALIGNED(width, 16)) {
+      UYVYToUV422Row = UYVYToUV422Row_SSE2;
+      UYVYToYRow = UYVYToYRow_SSE2;
+    }
+  }
+#endif
+#if defined(HAS_UYVYTOYROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    UYVYToUV422Row = UYVYToUV422Row_Any_AVX2;
+    UYVYToYRow = UYVYToYRow_Any_AVX2;
+    if (IS_ALIGNED(width, 32)) {
+      UYVYToUV422Row = UYVYToUV422Row_AVX2;
+      UYVYToYRow = UYVYToYRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_UYVYTOYROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    UYVYToYRow = UYVYToYRow_Any_NEON;
+    UYVYToUV422Row = UYVYToUV422Row_Any_NEON;
+    if (IS_ALIGNED(width, 16)) {
+      UYVYToYRow = UYVYToYRow_NEON;
+      UYVYToUV422Row = UYVYToUV422Row_NEON;
+    }
+  }
+#endif
+#if defined(HAS_UYVYTOYROW_MSA) && defined(HAS_UYVYTOUV422ROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    UYVYToYRow = UYVYToYRow_Any_MSA;
+    UYVYToUV422Row = UYVYToUV422Row_Any_MSA;
+    if (IS_ALIGNED(width, 32)) {
+      UYVYToYRow = UYVYToYRow_MSA;
+      UYVYToUV422Row = UYVYToUV422Row_MSA;
+    }
+  }
+#endif
+#if defined(HAS_UYVYTOYROW_LASX) && defined(HAS_UYVYTOUV422ROW_LASX)
+  if (TestCpuFlag(kCpuHasLASX)) {
+    UYVYToYRow = UYVYToYRow_Any_LASX;
+    UYVYToUV422Row = UYVYToUV422Row_Any_LASX;
+    if (IS_ALIGNED(width, 32)) {
+      UYVYToYRow = UYVYToYRow_LASX;
+      UYVYToUV422Row = UYVYToUV422Row_LASX;
+    }
+  }
+#endif
+
+  for (y = 0; y < height; ++y) {
+    UYVYToUV422Row(src_uyvy, dst_u, dst_v, width);
+    UYVYToYRow(src_uyvy, dst_y, width);
+    src_uyvy += src_stride_uyvy;
+    dst_y += dst_stride_y;
+    dst_u += dst_stride_u;
+    dst_v += dst_stride_v;
+  }
+  return 0;
+}
+
+// Convert YUY2 to Y.
+LIBYUV_API
+int YUY2ToY(const uint8_t* src_yuy2,
+            int src_stride_yuy2,
+            uint8_t* dst_y,
+            int dst_stride_y,
+            int width,
+            int height) {
+  int y;
+  void (*YUY2ToYRow)(const uint8_t* src_yuy2, uint8_t* dst_y, int width) =
+      YUY2ToYRow_C;
+  if (!src_yuy2 || !dst_y || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    src_yuy2 = src_yuy2 + (height - 1) * src_stride_yuy2;
+    src_stride_yuy2 = -src_stride_yuy2;
+  }
+  // Coalesce rows.
+  if (src_stride_yuy2 == width * 2 && dst_stride_y == width) {
+    width *= height;
+    height = 1;
+    src_stride_yuy2 = dst_stride_y = 0;
+  }
+#if defined(HAS_YUY2TOYROW_SSE2)
+  if (TestCpuFlag(kCpuHasSSE2)) {
+    YUY2ToYRow = YUY2ToYRow_Any_SSE2;
+    if (IS_ALIGNED(width, 16)) {
+      YUY2ToYRow = YUY2ToYRow_SSE2;
+    }
+  }
+#endif
+#if defined(HAS_YUY2TOYROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    YUY2ToYRow = YUY2ToYRow_Any_AVX2;
+    if (IS_ALIGNED(width, 32)) {
+      YUY2ToYRow = YUY2ToYRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_YUY2TOYROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    YUY2ToYRow = YUY2ToYRow_Any_NEON;
+    if (IS_ALIGNED(width, 16)) {
+      YUY2ToYRow = YUY2ToYRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_YUY2TOYROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    YUY2ToYRow = YUY2ToYRow_Any_MSA;
+    if (IS_ALIGNED(width, 32)) {
+      YUY2ToYRow = YUY2ToYRow_MSA;
+    }
+  }
+#endif
+
+  for (y = 0; y < height; ++y) {
+    YUY2ToYRow(src_yuy2, dst_y, width);
+    src_yuy2 += src_stride_yuy2;
+    dst_y += dst_stride_y;
+  }
+  return 0;
+}
+
+// Convert UYVY to Y.
+LIBYUV_API
+int UYVYToY(const uint8_t* src_uyvy,
+            int src_stride_uyvy,
+            uint8_t* dst_y,
+            int dst_stride_y,
+            int width,
+            int height) {
+  int y;
+  void (*UYVYToYRow)(const uint8_t* src_uyvy, uint8_t* dst_y, int width) =
+      UYVYToYRow_C;
+  if (!src_uyvy || !dst_y || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    src_uyvy = src_uyvy + (height - 1) * src_stride_uyvy;
+    src_stride_uyvy = -src_stride_uyvy;
+  }
+  // Coalesce rows.
+  if (src_stride_uyvy == width * 2 && dst_stride_y == width) {
+    width *= height;
+    height = 1;
+    src_stride_uyvy = dst_stride_y = 0;
+  }
+#if defined(HAS_UYVYTOYROW_SSE2)
+  if (TestCpuFlag(kCpuHasSSE2)) {
+    UYVYToYRow = UYVYToYRow_Any_SSE2;
+    if (IS_ALIGNED(width, 16)) {
+      UYVYToYRow = UYVYToYRow_SSE2;
+    }
+  }
+#endif
+#if defined(HAS_UYVYTOYROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    UYVYToYRow = UYVYToYRow_Any_AVX2;
+    if (IS_ALIGNED(width, 32)) {
+      UYVYToYRow = UYVYToYRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_UYVYTOYROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    UYVYToYRow = UYVYToYRow_Any_NEON;
+    if (IS_ALIGNED(width, 16)) {
+      UYVYToYRow = UYVYToYRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_UYVYTOYROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    UYVYToYRow = UYVYToYRow_Any_MSA;
+    if (IS_ALIGNED(width, 32)) {
+      UYVYToYRow = UYVYToYRow_MSA;
+    }
+  }
+#endif
+
+  for (y = 0; y < height; ++y) {
+    UYVYToYRow(src_uyvy, dst_y, width);
+    src_uyvy += src_stride_uyvy;
+    dst_y += dst_stride_y;
+  }
+  return 0;
+}
+
+// Mirror a plane of data.
+// See Also I400Mirror
+LIBYUV_API
+void MirrorPlane(const uint8_t* src_y,
+                 int src_stride_y,
+                 uint8_t* dst_y,
+                 int dst_stride_y,
+                 int width,
+                 int height) {
+  int y;
+  void (*MirrorRow)(const uint8_t* src, uint8_t* dst, int width) = MirrorRow_C;
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    src_y = src_y + (height - 1) * src_stride_y;
+    src_stride_y = -src_stride_y;
+  }
+#if defined(HAS_MIRRORROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    MirrorRow = MirrorRow_Any_NEON;
+    if (IS_ALIGNED(width, 32)) {
+      MirrorRow = MirrorRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_MIRRORROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    MirrorRow = MirrorRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 16)) {
+      MirrorRow = MirrorRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_MIRRORROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    MirrorRow = MirrorRow_Any_AVX2;
+    if (IS_ALIGNED(width, 32)) {
+      MirrorRow = MirrorRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_MIRRORROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    MirrorRow = MirrorRow_Any_MSA;
+    if (IS_ALIGNED(width, 64)) {
+      MirrorRow = MirrorRow_MSA;
+    }
+  }
+#endif
+#if defined(HAS_MIRRORROW_LASX)
+  if (TestCpuFlag(kCpuHasLASX)) {
+    MirrorRow = MirrorRow_Any_LASX;
+    if (IS_ALIGNED(width, 64)) {
+      MirrorRow = MirrorRow_LASX;
+    }
+  }
+#endif
+
+  // Mirror plane
+  for (y = 0; y < height; ++y) {
+    MirrorRow(src_y, dst_y, width);
+    src_y += src_stride_y;
+    dst_y += dst_stride_y;
+  }
+}
+
+// Mirror a plane of UV data.
+LIBYUV_API
+void MirrorUVPlane(const uint8_t* src_uv,
+                   int src_stride_uv,
+                   uint8_t* dst_uv,
+                   int dst_stride_uv,
+                   int width,
+                   int height) {
+  int y;
+  void (*MirrorUVRow)(const uint8_t* src, uint8_t* dst, int width) =
+      MirrorUVRow_C;
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    src_uv = src_uv + (height - 1) * src_stride_uv;
+    src_stride_uv = -src_stride_uv;
+  }
+#if defined(HAS_MIRRORUVROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    MirrorUVRow = MirrorUVRow_Any_NEON;
+    if (IS_ALIGNED(width, 32)) {
+      MirrorUVRow = MirrorUVRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_MIRRORUVROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    MirrorUVRow = MirrorUVRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 8)) {
+      MirrorUVRow = MirrorUVRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_MIRRORUVROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    MirrorUVRow = MirrorUVRow_Any_AVX2;
+    if (IS_ALIGNED(width, 16)) {
+      MirrorUVRow = MirrorUVRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_MIRRORUVROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    MirrorUVRow = MirrorUVRow_Any_MSA;
+    if (IS_ALIGNED(width, 8)) {
+      MirrorUVRow = MirrorUVRow_MSA;
+    }
+  }
+#endif
+#if defined(HAS_MIRRORUVROW_LASX)
+  if (TestCpuFlag(kCpuHasLASX)) {
+    MirrorUVRow = MirrorUVRow_Any_LASX;
+    if (IS_ALIGNED(width, 16)) {
+      MirrorUVRow = MirrorUVRow_LASX;
+    }
+  }
+#endif
+
+  // MirrorUV plane
+  for (y = 0; y < height; ++y) {
+    MirrorUVRow(src_uv, dst_uv, width);
+    src_uv += src_stride_uv;
+    dst_uv += dst_stride_uv;
+  }
+}
+
+// Mirror I400 with optional flipping
+LIBYUV_API
+int I400Mirror(const uint8_t* src_y,
+               int src_stride_y,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               int width,
+               int height) {
+  if (!src_y || !dst_y || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    src_y = src_y + (height - 1) * src_stride_y;
+    src_stride_y = -src_stride_y;
+  }
+
+  MirrorPlane(src_y, src_stride_y, dst_y, dst_stride_y, width, height);
+  return 0;
+}
+
+// Mirror I420 with optional flipping
+LIBYUV_API
+int I420Mirror(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_u,
+               int dst_stride_u,
+               uint8_t* dst_v,
+               int dst_stride_v,
+               int width,
+               int height) {
+  int halfwidth = (width + 1) >> 1;
+  int halfheight = (height + 1) >> 1;
+
+  if (!src_y || !src_u || !src_v || !dst_u || !dst_v || width <= 0 ||
+      height == 0) {
+    return -1;
+  }
+
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    halfheight = (height + 1) >> 1;
+    src_y = src_y + (height - 1) * src_stride_y;
+    src_u = src_u + (halfheight - 1) * src_stride_u;
+    src_v = src_v + (halfheight - 1) * src_stride_v;
+    src_stride_y = -src_stride_y;
+    src_stride_u = -src_stride_u;
+    src_stride_v = -src_stride_v;
+  }
+
+  if (dst_y) {
+    MirrorPlane(src_y, src_stride_y, dst_y, dst_stride_y, width, height);
+  }
+  MirrorPlane(src_u, src_stride_u, dst_u, dst_stride_u, halfwidth, halfheight);
+  MirrorPlane(src_v, src_stride_v, dst_v, dst_stride_v, halfwidth, halfheight);
+  return 0;
+}
+
+// NV12 mirror.
+LIBYUV_API
+int NV12Mirror(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_uv,
+               int src_stride_uv,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_uv,
+               int dst_stride_uv,
+               int width,
+               int height) {
+  int halfwidth = (width + 1) >> 1;
+  int halfheight = (height + 1) >> 1;
+
+  if (!src_y || !src_uv || !dst_uv || width <= 0 || height == 0) {
+    return -1;
+  }
+
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    halfheight = (height + 1) >> 1;
+    src_y = src_y + (height - 1) * src_stride_y;
+    src_uv = src_uv + (halfheight - 1) * src_stride_uv;
+    src_stride_y = -src_stride_y;
+    src_stride_uv = -src_stride_uv;
+  }
+
+  if (dst_y) {
+    MirrorPlane(src_y, src_stride_y, dst_y, dst_stride_y, width, height);
+  }
+  MirrorUVPlane(src_uv, src_stride_uv, dst_uv, dst_stride_uv, halfwidth,
+                halfheight);
+  return 0;
+}
+
+// ARGB mirror.
+LIBYUV_API
+int ARGBMirror(const uint8_t* src_argb,
+               int src_stride_argb,
+               uint8_t* dst_argb,
+               int dst_stride_argb,
+               int width,
+               int height) {
+  int y;
+  void (*ARGBMirrorRow)(const uint8_t* src, uint8_t* dst, int width) =
+      ARGBMirrorRow_C;
+  if (!src_argb || !dst_argb || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    src_argb = src_argb + (height - 1) * src_stride_argb;
+    src_stride_argb = -src_stride_argb;
+  }
+#if defined(HAS_ARGBMIRRORROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    ARGBMirrorRow = ARGBMirrorRow_Any_NEON;
+    if (IS_ALIGNED(width, 8)) {
+      ARGBMirrorRow = ARGBMirrorRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_ARGBMIRRORROW_SSE2)
+  if (TestCpuFlag(kCpuHasSSE2)) {
+    ARGBMirrorRow = ARGBMirrorRow_Any_SSE2;
+    if (IS_ALIGNED(width, 4)) {
+      ARGBMirrorRow = ARGBMirrorRow_SSE2;
+    }
+  }
+#endif
+#if defined(HAS_ARGBMIRRORROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ARGBMirrorRow = ARGBMirrorRow_Any_AVX2;
+    if (IS_ALIGNED(width, 8)) {
+      ARGBMirrorRow = ARGBMirrorRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_ARGBMIRRORROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    ARGBMirrorRow = ARGBMirrorRow_Any_MSA;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBMirrorRow = ARGBMirrorRow_MSA;
+    }
+  }
+#endif
+#if defined(HAS_ARGBMIRRORROW_LASX)
+  if (TestCpuFlag(kCpuHasLASX)) {
+    ARGBMirrorRow = ARGBMirrorRow_Any_LASX;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBMirrorRow = ARGBMirrorRow_LASX;
+    }
+  }
+#endif
+
+  // Mirror plane
+  for (y = 0; y < height; ++y) {
+    ARGBMirrorRow(src_argb, dst_argb, width);
+    src_argb += src_stride_argb;
+    dst_argb += dst_stride_argb;
+  }
+  return 0;
+}
+
+// RGB24 mirror.
+LIBYUV_API
+int RGB24Mirror(const uint8_t* src_rgb24,
+                int src_stride_rgb24,
+                uint8_t* dst_rgb24,
+                int dst_stride_rgb24,
+                int width,
+                int height) {
+  int y;
+  void (*RGB24MirrorRow)(const uint8_t* src, uint8_t* dst, int width) =
+      RGB24MirrorRow_C;
+  if (!src_rgb24 || !dst_rgb24 || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    src_rgb24 = src_rgb24 + (height - 1) * src_stride_rgb24;
+    src_stride_rgb24 = -src_stride_rgb24;
+  }
+#if defined(HAS_RGB24MIRRORROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    RGB24MirrorRow = RGB24MirrorRow_Any_NEON;
+    if (IS_ALIGNED(width, 16)) {
+      RGB24MirrorRow = RGB24MirrorRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_RGB24MIRRORROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    RGB24MirrorRow = RGB24MirrorRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 16)) {
+      RGB24MirrorRow = RGB24MirrorRow_SSSE3;
+    }
+  }
+#endif
+
+  // Mirror plane
+  for (y = 0; y < height; ++y) {
+    RGB24MirrorRow(src_rgb24, dst_rgb24, width);
+    src_rgb24 += src_stride_rgb24;
+    dst_rgb24 += dst_stride_rgb24;
+  }
+  return 0;
+}
+
+// Get a blender that optimized for the CPU and pixel count.
+// As there are 6 blenders to choose from, the caller should try to use
+// the same blend function for all pixels if possible.
+LIBYUV_API
+ARGBBlendRow GetARGBBlend() {
+  void (*ARGBBlendRow)(const uint8_t* src_argb, const uint8_t* src_argb1,
+                       uint8_t* dst_argb, int width) = ARGBBlendRow_C;
+#if defined(HAS_ARGBBLENDROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    ARGBBlendRow = ARGBBlendRow_SSSE3;
+    return ARGBBlendRow;
+  }
+#endif
+#if defined(HAS_ARGBBLENDROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    ARGBBlendRow = ARGBBlendRow_NEON;
+  }
+#endif
+#if defined(HAS_ARGBBLENDROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    ARGBBlendRow = ARGBBlendRow_MSA;
+  }
+#endif
+#if defined(HAS_ARGBBLENDROW_LSX)
+  if (TestCpuFlag(kCpuHasLSX)) {
+    ARGBBlendRow = ARGBBlendRow_LSX;
+  }
+#endif
+  return ARGBBlendRow;
+}
+
+// Alpha Blend 2 ARGB images and store to destination.
+LIBYUV_API
+int ARGBBlend(const uint8_t* src_argb0,
+              int src_stride_argb0,
+              const uint8_t* src_argb1,
+              int src_stride_argb1,
+              uint8_t* dst_argb,
+              int dst_stride_argb,
+              int width,
+              int height) {
+  int y;
+  void (*ARGBBlendRow)(const uint8_t* src_argb, const uint8_t* src_argb1,
+                       uint8_t* dst_argb, int width) = GetARGBBlend();
+  if (!src_argb0 || !src_argb1 || !dst_argb || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    dst_argb = dst_argb + (height - 1) * dst_stride_argb;
+    dst_stride_argb = -dst_stride_argb;
+  }
+  // Coalesce rows.
+  if (src_stride_argb0 == width * 4 && src_stride_argb1 == width * 4 &&
+      dst_stride_argb == width * 4) {
+    width *= height;
+    height = 1;
+    src_stride_argb0 = src_stride_argb1 = dst_stride_argb = 0;
+  }
+
+  for (y = 0; y < height; ++y) {
+    ARGBBlendRow(src_argb0, src_argb1, dst_argb, width);
+    src_argb0 += src_stride_argb0;
+    src_argb1 += src_stride_argb1;
+    dst_argb += dst_stride_argb;
+  }
+  return 0;
+}
+
+// Alpha Blend plane and store to destination.
+LIBYUV_API
+int BlendPlane(const uint8_t* src_y0,
+               int src_stride_y0,
+               const uint8_t* src_y1,
+               int src_stride_y1,
+               const uint8_t* alpha,
+               int alpha_stride,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               int width,
+               int height) {
+  int y;
+  void (*BlendPlaneRow)(const uint8_t* src0, const uint8_t* src1,
+                        const uint8_t* alpha, uint8_t* dst, int width) =
+      BlendPlaneRow_C;
+  if (!src_y0 || !src_y1 || !alpha || !dst_y || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    dst_y = dst_y + (height - 1) * dst_stride_y;
+    dst_stride_y = -dst_stride_y;
+  }
+
+  // Coalesce rows for Y plane.
+  if (src_stride_y0 == width && src_stride_y1 == width &&
+      alpha_stride == width && dst_stride_y == width) {
+    width *= height;
+    height = 1;
+    src_stride_y0 = src_stride_y1 = alpha_stride = dst_stride_y = 0;
+  }
+
+#if defined(HAS_BLENDPLANEROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    BlendPlaneRow = BlendPlaneRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 8)) {
+      BlendPlaneRow = BlendPlaneRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_BLENDPLANEROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    BlendPlaneRow = BlendPlaneRow_Any_AVX2;
+    if (IS_ALIGNED(width, 32)) {
+      BlendPlaneRow = BlendPlaneRow_AVX2;
+    }
+  }
+#endif
+
+  for (y = 0; y < height; ++y) {
+    BlendPlaneRow(src_y0, src_y1, alpha, dst_y, width);
+    src_y0 += src_stride_y0;
+    src_y1 += src_stride_y1;
+    alpha += alpha_stride;
+    dst_y += dst_stride_y;
+  }
+  return 0;
+}
+
+#define MAXTWIDTH 2048
+// Alpha Blend YUV images and store to destination.
+LIBYUV_API
+int I420Blend(const uint8_t* src_y0,
+              int src_stride_y0,
+              const uint8_t* src_u0,
+              int src_stride_u0,
+              const uint8_t* src_v0,
+              int src_stride_v0,
+              const uint8_t* src_y1,
+              int src_stride_y1,
+              const uint8_t* src_u1,
+              int src_stride_u1,
+              const uint8_t* src_v1,
+              int src_stride_v1,
+              const uint8_t* alpha,
+              int alpha_stride,
+              uint8_t* dst_y,
+              int dst_stride_y,
+              uint8_t* dst_u,
+              int dst_stride_u,
+              uint8_t* dst_v,
+              int dst_stride_v,
+              int width,
+              int height) {
+  int y;
+  // Half width/height for UV.
+  int halfwidth = (width + 1) >> 1;
+  void (*BlendPlaneRow)(const uint8_t* src0, const uint8_t* src1,
+                        const uint8_t* alpha, uint8_t* dst, int width) =
+      BlendPlaneRow_C;
+  void (*ScaleRowDown2)(const uint8_t* src_ptr, ptrdiff_t src_stride,
+                        uint8_t* dst_ptr, int dst_width) = ScaleRowDown2Box_C;
+
+  if (!src_y0 || !src_u0 || !src_v0 || !src_y1 || !src_u1 || !src_v1 ||
+      !alpha || !dst_y || !dst_u || !dst_v || width <= 0 || height == 0) {
+    return -1;
+  }
+
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    dst_y = dst_y + (height - 1) * dst_stride_y;
+    dst_stride_y = -dst_stride_y;
+  }
+
+  // Blend Y plane.
+  BlendPlane(src_y0, src_stride_y0, src_y1, src_stride_y1, alpha, alpha_stride,
+             dst_y, dst_stride_y, width, height);
+
+#if defined(HAS_BLENDPLANEROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    BlendPlaneRow = BlendPlaneRow_Any_SSSE3;
+    if (IS_ALIGNED(halfwidth, 8)) {
+      BlendPlaneRow = BlendPlaneRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_BLENDPLANEROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    BlendPlaneRow = BlendPlaneRow_Any_AVX2;
+    if (IS_ALIGNED(halfwidth, 32)) {
+      BlendPlaneRow = BlendPlaneRow_AVX2;
+    }
+  }
+#endif
+  if (!IS_ALIGNED(width, 2)) {
+    ScaleRowDown2 = ScaleRowDown2Box_Odd_C;
+  }
+#if defined(HAS_SCALEROWDOWN2_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    ScaleRowDown2 = ScaleRowDown2Box_Odd_NEON;
+    if (IS_ALIGNED(width, 2)) {
+      ScaleRowDown2 = ScaleRowDown2Box_Any_NEON;
+      if (IS_ALIGNED(halfwidth, 16)) {
+        ScaleRowDown2 = ScaleRowDown2Box_NEON;
+      }
+    }
+  }
+#endif
+#if defined(HAS_SCALEROWDOWN2_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    ScaleRowDown2 = ScaleRowDown2Box_Odd_SSSE3;
+    if (IS_ALIGNED(width, 2)) {
+      ScaleRowDown2 = ScaleRowDown2Box_Any_SSSE3;
+      if (IS_ALIGNED(halfwidth, 16)) {
+        ScaleRowDown2 = ScaleRowDown2Box_SSSE3;
+      }
+    }
+  }
+#endif
+#if defined(HAS_SCALEROWDOWN2_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ScaleRowDown2 = ScaleRowDown2Box_Odd_AVX2;
+    if (IS_ALIGNED(width, 2)) {
+      ScaleRowDown2 = ScaleRowDown2Box_Any_AVX2;
+      if (IS_ALIGNED(halfwidth, 32)) {
+        ScaleRowDown2 = ScaleRowDown2Box_AVX2;
+      }
+    }
+  }
+#endif
+
+  // Row buffer for intermediate alpha pixels.
+  align_buffer_64(halfalpha, halfwidth);
+  for (y = 0; y < height; y += 2) {
+    // last row of odd height image use 1 row of alpha instead of 2.
+    if (y == (height - 1)) {
+      alpha_stride = 0;
+    }
+    // Subsample 2 rows of UV to half width and half height.
+    ScaleRowDown2(alpha, alpha_stride, halfalpha, halfwidth);
+    alpha += alpha_stride * 2;
+    BlendPlaneRow(src_u0, src_u1, halfalpha, dst_u, halfwidth);
+    BlendPlaneRow(src_v0, src_v1, halfalpha, dst_v, halfwidth);
+    src_u0 += src_stride_u0;
+    src_u1 += src_stride_u1;
+    dst_u += dst_stride_u;
+    src_v0 += src_stride_v0;
+    src_v1 += src_stride_v1;
+    dst_v += dst_stride_v;
+  }
+  free_aligned_buffer_64(halfalpha);
+  return 0;
+}
+
+// Multiply 2 ARGB images and store to destination.
+LIBYUV_API
+int ARGBMultiply(const uint8_t* src_argb0,
+                 int src_stride_argb0,
+                 const uint8_t* src_argb1,
+                 int src_stride_argb1,
+                 uint8_t* dst_argb,
+                 int dst_stride_argb,
+                 int width,
+                 int height) {
+  int y;
+  void (*ARGBMultiplyRow)(const uint8_t* src0, const uint8_t* src1,
+                          uint8_t* dst, int width) = ARGBMultiplyRow_C;
+  if (!src_argb0 || !src_argb1 || !dst_argb || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    dst_argb = dst_argb + (height - 1) * dst_stride_argb;
+    dst_stride_argb = -dst_stride_argb;
+  }
+  // Coalesce rows.
+  if (src_stride_argb0 == width * 4 && src_stride_argb1 == width * 4 &&
+      dst_stride_argb == width * 4) {
+    width *= height;
+    height = 1;
+    src_stride_argb0 = src_stride_argb1 = dst_stride_argb = 0;
+  }
+#if defined(HAS_ARGBMULTIPLYROW_SSE2)
+  if (TestCpuFlag(kCpuHasSSE2)) {
+    ARGBMultiplyRow = ARGBMultiplyRow_Any_SSE2;
+    if (IS_ALIGNED(width, 4)) {
+      ARGBMultiplyRow = ARGBMultiplyRow_SSE2;
+    }
+  }
+#endif
+#if defined(HAS_ARGBMULTIPLYROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ARGBMultiplyRow = ARGBMultiplyRow_Any_AVX2;
+    if (IS_ALIGNED(width, 8)) {
+      ARGBMultiplyRow = ARGBMultiplyRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_ARGBMULTIPLYROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    ARGBMultiplyRow = ARGBMultiplyRow_Any_NEON;
+    if (IS_ALIGNED(width, 8)) {
+      ARGBMultiplyRow = ARGBMultiplyRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_ARGBMULTIPLYROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    ARGBMultiplyRow = ARGBMultiplyRow_Any_MSA;
+    if (IS_ALIGNED(width, 4)) {
+      ARGBMultiplyRow = ARGBMultiplyRow_MSA;
+    }
+  }
+#endif
+#if defined(HAS_ARGBMULTIPLYROW_LASX)
+  if (TestCpuFlag(kCpuHasLASX)) {
+    ARGBMultiplyRow = ARGBMultiplyRow_Any_LASX;
+    if (IS_ALIGNED(width, 8)) {
+      ARGBMultiplyRow = ARGBMultiplyRow_LASX;
+    }
+  }
+#endif
+
+  // Multiply plane
+  for (y = 0; y < height; ++y) {
+    ARGBMultiplyRow(src_argb0, src_argb1, dst_argb, width);
+    src_argb0 += src_stride_argb0;
+    src_argb1 += src_stride_argb1;
+    dst_argb += dst_stride_argb;
+  }
+  return 0;
+}
+
+// Add 2 ARGB images and store to destination.
+LIBYUV_API
+int ARGBAdd(const uint8_t* src_argb0,
+            int src_stride_argb0,
+            const uint8_t* src_argb1,
+            int src_stride_argb1,
+            uint8_t* dst_argb,
+            int dst_stride_argb,
+            int width,
+            int height) {
+  int y;
+  void (*ARGBAddRow)(const uint8_t* src0, const uint8_t* src1, uint8_t* dst,
+                     int width) = ARGBAddRow_C;
+  if (!src_argb0 || !src_argb1 || !dst_argb || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    dst_argb = dst_argb + (height - 1) * dst_stride_argb;
+    dst_stride_argb = -dst_stride_argb;
+  }
+  // Coalesce rows.
+  if (src_stride_argb0 == width * 4 && src_stride_argb1 == width * 4 &&
+      dst_stride_argb == width * 4) {
+    width *= height;
+    height = 1;
+    src_stride_argb0 = src_stride_argb1 = dst_stride_argb = 0;
+  }
+#if defined(HAS_ARGBADDROW_SSE2)
+  if (TestCpuFlag(kCpuHasSSE2)) {
+    ARGBAddRow = ARGBAddRow_SSE2;
+  }
+#endif
+#if defined(HAS_ARGBADDROW_SSE2)
+  if (TestCpuFlag(kCpuHasSSE2)) {
+    ARGBAddRow = ARGBAddRow_Any_SSE2;
+    if (IS_ALIGNED(width, 4)) {
+      ARGBAddRow = ARGBAddRow_SSE2;
+    }
+  }
+#endif
+#if defined(HAS_ARGBADDROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ARGBAddRow = ARGBAddRow_Any_AVX2;
+    if (IS_ALIGNED(width, 8)) {
+      ARGBAddRow = ARGBAddRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_ARGBADDROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    ARGBAddRow = ARGBAddRow_Any_NEON;
+    if (IS_ALIGNED(width, 8)) {
+      ARGBAddRow = ARGBAddRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_ARGBADDROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    ARGBAddRow = ARGBAddRow_Any_MSA;
+    if (IS_ALIGNED(width, 8)) {
+      ARGBAddRow = ARGBAddRow_MSA;
+    }
+  }
+#endif
+#if defined(HAS_ARGBADDROW_LASX)
+  if (TestCpuFlag(kCpuHasLASX)) {
+    ARGBAddRow = ARGBAddRow_Any_LASX;
+    if (IS_ALIGNED(width, 8)) {
+      ARGBAddRow = ARGBAddRow_LASX;
+    }
+  }
+#endif
+
+  // Add plane
+  for (y = 0; y < height; ++y) {
+    ARGBAddRow(src_argb0, src_argb1, dst_argb, width);
+    src_argb0 += src_stride_argb0;
+    src_argb1 += src_stride_argb1;
+    dst_argb += dst_stride_argb;
+  }
+  return 0;
+}
+
+// Subtract 2 ARGB images and store to destination.
+LIBYUV_API
+int ARGBSubtract(const uint8_t* src_argb0,
+                 int src_stride_argb0,
+                 const uint8_t* src_argb1,
+                 int src_stride_argb1,
+                 uint8_t* dst_argb,
+                 int dst_stride_argb,
+                 int width,
+                 int height) {
+  int y;
+  void (*ARGBSubtractRow)(const uint8_t* src0, const uint8_t* src1,
+                          uint8_t* dst, int width) = ARGBSubtractRow_C;
+  if (!src_argb0 || !src_argb1 || !dst_argb || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    dst_argb = dst_argb + (height - 1) * dst_stride_argb;
+    dst_stride_argb = -dst_stride_argb;
+  }
+  // Coalesce rows.
+  if (src_stride_argb0 == width * 4 && src_stride_argb1 == width * 4 &&
+      dst_stride_argb == width * 4) {
+    width *= height;
+    height = 1;
+    src_stride_argb0 = src_stride_argb1 = dst_stride_argb = 0;
+  }
+#if defined(HAS_ARGBSUBTRACTROW_SSE2)
+  if (TestCpuFlag(kCpuHasSSE2)) {
+    ARGBSubtractRow = ARGBSubtractRow_Any_SSE2;
+    if (IS_ALIGNED(width, 4)) {
+      ARGBSubtractRow = ARGBSubtractRow_SSE2;
+    }
+  }
+#endif
+#if defined(HAS_ARGBSUBTRACTROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ARGBSubtractRow = ARGBSubtractRow_Any_AVX2;
+    if (IS_ALIGNED(width, 8)) {
+      ARGBSubtractRow = ARGBSubtractRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_ARGBSUBTRACTROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    ARGBSubtractRow = ARGBSubtractRow_Any_NEON;
+    if (IS_ALIGNED(width, 8)) {
+      ARGBSubtractRow = ARGBSubtractRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_ARGBSUBTRACTROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    ARGBSubtractRow = ARGBSubtractRow_Any_MSA;
+    if (IS_ALIGNED(width, 8)) {
+      ARGBSubtractRow = ARGBSubtractRow_MSA;
+    }
+  }
+#endif
+#if defined(HAS_ARGBSUBTRACTROW_LASX)
+  if (TestCpuFlag(kCpuHasLASX)) {
+    ARGBSubtractRow = ARGBSubtractRow_Any_LASX;
+    if (IS_ALIGNED(width, 8)) {
+      ARGBSubtractRow = ARGBSubtractRow_LASX;
+    }
+  }
+#endif
+
+  // Subtract plane
+  for (y = 0; y < height; ++y) {
+    ARGBSubtractRow(src_argb0, src_argb1, dst_argb, width);
+    src_argb0 += src_stride_argb0;
+    src_argb1 += src_stride_argb1;
+    dst_argb += dst_stride_argb;
+  }
+  return 0;
+}
+
+// Convert RAW to RGB24.
+LIBYUV_API
+int RAWToRGB24(const uint8_t* src_raw,
+               int src_stride_raw,
+               uint8_t* dst_rgb24,
+               int dst_stride_rgb24,
+               int width,
+               int height) {
+  int y;
+  void (*RAWToRGB24Row)(const uint8_t* src_rgb, uint8_t* dst_rgb24, int width) =
+      RAWToRGB24Row_C;
+  if (!src_raw || !dst_rgb24 || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    src_raw = src_raw + (height - 1) * src_stride_raw;
+    src_stride_raw = -src_stride_raw;
+  }
+  // Coalesce rows.
+  if (src_stride_raw == width * 3 && dst_stride_rgb24 == width * 3) {
+    width *= height;
+    height = 1;
+    src_stride_raw = dst_stride_rgb24 = 0;
+  }
+#if defined(HAS_RAWTORGB24ROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    RAWToRGB24Row = RAWToRGB24Row_Any_SSSE3;
+    if (IS_ALIGNED(width, 8)) {
+      RAWToRGB24Row = RAWToRGB24Row_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_RAWTORGB24ROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    RAWToRGB24Row = RAWToRGB24Row_Any_NEON;
+    if (IS_ALIGNED(width, 8)) {
+      RAWToRGB24Row = RAWToRGB24Row_NEON;
+    }
+  }
+#endif
+#if defined(HAS_RAWTORGB24ROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    RAWToRGB24Row = RAWToRGB24Row_Any_MSA;
+    if (IS_ALIGNED(width, 16)) {
+      RAWToRGB24Row = RAWToRGB24Row_MSA;
+    }
+  }
+#endif
+#if defined(HAS_RAWTORGB24ROW_LSX)
+  if (TestCpuFlag(kCpuHasLSX)) {
+    RAWToRGB24Row = RAWToRGB24Row_Any_LSX;
+    if (IS_ALIGNED(width, 16)) {
+      RAWToRGB24Row = RAWToRGB24Row_LSX;
+    }
+  }
+#endif
+
+  for (y = 0; y < height; ++y) {
+    RAWToRGB24Row(src_raw, dst_rgb24, width);
+    src_raw += src_stride_raw;
+    dst_rgb24 += dst_stride_rgb24;
+  }
+  return 0;
+}
+
+LIBYUV_API
+void SetPlane(uint8_t* dst_y,
+              int dst_stride_y,
+              int width,
+              int height,
+              uint32_t value) {
+  int y;
+  void (*SetRow)(uint8_t * dst, uint8_t value, int width) = SetRow_C;
+
+  if (width <= 0 || height == 0) {
+    return;
+  }
+  if (height < 0) {
+    height = -height;
+    dst_y = dst_y + (height - 1) * dst_stride_y;
+    dst_stride_y = -dst_stride_y;
+  }
+  // Coalesce rows.
+  if (dst_stride_y == width) {
+    width *= height;
+    height = 1;
+    dst_stride_y = 0;
+  }
+#if defined(HAS_SETROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    SetRow = SetRow_Any_NEON;
+    if (IS_ALIGNED(width, 16)) {
+      SetRow = SetRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_SETROW_X86)
+  if (TestCpuFlag(kCpuHasX86)) {
+    SetRow = SetRow_Any_X86;
+    if (IS_ALIGNED(width, 4)) {
+      SetRow = SetRow_X86;
+    }
+  }
+#endif
+#if defined(HAS_SETROW_ERMS)
+  if (TestCpuFlag(kCpuHasERMS)) {
+    SetRow = SetRow_ERMS;
+  }
+#endif
+#if defined(HAS_SETROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA) && IS_ALIGNED(width, 16)) {
+    SetRow = SetRow_MSA;
+  }
+#endif
+#if defined(HAS_SETROW_LSX)
+  if (TestCpuFlag(kCpuHasLSX)) {
+    SetRow = SetRow_Any_LSX;
+    if (IS_ALIGNED(width, 16)) {
+      SetRow = SetRow_LSX;
+    }
+  }
+#endif
+
+  // Set plane
+  for (y = 0; y < height; ++y) {
+    SetRow(dst_y, value, width);
+    dst_y += dst_stride_y;
+  }
+}
+
+// Draw a rectangle into I420
+LIBYUV_API
+int I420Rect(uint8_t* dst_y,
+             int dst_stride_y,
+             uint8_t* dst_u,
+             int dst_stride_u,
+             uint8_t* dst_v,
+             int dst_stride_v,
+             int x,
+             int y,
+             int width,
+             int height,
+             int value_y,
+             int value_u,
+             int value_v) {
+  int halfwidth = (width + 1) >> 1;
+  int halfheight = (height + 1) >> 1;
+  uint8_t* start_y = dst_y + y * dst_stride_y + x;
+  uint8_t* start_u = dst_u + (y / 2) * dst_stride_u + (x / 2);
+  uint8_t* start_v = dst_v + (y / 2) * dst_stride_v + (x / 2);
+
+  if (!dst_y || !dst_u || !dst_v || width <= 0 || height == 0 || x < 0 ||
+      y < 0 || value_y < 0 || value_y > 255 || value_u < 0 || value_u > 255 ||
+      value_v < 0 || value_v > 255) {
+    return -1;
+  }
+
+  SetPlane(start_y, dst_stride_y, width, height, value_y);
+  SetPlane(start_u, dst_stride_u, halfwidth, halfheight, value_u);
+  SetPlane(start_v, dst_stride_v, halfwidth, halfheight, value_v);
+  return 0;
+}
+
+// Draw a rectangle into ARGB
+LIBYUV_API
+int ARGBRect(uint8_t* dst_argb,
+             int dst_stride_argb,
+             int dst_x,
+             int dst_y,
+             int width,
+             int height,
+             uint32_t value) {
+  int y;
+  void (*ARGBSetRow)(uint8_t * dst_argb, uint32_t value, int width) =
+      ARGBSetRow_C;
+  if (!dst_argb || width <= 0 || height == 0 || dst_x < 0 || dst_y < 0) {
+    return -1;
+  }
+  if (height < 0) {
+    height = -height;
+    dst_argb = dst_argb + (height - 1) * dst_stride_argb;
+    dst_stride_argb = -dst_stride_argb;
+  }
+  dst_argb += dst_y * dst_stride_argb + dst_x * 4;
+  // Coalesce rows.
+  if (dst_stride_argb == width * 4) {
+    width *= height;
+    height = 1;
+    dst_stride_argb = 0;
+  }
+
+#if defined(HAS_ARGBSETROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    ARGBSetRow = ARGBSetRow_Any_NEON;
+    if (IS_ALIGNED(width, 4)) {
+      ARGBSetRow = ARGBSetRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_ARGBSETROW_X86)
+  if (TestCpuFlag(kCpuHasX86)) {
+    ARGBSetRow = ARGBSetRow_X86;
+  }
+#endif
+#if defined(HAS_ARGBSETROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    ARGBSetRow = ARGBSetRow_Any_MSA;
+    if (IS_ALIGNED(width, 4)) {
+      ARGBSetRow = ARGBSetRow_MSA;
+    }
+  }
+#endif
+#if defined(HAS_ARGBSETROW_LSX)
+  if (TestCpuFlag(kCpuHasLSX)) {
+    ARGBSetRow = ARGBSetRow_Any_LSX;
+    if (IS_ALIGNED(width, 4)) {
+      ARGBSetRow = ARGBSetRow_LSX;
+    }
+  }
+#endif
+
+  // Set plane
+  for (y = 0; y < height; ++y) {
+    ARGBSetRow(dst_argb, value, width);
+    dst_argb += dst_stride_argb;
+  }
+  return 0;
+}
+
+// Convert unattentuated ARGB to preattenuated ARGB.
+// An unattenutated ARGB alpha blend uses the formula
+// p = a * f + (1 - a) * b
+// where
+//   p is output pixel
+//   f is foreground pixel
+//   b is background pixel
+//   a is alpha value from foreground pixel
+// An preattenutated ARGB alpha blend uses the formula
+// p = f + (1 - a) * b
+// where
+//   f is foreground pixel premultiplied by alpha
+
+LIBYUV_API
+int ARGBAttenuate(const uint8_t* src_argb,
+                  int src_stride_argb,
+                  uint8_t* dst_argb,
+                  int dst_stride_argb,
+                  int width,
+                  int height) {
+  int y;
+  void (*ARGBAttenuateRow)(const uint8_t* src_argb, uint8_t* dst_argb,
+                           int width) = ARGBAttenuateRow_C;
+  if (!src_argb || !dst_argb || width <= 0 || height == 0) {
+    return -1;
+  }
+  if (height < 0) {
+    height = -height;
+    src_argb = src_argb + (height - 1) * src_stride_argb;
+    src_stride_argb = -src_stride_argb;
+  }
+  // Coalesce rows.
+  if (src_stride_argb == width * 4 && dst_stride_argb == width * 4) {
+    width *= height;
+    height = 1;
+    src_stride_argb = dst_stride_argb = 0;
+  }
+#if defined(HAS_ARGBATTENUATEROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    ARGBAttenuateRow = ARGBAttenuateRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 4)) {
+      ARGBAttenuateRow = ARGBAttenuateRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_ARGBATTENUATEROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ARGBAttenuateRow = ARGBAttenuateRow_Any_AVX2;
+    if (IS_ALIGNED(width, 8)) {
+      ARGBAttenuateRow = ARGBAttenuateRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_ARGBATTENUATEROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    ARGBAttenuateRow = ARGBAttenuateRow_Any_NEON;
+    if (IS_ALIGNED(width, 8)) {
+      ARGBAttenuateRow = ARGBAttenuateRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_ARGBATTENUATEROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    ARGBAttenuateRow = ARGBAttenuateRow_Any_MSA;
+    if (IS_ALIGNED(width, 8)) {
+      ARGBAttenuateRow = ARGBAttenuateRow_MSA;
+    }
+  }
+#endif
+#if defined(HAS_ARGBATTENUATEROW_LASX)
+  if (TestCpuFlag(kCpuHasLASX)) {
+    ARGBAttenuateRow = ARGBAttenuateRow_Any_LASX;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBAttenuateRow = ARGBAttenuateRow_LASX;
+    }
+  }
+#endif
+
+  for (y = 0; y < height; ++y) {
+    ARGBAttenuateRow(src_argb, dst_argb, width);
+    src_argb += src_stride_argb;
+    dst_argb += dst_stride_argb;
+  }
+  return 0;
+}
+
+// Convert preattentuated ARGB to unattenuated ARGB.
+LIBYUV_API
+int ARGBUnattenuate(const uint8_t* src_argb,
+                    int src_stride_argb,
+                    uint8_t* dst_argb,
+                    int dst_stride_argb,
+                    int width,
+                    int height) {
+  int y;
+  void (*ARGBUnattenuateRow)(const uint8_t* src_argb, uint8_t* dst_argb,
+                             int width) = ARGBUnattenuateRow_C;
+  if (!src_argb || !dst_argb || width <= 0 || height == 0) {
+    return -1;
+  }
+  if (height < 0) {
+    height = -height;
+    src_argb = src_argb + (height - 1) * src_stride_argb;
+    src_stride_argb = -src_stride_argb;
+  }
+  // Coalesce rows.
+  if (src_stride_argb == width * 4 && dst_stride_argb == width * 4) {
+    width *= height;
+    height = 1;
+    src_stride_argb = dst_stride_argb = 0;
+  }
+#if defined(HAS_ARGBUNATTENUATEROW_SSE2)
+  if (TestCpuFlag(kCpuHasSSE2)) {
+    ARGBUnattenuateRow = ARGBUnattenuateRow_Any_SSE2;
+    if (IS_ALIGNED(width, 4)) {
+      ARGBUnattenuateRow = ARGBUnattenuateRow_SSE2;
+    }
+  }
+#endif
+#if defined(HAS_ARGBUNATTENUATEROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ARGBUnattenuateRow = ARGBUnattenuateRow_Any_AVX2;
+    if (IS_ALIGNED(width, 8)) {
+      ARGBUnattenuateRow = ARGBUnattenuateRow_AVX2;
+    }
+  }
+#endif
+  // TODO(fbarchard): Neon version.
+
+  for (y = 0; y < height; ++y) {
+    ARGBUnattenuateRow(src_argb, dst_argb, width);
+    src_argb += src_stride_argb;
+    dst_argb += dst_stride_argb;
+  }
+  return 0;
+}
+
+// Convert ARGB to Grayed ARGB.
+LIBYUV_API
+int ARGBGrayTo(const uint8_t* src_argb,
+               int src_stride_argb,
+               uint8_t* dst_argb,
+               int dst_stride_argb,
+               int width,
+               int height) {
+  int y;
+  void (*ARGBGrayRow)(const uint8_t* src_argb, uint8_t* dst_argb, int width) =
+      ARGBGrayRow_C;
+  if (!src_argb || !dst_argb || width <= 0 || height == 0) {
+    return -1;
+  }
+  if (height < 0) {
+    height = -height;
+    src_argb = src_argb + (height - 1) * src_stride_argb;
+    src_stride_argb = -src_stride_argb;
+  }
+  // Coalesce rows.
+  if (src_stride_argb == width * 4 && dst_stride_argb == width * 4) {
+    width *= height;
+    height = 1;
+    src_stride_argb = dst_stride_argb = 0;
+  }
+#if defined(HAS_ARGBGRAYROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3) && IS_ALIGNED(width, 8)) {
+    ARGBGrayRow = ARGBGrayRow_SSSE3;
+  }
+#endif
+#if defined(HAS_ARGBGRAYROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON) && IS_ALIGNED(width, 8)) {
+    ARGBGrayRow = ARGBGrayRow_NEON;
+  }
+#endif
+#if defined(HAS_ARGBGRAYROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA) && IS_ALIGNED(width, 8)) {
+    ARGBGrayRow = ARGBGrayRow_MSA;
+  }
+#endif
+#if defined(HAS_ARGBGRAYROW_LASX)
+  if (TestCpuFlag(kCpuHasLASX) && IS_ALIGNED(width, 16)) {
+    ARGBGrayRow = ARGBGrayRow_LASX;
+  }
+#endif
+
+  for (y = 0; y < height; ++y) {
+    ARGBGrayRow(src_argb, dst_argb, width);
+    src_argb += src_stride_argb;
+    dst_argb += dst_stride_argb;
+  }
+  return 0;
+}
+
+// Make a rectangle of ARGB gray scale.
+LIBYUV_API
+int ARGBGray(uint8_t* dst_argb,
+             int dst_stride_argb,
+             int dst_x,
+             int dst_y,
+             int width,
+             int height) {
+  int y;
+  void (*ARGBGrayRow)(const uint8_t* src_argb, uint8_t* dst_argb, int width) =
+      ARGBGrayRow_C;
+  uint8_t* dst = dst_argb + dst_y * dst_stride_argb + dst_x * 4;
+  if (!dst_argb || width <= 0 || height <= 0 || dst_x < 0 || dst_y < 0) {
+    return -1;
+  }
+  // Coalesce rows.
+  if (dst_stride_argb == width * 4) {
+    width *= height;
+    height = 1;
+    dst_stride_argb = 0;
+  }
+#if defined(HAS_ARGBGRAYROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3) && IS_ALIGNED(width, 8)) {
+    ARGBGrayRow = ARGBGrayRow_SSSE3;
+  }
+#endif
+#if defined(HAS_ARGBGRAYROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON) && IS_ALIGNED(width, 8)) {
+    ARGBGrayRow = ARGBGrayRow_NEON;
+  }
+#endif
+#if defined(HAS_ARGBGRAYROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA) && IS_ALIGNED(width, 8)) {
+    ARGBGrayRow = ARGBGrayRow_MSA;
+  }
+#endif
+#if defined(HAS_ARGBGRAYROW_LASX)
+  if (TestCpuFlag(kCpuHasLASX) && IS_ALIGNED(width, 16)) {
+    ARGBGrayRow = ARGBGrayRow_LASX;
+  }
+#endif
+
+  for (y = 0; y < height; ++y) {
+    ARGBGrayRow(dst, dst, width);
+    dst += dst_stride_argb;
+  }
+  return 0;
+}
+
+// Make a rectangle of ARGB Sepia tone.
+LIBYUV_API
+int ARGBSepia(uint8_t* dst_argb,
+              int dst_stride_argb,
+              int dst_x,
+              int dst_y,
+              int width,
+              int height) {
+  int y;
+  void (*ARGBSepiaRow)(uint8_t * dst_argb, int width) = ARGBSepiaRow_C;
+  uint8_t* dst = dst_argb + dst_y * dst_stride_argb + dst_x * 4;
+  if (!dst_argb || width <= 0 || height <= 0 || dst_x < 0 || dst_y < 0) {
+    return -1;
+  }
+  // Coalesce rows.
+  if (dst_stride_argb == width * 4) {
+    width *= height;
+    height = 1;
+    dst_stride_argb = 0;
+  }
+#if defined(HAS_ARGBSEPIAROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3) && IS_ALIGNED(width, 8)) {
+    ARGBSepiaRow = ARGBSepiaRow_SSSE3;
+  }
+#endif
+#if defined(HAS_ARGBSEPIAROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON) && IS_ALIGNED(width, 8)) {
+    ARGBSepiaRow = ARGBSepiaRow_NEON;
+  }
+#endif
+#if defined(HAS_ARGBSEPIAROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA) && IS_ALIGNED(width, 8)) {
+    ARGBSepiaRow = ARGBSepiaRow_MSA;
+  }
+#endif
+#if defined(HAS_ARGBSEPIAROW_LASX)
+  if (TestCpuFlag(kCpuHasLASX) && IS_ALIGNED(width, 16)) {
+    ARGBSepiaRow = ARGBSepiaRow_LASX;
+  }
+#endif
+
+  for (y = 0; y < height; ++y) {
+    ARGBSepiaRow(dst, width);
+    dst += dst_stride_argb;
+  }
+  return 0;
+}
+
+// Apply a 4x4 matrix to each ARGB pixel.
+// Note: Normally for shading, but can be used to swizzle or invert.
+LIBYUV_API
+int ARGBColorMatrix(const uint8_t* src_argb,
+                    int src_stride_argb,
+                    uint8_t* dst_argb,
+                    int dst_stride_argb,
+                    const int8_t* matrix_argb,
+                    int width,
+                    int height) {
+  int y;
+  void (*ARGBColorMatrixRow)(const uint8_t* src_argb, uint8_t* dst_argb,
+                             const int8_t* matrix_argb, int width) =
+      ARGBColorMatrixRow_C;
+  if (!src_argb || !dst_argb || !matrix_argb || width <= 0 || height == 0) {
+    return -1;
+  }
+  if (height < 0) {
+    height = -height;
+    src_argb = src_argb + (height - 1) * src_stride_argb;
+    src_stride_argb = -src_stride_argb;
+  }
+  // Coalesce rows.
+  if (src_stride_argb == width * 4 && dst_stride_argb == width * 4) {
+    width *= height;
+    height = 1;
+    src_stride_argb = dst_stride_argb = 0;
+  }
+#if defined(HAS_ARGBCOLORMATRIXROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3) && IS_ALIGNED(width, 8)) {
+    ARGBColorMatrixRow = ARGBColorMatrixRow_SSSE3;
+  }
+#endif
+#if defined(HAS_ARGBCOLORMATRIXROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON) && IS_ALIGNED(width, 8)) {
+    ARGBColorMatrixRow = ARGBColorMatrixRow_NEON;
+  }
+#endif
+#if defined(HAS_ARGBCOLORMATRIXROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA) && IS_ALIGNED(width, 8)) {
+    ARGBColorMatrixRow = ARGBColorMatrixRow_MSA;
+  }
+#endif
+#if defined(HAS_ARGBCOLORMATRIXROW_LSX)
+  if (TestCpuFlag(kCpuHasLSX) && IS_ALIGNED(width, 8)) {
+    ARGBColorMatrixRow = ARGBColorMatrixRow_LSX;
+  }
+#endif
+  for (y = 0; y < height; ++y) {
+    ARGBColorMatrixRow(src_argb, dst_argb, matrix_argb, width);
+    src_argb += src_stride_argb;
+    dst_argb += dst_stride_argb;
+  }
+  return 0;
+}
+
+// Apply a 4x3 matrix to each ARGB pixel.
+// Deprecated.
+LIBYUV_API
+int RGBColorMatrix(uint8_t* dst_argb,
+                   int dst_stride_argb,
+                   const int8_t* matrix_rgb,
+                   int dst_x,
+                   int dst_y,
+                   int width,
+                   int height) {
+  SIMD_ALIGNED(int8_t matrix_argb[16]);
+  uint8_t* dst = dst_argb + dst_y * dst_stride_argb + dst_x * 4;
+  if (!dst_argb || !matrix_rgb || width <= 0 || height <= 0 || dst_x < 0 ||
+      dst_y < 0) {
+    return -1;
+  }
+
+  // Convert 4x3 7 bit matrix to 4x4 6 bit matrix.
+  matrix_argb[0] = matrix_rgb[0] / 2;
+  matrix_argb[1] = matrix_rgb[1] / 2;
+  matrix_argb[2] = matrix_rgb[2] / 2;
+  matrix_argb[3] = matrix_rgb[3] / 2;
+  matrix_argb[4] = matrix_rgb[4] / 2;
+  matrix_argb[5] = matrix_rgb[5] / 2;
+  matrix_argb[6] = matrix_rgb[6] / 2;
+  matrix_argb[7] = matrix_rgb[7] / 2;
+  matrix_argb[8] = matrix_rgb[8] / 2;
+  matrix_argb[9] = matrix_rgb[9] / 2;
+  matrix_argb[10] = matrix_rgb[10] / 2;
+  matrix_argb[11] = matrix_rgb[11] / 2;
+  matrix_argb[14] = matrix_argb[13] = matrix_argb[12] = 0;
+  matrix_argb[15] = 64;  // 1.0
+
+  return ARGBColorMatrix((const uint8_t*)(dst), dst_stride_argb, dst,
+                         dst_stride_argb, &matrix_argb[0], width, height);
+}
+
+// Apply a color table each ARGB pixel.
+// Table contains 256 ARGB values.
+LIBYUV_API
+int ARGBColorTable(uint8_t* dst_argb,
+                   int dst_stride_argb,
+                   const uint8_t* table_argb,
+                   int dst_x,
+                   int dst_y,
+                   int width,
+                   int height) {
+  int y;
+  void (*ARGBColorTableRow)(uint8_t * dst_argb, const uint8_t* table_argb,
+                            int width) = ARGBColorTableRow_C;
+  uint8_t* dst = dst_argb + dst_y * dst_stride_argb + dst_x * 4;
+  if (!dst_argb || !table_argb || width <= 0 || height <= 0 || dst_x < 0 ||
+      dst_y < 0) {
+    return -1;
+  }
+  // Coalesce rows.
+  if (dst_stride_argb == width * 4) {
+    width *= height;
+    height = 1;
+    dst_stride_argb = 0;
+  }
+#if defined(HAS_ARGBCOLORTABLEROW_X86)
+  if (TestCpuFlag(kCpuHasX86)) {
+    ARGBColorTableRow = ARGBColorTableRow_X86;
+  }
+#endif
+  for (y = 0; y < height; ++y) {
+    ARGBColorTableRow(dst, table_argb, width);
+    dst += dst_stride_argb;
+  }
+  return 0;
+}
+
+// Apply a color table each ARGB pixel but preserve destination alpha.
+// Table contains 256 ARGB values.
+LIBYUV_API
+int RGBColorTable(uint8_t* dst_argb,
+                  int dst_stride_argb,
+                  const uint8_t* table_argb,
+                  int dst_x,
+                  int dst_y,
+                  int width,
+                  int height) {
+  int y;
+  void (*RGBColorTableRow)(uint8_t * dst_argb, const uint8_t* table_argb,
+                           int width) = RGBColorTableRow_C;
+  uint8_t* dst = dst_argb + dst_y * dst_stride_argb + dst_x * 4;
+  if (!dst_argb || !table_argb || width <= 0 || height <= 0 || dst_x < 0 ||
+      dst_y < 0) {
+    return -1;
+  }
+  // Coalesce rows.
+  if (dst_stride_argb == width * 4) {
+    width *= height;
+    height = 1;
+    dst_stride_argb = 0;
+  }
+#if defined(HAS_RGBCOLORTABLEROW_X86)
+  if (TestCpuFlag(kCpuHasX86)) {
+    RGBColorTableRow = RGBColorTableRow_X86;
+  }
+#endif
+  for (y = 0; y < height; ++y) {
+    RGBColorTableRow(dst, table_argb, width);
+    dst += dst_stride_argb;
+  }
+  return 0;
+}
+
+// ARGBQuantize is used to posterize art.
+// e.g. rgb / qvalue * qvalue + qvalue / 2
+// But the low levels implement efficiently with 3 parameters, and could be
+// used for other high level operations.
+// dst_argb[0] = (b * scale >> 16) * interval_size + interval_offset;
+// where scale is 1 / interval_size as a fixed point value.
+// The divide is replaces with a multiply by reciprocal fixed point multiply.
+// Caveat - although SSE2 saturates, the C function does not and should be used
+// with care if doing anything but quantization.
+LIBYUV_API
+int ARGBQuantize(uint8_t* dst_argb,
+                 int dst_stride_argb,
+                 int scale,
+                 int interval_size,
+                 int interval_offset,
+                 int dst_x,
+                 int dst_y,
+                 int width,
+                 int height) {
+  int y;
+  void (*ARGBQuantizeRow)(uint8_t * dst_argb, int scale, int interval_size,
+                          int interval_offset, int width) = ARGBQuantizeRow_C;
+  uint8_t* dst = dst_argb + dst_y * dst_stride_argb + dst_x * 4;
+  if (!dst_argb || width <= 0 || height <= 0 || dst_x < 0 || dst_y < 0 ||
+      interval_size < 1 || interval_size > 255) {
+    return -1;
+  }
+  // Coalesce rows.
+  if (dst_stride_argb == width * 4) {
+    width *= height;
+    height = 1;
+    dst_stride_argb = 0;
+  }
+#if defined(HAS_ARGBQUANTIZEROW_SSE2)
+  if (TestCpuFlag(kCpuHasSSE2) && IS_ALIGNED(width, 4)) {
+    ARGBQuantizeRow = ARGBQuantizeRow_SSE2;
+  }
+#endif
+#if defined(HAS_ARGBQUANTIZEROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON) && IS_ALIGNED(width, 8)) {
+    ARGBQuantizeRow = ARGBQuantizeRow_NEON;
+  }
+#endif
+#if defined(HAS_ARGBQUANTIZEROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA) && IS_ALIGNED(width, 8)) {
+    ARGBQuantizeRow = ARGBQuantizeRow_MSA;
+  }
+#endif
+#if defined(HAS_ARGBQUANTIZEROW_LSX)
+  if (TestCpuFlag(kCpuHasLSX) && IS_ALIGNED(width, 8)) {
+    ARGBQuantizeRow = ARGBQuantizeRow_LSX;
+  }
+#endif
+  for (y = 0; y < height; ++y) {
+    ARGBQuantizeRow(dst, scale, interval_size, interval_offset, width);
+    dst += dst_stride_argb;
+  }
+  return 0;
+}
+
+// Computes table of cumulative sum for image where the value is the sum
+// of all values above and to the left of the entry. Used by ARGBBlur.
+LIBYUV_API
+int ARGBComputeCumulativeSum(const uint8_t* src_argb,
+                             int src_stride_argb,
+                             int32_t* dst_cumsum,
+                             int dst_stride32_cumsum,
+                             int width,
+                             int height) {
+  int y;
+  void (*ComputeCumulativeSumRow)(const uint8_t* row, int32_t* cumsum,
+                                  const int32_t* previous_cumsum, int width) =
+      ComputeCumulativeSumRow_C;
+  int32_t* previous_cumsum = dst_cumsum;
+  if (!dst_cumsum || !src_argb || width <= 0 || height <= 0) {
+    return -1;
+  }
+#if defined(HAS_CUMULATIVESUMTOAVERAGEROW_SSE2)
+  if (TestCpuFlag(kCpuHasSSE2)) {
+    ComputeCumulativeSumRow = ComputeCumulativeSumRow_SSE2;
+  }
+#endif
+
+  memset(dst_cumsum, 0, width * sizeof(dst_cumsum[0]) * 4);  // 4 int per pixel.
+  for (y = 0; y < height; ++y) {
+    ComputeCumulativeSumRow(src_argb, dst_cumsum, previous_cumsum, width);
+    previous_cumsum = dst_cumsum;
+    dst_cumsum += dst_stride32_cumsum;
+    src_argb += src_stride_argb;
+  }
+  return 0;
+}
+
+// Blur ARGB image.
+// Caller should allocate CumulativeSum table of width * height * 16 bytes
+// aligned to 16 byte boundary. height can be radius * 2 + 2 to save memory
+// as the buffer is treated as circular.
+LIBYUV_API
+int ARGBBlur(const uint8_t* src_argb,
+             int src_stride_argb,
+             uint8_t* dst_argb,
+             int dst_stride_argb,
+             int32_t* dst_cumsum,
+             int dst_stride32_cumsum,
+             int width,
+             int height,
+             int radius) {
+  int y;
+  void (*ComputeCumulativeSumRow)(const uint8_t* row, int32_t* cumsum,
+                                  const int32_t* previous_cumsum, int width) =
+      ComputeCumulativeSumRow_C;
+  void (*CumulativeSumToAverageRow)(
+      const int32_t* topleft, const int32_t* botleft, int width, int area,
+      uint8_t* dst, int count) = CumulativeSumToAverageRow_C;
+  int32_t* cumsum_bot_row;
+  int32_t* max_cumsum_bot_row;
+  int32_t* cumsum_top_row;
+
+  if (!src_argb || !dst_argb || width <= 0 || height == 0) {
+    return -1;
+  }
+  if (height < 0) {
+    height = -height;
+    src_argb = src_argb + (height - 1) * src_stride_argb;
+    src_stride_argb = -src_stride_argb;
+  }
+  if (radius > height) {
+    radius = height;
+  }
+  if (radius > (width / 2 - 1)) {
+    radius = width / 2 - 1;
+  }
+  if (radius <= 0 || height <= 1) {
+    return -1;
+  }
+#if defined(HAS_CUMULATIVESUMTOAVERAGEROW_SSE2)
+  if (TestCpuFlag(kCpuHasSSE2)) {
+    ComputeCumulativeSumRow = ComputeCumulativeSumRow_SSE2;
+    CumulativeSumToAverageRow = CumulativeSumToAverageRow_SSE2;
+  }
+#endif
+  // Compute enough CumulativeSum for first row to be blurred. After this
+  // one row of CumulativeSum is updated at a time.
+  ARGBComputeCumulativeSum(src_argb, src_stride_argb, dst_cumsum,
+                           dst_stride32_cumsum, width, radius);
+
+  src_argb = src_argb + radius * src_stride_argb;
+  cumsum_bot_row = &dst_cumsum[(radius - 1) * dst_stride32_cumsum];
+
+  max_cumsum_bot_row = &dst_cumsum[(radius * 2 + 2) * dst_stride32_cumsum];
+  cumsum_top_row = &dst_cumsum[0];
+
+  for (y = 0; y < height; ++y) {
+    int top_y = ((y - radius - 1) >= 0) ? (y - radius - 1) : 0;
+    int bot_y = ((y + radius) < height) ? (y + radius) : (height - 1);
+    int area = radius * (bot_y - top_y);
+    int boxwidth = radius * 4;
+    int x;
+    int n;
+
+    // Increment cumsum_top_row pointer with circular buffer wrap around.
+    if (top_y) {
+      cumsum_top_row += dst_stride32_cumsum;
+      if (cumsum_top_row >= max_cumsum_bot_row) {
+        cumsum_top_row = dst_cumsum;
+      }
+    }
+    // Increment cumsum_bot_row pointer with circular buffer wrap around and
+    // then fill in a row of CumulativeSum.
+    if ((y + radius) < height) {
+      const int32_t* prev_cumsum_bot_row = cumsum_bot_row;
+      cumsum_bot_row += dst_stride32_cumsum;
+      if (cumsum_bot_row >= max_cumsum_bot_row) {
+        cumsum_bot_row = dst_cumsum;
+      }
+      ComputeCumulativeSumRow(src_argb, cumsum_bot_row, prev_cumsum_bot_row,
+                              width);
+      src_argb += src_stride_argb;
+    }
+
+    // Left clipped.
+    for (x = 0; x < radius + 1; ++x) {
+      CumulativeSumToAverageRow(cumsum_top_row, cumsum_bot_row, boxwidth, area,
+                                &dst_argb[x * 4], 1);
+      area += (bot_y - top_y);
+      boxwidth += 4;
+    }
+
+    // Middle unclipped.
+    n = (width - 1) - radius - x + 1;
+    CumulativeSumToAverageRow(cumsum_top_row, cumsum_bot_row, boxwidth, area,
+                              &dst_argb[x * 4], n);
+
+    // Right clipped.
+    for (x += n; x <= width - 1; ++x) {
+      area -= (bot_y - top_y);
+      boxwidth -= 4;
+      CumulativeSumToAverageRow(cumsum_top_row + (x - radius - 1) * 4,
+                                cumsum_bot_row + (x - radius - 1) * 4, boxwidth,
+                                area, &dst_argb[x * 4], 1);
+    }
+    dst_argb += dst_stride_argb;
+  }
+  return 0;
+}
+
+// Multiply ARGB image by a specified ARGB value.
+LIBYUV_API
+int ARGBShade(const uint8_t* src_argb,
+              int src_stride_argb,
+              uint8_t* dst_argb,
+              int dst_stride_argb,
+              int width,
+              int height,
+              uint32_t value) {
+  int y;
+  void (*ARGBShadeRow)(const uint8_t* src_argb, uint8_t* dst_argb, int width,
+                       uint32_t value) = ARGBShadeRow_C;
+  if (!src_argb || !dst_argb || width <= 0 || height == 0 || value == 0u) {
+    return -1;
+  }
+  if (height < 0) {
+    height = -height;
+    src_argb = src_argb + (height - 1) * src_stride_argb;
+    src_stride_argb = -src_stride_argb;
+  }
+  // Coalesce rows.
+  if (src_stride_argb == width * 4 && dst_stride_argb == width * 4) {
+    width *= height;
+    height = 1;
+    src_stride_argb = dst_stride_argb = 0;
+  }
+#if defined(HAS_ARGBSHADEROW_SSE2)
+  if (TestCpuFlag(kCpuHasSSE2) && IS_ALIGNED(width, 4)) {
+    ARGBShadeRow = ARGBShadeRow_SSE2;
+  }
+#endif
+#if defined(HAS_ARGBSHADEROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON) && IS_ALIGNED(width, 8)) {
+    ARGBShadeRow = ARGBShadeRow_NEON;
+  }
+#endif
+#if defined(HAS_ARGBSHADEROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA) && IS_ALIGNED(width, 4)) {
+    ARGBShadeRow = ARGBShadeRow_MSA;
+  }
+#endif
+#if defined(HAS_ARGBSHADEROW_LASX)
+  if (TestCpuFlag(kCpuHasLASX) && IS_ALIGNED(width, 8)) {
+    ARGBShadeRow = ARGBShadeRow_LASX;
+  }
+#endif
+
+  for (y = 0; y < height; ++y) {
+    ARGBShadeRow(src_argb, dst_argb, width, value);
+    src_argb += src_stride_argb;
+    dst_argb += dst_stride_argb;
+  }
+  return 0;
+}
+
+// Interpolate 2 planes by specified amount (0 to 255).
+LIBYUV_API
+int InterpolatePlane(const uint8_t* src0,
+                     int src_stride0,
+                     const uint8_t* src1,
+                     int src_stride1,
+                     uint8_t* dst,
+                     int dst_stride,
+                     int width,
+                     int height,
+                     int interpolation) {
+  int y;
+  void (*InterpolateRow)(uint8_t * dst_ptr, const uint8_t* src_ptr,
+                         ptrdiff_t src_stride, int dst_width,
+                         int source_y_fraction) = InterpolateRow_C;
+  if (!src0 || !src1 || !dst || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    dst = dst + (height - 1) * dst_stride;
+    dst_stride = -dst_stride;
+  }
+  // Coalesce rows.
+  if (src_stride0 == width && src_stride1 == width && dst_stride == width) {
+    width *= height;
+    height = 1;
+    src_stride0 = src_stride1 = dst_stride = 0;
+  }
+#if defined(HAS_INTERPOLATEROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    InterpolateRow = InterpolateRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 16)) {
+      InterpolateRow = InterpolateRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_INTERPOLATEROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    InterpolateRow = InterpolateRow_Any_AVX2;
+    if (IS_ALIGNED(width, 32)) {
+      InterpolateRow = InterpolateRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_INTERPOLATEROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    InterpolateRow = InterpolateRow_Any_NEON;
+    if (IS_ALIGNED(width, 16)) {
+      InterpolateRow = InterpolateRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_INTERPOLATEROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    InterpolateRow = InterpolateRow_Any_MSA;
+    if (IS_ALIGNED(width, 32)) {
+      InterpolateRow = InterpolateRow_MSA;
+    }
+  }
+#endif
+#if defined(HAS_INTERPOLATEROW_LSX)
+  if (TestCpuFlag(kCpuHasLSX)) {
+    InterpolateRow = InterpolateRow_Any_LSX;
+    if (IS_ALIGNED(width, 32)) {
+      InterpolateRow = InterpolateRow_LSX;
+    }
+  }
+#endif
+
+  for (y = 0; y < height; ++y) {
+    InterpolateRow(dst, src0, src1 - src0, width, interpolation);
+    src0 += src_stride0;
+    src1 += src_stride1;
+    dst += dst_stride;
+  }
+  return 0;
+}
+
+// Interpolate 2 planes by specified amount (0 to 255).
+LIBYUV_API
+int InterpolatePlane_16(const uint16_t* src0,
+                        int src_stride0,
+                        const uint16_t* src1,
+                        int src_stride1,
+                        uint16_t* dst,
+                        int dst_stride,
+                        int width,
+                        int height,
+                        int interpolation) {
+  int y;
+  void (*InterpolateRow_16)(uint16_t * dst_ptr, const uint16_t* src_ptr,
+                            ptrdiff_t src_stride, int dst_width,
+                            int source_y_fraction) = InterpolateRow_16_C;
+  if (!src0 || !src1 || !dst || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    dst = dst + (height - 1) * dst_stride;
+    dst_stride = -dst_stride;
+  }
+  // Coalesce rows.
+  if (src_stride0 == width && src_stride1 == width && dst_stride == width) {
+    width *= height;
+    height = 1;
+    src_stride0 = src_stride1 = dst_stride = 0;
+  }
+#if defined(HAS_INTERPOLATEROW_16_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    InterpolateRow_16 = InterpolateRow_16_Any_SSSE3;
+    if (IS_ALIGNED(width, 16)) {
+      InterpolateRow_16 = InterpolateRow_16_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_INTERPOLATEROW_16_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    InterpolateRow_16 = InterpolateRow_16_Any_AVX2;
+    if (IS_ALIGNED(width, 32)) {
+      InterpolateRow_16 = InterpolateRow_16_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_INTERPOLATEROW_16_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    InterpolateRow_16 = InterpolateRow_16_Any_NEON;
+    if (IS_ALIGNED(width, 8)) {
+      InterpolateRow_16 = InterpolateRow_16_NEON;
+    }
+  }
+#endif
+#if defined(HAS_INTERPOLATEROW_16_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    InterpolateRow_16 = InterpolateRow_16_Any_MSA;
+    if (IS_ALIGNED(width, 32)) {
+      InterpolateRow_16 = InterpolateRow_16_MSA;
+    }
+  }
+#endif
+#if defined(HAS_INTERPOLATEROW_16_LSX)
+  if (TestCpuFlag(kCpuHasLSX)) {
+    InterpolateRow_16 = InterpolateRow_16_Any_LSX;
+    if (IS_ALIGNED(width, 32)) {
+      InterpolateRow_16 = InterpolateRow_16_LSX;
+    }
+  }
+#endif
+
+  for (y = 0; y < height; ++y) {
+    InterpolateRow_16(dst, src0, src1 - src0, width, interpolation);
+    src0 += src_stride0;
+    src1 += src_stride1;
+    dst += dst_stride;
+  }
+  return 0;
+}
+
+// Interpolate 2 ARGB images by specified amount (0 to 255).
+LIBYUV_API
+int ARGBInterpolate(const uint8_t* src_argb0,
+                    int src_stride_argb0,
+                    const uint8_t* src_argb1,
+                    int src_stride_argb1,
+                    uint8_t* dst_argb,
+                    int dst_stride_argb,
+                    int width,
+                    int height,
+                    int interpolation) {
+  return InterpolatePlane(src_argb0, src_stride_argb0, src_argb1,
+                          src_stride_argb1, dst_argb, dst_stride_argb,
+                          width * 4, height, interpolation);
+}
+
+// Interpolate 2 YUV images by specified amount (0 to 255).
+LIBYUV_API
+int I420Interpolate(const uint8_t* src0_y,
+                    int src0_stride_y,
+                    const uint8_t* src0_u,
+                    int src0_stride_u,
+                    const uint8_t* src0_v,
+                    int src0_stride_v,
+                    const uint8_t* src1_y,
+                    int src1_stride_y,
+                    const uint8_t* src1_u,
+                    int src1_stride_u,
+                    const uint8_t* src1_v,
+                    int src1_stride_v,
+                    uint8_t* dst_y,
+                    int dst_stride_y,
+                    uint8_t* dst_u,
+                    int dst_stride_u,
+                    uint8_t* dst_v,
+                    int dst_stride_v,
+                    int width,
+                    int height,
+                    int interpolation) {
+  int halfwidth = (width + 1) >> 1;
+  int halfheight = (height + 1) >> 1;
+
+  if (!src0_y || !src0_u || !src0_v || !src1_y || !src1_u || !src1_v ||
+      !dst_y || !dst_u || !dst_v || width <= 0 || height == 0) {
+    return -1;
+  }
+
+  InterpolatePlane(src0_y, src0_stride_y, src1_y, src1_stride_y, dst_y,
+                   dst_stride_y, width, height, interpolation);
+  InterpolatePlane(src0_u, src0_stride_u, src1_u, src1_stride_u, dst_u,
+                   dst_stride_u, halfwidth, halfheight, interpolation);
+  InterpolatePlane(src0_v, src0_stride_v, src1_v, src1_stride_v, dst_v,
+                   dst_stride_v, halfwidth, halfheight, interpolation);
+  return 0;
+}
+
+// Shuffle ARGB channel order.  e.g. BGRA to ARGB.
+LIBYUV_API
+int ARGBShuffle(const uint8_t* src_bgra,
+                int src_stride_bgra,
+                uint8_t* dst_argb,
+                int dst_stride_argb,
+                const uint8_t* shuffler,
+                int width,
+                int height) {
+  int y;
+  void (*ARGBShuffleRow)(const uint8_t* src_bgra, uint8_t* dst_argb,
+                         const uint8_t* shuffler, int width) = ARGBShuffleRow_C;
+  if (!src_bgra || !dst_argb || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    src_bgra = src_bgra + (height - 1) * src_stride_bgra;
+    src_stride_bgra = -src_stride_bgra;
+  }
+  // Coalesce rows.
+  if (src_stride_bgra == width * 4 && dst_stride_argb == width * 4) {
+    width *= height;
+    height = 1;
+    src_stride_bgra = dst_stride_argb = 0;
+  }
+#if defined(HAS_ARGBSHUFFLEROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    ARGBShuffleRow = ARGBShuffleRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 8)) {
+      ARGBShuffleRow = ARGBShuffleRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_ARGBSHUFFLEROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ARGBShuffleRow = ARGBShuffleRow_Any_AVX2;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBShuffleRow = ARGBShuffleRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_ARGBSHUFFLEROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    ARGBShuffleRow = ARGBShuffleRow_Any_NEON;
+    if (IS_ALIGNED(width, 4)) {
+      ARGBShuffleRow = ARGBShuffleRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_ARGBSHUFFLEROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    ARGBShuffleRow = ARGBShuffleRow_Any_MSA;
+    if (IS_ALIGNED(width, 8)) {
+      ARGBShuffleRow = ARGBShuffleRow_MSA;
+    }
+  }
+#endif
+#if defined(HAS_ARGBSHUFFLEROW_LASX)
+  if (TestCpuFlag(kCpuHasLASX)) {
+    ARGBShuffleRow = ARGBShuffleRow_Any_LASX;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBShuffleRow = ARGBShuffleRow_LASX;
+    }
+  }
+#endif
+
+  for (y = 0; y < height; ++y) {
+    ARGBShuffleRow(src_bgra, dst_argb, shuffler, width);
+    src_bgra += src_stride_bgra;
+    dst_argb += dst_stride_argb;
+  }
+  return 0;
+}
+
+// Shuffle AR64 channel order.  e.g. AR64 to AB64.
+LIBYUV_API
+int AR64Shuffle(const uint16_t* src_ar64,
+                int src_stride_ar64,
+                uint16_t* dst_ar64,
+                int dst_stride_ar64,
+                const uint8_t* shuffler,
+                int width,
+                int height) {
+  int y;
+  void (*AR64ShuffleRow)(const uint8_t* src_ar64, uint8_t* dst_ar64,
+                         const uint8_t* shuffler, int width) = AR64ShuffleRow_C;
+  if (!src_ar64 || !dst_ar64 || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    src_ar64 = src_ar64 + (height - 1) * src_stride_ar64;
+    src_stride_ar64 = -src_stride_ar64;
+  }
+  // Coalesce rows.
+  if (src_stride_ar64 == width * 4 && dst_stride_ar64 == width * 4) {
+    width *= height;
+    height = 1;
+    src_stride_ar64 = dst_stride_ar64 = 0;
+  }
+  // Assembly versions can be reused if it's implemented with shuffle.
+#if defined(HAS_ARGBSHUFFLEROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    AR64ShuffleRow = ARGBShuffleRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 8)) {
+      AR64ShuffleRow = ARGBShuffleRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_ARGBSHUFFLEROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    AR64ShuffleRow = ARGBShuffleRow_Any_AVX2;
+    if (IS_ALIGNED(width, 16)) {
+      AR64ShuffleRow = ARGBShuffleRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_ARGBSHUFFLEROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    AR64ShuffleRow = ARGBShuffleRow_Any_NEON;
+    if (IS_ALIGNED(width, 4)) {
+      AR64ShuffleRow = ARGBShuffleRow_NEON;
+    }
+  }
+#endif
+
+  for (y = 0; y < height; ++y) {
+    AR64ShuffleRow((uint8_t*)(src_ar64), (uint8_t*)(dst_ar64), shuffler,
+                   width * 2);
+    src_ar64 += src_stride_ar64;
+    dst_ar64 += dst_stride_ar64;
+  }
+  return 0;
+}
+
+// Gauss blur a float plane using Gaussian 5x5 filter with
+// coefficients of 1, 4, 6, 4, 1.
+// Each destination pixel is a blur of the 5x5
+// pixels from the source.
+// Source edges are clamped.
+// Edge is 2 pixels on each side, and interior is multiple of 4.
+LIBYUV_API
+int GaussPlane_F32(const float* src,
+                   int src_stride,
+                   float* dst,
+                   int dst_stride,
+                   int width,
+                   int height) {
+  int y;
+  void (*GaussCol_F32)(const float* src0, const float* src1, const float* src2,
+                       const float* src3, const float* src4, float* dst,
+                       int width) = GaussCol_F32_C;
+  void (*GaussRow_F32)(const float* src, float* dst, int width) =
+      GaussRow_F32_C;
+  if (!src || !dst || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    src = src + (height - 1) * src_stride;
+    src_stride = -src_stride;
+  }
+
+#if defined(HAS_GAUSSCOL_F32_NEON)
+  if (TestCpuFlag(kCpuHasNEON) && IS_ALIGNED(width, 8)) {
+    GaussCol_F32 = GaussCol_F32_NEON;
+  }
+#endif
+#if defined(HAS_GAUSSROW_F32_NEON)
+  if (TestCpuFlag(kCpuHasNEON) && IS_ALIGNED(width, 8)) {
+    GaussRow_F32 = GaussRow_F32_NEON;
+  }
+#endif
+  {
+    // 2 pixels on each side, but aligned out to 16 bytes.
+    align_buffer_64(rowbuf, (4 + width + 4) * 4);
+    memset(rowbuf, 0, 16);
+    memset(rowbuf + (4 + width) * 4, 0, 16);
+    float* row = (float*)(rowbuf + 16);
+    const float* src0 = src;
+    const float* src1 = src;
+    const float* src2 = src;
+    const float* src3 = src2 + ((height > 1) ? src_stride : 0);
+    const float* src4 = src3 + ((height > 2) ? src_stride : 0);
+
+    for (y = 0; y < height; ++y) {
+      GaussCol_F32(src0, src1, src2, src3, src4, row, width);
+
+      // Extrude edge by 2 floats
+      row[-2] = row[-1] = row[0];
+      row[width + 1] = row[width] = row[width - 1];
+
+      GaussRow_F32(row - 2, dst, width);
+
+      src0 = src1;
+      src1 = src2;
+      src2 = src3;
+      src3 = src4;
+      if ((y + 2) < (height - 1)) {
+        src4 += src_stride;
+      }
+      dst += dst_stride;
+    }
+    free_aligned_buffer_64(rowbuf);
+  }
+  return 0;
+}
+
+// Sobel ARGB effect.
+static int ARGBSobelize(const uint8_t* src_argb,
+                        int src_stride_argb,
+                        uint8_t* dst_argb,
+                        int dst_stride_argb,
+                        int width,
+                        int height,
+                        void (*SobelRow)(const uint8_t* src_sobelx,
+                                         const uint8_t* src_sobely,
+                                         uint8_t* dst,
+                                         int width)) {
+  int y;
+  void (*ARGBToYJRow)(const uint8_t* src_argb, uint8_t* dst_g, int width) =
+      ARGBToYJRow_C;
+  void (*SobelYRow)(const uint8_t* src_y0, const uint8_t* src_y1,
+                    uint8_t* dst_sobely, int width) = SobelYRow_C;
+  void (*SobelXRow)(const uint8_t* src_y0, const uint8_t* src_y1,
+                    const uint8_t* src_y2, uint8_t* dst_sobely, int width) =
+      SobelXRow_C;
+  const int kEdge = 16;  // Extra pixels at start of row for extrude/align.
+  if (!src_argb || !dst_argb || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    src_argb = src_argb + (height - 1) * src_stride_argb;
+    src_stride_argb = -src_stride_argb;
+  }
+
+#if defined(HAS_ARGBTOYJROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    ARGBToYJRow = ARGBToYJRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBToYJRow = ARGBToYJRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOYJROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ARGBToYJRow = ARGBToYJRow_Any_AVX2;
+    if (IS_ALIGNED(width, 32)) {
+      ARGBToYJRow = ARGBToYJRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOYJROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    ARGBToYJRow = ARGBToYJRow_Any_NEON;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBToYJRow = ARGBToYJRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOYJROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    ARGBToYJRow = ARGBToYJRow_Any_MSA;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBToYJRow = ARGBToYJRow_MSA;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOYJROW_LSX)
+  if (TestCpuFlag(kCpuHasLSX)) {
+    ARGBToYJRow = ARGBToYJRow_Any_LSX;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBToYJRow = ARGBToYJRow_LSX;
+    }
+  }
+#endif
+#if defined(HAS_ARGBTOYJROW_LASX)
+  if (TestCpuFlag(kCpuHasLASX)) {
+    ARGBToYJRow = ARGBToYJRow_Any_LASX;
+    if (IS_ALIGNED(width, 32)) {
+      ARGBToYJRow = ARGBToYJRow_LASX;
+    }
+  }
+#endif
+
+#if defined(HAS_SOBELYROW_SSE2)
+  if (TestCpuFlag(kCpuHasSSE2)) {
+    SobelYRow = SobelYRow_SSE2;
+  }
+#endif
+#if defined(HAS_SOBELYROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    SobelYRow = SobelYRow_NEON;
+  }
+#endif
+#if defined(HAS_SOBELYROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    SobelYRow = SobelYRow_MSA;
+  }
+#endif
+#if defined(HAS_SOBELXROW_SSE2)
+  if (TestCpuFlag(kCpuHasSSE2)) {
+    SobelXRow = SobelXRow_SSE2;
+  }
+#endif
+#if defined(HAS_SOBELXROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    SobelXRow = SobelXRow_NEON;
+  }
+#endif
+#if defined(HAS_SOBELXROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    SobelXRow = SobelXRow_MSA;
+  }
+#endif
+  {
+    // 3 rows with edges before/after.
+    const int kRowSize = (width + kEdge + 31) & ~31;
+    align_buffer_64(rows, kRowSize * 2 + (kEdge + kRowSize * 3 + kEdge));
+    uint8_t* row_sobelx = rows;
+    uint8_t* row_sobely = rows + kRowSize;
+    uint8_t* row_y = rows + kRowSize * 2;
+
+    // Convert first row.
+    uint8_t* row_y0 = row_y + kEdge;
+    uint8_t* row_y1 = row_y0 + kRowSize;
+    uint8_t* row_y2 = row_y1 + kRowSize;
+    ARGBToYJRow(src_argb, row_y0, width);
+    row_y0[-1] = row_y0[0];
+    memset(row_y0 + width, row_y0[width - 1], 16);  // Extrude 16 for valgrind.
+    ARGBToYJRow(src_argb, row_y1, width);
+    row_y1[-1] = row_y1[0];
+    memset(row_y1 + width, row_y1[width - 1], 16);
+    memset(row_y2 + width, 0, 16);
+
+    for (y = 0; y < height; ++y) {
+      // Convert next row of ARGB to G.
+      if (y < (height - 1)) {
+        src_argb += src_stride_argb;
+      }
+      ARGBToYJRow(src_argb, row_y2, width);
+      row_y2[-1] = row_y2[0];
+      row_y2[width] = row_y2[width - 1];
+
+      SobelXRow(row_y0 - 1, row_y1 - 1, row_y2 - 1, row_sobelx, width);
+      SobelYRow(row_y0 - 1, row_y2 - 1, row_sobely, width);
+      SobelRow(row_sobelx, row_sobely, dst_argb, width);
+
+      // Cycle thru circular queue of 3 row_y buffers.
+      {
+        uint8_t* row_yt = row_y0;
+        row_y0 = row_y1;
+        row_y1 = row_y2;
+        row_y2 = row_yt;
+      }
+
+      dst_argb += dst_stride_argb;
+    }
+    free_aligned_buffer_64(rows);
+  }
+  return 0;
+}
+
+// Sobel ARGB effect.
+LIBYUV_API
+int ARGBSobel(const uint8_t* src_argb,
+              int src_stride_argb,
+              uint8_t* dst_argb,
+              int dst_stride_argb,
+              int width,
+              int height) {
+  void (*SobelRow)(const uint8_t* src_sobelx, const uint8_t* src_sobely,
+                   uint8_t* dst_argb, int width) = SobelRow_C;
+#if defined(HAS_SOBELROW_SSE2)
+  if (TestCpuFlag(kCpuHasSSE2)) {
+    SobelRow = SobelRow_Any_SSE2;
+    if (IS_ALIGNED(width, 16)) {
+      SobelRow = SobelRow_SSE2;
+    }
+  }
+#endif
+#if defined(HAS_SOBELROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    SobelRow = SobelRow_Any_NEON;
+    if (IS_ALIGNED(width, 8)) {
+      SobelRow = SobelRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_SOBELROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    SobelRow = SobelRow_Any_MSA;
+    if (IS_ALIGNED(width, 16)) {
+      SobelRow = SobelRow_MSA;
+    }
+  }
+#endif
+#if defined(HAS_SOBELROW_LSX)
+  if (TestCpuFlag(kCpuHasLSX)) {
+    SobelRow = SobelRow_Any_LSX;
+    if (IS_ALIGNED(width, 16)) {
+      SobelRow = SobelRow_LSX;
+    }
+  }
+#endif
+  return ARGBSobelize(src_argb, src_stride_argb, dst_argb, dst_stride_argb,
+                      width, height, SobelRow);
+}
+
+// Sobel ARGB effect with planar output.
+LIBYUV_API
+int ARGBSobelToPlane(const uint8_t* src_argb,
+                     int src_stride_argb,
+                     uint8_t* dst_y,
+                     int dst_stride_y,
+                     int width,
+                     int height) {
+  void (*SobelToPlaneRow)(const uint8_t* src_sobelx, const uint8_t* src_sobely,
+                          uint8_t* dst_, int width) = SobelToPlaneRow_C;
+#if defined(HAS_SOBELTOPLANEROW_SSE2)
+  if (TestCpuFlag(kCpuHasSSE2)) {
+    SobelToPlaneRow = SobelToPlaneRow_Any_SSE2;
+    if (IS_ALIGNED(width, 16)) {
+      SobelToPlaneRow = SobelToPlaneRow_SSE2;
+    }
+  }
+#endif
+#if defined(HAS_SOBELTOPLANEROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    SobelToPlaneRow = SobelToPlaneRow_Any_NEON;
+    if (IS_ALIGNED(width, 16)) {
+      SobelToPlaneRow = SobelToPlaneRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_SOBELTOPLANEROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    SobelToPlaneRow = SobelToPlaneRow_Any_MSA;
+    if (IS_ALIGNED(width, 32)) {
+      SobelToPlaneRow = SobelToPlaneRow_MSA;
+    }
+  }
+#endif
+#if defined(HAS_SOBELTOPLANEROW_LSX)
+  if (TestCpuFlag(kCpuHasLSX)) {
+    SobelToPlaneRow = SobelToPlaneRow_Any_LSX;
+    if (IS_ALIGNED(width, 32)) {
+      SobelToPlaneRow = SobelToPlaneRow_LSX;
+    }
+  }
+#endif
+  return ARGBSobelize(src_argb, src_stride_argb, dst_y, dst_stride_y, width,
+                      height, SobelToPlaneRow);
+}
+
+// SobelXY ARGB effect.
+// Similar to Sobel, but also stores Sobel X in R and Sobel Y in B.  G = Sobel.
+LIBYUV_API
+int ARGBSobelXY(const uint8_t* src_argb,
+                int src_stride_argb,
+                uint8_t* dst_argb,
+                int dst_stride_argb,
+                int width,
+                int height) {
+  void (*SobelXYRow)(const uint8_t* src_sobelx, const uint8_t* src_sobely,
+                     uint8_t* dst_argb, int width) = SobelXYRow_C;
+#if defined(HAS_SOBELXYROW_SSE2)
+  if (TestCpuFlag(kCpuHasSSE2)) {
+    SobelXYRow = SobelXYRow_Any_SSE2;
+    if (IS_ALIGNED(width, 16)) {
+      SobelXYRow = SobelXYRow_SSE2;
+    }
+  }
+#endif
+#if defined(HAS_SOBELXYROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    SobelXYRow = SobelXYRow_Any_NEON;
+    if (IS_ALIGNED(width, 8)) {
+      SobelXYRow = SobelXYRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_SOBELXYROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    SobelXYRow = SobelXYRow_Any_MSA;
+    if (IS_ALIGNED(width, 16)) {
+      SobelXYRow = SobelXYRow_MSA;
+    }
+  }
+#endif
+#if defined(HAS_SOBELXYROW_LSX)
+  if (TestCpuFlag(kCpuHasLSX)) {
+    SobelXYRow = SobelXYRow_Any_LSX;
+    if (IS_ALIGNED(width, 16)) {
+      SobelXYRow = SobelXYRow_LSX;
+    }
+  }
+#endif
+  return ARGBSobelize(src_argb, src_stride_argb, dst_argb, dst_stride_argb,
+                      width, height, SobelXYRow);
+}
+
+// Apply a 4x4 polynomial to each ARGB pixel.
+LIBYUV_API
+int ARGBPolynomial(const uint8_t* src_argb,
+                   int src_stride_argb,
+                   uint8_t* dst_argb,
+                   int dst_stride_argb,
+                   const float* poly,
+                   int width,
+                   int height) {
+  int y;
+  void (*ARGBPolynomialRow)(const uint8_t* src_argb, uint8_t* dst_argb,
+                            const float* poly, int width) = ARGBPolynomialRow_C;
+  if (!src_argb || !dst_argb || !poly || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    src_argb = src_argb + (height - 1) * src_stride_argb;
+    src_stride_argb = -src_stride_argb;
+  }
+  // Coalesce rows.
+  if (src_stride_argb == width * 4 && dst_stride_argb == width * 4) {
+    width *= height;
+    height = 1;
+    src_stride_argb = dst_stride_argb = 0;
+  }
+#if defined(HAS_ARGBPOLYNOMIALROW_SSE2)
+  if (TestCpuFlag(kCpuHasSSE2) && IS_ALIGNED(width, 2)) {
+    ARGBPolynomialRow = ARGBPolynomialRow_SSE2;
+  }
+#endif
+#if defined(HAS_ARGBPOLYNOMIALROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2) && TestCpuFlag(kCpuHasFMA3) &&
+      IS_ALIGNED(width, 2)) {
+    ARGBPolynomialRow = ARGBPolynomialRow_AVX2;
+  }
+#endif
+
+  for (y = 0; y < height; ++y) {
+    ARGBPolynomialRow(src_argb, dst_argb, poly, width);
+    src_argb += src_stride_argb;
+    dst_argb += dst_stride_argb;
+  }
+  return 0;
+}
+
+// Convert plane of 16 bit shorts to half floats.
+// Source values are multiplied by scale before storing as half float.
+LIBYUV_API
+int HalfFloatPlane(const uint16_t* src_y,
+                   int src_stride_y,
+                   uint16_t* dst_y,
+                   int dst_stride_y,
+                   float scale,
+                   int width,
+                   int height) {
+  int y;
+  void (*HalfFloatRow)(const uint16_t* src, uint16_t* dst, float scale,
+                       int width) = HalfFloatRow_C;
+  if (!src_y || !dst_y || width <= 0 || height == 0) {
+    return -1;
+  }
+  src_stride_y >>= 1;
+  dst_stride_y >>= 1;
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    src_y = src_y + (height - 1) * src_stride_y;
+    src_stride_y = -src_stride_y;
+  }
+  // Coalesce rows.
+  if (src_stride_y == width && dst_stride_y == width) {
+    width *= height;
+    height = 1;
+    src_stride_y = dst_stride_y = 0;
+  }
+#if defined(HAS_HALFFLOATROW_SSE2)
+  if (TestCpuFlag(kCpuHasSSE2)) {
+    HalfFloatRow = HalfFloatRow_Any_SSE2;
+    if (IS_ALIGNED(width, 8)) {
+      HalfFloatRow = HalfFloatRow_SSE2;
+    }
+  }
+#endif
+#if defined(HAS_HALFFLOATROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    HalfFloatRow = HalfFloatRow_Any_AVX2;
+    if (IS_ALIGNED(width, 16)) {
+      HalfFloatRow = HalfFloatRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_HALFFLOATROW_F16C)
+  if (TestCpuFlag(kCpuHasAVX2) && TestCpuFlag(kCpuHasF16C)) {
+    HalfFloatRow =
+        (scale == 1.0f) ? HalfFloat1Row_Any_F16C : HalfFloatRow_Any_F16C;
+    if (IS_ALIGNED(width, 16)) {
+      HalfFloatRow = (scale == 1.0f) ? HalfFloat1Row_F16C : HalfFloatRow_F16C;
+    }
+  }
+#endif
+#if defined(HAS_HALFFLOATROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    HalfFloatRow =
+        (scale == 1.0f) ? HalfFloat1Row_Any_NEON : HalfFloatRow_Any_NEON;
+    if (IS_ALIGNED(width, 8)) {
+      HalfFloatRow = (scale == 1.0f) ? HalfFloat1Row_NEON : HalfFloatRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_HALFFLOATROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    HalfFloatRow = HalfFloatRow_Any_MSA;
+    if (IS_ALIGNED(width, 32)) {
+      HalfFloatRow = HalfFloatRow_MSA;
+    }
+  }
+#endif
+#if defined(HAS_HALFFLOATROW_LSX)
+  if (TestCpuFlag(kCpuHasLSX)) {
+    HalfFloatRow = HalfFloatRow_Any_LSX;
+    if (IS_ALIGNED(width, 32)) {
+      HalfFloatRow = HalfFloatRow_LSX;
+    }
+  }
+#endif
+
+  for (y = 0; y < height; ++y) {
+    HalfFloatRow(src_y, dst_y, scale, width);
+    src_y += src_stride_y;
+    dst_y += dst_stride_y;
+  }
+  return 0;
+}
+
+// Convert a buffer of bytes to floats, scale the values and store as floats.
+LIBYUV_API
+int ByteToFloat(const uint8_t* src_y, float* dst_y, float scale, int width) {
+  void (*ByteToFloatRow)(const uint8_t* src, float* dst, float scale,
+                         int width) = ByteToFloatRow_C;
+  if (!src_y || !dst_y || width <= 0) {
+    return -1;
+  }
+#if defined(HAS_BYTETOFLOATROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    ByteToFloatRow = ByteToFloatRow_Any_NEON;
+    if (IS_ALIGNED(width, 8)) {
+      ByteToFloatRow = ByteToFloatRow_NEON;
+    }
+  }
+#endif
+
+  ByteToFloatRow(src_y, dst_y, scale, width);
+  return 0;
+}
+
+// Apply a lumacolortable to each ARGB pixel.
+LIBYUV_API
+int ARGBLumaColorTable(const uint8_t* src_argb,
+                       int src_stride_argb,
+                       uint8_t* dst_argb,
+                       int dst_stride_argb,
+                       const uint8_t* luma,
+                       int width,
+                       int height) {
+  int y;
+  void (*ARGBLumaColorTableRow)(
+      const uint8_t* src_argb, uint8_t* dst_argb, int width,
+      const uint8_t* luma, const uint32_t lumacoeff) = ARGBLumaColorTableRow_C;
+  if (!src_argb || !dst_argb || !luma || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    src_argb = src_argb + (height - 1) * src_stride_argb;
+    src_stride_argb = -src_stride_argb;
+  }
+  // Coalesce rows.
+  if (src_stride_argb == width * 4 && dst_stride_argb == width * 4) {
+    width *= height;
+    height = 1;
+    src_stride_argb = dst_stride_argb = 0;
+  }
+#if defined(HAS_ARGBLUMACOLORTABLEROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3) && IS_ALIGNED(width, 4)) {
+    ARGBLumaColorTableRow = ARGBLumaColorTableRow_SSSE3;
+  }
+#endif
+
+  for (y = 0; y < height; ++y) {
+    ARGBLumaColorTableRow(src_argb, dst_argb, width, luma, 0x00264b0f);
+    src_argb += src_stride_argb;
+    dst_argb += dst_stride_argb;
+  }
+  return 0;
+}
+
+// Copy Alpha from one ARGB image to another.
+LIBYUV_API
+int ARGBCopyAlpha(const uint8_t* src_argb,
+                  int src_stride_argb,
+                  uint8_t* dst_argb,
+                  int dst_stride_argb,
+                  int width,
+                  int height) {
+  int y;
+  void (*ARGBCopyAlphaRow)(const uint8_t* src_argb, uint8_t* dst_argb,
+                           int width) = ARGBCopyAlphaRow_C;
+  if (!src_argb || !dst_argb || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    src_argb = src_argb + (height - 1) * src_stride_argb;
+    src_stride_argb = -src_stride_argb;
+  }
+  // Coalesce rows.
+  if (src_stride_argb == width * 4 && dst_stride_argb == width * 4) {
+    width *= height;
+    height = 1;
+    src_stride_argb = dst_stride_argb = 0;
+  }
+#if defined(HAS_ARGBCOPYALPHAROW_SSE2)
+  if (TestCpuFlag(kCpuHasSSE2)) {
+    ARGBCopyAlphaRow = ARGBCopyAlphaRow_Any_SSE2;
+    if (IS_ALIGNED(width, 8)) {
+      ARGBCopyAlphaRow = ARGBCopyAlphaRow_SSE2;
+    }
+  }
+#endif
+#if defined(HAS_ARGBCOPYALPHAROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ARGBCopyAlphaRow = ARGBCopyAlphaRow_Any_AVX2;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBCopyAlphaRow = ARGBCopyAlphaRow_AVX2;
+    }
+  }
+#endif
+
+  for (y = 0; y < height; ++y) {
+    ARGBCopyAlphaRow(src_argb, dst_argb, width);
+    src_argb += src_stride_argb;
+    dst_argb += dst_stride_argb;
+  }
+  return 0;
+}
+
+// Extract just the alpha channel from ARGB.
+LIBYUV_API
+int ARGBExtractAlpha(const uint8_t* src_argb,
+                     int src_stride_argb,
+                     uint8_t* dst_a,
+                     int dst_stride_a,
+                     int width,
+                     int height) {
+  if (!src_argb || !dst_a || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    src_argb += (height - 1) * src_stride_argb;
+    src_stride_argb = -src_stride_argb;
+  }
+  // Coalesce rows.
+  if (src_stride_argb == width * 4 && dst_stride_a == width) {
+    width *= height;
+    height = 1;
+    src_stride_argb = dst_stride_a = 0;
+  }
+  void (*ARGBExtractAlphaRow)(const uint8_t* src_argb, uint8_t* dst_a,
+                              int width) = ARGBExtractAlphaRow_C;
+#if defined(HAS_ARGBEXTRACTALPHAROW_SSE2)
+  if (TestCpuFlag(kCpuHasSSE2)) {
+    ARGBExtractAlphaRow = IS_ALIGNED(width, 8) ? ARGBExtractAlphaRow_SSE2
+                                               : ARGBExtractAlphaRow_Any_SSE2;
+  }
+#endif
+#if defined(HAS_ARGBEXTRACTALPHAROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ARGBExtractAlphaRow = IS_ALIGNED(width, 32) ? ARGBExtractAlphaRow_AVX2
+                                                : ARGBExtractAlphaRow_Any_AVX2;
+  }
+#endif
+#if defined(HAS_ARGBEXTRACTALPHAROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    ARGBExtractAlphaRow = IS_ALIGNED(width, 16) ? ARGBExtractAlphaRow_NEON
+                                                : ARGBExtractAlphaRow_Any_NEON;
+  }
+#endif
+#if defined(HAS_ARGBEXTRACTALPHAROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    ARGBExtractAlphaRow = IS_ALIGNED(width, 16) ? ARGBExtractAlphaRow_MSA
+                                                : ARGBExtractAlphaRow_Any_MSA;
+  }
+#endif
+#if defined(HAS_ARGBEXTRACTALPHAROW_LSX)
+  if (TestCpuFlag(kCpuHasLSX)) {
+    ARGBExtractAlphaRow = IS_ALIGNED(width, 16) ? ARGBExtractAlphaRow_LSX
+                                                : ARGBExtractAlphaRow_Any_LSX;
+  }
+#endif
+
+  for (int y = 0; y < height; ++y) {
+    ARGBExtractAlphaRow(src_argb, dst_a, width);
+    src_argb += src_stride_argb;
+    dst_a += dst_stride_a;
+  }
+  return 0;
+}
+
+// Copy a planar Y channel to the alpha channel of a destination ARGB image.
+LIBYUV_API
+int ARGBCopyYToAlpha(const uint8_t* src_y,
+                     int src_stride_y,
+                     uint8_t* dst_argb,
+                     int dst_stride_argb,
+                     int width,
+                     int height) {
+  int y;
+  void (*ARGBCopyYToAlphaRow)(const uint8_t* src_y, uint8_t* dst_argb,
+                              int width) = ARGBCopyYToAlphaRow_C;
+  if (!src_y || !dst_argb || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    src_y = src_y + (height - 1) * src_stride_y;
+    src_stride_y = -src_stride_y;
+  }
+  // Coalesce rows.
+  if (src_stride_y == width && dst_stride_argb == width * 4) {
+    width *= height;
+    height = 1;
+    src_stride_y = dst_stride_argb = 0;
+  }
+#if defined(HAS_ARGBCOPYYTOALPHAROW_SSE2)
+  if (TestCpuFlag(kCpuHasSSE2)) {
+    ARGBCopyYToAlphaRow = ARGBCopyYToAlphaRow_Any_SSE2;
+    if (IS_ALIGNED(width, 8)) {
+      ARGBCopyYToAlphaRow = ARGBCopyYToAlphaRow_SSE2;
+    }
+  }
+#endif
+#if defined(HAS_ARGBCOPYYTOALPHAROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ARGBCopyYToAlphaRow = ARGBCopyYToAlphaRow_Any_AVX2;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBCopyYToAlphaRow = ARGBCopyYToAlphaRow_AVX2;
+    }
+  }
+#endif
+
+  for (y = 0; y < height; ++y) {
+    ARGBCopyYToAlphaRow(src_y, dst_argb, width);
+    src_y += src_stride_y;
+    dst_argb += dst_stride_argb;
+  }
+  return 0;
+}
+
+// TODO(fbarchard): Consider if width is even Y channel can be split
+// directly. A SplitUVRow_Odd function could copy the remaining chroma.
+
+LIBYUV_API
+int YUY2ToNV12(const uint8_t* src_yuy2,
+               int src_stride_yuy2,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_uv,
+               int dst_stride_uv,
+               int width,
+               int height) {
+  int y;
+  int halfwidth = (width + 1) >> 1;
+  void (*SplitUVRow)(const uint8_t* src_uv, uint8_t* dst_u, uint8_t* dst_v,
+                     int width) = SplitUVRow_C;
+  void (*InterpolateRow)(uint8_t * dst_ptr, const uint8_t* src_ptr,
+                         ptrdiff_t src_stride, int dst_width,
+                         int source_y_fraction) = InterpolateRow_C;
+
+  if (!src_yuy2 || !dst_y || !dst_uv || width <= 0 || height == 0) {
+    return -1;
+  }
+
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    src_yuy2 = src_yuy2 + (height - 1) * src_stride_yuy2;
+    src_stride_yuy2 = -src_stride_yuy2;
+  }
+#if defined(HAS_SPLITUVROW_SSE2)
+  if (TestCpuFlag(kCpuHasSSE2)) {
+    SplitUVRow = SplitUVRow_Any_SSE2;
+    if (IS_ALIGNED(width, 16)) {
+      SplitUVRow = SplitUVRow_SSE2;
+    }
+  }
+#endif
+#if defined(HAS_SPLITUVROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    SplitUVRow = SplitUVRow_Any_AVX2;
+    if (IS_ALIGNED(width, 32)) {
+      SplitUVRow = SplitUVRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_SPLITUVROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    SplitUVRow = SplitUVRow_Any_NEON;
+    if (IS_ALIGNED(width, 16)) {
+      SplitUVRow = SplitUVRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_SPLITUVROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    SplitUVRow = SplitUVRow_Any_MSA;
+    if (IS_ALIGNED(width, 32)) {
+      SplitUVRow = SplitUVRow_MSA;
+    }
+  }
+#endif
+#if defined(HAS_SPLITUVROW_LSX)
+  if (TestCpuFlag(kCpuHasLSX)) {
+    SplitUVRow = SplitUVRow_Any_LSX;
+    if (IS_ALIGNED(width, 32)) {
+      SplitUVRow = SplitUVRow_LSX;
+    }
+  }
+#endif
+#if defined(HAS_INTERPOLATEROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    InterpolateRow = InterpolateRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 16)) {
+      InterpolateRow = InterpolateRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_INTERPOLATEROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    InterpolateRow = InterpolateRow_Any_AVX2;
+    if (IS_ALIGNED(width, 32)) {
+      InterpolateRow = InterpolateRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_INTERPOLATEROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    InterpolateRow = InterpolateRow_Any_NEON;
+    if (IS_ALIGNED(width, 16)) {
+      InterpolateRow = InterpolateRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_INTERPOLATEROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    InterpolateRow = InterpolateRow_Any_MSA;
+    if (IS_ALIGNED(width, 32)) {
+      InterpolateRow = InterpolateRow_MSA;
+    }
+  }
+#endif
+#if defined(HAS_INTERPOLATEROW_LSX)
+  if (TestCpuFlag(kCpuHasLSX)) {
+    InterpolateRow = InterpolateRow_Any_LSX;
+    if (IS_ALIGNED(width, 32)) {
+      InterpolateRow = InterpolateRow_LSX;
+    }
+  }
+#endif
+
+  {
+    int awidth = halfwidth * 2;
+    // row of y and 2 rows of uv
+    align_buffer_64(rows, awidth * 3);
+
+    for (y = 0; y < height - 1; y += 2) {
+      // Split Y from UV.
+      SplitUVRow(src_yuy2, rows, rows + awidth, awidth);
+      memcpy(dst_y, rows, width);
+      SplitUVRow(src_yuy2 + src_stride_yuy2, rows, rows + awidth * 2, awidth);
+      memcpy(dst_y + dst_stride_y, rows, width);
+      InterpolateRow(dst_uv, rows + awidth, awidth, awidth, 128);
+      src_yuy2 += src_stride_yuy2 * 2;
+      dst_y += dst_stride_y * 2;
+      dst_uv += dst_stride_uv;
+    }
+    if (height & 1) {
+      // Split Y from UV.
+      SplitUVRow(src_yuy2, rows, dst_uv, awidth);
+      memcpy(dst_y, rows, width);
+    }
+    free_aligned_buffer_64(rows);
+  }
+  return 0;
+}
+
+LIBYUV_API
+int UYVYToNV12(const uint8_t* src_uyvy,
+               int src_stride_uyvy,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_uv,
+               int dst_stride_uv,
+               int width,
+               int height) {
+  int y;
+  int halfwidth = (width + 1) >> 1;
+  void (*SplitUVRow)(const uint8_t* src_uv, uint8_t* dst_u, uint8_t* dst_v,
+                     int width) = SplitUVRow_C;
+  void (*InterpolateRow)(uint8_t * dst_ptr, const uint8_t* src_ptr,
+                         ptrdiff_t src_stride, int dst_width,
+                         int source_y_fraction) = InterpolateRow_C;
+
+  if (!src_uyvy || !dst_y || !dst_uv || width <= 0 || height == 0) {
+    return -1;
+  }
+
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    src_uyvy = src_uyvy + (height - 1) * src_stride_uyvy;
+    src_stride_uyvy = -src_stride_uyvy;
+  }
+#if defined(HAS_SPLITUVROW_SSE2)
+  if (TestCpuFlag(kCpuHasSSE2)) {
+    SplitUVRow = SplitUVRow_Any_SSE2;
+    if (IS_ALIGNED(width, 16)) {
+      SplitUVRow = SplitUVRow_SSE2;
+    }
+  }
+#endif
+#if defined(HAS_SPLITUVROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    SplitUVRow = SplitUVRow_Any_AVX2;
+    if (IS_ALIGNED(width, 32)) {
+      SplitUVRow = SplitUVRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_SPLITUVROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    SplitUVRow = SplitUVRow_Any_NEON;
+    if (IS_ALIGNED(width, 16)) {
+      SplitUVRow = SplitUVRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_SPLITUVROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    SplitUVRow = SplitUVRow_Any_MSA;
+    if (IS_ALIGNED(width, 32)) {
+      SplitUVRow = SplitUVRow_MSA;
+    }
+  }
+#endif
+#if defined(HAS_SPLITUVROW_LSX)
+  if (TestCpuFlag(kCpuHasLSX)) {
+    SplitUVRow = SplitUVRow_Any_LSX;
+    if (IS_ALIGNED(width, 32)) {
+      SplitUVRow = SplitUVRow_LSX;
+    }
+  }
+#endif
+#if defined(HAS_INTERPOLATEROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    InterpolateRow = InterpolateRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 16)) {
+      InterpolateRow = InterpolateRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_INTERPOLATEROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    InterpolateRow = InterpolateRow_Any_AVX2;
+    if (IS_ALIGNED(width, 32)) {
+      InterpolateRow = InterpolateRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_INTERPOLATEROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    InterpolateRow = InterpolateRow_Any_NEON;
+    if (IS_ALIGNED(width, 16)) {
+      InterpolateRow = InterpolateRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_INTERPOLATEROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    InterpolateRow = InterpolateRow_Any_MSA;
+    if (IS_ALIGNED(width, 32)) {
+      InterpolateRow = InterpolateRow_MSA;
+    }
+  }
+#endif
+#if defined(HAS_INTERPOLATEROW_LSX)
+  if (TestCpuFlag(kCpuHasLSX)) {
+    InterpolateRow = InterpolateRow_Any_LSX;
+    if (IS_ALIGNED(width, 32)) {
+      InterpolateRow = InterpolateRow_LSX;
+    }
+  }
+#endif
+
+  {
+    int awidth = halfwidth * 2;
+    // row of y and 2 rows of uv
+    align_buffer_64(rows, awidth * 3);
+
+    for (y = 0; y < height - 1; y += 2) {
+      // Split Y from UV.
+      SplitUVRow(src_uyvy, rows + awidth, rows, awidth);
+      memcpy(dst_y, rows, width);
+      SplitUVRow(src_uyvy + src_stride_uyvy, rows + awidth * 2, rows, awidth);
+      memcpy(dst_y + dst_stride_y, rows, width);
+      InterpolateRow(dst_uv, rows + awidth, awidth, awidth, 128);
+      src_uyvy += src_stride_uyvy * 2;
+      dst_y += dst_stride_y * 2;
+      dst_uv += dst_stride_uv;
+    }
+    if (height & 1) {
+      // Split Y from UV.
+      SplitUVRow(src_uyvy, dst_uv, rows, awidth);
+      memcpy(dst_y, rows, width);
+    }
+    free_aligned_buffer_64(rows);
+  }
+  return 0;
+}
+
+// width and height are src size allowing odd size handling.
+LIBYUV_API
+void HalfMergeUVPlane(const uint8_t* src_u,
+                      int src_stride_u,
+                      const uint8_t* src_v,
+                      int src_stride_v,
+                      uint8_t* dst_uv,
+                      int dst_stride_uv,
+                      int width,
+                      int height) {
+  int y;
+  void (*HalfMergeUVRow)(const uint8_t* src_u, int src_stride_u,
+                         const uint8_t* src_v, int src_stride_v,
+                         uint8_t* dst_uv, int width) = HalfMergeUVRow_C;
+
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    src_u = src_u + (height - 1) * src_stride_u;
+    src_v = src_v + (height - 1) * src_stride_v;
+    src_stride_u = -src_stride_u;
+    src_stride_v = -src_stride_v;
+  }
+#if defined(HAS_HALFMERGEUVROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON) && IS_ALIGNED(width, 16)) {
+    HalfMergeUVRow = HalfMergeUVRow_NEON;
+  }
+#endif
+#if defined(HAS_HALFMERGEUVROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3) && IS_ALIGNED(width, 16)) {
+    HalfMergeUVRow = HalfMergeUVRow_SSSE3;
+  }
+#endif
+#if defined(HAS_HALFMERGEUVROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2) && IS_ALIGNED(width, 32)) {
+    HalfMergeUVRow = HalfMergeUVRow_AVX2;
+  }
+#endif
+  for (y = 0; y < height - 1; y += 2) {
+    // Merge a row of U and V into a row of UV.
+    HalfMergeUVRow(src_u, src_stride_u, src_v, src_stride_v, dst_uv, width);
+    src_u += src_stride_u * 2;
+    src_v += src_stride_v * 2;
+    dst_uv += dst_stride_uv;
+  }
+  if (height & 1) {
+    HalfMergeUVRow(src_u, 0, src_v, 0, dst_uv, width);
+  }
+}
+
+#ifdef __cplusplus
+}  // extern "C"
+}  // namespace libyuv
+#endif
diff --git a/3rdparty/libyuv/src/source/rotate.cc b/3rdparty/libyuv/src/source/rotate.cc
new file mode 100644
index 00000000..f1e83cbd
--- /dev/null
+++ b/3rdparty/libyuv/src/source/rotate.cc
@@ -0,0 +1,834 @@
+/*
+ *  Copyright 2011 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include "libyuv/rotate.h"
+
+#include "libyuv/convert.h"
+#include "libyuv/cpu_id.h"
+#include "libyuv/planar_functions.h"
+#include "libyuv/rotate_row.h"
+#include "libyuv/row.h"
+
+#ifdef __cplusplus
+namespace libyuv {
+extern "C" {
+#endif
+
+LIBYUV_API
+void TransposePlane(const uint8_t* src,
+                    int src_stride,
+                    uint8_t* dst,
+                    int dst_stride,
+                    int width,
+                    int height) {
+  int i = height;
+#if defined(HAS_TRANSPOSEWX16_MSA) || defined(HAS_TRANSPOSEWX16_LSX)
+  void (*TransposeWx16)(const uint8_t* src, int src_stride, uint8_t* dst,
+                        int dst_stride, int width) = TransposeWx16_C;
+#else
+  void (*TransposeWx8)(const uint8_t* src, int src_stride, uint8_t* dst,
+                       int dst_stride, int width) = TransposeWx8_C;
+#endif
+
+#if defined(HAS_TRANSPOSEWX8_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    TransposeWx8 = TransposeWx8_Any_NEON;
+    if (IS_ALIGNED(width, 8)) {
+      TransposeWx8 = TransposeWx8_NEON;
+    }
+  }
+#endif
+#if defined(HAS_TRANSPOSEWX8_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    TransposeWx8 = TransposeWx8_Any_SSSE3;
+    if (IS_ALIGNED(width, 8)) {
+      TransposeWx8 = TransposeWx8_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_TRANSPOSEWX8_FAST_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    TransposeWx8 = TransposeWx8_Fast_Any_SSSE3;
+    if (IS_ALIGNED(width, 16)) {
+      TransposeWx8 = TransposeWx8_Fast_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_TRANSPOSEWX16_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    TransposeWx16 = TransposeWx16_Any_MSA;
+    if (IS_ALIGNED(width, 16)) {
+      TransposeWx16 = TransposeWx16_MSA;
+    }
+  }
+#endif
+#if defined(HAS_TRANSPOSEWX16_LSX)
+  if (TestCpuFlag(kCpuHasLSX)) {
+    TransposeWx16 = TransposeWx16_Any_LSX;
+    if (IS_ALIGNED(width, 16)) {
+      TransposeWx16 = TransposeWx16_LSX;
+    }
+  }
+#endif
+
+#if defined(HAS_TRANSPOSEWX16_MSA) || defined(HAS_TRANSPOSEWX16_LSX)
+  // Work across the source in 16x16 tiles
+  while (i >= 16) {
+    TransposeWx16(src, src_stride, dst, dst_stride, width);
+    src += 16 * src_stride;  // Go down 16 rows.
+    dst += 16;               // Move over 16 columns.
+    i -= 16;
+  }
+#else
+  // Work across the source in 8x8 tiles
+  while (i >= 8) {
+    TransposeWx8(src, src_stride, dst, dst_stride, width);
+    src += 8 * src_stride;  // Go down 8 rows.
+    dst += 8;               // Move over 8 columns.
+    i -= 8;
+  }
+#endif
+
+  if (i > 0) {
+    TransposeWxH_C(src, src_stride, dst, dst_stride, width, i);
+  }
+}
+
+LIBYUV_API
+void RotatePlane90(const uint8_t* src,
+                   int src_stride,
+                   uint8_t* dst,
+                   int dst_stride,
+                   int width,
+                   int height) {
+  // Rotate by 90 is a transpose with the source read
+  // from bottom to top. So set the source pointer to the end
+  // of the buffer and flip the sign of the source stride.
+  src += src_stride * (height - 1);
+  src_stride = -src_stride;
+  TransposePlane(src, src_stride, dst, dst_stride, width, height);
+}
+
+LIBYUV_API
+void RotatePlane270(const uint8_t* src,
+                    int src_stride,
+                    uint8_t* dst,
+                    int dst_stride,
+                    int width,
+                    int height) {
+  // Rotate by 270 is a transpose with the destination written
+  // from bottom to top. So set the destination pointer to the end
+  // of the buffer and flip the sign of the destination stride.
+  dst += dst_stride * (width - 1);
+  dst_stride = -dst_stride;
+  TransposePlane(src, src_stride, dst, dst_stride, width, height);
+}
+
+LIBYUV_API
+void RotatePlane180(const uint8_t* src,
+                    int src_stride,
+                    uint8_t* dst,
+                    int dst_stride,
+                    int width,
+                    int height) {
+  // Swap first and last row and mirror the content. Uses a temporary row.
+  align_buffer_64(row, width);
+  const uint8_t* src_bot = src + src_stride * (height - 1);
+  uint8_t* dst_bot = dst + dst_stride * (height - 1);
+  int half_height = (height + 1) >> 1;
+  int y;
+  void (*MirrorRow)(const uint8_t* src, uint8_t* dst, int width) = MirrorRow_C;
+  void (*CopyRow)(const uint8_t* src, uint8_t* dst, int width) = CopyRow_C;
+#if defined(HAS_MIRRORROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    MirrorRow = MirrorRow_Any_NEON;
+    if (IS_ALIGNED(width, 32)) {
+      MirrorRow = MirrorRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_MIRRORROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    MirrorRow = MirrorRow_Any_SSSE3;
+    if (IS_ALIGNED(width, 16)) {
+      MirrorRow = MirrorRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_MIRRORROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    MirrorRow = MirrorRow_Any_AVX2;
+    if (IS_ALIGNED(width, 32)) {
+      MirrorRow = MirrorRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_MIRRORROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    MirrorRow = MirrorRow_Any_MSA;
+    if (IS_ALIGNED(width, 64)) {
+      MirrorRow = MirrorRow_MSA;
+    }
+  }
+#endif
+#if defined(HAS_MIRRORROW_LASX)
+  if (TestCpuFlag(kCpuHasLASX)) {
+    MirrorRow = MirrorRow_Any_LASX;
+    if (IS_ALIGNED(width, 64)) {
+      MirrorRow = MirrorRow_LASX;
+    }
+  }
+#endif
+#if defined(HAS_COPYROW_SSE2)
+  if (TestCpuFlag(kCpuHasSSE2)) {
+    CopyRow = IS_ALIGNED(width, 32) ? CopyRow_SSE2 : CopyRow_Any_SSE2;
+  }
+#endif
+#if defined(HAS_COPYROW_AVX)
+  if (TestCpuFlag(kCpuHasAVX)) {
+    CopyRow = IS_ALIGNED(width, 64) ? CopyRow_AVX : CopyRow_Any_AVX;
+  }
+#endif
+#if defined(HAS_COPYROW_ERMS)
+  if (TestCpuFlag(kCpuHasERMS)) {
+    CopyRow = CopyRow_ERMS;
+  }
+#endif
+#if defined(HAS_COPYROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    CopyRow = IS_ALIGNED(width, 32) ? CopyRow_NEON : CopyRow_Any_NEON;
+  }
+#endif
+
+  // Odd height will harmlessly mirror the middle row twice.
+  for (y = 0; y < half_height; ++y) {
+    CopyRow(src, row, width);        // Copy first row into buffer
+    MirrorRow(src_bot, dst, width);  // Mirror last row into first row
+    MirrorRow(row, dst_bot, width);  // Mirror buffer into last row
+    src += src_stride;
+    dst += dst_stride;
+    src_bot -= src_stride;
+    dst_bot -= dst_stride;
+  }
+  free_aligned_buffer_64(row);
+}
+
+LIBYUV_API
+void SplitTransposeUV(const uint8_t* src,
+                      int src_stride,
+                      uint8_t* dst_a,
+                      int dst_stride_a,
+                      uint8_t* dst_b,
+                      int dst_stride_b,
+                      int width,
+                      int height) {
+  int i = height;
+#if defined(HAS_TRANSPOSEUVWX16_MSA)
+  void (*TransposeUVWx16)(const uint8_t* src, int src_stride, uint8_t* dst_a,
+                          int dst_stride_a, uint8_t* dst_b, int dst_stride_b,
+                          int width) = TransposeUVWx16_C;
+#elif defined(HAS_TRANSPOSEUVWX16_LSX)
+  void (*TransposeUVWx16)(const uint8_t* src, int src_stride, uint8_t* dst_a,
+                          int dst_stride_a, uint8_t* dst_b, int dst_stride_b,
+                          int width) = TransposeUVWx16_C;
+#else
+  void (*TransposeUVWx8)(const uint8_t* src, int src_stride, uint8_t* dst_a,
+                         int dst_stride_a, uint8_t* dst_b, int dst_stride_b,
+                         int width) = TransposeUVWx8_C;
+#endif
+
+#if defined(HAS_TRANSPOSEUVWX16_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    TransposeUVWx16 = TransposeUVWx16_Any_MSA;
+    if (IS_ALIGNED(width, 8)) {
+      TransposeUVWx16 = TransposeUVWx16_MSA;
+    }
+  }
+#elif defined(HAS_TRANSPOSEUVWX16_LSX)
+  if (TestCpuFlag(kCpuHasLSX)) {
+    TransposeUVWx16 = TransposeUVWx16_Any_LSX;
+    if (IS_ALIGNED(width, 8)) {
+      TransposeUVWx16 = TransposeUVWx16_LSX;
+    }
+  }
+#else
+#if defined(HAS_TRANSPOSEUVWX8_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    TransposeUVWx8 = TransposeUVWx8_NEON;
+  }
+#endif
+#if defined(HAS_TRANSPOSEUVWX8_SSE2)
+  if (TestCpuFlag(kCpuHasSSE2)) {
+    TransposeUVWx8 = TransposeUVWx8_Any_SSE2;
+    if (IS_ALIGNED(width, 8)) {
+      TransposeUVWx8 = TransposeUVWx8_SSE2;
+    }
+  }
+#endif
+#endif /* defined(HAS_TRANSPOSEUVWX16_MSA) */
+
+#if defined(HAS_TRANSPOSEUVWX16_MSA)
+  // Work through the source in 8x8 tiles.
+  while (i >= 16) {
+    TransposeUVWx16(src, src_stride, dst_a, dst_stride_a, dst_b, dst_stride_b,
+                    width);
+    src += 16 * src_stride;  // Go down 16 rows.
+    dst_a += 16;             // Move over 8 columns.
+    dst_b += 16;             // Move over 8 columns.
+    i -= 16;
+  }
+#elif defined(HAS_TRANSPOSEUVWX16_LSX)
+  // Work through the source in 8x8 tiles.
+  while (i >= 16) {
+    TransposeUVWx16(src, src_stride, dst_a, dst_stride_a, dst_b, dst_stride_b,
+                    width);
+    src += 16 * src_stride;  // Go down 16 rows.
+    dst_a += 16;             // Move over 8 columns.
+    dst_b += 16;             // Move over 8 columns.
+    i -= 16;
+  }
+#else
+  // Work through the source in 8x8 tiles.
+  while (i >= 8) {
+    TransposeUVWx8(src, src_stride, dst_a, dst_stride_a, dst_b, dst_stride_b,
+                   width);
+    src += 8 * src_stride;  // Go down 8 rows.
+    dst_a += 8;             // Move over 8 columns.
+    dst_b += 8;             // Move over 8 columns.
+    i -= 8;
+  }
+#endif
+
+  if (i > 0) {
+    TransposeUVWxH_C(src, src_stride, dst_a, dst_stride_a, dst_b, dst_stride_b,
+                     width, i);
+  }
+}
+
+LIBYUV_API
+void SplitRotateUV90(const uint8_t* src,
+                     int src_stride,
+                     uint8_t* dst_a,
+                     int dst_stride_a,
+                     uint8_t* dst_b,
+                     int dst_stride_b,
+                     int width,
+                     int height) {
+  src += src_stride * (height - 1);
+  src_stride = -src_stride;
+
+  SplitTransposeUV(src, src_stride, dst_a, dst_stride_a, dst_b, dst_stride_b,
+                   width, height);
+}
+
+LIBYUV_API
+void SplitRotateUV270(const uint8_t* src,
+                      int src_stride,
+                      uint8_t* dst_a,
+                      int dst_stride_a,
+                      uint8_t* dst_b,
+                      int dst_stride_b,
+                      int width,
+                      int height) {
+  dst_a += dst_stride_a * (width - 1);
+  dst_b += dst_stride_b * (width - 1);
+  dst_stride_a = -dst_stride_a;
+  dst_stride_b = -dst_stride_b;
+
+  SplitTransposeUV(src, src_stride, dst_a, dst_stride_a, dst_b, dst_stride_b,
+                   width, height);
+}
+
+// Rotate 180 is a horizontal and vertical flip.
+LIBYUV_API
+void SplitRotateUV180(const uint8_t* src,
+                      int src_stride,
+                      uint8_t* dst_a,
+                      int dst_stride_a,
+                      uint8_t* dst_b,
+                      int dst_stride_b,
+                      int width,
+                      int height) {
+  int i;
+  void (*MirrorSplitUVRow)(const uint8_t* src, uint8_t* dst_u, uint8_t* dst_v,
+                           int width) = MirrorSplitUVRow_C;
+#if defined(HAS_MIRRORSPLITUVROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON) && IS_ALIGNED(width, 16)) {
+    MirrorSplitUVRow = MirrorSplitUVRow_NEON;
+  }
+#endif
+#if defined(HAS_MIRRORSPLITUVROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3) && IS_ALIGNED(width, 16)) {
+    MirrorSplitUVRow = MirrorSplitUVRow_SSSE3;
+  }
+#endif
+#if defined(HAS_MIRRORSPLITUVROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA) && IS_ALIGNED(width, 32)) {
+    MirrorSplitUVRow = MirrorSplitUVRow_MSA;
+  }
+#endif
+#if defined(HAS_MIRRORSPLITUVROW_LSX)
+  if (TestCpuFlag(kCpuHasLSX) && IS_ALIGNED(width, 32)) {
+    MirrorSplitUVRow = MirrorSplitUVRow_LSX;
+  }
+#endif
+
+  dst_a += dst_stride_a * (height - 1);
+  dst_b += dst_stride_b * (height - 1);
+
+  for (i = 0; i < height; ++i) {
+    MirrorSplitUVRow(src, dst_a, dst_b, width);
+    src += src_stride;
+    dst_a -= dst_stride_a;
+    dst_b -= dst_stride_b;
+  }
+}
+
+// Rotate UV and split into planar.
+// width and height expected to be half size for NV12
+LIBYUV_API
+int SplitRotateUV(const uint8_t* src_uv,
+                  int src_stride_uv,
+                  uint8_t* dst_u,
+                  int dst_stride_u,
+                  uint8_t* dst_v,
+                  int dst_stride_v,
+                  int width,
+                  int height,
+                  enum RotationMode mode) {
+  if (!src_uv || width <= 0 || height == 0 || !dst_u || !dst_v) {
+    return -1;
+  }
+
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    src_uv = src_uv + (height - 1) * src_stride_uv;
+    src_stride_uv = -src_stride_uv;
+  }
+
+  switch (mode) {
+    case kRotate0:
+      SplitUVPlane(src_uv, src_stride_uv, dst_u, dst_stride_u, dst_v,
+                   dst_stride_v, width, height);
+      return 0;
+    case kRotate90:
+      SplitRotateUV90(src_uv, src_stride_uv, dst_u, dst_stride_u, dst_v,
+                      dst_stride_v, width, height);
+      return 0;
+    case kRotate270:
+      SplitRotateUV270(src_uv, src_stride_uv, dst_u, dst_stride_u, dst_v,
+                       dst_stride_v, width, height);
+      return 0;
+    case kRotate180:
+      SplitRotateUV180(src_uv, src_stride_uv, dst_u, dst_stride_u, dst_v,
+                       dst_stride_v, width, height);
+      return 0;
+    default:
+      break;
+  }
+  return -1;
+}
+
+LIBYUV_API
+int RotatePlane(const uint8_t* src,
+                int src_stride,
+                uint8_t* dst,
+                int dst_stride,
+                int width,
+                int height,
+                enum RotationMode mode) {
+  if (!src || width <= 0 || height == 0 || !dst) {
+    return -1;
+  }
+
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    src = src + (height - 1) * src_stride;
+    src_stride = -src_stride;
+  }
+
+  switch (mode) {
+    case kRotate0:
+      // copy frame
+      CopyPlane(src, src_stride, dst, dst_stride, width, height);
+      return 0;
+    case kRotate90:
+      RotatePlane90(src, src_stride, dst, dst_stride, width, height);
+      return 0;
+    case kRotate270:
+      RotatePlane270(src, src_stride, dst, dst_stride, width, height);
+      return 0;
+    case kRotate180:
+      RotatePlane180(src, src_stride, dst, dst_stride, width, height);
+      return 0;
+    default:
+      break;
+  }
+  return -1;
+}
+
+LIBYUV_API
+int I420Rotate(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_u,
+               int dst_stride_u,
+               uint8_t* dst_v,
+               int dst_stride_v,
+               int width,
+               int height,
+               enum RotationMode mode) {
+  int halfwidth = (width + 1) >> 1;
+  int halfheight = (height + 1) >> 1;
+  if ((!src_y && dst_y) || !src_u || !src_v || width <= 0 || height == 0 ||
+      !dst_y || !dst_u || !dst_v) {
+    return -1;
+  }
+
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    halfheight = (height + 1) >> 1;
+    src_y = src_y + (height - 1) * src_stride_y;
+    src_u = src_u + (halfheight - 1) * src_stride_u;
+    src_v = src_v + (halfheight - 1) * src_stride_v;
+    src_stride_y = -src_stride_y;
+    src_stride_u = -src_stride_u;
+    src_stride_v = -src_stride_v;
+  }
+
+  switch (mode) {
+    case kRotate0:
+      // copy frame
+      return I420Copy(src_y, src_stride_y, src_u, src_stride_u, src_v,
+                      src_stride_v, dst_y, dst_stride_y, dst_u, dst_stride_u,
+                      dst_v, dst_stride_v, width, height);
+    case kRotate90:
+      RotatePlane90(src_y, src_stride_y, dst_y, dst_stride_y, width, height);
+      RotatePlane90(src_u, src_stride_u, dst_u, dst_stride_u, halfwidth,
+                    halfheight);
+      RotatePlane90(src_v, src_stride_v, dst_v, dst_stride_v, halfwidth,
+                    halfheight);
+      return 0;
+    case kRotate270:
+      RotatePlane270(src_y, src_stride_y, dst_y, dst_stride_y, width, height);
+      RotatePlane270(src_u, src_stride_u, dst_u, dst_stride_u, halfwidth,
+                     halfheight);
+      RotatePlane270(src_v, src_stride_v, dst_v, dst_stride_v, halfwidth,
+                     halfheight);
+      return 0;
+    case kRotate180:
+      RotatePlane180(src_y, src_stride_y, dst_y, dst_stride_y, width, height);
+      RotatePlane180(src_u, src_stride_u, dst_u, dst_stride_u, halfwidth,
+                     halfheight);
+      RotatePlane180(src_v, src_stride_v, dst_v, dst_stride_v, halfwidth,
+                     halfheight);
+      return 0;
+    default:
+      break;
+  }
+  return -1;
+}
+
+LIBYUV_API
+int I422Rotate(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_u,
+               int dst_stride_u,
+               uint8_t* dst_v,
+               int dst_stride_v,
+               int width,
+               int height,
+               enum RotationMode mode) {
+  int halfwidth = (width + 1) >> 1;
+  int halfheight = (height + 1) >> 1;
+  if (!src_y || !src_u || !src_v || width <= 0 || height == 0 || !dst_y ||
+      !dst_u || !dst_v) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    src_y = src_y + (height - 1) * src_stride_y;
+    src_u = src_u + (height - 1) * src_stride_u;
+    src_v = src_v + (height - 1) * src_stride_v;
+    src_stride_y = -src_stride_y;
+    src_stride_u = -src_stride_u;
+    src_stride_v = -src_stride_v;
+  }
+
+  switch (mode) {
+    case kRotate0:
+      // copy frame
+      CopyPlane(src_y, src_stride_y, dst_y, dst_stride_y, width, height);
+      CopyPlane(src_u, src_stride_u, dst_u, dst_stride_u, halfwidth, height);
+      CopyPlane(src_v, src_stride_v, dst_v, dst_stride_v, halfwidth, height);
+      return 0;
+    case kRotate90:
+      // We need to rotate and rescale, we use plane Y as temporal storage.
+      RotatePlane90(src_u, src_stride_u, dst_y, height, halfwidth, height);
+      ScalePlane(dst_y, height, height, halfwidth, dst_u, halfheight,
+                 halfheight, width, kFilterBilinear);
+      RotatePlane90(src_v, src_stride_v, dst_y, height, halfwidth, height);
+      ScalePlane(dst_y, height, height, halfwidth, dst_v, halfheight,
+                 halfheight, width, kFilterLinear);
+      RotatePlane90(src_y, src_stride_y, dst_y, dst_stride_y, width, height);
+      return 0;
+    case kRotate270:
+      // We need to rotate and rescale, we use plane Y as temporal storage.
+      RotatePlane270(src_u, src_stride_u, dst_y, height, halfwidth, height);
+      ScalePlane(dst_y, height, height, halfwidth, dst_u, halfheight,
+                 halfheight, width, kFilterBilinear);
+      RotatePlane270(src_v, src_stride_v, dst_y, height, halfwidth, height);
+      ScalePlane(dst_y, height, height, halfwidth, dst_v, halfheight,
+                 halfheight, width, kFilterLinear);
+      RotatePlane270(src_y, src_stride_y, dst_y, dst_stride_y, width, height);
+
+      return 0;
+    case kRotate180:
+      RotatePlane180(src_y, src_stride_y, dst_y, dst_stride_y, width, height);
+      RotatePlane180(src_u, src_stride_u, dst_u, dst_stride_u, halfwidth,
+                     height);
+      RotatePlane180(src_v, src_stride_v, dst_v, dst_stride_v, halfwidth,
+                     height);
+      return 0;
+    default:
+      break;
+  }
+  return -1;
+}
+
+LIBYUV_API
+int I444Rotate(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* src_u,
+               int src_stride_u,
+               const uint8_t* src_v,
+               int src_stride_v,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_u,
+               int dst_stride_u,
+               uint8_t* dst_v,
+               int dst_stride_v,
+               int width,
+               int height,
+               enum RotationMode mode) {
+  if (!src_y || !src_u || !src_v || width <= 0 || height == 0 || !dst_y ||
+      !dst_u || !dst_v) {
+    return -1;
+  }
+
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    src_y = src_y + (height - 1) * src_stride_y;
+    src_u = src_u + (height - 1) * src_stride_u;
+    src_v = src_v + (height - 1) * src_stride_v;
+    src_stride_y = -src_stride_y;
+    src_stride_u = -src_stride_u;
+    src_stride_v = -src_stride_v;
+  }
+
+  switch (mode) {
+    case kRotate0:
+      // copy frame
+      CopyPlane(src_y, src_stride_y, dst_y, dst_stride_y, width, height);
+      CopyPlane(src_u, src_stride_u, dst_u, dst_stride_u, width, height);
+      CopyPlane(src_v, src_stride_v, dst_v, dst_stride_v, width, height);
+      return 0;
+    case kRotate90:
+      RotatePlane90(src_y, src_stride_y, dst_y, dst_stride_y, width, height);
+      RotatePlane90(src_u, src_stride_u, dst_u, dst_stride_u, width, height);
+      RotatePlane90(src_v, src_stride_v, dst_v, dst_stride_v, width, height);
+      return 0;
+    case kRotate270:
+      RotatePlane270(src_y, src_stride_y, dst_y, dst_stride_y, width, height);
+      RotatePlane270(src_u, src_stride_u, dst_u, dst_stride_u, width, height);
+      RotatePlane270(src_v, src_stride_v, dst_v, dst_stride_v, width, height);
+      return 0;
+    case kRotate180:
+      RotatePlane180(src_y, src_stride_y, dst_y, dst_stride_y, width, height);
+      RotatePlane180(src_u, src_stride_u, dst_u, dst_stride_u, width, height);
+      RotatePlane180(src_v, src_stride_v, dst_v, dst_stride_v, width, height);
+      return 0;
+    default:
+      break;
+  }
+  return -1;
+}
+
+LIBYUV_API
+int NV12ToI420Rotate(const uint8_t* src_y,
+                     int src_stride_y,
+                     const uint8_t* src_uv,
+                     int src_stride_uv,
+                     uint8_t* dst_y,
+                     int dst_stride_y,
+                     uint8_t* dst_u,
+                     int dst_stride_u,
+                     uint8_t* dst_v,
+                     int dst_stride_v,
+                     int width,
+                     int height,
+                     enum RotationMode mode) {
+  int halfwidth = (width + 1) >> 1;
+  int halfheight = (height + 1) >> 1;
+  if (!src_y || !src_uv || width <= 0 || height == 0 || !dst_y || !dst_u ||
+      !dst_v) {
+    return -1;
+  }
+
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    halfheight = (height + 1) >> 1;
+    src_y = src_y + (height - 1) * src_stride_y;
+    src_uv = src_uv + (halfheight - 1) * src_stride_uv;
+    src_stride_y = -src_stride_y;
+    src_stride_uv = -src_stride_uv;
+  }
+
+  switch (mode) {
+    case kRotate0:
+      // copy frame
+      return NV12ToI420(src_y, src_stride_y, src_uv, src_stride_uv, dst_y,
+                        dst_stride_y, dst_u, dst_stride_u, dst_v, dst_stride_v,
+                        width, height);
+    case kRotate90:
+      RotatePlane90(src_y, src_stride_y, dst_y, dst_stride_y, width, height);
+      SplitRotateUV90(src_uv, src_stride_uv, dst_u, dst_stride_u, dst_v,
+                      dst_stride_v, halfwidth, halfheight);
+      return 0;
+    case kRotate270:
+      RotatePlane270(src_y, src_stride_y, dst_y, dst_stride_y, width, height);
+      SplitRotateUV270(src_uv, src_stride_uv, dst_u, dst_stride_u, dst_v,
+                       dst_stride_v, halfwidth, halfheight);
+      return 0;
+    case kRotate180:
+      RotatePlane180(src_y, src_stride_y, dst_y, dst_stride_y, width, height);
+      SplitRotateUV180(src_uv, src_stride_uv, dst_u, dst_stride_u, dst_v,
+                       dst_stride_v, halfwidth, halfheight);
+      return 0;
+    default:
+      break;
+  }
+  return -1;
+}
+
+static void SplitPixels(const uint8_t* src_u,
+                        int src_pixel_stride_uv,
+                        uint8_t* dst_u,
+                        int width) {
+  int i;
+  for (i = 0; i < width; ++i) {
+    *dst_u = *src_u;
+    ++dst_u;
+    src_u += src_pixel_stride_uv;
+  }
+}
+
+// Convert Android420 to I420 with Rotate
+LIBYUV_API
+int Android420ToI420Rotate(const uint8_t* src_y,
+                           int src_stride_y,
+                           const uint8_t* src_u,
+                           int src_stride_u,
+                           const uint8_t* src_v,
+                           int src_stride_v,
+                           int src_pixel_stride_uv,
+                           uint8_t* dst_y,
+                           int dst_stride_y,
+                           uint8_t* dst_u,
+                           int dst_stride_u,
+                           uint8_t* dst_v,
+                           int dst_stride_v,
+                           int width,
+                           int height,
+                           enum RotationMode rotation) {
+  int y;
+  const ptrdiff_t vu_off = src_v - src_u;
+  int halfwidth = (width + 1) >> 1;
+  int halfheight = (height + 1) >> 1;
+  if ((!src_y && dst_y) || !src_u || !src_v || !dst_u || !dst_v || width <= 0 ||
+      height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    halfheight = (height + 1) >> 1;
+    src_y = src_y + (height - 1) * src_stride_y;
+    src_u = src_u + (halfheight - 1) * src_stride_u;
+    src_v = src_v + (halfheight - 1) * src_stride_v;
+    src_stride_y = -src_stride_y;
+    src_stride_u = -src_stride_u;
+    src_stride_v = -src_stride_v;
+  }
+
+  if (dst_y) {
+    RotatePlane(src_y, src_stride_y, dst_y, dst_stride_y, width, height,
+                rotation);
+  }
+
+  // Copy UV planes - I420
+  if (src_pixel_stride_uv == 1) {
+    RotatePlane(src_u, src_stride_u, dst_u, dst_stride_u, halfwidth, halfheight,
+                rotation);
+    RotatePlane(src_v, src_stride_v, dst_v, dst_stride_v, halfwidth, halfheight,
+                rotation);
+    return 0;
+  }
+  // Split UV planes - NV21
+  if (src_pixel_stride_uv == 2 && vu_off == -1 &&
+      src_stride_u == src_stride_v) {
+    SplitRotateUV(src_v, src_stride_v, dst_v, dst_stride_v, dst_u, dst_stride_u,
+                  halfwidth, halfheight, rotation);
+    return 0;
+  }
+  // Split UV planes - NV12
+  if (src_pixel_stride_uv == 2 && vu_off == 1 && src_stride_u == src_stride_v) {
+    SplitRotateUV(src_u, src_stride_u, dst_u, dst_stride_u, dst_v, dst_stride_v,
+                  halfwidth, halfheight, rotation);
+    return 0;
+  }
+
+  if (rotation == 0) {
+    for (y = 0; y < halfheight; ++y) {
+      SplitPixels(src_u, src_pixel_stride_uv, dst_u, halfwidth);
+      SplitPixels(src_v, src_pixel_stride_uv, dst_v, halfwidth);
+      src_u += src_stride_u;
+      src_v += src_stride_v;
+      dst_u += dst_stride_u;
+      dst_v += dst_stride_v;
+    }
+    return 0;
+  }
+  // unsupported type and/or rotation.
+  return -1;
+}
+
+#ifdef __cplusplus
+}  // extern "C"
+}  // namespace libyuv
+#endif
diff --git a/3rdparty/libyuv/src/source/rotate_any.cc b/3rdparty/libyuv/src/source/rotate_any.cc
new file mode 100644
index 00000000..88ca7876
--- /dev/null
+++ b/3rdparty/libyuv/src/source/rotate_any.cc
@@ -0,0 +1,79 @@
+/*
+ *  Copyright 2015 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include "libyuv/rotate.h"
+#include "libyuv/rotate_row.h"
+
+#include "libyuv/basic_types.h"
+
+#ifdef __cplusplus
+namespace libyuv {
+extern "C" {
+#endif
+
+#define TANY(NAMEANY, TPOS_SIMD, MASK)                                        \
+  void NAMEANY(const uint8_t* src, int src_stride, uint8_t* dst,              \
+               int dst_stride, int width) {                                   \
+    int r = width & MASK;                                                     \
+    int n = width - r;                                                        \
+    if (n > 0) {                                                              \
+      TPOS_SIMD(src, src_stride, dst, dst_stride, n);                         \
+    }                                                                         \
+    TransposeWx8_C(src + n, src_stride, dst + n * dst_stride, dst_stride, r); \
+  }
+
+#ifdef HAS_TRANSPOSEWX8_NEON
+TANY(TransposeWx8_Any_NEON, TransposeWx8_NEON, 7)
+#endif
+#ifdef HAS_TRANSPOSEWX8_SSSE3
+TANY(TransposeWx8_Any_SSSE3, TransposeWx8_SSSE3, 7)
+#endif
+#ifdef HAS_TRANSPOSEWX8_FAST_SSSE3
+TANY(TransposeWx8_Fast_Any_SSSE3, TransposeWx8_Fast_SSSE3, 15)
+#endif
+#ifdef HAS_TRANSPOSEWX16_MSA
+TANY(TransposeWx16_Any_MSA, TransposeWx16_MSA, 15)
+#endif
+#ifdef HAS_TRANSPOSEWX16_LSX
+TANY(TransposeWx16_Any_LSX, TransposeWx16_LSX, 15)
+#endif
+#undef TANY
+
+#define TUVANY(NAMEANY, TPOS_SIMD, MASK)                                       \
+  void NAMEANY(const uint8_t* src, int src_stride, uint8_t* dst_a,             \
+               int dst_stride_a, uint8_t* dst_b, int dst_stride_b,             \
+               int width) {                                                    \
+    int r = width & MASK;                                                      \
+    int n = width - r;                                                         \
+    if (n > 0) {                                                               \
+      TPOS_SIMD(src, src_stride, dst_a, dst_stride_a, dst_b, dst_stride_b, n); \
+    }                                                                          \
+    TransposeUVWx8_C(src + n * 2, src_stride, dst_a + n * dst_stride_a,        \
+                     dst_stride_a, dst_b + n * dst_stride_b, dst_stride_b, r); \
+  }
+
+#ifdef HAS_TRANSPOSEUVWX8_NEON
+TUVANY(TransposeUVWx8_Any_NEON, TransposeUVWx8_NEON, 7)
+#endif
+#ifdef HAS_TRANSPOSEUVWX8_SSE2
+TUVANY(TransposeUVWx8_Any_SSE2, TransposeUVWx8_SSE2, 7)
+#endif
+#ifdef HAS_TRANSPOSEUVWX16_MSA
+TUVANY(TransposeUVWx16_Any_MSA, TransposeUVWx16_MSA, 7)
+#endif
+#ifdef HAS_TRANSPOSEUVWX16_LSX
+TUVANY(TransposeUVWx16_Any_LSX, TransposeUVWx16_LSX, 7)
+#endif
+#undef TUVANY
+
+#ifdef __cplusplus
+}  // extern "C"
+}  // namespace libyuv
+#endif
diff --git a/3rdparty/libyuv/src/source/rotate_argb.cc b/3rdparty/libyuv/src/source/rotate_argb.cc
new file mode 100644
index 00000000..539cf98d
--- /dev/null
+++ b/3rdparty/libyuv/src/source/rotate_argb.cc
@@ -0,0 +1,243 @@
+/*
+ *  Copyright 2012 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include "libyuv/rotate.h"
+
+#include "libyuv/convert.h"
+#include "libyuv/cpu_id.h"
+#include "libyuv/planar_functions.h"
+#include "libyuv/row.h"
+#include "libyuv/scale_row.h" /* for ScaleARGBRowDownEven_ */
+
+#ifdef __cplusplus
+namespace libyuv {
+extern "C" {
+#endif
+
+static int ARGBTranspose(const uint8_t* src_argb,
+                         int src_stride_argb,
+                         uint8_t* dst_argb,
+                         int dst_stride_argb,
+                         int width,
+                         int height) {
+  int i;
+  int src_pixel_step = src_stride_argb >> 2;
+  void (*ScaleARGBRowDownEven)(
+      const uint8_t* src_argb, ptrdiff_t src_stride_argb, int src_step,
+      uint8_t* dst_argb, int dst_width) = ScaleARGBRowDownEven_C;
+  // Check stride is a multiple of 4.
+  if (src_stride_argb & 3) {
+    return -1;
+  }
+#if defined(HAS_SCALEARGBROWDOWNEVEN_SSE2)
+  if (TestCpuFlag(kCpuHasSSE2)) {
+    ScaleARGBRowDownEven = ScaleARGBRowDownEven_Any_SSE2;
+    if (IS_ALIGNED(height, 4)) {  // Width of dest.
+      ScaleARGBRowDownEven = ScaleARGBRowDownEven_SSE2;
+    }
+  }
+#endif
+#if defined(HAS_SCALEARGBROWDOWNEVEN_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    ScaleARGBRowDownEven = ScaleARGBRowDownEven_Any_NEON;
+    if (IS_ALIGNED(height, 4)) {  // Width of dest.
+      ScaleARGBRowDownEven = ScaleARGBRowDownEven_NEON;
+    }
+  }
+#endif
+#if defined(HAS_SCALEARGBROWDOWNEVEN_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    ScaleARGBRowDownEven = ScaleARGBRowDownEven_Any_MSA;
+    if (IS_ALIGNED(height, 4)) {  // Width of dest.
+      ScaleARGBRowDownEven = ScaleARGBRowDownEven_MSA;
+    }
+  }
+#endif
+#if defined(HAS_SCALEARGBROWDOWNEVEN_LSX)
+  if (TestCpuFlag(kCpuHasLSX)) {
+    ScaleARGBRowDownEven = ScaleARGBRowDownEven_Any_LSX;
+    if (IS_ALIGNED(height, 4)) {  // Width of dest.
+      ScaleARGBRowDownEven = ScaleARGBRowDownEven_LSX;
+    }
+  }
+#endif
+
+  for (i = 0; i < width; ++i) {  // column of source to row of dest.
+    ScaleARGBRowDownEven(src_argb, 0, src_pixel_step, dst_argb, height);
+    dst_argb += dst_stride_argb;
+    src_argb += 4;
+  }
+  return 0;
+}
+
+static int ARGBRotate90(const uint8_t* src_argb,
+                        int src_stride_argb,
+                        uint8_t* dst_argb,
+                        int dst_stride_argb,
+                        int width,
+                        int height) {
+  // Rotate by 90 is a ARGBTranspose with the source read
+  // from bottom to top. So set the source pointer to the end
+  // of the buffer and flip the sign of the source stride.
+  src_argb += src_stride_argb * (height - 1);
+  src_stride_argb = -src_stride_argb;
+  return ARGBTranspose(src_argb, src_stride_argb, dst_argb, dst_stride_argb,
+                       width, height);
+}
+
+static int ARGBRotate270(const uint8_t* src_argb,
+                         int src_stride_argb,
+                         uint8_t* dst_argb,
+                         int dst_stride_argb,
+                         int width,
+                         int height) {
+  // Rotate by 270 is a ARGBTranspose with the destination written
+  // from bottom to top. So set the destination pointer to the end
+  // of the buffer and flip the sign of the destination stride.
+  dst_argb += dst_stride_argb * (width - 1);
+  dst_stride_argb = -dst_stride_argb;
+  return ARGBTranspose(src_argb, src_stride_argb, dst_argb, dst_stride_argb,
+                       width, height);
+}
+
+static int ARGBRotate180(const uint8_t* src_argb,
+                         int src_stride_argb,
+                         uint8_t* dst_argb,
+                         int dst_stride_argb,
+                         int width,
+                         int height) {
+  // Swap first and last row and mirror the content. Uses a temporary row.
+  align_buffer_64(row, width * 4);
+  const uint8_t* src_bot = src_argb + src_stride_argb * (height - 1);
+  uint8_t* dst_bot = dst_argb + dst_stride_argb * (height - 1);
+  int half_height = (height + 1) >> 1;
+  int y;
+  void (*ARGBMirrorRow)(const uint8_t* src_argb, uint8_t* dst_argb, int width) =
+      ARGBMirrorRow_C;
+  void (*CopyRow)(const uint8_t* src_argb, uint8_t* dst_argb, int width) =
+      CopyRow_C;
+#if defined(HAS_ARGBMIRRORROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    ARGBMirrorRow = ARGBMirrorRow_Any_NEON;
+    if (IS_ALIGNED(width, 8)) {
+      ARGBMirrorRow = ARGBMirrorRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_ARGBMIRRORROW_SSE2)
+  if (TestCpuFlag(kCpuHasSSE2)) {
+    ARGBMirrorRow = ARGBMirrorRow_Any_SSE2;
+    if (IS_ALIGNED(width, 4)) {
+      ARGBMirrorRow = ARGBMirrorRow_SSE2;
+    }
+  }
+#endif
+#if defined(HAS_ARGBMIRRORROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ARGBMirrorRow = ARGBMirrorRow_Any_AVX2;
+    if (IS_ALIGNED(width, 8)) {
+      ARGBMirrorRow = ARGBMirrorRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_ARGBMIRRORROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    ARGBMirrorRow = ARGBMirrorRow_Any_MSA;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBMirrorRow = ARGBMirrorRow_MSA;
+    }
+  }
+#endif
+#if defined(HAS_ARGBMIRRORROW_LASX)
+  if (TestCpuFlag(kCpuHasLASX)) {
+    ARGBMirrorRow = ARGBMirrorRow_Any_LASX;
+    if (IS_ALIGNED(width, 16)) {
+      ARGBMirrorRow = ARGBMirrorRow_LASX;
+    }
+  }
+#endif
+#if defined(HAS_COPYROW_SSE2)
+  if (TestCpuFlag(kCpuHasSSE2)) {
+    CopyRow = IS_ALIGNED(width * 4, 32) ? CopyRow_SSE2 : CopyRow_Any_SSE2;
+  }
+#endif
+#if defined(HAS_COPYROW_AVX)
+  if (TestCpuFlag(kCpuHasAVX)) {
+    CopyRow = IS_ALIGNED(width * 4, 64) ? CopyRow_AVX : CopyRow_Any_AVX;
+  }
+#endif
+#if defined(HAS_COPYROW_ERMS)
+  if (TestCpuFlag(kCpuHasERMS)) {
+    CopyRow = CopyRow_ERMS;
+  }
+#endif
+#if defined(HAS_COPYROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    CopyRow = IS_ALIGNED(width * 4, 32) ? CopyRow_NEON : CopyRow_Any_NEON;
+  }
+#endif
+
+  // Odd height will harmlessly mirror the middle row twice.
+  for (y = 0; y < half_height; ++y) {
+    ARGBMirrorRow(src_argb, row, width);      // Mirror first row into a buffer
+    ARGBMirrorRow(src_bot, dst_argb, width);  // Mirror last row into first row
+    CopyRow(row, dst_bot, width * 4);  // Copy first mirrored row into last
+    src_argb += src_stride_argb;
+    dst_argb += dst_stride_argb;
+    src_bot -= src_stride_argb;
+    dst_bot -= dst_stride_argb;
+  }
+  free_aligned_buffer_64(row);
+  return 0;
+}
+
+LIBYUV_API
+int ARGBRotate(const uint8_t* src_argb,
+               int src_stride_argb,
+               uint8_t* dst_argb,
+               int dst_stride_argb,
+               int width,
+               int height,
+               enum RotationMode mode) {
+  if (!src_argb || width <= 0 || height == 0 || !dst_argb) {
+    return -1;
+  }
+
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    src_argb = src_argb + (height - 1) * src_stride_argb;
+    src_stride_argb = -src_stride_argb;
+  }
+
+  switch (mode) {
+    case kRotate0:
+      // copy frame
+      return ARGBCopy(src_argb, src_stride_argb, dst_argb, dst_stride_argb,
+                      width, height);
+    case kRotate90:
+      return ARGBRotate90(src_argb, src_stride_argb, dst_argb, dst_stride_argb,
+                          width, height);
+    case kRotate270:
+      return ARGBRotate270(src_argb, src_stride_argb, dst_argb, dst_stride_argb,
+                           width, height);
+    case kRotate180:
+      return ARGBRotate180(src_argb, src_stride_argb, dst_argb, dst_stride_argb,
+                           width, height);
+    default:
+      break;
+  }
+  return -1;
+}
+
+#ifdef __cplusplus
+}  // extern "C"
+}  // namespace libyuv
+#endif
diff --git a/3rdparty/libyuv/src/source/rotate_common.cc b/3rdparty/libyuv/src/source/rotate_common.cc
new file mode 100644
index 00000000..ff212ade
--- /dev/null
+++ b/3rdparty/libyuv/src/source/rotate_common.cc
@@ -0,0 +1,106 @@
+/*
+ *  Copyright 2011 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include "libyuv/rotate_row.h"
+#include "libyuv/row.h"
+
+#ifdef __cplusplus
+namespace libyuv {
+extern "C" {
+#endif
+
+void TransposeWx8_C(const uint8_t* src,
+                    int src_stride,
+                    uint8_t* dst,
+                    int dst_stride,
+                    int width) {
+  int i;
+  for (i = 0; i < width; ++i) {
+    dst[0] = src[0 * src_stride];
+    dst[1] = src[1 * src_stride];
+    dst[2] = src[2 * src_stride];
+    dst[3] = src[3 * src_stride];
+    dst[4] = src[4 * src_stride];
+    dst[5] = src[5 * src_stride];
+    dst[6] = src[6 * src_stride];
+    dst[7] = src[7 * src_stride];
+    ++src;
+    dst += dst_stride;
+  }
+}
+
+void TransposeUVWx8_C(const uint8_t* src,
+                      int src_stride,
+                      uint8_t* dst_a,
+                      int dst_stride_a,
+                      uint8_t* dst_b,
+                      int dst_stride_b,
+                      int width) {
+  int i;
+  for (i = 0; i < width; ++i) {
+    dst_a[0] = src[0 * src_stride + 0];
+    dst_b[0] = src[0 * src_stride + 1];
+    dst_a[1] = src[1 * src_stride + 0];
+    dst_b[1] = src[1 * src_stride + 1];
+    dst_a[2] = src[2 * src_stride + 0];
+    dst_b[2] = src[2 * src_stride + 1];
+    dst_a[3] = src[3 * src_stride + 0];
+    dst_b[3] = src[3 * src_stride + 1];
+    dst_a[4] = src[4 * src_stride + 0];
+    dst_b[4] = src[4 * src_stride + 1];
+    dst_a[5] = src[5 * src_stride + 0];
+    dst_b[5] = src[5 * src_stride + 1];
+    dst_a[6] = src[6 * src_stride + 0];
+    dst_b[6] = src[6 * src_stride + 1];
+    dst_a[7] = src[7 * src_stride + 0];
+    dst_b[7] = src[7 * src_stride + 1];
+    src += 2;
+    dst_a += dst_stride_a;
+    dst_b += dst_stride_b;
+  }
+}
+
+void TransposeWxH_C(const uint8_t* src,
+                    int src_stride,
+                    uint8_t* dst,
+                    int dst_stride,
+                    int width,
+                    int height) {
+  int i;
+  for (i = 0; i < width; ++i) {
+    int j;
+    for (j = 0; j < height; ++j) {
+      dst[i * dst_stride + j] = src[j * src_stride + i];
+    }
+  }
+}
+
+void TransposeUVWxH_C(const uint8_t* src,
+                      int src_stride,
+                      uint8_t* dst_a,
+                      int dst_stride_a,
+                      uint8_t* dst_b,
+                      int dst_stride_b,
+                      int width,
+                      int height) {
+  int i;
+  for (i = 0; i < width * 2; i += 2) {
+    int j;
+    for (j = 0; j < height; ++j) {
+      dst_a[j + ((i >> 1) * dst_stride_a)] = src[i + (j * src_stride)];
+      dst_b[j + ((i >> 1) * dst_stride_b)] = src[i + (j * src_stride) + 1];
+    }
+  }
+}
+
+#ifdef __cplusplus
+}  // extern "C"
+}  // namespace libyuv
+#endif
diff --git a/3rdparty/libyuv/src/source/rotate_gcc.cc b/3rdparty/libyuv/src/source/rotate_gcc.cc
new file mode 100644
index 00000000..1a3f8cbb
--- /dev/null
+++ b/3rdparty/libyuv/src/source/rotate_gcc.cc
@@ -0,0 +1,373 @@
+/*
+ *  Copyright 2015 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include "libyuv/rotate_row.h"
+#include "libyuv/row.h"
+
+#ifdef __cplusplus
+namespace libyuv {
+extern "C" {
+#endif
+
+// This module is for GCC x86 and x64.
+#if !defined(LIBYUV_DISABLE_X86) && (defined(__x86_64__) || defined(__i386__))
+
+// Transpose 8x8. 32 or 64 bit, but not NaCL for 64 bit.
+#if defined(HAS_TRANSPOSEWX8_SSSE3)
+void TransposeWx8_SSSE3(const uint8_t* src,
+                        int src_stride,
+                        uint8_t* dst,
+                        int dst_stride,
+                        int width) {
+  asm volatile(
+      // Read in the data from the source pointer.
+      // First round of bit swap.
+      LABELALIGN
+      "1:                                        \n"
+      "movq        (%0),%%xmm0                   \n"
+      "movq        (%0,%3),%%xmm1                \n"
+      "lea         (%0,%3,2),%0                  \n"
+      "punpcklbw   %%xmm1,%%xmm0                 \n"
+      "movq        (%0),%%xmm2                   \n"
+      "movdqa      %%xmm0,%%xmm1                 \n"
+      "palignr     $0x8,%%xmm1,%%xmm1            \n"
+      "movq        (%0,%3),%%xmm3                \n"
+      "lea         (%0,%3,2),%0                  \n"
+      "punpcklbw   %%xmm3,%%xmm2                 \n"
+      "movdqa      %%xmm2,%%xmm3                 \n"
+      "movq        (%0),%%xmm4                   \n"
+      "palignr     $0x8,%%xmm3,%%xmm3            \n"
+      "movq        (%0,%3),%%xmm5                \n"
+      "lea         (%0,%3,2),%0                  \n"
+      "punpcklbw   %%xmm5,%%xmm4                 \n"
+      "movdqa      %%xmm4,%%xmm5                 \n"
+      "movq        (%0),%%xmm6                   \n"
+      "palignr     $0x8,%%xmm5,%%xmm5            \n"
+      "movq        (%0,%3),%%xmm7                \n"
+      "lea         (%0,%3,2),%0                  \n"
+      "punpcklbw   %%xmm7,%%xmm6                 \n"
+      "neg         %3                            \n"
+      "movdqa      %%xmm6,%%xmm7                 \n"
+      "lea         0x8(%0,%3,8),%0               \n"
+      "palignr     $0x8,%%xmm7,%%xmm7            \n"
+      "neg         %3                            \n"
+      // Second round of bit swap.
+      "punpcklwd   %%xmm2,%%xmm0                 \n"
+      "punpcklwd   %%xmm3,%%xmm1                 \n"
+      "movdqa      %%xmm0,%%xmm2                 \n"
+      "movdqa      %%xmm1,%%xmm3                 \n"
+      "palignr     $0x8,%%xmm2,%%xmm2            \n"
+      "palignr     $0x8,%%xmm3,%%xmm3            \n"
+      "punpcklwd   %%xmm6,%%xmm4                 \n"
+      "punpcklwd   %%xmm7,%%xmm5                 \n"
+      "movdqa      %%xmm4,%%xmm6                 \n"
+      "movdqa      %%xmm5,%%xmm7                 \n"
+      "palignr     $0x8,%%xmm6,%%xmm6            \n"
+      "palignr     $0x8,%%xmm7,%%xmm7            \n"
+      // Third round of bit swap.
+      // Write to the destination pointer.
+      "punpckldq   %%xmm4,%%xmm0                 \n"
+      "movq        %%xmm0,(%1)                   \n"
+      "movdqa      %%xmm0,%%xmm4                 \n"
+      "palignr     $0x8,%%xmm4,%%xmm4            \n"
+      "movq        %%xmm4,(%1,%4)                \n"
+      "lea         (%1,%4,2),%1                  \n"
+      "punpckldq   %%xmm6,%%xmm2                 \n"
+      "movdqa      %%xmm2,%%xmm6                 \n"
+      "movq        %%xmm2,(%1)                   \n"
+      "palignr     $0x8,%%xmm6,%%xmm6            \n"
+      "punpckldq   %%xmm5,%%xmm1                 \n"
+      "movq        %%xmm6,(%1,%4)                \n"
+      "lea         (%1,%4,2),%1                  \n"
+      "movdqa      %%xmm1,%%xmm5                 \n"
+      "movq        %%xmm1,(%1)                   \n"
+      "palignr     $0x8,%%xmm5,%%xmm5            \n"
+      "movq        %%xmm5,(%1,%4)                \n"
+      "lea         (%1,%4,2),%1                  \n"
+      "punpckldq   %%xmm7,%%xmm3                 \n"
+      "movq        %%xmm3,(%1)                   \n"
+      "movdqa      %%xmm3,%%xmm7                 \n"
+      "palignr     $0x8,%%xmm7,%%xmm7            \n"
+      "sub         $0x8,%2                       \n"
+      "movq        %%xmm7,(%1,%4)                \n"
+      "lea         (%1,%4,2),%1                  \n"
+      "jg          1b                            \n"
+      : "+r"(src),                    // %0
+        "+r"(dst),                    // %1
+        "+r"(width)                   // %2
+      : "r"((intptr_t)(src_stride)),  // %3
+        "r"((intptr_t)(dst_stride))   // %4
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6",
+        "xmm7");
+}
+#endif  // defined(HAS_TRANSPOSEWX8_SSSE3)
+
+// Transpose 16x8. 64 bit
+#if defined(HAS_TRANSPOSEWX8_FAST_SSSE3)
+void TransposeWx8_Fast_SSSE3(const uint8_t* src,
+                             int src_stride,
+                             uint8_t* dst,
+                             int dst_stride,
+                             int width) {
+  asm volatile(
+      // Read in the data from the source pointer.
+      // First round of bit swap.
+      LABELALIGN
+      "1:                                        \n"
+      "movdqu      (%0),%%xmm0                   \n"
+      "movdqu      (%0,%3),%%xmm1                \n"
+      "lea         (%0,%3,2),%0                  \n"
+      "movdqa      %%xmm0,%%xmm8                 \n"
+      "punpcklbw   %%xmm1,%%xmm0                 \n"
+      "punpckhbw   %%xmm1,%%xmm8                 \n"
+      "movdqu      (%0),%%xmm2                   \n"
+      "movdqa      %%xmm0,%%xmm1                 \n"
+      "movdqa      %%xmm8,%%xmm9                 \n"
+      "palignr     $0x8,%%xmm1,%%xmm1            \n"
+      "palignr     $0x8,%%xmm9,%%xmm9            \n"
+      "movdqu      (%0,%3),%%xmm3                \n"
+      "lea         (%0,%3,2),%0                  \n"
+      "movdqa      %%xmm2,%%xmm10                \n"
+      "punpcklbw   %%xmm3,%%xmm2                 \n"
+      "punpckhbw   %%xmm3,%%xmm10                \n"
+      "movdqa      %%xmm2,%%xmm3                 \n"
+      "movdqa      %%xmm10,%%xmm11               \n"
+      "movdqu      (%0),%%xmm4                   \n"
+      "palignr     $0x8,%%xmm3,%%xmm3            \n"
+      "palignr     $0x8,%%xmm11,%%xmm11          \n"
+      "movdqu      (%0,%3),%%xmm5                \n"
+      "lea         (%0,%3,2),%0                  \n"
+      "movdqa      %%xmm4,%%xmm12                \n"
+      "punpcklbw   %%xmm5,%%xmm4                 \n"
+      "punpckhbw   %%xmm5,%%xmm12                \n"
+      "movdqa      %%xmm4,%%xmm5                 \n"
+      "movdqa      %%xmm12,%%xmm13               \n"
+      "movdqu      (%0),%%xmm6                   \n"
+      "palignr     $0x8,%%xmm5,%%xmm5            \n"
+      "palignr     $0x8,%%xmm13,%%xmm13          \n"
+      "movdqu      (%0,%3),%%xmm7                \n"
+      "lea         (%0,%3,2),%0                  \n"
+      "movdqa      %%xmm6,%%xmm14                \n"
+      "punpcklbw   %%xmm7,%%xmm6                 \n"
+      "punpckhbw   %%xmm7,%%xmm14                \n"
+      "neg         %3                            \n"
+      "movdqa      %%xmm6,%%xmm7                 \n"
+      "movdqa      %%xmm14,%%xmm15               \n"
+      "lea         0x10(%0,%3,8),%0              \n"
+      "palignr     $0x8,%%xmm7,%%xmm7            \n"
+      "palignr     $0x8,%%xmm15,%%xmm15          \n"
+      "neg         %3                            \n"
+      // Second round of bit swap.
+      "punpcklwd   %%xmm2,%%xmm0                 \n"
+      "punpcklwd   %%xmm3,%%xmm1                 \n"
+      "movdqa      %%xmm0,%%xmm2                 \n"
+      "movdqa      %%xmm1,%%xmm3                 \n"
+      "palignr     $0x8,%%xmm2,%%xmm2            \n"
+      "palignr     $0x8,%%xmm3,%%xmm3            \n"
+      "punpcklwd   %%xmm6,%%xmm4                 \n"
+      "punpcklwd   %%xmm7,%%xmm5                 \n"
+      "movdqa      %%xmm4,%%xmm6                 \n"
+      "movdqa      %%xmm5,%%xmm7                 \n"
+      "palignr     $0x8,%%xmm6,%%xmm6            \n"
+      "palignr     $0x8,%%xmm7,%%xmm7            \n"
+      "punpcklwd   %%xmm10,%%xmm8                \n"
+      "punpcklwd   %%xmm11,%%xmm9                \n"
+      "movdqa      %%xmm8,%%xmm10                \n"
+      "movdqa      %%xmm9,%%xmm11                \n"
+      "palignr     $0x8,%%xmm10,%%xmm10          \n"
+      "palignr     $0x8,%%xmm11,%%xmm11          \n"
+      "punpcklwd   %%xmm14,%%xmm12               \n"
+      "punpcklwd   %%xmm15,%%xmm13               \n"
+      "movdqa      %%xmm12,%%xmm14               \n"
+      "movdqa      %%xmm13,%%xmm15               \n"
+      "palignr     $0x8,%%xmm14,%%xmm14          \n"
+      "palignr     $0x8,%%xmm15,%%xmm15          \n"
+      // Third round of bit swap.
+      // Write to the destination pointer.
+      "punpckldq   %%xmm4,%%xmm0                 \n"
+      "movq        %%xmm0,(%1)                   \n"
+      "movdqa      %%xmm0,%%xmm4                 \n"
+      "palignr     $0x8,%%xmm4,%%xmm4            \n"
+      "movq        %%xmm4,(%1,%4)                \n"
+      "lea         (%1,%4,2),%1                  \n"
+      "punpckldq   %%xmm6,%%xmm2                 \n"
+      "movdqa      %%xmm2,%%xmm6                 \n"
+      "movq        %%xmm2,(%1)                   \n"
+      "palignr     $0x8,%%xmm6,%%xmm6            \n"
+      "punpckldq   %%xmm5,%%xmm1                 \n"
+      "movq        %%xmm6,(%1,%4)                \n"
+      "lea         (%1,%4,2),%1                  \n"
+      "movdqa      %%xmm1,%%xmm5                 \n"
+      "movq        %%xmm1,(%1)                   \n"
+      "palignr     $0x8,%%xmm5,%%xmm5            \n"
+      "movq        %%xmm5,(%1,%4)                \n"
+      "lea         (%1,%4,2),%1                  \n"
+      "punpckldq   %%xmm7,%%xmm3                 \n"
+      "movq        %%xmm3,(%1)                   \n"
+      "movdqa      %%xmm3,%%xmm7                 \n"
+      "palignr     $0x8,%%xmm7,%%xmm7            \n"
+      "movq        %%xmm7,(%1,%4)                \n"
+      "lea         (%1,%4,2),%1                  \n"
+      "punpckldq   %%xmm12,%%xmm8                \n"
+      "movq        %%xmm8,(%1)                   \n"
+      "movdqa      %%xmm8,%%xmm12                \n"
+      "palignr     $0x8,%%xmm12,%%xmm12          \n"
+      "movq        %%xmm12,(%1,%4)               \n"
+      "lea         (%1,%4,2),%1                  \n"
+      "punpckldq   %%xmm14,%%xmm10               \n"
+      "movdqa      %%xmm10,%%xmm14               \n"
+      "movq        %%xmm10,(%1)                  \n"
+      "palignr     $0x8,%%xmm14,%%xmm14          \n"
+      "punpckldq   %%xmm13,%%xmm9                \n"
+      "movq        %%xmm14,(%1,%4)               \n"
+      "lea         (%1,%4,2),%1                  \n"
+      "movdqa      %%xmm9,%%xmm13                \n"
+      "movq        %%xmm9,(%1)                   \n"
+      "palignr     $0x8,%%xmm13,%%xmm13          \n"
+      "movq        %%xmm13,(%1,%4)               \n"
+      "lea         (%1,%4,2),%1                  \n"
+      "punpckldq   %%xmm15,%%xmm11               \n"
+      "movq        %%xmm11,(%1)                  \n"
+      "movdqa      %%xmm11,%%xmm15               \n"
+      "palignr     $0x8,%%xmm15,%%xmm15          \n"
+      "sub         $0x10,%2                      \n"
+      "movq        %%xmm15,(%1,%4)               \n"
+      "lea         (%1,%4,2),%1                  \n"
+      "jg          1b                            \n"
+      : "+r"(src),                    // %0
+        "+r"(dst),                    // %1
+        "+r"(width)                   // %2
+      : "r"((intptr_t)(src_stride)),  // %3
+        "r"((intptr_t)(dst_stride))   // %4
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6",
+        "xmm7", "xmm8", "xmm9", "xmm10", "xmm11", "xmm12", "xmm13", "xmm14",
+        "xmm15");
+}
+#endif  // defined(HAS_TRANSPOSEWX8_FAST_SSSE3)
+
+// Transpose UV 8x8.  64 bit.
+#if defined(HAS_TRANSPOSEUVWX8_SSE2)
+void TransposeUVWx8_SSE2(const uint8_t* src,
+                         int src_stride,
+                         uint8_t* dst_a,
+                         int dst_stride_a,
+                         uint8_t* dst_b,
+                         int dst_stride_b,
+                         int width) {
+  asm volatile(
+      // Read in the data from the source pointer.
+      // First round of bit swap.
+      LABELALIGN
+      "1:                                        \n"
+      "movdqu      (%0),%%xmm0                   \n"
+      "movdqu      (%0,%4),%%xmm1                \n"
+      "lea         (%0,%4,2),%0                  \n"
+      "movdqa      %%xmm0,%%xmm8                 \n"
+      "punpcklbw   %%xmm1,%%xmm0                 \n"
+      "punpckhbw   %%xmm1,%%xmm8                 \n"
+      "movdqa      %%xmm8,%%xmm1                 \n"
+      "movdqu      (%0),%%xmm2                   \n"
+      "movdqu      (%0,%4),%%xmm3                \n"
+      "lea         (%0,%4,2),%0                  \n"
+      "movdqa      %%xmm2,%%xmm8                 \n"
+      "punpcklbw   %%xmm3,%%xmm2                 \n"
+      "punpckhbw   %%xmm3,%%xmm8                 \n"
+      "movdqa      %%xmm8,%%xmm3                 \n"
+      "movdqu      (%0),%%xmm4                   \n"
+      "movdqu      (%0,%4),%%xmm5                \n"
+      "lea         (%0,%4,2),%0                  \n"
+      "movdqa      %%xmm4,%%xmm8                 \n"
+      "punpcklbw   %%xmm5,%%xmm4                 \n"
+      "punpckhbw   %%xmm5,%%xmm8                 \n"
+      "movdqa      %%xmm8,%%xmm5                 \n"
+      "movdqu      (%0),%%xmm6                   \n"
+      "movdqu      (%0,%4),%%xmm7                \n"
+      "lea         (%0,%4,2),%0                  \n"
+      "movdqa      %%xmm6,%%xmm8                 \n"
+      "punpcklbw   %%xmm7,%%xmm6                 \n"
+      "neg         %4                            \n"
+      "lea         0x10(%0,%4,8),%0              \n"
+      "punpckhbw   %%xmm7,%%xmm8                 \n"
+      "movdqa      %%xmm8,%%xmm7                 \n"
+      "neg         %4                            \n"
+      // Second round of bit swap.
+      "movdqa      %%xmm0,%%xmm8                 \n"
+      "movdqa      %%xmm1,%%xmm9                 \n"
+      "punpckhwd   %%xmm2,%%xmm8                 \n"
+      "punpckhwd   %%xmm3,%%xmm9                 \n"
+      "punpcklwd   %%xmm2,%%xmm0                 \n"
+      "punpcklwd   %%xmm3,%%xmm1                 \n"
+      "movdqa      %%xmm8,%%xmm2                 \n"
+      "movdqa      %%xmm9,%%xmm3                 \n"
+      "movdqa      %%xmm4,%%xmm8                 \n"
+      "movdqa      %%xmm5,%%xmm9                 \n"
+      "punpckhwd   %%xmm6,%%xmm8                 \n"
+      "punpckhwd   %%xmm7,%%xmm9                 \n"
+      "punpcklwd   %%xmm6,%%xmm4                 \n"
+      "punpcklwd   %%xmm7,%%xmm5                 \n"
+      "movdqa      %%xmm8,%%xmm6                 \n"
+      "movdqa      %%xmm9,%%xmm7                 \n"
+      // Third round of bit swap.
+      // Write to the destination pointer.
+      "movdqa      %%xmm0,%%xmm8                 \n"
+      "punpckldq   %%xmm4,%%xmm0                 \n"
+      "movlpd      %%xmm0,(%1)                   \n"  // Write back U channel
+      "movhpd      %%xmm0,(%2)                   \n"  // Write back V channel
+      "punpckhdq   %%xmm4,%%xmm8                 \n"
+      "movlpd      %%xmm8,(%1,%5)                \n"
+      "lea         (%1,%5,2),%1                  \n"
+      "movhpd      %%xmm8,(%2,%6)                \n"
+      "lea         (%2,%6,2),%2                  \n"
+      "movdqa      %%xmm2,%%xmm8                 \n"
+      "punpckldq   %%xmm6,%%xmm2                 \n"
+      "movlpd      %%xmm2,(%1)                   \n"
+      "movhpd      %%xmm2,(%2)                   \n"
+      "punpckhdq   %%xmm6,%%xmm8                 \n"
+      "movlpd      %%xmm8,(%1,%5)                \n"
+      "lea         (%1,%5,2),%1                  \n"
+      "movhpd      %%xmm8,(%2,%6)                \n"
+      "lea         (%2,%6,2),%2                  \n"
+      "movdqa      %%xmm1,%%xmm8                 \n"
+      "punpckldq   %%xmm5,%%xmm1                 \n"
+      "movlpd      %%xmm1,(%1)                   \n"
+      "movhpd      %%xmm1,(%2)                   \n"
+      "punpckhdq   %%xmm5,%%xmm8                 \n"
+      "movlpd      %%xmm8,(%1,%5)                \n"
+      "lea         (%1,%5,2),%1                  \n"
+      "movhpd      %%xmm8,(%2,%6)                \n"
+      "lea         (%2,%6,2),%2                  \n"
+      "movdqa      %%xmm3,%%xmm8                 \n"
+      "punpckldq   %%xmm7,%%xmm3                 \n"
+      "movlpd      %%xmm3,(%1)                   \n"
+      "movhpd      %%xmm3,(%2)                   \n"
+      "punpckhdq   %%xmm7,%%xmm8                 \n"
+      "sub         $0x8,%3                       \n"
+      "movlpd      %%xmm8,(%1,%5)                \n"
+      "lea         (%1,%5,2),%1                  \n"
+      "movhpd      %%xmm8,(%2,%6)                \n"
+      "lea         (%2,%6,2),%2                  \n"
+      "jg          1b                            \n"
+      : "+r"(src),                      // %0
+        "+r"(dst_a),                    // %1
+        "+r"(dst_b),                    // %2
+        "+r"(width)                     // %3
+      : "r"((intptr_t)(src_stride)),    // %4
+        "r"((intptr_t)(dst_stride_a)),  // %5
+        "r"((intptr_t)(dst_stride_b))   // %6
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6",
+        "xmm7", "xmm8", "xmm9");
+}
+#endif  // defined(HAS_TRANSPOSEUVWX8_SSE2)
+#endif  // defined(__x86_64__) || defined(__i386__)
+
+#ifdef __cplusplus
+}  // extern "C"
+}  // namespace libyuv
+#endif
diff --git a/3rdparty/libyuv/src/source/rotate_lsx.cc b/3rdparty/libyuv/src/source/rotate_lsx.cc
new file mode 100644
index 00000000..94a2b91c
--- /dev/null
+++ b/3rdparty/libyuv/src/source/rotate_lsx.cc
@@ -0,0 +1,243 @@
+/*
+ *  Copyright 2022 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Copyright (c) 2022 Loongson Technology Corporation Limited
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include "libyuv/rotate_row.h"
+
+#if !defined(LIBYUV_DISABLE_LSX) && defined(__loongarch_sx)
+#include "libyuv/loongson_intrinsics.h"
+
+#ifdef __cplusplus
+namespace libyuv {
+extern "C" {
+#endif
+
+#define ILVLH_B(in0, in1, in2, in3, out0, out1, out2, out3)   \
+  {                                                           \
+    DUP2_ARG2(__lsx_vilvl_b, in1, in0, in3, in2, out0, out2); \
+    DUP2_ARG2(__lsx_vilvh_b, in1, in0, in3, in2, out1, out3); \
+  }
+
+#define ILVLH_H(in0, in1, in2, in3, out0, out1, out2, out3)   \
+  {                                                           \
+    DUP2_ARG2(__lsx_vilvl_h, in1, in0, in3, in2, out0, out2); \
+    DUP2_ARG2(__lsx_vilvh_h, in1, in0, in3, in2, out1, out3); \
+  }
+
+#define ILVLH_W(in0, in1, in2, in3, out0, out1, out2, out3)   \
+  {                                                           \
+    DUP2_ARG2(__lsx_vilvl_w, in1, in0, in3, in2, out0, out2); \
+    DUP2_ARG2(__lsx_vilvh_w, in1, in0, in3, in2, out1, out3); \
+  }
+
+#define ILVLH_D(in0, in1, in2, in3, out0, out1, out2, out3)   \
+  {                                                           \
+    DUP2_ARG2(__lsx_vilvl_d, in1, in0, in3, in2, out0, out2); \
+    DUP2_ARG2(__lsx_vilvh_d, in1, in0, in3, in2, out1, out3); \
+  }
+
+#define LSX_ST_4(_dst0, _dst1, _dst2, _dst3, _dst, _stride, _stride2, \
+                 _stride3, _stride4)                                  \
+  {                                                                   \
+    __lsx_vst(_dst0, _dst, 0);                                        \
+    __lsx_vstx(_dst1, _dst, _stride);                                 \
+    __lsx_vstx(_dst2, _dst, _stride2);                                \
+    __lsx_vstx(_dst3, _dst, _stride3);                                \
+    _dst += _stride4;                                                 \
+  }
+
+#define LSX_ST_2(_dst0, _dst1, _dst, _stride, _stride2) \
+  {                                                     \
+    __lsx_vst(_dst0, _dst, 0);                          \
+    __lsx_vstx(_dst1, _dst, _stride);                   \
+    _dst += _stride2;                                   \
+  }
+
+void TransposeWx16_C(const uint8_t* src,
+                     int src_stride,
+                     uint8_t* dst,
+                     int dst_stride,
+                     int width) {
+  TransposeWx8_C(src, src_stride, dst, dst_stride, width);
+  TransposeWx8_C((src + 8 * src_stride), src_stride, (dst + 8), dst_stride,
+                 width);
+}
+
+void TransposeUVWx16_C(const uint8_t* src,
+                       int src_stride,
+                       uint8_t* dst_a,
+                       int dst_stride_a,
+                       uint8_t* dst_b,
+                       int dst_stride_b,
+                       int width) {
+  TransposeUVWx8_C(src, src_stride, dst_a, dst_stride_a, dst_b, dst_stride_b,
+                   width);
+  TransposeUVWx8_C((src + 8 * src_stride), src_stride, (dst_a + 8),
+                   dst_stride_a, (dst_b + 8), dst_stride_b, width);
+}
+
+void TransposeWx16_LSX(const uint8_t* src,
+                       int src_stride,
+                       uint8_t* dst,
+                       int dst_stride,
+                       int width) {
+  int x;
+  int len = width / 16;
+  uint8_t* s;
+  int src_stride2 = src_stride << 1;
+  int src_stride3 = src_stride + src_stride2;
+  int src_stride4 = src_stride2 << 1;
+  int dst_stride2 = dst_stride << 1;
+  int dst_stride3 = dst_stride + dst_stride2;
+  int dst_stride4 = dst_stride2 << 1;
+  __m128i src0, src1, src2, src3, dst0, dst1, dst2, dst3;
+  __m128i tmp0, tmp1, tmp2, tmp3;
+  __m128i reg0, reg1, reg2, reg3, reg4, reg5, reg6, reg7;
+  __m128i res0, res1, res2, res3, res4, res5, res6, res7, res8, res9;
+
+  for (x = 0; x < len; x++) {
+    s = (uint8_t*)src;
+    src0 = __lsx_vld(s, 0);
+    src1 = __lsx_vldx(s, src_stride);
+    src2 = __lsx_vldx(s, src_stride2);
+    src3 = __lsx_vldx(s, src_stride3);
+    s += src_stride4;
+    ILVLH_B(src0, src1, src2, src3, tmp0, tmp1, tmp2, tmp3);
+    ILVLH_H(tmp0, tmp2, tmp1, tmp3, reg0, reg1, reg2, reg3);
+    src0 = __lsx_vld(s, 0);
+    src1 = __lsx_vldx(s, src_stride);
+    src2 = __lsx_vldx(s, src_stride2);
+    src3 = __lsx_vldx(s, src_stride3);
+    s += src_stride4;
+    ILVLH_B(src0, src1, src2, src3, tmp0, tmp1, tmp2, tmp3);
+    ILVLH_H(tmp0, tmp2, tmp1, tmp3, reg4, reg5, reg6, reg7);
+    ILVLH_W(reg0, reg4, reg1, reg5, res0, res1, res2, res3);
+    ILVLH_W(reg2, reg6, reg3, reg7, res4, res5, res6, res7);
+    src0 = __lsx_vld(s, 0);
+    src1 = __lsx_vldx(s, src_stride);
+    src2 = __lsx_vldx(s, src_stride2);
+    src3 = __lsx_vldx(s, src_stride3);
+    s += src_stride4;
+    ILVLH_B(src0, src1, src2, src3, tmp0, tmp1, tmp2, tmp3);
+    ILVLH_H(tmp0, tmp2, tmp1, tmp3, reg0, reg1, reg2, reg3);
+    src0 = __lsx_vld(s, 0);
+    src1 = __lsx_vldx(s, src_stride);
+    src2 = __lsx_vldx(s, src_stride2);
+    src3 = __lsx_vldx(s, src_stride3);
+    s += src_stride4;
+    ILVLH_B(src0, src1, src2, src3, tmp0, tmp1, tmp2, tmp3);
+    ILVLH_H(tmp0, tmp2, tmp1, tmp3, reg4, reg5, reg6, reg7);
+    res8 = __lsx_vilvl_w(reg4, reg0);
+    res9 = __lsx_vilvh_w(reg4, reg0);
+    ILVLH_D(res0, res8, res1, res9, dst0, dst1, dst2, dst3);
+    LSX_ST_4(dst0, dst1, dst2, dst3, dst, dst_stride, dst_stride2, dst_stride3,
+             dst_stride4);
+    res8 = __lsx_vilvl_w(reg5, reg1);
+    res9 = __lsx_vilvh_w(reg5, reg1);
+    ILVLH_D(res2, res8, res3, res9, dst0, dst1, dst2, dst3);
+    LSX_ST_4(dst0, dst1, dst2, dst3, dst, dst_stride, dst_stride2, dst_stride3,
+             dst_stride4);
+    res8 = __lsx_vilvl_w(reg6, reg2);
+    res9 = __lsx_vilvh_w(reg6, reg2);
+    ILVLH_D(res4, res8, res5, res9, dst0, dst1, dst2, dst3);
+    LSX_ST_4(dst0, dst1, dst2, dst3, dst, dst_stride, dst_stride2, dst_stride3,
+             dst_stride4);
+    res8 = __lsx_vilvl_w(reg7, reg3);
+    res9 = __lsx_vilvh_w(reg7, reg3);
+    ILVLH_D(res6, res8, res7, res9, dst0, dst1, dst2, dst3);
+    LSX_ST_4(dst0, dst1, dst2, dst3, dst, dst_stride, dst_stride2, dst_stride3,
+             dst_stride4);
+    src += 16;
+  }
+}
+
+void TransposeUVWx16_LSX(const uint8_t* src,
+                         int src_stride,
+                         uint8_t* dst_a,
+                         int dst_stride_a,
+                         uint8_t* dst_b,
+                         int dst_stride_b,
+                         int width) {
+  int x;
+  int len = width / 8;
+  uint8_t* s;
+  int src_stride2 = src_stride << 1;
+  int src_stride3 = src_stride + src_stride2;
+  int src_stride4 = src_stride2 << 1;
+  int dst_stride_a2 = dst_stride_a << 1;
+  int dst_stride_b2 = dst_stride_b << 1;
+  __m128i src0, src1, src2, src3, dst0, dst1, dst2, dst3;
+  __m128i tmp0, tmp1, tmp2, tmp3;
+  __m128i reg0, reg1, reg2, reg3, reg4, reg5, reg6, reg7;
+  __m128i res0, res1, res2, res3, res4, res5, res6, res7, res8, res9;
+
+  for (x = 0; x < len; x++) {
+    s = (uint8_t*)src;
+    src0 = __lsx_vld(s, 0);
+    src1 = __lsx_vldx(s, src_stride);
+    src2 = __lsx_vldx(s, src_stride2);
+    src3 = __lsx_vldx(s, src_stride3);
+    s += src_stride4;
+    ILVLH_B(src0, src1, src2, src3, tmp0, tmp1, tmp2, tmp3);
+    ILVLH_H(tmp0, tmp2, tmp1, tmp3, reg0, reg1, reg2, reg3);
+    src0 = __lsx_vld(s, 0);
+    src1 = __lsx_vldx(s, src_stride);
+    src2 = __lsx_vldx(s, src_stride2);
+    src3 = __lsx_vldx(s, src_stride3);
+    s += src_stride4;
+    ILVLH_B(src0, src1, src2, src3, tmp0, tmp1, tmp2, tmp3);
+    ILVLH_H(tmp0, tmp2, tmp1, tmp3, reg4, reg5, reg6, reg7);
+    ILVLH_W(reg0, reg4, reg1, reg5, res0, res1, res2, res3);
+    ILVLH_W(reg2, reg6, reg3, reg7, res4, res5, res6, res7);
+    src0 = __lsx_vld(s, 0);
+    src1 = __lsx_vldx(s, src_stride);
+    src2 = __lsx_vldx(s, src_stride2);
+    src3 = __lsx_vldx(s, src_stride3);
+    s += src_stride4;
+    ILVLH_B(src0, src1, src2, src3, tmp0, tmp1, tmp2, tmp3);
+    ILVLH_H(tmp0, tmp2, tmp1, tmp3, reg0, reg1, reg2, reg3);
+    src0 = __lsx_vld(s, 0);
+    src1 = __lsx_vldx(s, src_stride);
+    src2 = __lsx_vldx(s, src_stride2);
+    src3 = __lsx_vldx(s, src_stride3);
+    s += src_stride4;
+    ILVLH_B(src0, src1, src2, src3, tmp0, tmp1, tmp2, tmp3);
+    ILVLH_H(tmp0, tmp2, tmp1, tmp3, reg4, reg5, reg6, reg7);
+    res8 = __lsx_vilvl_w(reg4, reg0);
+    res9 = __lsx_vilvh_w(reg4, reg0);
+    ILVLH_D(res0, res8, res1, res9, dst0, dst1, dst2, dst3);
+    LSX_ST_2(dst0, dst2, dst_a, dst_stride_a, dst_stride_a2);
+    LSX_ST_2(dst1, dst3, dst_b, dst_stride_b, dst_stride_b2);
+    res8 = __lsx_vilvl_w(reg5, reg1);
+    res9 = __lsx_vilvh_w(reg5, reg1);
+    ILVLH_D(res2, res8, res3, res9, dst0, dst1, dst2, dst3);
+    LSX_ST_2(dst0, dst2, dst_a, dst_stride_a, dst_stride_a2);
+    LSX_ST_2(dst1, dst3, dst_b, dst_stride_b, dst_stride_b2);
+    res8 = __lsx_vilvl_w(reg6, reg2);
+    res9 = __lsx_vilvh_w(reg6, reg2);
+    ILVLH_D(res4, res8, res5, res9, dst0, dst1, dst2, dst3);
+    LSX_ST_2(dst0, dst2, dst_a, dst_stride_a, dst_stride_a2);
+    LSX_ST_2(dst1, dst3, dst_b, dst_stride_b, dst_stride_b2);
+    res8 = __lsx_vilvl_w(reg7, reg3);
+    res9 = __lsx_vilvh_w(reg7, reg3);
+    ILVLH_D(res6, res8, res7, res9, dst0, dst1, dst2, dst3);
+    LSX_ST_2(dst0, dst2, dst_a, dst_stride_a, dst_stride_a2);
+    LSX_ST_2(dst1, dst3, dst_b, dst_stride_b, dst_stride_b2);
+    src += 16;
+  }
+}
+
+#ifdef __cplusplus
+}  // extern "C"
+}  // namespace libyuv
+#endif
+
+#endif  // !defined(LIBYUV_DISABLE_LSX) && defined(__loongarch_sx)
diff --git a/3rdparty/libyuv/src/source/rotate_mmi.cc b/3rdparty/libyuv/src/source/rotate_mmi.cc
new file mode 100644
index 00000000..f8de6083
--- /dev/null
+++ b/3rdparty/libyuv/src/source/rotate_mmi.cc
@@ -0,0 +1,291 @@
+/*
+ *  Copyright 2011 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include "libyuv/rotate_row.h"
+#include "libyuv/row.h"
+
+#ifdef __cplusplus
+namespace libyuv {
+extern "C" {
+#endif
+
+// This module is for Mips MMI.
+#if !defined(LIBYUV_DISABLE_MMI) && defined(_MIPS_ARCH_LOONGSON3A)
+
+void TransposeWx8_MMI(const uint8_t* src,
+                      int src_stride,
+                      uint8_t* dst,
+                      int dst_stride,
+                      int width) {
+  uint64_t tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6;
+  uint64_t tmp7, tmp8, tmp9, tmp10, tmp11, tmp12, tmp13;
+  uint8_t* src_tmp = nullptr;
+
+  __asm__ volatile(
+      "1:                                                           \n\t"
+      "ldc1       %[tmp12],        0x00(%[src])                     \n\t"
+      "dadd       %[src_tmp],      %[src],         %[src_stride]    \n\t"
+      "ldc1       %[tmp13],        0x00(%[src_tmp])                 \n\t"
+
+      /* tmp0 = (00 10 01 11 02 12 03 13) */
+      "punpcklbh  %[tmp0],         %[tmp12],       %[tmp13]         \n\t"
+      /* tmp1 = (04 14 05 15 06 16 07 17) */
+      "punpckhbh  %[tmp1],         %[tmp12],       %[tmp13]         \n\t"
+
+      "dadd       %[src_tmp],      %[src_tmp],     %[src_stride]    \n\t"
+      "ldc1       %[tmp12],        0x00(%[src_tmp])                 \n\t"
+      "dadd       %[src_tmp],      %[src_tmp],     %[src_stride]    \n\t"
+      "ldc1       %[tmp13],        0x00(%[src_tmp])                 \n\t"
+
+      /* tmp2 = (20 30 21 31 22 32 23 33) */
+      "punpcklbh  %[tmp2],         %[tmp12],       %[tmp13]         \n\t"
+      /* tmp3 = (24 34 25 35 26 36 27 37) */
+      "punpckhbh  %[tmp3],         %[tmp12],       %[tmp13]         \n\t"
+
+      /* tmp4 = (00 10 20 30 01 11 21 31) */
+      "punpcklhw  %[tmp4],         %[tmp0],        %[tmp2]          \n\t"
+      /* tmp5 = (02 12 22 32 03 13 23 33) */
+      "punpckhhw  %[tmp5],         %[tmp0],        %[tmp2]          \n\t"
+      /* tmp6 = (04 14 24 34 05 15 25 35) */
+      "punpcklhw  %[tmp6],         %[tmp1],        %[tmp3]          \n\t"
+      /* tmp7 = (06 16 26 36 07 17 27 37) */
+      "punpckhhw  %[tmp7],         %[tmp1],        %[tmp3]          \n\t"
+
+      "dadd       %[src_tmp],      %[src_tmp],     %[src_stride]    \n\t"
+      "ldc1       %[tmp12],        0x00(%[src_tmp])                 \n\t"
+      "dadd       %[src_tmp],      %[src_tmp],     %[src_stride]    \n\t"
+      "ldc1       %[tmp13],        0x00(%[src_tmp])                 \n\t"
+
+      /* tmp0 = (40 50 41 51 42 52 43 53) */
+      "punpcklbh  %[tmp0],         %[tmp12],       %[tmp13]         \n\t"
+      /* tmp1 = (44 54 45 55 46 56 47 57) */
+      "punpckhbh  %[tmp1],         %[tmp12],       %[tmp13]         \n\t"
+
+      "dadd       %[src_tmp],      %[src_tmp],     %[src_stride]    \n\t"
+      "ldc1       %[tmp12],        0x00(%[src_tmp])                 \n\t"
+      "dadd       %[src_tmp],      %[src_tmp],     %[src_stride]    \n\t"
+      "ldc1       %[tmp13],        0x00(%[src_tmp])                 \n\t"
+
+      /* tmp2 = (60 70 61 71 62 72 63 73) */
+      "punpcklbh  %[tmp2],         %[tmp12],       %[tmp13]         \n\t"
+      /* tmp3 = (64 74 65 75 66 76 67 77) */
+      "punpckhbh  %[tmp3],         %[tmp12],       %[tmp13]         \n\t"
+
+      /* tmp8 = (40 50 60 70 41 51 61 71) */
+      "punpcklhw  %[tmp8],         %[tmp0],        %[tmp2]          \n\t"
+      /* tmp9 = (42 52 62 72 43 53 63 73) */
+      "punpckhhw  %[tmp9],         %[tmp0],        %[tmp2]          \n\t"
+      /* tmp10 = (44 54 64 74 45 55 65 75) */
+      "punpcklhw  %[tmp10],        %[tmp1],        %[tmp3]          \n\t"
+      /* tmp11 = (46 56 66 76 47 57 67 77) */
+      "punpckhhw  %[tmp11],        %[tmp1],        %[tmp3]          \n\t"
+
+      /* tmp0 = (00 10 20 30 40 50 60 70) */
+      "punpcklwd  %[tmp0],         %[tmp4],        %[tmp8]          \n\t"
+      /* tmp1 = (01 11 21 31 41 51 61 71) */
+      "punpckhwd  %[tmp1],         %[tmp4],        %[tmp8]          \n\t"
+      "gssdlc1    %[tmp0],         0x07(%[dst])                     \n\t"
+      "gssdrc1    %[tmp0],         0x00(%[dst])                     \n\t"
+      "dadd       %[dst],          %[dst],         %[dst_stride]    \n\t"
+      "gssdlc1    %[tmp1],         0x07(%[dst])                     \n\t"
+      "gssdrc1    %[tmp1],         0x00(%[dst])                     \n\t"
+
+      /* tmp0 = (02 12 22 32 42 52 62 72) */
+      "punpcklwd  %[tmp0],         %[tmp5],        %[tmp9]          \n\t"
+      /* tmp1 = (03 13 23 33 43 53 63 73) */
+      "punpckhwd  %[tmp1],         %[tmp5],        %[tmp9]          \n\t"
+      "dadd       %[dst],          %[dst],         %[dst_stride]    \n\t"
+      "gssdlc1    %[tmp0],         0x07(%[dst])                     \n\t"
+      "gssdrc1    %[tmp0],         0x00(%[dst])                     \n\t"
+      "dadd       %[dst],          %[dst],         %[dst_stride]    \n\t"
+      "gssdlc1    %[tmp1],         0x07(%[dst])                     \n\t"
+      "gssdrc1    %[tmp1],         0x00(%[dst])                     \n\t"
+
+      /* tmp0 = (04 14 24 34 44 54 64 74) */
+      "punpcklwd  %[tmp0],         %[tmp6],        %[tmp10]         \n\t"
+      /* tmp1 = (05 15 25 35 45 55 65 75) */
+      "punpckhwd  %[tmp1],         %[tmp6],        %[tmp10]         \n\t"
+      "dadd       %[dst],          %[dst],         %[dst_stride]    \n\t"
+      "gssdlc1    %[tmp0],         0x07(%[dst])                     \n\t"
+      "gssdrc1    %[tmp0],         0x00(%[dst])                     \n\t"
+      "dadd       %[dst],          %[dst],         %[dst_stride]    \n\t"
+      "gssdlc1    %[tmp1],         0x07(%[dst])                     \n\t"
+      "gssdrc1    %[tmp1],         0x00(%[dst])                     \n\t"
+
+      /* tmp0 = (06 16 26 36 46 56 66 76) */
+      "punpcklwd  %[tmp0],         %[tmp7],        %[tmp11]         \n\t"
+      /* tmp1 = (07 17 27 37 47 57 67 77) */
+      "punpckhwd  %[tmp1],         %[tmp7],        %[tmp11]         \n\t"
+      "dadd       %[dst],          %[dst],         %[dst_stride]    \n\t"
+      "gssdlc1    %[tmp0],         0x07(%[dst])                     \n\t"
+      "gssdrc1    %[tmp0],         0x00(%[dst])                     \n\t"
+      "dadd       %[dst],          %[dst],         %[dst_stride]    \n\t"
+      "gssdlc1    %[tmp1],         0x07(%[dst])                     \n\t"
+      "gssdrc1    %[tmp1],         0x00(%[dst])                     \n\t"
+
+      "dadd       %[dst],          %[dst],         %[dst_stride]    \n\t"
+      "daddi      %[src],          %[src],          0x08            \n\t"
+      "daddi      %[width],        %[width],       -0x08            \n\t"
+      "bnez       %[width],        1b                               \n\t"
+
+      : [tmp0] "=&f"(tmp0), [tmp1] "=&f"(tmp1), [tmp2] "=&f"(tmp2),
+        [tmp3] "=&f"(tmp3), [tmp4] "=&f"(tmp4), [tmp5] "=&f"(tmp5),
+        [tmp6] "=&f"(tmp6), [tmp7] "=&f"(tmp7), [tmp8] "=&f"(tmp8),
+        [tmp9] "=&f"(tmp9), [tmp10] "=&f"(tmp10), [tmp11] "=&f"(tmp11),
+        [tmp12] "=&f"(tmp12), [tmp13] "=&f"(tmp13), [dst] "+&r"(dst),
+        [src_tmp] "+&r"(src_tmp)
+      : [src] "r"(src), [width] "r"(width), [src_stride] "r"(src_stride),
+        [dst_stride] "r"(dst_stride)
+      : "memory");
+}
+
+void TransposeUVWx8_MMI(const uint8_t* src,
+                        int src_stride,
+                        uint8_t* dst_a,
+                        int dst_stride_a,
+                        uint8_t* dst_b,
+                        int dst_stride_b,
+                        int width) {
+  uint64_t tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6;
+  uint64_t tmp7, tmp8, tmp9, tmp10, tmp11, tmp12, tmp13;
+  uint8_t* src_tmp = nullptr;
+
+  __asm__ volatile(
+      "1:                                                           \n\t"
+      /* tmp12 = (u00 v00 u01 v01 u02 v02 u03 v03) */
+      "ldc1       %[tmp12],        0x00(%[src])                     \n\t"
+      "dadd       %[src_tmp],      %[src],         %[src_stride]    \n\t"
+      /* tmp13 = (u10 v10 u11 v11 u12 v12 u13 v13) */
+      "ldc1       %[tmp13],        0x00(%[src_tmp])                  \n\t"
+
+      /* tmp0 = (u00 u10 v00 v10 u01 u11 v01 v11) */
+      "punpcklbh  %[tmp0],         %[tmp12],       %[tmp13]         \n\t"
+      /* tmp1 = (u02 u12 v02 v12 u03 u13 v03 v13) */
+      "punpckhbh  %[tmp1],         %[tmp12],       %[tmp13]         \n\t"
+
+      "dadd       %[src_tmp],      %[src_tmp],     %[src_stride]    \n\t"
+      /* tmp12 = (u20 v20 u21 v21 u22 v22 u23 v23) */
+      "ldc1       %[tmp12],        0x00(%[src_tmp])                 \n\t"
+      "dadd       %[src_tmp],      %[src_tmp],     %[src_stride]    \n\t"
+      /* tmp13 = (u30 v30 u31 v31 u32 v32 u33 v33) */
+      "ldc1       %[tmp13],        0x00(%[src_tmp])                 \n\t"
+
+      /* tmp2 = (u20 u30 v20 v30 u21 u31 v21 v31) */
+      "punpcklbh  %[tmp2],         %[tmp12],       %[tmp13]         \n\t"
+      /* tmp3 = (u22 u32 v22 v32 u23 u33 v23 v33) */
+      "punpckhbh  %[tmp3],         %[tmp12],       %[tmp13]         \n\t"
+
+      /* tmp4 = (u00 u10 u20 u30 v00 v10 v20 v30) */
+      "punpcklhw  %[tmp4],         %[tmp0],        %[tmp2]          \n\t"
+      /* tmp5 = (u01 u11 u21 u31 v01 v11 v21 v31) */
+      "punpckhhw  %[tmp5],         %[tmp0],        %[tmp2]          \n\t"
+      /* tmp6 = (u02 u12 u22 u32 v02 v12 v22 v32) */
+      "punpcklhw  %[tmp6],         %[tmp1],        %[tmp3]          \n\t"
+      /* tmp7 = (u03 u13 u23 u33 v03 v13 v23 v33) */
+      "punpckhhw  %[tmp7],         %[tmp1],        %[tmp3]          \n\t"
+
+      "dadd       %[src_tmp],     %[src_tmp],      %[src_stride]    \n\t"
+      /* tmp12 = (u40 v40 u41 v41 u42 v42 u43 v43) */
+      "ldc1       %[tmp12],        0x00(%[src_tmp])                 \n\t"
+      /* tmp13 = (u50 v50 u51 v51 u52 v52 u53 v53) */
+      "dadd       %[src_tmp],      %[src_tmp],     %[src_stride]    \n\t"
+      "ldc1       %[tmp13],        0x00(%[src_tmp])                 \n\t"
+
+      /* tmp0 = (u40 u50 v40 v50 u41 u51 v41 v51) */
+      "punpcklbh  %[tmp0],         %[tmp12],       %[tmp13]         \n\t"
+      /* tmp1 = (u42 u52 v42 v52 u43 u53 v43 v53) */
+      "punpckhbh  %[tmp1],         %[tmp12],       %[tmp13]         \n\t"
+
+      "dadd       %[src_tmp],      %[src_tmp],     %[src_stride]    \n\t"
+      /* tmp12 = (u60 v60 u61 v61 u62 v62 u63 v63) */
+      "ldc1       %[tmp12],        0x00(%[src_tmp])                 \n\t"
+      /* tmp13 = (u70 v70 u71 v71 u72 v72 u73 v73) */
+      "dadd       %[src_tmp],      %[src_tmp],     %[src_stride]    \n\t"
+      "ldc1       %[tmp13],        0x00(%[src_tmp])                 \n\t"
+
+      /* tmp2 = (u60 u70 v60 v70 u61 u71 v61 v71) */
+      "punpcklbh  %[tmp2],         %[tmp12],       %[tmp13]         \n\t"
+      /* tmp3 = (u62 u72 v62 v72 u63 u73 v63 v73) */
+      "punpckhbh  %[tmp3],         %[tmp12],       %[tmp13]         \n\t"
+
+      /* tmp8 = (u40 u50 u60 u70 v40 v50 v60 v70) */
+      "punpcklhw  %[tmp8],         %[tmp0],        %[tmp2]          \n\t"
+      /* tmp9 = (u41 u51 u61 u71 v41 v51 v61 v71) */
+      "punpckhhw  %[tmp9],         %[tmp0],        %[tmp2]          \n\t"
+      /* tmp10 = (u42 u52 u62 u72 v42 v52 v62 v72) */
+      "punpcklhw  %[tmp10],        %[tmp1],        %[tmp3]          \n\t"
+      /* tmp11 = (u43 u53 u63 u73 v43 v53 v63 v73) */
+      "punpckhhw  %[tmp11],        %[tmp1],        %[tmp3]          \n\t"
+
+      /* tmp0 = (u00 u10 u20 u30 u40 u50 u60 u70) */
+      "punpcklwd  %[tmp0],         %[tmp4],        %[tmp8]          \n\t"
+      /* tmp1 = (v00 v10 v20 v30 v40 v50 v60 v70) */
+      "punpckhwd  %[tmp1],         %[tmp4],        %[tmp8]          \n\t"
+      "gssdlc1    %[tmp0],         0x07(%[dst_a])                   \n\t"
+      "gssdrc1    %[tmp0],         0x00(%[dst_a])                   \n\t"
+      "gssdlc1    %[tmp1],         0x07(%[dst_b])                   \n\t"
+      "gssdrc1    %[tmp1],         0x00(%[dst_b])                   \n\t"
+
+      /* tmp0 = (u01 u11 u21 u31 u41 u51 u61 u71) */
+      "punpcklwd  %[tmp0],         %[tmp5],        %[tmp9]          \n\t"
+      /* tmp1 = (v01 v11 v21 v31 v41 v51 v61 v71) */
+      "punpckhwd  %[tmp1],         %[tmp5],        %[tmp9]          \n\t"
+      "dadd       %[dst_a],        %[dst_a],       %[dst_stride_a]  \n\t"
+      "gssdlc1    %[tmp0],         0x07(%[dst_a])                   \n\t"
+      "gssdrc1    %[tmp0],         0x00(%[dst_a])                   \n\t"
+      "dadd       %[dst_b],        %[dst_b],       %[dst_stride_b]  \n\t"
+      "gssdlc1    %[tmp1],         0x07(%[dst_b])                   \n\t"
+      "gssdrc1    %[tmp1],         0x00(%[dst_b])                   \n\t"
+
+      /* tmp0 = (u02 u12 u22 u32 u42 u52 u62 u72) */
+      "punpcklwd  %[tmp0],         %[tmp6],        %[tmp10]         \n\t"
+      /* tmp1 = (v02 v12 v22 v32 v42 v52 v62 v72) */
+      "punpckhwd  %[tmp1],         %[tmp6],        %[tmp10]         \n\t"
+      "dadd       %[dst_a],        %[dst_a],       %[dst_stride_a]  \n\t"
+      "gssdlc1    %[tmp0],         0x07(%[dst_a])                   \n\t"
+      "gssdrc1    %[tmp0],         0x00(%[dst_a])                   \n\t"
+      "dadd       %[dst_b],        %[dst_b],       %[dst_stride_b]  \n\t"
+      "gssdlc1    %[tmp1],         0x07(%[dst_b])                   \n\t"
+      "gssdrc1    %[tmp1],         0x00(%[dst_b])                   \n\t"
+
+      /* tmp0 = (u03 u13 u23 u33 u43 u53 u63 u73) */
+      "punpcklwd  %[tmp0],         %[tmp7],        %[tmp11]         \n\t"
+      /* tmp1 = (v03 v13 v23 v33 v43 v53 v63 v73) */
+      "punpckhwd  %[tmp1],         %[tmp7],        %[tmp11]         \n\t"
+      "dadd       %[dst_a],        %[dst_a],       %[dst_stride_a]  \n\t"
+      "gssdlc1    %[tmp0],         0x07(%[dst_a])                   \n\t"
+      "gssdrc1    %[tmp0],         0x00(%[dst_a])                   \n\t"
+      "dadd       %[dst_b],        %[dst_b],       %[dst_stride_b]  \n\t"
+      "gssdlc1    %[tmp1],         0x07(%[dst_b])                   \n\t"
+      "gssdrc1    %[tmp1],         0x00(%[dst_b])                   \n\t"
+
+      "dadd       %[dst_a],        %[dst_a],       %[dst_stride_a]  \n\t"
+      "dadd       %[dst_b],        %[dst_b],       %[dst_stride_b]  \n\t"
+      "daddiu     %[src],          %[src],          0x08            \n\t"
+      "daddi      %[width],        %[width],       -0x04            \n\t"
+      "bnez       %[width],        1b                               \n\t"
+
+      : [tmp0] "=&f"(tmp0), [tmp1] "=&f"(tmp1), [tmp2] "=&f"(tmp2),
+        [tmp3] "=&f"(tmp3), [tmp4] "=&f"(tmp4), [tmp5] "=&f"(tmp5),
+        [tmp6] "=&f"(tmp6), [tmp7] "=&f"(tmp7), [tmp8] "=&f"(tmp8),
+        [tmp9] "=&f"(tmp9), [tmp10] "=&f"(tmp10), [tmp11] "=&f"(tmp11),
+        [tmp12] "=&f"(tmp12), [tmp13] "=&f"(tmp13), [dst_a] "+&r"(dst_a),
+        [dst_b] "+&r"(dst_b), [src_tmp] "+&r"(src_tmp)
+      : [src] "r"(src), [width] "r"(width), [dst_stride_a] "r"(dst_stride_a),
+        [dst_stride_b] "r"(dst_stride_b), [src_stride] "r"(src_stride)
+      : "memory");
+}
+
+#endif  // !defined(LIBYUV_DISABLE_MMI) && defined(_MIPS_ARCH_LOONGSON3A)
+
+#ifdef __cplusplus
+}  // extern "C"
+}  // namespace libyuv
+#endif
diff --git a/3rdparty/libyuv/src/source/rotate_msa.cc b/3rdparty/libyuv/src/source/rotate_msa.cc
new file mode 100644
index 00000000..99bdca65
--- /dev/null
+++ b/3rdparty/libyuv/src/source/rotate_msa.cc
@@ -0,0 +1,250 @@
+/*
+ *  Copyright 2016 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include "libyuv/rotate_row.h"
+
+// This module is for GCC MSA
+#if !defined(LIBYUV_DISABLE_MSA) && defined(__mips_msa)
+#include "libyuv/macros_msa.h"
+
+#ifdef __cplusplus
+namespace libyuv {
+extern "C" {
+#endif
+
+#define ILVRL_B(in0, in1, in2, in3, out0, out1, out2, out3) \
+  {                                                         \
+    out0 = (v16u8)__msa_ilvr_b((v16i8)in1, (v16i8)in0);     \
+    out1 = (v16u8)__msa_ilvl_b((v16i8)in1, (v16i8)in0);     \
+    out2 = (v16u8)__msa_ilvr_b((v16i8)in3, (v16i8)in2);     \
+    out3 = (v16u8)__msa_ilvl_b((v16i8)in3, (v16i8)in2);     \
+  }
+
+#define ILVRL_H(in0, in1, in2, in3, out0, out1, out2, out3) \
+  {                                                         \
+    out0 = (v16u8)__msa_ilvr_h((v8i16)in1, (v8i16)in0);     \
+    out1 = (v16u8)__msa_ilvl_h((v8i16)in1, (v8i16)in0);     \
+    out2 = (v16u8)__msa_ilvr_h((v8i16)in3, (v8i16)in2);     \
+    out3 = (v16u8)__msa_ilvl_h((v8i16)in3, (v8i16)in2);     \
+  }
+
+#define ILVRL_W(in0, in1, in2, in3, out0, out1, out2, out3) \
+  {                                                         \
+    out0 = (v16u8)__msa_ilvr_w((v4i32)in1, (v4i32)in0);     \
+    out1 = (v16u8)__msa_ilvl_w((v4i32)in1, (v4i32)in0);     \
+    out2 = (v16u8)__msa_ilvr_w((v4i32)in3, (v4i32)in2);     \
+    out3 = (v16u8)__msa_ilvl_w((v4i32)in3, (v4i32)in2);     \
+  }
+
+#define ILVRL_D(in0, in1, in2, in3, out0, out1, out2, out3) \
+  {                                                         \
+    out0 = (v16u8)__msa_ilvr_d((v2i64)in1, (v2i64)in0);     \
+    out1 = (v16u8)__msa_ilvl_d((v2i64)in1, (v2i64)in0);     \
+    out2 = (v16u8)__msa_ilvr_d((v2i64)in3, (v2i64)in2);     \
+    out3 = (v16u8)__msa_ilvl_d((v2i64)in3, (v2i64)in2);     \
+  }
+
+void TransposeWx16_C(const uint8_t* src,
+                     int src_stride,
+                     uint8_t* dst,
+                     int dst_stride,
+                     int width) {
+  TransposeWx8_C(src, src_stride, dst, dst_stride, width);
+  TransposeWx8_C((src + 8 * src_stride), src_stride, (dst + 8), dst_stride,
+                 width);
+}
+
+void TransposeUVWx16_C(const uint8_t* src,
+                       int src_stride,
+                       uint8_t* dst_a,
+                       int dst_stride_a,
+                       uint8_t* dst_b,
+                       int dst_stride_b,
+                       int width) {
+  TransposeUVWx8_C(src, src_stride, dst_a, dst_stride_a, dst_b, dst_stride_b,
+                   width);
+  TransposeUVWx8_C((src + 8 * src_stride), src_stride, (dst_a + 8),
+                   dst_stride_a, (dst_b + 8), dst_stride_b, width);
+}
+
+void TransposeWx16_MSA(const uint8_t* src,
+                       int src_stride,
+                       uint8_t* dst,
+                       int dst_stride,
+                       int width) {
+  int x;
+  const uint8_t* s;
+  v16u8 src0, src1, src2, src3, dst0, dst1, dst2, dst3, vec0, vec1, vec2, vec3;
+  v16u8 reg0, reg1, reg2, reg3, reg4, reg5, reg6, reg7;
+  v16u8 res0, res1, res2, res3, res4, res5, res6, res7, res8, res9;
+
+  for (x = 0; x < width; x += 16) {
+    s = src;
+    src0 = (v16u8)__msa_ld_b((v16i8*)s, 0);
+    s += src_stride;
+    src1 = (v16u8)__msa_ld_b((v16i8*)s, 0);
+    s += src_stride;
+    src2 = (v16u8)__msa_ld_b((v16i8*)s, 0);
+    s += src_stride;
+    src3 = (v16u8)__msa_ld_b((v16i8*)s, 0);
+    s += src_stride;
+    ILVRL_B(src0, src1, src2, src3, vec0, vec1, vec2, vec3);
+    ILVRL_H(vec0, vec2, vec1, vec3, reg0, reg1, reg2, reg3);
+    src0 = (v16u8)__msa_ld_b((v16i8*)s, 0);
+    s += src_stride;
+    src1 = (v16u8)__msa_ld_b((v16i8*)s, 0);
+    s += src_stride;
+    src2 = (v16u8)__msa_ld_b((v16i8*)s, 0);
+    s += src_stride;
+    src3 = (v16u8)__msa_ld_b((v16i8*)s, 0);
+    s += src_stride;
+    ILVRL_B(src0, src1, src2, src3, vec0, vec1, vec2, vec3);
+    ILVRL_H(vec0, vec2, vec1, vec3, reg4, reg5, reg6, reg7);
+    ILVRL_W(reg0, reg4, reg1, reg5, res0, res1, res2, res3);
+    ILVRL_W(reg2, reg6, reg3, reg7, res4, res5, res6, res7);
+    src0 = (v16u8)__msa_ld_b((v16i8*)s, 0);
+    s += src_stride;
+    src1 = (v16u8)__msa_ld_b((v16i8*)s, 0);
+    s += src_stride;
+    src2 = (v16u8)__msa_ld_b((v16i8*)s, 0);
+    s += src_stride;
+    src3 = (v16u8)__msa_ld_b((v16i8*)s, 0);
+    s += src_stride;
+    ILVRL_B(src0, src1, src2, src3, vec0, vec1, vec2, vec3);
+    ILVRL_H(vec0, vec2, vec1, vec3, reg0, reg1, reg2, reg3);
+    src0 = (v16u8)__msa_ld_b((v16i8*)s, 0);
+    s += src_stride;
+    src1 = (v16u8)__msa_ld_b((v16i8*)s, 0);
+    s += src_stride;
+    src2 = (v16u8)__msa_ld_b((v16i8*)s, 0);
+    s += src_stride;
+    src3 = (v16u8)__msa_ld_b((v16i8*)s, 0);
+    s += src_stride;
+    ILVRL_B(src0, src1, src2, src3, vec0, vec1, vec2, vec3);
+    ILVRL_H(vec0, vec2, vec1, vec3, reg4, reg5, reg6, reg7);
+    res8 = (v16u8)__msa_ilvr_w((v4i32)reg4, (v4i32)reg0);
+    res9 = (v16u8)__msa_ilvl_w((v4i32)reg4, (v4i32)reg0);
+    ILVRL_D(res0, res8, res1, res9, dst0, dst1, dst2, dst3);
+    ST_UB4(dst0, dst1, dst2, dst3, dst, dst_stride);
+    dst += dst_stride * 4;
+    res8 = (v16u8)__msa_ilvr_w((v4i32)reg5, (v4i32)reg1);
+    res9 = (v16u8)__msa_ilvl_w((v4i32)reg5, (v4i32)reg1);
+    ILVRL_D(res2, res8, res3, res9, dst0, dst1, dst2, dst3);
+    ST_UB4(dst0, dst1, dst2, dst3, dst, dst_stride);
+    dst += dst_stride * 4;
+    res8 = (v16u8)__msa_ilvr_w((v4i32)reg6, (v4i32)reg2);
+    res9 = (v16u8)__msa_ilvl_w((v4i32)reg6, (v4i32)reg2);
+    ILVRL_D(res4, res8, res5, res9, dst0, dst1, dst2, dst3);
+    ST_UB4(dst0, dst1, dst2, dst3, dst, dst_stride);
+    dst += dst_stride * 4;
+    res8 = (v16u8)__msa_ilvr_w((v4i32)reg7, (v4i32)reg3);
+    res9 = (v16u8)__msa_ilvl_w((v4i32)reg7, (v4i32)reg3);
+    ILVRL_D(res6, res8, res7, res9, dst0, dst1, dst2, dst3);
+    ST_UB4(dst0, dst1, dst2, dst3, dst, dst_stride);
+    src += 16;
+    dst += dst_stride * 4;
+  }
+}
+
+void TransposeUVWx16_MSA(const uint8_t* src,
+                         int src_stride,
+                         uint8_t* dst_a,
+                         int dst_stride_a,
+                         uint8_t* dst_b,
+                         int dst_stride_b,
+                         int width) {
+  int x;
+  const uint8_t* s;
+  v16u8 src0, src1, src2, src3, dst0, dst1, dst2, dst3, vec0, vec1, vec2, vec3;
+  v16u8 reg0, reg1, reg2, reg3, reg4, reg5, reg6, reg7;
+  v16u8 res0, res1, res2, res3, res4, res5, res6, res7, res8, res9;
+
+  for (x = 0; x < width; x += 8) {
+    s = src;
+    src0 = (v16u8)__msa_ld_b((v16i8*)s, 0);
+    s += src_stride;
+    src1 = (v16u8)__msa_ld_b((v16i8*)s, 0);
+    s += src_stride;
+    src2 = (v16u8)__msa_ld_b((v16i8*)s, 0);
+    s += src_stride;
+    src3 = (v16u8)__msa_ld_b((v16i8*)s, 0);
+    s += src_stride;
+    ILVRL_B(src0, src1, src2, src3, vec0, vec1, vec2, vec3);
+    ILVRL_H(vec0, vec2, vec1, vec3, reg0, reg1, reg2, reg3);
+    src0 = (v16u8)__msa_ld_b((v16i8*)s, 0);
+    s += src_stride;
+    src1 = (v16u8)__msa_ld_b((v16i8*)s, 0);
+    s += src_stride;
+    src2 = (v16u8)__msa_ld_b((v16i8*)s, 0);
+    s += src_stride;
+    src3 = (v16u8)__msa_ld_b((v16i8*)s, 0);
+    s += src_stride;
+    ILVRL_B(src0, src1, src2, src3, vec0, vec1, vec2, vec3);
+    ILVRL_H(vec0, vec2, vec1, vec3, reg4, reg5, reg6, reg7);
+    ILVRL_W(reg0, reg4, reg1, reg5, res0, res1, res2, res3);
+    ILVRL_W(reg2, reg6, reg3, reg7, res4, res5, res6, res7);
+    src0 = (v16u8)__msa_ld_b((v16i8*)s, 0);
+    s += src_stride;
+    src1 = (v16u8)__msa_ld_b((v16i8*)s, 0);
+    s += src_stride;
+    src2 = (v16u8)__msa_ld_b((v16i8*)s, 0);
+    s += src_stride;
+    src3 = (v16u8)__msa_ld_b((v16i8*)s, 0);
+    s += src_stride;
+    ILVRL_B(src0, src1, src2, src3, vec0, vec1, vec2, vec3);
+    ILVRL_H(vec0, vec2, vec1, vec3, reg0, reg1, reg2, reg3);
+    src0 = (v16u8)__msa_ld_b((v16i8*)s, 0);
+    s += src_stride;
+    src1 = (v16u8)__msa_ld_b((v16i8*)s, 0);
+    s += src_stride;
+    src2 = (v16u8)__msa_ld_b((v16i8*)s, 0);
+    s += src_stride;
+    src3 = (v16u8)__msa_ld_b((v16i8*)s, 0);
+    s += src_stride;
+    ILVRL_B(src0, src1, src2, src3, vec0, vec1, vec2, vec3);
+    ILVRL_H(vec0, vec2, vec1, vec3, reg4, reg5, reg6, reg7);
+    res8 = (v16u8)__msa_ilvr_w((v4i32)reg4, (v4i32)reg0);
+    res9 = (v16u8)__msa_ilvl_w((v4i32)reg4, (v4i32)reg0);
+    ILVRL_D(res0, res8, res1, res9, dst0, dst1, dst2, dst3);
+    ST_UB2(dst0, dst2, dst_a, dst_stride_a);
+    ST_UB2(dst1, dst3, dst_b, dst_stride_b);
+    dst_a += dst_stride_a * 2;
+    dst_b += dst_stride_b * 2;
+    res8 = (v16u8)__msa_ilvr_w((v4i32)reg5, (v4i32)reg1);
+    res9 = (v16u8)__msa_ilvl_w((v4i32)reg5, (v4i32)reg1);
+    ILVRL_D(res2, res8, res3, res9, dst0, dst1, dst2, dst3);
+    ST_UB2(dst0, dst2, dst_a, dst_stride_a);
+    ST_UB2(dst1, dst3, dst_b, dst_stride_b);
+    dst_a += dst_stride_a * 2;
+    dst_b += dst_stride_b * 2;
+    res8 = (v16u8)__msa_ilvr_w((v4i32)reg6, (v4i32)reg2);
+    res9 = (v16u8)__msa_ilvl_w((v4i32)reg6, (v4i32)reg2);
+    ILVRL_D(res4, res8, res5, res9, dst0, dst1, dst2, dst3);
+    ST_UB2(dst0, dst2, dst_a, dst_stride_a);
+    ST_UB2(dst1, dst3, dst_b, dst_stride_b);
+    dst_a += dst_stride_a * 2;
+    dst_b += dst_stride_b * 2;
+    res8 = (v16u8)__msa_ilvr_w((v4i32)reg7, (v4i32)reg3);
+    res9 = (v16u8)__msa_ilvl_w((v4i32)reg7, (v4i32)reg3);
+    ILVRL_D(res6, res8, res7, res9, dst0, dst1, dst2, dst3);
+    ST_UB2(dst0, dst2, dst_a, dst_stride_a);
+    ST_UB2(dst1, dst3, dst_b, dst_stride_b);
+    src += 16;
+    dst_a += dst_stride_a * 2;
+    dst_b += dst_stride_b * 2;
+  }
+}
+
+#ifdef __cplusplus
+}  // extern "C"
+}  // namespace libyuv
+#endif
+
+#endif  // !defined(LIBYUV_DISABLE_MSA) && defined(__mips_msa)
diff --git a/3rdparty/libyuv/src/source/rotate_neon.cc b/3rdparty/libyuv/src/source/rotate_neon.cc
new file mode 100644
index 00000000..844df2bf
--- /dev/null
+++ b/3rdparty/libyuv/src/source/rotate_neon.cc
@@ -0,0 +1,418 @@
+/*
+ *  Copyright 2011 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include "libyuv/rotate_row.h"
+#include "libyuv/row.h"
+
+#include "libyuv/basic_types.h"
+
+#ifdef __cplusplus
+namespace libyuv {
+extern "C" {
+#endif
+
+#if !defined(LIBYUV_DISABLE_NEON) && defined(__ARM_NEON__) && \
+    !defined(__aarch64__)
+
+static const uvec8 kVTbl4x4Transpose = {0, 4, 8,  12, 1, 5, 9,  13,
+                                        2, 6, 10, 14, 3, 7, 11, 15};
+
+void TransposeWx8_NEON(const uint8_t* src,
+                       int src_stride,
+                       uint8_t* dst,
+                       int dst_stride,
+                       int width) {
+  const uint8_t* src_temp;
+  asm volatile(
+      // loops are on blocks of 8. loop will stop when
+      // counter gets to or below 0. starting the counter
+      // at w-8 allow for this
+      "sub         %5, #8                        \n"
+
+      // handle 8x8 blocks. this should be the majority of the plane
+      "1:                                        \n"
+      "mov         %0, %1                        \n"
+
+      "vld1.8      {d0}, [%0], %2                \n"
+      "vld1.8      {d1}, [%0], %2                \n"
+      "vld1.8      {d2}, [%0], %2                \n"
+      "vld1.8      {d3}, [%0], %2                \n"
+      "vld1.8      {d4}, [%0], %2                \n"
+      "vld1.8      {d5}, [%0], %2                \n"
+      "vld1.8      {d6}, [%0], %2                \n"
+      "vld1.8      {d7}, [%0]                    \n"
+
+      "vtrn.8      d1, d0                        \n"
+      "vtrn.8      d3, d2                        \n"
+      "vtrn.8      d5, d4                        \n"
+      "vtrn.8      d7, d6                        \n"
+
+      "vtrn.16     d1, d3                        \n"
+      "vtrn.16     d0, d2                        \n"
+      "vtrn.16     d5, d7                        \n"
+      "vtrn.16     d4, d6                        \n"
+
+      "vtrn.32     d1, d5                        \n"
+      "vtrn.32     d0, d4                        \n"
+      "vtrn.32     d3, d7                        \n"
+      "vtrn.32     d2, d6                        \n"
+
+      "vrev16.8    q0, q0                        \n"
+      "vrev16.8    q1, q1                        \n"
+      "vrev16.8    q2, q2                        \n"
+      "vrev16.8    q3, q3                        \n"
+
+      "mov         %0, %3                        \n"
+
+      "vst1.8      {d1}, [%0], %4                \n"
+      "vst1.8      {d0}, [%0], %4                \n"
+      "vst1.8      {d3}, [%0], %4                \n"
+      "vst1.8      {d2}, [%0], %4                \n"
+      "vst1.8      {d5}, [%0], %4                \n"
+      "vst1.8      {d4}, [%0], %4                \n"
+      "vst1.8      {d7}, [%0], %4                \n"
+      "vst1.8      {d6}, [%0]                    \n"
+
+      "add         %1, #8                        \n"  // src += 8
+      "add         %3, %3, %4, lsl #3            \n"  // dst += 8 * dst_stride
+      "subs        %5,  #8                       \n"  // w   -= 8
+      "bge         1b                            \n"
+
+      // add 8 back to counter. if the result is 0 there are
+      // no residuals.
+      "adds        %5, #8                        \n"
+      "beq         4f                            \n"
+
+      // some residual, so between 1 and 7 lines left to transpose
+      "cmp         %5, #2                        \n"
+      "blt         3f                            \n"
+
+      "cmp         %5, #4                        \n"
+      "blt         2f                            \n"
+
+      // 4x8 block
+      "mov         %0, %1                        \n"
+      "vld1.32     {d0[0]}, [%0], %2             \n"
+      "vld1.32     {d0[1]}, [%0], %2             \n"
+      "vld1.32     {d1[0]}, [%0], %2             \n"
+      "vld1.32     {d1[1]}, [%0], %2             \n"
+      "vld1.32     {d2[0]}, [%0], %2             \n"
+      "vld1.32     {d2[1]}, [%0], %2             \n"
+      "vld1.32     {d3[0]}, [%0], %2             \n"
+      "vld1.32     {d3[1]}, [%0]                 \n"
+
+      "mov         %0, %3                        \n"
+
+      "vld1.8      {q3}, [%6]                    \n"
+
+      "vtbl.8      d4, {d0, d1}, d6              \n"
+      "vtbl.8      d5, {d0, d1}, d7              \n"
+      "vtbl.8      d0, {d2, d3}, d6              \n"
+      "vtbl.8      d1, {d2, d3}, d7              \n"
+
+      // TODO(frkoenig): Rework shuffle above to
+      // write out with 4 instead of 8 writes.
+      "vst1.32     {d4[0]}, [%0], %4             \n"
+      "vst1.32     {d4[1]}, [%0], %4             \n"
+      "vst1.32     {d5[0]}, [%0], %4             \n"
+      "vst1.32     {d5[1]}, [%0]                 \n"
+
+      "add         %0, %3, #4                    \n"
+      "vst1.32     {d0[0]}, [%0], %4             \n"
+      "vst1.32     {d0[1]}, [%0], %4             \n"
+      "vst1.32     {d1[0]}, [%0], %4             \n"
+      "vst1.32     {d1[1]}, [%0]                 \n"
+
+      "add         %1, #4                        \n"  // src += 4
+      "add         %3, %3, %4, lsl #2            \n"  // dst += 4 * dst_stride
+      "subs        %5,  #4                       \n"  // w   -= 4
+      "beq         4f                            \n"
+
+      // some residual, check to see if it includes a 2x8 block,
+      // or less
+      "cmp         %5, #2                        \n"
+      "blt         3f                            \n"
+
+      // 2x8 block
+      "2:                                        \n"
+      "mov         %0, %1                        \n"
+      "vld1.16     {d0[0]}, [%0], %2             \n"
+      "vld1.16     {d1[0]}, [%0], %2             \n"
+      "vld1.16     {d0[1]}, [%0], %2             \n"
+      "vld1.16     {d1[1]}, [%0], %2             \n"
+      "vld1.16     {d0[2]}, [%0], %2             \n"
+      "vld1.16     {d1[2]}, [%0], %2             \n"
+      "vld1.16     {d0[3]}, [%0], %2             \n"
+      "vld1.16     {d1[3]}, [%0]                 \n"
+
+      "vtrn.8      d0, d1                        \n"
+
+      "mov         %0, %3                        \n"
+
+      "vst1.64     {d0}, [%0], %4                \n"
+      "vst1.64     {d1}, [%0]                    \n"
+
+      "add         %1, #2                        \n"  // src += 2
+      "add         %3, %3, %4, lsl #1            \n"  // dst += 2 * dst_stride
+      "subs        %5,  #2                       \n"  // w   -= 2
+      "beq         4f                            \n"
+
+      // 1x8 block
+      "3:                                        \n"
+      "vld1.8      {d0[0]}, [%1], %2             \n"
+      "vld1.8      {d0[1]}, [%1], %2             \n"
+      "vld1.8      {d0[2]}, [%1], %2             \n"
+      "vld1.8      {d0[3]}, [%1], %2             \n"
+      "vld1.8      {d0[4]}, [%1], %2             \n"
+      "vld1.8      {d0[5]}, [%1], %2             \n"
+      "vld1.8      {d0[6]}, [%1], %2             \n"
+      "vld1.8      {d0[7]}, [%1]                 \n"
+
+      "vst1.64     {d0}, [%3]                    \n"
+
+      "4:                                        \n"
+
+      : "=&r"(src_temp),         // %0
+        "+r"(src),               // %1
+        "+r"(src_stride),        // %2
+        "+r"(dst),               // %3
+        "+r"(dst_stride),        // %4
+        "+r"(width)              // %5
+      : "r"(&kVTbl4x4Transpose)  // %6
+      : "memory", "cc", "q0", "q1", "q2", "q3");
+}
+
+static const uvec8 kVTbl4x4TransposeDi = {0, 8,  1, 9,  2, 10, 3, 11,
+                                          4, 12, 5, 13, 6, 14, 7, 15};
+
+void TransposeUVWx8_NEON(const uint8_t* src,
+                         int src_stride,
+                         uint8_t* dst_a,
+                         int dst_stride_a,
+                         uint8_t* dst_b,
+                         int dst_stride_b,
+                         int width) {
+  const uint8_t* src_temp;
+  asm volatile(
+      // loops are on blocks of 8. loop will stop when
+      // counter gets to or below 0. starting the counter
+      // at w-8 allow for this
+      "sub         %7, #8                        \n"
+
+      // handle 8x8 blocks. this should be the majority of the plane
+      "1:                                        \n"
+      "mov         %0, %1                        \n"
+
+      "vld2.8      {d0,  d1},  [%0], %2          \n"
+      "vld2.8      {d2,  d3},  [%0], %2          \n"
+      "vld2.8      {d4,  d5},  [%0], %2          \n"
+      "vld2.8      {d6,  d7},  [%0], %2          \n"
+      "vld2.8      {d16, d17}, [%0], %2          \n"
+      "vld2.8      {d18, d19}, [%0], %2          \n"
+      "vld2.8      {d20, d21}, [%0], %2          \n"
+      "vld2.8      {d22, d23}, [%0]              \n"
+
+      "vtrn.8      q1, q0                        \n"
+      "vtrn.8      q3, q2                        \n"
+      "vtrn.8      q9, q8                        \n"
+      "vtrn.8      q11, q10                      \n"
+
+      "vtrn.16     q1, q3                        \n"
+      "vtrn.16     q0, q2                        \n"
+      "vtrn.16     q9, q11                       \n"
+      "vtrn.16     q8, q10                       \n"
+
+      "vtrn.32     q1, q9                        \n"
+      "vtrn.32     q0, q8                        \n"
+      "vtrn.32     q3, q11                       \n"
+      "vtrn.32     q2, q10                       \n"
+
+      "vrev16.8    q0, q0                        \n"
+      "vrev16.8    q1, q1                        \n"
+      "vrev16.8    q2, q2                        \n"
+      "vrev16.8    q3, q3                        \n"
+      "vrev16.8    q8, q8                        \n"
+      "vrev16.8    q9, q9                        \n"
+      "vrev16.8    q10, q10                      \n"
+      "vrev16.8    q11, q11                      \n"
+
+      "mov         %0, %3                        \n"
+
+      "vst1.8      {d2},  [%0], %4               \n"
+      "vst1.8      {d0},  [%0], %4               \n"
+      "vst1.8      {d6},  [%0], %4               \n"
+      "vst1.8      {d4},  [%0], %4               \n"
+      "vst1.8      {d18}, [%0], %4               \n"
+      "vst1.8      {d16}, [%0], %4               \n"
+      "vst1.8      {d22}, [%0], %4               \n"
+      "vst1.8      {d20}, [%0]                   \n"
+
+      "mov         %0, %5                        \n"
+
+      "vst1.8      {d3},  [%0], %6               \n"
+      "vst1.8      {d1},  [%0], %6               \n"
+      "vst1.8      {d7},  [%0], %6               \n"
+      "vst1.8      {d5},  [%0], %6               \n"
+      "vst1.8      {d19}, [%0], %6               \n"
+      "vst1.8      {d17}, [%0], %6               \n"
+      "vst1.8      {d23}, [%0], %6               \n"
+      "vst1.8      {d21}, [%0]                   \n"
+
+      "add         %1, #8*2                      \n"  // src   += 8*2
+      "add         %3, %3, %4, lsl #3            \n"  // dst_a += 8 *
+                                                      // dst_stride_a
+      "add         %5, %5, %6, lsl #3            \n"  // dst_b += 8 *
+                                                      // dst_stride_b
+      "subs        %7,  #8                       \n"  // w     -= 8
+      "bge         1b                            \n"
+
+      // add 8 back to counter. if the result is 0 there are
+      // no residuals.
+      "adds        %7, #8                        \n"
+      "beq         4f                            \n"
+
+      // some residual, so between 1 and 7 lines left to transpose
+      "cmp         %7, #2                        \n"
+      "blt         3f                            \n"
+
+      "cmp         %7, #4                        \n"
+      "blt         2f                            \n"
+
+      // TODO(frkoenig): Clean this up
+      // 4x8 block
+      "mov         %0, %1                        \n"
+      "vld1.64     {d0}, [%0], %2                \n"
+      "vld1.64     {d1}, [%0], %2                \n"
+      "vld1.64     {d2}, [%0], %2                \n"
+      "vld1.64     {d3}, [%0], %2                \n"
+      "vld1.64     {d4}, [%0], %2                \n"
+      "vld1.64     {d5}, [%0], %2                \n"
+      "vld1.64     {d6}, [%0], %2                \n"
+      "vld1.64     {d7}, [%0]                    \n"
+
+      "vld1.8      {q15}, [%8]                   \n"
+
+      "vtrn.8      q0, q1                        \n"
+      "vtrn.8      q2, q3                        \n"
+
+      "vtbl.8      d16, {d0, d1}, d30            \n"
+      "vtbl.8      d17, {d0, d1}, d31            \n"
+      "vtbl.8      d18, {d2, d3}, d30            \n"
+      "vtbl.8      d19, {d2, d3}, d31            \n"
+      "vtbl.8      d20, {d4, d5}, d30            \n"
+      "vtbl.8      d21, {d4, d5}, d31            \n"
+      "vtbl.8      d22, {d6, d7}, d30            \n"
+      "vtbl.8      d23, {d6, d7}, d31            \n"
+
+      "mov         %0, %3                        \n"
+
+      "vst1.32     {d16[0]},  [%0], %4           \n"
+      "vst1.32     {d16[1]},  [%0], %4           \n"
+      "vst1.32     {d17[0]},  [%0], %4           \n"
+      "vst1.32     {d17[1]},  [%0], %4           \n"
+
+      "add         %0, %3, #4                    \n"
+      "vst1.32     {d20[0]}, [%0], %4            \n"
+      "vst1.32     {d20[1]}, [%0], %4            \n"
+      "vst1.32     {d21[0]}, [%0], %4            \n"
+      "vst1.32     {d21[1]}, [%0]                \n"
+
+      "mov         %0, %5                        \n"
+
+      "vst1.32     {d18[0]}, [%0], %6            \n"
+      "vst1.32     {d18[1]}, [%0], %6            \n"
+      "vst1.32     {d19[0]}, [%0], %6            \n"
+      "vst1.32     {d19[1]}, [%0], %6            \n"
+
+      "add         %0, %5, #4                    \n"
+      "vst1.32     {d22[0]},  [%0], %6           \n"
+      "vst1.32     {d22[1]},  [%0], %6           \n"
+      "vst1.32     {d23[0]},  [%0], %6           \n"
+      "vst1.32     {d23[1]},  [%0]               \n"
+
+      "add         %1, #4*2                      \n"  // src   += 4 * 2
+      "add         %3, %3, %4, lsl #2            \n"  // dst_a += 4 *
+                                                      // dst_stride_a
+      "add         %5, %5, %6, lsl #2            \n"  // dst_b += 4 *
+                                                      // dst_stride_b
+      "subs        %7,  #4                       \n"  // w     -= 4
+      "beq         4f                            \n"
+
+      // some residual, check to see if it includes a 2x8 block,
+      // or less
+      "cmp         %7, #2                        \n"
+      "blt         3f                            \n"
+
+      // 2x8 block
+      "2:                                        \n"
+      "mov         %0, %1                        \n"
+      "vld2.16     {d0[0], d2[0]}, [%0], %2      \n"
+      "vld2.16     {d1[0], d3[0]}, [%0], %2      \n"
+      "vld2.16     {d0[1], d2[1]}, [%0], %2      \n"
+      "vld2.16     {d1[1], d3[1]}, [%0], %2      \n"
+      "vld2.16     {d0[2], d2[2]}, [%0], %2      \n"
+      "vld2.16     {d1[2], d3[2]}, [%0], %2      \n"
+      "vld2.16     {d0[3], d2[3]}, [%0], %2      \n"
+      "vld2.16     {d1[3], d3[3]}, [%0]          \n"
+
+      "vtrn.8      d0, d1                        \n"
+      "vtrn.8      d2, d3                        \n"
+
+      "mov         %0, %3                        \n"
+
+      "vst1.64     {d0}, [%0], %4                \n"
+      "vst1.64     {d2}, [%0]                    \n"
+
+      "mov         %0, %5                        \n"
+
+      "vst1.64     {d1}, [%0], %6                \n"
+      "vst1.64     {d3}, [%0]                    \n"
+
+      "add         %1, #2*2                      \n"  // src   += 2 * 2
+      "add         %3, %3, %4, lsl #1            \n"  // dst_a += 2 *
+                                                      // dst_stride_a
+      "add         %5, %5, %6, lsl #1            \n"  // dst_b += 2 *
+                                                      // dst_stride_b
+      "subs        %7,  #2                       \n"  // w     -= 2
+      "beq         4f                            \n"
+
+      // 1x8 block
+      "3:                                        \n"
+      "vld2.8      {d0[0], d1[0]}, [%1], %2      \n"
+      "vld2.8      {d0[1], d1[1]}, [%1], %2      \n"
+      "vld2.8      {d0[2], d1[2]}, [%1], %2      \n"
+      "vld2.8      {d0[3], d1[3]}, [%1], %2      \n"
+      "vld2.8      {d0[4], d1[4]}, [%1], %2      \n"
+      "vld2.8      {d0[5], d1[5]}, [%1], %2      \n"
+      "vld2.8      {d0[6], d1[6]}, [%1], %2      \n"
+      "vld2.8      {d0[7], d1[7]}, [%1]          \n"
+
+      "vst1.64     {d0}, [%3]                    \n"
+      "vst1.64     {d1}, [%5]                    \n"
+
+      "4:                                        \n"
+
+      : "=&r"(src_temp),           // %0
+        "+r"(src),                 // %1
+        "+r"(src_stride),          // %2
+        "+r"(dst_a),               // %3
+        "+r"(dst_stride_a),        // %4
+        "+r"(dst_b),               // %5
+        "+r"(dst_stride_b),        // %6
+        "+r"(width)                // %7
+      : "r"(&kVTbl4x4TransposeDi)  // %8
+      : "memory", "cc", "q0", "q1", "q2", "q3", "q8", "q9", "q10", "q11");
+}
+#endif  // defined(__ARM_NEON__) && !defined(__aarch64__)
+
+#ifdef __cplusplus
+}  // extern "C"
+}  // namespace libyuv
+#endif
diff --git a/3rdparty/libyuv/src/source/rotate_neon64.cc b/3rdparty/libyuv/src/source/rotate_neon64.cc
new file mode 100644
index 00000000..43c15817
--- /dev/null
+++ b/3rdparty/libyuv/src/source/rotate_neon64.cc
@@ -0,0 +1,443 @@
+/*
+ *  Copyright 2014 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include "libyuv/rotate_row.h"
+#include "libyuv/row.h"
+
+#include "libyuv/basic_types.h"
+
+#ifdef __cplusplus
+namespace libyuv {
+extern "C" {
+#endif
+
+// This module is for GCC Neon armv8 64 bit.
+#if !defined(LIBYUV_DISABLE_NEON) && defined(__aarch64__)
+
+static const uvec8 kVTbl4x4Transpose = {0, 4, 8,  12, 1, 5, 9,  13,
+                                        2, 6, 10, 14, 3, 7, 11, 15};
+
+void TransposeWx8_NEON(const uint8_t* src,
+                       int src_stride,
+                       uint8_t* dst,
+                       int dst_stride,
+                       int width) {
+  const uint8_t* src_temp;
+  asm volatile(
+      // loops are on blocks of 8. loop will stop when
+      // counter gets to or below 0. starting the counter
+      // at w-8 allow for this
+      "sub         %w3, %w3, #8                  \n"
+
+      // handle 8x8 blocks. this should be the majority of the plane
+      "1:                                        \n"
+      "mov         %0, %1                        \n"
+
+      "ld1         {v0.8b}, [%0], %5             \n"
+      "ld1         {v1.8b}, [%0], %5             \n"
+      "ld1         {v2.8b}, [%0], %5             \n"
+      "ld1         {v3.8b}, [%0], %5             \n"
+      "ld1         {v4.8b}, [%0], %5             \n"
+      "ld1         {v5.8b}, [%0], %5             \n"
+      "ld1         {v6.8b}, [%0], %5             \n"
+      "ld1         {v7.8b}, [%0]                 \n"
+      "mov         %0, %1                        \n"
+
+      "trn2        v16.8b, v0.8b, v1.8b          \n"
+      "prfm        pldl1keep, [%0, 448]          \n"  // prefetch 7 lines ahead
+      "trn1        v17.8b, v0.8b, v1.8b          \n"
+      "add         %0, %0, %5                    \n"
+      "trn2        v18.8b, v2.8b, v3.8b          \n"
+      "prfm        pldl1keep, [%0, 448]          \n"  // row 1
+      "trn1        v19.8b, v2.8b, v3.8b          \n"
+      "add         %0, %0, %5                    \n"
+      "trn2        v20.8b, v4.8b, v5.8b          \n"
+      "prfm        pldl1keep, [%0, 448]          \n"  // row 2
+      "trn1        v21.8b, v4.8b, v5.8b          \n"
+      "add         %0, %0, %5                    \n"
+      "trn2        v22.8b, v6.8b, v7.8b          \n"
+      "prfm        pldl1keep, [%0, 448]          \n"  // row 3
+      "trn1        v23.8b, v6.8b, v7.8b          \n"
+      "add         %0, %0, %5                    \n"
+
+      "trn2        v3.4h, v17.4h, v19.4h         \n"
+      "prfm        pldl1keep, [%0, 448]          \n"  // row 4
+      "trn1        v1.4h, v17.4h, v19.4h         \n"
+      "add         %0, %0, %5                    \n"
+      "trn2        v2.4h, v16.4h, v18.4h         \n"
+      "prfm        pldl1keep, [%0, 448]          \n"  // row 5
+      "trn1        v0.4h, v16.4h, v18.4h         \n"
+      "add         %0, %0, %5                    \n"
+      "trn2        v7.4h, v21.4h, v23.4h         \n"
+      "prfm        pldl1keep, [%0, 448]          \n"  // row 6
+      "trn1        v5.4h, v21.4h, v23.4h         \n"
+      "add         %0, %0, %5                    \n"
+      "trn2        v6.4h, v20.4h, v22.4h         \n"
+      "prfm        pldl1keep, [%0, 448]          \n"  // row 7
+      "trn1        v4.4h, v20.4h, v22.4h         \n"
+
+      "trn2        v21.2s, v1.2s, v5.2s          \n"
+      "trn1        v17.2s, v1.2s, v5.2s          \n"
+      "trn2        v20.2s, v0.2s, v4.2s          \n"
+      "trn1        v16.2s, v0.2s, v4.2s          \n"
+      "trn2        v23.2s, v3.2s, v7.2s          \n"
+      "trn1        v19.2s, v3.2s, v7.2s          \n"
+      "trn2        v22.2s, v2.2s, v6.2s          \n"
+      "trn1        v18.2s, v2.2s, v6.2s          \n"
+
+      "mov         %0, %2                        \n"
+
+      "st1         {v17.8b}, [%0], %6            \n"
+      "st1         {v16.8b}, [%0], %6            \n"
+      "st1         {v19.8b}, [%0], %6            \n"
+      "st1         {v18.8b}, [%0], %6            \n"
+      "st1         {v21.8b}, [%0], %6            \n"
+      "st1         {v20.8b}, [%0], %6            \n"
+      "st1         {v23.8b}, [%0], %6            \n"
+      "st1         {v22.8b}, [%0]                \n"
+
+      "add         %1, %1, #8                    \n"  // src += 8
+      "add         %2, %2, %6, lsl #3            \n"  // dst += 8 * dst_stride
+      "subs        %w3, %w3, #8                  \n"  // w   -= 8
+      "b.ge        1b                            \n"
+
+      // add 8 back to counter. if the result is 0 there are
+      // no residuals.
+      "adds        %w3, %w3, #8                  \n"
+      "b.eq        4f                            \n"
+
+      // some residual, so between 1 and 7 lines left to transpose
+      "cmp         %w3, #2                       \n"
+      "b.lt        3f                            \n"
+
+      "cmp         %w3, #4                       \n"
+      "b.lt        2f                            \n"
+
+      // 4x8 block
+      "mov         %0, %1                        \n"
+      "ld1         {v0.s}[0], [%0], %5           \n"
+      "ld1         {v0.s}[1], [%0], %5           \n"
+      "ld1         {v0.s}[2], [%0], %5           \n"
+      "ld1         {v0.s}[3], [%0], %5           \n"
+      "ld1         {v1.s}[0], [%0], %5           \n"
+      "ld1         {v1.s}[1], [%0], %5           \n"
+      "ld1         {v1.s}[2], [%0], %5           \n"
+      "ld1         {v1.s}[3], [%0]               \n"
+
+      "mov         %0, %2                        \n"
+
+      "ld1         {v2.16b}, [%4]                \n"
+
+      "tbl         v3.16b, {v0.16b}, v2.16b      \n"
+      "tbl         v0.16b, {v1.16b}, v2.16b      \n"
+
+      // TODO(frkoenig): Rework shuffle above to
+      // write out with 4 instead of 8 writes.
+      "st1 {v3.s}[0], [%0], %6                     \n"
+      "st1 {v3.s}[1], [%0], %6                     \n"
+      "st1 {v3.s}[2], [%0], %6                     \n"
+      "st1 {v3.s}[3], [%0]                         \n"
+
+      "add         %0, %2, #4                      \n"
+      "st1 {v0.s}[0], [%0], %6                     \n"
+      "st1 {v0.s}[1], [%0], %6                     \n"
+      "st1 {v0.s}[2], [%0], %6                     \n"
+      "st1 {v0.s}[3], [%0]                         \n"
+
+      "add         %1, %1, #4                      \n"  // src += 4
+      "add         %2, %2, %6, lsl #2              \n"  // dst += 4 * dst_stride
+      "subs        %w3, %w3, #4                    \n"  // w   -= 4
+      "b.eq        4f                              \n"
+
+      // some residual, check to see if it includes a 2x8 block,
+      // or less
+      "cmp         %w3, #2                         \n"
+      "b.lt        3f                              \n"
+
+      // 2x8 block
+      "2:                                          \n"
+      "mov         %0, %1                          \n"
+      "ld1     {v0.h}[0], [%0], %5                 \n"
+      "ld1     {v1.h}[0], [%0], %5                 \n"
+      "ld1     {v0.h}[1], [%0], %5                 \n"
+      "ld1     {v1.h}[1], [%0], %5                 \n"
+      "ld1     {v0.h}[2], [%0], %5                 \n"
+      "ld1     {v1.h}[2], [%0], %5                 \n"
+      "ld1     {v0.h}[3], [%0], %5                 \n"
+      "ld1     {v1.h}[3], [%0]                     \n"
+
+      "trn2    v2.8b, v0.8b, v1.8b                 \n"
+      "trn1    v3.8b, v0.8b, v1.8b                 \n"
+
+      "mov         %0, %2                          \n"
+
+      "st1     {v3.8b}, [%0], %6                   \n"
+      "st1     {v2.8b}, [%0]                       \n"
+
+      "add         %1, %1, #2                      \n"  // src += 2
+      "add         %2, %2, %6, lsl #1              \n"  // dst += 2 * dst_stride
+      "subs        %w3, %w3,  #2                   \n"  // w   -= 2
+      "b.eq        4f                              \n"
+
+      // 1x8 block
+      "3:                                          \n"
+      "ld1         {v0.b}[0], [%1], %5             \n"
+      "ld1         {v0.b}[1], [%1], %5             \n"
+      "ld1         {v0.b}[2], [%1], %5             \n"
+      "ld1         {v0.b}[3], [%1], %5             \n"
+      "ld1         {v0.b}[4], [%1], %5             \n"
+      "ld1         {v0.b}[5], [%1], %5             \n"
+      "ld1         {v0.b}[6], [%1], %5             \n"
+      "ld1         {v0.b}[7], [%1]                 \n"
+
+      "st1         {v0.8b}, [%2]                   \n"
+
+      "4:                                          \n"
+
+      : "=&r"(src_temp),                          // %0
+        "+r"(src),                                // %1
+        "+r"(dst),                                // %2
+        "+r"(width)                               // %3
+      : "r"(&kVTbl4x4Transpose),                  // %4
+        "r"(static_cast<ptrdiff_t>(src_stride)),  // %5
+        "r"(static_cast<ptrdiff_t>(dst_stride))   // %6
+      : "memory", "cc", "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7", "v16",
+        "v17", "v18", "v19", "v20", "v21", "v22", "v23");
+}
+
+static const uint8_t kVTbl4x4TransposeDi[32] = {
+    0, 16, 32, 48, 2, 18, 34, 50, 4, 20, 36, 52, 6, 22, 38, 54,
+    1, 17, 33, 49, 3, 19, 35, 51, 5, 21, 37, 53, 7, 23, 39, 55};
+
+void TransposeUVWx8_NEON(const uint8_t* src,
+                         int src_stride,
+                         uint8_t* dst_a,
+                         int dst_stride_a,
+                         uint8_t* dst_b,
+                         int dst_stride_b,
+                         int width) {
+  const uint8_t* src_temp;
+  asm volatile(
+      // loops are on blocks of 8. loop will stop when
+      // counter gets to or below 0. starting the counter
+      // at w-8 allow for this
+      "sub         %w4, %w4, #8                  \n"
+
+      // handle 8x8 blocks. this should be the majority of the plane
+      "1:                                        \n"
+      "mov         %0, %1                        \n"
+
+      "ld1         {v0.16b}, [%0], %5            \n"
+      "ld1         {v1.16b}, [%0], %5            \n"
+      "ld1         {v2.16b}, [%0], %5            \n"
+      "ld1         {v3.16b}, [%0], %5            \n"
+      "ld1         {v4.16b}, [%0], %5            \n"
+      "ld1         {v5.16b}, [%0], %5            \n"
+      "ld1         {v6.16b}, [%0], %5            \n"
+      "ld1         {v7.16b}, [%0]                \n"
+      "mov         %0, %1                        \n"
+
+      "trn1        v16.16b, v0.16b, v1.16b       \n"
+      "trn2        v17.16b, v0.16b, v1.16b       \n"
+      "trn1        v18.16b, v2.16b, v3.16b       \n"
+      "trn2        v19.16b, v2.16b, v3.16b       \n"
+      "trn1        v20.16b, v4.16b, v5.16b       \n"
+      "trn2        v21.16b, v4.16b, v5.16b       \n"
+      "trn1        v22.16b, v6.16b, v7.16b       \n"
+      "trn2        v23.16b, v6.16b, v7.16b       \n"
+
+      "trn1        v0.8h, v16.8h, v18.8h         \n"
+      "trn2        v1.8h, v16.8h, v18.8h         \n"
+      "trn1        v2.8h, v20.8h, v22.8h         \n"
+      "trn2        v3.8h, v20.8h, v22.8h         \n"
+      "trn1        v4.8h, v17.8h, v19.8h         \n"
+      "trn2        v5.8h, v17.8h, v19.8h         \n"
+      "trn1        v6.8h, v21.8h, v23.8h         \n"
+      "trn2        v7.8h, v21.8h, v23.8h         \n"
+
+      "trn1        v16.4s, v0.4s, v2.4s          \n"
+      "trn2        v17.4s, v0.4s, v2.4s          \n"
+      "trn1        v18.4s, v1.4s, v3.4s          \n"
+      "trn2        v19.4s, v1.4s, v3.4s          \n"
+      "trn1        v20.4s, v4.4s, v6.4s          \n"
+      "trn2        v21.4s, v4.4s, v6.4s          \n"
+      "trn1        v22.4s, v5.4s, v7.4s          \n"
+      "trn2        v23.4s, v5.4s, v7.4s          \n"
+
+      "mov         %0, %2                        \n"
+
+      "st1         {v16.d}[0], [%0], %6          \n"
+      "st1         {v18.d}[0], [%0], %6          \n"
+      "st1         {v17.d}[0], [%0], %6          \n"
+      "st1         {v19.d}[0], [%0], %6          \n"
+      "st1         {v16.d}[1], [%0], %6          \n"
+      "st1         {v18.d}[1], [%0], %6          \n"
+      "st1         {v17.d}[1], [%0], %6          \n"
+      "st1         {v19.d}[1], [%0]              \n"
+
+      "mov         %0, %3                        \n"
+
+      "st1         {v20.d}[0], [%0], %7          \n"
+      "st1         {v22.d}[0], [%0], %7          \n"
+      "st1         {v21.d}[0], [%0], %7          \n"
+      "st1         {v23.d}[0], [%0], %7          \n"
+      "st1         {v20.d}[1], [%0], %7          \n"
+      "st1         {v22.d}[1], [%0], %7          \n"
+      "st1         {v21.d}[1], [%0], %7          \n"
+      "st1         {v23.d}[1], [%0]              \n"
+
+      "add         %1, %1, #16                   \n"  // src   += 8*2
+      "add         %2, %2, %6, lsl #3            \n"  // dst_a += 8 *
+                                                      // dst_stride_a
+      "add         %3, %3, %7, lsl #3            \n"  // dst_b += 8 *
+                                                      // dst_stride_b
+      "subs        %w4, %w4,  #8                 \n"  // w     -= 8
+      "b.ge        1b                            \n"
+
+      // add 8 back to counter. if the result is 0 there are
+      // no residuals.
+      "adds        %w4, %w4, #8                  \n"
+      "b.eq        4f                            \n"
+
+      // some residual, so between 1 and 7 lines left to transpose
+      "cmp         %w4, #2                       \n"
+      "b.lt        3f                            \n"
+
+      "cmp         %w4, #4                       \n"
+      "b.lt        2f                            \n"
+
+      // TODO(frkoenig): Clean this up
+      // 4x8 block
+      "mov       %0, %1                          \n"
+      "ld1       {v0.8b}, [%0], %5               \n"
+      "ld1       {v1.8b}, [%0], %5               \n"
+      "ld1       {v2.8b}, [%0], %5               \n"
+      "ld1       {v3.8b}, [%0], %5               \n"
+      "ld1       {v4.8b}, [%0], %5               \n"
+      "ld1       {v5.8b}, [%0], %5               \n"
+      "ld1       {v6.8b}, [%0], %5               \n"
+      "ld1       {v7.8b}, [%0]                   \n"
+
+      "ld1       {v30.16b}, [%8], #16            \n"
+      "ld1       {v31.16b}, [%8]                 \n"
+
+      "tbl       v16.16b, {v0.16b, v1.16b, v2.16b, v3.16b}, v30.16b  \n"
+      "tbl       v17.16b, {v0.16b, v1.16b, v2.16b, v3.16b}, v31.16b  \n"
+      "tbl       v18.16b, {v4.16b, v5.16b, v6.16b, v7.16b}, v30.16b  \n"
+      "tbl       v19.16b, {v4.16b, v5.16b, v6.16b, v7.16b}, v31.16b  \n"
+
+      "mov       %0, %2                          \n"
+
+      "st1       {v16.s}[0],  [%0], %6           \n"
+      "st1       {v16.s}[1],  [%0], %6           \n"
+      "st1       {v16.s}[2],  [%0], %6           \n"
+      "st1       {v16.s}[3],  [%0], %6           \n"
+
+      "add       %0, %2, #4                      \n"
+      "st1       {v18.s}[0], [%0], %6            \n"
+      "st1       {v18.s}[1], [%0], %6            \n"
+      "st1       {v18.s}[2], [%0], %6            \n"
+      "st1       {v18.s}[3], [%0]                \n"
+
+      "mov       %0, %3                          \n"
+
+      "st1       {v17.s}[0], [%0], %7            \n"
+      "st1       {v17.s}[1], [%0], %7            \n"
+      "st1       {v17.s}[2], [%0], %7            \n"
+      "st1       {v17.s}[3], [%0], %7            \n"
+
+      "add       %0, %3, #4                      \n"
+      "st1       {v19.s}[0],  [%0], %7           \n"
+      "st1       {v19.s}[1],  [%0], %7           \n"
+      "st1       {v19.s}[2],  [%0], %7           \n"
+      "st1       {v19.s}[3],  [%0]               \n"
+
+      "add       %1, %1, #8                      \n"  // src   += 4 * 2
+      "add       %2, %2, %6, lsl #2              \n"  // dst_a += 4 *
+                                                      // dst_stride_a
+      "add       %3, %3, %7, lsl #2              \n"  // dst_b += 4 *
+                                                      // dst_stride_b
+      "subs      %w4,  %w4,  #4                  \n"  // w     -= 4
+      "b.eq      4f                              \n"
+
+      // some residual, check to see if it includes a 2x8 block,
+      // or less
+      "cmp       %w4, #2                         \n"
+      "b.lt      3f                              \n"
+
+      // 2x8 block
+      "2:                                        \n"
+      "mov       %0, %1                          \n"
+      "ld2       {v0.h, v1.h}[0], [%0], %5       \n"
+      "ld2       {v2.h, v3.h}[0], [%0], %5       \n"
+      "ld2       {v0.h, v1.h}[1], [%0], %5       \n"
+      "ld2       {v2.h, v3.h}[1], [%0], %5       \n"
+      "ld2       {v0.h, v1.h}[2], [%0], %5       \n"
+      "ld2       {v2.h, v3.h}[2], [%0], %5       \n"
+      "ld2       {v0.h, v1.h}[3], [%0], %5       \n"
+      "ld2       {v2.h, v3.h}[3], [%0]           \n"
+
+      "trn1      v4.8b, v0.8b, v2.8b             \n"
+      "trn2      v5.8b, v0.8b, v2.8b             \n"
+      "trn1      v6.8b, v1.8b, v3.8b             \n"
+      "trn2      v7.8b, v1.8b, v3.8b             \n"
+
+      "mov       %0, %2                          \n"
+
+      "st1       {v4.d}[0], [%0], %6             \n"
+      "st1       {v6.d}[0], [%0]                 \n"
+
+      "mov       %0, %3                          \n"
+
+      "st1       {v5.d}[0], [%0], %7             \n"
+      "st1       {v7.d}[0], [%0]                 \n"
+
+      "add       %1, %1, #4                      \n"  // src   += 2 * 2
+      "add       %2, %2, %6, lsl #1              \n"  // dst_a += 2 *
+                                                      // dst_stride_a
+      "add       %3, %3, %7, lsl #1              \n"  // dst_b += 2 *
+                                                      // dst_stride_b
+      "subs      %w4,  %w4,  #2                  \n"  // w     -= 2
+      "b.eq      4f                              \n"
+
+      // 1x8 block
+      "3:                                        \n"
+      "ld2       {v0.b, v1.b}[0], [%1], %5       \n"
+      "ld2       {v0.b, v1.b}[1], [%1], %5       \n"
+      "ld2       {v0.b, v1.b}[2], [%1], %5       \n"
+      "ld2       {v0.b, v1.b}[3], [%1], %5       \n"
+      "ld2       {v0.b, v1.b}[4], [%1], %5       \n"
+      "ld2       {v0.b, v1.b}[5], [%1], %5       \n"
+      "ld2       {v0.b, v1.b}[6], [%1], %5       \n"
+      "ld2       {v0.b, v1.b}[7], [%1]           \n"
+
+      "st1       {v0.d}[0], [%2]                 \n"
+      "st1       {v1.d}[0], [%3]                 \n"
+
+      "4:                                        \n"
+
+      : "=&r"(src_temp),                            // %0
+        "+r"(src),                                  // %1
+        "+r"(dst_a),                                // %2
+        "+r"(dst_b),                                // %3
+        "+r"(width)                                 // %4
+      : "r"(static_cast<ptrdiff_t>(src_stride)),    // %5
+        "r"(static_cast<ptrdiff_t>(dst_stride_a)),  // %6
+        "r"(static_cast<ptrdiff_t>(dst_stride_b)),  // %7
+        "r"(&kVTbl4x4TransposeDi)                   // %8
+      : "memory", "cc", "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7", "v16",
+        "v17", "v18", "v19", "v20", "v21", "v22", "v23", "v30", "v31");
+}
+#endif  // !defined(LIBYUV_DISABLE_NEON) && defined(__aarch64__)
+
+#ifdef __cplusplus
+}  // extern "C"
+}  // namespace libyuv
+#endif
diff --git a/3rdparty/libyuv/src/source/rotate_win.cc b/3rdparty/libyuv/src/source/rotate_win.cc
new file mode 100644
index 00000000..a78873f8
--- /dev/null
+++ b/3rdparty/libyuv/src/source/rotate_win.cc
@@ -0,0 +1,253 @@
+/*
+ *  Copyright 2013 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include "libyuv/rotate_row.h"
+#include "libyuv/row.h"
+
+#ifdef __cplusplus
+namespace libyuv {
+extern "C" {
+#endif
+
+// This module is for 32 bit Visual C x86
+#if !defined(LIBYUV_DISABLE_X86) && defined(_MSC_VER) && \
+    !defined(__clang__) && defined(_M_IX86)
+
+__declspec(naked) void TransposeWx8_SSSE3(const uint8_t* src,
+                                          int src_stride,
+                                          uint8_t* dst,
+                                          int dst_stride,
+                                          int width) {
+  __asm {
+    push      edi
+    push      esi
+    push      ebp
+    mov       eax, [esp + 12 + 4]  // src
+    mov       edi, [esp + 12 + 8]  // src_stride
+    mov       edx, [esp + 12 + 12]  // dst
+    mov       esi, [esp + 12 + 16]  // dst_stride
+    mov       ecx, [esp + 12 + 20]  // width
+
+    // Read in the data from the source pointer.
+    // First round of bit swap.
+    align      4
+ convertloop:
+    movq      xmm0, qword ptr [eax]
+    lea       ebp, [eax + 8]
+    movq      xmm1, qword ptr [eax + edi]
+    lea       eax, [eax + 2 * edi]
+    punpcklbw xmm0, xmm1
+    movq      xmm2, qword ptr [eax]
+    movdqa    xmm1, xmm0
+    palignr   xmm1, xmm1, 8
+    movq      xmm3, qword ptr [eax + edi]
+    lea       eax, [eax + 2 * edi]
+    punpcklbw xmm2, xmm3
+    movdqa    xmm3, xmm2
+    movq      xmm4, qword ptr [eax]
+    palignr   xmm3, xmm3, 8
+    movq      xmm5, qword ptr [eax + edi]
+    punpcklbw xmm4, xmm5
+    lea       eax, [eax + 2 * edi]
+    movdqa    xmm5, xmm4
+    movq      xmm6, qword ptr [eax]
+    palignr   xmm5, xmm5, 8
+    movq      xmm7, qword ptr [eax + edi]
+    punpcklbw xmm6, xmm7
+    mov       eax, ebp
+    movdqa    xmm7, xmm6
+    palignr   xmm7, xmm7, 8
+    // Second round of bit swap.
+    punpcklwd xmm0, xmm2
+    punpcklwd xmm1, xmm3
+    movdqa    xmm2, xmm0
+    movdqa    xmm3, xmm1
+    palignr   xmm2, xmm2, 8
+    palignr   xmm3, xmm3, 8
+    punpcklwd xmm4, xmm6
+    punpcklwd xmm5, xmm7
+    movdqa    xmm6, xmm4
+    movdqa    xmm7, xmm5
+    palignr   xmm6, xmm6, 8
+    palignr   xmm7, xmm7, 8
+    // Third round of bit swap.
+    // Write to the destination pointer.
+    punpckldq xmm0, xmm4
+    movq      qword ptr [edx], xmm0
+    movdqa    xmm4, xmm0
+    palignr   xmm4, xmm4, 8
+    movq      qword ptr [edx + esi], xmm4
+    lea       edx, [edx + 2 * esi]
+    punpckldq xmm2, xmm6
+    movdqa    xmm6, xmm2
+    palignr   xmm6, xmm6, 8
+    movq      qword ptr [edx], xmm2
+    punpckldq xmm1, xmm5
+    movq      qword ptr [edx + esi], xmm6
+    lea       edx, [edx + 2 * esi]
+    movdqa    xmm5, xmm1
+    movq      qword ptr [edx], xmm1
+    palignr   xmm5, xmm5, 8
+    punpckldq xmm3, xmm7
+    movq      qword ptr [edx + esi], xmm5
+    lea       edx, [edx + 2 * esi]
+    movq      qword ptr [edx], xmm3
+    movdqa    xmm7, xmm3
+    palignr   xmm7, xmm7, 8
+    sub       ecx, 8
+    movq      qword ptr [edx + esi], xmm7
+    lea       edx, [edx + 2 * esi]
+    jg        convertloop
+
+    pop       ebp
+    pop       esi
+    pop       edi
+    ret
+  }
+}
+
+__declspec(naked) void TransposeUVWx8_SSE2(const uint8_t* src,
+                                           int src_stride,
+                                           uint8_t* dst_a,
+                                           int dst_stride_a,
+                                           uint8_t* dst_b,
+                                           int dst_stride_b,
+                                           int w) {
+  __asm {
+    push      ebx
+    push      esi
+    push      edi
+    push      ebp
+    mov       eax, [esp + 16 + 4]  // src
+    mov       edi, [esp + 16 + 8]  // src_stride
+    mov       edx, [esp + 16 + 12]  // dst_a
+    mov       esi, [esp + 16 + 16]  // dst_stride_a
+    mov       ebx, [esp + 16 + 20]  // dst_b
+    mov       ebp, [esp + 16 + 24]  // dst_stride_b
+    mov       ecx, esp
+    sub       esp, 4 + 16
+    and       esp, ~15
+    mov       [esp + 16], ecx
+    mov       ecx, [ecx + 16 + 28]  // w
+
+    align      4
+    // Read in the data from the source pointer.
+    // First round of bit swap.
+  convertloop:
+    movdqu    xmm0, [eax]
+    movdqu    xmm1, [eax + edi]
+    lea       eax, [eax + 2 * edi]
+    movdqa    xmm7, xmm0  // use xmm7 as temp register.
+    punpcklbw xmm0, xmm1
+    punpckhbw xmm7, xmm1
+    movdqa    xmm1, xmm7
+    movdqu    xmm2, [eax]
+    movdqu    xmm3, [eax + edi]
+    lea       eax, [eax + 2 * edi]
+    movdqa    xmm7, xmm2
+    punpcklbw xmm2, xmm3
+    punpckhbw xmm7, xmm3
+    movdqa    xmm3, xmm7
+    movdqu    xmm4, [eax]
+    movdqu    xmm5, [eax + edi]
+    lea       eax, [eax + 2 * edi]
+    movdqa    xmm7, xmm4
+    punpcklbw xmm4, xmm5
+    punpckhbw xmm7, xmm5
+    movdqa    xmm5, xmm7
+    movdqu    xmm6, [eax]
+    movdqu    xmm7, [eax + edi]
+    lea       eax, [eax + 2 * edi]
+    movdqu    [esp], xmm5  // backup xmm5
+    neg       edi
+    movdqa    xmm5, xmm6  // use xmm5 as temp register.
+    punpcklbw xmm6, xmm7
+    punpckhbw xmm5, xmm7
+    movdqa    xmm7, xmm5
+    lea       eax, [eax + 8 * edi + 16]
+    neg       edi
+        // Second round of bit swap.
+    movdqa    xmm5, xmm0
+    punpcklwd xmm0, xmm2
+    punpckhwd xmm5, xmm2
+    movdqa    xmm2, xmm5
+    movdqa    xmm5, xmm1
+    punpcklwd xmm1, xmm3
+    punpckhwd xmm5, xmm3
+    movdqa    xmm3, xmm5
+    movdqa    xmm5, xmm4
+    punpcklwd xmm4, xmm6
+    punpckhwd xmm5, xmm6
+    movdqa    xmm6, xmm5
+    movdqu    xmm5, [esp]  // restore xmm5
+    movdqu    [esp], xmm6  // backup xmm6
+    movdqa    xmm6, xmm5  // use xmm6 as temp register.
+    punpcklwd xmm5, xmm7
+    punpckhwd xmm6, xmm7
+    movdqa    xmm7, xmm6
+
+        // Third round of bit swap.
+        // Write to the destination pointer.
+    movdqa    xmm6, xmm0
+    punpckldq xmm0, xmm4
+    punpckhdq xmm6, xmm4
+    movdqa    xmm4, xmm6
+    movdqu    xmm6, [esp]  // restore xmm6
+    movlpd    qword ptr [edx], xmm0
+    movhpd    qword ptr [ebx], xmm0
+    movlpd    qword ptr [edx + esi], xmm4
+    lea       edx, [edx + 2 * esi]
+    movhpd    qword ptr [ebx + ebp], xmm4
+    lea       ebx, [ebx + 2 * ebp]
+    movdqa    xmm0, xmm2  // use xmm0 as the temp register.
+    punpckldq xmm2, xmm6
+    movlpd    qword ptr [edx], xmm2
+    movhpd    qword ptr [ebx], xmm2
+    punpckhdq xmm0, xmm6
+    movlpd    qword ptr [edx + esi], xmm0
+    lea       edx, [edx + 2 * esi]
+    movhpd    qword ptr [ebx + ebp], xmm0
+    lea       ebx, [ebx + 2 * ebp]
+    movdqa    xmm0, xmm1  // use xmm0 as the temp register.
+    punpckldq xmm1, xmm5
+    movlpd    qword ptr [edx], xmm1
+    movhpd    qword ptr [ebx], xmm1
+    punpckhdq xmm0, xmm5
+    movlpd    qword ptr [edx + esi], xmm0
+    lea       edx, [edx + 2 * esi]
+    movhpd    qword ptr [ebx + ebp], xmm0
+    lea       ebx, [ebx + 2 * ebp]
+    movdqa    xmm0, xmm3  // use xmm0 as the temp register.
+    punpckldq xmm3, xmm7
+    movlpd    qword ptr [edx], xmm3
+    movhpd    qword ptr [ebx], xmm3
+    punpckhdq xmm0, xmm7
+    sub       ecx, 8
+    movlpd    qword ptr [edx + esi], xmm0
+    lea       edx, [edx + 2 * esi]
+    movhpd    qword ptr [ebx + ebp], xmm0
+    lea       ebx, [ebx + 2 * ebp]
+    jg        convertloop
+
+    mov       esp, [esp + 16]
+    pop       ebp
+    pop       edi
+    pop       esi
+    pop       ebx
+    ret
+  }
+}
+
+#endif  // !defined(LIBYUV_DISABLE_X86) && defined(_M_IX86)
+
+#ifdef __cplusplus
+}  // extern "C"
+}  // namespace libyuv
+#endif
diff --git a/3rdparty/libyuv/src/source/row_any.cc b/3rdparty/libyuv/src/source/row_any.cc
new file mode 100644
index 00000000..3781a9f2
--- /dev/null
+++ b/3rdparty/libyuv/src/source/row_any.cc
@@ -0,0 +1,2235 @@
+/*
+ *  Copyright 2012 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include "libyuv/row.h"
+
+#include <string.h>  // For memset.
+
+#include "libyuv/basic_types.h"
+
+#ifdef __cplusplus
+namespace libyuv {
+extern "C" {
+#endif
+
+// memset for temp is meant to clear the source buffer (not dest) so that
+// SIMD that reads full multiple of 16 bytes will not trigger msan errors.
+// memset is not needed for production, as the garbage values are processed but
+// not used, although there may be edge cases for subsampling.
+// The size of the buffer is based on the largest read, which can be inferred
+// by the source type (e.g. ARGB) and the mask (last parameter), or by examining
+// the source code for how much the source pointers are advanced.
+
+// Subsampled source needs to be increase by 1 of not even.
+#define SS(width, shift) (((width) + (1 << (shift)) - 1) >> (shift))
+
+// Any 4 planes to 1
+#define ANY41(NAMEANY, ANY_SIMD, UVSHIFT, DUVSHIFT, BPP, MASK)               \
+  void NAMEANY(const uint8_t* y_buf, const uint8_t* u_buf,                   \
+               const uint8_t* v_buf, const uint8_t* a_buf, uint8_t* dst_ptr, \
+               int width) {                                                  \
+    SIMD_ALIGNED(uint8_t temp[64 * 5]);                                      \
+    memset(temp, 0, 64 * 4); /* for msan */                                  \
+    int r = width & MASK;                                                    \
+    int n = width & ~MASK;                                                   \
+    if (n > 0) {                                                             \
+      ANY_SIMD(y_buf, u_buf, v_buf, a_buf, dst_ptr, n);                      \
+    }                                                                        \
+    memcpy(temp, y_buf + n, r);                                              \
+    memcpy(temp + 64, u_buf + (n >> UVSHIFT), SS(r, UVSHIFT));               \
+    memcpy(temp + 128, v_buf + (n >> UVSHIFT), SS(r, UVSHIFT));              \
+    memcpy(temp + 192, a_buf + n, r);                                        \
+    ANY_SIMD(temp, temp + 64, temp + 128, temp + 192, temp + 256, MASK + 1); \
+    memcpy(dst_ptr + (n >> DUVSHIFT) * BPP, temp + 256,                      \
+           SS(r, DUVSHIFT) * BPP);                                           \
+  }
+
+#ifdef HAS_MERGEARGBROW_SSE2
+ANY41(MergeARGBRow_Any_SSE2, MergeARGBRow_SSE2, 0, 0, 4, 7)
+#endif
+#ifdef HAS_MERGEARGBROW_AVX2
+ANY41(MergeARGBRow_Any_AVX2, MergeARGBRow_AVX2, 0, 0, 4, 15)
+#endif
+#ifdef HAS_MERGEARGBROW_NEON
+ANY41(MergeARGBRow_Any_NEON, MergeARGBRow_NEON, 0, 0, 4, 15)
+#endif
+
+// Note that odd width replication includes 444 due to implementation
+// on arm that subsamples 444 to 422 internally.
+// Any 4 planes to 1 with yuvconstants
+#define ANY41C(NAMEANY, ANY_SIMD, UVSHIFT, DUVSHIFT, BPP, MASK)              \
+  void NAMEANY(const uint8_t* y_buf, const uint8_t* u_buf,                   \
+               const uint8_t* v_buf, const uint8_t* a_buf, uint8_t* dst_ptr, \
+               const struct YuvConstants* yuvconstants, int width) {         \
+    SIMD_ALIGNED(uint8_t temp[64 * 5]);                                      \
+    memset(temp, 0, 64 * 4); /* for msan */                                  \
+    int r = width & MASK;                                                    \
+    int n = width & ~MASK;                                                   \
+    if (n > 0) {                                                             \
+      ANY_SIMD(y_buf, u_buf, v_buf, a_buf, dst_ptr, yuvconstants, n);        \
+    }                                                                        \
+    memcpy(temp, y_buf + n, r);                                              \
+    memcpy(temp + 64, u_buf + (n >> UVSHIFT), SS(r, UVSHIFT));               \
+    memcpy(temp + 128, v_buf + (n >> UVSHIFT), SS(r, UVSHIFT));              \
+    memcpy(temp + 192, a_buf + n, r);                                        \
+    if (width & 1) {                                                         \
+      temp[64 + SS(r, UVSHIFT)] = temp[64 + SS(r, UVSHIFT) - 1];             \
+      temp[128 + SS(r, UVSHIFT)] = temp[128 + SS(r, UVSHIFT) - 1];           \
+    }                                                                        \
+    ANY_SIMD(temp, temp + 64, temp + 128, temp + 192, temp + 256,            \
+             yuvconstants, MASK + 1);                                        \
+    memcpy(dst_ptr + (n >> DUVSHIFT) * BPP, temp + 256,                      \
+           SS(r, DUVSHIFT) * BPP);                                           \
+  }
+
+#ifdef HAS_I444ALPHATOARGBROW_SSSE3
+ANY41C(I444AlphaToARGBRow_Any_SSSE3, I444AlphaToARGBRow_SSSE3, 0, 0, 4, 7)
+#endif
+#ifdef HAS_I444ALPHATOARGBROW_AVX2
+ANY41C(I444AlphaToARGBRow_Any_AVX2, I444AlphaToARGBRow_AVX2, 0, 0, 4, 15)
+#endif
+#ifdef HAS_I422ALPHATOARGBROW_SSSE3
+ANY41C(I422AlphaToARGBRow_Any_SSSE3, I422AlphaToARGBRow_SSSE3, 1, 0, 4, 7)
+#endif
+#ifdef HAS_I422ALPHATOARGBROW_AVX2
+ANY41C(I422AlphaToARGBRow_Any_AVX2, I422AlphaToARGBRow_AVX2, 1, 0, 4, 15)
+#endif
+#ifdef HAS_I444ALPHATOARGBROW_NEON
+ANY41C(I444AlphaToARGBRow_Any_NEON, I444AlphaToARGBRow_NEON, 0, 0, 4, 7)
+#endif
+#ifdef HAS_I422ALPHATOARGBROW_NEON
+ANY41C(I422AlphaToARGBRow_Any_NEON, I422AlphaToARGBRow_NEON, 1, 0, 4, 7)
+#endif
+#ifdef HAS_I444ALPHATOARGBROW_MSA
+ANY41C(I444AlphaToARGBRow_Any_MSA, I444AlphaToARGBRow_MSA, 0, 0, 4, 7)
+#endif
+#ifdef HAS_I422ALPHATOARGBROW_MSA
+ANY41C(I422AlphaToARGBRow_Any_MSA, I422AlphaToARGBRow_MSA, 1, 0, 4, 7)
+#endif
+#ifdef HAS_I422ALPHATOARGBROW_LASX
+ANY41C(I422AlphaToARGBRow_Any_LASX, I422AlphaToARGBRow_LASX, 1, 0, 4, 15)
+#endif
+#undef ANY41C
+
+// Any 4 planes to 1 plane of 8 bit with yuvconstants
+#define ANY41CT(NAMEANY, ANY_SIMD, UVSHIFT, DUVSHIFT, T, SBPP, BPP, MASK)      \
+  void NAMEANY(const T* y_buf, const T* u_buf, const T* v_buf, const T* a_buf, \
+               uint8_t* dst_ptr, const struct YuvConstants* yuvconstants,      \
+               int width) {                                                    \
+    SIMD_ALIGNED(T temp[16 * 4]);                                              \
+    SIMD_ALIGNED(uint8_t out[64]);                                             \
+    memset(temp, 0, 16 * 4 * SBPP); /* for YUY2 and msan */                    \
+    int r = width & MASK;                                                      \
+    int n = width & ~MASK;                                                     \
+    if (n > 0) {                                                               \
+      ANY_SIMD(y_buf, u_buf, v_buf, a_buf, dst_ptr, yuvconstants, n);          \
+    }                                                                          \
+    memcpy(temp, y_buf + n, r * SBPP);                                         \
+    memcpy(temp + 16, u_buf + (n >> UVSHIFT), SS(r, UVSHIFT) * SBPP);          \
+    memcpy(temp + 32, v_buf + (n >> UVSHIFT), SS(r, UVSHIFT) * SBPP);          \
+    memcpy(temp + 48, a_buf + n, r * SBPP);                                    \
+    ANY_SIMD(temp, temp + 16, temp + 32, temp + 48, out, yuvconstants,         \
+             MASK + 1);                                                        \
+    memcpy(dst_ptr + (n >> DUVSHIFT) * BPP, out, SS(r, DUVSHIFT) * BPP);       \
+  }
+
+#ifdef HAS_I210ALPHATOARGBROW_SSSE3
+ANY41CT(I210AlphaToARGBRow_Any_SSSE3,
+        I210AlphaToARGBRow_SSSE3,
+        1,
+        0,
+        uint16_t,
+        2,
+        4,
+        7)
+#endif
+
+#ifdef HAS_I210ALPHATOARGBROW_AVX2
+ANY41CT(I210AlphaToARGBRow_Any_AVX2,
+        I210AlphaToARGBRow_AVX2,
+        1,
+        0,
+        uint16_t,
+        2,
+        4,
+        15)
+#endif
+
+#ifdef HAS_I410ALPHATOARGBROW_SSSE3
+ANY41CT(I410AlphaToARGBRow_Any_SSSE3,
+        I410AlphaToARGBRow_SSSE3,
+        0,
+        0,
+        uint16_t,
+        2,
+        4,
+        7)
+#endif
+
+#ifdef HAS_I410ALPHATOARGBROW_AVX2
+ANY41CT(I410AlphaToARGBRow_Any_AVX2,
+        I410AlphaToARGBRow_AVX2,
+        0,
+        0,
+        uint16_t,
+        2,
+        4,
+        15)
+#endif
+
+#undef ANY41CT
+
+// Any 4 planes to 1 plane with parameter
+#define ANY41PT(NAMEANY, ANY_SIMD, STYPE, SBPP, DTYPE, BPP, MASK)          \
+  void NAMEANY(const STYPE* r_buf, const STYPE* g_buf, const STYPE* b_buf, \
+               const STYPE* a_buf, DTYPE* dst_ptr, int depth, int width) { \
+    SIMD_ALIGNED(STYPE temp[16 * 4]);                                      \
+    SIMD_ALIGNED(DTYPE out[64]);                                           \
+    memset(temp, 0, 16 * 4 * SBPP); /* for YUY2 and msan */                \
+    int r = width & MASK;                                                  \
+    int n = width & ~MASK;                                                 \
+    if (n > 0) {                                                           \
+      ANY_SIMD(r_buf, g_buf, b_buf, a_buf, dst_ptr, depth, n);             \
+    }                                                                      \
+    memcpy(temp, r_buf + n, r * SBPP);                                     \
+    memcpy(temp + 16, g_buf + n, r * SBPP);                                \
+    memcpy(temp + 32, b_buf + n, r * SBPP);                                \
+    memcpy(temp + 48, a_buf + n, r * SBPP);                                \
+    ANY_SIMD(temp, temp + 16, temp + 32, temp + 48, out, depth, MASK + 1); \
+    memcpy((uint8_t*)dst_ptr + n * BPP, out, r * BPP);                     \
+  }
+
+#ifdef HAS_MERGEAR64ROW_AVX2
+ANY41PT(MergeAR64Row_Any_AVX2, MergeAR64Row_AVX2, uint16_t, 2, uint16_t, 8, 15)
+#endif
+
+#ifdef HAS_MERGEAR64ROW_NEON
+ANY41PT(MergeAR64Row_Any_NEON, MergeAR64Row_NEON, uint16_t, 2, uint16_t, 8, 7)
+#endif
+
+#ifdef HAS_MERGEARGB16TO8ROW_AVX2
+ANY41PT(MergeARGB16To8Row_Any_AVX2,
+        MergeARGB16To8Row_AVX2,
+        uint16_t,
+        2,
+        uint8_t,
+        4,
+        15)
+#endif
+
+#ifdef HAS_MERGEARGB16TO8ROW_NEON
+ANY41PT(MergeARGB16To8Row_Any_NEON,
+        MergeARGB16To8Row_NEON,
+        uint16_t,
+        2,
+        uint8_t,
+        4,
+        7)
+#endif
+
+#undef ANY41PT
+
+// Any 3 planes to 1.
+#define ANY31(NAMEANY, ANY_SIMD, UVSHIFT, DUVSHIFT, BPP, MASK)      \
+  void NAMEANY(const uint8_t* y_buf, const uint8_t* u_buf,          \
+               const uint8_t* v_buf, uint8_t* dst_ptr, int width) { \
+    SIMD_ALIGNED(uint8_t temp[64 * 4]);                             \
+    memset(temp, 0, 64 * 3); /* for YUY2 and msan */                \
+    int r = width & MASK;                                           \
+    int n = width & ~MASK;                                          \
+    if (n > 0) {                                                    \
+      ANY_SIMD(y_buf, u_buf, v_buf, dst_ptr, n);                    \
+    }                                                               \
+    memcpy(temp, y_buf + n, r);                                     \
+    memcpy(temp + 64, u_buf + (n >> UVSHIFT), SS(r, UVSHIFT));      \
+    memcpy(temp + 128, v_buf + (n >> UVSHIFT), SS(r, UVSHIFT));     \
+    ANY_SIMD(temp, temp + 64, temp + 128, temp + 192, MASK + 1);    \
+    memcpy(dst_ptr + (n >> DUVSHIFT) * BPP, temp + 192,             \
+           SS(r, DUVSHIFT) * BPP);                                  \
+  }
+
+// Merge functions.
+#ifdef HAS_MERGERGBROW_SSSE3
+ANY31(MergeRGBRow_Any_SSSE3, MergeRGBRow_SSSE3, 0, 0, 3, 15)
+#endif
+#ifdef HAS_MERGERGBROW_NEON
+ANY31(MergeRGBRow_Any_NEON, MergeRGBRow_NEON, 0, 0, 3, 15)
+#endif
+#ifdef HAS_MERGEXRGBROW_SSE2
+ANY31(MergeXRGBRow_Any_SSE2, MergeXRGBRow_SSE2, 0, 0, 4, 7)
+#endif
+#ifdef HAS_MERGEXRGBROW_AVX2
+ANY31(MergeXRGBRow_Any_AVX2, MergeXRGBRow_AVX2, 0, 0, 4, 15)
+#endif
+#ifdef HAS_MERGEXRGBROW_NEON
+ANY31(MergeXRGBRow_Any_NEON, MergeXRGBRow_NEON, 0, 0, 4, 15)
+#endif
+#ifdef HAS_I422TOYUY2ROW_SSE2
+ANY31(I422ToYUY2Row_Any_SSE2, I422ToYUY2Row_SSE2, 1, 1, 4, 15)
+ANY31(I422ToUYVYRow_Any_SSE2, I422ToUYVYRow_SSE2, 1, 1, 4, 15)
+#endif
+#ifdef HAS_I422TOYUY2ROW_AVX2
+ANY31(I422ToYUY2Row_Any_AVX2, I422ToYUY2Row_AVX2, 1, 1, 4, 31)
+ANY31(I422ToUYVYRow_Any_AVX2, I422ToUYVYRow_AVX2, 1, 1, 4, 31)
+#endif
+#ifdef HAS_I422TOYUY2ROW_NEON
+ANY31(I422ToYUY2Row_Any_NEON, I422ToYUY2Row_NEON, 1, 1, 4, 15)
+#endif
+#ifdef HAS_I422TOYUY2ROW_MSA
+ANY31(I422ToYUY2Row_Any_MSA, I422ToYUY2Row_MSA, 1, 1, 4, 31)
+#endif
+#ifdef HAS_I422TOYUY2ROW_LASX
+ANY31(I422ToYUY2Row_Any_LASX, I422ToYUY2Row_LASX, 1, 1, 4, 31)
+#endif
+#ifdef HAS_I422TOUYVYROW_NEON
+ANY31(I422ToUYVYRow_Any_NEON, I422ToUYVYRow_NEON, 1, 1, 4, 15)
+#endif
+#ifdef HAS_I422TOUYVYROW_MSA
+ANY31(I422ToUYVYRow_Any_MSA, I422ToUYVYRow_MSA, 1, 1, 4, 31)
+#endif
+#ifdef HAS_I422TOUYVYROW_LASX
+ANY31(I422ToUYVYRow_Any_LASX, I422ToUYVYRow_LASX, 1, 1, 4, 31)
+#endif
+#ifdef HAS_BLENDPLANEROW_AVX2
+ANY31(BlendPlaneRow_Any_AVX2, BlendPlaneRow_AVX2, 0, 0, 1, 31)
+#endif
+#ifdef HAS_BLENDPLANEROW_SSSE3
+ANY31(BlendPlaneRow_Any_SSSE3, BlendPlaneRow_SSSE3, 0, 0, 1, 7)
+#endif
+#undef ANY31
+
+// Note that odd width replication includes 444 due to implementation
+// on arm that subsamples 444 to 422 internally.
+// Any 3 planes to 1 with yuvconstants
+#define ANY31C(NAMEANY, ANY_SIMD, UVSHIFT, DUVSHIFT, BPP, MASK)      \
+  void NAMEANY(const uint8_t* y_buf, const uint8_t* u_buf,           \
+               const uint8_t* v_buf, uint8_t* dst_ptr,               \
+               const struct YuvConstants* yuvconstants, int width) { \
+    SIMD_ALIGNED(uint8_t temp[128 * 4]);                             \
+    memset(temp, 0, 128 * 3); /* for YUY2 and msan */                \
+    int r = width & MASK;                                            \
+    int n = width & ~MASK;                                           \
+    if (n > 0) {                                                     \
+      ANY_SIMD(y_buf, u_buf, v_buf, dst_ptr, yuvconstants, n);       \
+    }                                                                \
+    memcpy(temp, y_buf + n, r);                                      \
+    memcpy(temp + 128, u_buf + (n >> UVSHIFT), SS(r, UVSHIFT));      \
+    memcpy(temp + 256, v_buf + (n >> UVSHIFT), SS(r, UVSHIFT));      \
+    if (width & 1) {                                                 \
+      temp[128 + SS(r, UVSHIFT)] = temp[128 + SS(r, UVSHIFT) - 1];   \
+      temp[256 + SS(r, UVSHIFT)] = temp[256 + SS(r, UVSHIFT) - 1];   \
+    }                                                                \
+    ANY_SIMD(temp, temp + 128, temp + 256, temp + 384, yuvconstants, \
+             MASK + 1);                                              \
+    memcpy(dst_ptr + (n >> DUVSHIFT) * BPP, temp + 384,              \
+           SS(r, DUVSHIFT) * BPP);                                   \
+  }
+
+#ifdef HAS_I422TOARGBROW_SSSE3
+ANY31C(I422ToARGBRow_Any_SSSE3, I422ToARGBRow_SSSE3, 1, 0, 4, 7)
+#endif
+#ifdef HAS_I422TORGBAROW_SSSE3
+ANY31C(I422ToRGBARow_Any_SSSE3, I422ToRGBARow_SSSE3, 1, 0, 4, 7)
+#endif
+#ifdef HAS_I422TOARGB4444ROW_SSSE3
+ANY31C(I422ToARGB4444Row_Any_SSSE3, I422ToARGB4444Row_SSSE3, 1, 0, 2, 7)
+#endif
+#ifdef HAS_I422TOARGB1555ROW_SSSE3
+ANY31C(I422ToARGB1555Row_Any_SSSE3, I422ToARGB1555Row_SSSE3, 1, 0, 2, 7)
+#endif
+#ifdef HAS_I422TORGB565ROW_SSSE3
+ANY31C(I422ToRGB565Row_Any_SSSE3, I422ToRGB565Row_SSSE3, 1, 0, 2, 7)
+#endif
+#ifdef HAS_I422TORGB24ROW_SSSE3
+ANY31C(I422ToRGB24Row_Any_SSSE3, I422ToRGB24Row_SSSE3, 1, 0, 3, 15)
+#endif
+#ifdef HAS_I422TOAR30ROW_SSSE3
+ANY31C(I422ToAR30Row_Any_SSSE3, I422ToAR30Row_SSSE3, 1, 0, 4, 7)
+#endif
+#ifdef HAS_I422TOAR30ROW_AVX2
+ANY31C(I422ToAR30Row_Any_AVX2, I422ToAR30Row_AVX2, 1, 0, 4, 15)
+#endif
+#ifdef HAS_I444TOARGBROW_SSSE3
+ANY31C(I444ToARGBRow_Any_SSSE3, I444ToARGBRow_SSSE3, 0, 0, 4, 7)
+#endif
+#ifdef HAS_I422TORGB24ROW_AVX2
+ANY31C(I422ToRGB24Row_Any_AVX2, I422ToRGB24Row_AVX2, 1, 0, 3, 31)
+#endif
+#ifdef HAS_I422TOARGBROW_AVX2
+ANY31C(I422ToARGBRow_Any_AVX2, I422ToARGBRow_AVX2, 1, 0, 4, 15)
+#endif
+#ifdef HAS_I422TOARGBROW_AVX512BW
+ANY31C(I422ToARGBRow_Any_AVX512BW, I422ToARGBRow_AVX512BW, 1, 0, 4, 31)
+#endif
+#ifdef HAS_I422TORGBAROW_AVX2
+ANY31C(I422ToRGBARow_Any_AVX2, I422ToRGBARow_AVX2, 1, 0, 4, 15)
+#endif
+#ifdef HAS_I444TOARGBROW_AVX2
+ANY31C(I444ToARGBRow_Any_AVX2, I444ToARGBRow_AVX2, 0, 0, 4, 15)
+#endif
+#ifdef HAS_I422TOARGB4444ROW_AVX2
+ANY31C(I422ToARGB4444Row_Any_AVX2, I422ToARGB4444Row_AVX2, 1, 0, 2, 15)
+#endif
+#ifdef HAS_I422TOARGB1555ROW_AVX2
+ANY31C(I422ToARGB1555Row_Any_AVX2, I422ToARGB1555Row_AVX2, 1, 0, 2, 15)
+#endif
+#ifdef HAS_I422TORGB565ROW_AVX2
+ANY31C(I422ToRGB565Row_Any_AVX2, I422ToRGB565Row_AVX2, 1, 0, 2, 15)
+#endif
+#ifdef HAS_I422TOARGBROW_NEON
+ANY31C(I444ToARGBRow_Any_NEON, I444ToARGBRow_NEON, 0, 0, 4, 7)
+ANY31C(I422ToARGBRow_Any_NEON, I422ToARGBRow_NEON, 1, 0, 4, 7)
+ANY31C(I422ToRGBARow_Any_NEON, I422ToRGBARow_NEON, 1, 0, 4, 7)
+ANY31C(I422ToRGB24Row_Any_NEON, I422ToRGB24Row_NEON, 1, 0, 3, 7)
+ANY31C(I422ToARGB4444Row_Any_NEON, I422ToARGB4444Row_NEON, 1, 0, 2, 7)
+ANY31C(I422ToARGB1555Row_Any_NEON, I422ToARGB1555Row_NEON, 1, 0, 2, 7)
+ANY31C(I422ToRGB565Row_Any_NEON, I422ToRGB565Row_NEON, 1, 0, 2, 7)
+#endif
+#ifdef HAS_I422TOARGBROW_MSA
+ANY31C(I444ToARGBRow_Any_MSA, I444ToARGBRow_MSA, 0, 0, 4, 7)
+ANY31C(I422ToARGBRow_Any_MSA, I422ToARGBRow_MSA, 1, 0, 4, 7)
+ANY31C(I422ToRGBARow_Any_MSA, I422ToRGBARow_MSA, 1, 0, 4, 7)
+ANY31C(I422ToRGB24Row_Any_MSA, I422ToRGB24Row_MSA, 1, 0, 3, 15)
+ANY31C(I422ToARGB4444Row_Any_MSA, I422ToARGB4444Row_MSA, 1, 0, 2, 7)
+ANY31C(I422ToARGB1555Row_Any_MSA, I422ToARGB1555Row_MSA, 1, 0, 2, 7)
+ANY31C(I422ToRGB565Row_Any_MSA, I422ToRGB565Row_MSA, 1, 0, 2, 7)
+#endif
+#ifdef HAS_I422TOARGBROW_LASX
+ANY31C(I422ToARGBRow_Any_LASX, I422ToARGBRow_LASX, 1, 0, 4, 31)
+ANY31C(I422ToRGBARow_Any_LASX, I422ToRGBARow_LASX, 1, 0, 4, 31)
+ANY31C(I422ToRGB24Row_Any_LASX, I422ToRGB24Row_LASX, 1, 0, 3, 31)
+ANY31C(I422ToRGB565Row_Any_LASX, I422ToRGB565Row_LASX, 1, 0, 2, 31)
+ANY31C(I422ToARGB4444Row_Any_LASX, I422ToARGB4444Row_LASX, 1, 0, 2, 31)
+ANY31C(I422ToARGB1555Row_Any_LASX, I422ToARGB1555Row_LASX, 1, 0, 2, 31)
+#endif
+#ifdef HAS_I444TOARGBROW_LSX
+ANY31C(I444ToARGBRow_Any_LSX, I444ToARGBRow_LSX, 0, 0, 4, 15)
+#endif
+#undef ANY31C
+
+// Any 3 planes of 16 bit to 1 with yuvconstants
+// TODO(fbarchard): consider sharing this code with ANY31C
+#define ANY31CT(NAMEANY, ANY_SIMD, UVSHIFT, DUVSHIFT, T, SBPP, BPP, MASK) \
+  void NAMEANY(const T* y_buf, const T* u_buf, const T* v_buf,            \
+               uint8_t* dst_ptr, const struct YuvConstants* yuvconstants, \
+               int width) {                                               \
+    SIMD_ALIGNED(T temp[16 * 3]);                                         \
+    SIMD_ALIGNED(uint8_t out[64]);                                        \
+    memset(temp, 0, 16 * 3 * SBPP); /* for YUY2 and msan */               \
+    int r = width & MASK;                                                 \
+    int n = width & ~MASK;                                                \
+    if (n > 0) {                                                          \
+      ANY_SIMD(y_buf, u_buf, v_buf, dst_ptr, yuvconstants, n);            \
+    }                                                                     \
+    memcpy(temp, y_buf + n, r * SBPP);                                    \
+    memcpy(temp + 16, u_buf + (n >> UVSHIFT), SS(r, UVSHIFT) * SBPP);     \
+    memcpy(temp + 32, v_buf + (n >> UVSHIFT), SS(r, UVSHIFT) * SBPP);     \
+    ANY_SIMD(temp, temp + 16, temp + 32, out, yuvconstants, MASK + 1);    \
+    memcpy(dst_ptr + (n >> DUVSHIFT) * BPP, out, SS(r, DUVSHIFT) * BPP);  \
+  }
+
+#ifdef HAS_I210TOAR30ROW_SSSE3
+ANY31CT(I210ToAR30Row_Any_SSSE3, I210ToAR30Row_SSSE3, 1, 0, uint16_t, 2, 4, 7)
+#endif
+#ifdef HAS_I210TOARGBROW_SSSE3
+ANY31CT(I210ToARGBRow_Any_SSSE3, I210ToARGBRow_SSSE3, 1, 0, uint16_t, 2, 4, 7)
+#endif
+#ifdef HAS_I210TOARGBROW_AVX2
+ANY31CT(I210ToARGBRow_Any_AVX2, I210ToARGBRow_AVX2, 1, 0, uint16_t, 2, 4, 15)
+#endif
+#ifdef HAS_I210TOAR30ROW_AVX2
+ANY31CT(I210ToAR30Row_Any_AVX2, I210ToAR30Row_AVX2, 1, 0, uint16_t, 2, 4, 15)
+#endif
+#ifdef HAS_I410TOAR30ROW_SSSE3
+ANY31CT(I410ToAR30Row_Any_SSSE3, I410ToAR30Row_SSSE3, 0, 0, uint16_t, 2, 4, 7)
+#endif
+#ifdef HAS_I410TOARGBROW_SSSE3
+ANY31CT(I410ToARGBRow_Any_SSSE3, I410ToARGBRow_SSSE3, 0, 0, uint16_t, 2, 4, 7)
+#endif
+#ifdef HAS_I410TOARGBROW_AVX2
+ANY31CT(I410ToARGBRow_Any_AVX2, I410ToARGBRow_AVX2, 0, 0, uint16_t, 2, 4, 15)
+#endif
+#ifdef HAS_I410TOAR30ROW_AVX2
+ANY31CT(I410ToAR30Row_Any_AVX2, I410ToAR30Row_AVX2, 0, 0, uint16_t, 2, 4, 15)
+#endif
+#ifdef HAS_I212TOAR30ROW_SSSE3
+ANY31CT(I212ToAR30Row_Any_SSSE3, I212ToAR30Row_SSSE3, 1, 0, uint16_t, 2, 4, 7)
+#endif
+#ifdef HAS_I212TOARGBROW_SSSE3
+ANY31CT(I212ToARGBRow_Any_SSSE3, I212ToARGBRow_SSSE3, 1, 0, uint16_t, 2, 4, 7)
+#endif
+#ifdef HAS_I212TOARGBROW_AVX2
+ANY31CT(I212ToARGBRow_Any_AVX2, I212ToARGBRow_AVX2, 1, 0, uint16_t, 2, 4, 15)
+#endif
+#ifdef HAS_I212TOAR30ROW_AVX2
+ANY31CT(I212ToAR30Row_Any_AVX2, I212ToAR30Row_AVX2, 1, 0, uint16_t, 2, 4, 15)
+#endif
+#undef ANY31CT
+
+// Any 3 planes to 1 plane with parameter
+#define ANY31PT(NAMEANY, ANY_SIMD, STYPE, SBPP, DTYPE, BPP, MASK)          \
+  void NAMEANY(const STYPE* r_buf, const STYPE* g_buf, const STYPE* b_buf, \
+               DTYPE* dst_ptr, int depth, int width) {                     \
+    SIMD_ALIGNED(STYPE temp[16 * 3]);                                      \
+    SIMD_ALIGNED(DTYPE out[64]);                                           \
+    memset(temp, 0, 16 * 3 * SBPP); /* for YUY2 and msan */                \
+    int r = width & MASK;                                                  \
+    int n = width & ~MASK;                                                 \
+    if (n > 0) {                                                           \
+      ANY_SIMD(r_buf, g_buf, b_buf, dst_ptr, depth, n);                    \
+    }                                                                      \
+    memcpy(temp, r_buf + n, r * SBPP);                                     \
+    memcpy(temp + 16, g_buf + n, r * SBPP);                                \
+    memcpy(temp + 32, b_buf + n, r * SBPP);                                \
+    ANY_SIMD(temp, temp + 16, temp + 32, out, depth, MASK + 1);            \
+    memcpy((uint8_t*)dst_ptr + n * BPP, out, r * BPP);                     \
+  }
+
+#ifdef HAS_MERGEXR30ROW_AVX2
+ANY31PT(MergeXR30Row_Any_AVX2, MergeXR30Row_AVX2, uint16_t, 2, uint8_t, 4, 15)
+#endif
+
+#ifdef HAS_MERGEXR30ROW_NEON
+ANY31PT(MergeXR30Row_Any_NEON, MergeXR30Row_NEON, uint16_t, 2, uint8_t, 4, 3)
+ANY31PT(MergeXR30Row_10_Any_NEON,
+        MergeXR30Row_10_NEON,
+        uint16_t,
+        2,
+        uint8_t,
+        4,
+        3)
+#endif
+
+#ifdef HAS_MERGEXR64ROW_AVX2
+ANY31PT(MergeXR64Row_Any_AVX2, MergeXR64Row_AVX2, uint16_t, 2, uint16_t, 8, 15)
+#endif
+
+#ifdef HAS_MERGEXR64ROW_NEON
+ANY31PT(MergeXR64Row_Any_NEON, MergeXR64Row_NEON, uint16_t, 2, uint16_t, 8, 7)
+#endif
+
+#ifdef HAS_MERGEXRGB16TO8ROW_AVX2
+ANY31PT(MergeXRGB16To8Row_Any_AVX2,
+        MergeXRGB16To8Row_AVX2,
+        uint16_t,
+        2,
+        uint8_t,
+        4,
+        15)
+#endif
+
+#ifdef HAS_MERGEXRGB16TO8ROW_NEON
+ANY31PT(MergeXRGB16To8Row_Any_NEON,
+        MergeXRGB16To8Row_NEON,
+        uint16_t,
+        2,
+        uint8_t,
+        4,
+        7)
+#endif
+
+#undef ANY31PT
+
+// Any 2 planes to 1.
+#define ANY21(NAMEANY, ANY_SIMD, UVSHIFT, SBPP, SBPP2, BPP, MASK)             \
+  void NAMEANY(const uint8_t* y_buf, const uint8_t* uv_buf, uint8_t* dst_ptr, \
+               int width) {                                                   \
+    SIMD_ALIGNED(uint8_t temp[128 * 3]);                                      \
+    memset(temp, 0, 128 * 2); /* for msan */                                  \
+    int r = width & MASK;                                                     \
+    int n = width & ~MASK;                                                    \
+    if (n > 0) {                                                              \
+      ANY_SIMD(y_buf, uv_buf, dst_ptr, n);                                    \
+    }                                                                         \
+    memcpy(temp, y_buf + n * SBPP, r * SBPP);                                 \
+    memcpy(temp + 128, uv_buf + (n >> UVSHIFT) * SBPP2,                       \
+           SS(r, UVSHIFT) * SBPP2);                                           \
+    ANY_SIMD(temp, temp + 128, temp + 256, MASK + 1);                         \
+    memcpy(dst_ptr + n * BPP, temp + 256, r * BPP);                           \
+  }
+
+// Merge functions.
+#ifdef HAS_MERGEUVROW_SSE2
+ANY21(MergeUVRow_Any_SSE2, MergeUVRow_SSE2, 0, 1, 1, 2, 15)
+#endif
+#ifdef HAS_MERGEUVROW_AVX2
+ANY21(MergeUVRow_Any_AVX2, MergeUVRow_AVX2, 0, 1, 1, 2, 31)
+#endif
+#ifdef HAS_MERGEUVROW_NEON
+ANY21(MergeUVRow_Any_NEON, MergeUVRow_NEON, 0, 1, 1, 2, 15)
+#endif
+#ifdef HAS_MERGEUVROW_MSA
+ANY21(MergeUVRow_Any_MSA, MergeUVRow_MSA, 0, 1, 1, 2, 15)
+#endif
+#ifdef HAS_MERGEUVROW_LSX
+ANY21(MergeUVRow_Any_LSX, MergeUVRow_LSX, 0, 1, 1, 2, 15)
+#endif
+#ifdef HAS_NV21TOYUV24ROW_NEON
+ANY21(NV21ToYUV24Row_Any_NEON, NV21ToYUV24Row_NEON, 1, 1, 2, 3, 15)
+#endif
+#ifdef HAS_NV21TOYUV24ROW_SSSE3
+ANY21(NV21ToYUV24Row_Any_SSSE3, NV21ToYUV24Row_SSSE3, 1, 1, 2, 3, 15)
+#endif
+#ifdef HAS_NV21TOYUV24ROW_AVX2
+ANY21(NV21ToYUV24Row_Any_AVX2, NV21ToYUV24Row_AVX2, 1, 1, 2, 3, 31)
+#endif
+// Math functions.
+#ifdef HAS_ARGBMULTIPLYROW_SSE2
+ANY21(ARGBMultiplyRow_Any_SSE2, ARGBMultiplyRow_SSE2, 0, 4, 4, 4, 3)
+#endif
+#ifdef HAS_ARGBADDROW_SSE2
+ANY21(ARGBAddRow_Any_SSE2, ARGBAddRow_SSE2, 0, 4, 4, 4, 3)
+#endif
+#ifdef HAS_ARGBSUBTRACTROW_SSE2
+ANY21(ARGBSubtractRow_Any_SSE2, ARGBSubtractRow_SSE2, 0, 4, 4, 4, 3)
+#endif
+#ifdef HAS_ARGBMULTIPLYROW_AVX2
+ANY21(ARGBMultiplyRow_Any_AVX2, ARGBMultiplyRow_AVX2, 0, 4, 4, 4, 7)
+#endif
+#ifdef HAS_ARGBADDROW_AVX2
+ANY21(ARGBAddRow_Any_AVX2, ARGBAddRow_AVX2, 0, 4, 4, 4, 7)
+#endif
+#ifdef HAS_ARGBSUBTRACTROW_AVX2
+ANY21(ARGBSubtractRow_Any_AVX2, ARGBSubtractRow_AVX2, 0, 4, 4, 4, 7)
+#endif
+#ifdef HAS_ARGBMULTIPLYROW_NEON
+ANY21(ARGBMultiplyRow_Any_NEON, ARGBMultiplyRow_NEON, 0, 4, 4, 4, 7)
+#endif
+#ifdef HAS_ARGBADDROW_NEON
+ANY21(ARGBAddRow_Any_NEON, ARGBAddRow_NEON, 0, 4, 4, 4, 7)
+#endif
+#ifdef HAS_ARGBSUBTRACTROW_NEON
+ANY21(ARGBSubtractRow_Any_NEON, ARGBSubtractRow_NEON, 0, 4, 4, 4, 7)
+#endif
+#ifdef HAS_ARGBMULTIPLYROW_MSA
+ANY21(ARGBMultiplyRow_Any_MSA, ARGBMultiplyRow_MSA, 0, 4, 4, 4, 3)
+#endif
+#ifdef HAS_ARGBMULTIPLYROW_LASX
+ANY21(ARGBMultiplyRow_Any_LASX, ARGBMultiplyRow_LASX, 0, 4, 4, 4, 7)
+#endif
+#ifdef HAS_ARGBADDROW_MSA
+ANY21(ARGBAddRow_Any_MSA, ARGBAddRow_MSA, 0, 4, 4, 4, 7)
+#endif
+#ifdef HAS_ARGBADDROW_LASX
+ANY21(ARGBAddRow_Any_LASX, ARGBAddRow_LASX, 0, 4, 4, 4, 7)
+#endif
+#ifdef HAS_ARGBSUBTRACTROW_MSA
+ANY21(ARGBSubtractRow_Any_MSA, ARGBSubtractRow_MSA, 0, 4, 4, 4, 7)
+#endif
+#ifdef HAS_ARGBSUBTRACTROW_LASX
+ANY21(ARGBSubtractRow_Any_LASX, ARGBSubtractRow_LASX, 0, 4, 4, 4, 7)
+#endif
+#ifdef HAS_SOBELROW_SSE2
+ANY21(SobelRow_Any_SSE2, SobelRow_SSE2, 0, 1, 1, 4, 15)
+#endif
+#ifdef HAS_SOBELROW_NEON
+ANY21(SobelRow_Any_NEON, SobelRow_NEON, 0, 1, 1, 4, 7)
+#endif
+#ifdef HAS_SOBELROW_MSA
+ANY21(SobelRow_Any_MSA, SobelRow_MSA, 0, 1, 1, 4, 15)
+#endif
+#ifdef HAS_SOBELROW_LSX
+ANY21(SobelRow_Any_LSX, SobelRow_LSX, 0, 1, 1, 4, 15)
+#endif
+#ifdef HAS_SOBELTOPLANEROW_SSE2
+ANY21(SobelToPlaneRow_Any_SSE2, SobelToPlaneRow_SSE2, 0, 1, 1, 1, 15)
+#endif
+#ifdef HAS_SOBELTOPLANEROW_NEON
+ANY21(SobelToPlaneRow_Any_NEON, SobelToPlaneRow_NEON, 0, 1, 1, 1, 15)
+#endif
+#ifdef HAS_SOBELTOPLANEROW_MSA
+ANY21(SobelToPlaneRow_Any_MSA, SobelToPlaneRow_MSA, 0, 1, 1, 1, 31)
+#endif
+#ifdef HAS_SOBELTOPLANEROW_LSX
+ANY21(SobelToPlaneRow_Any_LSX, SobelToPlaneRow_LSX, 0, 1, 1, 1, 31)
+#endif
+#ifdef HAS_SOBELXYROW_SSE2
+ANY21(SobelXYRow_Any_SSE2, SobelXYRow_SSE2, 0, 1, 1, 4, 15)
+#endif
+#ifdef HAS_SOBELXYROW_NEON
+ANY21(SobelXYRow_Any_NEON, SobelXYRow_NEON, 0, 1, 1, 4, 7)
+#endif
+#ifdef HAS_SOBELXYROW_MSA
+ANY21(SobelXYRow_Any_MSA, SobelXYRow_MSA, 0, 1, 1, 4, 15)
+#endif
+#ifdef HAS_SOBELXYROW_LSX
+ANY21(SobelXYRow_Any_LSX, SobelXYRow_LSX, 0, 1, 1, 4, 15)
+#endif
+#undef ANY21
+
+// Any 2 planes to 1 with yuvconstants
+#define ANY21C(NAMEANY, ANY_SIMD, UVSHIFT, SBPP, SBPP2, BPP, MASK)            \
+  void NAMEANY(const uint8_t* y_buf, const uint8_t* uv_buf, uint8_t* dst_ptr, \
+               const struct YuvConstants* yuvconstants, int width) {          \
+    SIMD_ALIGNED(uint8_t temp[128 * 3]);                                      \
+    memset(temp, 0, 128 * 2); /* for msan */                                  \
+    int r = width & MASK;                                                     \
+    int n = width & ~MASK;                                                    \
+    if (n > 0) {                                                              \
+      ANY_SIMD(y_buf, uv_buf, dst_ptr, yuvconstants, n);                      \
+    }                                                                         \
+    memcpy(temp, y_buf + n * SBPP, r * SBPP);                                 \
+    memcpy(temp + 128, uv_buf + (n >> UVSHIFT) * SBPP2,                       \
+           SS(r, UVSHIFT) * SBPP2);                                           \
+    ANY_SIMD(temp, temp + 128, temp + 256, yuvconstants, MASK + 1);           \
+    memcpy(dst_ptr + n * BPP, temp + 256, r * BPP);                           \
+  }
+
+// Biplanar to RGB.
+#ifdef HAS_NV12TOARGBROW_SSSE3
+ANY21C(NV12ToARGBRow_Any_SSSE3, NV12ToARGBRow_SSSE3, 1, 1, 2, 4, 7)
+#endif
+#ifdef HAS_NV12TOARGBROW_AVX2
+ANY21C(NV12ToARGBRow_Any_AVX2, NV12ToARGBRow_AVX2, 1, 1, 2, 4, 15)
+#endif
+#ifdef HAS_NV12TOARGBROW_NEON
+ANY21C(NV12ToARGBRow_Any_NEON, NV12ToARGBRow_NEON, 1, 1, 2, 4, 7)
+#endif
+#ifdef HAS_NV12TOARGBROW_MSA
+ANY21C(NV12ToARGBRow_Any_MSA, NV12ToARGBRow_MSA, 1, 1, 2, 4, 7)
+#endif
+#ifdef HAS_NV12TOARGBROW_LSX
+ANY21C(NV12ToARGBRow_Any_LSX, NV12ToARGBRow_LSX, 1, 1, 2, 4, 7)
+#endif
+#ifdef HAS_NV12TOARGBROW_LASX
+ANY21C(NV12ToARGBRow_Any_LASX, NV12ToARGBRow_LASX, 1, 1, 2, 4, 15)
+#endif
+#ifdef HAS_NV21TOARGBROW_SSSE3
+ANY21C(NV21ToARGBRow_Any_SSSE3, NV21ToARGBRow_SSSE3, 1, 1, 2, 4, 7)
+#endif
+#ifdef HAS_NV21TOARGBROW_AVX2
+ANY21C(NV21ToARGBRow_Any_AVX2, NV21ToARGBRow_AVX2, 1, 1, 2, 4, 15)
+#endif
+#ifdef HAS_NV21TOARGBROW_NEON
+ANY21C(NV21ToARGBRow_Any_NEON, NV21ToARGBRow_NEON, 1, 1, 2, 4, 7)
+#endif
+#ifdef HAS_NV21TOARGBROW_MSA
+ANY21C(NV21ToARGBRow_Any_MSA, NV21ToARGBRow_MSA, 1, 1, 2, 4, 7)
+#endif
+#ifdef HAS_NV21TOARGBROW_LSX
+ANY21C(NV21ToARGBRow_Any_LSX, NV21ToARGBRow_LSX, 1, 1, 2, 4, 7)
+#endif
+#ifdef HAS_NV21TOARGBROW_LASX
+ANY21C(NV21ToARGBRow_Any_LASX, NV21ToARGBRow_LASX, 1, 1, 2, 4, 15)
+#endif
+#ifdef HAS_NV12TORGB24ROW_NEON
+ANY21C(NV12ToRGB24Row_Any_NEON, NV12ToRGB24Row_NEON, 1, 1, 2, 3, 7)
+#endif
+#ifdef HAS_NV21TORGB24ROW_NEON
+ANY21C(NV21ToRGB24Row_Any_NEON, NV21ToRGB24Row_NEON, 1, 1, 2, 3, 7)
+#endif
+#ifdef HAS_NV12TORGB24ROW_SSSE3
+ANY21C(NV12ToRGB24Row_Any_SSSE3, NV12ToRGB24Row_SSSE3, 1, 1, 2, 3, 15)
+#endif
+#ifdef HAS_NV21TORGB24ROW_SSSE3
+ANY21C(NV21ToRGB24Row_Any_SSSE3, NV21ToRGB24Row_SSSE3, 1, 1, 2, 3, 15)
+#endif
+#ifdef HAS_NV12TORGB24ROW_AVX2
+ANY21C(NV12ToRGB24Row_Any_AVX2, NV12ToRGB24Row_AVX2, 1, 1, 2, 3, 31)
+#endif
+#ifdef HAS_NV21TORGB24ROW_AVX2
+ANY21C(NV21ToRGB24Row_Any_AVX2, NV21ToRGB24Row_AVX2, 1, 1, 2, 3, 31)
+#endif
+#ifdef HAS_NV12TORGB565ROW_SSSE3
+ANY21C(NV12ToRGB565Row_Any_SSSE3, NV12ToRGB565Row_SSSE3, 1, 1, 2, 2, 7)
+#endif
+#ifdef HAS_NV12TORGB565ROW_AVX2
+ANY21C(NV12ToRGB565Row_Any_AVX2, NV12ToRGB565Row_AVX2, 1, 1, 2, 2, 15)
+#endif
+#ifdef HAS_NV12TORGB565ROW_NEON
+ANY21C(NV12ToRGB565Row_Any_NEON, NV12ToRGB565Row_NEON, 1, 1, 2, 2, 7)
+#endif
+#ifdef HAS_NV12TORGB565ROW_MSA
+ANY21C(NV12ToRGB565Row_Any_MSA, NV12ToRGB565Row_MSA, 1, 1, 2, 2, 7)
+#endif
+#ifdef HAS_NV12TORGB565ROW_LSX
+ANY21C(NV12ToRGB565Row_Any_LSX, NV12ToRGB565Row_LSX, 1, 1, 2, 2, 7)
+#endif
+#ifdef HAS_NV12TORGB565ROW_LASX
+ANY21C(NV12ToRGB565Row_Any_LASX, NV12ToRGB565Row_LASX, 1, 1, 2, 2, 15)
+#endif
+#undef ANY21C
+
+// Any 2 planes of 16 bit to 1 with yuvconstants
+#define ANY21CT(NAMEANY, ANY_SIMD, UVSHIFT, DUVSHIFT, T, SBPP, BPP, MASK)      \
+  void NAMEANY(const T* y_buf, const T* uv_buf, uint8_t* dst_ptr,              \
+               const struct YuvConstants* yuvconstants, int width) {           \
+    SIMD_ALIGNED(T temp[16 * 3]);                                              \
+    SIMD_ALIGNED(uint8_t out[64]);                                             \
+    memset(temp, 0, 16 * 3 * SBPP); /* for YUY2 and msan */                    \
+    int r = width & MASK;                                                      \
+    int n = width & ~MASK;                                                     \
+    if (n > 0) {                                                               \
+      ANY_SIMD(y_buf, uv_buf, dst_ptr, yuvconstants, n);                       \
+    }                                                                          \
+    memcpy(temp, y_buf + n, r * SBPP);                                         \
+    memcpy(temp + 16, uv_buf + 2 * (n >> UVSHIFT), SS(r, UVSHIFT) * SBPP * 2); \
+    ANY_SIMD(temp, temp + 16, out, yuvconstants, MASK + 1);                    \
+    memcpy(dst_ptr + (n >> DUVSHIFT) * BPP, out, SS(r, DUVSHIFT) * BPP);       \
+  }
+
+#ifdef HAS_P210TOAR30ROW_SSSE3
+ANY21CT(P210ToAR30Row_Any_SSSE3, P210ToAR30Row_SSSE3, 1, 0, uint16_t, 2, 4, 7)
+#endif
+#ifdef HAS_P210TOARGBROW_SSSE3
+ANY21CT(P210ToARGBRow_Any_SSSE3, P210ToARGBRow_SSSE3, 1, 0, uint16_t, 2, 4, 7)
+#endif
+#ifdef HAS_P210TOARGBROW_AVX2
+ANY21CT(P210ToARGBRow_Any_AVX2, P210ToARGBRow_AVX2, 1, 0, uint16_t, 2, 4, 15)
+#endif
+#ifdef HAS_P210TOAR30ROW_AVX2
+ANY21CT(P210ToAR30Row_Any_AVX2, P210ToAR30Row_AVX2, 1, 0, uint16_t, 2, 4, 15)
+#endif
+#ifdef HAS_P410TOAR30ROW_SSSE3
+ANY21CT(P410ToAR30Row_Any_SSSE3, P410ToAR30Row_SSSE3, 0, 0, uint16_t, 2, 4, 7)
+#endif
+#ifdef HAS_P410TOARGBROW_SSSE3
+ANY21CT(P410ToARGBRow_Any_SSSE3, P410ToARGBRow_SSSE3, 0, 0, uint16_t, 2, 4, 7)
+#endif
+#ifdef HAS_P410TOARGBROW_AVX2
+ANY21CT(P410ToARGBRow_Any_AVX2, P410ToARGBRow_AVX2, 0, 0, uint16_t, 2, 4, 15)
+#endif
+#ifdef HAS_P410TOAR30ROW_AVX2
+ANY21CT(P410ToAR30Row_Any_AVX2, P410ToAR30Row_AVX2, 0, 0, uint16_t, 2, 4, 15)
+#endif
+
+#undef ANY21CT
+
+// Any 2 16 bit planes with parameter to 1
+#define ANY21PT(NAMEANY, ANY_SIMD, T, BPP, MASK)                     \
+  void NAMEANY(const T* src_u, const T* src_v, T* dst_uv, int depth, \
+               int width) {                                          \
+    SIMD_ALIGNED(T temp[16 * 4]);                                    \
+    memset(temp, 0, 16 * 4 * BPP); /* for msan */                    \
+    int r = width & MASK;                                            \
+    int n = width & ~MASK;                                           \
+    if (n > 0) {                                                     \
+      ANY_SIMD(src_u, src_v, dst_uv, depth, n);                      \
+    }                                                                \
+    memcpy(temp, src_u + n, r * BPP);                                \
+    memcpy(temp + 16, src_v + n, r * BPP);                           \
+    ANY_SIMD(temp, temp + 16, temp + 32, depth, MASK + 1);           \
+    memcpy(dst_uv + n * 2, temp + 32, r * BPP * 2);                  \
+  }
+
+#ifdef HAS_MERGEUVROW_16_AVX2
+ANY21PT(MergeUVRow_16_Any_AVX2, MergeUVRow_16_AVX2, uint16_t, 2, 15)
+#endif
+#ifdef HAS_MERGEUVROW_16_NEON
+ANY21PT(MergeUVRow_16_Any_NEON, MergeUVRow_16_NEON, uint16_t, 2, 7)
+#endif
+
+#undef ANY21CT
+
+// Any 1 to 1.
+#define ANY11(NAMEANY, ANY_SIMD, UVSHIFT, SBPP, BPP, MASK)                \
+  void NAMEANY(const uint8_t* src_ptr, uint8_t* dst_ptr, int width) {     \
+    SIMD_ALIGNED(uint8_t temp[128 * 2]);                                  \
+    memset(temp, 0, 128); /* for YUY2 and msan */                         \
+    int r = width & MASK;                                                 \
+    int n = width & ~MASK;                                                \
+    if (n > 0) {                                                          \
+      ANY_SIMD(src_ptr, dst_ptr, n);                                      \
+    }                                                                     \
+    memcpy(temp, src_ptr + (n >> UVSHIFT) * SBPP, SS(r, UVSHIFT) * SBPP); \
+    ANY_SIMD(temp, temp + 128, MASK + 1);                                 \
+    memcpy(dst_ptr + n * BPP, temp + 128, r * BPP);                       \
+  }
+
+#ifdef HAS_COPYROW_AVX
+ANY11(CopyRow_Any_AVX, CopyRow_AVX, 0, 1, 1, 63)
+#endif
+#ifdef HAS_COPYROW_SSE2
+ANY11(CopyRow_Any_SSE2, CopyRow_SSE2, 0, 1, 1, 31)
+#endif
+#ifdef HAS_COPYROW_NEON
+ANY11(CopyRow_Any_NEON, CopyRow_NEON, 0, 1, 1, 31)
+#endif
+#if defined(HAS_ARGBTORGB24ROW_SSSE3)
+ANY11(ARGBToRGB24Row_Any_SSSE3, ARGBToRGB24Row_SSSE3, 0, 4, 3, 15)
+ANY11(ARGBToRAWRow_Any_SSSE3, ARGBToRAWRow_SSSE3, 0, 4, 3, 15)
+ANY11(ARGBToRGB565Row_Any_SSE2, ARGBToRGB565Row_SSE2, 0, 4, 2, 3)
+ANY11(ARGBToARGB1555Row_Any_SSE2, ARGBToARGB1555Row_SSE2, 0, 4, 2, 3)
+ANY11(ARGBToARGB4444Row_Any_SSE2, ARGBToARGB4444Row_SSE2, 0, 4, 2, 3)
+#endif
+#if defined(HAS_ARGBTORGB24ROW_AVX2)
+ANY11(ARGBToRGB24Row_Any_AVX2, ARGBToRGB24Row_AVX2, 0, 4, 3, 31)
+#endif
+#if defined(HAS_ARGBTORGB24ROW_AVX512VBMI)
+ANY11(ARGBToRGB24Row_Any_AVX512VBMI, ARGBToRGB24Row_AVX512VBMI, 0, 4, 3, 31)
+#endif
+#if defined(HAS_ARGBTORAWROW_AVX2)
+ANY11(ARGBToRAWRow_Any_AVX2, ARGBToRAWRow_AVX2, 0, 4, 3, 31)
+#endif
+#if defined(HAS_ARGBTORGB565ROW_AVX2)
+ANY11(ARGBToRGB565Row_Any_AVX2, ARGBToRGB565Row_AVX2, 0, 4, 2, 7)
+#endif
+#if defined(HAS_ARGBTOARGB4444ROW_AVX2)
+ANY11(ARGBToARGB1555Row_Any_AVX2, ARGBToARGB1555Row_AVX2, 0, 4, 2, 7)
+ANY11(ARGBToARGB4444Row_Any_AVX2, ARGBToARGB4444Row_AVX2, 0, 4, 2, 7)
+#endif
+#if defined(HAS_ABGRTOAR30ROW_SSSE3)
+ANY11(ABGRToAR30Row_Any_SSSE3, ABGRToAR30Row_SSSE3, 0, 4, 4, 3)
+#endif
+#if defined(HAS_ARGBTOAR30ROW_SSSE3)
+ANY11(ARGBToAR30Row_Any_SSSE3, ARGBToAR30Row_SSSE3, 0, 4, 4, 3)
+#endif
+#if defined(HAS_ABGRTOAR30ROW_AVX2)
+ANY11(ABGRToAR30Row_Any_AVX2, ABGRToAR30Row_AVX2, 0, 4, 4, 7)
+#endif
+#if defined(HAS_ARGBTOAR30ROW_AVX2)
+ANY11(ARGBToAR30Row_Any_AVX2, ARGBToAR30Row_AVX2, 0, 4, 4, 7)
+#endif
+#if defined(HAS_J400TOARGBROW_SSE2)
+ANY11(J400ToARGBRow_Any_SSE2, J400ToARGBRow_SSE2, 0, 1, 4, 7)
+#endif
+#if defined(HAS_J400TOARGBROW_AVX2)
+ANY11(J400ToARGBRow_Any_AVX2, J400ToARGBRow_AVX2, 0, 1, 4, 15)
+#endif
+#if defined(HAS_RGB24TOARGBROW_SSSE3)
+ANY11(RGB24ToARGBRow_Any_SSSE3, RGB24ToARGBRow_SSSE3, 0, 3, 4, 15)
+ANY11(RAWToARGBRow_Any_SSSE3, RAWToARGBRow_SSSE3, 0, 3, 4, 15)
+ANY11(RGB565ToARGBRow_Any_SSE2, RGB565ToARGBRow_SSE2, 0, 2, 4, 7)
+ANY11(ARGB1555ToARGBRow_Any_SSE2, ARGB1555ToARGBRow_SSE2, 0, 2, 4, 7)
+ANY11(ARGB4444ToARGBRow_Any_SSE2, ARGB4444ToARGBRow_SSE2, 0, 2, 4, 7)
+#endif
+#if defined(HAS_RAWTORGBAROW_SSSE3)
+ANY11(RAWToRGBARow_Any_SSSE3, RAWToRGBARow_SSSE3, 0, 3, 4, 15)
+#endif
+#if defined(HAS_RAWTORGB24ROW_SSSE3)
+ANY11(RAWToRGB24Row_Any_SSSE3, RAWToRGB24Row_SSSE3, 0, 3, 3, 7)
+#endif
+#if defined(HAS_RGB565TOARGBROW_AVX2)
+ANY11(RGB565ToARGBRow_Any_AVX2, RGB565ToARGBRow_AVX2, 0, 2, 4, 15)
+#endif
+#if defined(HAS_ARGB1555TOARGBROW_AVX2)
+ANY11(ARGB1555ToARGBRow_Any_AVX2, ARGB1555ToARGBRow_AVX2, 0, 2, 4, 15)
+#endif
+#if defined(HAS_ARGB4444TOARGBROW_AVX2)
+ANY11(ARGB4444ToARGBRow_Any_AVX2, ARGB4444ToARGBRow_AVX2, 0, 2, 4, 15)
+#endif
+#if defined(HAS_ARGBTORGB24ROW_NEON)
+ANY11(ARGBToRGB24Row_Any_NEON, ARGBToRGB24Row_NEON, 0, 4, 3, 15)
+ANY11(ARGBToRAWRow_Any_NEON, ARGBToRAWRow_NEON, 0, 4, 3, 7)
+ANY11(ARGBToRGB565Row_Any_NEON, ARGBToRGB565Row_NEON, 0, 4, 2, 7)
+ANY11(ARGBToARGB1555Row_Any_NEON, ARGBToARGB1555Row_NEON, 0, 4, 2, 7)
+ANY11(ARGBToARGB4444Row_Any_NEON, ARGBToARGB4444Row_NEON, 0, 4, 2, 7)
+ANY11(J400ToARGBRow_Any_NEON, J400ToARGBRow_NEON, 0, 1, 4, 7)
+#endif
+#if defined(HAS_ARGBTORGB24ROW_MSA)
+ANY11(ARGBToRGB24Row_Any_MSA, ARGBToRGB24Row_MSA, 0, 4, 3, 15)
+ANY11(ARGBToRAWRow_Any_MSA, ARGBToRAWRow_MSA, 0, 4, 3, 15)
+ANY11(ARGBToRGB565Row_Any_MSA, ARGBToRGB565Row_MSA, 0, 4, 2, 7)
+ANY11(ARGBToARGB1555Row_Any_MSA, ARGBToARGB1555Row_MSA, 0, 4, 2, 7)
+ANY11(ARGBToARGB4444Row_Any_MSA, ARGBToARGB4444Row_MSA, 0, 4, 2, 7)
+ANY11(J400ToARGBRow_Any_MSA, J400ToARGBRow_MSA, 0, 1, 4, 15)
+#endif
+#if defined(HAS_ARGBTORGB24ROW_LASX)
+ANY11(ARGBToRGB24Row_Any_LASX, ARGBToRGB24Row_LASX, 0, 4, 3, 31)
+ANY11(ARGBToRAWRow_Any_LASX, ARGBToRAWRow_LASX, 0, 4, 3, 31)
+ANY11(ARGBToRGB565Row_Any_LASX, ARGBToRGB565Row_LASX, 0, 4, 2, 15)
+ANY11(ARGBToARGB1555Row_Any_LASX, ARGBToARGB1555Row_LASX, 0, 4, 2, 15)
+ANY11(ARGBToARGB4444Row_Any_LASX, ARGBToARGB4444Row_LASX, 0, 4, 2, 15)
+#endif
+#if defined(HAS_J400TOARGBROW_LSX)
+ANY11(J400ToARGBRow_Any_LSX, J400ToARGBRow_LSX, 0, 1, 4, 15)
+#endif
+#if defined(HAS_RAWTORGB24ROW_NEON)
+ANY11(RAWToRGB24Row_Any_NEON, RAWToRGB24Row_NEON, 0, 3, 3, 7)
+#endif
+#if defined(HAS_RAWTORGB24ROW_MSA)
+ANY11(RAWToRGB24Row_Any_MSA, RAWToRGB24Row_MSA, 0, 3, 3, 15)
+#endif
+#if defined(HAS_RAWTORGB24ROW_LSX)
+ANY11(RAWToRGB24Row_Any_LSX, RAWToRGB24Row_LSX, 0, 3, 3, 15)
+#endif
+#ifdef HAS_ARGBTOYROW_AVX2
+ANY11(ARGBToYRow_Any_AVX2, ARGBToYRow_AVX2, 0, 4, 1, 31)
+#endif
+#ifdef HAS_ABGRTOYROW_AVX2
+ANY11(ABGRToYRow_Any_AVX2, ABGRToYRow_AVX2, 0, 4, 1, 31)
+#endif
+#ifdef HAS_ARGBTOYJROW_AVX2
+ANY11(ARGBToYJRow_Any_AVX2, ARGBToYJRow_AVX2, 0, 4, 1, 31)
+#endif
+#ifdef HAS_RGBATOYJROW_AVX2
+ANY11(RGBAToYJRow_Any_AVX2, RGBAToYJRow_AVX2, 0, 4, 1, 31)
+#endif
+#ifdef HAS_UYVYTOYROW_AVX2
+ANY11(UYVYToYRow_Any_AVX2, UYVYToYRow_AVX2, 0, 2, 1, 31)
+#endif
+#ifdef HAS_YUY2TOYROW_AVX2
+ANY11(YUY2ToYRow_Any_AVX2, YUY2ToYRow_AVX2, 1, 4, 1, 31)
+#endif
+#ifdef HAS_ARGBTOYROW_SSSE3
+ANY11(ARGBToYRow_Any_SSSE3, ARGBToYRow_SSSE3, 0, 4, 1, 15)
+#endif
+#ifdef HAS_BGRATOYROW_SSSE3
+ANY11(BGRAToYRow_Any_SSSE3, BGRAToYRow_SSSE3, 0, 4, 1, 15)
+ANY11(ABGRToYRow_Any_SSSE3, ABGRToYRow_SSSE3, 0, 4, 1, 15)
+ANY11(RGBAToYRow_Any_SSSE3, RGBAToYRow_SSSE3, 0, 4, 1, 15)
+#endif
+#ifdef HAS_YUY2TOYROW_SSE2
+ANY11(YUY2ToYRow_Any_SSE2, YUY2ToYRow_SSE2, 1, 4, 1, 15)
+ANY11(UYVYToYRow_Any_SSE2, UYVYToYRow_SSE2, 1, 4, 1, 15)
+#endif
+#ifdef HAS_ARGBTOYJROW_SSSE3
+ANY11(ARGBToYJRow_Any_SSSE3, ARGBToYJRow_SSSE3, 0, 4, 1, 15)
+#endif
+#ifdef HAS_RGBATOYJROW_SSSE3
+ANY11(RGBAToYJRow_Any_SSSE3, RGBAToYJRow_SSSE3, 0, 4, 1, 15)
+#endif
+#ifdef HAS_ARGBTOYROW_NEON
+ANY11(ARGBToYRow_Any_NEON, ARGBToYRow_NEON, 0, 4, 1, 15)
+#endif
+#ifdef HAS_ARGBTOYROW_MSA
+ANY11(ARGBToYRow_Any_MSA, ARGBToYRow_MSA, 0, 4, 1, 15)
+#endif
+#ifdef HAS_ARGBTOYROW_LASX
+ANY11(ARGBToYRow_Any_LASX, ARGBToYRow_LASX, 0, 4, 1, 31)
+#endif
+#ifdef HAS_ARGBTOYJROW_NEON
+ANY11(ARGBToYJRow_Any_NEON, ARGBToYJRow_NEON, 0, 4, 1, 15)
+#endif
+#ifdef HAS_RGBATOYJROW_NEON
+ANY11(RGBAToYJRow_Any_NEON, RGBAToYJRow_NEON, 0, 4, 1, 15)
+#endif
+#ifdef HAS_ARGBTOYJROW_MSA
+ANY11(ARGBToYJRow_Any_MSA, ARGBToYJRow_MSA, 0, 4, 1, 15)
+#endif
+#ifdef HAS_ARGBTOYJROW_LSX
+ANY11(ARGBToYJRow_Any_LSX, ARGBToYJRow_LSX, 0, 4, 1, 15)
+#endif
+#ifdef HAS_ARGBTOYJROW_LASX
+ANY11(ARGBToYJRow_Any_LASX, ARGBToYJRow_LASX, 0, 4, 1, 31)
+#endif
+#ifdef HAS_BGRATOYROW_NEON
+ANY11(BGRAToYRow_Any_NEON, BGRAToYRow_NEON, 0, 4, 1, 15)
+#endif
+#ifdef HAS_BGRATOYROW_MSA
+ANY11(BGRAToYRow_Any_MSA, BGRAToYRow_MSA, 0, 4, 1, 15)
+#endif
+#ifdef HAS_BGRATOYROW_LSX
+ANY11(BGRAToYRow_Any_LSX, BGRAToYRow_LSX, 0, 4, 1, 15)
+#endif
+#ifdef HAS_ABGRTOYROW_NEON
+ANY11(ABGRToYRow_Any_NEON, ABGRToYRow_NEON, 0, 4, 1, 15)
+#endif
+#ifdef HAS_ABGRTOYROW_MSA
+ANY11(ABGRToYRow_Any_MSA, ABGRToYRow_MSA, 0, 4, 1, 7)
+#endif
+#ifdef HAS_ABGRTOYROW_LSX
+ANY11(ABGRToYRow_Any_LSX, ABGRToYRow_LSX, 0, 4, 1, 15)
+#endif
+#ifdef HAS_RGBATOYROW_NEON
+ANY11(RGBAToYRow_Any_NEON, RGBAToYRow_NEON, 0, 4, 1, 15)
+#endif
+#ifdef HAS_RGBATOYROW_MSA
+ANY11(RGBAToYRow_Any_MSA, RGBAToYRow_MSA, 0, 4, 1, 15)
+#endif
+#ifdef HAS_RGBATOYROW_LSX
+ANY11(RGBAToYRow_Any_LSX, RGBAToYRow_LSX, 0, 4, 1, 15)
+#endif
+#ifdef HAS_RGB24TOYROW_NEON
+ANY11(RGB24ToYRow_Any_NEON, RGB24ToYRow_NEON, 0, 3, 1, 15)
+#endif
+#ifdef HAS_RGB24TOYJROW_AVX2
+ANY11(RGB24ToYJRow_Any_AVX2, RGB24ToYJRow_AVX2, 0, 3, 1, 31)
+#endif
+#ifdef HAS_RGB24TOYJROW_SSSE3
+ANY11(RGB24ToYJRow_Any_SSSE3, RGB24ToYJRow_SSSE3, 0, 3, 1, 15)
+#endif
+#ifdef HAS_RGB24TOYJROW_NEON
+ANY11(RGB24ToYJRow_Any_NEON, RGB24ToYJRow_NEON, 0, 3, 1, 15)
+#endif
+#ifdef HAS_RGB24TOYROW_MSA
+ANY11(RGB24ToYRow_Any_MSA, RGB24ToYRow_MSA, 0, 3, 1, 15)
+#endif
+#ifdef HAS_RGB24TOYROW_LSX
+ANY11(RGB24ToYRow_Any_LSX, RGB24ToYRow_LSX, 0, 3, 1, 15)
+#endif
+#ifdef HAS_RGB24TOYROW_LASX
+ANY11(RGB24ToYRow_Any_LASX, RGB24ToYRow_LASX, 0, 3, 1, 31)
+#endif
+#ifdef HAS_RAWTOYROW_NEON
+ANY11(RAWToYRow_Any_NEON, RAWToYRow_NEON, 0, 3, 1, 15)
+#endif
+#ifdef HAS_RAWTOYJROW_AVX2
+ANY11(RAWToYJRow_Any_AVX2, RAWToYJRow_AVX2, 0, 3, 1, 31)
+#endif
+#ifdef HAS_RAWTOYJROW_SSSE3
+ANY11(RAWToYJRow_Any_SSSE3, RAWToYJRow_SSSE3, 0, 3, 1, 15)
+#endif
+#ifdef HAS_RAWTOYJROW_NEON
+ANY11(RAWToYJRow_Any_NEON, RAWToYJRow_NEON, 0, 3, 1, 15)
+#endif
+#ifdef HAS_RAWTOYROW_MSA
+ANY11(RAWToYRow_Any_MSA, RAWToYRow_MSA, 0, 3, 1, 15)
+#endif
+#ifdef HAS_RAWTOYROW_LSX
+ANY11(RAWToYRow_Any_LSX, RAWToYRow_LSX, 0, 3, 1, 15)
+#endif
+#ifdef HAS_RAWTOYROW_LASX
+ANY11(RAWToYRow_Any_LASX, RAWToYRow_LASX, 0, 3, 1, 31)
+#endif
+#ifdef HAS_RGB565TOYROW_NEON
+ANY11(RGB565ToYRow_Any_NEON, RGB565ToYRow_NEON, 0, 2, 1, 7)
+#endif
+#ifdef HAS_RGB565TOYROW_MSA
+ANY11(RGB565ToYRow_Any_MSA, RGB565ToYRow_MSA, 0, 2, 1, 15)
+#endif
+#ifdef HAS_RGB565TOYROW_LSX
+ANY11(RGB565ToYRow_Any_LSX, RGB565ToYRow_LSX, 0, 2, 1, 15)
+#endif
+#ifdef HAS_RGB565TOYROW_LASX
+ANY11(RGB565ToYRow_Any_LASX, RGB565ToYRow_LASX, 0, 2, 1, 31)
+#endif
+#ifdef HAS_ARGB1555TOYROW_NEON
+ANY11(ARGB1555ToYRow_Any_NEON, ARGB1555ToYRow_NEON, 0, 2, 1, 7)
+#endif
+#ifdef HAS_ARGB1555TOYROW_MSA
+ANY11(ARGB1555ToYRow_Any_MSA, ARGB1555ToYRow_MSA, 0, 2, 1, 15)
+#endif
+#ifdef HAS_ARGB1555TOYROW_LSX
+ANY11(ARGB1555ToYRow_Any_LSX, ARGB1555ToYRow_LSX, 0, 2, 1, 15)
+#endif
+#ifdef HAS_ARGB1555TOYROW_LASX
+ANY11(ARGB1555ToYRow_Any_LASX, ARGB1555ToYRow_LASX, 0, 2, 1, 31)
+#endif
+#ifdef HAS_ARGB4444TOYROW_NEON
+ANY11(ARGB4444ToYRow_Any_NEON, ARGB4444ToYRow_NEON, 0, 2, 1, 7)
+#endif
+#ifdef HAS_YUY2TOYROW_NEON
+ANY11(YUY2ToYRow_Any_NEON, YUY2ToYRow_NEON, 1, 4, 1, 15)
+#endif
+#ifdef HAS_UYVYTOYROW_NEON
+ANY11(UYVYToYRow_Any_NEON, UYVYToYRow_NEON, 1, 4, 1, 15)
+#endif
+#ifdef HAS_YUY2TOYROW_MSA
+ANY11(YUY2ToYRow_Any_MSA, YUY2ToYRow_MSA, 1, 4, 1, 31)
+#endif
+#ifdef HAS_YUY2TOYROW_LASX
+ANY11(YUY2ToYRow_Any_LASX, YUY2ToYRow_LASX, 1, 4, 1, 31)
+#endif
+#ifdef HAS_UYVYTOYROW_MSA
+ANY11(UYVYToYRow_Any_MSA, UYVYToYRow_MSA, 1, 4, 1, 31)
+#endif
+#ifdef HAS_UYVYTOYROW_LASX
+ANY11(UYVYToYRow_Any_LASX, UYVYToYRow_LASX, 1, 4, 1, 31)
+#endif
+#ifdef HAS_AYUVTOYROW_NEON
+ANY11(AYUVToYRow_Any_NEON, AYUVToYRow_NEON, 0, 4, 1, 15)
+#endif
+#ifdef HAS_SWAPUVROW_SSSE3
+ANY11(SwapUVRow_Any_SSSE3, SwapUVRow_SSSE3, 0, 2, 2, 15)
+#endif
+#ifdef HAS_SWAPUVROW_AVX2
+ANY11(SwapUVRow_Any_AVX2, SwapUVRow_AVX2, 0, 2, 2, 31)
+#endif
+#ifdef HAS_SWAPUVROW_NEON
+ANY11(SwapUVRow_Any_NEON, SwapUVRow_NEON, 0, 2, 2, 15)
+#endif
+#ifdef HAS_RGB24TOARGBROW_NEON
+ANY11(RGB24ToARGBRow_Any_NEON, RGB24ToARGBRow_NEON, 0, 3, 4, 7)
+#endif
+#ifdef HAS_RGB24TOARGBROW_MSA
+ANY11(RGB24ToARGBRow_Any_MSA, RGB24ToARGBRow_MSA, 0, 3, 4, 15)
+#endif
+#ifdef HAS_RGB24TOARGBROW_LSX
+ANY11(RGB24ToARGBRow_Any_LSX, RGB24ToARGBRow_LSX, 0, 3, 4, 15)
+#endif
+#ifdef HAS_RGB24TOARGBROW_LASX
+ANY11(RGB24ToARGBRow_Any_LASX, RGB24ToARGBRow_LASX, 0, 3, 4, 31)
+#endif
+#ifdef HAS_RAWTOARGBROW_NEON
+ANY11(RAWToARGBRow_Any_NEON, RAWToARGBRow_NEON, 0, 3, 4, 7)
+#endif
+#ifdef HAS_RAWTORGBAROW_NEON
+ANY11(RAWToRGBARow_Any_NEON, RAWToRGBARow_NEON, 0, 3, 4, 7)
+#endif
+#ifdef HAS_RAWTOARGBROW_MSA
+ANY11(RAWToARGBRow_Any_MSA, RAWToARGBRow_MSA, 0, 3, 4, 15)
+#endif
+#ifdef HAS_RAWTOARGBROW_LSX
+ANY11(RAWToARGBRow_Any_LSX, RAWToARGBRow_LSX, 0, 3, 4, 15)
+#endif
+#ifdef HAS_RAWTOARGBROW_LASX
+ANY11(RAWToARGBRow_Any_LASX, RAWToARGBRow_LASX, 0, 3, 4, 31)
+#endif
+#ifdef HAS_RGB565TOARGBROW_NEON
+ANY11(RGB565ToARGBRow_Any_NEON, RGB565ToARGBRow_NEON, 0, 2, 4, 7)
+#endif
+#ifdef HAS_RGB565TOARGBROW_MSA
+ANY11(RGB565ToARGBRow_Any_MSA, RGB565ToARGBRow_MSA, 0, 2, 4, 15)
+#endif
+#ifdef HAS_RGB565TOARGBROW_LSX
+ANY11(RGB565ToARGBRow_Any_LSX, RGB565ToARGBRow_LSX, 0, 2, 4, 15)
+#endif
+#ifdef HAS_RGB565TOARGBROW_LASX
+ANY11(RGB565ToARGBRow_Any_LASX, RGB565ToARGBRow_LASX, 0, 2, 4, 31)
+#endif
+#ifdef HAS_ARGB1555TOARGBROW_NEON
+ANY11(ARGB1555ToARGBRow_Any_NEON, ARGB1555ToARGBRow_NEON, 0, 2, 4, 7)
+#endif
+#ifdef HAS_ARGB1555TOARGBROW_MSA
+ANY11(ARGB1555ToARGBRow_Any_MSA, ARGB1555ToARGBRow_MSA, 0, 2, 4, 15)
+#endif
+#ifdef HAS_ARGB1555TOARGBROW_LSX
+ANY11(ARGB1555ToARGBRow_Any_LSX, ARGB1555ToARGBRow_LSX, 0, 2, 4, 15)
+#endif
+#ifdef HAS_ARGB1555TOARGBROW_LASX
+ANY11(ARGB1555ToARGBRow_Any_LASX, ARGB1555ToARGBRow_LASX, 0, 2, 4, 31)
+#endif
+#ifdef HAS_ARGB4444TOARGBROW_NEON
+ANY11(ARGB4444ToARGBRow_Any_NEON, ARGB4444ToARGBRow_NEON, 0, 2, 4, 7)
+#endif
+#ifdef HAS_ARGB4444TOARGBROW_MSA
+ANY11(ARGB4444ToARGBRow_Any_MSA, ARGB4444ToARGBRow_MSA, 0, 2, 4, 15)
+#endif
+#ifdef HAS_ARGB4444TOARGBROW_LSX
+ANY11(ARGB4444ToARGBRow_Any_LSX, ARGB4444ToARGBRow_LSX, 0, 2, 4, 15)
+#endif
+#ifdef HAS_ARGB4444TOARGBROW_LASX
+ANY11(ARGB4444ToARGBRow_Any_LASX, ARGB4444ToARGBRow_LASX, 0, 2, 4, 31)
+#endif
+#ifdef HAS_ARGBATTENUATEROW_SSSE3
+ANY11(ARGBAttenuateRow_Any_SSSE3, ARGBAttenuateRow_SSSE3, 0, 4, 4, 3)
+#endif
+#ifdef HAS_ARGBUNATTENUATEROW_SSE2
+ANY11(ARGBUnattenuateRow_Any_SSE2, ARGBUnattenuateRow_SSE2, 0, 4, 4, 3)
+#endif
+#ifdef HAS_ARGBATTENUATEROW_AVX2
+ANY11(ARGBAttenuateRow_Any_AVX2, ARGBAttenuateRow_AVX2, 0, 4, 4, 7)
+#endif
+#ifdef HAS_ARGBUNATTENUATEROW_AVX2
+ANY11(ARGBUnattenuateRow_Any_AVX2, ARGBUnattenuateRow_AVX2, 0, 4, 4, 7)
+#endif
+#ifdef HAS_ARGBATTENUATEROW_NEON
+ANY11(ARGBAttenuateRow_Any_NEON, ARGBAttenuateRow_NEON, 0, 4, 4, 7)
+#endif
+#ifdef HAS_ARGBATTENUATEROW_MSA
+ANY11(ARGBAttenuateRow_Any_MSA, ARGBAttenuateRow_MSA, 0, 4, 4, 7)
+#endif
+#ifdef HAS_ARGBATTENUATEROW_LASX
+ANY11(ARGBAttenuateRow_Any_LASX, ARGBAttenuateRow_LASX, 0, 4, 4, 15)
+#endif
+#ifdef HAS_ARGBEXTRACTALPHAROW_SSE2
+ANY11(ARGBExtractAlphaRow_Any_SSE2, ARGBExtractAlphaRow_SSE2, 0, 4, 1, 7)
+#endif
+#ifdef HAS_ARGBEXTRACTALPHAROW_AVX2
+ANY11(ARGBExtractAlphaRow_Any_AVX2, ARGBExtractAlphaRow_AVX2, 0, 4, 1, 31)
+#endif
+#ifdef HAS_ARGBEXTRACTALPHAROW_NEON
+ANY11(ARGBExtractAlphaRow_Any_NEON, ARGBExtractAlphaRow_NEON, 0, 4, 1, 15)
+#endif
+#ifdef HAS_ARGBEXTRACTALPHAROW_MSA
+ANY11(ARGBExtractAlphaRow_Any_MSA, ARGBExtractAlphaRow_MSA, 0, 4, 1, 15)
+#endif
+#ifdef HAS_ARGBEXTRACTALPHAROW_LSX
+ANY11(ARGBExtractAlphaRow_Any_LSX, ARGBExtractAlphaRow_LSX, 0, 4, 1, 15)
+#endif
+#undef ANY11
+
+// Any 1 to 1 blended.  Destination is read, modify, write.
+#define ANY11B(NAMEANY, ANY_SIMD, UVSHIFT, SBPP, BPP, MASK)               \
+  void NAMEANY(const uint8_t* src_ptr, uint8_t* dst_ptr, int width) {     \
+    SIMD_ALIGNED(uint8_t temp[64 * 2]);                                   \
+    memset(temp, 0, 64 * 2); /* for msan */                               \
+    int r = width & MASK;                                                 \
+    int n = width & ~MASK;                                                \
+    if (n > 0) {                                                          \
+      ANY_SIMD(src_ptr, dst_ptr, n);                                      \
+    }                                                                     \
+    memcpy(temp, src_ptr + (n >> UVSHIFT) * SBPP, SS(r, UVSHIFT) * SBPP); \
+    memcpy(temp + 64, dst_ptr + n * BPP, r * BPP);                        \
+    ANY_SIMD(temp, temp + 64, MASK + 1);                                  \
+    memcpy(dst_ptr + n * BPP, temp + 64, r * BPP);                        \
+  }
+
+#ifdef HAS_ARGBCOPYALPHAROW_AVX2
+ANY11B(ARGBCopyAlphaRow_Any_AVX2, ARGBCopyAlphaRow_AVX2, 0, 4, 4, 15)
+#endif
+#ifdef HAS_ARGBCOPYALPHAROW_SSE2
+ANY11B(ARGBCopyAlphaRow_Any_SSE2, ARGBCopyAlphaRow_SSE2, 0, 4, 4, 7)
+#endif
+#ifdef HAS_ARGBCOPYYTOALPHAROW_AVX2
+ANY11B(ARGBCopyYToAlphaRow_Any_AVX2, ARGBCopyYToAlphaRow_AVX2, 0, 1, 4, 15)
+#endif
+#ifdef HAS_ARGBCOPYYTOALPHAROW_SSE2
+ANY11B(ARGBCopyYToAlphaRow_Any_SSE2, ARGBCopyYToAlphaRow_SSE2, 0, 1, 4, 7)
+#endif
+#undef ANY11B
+
+// Any 1 to 1 with parameter.
+#define ANY11P(NAMEANY, ANY_SIMD, T, SBPP, BPP, MASK)                          \
+  void NAMEANY(const uint8_t* src_ptr, uint8_t* dst_ptr, T param, int width) { \
+    SIMD_ALIGNED(uint8_t temp[64 * 2]);                                        \
+    memset(temp, 0, 64); /* for msan */                                        \
+    int r = width & MASK;                                                      \
+    int n = width & ~MASK;                                                     \
+    if (n > 0) {                                                               \
+      ANY_SIMD(src_ptr, dst_ptr, param, n);                                    \
+    }                                                                          \
+    memcpy(temp, src_ptr + n * SBPP, r * SBPP);                                \
+    ANY_SIMD(temp, temp + 64, param, MASK + 1);                                \
+    memcpy(dst_ptr + n * BPP, temp + 64, r * BPP);                             \
+  }
+
+#if defined(HAS_I400TOARGBROW_SSE2)
+ANY11P(I400ToARGBRow_Any_SSE2,
+       I400ToARGBRow_SSE2,
+       const struct YuvConstants*,
+       1,
+       4,
+       7)
+#endif
+#if defined(HAS_I400TOARGBROW_AVX2)
+ANY11P(I400ToARGBRow_Any_AVX2,
+       I400ToARGBRow_AVX2,
+       const struct YuvConstants*,
+       1,
+       4,
+       15)
+#endif
+#if defined(HAS_I400TOARGBROW_NEON)
+ANY11P(I400ToARGBRow_Any_NEON,
+       I400ToARGBRow_NEON,
+       const struct YuvConstants*,
+       1,
+       4,
+       7)
+#endif
+#if defined(HAS_I400TOARGBROW_MSA)
+ANY11P(I400ToARGBRow_Any_MSA,
+       I400ToARGBRow_MSA,
+       const struct YuvConstants*,
+       1,
+       4,
+       15)
+#endif
+#if defined(HAS_I400TOARGBROW_LSX)
+ANY11P(I400ToARGBRow_Any_LSX,
+       I400ToARGBRow_LSX,
+       const struct YuvConstants*,
+       1,
+       4,
+       15)
+#endif
+
+#if defined(HAS_ARGBTORGB565DITHERROW_SSE2)
+ANY11P(ARGBToRGB565DitherRow_Any_SSE2,
+       ARGBToRGB565DitherRow_SSE2,
+       const uint32_t,
+       4,
+       2,
+       3)
+#endif
+#if defined(HAS_ARGBTORGB565DITHERROW_AVX2)
+ANY11P(ARGBToRGB565DitherRow_Any_AVX2,
+       ARGBToRGB565DitherRow_AVX2,
+       const uint32_t,
+       4,
+       2,
+       7)
+#endif
+#if defined(HAS_ARGBTORGB565DITHERROW_NEON)
+ANY11P(ARGBToRGB565DitherRow_Any_NEON,
+       ARGBToRGB565DitherRow_NEON,
+       const uint32_t,
+       4,
+       2,
+       7)
+#endif
+#if defined(HAS_ARGBTORGB565DITHERROW_MSA)
+ANY11P(ARGBToRGB565DitherRow_Any_MSA,
+       ARGBToRGB565DitherRow_MSA,
+       const uint32_t,
+       4,
+       2,
+       7)
+#endif
+#if defined(HAS_ARGBTORGB565DITHERROW_LASX)
+ANY11P(ARGBToRGB565DitherRow_Any_LASX,
+       ARGBToRGB565DitherRow_LASX,
+       const uint32_t,
+       4,
+       2,
+       15)
+#endif
+#ifdef HAS_ARGBSHUFFLEROW_SSSE3
+ANY11P(ARGBShuffleRow_Any_SSSE3, ARGBShuffleRow_SSSE3, const uint8_t*, 4, 4, 7)
+#endif
+#ifdef HAS_ARGBSHUFFLEROW_AVX2
+ANY11P(ARGBShuffleRow_Any_AVX2, ARGBShuffleRow_AVX2, const uint8_t*, 4, 4, 15)
+#endif
+#ifdef HAS_ARGBSHUFFLEROW_NEON
+ANY11P(ARGBShuffleRow_Any_NEON, ARGBShuffleRow_NEON, const uint8_t*, 4, 4, 3)
+#endif
+#ifdef HAS_ARGBSHUFFLEROW_MSA
+ANY11P(ARGBShuffleRow_Any_MSA, ARGBShuffleRow_MSA, const uint8_t*, 4, 4, 7)
+#endif
+#ifdef HAS_ARGBSHUFFLEROW_LASX
+ANY11P(ARGBShuffleRow_Any_LASX, ARGBShuffleRow_LASX, const uint8_t*, 4, 4, 15)
+#endif
+#undef ANY11P
+#undef ANY11P
+
+// Any 1 to 1 with type
+#define ANY11T(NAMEANY, ANY_SIMD, SBPP, BPP, STYPE, DTYPE, MASK)  \
+  void NAMEANY(const STYPE* src_ptr, DTYPE* dst_ptr, int width) { \
+    SIMD_ALIGNED(uint8_t temp[(MASK + 1) * SBPP]);                \
+    SIMD_ALIGNED(uint8_t out[(MASK + 1) * BPP]);                  \
+    memset(temp, 0, (MASK + 1) * SBPP); /* for msan */            \
+    int r = width & MASK;                                         \
+    int n = width & ~MASK;                                        \
+    if (n > 0) {                                                  \
+      ANY_SIMD(src_ptr, dst_ptr, n);                              \
+    }                                                             \
+    memcpy(temp, (uint8_t*)(src_ptr) + n * SBPP, r * SBPP);       \
+    ANY_SIMD((STYPE*)temp, (DTYPE*)out, MASK + 1);                \
+    memcpy((uint8_t*)(dst_ptr) + n * BPP, out, r * BPP);          \
+  }
+
+#ifdef HAS_ARGBTOAR64ROW_SSSE3
+ANY11T(ARGBToAR64Row_Any_SSSE3, ARGBToAR64Row_SSSE3, 4, 8, uint8_t, uint16_t, 3)
+#endif
+
+#ifdef HAS_ARGBTOAB64ROW_SSSE3
+ANY11T(ARGBToAB64Row_Any_SSSE3, ARGBToAB64Row_SSSE3, 4, 8, uint8_t, uint16_t, 3)
+#endif
+
+#ifdef HAS_AR64TOARGBROW_SSSE3
+ANY11T(AR64ToARGBRow_Any_SSSE3, AR64ToARGBRow_SSSE3, 8, 4, uint16_t, uint8_t, 3)
+#endif
+
+#ifdef HAS_ARGBTOAR64ROW_SSSE3
+ANY11T(AB64ToARGBRow_Any_SSSE3, AB64ToARGBRow_SSSE3, 8, 4, uint16_t, uint8_t, 3)
+#endif
+
+#ifdef HAS_ARGBTOAR64ROW_AVX2
+ANY11T(ARGBToAR64Row_Any_AVX2, ARGBToAR64Row_AVX2, 4, 8, uint8_t, uint16_t, 7)
+#endif
+
+#ifdef HAS_ARGBTOAB64ROW_AVX2
+ANY11T(ARGBToAB64Row_Any_AVX2, ARGBToAB64Row_AVX2, 4, 8, uint8_t, uint16_t, 7)
+#endif
+
+#ifdef HAS_AR64TOARGBROW_AVX2
+ANY11T(AR64ToARGBRow_Any_AVX2, AR64ToARGBRow_AVX2, 8, 4, uint16_t, uint8_t, 7)
+#endif
+
+#ifdef HAS_ARGBTOAR64ROW_AVX2
+ANY11T(AB64ToARGBRow_Any_AVX2, AB64ToARGBRow_AVX2, 8, 4, uint16_t, uint8_t, 7)
+#endif
+
+#ifdef HAS_ARGBTOAR64ROW_NEON
+ANY11T(ARGBToAR64Row_Any_NEON, ARGBToAR64Row_NEON, 4, 8, uint8_t, uint16_t, 7)
+#endif
+
+#ifdef HAS_ARGBTOAB64ROW_NEON
+ANY11T(ARGBToAB64Row_Any_NEON, ARGBToAB64Row_NEON, 4, 8, uint8_t, uint16_t, 7)
+#endif
+
+#ifdef HAS_AR64TOARGBROW_NEON
+ANY11T(AR64ToARGBRow_Any_NEON, AR64ToARGBRow_NEON, 8, 4, uint16_t, uint8_t, 7)
+#endif
+
+#ifdef HAS_ARGBTOAR64ROW_NEON
+ANY11T(AB64ToARGBRow_Any_NEON, AB64ToARGBRow_NEON, 8, 4, uint16_t, uint8_t, 7)
+#endif
+
+#undef ANY11T
+
+// Any 1 to 1 with parameter and shorts.  BPP measures in shorts.
+#define ANY11C(NAMEANY, ANY_SIMD, SBPP, BPP, STYPE, DTYPE, MASK)             \
+  void NAMEANY(const STYPE* src_ptr, DTYPE* dst_ptr, int scale, int width) { \
+    SIMD_ALIGNED(STYPE temp[32]);                                            \
+    SIMD_ALIGNED(DTYPE out[32]);                                             \
+    memset(temp, 0, 32 * SBPP); /* for msan */                               \
+    int r = width & MASK;                                                    \
+    int n = width & ~MASK;                                                   \
+    if (n > 0) {                                                             \
+      ANY_SIMD(src_ptr, dst_ptr, scale, n);                                  \
+    }                                                                        \
+    memcpy(temp, src_ptr + n, r * SBPP);                                     \
+    ANY_SIMD(temp, out, scale, MASK + 1);                                    \
+    memcpy(dst_ptr + n, out, r * BPP);                                       \
+  }
+
+#ifdef HAS_CONVERT16TO8ROW_SSSE3
+ANY11C(Convert16To8Row_Any_SSSE3,
+       Convert16To8Row_SSSE3,
+       2,
+       1,
+       uint16_t,
+       uint8_t,
+       15)
+#endif
+#ifdef HAS_CONVERT16TO8ROW_AVX2
+ANY11C(Convert16To8Row_Any_AVX2,
+       Convert16To8Row_AVX2,
+       2,
+       1,
+       uint16_t,
+       uint8_t,
+       31)
+#endif
+#ifdef HAS_CONVERT16TO8ROW_NEON
+ANY11C(Convert16To8Row_Any_NEON,
+       Convert16To8Row_NEON,
+       2,
+       1,
+       uint16_t,
+       uint8_t,
+       15)
+#endif
+#ifdef HAS_CONVERT8TO16ROW_SSE2
+ANY11C(Convert8To16Row_Any_SSE2,
+       Convert8To16Row_SSE2,
+       1,
+       2,
+       uint8_t,
+       uint16_t,
+       15)
+#endif
+#ifdef HAS_CONVERT8TO16ROW_AVX2
+ANY11C(Convert8To16Row_Any_AVX2,
+       Convert8To16Row_AVX2,
+       1,
+       2,
+       uint8_t,
+       uint16_t,
+       31)
+#endif
+#ifdef HAS_MULTIPLYROW_16_AVX2
+ANY11C(MultiplyRow_16_Any_AVX2,
+       MultiplyRow_16_AVX2,
+       2,
+       2,
+       uint16_t,
+       uint16_t,
+       31)
+#endif
+#ifdef HAS_MULTIPLYROW_16_NEON
+ANY11C(MultiplyRow_16_Any_NEON,
+       MultiplyRow_16_NEON,
+       2,
+       2,
+       uint16_t,
+       uint16_t,
+       15)
+#endif
+#ifdef HAS_DIVIDEROW_16_AVX2
+ANY11C(DivideRow_16_Any_AVX2, DivideRow_16_AVX2, 2, 2, uint16_t, uint16_t, 31)
+#endif
+#ifdef HAS_DIVIDEROW_16_NEON
+ANY11C(DivideRow_16_Any_NEON, DivideRow_16_NEON, 2, 2, uint16_t, uint16_t, 15)
+#endif
+#undef ANY11C
+
+// Any 1 to 1 with parameter and shorts to byte.  BPP measures in shorts.
+#define ANY11P16(NAMEANY, ANY_SIMD, ST, T, SBPP, BPP, MASK)             \
+  void NAMEANY(const ST* src_ptr, T* dst_ptr, float param, int width) { \
+    SIMD_ALIGNED(ST temp[32]);                                          \
+    SIMD_ALIGNED(T out[32]);                                            \
+    memset(temp, 0, SBPP * 32); /* for msan */                          \
+    int r = width & MASK;                                               \
+    int n = width & ~MASK;                                              \
+    if (n > 0) {                                                        \
+      ANY_SIMD(src_ptr, dst_ptr, param, n);                             \
+    }                                                                   \
+    memcpy(temp, src_ptr + n, r * SBPP);                                \
+    ANY_SIMD(temp, out, param, MASK + 1);                               \
+    memcpy(dst_ptr + n, out, r * BPP);                                  \
+  }
+
+#ifdef HAS_HALFFLOATROW_SSE2
+ANY11P16(HalfFloatRow_Any_SSE2, HalfFloatRow_SSE2, uint16_t, uint16_t, 2, 2, 7)
+#endif
+#ifdef HAS_HALFFLOATROW_AVX2
+ANY11P16(HalfFloatRow_Any_AVX2, HalfFloatRow_AVX2, uint16_t, uint16_t, 2, 2, 15)
+#endif
+#ifdef HAS_HALFFLOATROW_F16C
+ANY11P16(HalfFloatRow_Any_F16C, HalfFloatRow_F16C, uint16_t, uint16_t, 2, 2, 15)
+ANY11P16(HalfFloat1Row_Any_F16C,
+         HalfFloat1Row_F16C,
+         uint16_t,
+         uint16_t,
+         2,
+         2,
+         15)
+#endif
+#ifdef HAS_HALFFLOATROW_NEON
+ANY11P16(HalfFloatRow_Any_NEON, HalfFloatRow_NEON, uint16_t, uint16_t, 2, 2, 7)
+ANY11P16(HalfFloat1Row_Any_NEON,
+         HalfFloat1Row_NEON,
+         uint16_t,
+         uint16_t,
+         2,
+         2,
+         7)
+#endif
+#ifdef HAS_HALFFLOATROW_MSA
+ANY11P16(HalfFloatRow_Any_MSA, HalfFloatRow_MSA, uint16_t, uint16_t, 2, 2, 31)
+#endif
+#ifdef HAS_BYTETOFLOATROW_NEON
+ANY11P16(ByteToFloatRow_Any_NEON, ByteToFloatRow_NEON, uint8_t, float, 1, 3, 7)
+#endif
+#ifdef HAS_HALFFLOATROW_LSX
+ANY11P16(HalfFloatRow_Any_LSX, HalfFloatRow_LSX, uint16_t, uint16_t, 2, 2, 31)
+#endif
+#undef ANY11P16
+
+// Any 1 to 1 with yuvconstants
+#define ANY11C(NAMEANY, ANY_SIMD, UVSHIFT, SBPP, BPP, MASK)               \
+  void NAMEANY(const uint8_t* src_ptr, uint8_t* dst_ptr,                  \
+               const struct YuvConstants* yuvconstants, int width) {      \
+    SIMD_ALIGNED(uint8_t temp[128 * 2]);                                  \
+    memset(temp, 0, 128); /* for YUY2 and msan */                         \
+    int r = width & MASK;                                                 \
+    int n = width & ~MASK;                                                \
+    if (n > 0) {                                                          \
+      ANY_SIMD(src_ptr, dst_ptr, yuvconstants, n);                        \
+    }                                                                     \
+    memcpy(temp, src_ptr + (n >> UVSHIFT) * SBPP, SS(r, UVSHIFT) * SBPP); \
+    ANY_SIMD(temp, temp + 128, yuvconstants, MASK + 1);                   \
+    memcpy(dst_ptr + n * BPP, temp + 128, r * BPP);                       \
+  }
+#if defined(HAS_YUY2TOARGBROW_SSSE3)
+ANY11C(YUY2ToARGBRow_Any_SSSE3, YUY2ToARGBRow_SSSE3, 1, 4, 4, 15)
+ANY11C(UYVYToARGBRow_Any_SSSE3, UYVYToARGBRow_SSSE3, 1, 4, 4, 15)
+#endif
+#if defined(HAS_YUY2TOARGBROW_AVX2)
+ANY11C(YUY2ToARGBRow_Any_AVX2, YUY2ToARGBRow_AVX2, 1, 4, 4, 31)
+ANY11C(UYVYToARGBRow_Any_AVX2, UYVYToARGBRow_AVX2, 1, 4, 4, 31)
+#endif
+#if defined(HAS_YUY2TOARGBROW_NEON)
+ANY11C(YUY2ToARGBRow_Any_NEON, YUY2ToARGBRow_NEON, 1, 4, 4, 7)
+ANY11C(UYVYToARGBRow_Any_NEON, UYVYToARGBRow_NEON, 1, 4, 4, 7)
+#endif
+#if defined(HAS_YUY2TOARGBROW_MSA)
+ANY11C(YUY2ToARGBRow_Any_MSA, YUY2ToARGBRow_MSA, 1, 4, 4, 7)
+ANY11C(UYVYToARGBRow_Any_MSA, UYVYToARGBRow_MSA, 1, 4, 4, 7)
+#endif
+#if defined(HAS_YUY2TOARGBROW_LSX)
+ANY11C(YUY2ToARGBRow_Any_LSX, YUY2ToARGBRow_LSX, 1, 4, 4, 7)
+ANY11C(UYVYToARGBRow_Any_LSX, UYVYToARGBRow_LSX, 1, 4, 4, 7)
+#endif
+#undef ANY11C
+
+// Any 1 to 1 interpolate.  Takes 2 rows of source via stride.
+#define ANY11I(NAMEANY, ANY_SIMD, TD, TS, SBPP, BPP, MASK)           \
+  void NAMEANY(TD* dst_ptr, const TS* src_ptr, ptrdiff_t src_stride, \
+               int width, int source_y_fraction) {                   \
+    SIMD_ALIGNED(TS temps[64 * 2]);                                  \
+    SIMD_ALIGNED(TD tempd[64]);                                      \
+    memset(temps, 0, sizeof(temps)); /* for msan */                  \
+    int r = width & MASK;                                            \
+    int n = width & ~MASK;                                           \
+    if (n > 0) {                                                     \
+      ANY_SIMD(dst_ptr, src_ptr, src_stride, n, source_y_fraction);  \
+    }                                                                \
+    memcpy(temps, src_ptr + n * SBPP, r * SBPP * sizeof(TS));        \
+    if (source_y_fraction) {                                         \
+      memcpy(temps + 64, src_ptr + src_stride + n * SBPP,            \
+             r * SBPP * sizeof(TS));                                 \
+    }                                                                \
+    ANY_SIMD(tempd, temps, 64, MASK + 1, source_y_fraction);         \
+    memcpy(dst_ptr + n * BPP, tempd, r * BPP * sizeof(TD));          \
+  }
+
+#ifdef HAS_INTERPOLATEROW_AVX2
+ANY11I(InterpolateRow_Any_AVX2, InterpolateRow_AVX2, uint8_t, uint8_t, 1, 1, 31)
+#endif
+#ifdef HAS_INTERPOLATEROW_SSSE3
+ANY11I(InterpolateRow_Any_SSSE3,
+       InterpolateRow_SSSE3,
+       uint8_t,
+       uint8_t,
+       1,
+       1,
+       15)
+#endif
+#ifdef HAS_INTERPOLATEROW_NEON
+ANY11I(InterpolateRow_Any_NEON, InterpolateRow_NEON, uint8_t, uint8_t, 1, 1, 15)
+#endif
+#ifdef HAS_INTERPOLATEROW_MSA
+ANY11I(InterpolateRow_Any_MSA, InterpolateRow_MSA, uint8_t, uint8_t, 1, 1, 31)
+#endif
+#ifdef HAS_INTERPOLATEROW_LSX
+ANY11I(InterpolateRow_Any_LSX, InterpolateRow_LSX, uint8_t, uint8_t, 1, 1, 31)
+#endif
+
+#ifdef HAS_INTERPOLATEROW_16_NEON
+ANY11I(InterpolateRow_16_Any_NEON,
+       InterpolateRow_16_NEON,
+       uint16_t,
+       uint16_t,
+       1,
+       1,
+       7)
+#endif
+#undef ANY11I
+
+// Any 1 to 1 interpolate with scale param
+#define ANY11IS(NAMEANY, ANY_SIMD, TD, TS, SBPP, BPP, MASK)                \
+  void NAMEANY(TD* dst_ptr, const TS* src_ptr, ptrdiff_t src_stride,       \
+               int scale, int width, int source_y_fraction) {              \
+    SIMD_ALIGNED(TS temps[64 * 2]);                                        \
+    SIMD_ALIGNED(TD tempd[64]);                                            \
+    memset(temps, 0, sizeof(temps)); /* for msan */                        \
+    int r = width & MASK;                                                  \
+    int n = width & ~MASK;                                                 \
+    if (n > 0) {                                                           \
+      ANY_SIMD(dst_ptr, src_ptr, src_stride, scale, n, source_y_fraction); \
+    }                                                                      \
+    memcpy(temps, src_ptr + n * SBPP, r * SBPP * sizeof(TS));              \
+    if (source_y_fraction) {                                               \
+      memcpy(temps + 64, src_ptr + src_stride + n * SBPP,                  \
+             r * SBPP * sizeof(TS));                                       \
+    }                                                                      \
+    ANY_SIMD(tempd, temps, 64, scale, MASK + 1, source_y_fraction);        \
+    memcpy(dst_ptr + n * BPP, tempd, r * BPP * sizeof(TD));                \
+  }
+
+#ifdef HAS_INTERPOLATEROW_16TO8_NEON
+ANY11IS(InterpolateRow_16To8_Any_NEON,
+        InterpolateRow_16To8_NEON,
+        uint8_t,
+        uint16_t,
+        1,
+        1,
+        7)
+#endif
+#ifdef HAS_INTERPOLATEROW_16TO8_AVX2
+ANY11IS(InterpolateRow_16To8_Any_AVX2,
+        InterpolateRow_16To8_AVX2,
+        uint8_t,
+        uint16_t,
+        1,
+        1,
+        31)
+#endif
+
+#undef ANY11IS
+
+// Any 1 to 1 mirror.
+#define ANY11M(NAMEANY, ANY_SIMD, BPP, MASK)                              \
+  void NAMEANY(const uint8_t* src_ptr, uint8_t* dst_ptr, int width) {     \
+    SIMD_ALIGNED(uint8_t temp[64 * 2]);                                   \
+    memset(temp, 0, 64); /* for msan */                                   \
+    int r = width & MASK;                                                 \
+    int n = width & ~MASK;                                                \
+    if (n > 0) {                                                          \
+      ANY_SIMD(src_ptr + r * BPP, dst_ptr, n);                            \
+    }                                                                     \
+    memcpy(temp, src_ptr, r* BPP);                                        \
+    ANY_SIMD(temp, temp + 64, MASK + 1);                                  \
+    memcpy(dst_ptr + n * BPP, temp + 64 + (MASK + 1 - r) * BPP, r * BPP); \
+  }
+
+#ifdef HAS_MIRRORROW_AVX2
+ANY11M(MirrorRow_Any_AVX2, MirrorRow_AVX2, 1, 31)
+#endif
+#ifdef HAS_MIRRORROW_SSSE3
+ANY11M(MirrorRow_Any_SSSE3, MirrorRow_SSSE3, 1, 15)
+#endif
+#ifdef HAS_MIRRORROW_NEON
+ANY11M(MirrorRow_Any_NEON, MirrorRow_NEON, 1, 31)
+#endif
+#ifdef HAS_MIRRORROW_MSA
+ANY11M(MirrorRow_Any_MSA, MirrorRow_MSA, 1, 63)
+#endif
+#ifdef HAS_MIRRORROW_LASX
+ANY11M(MirrorRow_Any_LASX, MirrorRow_LASX, 1, 63)
+#endif
+#ifdef HAS_MIRRORUVROW_AVX2
+ANY11M(MirrorUVRow_Any_AVX2, MirrorUVRow_AVX2, 2, 15)
+#endif
+#ifdef HAS_MIRRORUVROW_SSSE3
+ANY11M(MirrorUVRow_Any_SSSE3, MirrorUVRow_SSSE3, 2, 7)
+#endif
+#ifdef HAS_MIRRORUVROW_NEON
+ANY11M(MirrorUVRow_Any_NEON, MirrorUVRow_NEON, 2, 31)
+#endif
+#ifdef HAS_MIRRORUVROW_MSA
+ANY11M(MirrorUVRow_Any_MSA, MirrorUVRow_MSA, 2, 7)
+#endif
+#ifdef HAS_MIRRORUVROW_LASX
+ANY11M(MirrorUVRow_Any_LASX, MirrorUVRow_LASX, 2, 15)
+#endif
+#ifdef HAS_ARGBMIRRORROW_AVX2
+ANY11M(ARGBMirrorRow_Any_AVX2, ARGBMirrorRow_AVX2, 4, 7)
+#endif
+#ifdef HAS_ARGBMIRRORROW_SSE2
+ANY11M(ARGBMirrorRow_Any_SSE2, ARGBMirrorRow_SSE2, 4, 3)
+#endif
+#ifdef HAS_ARGBMIRRORROW_NEON
+ANY11M(ARGBMirrorRow_Any_NEON, ARGBMirrorRow_NEON, 4, 7)
+#endif
+#ifdef HAS_ARGBMIRRORROW_MSA
+ANY11M(ARGBMirrorRow_Any_MSA, ARGBMirrorRow_MSA, 4, 15)
+#endif
+#ifdef HAS_ARGBMIRRORROW_LASX
+ANY11M(ARGBMirrorRow_Any_LASX, ARGBMirrorRow_LASX, 4, 15)
+#endif
+#ifdef HAS_RGB24MIRRORROW_SSSE3
+ANY11M(RGB24MirrorRow_Any_SSSE3, RGB24MirrorRow_SSSE3, 3, 15)
+#endif
+#ifdef HAS_RGB24MIRRORROW_NEON
+ANY11M(RGB24MirrorRow_Any_NEON, RGB24MirrorRow_NEON, 3, 15)
+#endif
+#undef ANY11M
+
+// Any 1 plane. (memset)
+#define ANY1(NAMEANY, ANY_SIMD, T, BPP, MASK)        \
+  void NAMEANY(uint8_t* dst_ptr, T v32, int width) { \
+    SIMD_ALIGNED(uint8_t temp[64]);                  \
+    memset(temp, 0, 64); /* for msan */              \
+    int r = width & MASK;                            \
+    int n = width & ~MASK;                           \
+    if (n > 0) {                                     \
+      ANY_SIMD(dst_ptr, v32, n);                     \
+    }                                                \
+    ANY_SIMD(temp, v32, MASK + 1);                   \
+    memcpy(dst_ptr + n * BPP, temp, r * BPP);        \
+  }
+
+#ifdef HAS_SETROW_X86
+ANY1(SetRow_Any_X86, SetRow_X86, uint8_t, 1, 3)
+#endif
+#ifdef HAS_SETROW_NEON
+ANY1(SetRow_Any_NEON, SetRow_NEON, uint8_t, 1, 15)
+#endif
+#ifdef HAS_SETROW_LSX
+ANY1(SetRow_Any_LSX, SetRow_LSX, uint8_t, 1, 15)
+#endif
+#ifdef HAS_ARGBSETROW_NEON
+ANY1(ARGBSetRow_Any_NEON, ARGBSetRow_NEON, uint32_t, 4, 3)
+#endif
+#ifdef HAS_ARGBSETROW_MSA
+ANY1(ARGBSetRow_Any_MSA, ARGBSetRow_MSA, uint32_t, 4, 3)
+#endif
+#ifdef HAS_ARGBSETROW_LSX
+ANY1(ARGBSetRow_Any_LSX, ARGBSetRow_LSX, uint32_t, 4, 3)
+#endif
+#undef ANY1
+
+// Any 1 to 2.  Outputs UV planes.
+#define ANY12(NAMEANY, ANY_SIMD, UVSHIFT, BPP, DUVSHIFT, MASK)          \
+  void NAMEANY(const uint8_t* src_ptr, uint8_t* dst_u, uint8_t* dst_v,  \
+               int width) {                                             \
+    SIMD_ALIGNED(uint8_t temp[128 * 3]);                                \
+    memset(temp, 0, 128); /* for msan */                                \
+    int r = width & MASK;                                               \
+    int n = width & ~MASK;                                              \
+    if (n > 0) {                                                        \
+      ANY_SIMD(src_ptr, dst_u, dst_v, n);                               \
+    }                                                                   \
+    memcpy(temp, src_ptr + (n >> UVSHIFT) * BPP, SS(r, UVSHIFT) * BPP); \
+    ANY_SIMD(temp, temp + 128, temp + 256, MASK + 1);                   \
+    memcpy(dst_u + (n >> DUVSHIFT), temp + 128, SS(r, DUVSHIFT));       \
+    memcpy(dst_v + (n >> DUVSHIFT), temp + 256, SS(r, DUVSHIFT));       \
+  }
+
+#ifdef HAS_SPLITUVROW_SSE2
+ANY12(SplitUVRow_Any_SSE2, SplitUVRow_SSE2, 0, 2, 0, 15)
+#endif
+#ifdef HAS_SPLITUVROW_AVX2
+ANY12(SplitUVRow_Any_AVX2, SplitUVRow_AVX2, 0, 2, 0, 31)
+#endif
+#ifdef HAS_SPLITUVROW_NEON
+ANY12(SplitUVRow_Any_NEON, SplitUVRow_NEON, 0, 2, 0, 15)
+#endif
+#ifdef HAS_SPLITUVROW_MSA
+ANY12(SplitUVRow_Any_MSA, SplitUVRow_MSA, 0, 2, 0, 31)
+#endif
+#ifdef HAS_SPLITUVROW_LSX
+ANY12(SplitUVRow_Any_LSX, SplitUVRow_LSX, 0, 2, 0, 31)
+#endif
+#ifdef HAS_ARGBTOUV444ROW_SSSE3
+ANY12(ARGBToUV444Row_Any_SSSE3, ARGBToUV444Row_SSSE3, 0, 4, 0, 15)
+#endif
+#ifdef HAS_YUY2TOUV422ROW_AVX2
+ANY12(YUY2ToUV422Row_Any_AVX2, YUY2ToUV422Row_AVX2, 1, 4, 1, 31)
+ANY12(UYVYToUV422Row_Any_AVX2, UYVYToUV422Row_AVX2, 1, 4, 1, 31)
+#endif
+#ifdef HAS_YUY2TOUV422ROW_SSE2
+ANY12(YUY2ToUV422Row_Any_SSE2, YUY2ToUV422Row_SSE2, 1, 4, 1, 15)
+ANY12(UYVYToUV422Row_Any_SSE2, UYVYToUV422Row_SSE2, 1, 4, 1, 15)
+#endif
+#ifdef HAS_YUY2TOUV422ROW_NEON
+ANY12(ARGBToUV444Row_Any_NEON, ARGBToUV444Row_NEON, 0, 4, 0, 7)
+ANY12(YUY2ToUV422Row_Any_NEON, YUY2ToUV422Row_NEON, 1, 4, 1, 15)
+ANY12(UYVYToUV422Row_Any_NEON, UYVYToUV422Row_NEON, 1, 4, 1, 15)
+#endif
+#ifdef HAS_YUY2TOUV422ROW_MSA
+ANY12(ARGBToUV444Row_Any_MSA, ARGBToUV444Row_MSA, 0, 4, 0, 15)
+ANY12(YUY2ToUV422Row_Any_MSA, YUY2ToUV422Row_MSA, 1, 4, 1, 31)
+ANY12(UYVYToUV422Row_Any_MSA, UYVYToUV422Row_MSA, 1, 4, 1, 31)
+#endif
+#ifdef HAS_YUY2TOUV422ROW_LASX
+ANY12(ARGBToUV444Row_Any_LASX, ARGBToUV444Row_LASX, 0, 4, 0, 31)
+ANY12(YUY2ToUV422Row_Any_LASX, YUY2ToUV422Row_LASX, 1, 4, 1, 31)
+ANY12(UYVYToUV422Row_Any_LASX, UYVYToUV422Row_LASX, 1, 4, 1, 31)
+#endif
+#undef ANY12
+
+// Any 2 16 bit planes with parameter to 1
+#define ANY12PT(NAMEANY, ANY_SIMD, T, BPP, MASK)                            \
+  void NAMEANY(const T* src_uv, T* dst_u, T* dst_v, int depth, int width) { \
+    SIMD_ALIGNED(T temp[16 * 4]);                                           \
+    memset(temp, 0, 16 * 4 * BPP); /* for msan */                           \
+    int r = width & MASK;                                                   \
+    int n = width & ~MASK;                                                  \
+    if (n > 0) {                                                            \
+      ANY_SIMD(src_uv, dst_u, dst_v, depth, n);                             \
+    }                                                                       \
+    memcpy(temp, src_uv + n * 2, r * BPP * 2);                              \
+    ANY_SIMD(temp, temp + 32, temp + 48, depth, MASK + 1);                  \
+    memcpy(dst_u + n, temp + 32, r * BPP);                                  \
+    memcpy(dst_v + n, temp + 48, r * BPP);                                  \
+  }
+
+#ifdef HAS_SPLITUVROW_16_AVX2
+ANY12PT(SplitUVRow_16_Any_AVX2, SplitUVRow_16_AVX2, uint16_t, 2, 15)
+#endif
+
+#ifdef HAS_SPLITUVROW_16_NEON
+ANY12PT(SplitUVRow_16_Any_NEON, SplitUVRow_16_NEON, uint16_t, 2, 7)
+#endif
+
+#undef ANY21CT
+
+// Any 1 to 3.  Outputs RGB planes.
+#define ANY13(NAMEANY, ANY_SIMD, BPP, MASK)                                \
+  void NAMEANY(const uint8_t* src_ptr, uint8_t* dst_r, uint8_t* dst_g,     \
+               uint8_t* dst_b, int width) {                                \
+    SIMD_ALIGNED(uint8_t temp[16 * 6]);                                    \
+    memset(temp, 0, 16 * 3); /* for msan */                                \
+    int r = width & MASK;                                                  \
+    int n = width & ~MASK;                                                 \
+    if (n > 0) {                                                           \
+      ANY_SIMD(src_ptr, dst_r, dst_g, dst_b, n);                           \
+    }                                                                      \
+    memcpy(temp, src_ptr + n * BPP, r * BPP);                              \
+    ANY_SIMD(temp, temp + 16 * 3, temp + 16 * 4, temp + 16 * 5, MASK + 1); \
+    memcpy(dst_r + n, temp + 16 * 3, r);                                   \
+    memcpy(dst_g + n, temp + 16 * 4, r);                                   \
+    memcpy(dst_b + n, temp + 16 * 5, r);                                   \
+  }
+
+#ifdef HAS_SPLITRGBROW_SSSE3
+ANY13(SplitRGBRow_Any_SSSE3, SplitRGBRow_SSSE3, 3, 15)
+#endif
+#ifdef HAS_SPLITRGBROW_NEON
+ANY13(SplitRGBRow_Any_NEON, SplitRGBRow_NEON, 3, 15)
+#endif
+#ifdef HAS_SPLITXRGBROW_SSE2
+ANY13(SplitXRGBRow_Any_SSE2, SplitXRGBRow_SSE2, 4, 7)
+#endif
+#ifdef HAS_SPLITXRGBROW_SSSE3
+ANY13(SplitXRGBRow_Any_SSSE3, SplitXRGBRow_SSSE3, 4, 7)
+#endif
+#ifdef HAS_SPLITXRGBROW_AVX2
+ANY13(SplitXRGBRow_Any_AVX2, SplitXRGBRow_AVX2, 4, 15)
+#endif
+#ifdef HAS_SPLITXRGBROW_NEON
+ANY13(SplitXRGBRow_Any_NEON, SplitXRGBRow_NEON, 4, 15)
+#endif
+
+// Any 1 to 4.  Outputs ARGB planes.
+#define ANY14(NAMEANY, ANY_SIMD, BPP, MASK)                                    \
+  void NAMEANY(const uint8_t* src_ptr, uint8_t* dst_r, uint8_t* dst_g,         \
+               uint8_t* dst_b, uint8_t* dst_a, int width) {                    \
+    SIMD_ALIGNED(uint8_t temp[16 * 8]);                                        \
+    memset(temp, 0, 16 * 4); /* for msan */                                    \
+    int r = width & MASK;                                                      \
+    int n = width & ~MASK;                                                     \
+    if (n > 0) {                                                               \
+      ANY_SIMD(src_ptr, dst_r, dst_g, dst_b, dst_a, n);                        \
+    }                                                                          \
+    memcpy(temp, src_ptr + n * BPP, r * BPP);                                  \
+    ANY_SIMD(temp, temp + 16 * 4, temp + 16 * 5, temp + 16 * 6, temp + 16 * 7, \
+             MASK + 1);                                                        \
+    memcpy(dst_r + n, temp + 16 * 4, r);                                       \
+    memcpy(dst_g + n, temp + 16 * 5, r);                                       \
+    memcpy(dst_b + n, temp + 16 * 6, r);                                       \
+    memcpy(dst_a + n, temp + 16 * 7, r);                                       \
+  }
+
+#ifdef HAS_SPLITARGBROW_SSE2
+ANY14(SplitARGBRow_Any_SSE2, SplitARGBRow_SSE2, 4, 7)
+#endif
+#ifdef HAS_SPLITARGBROW_SSSE3
+ANY14(SplitARGBRow_Any_SSSE3, SplitARGBRow_SSSE3, 4, 7)
+#endif
+#ifdef HAS_SPLITARGBROW_AVX2
+ANY14(SplitARGBRow_Any_AVX2, SplitARGBRow_AVX2, 4, 15)
+#endif
+#ifdef HAS_SPLITARGBROW_NEON
+ANY14(SplitARGBRow_Any_NEON, SplitARGBRow_NEON, 4, 15)
+#endif
+
+// Any 1 to 2 with source stride (2 rows of source).  Outputs UV planes.
+// 128 byte row allows for 32 avx ARGB pixels.
+#define ANY12S(NAMEANY, ANY_SIMD, UVSHIFT, BPP, MASK)                        \
+  void NAMEANY(const uint8_t* src_ptr, int src_stride, uint8_t* dst_u,       \
+               uint8_t* dst_v, int width) {                                  \
+    SIMD_ALIGNED(uint8_t temp[128 * 4]);                                     \
+    memset(temp, 0, 128 * 2); /* for msan */                                 \
+    int r = width & MASK;                                                    \
+    int n = width & ~MASK;                                                   \
+    if (n > 0) {                                                             \
+      ANY_SIMD(src_ptr, src_stride, dst_u, dst_v, n);                        \
+    }                                                                        \
+    memcpy(temp, src_ptr + (n >> UVSHIFT) * BPP, SS(r, UVSHIFT) * BPP);      \
+    memcpy(temp + 128, src_ptr + src_stride + (n >> UVSHIFT) * BPP,          \
+           SS(r, UVSHIFT) * BPP);                                            \
+    if ((width & 1) && UVSHIFT == 0) { /* repeat last pixel for subsample */ \
+      memcpy(temp + SS(r, UVSHIFT) * BPP, temp + SS(r, UVSHIFT) * BPP - BPP, \
+             BPP);                                                           \
+      memcpy(temp + 128 + SS(r, UVSHIFT) * BPP,                              \
+             temp + 128 + SS(r, UVSHIFT) * BPP - BPP, BPP);                  \
+    }                                                                        \
+    ANY_SIMD(temp, 128, temp + 256, temp + 384, MASK + 1);                   \
+    memcpy(dst_u + (n >> 1), temp + 256, SS(r, 1));                          \
+    memcpy(dst_v + (n >> 1), temp + 384, SS(r, 1));                          \
+  }
+
+#ifdef HAS_ARGBTOUVROW_AVX2
+ANY12S(ARGBToUVRow_Any_AVX2, ARGBToUVRow_AVX2, 0, 4, 31)
+#endif
+#ifdef HAS_ABGRTOUVROW_AVX2
+ANY12S(ABGRToUVRow_Any_AVX2, ABGRToUVRow_AVX2, 0, 4, 31)
+#endif
+#ifdef HAS_ARGBTOUVJROW_AVX2
+ANY12S(ARGBToUVJRow_Any_AVX2, ARGBToUVJRow_AVX2, 0, 4, 31)
+#endif
+#ifdef HAS_ARGBTOUVROW_SSSE3
+ANY12S(ARGBToUVRow_Any_SSSE3, ARGBToUVRow_SSSE3, 0, 4, 15)
+ANY12S(ARGBToUVJRow_Any_SSSE3, ARGBToUVJRow_SSSE3, 0, 4, 15)
+ANY12S(BGRAToUVRow_Any_SSSE3, BGRAToUVRow_SSSE3, 0, 4, 15)
+ANY12S(ABGRToUVRow_Any_SSSE3, ABGRToUVRow_SSSE3, 0, 4, 15)
+ANY12S(RGBAToUVRow_Any_SSSE3, RGBAToUVRow_SSSE3, 0, 4, 15)
+#endif
+#ifdef HAS_YUY2TOUVROW_AVX2
+ANY12S(YUY2ToUVRow_Any_AVX2, YUY2ToUVRow_AVX2, 1, 4, 31)
+ANY12S(UYVYToUVRow_Any_AVX2, UYVYToUVRow_AVX2, 1, 4, 31)
+#endif
+#ifdef HAS_YUY2TOUVROW_SSE2
+ANY12S(YUY2ToUVRow_Any_SSE2, YUY2ToUVRow_SSE2, 1, 4, 15)
+ANY12S(UYVYToUVRow_Any_SSE2, UYVYToUVRow_SSE2, 1, 4, 15)
+#endif
+#ifdef HAS_ARGBTOUVROW_NEON
+ANY12S(ARGBToUVRow_Any_NEON, ARGBToUVRow_NEON, 0, 4, 15)
+#endif
+#ifdef HAS_ARGBTOUVROW_MSA
+ANY12S(ARGBToUVRow_Any_MSA, ARGBToUVRow_MSA, 0, 4, 31)
+#endif
+#ifdef HAS_ARGBTOUVROW_LASX
+ANY12S(ARGBToUVRow_Any_LASX, ARGBToUVRow_LASX, 0, 4, 31)
+#endif
+#ifdef HAS_ARGBTOUVJROW_NEON
+ANY12S(ARGBToUVJRow_Any_NEON, ARGBToUVJRow_NEON, 0, 4, 15)
+#endif
+#ifdef HAS_ARGBTOUVJROW_MSA
+ANY12S(ARGBToUVJRow_Any_MSA, ARGBToUVJRow_MSA, 0, 4, 31)
+#endif
+#ifdef HAS_ARGBTOUVJROW_LSX
+ANY12S(ARGBToUVJRow_Any_LSX, ARGBToUVJRow_LSX, 0, 4, 15)
+#endif
+#ifdef HAS_ARGBTOUVJROW_LASX
+ANY12S(ARGBToUVJRow_Any_LASX, ARGBToUVJRow_LASX, 0, 4, 31)
+#endif
+#ifdef HAS_BGRATOUVROW_NEON
+ANY12S(BGRAToUVRow_Any_NEON, BGRAToUVRow_NEON, 0, 4, 15)
+#endif
+#ifdef HAS_BGRATOUVROW_MSA
+ANY12S(BGRAToUVRow_Any_MSA, BGRAToUVRow_MSA, 0, 4, 15)
+#endif
+#ifdef HAS_BGRATOUVROW_LSX
+ANY12S(BGRAToUVRow_Any_LSX, BGRAToUVRow_LSX, 0, 4, 15)
+#endif
+#ifdef HAS_ABGRTOUVROW_NEON
+ANY12S(ABGRToUVRow_Any_NEON, ABGRToUVRow_NEON, 0, 4, 15)
+#endif
+#ifdef HAS_ABGRTOUVROW_MSA
+ANY12S(ABGRToUVRow_Any_MSA, ABGRToUVRow_MSA, 0, 4, 15)
+#endif
+#ifdef HAS_ABGRTOUVROW_LSX
+ANY12S(ABGRToUVRow_Any_LSX, ABGRToUVRow_LSX, 0, 4, 15)
+#endif
+#ifdef HAS_RGBATOUVROW_NEON
+ANY12S(RGBAToUVRow_Any_NEON, RGBAToUVRow_NEON, 0, 4, 15)
+#endif
+#ifdef HAS_RGBATOUVROW_MSA
+ANY12S(RGBAToUVRow_Any_MSA, RGBAToUVRow_MSA, 0, 4, 15)
+#endif
+#ifdef HAS_RGBATOUVROW_LSX
+ANY12S(RGBAToUVRow_Any_LSX, RGBAToUVRow_LSX, 0, 4, 15)
+#endif
+#ifdef HAS_RGB24TOUVROW_NEON
+ANY12S(RGB24ToUVRow_Any_NEON, RGB24ToUVRow_NEON, 0, 3, 15)
+#endif
+#ifdef HAS_RGB24TOUVJROW_NEON
+ANY12S(RGB24ToUVJRow_Any_NEON, RGB24ToUVJRow_NEON, 0, 3, 15)
+#endif
+#ifdef HAS_RGB24TOUVROW_MSA
+ANY12S(RGB24ToUVRow_Any_MSA, RGB24ToUVRow_MSA, 0, 3, 15)
+#endif
+#ifdef HAS_RGB24TOUVROW_LSX
+ANY12S(RGB24ToUVRow_Any_LSX, RGB24ToUVRow_LSX, 0, 3, 15)
+#endif
+#ifdef HAS_RGB24TOUVROW_LASX
+ANY12S(RGB24ToUVRow_Any_LASX, RGB24ToUVRow_LASX, 0, 3, 31)
+#endif
+#ifdef HAS_RAWTOUVROW_NEON
+ANY12S(RAWToUVRow_Any_NEON, RAWToUVRow_NEON, 0, 3, 15)
+#endif
+#ifdef HAS_RAWTOUVJROW_NEON
+ANY12S(RAWToUVJRow_Any_NEON, RAWToUVJRow_NEON, 0, 3, 15)
+#endif
+#ifdef HAS_RAWTOUVROW_MSA
+ANY12S(RAWToUVRow_Any_MSA, RAWToUVRow_MSA, 0, 3, 15)
+#endif
+#ifdef HAS_RAWTOUVROW_LSX
+ANY12S(RAWToUVRow_Any_LSX, RAWToUVRow_LSX, 0, 3, 15)
+#endif
+#ifdef HAS_RAWTOUVROW_LASX
+ANY12S(RAWToUVRow_Any_LASX, RAWToUVRow_LASX, 0, 3, 31)
+#endif
+#ifdef HAS_RGB565TOUVROW_NEON
+ANY12S(RGB565ToUVRow_Any_NEON, RGB565ToUVRow_NEON, 0, 2, 15)
+#endif
+#ifdef HAS_RGB565TOUVROW_MSA
+ANY12S(RGB565ToUVRow_Any_MSA, RGB565ToUVRow_MSA, 0, 2, 15)
+#endif
+#ifdef HAS_RGB565TOUVROW_LSX
+ANY12S(RGB565ToUVRow_Any_LSX, RGB565ToUVRow_LSX, 0, 2, 15)
+#endif
+#ifdef HAS_RGB565TOUVROW_LASX
+ANY12S(RGB565ToUVRow_Any_LASX, RGB565ToUVRow_LASX, 0, 2, 31)
+#endif
+#ifdef HAS_ARGB1555TOUVROW_NEON
+ANY12S(ARGB1555ToUVRow_Any_NEON, ARGB1555ToUVRow_NEON, 0, 2, 15)
+#endif
+#ifdef HAS_ARGB1555TOUVROW_MSA
+ANY12S(ARGB1555ToUVRow_Any_MSA, ARGB1555ToUVRow_MSA, 0, 2, 15)
+#endif
+#ifdef HAS_ARGB1555TOUVROW_LSX
+ANY12S(ARGB1555ToUVRow_Any_LSX, ARGB1555ToUVRow_LSX, 0, 2, 15)
+#endif
+#ifdef HAS_ARGB1555TOUVROW_LASX
+ANY12S(ARGB1555ToUVRow_Any_LASX, ARGB1555ToUVRow_LASX, 0, 2, 31)
+#endif
+#ifdef HAS_ARGB4444TOUVROW_NEON
+ANY12S(ARGB4444ToUVRow_Any_NEON, ARGB4444ToUVRow_NEON, 0, 2, 15)
+#endif
+#ifdef HAS_YUY2TOUVROW_NEON
+ANY12S(YUY2ToUVRow_Any_NEON, YUY2ToUVRow_NEON, 1, 4, 15)
+#endif
+#ifdef HAS_UYVYTOUVROW_NEON
+ANY12S(UYVYToUVRow_Any_NEON, UYVYToUVRow_NEON, 1, 4, 15)
+#endif
+#ifdef HAS_YUY2TOUVROW_MSA
+ANY12S(YUY2ToUVRow_Any_MSA, YUY2ToUVRow_MSA, 1, 4, 31)
+#endif
+#ifdef HAS_YUY2TOUVROW_LASX
+ANY12S(YUY2ToUVRow_Any_LASX, YUY2ToUVRow_LASX, 1, 4, 31)
+#endif
+#ifdef HAS_UYVYTOUVROW_MSA
+ANY12S(UYVYToUVRow_Any_MSA, UYVYToUVRow_MSA, 1, 4, 31)
+#endif
+#ifdef HAS_UYVYTOUVROW_LASX
+ANY12S(UYVYToUVRow_Any_LASX, UYVYToUVRow_LASX, 1, 4, 31)
+#endif
+#undef ANY12S
+
+// Any 1 to 1 with source stride (2 rows of source).  Outputs UV plane.
+// 128 byte row allows for 32 avx ARGB pixels.
+#define ANY11S(NAMEANY, ANY_SIMD, UVSHIFT, BPP, MASK)                        \
+  void NAMEANY(const uint8_t* src_ptr, int src_stride, uint8_t* dst_vu,      \
+               int width) {                                                  \
+    SIMD_ALIGNED(uint8_t temp[128 * 3]);                                     \
+    memset(temp, 0, 128 * 2); /* for msan */                                 \
+    int r = width & MASK;                                                    \
+    int n = width & ~MASK;                                                   \
+    if (n > 0) {                                                             \
+      ANY_SIMD(src_ptr, src_stride, dst_vu, n);                              \
+    }                                                                        \
+    memcpy(temp, src_ptr + (n >> UVSHIFT) * BPP, SS(r, UVSHIFT) * BPP);      \
+    memcpy(temp + 128, src_ptr + src_stride + (n >> UVSHIFT) * BPP,          \
+           SS(r, UVSHIFT) * BPP);                                            \
+    if ((width & 1) && UVSHIFT == 0) { /* repeat last pixel for subsample */ \
+      memcpy(temp + SS(r, UVSHIFT) * BPP, temp + SS(r, UVSHIFT) * BPP - BPP, \
+             BPP);                                                           \
+      memcpy(temp + 128 + SS(r, UVSHIFT) * BPP,                              \
+             temp + 128 + SS(r, UVSHIFT) * BPP - BPP, BPP);                  \
+    }                                                                        \
+    ANY_SIMD(temp, 128, temp + 256, MASK + 1);                               \
+    memcpy(dst_vu + (n >> 1) * 2, temp + 256, SS(r, 1) * 2);                 \
+  }
+
+#ifdef HAS_AYUVTOVUROW_NEON
+ANY11S(AYUVToUVRow_Any_NEON, AYUVToUVRow_NEON, 0, 4, 15)
+ANY11S(AYUVToVURow_Any_NEON, AYUVToVURow_NEON, 0, 4, 15)
+#endif
+#undef ANY11S
+
+#define ANYDETILE(NAMEANY, ANY_SIMD, MASK)                                  \
+  void NAMEANY(const uint8_t* src, ptrdiff_t src_tile_stride, uint8_t* dst, \
+               int width) {                                                 \
+    SIMD_ALIGNED(uint8_t temp[16 * 2]);                                     \
+    memset(temp, 0, 16); /* for msan */                                     \
+    int r = width & MASK;                                                   \
+    int n = width & ~MASK;                                                  \
+    if (n > 0) {                                                            \
+      ANY_SIMD(src, src_tile_stride, dst, n);                               \
+    }                                                                       \
+    memcpy(temp, src + (n / 16) * src_tile_stride, r);                      \
+    ANY_SIMD(temp, src_tile_stride, temp + 16, MASK + 1);                   \
+    memcpy(dst + n, temp + 16, r);                                          \
+  }
+
+#ifdef HAS_DETILEROW_NEON
+ANYDETILE(DetileRow_Any_NEON, DetileRow_NEON, 15)
+#endif
+#ifdef HAS_DETILEROW_SSE2
+ANYDETILE(DetileRow_Any_SSE2, DetileRow_SSE2, 15)
+#endif
+
+#define ANYDETILESPLITUV(NAMEANY, ANY_SIMD, MASK)                \
+  void NAMEANY(const uint8_t* src_uv, ptrdiff_t src_tile_stride, \
+               uint8_t* dst_u, uint8_t* dst_v, int width) {      \
+    SIMD_ALIGNED(uint8_t temp[16 * 2]);                          \
+    memset(temp, 0, 16 * 2); /* for msan */                      \
+    int r = width & MASK;                                        \
+    int n = width & ~MASK;                                       \
+    if (n > 0) {                                                 \
+      ANY_SIMD(src_uv, src_tile_stride, dst_u, dst_v, n);        \
+    }                                                            \
+    memcpy(temp, src_uv + (n / 16) * src_tile_stride, r);        \
+    ANY_SIMD(temp, src_tile_stride, temp + 16, temp + 24, r);    \
+    memcpy(dst_u + n / 2, temp + 16, (r + 1) / 2);               \
+    memcpy(dst_v + n / 2, temp + 24, (r + 1) / 2);               \
+  }
+
+#ifdef HAS_DETILESPLITUVROW_NEON
+ANYDETILESPLITUV(DetileSplitUVRow_Any_NEON, DetileSplitUVRow_NEON, 15)
+#endif
+#ifdef HAS_DETILESPLITUVROW_SSSE3
+ANYDETILESPLITUV(DetileSplitUVRow_Any_SSSE3, DetileSplitUVRow_SSSE3, 15)
+#endif
+
+#ifdef __cplusplus
+}  // extern "C"
+}  // namespace libyuv
+#endif
diff --git a/3rdparty/libyuv/src/source/row_common.cc b/3rdparty/libyuv/src/source/row_common.cc
new file mode 100644
index 00000000..150f48db
--- /dev/null
+++ b/3rdparty/libyuv/src/source/row_common.cc
@@ -0,0 +1,4338 @@
+/*
+ *  Copyright 2011 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include "libyuv/row.h"
+
+#include <assert.h>
+#include <string.h>  // For memcpy and memset.
+
+#include "libyuv/basic_types.h"
+#include "libyuv/convert_argb.h"  // For kYuvI601Constants
+
+#ifdef __cplusplus
+namespace libyuv {
+extern "C" {
+#endif
+
+// This macro controls YUV to RGB using unsigned math to extend range of
+// YUV to RGB coefficients to 0 to 4 instead of 0 to 2 for more accuracy on B:
+// LIBYUV_UNLIMITED_DATA
+
+// Macros to enable unlimited data for each colorspace
+// LIBYUV_UNLIMITED_BT601
+// LIBYUV_UNLIMITED_BT709
+// LIBYUV_UNLIMITED_BT2020
+
+// The following macro from row_win makes the C code match the row_win code,
+// which is 7 bit fixed point for ARGBToI420:
+#if !defined(LIBYUV_BIT_EXACT) && !defined(LIBYUV_DISABLE_X86) && \
+    defined(_MSC_VER) && !defined(__clang__) &&                   \
+    (defined(_M_IX86) || defined(_M_X64))
+#define LIBYUV_RGB7 1
+#endif
+
+#if !defined(LIBYUV_BIT_EXACT) && (defined(__x86_64__) || defined(_M_X64) || \
+                                   defined(__i386__) || defined(_M_IX86))
+#define LIBYUV_ARGBTOUV_PAVGB 1
+#define LIBYUV_RGBTOU_TRUNCATE 1
+#define LIBYUV_ATTENUATE_DUP 1
+#endif
+#if defined(LIBYUV_BIT_EXACT)
+#define LIBYUV_UNATTENUATE_DUP 1
+#endif
+
+// llvm x86 is poor at ternary operator, so use branchless min/max.
+
+#define USE_BRANCHLESS 1
+#if USE_BRANCHLESS
+static __inline int32_t clamp0(int32_t v) {
+  return -(v >= 0) & v;
+}
+// TODO(fbarchard): make clamp255 preserve negative values.
+static __inline int32_t clamp255(int32_t v) {
+  return (-(v >= 255) | v) & 255;
+}
+
+static __inline int32_t clamp1023(int32_t v) {
+  return (-(v >= 1023) | v) & 1023;
+}
+
+// clamp to max
+static __inline int32_t ClampMax(int32_t v, int32_t max) {
+  return (-(v >= max) | v) & max;
+}
+
+static __inline uint32_t Abs(int32_t v) {
+  int m = -(v < 0);
+  return (v + m) ^ m;
+}
+#else   // USE_BRANCHLESS
+static __inline int32_t clamp0(int32_t v) {
+  return (v < 0) ? 0 : v;
+}
+
+static __inline int32_t clamp255(int32_t v) {
+  return (v > 255) ? 255 : v;
+}
+
+static __inline int32_t clamp1023(int32_t v) {
+  return (v > 1023) ? 1023 : v;
+}
+
+static __inline int32_t ClampMax(int32_t v, int32_t max) {
+  return (v > max) ? max : v;
+}
+
+static __inline uint32_t Abs(int32_t v) {
+  return (v < 0) ? -v : v;
+}
+#endif  // USE_BRANCHLESS
+static __inline uint32_t Clamp(int32_t val) {
+  int v = clamp0(val);
+  return (uint32_t)(clamp255(v));
+}
+
+static __inline uint32_t Clamp10(int32_t val) {
+  int v = clamp0(val);
+  return (uint32_t)(clamp1023(v));
+}
+
+// Little Endian
+#if defined(__x86_64__) || defined(_M_X64) || defined(__i386__) || \
+    defined(_M_IX86) || defined(__arm__) || defined(_M_ARM) ||     \
+    (defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)
+#define WRITEWORD(p, v) *(uint32_t*)(p) = v
+#else
+static inline void WRITEWORD(uint8_t* p, uint32_t v) {
+  p[0] = (uint8_t)(v & 255);
+  p[1] = (uint8_t)((v >> 8) & 255);
+  p[2] = (uint8_t)((v >> 16) & 255);
+  p[3] = (uint8_t)((v >> 24) & 255);
+}
+#endif
+
+void RGB24ToARGBRow_C(const uint8_t* src_rgb24, uint8_t* dst_argb, int width) {
+  int x;
+  for (x = 0; x < width; ++x) {
+    uint8_t b = src_rgb24[0];
+    uint8_t g = src_rgb24[1];
+    uint8_t r = src_rgb24[2];
+    dst_argb[0] = b;
+    dst_argb[1] = g;
+    dst_argb[2] = r;
+    dst_argb[3] = 255u;
+    dst_argb += 4;
+    src_rgb24 += 3;
+  }
+}
+
+void RAWToARGBRow_C(const uint8_t* src_raw, uint8_t* dst_argb, int width) {
+  int x;
+  for (x = 0; x < width; ++x) {
+    uint8_t r = src_raw[0];
+    uint8_t g = src_raw[1];
+    uint8_t b = src_raw[2];
+    dst_argb[0] = b;
+    dst_argb[1] = g;
+    dst_argb[2] = r;
+    dst_argb[3] = 255u;
+    dst_argb += 4;
+    src_raw += 3;
+  }
+}
+
+void RAWToRGBARow_C(const uint8_t* src_raw, uint8_t* dst_rgba, int width) {
+  int x;
+  for (x = 0; x < width; ++x) {
+    uint8_t r = src_raw[0];
+    uint8_t g = src_raw[1];
+    uint8_t b = src_raw[2];
+    dst_rgba[0] = 255u;
+    dst_rgba[1] = b;
+    dst_rgba[2] = g;
+    dst_rgba[3] = r;
+    dst_rgba += 4;
+    src_raw += 3;
+  }
+}
+
+void RAWToRGB24Row_C(const uint8_t* src_raw, uint8_t* dst_rgb24, int width) {
+  int x;
+  for (x = 0; x < width; ++x) {
+    uint8_t r = src_raw[0];
+    uint8_t g = src_raw[1];
+    uint8_t b = src_raw[2];
+    dst_rgb24[0] = b;
+    dst_rgb24[1] = g;
+    dst_rgb24[2] = r;
+    dst_rgb24 += 3;
+    src_raw += 3;
+  }
+}
+
+void RGB565ToARGBRow_C(const uint8_t* src_rgb565,
+                       uint8_t* dst_argb,
+                       int width) {
+  int x;
+  for (x = 0; x < width; ++x) {
+    uint8_t b = src_rgb565[0] & 0x1f;
+    uint8_t g = (src_rgb565[0] >> 5) | ((src_rgb565[1] & 0x07) << 3);
+    uint8_t r = src_rgb565[1] >> 3;
+    dst_argb[0] = (b << 3) | (b >> 2);
+    dst_argb[1] = (g << 2) | (g >> 4);
+    dst_argb[2] = (r << 3) | (r >> 2);
+    dst_argb[3] = 255u;
+    dst_argb += 4;
+    src_rgb565 += 2;
+  }
+}
+
+void ARGB1555ToARGBRow_C(const uint8_t* src_argb1555,
+                         uint8_t* dst_argb,
+                         int width) {
+  int x;
+  for (x = 0; x < width; ++x) {
+    uint8_t b = src_argb1555[0] & 0x1f;
+    uint8_t g = (src_argb1555[0] >> 5) | ((src_argb1555[1] & 0x03) << 3);
+    uint8_t r = (src_argb1555[1] & 0x7c) >> 2;
+    uint8_t a = src_argb1555[1] >> 7;
+    dst_argb[0] = (b << 3) | (b >> 2);
+    dst_argb[1] = (g << 3) | (g >> 2);
+    dst_argb[2] = (r << 3) | (r >> 2);
+    dst_argb[3] = -a;
+    dst_argb += 4;
+    src_argb1555 += 2;
+  }
+}
+
+void ARGB4444ToARGBRow_C(const uint8_t* src_argb4444,
+                         uint8_t* dst_argb,
+                         int width) {
+  int x;
+  for (x = 0; x < width; ++x) {
+    uint8_t b = src_argb4444[0] & 0x0f;
+    uint8_t g = src_argb4444[0] >> 4;
+    uint8_t r = src_argb4444[1] & 0x0f;
+    uint8_t a = src_argb4444[1] >> 4;
+    dst_argb[0] = (b << 4) | b;
+    dst_argb[1] = (g << 4) | g;
+    dst_argb[2] = (r << 4) | r;
+    dst_argb[3] = (a << 4) | a;
+    dst_argb += 4;
+    src_argb4444 += 2;
+  }
+}
+
+void AR30ToARGBRow_C(const uint8_t* src_ar30, uint8_t* dst_argb, int width) {
+  int x;
+  for (x = 0; x < width; ++x) {
+    uint32_t ar30;
+    memcpy(&ar30, src_ar30, sizeof ar30);
+    uint32_t b = (ar30 >> 2) & 0xff;
+    uint32_t g = (ar30 >> 12) & 0xff;
+    uint32_t r = (ar30 >> 22) & 0xff;
+    uint32_t a = (ar30 >> 30) * 0x55;  // Replicate 2 bits to 8 bits.
+    *(uint32_t*)(dst_argb) = b | (g << 8) | (r << 16) | (a << 24);
+    dst_argb += 4;
+    src_ar30 += 4;
+  }
+}
+
+void AR30ToABGRRow_C(const uint8_t* src_ar30, uint8_t* dst_abgr, int width) {
+  int x;
+  for (x = 0; x < width; ++x) {
+    uint32_t ar30;
+    memcpy(&ar30, src_ar30, sizeof ar30);
+    uint32_t b = (ar30 >> 2) & 0xff;
+    uint32_t g = (ar30 >> 12) & 0xff;
+    uint32_t r = (ar30 >> 22) & 0xff;
+    uint32_t a = (ar30 >> 30) * 0x55;  // Replicate 2 bits to 8 bits.
+    *(uint32_t*)(dst_abgr) = r | (g << 8) | (b << 16) | (a << 24);
+    dst_abgr += 4;
+    src_ar30 += 4;
+  }
+}
+
+void AR30ToAB30Row_C(const uint8_t* src_ar30, uint8_t* dst_ab30, int width) {
+  int x;
+  for (x = 0; x < width; ++x) {
+    uint32_t ar30;
+    memcpy(&ar30, src_ar30, sizeof ar30);
+    uint32_t b = ar30 & 0x3ff;
+    uint32_t ga = ar30 & 0xc00ffc00;
+    uint32_t r = (ar30 >> 20) & 0x3ff;
+    *(uint32_t*)(dst_ab30) = r | ga | (b << 20);
+    dst_ab30 += 4;
+    src_ar30 += 4;
+  }
+}
+
+void ARGBToRGB24Row_C(const uint8_t* src_argb, uint8_t* dst_rgb, int width) {
+  int x;
+  for (x = 0; x < width; ++x) {
+    uint8_t b = src_argb[0];
+    uint8_t g = src_argb[1];
+    uint8_t r = src_argb[2];
+    dst_rgb[0] = b;
+    dst_rgb[1] = g;
+    dst_rgb[2] = r;
+    dst_rgb += 3;
+    src_argb += 4;
+  }
+}
+
+void ARGBToRAWRow_C(const uint8_t* src_argb, uint8_t* dst_rgb, int width) {
+  int x;
+  for (x = 0; x < width; ++x) {
+    uint8_t b = src_argb[0];
+    uint8_t g = src_argb[1];
+    uint8_t r = src_argb[2];
+    dst_rgb[0] = r;
+    dst_rgb[1] = g;
+    dst_rgb[2] = b;
+    dst_rgb += 3;
+    src_argb += 4;
+  }
+}
+
+void ARGBToRGB565Row_C(const uint8_t* src_argb, uint8_t* dst_rgb, int width) {
+  int x;
+  for (x = 0; x < width - 1; x += 2) {
+    uint8_t b0 = src_argb[0] >> 3;
+    uint8_t g0 = src_argb[1] >> 2;
+    uint8_t r0 = src_argb[2] >> 3;
+    uint8_t b1 = src_argb[4] >> 3;
+    uint8_t g1 = src_argb[5] >> 2;
+    uint8_t r1 = src_argb[6] >> 3;
+    WRITEWORD(dst_rgb, b0 | (g0 << 5) | (r0 << 11) | (b1 << 16) | (g1 << 21) |
+                           (r1 << 27));
+    dst_rgb += 4;
+    src_argb += 8;
+  }
+  if (width & 1) {
+    uint8_t b0 = src_argb[0] >> 3;
+    uint8_t g0 = src_argb[1] >> 2;
+    uint8_t r0 = src_argb[2] >> 3;
+    *(uint16_t*)(dst_rgb) = b0 | (g0 << 5) | (r0 << 11);
+  }
+}
+
+// dither4 is a row of 4 values from 4x4 dither matrix.
+// The 4x4 matrix contains values to increase RGB.  When converting to
+// fewer bits (565) this provides an ordered dither.
+// The order in the 4x4 matrix in first byte is upper left.
+// The 4 values are passed as an int, then referenced as an array, so
+// endian will not affect order of the original matrix.  But the dither4
+// will containing the first pixel in the lower byte for little endian
+// or the upper byte for big endian.
+void ARGBToRGB565DitherRow_C(const uint8_t* src_argb,
+                             uint8_t* dst_rgb,
+                             const uint32_t dither4,
+                             int width) {
+  int x;
+  for (x = 0; x < width - 1; x += 2) {
+    int dither0 = ((const unsigned char*)(&dither4))[x & 3];
+    int dither1 = ((const unsigned char*)(&dither4))[(x + 1) & 3];
+    uint8_t b0 = clamp255(src_argb[0] + dither0) >> 3;
+    uint8_t g0 = clamp255(src_argb[1] + dither0) >> 2;
+    uint8_t r0 = clamp255(src_argb[2] + dither0) >> 3;
+    uint8_t b1 = clamp255(src_argb[4] + dither1) >> 3;
+    uint8_t g1 = clamp255(src_argb[5] + dither1) >> 2;
+    uint8_t r1 = clamp255(src_argb[6] + dither1) >> 3;
+    *(uint16_t*)(dst_rgb + 0) = b0 | (g0 << 5) | (r0 << 11);
+    *(uint16_t*)(dst_rgb + 2) = b1 | (g1 << 5) | (r1 << 11);
+    dst_rgb += 4;
+    src_argb += 8;
+  }
+  if (width & 1) {
+    int dither0 = ((const unsigned char*)(&dither4))[(width - 1) & 3];
+    uint8_t b0 = clamp255(src_argb[0] + dither0) >> 3;
+    uint8_t g0 = clamp255(src_argb[1] + dither0) >> 2;
+    uint8_t r0 = clamp255(src_argb[2] + dither0) >> 3;
+    *(uint16_t*)(dst_rgb) = b0 | (g0 << 5) | (r0 << 11);
+  }
+}
+
+void ARGBToARGB1555Row_C(const uint8_t* src_argb, uint8_t* dst_rgb, int width) {
+  int x;
+  for (x = 0; x < width - 1; x += 2) {
+    uint8_t b0 = src_argb[0] >> 3;
+    uint8_t g0 = src_argb[1] >> 3;
+    uint8_t r0 = src_argb[2] >> 3;
+    uint8_t a0 = src_argb[3] >> 7;
+    uint8_t b1 = src_argb[4] >> 3;
+    uint8_t g1 = src_argb[5] >> 3;
+    uint8_t r1 = src_argb[6] >> 3;
+    uint8_t a1 = src_argb[7] >> 7;
+    *(uint16_t*)(dst_rgb + 0) = b0 | (g0 << 5) | (r0 << 10) | (a0 << 15);
+    *(uint16_t*)(dst_rgb + 2) = b1 | (g1 << 5) | (r1 << 10) | (a1 << 15);
+    dst_rgb += 4;
+    src_argb += 8;
+  }
+  if (width & 1) {
+    uint8_t b0 = src_argb[0] >> 3;
+    uint8_t g0 = src_argb[1] >> 3;
+    uint8_t r0 = src_argb[2] >> 3;
+    uint8_t a0 = src_argb[3] >> 7;
+    *(uint16_t*)(dst_rgb) = b0 | (g0 << 5) | (r0 << 10) | (a0 << 15);
+  }
+}
+
+void ARGBToARGB4444Row_C(const uint8_t* src_argb, uint8_t* dst_rgb, int width) {
+  int x;
+  for (x = 0; x < width - 1; x += 2) {
+    uint8_t b0 = src_argb[0] >> 4;
+    uint8_t g0 = src_argb[1] >> 4;
+    uint8_t r0 = src_argb[2] >> 4;
+    uint8_t a0 = src_argb[3] >> 4;
+    uint8_t b1 = src_argb[4] >> 4;
+    uint8_t g1 = src_argb[5] >> 4;
+    uint8_t r1 = src_argb[6] >> 4;
+    uint8_t a1 = src_argb[7] >> 4;
+    *(uint16_t*)(dst_rgb + 0) = b0 | (g0 << 4) | (r0 << 8) | (a0 << 12);
+    *(uint16_t*)(dst_rgb + 2) = b1 | (g1 << 4) | (r1 << 8) | (a1 << 12);
+    dst_rgb += 4;
+    src_argb += 8;
+  }
+  if (width & 1) {
+    uint8_t b0 = src_argb[0] >> 4;
+    uint8_t g0 = src_argb[1] >> 4;
+    uint8_t r0 = src_argb[2] >> 4;
+    uint8_t a0 = src_argb[3] >> 4;
+    *(uint16_t*)(dst_rgb) = b0 | (g0 << 4) | (r0 << 8) | (a0 << 12);
+  }
+}
+
+void ABGRToAR30Row_C(const uint8_t* src_abgr, uint8_t* dst_ar30, int width) {
+  int x;
+  for (x = 0; x < width; ++x) {
+    uint32_t b0 = (src_abgr[0] >> 6) | ((uint32_t)(src_abgr[0]) << 2);
+    uint32_t g0 = (src_abgr[1] >> 6) | ((uint32_t)(src_abgr[1]) << 2);
+    uint32_t r0 = (src_abgr[2] >> 6) | ((uint32_t)(src_abgr[2]) << 2);
+    uint32_t a0 = (src_abgr[3] >> 6);
+    *(uint32_t*)(dst_ar30) = r0 | (g0 << 10) | (b0 << 20) | (a0 << 30);
+    dst_ar30 += 4;
+    src_abgr += 4;
+  }
+}
+
+void ARGBToAR30Row_C(const uint8_t* src_argb, uint8_t* dst_ar30, int width) {
+  int x;
+  for (x = 0; x < width; ++x) {
+    uint32_t b0 = (src_argb[0] >> 6) | ((uint32_t)(src_argb[0]) << 2);
+    uint32_t g0 = (src_argb[1] >> 6) | ((uint32_t)(src_argb[1]) << 2);
+    uint32_t r0 = (src_argb[2] >> 6) | ((uint32_t)(src_argb[2]) << 2);
+    uint32_t a0 = (src_argb[3] >> 6);
+    *(uint32_t*)(dst_ar30) = b0 | (g0 << 10) | (r0 << 20) | (a0 << 30);
+    dst_ar30 += 4;
+    src_argb += 4;
+  }
+}
+
+void ARGBToAR64Row_C(const uint8_t* src_argb, uint16_t* dst_ar64, int width) {
+  int x;
+  for (x = 0; x < width; ++x) {
+    dst_ar64[0] = src_argb[0] * 0x0101;
+    dst_ar64[1] = src_argb[1] * 0x0101;
+    dst_ar64[2] = src_argb[2] * 0x0101;
+    dst_ar64[3] = src_argb[3] * 0x0101;
+    dst_ar64 += 4;
+    src_argb += 4;
+  }
+}
+
+void ARGBToAB64Row_C(const uint8_t* src_argb, uint16_t* dst_ab64, int width) {
+  int x;
+  for (x = 0; x < width; ++x) {
+    dst_ab64[0] = src_argb[2] * 0x0101;
+    dst_ab64[1] = src_argb[1] * 0x0101;
+    dst_ab64[2] = src_argb[0] * 0x0101;
+    dst_ab64[3] = src_argb[3] * 0x0101;
+    dst_ab64 += 4;
+    src_argb += 4;
+  }
+}
+
+void AR64ToARGBRow_C(const uint16_t* src_ar64, uint8_t* dst_argb, int width) {
+  int x;
+  for (x = 0; x < width; ++x) {
+    dst_argb[0] = src_ar64[0] >> 8;
+    dst_argb[1] = src_ar64[1] >> 8;
+    dst_argb[2] = src_ar64[2] >> 8;
+    dst_argb[3] = src_ar64[3] >> 8;
+    dst_argb += 4;
+    src_ar64 += 4;
+  }
+}
+
+void AB64ToARGBRow_C(const uint16_t* src_ab64, uint8_t* dst_argb, int width) {
+  int x;
+  for (x = 0; x < width; ++x) {
+    dst_argb[0] = src_ab64[2] >> 8;
+    dst_argb[1] = src_ab64[1] >> 8;
+    dst_argb[2] = src_ab64[0] >> 8;
+    dst_argb[3] = src_ab64[3] >> 8;
+    dst_argb += 4;
+    src_ab64 += 4;
+  }
+}
+
+// TODO(fbarchard): Make shuffle compatible with SIMD versions
+void AR64ShuffleRow_C(const uint8_t* src_ar64,
+                      uint8_t* dst_ar64,
+                      const uint8_t* shuffler,
+                      int width) {
+  const uint16_t* src_ar64_16 = (const uint16_t*)src_ar64;
+  uint16_t* dst_ar64_16 = (uint16_t*)dst_ar64;
+  int index0 = shuffler[0] / 2;
+  int index1 = shuffler[2] / 2;
+  int index2 = shuffler[4] / 2;
+  int index3 = shuffler[6] / 2;
+  // Shuffle a row of AR64.
+  int x;
+  for (x = 0; x < width / 2; ++x) {
+    // To support in-place conversion.
+    uint16_t b = src_ar64_16[index0];
+    uint16_t g = src_ar64_16[index1];
+    uint16_t r = src_ar64_16[index2];
+    uint16_t a = src_ar64_16[index3];
+    dst_ar64_16[0] = b;
+    dst_ar64_16[1] = g;
+    dst_ar64_16[2] = r;
+    dst_ar64_16[3] = a;
+    src_ar64_16 += 4;
+    dst_ar64_16 += 4;
+  }
+}
+
+#ifdef LIBYUV_RGB7
+// Old 7 bit math for compatibility on unsupported platforms.
+static __inline int RGBToY(uint8_t r, uint8_t g, uint8_t b) {
+  return ((33 * r + 65 * g + 13 * b) >> 7) + 16;
+}
+#else
+// 8 bit
+// Intel SSE/AVX uses the following equivalent formula
+// 0x7e80 = (66 + 129 + 25) * -128 + 0x1000 (for +16) and 0x0080 for round.
+//  return (66 * ((int)r - 128) + 129 * ((int)g - 128) + 25 * ((int)b - 128) +
+//  0x7e80) >> 8;
+
+static __inline int RGBToY(uint8_t r, uint8_t g, uint8_t b) {
+  return (66 * r + 129 * g + 25 * b + 0x1080) >> 8;
+}
+#endif
+
+#define AVGB(a, b) (((a) + (b) + 1) >> 1)
+
+// LIBYUV_RGBTOU_TRUNCATE mimics x86 code that does not round.
+#ifdef LIBYUV_RGBTOU_TRUNCATE
+static __inline int RGBToU(uint8_t r, uint8_t g, uint8_t b) {
+  return (112 * b - 74 * g - 38 * r + 0x8000) >> 8;
+}
+static __inline int RGBToV(uint8_t r, uint8_t g, uint8_t b) {
+  return (112 * r - 94 * g - 18 * b + 0x8000) >> 8;
+}
+#else
+// TODO(fbarchard): Add rounding to x86 SIMD and use this
+static __inline int RGBToU(uint8_t r, uint8_t g, uint8_t b) {
+  return (112 * b - 74 * g - 38 * r + 0x8080) >> 8;
+}
+static __inline int RGBToV(uint8_t r, uint8_t g, uint8_t b) {
+  return (112 * r - 94 * g - 18 * b + 0x8080) >> 8;
+}
+#endif
+
+// LIBYUV_ARGBTOUV_PAVGB mimics x86 code that subsamples with 2 pavgb.
+#if !defined(LIBYUV_ARGBTOUV_PAVGB)
+static __inline int RGB2xToU(uint16_t r, uint16_t g, uint16_t b) {
+  return ((112 / 2) * b - (74 / 2) * g - (38 / 2) * r + 0x8080) >> 8;
+}
+static __inline int RGB2xToV(uint16_t r, uint16_t g, uint16_t b) {
+  return ((112 / 2) * r - (94 / 2) * g - (18 / 2) * b + 0x8080) >> 8;
+}
+#endif
+
+// ARGBToY_C and ARGBToUV_C
+// Intel version mimic SSE/AVX which does 2 pavgb
+#if LIBYUV_ARGBTOUV_PAVGB
+#define MAKEROWY(NAME, R, G, B, BPP)                                       \
+  void NAME##ToYRow_C(const uint8_t* src_rgb, uint8_t* dst_y, int width) { \
+    int x;                                                                 \
+    for (x = 0; x < width; ++x) {                                          \
+      dst_y[0] = RGBToY(src_rgb[R], src_rgb[G], src_rgb[B]);               \
+      src_rgb += BPP;                                                      \
+      dst_y += 1;                                                          \
+    }                                                                      \
+  }                                                                        \
+  void NAME##ToUVRow_C(const uint8_t* src_rgb, int src_stride_rgb,         \
+                       uint8_t* dst_u, uint8_t* dst_v, int width) {        \
+    const uint8_t* src_rgb1 = src_rgb + src_stride_rgb;                    \
+    int x;                                                                 \
+    for (x = 0; x < width - 1; x += 2) {                                   \
+      uint8_t ab = AVGB(AVGB(src_rgb[B], src_rgb1[B]),                     \
+                        AVGB(src_rgb[B + BPP], src_rgb1[B + BPP]));        \
+      uint8_t ag = AVGB(AVGB(src_rgb[G], src_rgb1[G]),                     \
+                        AVGB(src_rgb[G + BPP], src_rgb1[G + BPP]));        \
+      uint8_t ar = AVGB(AVGB(src_rgb[R], src_rgb1[R]),                     \
+                        AVGB(src_rgb[R + BPP], src_rgb1[R + BPP]));        \
+      dst_u[0] = RGBToU(ar, ag, ab);                                       \
+      dst_v[0] = RGBToV(ar, ag, ab);                                       \
+      src_rgb += BPP * 2;                                                  \
+      src_rgb1 += BPP * 2;                                                 \
+      dst_u += 1;                                                          \
+      dst_v += 1;                                                          \
+    }                                                                      \
+    if (width & 1) {                                                       \
+      uint8_t ab = AVGB(src_rgb[B], src_rgb1[B]);                          \
+      uint8_t ag = AVGB(src_rgb[G], src_rgb1[G]);                          \
+      uint8_t ar = AVGB(src_rgb[R], src_rgb1[R]);                          \
+      dst_u[0] = RGBToU(ar, ag, ab);                                       \
+      dst_v[0] = RGBToV(ar, ag, ab);                                       \
+    }                                                                      \
+  }
+#else
+// ARM version does sum / 2 then multiply by 2x smaller coefficients
+#define MAKEROWY(NAME, R, G, B, BPP)                                       \
+  void NAME##ToYRow_C(const uint8_t* src_rgb, uint8_t* dst_y, int width) { \
+    int x;                                                                 \
+    for (x = 0; x < width; ++x) {                                          \
+      dst_y[0] = RGBToY(src_rgb[R], src_rgb[G], src_rgb[B]);               \
+      src_rgb += BPP;                                                      \
+      dst_y += 1;                                                          \
+    }                                                                      \
+  }                                                                        \
+  void NAME##ToUVRow_C(const uint8_t* src_rgb, int src_stride_rgb,         \
+                       uint8_t* dst_u, uint8_t* dst_v, int width) {        \
+    const uint8_t* src_rgb1 = src_rgb + src_stride_rgb;                    \
+    int x;                                                                 \
+    for (x = 0; x < width - 1; x += 2) {                                   \
+      uint16_t ab = (src_rgb[B] + src_rgb[B + BPP] + src_rgb1[B] +         \
+                     src_rgb1[B + BPP] + 1) >>                             \
+                    1;                                                     \
+      uint16_t ag = (src_rgb[G] + src_rgb[G + BPP] + src_rgb1[G] +         \
+                     src_rgb1[G + BPP] + 1) >>                             \
+                    1;                                                     \
+      uint16_t ar = (src_rgb[R] + src_rgb[R + BPP] + src_rgb1[R] +         \
+                     src_rgb1[R + BPP] + 1) >>                             \
+                    1;                                                     \
+      dst_u[0] = RGB2xToU(ar, ag, ab);                                     \
+      dst_v[0] = RGB2xToV(ar, ag, ab);                                     \
+      src_rgb += BPP * 2;                                                  \
+      src_rgb1 += BPP * 2;                                                 \
+      dst_u += 1;                                                          \
+      dst_v += 1;                                                          \
+    }                                                                      \
+    if (width & 1) {                                                       \
+      uint16_t ab = src_rgb[B] + src_rgb1[B];                              \
+      uint16_t ag = src_rgb[G] + src_rgb1[G];                              \
+      uint16_t ar = src_rgb[R] + src_rgb1[R];                              \
+      dst_u[0] = RGB2xToU(ar, ag, ab);                                     \
+      dst_v[0] = RGB2xToV(ar, ag, ab);                                     \
+    }                                                                      \
+  }
+#endif
+
+MAKEROWY(ARGB, 2, 1, 0, 4)
+MAKEROWY(BGRA, 1, 2, 3, 4)
+MAKEROWY(ABGR, 0, 1, 2, 4)
+MAKEROWY(RGBA, 3, 2, 1, 4)
+MAKEROWY(RGB24, 2, 1, 0, 3)
+MAKEROWY(RAW, 0, 1, 2, 3)
+#undef MAKEROWY
+
+// JPeg uses a variation on BT.601-1 full range
+// y =  0.29900 * r + 0.58700 * g + 0.11400 * b
+// u = -0.16874 * r - 0.33126 * g + 0.50000 * b  + center
+// v =  0.50000 * r - 0.41869 * g - 0.08131 * b  + center
+// BT.601 Mpeg range uses:
+// b 0.1016 * 255 = 25.908 = 25
+// g 0.5078 * 255 = 129.489 = 129
+// r 0.2578 * 255 = 65.739 = 66
+// JPeg 7 bit Y (deprecated)
+// b 0.11400 * 128 = 14.592 = 15
+// g 0.58700 * 128 = 75.136 = 75
+// r 0.29900 * 128 = 38.272 = 38
+// JPeg 8 bit Y:
+// b 0.11400 * 256 = 29.184 = 29
+// g 0.58700 * 256 = 150.272 = 150
+// r 0.29900 * 256 = 76.544 = 77
+// JPeg 8 bit U:
+// b  0.50000 * 255 = 127.5 = 127
+// g -0.33126 * 255 = -84.4713 = -84
+// r -0.16874 * 255 = -43.0287 = -43
+// JPeg 8 bit V:
+// b -0.08131 * 255 = -20.73405 = -20
+// g -0.41869 * 255 = -106.76595 = -107
+// r  0.50000 * 255 = 127.5 = 127
+
+#ifdef LIBYUV_RGB7
+// Old 7 bit math for compatibility on unsupported platforms.
+static __inline int RGBToYJ(uint8_t r, uint8_t g, uint8_t b) {
+  return (38 * r + 75 * g + 15 * b + 64) >> 7;
+}
+#else
+// 8 bit
+static __inline int RGBToYJ(uint8_t r, uint8_t g, uint8_t b) {
+  return (77 * r + 150 * g + 29 * b + 128) >> 8;
+}
+#endif
+
+#if defined(LIBYUV_ARGBTOUV_PAVGB)
+static __inline int RGBToUJ(uint8_t r, uint8_t g, uint8_t b) {
+  return (127 * b - 84 * g - 43 * r + 0x8080) >> 8;
+}
+static __inline int RGBToVJ(uint8_t r, uint8_t g, uint8_t b) {
+  return (127 * r - 107 * g - 20 * b + 0x8080) >> 8;
+}
+#else
+static __inline int RGB2xToUJ(uint16_t r, uint16_t g, uint16_t b) {
+  return ((127 / 2) * b - (84 / 2) * g - (43 / 2) * r + 0x8080) >> 8;
+}
+static __inline int RGB2xToVJ(uint16_t r, uint16_t g, uint16_t b) {
+  return ((127 / 2) * r - (107 / 2) * g - (20 / 2) * b + 0x8080) >> 8;
+}
+#endif
+
+// ARGBToYJ_C and ARGBToUVJ_C
+// Intel version mimic SSE/AVX which does 2 pavgb
+#if LIBYUV_ARGBTOUV_PAVGB
+#define MAKEROWYJ(NAME, R, G, B, BPP)                                       \
+  void NAME##ToYJRow_C(const uint8_t* src_rgb, uint8_t* dst_y, int width) { \
+    int x;                                                                  \
+    for (x = 0; x < width; ++x) {                                           \
+      dst_y[0] = RGBToYJ(src_rgb[R], src_rgb[G], src_rgb[B]);               \
+      src_rgb += BPP;                                                       \
+      dst_y += 1;                                                           \
+    }                                                                       \
+  }                                                                         \
+  void NAME##ToUVJRow_C(const uint8_t* src_rgb, int src_stride_rgb,         \
+                        uint8_t* dst_u, uint8_t* dst_v, int width) {        \
+    const uint8_t* src_rgb1 = src_rgb + src_stride_rgb;                     \
+    int x;                                                                  \
+    for (x = 0; x < width - 1; x += 2) {                                    \
+      uint8_t ab = AVGB(AVGB(src_rgb[B], src_rgb1[B]),                      \
+                        AVGB(src_rgb[B + BPP], src_rgb1[B + BPP]));         \
+      uint8_t ag = AVGB(AVGB(src_rgb[G], src_rgb1[G]),                      \
+                        AVGB(src_rgb[G + BPP], src_rgb1[G + BPP]));         \
+      uint8_t ar = AVGB(AVGB(src_rgb[R], src_rgb1[R]),                      \
+                        AVGB(src_rgb[R + BPP], src_rgb1[R + BPP]));         \
+      dst_u[0] = RGBToUJ(ar, ag, ab);                                       \
+      dst_v[0] = RGBToVJ(ar, ag, ab);                                       \
+      src_rgb += BPP * 2;                                                   \
+      src_rgb1 += BPP * 2;                                                  \
+      dst_u += 1;                                                           \
+      dst_v += 1;                                                           \
+    }                                                                       \
+    if (width & 1) {                                                        \
+      uint8_t ab = AVGB(src_rgb[B], src_rgb1[B]);                           \
+      uint8_t ag = AVGB(src_rgb[G], src_rgb1[G]);                           \
+      uint8_t ar = AVGB(src_rgb[R], src_rgb1[R]);                           \
+      dst_u[0] = RGBToUJ(ar, ag, ab);                                       \
+      dst_v[0] = RGBToVJ(ar, ag, ab);                                       \
+    }                                                                       \
+  }
+#else
+// ARM version does sum / 2 then multiply by 2x smaller coefficients
+#define MAKEROWYJ(NAME, R, G, B, BPP)                                       \
+  void NAME##ToYJRow_C(const uint8_t* src_rgb, uint8_t* dst_y, int width) { \
+    int x;                                                                  \
+    for (x = 0; x < width; ++x) {                                           \
+      dst_y[0] = RGBToYJ(src_rgb[R], src_rgb[G], src_rgb[B]);               \
+      src_rgb += BPP;                                                       \
+      dst_y += 1;                                                           \
+    }                                                                       \
+  }                                                                         \
+  void NAME##ToUVJRow_C(const uint8_t* src_rgb, int src_stride_rgb,         \
+                        uint8_t* dst_u, uint8_t* dst_v, int width) {        \
+    const uint8_t* src_rgb1 = src_rgb + src_stride_rgb;                     \
+    int x;                                                                  \
+    for (x = 0; x < width - 1; x += 2) {                                    \
+      uint16_t ab = (src_rgb[B] + src_rgb[B + BPP] + src_rgb1[B] +          \
+                     src_rgb1[B + BPP] + 1) >>                              \
+                    1;                                                      \
+      uint16_t ag = (src_rgb[G] + src_rgb[G + BPP] + src_rgb1[G] +          \
+                     src_rgb1[G + BPP] + 1) >>                              \
+                    1;                                                      \
+      uint16_t ar = (src_rgb[R] + src_rgb[R + BPP] + src_rgb1[R] +          \
+                     src_rgb1[R + BPP] + 1) >>                              \
+                    1;                                                      \
+      dst_u[0] = RGB2xToUJ(ar, ag, ab);                                     \
+      dst_v[0] = RGB2xToVJ(ar, ag, ab);                                     \
+      src_rgb += BPP * 2;                                                   \
+      src_rgb1 += BPP * 2;                                                  \
+      dst_u += 1;                                                           \
+      dst_v += 1;                                                           \
+    }                                                                       \
+    if (width & 1) {                                                        \
+      uint16_t ab = (src_rgb[B] + src_rgb1[B]);                             \
+      uint16_t ag = (src_rgb[G] + src_rgb1[G]);                             \
+      uint16_t ar = (src_rgb[R] + src_rgb1[R]);                             \
+      dst_u[0] = RGB2xToUJ(ar, ag, ab);                                     \
+      dst_v[0] = RGB2xToVJ(ar, ag, ab);                                     \
+    }                                                                       \
+  }
+
+#endif
+
+MAKEROWYJ(ARGB, 2, 1, 0, 4)
+MAKEROWYJ(RGBA, 3, 2, 1, 4)
+MAKEROWYJ(RGB24, 2, 1, 0, 3)
+MAKEROWYJ(RAW, 0, 1, 2, 3)
+#undef MAKEROWYJ
+
+void RGB565ToYRow_C(const uint8_t* src_rgb565, uint8_t* dst_y, int width) {
+  int x;
+  for (x = 0; x < width; ++x) {
+    uint8_t b = src_rgb565[0] & 0x1f;
+    uint8_t g = (src_rgb565[0] >> 5) | ((src_rgb565[1] & 0x07) << 3);
+    uint8_t r = src_rgb565[1] >> 3;
+    b = (b << 3) | (b >> 2);
+    g = (g << 2) | (g >> 4);
+    r = (r << 3) | (r >> 2);
+    dst_y[0] = RGBToY(r, g, b);
+    src_rgb565 += 2;
+    dst_y += 1;
+  }
+}
+
+void ARGB1555ToYRow_C(const uint8_t* src_argb1555, uint8_t* dst_y, int width) {
+  int x;
+  for (x = 0; x < width; ++x) {
+    uint8_t b = src_argb1555[0] & 0x1f;
+    uint8_t g = (src_argb1555[0] >> 5) | ((src_argb1555[1] & 0x03) << 3);
+    uint8_t r = (src_argb1555[1] & 0x7c) >> 2;
+    b = (b << 3) | (b >> 2);
+    g = (g << 3) | (g >> 2);
+    r = (r << 3) | (r >> 2);
+    dst_y[0] = RGBToY(r, g, b);
+    src_argb1555 += 2;
+    dst_y += 1;
+  }
+}
+
+void ARGB4444ToYRow_C(const uint8_t* src_argb4444, uint8_t* dst_y, int width) {
+  int x;
+  for (x = 0; x < width; ++x) {
+    uint8_t b = src_argb4444[0] & 0x0f;
+    uint8_t g = src_argb4444[0] >> 4;
+    uint8_t r = src_argb4444[1] & 0x0f;
+    b = (b << 4) | b;
+    g = (g << 4) | g;
+    r = (r << 4) | r;
+    dst_y[0] = RGBToY(r, g, b);
+    src_argb4444 += 2;
+    dst_y += 1;
+  }
+}
+
+void RGB565ToUVRow_C(const uint8_t* src_rgb565,
+                     int src_stride_rgb565,
+                     uint8_t* dst_u,
+                     uint8_t* dst_v,
+                     int width) {
+  const uint8_t* next_rgb565 = src_rgb565 + src_stride_rgb565;
+  int x;
+  for (x = 0; x < width - 1; x += 2) {
+    uint8_t b0 = src_rgb565[0] & 0x1f;
+    uint8_t g0 = (src_rgb565[0] >> 5) | ((src_rgb565[1] & 0x07) << 3);
+    uint8_t r0 = src_rgb565[1] >> 3;
+    uint8_t b1 = src_rgb565[2] & 0x1f;
+    uint8_t g1 = (src_rgb565[2] >> 5) | ((src_rgb565[3] & 0x07) << 3);
+    uint8_t r1 = src_rgb565[3] >> 3;
+    uint8_t b2 = next_rgb565[0] & 0x1f;
+    uint8_t g2 = (next_rgb565[0] >> 5) | ((next_rgb565[1] & 0x07) << 3);
+    uint8_t r2 = next_rgb565[1] >> 3;
+    uint8_t b3 = next_rgb565[2] & 0x1f;
+    uint8_t g3 = (next_rgb565[2] >> 5) | ((next_rgb565[3] & 0x07) << 3);
+    uint8_t r3 = next_rgb565[3] >> 3;
+
+    b0 = (b0 << 3) | (b0 >> 2);
+    g0 = (g0 << 2) | (g0 >> 4);
+    r0 = (r0 << 3) | (r0 >> 2);
+    b1 = (b1 << 3) | (b1 >> 2);
+    g1 = (g1 << 2) | (g1 >> 4);
+    r1 = (r1 << 3) | (r1 >> 2);
+    b2 = (b2 << 3) | (b2 >> 2);
+    g2 = (g2 << 2) | (g2 >> 4);
+    r2 = (r2 << 3) | (r2 >> 2);
+    b3 = (b3 << 3) | (b3 >> 2);
+    g3 = (g3 << 2) | (g3 >> 4);
+    r3 = (r3 << 3) | (r3 >> 2);
+
+#if LIBYUV_ARGBTOUV_PAVGB
+    uint8_t ab = AVGB(AVGB(b0, b2), AVGB(b1, b3));
+    uint8_t ag = AVGB(AVGB(g0, g2), AVGB(g1, g3));
+    uint8_t ar = AVGB(AVGB(r0, r2), AVGB(r1, r3));
+    dst_u[0] = RGBToU(ar, ag, ab);
+    dst_v[0] = RGBToV(ar, ag, ab);
+#else
+    uint16_t b = (b0 + b1 + b2 + b3 + 1) >> 1;
+    uint16_t g = (g0 + g1 + g2 + g3 + 1) >> 1;
+    uint16_t r = (r0 + r1 + r2 + r3 + 1) >> 1;
+    dst_u[0] = RGB2xToU(r, g, b);
+    dst_v[0] = RGB2xToV(r, g, b);
+#endif
+
+    src_rgb565 += 4;
+    next_rgb565 += 4;
+    dst_u += 1;
+    dst_v += 1;
+  }
+  if (width & 1) {
+    uint8_t b0 = src_rgb565[0] & 0x1f;
+    uint8_t g0 = (src_rgb565[0] >> 5) | ((src_rgb565[1] & 0x07) << 3);
+    uint8_t r0 = src_rgb565[1] >> 3;
+    uint8_t b2 = next_rgb565[0] & 0x1f;
+    uint8_t g2 = (next_rgb565[0] >> 5) | ((next_rgb565[1] & 0x07) << 3);
+    uint8_t r2 = next_rgb565[1] >> 3;
+
+    b0 = (b0 << 3) | (b0 >> 2);
+    g0 = (g0 << 2) | (g0 >> 4);
+    r0 = (r0 << 3) | (r0 >> 2);
+    b2 = (b2 << 3) | (b2 >> 2);
+    g2 = (g2 << 2) | (g2 >> 4);
+    r2 = (r2 << 3) | (r2 >> 2);
+
+#if LIBYUV_ARGBTOUV_PAVGB
+    uint8_t ab = AVGB(b0, b2);
+    uint8_t ag = AVGB(g0, g2);
+    uint8_t ar = AVGB(r0, r2);
+    dst_u[0] = RGBToU(ar, ag, ab);
+    dst_v[0] = RGBToV(ar, ag, ab);
+#else
+    uint16_t b = b0 + b2;
+    uint16_t g = g0 + g2;
+    uint16_t r = r0 + r2;
+    dst_u[0] = RGB2xToU(r, g, b);
+    dst_v[0] = RGB2xToV(r, g, b);
+#endif
+  }
+}
+
+void ARGB1555ToUVRow_C(const uint8_t* src_argb1555,
+                       int src_stride_argb1555,
+                       uint8_t* dst_u,
+                       uint8_t* dst_v,
+                       int width) {
+  const uint8_t* next_argb1555 = src_argb1555 + src_stride_argb1555;
+  int x;
+  for (x = 0; x < width - 1; x += 2) {
+    uint8_t b0 = src_argb1555[0] & 0x1f;
+    uint8_t g0 = (src_argb1555[0] >> 5) | ((src_argb1555[1] & 0x03) << 3);
+    uint8_t r0 = (src_argb1555[1] & 0x7c) >> 2;
+    uint8_t b1 = src_argb1555[2] & 0x1f;
+    uint8_t g1 = (src_argb1555[2] >> 5) | ((src_argb1555[3] & 0x03) << 3);
+    uint8_t r1 = (src_argb1555[3] & 0x7c) >> 2;
+    uint8_t b2 = next_argb1555[0] & 0x1f;
+    uint8_t g2 = (next_argb1555[0] >> 5) | ((next_argb1555[1] & 0x03) << 3);
+    uint8_t r2 = (next_argb1555[1] & 0x7c) >> 2;
+    uint8_t b3 = next_argb1555[2] & 0x1f;
+    uint8_t g3 = (next_argb1555[2] >> 5) | ((next_argb1555[3] & 0x03) << 3);
+    uint8_t r3 = (next_argb1555[3] & 0x7c) >> 2;
+
+    b0 = (b0 << 3) | (b0 >> 2);
+    g0 = (g0 << 3) | (g0 >> 2);
+    r0 = (r0 << 3) | (r0 >> 2);
+    b1 = (b1 << 3) | (b1 >> 2);
+    g1 = (g1 << 3) | (g1 >> 2);
+    r1 = (r1 << 3) | (r1 >> 2);
+    b2 = (b2 << 3) | (b2 >> 2);
+    g2 = (g2 << 3) | (g2 >> 2);
+    r2 = (r2 << 3) | (r2 >> 2);
+    b3 = (b3 << 3) | (b3 >> 2);
+    g3 = (g3 << 3) | (g3 >> 2);
+    r3 = (r3 << 3) | (r3 >> 2);
+
+#if LIBYUV_ARGBTOUV_PAVGB
+    uint8_t ab = AVGB(AVGB(b0, b2), AVGB(b1, b3));
+    uint8_t ag = AVGB(AVGB(g0, g2), AVGB(g1, g3));
+    uint8_t ar = AVGB(AVGB(r0, r2), AVGB(r1, r3));
+    dst_u[0] = RGBToU(ar, ag, ab);
+    dst_v[0] = RGBToV(ar, ag, ab);
+#else
+    uint16_t b = (b0 + b1 + b2 + b3 + 1) >> 1;
+    uint16_t g = (g0 + g1 + g2 + g3 + 1) >> 1;
+    uint16_t r = (r0 + r1 + r2 + r3 + 1) >> 1;
+    dst_u[0] = RGB2xToU(r, g, b);
+    dst_v[0] = RGB2xToV(r, g, b);
+#endif
+
+    src_argb1555 += 4;
+    next_argb1555 += 4;
+    dst_u += 1;
+    dst_v += 1;
+  }
+  if (width & 1) {
+    uint8_t b0 = src_argb1555[0] & 0x1f;
+    uint8_t g0 = (src_argb1555[0] >> 5) | ((src_argb1555[1] & 0x03) << 3);
+    uint8_t r0 = (src_argb1555[1] & 0x7c) >> 2;
+    uint8_t b2 = next_argb1555[0] & 0x1f;
+    uint8_t g2 = (next_argb1555[0] >> 5) | ((next_argb1555[1] & 0x03) << 3);
+    uint8_t r2 = (next_argb1555[1] & 0x7c) >> 2;
+
+    b0 = (b0 << 3) | (b0 >> 2);
+    g0 = (g0 << 3) | (g0 >> 2);
+    r0 = (r0 << 3) | (r0 >> 2);
+    b2 = (b2 << 3) | (b2 >> 2);
+    g2 = (g2 << 3) | (g2 >> 2);
+    r2 = (r2 << 3) | (r2 >> 2);
+
+#if LIBYUV_ARGBTOUV_PAVGB
+    uint8_t ab = AVGB(b0, b2);
+    uint8_t ag = AVGB(g0, g2);
+    uint8_t ar = AVGB(r0, r2);
+    dst_u[0] = RGBToU(ar, ag, ab);
+    dst_v[0] = RGBToV(ar, ag, ab);
+#else
+    uint16_t b = b0 + b2;
+    uint16_t g = g0 + g2;
+    uint16_t r = r0 + r2;
+    dst_u[0] = RGB2xToU(r, g, b);
+    dst_v[0] = RGB2xToV(r, g, b);
+#endif
+  }
+}
+
+void ARGB4444ToUVRow_C(const uint8_t* src_argb4444,
+                       int src_stride_argb4444,
+                       uint8_t* dst_u,
+                       uint8_t* dst_v,
+                       int width) {
+  const uint8_t* next_argb4444 = src_argb4444 + src_stride_argb4444;
+  int x;
+  for (x = 0; x < width - 1; x += 2) {
+    uint8_t b0 = src_argb4444[0] & 0x0f;
+    uint8_t g0 = src_argb4444[0] >> 4;
+    uint8_t r0 = src_argb4444[1] & 0x0f;
+    uint8_t b1 = src_argb4444[2] & 0x0f;
+    uint8_t g1 = src_argb4444[2] >> 4;
+    uint8_t r1 = src_argb4444[3] & 0x0f;
+    uint8_t b2 = next_argb4444[0] & 0x0f;
+    uint8_t g2 = next_argb4444[0] >> 4;
+    uint8_t r2 = next_argb4444[1] & 0x0f;
+    uint8_t b3 = next_argb4444[2] & 0x0f;
+    uint8_t g3 = next_argb4444[2] >> 4;
+    uint8_t r3 = next_argb4444[3] & 0x0f;
+
+    b0 = (b0 << 4) | b0;
+    g0 = (g0 << 4) | g0;
+    r0 = (r0 << 4) | r0;
+    b1 = (b1 << 4) | b1;
+    g1 = (g1 << 4) | g1;
+    r1 = (r1 << 4) | r1;
+    b2 = (b2 << 4) | b2;
+    g2 = (g2 << 4) | g2;
+    r2 = (r2 << 4) | r2;
+    b3 = (b3 << 4) | b3;
+    g3 = (g3 << 4) | g3;
+    r3 = (r3 << 4) | r3;
+
+#if LIBYUV_ARGBTOUV_PAVGB
+    uint8_t ab = AVGB(AVGB(b0, b2), AVGB(b1, b3));
+    uint8_t ag = AVGB(AVGB(g0, g2), AVGB(g1, g3));
+    uint8_t ar = AVGB(AVGB(r0, r2), AVGB(r1, r3));
+    dst_u[0] = RGBToU(ar, ag, ab);
+    dst_v[0] = RGBToV(ar, ag, ab);
+#else
+    uint16_t b = (b0 + b1 + b2 + b3 + 1) >> 1;
+    uint16_t g = (g0 + g1 + g2 + g3 + 1) >> 1;
+    uint16_t r = (r0 + r1 + r2 + r3 + 1) >> 1;
+    dst_u[0] = RGB2xToU(r, g, b);
+    dst_v[0] = RGB2xToV(r, g, b);
+#endif
+
+    src_argb4444 += 4;
+    next_argb4444 += 4;
+    dst_u += 1;
+    dst_v += 1;
+  }
+  if (width & 1) {
+    uint8_t b0 = src_argb4444[0] & 0x0f;
+    uint8_t g0 = src_argb4444[0] >> 4;
+    uint8_t r0 = src_argb4444[1] & 0x0f;
+    uint8_t b2 = next_argb4444[0] & 0x0f;
+    uint8_t g2 = next_argb4444[0] >> 4;
+    uint8_t r2 = next_argb4444[1] & 0x0f;
+
+    b0 = (b0 << 4) | b0;
+    g0 = (g0 << 4) | g0;
+    r0 = (r0 << 4) | r0;
+    b2 = (b2 << 4) | b2;
+    g2 = (g2 << 4) | g2;
+    r2 = (r2 << 4) | r2;
+
+#if LIBYUV_ARGBTOUV_PAVGB
+    uint8_t ab = AVGB(b0, b2);
+    uint8_t ag = AVGB(g0, g2);
+    uint8_t ar = AVGB(r0, r2);
+    dst_u[0] = RGBToU(ar, ag, ab);
+    dst_v[0] = RGBToV(ar, ag, ab);
+#else
+    uint16_t b = b0 + b2;
+    uint16_t g = g0 + g2;
+    uint16_t r = r0 + r2;
+    dst_u[0] = RGB2xToU(r, g, b);
+    dst_v[0] = RGB2xToV(r, g, b);
+#endif
+  }
+}
+
+void ARGBToUV444Row_C(const uint8_t* src_argb,
+                      uint8_t* dst_u,
+                      uint8_t* dst_v,
+                      int width) {
+  int x;
+  for (x = 0; x < width; ++x) {
+    uint8_t ab = src_argb[0];
+    uint8_t ag = src_argb[1];
+    uint8_t ar = src_argb[2];
+    dst_u[0] = RGBToU(ar, ag, ab);
+    dst_v[0] = RGBToV(ar, ag, ab);
+    src_argb += 4;
+    dst_u += 1;
+    dst_v += 1;
+  }
+}
+
+void ARGBGrayRow_C(const uint8_t* src_argb, uint8_t* dst_argb, int width) {
+  int x;
+  for (x = 0; x < width; ++x) {
+    uint8_t y = RGBToYJ(src_argb[2], src_argb[1], src_argb[0]);
+    dst_argb[2] = dst_argb[1] = dst_argb[0] = y;
+    dst_argb[3] = src_argb[3];
+    dst_argb += 4;
+    src_argb += 4;
+  }
+}
+
+// Convert a row of image to Sepia tone.
+void ARGBSepiaRow_C(uint8_t* dst_argb, int width) {
+  int x;
+  for (x = 0; x < width; ++x) {
+    int b = dst_argb[0];
+    int g = dst_argb[1];
+    int r = dst_argb[2];
+    int sb = (b * 17 + g * 68 + r * 35) >> 7;
+    int sg = (b * 22 + g * 88 + r * 45) >> 7;
+    int sr = (b * 24 + g * 98 + r * 50) >> 7;
+    // b does not over flow. a is preserved from original.
+    dst_argb[0] = sb;
+    dst_argb[1] = clamp255(sg);
+    dst_argb[2] = clamp255(sr);
+    dst_argb += 4;
+  }
+}
+
+// Apply color matrix to a row of image. Matrix is signed.
+// TODO(fbarchard): Consider adding rounding (+32).
+void ARGBColorMatrixRow_C(const uint8_t* src_argb,
+                          uint8_t* dst_argb,
+                          const int8_t* matrix_argb,
+                          int width) {
+  int x;
+  for (x = 0; x < width; ++x) {
+    int b = src_argb[0];
+    int g = src_argb[1];
+    int r = src_argb[2];
+    int a = src_argb[3];
+    int sb = (b * matrix_argb[0] + g * matrix_argb[1] + r * matrix_argb[2] +
+              a * matrix_argb[3]) >>
+             6;
+    int sg = (b * matrix_argb[4] + g * matrix_argb[5] + r * matrix_argb[6] +
+              a * matrix_argb[7]) >>
+             6;
+    int sr = (b * matrix_argb[8] + g * matrix_argb[9] + r * matrix_argb[10] +
+              a * matrix_argb[11]) >>
+             6;
+    int sa = (b * matrix_argb[12] + g * matrix_argb[13] + r * matrix_argb[14] +
+              a * matrix_argb[15]) >>
+             6;
+    dst_argb[0] = Clamp(sb);
+    dst_argb[1] = Clamp(sg);
+    dst_argb[2] = Clamp(sr);
+    dst_argb[3] = Clamp(sa);
+    src_argb += 4;
+    dst_argb += 4;
+  }
+}
+
+// Apply color table to a row of image.
+void ARGBColorTableRow_C(uint8_t* dst_argb,
+                         const uint8_t* table_argb,
+                         int width) {
+  int x;
+  for (x = 0; x < width; ++x) {
+    int b = dst_argb[0];
+    int g = dst_argb[1];
+    int r = dst_argb[2];
+    int a = dst_argb[3];
+    dst_argb[0] = table_argb[b * 4 + 0];
+    dst_argb[1] = table_argb[g * 4 + 1];
+    dst_argb[2] = table_argb[r * 4 + 2];
+    dst_argb[3] = table_argb[a * 4 + 3];
+    dst_argb += 4;
+  }
+}
+
+// Apply color table to a row of image.
+void RGBColorTableRow_C(uint8_t* dst_argb,
+                        const uint8_t* table_argb,
+                        int width) {
+  int x;
+  for (x = 0; x < width; ++x) {
+    int b = dst_argb[0];
+    int g = dst_argb[1];
+    int r = dst_argb[2];
+    dst_argb[0] = table_argb[b * 4 + 0];
+    dst_argb[1] = table_argb[g * 4 + 1];
+    dst_argb[2] = table_argb[r * 4 + 2];
+    dst_argb += 4;
+  }
+}
+
+void ARGBQuantizeRow_C(uint8_t* dst_argb,
+                       int scale,
+                       int interval_size,
+                       int interval_offset,
+                       int width) {
+  int x;
+  for (x = 0; x < width; ++x) {
+    int b = dst_argb[0];
+    int g = dst_argb[1];
+    int r = dst_argb[2];
+    dst_argb[0] = (b * scale >> 16) * interval_size + interval_offset;
+    dst_argb[1] = (g * scale >> 16) * interval_size + interval_offset;
+    dst_argb[2] = (r * scale >> 16) * interval_size + interval_offset;
+    dst_argb += 4;
+  }
+}
+
+#define REPEAT8(v) (v) | ((v) << 8)
+#define SHADE(f, v) v* f >> 24
+
+void ARGBShadeRow_C(const uint8_t* src_argb,
+                    uint8_t* dst_argb,
+                    int width,
+                    uint32_t value) {
+  const uint32_t b_scale = REPEAT8(value & 0xff);
+  const uint32_t g_scale = REPEAT8((value >> 8) & 0xff);
+  const uint32_t r_scale = REPEAT8((value >> 16) & 0xff);
+  const uint32_t a_scale = REPEAT8(value >> 24);
+
+  int i;
+  for (i = 0; i < width; ++i) {
+    const uint32_t b = REPEAT8(src_argb[0]);
+    const uint32_t g = REPEAT8(src_argb[1]);
+    const uint32_t r = REPEAT8(src_argb[2]);
+    const uint32_t a = REPEAT8(src_argb[3]);
+    dst_argb[0] = SHADE(b, b_scale);
+    dst_argb[1] = SHADE(g, g_scale);
+    dst_argb[2] = SHADE(r, r_scale);
+    dst_argb[3] = SHADE(a, a_scale);
+    src_argb += 4;
+    dst_argb += 4;
+  }
+}
+#undef REPEAT8
+#undef SHADE
+
+#define REPEAT8(v) (v) | ((v) << 8)
+#define SHADE(f, v) v* f >> 16
+
+void ARGBMultiplyRow_C(const uint8_t* src_argb,
+                       const uint8_t* src_argb1,
+                       uint8_t* dst_argb,
+                       int width) {
+  int i;
+  for (i = 0; i < width; ++i) {
+    const uint32_t b = REPEAT8(src_argb[0]);
+    const uint32_t g = REPEAT8(src_argb[1]);
+    const uint32_t r = REPEAT8(src_argb[2]);
+    const uint32_t a = REPEAT8(src_argb[3]);
+    const uint32_t b_scale = src_argb1[0];
+    const uint32_t g_scale = src_argb1[1];
+    const uint32_t r_scale = src_argb1[2];
+    const uint32_t a_scale = src_argb1[3];
+    dst_argb[0] = SHADE(b, b_scale);
+    dst_argb[1] = SHADE(g, g_scale);
+    dst_argb[2] = SHADE(r, r_scale);
+    dst_argb[3] = SHADE(a, a_scale);
+    src_argb += 4;
+    src_argb1 += 4;
+    dst_argb += 4;
+  }
+}
+#undef REPEAT8
+#undef SHADE
+
+#define SHADE(f, v) clamp255(v + f)
+
+void ARGBAddRow_C(const uint8_t* src_argb,
+                  const uint8_t* src_argb1,
+                  uint8_t* dst_argb,
+                  int width) {
+  int i;
+  for (i = 0; i < width; ++i) {
+    const int b = src_argb[0];
+    const int g = src_argb[1];
+    const int r = src_argb[2];
+    const int a = src_argb[3];
+    const int b_add = src_argb1[0];
+    const int g_add = src_argb1[1];
+    const int r_add = src_argb1[2];
+    const int a_add = src_argb1[3];
+    dst_argb[0] = SHADE(b, b_add);
+    dst_argb[1] = SHADE(g, g_add);
+    dst_argb[2] = SHADE(r, r_add);
+    dst_argb[3] = SHADE(a, a_add);
+    src_argb += 4;
+    src_argb1 += 4;
+    dst_argb += 4;
+  }
+}
+#undef SHADE
+
+#define SHADE(f, v) clamp0(f - v)
+
+void ARGBSubtractRow_C(const uint8_t* src_argb,
+                       const uint8_t* src_argb1,
+                       uint8_t* dst_argb,
+                       int width) {
+  int i;
+  for (i = 0; i < width; ++i) {
+    const int b = src_argb[0];
+    const int g = src_argb[1];
+    const int r = src_argb[2];
+    const int a = src_argb[3];
+    const int b_sub = src_argb1[0];
+    const int g_sub = src_argb1[1];
+    const int r_sub = src_argb1[2];
+    const int a_sub = src_argb1[3];
+    dst_argb[0] = SHADE(b, b_sub);
+    dst_argb[1] = SHADE(g, g_sub);
+    dst_argb[2] = SHADE(r, r_sub);
+    dst_argb[3] = SHADE(a, a_sub);
+    src_argb += 4;
+    src_argb1 += 4;
+    dst_argb += 4;
+  }
+}
+#undef SHADE
+
+// Sobel functions which mimics SSSE3.
+void SobelXRow_C(const uint8_t* src_y0,
+                 const uint8_t* src_y1,
+                 const uint8_t* src_y2,
+                 uint8_t* dst_sobelx,
+                 int width) {
+  int i;
+  for (i = 0; i < width; ++i) {
+    int a = src_y0[i];
+    int b = src_y1[i];
+    int c = src_y2[i];
+    int a_sub = src_y0[i + 2];
+    int b_sub = src_y1[i + 2];
+    int c_sub = src_y2[i + 2];
+    int a_diff = a - a_sub;
+    int b_diff = b - b_sub;
+    int c_diff = c - c_sub;
+    int sobel = Abs(a_diff + b_diff * 2 + c_diff);
+    dst_sobelx[i] = (uint8_t)(clamp255(sobel));
+  }
+}
+
+void SobelYRow_C(const uint8_t* src_y0,
+                 const uint8_t* src_y1,
+                 uint8_t* dst_sobely,
+                 int width) {
+  int i;
+  for (i = 0; i < width; ++i) {
+    int a = src_y0[i + 0];
+    int b = src_y0[i + 1];
+    int c = src_y0[i + 2];
+    int a_sub = src_y1[i + 0];
+    int b_sub = src_y1[i + 1];
+    int c_sub = src_y1[i + 2];
+    int a_diff = a - a_sub;
+    int b_diff = b - b_sub;
+    int c_diff = c - c_sub;
+    int sobel = Abs(a_diff + b_diff * 2 + c_diff);
+    dst_sobely[i] = (uint8_t)(clamp255(sobel));
+  }
+}
+
+void SobelRow_C(const uint8_t* src_sobelx,
+                const uint8_t* src_sobely,
+                uint8_t* dst_argb,
+                int width) {
+  int i;
+  for (i = 0; i < width; ++i) {
+    int r = src_sobelx[i];
+    int b = src_sobely[i];
+    int s = clamp255(r + b);
+    dst_argb[0] = (uint8_t)(s);
+    dst_argb[1] = (uint8_t)(s);
+    dst_argb[2] = (uint8_t)(s);
+    dst_argb[3] = (uint8_t)(255u);
+    dst_argb += 4;
+  }
+}
+
+void SobelToPlaneRow_C(const uint8_t* src_sobelx,
+                       const uint8_t* src_sobely,
+                       uint8_t* dst_y,
+                       int width) {
+  int i;
+  for (i = 0; i < width; ++i) {
+    int r = src_sobelx[i];
+    int b = src_sobely[i];
+    int s = clamp255(r + b);
+    dst_y[i] = (uint8_t)(s);
+  }
+}
+
+void SobelXYRow_C(const uint8_t* src_sobelx,
+                  const uint8_t* src_sobely,
+                  uint8_t* dst_argb,
+                  int width) {
+  int i;
+  for (i = 0; i < width; ++i) {
+    int r = src_sobelx[i];
+    int b = src_sobely[i];
+    int g = clamp255(r + b);
+    dst_argb[0] = (uint8_t)(b);
+    dst_argb[1] = (uint8_t)(g);
+    dst_argb[2] = (uint8_t)(r);
+    dst_argb[3] = (uint8_t)(255u);
+    dst_argb += 4;
+  }
+}
+
+void J400ToARGBRow_C(const uint8_t* src_y, uint8_t* dst_argb, int width) {
+  // Copy a Y to RGB.
+  int x;
+  for (x = 0; x < width; ++x) {
+    uint8_t y = src_y[0];
+    dst_argb[2] = dst_argb[1] = dst_argb[0] = y;
+    dst_argb[3] = 255u;
+    dst_argb += 4;
+    ++src_y;
+  }
+}
+
+// Macros to create SIMD specific yuv to rgb conversion constants.
+
+// clang-format off
+
+#if defined(__aarch64__) || defined(__arm__)
+// Bias values include subtract 128 from U and V, bias from Y and rounding.
+// For B and R bias is negative. For G bias is positive.
+#define YUVCONSTANTSBODY(YG, YB, UB, UG, VG, VR)                             \
+  {{UB, VR, UG, VG, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},                     \
+   {YG, (UB * 128 - YB), (UG * 128 + VG * 128 + YB), (VR * 128 - YB), YB, 0, \
+    0, 0}}
+#else
+#define YUVCONSTANTSBODY(YG, YB, UB, UG, VG, VR)                     \
+  {{UB, 0, UB, 0, UB, 0, UB, 0, UB, 0, UB, 0, UB, 0, UB, 0,          \
+    UB, 0, UB, 0, UB, 0, UB, 0, UB, 0, UB, 0, UB, 0, UB, 0},         \
+   {UG, VG, UG, VG, UG, VG, UG, VG, UG, VG, UG, VG, UG, VG, UG, VG,  \
+    UG, VG, UG, VG, UG, VG, UG, VG, UG, VG, UG, VG, UG, VG, UG, VG}, \
+   {0, VR, 0, VR, 0, VR, 0, VR, 0, VR, 0, VR, 0, VR, 0, VR,          \
+    0, VR, 0, VR, 0, VR, 0, VR, 0, VR, 0, VR, 0, VR, 0, VR},         \
+   {YG, YG, YG, YG, YG, YG, YG, YG, YG, YG, YG, YG, YG, YG, YG, YG}, \
+   {YB, YB, YB, YB, YB, YB, YB, YB, YB, YB, YB, YB, YB, YB, YB, YB}}
+#endif
+
+// clang-format on
+
+#define MAKEYUVCONSTANTS(name, YG, YB, UB, UG, VG, VR)            \
+  const struct YuvConstants SIMD_ALIGNED(kYuv##name##Constants) = \
+      YUVCONSTANTSBODY(YG, YB, UB, UG, VG, VR);                   \
+  const struct YuvConstants SIMD_ALIGNED(kYvu##name##Constants) = \
+      YUVCONSTANTSBODY(YG, YB, VR, VG, UG, UB);
+
+// TODO(fbarchard): Generate SIMD structures from float matrix.
+
+// BT.601 limited range YUV to RGB reference
+//  R = (Y - 16) * 1.164             + V * 1.596
+//  G = (Y - 16) * 1.164 - U * 0.391 - V * 0.813
+//  B = (Y - 16) * 1.164 + U * 2.018
+// KR = 0.299; KB = 0.114
+
+// U and V contributions to R,G,B.
+#if defined(LIBYUV_UNLIMITED_DATA) || defined(LIBYUV_UNLIMITED_BT601)
+#define UB 129 /* round(2.018 * 64) */
+#else
+#define UB 128 /* max(128, round(2.018 * 64)) */
+#endif
+#define UG 25  /* round(0.391 * 64) */
+#define VG 52  /* round(0.813 * 64) */
+#define VR 102 /* round(1.596 * 64) */
+
+// Y contribution to R,G,B.  Scale and bias.
+#define YG 18997 /* round(1.164 * 64 * 256 * 256 / 257) */
+#define YB -1160 /* 1.164 * 64 * -16 + 64 / 2 */
+
+MAKEYUVCONSTANTS(I601, YG, YB, UB, UG, VG, VR)
+
+#undef YG
+#undef YB
+#undef UB
+#undef UG
+#undef VG
+#undef VR
+
+// BT.601 full range YUV to RGB reference (aka JPEG)
+// *  R = Y               + V * 1.40200
+// *  G = Y - U * 0.34414 - V * 0.71414
+// *  B = Y + U * 1.77200
+// KR = 0.299; KB = 0.114
+
+// U and V contributions to R,G,B.
+#define UB 113 /* round(1.77200 * 64) */
+#define UG 22  /* round(0.34414 * 64) */
+#define VG 46  /* round(0.71414 * 64) */
+#define VR 90  /* round(1.40200 * 64) */
+
+// Y contribution to R,G,B.  Scale and bias.
+#define YG 16320 /* round(1.000 * 64 * 256 * 256 / 257) */
+#define YB 32    /* 64 / 2 */
+
+MAKEYUVCONSTANTS(JPEG, YG, YB, UB, UG, VG, VR)
+
+#undef YG
+#undef YB
+#undef UB
+#undef UG
+#undef VG
+#undef VR
+
+// BT.709 limited range YUV to RGB reference
+//  R = (Y - 16) * 1.164             + V * 1.793
+//  G = (Y - 16) * 1.164 - U * 0.213 - V * 0.533
+//  B = (Y - 16) * 1.164 + U * 2.112
+//  KR = 0.2126, KB = 0.0722
+
+// U and V contributions to R,G,B.
+#if defined(LIBYUV_UNLIMITED_DATA) || defined(LIBYUV_UNLIMITED_BT709)
+#define UB 135 /* round(2.112 * 64) */
+#else
+#define UB 128 /* max(128, round(2.112 * 64)) */
+#endif
+#define UG 14  /* round(0.213 * 64) */
+#define VG 34  /* round(0.533 * 64) */
+#define VR 115 /* round(1.793 * 64) */
+
+// Y contribution to R,G,B.  Scale and bias.
+#define YG 18997 /* round(1.164 * 64 * 256 * 256 / 257) */
+#define YB -1160 /* 1.164 * 64 * -16 + 64 / 2 */
+
+MAKEYUVCONSTANTS(H709, YG, YB, UB, UG, VG, VR)
+
+#undef YG
+#undef YB
+#undef UB
+#undef UG
+#undef VG
+#undef VR
+
+// BT.709 full range YUV to RGB reference
+//  R = Y               + V * 1.5748
+//  G = Y - U * 0.18732 - V * 0.46812
+//  B = Y + U * 1.8556
+//  KR = 0.2126, KB = 0.0722
+
+// U and V contributions to R,G,B.
+#define UB 119 /* round(1.8556 * 64) */
+#define UG 12  /* round(0.18732 * 64) */
+#define VG 30  /* round(0.46812 * 64) */
+#define VR 101 /* round(1.5748 * 64) */
+
+// Y contribution to R,G,B.  Scale and bias.  (same as jpeg)
+#define YG 16320 /* round(1 * 64 * 256 * 256 / 257) */
+#define YB 32    /* 64 / 2 */
+
+MAKEYUVCONSTANTS(F709, YG, YB, UB, UG, VG, VR)
+
+#undef YG
+#undef YB
+#undef UB
+#undef UG
+#undef VG
+#undef VR
+
+// BT.2020 limited range YUV to RGB reference
+//  R = (Y - 16) * 1.164384                + V * 1.67867
+//  G = (Y - 16) * 1.164384 - U * 0.187326 - V * 0.65042
+//  B = (Y - 16) * 1.164384 + U * 2.14177
+// KR = 0.2627; KB = 0.0593
+
+// U and V contributions to R,G,B.
+#if defined(LIBYUV_UNLIMITED_DATA) || defined(LIBYUV_UNLIMITED_BT2020)
+#define UB 137 /* round(2.142 * 64) */
+#else
+#define UB 128 /* max(128, round(2.142 * 64)) */
+#endif
+#define UG 12  /* round(0.187326 * 64) */
+#define VG 42  /* round(0.65042 * 64) */
+#define VR 107 /* round(1.67867 * 64) */
+
+// Y contribution to R,G,B.  Scale and bias.
+#define YG 19003 /* round(1.164384 * 64 * 256 * 256 / 257) */
+#define YB -1160 /* 1.164384 * 64 * -16 + 64 / 2 */
+
+MAKEYUVCONSTANTS(2020, YG, YB, UB, UG, VG, VR)
+
+#undef YG
+#undef YB
+#undef UB
+#undef UG
+#undef VG
+#undef VR
+
+// BT.2020 full range YUV to RGB reference
+//  R = Y                + V * 1.474600
+//  G = Y - U * 0.164553 - V * 0.571353
+//  B = Y + U * 1.881400
+// KR = 0.2627; KB = 0.0593
+
+#define UB 120 /* round(1.881400 * 64) */
+#define UG 11  /* round(0.164553 * 64) */
+#define VG 37  /* round(0.571353 * 64) */
+#define VR 94  /* round(1.474600 * 64) */
+
+// Y contribution to R,G,B.  Scale and bias.  (same as jpeg)
+#define YG 16320 /* round(1 * 64 * 256 * 256 / 257) */
+#define YB 32    /* 64 / 2 */
+
+MAKEYUVCONSTANTS(V2020, YG, YB, UB, UG, VG, VR)
+
+#undef YG
+#undef YB
+#undef UB
+#undef UG
+#undef VG
+#undef VR
+
+#undef BB
+#undef BG
+#undef BR
+
+#undef MAKEYUVCONSTANTS
+
+#if defined(__aarch64__) || defined(__arm__)
+#define LOAD_YUV_CONSTANTS                 \
+  int ub = yuvconstants->kUVCoeff[0];      \
+  int vr = yuvconstants->kUVCoeff[1];      \
+  int ug = yuvconstants->kUVCoeff[2];      \
+  int vg = yuvconstants->kUVCoeff[3];      \
+  int yg = yuvconstants->kRGBCoeffBias[0]; \
+  int bb = yuvconstants->kRGBCoeffBias[1]; \
+  int bg = yuvconstants->kRGBCoeffBias[2]; \
+  int br = yuvconstants->kRGBCoeffBias[3]
+
+#define CALC_RGB16                         \
+  int32_t y1 = (uint32_t)(y32 * yg) >> 16; \
+  int b16 = y1 + (u * ub) - bb;            \
+  int g16 = y1 + bg - (u * ug + v * vg);   \
+  int r16 = y1 + (v * vr) - br
+#else
+#define LOAD_YUV_CONSTANTS           \
+  int ub = yuvconstants->kUVToB[0];  \
+  int ug = yuvconstants->kUVToG[0];  \
+  int vg = yuvconstants->kUVToG[1];  \
+  int vr = yuvconstants->kUVToR[1];  \
+  int yg = yuvconstants->kYToRgb[0]; \
+  int yb = yuvconstants->kYBiasToRgb[0]
+
+#define CALC_RGB16                                \
+  int32_t y1 = ((uint32_t)(y32 * yg) >> 16) + yb; \
+  int8_t ui = u;                                  \
+  int8_t vi = v;                                  \
+  ui -= 0x80;                                     \
+  vi -= 0x80;                                     \
+  int b16 = y1 + (ui * ub);                       \
+  int g16 = y1 - (ui * ug + vi * vg);             \
+  int r16 = y1 + (vi * vr)
+#endif
+
+// C reference code that mimics the YUV assembly.
+// Reads 8 bit YUV and leaves result as 16 bit.
+static __inline void YuvPixel(uint8_t y,
+                              uint8_t u,
+                              uint8_t v,
+                              uint8_t* b,
+                              uint8_t* g,
+                              uint8_t* r,
+                              const struct YuvConstants* yuvconstants) {
+  LOAD_YUV_CONSTANTS;
+  uint32_t y32 = y * 0x0101;
+  CALC_RGB16;
+  *b = Clamp((int32_t)(b16) >> 6);
+  *g = Clamp((int32_t)(g16) >> 6);
+  *r = Clamp((int32_t)(r16) >> 6);
+}
+
+// Reads 8 bit YUV and leaves result as 16 bit.
+static __inline void YuvPixel8_16(uint8_t y,
+                                  uint8_t u,
+                                  uint8_t v,
+                                  int* b,
+                                  int* g,
+                                  int* r,
+                                  const struct YuvConstants* yuvconstants) {
+  LOAD_YUV_CONSTANTS;
+  uint32_t y32 = y * 0x0101;
+  CALC_RGB16;
+  *b = b16;
+  *g = g16;
+  *r = r16;
+}
+
+// C reference code that mimics the YUV 16 bit assembly.
+// Reads 10 bit YUV and leaves result as 16 bit.
+static __inline void YuvPixel10_16(uint16_t y,
+                                   uint16_t u,
+                                   uint16_t v,
+                                   int* b,
+                                   int* g,
+                                   int* r,
+                                   const struct YuvConstants* yuvconstants) {
+  LOAD_YUV_CONSTANTS;
+  uint32_t y32 = y << 6;
+  u = clamp255(u >> 2);
+  v = clamp255(v >> 2);
+  CALC_RGB16;
+  *b = b16;
+  *g = g16;
+  *r = r16;
+}
+
+// C reference code that mimics the YUV 16 bit assembly.
+// Reads 12 bit YUV and leaves result as 16 bit.
+static __inline void YuvPixel12_16(int16_t y,
+                                   int16_t u,
+                                   int16_t v,
+                                   int* b,
+                                   int* g,
+                                   int* r,
+                                   const struct YuvConstants* yuvconstants) {
+  LOAD_YUV_CONSTANTS;
+  uint32_t y32 = y << 4;
+  u = clamp255(u >> 4);
+  v = clamp255(v >> 4);
+  CALC_RGB16;
+  *b = b16;
+  *g = g16;
+  *r = r16;
+}
+
+// C reference code that mimics the YUV 10 bit assembly.
+// Reads 10 bit YUV and clamps down to 8 bit RGB.
+static __inline void YuvPixel10(uint16_t y,
+                                uint16_t u,
+                                uint16_t v,
+                                uint8_t* b,
+                                uint8_t* g,
+                                uint8_t* r,
+                                const struct YuvConstants* yuvconstants) {
+  int b16;
+  int g16;
+  int r16;
+  YuvPixel10_16(y, u, v, &b16, &g16, &r16, yuvconstants);
+  *b = Clamp(b16 >> 6);
+  *g = Clamp(g16 >> 6);
+  *r = Clamp(r16 >> 6);
+}
+
+// C reference code that mimics the YUV 12 bit assembly.
+// Reads 12 bit YUV and clamps down to 8 bit RGB.
+static __inline void YuvPixel12(uint16_t y,
+                                uint16_t u,
+                                uint16_t v,
+                                uint8_t* b,
+                                uint8_t* g,
+                                uint8_t* r,
+                                const struct YuvConstants* yuvconstants) {
+  int b16;
+  int g16;
+  int r16;
+  YuvPixel12_16(y, u, v, &b16, &g16, &r16, yuvconstants);
+  *b = Clamp(b16 >> 6);
+  *g = Clamp(g16 >> 6);
+  *r = Clamp(r16 >> 6);
+}
+
+// C reference code that mimics the YUV 16 bit assembly.
+// Reads 16 bit YUV and leaves result as 8 bit.
+static __inline void YuvPixel16_8(uint16_t y,
+                                  uint16_t u,
+                                  uint16_t v,
+                                  uint8_t* b,
+                                  uint8_t* g,
+                                  uint8_t* r,
+                                  const struct YuvConstants* yuvconstants) {
+  LOAD_YUV_CONSTANTS;
+  uint32_t y32 = y;
+  u = clamp255(u >> 8);
+  v = clamp255(v >> 8);
+  CALC_RGB16;
+  *b = Clamp((int32_t)(b16) >> 6);
+  *g = Clamp((int32_t)(g16) >> 6);
+  *r = Clamp((int32_t)(r16) >> 6);
+}
+
+// C reference code that mimics the YUV 16 bit assembly.
+// Reads 16 bit YUV and leaves result as 16 bit.
+static __inline void YuvPixel16_16(uint16_t y,
+                                   uint16_t u,
+                                   uint16_t v,
+                                   int* b,
+                                   int* g,
+                                   int* r,
+                                   const struct YuvConstants* yuvconstants) {
+  LOAD_YUV_CONSTANTS;
+  uint32_t y32 = y;
+  u = clamp255(u >> 8);
+  v = clamp255(v >> 8);
+  CALC_RGB16;
+  *b = b16;
+  *g = g16;
+  *r = r16;
+}
+
+// C reference code that mimics the YUV assembly.
+// Reads 8 bit YUV and leaves result as 8 bit.
+static __inline void YPixel(uint8_t y,
+                            uint8_t* b,
+                            uint8_t* g,
+                            uint8_t* r,
+                            const struct YuvConstants* yuvconstants) {
+#if defined(__aarch64__) || defined(__arm__)
+  int yg = yuvconstants->kRGBCoeffBias[0];
+  int ygb = yuvconstants->kRGBCoeffBias[4];
+#else
+  int ygb = yuvconstants->kYBiasToRgb[0];
+  int yg = yuvconstants->kYToRgb[0];
+#endif
+  uint32_t y1 = (uint32_t)(y * 0x0101 * yg) >> 16;
+  *b = Clamp(((int32_t)(y1) + ygb) >> 6);
+  *g = Clamp(((int32_t)(y1) + ygb) >> 6);
+  *r = Clamp(((int32_t)(y1) + ygb) >> 6);
+}
+
+void I444ToARGBRow_C(const uint8_t* src_y,
+                     const uint8_t* src_u,
+                     const uint8_t* src_v,
+                     uint8_t* rgb_buf,
+                     const struct YuvConstants* yuvconstants,
+                     int width) {
+  int x;
+  for (x = 0; x < width; ++x) {
+    YuvPixel(src_y[0], src_u[0], src_v[0], rgb_buf + 0, rgb_buf + 1,
+             rgb_buf + 2, yuvconstants);
+    rgb_buf[3] = 255;
+    src_y += 1;
+    src_u += 1;
+    src_v += 1;
+    rgb_buf += 4;  // Advance 1 pixel.
+  }
+}
+
+// Also used for 420
+void I422ToARGBRow_C(const uint8_t* src_y,
+                     const uint8_t* src_u,
+                     const uint8_t* src_v,
+                     uint8_t* rgb_buf,
+                     const struct YuvConstants* yuvconstants,
+                     int width) {
+  int x;
+  for (x = 0; x < width - 1; x += 2) {
+    YuvPixel(src_y[0], src_u[0], src_v[0], rgb_buf + 0, rgb_buf + 1,
+             rgb_buf + 2, yuvconstants);
+    rgb_buf[3] = 255;
+    YuvPixel(src_y[1], src_u[0], src_v[0], rgb_buf + 4, rgb_buf + 5,
+             rgb_buf + 6, yuvconstants);
+    rgb_buf[7] = 255;
+    src_y += 2;
+    src_u += 1;
+    src_v += 1;
+    rgb_buf += 8;  // Advance 2 pixels.
+  }
+  if (width & 1) {
+    YuvPixel(src_y[0], src_u[0], src_v[0], rgb_buf + 0, rgb_buf + 1,
+             rgb_buf + 2, yuvconstants);
+    rgb_buf[3] = 255;
+  }
+}
+
+// 10 bit YUV to ARGB
+void I210ToARGBRow_C(const uint16_t* src_y,
+                     const uint16_t* src_u,
+                     const uint16_t* src_v,
+                     uint8_t* rgb_buf,
+                     const struct YuvConstants* yuvconstants,
+                     int width) {
+  int x;
+  for (x = 0; x < width - 1; x += 2) {
+    YuvPixel10(src_y[0], src_u[0], src_v[0], rgb_buf + 0, rgb_buf + 1,
+               rgb_buf + 2, yuvconstants);
+    rgb_buf[3] = 255;
+    YuvPixel10(src_y[1], src_u[0], src_v[0], rgb_buf + 4, rgb_buf + 5,
+               rgb_buf + 6, yuvconstants);
+    rgb_buf[7] = 255;
+    src_y += 2;
+    src_u += 1;
+    src_v += 1;
+    rgb_buf += 8;  // Advance 2 pixels.
+  }
+  if (width & 1) {
+    YuvPixel10(src_y[0], src_u[0], src_v[0], rgb_buf + 0, rgb_buf + 1,
+               rgb_buf + 2, yuvconstants);
+    rgb_buf[3] = 255;
+  }
+}
+
+void I410ToARGBRow_C(const uint16_t* src_y,
+                     const uint16_t* src_u,
+                     const uint16_t* src_v,
+                     uint8_t* rgb_buf,
+                     const struct YuvConstants* yuvconstants,
+                     int width) {
+  int x;
+  for (x = 0; x < width; ++x) {
+    YuvPixel10(src_y[0], src_u[0], src_v[0], rgb_buf + 0, rgb_buf + 1,
+               rgb_buf + 2, yuvconstants);
+    rgb_buf[3] = 255;
+    src_y += 1;
+    src_u += 1;
+    src_v += 1;
+    rgb_buf += 4;  // Advance 1 pixels.
+  }
+}
+
+void I210AlphaToARGBRow_C(const uint16_t* src_y,
+                          const uint16_t* src_u,
+                          const uint16_t* src_v,
+                          const uint16_t* src_a,
+                          uint8_t* rgb_buf,
+                          const struct YuvConstants* yuvconstants,
+                          int width) {
+  int x;
+  for (x = 0; x < width - 1; x += 2) {
+    YuvPixel10(src_y[0], src_u[0], src_v[0], rgb_buf + 0, rgb_buf + 1,
+               rgb_buf + 2, yuvconstants);
+    rgb_buf[3] = clamp255(src_a[0] >> 2);
+    YuvPixel10(src_y[1], src_u[0], src_v[0], rgb_buf + 4, rgb_buf + 5,
+               rgb_buf + 6, yuvconstants);
+    rgb_buf[7] = clamp255(src_a[1] >> 2);
+    src_y += 2;
+    src_u += 1;
+    src_v += 1;
+    src_a += 2;
+    rgb_buf += 8;  // Advance 2 pixels.
+  }
+  if (width & 1) {
+    YuvPixel10(src_y[0], src_u[0], src_v[0], rgb_buf + 0, rgb_buf + 1,
+               rgb_buf + 2, yuvconstants);
+    rgb_buf[3] = clamp255(src_a[0] >> 2);
+  }
+}
+
+void I410AlphaToARGBRow_C(const uint16_t* src_y,
+                          const uint16_t* src_u,
+                          const uint16_t* src_v,
+                          const uint16_t* src_a,
+                          uint8_t* rgb_buf,
+                          const struct YuvConstants* yuvconstants,
+                          int width) {
+  int x;
+  for (x = 0; x < width; ++x) {
+    YuvPixel10(src_y[0], src_u[0], src_v[0], rgb_buf + 0, rgb_buf + 1,
+               rgb_buf + 2, yuvconstants);
+    rgb_buf[3] = clamp255(src_a[0] >> 2);
+    src_y += 1;
+    src_u += 1;
+    src_v += 1;
+    src_a += 1;
+    rgb_buf += 4;  // Advance 1 pixels.
+  }
+}
+
+// 12 bit YUV to ARGB
+void I212ToARGBRow_C(const uint16_t* src_y,
+                     const uint16_t* src_u,
+                     const uint16_t* src_v,
+                     uint8_t* rgb_buf,
+                     const struct YuvConstants* yuvconstants,
+                     int width) {
+  int x;
+  for (x = 0; x < width - 1; x += 2) {
+    YuvPixel12(src_y[0], src_u[0], src_v[0], rgb_buf + 0, rgb_buf + 1,
+               rgb_buf + 2, yuvconstants);
+    rgb_buf[3] = 255;
+    YuvPixel12(src_y[1], src_u[0], src_v[0], rgb_buf + 4, rgb_buf + 5,
+               rgb_buf + 6, yuvconstants);
+    rgb_buf[7] = 255;
+    src_y += 2;
+    src_u += 1;
+    src_v += 1;
+    rgb_buf += 8;  // Advance 2 pixels.
+  }
+  if (width & 1) {
+    YuvPixel12(src_y[0], src_u[0], src_v[0], rgb_buf + 0, rgb_buf + 1,
+               rgb_buf + 2, yuvconstants);
+    rgb_buf[3] = 255;
+  }
+}
+
+static void StoreAR30(uint8_t* rgb_buf, int b, int g, int r) {
+  uint32_t ar30;
+  b = b >> 4;  // convert 8 bit 10.6 to 10 bit.
+  g = g >> 4;
+  r = r >> 4;
+  b = Clamp10(b);
+  g = Clamp10(g);
+  r = Clamp10(r);
+  ar30 = b | ((uint32_t)g << 10) | ((uint32_t)r << 20) | 0xc0000000;
+  (*(uint32_t*)rgb_buf) = ar30;
+}
+
+// 10 bit YUV to 10 bit AR30
+void I210ToAR30Row_C(const uint16_t* src_y,
+                     const uint16_t* src_u,
+                     const uint16_t* src_v,
+                     uint8_t* rgb_buf,
+                     const struct YuvConstants* yuvconstants,
+                     int width) {
+  int x;
+  int b;
+  int g;
+  int r;
+  for (x = 0; x < width - 1; x += 2) {
+    YuvPixel10_16(src_y[0], src_u[0], src_v[0], &b, &g, &r, yuvconstants);
+    StoreAR30(rgb_buf, b, g, r);
+    YuvPixel10_16(src_y[1], src_u[0], src_v[0], &b, &g, &r, yuvconstants);
+    StoreAR30(rgb_buf + 4, b, g, r);
+    src_y += 2;
+    src_u += 1;
+    src_v += 1;
+    rgb_buf += 8;  // Advance 2 pixels.
+  }
+  if (width & 1) {
+    YuvPixel10_16(src_y[0], src_u[0], src_v[0], &b, &g, &r, yuvconstants);
+    StoreAR30(rgb_buf, b, g, r);
+  }
+}
+
+// 12 bit YUV to 10 bit AR30
+void I212ToAR30Row_C(const uint16_t* src_y,
+                     const uint16_t* src_u,
+                     const uint16_t* src_v,
+                     uint8_t* rgb_buf,
+                     const struct YuvConstants* yuvconstants,
+                     int width) {
+  int x;
+  int b;
+  int g;
+  int r;
+  for (x = 0; x < width - 1; x += 2) {
+    YuvPixel12_16(src_y[0], src_u[0], src_v[0], &b, &g, &r, yuvconstants);
+    StoreAR30(rgb_buf, b, g, r);
+    YuvPixel12_16(src_y[1], src_u[0], src_v[0], &b, &g, &r, yuvconstants);
+    StoreAR30(rgb_buf + 4, b, g, r);
+    src_y += 2;
+    src_u += 1;
+    src_v += 1;
+    rgb_buf += 8;  // Advance 2 pixels.
+  }
+  if (width & 1) {
+    YuvPixel12_16(src_y[0], src_u[0], src_v[0], &b, &g, &r, yuvconstants);
+    StoreAR30(rgb_buf, b, g, r);
+  }
+}
+
+void I410ToAR30Row_C(const uint16_t* src_y,
+                     const uint16_t* src_u,
+                     const uint16_t* src_v,
+                     uint8_t* rgb_buf,
+                     const struct YuvConstants* yuvconstants,
+                     int width) {
+  int x;
+  int b;
+  int g;
+  int r;
+  for (x = 0; x < width; ++x) {
+    YuvPixel10_16(src_y[0], src_u[0], src_v[0], &b, &g, &r, yuvconstants);
+    StoreAR30(rgb_buf, b, g, r);
+    src_y += 1;
+    src_u += 1;
+    src_v += 1;
+    rgb_buf += 4;  // Advance 1 pixel.
+  }
+}
+
+// P210 has 10 bits in msb of 16 bit NV12 style layout.
+void P210ToARGBRow_C(const uint16_t* src_y,
+                     const uint16_t* src_uv,
+                     uint8_t* dst_argb,
+                     const struct YuvConstants* yuvconstants,
+                     int width) {
+  int x;
+  for (x = 0; x < width - 1; x += 2) {
+    YuvPixel16_8(src_y[0], src_uv[0], src_uv[1], dst_argb + 0, dst_argb + 1,
+                 dst_argb + 2, yuvconstants);
+    dst_argb[3] = 255;
+    YuvPixel16_8(src_y[1], src_uv[0], src_uv[1], dst_argb + 4, dst_argb + 5,
+                 dst_argb + 6, yuvconstants);
+    dst_argb[7] = 255;
+    src_y += 2;
+    src_uv += 2;
+    dst_argb += 8;  // Advance 2 pixels.
+  }
+  if (width & 1) {
+    YuvPixel16_8(src_y[0], src_uv[0], src_uv[1], dst_argb + 0, dst_argb + 1,
+                 dst_argb + 2, yuvconstants);
+    dst_argb[3] = 255;
+  }
+}
+
+void P410ToARGBRow_C(const uint16_t* src_y,
+                     const uint16_t* src_uv,
+                     uint8_t* dst_argb,
+                     const struct YuvConstants* yuvconstants,
+                     int width) {
+  int x;
+  for (x = 0; x < width; ++x) {
+    YuvPixel16_8(src_y[0], src_uv[0], src_uv[1], dst_argb + 0, dst_argb + 1,
+                 dst_argb + 2, yuvconstants);
+    dst_argb[3] = 255;
+    src_y += 1;
+    src_uv += 2;
+    dst_argb += 4;  // Advance 1 pixels.
+  }
+}
+
+void P210ToAR30Row_C(const uint16_t* src_y,
+                     const uint16_t* src_uv,
+                     uint8_t* dst_ar30,
+                     const struct YuvConstants* yuvconstants,
+                     int width) {
+  int x;
+  int b;
+  int g;
+  int r;
+  for (x = 0; x < width - 1; x += 2) {
+    YuvPixel16_16(src_y[0], src_uv[0], src_uv[1], &b, &g, &r, yuvconstants);
+    StoreAR30(dst_ar30, b, g, r);
+    YuvPixel16_16(src_y[1], src_uv[0], src_uv[1], &b, &g, &r, yuvconstants);
+    StoreAR30(dst_ar30 + 4, b, g, r);
+    src_y += 2;
+    src_uv += 2;
+    dst_ar30 += 8;  // Advance 2 pixels.
+  }
+  if (width & 1) {
+    YuvPixel16_16(src_y[0], src_uv[0], src_uv[1], &b, &g, &r, yuvconstants);
+    StoreAR30(dst_ar30, b, g, r);
+  }
+}
+
+void P410ToAR30Row_C(const uint16_t* src_y,
+                     const uint16_t* src_uv,
+                     uint8_t* dst_ar30,
+                     const struct YuvConstants* yuvconstants,
+                     int width) {
+  int x;
+  int b;
+  int g;
+  int r;
+  for (x = 0; x < width; ++x) {
+    YuvPixel16_16(src_y[0], src_uv[0], src_uv[1], &b, &g, &r, yuvconstants);
+    StoreAR30(dst_ar30, b, g, r);
+    src_y += 1;
+    src_uv += 2;
+    dst_ar30 += 4;  // Advance 1 pixel.
+  }
+}
+
+// 8 bit YUV to 10 bit AR30
+// Uses same code as 10 bit YUV bit shifts the 8 bit values up to 10 bits.
+void I422ToAR30Row_C(const uint8_t* src_y,
+                     const uint8_t* src_u,
+                     const uint8_t* src_v,
+                     uint8_t* rgb_buf,
+                     const struct YuvConstants* yuvconstants,
+                     int width) {
+  int x;
+  int b;
+  int g;
+  int r;
+  for (x = 0; x < width - 1; x += 2) {
+    YuvPixel8_16(src_y[0], src_u[0], src_v[0], &b, &g, &r, yuvconstants);
+    StoreAR30(rgb_buf, b, g, r);
+    YuvPixel8_16(src_y[1], src_u[0], src_v[0], &b, &g, &r, yuvconstants);
+    StoreAR30(rgb_buf + 4, b, g, r);
+    src_y += 2;
+    src_u += 1;
+    src_v += 1;
+    rgb_buf += 8;  // Advance 2 pixels.
+  }
+  if (width & 1) {
+    YuvPixel8_16(src_y[0], src_u[0], src_v[0], &b, &g, &r, yuvconstants);
+    StoreAR30(rgb_buf, b, g, r);
+  }
+}
+
+void I444AlphaToARGBRow_C(const uint8_t* src_y,
+                          const uint8_t* src_u,
+                          const uint8_t* src_v,
+                          const uint8_t* src_a,
+                          uint8_t* rgb_buf,
+                          const struct YuvConstants* yuvconstants,
+                          int width) {
+  int x;
+  for (x = 0; x < width; ++x) {
+    YuvPixel(src_y[0], src_u[0], src_v[0], rgb_buf + 0, rgb_buf + 1,
+             rgb_buf + 2, yuvconstants);
+    rgb_buf[3] = src_a[0];
+    src_y += 1;
+    src_u += 1;
+    src_v += 1;
+    src_a += 1;
+    rgb_buf += 4;  // Advance 1 pixel.
+  }
+}
+
+void I422AlphaToARGBRow_C(const uint8_t* src_y,
+                          const uint8_t* src_u,
+                          const uint8_t* src_v,
+                          const uint8_t* src_a,
+                          uint8_t* rgb_buf,
+                          const struct YuvConstants* yuvconstants,
+                          int width) {
+  int x;
+  for (x = 0; x < width - 1; x += 2) {
+    YuvPixel(src_y[0], src_u[0], src_v[0], rgb_buf + 0, rgb_buf + 1,
+             rgb_buf + 2, yuvconstants);
+    rgb_buf[3] = src_a[0];
+    YuvPixel(src_y[1], src_u[0], src_v[0], rgb_buf + 4, rgb_buf + 5,
+             rgb_buf + 6, yuvconstants);
+    rgb_buf[7] = src_a[1];
+    src_y += 2;
+    src_u += 1;
+    src_v += 1;
+    src_a += 2;
+    rgb_buf += 8;  // Advance 2 pixels.
+  }
+  if (width & 1) {
+    YuvPixel(src_y[0], src_u[0], src_v[0], rgb_buf + 0, rgb_buf + 1,
+             rgb_buf + 2, yuvconstants);
+    rgb_buf[3] = src_a[0];
+  }
+}
+
+void I422ToRGB24Row_C(const uint8_t* src_y,
+                      const uint8_t* src_u,
+                      const uint8_t* src_v,
+                      uint8_t* rgb_buf,
+                      const struct YuvConstants* yuvconstants,
+                      int width) {
+  int x;
+  for (x = 0; x < width - 1; x += 2) {
+    YuvPixel(src_y[0], src_u[0], src_v[0], rgb_buf + 0, rgb_buf + 1,
+             rgb_buf + 2, yuvconstants);
+    YuvPixel(src_y[1], src_u[0], src_v[0], rgb_buf + 3, rgb_buf + 4,
+             rgb_buf + 5, yuvconstants);
+    src_y += 2;
+    src_u += 1;
+    src_v += 1;
+    rgb_buf += 6;  // Advance 2 pixels.
+  }
+  if (width & 1) {
+    YuvPixel(src_y[0], src_u[0], src_v[0], rgb_buf + 0, rgb_buf + 1,
+             rgb_buf + 2, yuvconstants);
+  }
+}
+
+void I422ToARGB4444Row_C(const uint8_t* src_y,
+                         const uint8_t* src_u,
+                         const uint8_t* src_v,
+                         uint8_t* dst_argb4444,
+                         const struct YuvConstants* yuvconstants,
+                         int width) {
+  uint8_t b0;
+  uint8_t g0;
+  uint8_t r0;
+  uint8_t b1;
+  uint8_t g1;
+  uint8_t r1;
+  int x;
+  for (x = 0; x < width - 1; x += 2) {
+    YuvPixel(src_y[0], src_u[0], src_v[0], &b0, &g0, &r0, yuvconstants);
+    YuvPixel(src_y[1], src_u[0], src_v[0], &b1, &g1, &r1, yuvconstants);
+    b0 = b0 >> 4;
+    g0 = g0 >> 4;
+    r0 = r0 >> 4;
+    b1 = b1 >> 4;
+    g1 = g1 >> 4;
+    r1 = r1 >> 4;
+    *(uint16_t*)(dst_argb4444 + 0) = b0 | (g0 << 4) | (r0 << 8) | 0xf000;
+    *(uint16_t*)(dst_argb4444 + 2) = b1 | (g1 << 4) | (r1 << 8) | 0xf000;
+    src_y += 2;
+    src_u += 1;
+    src_v += 1;
+    dst_argb4444 += 4;  // Advance 2 pixels.
+  }
+  if (width & 1) {
+    YuvPixel(src_y[0], src_u[0], src_v[0], &b0, &g0, &r0, yuvconstants);
+    b0 = b0 >> 4;
+    g0 = g0 >> 4;
+    r0 = r0 >> 4;
+    *(uint16_t*)(dst_argb4444) = b0 | (g0 << 4) | (r0 << 8) | 0xf000;
+  }
+}
+
+void I422ToARGB1555Row_C(const uint8_t* src_y,
+                         const uint8_t* src_u,
+                         const uint8_t* src_v,
+                         uint8_t* dst_argb1555,
+                         const struct YuvConstants* yuvconstants,
+                         int width) {
+  uint8_t b0;
+  uint8_t g0;
+  uint8_t r0;
+  uint8_t b1;
+  uint8_t g1;
+  uint8_t r1;
+  int x;
+  for (x = 0; x < width - 1; x += 2) {
+    YuvPixel(src_y[0], src_u[0], src_v[0], &b0, &g0, &r0, yuvconstants);
+    YuvPixel(src_y[1], src_u[0], src_v[0], &b1, &g1, &r1, yuvconstants);
+    b0 = b0 >> 3;
+    g0 = g0 >> 3;
+    r0 = r0 >> 3;
+    b1 = b1 >> 3;
+    g1 = g1 >> 3;
+    r1 = r1 >> 3;
+    *(uint16_t*)(dst_argb1555 + 0) = b0 | (g0 << 5) | (r0 << 10) | 0x8000;
+    *(uint16_t*)(dst_argb1555 + 2) = b1 | (g1 << 5) | (r1 << 10) | 0x8000;
+    src_y += 2;
+    src_u += 1;
+    src_v += 1;
+    dst_argb1555 += 4;  // Advance 2 pixels.
+  }
+  if (width & 1) {
+    YuvPixel(src_y[0], src_u[0], src_v[0], &b0, &g0, &r0, yuvconstants);
+    b0 = b0 >> 3;
+    g0 = g0 >> 3;
+    r0 = r0 >> 3;
+    *(uint16_t*)(dst_argb1555) = b0 | (g0 << 5) | (r0 << 10) | 0x8000;
+  }
+}
+
+void I422ToRGB565Row_C(const uint8_t* src_y,
+                       const uint8_t* src_u,
+                       const uint8_t* src_v,
+                       uint8_t* dst_rgb565,
+                       const struct YuvConstants* yuvconstants,
+                       int width) {
+  uint8_t b0;
+  uint8_t g0;
+  uint8_t r0;
+  uint8_t b1;
+  uint8_t g1;
+  uint8_t r1;
+  int x;
+  for (x = 0; x < width - 1; x += 2) {
+    YuvPixel(src_y[0], src_u[0], src_v[0], &b0, &g0, &r0, yuvconstants);
+    YuvPixel(src_y[1], src_u[0], src_v[0], &b1, &g1, &r1, yuvconstants);
+    b0 = b0 >> 3;
+    g0 = g0 >> 2;
+    r0 = r0 >> 3;
+    b1 = b1 >> 3;
+    g1 = g1 >> 2;
+    r1 = r1 >> 3;
+    *(uint16_t*)(dst_rgb565 + 0) = b0 | (g0 << 5) | (r0 << 11);  // for ubsan
+    *(uint16_t*)(dst_rgb565 + 2) = b1 | (g1 << 5) | (r1 << 11);
+    src_y += 2;
+    src_u += 1;
+    src_v += 1;
+    dst_rgb565 += 4;  // Advance 2 pixels.
+  }
+  if (width & 1) {
+    YuvPixel(src_y[0], src_u[0], src_v[0], &b0, &g0, &r0, yuvconstants);
+    b0 = b0 >> 3;
+    g0 = g0 >> 2;
+    r0 = r0 >> 3;
+    *(uint16_t*)(dst_rgb565) = b0 | (g0 << 5) | (r0 << 11);
+  }
+}
+
+void NV12ToARGBRow_C(const uint8_t* src_y,
+                     const uint8_t* src_uv,
+                     uint8_t* rgb_buf,
+                     const struct YuvConstants* yuvconstants,
+                     int width) {
+  int x;
+  for (x = 0; x < width - 1; x += 2) {
+    YuvPixel(src_y[0], src_uv[0], src_uv[1], rgb_buf + 0, rgb_buf + 1,
+             rgb_buf + 2, yuvconstants);
+    rgb_buf[3] = 255;
+    YuvPixel(src_y[1], src_uv[0], src_uv[1], rgb_buf + 4, rgb_buf + 5,
+             rgb_buf + 6, yuvconstants);
+    rgb_buf[7] = 255;
+    src_y += 2;
+    src_uv += 2;
+    rgb_buf += 8;  // Advance 2 pixels.
+  }
+  if (width & 1) {
+    YuvPixel(src_y[0], src_uv[0], src_uv[1], rgb_buf + 0, rgb_buf + 1,
+             rgb_buf + 2, yuvconstants);
+    rgb_buf[3] = 255;
+  }
+}
+
+void NV21ToARGBRow_C(const uint8_t* src_y,
+                     const uint8_t* src_vu,
+                     uint8_t* rgb_buf,
+                     const struct YuvConstants* yuvconstants,
+                     int width) {
+  int x;
+  for (x = 0; x < width - 1; x += 2) {
+    YuvPixel(src_y[0], src_vu[1], src_vu[0], rgb_buf + 0, rgb_buf + 1,
+             rgb_buf + 2, yuvconstants);
+    rgb_buf[3] = 255;
+    YuvPixel(src_y[1], src_vu[1], src_vu[0], rgb_buf + 4, rgb_buf + 5,
+             rgb_buf + 6, yuvconstants);
+    rgb_buf[7] = 255;
+    src_y += 2;
+    src_vu += 2;
+    rgb_buf += 8;  // Advance 2 pixels.
+  }
+  if (width & 1) {
+    YuvPixel(src_y[0], src_vu[1], src_vu[0], rgb_buf + 0, rgb_buf + 1,
+             rgb_buf + 2, yuvconstants);
+    rgb_buf[3] = 255;
+  }
+}
+
+void NV12ToRGB24Row_C(const uint8_t* src_y,
+                      const uint8_t* src_uv,
+                      uint8_t* rgb_buf,
+                      const struct YuvConstants* yuvconstants,
+                      int width) {
+  int x;
+  for (x = 0; x < width - 1; x += 2) {
+    YuvPixel(src_y[0], src_uv[0], src_uv[1], rgb_buf + 0, rgb_buf + 1,
+             rgb_buf + 2, yuvconstants);
+    YuvPixel(src_y[1], src_uv[0], src_uv[1], rgb_buf + 3, rgb_buf + 4,
+             rgb_buf + 5, yuvconstants);
+    src_y += 2;
+    src_uv += 2;
+    rgb_buf += 6;  // Advance 2 pixels.
+  }
+  if (width & 1) {
+    YuvPixel(src_y[0], src_uv[0], src_uv[1], rgb_buf + 0, rgb_buf + 1,
+             rgb_buf + 2, yuvconstants);
+  }
+}
+
+void NV21ToRGB24Row_C(const uint8_t* src_y,
+                      const uint8_t* src_vu,
+                      uint8_t* rgb_buf,
+                      const struct YuvConstants* yuvconstants,
+                      int width) {
+  int x;
+  for (x = 0; x < width - 1; x += 2) {
+    YuvPixel(src_y[0], src_vu[1], src_vu[0], rgb_buf + 0, rgb_buf + 1,
+             rgb_buf + 2, yuvconstants);
+    YuvPixel(src_y[1], src_vu[1], src_vu[0], rgb_buf + 3, rgb_buf + 4,
+             rgb_buf + 5, yuvconstants);
+    src_y += 2;
+    src_vu += 2;
+    rgb_buf += 6;  // Advance 2 pixels.
+  }
+  if (width & 1) {
+    YuvPixel(src_y[0], src_vu[1], src_vu[0], rgb_buf + 0, rgb_buf + 1,
+             rgb_buf + 2, yuvconstants);
+  }
+}
+
+void NV12ToRGB565Row_C(const uint8_t* src_y,
+                       const uint8_t* src_uv,
+                       uint8_t* dst_rgb565,
+                       const struct YuvConstants* yuvconstants,
+                       int width) {
+  uint8_t b0;
+  uint8_t g0;
+  uint8_t r0;
+  uint8_t b1;
+  uint8_t g1;
+  uint8_t r1;
+  int x;
+  for (x = 0; x < width - 1; x += 2) {
+    YuvPixel(src_y[0], src_uv[0], src_uv[1], &b0, &g0, &r0, yuvconstants);
+    YuvPixel(src_y[1], src_uv[0], src_uv[1], &b1, &g1, &r1, yuvconstants);
+    b0 = b0 >> 3;
+    g0 = g0 >> 2;
+    r0 = r0 >> 3;
+    b1 = b1 >> 3;
+    g1 = g1 >> 2;
+    r1 = r1 >> 3;
+    *(uint16_t*)(dst_rgb565 + 0) = b0 | (g0 << 5) | (r0 << 11);
+    *(uint16_t*)(dst_rgb565 + 2) = b1 | (g1 << 5) | (r1 << 11);
+    src_y += 2;
+    src_uv += 2;
+    dst_rgb565 += 4;  // Advance 2 pixels.
+  }
+  if (width & 1) {
+    YuvPixel(src_y[0], src_uv[0], src_uv[1], &b0, &g0, &r0, yuvconstants);
+    b0 = b0 >> 3;
+    g0 = g0 >> 2;
+    r0 = r0 >> 3;
+    *(uint16_t*)(dst_rgb565) = b0 | (g0 << 5) | (r0 << 11);
+  }
+}
+
+void YUY2ToARGBRow_C(const uint8_t* src_yuy2,
+                     uint8_t* rgb_buf,
+                     const struct YuvConstants* yuvconstants,
+                     int width) {
+  int x;
+  for (x = 0; x < width - 1; x += 2) {
+    YuvPixel(src_yuy2[0], src_yuy2[1], src_yuy2[3], rgb_buf + 0, rgb_buf + 1,
+             rgb_buf + 2, yuvconstants);
+    rgb_buf[3] = 255;
+    YuvPixel(src_yuy2[2], src_yuy2[1], src_yuy2[3], rgb_buf + 4, rgb_buf + 5,
+             rgb_buf + 6, yuvconstants);
+    rgb_buf[7] = 255;
+    src_yuy2 += 4;
+    rgb_buf += 8;  // Advance 2 pixels.
+  }
+  if (width & 1) {
+    YuvPixel(src_yuy2[0], src_yuy2[1], src_yuy2[3], rgb_buf + 0, rgb_buf + 1,
+             rgb_buf + 2, yuvconstants);
+    rgb_buf[3] = 255;
+  }
+}
+
+void UYVYToARGBRow_C(const uint8_t* src_uyvy,
+                     uint8_t* rgb_buf,
+                     const struct YuvConstants* yuvconstants,
+                     int width) {
+  int x;
+  for (x = 0; x < width - 1; x += 2) {
+    YuvPixel(src_uyvy[1], src_uyvy[0], src_uyvy[2], rgb_buf + 0, rgb_buf + 1,
+             rgb_buf + 2, yuvconstants);
+    rgb_buf[3] = 255;
+    YuvPixel(src_uyvy[3], src_uyvy[0], src_uyvy[2], rgb_buf + 4, rgb_buf + 5,
+             rgb_buf + 6, yuvconstants);
+    rgb_buf[7] = 255;
+    src_uyvy += 4;
+    rgb_buf += 8;  // Advance 2 pixels.
+  }
+  if (width & 1) {
+    YuvPixel(src_uyvy[1], src_uyvy[0], src_uyvy[2], rgb_buf + 0, rgb_buf + 1,
+             rgb_buf + 2, yuvconstants);
+    rgb_buf[3] = 255;
+  }
+}
+
+void I422ToRGBARow_C(const uint8_t* src_y,
+                     const uint8_t* src_u,
+                     const uint8_t* src_v,
+                     uint8_t* rgb_buf,
+                     const struct YuvConstants* yuvconstants,
+                     int width) {
+  int x;
+  for (x = 0; x < width - 1; x += 2) {
+    YuvPixel(src_y[0], src_u[0], src_v[0], rgb_buf + 1, rgb_buf + 2,
+             rgb_buf + 3, yuvconstants);
+    rgb_buf[0] = 255;
+    YuvPixel(src_y[1], src_u[0], src_v[0], rgb_buf + 5, rgb_buf + 6,
+             rgb_buf + 7, yuvconstants);
+    rgb_buf[4] = 255;
+    src_y += 2;
+    src_u += 1;
+    src_v += 1;
+    rgb_buf += 8;  // Advance 2 pixels.
+  }
+  if (width & 1) {
+    YuvPixel(src_y[0], src_u[0], src_v[0], rgb_buf + 1, rgb_buf + 2,
+             rgb_buf + 3, yuvconstants);
+    rgb_buf[0] = 255;
+  }
+}
+
+void I400ToARGBRow_C(const uint8_t* src_y,
+                     uint8_t* rgb_buf,
+                     const struct YuvConstants* yuvconstants,
+                     int width) {
+  int x;
+  for (x = 0; x < width - 1; x += 2) {
+    YPixel(src_y[0], rgb_buf + 0, rgb_buf + 1, rgb_buf + 2, yuvconstants);
+    rgb_buf[3] = 255;
+    YPixel(src_y[1], rgb_buf + 4, rgb_buf + 5, rgb_buf + 6, yuvconstants);
+    rgb_buf[7] = 255;
+    src_y += 2;
+    rgb_buf += 8;  // Advance 2 pixels.
+  }
+  if (width & 1) {
+    YPixel(src_y[0], rgb_buf + 0, rgb_buf + 1, rgb_buf + 2, yuvconstants);
+    rgb_buf[3] = 255;
+  }
+}
+
+void MirrorRow_C(const uint8_t* src, uint8_t* dst, int width) {
+  int x;
+  src += width - 1;
+  for (x = 0; x < width - 1; x += 2) {
+    dst[x] = src[0];
+    dst[x + 1] = src[-1];
+    src -= 2;
+  }
+  if (width & 1) {
+    dst[width - 1] = src[0];
+  }
+}
+
+void MirrorUVRow_C(const uint8_t* src_uv, uint8_t* dst_uv, int width) {
+  int x;
+  src_uv += (width - 1) << 1;
+  for (x = 0; x < width; ++x) {
+    dst_uv[0] = src_uv[0];
+    dst_uv[1] = src_uv[1];
+    src_uv -= 2;
+    dst_uv += 2;
+  }
+}
+
+void MirrorSplitUVRow_C(const uint8_t* src_uv,
+                        uint8_t* dst_u,
+                        uint8_t* dst_v,
+                        int width) {
+  int x;
+  src_uv += (width - 1) << 1;
+  for (x = 0; x < width - 1; x += 2) {
+    dst_u[x] = src_uv[0];
+    dst_u[x + 1] = src_uv[-2];
+    dst_v[x] = src_uv[1];
+    dst_v[x + 1] = src_uv[-2 + 1];
+    src_uv -= 4;
+  }
+  if (width & 1) {
+    dst_u[width - 1] = src_uv[0];
+    dst_v[width - 1] = src_uv[1];
+  }
+}
+
+void ARGBMirrorRow_C(const uint8_t* src, uint8_t* dst, int width) {
+  int x;
+  const uint32_t* src32 = (const uint32_t*)(src);
+  uint32_t* dst32 = (uint32_t*)(dst);
+  src32 += width - 1;
+  for (x = 0; x < width - 1; x += 2) {
+    dst32[x] = src32[0];
+    dst32[x + 1] = src32[-1];
+    src32 -= 2;
+  }
+  if (width & 1) {
+    dst32[width - 1] = src32[0];
+  }
+}
+
+void RGB24MirrorRow_C(const uint8_t* src_rgb24, uint8_t* dst_rgb24, int width) {
+  int x;
+  src_rgb24 += width * 3 - 3;
+  for (x = 0; x < width; ++x) {
+    uint8_t b = src_rgb24[0];
+    uint8_t g = src_rgb24[1];
+    uint8_t r = src_rgb24[2];
+    dst_rgb24[0] = b;
+    dst_rgb24[1] = g;
+    dst_rgb24[2] = r;
+    src_rgb24 -= 3;
+    dst_rgb24 += 3;
+  }
+}
+
+void DetileRow_C(const uint8_t* src,
+                 ptrdiff_t src_tile_stride,
+                 uint8_t* dst,
+                 int width) {
+  int x;
+  for (x = 0; x < width - 15; x += 16) {
+    memcpy(dst, src, 16);
+    dst += 16;
+    src += src_tile_stride;
+  }
+  if (width & 15) {
+    memcpy(dst, src, width & 15);
+  }
+}
+
+void DetileSplitUVRow_C(const uint8_t* src_uv,
+                        ptrdiff_t src_tile_stride,
+                        uint8_t* dst_u,
+                        uint8_t* dst_v,
+                        int width) {
+  int tile;
+  for (tile = 0; tile < width / 16; tile++) {
+    for (int x = 0; x < 8; x++) {
+      *dst_u++ = src_uv[0];
+      *dst_v++ = src_uv[1];
+      src_uv += 2;
+    }
+    src_uv += src_tile_stride - 16;
+  }
+  for (int x = 0; x < (width & 0xF) / 2; ++x) {
+    *dst_u = *src_uv;
+    dst_u++;
+    src_uv++;
+    *dst_v = *src_uv;
+    dst_v++;
+    src_uv++;
+  }
+}
+
+void SplitUVRow_C(const uint8_t* src_uv,
+                  uint8_t* dst_u,
+                  uint8_t* dst_v,
+                  int width) {
+  int x;
+  for (x = 0; x < width - 1; x += 2) {
+    dst_u[x] = src_uv[0];
+    dst_u[x + 1] = src_uv[2];
+    dst_v[x] = src_uv[1];
+    dst_v[x + 1] = src_uv[3];
+    src_uv += 4;
+  }
+  if (width & 1) {
+    dst_u[width - 1] = src_uv[0];
+    dst_v[width - 1] = src_uv[1];
+  }
+}
+
+void MergeUVRow_C(const uint8_t* src_u,
+                  const uint8_t* src_v,
+                  uint8_t* dst_uv,
+                  int width) {
+  int x;
+  for (x = 0; x < width - 1; x += 2) {
+    dst_uv[0] = src_u[x];
+    dst_uv[1] = src_v[x];
+    dst_uv[2] = src_u[x + 1];
+    dst_uv[3] = src_v[x + 1];
+    dst_uv += 4;
+  }
+  if (width & 1) {
+    dst_uv[0] = src_u[width - 1];
+    dst_uv[1] = src_v[width - 1];
+  }
+}
+
+void SplitRGBRow_C(const uint8_t* src_rgb,
+                   uint8_t* dst_r,
+                   uint8_t* dst_g,
+                   uint8_t* dst_b,
+                   int width) {
+  int x;
+  for (x = 0; x < width; ++x) {
+    dst_r[x] = src_rgb[0];
+    dst_g[x] = src_rgb[1];
+    dst_b[x] = src_rgb[2];
+    src_rgb += 3;
+  }
+}
+
+void MergeRGBRow_C(const uint8_t* src_r,
+                   const uint8_t* src_g,
+                   const uint8_t* src_b,
+                   uint8_t* dst_rgb,
+                   int width) {
+  int x;
+  for (x = 0; x < width; ++x) {
+    dst_rgb[0] = src_r[x];
+    dst_rgb[1] = src_g[x];
+    dst_rgb[2] = src_b[x];
+    dst_rgb += 3;
+  }
+}
+
+void SplitARGBRow_C(const uint8_t* src_argb,
+                    uint8_t* dst_r,
+                    uint8_t* dst_g,
+                    uint8_t* dst_b,
+                    uint8_t* dst_a,
+                    int width) {
+  int x;
+  for (x = 0; x < width; ++x) {
+    dst_b[x] = src_argb[0];
+    dst_g[x] = src_argb[1];
+    dst_r[x] = src_argb[2];
+    dst_a[x] = src_argb[3];
+    src_argb += 4;
+  }
+}
+
+void MergeARGBRow_C(const uint8_t* src_r,
+                    const uint8_t* src_g,
+                    const uint8_t* src_b,
+                    const uint8_t* src_a,
+                    uint8_t* dst_argb,
+                    int width) {
+  int x;
+  for (x = 0; x < width; ++x) {
+    dst_argb[0] = src_b[x];
+    dst_argb[1] = src_g[x];
+    dst_argb[2] = src_r[x];
+    dst_argb[3] = src_a[x];
+    dst_argb += 4;
+  }
+}
+
+void MergeXR30Row_C(const uint16_t* src_r,
+                    const uint16_t* src_g,
+                    const uint16_t* src_b,
+                    uint8_t* dst_ar30,
+                    int depth,
+                    int width) {
+  assert(depth >= 10);
+  assert(depth <= 16);
+  int x;
+  int shift = depth - 10;
+  uint32_t* dst_ar30_32 = (uint32_t*)dst_ar30;
+  for (x = 0; x < width; ++x) {
+    uint32_t r = clamp1023(src_r[x] >> shift);
+    uint32_t g = clamp1023(src_g[x] >> shift);
+    uint32_t b = clamp1023(src_b[x] >> shift);
+    dst_ar30_32[x] = b | (g << 10) | (r << 20) | 0xc0000000;
+  }
+}
+
+void MergeAR64Row_C(const uint16_t* src_r,
+                    const uint16_t* src_g,
+                    const uint16_t* src_b,
+                    const uint16_t* src_a,
+                    uint16_t* dst_ar64,
+                    int depth,
+                    int width) {
+  assert(depth >= 1);
+  assert(depth <= 16);
+  int x;
+  int shift = 16 - depth;
+  int max = (1 << depth) - 1;
+  for (x = 0; x < width; ++x) {
+    dst_ar64[0] = ClampMax(src_b[x], max) << shift;
+    dst_ar64[1] = ClampMax(src_g[x], max) << shift;
+    dst_ar64[2] = ClampMax(src_r[x], max) << shift;
+    dst_ar64[3] = ClampMax(src_a[x], max) << shift;
+    dst_ar64 += 4;
+  }
+}
+
+void MergeARGB16To8Row_C(const uint16_t* src_r,
+                         const uint16_t* src_g,
+                         const uint16_t* src_b,
+                         const uint16_t* src_a,
+                         uint8_t* dst_argb,
+                         int depth,
+                         int width) {
+  assert(depth >= 8);
+  assert(depth <= 16);
+  int x;
+  int shift = depth - 8;
+  for (x = 0; x < width; ++x) {
+    dst_argb[0] = clamp255(src_b[x] >> shift);
+    dst_argb[1] = clamp255(src_g[x] >> shift);
+    dst_argb[2] = clamp255(src_r[x] >> shift);
+    dst_argb[3] = clamp255(src_a[x] >> shift);
+    dst_argb += 4;
+  }
+}
+
+void MergeXR64Row_C(const uint16_t* src_r,
+                    const uint16_t* src_g,
+                    const uint16_t* src_b,
+                    uint16_t* dst_ar64,
+                    int depth,
+                    int width) {
+  assert(depth >= 1);
+  assert(depth <= 16);
+  int x;
+  int shift = 16 - depth;
+  int max = (1 << depth) - 1;
+  for (x = 0; x < width; ++x) {
+    dst_ar64[0] = ClampMax(src_b[x], max) << shift;
+    dst_ar64[1] = ClampMax(src_g[x], max) << shift;
+    dst_ar64[2] = ClampMax(src_r[x], max) << shift;
+    dst_ar64[3] = 0xffff;
+    dst_ar64 += 4;
+  }
+}
+
+void MergeXRGB16To8Row_C(const uint16_t* src_r,
+                         const uint16_t* src_g,
+                         const uint16_t* src_b,
+                         uint8_t* dst_argb,
+                         int depth,
+                         int width) {
+  assert(depth >= 8);
+  assert(depth <= 16);
+  int x;
+  int shift = depth - 8;
+  for (x = 0; x < width; ++x) {
+    dst_argb[0] = clamp255(src_b[x] >> shift);
+    dst_argb[1] = clamp255(src_g[x] >> shift);
+    dst_argb[2] = clamp255(src_r[x] >> shift);
+    dst_argb[3] = 0xff;
+    dst_argb += 4;
+  }
+}
+
+void SplitXRGBRow_C(const uint8_t* src_argb,
+                    uint8_t* dst_r,
+                    uint8_t* dst_g,
+                    uint8_t* dst_b,
+                    int width) {
+  int x;
+  for (x = 0; x < width; ++x) {
+    dst_b[x] = src_argb[0];
+    dst_g[x] = src_argb[1];
+    dst_r[x] = src_argb[2];
+    src_argb += 4;
+  }
+}
+
+void MergeXRGBRow_C(const uint8_t* src_r,
+                    const uint8_t* src_g,
+                    const uint8_t* src_b,
+                    uint8_t* dst_argb,
+                    int width) {
+  int x;
+  for (x = 0; x < width; ++x) {
+    dst_argb[0] = src_b[x];
+    dst_argb[1] = src_g[x];
+    dst_argb[2] = src_r[x];
+    dst_argb[3] = 255;
+    dst_argb += 4;
+  }
+}
+
+// Convert lsb formats to msb, depending on sample depth.
+void MergeUVRow_16_C(const uint16_t* src_u,
+                     const uint16_t* src_v,
+                     uint16_t* dst_uv,
+                     int depth,
+                     int width) {
+  int shift = 16 - depth;
+  assert(depth >= 8);
+  assert(depth <= 16);
+  int x;
+  for (x = 0; x < width; ++x) {
+    dst_uv[0] = src_u[x] << shift;
+    dst_uv[1] = src_v[x] << shift;
+    dst_uv += 2;
+  }
+}
+
+// Convert msb formats to lsb, depending on sample depth.
+void SplitUVRow_16_C(const uint16_t* src_uv,
+                     uint16_t* dst_u,
+                     uint16_t* dst_v,
+                     int depth,
+                     int width) {
+  int shift = 16 - depth;
+  int x;
+  assert(depth >= 8);
+  assert(depth <= 16);
+  for (x = 0; x < width; ++x) {
+    dst_u[x] = src_uv[0] >> shift;
+    dst_v[x] = src_uv[1] >> shift;
+    src_uv += 2;
+  }
+}
+
+void MultiplyRow_16_C(const uint16_t* src_y,
+                      uint16_t* dst_y,
+                      int scale,
+                      int width) {
+  int x;
+  for (x = 0; x < width; ++x) {
+    dst_y[x] = src_y[x] * scale;
+  }
+}
+
+void DivideRow_16_C(const uint16_t* src_y,
+                    uint16_t* dst_y,
+                    int scale,
+                    int width) {
+  int x;
+  for (x = 0; x < width; ++x) {
+    dst_y[x] = (src_y[x] * scale) >> 16;
+  }
+}
+
+// Use scale to convert lsb formats to msb, depending how many bits there are:
+// 32768 = 9 bits
+// 16384 = 10 bits
+// 4096 = 12 bits
+// 256 = 16 bits
+// TODO(fbarchard): change scale to bits
+#define C16TO8(v, scale) clamp255(((v) * (scale)) >> 16)
+
+void Convert16To8Row_C(const uint16_t* src_y,
+                       uint8_t* dst_y,
+                       int scale,
+                       int width) {
+  int x;
+  assert(scale >= 256);
+  assert(scale <= 32768);
+
+  for (x = 0; x < width; ++x) {
+    dst_y[x] = C16TO8(src_y[x], scale);
+  }
+}
+
+// Use scale to convert lsb formats to msb, depending how many bits there are:
+// 1024 = 10 bits
+void Convert8To16Row_C(const uint8_t* src_y,
+                       uint16_t* dst_y,
+                       int scale,
+                       int width) {
+  int x;
+  scale *= 0x0101;  // replicates the byte.
+  for (x = 0; x < width; ++x) {
+    dst_y[x] = (src_y[x] * scale) >> 16;
+  }
+}
+
+void CopyRow_C(const uint8_t* src, uint8_t* dst, int count) {
+  memcpy(dst, src, count);
+}
+
+void CopyRow_16_C(const uint16_t* src, uint16_t* dst, int count) {
+  memcpy(dst, src, count * 2);
+}
+
+void SetRow_C(uint8_t* dst, uint8_t v8, int width) {
+  memset(dst, v8, width);
+}
+
+void ARGBSetRow_C(uint8_t* dst_argb, uint32_t v32, int width) {
+  int x;
+  for (x = 0; x < width; ++x) {
+    memcpy(dst_argb + x * sizeof v32, &v32, sizeof v32);
+  }
+}
+
+// Filter 2 rows of YUY2 UV's (422) into U and V (420).
+void YUY2ToUVRow_C(const uint8_t* src_yuy2,
+                   int src_stride_yuy2,
+                   uint8_t* dst_u,
+                   uint8_t* dst_v,
+                   int width) {
+  // Output a row of UV values, filtering 2 rows of YUY2.
+  int x;
+  for (x = 0; x < width; x += 2) {
+    dst_u[0] = (src_yuy2[1] + src_yuy2[src_stride_yuy2 + 1] + 1) >> 1;
+    dst_v[0] = (src_yuy2[3] + src_yuy2[src_stride_yuy2 + 3] + 1) >> 1;
+    src_yuy2 += 4;
+    dst_u += 1;
+    dst_v += 1;
+  }
+}
+
+// Copy row of YUY2 UV's (422) into U and V (422).
+void YUY2ToUV422Row_C(const uint8_t* src_yuy2,
+                      uint8_t* dst_u,
+                      uint8_t* dst_v,
+                      int width) {
+  // Output a row of UV values.
+  int x;
+  for (x = 0; x < width; x += 2) {
+    dst_u[0] = src_yuy2[1];
+    dst_v[0] = src_yuy2[3];
+    src_yuy2 += 4;
+    dst_u += 1;
+    dst_v += 1;
+  }
+}
+
+// Copy row of YUY2 Y's (422) into Y (420/422).
+void YUY2ToYRow_C(const uint8_t* src_yuy2, uint8_t* dst_y, int width) {
+  // Output a row of Y values.
+  int x;
+  for (x = 0; x < width - 1; x += 2) {
+    dst_y[x] = src_yuy2[0];
+    dst_y[x + 1] = src_yuy2[2];
+    src_yuy2 += 4;
+  }
+  if (width & 1) {
+    dst_y[width - 1] = src_yuy2[0];
+  }
+}
+
+// Filter 2 rows of UYVY UV's (422) into U and V (420).
+void UYVYToUVRow_C(const uint8_t* src_uyvy,
+                   int src_stride_uyvy,
+                   uint8_t* dst_u,
+                   uint8_t* dst_v,
+                   int width) {
+  // Output a row of UV values.
+  int x;
+  for (x = 0; x < width; x += 2) {
+    dst_u[0] = (src_uyvy[0] + src_uyvy[src_stride_uyvy + 0] + 1) >> 1;
+    dst_v[0] = (src_uyvy[2] + src_uyvy[src_stride_uyvy + 2] + 1) >> 1;
+    src_uyvy += 4;
+    dst_u += 1;
+    dst_v += 1;
+  }
+}
+
+// Copy row of UYVY UV's (422) into U and V (422).
+void UYVYToUV422Row_C(const uint8_t* src_uyvy,
+                      uint8_t* dst_u,
+                      uint8_t* dst_v,
+                      int width) {
+  // Output a row of UV values.
+  int x;
+  for (x = 0; x < width; x += 2) {
+    dst_u[0] = src_uyvy[0];
+    dst_v[0] = src_uyvy[2];
+    src_uyvy += 4;
+    dst_u += 1;
+    dst_v += 1;
+  }
+}
+
+// Copy row of UYVY Y's (422) into Y (420/422).
+void UYVYToYRow_C(const uint8_t* src_uyvy, uint8_t* dst_y, int width) {
+  // Output a row of Y values.
+  int x;
+  for (x = 0; x < width - 1; x += 2) {
+    dst_y[x] = src_uyvy[1];
+    dst_y[x + 1] = src_uyvy[3];
+    src_uyvy += 4;
+  }
+  if (width & 1) {
+    dst_y[width - 1] = src_uyvy[1];
+  }
+}
+
+#define BLEND(f, b, a) clamp255((((256 - a) * b) >> 8) + f)
+
+// Blend src_argb over src_argb1 and store to dst_argb.
+// dst_argb may be src_argb or src_argb1.
+// This code mimics the SSSE3 version for better testability.
+void ARGBBlendRow_C(const uint8_t* src_argb,
+                    const uint8_t* src_argb1,
+                    uint8_t* dst_argb,
+                    int width) {
+  int x;
+  for (x = 0; x < width - 1; x += 2) {
+    uint32_t fb = src_argb[0];
+    uint32_t fg = src_argb[1];
+    uint32_t fr = src_argb[2];
+    uint32_t a = src_argb[3];
+    uint32_t bb = src_argb1[0];
+    uint32_t bg = src_argb1[1];
+    uint32_t br = src_argb1[2];
+    dst_argb[0] = BLEND(fb, bb, a);
+    dst_argb[1] = BLEND(fg, bg, a);
+    dst_argb[2] = BLEND(fr, br, a);
+    dst_argb[3] = 255u;
+
+    fb = src_argb[4 + 0];
+    fg = src_argb[4 + 1];
+    fr = src_argb[4 + 2];
+    a = src_argb[4 + 3];
+    bb = src_argb1[4 + 0];
+    bg = src_argb1[4 + 1];
+    br = src_argb1[4 + 2];
+    dst_argb[4 + 0] = BLEND(fb, bb, a);
+    dst_argb[4 + 1] = BLEND(fg, bg, a);
+    dst_argb[4 + 2] = BLEND(fr, br, a);
+    dst_argb[4 + 3] = 255u;
+    src_argb += 8;
+    src_argb1 += 8;
+    dst_argb += 8;
+  }
+
+  if (width & 1) {
+    uint32_t fb = src_argb[0];
+    uint32_t fg = src_argb[1];
+    uint32_t fr = src_argb[2];
+    uint32_t a = src_argb[3];
+    uint32_t bb = src_argb1[0];
+    uint32_t bg = src_argb1[1];
+    uint32_t br = src_argb1[2];
+    dst_argb[0] = BLEND(fb, bb, a);
+    dst_argb[1] = BLEND(fg, bg, a);
+    dst_argb[2] = BLEND(fr, br, a);
+    dst_argb[3] = 255u;
+  }
+}
+#undef BLEND
+
+#define UBLEND(f, b, a) (((a)*f) + ((255 - a) * b) + 255) >> 8
+void BlendPlaneRow_C(const uint8_t* src0,
+                     const uint8_t* src1,
+                     const uint8_t* alpha,
+                     uint8_t* dst,
+                     int width) {
+  int x;
+  for (x = 0; x < width - 1; x += 2) {
+    dst[0] = UBLEND(src0[0], src1[0], alpha[0]);
+    dst[1] = UBLEND(src0[1], src1[1], alpha[1]);
+    src0 += 2;
+    src1 += 2;
+    alpha += 2;
+    dst += 2;
+  }
+  if (width & 1) {
+    dst[0] = UBLEND(src0[0], src1[0], alpha[0]);
+  }
+}
+#undef UBLEND
+
+#if LIBYUV_ATTENUATE_DUP
+// This code mimics the SSSE3 version for better testability.
+#define ATTENUATE(f, a) (a | (a << 8)) * (f | (f << 8)) >> 24
+#else
+#define ATTENUATE(f, a) (f * a + 128) >> 8
+#endif
+
+// Multiply source RGB by alpha and store to destination.
+void ARGBAttenuateRow_C(const uint8_t* src_argb, uint8_t* dst_argb, int width) {
+  int i;
+  for (i = 0; i < width - 1; i += 2) {
+    uint32_t b = src_argb[0];
+    uint32_t g = src_argb[1];
+    uint32_t r = src_argb[2];
+    uint32_t a = src_argb[3];
+    dst_argb[0] = ATTENUATE(b, a);
+    dst_argb[1] = ATTENUATE(g, a);
+    dst_argb[2] = ATTENUATE(r, a);
+    dst_argb[3] = a;
+    b = src_argb[4];
+    g = src_argb[5];
+    r = src_argb[6];
+    a = src_argb[7];
+    dst_argb[4] = ATTENUATE(b, a);
+    dst_argb[5] = ATTENUATE(g, a);
+    dst_argb[6] = ATTENUATE(r, a);
+    dst_argb[7] = a;
+    src_argb += 8;
+    dst_argb += 8;
+  }
+
+  if (width & 1) {
+    const uint32_t b = src_argb[0];
+    const uint32_t g = src_argb[1];
+    const uint32_t r = src_argb[2];
+    const uint32_t a = src_argb[3];
+    dst_argb[0] = ATTENUATE(b, a);
+    dst_argb[1] = ATTENUATE(g, a);
+    dst_argb[2] = ATTENUATE(r, a);
+    dst_argb[3] = a;
+  }
+}
+#undef ATTENUATE
+
+// Divide source RGB by alpha and store to destination.
+// b = (b * 255 + (a / 2)) / a;
+// g = (g * 255 + (a / 2)) / a;
+// r = (r * 255 + (a / 2)) / a;
+// Reciprocal method is off by 1 on some values. ie 125
+// 8.8 fixed point inverse table with 1.0 in upper short and 1 / a in lower.
+#define T(a) 0x01000000 + (0x10000 / a)
+const uint32_t fixed_invtbl8[256] = {
+    0x01000000, 0x0100ffff, T(0x02), T(0x03),   T(0x04), T(0x05), T(0x06),
+    T(0x07),    T(0x08),    T(0x09), T(0x0a),   T(0x0b), T(0x0c), T(0x0d),
+    T(0x0e),    T(0x0f),    T(0x10), T(0x11),   T(0x12), T(0x13), T(0x14),
+    T(0x15),    T(0x16),    T(0x17), T(0x18),   T(0x19), T(0x1a), T(0x1b),
+    T(0x1c),    T(0x1d),    T(0x1e), T(0x1f),   T(0x20), T(0x21), T(0x22),
+    T(0x23),    T(0x24),    T(0x25), T(0x26),   T(0x27), T(0x28), T(0x29),
+    T(0x2a),    T(0x2b),    T(0x2c), T(0x2d),   T(0x2e), T(0x2f), T(0x30),
+    T(0x31),    T(0x32),    T(0x33), T(0x34),   T(0x35), T(0x36), T(0x37),
+    T(0x38),    T(0x39),    T(0x3a), T(0x3b),   T(0x3c), T(0x3d), T(0x3e),
+    T(0x3f),    T(0x40),    T(0x41), T(0x42),   T(0x43), T(0x44), T(0x45),
+    T(0x46),    T(0x47),    T(0x48), T(0x49),   T(0x4a), T(0x4b), T(0x4c),
+    T(0x4d),    T(0x4e),    T(0x4f), T(0x50),   T(0x51), T(0x52), T(0x53),
+    T(0x54),    T(0x55),    T(0x56), T(0x57),   T(0x58), T(0x59), T(0x5a),
+    T(0x5b),    T(0x5c),    T(0x5d), T(0x5e),   T(0x5f), T(0x60), T(0x61),
+    T(0x62),    T(0x63),    T(0x64), T(0x65),   T(0x66), T(0x67), T(0x68),
+    T(0x69),    T(0x6a),    T(0x6b), T(0x6c),   T(0x6d), T(0x6e), T(0x6f),
+    T(0x70),    T(0x71),    T(0x72), T(0x73),   T(0x74), T(0x75), T(0x76),
+    T(0x77),    T(0x78),    T(0x79), T(0x7a),   T(0x7b), T(0x7c), T(0x7d),
+    T(0x7e),    T(0x7f),    T(0x80), T(0x81),   T(0x82), T(0x83), T(0x84),
+    T(0x85),    T(0x86),    T(0x87), T(0x88),   T(0x89), T(0x8a), T(0x8b),
+    T(0x8c),    T(0x8d),    T(0x8e), T(0x8f),   T(0x90), T(0x91), T(0x92),
+    T(0x93),    T(0x94),    T(0x95), T(0x96),   T(0x97), T(0x98), T(0x99),
+    T(0x9a),    T(0x9b),    T(0x9c), T(0x9d),   T(0x9e), T(0x9f), T(0xa0),
+    T(0xa1),    T(0xa2),    T(0xa3), T(0xa4),   T(0xa5), T(0xa6), T(0xa7),
+    T(0xa8),    T(0xa9),    T(0xaa), T(0xab),   T(0xac), T(0xad), T(0xae),
+    T(0xaf),    T(0xb0),    T(0xb1), T(0xb2),   T(0xb3), T(0xb4), T(0xb5),
+    T(0xb6),    T(0xb7),    T(0xb8), T(0xb9),   T(0xba), T(0xbb), T(0xbc),
+    T(0xbd),    T(0xbe),    T(0xbf), T(0xc0),   T(0xc1), T(0xc2), T(0xc3),
+    T(0xc4),    T(0xc5),    T(0xc6), T(0xc7),   T(0xc8), T(0xc9), T(0xca),
+    T(0xcb),    T(0xcc),    T(0xcd), T(0xce),   T(0xcf), T(0xd0), T(0xd1),
+    T(0xd2),    T(0xd3),    T(0xd4), T(0xd5),   T(0xd6), T(0xd7), T(0xd8),
+    T(0xd9),    T(0xda),    T(0xdb), T(0xdc),   T(0xdd), T(0xde), T(0xdf),
+    T(0xe0),    T(0xe1),    T(0xe2), T(0xe3),   T(0xe4), T(0xe5), T(0xe6),
+    T(0xe7),    T(0xe8),    T(0xe9), T(0xea),   T(0xeb), T(0xec), T(0xed),
+    T(0xee),    T(0xef),    T(0xf0), T(0xf1),   T(0xf2), T(0xf3), T(0xf4),
+    T(0xf5),    T(0xf6),    T(0xf7), T(0xf8),   T(0xf9), T(0xfa), T(0xfb),
+    T(0xfc),    T(0xfd),    T(0xfe), 0x01000100};
+#undef T
+
+#if LIBYUV_UNATTENUATE_DUP
+// This code mimics the Intel SIMD version for better testability.
+#define UNATTENUATE(f, ia) clamp255(((f | (f << 8)) * ia) >> 16)
+#else
+#define UNATTENUATE(f, ia) clamp255((f * ia) >> 8)
+#endif
+
+// mimics the Intel SIMD code for exactness.
+void ARGBUnattenuateRow_C(const uint8_t* src_argb,
+                          uint8_t* dst_argb,
+                          int width) {
+  int i;
+  for (i = 0; i < width; ++i) {
+    uint32_t b = src_argb[0];
+    uint32_t g = src_argb[1];
+    uint32_t r = src_argb[2];
+    const uint32_t a = src_argb[3];
+    const uint32_t ia = fixed_invtbl8[a] & 0xffff;  // 8.8 fixed point
+
+    // Clamping should not be necessary but is free in assembly.
+    dst_argb[0] = UNATTENUATE(b, ia);
+    dst_argb[1] = UNATTENUATE(g, ia);
+    dst_argb[2] = UNATTENUATE(r, ia);
+    dst_argb[3] = a;
+    src_argb += 4;
+    dst_argb += 4;
+  }
+}
+
+void ComputeCumulativeSumRow_C(const uint8_t* row,
+                               int32_t* cumsum,
+                               const int32_t* previous_cumsum,
+                               int width) {
+  int32_t row_sum[4] = {0, 0, 0, 0};
+  int x;
+  for (x = 0; x < width; ++x) {
+    row_sum[0] += row[x * 4 + 0];
+    row_sum[1] += row[x * 4 + 1];
+    row_sum[2] += row[x * 4 + 2];
+    row_sum[3] += row[x * 4 + 3];
+    cumsum[x * 4 + 0] = row_sum[0] + previous_cumsum[x * 4 + 0];
+    cumsum[x * 4 + 1] = row_sum[1] + previous_cumsum[x * 4 + 1];
+    cumsum[x * 4 + 2] = row_sum[2] + previous_cumsum[x * 4 + 2];
+    cumsum[x * 4 + 3] = row_sum[3] + previous_cumsum[x * 4 + 3];
+  }
+}
+
+void CumulativeSumToAverageRow_C(const int32_t* tl,
+                                 const int32_t* bl,
+                                 int w,
+                                 int area,
+                                 uint8_t* dst,
+                                 int count) {
+  float ooa;
+  int i;
+  assert(area != 0);
+
+  ooa = 1.0f / area;
+  for (i = 0; i < count; ++i) {
+    dst[0] = (uint8_t)((bl[w + 0] + tl[0] - bl[0] - tl[w + 0]) * ooa);
+    dst[1] = (uint8_t)((bl[w + 1] + tl[1] - bl[1] - tl[w + 1]) * ooa);
+    dst[2] = (uint8_t)((bl[w + 2] + tl[2] - bl[2] - tl[w + 2]) * ooa);
+    dst[3] = (uint8_t)((bl[w + 3] + tl[3] - bl[3] - tl[w + 3]) * ooa);
+    dst += 4;
+    tl += 4;
+    bl += 4;
+  }
+}
+
+// Copy pixels from rotated source to destination row with a slope.
+LIBYUV_API
+void ARGBAffineRow_C(const uint8_t* src_argb,
+                     int src_argb_stride,
+                     uint8_t* dst_argb,
+                     const float* uv_dudv,
+                     int width) {
+  int i;
+  // Render a row of pixels from source into a buffer.
+  float uv[2];
+  uv[0] = uv_dudv[0];
+  uv[1] = uv_dudv[1];
+  for (i = 0; i < width; ++i) {
+    int x = (int)(uv[0]);
+    int y = (int)(uv[1]);
+    *(uint32_t*)(dst_argb) =
+        *(const uint32_t*)(src_argb + y * src_argb_stride + x * 4);
+    dst_argb += 4;
+    uv[0] += uv_dudv[2];
+    uv[1] += uv_dudv[3];
+  }
+}
+
+// Blend 2 rows into 1.
+static void HalfRow_C(const uint8_t* src_uv,
+                      ptrdiff_t src_uv_stride,
+                      uint8_t* dst_uv,
+                      int width) {
+  int x;
+  for (x = 0; x < width; ++x) {
+    dst_uv[x] = (src_uv[x] + src_uv[src_uv_stride + x] + 1) >> 1;
+  }
+}
+
+static void HalfRow_16_C(const uint16_t* src_uv,
+                         ptrdiff_t src_uv_stride,
+                         uint16_t* dst_uv,
+                         int width) {
+  int x;
+  for (x = 0; x < width; ++x) {
+    dst_uv[x] = (src_uv[x] + src_uv[src_uv_stride + x] + 1) >> 1;
+  }
+}
+
+static void HalfRow_16To8_C(const uint16_t* src_uv,
+                            ptrdiff_t src_uv_stride,
+                            uint8_t* dst_uv,
+                            int scale,
+                            int width) {
+  int x;
+  for (x = 0; x < width; ++x) {
+    dst_uv[x] = C16TO8((src_uv[x] + src_uv[src_uv_stride + x] + 1) >> 1, scale);
+  }
+}
+
+// C version 2x2 -> 2x1.
+void InterpolateRow_C(uint8_t* dst_ptr,
+                      const uint8_t* src_ptr,
+                      ptrdiff_t src_stride,
+                      int width,
+                      int source_y_fraction) {
+  int y1_fraction = source_y_fraction;
+  int y0_fraction = 256 - y1_fraction;
+  const uint8_t* src_ptr1 = src_ptr + src_stride;
+  int x;
+  assert(source_y_fraction >= 0);
+  assert(source_y_fraction < 256);
+
+  if (y1_fraction == 0) {
+    memcpy(dst_ptr, src_ptr, width);
+    return;
+  }
+  if (y1_fraction == 128) {
+    HalfRow_C(src_ptr, src_stride, dst_ptr, width);
+    return;
+  }
+  for (x = 0; x < width; ++x) {
+    dst_ptr[0] =
+        (src_ptr[0] * y0_fraction + src_ptr1[0] * y1_fraction + 128) >> 8;
+    ++src_ptr;
+    ++src_ptr1;
+    ++dst_ptr;
+  }
+}
+
+// C version 2x2 -> 2x1.
+void InterpolateRow_16_C(uint16_t* dst_ptr,
+                         const uint16_t* src_ptr,
+                         ptrdiff_t src_stride,
+                         int width,
+                         int source_y_fraction) {
+  int y1_fraction = source_y_fraction;
+  int y0_fraction = 256 - y1_fraction;
+  const uint16_t* src_ptr1 = src_ptr + src_stride;
+  int x;
+  assert(source_y_fraction >= 0);
+  assert(source_y_fraction < 256);
+
+  if (y1_fraction == 0) {
+    memcpy(dst_ptr, src_ptr, width * 2);
+    return;
+  }
+  if (y1_fraction == 128) {
+    HalfRow_16_C(src_ptr, src_stride, dst_ptr, width);
+    return;
+  }
+  for (x = 0; x < width; ++x) {
+    dst_ptr[0] =
+        (src_ptr[0] * y0_fraction + src_ptr1[0] * y1_fraction + 128) >> 8;
+    ++src_ptr;
+    ++src_ptr1;
+    ++dst_ptr;
+  }
+}
+
+// C version 2x2 16 bit-> 2x1 8 bit.
+// Use scale to convert lsb formats to msb, depending how many bits there are:
+// 32768 = 9 bits
+// 16384 = 10 bits
+// 4096 = 12 bits
+// 256 = 16 bits
+// TODO(fbarchard): change scale to bits
+
+void InterpolateRow_16To8_C(uint8_t* dst_ptr,
+                            const uint16_t* src_ptr,
+                            ptrdiff_t src_stride,
+                            int scale,
+                            int width,
+                            int source_y_fraction) {
+  int y1_fraction = source_y_fraction;
+  int y0_fraction = 256 - y1_fraction;
+  const uint16_t* src_ptr1 = src_ptr + src_stride;
+  int x;
+  assert(source_y_fraction >= 0);
+  assert(source_y_fraction < 256);
+
+  if (source_y_fraction == 0) {
+    Convert16To8Row_C(src_ptr, dst_ptr, scale, width);
+    return;
+  }
+  if (source_y_fraction == 128) {
+    HalfRow_16To8_C(src_ptr, src_stride, dst_ptr, scale, width);
+    return;
+  }
+  for (x = 0; x < width; ++x) {
+    dst_ptr[0] = C16TO8(
+        (src_ptr[0] * y0_fraction + src_ptr1[0] * y1_fraction + 128) >> 8,
+        scale);
+    src_ptr += 1;
+    src_ptr1 += 1;
+    dst_ptr += 1;
+  }
+}
+
+// Use first 4 shuffler values to reorder ARGB channels.
+void ARGBShuffleRow_C(const uint8_t* src_argb,
+                      uint8_t* dst_argb,
+                      const uint8_t* shuffler,
+                      int width) {
+  int index0 = shuffler[0];
+  int index1 = shuffler[1];
+  int index2 = shuffler[2];
+  int index3 = shuffler[3];
+  // Shuffle a row of ARGB.
+  int x;
+  for (x = 0; x < width; ++x) {
+    // To support in-place conversion.
+    uint8_t b = src_argb[index0];
+    uint8_t g = src_argb[index1];
+    uint8_t r = src_argb[index2];
+    uint8_t a = src_argb[index3];
+    dst_argb[0] = b;
+    dst_argb[1] = g;
+    dst_argb[2] = r;
+    dst_argb[3] = a;
+    src_argb += 4;
+    dst_argb += 4;
+  }
+}
+
+void I422ToYUY2Row_C(const uint8_t* src_y,
+                     const uint8_t* src_u,
+                     const uint8_t* src_v,
+                     uint8_t* dst_frame,
+                     int width) {
+  int x;
+  for (x = 0; x < width - 1; x += 2) {
+    dst_frame[0] = src_y[0];
+    dst_frame[1] = src_u[0];
+    dst_frame[2] = src_y[1];
+    dst_frame[3] = src_v[0];
+    dst_frame += 4;
+    src_y += 2;
+    src_u += 1;
+    src_v += 1;
+  }
+  if (width & 1) {
+    dst_frame[0] = src_y[0];
+    dst_frame[1] = src_u[0];
+    dst_frame[2] = 0;
+    dst_frame[3] = src_v[0];
+  }
+}
+
+void I422ToUYVYRow_C(const uint8_t* src_y,
+                     const uint8_t* src_u,
+                     const uint8_t* src_v,
+                     uint8_t* dst_frame,
+                     int width) {
+  int x;
+  for (x = 0; x < width - 1; x += 2) {
+    dst_frame[0] = src_u[0];
+    dst_frame[1] = src_y[0];
+    dst_frame[2] = src_v[0];
+    dst_frame[3] = src_y[1];
+    dst_frame += 4;
+    src_y += 2;
+    src_u += 1;
+    src_v += 1;
+  }
+  if (width & 1) {
+    dst_frame[0] = src_u[0];
+    dst_frame[1] = src_y[0];
+    dst_frame[2] = src_v[0];
+    dst_frame[3] = 0;
+  }
+}
+
+void ARGBPolynomialRow_C(const uint8_t* src_argb,
+                         uint8_t* dst_argb,
+                         const float* poly,
+                         int width) {
+  int i;
+  for (i = 0; i < width; ++i) {
+    float b = (float)(src_argb[0]);
+    float g = (float)(src_argb[1]);
+    float r = (float)(src_argb[2]);
+    float a = (float)(src_argb[3]);
+    float b2 = b * b;
+    float g2 = g * g;
+    float r2 = r * r;
+    float a2 = a * a;
+    float db = poly[0] + poly[4] * b;
+    float dg = poly[1] + poly[5] * g;
+    float dr = poly[2] + poly[6] * r;
+    float da = poly[3] + poly[7] * a;
+    float b3 = b2 * b;
+    float g3 = g2 * g;
+    float r3 = r2 * r;
+    float a3 = a2 * a;
+    db += poly[8] * b2;
+    dg += poly[9] * g2;
+    dr += poly[10] * r2;
+    da += poly[11] * a2;
+    db += poly[12] * b3;
+    dg += poly[13] * g3;
+    dr += poly[14] * r3;
+    da += poly[15] * a3;
+
+    dst_argb[0] = Clamp((int32_t)(db));
+    dst_argb[1] = Clamp((int32_t)(dg));
+    dst_argb[2] = Clamp((int32_t)(dr));
+    dst_argb[3] = Clamp((int32_t)(da));
+    src_argb += 4;
+    dst_argb += 4;
+  }
+}
+
+// Samples assumed to be unsigned in low 9, 10 or 12 bits.  Scale factor
+// adjust the source integer range to the half float range desired.
+
+// This magic constant is 2^-112. Multiplying by this
+// is the same as subtracting 112 from the exponent, which
+// is the difference in exponent bias between 32-bit and
+// 16-bit floats. Once we've done this subtraction, we can
+// simply extract the low bits of the exponent and the high
+// bits of the mantissa from our float and we're done.
+
+// Work around GCC 7 punning warning -Wstrict-aliasing
+#if defined(__GNUC__)
+typedef uint32_t __attribute__((__may_alias__)) uint32_alias_t;
+#else
+typedef uint32_t uint32_alias_t;
+#endif
+
+void HalfFloatRow_C(const uint16_t* src,
+                    uint16_t* dst,
+                    float scale,
+                    int width) {
+  int i;
+  float mult = 1.9259299444e-34f * scale;
+  for (i = 0; i < width; ++i) {
+    float value = src[i] * mult;
+    dst[i] = (uint16_t)((*(const uint32_alias_t*)&value) >> 13);
+  }
+}
+
+void ByteToFloatRow_C(const uint8_t* src, float* dst, float scale, int width) {
+  int i;
+  for (i = 0; i < width; ++i) {
+    float value = src[i] * scale;
+    dst[i] = value;
+  }
+}
+
+void ARGBLumaColorTableRow_C(const uint8_t* src_argb,
+                             uint8_t* dst_argb,
+                             int width,
+                             const uint8_t* luma,
+                             uint32_t lumacoeff) {
+  uint32_t bc = lumacoeff & 0xff;
+  uint32_t gc = (lumacoeff >> 8) & 0xff;
+  uint32_t rc = (lumacoeff >> 16) & 0xff;
+
+  int i;
+  for (i = 0; i < width - 1; i += 2) {
+    // Luminance in rows, color values in columns.
+    const uint8_t* luma0 =
+        ((src_argb[0] * bc + src_argb[1] * gc + src_argb[2] * rc) & 0x7F00u) +
+        luma;
+    const uint8_t* luma1;
+    dst_argb[0] = luma0[src_argb[0]];
+    dst_argb[1] = luma0[src_argb[1]];
+    dst_argb[2] = luma0[src_argb[2]];
+    dst_argb[3] = src_argb[3];
+    luma1 =
+        ((src_argb[4] * bc + src_argb[5] * gc + src_argb[6] * rc) & 0x7F00u) +
+        luma;
+    dst_argb[4] = luma1[src_argb[4]];
+    dst_argb[5] = luma1[src_argb[5]];
+    dst_argb[6] = luma1[src_argb[6]];
+    dst_argb[7] = src_argb[7];
+    src_argb += 8;
+    dst_argb += 8;
+  }
+  if (width & 1) {
+    // Luminance in rows, color values in columns.
+    const uint8_t* luma0 =
+        ((src_argb[0] * bc + src_argb[1] * gc + src_argb[2] * rc) & 0x7F00u) +
+        luma;
+    dst_argb[0] = luma0[src_argb[0]];
+    dst_argb[1] = luma0[src_argb[1]];
+    dst_argb[2] = luma0[src_argb[2]];
+    dst_argb[3] = src_argb[3];
+  }
+}
+
+void ARGBCopyAlphaRow_C(const uint8_t* src, uint8_t* dst, int width) {
+  int i;
+  for (i = 0; i < width - 1; i += 2) {
+    dst[3] = src[3];
+    dst[7] = src[7];
+    dst += 8;
+    src += 8;
+  }
+  if (width & 1) {
+    dst[3] = src[3];
+  }
+}
+
+void ARGBExtractAlphaRow_C(const uint8_t* src_argb, uint8_t* dst_a, int width) {
+  int i;
+  for (i = 0; i < width - 1; i += 2) {
+    dst_a[0] = src_argb[3];
+    dst_a[1] = src_argb[7];
+    dst_a += 2;
+    src_argb += 8;
+  }
+  if (width & 1) {
+    dst_a[0] = src_argb[3];
+  }
+}
+
+void ARGBCopyYToAlphaRow_C(const uint8_t* src, uint8_t* dst, int width) {
+  int i;
+  for (i = 0; i < width - 1; i += 2) {
+    dst[3] = src[0];
+    dst[7] = src[1];
+    dst += 8;
+    src += 2;
+  }
+  if (width & 1) {
+    dst[3] = src[0];
+  }
+}
+
+// Maximum temporary width for wrappers to process at a time, in pixels.
+#define MAXTWIDTH 2048
+
+#if !(defined(_MSC_VER) && !defined(__clang__) && defined(_M_IX86)) && \
+    defined(HAS_I422TORGB565ROW_SSSE3)
+// row_win.cc has asm version, but GCC uses 2 step wrapper.
+void I422ToRGB565Row_SSSE3(const uint8_t* src_y,
+                           const uint8_t* src_u,
+                           const uint8_t* src_v,
+                           uint8_t* dst_rgb565,
+                           const struct YuvConstants* yuvconstants,
+                           int width) {
+  SIMD_ALIGNED(uint8_t row[MAXTWIDTH * 4]);
+  while (width > 0) {
+    int twidth = width > MAXTWIDTH ? MAXTWIDTH : width;
+    I422ToARGBRow_SSSE3(src_y, src_u, src_v, row, yuvconstants, twidth);
+    ARGBToRGB565Row_SSE2(row, dst_rgb565, twidth);
+    src_y += twidth;
+    src_u += twidth / 2;
+    src_v += twidth / 2;
+    dst_rgb565 += twidth * 2;
+    width -= twidth;
+  }
+}
+#endif
+
+#if defined(HAS_I422TOARGB1555ROW_SSSE3)
+void I422ToARGB1555Row_SSSE3(const uint8_t* src_y,
+                             const uint8_t* src_u,
+                             const uint8_t* src_v,
+                             uint8_t* dst_argb1555,
+                             const struct YuvConstants* yuvconstants,
+                             int width) {
+  // Row buffer for intermediate ARGB pixels.
+  SIMD_ALIGNED(uint8_t row[MAXTWIDTH * 4]);
+  while (width > 0) {
+    int twidth = width > MAXTWIDTH ? MAXTWIDTH : width;
+    I422ToARGBRow_SSSE3(src_y, src_u, src_v, row, yuvconstants, twidth);
+    ARGBToARGB1555Row_SSE2(row, dst_argb1555, twidth);
+    src_y += twidth;
+    src_u += twidth / 2;
+    src_v += twidth / 2;
+    dst_argb1555 += twidth * 2;
+    width -= twidth;
+  }
+}
+#endif
+
+#if defined(HAS_I422TOARGB4444ROW_SSSE3)
+void I422ToARGB4444Row_SSSE3(const uint8_t* src_y,
+                             const uint8_t* src_u,
+                             const uint8_t* src_v,
+                             uint8_t* dst_argb4444,
+                             const struct YuvConstants* yuvconstants,
+                             int width) {
+  // Row buffer for intermediate ARGB pixels.
+  SIMD_ALIGNED(uint8_t row[MAXTWIDTH * 4]);
+  while (width > 0) {
+    int twidth = width > MAXTWIDTH ? MAXTWIDTH : width;
+    I422ToARGBRow_SSSE3(src_y, src_u, src_v, row, yuvconstants, twidth);
+    ARGBToARGB4444Row_SSE2(row, dst_argb4444, twidth);
+    src_y += twidth;
+    src_u += twidth / 2;
+    src_v += twidth / 2;
+    dst_argb4444 += twidth * 2;
+    width -= twidth;
+  }
+}
+#endif
+
+#if defined(HAS_NV12TORGB565ROW_SSSE3)
+void NV12ToRGB565Row_SSSE3(const uint8_t* src_y,
+                           const uint8_t* src_uv,
+                           uint8_t* dst_rgb565,
+                           const struct YuvConstants* yuvconstants,
+                           int width) {
+  // Row buffer for intermediate ARGB pixels.
+  SIMD_ALIGNED(uint8_t row[MAXTWIDTH * 4]);
+  while (width > 0) {
+    int twidth = width > MAXTWIDTH ? MAXTWIDTH : width;
+    NV12ToARGBRow_SSSE3(src_y, src_uv, row, yuvconstants, twidth);
+    ARGBToRGB565Row_SSE2(row, dst_rgb565, twidth);
+    src_y += twidth;
+    src_uv += twidth;
+    dst_rgb565 += twidth * 2;
+    width -= twidth;
+  }
+}
+#endif
+
+#if defined(HAS_NV12TORGB24ROW_SSSE3)
+void NV12ToRGB24Row_SSSE3(const uint8_t* src_y,
+                          const uint8_t* src_uv,
+                          uint8_t* dst_rgb24,
+                          const struct YuvConstants* yuvconstants,
+                          int width) {
+  // Row buffer for intermediate ARGB pixels.
+  SIMD_ALIGNED(uint8_t row[MAXTWIDTH * 4]);
+  while (width > 0) {
+    int twidth = width > MAXTWIDTH ? MAXTWIDTH : width;
+    NV12ToARGBRow_SSSE3(src_y, src_uv, row, yuvconstants, twidth);
+    ARGBToRGB24Row_SSSE3(row, dst_rgb24, twidth);
+    src_y += twidth;
+    src_uv += twidth;
+    dst_rgb24 += twidth * 3;
+    width -= twidth;
+  }
+}
+#endif
+
+#if defined(HAS_NV21TORGB24ROW_SSSE3)
+void NV21ToRGB24Row_SSSE3(const uint8_t* src_y,
+                          const uint8_t* src_vu,
+                          uint8_t* dst_rgb24,
+                          const struct YuvConstants* yuvconstants,
+                          int width) {
+  // Row buffer for intermediate ARGB pixels.
+  SIMD_ALIGNED(uint8_t row[MAXTWIDTH * 4]);
+  while (width > 0) {
+    int twidth = width > MAXTWIDTH ? MAXTWIDTH : width;
+    NV21ToARGBRow_SSSE3(src_y, src_vu, row, yuvconstants, twidth);
+    ARGBToRGB24Row_SSSE3(row, dst_rgb24, twidth);
+    src_y += twidth;
+    src_vu += twidth;
+    dst_rgb24 += twidth * 3;
+    width -= twidth;
+  }
+}
+#endif
+
+#if defined(HAS_NV12TORGB24ROW_AVX2)
+void NV12ToRGB24Row_AVX2(const uint8_t* src_y,
+                         const uint8_t* src_uv,
+                         uint8_t* dst_rgb24,
+                         const struct YuvConstants* yuvconstants,
+                         int width) {
+  // Row buffer for intermediate ARGB pixels.
+  SIMD_ALIGNED(uint8_t row[MAXTWIDTH * 4]);
+  while (width > 0) {
+    int twidth = width > MAXTWIDTH ? MAXTWIDTH : width;
+    NV12ToARGBRow_AVX2(src_y, src_uv, row, yuvconstants, twidth);
+#if defined(HAS_ARGBTORGB24ROW_AVX2)
+    ARGBToRGB24Row_AVX2(row, dst_rgb24, twidth);
+#else
+    ARGBToRGB24Row_SSSE3(row, dst_rgb24, twidth);
+#endif
+    src_y += twidth;
+    src_uv += twidth;
+    dst_rgb24 += twidth * 3;
+    width -= twidth;
+  }
+}
+#endif
+
+#if defined(HAS_NV21TORGB24ROW_AVX2)
+void NV21ToRGB24Row_AVX2(const uint8_t* src_y,
+                         const uint8_t* src_vu,
+                         uint8_t* dst_rgb24,
+                         const struct YuvConstants* yuvconstants,
+                         int width) {
+  // Row buffer for intermediate ARGB pixels.
+  SIMD_ALIGNED(uint8_t row[MAXTWIDTH * 4]);
+  while (width > 0) {
+    int twidth = width > MAXTWIDTH ? MAXTWIDTH : width;
+    NV21ToARGBRow_AVX2(src_y, src_vu, row, yuvconstants, twidth);
+#if defined(HAS_ARGBTORGB24ROW_AVX2)
+    ARGBToRGB24Row_AVX2(row, dst_rgb24, twidth);
+#else
+    ARGBToRGB24Row_SSSE3(row, dst_rgb24, twidth);
+#endif
+    src_y += twidth;
+    src_vu += twidth;
+    dst_rgb24 += twidth * 3;
+    width -= twidth;
+  }
+}
+#endif
+
+#if defined(HAS_I422TORGB565ROW_AVX2)
+void I422ToRGB565Row_AVX2(const uint8_t* src_y,
+                          const uint8_t* src_u,
+                          const uint8_t* src_v,
+                          uint8_t* dst_rgb565,
+                          const struct YuvConstants* yuvconstants,
+                          int width) {
+  SIMD_ALIGNED(uint8_t row[MAXTWIDTH * 4]);
+  while (width > 0) {
+    int twidth = width > MAXTWIDTH ? MAXTWIDTH : width;
+    I422ToARGBRow_AVX2(src_y, src_u, src_v, row, yuvconstants, twidth);
+#if defined(HAS_ARGBTORGB565ROW_AVX2)
+    ARGBToRGB565Row_AVX2(row, dst_rgb565, twidth);
+#else
+    ARGBToRGB565Row_SSE2(row, dst_rgb565, twidth);
+#endif
+    src_y += twidth;
+    src_u += twidth / 2;
+    src_v += twidth / 2;
+    dst_rgb565 += twidth * 2;
+    width -= twidth;
+  }
+}
+#endif
+
+#if defined(HAS_I422TOARGB1555ROW_AVX2)
+void I422ToARGB1555Row_AVX2(const uint8_t* src_y,
+                            const uint8_t* src_u,
+                            const uint8_t* src_v,
+                            uint8_t* dst_argb1555,
+                            const struct YuvConstants* yuvconstants,
+                            int width) {
+  // Row buffer for intermediate ARGB pixels.
+  SIMD_ALIGNED(uint8_t row[MAXTWIDTH * 4]);
+  while (width > 0) {
+    int twidth = width > MAXTWIDTH ? MAXTWIDTH : width;
+    I422ToARGBRow_AVX2(src_y, src_u, src_v, row, yuvconstants, twidth);
+#if defined(HAS_ARGBTOARGB1555ROW_AVX2)
+    ARGBToARGB1555Row_AVX2(row, dst_argb1555, twidth);
+#else
+    ARGBToARGB1555Row_SSE2(row, dst_argb1555, twidth);
+#endif
+    src_y += twidth;
+    src_u += twidth / 2;
+    src_v += twidth / 2;
+    dst_argb1555 += twidth * 2;
+    width -= twidth;
+  }
+}
+#endif
+
+#if defined(HAS_I422TOARGB4444ROW_AVX2)
+void I422ToARGB4444Row_AVX2(const uint8_t* src_y,
+                            const uint8_t* src_u,
+                            const uint8_t* src_v,
+                            uint8_t* dst_argb4444,
+                            const struct YuvConstants* yuvconstants,
+                            int width) {
+  // Row buffer for intermediate ARGB pixels.
+  SIMD_ALIGNED(uint8_t row[MAXTWIDTH * 4]);
+  while (width > 0) {
+    int twidth = width > MAXTWIDTH ? MAXTWIDTH : width;
+    I422ToARGBRow_AVX2(src_y, src_u, src_v, row, yuvconstants, twidth);
+#if defined(HAS_ARGBTOARGB4444ROW_AVX2)
+    ARGBToARGB4444Row_AVX2(row, dst_argb4444, twidth);
+#else
+    ARGBToARGB4444Row_SSE2(row, dst_argb4444, twidth);
+#endif
+    src_y += twidth;
+    src_u += twidth / 2;
+    src_v += twidth / 2;
+    dst_argb4444 += twidth * 2;
+    width -= twidth;
+  }
+}
+#endif
+
+#if defined(HAS_I422TORGB24ROW_AVX2)
+void I422ToRGB24Row_AVX2(const uint8_t* src_y,
+                         const uint8_t* src_u,
+                         const uint8_t* src_v,
+                         uint8_t* dst_rgb24,
+                         const struct YuvConstants* yuvconstants,
+                         int width) {
+  // Row buffer for intermediate ARGB pixels.
+  SIMD_ALIGNED(uint8_t row[MAXTWIDTH * 4]);
+  while (width > 0) {
+    int twidth = width > MAXTWIDTH ? MAXTWIDTH : width;
+    I422ToARGBRow_AVX2(src_y, src_u, src_v, row, yuvconstants, twidth);
+#if defined(HAS_ARGBTORGB24ROW_AVX2)
+    ARGBToRGB24Row_AVX2(row, dst_rgb24, twidth);
+#else
+    ARGBToRGB24Row_SSSE3(row, dst_rgb24, twidth);
+#endif
+    src_y += twidth;
+    src_u += twidth / 2;
+    src_v += twidth / 2;
+    dst_rgb24 += twidth * 3;
+    width -= twidth;
+  }
+}
+#endif
+
+#if defined(HAS_NV12TORGB565ROW_AVX2)
+void NV12ToRGB565Row_AVX2(const uint8_t* src_y,
+                          const uint8_t* src_uv,
+                          uint8_t* dst_rgb565,
+                          const struct YuvConstants* yuvconstants,
+                          int width) {
+  // Row buffer for intermediate ARGB pixels.
+  SIMD_ALIGNED(uint8_t row[MAXTWIDTH * 4]);
+  while (width > 0) {
+    int twidth = width > MAXTWIDTH ? MAXTWIDTH : width;
+    NV12ToARGBRow_AVX2(src_y, src_uv, row, yuvconstants, twidth);
+#if defined(HAS_ARGBTORGB565ROW_AVX2)
+    ARGBToRGB565Row_AVX2(row, dst_rgb565, twidth);
+#else
+    ARGBToRGB565Row_SSE2(row, dst_rgb565, twidth);
+#endif
+    src_y += twidth;
+    src_uv += twidth;
+    dst_rgb565 += twidth * 2;
+    width -= twidth;
+  }
+}
+#endif
+
+#ifdef HAS_RGB24TOYJROW_AVX2
+// Convert 16 RGB24 pixels (64 bytes) to 16 YJ values.
+void RGB24ToYJRow_AVX2(const uint8_t* src_rgb24, uint8_t* dst_yj, int width) {
+  // Row buffer for intermediate ARGB pixels.
+  SIMD_ALIGNED(uint8_t row[MAXTWIDTH * 4]);
+  while (width > 0) {
+    int twidth = width > MAXTWIDTH ? MAXTWIDTH : width;
+    RGB24ToARGBRow_SSSE3(src_rgb24, row, twidth);
+    ARGBToYJRow_AVX2(row, dst_yj, twidth);
+    src_rgb24 += twidth * 3;
+    dst_yj += twidth;
+    width -= twidth;
+  }
+}
+#endif  // HAS_RGB24TOYJROW_AVX2
+
+#ifdef HAS_RAWTOYJROW_AVX2
+// Convert 16 RAW pixels (64 bytes) to 16 YJ values.
+void RAWToYJRow_AVX2(const uint8_t* src_raw, uint8_t* dst_yj, int width) {
+  // Row buffer for intermediate ARGB pixels.
+  SIMD_ALIGNED(uint8_t row[MAXTWIDTH * 4]);
+  while (width > 0) {
+    int twidth = width > MAXTWIDTH ? MAXTWIDTH : width;
+    RAWToARGBRow_SSSE3(src_raw, row, twidth);
+    ARGBToYJRow_AVX2(row, dst_yj, twidth);
+    src_raw += twidth * 3;
+    dst_yj += twidth;
+    width -= twidth;
+  }
+}
+#endif  // HAS_RAWTOYJROW_AVX2
+
+#ifdef HAS_RGB24TOYJROW_SSSE3
+// Convert 16 RGB24 pixels (64 bytes) to 16 YJ values.
+void RGB24ToYJRow_SSSE3(const uint8_t* src_rgb24, uint8_t* dst_yj, int width) {
+  // Row buffer for intermediate ARGB pixels.
+  SIMD_ALIGNED(uint8_t row[MAXTWIDTH * 4]);
+  while (width > 0) {
+    int twidth = width > MAXTWIDTH ? MAXTWIDTH : width;
+    RGB24ToARGBRow_SSSE3(src_rgb24, row, twidth);
+    ARGBToYJRow_SSSE3(row, dst_yj, twidth);
+    src_rgb24 += twidth * 3;
+    dst_yj += twidth;
+    width -= twidth;
+  }
+}
+#endif  // HAS_RGB24TOYJROW_SSSE3
+
+#ifdef HAS_RAWTOYJROW_SSSE3
+// Convert 16 RAW pixels (64 bytes) to 16 YJ values.
+void RAWToYJRow_SSSE3(const uint8_t* src_raw, uint8_t* dst_yj, int width) {
+  // Row buffer for intermediate ARGB pixels.
+  SIMD_ALIGNED(uint8_t row[MAXTWIDTH * 4]);
+  while (width > 0) {
+    int twidth = width > MAXTWIDTH ? MAXTWIDTH : width;
+    RAWToARGBRow_SSSE3(src_raw, row, twidth);
+    ARGBToYJRow_SSSE3(row, dst_yj, twidth);
+    src_raw += twidth * 3;
+    dst_yj += twidth;
+    width -= twidth;
+  }
+}
+#endif  // HAS_RAWTOYJROW_SSSE3
+
+#ifdef HAS_INTERPOLATEROW_16TO8_AVX2
+void InterpolateRow_16To8_AVX2(uint8_t* dst_ptr,
+                               const uint16_t* src_ptr,
+                               ptrdiff_t src_stride,
+                               int scale,
+                               int width,
+                               int source_y_fraction) {
+  // Row buffer for intermediate 16 bit pixels.
+  SIMD_ALIGNED(uint16_t row[MAXTWIDTH]);
+  while (width > 0) {
+    int twidth = width > MAXTWIDTH ? MAXTWIDTH : width;
+    InterpolateRow_16_C(row, src_ptr, src_stride, twidth, source_y_fraction);
+    Convert16To8Row_AVX2(row, dst_ptr, scale, twidth);
+    src_ptr += twidth;
+    dst_ptr += twidth;
+    width -= twidth;
+  }
+}
+#endif  // HAS_INTERPOLATEROW_16TO8_AVX2
+
+float ScaleSumSamples_C(const float* src, float* dst, float scale, int width) {
+  float fsum = 0.f;
+  int i;
+  for (i = 0; i < width; ++i) {
+    float v = *src++;
+    fsum += v * v;
+    *dst++ = v * scale;
+  }
+  return fsum;
+}
+
+float ScaleMaxSamples_C(const float* src, float* dst, float scale, int width) {
+  float fmax = 0.f;
+  int i;
+  for (i = 0; i < width; ++i) {
+    float v = *src++;
+    float vs = v * scale;
+    fmax = (v > fmax) ? v : fmax;
+    *dst++ = vs;
+  }
+  return fmax;
+}
+
+void ScaleSamples_C(const float* src, float* dst, float scale, int width) {
+  int i;
+  for (i = 0; i < width; ++i) {
+    *dst++ = *src++ * scale;
+  }
+}
+
+void GaussRow_C(const uint32_t* src, uint16_t* dst, int width) {
+  int i;
+  for (i = 0; i < width; ++i) {
+    *dst++ =
+        (src[0] + src[1] * 4 + src[2] * 6 + src[3] * 4 + src[4] + 128) >> 8;
+    ++src;
+  }
+}
+
+// filter 5 rows with 1, 4, 6, 4, 1 coefficients to produce 1 row.
+void GaussCol_C(const uint16_t* src0,
+                const uint16_t* src1,
+                const uint16_t* src2,
+                const uint16_t* src3,
+                const uint16_t* src4,
+                uint32_t* dst,
+                int width) {
+  int i;
+  for (i = 0; i < width; ++i) {
+    *dst++ = *src0++ + *src1++ * 4 + *src2++ * 6 + *src3++ * 4 + *src4++;
+  }
+}
+
+void GaussRow_F32_C(const float* src, float* dst, int width) {
+  int i;
+  for (i = 0; i < width; ++i) {
+    *dst++ = (src[0] + src[1] * 4 + src[2] * 6 + src[3] * 4 + src[4]) *
+             (1.0f / 256.0f);
+    ++src;
+  }
+}
+
+// filter 5 rows with 1, 4, 6, 4, 1 coefficients to produce 1 row.
+void GaussCol_F32_C(const float* src0,
+                    const float* src1,
+                    const float* src2,
+                    const float* src3,
+                    const float* src4,
+                    float* dst,
+                    int width) {
+  int i;
+  for (i = 0; i < width; ++i) {
+    *dst++ = *src0++ + *src1++ * 4 + *src2++ * 6 + *src3++ * 4 + *src4++;
+  }
+}
+
+// Convert biplanar NV21 to packed YUV24
+void NV21ToYUV24Row_C(const uint8_t* src_y,
+                      const uint8_t* src_vu,
+                      uint8_t* dst_yuv24,
+                      int width) {
+  int x;
+  for (x = 0; x < width - 1; x += 2) {
+    dst_yuv24[0] = src_vu[0];  // V
+    dst_yuv24[1] = src_vu[1];  // U
+    dst_yuv24[2] = src_y[0];   // Y0
+    dst_yuv24[3] = src_vu[0];  // V
+    dst_yuv24[4] = src_vu[1];  // U
+    dst_yuv24[5] = src_y[1];   // Y1
+    src_y += 2;
+    src_vu += 2;
+    dst_yuv24 += 6;  // Advance 2 pixels.
+  }
+  if (width & 1) {
+    dst_yuv24[0] = src_vu[0];  // V
+    dst_yuv24[1] = src_vu[1];  // U
+    dst_yuv24[2] = src_y[0];   // Y0
+  }
+}
+
+// Filter 2 rows of AYUV UV's (444) into UV (420).
+// AYUV is VUYA in memory.  UV for NV12 is UV order in memory.
+void AYUVToUVRow_C(const uint8_t* src_ayuv,
+                   int src_stride_ayuv,
+                   uint8_t* dst_uv,
+                   int width) {
+  // Output a row of UV values, filtering 2x2 rows of AYUV.
+  int x;
+  for (x = 0; x < width - 1; x += 2) {
+    dst_uv[0] = (src_ayuv[1] + src_ayuv[5] + src_ayuv[src_stride_ayuv + 1] +
+                 src_ayuv[src_stride_ayuv + 5] + 2) >>
+                2;
+    dst_uv[1] = (src_ayuv[0] + src_ayuv[4] + src_ayuv[src_stride_ayuv + 0] +
+                 src_ayuv[src_stride_ayuv + 4] + 2) >>
+                2;
+    src_ayuv += 8;
+    dst_uv += 2;
+  }
+  if (width & 1) {
+    dst_uv[0] = (src_ayuv[1] + src_ayuv[src_stride_ayuv + 1] + 1) >> 1;
+    dst_uv[1] = (src_ayuv[0] + src_ayuv[src_stride_ayuv + 0] + 1) >> 1;
+  }
+}
+
+// Filter 2 rows of AYUV UV's (444) into VU (420).
+void AYUVToVURow_C(const uint8_t* src_ayuv,
+                   int src_stride_ayuv,
+                   uint8_t* dst_vu,
+                   int width) {
+  // Output a row of VU values, filtering 2x2 rows of AYUV.
+  int x;
+  for (x = 0; x < width - 1; x += 2) {
+    dst_vu[0] = (src_ayuv[0] + src_ayuv[4] + src_ayuv[src_stride_ayuv + 0] +
+                 src_ayuv[src_stride_ayuv + 4] + 2) >>
+                2;
+    dst_vu[1] = (src_ayuv[1] + src_ayuv[5] + src_ayuv[src_stride_ayuv + 1] +
+                 src_ayuv[src_stride_ayuv + 5] + 2) >>
+                2;
+    src_ayuv += 8;
+    dst_vu += 2;
+  }
+  if (width & 1) {
+    dst_vu[0] = (src_ayuv[0] + src_ayuv[src_stride_ayuv + 0] + 1) >> 1;
+    dst_vu[1] = (src_ayuv[1] + src_ayuv[src_stride_ayuv + 1] + 1) >> 1;
+  }
+}
+
+// Copy row of AYUV Y's into Y
+void AYUVToYRow_C(const uint8_t* src_ayuv, uint8_t* dst_y, int width) {
+  // Output a row of Y values.
+  int x;
+  for (x = 0; x < width; ++x) {
+    dst_y[x] = src_ayuv[2];  // v,u,y,a
+    src_ayuv += 4;
+  }
+}
+
+// Convert UV plane of NV12 to VU of NV21.
+void SwapUVRow_C(const uint8_t* src_uv, uint8_t* dst_vu, int width) {
+  int x;
+  for (x = 0; x < width; ++x) {
+    uint8_t u = src_uv[0];
+    uint8_t v = src_uv[1];
+    dst_vu[0] = v;
+    dst_vu[1] = u;
+    src_uv += 2;
+    dst_vu += 2;
+  }
+}
+
+void HalfMergeUVRow_C(const uint8_t* src_u,
+                      int src_stride_u,
+                      const uint8_t* src_v,
+                      int src_stride_v,
+                      uint8_t* dst_uv,
+                      int width) {
+  int x;
+  for (x = 0; x < width - 1; x += 2) {
+    dst_uv[0] = (src_u[0] + src_u[1] + src_u[src_stride_u] +
+                 src_u[src_stride_u + 1] + 2) >>
+                2;
+    dst_uv[1] = (src_v[0] + src_v[1] + src_v[src_stride_v] +
+                 src_v[src_stride_v + 1] + 2) >>
+                2;
+    src_u += 2;
+    src_v += 2;
+    dst_uv += 2;
+  }
+  if (width & 1) {
+    dst_uv[0] = (src_u[0] + src_u[src_stride_u] + 1) >> 1;
+    dst_uv[1] = (src_v[0] + src_v[src_stride_v] + 1) >> 1;
+  }
+}
+
+#ifdef __cplusplus
+}  // extern "C"
+}  // namespace libyuv
+#endif
diff --git a/3rdparty/libyuv/src/source/row_gcc.cc b/3rdparty/libyuv/src/source/row_gcc.cc
new file mode 100644
index 00000000..dce8c439
--- /dev/null
+++ b/3rdparty/libyuv/src/source/row_gcc.cc
@@ -0,0 +1,9335 @@
+/*
+ *  Copyright 2011 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include "libyuv/row.h"
+#ifdef __cplusplus
+namespace libyuv {
+extern "C" {
+#endif
+
+// This module is for GCC x86 and x64.
+#if !defined(LIBYUV_DISABLE_X86) && (defined(__x86_64__) || defined(__i386__))
+
+#if defined(HAS_ARGBTOYROW_SSSE3) || defined(HAS_ARGBGRAYROW_SSSE3)
+
+// Constants for ARGB
+static const uvec8 kARGBToY = {25u, 129u, 66u, 0u, 25u, 129u, 66u, 0u,
+                               25u, 129u, 66u, 0u, 25u, 129u, 66u, 0u};
+
+// JPeg full range.
+static const uvec8 kARGBToYJ = {29u, 150u, 77u, 0u, 29u, 150u, 77u, 0u,
+                                29u, 150u, 77u, 0u, 29u, 150u, 77u, 0u};
+
+static const uvec8 kRGBAToYJ = {0u, 29u, 150u, 77u, 0u, 29u, 150u, 77u,
+                                0u, 29u, 150u, 77u, 0u, 29u, 150u, 77u};
+#endif  // defined(HAS_ARGBTOYROW_SSSE3) || defined(HAS_ARGBGRAYROW_SSSE3)
+
+#if defined(HAS_ARGBTOYROW_SSSE3) || defined(HAS_I422TOARGBROW_SSSE3)
+
+static const vec8 kARGBToU = {112, -74, -38, 0, 112, -74, -38, 0,
+                              112, -74, -38, 0, 112, -74, -38, 0};
+
+static const vec8 kARGBToUJ = {127, -84, -43, 0, 127, -84, -43, 0,
+                               127, -84, -43, 0, 127, -84, -43, 0};
+
+static const vec8 kARGBToV = {-18, -94, 112, 0, -18, -94, 112, 0,
+                              -18, -94, 112, 0, -18, -94, 112, 0};
+
+static const vec8 kARGBToVJ = {-20, -107, 127, 0, -20, -107, 127, 0,
+                               -20, -107, 127, 0, -20, -107, 127, 0};
+
+// Constants for BGRA
+static const uvec8 kBGRAToY = {0u, 66u, 129u, 25u, 0u, 66u, 129u, 25u,
+                               0u, 66u, 129u, 25u, 0u, 66u, 129u, 25u};
+
+static const vec8 kBGRAToU = {0, -38, -74, 112, 0, -38, -74, 112,
+                              0, -38, -74, 112, 0, -38, -74, 112};
+
+static const vec8 kBGRAToV = {0, 112, -94, -18, 0, 112, -94, -18,
+                              0, 112, -94, -18, 0, 112, -94, -18};
+
+// Constants for ABGR
+static const uvec8 kABGRToY = {66u, 129u, 25u, 0u, 66u, 129u, 25u, 0u,
+                               66u, 129u, 25u, 0u, 66u, 129u, 25u, 0u};
+
+static const vec8 kABGRToU = {-38, -74, 112, 0, -38, -74, 112, 0,
+                              -38, -74, 112, 0, -38, -74, 112, 0};
+
+static const vec8 kABGRToV = {112, -94, -18, 0, 112, -94, -18, 0,
+                              112, -94, -18, 0, 112, -94, -18, 0};
+
+// Constants for RGBA.
+static const uvec8 kRGBAToY = {0u, 25u, 129u, 66u, 0u, 25u, 129u, 66u,
+                               0u, 25u, 129u, 66u, 0u, 25u, 129u, 66u};
+
+static const vec8 kRGBAToU = {0, 112, -74, -38, 0, 112, -74, -38,
+                              0, 112, -74, -38, 0, 112, -74, -38};
+
+static const vec8 kRGBAToV = {0, -18, -94, 112, 0, -18, -94, 112,
+                              0, -18, -94, 112, 0, -18, -94, 112};
+
+static const uvec16 kAddY16 = {0x7e80u, 0x7e80u, 0x7e80u, 0x7e80u,
+                               0x7e80u, 0x7e80u, 0x7e80u, 0x7e80u};
+
+static const uvec8 kAddUV128 = {128u, 128u, 128u, 128u, 128u, 128u, 128u, 128u,
+                                128u, 128u, 128u, 128u, 128u, 128u, 128u, 128u};
+
+static const uvec16 kSub128 = {0x8080u, 0x8080u, 0x8080u, 0x8080u,
+                               0x8080u, 0x8080u, 0x8080u, 0x8080u};
+
+#endif  // defined(HAS_ARGBTOYROW_SSSE3) || defined(HAS_I422TOARGBROW_SSSE3)
+
+#ifdef HAS_RGB24TOARGBROW_SSSE3
+
+// Shuffle table for converting RGB24 to ARGB.
+static const uvec8 kShuffleMaskRGB24ToARGB = {
+    0u, 1u, 2u, 12u, 3u, 4u, 5u, 13u, 6u, 7u, 8u, 14u, 9u, 10u, 11u, 15u};
+
+// Shuffle table for converting RAW to ARGB.
+static const uvec8 kShuffleMaskRAWToARGB = {2u, 1u, 0u, 12u, 5u,  4u,  3u, 13u,
+                                            8u, 7u, 6u, 14u, 11u, 10u, 9u, 15u};
+
+// Shuffle table for converting RAW to RGBA.
+static const uvec8 kShuffleMaskRAWToRGBA = {12u, 2u, 1u, 0u, 13u, 5u,  4u,  3u,
+                                            14u, 8u, 7u, 6u, 15u, 11u, 10u, 9u};
+
+// Shuffle table for converting RAW to RGB24.  First 8.
+static const uvec8 kShuffleMaskRAWToRGB24_0 = {
+    2u,   1u,   0u,   5u,   4u,   3u,   8u,   7u,
+    128u, 128u, 128u, 128u, 128u, 128u, 128u, 128u};
+
+// Shuffle table for converting RAW to RGB24.  Middle 8.
+static const uvec8 kShuffleMaskRAWToRGB24_1 = {
+    2u,   7u,   6u,   5u,   10u,  9u,   8u,   13u,
+    128u, 128u, 128u, 128u, 128u, 128u, 128u, 128u};
+
+// Shuffle table for converting RAW to RGB24.  Last 8.
+static const uvec8 kShuffleMaskRAWToRGB24_2 = {
+    8u,   7u,   12u,  11u,  10u,  15u,  14u,  13u,
+    128u, 128u, 128u, 128u, 128u, 128u, 128u, 128u};
+
+// Shuffle table for converting ARGB to RGB24.
+static const uvec8 kShuffleMaskARGBToRGB24 = {
+    0u, 1u, 2u, 4u, 5u, 6u, 8u, 9u, 10u, 12u, 13u, 14u, 128u, 128u, 128u, 128u};
+
+// Shuffle table for converting ARGB to RAW.
+static const uvec8 kShuffleMaskARGBToRAW = {
+    2u, 1u, 0u, 6u, 5u, 4u, 10u, 9u, 8u, 14u, 13u, 12u, 128u, 128u, 128u, 128u};
+
+// Shuffle table for converting ARGBToRGB24 for I422ToRGB24.  First 8 + next 4
+static const uvec8 kShuffleMaskARGBToRGB24_0 = {
+    0u, 1u, 2u, 4u, 5u, 6u, 8u, 9u, 128u, 128u, 128u, 128u, 10u, 12u, 13u, 14u};
+
+// YUY2 shuf 16 Y to 32 Y.
+static const lvec8 kShuffleYUY2Y = {0,  0,  2,  2,  4,  4,  6,  6,  8,  8, 10,
+                                    10, 12, 12, 14, 14, 0,  0,  2,  2,  4, 4,
+                                    6,  6,  8,  8,  10, 10, 12, 12, 14, 14};
+
+// YUY2 shuf 8 UV to 16 UV.
+static const lvec8 kShuffleYUY2UV = {1,  3,  1,  3,  5,  7,  5,  7,  9,  11, 9,
+                                     11, 13, 15, 13, 15, 1,  3,  1,  3,  5,  7,
+                                     5,  7,  9,  11, 9,  11, 13, 15, 13, 15};
+
+// UYVY shuf 16 Y to 32 Y.
+static const lvec8 kShuffleUYVYY = {1,  1,  3,  3,  5,  5,  7,  7,  9,  9, 11,
+                                    11, 13, 13, 15, 15, 1,  1,  3,  3,  5, 5,
+                                    7,  7,  9,  9,  11, 11, 13, 13, 15, 15};
+
+// UYVY shuf 8 UV to 16 UV.
+static const lvec8 kShuffleUYVYUV = {0,  2,  0,  2,  4,  6,  4,  6,  8,  10, 8,
+                                     10, 12, 14, 12, 14, 0,  2,  0,  2,  4,  6,
+                                     4,  6,  8,  10, 8,  10, 12, 14, 12, 14};
+
+// NV21 shuf 8 VU to 16 UV.
+static const lvec8 kShuffleNV21 = {
+    1, 0, 1, 0, 3, 2, 3, 2, 5, 4, 5, 4, 7, 6, 7, 6,
+    1, 0, 1, 0, 3, 2, 3, 2, 5, 4, 5, 4, 7, 6, 7, 6,
+};
+#endif  // HAS_RGB24TOARGBROW_SSSE3
+
+#ifdef HAS_J400TOARGBROW_SSE2
+void J400ToARGBRow_SSE2(const uint8_t* src_y, uint8_t* dst_argb, int width) {
+  asm volatile(
+      "pcmpeqb     %%xmm5,%%xmm5                 \n"
+      "pslld       $0x18,%%xmm5                  \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "movq        (%0),%%xmm0                   \n"
+      "lea         0x8(%0),%0                    \n"
+      "punpcklbw   %%xmm0,%%xmm0                 \n"
+      "movdqa      %%xmm0,%%xmm1                 \n"
+      "punpcklwd   %%xmm0,%%xmm0                 \n"
+      "punpckhwd   %%xmm1,%%xmm1                 \n"
+      "por         %%xmm5,%%xmm0                 \n"
+      "por         %%xmm5,%%xmm1                 \n"
+      "movdqu      %%xmm0,(%1)                   \n"
+      "movdqu      %%xmm1,0x10(%1)               \n"
+      "lea         0x20(%1),%1                   \n"
+      "sub         $0x8,%2                       \n"
+      "jg          1b                            \n"
+      : "+r"(src_y),     // %0
+        "+r"(dst_argb),  // %1
+        "+r"(width)      // %2
+        ::"memory",
+        "cc", "xmm0", "xmm1", "xmm5");
+}
+#endif  // HAS_J400TOARGBROW_SSE2
+
+#ifdef HAS_RGB24TOARGBROW_SSSE3
+void RGB24ToARGBRow_SSSE3(const uint8_t* src_rgb24,
+                          uint8_t* dst_argb,
+                          int width) {
+  asm volatile(
+      "pcmpeqb     %%xmm5,%%xmm5                 \n"  // 0xff000000
+      "pslld       $0x18,%%xmm5                  \n"
+      "movdqa      %3,%%xmm4                     \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "movdqu      (%0),%%xmm0                   \n"
+      "movdqu      0x10(%0),%%xmm1               \n"
+      "movdqu      0x20(%0),%%xmm3               \n"
+      "lea         0x30(%0),%0                   \n"
+      "movdqa      %%xmm3,%%xmm2                 \n"
+      "palignr     $0x8,%%xmm1,%%xmm2            \n"
+      "pshufb      %%xmm4,%%xmm2                 \n"
+      "por         %%xmm5,%%xmm2                 \n"
+      "palignr     $0xc,%%xmm0,%%xmm1            \n"
+      "pshufb      %%xmm4,%%xmm0                 \n"
+      "movdqu      %%xmm2,0x20(%1)               \n"
+      "por         %%xmm5,%%xmm0                 \n"
+      "pshufb      %%xmm4,%%xmm1                 \n"
+      "movdqu      %%xmm0,(%1)                   \n"
+      "por         %%xmm5,%%xmm1                 \n"
+      "palignr     $0x4,%%xmm3,%%xmm3            \n"
+      "pshufb      %%xmm4,%%xmm3                 \n"
+      "movdqu      %%xmm1,0x10(%1)               \n"
+      "por         %%xmm5,%%xmm3                 \n"
+      "movdqu      %%xmm3,0x30(%1)               \n"
+      "lea         0x40(%1),%1                   \n"
+      "sub         $0x10,%2                      \n"
+      "jg          1b                            \n"
+      : "+r"(src_rgb24),              // %0
+        "+r"(dst_argb),               // %1
+        "+r"(width)                   // %2
+      : "m"(kShuffleMaskRGB24ToARGB)  // %3
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5");
+}
+
+void RAWToARGBRow_SSSE3(const uint8_t* src_raw, uint8_t* dst_argb, int width) {
+  asm volatile(
+      "pcmpeqb     %%xmm5,%%xmm5                 \n"  // 0xff000000
+      "pslld       $0x18,%%xmm5                  \n"
+      "movdqa      %3,%%xmm4                     \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "movdqu      (%0),%%xmm0                   \n"
+      "movdqu      0x10(%0),%%xmm1               \n"
+      "movdqu      0x20(%0),%%xmm3               \n"
+      "lea         0x30(%0),%0                   \n"
+      "movdqa      %%xmm3,%%xmm2                 \n"
+      "palignr     $0x8,%%xmm1,%%xmm2            \n"
+      "pshufb      %%xmm4,%%xmm2                 \n"
+      "por         %%xmm5,%%xmm2                 \n"
+      "palignr     $0xc,%%xmm0,%%xmm1            \n"
+      "pshufb      %%xmm4,%%xmm0                 \n"
+      "movdqu      %%xmm2,0x20(%1)               \n"
+      "por         %%xmm5,%%xmm0                 \n"
+      "pshufb      %%xmm4,%%xmm1                 \n"
+      "movdqu      %%xmm0,(%1)                   \n"
+      "por         %%xmm5,%%xmm1                 \n"
+      "palignr     $0x4,%%xmm3,%%xmm3            \n"
+      "pshufb      %%xmm4,%%xmm3                 \n"
+      "movdqu      %%xmm1,0x10(%1)               \n"
+      "por         %%xmm5,%%xmm3                 \n"
+      "movdqu      %%xmm3,0x30(%1)               \n"
+      "lea         0x40(%1),%1                   \n"
+      "sub         $0x10,%2                      \n"
+      "jg          1b                            \n"
+      : "+r"(src_raw),              // %0
+        "+r"(dst_argb),             // %1
+        "+r"(width)                 // %2
+      : "m"(kShuffleMaskRAWToARGB)  // %3
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5");
+}
+
+// Same code as RAWToARGB with different shuffler and A in low bits
+void RAWToRGBARow_SSSE3(const uint8_t* src_raw, uint8_t* dst_rgba, int width) {
+  asm volatile(
+      "pcmpeqb     %%xmm5,%%xmm5                 \n"  // 0x000000ff
+      "psrld       $0x18,%%xmm5                  \n"
+      "movdqa      %3,%%xmm4                     \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "movdqu      (%0),%%xmm0                   \n"
+      "movdqu      0x10(%0),%%xmm1               \n"
+      "movdqu      0x20(%0),%%xmm3               \n"
+      "lea         0x30(%0),%0                   \n"
+      "movdqa      %%xmm3,%%xmm2                 \n"
+      "palignr     $0x8,%%xmm1,%%xmm2            \n"
+      "pshufb      %%xmm4,%%xmm2                 \n"
+      "por         %%xmm5,%%xmm2                 \n"
+      "palignr     $0xc,%%xmm0,%%xmm1            \n"
+      "pshufb      %%xmm4,%%xmm0                 \n"
+      "movdqu      %%xmm2,0x20(%1)               \n"
+      "por         %%xmm5,%%xmm0                 \n"
+      "pshufb      %%xmm4,%%xmm1                 \n"
+      "movdqu      %%xmm0,(%1)                   \n"
+      "por         %%xmm5,%%xmm1                 \n"
+      "palignr     $0x4,%%xmm3,%%xmm3            \n"
+      "pshufb      %%xmm4,%%xmm3                 \n"
+      "movdqu      %%xmm1,0x10(%1)               \n"
+      "por         %%xmm5,%%xmm3                 \n"
+      "movdqu      %%xmm3,0x30(%1)               \n"
+      "lea         0x40(%1),%1                   \n"
+      "sub         $0x10,%2                      \n"
+      "jg          1b                            \n"
+      : "+r"(src_raw),              // %0
+        "+r"(dst_rgba),             // %1
+        "+r"(width)                 // %2
+      : "m"(kShuffleMaskRAWToRGBA)  // %3
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5");
+}
+
+void RAWToRGB24Row_SSSE3(const uint8_t* src_raw,
+                         uint8_t* dst_rgb24,
+                         int width) {
+  asm volatile(
+      "movdqa      %3,%%xmm3                     \n"
+      "movdqa      %4,%%xmm4                     \n"
+      "movdqa      %5,%%xmm5                     \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "movdqu      (%0),%%xmm0                   \n"
+      "movdqu      0x4(%0),%%xmm1                \n"
+      "movdqu      0x8(%0),%%xmm2                \n"
+      "lea         0x18(%0),%0                   \n"
+      "pshufb      %%xmm3,%%xmm0                 \n"
+      "pshufb      %%xmm4,%%xmm1                 \n"
+      "pshufb      %%xmm5,%%xmm2                 \n"
+      "movq        %%xmm0,(%1)                   \n"
+      "movq        %%xmm1,0x8(%1)                \n"
+      "movq        %%xmm2,0x10(%1)               \n"
+      "lea         0x18(%1),%1                   \n"
+      "sub         $0x8,%2                       \n"
+      "jg          1b                            \n"
+      : "+r"(src_raw),                  // %0
+        "+r"(dst_rgb24),                // %1
+        "+r"(width)                     // %2
+      : "m"(kShuffleMaskRAWToRGB24_0),  // %3
+        "m"(kShuffleMaskRAWToRGB24_1),  // %4
+        "m"(kShuffleMaskRAWToRGB24_2)   // %5
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5");
+}
+
+void RGB565ToARGBRow_SSE2(const uint8_t* src, uint8_t* dst, int width) {
+  asm volatile(
+      "mov         $0x1080108,%%eax              \n"
+      "movd        %%eax,%%xmm5                  \n"
+      "pshufd      $0x0,%%xmm5,%%xmm5            \n"
+      "mov         $0x20802080,%%eax             \n"
+      "movd        %%eax,%%xmm6                  \n"
+      "pshufd      $0x0,%%xmm6,%%xmm6            \n"
+      "pcmpeqb     %%xmm3,%%xmm3                 \n"
+      "psllw       $0xb,%%xmm3                   \n"
+      "pcmpeqb     %%xmm4,%%xmm4                 \n"
+      "psllw       $0xa,%%xmm4                   \n"
+      "psrlw       $0x5,%%xmm4                   \n"
+      "pcmpeqb     %%xmm7,%%xmm7                 \n"
+      "psllw       $0x8,%%xmm7                   \n"
+      "sub         %0,%1                         \n"
+      "sub         %0,%1                         \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "movdqu      (%0),%%xmm0                   \n"
+      "movdqa      %%xmm0,%%xmm1                 \n"
+      "movdqa      %%xmm0,%%xmm2                 \n"
+      "pand        %%xmm3,%%xmm1                 \n"
+      "psllw       $0xb,%%xmm2                   \n"
+      "pmulhuw     %%xmm5,%%xmm1                 \n"
+      "pmulhuw     %%xmm5,%%xmm2                 \n"
+      "psllw       $0x8,%%xmm1                   \n"
+      "por         %%xmm2,%%xmm1                 \n"
+      "pand        %%xmm4,%%xmm0                 \n"
+      "pmulhuw     %%xmm6,%%xmm0                 \n"
+      "por         %%xmm7,%%xmm0                 \n"
+      "movdqa      %%xmm1,%%xmm2                 \n"
+      "punpcklbw   %%xmm0,%%xmm1                 \n"
+      "punpckhbw   %%xmm0,%%xmm2                 \n"
+      "movdqu      %%xmm1,0x00(%1,%0,2)          \n"
+      "movdqu      %%xmm2,0x10(%1,%0,2)          \n"
+      "lea         0x10(%0),%0                   \n"
+      "sub         $0x8,%2                       \n"
+      "jg          1b                            \n"
+      : "+r"(src),   // %0
+        "+r"(dst),   // %1
+        "+r"(width)  // %2
+      :
+      : "memory", "cc", "eax", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5",
+        "xmm6", "xmm7");
+}
+
+void ARGB1555ToARGBRow_SSE2(const uint8_t* src, uint8_t* dst, int width) {
+  asm volatile(
+      "mov         $0x1080108,%%eax              \n"
+      "movd        %%eax,%%xmm5                  \n"
+      "pshufd      $0x0,%%xmm5,%%xmm5            \n"
+      "mov         $0x42004200,%%eax             \n"
+      "movd        %%eax,%%xmm6                  \n"
+      "pshufd      $0x0,%%xmm6,%%xmm6            \n"
+      "pcmpeqb     %%xmm3,%%xmm3                 \n"
+      "psllw       $0xb,%%xmm3                   \n"
+      "movdqa      %%xmm3,%%xmm4                 \n"
+      "psrlw       $0x6,%%xmm4                   \n"
+      "pcmpeqb     %%xmm7,%%xmm7                 \n"
+      "psllw       $0x8,%%xmm7                   \n"
+      "sub         %0,%1                         \n"
+      "sub         %0,%1                         \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "movdqu      (%0),%%xmm0                   \n"
+      "movdqa      %%xmm0,%%xmm1                 \n"
+      "movdqa      %%xmm0,%%xmm2                 \n"
+      "psllw       $0x1,%%xmm1                   \n"
+      "psllw       $0xb,%%xmm2                   \n"
+      "pand        %%xmm3,%%xmm1                 \n"
+      "pmulhuw     %%xmm5,%%xmm2                 \n"
+      "pmulhuw     %%xmm5,%%xmm1                 \n"
+      "psllw       $0x8,%%xmm1                   \n"
+      "por         %%xmm2,%%xmm1                 \n"
+      "movdqa      %%xmm0,%%xmm2                 \n"
+      "pand        %%xmm4,%%xmm0                 \n"
+      "psraw       $0x8,%%xmm2                   \n"
+      "pmulhuw     %%xmm6,%%xmm0                 \n"
+      "pand        %%xmm7,%%xmm2                 \n"
+      "por         %%xmm2,%%xmm0                 \n"
+      "movdqa      %%xmm1,%%xmm2                 \n"
+      "punpcklbw   %%xmm0,%%xmm1                 \n"
+      "punpckhbw   %%xmm0,%%xmm2                 \n"
+      "movdqu      %%xmm1,0x00(%1,%0,2)          \n"
+      "movdqu      %%xmm2,0x10(%1,%0,2)          \n"
+      "lea         0x10(%0),%0                   \n"
+      "sub         $0x8,%2                       \n"
+      "jg          1b                            \n"
+      : "+r"(src),   // %0
+        "+r"(dst),   // %1
+        "+r"(width)  // %2
+      :
+      : "memory", "cc", "eax", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5",
+        "xmm6", "xmm7");
+}
+
+void ARGB4444ToARGBRow_SSE2(const uint8_t* src, uint8_t* dst, int width) {
+  asm volatile(
+      "mov         $0xf0f0f0f,%%eax              \n"
+      "movd        %%eax,%%xmm4                  \n"
+      "pshufd      $0x0,%%xmm4,%%xmm4            \n"
+      "movdqa      %%xmm4,%%xmm5                 \n"
+      "pslld       $0x4,%%xmm5                   \n"
+      "sub         %0,%1                         \n"
+      "sub         %0,%1                         \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "movdqu      (%0),%%xmm0                   \n"
+      "movdqa      %%xmm0,%%xmm2                 \n"
+      "pand        %%xmm4,%%xmm0                 \n"
+      "pand        %%xmm5,%%xmm2                 \n"
+      "movdqa      %%xmm0,%%xmm1                 \n"
+      "movdqa      %%xmm2,%%xmm3                 \n"
+      "psllw       $0x4,%%xmm1                   \n"
+      "psrlw       $0x4,%%xmm3                   \n"
+      "por         %%xmm1,%%xmm0                 \n"
+      "por         %%xmm3,%%xmm2                 \n"
+      "movdqa      %%xmm0,%%xmm1                 \n"
+      "punpcklbw   %%xmm2,%%xmm0                 \n"
+      "punpckhbw   %%xmm2,%%xmm1                 \n"
+      "movdqu      %%xmm0,0x00(%1,%0,2)          \n"
+      "movdqu      %%xmm1,0x10(%1,%0,2)          \n"
+      "lea         0x10(%0),%0                   \n"
+      "sub         $0x8,%2                       \n"
+      "jg          1b                            \n"
+      : "+r"(src),   // %0
+        "+r"(dst),   // %1
+        "+r"(width)  // %2
+      :
+      : "memory", "cc", "eax", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5");
+}
+
+void ARGBToRGB24Row_SSSE3(const uint8_t* src, uint8_t* dst, int width) {
+  asm volatile(
+
+      "movdqa      %3,%%xmm6                     \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "movdqu      (%0),%%xmm0                   \n"
+      "movdqu      0x10(%0),%%xmm1               \n"
+      "movdqu      0x20(%0),%%xmm2               \n"
+      "movdqu      0x30(%0),%%xmm3               \n"
+      "lea         0x40(%0),%0                   \n"
+      "pshufb      %%xmm6,%%xmm0                 \n"
+      "pshufb      %%xmm6,%%xmm1                 \n"
+      "pshufb      %%xmm6,%%xmm2                 \n"
+      "pshufb      %%xmm6,%%xmm3                 \n"
+      "movdqa      %%xmm1,%%xmm4                 \n"
+      "psrldq      $0x4,%%xmm1                   \n"
+      "pslldq      $0xc,%%xmm4                   \n"
+      "movdqa      %%xmm2,%%xmm5                 \n"
+      "por         %%xmm4,%%xmm0                 \n"
+      "pslldq      $0x8,%%xmm5                   \n"
+      "movdqu      %%xmm0,(%1)                   \n"
+      "por         %%xmm5,%%xmm1                 \n"
+      "psrldq      $0x8,%%xmm2                   \n"
+      "pslldq      $0x4,%%xmm3                   \n"
+      "por         %%xmm3,%%xmm2                 \n"
+      "movdqu      %%xmm1,0x10(%1)               \n"
+      "movdqu      %%xmm2,0x20(%1)               \n"
+      "lea         0x30(%1),%1                   \n"
+      "sub         $0x10,%2                      \n"
+      "jg          1b                            \n"
+      : "+r"(src),                    // %0
+        "+r"(dst),                    // %1
+        "+r"(width)                   // %2
+      : "m"(kShuffleMaskARGBToRGB24)  // %3
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6");
+}
+
+void ARGBToRAWRow_SSSE3(const uint8_t* src, uint8_t* dst, int width) {
+  asm volatile(
+
+      "movdqa      %3,%%xmm6                     \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "movdqu      (%0),%%xmm0                   \n"
+      "movdqu      0x10(%0),%%xmm1               \n"
+      "movdqu      0x20(%0),%%xmm2               \n"
+      "movdqu      0x30(%0),%%xmm3               \n"
+      "lea         0x40(%0),%0                   \n"
+      "pshufb      %%xmm6,%%xmm0                 \n"
+      "pshufb      %%xmm6,%%xmm1                 \n"
+      "pshufb      %%xmm6,%%xmm2                 \n"
+      "pshufb      %%xmm6,%%xmm3                 \n"
+      "movdqa      %%xmm1,%%xmm4                 \n"
+      "psrldq      $0x4,%%xmm1                   \n"
+      "pslldq      $0xc,%%xmm4                   \n"
+      "movdqa      %%xmm2,%%xmm5                 \n"
+      "por         %%xmm4,%%xmm0                 \n"
+      "pslldq      $0x8,%%xmm5                   \n"
+      "movdqu      %%xmm0,(%1)                   \n"
+      "por         %%xmm5,%%xmm1                 \n"
+      "psrldq      $0x8,%%xmm2                   \n"
+      "pslldq      $0x4,%%xmm3                   \n"
+      "por         %%xmm3,%%xmm2                 \n"
+      "movdqu      %%xmm1,0x10(%1)               \n"
+      "movdqu      %%xmm2,0x20(%1)               \n"
+      "lea         0x30(%1),%1                   \n"
+      "sub         $0x10,%2                      \n"
+      "jg          1b                            \n"
+      : "+r"(src),                  // %0
+        "+r"(dst),                  // %1
+        "+r"(width)                 // %2
+      : "m"(kShuffleMaskARGBToRAW)  // %3
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6");
+}
+
+#ifdef HAS_ARGBTORGB24ROW_AVX2
+// vpermd for 12+12 to 24
+static const lvec32 kPermdRGB24_AVX = {0, 1, 2, 4, 5, 6, 3, 7};
+
+void ARGBToRGB24Row_AVX2(const uint8_t* src, uint8_t* dst, int width) {
+  asm volatile(
+      "vbroadcastf128 %3,%%ymm6                  \n"
+      "vmovdqa     %4,%%ymm7                     \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "vmovdqu     (%0),%%ymm0                   \n"
+      "vmovdqu     0x20(%0),%%ymm1               \n"
+      "vmovdqu     0x40(%0),%%ymm2               \n"
+      "vmovdqu     0x60(%0),%%ymm3               \n"
+      "lea         0x80(%0),%0                   \n"
+      "vpshufb     %%ymm6,%%ymm0,%%ymm0          \n"  // xxx0yyy0
+      "vpshufb     %%ymm6,%%ymm1,%%ymm1          \n"
+      "vpshufb     %%ymm6,%%ymm2,%%ymm2          \n"
+      "vpshufb     %%ymm6,%%ymm3,%%ymm3          \n"
+      "vpermd      %%ymm0,%%ymm7,%%ymm0          \n"  // pack to 24 bytes
+      "vpermd      %%ymm1,%%ymm7,%%ymm1          \n"
+      "vpermd      %%ymm2,%%ymm7,%%ymm2          \n"
+      "vpermd      %%ymm3,%%ymm7,%%ymm3          \n"
+      "vpermq      $0x3f,%%ymm1,%%ymm4           \n"  // combine 24 + 8
+      "vpor        %%ymm4,%%ymm0,%%ymm0          \n"
+      "vmovdqu     %%ymm0,(%1)                   \n"
+      "vpermq      $0xf9,%%ymm1,%%ymm1           \n"  // combine 16 + 16
+      "vpermq      $0x4f,%%ymm2,%%ymm4           \n"
+      "vpor        %%ymm4,%%ymm1,%%ymm1          \n"
+      "vmovdqu     %%ymm1,0x20(%1)               \n"
+      "vpermq      $0xfe,%%ymm2,%%ymm2           \n"  // combine 8 + 24
+      "vpermq      $0x93,%%ymm3,%%ymm3           \n"
+      "vpor        %%ymm3,%%ymm2,%%ymm2          \n"
+      "vmovdqu     %%ymm2,0x40(%1)               \n"
+      "lea         0x60(%1),%1                   \n"
+      "sub         $0x20,%2                      \n"
+      "jg          1b                            \n"
+      "vzeroupper                                \n"
+      : "+r"(src),                     // %0
+        "+r"(dst),                     // %1
+        "+r"(width)                    // %2
+      : "m"(kShuffleMaskARGBToRGB24),  // %3
+        "m"(kPermdRGB24_AVX)           // %4
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6",
+        "xmm7");
+}
+#endif
+
+#ifdef HAS_ARGBTORGB24ROW_AVX512VBMI
+// Shuffle table for converting ARGBToRGB24
+static const ulvec8 kPermARGBToRGB24_0 = {
+    0u,  1u,  2u,  4u,  5u,  6u,  8u,  9u,  10u, 12u, 13u,
+    14u, 16u, 17u, 18u, 20u, 21u, 22u, 24u, 25u, 26u, 28u,
+    29u, 30u, 32u, 33u, 34u, 36u, 37u, 38u, 40u, 41u};
+static const ulvec8 kPermARGBToRGB24_1 = {
+    10u, 12u, 13u, 14u, 16u, 17u, 18u, 20u, 21u, 22u, 24u,
+    25u, 26u, 28u, 29u, 30u, 32u, 33u, 34u, 36u, 37u, 38u,
+    40u, 41u, 42u, 44u, 45u, 46u, 48u, 49u, 50u, 52u};
+static const ulvec8 kPermARGBToRGB24_2 = {
+    21u, 22u, 24u, 25u, 26u, 28u, 29u, 30u, 32u, 33u, 34u,
+    36u, 37u, 38u, 40u, 41u, 42u, 44u, 45u, 46u, 48u, 49u,
+    50u, 52u, 53u, 54u, 56u, 57u, 58u, 60u, 61u, 62u};
+
+void ARGBToRGB24Row_AVX512VBMI(const uint8_t* src, uint8_t* dst, int width) {
+  asm volatile(
+      "vmovdqa     %3,%%ymm5                     \n"
+      "vmovdqa     %4,%%ymm6                     \n"
+      "vmovdqa     %5,%%ymm7                     \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "vmovdqu     (%0),%%ymm0                   \n"
+      "vmovdqu     0x20(%0),%%ymm1               \n"
+      "vmovdqu     0x40(%0),%%ymm2               \n"
+      "vmovdqu     0x60(%0),%%ymm3               \n"
+      "lea         0x80(%0),%0                   \n"
+      "vpermt2b    %%ymm1,%%ymm5,%%ymm0          \n"
+      "vpermt2b    %%ymm2,%%ymm6,%%ymm1          \n"
+      "vpermt2b    %%ymm3,%%ymm7,%%ymm2          \n"
+      "vmovdqu     %%ymm0,(%1)                   \n"
+      "vmovdqu     %%ymm1,0x20(%1)               \n"
+      "vmovdqu     %%ymm2,0x40(%1)               \n"
+      "lea         0x60(%1),%1                   \n"
+      "sub         $0x20,%2                      \n"
+      "jg          1b                            \n"
+      "vzeroupper                                \n"
+      : "+r"(src),                // %0
+        "+r"(dst),                // %1
+        "+r"(width)               // %2
+      : "m"(kPermARGBToRGB24_0),  // %3
+        "m"(kPermARGBToRGB24_1),  // %4
+        "m"(kPermARGBToRGB24_2)   // %5
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm5", "xmm6", "xmm7");
+}
+#endif
+
+#ifdef HAS_ARGBTORAWROW_AVX2
+void ARGBToRAWRow_AVX2(const uint8_t* src, uint8_t* dst, int width) {
+  asm volatile(
+      "vbroadcastf128 %3,%%ymm6                  \n"
+      "vmovdqa     %4,%%ymm7                     \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "vmovdqu     (%0),%%ymm0                   \n"
+      "vmovdqu     0x20(%0),%%ymm1               \n"
+      "vmovdqu     0x40(%0),%%ymm2               \n"
+      "vmovdqu     0x60(%0),%%ymm3               \n"
+      "lea         0x80(%0),%0                   \n"
+      "vpshufb     %%ymm6,%%ymm0,%%ymm0          \n"  // xxx0yyy0
+      "vpshufb     %%ymm6,%%ymm1,%%ymm1          \n"
+      "vpshufb     %%ymm6,%%ymm2,%%ymm2          \n"
+      "vpshufb     %%ymm6,%%ymm3,%%ymm3          \n"
+      "vpermd      %%ymm0,%%ymm7,%%ymm0          \n"  // pack to 24 bytes
+      "vpermd      %%ymm1,%%ymm7,%%ymm1          \n"
+      "vpermd      %%ymm2,%%ymm7,%%ymm2          \n"
+      "vpermd      %%ymm3,%%ymm7,%%ymm3          \n"
+      "vpermq      $0x3f,%%ymm1,%%ymm4           \n"  // combine 24 + 8
+      "vpor        %%ymm4,%%ymm0,%%ymm0          \n"
+      "vmovdqu     %%ymm0,(%1)                   \n"
+      "vpermq      $0xf9,%%ymm1,%%ymm1           \n"  // combine 16 + 16
+      "vpermq      $0x4f,%%ymm2,%%ymm4           \n"
+      "vpor        %%ymm4,%%ymm1,%%ymm1          \n"
+      "vmovdqu     %%ymm1,0x20(%1)               \n"
+      "vpermq      $0xfe,%%ymm2,%%ymm2           \n"  // combine 8 + 24
+      "vpermq      $0x93,%%ymm3,%%ymm3           \n"
+      "vpor        %%ymm3,%%ymm2,%%ymm2          \n"
+      "vmovdqu     %%ymm2,0x40(%1)               \n"
+      "lea         0x60(%1),%1                   \n"
+      "sub         $0x20,%2                      \n"
+      "jg          1b                            \n"
+      "vzeroupper                                \n"
+      : "+r"(src),                   // %0
+        "+r"(dst),                   // %1
+        "+r"(width)                  // %2
+      : "m"(kShuffleMaskARGBToRAW),  // %3
+        "m"(kPermdRGB24_AVX)         // %4
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6",
+        "xmm7");
+}
+#endif
+
+void ARGBToRGB565Row_SSE2(const uint8_t* src, uint8_t* dst, int width) {
+  asm volatile(
+      "pcmpeqb     %%xmm3,%%xmm3                 \n"
+      "psrld       $0x1b,%%xmm3                  \n"
+      "pcmpeqb     %%xmm4,%%xmm4                 \n"
+      "psrld       $0x1a,%%xmm4                  \n"
+      "pslld       $0x5,%%xmm4                   \n"
+      "pcmpeqb     %%xmm5,%%xmm5                 \n"
+      "pslld       $0xb,%%xmm5                   \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "movdqu      (%0),%%xmm0                   \n"
+      "movdqa      %%xmm0,%%xmm1                 \n"
+      "movdqa      %%xmm0,%%xmm2                 \n"
+      "pslld       $0x8,%%xmm0                   \n"
+      "psrld       $0x3,%%xmm1                   \n"
+      "psrld       $0x5,%%xmm2                   \n"
+      "psrad       $0x10,%%xmm0                  \n"
+      "pand        %%xmm3,%%xmm1                 \n"
+      "pand        %%xmm4,%%xmm2                 \n"
+      "pand        %%xmm5,%%xmm0                 \n"
+      "por         %%xmm2,%%xmm1                 \n"
+      "por         %%xmm1,%%xmm0                 \n"
+      "packssdw    %%xmm0,%%xmm0                 \n"
+      "lea         0x10(%0),%0                   \n"
+      "movq        %%xmm0,(%1)                   \n"
+      "lea         0x8(%1),%1                    \n"
+      "sub         $0x4,%2                       \n"
+      "jg          1b                            \n"
+      : "+r"(src),   // %0
+        "+r"(dst),   // %1
+        "+r"(width)  // %2
+        ::"memory",
+        "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5");
+}
+
+void ARGBToRGB565DitherRow_SSE2(const uint8_t* src,
+                                uint8_t* dst,
+                                const uint32_t dither4,
+                                int width) {
+  asm volatile(
+      "movd        %3,%%xmm6                     \n"
+      "punpcklbw   %%xmm6,%%xmm6                 \n"
+      "movdqa      %%xmm6,%%xmm7                 \n"
+      "punpcklwd   %%xmm6,%%xmm6                 \n"
+      "punpckhwd   %%xmm7,%%xmm7                 \n"
+      "pcmpeqb     %%xmm3,%%xmm3                 \n"
+      "psrld       $0x1b,%%xmm3                  \n"
+      "pcmpeqb     %%xmm4,%%xmm4                 \n"
+      "psrld       $0x1a,%%xmm4                  \n"
+      "pslld       $0x5,%%xmm4                   \n"
+      "pcmpeqb     %%xmm5,%%xmm5                 \n"
+      "pslld       $0xb,%%xmm5                   \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "movdqu      (%0),%%xmm0                   \n"
+      "paddusb     %%xmm6,%%xmm0                 \n"
+      "movdqa      %%xmm0,%%xmm1                 \n"
+      "movdqa      %%xmm0,%%xmm2                 \n"
+      "pslld       $0x8,%%xmm0                   \n"
+      "psrld       $0x3,%%xmm1                   \n"
+      "psrld       $0x5,%%xmm2                   \n"
+      "psrad       $0x10,%%xmm0                  \n"
+      "pand        %%xmm3,%%xmm1                 \n"
+      "pand        %%xmm4,%%xmm2                 \n"
+      "pand        %%xmm5,%%xmm0                 \n"
+      "por         %%xmm2,%%xmm1                 \n"
+      "por         %%xmm1,%%xmm0                 \n"
+      "packssdw    %%xmm0,%%xmm0                 \n"
+      "lea         0x10(%0),%0                   \n"
+      "movq        %%xmm0,(%1)                   \n"
+      "lea         0x8(%1),%1                    \n"
+      "sub         $0x4,%2                       \n"
+      "jg          1b                            \n"
+      : "+r"(src),    // %0
+        "+r"(dst),    // %1
+        "+r"(width)   // %2
+      : "m"(dither4)  // %3
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6",
+        "xmm7");
+}
+
+#ifdef HAS_ARGBTORGB565DITHERROW_AVX2
+void ARGBToRGB565DitherRow_AVX2(const uint8_t* src,
+                                uint8_t* dst,
+                                const uint32_t dither4,
+                                int width) {
+  asm volatile(
+      "vbroadcastss %3,%%xmm6                    \n"
+      "vpunpcklbw  %%xmm6,%%xmm6,%%xmm6          \n"
+      "vpermq      $0xd8,%%ymm6,%%ymm6           \n"
+      "vpunpcklwd  %%ymm6,%%ymm6,%%ymm6          \n"
+      "vpcmpeqb    %%ymm3,%%ymm3,%%ymm3          \n"
+      "vpsrld      $0x1b,%%ymm3,%%ymm3           \n"
+      "vpcmpeqb    %%ymm4,%%ymm4,%%ymm4          \n"
+      "vpsrld      $0x1a,%%ymm4,%%ymm4           \n"
+      "vpslld      $0x5,%%ymm4,%%ymm4            \n"
+      "vpslld      $0xb,%%ymm3,%%ymm5            \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "vmovdqu     (%0),%%ymm0                   \n"
+      "vpaddusb    %%ymm6,%%ymm0,%%ymm0          \n"
+      "vpsrld      $0x5,%%ymm0,%%ymm2            \n"
+      "vpsrld      $0x3,%%ymm0,%%ymm1            \n"
+      "vpsrld      $0x8,%%ymm0,%%ymm0            \n"
+      "vpand       %%ymm4,%%ymm2,%%ymm2          \n"
+      "vpand       %%ymm3,%%ymm1,%%ymm1          \n"
+      "vpand       %%ymm5,%%ymm0,%%ymm0          \n"
+      "vpor        %%ymm2,%%ymm1,%%ymm1          \n"
+      "vpor        %%ymm1,%%ymm0,%%ymm0          \n"
+      "vpackusdw   %%ymm0,%%ymm0,%%ymm0          \n"
+      "vpermq      $0xd8,%%ymm0,%%ymm0           \n"
+      "lea         0x20(%0),%0                   \n"
+      "vmovdqu     %%xmm0,(%1)                   \n"
+      "lea         0x10(%1),%1                   \n"
+      "sub         $0x8,%2                       \n"
+      "jg          1b                            \n"
+      "vzeroupper                                \n"
+      : "+r"(src),    // %0
+        "+r"(dst),    // %1
+        "+r"(width)   // %2
+      : "m"(dither4)  // %3
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6",
+        "xmm7");
+}
+#endif  // HAS_ARGBTORGB565DITHERROW_AVX2
+
+void ARGBToARGB1555Row_SSE2(const uint8_t* src, uint8_t* dst, int width) {
+  asm volatile(
+      "pcmpeqb     %%xmm4,%%xmm4                 \n"
+      "psrld       $0x1b,%%xmm4                  \n"
+      "movdqa      %%xmm4,%%xmm5                 \n"
+      "pslld       $0x5,%%xmm5                   \n"
+      "movdqa      %%xmm4,%%xmm6                 \n"
+      "pslld       $0xa,%%xmm6                   \n"
+      "pcmpeqb     %%xmm7,%%xmm7                 \n"
+      "pslld       $0xf,%%xmm7                   \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "movdqu      (%0),%%xmm0                   \n"
+      "movdqa      %%xmm0,%%xmm1                 \n"
+      "movdqa      %%xmm0,%%xmm2                 \n"
+      "movdqa      %%xmm0,%%xmm3                 \n"
+      "psrad       $0x10,%%xmm0                  \n"
+      "psrld       $0x3,%%xmm1                   \n"
+      "psrld       $0x6,%%xmm2                   \n"
+      "psrld       $0x9,%%xmm3                   \n"
+      "pand        %%xmm7,%%xmm0                 \n"
+      "pand        %%xmm4,%%xmm1                 \n"
+      "pand        %%xmm5,%%xmm2                 \n"
+      "pand        %%xmm6,%%xmm3                 \n"
+      "por         %%xmm1,%%xmm0                 \n"
+      "por         %%xmm3,%%xmm2                 \n"
+      "por         %%xmm2,%%xmm0                 \n"
+      "packssdw    %%xmm0,%%xmm0                 \n"
+      "lea         0x10(%0),%0                   \n"
+      "movq        %%xmm0,(%1)                   \n"
+      "lea         0x8(%1),%1                    \n"
+      "sub         $0x4,%2                       \n"
+      "jg          1b                            \n"
+      : "+r"(src),   // %0
+        "+r"(dst),   // %1
+        "+r"(width)  // %2
+        ::"memory",
+        "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7");
+}
+
+void ARGBToARGB4444Row_SSE2(const uint8_t* src, uint8_t* dst, int width) {
+  asm volatile(
+      "pcmpeqb     %%xmm4,%%xmm4                 \n"
+      "psllw       $0xc,%%xmm4                   \n"
+      "movdqa      %%xmm4,%%xmm3                 \n"
+      "psrlw       $0x8,%%xmm3                   \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "movdqu      (%0),%%xmm0                   \n"
+      "movdqa      %%xmm0,%%xmm1                 \n"
+      "pand        %%xmm3,%%xmm0                 \n"
+      "pand        %%xmm4,%%xmm1                 \n"
+      "psrlq       $0x4,%%xmm0                   \n"
+      "psrlq       $0x8,%%xmm1                   \n"
+      "por         %%xmm1,%%xmm0                 \n"
+      "packuswb    %%xmm0,%%xmm0                 \n"
+      "lea         0x10(%0),%0                   \n"
+      "movq        %%xmm0,(%1)                   \n"
+      "lea         0x8(%1),%1                    \n"
+      "sub         $0x4,%2                       \n"
+      "jg          1b                            \n"
+      : "+r"(src),   // %0
+        "+r"(dst),   // %1
+        "+r"(width)  // %2
+        ::"memory",
+        "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4");
+}
+#endif  // HAS_RGB24TOARGBROW_SSSE3
+
+/*
+
+ARGBToAR30Row:
+
+Red Blue
+With the 8 bit value in the upper bits of a short, vpmulhuw by (1024+4) will
+produce a 10 bit value in the low 10 bits of each 16 bit value. This is whats
+wanted for the blue channel. The red needs to be shifted 4 left, so multiply by
+(1024+4)*16 for red.
+
+Alpha Green
+Alpha and Green are already in the high bits so vpand can zero out the other
+bits, keeping just 2 upper bits of alpha and 8 bit green. The same multiplier
+could be used for Green - (1024+4) putting the 10 bit green in the lsb.  Alpha
+would be a simple multiplier to shift it into position.  It wants a gap of 10
+above the green.  Green is 10 bits, so there are 6 bits in the low short.  4
+more are needed, so a multiplier of 4 gets the 2 bits into the upper 16 bits,
+and then a shift of 4 is a multiply of 16, so (4*16) = 64.  Then shift the
+result left 10 to position the A and G channels.
+*/
+
+// Shuffle table for converting RAW to RGB24.  Last 8.
+static const uvec8 kShuffleRB30 = {128u, 0u, 128u, 2u,  128u, 4u,  128u, 6u,
+                                   128u, 8u, 128u, 10u, 128u, 12u, 128u, 14u};
+
+static const uvec8 kShuffleBR30 = {128u, 2u,  128u, 0u, 128u, 6u,  128u, 4u,
+                                   128u, 10u, 128u, 8u, 128u, 14u, 128u, 12u};
+
+static const uint32_t kMulRB10 = 1028 * 16 * 65536 + 1028;
+static const uint32_t kMaskRB10 = 0x3ff003ff;
+static const uint32_t kMaskAG10 = 0xc000ff00;
+static const uint32_t kMulAG10 = 64 * 65536 + 1028;
+
+void ARGBToAR30Row_SSSE3(const uint8_t* src, uint8_t* dst, int width) {
+  asm volatile(
+      "movdqa      %3,%%xmm2                     \n"  // shuffler for RB
+      "movd        %4,%%xmm3                     \n"  // multipler for RB
+      "movd        %5,%%xmm4                     \n"  // mask for R10 B10
+      "movd        %6,%%xmm5                     \n"  // mask for AG
+      "movd        %7,%%xmm6                     \n"  // multipler for AG
+      "pshufd      $0x0,%%xmm3,%%xmm3            \n"
+      "pshufd      $0x0,%%xmm4,%%xmm4            \n"
+      "pshufd      $0x0,%%xmm5,%%xmm5            \n"
+      "pshufd      $0x0,%%xmm6,%%xmm6            \n"
+      "sub         %0,%1                         \n"
+
+      "1:                                        \n"
+      "movdqu      (%0),%%xmm0                   \n"  // fetch 4 ARGB pixels
+      "movdqa      %%xmm0,%%xmm1                 \n"
+      "pshufb      %%xmm2,%%xmm1                 \n"  // R0B0
+      "pand        %%xmm5,%%xmm0                 \n"  // A0G0
+      "pmulhuw     %%xmm3,%%xmm1                 \n"  // X2 R16 X4  B10
+      "pmulhuw     %%xmm6,%%xmm0                 \n"  // X10 A2 X10 G10
+      "pand        %%xmm4,%%xmm1                 \n"  // X2 R10 X10 B10
+      "pslld       $10,%%xmm0                    \n"  // A2 x10 G10 x10
+      "por         %%xmm1,%%xmm0                 \n"  // A2 R10 G10 B10
+      "movdqu      %%xmm0,(%1,%0)                \n"  // store 4 AR30 pixels
+      "add         $0x10,%0                      \n"
+      "sub         $0x4,%2                       \n"
+      "jg          1b                            \n"
+
+      : "+r"(src),          // %0
+        "+r"(dst),          // %1
+        "+r"(width)         // %2
+      : "m"(kShuffleRB30),  // %3
+        "m"(kMulRB10),      // %4
+        "m"(kMaskRB10),     // %5
+        "m"(kMaskAG10),     // %6
+        "m"(kMulAG10)       // %7
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6");
+}
+
+void ABGRToAR30Row_SSSE3(const uint8_t* src, uint8_t* dst, int width) {
+  asm volatile(
+      "movdqa      %3,%%xmm2                     \n"  // shuffler for RB
+      "movd        %4,%%xmm3                     \n"  // multipler for RB
+      "movd        %5,%%xmm4                     \n"  // mask for R10 B10
+      "movd        %6,%%xmm5                     \n"  // mask for AG
+      "movd        %7,%%xmm6                     \n"  // multipler for AG
+      "pshufd      $0x0,%%xmm3,%%xmm3            \n"
+      "pshufd      $0x0,%%xmm4,%%xmm4            \n"
+      "pshufd      $0x0,%%xmm5,%%xmm5            \n"
+      "pshufd      $0x0,%%xmm6,%%xmm6            \n"
+      "sub         %0,%1                         \n"
+
+      "1:                                        \n"
+      "movdqu      (%0),%%xmm0                   \n"  // fetch 4 ABGR pixels
+      "movdqa      %%xmm0,%%xmm1                 \n"
+      "pshufb      %%xmm2,%%xmm1                 \n"  // R0B0
+      "pand        %%xmm5,%%xmm0                 \n"  // A0G0
+      "pmulhuw     %%xmm3,%%xmm1                 \n"  // X2 R16 X4  B10
+      "pmulhuw     %%xmm6,%%xmm0                 \n"  // X10 A2 X10 G10
+      "pand        %%xmm4,%%xmm1                 \n"  // X2 R10 X10 B10
+      "pslld       $10,%%xmm0                    \n"  // A2 x10 G10 x10
+      "por         %%xmm1,%%xmm0                 \n"  // A2 R10 G10 B10
+      "movdqu      %%xmm0,(%1,%0)                \n"  // store 4 AR30 pixels
+      "add         $0x10,%0                      \n"
+      "sub         $0x4,%2                       \n"
+      "jg          1b                            \n"
+
+      : "+r"(src),          // %0
+        "+r"(dst),          // %1
+        "+r"(width)         // %2
+      : "m"(kShuffleBR30),  // %3  reversed shuffler
+        "m"(kMulRB10),      // %4
+        "m"(kMaskRB10),     // %5
+        "m"(kMaskAG10),     // %6
+        "m"(kMulAG10)       // %7
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6");
+}
+
+#ifdef HAS_ARGBTOAR30ROW_AVX2
+void ARGBToAR30Row_AVX2(const uint8_t* src, uint8_t* dst, int width) {
+  asm volatile(
+      "vbroadcastf128 %3,%%ymm2                  \n"  // shuffler for RB
+      "vbroadcastss %4,%%ymm3                    \n"  // multipler for RB
+      "vbroadcastss %5,%%ymm4                    \n"  // mask for R10 B10
+      "vbroadcastss %6,%%ymm5                    \n"  // mask for AG
+      "vbroadcastss %7,%%ymm6                    \n"  // multipler for AG
+      "sub         %0,%1                         \n"
+
+      "1:                                        \n"
+      "vmovdqu     (%0),%%ymm0                   \n"  // fetch 8 ARGB pixels
+      "vpshufb     %%ymm2,%%ymm0,%%ymm1          \n"  // R0B0
+      "vpand       %%ymm5,%%ymm0,%%ymm0          \n"  // A0G0
+      "vpmulhuw    %%ymm3,%%ymm1,%%ymm1          \n"  // X2 R16 X4  B10
+      "vpmulhuw    %%ymm6,%%ymm0,%%ymm0          \n"  // X10 A2 X10 G10
+      "vpand       %%ymm4,%%ymm1,%%ymm1          \n"  // X2 R10 X10 B10
+      "vpslld      $10,%%ymm0,%%ymm0             \n"  // A2 x10 G10 x10
+      "vpor        %%ymm1,%%ymm0,%%ymm0          \n"  // A2 R10 G10 B10
+      "vmovdqu     %%ymm0,(%1,%0)                \n"  // store 8 AR30 pixels
+      "add         $0x20,%0                      \n"
+      "sub         $0x8,%2                       \n"
+      "jg          1b                            \n"
+      "vzeroupper                                \n"
+
+      : "+r"(src),          // %0
+        "+r"(dst),          // %1
+        "+r"(width)         // %2
+      : "m"(kShuffleRB30),  // %3
+        "m"(kMulRB10),      // %4
+        "m"(kMaskRB10),     // %5
+        "m"(kMaskAG10),     // %6
+        "m"(kMulAG10)       // %7
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6");
+}
+#endif
+
+#ifdef HAS_ABGRTOAR30ROW_AVX2
+void ABGRToAR30Row_AVX2(const uint8_t* src, uint8_t* dst, int width) {
+  asm volatile(
+      "vbroadcastf128 %3,%%ymm2                  \n"  // shuffler for RB
+      "vbroadcastss %4,%%ymm3                    \n"  // multipler for RB
+      "vbroadcastss %5,%%ymm4                    \n"  // mask for R10 B10
+      "vbroadcastss %6,%%ymm5                    \n"  // mask for AG
+      "vbroadcastss %7,%%ymm6                    \n"  // multipler for AG
+      "sub         %0,%1                         \n"
+
+      "1:                                        \n"
+      "vmovdqu     (%0),%%ymm0                   \n"  // fetch 8 ABGR pixels
+      "vpshufb     %%ymm2,%%ymm0,%%ymm1          \n"  // R0B0
+      "vpand       %%ymm5,%%ymm0,%%ymm0          \n"  // A0G0
+      "vpmulhuw    %%ymm3,%%ymm1,%%ymm1          \n"  // X2 R16 X4  B10
+      "vpmulhuw    %%ymm6,%%ymm0,%%ymm0          \n"  // X10 A2 X10 G10
+      "vpand       %%ymm4,%%ymm1,%%ymm1          \n"  // X2 R10 X10 B10
+      "vpslld      $10,%%ymm0,%%ymm0             \n"  // A2 x10 G10 x10
+      "vpor        %%ymm1,%%ymm0,%%ymm0          \n"  // A2 R10 G10 B10
+      "vmovdqu     %%ymm0,(%1,%0)                \n"  // store 8 AR30 pixels
+      "add         $0x20,%0                      \n"
+      "sub         $0x8,%2                       \n"
+      "jg          1b                            \n"
+      "vzeroupper                                \n"
+
+      : "+r"(src),          // %0
+        "+r"(dst),          // %1
+        "+r"(width)         // %2
+      : "m"(kShuffleBR30),  // %3  reversed shuffler
+        "m"(kMulRB10),      // %4
+        "m"(kMaskRB10),     // %5
+        "m"(kMaskAG10),     // %6
+        "m"(kMulAG10)       // %7
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6");
+}
+#endif
+
+static const uvec8 kShuffleARGBToABGR = {2,  1, 0, 3,  6,  5,  4,  7,
+                                         10, 9, 8, 11, 14, 13, 12, 15};
+
+static const uvec8 kShuffleARGBToAB64Lo = {2, 2, 1, 1, 0, 0, 3, 3,
+                                           6, 6, 5, 5, 4, 4, 7, 7};
+static const uvec8 kShuffleARGBToAB64Hi = {10, 10, 9,  9,  8,  8,  11, 11,
+                                           14, 14, 13, 13, 12, 12, 15, 15};
+
+void ARGBToAR64Row_SSSE3(const uint8_t* src_argb,
+                         uint16_t* dst_ar64,
+                         int width) {
+  asm volatile(
+
+      LABELALIGN
+      "1:                                        \n"
+      "movdqu      (%0),%%xmm0                   \n"
+      "movdqa      %%xmm0,%%xmm1                 \n"
+      "punpcklbw   %%xmm0,%%xmm0                 \n"
+      "punpckhbw   %%xmm1,%%xmm1                 \n"
+      "movdqu      %%xmm0,(%1)                   \n"
+      "movdqu      %%xmm1,0x10(%1)               \n"
+      "lea         0x10(%0),%0                   \n"
+      "lea         0x20(%1),%1                   \n"
+      "sub         $0x4,%2                       \n"
+      "jg          1b                            \n"
+      : "+r"(src_argb),  // %0
+        "+r"(dst_ar64),  // %1
+        "+r"(width)      // %2
+      :
+      : "memory", "cc", "xmm0", "xmm1");
+}
+
+void ARGBToAB64Row_SSSE3(const uint8_t* src_argb,
+                         uint16_t* dst_ab64,
+                         int width) {
+  asm volatile(
+
+      "movdqa      %3,%%xmm2                     \n"
+      "movdqa      %4,%%xmm3                     \n" LABELALIGN
+      "1:                                        \n"
+      "movdqu      (%0),%%xmm0                   \n"
+      "movdqa      %%xmm0,%%xmm1                 \n"
+      "pshufb      %%xmm2,%%xmm0                 \n"
+      "pshufb      %%xmm3,%%xmm1                 \n"
+      "movdqu      %%xmm0,(%1)                   \n"
+      "movdqu      %%xmm1,0x10(%1)               \n"
+      "lea         0x10(%0),%0                   \n"
+      "lea         0x20(%1),%1                   \n"
+      "sub         $0x4,%2                       \n"
+      "jg          1b                            \n"
+      : "+r"(src_argb),             // %0
+        "+r"(dst_ab64),             // %1
+        "+r"(width)                 // %2
+      : "m"(kShuffleARGBToAB64Lo),  // %3
+        "m"(kShuffleARGBToAB64Hi)   // %4
+      : "memory", "cc", "xmm0", "xmm1", "xmm2");
+}
+
+void AR64ToARGBRow_SSSE3(const uint16_t* src_ar64,
+                         uint8_t* dst_argb,
+                         int width) {
+  asm volatile(
+
+      LABELALIGN
+      "1:                                        \n"
+      "movdqu      (%0),%%xmm0                   \n"
+      "movdqu      0x10(%0),%%xmm1               \n"
+      "psrlw       $8,%%xmm0                     \n"
+      "psrlw       $8,%%xmm1                     \n"
+      "packuswb    %%xmm1,%%xmm0                 \n"
+      "movdqu      %%xmm0,(%1)                   \n"
+      "lea         0x20(%0),%0                   \n"
+      "lea         0x10(%1),%1                   \n"
+      "sub         $0x4,%2                       \n"
+      "jg          1b                            \n"
+      : "+r"(src_ar64),  // %0
+        "+r"(dst_argb),  // %1
+        "+r"(width)      // %2
+      :
+      : "memory", "cc", "xmm0", "xmm1");
+}
+
+void AB64ToARGBRow_SSSE3(const uint16_t* src_ab64,
+                         uint8_t* dst_argb,
+                         int width) {
+  asm volatile(
+
+      "movdqa      %3,%%xmm2                     \n" LABELALIGN
+      "1:                                        \n"
+      "movdqu      (%0),%%xmm0                   \n"
+      "movdqu      0x10(%0),%%xmm1               \n"
+      "psrlw       $8,%%xmm0                     \n"
+      "psrlw       $8,%%xmm1                     \n"
+      "packuswb    %%xmm1,%%xmm0                 \n"
+      "pshufb      %%xmm2,%%xmm0                 \n"
+      "movdqu      %%xmm0,(%1)                   \n"
+      "lea         0x20(%0),%0                   \n"
+      "lea         0x10(%1),%1                   \n"
+      "sub         $0x4,%2                       \n"
+      "jg          1b                            \n"
+      : "+r"(src_ab64),          // %0
+        "+r"(dst_argb),          // %1
+        "+r"(width)              // %2
+      : "m"(kShuffleARGBToABGR)  // %3
+      : "memory", "cc", "xmm0", "xmm1", "xmm2");
+}
+
+#ifdef HAS_ARGBTOAR64ROW_AVX2
+void ARGBToAR64Row_AVX2(const uint8_t* src_argb,
+                        uint16_t* dst_ar64,
+                        int width) {
+  asm volatile(
+
+      LABELALIGN
+      "1:                                        \n"
+      "vmovdqu     (%0),%%ymm0                   \n"
+      "vpermq      $0xd8,%%ymm0,%%ymm0           \n"
+      "vpunpckhbw  %%ymm0,%%ymm0,%%ymm1          \n"
+      "vpunpcklbw  %%ymm0,%%ymm0,%%ymm0          \n"
+      "vmovdqu     %%ymm0,(%1)                   \n"
+      "vmovdqu     %%ymm1,0x20(%1)               \n"
+      "lea         0x20(%0),%0                   \n"
+      "lea         0x40(%1),%1                   \n"
+      "sub         $0x8,%2                       \n"
+      "jg          1b                            \n"
+      : "+r"(src_argb),  // %0
+        "+r"(dst_ar64),  // %1
+        "+r"(width)      // %2
+      :
+      : "memory", "cc", "xmm0", "xmm1");
+}
+#endif
+
+#ifdef HAS_ARGBTOAB64ROW_AVX2
+void ARGBToAB64Row_AVX2(const uint8_t* src_argb,
+                        uint16_t* dst_ab64,
+                        int width) {
+  asm volatile(
+
+      "vbroadcastf128 %3,%%ymm2                  \n"
+      "vbroadcastf128 %4,%%ymm3                  \n" LABELALIGN
+      "1:                                        \n"
+      "vmovdqu     (%0),%%ymm0                   \n"
+      "vpermq      $0xd8,%%ymm0,%%ymm0           \n"
+      "vpshufb     %%ymm3,%%ymm0,%%ymm1          \n"
+      "vpshufb     %%ymm2,%%ymm0,%%ymm0          \n"
+      "vmovdqu     %%ymm0,(%1)                   \n"
+      "vmovdqu     %%ymm1,0x20(%1)               \n"
+      "lea         0x20(%0),%0                   \n"
+      "lea         0x40(%1),%1                   \n"
+      "sub         $0x8,%2                       \n"
+      "jg          1b                            \n"
+      : "+r"(src_argb),             // %0
+        "+r"(dst_ab64),             // %1
+        "+r"(width)                 // %2
+      : "m"(kShuffleARGBToAB64Lo),  // %3
+        "m"(kShuffleARGBToAB64Hi)   // %3
+      : "memory", "cc", "xmm0", "xmm1", "xmm2");
+}
+#endif
+
+#ifdef HAS_AR64TOARGBROW_AVX2
+void AR64ToARGBRow_AVX2(const uint16_t* src_ar64,
+                        uint8_t* dst_argb,
+                        int width) {
+  asm volatile(
+
+      LABELALIGN
+      "1:                                        \n"
+      "vmovdqu     (%0),%%ymm0                   \n"
+      "vmovdqu     0x20(%0),%%ymm1               \n"
+      "vpsrlw      $8,%%ymm0,%%ymm0              \n"
+      "vpsrlw      $8,%%ymm1,%%ymm1              \n"
+      "vpackuswb   %%ymm1,%%ymm0,%%ymm0          \n"
+      "vpermq      $0xd8,%%ymm0,%%ymm0           \n"
+      "vmovdqu     %%ymm0,(%1)                   \n"
+      "lea         0x40(%0),%0                   \n"
+      "lea         0x20(%1),%1                   \n"
+      "sub         $0x8,%2                       \n"
+      "jg          1b                            \n"
+      : "+r"(src_ar64),  // %0
+        "+r"(dst_argb),  // %1
+        "+r"(width)      // %2
+      :
+      : "memory", "cc", "xmm0", "xmm1");
+}
+#endif
+
+#ifdef HAS_AB64TOARGBROW_AVX2
+void AB64ToARGBRow_AVX2(const uint16_t* src_ab64,
+                        uint8_t* dst_argb,
+                        int width) {
+  asm volatile(
+
+      "vbroadcastf128 %3,%%ymm2                  \n" LABELALIGN
+      "1:                                        \n"
+      "vmovdqu     (%0),%%ymm0                   \n"
+      "vmovdqu     0x20(%0),%%ymm1               \n"
+      "vpsrlw      $8,%%ymm0,%%ymm0              \n"
+      "vpsrlw      $8,%%ymm1,%%ymm1              \n"
+      "vpackuswb   %%ymm1,%%ymm0,%%ymm0          \n"
+      "vpermq      $0xd8,%%ymm0,%%ymm0           \n"
+      "vpshufb     %%ymm2,%%ymm0,%%ymm0          \n"
+      "vmovdqu     %%ymm0,(%1)                   \n"
+      "lea         0x40(%0),%0                   \n"
+      "lea         0x20(%1),%1                   \n"
+      "sub         $0x8,%2                       \n"
+      "jg          1b                            \n"
+      : "+r"(src_ab64),          // %0
+        "+r"(dst_argb),          // %1
+        "+r"(width)              // %2
+      : "m"(kShuffleARGBToABGR)  // %3
+      : "memory", "cc", "xmm0", "xmm1", "xmm2");
+}
+#endif
+
+// clang-format off
+
+// TODO(mraptis): Consider passing R, G, B multipliers as parameter.
+// round parameter is register containing value to add before shift.
+#define RGBTOY(round)                            \
+  "1:                                        \n" \
+  "movdqu    (%0),%%xmm0                     \n" \
+  "movdqu    0x10(%0),%%xmm1                 \n" \
+  "movdqu    0x20(%0),%%xmm2                 \n" \
+  "movdqu    0x30(%0),%%xmm3                 \n" \
+  "psubb     %%xmm5,%%xmm0                   \n" \
+  "psubb     %%xmm5,%%xmm1                   \n" \
+  "psubb     %%xmm5,%%xmm2                   \n" \
+  "psubb     %%xmm5,%%xmm3                   \n" \
+  "movdqu    %%xmm4,%%xmm6                   \n" \
+  "pmaddubsw %%xmm0,%%xmm6                   \n" \
+  "movdqu    %%xmm4,%%xmm0                   \n" \
+  "pmaddubsw %%xmm1,%%xmm0                   \n" \
+  "movdqu    %%xmm4,%%xmm1                   \n" \
+  "pmaddubsw %%xmm2,%%xmm1                   \n" \
+  "movdqu    %%xmm4,%%xmm2                   \n" \
+  "pmaddubsw %%xmm3,%%xmm2                   \n" \
+  "lea       0x40(%0),%0                     \n" \
+  "phaddw    %%xmm0,%%xmm6                   \n" \
+  "phaddw    %%xmm2,%%xmm1                   \n" \
+  "prefetcht0 1280(%0)                       \n" \
+  "paddw     %%" #round ",%%xmm6             \n" \
+  "paddw     %%" #round ",%%xmm1             \n" \
+  "psrlw     $0x8,%%xmm6                     \n" \
+  "psrlw     $0x8,%%xmm1                     \n" \
+  "packuswb  %%xmm1,%%xmm6                   \n" \
+  "movdqu    %%xmm6,(%1)                     \n" \
+  "lea       0x10(%1),%1                     \n" \
+  "sub       $0x10,%2                        \n" \
+  "jg        1b                              \n"
+
+#define RGBTOY_AVX2(round)                                       \
+  "1:                                        \n"                 \
+  "vmovdqu    (%0),%%ymm0                    \n"                 \
+  "vmovdqu    0x20(%0),%%ymm1                \n"                 \
+  "vmovdqu    0x40(%0),%%ymm2                \n"                 \
+  "vmovdqu    0x60(%0),%%ymm3                \n"                 \
+  "vpsubb     %%ymm5, %%ymm0, %%ymm0         \n"                 \
+  "vpsubb     %%ymm5, %%ymm1, %%ymm1         \n"                 \
+  "vpsubb     %%ymm5, %%ymm2, %%ymm2         \n"                 \
+  "vpsubb     %%ymm5, %%ymm3, %%ymm3         \n"                 \
+  "vpmaddubsw %%ymm0,%%ymm4,%%ymm0           \n"                 \
+  "vpmaddubsw %%ymm1,%%ymm4,%%ymm1           \n"                 \
+  "vpmaddubsw %%ymm2,%%ymm4,%%ymm2           \n"                 \
+  "vpmaddubsw %%ymm3,%%ymm4,%%ymm3           \n"                 \
+  "lea       0x80(%0),%0                     \n"                 \
+  "vphaddw    %%ymm1,%%ymm0,%%ymm0           \n" /* mutates. */  \
+  "vphaddw    %%ymm3,%%ymm2,%%ymm2           \n"                 \
+  "prefetcht0 1280(%0)                       \n"                 \
+  "vpaddw     %%" #round ",%%ymm0,%%ymm0     \n" /* Add .5 for rounding. */             \
+  "vpaddw     %%" #round ",%%ymm2,%%ymm2     \n" \
+  "vpsrlw     $0x8,%%ymm0,%%ymm0             \n"                 \
+  "vpsrlw     $0x8,%%ymm2,%%ymm2             \n"                 \
+  "vpackuswb  %%ymm2,%%ymm0,%%ymm0           \n" /* mutates. */  \
+  "vpermd     %%ymm0,%%ymm6,%%ymm0           \n" /* unmutate. */ \
+  "vmovdqu    %%ymm0,(%1)                    \n"                 \
+  "lea       0x20(%1),%1                     \n"                 \
+  "sub       $0x20,%2                        \n"                 \
+  "jg        1b                              \n"                 \
+  "vzeroupper                                \n"
+
+// clang-format on
+
+#ifdef HAS_ARGBTOYROW_SSSE3
+// Convert 16 ARGB pixels (64 bytes) to 16 Y values.
+void ARGBToYRow_SSSE3(const uint8_t* src_argb, uint8_t* dst_y, int width) {
+  asm volatile(
+      "movdqa      %3,%%xmm4                     \n"
+      "movdqa      %4,%%xmm5                     \n"
+      "movdqa      %5,%%xmm7                     \n"
+
+      LABELALIGN RGBTOY(xmm7)
+      : "+r"(src_argb),  // %0
+        "+r"(dst_y),     // %1
+        "+r"(width)      // %2
+      : "m"(kARGBToY),   // %3
+        "m"(kSub128),    // %4
+        "m"(kAddY16)     // %5
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6",
+        "xmm7");
+}
+#endif  // HAS_ARGBTOYROW_SSSE3
+
+#ifdef HAS_ARGBTOYJROW_SSSE3
+// Convert 16 ARGB pixels (64 bytes) to 16 YJ values.
+// Same as ARGBToYRow but different coefficients, no add 16.
+void ARGBToYJRow_SSSE3(const uint8_t* src_argb, uint8_t* dst_y, int width) {
+  asm volatile(
+      "movdqa      %3,%%xmm4                     \n"
+      "movdqa      %4,%%xmm5                     \n"
+
+      LABELALIGN RGBTOY(xmm5)
+      : "+r"(src_argb),  // %0
+        "+r"(dst_y),     // %1
+        "+r"(width)      // %2
+      : "m"(kARGBToYJ),  // %3
+        "m"(kSub128)     // %4
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6");
+}
+#endif  // HAS_ARGBTOYJROW_SSSE3
+
+#ifdef HAS_RGBATOYJROW_SSSE3
+// Convert 16 ARGB pixels (64 bytes) to 16 YJ values.
+// Same as ARGBToYRow but different coefficients, no add 16.
+void RGBAToYJRow_SSSE3(const uint8_t* src_rgba, uint8_t* dst_y, int width) {
+  asm volatile(
+      "movdqa      %3,%%xmm4                     \n"
+      "movdqa      %4,%%xmm5                     \n"
+
+      LABELALIGN RGBTOY(xmm5)
+      : "+r"(src_rgba),  // %0
+        "+r"(dst_y),     // %1
+        "+r"(width)      // %2
+      : "m"(kRGBAToYJ),  // %3
+        "m"(kSub128)     // %4
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6");
+}
+#endif  // HAS_RGBATOYJROW_SSSE3
+
+#if defined(HAS_ARGBTOYROW_AVX2) || defined(HAS_ARGBEXTRACTALPHAROW_AVX2)
+// vpermd for vphaddw + vpackuswb vpermd.
+static const lvec32 kPermdARGBToY_AVX = {0, 4, 1, 5, 2, 6, 3, 7};
+#endif
+
+#ifdef HAS_ARGBTOYROW_AVX2
+
+// Convert 32 ARGB pixels (128 bytes) to 32 Y values.
+void ARGBToYRow_AVX2(const uint8_t* src_argb, uint8_t* dst_y, int width) {
+  asm volatile(
+      "vbroadcastf128 %3,%%ymm4                  \n"
+      "vbroadcastf128 %4,%%ymm5                  \n"
+      "vbroadcastf128 %5,%%ymm7                  \n"
+      "vmovdqu     %6,%%ymm6                     \n"
+
+      LABELALIGN RGBTOY_AVX2(ymm7)
+      : "+r"(src_argb),         // %0
+        "+r"(dst_y),            // %1
+        "+r"(width)             // %2
+      : "m"(kARGBToY),          // %3
+        "m"(kSub128),           // %4
+        "m"(kAddY16),           // %5
+        "m"(kPermdARGBToY_AVX)  // %6
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6",
+        "xmm7");
+}
+#endif  // HAS_ARGBTOYROW_AVX2
+
+#ifdef HAS_ABGRTOYROW_AVX2
+// Convert 32 ABGR pixels (128 bytes) to 32 Y values.
+void ABGRToYRow_AVX2(const uint8_t* src_abgr, uint8_t* dst_y, int width) {
+  asm volatile(
+      "vbroadcastf128 %3,%%ymm4                  \n"
+      "vbroadcastf128 %4,%%ymm5                  \n"
+      "vbroadcastf128 %5,%%ymm7                  \n"
+      "vmovdqu     %6,%%ymm6                     \n"
+
+      LABELALIGN RGBTOY_AVX2(ymm7)
+      : "+r"(src_abgr),         // %0
+        "+r"(dst_y),            // %1
+        "+r"(width)             // %2
+      : "m"(kABGRToY),          // %3
+        "m"(kSub128),           // %4
+        "m"(kAddY16),           // %5
+        "m"(kPermdARGBToY_AVX)  // %6
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6",
+        "xmm7");
+}
+#endif  // HAS_ABGRTOYROW_AVX2
+
+#ifdef HAS_ARGBTOYJROW_AVX2
+// Convert 32 ARGB pixels (128 bytes) to 32 Y values.
+void ARGBToYJRow_AVX2(const uint8_t* src_argb, uint8_t* dst_y, int width) {
+  asm volatile(
+      "vbroadcastf128 %3,%%ymm4                  \n"
+      "vbroadcastf128 %4,%%ymm5                  \n"
+      "vmovdqu     %5,%%ymm6                     \n"
+
+      LABELALIGN RGBTOY_AVX2(ymm5)
+      : "+r"(src_argb),         // %0
+        "+r"(dst_y),            // %1
+        "+r"(width)             // %2
+      : "m"(kARGBToYJ),         // %3
+        "m"(kSub128),           // %4
+        "m"(kPermdARGBToY_AVX)  // %5
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6",
+        "xmm7");
+}
+#endif  // HAS_ARGBTOYJROW_AVX2
+
+#ifdef HAS_RGBATOYJROW_AVX2
+// Convert 32 ARGB pixels (128 bytes) to 32 Y values.
+void RGBAToYJRow_AVX2(const uint8_t* src_rgba, uint8_t* dst_y, int width) {
+  asm volatile(
+      "vbroadcastf128 %3,%%ymm4                  \n"
+      "vbroadcastf128 %4,%%ymm5                  \n"
+      "vmovdqu     %5,%%ymm6                     \n"
+
+      LABELALIGN RGBTOY_AVX2(
+      ymm5) "vzeroupper                                \n"
+      : "+r"(src_rgba),         // %0
+        "+r"(dst_y),            // %1
+        "+r"(width)             // %2
+      : "m"(kRGBAToYJ),         // %3
+        "m"(kSub128),           // %4
+        "m"(kPermdARGBToY_AVX)  // %5
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6");
+}
+#endif  // HAS_RGBATOYJROW_AVX2
+
+#ifdef HAS_ARGBTOUVROW_SSSE3
+void ARGBToUVRow_SSSE3(const uint8_t* src_argb,
+                       int src_stride_argb,
+                       uint8_t* dst_u,
+                       uint8_t* dst_v,
+                       int width) {
+  asm volatile(
+      "movdqa      %5,%%xmm3                     \n"
+      "movdqa      %6,%%xmm4                     \n"
+      "movdqa      %7,%%xmm5                     \n"
+      "sub         %1,%2                         \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "movdqu      (%0),%%xmm0                   \n"
+      "movdqu      0x00(%0,%4,1),%%xmm7          \n"
+      "pavgb       %%xmm7,%%xmm0                 \n"
+      "movdqu      0x10(%0),%%xmm1               \n"
+      "movdqu      0x10(%0,%4,1),%%xmm7          \n"
+      "pavgb       %%xmm7,%%xmm1                 \n"
+      "movdqu      0x20(%0),%%xmm2               \n"
+      "movdqu      0x20(%0,%4,1),%%xmm7          \n"
+      "pavgb       %%xmm7,%%xmm2                 \n"
+      "movdqu      0x30(%0),%%xmm6               \n"
+      "movdqu      0x30(%0,%4,1),%%xmm7          \n"
+      "pavgb       %%xmm7,%%xmm6                 \n"
+
+      "lea         0x40(%0),%0                   \n"
+      "movdqa      %%xmm0,%%xmm7                 \n"
+      "shufps      $0x88,%%xmm1,%%xmm0           \n"
+      "shufps      $0xdd,%%xmm1,%%xmm7           \n"
+      "pavgb       %%xmm7,%%xmm0                 \n"
+      "movdqa      %%xmm2,%%xmm7                 \n"
+      "shufps      $0x88,%%xmm6,%%xmm2           \n"
+      "shufps      $0xdd,%%xmm6,%%xmm7           \n"
+      "pavgb       %%xmm7,%%xmm2                 \n"
+      "movdqa      %%xmm0,%%xmm1                 \n"
+      "movdqa      %%xmm2,%%xmm6                 \n"
+      "pmaddubsw   %%xmm4,%%xmm0                 \n"
+      "pmaddubsw   %%xmm4,%%xmm2                 \n"
+      "pmaddubsw   %%xmm3,%%xmm1                 \n"
+      "pmaddubsw   %%xmm3,%%xmm6                 \n"
+      "phaddw      %%xmm2,%%xmm0                 \n"
+      "phaddw      %%xmm6,%%xmm1                 \n"
+      "psraw       $0x8,%%xmm0                   \n"
+      "psraw       $0x8,%%xmm1                   \n"
+      "packsswb    %%xmm1,%%xmm0                 \n"
+      "paddb       %%xmm5,%%xmm0                 \n"
+      "movlps      %%xmm0,(%1)                   \n"
+      "movhps      %%xmm0,0x00(%1,%2,1)          \n"
+      "lea         0x8(%1),%1                    \n"
+      "sub         $0x10,%3                      \n"
+      "jg          1b                            \n"
+      : "+r"(src_argb),                    // %0
+        "+r"(dst_u),                       // %1
+        "+r"(dst_v),                       // %2
+        "+rm"(width)                       // %3
+      : "r"((intptr_t)(src_stride_argb)),  // %4
+        "m"(kARGBToV),                     // %5
+        "m"(kARGBToU),                     // %6
+        "m"(kAddUV128)                     // %7
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm6", "xmm7");
+}
+#endif  // HAS_ARGBTOUVROW_SSSE3
+
+#ifdef HAS_ARGBTOUVROW_AVX2
+// vpshufb for vphaddw + vpackuswb packed to shorts.
+static const lvec8 kShufARGBToUV_AVX = {
+    0, 1, 8, 9, 2, 3, 10, 11, 4, 5, 12, 13, 6, 7, 14, 15,
+    0, 1, 8, 9, 2, 3, 10, 11, 4, 5, 12, 13, 6, 7, 14, 15};
+void ARGBToUVRow_AVX2(const uint8_t* src_argb,
+                      int src_stride_argb,
+                      uint8_t* dst_u,
+                      uint8_t* dst_v,
+                      int width) {
+  asm volatile(
+      "vbroadcastf128 %5,%%ymm5                  \n"
+      "vbroadcastf128 %6,%%ymm6                  \n"
+      "vbroadcastf128 %7,%%ymm7                  \n"
+      "sub         %1,%2                         \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "vmovdqu     (%0),%%ymm0                   \n"
+      "vmovdqu     0x20(%0),%%ymm1               \n"
+      "vmovdqu     0x40(%0),%%ymm2               \n"
+      "vmovdqu     0x60(%0),%%ymm3               \n"
+      "vpavgb      0x00(%0,%4,1),%%ymm0,%%ymm0   \n"
+      "vpavgb      0x20(%0,%4,1),%%ymm1,%%ymm1   \n"
+      "vpavgb      0x40(%0,%4,1),%%ymm2,%%ymm2   \n"
+      "vpavgb      0x60(%0,%4,1),%%ymm3,%%ymm3   \n"
+      "lea         0x80(%0),%0                   \n"
+      "vshufps     $0x88,%%ymm1,%%ymm0,%%ymm4    \n"
+      "vshufps     $0xdd,%%ymm1,%%ymm0,%%ymm0    \n"
+      "vpavgb      %%ymm4,%%ymm0,%%ymm0          \n"
+      "vshufps     $0x88,%%ymm3,%%ymm2,%%ymm4    \n"
+      "vshufps     $0xdd,%%ymm3,%%ymm2,%%ymm2    \n"
+      "vpavgb      %%ymm4,%%ymm2,%%ymm2          \n"
+
+      "vpmaddubsw  %%ymm7,%%ymm0,%%ymm1          \n"
+      "vpmaddubsw  %%ymm7,%%ymm2,%%ymm3          \n"
+      "vpmaddubsw  %%ymm6,%%ymm0,%%ymm0          \n"
+      "vpmaddubsw  %%ymm6,%%ymm2,%%ymm2          \n"
+      "vphaddw     %%ymm3,%%ymm1,%%ymm1          \n"
+      "vphaddw     %%ymm2,%%ymm0,%%ymm0          \n"
+      "vpsraw      $0x8,%%ymm1,%%ymm1            \n"
+      "vpsraw      $0x8,%%ymm0,%%ymm0            \n"
+      "vpacksswb   %%ymm0,%%ymm1,%%ymm0          \n"
+      "vpermq      $0xd8,%%ymm0,%%ymm0           \n"
+      "vpshufb     %8,%%ymm0,%%ymm0              \n"
+      "vpaddb      %%ymm5,%%ymm0,%%ymm0          \n"
+
+      "vextractf128 $0x0,%%ymm0,(%1)             \n"
+      "vextractf128 $0x1,%%ymm0,0x0(%1,%2,1)     \n"
+      "lea         0x10(%1),%1                   \n"
+      "sub         $0x20,%3                      \n"
+      "jg          1b                            \n"
+      "vzeroupper                                \n"
+      : "+r"(src_argb),                    // %0
+        "+r"(dst_u),                       // %1
+        "+r"(dst_v),                       // %2
+        "+rm"(width)                       // %3
+      : "r"((intptr_t)(src_stride_argb)),  // %4
+        "m"(kAddUV128),                    // %5
+        "m"(kARGBToV),                     // %6
+        "m"(kARGBToU),                     // %7
+        "m"(kShufARGBToUV_AVX)             // %8
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6",
+        "xmm7");
+}
+#endif  // HAS_ARGBTOUVROW_AVX2
+
+#ifdef HAS_ABGRTOUVROW_AVX2
+void ABGRToUVRow_AVX2(const uint8_t* src_abgr,
+                      int src_stride_abgr,
+                      uint8_t* dst_u,
+                      uint8_t* dst_v,
+                      int width) {
+  asm volatile(
+      "vbroadcastf128 %5,%%ymm5                  \n"
+      "vbroadcastf128 %6,%%ymm6                  \n"
+      "vbroadcastf128 %7,%%ymm7                  \n"
+      "sub         %1,%2                         \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "vmovdqu     (%0),%%ymm0                   \n"
+      "vmovdqu     0x20(%0),%%ymm1               \n"
+      "vmovdqu     0x40(%0),%%ymm2               \n"
+      "vmovdqu     0x60(%0),%%ymm3               \n"
+      "vpavgb      0x00(%0,%4,1),%%ymm0,%%ymm0   \n"
+      "vpavgb      0x20(%0,%4,1),%%ymm1,%%ymm1   \n"
+      "vpavgb      0x40(%0,%4,1),%%ymm2,%%ymm2   \n"
+      "vpavgb      0x60(%0,%4,1),%%ymm3,%%ymm3   \n"
+      "lea         0x80(%0),%0                   \n"
+      "vshufps     $0x88,%%ymm1,%%ymm0,%%ymm4    \n"
+      "vshufps     $0xdd,%%ymm1,%%ymm0,%%ymm0    \n"
+      "vpavgb      %%ymm4,%%ymm0,%%ymm0          \n"
+      "vshufps     $0x88,%%ymm3,%%ymm2,%%ymm4    \n"
+      "vshufps     $0xdd,%%ymm3,%%ymm2,%%ymm2    \n"
+      "vpavgb      %%ymm4,%%ymm2,%%ymm2          \n"
+
+      "vpmaddubsw  %%ymm7,%%ymm0,%%ymm1          \n"
+      "vpmaddubsw  %%ymm7,%%ymm2,%%ymm3          \n"
+      "vpmaddubsw  %%ymm6,%%ymm0,%%ymm0          \n"
+      "vpmaddubsw  %%ymm6,%%ymm2,%%ymm2          \n"
+      "vphaddw     %%ymm3,%%ymm1,%%ymm1          \n"
+      "vphaddw     %%ymm2,%%ymm0,%%ymm0          \n"
+      "vpsraw      $0x8,%%ymm1,%%ymm1            \n"
+      "vpsraw      $0x8,%%ymm0,%%ymm0            \n"
+      "vpacksswb   %%ymm0,%%ymm1,%%ymm0          \n"
+      "vpermq      $0xd8,%%ymm0,%%ymm0           \n"
+      "vpshufb     %8,%%ymm0,%%ymm0              \n"
+      "vpaddb      %%ymm5,%%ymm0,%%ymm0          \n"
+
+      "vextractf128 $0x0,%%ymm0,(%1)             \n"
+      "vextractf128 $0x1,%%ymm0,0x0(%1,%2,1)     \n"
+      "lea         0x10(%1),%1                   \n"
+      "sub         $0x20,%3                      \n"
+      "jg          1b                            \n"
+      "vzeroupper                                \n"
+      : "+r"(src_abgr),                    // %0
+        "+r"(dst_u),                       // %1
+        "+r"(dst_v),                       // %2
+        "+rm"(width)                       // %3
+      : "r"((intptr_t)(src_stride_abgr)),  // %4
+        "m"(kAddUV128),                    // %5
+        "m"(kABGRToV),                     // %6
+        "m"(kABGRToU),                     // %7
+        "m"(kShufARGBToUV_AVX)             // %8
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6",
+        "xmm7");
+}
+#endif  // HAS_ABGRTOUVROW_AVX2
+
+#ifdef HAS_ARGBTOUVJROW_AVX2
+void ARGBToUVJRow_AVX2(const uint8_t* src_argb,
+                       int src_stride_argb,
+                       uint8_t* dst_u,
+                       uint8_t* dst_v,
+                       int width) {
+  asm volatile(
+      "vbroadcastf128 %5,%%ymm5                  \n"
+      "vbroadcastf128 %6,%%ymm6                  \n"
+      "vbroadcastf128 %7,%%ymm7                  \n"
+      "sub         %1,%2                         \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "vmovdqu     (%0),%%ymm0                   \n"
+      "vmovdqu     0x20(%0),%%ymm1               \n"
+      "vmovdqu     0x40(%0),%%ymm2               \n"
+      "vmovdqu     0x60(%0),%%ymm3               \n"
+      "vpavgb      0x00(%0,%4,1),%%ymm0,%%ymm0   \n"
+      "vpavgb      0x20(%0,%4,1),%%ymm1,%%ymm1   \n"
+      "vpavgb      0x40(%0,%4,1),%%ymm2,%%ymm2   \n"
+      "vpavgb      0x60(%0,%4,1),%%ymm3,%%ymm3   \n"
+      "lea         0x80(%0),%0                   \n"
+      "vshufps     $0x88,%%ymm1,%%ymm0,%%ymm4    \n"
+      "vshufps     $0xdd,%%ymm1,%%ymm0,%%ymm0    \n"
+      "vpavgb      %%ymm4,%%ymm0,%%ymm0          \n"
+      "vshufps     $0x88,%%ymm3,%%ymm2,%%ymm4    \n"
+      "vshufps     $0xdd,%%ymm3,%%ymm2,%%ymm2    \n"
+      "vpavgb      %%ymm4,%%ymm2,%%ymm2          \n"
+
+      "vpmaddubsw  %%ymm7,%%ymm0,%%ymm1          \n"
+      "vpmaddubsw  %%ymm7,%%ymm2,%%ymm3          \n"
+      "vpmaddubsw  %%ymm6,%%ymm0,%%ymm0          \n"
+      "vpmaddubsw  %%ymm6,%%ymm2,%%ymm2          \n"
+      "vphaddw     %%ymm3,%%ymm1,%%ymm1          \n"
+      "vphaddw     %%ymm2,%%ymm0,%%ymm0          \n"
+      "vpaddw      %%ymm5,%%ymm0,%%ymm0          \n"
+      "vpaddw      %%ymm5,%%ymm1,%%ymm1          \n"
+      "vpsraw      $0x8,%%ymm1,%%ymm1            \n"
+      "vpsraw      $0x8,%%ymm0,%%ymm0            \n"
+      "vpacksswb   %%ymm0,%%ymm1,%%ymm0          \n"
+      "vpermq      $0xd8,%%ymm0,%%ymm0           \n"
+      "vpshufb     %8,%%ymm0,%%ymm0              \n"
+
+      "vextractf128 $0x0,%%ymm0,(%1)             \n"
+      "vextractf128 $0x1,%%ymm0,0x0(%1,%2,1)     \n"
+      "lea         0x10(%1),%1                   \n"
+      "sub         $0x20,%3                      \n"
+      "jg          1b                            \n"
+      "vzeroupper                                \n"
+      : "+r"(src_argb),                    // %0
+        "+r"(dst_u),                       // %1
+        "+r"(dst_v),                       // %2
+        "+rm"(width)                       // %3
+      : "r"((intptr_t)(src_stride_argb)),  // %4
+        "m"(kSub128),                      // %5
+        "m"(kARGBToVJ),                    // %6
+        "m"(kARGBToUJ),                    // %7
+        "m"(kShufARGBToUV_AVX)             // %8
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6",
+        "xmm7");
+}
+#endif  // HAS_ARGBTOUVJROW_AVX2
+
+#ifdef HAS_ARGBTOUVJROW_SSSE3
+void ARGBToUVJRow_SSSE3(const uint8_t* src_argb,
+                        int src_stride_argb,
+                        uint8_t* dst_u,
+                        uint8_t* dst_v,
+                        int width) {
+  asm volatile(
+      "movdqa      %5,%%xmm3                     \n"
+      "movdqa      %6,%%xmm4                     \n"
+      "movdqa      %7,%%xmm5                     \n"
+      "sub         %1,%2                         \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "movdqu      (%0),%%xmm0                   \n"
+      "movdqu      0x00(%0,%4,1),%%xmm7          \n"
+      "pavgb       %%xmm7,%%xmm0                 \n"
+      "movdqu      0x10(%0),%%xmm1               \n"
+      "movdqu      0x10(%0,%4,1),%%xmm7          \n"
+      "pavgb       %%xmm7,%%xmm1                 \n"
+      "movdqu      0x20(%0),%%xmm2               \n"
+      "movdqu      0x20(%0,%4,1),%%xmm7          \n"
+      "pavgb       %%xmm7,%%xmm2                 \n"
+      "movdqu      0x30(%0),%%xmm6               \n"
+      "movdqu      0x30(%0,%4,1),%%xmm7          \n"
+      "pavgb       %%xmm7,%%xmm6                 \n"
+
+      "lea         0x40(%0),%0                   \n"
+      "movdqa      %%xmm0,%%xmm7                 \n"
+      "shufps      $0x88,%%xmm1,%%xmm0           \n"
+      "shufps      $0xdd,%%xmm1,%%xmm7           \n"
+      "pavgb       %%xmm7,%%xmm0                 \n"
+      "movdqa      %%xmm2,%%xmm7                 \n"
+      "shufps      $0x88,%%xmm6,%%xmm2           \n"
+      "shufps      $0xdd,%%xmm6,%%xmm7           \n"
+      "pavgb       %%xmm7,%%xmm2                 \n"
+      "movdqa      %%xmm0,%%xmm1                 \n"
+      "movdqa      %%xmm2,%%xmm6                 \n"
+      "pmaddubsw   %%xmm4,%%xmm0                 \n"
+      "pmaddubsw   %%xmm4,%%xmm2                 \n"
+      "pmaddubsw   %%xmm3,%%xmm1                 \n"
+      "pmaddubsw   %%xmm3,%%xmm6                 \n"
+      "phaddw      %%xmm2,%%xmm0                 \n"
+      "phaddw      %%xmm6,%%xmm1                 \n"
+      "paddw       %%xmm5,%%xmm0                 \n"
+      "paddw       %%xmm5,%%xmm1                 \n"
+      "psraw       $0x8,%%xmm0                   \n"
+      "psraw       $0x8,%%xmm1                   \n"
+      "packsswb    %%xmm1,%%xmm0                 \n"
+      "movlps      %%xmm0,(%1)                   \n"
+      "movhps      %%xmm0,0x00(%1,%2,1)          \n"
+      "lea         0x8(%1),%1                    \n"
+      "sub         $0x10,%3                      \n"
+      "jg          1b                            \n"
+      : "+r"(src_argb),                    // %0
+        "+r"(dst_u),                       // %1
+        "+r"(dst_v),                       // %2
+        "+rm"(width)                       // %3
+      : "r"((intptr_t)(src_stride_argb)),  // %4
+        "m"(kARGBToVJ),                    // %5
+        "m"(kARGBToUJ),                    // %6
+        "m"(kSub128)                       // %7
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm6", "xmm7");
+}
+#endif  // HAS_ARGBTOUVJROW_SSSE3
+
+#ifdef HAS_ARGBTOUV444ROW_SSSE3
+void ARGBToUV444Row_SSSE3(const uint8_t* src_argb,
+                          uint8_t* dst_u,
+                          uint8_t* dst_v,
+                          int width) {
+  asm volatile(
+      "movdqa      %4,%%xmm3                     \n"
+      "movdqa      %5,%%xmm4                     \n"
+      "movdqa      %6,%%xmm5                     \n"
+      "sub         %1,%2                         \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "movdqu      (%0),%%xmm0                   \n"
+      "movdqu      0x10(%0),%%xmm1               \n"
+      "movdqu      0x20(%0),%%xmm2               \n"
+      "movdqu      0x30(%0),%%xmm6               \n"
+      "pmaddubsw   %%xmm4,%%xmm0                 \n"
+      "pmaddubsw   %%xmm4,%%xmm1                 \n"
+      "pmaddubsw   %%xmm4,%%xmm2                 \n"
+      "pmaddubsw   %%xmm4,%%xmm6                 \n"
+      "phaddw      %%xmm1,%%xmm0                 \n"
+      "phaddw      %%xmm6,%%xmm2                 \n"
+      "psraw       $0x8,%%xmm0                   \n"
+      "psraw       $0x8,%%xmm2                   \n"
+      "packsswb    %%xmm2,%%xmm0                 \n"
+      "paddb       %%xmm5,%%xmm0                 \n"
+      "movdqu      %%xmm0,(%1)                   \n"
+      "movdqu      (%0),%%xmm0                   \n"
+      "movdqu      0x10(%0),%%xmm1               \n"
+      "movdqu      0x20(%0),%%xmm2               \n"
+      "movdqu      0x30(%0),%%xmm6               \n"
+      "pmaddubsw   %%xmm3,%%xmm0                 \n"
+      "pmaddubsw   %%xmm3,%%xmm1                 \n"
+      "pmaddubsw   %%xmm3,%%xmm2                 \n"
+      "pmaddubsw   %%xmm3,%%xmm6                 \n"
+      "phaddw      %%xmm1,%%xmm0                 \n"
+      "phaddw      %%xmm6,%%xmm2                 \n"
+      "psraw       $0x8,%%xmm0                   \n"
+      "psraw       $0x8,%%xmm2                   \n"
+      "packsswb    %%xmm2,%%xmm0                 \n"
+      "paddb       %%xmm5,%%xmm0                 \n"
+      "lea         0x40(%0),%0                   \n"
+      "movdqu      %%xmm0,0x00(%1,%2,1)          \n"
+      "lea         0x10(%1),%1                   \n"
+      "sub         $0x10,%3                      \n"
+      "jg          1b                            \n"
+      : "+r"(src_argb),  // %0
+        "+r"(dst_u),     // %1
+        "+r"(dst_v),     // %2
+        "+rm"(width)     // %3
+      : "m"(kARGBToV),   // %4
+        "m"(kARGBToU),   // %5
+        "m"(kAddUV128)   // %6
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm6");
+}
+#endif  // HAS_ARGBTOUV444ROW_SSSE3
+
+void BGRAToYRow_SSSE3(const uint8_t* src_bgra, uint8_t* dst_y, int width) {
+  asm volatile(
+      "movdqa      %3,%%xmm4                     \n"
+      "movdqa      %4,%%xmm5                     \n"
+      "movdqa      %5,%%xmm7                     \n"
+
+      LABELALIGN RGBTOY(xmm7)
+      : "+r"(src_bgra),  // %0
+        "+r"(dst_y),     // %1
+        "+r"(width)      // %2
+      : "m"(kBGRAToY),   // %3
+        "m"(kSub128),    // %4
+        "m"(kAddY16)     // %5
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6",
+        "xmm7");
+}
+
+void BGRAToUVRow_SSSE3(const uint8_t* src_bgra,
+                       int src_stride_bgra,
+                       uint8_t* dst_u,
+                       uint8_t* dst_v,
+                       int width) {
+  asm volatile(
+      "movdqa      %5,%%xmm3                     \n"
+      "movdqa      %6,%%xmm4                     \n"
+      "movdqa      %7,%%xmm5                     \n"
+      "sub         %1,%2                         \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "movdqu      (%0),%%xmm0                   \n"
+      "movdqu      0x00(%0,%4,1),%%xmm7          \n"
+      "pavgb       %%xmm7,%%xmm0                 \n"
+      "movdqu      0x10(%0),%%xmm1               \n"
+      "movdqu      0x10(%0,%4,1),%%xmm7          \n"
+      "pavgb       %%xmm7,%%xmm1                 \n"
+      "movdqu      0x20(%0),%%xmm2               \n"
+      "movdqu      0x20(%0,%4,1),%%xmm7          \n"
+      "pavgb       %%xmm7,%%xmm2                 \n"
+      "movdqu      0x30(%0),%%xmm6               \n"
+      "movdqu      0x30(%0,%4,1),%%xmm7          \n"
+      "pavgb       %%xmm7,%%xmm6                 \n"
+
+      "lea         0x40(%0),%0                   \n"
+      "movdqa      %%xmm0,%%xmm7                 \n"
+      "shufps      $0x88,%%xmm1,%%xmm0           \n"
+      "shufps      $0xdd,%%xmm1,%%xmm7           \n"
+      "pavgb       %%xmm7,%%xmm0                 \n"
+      "movdqa      %%xmm2,%%xmm7                 \n"
+      "shufps      $0x88,%%xmm6,%%xmm2           \n"
+      "shufps      $0xdd,%%xmm6,%%xmm7           \n"
+      "pavgb       %%xmm7,%%xmm2                 \n"
+      "movdqa      %%xmm0,%%xmm1                 \n"
+      "movdqa      %%xmm2,%%xmm6                 \n"
+      "pmaddubsw   %%xmm4,%%xmm0                 \n"
+      "pmaddubsw   %%xmm4,%%xmm2                 \n"
+      "pmaddubsw   %%xmm3,%%xmm1                 \n"
+      "pmaddubsw   %%xmm3,%%xmm6                 \n"
+      "phaddw      %%xmm2,%%xmm0                 \n"
+      "phaddw      %%xmm6,%%xmm1                 \n"
+      "psraw       $0x8,%%xmm0                   \n"
+      "psraw       $0x8,%%xmm1                   \n"
+      "packsswb    %%xmm1,%%xmm0                 \n"
+      "paddb       %%xmm5,%%xmm0                 \n"
+      "movlps      %%xmm0,(%1)                   \n"
+      "movhps      %%xmm0,0x00(%1,%2,1)          \n"
+      "lea         0x8(%1),%1                    \n"
+      "sub         $0x10,%3                      \n"
+      "jg          1b                            \n"
+      : "+r"(src_bgra),                    // %0
+        "+r"(dst_u),                       // %1
+        "+r"(dst_v),                       // %2
+        "+rm"(width)                       // %3
+      : "r"((intptr_t)(src_stride_bgra)),  // %4
+        "m"(kBGRAToV),                     // %5
+        "m"(kBGRAToU),                     // %6
+        "m"(kAddUV128)                     // %7
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm6", "xmm7");
+}
+
+void ABGRToYRow_SSSE3(const uint8_t* src_abgr, uint8_t* dst_y, int width) {
+  asm volatile(
+      "movdqa      %3,%%xmm4                     \n"
+      "movdqa      %4,%%xmm5                     \n"
+      "movdqa      %5,%%xmm7                     \n"
+
+      LABELALIGN RGBTOY(xmm7)
+      : "+r"(src_abgr),  // %0
+        "+r"(dst_y),     // %1
+        "+r"(width)      // %2
+      : "m"(kABGRToY),   // %3
+        "m"(kSub128),    // %4
+        "m"(kAddY16)     // %5
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6",
+        "xmm7");
+}
+
+void RGBAToYRow_SSSE3(const uint8_t* src_rgba, uint8_t* dst_y, int width) {
+  asm volatile(
+      "movdqa      %3,%%xmm4                     \n"
+      "movdqa      %4,%%xmm5                     \n"
+      "movdqa      %5,%%xmm7                     \n"
+
+      LABELALIGN RGBTOY(xmm7)
+      : "+r"(src_rgba),  // %0
+        "+r"(dst_y),     // %1
+        "+r"(width)      // %2
+      : "m"(kRGBAToY),   // %3
+        "m"(kSub128),    // %4
+        "m"(kAddY16)     // %5
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6",
+        "xmm7");
+}
+
+void ABGRToUVRow_SSSE3(const uint8_t* src_abgr,
+                       int src_stride_abgr,
+                       uint8_t* dst_u,
+                       uint8_t* dst_v,
+                       int width) {
+  asm volatile(
+      "movdqa      %5,%%xmm3                     \n"
+      "movdqa      %6,%%xmm4                     \n"
+      "movdqa      %7,%%xmm5                     \n"
+      "sub         %1,%2                         \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "movdqu      (%0),%%xmm0                   \n"
+      "movdqu      0x00(%0,%4,1),%%xmm7          \n"
+      "pavgb       %%xmm7,%%xmm0                 \n"
+      "movdqu      0x10(%0),%%xmm1               \n"
+      "movdqu      0x10(%0,%4,1),%%xmm7          \n"
+      "pavgb       %%xmm7,%%xmm1                 \n"
+      "movdqu      0x20(%0),%%xmm2               \n"
+      "movdqu      0x20(%0,%4,1),%%xmm7          \n"
+      "pavgb       %%xmm7,%%xmm2                 \n"
+      "movdqu      0x30(%0),%%xmm6               \n"
+      "movdqu      0x30(%0,%4,1),%%xmm7          \n"
+      "pavgb       %%xmm7,%%xmm6                 \n"
+
+      "lea         0x40(%0),%0                   \n"
+      "movdqa      %%xmm0,%%xmm7                 \n"
+      "shufps      $0x88,%%xmm1,%%xmm0           \n"
+      "shufps      $0xdd,%%xmm1,%%xmm7           \n"
+      "pavgb       %%xmm7,%%xmm0                 \n"
+      "movdqa      %%xmm2,%%xmm7                 \n"
+      "shufps      $0x88,%%xmm6,%%xmm2           \n"
+      "shufps      $0xdd,%%xmm6,%%xmm7           \n"
+      "pavgb       %%xmm7,%%xmm2                 \n"
+      "movdqa      %%xmm0,%%xmm1                 \n"
+      "movdqa      %%xmm2,%%xmm6                 \n"
+      "pmaddubsw   %%xmm4,%%xmm0                 \n"
+      "pmaddubsw   %%xmm4,%%xmm2                 \n"
+      "pmaddubsw   %%xmm3,%%xmm1                 \n"
+      "pmaddubsw   %%xmm3,%%xmm6                 \n"
+      "phaddw      %%xmm2,%%xmm0                 \n"
+      "phaddw      %%xmm6,%%xmm1                 \n"
+      "psraw       $0x8,%%xmm0                   \n"
+      "psraw       $0x8,%%xmm1                   \n"
+      "packsswb    %%xmm1,%%xmm0                 \n"
+      "paddb       %%xmm5,%%xmm0                 \n"
+      "movlps      %%xmm0,(%1)                   \n"
+      "movhps      %%xmm0,0x00(%1,%2,1)          \n"
+      "lea         0x8(%1),%1                    \n"
+      "sub         $0x10,%3                      \n"
+      "jg          1b                            \n"
+      : "+r"(src_abgr),                    // %0
+        "+r"(dst_u),                       // %1
+        "+r"(dst_v),                       // %2
+        "+rm"(width)                       // %3
+      : "r"((intptr_t)(src_stride_abgr)),  // %4
+        "m"(kABGRToV),                     // %5
+        "m"(kABGRToU),                     // %6
+        "m"(kAddUV128)                     // %7
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm6", "xmm7");
+}
+
+void RGBAToUVRow_SSSE3(const uint8_t* src_rgba,
+                       int src_stride_rgba,
+                       uint8_t* dst_u,
+                       uint8_t* dst_v,
+                       int width) {
+  asm volatile(
+      "movdqa      %5,%%xmm3                     \n"
+      "movdqa      %6,%%xmm4                     \n"
+      "movdqa      %7,%%xmm5                     \n"
+      "sub         %1,%2                         \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "movdqu      (%0),%%xmm0                   \n"
+      "movdqu      0x00(%0,%4,1),%%xmm7          \n"
+      "pavgb       %%xmm7,%%xmm0                 \n"
+      "movdqu      0x10(%0),%%xmm1               \n"
+      "movdqu      0x10(%0,%4,1),%%xmm7          \n"
+      "pavgb       %%xmm7,%%xmm1                 \n"
+      "movdqu      0x20(%0),%%xmm2               \n"
+      "movdqu      0x20(%0,%4,1),%%xmm7          \n"
+      "pavgb       %%xmm7,%%xmm2                 \n"
+      "movdqu      0x30(%0),%%xmm6               \n"
+      "movdqu      0x30(%0,%4,1),%%xmm7          \n"
+      "pavgb       %%xmm7,%%xmm6                 \n"
+
+      "lea         0x40(%0),%0                   \n"
+      "movdqa      %%xmm0,%%xmm7                 \n"
+      "shufps      $0x88,%%xmm1,%%xmm0           \n"
+      "shufps      $0xdd,%%xmm1,%%xmm7           \n"
+      "pavgb       %%xmm7,%%xmm0                 \n"
+      "movdqa      %%xmm2,%%xmm7                 \n"
+      "shufps      $0x88,%%xmm6,%%xmm2           \n"
+      "shufps      $0xdd,%%xmm6,%%xmm7           \n"
+      "pavgb       %%xmm7,%%xmm2                 \n"
+      "movdqa      %%xmm0,%%xmm1                 \n"
+      "movdqa      %%xmm2,%%xmm6                 \n"
+      "pmaddubsw   %%xmm4,%%xmm0                 \n"
+      "pmaddubsw   %%xmm4,%%xmm2                 \n"
+      "pmaddubsw   %%xmm3,%%xmm1                 \n"
+      "pmaddubsw   %%xmm3,%%xmm6                 \n"
+      "phaddw      %%xmm2,%%xmm0                 \n"
+      "phaddw      %%xmm6,%%xmm1                 \n"
+      "psraw       $0x8,%%xmm0                   \n"
+      "psraw       $0x8,%%xmm1                   \n"
+      "packsswb    %%xmm1,%%xmm0                 \n"
+      "paddb       %%xmm5,%%xmm0                 \n"
+      "movlps      %%xmm0,(%1)                   \n"
+      "movhps      %%xmm0,0x00(%1,%2,1)          \n"
+      "lea         0x8(%1),%1                    \n"
+      "sub         $0x10,%3                      \n"
+      "jg          1b                            \n"
+      : "+r"(src_rgba),                    // %0
+        "+r"(dst_u),                       // %1
+        "+r"(dst_v),                       // %2
+        "+rm"(width)                       // %3
+      : "r"((intptr_t)(src_stride_rgba)),  // %4
+        "m"(kRGBAToV),                     // %5
+        "m"(kRGBAToU),                     // %6
+        "m"(kAddUV128)                     // %7
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm6", "xmm7");
+}
+
+#if defined(HAS_I422TOARGBROW_SSSE3) || defined(HAS_I422TOARGBROW_AVX2)
+
+// Read 8 UV from 444
+#define READYUV444                                                \
+  "movq       (%[u_buf]),%%xmm3                               \n" \
+  "movq       0x00(%[u_buf],%[v_buf],1),%%xmm1                \n" \
+  "lea        0x8(%[u_buf]),%[u_buf]                          \n" \
+  "punpcklbw  %%xmm1,%%xmm3                                   \n" \
+  "movq       (%[y_buf]),%%xmm4                               \n" \
+  "punpcklbw  %%xmm4,%%xmm4                                   \n" \
+  "lea        0x8(%[y_buf]),%[y_buf]                          \n"
+
+// Read 4 UV from 422, upsample to 8 UV
+#define READYUV422                                                \
+  "movd       (%[u_buf]),%%xmm3                               \n" \
+  "movd       0x00(%[u_buf],%[v_buf],1),%%xmm1                \n" \
+  "lea        0x4(%[u_buf]),%[u_buf]                          \n" \
+  "punpcklbw  %%xmm1,%%xmm3                                   \n" \
+  "punpcklwd  %%xmm3,%%xmm3                                   \n" \
+  "movq       (%[y_buf]),%%xmm4                               \n" \
+  "punpcklbw  %%xmm4,%%xmm4                                   \n" \
+  "lea        0x8(%[y_buf]),%[y_buf]                          \n"
+
+// Read 4 UV from 422 10 bit, upsample to 8 UV
+// TODO(fbarchard): Consider shufb to replace pack/unpack
+// TODO(fbarchard): Consider pmulhuw to replace psraw
+// TODO(fbarchard): Consider pmullw to replace psllw and allow different bits.
+#define READYUV210                                                \
+  "movq       (%[u_buf]),%%xmm3                               \n" \
+  "movq       0x00(%[u_buf],%[v_buf],1),%%xmm1                \n" \
+  "lea        0x8(%[u_buf]),%[u_buf]                          \n" \
+  "punpcklwd  %%xmm1,%%xmm3                                   \n" \
+  "psraw      $2,%%xmm3                                       \n" \
+  "packuswb   %%xmm3,%%xmm3                                   \n" \
+  "punpcklwd  %%xmm3,%%xmm3                                   \n" \
+  "movdqu     (%[y_buf]),%%xmm4                               \n" \
+  "psllw      $6,%%xmm4                                       \n" \
+  "lea        0x10(%[y_buf]),%[y_buf]                         \n"
+
+#define READYUVA210                                               \
+  "movq       (%[u_buf]),%%xmm3                               \n" \
+  "movq       0x00(%[u_buf],%[v_buf],1),%%xmm1                \n" \
+  "lea        0x8(%[u_buf]),%[u_buf]                          \n" \
+  "punpcklwd  %%xmm1,%%xmm3                                   \n" \
+  "psraw      $2,%%xmm3                                       \n" \
+  "packuswb   %%xmm3,%%xmm3                                   \n" \
+  "punpcklwd  %%xmm3,%%xmm3                                   \n" \
+  "movdqu     (%[y_buf]),%%xmm4                               \n" \
+  "psllw      $6,%%xmm4                                       \n" \
+  "lea        0x10(%[y_buf]),%[y_buf]                         \n" \
+  "movdqu     (%[a_buf]),%%xmm5                               \n" \
+  "psraw      $2,%%xmm5                                       \n" \
+  "packuswb   %%xmm5,%%xmm5                                   \n" \
+  "lea        0x10(%[a_buf]),%[a_buf]                         \n"
+
+// Read 8 UV from 444 10 bit
+#define READYUV410                                                \
+  "movdqu     (%[u_buf]),%%xmm3                               \n" \
+  "movdqu     0x00(%[u_buf],%[v_buf],1),%%xmm2                \n" \
+  "lea        0x10(%[u_buf]),%[u_buf]                         \n" \
+  "psraw      $2,%%xmm3                                       \n" \
+  "psraw      $2,%%xmm2                                       \n" \
+  "movdqa     %%xmm3,%%xmm1                                   \n" \
+  "punpcklwd  %%xmm2,%%xmm3                                   \n" \
+  "punpckhwd  %%xmm2,%%xmm1                                   \n" \
+  "packuswb   %%xmm1,%%xmm3                                   \n" \
+  "movdqu     (%[y_buf]),%%xmm4                               \n" \
+  "psllw      $6,%%xmm4                                       \n" \
+  "lea        0x10(%[y_buf]),%[y_buf]                         \n"
+
+// Read 8 UV from 444 10 bit.  With 8 Alpha.
+#define READYUVA410                                               \
+  "movdqu     (%[u_buf]),%%xmm3                               \n" \
+  "movdqu     0x00(%[u_buf],%[v_buf],1),%%xmm2                \n" \
+  "lea        0x10(%[u_buf]),%[u_buf]                         \n" \
+  "psraw      $2,%%xmm3                                       \n" \
+  "psraw      $2,%%xmm2                                       \n" \
+  "movdqa     %%xmm3,%%xmm1                                   \n" \
+  "punpcklwd  %%xmm2,%%xmm3                                   \n" \
+  "punpckhwd  %%xmm2,%%xmm1                                   \n" \
+  "packuswb   %%xmm1,%%xmm3                                   \n" \
+  "movdqu     (%[y_buf]),%%xmm4                               \n" \
+  "psllw      $0x6,%%xmm4                                     \n" \
+  "lea        0x10(%[y_buf]),%[y_buf]                         \n" \
+  "movdqu     (%[a_buf]),%%xmm5                               \n" \
+  "psraw      $2,%%xmm5                                       \n" \
+  "packuswb   %%xmm5,%%xmm5                                   \n" \
+  "lea        0x10(%[a_buf]),%[a_buf]                         \n"
+
+// Read 4 UV from 422 12 bit, upsample to 8 UV
+#define READYUV212                                                \
+  "movq       (%[u_buf]),%%xmm3                               \n" \
+  "movq       0x00(%[u_buf],%[v_buf],1),%%xmm1                \n" \
+  "lea        0x8(%[u_buf]),%[u_buf]                          \n" \
+  "punpcklwd  %%xmm1,%%xmm3                                   \n" \
+  "psraw      $0x4,%%xmm3                                     \n" \
+  "packuswb   %%xmm3,%%xmm3                                   \n" \
+  "punpcklwd  %%xmm3,%%xmm3                                   \n" \
+  "movdqu     (%[y_buf]),%%xmm4                               \n" \
+  "psllw      $0x4,%%xmm4                                     \n" \
+  "lea        0x10(%[y_buf]),%[y_buf]                         \n"
+
+// Read 4 UV from 422, upsample to 8 UV.  With 8 Alpha.
+#define READYUVA422                                               \
+  "movd       (%[u_buf]),%%xmm3                               \n" \
+  "movd       0x00(%[u_buf],%[v_buf],1),%%xmm1                \n" \
+  "lea        0x4(%[u_buf]),%[u_buf]                          \n" \
+  "punpcklbw  %%xmm1,%%xmm3                                   \n" \
+  "punpcklwd  %%xmm3,%%xmm3                                   \n" \
+  "movq       (%[y_buf]),%%xmm4                               \n" \
+  "punpcklbw  %%xmm4,%%xmm4                                   \n" \
+  "lea        0x8(%[y_buf]),%[y_buf]                          \n" \
+  "movq       (%[a_buf]),%%xmm5                               \n" \
+  "lea        0x8(%[a_buf]),%[a_buf]                          \n"
+
+// Read 8 UV from 444.  With 8 Alpha.
+#define READYUVA444                                               \
+  "movq       (%[u_buf]),%%xmm3                               \n" \
+  "movq       0x00(%[u_buf],%[v_buf],1),%%xmm1                \n" \
+  "lea        0x8(%[u_buf]),%[u_buf]                          \n" \
+  "punpcklbw  %%xmm1,%%xmm3                                   \n" \
+  "movq       (%[y_buf]),%%xmm4                               \n" \
+  "punpcklbw  %%xmm4,%%xmm4                                   \n" \
+  "lea        0x8(%[y_buf]),%[y_buf]                          \n" \
+  "movq       (%[a_buf]),%%xmm5                               \n" \
+  "lea        0x8(%[a_buf]),%[a_buf]                          \n"
+
+// Read 4 UV from NV12, upsample to 8 UV
+#define READNV12                                                  \
+  "movq       (%[uv_buf]),%%xmm3                              \n" \
+  "lea        0x8(%[uv_buf]),%[uv_buf]                        \n" \
+  "punpcklwd  %%xmm3,%%xmm3                                   \n" \
+  "movq       (%[y_buf]),%%xmm4                               \n" \
+  "punpcklbw  %%xmm4,%%xmm4                                   \n" \
+  "lea        0x8(%[y_buf]),%[y_buf]                          \n"
+
+// Read 4 VU from NV21, upsample to 8 UV
+#define READNV21                                                  \
+  "movq       (%[vu_buf]),%%xmm3                              \n" \
+  "lea        0x8(%[vu_buf]),%[vu_buf]                        \n" \
+  "pshufb     %[kShuffleNV21], %%xmm3                         \n" \
+  "movq       (%[y_buf]),%%xmm4                               \n" \
+  "punpcklbw  %%xmm4,%%xmm4                                   \n" \
+  "lea        0x8(%[y_buf]),%[y_buf]                          \n"
+
+// Read 4 YUY2 with 8 Y and update 4 UV to 8 UV.
+#define READYUY2                                                  \
+  "movdqu     (%[yuy2_buf]),%%xmm4                            \n" \
+  "pshufb     %[kShuffleYUY2Y], %%xmm4                        \n" \
+  "movdqu     (%[yuy2_buf]),%%xmm3                            \n" \
+  "pshufb     %[kShuffleYUY2UV], %%xmm3                       \n" \
+  "lea        0x10(%[yuy2_buf]),%[yuy2_buf]                   \n"
+
+// Read 4 UYVY with 8 Y and update 4 UV to 8 UV.
+#define READUYVY                                                  \
+  "movdqu     (%[uyvy_buf]),%%xmm4                            \n" \
+  "pshufb     %[kShuffleUYVYY], %%xmm4                        \n" \
+  "movdqu     (%[uyvy_buf]),%%xmm3                            \n" \
+  "pshufb     %[kShuffleUYVYUV], %%xmm3                       \n" \
+  "lea        0x10(%[uyvy_buf]),%[uyvy_buf]                   \n"
+
+// Read 4 UV from P210, upsample to 8 UV
+#define READP210                                                  \
+  "movdqu     (%[uv_buf]),%%xmm3                              \n" \
+  "lea        0x10(%[uv_buf]),%[uv_buf]                       \n" \
+  "psrlw      $0x8,%%xmm3                                     \n" \
+  "packuswb   %%xmm3,%%xmm3                                   \n" \
+  "punpcklwd  %%xmm3,%%xmm3                                   \n" \
+  "movdqu     (%[y_buf]),%%xmm4                               \n" \
+  "lea        0x10(%[y_buf]),%[y_buf]                         \n"
+
+// Read 8 UV from P410
+#define READP410                                                  \
+  "movdqu     (%[uv_buf]),%%xmm3                              \n" \
+  "movdqu     0x10(%[uv_buf]),%%xmm1                          \n" \
+  "lea        0x20(%[uv_buf]),%[uv_buf]                       \n" \
+  "psrlw      $0x8,%%xmm3                                     \n" \
+  "psrlw      $0x8,%%xmm1                                     \n" \
+  "packuswb   %%xmm1,%%xmm3                                   \n" \
+  "movdqu     (%[y_buf]),%%xmm4                               \n" \
+  "lea        0x10(%[y_buf]),%[y_buf]                         \n"
+
+#if defined(__x86_64__)
+#define YUVTORGB_SETUP(yuvconstants)                              \
+  "pcmpeqb    %%xmm13,%%xmm13                                 \n" \
+  "movdqa     (%[yuvconstants]),%%xmm8                        \n" \
+  "pxor       %%xmm12,%%xmm12                                 \n" \
+  "movdqa     32(%[yuvconstants]),%%xmm9                      \n" \
+  "psllw      $7,%%xmm13                                      \n" \
+  "movdqa     64(%[yuvconstants]),%%xmm10                     \n" \
+  "pshufb     %%xmm12,%%xmm13                                 \n" \
+  "movdqa     96(%[yuvconstants]),%%xmm11                     \n" \
+  "movdqa     128(%[yuvconstants]),%%xmm12                    \n"
+
+// Convert 8 pixels: 8 UV and 8 Y
+#define YUVTORGB16(yuvconstants)                                  \
+  "psubb      %%xmm13,%%xmm3                                  \n" \
+  "pmulhuw    %%xmm11,%%xmm4                                  \n" \
+  "movdqa     %%xmm8,%%xmm0                                   \n" \
+  "movdqa     %%xmm9,%%xmm1                                   \n" \
+  "movdqa     %%xmm10,%%xmm2                                  \n" \
+  "paddw      %%xmm12,%%xmm4                                  \n" \
+  "pmaddubsw  %%xmm3,%%xmm0                                   \n" \
+  "pmaddubsw  %%xmm3,%%xmm1                                   \n" \
+  "pmaddubsw  %%xmm3,%%xmm2                                   \n" \
+  "paddsw     %%xmm4,%%xmm0                                   \n" \
+  "paddsw     %%xmm4,%%xmm2                                   \n" \
+  "psubsw     %%xmm1,%%xmm4                                   \n" \
+  "movdqa     %%xmm4,%%xmm1                                   \n"
+
+#define YUVTORGB_REGS "xmm8", "xmm9", "xmm10", "xmm11", "xmm12", "xmm13",
+
+#else
+#define YUVTORGB_SETUP(yuvconstants)
+// Convert 8 pixels: 8 UV and 8 Y
+#define YUVTORGB16(yuvconstants)                                  \
+  "pcmpeqb    %%xmm0,%%xmm0                                   \n" \
+  "pxor       %%xmm1,%%xmm1                                   \n" \
+  "psllw      $7,%%xmm0                                       \n" \
+  "pshufb     %%xmm1,%%xmm0                                   \n" \
+  "psubb      %%xmm0,%%xmm3                                   \n" \
+  "pmulhuw    96(%[yuvconstants]),%%xmm4                      \n" \
+  "movdqa     (%[yuvconstants]),%%xmm0                        \n" \
+  "movdqa     32(%[yuvconstants]),%%xmm1                      \n" \
+  "movdqa     64(%[yuvconstants]),%%xmm2                      \n" \
+  "pmaddubsw  %%xmm3,%%xmm0                                   \n" \
+  "pmaddubsw  %%xmm3,%%xmm1                                   \n" \
+  "pmaddubsw  %%xmm3,%%xmm2                                   \n" \
+  "movdqa     128(%[yuvconstants]),%%xmm3                     \n" \
+  "paddw      %%xmm3,%%xmm4                                   \n" \
+  "paddsw     %%xmm4,%%xmm0                                   \n" \
+  "paddsw     %%xmm4,%%xmm2                                   \n" \
+  "psubsw     %%xmm1,%%xmm4                                   \n" \
+  "movdqa     %%xmm4,%%xmm1                                   \n"
+
+#define YUVTORGB_REGS
+#endif
+
+#define YUVTORGB(yuvconstants)                                    \
+  YUVTORGB16(yuvconstants)                                        \
+  "psraw      $0x6,%%xmm0                                     \n" \
+  "psraw      $0x6,%%xmm1                                     \n" \
+  "psraw      $0x6,%%xmm2                                     \n" \
+  "packuswb   %%xmm0,%%xmm0                                   \n" \
+  "packuswb   %%xmm1,%%xmm1                                   \n" \
+  "packuswb   %%xmm2,%%xmm2                                   \n"
+
+// Store 8 ARGB values.
+#define STOREARGB                                                  \
+  "punpcklbw  %%xmm1,%%xmm0                                    \n" \
+  "punpcklbw  %%xmm5,%%xmm2                                    \n" \
+  "movdqa     %%xmm0,%%xmm1                                    \n" \
+  "punpcklwd  %%xmm2,%%xmm0                                    \n" \
+  "punpckhwd  %%xmm2,%%xmm1                                    \n" \
+  "movdqu     %%xmm0,(%[dst_argb])                             \n" \
+  "movdqu     %%xmm1,0x10(%[dst_argb])                         \n" \
+  "lea        0x20(%[dst_argb]), %[dst_argb]                   \n"
+
+// Store 8 RGBA values.
+#define STORERGBA                                                  \
+  "pcmpeqb   %%xmm5,%%xmm5                                     \n" \
+  "punpcklbw %%xmm2,%%xmm1                                     \n" \
+  "punpcklbw %%xmm0,%%xmm5                                     \n" \
+  "movdqa    %%xmm5,%%xmm0                                     \n" \
+  "punpcklwd %%xmm1,%%xmm5                                     \n" \
+  "punpckhwd %%xmm1,%%xmm0                                     \n" \
+  "movdqu    %%xmm5,(%[dst_rgba])                              \n" \
+  "movdqu    %%xmm0,0x10(%[dst_rgba])                          \n" \
+  "lea       0x20(%[dst_rgba]),%[dst_rgba]                     \n"
+
+// Store 8 AR30 values.
+#define STOREAR30                                                  \
+  "psraw      $0x4,%%xmm0                                      \n" \
+  "psraw      $0x4,%%xmm1                                      \n" \
+  "psraw      $0x4,%%xmm2                                      \n" \
+  "pminsw     %%xmm7,%%xmm0                                    \n" \
+  "pminsw     %%xmm7,%%xmm1                                    \n" \
+  "pminsw     %%xmm7,%%xmm2                                    \n" \
+  "pmaxsw     %%xmm6,%%xmm0                                    \n" \
+  "pmaxsw     %%xmm6,%%xmm1                                    \n" \
+  "pmaxsw     %%xmm6,%%xmm2                                    \n" \
+  "psllw      $0x4,%%xmm2                                      \n" \
+  "movdqa     %%xmm0,%%xmm3                                    \n" \
+  "punpcklwd  %%xmm2,%%xmm0                                    \n" \
+  "punpckhwd  %%xmm2,%%xmm3                                    \n" \
+  "movdqa     %%xmm1,%%xmm2                                    \n" \
+  "punpcklwd  %%xmm5,%%xmm1                                    \n" \
+  "punpckhwd  %%xmm5,%%xmm2                                    \n" \
+  "pslld      $0xa,%%xmm1                                      \n" \
+  "pslld      $0xa,%%xmm2                                      \n" \
+  "por        %%xmm1,%%xmm0                                    \n" \
+  "por        %%xmm2,%%xmm3                                    \n" \
+  "movdqu     %%xmm0,(%[dst_ar30])                             \n" \
+  "movdqu     %%xmm3,0x10(%[dst_ar30])                         \n" \
+  "lea        0x20(%[dst_ar30]), %[dst_ar30]                   \n"
+
+void OMITFP I444ToARGBRow_SSSE3(const uint8_t* y_buf,
+                                const uint8_t* u_buf,
+                                const uint8_t* v_buf,
+                                uint8_t* dst_argb,
+                                const struct YuvConstants* yuvconstants,
+                                int width) {
+  asm volatile (
+    YUVTORGB_SETUP(yuvconstants)
+      "sub         %[u_buf],%[v_buf]             \n"
+      "pcmpeqb     %%xmm5,%%xmm5                 \n"
+
+    LABELALIGN
+      "1:                                        \n"
+    READYUV444
+    YUVTORGB(yuvconstants)
+    STOREARGB
+      "sub         $0x8,%[width]                 \n"
+      "jg          1b                            \n"
+  : [y_buf]"+r"(y_buf),    // %[y_buf]
+    [u_buf]"+r"(u_buf),    // %[u_buf]
+    [v_buf]"+r"(v_buf),    // %[v_buf]
+    [dst_argb]"+r"(dst_argb),  // %[dst_argb]
+    [width]"+rm"(width)    // %[width]
+  : [yuvconstants]"r"(yuvconstants)  // %[yuvconstants]
+  : "memory", "cc", YUVTORGB_REGS
+    "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5"
+  );
+}
+
+#ifdef HAS_I444ALPHATOARGBROW_SSSE3
+void OMITFP I444AlphaToARGBRow_SSSE3(const uint8_t* y_buf,
+                                     const uint8_t* u_buf,
+                                     const uint8_t* v_buf,
+                                     const uint8_t* a_buf,
+                                     uint8_t* dst_argb,
+                                     const struct YuvConstants* yuvconstants,
+                                     int width) {
+  // clang-format off
+  asm volatile (
+  YUVTORGB_SETUP(yuvconstants)
+      "sub         %[u_buf],%[v_buf]             \n"
+
+  LABELALIGN
+      "1:                                        \n"
+  READYUVA444
+  YUVTORGB(yuvconstants)
+  STOREARGB
+      "subl        $0x8,%[width]                 \n"
+      "jg          1b                            \n"
+  : [y_buf]"+r"(y_buf),    // %[y_buf]
+    [u_buf]"+r"(u_buf),    // %[u_buf]
+    [v_buf]"+r"(v_buf),    // %[v_buf]
+    [a_buf]"+r"(a_buf),    // %[a_buf]
+    [dst_argb]"+r"(dst_argb),  // %[dst_argb]
+#if defined(__i386__)
+    [width]"+m"(width)     // %[width]
+#else
+    [width]"+rm"(width)    // %[width]
+#endif
+  : [yuvconstants]"r"(yuvconstants)  // %[yuvconstants]
+  : "memory", "cc", YUVTORGB_REGS
+      "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5"
+  );
+  // clang-format on
+}
+#endif  // HAS_I444ALPHATOARGBROW_SSSE3
+
+void OMITFP I422ToRGB24Row_SSSE3(const uint8_t* y_buf,
+                                 const uint8_t* u_buf,
+                                 const uint8_t* v_buf,
+                                 uint8_t* dst_rgb24,
+                                 const struct YuvConstants* yuvconstants,
+                                 int width) {
+  asm volatile (
+    YUVTORGB_SETUP(yuvconstants)
+      "movdqa      %[kShuffleMaskARGBToRGB24_0],%%xmm5 \n"
+      "movdqa      %[kShuffleMaskARGBToRGB24],%%xmm6 \n"
+      "sub         %[u_buf],%[v_buf]             \n"
+
+    LABELALIGN
+      "1:                                        \n"
+    READYUV422
+    YUVTORGB(yuvconstants)
+      "punpcklbw   %%xmm1,%%xmm0                 \n"
+      "punpcklbw   %%xmm2,%%xmm2                 \n"
+      "movdqa      %%xmm0,%%xmm1                 \n"
+      "punpcklwd   %%xmm2,%%xmm0                 \n"
+      "punpckhwd   %%xmm2,%%xmm1                 \n"
+      "pshufb      %%xmm5,%%xmm0                 \n"
+      "pshufb      %%xmm6,%%xmm1                 \n"
+      "palignr     $0xc,%%xmm0,%%xmm1            \n"
+      "movq        %%xmm0,(%[dst_rgb24])         \n"
+      "movdqu      %%xmm1,0x8(%[dst_rgb24])      \n"
+      "lea         0x18(%[dst_rgb24]),%[dst_rgb24] \n"
+      "subl        $0x8,%[width]                 \n"
+      "jg          1b                            \n"
+  : [y_buf]"+r"(y_buf),    // %[y_buf]
+    [u_buf]"+r"(u_buf),    // %[u_buf]
+    [v_buf]"+r"(v_buf),    // %[v_buf]
+    [dst_rgb24]"+r"(dst_rgb24),  // %[dst_rgb24]
+#if defined(__i386__)
+    [width]"+m"(width)     // %[width]
+#else
+    [width]"+rm"(width)    // %[width]
+#endif
+  : [yuvconstants]"r"(yuvconstants),  // %[yuvconstants]
+    [kShuffleMaskARGBToRGB24_0]"m"(kShuffleMaskARGBToRGB24_0),
+    [kShuffleMaskARGBToRGB24]"m"(kShuffleMaskARGBToRGB24)
+  : "memory", "cc", YUVTORGB_REGS
+    "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6"
+  );
+}
+
+void OMITFP I422ToARGBRow_SSSE3(const uint8_t* y_buf,
+                                const uint8_t* u_buf,
+                                const uint8_t* v_buf,
+                                uint8_t* dst_argb,
+                                const struct YuvConstants* yuvconstants,
+                                int width) {
+  asm volatile (
+    YUVTORGB_SETUP(yuvconstants)
+      "sub         %[u_buf],%[v_buf]             \n"
+      "pcmpeqb     %%xmm5,%%xmm5                 \n"
+
+    LABELALIGN
+      "1:                                        \n"
+    READYUV422
+    YUVTORGB(yuvconstants)
+    STOREARGB
+      "sub         $0x8,%[width]                 \n"
+      "jg          1b                            \n"
+  : [y_buf]"+r"(y_buf),    // %[y_buf]
+    [u_buf]"+r"(u_buf),    // %[u_buf]
+    [v_buf]"+r"(v_buf),    // %[v_buf]
+    [dst_argb]"+r"(dst_argb),  // %[dst_argb]
+    [width]"+rm"(width)    // %[width]
+  : [yuvconstants]"r"(yuvconstants)  // %[yuvconstants]
+  : "memory", "cc", YUVTORGB_REGS
+    "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5"
+  );
+}
+
+void OMITFP I422ToAR30Row_SSSE3(const uint8_t* y_buf,
+                                const uint8_t* u_buf,
+                                const uint8_t* v_buf,
+                                uint8_t* dst_ar30,
+                                const struct YuvConstants* yuvconstants,
+                                int width) {
+  asm volatile (
+    YUVTORGB_SETUP(yuvconstants)
+      "sub         %[u_buf],%[v_buf]             \n"
+      "pcmpeqb     %%xmm5,%%xmm5                 \n"  // AR30 constants
+      "psrlw       $14,%%xmm5                    \n"
+      "psllw       $4,%%xmm5                     \n"  // 2 alpha bits
+      "pxor        %%xmm6,%%xmm6                 \n"  // 0 for min
+      "pcmpeqb     %%xmm7,%%xmm7                 \n"
+      "psrlw       $6,%%xmm7                     \n"  // 1023 for max
+
+    LABELALIGN
+      "1:                                        \n"
+    READYUV422
+    YUVTORGB16(yuvconstants)
+    STOREAR30
+      "sub         $0x8,%[width]                 \n"
+      "jg          1b                            \n"
+  : [y_buf]"+r"(y_buf),    // %[y_buf]
+    [u_buf]"+r"(u_buf),    // %[u_buf]
+    [v_buf]"+r"(v_buf),    // %[v_buf]
+    [dst_ar30]"+r"(dst_ar30),  // %[dst_ar30]
+    [width]"+rm"(width)    // %[width]
+  : [yuvconstants]"r"(yuvconstants)  // %[yuvconstants]
+  : "memory", "cc", YUVTORGB_REGS
+    "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7"
+  );
+}
+
+// 10 bit YUV to ARGB
+void OMITFP I210ToARGBRow_SSSE3(const uint16_t* y_buf,
+                                const uint16_t* u_buf,
+                                const uint16_t* v_buf,
+                                uint8_t* dst_argb,
+                                const struct YuvConstants* yuvconstants,
+                                int width) {
+  asm volatile (
+    YUVTORGB_SETUP(yuvconstants)
+      "sub         %[u_buf],%[v_buf]             \n"
+      "pcmpeqb     %%xmm5,%%xmm5                 \n"
+
+    LABELALIGN
+      "1:                                        \n"
+    READYUV210
+    YUVTORGB(yuvconstants)
+    STOREARGB
+      "sub         $0x8,%[width]                 \n"
+      "jg          1b                            \n"
+  : [y_buf]"+r"(y_buf),    // %[y_buf]
+    [u_buf]"+r"(u_buf),    // %[u_buf]
+    [v_buf]"+r"(v_buf),    // %[v_buf]
+    [dst_argb]"+r"(dst_argb),  // %[dst_argb]
+    [width]"+rm"(width)    // %[width]
+  : [yuvconstants]"r"(yuvconstants)  // %[yuvconstants]
+  : "memory", "cc", YUVTORGB_REGS
+    "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5"
+  );
+}
+
+// 12 bit YUV to ARGB
+void OMITFP I212ToARGBRow_SSSE3(const uint16_t* y_buf,
+                                const uint16_t* u_buf,
+                                const uint16_t* v_buf,
+                                uint8_t* dst_argb,
+                                const struct YuvConstants* yuvconstants,
+                                int width) {
+  asm volatile (
+    YUVTORGB_SETUP(yuvconstants)
+      "sub         %[u_buf],%[v_buf]             \n"
+      "pcmpeqb     %%xmm5,%%xmm5                 \n"
+
+    LABELALIGN
+      "1:                                        \n"
+    READYUV212
+    YUVTORGB(yuvconstants)
+    STOREARGB
+      "sub         $0x8,%[width]                 \n"
+      "jg          1b                            \n"
+  : [y_buf]"+r"(y_buf),    // %[y_buf]
+    [u_buf]"+r"(u_buf),    // %[u_buf]
+    [v_buf]"+r"(v_buf),    // %[v_buf]
+    [dst_argb]"+r"(dst_argb),  // %[dst_argb]
+    [width]"+rm"(width)    // %[width]
+  : [yuvconstants]"r"(yuvconstants)  // %[yuvconstants]
+  : "memory", "cc", YUVTORGB_REGS
+    "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5"
+  );
+}
+
+// 10 bit YUV to AR30
+void OMITFP I210ToAR30Row_SSSE3(const uint16_t* y_buf,
+                                const uint16_t* u_buf,
+                                const uint16_t* v_buf,
+                                uint8_t* dst_ar30,
+                                const struct YuvConstants* yuvconstants,
+                                int width) {
+  asm volatile (
+    YUVTORGB_SETUP(yuvconstants)
+      "sub         %[u_buf],%[v_buf]             \n"
+      "pcmpeqb     %%xmm5,%%xmm5                 \n"
+      "psrlw       $14,%%xmm5                    \n"
+      "psllw       $4,%%xmm5                     \n"  // 2 alpha bits
+      "pxor        %%xmm6,%%xmm6                 \n"  // 0 for min
+      "pcmpeqb     %%xmm7,%%xmm7                 \n"
+      "psrlw       $6,%%xmm7                     \n"  // 1023 for max
+
+    LABELALIGN
+      "1:                                        \n"
+    READYUV210
+    YUVTORGB16(yuvconstants)
+    STOREAR30
+      "sub         $0x8,%[width]                 \n"
+      "jg          1b                            \n"
+  : [y_buf]"+r"(y_buf),    // %[y_buf]
+    [u_buf]"+r"(u_buf),    // %[u_buf]
+    [v_buf]"+r"(v_buf),    // %[v_buf]
+    [dst_ar30]"+r"(dst_ar30),  // %[dst_ar30]
+    [width]"+rm"(width)    // %[width]
+  : [yuvconstants]"r"(yuvconstants)  // %[yuvconstants]
+  : "memory", "cc", YUVTORGB_REGS
+    "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7"
+  );
+}
+
+// 12 bit YUV to AR30
+void OMITFP I212ToAR30Row_SSSE3(const uint16_t* y_buf,
+                                const uint16_t* u_buf,
+                                const uint16_t* v_buf,
+                                uint8_t* dst_ar30,
+                                const struct YuvConstants* yuvconstants,
+                                int width) {
+  asm volatile (
+    YUVTORGB_SETUP(yuvconstants)
+      "sub         %[u_buf],%[v_buf]             \n"
+      "pcmpeqb     %%xmm5,%%xmm5                 \n"
+      "psrlw       $14,%%xmm5                    \n"
+      "psllw       $4,%%xmm5                     \n"  // 2 alpha bits
+      "pxor        %%xmm6,%%xmm6                 \n"  // 0 for min
+      "pcmpeqb     %%xmm7,%%xmm7                 \n"
+      "psrlw       $6,%%xmm7                     \n"  // 1023 for max
+
+    LABELALIGN
+      "1:                                        \n"
+    READYUV212
+    YUVTORGB16(yuvconstants)
+    STOREAR30
+      "sub         $0x8,%[width]                 \n"
+      "jg          1b                            \n"
+  : [y_buf]"+r"(y_buf),    // %[y_buf]
+    [u_buf]"+r"(u_buf),    // %[u_buf]
+    [v_buf]"+r"(v_buf),    // %[v_buf]
+    [dst_ar30]"+r"(dst_ar30),  // %[dst_ar30]
+    [width]"+rm"(width)    // %[width]
+  : [yuvconstants]"r"(yuvconstants)  // %[yuvconstants]
+  : "memory", "cc", YUVTORGB_REGS
+    "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7"
+  );
+}
+
+// 10 bit YUV to ARGB
+void OMITFP I410ToARGBRow_SSSE3(const uint16_t* y_buf,
+                                const uint16_t* u_buf,
+                                const uint16_t* v_buf,
+                                uint8_t* dst_argb,
+                                const struct YuvConstants* yuvconstants,
+                                int width) {
+  asm volatile (
+    YUVTORGB_SETUP(yuvconstants)
+      "sub         %[u_buf],%[v_buf]             \n"
+      "pcmpeqb     %%xmm5,%%xmm5                 \n"
+
+    LABELALIGN
+      "1:                                        \n"
+    READYUV410
+    YUVTORGB(yuvconstants)
+    STOREARGB
+      "sub         $0x8,%[width]                 \n"
+      "jg          1b                            \n"
+  : [y_buf]"+r"(y_buf),    // %[y_buf]
+    [u_buf]"+r"(u_buf),    // %[u_buf]
+    [v_buf]"+r"(v_buf),    // %[v_buf]
+    [dst_argb]"+r"(dst_argb),  // %[dst_argb]
+    [width]"+rm"(width)    // %[width]
+  : [yuvconstants]"r"(yuvconstants)  // %[yuvconstants]
+  : "memory", "cc", YUVTORGB_REGS "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5"
+  );
+}
+
+#ifdef HAS_I210ALPHATOARGBROW_SSSE3
+// 10 bit YUVA to ARGB
+void OMITFP I210AlphaToARGBRow_SSSE3(const uint16_t* y_buf,
+                                     const uint16_t* u_buf,
+                                     const uint16_t* v_buf,
+                                     const uint16_t* a_buf,
+                                     uint8_t* dst_argb,
+                                     const struct YuvConstants* yuvconstants,
+                                     int width) {
+  asm volatile(
+      YUVTORGB_SETUP(
+      yuvconstants) "sub         %[u_buf],%[v_buf]             \n"
+
+      LABELALIGN "1:                                        \n" READYUVA210
+          YUVTORGB(yuvconstants) STOREARGB
+      "subl        $0x8,%[width]                 \n"
+      "jg          1b                            \n"
+      : [y_buf] "+r"(y_buf),  // %[y_buf]
+        [u_buf] "+r"(u_buf),  // %[u_buf]
+        [v_buf] "+r"(v_buf),  // %[v_buf]
+        [a_buf] "+r"(a_buf),
+        [dst_argb] "+r"(dst_argb),  // %[dst_argb]
+#if defined(__i386__)
+        [width] "+m"(width)  // %[width]
+#else
+        [width] "+rm"(width)  // %[width]
+#endif
+      : [yuvconstants] "r"(yuvconstants)  // %[yuvconstants]
+      : "memory", "cc", YUVTORGB_REGS "xmm0", "xmm1", "xmm2", "xmm3", "xmm4",
+        "xmm5");
+}
+#endif
+
+#ifdef HAS_I410ALPHATOARGBROW_SSSE3
+// 10 bit YUVA to ARGB
+void OMITFP I410AlphaToARGBRow_SSSE3(const uint16_t* y_buf,
+                                     const uint16_t* u_buf,
+                                     const uint16_t* v_buf,
+                                     const uint16_t* a_buf,
+                                     uint8_t* dst_argb,
+                                     const struct YuvConstants* yuvconstants,
+                                     int width) {
+  // clang-format off
+  asm volatile(
+    YUVTORGB_SETUP(yuvconstants)
+      "sub         %[u_buf],%[v_buf]             \n"
+
+    LABELALIGN
+      "1:                                        \n"
+    READYUVA410
+    YUVTORGB(yuvconstants)
+    STOREARGB
+      "subl        $0x8,%[width]                 \n"
+      "jg          1b                            \n"
+    : [y_buf] "+r"(y_buf),  // %[y_buf]
+      [u_buf] "+r"(u_buf),  // %[u_buf]
+      [v_buf] "+r"(v_buf),  // %[v_buf]
+      [a_buf] "+r"(a_buf),
+      [dst_argb] "+r"(dst_argb),  // %[dst_argb]
+#if defined(__i386__)
+      [width] "+m"(width)  // %[width]
+#else
+      [width] "+rm"(width)  // %[width]
+#endif
+    : [yuvconstants] "r"(yuvconstants)  // %[yuvconstants]
+    : "memory", "cc", YUVTORGB_REGS "xmm0", "xmm1", "xmm2", "xmm3", "xmm4",
+      "xmm5");
+  // clang-format on
+}
+#endif
+
+// 10 bit YUV to AR30
+void OMITFP I410ToAR30Row_SSSE3(const uint16_t* y_buf,
+                                const uint16_t* u_buf,
+                                const uint16_t* v_buf,
+                                uint8_t* dst_ar30,
+                                const struct YuvConstants* yuvconstants,
+                                int width) {
+  asm volatile (
+    YUVTORGB_SETUP(yuvconstants)
+      "sub         %[u_buf],%[v_buf]             \n"
+      "pcmpeqb     %%xmm5,%%xmm5                 \n"
+      "psrlw       $14,%%xmm5                    \n"
+      "psllw       $4,%%xmm5                     \n"  // 2 alpha bits
+      "pxor        %%xmm6,%%xmm6                 \n"  // 0 for min
+      "pcmpeqb     %%xmm7,%%xmm7                 \n"
+      "psrlw       $6,%%xmm7                     \n"  // 1023 for max
+
+    LABELALIGN
+      "1:                                        \n"
+    READYUV410
+    YUVTORGB16(yuvconstants)
+    STOREAR30
+      "sub         $0x8,%[width]                 \n"
+      "jg          1b                            \n"
+  : [y_buf]"+r"(y_buf),    // %[y_buf]
+    [u_buf]"+r"(u_buf),    // %[u_buf]
+    [v_buf]"+r"(v_buf),    // %[v_buf]
+    [dst_ar30]"+r"(dst_ar30),  // %[dst_ar30]
+    [width]"+rm"(width)    // %[width]
+  : [yuvconstants]"r"(yuvconstants)   // %[yuvconstants]
+  : "memory", "cc", YUVTORGB_REGS
+      "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7"
+  );
+}
+
+#ifdef HAS_I422ALPHATOARGBROW_SSSE3
+void OMITFP I422AlphaToARGBRow_SSSE3(const uint8_t* y_buf,
+                                     const uint8_t* u_buf,
+                                     const uint8_t* v_buf,
+                                     const uint8_t* a_buf,
+                                     uint8_t* dst_argb,
+                                     const struct YuvConstants* yuvconstants,
+                                     int width) {
+  // clang-format off
+  asm volatile (
+    YUVTORGB_SETUP(yuvconstants)
+      "sub         %[u_buf],%[v_buf]             \n"
+
+    LABELALIGN
+      "1:                                        \n"
+    READYUVA422
+    YUVTORGB(yuvconstants)
+    STOREARGB
+      "subl        $0x8,%[width]                 \n"
+      "jg          1b                            \n"
+  : [y_buf]"+r"(y_buf),    // %[y_buf]
+    [u_buf]"+r"(u_buf),    // %[u_buf]
+    [v_buf]"+r"(v_buf),    // %[v_buf]
+    [a_buf]"+r"(a_buf),    // %[a_buf]
+    [dst_argb]"+r"(dst_argb),  // %[dst_argb]
+#if defined(__i386__)
+    [width]"+m"(width)     // %[width]
+#else
+    [width]"+rm"(width)    // %[width]
+#endif
+  : [yuvconstants]"r"(yuvconstants)  // %[yuvconstants]
+  : "memory", "cc", YUVTORGB_REGS
+    "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5"
+  );
+  // clang-format on
+}
+#endif  // HAS_I422ALPHATOARGBROW_SSSE3
+
+void OMITFP NV12ToARGBRow_SSSE3(const uint8_t* y_buf,
+                                const uint8_t* uv_buf,
+                                uint8_t* dst_argb,
+                                const struct YuvConstants* yuvconstants,
+                                int width) {
+  // clang-format off
+  asm volatile (
+    YUVTORGB_SETUP(yuvconstants)
+      "pcmpeqb     %%xmm5,%%xmm5                 \n"
+
+    LABELALIGN
+      "1:                                        \n"
+    READNV12
+    YUVTORGB(yuvconstants)
+    STOREARGB
+      "sub         $0x8,%[width]                 \n"
+      "jg          1b                            \n"
+  : [y_buf]"+r"(y_buf),    // %[y_buf]
+    [uv_buf]"+r"(uv_buf),    // %[uv_buf]
+    [dst_argb]"+r"(dst_argb),  // %[dst_argb]
+    [width]"+rm"(width)    // %[width]
+  : [yuvconstants]"r"(yuvconstants)  // %[yuvconstants]
+    : "memory", "cc", YUVTORGB_REGS
+      "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5"
+  );
+  // clang-format on
+}
+
+void OMITFP NV21ToARGBRow_SSSE3(const uint8_t* y_buf,
+                                const uint8_t* vu_buf,
+                                uint8_t* dst_argb,
+                                const struct YuvConstants* yuvconstants,
+                                int width) {
+  // clang-format off
+  asm volatile (
+    YUVTORGB_SETUP(yuvconstants)
+      "pcmpeqb     %%xmm5,%%xmm5                 \n"
+
+    LABELALIGN
+      "1:                                        \n"
+    READNV21
+    YUVTORGB(yuvconstants)
+    STOREARGB
+      "sub         $0x8,%[width]                 \n"
+      "jg          1b                            \n"
+  : [y_buf]"+r"(y_buf),    // %[y_buf]
+    [vu_buf]"+r"(vu_buf),    // %[vu_buf]
+    [dst_argb]"+r"(dst_argb),  // %[dst_argb]
+    [width]"+rm"(width)    // %[width]
+  : [yuvconstants]"r"(yuvconstants), // %[yuvconstants]
+    [kShuffleNV21]"m"(kShuffleNV21)
+    : "memory", "cc", YUVTORGB_REGS
+      "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5"
+  );
+  // clang-format on
+}
+
+void OMITFP YUY2ToARGBRow_SSSE3(const uint8_t* yuy2_buf,
+                                uint8_t* dst_argb,
+                                const struct YuvConstants* yuvconstants,
+                                int width) {
+  // clang-format off
+  asm volatile (
+    YUVTORGB_SETUP(yuvconstants)
+      "pcmpeqb     %%xmm5,%%xmm5                 \n"
+
+    LABELALIGN
+      "1:                                        \n"
+    READYUY2
+    YUVTORGB(yuvconstants)
+    STOREARGB
+      "sub         $0x8,%[width]                 \n"
+      "jg          1b                            \n"
+  : [yuy2_buf]"+r"(yuy2_buf),    // %[yuy2_buf]
+    [dst_argb]"+r"(dst_argb),  // %[dst_argb]
+    [width]"+rm"(width)    // %[width]
+  : [yuvconstants]"r"(yuvconstants), // %[yuvconstants]
+    [kShuffleYUY2Y]"m"(kShuffleYUY2Y),
+    [kShuffleYUY2UV]"m"(kShuffleYUY2UV)
+    : "memory", "cc", YUVTORGB_REGS
+      "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5"
+  );
+  // clang-format on
+}
+
+void OMITFP UYVYToARGBRow_SSSE3(const uint8_t* uyvy_buf,
+                                uint8_t* dst_argb,
+                                const struct YuvConstants* yuvconstants,
+                                int width) {
+  // clang-format off
+  asm volatile (
+    YUVTORGB_SETUP(yuvconstants)
+      "pcmpeqb     %%xmm5,%%xmm5                 \n"
+
+    LABELALIGN
+      "1:                                        \n"
+    READUYVY
+    YUVTORGB(yuvconstants)
+    STOREARGB
+      "sub         $0x8,%[width]                 \n"
+      "jg          1b                            \n"
+  : [uyvy_buf]"+r"(uyvy_buf),    // %[uyvy_buf]
+    [dst_argb]"+r"(dst_argb),  // %[dst_argb]
+    [width]"+rm"(width)    // %[width]
+  : [yuvconstants]"r"(yuvconstants), // %[yuvconstants]
+    [kShuffleUYVYY]"m"(kShuffleUYVYY),
+    [kShuffleUYVYUV]"m"(kShuffleUYVYUV)
+    : "memory", "cc", YUVTORGB_REGS
+      "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5"
+  );
+  // clang-format on
+}
+
+void OMITFP P210ToARGBRow_SSSE3(const uint16_t* y_buf,
+                                const uint16_t* uv_buf,
+                                uint8_t* dst_argb,
+                                const struct YuvConstants* yuvconstants,
+                                int width) {
+  asm volatile(
+      YUVTORGB_SETUP(
+      yuvconstants) "pcmpeqb     %%xmm5,%%xmm5                 \n"
+
+      LABELALIGN "1:                                        \n" READP210
+          YUVTORGB(yuvconstants) STOREARGB
+      "sub         $0x8,%[width]                 \n"
+      "jg          1b                            \n"
+      : [y_buf] "+r"(y_buf),              // %[y_buf]
+        [uv_buf] "+r"(uv_buf),            // %[u_buf]
+        [dst_argb] "+r"(dst_argb),        // %[dst_argb]
+        [width] "+rm"(width)              // %[width]
+      : [yuvconstants] "r"(yuvconstants)  // %[yuvconstants]
+      : "memory", "cc", YUVTORGB_REGS "xmm0", "xmm1", "xmm2", "xmm3", "xmm4",
+        "xmm5");
+}
+
+void OMITFP P410ToARGBRow_SSSE3(const uint16_t* y_buf,
+                                const uint16_t* uv_buf,
+                                uint8_t* dst_argb,
+                                const struct YuvConstants* yuvconstants,
+                                int width) {
+  asm volatile(
+      YUVTORGB_SETUP(
+      yuvconstants) "pcmpeqb     %%xmm5,%%xmm5                 \n"
+
+      LABELALIGN "1:                                        \n" READP410
+          YUVTORGB(yuvconstants) STOREARGB
+      "sub         $0x8,%[width]                 \n"
+      "jg          1b                            \n"
+      : [y_buf] "+r"(y_buf),              // %[y_buf]
+        [uv_buf] "+r"(uv_buf),            // %[u_buf]
+        [dst_argb] "+r"(dst_argb),        // %[dst_argb]
+        [width] "+rm"(width)              // %[width]
+      : [yuvconstants] "r"(yuvconstants)  // %[yuvconstants]
+      : "memory", "cc", YUVTORGB_REGS "xmm0", "xmm1", "xmm2", "xmm3", "xmm4",
+        "xmm5");
+}
+
+void OMITFP P210ToAR30Row_SSSE3(const uint16_t* y_buf,
+                                const uint16_t* uv_buf,
+                                uint8_t* dst_ar30,
+                                const struct YuvConstants* yuvconstants,
+                                int width) {
+  asm volatile (
+    YUVTORGB_SETUP(yuvconstants)
+      "pcmpeqb     %%xmm5,%%xmm5                 \n"
+      "psrlw       $14,%%xmm5                    \n"
+      "psllw       $4,%%xmm5                     \n"  // 2 alpha bits
+      "pxor        %%xmm6,%%xmm6                 \n"  // 0 for min
+      "pcmpeqb     %%xmm7,%%xmm7                 \n"
+      "psrlw       $6,%%xmm7                     \n"  // 1023 for max
+
+    LABELALIGN
+      "1:                                        \n"
+    READP210
+    YUVTORGB16(yuvconstants)
+    STOREAR30
+      "sub         $0x8,%[width]                 \n"
+      "jg          1b                            \n"
+  : [y_buf]"+r"(y_buf),              // %[y_buf]
+    [uv_buf]"+r"(uv_buf),            // %[uv_buf]
+    [dst_ar30]"+r"(dst_ar30),        // %[dst_ar30]
+    [width]"+rm"(width)              // %[width]
+  : [yuvconstants]"r"(yuvconstants)  // %[yuvconstants]
+  : "memory", "cc", YUVTORGB_REGS
+      "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7"
+  );
+}
+
+void OMITFP P410ToAR30Row_SSSE3(const uint16_t* y_buf,
+                                const uint16_t* uv_buf,
+                                uint8_t* dst_ar30,
+                                const struct YuvConstants* yuvconstants,
+                                int width) {
+  asm volatile (
+    YUVTORGB_SETUP(yuvconstants)
+      "pcmpeqb     %%xmm5,%%xmm5                 \n"
+      "psrlw       $14,%%xmm5                    \n"
+      "psllw       $4,%%xmm5                     \n"  // 2 alpha bits
+      "pxor        %%xmm6,%%xmm6                 \n"  // 0 for min
+      "pcmpeqb     %%xmm7,%%xmm7                 \n"
+      "psrlw       $6,%%xmm7                     \n"  // 1023 for max
+
+    LABELALIGN
+      "1:                                        \n"
+    READP410
+    YUVTORGB16(yuvconstants)
+    STOREAR30
+      "sub         $0x8,%[width]                 \n"
+      "jg          1b                            \n"
+  : [y_buf]"+r"(y_buf),              // %[y_buf]
+    [uv_buf]"+r"(uv_buf),            // %[uv_buf]
+    [dst_ar30]"+r"(dst_ar30),        // %[dst_ar30]
+    [width]"+rm"(width)              // %[width]
+  : [yuvconstants]"r"(yuvconstants)  // %[yuvconstants]
+  : "memory", "cc", YUVTORGB_REGS
+      "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7"
+  );
+}
+
+void OMITFP I422ToRGBARow_SSSE3(const uint8_t* y_buf,
+                                const uint8_t* u_buf,
+                                const uint8_t* v_buf,
+                                uint8_t* dst_rgba,
+                                const struct YuvConstants* yuvconstants,
+                                int width) {
+  asm volatile (
+    YUVTORGB_SETUP(yuvconstants)
+      "sub         %[u_buf],%[v_buf]             \n"
+      "pcmpeqb     %%xmm5,%%xmm5                 \n"
+
+    LABELALIGN
+      "1:                                        \n"
+    READYUV422
+    YUVTORGB(yuvconstants)
+    STORERGBA
+      "sub         $0x8,%[width]                 \n"
+      "jg          1b                            \n"
+  : [y_buf]"+r"(y_buf),    // %[y_buf]
+    [u_buf]"+r"(u_buf),    // %[u_buf]
+    [v_buf]"+r"(v_buf),    // %[v_buf]
+    [dst_rgba]"+r"(dst_rgba),  // %[dst_rgba]
+    [width]"+rm"(width)    // %[width]
+  : [yuvconstants]"r"(yuvconstants)  // %[yuvconstants]
+  : "memory", "cc", YUVTORGB_REGS
+    "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5"
+  );
+}
+
+#endif  // HAS_I422TOARGBROW_SSSE3
+
+// Read 16 UV from 444
+#define READYUV444_AVX2                                               \
+  "vmovdqu    (%[u_buf]),%%xmm3                                   \n" \
+  "vmovdqu    0x00(%[u_buf],%[v_buf],1),%%xmm1                    \n" \
+  "lea        0x10(%[u_buf]),%[u_buf]                             \n" \
+  "vpermq     $0xd8,%%ymm3,%%ymm3                                 \n" \
+  "vpermq     $0xd8,%%ymm1,%%ymm1                                 \n" \
+  "vpunpcklbw %%ymm1,%%ymm3,%%ymm3                                \n" \
+  "vmovdqu    (%[y_buf]),%%xmm4                                   \n" \
+  "vpermq     $0xd8,%%ymm4,%%ymm4                                 \n" \
+  "vpunpcklbw %%ymm4,%%ymm4,%%ymm4                                \n" \
+  "lea        0x10(%[y_buf]),%[y_buf]                             \n"
+
+// Read 8 UV from 422, upsample to 16 UV.
+#define READYUV422_AVX2                                               \
+  "vmovq      (%[u_buf]),%%xmm3                                   \n" \
+  "vmovq      0x00(%[u_buf],%[v_buf],1),%%xmm1                    \n" \
+  "lea        0x8(%[u_buf]),%[u_buf]                              \n" \
+  "vpunpcklbw %%ymm1,%%ymm3,%%ymm3                                \n" \
+  "vpermq     $0xd8,%%ymm3,%%ymm3                                 \n" \
+  "vpunpcklwd %%ymm3,%%ymm3,%%ymm3                                \n" \
+  "vmovdqu    (%[y_buf]),%%xmm4                                   \n" \
+  "vpermq     $0xd8,%%ymm4,%%ymm4                                 \n" \
+  "vpunpcklbw %%ymm4,%%ymm4,%%ymm4                                \n" \
+  "lea        0x10(%[y_buf]),%[y_buf]                             \n"
+
+#define READYUV422_AVX512BW                                           \
+  "vmovdqu    (%[u_buf]),%%xmm3                                   \n" \
+  "vmovdqu    0x00(%[u_buf],%[v_buf],1),%%xmm1                    \n" \
+  "vpermq     %%zmm3,%%zmm16,%%zmm3                               \n" \
+  "vpermq     %%zmm1,%%zmm16,%%zmm1                               \n" \
+  "lea        0x10(%[u_buf]),%[u_buf]                             \n" \
+  "vpunpcklbw %%zmm1,%%zmm3,%%zmm3                                \n" \
+  "vpermq     $0xd8,%%zmm3,%%zmm3                                 \n" \
+  "vpunpcklwd %%zmm3,%%zmm3,%%zmm3                                \n" \
+  "vmovdqu8   (%[y_buf]),%%ymm4                                   \n" \
+  "vpermq     %%zmm4,%%zmm17,%%zmm4                               \n" \
+  "vpermq     $0xd8,%%zmm4,%%zmm4                                 \n" \
+  "vpunpcklbw %%zmm4,%%zmm4,%%zmm4                                \n" \
+  "lea        0x20(%[y_buf]),%[y_buf]                             \n"
+
+// Read 8 UV from 210, upsample to 16 UV
+// TODO(fbarchard): Consider vshufb to replace pack/unpack
+// TODO(fbarchard): Consider vunpcklpd to combine the 2 registers into 1.
+#define READYUV210_AVX2                                            \
+  "vmovdqu    (%[u_buf]),%%xmm3                                \n" \
+  "vmovdqu    0x00(%[u_buf],%[v_buf],1),%%xmm1                 \n" \
+  "lea        0x10(%[u_buf]),%[u_buf]                          \n" \
+  "vpermq     $0xd8,%%ymm3,%%ymm3                              \n" \
+  "vpermq     $0xd8,%%ymm1,%%ymm1                              \n" \
+  "vpunpcklwd %%ymm1,%%ymm3,%%ymm3                             \n" \
+  "vpsraw     $2,%%ymm3,%%ymm3                                 \n" \
+  "vpackuswb  %%ymm3,%%ymm3,%%ymm3                             \n" \
+  "vpunpcklwd %%ymm3,%%ymm3,%%ymm3                             \n" \
+  "vmovdqu    (%[y_buf]),%%ymm4                                \n" \
+  "vpsllw     $6,%%ymm4,%%ymm4                                 \n" \
+  "lea        0x20(%[y_buf]),%[y_buf]                          \n"
+
+// Read 8 UV from 210, upsample to 16 UV. With 16 Alpha.
+#define READYUVA210_AVX2                                           \
+  "vmovdqu    (%[u_buf]),%%xmm3                                \n" \
+  "vmovdqu    0x00(%[u_buf],%[v_buf],1),%%xmm1                 \n" \
+  "lea        0x10(%[u_buf]),%[u_buf]                          \n" \
+  "vpermq     $0xd8,%%ymm3,%%ymm3                              \n" \
+  "vpermq     $0xd8,%%ymm1,%%ymm1                              \n" \
+  "vpunpcklwd %%ymm1,%%ymm3,%%ymm3                             \n" \
+  "vpsraw     $2,%%ymm3,%%ymm3                                 \n" \
+  "vpackuswb  %%ymm3,%%ymm3,%%ymm3                             \n" \
+  "vpunpcklwd %%ymm3,%%ymm3,%%ymm3                             \n" \
+  "vmovdqu    (%[y_buf]),%%ymm4                                \n" \
+  "vpsllw     $6,%%ymm4,%%ymm4                                 \n" \
+  "lea        0x20(%[y_buf]),%[y_buf]                          \n" \
+  "vmovdqu    (%[a_buf]),%%ymm5                                \n" \
+  "vpsraw     $2,%%ymm5,%%ymm5                                 \n" \
+  "vpackuswb  %%ymm5,%%ymm5,%%ymm5                             \n" \
+  "lea        0x20(%[a_buf]),%[a_buf]                          \n"
+
+// Read 16 UV from 410
+#define READYUV410_AVX2                                            \
+  "vmovdqu    (%[u_buf]),%%ymm3                                \n" \
+  "vmovdqu    0x00(%[u_buf],%[v_buf],1),%%ymm2                 \n" \
+  "lea        0x20(%[u_buf]),%[u_buf]                          \n" \
+  "vpsraw     $2,%%ymm3,%%ymm3                                 \n" \
+  "vpsraw     $2,%%ymm2,%%ymm2                                 \n" \
+  "vpunpckhwd %%ymm2,%%ymm3,%%ymm1                             \n" \
+  "vpunpcklwd %%ymm2,%%ymm3,%%ymm3                             \n" \
+  "vpackuswb  %%ymm1,%%ymm3,%%ymm3                             \n" \
+  "vmovdqu    (%[y_buf]),%%ymm4                                \n" \
+  "vpsllw     $6,%%ymm4,%%ymm4                                 \n" \
+  "lea        0x20(%[y_buf]),%[y_buf]                          \n"
+
+// Read 8 UV from 212 12 bit, upsample to 16 UV
+#define READYUV212_AVX2                                            \
+  "vmovdqu    (%[u_buf]),%%xmm3                                \n" \
+  "vmovdqu    0x00(%[u_buf],%[v_buf],1),%%xmm1                 \n" \
+  "lea        0x10(%[u_buf]),%[u_buf]                          \n" \
+  "vpermq     $0xd8,%%ymm3,%%ymm3                              \n" \
+  "vpermq     $0xd8,%%ymm1,%%ymm1                              \n" \
+  "vpunpcklwd %%ymm1,%%ymm3,%%ymm3                             \n" \
+  "vpsraw     $0x4,%%ymm3,%%ymm3                               \n" \
+  "vpackuswb  %%ymm3,%%ymm3,%%ymm3                             \n" \
+  "vpunpcklwd %%ymm3,%%ymm3,%%ymm3                             \n" \
+  "vmovdqu    (%[y_buf]),%%ymm4                                \n" \
+  "vpsllw     $0x4,%%ymm4,%%ymm4                               \n" \
+  "lea        0x20(%[y_buf]),%[y_buf]                          \n"
+
+// Read 16 UV from 410. With 16 Alpha.
+#define READYUVA410_AVX2                                           \
+  "vmovdqu    (%[u_buf]),%%ymm3                                \n" \
+  "vmovdqu    0x00(%[u_buf],%[v_buf],1),%%ymm2                 \n" \
+  "lea        0x20(%[u_buf]),%[u_buf]                          \n" \
+  "vpsraw     $2,%%ymm3,%%ymm3                                 \n" \
+  "vpsraw     $2,%%ymm2,%%ymm2                                 \n" \
+  "vpunpckhwd %%ymm2,%%ymm3,%%ymm1                             \n" \
+  "vpunpcklwd %%ymm2,%%ymm3,%%ymm3                             \n" \
+  "vpackuswb  %%ymm1,%%ymm3,%%ymm3                             \n" \
+  "vmovdqu    (%[y_buf]),%%ymm4                                \n" \
+  "vpsllw     $6,%%ymm4,%%ymm4                                 \n" \
+  "lea        0x20(%[y_buf]),%[y_buf]                          \n" \
+  "vmovdqu    (%[a_buf]),%%ymm5                                \n" \
+  "vpsraw     $2,%%ymm5,%%ymm5                                 \n" \
+  "vpackuswb  %%ymm5,%%ymm5,%%ymm5                             \n" \
+  "lea        0x20(%[a_buf]),%[a_buf]                          \n"
+
+// Read 16 UV from 444.  With 16 Alpha.
+#define READYUVA444_AVX2                                              \
+  "vmovdqu    (%[u_buf]),%%xmm3                                   \n" \
+  "vmovdqu    0x00(%[u_buf],%[v_buf],1),%%xmm1                    \n" \
+  "lea        0x10(%[u_buf]),%[u_buf]                             \n" \
+  "vpermq     $0xd8,%%ymm3,%%ymm3                                 \n" \
+  "vpermq     $0xd8,%%ymm1,%%ymm1                                 \n" \
+  "vpunpcklbw %%ymm1,%%ymm3,%%ymm3                                \n" \
+  "vmovdqu    (%[y_buf]),%%xmm4                                   \n" \
+  "vpermq     $0xd8,%%ymm4,%%ymm4                                 \n" \
+  "vpunpcklbw %%ymm4,%%ymm4,%%ymm4                                \n" \
+  "lea        0x10(%[y_buf]),%[y_buf]                             \n" \
+  "vmovdqu    (%[a_buf]),%%xmm5                                   \n" \
+  "vpermq     $0xd8,%%ymm5,%%ymm5                                 \n" \
+  "lea        0x10(%[a_buf]),%[a_buf]                             \n"
+
+// Read 8 UV from 422, upsample to 16 UV.  With 16 Alpha.
+#define READYUVA422_AVX2                                              \
+  "vmovq      (%[u_buf]),%%xmm3                                   \n" \
+  "vmovq      0x00(%[u_buf],%[v_buf],1),%%xmm1                    \n" \
+  "lea        0x8(%[u_buf]),%[u_buf]                              \n" \
+  "vpunpcklbw %%ymm1,%%ymm3,%%ymm3                                \n" \
+  "vpermq     $0xd8,%%ymm3,%%ymm3                                 \n" \
+  "vpunpcklwd %%ymm3,%%ymm3,%%ymm3                                \n" \
+  "vmovdqu    (%[y_buf]),%%xmm4                                   \n" \
+  "vpermq     $0xd8,%%ymm4,%%ymm4                                 \n" \
+  "vpunpcklbw %%ymm4,%%ymm4,%%ymm4                                \n" \
+  "lea        0x10(%[y_buf]),%[y_buf]                             \n" \
+  "vmovdqu    (%[a_buf]),%%xmm5                                   \n" \
+  "vpermq     $0xd8,%%ymm5,%%ymm5                                 \n" \
+  "lea        0x10(%[a_buf]),%[a_buf]                             \n"
+
+// Read 8 UV from NV12, upsample to 16 UV.
+#define READNV12_AVX2                                                 \
+  "vmovdqu    (%[uv_buf]),%%xmm3                                  \n" \
+  "lea        0x10(%[uv_buf]),%[uv_buf]                           \n" \
+  "vpermq     $0xd8,%%ymm3,%%ymm3                                 \n" \
+  "vpunpcklwd %%ymm3,%%ymm3,%%ymm3                                \n" \
+  "vmovdqu    (%[y_buf]),%%xmm4                                   \n" \
+  "vpermq     $0xd8,%%ymm4,%%ymm4                                 \n" \
+  "vpunpcklbw %%ymm4,%%ymm4,%%ymm4                                \n" \
+  "lea        0x10(%[y_buf]),%[y_buf]                             \n"
+
+// Read 8 VU from NV21, upsample to 16 UV.
+#define READNV21_AVX2                                                 \
+  "vmovdqu    (%[vu_buf]),%%xmm3                                  \n" \
+  "lea        0x10(%[vu_buf]),%[vu_buf]                           \n" \
+  "vpermq     $0xd8,%%ymm3,%%ymm3                                 \n" \
+  "vpshufb     %[kShuffleNV21], %%ymm3, %%ymm3                    \n" \
+  "vmovdqu    (%[y_buf]),%%xmm4                                   \n" \
+  "vpermq     $0xd8,%%ymm4,%%ymm4                                 \n" \
+  "vpunpcklbw %%ymm4,%%ymm4,%%ymm4                                \n" \
+  "lea        0x10(%[y_buf]),%[y_buf]                             \n"
+
+// Read 4 UV from P210, upsample to 8 UV
+#define READP210_AVX2                                                 \
+  "vmovdqu    (%[uv_buf]),%%ymm3                                  \n" \
+  "lea        0x20(%[uv_buf]),%[uv_buf]                           \n" \
+  "vpsrlw     $0x8,%%ymm3,%%ymm3                                  \n" \
+  "vpackuswb  %%ymm3,%%ymm3,%%ymm3                                \n" \
+  "vpunpcklwd %%ymm3,%%ymm3,%%ymm3                                \n" \
+  "vmovdqu    (%[y_buf]),%%ymm4                                   \n" \
+  "lea        0x20(%[y_buf]),%[y_buf]                             \n"
+
+// Read 8 UV from P410
+#define READP410_AVX2                                                 \
+  "vmovdqu    (%[uv_buf]),%%ymm3                                  \n" \
+  "vmovdqu    0x20(%[uv_buf]),%%ymm1                              \n" \
+  "lea        0x40(%[uv_buf]),%[uv_buf]                           \n" \
+  "vpsrlw     $0x8,%%ymm3,%%ymm3                                  \n" \
+  "vpsrlw     $0x8,%%ymm1,%%ymm1                                  \n" \
+  "vpackuswb  %%ymm1,%%ymm3,%%ymm3                                \n" \
+  "vpermq     $0xd8,%%ymm3,%%ymm3                                 \n" \
+  "vmovdqu    (%[y_buf]),%%ymm4                                   \n" \
+  "lea        0x20(%[y_buf]),%[y_buf]                             \n"
+
+// Read 8 YUY2 with 16 Y and upsample 8 UV to 16 UV.
+#define READYUY2_AVX2                                                 \
+  "vmovdqu    (%[yuy2_buf]),%%ymm4                                \n" \
+  "vpshufb    %[kShuffleYUY2Y], %%ymm4, %%ymm4                    \n" \
+  "vmovdqu    (%[yuy2_buf]),%%ymm3                                \n" \
+  "vpshufb    %[kShuffleYUY2UV], %%ymm3, %%ymm3                   \n" \
+  "lea        0x20(%[yuy2_buf]),%[yuy2_buf]                       \n"
+
+// Read 8 UYVY with 16 Y and upsample 8 UV to 16 UV.
+#define READUYVY_AVX2                                                 \
+  "vmovdqu    (%[uyvy_buf]),%%ymm4                                \n" \
+  "vpshufb    %[kShuffleUYVYY], %%ymm4, %%ymm4                    \n" \
+  "vmovdqu    (%[uyvy_buf]),%%ymm3                                \n" \
+  "vpshufb    %[kShuffleUYVYUV], %%ymm3, %%ymm3                   \n" \
+  "lea        0x20(%[uyvy_buf]),%[uyvy_buf]                       \n"
+
+// TODO(fbarchard): Remove broadcastb
+#if defined(__x86_64__)
+#define YUVTORGB_SETUP_AVX2(yuvconstants)                             \
+  "vpcmpeqb    %%xmm13,%%xmm13,%%xmm13                            \n" \
+  "vmovdqa     (%[yuvconstants]),%%ymm8                           \n" \
+  "vpsllw      $7,%%xmm13,%%xmm13                                 \n" \
+  "vmovdqa     32(%[yuvconstants]),%%ymm9                         \n" \
+  "vpbroadcastb %%xmm13,%%ymm13                                   \n" \
+  "vmovdqa     64(%[yuvconstants]),%%ymm10                        \n" \
+  "vmovdqa     96(%[yuvconstants]),%%ymm11                        \n" \
+  "vmovdqa     128(%[yuvconstants]),%%ymm12                       \n"
+
+#define YUVTORGB_SETUP_AVX512BW(yuvconstants)                         \
+  "vpcmpeqb   %%xmm13,%%xmm13,%%xmm13                             \n" \
+  "movdqa     (%[yuvconstants]),%%xmm8                            \n" \
+  "vpbroadcastq %%xmm8, %%zmm8                                    \n" \
+  "vpsllw     $7,%%xmm13,%%xmm13                                  \n" \
+  "vpbroadcastb %%xmm13,%%zmm13                                   \n" \
+  "movq     32(%[yuvconstants]),%%xmm9                            \n" \
+  "vpbroadcastq %%xmm9,%%zmm9                                     \n" \
+  "movq     64(%[yuvconstants]),%%xmm10                           \n" \
+  "vpbroadcastq %%xmm10,%%zmm10                                   \n" \
+  "movq     96(%[yuvconstants]),%%xmm11                           \n" \
+  "vpbroadcastq %%xmm11,%%zmm11                                   \n" \
+  "movq     128(%[yuvconstants]),%%xmm12                          \n" \
+  "vpbroadcastq %%xmm12,%%zmm12                                   \n" \
+  "vmovdqu8 (%[quadsplitperm]),%%zmm16                            \n" \
+  "vmovdqu8 (%[dquadsplitperm]),%%zmm17                           \n" \
+  "vmovdqu8 (%[unperm]),%%zmm18                                   \n"
+
+#define YUVTORGB16_AVX2(yuvconstants)                                 \
+  "vpsubb      %%ymm13,%%ymm3,%%ymm3                              \n" \
+  "vpmulhuw    %%ymm11,%%ymm4,%%ymm4                              \n" \
+  "vpmaddubsw  %%ymm3,%%ymm8,%%ymm0                               \n" \
+  "vpmaddubsw  %%ymm3,%%ymm9,%%ymm1                               \n" \
+  "vpmaddubsw  %%ymm3,%%ymm10,%%ymm2                              \n" \
+  "vpaddw      %%ymm4,%%ymm12,%%ymm4                              \n" \
+  "vpaddsw     %%ymm4,%%ymm0,%%ymm0                               \n" \
+  "vpsubsw     %%ymm1,%%ymm4,%%ymm1                               \n" \
+  "vpaddsw     %%ymm4,%%ymm2,%%ymm2                               \n"
+
+#define YUVTORGB16_AVX512BW(yuvconstants)                             \
+  "vpsubb      %%zmm13,%%zmm3,%%zmm3                              \n" \
+  "vpmulhuw    %%zmm11,%%zmm4,%%zmm4                              \n" \
+  "vpmaddubsw  %%zmm3,%%zmm8,%%zmm0                               \n" \
+  "vpmaddubsw  %%zmm3,%%zmm9,%%zmm1                               \n" \
+  "vpmaddubsw  %%zmm3,%%zmm10,%%zmm2                              \n" \
+  "vpaddw      %%zmm4,%%zmm12,%%zmm4                              \n" \
+  "vpaddsw     %%zmm4,%%zmm0,%%zmm0                               \n" \
+  "vpsubsw     %%zmm1,%%zmm4,%%zmm1                               \n" \
+  "vpaddsw     %%zmm4,%%zmm2,%%zmm2                               \n"
+
+#define YUVTORGB_REGS_AVX2 "xmm8", "xmm9", "xmm10", "xmm11", "xmm12", "xmm13",
+#define YUVTORGB_REGS_AVX512BW \
+  "xmm8", "xmm9", "xmm10", "xmm11", "xmm12", "xmm13", "xmm16", "xmm17", "xmm18",
+
+#else  // Convert 16 pixels: 16 UV and 16 Y.
+
+#define YUVTORGB_SETUP_AVX2(yuvconstants)
+#define YUVTORGB16_AVX2(yuvconstants)                                 \
+  "vpcmpeqb    %%xmm0,%%xmm0,%%xmm0                               \n" \
+  "vpsllw      $7,%%xmm0,%%xmm0                                   \n" \
+  "vpbroadcastb %%xmm0,%%ymm0                                     \n" \
+  "vpsubb      %%ymm0,%%ymm3,%%ymm3                               \n" \
+  "vpmulhuw    96(%[yuvconstants]),%%ymm4,%%ymm4                  \n" \
+  "vmovdqa     (%[yuvconstants]),%%ymm0                           \n" \
+  "vmovdqa     32(%[yuvconstants]),%%ymm1                         \n" \
+  "vmovdqa     64(%[yuvconstants]),%%ymm2                         \n" \
+  "vpmaddubsw  %%ymm3,%%ymm0,%%ymm0                               \n" \
+  "vpmaddubsw  %%ymm3,%%ymm1,%%ymm1                               \n" \
+  "vpmaddubsw  %%ymm3,%%ymm2,%%ymm2                               \n" \
+  "vmovdqa     128(%[yuvconstants]),%%ymm3                        \n" \
+  "vpaddw      %%ymm4,%%ymm3,%%ymm4                               \n" \
+  "vpaddsw     %%ymm4,%%ymm0,%%ymm0                               \n" \
+  "vpsubsw     %%ymm1,%%ymm4,%%ymm1                               \n" \
+  "vpaddsw     %%ymm4,%%ymm2,%%ymm2                               \n"
+
+#define YUVTORGB_REGS_AVX2
+#endif
+
+#define YUVTORGB_AVX2(yuvconstants)                                   \
+  YUVTORGB16_AVX2(yuvconstants)                                       \
+  "vpsraw      $0x6,%%ymm0,%%ymm0                                 \n" \
+  "vpsraw      $0x6,%%ymm1,%%ymm1                                 \n" \
+  "vpsraw      $0x6,%%ymm2,%%ymm2                                 \n" \
+  "vpackuswb   %%ymm0,%%ymm0,%%ymm0                               \n" \
+  "vpackuswb   %%ymm1,%%ymm1,%%ymm1                               \n" \
+  "vpackuswb   %%ymm2,%%ymm2,%%ymm2                               \n"
+
+#define YUVTORGB_AVX512BW(yuvconstants)                               \
+  YUVTORGB16_AVX512BW(yuvconstants)                                   \
+  "vpsraw     $0x6,%%zmm0,%%zmm0                                  \n" \
+  "vpsraw     $0x6,%%zmm1,%%zmm1                                  \n" \
+  "vpsraw     $0x6,%%zmm2,%%zmm2                                  \n" \
+  "vpackuswb  %%zmm0,%%zmm0,%%zmm0                                \n" \
+  "vpackuswb  %%zmm1,%%zmm1,%%zmm1                                \n" \
+  "vpackuswb  %%zmm2,%%zmm2,%%zmm2                                \n"
+
+// Store 16 ARGB values.
+#define STOREARGB_AVX2                                                \
+  "vpunpcklbw %%ymm1,%%ymm0,%%ymm0                                \n" \
+  "vpermq     $0xd8,%%ymm0,%%ymm0                                 \n" \
+  "vpunpcklbw %%ymm5,%%ymm2,%%ymm2                                \n" \
+  "vpermq     $0xd8,%%ymm2,%%ymm2                                 \n" \
+  "vpunpcklwd %%ymm2,%%ymm0,%%ymm1                                \n" \
+  "vpunpckhwd %%ymm2,%%ymm0,%%ymm0                                \n" \
+  "vmovdqu    %%ymm1,(%[dst_argb])                                \n" \
+  "vmovdqu    %%ymm0,0x20(%[dst_argb])                            \n" \
+  "lea        0x40(%[dst_argb]), %[dst_argb]                      \n"
+
+// Store 32 ARGB values.
+#define STOREARGB_AVX512BW                                            \
+  "vpunpcklbw %%zmm1,%%zmm0,%%zmm0                                \n" \
+  "vpermq     %%zmm0,%%zmm18,%%zmm0                               \n" \
+  "vpunpcklbw %%zmm5,%%zmm2,%%zmm2                                \n" \
+  "vpermq     %%zmm2,%%zmm18,%%zmm2                               \n" \
+  "vpunpcklwd %%zmm2,%%zmm0,%%zmm1                                \n" \
+  "vpunpckhwd %%zmm2,%%zmm0,%%zmm0                                \n" \
+  "vmovdqu8   %%zmm1,(%[dst_argb])                                \n" \
+  "vmovdqu8   %%zmm0,0x40(%[dst_argb])                            \n" \
+  "lea        0x80(%[dst_argb]), %[dst_argb]                      \n"
+
+// Store 16 AR30 values.
+#define STOREAR30_AVX2                                                \
+  "vpsraw     $0x4,%%ymm0,%%ymm0                                  \n" \
+  "vpsraw     $0x4,%%ymm1,%%ymm1                                  \n" \
+  "vpsraw     $0x4,%%ymm2,%%ymm2                                  \n" \
+  "vpminsw    %%ymm7,%%ymm0,%%ymm0                                \n" \
+  "vpminsw    %%ymm7,%%ymm1,%%ymm1                                \n" \
+  "vpminsw    %%ymm7,%%ymm2,%%ymm2                                \n" \
+  "vpmaxsw    %%ymm6,%%ymm0,%%ymm0                                \n" \
+  "vpmaxsw    %%ymm6,%%ymm1,%%ymm1                                \n" \
+  "vpmaxsw    %%ymm6,%%ymm2,%%ymm2                                \n" \
+  "vpsllw     $0x4,%%ymm2,%%ymm2                                  \n" \
+  "vpermq     $0xd8,%%ymm0,%%ymm0                                 \n" \
+  "vpermq     $0xd8,%%ymm1,%%ymm1                                 \n" \
+  "vpermq     $0xd8,%%ymm2,%%ymm2                                 \n" \
+  "vpunpckhwd %%ymm2,%%ymm0,%%ymm3                                \n" \
+  "vpunpcklwd %%ymm2,%%ymm0,%%ymm0                                \n" \
+  "vpunpckhwd %%ymm5,%%ymm1,%%ymm2                                \n" \
+  "vpunpcklwd %%ymm5,%%ymm1,%%ymm1                                \n" \
+  "vpslld     $0xa,%%ymm1,%%ymm1                                  \n" \
+  "vpslld     $0xa,%%ymm2,%%ymm2                                  \n" \
+  "vpor       %%ymm1,%%ymm0,%%ymm0                                \n" \
+  "vpor       %%ymm2,%%ymm3,%%ymm3                                \n" \
+  "vmovdqu    %%ymm0,(%[dst_ar30])                                \n" \
+  "vmovdqu    %%ymm3,0x20(%[dst_ar30])                            \n" \
+  "lea        0x40(%[dst_ar30]), %[dst_ar30]                      \n"
+
+#ifdef HAS_I444TOARGBROW_AVX2
+// 16 pixels
+// 16 UV values with 16 Y producing 16 ARGB (64 bytes).
+void OMITFP I444ToARGBRow_AVX2(const uint8_t* y_buf,
+                               const uint8_t* u_buf,
+                               const uint8_t* v_buf,
+                               uint8_t* dst_argb,
+                               const struct YuvConstants* yuvconstants,
+                               int width) {
+  asm volatile (
+    YUVTORGB_SETUP_AVX2(yuvconstants)
+      "sub         %[u_buf],%[v_buf]             \n"
+      "vpcmpeqb    %%ymm5,%%ymm5,%%ymm5          \n"
+
+    LABELALIGN
+      "1:                                        \n"
+    READYUV444_AVX2
+    YUVTORGB_AVX2(yuvconstants)
+    STOREARGB_AVX2
+      "sub         $0x10,%[width]                \n"
+      "jg          1b                            \n"
+      "vzeroupper                                \n"
+  : [y_buf]"+r"(y_buf),    // %[y_buf]
+    [u_buf]"+r"(u_buf),    // %[u_buf]
+    [v_buf]"+r"(v_buf),    // %[v_buf]
+    [dst_argb]"+r"(dst_argb),  // %[dst_argb]
+    [width]"+rm"(width)    // %[width]
+  : [yuvconstants]"r"(yuvconstants)  // %[yuvconstants]
+  : "memory", "cc", YUVTORGB_REGS_AVX2
+    "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5"
+  );
+}
+#endif  // HAS_I444TOARGBROW_AVX2
+
+#if defined(HAS_I422TOARGBROW_AVX2)
+// 16 pixels
+// 8 UV values upsampled to 16 UV, mixed with 16 Y producing 16 ARGB (64 bytes).
+void OMITFP I422ToARGBRow_AVX2(const uint8_t* y_buf,
+                               const uint8_t* u_buf,
+                               const uint8_t* v_buf,
+                               uint8_t* dst_argb,
+                               const struct YuvConstants* yuvconstants,
+                               int width) {
+  asm volatile (
+    YUVTORGB_SETUP_AVX2(yuvconstants)
+      "sub         %[u_buf],%[v_buf]             \n"
+      "vpcmpeqb    %%ymm5,%%ymm5,%%ymm5          \n"
+
+    LABELALIGN
+      "1:                                        \n"
+    READYUV422_AVX2
+    YUVTORGB_AVX2(yuvconstants)
+    STOREARGB_AVX2
+      "sub         $0x10,%[width]                \n"
+      "jg          1b                            \n"
+
+      "vzeroupper                                \n"
+  : [y_buf]"+r"(y_buf),    // %[y_buf]
+    [u_buf]"+r"(u_buf),    // %[u_buf]
+    [v_buf]"+r"(v_buf),    // %[v_buf]
+    [dst_argb]"+r"(dst_argb),  // %[dst_argb]
+    [width]"+rm"(width)    // %[width]
+  : [yuvconstants]"r"(yuvconstants)  // %[yuvconstants]
+  : "memory", "cc", YUVTORGB_REGS_AVX2
+    "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5"
+  );
+}
+#endif  // HAS_I422TOARGBROW_AVX2
+
+#if defined(HAS_I422TOARGBROW_AVX512BW)
+static const uint64_t kSplitQuadWords[8] = {0, 2, 2, 2, 1, 2, 2, 2};
+static const uint64_t kSplitDoubleQuadWords[8] = {0, 1, 4, 4, 2, 3, 4, 4};
+static const uint64_t kUnpermuteAVX512[8] = {0, 4, 1, 5, 2, 6, 3, 7};
+
+// 32 pixels
+// 16 UV values upsampled to 32 UV, mixed with 32 Y producing 32 ARGB (128
+// bytes).
+void OMITFP I422ToARGBRow_AVX512BW(const uint8_t* y_buf,
+                                   const uint8_t* u_buf,
+                                   const uint8_t* v_buf,
+                                   uint8_t* dst_argb,
+                                   const struct YuvConstants* yuvconstants,
+                                   int width) {
+  asm volatile (
+    YUVTORGB_SETUP_AVX512BW(yuvconstants)
+      "sub         %[u_buf],%[v_buf]             \n"
+      "vpcmpeqb    %%xmm5,%%xmm5,%%xmm5          \n"
+      "vpbroadcastq %%xmm5,%%zmm5                \n"
+
+    LABELALIGN
+      "1:                                        \n"
+    READYUV422_AVX512BW
+    YUVTORGB_AVX512BW(yuvconstants)
+    STOREARGB_AVX512BW
+      "sub         $0x20,%[width]                \n"
+      "jg          1b                            \n"
+
+      "vzeroupper                                \n"
+  : [y_buf]"+r"(y_buf),                         // %[y_buf]
+    [u_buf]"+r"(u_buf),                         // %[u_buf]
+    [v_buf]"+r"(v_buf),                         // %[v_buf]
+    [dst_argb]"+r"(dst_argb),                   // %[dst_argb]
+    [width]"+rm"(width)                         // %[width]
+  : [yuvconstants]"r"(yuvconstants),            // %[yuvconstants]
+    [quadsplitperm]"r"(kSplitQuadWords),        // %[quadsplitperm]
+    [dquadsplitperm]"r"(kSplitDoubleQuadWords), // %[dquadsplitperm]
+    [unperm]"r"(kUnpermuteAVX512)               // %[unperm]
+  : "memory", "cc", YUVTORGB_REGS_AVX512BW
+    "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5"
+  );
+}
+#endif  // HAS_I422TOARGBROW_AVX512BW
+
+#if defined(HAS_I422TOAR30ROW_AVX2)
+// 16 pixels
+// 8 UV values upsampled to 16 UV, mixed with 16 Y producing 16 AR30 (64 bytes).
+void OMITFP I422ToAR30Row_AVX2(const uint8_t* y_buf,
+                               const uint8_t* u_buf,
+                               const uint8_t* v_buf,
+                               uint8_t* dst_ar30,
+                               const struct YuvConstants* yuvconstants,
+                               int width) {
+  asm volatile (
+    YUVTORGB_SETUP_AVX2(yuvconstants)
+      "sub         %[u_buf],%[v_buf]             \n"
+      "vpcmpeqb    %%ymm5,%%ymm5,%%ymm5          \n"  // AR30 constants
+      "vpsrlw      $14,%%ymm5,%%ymm5             \n"
+      "vpsllw      $4,%%ymm5,%%ymm5              \n"  // 2 alpha bits
+      "vpxor       %%ymm6,%%ymm6,%%ymm6          \n"  // 0 for min
+      "vpcmpeqb    %%ymm7,%%ymm7,%%ymm7          \n"  // 1023 for max
+      "vpsrlw      $6,%%ymm7,%%ymm7              \n"
+
+    LABELALIGN
+      "1:                                        \n"
+    READYUV422_AVX2
+    YUVTORGB16_AVX2(yuvconstants)
+    STOREAR30_AVX2
+      "sub         $0x10,%[width]                \n"
+      "jg          1b                            \n"
+
+      "vzeroupper                                \n"
+  : [y_buf]"+r"(y_buf),    // %[y_buf]
+    [u_buf]"+r"(u_buf),    // %[u_buf]
+    [v_buf]"+r"(v_buf),    // %[v_buf]
+    [dst_ar30]"+r"(dst_ar30),  // %[dst_ar30]
+    [width]"+rm"(width)    // %[width]
+  : [yuvconstants]"r"(yuvconstants)  // %[yuvconstants]
+  : "memory", "cc", YUVTORGB_REGS_AVX2
+    "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7"
+  );
+}
+#endif  // HAS_I422TOAR30ROW_AVX2
+
+#if defined(HAS_I210TOARGBROW_AVX2)
+// 16 pixels
+// 8 UV values upsampled to 16 UV, mixed with 16 Y producing 16 ARGB (64 bytes).
+void OMITFP I210ToARGBRow_AVX2(const uint16_t* y_buf,
+                               const uint16_t* u_buf,
+                               const uint16_t* v_buf,
+                               uint8_t* dst_argb,
+                               const struct YuvConstants* yuvconstants,
+                               int width) {
+  asm volatile (
+    YUVTORGB_SETUP_AVX2(yuvconstants)
+      "sub         %[u_buf],%[v_buf]             \n"
+      "vpcmpeqb    %%ymm5,%%ymm5,%%ymm5          \n"
+
+    LABELALIGN
+      "1:                                        \n"
+    READYUV210_AVX2
+    YUVTORGB_AVX2(yuvconstants)
+    STOREARGB_AVX2
+      "sub         $0x10,%[width]                \n"
+      "jg          1b                            \n"
+
+      "vzeroupper                                \n"
+  : [y_buf]"+r"(y_buf),    // %[y_buf]
+    [u_buf]"+r"(u_buf),    // %[u_buf]
+    [v_buf]"+r"(v_buf),    // %[v_buf]
+    [dst_argb]"+r"(dst_argb),  // %[dst_argb]
+    [width]"+rm"(width)    // %[width]
+  : [yuvconstants]"r"(yuvconstants)  // %[yuvconstants]
+  : "memory", "cc", YUVTORGB_REGS_AVX2
+    "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5"
+  );
+}
+#endif  // HAS_I210TOARGBROW_AVX2
+
+#if defined(HAS_I212TOARGBROW_AVX2)
+// 16 pixels
+// 8 UV values upsampled to 16 UV, mixed with 16 Y producing 16 ARGB (64 bytes).
+void OMITFP I212ToARGBRow_AVX2(const uint16_t* y_buf,
+                               const uint16_t* u_buf,
+                               const uint16_t* v_buf,
+                               uint8_t* dst_argb,
+                               const struct YuvConstants* yuvconstants,
+                               int width) {
+  asm volatile (
+    YUVTORGB_SETUP_AVX2(yuvconstants)
+      "sub         %[u_buf],%[v_buf]             \n"
+      "vpcmpeqb    %%ymm5,%%ymm5,%%ymm5          \n"
+
+    LABELALIGN
+      "1:                                        \n"
+    READYUV212_AVX2
+    YUVTORGB_AVX2(yuvconstants)
+    STOREARGB_AVX2
+      "sub         $0x10,%[width]                \n"
+      "jg          1b                            \n"
+
+      "vzeroupper                                \n"
+  : [y_buf]"+r"(y_buf),    // %[y_buf]
+    [u_buf]"+r"(u_buf),    // %[u_buf]
+    [v_buf]"+r"(v_buf),    // %[v_buf]
+    [dst_argb]"+r"(dst_argb),  // %[dst_argb]
+    [width]"+rm"(width)    // %[width]
+  : [yuvconstants]"r"(yuvconstants)  // %[yuvconstants]
+  : "memory", "cc", YUVTORGB_REGS_AVX2
+    "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5"
+  );
+}
+#endif  // HAS_I212TOARGBROW_AVX2
+
+#if defined(HAS_I210TOAR30ROW_AVX2)
+// 16 pixels
+// 8 UV values upsampled to 16 UV, mixed with 16 Y producing 16 AR30 (64 bytes).
+void OMITFP I210ToAR30Row_AVX2(const uint16_t* y_buf,
+                               const uint16_t* u_buf,
+                               const uint16_t* v_buf,
+                               uint8_t* dst_ar30,
+                               const struct YuvConstants* yuvconstants,
+                               int width) {
+  asm volatile (
+    YUVTORGB_SETUP_AVX2(yuvconstants)
+      "sub         %[u_buf],%[v_buf]             \n"
+      "vpcmpeqb    %%ymm5,%%ymm5,%%ymm5          \n"  // AR30 constants
+      "vpsrlw      $14,%%ymm5,%%ymm5             \n"
+      "vpsllw      $4,%%ymm5,%%ymm5              \n"  // 2 alpha bits
+      "vpxor       %%ymm6,%%ymm6,%%ymm6          \n"  // 0 for min
+      "vpcmpeqb    %%ymm7,%%ymm7,%%ymm7          \n"  // 1023 for max
+      "vpsrlw      $6,%%ymm7,%%ymm7              \n"
+
+    LABELALIGN
+      "1:                                        \n"
+    READYUV210_AVX2
+    YUVTORGB16_AVX2(yuvconstants)
+    STOREAR30_AVX2
+      "sub         $0x10,%[width]                \n"
+      "jg          1b                            \n"
+
+      "vzeroupper                                \n"
+  : [y_buf]"+r"(y_buf),    // %[y_buf]
+    [u_buf]"+r"(u_buf),    // %[u_buf]
+    [v_buf]"+r"(v_buf),    // %[v_buf]
+    [dst_ar30]"+r"(dst_ar30),  // %[dst_ar30]
+    [width]"+rm"(width)    // %[width]
+  : [yuvconstants]"r"(yuvconstants)  // %[yuvconstants]
+  : "memory", "cc", YUVTORGB_REGS_AVX2
+    "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7"
+  );
+}
+#endif  // HAS_I210TOAR30ROW_AVX2
+
+#if defined(HAS_I212TOAR30ROW_AVX2)
+// 16 pixels
+// 8 UV values upsampled to 16 UV, mixed with 16 Y producing 16 AR30 (64 bytes).
+void OMITFP I212ToAR30Row_AVX2(const uint16_t* y_buf,
+                               const uint16_t* u_buf,
+                               const uint16_t* v_buf,
+                               uint8_t* dst_ar30,
+                               const struct YuvConstants* yuvconstants,
+                               int width) {
+  asm volatile (
+    YUVTORGB_SETUP_AVX2(yuvconstants)
+      "sub         %[u_buf],%[v_buf]             \n"
+      "vpcmpeqb    %%ymm5,%%ymm5,%%ymm5          \n"  // AR30 constants
+      "vpsrlw      $14,%%ymm5,%%ymm5             \n"
+      "vpsllw      $4,%%ymm5,%%ymm5              \n"  // 2 alpha bits
+      "vpxor       %%ymm6,%%ymm6,%%ymm6          \n"  // 0 for min
+      "vpcmpeqb    %%ymm7,%%ymm7,%%ymm7          \n"  // 1023 for max
+      "vpsrlw      $6,%%ymm7,%%ymm7              \n"
+
+    LABELALIGN
+      "1:                                        \n"
+    READYUV212_AVX2
+    YUVTORGB16_AVX2(yuvconstants)
+    STOREAR30_AVX2
+      "sub         $0x10,%[width]                \n"
+      "jg          1b                            \n"
+
+      "vzeroupper                                \n"
+  : [y_buf]"+r"(y_buf),    // %[y_buf]
+    [u_buf]"+r"(u_buf),    // %[u_buf]
+    [v_buf]"+r"(v_buf),    // %[v_buf]
+    [dst_ar30]"+r"(dst_ar30),  // %[dst_ar30]
+    [width]"+rm"(width)    // %[width]
+  : [yuvconstants]"r"(yuvconstants)  // %[yuvconstants]
+  : "memory", "cc", YUVTORGB_REGS_AVX2
+    "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7"
+  );
+}
+#endif  // HAS_I212TOAR30ROW_AVX2
+
+#if defined(HAS_I410TOARGBROW_AVX2)
+// 16 pixels
+// 16 UV values with 16 Y producing 16 ARGB (64 bytes).
+void OMITFP I410ToARGBRow_AVX2(const uint16_t* y_buf,
+                               const uint16_t* u_buf,
+                               const uint16_t* v_buf,
+                               uint8_t* dst_argb,
+                               const struct YuvConstants* yuvconstants,
+                               int width) {
+  asm volatile (
+    YUVTORGB_SETUP_AVX2(yuvconstants)
+      "sub         %[u_buf],%[v_buf]             \n"
+      "vpcmpeqb    %%ymm5,%%ymm5,%%ymm5          \n"
+
+    LABELALIGN
+      "1:                                        \n"
+    READYUV410_AVX2
+    YUVTORGB_AVX2(yuvconstants)
+    STOREARGB_AVX2
+      "sub         $0x10,%[width]                \n"
+      "jg          1b                            \n"
+      "vzeroupper                                \n"
+
+  : [y_buf]"+r"(y_buf),    // %[y_buf]
+    [u_buf]"+r"(u_buf),    // %[u_buf]
+    [v_buf]"+r"(v_buf),    // %[v_buf]
+    [dst_argb]"+r"(dst_argb),  // %[dst_argb]
+    [width]"+rm"(width)    // %[width]
+  : [yuvconstants]"r"(yuvconstants)  // %[yuvconstants]
+  : "memory", "cc", YUVTORGB_REGS_AVX2
+      "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5"
+  );
+}
+#endif  // HAS_I410TOARGBROW_AVX2
+
+#if defined(HAS_I210ALPHATOARGBROW_AVX2)
+// 16 pixels
+// 8 UV, 16 Y and 16 A producing 16 ARGB (64 bytes).
+void OMITFP I210AlphaToARGBRow_AVX2(const uint16_t* y_buf,
+                                    const uint16_t* u_buf,
+                                    const uint16_t* v_buf,
+                                    const uint16_t* a_buf,
+                                    uint8_t* dst_argb,
+                                    const struct YuvConstants* yuvconstants,
+                                    int width) {
+  asm volatile(
+      YUVTORGB_SETUP_AVX2(
+      yuvconstants) "sub         %[u_buf],%[v_buf]             \n"
+
+      LABELALIGN "1:                                        \n" READYUVA210_AVX2
+          YUVTORGB_AVX2(yuvconstants) STOREARGB_AVX2
+      "subl        $0x10,%[width]                \n"
+      "jg          1b                            \n"
+      "vzeroupper                                \n"
+
+      : [y_buf] "+r"(y_buf),        // %[y_buf]
+        [u_buf] "+r"(u_buf),        // %[u_buf]
+        [v_buf] "+r"(v_buf),        // %[v_buf]
+        [a_buf] "+r"(a_buf),        // %[a_buf]
+        [dst_argb] "+r"(dst_argb),  // %[dst_argb]
+#if defined(__i386__)
+        [width] "+m"(width)  // %[width]
+#else
+        [width] "+rm"(width)  // %[width]
+#endif
+      : [yuvconstants] "r"(yuvconstants)  // %[yuvconstants]
+      : "memory", "cc", YUVTORGB_REGS_AVX2 "xmm0", "xmm1", "xmm2", "xmm3",
+        "xmm4", "xmm5");
+}
+#endif  // HAS_I210TOARGBROW_AVX2
+
+#if defined(HAS_I410ALPHATOARGBROW_AVX2)
+// 16 pixels
+// 16 UV, 16 Y and 16 A producing 16 ARGB (64 bytes).
+void OMITFP I410AlphaToARGBRow_AVX2(const uint16_t* y_buf,
+                                    const uint16_t* u_buf,
+                                    const uint16_t* v_buf,
+                                    const uint16_t* a_buf,
+                                    uint8_t* dst_argb,
+                                    const struct YuvConstants* yuvconstants,
+                                    int width) {
+  asm volatile(
+      YUVTORGB_SETUP_AVX2(
+      yuvconstants) "sub         %[u_buf],%[v_buf]             \n"
+
+      LABELALIGN "1:                                        \n" READYUVA410_AVX2
+          YUVTORGB_AVX2(yuvconstants) STOREARGB_AVX2
+      "subl        $0x10,%[width]                \n"
+      "jg          1b                            \n"
+      "vzeroupper                                \n"
+
+      : [y_buf] "+r"(y_buf),        // %[y_buf]
+        [u_buf] "+r"(u_buf),        // %[u_buf]
+        [v_buf] "+r"(v_buf),        // %[v_buf]
+        [a_buf] "+r"(a_buf),        // %[a_buf]
+        [dst_argb] "+r"(dst_argb),  // %[dst_argb]
+#if defined(__i386__)
+        [width] "+m"(width)  // %[width]
+#else
+        [width] "+rm"(width)  // %[width]
+#endif
+      : [yuvconstants] "r"(yuvconstants)  // %[yuvconstants]
+      : "memory", "cc", YUVTORGB_REGS_AVX2 "xmm0", "xmm1", "xmm2", "xmm3",
+        "xmm4", "xmm5");
+}
+#endif  // HAS_I410TOARGBROW_AVX2
+
+#if defined(HAS_I410TOAR30ROW_AVX2)
+// 16 pixels
+// 16 UV values with 16 Y producing 16 AR30 (64 bytes).
+void OMITFP I410ToAR30Row_AVX2(const uint16_t* y_buf,
+                               const uint16_t* u_buf,
+                               const uint16_t* v_buf,
+                               uint8_t* dst_ar30,
+                               const struct YuvConstants* yuvconstants,
+                               int width) {
+  asm volatile (
+    YUVTORGB_SETUP_AVX2(yuvconstants)
+      "sub         %[u_buf],%[v_buf]             \n"
+      "vpcmpeqb    %%ymm5,%%ymm5,%%ymm5          \n"  // AR30 constants
+      "vpsrlw      $14,%%ymm5,%%ymm5             \n"
+      "vpsllw      $4,%%ymm5,%%ymm5              \n"  // 2 alpha bits
+      "vpxor       %%ymm6,%%ymm6,%%ymm6          \n"  // 0 for min
+      "vpcmpeqb    %%ymm7,%%ymm7,%%ymm7          \n"  // 1023 for max
+      "vpsrlw      $6,%%ymm7,%%ymm7              \n"
+
+    LABELALIGN
+      "1:                                        \n"
+    READYUV410_AVX2
+    YUVTORGB16_AVX2(yuvconstants)
+    STOREAR30_AVX2
+      "sub         $0x10,%[width]                \n"
+      "jg          1b                            \n"
+
+      "vzeroupper                                \n"
+  : [y_buf]"+r"(y_buf),    // %[y_buf]
+    [u_buf]"+r"(u_buf),    // %[u_buf]
+    [v_buf]"+r"(v_buf),    // %[v_buf]
+    [dst_ar30]"+r"(dst_ar30),  // %[dst_ar30]
+    [width]"+rm"(width)    // %[width]
+  : [yuvconstants]"r"(yuvconstants)  // %[yuvconstants]
+  : "memory", "cc", YUVTORGB_REGS_AVX2
+      "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7"
+  );
+}
+#endif  // HAS_I410TOAR30ROW_AVX2
+
+#if defined(HAS_I444ALPHATOARGBROW_AVX2)
+// 16 pixels
+// 16 UV values with 16 Y and 16 A producing 16 ARGB.
+void OMITFP I444AlphaToARGBRow_AVX2(const uint8_t* y_buf,
+                                    const uint8_t* u_buf,
+                                    const uint8_t* v_buf,
+                                    const uint8_t* a_buf,
+                                    uint8_t* dst_argb,
+                                    const struct YuvConstants* yuvconstants,
+                                    int width) {
+  // clang-format off
+  asm volatile (
+  YUVTORGB_SETUP_AVX2(yuvconstants)
+      "sub         %[u_buf],%[v_buf]             \n"
+
+  LABELALIGN
+      "1:                                        \n"
+  READYUVA444_AVX2
+  YUVTORGB_AVX2(yuvconstants)
+  STOREARGB_AVX2
+      "subl        $0x10,%[width]                \n"
+      "jg          1b                            \n"
+      "vzeroupper                                \n"
+  : [y_buf]"+r"(y_buf),    // %[y_buf]
+    [u_buf]"+r"(u_buf),    // %[u_buf]
+    [v_buf]"+r"(v_buf),    // %[v_buf]
+    [a_buf]"+r"(a_buf),    // %[a_buf]
+    [dst_argb]"+r"(dst_argb),  // %[dst_argb]
+#if defined(__i386__)
+    [width]"+m"(width)     // %[width]
+#else
+    [width]"+rm"(width)    // %[width]
+#endif
+  : [yuvconstants]"r"(yuvconstants)  // %[yuvconstants]
+  : "memory", "cc", YUVTORGB_REGS_AVX2
+      "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5"
+  );
+  // clang-format on
+}
+#endif  // HAS_I444ALPHATOARGBROW_AVX2
+
+#if defined(HAS_I422ALPHATOARGBROW_AVX2)
+// 16 pixels
+// 8 UV values upsampled to 16 UV, mixed with 16 Y and 16 A producing 16 ARGB.
+void OMITFP I422AlphaToARGBRow_AVX2(const uint8_t* y_buf,
+                                    const uint8_t* u_buf,
+                                    const uint8_t* v_buf,
+                                    const uint8_t* a_buf,
+                                    uint8_t* dst_argb,
+                                    const struct YuvConstants* yuvconstants,
+                                    int width) {
+  // clang-format off
+  asm volatile (
+    YUVTORGB_SETUP_AVX2(yuvconstants)
+      "sub         %[u_buf],%[v_buf]             \n"
+
+    LABELALIGN
+      "1:                                        \n"
+    READYUVA422_AVX2
+    YUVTORGB_AVX2(yuvconstants)
+    STOREARGB_AVX2
+      "subl        $0x10,%[width]                \n"
+      "jg          1b                            \n"
+      "vzeroupper                                \n"
+  : [y_buf]"+r"(y_buf),    // %[y_buf]
+    [u_buf]"+r"(u_buf),    // %[u_buf]
+    [v_buf]"+r"(v_buf),    // %[v_buf]
+    [a_buf]"+r"(a_buf),    // %[a_buf]
+    [dst_argb]"+r"(dst_argb),  // %[dst_argb]
+#if defined(__i386__)
+    [width]"+m"(width)     // %[width]
+#else
+    [width]"+rm"(width)    // %[width]
+#endif
+  : [yuvconstants]"r"(yuvconstants)  // %[yuvconstants]
+  : "memory", "cc", YUVTORGB_REGS_AVX2
+    "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5"
+  );
+  // clang-format on
+}
+#endif  // HAS_I422ALPHATOARGBROW_AVX2
+
+#if defined(HAS_I422TORGBAROW_AVX2)
+// 16 pixels
+// 8 UV values upsampled to 16 UV, mixed with 16 Y producing 16 RGBA (64 bytes).
+void OMITFP I422ToRGBARow_AVX2(const uint8_t* y_buf,
+                               const uint8_t* u_buf,
+                               const uint8_t* v_buf,
+                               uint8_t* dst_argb,
+                               const struct YuvConstants* yuvconstants,
+                               int width) {
+  asm volatile (
+    YUVTORGB_SETUP_AVX2(yuvconstants)
+      "sub         %[u_buf],%[v_buf]             \n"
+      "vpcmpeqb    %%ymm5,%%ymm5,%%ymm5          \n"
+
+    LABELALIGN
+      "1:                                        \n"
+    READYUV422_AVX2
+    YUVTORGB_AVX2(yuvconstants)
+
+    // Step 3: Weave into RGBA
+    "vpunpcklbw %%ymm2,%%ymm1,%%ymm1           \n"
+    "vpermq     $0xd8,%%ymm1,%%ymm1            \n"
+    "vpunpcklbw %%ymm0,%%ymm5,%%ymm2           \n"
+    "vpermq     $0xd8,%%ymm2,%%ymm2            \n"
+    "vpunpcklwd %%ymm1,%%ymm2,%%ymm0           \n"
+    "vpunpckhwd %%ymm1,%%ymm2,%%ymm1           \n"
+    "vmovdqu    %%ymm0,(%[dst_argb])           \n"
+    "vmovdqu    %%ymm1,0x20(%[dst_argb])       \n"
+    "lea        0x40(%[dst_argb]),%[dst_argb]  \n"
+    "sub        $0x10,%[width]                 \n"
+    "jg         1b                             \n"
+    "vzeroupper                                \n"
+  : [y_buf]"+r"(y_buf),    // %[y_buf]
+    [u_buf]"+r"(u_buf),    // %[u_buf]
+    [v_buf]"+r"(v_buf),    // %[v_buf]
+    [dst_argb]"+r"(dst_argb),  // %[dst_argb]
+    [width]"+rm"(width)    // %[width]
+  : [yuvconstants]"r"(yuvconstants)  // %[yuvconstants]
+  : "memory", "cc", YUVTORGB_REGS_AVX2
+    "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5"
+  );
+}
+#endif  // HAS_I422TORGBAROW_AVX2
+
+#if defined(HAS_NV12TOARGBROW_AVX2)
+// 16 pixels.
+// 8 UV values upsampled to 16 UV, mixed with 16 Y producing 16 ARGB (64 bytes).
+void OMITFP NV12ToARGBRow_AVX2(const uint8_t* y_buf,
+                               const uint8_t* uv_buf,
+                               uint8_t* dst_argb,
+                               const struct YuvConstants* yuvconstants,
+                               int width) {
+  // clang-format off
+  asm volatile (
+    YUVTORGB_SETUP_AVX2(yuvconstants)
+      "vpcmpeqb    %%ymm5,%%ymm5,%%ymm5          \n"
+
+    LABELALIGN
+      "1:                                        \n"
+    READNV12_AVX2
+    YUVTORGB_AVX2(yuvconstants)
+    STOREARGB_AVX2
+      "sub         $0x10,%[width]                \n"
+      "jg          1b                            \n"
+      "vzeroupper                                \n"
+  : [y_buf]"+r"(y_buf),    // %[y_buf]
+    [uv_buf]"+r"(uv_buf),    // %[uv_buf]
+    [dst_argb]"+r"(dst_argb),  // %[dst_argb]
+    [width]"+rm"(width)    // %[width]
+  : [yuvconstants]"r"(yuvconstants)  // %[yuvconstants]
+    : "memory", "cc", YUVTORGB_REGS_AVX2
+    "xmm0", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5"
+  );
+  // clang-format on
+}
+#endif  // HAS_NV12TOARGBROW_AVX2
+
+#if defined(HAS_NV21TOARGBROW_AVX2)
+// 16 pixels.
+// 8 VU values upsampled to 16 UV, mixed with 16 Y producing 16 ARGB (64 bytes).
+void OMITFP NV21ToARGBRow_AVX2(const uint8_t* y_buf,
+                               const uint8_t* vu_buf,
+                               uint8_t* dst_argb,
+                               const struct YuvConstants* yuvconstants,
+                               int width) {
+  // clang-format off
+  asm volatile (
+    YUVTORGB_SETUP_AVX2(yuvconstants)
+      "vpcmpeqb    %%ymm5,%%ymm5,%%ymm5          \n"
+
+    LABELALIGN
+      "1:                                        \n"
+    READNV21_AVX2
+    YUVTORGB_AVX2(yuvconstants)
+    STOREARGB_AVX2
+      "sub         $0x10,%[width]                \n"
+      "jg          1b                            \n"
+      "vzeroupper                                \n"
+  : [y_buf]"+r"(y_buf),    // %[y_buf]
+    [vu_buf]"+r"(vu_buf),    // %[vu_buf]
+    [dst_argb]"+r"(dst_argb),  // %[dst_argb]
+    [width]"+rm"(width)    // %[width]
+  : [yuvconstants]"r"(yuvconstants), // %[yuvconstants]
+    [kShuffleNV21]"m"(kShuffleNV21)
+    : "memory", "cc", YUVTORGB_REGS_AVX2
+      "xmm0", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5"
+  );
+  // clang-format on
+}
+#endif  // HAS_NV21TOARGBROW_AVX2
+
+#if defined(HAS_YUY2TOARGBROW_AVX2)
+// 16 pixels.
+// 8 YUY2 values with 16 Y and 8 UV producing 16 ARGB (64 bytes).
+void OMITFP YUY2ToARGBRow_AVX2(const uint8_t* yuy2_buf,
+                               uint8_t* dst_argb,
+                               const struct YuvConstants* yuvconstants,
+                               int width) {
+  // clang-format off
+  asm volatile (
+    YUVTORGB_SETUP_AVX2(yuvconstants)
+      "vpcmpeqb    %%ymm5,%%ymm5,%%ymm5          \n"
+
+    LABELALIGN
+      "1:                                        \n"
+    READYUY2_AVX2
+    YUVTORGB_AVX2(yuvconstants)
+    STOREARGB_AVX2
+      "sub         $0x10,%[width]                \n"
+      "jg          1b                            \n"
+      "vzeroupper                                \n"
+  : [yuy2_buf]"+r"(yuy2_buf),    // %[yuy2_buf]
+    [dst_argb]"+r"(dst_argb),  // %[dst_argb]
+    [width]"+rm"(width)    // %[width]
+  : [yuvconstants]"r"(yuvconstants), // %[yuvconstants]
+    [kShuffleYUY2Y]"m"(kShuffleYUY2Y),
+    [kShuffleYUY2UV]"m"(kShuffleYUY2UV)
+    : "memory", "cc", YUVTORGB_REGS_AVX2
+      "xmm0", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5"
+  );
+  // clang-format on
+}
+#endif  // HAS_YUY2TOARGBROW_AVX2
+
+#if defined(HAS_UYVYTOARGBROW_AVX2)
+// 16 pixels.
+// 8 UYVY values with 16 Y and 8 UV producing 16 ARGB (64 bytes).
+void OMITFP UYVYToARGBRow_AVX2(const uint8_t* uyvy_buf,
+                               uint8_t* dst_argb,
+                               const struct YuvConstants* yuvconstants,
+                               int width) {
+  // clang-format off
+  asm volatile (
+    YUVTORGB_SETUP_AVX2(yuvconstants)
+      "vpcmpeqb    %%ymm5,%%ymm5,%%ymm5          \n"
+
+    LABELALIGN
+      "1:                                        \n"
+    READUYVY_AVX2
+    YUVTORGB_AVX2(yuvconstants)
+    STOREARGB_AVX2
+      "sub         $0x10,%[width]                \n"
+      "jg          1b                            \n"
+      "vzeroupper                                \n"
+  : [uyvy_buf]"+r"(uyvy_buf),    // %[uyvy_buf]
+    [dst_argb]"+r"(dst_argb),  // %[dst_argb]
+    [width]"+rm"(width)    // %[width]
+  : [yuvconstants]"r"(yuvconstants), // %[yuvconstants]
+    [kShuffleUYVYY]"m"(kShuffleUYVYY),
+    [kShuffleUYVYUV]"m"(kShuffleUYVYUV)
+    : "memory", "cc", YUVTORGB_REGS_AVX2
+      "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5"
+  );
+  // clang-format on
+}
+#endif  // HAS_UYVYTOARGBROW_AVX2
+
+#if defined(HAS_P210TOARGBROW_AVX2)
+// 16 pixels.
+// 8 UV values upsampled to 16 UV, mixed with 16 Y producing 16 ARGB (64 bytes).
+void OMITFP P210ToARGBRow_AVX2(const uint16_t* y_buf,
+                               const uint16_t* uv_buf,
+                               uint8_t* dst_argb,
+                               const struct YuvConstants* yuvconstants,
+                               int width) {
+  // clang-format off
+  asm volatile (
+    YUVTORGB_SETUP_AVX2(yuvconstants)
+      "vpcmpeqb    %%ymm5,%%ymm5,%%ymm5          \n"
+
+    LABELALIGN
+      "1:                                        \n"
+    READP210_AVX2
+    YUVTORGB_AVX2(yuvconstants)
+    STOREARGB_AVX2
+      "sub         $0x10,%[width]                \n"
+      "jg          1b                            \n"
+      "vzeroupper                                \n"
+  : [y_buf]"+r"(y_buf),    // %[y_buf]
+    [uv_buf]"+r"(uv_buf),    // %[uv_buf]
+    [dst_argb]"+r"(dst_argb),  // %[dst_argb]
+    [width]"+rm"(width)    // %[width]
+  : [yuvconstants]"r"(yuvconstants)  // %[yuvconstants]
+  : "memory", "cc", YUVTORGB_REGS_AVX2
+      "xmm0", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5"
+  );
+  // clang-format on
+}
+#endif  // HAS_P210TOARGBROW_AVX2
+
+#if defined(HAS_P410TOARGBROW_AVX2)
+// 16 pixels.
+// 8 UV values upsampled to 16 UV, mixed with 16 Y producing 16 ARGB (64 bytes).
+void OMITFP P410ToARGBRow_AVX2(const uint16_t* y_buf,
+                               const uint16_t* uv_buf,
+                               uint8_t* dst_argb,
+                               const struct YuvConstants* yuvconstants,
+                               int width) {
+  // clang-format off
+  asm volatile (
+    YUVTORGB_SETUP_AVX2(yuvconstants)
+      "vpcmpeqb    %%ymm5,%%ymm5,%%ymm5          \n"
+
+    LABELALIGN
+      "1:                                        \n"
+    READP410_AVX2
+    YUVTORGB_AVX2(yuvconstants)
+    STOREARGB_AVX2
+      "sub         $0x10,%[width]                \n"
+      "jg          1b                            \n"
+      "vzeroupper                                \n"
+  : [y_buf]"+r"(y_buf),    // %[y_buf]
+    [uv_buf]"+r"(uv_buf),    // %[uv_buf]
+    [dst_argb]"+r"(dst_argb),  // %[dst_argb]
+    [width]"+rm"(width)    // %[width]
+  : [yuvconstants]"r"(yuvconstants)  // %[yuvconstants]
+  : "memory", "cc", YUVTORGB_REGS_AVX2
+      "xmm0", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5"
+  );
+  // clang-format on
+}
+#endif  // HAS_P410TOARGBROW_AVX2
+
+#if defined(HAS_P210TOAR30ROW_AVX2)
+// 16 pixels
+// 16 UV values with 16 Y producing 16 AR30 (64 bytes).
+void OMITFP P210ToAR30Row_AVX2(const uint16_t* y_buf,
+                               const uint16_t* uv_buf,
+                               uint8_t* dst_ar30,
+                               const struct YuvConstants* yuvconstants,
+                               int width) {
+  asm volatile (
+    YUVTORGB_SETUP_AVX2(yuvconstants)
+      "vpcmpeqb    %%ymm5,%%ymm5,%%ymm5          \n"  // AR30 constants
+      "vpsrlw      $14,%%ymm5,%%ymm5             \n"
+      "vpsllw      $4,%%ymm5,%%ymm5              \n"  // 2 alpha bits
+      "vpxor       %%ymm6,%%ymm6,%%ymm6          \n"  // 0 for min
+      "vpcmpeqb    %%ymm7,%%ymm7,%%ymm7          \n"  // 1023 for max
+      "vpsrlw      $6,%%ymm7,%%ymm7              \n"
+
+    LABELALIGN
+      "1:                                        \n"
+    READP210_AVX2
+    YUVTORGB16_AVX2(yuvconstants)
+    STOREAR30_AVX2
+      "sub         $0x10,%[width]                \n"
+      "jg          1b                            \n"
+
+      "vzeroupper                                \n"
+  : [y_buf]"+r"(y_buf),    // %[y_buf]
+    [uv_buf]"+r"(uv_buf),    // %[uv_buf]
+    [dst_ar30]"+r"(dst_ar30),  // %[dst_ar30]
+    [width]"+rm"(width)    // %[width]
+  : [yuvconstants]"r"(yuvconstants)  // %[yuvconstants]
+  : "memory", "cc", YUVTORGB_REGS_AVX2
+      "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7"
+  );
+}
+#endif  // HAS_P210TOAR30ROW_AVX2
+
+#if defined(HAS_P410TOAR30ROW_AVX2)
+// 16 pixels
+// 16 UV values with 16 Y producing 16 AR30 (64 bytes).
+void OMITFP P410ToAR30Row_AVX2(const uint16_t* y_buf,
+                               const uint16_t* uv_buf,
+                               uint8_t* dst_ar30,
+                               const struct YuvConstants* yuvconstants,
+                               int width) {
+  asm volatile (
+    YUVTORGB_SETUP_AVX2(yuvconstants)
+      "vpcmpeqb    %%ymm5,%%ymm5,%%ymm5          \n"  // AR30 constants
+      "vpsrlw      $14,%%ymm5,%%ymm5             \n"
+      "vpsllw      $4,%%ymm5,%%ymm5              \n"  // 2 alpha bits
+      "vpxor       %%ymm6,%%ymm6,%%ymm6          \n"  // 0 for min
+      "vpcmpeqb    %%ymm7,%%ymm7,%%ymm7          \n"  // 1023 for max
+      "vpsrlw      $6,%%ymm7,%%ymm7              \n"
+
+    LABELALIGN
+      "1:                                        \n"
+    READP410_AVX2
+    YUVTORGB16_AVX2(yuvconstants)
+    STOREAR30_AVX2
+      "sub         $0x10,%[width]                \n"
+      "jg          1b                            \n"
+
+      "vzeroupper                                \n"
+  : [y_buf]"+r"(y_buf),    // %[y_buf]
+    [uv_buf]"+r"(uv_buf),    // %[uv_buf]
+    [dst_ar30]"+r"(dst_ar30),  // %[dst_ar30]
+    [width]"+rm"(width)    // %[width]
+  : [yuvconstants]"r"(yuvconstants)  // %[yuvconstants]
+  : "memory", "cc", YUVTORGB_REGS_AVX2
+      "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7"
+  );
+}
+#endif  // HAS_P410TOAR30ROW_AVX2
+
+#ifdef HAS_I400TOARGBROW_SSE2
+void I400ToARGBRow_SSE2(const uint8_t* y_buf,
+                        uint8_t* dst_argb,
+                        const struct YuvConstants* yuvconstants,
+                        int width) {
+  asm volatile(
+      "movdqa      96(%3),%%xmm2                 \n"  // yg = 18997 = 1.164
+      "movdqa      128(%3),%%xmm3                \n"  // ygb = 1160 = 1.164 * 16
+      "pcmpeqb     %%xmm4,%%xmm4                 \n"  // 0xff000000
+      "pslld       $0x18,%%xmm4                  \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      // Step 1: Scale Y contribution to 8 G values. G = (y - 16) * 1.164
+      "movq      (%0),%%xmm0                     \n"
+      "lea       0x8(%0),%0                      \n"
+      "punpcklbw %%xmm0,%%xmm0                   \n"
+      "pmulhuw   %%xmm2,%%xmm0                   \n"
+      "paddsw    %%xmm3,%%xmm0                   \n"
+      "psraw     $6, %%xmm0                      \n"
+      "packuswb  %%xmm0,%%xmm0                   \n"
+
+      // Step 2: Weave into ARGB
+      "punpcklbw %%xmm0,%%xmm0                   \n"
+      "movdqa    %%xmm0,%%xmm1                   \n"
+      "punpcklwd %%xmm0,%%xmm0                   \n"
+      "punpckhwd %%xmm1,%%xmm1                   \n"
+      "por       %%xmm4,%%xmm0                   \n"
+      "por       %%xmm4,%%xmm1                   \n"
+      "movdqu    %%xmm0,(%1)                     \n"
+      "movdqu    %%xmm1,0x10(%1)                 \n"
+      "lea       0x20(%1),%1                     \n"
+
+      "sub       $0x8,%2                         \n"
+      "jg        1b                              \n"
+      : "+r"(y_buf),       // %0
+        "+r"(dst_argb),    // %1
+        "+rm"(width)       // %2
+      : "r"(yuvconstants)  // %3
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4");
+}
+#endif  // HAS_I400TOARGBROW_SSE2
+
+#ifdef HAS_I400TOARGBROW_AVX2
+// 16 pixels of Y converted to 16 pixels of ARGB (64 bytes).
+// note: vpunpcklbw mutates and vpackuswb unmutates.
+void I400ToARGBRow_AVX2(const uint8_t* y_buf,
+                        uint8_t* dst_argb,
+                        const struct YuvConstants* yuvconstants,
+                        int width) {
+  asm volatile(
+      "vmovdqa     96(%3),%%ymm2                 \n"  // yg = 18997 = 1.164
+      "vmovdqa     128(%3),%%ymm3                \n"  // ygb = -1160 = 1.164*16
+      "vpcmpeqb    %%ymm4,%%ymm4,%%ymm4          \n"  // 0xff000000
+      "vpslld      $0x18,%%ymm4,%%ymm4           \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      // Step 1: Scale Y contribution to 16 G values. G = (y - 16) * 1.164
+      "vmovdqu    (%0),%%xmm0                    \n"
+      "lea        0x10(%0),%0                    \n"
+      "vpermq     $0xd8,%%ymm0,%%ymm0            \n"
+      "vpunpcklbw %%ymm0,%%ymm0,%%ymm0           \n"
+      "vpmulhuw   %%ymm2,%%ymm0,%%ymm0           \n"
+      "vpaddsw    %%ymm3,%%ymm0,%%ymm0           \n"
+      "vpsraw     $0x6,%%ymm0,%%ymm0             \n"
+      "vpackuswb  %%ymm0,%%ymm0,%%ymm0           \n"
+      "vpunpcklbw %%ymm0,%%ymm0,%%ymm1           \n"
+      "vpermq     $0xd8,%%ymm1,%%ymm1            \n"
+      "vpunpcklwd %%ymm1,%%ymm1,%%ymm0           \n"
+      "vpunpckhwd %%ymm1,%%ymm1,%%ymm1           \n"
+      "vpor       %%ymm4,%%ymm0,%%ymm0           \n"
+      "vpor       %%ymm4,%%ymm1,%%ymm1           \n"
+      "vmovdqu    %%ymm0,(%1)                    \n"
+      "vmovdqu    %%ymm1,0x20(%1)                \n"
+      "lea        0x40(%1),%1                     \n"
+      "sub        $0x10,%2                       \n"
+      "jg        1b                              \n"
+      "vzeroupper                                \n"
+      : "+r"(y_buf),       // %0
+        "+r"(dst_argb),    // %1
+        "+rm"(width)       // %2
+      : "r"(yuvconstants)  // %3
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4");
+}
+#endif  // HAS_I400TOARGBROW_AVX2
+
+#ifdef HAS_MIRRORROW_SSSE3
+// Shuffle table for reversing the bytes.
+static const uvec8 kShuffleMirror = {15u, 14u, 13u, 12u, 11u, 10u, 9u, 8u,
+                                     7u,  6u,  5u,  4u,  3u,  2u,  1u, 0u};
+
+void MirrorRow_SSSE3(const uint8_t* src, uint8_t* dst, int width) {
+  intptr_t temp_width = (intptr_t)(width);
+  asm volatile(
+
+      "movdqa      %3,%%xmm5                     \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "movdqu      -0x10(%0,%2,1),%%xmm0         \n"
+      "pshufb      %%xmm5,%%xmm0                 \n"
+      "movdqu      %%xmm0,(%1)                   \n"
+      "lea         0x10(%1),%1                   \n"
+      "sub         $0x10,%2                      \n"
+      "jg          1b                            \n"
+      : "+r"(src),           // %0
+        "+r"(dst),           // %1
+        "+r"(temp_width)     // %2
+      : "m"(kShuffleMirror)  // %3
+      : "memory", "cc", "xmm0", "xmm5");
+}
+#endif  // HAS_MIRRORROW_SSSE3
+
+#ifdef HAS_MIRRORROW_AVX2
+void MirrorRow_AVX2(const uint8_t* src, uint8_t* dst, int width) {
+  intptr_t temp_width = (intptr_t)(width);
+  asm volatile(
+
+      "vbroadcastf128 %3,%%ymm5                  \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "vmovdqu     -0x20(%0,%2,1),%%ymm0         \n"
+      "vpshufb     %%ymm5,%%ymm0,%%ymm0          \n"
+      "vpermq      $0x4e,%%ymm0,%%ymm0           \n"
+      "vmovdqu     %%ymm0,(%1)                   \n"
+      "lea         0x20(%1),%1                   \n"
+      "sub         $0x20,%2                      \n"
+      "jg          1b                            \n"
+      "vzeroupper                                \n"
+      : "+r"(src),           // %0
+        "+r"(dst),           // %1
+        "+r"(temp_width)     // %2
+      : "m"(kShuffleMirror)  // %3
+      : "memory", "cc", "xmm0", "xmm5");
+}
+#endif  // HAS_MIRRORROW_AVX2
+
+#ifdef HAS_MIRRORUVROW_SSSE3
+// Shuffle table for reversing the UV.
+static const uvec8 kShuffleMirrorUV = {14u, 15u, 12u, 13u, 10u, 11u, 8u, 9u,
+                                       6u,  7u,  4u,  5u,  2u,  3u,  0u, 1u};
+
+void MirrorUVRow_SSSE3(const uint8_t* src_uv, uint8_t* dst_uv, int width) {
+  intptr_t temp_width = (intptr_t)(width);
+  asm volatile(
+
+      "movdqa      %3,%%xmm5                     \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "movdqu      -0x10(%0,%2,2),%%xmm0         \n"
+      "pshufb      %%xmm5,%%xmm0                 \n"
+      "movdqu      %%xmm0,(%1)                   \n"
+      "lea         0x10(%1),%1                   \n"
+      "sub         $0x8,%2                       \n"
+      "jg          1b                            \n"
+      : "+r"(src_uv),          // %0
+        "+r"(dst_uv),          // %1
+        "+r"(temp_width)       // %2
+      : "m"(kShuffleMirrorUV)  // %3
+      : "memory", "cc", "xmm0", "xmm5");
+}
+#endif  // HAS_MIRRORUVROW_SSSE3
+
+#ifdef HAS_MIRRORUVROW_AVX2
+void MirrorUVRow_AVX2(const uint8_t* src_uv, uint8_t* dst_uv, int width) {
+  intptr_t temp_width = (intptr_t)(width);
+  asm volatile(
+
+      "vbroadcastf128 %3,%%ymm5                  \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "vmovdqu     -0x20(%0,%2,2),%%ymm0         \n"
+      "vpshufb     %%ymm5,%%ymm0,%%ymm0          \n"
+      "vpermq      $0x4e,%%ymm0,%%ymm0           \n"
+      "vmovdqu     %%ymm0,(%1)                   \n"
+      "lea         0x20(%1),%1                   \n"
+      "sub         $0x10,%2                      \n"
+      "jg          1b                            \n"
+      "vzeroupper                                \n"
+      : "+r"(src_uv),          // %0
+        "+r"(dst_uv),          // %1
+        "+r"(temp_width)       // %2
+      : "m"(kShuffleMirrorUV)  // %3
+      : "memory", "cc", "xmm0", "xmm5");
+}
+#endif  // HAS_MIRRORUVROW_AVX2
+
+#ifdef HAS_MIRRORSPLITUVROW_SSSE3
+// Shuffle table for reversing the bytes of UV channels.
+static const uvec8 kShuffleMirrorSplitUV = {14u, 12u, 10u, 8u, 6u, 4u, 2u, 0u,
+                                            15u, 13u, 11u, 9u, 7u, 5u, 3u, 1u};
+void MirrorSplitUVRow_SSSE3(const uint8_t* src,
+                            uint8_t* dst_u,
+                            uint8_t* dst_v,
+                            int width) {
+  intptr_t temp_width = (intptr_t)(width);
+  asm volatile(
+      "movdqa      %4,%%xmm1                     \n"
+      "lea         -0x10(%0,%3,2),%0             \n"
+      "sub         %1,%2                         \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "movdqu      (%0),%%xmm0                   \n"
+      "lea         -0x10(%0),%0                  \n"
+      "pshufb      %%xmm1,%%xmm0                 \n"
+      "movlpd      %%xmm0,(%1)                   \n"
+      "movhpd      %%xmm0,0x00(%1,%2,1)          \n"
+      "lea         0x8(%1),%1                    \n"
+      "sub         $8,%3                         \n"
+      "jg          1b                            \n"
+      : "+r"(src),                  // %0
+        "+r"(dst_u),                // %1
+        "+r"(dst_v),                // %2
+        "+r"(temp_width)            // %3
+      : "m"(kShuffleMirrorSplitUV)  // %4
+      : "memory", "cc", "xmm0", "xmm1");
+}
+#endif  // HAS_MIRRORSPLITUVROW_SSSE3
+
+#ifdef HAS_RGB24MIRRORROW_SSSE3
+
+// Shuffle first 5 pixels to last 5 mirrored.  first byte zero
+static const uvec8 kShuffleMirrorRGB0 = {128u, 12u, 13u, 14u, 9u, 10u, 11u, 6u,
+                                         7u,   8u,  3u,  4u,  5u, 0u,  1u,  2u};
+
+// Shuffle last 5 pixels to first 5 mirrored.  last byte zero
+static const uvec8 kShuffleMirrorRGB1 = {
+    13u, 14u, 15u, 10u, 11u, 12u, 7u, 8u, 9u, 4u, 5u, 6u, 1u, 2u, 3u, 128u};
+
+// Shuffle 5 pixels at a time (15 bytes)
+void RGB24MirrorRow_SSSE3(const uint8_t* src_rgb24,
+                          uint8_t* dst_rgb24,
+                          int width) {
+  intptr_t temp_width = (intptr_t)(width);
+  src_rgb24 += width * 3 - 48;
+  asm volatile(
+      "movdqa      %3,%%xmm4                     \n"
+      "movdqa      %4,%%xmm5                     \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "movdqu      (%0),%%xmm0                   \n"  // first 5
+      "movdqu      15(%0),%%xmm1                 \n"  // next 5
+      "movdqu      30(%0),%%xmm2                 \n"  // next 5
+      "movdqu      32(%0),%%xmm3                 \n"  // last 1 special
+      "pshufb      %%xmm4,%%xmm0                 \n"
+      "pshufb      %%xmm4,%%xmm1                 \n"
+      "pshufb      %%xmm4,%%xmm2                 \n"
+      "pshufb      %%xmm5,%%xmm3                 \n"
+      "lea         -0x30(%0),%0                  \n"
+      "movdqu      %%xmm0,32(%1)                 \n"  // last 5
+      "movdqu      %%xmm1,17(%1)                 \n"  // next 5
+      "movdqu      %%xmm2,2(%1)                  \n"  // next 5
+      "movlpd      %%xmm3,0(%1)                  \n"  // first 1
+      "lea         0x30(%1),%1                   \n"
+      "sub         $0x10,%2                      \n"
+      "jg          1b                            \n"
+      : "+r"(src_rgb24),          // %0
+        "+r"(dst_rgb24),          // %1
+        "+r"(temp_width)          // %2
+      : "m"(kShuffleMirrorRGB0),  // %3
+        "m"(kShuffleMirrorRGB1)   // %4
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5");
+}
+#endif  // HAS_RGB24MIRRORROW_SSSE3
+
+#ifdef HAS_ARGBMIRRORROW_SSE2
+
+void ARGBMirrorRow_SSE2(const uint8_t* src, uint8_t* dst, int width) {
+  intptr_t temp_width = (intptr_t)(width);
+  asm volatile(
+
+      "lea         -0x10(%0,%2,4),%0             \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "movdqu      (%0),%%xmm0                   \n"
+      "pshufd      $0x1b,%%xmm0,%%xmm0           \n"
+      "lea         -0x10(%0),%0                  \n"
+      "movdqu      %%xmm0,(%1)                   \n"
+      "lea         0x10(%1),%1                   \n"
+      "sub         $0x4,%2                       \n"
+      "jg          1b                            \n"
+      : "+r"(src),        // %0
+        "+r"(dst),        // %1
+        "+r"(temp_width)  // %2
+      :
+      : "memory", "cc", "xmm0");
+}
+#endif  // HAS_ARGBMIRRORROW_SSE2
+
+#ifdef HAS_ARGBMIRRORROW_AVX2
+// Shuffle table for reversing the bytes.
+static const ulvec32 kARGBShuffleMirror_AVX2 = {7u, 6u, 5u, 4u, 3u, 2u, 1u, 0u};
+void ARGBMirrorRow_AVX2(const uint8_t* src, uint8_t* dst, int width) {
+  intptr_t temp_width = (intptr_t)(width);
+  asm volatile(
+
+      "vmovdqu     %3,%%ymm5                     \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "vpermd      -0x20(%0,%2,4),%%ymm5,%%ymm0  \n"
+      "vmovdqu     %%ymm0,(%1)                   \n"
+      "lea         0x20(%1),%1                   \n"
+      "sub         $0x8,%2                       \n"
+      "jg          1b                            \n"
+      "vzeroupper                                \n"
+      : "+r"(src),                    // %0
+        "+r"(dst),                    // %1
+        "+r"(temp_width)              // %2
+      : "m"(kARGBShuffleMirror_AVX2)  // %3
+      : "memory", "cc", "xmm0", "xmm5");
+}
+#endif  // HAS_ARGBMIRRORROW_AVX2
+
+#ifdef HAS_SPLITUVROW_AVX2
+void SplitUVRow_AVX2(const uint8_t* src_uv,
+                     uint8_t* dst_u,
+                     uint8_t* dst_v,
+                     int width) {
+  asm volatile(
+      "vpcmpeqb    %%ymm5,%%ymm5,%%ymm5          \n"
+      "vpsrlw      $0x8,%%ymm5,%%ymm5            \n"
+      "sub         %1,%2                         \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "vmovdqu     (%0),%%ymm0                   \n"
+      "vmovdqu     0x20(%0),%%ymm1               \n"
+      "lea         0x40(%0),%0                   \n"
+      "vpsrlw      $0x8,%%ymm0,%%ymm2            \n"
+      "vpsrlw      $0x8,%%ymm1,%%ymm3            \n"
+      "vpand       %%ymm5,%%ymm0,%%ymm0          \n"
+      "vpand       %%ymm5,%%ymm1,%%ymm1          \n"
+      "vpackuswb   %%ymm1,%%ymm0,%%ymm0          \n"
+      "vpackuswb   %%ymm3,%%ymm2,%%ymm2          \n"
+      "vpermq      $0xd8,%%ymm0,%%ymm0           \n"
+      "vpermq      $0xd8,%%ymm2,%%ymm2           \n"
+      "vmovdqu     %%ymm0,(%1)                   \n"
+      "vmovdqu     %%ymm2,0x00(%1,%2,1)          \n"
+      "lea         0x20(%1),%1                   \n"
+      "sub         $0x20,%3                      \n"
+      "jg          1b                            \n"
+      "vzeroupper                                \n"
+      : "+r"(src_uv),  // %0
+        "+r"(dst_u),   // %1
+        "+r"(dst_v),   // %2
+        "+r"(width)    // %3
+      :
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm5");
+}
+#endif  // HAS_SPLITUVROW_AVX2
+
+#ifdef HAS_SPLITUVROW_SSE2
+void SplitUVRow_SSE2(const uint8_t* src_uv,
+                     uint8_t* dst_u,
+                     uint8_t* dst_v,
+                     int width) {
+  asm volatile(
+      "pcmpeqb     %%xmm5,%%xmm5                 \n"
+      "psrlw       $0x8,%%xmm5                   \n"
+      "sub         %1,%2                         \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "movdqu      (%0),%%xmm0                   \n"
+      "movdqu      0x10(%0),%%xmm1               \n"
+      "lea         0x20(%0),%0                   \n"
+      "movdqa      %%xmm0,%%xmm2                 \n"
+      "movdqa      %%xmm1,%%xmm3                 \n"
+      "pand        %%xmm5,%%xmm0                 \n"
+      "pand        %%xmm5,%%xmm1                 \n"
+      "packuswb    %%xmm1,%%xmm0                 \n"
+      "psrlw       $0x8,%%xmm2                   \n"
+      "psrlw       $0x8,%%xmm3                   \n"
+      "packuswb    %%xmm3,%%xmm2                 \n"
+      "movdqu      %%xmm0,(%1)                   \n"
+      "movdqu      %%xmm2,0x00(%1,%2,1)          \n"
+      "lea         0x10(%1),%1                   \n"
+      "sub         $0x10,%3                      \n"
+      "jg          1b                            \n"
+      : "+r"(src_uv),  // %0
+        "+r"(dst_u),   // %1
+        "+r"(dst_v),   // %2
+        "+r"(width)    // %3
+      :
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm5");
+}
+#endif  // HAS_SPLITUVROW_SSE2
+
+#ifdef HAS_DETILEROW_SSE2
+void DetileRow_SSE2(const uint8_t* src,
+                    ptrdiff_t src_tile_stride,
+                    uint8_t* dst,
+                    int width) {
+  asm volatile(
+      "1:                                        \n"
+      "movdqu      (%0),%%xmm0                   \n"
+      "sub         $0x10,%2                      \n"
+      "lea         (%0,%3),%0                    \n"
+      "movdqu      %%xmm0,(%1)                   \n"
+      "lea         0x10(%1),%1                   \n"
+      "jg          1b                            \n"
+      : "+r"(src),            // %0
+        "+r"(dst),            // %1
+        "+r"(width)           // %2
+      : "r"(src_tile_stride)  // %3
+      : "cc", "memory", "xmm0");
+}
+#endif  // HAS_DETILEROW_SSE2
+
+#ifdef HAS_DETILESPLITUVROW_SSSE3
+// TODO(greenjustin): Look into generating these constants instead of loading
+// them since this can cause branch mispredicts for fPIC code on 32-bit
+// machines.
+static const uvec8 kDeinterlaceUV = {0, 2, 4, 6, 8, 10, 12, 14,
+                                     1, 3, 5, 7, 9, 11, 13, 15};
+
+// TODO(greenjustin): Research alternatives to pshufb, since pshufb can be very
+// slow on older SSE2 processors.
+void DetileSplitUVRow_SSSE3(const uint8_t* src_uv,
+                            ptrdiff_t src_tile_stride,
+                            uint8_t* dst_u,
+                            uint8_t* dst_v,
+                            int width) {
+  asm volatile(
+      "movdqu      %4,%%xmm1                     \n"
+      "1:                                        \n"
+      "movdqu      (%0),%%xmm0                   \n"
+      "lea         (%0, %5),%0                   \n"
+      "pshufb      %%xmm1,%%xmm0                 \n"
+      "movq        %%xmm0,(%1)                   \n"
+      "lea         0x8(%1),%1                    \n"
+      "movhps      %%xmm0,(%2)                   \n"
+      "lea         0x8(%2),%2                    \n"
+      "sub         $0x10,%3                      \n"
+      "jg          1b                            \n"
+      : "+r"(src_uv),         // %0
+        "+r"(dst_u),          // %1
+        "+r"(dst_v),          // %2
+        "+r"(width)           // %3
+      : "m"(kDeinterlaceUV),  // %4
+        "r"(src_tile_stride)  // %5
+      : "cc", "memory", "xmm0", "xmm1");
+}
+#endif  // HAS_DETILESPLITUVROW_SSSE3
+
+#ifdef HAS_MERGEUVROW_AVX2
+void MergeUVRow_AVX2(const uint8_t* src_u,
+                     const uint8_t* src_v,
+                     uint8_t* dst_uv,
+                     int width) {
+  asm volatile(
+
+      "sub         %0,%1                         \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "vmovdqu     (%0),%%ymm0                   \n"
+      "vmovdqu     0x00(%0,%1,1),%%ymm1          \n"
+      "lea         0x20(%0),%0                   \n"
+      "vpunpcklbw  %%ymm1,%%ymm0,%%ymm2          \n"
+      "vpunpckhbw  %%ymm1,%%ymm0,%%ymm0          \n"
+      "vextractf128 $0x0,%%ymm2,(%2)             \n"
+      "vextractf128 $0x0,%%ymm0,0x10(%2)         \n"
+      "vextractf128 $0x1,%%ymm2,0x20(%2)         \n"
+      "vextractf128 $0x1,%%ymm0,0x30(%2)         \n"
+      "lea         0x40(%2),%2                   \n"
+      "sub         $0x20,%3                      \n"
+      "jg          1b                            \n"
+      "vzeroupper                                \n"
+      : "+r"(src_u),   // %0
+        "+r"(src_v),   // %1
+        "+r"(dst_uv),  // %2
+        "+r"(width)    // %3
+      :
+      : "memory", "cc", "xmm0", "xmm1", "xmm2");
+}
+#endif  // HAS_MERGEUVROW_AVX2
+
+#ifdef HAS_MERGEUVROW_SSE2
+void MergeUVRow_SSE2(const uint8_t* src_u,
+                     const uint8_t* src_v,
+                     uint8_t* dst_uv,
+                     int width) {
+  asm volatile(
+
+      "sub         %0,%1                         \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "movdqu      (%0),%%xmm0                   \n"
+      "movdqu      0x00(%0,%1,1),%%xmm1          \n"
+      "lea         0x10(%0),%0                   \n"
+      "movdqa      %%xmm0,%%xmm2                 \n"
+      "punpcklbw   %%xmm1,%%xmm0                 \n"
+      "punpckhbw   %%xmm1,%%xmm2                 \n"
+      "movdqu      %%xmm0,(%2)                   \n"
+      "movdqu      %%xmm2,0x10(%2)               \n"
+      "lea         0x20(%2),%2                   \n"
+      "sub         $0x10,%3                      \n"
+      "jg          1b                            \n"
+      : "+r"(src_u),   // %0
+        "+r"(src_v),   // %1
+        "+r"(dst_uv),  // %2
+        "+r"(width)    // %3
+      :
+      : "memory", "cc", "xmm0", "xmm1", "xmm2");
+}
+#endif  // HAS_MERGEUVROW_SSE2
+
+#ifdef HAS_MERGEUVROW_16_AVX2
+void MergeUVRow_16_AVX2(const uint16_t* src_u,
+                        const uint16_t* src_v,
+                        uint16_t* dst_uv,
+                        int depth,
+                        int width) {
+  depth = 16 - depth;
+  // clang-format off
+  asm volatile (
+      "vmovd       %4,%%xmm3                     \n"
+      "sub         %0,%1                         \n"
+
+    // 16 pixels per loop.
+    LABELALIGN
+      "1:                                        \n"
+      "vmovdqu     (%0),%%ymm0                   \n"
+      "vmovdqu     (%0,%1,1),%%ymm1              \n"
+      "add         $0x20,%0                      \n"
+
+      "vpsllw      %%xmm3,%%ymm0,%%ymm0          \n"
+      "vpsllw      %%xmm3,%%ymm1,%%ymm1          \n"
+      "vpunpcklwd  %%ymm1,%%ymm0,%%ymm2          \n"  // mutates
+      "vpunpckhwd  %%ymm1,%%ymm0,%%ymm0          \n"
+      "vextractf128 $0x0,%%ymm2,(%2)             \n"
+      "vextractf128 $0x0,%%ymm0,0x10(%2)         \n"
+      "vextractf128 $0x1,%%ymm2,0x20(%2)         \n"
+      "vextractf128 $0x1,%%ymm0,0x30(%2)         \n"
+      "add         $0x40,%2                      \n"
+      "sub         $0x10,%3                      \n"
+      "jg          1b                            \n"
+      "vzeroupper                                \n"
+  : "+r"(src_u),   // %0
+    "+r"(src_v),   // %1
+    "+r"(dst_uv),  // %2
+    "+r"(width)    // %3
+  : "r"(depth)     // %4
+  : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3");
+  // clang-format on
+}
+#endif  // HAS_MERGEUVROW_AVX2
+
+#ifdef HAS_SPLITUVROW_16_AVX2
+const uvec8 kSplitUVShuffle16 = {0, 1, 4, 5, 8,  9,  12, 13,
+                                 2, 3, 6, 7, 10, 11, 14, 15};
+void SplitUVRow_16_AVX2(const uint16_t* src_uv,
+                        uint16_t* dst_u,
+                        uint16_t* dst_v,
+                        int depth,
+                        int width) {
+  depth = 16 - depth;
+  // clang-format off
+  asm volatile (
+      "vmovd       %4,%%xmm3                     \n"
+      "vbroadcastf128 %5,%%ymm4                  \n"
+      "sub         %1,%2                         \n"
+
+    // 16 pixels per loop.
+    LABELALIGN
+      "1:                                        \n"
+      "vmovdqu     (%0),%%ymm0                   \n"
+      "vmovdqu     0x20(%0),%%ymm1               \n"
+      "add         $0x40,%0                      \n"
+
+      "vpsrlw      %%xmm3,%%ymm0,%%ymm0          \n"
+      "vpsrlw      %%xmm3,%%ymm1,%%ymm1          \n"
+      "vpshufb     %%ymm4,%%ymm0,%%ymm0          \n"
+      "vpshufb     %%ymm4,%%ymm1,%%ymm1          \n"
+      "vpermq      $0xd8,%%ymm0,%%ymm0           \n"
+      "vpermq      $0xd8,%%ymm1,%%ymm1           \n"
+      "vextractf128 $0x0,%%ymm0,(%1)             \n"
+      "vextractf128 $0x0,%%ymm1,0x10(%1)         \n"
+      "vextractf128 $0x1,%%ymm0,(%1,%2)          \n"
+      "vextractf128 $0x1,%%ymm1,0x10(%1,%2)      \n"
+      "add         $0x20,%1                      \n"
+      "sub         $0x10,%3                      \n"
+      "jg          1b                            \n"
+      "vzeroupper                                \n"
+  : "+r"(src_uv),   // %0
+    "+r"(dst_u),    // %1
+    "+r"(dst_v),    // %2
+    "+r"(width)     // %3
+  : "r"(depth),     // %4
+    "m"(kSplitUVShuffle16) // %5
+  : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4");
+  // clang-format on
+}
+#endif  // HAS_SPLITUVROW_16_AVX2
+
+// Use scale to convert lsb formats to msb, depending how many bits there are:
+// 128 = 9 bits
+// 64 = 10 bits
+// 16 = 12 bits
+// 1 = 16 bits
+#ifdef HAS_MULTIPLYROW_16_AVX2
+void MultiplyRow_16_AVX2(const uint16_t* src_y,
+                         uint16_t* dst_y,
+                         int scale,
+                         int width) {
+  // clang-format off
+  asm volatile (
+      "vmovd       %3,%%xmm3                     \n"
+      "vpunpcklwd  %%xmm3,%%xmm3,%%xmm3          \n"
+      "vbroadcastss %%xmm3,%%ymm3                \n"
+      "sub         %0,%1                         \n"
+
+    // 32 pixels per loop.
+    LABELALIGN
+      "1:                                        \n"
+      "vmovdqu     (%0),%%ymm0                   \n"
+      "vmovdqu     0x20(%0),%%ymm1               \n"
+      "vpmullw     %%ymm3,%%ymm0,%%ymm0          \n"
+      "vpmullw     %%ymm3,%%ymm1,%%ymm1          \n"
+      "vmovdqu     %%ymm0,(%0,%1)                \n"
+      "vmovdqu     %%ymm1,0x20(%0,%1)            \n"
+      "add         $0x40,%0                      \n"
+      "sub         $0x20,%2                      \n"
+      "jg          1b                            \n"
+      "vzeroupper                                \n"
+  : "+r"(src_y),   // %0
+    "+r"(dst_y),   // %1
+    "+r"(width)    // %2
+  : "r"(scale)     // %3
+  : "memory", "cc", "xmm0", "xmm1", "xmm3");
+  // clang-format on
+}
+#endif  // HAS_MULTIPLYROW_16_AVX2
+
+// Use scale to convert msb formats to lsb, depending how many bits there are:
+// 512 = 9 bits
+// 1024 = 10 bits
+// 4096 = 12 bits
+// 65536 = 16 bits
+#ifdef HAS_DIVIDEROW_16_AVX2
+void DivideRow_16_AVX2(const uint16_t* src_y,
+                       uint16_t* dst_y,
+                       int scale,
+                       int width) {
+  // clang-format off
+  asm volatile (
+      "vmovd       %3,%%xmm3                     \n"
+      "vpunpcklwd  %%xmm3,%%xmm3,%%xmm3          \n"
+      "vbroadcastss %%xmm3,%%ymm3                \n"
+      "sub         %0,%1                         \n"
+
+    // 32 pixels per loop.
+    LABELALIGN
+      "1:                                        \n"
+      "vmovdqu     (%0),%%ymm0                   \n"
+      "vmovdqu     0x20(%0),%%ymm1               \n"
+      "vpmulhuw    %%ymm3,%%ymm0,%%ymm0          \n"
+      "vpmulhuw    %%ymm3,%%ymm1,%%ymm1          \n"
+      "vmovdqu     %%ymm0,(%0,%1)                \n"
+      "vmovdqu     %%ymm1,0x20(%0,%1)            \n"
+      "add         $0x40,%0                      \n"
+      "sub         $0x20,%2                      \n"
+      "jg          1b                            \n"
+      "vzeroupper                                \n"
+  : "+r"(src_y),   // %0
+    "+r"(dst_y),   // %1
+    "+r"(width),    // %2
+    "+r"(scale)     // %3
+  :
+  : "memory", "cc", "xmm0", "xmm1", "xmm3");
+  // clang-format on
+}
+#endif  // HAS_MULTIPLYROW_16_AVX2
+
+// Use scale to convert lsb formats to msb, depending how many bits there are:
+// 32768 = 9 bits
+// 16384 = 10 bits
+// 4096 = 12 bits
+// 256 = 16 bits
+void Convert16To8Row_SSSE3(const uint16_t* src_y,
+                           uint8_t* dst_y,
+                           int scale,
+                           int width) {
+  // clang-format off
+  asm volatile (
+      "movd        %3,%%xmm2                     \n"
+      "punpcklwd   %%xmm2,%%xmm2                 \n"
+      "pshufd      $0x0,%%xmm2,%%xmm2            \n"
+
+    // 32 pixels per loop.
+    LABELALIGN
+      "1:                                        \n"
+      "movdqu      (%0),%%xmm0                   \n"
+      "movdqu      0x10(%0),%%xmm1               \n"
+      "add         $0x20,%0                      \n"
+      "pmulhuw     %%xmm2,%%xmm0                 \n"
+      "pmulhuw     %%xmm2,%%xmm1                 \n"
+      "packuswb    %%xmm1,%%xmm0                 \n"
+      "movdqu      %%xmm0,(%1)                   \n"
+      "add         $0x10,%1                      \n"
+      "sub         $0x10,%2                      \n"
+      "jg          1b                            \n"
+  : "+r"(src_y),   // %0
+    "+r"(dst_y),   // %1
+    "+r"(width)    // %2
+  : "r"(scale)     // %3
+  : "memory", "cc", "xmm0", "xmm1", "xmm2");
+  // clang-format on
+}
+
+#ifdef HAS_CONVERT16TO8ROW_AVX2
+void Convert16To8Row_AVX2(const uint16_t* src_y,
+                          uint8_t* dst_y,
+                          int scale,
+                          int width) {
+  // clang-format off
+  asm volatile (
+      "vmovd       %3,%%xmm2                     \n"
+      "vpunpcklwd  %%xmm2,%%xmm2,%%xmm2          \n"
+      "vbroadcastss %%xmm2,%%ymm2                \n"
+
+    // 32 pixels per loop.
+    LABELALIGN
+      "1:                                        \n"
+      "vmovdqu     (%0),%%ymm0                   \n"
+      "vmovdqu     0x20(%0),%%ymm1               \n"
+      "add         $0x40,%0                      \n"
+      "vpmulhuw    %%ymm2,%%ymm0,%%ymm0          \n"
+      "vpmulhuw    %%ymm2,%%ymm1,%%ymm1          \n"
+      "vpackuswb   %%ymm1,%%ymm0,%%ymm0          \n"  // mutates
+      "vpermq      $0xd8,%%ymm0,%%ymm0           \n"
+      "vmovdqu     %%ymm0,(%1)                   \n"
+      "add         $0x20,%1                      \n"
+      "sub         $0x20,%2                      \n"
+      "jg          1b                            \n"
+      "vzeroupper                                \n"
+  : "+r"(src_y),   // %0
+    "+r"(dst_y),   // %1
+    "+r"(width)    // %2
+  : "r"(scale)     // %3
+  : "memory", "cc", "xmm0", "xmm1", "xmm2");
+  // clang-format on
+}
+#endif  // HAS_CONVERT16TO8ROW_AVX2
+
+// Use scale to convert to lsb formats depending how many bits there are:
+// 512 = 9 bits
+// 1024 = 10 bits
+// 4096 = 12 bits
+// TODO(fbarchard): reduce to SSE2
+void Convert8To16Row_SSE2(const uint8_t* src_y,
+                          uint16_t* dst_y,
+                          int scale,
+                          int width) {
+  // clang-format off
+  asm volatile (
+      "movd        %3,%%xmm2                     \n"
+      "punpcklwd   %%xmm2,%%xmm2                 \n"
+      "pshufd      $0x0,%%xmm2,%%xmm2            \n"
+
+    // 32 pixels per loop.
+    LABELALIGN
+      "1:                                        \n"
+      "movdqu      (%0),%%xmm0                   \n"
+      "movdqa      %%xmm0,%%xmm1                 \n"
+      "punpcklbw   %%xmm0,%%xmm0                 \n"
+      "punpckhbw   %%xmm1,%%xmm1                 \n"
+      "add         $0x10,%0                      \n"
+      "pmulhuw     %%xmm2,%%xmm0                 \n"
+      "pmulhuw     %%xmm2,%%xmm1                 \n"
+      "movdqu      %%xmm0,(%1)                   \n"
+      "movdqu      %%xmm1,0x10(%1)               \n"
+      "add         $0x20,%1                      \n"
+      "sub         $0x10,%2                      \n"
+      "jg          1b                            \n"
+  : "+r"(src_y),   // %0
+    "+r"(dst_y),   // %1
+    "+r"(width)    // %2
+  : "r"(scale)     // %3
+  : "memory", "cc", "xmm0", "xmm1", "xmm2");
+  // clang-format on
+}
+
+#ifdef HAS_CONVERT8TO16ROW_AVX2
+void Convert8To16Row_AVX2(const uint8_t* src_y,
+                          uint16_t* dst_y,
+                          int scale,
+                          int width) {
+  // clang-format off
+  asm volatile (
+      "vmovd       %3,%%xmm2                     \n"
+      "vpunpcklwd  %%xmm2,%%xmm2,%%xmm2          \n"
+      "vbroadcastss %%xmm2,%%ymm2                \n"
+
+    // 32 pixels per loop.
+    LABELALIGN
+      "1:                                        \n"
+      "vmovdqu     (%0),%%ymm0                   \n"
+      "vpermq      $0xd8,%%ymm0,%%ymm0           \n"
+      "add         $0x20,%0                      \n"
+      "vpunpckhbw  %%ymm0,%%ymm0,%%ymm1          \n"
+      "vpunpcklbw  %%ymm0,%%ymm0,%%ymm0          \n"
+      "vpmulhuw    %%ymm2,%%ymm0,%%ymm0          \n"
+      "vpmulhuw    %%ymm2,%%ymm1,%%ymm1          \n"
+      "vmovdqu     %%ymm0,(%1)                   \n"
+      "vmovdqu     %%ymm1,0x20(%1)               \n"
+      "add         $0x40,%1                      \n"
+      "sub         $0x20,%2                      \n"
+      "jg          1b                            \n"
+      "vzeroupper                                \n"
+  : "+r"(src_y),   // %0
+    "+r"(dst_y),   // %1
+    "+r"(width)    // %2
+  : "r"(scale)     // %3
+  : "memory", "cc", "xmm0", "xmm1", "xmm2");
+  // clang-format on
+}
+#endif  // HAS_CONVERT8TO16ROW_AVX2
+
+#ifdef HAS_SPLITRGBROW_SSSE3
+// Shuffle table for converting RGB to Planar.
+static const uvec8 kSplitRGBShuffle[9] = {
+    {0u, 3u, 6u, 9u, 12u, 15u, 128u, 128u, 128u, 128u, 128u, 128u, 128u, 128u,
+     128u, 128u},
+    {128u, 128u, 128u, 128u, 128u, 128u, 2u, 5u, 8u, 11u, 14u, 128u, 128u, 128u,
+     128u, 128u},
+    {128u, 128u, 128u, 128u, 128u, 128u, 128u, 128u, 128u, 128u, 128u, 1u, 4u,
+     7u, 10u, 13u},
+    {1u, 4u, 7u, 10u, 13u, 128u, 128u, 128u, 128u, 128u, 128u, 128u, 128u, 128u,
+     128u, 128u},
+    {128u, 128u, 128u, 128u, 128u, 0u, 3u, 6u, 9u, 12u, 15u, 128u, 128u, 128u,
+     128u, 128u},
+    {128u, 128u, 128u, 128u, 128u, 128u, 128u, 128u, 128u, 128u, 128u, 2u, 5u,
+     8u, 11u, 14u},
+    {2u, 5u, 8u, 11u, 14u, 128u, 128u, 128u, 128u, 128u, 128u, 128u, 128u, 128u,
+     128u, 128u},
+    {128u, 128u, 128u, 128u, 128u, 1u, 4u, 7u, 10u, 13u, 128u, 128u, 128u, 128u,
+     128u, 128u},
+    {128u, 128u, 128u, 128u, 128u, 128u, 128u, 128u, 128u, 128u, 0u, 3u, 6u, 9u,
+     12u, 15u}};
+
+void SplitRGBRow_SSSE3(const uint8_t* src_rgb,
+                       uint8_t* dst_r,
+                       uint8_t* dst_g,
+                       uint8_t* dst_b,
+                       int width) {
+  asm volatile(
+
+      LABELALIGN
+      "1:                                        \n"
+      "movdqu      (%0),%%xmm0                   \n"
+      "movdqu      0x10(%0),%%xmm1               \n"
+      "movdqu      0x20(%0),%%xmm2               \n"
+      "pshufb      0(%5), %%xmm0                 \n"
+      "pshufb      16(%5), %%xmm1                \n"
+      "pshufb      32(%5), %%xmm2                \n"
+      "por         %%xmm1,%%xmm0                 \n"
+      "por         %%xmm2,%%xmm0                 \n"
+      "movdqu      %%xmm0,(%1)                   \n"
+      "lea         0x10(%1),%1                   \n"
+
+      "movdqu      (%0),%%xmm0                   \n"
+      "movdqu      0x10(%0),%%xmm1               \n"
+      "movdqu      0x20(%0),%%xmm2               \n"
+      "pshufb      48(%5),%%xmm0                 \n"
+      "pshufb      64(%5),%%xmm1                 \n"
+      "pshufb      80(%5), %%xmm2                \n"
+      "por         %%xmm1,%%xmm0                 \n"
+      "por         %%xmm2,%%xmm0                 \n"
+      "movdqu      %%xmm0,(%2)                   \n"
+      "lea         0x10(%2),%2                   \n"
+
+      "movdqu      (%0),%%xmm0                   \n"
+      "movdqu      0x10(%0),%%xmm1               \n"
+      "movdqu      0x20(%0),%%xmm2               \n"
+      "pshufb      96(%5), %%xmm0                \n"
+      "pshufb      112(%5), %%xmm1               \n"
+      "pshufb      128(%5), %%xmm2               \n"
+      "por         %%xmm1,%%xmm0                 \n"
+      "por         %%xmm2,%%xmm0                 \n"
+      "movdqu      %%xmm0,(%3)                   \n"
+      "lea         0x10(%3),%3                   \n"
+      "lea         0x30(%0),%0                   \n"
+      "sub         $0x10,%4                      \n"
+      "jg          1b                            \n"
+      : "+r"(src_rgb),             // %0
+        "+r"(dst_r),               // %1
+        "+r"(dst_g),               // %2
+        "+r"(dst_b),               // %3
+        "+r"(width)                // %4
+      : "r"(&kSplitRGBShuffle[0])  // %5
+      : "memory", "cc", "xmm0", "xmm1", "xmm2");
+}
+#endif  // HAS_SPLITRGBROW_SSSE3
+
+#ifdef HAS_MERGERGBROW_SSSE3
+// Shuffle table for converting Planar to RGB.
+static const uvec8 kMergeRGBShuffle[9] = {
+    {0u, 128u, 128u, 1u, 128u, 128u, 2u, 128u, 128u, 3u, 128u, 128u, 4u, 128u,
+     128u, 5u},
+    {128u, 0u, 128u, 128u, 1u, 128u, 128u, 2u, 128u, 128u, 3u, 128u, 128u, 4u,
+     128u, 128u},
+    {128u, 128u, 0u, 128u, 128u, 1u, 128u, 128u, 2u, 128u, 128u, 3u, 128u, 128u,
+     4u, 128u},
+    {128u, 128u, 6u, 128u, 128u, 7u, 128u, 128u, 8u, 128u, 128u, 9u, 128u, 128u,
+     10u, 128u},
+    {5u, 128u, 128u, 6u, 128u, 128u, 7u, 128u, 128u, 8u, 128u, 128u, 9u, 128u,
+     128u, 10u},
+    {128u, 5u, 128u, 128u, 6u, 128u, 128u, 7u, 128u, 128u, 8u, 128u, 128u, 9u,
+     128u, 128u},
+    {128u, 11u, 128u, 128u, 12u, 128u, 128u, 13u, 128u, 128u, 14u, 128u, 128u,
+     15u, 128u, 128u},
+    {128u, 128u, 11u, 128u, 128u, 12u, 128u, 128u, 13u, 128u, 128u, 14u, 128u,
+     128u, 15u, 128u},
+    {10u, 128u, 128u, 11u, 128u, 128u, 12u, 128u, 128u, 13u, 128u, 128u, 14u,
+     128u, 128u, 15u}};
+
+void MergeRGBRow_SSSE3(const uint8_t* src_r,
+                       const uint8_t* src_g,
+                       const uint8_t* src_b,
+                       uint8_t* dst_rgb,
+                       int width) {
+  asm volatile(
+
+      LABELALIGN
+      "1:                                        \n"
+      "movdqu      (%0),%%xmm0                   \n"
+      "movdqu      (%1),%%xmm1                   \n"
+      "movdqu      (%2),%%xmm2                   \n"
+      "pshufb      (%5), %%xmm0                  \n"
+      "pshufb      16(%5), %%xmm1                \n"
+      "pshufb      32(%5), %%xmm2                \n"
+      "por         %%xmm1,%%xmm0                 \n"
+      "por         %%xmm2,%%xmm0                 \n"
+      "movdqu      %%xmm0,(%3)                   \n"
+
+      "movdqu      (%0),%%xmm0                   \n"
+      "movdqu      (%1),%%xmm1                   \n"
+      "movdqu      (%2),%%xmm2                   \n"
+      "pshufb      48(%5), %%xmm0                \n"
+      "pshufb      64(%5), %%xmm1                \n"
+      "pshufb      80(%5), %%xmm2                \n"
+      "por         %%xmm1,%%xmm0                 \n"
+      "por         %%xmm2,%%xmm0                 \n"
+      "movdqu      %%xmm0,16(%3)                 \n"
+
+      "movdqu      (%0),%%xmm0                   \n"
+      "movdqu      (%1),%%xmm1                   \n"
+      "movdqu      (%2),%%xmm2                   \n"
+      "pshufb      96(%5), %%xmm0                \n"
+      "pshufb      112(%5), %%xmm1               \n"
+      "pshufb      128(%5), %%xmm2               \n"
+      "por         %%xmm1,%%xmm0                 \n"
+      "por         %%xmm2,%%xmm0                 \n"
+      "movdqu      %%xmm0,32(%3)                 \n"
+
+      "lea         0x10(%0),%0                   \n"
+      "lea         0x10(%1),%1                   \n"
+      "lea         0x10(%2),%2                   \n"
+      "lea         0x30(%3),%3                   \n"
+      "sub         $0x10,%4                      \n"
+      "jg          1b                            \n"
+      : "+r"(src_r),               // %0
+        "+r"(src_g),               // %1
+        "+r"(src_b),               // %2
+        "+r"(dst_rgb),             // %3
+        "+r"(width)                // %4
+      : "r"(&kMergeRGBShuffle[0])  // %5
+      : "memory", "cc", "xmm0", "xmm1", "xmm2");
+}
+#endif  // HAS_MERGERGBROW_SSSE3
+
+#ifdef HAS_MERGEARGBROW_SSE2
+void MergeARGBRow_SSE2(const uint8_t* src_r,
+                       const uint8_t* src_g,
+                       const uint8_t* src_b,
+                       const uint8_t* src_a,
+                       uint8_t* dst_argb,
+                       int width) {
+  asm volatile(
+
+      "sub         %0,%1                         \n"
+      "sub         %0,%2                         \n"
+      "sub         %0,%3                         \n"
+
+      LABELALIGN
+      "1:                                        \n"
+
+      "movq        (%0,%2),%%xmm0                \n"  // B
+      "movq        (%0),%%xmm1                   \n"  // R
+      "movq        (%0,%1),%%xmm2                \n"  // G
+      "punpcklbw   %%xmm1,%%xmm0                 \n"  // BR
+      "movq        (%0,%3),%%xmm1                \n"  // A
+      "punpcklbw   %%xmm1,%%xmm2                 \n"  // GA
+      "movdqa      %%xmm0,%%xmm1                 \n"  // BR
+      "punpckhbw   %%xmm2,%%xmm1                 \n"  // BGRA (hi)
+      "punpcklbw   %%xmm2,%%xmm0                 \n"  // BGRA (lo)
+      "movdqu      %%xmm0,(%4)                   \n"
+      "movdqu      %%xmm1,16(%4)                 \n"
+
+      "lea         8(%0),%0                      \n"
+      "lea         32(%4),%4                     \n"
+      "sub         $0x8,%5                       \n"
+      "jg          1b                            \n"
+      : "+r"(src_r),     // %0
+        "+r"(src_g),     // %1
+        "+r"(src_b),     // %2
+        "+r"(src_a),     // %3
+        "+r"(dst_argb),  // %4
+        "+r"(width)      // %5
+      :
+      : "memory", "cc", "xmm0", "xmm1", "xmm2");
+}
+#endif
+
+#ifdef HAS_MERGEXRGBROW_SSE2
+void MergeXRGBRow_SSE2(const uint8_t* src_r,
+                       const uint8_t* src_g,
+                       const uint8_t* src_b,
+                       uint8_t* dst_argb,
+                       int width) {
+  asm volatile(
+
+      LABELALIGN
+      "1:                                        \n"
+
+      "movq        (%2),%%xmm0                   \n"  // B
+      "movq        (%0),%%xmm1                   \n"  // R
+      "movq        (%1),%%xmm2                   \n"  // G
+      "punpcklbw   %%xmm1,%%xmm0                 \n"  // BR
+      "pcmpeqd     %%xmm1,%%xmm1                 \n"  // A(255)
+      "punpcklbw   %%xmm1,%%xmm2                 \n"  // GA
+      "movdqa      %%xmm0,%%xmm1                 \n"  // BR
+      "punpckhbw   %%xmm2,%%xmm1                 \n"  // BGRA (hi)
+      "punpcklbw   %%xmm2,%%xmm0                 \n"  // BGRA (lo)
+      "movdqu      %%xmm0,(%3)                   \n"
+      "movdqu      %%xmm1,16(%3)                 \n"
+
+      "lea         8(%0),%0                      \n"
+      "lea         8(%1),%1                      \n"
+      "lea         8(%2),%2                      \n"
+      "lea         32(%3),%3                     \n"
+      "sub         $0x8,%4                       \n"
+      "jg          1b                            \n"
+      : "+r"(src_r),     // %0
+        "+r"(src_g),     // %1
+        "+r"(src_b),     // %2
+        "+r"(dst_argb),  // %3
+        "+r"(width)      // %4
+      :
+      : "memory", "cc", "xmm0", "xmm1", "xmm2");
+}
+#endif  // HAS_MERGEARGBROW_SSE2
+
+#ifdef HAS_MERGEARGBROW_AVX2
+void MergeARGBRow_AVX2(const uint8_t* src_r,
+                       const uint8_t* src_g,
+                       const uint8_t* src_b,
+                       const uint8_t* src_a,
+                       uint8_t* dst_argb,
+                       int width) {
+  asm volatile(
+
+      "sub         %0,%1                         \n"
+      "sub         %0,%2                         \n"
+      "sub         %0,%3                         \n"
+
+      LABELALIGN
+      "1:                                        \n"
+
+      "vmovdqu     (%0,%2),%%xmm0                \n"  // B
+      "vmovdqu     (%0,%1),%%xmm1                \n"  // R
+      "vinserti128 $1,(%0),%%ymm0,%%ymm0         \n"  // G
+      "vinserti128 $1,(%0,%3),%%ymm1,%%ymm1      \n"  // A
+      "vpunpckhbw  %%ymm1,%%ymm0,%%ymm2          \n"
+      "vpunpcklbw  %%ymm1,%%ymm0,%%ymm0          \n"
+      "vperm2i128  $0x31,%%ymm2,%%ymm0,%%ymm1    \n"
+      "vperm2i128  $0x20,%%ymm2,%%ymm0,%%ymm0    \n"
+      "vpunpckhwd  %%ymm1,%%ymm0,%%ymm2          \n"
+      "vpunpcklwd  %%ymm1,%%ymm0,%%ymm0          \n"
+      "vperm2i128  $0x31,%%ymm2,%%ymm0,%%ymm1    \n"
+      "vperm2i128  $0x20,%%ymm2,%%ymm0,%%ymm0    \n"
+      "vmovdqu     %%ymm0,(%4)                   \n"  // First 8
+      "vmovdqu     %%ymm1,32(%4)                 \n"  // Next 8
+
+      "lea         16(%0),%0                     \n"
+      "lea         64(%4),%4                     \n"
+      "sub         $0x10,%5                      \n"
+      "jg          1b                            \n"
+      "vzeroupper                                \n"
+      : "+r"(src_r),     // %0
+        "+r"(src_g),     // %1
+        "+r"(src_b),     // %2
+        "+r"(src_a),     // %3
+        "+r"(dst_argb),  // %4
+        "+r"(width)      // %5
+      :
+      : "memory", "cc", "xmm0", "xmm1", "xmm2");
+}
+#endif
+
+#ifdef HAS_MERGEXRGBROW_AVX2
+void MergeXRGBRow_AVX2(const uint8_t* src_r,
+                       const uint8_t* src_g,
+                       const uint8_t* src_b,
+                       uint8_t* dst_argb,
+                       int width) {
+  asm volatile(
+
+      LABELALIGN
+      "1:                                        \n"
+
+      "vmovdqu     (%2),%%xmm0                   \n"  // B
+      "vpcmpeqd    %%ymm1,%%ymm1,%%ymm1          \n"  // A(255)
+      "vinserti128 $0,(%1),%%ymm1,%%ymm1         \n"  // R
+      "vinserti128 $1,(%0),%%ymm0,%%ymm0         \n"  // G
+      "vpunpckhbw  %%ymm1,%%ymm0,%%ymm2          \n"
+      "vpunpcklbw  %%ymm1,%%ymm0,%%ymm0          \n"
+      "vperm2i128  $0x31,%%ymm2,%%ymm0,%%ymm1    \n"
+      "vperm2i128  $0x20,%%ymm2,%%ymm0,%%ymm0    \n"
+      "vpunpckhwd  %%ymm1,%%ymm0,%%ymm2          \n"
+      "vpunpcklwd  %%ymm1,%%ymm0,%%ymm0          \n"
+      "vperm2i128  $0x31,%%ymm2,%%ymm0,%%ymm1    \n"
+      "vperm2i128  $0x20,%%ymm2,%%ymm0,%%ymm0    \n"
+      "vmovdqu     %%ymm0,(%3)                   \n"  // First 8
+      "vmovdqu     %%ymm1,32(%3)                 \n"  // Next 8
+
+      "lea         16(%0),%0                     \n"
+      "lea         16(%1),%1                     \n"
+      "lea         16(%2),%2                     \n"
+      "lea         64(%3),%3                     \n"
+      "sub         $0x10,%4                      \n"
+      "jg          1b                            \n"
+      "vzeroupper                                \n"
+      : "+r"(src_r),     // %0
+        "+r"(src_g),     // %1
+        "+r"(src_b),     // %2
+        "+r"(dst_argb),  // %3
+        "+rm"(width)     // %4
+      :
+      : "memory", "cc", "xmm0", "xmm1", "xmm2");
+}
+#endif  // HAS_MERGEARGBROW_AVX2
+
+#ifdef HAS_SPLITARGBROW_SSE2
+void SplitARGBRow_SSE2(const uint8_t* src_argb,
+                       uint8_t* dst_r,
+                       uint8_t* dst_g,
+                       uint8_t* dst_b,
+                       uint8_t* dst_a,
+                       int width) {
+  asm volatile(
+
+      "sub         %1,%2                         \n"
+      "sub         %1,%3                         \n"
+      "sub         %1,%4                         \n"
+
+      LABELALIGN
+      "1:                                        \n"
+
+      "movdqu      (%0),%%xmm0                   \n"  // 00-0F
+      "movdqu      16(%0),%%xmm1                 \n"  // 10-1F
+      "movdqa      %%xmm0,%%xmm2                 \n"
+      "punpcklqdq  %%xmm1,%%xmm0                 \n"  // 00-07 10-17
+      "punpckhqdq  %%xmm1,%%xmm2                 \n"  // 08-0F 18-1F
+      "movdqa      %%xmm0,%%xmm1                 \n"
+      "punpcklbw   %%xmm2,%%xmm0                 \n"  // 08192A3B4C5D6E7F (lo)
+      "punpckhbw   %%xmm2,%%xmm1                 \n"  // 08192A3B4C5D6E7F (hi)
+      "movdqa      %%xmm0,%%xmm2                 \n"
+      "punpcklqdq  %%xmm1,%%xmm0                 \n"  // 08192A3B08192A3B
+      "punpckhqdq  %%xmm1,%%xmm2                 \n"  // 4C5D6E7F4C5D6E7F
+      "movdqa      %%xmm0,%%xmm1                 \n"
+      "punpcklbw   %%xmm2,%%xmm0                 \n"  // 048C159D26AE37BF (lo)
+      "punpckhbw   %%xmm2,%%xmm1                 \n"  // 048C159D26AE37BF (hi)
+      "movdqa      %%xmm0,%%xmm2                 \n"
+      "punpckldq   %%xmm1,%%xmm0                 \n"  // 048C048C159D159D (BG)
+      "punpckhdq   %%xmm1,%%xmm2                 \n"  // 26AE26AE37BF37BF (RA)
+      "movlps      %%xmm0,(%1,%3)                \n"  // B
+      "movhps      %%xmm0,(%1,%2)                \n"  // G
+      "movlps      %%xmm2,(%1)                   \n"  // R
+      "movhps      %%xmm2,(%1,%4)                \n"  // A
+
+      "lea         32(%0),%0                     \n"
+      "lea         8(%1),%1                      \n"
+      "sub         $0x8,%5                       \n"
+      "jg          1b                            \n"
+      : "+r"(src_argb),  // %0
+        "+r"(dst_r),     // %1
+        "+r"(dst_g),     // %2
+        "+r"(dst_b),     // %3
+        "+r"(dst_a),     // %4
+        "+rm"(width)     // %5
+      :
+      : "memory", "cc", "xmm0", "xmm1", "xmm2");
+}
+#endif
+
+#ifdef HAS_SPLITXRGBROW_SSE2
+void SplitXRGBRow_SSE2(const uint8_t* src_argb,
+                       uint8_t* dst_r,
+                       uint8_t* dst_g,
+                       uint8_t* dst_b,
+                       int width) {
+  asm volatile(
+
+      LABELALIGN
+      "1:                                        \n"
+
+      "movdqu      (%0),%%xmm0                   \n"  // 00-0F
+      "movdqu      16(%0),%%xmm1                 \n"  // 10-1F
+      "movdqa      %%xmm0,%%xmm2                 \n"
+      "punpcklqdq  %%xmm1,%%xmm0                 \n"  // 00-07 10-17
+      "punpckhqdq  %%xmm1,%%xmm2                 \n"  // 08-0F 18-1F
+      "movdqa      %%xmm0,%%xmm1                 \n"
+      "punpcklbw   %%xmm2,%%xmm0                 \n"  // 08192A3B4C5D6E7F (lo)
+      "punpckhbw   %%xmm2,%%xmm1                 \n"  // 08192A3B4C5D6E7F (hi)
+      "movdqa      %%xmm0,%%xmm2                 \n"
+      "punpcklqdq  %%xmm1,%%xmm0                 \n"  // 08192A3B08192A3B
+      "punpckhqdq  %%xmm1,%%xmm2                 \n"  // 4C5D6E7F4C5D6E7F
+      "movdqa      %%xmm0,%%xmm1                 \n"
+      "punpcklbw   %%xmm2,%%xmm0                 \n"  // 048C159D26AE37BF (lo)
+      "punpckhbw   %%xmm2,%%xmm1                 \n"  // 048C159D26AE37BF (hi)
+      "movdqa      %%xmm0,%%xmm2                 \n"
+      "punpckldq   %%xmm1,%%xmm0                 \n"  // 048C048C159D159D (BG)
+      "punpckhdq   %%xmm1,%%xmm2                 \n"  // 26AE26AE37BF37BF (RA)
+      "movlps      %%xmm0,(%3)                   \n"  // B
+      "movhps      %%xmm0,(%2)                   \n"  // G
+      "movlps      %%xmm2,(%1)                   \n"  // R
+
+      "lea         32(%0),%0                     \n"
+      "lea         8(%1),%1                      \n"
+      "lea         8(%2),%2                      \n"
+      "lea         8(%3),%3                      \n"
+      "sub         $0x8,%4                       \n"
+      "jg          1b                            \n"
+      : "+r"(src_argb),  // %0
+        "+r"(dst_r),     // %1
+        "+r"(dst_g),     // %2
+        "+r"(dst_b),     // %3
+        "+rm"(width)     // %4
+      :
+      : "memory", "cc", "xmm0", "xmm1", "xmm2");
+}
+#endif
+
+static const uvec8 kShuffleMaskARGBSplit = {0, 4, 8,  12, 1, 5, 9,  13,
+                                            2, 6, 10, 14, 3, 7, 11, 15};
+#ifdef HAS_SPLITARGBROW_SSSE3
+void SplitARGBRow_SSSE3(const uint8_t* src_argb,
+                        uint8_t* dst_r,
+                        uint8_t* dst_g,
+                        uint8_t* dst_b,
+                        uint8_t* dst_a,
+                        int width) {
+  asm volatile(
+
+      "movdqa      %6,%%xmm3                     \n"
+      "sub         %1,%2                         \n"
+      "sub         %1,%3                         \n"
+      "sub         %1,%4                         \n"
+
+      LABELALIGN
+      "1:                                        \n"
+
+      "movdqu      (%0),%%xmm0                   \n"  // 00-0F
+      "movdqu      16(%0),%%xmm1                 \n"  // 10-1F
+      "pshufb      %%xmm3,%%xmm0                 \n"  // 048C159D26AE37BF (lo)
+      "pshufb      %%xmm3,%%xmm1                 \n"  // 048C159D26AE37BF (hi)
+      "movdqa      %%xmm0,%%xmm2                 \n"
+      "punpckldq   %%xmm1,%%xmm0                 \n"  // 048C048C159D159D (BG)
+      "punpckhdq   %%xmm1,%%xmm2                 \n"  // 26AE26AE37BF37BF (RA)
+      "movlps      %%xmm0,(%1,%3)                \n"  // B
+      "movhps      %%xmm0,(%1,%2)                \n"  // G
+      "movlps      %%xmm2,(%1)                   \n"  // R
+      "movhps      %%xmm2,(%1,%4)                \n"  // A
+
+      "lea         32(%0),%0                     \n"
+      "lea         8(%1),%1                      \n"
+      "subl        $0x8,%5                       \n"
+      "jg          1b                            \n"
+      : "+r"(src_argb),  // %0
+        "+r"(dst_r),     // %1
+        "+r"(dst_g),     // %2
+        "+r"(dst_b),     // %3
+        "+r"(dst_a),     // %4
+#if defined(__i386__)
+        "+m"(width)  // %5
+#else
+        "+rm"(width)          // %5
+#endif
+      : "m"(kShuffleMaskARGBSplit)  // %6
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3");
+}
+#endif
+
+#ifdef HAS_SPLITXRGBROW_SSSE3
+void SplitXRGBRow_SSSE3(const uint8_t* src_argb,
+                        uint8_t* dst_r,
+                        uint8_t* dst_g,
+                        uint8_t* dst_b,
+                        int width) {
+  asm volatile(
+
+      "movdqa      %5,%%xmm3                     \n"
+
+      LABELALIGN
+      "1:                                        \n"
+
+      "movdqu      (%0),%%xmm0                   \n"  // 00-0F
+      "movdqu      16(%0),%%xmm1                 \n"  // 10-1F
+      "pshufb      %%xmm3,%%xmm0                 \n"  // 048C159D26AE37BF (lo)
+      "pshufb      %%xmm3,%%xmm1                 \n"  // 048C159D26AE37BF (hi)
+      "movdqa      %%xmm0,%%xmm2                 \n"
+      "punpckldq   %%xmm1,%%xmm0                 \n"  // 048C048C159D159D (BG)
+      "punpckhdq   %%xmm1,%%xmm2                 \n"  // 26AE26AE37BF37BF (RA)
+      "movlps      %%xmm0,(%3)                   \n"  // B
+      "movhps      %%xmm0,(%2)                   \n"  // G
+      "movlps      %%xmm2,(%1)                   \n"  // R
+
+      "lea         32(%0),%0                     \n"
+      "lea         8(%1),%1                      \n"
+      "lea         8(%2),%2                      \n"
+      "lea         8(%3),%3                      \n"
+      "sub         $0x8,%4                       \n"
+      "jg          1b                            \n"
+      : "+r"(src_argb),             // %0
+        "+r"(dst_r),                // %1
+        "+r"(dst_g),                // %2
+        "+r"(dst_b),                // %3
+        "+r"(width)                 // %4
+      : "m"(kShuffleMaskARGBSplit)  // %5
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3");
+}
+#endif
+
+#ifdef HAS_SPLITARGBROW_AVX2
+static const ulvec32 kShuffleMaskARGBPermute = {0, 4, 1, 5, 2, 6, 3, 7};
+void SplitARGBRow_AVX2(const uint8_t* src_argb,
+                       uint8_t* dst_r,
+                       uint8_t* dst_g,
+                       uint8_t* dst_b,
+                       uint8_t* dst_a,
+                       int width) {
+  asm volatile(
+
+      "sub         %1,%2                         \n"
+      "sub         %1,%3                         \n"
+      "sub         %1,%4                         \n"
+      "vmovdqa     %7,%%ymm3                     \n"
+      "vbroadcastf128 %6,%%ymm4                  \n"
+
+      LABELALIGN
+      "1:                                        \n"
+
+      "vmovdqu     (%0),%%xmm0                   \n"  // 00-0F
+      "vmovdqu     16(%0),%%xmm1                 \n"  // 10-1F
+      "vinserti128 $1,32(%0),%%ymm0,%%ymm0       \n"  // 00-0F 20-2F
+      "vinserti128 $1,48(%0),%%ymm1,%%ymm1       \n"  // 10-1F 30-3F
+      "vpshufb     %%ymm4,%%ymm0,%%ymm0          \n"
+      "vpshufb     %%ymm4,%%ymm1,%%ymm1          \n"
+      "vpermd      %%ymm0,%%ymm3,%%ymm0          \n"
+      "vpermd      %%ymm1,%%ymm3,%%ymm1          \n"
+      "vpunpckhdq  %%ymm1,%%ymm0,%%ymm2          \n"  // GA
+      "vpunpckldq  %%ymm1,%%ymm0,%%ymm0          \n"  // BR
+      "vmovdqu     %%xmm0,(%1,%3)                \n"  // B
+      "vextracti128 $1,%%ymm0,(%1)               \n"  // R
+      "vmovdqu     %%xmm2,(%1,%2)                \n"  // G
+      "vextracti128 $1,%%ymm2,(%1,%4)            \n"  // A
+      "lea         64(%0),%0                     \n"
+      "lea         16(%1),%1                     \n"
+      "subl        $0x10,%5                      \n"
+      "jg          1b                            \n"
+      "vzeroupper                                \n"
+      : "+r"(src_argb),  // %0
+        "+r"(dst_r),     // %1
+        "+r"(dst_g),     // %2
+        "+r"(dst_b),     // %3
+        "+r"(dst_a),     // %4
+#if defined(__i386__)
+        "+m"(width)  // %5
+#else
+        "+rm"(width)          // %5
+#endif
+      : "m"(kShuffleMaskARGBSplit),   // %6
+        "m"(kShuffleMaskARGBPermute)  // %7
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4");
+}
+#endif
+
+#ifdef HAS_SPLITXRGBROW_AVX2
+void SplitXRGBRow_AVX2(const uint8_t* src_argb,
+                       uint8_t* dst_r,
+                       uint8_t* dst_g,
+                       uint8_t* dst_b,
+                       int width) {
+  asm volatile(
+
+      "vmovdqa     %6,%%ymm3                     \n"
+      "vbroadcastf128 %5,%%ymm4                  \n"
+
+      LABELALIGN
+      "1:                                        \n"
+
+      "vmovdqu     (%0),%%xmm0                   \n"  // 00-0F
+      "vmovdqu     16(%0),%%xmm1                 \n"  // 10-1F
+      "vinserti128 $1,32(%0),%%ymm0,%%ymm0       \n"  // 00-0F 20-2F
+      "vinserti128 $1,48(%0),%%ymm1,%%ymm1       \n"  // 10-1F 30-3F
+      "vpshufb     %%ymm4,%%ymm0,%%ymm0          \n"
+      "vpshufb     %%ymm4,%%ymm1,%%ymm1          \n"
+      "vpermd      %%ymm0,%%ymm3,%%ymm0          \n"
+      "vpermd      %%ymm1,%%ymm3,%%ymm1          \n"
+      "vpunpckhdq  %%ymm1,%%ymm0,%%ymm2          \n"  // GA
+      "vpunpckldq  %%ymm1,%%ymm0,%%ymm0          \n"  // BR
+      "vmovdqu     %%xmm0,(%3)                   \n"  // B
+      "vextracti128 $1,%%ymm0,(%1)               \n"  // R
+      "vmovdqu     %%xmm2,(%2)                   \n"  // G
+
+      "lea         64(%0),%0                     \n"
+      "lea         16(%1),%1                     \n"
+      "lea         16(%2),%2                     \n"
+      "lea         16(%3),%3                     \n"
+      "sub         $0x10,%4                      \n"
+      "jg          1b                            \n"
+      "vzeroupper                                \n"
+      : "+r"(src_argb),               // %0
+        "+r"(dst_r),                  // %1
+        "+r"(dst_g),                  // %2
+        "+r"(dst_b),                  // %3
+        "+r"(width)                   // %4
+      : "m"(kShuffleMaskARGBSplit),   // %5
+        "m"(kShuffleMaskARGBPermute)  // %6
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4");
+}
+#endif
+
+#ifdef HAS_MERGEXR30ROW_AVX2
+void MergeXR30Row_AVX2(const uint16_t* src_r,
+                       const uint16_t* src_g,
+                       const uint16_t* src_b,
+                       uint8_t* dst_ar30,
+                       int depth,
+                       int width) {
+  int shift = depth - 10;
+  asm volatile(
+
+      "sub         %0,%1                         \n"
+      "sub         %0,%2                         \n"
+      "vpcmpeqb    %%ymm5,%%ymm5,%%ymm5          \n"  // AR30 constants
+      "vpsrlw      $14,%%ymm5,%%ymm5             \n"
+      "vpsllw      $4,%%ymm5,%%ymm5              \n"  // 2 alpha bits
+      "vpcmpeqb    %%ymm6,%%ymm6,%%ymm6          \n"
+      "vpsrlw      $6,%%ymm6,%%ymm6              \n"
+      "vmovd       %5,%%xmm4                     \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "vmovdqu     (%0),%%ymm0                   \n"
+      "vmovdqu     (%0,%1),%%ymm1                \n"
+      "vmovdqu     (%0,%2),%%ymm2                \n"
+      "vpsrlw      %%xmm4,%%ymm0,%%ymm0          \n"
+      "vpsrlw      %%xmm4,%%ymm1,%%ymm1          \n"
+      "vpsrlw      %%xmm4,%%ymm2,%%ymm2          \n"
+      "vpminuw     %%ymm0,%%ymm6,%%ymm0          \n"
+      "vpminuw     %%ymm1,%%ymm6,%%ymm1          \n"
+      "vpminuw     %%ymm2,%%ymm6,%%ymm2          \n"
+      "vpermq      $0xd8,%%ymm0,%%ymm0           \n"
+      "vpermq      $0xd8,%%ymm1,%%ymm1           \n"
+      "vpermq      $0xd8,%%ymm2,%%ymm2           \n"
+      "vpsllw      $0x4,%%ymm0,%%ymm0            \n"  // Shift R to target bit
+      "vpunpckhwd  %%ymm0,%%ymm2,%%ymm3          \n"  // RB
+      "vpunpcklwd  %%ymm0,%%ymm2,%%ymm0          \n"
+      "vpunpckhwd  %%ymm5,%%ymm1,%%ymm2          \n"  // AG
+      "vpunpcklwd  %%ymm5,%%ymm1,%%ymm1          \n"
+      "vpslld      $0xa,%%ymm1,%%ymm1            \n"  // Shift AG to target bit
+      "vpslld      $0xa,%%ymm2,%%ymm2            \n"
+      "vpor        %%ymm1,%%ymm0,%%ymm0          \n"  // Combine
+      "vpor        %%ymm2,%%ymm3,%%ymm3          \n"
+      "vmovdqu     %%ymm0,(%3)                   \n"
+      "vmovdqu     %%ymm3,0x20(%3)               \n"
+      "lea         0x20(%0),%0                   \n"
+      "lea         0x40(%3),%3                   \n"
+      "sub         $0x10,%4                      \n"
+      "jg          1b                            \n"
+      "vzeroupper                                \n"
+      : "+r"(src_r),     // %0
+        "+r"(src_g),     // %1
+        "+r"(src_b),     // %2
+        "+r"(dst_ar30),  // %3
+        "+r"(width)      // %4
+#if defined(__i386__)
+      : "m"(shift)  // %5
+#else
+      : "rm"(shift)           // %5
+#endif
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5");
+}
+#endif
+
+#ifdef HAS_MERGEAR64ROW_AVX2
+static const lvec32 MergeAR64Permute = {0, 4, 2, 6, 1, 5, 3, 7};
+void MergeAR64Row_AVX2(const uint16_t* src_r,
+                       const uint16_t* src_g,
+                       const uint16_t* src_b,
+                       const uint16_t* src_a,
+                       uint16_t* dst_ar64,
+                       int depth,
+                       int width) {
+  int shift = 16 - depth;
+  int mask = (1 << depth) - 1;
+  mask = (mask << 16) + mask;
+  asm volatile(
+
+      "sub         %0,%1                         \n"
+      "sub         %0,%2                         \n"
+      "sub         %0,%3                         \n"
+      "vmovdqa     %8,%%ymm5                     \n"
+      "vmovd       %6,%%xmm6                     \n"
+      "vbroadcastss %7,%%ymm7                    \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "vmovdqu     (%0),%%ymm0                   \n"  // R
+      "vmovdqu     (%0,%1),%%ymm1                \n"  // G
+      "vmovdqu     (%0,%2),%%ymm2                \n"  // B
+      "vmovdqu     (%0,%3),%%ymm3                \n"  // A
+      "vpminuw     %%ymm0,%%ymm7,%%ymm0          \n"
+      "vpminuw     %%ymm1,%%ymm7,%%ymm1          \n"
+      "vpminuw     %%ymm2,%%ymm7,%%ymm2          \n"
+      "vpminuw     %%ymm3,%%ymm7,%%ymm3          \n"
+      "vpsllw      %%xmm6,%%ymm0,%%ymm0          \n"
+      "vpsllw      %%xmm6,%%ymm1,%%ymm1          \n"
+      "vpsllw      %%xmm6,%%ymm2,%%ymm2          \n"
+      "vpsllw      %%xmm6,%%ymm3,%%ymm3          \n"
+      "vpermd      %%ymm0,%%ymm5,%%ymm0          \n"
+      "vpermd      %%ymm1,%%ymm5,%%ymm1          \n"
+      "vpermd      %%ymm2,%%ymm5,%%ymm2          \n"
+      "vpermd      %%ymm3,%%ymm5,%%ymm3          \n"
+      "vpunpcklwd  %%ymm1,%%ymm2,%%ymm4          \n"  // BG(low)
+      "vpunpckhwd  %%ymm1,%%ymm2,%%ymm1          \n"  // BG(hi)
+      "vpunpcklwd  %%ymm3,%%ymm0,%%ymm2          \n"  // RA(low)
+      "vpunpckhwd  %%ymm3,%%ymm0,%%ymm0          \n"  // RA(hi)
+      "vpunpckldq  %%ymm2,%%ymm4,%%ymm3          \n"  // BGRA(1)
+      "vpunpckhdq  %%ymm2,%%ymm4,%%ymm4          \n"  // BGRA(3)
+      "vpunpckldq  %%ymm0,%%ymm1,%%ymm2          \n"  // BGRA(2)
+      "vpunpckhdq  %%ymm0,%%ymm1,%%ymm1          \n"  // BGRA(4)
+      "vmovdqu     %%ymm3,(%4)                   \n"
+      "vmovdqu     %%ymm2,0x20(%4)               \n"
+      "vmovdqu     %%ymm4,0x40(%4)               \n"
+      "vmovdqu     %%ymm1,0x60(%4)               \n"
+      "lea         0x20(%0),%0                   \n"
+      "lea         0x80(%4),%4                   \n"
+      "subl        $0x10,%5                      \n"
+      "jg          1b                            \n"
+      "vzeroupper                                \n"
+      : "+r"(src_r),     // %0
+        "+r"(src_g),     // %1
+        "+r"(src_b),     // %2
+        "+r"(src_a),     // %3
+        "+r"(dst_ar64),  // %4
+#if defined(__i386__)
+        "+m"(width)  // %5
+#else
+        "+rm"(width)          // %5
+#endif
+      : "m"(shift),            // %6
+        "m"(mask),             // %7
+        "m"(MergeAR64Permute)  // %8
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6",
+        "xmm7");
+}
+#endif
+
+#ifdef HAS_MERGEXR64ROW_AVX2
+void MergeXR64Row_AVX2(const uint16_t* src_r,
+                       const uint16_t* src_g,
+                       const uint16_t* src_b,
+                       uint16_t* dst_ar64,
+                       int depth,
+                       int width) {
+  int shift = 16 - depth;
+  int mask = (1 << depth) - 1;
+  mask = (mask << 16) + mask;
+  asm volatile(
+
+      "sub         %0,%1                         \n"
+      "sub         %0,%2                         \n"
+      "vmovdqa     %7,%%ymm5                     \n"
+      "vmovd       %5,%%xmm6                     \n"
+      "vbroadcastss %6,%%ymm7                    \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "vmovdqu     (%0),%%ymm0                   \n"  // R
+      "vmovdqu     (%0,%1),%%ymm1                \n"  // G
+      "vmovdqu     (%0,%2),%%ymm2                \n"  // B
+      "vpminuw     %%ymm0,%%ymm7,%%ymm0          \n"
+      "vpminuw     %%ymm1,%%ymm7,%%ymm1          \n"
+      "vpminuw     %%ymm2,%%ymm7,%%ymm2          \n"
+      "vpsllw      %%xmm6,%%ymm0,%%ymm0          \n"
+      "vpsllw      %%xmm6,%%ymm1,%%ymm1          \n"
+      "vpsllw      %%xmm6,%%ymm2,%%ymm2          \n"
+      "vpermd      %%ymm0,%%ymm5,%%ymm0          \n"
+      "vpermd      %%ymm1,%%ymm5,%%ymm1          \n"
+      "vpermd      %%ymm2,%%ymm5,%%ymm2          \n"
+      "vpcmpeqb    %%ymm3,%%ymm3,%%ymm3          \n"  // A (0xffff)
+      "vpunpcklwd  %%ymm1,%%ymm2,%%ymm4          \n"  // BG(low)
+      "vpunpckhwd  %%ymm1,%%ymm2,%%ymm1          \n"  // BG(hi)
+      "vpunpcklwd  %%ymm3,%%ymm0,%%ymm2          \n"  // RA(low)
+      "vpunpckhwd  %%ymm3,%%ymm0,%%ymm0          \n"  // RA(hi)
+      "vpunpckldq  %%ymm2,%%ymm4,%%ymm3          \n"  // BGRA(1)
+      "vpunpckhdq  %%ymm2,%%ymm4,%%ymm4          \n"  // BGRA(3)
+      "vpunpckldq  %%ymm0,%%ymm1,%%ymm2          \n"  // BGRA(2)
+      "vpunpckhdq  %%ymm0,%%ymm1,%%ymm1          \n"  // BGRA(4)
+      "vmovdqu     %%ymm3,(%3)                   \n"
+      "vmovdqu     %%ymm2,0x20(%3)               \n"
+      "vmovdqu     %%ymm4,0x40(%3)               \n"
+      "vmovdqu     %%ymm1,0x60(%3)               \n"
+      "lea         0x20(%0),%0                   \n"
+      "lea         0x80(%3),%3                   \n"
+      "subl        $0x10,%4                      \n"
+      "jg          1b                            \n"
+      "vzeroupper                                \n"
+      : "+r"(src_r),           // %0
+        "+r"(src_g),           // %1
+        "+r"(src_b),           // %2
+        "+r"(dst_ar64),        // %3
+        "+r"(width)            // %4
+      : "m"(shift),            // %5
+        "m"(mask),             // %6
+        "m"(MergeAR64Permute)  // %7
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6",
+        "xmm7");
+}
+#endif
+
+#ifdef HAS_MERGEARGB16TO8ROW_AVX2
+static const uvec8 MergeARGB16To8Shuffle = {0, 8,  1, 9,  2, 10, 3, 11,
+                                            4, 12, 5, 13, 6, 14, 7, 15};
+void MergeARGB16To8Row_AVX2(const uint16_t* src_r,
+                            const uint16_t* src_g,
+                            const uint16_t* src_b,
+                            const uint16_t* src_a,
+                            uint8_t* dst_argb,
+                            int depth,
+                            int width) {
+  int shift = depth - 8;
+  asm volatile(
+
+      "sub         %0,%1                         \n"
+      "sub         %0,%2                         \n"
+      "sub         %0,%3                         \n"
+      "vbroadcastf128 %7,%%ymm5                  \n"
+      "vmovd       %6,%%xmm6                     \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "vmovdqu     (%0),%%ymm0                   \n"  // R
+      "vmovdqu     (%0,%1),%%ymm1                \n"  // G
+      "vmovdqu     (%0,%2),%%ymm2                \n"  // B
+      "vmovdqu     (%0,%3),%%ymm3                \n"  // A
+      "vpsrlw      %%xmm6,%%ymm0,%%ymm0          \n"
+      "vpsrlw      %%xmm6,%%ymm1,%%ymm1          \n"
+      "vpsrlw      %%xmm6,%%ymm2,%%ymm2          \n"
+      "vpsrlw      %%xmm6,%%ymm3,%%ymm3          \n"
+      "vpackuswb   %%ymm1,%%ymm2,%%ymm1          \n"  // BG (planar)
+      "vpackuswb   %%ymm3,%%ymm0,%%ymm0          \n"  // RA (planar)
+      "vpshufb     %%ymm5,%%ymm1,%%ymm1          \n"  // BG (interleave)
+      "vpshufb     %%ymm5,%%ymm0,%%ymm0          \n"  // RA (interleave)
+      "vpermq      $0xd8,%%ymm1,%%ymm1           \n"
+      "vpermq      $0xd8,%%ymm0,%%ymm0           \n"
+      "vpunpcklwd  %%ymm0,%%ymm1,%%ymm2          \n"  // BGRA (low)
+      "vpunpckhwd  %%ymm0,%%ymm1,%%ymm0          \n"  // BGRA (hi)
+      "vmovdqu     %%ymm2,(%4)                   \n"
+      "vmovdqu     %%ymm0,0x20(%4)               \n"
+      "lea         0x20(%0),%0                   \n"
+      "lea         0x40(%4),%4                   \n"
+      "subl        $0x10,%5                      \n"
+      "jg          1b                            \n"
+      "vzeroupper                                \n"
+      : "+r"(src_r),     // %0
+        "+r"(src_g),     // %1
+        "+r"(src_b),     // %2
+        "+r"(src_a),     // %3
+        "+r"(dst_argb),  // %4
+#if defined(__i386__)
+        "+m"(width)  // %5
+#else
+        "+rm"(width)          // %5
+#endif
+      : "m"(shift),                 // %6
+        "m"(MergeARGB16To8Shuffle)  // %7
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6");
+}
+#endif
+
+#ifdef HAS_MERGEXRGB16TO8ROW_AVX2
+void MergeXRGB16To8Row_AVX2(const uint16_t* src_r,
+                            const uint16_t* src_g,
+                            const uint16_t* src_b,
+                            uint8_t* dst_argb,
+                            int depth,
+                            int width) {
+  int shift = depth - 8;
+  asm volatile(
+
+      "sub         %0,%1                         \n"
+      "sub         %0,%2                         \n"
+      "vbroadcastf128 %6,%%ymm5                  \n"
+      "vmovd       %5,%%xmm6                     \n"
+      "vpcmpeqb    %%ymm3,%%ymm3,%%ymm3          \n"
+      "vpsrlw      $8,%%ymm3,%%ymm3              \n"  // A (0xff)
+
+      LABELALIGN
+      "1:                                        \n"
+      "vmovdqu     (%0),%%ymm0                   \n"  // R
+      "vmovdqu     (%0,%1),%%ymm1                \n"  // G
+      "vmovdqu     (%0,%2),%%ymm2                \n"  // B
+      "vpsrlw      %%xmm6,%%ymm0,%%ymm0          \n"
+      "vpsrlw      %%xmm6,%%ymm1,%%ymm1          \n"
+      "vpsrlw      %%xmm6,%%ymm2,%%ymm2          \n"
+      "vpackuswb   %%ymm1,%%ymm2,%%ymm1          \n"  // BG (planar)
+      "vpackuswb   %%ymm3,%%ymm0,%%ymm0          \n"  // RA (planar)
+      "vpshufb     %%ymm5,%%ymm1,%%ymm1          \n"  // BG (interleave)
+      "vpshufb     %%ymm5,%%ymm0,%%ymm0          \n"  // RA (interleave)
+      "vpermq      $0xd8,%%ymm1,%%ymm1           \n"
+      "vpermq      $0xd8,%%ymm0,%%ymm0           \n"
+      "vpunpcklwd  %%ymm0,%%ymm1,%%ymm2          \n"  // BGRA (low)
+      "vpunpckhwd  %%ymm0,%%ymm1,%%ymm0          \n"  // BGRA (hi)
+      "vmovdqu     %%ymm2,(%3)                   \n"
+      "vmovdqu     %%ymm0,0x20(%3)               \n"
+      "lea         0x20(%0),%0                   \n"
+      "lea         0x40(%3),%3                   \n"
+      "subl        $0x10,%4                      \n"
+      "jg          1b                            \n"
+      "vzeroupper                                \n"
+      : "+r"(src_r),                // %0
+        "+r"(src_g),                // %1
+        "+r"(src_b),                // %2
+        "+r"(dst_argb),             // %3
+        "+r"(width)                 // %4
+      : "m"(shift),                 // %5
+        "m"(MergeARGB16To8Shuffle)  // %6
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6");
+}
+#endif
+
+#ifdef HAS_COPYROW_SSE2
+void CopyRow_SSE2(const uint8_t* src, uint8_t* dst, int width) {
+  asm volatile(
+      "test        $0xf,%0                       \n"
+      "jne         2f                            \n"
+      "test        $0xf,%1                       \n"
+      "jne         2f                            \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "movdqa      (%0),%%xmm0                   \n"
+      "movdqa      0x10(%0),%%xmm1               \n"
+      "lea         0x20(%0),%0                   \n"
+      "movdqa      %%xmm0,(%1)                   \n"
+      "movdqa      %%xmm1,0x10(%1)               \n"
+      "lea         0x20(%1),%1                   \n"
+      "sub         $0x20,%2                      \n"
+      "jg          1b                            \n"
+      "jmp         9f                            \n"
+
+      LABELALIGN
+      "2:                                        \n"
+      "movdqu      (%0),%%xmm0                   \n"
+      "movdqu      0x10(%0),%%xmm1               \n"
+      "lea         0x20(%0),%0                   \n"
+      "movdqu      %%xmm0,(%1)                   \n"
+      "movdqu      %%xmm1,0x10(%1)               \n"
+      "lea         0x20(%1),%1                   \n"
+      "sub         $0x20,%2                      \n"
+      "jg          2b                            \n"
+
+      LABELALIGN "9:                                        \n"
+      : "+r"(src),   // %0
+        "+r"(dst),   // %1
+        "+r"(width)  // %2
+      :
+      : "memory", "cc", "xmm0", "xmm1");
+}
+#endif  // HAS_COPYROW_SSE2
+
+#ifdef HAS_COPYROW_AVX
+void CopyRow_AVX(const uint8_t* src, uint8_t* dst, int width) {
+  asm volatile(
+
+      LABELALIGN
+      "1:                                        \n"
+      "vmovdqu     (%0),%%ymm0                   \n"
+      "vmovdqu     0x20(%0),%%ymm1               \n"
+      "lea         0x40(%0),%0                   \n"
+      "vmovdqu     %%ymm0,(%1)                   \n"
+      "vmovdqu     %%ymm1,0x20(%1)               \n"
+      "lea         0x40(%1),%1                   \n"
+      "sub         $0x40,%2                      \n"
+      "jg          1b                            \n"
+      : "+r"(src),   // %0
+        "+r"(dst),   // %1
+        "+r"(width)  // %2
+      :
+      : "memory", "cc", "xmm0", "xmm1");
+}
+#endif  // HAS_COPYROW_AVX
+
+#ifdef HAS_COPYROW_ERMS
+// Multiple of 1.
+void CopyRow_ERMS(const uint8_t* src, uint8_t* dst, int width) {
+  size_t width_tmp = (size_t)(width);
+  asm volatile(
+
+      "rep         movsb                         \n"
+      : "+S"(src),       // %0
+        "+D"(dst),       // %1
+        "+c"(width_tmp)  // %2
+      :
+      : "memory", "cc");
+}
+#endif  // HAS_COPYROW_ERMS
+
+#ifdef HAS_ARGBCOPYALPHAROW_SSE2
+// width in pixels
+void ARGBCopyAlphaRow_SSE2(const uint8_t* src, uint8_t* dst, int width) {
+  asm volatile(
+      "pcmpeqb     %%xmm0,%%xmm0                 \n"
+      "pslld       $0x18,%%xmm0                  \n"
+      "pcmpeqb     %%xmm1,%%xmm1                 \n"
+      "psrld       $0x8,%%xmm1                   \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "movdqu      (%0),%%xmm2                   \n"
+      "movdqu      0x10(%0),%%xmm3               \n"
+      "lea         0x20(%0),%0                   \n"
+      "movdqu      (%1),%%xmm4                   \n"
+      "movdqu      0x10(%1),%%xmm5               \n"
+      "pand        %%xmm0,%%xmm2                 \n"
+      "pand        %%xmm0,%%xmm3                 \n"
+      "pand        %%xmm1,%%xmm4                 \n"
+      "pand        %%xmm1,%%xmm5                 \n"
+      "por         %%xmm4,%%xmm2                 \n"
+      "por         %%xmm5,%%xmm3                 \n"
+      "movdqu      %%xmm2,(%1)                   \n"
+      "movdqu      %%xmm3,0x10(%1)               \n"
+      "lea         0x20(%1),%1                   \n"
+      "sub         $0x8,%2                       \n"
+      "jg          1b                            \n"
+      : "+r"(src),   // %0
+        "+r"(dst),   // %1
+        "+r"(width)  // %2
+      :
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5");
+}
+#endif  // HAS_ARGBCOPYALPHAROW_SSE2
+
+#ifdef HAS_ARGBCOPYALPHAROW_AVX2
+// width in pixels
+void ARGBCopyAlphaRow_AVX2(const uint8_t* src, uint8_t* dst, int width) {
+  asm volatile(
+      "vpcmpeqb    %%ymm0,%%ymm0,%%ymm0          \n"
+      "vpsrld      $0x8,%%ymm0,%%ymm0            \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "vmovdqu     (%0),%%ymm1                   \n"
+      "vmovdqu     0x20(%0),%%ymm2               \n"
+      "lea         0x40(%0),%0                   \n"
+      "vpblendvb   %%ymm0,(%1),%%ymm1,%%ymm1     \n"
+      "vpblendvb   %%ymm0,0x20(%1),%%ymm2,%%ymm2 \n"
+      "vmovdqu     %%ymm1,(%1)                   \n"
+      "vmovdqu     %%ymm2,0x20(%1)               \n"
+      "lea         0x40(%1),%1                   \n"
+      "sub         $0x10,%2                      \n"
+      "jg          1b                            \n"
+      "vzeroupper                                \n"
+      : "+r"(src),   // %0
+        "+r"(dst),   // %1
+        "+r"(width)  // %2
+      :
+      : "memory", "cc", "xmm0", "xmm1", "xmm2");
+}
+#endif  // HAS_ARGBCOPYALPHAROW_AVX2
+
+#ifdef HAS_ARGBEXTRACTALPHAROW_SSE2
+// width in pixels
+void ARGBExtractAlphaRow_SSE2(const uint8_t* src_argb,
+                              uint8_t* dst_a,
+                              int width) {
+  asm volatile(
+
+      LABELALIGN
+      "1:                                        \n"
+      "movdqu      (%0), %%xmm0                  \n"
+      "movdqu      0x10(%0), %%xmm1              \n"
+      "lea         0x20(%0), %0                  \n"
+      "psrld       $0x18, %%xmm0                 \n"
+      "psrld       $0x18, %%xmm1                 \n"
+      "packssdw    %%xmm1, %%xmm0                \n"
+      "packuswb    %%xmm0, %%xmm0                \n"
+      "movq        %%xmm0,(%1)                   \n"
+      "lea         0x8(%1), %1                   \n"
+      "sub         $0x8, %2                      \n"
+      "jg          1b                            \n"
+      : "+r"(src_argb),  // %0
+        "+r"(dst_a),     // %1
+        "+rm"(width)     // %2
+      :
+      : "memory", "cc", "xmm0", "xmm1");
+}
+#endif  // HAS_ARGBEXTRACTALPHAROW_SSE2
+
+#ifdef HAS_ARGBEXTRACTALPHAROW_AVX2
+static const uvec8 kShuffleAlphaShort_AVX2 = {
+    3u,  128u, 128u, 128u, 7u,  128u, 128u, 128u,
+    11u, 128u, 128u, 128u, 15u, 128u, 128u, 128u};
+
+void ARGBExtractAlphaRow_AVX2(const uint8_t* src_argb,
+                              uint8_t* dst_a,
+                              int width) {
+  asm volatile(
+      "vmovdqa     %3,%%ymm4                     \n"
+      "vbroadcastf128 %4,%%ymm5                  \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "vmovdqu     (%0), %%ymm0                  \n"
+      "vmovdqu     0x20(%0), %%ymm1              \n"
+      "vpshufb     %%ymm5,%%ymm0,%%ymm0          \n"  // vpsrld $0x18, %%ymm0
+      "vpshufb     %%ymm5,%%ymm1,%%ymm1          \n"
+      "vmovdqu     0x40(%0), %%ymm2              \n"
+      "vmovdqu     0x60(%0), %%ymm3              \n"
+      "lea         0x80(%0), %0                  \n"
+      "vpackssdw   %%ymm1, %%ymm0, %%ymm0        \n"  // mutates
+      "vpshufb     %%ymm5,%%ymm2,%%ymm2          \n"
+      "vpshufb     %%ymm5,%%ymm3,%%ymm3          \n"
+      "vpackssdw   %%ymm3, %%ymm2, %%ymm2        \n"  // mutates
+      "vpackuswb   %%ymm2,%%ymm0,%%ymm0          \n"  // mutates.
+      "vpermd      %%ymm0,%%ymm4,%%ymm0          \n"  // unmutate.
+      "vmovdqu     %%ymm0,(%1)                   \n"
+      "lea         0x20(%1),%1                   \n"
+      "sub         $0x20, %2                     \n"
+      "jg          1b                            \n"
+      "vzeroupper                                \n"
+      : "+r"(src_argb),               // %0
+        "+r"(dst_a),                  // %1
+        "+rm"(width)                  // %2
+      : "m"(kPermdARGBToY_AVX),       // %3
+        "m"(kShuffleAlphaShort_AVX2)  // %4
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5");
+}
+#endif  // HAS_ARGBEXTRACTALPHAROW_AVX2
+
+#ifdef HAS_ARGBCOPYYTOALPHAROW_SSE2
+// width in pixels
+void ARGBCopyYToAlphaRow_SSE2(const uint8_t* src, uint8_t* dst, int width) {
+  asm volatile(
+      "pcmpeqb     %%xmm0,%%xmm0                 \n"
+      "pslld       $0x18,%%xmm0                  \n"
+      "pcmpeqb     %%xmm1,%%xmm1                 \n"
+      "psrld       $0x8,%%xmm1                   \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "movq        (%0),%%xmm2                   \n"
+      "lea         0x8(%0),%0                    \n"
+      "punpcklbw   %%xmm2,%%xmm2                 \n"
+      "punpckhwd   %%xmm2,%%xmm3                 \n"
+      "punpcklwd   %%xmm2,%%xmm2                 \n"
+      "movdqu      (%1),%%xmm4                   \n"
+      "movdqu      0x10(%1),%%xmm5               \n"
+      "pand        %%xmm0,%%xmm2                 \n"
+      "pand        %%xmm0,%%xmm3                 \n"
+      "pand        %%xmm1,%%xmm4                 \n"
+      "pand        %%xmm1,%%xmm5                 \n"
+      "por         %%xmm4,%%xmm2                 \n"
+      "por         %%xmm5,%%xmm3                 \n"
+      "movdqu      %%xmm2,(%1)                   \n"
+      "movdqu      %%xmm3,0x10(%1)               \n"
+      "lea         0x20(%1),%1                   \n"
+      "sub         $0x8,%2                       \n"
+      "jg          1b                            \n"
+      : "+r"(src),   // %0
+        "+r"(dst),   // %1
+        "+r"(width)  // %2
+      :
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5");
+}
+#endif  // HAS_ARGBCOPYYTOALPHAROW_SSE2
+
+#ifdef HAS_ARGBCOPYYTOALPHAROW_AVX2
+// width in pixels
+void ARGBCopyYToAlphaRow_AVX2(const uint8_t* src, uint8_t* dst, int width) {
+  asm volatile(
+      "vpcmpeqb    %%ymm0,%%ymm0,%%ymm0          \n"
+      "vpsrld      $0x8,%%ymm0,%%ymm0            \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "vpmovzxbd   (%0),%%ymm1                   \n"
+      "vpmovzxbd   0x8(%0),%%ymm2                \n"
+      "lea         0x10(%0),%0                   \n"
+      "vpslld      $0x18,%%ymm1,%%ymm1           \n"
+      "vpslld      $0x18,%%ymm2,%%ymm2           \n"
+      "vpblendvb   %%ymm0,(%1),%%ymm1,%%ymm1     \n"
+      "vpblendvb   %%ymm0,0x20(%1),%%ymm2,%%ymm2 \n"
+      "vmovdqu     %%ymm1,(%1)                   \n"
+      "vmovdqu     %%ymm2,0x20(%1)               \n"
+      "lea         0x40(%1),%1                   \n"
+      "sub         $0x10,%2                      \n"
+      "jg          1b                            \n"
+      "vzeroupper                                \n"
+      : "+r"(src),   // %0
+        "+r"(dst),   // %1
+        "+r"(width)  // %2
+      :
+      : "memory", "cc", "xmm0", "xmm1", "xmm2");
+}
+#endif  // HAS_ARGBCOPYYTOALPHAROW_AVX2
+
+#ifdef HAS_SETROW_X86
+void SetRow_X86(uint8_t* dst, uint8_t v8, int width) {
+  size_t width_tmp = (size_t)(width >> 2);
+  const uint32_t v32 = v8 * 0x01010101u;  // Duplicate byte to all bytes.
+  asm volatile(
+
+      "rep         stosl                         \n"
+      : "+D"(dst),       // %0
+        "+c"(width_tmp)  // %1
+      : "a"(v32)         // %2
+      : "memory", "cc");
+}
+
+void SetRow_ERMS(uint8_t* dst, uint8_t v8, int width) {
+  size_t width_tmp = (size_t)(width);
+  asm volatile(
+
+      "rep         stosb                         \n"
+      : "+D"(dst),       // %0
+        "+c"(width_tmp)  // %1
+      : "a"(v8)          // %2
+      : "memory", "cc");
+}
+
+void ARGBSetRow_X86(uint8_t* dst_argb, uint32_t v32, int width) {
+  size_t width_tmp = (size_t)(width);
+  asm volatile(
+
+      "rep         stosl                         \n"
+      : "+D"(dst_argb),  // %0
+        "+c"(width_tmp)  // %1
+      : "a"(v32)         // %2
+      : "memory", "cc");
+}
+#endif  // HAS_SETROW_X86
+
+#ifdef HAS_YUY2TOYROW_SSE2
+void YUY2ToYRow_SSE2(const uint8_t* src_yuy2, uint8_t* dst_y, int width) {
+  asm volatile(
+      "pcmpeqb     %%xmm5,%%xmm5                 \n"
+      "psrlw       $0x8,%%xmm5                   \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "movdqu      (%0),%%xmm0                   \n"
+      "movdqu      0x10(%0),%%xmm1               \n"
+      "lea         0x20(%0),%0                   \n"
+      "pand        %%xmm5,%%xmm0                 \n"
+      "pand        %%xmm5,%%xmm1                 \n"
+      "packuswb    %%xmm1,%%xmm0                 \n"
+      "movdqu      %%xmm0,(%1)                   \n"
+      "lea         0x10(%1),%1                   \n"
+      "sub         $0x10,%2                      \n"
+      "jg          1b                            \n"
+      : "+r"(src_yuy2),  // %0
+        "+r"(dst_y),     // %1
+        "+r"(width)      // %2
+      :
+      : "memory", "cc", "xmm0", "xmm1", "xmm5");
+}
+
+void YUY2ToUVRow_SSE2(const uint8_t* src_yuy2,
+                      int stride_yuy2,
+                      uint8_t* dst_u,
+                      uint8_t* dst_v,
+                      int width) {
+  asm volatile(
+      "pcmpeqb     %%xmm5,%%xmm5                 \n"
+      "psrlw       $0x8,%%xmm5                   \n"
+      "sub         %1,%2                         \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "movdqu      (%0),%%xmm0                   \n"
+      "movdqu      0x10(%0),%%xmm1               \n"
+      "movdqu      0x00(%0,%4,1),%%xmm2          \n"
+      "movdqu      0x10(%0,%4,1),%%xmm3          \n"
+      "lea         0x20(%0),%0                   \n"
+      "pavgb       %%xmm2,%%xmm0                 \n"
+      "pavgb       %%xmm3,%%xmm1                 \n"
+      "psrlw       $0x8,%%xmm0                   \n"
+      "psrlw       $0x8,%%xmm1                   \n"
+      "packuswb    %%xmm1,%%xmm0                 \n"
+      "movdqa      %%xmm0,%%xmm1                 \n"
+      "pand        %%xmm5,%%xmm0                 \n"
+      "packuswb    %%xmm0,%%xmm0                 \n"
+      "psrlw       $0x8,%%xmm1                   \n"
+      "packuswb    %%xmm1,%%xmm1                 \n"
+      "movq        %%xmm0,(%1)                   \n"
+      "movq        %%xmm1,0x00(%1,%2,1)          \n"
+      "lea         0x8(%1),%1                    \n"
+      "sub         $0x10,%3                      \n"
+      "jg          1b                            \n"
+      : "+r"(src_yuy2),               // %0
+        "+r"(dst_u),                  // %1
+        "+r"(dst_v),                  // %2
+        "+r"(width)                   // %3
+      : "r"((intptr_t)(stride_yuy2))  // %4
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm5");
+}
+
+void YUY2ToUV422Row_SSE2(const uint8_t* src_yuy2,
+                         uint8_t* dst_u,
+                         uint8_t* dst_v,
+                         int width) {
+  asm volatile(
+      "pcmpeqb     %%xmm5,%%xmm5                 \n"
+      "psrlw       $0x8,%%xmm5                   \n"
+      "sub         %1,%2                         \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "movdqu      (%0),%%xmm0                   \n"
+      "movdqu      0x10(%0),%%xmm1               \n"
+      "lea         0x20(%0),%0                   \n"
+      "psrlw       $0x8,%%xmm0                   \n"
+      "psrlw       $0x8,%%xmm1                   \n"
+      "packuswb    %%xmm1,%%xmm0                 \n"
+      "movdqa      %%xmm0,%%xmm1                 \n"
+      "pand        %%xmm5,%%xmm0                 \n"
+      "packuswb    %%xmm0,%%xmm0                 \n"
+      "psrlw       $0x8,%%xmm1                   \n"
+      "packuswb    %%xmm1,%%xmm1                 \n"
+      "movq        %%xmm0,(%1)                   \n"
+      "movq        %%xmm1,0x00(%1,%2,1)          \n"
+      "lea         0x8(%1),%1                    \n"
+      "sub         $0x10,%3                      \n"
+      "jg          1b                            \n"
+      : "+r"(src_yuy2),  // %0
+        "+r"(dst_u),     // %1
+        "+r"(dst_v),     // %2
+        "+r"(width)      // %3
+      :
+      : "memory", "cc", "xmm0", "xmm1", "xmm5");
+}
+
+void UYVYToYRow_SSE2(const uint8_t* src_uyvy, uint8_t* dst_y, int width) {
+  asm volatile(
+
+      LABELALIGN
+      "1:                                        \n"
+      "movdqu      (%0),%%xmm0                   \n"
+      "movdqu      0x10(%0),%%xmm1               \n"
+      "lea         0x20(%0),%0                   \n"
+      "psrlw       $0x8,%%xmm0                   \n"
+      "psrlw       $0x8,%%xmm1                   \n"
+      "packuswb    %%xmm1,%%xmm0                 \n"
+      "movdqu      %%xmm0,(%1)                   \n"
+      "lea         0x10(%1),%1                   \n"
+      "sub         $0x10,%2                      \n"
+      "jg          1b                            \n"
+      : "+r"(src_uyvy),  // %0
+        "+r"(dst_y),     // %1
+        "+r"(width)      // %2
+      :
+      : "memory", "cc", "xmm0", "xmm1");
+}
+
+void UYVYToUVRow_SSE2(const uint8_t* src_uyvy,
+                      int stride_uyvy,
+                      uint8_t* dst_u,
+                      uint8_t* dst_v,
+                      int width) {
+  asm volatile(
+      "pcmpeqb     %%xmm5,%%xmm5                 \n"
+      "psrlw       $0x8,%%xmm5                   \n"
+      "sub         %1,%2                         \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "movdqu      (%0),%%xmm0                   \n"
+      "movdqu      0x10(%0),%%xmm1               \n"
+      "movdqu      0x00(%0,%4,1),%%xmm2          \n"
+      "movdqu      0x10(%0,%4,1),%%xmm3          \n"
+      "lea         0x20(%0),%0                   \n"
+      "pavgb       %%xmm2,%%xmm0                 \n"
+      "pavgb       %%xmm3,%%xmm1                 \n"
+      "pand        %%xmm5,%%xmm0                 \n"
+      "pand        %%xmm5,%%xmm1                 \n"
+      "packuswb    %%xmm1,%%xmm0                 \n"
+      "movdqa      %%xmm0,%%xmm1                 \n"
+      "pand        %%xmm5,%%xmm0                 \n"
+      "packuswb    %%xmm0,%%xmm0                 \n"
+      "psrlw       $0x8,%%xmm1                   \n"
+      "packuswb    %%xmm1,%%xmm1                 \n"
+      "movq        %%xmm0,(%1)                   \n"
+      "movq        %%xmm1,0x00(%1,%2,1)          \n"
+      "lea         0x8(%1),%1                    \n"
+      "sub         $0x10,%3                      \n"
+      "jg          1b                            \n"
+      : "+r"(src_uyvy),               // %0
+        "+r"(dst_u),                  // %1
+        "+r"(dst_v),                  // %2
+        "+r"(width)                   // %3
+      : "r"((intptr_t)(stride_uyvy))  // %4
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm5");
+}
+
+void UYVYToUV422Row_SSE2(const uint8_t* src_uyvy,
+                         uint8_t* dst_u,
+                         uint8_t* dst_v,
+                         int width) {
+  asm volatile(
+      "pcmpeqb     %%xmm5,%%xmm5                 \n"
+      "psrlw       $0x8,%%xmm5                   \n"
+      "sub         %1,%2                         \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "movdqu      (%0),%%xmm0                   \n"
+      "movdqu      0x10(%0),%%xmm1               \n"
+      "lea         0x20(%0),%0                   \n"
+      "pand        %%xmm5,%%xmm0                 \n"
+      "pand        %%xmm5,%%xmm1                 \n"
+      "packuswb    %%xmm1,%%xmm0                 \n"
+      "movdqa      %%xmm0,%%xmm1                 \n"
+      "pand        %%xmm5,%%xmm0                 \n"
+      "packuswb    %%xmm0,%%xmm0                 \n"
+      "psrlw       $0x8,%%xmm1                   \n"
+      "packuswb    %%xmm1,%%xmm1                 \n"
+      "movq        %%xmm0,(%1)                   \n"
+      "movq        %%xmm1,0x00(%1,%2,1)          \n"
+      "lea         0x8(%1),%1                    \n"
+      "sub         $0x10,%3                      \n"
+      "jg          1b                            \n"
+      : "+r"(src_uyvy),  // %0
+        "+r"(dst_u),     // %1
+        "+r"(dst_v),     // %2
+        "+r"(width)      // %3
+      :
+      : "memory", "cc", "xmm0", "xmm1", "xmm5");
+}
+#endif  // HAS_YUY2TOYROW_SSE2
+
+#ifdef HAS_YUY2TOYROW_AVX2
+void YUY2ToYRow_AVX2(const uint8_t* src_yuy2, uint8_t* dst_y, int width) {
+  asm volatile(
+      "vpcmpeqb    %%ymm5,%%ymm5,%%ymm5          \n"
+      "vpsrlw      $0x8,%%ymm5,%%ymm5            \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "vmovdqu     (%0),%%ymm0                   \n"
+      "vmovdqu     0x20(%0),%%ymm1               \n"
+      "lea         0x40(%0),%0                   \n"
+      "vpand       %%ymm5,%%ymm0,%%ymm0          \n"
+      "vpand       %%ymm5,%%ymm1,%%ymm1          \n"
+      "vpackuswb   %%ymm1,%%ymm0,%%ymm0          \n"
+      "vpermq      $0xd8,%%ymm0,%%ymm0           \n"
+      "vmovdqu     %%ymm0,(%1)                   \n"
+      "lea         0x20(%1),%1                   \n"
+      "sub         $0x20,%2                      \n"
+      "jg          1b                            \n"
+      "vzeroupper                                \n"
+      : "+r"(src_yuy2),  // %0
+        "+r"(dst_y),     // %1
+        "+r"(width)      // %2
+      :
+      : "memory", "cc", "xmm0", "xmm1", "xmm5");
+}
+
+void YUY2ToUVRow_AVX2(const uint8_t* src_yuy2,
+                      int stride_yuy2,
+                      uint8_t* dst_u,
+                      uint8_t* dst_v,
+                      int width) {
+  asm volatile(
+      "vpcmpeqb    %%ymm5,%%ymm5,%%ymm5          \n"
+      "vpsrlw      $0x8,%%ymm5,%%ymm5            \n"
+      "sub         %1,%2                         \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "vmovdqu     (%0),%%ymm0                   \n"
+      "vmovdqu     0x20(%0),%%ymm1               \n"
+      "vpavgb      0x00(%0,%4,1),%%ymm0,%%ymm0   \n"
+      "vpavgb      0x20(%0,%4,1),%%ymm1,%%ymm1   \n"
+      "lea         0x40(%0),%0                   \n"
+      "vpsrlw      $0x8,%%ymm0,%%ymm0            \n"
+      "vpsrlw      $0x8,%%ymm1,%%ymm1            \n"
+      "vpackuswb   %%ymm1,%%ymm0,%%ymm0          \n"
+      "vpermq      $0xd8,%%ymm0,%%ymm0           \n"
+      "vpand       %%ymm5,%%ymm0,%%ymm1          \n"
+      "vpsrlw      $0x8,%%ymm0,%%ymm0            \n"
+      "vpackuswb   %%ymm1,%%ymm1,%%ymm1          \n"
+      "vpackuswb   %%ymm0,%%ymm0,%%ymm0          \n"
+      "vpermq      $0xd8,%%ymm1,%%ymm1           \n"
+      "vpermq      $0xd8,%%ymm0,%%ymm0           \n"
+      "vextractf128 $0x0,%%ymm1,(%1)             \n"
+      "vextractf128 $0x0,%%ymm0,0x00(%1,%2,1)    \n"
+      "lea         0x10(%1),%1                   \n"
+      "sub         $0x20,%3                      \n"
+      "jg          1b                            \n"
+      "vzeroupper                                \n"
+      : "+r"(src_yuy2),               // %0
+        "+r"(dst_u),                  // %1
+        "+r"(dst_v),                  // %2
+        "+r"(width)                   // %3
+      : "r"((intptr_t)(stride_yuy2))  // %4
+      : "memory", "cc", "xmm0", "xmm1", "xmm5");
+}
+
+void YUY2ToUV422Row_AVX2(const uint8_t* src_yuy2,
+                         uint8_t* dst_u,
+                         uint8_t* dst_v,
+                         int width) {
+  asm volatile(
+      "vpcmpeqb    %%ymm5,%%ymm5,%%ymm5          \n"
+      "vpsrlw      $0x8,%%ymm5,%%ymm5            \n"
+      "sub         %1,%2                         \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "vmovdqu     (%0),%%ymm0                   \n"
+      "vmovdqu     0x20(%0),%%ymm1               \n"
+      "lea         0x40(%0),%0                   \n"
+      "vpsrlw      $0x8,%%ymm0,%%ymm0            \n"
+      "vpsrlw      $0x8,%%ymm1,%%ymm1            \n"
+      "vpackuswb   %%ymm1,%%ymm0,%%ymm0          \n"
+      "vpermq      $0xd8,%%ymm0,%%ymm0           \n"
+      "vpand       %%ymm5,%%ymm0,%%ymm1          \n"
+      "vpsrlw      $0x8,%%ymm0,%%ymm0            \n"
+      "vpackuswb   %%ymm1,%%ymm1,%%ymm1          \n"
+      "vpackuswb   %%ymm0,%%ymm0,%%ymm0          \n"
+      "vpermq      $0xd8,%%ymm1,%%ymm1           \n"
+      "vpermq      $0xd8,%%ymm0,%%ymm0           \n"
+      "vextractf128 $0x0,%%ymm1,(%1)             \n"
+      "vextractf128 $0x0,%%ymm0,0x00(%1,%2,1)    \n"
+      "lea         0x10(%1),%1                   \n"
+      "sub         $0x20,%3                      \n"
+      "jg          1b                            \n"
+      "vzeroupper                                \n"
+      : "+r"(src_yuy2),  // %0
+        "+r"(dst_u),     // %1
+        "+r"(dst_v),     // %2
+        "+r"(width)      // %3
+      :
+      : "memory", "cc", "xmm0", "xmm1", "xmm5");
+}
+
+void UYVYToYRow_AVX2(const uint8_t* src_uyvy, uint8_t* dst_y, int width) {
+  asm volatile(
+
+      LABELALIGN
+      "1:                                        \n"
+      "vmovdqu     (%0),%%ymm0                   \n"
+      "vmovdqu     0x20(%0),%%ymm1               \n"
+      "lea         0x40(%0),%0                   \n"
+      "vpsrlw      $0x8,%%ymm0,%%ymm0            \n"
+      "vpsrlw      $0x8,%%ymm1,%%ymm1            \n"
+      "vpackuswb   %%ymm1,%%ymm0,%%ymm0          \n"
+      "vpermq      $0xd8,%%ymm0,%%ymm0           \n"
+      "vmovdqu     %%ymm0,(%1)                   \n"
+      "lea         0x20(%1),%1                   \n"
+      "sub         $0x20,%2                      \n"
+      "jg          1b                            \n"
+      "vzeroupper                                \n"
+      : "+r"(src_uyvy),  // %0
+        "+r"(dst_y),     // %1
+        "+r"(width)      // %2
+      :
+      : "memory", "cc", "xmm0", "xmm1", "xmm5");
+}
+void UYVYToUVRow_AVX2(const uint8_t* src_uyvy,
+                      int stride_uyvy,
+                      uint8_t* dst_u,
+                      uint8_t* dst_v,
+                      int width) {
+  asm volatile(
+      "vpcmpeqb    %%ymm5,%%ymm5,%%ymm5          \n"
+      "vpsrlw      $0x8,%%ymm5,%%ymm5            \n"
+      "sub         %1,%2                         \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "vmovdqu     (%0),%%ymm0                   \n"
+      "vmovdqu     0x20(%0),%%ymm1               \n"
+      "vpavgb      0x00(%0,%4,1),%%ymm0,%%ymm0   \n"
+      "vpavgb      0x20(%0,%4,1),%%ymm1,%%ymm1   \n"
+      "lea         0x40(%0),%0                   \n"
+      "vpand       %%ymm5,%%ymm0,%%ymm0          \n"
+      "vpand       %%ymm5,%%ymm1,%%ymm1          \n"
+      "vpackuswb   %%ymm1,%%ymm0,%%ymm0          \n"
+      "vpermq      $0xd8,%%ymm0,%%ymm0           \n"
+      "vpand       %%ymm5,%%ymm0,%%ymm1          \n"
+      "vpsrlw      $0x8,%%ymm0,%%ymm0            \n"
+      "vpackuswb   %%ymm1,%%ymm1,%%ymm1          \n"
+      "vpackuswb   %%ymm0,%%ymm0,%%ymm0          \n"
+      "vpermq      $0xd8,%%ymm1,%%ymm1           \n"
+      "vpermq      $0xd8,%%ymm0,%%ymm0           \n"
+      "vextractf128 $0x0,%%ymm1,(%1)             \n"
+      "vextractf128 $0x0,%%ymm0,0x00(%1,%2,1)    \n"
+      "lea         0x10(%1),%1                   \n"
+      "sub         $0x20,%3                      \n"
+      "jg          1b                            \n"
+      "vzeroupper                                \n"
+      : "+r"(src_uyvy),               // %0
+        "+r"(dst_u),                  // %1
+        "+r"(dst_v),                  // %2
+        "+r"(width)                   // %3
+      : "r"((intptr_t)(stride_uyvy))  // %4
+      : "memory", "cc", "xmm0", "xmm1", "xmm5");
+}
+
+void UYVYToUV422Row_AVX2(const uint8_t* src_uyvy,
+                         uint8_t* dst_u,
+                         uint8_t* dst_v,
+                         int width) {
+  asm volatile(
+      "vpcmpeqb    %%ymm5,%%ymm5,%%ymm5          \n"
+      "vpsrlw      $0x8,%%ymm5,%%ymm5            \n"
+      "sub         %1,%2                         \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "vmovdqu     (%0),%%ymm0                   \n"
+      "vmovdqu     0x20(%0),%%ymm1               \n"
+      "lea         0x40(%0),%0                   \n"
+      "vpand       %%ymm5,%%ymm0,%%ymm0          \n"
+      "vpand       %%ymm5,%%ymm1,%%ymm1          \n"
+      "vpackuswb   %%ymm1,%%ymm0,%%ymm0          \n"
+      "vpermq      $0xd8,%%ymm0,%%ymm0           \n"
+      "vpand       %%ymm5,%%ymm0,%%ymm1          \n"
+      "vpsrlw      $0x8,%%ymm0,%%ymm0            \n"
+      "vpackuswb   %%ymm1,%%ymm1,%%ymm1          \n"
+      "vpackuswb   %%ymm0,%%ymm0,%%ymm0          \n"
+      "vpermq      $0xd8,%%ymm1,%%ymm1           \n"
+      "vpermq      $0xd8,%%ymm0,%%ymm0           \n"
+      "vextractf128 $0x0,%%ymm1,(%1)             \n"
+      "vextractf128 $0x0,%%ymm0,0x00(%1,%2,1)    \n"
+      "lea         0x10(%1),%1                   \n"
+      "sub         $0x20,%3                      \n"
+      "jg          1b                            \n"
+      "vzeroupper                                \n"
+      : "+r"(src_uyvy),  // %0
+        "+r"(dst_u),     // %1
+        "+r"(dst_v),     // %2
+        "+r"(width)      // %3
+      :
+      : "memory", "cc", "xmm0", "xmm1", "xmm5");
+}
+#endif  // HAS_YUY2TOYROW_AVX2
+
+#ifdef HAS_ARGBBLENDROW_SSSE3
+// Shuffle table for isolating alpha.
+static const uvec8 kShuffleAlpha = {3u,  0x80, 3u,  0x80, 7u,  0x80, 7u,  0x80,
+                                    11u, 0x80, 11u, 0x80, 15u, 0x80, 15u, 0x80};
+
+// Blend 8 pixels at a time
+void ARGBBlendRow_SSSE3(const uint8_t* src_argb,
+                        const uint8_t* src_argb1,
+                        uint8_t* dst_argb,
+                        int width) {
+  asm volatile(
+      "pcmpeqb     %%xmm7,%%xmm7                 \n"
+      "psrlw       $0xf,%%xmm7                   \n"
+      "pcmpeqb     %%xmm6,%%xmm6                 \n"
+      "psrlw       $0x8,%%xmm6                   \n"
+      "pcmpeqb     %%xmm5,%%xmm5                 \n"
+      "psllw       $0x8,%%xmm5                   \n"
+      "pcmpeqb     %%xmm4,%%xmm4                 \n"
+      "pslld       $0x18,%%xmm4                  \n"
+      "sub         $0x4,%3                       \n"
+      "jl          49f                           \n"
+
+      // 4 pixel loop.
+      LABELALIGN
+      "40:                                       \n"
+      "movdqu      (%0),%%xmm3                   \n"
+      "lea         0x10(%0),%0                   \n"
+      "movdqa      %%xmm3,%%xmm0                 \n"
+      "pxor        %%xmm4,%%xmm3                 \n"
+      "movdqu      (%1),%%xmm2                   \n"
+      "pshufb      %4,%%xmm3                     \n"
+      "pand        %%xmm6,%%xmm2                 \n"
+      "paddw       %%xmm7,%%xmm3                 \n"
+      "pmullw      %%xmm3,%%xmm2                 \n"
+      "movdqu      (%1),%%xmm1                   \n"
+      "lea         0x10(%1),%1                   \n"
+      "psrlw       $0x8,%%xmm1                   \n"
+      "por         %%xmm4,%%xmm0                 \n"
+      "pmullw      %%xmm3,%%xmm1                 \n"
+      "psrlw       $0x8,%%xmm2                   \n"
+      "paddusb     %%xmm2,%%xmm0                 \n"
+      "pand        %%xmm5,%%xmm1                 \n"
+      "paddusb     %%xmm1,%%xmm0                 \n"
+      "movdqu      %%xmm0,(%2)                   \n"
+      "lea         0x10(%2),%2                   \n"
+      "sub         $0x4,%3                       \n"
+      "jge         40b                           \n"
+
+      "49:                                       \n"
+      "add         $0x3,%3                       \n"
+      "jl          99f                           \n"
+
+      // 1 pixel loop.
+      "91:                                       \n"
+      "movd        (%0),%%xmm3                   \n"
+      "lea         0x4(%0),%0                    \n"
+      "movdqa      %%xmm3,%%xmm0                 \n"
+      "pxor        %%xmm4,%%xmm3                 \n"
+      "movd        (%1),%%xmm2                   \n"
+      "pshufb      %4,%%xmm3                     \n"
+      "pand        %%xmm6,%%xmm2                 \n"
+      "paddw       %%xmm7,%%xmm3                 \n"
+      "pmullw      %%xmm3,%%xmm2                 \n"
+      "movd        (%1),%%xmm1                   \n"
+      "lea         0x4(%1),%1                    \n"
+      "psrlw       $0x8,%%xmm1                   \n"
+      "por         %%xmm4,%%xmm0                 \n"
+      "pmullw      %%xmm3,%%xmm1                 \n"
+      "psrlw       $0x8,%%xmm2                   \n"
+      "paddusb     %%xmm2,%%xmm0                 \n"
+      "pand        %%xmm5,%%xmm1                 \n"
+      "paddusb     %%xmm1,%%xmm0                 \n"
+      "movd        %%xmm0,(%2)                   \n"
+      "lea         0x4(%2),%2                    \n"
+      "sub         $0x1,%3                       \n"
+      "jge         91b                           \n"
+      "99:                                       \n"
+      : "+r"(src_argb),     // %0
+        "+r"(src_argb1),    // %1
+        "+r"(dst_argb),     // %2
+        "+r"(width)         // %3
+      : "m"(kShuffleAlpha)  // %4
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6",
+        "xmm7");
+}
+#endif  // HAS_ARGBBLENDROW_SSSE3
+
+#ifdef HAS_BLENDPLANEROW_SSSE3
+// Blend 8 pixels at a time.
+// unsigned version of math
+// =((A2*C2)+(B2*(255-C2))+255)/256
+// signed version of math
+// =(((A2-128)*C2)+((B2-128)*(255-C2))+32768+127)/256
+void BlendPlaneRow_SSSE3(const uint8_t* src0,
+                         const uint8_t* src1,
+                         const uint8_t* alpha,
+                         uint8_t* dst,
+                         int width) {
+  asm volatile(
+      "pcmpeqb     %%xmm5,%%xmm5                 \n"
+      "psllw       $0x8,%%xmm5                   \n"
+      "mov         $0x80808080,%%eax             \n"
+      "movd        %%eax,%%xmm6                  \n"
+      "pshufd      $0x0,%%xmm6,%%xmm6            \n"
+      "mov         $0x807f807f,%%eax             \n"
+      "movd        %%eax,%%xmm7                  \n"
+      "pshufd      $0x0,%%xmm7,%%xmm7            \n"
+      "sub         %2,%0                         \n"
+      "sub         %2,%1                         \n"
+      "sub         %2,%3                         \n"
+
+      // 8 pixel loop.
+      LABELALIGN
+      "1:                                        \n"
+      "movq        (%2),%%xmm0                   \n"
+      "punpcklbw   %%xmm0,%%xmm0                 \n"
+      "pxor        %%xmm5,%%xmm0                 \n"
+      "movq        (%0,%2,1),%%xmm1              \n"
+      "movq        (%1,%2,1),%%xmm2              \n"
+      "punpcklbw   %%xmm2,%%xmm1                 \n"
+      "psubb       %%xmm6,%%xmm1                 \n"
+      "pmaddubsw   %%xmm1,%%xmm0                 \n"
+      "paddw       %%xmm7,%%xmm0                 \n"
+      "psrlw       $0x8,%%xmm0                   \n"
+      "packuswb    %%xmm0,%%xmm0                 \n"
+      "movq        %%xmm0,(%3,%2,1)              \n"
+      "lea         0x8(%2),%2                    \n"
+      "sub         $0x8,%4                       \n"
+      "jg          1b                            \n"
+      : "+r"(src0),   // %0
+        "+r"(src1),   // %1
+        "+r"(alpha),  // %2
+        "+r"(dst),    // %3
+        "+rm"(width)  // %4
+        ::"memory",
+        "cc", "eax", "xmm0", "xmm1", "xmm2", "xmm5", "xmm6", "xmm7");
+}
+#endif  // HAS_BLENDPLANEROW_SSSE3
+
+#ifdef HAS_BLENDPLANEROW_AVX2
+// Blend 32 pixels at a time.
+// unsigned version of math
+// =((A2*C2)+(B2*(255-C2))+255)/256
+// signed version of math
+// =(((A2-128)*C2)+((B2-128)*(255-C2))+32768+127)/256
+void BlendPlaneRow_AVX2(const uint8_t* src0,
+                        const uint8_t* src1,
+                        const uint8_t* alpha,
+                        uint8_t* dst,
+                        int width) {
+  asm volatile(
+      "vpcmpeqb    %%ymm5,%%ymm5,%%ymm5          \n"
+      "vpsllw      $0x8,%%ymm5,%%ymm5            \n"
+      "mov         $0x80808080,%%eax             \n"
+      "vmovd       %%eax,%%xmm6                  \n"
+      "vbroadcastss %%xmm6,%%ymm6                \n"
+      "mov         $0x807f807f,%%eax             \n"
+      "vmovd       %%eax,%%xmm7                  \n"
+      "vbroadcastss %%xmm7,%%ymm7                \n"
+      "sub         %2,%0                         \n"
+      "sub         %2,%1                         \n"
+      "sub         %2,%3                         \n"
+
+      // 32 pixel loop.
+      LABELALIGN
+      "1:                                        \n"
+      "vmovdqu     (%2),%%ymm0                   \n"
+      "vpunpckhbw  %%ymm0,%%ymm0,%%ymm3          \n"
+      "vpunpcklbw  %%ymm0,%%ymm0,%%ymm0          \n"
+      "vpxor       %%ymm5,%%ymm3,%%ymm3          \n"
+      "vpxor       %%ymm5,%%ymm0,%%ymm0          \n"
+      "vmovdqu     (%0,%2,1),%%ymm1              \n"
+      "vmovdqu     (%1,%2,1),%%ymm2              \n"
+      "vpunpckhbw  %%ymm2,%%ymm1,%%ymm4          \n"
+      "vpunpcklbw  %%ymm2,%%ymm1,%%ymm1          \n"
+      "vpsubb      %%ymm6,%%ymm4,%%ymm4          \n"
+      "vpsubb      %%ymm6,%%ymm1,%%ymm1          \n"
+      "vpmaddubsw  %%ymm4,%%ymm3,%%ymm3          \n"
+      "vpmaddubsw  %%ymm1,%%ymm0,%%ymm0          \n"
+      "vpaddw      %%ymm7,%%ymm3,%%ymm3          \n"
+      "vpaddw      %%ymm7,%%ymm0,%%ymm0          \n"
+      "vpsrlw      $0x8,%%ymm3,%%ymm3            \n"
+      "vpsrlw      $0x8,%%ymm0,%%ymm0            \n"
+      "vpackuswb   %%ymm3,%%ymm0,%%ymm0          \n"
+      "vmovdqu     %%ymm0,(%3,%2,1)              \n"
+      "lea         0x20(%2),%2                   \n"
+      "sub         $0x20,%4                      \n"
+      "jg          1b                            \n"
+      "vzeroupper                                \n"
+      : "+r"(src0),   // %0
+        "+r"(src1),   // %1
+        "+r"(alpha),  // %2
+        "+r"(dst),    // %3
+        "+rm"(width)  // %4
+        ::"memory",
+        "cc", "eax", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6",
+        "xmm7");
+}
+#endif  // HAS_BLENDPLANEROW_AVX2
+
+#ifdef HAS_ARGBATTENUATEROW_SSSE3
+// Shuffle table duplicating alpha.
+static const uvec8 kShuffleAlpha0 = {3u, 3u, 3u, 3u, 3u, 3u, 128u, 128u,
+                                     7u, 7u, 7u, 7u, 7u, 7u, 128u, 128u};
+static const uvec8 kShuffleAlpha1 = {11u, 11u, 11u, 11u, 11u, 11u, 128u, 128u,
+                                     15u, 15u, 15u, 15u, 15u, 15u, 128u, 128u};
+// Attenuate 4 pixels at a time.
+void ARGBAttenuateRow_SSSE3(const uint8_t* src_argb,
+                            uint8_t* dst_argb,
+                            int width) {
+  asm volatile(
+      "pcmpeqb     %%xmm3,%%xmm3                 \n"
+      "pslld       $0x18,%%xmm3                  \n"
+      "movdqa      %3,%%xmm4                     \n"
+      "movdqa      %4,%%xmm5                     \n"
+
+      // 4 pixel loop.
+      LABELALIGN
+      "1:                                        \n"
+      "movdqu      (%0),%%xmm0                   \n"
+      "pshufb      %%xmm4,%%xmm0                 \n"
+      "movdqu      (%0),%%xmm1                   \n"
+      "punpcklbw   %%xmm1,%%xmm1                 \n"
+      "pmulhuw     %%xmm1,%%xmm0                 \n"
+      "movdqu      (%0),%%xmm1                   \n"
+      "pshufb      %%xmm5,%%xmm1                 \n"
+      "movdqu      (%0),%%xmm2                   \n"
+      "punpckhbw   %%xmm2,%%xmm2                 \n"
+      "pmulhuw     %%xmm2,%%xmm1                 \n"
+      "movdqu      (%0),%%xmm2                   \n"
+      "lea         0x10(%0),%0                   \n"
+      "pand        %%xmm3,%%xmm2                 \n"
+      "psrlw       $0x8,%%xmm0                   \n"
+      "psrlw       $0x8,%%xmm1                   \n"
+      "packuswb    %%xmm1,%%xmm0                 \n"
+      "por         %%xmm2,%%xmm0                 \n"
+      "movdqu      %%xmm0,(%1)                   \n"
+      "lea         0x10(%1),%1                   \n"
+      "sub         $0x4,%2                       \n"
+      "jg          1b                            \n"
+      : "+r"(src_argb),       // %0
+        "+r"(dst_argb),       // %1
+        "+r"(width)           // %2
+      : "m"(kShuffleAlpha0),  // %3
+        "m"(kShuffleAlpha1)   // %4
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5");
+}
+#endif  // HAS_ARGBATTENUATEROW_SSSE3
+
+#ifdef HAS_ARGBATTENUATEROW_AVX2
+// Shuffle table duplicating alpha.
+static const uvec8 kShuffleAlpha_AVX2 = {6u,   7u,   6u,   7u,  6u,  7u,
+                                         128u, 128u, 14u,  15u, 14u, 15u,
+                                         14u,  15u,  128u, 128u};
+// Attenuate 8 pixels at a time.
+void ARGBAttenuateRow_AVX2(const uint8_t* src_argb,
+                           uint8_t* dst_argb,
+                           int width) {
+  asm volatile(
+      "vbroadcastf128 %3,%%ymm4                  \n"
+      "vpcmpeqb    %%ymm5,%%ymm5,%%ymm5          \n"
+      "vpslld      $0x18,%%ymm5,%%ymm5           \n"
+      "sub         %0,%1                         \n"
+
+      // 8 pixel loop.
+      LABELALIGN
+      "1:                                        \n"
+      "vmovdqu     (%0),%%ymm6                   \n"
+      "vpunpcklbw  %%ymm6,%%ymm6,%%ymm0          \n"
+      "vpunpckhbw  %%ymm6,%%ymm6,%%ymm1          \n"
+      "vpshufb     %%ymm4,%%ymm0,%%ymm2          \n"
+      "vpshufb     %%ymm4,%%ymm1,%%ymm3          \n"
+      "vpmulhuw    %%ymm2,%%ymm0,%%ymm0          \n"
+      "vpmulhuw    %%ymm3,%%ymm1,%%ymm1          \n"
+      "vpand       %%ymm5,%%ymm6,%%ymm6          \n"
+      "vpsrlw      $0x8,%%ymm0,%%ymm0            \n"
+      "vpsrlw      $0x8,%%ymm1,%%ymm1            \n"
+      "vpackuswb   %%ymm1,%%ymm0,%%ymm0          \n"
+      "vpor        %%ymm6,%%ymm0,%%ymm0          \n"
+      "vmovdqu     %%ymm0,0x00(%0,%1,1)          \n"
+      "lea         0x20(%0),%0                   \n"
+      "sub         $0x8,%2                       \n"
+      "jg          1b                            \n"
+      "vzeroupper                                \n"
+      : "+r"(src_argb),          // %0
+        "+r"(dst_argb),          // %1
+        "+r"(width)              // %2
+      : "m"(kShuffleAlpha_AVX2)  // %3
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6");
+}
+#endif  // HAS_ARGBATTENUATEROW_AVX2
+
+#ifdef HAS_ARGBUNATTENUATEROW_SSE2
+// Unattenuate 4 pixels at a time.
+void ARGBUnattenuateRow_SSE2(const uint8_t* src_argb,
+                             uint8_t* dst_argb,
+                             int width) {
+  uintptr_t alpha;
+  asm volatile(
+      // 4 pixel loop.
+      LABELALIGN
+      "1:                                        \n"
+      "movdqu      (%0),%%xmm0                   \n"
+      "movzb       0x03(%0),%3                   \n"
+      "punpcklbw   %%xmm0,%%xmm0                 \n"
+      "movd        0x00(%4,%3,4),%%xmm2          \n"
+      "movzb       0x07(%0),%3                   \n"
+      "movd        0x00(%4,%3,4),%%xmm3          \n"
+      "pshuflw     $0x40,%%xmm2,%%xmm2           \n"
+      "pshuflw     $0x40,%%xmm3,%%xmm3           \n"
+      "movlhps     %%xmm3,%%xmm2                 \n"
+      "pmulhuw     %%xmm2,%%xmm0                 \n"
+      "movdqu      (%0),%%xmm1                   \n"
+      "movzb       0x0b(%0),%3                   \n"
+      "punpckhbw   %%xmm1,%%xmm1                 \n"
+      "movd        0x00(%4,%3,4),%%xmm2          \n"
+      "movzb       0x0f(%0),%3                   \n"
+      "movd        0x00(%4,%3,4),%%xmm3          \n"
+      "pshuflw     $0x40,%%xmm2,%%xmm2           \n"
+      "pshuflw     $0x40,%%xmm3,%%xmm3           \n"
+      "movlhps     %%xmm3,%%xmm2                 \n"
+      "pmulhuw     %%xmm2,%%xmm1                 \n"
+      "lea         0x10(%0),%0                   \n"
+      "packuswb    %%xmm1,%%xmm0                 \n"
+      "movdqu      %%xmm0,(%1)                   \n"
+      "lea         0x10(%1),%1                   \n"
+      "sub         $0x4,%2                       \n"
+      "jg          1b                            \n"
+      : "+r"(src_argb),     // %0
+        "+r"(dst_argb),     // %1
+        "+r"(width),        // %2
+        "=&r"(alpha)        // %3
+      : "r"(fixed_invtbl8)  // %4
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5");
+}
+#endif  // HAS_ARGBUNATTENUATEROW_SSE2
+
+#ifdef HAS_ARGBUNATTENUATEROW_AVX2
+// Shuffle table duplicating alpha.
+static const uvec8 kUnattenShuffleAlpha_AVX2 = {
+    0u, 1u, 0u, 1u, 0u, 1u, 6u, 7u, 8u, 9u, 8u, 9u, 8u, 9u, 14u, 15u};
+// Unattenuate 8 pixels at a time.
+void ARGBUnattenuateRow_AVX2(const uint8_t* src_argb,
+                             uint8_t* dst_argb,
+                             int width) {
+  uintptr_t alpha;
+  asm volatile(
+      "sub         %0,%1                         \n"
+      "vbroadcastf128 %5,%%ymm5                  \n"
+
+      // 8 pixel loop.
+      LABELALIGN
+      "1:                                        \n"
+      // replace VPGATHER
+      "movzb       0x03(%0),%3                   \n"
+      "vmovd       0x00(%4,%3,4),%%xmm0          \n"
+      "movzb       0x07(%0),%3                   \n"
+      "vmovd       0x00(%4,%3,4),%%xmm1          \n"
+      "movzb       0x0b(%0),%3                   \n"
+      "vpunpckldq  %%xmm1,%%xmm0,%%xmm6          \n"
+      "vmovd       0x00(%4,%3,4),%%xmm2          \n"
+      "movzb       0x0f(%0),%3                   \n"
+      "vmovd       0x00(%4,%3,4),%%xmm3          \n"
+      "movzb       0x13(%0),%3                   \n"
+      "vpunpckldq  %%xmm3,%%xmm2,%%xmm7          \n"
+      "vmovd       0x00(%4,%3,4),%%xmm0          \n"
+      "movzb       0x17(%0),%3                   \n"
+      "vmovd       0x00(%4,%3,4),%%xmm1          \n"
+      "movzb       0x1b(%0),%3                   \n"
+      "vpunpckldq  %%xmm1,%%xmm0,%%xmm0          \n"
+      "vmovd       0x00(%4,%3,4),%%xmm2          \n"
+      "movzb       0x1f(%0),%3                   \n"
+      "vmovd       0x00(%4,%3,4),%%xmm3          \n"
+      "vpunpckldq  %%xmm3,%%xmm2,%%xmm2          \n"
+      "vpunpcklqdq %%xmm7,%%xmm6,%%xmm3          \n"
+      "vpunpcklqdq %%xmm2,%%xmm0,%%xmm0          \n"
+      "vinserti128 $0x1,%%xmm0,%%ymm3,%%ymm3     \n"
+      // end of VPGATHER
+
+      "vmovdqu     (%0),%%ymm6                   \n"
+      "vpunpcklbw  %%ymm6,%%ymm6,%%ymm0          \n"
+      "vpunpckhbw  %%ymm6,%%ymm6,%%ymm1          \n"
+      "vpunpcklwd  %%ymm3,%%ymm3,%%ymm2          \n"
+      "vpunpckhwd  %%ymm3,%%ymm3,%%ymm3          \n"
+      "vpshufb     %%ymm5,%%ymm2,%%ymm2          \n"
+      "vpshufb     %%ymm5,%%ymm3,%%ymm3          \n"
+      "vpmulhuw    %%ymm2,%%ymm0,%%ymm0          \n"
+      "vpmulhuw    %%ymm3,%%ymm1,%%ymm1          \n"
+      "vpackuswb   %%ymm1,%%ymm0,%%ymm0          \n"
+      "vmovdqu     %%ymm0,0x00(%0,%1,1)          \n"
+      "lea         0x20(%0),%0                   \n"
+      "sub         $0x8,%2                       \n"
+      "jg          1b                            \n"
+      "vzeroupper                                \n"
+      : "+r"(src_argb),                 // %0
+        "+r"(dst_argb),                 // %1
+        "+r"(width),                    // %2
+        "=&r"(alpha)                    // %3
+      : "r"(fixed_invtbl8),             // %4
+        "m"(kUnattenShuffleAlpha_AVX2)  // %5
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6",
+        "xmm7");
+}
+#endif  // HAS_ARGBUNATTENUATEROW_AVX2
+
+#ifdef HAS_ARGBGRAYROW_SSSE3
+// Convert 8 ARGB pixels (64 bytes) to 8 Gray ARGB pixels
+void ARGBGrayRow_SSSE3(const uint8_t* src_argb, uint8_t* dst_argb, int width) {
+  asm volatile(
+      "movdqa      %3,%%xmm4                     \n"
+      "movdqa      %4,%%xmm5                     \n"
+
+      // 8 pixel loop.
+      LABELALIGN
+      "1:                                        \n"
+      "movdqu      (%0),%%xmm0                   \n"
+      "movdqu      0x10(%0),%%xmm1               \n"
+      "psubb       %%xmm5,%%xmm0                 \n"
+      "psubb       %%xmm5,%%xmm1                 \n"
+      "movdqu      %%xmm4,%%xmm6                 \n"
+      "pmaddubsw   %%xmm0,%%xmm6                 \n"
+      "movdqu      %%xmm4,%%xmm0                 \n"
+      "pmaddubsw   %%xmm1,%%xmm0                 \n"
+      "phaddw      %%xmm0,%%xmm6                 \n"
+      "paddw       %%xmm5,%%xmm6                 \n"
+      "psrlw       $0x8,%%xmm6                   \n"
+      "packuswb    %%xmm6,%%xmm6                 \n"
+      "movdqu      (%0),%%xmm2                   \n"
+      "movdqu      0x10(%0),%%xmm3               \n"
+      "lea         0x20(%0),%0                   \n"
+      "psrld       $0x18,%%xmm2                  \n"
+      "psrld       $0x18,%%xmm3                  \n"
+      "packuswb    %%xmm3,%%xmm2                 \n"
+      "packuswb    %%xmm2,%%xmm2                 \n"
+      "movdqa      %%xmm6,%%xmm3                 \n"
+      "punpcklbw   %%xmm6,%%xmm6                 \n"
+      "punpcklbw   %%xmm2,%%xmm3                 \n"
+      "movdqa      %%xmm6,%%xmm1                 \n"
+      "punpcklwd   %%xmm3,%%xmm6                 \n"
+      "punpckhwd   %%xmm3,%%xmm1                 \n"
+      "movdqu      %%xmm6,(%1)                   \n"
+      "movdqu      %%xmm1,0x10(%1)               \n"
+      "lea         0x20(%1),%1                   \n"
+      "sub         $0x8,%2                       \n"
+      "jg          1b                            \n"
+      : "+r"(src_argb),  // %0
+        "+r"(dst_argb),  // %1
+        "+r"(width)      // %2
+      : "m"(kARGBToYJ),  // %3
+        "m"(kSub128)     // %4
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6");
+}
+#endif  // HAS_ARGBGRAYROW_SSSE3
+
+#ifdef HAS_ARGBSEPIAROW_SSSE3
+//    b = (r * 35 + g * 68 + b * 17) >> 7
+//    g = (r * 45 + g * 88 + b * 22) >> 7
+//    r = (r * 50 + g * 98 + b * 24) >> 7
+// Constant for ARGB color to sepia tone
+static const vec8 kARGBToSepiaB = {17, 68, 35, 0, 17, 68, 35, 0,
+                                   17, 68, 35, 0, 17, 68, 35, 0};
+
+static const vec8 kARGBToSepiaG = {22, 88, 45, 0, 22, 88, 45, 0,
+                                   22, 88, 45, 0, 22, 88, 45, 0};
+
+static const vec8 kARGBToSepiaR = {24, 98, 50, 0, 24, 98, 50, 0,
+                                   24, 98, 50, 0, 24, 98, 50, 0};
+
+// Convert 8 ARGB pixels (32 bytes) to 8 Sepia ARGB pixels.
+void ARGBSepiaRow_SSSE3(uint8_t* dst_argb, int width) {
+  asm volatile(
+      "movdqa      %2,%%xmm2                     \n"
+      "movdqa      %3,%%xmm3                     \n"
+      "movdqa      %4,%%xmm4                     \n"
+
+      // 8 pixel loop.
+      LABELALIGN
+      "1:                                        \n"
+      "movdqu      (%0),%%xmm0                   \n"
+      "movdqu      0x10(%0),%%xmm6               \n"
+      "pmaddubsw   %%xmm2,%%xmm0                 \n"
+      "pmaddubsw   %%xmm2,%%xmm6                 \n"
+      "phaddw      %%xmm6,%%xmm0                 \n"
+      "psrlw       $0x7,%%xmm0                   \n"
+      "packuswb    %%xmm0,%%xmm0                 \n"
+      "movdqu      (%0),%%xmm5                   \n"
+      "movdqu      0x10(%0),%%xmm1               \n"
+      "pmaddubsw   %%xmm3,%%xmm5                 \n"
+      "pmaddubsw   %%xmm3,%%xmm1                 \n"
+      "phaddw      %%xmm1,%%xmm5                 \n"
+      "psrlw       $0x7,%%xmm5                   \n"
+      "packuswb    %%xmm5,%%xmm5                 \n"
+      "punpcklbw   %%xmm5,%%xmm0                 \n"
+      "movdqu      (%0),%%xmm5                   \n"
+      "movdqu      0x10(%0),%%xmm1               \n"
+      "pmaddubsw   %%xmm4,%%xmm5                 \n"
+      "pmaddubsw   %%xmm4,%%xmm1                 \n"
+      "phaddw      %%xmm1,%%xmm5                 \n"
+      "psrlw       $0x7,%%xmm5                   \n"
+      "packuswb    %%xmm5,%%xmm5                 \n"
+      "movdqu      (%0),%%xmm6                   \n"
+      "movdqu      0x10(%0),%%xmm1               \n"
+      "psrld       $0x18,%%xmm6                  \n"
+      "psrld       $0x18,%%xmm1                  \n"
+      "packuswb    %%xmm1,%%xmm6                 \n"
+      "packuswb    %%xmm6,%%xmm6                 \n"
+      "punpcklbw   %%xmm6,%%xmm5                 \n"
+      "movdqa      %%xmm0,%%xmm1                 \n"
+      "punpcklwd   %%xmm5,%%xmm0                 \n"
+      "punpckhwd   %%xmm5,%%xmm1                 \n"
+      "movdqu      %%xmm0,(%0)                   \n"
+      "movdqu      %%xmm1,0x10(%0)               \n"
+      "lea         0x20(%0),%0                   \n"
+      "sub         $0x8,%1                       \n"
+      "jg          1b                            \n"
+      : "+r"(dst_argb),      // %0
+        "+r"(width)          // %1
+      : "m"(kARGBToSepiaB),  // %2
+        "m"(kARGBToSepiaG),  // %3
+        "m"(kARGBToSepiaR)   // %4
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6");
+}
+#endif  // HAS_ARGBSEPIAROW_SSSE3
+
+#ifdef HAS_ARGBCOLORMATRIXROW_SSSE3
+// Tranform 8 ARGB pixels (32 bytes) with color matrix.
+// Same as Sepia except matrix is provided.
+void ARGBColorMatrixRow_SSSE3(const uint8_t* src_argb,
+                              uint8_t* dst_argb,
+                              const int8_t* matrix_argb,
+                              int width) {
+  asm volatile(
+      "movdqu      (%3),%%xmm5                   \n"
+      "pshufd      $0x00,%%xmm5,%%xmm2           \n"
+      "pshufd      $0x55,%%xmm5,%%xmm3           \n"
+      "pshufd      $0xaa,%%xmm5,%%xmm4           \n"
+      "pshufd      $0xff,%%xmm5,%%xmm5           \n"
+
+      // 8 pixel loop.
+      LABELALIGN
+      "1:                                        \n"
+      "movdqu      (%0),%%xmm0                   \n"
+      "movdqu      0x10(%0),%%xmm7               \n"
+      "pmaddubsw   %%xmm2,%%xmm0                 \n"
+      "pmaddubsw   %%xmm2,%%xmm7                 \n"
+      "movdqu      (%0),%%xmm6                   \n"
+      "movdqu      0x10(%0),%%xmm1               \n"
+      "pmaddubsw   %%xmm3,%%xmm6                 \n"
+      "pmaddubsw   %%xmm3,%%xmm1                 \n"
+      "phaddsw     %%xmm7,%%xmm0                 \n"
+      "phaddsw     %%xmm1,%%xmm6                 \n"
+      "psraw       $0x6,%%xmm0                   \n"
+      "psraw       $0x6,%%xmm6                   \n"
+      "packuswb    %%xmm0,%%xmm0                 \n"
+      "packuswb    %%xmm6,%%xmm6                 \n"
+      "punpcklbw   %%xmm6,%%xmm0                 \n"
+      "movdqu      (%0),%%xmm1                   \n"
+      "movdqu      0x10(%0),%%xmm7               \n"
+      "pmaddubsw   %%xmm4,%%xmm1                 \n"
+      "pmaddubsw   %%xmm4,%%xmm7                 \n"
+      "phaddsw     %%xmm7,%%xmm1                 \n"
+      "movdqu      (%0),%%xmm6                   \n"
+      "movdqu      0x10(%0),%%xmm7               \n"
+      "pmaddubsw   %%xmm5,%%xmm6                 \n"
+      "pmaddubsw   %%xmm5,%%xmm7                 \n"
+      "phaddsw     %%xmm7,%%xmm6                 \n"
+      "psraw       $0x6,%%xmm1                   \n"
+      "psraw       $0x6,%%xmm6                   \n"
+      "packuswb    %%xmm1,%%xmm1                 \n"
+      "packuswb    %%xmm6,%%xmm6                 \n"
+      "punpcklbw   %%xmm6,%%xmm1                 \n"
+      "movdqa      %%xmm0,%%xmm6                 \n"
+      "punpcklwd   %%xmm1,%%xmm0                 \n"
+      "punpckhwd   %%xmm1,%%xmm6                 \n"
+      "movdqu      %%xmm0,(%1)                   \n"
+      "movdqu      %%xmm6,0x10(%1)               \n"
+      "lea         0x20(%0),%0                   \n"
+      "lea         0x20(%1),%1                   \n"
+      "sub         $0x8,%2                       \n"
+      "jg          1b                            \n"
+      : "+r"(src_argb),   // %0
+        "+r"(dst_argb),   // %1
+        "+r"(width)       // %2
+      : "r"(matrix_argb)  // %3
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6",
+        "xmm7");
+}
+#endif  // HAS_ARGBCOLORMATRIXROW_SSSE3
+
+#ifdef HAS_ARGBQUANTIZEROW_SSE2
+// Quantize 4 ARGB pixels (16 bytes).
+void ARGBQuantizeRow_SSE2(uint8_t* dst_argb,
+                          int scale,
+                          int interval_size,
+                          int interval_offset,
+                          int width) {
+  asm volatile(
+      "movd        %2,%%xmm2                     \n"
+      "movd        %3,%%xmm3                     \n"
+      "movd        %4,%%xmm4                     \n"
+      "pshuflw     $0x40,%%xmm2,%%xmm2           \n"
+      "pshufd      $0x44,%%xmm2,%%xmm2           \n"
+      "pshuflw     $0x40,%%xmm3,%%xmm3           \n"
+      "pshufd      $0x44,%%xmm3,%%xmm3           \n"
+      "pshuflw     $0x40,%%xmm4,%%xmm4           \n"
+      "pshufd      $0x44,%%xmm4,%%xmm4           \n"
+      "pxor        %%xmm5,%%xmm5                 \n"
+      "pcmpeqb     %%xmm6,%%xmm6                 \n"
+      "pslld       $0x18,%%xmm6                  \n"
+
+      // 4 pixel loop.
+      LABELALIGN
+      "1:                                        \n"
+      "movdqu      (%0),%%xmm0                   \n"
+      "punpcklbw   %%xmm5,%%xmm0                 \n"
+      "pmulhuw     %%xmm2,%%xmm0                 \n"
+      "movdqu      (%0),%%xmm1                   \n"
+      "punpckhbw   %%xmm5,%%xmm1                 \n"
+      "pmulhuw     %%xmm2,%%xmm1                 \n"
+      "pmullw      %%xmm3,%%xmm0                 \n"
+      "movdqu      (%0),%%xmm7                   \n"
+      "pmullw      %%xmm3,%%xmm1                 \n"
+      "pand        %%xmm6,%%xmm7                 \n"
+      "paddw       %%xmm4,%%xmm0                 \n"
+      "paddw       %%xmm4,%%xmm1                 \n"
+      "packuswb    %%xmm1,%%xmm0                 \n"
+      "por         %%xmm7,%%xmm0                 \n"
+      "movdqu      %%xmm0,(%0)                   \n"
+      "lea         0x10(%0),%0                   \n"
+      "sub         $0x4,%1                       \n"
+      "jg          1b                            \n"
+      : "+r"(dst_argb),       // %0
+        "+r"(width)           // %1
+      : "r"(scale),           // %2
+        "r"(interval_size),   // %3
+        "r"(interval_offset)  // %4
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6",
+        "xmm7");
+}
+#endif  // HAS_ARGBQUANTIZEROW_SSE2
+
+#ifdef HAS_ARGBSHADEROW_SSE2
+// Shade 4 pixels at a time by specified value.
+void ARGBShadeRow_SSE2(const uint8_t* src_argb,
+                       uint8_t* dst_argb,
+                       int width,
+                       uint32_t value) {
+  asm volatile(
+      "movd        %3,%%xmm2                     \n"
+      "punpcklbw   %%xmm2,%%xmm2                 \n"
+      "punpcklqdq  %%xmm2,%%xmm2                 \n"
+
+      // 4 pixel loop.
+      LABELALIGN
+      "1:                                        \n"
+      "movdqu      (%0),%%xmm0                   \n"
+      "lea         0x10(%0),%0                   \n"
+      "movdqa      %%xmm0,%%xmm1                 \n"
+      "punpcklbw   %%xmm0,%%xmm0                 \n"
+      "punpckhbw   %%xmm1,%%xmm1                 \n"
+      "pmulhuw     %%xmm2,%%xmm0                 \n"
+      "pmulhuw     %%xmm2,%%xmm1                 \n"
+      "psrlw       $0x8,%%xmm0                   \n"
+      "psrlw       $0x8,%%xmm1                   \n"
+      "packuswb    %%xmm1,%%xmm0                 \n"
+      "movdqu      %%xmm0,(%1)                   \n"
+      "lea         0x10(%1),%1                   \n"
+      "sub         $0x4,%2                       \n"
+      "jg          1b                            \n"
+      : "+r"(src_argb),  // %0
+        "+r"(dst_argb),  // %1
+        "+r"(width)      // %2
+      : "r"(value)       // %3
+      : "memory", "cc", "xmm0", "xmm1", "xmm2");
+}
+#endif  // HAS_ARGBSHADEROW_SSE2
+
+#ifdef HAS_ARGBMULTIPLYROW_SSE2
+// Multiply 2 rows of ARGB pixels together, 4 pixels at a time.
+void ARGBMultiplyRow_SSE2(const uint8_t* src_argb,
+                          const uint8_t* src_argb1,
+                          uint8_t* dst_argb,
+                          int width) {
+  asm volatile(
+
+      "pxor        %%xmm5,%%xmm5                 \n"
+
+      // 4 pixel loop.
+      LABELALIGN
+      "1:                                        \n"
+      "movdqu      (%0),%%xmm0                   \n"
+      "lea         0x10(%0),%0                   \n"
+      "movdqu      (%1),%%xmm2                   \n"
+      "lea         0x10(%1),%1                   \n"
+      "movdqu      %%xmm0,%%xmm1                 \n"
+      "movdqu      %%xmm2,%%xmm3                 \n"
+      "punpcklbw   %%xmm0,%%xmm0                 \n"
+      "punpckhbw   %%xmm1,%%xmm1                 \n"
+      "punpcklbw   %%xmm5,%%xmm2                 \n"
+      "punpckhbw   %%xmm5,%%xmm3                 \n"
+      "pmulhuw     %%xmm2,%%xmm0                 \n"
+      "pmulhuw     %%xmm3,%%xmm1                 \n"
+      "packuswb    %%xmm1,%%xmm0                 \n"
+      "movdqu      %%xmm0,(%2)                   \n"
+      "lea         0x10(%2),%2                   \n"
+      "sub         $0x4,%3                       \n"
+      "jg          1b                            \n"
+      : "+r"(src_argb),   // %0
+        "+r"(src_argb1),  // %1
+        "+r"(dst_argb),   // %2
+        "+r"(width)       // %3
+      :
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm5");
+}
+#endif  // HAS_ARGBMULTIPLYROW_SSE2
+
+#ifdef HAS_ARGBMULTIPLYROW_AVX2
+// Multiply 2 rows of ARGB pixels together, 8 pixels at a time.
+void ARGBMultiplyRow_AVX2(const uint8_t* src_argb,
+                          const uint8_t* src_argb1,
+                          uint8_t* dst_argb,
+                          int width) {
+  asm volatile(
+
+      "vpxor       %%ymm5,%%ymm5,%%ymm5          \n"
+
+      // 4 pixel loop.
+      LABELALIGN
+      "1:                                        \n"
+      "vmovdqu     (%0),%%ymm1                   \n"
+      "lea         0x20(%0),%0                   \n"
+      "vmovdqu     (%1),%%ymm3                   \n"
+      "lea         0x20(%1),%1                   \n"
+      "vpunpcklbw  %%ymm1,%%ymm1,%%ymm0          \n"
+      "vpunpckhbw  %%ymm1,%%ymm1,%%ymm1          \n"
+      "vpunpcklbw  %%ymm5,%%ymm3,%%ymm2          \n"
+      "vpunpckhbw  %%ymm5,%%ymm3,%%ymm3          \n"
+      "vpmulhuw    %%ymm2,%%ymm0,%%ymm0          \n"
+      "vpmulhuw    %%ymm3,%%ymm1,%%ymm1          \n"
+      "vpackuswb   %%ymm1,%%ymm0,%%ymm0          \n"
+      "vmovdqu     %%ymm0,(%2)                   \n"
+      "lea         0x20(%2),%2                   \n"
+      "sub         $0x8,%3                       \n"
+      "jg          1b                            \n"
+      "vzeroupper                                \n"
+      : "+r"(src_argb),   // %0
+        "+r"(src_argb1),  // %1
+        "+r"(dst_argb),   // %2
+        "+r"(width)       // %3
+      :
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm5");
+}
+#endif  // HAS_ARGBMULTIPLYROW_AVX2
+
+#ifdef HAS_ARGBADDROW_SSE2
+// Add 2 rows of ARGB pixels together, 4 pixels at a time.
+void ARGBAddRow_SSE2(const uint8_t* src_argb,
+                     const uint8_t* src_argb1,
+                     uint8_t* dst_argb,
+                     int width) {
+  asm volatile(
+      // 4 pixel loop.
+      LABELALIGN
+      "1:                                        \n"
+      "movdqu      (%0),%%xmm0                   \n"
+      "lea         0x10(%0),%0                   \n"
+      "movdqu      (%1),%%xmm1                   \n"
+      "lea         0x10(%1),%1                   \n"
+      "paddusb     %%xmm1,%%xmm0                 \n"
+      "movdqu      %%xmm0,(%2)                   \n"
+      "lea         0x10(%2),%2                   \n"
+      "sub         $0x4,%3                       \n"
+      "jg          1b                            \n"
+      : "+r"(src_argb),   // %0
+        "+r"(src_argb1),  // %1
+        "+r"(dst_argb),   // %2
+        "+r"(width)       // %3
+      :
+      : "memory", "cc", "xmm0", "xmm1");
+}
+#endif  // HAS_ARGBADDROW_SSE2
+
+#ifdef HAS_ARGBADDROW_AVX2
+// Add 2 rows of ARGB pixels together, 4 pixels at a time.
+void ARGBAddRow_AVX2(const uint8_t* src_argb,
+                     const uint8_t* src_argb1,
+                     uint8_t* dst_argb,
+                     int width) {
+  asm volatile(
+      // 4 pixel loop.
+      LABELALIGN
+      "1:                                        \n"
+      "vmovdqu     (%0),%%ymm0                   \n"
+      "lea         0x20(%0),%0                   \n"
+      "vpaddusb    (%1),%%ymm0,%%ymm0            \n"
+      "lea         0x20(%1),%1                   \n"
+      "vmovdqu     %%ymm0,(%2)                   \n"
+      "lea         0x20(%2),%2                   \n"
+      "sub         $0x8,%3                       \n"
+      "jg          1b                            \n"
+      "vzeroupper                                \n"
+      : "+r"(src_argb),   // %0
+        "+r"(src_argb1),  // %1
+        "+r"(dst_argb),   // %2
+        "+r"(width)       // %3
+      :
+      : "memory", "cc", "xmm0");
+}
+#endif  // HAS_ARGBADDROW_AVX2
+
+#ifdef HAS_ARGBSUBTRACTROW_SSE2
+// Subtract 2 rows of ARGB pixels, 4 pixels at a time.
+void ARGBSubtractRow_SSE2(const uint8_t* src_argb,
+                          const uint8_t* src_argb1,
+                          uint8_t* dst_argb,
+                          int width) {
+  asm volatile(
+      // 4 pixel loop.
+      LABELALIGN
+      "1:                                        \n"
+      "movdqu      (%0),%%xmm0                   \n"
+      "lea         0x10(%0),%0                   \n"
+      "movdqu      (%1),%%xmm1                   \n"
+      "lea         0x10(%1),%1                   \n"
+      "psubusb     %%xmm1,%%xmm0                 \n"
+      "movdqu      %%xmm0,(%2)                   \n"
+      "lea         0x10(%2),%2                   \n"
+      "sub         $0x4,%3                       \n"
+      "jg          1b                            \n"
+      : "+r"(src_argb),   // %0
+        "+r"(src_argb1),  // %1
+        "+r"(dst_argb),   // %2
+        "+r"(width)       // %3
+      :
+      : "memory", "cc", "xmm0", "xmm1");
+}
+#endif  // HAS_ARGBSUBTRACTROW_SSE2
+
+#ifdef HAS_ARGBSUBTRACTROW_AVX2
+// Subtract 2 rows of ARGB pixels, 8 pixels at a time.
+void ARGBSubtractRow_AVX2(const uint8_t* src_argb,
+                          const uint8_t* src_argb1,
+                          uint8_t* dst_argb,
+                          int width) {
+  asm volatile(
+      // 4 pixel loop.
+      LABELALIGN
+      "1:                                        \n"
+      "vmovdqu     (%0),%%ymm0                   \n"
+      "lea         0x20(%0),%0                   \n"
+      "vpsubusb    (%1),%%ymm0,%%ymm0            \n"
+      "lea         0x20(%1),%1                   \n"
+      "vmovdqu     %%ymm0,(%2)                   \n"
+      "lea         0x20(%2),%2                   \n"
+      "sub         $0x8,%3                       \n"
+      "jg          1b                            \n"
+      "vzeroupper                                \n"
+      : "+r"(src_argb),   // %0
+        "+r"(src_argb1),  // %1
+        "+r"(dst_argb),   // %2
+        "+r"(width)       // %3
+      :
+      : "memory", "cc", "xmm0");
+}
+#endif  // HAS_ARGBSUBTRACTROW_AVX2
+
+#ifdef HAS_SOBELXROW_SSE2
+// SobelX as a matrix is
+// -1  0  1
+// -2  0  2
+// -1  0  1
+void SobelXRow_SSE2(const uint8_t* src_y0,
+                    const uint8_t* src_y1,
+                    const uint8_t* src_y2,
+                    uint8_t* dst_sobelx,
+                    int width) {
+  asm volatile(
+      "sub         %0,%1                         \n"
+      "sub         %0,%2                         \n"
+      "sub         %0,%3                         \n"
+      "pxor        %%xmm5,%%xmm5                 \n"
+
+      // 8 pixel loop.
+      LABELALIGN
+      "1:                                        \n"
+      "movq        (%0),%%xmm0                   \n"
+      "movq        0x2(%0),%%xmm1                \n"
+      "punpcklbw   %%xmm5,%%xmm0                 \n"
+      "punpcklbw   %%xmm5,%%xmm1                 \n"
+      "psubw       %%xmm1,%%xmm0                 \n"
+      "movq        0x00(%0,%1,1),%%xmm1          \n"
+      "movq        0x02(%0,%1,1),%%xmm2          \n"
+      "punpcklbw   %%xmm5,%%xmm1                 \n"
+      "punpcklbw   %%xmm5,%%xmm2                 \n"
+      "psubw       %%xmm2,%%xmm1                 \n"
+      "movq        0x00(%0,%2,1),%%xmm2          \n"
+      "movq        0x02(%0,%2,1),%%xmm3          \n"
+      "punpcklbw   %%xmm5,%%xmm2                 \n"
+      "punpcklbw   %%xmm5,%%xmm3                 \n"
+      "psubw       %%xmm3,%%xmm2                 \n"
+      "paddw       %%xmm2,%%xmm0                 \n"
+      "paddw       %%xmm1,%%xmm0                 \n"
+      "paddw       %%xmm1,%%xmm0                 \n"
+      "pxor        %%xmm1,%%xmm1                 \n"
+      "psubw       %%xmm0,%%xmm1                 \n"
+      "pmaxsw      %%xmm1,%%xmm0                 \n"
+      "packuswb    %%xmm0,%%xmm0                 \n"
+      "movq        %%xmm0,0x00(%0,%3,1)          \n"
+      "lea         0x8(%0),%0                    \n"
+      "sub         $0x8,%4                       \n"
+      "jg          1b                            \n"
+      : "+r"(src_y0),      // %0
+        "+r"(src_y1),      // %1
+        "+r"(src_y2),      // %2
+        "+r"(dst_sobelx),  // %3
+        "+r"(width)        // %4
+      :
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm5");
+}
+#endif  // HAS_SOBELXROW_SSE2
+
+#ifdef HAS_SOBELYROW_SSE2
+// SobelY as a matrix is
+// -1 -2 -1
+//  0  0  0
+//  1  2  1
+void SobelYRow_SSE2(const uint8_t* src_y0,
+                    const uint8_t* src_y1,
+                    uint8_t* dst_sobely,
+                    int width) {
+  asm volatile(
+      "sub         %0,%1                         \n"
+      "sub         %0,%2                         \n"
+      "pxor        %%xmm5,%%xmm5                 \n"
+
+      // 8 pixel loop.
+      LABELALIGN
+      "1:                                        \n"
+      "movq        (%0),%%xmm0                   \n"
+      "movq        0x00(%0,%1,1),%%xmm1          \n"
+      "punpcklbw   %%xmm5,%%xmm0                 \n"
+      "punpcklbw   %%xmm5,%%xmm1                 \n"
+      "psubw       %%xmm1,%%xmm0                 \n"
+      "movq        0x1(%0),%%xmm1                \n"
+      "movq        0x01(%0,%1,1),%%xmm2          \n"
+      "punpcklbw   %%xmm5,%%xmm1                 \n"
+      "punpcklbw   %%xmm5,%%xmm2                 \n"
+      "psubw       %%xmm2,%%xmm1                 \n"
+      "movq        0x2(%0),%%xmm2                \n"
+      "movq        0x02(%0,%1,1),%%xmm3          \n"
+      "punpcklbw   %%xmm5,%%xmm2                 \n"
+      "punpcklbw   %%xmm5,%%xmm3                 \n"
+      "psubw       %%xmm3,%%xmm2                 \n"
+      "paddw       %%xmm2,%%xmm0                 \n"
+      "paddw       %%xmm1,%%xmm0                 \n"
+      "paddw       %%xmm1,%%xmm0                 \n"
+      "pxor        %%xmm1,%%xmm1                 \n"
+      "psubw       %%xmm0,%%xmm1                 \n"
+      "pmaxsw      %%xmm1,%%xmm0                 \n"
+      "packuswb    %%xmm0,%%xmm0                 \n"
+      "movq        %%xmm0,0x00(%0,%2,1)          \n"
+      "lea         0x8(%0),%0                    \n"
+      "sub         $0x8,%3                       \n"
+      "jg          1b                            \n"
+      : "+r"(src_y0),      // %0
+        "+r"(src_y1),      // %1
+        "+r"(dst_sobely),  // %2
+        "+r"(width)        // %3
+      :
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm5");
+}
+#endif  // HAS_SOBELYROW_SSE2
+
+#ifdef HAS_SOBELROW_SSE2
+// Adds Sobel X and Sobel Y and stores Sobel into ARGB.
+// A = 255
+// R = Sobel
+// G = Sobel
+// B = Sobel
+void SobelRow_SSE2(const uint8_t* src_sobelx,
+                   const uint8_t* src_sobely,
+                   uint8_t* dst_argb,
+                   int width) {
+  asm volatile(
+      "sub         %0,%1                         \n"
+      "pcmpeqb     %%xmm5,%%xmm5                 \n"
+      "pslld       $0x18,%%xmm5                  \n"
+
+      // 8 pixel loop.
+      LABELALIGN
+      "1:                                        \n"
+      "movdqu      (%0),%%xmm0                   \n"
+      "movdqu      0x00(%0,%1,1),%%xmm1          \n"
+      "lea         0x10(%0),%0                   \n"
+      "paddusb     %%xmm1,%%xmm0                 \n"
+      "movdqa      %%xmm0,%%xmm2                 \n"
+      "punpcklbw   %%xmm0,%%xmm2                 \n"
+      "punpckhbw   %%xmm0,%%xmm0                 \n"
+      "movdqa      %%xmm2,%%xmm1                 \n"
+      "punpcklwd   %%xmm2,%%xmm1                 \n"
+      "punpckhwd   %%xmm2,%%xmm2                 \n"
+      "por         %%xmm5,%%xmm1                 \n"
+      "por         %%xmm5,%%xmm2                 \n"
+      "movdqa      %%xmm0,%%xmm3                 \n"
+      "punpcklwd   %%xmm0,%%xmm3                 \n"
+      "punpckhwd   %%xmm0,%%xmm0                 \n"
+      "por         %%xmm5,%%xmm3                 \n"
+      "por         %%xmm5,%%xmm0                 \n"
+      "movdqu      %%xmm1,(%2)                   \n"
+      "movdqu      %%xmm2,0x10(%2)               \n"
+      "movdqu      %%xmm3,0x20(%2)               \n"
+      "movdqu      %%xmm0,0x30(%2)               \n"
+      "lea         0x40(%2),%2                   \n"
+      "sub         $0x10,%3                      \n"
+      "jg          1b                            \n"
+      : "+r"(src_sobelx),  // %0
+        "+r"(src_sobely),  // %1
+        "+r"(dst_argb),    // %2
+        "+r"(width)        // %3
+      :
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm5");
+}
+#endif  // HAS_SOBELROW_SSE2
+
+#ifdef HAS_SOBELTOPLANEROW_SSE2
+// Adds Sobel X and Sobel Y and stores Sobel into a plane.
+void SobelToPlaneRow_SSE2(const uint8_t* src_sobelx,
+                          const uint8_t* src_sobely,
+                          uint8_t* dst_y,
+                          int width) {
+  asm volatile(
+      "sub         %0,%1                         \n"
+      "pcmpeqb     %%xmm5,%%xmm5                 \n"
+      "pslld       $0x18,%%xmm5                  \n"
+
+      // 8 pixel loop.
+      LABELALIGN
+      "1:                                        \n"
+      "movdqu      (%0),%%xmm0                   \n"
+      "movdqu      0x00(%0,%1,1),%%xmm1          \n"
+      "lea         0x10(%0),%0                   \n"
+      "paddusb     %%xmm1,%%xmm0                 \n"
+      "movdqu      %%xmm0,(%2)                   \n"
+      "lea         0x10(%2),%2                   \n"
+      "sub         $0x10,%3                      \n"
+      "jg          1b                            \n"
+      : "+r"(src_sobelx),  // %0
+        "+r"(src_sobely),  // %1
+        "+r"(dst_y),       // %2
+        "+r"(width)        // %3
+      :
+      : "memory", "cc", "xmm0", "xmm1");
+}
+#endif  // HAS_SOBELTOPLANEROW_SSE2
+
+#ifdef HAS_SOBELXYROW_SSE2
+// Mixes Sobel X, Sobel Y and Sobel into ARGB.
+// A = 255
+// R = Sobel X
+// G = Sobel
+// B = Sobel Y
+void SobelXYRow_SSE2(const uint8_t* src_sobelx,
+                     const uint8_t* src_sobely,
+                     uint8_t* dst_argb,
+                     int width) {
+  asm volatile(
+      "sub         %0,%1                         \n"
+      "pcmpeqb     %%xmm5,%%xmm5                 \n"
+
+      // 8 pixel loop.
+      LABELALIGN
+      "1:                                        \n"
+      "movdqu      (%0),%%xmm0                   \n"
+      "movdqu      0x00(%0,%1,1),%%xmm1          \n"
+      "lea         0x10(%0),%0                   \n"
+      "movdqa      %%xmm0,%%xmm2                 \n"
+      "paddusb     %%xmm1,%%xmm2                 \n"
+      "movdqa      %%xmm0,%%xmm3                 \n"
+      "punpcklbw   %%xmm5,%%xmm3                 \n"
+      "punpckhbw   %%xmm5,%%xmm0                 \n"
+      "movdqa      %%xmm1,%%xmm4                 \n"
+      "punpcklbw   %%xmm2,%%xmm4                 \n"
+      "punpckhbw   %%xmm2,%%xmm1                 \n"
+      "movdqa      %%xmm4,%%xmm6                 \n"
+      "punpcklwd   %%xmm3,%%xmm6                 \n"
+      "punpckhwd   %%xmm3,%%xmm4                 \n"
+      "movdqa      %%xmm1,%%xmm7                 \n"
+      "punpcklwd   %%xmm0,%%xmm7                 \n"
+      "punpckhwd   %%xmm0,%%xmm1                 \n"
+      "movdqu      %%xmm6,(%2)                   \n"
+      "movdqu      %%xmm4,0x10(%2)               \n"
+      "movdqu      %%xmm7,0x20(%2)               \n"
+      "movdqu      %%xmm1,0x30(%2)               \n"
+      "lea         0x40(%2),%2                   \n"
+      "sub         $0x10,%3                      \n"
+      "jg          1b                            \n"
+      : "+r"(src_sobelx),  // %0
+        "+r"(src_sobely),  // %1
+        "+r"(dst_argb),    // %2
+        "+r"(width)        // %3
+      :
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6",
+        "xmm7");
+}
+#endif  // HAS_SOBELXYROW_SSE2
+
+#ifdef HAS_COMPUTECUMULATIVESUMROW_SSE2
+// Creates a table of cumulative sums where each value is a sum of all values
+// above and to the left of the value, inclusive of the value.
+void ComputeCumulativeSumRow_SSE2(const uint8_t* row,
+                                  int32_t* cumsum,
+                                  const int32_t* previous_cumsum,
+                                  int width) {
+  asm volatile(
+      "pxor        %%xmm0,%%xmm0                 \n"
+      "pxor        %%xmm1,%%xmm1                 \n"
+      "sub         $0x4,%3                       \n"
+      "jl          49f                           \n"
+      "test        $0xf,%1                       \n"
+      "jne         49f                           \n"
+
+      // 4 pixel loop.
+      LABELALIGN
+      "40:                                       \n"
+      "movdqu      (%0),%%xmm2                   \n"
+      "lea         0x10(%0),%0                   \n"
+      "movdqa      %%xmm2,%%xmm4                 \n"
+      "punpcklbw   %%xmm1,%%xmm2                 \n"
+      "movdqa      %%xmm2,%%xmm3                 \n"
+      "punpcklwd   %%xmm1,%%xmm2                 \n"
+      "punpckhwd   %%xmm1,%%xmm3                 \n"
+      "punpckhbw   %%xmm1,%%xmm4                 \n"
+      "movdqa      %%xmm4,%%xmm5                 \n"
+      "punpcklwd   %%xmm1,%%xmm4                 \n"
+      "punpckhwd   %%xmm1,%%xmm5                 \n"
+      "paddd       %%xmm2,%%xmm0                 \n"
+      "movdqu      (%2),%%xmm2                   \n"
+      "paddd       %%xmm0,%%xmm2                 \n"
+      "paddd       %%xmm3,%%xmm0                 \n"
+      "movdqu      0x10(%2),%%xmm3               \n"
+      "paddd       %%xmm0,%%xmm3                 \n"
+      "paddd       %%xmm4,%%xmm0                 \n"
+      "movdqu      0x20(%2),%%xmm4               \n"
+      "paddd       %%xmm0,%%xmm4                 \n"
+      "paddd       %%xmm5,%%xmm0                 \n"
+      "movdqu      0x30(%2),%%xmm5               \n"
+      "lea         0x40(%2),%2                   \n"
+      "paddd       %%xmm0,%%xmm5                 \n"
+      "movdqu      %%xmm2,(%1)                   \n"
+      "movdqu      %%xmm3,0x10(%1)               \n"
+      "movdqu      %%xmm4,0x20(%1)               \n"
+      "movdqu      %%xmm5,0x30(%1)               \n"
+      "lea         0x40(%1),%1                   \n"
+      "sub         $0x4,%3                       \n"
+      "jge         40b                           \n"
+
+      "49:                                       \n"
+      "add         $0x3,%3                       \n"
+      "jl          19f                           \n"
+
+      // 1 pixel loop.
+      LABELALIGN
+      "10:                                       \n"
+      "movd        (%0),%%xmm2                   \n"
+      "lea         0x4(%0),%0                    \n"
+      "punpcklbw   %%xmm1,%%xmm2                 \n"
+      "punpcklwd   %%xmm1,%%xmm2                 \n"
+      "paddd       %%xmm2,%%xmm0                 \n"
+      "movdqu      (%2),%%xmm2                   \n"
+      "lea         0x10(%2),%2                   \n"
+      "paddd       %%xmm0,%%xmm2                 \n"
+      "movdqu      %%xmm2,(%1)                   \n"
+      "lea         0x10(%1),%1                   \n"
+      "sub         $0x1,%3                       \n"
+      "jge         10b                           \n"
+
+      "19:                                       \n"
+      : "+r"(row),              // %0
+        "+r"(cumsum),           // %1
+        "+r"(previous_cumsum),  // %2
+        "+r"(width)             // %3
+      :
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5");
+}
+#endif  // HAS_COMPUTECUMULATIVESUMROW_SSE2
+
+#ifdef HAS_CUMULATIVESUMTOAVERAGEROW_SSE2
+void CumulativeSumToAverageRow_SSE2(const int32_t* topleft,
+                                    const int32_t* botleft,
+                                    int width,
+                                    int area,
+                                    uint8_t* dst,
+                                    int count) {
+  asm volatile(
+      "movd        %5,%%xmm5                     \n"
+      "cvtdq2ps    %%xmm5,%%xmm5                 \n"
+      "rcpss       %%xmm5,%%xmm4                 \n"
+      "pshufd      $0x0,%%xmm4,%%xmm4            \n"
+      "sub         $0x4,%3                       \n"
+      "jl          49f                           \n"
+      "cmpl        $0x80,%5                      \n"
+      "ja          40f                           \n"
+
+      "pshufd      $0x0,%%xmm5,%%xmm5            \n"
+      "pcmpeqb     %%xmm6,%%xmm6                 \n"
+      "psrld       $0x10,%%xmm6                  \n"
+      "cvtdq2ps    %%xmm6,%%xmm6                 \n"
+      "addps       %%xmm6,%%xmm5                 \n"
+      "mulps       %%xmm4,%%xmm5                 \n"
+      "cvtps2dq    %%xmm5,%%xmm5                 \n"
+      "packssdw    %%xmm5,%%xmm5                 \n"
+
+      // 4 pixel small loop.
+      LABELALIGN
+      "4:                                        \n"
+      "movdqu      (%0),%%xmm0                   \n"
+      "movdqu      0x10(%0),%%xmm1               \n"
+      "movdqu      0x20(%0),%%xmm2               \n"
+      "movdqu      0x30(%0),%%xmm3               \n"
+      "psubd       0x00(%0,%4,4),%%xmm0          \n"
+      "psubd       0x10(%0,%4,4),%%xmm1          \n"
+      "psubd       0x20(%0,%4,4),%%xmm2          \n"
+      "psubd       0x30(%0,%4,4),%%xmm3          \n"
+      "lea         0x40(%0),%0                   \n"
+      "psubd       (%1),%%xmm0                   \n"
+      "psubd       0x10(%1),%%xmm1               \n"
+      "psubd       0x20(%1),%%xmm2               \n"
+      "psubd       0x30(%1),%%xmm3               \n"
+      "paddd       0x00(%1,%4,4),%%xmm0          \n"
+      "paddd       0x10(%1,%4,4),%%xmm1          \n"
+      "paddd       0x20(%1,%4,4),%%xmm2          \n"
+      "paddd       0x30(%1,%4,4),%%xmm3          \n"
+      "lea         0x40(%1),%1                   \n"
+      "packssdw    %%xmm1,%%xmm0                 \n"
+      "packssdw    %%xmm3,%%xmm2                 \n"
+      "pmulhuw     %%xmm5,%%xmm0                 \n"
+      "pmulhuw     %%xmm5,%%xmm2                 \n"
+      "packuswb    %%xmm2,%%xmm0                 \n"
+      "movdqu      %%xmm0,(%2)                   \n"
+      "lea         0x10(%2),%2                   \n"
+      "sub         $0x4,%3                       \n"
+      "jge         4b                            \n"
+      "jmp         49f                           \n"
+
+      // 4 pixel loop
+      LABELALIGN
+      "40:                                       \n"
+      "movdqu      (%0),%%xmm0                   \n"
+      "movdqu      0x10(%0),%%xmm1               \n"
+      "movdqu      0x20(%0),%%xmm2               \n"
+      "movdqu      0x30(%0),%%xmm3               \n"
+      "psubd       0x00(%0,%4,4),%%xmm0          \n"
+      "psubd       0x10(%0,%4,4),%%xmm1          \n"
+      "psubd       0x20(%0,%4,4),%%xmm2          \n"
+      "psubd       0x30(%0,%4,4),%%xmm3          \n"
+      "lea         0x40(%0),%0                   \n"
+      "psubd       (%1),%%xmm0                   \n"
+      "psubd       0x10(%1),%%xmm1               \n"
+      "psubd       0x20(%1),%%xmm2               \n"
+      "psubd       0x30(%1),%%xmm3               \n"
+      "paddd       0x00(%1,%4,4),%%xmm0          \n"
+      "paddd       0x10(%1,%4,4),%%xmm1          \n"
+      "paddd       0x20(%1,%4,4),%%xmm2          \n"
+      "paddd       0x30(%1,%4,4),%%xmm3          \n"
+      "lea         0x40(%1),%1                   \n"
+      "cvtdq2ps    %%xmm0,%%xmm0                 \n"
+      "cvtdq2ps    %%xmm1,%%xmm1                 \n"
+      "mulps       %%xmm4,%%xmm0                 \n"
+      "mulps       %%xmm4,%%xmm1                 \n"
+      "cvtdq2ps    %%xmm2,%%xmm2                 \n"
+      "cvtdq2ps    %%xmm3,%%xmm3                 \n"
+      "mulps       %%xmm4,%%xmm2                 \n"
+      "mulps       %%xmm4,%%xmm3                 \n"
+      "cvtps2dq    %%xmm0,%%xmm0                 \n"
+      "cvtps2dq    %%xmm1,%%xmm1                 \n"
+      "cvtps2dq    %%xmm2,%%xmm2                 \n"
+      "cvtps2dq    %%xmm3,%%xmm3                 \n"
+      "packssdw    %%xmm1,%%xmm0                 \n"
+      "packssdw    %%xmm3,%%xmm2                 \n"
+      "packuswb    %%xmm2,%%xmm0                 \n"
+      "movdqu      %%xmm0,(%2)                   \n"
+      "lea         0x10(%2),%2                   \n"
+      "sub         $0x4,%3                       \n"
+      "jge         40b                           \n"
+
+      "49:                                       \n"
+      "add         $0x3,%3                       \n"
+      "jl          19f                           \n"
+
+      // 1 pixel loop
+      LABELALIGN
+      "10:                                       \n"
+      "movdqu      (%0),%%xmm0                   \n"
+      "psubd       0x00(%0,%4,4),%%xmm0          \n"
+      "lea         0x10(%0),%0                   \n"
+      "psubd       (%1),%%xmm0                   \n"
+      "paddd       0x00(%1,%4,4),%%xmm0          \n"
+      "lea         0x10(%1),%1                   \n"
+      "cvtdq2ps    %%xmm0,%%xmm0                 \n"
+      "mulps       %%xmm4,%%xmm0                 \n"
+      "cvtps2dq    %%xmm0,%%xmm0                 \n"
+      "packssdw    %%xmm0,%%xmm0                 \n"
+      "packuswb    %%xmm0,%%xmm0                 \n"
+      "movd        %%xmm0,(%2)                   \n"
+      "lea         0x4(%2),%2                    \n"
+      "sub         $0x1,%3                       \n"
+      "jge         10b                           \n"
+      "19:                                       \n"
+      : "+r"(topleft),           // %0
+        "+r"(botleft),           // %1
+        "+r"(dst),               // %2
+        "+rm"(count)             // %3
+      : "r"((intptr_t)(width)),  // %4
+        "rm"(area)               // %5
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6");
+}
+#endif  // HAS_CUMULATIVESUMTOAVERAGEROW_SSE2
+
+#ifdef HAS_ARGBAFFINEROW_SSE2
+// Copy ARGB pixels from source image with slope to a row of destination.
+LIBYUV_API
+void ARGBAffineRow_SSE2(const uint8_t* src_argb,
+                        int src_argb_stride,
+                        uint8_t* dst_argb,
+                        const float* src_dudv,
+                        int width) {
+  intptr_t src_argb_stride_temp = src_argb_stride;
+  intptr_t temp;
+  asm volatile(
+      "movq        (%3),%%xmm2                   \n"
+      "movq        0x08(%3),%%xmm7               \n"
+      "shl         $0x10,%1                      \n"
+      "add         $0x4,%1                       \n"
+      "movd        %1,%%xmm5                     \n"
+      "sub         $0x4,%4                       \n"
+      "jl          49f                           \n"
+
+      "pshufd      $0x44,%%xmm7,%%xmm7           \n"
+      "pshufd      $0x0,%%xmm5,%%xmm5            \n"
+      "movdqa      %%xmm2,%%xmm0                 \n"
+      "addps       %%xmm7,%%xmm0                 \n"
+      "movlhps     %%xmm0,%%xmm2                 \n"
+      "movdqa      %%xmm7,%%xmm4                 \n"
+      "addps       %%xmm4,%%xmm4                 \n"
+      "movdqa      %%xmm2,%%xmm3                 \n"
+      "addps       %%xmm4,%%xmm3                 \n"
+      "addps       %%xmm4,%%xmm4                 \n"
+
+      // 4 pixel loop
+      LABELALIGN
+      "40:                                       \n"
+      "cvttps2dq   %%xmm2,%%xmm0                 \n"  // x,y float->int first 2
+      "cvttps2dq   %%xmm3,%%xmm1                 \n"  // x,y float->int next 2
+      "packssdw    %%xmm1,%%xmm0                 \n"  // x, y as 8 shorts
+      "pmaddwd     %%xmm5,%%xmm0                 \n"  // off = x*4 + y*stride
+      "movd        %%xmm0,%k1                    \n"
+      "pshufd      $0x39,%%xmm0,%%xmm0           \n"
+      "movd        %%xmm0,%k5                    \n"
+      "pshufd      $0x39,%%xmm0,%%xmm0           \n"
+      "movd        0x00(%0,%1,1),%%xmm1          \n"
+      "movd        0x00(%0,%5,1),%%xmm6          \n"
+      "punpckldq   %%xmm6,%%xmm1                 \n"
+      "addps       %%xmm4,%%xmm2                 \n"
+      "movq        %%xmm1,(%2)                   \n"
+      "movd        %%xmm0,%k1                    \n"
+      "pshufd      $0x39,%%xmm0,%%xmm0           \n"
+      "movd        %%xmm0,%k5                    \n"
+      "movd        0x00(%0,%1,1),%%xmm0          \n"
+      "movd        0x00(%0,%5,1),%%xmm6          \n"
+      "punpckldq   %%xmm6,%%xmm0                 \n"
+      "addps       %%xmm4,%%xmm3                 \n"
+      "movq        %%xmm0,0x08(%2)               \n"
+      "lea         0x10(%2),%2                   \n"
+      "sub         $0x4,%4                       \n"
+      "jge         40b                           \n"
+
+      "49:                                       \n"
+      "add         $0x3,%4                       \n"
+      "jl          19f                           \n"
+
+      // 1 pixel loop
+      LABELALIGN
+      "10:                                       \n"
+      "cvttps2dq   %%xmm2,%%xmm0                 \n"
+      "packssdw    %%xmm0,%%xmm0                 \n"
+      "pmaddwd     %%xmm5,%%xmm0                 \n"
+      "addps       %%xmm7,%%xmm2                 \n"
+      "movd        %%xmm0,%k1                    \n"
+      "movd        0x00(%0,%1,1),%%xmm0          \n"
+      "movd        %%xmm0,(%2)                   \n"
+      "lea         0x04(%2),%2                   \n"
+      "sub         $0x1,%4                       \n"
+      "jge         10b                           \n"
+      "19:                                       \n"
+      : "+r"(src_argb),              // %0
+        "+r"(src_argb_stride_temp),  // %1
+        "+r"(dst_argb),              // %2
+        "+r"(src_dudv),              // %3
+        "+rm"(width),                // %4
+        "=&r"(temp)                  // %5
+      :
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6",
+        "xmm7");
+}
+#endif  // HAS_ARGBAFFINEROW_SSE2
+
+#ifdef HAS_INTERPOLATEROW_SSSE3
+// Bilinear filter 16x2 -> 16x1
+void InterpolateRow_SSSE3(uint8_t* dst_ptr,
+                          const uint8_t* src_ptr,
+                          ptrdiff_t src_stride,
+                          int width,
+                          int source_y_fraction) {
+  asm volatile(
+      "sub         %1,%0                         \n"
+      "cmp         $0x0,%3                       \n"
+      "je          100f                          \n"
+      "cmp         $0x80,%3                      \n"
+      "je          50f                           \n"
+
+      "movd        %3,%%xmm0                     \n"
+      "neg         %3                            \n"
+      "add         $0x100,%3                     \n"
+      "movd        %3,%%xmm5                     \n"
+      "punpcklbw   %%xmm0,%%xmm5                 \n"
+      "punpcklwd   %%xmm5,%%xmm5                 \n"
+      "pshufd      $0x0,%%xmm5,%%xmm5            \n"
+      "mov         $0x80808080,%%eax             \n"
+      "movd        %%eax,%%xmm4                  \n"
+      "pshufd      $0x0,%%xmm4,%%xmm4            \n"
+
+      // General purpose row blend.
+      LABELALIGN
+      "1:                                        \n"
+      "movdqu      (%1),%%xmm0                   \n"
+      "movdqu      0x00(%1,%4,1),%%xmm2          \n"
+      "movdqa      %%xmm0,%%xmm1                 \n"
+      "punpcklbw   %%xmm2,%%xmm0                 \n"
+      "punpckhbw   %%xmm2,%%xmm1                 \n"
+      "psubb       %%xmm4,%%xmm0                 \n"
+      "psubb       %%xmm4,%%xmm1                 \n"
+      "movdqa      %%xmm5,%%xmm2                 \n"
+      "movdqa      %%xmm5,%%xmm3                 \n"
+      "pmaddubsw   %%xmm0,%%xmm2                 \n"
+      "pmaddubsw   %%xmm1,%%xmm3                 \n"
+      "paddw       %%xmm4,%%xmm2                 \n"
+      "paddw       %%xmm4,%%xmm3                 \n"
+      "psrlw       $0x8,%%xmm2                   \n"
+      "psrlw       $0x8,%%xmm3                   \n"
+      "packuswb    %%xmm3,%%xmm2                 \n"
+      "movdqu      %%xmm2,0x00(%1,%0,1)          \n"
+      "lea         0x10(%1),%1                   \n"
+      "sub         $0x10,%2                      \n"
+      "jg          1b                            \n"
+      "jmp         99f                           \n"
+
+      // Blend 50 / 50.
+      LABELALIGN
+      "50:                                       \n"
+      "movdqu      (%1),%%xmm0                   \n"
+      "movdqu      0x00(%1,%4,1),%%xmm1          \n"
+      "pavgb       %%xmm1,%%xmm0                 \n"
+      "movdqu      %%xmm0,0x00(%1,%0,1)          \n"
+      "lea         0x10(%1),%1                   \n"
+      "sub         $0x10,%2                      \n"
+      "jg          50b                           \n"
+      "jmp         99f                           \n"
+
+      // Blend 100 / 0 - Copy row unchanged.
+      LABELALIGN
+      "100:                                      \n"
+      "movdqu      (%1),%%xmm0                   \n"
+      "movdqu      %%xmm0,0x00(%1,%0,1)          \n"
+      "lea         0x10(%1),%1                   \n"
+      "sub         $0x10,%2                      \n"
+      "jg          100b                          \n"
+
+      "99:                                       \n"
+      : "+r"(dst_ptr),               // %0
+        "+r"(src_ptr),               // %1
+        "+rm"(width),                // %2
+        "+r"(source_y_fraction)      // %3
+      : "r"((intptr_t)(src_stride))  // %4
+      : "memory", "cc", "eax", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5");
+}
+#endif  // HAS_INTERPOLATEROW_SSSE3
+
+#ifdef HAS_INTERPOLATEROW_AVX2
+// Bilinear filter 32x2 -> 32x1
+void InterpolateRow_AVX2(uint8_t* dst_ptr,
+                         const uint8_t* src_ptr,
+                         ptrdiff_t src_stride,
+                         int width,
+                         int source_y_fraction) {
+  asm volatile(
+      "sub         %1,%0                         \n"
+      "cmp         $0x0,%3                       \n"
+      "je          100f                          \n"
+      "cmp         $0x80,%3                      \n"
+      "je          50f                           \n"
+
+      "vmovd       %3,%%xmm0                     \n"
+      "neg         %3                            \n"
+      "add         $0x100,%3                     \n"
+      "vmovd       %3,%%xmm5                     \n"
+      "vpunpcklbw  %%xmm0,%%xmm5,%%xmm5          \n"
+      "vpunpcklwd  %%xmm5,%%xmm5,%%xmm5          \n"
+      "vbroadcastss %%xmm5,%%ymm5                \n"
+      "mov         $0x80808080,%%eax             \n"
+      "vmovd       %%eax,%%xmm4                  \n"
+      "vbroadcastss %%xmm4,%%ymm4                \n"
+
+      // General purpose row blend.
+      LABELALIGN
+      "1:                                        \n"
+      "vmovdqu     (%1),%%ymm0                   \n"
+      "vmovdqu     0x00(%1,%4,1),%%ymm2          \n"
+      "vpunpckhbw  %%ymm2,%%ymm0,%%ymm1          \n"
+      "vpunpcklbw  %%ymm2,%%ymm0,%%ymm0          \n"
+      "vpsubb      %%ymm4,%%ymm1,%%ymm1          \n"
+      "vpsubb      %%ymm4,%%ymm0,%%ymm0          \n"
+      "vpmaddubsw  %%ymm1,%%ymm5,%%ymm1          \n"
+      "vpmaddubsw  %%ymm0,%%ymm5,%%ymm0          \n"
+      "vpaddw      %%ymm4,%%ymm1,%%ymm1          \n"
+      "vpaddw      %%ymm4,%%ymm0,%%ymm0          \n"
+      "vpsrlw      $0x8,%%ymm1,%%ymm1            \n"
+      "vpsrlw      $0x8,%%ymm0,%%ymm0            \n"
+      "vpackuswb   %%ymm1,%%ymm0,%%ymm0          \n"
+      "vmovdqu     %%ymm0,0x00(%1,%0,1)          \n"
+      "lea         0x20(%1),%1                   \n"
+      "sub         $0x20,%2                      \n"
+      "jg          1b                            \n"
+      "jmp         99f                           \n"
+
+      // Blend 50 / 50.
+      LABELALIGN
+      "50:                                       \n"
+      "vmovdqu     (%1),%%ymm0                   \n"
+      "vpavgb      0x00(%1,%4,1),%%ymm0,%%ymm0   \n"
+      "vmovdqu     %%ymm0,0x00(%1,%0,1)          \n"
+      "lea         0x20(%1),%1                   \n"
+      "sub         $0x20,%2                      \n"
+      "jg          50b                           \n"
+      "jmp         99f                           \n"
+
+      // Blend 100 / 0 - Copy row unchanged.
+      LABELALIGN
+      "100:                                      \n"
+      "vmovdqu     (%1),%%ymm0                   \n"
+      "vmovdqu     %%ymm0,0x00(%1,%0,1)          \n"
+      "lea         0x20(%1),%1                   \n"
+      "sub         $0x20,%2                      \n"
+      "jg          100b                          \n"
+
+      "99:                                       \n"
+      "vzeroupper                                \n"
+      : "+r"(dst_ptr),               // %0
+        "+r"(src_ptr),               // %1
+        "+r"(width),                 // %2
+        "+r"(source_y_fraction)      // %3
+      : "r"((intptr_t)(src_stride))  // %4
+      : "memory", "cc", "eax", "xmm0", "xmm1", "xmm2", "xmm4", "xmm5");
+}
+#endif  // HAS_INTERPOLATEROW_AVX2
+
+#ifdef HAS_ARGBSHUFFLEROW_SSSE3
+// For BGRAToARGB, ABGRToARGB, RGBAToARGB, and ARGBToRGBA.
+void ARGBShuffleRow_SSSE3(const uint8_t* src_argb,
+                          uint8_t* dst_argb,
+                          const uint8_t* shuffler,
+                          int width) {
+  asm volatile(
+
+      "movdqu      (%3),%%xmm5                   \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "movdqu      (%0),%%xmm0                   \n"
+      "movdqu      0x10(%0),%%xmm1               \n"
+      "lea         0x20(%0),%0                   \n"
+      "pshufb      %%xmm5,%%xmm0                 \n"
+      "pshufb      %%xmm5,%%xmm1                 \n"
+      "movdqu      %%xmm0,(%1)                   \n"
+      "movdqu      %%xmm1,0x10(%1)               \n"
+      "lea         0x20(%1),%1                   \n"
+      "sub         $0x8,%2                       \n"
+      "jg          1b                            \n"
+      : "+r"(src_argb),  // %0
+        "+r"(dst_argb),  // %1
+        "+r"(width)      // %2
+      : "r"(shuffler)    // %3
+      : "memory", "cc", "xmm0", "xmm1", "xmm5");
+}
+#endif  // HAS_ARGBSHUFFLEROW_SSSE3
+
+#ifdef HAS_ARGBSHUFFLEROW_AVX2
+// For BGRAToARGB, ABGRToARGB, RGBAToARGB, and ARGBToRGBA.
+void ARGBShuffleRow_AVX2(const uint8_t* src_argb,
+                         uint8_t* dst_argb,
+                         const uint8_t* shuffler,
+                         int width) {
+  asm volatile(
+
+      "vbroadcastf128 (%3),%%ymm5                \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "vmovdqu     (%0),%%ymm0                   \n"
+      "vmovdqu     0x20(%0),%%ymm1               \n"
+      "lea         0x40(%0),%0                   \n"
+      "vpshufb     %%ymm5,%%ymm0,%%ymm0          \n"
+      "vpshufb     %%ymm5,%%ymm1,%%ymm1          \n"
+      "vmovdqu     %%ymm0,(%1)                   \n"
+      "vmovdqu     %%ymm1,0x20(%1)               \n"
+      "lea         0x40(%1),%1                   \n"
+      "sub         $0x10,%2                      \n"
+      "jg          1b                            \n"
+      "vzeroupper                                \n"
+      : "+r"(src_argb),  // %0
+        "+r"(dst_argb),  // %1
+        "+r"(width)      // %2
+      : "r"(shuffler)    // %3
+      : "memory", "cc", "xmm0", "xmm1", "xmm5");
+}
+#endif  // HAS_ARGBSHUFFLEROW_AVX2
+
+#ifdef HAS_I422TOYUY2ROW_SSE2
+void I422ToYUY2Row_SSE2(const uint8_t* src_y,
+                        const uint8_t* src_u,
+                        const uint8_t* src_v,
+                        uint8_t* dst_yuy2,
+                        int width) {
+  asm volatile(
+
+      "sub         %1,%2                         \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "movq        (%1),%%xmm2                   \n"
+      "movq        0x00(%1,%2,1),%%xmm1          \n"
+      "add         $0x8,%1                       \n"
+      "punpcklbw   %%xmm1,%%xmm2                 \n"
+      "movdqu      (%0),%%xmm0                   \n"
+      "add         $0x10,%0                      \n"
+      "movdqa      %%xmm0,%%xmm1                 \n"
+      "punpcklbw   %%xmm2,%%xmm0                 \n"
+      "punpckhbw   %%xmm2,%%xmm1                 \n"
+      "movdqu      %%xmm0,(%3)                   \n"
+      "movdqu      %%xmm1,0x10(%3)               \n"
+      "lea         0x20(%3),%3                   \n"
+      "sub         $0x10,%4                      \n"
+      "jg          1b                            \n"
+      : "+r"(src_y),     // %0
+        "+r"(src_u),     // %1
+        "+r"(src_v),     // %2
+        "+r"(dst_yuy2),  // %3
+        "+rm"(width)     // %4
+      :
+      : "memory", "cc", "xmm0", "xmm1", "xmm2");
+}
+#endif  // HAS_I422TOYUY2ROW_SSE2
+
+#ifdef HAS_I422TOUYVYROW_SSE2
+void I422ToUYVYRow_SSE2(const uint8_t* src_y,
+                        const uint8_t* src_u,
+                        const uint8_t* src_v,
+                        uint8_t* dst_uyvy,
+                        int width) {
+  asm volatile(
+
+      "sub         %1,%2                         \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "movq        (%1),%%xmm2                   \n"
+      "movq        0x00(%1,%2,1),%%xmm1          \n"
+      "add         $0x8,%1                       \n"
+      "punpcklbw   %%xmm1,%%xmm2                 \n"
+      "movdqu      (%0),%%xmm0                   \n"
+      "movdqa      %%xmm2,%%xmm1                 \n"
+      "add         $0x10,%0                      \n"
+      "punpcklbw   %%xmm0,%%xmm1                 \n"
+      "punpckhbw   %%xmm0,%%xmm2                 \n"
+      "movdqu      %%xmm1,(%3)                   \n"
+      "movdqu      %%xmm2,0x10(%3)               \n"
+      "lea         0x20(%3),%3                   \n"
+      "sub         $0x10,%4                      \n"
+      "jg          1b                            \n"
+      : "+r"(src_y),     // %0
+        "+r"(src_u),     // %1
+        "+r"(src_v),     // %2
+        "+r"(dst_uyvy),  // %3
+        "+rm"(width)     // %4
+      :
+      : "memory", "cc", "xmm0", "xmm1", "xmm2");
+}
+#endif  // HAS_I422TOUYVYROW_SSE2
+
+#ifdef HAS_I422TOYUY2ROW_AVX2
+void I422ToYUY2Row_AVX2(const uint8_t* src_y,
+                        const uint8_t* src_u,
+                        const uint8_t* src_v,
+                        uint8_t* dst_yuy2,
+                        int width) {
+  asm volatile(
+
+      "sub         %1,%2                         \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "vpmovzxbw   (%1),%%ymm1                   \n"
+      "vpmovzxbw   0x00(%1,%2,1),%%ymm2          \n"
+      "add         $0x10,%1                      \n"
+      "vpsllw      $0x8,%%ymm2,%%ymm2            \n"
+      "vpor        %%ymm1,%%ymm2,%%ymm2          \n"
+      "vmovdqu     (%0),%%ymm0                   \n"
+      "add         $0x20,%0                      \n"
+      "vpunpcklbw  %%ymm2,%%ymm0,%%ymm1          \n"
+      "vpunpckhbw  %%ymm2,%%ymm0,%%ymm2          \n"
+      "vextractf128 $0x0,%%ymm1,(%3)             \n"
+      "vextractf128 $0x0,%%ymm2,0x10(%3)         \n"
+      "vextractf128 $0x1,%%ymm1,0x20(%3)         \n"
+      "vextractf128 $0x1,%%ymm2,0x30(%3)         \n"
+      "lea         0x40(%3),%3                   \n"
+      "sub         $0x20,%4                      \n"
+      "jg          1b                            \n"
+      "vzeroupper                                \n"
+      : "+r"(src_y),     // %0
+        "+r"(src_u),     // %1
+        "+r"(src_v),     // %2
+        "+r"(dst_yuy2),  // %3
+        "+rm"(width)     // %4
+      :
+      : "memory", "cc", "xmm0", "xmm1", "xmm2");
+}
+#endif  // HAS_I422TOYUY2ROW_AVX2
+
+#ifdef HAS_I422TOUYVYROW_AVX2
+void I422ToUYVYRow_AVX2(const uint8_t* src_y,
+                        const uint8_t* src_u,
+                        const uint8_t* src_v,
+                        uint8_t* dst_uyvy,
+                        int width) {
+  asm volatile(
+
+      "sub         %1,%2                         \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "vpmovzxbw   (%1),%%ymm1                   \n"
+      "vpmovzxbw   0x00(%1,%2,1),%%ymm2          \n"
+      "add         $0x10,%1                      \n"
+      "vpsllw      $0x8,%%ymm2,%%ymm2            \n"
+      "vpor        %%ymm1,%%ymm2,%%ymm2          \n"
+      "vmovdqu     (%0),%%ymm0                   \n"
+      "add         $0x20,%0                      \n"
+      "vpunpcklbw  %%ymm0,%%ymm2,%%ymm1          \n"
+      "vpunpckhbw  %%ymm0,%%ymm2,%%ymm2          \n"
+      "vextractf128 $0x0,%%ymm1,(%3)             \n"
+      "vextractf128 $0x0,%%ymm2,0x10(%3)         \n"
+      "vextractf128 $0x1,%%ymm1,0x20(%3)         \n"
+      "vextractf128 $0x1,%%ymm2,0x30(%3)         \n"
+      "lea         0x40(%3),%3                   \n"
+      "sub         $0x20,%4                      \n"
+      "jg          1b                            \n"
+      "vzeroupper                                \n"
+      : "+r"(src_y),     // %0
+        "+r"(src_u),     // %1
+        "+r"(src_v),     // %2
+        "+r"(dst_uyvy),  // %3
+        "+rm"(width)     // %4
+      :
+      : "memory", "cc", "xmm0", "xmm1", "xmm2");
+}
+#endif  // HAS_I422TOUYVYROW_AVX2
+
+#ifdef HAS_ARGBPOLYNOMIALROW_SSE2
+void ARGBPolynomialRow_SSE2(const uint8_t* src_argb,
+                            uint8_t* dst_argb,
+                            const float* poly,
+                            int width) {
+  asm volatile(
+
+      "pxor        %%xmm3,%%xmm3                 \n"
+
+      // 2 pixel loop.
+      LABELALIGN
+      "1:                                        \n"
+      "movq        (%0),%%xmm0                   \n"
+      "lea         0x8(%0),%0                    \n"
+      "punpcklbw   %%xmm3,%%xmm0                 \n"
+      "movdqa      %%xmm0,%%xmm4                 \n"
+      "punpcklwd   %%xmm3,%%xmm0                 \n"
+      "punpckhwd   %%xmm3,%%xmm4                 \n"
+      "cvtdq2ps    %%xmm0,%%xmm0                 \n"
+      "cvtdq2ps    %%xmm4,%%xmm4                 \n"
+      "movdqa      %%xmm0,%%xmm1                 \n"
+      "movdqa      %%xmm4,%%xmm5                 \n"
+      "mulps       0x10(%3),%%xmm0               \n"
+      "mulps       0x10(%3),%%xmm4               \n"
+      "addps       (%3),%%xmm0                   \n"
+      "addps       (%3),%%xmm4                   \n"
+      "movdqa      %%xmm1,%%xmm2                 \n"
+      "movdqa      %%xmm5,%%xmm6                 \n"
+      "mulps       %%xmm1,%%xmm2                 \n"
+      "mulps       %%xmm5,%%xmm6                 \n"
+      "mulps       %%xmm2,%%xmm1                 \n"
+      "mulps       %%xmm6,%%xmm5                 \n"
+      "mulps       0x20(%3),%%xmm2               \n"
+      "mulps       0x20(%3),%%xmm6               \n"
+      "mulps       0x30(%3),%%xmm1               \n"
+      "mulps       0x30(%3),%%xmm5               \n"
+      "addps       %%xmm2,%%xmm0                 \n"
+      "addps       %%xmm6,%%xmm4                 \n"
+      "addps       %%xmm1,%%xmm0                 \n"
+      "addps       %%xmm5,%%xmm4                 \n"
+      "cvttps2dq   %%xmm0,%%xmm0                 \n"
+      "cvttps2dq   %%xmm4,%%xmm4                 \n"
+      "packuswb    %%xmm4,%%xmm0                 \n"
+      "packuswb    %%xmm0,%%xmm0                 \n"
+      "movq        %%xmm0,(%1)                   \n"
+      "lea         0x8(%1),%1                    \n"
+      "sub         $0x2,%2                       \n"
+      "jg          1b                            \n"
+      : "+r"(src_argb),  // %0
+        "+r"(dst_argb),  // %1
+        "+r"(width)      // %2
+      : "r"(poly)        // %3
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6");
+}
+#endif  // HAS_ARGBPOLYNOMIALROW_SSE2
+
+#ifdef HAS_ARGBPOLYNOMIALROW_AVX2
+void ARGBPolynomialRow_AVX2(const uint8_t* src_argb,
+                            uint8_t* dst_argb,
+                            const float* poly,
+                            int width) {
+  asm volatile(
+      "vbroadcastf128 (%3),%%ymm4                \n"
+      "vbroadcastf128 0x10(%3),%%ymm5            \n"
+      "vbroadcastf128 0x20(%3),%%ymm6            \n"
+      "vbroadcastf128 0x30(%3),%%ymm7            \n"
+
+      // 2 pixel loop.
+      LABELALIGN
+      "1:                                        \n"
+      "vpmovzxbd   (%0),%%ymm0                   \n"  // 2 ARGB pixels
+      "lea         0x8(%0),%0                    \n"
+      "vcvtdq2ps   %%ymm0,%%ymm0                 \n"  // X 8 floats
+      "vmulps      %%ymm0,%%ymm0,%%ymm2          \n"  // X * X
+      "vmulps      %%ymm7,%%ymm0,%%ymm3          \n"  // C3 * X
+      "vfmadd132ps %%ymm5,%%ymm4,%%ymm0          \n"  // result = C0 + C1 * X
+      "vfmadd231ps %%ymm6,%%ymm2,%%ymm0          \n"  // result += C2 * X * X
+      "vfmadd231ps %%ymm3,%%ymm2,%%ymm0          \n"  // result += C3 * X * X *
+                                                      // X
+      "vcvttps2dq  %%ymm0,%%ymm0                 \n"
+      "vpackusdw   %%ymm0,%%ymm0,%%ymm0          \n"
+      "vpermq      $0xd8,%%ymm0,%%ymm0           \n"
+      "vpackuswb   %%xmm0,%%xmm0,%%xmm0          \n"
+      "vmovq       %%xmm0,(%1)                   \n"
+      "lea         0x8(%1),%1                    \n"
+      "sub         $0x2,%2                       \n"
+      "jg          1b                            \n"
+      "vzeroupper                                \n"
+      : "+r"(src_argb),  // %0
+        "+r"(dst_argb),  // %1
+        "+r"(width)      // %2
+      : "r"(poly)        // %3
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6",
+        "xmm7");
+}
+#endif  // HAS_ARGBPOLYNOMIALROW_AVX2
+
+#ifdef HAS_HALFFLOATROW_SSE2
+static float kScaleBias = 1.9259299444e-34f;
+void HalfFloatRow_SSE2(const uint16_t* src,
+                       uint16_t* dst,
+                       float scale,
+                       int width) {
+  scale *= kScaleBias;
+  asm volatile(
+      "movd        %3,%%xmm4                     \n"
+      "pshufd      $0x0,%%xmm4,%%xmm4            \n"
+      "pxor        %%xmm5,%%xmm5                 \n"
+      "sub         %0,%1                         \n"
+
+      // 16 pixel loop.
+      LABELALIGN
+      "1:                                        \n"
+      "movdqu      (%0),%%xmm2                   \n"  // 8 shorts
+      "add         $0x10,%0                      \n"
+      "movdqa      %%xmm2,%%xmm3                 \n"
+      "punpcklwd   %%xmm5,%%xmm2                 \n"  // 8 ints in xmm2/1
+      "cvtdq2ps    %%xmm2,%%xmm2                 \n"  // 8 floats
+      "punpckhwd   %%xmm5,%%xmm3                 \n"
+      "cvtdq2ps    %%xmm3,%%xmm3                 \n"
+      "mulps       %%xmm4,%%xmm2                 \n"
+      "mulps       %%xmm4,%%xmm3                 \n"
+      "psrld       $0xd,%%xmm2                   \n"
+      "psrld       $0xd,%%xmm3                   \n"
+      "packssdw    %%xmm3,%%xmm2                 \n"
+      "movdqu      %%xmm2,-0x10(%0,%1,1)         \n"
+      "sub         $0x8,%2                       \n"
+      "jg          1b                            \n"
+      : "+r"(src),   // %0
+        "+r"(dst),   // %1
+        "+r"(width)  // %2
+      : "m"(scale)   // %3
+      : "memory", "cc", "xmm2", "xmm3", "xmm4", "xmm5");
+}
+#endif  // HAS_HALFFLOATROW_SSE2
+
+#ifdef HAS_HALFFLOATROW_AVX2
+void HalfFloatRow_AVX2(const uint16_t* src,
+                       uint16_t* dst,
+                       float scale,
+                       int width) {
+  scale *= kScaleBias;
+  asm volatile(
+      "vbroadcastss %3, %%ymm4                   \n"
+      "vpxor       %%ymm5,%%ymm5,%%ymm5          \n"
+      "sub         %0,%1                         \n"
+
+      // 16 pixel loop.
+      LABELALIGN
+      "1:                                        \n"
+      "vmovdqu     (%0),%%ymm2                   \n"  // 16 shorts
+      "add         $0x20,%0                      \n"
+      "vpunpckhwd  %%ymm5,%%ymm2,%%ymm3          \n"  // mutates
+      "vpunpcklwd  %%ymm5,%%ymm2,%%ymm2          \n"
+      "vcvtdq2ps   %%ymm3,%%ymm3                 \n"
+      "vcvtdq2ps   %%ymm2,%%ymm2                 \n"
+      "vmulps      %%ymm3,%%ymm4,%%ymm3          \n"
+      "vmulps      %%ymm2,%%ymm4,%%ymm2          \n"
+      "vpsrld      $0xd,%%ymm3,%%ymm3            \n"
+      "vpsrld      $0xd,%%ymm2,%%ymm2            \n"
+      "vpackssdw   %%ymm3, %%ymm2, %%ymm2        \n"  // unmutates
+      "vmovdqu     %%ymm2,-0x20(%0,%1,1)         \n"
+      "sub         $0x10,%2                      \n"
+      "jg          1b                            \n"
+
+      "vzeroupper                                \n"
+      : "+r"(src),   // %0
+        "+r"(dst),   // %1
+        "+r"(width)  // %2
+#if defined(__x86_64__)
+      : "x"(scale)  // %3
+#else
+      : "m"(scale)            // %3
+#endif
+      : "memory", "cc", "xmm2", "xmm3", "xmm4", "xmm5");
+}
+#endif  // HAS_HALFFLOATROW_AVX2
+
+#ifdef HAS_HALFFLOATROW_F16C
+void HalfFloatRow_F16C(const uint16_t* src,
+                       uint16_t* dst,
+                       float scale,
+                       int width) {
+  asm volatile(
+      "vbroadcastss %3, %%ymm4                   \n"
+      "sub         %0,%1                         \n"
+
+      // 16 pixel loop.
+      LABELALIGN
+      "1:                                        \n"
+      "vpmovzxwd   (%0),%%ymm2                   \n"  // 16 shorts -> 16 ints
+      "vpmovzxwd   0x10(%0),%%ymm3               \n"
+      "vcvtdq2ps   %%ymm2,%%ymm2                 \n"
+      "vcvtdq2ps   %%ymm3,%%ymm3                 \n"
+      "vmulps      %%ymm2,%%ymm4,%%ymm2          \n"
+      "vmulps      %%ymm3,%%ymm4,%%ymm3          \n"
+      "vcvtps2ph   $3, %%ymm2, %%xmm2            \n"
+      "vcvtps2ph   $3, %%ymm3, %%xmm3            \n"
+      "vmovdqu     %%xmm2,0x00(%0,%1,1)          \n"
+      "vmovdqu     %%xmm3,0x10(%0,%1,1)          \n"
+      "add         $0x20,%0                      \n"
+      "sub         $0x10,%2                      \n"
+      "jg          1b                            \n"
+      "vzeroupper                                \n"
+      : "+r"(src),   // %0
+        "+r"(dst),   // %1
+        "+r"(width)  // %2
+#if defined(__x86_64__)
+      : "x"(scale)  // %3
+#else
+      : "m"(scale)            // %3
+#endif
+      : "memory", "cc", "xmm2", "xmm3", "xmm4");
+}
+#endif  // HAS_HALFFLOATROW_F16C
+
+#ifdef HAS_HALFFLOATROW_F16C
+void HalfFloat1Row_F16C(const uint16_t* src, uint16_t* dst, float, int width) {
+  asm volatile(
+      "sub         %0,%1                         \n"
+      // 16 pixel loop.
+      LABELALIGN
+      "1:                                        \n"
+      "vpmovzxwd   (%0),%%ymm2                   \n"  // 16 shorts -> 16 ints
+      "vpmovzxwd   0x10(%0),%%ymm3               \n"
+      "vcvtdq2ps   %%ymm2,%%ymm2                 \n"
+      "vcvtdq2ps   %%ymm3,%%ymm3                 \n"
+      "vcvtps2ph   $3, %%ymm2, %%xmm2            \n"
+      "vcvtps2ph   $3, %%ymm3, %%xmm3            \n"
+      "vmovdqu     %%xmm2,0x00(%0,%1,1)          \n"
+      "vmovdqu     %%xmm3,0x10(%0,%1,1)          \n"
+      "add         $0x20,%0                      \n"
+      "sub         $0x10,%2                      \n"
+      "jg          1b                            \n"
+      "vzeroupper                                \n"
+      : "+r"(src),   // %0
+        "+r"(dst),   // %1
+        "+r"(width)  // %2
+      :
+      : "memory", "cc", "xmm2", "xmm3");
+}
+#endif  // HAS_HALFFLOATROW_F16C
+
+#ifdef HAS_ARGBCOLORTABLEROW_X86
+// Tranform ARGB pixels with color table.
+void ARGBColorTableRow_X86(uint8_t* dst_argb,
+                           const uint8_t* table_argb,
+                           int width) {
+  uintptr_t pixel_temp;
+  asm volatile(
+      // 1 pixel loop.
+      LABELALIGN
+      "1:                                        \n"
+      "movzb       (%0),%1                       \n"
+      "lea         0x4(%0),%0                    \n"
+      "movzb       0x00(%3,%1,4),%1              \n"
+      "mov         %b1,-0x4(%0)                  \n"
+      "movzb       -0x3(%0),%1                   \n"
+      "movzb       0x01(%3,%1,4),%1              \n"
+      "mov         %b1,-0x3(%0)                  \n"
+      "movzb       -0x2(%0),%1                   \n"
+      "movzb       0x02(%3,%1,4),%1              \n"
+      "mov         %b1,-0x2(%0)                  \n"
+      "movzb       -0x1(%0),%1                   \n"
+      "movzb       0x03(%3,%1,4),%1              \n"
+      "mov         %b1,-0x1(%0)                  \n"
+      "dec         %2                            \n"
+      "jg          1b                            \n"
+      : "+r"(dst_argb),     // %0
+        "=&d"(pixel_temp),  // %1
+        "+r"(width)         // %2
+      : "r"(table_argb)     // %3
+      : "memory", "cc");
+}
+#endif  // HAS_ARGBCOLORTABLEROW_X86
+
+#ifdef HAS_RGBCOLORTABLEROW_X86
+// Tranform RGB pixels with color table.
+void RGBColorTableRow_X86(uint8_t* dst_argb,
+                          const uint8_t* table_argb,
+                          int width) {
+  uintptr_t pixel_temp;
+  asm volatile(
+      // 1 pixel loop.
+      LABELALIGN
+      "1:                                        \n"
+      "movzb       (%0),%1                       \n"
+      "lea         0x4(%0),%0                    \n"
+      "movzb       0x00(%3,%1,4),%1              \n"
+      "mov         %b1,-0x4(%0)                  \n"
+      "movzb       -0x3(%0),%1                   \n"
+      "movzb       0x01(%3,%1,4),%1              \n"
+      "mov         %b1,-0x3(%0)                  \n"
+      "movzb       -0x2(%0),%1                   \n"
+      "movzb       0x02(%3,%1,4),%1              \n"
+      "mov         %b1,-0x2(%0)                  \n"
+      "dec         %2                            \n"
+      "jg          1b                            \n"
+      : "+r"(dst_argb),     // %0
+        "=&d"(pixel_temp),  // %1
+        "+r"(width)         // %2
+      : "r"(table_argb)     // %3
+      : "memory", "cc");
+}
+#endif  // HAS_RGBCOLORTABLEROW_X86
+
+#ifdef HAS_ARGBLUMACOLORTABLEROW_SSSE3
+// Tranform RGB pixels with luma table.
+void ARGBLumaColorTableRow_SSSE3(const uint8_t* src_argb,
+                                 uint8_t* dst_argb,
+                                 int width,
+                                 const uint8_t* luma,
+                                 uint32_t lumacoeff) {
+  uintptr_t pixel_temp;
+  uintptr_t table_temp;
+  asm volatile(
+      "movd        %6,%%xmm3                     \n"
+      "pshufd      $0x0,%%xmm3,%%xmm3            \n"
+      "pcmpeqb     %%xmm4,%%xmm4                 \n"
+      "psllw       $0x8,%%xmm4                   \n"
+      "pxor        %%xmm5,%%xmm5                 \n"
+
+      // 4 pixel loop.
+      LABELALIGN
+      "1:                                        \n"
+      "movdqu      (%2),%%xmm0                   \n"
+      "pmaddubsw   %%xmm3,%%xmm0                 \n"
+      "phaddw      %%xmm0,%%xmm0                 \n"
+      "pand        %%xmm4,%%xmm0                 \n"
+      "punpcklwd   %%xmm5,%%xmm0                 \n"
+      "movd        %%xmm0,%k1                    \n"  // 32 bit offset
+      "add         %5,%1                         \n"
+      "pshufd      $0x39,%%xmm0,%%xmm0           \n"
+
+      "movzb       (%2),%0                       \n"
+      "movzb       0x00(%1,%0,1),%0              \n"
+      "mov         %b0,(%3)                      \n"
+      "movzb       0x1(%2),%0                    \n"
+      "movzb       0x00(%1,%0,1),%0              \n"
+      "mov         %b0,0x1(%3)                   \n"
+      "movzb       0x2(%2),%0                    \n"
+      "movzb       0x00(%1,%0,1),%0              \n"
+      "mov         %b0,0x2(%3)                   \n"
+      "movzb       0x3(%2),%0                    \n"
+      "mov         %b0,0x3(%3)                   \n"
+
+      "movd        %%xmm0,%k1                    \n"  // 32 bit offset
+      "add         %5,%1                         \n"
+      "pshufd      $0x39,%%xmm0,%%xmm0           \n"
+
+      "movzb       0x4(%2),%0                    \n"
+      "movzb       0x00(%1,%0,1),%0              \n"
+      "mov         %b0,0x4(%3)                   \n"
+      "movzb       0x5(%2),%0                    \n"
+      "movzb       0x00(%1,%0,1),%0              \n"
+      "mov         %b0,0x5(%3)                   \n"
+      "movzb       0x6(%2),%0                    \n"
+      "movzb       0x00(%1,%0,1),%0              \n"
+      "mov         %b0,0x6(%3)                   \n"
+      "movzb       0x7(%2),%0                    \n"
+      "mov         %b0,0x7(%3)                   \n"
+
+      "movd        %%xmm0,%k1                    \n"  // 32 bit offset
+      "add         %5,%1                         \n"
+      "pshufd      $0x39,%%xmm0,%%xmm0           \n"
+
+      "movzb       0x8(%2),%0                    \n"
+      "movzb       0x00(%1,%0,1),%0              \n"
+      "mov         %b0,0x8(%3)                   \n"
+      "movzb       0x9(%2),%0                    \n"
+      "movzb       0x00(%1,%0,1),%0              \n"
+      "mov         %b0,0x9(%3)                   \n"
+      "movzb       0xa(%2),%0                    \n"
+      "movzb       0x00(%1,%0,1),%0              \n"
+      "mov         %b0,0xa(%3)                   \n"
+      "movzb       0xb(%2),%0                    \n"
+      "mov         %b0,0xb(%3)                   \n"
+
+      "movd        %%xmm0,%k1                    \n"  // 32 bit offset
+      "add         %5,%1                         \n"
+
+      "movzb       0xc(%2),%0                    \n"
+      "movzb       0x00(%1,%0,1),%0              \n"
+      "mov         %b0,0xc(%3)                   \n"
+      "movzb       0xd(%2),%0                    \n"
+      "movzb       0x00(%1,%0,1),%0              \n"
+      "mov         %b0,0xd(%3)                   \n"
+      "movzb       0xe(%2),%0                    \n"
+      "movzb       0x00(%1,%0,1),%0              \n"
+      "mov         %b0,0xe(%3)                   \n"
+      "movzb       0xf(%2),%0                    \n"
+      "mov         %b0,0xf(%3)                   \n"
+      "lea         0x10(%2),%2                   \n"
+      "lea         0x10(%3),%3                   \n"
+      "sub         $0x4,%4                       \n"
+      "jg          1b                            \n"
+      : "=&d"(pixel_temp),  // %0
+        "=&a"(table_temp),  // %1
+        "+r"(src_argb),     // %2
+        "+r"(dst_argb),     // %3
+        "+rm"(width)        // %4
+      : "r"(luma),          // %5
+        "rm"(lumacoeff)     // %6
+      : "memory", "cc", "xmm0", "xmm3", "xmm4", "xmm5");
+}
+#endif  // HAS_ARGBLUMACOLORTABLEROW_SSSE3
+
+static const uvec8 kYUV24Shuffle[3] = {
+    {8, 9, 0, 8, 9, 1, 10, 11, 2, 10, 11, 3, 12, 13, 4, 12},
+    {9, 1, 10, 11, 2, 10, 11, 3, 12, 13, 4, 12, 13, 5, 14, 15},
+    {2, 10, 11, 3, 12, 13, 4, 12, 13, 5, 14, 15, 6, 14, 15, 7}};
+
+// Convert biplanar NV21 to packed YUV24
+// NV21 has VU in memory for chroma.
+// YUV24 is VUY in memory
+void NV21ToYUV24Row_SSSE3(const uint8_t* src_y,
+                          const uint8_t* src_vu,
+                          uint8_t* dst_yuv24,
+                          int width) {
+  asm volatile(
+      "sub         %0,%1                         \n"
+      "movdqa      (%4),%%xmm4                   \n"  // 3 shuffler constants
+      "movdqa      16(%4),%%xmm5                 \n"
+      "movdqa      32(%4),%%xmm6                 \n"
+      "1:                                        \n"
+      "movdqu      (%0),%%xmm2                   \n"  // load 16 Y values
+      "movdqu      (%0,%1),%%xmm3                \n"  // load 8 VU values
+      "lea         16(%0),%0                     \n"
+      "movdqa      %%xmm2,%%xmm0                 \n"
+      "movdqa      %%xmm2,%%xmm1                 \n"
+      "shufps      $0x44,%%xmm3,%%xmm0           \n"  // Y 0..7,  UV 0..3
+      "shufps      $0x99,%%xmm3,%%xmm1           \n"  // Y 4..11, UV 2..5
+      "shufps      $0xee,%%xmm3,%%xmm2           \n"  // Y 8..15, UV 4..7
+      "pshufb      %%xmm4, %%xmm0                \n"  // weave into YUV24
+      "pshufb      %%xmm5, %%xmm1                \n"
+      "pshufb      %%xmm6, %%xmm2                \n"
+      "movdqu      %%xmm0,(%2)                   \n"
+      "movdqu      %%xmm1,16(%2)                 \n"
+      "movdqu      %%xmm2,32(%2)                 \n"
+      "lea         48(%2),%2                     \n"
+      "sub         $16,%3                        \n"  // 16 pixels per loop
+      "jg          1b                            \n"
+      : "+r"(src_y),            // %0
+        "+r"(src_vu),           // %1
+        "+r"(dst_yuv24),        // %2
+        "+r"(width)             // %3
+      : "r"(&kYUV24Shuffle[0])  // %4
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6");
+}
+
+// Convert biplanar NV21 to packed YUV24
+// NV21 has VU in memory for chroma.
+// YUV24 is VUY in memory
+void NV21ToYUV24Row_AVX2(const uint8_t* src_y,
+                         const uint8_t* src_vu,
+                         uint8_t* dst_yuv24,
+                         int width) {
+  asm volatile(
+      "sub         %0,%1                         \n"
+      "vbroadcastf128 (%4),%%ymm4                \n"  // 3 shuffler constants
+      "vbroadcastf128 16(%4),%%ymm5              \n"
+      "vbroadcastf128 32(%4),%%ymm6              \n"
+
+      "1:                                        \n"
+      "vmovdqu     (%0),%%ymm2                   \n"  // load 32 Y values
+      "vmovdqu     (%0,%1),%%ymm3                \n"  // load 16 VU values
+      "lea         32(%0),%0                     \n"
+      "vshufps     $0x44,%%ymm3,%%ymm2,%%ymm0    \n"  // Y 0..7,  UV 0..3
+      "vshufps     $0x99,%%ymm3,%%ymm2,%%ymm1    \n"  // Y 4..11, UV 2..5
+      "vshufps     $0xee,%%ymm3,%%ymm2,%%ymm2    \n"  // Y 8..15, UV 4..7
+      "vpshufb     %%ymm4,%%ymm0,%%ymm0          \n"  // weave into YUV24
+      "vpshufb     %%ymm5,%%ymm1,%%ymm1          \n"
+      "vpshufb     %%ymm6,%%ymm2,%%ymm2          \n"
+      "vperm2i128  $0x20,%%ymm1,%%ymm0,%%ymm3    \n"
+      "vperm2i128  $0x30,%%ymm0,%%ymm2,%%ymm0    \n"
+      "vperm2i128  $0x31,%%ymm2,%%ymm1,%%ymm1    \n"
+      "vmovdqu     %%ymm3,(%2)                   \n"
+      "vmovdqu     %%ymm0,32(%2)                 \n"
+      "vmovdqu     %%ymm1,64(%2)                 \n"
+      "lea         96(%2),%2                     \n"
+      "sub         $32,%3                        \n"  // 32 pixels per loop
+      "jg          1b                            \n"
+      "vzeroupper                                \n"
+      : "+r"(src_y),            // %0
+        "+r"(src_vu),           // %1
+        "+r"(dst_yuv24),        // %2
+        "+r"(width)             // %3
+      : "r"(&kYUV24Shuffle[0])  // %4
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6");
+}
+
+#ifdef HAS_NV21ToYUV24ROW_AVX512
+// The following VMBI VEX256 code tests okay with the intelsde emulator.
+static const lvec8 kYUV24Perm[3] = {
+    {32, 33, 0,  32, 33, 1,  34, 35, 2,  34, 35, 3,  36, 37, 4,  36,
+     37, 5,  38, 39, 6,  38, 39, 7,  40, 41, 8,  40, 41, 9,  42, 43},
+    {10, 42, 43, 11, 44, 45, 12, 44, 45, 13, 46, 47, 14, 46, 47, 15,
+     48, 49, 16, 48, 49, 17, 50, 51, 18, 50, 51, 19, 52, 53, 20, 52},
+    {53, 21, 54, 55, 22, 54, 55, 23, 56, 57, 24, 56, 57, 25, 58, 59,
+     26, 58, 59, 27, 60, 61, 28, 60, 61, 29, 62, 63, 30, 62, 63, 31}};
+
+void NV21ToYUV24Row_AVX512(const uint8_t* src_y,
+                           const uint8_t* src_vu,
+                           uint8_t* dst_yuv24,
+                           int width) {
+  asm volatile(
+      "sub         %0,%1                         \n"
+      "vmovdqa     (%4),%%ymm4                   \n"  // 3 shuffler constants
+      "vmovdqa     32(%4),%%ymm5                 \n"
+      "vmovdqa     64(%4),%%ymm6                 \n" LABELALIGN
+      "1:                                        \n"
+      "vmovdqu     (%0),%%ymm2                   \n"  // load 32 Y values
+      "vmovdqu     (%0,%1),%%ymm3                \n"  // load 16 VU values
+      "lea         32(%0),%0                     \n"
+      "vmovdqa     %%ymm2, %%ymm0                \n"
+      "vmovdqa     %%ymm2, %%ymm1                \n"
+      "vpermt2b    %%ymm3,%%ymm4,%%ymm0          \n"
+      "vpermt2b    %%ymm3,%%ymm5,%%ymm1          \n"
+      "vpermt2b    %%ymm3,%%ymm6,%%ymm2          \n"
+      "vmovdqu     %%ymm0,(%2)                   \n"
+      "vmovdqu     %%ymm1,32(%2)                 \n"
+      "vmovdqu     %%ymm2,64(%2)                 \n"
+      "lea         96(%2),%2                     \n"
+      "sub         $32,%3                        \n"
+      "jg          1b                            \n"
+      "vzeroupper                                \n"
+      : "+r"(src_y),         // %0
+        "+r"(src_vu),        // %1
+        "+r"(dst_yuv24),     // %2
+        "+r"(width)          // %3
+      : "r"(&kYUV24Perm[0])  // %4
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6");
+}
+
+#endif  // HAS_NV21ToYUV24ROW_AVX512
+
+#ifdef HAS_SWAPUVROW_SSSE3
+
+// Shuffle table for reversing the bytes.
+static const uvec8 kShuffleUVToVU = {1u, 0u, 3u,  2u,  5u,  4u,  7u,  6u,
+                                     9u, 8u, 11u, 10u, 13u, 12u, 15u, 14u};
+
+// Convert UV plane of NV12 to VU of NV21.
+void SwapUVRow_SSSE3(const uint8_t* src_uv, uint8_t* dst_vu, int width) {
+  asm volatile(
+
+      "movdqu      %3,%%xmm5                     \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "movdqu      (%0),%%xmm0                   \n"
+      "movdqu      0x10(%0),%%xmm1               \n"
+      "lea         0x20(%0),%0                   \n"
+      "pshufb      %%xmm5,%%xmm0                 \n"
+      "pshufb      %%xmm5,%%xmm1                 \n"
+      "movdqu      %%xmm0,(%1)                   \n"
+      "movdqu      %%xmm1,0x10(%1)               \n"
+      "lea         0x20(%1),%1                   \n"
+      "sub         $0x10,%2                      \n"
+      "jg          1b                            \n"
+      : "+r"(src_uv),        // %0
+        "+r"(dst_vu),        // %1
+        "+r"(width)          // %2
+      : "m"(kShuffleUVToVU)  // %3
+      : "memory", "cc", "xmm0", "xmm1", "xmm5");
+}
+#endif  // HAS_SWAPUVROW_SSSE3
+
+#ifdef HAS_SWAPUVROW_AVX2
+void SwapUVRow_AVX2(const uint8_t* src_uv, uint8_t* dst_vu, int width) {
+  asm volatile(
+
+      "vbroadcastf128 %3,%%ymm5                  \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "vmovdqu     (%0),%%ymm0                   \n"
+      "vmovdqu     0x20(%0),%%ymm1               \n"
+      "lea         0x40(%0),%0                   \n"
+      "vpshufb     %%ymm5,%%ymm0,%%ymm0          \n"
+      "vpshufb     %%ymm5,%%ymm1,%%ymm1          \n"
+      "vmovdqu     %%ymm0,(%1)                   \n"
+      "vmovdqu     %%ymm1,0x20(%1)               \n"
+      "lea         0x40(%1),%1                   \n"
+      "sub         $0x20,%2                      \n"
+      "jg          1b                            \n"
+      "vzeroupper                                \n"
+      : "+r"(src_uv),        // %0
+        "+r"(dst_vu),        // %1
+        "+r"(width)          // %2
+      : "m"(kShuffleUVToVU)  // %3
+      : "memory", "cc", "xmm0", "xmm1", "xmm5");
+}
+#endif  // HAS_SWAPUVROW_AVX2
+
+void HalfMergeUVRow_SSSE3(const uint8_t* src_u,
+                          int src_stride_u,
+                          const uint8_t* src_v,
+                          int src_stride_v,
+                          uint8_t* dst_uv,
+                          int width) {
+  asm volatile(
+      "pcmpeqb     %%xmm4,%%xmm4                 \n"
+      "psrlw       $0xf,%%xmm4                   \n"
+      "packuswb    %%xmm4,%%xmm4                 \n"
+      "pxor        %%xmm5,%%xmm5                 \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "movdqu      (%0),%%xmm0                   \n"  // load 16 U values
+      "movdqu      (%1),%%xmm1                   \n"  // load 16 V values
+      "movdqu      0(%0,%4,1),%%xmm2             \n"  // 16 from next row
+      "movdqu      0(%1,%5,1),%%xmm3             \n"
+      "lea         0x10(%0),%0                   \n"
+      "pmaddubsw   %%xmm4,%%xmm0                 \n"  // half size
+      "pmaddubsw   %%xmm4,%%xmm1                 \n"
+      "pmaddubsw   %%xmm4,%%xmm2                 \n"
+      "pmaddubsw   %%xmm4,%%xmm3                 \n"
+      "lea         0x10(%1),%1                   \n"
+      "paddw       %%xmm2,%%xmm0                 \n"
+      "paddw       %%xmm3,%%xmm1                 \n"
+      "psrlw       $0x1,%%xmm0                   \n"
+      "psrlw       $0x1,%%xmm1                   \n"
+      "pavgw       %%xmm5,%%xmm0                 \n"
+      "pavgw       %%xmm5,%%xmm1                 \n"
+      "packuswb    %%xmm0,%%xmm0                 \n"
+      "packuswb    %%xmm1,%%xmm1                 \n"
+      "punpcklbw   %%xmm1,%%xmm0                 \n"
+      "movdqu      %%xmm0,(%2)                   \n"  // store 8 UV pixels
+      "lea         0x10(%2),%2                   \n"
+      "sub         $0x10,%3                      \n"  // 16 src pixels per loop
+      "jg          1b                            \n"
+      : "+r"(src_u),                    // %0
+        "+r"(src_v),                    // %1
+        "+r"(dst_uv),                   // %2
+        "+r"(width)                     // %3
+      : "r"((intptr_t)(src_stride_u)),  // %4
+        "r"((intptr_t)(src_stride_v))   // %5
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5");
+}
+
+void HalfMergeUVRow_AVX2(const uint8_t* src_u,
+                         int src_stride_u,
+                         const uint8_t* src_v,
+                         int src_stride_v,
+                         uint8_t* dst_uv,
+                         int width) {
+  asm volatile(
+      "vpcmpeqb    %%ymm4,%%ymm4,%%ymm4          \n"
+      "vpsrlw      $0xf,%%ymm4,%%ymm4            \n"
+      "vpackuswb   %%ymm4,%%ymm4,%%ymm4          \n"
+      "vpxor       %%ymm5,%%ymm5,%%ymm5          \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "vmovdqu     (%0),%%ymm0                   \n"  // load 32 U values
+      "vmovdqu     (%1),%%ymm1                   \n"  // load 32 V values
+      "vmovdqu     0(%0,%4,1),%%ymm2             \n"  // 32 from next row
+      "vmovdqu     0(%1,%5,1),%%ymm3             \n"
+      "lea         0x20(%0),%0                   \n"
+      "vpmaddubsw  %%ymm4,%%ymm0,%%ymm0          \n"  // half size
+      "vpmaddubsw  %%ymm4,%%ymm1,%%ymm1          \n"
+      "vpmaddubsw  %%ymm4,%%ymm2,%%ymm2          \n"
+      "vpmaddubsw  %%ymm4,%%ymm3,%%ymm3          \n"
+      "lea         0x20(%1),%1                   \n"
+      "vpaddw      %%ymm2,%%ymm0,%%ymm0          \n"
+      "vpaddw      %%ymm3,%%ymm1,%%ymm1          \n"
+      "vpsrlw      $0x1,%%ymm0,%%ymm0            \n"
+      "vpsrlw      $0x1,%%ymm1,%%ymm1            \n"
+      "vpavgw      %%ymm5,%%ymm0,%%ymm0          \n"
+      "vpavgw      %%ymm5,%%ymm1,%%ymm1          \n"
+      "vpackuswb   %%ymm0,%%ymm0,%%ymm0          \n"
+      "vpackuswb   %%ymm1,%%ymm1,%%ymm1          \n"
+      "vpunpcklbw  %%ymm1,%%ymm0,%%ymm0          \n"
+      "vmovdqu     %%ymm0,(%2)                   \n"  // store 16 UV pixels
+      "lea         0x20(%2),%2                   \n"
+      "sub         $0x20,%3                      \n"  // 32 src pixels per loop
+      "jg          1b                            \n"
+      "vzeroupper                                \n"
+      : "+r"(src_u),                    // %0
+        "+r"(src_v),                    // %1
+        "+r"(dst_uv),                   // %2
+        "+r"(width)                     // %3
+      : "r"((intptr_t)(src_stride_u)),  // %4
+        "r"((intptr_t)(src_stride_v))   // %5
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5");
+}
+
+void ClampFloatToZero_SSE2(const float* src_x, float* dst_y, int width) {
+  asm volatile(
+      "pxor        %%xmm1,%%xmm1                 \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "movd        (%0),%%xmm0                   \n"  // load float
+      "maxss       %%xmm1, %%xmm0                \n"  // clamp to zero
+      "add         4, %0                         \n"
+      "movd        %%xmm0, (%1)                  \n"  // store float
+      "add         4, %1                         \n"
+      "sub         $0x4,%2                       \n"  // 1 float per loop
+      "jg          1b                            \n"
+      : "+r"(src_x),  // %0
+        "+r"(dst_y),  // %1
+        "+r"(width)   // %2
+      :
+      : "memory", "cc", "xmm0", "xmm1");
+}
+
+#endif  // defined(__x86_64__) || defined(__i386__)
+
+#ifdef __cplusplus
+}  // extern "C"
+}  // namespace libyuv
+#endif
diff --git a/3rdparty/libyuv/src/source/row_lasx.cc b/3rdparty/libyuv/src/source/row_lasx.cc
new file mode 100644
index 00000000..7dd18f40
--- /dev/null
+++ b/3rdparty/libyuv/src/source/row_lasx.cc
@@ -0,0 +1,2230 @@
+/*
+ *  Copyright 2022 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Copyright (c) 2022 Loongson Technology Corporation Limited
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include "libyuv/row.h"
+
+#if !defined(LIBYUV_DISABLE_LASX) && defined(__loongarch_asx)
+#include "libyuv/loongson_intrinsics.h"
+
+#ifdef __cplusplus
+namespace libyuv {
+extern "C" {
+#endif
+
+#define ALPHA_VAL (-1)
+
+// Fill YUV -> RGB conversion constants into vectors
+#define YUVTORGB_SETUP(yuvconst, ub, vr, ug, vg, yg, yb) \
+  {                                                      \
+    ub = __lasx_xvreplgr2vr_h(yuvconst->kUVToB[0]);      \
+    vr = __lasx_xvreplgr2vr_h(yuvconst->kUVToR[1]);      \
+    ug = __lasx_xvreplgr2vr_h(yuvconst->kUVToG[0]);      \
+    vg = __lasx_xvreplgr2vr_h(yuvconst->kUVToG[1]);      \
+    yg = __lasx_xvreplgr2vr_h(yuvconst->kYToRgb[0]);     \
+    yb = __lasx_xvreplgr2vr_w(yuvconst->kYBiasToRgb[0]); \
+  }
+
+// Load 32 YUV422 pixel data
+#define READYUV422_D(psrc_y, psrc_u, psrc_v, out_y, uv_l, uv_h) \
+  {                                                             \
+    __m256i temp0, temp1;                                       \
+                                                                \
+    DUP2_ARG2(__lasx_xvld, psrc_y, 0, psrc_u, 0, out_y, temp0); \
+    temp1 = __lasx_xvld(psrc_v, 0);                             \
+    temp0 = __lasx_xvsub_b(temp0, const_0x80);                  \
+    temp1 = __lasx_xvsub_b(temp1, const_0x80);                  \
+    temp0 = __lasx_vext2xv_h_b(temp0);                          \
+    temp1 = __lasx_vext2xv_h_b(temp1);                          \
+    uv_l = __lasx_xvilvl_h(temp0, temp1);                       \
+    uv_h = __lasx_xvilvh_h(temp0, temp1);                       \
+  }
+
+// Load 16 YUV422 pixel data
+#define READYUV422(psrc_y, psrc_u, psrc_v, out_y, uv) \
+  {                                                   \
+    __m256i temp0, temp1;                             \
+                                                      \
+    out_y = __lasx_xvld(psrc_y, 0);                   \
+    temp0 = __lasx_xvldrepl_d(psrc_u, 0);             \
+    temp1 = __lasx_xvldrepl_d(psrc_v, 0);             \
+    uv = __lasx_xvilvl_b(temp0, temp1);               \
+    uv = __lasx_xvsub_b(uv, const_0x80);              \
+    uv = __lasx_vext2xv_h_b(uv);                      \
+  }
+
+// Convert 16 pixels of YUV420 to RGB.
+#define YUVTORGB_D(in_y, in_uvl, in_uvh, ubvr, ugvg, yg, yb, b_l, b_h, g_l,   \
+                   g_h, r_l, r_h)                                             \
+  {                                                                           \
+    __m256i u_l, u_h, v_l, v_h;                                               \
+    __m256i yl_ev, yl_od, yh_ev, yh_od;                                       \
+    __m256i temp0, temp1, temp2, temp3;                                       \
+                                                                              \
+    temp0 = __lasx_xvilvl_b(in_y, in_y);                                      \
+    temp1 = __lasx_xvilvh_b(in_y, in_y);                                      \
+    yl_ev = __lasx_xvmulwev_w_hu_h(temp0, yg);                                \
+    yl_od = __lasx_xvmulwod_w_hu_h(temp0, yg);                                \
+    yh_ev = __lasx_xvmulwev_w_hu_h(temp1, yg);                                \
+    yh_od = __lasx_xvmulwod_w_hu_h(temp1, yg);                                \
+    DUP4_ARG2(__lasx_xvsrai_w, yl_ev, 16, yl_od, 16, yh_ev, 16, yh_od, 16,    \
+              yl_ev, yl_od, yh_ev, yh_od);                                    \
+    yl_ev = __lasx_xvadd_w(yl_ev, yb);                                        \
+    yl_od = __lasx_xvadd_w(yl_od, yb);                                        \
+    yh_ev = __lasx_xvadd_w(yh_ev, yb);                                        \
+    yh_od = __lasx_xvadd_w(yh_od, yb);                                        \
+    v_l = __lasx_xvmulwev_w_h(in_uvl, ubvr);                                  \
+    u_l = __lasx_xvmulwod_w_h(in_uvl, ubvr);                                  \
+    v_h = __lasx_xvmulwev_w_h(in_uvh, ubvr);                                  \
+    u_h = __lasx_xvmulwod_w_h(in_uvh, ubvr);                                  \
+    temp0 = __lasx_xvadd_w(yl_ev, u_l);                                       \
+    temp1 = __lasx_xvadd_w(yl_od, u_l);                                       \
+    temp2 = __lasx_xvadd_w(yh_ev, u_h);                                       \
+    temp3 = __lasx_xvadd_w(yh_od, u_h);                                       \
+    DUP4_ARG2(__lasx_xvsrai_w, temp0, 6, temp1, 6, temp2, 6, temp3, 6, temp0, \
+              temp1, temp2, temp3);                                           \
+    DUP4_ARG1(__lasx_xvclip255_w, temp0, temp1, temp2, temp3, temp0, temp1,   \
+              temp2, temp3);                                                  \
+    b_l = __lasx_xvpackev_h(temp1, temp0);                                    \
+    b_h = __lasx_xvpackev_h(temp3, temp2);                                    \
+    temp0 = __lasx_xvadd_w(yl_ev, v_l);                                       \
+    temp1 = __lasx_xvadd_w(yl_od, v_l);                                       \
+    temp2 = __lasx_xvadd_w(yh_ev, v_h);                                       \
+    temp3 = __lasx_xvadd_w(yh_od, v_h);                                       \
+    DUP4_ARG2(__lasx_xvsrai_w, temp0, 6, temp1, 6, temp2, 6, temp3, 6, temp0, \
+              temp1, temp2, temp3);                                           \
+    DUP4_ARG1(__lasx_xvclip255_w, temp0, temp1, temp2, temp3, temp0, temp1,   \
+              temp2, temp3);                                                  \
+    r_l = __lasx_xvpackev_h(temp1, temp0);                                    \
+    r_h = __lasx_xvpackev_h(temp3, temp2);                                    \
+    DUP2_ARG2(__lasx_xvdp2_w_h, in_uvl, ugvg, in_uvh, ugvg, u_l, u_h);        \
+    temp0 = __lasx_xvsub_w(yl_ev, u_l);                                       \
+    temp1 = __lasx_xvsub_w(yl_od, u_l);                                       \
+    temp2 = __lasx_xvsub_w(yh_ev, u_h);                                       \
+    temp3 = __lasx_xvsub_w(yh_od, u_h);                                       \
+    DUP4_ARG2(__lasx_xvsrai_w, temp0, 6, temp1, 6, temp2, 6, temp3, 6, temp0, \
+              temp1, temp2, temp3);                                           \
+    DUP4_ARG1(__lasx_xvclip255_w, temp0, temp1, temp2, temp3, temp0, temp1,   \
+              temp2, temp3);                                                  \
+    g_l = __lasx_xvpackev_h(temp1, temp0);                                    \
+    g_h = __lasx_xvpackev_h(temp3, temp2);                                    \
+  }
+
+// Convert 8 pixels of YUV420 to RGB.
+#define YUVTORGB(in_y, in_uv, ubvr, ugvg, yg, yb, out_b, out_g, out_r) \
+  {                                                                    \
+    __m256i u_l, v_l, yl_ev, yl_od;                                    \
+    __m256i temp0, temp1;                                              \
+                                                                       \
+    in_y = __lasx_xvpermi_d(in_y, 0xD8);                               \
+    temp0 = __lasx_xvilvl_b(in_y, in_y);                               \
+    yl_ev = __lasx_xvmulwev_w_hu_h(temp0, yg);                         \
+    yl_od = __lasx_xvmulwod_w_hu_h(temp0, yg);                         \
+    DUP2_ARG2(__lasx_xvsrai_w, yl_ev, 16, yl_od, 16, yl_ev, yl_od);    \
+    yl_ev = __lasx_xvadd_w(yl_ev, yb);                                 \
+    yl_od = __lasx_xvadd_w(yl_od, yb);                                 \
+    v_l = __lasx_xvmulwev_w_h(in_uv, ubvr);                            \
+    u_l = __lasx_xvmulwod_w_h(in_uv, ubvr);                            \
+    temp0 = __lasx_xvadd_w(yl_ev, u_l);                                \
+    temp1 = __lasx_xvadd_w(yl_od, u_l);                                \
+    DUP2_ARG2(__lasx_xvsrai_w, temp0, 6, temp1, 6, temp0, temp1);      \
+    DUP2_ARG1(__lasx_xvclip255_w, temp0, temp1, temp0, temp1);         \
+    out_b = __lasx_xvpackev_h(temp1, temp0);                           \
+    temp0 = __lasx_xvadd_w(yl_ev, v_l);                                \
+    temp1 = __lasx_xvadd_w(yl_od, v_l);                                \
+    DUP2_ARG2(__lasx_xvsrai_w, temp0, 6, temp1, 6, temp0, temp1);      \
+    DUP2_ARG1(__lasx_xvclip255_w, temp0, temp1, temp0, temp1);         \
+    out_r = __lasx_xvpackev_h(temp1, temp0);                           \
+    u_l = __lasx_xvdp2_w_h(in_uv, ugvg);                               \
+    temp0 = __lasx_xvsub_w(yl_ev, u_l);                                \
+    temp1 = __lasx_xvsub_w(yl_od, u_l);                                \
+    DUP2_ARG2(__lasx_xvsrai_w, temp0, 6, temp1, 6, temp0, temp1);      \
+    DUP2_ARG1(__lasx_xvclip255_w, temp0, temp1, temp0, temp1);         \
+    out_g = __lasx_xvpackev_h(temp1, temp0);                           \
+  }
+
+// Pack and Store 16 ARGB values.
+#define STOREARGB_D(a_l, a_h, r_l, r_h, g_l, g_h, b_l, b_h, pdst_argb) \
+  {                                                                    \
+    __m256i temp0, temp1, temp2, temp3;                                \
+                                                                       \
+    temp0 = __lasx_xvpackev_b(g_l, b_l);                               \
+    temp1 = __lasx_xvpackev_b(a_l, r_l);                               \
+    temp2 = __lasx_xvpackev_b(g_h, b_h);                               \
+    temp3 = __lasx_xvpackev_b(a_h, r_h);                               \
+    r_l = __lasx_xvilvl_h(temp1, temp0);                               \
+    r_h = __lasx_xvilvh_h(temp1, temp0);                               \
+    g_l = __lasx_xvilvl_h(temp3, temp2);                               \
+    g_h = __lasx_xvilvh_h(temp3, temp2);                               \
+    temp0 = __lasx_xvpermi_q(r_h, r_l, 0x20);                          \
+    temp1 = __lasx_xvpermi_q(g_h, g_l, 0x20);                          \
+    temp2 = __lasx_xvpermi_q(r_h, r_l, 0x31);                          \
+    temp3 = __lasx_xvpermi_q(g_h, g_l, 0x31);                          \
+    __lasx_xvst(temp0, pdst_argb, 0);                                  \
+    __lasx_xvst(temp1, pdst_argb, 32);                                 \
+    __lasx_xvst(temp2, pdst_argb, 64);                                 \
+    __lasx_xvst(temp3, pdst_argb, 96);                                 \
+    pdst_argb += 128;                                                  \
+  }
+
+// Pack and Store 8 ARGB values.
+#define STOREARGB(in_a, in_r, in_g, in_b, pdst_argb) \
+  {                                                  \
+    __m256i temp0, temp1, temp2, temp3;              \
+                                                     \
+    temp0 = __lasx_xvpackev_b(in_g, in_b);           \
+    temp1 = __lasx_xvpackev_b(in_a, in_r);           \
+    temp2 = __lasx_xvilvl_h(temp1, temp0);           \
+    temp3 = __lasx_xvilvh_h(temp1, temp0);           \
+    temp0 = __lasx_xvpermi_q(temp3, temp2, 0x20);    \
+    temp1 = __lasx_xvpermi_q(temp3, temp2, 0x31);    \
+    __lasx_xvst(temp0, pdst_argb, 0);                \
+    __lasx_xvst(temp1, pdst_argb, 32);               \
+    pdst_argb += 64;                                 \
+  }
+
+#define RGBTOUV(_tmpb, _tmpg, _tmpr, _nexb, _nexg, _nexr, _reg0, _reg1) \
+  {                                                                     \
+    __m256i _tmp0, _tmp1, _tmp2, _tmp3;                                 \
+    _tmp0 = __lasx_xvaddwev_h_bu(_tmpb, _nexb);                         \
+    _tmp1 = __lasx_xvaddwod_h_bu(_tmpb, _nexb);                         \
+    _tmp2 = __lasx_xvaddwev_h_bu(_tmpg, _nexg);                         \
+    _tmp3 = __lasx_xvaddwod_h_bu(_tmpg, _nexg);                         \
+    _reg0 = __lasx_xvaddwev_h_bu(_tmpr, _nexr);                         \
+    _reg1 = __lasx_xvaddwod_h_bu(_tmpr, _nexr);                         \
+    _tmpb = __lasx_xvavgr_hu(_tmp0, _tmp1);                             \
+    _tmpg = __lasx_xvavgr_hu(_tmp2, _tmp3);                             \
+    _tmpr = __lasx_xvavgr_hu(_reg0, _reg1);                             \
+    _reg0 = __lasx_xvmadd_h(const_8080, const_112, _tmpb);              \
+    _reg1 = __lasx_xvmadd_h(const_8080, const_112, _tmpr);              \
+    _reg0 = __lasx_xvmsub_h(_reg0, const_74, _tmpg);                    \
+    _reg1 = __lasx_xvmsub_h(_reg1, const_94, _tmpg);                    \
+    _reg0 = __lasx_xvmsub_h(_reg0, const_38, _tmpr);                    \
+    _reg1 = __lasx_xvmsub_h(_reg1, const_18, _tmpb);                    \
+  }
+
+void MirrorRow_LASX(const uint8_t* src, uint8_t* dst, int width) {
+  int x;
+  int len = width / 64;
+  __m256i src0, src1;
+  __m256i shuffler = {0x08090A0B0C0D0E0F, 0x0001020304050607,
+                      0x08090A0B0C0D0E0F, 0x0001020304050607};
+  src += width - 64;
+  for (x = 0; x < len; x++) {
+    DUP2_ARG2(__lasx_xvld, src, 0, src, 32, src0, src1);
+    DUP2_ARG3(__lasx_xvshuf_b, src0, src0, shuffler, src1, src1, shuffler, src0,
+              src1);
+    src0 = __lasx_xvpermi_q(src0, src0, 0x01);
+    src1 = __lasx_xvpermi_q(src1, src1, 0x01);
+    __lasx_xvst(src1, dst, 0);
+    __lasx_xvst(src0, dst, 32);
+    dst += 64;
+    src -= 64;
+  }
+}
+
+void MirrorUVRow_LASX(const uint8_t* src_uv, uint8_t* dst_uv, int width) {
+  int x;
+  int len = width / 16;
+  __m256i src, dst;
+  __m256i shuffler = {0x0004000500060007, 0x0000000100020003,
+                      0x0004000500060007, 0x0000000100020003};
+
+  src_uv += (width - 16) << 1;
+  for (x = 0; x < len; x++) {
+    src = __lasx_xvld(src_uv, 0);
+    dst = __lasx_xvshuf_h(shuffler, src, src);
+    dst = __lasx_xvpermi_q(dst, dst, 0x01);
+    __lasx_xvst(dst, dst_uv, 0);
+    src_uv -= 32;
+    dst_uv += 32;
+  }
+}
+
+void ARGBMirrorRow_LASX(const uint8_t* src, uint8_t* dst, int width) {
+  int x;
+  int len = width / 16;
+  __m256i src0, src1;
+  __m256i dst0, dst1;
+  __m256i shuffler = {0x0B0A09080F0E0D0C, 0x0302010007060504,
+                      0x0B0A09080F0E0D0C, 0x0302010007060504};
+  src += (width * 4) - 64;
+  for (x = 0; x < len; x++) {
+    DUP2_ARG2(__lasx_xvld, src, 0, src, 32, src0, src1);
+    DUP2_ARG3(__lasx_xvshuf_b, src0, src0, shuffler, src1, src1, shuffler, src0,
+              src1);
+    dst1 = __lasx_xvpermi_q(src0, src0, 0x01);
+    dst0 = __lasx_xvpermi_q(src1, src1, 0x01);
+    __lasx_xvst(dst0, dst, 0);
+    __lasx_xvst(dst1, dst, 32);
+    dst += 64;
+    src -= 64;
+  }
+}
+
+void I422ToYUY2Row_LASX(const uint8_t* src_y,
+                        const uint8_t* src_u,
+                        const uint8_t* src_v,
+                        uint8_t* dst_yuy2,
+                        int width) {
+  int x;
+  int len = width / 32;
+  __m256i src_u0, src_v0, src_y0, vec_uv0;
+  __m256i vec_yuy2_0, vec_yuy2_1;
+  __m256i dst_yuy2_0, dst_yuy2_1;
+
+  for (x = 0; x < len; x++) {
+    DUP2_ARG2(__lasx_xvld, src_u, 0, src_v, 0, src_u0, src_v0);
+    src_y0 = __lasx_xvld(src_y, 0);
+    src_u0 = __lasx_xvpermi_d(src_u0, 0xD8);
+    src_v0 = __lasx_xvpermi_d(src_v0, 0xD8);
+    vec_uv0 = __lasx_xvilvl_b(src_v0, src_u0);
+    vec_yuy2_0 = __lasx_xvilvl_b(vec_uv0, src_y0);
+    vec_yuy2_1 = __lasx_xvilvh_b(vec_uv0, src_y0);
+    dst_yuy2_0 = __lasx_xvpermi_q(vec_yuy2_1, vec_yuy2_0, 0x20);
+    dst_yuy2_1 = __lasx_xvpermi_q(vec_yuy2_1, vec_yuy2_0, 0x31);
+    __lasx_xvst(dst_yuy2_0, dst_yuy2, 0);
+    __lasx_xvst(dst_yuy2_1, dst_yuy2, 32);
+    src_u += 16;
+    src_v += 16;
+    src_y += 32;
+    dst_yuy2 += 64;
+  }
+}
+
+void I422ToUYVYRow_LASX(const uint8_t* src_y,
+                        const uint8_t* src_u,
+                        const uint8_t* src_v,
+                        uint8_t* dst_uyvy,
+                        int width) {
+  int x;
+  int len = width / 32;
+  __m256i src_u0, src_v0, src_y0, vec_uv0;
+  __m256i vec_uyvy0, vec_uyvy1;
+  __m256i dst_uyvy0, dst_uyvy1;
+
+  for (x = 0; x < len; x++) {
+    DUP2_ARG2(__lasx_xvld, src_u, 0, src_v, 0, src_u0, src_v0);
+    src_y0 = __lasx_xvld(src_y, 0);
+    src_u0 = __lasx_xvpermi_d(src_u0, 0xD8);
+    src_v0 = __lasx_xvpermi_d(src_v0, 0xD8);
+    vec_uv0 = __lasx_xvilvl_b(src_v0, src_u0);
+    vec_uyvy0 = __lasx_xvilvl_b(src_y0, vec_uv0);
+    vec_uyvy1 = __lasx_xvilvh_b(src_y0, vec_uv0);
+    dst_uyvy0 = __lasx_xvpermi_q(vec_uyvy1, vec_uyvy0, 0x20);
+    dst_uyvy1 = __lasx_xvpermi_q(vec_uyvy1, vec_uyvy0, 0x31);
+    __lasx_xvst(dst_uyvy0, dst_uyvy, 0);
+    __lasx_xvst(dst_uyvy1, dst_uyvy, 32);
+    src_u += 16;
+    src_v += 16;
+    src_y += 32;
+    dst_uyvy += 64;
+  }
+}
+
+void I422ToARGBRow_LASX(const uint8_t* src_y,
+                        const uint8_t* src_u,
+                        const uint8_t* src_v,
+                        uint8_t* dst_argb,
+                        const struct YuvConstants* yuvconstants,
+                        int width) {
+  int x;
+  int len = width / 32;
+  __m256i vec_yb, vec_yg, vec_ub, vec_ug, vec_vr, vec_vg;
+  __m256i vec_ubvr, vec_ugvg;
+  __m256i alpha = __lasx_xvldi(0xFF);
+  __m256i const_0x80 = __lasx_xvldi(0x80);
+
+  YUVTORGB_SETUP(yuvconstants, vec_ub, vec_vr, vec_ug, vec_vg, vec_yg, vec_yb);
+  vec_ubvr = __lasx_xvilvl_h(vec_ub, vec_vr);
+  vec_ugvg = __lasx_xvilvl_h(vec_ug, vec_vg);
+
+  for (x = 0; x < len; x++) {
+    __m256i y, uv_l, uv_h, b_l, b_h, g_l, g_h, r_l, r_h;
+
+    READYUV422_D(src_y, src_u, src_v, y, uv_l, uv_h);
+    YUVTORGB_D(y, uv_l, uv_h, vec_ubvr, vec_ugvg, vec_yg, vec_yb, b_l, b_h, g_l,
+               g_h, r_l, r_h);
+    STOREARGB_D(alpha, alpha, r_l, r_h, g_l, g_h, b_l, b_h, dst_argb);
+    src_y += 32;
+    src_u += 16;
+    src_v += 16;
+  }
+}
+
+void I422ToRGBARow_LASX(const uint8_t* src_y,
+                        const uint8_t* src_u,
+                        const uint8_t* src_v,
+                        uint8_t* dst_argb,
+                        const struct YuvConstants* yuvconstants,
+                        int width) {
+  int x;
+  int len = width / 32;
+  __m256i vec_yb, vec_yg, vec_ub, vec_vr, vec_ug, vec_vg;
+  __m256i vec_ubvr, vec_ugvg;
+  __m256i alpha = __lasx_xvldi(0xFF);
+  __m256i const_0x80 = __lasx_xvldi(0x80);
+
+  YUVTORGB_SETUP(yuvconstants, vec_ub, vec_vr, vec_ug, vec_vg, vec_yg, vec_yb);
+  vec_ubvr = __lasx_xvilvl_h(vec_ub, vec_vr);
+  vec_ugvg = __lasx_xvilvl_h(vec_ug, vec_vg);
+
+  for (x = 0; x < len; x++) {
+    __m256i y, uv_l, uv_h, b_l, b_h, g_l, g_h, r_l, r_h;
+
+    READYUV422_D(src_y, src_u, src_v, y, uv_l, uv_h);
+    YUVTORGB_D(y, uv_l, uv_h, vec_ubvr, vec_ugvg, vec_yg, vec_yb, b_l, b_h, g_l,
+               g_h, r_l, r_h);
+    STOREARGB_D(r_l, r_h, g_l, g_h, b_l, b_h, alpha, alpha, dst_argb);
+    src_y += 32;
+    src_u += 16;
+    src_v += 16;
+  }
+}
+
+void I422AlphaToARGBRow_LASX(const uint8_t* src_y,
+                             const uint8_t* src_u,
+                             const uint8_t* src_v,
+                             const uint8_t* src_a,
+                             uint8_t* dst_argb,
+                             const struct YuvConstants* yuvconstants,
+                             int width) {
+  int x;
+  int len = width / 32;
+  int res = width & 31;
+  __m256i vec_yb, vec_yg, vec_ub, vec_vr, vec_ug, vec_vg;
+  __m256i vec_ubvr, vec_ugvg;
+  __m256i zero = __lasx_xvldi(0);
+  __m256i const_0x80 = __lasx_xvldi(0x80);
+
+  YUVTORGB_SETUP(yuvconstants, vec_ub, vec_vr, vec_ug, vec_vg, vec_yg, vec_yb);
+  vec_ubvr = __lasx_xvilvl_h(vec_ub, vec_vr);
+  vec_ugvg = __lasx_xvilvl_h(vec_ug, vec_vg);
+
+  for (x = 0; x < len; x++) {
+    __m256i y, uv_l, uv_h, b_l, b_h, g_l, g_h, r_l, r_h, a_l, a_h;
+
+    y = __lasx_xvld(src_a, 0);
+    a_l = __lasx_xvilvl_b(zero, y);
+    a_h = __lasx_xvilvh_b(zero, y);
+    READYUV422_D(src_y, src_u, src_v, y, uv_l, uv_h);
+    YUVTORGB_D(y, uv_l, uv_h, vec_ubvr, vec_ugvg, vec_yg, vec_yb, b_l, b_h, g_l,
+               g_h, r_l, r_h);
+    STOREARGB_D(a_l, a_h, r_l, r_h, g_l, g_h, b_l, b_h, dst_argb);
+    src_y += 32;
+    src_u += 16;
+    src_v += 16;
+    src_a += 32;
+  }
+  if (res) {
+    __m256i y, uv, r, g, b, a;
+    a = __lasx_xvld(src_a, 0);
+    a = __lasx_vext2xv_hu_bu(a);
+    READYUV422(src_y, src_u, src_v, y, uv);
+    YUVTORGB(y, uv, vec_ubvr, vec_ugvg, vec_yg, vec_yb, b, g, r);
+    STOREARGB(a, r, g, b, dst_argb);
+  }
+}
+
+void I422ToRGB24Row_LASX(const uint8_t* src_y,
+                         const uint8_t* src_u,
+                         const uint8_t* src_v,
+                         uint8_t* dst_argb,
+                         const struct YuvConstants* yuvconstants,
+                         int32_t width) {
+  int x;
+  int len = width / 32;
+  __m256i vec_yb, vec_yg, vec_ub, vec_vr, vec_ug, vec_vg;
+  __m256i vec_ubvr, vec_ugvg;
+  __m256i const_0x80 = __lasx_xvldi(0x80);
+  __m256i shuffler0 = {0x0504120302100100, 0x0A18090816070614,
+                       0x0504120302100100, 0x0A18090816070614};
+  __m256i shuffler1 = {0x1E0F0E1C0D0C1A0B, 0x1E0F0E1C0D0C1A0B,
+                       0x1E0F0E1C0D0C1A0B, 0x1E0F0E1C0D0C1A0B};
+
+  YUVTORGB_SETUP(yuvconstants, vec_ub, vec_vr, vec_ug, vec_vg, vec_yg, vec_yb);
+  vec_ubvr = __lasx_xvilvl_h(vec_ub, vec_vr);
+  vec_ugvg = __lasx_xvilvl_h(vec_ug, vec_vg);
+
+  for (x = 0; x < len; x++) {
+    __m256i y, uv_l, uv_h, b_l, b_h, g_l, g_h, r_l, r_h;
+    __m256i temp0, temp1, temp2, temp3;
+
+    READYUV422_D(src_y, src_u, src_v, y, uv_l, uv_h);
+    YUVTORGB_D(y, uv_l, uv_h, vec_ubvr, vec_ugvg, vec_yg, vec_yb, b_l, b_h, g_l,
+               g_h, r_l, r_h);
+    temp0 = __lasx_xvpackev_b(g_l, b_l);
+    temp1 = __lasx_xvpackev_b(g_h, b_h);
+    DUP4_ARG3(__lasx_xvshuf_b, r_l, temp0, shuffler1, r_h, temp1, shuffler1,
+              r_l, temp0, shuffler0, r_h, temp1, shuffler0, temp2, temp3, temp0,
+              temp1);
+
+    b_l = __lasx_xvilvl_d(temp1, temp2);
+    b_h = __lasx_xvilvh_d(temp3, temp1);
+    temp1 = __lasx_xvpermi_q(b_l, temp0, 0x20);
+    temp2 = __lasx_xvpermi_q(temp0, b_h, 0x30);
+    temp3 = __lasx_xvpermi_q(b_h, b_l, 0x31);
+    __lasx_xvst(temp1, dst_argb, 0);
+    __lasx_xvst(temp2, dst_argb, 32);
+    __lasx_xvst(temp3, dst_argb, 64);
+    dst_argb += 96;
+    src_y += 32;
+    src_u += 16;
+    src_v += 16;
+  }
+}
+
+// TODO(fbarchard): Consider AND instead of shift to isolate 5 upper bits of R.
+void I422ToRGB565Row_LASX(const uint8_t* src_y,
+                          const uint8_t* src_u,
+                          const uint8_t* src_v,
+                          uint8_t* dst_rgb565,
+                          const struct YuvConstants* yuvconstants,
+                          int width) {
+  int x;
+  int len = width / 32;
+  __m256i vec_yb, vec_yg, vec_ub, vec_vr, vec_ug, vec_vg;
+  __m256i vec_ubvr, vec_ugvg;
+  __m256i const_0x80 = __lasx_xvldi(0x80);
+
+  YUVTORGB_SETUP(yuvconstants, vec_ub, vec_vr, vec_ug, vec_vg, vec_yg, vec_yb);
+  vec_ubvr = __lasx_xvilvl_h(vec_ub, vec_vr);
+  vec_ugvg = __lasx_xvilvl_h(vec_ug, vec_vg);
+
+  for (x = 0; x < len; x++) {
+    __m256i y, uv_l, uv_h, b_l, b_h, g_l, g_h, r_l, r_h;
+    __m256i dst_l, dst_h;
+
+    READYUV422_D(src_y, src_u, src_v, y, uv_l, uv_h);
+    YUVTORGB_D(y, uv_l, uv_h, vec_ubvr, vec_ugvg, vec_yg, vec_yb, b_l, b_h, g_l,
+               g_h, r_l, r_h);
+    b_l = __lasx_xvsrli_h(b_l, 3);
+    b_h = __lasx_xvsrli_h(b_h, 3);
+    g_l = __lasx_xvsrli_h(g_l, 2);
+    g_h = __lasx_xvsrli_h(g_h, 2);
+    r_l = __lasx_xvsrli_h(r_l, 3);
+    r_h = __lasx_xvsrli_h(r_h, 3);
+    r_l = __lasx_xvslli_h(r_l, 11);
+    r_h = __lasx_xvslli_h(r_h, 11);
+    g_l = __lasx_xvslli_h(g_l, 5);
+    g_h = __lasx_xvslli_h(g_h, 5);
+    r_l = __lasx_xvor_v(r_l, g_l);
+    r_l = __lasx_xvor_v(r_l, b_l);
+    r_h = __lasx_xvor_v(r_h, g_h);
+    r_h = __lasx_xvor_v(r_h, b_h);
+    dst_l = __lasx_xvpermi_q(r_h, r_l, 0x20);
+    dst_h = __lasx_xvpermi_q(r_h, r_l, 0x31);
+    __lasx_xvst(dst_l, dst_rgb565, 0);
+    __lasx_xvst(dst_h, dst_rgb565, 32);
+    dst_rgb565 += 64;
+    src_y += 32;
+    src_u += 16;
+    src_v += 16;
+  }
+}
+
+// TODO(fbarchard): Consider AND instead of shift to isolate 4 upper bits of G.
+void I422ToARGB4444Row_LASX(const uint8_t* src_y,
+                            const uint8_t* src_u,
+                            const uint8_t* src_v,
+                            uint8_t* dst_argb4444,
+                            const struct YuvConstants* yuvconstants,
+                            int width) {
+  int x;
+  int len = width / 32;
+  __m256i vec_yb, vec_yg, vec_ub, vec_vr, vec_ug, vec_vg;
+  __m256i vec_ubvr, vec_ugvg;
+  __m256i const_0x80 = __lasx_xvldi(0x80);
+  __m256i alpha = {0xF000F000F000F000, 0xF000F000F000F000, 0xF000F000F000F000,
+                   0xF000F000F000F000};
+  __m256i mask = {0x00F000F000F000F0, 0x00F000F000F000F0, 0x00F000F000F000F0,
+                  0x00F000F000F000F0};
+
+  YUVTORGB_SETUP(yuvconstants, vec_ub, vec_vr, vec_ug, vec_vg, vec_yg, vec_yb);
+  vec_ubvr = __lasx_xvilvl_h(vec_ub, vec_vr);
+  vec_ugvg = __lasx_xvilvl_h(vec_ug, vec_vg);
+
+  for (x = 0; x < len; x++) {
+    __m256i y, uv_l, uv_h, b_l, b_h, g_l, g_h, r_l, r_h;
+    __m256i dst_l, dst_h;
+
+    READYUV422_D(src_y, src_u, src_v, y, uv_l, uv_h);
+    YUVTORGB_D(y, uv_l, uv_h, vec_ubvr, vec_ugvg, vec_yg, vec_yb, b_l, b_h, g_l,
+               g_h, r_l, r_h);
+    b_l = __lasx_xvsrli_h(b_l, 4);
+    b_h = __lasx_xvsrli_h(b_h, 4);
+    r_l = __lasx_xvsrli_h(r_l, 4);
+    r_h = __lasx_xvsrli_h(r_h, 4);
+    g_l = __lasx_xvand_v(g_l, mask);
+    g_h = __lasx_xvand_v(g_h, mask);
+    r_l = __lasx_xvslli_h(r_l, 8);
+    r_h = __lasx_xvslli_h(r_h, 8);
+    r_l = __lasx_xvor_v(r_l, alpha);
+    r_h = __lasx_xvor_v(r_h, alpha);
+    r_l = __lasx_xvor_v(r_l, g_l);
+    r_h = __lasx_xvor_v(r_h, g_h);
+    r_l = __lasx_xvor_v(r_l, b_l);
+    r_h = __lasx_xvor_v(r_h, b_h);
+    dst_l = __lasx_xvpermi_q(r_h, r_l, 0x20);
+    dst_h = __lasx_xvpermi_q(r_h, r_l, 0x31);
+    __lasx_xvst(dst_l, dst_argb4444, 0);
+    __lasx_xvst(dst_h, dst_argb4444, 32);
+    dst_argb4444 += 64;
+    src_y += 32;
+    src_u += 16;
+    src_v += 16;
+  }
+}
+
+void I422ToARGB1555Row_LASX(const uint8_t* src_y,
+                            const uint8_t* src_u,
+                            const uint8_t* src_v,
+                            uint8_t* dst_argb1555,
+                            const struct YuvConstants* yuvconstants,
+                            int width) {
+  int x;
+  int len = width / 32;
+  __m256i vec_yb, vec_yg, vec_ub, vec_vr, vec_ug, vec_vg;
+  __m256i vec_ubvr, vec_ugvg;
+  __m256i const_0x80 = __lasx_xvldi(0x80);
+  __m256i alpha = {0x8000800080008000, 0x8000800080008000, 0x8000800080008000,
+                   0x8000800080008000};
+
+  YUVTORGB_SETUP(yuvconstants, vec_ub, vec_vr, vec_ug, vec_vg, vec_yg, vec_yb);
+  vec_ubvr = __lasx_xvilvl_h(vec_ub, vec_vr);
+  vec_ugvg = __lasx_xvilvl_h(vec_ug, vec_vg);
+
+  for (x = 0; x < len; x++) {
+    __m256i y, uv_l, uv_h, b_l, b_h, g_l, g_h, r_l, r_h;
+    __m256i dst_l, dst_h;
+
+    READYUV422_D(src_y, src_u, src_v, y, uv_l, uv_h);
+    YUVTORGB_D(y, uv_l, uv_h, vec_ubvr, vec_ugvg, vec_yg, vec_yb, b_l, b_h, g_l,
+               g_h, r_l, r_h);
+    b_l = __lasx_xvsrli_h(b_l, 3);
+    b_h = __lasx_xvsrli_h(b_h, 3);
+    g_l = __lasx_xvsrli_h(g_l, 3);
+    g_h = __lasx_xvsrli_h(g_h, 3);
+    g_l = __lasx_xvslli_h(g_l, 5);
+    g_h = __lasx_xvslli_h(g_h, 5);
+    r_l = __lasx_xvsrli_h(r_l, 3);
+    r_h = __lasx_xvsrli_h(r_h, 3);
+    r_l = __lasx_xvslli_h(r_l, 10);
+    r_h = __lasx_xvslli_h(r_h, 10);
+    r_l = __lasx_xvor_v(r_l, alpha);
+    r_h = __lasx_xvor_v(r_h, alpha);
+    r_l = __lasx_xvor_v(r_l, g_l);
+    r_h = __lasx_xvor_v(r_h, g_h);
+    r_l = __lasx_xvor_v(r_l, b_l);
+    r_h = __lasx_xvor_v(r_h, b_h);
+    dst_l = __lasx_xvpermi_q(r_h, r_l, 0x20);
+    dst_h = __lasx_xvpermi_q(r_h, r_l, 0x31);
+    __lasx_xvst(dst_l, dst_argb1555, 0);
+    __lasx_xvst(dst_h, dst_argb1555, 32);
+    dst_argb1555 += 64;
+    src_y += 32;
+    src_u += 16;
+    src_v += 16;
+  }
+}
+
+void YUY2ToYRow_LASX(const uint8_t* src_yuy2, uint8_t* dst_y, int width) {
+  int x;
+  int len = width / 32;
+  __m256i src0, src1, dst0;
+
+  for (x = 0; x < len; x++) {
+    DUP2_ARG2(__lasx_xvld, src_yuy2, 0, src_yuy2, 32, src0, src1);
+    dst0 = __lasx_xvpickev_b(src1, src0);
+    dst0 = __lasx_xvpermi_d(dst0, 0xD8);
+    __lasx_xvst(dst0, dst_y, 0);
+    src_yuy2 += 64;
+    dst_y += 32;
+  }
+}
+
+void YUY2ToUVRow_LASX(const uint8_t* src_yuy2,
+                      int src_stride_yuy2,
+                      uint8_t* dst_u,
+                      uint8_t* dst_v,
+                      int width) {
+  const uint8_t* src_yuy2_next = src_yuy2 + src_stride_yuy2;
+  int x;
+  int len = width / 32;
+  __m256i src0, src1, src2, src3;
+  __m256i tmp0, dst0, dst1;
+
+  for (x = 0; x < len; x++) {
+    DUP4_ARG2(__lasx_xvld, src_yuy2, 0, src_yuy2, 32, src_yuy2_next, 0,
+              src_yuy2_next, 32, src0, src1, src2, src3);
+    src0 = __lasx_xvpickod_b(src1, src0);
+    src1 = __lasx_xvpickod_b(src3, src2);
+    tmp0 = __lasx_xvavgr_bu(src1, src0);
+    tmp0 = __lasx_xvpermi_d(tmp0, 0xD8);
+    dst0 = __lasx_xvpickev_b(tmp0, tmp0);
+    dst1 = __lasx_xvpickod_b(tmp0, tmp0);
+    __lasx_xvstelm_d(dst0, dst_u, 0, 0);
+    __lasx_xvstelm_d(dst0, dst_u, 8, 2);
+    __lasx_xvstelm_d(dst1, dst_v, 0, 0);
+    __lasx_xvstelm_d(dst1, dst_v, 8, 2);
+    src_yuy2 += 64;
+    src_yuy2_next += 64;
+    dst_u += 16;
+    dst_v += 16;
+  }
+}
+
+void YUY2ToUV422Row_LASX(const uint8_t* src_yuy2,
+                         uint8_t* dst_u,
+                         uint8_t* dst_v,
+                         int width) {
+  int x;
+  int len = width / 32;
+  __m256i src0, src1, tmp0, dst0, dst1;
+
+  for (x = 0; x < len; x++) {
+    DUP2_ARG2(__lasx_xvld, src_yuy2, 0, src_yuy2, 32, src0, src1);
+    tmp0 = __lasx_xvpickod_b(src1, src0);
+    tmp0 = __lasx_xvpermi_d(tmp0, 0xD8);
+    dst0 = __lasx_xvpickev_b(tmp0, tmp0);
+    dst1 = __lasx_xvpickod_b(tmp0, tmp0);
+    __lasx_xvstelm_d(dst0, dst_u, 0, 0);
+    __lasx_xvstelm_d(dst0, dst_u, 8, 2);
+    __lasx_xvstelm_d(dst1, dst_v, 0, 0);
+    __lasx_xvstelm_d(dst1, dst_v, 8, 2);
+    src_yuy2 += 64;
+    dst_u += 16;
+    dst_v += 16;
+  }
+}
+
+void UYVYToYRow_LASX(const uint8_t* src_uyvy, uint8_t* dst_y, int width) {
+  int x;
+  int len = width / 32;
+  __m256i src0, src1, dst0;
+
+  for (x = 0; x < len; x++) {
+    DUP2_ARG2(__lasx_xvld, src_uyvy, 0, src_uyvy, 32, src0, src1);
+    dst0 = __lasx_xvpickod_b(src1, src0);
+    dst0 = __lasx_xvpermi_d(dst0, 0xD8);
+    __lasx_xvst(dst0, dst_y, 0);
+    src_uyvy += 64;
+    dst_y += 32;
+  }
+}
+
+void UYVYToUVRow_LASX(const uint8_t* src_uyvy,
+                      int src_stride_uyvy,
+                      uint8_t* dst_u,
+                      uint8_t* dst_v,
+                      int width) {
+  const uint8_t* src_uyvy_next = src_uyvy + src_stride_uyvy;
+  int x;
+  int len = width / 32;
+  __m256i src0, src1, src2, src3, tmp0, dst0, dst1;
+
+  for (x = 0; x < len; x++) {
+    DUP4_ARG2(__lasx_xvld, src_uyvy, 0, src_uyvy, 32, src_uyvy_next, 0,
+              src_uyvy_next, 32, src0, src1, src2, src3);
+    src0 = __lasx_xvpickev_b(src1, src0);
+    src1 = __lasx_xvpickev_b(src3, src2);
+    tmp0 = __lasx_xvavgr_bu(src1, src0);
+    tmp0 = __lasx_xvpermi_d(tmp0, 0xD8);
+    dst0 = __lasx_xvpickev_b(tmp0, tmp0);
+    dst1 = __lasx_xvpickod_b(tmp0, tmp0);
+    __lasx_xvstelm_d(dst0, dst_u, 0, 0);
+    __lasx_xvstelm_d(dst0, dst_u, 8, 2);
+    __lasx_xvstelm_d(dst1, dst_v, 0, 0);
+    __lasx_xvstelm_d(dst1, dst_v, 8, 2);
+    src_uyvy += 64;
+    src_uyvy_next += 64;
+    dst_u += 16;
+    dst_v += 16;
+  }
+}
+
+void UYVYToUV422Row_LASX(const uint8_t* src_uyvy,
+                         uint8_t* dst_u,
+                         uint8_t* dst_v,
+                         int width) {
+  int x;
+  int len = width / 32;
+  __m256i src0, src1, tmp0, dst0, dst1;
+
+  for (x = 0; x < len; x++) {
+    DUP2_ARG2(__lasx_xvld, src_uyvy, 0, src_uyvy, 32, src0, src1);
+    tmp0 = __lasx_xvpickev_b(src1, src0);
+    tmp0 = __lasx_xvpermi_d(tmp0, 0xD8);
+    dst0 = __lasx_xvpickev_b(tmp0, tmp0);
+    dst1 = __lasx_xvpickod_b(tmp0, tmp0);
+    __lasx_xvstelm_d(dst0, dst_u, 0, 0);
+    __lasx_xvstelm_d(dst0, dst_u, 8, 2);
+    __lasx_xvstelm_d(dst1, dst_v, 0, 0);
+    __lasx_xvstelm_d(dst1, dst_v, 8, 2);
+    src_uyvy += 64;
+    dst_u += 16;
+    dst_v += 16;
+  }
+}
+
+void ARGBToYRow_LASX(const uint8_t* src_argb0, uint8_t* dst_y, int width) {
+  int x;
+  int len = width / 32;
+  __m256i src0, src1, src2, src3, vec0, vec1, vec2, vec3;
+  __m256i tmp0, tmp1, dst0;
+  __m256i const_19 = __lasx_xvldi(0x19);
+  __m256i const_42 = __lasx_xvldi(0x42);
+  __m256i const_81 = __lasx_xvldi(0x81);
+  __m256i const_1080 = {0x1080108010801080, 0x1080108010801080,
+                        0x1080108010801080, 0x1080108010801080};
+  __m256i control = {0x0000000400000000, 0x0000000500000001, 0x0000000600000002,
+                     0x0000000700000003};
+
+  for (x = 0; x < len; x++) {
+    DUP4_ARG2(__lasx_xvld, src_argb0, 0, src_argb0, 32, src_argb0, 64,
+              src_argb0, 96, src0, src1, src2, src3);
+    vec0 = __lasx_xvpickev_b(src1, src0);
+    vec1 = __lasx_xvpickev_b(src3, src2);
+    vec2 = __lasx_xvpickod_b(src1, src0);
+    vec3 = __lasx_xvpickod_b(src3, src2);
+    tmp0 = __lasx_xvmaddwev_h_bu(const_1080, vec0, const_19);
+    tmp1 = __lasx_xvmaddwev_h_bu(const_1080, vec1, const_19);
+    tmp0 = __lasx_xvmaddwev_h_bu(tmp0, vec2, const_81);
+    tmp1 = __lasx_xvmaddwev_h_bu(tmp1, vec3, const_81);
+    tmp0 = __lasx_xvmaddwod_h_bu(tmp0, vec0, const_42);
+    tmp1 = __lasx_xvmaddwod_h_bu(tmp1, vec1, const_42);
+    dst0 = __lasx_xvssrani_b_h(tmp1, tmp0, 8);
+    dst0 = __lasx_xvperm_w(dst0, control);
+    __lasx_xvst(dst0, dst_y, 0);
+    src_argb0 += 128;
+    dst_y += 32;
+  }
+}
+
+void ARGBToUVRow_LASX(const uint8_t* src_argb0,
+                      int src_stride_argb,
+                      uint8_t* dst_u,
+                      uint8_t* dst_v,
+                      int width) {
+  int x;
+  int len = width / 32;
+  const uint8_t* src_argb1 = src_argb0 + src_stride_argb;
+
+  __m256i src0, src1, src2, src3, src4, src5, src6, src7;
+  __m256i vec0, vec1, vec2, vec3;
+  __m256i tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, dst0, dst1;
+  __m256i const_0x70 = {0x0038003800380038, 0x0038003800380038,
+                        0x0038003800380038, 0x0038003800380038};
+  __m256i const_0x4A = {0x0025002500250025, 0x0025002500250025,
+                        0x0025002500250025, 0x0025002500250025};
+  __m256i const_0x26 = {0x0013001300130013, 0x0013001300130013,
+                        0x0013001300130013, 0x0013001300130013};
+  __m256i const_0x5E = {0x002f002f002f002f, 0x002f002f002f002f,
+                        0x002f002f002f002f, 0x002f002f002f002f};
+  __m256i const_0x12 = {0x0009000900090009, 0x0009000900090009,
+                        0x0009000900090009, 0x0009000900090009};
+  __m256i control = {0x0000000400000000, 0x0000000500000001, 0x0000000600000002,
+                     0x0000000700000003};
+  __m256i const_0x8080 = {0x8080808080808080, 0x8080808080808080,
+                          0x8080808080808080, 0x8080808080808080};
+
+  for (x = 0; x < len; x++) {
+    DUP4_ARG2(__lasx_xvld, src_argb0, 0, src_argb0, 32, src_argb0, 64,
+              src_argb0, 96, src0, src1, src2, src3);
+    DUP4_ARG2(__lasx_xvld, src_argb1, 0, src_argb1, 32, src_argb1, 64,
+              src_argb1, 96, src4, src5, src6, src7);
+    vec0 = __lasx_xvaddwev_h_bu(src0, src4);
+    vec1 = __lasx_xvaddwev_h_bu(src1, src5);
+    vec2 = __lasx_xvaddwev_h_bu(src2, src6);
+    vec3 = __lasx_xvaddwev_h_bu(src3, src7);
+    tmp0 = __lasx_xvpickev_h(vec1, vec0);
+    tmp1 = __lasx_xvpickev_h(vec3, vec2);
+    tmp2 = __lasx_xvpickod_h(vec1, vec0);
+    tmp3 = __lasx_xvpickod_h(vec3, vec2);
+    vec0 = __lasx_xvaddwod_h_bu(src0, src4);
+    vec1 = __lasx_xvaddwod_h_bu(src1, src5);
+    vec2 = __lasx_xvaddwod_h_bu(src2, src6);
+    vec3 = __lasx_xvaddwod_h_bu(src3, src7);
+    tmp4 = __lasx_xvpickev_h(vec1, vec0);
+    tmp5 = __lasx_xvpickev_h(vec3, vec2);
+    vec0 = __lasx_xvpickev_h(tmp1, tmp0);
+    vec1 = __lasx_xvpickod_h(tmp1, tmp0);
+    src0 = __lasx_xvavgr_h(vec0, vec1);
+    vec0 = __lasx_xvpickev_h(tmp3, tmp2);
+    vec1 = __lasx_xvpickod_h(tmp3, tmp2);
+    src1 = __lasx_xvavgr_h(vec0, vec1);
+    vec0 = __lasx_xvpickev_h(tmp5, tmp4);
+    vec1 = __lasx_xvpickod_h(tmp5, tmp4);
+    src2 = __lasx_xvavgr_h(vec0, vec1);
+    dst0 = __lasx_xvmadd_h(const_0x8080, src0, const_0x70);
+    dst0 = __lasx_xvmsub_h(dst0, src2, const_0x4A);
+    dst0 = __lasx_xvmsub_h(dst0, src1, const_0x26);
+    dst1 = __lasx_xvmadd_h(const_0x8080, src1, const_0x70);
+    dst1 = __lasx_xvmsub_h(dst1, src2, const_0x5E);
+    dst1 = __lasx_xvmsub_h(dst1, src0, const_0x12);
+    dst0 = __lasx_xvperm_w(dst0, control);
+    dst1 = __lasx_xvperm_w(dst1, control);
+    dst0 = __lasx_xvssrani_b_h(dst0, dst0, 8);
+    dst1 = __lasx_xvssrani_b_h(dst1, dst1, 8);
+    __lasx_xvstelm_d(dst0, dst_u, 0, 0);
+    __lasx_xvstelm_d(dst0, dst_u, 8, 2);
+    __lasx_xvstelm_d(dst1, dst_v, 0, 0);
+    __lasx_xvstelm_d(dst1, dst_v, 8, 2);
+    src_argb0 += 128;
+    src_argb1 += 128;
+    dst_u += 16;
+    dst_v += 16;
+  }
+}
+
+void ARGBToRGB24Row_LASX(const uint8_t* src_argb, uint8_t* dst_rgb, int width) {
+  int x;
+  int len = (width / 32) - 1;
+  __m256i src0, src1, src2, src3;
+  __m256i tmp0, tmp1, tmp2, tmp3;
+  __m256i shuf = {0x0908060504020100, 0x000000000E0D0C0A, 0x0908060504020100,
+                  0x000000000E0D0C0A};
+  __m256i control = {0x0000000100000000, 0x0000000400000002, 0x0000000600000005,
+                     0x0000000700000003};
+  for (x = 0; x < len; x++) {
+    DUP4_ARG2(__lasx_xvld, src_argb, 0, src_argb, 32, src_argb, 64, src_argb,
+              96, src0, src1, src2, src3);
+    tmp0 = __lasx_xvshuf_b(src0, src0, shuf);
+    tmp1 = __lasx_xvshuf_b(src1, src1, shuf);
+    tmp2 = __lasx_xvshuf_b(src2, src2, shuf);
+    tmp3 = __lasx_xvshuf_b(src3, src3, shuf);
+    tmp0 = __lasx_xvperm_w(tmp0, control);
+    tmp1 = __lasx_xvperm_w(tmp1, control);
+    tmp2 = __lasx_xvperm_w(tmp2, control);
+    tmp3 = __lasx_xvperm_w(tmp3, control);
+    __lasx_xvst(tmp0, dst_rgb, 0);
+    __lasx_xvst(tmp1, dst_rgb, 24);
+    __lasx_xvst(tmp2, dst_rgb, 48);
+    __lasx_xvst(tmp3, dst_rgb, 72);
+    dst_rgb += 96;
+    src_argb += 128;
+  }
+  DUP4_ARG2(__lasx_xvld, src_argb, 0, src_argb, 32, src_argb, 64, src_argb, 96,
+            src0, src1, src2, src3);
+  tmp0 = __lasx_xvshuf_b(src0, src0, shuf);
+  tmp1 = __lasx_xvshuf_b(src1, src1, shuf);
+  tmp2 = __lasx_xvshuf_b(src2, src2, shuf);
+  tmp3 = __lasx_xvshuf_b(src3, src3, shuf);
+  tmp0 = __lasx_xvperm_w(tmp0, control);
+  tmp1 = __lasx_xvperm_w(tmp1, control);
+  tmp2 = __lasx_xvperm_w(tmp2, control);
+  tmp3 = __lasx_xvperm_w(tmp3, control);
+  __lasx_xvst(tmp0, dst_rgb, 0);
+  __lasx_xvst(tmp1, dst_rgb, 24);
+  __lasx_xvst(tmp2, dst_rgb, 48);
+  dst_rgb += 72;
+  __lasx_xvstelm_d(tmp3, dst_rgb, 0, 0);
+  __lasx_xvstelm_d(tmp3, dst_rgb, 8, 1);
+  __lasx_xvstelm_d(tmp3, dst_rgb, 16, 2);
+}
+
+void ARGBToRAWRow_LASX(const uint8_t* src_argb, uint8_t* dst_rgb, int width) {
+  int x;
+  int len = (width / 32) - 1;
+  __m256i src0, src1, src2, src3;
+  __m256i tmp0, tmp1, tmp2, tmp3;
+  __m256i shuf = {0x090A040506000102, 0x000000000C0D0E08, 0x090A040506000102,
+                  0x000000000C0D0E08};
+  __m256i control = {0x0000000100000000, 0x0000000400000002, 0x0000000600000005,
+                     0x0000000700000003};
+  for (x = 0; x < len; x++) {
+    DUP4_ARG2(__lasx_xvld, src_argb, 0, src_argb, 32, src_argb, 64, src_argb,
+              96, src0, src1, src2, src3);
+    tmp0 = __lasx_xvshuf_b(src0, src0, shuf);
+    tmp1 = __lasx_xvshuf_b(src1, src1, shuf);
+    tmp2 = __lasx_xvshuf_b(src2, src2, shuf);
+    tmp3 = __lasx_xvshuf_b(src3, src3, shuf);
+    tmp0 = __lasx_xvperm_w(tmp0, control);
+    tmp1 = __lasx_xvperm_w(tmp1, control);
+    tmp2 = __lasx_xvperm_w(tmp2, control);
+    tmp3 = __lasx_xvperm_w(tmp3, control);
+    __lasx_xvst(tmp0, dst_rgb, 0);
+    __lasx_xvst(tmp1, dst_rgb, 24);
+    __lasx_xvst(tmp2, dst_rgb, 48);
+    __lasx_xvst(tmp3, dst_rgb, 72);
+    dst_rgb += 96;
+    src_argb += 128;
+  }
+  DUP4_ARG2(__lasx_xvld, src_argb, 0, src_argb, 32, src_argb, 64, src_argb, 96,
+            src0, src1, src2, src3);
+  tmp0 = __lasx_xvshuf_b(src0, src0, shuf);
+  tmp1 = __lasx_xvshuf_b(src1, src1, shuf);
+  tmp2 = __lasx_xvshuf_b(src2, src2, shuf);
+  tmp3 = __lasx_xvshuf_b(src3, src3, shuf);
+  tmp0 = __lasx_xvperm_w(tmp0, control);
+  tmp1 = __lasx_xvperm_w(tmp1, control);
+  tmp2 = __lasx_xvperm_w(tmp2, control);
+  tmp3 = __lasx_xvperm_w(tmp3, control);
+  __lasx_xvst(tmp0, dst_rgb, 0);
+  __lasx_xvst(tmp1, dst_rgb, 24);
+  __lasx_xvst(tmp2, dst_rgb, 48);
+  dst_rgb += 72;
+  __lasx_xvstelm_d(tmp3, dst_rgb, 0, 0);
+  __lasx_xvstelm_d(tmp3, dst_rgb, 8, 1);
+  __lasx_xvstelm_d(tmp3, dst_rgb, 16, 2);
+}
+
+void ARGBToRGB565Row_LASX(const uint8_t* src_argb,
+                          uint8_t* dst_rgb,
+                          int width) {
+  int x;
+  int len = width / 16;
+  __m256i zero = __lasx_xvldi(0);
+  __m256i src0, src1, tmp0, tmp1, dst0;
+  __m256i shift = {0x0300030003000300, 0x0300030003000300, 0x0300030003000300,
+                   0x0300030003000300};
+
+  for (x = 0; x < len; x++) {
+    DUP2_ARG2(__lasx_xvld, src_argb, 0, src_argb, 32, src0, src1);
+    tmp0 = __lasx_xvpickev_b(src1, src0);
+    tmp1 = __lasx_xvpickod_b(src1, src0);
+    tmp0 = __lasx_xvsrli_b(tmp0, 3);
+    tmp1 = __lasx_xvpackev_b(zero, tmp1);
+    tmp1 = __lasx_xvsrli_h(tmp1, 2);
+    tmp0 = __lasx_xvsll_b(tmp0, shift);
+    tmp1 = __lasx_xvslli_h(tmp1, 5);
+    dst0 = __lasx_xvor_v(tmp0, tmp1);
+    dst0 = __lasx_xvpermi_d(dst0, 0xD8);
+    __lasx_xvst(dst0, dst_rgb, 0);
+    dst_rgb += 32;
+    src_argb += 64;
+  }
+}
+
+void ARGBToARGB1555Row_LASX(const uint8_t* src_argb,
+                            uint8_t* dst_rgb,
+                            int width) {
+  int x;
+  int len = width / 16;
+  __m256i zero = __lasx_xvldi(0);
+  __m256i src0, src1, tmp0, tmp1, tmp2, tmp3, dst0;
+  __m256i shift1 = {0x0703070307030703, 0x0703070307030703, 0x0703070307030703,
+                    0x0703070307030703};
+  __m256i shift2 = {0x0200020002000200, 0x0200020002000200, 0x0200020002000200,
+                    0x0200020002000200};
+
+  for (x = 0; x < len; x++) {
+    DUP2_ARG2(__lasx_xvld, src_argb, 0, src_argb, 32, src0, src1);
+    tmp0 = __lasx_xvpickev_b(src1, src0);
+    tmp1 = __lasx_xvpickod_b(src1, src0);
+    tmp0 = __lasx_xvsrli_b(tmp0, 3);
+    tmp1 = __lasx_xvsrl_b(tmp1, shift1);
+    tmp0 = __lasx_xvsll_b(tmp0, shift2);
+    tmp2 = __lasx_xvpackev_b(zero, tmp1);
+    tmp3 = __lasx_xvpackod_b(zero, tmp1);
+    tmp2 = __lasx_xvslli_h(tmp2, 5);
+    tmp3 = __lasx_xvslli_h(tmp3, 15);
+    dst0 = __lasx_xvor_v(tmp0, tmp2);
+    dst0 = __lasx_xvor_v(dst0, tmp3);
+    dst0 = __lasx_xvpermi_d(dst0, 0xD8);
+    __lasx_xvst(dst0, dst_rgb, 0);
+    dst_rgb += 32;
+    src_argb += 64;
+  }
+}
+
+void ARGBToARGB4444Row_LASX(const uint8_t* src_argb,
+                            uint8_t* dst_rgb,
+                            int width) {
+  int x;
+  int len = width / 16;
+  __m256i src0, src1, tmp0, tmp1, dst0;
+
+  for (x = 0; x < len; x++) {
+    DUP2_ARG2(__lasx_xvld, src_argb, 0, src_argb, 32, src0, src1);
+    tmp0 = __lasx_xvpickev_b(src1, src0);
+    tmp1 = __lasx_xvpickod_b(src1, src0);
+    tmp1 = __lasx_xvandi_b(tmp1, 0xF0);
+    tmp0 = __lasx_xvsrli_b(tmp0, 4);
+    dst0 = __lasx_xvor_v(tmp1, tmp0);
+    dst0 = __lasx_xvpermi_d(dst0, 0xD8);
+    __lasx_xvst(dst0, dst_rgb, 0);
+    dst_rgb += 32;
+    src_argb += 64;
+  }
+}
+
+void ARGBToUV444Row_LASX(const uint8_t* src_argb,
+                         uint8_t* dst_u,
+                         uint8_t* dst_v,
+                         int32_t width) {
+  int x;
+  int len = width / 32;
+  __m256i src0, src1, src2, src3;
+  __m256i tmp0, tmp1, tmp2, tmp3;
+  __m256i reg0, reg1, reg2, reg3, dst0, dst1;
+  __m256i const_112 = __lasx_xvldi(112);
+  __m256i const_74 = __lasx_xvldi(74);
+  __m256i const_38 = __lasx_xvldi(38);
+  __m256i const_94 = __lasx_xvldi(94);
+  __m256i const_18 = __lasx_xvldi(18);
+  __m256i const_0x8080 = {0x8080808080808080, 0x8080808080808080,
+                          0x8080808080808080, 0x8080808080808080};
+  __m256i control = {0x0000000400000000, 0x0000000500000001, 0x0000000600000002,
+                     0x0000000700000003};
+  for (x = 0; x < len; x++) {
+    DUP4_ARG2(__lasx_xvld, src_argb, 0, src_argb, 32, src_argb, 64, src_argb,
+              96, src0, src1, src2, src3);
+    tmp0 = __lasx_xvpickev_h(src1, src0);
+    tmp1 = __lasx_xvpickod_h(src1, src0);
+    tmp2 = __lasx_xvpickev_h(src3, src2);
+    tmp3 = __lasx_xvpickod_h(src3, src2);
+    reg0 = __lasx_xvmaddwev_h_bu(const_0x8080, tmp0, const_112);
+    reg1 = __lasx_xvmaddwev_h_bu(const_0x8080, tmp2, const_112);
+    reg2 = __lasx_xvmulwod_h_bu(tmp0, const_74);
+    reg3 = __lasx_xvmulwod_h_bu(tmp2, const_74);
+    reg2 = __lasx_xvmaddwev_h_bu(reg2, tmp1, const_38);
+    reg3 = __lasx_xvmaddwev_h_bu(reg3, tmp3, const_38);
+    reg0 = __lasx_xvsub_h(reg0, reg2);
+    reg1 = __lasx_xvsub_h(reg1, reg3);
+    dst0 = __lasx_xvssrani_b_h(reg1, reg0, 8);
+    dst0 = __lasx_xvperm_w(dst0, control);
+    reg0 = __lasx_xvmaddwev_h_bu(const_0x8080, tmp1, const_112);
+    reg1 = __lasx_xvmaddwev_h_bu(const_0x8080, tmp3, const_112);
+    reg2 = __lasx_xvmulwev_h_bu(tmp0, const_18);
+    reg3 = __lasx_xvmulwev_h_bu(tmp2, const_18);
+    reg2 = __lasx_xvmaddwod_h_bu(reg2, tmp0, const_94);
+    reg3 = __lasx_xvmaddwod_h_bu(reg3, tmp2, const_94);
+    reg0 = __lasx_xvsub_h(reg0, reg2);
+    reg1 = __lasx_xvsub_h(reg1, reg3);
+    dst1 = __lasx_xvssrani_b_h(reg1, reg0, 8);
+    dst1 = __lasx_xvperm_w(dst1, control);
+    __lasx_xvst(dst0, dst_u, 0);
+    __lasx_xvst(dst1, dst_v, 0);
+    dst_u += 32;
+    dst_v += 32;
+    src_argb += 128;
+  }
+}
+
+void ARGBMultiplyRow_LASX(const uint8_t* src_argb0,
+                          const uint8_t* src_argb1,
+                          uint8_t* dst_argb,
+                          int width) {
+  int x;
+  int len = width / 8;
+  __m256i zero = __lasx_xvldi(0);
+  __m256i src0, src1, dst0, dst1;
+  __m256i tmp0, tmp1, tmp2, tmp3;
+
+  for (x = 0; x < len; x++) {
+    DUP2_ARG2(__lasx_xvld, src_argb0, 0, src_argb1, 0, src0, src1);
+    tmp0 = __lasx_xvilvl_b(src0, src0);
+    tmp1 = __lasx_xvilvh_b(src0, src0);
+    tmp2 = __lasx_xvilvl_b(zero, src1);
+    tmp3 = __lasx_xvilvh_b(zero, src1);
+    dst0 = __lasx_xvmuh_hu(tmp0, tmp2);
+    dst1 = __lasx_xvmuh_hu(tmp1, tmp3);
+    dst0 = __lasx_xvpickev_b(dst1, dst0);
+    __lasx_xvst(dst0, dst_argb, 0);
+    src_argb0 += 32;
+    src_argb1 += 32;
+    dst_argb += 32;
+  }
+}
+
+void ARGBAddRow_LASX(const uint8_t* src_argb0,
+                     const uint8_t* src_argb1,
+                     uint8_t* dst_argb,
+                     int width) {
+  int x;
+  int len = width / 8;
+  __m256i src0, src1, dst0;
+
+  for (x = 0; x < len; x++) {
+    DUP2_ARG2(__lasx_xvld, src_argb0, 0, src_argb1, 0, src0, src1);
+    dst0 = __lasx_xvsadd_bu(src0, src1);
+    __lasx_xvst(dst0, dst_argb, 0);
+    src_argb0 += 32;
+    src_argb1 += 32;
+    dst_argb += 32;
+  }
+}
+
+void ARGBSubtractRow_LASX(const uint8_t* src_argb0,
+                          const uint8_t* src_argb1,
+                          uint8_t* dst_argb,
+                          int width) {
+  int x;
+  int len = width / 8;
+  __m256i src0, src1, dst0;
+
+  for (x = 0; x < len; x++) {
+    DUP2_ARG2(__lasx_xvld, src_argb0, 0, src_argb1, 0, src0, src1);
+    dst0 = __lasx_xvssub_bu(src0, src1);
+    __lasx_xvst(dst0, dst_argb, 0);
+    src_argb0 += 32;
+    src_argb1 += 32;
+    dst_argb += 32;
+  }
+}
+
+void ARGBAttenuateRow_LASX(const uint8_t* src_argb,
+                           uint8_t* dst_argb,
+                           int width) {
+  int x;
+  int len = width / 16;
+  __m256i src0, src1, tmp0, tmp1;
+  __m256i reg0, reg1, reg2, reg3, reg4, reg5;
+  __m256i b, g, r, a, dst0, dst1;
+  __m256i control = {0x0005000100040000, 0x0007000300060002, 0x0005000100040000,
+                     0x0007000300060002};
+
+  for (x = 0; x < len; x++) {
+    DUP2_ARG2(__lasx_xvld, src_argb, 0, src_argb, 32, src0, src1);
+    tmp0 = __lasx_xvpickev_b(src1, src0);
+    tmp1 = __lasx_xvpickod_b(src1, src0);
+    b = __lasx_xvpackev_b(tmp0, tmp0);
+    r = __lasx_xvpackod_b(tmp0, tmp0);
+    g = __lasx_xvpackev_b(tmp1, tmp1);
+    a = __lasx_xvpackod_b(tmp1, tmp1);
+    reg0 = __lasx_xvmulwev_w_hu(b, a);
+    reg1 = __lasx_xvmulwod_w_hu(b, a);
+    reg2 = __lasx_xvmulwev_w_hu(r, a);
+    reg3 = __lasx_xvmulwod_w_hu(r, a);
+    reg4 = __lasx_xvmulwev_w_hu(g, a);
+    reg5 = __lasx_xvmulwod_w_hu(g, a);
+    reg0 = __lasx_xvssrani_h_w(reg1, reg0, 24);
+    reg2 = __lasx_xvssrani_h_w(reg3, reg2, 24);
+    reg4 = __lasx_xvssrani_h_w(reg5, reg4, 24);
+    reg0 = __lasx_xvshuf_h(control, reg0, reg0);
+    reg2 = __lasx_xvshuf_h(control, reg2, reg2);
+    reg4 = __lasx_xvshuf_h(control, reg4, reg4);
+    tmp0 = __lasx_xvpackev_b(reg4, reg0);
+    tmp1 = __lasx_xvpackev_b(a, reg2);
+    dst0 = __lasx_xvilvl_h(tmp1, tmp0);
+    dst1 = __lasx_xvilvh_h(tmp1, tmp0);
+    __lasx_xvst(dst0, dst_argb, 0);
+    __lasx_xvst(dst1, dst_argb, 32);
+    dst_argb += 64;
+    src_argb += 64;
+  }
+}
+
+void ARGBToRGB565DitherRow_LASX(const uint8_t* src_argb,
+                                uint8_t* dst_rgb,
+                                const uint32_t dither4,
+                                int width) {
+  int x;
+  int len = width / 16;
+  __m256i src0, src1, tmp0, tmp1, dst0;
+  __m256i b, g, r;
+  __m256i zero = __lasx_xvldi(0);
+  __m256i vec_dither = __lasx_xvldrepl_w(&dither4, 0);
+
+  vec_dither = __lasx_xvilvl_b(zero, vec_dither);
+  for (x = 0; x < len; x++) {
+    DUP2_ARG2(__lasx_xvld, src_argb, 0, src_argb, 32, src0, src1);
+    tmp0 = __lasx_xvpickev_b(src1, src0);
+    tmp1 = __lasx_xvpickod_b(src1, src0);
+    b = __lasx_xvpackev_b(zero, tmp0);
+    r = __lasx_xvpackod_b(zero, tmp0);
+    g = __lasx_xvpackev_b(zero, tmp1);
+    b = __lasx_xvadd_h(b, vec_dither);
+    g = __lasx_xvadd_h(g, vec_dither);
+    r = __lasx_xvadd_h(r, vec_dither);
+    DUP2_ARG1(__lasx_xvclip255_h, b, g, b, g);
+    r = __lasx_xvclip255_h(r);
+    b = __lasx_xvsrai_h(b, 3);
+    g = __lasx_xvsrai_h(g, 2);
+    r = __lasx_xvsrai_h(r, 3);
+    g = __lasx_xvslli_h(g, 5);
+    r = __lasx_xvslli_h(r, 11);
+    dst0 = __lasx_xvor_v(b, g);
+    dst0 = __lasx_xvor_v(dst0, r);
+    dst0 = __lasx_xvpermi_d(dst0, 0xD8);
+    __lasx_xvst(dst0, dst_rgb, 0);
+    src_argb += 64;
+    dst_rgb += 32;
+  }
+}
+
+void ARGBShuffleRow_LASX(const uint8_t* src_argb,
+                         uint8_t* dst_argb,
+                         const uint8_t* shuffler,
+                         int width) {
+  int x;
+  int len = width / 16;
+  __m256i src0, src1, dst0, dst1;
+  __m256i shuf = {0x0404040400000000, 0x0C0C0C0C08080808, 0x0404040400000000,
+                  0x0C0C0C0C08080808};
+  __m256i temp = __lasx_xvldrepl_w(shuffler, 0);
+
+  shuf = __lasx_xvadd_b(shuf, temp);
+  for (x = 0; x < len; x++) {
+    DUP2_ARG2(__lasx_xvld, src_argb, 0, src_argb, 32, src0, src1);
+    dst0 = __lasx_xvshuf_b(src0, src0, shuf);
+    dst1 = __lasx_xvshuf_b(src1, src1, shuf);
+    __lasx_xvst(dst0, dst_argb, 0);
+    __lasx_xvst(dst1, dst_argb, 32);
+    src_argb += 64;
+    dst_argb += 64;
+  }
+}
+
+void ARGBShadeRow_LASX(const uint8_t* src_argb,
+                       uint8_t* dst_argb,
+                       int width,
+                       uint32_t value) {
+  int x;
+  int len = width / 8;
+  __m256i src0, dst0, tmp0, tmp1;
+  __m256i vec_value = __lasx_xvreplgr2vr_w(value);
+
+  vec_value = __lasx_xvilvl_b(vec_value, vec_value);
+  for (x = 0; x < len; x++) {
+    src0 = __lasx_xvld(src_argb, 0);
+    tmp0 = __lasx_xvilvl_b(src0, src0);
+    tmp1 = __lasx_xvilvh_b(src0, src0);
+    tmp0 = __lasx_xvmuh_hu(tmp0, vec_value);
+    tmp1 = __lasx_xvmuh_hu(tmp1, vec_value);
+    dst0 = __lasx_xvpickod_b(tmp1, tmp0);
+    __lasx_xvst(dst0, dst_argb, 0);
+    src_argb += 32;
+    dst_argb += 32;
+  }
+}
+
+void ARGBGrayRow_LASX(const uint8_t* src_argb, uint8_t* dst_argb, int width) {
+  int x;
+  int len = width / 16;
+  __m256i src0, src1, tmp0, tmp1;
+  __m256i reg0, reg1, reg2, dst0, dst1;
+  __m256i const_128 = __lasx_xvldi(0x480);
+  __m256i const_150 = __lasx_xvldi(0x96);
+  __m256i const_br = {0x4D1D4D1D4D1D4D1D, 0x4D1D4D1D4D1D4D1D,
+                      0x4D1D4D1D4D1D4D1D, 0x4D1D4D1D4D1D4D1D};
+
+  for (x = 0; x < len; x++) {
+    DUP2_ARG2(__lasx_xvld, src_argb, 0, src_argb, 32, src0, src1);
+    tmp0 = __lasx_xvpickev_b(src1, src0);
+    tmp1 = __lasx_xvpickod_b(src1, src0);
+    reg0 = __lasx_xvdp2_h_bu(tmp0, const_br);
+    reg1 = __lasx_xvmaddwev_h_bu(const_128, tmp1, const_150);
+    reg2 = __lasx_xvadd_h(reg0, reg1);
+    tmp0 = __lasx_xvpackod_b(reg2, reg2);
+    tmp1 = __lasx_xvpackod_b(tmp1, reg2);
+    dst0 = __lasx_xvilvl_h(tmp1, tmp0);
+    dst1 = __lasx_xvilvh_h(tmp1, tmp0);
+    __lasx_xvst(dst0, dst_argb, 0);
+    __lasx_xvst(dst1, dst_argb, 32);
+    src_argb += 64;
+    dst_argb += 64;
+  }
+}
+
+void ARGBSepiaRow_LASX(uint8_t* dst_argb, int width) {
+  int x;
+  int len = width / 16;
+  __m256i src0, src1, tmp0, tmp1;
+  __m256i reg0, reg1, spb, spg, spr;
+  __m256i dst0, dst1;
+  __m256i spb_g = __lasx_xvldi(68);
+  __m256i spg_g = __lasx_xvldi(88);
+  __m256i spr_g = __lasx_xvldi(98);
+  __m256i spb_br = {0x2311231123112311, 0x2311231123112311, 0x2311231123112311,
+                    0x2311231123112311};
+  __m256i spg_br = {0x2D162D162D162D16, 0x2D162D162D162D16, 0x2D162D162D162D16,
+                    0x2D162D162D162D16};
+  __m256i spr_br = {0x3218321832183218, 0x3218321832183218, 0x3218321832183218,
+                    0x3218321832183218};
+  __m256i shuff = {0x1706150413021100, 0x1F0E1D0C1B0A1908, 0x1706150413021100,
+                   0x1F0E1D0C1B0A1908};
+
+  for (x = 0; x < len; x++) {
+    DUP2_ARG2(__lasx_xvld, dst_argb, 0, dst_argb, 32, src0, src1);
+    tmp0 = __lasx_xvpickev_b(src1, src0);
+    tmp1 = __lasx_xvpickod_b(src1, src0);
+    DUP2_ARG2(__lasx_xvdp2_h_bu, tmp0, spb_br, tmp0, spg_br, spb, spg);
+    spr = __lasx_xvdp2_h_bu(tmp0, spr_br);
+    spb = __lasx_xvmaddwev_h_bu(spb, tmp1, spb_g);
+    spg = __lasx_xvmaddwev_h_bu(spg, tmp1, spg_g);
+    spr = __lasx_xvmaddwev_h_bu(spr, tmp1, spr_g);
+    spb = __lasx_xvsrli_h(spb, 7);
+    spg = __lasx_xvsrli_h(spg, 7);
+    spr = __lasx_xvsrli_h(spr, 7);
+    spg = __lasx_xvsat_hu(spg, 7);
+    spr = __lasx_xvsat_hu(spr, 7);
+    reg0 = __lasx_xvpackev_b(spg, spb);
+    reg1 = __lasx_xvshuf_b(tmp1, spr, shuff);
+    dst0 = __lasx_xvilvl_h(reg1, reg0);
+    dst1 = __lasx_xvilvh_h(reg1, reg0);
+    __lasx_xvst(dst0, dst_argb, 0);
+    __lasx_xvst(dst1, dst_argb, 32);
+    dst_argb += 64;
+  }
+}
+
+void ARGB4444ToARGBRow_LASX(const uint8_t* src_argb4444,
+                            uint8_t* dst_argb,
+                            int width) {
+  int x;
+  int len = width / 32;
+  __m256i src0, src1;
+  __m256i tmp0, tmp1, tmp2, tmp3;
+  __m256i reg0, reg1, reg2, reg3;
+  __m256i dst0, dst1, dst2, dst3;
+
+  for (x = 0; x < len; x++) {
+    src0 = __lasx_xvld(src_argb4444, 0);
+    src1 = __lasx_xvld(src_argb4444, 32);
+    DUP4_ARG2(__lasx_xvandi_b, src0, 0x0F, src0, 0xF0, src1, 0x0F, src1, 0xF0,
+              tmp0, tmp1, tmp2, tmp3);
+    DUP2_ARG2(__lasx_xvslli_b, tmp0, 4, tmp2, 4, reg0, reg2);
+    DUP2_ARG2(__lasx_xvsrli_b, tmp1, 4, tmp3, 4, reg1, reg3);
+    DUP4_ARG2(__lasx_xvor_v, tmp0, reg0, tmp1, reg1, tmp2, reg2, tmp3, reg3,
+              tmp0, tmp1, tmp2, tmp3);
+    DUP2_ARG2(__lasx_xvilvl_b, tmp1, tmp0, tmp3, tmp2, reg0, reg2);
+    DUP2_ARG2(__lasx_xvilvh_b, tmp1, tmp0, tmp3, tmp2, reg1, reg3);
+    DUP4_ARG3(__lasx_xvpermi_q, reg1, reg0, 0x20, reg1, reg0, 0x31, reg3, reg2,
+              0x20, reg3, reg2, 0x31, dst0, dst1, dst2, dst3);
+    __lasx_xvst(dst0, dst_argb, 0);
+    __lasx_xvst(dst1, dst_argb, 32);
+    __lasx_xvst(dst2, dst_argb, 64);
+    __lasx_xvst(dst3, dst_argb, 96);
+    src_argb4444 += 64;
+    dst_argb += 128;
+  }
+}
+
+void ARGB1555ToARGBRow_LASX(const uint8_t* src_argb1555,
+                            uint8_t* dst_argb,
+                            int width) {
+  int x;
+  int len = width / 32;
+  __m256i src0, src1;
+  __m256i tmp0, tmp1, tmpb, tmpg, tmpr, tmpa;
+  __m256i reg0, reg1, reg2, reg3;
+  __m256i dst0, dst1, dst2, dst3;
+
+  for (x = 0; x < len; x++) {
+    src0 = __lasx_xvld(src_argb1555, 0);
+    src1 = __lasx_xvld(src_argb1555, 32);
+    tmp0 = __lasx_xvpickev_b(src1, src0);
+    tmp1 = __lasx_xvpickod_b(src1, src0);
+    tmpb = __lasx_xvandi_b(tmp0, 0x1F);
+    tmpg = __lasx_xvsrli_b(tmp0, 5);
+    reg0 = __lasx_xvandi_b(tmp1, 0x03);
+    reg0 = __lasx_xvslli_b(reg0, 3);
+    tmpg = __lasx_xvor_v(tmpg, reg0);
+    reg1 = __lasx_xvandi_b(tmp1, 0x7C);
+    tmpr = __lasx_xvsrli_b(reg1, 2);
+    tmpa = __lasx_xvsrli_b(tmp1, 7);
+    tmpa = __lasx_xvneg_b(tmpa);
+    reg0 = __lasx_xvslli_b(tmpb, 3);
+    reg1 = __lasx_xvslli_b(tmpg, 3);
+    reg2 = __lasx_xvslli_b(tmpr, 3);
+    tmpb = __lasx_xvsrli_b(tmpb, 2);
+    tmpg = __lasx_xvsrli_b(tmpg, 2);
+    tmpr = __lasx_xvsrli_b(tmpr, 2);
+    tmpb = __lasx_xvor_v(reg0, tmpb);
+    tmpg = __lasx_xvor_v(reg1, tmpg);
+    tmpr = __lasx_xvor_v(reg2, tmpr);
+    DUP2_ARG2(__lasx_xvilvl_b, tmpg, tmpb, tmpa, tmpr, reg0, reg1);
+    DUP2_ARG2(__lasx_xvilvh_b, tmpg, tmpb, tmpa, tmpr, reg2, reg3);
+    dst0 = __lasx_xvilvl_h(reg1, reg0);
+    dst1 = __lasx_xvilvh_h(reg1, reg0);
+    dst2 = __lasx_xvilvl_h(reg3, reg2);
+    dst3 = __lasx_xvilvh_h(reg3, reg2);
+    DUP4_ARG3(__lasx_xvpermi_q, dst1, dst0, 0x20, dst1, dst0, 0x31, dst3, dst2,
+              0x20, dst3, dst2, 0x31, reg0, reg1, reg2, reg3);
+    __lasx_xvst(reg0, dst_argb, 0);
+    __lasx_xvst(reg1, dst_argb, 32);
+    __lasx_xvst(reg2, dst_argb, 64);
+    __lasx_xvst(reg3, dst_argb, 96);
+    src_argb1555 += 64;
+    dst_argb += 128;
+  }
+}
+
+void RGB565ToARGBRow_LASX(const uint8_t* src_rgb565,
+                          uint8_t* dst_argb,
+                          int width) {
+  int x;
+  int len = width / 32;
+  __m256i src0, src1;
+  __m256i tmp0, tmp1, tmpb, tmpg, tmpr;
+  __m256i reg0, reg1, reg2, reg3, dst0, dst1, dst2, dst3;
+  __m256i alpha = __lasx_xvldi(0xFF);
+
+  for (x = 0; x < len; x++) {
+    src0 = __lasx_xvld(src_rgb565, 0);
+    src1 = __lasx_xvld(src_rgb565, 32);
+    tmp0 = __lasx_xvpickev_b(src1, src0);
+    tmp1 = __lasx_xvpickod_b(src1, src0);
+    tmpb = __lasx_xvandi_b(tmp0, 0x1F);
+    tmpr = __lasx_xvandi_b(tmp1, 0xF8);
+    reg1 = __lasx_xvandi_b(tmp1, 0x07);
+    reg0 = __lasx_xvsrli_b(tmp0, 5);
+    reg1 = __lasx_xvslli_b(reg1, 3);
+    tmpg = __lasx_xvor_v(reg1, reg0);
+    reg0 = __lasx_xvslli_b(tmpb, 3);
+    reg1 = __lasx_xvsrli_b(tmpb, 2);
+    tmpb = __lasx_xvor_v(reg1, reg0);
+    reg0 = __lasx_xvslli_b(tmpg, 2);
+    reg1 = __lasx_xvsrli_b(tmpg, 4);
+    tmpg = __lasx_xvor_v(reg1, reg0);
+    reg0 = __lasx_xvsrli_b(tmpr, 5);
+    tmpr = __lasx_xvor_v(tmpr, reg0);
+    DUP2_ARG2(__lasx_xvilvl_b, tmpg, tmpb, alpha, tmpr, reg0, reg1);
+    dst0 = __lasx_xvilvl_h(reg1, reg0);
+    dst1 = __lasx_xvilvh_h(reg1, reg0);
+    DUP2_ARG2(__lasx_xvilvh_b, tmpg, tmpb, alpha, tmpr, reg0, reg1);
+    dst2 = __lasx_xvilvl_h(reg1, reg0);
+    dst3 = __lasx_xvilvh_h(reg1, reg0);
+    DUP4_ARG3(__lasx_xvpermi_q, dst1, dst0, 0x20, dst1, dst0, 0x31, dst3, dst2,
+              0x20, dst3, dst2, 0x31, reg0, reg1, reg2, reg3);
+    __lasx_xvst(reg0, dst_argb, 0);
+    __lasx_xvst(reg1, dst_argb, 32);
+    __lasx_xvst(reg2, dst_argb, 64);
+    __lasx_xvst(reg3, dst_argb, 96);
+    src_rgb565 += 64;
+    dst_argb += 128;
+  }
+}
+
+void RGB24ToARGBRow_LASX(const uint8_t* src_rgb24,
+                         uint8_t* dst_argb,
+                         int width) {
+  int x;
+  int len = width / 32;
+  __m256i src0, src1, src2;
+  __m256i tmp0, tmp1, tmp2;
+  __m256i dst0, dst1, dst2, dst3;
+  __m256i reg0, reg1, reg2, reg3;
+  __m256i alpha = __lasx_xvldi(0xFF);
+  __m256i shuf0 = {0x131211100F0E0D0C, 0x1B1A191817161514, 0x131211100F0E0D0C,
+                   0x1B1A191817161514};
+  __m256i shuf1 = {0x1F1E1D1C1B1A1918, 0x0706050403020100, 0x1F1E1D1C1B1A1918,
+                   0x0706050403020100};
+  __m256i shuf2 = {0x0B0A090807060504, 0x131211100F0E0D0C, 0x0B0A090807060504,
+                   0x131211100F0E0D0C};
+  __m256i shuf3 = {0x1005040310020100, 0x100B0A0910080706, 0x1005040310020100,
+                   0x100B0A0910080706};
+
+  for (x = 0; x < len; x++) {
+    reg0 = __lasx_xvld(src_rgb24, 0);
+    reg1 = __lasx_xvld(src_rgb24, 32);
+    reg2 = __lasx_xvld(src_rgb24, 64);
+    src0 = __lasx_xvpermi_q(reg1, reg0, 0x30);
+    src1 = __lasx_xvpermi_q(reg2, reg0, 0x21);
+    src2 = __lasx_xvpermi_q(reg2, reg1, 0x30);
+    DUP2_ARG3(__lasx_xvshuf_b, src1, src0, shuf0, src1, src2, shuf1, tmp0,
+              tmp1);
+    tmp2 = __lasx_xvshuf_b(src1, src2, shuf2);
+    DUP4_ARG3(__lasx_xvshuf_b, alpha, src0, shuf3, alpha, tmp0, shuf3, alpha,
+              tmp1, shuf3, alpha, tmp2, shuf3, reg0, reg1, reg2, reg3);
+    DUP4_ARG3(__lasx_xvpermi_q, reg1, reg0, 0x20, reg3, reg2, 0x20, reg1, reg0,
+              0x31, reg3, reg2, 0x31, dst0, dst1, dst2, dst3);
+    __lasx_xvst(dst0, dst_argb, 0);
+    __lasx_xvst(dst1, dst_argb, 32);
+    __lasx_xvst(dst2, dst_argb, 64);
+    __lasx_xvst(dst3, dst_argb, 96);
+    src_rgb24 += 96;
+    dst_argb += 128;
+  }
+}
+
+void RAWToARGBRow_LASX(const uint8_t* src_raw, uint8_t* dst_argb, int width) {
+  int x;
+  int len = width / 32;
+  __m256i src0, src1, src2;
+  __m256i tmp0, tmp1, tmp2, reg0, reg1, reg2, reg3;
+  __m256i dst0, dst1, dst2, dst3;
+  __m256i alpha = __lasx_xvldi(0xFF);
+  __m256i shuf0 = {0x131211100F0E0D0C, 0x1B1A191817161514, 0x131211100F0E0D0C,
+                   0x1B1A191817161514};
+  __m256i shuf1 = {0x1F1E1D1C1B1A1918, 0x0706050403020100, 0x1F1E1D1C1B1A1918,
+                   0x0706050403020100};
+  __m256i shuf2 = {0x0B0A090807060504, 0x131211100F0E0D0C, 0x0B0A090807060504,
+                   0x131211100F0E0D0C};
+  __m256i shuf3 = {0x1003040510000102, 0x10090A0B10060708, 0x1003040510000102,
+                   0x10090A0B10060708};
+
+  for (x = 0; x < len; x++) {
+    reg0 = __lasx_xvld(src_raw, 0);
+    reg1 = __lasx_xvld(src_raw, 32);
+    reg2 = __lasx_xvld(src_raw, 64);
+    src0 = __lasx_xvpermi_q(reg1, reg0, 0x30);
+    src1 = __lasx_xvpermi_q(reg2, reg0, 0x21);
+    src2 = __lasx_xvpermi_q(reg2, reg1, 0x30);
+    DUP2_ARG3(__lasx_xvshuf_b, src1, src0, shuf0, src1, src2, shuf1, tmp0,
+              tmp1);
+    tmp2 = __lasx_xvshuf_b(src1, src2, shuf2);
+    DUP4_ARG3(__lasx_xvshuf_b, alpha, src0, shuf3, alpha, tmp0, shuf3, alpha,
+              tmp1, shuf3, alpha, tmp2, shuf3, reg0, reg1, reg2, reg3);
+    DUP4_ARG3(__lasx_xvpermi_q, reg1, reg0, 0x20, reg3, reg2, 0x20, reg1, reg0,
+              0x31, reg3, reg2, 0x31, dst0, dst1, dst2, dst3);
+    __lasx_xvst(dst0, dst_argb, 0);
+    __lasx_xvst(dst1, dst_argb, 32);
+    __lasx_xvst(dst2, dst_argb, 64);
+    __lasx_xvst(dst3, dst_argb, 96);
+    src_raw += 96;
+    dst_argb += 128;
+  }
+}
+
+void ARGB1555ToYRow_LASX(const uint8_t* src_argb1555,
+                         uint8_t* dst_y,
+                         int width) {
+  int x;
+  int len = width / 32;
+  __m256i src0, src1;
+  __m256i tmp0, tmp1, tmpb, tmpg, tmpr;
+  __m256i reg0, reg1, reg2, dst0;
+  __m256i const_66 = __lasx_xvldi(66);
+  __m256i const_129 = __lasx_xvldi(129);
+  __m256i const_25 = __lasx_xvldi(25);
+  __m256i const_1080 = {0x1080108010801080, 0x1080108010801080,
+                        0x1080108010801080, 0x1080108010801080};
+
+  for (x = 0; x < len; x++) {
+    src0 = __lasx_xvld(src_argb1555, 0);
+    src1 = __lasx_xvld(src_argb1555, 32);
+    tmp0 = __lasx_xvpickev_b(src1, src0);
+    tmp1 = __lasx_xvpickod_b(src1, src0);
+    tmpb = __lasx_xvandi_b(tmp0, 0x1F);
+    tmpg = __lasx_xvsrli_b(tmp0, 5);
+    reg0 = __lasx_xvandi_b(tmp1, 0x03);
+    reg0 = __lasx_xvslli_b(reg0, 3);
+    tmpg = __lasx_xvor_v(tmpg, reg0);
+    reg1 = __lasx_xvandi_b(tmp1, 0x7C);
+    tmpr = __lasx_xvsrli_b(reg1, 2);
+    reg0 = __lasx_xvslli_b(tmpb, 3);
+    reg1 = __lasx_xvslli_b(tmpg, 3);
+    reg2 = __lasx_xvslli_b(tmpr, 3);
+    tmpb = __lasx_xvsrli_b(tmpb, 2);
+    tmpg = __lasx_xvsrli_b(tmpg, 2);
+    tmpr = __lasx_xvsrli_b(tmpr, 2);
+    tmpb = __lasx_xvor_v(reg0, tmpb);
+    tmpg = __lasx_xvor_v(reg1, tmpg);
+    tmpr = __lasx_xvor_v(reg2, tmpr);
+    reg0 = __lasx_xvmaddwev_h_bu(const_1080, tmpb, const_25);
+    reg1 = __lasx_xvmaddwod_h_bu(const_1080, tmpb, const_25);
+    reg0 = __lasx_xvmaddwev_h_bu(reg0, tmpg, const_129);
+    reg1 = __lasx_xvmaddwod_h_bu(reg1, tmpg, const_129);
+    reg0 = __lasx_xvmaddwev_h_bu(reg0, tmpr, const_66);
+    reg1 = __lasx_xvmaddwod_h_bu(reg1, tmpr, const_66);
+    dst0 = __lasx_xvpackod_b(reg1, reg0);
+    dst0 = __lasx_xvpermi_d(dst0, 0xD8);
+    __lasx_xvst(dst0, dst_y, 0);
+    src_argb1555 += 64;
+    dst_y += 32;
+  }
+}
+
+void ARGB1555ToUVRow_LASX(const uint8_t* src_argb1555,
+                          int src_stride_argb1555,
+                          uint8_t* dst_u,
+                          uint8_t* dst_v,
+                          int width) {
+  int x;
+  int len = width / 32;
+  const uint8_t* next_argb1555 = src_argb1555 + src_stride_argb1555;
+  __m256i src0, src1, src2, src3;
+  __m256i tmp0, tmp1, tmp2, tmp3;
+  __m256i tmpb, tmpg, tmpr, nexb, nexg, nexr;
+  __m256i reg0, reg1, reg2, reg3, dst0;
+  __m256i const_112 = __lasx_xvldi(0x438);
+  __m256i const_74 = __lasx_xvldi(0x425);
+  __m256i const_38 = __lasx_xvldi(0x413);
+  __m256i const_94 = __lasx_xvldi(0x42F);
+  __m256i const_18 = __lasx_xvldi(0x409);
+  __m256i const_8080 = {0x8080808080808080, 0x8080808080808080,
+                        0x8080808080808080, 0x8080808080808080};
+
+  for (x = 0; x < len; x++) {
+    DUP4_ARG2(__lasx_xvld, src_argb1555, 0, src_argb1555, 32, next_argb1555, 0,
+              next_argb1555, 32, src0, src1, src2, src3);
+    DUP2_ARG2(__lasx_xvpickev_b, src1, src0, src3, src2, tmp0, tmp2);
+    DUP2_ARG2(__lasx_xvpickod_b, src1, src0, src3, src2, tmp1, tmp3);
+    tmpb = __lasx_xvandi_b(tmp0, 0x1F);
+    nexb = __lasx_xvandi_b(tmp2, 0x1F);
+    tmpg = __lasx_xvsrli_b(tmp0, 5);
+    nexg = __lasx_xvsrli_b(tmp2, 5);
+    reg0 = __lasx_xvandi_b(tmp1, 0x03);
+    reg2 = __lasx_xvandi_b(tmp3, 0x03);
+    reg0 = __lasx_xvslli_b(reg0, 3);
+    reg2 = __lasx_xvslli_b(reg2, 3);
+    tmpg = __lasx_xvor_v(tmpg, reg0);
+    nexg = __lasx_xvor_v(nexg, reg2);
+    reg1 = __lasx_xvandi_b(tmp1, 0x7C);
+    reg3 = __lasx_xvandi_b(tmp3, 0x7C);
+    tmpr = __lasx_xvsrli_b(reg1, 2);
+    nexr = __lasx_xvsrli_b(reg3, 2);
+    reg0 = __lasx_xvslli_b(tmpb, 3);
+    reg1 = __lasx_xvslli_b(tmpg, 3);
+    reg2 = __lasx_xvslli_b(tmpr, 3);
+    tmpb = __lasx_xvsrli_b(tmpb, 2);
+    tmpg = __lasx_xvsrli_b(tmpg, 2);
+    tmpr = __lasx_xvsrli_b(tmpr, 2);
+    tmpb = __lasx_xvor_v(reg0, tmpb);
+    tmpg = __lasx_xvor_v(reg1, tmpg);
+    tmpr = __lasx_xvor_v(reg2, tmpr);
+    reg0 = __lasx_xvslli_b(nexb, 3);
+    reg1 = __lasx_xvslli_b(nexg, 3);
+    reg2 = __lasx_xvslli_b(nexr, 3);
+    nexb = __lasx_xvsrli_b(nexb, 2);
+    nexg = __lasx_xvsrli_b(nexg, 2);
+    nexr = __lasx_xvsrli_b(nexr, 2);
+    nexb = __lasx_xvor_v(reg0, nexb);
+    nexg = __lasx_xvor_v(reg1, nexg);
+    nexr = __lasx_xvor_v(reg2, nexr);
+    RGBTOUV(tmpb, tmpg, tmpr, nexb, nexg, nexr, reg0, reg1);
+    reg0 = __lasx_xvpermi_d(reg0, 0xD8);
+    reg1 = __lasx_xvpermi_d(reg1, 0xD8);
+    dst0 = __lasx_xvpickod_b(reg1, reg0);
+    __lasx_xvstelm_d(dst0, dst_u, 0, 0);
+    __lasx_xvstelm_d(dst0, dst_v, 0, 1);
+    __lasx_xvstelm_d(dst0, dst_u, 8, 2);
+    __lasx_xvstelm_d(dst0, dst_v, 8, 3);
+    src_argb1555 += 64;
+    next_argb1555 += 64;
+    dst_u += 16;
+    dst_v += 16;
+  }
+}
+
+void RGB565ToYRow_LASX(const uint8_t* src_rgb565, uint8_t* dst_y, int width) {
+  int x;
+  int len = width / 32;
+  __m256i src0, src1;
+  __m256i tmp0, tmp1, tmpb, tmpg, tmpr;
+  __m256i reg0, reg1, dst0;
+  __m256i const_66 = __lasx_xvldi(66);
+  __m256i const_129 = __lasx_xvldi(129);
+  __m256i const_25 = __lasx_xvldi(25);
+  __m256i const_1080 = {0x1080108010801080, 0x1080108010801080,
+                        0x1080108010801080, 0x1080108010801080};
+
+  for (x = 0; x < len; x++) {
+    src0 = __lasx_xvld(src_rgb565, 0);
+    src1 = __lasx_xvld(src_rgb565, 32);
+    tmp0 = __lasx_xvpickev_b(src1, src0);
+    tmp1 = __lasx_xvpickod_b(src1, src0);
+    tmpb = __lasx_xvandi_b(tmp0, 0x1F);
+    tmpr = __lasx_xvandi_b(tmp1, 0xF8);
+    reg1 = __lasx_xvandi_b(tmp1, 0x07);
+    reg0 = __lasx_xvsrli_b(tmp0, 5);
+    reg1 = __lasx_xvslli_b(reg1, 3);
+    tmpg = __lasx_xvor_v(reg1, reg0);
+    reg0 = __lasx_xvslli_b(tmpb, 3);
+    reg1 = __lasx_xvsrli_b(tmpb, 2);
+    tmpb = __lasx_xvor_v(reg1, reg0);
+    reg0 = __lasx_xvslli_b(tmpg, 2);
+    reg1 = __lasx_xvsrli_b(tmpg, 4);
+    tmpg = __lasx_xvor_v(reg1, reg0);
+    reg0 = __lasx_xvsrli_b(tmpr, 5);
+    tmpr = __lasx_xvor_v(tmpr, reg0);
+    reg0 = __lasx_xvmaddwev_h_bu(const_1080, tmpb, const_25);
+    reg1 = __lasx_xvmaddwod_h_bu(const_1080, tmpb, const_25);
+    reg0 = __lasx_xvmaddwev_h_bu(reg0, tmpg, const_129);
+    reg1 = __lasx_xvmaddwod_h_bu(reg1, tmpg, const_129);
+    reg0 = __lasx_xvmaddwev_h_bu(reg0, tmpr, const_66);
+    reg1 = __lasx_xvmaddwod_h_bu(reg1, tmpr, const_66);
+    dst0 = __lasx_xvpackod_b(reg1, reg0);
+    dst0 = __lasx_xvpermi_d(dst0, 0xD8);
+    __lasx_xvst(dst0, dst_y, 0);
+    dst_y += 32;
+    src_rgb565 += 64;
+  }
+}
+
+void RGB565ToUVRow_LASX(const uint8_t* src_rgb565,
+                        int src_stride_rgb565,
+                        uint8_t* dst_u,
+                        uint8_t* dst_v,
+                        int width) {
+  int x;
+  int len = width / 32;
+  const uint8_t* next_rgb565 = src_rgb565 + src_stride_rgb565;
+  __m256i src0, src1, src2, src3;
+  __m256i tmp0, tmp1, tmp2, tmp3;
+  __m256i tmpb, tmpg, tmpr, nexb, nexg, nexr;
+  __m256i reg0, reg1, reg2, reg3, dst0;
+  __m256i const_112 = __lasx_xvldi(0x438);
+  __m256i const_74 = __lasx_xvldi(0x425);
+  __m256i const_38 = __lasx_xvldi(0x413);
+  __m256i const_94 = __lasx_xvldi(0x42F);
+  __m256i const_18 = __lasx_xvldi(0x409);
+  __m256i const_8080 = {0x8080808080808080, 0x8080808080808080,
+                        0x8080808080808080, 0x8080808080808080};
+
+  for (x = 0; x < len; x++) {
+    DUP4_ARG2(__lasx_xvld, src_rgb565, 0, src_rgb565, 32, next_rgb565, 0,
+              next_rgb565, 32, src0, src1, src2, src3);
+    DUP2_ARG2(__lasx_xvpickev_b, src1, src0, src3, src2, tmp0, tmp2);
+    DUP2_ARG2(__lasx_xvpickod_b, src1, src0, src3, src2, tmp1, tmp3);
+    tmpb = __lasx_xvandi_b(tmp0, 0x1F);
+    tmpr = __lasx_xvandi_b(tmp1, 0xF8);
+    nexb = __lasx_xvandi_b(tmp2, 0x1F);
+    nexr = __lasx_xvandi_b(tmp3, 0xF8);
+    reg1 = __lasx_xvandi_b(tmp1, 0x07);
+    reg3 = __lasx_xvandi_b(tmp3, 0x07);
+    reg0 = __lasx_xvsrli_b(tmp0, 5);
+    reg1 = __lasx_xvslli_b(reg1, 3);
+    reg2 = __lasx_xvsrli_b(tmp2, 5);
+    reg3 = __lasx_xvslli_b(reg3, 3);
+    tmpg = __lasx_xvor_v(reg1, reg0);
+    nexg = __lasx_xvor_v(reg2, reg3);
+    reg0 = __lasx_xvslli_b(tmpb, 3);
+    reg1 = __lasx_xvsrli_b(tmpb, 2);
+    reg2 = __lasx_xvslli_b(nexb, 3);
+    reg3 = __lasx_xvsrli_b(nexb, 2);
+    tmpb = __lasx_xvor_v(reg1, reg0);
+    nexb = __lasx_xvor_v(reg2, reg3);
+    reg0 = __lasx_xvslli_b(tmpg, 2);
+    reg1 = __lasx_xvsrli_b(tmpg, 4);
+    reg2 = __lasx_xvslli_b(nexg, 2);
+    reg3 = __lasx_xvsrli_b(nexg, 4);
+    tmpg = __lasx_xvor_v(reg1, reg0);
+    nexg = __lasx_xvor_v(reg2, reg3);
+    reg0 = __lasx_xvsrli_b(tmpr, 5);
+    reg2 = __lasx_xvsrli_b(nexr, 5);
+    tmpr = __lasx_xvor_v(tmpr, reg0);
+    nexr = __lasx_xvor_v(nexr, reg2);
+    RGBTOUV(tmpb, tmpg, tmpr, nexb, nexg, nexr, reg0, reg1);
+    reg0 = __lasx_xvpermi_d(reg0, 0xD8);
+    reg1 = __lasx_xvpermi_d(reg1, 0xD8);
+    dst0 = __lasx_xvpickod_b(reg1, reg0);
+    __lasx_xvstelm_d(dst0, dst_u, 0, 0);
+    __lasx_xvstelm_d(dst0, dst_v, 0, 1);
+    __lasx_xvstelm_d(dst0, dst_u, 8, 2);
+    __lasx_xvstelm_d(dst0, dst_v, 8, 3);
+    dst_u += 16;
+    dst_v += 16;
+    src_rgb565 += 64;
+    next_rgb565 += 64;
+  }
+}
+
+void RGB24ToYRow_LASX(const uint8_t* src_rgb24, uint8_t* dst_y, int width) {
+  int x;
+  int len = width / 32;
+  __m256i src0, src1, src2;
+  __m256i tmp0, tmp1, tmp2, tmp3;
+  __m256i reg0, reg1, reg2, dst0;
+  __m256i const_129 = __lasx_xvldi(129);
+  __m256i const_br = {0x4219421942194219, 0x4219421942194219,
+                      0x4219421942194219, 0x4219421942194219};
+  __m256i const_1080 = {0x1080108010801080, 0x1080108010801080,
+                        0x1080108010801080, 0x1080108010801080};
+  __m256i shuff0 = {0x0B09080605030200, 0x17151412110F0E0C, 0x0B09080605030200,
+                    0x17151412110F0E0C};
+  __m256i shuff1 = {0x0301001E1D1B1A18, 0x0F0D0C0A09070604, 0x0301001E1D1B1A18,
+                    0x0F0D0C0A09070604};
+  __m256i shuff2 = {0x000A000700040001, 0x001600130010000D, 0x000A000700040001,
+                    0x001600130010000D};
+  __m256i shuff3 = {0x0002001F001C0019, 0x000E000B00080005, 0x0002001F001C0019,
+                    0x000E000B00080005};
+
+  for (x = 0; x < len; x++) {
+    reg0 = __lasx_xvld(src_rgb24, 0);
+    reg1 = __lasx_xvld(src_rgb24, 32);
+    reg2 = __lasx_xvld(src_rgb24, 64);
+    src0 = __lasx_xvpermi_q(reg1, reg0, 0x30);
+    src1 = __lasx_xvpermi_q(reg2, reg0, 0x21);
+    src2 = __lasx_xvpermi_q(reg2, reg1, 0x30);
+    tmp0 = __lasx_xvshuf_b(src1, src0, shuff0);
+    tmp1 = __lasx_xvshuf_b(src1, src2, shuff1);
+    tmp2 = __lasx_xvshuf_b(src1, src0, shuff2);
+    tmp3 = __lasx_xvshuf_b(src1, src2, shuff3);
+    reg0 = __lasx_xvmaddwev_h_bu(const_1080, tmp2, const_129);
+    reg1 = __lasx_xvmaddwev_h_bu(const_1080, tmp3, const_129);
+    reg0 = __lasx_xvdp2add_h_bu(reg0, const_br, tmp0);
+    reg1 = __lasx_xvdp2add_h_bu(reg1, const_br, tmp1);
+    dst0 = __lasx_xvpickod_b(reg1, reg0);
+    __lasx_xvst(dst0, dst_y, 0);
+    dst_y += 32;
+    src_rgb24 += 96;
+  }
+}
+
+void RGB24ToUVRow_LASX(const uint8_t* src_rgb24,
+                       int src_stride_rgb24,
+                       uint8_t* dst_u,
+                       uint8_t* dst_v,
+                       int width) {
+  int x;
+  const uint8_t* next_rgb24 = src_rgb24 + src_stride_rgb24;
+  int len = width / 32;
+  __m256i src0, src1, src2, reg0, reg1, reg2;
+  __m256i nex0, nex1, nex2, dst0, tmp0, tmp1, tmp2;
+  __m256i tmpb, tmpg, tmpr, nexb, nexg, nexr;
+  __m256i const_112 = __lasx_xvldi(0x438);
+  __m256i const_74 = __lasx_xvldi(0x425);
+  __m256i const_38 = __lasx_xvldi(0x413);
+  __m256i const_94 = __lasx_xvldi(0x42F);
+  __m256i const_18 = __lasx_xvldi(0x409);
+  __m256i const_8080 = {0x8080808080808080, 0x8080808080808080,
+                        0x8080808080808080, 0x8080808080808080};
+  __m256i shuff0_b = {0x15120F0C09060300, 0x00000000001E1B18,
+                      0x15120F0C09060300, 0x00000000001E1B18};
+  __m256i shuff1_b = {0x0706050403020100, 0x1D1A1714110A0908,
+                      0x0706050403020100, 0x1D1A1714110A0908};
+  __m256i shuff0_g = {0x1613100D0A070401, 0x00000000001F1C19,
+                      0x1613100D0A070401, 0x00000000001F1C19};
+  __m256i shuff1_g = {0x0706050403020100, 0x1E1B1815120A0908,
+                      0x0706050403020100, 0x1E1B1815120A0908};
+  __m256i shuff0_r = {0x1714110E0B080502, 0x0000000000001D1A,
+                      0x1714110E0B080502, 0x0000000000001D1A};
+  __m256i shuff1_r = {0x0706050403020100, 0x1F1C191613100908,
+                      0x0706050403020100, 0x1F1C191613100908};
+
+  for (x = 0; x < len; x++) {
+    DUP4_ARG2(__lasx_xvld, src_rgb24, 0, src_rgb24, 32, src_rgb24, 64,
+              next_rgb24, 0, reg0, reg1, reg2, tmp0);
+    DUP2_ARG2(__lasx_xvld, next_rgb24, 32, next_rgb24, 64, tmp1, tmp2);
+    DUP4_ARG3(__lasx_xvpermi_q, reg1, reg0, 0x30, reg2, reg0, 0x21, reg2, reg1,
+              0x30, tmp1, tmp0, 0x30, src0, src1, src2, nex0);
+    DUP2_ARG3(__lasx_xvpermi_q, tmp2, tmp0, 0x21, tmp2, tmp1, 0x30, nex1, nex2);
+    DUP2_ARG3(__lasx_xvshuf_b, src1, src0, shuff0_b, nex1, nex0, shuff0_b, tmpb,
+              nexb);
+    DUP2_ARG3(__lasx_xvshuf_b, src1, src0, shuff0_g, nex1, nex0, shuff0_g, tmpg,
+              nexg);
+    DUP2_ARG3(__lasx_xvshuf_b, src1, src0, shuff0_r, nex1, nex0, shuff0_r, tmpr,
+              nexr);
+    DUP2_ARG3(__lasx_xvshuf_b, src2, tmpb, shuff1_b, nex2, nexb, shuff1_b, tmpb,
+              nexb);
+    DUP2_ARG3(__lasx_xvshuf_b, src2, tmpg, shuff1_g, nex2, nexg, shuff1_g, tmpg,
+              nexg);
+    DUP2_ARG3(__lasx_xvshuf_b, src2, tmpr, shuff1_r, nex2, nexr, shuff1_r, tmpr,
+              nexr);
+    RGBTOUV(tmpb, tmpg, tmpr, nexb, nexg, nexr, reg0, reg1);
+    dst0 = __lasx_xvpickod_b(reg1, reg0);
+    __lasx_xvstelm_d(dst0, dst_u, 0, 0);
+    __lasx_xvstelm_d(dst0, dst_v, 0, 1);
+    __lasx_xvstelm_d(dst0, dst_u, 8, 2);
+    __lasx_xvstelm_d(dst0, dst_v, 8, 3);
+    src_rgb24 += 96;
+    next_rgb24 += 96;
+    dst_u += 16;
+    dst_v += 16;
+  }
+}
+
+void RAWToYRow_LASX(const uint8_t* src_raw, uint8_t* dst_y, int width) {
+  int x;
+  int len = width / 32;
+  __m256i src0, src1, src2;
+  __m256i tmp0, tmp1, tmp2, tmp3;
+  __m256i reg0, reg1, reg2, dst0;
+  __m256i const_129 = __lasx_xvldi(129);
+  __m256i const_br = {0x1942194219421942, 0x1942194219421942,
+                      0x1942194219421942, 0x1942194219421942};
+  __m256i const_1080 = {0x1080108010801080, 0x1080108010801080,
+                        0x1080108010801080, 0x1080108010801080};
+  __m256i shuff0 = {0x0B09080605030200, 0x17151412110F0E0C, 0x0B09080605030200,
+                    0x17151412110F0E0C};
+  __m256i shuff1 = {0x0301001E1D1B1A18, 0x0F0D0C0A09070604, 0x0301001E1D1B1A18,
+                    0x0F0D0C0A09070604};
+  __m256i shuff2 = {0x000A000700040001, 0x001600130010000D, 0x000A000700040001,
+                    0x001600130010000D};
+  __m256i shuff3 = {0x0002001F001C0019, 0x000E000B00080005, 0x0002001F001C0019,
+                    0x000E000B00080005};
+
+  for (x = 0; x < len; x++) {
+    reg0 = __lasx_xvld(src_raw, 0);
+    reg1 = __lasx_xvld(src_raw, 32);
+    reg2 = __lasx_xvld(src_raw, 64);
+    src0 = __lasx_xvpermi_q(reg1, reg0, 0x30);
+    src1 = __lasx_xvpermi_q(reg2, reg0, 0x21);
+    src2 = __lasx_xvpermi_q(reg2, reg1, 0x30);
+    tmp0 = __lasx_xvshuf_b(src1, src0, shuff0);
+    tmp1 = __lasx_xvshuf_b(src1, src2, shuff1);
+    tmp2 = __lasx_xvshuf_b(src1, src0, shuff2);
+    tmp3 = __lasx_xvshuf_b(src1, src2, shuff3);
+    reg0 = __lasx_xvmaddwev_h_bu(const_1080, tmp2, const_129);
+    reg1 = __lasx_xvmaddwev_h_bu(const_1080, tmp3, const_129);
+    reg0 = __lasx_xvdp2add_h_bu(reg0, const_br, tmp0);
+    reg1 = __lasx_xvdp2add_h_bu(reg1, const_br, tmp1);
+    dst0 = __lasx_xvpickod_b(reg1, reg0);
+    __lasx_xvst(dst0, dst_y, 0);
+    dst_y += 32;
+    src_raw += 96;
+  }
+}
+
+void RAWToUVRow_LASX(const uint8_t* src_raw,
+                     int src_stride_raw,
+                     uint8_t* dst_u,
+                     uint8_t* dst_v,
+                     int width) {
+  int x;
+  const uint8_t* next_raw = src_raw + src_stride_raw;
+  int len = width / 32;
+  __m256i src0, src1, src2, reg0, reg1, reg2;
+  __m256i nex0, nex1, nex2, dst0, tmp0, tmp1, tmp2;
+  __m256i tmpb, tmpg, tmpr, nexb, nexg, nexr;
+  __m256i const_112 = __lasx_xvldi(0x438);
+  __m256i const_74 = __lasx_xvldi(0x425);
+  __m256i const_38 = __lasx_xvldi(0x413);
+  __m256i const_94 = __lasx_xvldi(0x42F);
+  __m256i const_18 = __lasx_xvldi(0x409);
+  __m256i const_8080 = {0x8080808080808080, 0x8080808080808080,
+                        0x8080808080808080, 0x8080808080808080};
+  __m256i shuff0_r = {0x15120F0C09060300, 0x00000000001E1B18,
+                      0x15120F0C09060300, 0x00000000001E1B18};
+  __m256i shuff1_r = {0x0706050403020100, 0x1D1A1714110A0908,
+                      0x0706050403020100, 0x1D1A1714110A0908};
+  __m256i shuff0_g = {0x1613100D0A070401, 0x00000000001F1C19,
+                      0x1613100D0A070401, 0x00000000001F1C19};
+  __m256i shuff1_g = {0x0706050403020100, 0x1E1B1815120A0908,
+                      0x0706050403020100, 0x1E1B1815120A0908};
+  __m256i shuff0_b = {0x1714110E0B080502, 0x0000000000001D1A,
+                      0x1714110E0B080502, 0x0000000000001D1A};
+  __m256i shuff1_b = {0x0706050403020100, 0x1F1C191613100908,
+                      0x0706050403020100, 0x1F1C191613100908};
+
+  for (x = 0; x < len; x++) {
+    DUP4_ARG2(__lasx_xvld, src_raw, 0, src_raw, 32, src_raw, 64, next_raw, 0,
+              reg0, reg1, reg2, tmp0);
+    DUP2_ARG2(__lasx_xvld, next_raw, 32, next_raw, 64, tmp1, tmp2);
+    DUP4_ARG3(__lasx_xvpermi_q, reg1, reg0, 0x30, reg2, reg0, 0x21, reg2, reg1,
+              0x30, tmp1, tmp0, 0x30, src0, src1, src2, nex0);
+    DUP2_ARG3(__lasx_xvpermi_q, tmp2, tmp0, 0x21, tmp2, tmp1, 0x30, nex1, nex2);
+    DUP2_ARG3(__lasx_xvshuf_b, src1, src0, shuff0_b, nex1, nex0, shuff0_b, tmpb,
+              nexb);
+    DUP2_ARG3(__lasx_xvshuf_b, src1, src0, shuff0_g, nex1, nex0, shuff0_g, tmpg,
+              nexg);
+    DUP2_ARG3(__lasx_xvshuf_b, src1, src0, shuff0_r, nex1, nex0, shuff0_r, tmpr,
+              nexr);
+    DUP2_ARG3(__lasx_xvshuf_b, src2, tmpb, shuff1_b, nex2, nexb, shuff1_b, tmpb,
+              nexb);
+    DUP2_ARG3(__lasx_xvshuf_b, src2, tmpg, shuff1_g, nex2, nexg, shuff1_g, tmpg,
+              nexg);
+    DUP2_ARG3(__lasx_xvshuf_b, src2, tmpr, shuff1_r, nex2, nexr, shuff1_r, tmpr,
+              nexr);
+    RGBTOUV(tmpb, tmpg, tmpr, nexb, nexg, nexr, reg0, reg1);
+    dst0 = __lasx_xvpickod_b(reg1, reg0);
+    __lasx_xvstelm_d(dst0, dst_u, 0, 0);
+    __lasx_xvstelm_d(dst0, dst_v, 0, 1);
+    __lasx_xvstelm_d(dst0, dst_u, 8, 2);
+    __lasx_xvstelm_d(dst0, dst_v, 8, 3);
+    src_raw += 96;
+    next_raw += 96;
+    dst_u += 16;
+    dst_v += 16;
+  }
+}
+
+void NV12ToARGBRow_LASX(const uint8_t* src_y,
+                        const uint8_t* src_uv,
+                        uint8_t* dst_argb,
+                        const struct YuvConstants* yuvconstants,
+                        int width) {
+  int x;
+  int len = width / 16;
+  __m256i vec_yg, vec_yb, vec_ub, vec_vr, vec_ug, vec_vg;
+  __m256i vec_vrub, vec_vgug, vec_y, vec_vu;
+  __m256i out_b, out_g, out_r;
+  __m256i const_0x80 = __lasx_xvldi(0x80);
+  __m256i alpha = __lasx_xvldi(0xFF);
+
+  YUVTORGB_SETUP(yuvconstants, vec_ub, vec_vr, vec_ug, vec_vg, vec_yg, vec_yb);
+  vec_vrub = __lasx_xvilvl_h(vec_vr, vec_ub);
+  vec_vgug = __lasx_xvilvl_h(vec_vg, vec_ug);
+
+  for (x = 0; x < len; x++) {
+    vec_y = __lasx_xvld(src_y, 0);
+    vec_vu = __lasx_xvld(src_uv, 0);
+    vec_vu = __lasx_xvsub_b(vec_vu, const_0x80);
+    vec_vu = __lasx_vext2xv_h_b(vec_vu);
+    YUVTORGB(vec_y, vec_vu, vec_vrub, vec_vgug, vec_yg, vec_yb, out_r, out_g,
+             out_b);
+    STOREARGB(alpha, out_r, out_g, out_b, dst_argb);
+    src_y += 16;
+    src_uv += 16;
+  }
+}
+
+void NV12ToRGB565Row_LASX(const uint8_t* src_y,
+                          const uint8_t* src_uv,
+                          uint8_t* dst_rgb565,
+                          const struct YuvConstants* yuvconstants,
+                          int width) {
+  int x;
+  int len = width / 16;
+  __m256i vec_yg, vec_yb, vec_ub, vec_vr, vec_ug, vec_vg;
+  __m256i vec_vrub, vec_vgug, vec_y, vec_vu;
+  __m256i out_b, out_g, out_r;
+  __m256i const_0x80 = __lasx_xvldi(0x80);
+
+  YUVTORGB_SETUP(yuvconstants, vec_ub, vec_vr, vec_ug, vec_vg, vec_yg, vec_yb);
+  vec_vrub = __lasx_xvilvl_h(vec_vr, vec_ub);
+  vec_vgug = __lasx_xvilvl_h(vec_vg, vec_ug);
+
+  for (x = 0; x < len; x++) {
+    vec_y = __lasx_xvld(src_y, 0);
+    vec_vu = __lasx_xvld(src_uv, 0);
+    vec_vu = __lasx_xvsub_b(vec_vu, const_0x80);
+    vec_vu = __lasx_vext2xv_h_b(vec_vu);
+    YUVTORGB(vec_y, vec_vu, vec_vrub, vec_vgug, vec_yg, vec_yb, out_r, out_g,
+             out_b);
+    out_b = __lasx_xvsrli_h(out_b, 3);
+    out_g = __lasx_xvsrli_h(out_g, 2);
+    out_r = __lasx_xvsrli_h(out_r, 3);
+    out_g = __lasx_xvslli_h(out_g, 5);
+    out_r = __lasx_xvslli_h(out_r, 11);
+    out_r = __lasx_xvor_v(out_r, out_g);
+    out_r = __lasx_xvor_v(out_r, out_b);
+    __lasx_xvst(out_r, dst_rgb565, 0);
+    src_y += 16;
+    src_uv += 16;
+    dst_rgb565 += 32;
+  }
+}
+
+void NV21ToARGBRow_LASX(const uint8_t* src_y,
+                        const uint8_t* src_uv,
+                        uint8_t* dst_argb,
+                        const struct YuvConstants* yuvconstants,
+                        int width) {
+  int x;
+  int len = width / 16;
+  __m256i vec_yg, vec_yb, vec_ub, vec_vr, vec_ug, vec_vg;
+  __m256i vec_ubvr, vec_ugvg, vec_y, vec_uv;
+  __m256i out_b, out_g, out_r;
+  __m256i const_0x80 = __lasx_xvldi(0x80);
+  __m256i alpha = __lasx_xvldi(0xFF);
+
+  YUVTORGB_SETUP(yuvconstants, vec_ub, vec_vr, vec_ug, vec_vg, vec_yg, vec_yb);
+  vec_ubvr = __lasx_xvilvl_h(vec_ub, vec_vr);
+  vec_ugvg = __lasx_xvilvl_h(vec_ug, vec_vg);
+
+  for (x = 0; x < len; x++) {
+    vec_y = __lasx_xvld(src_y, 0);
+    vec_uv = __lasx_xvld(src_uv, 0);
+    vec_uv = __lasx_xvsub_b(vec_uv, const_0x80);
+    vec_uv = __lasx_vext2xv_h_b(vec_uv);
+    YUVTORGB(vec_y, vec_uv, vec_ubvr, vec_ugvg, vec_yg, vec_yb, out_b, out_g,
+             out_r);
+    STOREARGB(alpha, out_r, out_g, out_b, dst_argb);
+    src_y += 16;
+    src_uv += 16;
+  }
+}
+
+void ARGBToYJRow_LASX(const uint8_t* src_argb, uint8_t* dst_y, int width) {
+  int x;
+  int len = width / 32;
+  __m256i src0, src1, src2, src3, dst0;
+  __m256i tmp0, tmp1, tmp2, tmp3;
+  __m256i reg0, reg1;
+  __m256i const_128 = __lasx_xvldi(0x480);
+  __m256i const_150 = __lasx_xvldi(0x96);
+  __m256i const_br = {0x4D1D4D1D4D1D4D1D, 0x4D1D4D1D4D1D4D1D,
+                      0x4D1D4D1D4D1D4D1D, 0x4D1D4D1D4D1D4D1D};
+  __m256i shuff = {0x0000000400000000, 0x0000000500000001, 0x0000000600000002,
+                   0x0000000700000003};
+
+  for (x = 0; x < len; x++) {
+    DUP4_ARG2(__lasx_xvld, src_argb, 0, src_argb, 32, src_argb, 64, src_argb,
+              96, src0, src1, src2, src3);
+    tmp0 = __lasx_xvpickev_b(src1, src0);
+    tmp1 = __lasx_xvpickod_b(src1, src0);
+    tmp2 = __lasx_xvpickev_b(src3, src2);
+    tmp3 = __lasx_xvpickod_b(src3, src2);
+    reg0 = __lasx_xvmaddwev_h_bu(const_128, tmp1, const_150);
+    reg1 = __lasx_xvmaddwev_h_bu(const_128, tmp3, const_150);
+    reg0 = __lasx_xvdp2add_h_bu(reg0, const_br, tmp0);
+    reg1 = __lasx_xvdp2add_h_bu(reg1, const_br, tmp2);
+    dst0 = __lasx_xvpickod_b(reg1, reg0);
+    dst0 = __lasx_xvperm_w(dst0, shuff);
+    __lasx_xvst(dst0, dst_y, 0);
+    dst_y += 32;
+    src_argb += 128;
+  }
+}
+
+void ARGBToUVJRow_LASX(const uint8_t* src_argb,
+                       int src_stride_argb,
+                       uint8_t* dst_u,
+                       uint8_t* dst_v,
+                       int width) {
+  int x;
+  const uint8_t* next_argb = src_argb + src_stride_argb;
+  int len = width / 32;
+  __m256i src0, src1, src2, src3;
+  __m256i nex0, nex1, nex2, nex3;
+  __m256i tmp0, tmp1, tmp2, tmp3;
+  __m256i reg0, reg1, dst0;
+  __m256i tmpb, tmpg, tmpr, nexb, nexg, nexr;
+  __m256i const_63 = __lasx_xvldi(0x43F);
+  __m256i const_42 = __lasx_xvldi(0x42A);
+  __m256i const_21 = __lasx_xvldi(0x415);
+  __m256i const_53 = __lasx_xvldi(0x435);
+  __m256i const_10 = __lasx_xvldi(0x40A);
+  __m256i const_8080 = {0x8080808080808080, 0x8080808080808080,
+                        0x8080808080808080, 0x8080808080808080};
+  __m256i shuff = {0x1614060412100200, 0x1E1C0E0C1A180A08, 0x1715070513110301,
+                   0x1F1D0F0D1B190B09};
+
+  for (x = 0; x < len; x++) {
+    DUP4_ARG2(__lasx_xvld, src_argb, 0, src_argb, 32, src_argb, 64, src_argb,
+              96, src0, src1, src2, src3);
+    DUP4_ARG2(__lasx_xvld, next_argb, 0, next_argb, 32, next_argb, 64,
+              next_argb, 96, nex0, nex1, nex2, nex3);
+    tmp0 = __lasx_xvpickev_b(src1, src0);
+    tmp1 = __lasx_xvpickod_b(src1, src0);
+    tmp2 = __lasx_xvpickev_b(src3, src2);
+    tmp3 = __lasx_xvpickod_b(src3, src2);
+    tmpr = __lasx_xvpickod_b(tmp2, tmp0);
+    tmpb = __lasx_xvpickev_b(tmp2, tmp0);
+    tmpg = __lasx_xvpickev_b(tmp3, tmp1);
+    tmp0 = __lasx_xvpickev_b(nex1, nex0);
+    tmp1 = __lasx_xvpickod_b(nex1, nex0);
+    tmp2 = __lasx_xvpickev_b(nex3, nex2);
+    tmp3 = __lasx_xvpickod_b(nex3, nex2);
+    nexr = __lasx_xvpickod_b(tmp2, tmp0);
+    nexb = __lasx_xvpickev_b(tmp2, tmp0);
+    nexg = __lasx_xvpickev_b(tmp3, tmp1);
+    tmp0 = __lasx_xvaddwev_h_bu(tmpb, nexb);
+    tmp1 = __lasx_xvaddwod_h_bu(tmpb, nexb);
+    tmp2 = __lasx_xvaddwev_h_bu(tmpg, nexg);
+    tmp3 = __lasx_xvaddwod_h_bu(tmpg, nexg);
+    reg0 = __lasx_xvaddwev_h_bu(tmpr, nexr);
+    reg1 = __lasx_xvaddwod_h_bu(tmpr, nexr);
+    tmpb = __lasx_xvavgr_hu(tmp0, tmp1);
+    tmpg = __lasx_xvavgr_hu(tmp2, tmp3);
+    tmpr = __lasx_xvavgr_hu(reg0, reg1);
+    reg0 = __lasx_xvmadd_h(const_8080, const_63, tmpb);
+    reg1 = __lasx_xvmadd_h(const_8080, const_63, tmpr);
+    reg0 = __lasx_xvmsub_h(reg0, const_42, tmpg);
+    reg1 = __lasx_xvmsub_h(reg1, const_53, tmpg);
+    reg0 = __lasx_xvmsub_h(reg0, const_21, tmpr);
+    reg1 = __lasx_xvmsub_h(reg1, const_10, tmpb);
+    dst0 = __lasx_xvpackod_b(reg1, reg0);
+    tmp0 = __lasx_xvpermi_d(dst0, 0x44);
+    tmp1 = __lasx_xvpermi_d(dst0, 0xEE);
+    dst0 = __lasx_xvshuf_b(tmp1, tmp0, shuff);
+    __lasx_xvstelm_d(dst0, dst_u, 0, 0);
+    __lasx_xvstelm_d(dst0, dst_v, 0, 2);
+    __lasx_xvstelm_d(dst0, dst_u, 8, 1);
+    __lasx_xvstelm_d(dst0, dst_v, 8, 3);
+    dst_u += 16;
+    dst_v += 16;
+    src_argb += 128;
+    next_argb += 128;
+  }
+}
+
+#ifdef __cplusplus
+}  // extern "C"
+}  // namespace libyuv
+#endif
+
+#endif  // !defined(LIBYUV_DISABLE_LASX) && defined(__loongarch_asx)
diff --git a/3rdparty/libyuv/src/source/row_lsx.cc b/3rdparty/libyuv/src/source/row_lsx.cc
new file mode 100644
index 00000000..3e8b901a
--- /dev/null
+++ b/3rdparty/libyuv/src/source/row_lsx.cc
@@ -0,0 +1,1829 @@
+/*
+ *  Copyright 2022 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Copyright (c) 2022 Loongson Technology Corporation Limited
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include "libyuv/row.h"
+
+#if !defined(LIBYUV_DISABLE_LSX) && defined(__loongarch_sx)
+#include "libyuv/loongson_intrinsics.h"
+
+#ifdef __cplusplus
+namespace libyuv {
+extern "C" {
+#endif
+
+// Fill YUV -> RGB conversion constants into vectors
+#define YUVTORGB_SETUP(yuvconst, vr, ub, vg, ug, yg, yb) \
+  {                                                      \
+    ub = __lsx_vreplgr2vr_h(yuvconst->kUVToB[0]);        \
+    vr = __lsx_vreplgr2vr_h(yuvconst->kUVToR[1]);        \
+    ug = __lsx_vreplgr2vr_h(yuvconst->kUVToG[0]);        \
+    vg = __lsx_vreplgr2vr_h(yuvconst->kUVToG[1]);        \
+    yg = __lsx_vreplgr2vr_h(yuvconst->kYToRgb[0]);       \
+    yb = __lsx_vreplgr2vr_w(yuvconst->kYBiasToRgb[0]);   \
+  }
+
+// Convert 8 pixels of YUV420 to RGB.
+#define YUVTORGB(in_y, in_vu, vrub, vgug, yg, yb, out_b, out_g, out_r) \
+  {                                                                    \
+    __m128i y_ev, y_od, u_l, v_l;                                      \
+    __m128i tmp0, tmp1, tmp2, tmp3;                                    \
+                                                                       \
+    tmp0 = __lsx_vilvl_b(in_y, in_y);                                  \
+    y_ev = __lsx_vmulwev_w_hu_h(tmp0, yg);                             \
+    y_od = __lsx_vmulwod_w_hu_h(tmp0, yg);                             \
+    y_ev = __lsx_vsrai_w(y_ev, 16);                                    \
+    y_od = __lsx_vsrai_w(y_od, 16);                                    \
+    y_ev = __lsx_vadd_w(y_ev, yb);                                     \
+    y_od = __lsx_vadd_w(y_od, yb);                                     \
+    in_vu = __lsx_vilvl_b(zero, in_vu);                                \
+    in_vu = __lsx_vsub_h(in_vu, const_80);                             \
+    u_l = __lsx_vmulwev_w_h(in_vu, vrub);                              \
+    v_l = __lsx_vmulwod_w_h(in_vu, vrub);                              \
+    tmp0 = __lsx_vadd_w(y_ev, u_l);                                    \
+    tmp1 = __lsx_vadd_w(y_od, u_l);                                    \
+    tmp2 = __lsx_vadd_w(y_ev, v_l);                                    \
+    tmp3 = __lsx_vadd_w(y_od, v_l);                                    \
+    tmp0 = __lsx_vsrai_w(tmp0, 6);                                     \
+    tmp1 = __lsx_vsrai_w(tmp1, 6);                                     \
+    tmp2 = __lsx_vsrai_w(tmp2, 6);                                     \
+    tmp3 = __lsx_vsrai_w(tmp3, 6);                                     \
+    tmp0 = __lsx_vclip255_w(tmp0);                                     \
+    tmp1 = __lsx_vclip255_w(tmp1);                                     \
+    tmp2 = __lsx_vclip255_w(tmp2);                                     \
+    tmp3 = __lsx_vclip255_w(tmp3);                                     \
+    out_b = __lsx_vpackev_h(tmp1, tmp0);                               \
+    out_r = __lsx_vpackev_h(tmp3, tmp2);                               \
+    tmp0 = __lsx_vdp2_w_h(in_vu, vgug);                                \
+    tmp1 = __lsx_vsub_w(y_ev, tmp0);                                   \
+    tmp2 = __lsx_vsub_w(y_od, tmp0);                                   \
+    tmp1 = __lsx_vsrai_w(tmp1, 6);                                     \
+    tmp2 = __lsx_vsrai_w(tmp2, 6);                                     \
+    tmp1 = __lsx_vclip255_w(tmp1);                                     \
+    tmp2 = __lsx_vclip255_w(tmp2);                                     \
+    out_g = __lsx_vpackev_h(tmp2, tmp1);                               \
+  }
+
+// Convert I444 pixels of YUV420 to RGB.
+#define I444TORGB(in_yy, in_u, in_v, ub, vr, ugvg, yg, yb, out_b, out_g, \
+                  out_r)                                                 \
+  {                                                                      \
+    __m128i y_ev, y_od, u_ev, v_ev, u_od, v_od;                          \
+    __m128i tmp0, tmp1, tmp2, tmp3;                                      \
+                                                                         \
+    y_ev = __lsx_vmulwev_w_hu_h(in_yy, yg);                              \
+    y_od = __lsx_vmulwod_w_hu_h(in_yy, yg);                              \
+    y_ev = __lsx_vsrai_w(y_ev, 16);                                      \
+    y_od = __lsx_vsrai_w(y_od, 16);                                      \
+    y_ev = __lsx_vadd_w(y_ev, yb);                                       \
+    y_od = __lsx_vadd_w(y_od, yb);                                       \
+    in_u = __lsx_vsub_h(in_u, const_80);                                 \
+    in_v = __lsx_vsub_h(in_v, const_80);                                 \
+    u_ev = __lsx_vmulwev_w_h(in_u, ub);                                  \
+    u_od = __lsx_vmulwod_w_h(in_u, ub);                                  \
+    v_ev = __lsx_vmulwev_w_h(in_v, vr);                                  \
+    v_od = __lsx_vmulwod_w_h(in_v, vr);                                  \
+    tmp0 = __lsx_vadd_w(y_ev, u_ev);                                     \
+    tmp1 = __lsx_vadd_w(y_od, u_od);                                     \
+    tmp2 = __lsx_vadd_w(y_ev, v_ev);                                     \
+    tmp3 = __lsx_vadd_w(y_od, v_od);                                     \
+    tmp0 = __lsx_vsrai_w(tmp0, 6);                                       \
+    tmp1 = __lsx_vsrai_w(tmp1, 6);                                       \
+    tmp2 = __lsx_vsrai_w(tmp2, 6);                                       \
+    tmp3 = __lsx_vsrai_w(tmp3, 6);                                       \
+    tmp0 = __lsx_vclip255_w(tmp0);                                       \
+    tmp1 = __lsx_vclip255_w(tmp1);                                       \
+    tmp2 = __lsx_vclip255_w(tmp2);                                       \
+    tmp3 = __lsx_vclip255_w(tmp3);                                       \
+    out_b = __lsx_vpackev_h(tmp1, tmp0);                                 \
+    out_r = __lsx_vpackev_h(tmp3, tmp2);                                 \
+    u_ev = __lsx_vpackev_h(in_u, in_v);                                  \
+    u_od = __lsx_vpackod_h(in_u, in_v);                                  \
+    v_ev = __lsx_vdp2_w_h(u_ev, ugvg);                                   \
+    v_od = __lsx_vdp2_w_h(u_od, ugvg);                                   \
+    tmp0 = __lsx_vsub_w(y_ev, v_ev);                                     \
+    tmp1 = __lsx_vsub_w(y_od, v_od);                                     \
+    tmp0 = __lsx_vsrai_w(tmp0, 6);                                       \
+    tmp1 = __lsx_vsrai_w(tmp1, 6);                                       \
+    tmp0 = __lsx_vclip255_w(tmp0);                                       \
+    tmp1 = __lsx_vclip255_w(tmp1);                                       \
+    out_g = __lsx_vpackev_h(tmp1, tmp0);                                 \
+  }
+
+// Pack and Store 8 ARGB values.
+#define STOREARGB(in_a, in_r, in_g, in_b, pdst_argb) \
+  {                                                  \
+    __m128i temp0, temp1;                            \
+    __m128i dst0, dst1;                              \
+                                                     \
+    temp0 = __lsx_vpackev_b(in_g, in_b);             \
+    temp1 = __lsx_vpackev_b(in_a, in_r);             \
+    dst0 = __lsx_vilvl_h(temp1, temp0);              \
+    dst1 = __lsx_vilvh_h(temp1, temp0);              \
+    __lsx_vst(dst0, pdst_argb, 0);                   \
+    __lsx_vst(dst1, pdst_argb, 16);                  \
+    pdst_argb += 32;                                 \
+  }
+
+#define RGBTOUV(_tmpb, _tmpg, _tmpr, _nexb, _nexg, _nexr, _dst0) \
+  {                                                              \
+    __m128i _tmp0, _tmp1, _tmp2, _tmp3;                          \
+    __m128i _reg0, _reg1;                                        \
+    _tmp0 = __lsx_vaddwev_h_bu(_tmpb, _nexb);                    \
+    _tmp1 = __lsx_vaddwod_h_bu(_tmpb, _nexb);                    \
+    _tmp2 = __lsx_vaddwev_h_bu(_tmpg, _nexg);                    \
+    _tmp3 = __lsx_vaddwod_h_bu(_tmpg, _nexg);                    \
+    _reg0 = __lsx_vaddwev_h_bu(_tmpr, _nexr);                    \
+    _reg1 = __lsx_vaddwod_h_bu(_tmpr, _nexr);                    \
+    _tmpb = __lsx_vavgr_hu(_tmp0, _tmp1);                        \
+    _tmpg = __lsx_vavgr_hu(_tmp2, _tmp3);                        \
+    _tmpr = __lsx_vavgr_hu(_reg0, _reg1);                        \
+    _reg0 = __lsx_vmadd_h(const_8080, const_112, _tmpb);         \
+    _reg1 = __lsx_vmadd_h(const_8080, const_112, _tmpr);         \
+    _reg0 = __lsx_vmsub_h(_reg0, const_74, _tmpg);               \
+    _reg1 = __lsx_vmsub_h(_reg1, const_94, _tmpg);               \
+    _reg0 = __lsx_vmsub_h(_reg0, const_38, _tmpr);               \
+    _reg1 = __lsx_vmsub_h(_reg1, const_18, _tmpb);               \
+    _dst0 = __lsx_vpickod_b(_reg1, _reg0);                       \
+  }
+
+void ARGB4444ToARGBRow_LSX(const uint8_t* src_argb4444,
+                           uint8_t* dst_argb,
+                           int width) {
+  int x;
+  int len = width / 16;
+  __m128i src0, src1;
+  __m128i tmp0, tmp1, tmp2, tmp3;
+  __m128i reg0, reg1, reg2, reg3;
+  __m128i dst0, dst1, dst2, dst3;
+
+  for (x = 0; x < len; x++) {
+    src0 = __lsx_vld(src_argb4444, 0);
+    src1 = __lsx_vld(src_argb4444, 16);
+    tmp0 = __lsx_vandi_b(src0, 0x0F);
+    tmp1 = __lsx_vandi_b(src0, 0xF0);
+    tmp2 = __lsx_vandi_b(src1, 0x0F);
+    tmp3 = __lsx_vandi_b(src1, 0xF0);
+    reg0 = __lsx_vslli_b(tmp0, 4);
+    reg2 = __lsx_vslli_b(tmp2, 4);
+    reg1 = __lsx_vsrli_b(tmp1, 4);
+    reg3 = __lsx_vsrli_b(tmp3, 4);
+    DUP4_ARG2(__lsx_vor_v, tmp0, reg0, tmp1, reg1, tmp2, reg2, tmp3, reg3, tmp0,
+              tmp1, tmp2, tmp3);
+    dst0 = __lsx_vilvl_b(tmp1, tmp0);
+    dst2 = __lsx_vilvl_b(tmp3, tmp2);
+    dst1 = __lsx_vilvh_b(tmp1, tmp0);
+    dst3 = __lsx_vilvh_b(tmp3, tmp2);
+    __lsx_vst(dst0, dst_argb, 0);
+    __lsx_vst(dst1, dst_argb, 16);
+    __lsx_vst(dst2, dst_argb, 32);
+    __lsx_vst(dst3, dst_argb, 48);
+    dst_argb += 64;
+    src_argb4444 += 32;
+  }
+}
+
+void ARGB1555ToARGBRow_LSX(const uint8_t* src_argb1555,
+                           uint8_t* dst_argb,
+                           int width) {
+  int x;
+  int len = width / 16;
+  __m128i src0, src1;
+  __m128i tmp0, tmp1, tmpb, tmpg, tmpr, tmpa;
+  __m128i reg0, reg1, reg2;
+  __m128i dst0, dst1, dst2, dst3;
+
+  for (x = 0; x < len; x++) {
+    src0 = __lsx_vld(src_argb1555, 0);
+    src1 = __lsx_vld(src_argb1555, 16);
+    tmp0 = __lsx_vpickev_b(src1, src0);
+    tmp1 = __lsx_vpickod_b(src1, src0);
+    tmpb = __lsx_vandi_b(tmp0, 0x1F);
+    tmpg = __lsx_vsrli_b(tmp0, 5);
+    reg0 = __lsx_vandi_b(tmp1, 0x03);
+    reg0 = __lsx_vslli_b(reg0, 3);
+    tmpg = __lsx_vor_v(tmpg, reg0);
+    reg1 = __lsx_vandi_b(tmp1, 0x7C);
+    tmpr = __lsx_vsrli_b(reg1, 2);
+    tmpa = __lsx_vsrli_b(tmp1, 7);
+    tmpa = __lsx_vneg_b(tmpa);
+    reg0 = __lsx_vslli_b(tmpb, 3);
+    reg1 = __lsx_vslli_b(tmpg, 3);
+    reg2 = __lsx_vslli_b(tmpr, 3);
+    tmpb = __lsx_vsrli_b(tmpb, 2);
+    tmpg = __lsx_vsrli_b(tmpg, 2);
+    tmpr = __lsx_vsrli_b(tmpr, 2);
+    tmpb = __lsx_vor_v(reg0, tmpb);
+    tmpg = __lsx_vor_v(reg1, tmpg);
+    tmpr = __lsx_vor_v(reg2, tmpr);
+    DUP2_ARG2(__lsx_vilvl_b, tmpg, tmpb, tmpa, tmpr, reg0, reg1);
+    dst0 = __lsx_vilvl_h(reg1, reg0);
+    dst1 = __lsx_vilvh_h(reg1, reg0);
+    DUP2_ARG2(__lsx_vilvh_b, tmpg, tmpb, tmpa, tmpr, reg0, reg1);
+    dst2 = __lsx_vilvl_h(reg1, reg0);
+    dst3 = __lsx_vilvh_h(reg1, reg0);
+    __lsx_vst(dst0, dst_argb, 0);
+    __lsx_vst(dst1, dst_argb, 16);
+    __lsx_vst(dst2, dst_argb, 32);
+    __lsx_vst(dst3, dst_argb, 48);
+    dst_argb += 64;
+    src_argb1555 += 32;
+  }
+}
+
+void RGB565ToARGBRow_LSX(const uint8_t* src_rgb565,
+                         uint8_t* dst_argb,
+                         int width) {
+  int x;
+  int len = width / 16;
+  __m128i src0, src1;
+  __m128i tmp0, tmp1, tmpb, tmpg, tmpr;
+  __m128i reg0, reg1, dst0, dst1, dst2, dst3;
+  __m128i alpha = __lsx_vldi(0xFF);
+
+  for (x = 0; x < len; x++) {
+    src0 = __lsx_vld(src_rgb565, 0);
+    src1 = __lsx_vld(src_rgb565, 16);
+    tmp0 = __lsx_vpickev_b(src1, src0);
+    tmp1 = __lsx_vpickod_b(src1, src0);
+    tmpb = __lsx_vandi_b(tmp0, 0x1F);
+    tmpr = __lsx_vandi_b(tmp1, 0xF8);
+    reg1 = __lsx_vandi_b(tmp1, 0x07);
+    reg0 = __lsx_vsrli_b(tmp0, 5);
+    reg1 = __lsx_vslli_b(reg1, 3);
+    tmpg = __lsx_vor_v(reg1, reg0);
+    reg0 = __lsx_vslli_b(tmpb, 3);
+    reg1 = __lsx_vsrli_b(tmpb, 2);
+    tmpb = __lsx_vor_v(reg1, reg0);
+    reg0 = __lsx_vslli_b(tmpg, 2);
+    reg1 = __lsx_vsrli_b(tmpg, 4);
+    tmpg = __lsx_vor_v(reg1, reg0);
+    reg0 = __lsx_vsrli_b(tmpr, 5);
+    tmpr = __lsx_vor_v(tmpr, reg0);
+    DUP2_ARG2(__lsx_vilvl_b, tmpg, tmpb, alpha, tmpr, reg0, reg1);
+    dst0 = __lsx_vilvl_h(reg1, reg0);
+    dst1 = __lsx_vilvh_h(reg1, reg0);
+    DUP2_ARG2(__lsx_vilvh_b, tmpg, tmpb, alpha, tmpr, reg0, reg1);
+    dst2 = __lsx_vilvl_h(reg1, reg0);
+    dst3 = __lsx_vilvh_h(reg1, reg0);
+    __lsx_vst(dst0, dst_argb, 0);
+    __lsx_vst(dst1, dst_argb, 16);
+    __lsx_vst(dst2, dst_argb, 32);
+    __lsx_vst(dst3, dst_argb, 48);
+    dst_argb += 64;
+    src_rgb565 += 32;
+  }
+}
+
+void RGB24ToARGBRow_LSX(const uint8_t* src_rgb24,
+                        uint8_t* dst_argb,
+                        int width) {
+  int x;
+  int len = width / 16;
+  __m128i src0, src1, src2;
+  __m128i tmp0, tmp1, tmp2;
+  __m128i dst0, dst1, dst2, dst3;
+  __m128i alpha = __lsx_vldi(0xFF);
+  __m128i shuf0 = {0x131211100F0E0D0C, 0x1B1A191817161514};
+  __m128i shuf1 = {0x1F1E1D1C1B1A1918, 0x0706050403020100};
+  __m128i shuf2 = {0x0B0A090807060504, 0x131211100F0E0D0C};
+  __m128i shuf3 = {0x1005040310020100, 0x100B0A0910080706};
+
+  for (x = 0; x < len; x++) {
+    src0 = __lsx_vld(src_rgb24, 0);
+    src1 = __lsx_vld(src_rgb24, 16);
+    src2 = __lsx_vld(src_rgb24, 32);
+    DUP2_ARG3(__lsx_vshuf_b, src1, src0, shuf0, src1, src2, shuf1, tmp0, tmp1);
+    tmp2 = __lsx_vshuf_b(src1, src2, shuf2);
+    DUP4_ARG3(__lsx_vshuf_b, alpha, src0, shuf3, alpha, tmp0, shuf3, alpha,
+              tmp1, shuf3, alpha, tmp2, shuf3, dst0, dst1, dst2, dst3);
+    __lsx_vst(dst0, dst_argb, 0);
+    __lsx_vst(dst1, dst_argb, 16);
+    __lsx_vst(dst2, dst_argb, 32);
+    __lsx_vst(dst3, dst_argb, 48);
+    dst_argb += 64;
+    src_rgb24 += 48;
+  }
+}
+
+void RAWToARGBRow_LSX(const uint8_t* src_raw, uint8_t* dst_argb, int width) {
+  int x;
+  int len = width / 16;
+  __m128i src0, src1, src2;
+  __m128i tmp0, tmp1, tmp2;
+  __m128i dst0, dst1, dst2, dst3;
+  __m128i alpha = __lsx_vldi(0xFF);
+  __m128i shuf0 = {0x131211100F0E0D0C, 0x1B1A191817161514};
+  __m128i shuf1 = {0x1F1E1D1C1B1A1918, 0x0706050403020100};
+  __m128i shuf2 = {0x0B0A090807060504, 0x131211100F0E0D0C};
+  __m128i shuf3 = {0x1003040510000102, 0x10090A0B10060708};
+
+  for (x = 0; x < len; x++) {
+    src0 = __lsx_vld(src_raw, 0);
+    src1 = __lsx_vld(src_raw, 16);
+    src2 = __lsx_vld(src_raw, 32);
+    DUP2_ARG3(__lsx_vshuf_b, src1, src0, shuf0, src1, src2, shuf1, tmp0, tmp1);
+    tmp2 = __lsx_vshuf_b(src1, src2, shuf2);
+    DUP4_ARG3(__lsx_vshuf_b, alpha, src0, shuf3, alpha, tmp0, shuf3, alpha,
+              tmp1, shuf3, alpha, tmp2, shuf3, dst0, dst1, dst2, dst3);
+    __lsx_vst(dst0, dst_argb, 0);
+    __lsx_vst(dst1, dst_argb, 16);
+    __lsx_vst(dst2, dst_argb, 32);
+    __lsx_vst(dst3, dst_argb, 48);
+    dst_argb += 64;
+    src_raw += 48;
+  }
+}
+
+void ARGB1555ToYRow_LSX(const uint8_t* src_argb1555,
+                        uint8_t* dst_y,
+                        int width) {
+  int x;
+  int len = width / 16;
+  __m128i src0, src1;
+  __m128i tmp0, tmp1, tmpb, tmpg, tmpr;
+  __m128i reg0, reg1, reg2, dst0;
+  __m128i const_66 = __lsx_vldi(66);
+  __m128i const_129 = __lsx_vldi(129);
+  __m128i const_25 = __lsx_vldi(25);
+  __m128i const_1080 = {0x1080108010801080, 0x1080108010801080};
+
+  for (x = 0; x < len; x++) {
+    src0 = __lsx_vld(src_argb1555, 0);
+    src1 = __lsx_vld(src_argb1555, 16);
+    tmp0 = __lsx_vpickev_b(src1, src0);
+    tmp1 = __lsx_vpickod_b(src1, src0);
+    tmpb = __lsx_vandi_b(tmp0, 0x1F);
+    tmpg = __lsx_vsrli_b(tmp0, 5);
+    reg0 = __lsx_vandi_b(tmp1, 0x03);
+    reg0 = __lsx_vslli_b(reg0, 3);
+    tmpg = __lsx_vor_v(tmpg, reg0);
+    reg1 = __lsx_vandi_b(tmp1, 0x7C);
+    tmpr = __lsx_vsrli_b(reg1, 2);
+    reg0 = __lsx_vslli_b(tmpb, 3);
+    reg1 = __lsx_vslli_b(tmpg, 3);
+    reg2 = __lsx_vslli_b(tmpr, 3);
+    tmpb = __lsx_vsrli_b(tmpb, 2);
+    tmpg = __lsx_vsrli_b(tmpg, 2);
+    tmpr = __lsx_vsrli_b(tmpr, 2);
+    tmpb = __lsx_vor_v(reg0, tmpb);
+    tmpg = __lsx_vor_v(reg1, tmpg);
+    tmpr = __lsx_vor_v(reg2, tmpr);
+    reg0 = __lsx_vmaddwev_h_bu(const_1080, tmpb, const_25);
+    reg1 = __lsx_vmaddwod_h_bu(const_1080, tmpb, const_25);
+    reg0 = __lsx_vmaddwev_h_bu(reg0, tmpg, const_129);
+    reg1 = __lsx_vmaddwod_h_bu(reg1, tmpg, const_129);
+    reg0 = __lsx_vmaddwev_h_bu(reg0, tmpr, const_66);
+    reg1 = __lsx_vmaddwod_h_bu(reg1, tmpr, const_66);
+    dst0 = __lsx_vpackod_b(reg1, reg0);
+    __lsx_vst(dst0, dst_y, 0);
+    dst_y += 16;
+    src_argb1555 += 32;
+  }
+}
+
+void ARGB1555ToUVRow_LSX(const uint8_t* src_argb1555,
+                         int src_stride_argb1555,
+                         uint8_t* dst_u,
+                         uint8_t* dst_v,
+                         int width) {
+  int x;
+  int len = width / 16;
+  const uint8_t* next_argb1555 = src_argb1555 + src_stride_argb1555;
+  __m128i src0, src1, src2, src3;
+  __m128i tmp0, tmp1, tmp2, tmp3;
+  __m128i tmpb, tmpg, tmpr, nexb, nexg, nexr;
+  __m128i reg0, reg1, reg2, reg3, dst0;
+  __m128i const_112 = __lsx_vldi(0x438);
+  __m128i const_74 = __lsx_vldi(0x425);
+  __m128i const_38 = __lsx_vldi(0x413);
+  __m128i const_94 = __lsx_vldi(0x42F);
+  __m128i const_18 = __lsx_vldi(0x409);
+  __m128i const_8080 = {0x8080808080808080, 0x8080808080808080};
+
+  for (x = 0; x < len; x++) {
+    DUP4_ARG2(__lsx_vld, src_argb1555, 0, src_argb1555, 16, next_argb1555, 0,
+              next_argb1555, 16, src0, src1, src2, src3);
+    DUP2_ARG2(__lsx_vpickev_b, src1, src0, src3, src2, tmp0, tmp2);
+    DUP2_ARG2(__lsx_vpickod_b, src1, src0, src3, src2, tmp1, tmp3);
+    tmpb = __lsx_vandi_b(tmp0, 0x1F);
+    nexb = __lsx_vandi_b(tmp2, 0x1F);
+    tmpg = __lsx_vsrli_b(tmp0, 5);
+    nexg = __lsx_vsrli_b(tmp2, 5);
+    reg0 = __lsx_vandi_b(tmp1, 0x03);
+    reg2 = __lsx_vandi_b(tmp3, 0x03);
+    reg0 = __lsx_vslli_b(reg0, 3);
+    reg2 = __lsx_vslli_b(reg2, 3);
+    tmpg = __lsx_vor_v(tmpg, reg0);
+    nexg = __lsx_vor_v(nexg, reg2);
+    reg1 = __lsx_vandi_b(tmp1, 0x7C);
+    reg3 = __lsx_vandi_b(tmp3, 0x7C);
+    tmpr = __lsx_vsrli_b(reg1, 2);
+    nexr = __lsx_vsrli_b(reg3, 2);
+    reg0 = __lsx_vslli_b(tmpb, 3);
+    reg1 = __lsx_vslli_b(tmpg, 3);
+    reg2 = __lsx_vslli_b(tmpr, 3);
+    tmpb = __lsx_vsrli_b(tmpb, 2);
+    tmpg = __lsx_vsrli_b(tmpg, 2);
+    tmpr = __lsx_vsrli_b(tmpr, 2);
+    tmpb = __lsx_vor_v(reg0, tmpb);
+    tmpg = __lsx_vor_v(reg1, tmpg);
+    tmpr = __lsx_vor_v(reg2, tmpr);
+    reg0 = __lsx_vslli_b(nexb, 3);
+    reg1 = __lsx_vslli_b(nexg, 3);
+    reg2 = __lsx_vslli_b(nexr, 3);
+    nexb = __lsx_vsrli_b(nexb, 2);
+    nexg = __lsx_vsrli_b(nexg, 2);
+    nexr = __lsx_vsrli_b(nexr, 2);
+    nexb = __lsx_vor_v(reg0, nexb);
+    nexg = __lsx_vor_v(reg1, nexg);
+    nexr = __lsx_vor_v(reg2, nexr);
+    RGBTOUV(tmpb, tmpg, tmpr, nexb, nexg, nexr, dst0);
+    __lsx_vstelm_d(dst0, dst_u, 0, 0);
+    __lsx_vstelm_d(dst0, dst_v, 0, 1);
+    dst_u += 8;
+    dst_v += 8;
+    src_argb1555 += 32;
+    next_argb1555 += 32;
+  }
+}
+
+void RGB565ToYRow_LSX(const uint8_t* src_rgb565, uint8_t* dst_y, int width) {
+  int x;
+  int len = width / 16;
+  __m128i src0, src1;
+  __m128i tmp0, tmp1, tmpb, tmpg, tmpr;
+  __m128i reg0, reg1, dst0;
+  __m128i const_66 = __lsx_vldi(66);
+  __m128i const_129 = __lsx_vldi(129);
+  __m128i const_25 = __lsx_vldi(25);
+  __m128i const_1080 = {0x1080108010801080, 0x1080108010801080};
+
+  for (x = 0; x < len; x++) {
+    src0 = __lsx_vld(src_rgb565, 0);
+    src1 = __lsx_vld(src_rgb565, 16);
+    tmp0 = __lsx_vpickev_b(src1, src0);
+    tmp1 = __lsx_vpickod_b(src1, src0);
+    tmpb = __lsx_vandi_b(tmp0, 0x1F);
+    tmpr = __lsx_vandi_b(tmp1, 0xF8);
+    reg1 = __lsx_vandi_b(tmp1, 0x07);
+    reg0 = __lsx_vsrli_b(tmp0, 5);
+    reg1 = __lsx_vslli_b(reg1, 3);
+    tmpg = __lsx_vor_v(reg1, reg0);
+    reg0 = __lsx_vslli_b(tmpb, 3);
+    reg1 = __lsx_vsrli_b(tmpb, 2);
+    tmpb = __lsx_vor_v(reg1, reg0);
+    reg0 = __lsx_vslli_b(tmpg, 2);
+    reg1 = __lsx_vsrli_b(tmpg, 4);
+    tmpg = __lsx_vor_v(reg1, reg0);
+    reg0 = __lsx_vsrli_b(tmpr, 5);
+    tmpr = __lsx_vor_v(tmpr, reg0);
+    reg0 = __lsx_vmaddwev_h_bu(const_1080, tmpb, const_25);
+    reg1 = __lsx_vmaddwod_h_bu(const_1080, tmpb, const_25);
+    reg0 = __lsx_vmaddwev_h_bu(reg0, tmpg, const_129);
+    reg1 = __lsx_vmaddwod_h_bu(reg1, tmpg, const_129);
+    reg0 = __lsx_vmaddwev_h_bu(reg0, tmpr, const_66);
+    reg1 = __lsx_vmaddwod_h_bu(reg1, tmpr, const_66);
+    dst0 = __lsx_vpackod_b(reg1, reg0);
+    __lsx_vst(dst0, dst_y, 0);
+    dst_y += 16;
+    src_rgb565 += 32;
+  }
+}
+
+void RGB565ToUVRow_LSX(const uint8_t* src_rgb565,
+                       int src_stride_rgb565,
+                       uint8_t* dst_u,
+                       uint8_t* dst_v,
+                       int width) {
+  int x;
+  int len = width / 16;
+  const uint8_t* next_rgb565 = src_rgb565 + src_stride_rgb565;
+  __m128i src0, src1, src2, src3;
+  __m128i tmp0, tmp1, tmp2, tmp3;
+  __m128i tmpb, tmpg, tmpr, nexb, nexg, nexr;
+  __m128i reg0, reg1, reg2, reg3, dst0;
+  __m128i const_112 = __lsx_vldi(0x438);
+  __m128i const_74 = __lsx_vldi(0x425);
+  __m128i const_38 = __lsx_vldi(0x413);
+  __m128i const_94 = __lsx_vldi(0x42F);
+  __m128i const_18 = __lsx_vldi(0x409);
+  __m128i const_8080 = {0x8080808080808080, 0x8080808080808080};
+
+  for (x = 0; x < len; x++) {
+    DUP4_ARG2(__lsx_vld, src_rgb565, 0, src_rgb565, 16, next_rgb565, 0,
+              next_rgb565, 16, src0, src1, src2, src3);
+    DUP2_ARG2(__lsx_vpickev_b, src1, src0, src3, src2, tmp0, tmp2);
+    DUP2_ARG2(__lsx_vpickod_b, src1, src0, src3, src2, tmp1, tmp3);
+    tmpb = __lsx_vandi_b(tmp0, 0x1F);
+    tmpr = __lsx_vandi_b(tmp1, 0xF8);
+    nexb = __lsx_vandi_b(tmp2, 0x1F);
+    nexr = __lsx_vandi_b(tmp3, 0xF8);
+    reg1 = __lsx_vandi_b(tmp1, 0x07);
+    reg3 = __lsx_vandi_b(tmp3, 0x07);
+    reg0 = __lsx_vsrli_b(tmp0, 5);
+    reg1 = __lsx_vslli_b(reg1, 3);
+    reg2 = __lsx_vsrli_b(tmp2, 5);
+    reg3 = __lsx_vslli_b(reg3, 3);
+    tmpg = __lsx_vor_v(reg1, reg0);
+    nexg = __lsx_vor_v(reg2, reg3);
+    reg0 = __lsx_vslli_b(tmpb, 3);
+    reg1 = __lsx_vsrli_b(tmpb, 2);
+    reg2 = __lsx_vslli_b(nexb, 3);
+    reg3 = __lsx_vsrli_b(nexb, 2);
+    tmpb = __lsx_vor_v(reg1, reg0);
+    nexb = __lsx_vor_v(reg2, reg3);
+    reg0 = __lsx_vslli_b(tmpg, 2);
+    reg1 = __lsx_vsrli_b(tmpg, 4);
+    reg2 = __lsx_vslli_b(nexg, 2);
+    reg3 = __lsx_vsrli_b(nexg, 4);
+    tmpg = __lsx_vor_v(reg1, reg0);
+    nexg = __lsx_vor_v(reg2, reg3);
+    reg0 = __lsx_vsrli_b(tmpr, 5);
+    reg2 = __lsx_vsrli_b(nexr, 5);
+    tmpr = __lsx_vor_v(tmpr, reg0);
+    nexr = __lsx_vor_v(nexr, reg2);
+    RGBTOUV(tmpb, tmpg, tmpr, nexb, nexg, nexr, dst0);
+    __lsx_vstelm_d(dst0, dst_u, 0, 0);
+    __lsx_vstelm_d(dst0, dst_v, 0, 1);
+    dst_u += 8;
+    dst_v += 8;
+    src_rgb565 += 32;
+    next_rgb565 += 32;
+  }
+}
+
+void RGB24ToYRow_LSX(const uint8_t* src_rgb24, uint8_t* dst_y, int width) {
+  int x;
+  int len = width / 16;
+  __m128i src0, src1, src2;
+  __m128i tmp0, tmp1, tmp2, tmp3;
+  __m128i reg0, reg1, dst0;
+  __m128i const_129 = __lsx_vldi(129);
+  __m128i const_br = {0x4219421942194219, 0x4219421942194219};
+  __m128i const_1080 = {0x1080108010801080, 0x1080108010801080};
+  __m128i shuff0 = {0x0B09080605030200, 0x17151412110F0E0C};
+  __m128i shuff1 = {0x0301001E1D1B1A18, 0x0F0D0C0A09070604};
+  __m128i shuff2 = {0x000A000700040001, 0x001600130010000D};
+  __m128i shuff3 = {0x0002001F001C0019, 0x000E000B00080005};
+
+  for (x = 0; x < len; x++) {
+    src0 = __lsx_vld(src_rgb24, 0);
+    src1 = __lsx_vld(src_rgb24, 16);
+    src2 = __lsx_vld(src_rgb24, 32);
+    tmp0 = __lsx_vshuf_b(src1, src0, shuff0);
+    tmp1 = __lsx_vshuf_b(src1, src2, shuff1);
+    tmp2 = __lsx_vshuf_b(src1, src0, shuff2);
+    tmp3 = __lsx_vshuf_b(src1, src2, shuff3);
+    reg0 = __lsx_vmaddwev_h_bu(const_1080, tmp2, const_129);
+    reg1 = __lsx_vmaddwev_h_bu(const_1080, tmp3, const_129);
+    reg0 = __lsx_vdp2add_h_bu(reg0, const_br, tmp0);
+    reg1 = __lsx_vdp2add_h_bu(reg1, const_br, tmp1);
+    dst0 = __lsx_vpickod_b(reg1, reg0);
+    __lsx_vst(dst0, dst_y, 0);
+    dst_y += 16;
+    src_rgb24 += 48;
+  }
+}
+
+void RGB24ToUVRow_LSX(const uint8_t* src_rgb24,
+                      int src_stride_rgb24,
+                      uint8_t* dst_u,
+                      uint8_t* dst_v,
+                      int width) {
+  int x;
+  const uint8_t* next_rgb24 = src_rgb24 + src_stride_rgb24;
+  int len = width / 16;
+  __m128i src0, src1, src2;
+  __m128i nex0, nex1, nex2, dst0;
+  __m128i tmpb, tmpg, tmpr, nexb, nexg, nexr;
+  __m128i const_112 = __lsx_vldi(0x438);
+  __m128i const_74 = __lsx_vldi(0x425);
+  __m128i const_38 = __lsx_vldi(0x413);
+  __m128i const_94 = __lsx_vldi(0x42F);
+  __m128i const_18 = __lsx_vldi(0x409);
+  __m128i const_8080 = {0x8080808080808080, 0x8080808080808080};
+  __m128i shuff0_b = {0x15120F0C09060300, 0x00000000001E1B18};
+  __m128i shuff1_b = {0x0706050403020100, 0x1D1A1714110A0908};
+  __m128i shuff0_g = {0x1613100D0A070401, 0x00000000001F1C19};
+  __m128i shuff1_g = {0x0706050403020100, 0x1E1B1815120A0908};
+  __m128i shuff0_r = {0x1714110E0B080502, 0x0000000000001D1A};
+  __m128i shuff1_r = {0x0706050403020100, 0x1F1C191613100908};
+
+  for (x = 0; x < len; x++) {
+    src0 = __lsx_vld(src_rgb24, 0);
+    src1 = __lsx_vld(src_rgb24, 16);
+    src2 = __lsx_vld(src_rgb24, 32);
+    nex0 = __lsx_vld(next_rgb24, 0);
+    nex1 = __lsx_vld(next_rgb24, 16);
+    nex2 = __lsx_vld(next_rgb24, 32);
+    DUP2_ARG3(__lsx_vshuf_b, src1, src0, shuff0_b, nex1, nex0, shuff0_b, tmpb,
+              nexb);
+    DUP2_ARG3(__lsx_vshuf_b, src1, src0, shuff0_g, nex1, nex0, shuff0_g, tmpg,
+              nexg);
+    DUP2_ARG3(__lsx_vshuf_b, src1, src0, shuff0_r, nex1, nex0, shuff0_r, tmpr,
+              nexr);
+    DUP2_ARG3(__lsx_vshuf_b, src2, tmpb, shuff1_b, nex2, nexb, shuff1_b, tmpb,
+              nexb);
+    DUP2_ARG3(__lsx_vshuf_b, src2, tmpg, shuff1_g, nex2, nexg, shuff1_g, tmpg,
+              nexg);
+    DUP2_ARG3(__lsx_vshuf_b, src2, tmpr, shuff1_r, nex2, nexr, shuff1_r, tmpr,
+              nexr);
+    RGBTOUV(tmpb, tmpg, tmpr, nexb, nexg, nexr, dst0);
+    __lsx_vstelm_d(dst0, dst_u, 0, 0);
+    __lsx_vstelm_d(dst0, dst_v, 0, 1);
+    dst_u += 8;
+    dst_v += 8;
+    src_rgb24 += 48;
+    next_rgb24 += 48;
+  }
+}
+
+void RAWToYRow_LSX(const uint8_t* src_raw, uint8_t* dst_y, int width) {
+  int x;
+  int len = width / 16;
+  __m128i src0, src1, src2;
+  __m128i tmp0, tmp1, tmp2, tmp3;
+  __m128i reg0, reg1, dst0;
+  __m128i const_129 = __lsx_vldi(129);
+  __m128i const_br = {0x1942194219421942, 0x1942194219421942};
+  __m128i const_1080 = {0x1080108010801080, 0x1080108010801080};
+  __m128i shuff0 = {0x0B09080605030200, 0x17151412110F0E0C};
+  __m128i shuff1 = {0x0301001E1D1B1A18, 0x0F0D0C0A09070604};
+  __m128i shuff2 = {0x000A000700040001, 0x001600130010000D};
+  __m128i shuff3 = {0x0002001F001C0019, 0x000E000B00080005};
+
+  for (x = 0; x < len; x++) {
+    src0 = __lsx_vld(src_raw, 0);
+    src1 = __lsx_vld(src_raw, 16);
+    src2 = __lsx_vld(src_raw, 32);
+    tmp0 = __lsx_vshuf_b(src1, src0, shuff0);
+    tmp1 = __lsx_vshuf_b(src1, src2, shuff1);
+    tmp2 = __lsx_vshuf_b(src1, src0, shuff2);
+    tmp3 = __lsx_vshuf_b(src1, src2, shuff3);
+    reg0 = __lsx_vmaddwev_h_bu(const_1080, tmp2, const_129);
+    reg1 = __lsx_vmaddwev_h_bu(const_1080, tmp3, const_129);
+    reg0 = __lsx_vdp2add_h_bu(reg0, const_br, tmp0);
+    reg1 = __lsx_vdp2add_h_bu(reg1, const_br, tmp1);
+    dst0 = __lsx_vsrlni_b_h(reg1, reg0, 8);
+    __lsx_vst(dst0, dst_y, 0);
+    dst_y += 16;
+    src_raw += 48;
+  }
+}
+
+void RAWToUVRow_LSX(const uint8_t* src_raw,
+                    int src_stride_raw,
+                    uint8_t* dst_u,
+                    uint8_t* dst_v,
+                    int width) {
+  int x;
+  const uint8_t* next_raw = src_raw + src_stride_raw;
+  int len = width / 16;
+  __m128i src0, src1, src2;
+  __m128i nex0, nex1, nex2, dst0;
+  __m128i tmpb, tmpg, tmpr, nexb, nexg, nexr;
+  __m128i const_112 = __lsx_vldi(0x438);
+  __m128i const_74 = __lsx_vldi(0x425);
+  __m128i const_38 = __lsx_vldi(0x413);
+  __m128i const_94 = __lsx_vldi(0x42F);
+  __m128i const_18 = __lsx_vldi(0x409);
+  __m128i const_8080 = {0x8080808080808080, 0x8080808080808080};
+  __m128i shuff0_r = {0x15120F0C09060300, 0x00000000001E1B18};
+  __m128i shuff1_r = {0x0706050403020100, 0x1D1A1714110A0908};
+  __m128i shuff0_g = {0x1613100D0A070401, 0x00000000001F1C19};
+  __m128i shuff1_g = {0x0706050403020100, 0x1E1B1815120A0908};
+  __m128i shuff0_b = {0x1714110E0B080502, 0x0000000000001D1A};
+  __m128i shuff1_b = {0x0706050403020100, 0x1F1C191613100908};
+
+  for (x = 0; x < len; x++) {
+    src0 = __lsx_vld(src_raw, 0);
+    src1 = __lsx_vld(src_raw, 16);
+    src2 = __lsx_vld(src_raw, 32);
+    nex0 = __lsx_vld(next_raw, 0);
+    nex1 = __lsx_vld(next_raw, 16);
+    nex2 = __lsx_vld(next_raw, 32);
+    DUP2_ARG3(__lsx_vshuf_b, src1, src0, shuff0_b, nex1, nex0, shuff0_b, tmpb,
+              nexb);
+    DUP2_ARG3(__lsx_vshuf_b, src1, src0, shuff0_g, nex1, nex0, shuff0_g, tmpg,
+              nexg);
+    DUP2_ARG3(__lsx_vshuf_b, src1, src0, shuff0_r, nex1, nex0, shuff0_r, tmpr,
+              nexr);
+    DUP2_ARG3(__lsx_vshuf_b, src2, tmpb, shuff1_b, nex2, nexb, shuff1_b, tmpb,
+              nexb);
+    DUP2_ARG3(__lsx_vshuf_b, src2, tmpg, shuff1_g, nex2, nexg, shuff1_g, tmpg,
+              nexg);
+    DUP2_ARG3(__lsx_vshuf_b, src2, tmpr, shuff1_r, nex2, nexr, shuff1_r, tmpr,
+              nexr);
+    RGBTOUV(tmpb, tmpg, tmpr, nexb, nexg, nexr, dst0);
+    __lsx_vstelm_d(dst0, dst_u, 0, 0);
+    __lsx_vstelm_d(dst0, dst_v, 0, 1);
+    dst_u += 8;
+    dst_v += 8;
+    src_raw += 48;
+    next_raw += 48;
+  }
+}
+
+void NV12ToARGBRow_LSX(const uint8_t* src_y,
+                       const uint8_t* src_uv,
+                       uint8_t* dst_argb,
+                       const struct YuvConstants* yuvconstants,
+                       int width) {
+  int x;
+  int len = width / 8;
+  __m128i vec_y, vec_vu;
+  __m128i vec_vr, vec_ub, vec_vg, vec_ug, vec_yg, vec_yb;
+  __m128i vec_vrub, vec_vgug;
+  __m128i out_b, out_g, out_r;
+  __m128i const_80 = __lsx_vldi(0x480);
+  __m128i alpha = __lsx_vldi(0xFF);
+  __m128i zero = __lsx_vldi(0);
+
+  YUVTORGB_SETUP(yuvconstants, vec_vr, vec_ub, vec_vg, vec_ug, vec_yg, vec_yb);
+  vec_vrub = __lsx_vilvl_h(vec_vr, vec_ub);
+  vec_vgug = __lsx_vilvl_h(vec_vg, vec_ug);
+
+  for (x = 0; x < len; x++) {
+    vec_y = __lsx_vld(src_y, 0);
+    vec_vu = __lsx_vld(src_uv, 0);
+    YUVTORGB(vec_y, vec_vu, vec_vrub, vec_vgug, vec_yg, vec_yb, out_b, out_g,
+             out_r);
+    STOREARGB(alpha, out_r, out_g, out_b, dst_argb);
+    src_y += 8;
+    src_uv += 8;
+  }
+}
+
+void NV12ToRGB565Row_LSX(const uint8_t* src_y,
+                         const uint8_t* src_uv,
+                         uint8_t* dst_rgb565,
+                         const struct YuvConstants* yuvconstants,
+                         int width) {
+  int x;
+  int len = width / 8;
+  __m128i vec_y, vec_vu;
+  __m128i vec_vr, vec_ub, vec_vg, vec_ug, vec_yg, vec_yb;
+  __m128i vec_vrub, vec_vgug;
+  __m128i out_b, out_g, out_r;
+  __m128i const_80 = __lsx_vldi(0x480);
+  __m128i zero = __lsx_vldi(0);
+
+  YUVTORGB_SETUP(yuvconstants, vec_vr, vec_ub, vec_vg, vec_ug, vec_yg, vec_yb);
+  vec_vrub = __lsx_vilvl_h(vec_vr, vec_ub);
+  vec_vgug = __lsx_vilvl_h(vec_vg, vec_ug);
+
+  for (x = 0; x < len; x++) {
+    vec_y = __lsx_vld(src_y, 0);
+    vec_vu = __lsx_vld(src_uv, 0);
+    YUVTORGB(vec_y, vec_vu, vec_vrub, vec_vgug, vec_yg, vec_yb, out_b, out_g,
+             out_r);
+    out_b = __lsx_vsrli_h(out_b, 3);
+    out_g = __lsx_vsrli_h(out_g, 2);
+    out_r = __lsx_vsrli_h(out_r, 3);
+    out_g = __lsx_vslli_h(out_g, 5);
+    out_r = __lsx_vslli_h(out_r, 11);
+    out_r = __lsx_vor_v(out_r, out_g);
+    out_r = __lsx_vor_v(out_r, out_b);
+    __lsx_vst(out_r, dst_rgb565, 0);
+    src_y += 8;
+    src_uv += 8;
+    dst_rgb565 += 16;
+  }
+}
+
+void NV21ToARGBRow_LSX(const uint8_t* src_y,
+                       const uint8_t* src_vu,
+                       uint8_t* dst_argb,
+                       const struct YuvConstants* yuvconstants,
+                       int width) {
+  int x;
+  int len = width / 8;
+  __m128i vec_y, vec_uv;
+  __m128i vec_vr, vec_ub, vec_vg, vec_ug, vec_yg, vec_yb;
+  __m128i vec_ubvr, vec_ugvg;
+  __m128i out_b, out_g, out_r;
+  __m128i const_80 = __lsx_vldi(0x480);
+  __m128i alpha = __lsx_vldi(0xFF);
+  __m128i zero = __lsx_vldi(0);
+
+  YUVTORGB_SETUP(yuvconstants, vec_vr, vec_ub, vec_vg, vec_ug, vec_yg, vec_yb);
+  vec_ubvr = __lsx_vilvl_h(vec_ub, vec_vr);
+  vec_ugvg = __lsx_vilvl_h(vec_ug, vec_vg);
+
+  for (x = 0; x < len; x++) {
+    vec_y = __lsx_vld(src_y, 0);
+    vec_uv = __lsx_vld(src_vu, 0);
+    YUVTORGB(vec_y, vec_uv, vec_ubvr, vec_ugvg, vec_yg, vec_yb, out_r, out_g,
+             out_b);
+    STOREARGB(alpha, out_r, out_g, out_b, dst_argb);
+    src_y += 8;
+    src_vu += 8;
+  }
+}
+
+void SobelRow_LSX(const uint8_t* src_sobelx,
+                  const uint8_t* src_sobely,
+                  uint8_t* dst_argb,
+                  int width) {
+  int x;
+  int len = width / 16;
+  __m128i src0, src1, tmp0;
+  __m128i out0, out1, out2, out3;
+  __m128i alpha = __lsx_vldi(0xFF);
+  __m128i shuff0 = {0x1001010110000000, 0x1003030310020202};
+  __m128i shuff1 = __lsx_vaddi_bu(shuff0, 0x04);
+  __m128i shuff2 = __lsx_vaddi_bu(shuff1, 0x04);
+  __m128i shuff3 = __lsx_vaddi_bu(shuff2, 0x04);
+
+  for (x = 0; x < len; x++) {
+    src0 = __lsx_vld(src_sobelx, 0);
+    src1 = __lsx_vld(src_sobely, 0);
+    tmp0 = __lsx_vsadd_bu(src0, src1);
+    DUP4_ARG3(__lsx_vshuf_b, alpha, tmp0, shuff0, alpha, tmp0, shuff1, alpha,
+              tmp0, shuff2, alpha, tmp0, shuff3, out0, out1, out2, out3);
+    __lsx_vst(out0, dst_argb, 0);
+    __lsx_vst(out1, dst_argb, 16);
+    __lsx_vst(out2, dst_argb, 32);
+    __lsx_vst(out3, dst_argb, 48);
+    src_sobelx += 16;
+    src_sobely += 16;
+    dst_argb += 64;
+  }
+}
+
+void SobelToPlaneRow_LSX(const uint8_t* src_sobelx,
+                         const uint8_t* src_sobely,
+                         uint8_t* dst_y,
+                         int width) {
+  int x;
+  int len = width / 32;
+  __m128i src0, src1, src2, src3, dst0, dst1;
+
+  for (x = 0; x < len; x++) {
+    DUP2_ARG2(__lsx_vld, src_sobelx, 0, src_sobelx, 16, src0, src1);
+    DUP2_ARG2(__lsx_vld, src_sobely, 0, src_sobely, 16, src2, src3);
+    dst0 = __lsx_vsadd_bu(src0, src2);
+    dst1 = __lsx_vsadd_bu(src1, src3);
+    __lsx_vst(dst0, dst_y, 0);
+    __lsx_vst(dst1, dst_y, 16);
+    src_sobelx += 32;
+    src_sobely += 32;
+    dst_y += 32;
+  }
+}
+
+void SobelXYRow_LSX(const uint8_t* src_sobelx,
+                    const uint8_t* src_sobely,
+                    uint8_t* dst_argb,
+                    int width) {
+  int x;
+  int len = width / 16;
+  __m128i src_r, src_b, src_g;
+  __m128i tmp0, tmp1, tmp2, tmp3;
+  __m128i dst0, dst1, dst2, dst3;
+  __m128i alpha = __lsx_vldi(0xFF);
+
+  for (x = 0; x < len; x++) {
+    src_r = __lsx_vld(src_sobelx, 0);
+    src_b = __lsx_vld(src_sobely, 0);
+    src_g = __lsx_vsadd_bu(src_r, src_b);
+    tmp0 = __lsx_vilvl_b(src_g, src_b);
+    tmp1 = __lsx_vilvh_b(src_g, src_b);
+    tmp2 = __lsx_vilvl_b(alpha, src_r);
+    tmp3 = __lsx_vilvh_b(alpha, src_r);
+    dst0 = __lsx_vilvl_h(tmp2, tmp0);
+    dst1 = __lsx_vilvh_h(tmp2, tmp0);
+    dst2 = __lsx_vilvl_h(tmp3, tmp1);
+    dst3 = __lsx_vilvh_h(tmp3, tmp1);
+    __lsx_vst(dst0, dst_argb, 0);
+    __lsx_vst(dst1, dst_argb, 16);
+    __lsx_vst(dst2, dst_argb, 32);
+    __lsx_vst(dst3, dst_argb, 48);
+    src_sobelx += 16;
+    src_sobely += 16;
+    dst_argb += 64;
+  }
+}
+
+void ARGBToYJRow_LSX(const uint8_t* src_argb, uint8_t* dst_y, int width) {
+  int x;
+  int len = width / 16;
+  __m128i src0, src1, src2, src3, dst0;
+  __m128i tmp0, tmp1, tmp2, tmp3;
+  __m128i reg0, reg1;
+  __m128i const_128 = __lsx_vldi(0x480);
+  __m128i const_150 = __lsx_vldi(0x96);
+  __m128i const_br = {0x4D1D4D1D4D1D4D1D, 0x4D1D4D1D4D1D4D1D};
+
+  for (x = 0; x < len; x++) {
+    DUP4_ARG2(__lsx_vld, src_argb, 0, src_argb, 16, src_argb, 32, src_argb, 48,
+              src0, src1, src2, src3);
+    tmp0 = __lsx_vpickev_b(src1, src0);
+    tmp1 = __lsx_vpickod_b(src1, src0);
+    tmp2 = __lsx_vpickev_b(src3, src2);
+    tmp3 = __lsx_vpickod_b(src3, src2);
+    reg0 = __lsx_vmaddwev_h_bu(const_128, tmp1, const_150);
+    reg1 = __lsx_vmaddwev_h_bu(const_128, tmp3, const_150);
+    reg0 = __lsx_vdp2add_h_bu(reg0, const_br, tmp0);
+    reg1 = __lsx_vdp2add_h_bu(reg1, const_br, tmp2);
+    dst0 = __lsx_vpickod_b(reg1, reg0);
+    __lsx_vst(dst0, dst_y, 0);
+    dst_y += 16;
+    src_argb += 64;
+  }
+}
+
+void BGRAToYRow_LSX(const uint8_t* src_bgra, uint8_t* dst_y, int width) {
+  int x;
+  int len = width / 16;
+  __m128i src0, src1, src2, src3, dst0;
+  __m128i tmp0, tmp1, tmp2, tmp3;
+  __m128i reg0, reg1;
+  __m128i const_129 = __lsx_vldi(0x81);
+  __m128i const_br = {0x1942194219421942, 0x1942194219421942};
+  __m128i const_1080 = {0x1080108010801080, 0x1080108010801080};
+
+  for (x = 0; x < len; x++) {
+    DUP4_ARG2(__lsx_vld, src_bgra, 0, src_bgra, 16, src_bgra, 32, src_bgra, 48,
+              src0, src1, src2, src3);
+    tmp0 = __lsx_vpickod_b(src1, src0);
+    tmp1 = __lsx_vpickev_b(src1, src0);
+    tmp2 = __lsx_vpickod_b(src3, src2);
+    tmp3 = __lsx_vpickev_b(src3, src2);
+    reg0 = __lsx_vmaddwod_h_bu(const_1080, tmp1, const_129);
+    reg1 = __lsx_vmaddwod_h_bu(const_1080, tmp3, const_129);
+    reg0 = __lsx_vdp2add_h_bu(reg0, const_br, tmp0);
+    reg1 = __lsx_vdp2add_h_bu(reg1, const_br, tmp2);
+    dst0 = __lsx_vsrlni_b_h(reg1, reg0, 8);
+    __lsx_vst(dst0, dst_y, 0);
+    dst_y += 16;
+    src_bgra += 64;
+  }
+}
+
+void BGRAToUVRow_LSX(const uint8_t* src_bgra,
+                     int src_stride_bgra,
+                     uint8_t* dst_u,
+                     uint8_t* dst_v,
+                     int width) {
+  int x;
+  const uint8_t* next_bgra = src_bgra + src_stride_bgra;
+  int len = width / 16;
+  __m128i src0, src1, src2, src3;
+  __m128i nex0, nex1, nex2, nex3;
+  __m128i tmp0, tmp1, tmp2, tmp3, dst0;
+  __m128i tmpb, tmpg, tmpr, nexb, nexg, nexr;
+  __m128i const_112 = __lsx_vldi(0x438);
+  __m128i const_74 = __lsx_vldi(0x425);
+  __m128i const_38 = __lsx_vldi(0x413);
+  __m128i const_94 = __lsx_vldi(0x42F);
+  __m128i const_18 = __lsx_vldi(0x409);
+  __m128i const_8080 = {0x8080808080808080, 0x8080808080808080};
+
+  for (x = 0; x < len; x++) {
+    DUP4_ARG2(__lsx_vld, src_bgra, 0, src_bgra, 16, src_bgra, 32, src_bgra, 48,
+              src0, src1, src2, src3);
+    DUP4_ARG2(__lsx_vld, next_bgra, 0, next_bgra, 16, next_bgra, 32, next_bgra,
+              48, nex0, nex1, nex2, nex3);
+    tmp0 = __lsx_vpickod_b(src1, src0);
+    tmp1 = __lsx_vpickev_b(src1, src0);
+    tmp2 = __lsx_vpickod_b(src3, src2);
+    tmp3 = __lsx_vpickev_b(src3, src2);
+    tmpb = __lsx_vpickod_b(tmp2, tmp0);
+    tmpr = __lsx_vpickev_b(tmp2, tmp0);
+    tmpg = __lsx_vpickod_b(tmp3, tmp1);
+    tmp0 = __lsx_vpickod_b(nex1, nex0);
+    tmp1 = __lsx_vpickev_b(nex1, nex0);
+    tmp2 = __lsx_vpickod_b(nex3, nex2);
+    tmp3 = __lsx_vpickev_b(nex3, nex2);
+    nexb = __lsx_vpickod_b(tmp2, tmp0);
+    nexr = __lsx_vpickev_b(tmp2, tmp0);
+    nexg = __lsx_vpickod_b(tmp3, tmp1);
+    RGBTOUV(tmpb, tmpg, tmpr, nexb, nexg, nexr, dst0);
+    __lsx_vstelm_d(dst0, dst_u, 0, 0);
+    __lsx_vstelm_d(dst0, dst_v, 0, 1);
+    dst_u += 8;
+    dst_v += 8;
+    src_bgra += 64;
+    next_bgra += 64;
+  }
+}
+
+void ABGRToYRow_LSX(const uint8_t* src_abgr, uint8_t* dst_y, int width) {
+  int x;
+  int len = width / 16;
+  __m128i src0, src1, src2, src3, dst0;
+  __m128i tmp0, tmp1, tmp2, tmp3;
+  __m128i reg0, reg1;
+  __m128i const_129 = __lsx_vldi(0x81);
+  __m128i const_br = {0x1942194219421942, 0x1942194219421942};
+  __m128i const_1080 = {0x1080108010801080, 0x1080108010801080};
+
+  for (x = 0; x < len; x++) {
+    DUP4_ARG2(__lsx_vld, src_abgr, 0, src_abgr, 16, src_abgr, 32, src_abgr, 48,
+              src0, src1, src2, src3);
+    tmp0 = __lsx_vpickev_b(src1, src0);
+    tmp1 = __lsx_vpickod_b(src1, src0);
+    tmp2 = __lsx_vpickev_b(src3, src2);
+    tmp3 = __lsx_vpickod_b(src3, src2);
+    reg0 = __lsx_vmaddwev_h_bu(const_1080, tmp1, const_129);
+    reg1 = __lsx_vmaddwev_h_bu(const_1080, tmp3, const_129);
+    reg0 = __lsx_vdp2add_h_bu(reg0, const_br, tmp0);
+    reg1 = __lsx_vdp2add_h_bu(reg1, const_br, tmp2);
+    dst0 = __lsx_vsrlni_b_h(reg1, reg0, 8);
+    __lsx_vst(dst0, dst_y, 0);
+    dst_y += 16;
+    src_abgr += 64;
+  }
+}
+
+void ABGRToUVRow_LSX(const uint8_t* src_abgr,
+                     int src_stride_abgr,
+                     uint8_t* dst_u,
+                     uint8_t* dst_v,
+                     int width) {
+  int x;
+  const uint8_t* next_abgr = src_abgr + src_stride_abgr;
+  int len = width / 16;
+  __m128i src0, src1, src2, src3;
+  __m128i nex0, nex1, nex2, nex3;
+  __m128i tmp0, tmp1, tmp2, tmp3, dst0;
+  __m128i tmpb, tmpg, tmpr, nexb, nexg, nexr;
+  __m128i const_112 = __lsx_vldi(0x438);
+  __m128i const_74 = __lsx_vldi(0x425);
+  __m128i const_38 = __lsx_vldi(0x413);
+  __m128i const_94 = __lsx_vldi(0x42F);
+  __m128i const_18 = __lsx_vldi(0x409);
+  __m128i const_8080 = {0x8080808080808080, 0x8080808080808080};
+
+  for (x = 0; x < len; x++) {
+    DUP4_ARG2(__lsx_vld, src_abgr, 0, src_abgr, 16, src_abgr, 32, src_abgr, 48,
+              src0, src1, src2, src3);
+    DUP4_ARG2(__lsx_vld, next_abgr, 0, next_abgr, 16, next_abgr, 32, next_abgr,
+              48, nex0, nex1, nex2, nex3);
+    tmp0 = __lsx_vpickev_b(src1, src0);
+    tmp1 = __lsx_vpickod_b(src1, src0);
+    tmp2 = __lsx_vpickev_b(src3, src2);
+    tmp3 = __lsx_vpickod_b(src3, src2);
+    tmpb = __lsx_vpickod_b(tmp2, tmp0);
+    tmpr = __lsx_vpickev_b(tmp2, tmp0);
+    tmpg = __lsx_vpickev_b(tmp3, tmp1);
+    tmp0 = __lsx_vpickev_b(nex1, nex0);
+    tmp1 = __lsx_vpickod_b(nex1, nex0);
+    tmp2 = __lsx_vpickev_b(nex3, nex2);
+    tmp3 = __lsx_vpickod_b(nex3, nex2);
+    nexb = __lsx_vpickod_b(tmp2, tmp0);
+    nexr = __lsx_vpickev_b(tmp2, tmp0);
+    nexg = __lsx_vpickev_b(tmp3, tmp1);
+    RGBTOUV(tmpb, tmpg, tmpr, nexb, nexg, nexr, dst0);
+    __lsx_vstelm_d(dst0, dst_u, 0, 0);
+    __lsx_vstelm_d(dst0, dst_v, 0, 1);
+    dst_u += 8;
+    dst_v += 8;
+    src_abgr += 64;
+    next_abgr += 64;
+  }
+}
+
+void RGBAToYRow_LSX(const uint8_t* src_rgba, uint8_t* dst_y, int width) {
+  int x;
+  int len = width / 16;
+  __m128i src0, src1, src2, src3, dst0;
+  __m128i tmp0, tmp1, tmp2, tmp3;
+  __m128i reg0, reg1;
+  __m128i const_129 = __lsx_vldi(0x81);
+  __m128i const_br = {0x4219421942194219, 0x4219421942194219};
+  __m128i const_1080 = {0x1080108010801080, 0x1080108010801080};
+
+  for (x = 0; x < len; x++) {
+    DUP4_ARG2(__lsx_vld, src_rgba, 0, src_rgba, 16, src_rgba, 32, src_rgba, 48,
+              src0, src1, src2, src3);
+    tmp0 = __lsx_vpickod_b(src1, src0);
+    tmp1 = __lsx_vpickev_b(src1, src0);
+    tmp2 = __lsx_vpickod_b(src3, src2);
+    tmp3 = __lsx_vpickev_b(src3, src2);
+    reg0 = __lsx_vmaddwod_h_bu(const_1080, tmp1, const_129);
+    reg1 = __lsx_vmaddwod_h_bu(const_1080, tmp3, const_129);
+    reg0 = __lsx_vdp2add_h_bu(reg0, const_br, tmp0);
+    reg1 = __lsx_vdp2add_h_bu(reg1, const_br, tmp2);
+    dst0 = __lsx_vsrlni_b_h(reg1, reg0, 8);
+    __lsx_vst(dst0, dst_y, 0);
+    dst_y += 16;
+    src_rgba += 64;
+  }
+}
+
+void RGBAToUVRow_LSX(const uint8_t* src_rgba,
+                     int src_stride_rgba,
+                     uint8_t* dst_u,
+                     uint8_t* dst_v,
+                     int width) {
+  int x;
+  const uint8_t* next_rgba = src_rgba + src_stride_rgba;
+  int len = width / 16;
+  __m128i src0, src1, src2, src3;
+  __m128i nex0, nex1, nex2, nex3;
+  __m128i tmp0, tmp1, tmp2, tmp3, dst0;
+  __m128i tmpb, tmpg, tmpr, nexb, nexg, nexr;
+  __m128i const_112 = __lsx_vldi(0x438);
+  __m128i const_74 = __lsx_vldi(0x425);
+  __m128i const_38 = __lsx_vldi(0x413);
+  __m128i const_94 = __lsx_vldi(0x42F);
+  __m128i const_18 = __lsx_vldi(0x409);
+  __m128i const_8080 = {0x8080808080808080, 0x8080808080808080};
+
+  for (x = 0; x < len; x++) {
+    DUP4_ARG2(__lsx_vld, src_rgba, 0, src_rgba, 16, src_rgba, 32, src_rgba, 48,
+              src0, src1, src2, src3);
+    DUP4_ARG2(__lsx_vld, next_rgba, 0, next_rgba, 16, next_rgba, 32, next_rgba,
+              48, nex0, nex1, nex2, nex3);
+    tmp0 = __lsx_vpickod_b(src1, src0);
+    tmp1 = __lsx_vpickev_b(src1, src0);
+    tmp2 = __lsx_vpickod_b(src3, src2);
+    tmp3 = __lsx_vpickev_b(src3, src2);
+    tmpr = __lsx_vpickod_b(tmp2, tmp0);
+    tmpb = __lsx_vpickev_b(tmp2, tmp0);
+    tmpg = __lsx_vpickod_b(tmp3, tmp1);
+    tmp0 = __lsx_vpickod_b(nex1, nex0);
+    tmp1 = __lsx_vpickev_b(nex1, nex0);
+    tmp2 = __lsx_vpickod_b(nex3, nex2);
+    tmp3 = __lsx_vpickev_b(nex3, nex2);
+    nexr = __lsx_vpickod_b(tmp2, tmp0);
+    nexb = __lsx_vpickev_b(tmp2, tmp0);
+    nexg = __lsx_vpickod_b(tmp3, tmp1);
+    RGBTOUV(tmpb, tmpg, tmpr, nexb, nexg, nexr, dst0);
+    __lsx_vstelm_d(dst0, dst_u, 0, 0);
+    __lsx_vstelm_d(dst0, dst_v, 0, 1);
+    dst_u += 8;
+    dst_v += 8;
+    src_rgba += 64;
+    next_rgba += 64;
+  }
+}
+
+void ARGBToUVJRow_LSX(const uint8_t* src_argb,
+                      int src_stride_argb,
+                      uint8_t* dst_u,
+                      uint8_t* dst_v,
+                      int width) {
+  int x;
+  const uint8_t* next_argb = src_argb + src_stride_argb;
+  int len = width / 16;
+  __m128i src0, src1, src2, src3;
+  __m128i nex0, nex1, nex2, nex3;
+  __m128i tmp0, tmp1, tmp2, tmp3;
+  __m128i reg0, reg1, dst0;
+  __m128i tmpb, tmpg, tmpr, nexb, nexg, nexr;
+  __m128i const_63 = __lsx_vldi(0x43F);
+  __m128i const_42 = __lsx_vldi(0x42A);
+  __m128i const_21 = __lsx_vldi(0x415);
+  __m128i const_53 = __lsx_vldi(0x435);
+  __m128i const_10 = __lsx_vldi(0x40A);
+  __m128i const_8080 = {0x8080808080808080, 0x8080808080808080};
+
+  for (x = 0; x < len; x++) {
+    DUP4_ARG2(__lsx_vld, src_argb, 0, src_argb, 16, src_argb, 32, src_argb, 48,
+              src0, src1, src2, src3);
+    DUP4_ARG2(__lsx_vld, next_argb, 0, next_argb, 16, next_argb, 32, next_argb,
+              48, nex0, nex1, nex2, nex3);
+    tmp0 = __lsx_vpickev_b(src1, src0);
+    tmp1 = __lsx_vpickod_b(src1, src0);
+    tmp2 = __lsx_vpickev_b(src3, src2);
+    tmp3 = __lsx_vpickod_b(src3, src2);
+    tmpr = __lsx_vpickod_b(tmp2, tmp0);
+    tmpb = __lsx_vpickev_b(tmp2, tmp0);
+    tmpg = __lsx_vpickev_b(tmp3, tmp1);
+    tmp0 = __lsx_vpickev_b(nex1, nex0);
+    tmp1 = __lsx_vpickod_b(nex1, nex0);
+    tmp2 = __lsx_vpickev_b(nex3, nex2);
+    tmp3 = __lsx_vpickod_b(nex3, nex2);
+    nexr = __lsx_vpickod_b(tmp2, tmp0);
+    nexb = __lsx_vpickev_b(tmp2, tmp0);
+    nexg = __lsx_vpickev_b(tmp3, tmp1);
+    tmp0 = __lsx_vaddwev_h_bu(tmpb, nexb);
+    tmp1 = __lsx_vaddwod_h_bu(tmpb, nexb);
+    tmp2 = __lsx_vaddwev_h_bu(tmpg, nexg);
+    tmp3 = __lsx_vaddwod_h_bu(tmpg, nexg);
+    reg0 = __lsx_vaddwev_h_bu(tmpr, nexr);
+    reg1 = __lsx_vaddwod_h_bu(tmpr, nexr);
+    tmpb = __lsx_vavgr_hu(tmp0, tmp1);
+    tmpg = __lsx_vavgr_hu(tmp2, tmp3);
+    tmpr = __lsx_vavgr_hu(reg0, reg1);
+    reg0 = __lsx_vmadd_h(const_8080, const_63, tmpb);
+    reg1 = __lsx_vmadd_h(const_8080, const_63, tmpr);
+    reg0 = __lsx_vmsub_h(reg0, const_42, tmpg);
+    reg1 = __lsx_vmsub_h(reg1, const_53, tmpg);
+    reg0 = __lsx_vmsub_h(reg0, const_21, tmpr);
+    reg1 = __lsx_vmsub_h(reg1, const_10, tmpb);
+    dst0 = __lsx_vpickod_b(reg1, reg0);
+    __lsx_vstelm_d(dst0, dst_u, 0, 0);
+    __lsx_vstelm_d(dst0, dst_v, 0, 1);
+    dst_u += 8;
+    dst_v += 8;
+    src_argb += 64;
+    next_argb += 64;
+  }
+}
+
+void I444ToARGBRow_LSX(const uint8_t* src_y,
+                       const uint8_t* src_u,
+                       const uint8_t* src_v,
+                       uint8_t* dst_argb,
+                       const struct YuvConstants* yuvconstants,
+                       int width) {
+  int x;
+  int len = width / 16;
+  __m128i vec_y, vec_u, vec_v, out_b, out_g, out_r;
+  __m128i vec_yl, vec_yh, vec_ul, vec_vl, vec_uh, vec_vh;
+  __m128i vec_vr, vec_ub, vec_vg, vec_ug, vec_yg, vec_yb, vec_ugvg;
+  __m128i const_80 = __lsx_vldi(0x480);
+  __m128i alpha = __lsx_vldi(0xFF);
+  __m128i zero = __lsx_vldi(0);
+
+  YUVTORGB_SETUP(yuvconstants, vec_vr, vec_ub, vec_vg, vec_ug, vec_yg, vec_yb);
+  vec_ugvg = __lsx_vilvl_h(vec_ug, vec_vg);
+
+  for (x = 0; x < len; x++) {
+    vec_y = __lsx_vld(src_y, 0);
+    vec_u = __lsx_vld(src_u, 0);
+    vec_v = __lsx_vld(src_v, 0);
+    vec_yl = __lsx_vilvl_b(vec_y, vec_y);
+    vec_ul = __lsx_vilvl_b(zero, vec_u);
+    vec_vl = __lsx_vilvl_b(zero, vec_v);
+    I444TORGB(vec_yl, vec_ul, vec_vl, vec_ub, vec_vr, vec_ugvg, vec_yg, vec_yb,
+              out_b, out_g, out_r);
+    STOREARGB(alpha, out_r, out_g, out_b, dst_argb);
+    vec_yh = __lsx_vilvh_b(vec_y, vec_y);
+    vec_uh = __lsx_vilvh_b(zero, vec_u);
+    vec_vh = __lsx_vilvh_b(zero, vec_v);
+    I444TORGB(vec_yh, vec_uh, vec_vh, vec_ub, vec_vr, vec_ugvg, vec_yg, vec_yb,
+              out_b, out_g, out_r);
+    STOREARGB(alpha, out_r, out_g, out_b, dst_argb);
+    src_y += 16;
+    src_u += 16;
+    src_v += 16;
+  }
+}
+
+void I400ToARGBRow_LSX(const uint8_t* src_y,
+                       uint8_t* dst_argb,
+                       const struct YuvConstants* yuvconstants,
+                       int width) {
+  int x;
+  int len = width / 16;
+  __m128i vec_y, vec_yl, vec_yh, out0;
+  __m128i y_ev, y_od, dst0, dst1, dst2, dst3;
+  __m128i temp0, temp1;
+  __m128i alpha = __lsx_vldi(0xFF);
+  __m128i vec_yg = __lsx_vreplgr2vr_h(yuvconstants->kYToRgb[0]);
+  __m128i vec_yb = __lsx_vreplgr2vr_w(yuvconstants->kYBiasToRgb[0]);
+
+  for (x = 0; x < len; x++) {
+    vec_y = __lsx_vld(src_y, 0);
+    vec_yl = __lsx_vilvl_b(vec_y, vec_y);
+    y_ev = __lsx_vmulwev_w_hu_h(vec_yl, vec_yg);
+    y_od = __lsx_vmulwod_w_hu_h(vec_yl, vec_yg);
+    y_ev = __lsx_vsrai_w(y_ev, 16);
+    y_od = __lsx_vsrai_w(y_od, 16);
+    y_ev = __lsx_vadd_w(y_ev, vec_yb);
+    y_od = __lsx_vadd_w(y_od, vec_yb);
+    y_ev = __lsx_vsrai_w(y_ev, 6);
+    y_od = __lsx_vsrai_w(y_od, 6);
+    y_ev = __lsx_vclip255_w(y_ev);
+    y_od = __lsx_vclip255_w(y_od);
+    out0 = __lsx_vpackev_h(y_od, y_ev);
+    temp0 = __lsx_vpackev_b(out0, out0);
+    temp1 = __lsx_vpackev_b(alpha, out0);
+    dst0 = __lsx_vilvl_h(temp1, temp0);
+    dst1 = __lsx_vilvh_h(temp1, temp0);
+    vec_yh = __lsx_vilvh_b(vec_y, vec_y);
+    y_ev = __lsx_vmulwev_w_hu_h(vec_yh, vec_yg);
+    y_od = __lsx_vmulwod_w_hu_h(vec_yh, vec_yg);
+    y_ev = __lsx_vsrai_w(y_ev, 16);
+    y_od = __lsx_vsrai_w(y_od, 16);
+    y_ev = __lsx_vadd_w(y_ev, vec_yb);
+    y_od = __lsx_vadd_w(y_od, vec_yb);
+    y_ev = __lsx_vsrai_w(y_ev, 6);
+    y_od = __lsx_vsrai_w(y_od, 6);
+    y_ev = __lsx_vclip255_w(y_ev);
+    y_od = __lsx_vclip255_w(y_od);
+    out0 = __lsx_vpackev_h(y_od, y_ev);
+    temp0 = __lsx_vpackev_b(out0, out0);
+    temp1 = __lsx_vpackev_b(alpha, out0);
+    dst2 = __lsx_vilvl_h(temp1, temp0);
+    dst3 = __lsx_vilvh_h(temp1, temp0);
+    __lsx_vst(dst0, dst_argb, 0);
+    __lsx_vst(dst1, dst_argb, 16);
+    __lsx_vst(dst2, dst_argb, 32);
+    __lsx_vst(dst3, dst_argb, 48);
+    dst_argb += 64;
+    src_y += 16;
+  }
+}
+
+void J400ToARGBRow_LSX(const uint8_t* src_y, uint8_t* dst_argb, int width) {
+  int x;
+  int len = width / 16;
+  __m128i vec_y, dst0, dst1, dst2, dst3;
+  __m128i tmp0, tmp1, tmp2, tmp3;
+  __m128i alpha = __lsx_vldi(0xFF);
+
+  for (x = 0; x < len; x++) {
+    vec_y = __lsx_vld(src_y, 0);
+    tmp0 = __lsx_vilvl_b(vec_y, vec_y);
+    tmp1 = __lsx_vilvh_b(vec_y, vec_y);
+    tmp2 = __lsx_vilvl_b(alpha, vec_y);
+    tmp3 = __lsx_vilvh_b(alpha, vec_y);
+    dst0 = __lsx_vilvl_h(tmp2, tmp0);
+    dst1 = __lsx_vilvh_h(tmp2, tmp0);
+    dst2 = __lsx_vilvl_h(tmp3, tmp1);
+    dst3 = __lsx_vilvh_h(tmp3, tmp1);
+    __lsx_vst(dst0, dst_argb, 0);
+    __lsx_vst(dst1, dst_argb, 16);
+    __lsx_vst(dst2, dst_argb, 32);
+    __lsx_vst(dst3, dst_argb, 48);
+    dst_argb += 64;
+    src_y += 16;
+  }
+}
+
+void YUY2ToARGBRow_LSX(const uint8_t* src_yuy2,
+                       uint8_t* dst_argb,
+                       const struct YuvConstants* yuvconstants,
+                       int width) {
+  int x;
+  int len = width / 8;
+  __m128i src0, vec_y, vec_vu;
+  __m128i vec_vr, vec_ub, vec_vg, vec_ug, vec_yg, vec_yb;
+  __m128i vec_vrub, vec_vgug;
+  __m128i out_b, out_g, out_r;
+  __m128i const_80 = __lsx_vldi(0x480);
+  __m128i zero = __lsx_vldi(0);
+  __m128i alpha = __lsx_vldi(0xFF);
+
+  YUVTORGB_SETUP(yuvconstants, vec_vr, vec_ub, vec_vg, vec_ug, vec_yg, vec_yb);
+  vec_vrub = __lsx_vilvl_h(vec_vr, vec_ub);
+  vec_vgug = __lsx_vilvl_h(vec_vg, vec_ug);
+
+  for (x = 0; x < len; x++) {
+    src0 = __lsx_vld(src_yuy2, 0);
+    vec_y = __lsx_vpickev_b(src0, src0);
+    vec_vu = __lsx_vpickod_b(src0, src0);
+    YUVTORGB(vec_y, vec_vu, vec_vrub, vec_vgug, vec_yg, vec_yb, out_b, out_g,
+             out_r);
+    STOREARGB(alpha, out_r, out_g, out_b, dst_argb);
+    src_yuy2 += 16;
+  }
+}
+
+void UYVYToARGBRow_LSX(const uint8_t* src_uyvy,
+                       uint8_t* dst_argb,
+                       const struct YuvConstants* yuvconstants,
+                       int width) {
+  int x;
+  int len = width / 8;
+  __m128i src0, vec_y, vec_vu;
+  __m128i vec_vr, vec_ub, vec_vg, vec_ug, vec_yg, vec_yb;
+  __m128i vec_vrub, vec_vgug;
+  __m128i out_b, out_g, out_r;
+  __m128i const_80 = __lsx_vldi(0x480);
+  __m128i zero = __lsx_vldi(0);
+  __m128i alpha = __lsx_vldi(0xFF);
+
+  YUVTORGB_SETUP(yuvconstants, vec_vr, vec_ub, vec_vg, vec_ug, vec_yg, vec_yb);
+  vec_vrub = __lsx_vilvl_h(vec_vr, vec_ub);
+  vec_vgug = __lsx_vilvl_h(vec_vg, vec_ug);
+
+  for (x = 0; x < len; x++) {
+    src0 = __lsx_vld(src_uyvy, 0);
+    vec_y = __lsx_vpickod_b(src0, src0);
+    vec_vu = __lsx_vpickev_b(src0, src0);
+    YUVTORGB(vec_y, vec_vu, vec_vrub, vec_vgug, vec_yg, vec_yb, out_b, out_g,
+             out_r);
+    STOREARGB(alpha, out_r, out_g, out_b, dst_argb);
+    src_uyvy += 16;
+  }
+}
+
+void InterpolateRow_LSX(uint8_t* dst_ptr,
+                        const uint8_t* src_ptr,
+                        ptrdiff_t src_stride,
+                        int width,
+                        int32_t source_y_fraction) {
+  int x;
+  int y1_fraction = source_y_fraction;
+  int y0_fraction = 256 - y1_fraction;
+  const uint8_t* nex_ptr = src_ptr + src_stride;
+  uint16_t y_fractions;
+  int len = width / 32;
+  __m128i src0, src1, nex0, nex1;
+  __m128i dst0, dst1, y_frac;
+  __m128i tmp0, tmp1, tmp2, tmp3;
+  __m128i const_128 = __lsx_vldi(0x480);
+
+  if (y1_fraction == 0) {
+    for (x = 0; x < len; x++) {
+      DUP2_ARG2(__lsx_vld, src_ptr, 0, src_ptr, 16, src0, src1);
+      __lsx_vst(src0, dst_ptr, 0);
+      __lsx_vst(src1, dst_ptr, 16);
+      src_ptr += 32;
+      dst_ptr += 32;
+    }
+    return;
+  }
+
+  if (y1_fraction == 128) {
+    for (x = 0; x < len; x++) {
+      DUP2_ARG2(__lsx_vld, src_ptr, 0, src_ptr, 16, src0, src1);
+      DUP2_ARG2(__lsx_vld, nex_ptr, 0, nex_ptr, 16, nex0, nex1);
+      dst0 = __lsx_vavgr_bu(src0, nex0);
+      dst1 = __lsx_vavgr_bu(src1, nex1);
+      __lsx_vst(dst0, dst_ptr, 0);
+      __lsx_vst(dst1, dst_ptr, 16);
+      src_ptr += 32;
+      nex_ptr += 32;
+      dst_ptr += 32;
+    }
+    return;
+  }
+
+  y_fractions = (uint16_t)(y0_fraction + (y1_fraction << 8));
+  y_frac = __lsx_vreplgr2vr_h(y_fractions);
+
+  for (x = 0; x < len; x++) {
+    DUP2_ARG2(__lsx_vld, src_ptr, 0, src_ptr, 16, src0, src1);
+    DUP2_ARG2(__lsx_vld, nex_ptr, 0, nex_ptr, 16, nex0, nex1);
+    tmp0 = __lsx_vilvl_b(nex0, src0);
+    tmp1 = __lsx_vilvh_b(nex0, src0);
+    tmp2 = __lsx_vilvl_b(nex1, src1);
+    tmp3 = __lsx_vilvh_b(nex1, src1);
+    tmp0 = __lsx_vdp2add_h_bu(const_128, tmp0, y_frac);
+    tmp1 = __lsx_vdp2add_h_bu(const_128, tmp1, y_frac);
+    tmp2 = __lsx_vdp2add_h_bu(const_128, tmp2, y_frac);
+    tmp3 = __lsx_vdp2add_h_bu(const_128, tmp3, y_frac);
+    dst0 = __lsx_vsrlni_b_h(tmp1, tmp0, 8);
+    dst1 = __lsx_vsrlni_b_h(tmp3, tmp2, 8);
+    __lsx_vst(dst0, dst_ptr, 0);
+    __lsx_vst(dst1, dst_ptr, 16);
+    src_ptr += 32;
+    nex_ptr += 32;
+    dst_ptr += 32;
+  }
+}
+
+void ARGBSetRow_LSX(uint8_t* dst_argb, uint32_t v32, int width) {
+  int x;
+  int len = width / 4;
+  __m128i dst0 = __lsx_vreplgr2vr_w(v32);
+
+  for (x = 0; x < len; x++) {
+    __lsx_vst(dst0, dst_argb, 0);
+    dst_argb += 16;
+  }
+}
+
+void RAWToRGB24Row_LSX(const uint8_t* src_raw, uint8_t* dst_rgb24, int width) {
+  int x;
+  int len = width / 16;
+  __m128i src0, src1, src2;
+  __m128i dst0, dst1, dst2;
+  __m128i shuf0 = {0x0708030405000102, 0x110C0D0E090A0B06};
+  __m128i shuf1 = {0x1516171213140F10, 0x1F1E1B1C1D18191A};
+  __m128i shuf2 = {0x090405060102031E, 0x0D0E0F0A0B0C0708};
+
+  for (x = 0; x < len; x++) {
+    DUP2_ARG2(__lsx_vld, src_raw, 0, src_raw, 16, src0, src1);
+    src2 = __lsx_vld(src_raw, 32);
+    DUP2_ARG3(__lsx_vshuf_b, src1, src0, shuf0, src1, src0, shuf1, dst0, dst1);
+    dst2 = __lsx_vshuf_b(src1, src2, shuf2);
+    dst1 = __lsx_vinsgr2vr_b(dst1, src_raw[32], 0x0E);
+    __lsx_vst(dst0, dst_rgb24, 0);
+    __lsx_vst(dst1, dst_rgb24, 16);
+    __lsx_vst(dst2, dst_rgb24, 32);
+    dst_rgb24 += 48;
+    src_raw += 48;
+  }
+}
+
+void MergeUVRow_LSX(const uint8_t* src_u,
+                    const uint8_t* src_v,
+                    uint8_t* dst_uv,
+                    int width) {
+  int x;
+  int len = width / 16;
+  __m128i src0, src1, dst0, dst1;
+
+  for (x = 0; x < len; x++) {
+    DUP2_ARG2(__lsx_vld, src_u, 0, src_v, 0, src0, src1);
+    dst0 = __lsx_vilvl_b(src1, src0);
+    dst1 = __lsx_vilvh_b(src1, src0);
+    __lsx_vst(dst0, dst_uv, 0);
+    __lsx_vst(dst1, dst_uv, 16);
+    src_u += 16;
+    src_v += 16;
+    dst_uv += 32;
+  }
+}
+
+void ARGBExtractAlphaRow_LSX(const uint8_t* src_argb,
+                             uint8_t* dst_a,
+                             int width) {
+  int x;
+  int len = width / 16;
+  __m128i src0, src1, src2, src3, tmp0, tmp1, dst0;
+
+  for (x = 0; x < len; x++) {
+    DUP4_ARG2(__lsx_vld, src_argb, 0, src_argb, 16, src_argb, 32, src_argb, 48,
+              src0, src1, src2, src3);
+    tmp0 = __lsx_vpickod_b(src1, src0);
+    tmp1 = __lsx_vpickod_b(src3, src2);
+    dst0 = __lsx_vpickod_b(tmp1, tmp0);
+    __lsx_vst(dst0, dst_a, 0);
+    src_argb += 64;
+    dst_a += 16;
+  }
+}
+
+void ARGBBlendRow_LSX(const uint8_t* src_argb,
+                      const uint8_t* src_argb1,
+                      uint8_t* dst_argb,
+                      int width) {
+  int x;
+  int len = width / 8;
+  __m128i src0, src1, src2, src3;
+  __m128i tmp0, tmp1, dst0, dst1;
+  __m128i reg0, reg1, reg2, reg3;
+  __m128i a0, a1, a2, a3;
+  __m128i const_256 = __lsx_vldi(0x500);
+  __m128i zero = __lsx_vldi(0);
+  __m128i alpha = __lsx_vldi(0xFF);
+  __m128i control = {0xFF000000FF000000, 0xFF000000FF000000};
+
+  for (x = 0; x < len; x++) {
+    DUP4_ARG2(__lsx_vld, src_argb, 0, src_argb, 16, src_argb1, 0, src_argb1, 16,
+              src0, src1, src2, src3);
+    tmp0 = __lsx_vshuf4i_b(src0, 0xFF);
+    tmp1 = __lsx_vshuf4i_b(src1, 0xFF);
+    a0 = __lsx_vilvl_b(zero, tmp0);
+    a1 = __lsx_vilvh_b(zero, tmp0);
+    a2 = __lsx_vilvl_b(zero, tmp1);
+    a3 = __lsx_vilvh_b(zero, tmp1);
+    reg0 = __lsx_vilvl_b(zero, src2);
+    reg1 = __lsx_vilvh_b(zero, src2);
+    reg2 = __lsx_vilvl_b(zero, src3);
+    reg3 = __lsx_vilvh_b(zero, src3);
+    DUP4_ARG2(__lsx_vsub_h, const_256, a0, const_256, a1, const_256, a2,
+              const_256, a3, a0, a1, a2, a3);
+    DUP4_ARG2(__lsx_vmul_h, a0, reg0, a1, reg1, a2, reg2, a3, reg3, reg0, reg1,
+              reg2, reg3);
+    DUP2_ARG3(__lsx_vsrani_b_h, reg1, reg0, 8, reg3, reg2, 8, dst0, dst1);
+    dst0 = __lsx_vsadd_bu(dst0, src0);
+    dst1 = __lsx_vsadd_bu(dst1, src1);
+    dst0 = __lsx_vbitsel_v(dst0, alpha, control);
+    dst1 = __lsx_vbitsel_v(dst1, alpha, control);
+    __lsx_vst(dst0, dst_argb, 0);
+    __lsx_vst(dst1, dst_argb, 16);
+    src_argb += 32;
+    src_argb1 += 32;
+    dst_argb += 32;
+  }
+}
+
+void ARGBQuantizeRow_LSX(uint8_t* dst_argb,
+                         int scale,
+                         int interval_size,
+                         int interval_offset,
+                         int width) {
+  int x;
+  int len = width / 16;
+  __m128i src0, src1, src2, src3, dst0, dst1, dst2, dst3;
+  __m128i tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
+  __m128i reg0, reg1, reg2, reg3, reg4, reg5, reg6, reg7;
+  __m128i vec_size = __lsx_vreplgr2vr_b(interval_size);
+  __m128i vec_offset = __lsx_vreplgr2vr_b(interval_offset);
+  __m128i vec_scale = __lsx_vreplgr2vr_w(scale);
+  __m128i zero = __lsx_vldi(0);
+  __m128i control = {0xFF000000FF000000, 0xFF000000FF000000};
+
+  for (x = 0; x < len; x++) {
+    DUP4_ARG2(__lsx_vld, dst_argb, 0, dst_argb, 16, dst_argb, 32, dst_argb, 48,
+              src0, src1, src2, src3);
+    reg0 = __lsx_vilvl_b(zero, src0);
+    reg1 = __lsx_vilvh_b(zero, src0);
+    reg2 = __lsx_vilvl_b(zero, src1);
+    reg3 = __lsx_vilvh_b(zero, src1);
+    reg4 = __lsx_vilvl_b(zero, src2);
+    reg5 = __lsx_vilvh_b(zero, src2);
+    reg6 = __lsx_vilvl_b(zero, src3);
+    reg7 = __lsx_vilvh_b(zero, src3);
+    tmp0 = __lsx_vilvl_h(zero, reg0);
+    tmp1 = __lsx_vilvh_h(zero, reg0);
+    tmp2 = __lsx_vilvl_h(zero, reg1);
+    tmp3 = __lsx_vilvh_h(zero, reg1);
+    tmp4 = __lsx_vilvl_h(zero, reg2);
+    tmp5 = __lsx_vilvh_h(zero, reg2);
+    tmp6 = __lsx_vilvl_h(zero, reg3);
+    tmp7 = __lsx_vilvh_h(zero, reg3);
+    DUP4_ARG2(__lsx_vmul_w, tmp0, vec_scale, tmp1, vec_scale, tmp2, vec_scale,
+              tmp3, vec_scale, tmp0, tmp1, tmp2, tmp3);
+    DUP4_ARG2(__lsx_vmul_w, tmp4, vec_scale, tmp5, vec_scale, tmp6, vec_scale,
+              tmp7, vec_scale, tmp4, tmp5, tmp6, tmp7);
+    DUP4_ARG3(__lsx_vsrani_h_w, tmp1, tmp0, 16, tmp3, tmp2, 16, tmp5, tmp4, 16,
+              tmp7, tmp6, 16, reg0, reg1, reg2, reg3);
+    dst0 = __lsx_vpickev_b(reg1, reg0);
+    dst1 = __lsx_vpickev_b(reg3, reg2);
+    tmp0 = __lsx_vilvl_h(zero, reg4);
+    tmp1 = __lsx_vilvh_h(zero, reg4);
+    tmp2 = __lsx_vilvl_h(zero, reg5);
+    tmp3 = __lsx_vilvh_h(zero, reg5);
+    tmp4 = __lsx_vilvl_h(zero, reg6);
+    tmp5 = __lsx_vilvh_h(zero, reg6);
+    tmp6 = __lsx_vilvl_h(zero, reg7);
+    tmp7 = __lsx_vilvh_h(zero, reg7);
+    DUP4_ARG2(__lsx_vmul_w, tmp0, vec_scale, tmp1, vec_scale, tmp2, vec_scale,
+              tmp3, vec_scale, tmp0, tmp1, tmp2, tmp3);
+    DUP4_ARG2(__lsx_vmul_w, tmp4, vec_scale, tmp5, vec_scale, tmp6, vec_scale,
+              tmp7, vec_scale, tmp4, tmp5, tmp6, tmp7);
+    DUP4_ARG3(__lsx_vsrani_h_w, tmp1, tmp0, 16, tmp3, tmp2, 16, tmp5, tmp4, 16,
+              tmp7, tmp6, 16, reg0, reg1, reg2, reg3);
+    dst2 = __lsx_vpickev_b(reg1, reg0);
+    dst3 = __lsx_vpickev_b(reg3, reg2);
+    DUP4_ARG2(__lsx_vmul_b, dst0, vec_size, dst1, vec_size, dst2, vec_size,
+              dst3, vec_size, dst0, dst1, dst2, dst3);
+    DUP4_ARG2(__lsx_vadd_b, dst0, vec_offset, dst1, vec_offset, dst2,
+              vec_offset, dst3, vec_offset, dst0, dst1, dst2, dst3);
+    DUP4_ARG3(__lsx_vbitsel_v, dst0, src0, control, dst1, src1, control, dst2,
+              src2, control, dst3, src3, control, dst0, dst1, dst2, dst3);
+    __lsx_vst(dst0, dst_argb, 0);
+    __lsx_vst(dst1, dst_argb, 16);
+    __lsx_vst(dst2, dst_argb, 32);
+    __lsx_vst(dst3, dst_argb, 48);
+    dst_argb += 64;
+  }
+}
+
+void ARGBColorMatrixRow_LSX(const uint8_t* src_argb,
+                            uint8_t* dst_argb,
+                            const int8_t* matrix_argb,
+                            int width) {
+  int x;
+  int len = width / 8;
+  __m128i src0, src1, tmp0, tmp1, dst0, dst1;
+  __m128i tmp_b, tmp_g, tmp_r, tmp_a;
+  __m128i reg_b, reg_g, reg_r, reg_a;
+  __m128i matrix_b = __lsx_vldrepl_w(matrix_argb, 0);
+  __m128i matrix_g = __lsx_vldrepl_w(matrix_argb, 4);
+  __m128i matrix_r = __lsx_vldrepl_w(matrix_argb, 8);
+  __m128i matrix_a = __lsx_vldrepl_w(matrix_argb, 12);
+
+  for (x = 0; x < len; x++) {
+    DUP2_ARG2(__lsx_vld, src_argb, 0, src_argb, 16, src0, src1);
+    DUP4_ARG2(__lsx_vdp2_h_bu_b, src0, matrix_b, src0, matrix_g, src0, matrix_r,
+              src0, matrix_a, tmp_b, tmp_g, tmp_r, tmp_a);
+    DUP4_ARG2(__lsx_vdp2_h_bu_b, src1, matrix_b, src1, matrix_g, src1, matrix_r,
+              src1, matrix_a, reg_b, reg_g, reg_r, reg_a);
+    DUP4_ARG2(__lsx_vhaddw_w_h, tmp_b, tmp_b, tmp_g, tmp_g, tmp_r, tmp_r, tmp_a,
+              tmp_a, tmp_b, tmp_g, tmp_r, tmp_a);
+    DUP4_ARG2(__lsx_vhaddw_w_h, reg_b, reg_b, reg_g, reg_g, reg_r, reg_r, reg_a,
+              reg_a, reg_b, reg_g, reg_r, reg_a);
+    DUP4_ARG2(__lsx_vsrai_w, tmp_b, 6, tmp_g, 6, tmp_r, 6, tmp_a, 6, tmp_b,
+              tmp_g, tmp_r, tmp_a);
+    DUP4_ARG2(__lsx_vsrai_w, reg_b, 6, reg_g, 6, reg_r, 6, reg_a, 6, reg_b,
+              reg_g, reg_r, reg_a);
+    DUP4_ARG1(__lsx_vclip255_w, tmp_b, tmp_g, tmp_r, tmp_a, tmp_b, tmp_g, tmp_r,
+              tmp_a)
+    DUP4_ARG1(__lsx_vclip255_w, reg_b, reg_g, reg_r, reg_a, reg_b, reg_g, reg_r,
+              reg_a)
+    DUP4_ARG2(__lsx_vpickev_h, reg_b, tmp_b, reg_g, tmp_g, reg_r, tmp_r, reg_a,
+              tmp_a, tmp_b, tmp_g, tmp_r, tmp_a);
+    tmp0 = __lsx_vpackev_b(tmp_g, tmp_b);
+    tmp1 = __lsx_vpackev_b(tmp_a, tmp_r);
+    dst0 = __lsx_vilvl_h(tmp1, tmp0);
+    dst1 = __lsx_vilvh_h(tmp1, tmp0);
+    __lsx_vst(dst0, dst_argb, 0);
+    __lsx_vst(dst1, dst_argb, 16);
+    src_argb += 32;
+    dst_argb += 32;
+  }
+}
+
+void SplitUVRow_LSX(const uint8_t* src_uv,
+                    uint8_t* dst_u,
+                    uint8_t* dst_v,
+                    int width) {
+  int x;
+  int len = width / 32;
+  __m128i src0, src1, src2, src3;
+  __m128i dst0, dst1, dst2, dst3;
+
+  for (x = 0; x < len; x++) {
+    DUP4_ARG2(__lsx_vld, src_uv, 0, src_uv, 16, src_uv, 32, src_uv, 48, src0,
+              src1, src2, src3);
+    DUP2_ARG2(__lsx_vpickev_b, src1, src0, src3, src2, dst0, dst1);
+    DUP2_ARG2(__lsx_vpickod_b, src1, src0, src3, src2, dst2, dst3);
+    __lsx_vst(dst0, dst_u, 0);
+    __lsx_vst(dst1, dst_u, 16);
+    __lsx_vst(dst2, dst_v, 0);
+    __lsx_vst(dst3, dst_v, 16);
+    src_uv += 64;
+    dst_u += 32;
+    dst_v += 32;
+  }
+}
+
+void SetRow_LSX(uint8_t* dst, uint8_t v8, int width) {
+  int x;
+  int len = width / 16;
+  __m128i dst0 = __lsx_vreplgr2vr_b(v8);
+
+  for (x = 0; x < len; x++) {
+    __lsx_vst(dst0, dst, 0);
+    dst += 16;
+  }
+}
+
+void MirrorSplitUVRow_LSX(const uint8_t* src_uv,
+                          uint8_t* dst_u,
+                          uint8_t* dst_v,
+                          int width) {
+  int x;
+  int len = width / 32;
+  __m128i src0, src1, src2, src3;
+  __m128i dst0, dst1, dst2, dst3;
+  __m128i shuff0 = {0x10121416181A1C1E, 0x00020406080A0C0E};
+  __m128i shuff1 = {0x11131517191B1D1F, 0x01030507090B0D0F};
+
+  src_uv += (width << 1);
+  for (x = 0; x < len; x++) {
+    src_uv -= 64;
+    DUP4_ARG2(__lsx_vld, src_uv, 0, src_uv, 16, src_uv, 32, src_uv, 48, src2,
+              src3, src0, src1);
+    DUP4_ARG3(__lsx_vshuf_b, src1, src0, shuff1, src3, src2, shuff1, src1, src0,
+              shuff0, src3, src2, shuff0, dst0, dst1, dst2, dst3);
+    __lsx_vst(dst0, dst_v, 0);
+    __lsx_vst(dst1, dst_v, 16);
+    __lsx_vst(dst2, dst_u, 0);
+    __lsx_vst(dst3, dst_u, 16);
+    dst_u += 32;
+    dst_v += 32;
+  }
+}
+
+void HalfFloatRow_LSX(const uint16_t* src,
+                      uint16_t* dst,
+                      float scale,
+                      int width) {
+  int x;
+  int len = width / 32;
+  float mult = 1.9259299444e-34f * scale;
+  __m128i src0, src1, src2, src3, dst0, dst1, dst2, dst3;
+  __m128i tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
+  __m128 reg0, reg1, reg2, reg3, reg4, reg5, reg6, reg7;
+  __m128 vec_mult = (__m128)__lsx_vldrepl_w(&mult, 0);
+  __m128i zero = __lsx_vldi(0);
+
+  for (x = 0; x < len; x++) {
+    DUP4_ARG2(__lsx_vld, src, 0, src, 16, src, 32, src, 48, src0, src1, src2,
+              src3);
+    DUP4_ARG2(__lsx_vilvl_h, zero, src0, zero, src1, zero, src2, zero, src3,
+              tmp0, tmp2, tmp4, tmp6);
+    DUP4_ARG2(__lsx_vilvh_h, zero, src0, zero, src1, zero, src2, zero, src3,
+              tmp1, tmp3, tmp5, tmp7);
+    DUP4_ARG1(__lsx_vffint_s_wu, tmp0, tmp2, tmp4, tmp6, reg0, reg2, reg4,
+              reg6);
+    DUP4_ARG1(__lsx_vffint_s_wu, tmp1, tmp3, tmp5, tmp7, reg1, reg3, reg5,
+              reg7);
+    DUP4_ARG2(__lsx_vfmul_s, reg0, vec_mult, reg1, vec_mult, reg2, vec_mult,
+              reg3, vec_mult, reg0, reg1, reg2, reg3);
+    DUP4_ARG2(__lsx_vfmul_s, reg4, vec_mult, reg5, vec_mult, reg6, vec_mult,
+              reg7, vec_mult, reg4, reg5, reg6, reg7);
+    DUP4_ARG2(__lsx_vsrli_w, (v4u32)reg0, 13, (v4u32)reg1, 13, (v4u32)reg2, 13,
+              (v4u32)reg3, 13, tmp0, tmp1, tmp2, tmp3);
+    DUP4_ARG2(__lsx_vsrli_w, (v4u32)reg4, 13, (v4u32)reg5, 13, (v4u32)reg6, 13,
+              (v4u32)reg7, 13, tmp4, tmp5, tmp6, tmp7);
+    DUP4_ARG2(__lsx_vpickev_h, tmp1, tmp0, tmp3, tmp2, tmp5, tmp4, tmp7, tmp6,
+              dst0, dst1, dst2, dst3);
+    __lsx_vst(dst0, dst, 0);
+    __lsx_vst(dst1, dst, 16);
+    __lsx_vst(dst2, dst, 32);
+    __lsx_vst(dst3, dst, 48);
+    src += 32;
+    dst += 32;
+  }
+}
+
+#ifdef __cplusplus
+}  // extern "C"
+}  // namespace libyuv
+#endif
+
+#endif  // !defined(LIBYUV_DISABLE_LSX) && defined(__loongarch_sx)
diff --git a/3rdparty/libyuv/src/source/row_mmi.cc b/3rdparty/libyuv/src/source/row_mmi.cc
new file mode 100644
index 00000000..362fd1cf
--- /dev/null
+++ b/3rdparty/libyuv/src/source/row_mmi.cc
@@ -0,0 +1,7842 @@
+/*
+ *  Copyright 2011 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+#include "libyuv/row.h"
+
+#include <string.h>  // For memcpy and memset.
+
+#include "libyuv/basic_types.h"
+
+#ifdef __cplusplus
+namespace libyuv {
+extern "C" {
+#endif
+
+// This module is for Mips MMI.
+#if !defined(LIBYUV_DISABLE_MMI) && defined(_MIPS_ARCH_LOONGSON3A)
+
+// clang-format off
+
+void RGB24ToARGBRow_MMI(const uint8_t* src_rgb24,
+                        uint8_t* dst_argb,
+                        int width) {
+  uint64_t src0, src1, dest;
+  const uint64_t mask = 0xff000000ULL;
+
+  __asm__ volatile(
+      "1:                                                           \n\t"
+      "gslwlc1    %[src0],         0x03(%[src_ptr])                 \n\t"
+      "gslwrc1    %[src0],         0x00(%[src_ptr])                 \n\t"
+      "gslwlc1    %[src1],         0x06(%[src_ptr])                 \n\t"
+      "gslwrc1    %[src1],         0x03(%[src_ptr])                 \n\t"
+
+      "or         %[src0],         %[src0],           %[mask]       \n\t"
+      "or         %[src1],         %[src1],           %[mask]       \n\t"
+      "punpcklwd  %[dest],         %[src0],           %[src1]       \n\t"
+      "gssdlc1    %[dest],         0x07(%[dst_ptr])                 \n\t"
+      "gssdrc1    %[dest],         0x00(%[dst_ptr])                 \n\t"
+
+      "gslwlc1    %[src0],         0x09(%[src_ptr])                 \n\t"
+      "gslwrc1    %[src0],         0x06(%[src_ptr])                 \n\t"
+      "gslwlc1    %[src1],         0x0c(%[src_ptr])                 \n\t"
+      "gslwrc1    %[src1],         0x09(%[src_ptr])                 \n\t"
+
+      "or         %[src0],         %[src0],           %[mask]       \n\t"
+      "or         %[src1],         %[src1],           %[mask]       \n\t"
+      "punpcklwd  %[dest],         %[src0],           %[src1]       \n\t"
+      "gssdlc1    %[dest],         0x0f(%[dst_ptr])                 \n\t"
+      "gssdrc1    %[dest],         0x08(%[dst_ptr])                 \n\t"
+
+      "daddiu     %[src_ptr],      %[src_ptr],        0x0c          \n\t"
+      "daddiu     %[dst_ptr],      %[dst_ptr],        0x10          \n\t"
+      "daddi      %[width],        %[width],         -0x04          \n\t"
+      "bnez       %[width],        1b                               \n\t"
+      : [src0] "=&f"(src0), [src1] "=&f"(src1), [dest] "=&f"(dest)
+      : [src_ptr] "r"(src_rgb24), [dst_ptr] "r"(dst_argb), [width] "r"(width),
+        [mask] "f"(mask)
+      : "memory");
+}
+
+void RAWToARGBRow_MMI(const uint8_t* src_raw, uint8_t* dst_argb, int width) {
+  uint64_t src0, src1, dest;
+  const uint64_t mask0 = 0x0;
+  const uint64_t mask1 = 0xff000000ULL;
+  const uint64_t mask2 = 0xc6;
+
+  __asm__ volatile(
+      "1:                                                           \n\t"
+      "gslwlc1    %[src0],         0x03(%[src_ptr])                 \n\t"
+      "gslwrc1    %[src0],         0x00(%[src_ptr])                 \n\t"
+      "gslwlc1    %[src1],         0x06(%[src_ptr])                 \n\t"
+      "gslwrc1    %[src1],         0x03(%[src_ptr])                 \n\t"
+
+      "or         %[src0],         %[src0],           %[mask1]      \n\t"
+      "punpcklbh  %[src0],         %[src0],           %[mask0]      \n\t"
+      "pshufh     %[src0],         %[src0],           %[mask2]      \n\t"
+      "or         %[src1],         %[src1],           %[mask1]      \n\t"
+      "punpcklbh  %[src1],         %[src1],           %[mask0]      \n\t"
+      "pshufh     %[src1],         %[src1],           %[mask2]      \n\t"
+      "packushb   %[dest],         %[src0],           %[src1]       \n\t"
+      "gssdlc1    %[dest],         0x07(%[dst_ptr])                 \n\t"
+      "gssdrc1    %[dest],         0x00(%[dst_ptr])                 \n\t"
+
+      "gslwlc1    %[src0],         0x09(%[src_ptr])                 \n\t"
+      "gslwrc1    %[src0],         0x06(%[src_ptr])                 \n\t"
+      "gslwlc1    %[src1],         0x0c(%[src_ptr])                 \n\t"
+      "gslwrc1    %[src1],         0x09(%[src_ptr])                 \n\t"
+
+      "or         %[src0],         %[src0],           %[mask1]      \n\t"
+      "punpcklbh  %[src0],         %[src0],           %[mask0]      \n\t"
+      "pshufh     %[src0],         %[src0],           %[mask2]      \n\t"
+      "or         %[src1],         %[src1],           %[mask1]      \n\t"
+      "punpcklbh  %[src1],         %[src1],           %[mask0]      \n\t"
+      "pshufh     %[src1],         %[src1],           %[mask2]      \n\t"
+      "packushb   %[dest],         %[src0],           %[src1]       \n\t"
+      "gssdlc1    %[dest],         0x0f(%[dst_ptr])                 \n\t"
+      "gssdrc1    %[dest],         0x08(%[dst_ptr])                 \n\t"
+
+      "daddiu     %[src_ptr],      %[src_ptr],        0x0c          \n\t"
+      "daddiu     %[dst_ptr],      %[dst_ptr],        0x10          \n\t"
+      "daddi      %[width],        %[width],         -0x04          \n\t"
+      "bnez       %[width],        1b                               \n\t"
+      : [src0] "=&f"(src0), [src1] "=&f"(src1), [dest] "=&f"(dest)
+      : [src_ptr] "r"(src_raw), [dst_ptr] "r"(dst_argb), [mask0] "f"(mask0),
+        [mask1] "f"(mask1), [mask2] "f"(mask2), [width] "r"(width)
+      : "memory");
+}
+
+void RAWToRGB24Row_MMI(const uint8_t* src_raw, uint8_t* dst_rgb24, int width) {
+  uint64_t src0, src1;
+  uint64_t ftmp[4];
+  uint64_t mask0 = 0xc6;
+  uint64_t mask1 = 0x6c;
+
+  __asm__ volatile(
+      "1:                                                           \n\t"
+      "gsldrc1    %[src0],         0x00(%[src_raw])                 \n\t"
+      "gsldlc1    %[src0],         0x07(%[src_raw])                 \n\t"
+      "gslwrc1    %[src1],         0x08(%[src_raw])                 \n\t"
+      "gslwlc1    %[src1],         0x0b(%[src_raw])                 \n\t"
+
+      "punpcklbh  %[ftmp0],        %[src0],           %[zero]       \n\t"
+      "pshufh     %[ftmp0],        %[ftmp0],          %[mask0]      \n\t"
+      "punpckhbh  %[ftmp1],        %[src0],           %[zero]       \n\t"
+      "punpcklbh  %[src1],         %[src1],           %[zero]       \n\t"
+      "pextrh     %[ftmp2],        %[ftmp0],          %[three]      \n\t"
+      "pextrh     %[ftmp3],        %[ftmp1],          %[one]        \n\t"
+      "pinsrh_3   %[ftmp0],        %[ftmp0],          %[ftmp3]      \n\t"
+      "pextrh     %[ftmp3],        %[ftmp1],          %[two]        \n\t"
+      "pinsrh_1   %[ftmp1],        %[ftmp1],          %[ftmp2]      \n\t"
+      "pshufh     %[src1],         %[src1],           %[mask1]      \n\t"
+      "pextrh     %[ftmp2],        %[src1],           %[zero]       \n\t"
+      "pinsrh_2   %[ftmp1],        %[ftmp1],          %[ftmp2]      \n\t"
+      "pinsrh_0   %[src1],         %[src1],           %[ftmp3]      \n\t"
+      "packushb   %[ftmp0],        %[ftmp0],          %[ftmp1]      \n\t"
+      "packushb   %[src1],         %[src1],           %[zero]       \n\t"
+
+      "gssdrc1    %[ftmp0],        0x00(%[dst_rgb24])               \n\t"
+      "gssdlc1    %[ftmp0],        0x07(%[dst_rgb24])               \n\t"
+      "gsswrc1    %[src1],         0x08(%[dst_rgb24])               \n\t"
+      "gsswlc1    %[src1],         0x0b(%[dst_rgb24])               \n\t"
+
+      "daddiu     %[src_raw],      %[src_raw],        0x0c          \n\t"
+      "daddiu     %[dst_rgb24],    %[dst_rgb24],      0x0c          \n\t"
+      "daddiu     %[width],        %[width],         -0x04          \n\t"
+      "bgtz       %[width],        1b                               \n\t"
+      : [src0] "=&f"(src0), [src1] "=&f"(src1), [ftmp0] "=&f"(ftmp[0]),
+        [ftmp1] "=&f"(ftmp[1]), [ftmp2] "=&f"(ftmp[2]), [ftmp3] "=&f"(ftmp[3])
+      : [src_raw] "r"(src_raw), [dst_rgb24] "r"(dst_rgb24), [width] "r"(width),
+        [mask0] "f"(mask0), [mask1] "f"(mask1), [zero] "f"(0x00),
+        [one] "f"(0x01), [two] "f"(0x02), [three] "f"(0x03)
+      : "memory");
+}
+
+void RGB565ToARGBRow_MMI(const uint8_t* src_rgb565,
+                         uint8_t* dst_argb,
+                         int width) {
+  uint64_t ftmp[5];
+  uint64_t c0 = 0x001f001f001f001f;
+  uint64_t c1 = 0x00ff00ff00ff00ff;
+  uint64_t c2 = 0x0007000700070007;
+  __asm__ volatile(
+      "1:                                                      \n\t"
+      "gsldrc1   %[src0],       0x00(%[src_rgb565])            \n\t"
+      "gsldlc1   %[src0],       0x07(%[src_rgb565])            \n\t"
+      "psrlh     %[src1],       %[src0],             %[eight]  \n\t"
+      "and       %[b],          %[src0],             %[c0]     \n\t"
+      "and       %[src0],       %[src0],             %[c1]     \n\t"
+      "psrlh     %[src0],       %[src0],             %[five]   \n\t"
+      "and       %[g],          %[src1],             %[c2]     \n\t"
+      "psllh     %[g],          %[g],                %[three]  \n\t"
+      "or        %[g],          %[src0],             %[g]      \n\t"
+      "psrlh     %[r],          %[src1],             %[three]  \n\t"
+      "psllh     %[src0],       %[b],                %[three]  \n\t"
+      "psrlh     %[src1],       %[b],                %[two]    \n\t"
+      "or        %[b],          %[src0],             %[src1]   \n\t"
+      "psllh     %[src0],       %[g],                %[two]    \n\t"
+      "psrlh     %[src1],       %[g],                %[four]   \n\t"
+      "or        %[g],          %[src0],             %[src1]   \n\t"
+      "psllh     %[src0],       %[r],                %[three]  \n\t"
+      "psrlh     %[src1],       %[r],                %[two]    \n\t"
+      "or        %[r],          %[src0],             %[src1]   \n\t"
+      "packushb  %[b],          %[b],                %[r]      \n\t"
+      "packushb  %[g],          %[g],                %[c1]     \n\t"
+      "punpcklbh %[src0],       %[b],                %[g]      \n\t"
+      "punpckhbh %[src1],       %[b],                %[g]      \n\t"
+      "punpcklhw %[r],          %[src0],             %[src1]   \n\t"
+      "gssdrc1   %[r],          0x00(%[dst_argb])              \n\t"
+      "gssdlc1   %[r],          0x07(%[dst_argb])              \n\t"
+      "punpckhhw %[r],          %[src0],             %[src1]   \n\t"
+      "gssdrc1   %[r],          0x08(%[dst_argb])              \n\t"
+      "gssdlc1   %[r],          0x0f(%[dst_argb])              \n\t"
+      "daddiu    %[src_rgb565], %[src_rgb565],       0x08      \n\t"
+      "daddiu    %[dst_argb],   %[dst_argb],         0x10      \n\t"
+      "daddiu    %[width],      %[width],           -0x04      \n\t"
+      "bgtz      %[width],     1b                              \n\t"
+      : [src0] "=&f"(ftmp[0]), [src1] "=&f"(ftmp[1]), [b] "=&f"(ftmp[2]),
+        [g] "=&f"(ftmp[3]), [r] "=&f"(ftmp[4])
+      : [src_rgb565] "r"(src_rgb565), [dst_argb] "r"(dst_argb),
+        [width] "r"(width), [c0] "f"(c0), [c1] "f"(c1), [c2] "f"(c2),
+        [eight] "f"(0x08), [five] "f"(0x05), [three] "f"(0x03), [two] "f"(0x02),
+        [four] "f"(0x04)
+      : "memory");
+}
+
+void ARGB1555ToARGBRow_MMI(const uint8_t* src_argb1555,
+                           uint8_t* dst_argb,
+                           int width) {
+  uint64_t ftmp[6];
+  uint64_t c0 = 0x001f001f001f001f;
+  uint64_t c1 = 0x00ff00ff00ff00ff;
+  uint64_t c2 = 0x0003000300030003;
+  uint64_t c3 = 0x007c007c007c007c;
+  uint64_t c4 = 0x0001000100010001;
+  __asm__ volatile(
+      "1:                                                         \n\t"
+      "gsldrc1   %[src0],         0x00(%[src_argb1555])           \n\t"
+      "gsldlc1   %[src0],         0x07(%[src_argb1555])           \n\t"
+      "psrlh     %[src1],         %[src0],              %[eight]  \n\t"
+      "and       %[b],            %[src0],              %[c0]     \n\t"
+      "and       %[src0],         %[src0],              %[c1]     \n\t"
+      "psrlh     %[src0],         %[src0],              %[five]   \n\t"
+      "and       %[g],            %[src1],              %[c2]     \n\t"
+      "psllh     %[g],            %[g],                 %[three]  \n\t"
+      "or        %[g],            %[src0],              %[g]      \n\t"
+      "and       %[r],            %[src1],              %[c3]     \n\t"
+      "psrlh     %[r],            %[r],                 %[two]    \n\t"
+      "psrlh     %[a],            %[src1],              %[seven]  \n\t"
+      "psllh     %[src0],         %[b],                 %[three]  \n\t"
+      "psrlh     %[src1],         %[b],                 %[two]    \n\t"
+      "or        %[b],            %[src0],              %[src1]   \n\t"
+      "psllh     %[src0],         %[g],                 %[three]  \n\t"
+      "psrlh     %[src1],         %[g],                 %[two]    \n\t"
+      "or        %[g],            %[src0],              %[src1]   \n\t"
+      "psllh     %[src0],         %[r],                 %[three]  \n\t"
+      "psrlh     %[src1],         %[r],                 %[two]    \n\t"
+      "or        %[r],            %[src0],              %[src1]   \n\t"
+      "xor       %[a],            %[a],                 %[c1]     \n\t"
+      "paddb     %[a],            %[a],                 %[c4]     \n\t"
+      "packushb  %[b],            %[b],                 %[r]      \n\t"
+      "packushb  %[g],            %[g],                 %[a]      \n\t"
+      "punpcklbh %[src0],         %[b],                 %[g]      \n\t"
+      "punpckhbh %[src1],         %[b],                 %[g]      \n\t"
+      "punpcklhw %[r],            %[src0],              %[src1]   \n\t"
+      "gssdrc1   %[r],            0x00(%[dst_argb])               \n\t"
+      "gssdlc1   %[r],            0x07(%[dst_argb])               \n\t"
+      "punpckhhw %[r],            %[src0],              %[src1]   \n\t"
+      "gssdrc1   %[r],            0x08(%[dst_argb])               \n\t"
+      "gssdlc1   %[r],            0x0f(%[dst_argb])               \n\t"
+      "daddiu    %[src_argb1555], %[src_argb1555],      0x08      \n\t"
+      "daddiu    %[dst_argb],     %[dst_argb],          0x10      \n\t"
+      "daddiu    %[width],        %[width],            -0x04      \n\t"
+      "bgtz      %[width],        1b                              \n\t"
+      : [src0] "=&f"(ftmp[0]), [src1] "=&f"(ftmp[1]), [b] "=&f"(ftmp[2]),
+        [g] "=&f"(ftmp[3]), [r] "=&f"(ftmp[4]), [a] "=&f"(ftmp[5])
+      : [src_argb1555] "r"(src_argb1555), [dst_argb] "r"(dst_argb),
+        [width] "r"(width), [c0] "f"(c0), [c1] "f"(c1), [c2] "f"(c2),
+        [c3] "f"(c3), [c4] "f"(c4), [eight] "f"(0x08), [five] "f"(0x05),
+        [three] "f"(0x03), [two] "f"(0x02), [seven] "f"(0x07)
+      : "memory");
+}
+
+void ARGB4444ToARGBRow_MMI(const uint8_t* src_argb4444,
+                           uint8_t* dst_argb,
+                           int width) {
+  uint64_t ftmp[6];
+  uint64_t c0 = 0x000f000f000f000f;
+  uint64_t c1 = 0x00ff00ff00ff00ff;
+  __asm__ volatile(
+      "1:                                                          \n\t"
+      "gsldrc1   %[src0],         0x00(%[src_argb4444])            \n\t"
+      "gsldlc1   %[src0],         0x07(%[src_argb4444])            \n\t"
+      "psrlh     %[src1],         %[src0],              %[eight]   \n\t"
+      "and       %[b],            %[src0],              %[c0]      \n\t"
+      "and       %[src0],         %[src0],              %[c1]      \n\t"
+      "psrlh     %[g],            %[src0],              %[four]    \n\t"
+      "and       %[r],            %[src1],              %[c0]      \n\t"
+      "psrlh     %[a],            %[src1],              %[four]    \n\t"
+      "psllh     %[src0],         %[b],                 %[four]    \n\t"
+      "or        %[b],            %[src0],              %[b]       \n\t"
+      "psllh     %[src0],         %[g],                 %[four]    \n\t"
+      "or        %[g],            %[src0],              %[g]       \n\t"
+      "psllh     %[src0],         %[r],                 %[four]    \n\t"
+      "or        %[r],            %[src0],              %[r]       \n\t"
+      "psllh     %[src0],         %[a],                 %[four]    \n\t"
+      "or        %[a],            %[src0],              %[a]       \n\t"
+      "packushb  %[b],            %[b],                 %[r]       \n\t"
+      "packushb  %[g],            %[g],                 %[a]       \n\t"
+      "punpcklbh %[src0],         %[b],                 %[g]       \n\t"
+      "punpckhbh %[src1],         %[b],                 %[g]       \n\t"
+      "punpcklhw %[r],            %[src0],              %[src1]    \n\t"
+      "gssdrc1   %[r],            0x00(%[dst_argb])                \n\t"
+      "gssdlc1   %[r],            0x07(%[dst_argb])                \n\t"
+      "punpckhhw %[r],            %[src0],              %[src1]    \n\t"
+      "gssdrc1   %[r],            0x08(%[dst_argb])                \n\t"
+      "gssdlc1   %[r],            0x0f(%[dst_argb])                \n\t"
+      "daddiu    %[src_argb4444], %[src_argb4444],      0x08       \n\t"
+      "daddiu    %[dst_argb],     %[dst_argb],          0x10       \n\t"
+      "daddiu    %[width],        %[width],            -0x04       \n\t"
+      "bgtz      %[width],        1b                               \n\t"
+      : [src0] "=&f"(ftmp[0]), [src1] "=&f"(ftmp[1]), [b] "=&f"(ftmp[2]),
+        [g] "=&f"(ftmp[3]), [r] "=&f"(ftmp[4]), [a] "=&f"(ftmp[5])
+      : [src_argb4444] "r"(src_argb4444), [dst_argb] "r"(dst_argb),
+        [width] "r"(width), [c0] "f"(c0), [c1] "f"(c1), [eight] "f"(0x08),
+        [four] "f"(0x04)
+      : "memory");
+}
+
+void ARGBToRGB24Row_MMI(const uint8_t* src_argb, uint8_t* dst_rgb, int width) {
+  uint64_t src;
+
+  __asm__ volatile(
+      "1:                                                           \n\t"
+      "gslwlc1    %[src],          0x03(%[src_ptr])                 \n\t"
+      "gslwrc1    %[src],          0x00(%[src_ptr])                 \n\t"
+      "gsswlc1    %[src],          0x03(%[dst_ptr])                 \n\t"
+      "gsswrc1    %[src],          0x00(%[dst_ptr])                 \n\t"
+
+      "gslwlc1    %[src],          0x07(%[src_ptr])                 \n\t"
+      "gslwrc1    %[src],          0x04(%[src_ptr])                 \n\t"
+      "gsswlc1    %[src],          0x06(%[dst_ptr])                 \n\t"
+      "gsswrc1    %[src],          0x03(%[dst_ptr])                 \n\t"
+
+      "gslwlc1    %[src],          0x0b(%[src_ptr])                 \n\t"
+      "gslwrc1    %[src],          0x08(%[src_ptr])                 \n\t"
+      "gsswlc1    %[src],          0x09(%[dst_ptr])                 \n\t"
+      "gsswrc1    %[src],          0x06(%[dst_ptr])                 \n\t"
+
+      "gslwlc1    %[src],          0x0f(%[src_ptr])                 \n\t"
+      "gslwrc1    %[src],          0x0c(%[src_ptr])                 \n\t"
+      "gsswlc1    %[src],          0x0c(%[dst_ptr])                 \n\t"
+      "gsswrc1    %[src],          0x09(%[dst_ptr])                 \n\t"
+
+      "daddiu     %[src_ptr],      %[src_ptr],        0x10          \n\t"
+      "daddiu     %[dst_ptr],      %[dst_ptr],        0x0c          \n\t"
+      "daddi      %[width],        %[width],         -0x04          \n\t"
+      "bnez       %[width],        1b                               \n\t"
+      : [src] "=&f"(src)
+      : [src_ptr] "r"(src_argb), [dst_ptr] "r"(dst_rgb), [width] "r"(width)
+      : "memory");
+}
+
+void ARGBToRAWRow_MMI(const uint8_t* src_argb, uint8_t* dst_rgb, int width) {
+  uint64_t src0, src1;
+  uint64_t ftmp[3];
+  uint64_t mask0 = 0xc6;
+  uint64_t mask1 = 0x18;
+
+  __asm__ volatile(
+      "1:                                                           \n\t"
+      "gsldrc1    %[src0],         0x00(%[src_argb])                \n\t"
+      "gsldlc1    %[src0],         0x07(%[src_argb])                \n\t"
+      "gsldrc1    %[src1],         0x08(%[src_argb])                \n\t"
+      "gsldlc1    %[src1],         0x0f(%[src_argb])                \n\t"
+
+      "punpcklbh  %[ftmp0],        %[src0],           %[zero]       \n\t"
+      "pshufh     %[ftmp0],        %[ftmp0],          %[mask0]      \n\t"
+      "punpckhbh  %[ftmp1],        %[src0],           %[zero]       \n\t"
+      "punpcklbh  %[ftmp2],        %[src1],           %[zero]       \n\t"
+      "punpckhbh  %[src1],         %[src1],           %[zero]       \n\t"
+
+      "pextrh     %[src0],         %[ftmp1],          %[two]        \n\t"
+      "pinsrh_3   %[ftmp0],        %[ftmp0],          %[src0]       \n\t"
+      "pshufh     %[ftmp1],        %[ftmp1],          %[one]        \n\t"
+
+      "pextrh     %[src0],         %[ftmp2],          %[two]        \n\t"
+      "pinsrh_2   %[ftmp1],        %[ftmp1],          %[src0]       \n\t"
+      "pextrh     %[src0],         %[ftmp2],          %[one]        \n\t"
+      "pinsrh_3   %[ftmp1],        %[ftmp1],          %[src0]       \n\t"
+      "pextrh     %[src0],         %[ftmp2],          %[zero]       \n\t"
+      "pshufh     %[src1],         %[src1],           %[mask1]      \n\t"
+      "pinsrh_0   %[src1],         %[src1],           %[src0]       \n\t"
+      "packushb   %[ftmp0],        %[ftmp0],          %[ftmp1]      \n\t"
+      "packushb   %[src1],         %[src1],           %[zero]       \n\t"
+
+      "gssdrc1    %[ftmp0],        0x00(%[dst_rgb])                 \n\t"
+      "gssdlc1    %[ftmp0],        0x07(%[dst_rgb])                 \n\t"
+      "gsswrc1    %[src1],         0x08(%[dst_rgb])                 \n\t"
+      "gsswlc1    %[src1],         0x0b(%[dst_rgb])                 \n\t"
+
+      "daddiu     %[src_argb],     %[src_argb],       0x10          \n\t"
+      "daddiu     %[dst_rgb],      %[dst_rgb],        0x0c          \n\t"
+      "daddiu     %[width],        %[width],         -0x04          \n\t"
+      "bgtz       %[width],        1b                               \n\t"
+      : [src0] "=&f"(src0), [src1] "=&f"(src1), [ftmp0] "=&f"(ftmp[0]),
+        [ftmp1] "=&f"(ftmp[1]), [ftmp2] "=&f"(ftmp[2])
+      : [src_argb] "r"(src_argb), [dst_rgb] "r"(dst_rgb), [width] "r"(width),
+        [mask0] "f"(mask0), [mask1] "f"(mask1), [zero] "f"(0x00),
+        [one] "f"(0x01), [two] "f"(0x02)
+      : "memory");
+}
+
+void ARGBToRGB565Row_MMI(const uint8_t* src_argb, uint8_t* dst_rgb, int width) {
+  uint64_t src0, src1;
+  uint64_t ftmp[3];
+
+  __asm__ volatile(
+      "1:                                                           \n\t"
+      "gsldrc1    %[src0],         0x00(%[src_argb])                \n\t"
+      "gsldlc1    %[src0],         0x07(%[src_argb])                \n\t"
+      "gsldrc1    %[src1],         0x08(%[src_argb])                \n\t"
+      "gsldlc1    %[src1],         0x0f(%[src_argb])                \n\t"
+
+      "punpcklbh  %[b],            %[src0],           %[src1]       \n\t"
+      "punpckhbh  %[g],            %[src0],           %[src1]       \n\t"
+      "punpcklbh  %[src0],         %[b],              %[g]          \n\t"
+      "punpckhbh  %[src1],         %[b],              %[g]          \n\t"
+      "punpcklbh  %[b],            %[src0],           %[zero]       \n\t"
+      "punpckhbh  %[g],            %[src0],           %[zero]       \n\t"
+      "punpcklbh  %[r],            %[src1],           %[zero]       \n\t"
+
+      "psrlh      %[b],            %[b],              %[three]      \n\t"
+      "psrlh      %[g],            %[g],              %[two]        \n\t"
+      "psrlh      %[r],            %[r],              %[three]      \n\t"
+
+      "psllh      %[g],            %[g],              %[five]       \n\t"
+      "psllh      %[r],            %[r],              %[eleven]     \n\t"
+      "or         %[b],            %[b],              %[g]          \n\t"
+      "or         %[b],            %[b],              %[r]          \n\t"
+
+      "gssdrc1    %[b],            0x00(%[dst_rgb])                 \n\t"
+      "gssdlc1    %[b],            0x07(%[dst_rgb])                 \n\t"
+
+      "daddiu     %[src_argb],     %[src_argb],       0x10          \n\t"
+      "daddiu     %[dst_rgb],      %[dst_rgb],        0x08          \n\t"
+      "daddiu     %[width],        %[width],         -0x04          \n\t"
+      "bgtz       %[width],        1b                               \n\t"
+      : [src0] "=&f"(src0), [src1] "=&f"(src1), [b] "=&f"(ftmp[0]),
+        [g] "=&f"(ftmp[1]), [r] "=&f"(ftmp[2])
+      : [src_argb] "r"(src_argb), [dst_rgb] "r"(dst_rgb), [width] "r"(width),
+        [zero] "f"(0x00), [two] "f"(0x02), [three] "f"(0x03), [five] "f"(0x05),
+        [eleven] "f"(0x0b)
+      : "memory");
+}
+
+// dither4 is a row of 4 values from 4x4 dither matrix.
+// The 4x4 matrix contains values to increase RGB.  When converting to
+// fewer bits (565) this provides an ordered dither.
+// The order in the 4x4 matrix in first byte is upper left.
+// The 4 values are passed as an int, then referenced as an array, so
+// endian will not affect order of the original matrix.  But the dither4
+// will containing the first pixel in the lower byte for little endian
+// or the upper byte for big endian.
+void ARGBToRGB565DitherRow_MMI(const uint8_t* src_argb,
+                               uint8_t* dst_rgb,
+                               const uint32_t dither4,
+                               int width) {
+  uint64_t src0, src1;
+  uint64_t ftmp[3];
+  uint64_t c0 = 0x00ff00ff00ff00ff;
+
+  __asm__ volatile(
+      "punpcklbh  %[dither],       %[dither],         %[zero]       \n\t"
+      "1:                                                           \n\t"
+      "gsldrc1    %[src0],         0x00(%[src_argb])                \n\t"
+      "gsldlc1    %[src0],         0x07(%[src_argb])                \n\t"
+      "gsldrc1    %[src1],         0x08(%[src_argb])                \n\t"
+      "gsldlc1    %[src1],         0x0f(%[src_argb])                \n\t"
+
+      "punpcklbh  %[b],            %[src0],           %[src1]       \n\t"
+      "punpckhbh  %[g],            %[src0],           %[src1]       \n\t"
+      "punpcklbh  %[src0],         %[b],              %[g]          \n\t"
+      "punpckhbh  %[src1],         %[b],              %[g]          \n\t"
+      "punpcklbh  %[b],            %[src0],           %[zero]       \n\t"
+      "punpckhbh  %[g],            %[src0],           %[zero]       \n\t"
+      "punpcklbh  %[r],            %[src1],           %[zero]       \n\t"
+
+      "paddh      %[b],            %[b],              %[dither]     \n\t"
+      "paddh      %[g],            %[g],              %[dither]     \n\t"
+      "paddh      %[r],            %[r],              %[dither]     \n\t"
+      "pcmpgth    %[src0],         %[b],              %[c0]         \n\t"
+      "or         %[src0],         %[src0],           %[b]          \n\t"
+      "and        %[b],            %[src0],           %[c0]         \n\t"
+      "pcmpgth    %[src0],         %[g],              %[c0]         \n\t"
+      "or         %[src0],         %[src0],           %[g]          \n\t"
+      "and        %[g],            %[src0],           %[c0]         \n\t"
+      "pcmpgth    %[src0],         %[r],              %[c0]         \n\t"
+      "or         %[src0],         %[src0],           %[r]          \n\t"
+      "and        %[r],            %[src0],           %[c0]         \n\t"
+
+      "psrlh      %[b],            %[b],              %[three]      \n\t"
+      "psrlh      %[g],            %[g],              %[two]        \n\t"
+      "psrlh      %[r],            %[r],              %[three]      \n\t"
+
+      "psllh      %[g],            %[g],              %[five]       \n\t"
+      "psllh      %[r],            %[r],              %[eleven]     \n\t"
+      "or         %[b],            %[b],              %[g]          \n\t"
+      "or         %[b],            %[b],              %[r]          \n\t"
+
+      "gssdrc1    %[b],            0x00(%[dst_rgb])                 \n\t"
+      "gssdlc1    %[b],            0x07(%[dst_rgb])                 \n\t"
+
+      "daddiu     %[src_argb],     %[src_argb],       0x10          \n\t"
+      "daddiu     %[dst_rgb],      %[dst_rgb],        0x08          \n\t"
+      "daddiu     %[width],        %[width],         -0x04          \n\t"
+      "bgtz       %[width],        1b                               \n\t"
+      : [src0] "=&f"(src0), [src1] "=&f"(src1), [b] "=&f"(ftmp[0]),
+        [g] "=&f"(ftmp[1]), [r] "=&f"(ftmp[2])
+      : [src_argb] "r"(src_argb), [dst_rgb] "r"(dst_rgb), [width] "r"(width),
+        [dither] "f"(dither4), [c0] "f"(c0), [zero] "f"(0x00), [two] "f"(0x02),
+        [three] "f"(0x03), [five] "f"(0x05), [eleven] "f"(0x0b)
+      : "memory");
+}
+
+void ARGBToARGB1555Row_MMI(const uint8_t* src_argb,
+                           uint8_t* dst_rgb,
+                           int width) {
+  uint64_t src0, src1;
+  uint64_t ftmp[4];
+
+  __asm__ volatile(
+      "1:                                                           \n\t"
+      "gsldrc1    %[src0],         0x00(%[src_argb])                \n\t"
+      "gsldlc1    %[src0],         0x07(%[src_argb])                \n\t"
+      "gsldrc1    %[src1],         0x08(%[src_argb])                \n\t"
+      "gsldlc1    %[src1],         0x0f(%[src_argb])                \n\t"
+
+      "punpcklbh  %[b],            %[src0],           %[src1]       \n\t"
+      "punpckhbh  %[g],            %[src0],           %[src1]       \n\t"
+      "punpcklbh  %[src0],         %[b],              %[g]          \n\t"
+      "punpckhbh  %[src1],         %[b],              %[g]          \n\t"
+      "punpcklbh  %[b],            %[src0],           %[zero]       \n\t"
+      "punpckhbh  %[g],            %[src0],           %[zero]       \n\t"
+      "punpcklbh  %[r],            %[src1],           %[zero]       \n\t"
+      "punpckhbh  %[a],            %[src1],           %[zero]       \n\t"
+
+      "psrlh      %[b],            %[b],              %[three]      \n\t"
+      "psrlh      %[g],            %[g],              %[three]      \n\t"
+      "psrlh      %[r],            %[r],              %[three]      \n\t"
+      "psrlh      %[a],            %[a],              %[seven]      \n\t"
+
+      "psllh      %[g],            %[g],              %[five]       \n\t"
+      "psllh      %[r],            %[r],              %[ten]        \n\t"
+      "psllh      %[a],            %[a],              %[fifteen]    \n\t"
+      "or         %[b],            %[b],              %[g]          \n\t"
+      "or         %[b],            %[b],              %[r]          \n\t"
+      "or         %[b],            %[b],              %[a]          \n\t"
+
+      "gssdrc1    %[b],            0x00(%[dst_rgb])                 \n\t"
+      "gssdlc1    %[b],            0x07(%[dst_rgb])                 \n\t"
+
+      "daddiu     %[src_argb],     %[src_argb],       0x10          \n\t"
+      "daddiu     %[dst_rgb],      %[dst_rgb],        0x08          \n\t"
+      "daddiu     %[width],        %[width],         -0x04          \n\t"
+      "bgtz       %[width],        1b                               \n\t"
+      : [src0] "=&f"(src0), [src1] "=&f"(src1), [b] "=&f"(ftmp[0]),
+        [g] "=&f"(ftmp[1]), [r] "=&f"(ftmp[2]), [a] "=&f"(ftmp[3])
+      : [src_argb] "r"(src_argb), [dst_rgb] "r"(dst_rgb), [width] "r"(width),
+        [zero] "f"(0x00), [three] "f"(0x03), [five] "f"(0x05),
+        [seven] "f"(0x07), [ten] "f"(0x0a), [fifteen] "f"(0x0f)
+      : "memory");
+}
+
+void ARGBToARGB4444Row_MMI(const uint8_t* src_argb,
+                           uint8_t* dst_rgb,
+                           int width) {
+  uint64_t src0, src1;
+  uint64_t ftmp[4];
+
+  __asm__ volatile(
+      "1:                                                           \n\t"
+      "gsldrc1    %[src0],         0x00(%[src_argb])                \n\t"
+      "gsldlc1    %[src0],         0x07(%[src_argb])                \n\t"
+      "gsldrc1    %[src1],         0x08(%[src_argb])                \n\t"
+      "gsldlc1    %[src1],         0x0f(%[src_argb])                \n\t"
+
+      "punpcklbh  %[b],            %[src0],           %[src1]       \n\t"
+      "punpckhbh  %[g],            %[src0],           %[src1]       \n\t"
+      "punpcklbh  %[src0],         %[b],              %[g]          \n\t"
+      "punpckhbh  %[src1],         %[b],              %[g]          \n\t"
+      "punpcklbh  %[b],            %[src0],           %[zero]       \n\t"
+      "punpckhbh  %[g],            %[src0],           %[zero]       \n\t"
+      "punpcklbh  %[r],            %[src1],           %[zero]       \n\t"
+      "punpckhbh  %[a],            %[src1],           %[zero]       \n\t"
+
+      "psrlh      %[b],            %[b],              %[four]       \n\t"
+      "psrlh      %[g],            %[g],              %[four]       \n\t"
+      "psrlh      %[r],            %[r],              %[four]       \n\t"
+      "psrlh      %[a],            %[a],              %[four]       \n\t"
+
+      "psllh      %[g],            %[g],              %[four]       \n\t"
+      "psllh      %[r],            %[r],              %[eight]      \n\t"
+      "psllh      %[a],            %[a],              %[twelve]     \n\t"
+      "or         %[b],            %[b],              %[g]          \n\t"
+      "or         %[b],            %[b],              %[r]          \n\t"
+      "or         %[b],            %[b],              %[a]          \n\t"
+
+      "gssdrc1    %[b],            0x00(%[dst_rgb])                 \n\t"
+      "gssdlc1    %[b],            0x07(%[dst_rgb])                 \n\t"
+
+      "daddiu     %[src_argb],     %[src_argb],       0x10          \n\t"
+      "daddiu     %[dst_rgb],      %[dst_rgb],        0x08          \n\t"
+      "daddiu     %[width],        %[width],         -0x04          \n\t"
+      "bgtz       %[width],        1b                               \n\t"
+      : [src0] "=&f"(src0), [src1] "=&f"(src1), [b] "=&f"(ftmp[0]),
+        [g] "=&f"(ftmp[1]), [r] "=&f"(ftmp[2]), [a] "=&f"(ftmp[3])
+      : [src_argb] "r"(src_argb), [dst_rgb] "r"(dst_rgb), [width] "r"(width),
+        [zero] "f"(0x00), [four] "f"(0x04), [eight] "f"(0x08),
+        [twelve] "f"(0x0c)
+      : "memory");
+}
+
+void ARGBToYRow_MMI(const uint8_t* src_argb, uint8_t* dst_y, int width) {
+  uint64_t src, src_hi, src_lo;
+  uint64_t dest0, dest1, dest2, dest3;
+  const uint64_t value = 0x1080;
+  const uint64_t mask = 0x0001004200810019;
+
+  __asm__ volatile(
+      "1:                                                           \n\t"
+      "gsldlc1    %[src],          0x07(%[src_argb])               \n\t"
+      "gsldrc1    %[src],          0x00(%[src_argb])               \n\t"
+      "punpcklbh  %[src_lo],       %[src],            %[zero]       \n\t"
+      "pinsrh_3   %[src_lo],       %[src_lo],         %[value]      \n\t"
+      "pmaddhw    %[src_lo],       %[src_lo],         %[mask]       \n\t"
+      "punpckhbh  %[src_hi],       %[src],            %[zero]       \n\t"
+      "pinsrh_3   %[src_hi],       %[src_hi],         %[value]      \n\t"
+      "pmaddhw    %[src_hi],       %[src_hi],         %[mask]       \n\t"
+      "punpcklwd  %[src],          %[src_lo],         %[src_hi]     \n\t"
+      "punpckhwd  %[dest0],        %[src_lo],         %[src_hi]     \n\t"
+      "paddw      %[dest0],        %[dest0],          %[src]        \n\t"
+      "psrlw      %[dest0],        %[dest0],          %[eight]      \n\t"
+
+      "gsldlc1    %[src],          0x0f(%[src_argb])               \n\t"
+      "gsldrc1    %[src],          0x08(%[src_argb])               \n\t"
+      "punpcklbh  %[src_lo],       %[src],            %[zero]       \n\t"
+      "pinsrh_3   %[src_lo],       %[src_lo],         %[value]      \n\t"
+      "pmaddhw    %[src_lo],       %[src_lo],         %[mask]       \n\t"
+      "punpckhbh  %[src_hi],       %[src],            %[zero]       \n\t"
+      "pinsrh_3   %[src_hi],       %[src_hi],         %[value]      \n\t"
+      "pmaddhw    %[src_hi],       %[src_hi],         %[mask]       \n\t"
+      "punpcklwd  %[src],          %[src_lo],         %[src_hi]     \n\t"
+      "punpckhwd  %[dest1],        %[src_lo],         %[src_hi]     \n\t"
+      "paddw      %[dest1],        %[dest1],          %[src]        \n\t"
+      "psrlw      %[dest1],        %[dest1],          %[eight]      \n\t"
+
+      "gsldlc1    %[src],          0x17(%[src_argb])               \n\t"
+      "gsldrc1    %[src],          0x10(%[src_argb])               \n\t"
+      "punpcklbh  %[src_lo],       %[src],            %[zero]       \n\t"
+      "pinsrh_3   %[src_lo],       %[src_lo],         %[value]      \n\t"
+      "pmaddhw    %[src_lo],       %[src_lo],         %[mask]       \n\t"
+      "punpckhbh  %[src_hi],       %[src],            %[zero]       \n\t"
+      "pinsrh_3   %[src_hi],       %[src_hi],         %[value]      \n\t"
+      "pmaddhw    %[src_hi],       %[src_hi],         %[mask]       \n\t"
+      "punpcklwd  %[src],          %[src_lo],         %[src_hi]     \n\t"
+      "punpckhwd  %[dest2],        %[src_lo],         %[src_hi]     \n\t"
+      "paddw      %[dest2],        %[dest2],          %[src]        \n\t"
+      "psrlw      %[dest2],        %[dest2],          %[eight]      \n\t"
+
+      "gsldlc1    %[src],          0x1f(%[src_argb])               \n\t"
+      "gsldrc1    %[src],          0x18(%[src_argb])               \n\t"
+      "punpcklbh  %[src_lo],       %[src],            %[zero]       \n\t"
+      "pinsrh_3   %[src_lo],       %[src_lo],         %[value]      \n\t"
+      "pmaddhw    %[src_lo],       %[src_lo],         %[mask]       \n\t"
+      "punpckhbh  %[src_hi],       %[src],            %[zero]       \n\t"
+      "pinsrh_3   %[src_hi],       %[src_hi],         %[value]      \n\t"
+      "pmaddhw    %[src_hi],       %[src_hi],         %[mask]       \n\t"
+      "punpcklwd  %[src],          %[src_lo],         %[src_hi]     \n\t"
+      "punpckhwd  %[dest3],        %[src_lo],         %[src_hi]     \n\t"
+      "paddw      %[dest3],        %[dest3],          %[src]        \n\t"
+      "psrlw      %[dest3],        %[dest3],          %[eight]      \n\t"
+
+      "packsswh   %[src_lo],       %[dest0],          %[dest1]      \n\t"
+      "packsswh   %[src_hi],       %[dest2],          %[dest3]      \n\t"
+      "packushb   %[dest0],        %[src_lo],         %[src_hi]     \n\t"
+      "gssdlc1    %[dest0],        0x07(%[dst_y])                   \n\t"
+      "gssdrc1    %[dest0],        0x00(%[dst_y])                   \n\t"
+
+      "daddiu     %[src_argb],    %[src_argb],      0x20          \n\t"
+      "daddiu     %[dst_y],        %[dst_y],          0x08          \n\t"
+      "daddi      %[width],        %[width],         -0x08          \n\t"
+      "bnez       %[width],        1b                               \n\t"
+      : [src] "=&f"(src), [src_hi] "=&f"(src_hi), [src_lo] "=&f"(src_lo),
+        [dest0] "=&f"(dest0), [dest1] "=&f"(dest1), [dest2] "=&f"(dest2),
+        [dest3] "=&f"(dest3)
+      : [src_argb] "r"(src_argb), [dst_y] "r"(dst_y), [width] "r"(width),
+        [mask] "f"(mask), [value] "f"(value), [eight] "f"(0x08),
+        [zero] "f"(0x00)
+      : "memory");
+}
+
+void ARGBToUVRow_MMI(const uint8_t* src_rgb,
+                     int src_stride_rgb,
+                     uint8_t* dst_u,
+                     uint8_t* dst_v,
+                     int width) {
+  uint64_t src_rgb1;
+  uint64_t ftmp[13];
+  uint64_t tmp[1];
+  const uint64_t value = 0x4040;
+  const uint64_t mask_u = 0x0013002500380002;
+  const uint64_t mask_v = 0x00020038002f0009;
+
+  __asm__ volatile(
+      "dli        %[tmp0],         0x0001000100010001                   \n\t"
+      "dmtc1      %[tmp0],         %[ftmp12]                            \n\t"
+      "1:                                                               \n\t"
+      "daddu      %[src_rgb1],     %[src_rgb],       %[src_stride_rgb] \n\t"
+      "gsldrc1    %[src0],         0x00(%[src_rgb])                    \n\t"
+      "gsldlc1    %[src0],         0x07(%[src_rgb])                    \n\t"
+      "gsldrc1    %[src1],         0x00(%[src_rgb1])                    \n\t"
+      "gsldlc1    %[src1],         0x07(%[src_rgb1])                    \n\t"
+      "punpcklbh  %[src_lo],       %[src0],           %[zero]           \n\t"
+      "punpckhbh  %[src_hi],       %[src0],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src_lo],         %[src_hi]         \n\t"
+      "punpcklbh  %[src_lo],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_lo]         \n\t"
+      "punpckhbh  %[src_hi],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_hi]         \n\t"
+      "paddh      %[src0],         %[src0],           %[ftmp12]         \n\t"
+      "psrlh      %[src0],         %[src0],           %[one]            \n\t"
+      "dsll       %[dest0_u],      %[src0],           %[sixteen]        \n\t"
+      "pinsrh_0   %[dest0_u],      %[dest0_u],        %[value]          \n\t"
+      "pinsrh_3   %[dest0_v],      %[src0],           %[value]          \n\t"
+      "pmaddhw    %[dest0_u],      %[dest0_u],        %[mask_u]         \n\t"
+      "pmaddhw    %[dest0_v],      %[dest0_v],        %[mask_v]         \n\t"
+
+      "gsldrc1    %[src0],         0x08(%[src_rgb])                    \n\t"
+      "gsldlc1    %[src0],         0x0f(%[src_rgb])                    \n\t"
+      "gsldrc1    %[src1],         0x08(%[src_rgb1])                    \n\t"
+      "gsldlc1    %[src1],         0x0f(%[src_rgb1])                    \n\t"
+      "punpcklbh  %[src_lo],       %[src0],           %[zero]           \n\t"
+      "punpckhbh  %[src_hi],       %[src0],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src_lo],         %[src_hi]         \n\t"
+      "punpcklbh  %[src_lo],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_lo]         \n\t"
+      "punpckhbh  %[src_hi],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_hi]         \n\t"
+      "paddh      %[src0],         %[src0],           %[ftmp12]         \n\t"
+      "psrlh      %[src0],         %[src0],           %[one]            \n\t"
+      "dsll       %[src_lo],       %[src0],           %[sixteen]        \n\t"
+      "pinsrh_0   %[src_lo],       %[src_lo],         %[value]          \n\t"
+      "pinsrh_3   %[src_hi],       %[src0],           %[value]          \n\t"
+      "pmaddhw    %[src_lo],       %[src_lo],         %[mask_u]         \n\t"
+      "pmaddhw    %[src_hi],       %[src_hi],         %[mask_v]         \n\t"
+
+      "punpcklwd  %[src0],         %[dest0_u],        %[src_lo]         \n\t"
+      "punpckhwd  %[src1],         %[dest0_u],        %[src_lo]         \n\t"
+      "psubw      %[dest0_u],      %[src0],           %[src1]           \n\t"
+      "psraw      %[dest0_u],      %[dest0_u],        %[eight]          \n\t"
+      "punpcklwd  %[src0],         %[dest0_v],        %[src_hi]         \n\t"
+      "punpckhwd  %[src1],         %[dest0_v],        %[src_hi]         \n\t"
+      "psubw      %[dest0_v],      %[src1],           %[src0]           \n\t"
+      "psraw      %[dest0_v],      %[dest0_v],        %[eight]          \n\t"
+
+      "gsldrc1    %[src0],         0x10(%[src_rgb])                    \n\t"
+      "gsldlc1    %[src0],         0x17(%[src_rgb])                    \n\t"
+      "gsldrc1    %[src1],         0x10(%[src_rgb1])                    \n\t"
+      "gsldlc1    %[src1],         0x17(%[src_rgb1])                    \n\t"
+      "punpcklbh  %[src_lo],       %[src0],           %[zero]           \n\t"
+      "punpckhbh  %[src_hi],       %[src0],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src_lo],         %[src_hi]         \n\t"
+      "punpcklbh  %[src_lo],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_lo]         \n\t"
+      "punpckhbh  %[src_hi],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_hi]         \n\t"
+      "paddh      %[src0],         %[src0],           %[ftmp12]         \n\t"
+      "psrlh      %[src0],         %[src0],           %[one]            \n\t"
+      "dsll       %[dest1_u],      %[src0],           %[sixteen]        \n\t"
+      "pinsrh_0   %[dest1_u],      %[dest1_u],        %[value]          \n\t"
+      "pinsrh_3   %[dest1_v],      %[src0],           %[value]          \n\t"
+      "pmaddhw    %[dest1_u],      %[dest1_u],        %[mask_u]         \n\t"
+      "pmaddhw    %[dest1_v],      %[dest1_v],        %[mask_v]         \n\t"
+
+      "gsldrc1    %[src0],         0x18(%[src_rgb])                    \n\t"
+      "gsldlc1    %[src0],         0x1f(%[src_rgb])                    \n\t"
+      "gsldrc1    %[src1],         0x18(%[src_rgb1])                    \n\t"
+      "gsldlc1    %[src1],         0x1f(%[src_rgb1])                    \n\t"
+      "punpcklbh  %[src_lo],       %[src0],           %[zero]           \n\t"
+      "punpckhbh  %[src_hi],       %[src0],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src_lo],         %[src_hi]         \n\t"
+      "punpcklbh  %[src_lo],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_lo]         \n\t"
+      "punpckhbh  %[src_hi],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_hi]         \n\t"
+      "paddh      %[src0],         %[src0],           %[ftmp12]         \n\t"
+      "psrlh      %[src0],         %[src0],           %[one]            \n\t"
+      "dsll       %[src_lo],       %[src0],           %[sixteen]        \n\t"
+      "pinsrh_0   %[src_lo],       %[src_lo],         %[value]          \n\t"
+      "pinsrh_3   %[src_hi],       %[src0],           %[value]          \n\t"
+      "pmaddhw    %[src_lo],       %[src_lo],         %[mask_u]         \n\t"
+      "pmaddhw    %[src_hi],       %[src_hi],         %[mask_v]         \n\t"
+
+      "punpcklwd  %[src0],         %[dest1_u],        %[src_lo]         \n\t"
+      "punpckhwd  %[src1],         %[dest1_u],        %[src_lo]         \n\t"
+      "psubw      %[dest1_u],      %[src0],           %[src1]           \n\t"
+      "psraw      %[dest1_u],      %[dest1_u],        %[eight]          \n\t"
+      "punpcklwd  %[src0],         %[dest1_v],        %[src_hi]         \n\t"
+      "punpckhwd  %[src1],         %[dest1_v],        %[src_hi]         \n\t"
+      "psubw      %[dest1_v],      %[src1],           %[src0]           \n\t"
+      "psraw      %[dest1_v],      %[dest1_v],        %[eight]          \n\t"
+
+      "gsldrc1    %[src0],         0x20(%[src_rgb])                    \n\t"
+      "gsldlc1    %[src0],         0x27(%[src_rgb])                    \n\t"
+      "gsldrc1    %[src1],         0x20(%[src_rgb1])                    \n\t"
+      "gsldlc1    %[src1],         0x27(%[src_rgb1])                    \n\t"
+      "punpcklbh  %[src_lo],       %[src0],           %[zero]           \n\t"
+      "punpckhbh  %[src_hi],       %[src0],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src_lo],         %[src_hi]         \n\t"
+      "punpcklbh  %[src_lo],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_lo]         \n\t"
+      "punpckhbh  %[src_hi],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_hi]         \n\t"
+      "paddh      %[src0],         %[src0],           %[ftmp12]         \n\t"
+      "psrlh      %[src0],         %[src0],           %[one]            \n\t"
+      "dsll       %[dest2_u],      %[src0],           %[sixteen]        \n\t"
+      "pinsrh_0   %[dest2_u],      %[dest2_u],        %[value]          \n\t"
+      "pinsrh_3   %[dest2_v],      %[src0],           %[value]          \n\t"
+      "pmaddhw    %[dest2_u],      %[dest2_u],        %[mask_u]         \n\t"
+      "pmaddhw    %[dest2_v],      %[dest2_v],        %[mask_v]         \n\t"
+
+      "gsldrc1    %[src0],         0x28(%[src_rgb])                    \n\t"
+      "gsldlc1    %[src0],         0x2f(%[src_rgb])                    \n\t"
+      "gsldrc1    %[src1],         0x28(%[src_rgb1])                    \n\t"
+      "gsldlc1    %[src1],         0x2f(%[src_rgb1])                    \n\t"
+      "punpcklbh  %[src_lo],       %[src0],           %[zero]           \n\t"
+      "punpckhbh  %[src_hi],       %[src0],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src_lo],         %[src_hi]         \n\t"
+      "punpcklbh  %[src_lo],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_lo]         \n\t"
+      "punpckhbh  %[src_hi],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_hi]         \n\t"
+      "paddh      %[src0],         %[src0],           %[ftmp12]         \n\t"
+      "psrlh      %[src0],         %[src0],           %[one]            \n\t"
+      "dsll       %[src_lo],       %[src0],           %[sixteen]        \n\t"
+      "pinsrh_0   %[src_lo],       %[src_lo],         %[value]          \n\t"
+      "pinsrh_3   %[src_hi],       %[src0],           %[value]          \n\t"
+      "pmaddhw    %[src_lo],       %[src_lo],         %[mask_u]         \n\t"
+      "pmaddhw    %[src_hi],       %[src_hi],         %[mask_v]         \n\t"
+
+      "punpcklwd  %[src0],         %[dest2_u],        %[src_lo]         \n\t"
+      "punpckhwd  %[src1],         %[dest2_u],        %[src_lo]         \n\t"
+      "psubw      %[dest2_u],      %[src0],           %[src1]           \n\t"
+      "psraw      %[dest2_u],      %[dest2_u],        %[eight]          \n\t"
+      "punpcklwd  %[src0],         %[dest2_v],        %[src_hi]         \n\t"
+      "punpckhwd  %[src1],         %[dest2_v],        %[src_hi]         \n\t"
+      "psubw      %[dest2_v],      %[src1],           %[src0]           \n\t"
+      "psraw      %[dest2_v],      %[dest2_v],        %[eight]          \n\t"
+
+      "gsldrc1    %[src0],         0x30(%[src_rgb])                    \n\t"
+      "gsldlc1    %[src0],         0x37(%[src_rgb])                    \n\t"
+      "gsldrc1    %[src1],         0x30(%[src_rgb1])                    \n\t"
+      "gsldlc1    %[src1],         0x37(%[src_rgb1])                    \n\t"
+      "punpcklbh  %[src_lo],       %[src0],           %[zero]           \n\t"
+      "punpckhbh  %[src_hi],       %[src0],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src_lo],         %[src_hi]         \n\t"
+      "punpcklbh  %[src_lo],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_lo]         \n\t"
+      "punpckhbh  %[src_hi],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_hi]         \n\t"
+      "paddh      %[src0],         %[src0],           %[ftmp12]         \n\t"
+      "psrlh      %[src0],         %[src0],           %[one]            \n\t"
+      "dsll       %[dest3_u],      %[src0],           %[sixteen]        \n\t"
+      "pinsrh_0   %[dest3_u],      %[dest3_u],        %[value]          \n\t"
+      "pinsrh_3   %[dest3_v],      %[src0],           %[value]          \n\t"
+      "pmaddhw    %[dest3_u],      %[dest3_u],        %[mask_u]         \n\t"
+      "pmaddhw    %[dest3_v],      %[dest3_v],        %[mask_v]         \n\t"
+
+      "gsldrc1    %[src0],         0x38(%[src_rgb])                    \n\t"
+      "gsldlc1    %[src0],         0x3f(%[src_rgb])                    \n\t"
+      "gsldrc1    %[src1],         0x38(%[src_rgb1])                    \n\t"
+      "gsldlc1    %[src1],         0x3f(%[src_rgb1])                    \n\t"
+      "punpcklbh  %[src_lo],       %[src0],           %[zero]           \n\t"
+      "punpckhbh  %[src_hi],       %[src0],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src_lo],         %[src_hi]         \n\t"
+      "punpcklbh  %[src_lo],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_lo]         \n\t"
+      "punpckhbh  %[src_hi],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_hi]         \n\t"
+      "paddh      %[src0],         %[src0],           %[ftmp12]         \n\t"
+      "psrlh      %[src0],         %[src0],           %[one]            \n\t"
+      "dsll       %[src_lo],       %[src0],           %[sixteen]        \n\t"
+      "pinsrh_0   %[src_lo],       %[src_lo],         %[value]          \n\t"
+      "pinsrh_3   %[src_hi],       %[src0],           %[value]          \n\t"
+      "pmaddhw    %[src_lo],       %[src_lo],         %[mask_u]         \n\t"
+      "pmaddhw    %[src_hi],       %[src_hi],         %[mask_v]         \n\t"
+
+      "punpcklwd  %[src0],         %[dest3_u],        %[src_lo]         \n\t"
+      "punpckhwd  %[src1],         %[dest3_u],        %[src_lo]         \n\t"
+      "psubw      %[dest3_u],      %[src0],           %[src1]           \n\t"
+      "psraw      %[dest3_u],      %[dest3_u],        %[eight]          \n\t"
+      "punpcklwd  %[src0],         %[dest3_v],        %[src_hi]         \n\t"
+      "punpckhwd  %[src1],         %[dest3_v],        %[src_hi]         \n\t"
+      "psubw      %[dest3_v],      %[src1],           %[src0]           \n\t"
+      "psraw      %[dest3_v],      %[dest3_v],        %[eight]          \n\t"
+
+      "packsswh   %[src0],         %[dest0_u],        %[dest1_u]        \n\t"
+      "packsswh   %[src1],         %[dest2_u],        %[dest3_u]        \n\t"
+      "packushb   %[dest0_u],      %[src0],           %[src1]           \n\t"
+      "gssdlc1    %[dest0_u],      0x07(%[dst_u])                       \n\t"
+      "gssdrc1    %[dest0_u],      0x00(%[dst_u])                       \n\t"
+
+      "packsswh   %[src0],         %[dest0_v],        %[dest1_v]        \n\t"
+      "packsswh   %[src1],         %[dest2_v],        %[dest3_v]        \n\t"
+      "packushb   %[dest0_v],      %[src0],           %[src1]           \n\t"
+      "gssdlc1    %[dest0_v],      0x07(%[dst_v])                       \n\t"
+      "gssdrc1    %[dest0_v],      0x00(%[dst_v])                       \n\t"
+
+      "daddiu     %[src_rgb],     %[src_rgb],       0x40              \n\t"
+      "daddiu     %[dst_u],        %[dst_u],          0x08              \n\t"
+      "daddiu     %[dst_v],        %[dst_v],          0x08              \n\t"
+      "daddi      %[width],        %[width],         -0x10              \n\t"
+      "bgtz       %[width],        1b                                   \n\t"
+      : [src_rgb1] "=&r"(src_rgb1), [src0] "=&f"(ftmp[0]),
+        [src1] "=&f"(ftmp[1]), [src_lo] "=&f"(ftmp[2]), [src_hi] "=&f"(ftmp[3]),
+        [dest0_u] "=&f"(ftmp[4]), [dest0_v] "=&f"(ftmp[5]),
+        [dest1_u] "=&f"(ftmp[6]), [dest1_v] "=&f"(ftmp[7]),
+        [dest2_u] "=&f"(ftmp[8]), [dest2_v] "=&f"(ftmp[9]),
+        [dest3_u] "=&f"(ftmp[10]), [dest3_v] "=&f"(ftmp[11]),
+        [ftmp12] "=&f"(ftmp[12]), [tmp0] "=&r"(tmp[0])
+      : [src_rgb] "r"(src_rgb), [src_stride_rgb] "r"(src_stride_rgb),
+        [dst_u] "r"(dst_u), [dst_v] "r"(dst_v), [width] "r"(width),
+        [mask_u] "f"(mask_u), [mask_v] "f"(mask_v), [value] "f"(value),
+        [zero] "f"(0x00), [eight] "f"(0x08), [one] "f"(0x01),
+        [sixteen] "f"(0x10)
+      : "memory");
+}
+
+void BGRAToYRow_MMI(const uint8_t* src_argb, uint8_t* dst_y, int width) {
+  uint64_t src, src_hi, src_lo;
+  uint64_t dest0, dest1, dest2, dest3;
+  const uint64_t value = 0x1080;
+  const uint64_t mask = 0x0019008100420001;
+
+  __asm__ volatile(
+      "1:                                                           \n\t"
+      "gsldlc1    %[src],          0x07(%[src_argb])               \n\t"
+      "gsldrc1    %[src],          0x00(%[src_argb])               \n\t"
+      "punpcklbh  %[src_lo],       %[src],            %[zero]       \n\t"
+      "pinsrh_0   %[src_lo],       %[src_lo],         %[value]      \n\t"
+      "pmaddhw    %[src_lo],       %[src_lo],         %[mask]       \n\t"
+      "punpckhbh  %[src_hi],       %[src],            %[zero]       \n\t"
+      "pinsrh_0   %[src_hi],       %[src_hi],         %[value]      \n\t"
+      "pmaddhw    %[src_hi],       %[src_hi],         %[mask]       \n\t"
+      "punpcklwd  %[src],          %[src_lo],         %[src_hi]     \n\t"
+      "punpckhwd  %[dest0],        %[src_lo],         %[src_hi]     \n\t"
+      "paddw      %[dest0],        %[dest0],          %[src]        \n\t"
+      "psrlw      %[dest0],        %[dest0],          %[eight]      \n\t"
+
+      "gsldlc1    %[src],          0x0f(%[src_argb])               \n\t"
+      "gsldrc1    %[src],          0x08(%[src_argb])               \n\t"
+      "punpcklbh  %[src_lo],       %[src],            %[zero]       \n\t"
+      "pinsrh_0   %[src_lo],       %[src_lo],         %[value]      \n\t"
+      "pmaddhw    %[src_lo],       %[src_lo],         %[mask]       \n\t"
+      "punpckhbh  %[src_hi],       %[src],            %[zero]       \n\t"
+      "pinsrh_0   %[src_hi],       %[src_hi],         %[value]      \n\t"
+      "pmaddhw    %[src_hi],       %[src_hi],         %[mask]       \n\t"
+      "punpcklwd  %[src],          %[src_lo],         %[src_hi]     \n\t"
+      "punpckhwd  %[dest1],        %[src_lo],         %[src_hi]     \n\t"
+      "paddw      %[dest1],        %[dest1],          %[src]        \n\t"
+      "psrlw      %[dest1],        %[dest1],          %[eight]      \n\t"
+
+      "gsldlc1    %[src],          0x17(%[src_argb])               \n\t"
+      "gsldrc1    %[src],          0x10(%[src_argb])               \n\t"
+      "punpcklbh  %[src_lo],       %[src],            %[zero]       \n\t"
+      "pinsrh_0   %[src_lo],       %[src_lo],         %[value]      \n\t"
+      "pmaddhw    %[src_lo],       %[src_lo],         %[mask]       \n\t"
+      "punpckhbh  %[src_hi],       %[src],            %[zero]       \n\t"
+      "pinsrh_0   %[src_hi],       %[src_hi],         %[value]      \n\t"
+      "pmaddhw    %[src_hi],       %[src_hi],         %[mask]       \n\t"
+      "punpcklwd  %[src],          %[src_lo],         %[src_hi]     \n\t"
+      "punpckhwd  %[dest2],        %[src_lo],         %[src_hi]     \n\t"
+      "paddw      %[dest2],        %[dest2],          %[src]        \n\t"
+      "psrlw      %[dest2],        %[dest2],          %[eight]      \n\t"
+
+      "gsldlc1    %[src],          0x1f(%[src_argb])               \n\t"
+      "gsldrc1    %[src],          0x18(%[src_argb])               \n\t"
+      "punpcklbh  %[src_lo],       %[src],            %[zero]       \n\t"
+      "pinsrh_0   %[src_lo],       %[src_lo],         %[value]      \n\t"
+      "pmaddhw    %[src_lo],       %[src_lo],         %[mask]       \n\t"
+      "punpckhbh  %[src_hi],       %[src],            %[zero]       \n\t"
+      "pinsrh_0   %[src_hi],       %[src_hi],         %[value]      \n\t"
+      "pmaddhw    %[src_hi],       %[src_hi],         %[mask]       \n\t"
+      "punpcklwd  %[src],          %[src_lo],         %[src_hi]     \n\t"
+      "punpckhwd  %[dest3],        %[src_lo],         %[src_hi]     \n\t"
+      "paddw      %[dest3],        %[dest3],          %[src]        \n\t"
+      "psrlw      %[dest3],        %[dest3],          %[eight]      \n\t"
+
+      "packsswh   %[src_lo],       %[dest0],          %[dest1]      \n\t"
+      "packsswh   %[src_hi],       %[dest2],          %[dest3]      \n\t"
+      "packushb   %[dest0],        %[src_lo],         %[src_hi]     \n\t"
+      "gssdlc1    %[dest0],        0x07(%[dst_y])                   \n\t"
+      "gssdrc1    %[dest0],        0x00(%[dst_y])                   \n\t"
+
+      "daddiu     %[src_argb],    %[src_argb],      0x20          \n\t"
+      "daddiu     %[dst_y],        %[dst_y],          0x08          \n\t"
+      "daddi      %[width],        %[width],         -0x08          \n\t"
+      "bnez       %[width],        1b                               \n\t"
+      : [src] "=&f"(src), [src_hi] "=&f"(src_hi), [src_lo] "=&f"(src_lo),
+        [dest0] "=&f"(dest0), [dest1] "=&f"(dest1), [dest2] "=&f"(dest2),
+        [dest3] "=&f"(dest3)
+      : [src_argb] "r"(src_argb), [dst_y] "r"(dst_y), [width] "r"(width),
+        [mask] "f"(mask), [value] "f"(value), [eight] "f"(0x08),
+        [zero] "f"(0x00)
+      : "memory");
+}
+
+void BGRAToUVRow_MMI(const uint8_t* src_rgb,
+                     int src_stride_rgb,
+                     uint8_t* dst_u,
+                     uint8_t* dst_v,
+                     int width) {
+  uint64_t src_rgb1;
+  uint64_t ftmp[13];
+  uint64_t tmp[1];
+  const uint64_t value = 0x4040;
+  const uint64_t mask_u = 0x0002003800250013;
+  const uint64_t mask_v = 0x0009002f00380002;
+
+  __asm__ volatile(
+      "dli        %[tmp0],         0x0001000100010001                   \n\t"
+      "dmtc1      %[tmp0],         %[ftmp12]                            \n\t"
+      "1:                                                               \n\t"
+      "daddu      %[src_rgb1],     %[src_rgb],       %[src_stride_rgb] \n\t"
+      "gsldrc1    %[src0],         0x00(%[src_rgb])                    \n\t"
+      "gsldlc1    %[src0],         0x07(%[src_rgb])                    \n\t"
+      "gsldrc1    %[src1],         0x00(%[src_rgb1])                    \n\t"
+      "gsldlc1    %[src1],         0x07(%[src_rgb1])                    \n\t"
+      "punpcklbh  %[src_lo],       %[src0],           %[zero]           \n\t"
+      "punpckhbh  %[src_hi],       %[src0],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src_lo],         %[src_hi]         \n\t"
+      "punpcklbh  %[src_lo],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_lo]         \n\t"
+      "punpckhbh  %[src_hi],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_hi]         \n\t"
+      "paddh      %[src0],         %[src0],           %[ftmp12]         \n\t"
+      "psrlh      %[src0],         %[src0],           %[one]            \n\t"
+      "dsrl       %[dest0_u],      %[src0],           %[sixteen]        \n\t"
+      "pinsrh_3   %[dest0_u],      %[dest0_u],        %[value]          \n\t"
+      "pinsrh_0   %[dest0_v],      %[src0],           %[value]          \n\t"
+      "pmaddhw    %[dest0_u],      %[dest0_u],        %[mask_u]         \n\t"
+      "pmaddhw    %[dest0_v],      %[dest0_v],        %[mask_v]         \n\t"
+
+      "gsldrc1    %[src0],         0x08(%[src_rgb])                    \n\t"
+      "gsldlc1    %[src0],         0x0f(%[src_rgb])                    \n\t"
+      "gsldrc1    %[src1],         0x08(%[src_rgb1])                    \n\t"
+      "gsldlc1    %[src1],         0x0f(%[src_rgb1])                    \n\t"
+      "punpcklbh  %[src_lo],       %[src0],           %[zero]           \n\t"
+      "punpckhbh  %[src_hi],       %[src0],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src_lo],         %[src_hi]         \n\t"
+      "punpcklbh  %[src_lo],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_lo]         \n\t"
+      "punpckhbh  %[src_hi],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_hi]         \n\t"
+      "paddh      %[src0],         %[src0],           %[ftmp12]         \n\t"
+      "psrlh      %[src0],         %[src0],           %[one]            \n\t"
+      "dsrl       %[src_lo],       %[src0],           %[sixteen]        \n\t"
+      "pinsrh_3   %[src_lo],       %[src_lo],         %[value]          \n\t"
+      "pinsrh_0   %[src_hi],       %[src0],           %[value]          \n\t"
+      "pmaddhw    %[src_lo],       %[src_lo],         %[mask_u]         \n\t"
+      "pmaddhw    %[src_hi],       %[src_hi],         %[mask_v]         \n\t"
+
+      "punpcklwd  %[src0],         %[dest0_u],        %[src_lo]         \n\t"
+      "punpckhwd  %[src1],         %[dest0_u],        %[src_lo]         \n\t"
+      "psubw      %[dest0_u],      %[src1],           %[src0]           \n\t"
+      "psraw      %[dest0_u],      %[dest0_u],        %[eight]          \n\t"
+      "punpcklwd  %[src0],         %[dest0_v],        %[src_hi]         \n\t"
+      "punpckhwd  %[src1],         %[dest0_v],        %[src_hi]         \n\t"
+      "psubw      %[dest0_v],      %[src0],           %[src1]           \n\t"
+      "psraw      %[dest0_v],      %[dest0_v],        %[eight]          \n\t"
+
+      "gsldrc1    %[src0],         0x10(%[src_rgb])                    \n\t"
+      "gsldlc1    %[src0],         0x17(%[src_rgb])                    \n\t"
+      "gsldrc1    %[src1],         0x10(%[src_rgb1])                    \n\t"
+      "gsldlc1    %[src1],         0x17(%[src_rgb1])                    \n\t"
+      "punpcklbh  %[src_lo],       %[src0],           %[zero]           \n\t"
+      "punpckhbh  %[src_hi],       %[src0],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src_lo],         %[src_hi]         \n\t"
+      "punpcklbh  %[src_lo],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_lo]         \n\t"
+      "punpckhbh  %[src_hi],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_hi]         \n\t"
+      "paddh      %[src0],         %[src0],           %[ftmp12]         \n\t"
+      "psrlh      %[src0],         %[src0],           %[one]            \n\t"
+      "dsrl       %[dest1_u],      %[src0],           %[sixteen]        \n\t"
+      "pinsrh_3   %[dest1_u],      %[dest1_u],        %[value]          \n\t"
+      "pinsrh_0   %[dest1_v],      %[src0],           %[value]          \n\t"
+      "pmaddhw    %[dest1_u],      %[dest1_u],        %[mask_u]         \n\t"
+      "pmaddhw    %[dest1_v],      %[dest1_v],        %[mask_v]         \n\t"
+
+      "gsldrc1    %[src0],         0x18(%[src_rgb])                    \n\t"
+      "gsldlc1    %[src0],         0x1f(%[src_rgb])                    \n\t"
+      "gsldrc1    %[src1],         0x18(%[src_rgb1])                    \n\t"
+      "gsldlc1    %[src1],         0x1f(%[src_rgb1])                    \n\t"
+      "punpcklbh  %[src_lo],       %[src0],           %[zero]           \n\t"
+      "punpckhbh  %[src_hi],       %[src0],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src_lo],         %[src_hi]         \n\t"
+      "punpcklbh  %[src_lo],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_lo]         \n\t"
+      "punpckhbh  %[src_hi],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_hi]         \n\t"
+      "paddh      %[src0],         %[src0],           %[ftmp12]         \n\t"
+      "psrlh      %[src0],         %[src0],           %[one]            \n\t"
+      "dsrl       %[src_lo],       %[src0],           %[sixteen]        \n\t"
+      "pinsrh_3   %[src_lo],       %[src_lo],         %[value]          \n\t"
+      "pinsrh_0   %[src_hi],       %[src0],           %[value]          \n\t"
+      "pmaddhw    %[src_lo],       %[src_lo],         %[mask_u]         \n\t"
+      "pmaddhw    %[src_hi],       %[src_hi],         %[mask_v]         \n\t"
+
+      "punpcklwd  %[src0],         %[dest1_u],        %[src_lo]         \n\t"
+      "punpckhwd  %[src1],         %[dest1_u],        %[src_lo]         \n\t"
+      "psubw      %[dest1_u],      %[src1],           %[src0]           \n\t"
+      "psraw      %[dest1_u],      %[dest1_u],        %[eight]          \n\t"
+      "punpcklwd  %[src0],         %[dest1_v],        %[src_hi]         \n\t"
+      "punpckhwd  %[src1],         %[dest1_v],        %[src_hi]         \n\t"
+      "psubw      %[dest1_v],      %[src0],           %[src1]           \n\t"
+      "psraw      %[dest1_v],      %[dest1_v],        %[eight]          \n\t"
+
+      "gsldrc1    %[src0],         0x20(%[src_rgb])                    \n\t"
+      "gsldlc1    %[src0],         0x27(%[src_rgb])                    \n\t"
+      "gsldrc1    %[src1],         0x20(%[src_rgb1])                    \n\t"
+      "gsldlc1    %[src1],         0x27(%[src_rgb1])                    \n\t"
+      "punpcklbh  %[src_lo],       %[src0],           %[zero]           \n\t"
+      "punpckhbh  %[src_hi],       %[src0],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src_lo],         %[src_hi]         \n\t"
+      "punpcklbh  %[src_lo],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_lo]         \n\t"
+      "punpckhbh  %[src_hi],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_hi]         \n\t"
+      "paddh      %[src0],         %[src0],           %[ftmp12]         \n\t"
+      "psrlh      %[src0],         %[src0],           %[one]            \n\t"
+      "dsrl       %[dest2_u],      %[src0],           %[sixteen]        \n\t"
+      "pinsrh_3   %[dest2_u],      %[dest2_u],        %[value]          \n\t"
+      "pinsrh_0   %[dest2_v],      %[src0],           %[value]          \n\t"
+      "pmaddhw    %[dest2_u],      %[dest2_u],        %[mask_u]         \n\t"
+      "pmaddhw    %[dest2_v],      %[dest2_v],        %[mask_v]         \n\t"
+
+      "gsldrc1    %[src0],         0x28(%[src_rgb])                    \n\t"
+      "gsldlc1    %[src0],         0x2f(%[src_rgb])                    \n\t"
+      "gsldrc1    %[src1],         0x28(%[src_rgb1])                    \n\t"
+      "gsldlc1    %[src1],         0x2f(%[src_rgb1])                    \n\t"
+      "punpcklbh  %[src_lo],       %[src0],           %[zero]           \n\t"
+      "punpckhbh  %[src_hi],       %[src0],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src_lo],         %[src_hi]         \n\t"
+      "punpcklbh  %[src_lo],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_lo]        \n\t"
+      "punpckhbh  %[src_hi],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_hi]         \n\t"
+      "paddh      %[src0],         %[src0],           %[ftmp12]         \n\t"
+      "psrlh      %[src0],         %[src0],           %[one]            \n\t"
+      "dsrl       %[src_lo],       %[src0],           %[sixteen]        \n\t"
+      "pinsrh_3   %[src_lo],       %[src_lo],         %[value]          \n\t"
+      "pinsrh_0   %[src_hi],       %[src0],           %[value]          \n\t"
+      "pmaddhw    %[src_lo],       %[src_lo],         %[mask_u]         \n\t"
+      "pmaddhw    %[src_hi],       %[src_hi],         %[mask_v]         \n\t"
+
+      "punpcklwd  %[src0],         %[dest2_u],        %[src_lo]         \n\t"
+      "punpckhwd  %[src1],         %[dest2_u],        %[src_lo]         \n\t"
+      "psubw      %[dest2_u],      %[src1],           %[src0]           \n\t"
+      "psraw      %[dest2_u],      %[dest2_u],        %[eight]          \n\t"
+      "punpcklwd  %[src0],         %[dest2_v],        %[src_hi]         \n\t"
+      "punpckhwd  %[src1],         %[dest2_v],        %[src_hi]         \n\t"
+      "psubw      %[dest2_v],      %[src0],           %[src1]           \n\t"
+      "psraw      %[dest2_v],      %[dest2_v],        %[eight]          \n\t"
+
+      "gsldrc1    %[src0],         0x30(%[src_rgb])                    \n\t"
+      "gsldlc1    %[src0],         0x37(%[src_rgb])                    \n\t"
+      "gsldrc1    %[src1],         0x30(%[src_rgb1])                    \n\t"
+      "gsldlc1    %[src1],         0x37(%[src_rgb1])                    \n\t"
+      "punpcklbh  %[src_lo],       %[src0],           %[zero]           \n\t"
+      "punpckhbh  %[src_hi],       %[src0],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src_lo],         %[src_hi]         \n\t"
+      "punpcklbh  %[src_lo],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_lo]         \n\t"
+      "punpckhbh  %[src_hi],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_hi]         \n\t"
+      "paddh      %[src0],         %[src0],           %[ftmp12]         \n\t"
+      "psrlh      %[src0],         %[src0],           %[one]            \n\t"
+      "dsrl       %[dest3_u],      %[src0],           %[sixteen]        \n\t"
+      "pinsrh_3   %[dest3_u],      %[dest3_u],        %[value]          \n\t"
+      "pinsrh_0   %[dest3_v],      %[src0],           %[value]          \n\t"
+      "pmaddhw    %[dest3_u],      %[dest3_u],        %[mask_u]         \n\t"
+      "pmaddhw    %[dest3_v],      %[dest3_v],        %[mask_v]         \n\t"
+
+      "gsldrc1    %[src0],         0x38(%[src_rgb])                    \n\t"
+      "gsldlc1    %[src0],         0x3f(%[src_rgb])                    \n\t"
+      "gsldrc1    %[src1],         0x38(%[src_rgb1])                    \n\t"
+      "gsldlc1    %[src1],         0x3f(%[src_rgb1])                    \n\t"
+      "punpcklbh  %[src_lo],       %[src0],           %[zero]           \n\t"
+      "punpckhbh  %[src_hi],       %[src0],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src_lo],         %[src_hi]         \n\t"
+      "punpcklbh  %[src_lo],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_lo]         \n\t"
+      "punpckhbh  %[src_hi],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_hi]         \n\t"
+      "paddh      %[src0],         %[src0],           %[ftmp12]         \n\t"
+      "psrlh      %[src0],         %[src0],           %[one]            \n\t"
+      "dsrl       %[src_lo],       %[src0],           %[sixteen]        \n\t"
+      "pinsrh_3   %[src_lo],       %[src_lo],         %[value]          \n\t"
+      "pinsrh_0   %[src_hi],       %[src0],           %[value]          \n\t"
+      "pmaddhw    %[src_lo],       %[src_lo],         %[mask_u]         \n\t"
+      "pmaddhw    %[src_hi],       %[src_hi],         %[mask_v]         \n\t"
+
+      "punpcklwd  %[src0],         %[dest3_u],        %[src_lo]         \n\t"
+      "punpckhwd  %[src1],         %[dest3_u],        %[src_lo]         \n\t"
+      "psubw      %[dest3_u],      %[src1],           %[src0]           \n\t"
+      "psraw      %[dest3_u],      %[dest3_u],        %[eight]          \n\t"
+      "punpcklwd  %[src0],         %[dest3_v],        %[src_hi]         \n\t"
+      "punpckhwd  %[src1],         %[dest3_v],        %[src_hi]         \n\t"
+      "psubw      %[dest3_v],      %[src0],           %[src1]           \n\t"
+      "psraw      %[dest3_v],      %[dest3_v],        %[eight]          \n\t"
+
+      "packsswh   %[src0],         %[dest0_u],        %[dest1_u]        \n\t"
+      "packsswh   %[src1],         %[dest2_u],        %[dest3_u]        \n\t"
+      "packushb   %[dest0_u],      %[src0],           %[src1]           \n\t"
+      "gssdlc1    %[dest0_u],      0x07(%[dst_u])                       \n\t"
+      "gssdrc1    %[dest0_u],      0x00(%[dst_u])                       \n\t"
+
+      "packsswh   %[src0],         %[dest0_v],        %[dest1_v]        \n\t"
+      "packsswh   %[src1],         %[dest2_v],        %[dest3_v]        \n\t"
+      "packushb   %[dest0_v],      %[src0],           %[src1]           \n\t"
+      "gssdlc1    %[dest0_v],      0x07(%[dst_v])                       \n\t"
+      "gssdrc1    %[dest0_v],      0x00(%[dst_v])                       \n\t"
+
+      "daddiu     %[src_rgb],     %[src_rgb],       0x40              \n\t"
+      "daddiu     %[dst_u],        %[dst_u],          0x08              \n\t"
+      "daddiu     %[dst_v],        %[dst_v],          0x08              \n\t"
+      "daddi      %[width],        %[width],         -0x10              \n\t"
+      "bgtz       %[width],        1b                                   \n\t"
+      : [src_rgb1] "=&r"(src_rgb1), [src0] "=&f"(ftmp[0]),
+        [src1] "=&f"(ftmp[1]), [src_lo] "=&f"(ftmp[2]), [src_hi] "=&f"(ftmp[3]),
+        [dest0_u] "=&f"(ftmp[4]), [dest0_v] "=&f"(ftmp[5]),
+        [dest1_u] "=&f"(ftmp[6]), [dest1_v] "=&f"(ftmp[7]),
+        [dest2_u] "=&f"(ftmp[8]), [dest2_v] "=&f"(ftmp[9]),
+        [dest3_u] "=&f"(ftmp[10]), [dest3_v] "=&f"(ftmp[11]),
+        [ftmp12] "=&f"(ftmp[12]), [tmp0] "=&r"(tmp[0])
+      : [src_rgb] "r"(src_rgb), [src_stride_rgb] "r"(src_stride_rgb),
+        [dst_u] "r"(dst_u), [dst_v] "r"(dst_v), [width] "r"(width),
+        [mask_u] "f"(mask_u), [mask_v] "f"(mask_v), [value] "f"(value),
+        [zero] "f"(0x00), [eight] "f"(0x08), [one] "f"(0x01),
+        [sixteen] "f"(0x10)
+      : "memory");
+}
+
+void ABGRToYRow_MMI(const uint8_t* src_argb, uint8_t* dst_y, int width) {
+  uint64_t src, src_hi, src_lo;
+  uint64_t dest0, dest1, dest2, dest3;
+  const uint64_t value = 0x1080;
+  const uint64_t mask = 0x0001001900810042;
+
+  __asm__ volatile(
+      "1:                                                           \n\t"
+      "gsldlc1    %[src],          0x07(%[src_argb])               \n\t"
+      "gsldrc1    %[src],          0x00(%[src_argb])               \n\t"
+      "punpcklbh  %[src_lo],       %[src],            %[zero]       \n\t"
+      "pinsrh_3   %[src_lo],       %[src_lo],         %[value]      \n\t"
+      "pmaddhw    %[src_lo],       %[src_lo],         %[mask]       \n\t"
+      "punpckhbh  %[src_hi],       %[src],            %[zero]       \n\t"
+      "pinsrh_3   %[src_hi],       %[src_hi],         %[value]      \n\t"
+      "pmaddhw    %[src_hi],       %[src_hi],         %[mask]       \n\t"
+      "punpcklwd  %[src],          %[src_lo],         %[src_hi]     \n\t"
+      "punpckhwd  %[dest0],        %[src_lo],         %[src_hi]     \n\t"
+      "paddw      %[dest0],        %[dest0],          %[src]        \n\t"
+      "psrlw      %[dest0],        %[dest0],          %[eight]      \n\t"
+
+      "gsldlc1    %[src],          0x0f(%[src_argb])               \n\t"
+      "gsldrc1    %[src],          0x08(%[src_argb])               \n\t"
+      "punpcklbh  %[src_lo],       %[src],            %[zero]       \n\t"
+      "pinsrh_3   %[src_lo],       %[src_lo],         %[value]      \n\t"
+      "pmaddhw    %[src_lo],       %[src_lo],         %[mask]       \n\t"
+      "punpckhbh  %[src_hi],       %[src],            %[zero]       \n\t"
+      "pinsrh_3   %[src_hi],       %[src_hi],         %[value]      \n\t"
+      "pmaddhw    %[src_hi],       %[src_hi],         %[mask]       \n\t"
+      "punpcklwd  %[src],          %[src_lo],         %[src_hi]     \n\t"
+      "punpckhwd  %[dest1],        %[src_lo],         %[src_hi]     \n\t"
+      "paddw      %[dest1],        %[dest1],          %[src]        \n\t"
+      "psrlw      %[dest1],        %[dest1],          %[eight]      \n\t"
+
+      "gsldlc1    %[src],          0x17(%[src_argb])               \n\t"
+      "gsldrc1    %[src],          0x10(%[src_argb])               \n\t"
+      "punpcklbh  %[src_lo],       %[src],            %[zero]       \n\t"
+      "pinsrh_3   %[src_lo],       %[src_lo],         %[value]      \n\t"
+      "pmaddhw    %[src_lo],       %[src_lo],         %[mask]       \n\t"
+      "punpckhbh  %[src_hi],       %[src],            %[zero]       \n\t"
+      "pinsrh_3   %[src_hi],       %[src_hi],         %[value]      \n\t"
+      "pmaddhw    %[src_hi],       %[src_hi],         %[mask]       \n\t"
+      "punpcklwd  %[src],          %[src_lo],         %[src_hi]     \n\t"
+      "punpckhwd  %[dest2],        %[src_lo],         %[src_hi]     \n\t"
+      "paddw      %[dest2],        %[dest2],          %[src]        \n\t"
+      "psrlw      %[dest2],        %[dest2],          %[eight]      \n\t"
+
+      "gsldlc1    %[src],          0x1f(%[src_argb])               \n\t"
+      "gsldrc1    %[src],          0x18(%[src_argb])               \n\t"
+      "punpcklbh  %[src_lo],       %[src],            %[zero]       \n\t"
+      "pinsrh_3   %[src_lo],       %[src_lo],         %[value]      \n\t"
+      "pmaddhw    %[src_lo],       %[src_lo],         %[mask]       \n\t"
+      "punpckhbh  %[src_hi],       %[src],            %[zero]       \n\t"
+      "pinsrh_3   %[src_hi],       %[src_hi],         %[value]      \n\t"
+      "pmaddhw    %[src_hi],       %[src_hi],         %[mask]       \n\t"
+      "punpcklwd  %[src],          %[src_lo],         %[src_hi]     \n\t"
+      "punpckhwd  %[dest3],        %[src_lo],         %[src_hi]     \n\t"
+      "paddw      %[dest3],        %[dest3],          %[src]        \n\t"
+      "psrlw      %[dest3],        %[dest3],          %[eight]      \n\t"
+
+      "packsswh   %[src_lo],       %[dest0],          %[dest1]      \n\t"
+      "packsswh   %[src_hi],       %[dest2],          %[dest3]      \n\t"
+      "packushb   %[dest0],        %[src_lo],         %[src_hi]     \n\t"
+      "gssdlc1    %[dest0],        0x07(%[dst_y])                   \n\t"
+      "gssdrc1    %[dest0],        0x00(%[dst_y])                   \n\t"
+
+      "daddiu     %[src_argb],    %[src_argb],      0x20          \n\t"
+      "daddiu     %[dst_y],        %[dst_y],          0x08          \n\t"
+      "daddi      %[width],        %[width],         -0x08          \n\t"
+      "bnez       %[width],        1b                               \n\t"
+      : [src] "=&f"(src), [src_hi] "=&f"(src_hi), [src_lo] "=&f"(src_lo),
+        [dest0] "=&f"(dest0), [dest1] "=&f"(dest1), [dest2] "=&f"(dest2),
+        [dest3] "=&f"(dest3)
+      : [src_argb] "r"(src_argb), [dst_y] "r"(dst_y), [width] "r"(width),
+        [mask] "f"(mask), [value] "f"(value), [eight] "f"(0x08),
+        [zero] "f"(0x00)
+      : "memory");
+}
+
+void ABGRToUVRow_MMI(const uint8_t* src_rgb,
+                     int src_stride_rgb,
+                     uint8_t* dst_u,
+                     uint8_t* dst_v,
+                     int width) {
+  uint64_t src_rgb1;
+  uint64_t ftmp[13];
+  uint64_t tmp[1];
+  const uint64_t value = 0x4040;
+  const uint64_t mask_u = 0x0002003800250013;
+  const uint64_t mask_v = 0x0009002F00380002;
+
+  __asm__ volatile(
+      "dli        %[tmp0],         0x0001000100010001                   \n\t"
+      "dmtc1      %[tmp0],         %[ftmp12]                            \n\t"
+      "1:                                                               \n\t"
+      "daddu      %[src_rgb1],     %[src_rgb],       %[src_stride_rgb] \n\t"
+      "gsldrc1    %[src0],         0x00(%[src_rgb])                    \n\t"
+      "gsldlc1    %[src0],         0x07(%[src_rgb])                    \n\t"
+      "gsldrc1    %[src1],         0x00(%[src_rgb1])                    \n\t"
+      "gsldlc1    %[src1],         0x07(%[src_rgb1])                    \n\t"
+      "punpcklbh  %[src_lo],       %[src0],           %[zero]           \n\t"
+      "punpckhbh  %[src_hi],       %[src0],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src_lo],         %[src_hi]         \n\t"
+      "punpcklbh  %[src_lo],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_lo]         \n\t"
+      "punpckhbh  %[src_hi],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_hi]         \n\t"
+      "paddh      %[src0],         %[src0],           %[ftmp12]         \n\t"
+      "psrlh      %[src0],         %[src0],           %[one]            \n\t"
+      "pinsrh_3   %[dest0_u],      %[src0],           %[value]          \n\t"
+      "dsll       %[dest0_v],      %[src0],           %[sixteen]        \n\t"
+      "pinsrh_0   %[dest0_v],      %[dest0_v],        %[value]          \n\t"
+      "pmaddhw    %[dest0_u],      %[dest0_u],        %[mask_u]         \n\t"
+      "pmaddhw    %[dest0_v],      %[dest0_v],        %[mask_v]         \n\t"
+
+      "gsldrc1    %[src0],         0x08(%[src_rgb])                    \n\t"
+      "gsldlc1    %[src0],         0x0f(%[src_rgb])                    \n\t"
+      "gsldrc1    %[src1],         0x08(%[src_rgb1])                    \n\t"
+      "gsldlc1    %[src1],         0x0f(%[src_rgb1])                    \n\t"
+      "punpcklbh  %[src_lo],       %[src0],           %[zero]           \n\t"
+      "punpckhbh  %[src_hi],       %[src0],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src_lo],         %[src_hi]         \n\t"
+      "punpcklbh  %[src_lo],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_lo]         \n\t"
+      "punpckhbh  %[src_hi],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_hi]         \n\t"
+      "paddh      %[src0],         %[src0],           %[ftmp12]         \n\t"
+      "psrlh      %[src0],         %[src0],           %[one]            \n\t"
+      "pinsrh_3   %[src_lo],       %[src0],           %[value]          \n\t"
+      "dsll       %[src_hi],       %[src0],           %[sixteen]        \n\t"
+      "pinsrh_0   %[src_hi],       %[src_hi],         %[value]          \n\t"
+      "pmaddhw    %[src_lo],       %[src_lo],         %[mask_u]         \n\t"
+      "pmaddhw    %[src_hi],       %[src_hi],         %[mask_v]         \n\t"
+
+      "punpcklwd  %[src0],         %[dest0_u],        %[src_lo]         \n\t"
+      "punpckhwd  %[src1],         %[dest0_u],        %[src_lo]         \n\t"
+      "psubw      %[dest0_u],      %[src1],           %[src0]           \n\t"
+      "psraw      %[dest0_u],      %[dest0_u],        %[eight]          \n\t"
+      "punpcklwd  %[src0],         %[dest0_v],        %[src_hi]         \n\t"
+      "punpckhwd  %[src1],         %[dest0_v],        %[src_hi]         \n\t"
+      "psubw      %[dest0_v],      %[src0],           %[src1]           \n\t"
+      "psraw      %[dest0_v],      %[dest0_v],        %[eight]          \n\t"
+
+      "gsldrc1    %[src0],         0x10(%[src_rgb])                    \n\t"
+      "gsldlc1    %[src0],         0x17(%[src_rgb])                    \n\t"
+      "gsldrc1    %[src1],         0x10(%[src_rgb1])                    \n\t"
+      "gsldlc1    %[src1],         0x17(%[src_rgb1])                    \n\t"
+      "punpcklbh  %[src_lo],       %[src0],           %[zero]           \n\t"
+      "punpckhbh  %[src_hi],       %[src0],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src_lo],         %[src_hi]         \n\t"
+      "punpcklbh  %[src_lo],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_lo]         \n\t"
+      "punpckhbh  %[src_hi],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_hi]         \n\t"
+      "paddh      %[src0],         %[src0],           %[ftmp12]         \n\t"
+      "psrlh      %[src0],         %[src0],           %[one]            \n\t"
+      "pinsrh_3   %[dest1_u],      %[src0],           %[value]          \n\t"
+      "dsll       %[dest1_v],      %[src0],           %[sixteen]        \n\t"
+      "pinsrh_0   %[dest1_v],      %[dest1_v],        %[value]          \n\t"
+      "pmaddhw    %[dest1_u],      %[dest1_u],        %[mask_u]         \n\t"
+      "pmaddhw    %[dest1_v],      %[dest1_v],        %[mask_v]         \n\t"
+
+      "gsldrc1    %[src0],         0x18(%[src_rgb])                    \n\t"
+      "gsldlc1    %[src0],         0x1f(%[src_rgb])                    \n\t"
+      "gsldrc1    %[src1],         0x18(%[src_rgb1])                    \n\t"
+      "gsldlc1    %[src1],         0x1f(%[src_rgb1])                    \n\t"
+      "punpcklbh  %[src_lo],       %[src0],           %[zero]           \n\t"
+      "punpckhbh  %[src_hi],       %[src0],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src_lo],         %[src_hi]         \n\t"
+      "punpcklbh  %[src_lo],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_lo]         \n\t"
+      "punpckhbh  %[src_hi],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_hi]         \n\t"
+      "paddh      %[src0],         %[src0],           %[ftmp12]         \n\t"
+      "psrlh      %[src0],         %[src0],           %[one]            \n\t"
+      "pinsrh_3   %[src_lo],       %[src0],           %[value]          \n\t"
+      "dsll       %[src_hi],       %[src0],           %[sixteen]        \n\t"
+      "pinsrh_0   %[src_hi],       %[src_hi],         %[value]          \n\t"
+      "pmaddhw    %[src_lo],       %[src_lo],         %[mask_u]         \n\t"
+      "pmaddhw    %[src_hi],       %[src_hi],         %[mask_v]         \n\t"
+
+      "punpcklwd  %[src0],         %[dest1_u],        %[src_lo]         \n\t"
+      "punpckhwd  %[src1],         %[dest1_u],        %[src_lo]         \n\t"
+      "psubw      %[dest1_u],      %[src1],           %[src0]           \n\t"
+      "psraw      %[dest1_u],      %[dest1_u],        %[eight]          \n\t"
+      "punpcklwd  %[src0],         %[dest1_v],        %[src_hi]         \n\t"
+      "punpckhwd  %[src1],         %[dest1_v],        %[src_hi]         \n\t"
+      "psubw      %[dest1_v],      %[src0],           %[src1]           \n\t"
+      "psraw      %[dest1_v],      %[dest1_v],        %[eight]          \n\t"
+
+      "gsldrc1    %[src0],         0x20(%[src_rgb])                    \n\t"
+      "gsldlc1    %[src0],         0x27(%[src_rgb])                    \n\t"
+      "gsldrc1    %[src1],         0x20(%[src_rgb1])                    \n\t"
+      "gsldlc1    %[src1],         0x27(%[src_rgb1])                    \n\t"
+      "punpcklbh  %[src_lo],       %[src0],           %[zero]           \n\t"
+      "punpckhbh  %[src_hi],       %[src0],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src_lo],         %[src_hi]         \n\t"
+      "punpcklbh  %[src_lo],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_lo]         \n\t"
+      "punpckhbh  %[src_hi],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_hi]         \n\t"
+      "paddh      %[src0],         %[src0],           %[ftmp12]         \n\t"
+      "psrlh      %[src0],         %[src0],           %[one]            \n\t"
+      "pinsrh_3   %[dest2_u],      %[src0],           %[value]          \n\t"
+      "dsll       %[dest2_v],      %[src0],           %[sixteen]        \n\t"
+      "pinsrh_0   %[dest2_v],      %[dest2_v],        %[value]          \n\t"
+      "pmaddhw    %[dest2_u],      %[dest2_u],        %[mask_u]         \n\t"
+      "pmaddhw    %[dest2_v],      %[dest2_v],        %[mask_v]         \n\t"
+
+      "gsldrc1    %[src0],         0x28(%[src_rgb])                    \n\t"
+      "gsldlc1    %[src0],         0x2f(%[src_rgb])                    \n\t"
+      "gsldrc1    %[src1],         0x28(%[src_rgb1])                    \n\t"
+      "gsldlc1    %[src1],         0x2f(%[src_rgb1])                    \n\t"
+      "punpcklbh  %[src_lo],       %[src0],           %[zero]           \n\t"
+      "punpckhbh  %[src_hi],       %[src0],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src_lo],         %[src_hi]         \n\t"
+      "punpcklbh  %[src_lo],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_lo]         \n\t"
+      "punpckhbh  %[src_hi],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_hi]         \n\t"
+      "paddh      %[src0],         %[src0],           %[ftmp12]         \n\t"
+      "psrlh      %[src0],         %[src0],           %[one]            \n\t"
+      "pinsrh_3   %[src_lo],       %[src0],           %[value]          \n\t"
+      "dsll       %[src_hi],       %[src0],           %[sixteen]        \n\t"
+      "pinsrh_0   %[src_hi],       %[src_hi],         %[value]          \n\t"
+      "pmaddhw    %[src_lo],       %[src_lo],         %[mask_u]         \n\t"
+      "pmaddhw    %[src_hi],       %[src_hi],         %[mask_v]         \n\t"
+
+      "punpcklwd  %[src0],         %[dest2_u],        %[src_lo]         \n\t"
+      "punpckhwd  %[src1],         %[dest2_u],        %[src_lo]         \n\t"
+      "psubw      %[dest2_u],      %[src1],           %[src0]           \n\t"
+      "psraw      %[dest2_u],      %[dest2_u],        %[eight]          \n\t"
+      "punpcklwd  %[src0],         %[dest2_v],        %[src_hi]         \n\t"
+      "punpckhwd  %[src1],         %[dest2_v],        %[src_hi]         \n\t"
+      "psubw      %[dest2_v],      %[src0],           %[src1]           \n\t"
+      "psraw      %[dest2_v],      %[dest2_v],        %[eight]          \n\t"
+
+      "gsldrc1    %[src0],         0x30(%[src_rgb])                    \n\t"
+      "gsldlc1    %[src0],         0x37(%[src_rgb])                    \n\t"
+      "gsldrc1    %[src1],         0x30(%[src_rgb1])                    \n\t"
+      "gsldlc1    %[src1],         0x37(%[src_rgb1])                    \n\t"
+      "punpcklbh  %[src_lo],       %[src0],           %[zero]           \n\t"
+      "punpckhbh  %[src_hi],       %[src0],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src_lo],         %[src_hi]         \n\t"
+      "punpcklbh  %[src_lo],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_lo]         \n\t"
+      "punpckhbh  %[src_hi],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_hi]         \n\t"
+      "paddh      %[src0],         %[src0],           %[ftmp12]         \n\t"
+      "psrlh      %[src0],         %[src0],           %[one]            \n\t"
+      "pinsrh_3   %[dest3_u],      %[src0],           %[value]          \n\t"
+      "dsll       %[dest3_v],      %[src0],           %[sixteen]        \n\t"
+      "pinsrh_0   %[dest3_v],      %[dest3_v],        %[value]          \n\t"
+      "pmaddhw    %[dest3_u],      %[dest3_u],        %[mask_u]         \n\t"
+      "pmaddhw    %[dest3_v],      %[dest3_v],        %[mask_v]         \n\t"
+
+      "gsldrc1    %[src0],         0x38(%[src_rgb])                    \n\t"
+      "gsldlc1    %[src0],         0x3f(%[src_rgb])                    \n\t"
+      "gsldrc1    %[src1],         0x38(%[src_rgb1])                    \n\t"
+      "gsldlc1    %[src1],         0x3f(%[src_rgb1])                    \n\t"
+      "punpcklbh  %[src_lo],       %[src0],           %[zero]           \n\t"
+      "punpckhbh  %[src_hi],       %[src0],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src_lo],         %[src_hi]         \n\t"
+      "punpcklbh  %[src_lo],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_lo]         \n\t"
+      "punpckhbh  %[src_hi],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_hi]         \n\t"
+      "paddh      %[src0],         %[src0],           %[ftmp12]         \n\t"
+      "psrlh      %[src0],         %[src0],           %[one]            \n\t"
+      "pinsrh_3   %[src_lo],       %[src0],           %[value]          \n\t"
+      "dsll       %[src_hi],       %[src0],           %[sixteen]        \n\t"
+      "pinsrh_0   %[src_hi],       %[src_hi],         %[value]          \n\t"
+      "pmaddhw    %[src_lo],       %[src_lo],         %[mask_u]         \n\t"
+      "pmaddhw    %[src_hi],       %[src_hi],         %[mask_v]         \n\t"
+
+      "punpcklwd  %[src0],         %[dest3_u],        %[src_lo]         \n\t"
+      "punpckhwd  %[src1],         %[dest3_u],        %[src_lo]         \n\t"
+      "psubw      %[dest3_u],      %[src1],           %[src0]           \n\t"
+      "psraw      %[dest3_u],      %[dest3_u],        %[eight]          \n\t"
+      "punpcklwd  %[src0],         %[dest3_v],        %[src_hi]         \n\t"
+      "punpckhwd  %[src1],         %[dest3_v],        %[src_hi]         \n\t"
+      "psubw      %[dest3_v],      %[src0],           %[src1]           \n\t"
+      "psraw      %[dest3_v],      %[dest3_v],        %[eight]          \n\t"
+
+      "packsswh   %[src0],         %[dest0_u],        %[dest1_u]        \n\t"
+      "packsswh   %[src1],         %[dest2_u],        %[dest3_u]        \n\t"
+      "packushb   %[dest0_u],      %[src0],           %[src1]           \n\t"
+      "gssdlc1    %[dest0_u],      0x07(%[dst_u])                       \n\t"
+      "gssdrc1    %[dest0_u],      0x00(%[dst_u])                       \n\t"
+
+      "packsswh   %[src0],         %[dest0_v],        %[dest1_v]        \n\t"
+      "packsswh   %[src1],         %[dest2_v],        %[dest3_v]        \n\t"
+      "packushb   %[dest0_v],      %[src0],           %[src1]           \n\t"
+      "gssdlc1    %[dest0_v],      0x07(%[dst_v])                       \n\t"
+      "gssdrc1    %[dest0_v],      0x00(%[dst_v])                       \n\t"
+
+      "daddiu     %[src_rgb],     %[src_rgb],       0x40              \n\t"
+      "daddiu     %[dst_u],        %[dst_u],          0x08              \n\t"
+      "daddiu     %[dst_v],        %[dst_v],          0x08              \n\t"
+      "daddi      %[width],        %[width],         -0x10              \n\t"
+      "bgtz       %[width],        1b                                   \n\t"
+      : [src_rgb1] "=&r"(src_rgb1), [src0] "=&f"(ftmp[0]),
+        [src1] "=&f"(ftmp[1]), [src_lo] "=&f"(ftmp[2]), [src_hi] "=&f"(ftmp[3]),
+        [dest0_u] "=&f"(ftmp[4]), [dest0_v] "=&f"(ftmp[5]),
+        [dest1_u] "=&f"(ftmp[6]), [dest1_v] "=&f"(ftmp[7]),
+        [dest2_u] "=&f"(ftmp[8]), [dest2_v] "=&f"(ftmp[9]),
+        [dest3_u] "=&f"(ftmp[10]), [dest3_v] "=&f"(ftmp[11]),
+        [ftmp12] "=&f"(ftmp[12]), [tmp0] "=&r"(tmp[0])
+      : [src_rgb] "r"(src_rgb), [src_stride_rgb] "r"(src_stride_rgb),
+        [dst_u] "r"(dst_u), [dst_v] "r"(dst_v), [width] "r"(width),
+        [mask_u] "f"(mask_u), [mask_v] "f"(mask_v), [value] "f"(value),
+        [zero] "f"(0x00), [eight] "f"(0x08), [one] "f"(0x01),
+        [sixteen] "f"(0x10)
+      : "memory");
+}
+
+void RGBAToYRow_MMI(const uint8_t* src_argb, uint8_t* dst_y, int width) {
+  uint64_t src, src_hi, src_lo;
+  uint64_t dest0, dest1, dest2, dest3;
+  const uint64_t value = 0x1080;
+  const uint64_t mask = 0x0042008100190001;
+
+  __asm__ volatile(
+      "1:                                                           \n\t"
+      "gsldlc1    %[src],          0x07(%[src_argb])               \n\t"
+      "gsldrc1    %[src],          0x00(%[src_argb])               \n\t"
+      "punpcklbh  %[src_lo],       %[src],            %[zero]       \n\t"
+      "pinsrh_0   %[src_lo],       %[src_lo],         %[value]      \n\t"
+      "pmaddhw    %[src_lo],       %[src_lo],         %[mask]       \n\t"
+      "punpckhbh  %[src_hi],       %[src],            %[zero]       \n\t"
+      "pinsrh_0   %[src_hi],       %[src_hi],         %[value]      \n\t"
+      "pmaddhw    %[src_hi],       %[src_hi],         %[mask]       \n\t"
+      "punpcklwd  %[src],          %[src_lo],         %[src_hi]     \n\t"
+      "punpckhwd  %[dest0],        %[src_lo],         %[src_hi]     \n\t"
+      "paddw      %[dest0],        %[dest0],          %[src]        \n\t"
+      "psrlw      %[dest0],        %[dest0],          %[eight]      \n\t"
+
+      "gsldlc1    %[src],          0x0f(%[src_argb])               \n\t"
+      "gsldrc1    %[src],          0x08(%[src_argb])               \n\t"
+      "punpcklbh  %[src_lo],       %[src],            %[zero]       \n\t"
+      "pinsrh_0   %[src_lo],       %[src_lo],         %[value]      \n\t"
+      "pmaddhw    %[src_lo],       %[src_lo],         %[mask]       \n\t"
+      "punpckhbh  %[src_hi],       %[src],            %[zero]       \n\t"
+      "pinsrh_0   %[src_hi],       %[src_hi],         %[value]      \n\t"
+      "pmaddhw    %[src_hi],       %[src_hi],         %[mask]       \n\t"
+      "punpcklwd  %[src],          %[src_lo],         %[src_hi]     \n\t"
+      "punpckhwd  %[dest1],        %[src_lo],         %[src_hi]     \n\t"
+      "paddw      %[dest1],        %[dest1],          %[src]        \n\t"
+      "psrlw      %[dest1],        %[dest1],          %[eight]      \n\t"
+
+      "gsldlc1    %[src],          0x17(%[src_argb])               \n\t"
+      "gsldrc1    %[src],          0x10(%[src_argb])               \n\t"
+      "punpcklbh  %[src_lo],       %[src],            %[zero]       \n\t"
+      "pinsrh_0   %[src_lo],       %[src_lo],         %[value]      \n\t"
+      "pmaddhw    %[src_lo],       %[src_lo],         %[mask]       \n\t"
+      "punpckhbh  %[src_hi],       %[src],            %[zero]       \n\t"
+      "pinsrh_0   %[src_hi],       %[src_hi],         %[value]      \n\t"
+      "pmaddhw    %[src_hi],       %[src_hi],         %[mask]       \n\t"
+      "punpcklwd  %[src],          %[src_lo],         %[src_hi]     \n\t"
+      "punpckhwd  %[dest2],        %[src_lo],         %[src_hi]     \n\t"
+      "paddw      %[dest2],        %[dest2],          %[src]        \n\t"
+      "psrlw      %[dest2],        %[dest2],          %[eight]      \n\t"
+
+      "gsldlc1    %[src],          0x1f(%[src_argb])               \n\t"
+      "gsldrc1    %[src],          0x18(%[src_argb])               \n\t"
+      "punpcklbh  %[src_lo],       %[src],            %[zero]       \n\t"
+      "pinsrh_0   %[src_lo],       %[src_lo],         %[value]      \n\t"
+      "pmaddhw    %[src_lo],       %[src_lo],         %[mask]       \n\t"
+      "punpckhbh  %[src_hi],       %[src],            %[zero]       \n\t"
+      "pinsrh_0   %[src_hi],       %[src_hi],         %[value]      \n\t"
+      "pmaddhw    %[src_hi],       %[src_hi],         %[mask]       \n\t"
+      "punpcklwd  %[src],          %[src_lo],         %[src_hi]     \n\t"
+      "punpckhwd  %[dest3],        %[src_lo],         %[src_hi]     \n\t"
+      "paddw      %[dest3],        %[dest3],          %[src]        \n\t"
+      "psrlw      %[dest3],        %[dest3],          %[eight]      \n\t"
+
+      "packsswh   %[src_lo],       %[dest0],          %[dest1]      \n\t"
+      "packsswh   %[src_hi],       %[dest2],          %[dest3]      \n\t"
+      "packushb   %[dest0],        %[src_lo],         %[src_hi]     \n\t"
+      "gssdlc1    %[dest0],        0x07(%[dst_y])                   \n\t"
+      "gssdrc1    %[dest0],        0x00(%[dst_y])                   \n\t"
+
+      "daddiu     %[src_argb],    %[src_argb],      0x20          \n\t"
+      "daddiu     %[dst_y],        %[dst_y],          0x08          \n\t"
+      "daddi      %[width],        %[width],         -0x08          \n\t"
+      "bnez       %[width],        1b                               \n\t"
+      : [src] "=&f"(src), [src_hi] "=&f"(src_hi), [src_lo] "=&f"(src_lo),
+        [dest0] "=&f"(dest0), [dest1] "=&f"(dest1), [dest2] "=&f"(dest2),
+        [dest3] "=&f"(dest3)
+      : [src_argb] "r"(src_argb), [dst_y] "r"(dst_y), [width] "r"(width),
+        [mask] "f"(mask), [value] "f"(value), [eight] "f"(0x08),
+        [zero] "f"(0x00)
+      : "memory");
+}
+
+void RGBAToUVRow_MMI(const uint8_t* src_rgb,
+                     int src_stride_rgb,
+                     uint8_t* dst_u,
+                     uint8_t* dst_v,
+                     int width) {
+  uint64_t src_rgb1;
+  uint64_t ftmp[13];
+  uint64_t tmp[1];
+  const uint64_t value = 0x4040;
+  const uint64_t mask_u = 0x0013002500380002;
+  const uint64_t mask_v = 0x00020038002f0009;
+
+  __asm__ volatile(
+      "dli        %[tmp0],         0x0001000100010001                   \n\t"
+      "dmtc1      %[tmp0],         %[ftmp12]                            \n\t"
+      "1:                                                               \n\t"
+      "daddu      %[src_rgb1],     %[src_rgb],       %[src_stride_rgb] \n\t"
+      "gsldrc1    %[src0],         0x00(%[src_rgb])                    \n\t"
+      "gsldlc1    %[src0],         0x07(%[src_rgb])                    \n\t"
+      "gsldrc1    %[src1],         0x00(%[src_rgb1])                    \n\t"
+      "gsldlc1    %[src1],         0x07(%[src_rgb1])                    \n\t"
+      "punpcklbh  %[src_lo],       %[src0],           %[zero]           \n\t"
+      "punpckhbh  %[src_hi],       %[src0],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src_lo],         %[src_hi]         \n\t"
+      "punpcklbh  %[src_lo],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_lo]         \n\t"
+      "punpckhbh  %[src_hi],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_hi]         \n\t"
+      "paddh      %[src0],         %[src0],           %[ftmp12]         \n\t"
+      "psrlh      %[src0],         %[src0],           %[one]            \n\t"
+      "pinsrh_0   %[dest0_u],      %[src0],           %[value]          \n\t"
+      "dsrl       %[dest0_v],      %[src0],           %[sixteen]        \n\t"
+      "pinsrh_3   %[dest0_v],      %[dest0_v],        %[value]          \n\t"
+      "pmaddhw    %[dest0_u],      %[dest0_u],        %[mask_u]         \n\t"
+      "pmaddhw    %[dest0_v],      %[dest0_v],        %[mask_v]         \n\t"
+
+      "gsldrc1    %[src0],         0x08(%[src_rgb])                    \n\t"
+      "gsldlc1    %[src0],         0x0f(%[src_rgb])                    \n\t"
+      "gsldrc1    %[src1],         0x08(%[src_rgb1])                    \n\t"
+      "gsldlc1    %[src1],         0x0f(%[src_rgb1])                    \n\t"
+      "punpcklbh  %[src_lo],       %[src0],           %[zero]           \n\t"
+      "punpckhbh  %[src_hi],       %[src0],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src_lo],         %[src_hi]         \n\t"
+      "punpcklbh  %[src_lo],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_lo]         \n\t"
+      "punpckhbh  %[src_hi],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_hi]         \n\t"
+      "paddh      %[src0],         %[src0],           %[ftmp12]         \n\t"
+      "psrlh      %[src0],         %[src0],           %[one]            \n\t"
+      "pinsrh_0   %[src_lo],       %[src0],           %[value]          \n\t"
+      "dsrl       %[src_hi],       %[src0],           %[sixteen]        \n\t"
+      "pinsrh_3   %[src_hi],       %[src_hi],         %[value]          \n\t"
+      "pmaddhw    %[src_lo],       %[src_lo],         %[mask_u]         \n\t"
+      "pmaddhw    %[src_hi],       %[src_hi],         %[mask_v]         \n\t"
+
+      "punpcklwd  %[src0],         %[dest0_u],        %[src_lo]         \n\t"
+      "punpckhwd  %[src1],         %[dest0_u],        %[src_lo]         \n\t"
+      "psubw      %[dest0_u],      %[src0],           %[src1]           \n\t"
+      "psraw      %[dest0_u],      %[dest0_u],        %[eight]          \n\t"
+      "punpcklwd  %[src0],         %[dest0_v],        %[src_hi]         \n\t"
+      "punpckhwd  %[src1],         %[dest0_v],        %[src_hi]         \n\t"
+      "psubw      %[dest0_v],      %[src1],           %[src0]           \n\t"
+      "psraw      %[dest0_v],      %[dest0_v],        %[eight]          \n\t"
+
+      "gsldrc1    %[src0],         0x10(%[src_rgb])                    \n\t"
+      "gsldlc1    %[src0],         0x17(%[src_rgb])                    \n\t"
+      "gsldrc1    %[src1],         0x10(%[src_rgb1])                    \n\t"
+      "gsldlc1    %[src1],         0x17(%[src_rgb1])                    \n\t"
+      "punpcklbh  %[src_lo],       %[src0],           %[zero]           \n\t"
+      "punpckhbh  %[src_hi],       %[src0],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src_lo],         %[src_hi]         \n\t"
+      "punpcklbh  %[src_lo],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_lo]         \n\t"
+      "punpckhbh  %[src_hi],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_hi]         \n\t"
+      "paddh      %[src0],         %[src0],           %[ftmp12]         \n\t"
+      "psrlh      %[src0],         %[src0],           %[one]            \n\t"
+      "pinsrh_0   %[dest1_u],      %[src0],           %[value]          \n\t"
+      "dsrl       %[dest1_v],      %[src0],           %[sixteen]        \n\t"
+      "pinsrh_3   %[dest1_v],      %[dest1_v],        %[value]          \n\t"
+      "pmaddhw    %[dest1_u],      %[dest1_u],        %[mask_u]         \n\t"
+      "pmaddhw    %[dest1_v],      %[dest1_v],        %[mask_v]         \n\t"
+
+      "gsldrc1    %[src0],         0x18(%[src_rgb])                    \n\t"
+      "gsldlc1    %[src0],         0x1f(%[src_rgb])                    \n\t"
+      "gsldrc1    %[src1],         0x18(%[src_rgb1])                    \n\t"
+      "gsldlc1    %[src1],         0x1f(%[src_rgb1])                    \n\t"
+      "punpcklbh  %[src_lo],       %[src0],           %[zero]           \n\t"
+      "punpckhbh  %[src_hi],       %[src0],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src_lo],         %[src_hi]         \n\t"
+      "punpcklbh  %[src_lo],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_lo]         \n\t"
+      "punpckhbh  %[src_hi],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_hi]         \n\t"
+      "paddh      %[src0],         %[src0],           %[ftmp12]         \n\t"
+      "psrlh      %[src0],         %[src0],           %[one]            \n\t"
+      "pinsrh_0   %[src_lo],       %[src0],           %[value]          \n\t"
+      "dsrl       %[src_hi],       %[src0],           %[sixteen]        \n\t"
+      "pinsrh_3   %[src_hi],       %[src_hi],         %[value]          \n\t"
+      "pmaddhw    %[src_lo],       %[src_lo],         %[mask_u]         \n\t"
+      "pmaddhw    %[src_hi],       %[src_hi],         %[mask_v]         \n\t"
+
+      "punpcklwd  %[src0],         %[dest1_u],        %[src_lo]         \n\t"
+      "punpckhwd  %[src1],         %[dest1_u],        %[src_lo]         \n\t"
+      "psubw      %[dest1_u],      %[src0],           %[src1]           \n\t"
+      "psraw      %[dest1_u],      %[dest1_u],        %[eight]          \n\t"
+      "punpcklwd  %[src0],         %[dest1_v],        %[src_hi]         \n\t"
+      "punpckhwd  %[src1],         %[dest1_v],        %[src_hi]         \n\t"
+      "psubw      %[dest1_v],      %[src1],           %[src0]           \n\t"
+      "psraw      %[dest1_v],      %[dest1_v],        %[eight]          \n\t"
+
+      "gsldrc1    %[src0],         0x20(%[src_rgb])                    \n\t"
+      "gsldlc1    %[src0],         0x27(%[src_rgb])                    \n\t"
+      "gsldrc1    %[src1],         0x20(%[src_rgb1])                    \n\t"
+      "gsldlc1    %[src1],         0x27(%[src_rgb1])                    \n\t"
+      "punpcklbh  %[src_lo],       %[src0],           %[zero]           \n\t"
+      "punpckhbh  %[src_hi],       %[src0],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src_lo],         %[src_hi]         \n\t"
+      "punpcklbh  %[src_lo],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_lo]         \n\t"
+      "punpckhbh  %[src_hi],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_hi]         \n\t"
+      "paddh      %[src0],         %[src0],           %[ftmp12]         \n\t"
+      "psrlh      %[src0],         %[src0],           %[one]            \n\t"
+      "pinsrh_0   %[dest2_u],      %[src0],           %[value]          \n\t"
+      "dsrl       %[dest2_v],      %[src0],           %[sixteen]        \n\t"
+      "pinsrh_3   %[dest2_v],      %[dest2_v],        %[value]          \n\t"
+      "pmaddhw    %[dest2_u],      %[dest2_u],        %[mask_u]         \n\t"
+      "pmaddhw    %[dest2_v],      %[dest2_v],        %[mask_v]         \n\t"
+
+      "gsldrc1    %[src0],         0x28(%[src_rgb])                    \n\t"
+      "gsldlc1    %[src0],         0x2f(%[src_rgb])                    \n\t"
+      "gsldrc1    %[src1],         0x28(%[src_rgb1])                    \n\t"
+      "gsldlc1    %[src1],         0x2f(%[src_rgb1])                    \n\t"
+      "punpcklbh  %[src_lo],       %[src0],           %[zero]           \n\t"
+      "punpckhbh  %[src_hi],       %[src0],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src_lo],         %[src_hi]         \n\t"
+      "punpcklbh  %[src_lo],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_lo]         \n\t"
+      "punpckhbh  %[src_hi],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_hi]         \n\t"
+      "paddh      %[src0],         %[src0],           %[ftmp12]         \n\t"
+      "psrlh      %[src0],         %[src0],           %[one]            \n\t"
+      "pinsrh_0   %[src_lo],       %[src0],           %[value]          \n\t"
+      "dsrl       %[src_hi],       %[src0],           %[sixteen]        \n\t"
+      "pinsrh_3   %[src_hi],       %[src_hi],         %[value]          \n\t"
+      "pmaddhw    %[src_lo],       %[src_lo],         %[mask_u]         \n\t"
+      "pmaddhw    %[src_hi],       %[src_hi],         %[mask_v]         \n\t"
+
+      "punpcklwd  %[src0],         %[dest2_u],        %[src_lo]         \n\t"
+      "punpckhwd  %[src1],         %[dest2_u],        %[src_lo]         \n\t"
+      "psubw      %[dest2_u],      %[src0],           %[src1]           \n\t"
+      "psraw      %[dest2_u],      %[dest2_u],        %[eight]          \n\t"
+      "punpcklwd  %[src0],         %[dest2_v],        %[src_hi]         \n\t"
+      "punpckhwd  %[src1],         %[dest2_v],        %[src_hi]         \n\t"
+      "psubw      %[dest2_v],      %[src1],           %[src0]           \n\t"
+      "psraw      %[dest2_v],      %[dest2_v],        %[eight]          \n\t"
+
+      "gsldrc1    %[src0],         0x30(%[src_rgb])                    \n\t"
+      "gsldlc1    %[src0],         0x37(%[src_rgb])                    \n\t"
+      "gsldrc1    %[src1],         0x30(%[src_rgb1])                    \n\t"
+      "gsldlc1    %[src1],         0x37(%[src_rgb1])                    \n\t"
+      "punpcklbh  %[src_lo],       %[src0],           %[zero]           \n\t"
+      "punpckhbh  %[src_hi],       %[src0],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src_lo],         %[src_hi]         \n\t"
+      "punpcklbh  %[src_lo],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_lo]         \n\t"
+      "punpckhbh  %[src_hi],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_hi]         \n\t"
+      "paddh      %[src0],         %[src0],           %[ftmp12]         \n\t"
+      "psrlh      %[src0],         %[src0],           %[one]            \n\t"
+      "pinsrh_0   %[dest3_u],      %[src0],           %[value]          \n\t"
+      "dsrl       %[dest3_v],      %[src0],           %[sixteen]        \n\t"
+      "pinsrh_3   %[dest3_v],      %[dest3_v],        %[value]          \n\t"
+      "pmaddhw    %[dest3_u],      %[dest3_u],        %[mask_u]         \n\t"
+      "pmaddhw    %[dest3_v],      %[dest3_v],        %[mask_v]         \n\t"
+
+      "gsldrc1    %[src0],         0x38(%[src_rgb])                    \n\t"
+      "gsldlc1    %[src0],         0x3f(%[src_rgb])                    \n\t"
+      "gsldrc1    %[src1],         0x38(%[src_rgb1])                    \n\t"
+      "gsldlc1    %[src1],         0x3f(%[src_rgb1])                    \n\t"
+      "punpcklbh  %[src_lo],       %[src0],           %[zero]           \n\t"
+      "punpckhbh  %[src_hi],       %[src0],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src_lo],         %[src_hi]         \n\t"
+      "punpcklbh  %[src_lo],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_lo]         \n\t"
+      "punpckhbh  %[src_hi],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_hi]         \n\t"
+      "paddh      %[src0],         %[src0],           %[ftmp12]         \n\t"
+      "psrlh      %[src0],         %[src0],           %[one]            \n\t"
+      "pinsrh_0   %[src_lo],       %[src0],           %[value]          \n\t"
+      "dsrl       %[src_hi],       %[src0],           %[sixteen]        \n\t"
+      "pinsrh_3   %[src_hi],       %[src_hi],         %[value]          \n\t"
+      "pmaddhw    %[src_lo],       %[src_lo],         %[mask_u]         \n\t"
+      "pmaddhw    %[src_hi],       %[src_hi],         %[mask_v]         \n\t"
+
+      "punpcklwd  %[src0],         %[dest3_u],        %[src_lo]         \n\t"
+      "punpckhwd  %[src1],         %[dest3_u],        %[src_lo]         \n\t"
+      "psubw      %[dest3_u],      %[src0],           %[src1]           \n\t"
+      "psraw      %[dest3_u],      %[dest3_u],        %[eight]          \n\t"
+      "punpcklwd  %[src0],         %[dest3_v],        %[src_hi]         \n\t"
+      "punpckhwd  %[src1],         %[dest3_v],        %[src_hi]         \n\t"
+      "psubw      %[dest3_v],      %[src1],           %[src0]           \n\t"
+      "psraw      %[dest3_v],      %[dest3_v],        %[eight]          \n\t"
+
+      "packsswh   %[src0],         %[dest0_u],        %[dest1_u]        \n\t"
+      "packsswh   %[src1],         %[dest2_u],        %[dest3_u]        \n\t"
+      "packushb   %[dest0_u],      %[src0],           %[src1]           \n\t"
+      "gssdlc1    %[dest0_u],      0x07(%[dst_u])                       \n\t"
+      "gssdrc1    %[dest0_u],      0x00(%[dst_u])                       \n\t"
+
+      "packsswh   %[src0],         %[dest0_v],        %[dest1_v]        \n\t"
+      "packsswh   %[src1],         %[dest2_v],        %[dest3_v]        \n\t"
+      "packushb   %[dest0_v],      %[src0],           %[src1]           \n\t"
+      "gssdlc1    %[dest0_v],      0x07(%[dst_v])                       \n\t"
+      "gssdrc1    %[dest0_v],      0x00(%[dst_v])                       \n\t"
+
+      "daddiu     %[src_rgb],     %[src_rgb],       0x40              \n\t"
+      "daddiu     %[dst_u],        %[dst_u],          0x08              \n\t"
+      "daddiu     %[dst_v],        %[dst_v],          0x08              \n\t"
+      "daddi      %[width],        %[width],         -0x10              \n\t"
+      "bgtz       %[width],        1b                                   \n\t"
+      : [src_rgb1] "=&r"(src_rgb1), [src0] "=&f"(ftmp[0]),
+        [src1] "=&f"(ftmp[1]), [src_lo] "=&f"(ftmp[2]), [src_hi] "=&f"(ftmp[3]),
+        [dest0_u] "=&f"(ftmp[4]), [dest0_v] "=&f"(ftmp[5]),
+        [dest1_u] "=&f"(ftmp[6]), [dest1_v] "=&f"(ftmp[7]),
+        [dest2_u] "=&f"(ftmp[8]), [dest2_v] "=&f"(ftmp[9]),
+        [dest3_u] "=&f"(ftmp[10]), [dest3_v] "=&f"(ftmp[11]),
+        [ftmp12] "=&f"(ftmp[12]), [tmp0] "=&r"(tmp[0])
+      : [src_rgb] "r"(src_rgb), [src_stride_rgb] "r"(src_stride_rgb),
+        [dst_u] "r"(dst_u), [dst_v] "r"(dst_v), [width] "r"(width),
+        [mask_u] "f"(mask_u), [mask_v] "f"(mask_v), [value] "f"(value),
+        [zero] "f"(0x00), [eight] "f"(0x08), [one] "f"(0x01),
+        [sixteen] "f"(0x10)
+      : "memory");
+}
+
+void RGB24ToYRow_MMI(const uint8_t* src_argb, uint8_t* dst_y, int width) {
+  uint64_t src, src_hi, src_lo;
+  uint64_t dest0, dest1, dest2, dest3;
+  const uint64_t value = 0x1080;
+  const uint64_t mask = 0x0001004200810019;
+
+  __asm__ volatile(
+      "1:                                                           \n\t"
+      "gsldlc1    %[src],          0x07(%[src_argb])               \n\t"
+      "gsldrc1    %[src],          0x00(%[src_argb])               \n\t"
+      "punpcklbh  %[src_lo],       %[src],            %[zero]       \n\t"
+      "pinsrh_3   %[src_lo],       %[src_lo],         %[value]      \n\t"
+      "pmaddhw    %[src_lo],       %[src_lo],         %[mask]       \n\t"
+      "dsll       %[src],          %[src],            %[eight]      \n\t"
+      "punpckhbh  %[src_hi],       %[src],            %[zero]       \n\t"
+      "pinsrh_3   %[src_hi],       %[src_hi],         %[value]      \n\t"
+      "pmaddhw    %[src_hi],       %[src_hi],         %[mask]       \n\t"
+      "punpcklwd  %[src],          %[src_lo],         %[src_hi]     \n\t"
+      "punpckhwd  %[dest0],        %[src_lo],         %[src_hi]     \n\t"
+      "paddw      %[dest0],        %[dest0],          %[src]        \n\t"
+      "psrlw      %[dest0],        %[dest0],          %[eight]      \n\t"
+
+      "gsldlc1    %[src],          0x0d(%[src_argb])               \n\t"
+      "gsldrc1    %[src],          0x06(%[src_argb])               \n\t"
+      "punpcklbh  %[src_lo],       %[src],            %[zero]       \n\t"
+      "pinsrh_3   %[src_lo],       %[src_lo],         %[value]      \n\t"
+      "pmaddhw    %[src_lo],       %[src_lo],         %[mask]       \n\t"
+      "dsll       %[src],          %[src],            %[eight]      \n\t"
+      "punpckhbh  %[src_hi],       %[src],            %[zero]       \n\t"
+      "pinsrh_3   %[src_hi],       %[src_hi],         %[value]      \n\t"
+      "pmaddhw    %[src_hi],       %[src_hi],         %[mask]       \n\t"
+      "punpcklwd  %[src],          %[src_lo],         %[src_hi]     \n\t"
+      "punpckhwd  %[dest1],        %[src_lo],         %[src_hi]     \n\t"
+      "paddw      %[dest1],        %[dest1],          %[src]        \n\t"
+      "psrlw      %[dest1],        %[dest1],          %[eight]      \n\t"
+
+      "gsldlc1    %[src],          0x13(%[src_argb])               \n\t"
+      "gsldrc1    %[src],          0x0c(%[src_argb])               \n\t"
+      "punpcklbh  %[src_lo],       %[src],            %[zero]       \n\t"
+      "pinsrh_3   %[src_lo],       %[src_lo],         %[value]      \n\t"
+      "pmaddhw    %[src_lo],       %[src_lo],         %[mask]       \n\t"
+      "dsll       %[src],          %[src],            %[eight]      \n\t"
+      "punpckhbh  %[src_hi],       %[src],            %[zero]       \n\t"
+      "pinsrh_3   %[src_hi],       %[src_hi],         %[value]      \n\t"
+      "pmaddhw    %[src_hi],       %[src_hi],         %[mask]       \n\t"
+      "punpcklwd  %[src],          %[src_lo],         %[src_hi]     \n\t"
+      "punpckhwd  %[dest2],        %[src_lo],         %[src_hi]     \n\t"
+      "paddw      %[dest2],        %[dest2],          %[src]        \n\t"
+      "psrlw      %[dest2],        %[dest2],          %[eight]      \n\t"
+
+      "gsldlc1    %[src],          0x19(%[src_argb])               \n\t"
+      "gsldrc1    %[src],          0x12(%[src_argb])               \n\t"
+      "punpcklbh  %[src_lo],       %[src],            %[zero]       \n\t"
+      "pinsrh_3   %[src_lo],       %[src_lo],         %[value]      \n\t"
+      "pmaddhw    %[src_lo],       %[src_lo],         %[mask]       \n\t"
+      "dsll       %[src],          %[src],            %[eight]      \n\t"
+      "punpckhbh  %[src_hi],       %[src],            %[zero]       \n\t"
+      "pinsrh_3   %[src_hi],       %[src_hi],         %[value]      \n\t"
+      "pmaddhw    %[src_hi],       %[src_hi],         %[mask]       \n\t"
+      "punpcklwd  %[src],          %[src_lo],         %[src_hi]     \n\t"
+      "punpckhwd  %[dest3],        %[src_lo],         %[src_hi]     \n\t"
+      "paddw      %[dest3],        %[dest3],          %[src]        \n\t"
+      "psrlw      %[dest3],        %[dest3],          %[eight]      \n\t"
+
+      "packsswh   %[src_lo],       %[dest0],          %[dest1]      \n\t"
+      "packsswh   %[src_hi],       %[dest2],          %[dest3]      \n\t"
+      "packushb   %[dest0],        %[src_lo],         %[src_hi]     \n\t"
+      "gssdlc1    %[dest0],        0x07(%[dst_y])                   \n\t"
+      "gssdrc1    %[dest0],        0x00(%[dst_y])                   \n\t"
+
+      "daddiu     %[src_argb],    %[src_argb],      0x18          \n\t"
+      "daddiu     %[dst_y],        %[dst_y],          0x08          \n\t"
+      "daddi      %[width],        %[width],         -0x08          \n\t"
+      "bnez       %[width],        1b                               \n\t"
+      : [src] "=&f"(src), [src_hi] "=&f"(src_hi), [src_lo] "=&f"(src_lo),
+        [dest0] "=&f"(dest0), [dest1] "=&f"(dest1), [dest2] "=&f"(dest2),
+        [dest3] "=&f"(dest3)
+      : [src_argb] "r"(src_argb), [dst_y] "r"(dst_y), [width] "r"(width),
+        [mask] "f"(mask), [value] "f"(value), [eight] "f"(0x08),
+        [zero] "f"(0x00)
+      : "memory");
+}
+
+void RGB24ToUVRow_MMI(const uint8_t* src_rgb,
+                      int src_stride_rgb,
+                      uint8_t* dst_u,
+                      uint8_t* dst_v,
+                      int width) {
+  uint64_t src_rgb1;
+  uint64_t ftmp[13];
+  uint64_t tmp[1];
+  const uint64_t value = 0x4040;
+  const uint64_t mask_u = 0x0013002500380002;
+  const uint64_t mask_v = 0x00020038002f0009;
+
+  __asm__ volatile(
+      "dli        %[tmp0],         0x0001000100010001                   \n\t"
+      "dmtc1      %[tmp0],         %[ftmp12]                            \n\t"
+      "1:                                                               \n\t"
+      "daddu      %[src_rgb1],     %[src_rgb],       %[src_stride_rgb] \n\t"
+      "gsldrc1    %[src0],         0x00(%[src_rgb])                    \n\t"
+      "gsldlc1    %[src0],         0x07(%[src_rgb])                    \n\t"
+      "gsldrc1    %[src1],         0x00(%[src_rgb1])                    \n\t"
+      "gsldlc1    %[src1],         0x07(%[src_rgb1])                    \n\t"
+      "punpcklbh  %[src_lo],       %[src0],           %[zero]           \n\t"
+      "dsll       %[src0],         %[src0],           %[eight]          \n\t"
+      "punpckhbh  %[src_hi],       %[src0],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src_lo],         %[src_hi]         \n\t"
+      "punpcklbh  %[src_lo],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_lo]         \n\t"
+      "dsll       %[src1],         %[src1],           %[eight]          \n\t"
+      "punpckhbh  %[src_hi],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_hi]         \n\t"
+      "paddh      %[src0],         %[src0],           %[ftmp12]         \n\t"
+      "psrlh      %[src0],         %[src0],           %[one]            \n\t"
+      "dsll       %[dest0_u],      %[src0],           %[sixteen]        \n\t"
+      "pinsrh_0   %[dest0_u],      %[dest0_u],        %[value]          \n\t"
+      "pinsrh_3   %[dest0_v],      %[src0],           %[value]          \n\t"
+      "pmaddhw    %[dest0_u],      %[dest0_u],        %[mask_u]         \n\t"
+      "pmaddhw    %[dest0_v],      %[dest0_v],        %[mask_v]         \n\t"
+
+      "gsldrc1    %[src0],         0x06(%[src_rgb])                    \n\t"
+      "gsldlc1    %[src0],         0x0d(%[src_rgb])                    \n\t"
+      "gsldrc1    %[src1],         0x06(%[src_rgb1])                    \n\t"
+      "gsldlc1    %[src1],         0x0d(%[src_rgb1])                    \n\t"
+      "punpcklbh  %[src_lo],       %[src0],           %[zero]           \n\t"
+      "dsll       %[src0],         %[src0],           %[eight]          \n\t"
+      "punpckhbh  %[src_hi],       %[src0],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src_lo],         %[src_hi]         \n\t"
+      "punpcklbh  %[src_lo],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_lo]         \n\t"
+      "dsll       %[src1],         %[src1],           %[eight]          \n\t"
+      "punpckhbh  %[src_hi],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_hi]         \n\t"
+      "paddh      %[src0],         %[src0],           %[ftmp12]         \n\t"
+      "psrlh      %[src0],         %[src0],           %[one]            \n\t"
+      "dsll       %[src_lo],       %[src0],           %[sixteen]        \n\t"
+      "pinsrh_0   %[src_lo],       %[src_lo],         %[value]          \n\t"
+      "pinsrh_3   %[src_hi],       %[src0],           %[value]          \n\t"
+      "pmaddhw    %[src_lo],       %[src_lo],         %[mask_u]         \n\t"
+      "pmaddhw    %[src_hi],       %[src_hi],         %[mask_v]         \n\t"
+
+      "punpcklwd  %[src0],         %[dest0_u],        %[src_lo]         \n\t"
+      "punpckhwd  %[src1],         %[dest0_u],        %[src_lo]         \n\t"
+      "psubw      %[dest0_u],      %[src0],           %[src1]           \n\t"
+      "psraw      %[dest0_u],      %[dest0_u],        %[eight]          \n\t"
+      "punpcklwd  %[src0],         %[dest0_v],        %[src_hi]         \n\t"
+      "punpckhwd  %[src1],         %[dest0_v],        %[src_hi]         \n\t"
+      "psubw      %[dest0_v],      %[src1],           %[src0]           \n\t"
+      "psraw      %[dest0_v],      %[dest0_v],        %[eight]          \n\t"
+
+      "gsldrc1    %[src0],         0x0c(%[src_rgb])                    \n\t"
+      "gsldlc1    %[src0],         0x13(%[src_rgb])                    \n\t"
+      "gsldrc1    %[src1],         0x0c(%[src_rgb1])                    \n\t"
+      "gsldlc1    %[src1],         0x13(%[src_rgb1])                    \n\t"
+      "punpcklbh  %[src_lo],       %[src0],           %[zero]           \n\t"
+      "dsll       %[src0],         %[src0],           %[eight]          \n\t"
+      "punpckhbh  %[src_hi],       %[src0],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src_lo],         %[src_hi]         \n\t"
+      "punpcklbh  %[src_lo],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_lo]         \n\t"
+      "dsll       %[src1],         %[src1],           %[eight]          \n\t"
+      "punpckhbh  %[src_hi],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_hi]         \n\t"
+      "paddh      %[src0],         %[src0],           %[ftmp12]         \n\t"
+      "psrlh      %[src0],         %[src0],           %[one]            \n\t"
+      "dsll       %[dest1_u],      %[src0],           %[sixteen]        \n\t"
+      "pinsrh_0   %[dest1_u],      %[dest1_u],        %[value]          \n\t"
+      "pinsrh_3   %[dest1_v],      %[src0],           %[value]          \n\t"
+      "pmaddhw    %[dest1_u],      %[dest1_u],        %[mask_u]         \n\t"
+      "pmaddhw    %[dest1_v],      %[dest1_v],        %[mask_v]         \n\t"
+
+      "gsldrc1    %[src0],         0x12(%[src_rgb])                    \n\t"
+      "gsldlc1    %[src0],         0x19(%[src_rgb])                    \n\t"
+      "gsldrc1    %[src1],         0x12(%[src_rgb1])                    \n\t"
+      "gsldlc1    %[src1],         0x19(%[src_rgb1])                    \n\t"
+      "punpcklbh  %[src_lo],       %[src0],           %[zero]           \n\t"
+      "dsll       %[src0],         %[src0],           %[eight]          \n\t"
+      "punpckhbh  %[src_hi],       %[src0],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src_lo],         %[src_hi]         \n\t"
+      "punpcklbh  %[src_lo],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_lo]         \n\t"
+      "dsll       %[src1],         %[src1],           %[eight]          \n\t"
+      "punpckhbh  %[src_hi],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_hi]         \n\t"
+      "paddh      %[src0],         %[src0],           %[ftmp12]         \n\t"
+      "psrlh      %[src0],         %[src0],           %[one]            \n\t"
+      "dsll       %[src_lo],       %[src0],           %[sixteen]        \n\t"
+      "pinsrh_0   %[src_lo],       %[src_lo],         %[value]          \n\t"
+      "pinsrh_3   %[src_hi],       %[src0],           %[value]          \n\t"
+      "pmaddhw    %[src_lo],       %[src_lo],         %[mask_u]         \n\t"
+      "pmaddhw    %[src_hi],       %[src_hi],         %[mask_v]         \n\t"
+
+      "punpcklwd  %[src0],         %[dest1_u],        %[src_lo]         \n\t"
+      "punpckhwd  %[src1],         %[dest1_u],        %[src_lo]         \n\t"
+      "psubw      %[dest1_u],      %[src0],           %[src1]           \n\t"
+      "psraw      %[dest1_u],      %[dest1_u],        %[eight]          \n\t"
+      "punpcklwd  %[src0],         %[dest1_v],        %[src_hi]         \n\t"
+      "punpckhwd  %[src1],         %[dest1_v],        %[src_hi]         \n\t"
+      "psubw      %[dest1_v],      %[src1],           %[src0]           \n\t"
+      "psraw      %[dest1_v],      %[dest1_v],        %[eight]          \n\t"
+
+      "gsldrc1    %[src0],         0x18(%[src_rgb])                    \n\t"
+      "gsldlc1    %[src0],         0x1f(%[src_rgb])                    \n\t"
+      "gsldrc1    %[src1],         0x18(%[src_rgb1])                    \n\t"
+      "gsldlc1    %[src1],         0x1f(%[src_rgb1])                    \n\t"
+      "punpcklbh  %[src_lo],       %[src0],           %[zero]           \n\t"
+      "dsll       %[src0],         %[src0],           %[eight]          \n\t"
+      "punpckhbh  %[src_hi],       %[src0],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src_lo],         %[src_hi]         \n\t"
+      "punpcklbh  %[src_lo],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_lo]         \n\t"
+      "dsll       %[src1],         %[src1],           %[eight]          \n\t"
+      "punpckhbh  %[src_hi],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_hi]         \n\t"
+      "paddh      %[src0],         %[src0],           %[ftmp12]         \n\t"
+      "psrlh      %[src0],         %[src0],           %[one]            \n\t"
+      "dsll       %[dest2_u],      %[src0],           %[sixteen]        \n\t"
+      "pinsrh_0   %[dest2_u],      %[dest2_u],        %[value]          \n\t"
+      "pinsrh_3   %[dest2_v],      %[src0],           %[value]          \n\t"
+      "pmaddhw    %[dest2_u],      %[dest2_u],        %[mask_u]         \n\t"
+      "pmaddhw    %[dest2_v],      %[dest2_v],        %[mask_v]         \n\t"
+
+      "gsldrc1    %[src0],         0x1e(%[src_rgb])                    \n\t"
+      "gsldlc1    %[src0],         0x25(%[src_rgb])                    \n\t"
+      "gsldrc1    %[src1],         0x1e(%[src_rgb1])                    \n\t"
+      "gsldlc1    %[src1],         0x25(%[src_rgb1])                    \n\t"
+      "punpcklbh  %[src_lo],       %[src0],           %[zero]           \n\t"
+      "dsll       %[src0],         %[src0],           %[eight]          \n\t"
+      "punpckhbh  %[src_hi],       %[src0],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src_lo],         %[src_hi]         \n\t"
+      "punpcklbh  %[src_lo],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_lo]         \n\t"
+      "dsll       %[src1],         %[src1],           %[eight]          \n\t"
+      "punpckhbh  %[src_hi],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_hi]         \n\t"
+      "paddh      %[src0],         %[src0],           %[ftmp12]         \n\t"
+      "psrlh      %[src0],         %[src0],           %[one]            \n\t"
+      "dsll       %[src_lo],       %[src0],           %[sixteen]        \n\t"
+      "pinsrh_0   %[src_lo],       %[src_lo],         %[value]          \n\t"
+      "pinsrh_3   %[src_hi],       %[src0],           %[value]          \n\t"
+      "pmaddhw    %[src_lo],       %[src_lo],         %[mask_u]         \n\t"
+      "pmaddhw    %[src_hi],       %[src_hi],         %[mask_v]         \n\t"
+
+      "punpcklwd  %[src0],         %[dest2_u],        %[src_lo]         \n\t"
+      "punpckhwd  %[src1],         %[dest2_u],        %[src_lo]         \n\t"
+      "psubw      %[dest2_u],      %[src0],           %[src1]           \n\t"
+      "psraw      %[dest2_u],      %[dest2_u],        %[eight]          \n\t"
+      "punpcklwd  %[src0],         %[dest2_v],        %[src_hi]         \n\t"
+      "punpckhwd  %[src1],         %[dest2_v],        %[src_hi]         \n\t"
+      "psubw      %[dest2_v],      %[src1],           %[src0]           \n\t"
+      "psraw      %[dest2_v],      %[dest2_v],        %[eight]          \n\t"
+
+      "gsldrc1    %[src0],         0x24(%[src_rgb])                    \n\t"
+      "gsldlc1    %[src0],         0x2b(%[src_rgb])                    \n\t"
+      "gsldrc1    %[src1],         0x24(%[src_rgb1])                    \n\t"
+      "gsldlc1    %[src1],         0x2b(%[src_rgb1])                    \n\t"
+      "punpcklbh  %[src_lo],       %[src0],           %[zero]           \n\t"
+      "dsll       %[src0],         %[src0],           %[eight]          \n\t"
+      "punpckhbh  %[src_hi],       %[src0],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src_lo],         %[src_hi]         \n\t"
+      "punpcklbh  %[src_lo],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_lo]         \n\t"
+      "dsll       %[src1],         %[src1],           %[eight]          \n\t"
+      "punpckhbh  %[src_hi],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_hi]         \n\t"
+      "paddh      %[src0],         %[src0],           %[ftmp12]         \n\t"
+      "psrlh      %[src0],         %[src0],           %[one]            \n\t"
+      "dsll       %[dest3_u],      %[src0],           %[sixteen]        \n\t"
+      "pinsrh_0   %[dest3_u],      %[dest3_u],        %[value]          \n\t"
+      "pinsrh_3   %[dest3_v],      %[src0],           %[value]          \n\t"
+      "pmaddhw    %[dest3_u],      %[dest3_u],        %[mask_u]         \n\t"
+      "pmaddhw    %[dest3_v],      %[dest3_v],        %[mask_v]         \n\t"
+
+      "gsldrc1    %[src0],         0x2a(%[src_rgb])                    \n\t"
+      "gsldlc1    %[src0],         0x31(%[src_rgb])                    \n\t"
+      "gsldrc1    %[src1],         0x2a(%[src_rgb1])                    \n\t"
+      "gsldlc1    %[src1],         0x31(%[src_rgb1])                    \n\t"
+      "punpcklbh  %[src_lo],       %[src0],           %[zero]           \n\t"
+      "dsll       %[src0],         %[src0],           %[eight]          \n\t"
+      "punpckhbh  %[src_hi],       %[src0],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src_lo],         %[src_hi]         \n\t"
+      "punpcklbh  %[src_lo],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_lo]         \n\t"
+      "dsll       %[src1],         %[src1],           %[eight]          \n\t"
+      "punpckhbh  %[src_hi],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_hi]         \n\t"
+      "paddh      %[src0],         %[src0],           %[ftmp12]         \n\t"
+      "psrlh      %[src0],         %[src0],           %[one]            \n\t"
+      "dsll       %[src_lo],       %[src0],           %[sixteen]        \n\t"
+      "pinsrh_0   %[src_lo],       %[src_lo],         %[value]          \n\t"
+      "pinsrh_3   %[src_hi],       %[src0],           %[value]          \n\t"
+      "pmaddhw    %[src_lo],       %[src_lo],         %[mask_u]         \n\t"
+      "pmaddhw    %[src_hi],       %[src_hi],         %[mask_v]         \n\t"
+
+      "punpcklwd  %[src0],         %[dest3_u],        %[src_lo]         \n\t"
+      "punpckhwd  %[src1],         %[dest3_u],        %[src_lo]         \n\t"
+      "psubw      %[dest3_u],      %[src0],           %[src1]           \n\t"
+      "psraw      %[dest3_u],      %[dest3_u],        %[eight]          \n\t"
+      "punpcklwd  %[src0],         %[dest3_v],        %[src_hi]         \n\t"
+      "punpckhwd  %[src1],         %[dest3_v],        %[src_hi]         \n\t"
+      "psubw      %[dest3_v],      %[src1],           %[src0]           \n\t"
+      "psraw      %[dest3_v],      %[dest3_v],        %[eight]          \n\t"
+
+      "packsswh   %[src0],         %[dest0_u],        %[dest1_u]        \n\t"
+      "packsswh   %[src1],         %[dest2_u],        %[dest3_u]        \n\t"
+      "packushb   %[dest0_u],      %[src0],           %[src1]           \n\t"
+      "gssdlc1    %[dest0_u],      0x07(%[dst_u])                       \n\t"
+      "gssdrc1    %[dest0_u],      0x00(%[dst_u])                       \n\t"
+
+      "packsswh   %[src0],         %[dest0_v],        %[dest1_v]        \n\t"
+      "packsswh   %[src1],         %[dest2_v],        %[dest3_v]        \n\t"
+      "packushb   %[dest0_v],      %[src0],           %[src1]           \n\t"
+      "gssdlc1    %[dest0_v],      0x07(%[dst_v])                       \n\t"
+      "gssdrc1    %[dest0_v],      0x00(%[dst_v])                       \n\t"
+
+      "daddiu     %[src_rgb],     %[src_rgb],       0x30              \n\t"
+      "daddiu     %[dst_u],        %[dst_u],          0x08              \n\t"
+      "daddiu     %[dst_v],        %[dst_v],          0x08              \n\t"
+      "daddi      %[width],        %[width],         -0x10              \n\t"
+      "bgtz       %[width],        1b                                   \n\t"
+      : [src_rgb1] "=&r"(src_rgb1), [src0] "=&f"(ftmp[0]),
+        [src1] "=&f"(ftmp[1]), [src_lo] "=&f"(ftmp[2]), [src_hi] "=&f"(ftmp[3]),
+        [dest0_u] "=&f"(ftmp[4]), [dest0_v] "=&f"(ftmp[5]),
+        [dest1_u] "=&f"(ftmp[6]), [dest1_v] "=&f"(ftmp[7]),
+        [dest2_u] "=&f"(ftmp[8]), [dest2_v] "=&f"(ftmp[9]),
+        [dest3_u] "=&f"(ftmp[10]), [dest3_v] "=&f"(ftmp[11]),
+        [ftmp12] "=&f"(ftmp[12]), [tmp0] "=&r"(tmp[0])
+      : [src_rgb] "r"(src_rgb), [src_stride_rgb] "r"(src_stride_rgb),
+        [dst_u] "r"(dst_u), [dst_v] "r"(dst_v), [width] "r"(width),
+        [mask_u] "f"(mask_u), [mask_v] "f"(mask_v), [value] "f"(value),
+        [zero] "f"(0x00), [eight] "f"(0x08), [one] "f"(0x01),
+        [sixteen] "f"(0x10)
+      : "memory");
+}
+
+void RAWToYRow_MMI(const uint8_t* src_argb, uint8_t* dst_y, int width) {
+  uint64_t src, src_hi, src_lo;
+  uint64_t dest0, dest1, dest2, dest3;
+  const uint64_t value = 0x1080;
+  const uint64_t mask = 0x0001001900810042;
+
+  __asm__ volatile(
+      "1:                                                           \n\t"
+      "gsldlc1    %[src],          0x07(%[src_argb])               \n\t"
+      "gsldrc1    %[src],          0x00(%[src_argb])               \n\t"
+      "punpcklbh  %[src_lo],       %[src],            %[zero]       \n\t"
+      "pinsrh_3   %[src_lo],       %[src_lo],         %[value]      \n\t"
+      "pmaddhw    %[src_lo],       %[src_lo],         %[mask]       \n\t"
+      "dsll       %[src],          %[src],            %[eight]      \n\t"
+      "punpckhbh  %[src_hi],       %[src],            %[zero]       \n\t"
+      "pinsrh_3   %[src_hi],       %[src_hi],         %[value]      \n\t"
+      "pmaddhw    %[src_hi],       %[src_hi],         %[mask]       \n\t"
+      "punpcklwd  %[src],          %[src_lo],         %[src_hi]     \n\t"
+      "punpckhwd  %[dest0],        %[src_lo],         %[src_hi]     \n\t"
+      "paddw      %[dest0],        %[dest0],          %[src]        \n\t"
+      "psrlw      %[dest0],        %[dest0],          %[eight]      \n\t"
+
+      "gsldlc1    %[src],          0x0d(%[src_argb])               \n\t"
+      "gsldrc1    %[src],          0x06(%[src_argb])               \n\t"
+      "punpcklbh  %[src_lo],       %[src],            %[zero]       \n\t"
+      "pinsrh_3   %[src_lo],       %[src_lo],         %[value]      \n\t"
+      "pmaddhw    %[src_lo],       %[src_lo],         %[mask]       \n\t"
+      "dsll       %[src],          %[src],            %[eight]      \n\t"
+      "punpckhbh  %[src_hi],       %[src],            %[zero]       \n\t"
+      "pinsrh_3   %[src_hi],       %[src_hi],         %[value]      \n\t"
+      "pmaddhw    %[src_hi],       %[src_hi],         %[mask]       \n\t"
+      "punpcklwd  %[src],          %[src_lo],         %[src_hi]     \n\t"
+      "punpckhwd  %[dest1],        %[src_lo],         %[src_hi]     \n\t"
+      "paddw      %[dest1],        %[dest1],          %[src]        \n\t"
+      "psrlw      %[dest1],        %[dest1],          %[eight]      \n\t"
+
+      "gsldlc1    %[src],          0x13(%[src_argb])               \n\t"
+      "gsldrc1    %[src],          0x0c(%[src_argb])               \n\t"
+      "punpcklbh  %[src_lo],       %[src],            %[zero]       \n\t"
+      "pinsrh_3   %[src_lo],       %[src_lo],         %[value]      \n\t"
+      "pmaddhw    %[src_lo],       %[src_lo],         %[mask]       \n\t"
+      "dsll       %[src],          %[src],            %[eight]      \n\t"
+      "punpckhbh  %[src_hi],       %[src],            %[zero]       \n\t"
+      "pinsrh_3   %[src_hi],       %[src_hi],         %[value]      \n\t"
+      "pmaddhw    %[src_hi],       %[src_hi],         %[mask]       \n\t"
+      "punpcklwd  %[src],          %[src_lo],         %[src_hi]     \n\t"
+      "punpckhwd  %[dest2],        %[src_lo],         %[src_hi]     \n\t"
+      "paddw      %[dest2],        %[dest2],          %[src]        \n\t"
+      "psrlw      %[dest2],        %[dest2],          %[eight]      \n\t"
+
+      "gsldlc1    %[src],          0x19(%[src_argb])               \n\t"
+      "gsldrc1    %[src],          0x12(%[src_argb])               \n\t"
+      "punpcklbh  %[src_lo],       %[src],            %[zero]       \n\t"
+      "pinsrh_3   %[src_lo],       %[src_lo],         %[value]      \n\t"
+      "pmaddhw    %[src_lo],       %[src_lo],         %[mask]       \n\t"
+      "dsll       %[src],          %[src],            %[eight]      \n\t"
+      "punpckhbh  %[src_hi],       %[src],            %[zero]       \n\t"
+      "pinsrh_3   %[src_hi],       %[src_hi],         %[value]      \n\t"
+      "pmaddhw    %[src_hi],       %[src_hi],         %[mask]       \n\t"
+      "punpcklwd  %[src],          %[src_lo],         %[src_hi]     \n\t"
+      "punpckhwd  %[dest3],        %[src_lo],         %[src_hi]     \n\t"
+      "paddw      %[dest3],        %[dest3],          %[src]        \n\t"
+      "psrlw      %[dest3],        %[dest3],          %[eight]      \n\t"
+
+      "packsswh   %[src_lo],       %[dest0],          %[dest1]      \n\t"
+      "packsswh   %[src_hi],       %[dest2],          %[dest3]      \n\t"
+      "packushb   %[dest0],        %[src_lo],         %[src_hi]     \n\t"
+      "gssdlc1    %[dest0],        0x07(%[dst_y])                   \n\t"
+      "gssdrc1    %[dest0],        0x00(%[dst_y])                   \n\t"
+
+      "daddiu     %[src_argb],    %[src_argb],      0x18          \n\t"
+      "daddiu     %[dst_y],        %[dst_y],          0x08          \n\t"
+      "daddi      %[width],        %[width],         -0x08          \n\t"
+      "bnez       %[width],        1b                               \n\t"
+      : [src] "=&f"(src), [src_hi] "=&f"(src_hi), [src_lo] "=&f"(src_lo),
+        [dest0] "=&f"(dest0), [dest1] "=&f"(dest1), [dest2] "=&f"(dest2),
+        [dest3] "=&f"(dest3)
+      : [src_argb] "r"(src_argb), [dst_y] "r"(dst_y), [width] "r"(width),
+        [mask] "f"(mask), [value] "f"(value), [eight] "f"(0x08),
+        [zero] "f"(0x00)
+      : "memory");
+}
+
+void RAWToUVRow_MMI(const uint8_t* src_rgb,
+                    int src_stride_rgb,
+                    uint8_t* dst_u,
+                    uint8_t* dst_v,
+                    int width) {
+  uint64_t src_rgb1;
+  uint64_t ftmp[13];
+  uint64_t tmp[1];
+  const uint64_t value = 0x4040;
+  const uint64_t mask_u = 0x0002003800250013;
+  const uint64_t mask_v = 0x0009002f00380002;
+
+  __asm__ volatile(
+      "dli        %[tmp0],         0x0001000100010001                   \n\t"
+      "dmtc1      %[tmp0],         %[ftmp12]                            \n\t"
+      "1:                                                               \n\t"
+      "daddu      %[src_rgb1],     %[src_rgb],       %[src_stride_rgb] \n\t"
+      "gsldrc1    %[src0],         0x00(%[src_rgb])                    \n\t"
+      "gsldlc1    %[src0],         0x07(%[src_rgb])                    \n\t"
+      "gsldrc1    %[src1],         0x00(%[src_rgb1])                    \n\t"
+      "gsldlc1    %[src1],         0x07(%[src_rgb1])                    \n\t"
+      "punpcklbh  %[src_lo],       %[src0],           %[zero]           \n\t"
+      "dsll       %[src0],         %[src0],           %[eight]          \n\t"
+      "punpckhbh  %[src_hi],       %[src0],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src_lo],         %[src_hi]         \n\t"
+      "punpcklbh  %[src_lo],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_lo]         \n\t"
+      "dsll       %[src1],         %[src1],           %[eight]          \n\t"
+      "punpckhbh  %[src_hi],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_hi]         \n\t"
+      "paddh      %[src0],         %[src0],           %[ftmp12]         \n\t"
+      "psrlh      %[src0],         %[src0],           %[one]            \n\t"
+      "pinsrh_3   %[dest0_u],      %[src0],           %[value]          \n\t"
+      "dsll       %[dest0_v],      %[src0],           %[sixteen]        \n\t"
+      "pinsrh_0   %[dest0_v],      %[dest0_v],        %[value]          \n\t"
+      "pmaddhw    %[dest0_u],      %[dest0_u],        %[mask_u]         \n\t"
+      "pmaddhw    %[dest0_v],      %[dest0_v],        %[mask_v]         \n\t"
+
+      "gsldrc1    %[src0],         0x06(%[src_rgb])                    \n\t"
+      "gsldlc1    %[src0],         0x0d(%[src_rgb])                    \n\t"
+      "gsldrc1    %[src1],         0x06(%[src_rgb1])                    \n\t"
+      "gsldlc1    %[src1],         0x0d(%[src_rgb1])                    \n\t"
+      "punpcklbh  %[src_lo],       %[src0],           %[zero]           \n\t"
+      "dsll       %[src0],         %[src0],           %[eight]          \n\t"
+      "punpckhbh  %[src_hi],       %[src0],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src_lo],         %[src_hi]         \n\t"
+      "punpcklbh  %[src_lo],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_lo]         \n\t"
+      "dsll       %[src1],         %[src1],           %[eight]          \n\t"
+      "punpckhbh  %[src_hi],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_hi]         \n\t"
+      "paddh      %[src0],         %[src0],           %[ftmp12]         \n\t"
+      "psrlh      %[src0],         %[src0],           %[one]            \n\t"
+      "pinsrh_3   %[src_lo],       %[src0],           %[value]          \n\t"
+      "dsll       %[src_hi],       %[src0],           %[sixteen]        \n\t"
+      "pinsrh_0   %[src_hi],       %[src_hi],         %[value]          \n\t"
+      "pmaddhw    %[src_lo],       %[src_lo],         %[mask_u]         \n\t"
+      "pmaddhw    %[src_hi],       %[src_hi],         %[mask_v]         \n\t"
+
+      "punpcklwd  %[src0],         %[dest0_u],        %[src_lo]         \n\t"
+      "punpckhwd  %[src1],         %[dest0_u],        %[src_lo]         \n\t"
+      "psubw      %[dest0_u],      %[src1],           %[src0]           \n\t"
+      "psraw      %[dest0_u],      %[dest0_u],        %[eight]          \n\t"
+      "punpcklwd  %[src0],         %[dest0_v],        %[src_hi]         \n\t"
+      "punpckhwd  %[src1],         %[dest0_v],        %[src_hi]         \n\t"
+      "psubw      %[dest0_v],      %[src0],           %[src1]           \n\t"
+      "psraw      %[dest0_v],      %[dest0_v],        %[eight]          \n\t"
+
+      "gsldrc1    %[src0],         0x0c(%[src_rgb])                    \n\t"
+      "gsldlc1    %[src0],         0x13(%[src_rgb])                    \n\t"
+      "gsldrc1    %[src1],         0x0c(%[src_rgb1])                    \n\t"
+      "gsldlc1    %[src1],         0x13(%[src_rgb1])                    \n\t"
+      "punpcklbh  %[src_lo],       %[src0],           %[zero]           \n\t"
+      "dsll       %[src0],         %[src0],           %[eight]          \n\t"
+      "punpckhbh  %[src_hi],       %[src0],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src_lo],         %[src_hi]         \n\t"
+      "punpcklbh  %[src_lo],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_lo]         \n\t"
+      "dsll       %[src1],         %[src1],           %[eight]          \n\t"
+      "punpckhbh  %[src_hi],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_hi]         \n\t"
+      "paddh      %[src0],         %[src0],           %[ftmp12]         \n\t"
+      "psrlh      %[src0],         %[src0],           %[one]            \n\t"
+      "pinsrh_3   %[dest1_u],      %[src0],           %[value]          \n\t"
+      "dsll       %[dest1_v],      %[src0],           %[sixteen]        \n\t"
+      "pinsrh_0   %[dest1_v],      %[dest1_v],        %[value]          \n\t"
+      "pmaddhw    %[dest1_u],      %[dest1_u],        %[mask_u]         \n\t"
+      "pmaddhw    %[dest1_v],      %[dest1_v],        %[mask_v]         \n\t"
+
+      "gsldrc1    %[src0],         0x12(%[src_rgb])                    \n\t"
+      "gsldlc1    %[src0],         0x19(%[src_rgb])                    \n\t"
+      "gsldrc1    %[src1],         0x12(%[src_rgb1])                    \n\t"
+      "gsldlc1    %[src1],         0x19(%[src_rgb1])                    \n\t"
+      "punpcklbh  %[src_lo],       %[src0],           %[zero]           \n\t"
+      "dsll       %[src0],         %[src0],           %[eight]          \n\t"
+      "punpckhbh  %[src_hi],       %[src0],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src_lo],         %[src_hi]         \n\t"
+      "punpcklbh  %[src_lo],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_lo]         \n\t"
+      "dsll       %[src1],         %[src1],           %[eight]          \n\t"
+      "punpckhbh  %[src_hi],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_hi]         \n\t"
+      "paddh      %[src0],         %[src0],           %[ftmp12]         \n\t"
+      "psrlh      %[src0],         %[src0],           %[one]            \n\t"
+      "pinsrh_3   %[src_lo],       %[src0],           %[value]          \n\t"
+      "dsll       %[src_hi],       %[src0],           %[sixteen]        \n\t"
+      "pinsrh_0   %[src_hi],       %[src_hi],         %[value]          \n\t"
+      "pmaddhw    %[src_lo],       %[src_lo],         %[mask_u]         \n\t"
+      "pmaddhw    %[src_hi],       %[src_hi],         %[mask_v]         \n\t"
+
+      "punpcklwd  %[src0],         %[dest1_u],        %[src_lo]         \n\t"
+      "punpckhwd  %[src1],         %[dest1_u],        %[src_lo]         \n\t"
+      "psubw      %[dest1_u],      %[src1],           %[src0]           \n\t"
+      "psraw      %[dest1_u],      %[dest1_u],        %[eight]          \n\t"
+      "punpcklwd  %[src0],         %[dest1_v],        %[src_hi]         \n\t"
+      "punpckhwd  %[src1],         %[dest1_v],        %[src_hi]         \n\t"
+      "psubw      %[dest1_v],      %[src0],           %[src1]           \n\t"
+      "psraw      %[dest1_v],      %[dest1_v],        %[eight]          \n\t"
+
+      "gsldrc1    %[src0],         0x18(%[src_rgb])                    \n\t"
+      "gsldlc1    %[src0],         0x1f(%[src_rgb])                    \n\t"
+      "gsldrc1    %[src1],         0x18(%[src_rgb1])                    \n\t"
+      "gsldlc1    %[src1],         0x1f(%[src_rgb1])                    \n\t"
+      "punpcklbh  %[src_lo],       %[src0],           %[zero]           \n\t"
+      "dsll       %[src0],         %[src0],           %[eight]          \n\t"
+      "punpckhbh  %[src_hi],       %[src0],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src_lo],         %[src_hi]         \n\t"
+      "punpcklbh  %[src_lo],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_lo]         \n\t"
+      "dsll       %[src1],         %[src1],           %[eight]          \n\t"
+      "punpckhbh  %[src_hi],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_hi]         \n\t"
+      "paddh      %[src0],         %[src0],           %[ftmp12]         \n\t"
+      "psrlh      %[src0],         %[src0],           %[one]            \n\t"
+      "pinsrh_3   %[dest2_u],      %[src0],           %[value]          \n\t"
+      "dsll       %[dest2_v],      %[src0],           %[sixteen]        \n\t"
+      "pinsrh_0   %[dest2_v],      %[dest2_v],        %[value]          \n\t"
+      "pmaddhw    %[dest2_u],      %[dest2_u],        %[mask_u]         \n\t"
+      "pmaddhw    %[dest2_v],      %[dest2_v],        %[mask_v]         \n\t"
+
+      "gsldrc1    %[src0],         0x1e(%[src_rgb])                    \n\t"
+      "gsldlc1    %[src0],         0x25(%[src_rgb])                    \n\t"
+      "gsldrc1    %[src1],         0x1e(%[src_rgb1])                    \n\t"
+      "gsldlc1    %[src1],         0x25(%[src_rgb1])                    \n\t"
+      "punpcklbh  %[src_lo],       %[src0],           %[zero]           \n\t"
+      "dsll       %[src0],         %[src0],           %[eight]          \n\t"
+      "punpckhbh  %[src_hi],       %[src0],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src_lo],         %[src_hi]         \n\t"
+      "punpcklbh  %[src_lo],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_lo]         \n\t"
+      "dsll       %[src1],         %[src1],           %[eight]          \n\t"
+      "punpckhbh  %[src_hi],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_hi]         \n\t"
+      "paddh      %[src0],         %[src0],           %[ftmp12]         \n\t"
+      "psrlh      %[src0],         %[src0],           %[one]            \n\t"
+      "pinsrh_3   %[src_lo],       %[src0],           %[value]          \n\t"
+      "dsll       %[src_hi],       %[src0],           %[sixteen]        \n\t"
+      "pinsrh_0   %[src_hi],       %[src_hi],         %[value]          \n\t"
+      "pmaddhw    %[src_lo],       %[src_lo],         %[mask_u]         \n\t"
+      "pmaddhw    %[src_hi],       %[src_hi],         %[mask_v]         \n\t"
+
+      "punpcklwd  %[src0],         %[dest2_u],        %[src_lo]         \n\t"
+      "punpckhwd  %[src1],         %[dest2_u],        %[src_lo]         \n\t"
+      "psubw      %[dest2_u],      %[src1],           %[src0]           \n\t"
+      "psraw      %[dest2_u],      %[dest2_u],        %[eight]          \n\t"
+      "punpcklwd  %[src0],         %[dest2_v],        %[src_hi]         \n\t"
+      "punpckhwd  %[src1],         %[dest2_v],        %[src_hi]         \n\t"
+      "psubw      %[dest2_v],      %[src0],           %[src1]           \n\t"
+      "psraw      %[dest2_v],      %[dest2_v],        %[eight]          \n\t"
+
+      "gsldrc1    %[src0],         0x24(%[src_rgb])                    \n\t"
+      "gsldlc1    %[src0],         0x2b(%[src_rgb])                    \n\t"
+      "gsldrc1    %[src1],         0x24(%[src_rgb1])                    \n\t"
+      "gsldlc1    %[src1],         0x2b(%[src_rgb1])                    \n\t"
+      "punpcklbh  %[src_lo],       %[src0],           %[zero]           \n\t"
+      "dsll       %[src0],         %[src0],           %[eight]          \n\t"
+      "punpckhbh  %[src_hi],       %[src0],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src_lo],         %[src_hi]         \n\t"
+      "punpcklbh  %[src_lo],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_lo]         \n\t"
+      "dsll       %[src1],         %[src1],           %[eight]          \n\t"
+      "punpckhbh  %[src_hi],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_hi]         \n\t"
+      "paddh      %[src0],         %[src0],           %[ftmp12]         \n\t"
+      "psrlh      %[src0],         %[src0],           %[one]            \n\t"
+      "pinsrh_3   %[dest3_u],      %[src0],           %[value]          \n\t"
+      "dsll       %[dest3_v],      %[src0],           %[sixteen]        \n\t"
+      "pinsrh_0   %[dest3_v],      %[dest3_v],        %[value]          \n\t"
+      "pmaddhw    %[dest3_u],      %[dest3_u],        %[mask_u]         \n\t"
+      "pmaddhw    %[dest3_v],      %[dest3_v],        %[mask_v]         \n\t"
+
+      "gsldrc1    %[src0],         0x2a(%[src_rgb])                    \n\t"
+      "gsldlc1    %[src0],         0x31(%[src_rgb])                    \n\t"
+      "gsldrc1    %[src1],         0x2a(%[src_rgb1])                    \n\t"
+      "gsldlc1    %[src1],         0x31(%[src_rgb1])                    \n\t"
+      "punpcklbh  %[src_lo],       %[src0],           %[zero]           \n\t"
+      "dsll       %[src0],         %[src0],           %[eight]          \n\t"
+      "punpckhbh  %[src_hi],       %[src0],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src_lo],         %[src_hi]         \n\t"
+      "punpcklbh  %[src_lo],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_lo]         \n\t"
+      "dsll       %[src1],         %[src1],           %[eight]          \n\t"
+      "punpckhbh  %[src_hi],       %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src0],           %[src_hi]         \n\t"
+      "paddh      %[src0],         %[src0],           %[ftmp12]         \n\t"
+      "psrlh      %[src0],         %[src0],           %[one]            \n\t"
+      "pinsrh_3   %[src_lo],       %[src0],           %[value]          \n\t"
+      "dsll       %[src_hi],       %[src0],           %[sixteen]        \n\t"
+      "pinsrh_0   %[src_hi],       %[src_hi],         %[value]          \n\t"
+      "pmaddhw    %[src_lo],       %[src_lo],         %[mask_u]         \n\t"
+      "pmaddhw    %[src_hi],       %[src_hi],         %[mask_v]         \n\t"
+
+      "punpcklwd  %[src0],         %[dest3_u],        %[src_lo]         \n\t"
+      "punpckhwd  %[src1],         %[dest3_u],        %[src_lo]         \n\t"
+      "psubw      %[dest3_u],      %[src1],           %[src0]           \n\t"
+      "psraw      %[dest3_u],      %[dest3_u],        %[eight]          \n\t"
+      "punpcklwd  %[src0],         %[dest3_v],        %[src_hi]         \n\t"
+      "punpckhwd  %[src1],         %[dest3_v],        %[src_hi]         \n\t"
+      "psubw      %[dest3_v],      %[src0],           %[src1]           \n\t"
+      "psraw      %[dest3_v],      %[dest3_v],        %[eight]          \n\t"
+
+      "packsswh   %[src0],         %[dest0_u],        %[dest1_u]        \n\t"
+      "packsswh   %[src1],         %[dest2_u],        %[dest3_u]        \n\t"
+      "packushb   %[dest0_u],      %[src0],           %[src1]           \n\t"
+      "gssdlc1    %[dest0_u],      0x07(%[dst_u])                       \n\t"
+      "gssdrc1    %[dest0_u],      0x00(%[dst_u])                       \n\t"
+
+      "packsswh   %[src0],         %[dest0_v],        %[dest1_v]        \n\t"
+      "packsswh   %[src1],         %[dest2_v],        %[dest3_v]        \n\t"
+      "packushb   %[dest0_v],      %[src0],           %[src1]           \n\t"
+      "gssdlc1    %[dest0_v],      0x07(%[dst_v])                       \n\t"
+      "gssdrc1    %[dest0_v],      0x00(%[dst_v])                       \n\t"
+
+      "daddiu     %[src_rgb],     %[src_rgb],       0x30              \n\t"
+      "daddiu     %[dst_u],        %[dst_u],          0x08              \n\t"
+      "daddiu     %[dst_v],        %[dst_v],          0x08              \n\t"
+      "daddi      %[width],        %[width],         -0x10              \n\t"
+      "bgtz       %[width],        1b                                   \n\t"
+      : [src_rgb1] "=&r"(src_rgb1), [src0] "=&f"(ftmp[0]),
+        [src1] "=&f"(ftmp[1]), [src_lo] "=&f"(ftmp[2]), [src_hi] "=&f"(ftmp[3]),
+        [dest0_u] "=&f"(ftmp[4]), [dest0_v] "=&f"(ftmp[5]),
+        [dest1_u] "=&f"(ftmp[6]), [dest1_v] "=&f"(ftmp[7]),
+        [dest2_u] "=&f"(ftmp[8]), [dest2_v] "=&f"(ftmp[9]),
+        [dest3_u] "=&f"(ftmp[10]), [dest3_v] "=&f"(ftmp[11]),
+        [ftmp12] "=&f"(ftmp[12]), [tmp0] "=&r"(tmp[0])
+      : [src_rgb] "r"(src_rgb), [src_stride_rgb] "r"(src_stride_rgb),
+        [dst_u] "r"(dst_u), [dst_v] "r"(dst_v), [width] "r"(width),
+        [mask_u] "f"(mask_u), [mask_v] "f"(mask_v), [value] "f"(value),
+        [zero] "f"(0x00), [eight] "f"(0x08), [one] "f"(0x01),
+        [sixteen] "f"(0x10)
+      : "memory");
+}
+
+void ARGBToYJRow_MMI(const uint8_t* src_argb, uint8_t* dst_y, int width) {
+  uint64_t src, src_hi, src_lo;
+  uint64_t dest, dest0, dest1, dest2, dest3;
+  uint64_t tmp0, tmp1;
+  const uint64_t shift = 0x08;
+  const uint64_t value = 0x80;
+  const uint64_t mask0 = 0x0;
+  const uint64_t mask1 = 0x0001004D0096001DULL;
+
+  __asm__ volatile(
+      "1:                                                           \n\t"
+      "gsldlc1    %[src],          0x07(%[src_ptr])                 \n\t"
+      "gsldrc1    %[src],          0x00(%[src_ptr])                 \n\t"
+      "punpcklbh  %[src_lo],       %[src],            %[mask0]      \n\t"
+      "pinsrh_3   %[src_lo],       %[src_lo],         %[value]      \n\t"
+      "pmaddhw    %[src_lo],       %[src_lo],         %[mask1]      \n\t"
+      "punpckhbh  %[src_hi],       %[src],            %[mask0]      \n\t"
+      "pinsrh_3   %[src_hi],       %[src_hi],         %[value]      \n\t"
+      "pmaddhw    %[src_hi],       %[src_hi],         %[mask1]      \n\t"
+      "punpcklwd  %[tmp0],         %[src_lo],         %[src_hi]     \n\t"
+      "punpckhwd  %[tmp1],         %[src_lo],         %[src_hi]     \n\t"
+      "paddw      %[dest0],        %[tmp0],           %[tmp1]       \n\t"
+      "psrlw      %[dest0],        %[dest0],          %[shift]      \n\t"
+
+      "gsldlc1    %[src],          0x0f(%[src_ptr])                 \n\t"
+      "gsldrc1    %[src],          0x08(%[src_ptr])                 \n\t"
+      "punpcklbh  %[src_lo],       %[src],            %[mask0]      \n\t"
+      "pinsrh_3   %[src_lo],       %[src_lo],         %[value]      \n\t"
+      "pmaddhw    %[src_lo],       %[src_lo],         %[mask1]      \n\t"
+      "punpckhbh  %[src_hi],       %[src],            %[mask0]      \n\t"
+      "pinsrh_3   %[src_hi],       %[src_hi],         %[value]      \n\t"
+      "pmaddhw    %[src_hi],       %[src_hi],         %[mask1]      \n\t"
+      "punpcklwd  %[tmp0],         %[src_lo],         %[src_hi]     \n\t"
+      "punpckhwd  %[tmp1],         %[src_lo],         %[src_hi]     \n\t"
+      "paddw      %[dest1],        %[tmp0],           %[tmp1]       \n\t"
+      "psrlw      %[dest1],        %[dest1],          %[shift]      \n\t"
+
+      "gsldlc1    %[src],          0x17(%[src_ptr])                 \n\t"
+      "gsldrc1    %[src],          0x10(%[src_ptr])                 \n\t"
+      "punpcklbh  %[src_lo],       %[src],            %[mask0]      \n\t"
+      "pinsrh_3   %[src_lo],       %[src_lo],         %[value]      \n\t"
+      "pmaddhw    %[src_lo],       %[src_lo],         %[mask1]      \n\t"
+      "punpckhbh  %[src_hi],       %[src],            %[mask0]      \n\t"
+      "pinsrh_3   %[src_hi],       %[src_hi],         %[value]      \n\t"
+      "pmaddhw    %[src_hi],       %[src_hi],         %[mask1]      \n\t"
+      "punpcklwd  %[tmp0],         %[src_lo],         %[src_hi]     \n\t"
+      "punpckhwd  %[tmp1],         %[src_lo],         %[src_hi]     \n\t"
+      "paddw      %[dest2],        %[tmp0],           %[tmp1]       \n\t"
+      "psrlw      %[dest2],        %[dest2],          %[shift]      \n\t"
+
+      "gsldlc1    %[src],          0x1f(%[src_ptr])                 \n\t"
+      "gsldrc1    %[src],          0x18(%[src_ptr])                 \n\t"
+      "punpcklbh  %[src_lo],       %[src],            %[mask0]      \n\t"
+      "pinsrh_3   %[src_lo],       %[src_lo],         %[value]      \n\t"
+      "pmaddhw    %[src_lo],       %[src_lo],         %[mask1]      \n\t"
+      "punpckhbh  %[src_hi],       %[src],            %[mask0]      \n\t"
+      "pinsrh_3   %[src_hi],       %[src_hi],         %[value]      \n\t"
+      "pmaddhw    %[src_hi],       %[src_hi],         %[mask1]      \n\t"
+      "punpcklwd  %[tmp0],         %[src_lo],         %[src_hi]     \n\t"
+      "punpckhwd  %[tmp1],         %[src_lo],         %[src_hi]     \n\t"
+      "paddw      %[dest3],        %[tmp0],           %[tmp1]       \n\t"
+      "psrlw      %[dest3],        %[dest3],          %[shift]      \n\t"
+
+      "packsswh   %[tmp0],         %[dest0],          %[dest1]      \n\t"
+      "packsswh   %[tmp1],         %[dest2],          %[dest3]      \n\t"
+      "packushb   %[dest],         %[tmp0],           %[tmp1]       \n\t"
+      "gssdlc1    %[dest],         0x07(%[dst_ptr])                 \n\t"
+      "gssdrc1    %[dest],         0x00(%[dst_ptr])                 \n\t"
+
+      "daddiu     %[src_ptr],      %[src_ptr],        0x20          \n\t"
+      "daddiu     %[dst_ptr],      %[dst_ptr],        0x08          \n\t"
+      "daddi      %[width],        %[width],         -0x08          \n\t"
+      "bnez       %[width],        1b                               \n\t"
+      : [src] "=&f"(src), [dest] "=&f"(dest), [src_hi] "=&f"(src_hi),
+        [src_lo] "=&f"(src_lo), [dest0] "=&f"(dest0), [dest1] "=&f"(dest1),
+        [dest2] "=&f"(dest2), [dest3] "=&f"(dest3), [tmp0] "=&f"(tmp0),
+        [tmp1] "=&f"(tmp1)
+      : [src_ptr] "r"(src_argb), [dst_ptr] "r"(dst_y), [mask0] "f"(mask0),
+        [mask1] "f"(mask1), [shift] "f"(shift), [value] "f"(value),
+        [width] "r"(width)
+      : "memory");
+}
+
+void ARGBToUVJRow_MMI(const uint8_t* src_rgb,
+                      int src_stride_rgb,
+                      uint8_t* dst_u,
+                      uint8_t* dst_v,
+                      int width) {
+  uint64_t src_rgb1;
+  uint64_t ftmp[12];
+  const uint64_t value = 0x4040;
+  const uint64_t mask_u = 0x0015002a003f0002;
+  const uint64_t mask_v = 0x0002003f0035000a;
+
+  __asm__ volatile(
+      "1:                                                               \n\t"
+      "daddu      %[src_rgb1],     %[src_rgb],       %[src_stride_rgb] \n\t"
+      "gsldrc1    %[src0],         0x00(%[src_rgb])                    \n\t"
+      "gsldlc1    %[src0],         0x07(%[src_rgb])                    \n\t"
+      "gsldrc1    %[src1],         0x00(%[src_rgb1])                    \n\t"
+      "gsldlc1    %[src1],         0x07(%[src_rgb1])                    \n\t"
+      "punpcklbh  %[src_lo],       %[src0],           %[zero]           \n\t"
+      "punpckhbh  %[src_hi],       %[src0],           %[zero]           \n\t"
+      "punpcklbh  %[src0],         %[src1],           %[zero]           \n\t"
+      "punpckhbh  %[src1],         %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src_lo],         %[src0]           \n\t"
+      "paddh      %[src1],         %[src_hi],         %[src1]           \n\t"
+      "pavgh      %[src0],         %[src0],           %[src1]           \n\t"
+      "dsll       %[dest0_u],      %[src0],           %[sixteen]        \n\t"
+      "pinsrh_0   %[dest0_u],      %[dest0_u],        %[value]          \n\t"
+      "pinsrh_3   %[dest0_v],      %[src0],           %[value]          \n\t"
+      "pmaddhw    %[dest0_u],      %[dest0_u],        %[mask_u]         \n\t"
+      "pmaddhw    %[dest0_v],      %[dest0_v],        %[mask_v]         \n\t"
+
+      "gsldrc1    %[src0],         0x08(%[src_rgb])                    \n\t"
+      "gsldlc1    %[src0],         0x0f(%[src_rgb])                    \n\t"
+      "gsldrc1    %[src1],         0x08(%[src_rgb1])                    \n\t"
+      "gsldlc1    %[src1],         0x0f(%[src_rgb1])                    \n\t"
+      "punpcklbh  %[src_lo],       %[src0],           %[zero]           \n\t"
+      "punpckhbh  %[src_hi],       %[src0],           %[zero]           \n\t"
+      "punpcklbh  %[src0],         %[src1],           %[zero]           \n\t"
+      "punpckhbh  %[src1],         %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src_lo],         %[src0]           \n\t"
+      "paddh      %[src1],         %[src_hi],         %[src1]           \n\t"
+      "pavgh      %[src0],         %[src0],           %[src1]           \n\t"
+      "dsll       %[src_lo],       %[src0],           %[sixteen]        \n\t"
+      "pinsrh_0   %[src_lo],       %[src_lo],         %[value]          \n\t"
+      "pinsrh_3   %[src_hi],       %[src0],           %[value]          \n\t"
+      "pmaddhw    %[src_lo],       %[src_lo],         %[mask_u]         \n\t"
+      "pmaddhw    %[src_hi],       %[src_hi],         %[mask_v]         \n\t"
+
+      "punpcklwd  %[src0],         %[dest0_u],        %[src_lo]         \n\t"
+      "punpckhwd  %[src1],         %[dest0_u],        %[src_lo]         \n\t"
+      "psubw      %[dest0_u],      %[src0],           %[src1]           \n\t"
+      "psraw      %[dest0_u],      %[dest0_u],        %[eight]          \n\t"
+      "punpcklwd  %[src0],         %[dest0_v],        %[src_hi]         \n\t"
+      "punpckhwd  %[src1],         %[dest0_v],        %[src_hi]         \n\t"
+      "psubw      %[dest0_v],      %[src1],           %[src0]           \n\t"
+      "psraw      %[dest0_v],      %[dest0_v],        %[eight]          \n\t"
+
+      "gsldrc1    %[src0],         0x10(%[src_rgb])                    \n\t"
+      "gsldlc1    %[src0],         0x17(%[src_rgb])                    \n\t"
+      "gsldrc1    %[src1],         0x10(%[src_rgb1])                    \n\t"
+      "gsldlc1    %[src1],         0x17(%[src_rgb1])                    \n\t"
+      "punpcklbh  %[src_lo],       %[src0],           %[zero]           \n\t"
+      "punpckhbh  %[src_hi],       %[src0],           %[zero]           \n\t"
+      "punpcklbh  %[src0],         %[src1],           %[zero]           \n\t"
+      "punpckhbh  %[src1],         %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src_lo],         %[src0]           \n\t"
+      "paddh      %[src1],         %[src_hi],         %[src1]           \n\t"
+      "pavgh      %[src0],         %[src0],           %[src1]           \n\t"
+      "dsll       %[dest1_u],      %[src0],           %[sixteen]        \n\t"
+      "pinsrh_0   %[dest1_u],      %[dest1_u],        %[value]          \n\t"
+      "pinsrh_3   %[dest1_v],      %[src0],           %[value]          \n\t"
+      "pmaddhw    %[dest1_u],      %[dest1_u],        %[mask_u]         \n\t"
+      "pmaddhw    %[dest1_v],      %[dest1_v],        %[mask_v]         \n\t"
+
+      "gsldrc1    %[src0],         0x18(%[src_rgb])                    \n\t"
+      "gsldlc1    %[src0],         0x1f(%[src_rgb])                    \n\t"
+      "gsldrc1    %[src1],         0x18(%[src_rgb1])                    \n\t"
+      "gsldlc1    %[src1],         0x1f(%[src_rgb1])                    \n\t"
+      "punpcklbh  %[src_lo],       %[src0],           %[zero]           \n\t"
+      "punpckhbh  %[src_hi],       %[src0],           %[zero]           \n\t"
+      "punpcklbh  %[src0],         %[src1],           %[zero]           \n\t"
+      "punpckhbh  %[src1],         %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src_lo],         %[src0]           \n\t"
+      "paddh      %[src1],         %[src_hi],         %[src1]           \n\t"
+      "pavgh      %[src0],         %[src0],           %[src1]           \n\t"
+      "dsll       %[src_lo],       %[src0],           %[sixteen]        \n\t"
+      "pinsrh_0   %[src_lo],       %[src_lo],         %[value]          \n\t"
+      "pinsrh_3   %[src_hi],       %[src0],           %[value]          \n\t"
+      "pmaddhw    %[src_lo],       %[src_lo],         %[mask_u]         \n\t"
+      "pmaddhw    %[src_hi],       %[src_hi],         %[mask_v]         \n\t"
+
+      "punpcklwd  %[src0],         %[dest1_u],        %[src_lo]         \n\t"
+      "punpckhwd  %[src1],         %[dest1_u],        %[src_lo]         \n\t"
+      "psubw      %[dest1_u],      %[src0],           %[src1]           \n\t"
+      "psraw      %[dest1_u],      %[dest1_u],        %[eight]          \n\t"
+      "punpcklwd  %[src0],         %[dest1_v],        %[src_hi]         \n\t"
+      "punpckhwd  %[src1],         %[dest1_v],        %[src_hi]         \n\t"
+      "psubw      %[dest1_v],      %[src1],           %[src0]           \n\t"
+      "psraw      %[dest1_v],      %[dest1_v],        %[eight]          \n\t"
+
+      "gsldrc1    %[src0],         0x20(%[src_rgb])                    \n\t"
+      "gsldlc1    %[src0],         0x27(%[src_rgb])                    \n\t"
+      "gsldrc1    %[src1],         0x20(%[src_rgb1])                    \n\t"
+      "gsldlc1    %[src1],         0x27(%[src_rgb1])                    \n\t"
+      "punpcklbh  %[src_lo],       %[src0],           %[zero]           \n\t"
+      "punpckhbh  %[src_hi],       %[src0],           %[zero]           \n\t"
+      "punpcklbh  %[src0],         %[src1],           %[zero]           \n\t"
+      "punpckhbh  %[src1],         %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src_lo],         %[src0]           \n\t"
+      "paddh      %[src1],         %[src_hi],         %[src1]           \n\t"
+      "pavgh      %[src0],         %[src0],           %[src1]           \n\t"
+      "dsll       %[dest2_u],      %[src0],           %[sixteen]        \n\t"
+      "pinsrh_0   %[dest2_u],      %[dest2_u],        %[value]          \n\t"
+      "pinsrh_3   %[dest2_v],      %[src0],           %[value]          \n\t"
+      "pmaddhw    %[dest2_u],      %[dest2_u],        %[mask_u]         \n\t"
+      "pmaddhw    %[dest2_v],      %[dest2_v],        %[mask_v]         \n\t"
+
+      "gsldrc1    %[src0],         0x28(%[src_rgb])                    \n\t"
+      "gsldlc1    %[src0],         0x2f(%[src_rgb])                    \n\t"
+      "gsldrc1    %[src1],         0x28(%[src_rgb1])                    \n\t"
+      "gsldlc1    %[src1],         0x2f(%[src_rgb1])                    \n\t"
+      "punpcklbh  %[src_lo],       %[src0],           %[zero]           \n\t"
+      "punpckhbh  %[src_hi],       %[src0],           %[zero]           \n\t"
+      "punpcklbh  %[src0],         %[src1],           %[zero]           \n\t"
+      "punpckhbh  %[src1],         %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src_lo],         %[src0]           \n\t"
+      "paddh      %[src1],         %[src_hi],         %[src1]           \n\t"
+      "pavgh      %[src0],         %[src0],           %[src1]           \n\t"
+      "dsll       %[src_lo],       %[src0],           %[sixteen]        \n\t"
+      "pinsrh_0   %[src_lo],       %[src_lo],         %[value]          \n\t"
+      "pinsrh_3   %[src_hi],       %[src0],           %[value]          \n\t"
+      "pmaddhw    %[src_lo],       %[src_lo],         %[mask_u]         \n\t"
+      "pmaddhw    %[src_hi],       %[src_hi],         %[mask_v]         \n\t"
+
+      "punpcklwd  %[src0],         %[dest2_u],        %[src_lo]         \n\t"
+      "punpckhwd  %[src1],         %[dest2_u],        %[src_lo]         \n\t"
+      "psubw      %[dest2_u],      %[src0],           %[src1]           \n\t"
+      "psraw      %[dest2_u],      %[dest2_u],        %[eight]          \n\t"
+      "punpcklwd  %[src0],         %[dest2_v],        %[src_hi]         \n\t"
+      "punpckhwd  %[src1],         %[dest2_v],        %[src_hi]         \n\t"
+      "psubw      %[dest2_v],      %[src1],           %[src0]           \n\t"
+      "psraw      %[dest2_v],      %[dest2_v],        %[eight]          \n\t"
+
+      "gsldrc1    %[src0],         0x30(%[src_rgb])                    \n\t"
+      "gsldlc1    %[src0],         0x37(%[src_rgb])                    \n\t"
+      "gsldrc1    %[src1],         0x30(%[src_rgb1])                    \n\t"
+      "gsldlc1    %[src1],         0x37(%[src_rgb1])                    \n\t"
+      "punpcklbh  %[src_lo],       %[src0],           %[zero]           \n\t"
+      "punpckhbh  %[src_hi],       %[src0],           %[zero]           \n\t"
+      "punpcklbh  %[src0],         %[src1],           %[zero]           \n\t"
+      "punpckhbh  %[src1],         %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src_lo],         %[src0]           \n\t"
+      "paddh      %[src1],         %[src_hi],         %[src1]           \n\t"
+      "pavgh      %[src0],         %[src0],           %[src1]           \n\t"
+      "dsll       %[dest3_u],      %[src0],           %[sixteen]        \n\t"
+      "pinsrh_0   %[dest3_u],      %[dest3_u],        %[value]          \n\t"
+      "pinsrh_3   %[dest3_v],      %[src0],           %[value]          \n\t"
+      "pmaddhw    %[dest3_u],      %[dest3_u],        %[mask_u]         \n\t"
+      "pmaddhw    %[dest3_v],      %[dest3_v],        %[mask_v]         \n\t"
+
+      "gsldrc1    %[src0],         0x38(%[src_rgb])                    \n\t"
+      "gsldlc1    %[src0],         0x3f(%[src_rgb])                    \n\t"
+      "gsldrc1    %[src1],         0x38(%[src_rgb1])                    \n\t"
+      "gsldlc1    %[src1],         0x3f(%[src_rgb1])                    \n\t"
+      "punpcklbh  %[src_lo],       %[src0],           %[zero]           \n\t"
+      "punpckhbh  %[src_hi],       %[src0],           %[zero]           \n\t"
+      "punpcklbh  %[src0],         %[src1],           %[zero]           \n\t"
+      "punpckhbh  %[src1],         %[src1],           %[zero]           \n\t"
+      "paddh      %[src0],         %[src_lo],         %[src0]           \n\t"
+      "paddh      %[src1],         %[src_hi],         %[src1]           \n\t"
+      "pavgh      %[src0],         %[src0],           %[src1]           \n\t"
+      "dsll       %[src_lo],       %[src0],           %[sixteen]        \n\t"
+      "pinsrh_0   %[src_lo],       %[src_lo],         %[value]          \n\t"
+      "pinsrh_3   %[src_hi],       %[src0],           %[value]          \n\t"
+      "pmaddhw    %[src_lo],       %[src_lo],         %[mask_u]         \n\t"
+      "pmaddhw    %[src_hi],       %[src_hi],         %[mask_v]         \n\t"
+
+      "punpcklwd  %[src0],         %[dest3_u],        %[src_lo]         \n\t"
+      "punpckhwd  %[src1],         %[dest3_u],        %[src_lo]         \n\t"
+      "psubw      %[dest3_u],      %[src0],           %[src1]           \n\t"
+      "psraw      %[dest3_u],      %[dest3_u],        %[eight]          \n\t"
+      "punpcklwd  %[src0],         %[dest3_v],        %[src_hi]         \n\t"
+      "punpckhwd  %[src1],         %[dest3_v],        %[src_hi]         \n\t"
+      "psubw      %[dest3_v],      %[src1],           %[src0]           \n\t"
+      "psraw      %[dest3_v],      %[dest3_v],        %[eight]          \n\t"
+
+      "packsswh   %[src0],         %[dest0_u],        %[dest1_u]        \n\t"
+      "packsswh   %[src1],         %[dest2_u],        %[dest3_u]        \n\t"
+      "packushb   %[dest0_u],      %[src0],           %[src1]           \n\t"
+      "gssdlc1    %[dest0_u],      0x07(%[dst_u])                       \n\t"
+      "gssdrc1    %[dest0_u],      0x00(%[dst_u])                       \n\t"
+
+      "packsswh   %[src0],         %[dest0_v],        %[dest1_v]        \n\t"
+      "packsswh   %[src1],         %[dest2_v],        %[dest3_v]        \n\t"
+      "packushb   %[dest0_v],      %[src0],           %[src1]           \n\t"
+      "gssdlc1    %[dest0_v],      0x07(%[dst_v])                       \n\t"
+      "gssdrc1    %[dest0_v],      0x00(%[dst_v])                       \n\t"
+
+      "daddiu     %[src_rgb],     %[src_rgb],       0x40              \n\t"
+      "daddiu     %[dst_u],        %[dst_u],          0x08              \n\t"
+      "daddiu     %[dst_v],        %[dst_v],          0x08              \n\t"
+      "daddi      %[width],        %[width],         -0x10              \n\t"
+      "bgtz       %[width],        1b                                   \n\t"
+      : [src_rgb1] "=&r"(src_rgb1), [src0] "=&f"(ftmp[0]),
+        [src1] "=&f"(ftmp[1]), [src_lo] "=&f"(ftmp[2]), [src_hi] "=&f"(ftmp[3]),
+        [dest0_u] "=&f"(ftmp[4]), [dest0_v] "=&f"(ftmp[5]),
+        [dest1_u] "=&f"(ftmp[6]), [dest1_v] "=&f"(ftmp[7]),
+        [dest2_u] "=&f"(ftmp[8]), [dest2_v] "=&f"(ftmp[9]),
+        [dest3_u] "=&f"(ftmp[10]), [dest3_v] "=&f"(ftmp[11])
+      : [src_rgb] "r"(src_rgb), [src_stride_rgb] "r"(src_stride_rgb),
+        [dst_u] "r"(dst_u), [dst_v] "r"(dst_v), [width] "r"(width),
+        [mask_u] "f"(mask_u), [mask_v] "f"(mask_v), [value] "f"(value),
+        [zero] "f"(0x00), [eight] "f"(0x08),
+        [sixteen] "f"(0x10)
+      : "memory");
+}
+
+void RGB565ToYRow_MMI(const uint8_t* src_rgb565, uint8_t* dst_y, int width) {
+  uint64_t ftmp[11];
+  const uint64_t value = 0x1080108010801080;
+  const uint64_t mask = 0x0001004200810019;
+  uint64_t c0 = 0x001f001f001f001f;
+  uint64_t c1 = 0x00ff00ff00ff00ff;
+  uint64_t c2 = 0x0007000700070007;
+  __asm__ volatile(
+      "1:                                                            \n\t"
+      "gsldrc1    %[src0],        0x00(%[src_rgb565])                \n\t"
+      "gsldlc1    %[src0],        0x07(%[src_rgb565])                \n\t"
+      "psrlh      %[src1],        %[src0],             %[eight]      \n\t"
+      "and        %[b],           %[src0],             %[c0]         \n\t"
+      "and        %[src0],        %[src0],             %[c1]         \n\t"
+      "psrlh      %[src0],        %[src0],             %[five]       \n\t"
+      "and        %[g],           %[src1],             %[c2]         \n\t"
+      "psllh      %[g],           %[g],                %[three]      \n\t"
+      "or         %[g],           %[src0],             %[g]          \n\t"
+      "psrlh      %[r],           %[src1],             %[three]      \n\t"
+      "psllh      %[src0],        %[b],                %[three]      \n\t"
+      "psrlh      %[src1],        %[b],                %[two]        \n\t"
+      "or         %[b],           %[src0],             %[src1]       \n\t"
+      "psllh      %[src0],        %[g],                %[two]        \n\t"
+      "psrlh      %[src1],        %[g],                %[four]       \n\t"
+      "or         %[g],           %[src0],             %[src1]       \n\t"
+      "psllh      %[src0],        %[r],                %[three]      \n\t"
+      "psrlh      %[src1],        %[r],                %[two]        \n\t"
+      "or         %[r],           %[src0],             %[src1]       \n\t"
+      "punpcklhw  %[src0],        %[b],                %[r]          \n\t"
+      "punpcklhw  %[src1],        %[g],                %[value]      \n\t"
+      "punpcklhw  %[src_lo],      %[src0],             %[src1]       \n\t"
+      "punpckhhw  %[src_hi],      %[src0],             %[src1]       \n\t"
+      "pmaddhw    %[src_lo],      %[src_lo],           %[mask]       \n\t"
+      "pmaddhw    %[src_hi],      %[src_hi],           %[mask]       \n\t"
+      "punpcklwd  %[src0],        %[src_lo],           %[src_hi]     \n\t"
+      "punpckhwd  %[src1],        %[src_lo],           %[src_hi]     \n\t"
+      "paddw      %[dest0],       %[src0],             %[src1]       \n\t"
+      "psrlw      %[dest0],       %[dest0],            %[eight]      \n\t"
+
+      "punpckhhw  %[src0],        %[b],                %[r]          \n\t"
+      "punpckhhw  %[src1],        %[g],                %[value]      \n\t"
+      "punpcklhw  %[src_lo],      %[src0],             %[src1]       \n\t"
+      "punpckhhw  %[src_hi],      %[src0],             %[src1]       \n\t"
+      "pmaddhw    %[src_lo],      %[src_lo],           %[mask]       \n\t"
+      "pmaddhw    %[src_hi],      %[src_hi],           %[mask]       \n\t"
+      "punpcklwd  %[src0],        %[src_lo],           %[src_hi]     \n\t"
+      "punpckhwd  %[src1],        %[src_lo],           %[src_hi]     \n\t"
+      "paddw      %[dest1],       %[src0],             %[src1]       \n\t"
+      "psrlw      %[dest1],       %[dest1],            %[eight]      \n\t"
+
+      "gsldrc1    %[src0],        0x08(%[src_rgb565])                \n\t"
+      "gsldlc1    %[src0],        0x0f(%[src_rgb565])                \n\t"
+      "psrlh      %[src1],        %[src0],             %[eight]      \n\t"
+      "and        %[b],           %[src0],             %[c0]         \n\t"
+      "and        %[src0],        %[src0],             %[c1]         \n\t"
+      "psrlh      %[src0],        %[src0],             %[five]       \n\t"
+      "and        %[g],           %[src1],             %[c2]         \n\t"
+      "psllh      %[g],           %[g],                %[three]      \n\t"
+      "or         %[g],           %[src0],             %[g]          \n\t"
+      "psrlh      %[r],           %[src1],             %[three]      \n\t"
+      "psllh      %[src0],        %[b],                %[three]      \n\t"
+      "psrlh      %[src1],        %[b],                %[two]        \n\t"
+      "or         %[b],           %[src0],             %[src1]       \n\t"
+      "psllh      %[src0],        %[g],                %[two]        \n\t"
+      "psrlh      %[src1],        %[g],                %[four]       \n\t"
+      "or         %[g],           %[src0],             %[src1]       \n\t"
+      "psllh      %[src0],        %[r],                %[three]      \n\t"
+      "psrlh      %[src1],        %[r],                %[two]        \n\t"
+      "or         %[r],           %[src0],             %[src1]       \n\t"
+      "punpcklhw  %[src0],        %[b],                %[r]          \n\t"
+      "punpcklhw  %[src1],        %[g],                %[value]      \n\t"
+      "punpcklhw  %[src_lo],      %[src0],             %[src1]       \n\t"
+      "punpckhhw  %[src_hi],      %[src0],             %[src1]       \n\t"
+      "pmaddhw    %[src_lo],      %[src_lo],           %[mask]       \n\t"
+      "pmaddhw    %[src_hi],      %[src_hi],           %[mask]       \n\t"
+      "punpcklwd  %[src0],        %[src_lo],           %[src_hi]     \n\t"
+      "punpckhwd  %[src1],        %[src_lo],           %[src_hi]     \n\t"
+      "paddw      %[dest2],       %[src0],             %[src1]       \n\t"
+      "psrlw      %[dest2],       %[dest2],            %[eight]      \n\t"
+
+      "punpckhhw  %[src0],        %[b],                %[r]          \n\t"
+      "punpckhhw  %[src1],        %[g],                %[value]      \n\t"
+      "punpcklhw  %[src_lo],      %[src0],             %[src1]       \n\t"
+      "punpckhhw  %[src_hi],      %[src0],             %[src1]       \n\t"
+      "pmaddhw    %[src_lo],      %[src_lo],           %[mask]       \n\t"
+      "pmaddhw    %[src_hi],      %[src_hi],           %[mask]       \n\t"
+      "punpcklwd  %[src0],        %[src_lo],           %[src_hi]     \n\t"
+      "punpckhwd  %[src1],        %[src_lo],           %[src_hi]     \n\t"
+      "paddw      %[dest3],       %[src0],             %[src1]       \n\t"
+      "psrlw      %[dest3],       %[dest3],            %[eight]      \n\t"
+
+      "packsswh   %[src_lo],      %[dest0],            %[dest1]      \n\t"
+      "packsswh   %[src_hi],      %[dest2],            %[dest3]      \n\t"
+      "packushb   %[dest0],       %[src_lo],           %[src_hi]     \n\t"
+      "gssdlc1    %[dest0],       0x07(%[dst_y])                     \n\t"
+      "gssdrc1    %[dest0],       0x00(%[dst_y])                     \n\t"
+
+      "daddiu    %[src_rgb565],   %[src_rgb565],       0x10          \n\t"
+      "daddiu    %[dst_y],        %[dst_y],            0x08          \n\t"
+      "daddiu    %[width],        %[width],           -0x08          \n\t"
+      "bgtz      %[width],        1b                                 \n\t"
+      : [src0] "=&f"(ftmp[0]), [src1] "=&f"(ftmp[1]), [src_lo] "=&f"(ftmp[2]),
+        [src_hi] "=&f"(ftmp[3]), [b] "=&f"(ftmp[4]), [g] "=&f"(ftmp[5]),
+        [r] "=&f"(ftmp[6]), [dest0] "=&f"(ftmp[7]), [dest1] "=&f"(ftmp[8]),
+        [dest2] "=&f"(ftmp[9]), [dest3] "=&f"(ftmp[10])
+      : [src_rgb565] "r"(src_rgb565), [dst_y] "r"(dst_y), [value] "f"(value),
+        [width] "r"(width), [c0] "f"(c0), [c1] "f"(c1), [c2] "f"(c2),
+        [mask] "f"(mask), [eight] "f"(0x08), [five] "f"(0x05),
+        [three] "f"(0x03), [two] "f"(0x02), [four] "f"(0x04)
+      : "memory");
+}
+
+void ARGB1555ToYRow_MMI(const uint8_t* src_argb1555,
+                        uint8_t* dst_y,
+                        int width) {
+  uint64_t ftmp[11];
+  const uint64_t value = 0x1080108010801080;
+  const uint64_t mask = 0x0001004200810019;
+  uint64_t c0 = 0x001f001f001f001f;
+  uint64_t c1 = 0x00ff00ff00ff00ff;
+  uint64_t c2 = 0x0003000300030003;
+  uint64_t c3 = 0x007c007c007c007c;
+  __asm__ volatile(
+      "1:                                                            \n\t"
+      "gsldrc1    %[src0],         0x00(%[src_argb1555])             \n\t"
+      "gsldlc1    %[src0],         0x07(%[src_argb1555])             \n\t"
+      "psrlh      %[src1],         %[src0],              %[eight]    \n\t"
+      "and        %[b],            %[src0],              %[c0]       \n\t"
+      "and        %[src0],         %[src0],              %[c1]       \n\t"
+      "psrlh      %[src0],         %[src0],              %[five]     \n\t"
+      "and        %[g],            %[src1],              %[c2]       \n\t"
+      "psllh      %[g],            %[g],                 %[three]    \n\t"
+      "or         %[g],            %[src0],              %[g]        \n\t"
+      "and        %[r],            %[src1],              %[c3]       \n\t"
+      "psrlh      %[r],            %[r],                 %[two]      \n\t"
+      "psllh      %[src0],         %[b],                 %[three]    \n\t"
+      "psrlh      %[src1],         %[b],                 %[two]      \n\t"
+      "or         %[b],            %[src0],              %[src1]     \n\t"
+      "psllh      %[src0],         %[g],                 %[three]    \n\t"
+      "psrlh      %[src1],         %[g],                 %[two]      \n\t"
+      "or         %[g],            %[src0],              %[src1]     \n\t"
+      "psllh      %[src0],         %[r],                 %[three]    \n\t"
+      "psrlh      %[src1],         %[r],                 %[two]      \n\t"
+      "or         %[r],            %[src0],              %[src1]     \n\t"
+      "punpcklhw  %[src0],         %[b],                 %[r]        \n\t"
+      "punpcklhw  %[src1],         %[g],                 %[value]    \n\t"
+      "punpcklhw  %[src_lo],       %[src0],              %[src1]     \n\t"
+      "punpckhhw  %[src_hi],       %[src0],              %[src1]     \n\t"
+      "pmaddhw    %[src_lo],       %[src_lo],            %[mask]     \n\t"
+      "pmaddhw    %[src_hi],       %[src_hi],            %[mask]     \n\t"
+      "punpcklwd  %[src0],         %[src_lo],            %[src_hi]   \n\t"
+      "punpckhwd  %[src1],         %[src_lo],            %[src_hi]   \n\t"
+      "paddw      %[dest0],        %[src0],              %[src1]     \n\t"
+      "psrlw      %[dest0],        %[dest0],             %[eight]    \n\t"
+
+      "punpckhhw  %[src0],         %[b],                 %[r]        \n\t"
+      "punpckhhw  %[src1],         %[g],                 %[value]    \n\t"
+      "punpcklhw  %[src_lo],       %[src0],              %[src1]     \n\t"
+      "punpckhhw  %[src_hi],       %[src0],              %[src1]     \n\t"
+      "pmaddhw    %[src_lo],       %[src_lo],            %[mask]     \n\t"
+      "pmaddhw    %[src_hi],       %[src_hi],            %[mask]     \n\t"
+      "punpcklwd  %[src0],         %[src_lo],            %[src_hi]   \n\t"
+      "punpckhwd  %[src1],         %[src_lo],            %[src_hi]   \n\t"
+      "paddw      %[dest1],        %[src0],              %[src1]     \n\t"
+      "psrlw      %[dest1],        %[dest1],             %[eight]    \n\t"
+
+      "gsldrc1    %[src0],         0x08(%[src_argb1555])             \n\t"
+      "gsldlc1    %[src0],         0x0f(%[src_argb1555])             \n\t"
+      "psrlh      %[src1],         %[src0],              %[eight]    \n\t"
+      "and        %[b],            %[src0],              %[c0]       \n\t"
+      "and        %[src0],         %[src0],              %[c1]       \n\t"
+      "psrlh      %[src0],         %[src0],              %[five]     \n\t"
+      "and        %[g],            %[src1],              %[c2]       \n\t"
+      "psllh      %[g],            %[g],                 %[three]    \n\t"
+      "or         %[g],            %[src0],              %[g]        \n\t"
+      "and        %[r],            %[src1],              %[c3]       \n\t"
+      "psrlh      %[r],            %[r],                 %[two]      \n\t"
+      "psllh      %[src0],         %[b],                 %[three]    \n\t"
+      "psrlh      %[src1],         %[b],                 %[two]      \n\t"
+      "or         %[b],            %[src0],              %[src1]     \n\t"
+      "psllh      %[src0],         %[g],                 %[three]    \n\t"
+      "psrlh      %[src1],         %[g],                 %[two]      \n\t"
+      "or         %[g],            %[src0],              %[src1]     \n\t"
+      "psllh      %[src0],         %[r],                 %[three]    \n\t"
+      "psrlh      %[src1],         %[r],                 %[two]      \n\t"
+      "or         %[r],            %[src0],              %[src1]     \n\t"
+      "punpcklhw  %[src0],         %[b],                 %[r]        \n\t"
+      "punpcklhw  %[src1],         %[g],                 %[value]    \n\t"
+      "punpcklhw  %[src_lo],       %[src0],              %[src1]     \n\t"
+      "punpckhhw  %[src_hi],       %[src0],              %[src1]     \n\t"
+      "pmaddhw    %[src_lo],       %[src_lo],            %[mask]     \n\t"
+      "pmaddhw    %[src_hi],       %[src_hi],            %[mask]     \n\t"
+      "punpcklwd  %[src0],         %[src_lo],            %[src_hi]   \n\t"
+      "punpckhwd  %[src1],         %[src_lo],            %[src_hi]   \n\t"
+      "paddw      %[dest2],        %[src0],              %[src1]     \n\t"
+      "psrlw      %[dest2],        %[dest2],             %[eight]    \n\t"
+
+      "punpckhhw  %[src0],         %[b],                 %[r]        \n\t"
+      "punpckhhw  %[src1],         %[g],                 %[value]    \n\t"
+      "punpcklhw  %[src_lo],       %[src0],              %[src1]     \n\t"
+      "punpckhhw  %[src_hi],       %[src0],              %[src1]     \n\t"
+      "pmaddhw    %[src_lo],       %[src_lo],            %[mask]     \n\t"
+      "pmaddhw    %[src_hi],       %[src_hi],            %[mask]     \n\t"
+      "punpcklwd  %[src0],         %[src_lo],            %[src_hi]   \n\t"
+      "punpckhwd  %[src1],         %[src_lo],            %[src_hi]   \n\t"
+      "paddw      %[dest3],        %[src0],              %[src1]     \n\t"
+      "psrlw      %[dest3],        %[dest3],             %[eight]    \n\t"
+
+      "packsswh   %[src_lo],       %[dest0],             %[dest1]    \n\t"
+      "packsswh   %[src_hi],       %[dest2],             %[dest3]    \n\t"
+      "packushb   %[dest0],        %[src_lo],            %[src_hi]   \n\t"
+      "gssdlc1    %[dest0],        0x07(%[dst_y])                    \n\t"
+      "gssdrc1    %[dest0],        0x00(%[dst_y])                    \n\t"
+
+      "daddiu     %[src_argb1555], %[src_argb1555],      0x10        \n\t"
+      "daddiu     %[dst_y],        %[dst_y],             0x08        \n\t"
+      "daddiu     %[width],        %[width],            -0x08        \n\t"
+      "bgtz       %[width],        1b                                \n\t"
+      : [src0] "=&f"(ftmp[0]), [src1] "=&f"(ftmp[1]), [src_lo] "=&f"(ftmp[2]),
+        [src_hi] "=&f"(ftmp[3]), [b] "=&f"(ftmp[4]), [g] "=&f"(ftmp[5]),
+        [r] "=&f"(ftmp[6]), [dest0] "=&f"(ftmp[7]), [dest1] "=&f"(ftmp[8]),
+        [dest2] "=&f"(ftmp[9]), [dest3] "=&f"(ftmp[10])
+      : [src_argb1555] "r"(src_argb1555), [dst_y] "r"(dst_y),
+        [width] "r"(width), [value] "f"(value), [mask] "f"(mask), [c0] "f"(c0),
+        [c1] "f"(c1), [c2] "f"(c2), [c3] "f"(c3), [eight] "f"(0x08),
+        [five] "f"(0x05), [three] "f"(0x03), [two] "f"(0x02), [seven] "f"(0x07)
+      : "memory");
+}
+
+void ARGB4444ToYRow_MMI(const uint8_t* src_argb4444,
+                        uint8_t* dst_y,
+                        int width) {
+  uint64_t ftmp[11];
+  uint64_t value = 0x1080108010801080;
+  uint64_t mask = 0x0001004200810019;
+  uint64_t c0 = 0x000f000f000f000f;
+  uint64_t c1 = 0x00ff00ff00ff00ff;
+  __asm__ volatile(
+      "1:                                                            \n\t"
+      "gsldrc1    %[src0],         0x00(%[src_argb4444])             \n\t"
+      "gsldlc1    %[src0],         0x07(%[src_argb4444])             \n\t"
+      "psrlh      %[src1],         %[src0],              %[eight]    \n\t"
+      "and        %[b],            %[src0],              %[c0]       \n\t"
+      "and        %[src0],         %[src0],              %[c1]       \n\t"
+      "psrlh      %[g],            %[src0],              %[four]     \n\t"
+      "and        %[r],            %[src1],              %[c0]       \n\t"
+      "psllh      %[src0],         %[b],                 %[four]     \n\t"
+      "or         %[b],            %[src0],              %[b]        \n\t"
+      "psllh      %[src0],         %[g],                 %[four]     \n\t"
+      "or         %[g],            %[src0],              %[g]        \n\t"
+      "psllh      %[src0],         %[r],                 %[four]     \n\t"
+      "or         %[r],            %[src0],              %[r]        \n\t"
+      "punpcklhw  %[src0],         %[b],                 %[r]        \n\t"
+      "punpcklhw  %[src1],         %[g],                 %[value]    \n\t"
+      "punpcklhw  %[src_lo],       %[src0],              %[src1]     \n\t"
+      "punpckhhw  %[src_hi],       %[src0],              %[src1]     \n\t"
+      "pmaddhw    %[src_lo],       %[src_lo],            %[mask]     \n\t"
+      "pmaddhw    %[src_hi],       %[src_hi],            %[mask]     \n\t"
+      "punpcklwd  %[src0],         %[src_lo],            %[src_hi]   \n\t"
+      "punpckhwd  %[src1],         %[src_lo],            %[src_hi]   \n\t"
+      "paddw      %[dest0],        %[src0],              %[src1]     \n\t"
+      "psrlw      %[dest0],        %[dest0],             %[eight]    \n\t"
+
+      "punpckhhw  %[src0],         %[b],                 %[r]        \n\t"
+      "punpckhhw  %[src1],         %[g],                 %[value]    \n\t"
+      "punpcklhw  %[src_lo],       %[src0],              %[src1]     \n\t"
+      "punpckhhw  %[src_hi],       %[src0],              %[src1]     \n\t"
+      "pmaddhw    %[src_lo],       %[src_lo],            %[mask]     \n\t"
+      "pmaddhw    %[src_hi],       %[src_hi],            %[mask]     \n\t"
+      "punpcklwd  %[src0],         %[src_lo],            %[src_hi]   \n\t"
+      "punpckhwd  %[src1],         %[src_lo],            %[src_hi]   \n\t"
+      "paddw      %[dest1],        %[src0],              %[src1]     \n\t"
+      "psrlw      %[dest1],        %[dest1],             %[eight]    \n\t"
+
+      "gsldrc1    %[src0],         0x08(%[src_argb4444])             \n\t"
+      "gsldlc1    %[src0],         0x0f(%[src_argb4444])             \n\t"
+      "psrlh      %[src1],         %[src0],              %[eight]    \n\t"
+      "and        %[b],            %[src0],              %[c0]       \n\t"
+      "and        %[src0],         %[src0],              %[c1]       \n\t"
+      "psrlh      %[g],            %[src0],              %[four]     \n\t"
+      "and        %[r],            %[src1],              %[c0]       \n\t"
+      "psllh      %[src0],         %[b],                 %[four]     \n\t"
+      "or         %[b],            %[src0],              %[b]        \n\t"
+      "psllh      %[src0],         %[g],                 %[four]     \n\t"
+      "or         %[g],            %[src0],              %[g]        \n\t"
+      "psllh      %[src0],         %[r],                 %[four]     \n\t"
+      "or         %[r],            %[src0],              %[r]        \n\t"
+      "punpcklhw  %[src0],         %[b],                 %[r]        \n\t"
+      "punpcklhw  %[src1],         %[g],                 %[value]    \n\t"
+      "punpcklhw  %[src_lo],       %[src0],              %[src1]     \n\t"
+      "punpckhhw  %[src_hi],       %[src0],              %[src1]     \n\t"
+      "pmaddhw    %[src_lo],       %[src_lo],            %[mask]     \n\t"
+      "pmaddhw    %[src_hi],       %[src_hi],            %[mask]     \n\t"
+      "punpcklwd  %[src0],         %[src_lo],            %[src_hi]   \n\t"
+      "punpckhwd  %[src1],         %[src_lo],            %[src_hi]   \n\t"
+      "paddw      %[dest2],        %[src0],              %[src1]     \n\t"
+      "psrlw      %[dest2],        %[dest2],             %[eight]    \n\t"
+
+      "punpckhhw  %[src0],         %[b],                 %[r]        \n\t"
+      "punpckhhw  %[src1],         %[g],                 %[value]    \n\t"
+      "punpcklhw  %[src_lo],       %[src0],              %[src1]     \n\t"
+      "punpckhhw  %[src_hi],       %[src0],              %[src1]     \n\t"
+      "pmaddhw    %[src_lo],       %[src_lo],            %[mask]     \n\t"
+      "pmaddhw    %[src_hi],       %[src_hi],            %[mask]     \n\t"
+      "punpcklwd  %[src0],         %[src_lo],            %[src_hi]   \n\t"
+      "punpckhwd  %[src1],         %[src_lo],            %[src_hi]   \n\t"
+      "paddw      %[dest3],        %[src0],              %[src1]     \n\t"
+      "psrlw      %[dest3],        %[dest3],             %[eight]    \n\t"
+
+      "packsswh   %[src_lo],       %[dest0],             %[dest1]    \n\t"
+      "packsswh   %[src_hi],       %[dest2],             %[dest3]    \n\t"
+      "packushb   %[dest0],        %[src_lo],            %[src_hi]   \n\t"
+      "gssdlc1    %[dest0],        0x07(%[dst_y])                    \n\t"
+      "gssdrc1    %[dest0],        0x00(%[dst_y])                    \n\t"
+
+      "daddiu     %[src_argb4444], %[src_argb4444],      0x10        \n\t"
+      "daddiu     %[dst_y],        %[dst_y],             0x08        \n\t"
+      "daddiu     %[width],        %[width],            -0x08        \n\t"
+      "bgtz       %[width],        1b                                \n\t"
+      : [src0] "=&f"(ftmp[0]), [src1] "=&f"(ftmp[1]), [src_lo] "=&f"(ftmp[2]),
+        [src_hi] "=&f"(ftmp[3]), [b] "=&f"(ftmp[4]), [g] "=&f"(ftmp[5]),
+        [r] "=&f"(ftmp[6]), [dest0] "=&f"(ftmp[7]), [dest1] "=&f"(ftmp[8]),
+        [dest2] "=&f"(ftmp[9]), [dest3] "=&f"(ftmp[10])
+      : [src_argb4444] "r"(src_argb4444), [dst_y] "r"(dst_y),
+        [width] "r"(width), [value] "f"(value), [mask] "f"(mask), [c0] "f"(c0),
+        [c1] "f"(c1), [eight] "f"(0x08), [four] "f"(0x04)
+      : "memory");
+}
+
+void RGB565ToUVRow_MMI(const uint8_t* src_rgb565,
+                       int src_stride_rgb565,
+                       uint8_t* dst_u,
+                       uint8_t* dst_v,
+                       int width) {
+  uint64_t ftmp[13];
+  uint64_t value = 0x2020202020202020;
+  uint64_t mask_u = 0x0026004a00700002;
+  uint64_t mask_v = 0x00020070005e0012;
+  uint64_t mask = 0x93;
+  uint64_t c0 = 0x001f001f001f001f;
+  uint64_t c1 = 0x00ff00ff00ff00ff;
+  uint64_t c2 = 0x0007000700070007;
+  __asm__ volatile(
+      "daddu      %[next_rgb565], %[src_rgb565],       %[next_rgb565]   \n\t"
+      "1:                                                               \n\t"
+      "gsldrc1    %[src0],        0x00(%[src_rgb565])                   \n\t"
+      "gsldlc1    %[src0],        0x07(%[src_rgb565])                   \n\t"
+      "gsldrc1    %[src1],        0x00(%[next_rgb565])                  \n\t"
+      "gsldlc1    %[src1],        0x07(%[next_rgb565])                  \n\t"
+      "psrlh      %[dest0_u],     %[src0],             %[eight]         \n\t"
+      "and        %[b0],          %[src0],             %[c0]            \n\t"
+      "and        %[src0],        %[src0],             %[c1]            \n\t"
+      "psrlh      %[src0],        %[src0],             %[five]          \n\t"
+      "and        %[g0],          %[dest0_u],          %[c2]            \n\t"
+      "psllh      %[g0],          %[g0],               %[three]         \n\t"
+      "or         %[g0],          %[src0],             %[g0]            \n\t"
+      "psrlh      %[r0],          %[dest0_u],          %[three]         \n\t"
+      "psrlh      %[src0],        %[src1],             %[eight]         \n\t"
+      "and        %[dest0_u],     %[src1],             %[c0]            \n\t"
+      "and        %[src1],        %[src1],             %[c1]            \n\t"
+      "psrlh      %[src1],        %[src1],             %[five]          \n\t"
+      "and        %[dest0_v],     %[src0],             %[c2]            \n\t"
+      "psllh      %[dest0_v],     %[dest0_v],          %[three]         \n\t"
+      "or         %[dest0_v],     %[src1],             %[dest0_v]       \n\t"
+      "psrlh      %[src0],        %[src0],             %[three]         \n\t"
+      "paddh      %[b0],          %[b0],               %[dest0_u]       \n\t"
+      "paddh      %[g0],          %[g0],               %[dest0_v]       \n\t"
+      "paddh      %[r0],          %[r0],               %[src0]          \n\t"
+      "punpcklhw  %[src0],        %[b0],               %[r0]            \n\t"
+      "punpckhhw  %[src1],        %[b0],               %[r0]            \n\t"
+      "punpcklwd  %[dest0_u],     %[src0],             %[src1]          \n\t"
+      "punpckhwd  %[dest0_v],     %[src0],             %[src1]          \n\t"
+      "paddh      %[src0],        %[dest0_u],          %[dest0_v]       \n\t"
+      "psrlh      %[b0],          %[src0],             %[six]           \n\t"
+      "psllh      %[r0],          %[src0],             %[one]           \n\t"
+      "or         %[b0],          %[b0],               %[r0]            \n\t"
+      "punpcklhw  %[src0],        %[g0],               %[value]         \n\t"
+      "punpckhhw  %[src1],        %[g0],               %[value]         \n\t"
+      "punpcklwd  %[dest0_u],     %[src0],             %[src1]          \n\t"
+      "punpckhwd  %[dest0_v],     %[src0],             %[src1]          \n\t"
+      "paddh      %[g0],          %[dest0_u],          %[dest0_v]       \n\t"
+      "punpcklhw  %[src0],        %[b0],               %[g0]            \n\t"
+      "punpckhhw  %[src1],        %[b0],               %[g0]            \n\t"
+
+      "pmaddhw    %[dest0_v],     %[src0],             %[mask_v]        \n\t"
+      "pshufh     %[dest0_u],     %[src0],             %[mask]          \n\t"
+      "pmaddhw    %[dest0_u],     %[dest0_u],          %[mask_u]        \n\t"
+      "pmaddhw    %[g0],          %[src1],             %[mask_v]        \n\t"
+      "pshufh     %[b0],          %[src1],             %[mask]          \n\t"
+      "pmaddhw    %[b0],          %[b0],               %[mask_u]        \n\t"
+
+      "punpcklwd  %[src0],        %[dest0_u],          %[b0]            \n\t"
+      "punpckhwd  %[src1],        %[dest0_u],          %[b0]            \n\t"
+      "psubw      %[dest0_u],     %[src0],             %[src1]          \n\t"
+      "psraw      %[dest0_u],     %[dest0_u],          %[eight]         \n\t"
+      "punpcklwd  %[src0],        %[dest0_v],          %[g0]            \n\t"
+      "punpckhwd  %[src1],        %[dest0_v],          %[g0]            \n\t"
+      "psubw      %[dest0_v],     %[src1],             %[src0]          \n\t"
+      "psraw      %[dest0_v],     %[dest0_v],          %[eight]         \n\t"
+
+      "gsldrc1    %[src0],        0x08(%[src_rgb565])                   \n\t"
+      "gsldlc1    %[src0],        0x0f(%[src_rgb565])                   \n\t"
+      "gsldrc1    %[src1],        0x08(%[next_rgb565])                  \n\t"
+      "gsldlc1    %[src1],        0x0f(%[next_rgb565])                  \n\t"
+      "psrlh      %[dest1_u],     %[src0],             %[eight]         \n\t"
+      "and        %[b0],          %[src0],             %[c0]            \n\t"
+      "and        %[src0],        %[src0],             %[c1]            \n\t"
+      "psrlh      %[src0],        %[src0],             %[five]          \n\t"
+      "and        %[g0],          %[dest1_u],          %[c2]            \n\t"
+      "psllh      %[g0],          %[g0],               %[three]         \n\t"
+      "or         %[g0],          %[src0],             %[g0]            \n\t"
+      "psrlh      %[r0],          %[dest1_u],          %[three]         \n\t"
+      "psrlh      %[src0],        %[src1],             %[eight]         \n\t"
+      "and        %[dest1_u],     %[src1],             %[c0]            \n\t"
+      "and        %[src1],        %[src1],             %[c1]            \n\t"
+      "psrlh      %[src1],        %[src1],             %[five]          \n\t"
+      "and        %[dest1_v],     %[src0],             %[c2]            \n\t"
+      "psllh      %[dest1_v],     %[dest1_v],          %[three]         \n\t"
+      "or         %[dest1_v],     %[src1],             %[dest1_v]       \n\t"
+      "psrlh      %[src0],        %[src0],             %[three]         \n\t"
+      "paddh      %[b0],          %[b0],               %[dest1_u]       \n\t"
+      "paddh      %[g0],          %[g0],               %[dest1_v]       \n\t"
+      "paddh      %[r0],          %[r0],               %[src0]          \n\t"
+      "punpcklhw  %[src0],        %[b0],               %[r0]            \n\t"
+      "punpckhhw  %[src1],        %[b0],               %[r0]            \n\t"
+      "punpcklwd  %[dest1_u],     %[src0],             %[src1]          \n\t"
+      "punpckhwd  %[dest1_v],     %[src0],             %[src1]          \n\t"
+      "paddh      %[src0],        %[dest1_u],          %[dest1_v]       \n\t"
+      "psrlh      %[b0],          %[src0],             %[six]           \n\t"
+      "psllh      %[r0],          %[src0],             %[one]           \n\t"
+      "or         %[b0],          %[b0],               %[r0]            \n\t"
+      "punpcklhw  %[src0],        %[g0],               %[value]         \n\t"
+      "punpckhhw  %[src1],        %[g0],               %[value]         \n\t"
+      "punpcklwd  %[dest1_u],     %[src0],             %[src1]          \n\t"
+      "punpckhwd  %[dest1_v],     %[src0],             %[src1]          \n\t"
+      "paddh      %[g0],          %[dest1_u],          %[dest1_v]       \n\t"
+      "punpcklhw  %[src0],        %[b0],               %[g0]            \n\t"
+      "punpckhhw  %[src1],        %[b0],               %[g0]            \n\t"
+
+      "pmaddhw    %[dest1_v],     %[src0],             %[mask_v]        \n\t"
+      "pshufh     %[dest1_u],     %[src0],             %[mask]          \n\t"
+      "pmaddhw    %[dest1_u],     %[dest1_u],          %[mask_u]        \n\t"
+      "pmaddhw    %[g0],          %[src1],             %[mask_v]        \n\t"
+      "pshufh     %[b0],          %[src1],             %[mask]          \n\t"
+      "pmaddhw    %[b0],          %[b0],               %[mask_u]        \n\t"
+
+      "punpcklwd  %[src0],        %[dest1_u],          %[b0]            \n\t"
+      "punpckhwd  %[src1],        %[dest1_u],          %[b0]            \n\t"
+      "psubw      %[dest1_u],     %[src0],             %[src1]          \n\t"
+      "psraw      %[dest1_u],     %[dest1_u],          %[eight]         \n\t"
+      "punpcklwd  %[src0],        %[dest1_v],          %[g0]            \n\t"
+      "punpckhwd  %[src1],        %[dest1_v],          %[g0]            \n\t"
+      "psubw      %[dest1_v],     %[src1],             %[src0]          \n\t"
+      "psraw      %[dest1_v],     %[dest1_v],          %[eight]         \n\t"
+
+      "gsldrc1    %[src0],        0x10(%[src_rgb565])                   \n\t"
+      "gsldlc1    %[src0],        0x17(%[src_rgb565])                   \n\t"
+      "gsldrc1    %[src1],        0x10(%[next_rgb565])                  \n\t"
+      "gsldlc1    %[src1],        0x17(%[next_rgb565])                  \n\t"
+      "psrlh      %[dest2_u],     %[src0],             %[eight]         \n\t"
+      "and        %[b0],          %[src0],             %[c0]            \n\t"
+      "and        %[src0],        %[src0],             %[c1]            \n\t"
+      "psrlh      %[src0],        %[src0],             %[five]          \n\t"
+      "and        %[g0],          %[dest2_u],          %[c2]            \n\t"
+      "psllh      %[g0],          %[g0],               %[three]         \n\t"
+      "or         %[g0],          %[src0],             %[g0]            \n\t"
+      "psrlh      %[r0],          %[dest2_u],          %[three]         \n\t"
+      "psrlh      %[src0],        %[src1],             %[eight]         \n\t"
+      "and        %[dest2_u],     %[src1],             %[c0]            \n\t"
+      "and        %[src1],        %[src1],             %[c1]            \n\t"
+      "psrlh      %[src1],        %[src1],             %[five]          \n\t"
+      "and        %[dest2_v],     %[src0],             %[c2]            \n\t"
+      "psllh      %[dest2_v],     %[dest2_v],          %[three]         \n\t"
+      "or         %[dest2_v],     %[src1],             %[dest2_v]       \n\t"
+      "psrlh      %[src0],        %[src0],             %[three]         \n\t"
+      "paddh      %[b0],          %[b0],               %[dest2_u]       \n\t"
+      "paddh      %[g0],          %[g0],               %[dest2_v]       \n\t"
+      "paddh      %[r0],          %[r0],               %[src0]          \n\t"
+      "punpcklhw  %[src0],        %[b0],               %[r0]            \n\t"
+      "punpckhhw  %[src1],        %[b0],               %[r0]            \n\t"
+      "punpcklwd  %[dest2_u],     %[src0],             %[src1]          \n\t"
+      "punpckhwd  %[dest2_v],     %[src0],             %[src1]          \n\t"
+      "paddh      %[src0],        %[dest2_u],          %[dest2_v]       \n\t"
+      "psrlh      %[b0],          %[src0],             %[six]           \n\t"
+      "psllh      %[r0],          %[src0],             %[one]           \n\t"
+      "or         %[b0],          %[b0],               %[r0]            \n\t"
+      "punpcklhw  %[src0],        %[g0],               %[value]         \n\t"
+      "punpckhhw  %[src1],        %[g0],               %[value]         \n\t"
+      "punpcklwd  %[dest2_u],     %[src0],             %[src1]          \n\t"
+      "punpckhwd  %[dest2_v],     %[src0],             %[src1]          \n\t"
+      "paddh      %[g0],          %[dest2_u],          %[dest2_v]       \n\t"
+      "punpcklhw  %[src0],        %[b0],               %[g0]            \n\t"
+      "punpckhhw  %[src1],        %[b0],               %[g0]            \n\t"
+
+      "pmaddhw    %[dest2_v],     %[src0],             %[mask_v]        \n\t"
+      "pshufh     %[dest2_u],     %[src0],             %[mask]          \n\t"
+      "pmaddhw    %[dest2_u],     %[dest2_u],          %[mask_u]        \n\t"
+      "pmaddhw    %[g0],          %[src1],             %[mask_v]        \n\t"
+      "pshufh     %[b0],          %[src1],             %[mask]          \n\t"
+      "pmaddhw    %[b0],          %[b0],               %[mask_u]        \n\t"
+
+      "punpcklwd  %[src0],        %[dest2_u],          %[b0]            \n\t"
+      "punpckhwd  %[src1],        %[dest2_u],          %[b0]            \n\t"
+      "psubw      %[dest2_u],     %[src0],             %[src1]          \n\t"
+      "psraw      %[dest2_u],     %[dest2_u],          %[eight]         \n\t"
+      "punpcklwd  %[src0],        %[dest2_v],          %[g0]            \n\t"
+      "punpckhwd  %[src1],        %[dest2_v],          %[g0]            \n\t"
+      "psubw      %[dest2_v],     %[src1],             %[src0]          \n\t"
+      "psraw      %[dest2_v],     %[dest2_v],          %[eight]         \n\t"
+
+      "gsldrc1    %[src0],        0x18(%[src_rgb565])                   \n\t"
+      "gsldlc1    %[src0],        0x1f(%[src_rgb565])                   \n\t"
+      "gsldrc1    %[src1],        0x18(%[next_rgb565])                  \n\t"
+      "gsldlc1    %[src1],        0x1f(%[next_rgb565])                  \n\t"
+      "psrlh      %[dest3_u],     %[src0],             %[eight]         \n\t"
+      "and        %[b0],          %[src0],             %[c0]            \n\t"
+      "and        %[src0],        %[src0],             %[c1]            \n\t"
+      "psrlh      %[src0],        %[src0],             %[five]          \n\t"
+      "and        %[g0],          %[dest3_u],          %[c2]            \n\t"
+      "psllh      %[g0],          %[g0],               %[three]         \n\t"
+      "or         %[g0],          %[src0],             %[g0]            \n\t"
+      "psrlh      %[r0],          %[dest3_u],          %[three]         \n\t"
+      "psrlh      %[src0],        %[src1],             %[eight]         \n\t"
+      "and        %[dest3_u],     %[src1],             %[c0]            \n\t"
+      "and        %[src1],        %[src1],             %[c1]            \n\t"
+      "psrlh      %[src1],        %[src1],             %[five]          \n\t"
+      "and        %[dest3_v],     %[src0],             %[c2]            \n\t"
+      "psllh      %[dest3_v],     %[dest3_v],          %[three]         \n\t"
+      "or         %[dest3_v],     %[src1],             %[dest3_v]       \n\t"
+      "psrlh      %[src0],        %[src0],             %[three]         \n\t"
+      "paddh      %[b0],          %[b0],               %[dest3_u]       \n\t"
+      "paddh      %[g0],          %[g0],               %[dest3_v]       \n\t"
+      "paddh      %[r0],          %[r0],               %[src0]          \n\t"
+      "punpcklhw  %[src0],        %[b0],               %[r0]            \n\t"
+      "punpckhhw  %[src1],        %[b0],               %[r0]            \n\t"
+      "punpcklwd  %[dest3_u],     %[src0],             %[src1]          \n\t"
+      "punpckhwd  %[dest3_v],     %[src0],             %[src1]          \n\t"
+      "paddh      %[src0],        %[dest3_u],          %[dest3_v]       \n\t"
+      "psrlh      %[b0],          %[src0],             %[six]           \n\t"
+      "psllh      %[r0],          %[src0],             %[one]           \n\t"
+      "or         %[b0],          %[b0],               %[r0]            \n\t"
+      "punpcklhw  %[src0],        %[g0],               %[value]         \n\t"
+      "punpckhhw  %[src1],        %[g0],               %[value]         \n\t"
+      "punpcklwd  %[dest3_u],     %[src0],             %[src1]          \n\t"
+      "punpckhwd  %[dest3_v],     %[src0],             %[src1]          \n\t"
+      "paddh      %[g0],          %[dest3_u],          %[dest3_v]       \n\t"
+      "punpcklhw  %[src0],        %[b0],               %[g0]            \n\t"
+      "punpckhhw  %[src1],        %[b0],               %[g0]            \n\t"
+
+      "pmaddhw    %[dest3_v],     %[src0],             %[mask_v]        \n\t"
+      "pshufh     %[dest3_u],     %[src0],             %[mask]          \n\t"
+      "pmaddhw    %[dest3_u],     %[dest3_u],          %[mask_u]        \n\t"
+      "pmaddhw    %[g0],          %[src1],             %[mask_v]        \n\t"
+      "pshufh     %[b0],          %[src1],             %[mask]          \n\t"
+      "pmaddhw    %[b0],          %[b0],               %[mask_u]        \n\t"
+
+      "punpcklwd  %[src0],        %[dest3_u],          %[b0]            \n\t"
+      "punpckhwd  %[src1],        %[dest3_u],          %[b0]            \n\t"
+      "psubw      %[dest3_u],     %[src0],             %[src1]          \n\t"
+      "psraw      %[dest3_u],     %[dest3_u],          %[eight]         \n\t"
+      "punpcklwd  %[src0],        %[dest3_v],          %[g0]            \n\t"
+      "punpckhwd  %[src1],        %[dest3_v],          %[g0]            \n\t"
+      "psubw      %[dest3_v],     %[src1],             %[src0]          \n\t"
+      "psraw      %[dest3_v],     %[dest3_v],          %[eight]         \n\t"
+
+      "packsswh   %[src0],        %[dest0_u],          %[dest1_u]       \n\t"
+      "packsswh   %[src1],        %[dest2_u],          %[dest3_u]       \n\t"
+      "packushb   %[dest0_u],     %[src0],             %[src1]          \n\t"
+      "gssdlc1    %[dest0_u],     0x07(%[dst_u])                        \n\t"
+      "gssdrc1    %[dest0_u],     0x00(%[dst_u])                        \n\t"
+      "packsswh   %[src0],        %[dest0_v],          %[dest1_v]       \n\t"
+      "packsswh   %[src1],        %[dest2_v],          %[dest3_v]       \n\t"
+      "packushb   %[dest0_v],     %[src0],             %[src1]          \n\t"
+      "gssdlc1    %[dest0_v],     0x07(%[dst_v])                        \n\t"
+      "gssdrc1    %[dest0_v],     0x00(%[dst_v])                        \n\t"
+
+      "daddiu    %[src_rgb565],   %[src_rgb565],       0x20             \n\t"
+      "daddiu    %[next_rgb565],  %[next_rgb565],      0x20             \n\t"
+      "daddiu    %[dst_u],        %[dst_u],            0x08             \n\t"
+      "daddiu    %[dst_v],        %[dst_v],            0x08             \n\t"
+      "daddiu    %[width],        %[width],           -0x10             \n\t"
+      "bgtz      %[width],        1b                                    \n\t"
+      : [src0] "=&f"(ftmp[0]), [src1] "=&f"(ftmp[1]), [b0] "=&f"(ftmp[2]),
+        [g0] "=&f"(ftmp[3]), [r0] "=&f"(ftmp[4]), [dest0_u] "=&f"(ftmp[5]),
+        [dest1_u] "=&f"(ftmp[6]), [dest2_u] "=&f"(ftmp[7]),
+        [dest3_u] "=&f"(ftmp[8]), [dest0_v] "=&f"(ftmp[9]),
+        [dest1_v] "=&f"(ftmp[10]), [dest2_v] "=&f"(ftmp[11]),
+        [dest3_v] "=&f"(ftmp[12])
+      : [src_rgb565] "r"(src_rgb565), [next_rgb565] "r"(src_stride_rgb565),
+        [dst_u] "r"(dst_u), [dst_v] "r"(dst_v), [width] "r"(width),
+        [value] "f"(value), [c0] "f"(c0), [c1] "f"(c1), [c2] "f"(c2),
+        [mask] "f"(mask), [mask_u] "f"(mask_u), [mask_v] "f"(mask_v),
+        [eight] "f"(0x08), [six] "f"(0x06), [five] "f"(0x05), [three] "f"(0x03),
+        [one] "f"(0x01)
+      : "memory");
+}
+
+void ARGB1555ToUVRow_MMI(const uint8_t* src_argb1555,
+                         int src_stride_argb1555,
+                         uint8_t* dst_u,
+                         uint8_t* dst_v,
+                         int width) {
+  uint64_t ftmp[11];
+  uint64_t value = 0x2020202020202020;
+  uint64_t mask_u = 0x0026004a00700002;
+  uint64_t mask_v = 0x00020070005e0012;
+  uint64_t mask = 0x93;
+  uint64_t c0 = 0x001f001f001f001f;
+  uint64_t c1 = 0x00ff00ff00ff00ff;
+  uint64_t c2 = 0x0003000300030003;
+  uint64_t c3 = 0x007c007c007c007c;
+  __asm__ volatile(
+      "daddu      %[next_argb1555], %[src_argb1555],      %[next_argb1555] \n\t"
+      "1:                                                                  \n\t"
+      "gsldrc1    %[src0],          0x00(%[src_argb1555])                  \n\t"
+      "gsldlc1    %[src0],          0x07(%[src_argb1555])                  \n\t"
+      "gsldrc1    %[src1],          0x00(%[next_argb1555])                 \n\t"
+      "gsldlc1    %[src1],          0x07(%[next_argb1555])                 \n\t"
+      "psrlh      %[dest0_u],       %[src0],               %[eight]        \n\t"
+      "and        %[b0],            %[src0],               %[c0]           \n\t"
+      "and        %[src0],          %[src0],               %[c1]           \n\t"
+      "psrlh      %[src0],          %[src0],               %[five]         \n\t"
+      "and        %[g0],            %[dest0_u],            %[c2]           \n\t"
+      "psllh      %[g0],            %[g0],                 %[three]        \n\t"
+      "or         %[g0],            %[src0],               %[g0]           \n\t"
+      "and        %[r0],            %[dest0_u],            %[c3]           \n\t"
+      "psrlh      %[r0],            %[r0],                 %[two]          \n\t"
+      "psrlh      %[src0],          %[src1],               %[eight]        \n\t"
+      "and        %[dest0_u],       %[src1],               %[c0]           \n\t"
+      "and        %[src1],          %[src1],               %[c1]           \n\t"
+      "psrlh      %[src1],          %[src1],               %[five]         \n\t"
+      "and        %[dest0_v],       %[src0],               %[c2]           \n\t"
+      "psllh      %[dest0_v],       %[dest0_v],            %[three]        \n\t"
+      "or         %[dest0_v],       %[src1],               %[dest0_v]      \n\t"
+      "and        %[src0],          %[src0],               %[c3]           \n\t"
+      "psrlh      %[src0],          %[src0],               %[two]          \n\t"
+      "paddh      %[b0],            %[b0],                 %[dest0_u]      \n\t"
+      "paddh      %[g0],            %[g0],                 %[dest0_v]      \n\t"
+      "paddh      %[r0],            %[r0],                 %[src0]         \n\t"
+      "punpcklhw  %[src0],          %[b0],                 %[r0]           \n\t"
+      "punpckhhw  %[src1],          %[b0],                 %[r0]           \n\t"
+      "punpcklwd  %[dest0_u],       %[src0],               %[src1]         \n\t"
+      "punpckhwd  %[dest0_v],       %[src0],               %[src1]         \n\t"
+      "paddh      %[src0],          %[dest0_u],            %[dest0_v]      \n\t"
+      "psrlh      %[b0],            %[src0],               %[six]          \n\t"
+      "psllh      %[r0],            %[src0],               %[one]          \n\t"
+      "or         %[b0],            %[b0],                 %[r0]           \n\t"
+      "psrlh      %[r0],            %[g0],                 %[six]          \n\t"
+      "psllh      %[g0],            %[g0],                 %[one]          \n\t"
+      "or         %[g0],            %[g0],                 %[r0]           \n\t"
+      "punpcklhw  %[src0],          %[g0],                 %[value]        \n\t"
+      "punpckhhw  %[src1],          %[g0],                 %[value]        \n\t"
+      "punpcklwd  %[dest0_u],       %[src0],               %[src1]         \n\t"
+      "punpckhwd  %[dest0_v],       %[src0],               %[src1]         \n\t"
+      "paddh      %[g0],            %[dest0_u],            %[dest0_v]      \n\t"
+      "punpcklhw  %[src0],          %[b0],                 %[g0]           \n\t"
+      "punpckhhw  %[src1],          %[b0],                 %[g0]           \n\t"
+
+      "pmaddhw    %[dest0_v],       %[src0],               %[mask_v]       \n\t"
+      "pshufh     %[dest0_u],       %[src0],               %[mask]         \n\t"
+      "pmaddhw    %[dest0_u],       %[dest0_u],            %[mask_u]       \n\t"
+      "pmaddhw    %[g0],            %[src1],               %[mask_v]       \n\t"
+      "pshufh     %[b0],            %[src1],               %[mask]         \n\t"
+      "pmaddhw    %[b0],            %[b0],                 %[mask_u]       \n\t"
+
+      "punpcklwd  %[src0],          %[dest0_u],            %[b0]           \n\t"
+      "punpckhwd  %[src1],          %[dest0_u],            %[b0]           \n\t"
+      "psubw      %[dest0_u],       %[src0],               %[src1]         \n\t"
+      "psraw      %[dest0_u],       %[dest0_u],            %[eight]        \n\t"
+      "punpcklwd  %[src0],          %[dest0_v],            %[g0]           \n\t"
+      "punpckhwd  %[src1],          %[dest0_v],            %[g0]           \n\t"
+      "psubw      %[dest0_v],       %[src1],               %[src0]         \n\t"
+      "psraw      %[dest0_v],       %[dest0_v],            %[eight]        \n\t"
+
+      "gsldrc1    %[src0],          0x08(%[src_argb1555])                  \n\t"
+      "gsldlc1    %[src0],          0x0f(%[src_argb1555])                  \n\t"
+      "gsldrc1    %[src1],          0x08(%[next_argb1555])                 \n\t"
+      "gsldlc1    %[src1],          0x0f(%[next_argb1555])                 \n\t"
+      "psrlh      %[dest1_u],       %[src0],               %[eight]        \n\t"
+      "and        %[b0],            %[src0],               %[c0]           \n\t"
+      "and        %[src0],          %[src0],               %[c1]           \n\t"
+      "psrlh      %[src0],          %[src0],               %[five]         \n\t"
+      "and        %[g0],            %[dest1_u],            %[c2]           \n\t"
+      "psllh      %[g0],            %[g0],                 %[three]        \n\t"
+      "or         %[g0],            %[src0],               %[g0]           \n\t"
+      "and        %[r0],            %[dest1_u],            %[c3]           \n\t"
+      "psrlh      %[r0],            %[r0],                 %[two]          \n\t"
+      "psrlh      %[src0],          %[src1],               %[eight]        \n\t"
+      "and        %[dest1_u],       %[src1],               %[c0]           \n\t"
+      "and        %[src1],          %[src1],               %[c1]           \n\t"
+      "psrlh      %[src1],          %[src1],               %[five]         \n\t"
+      "and        %[dest1_v],       %[src0],               %[c2]           \n\t"
+      "psllh      %[dest1_v],       %[dest1_v],            %[three]        \n\t"
+      "or         %[dest1_v],       %[src1],               %[dest1_v]      \n\t"
+      "and        %[src0],          %[src0],               %[c3]           \n\t"
+      "psrlh      %[src0],          %[src0],               %[two]          \n\t"
+      "paddh      %[b0],            %[b0],                 %[dest1_u]      \n\t"
+      "paddh      %[g0],            %[g0],                 %[dest1_v]      \n\t"
+      "paddh      %[r0],            %[r0],                 %[src0]         \n\t"
+      "punpcklhw  %[src0],          %[b0],                 %[r0]           \n\t"
+      "punpckhhw  %[src1],          %[b0],                 %[r0]           \n\t"
+      "punpcklwd  %[dest1_u],       %[src0],               %[src1]         \n\t"
+      "punpckhwd  %[dest1_v],       %[src0],               %[src1]         \n\t"
+      "paddh      %[src0],          %[dest1_u],            %[dest1_v]      \n\t"
+      "psrlh      %[b0],            %[src0],               %[six]          \n\t"
+      "psllh      %[r0],            %[src0],               %[one]          \n\t"
+      "or         %[b0],            %[b0],                 %[r0]           \n\t"
+      "psrlh      %[r0],            %[g0],                 %[six]          \n\t"
+      "psllh      %[g0],            %[g0],                 %[one]          \n\t"
+      "or         %[g0],            %[g0],                 %[r0]           \n\t"
+      "punpcklhw  %[src0],          %[g0],                 %[value]        \n\t"
+      "punpckhhw  %[src1],          %[g0],                 %[value]        \n\t"
+      "punpcklwd  %[dest1_u],       %[src0],               %[src1]         \n\t"
+      "punpckhwd  %[dest1_v],       %[src0],               %[src1]         \n\t"
+      "paddh      %[g0],            %[dest1_u],            %[dest1_v]      \n\t"
+      "punpcklhw  %[src0],          %[b0],                 %[g0]           \n\t"
+      "punpckhhw  %[src1],          %[b0],                 %[g0]           \n\t"
+
+      "pmaddhw    %[dest1_v],       %[src0],               %[mask_v]       \n\t"
+      "pshufh     %[dest1_u],       %[src0],               %[mask]         \n\t"
+      "pmaddhw    %[dest1_u],       %[dest1_u],            %[mask_u]       \n\t"
+      "pmaddhw    %[g0],            %[src1],               %[mask_v]       \n\t"
+      "pshufh     %[b0],            %[src1],               %[mask]         \n\t"
+      "pmaddhw    %[b0],            %[b0],                 %[mask_u]       \n\t"
+
+      "punpcklwd  %[src0],          %[dest1_u],            %[b0]           \n\t"
+      "punpckhwd  %[src1],          %[dest1_u],            %[b0]           \n\t"
+      "psubw      %[dest1_u],       %[src0],               %[src1]         \n\t"
+      "psraw      %[dest1_u],       %[dest1_u],            %[eight]        \n\t"
+      "punpcklwd  %[src0],          %[dest1_v],            %[g0]           \n\t"
+      "punpckhwd  %[src1],          %[dest1_v],            %[g0]           \n\t"
+      "psubw      %[dest1_v],       %[src1],               %[src0]         \n\t"
+      "psraw      %[dest1_v],       %[dest1_v],            %[eight]        \n\t"
+
+      "packsswh   %[dest0_u],       %[dest0_u],            %[dest1_u]      \n\t"
+      "packsswh   %[dest1_u],       %[dest0_v],            %[dest1_v]      \n\t"
+
+      "gsldrc1    %[src0],          0x10(%[src_argb1555])                  \n\t"
+      "gsldlc1    %[src0],          0x17(%[src_argb1555])                  \n\t"
+      "gsldrc1    %[src1],          0x10(%[next_argb1555])                 \n\t"
+      "gsldlc1    %[src1],          0x17(%[next_argb1555])                 \n\t"
+      "psrlh      %[dest2_u],       %[src0],               %[eight]        \n\t"
+      "and        %[b0],            %[src0],               %[c0]           \n\t"
+      "and        %[src0],          %[src0],               %[c1]           \n\t"
+      "psrlh      %[src0],          %[src0],               %[five]         \n\t"
+      "and        %[g0],            %[dest2_u],            %[c2]           \n\t"
+      "psllh      %[g0],            %[g0],                 %[three]        \n\t"
+      "or         %[g0],            %[src0],               %[g0]           \n\t"
+      "and        %[r0],            %[dest2_u],            %[c3]           \n\t"
+      "psrlh      %[r0],            %[r0],                 %[two]          \n\t"
+      "psrlh      %[src0],          %[src1],               %[eight]        \n\t"
+      "and        %[dest2_u],       %[src1],               %[c0]           \n\t"
+      "and        %[src1],          %[src1],               %[c1]           \n\t"
+      "psrlh      %[src1],          %[src1],               %[five]         \n\t"
+      "and        %[dest0_v],       %[src0],               %[c2]           \n\t"
+      "psllh      %[dest0_v],       %[dest0_v],            %[three]        \n\t"
+      "or         %[dest0_v],       %[src1],               %[dest0_v]      \n\t"
+      "and        %[src0],          %[src0],               %[c3]           \n\t"
+      "psrlh      %[src0],          %[src0],               %[two]          \n\t"
+      "paddh      %[b0],            %[b0],                 %[dest2_u]      \n\t"
+      "paddh      %[g0],            %[g0],                 %[dest0_v]      \n\t"
+      "paddh      %[r0],            %[r0],                 %[src0]         \n\t"
+      "punpcklhw  %[src0],          %[b0],                 %[r0]           \n\t"
+      "punpckhhw  %[src1],          %[b0],                 %[r0]           \n\t"
+      "punpcklwd  %[dest2_u],       %[src0],               %[src1]         \n\t"
+      "punpckhwd  %[dest0_v],       %[src0],               %[src1]         \n\t"
+      "paddh      %[src0],          %[dest2_u],            %[dest0_v]      \n\t"
+      "psrlh      %[b0],            %[src0],               %[six]          \n\t"
+      "psllh      %[r0],            %[src0],               %[one]          \n\t"
+      "or         %[b0],            %[b0],                 %[r0]           \n\t"
+      "psrlh      %[r0],            %[g0],                 %[six]          \n\t"
+      "psllh      %[g0],            %[g0],                 %[one]          \n\t"
+      "or         %[g0],            %[g0],                 %[r0]           \n\t"
+      "punpcklhw  %[src0],          %[g0],                 %[value]        \n\t"
+      "punpckhhw  %[src1],          %[g0],                 %[value]        \n\t"
+      "punpcklwd  %[dest2_u],       %[src0],               %[src1]         \n\t"
+      "punpckhwd  %[dest0_v],       %[src0],               %[src1]         \n\t"
+      "paddh      %[g0],            %[dest2_u],            %[dest0_v]      \n\t"
+      "punpcklhw  %[src0],          %[b0],                 %[g0]           \n\t"
+      "punpckhhw  %[src1],          %[b0],                 %[g0]           \n\t"
+
+      "pmaddhw    %[dest0_v],       %[src0],               %[mask_v]       \n\t"
+      "pshufh     %[dest2_u],       %[src0],               %[mask]         \n\t"
+      "pmaddhw    %[dest2_u],       %[dest2_u],            %[mask_u]       \n\t"
+      "pmaddhw    %[g0],            %[src1],               %[mask_v]       \n\t"
+      "pshufh     %[b0],            %[src1],               %[mask]         \n\t"
+      "pmaddhw    %[b0],            %[b0],                 %[mask_u]       \n\t"
+
+      "punpcklwd  %[src0],          %[dest2_u],            %[b0]           \n\t"
+      "punpckhwd  %[src1],          %[dest2_u],            %[b0]           \n\t"
+      "psubw      %[dest2_u],       %[src0],               %[src1]         \n\t"
+      "psraw      %[dest2_u],       %[dest2_u],            %[eight]        \n\t"
+      "punpcklwd  %[src0],          %[dest0_v],            %[g0]           \n\t"
+      "punpckhwd  %[src1],          %[dest0_v],            %[g0]           \n\t"
+      "psubw      %[dest0_v],       %[src1],               %[src0]         \n\t"
+      "psraw      %[dest0_v],       %[dest0_v],            %[eight]        \n\t"
+
+      "gsldrc1    %[src0],          0x18(%[src_argb1555])                  \n\t"
+      "gsldlc1    %[src0],          0x1f(%[src_argb1555])                  \n\t"
+      "gsldrc1    %[src1],          0x18(%[next_argb1555])                 \n\t"
+      "gsldlc1    %[src1],          0x1f(%[next_argb1555])                 \n\t"
+      "psrlh      %[dest3_u],       %[src0],               %[eight]        \n\t"
+      "and        %[b0],            %[src0],               %[c0]           \n\t"
+      "and        %[src0],          %[src0],               %[c1]           \n\t"
+      "psrlh      %[src0],          %[src0],               %[five]         \n\t"
+      "and        %[g0],            %[dest3_u],            %[c2]           \n\t"
+      "psllh      %[g0],            %[g0],                 %[three]        \n\t"
+      "or         %[g0],            %[src0],               %[g0]           \n\t"
+      "and        %[r0],            %[dest3_u],            %[c3]           \n\t"
+      "psrlh      %[r0],            %[r0],                 %[two]          \n\t"
+      "psrlh      %[src0],          %[src1],               %[eight]        \n\t"
+      "and        %[dest3_u],       %[src1],               %[c0]           \n\t"
+      "and        %[src1],          %[src1],               %[c1]           \n\t"
+      "psrlh      %[src1],          %[src1],               %[five]         \n\t"
+      "and        %[dest1_v],       %[src0],               %[c2]           \n\t"
+      "psllh      %[dest1_v],       %[dest1_v],            %[three]        \n\t"
+      "or         %[dest1_v],       %[src1],               %[dest1_v]      \n\t"
+      "and        %[src0],          %[src0],               %[c3]           \n\t"
+      "psrlh      %[src0],          %[src0],               %[two]          \n\t"
+      "paddh      %[b0],            %[b0],                 %[dest3_u]      \n\t"
+      "paddh      %[g0],            %[g0],                 %[dest1_v]      \n\t"
+      "paddh      %[r0],            %[r0],                 %[src0]         \n\t"
+      "punpcklhw  %[src0],          %[b0],                 %[r0]           \n\t"
+      "punpckhhw  %[src1],          %[b0],                 %[r0]           \n\t"
+      "punpcklwd  %[dest3_u],       %[src0],               %[src1]         \n\t"
+      "punpckhwd  %[dest1_v],       %[src0],               %[src1]         \n\t"
+      "paddh      %[src0],          %[dest3_u],            %[dest1_v]      \n\t"
+      "psrlh      %[b0],            %[src0],               %[six]          \n\t"
+      "psllh      %[r0],            %[src0],               %[one]          \n\t"
+      "or         %[b0],            %[b0],                 %[r0]           \n\t"
+      "psrlh      %[r0],            %[g0],                 %[six]          \n\t"
+      "psllh      %[g0],            %[g0],                 %[one]          \n\t"
+      "or         %[g0],            %[g0],                 %[r0]           \n\t"
+      "punpcklhw  %[src0],          %[g0],                 %[value]        \n\t"
+      "punpckhhw  %[src1],          %[g0],                 %[value]        \n\t"
+      "punpcklwd  %[dest3_u],       %[src0],               %[src1]         \n\t"
+      "punpckhwd  %[dest1_v],       %[src0],               %[src1]         \n\t"
+      "paddh      %[g0],            %[dest3_u],            %[dest1_v]      \n\t"
+      "punpcklhw  %[src0],          %[b0],                 %[g0]           \n\t"
+      "punpckhhw  %[src1],          %[b0],                 %[g0]           \n\t"
+
+      "pmaddhw    %[dest1_v],       %[src0],               %[mask_v]       \n\t"
+      "pshufh     %[dest3_u],       %[src0],               %[mask]         \n\t"
+      "pmaddhw    %[dest3_u],       %[dest3_u],            %[mask_u]       \n\t"
+      "pmaddhw    %[g0],            %[src1],               %[mask_v]       \n\t"
+      "pshufh     %[b0],            %[src1],               %[mask]         \n\t"
+      "pmaddhw    %[b0],            %[b0],                 %[mask_u]       \n\t"
+
+      "punpcklwd  %[src0],          %[dest3_u],            %[b0]           \n\t"
+      "punpckhwd  %[src1],          %[dest3_u],            %[b0]           \n\t"
+      "psubw      %[dest3_u],       %[src0],               %[src1]         \n\t"
+      "psraw      %[dest3_u],       %[dest3_u],            %[eight]        \n\t"
+      "punpcklwd  %[src0],          %[dest1_v],            %[g0]           \n\t"
+      "punpckhwd  %[src1],          %[dest1_v],            %[g0]           \n\t"
+      "psubw      %[dest1_v],       %[src1],               %[src0]         \n\t"
+      "psraw      %[dest1_v],       %[dest1_v],            %[eight]        \n\t"
+
+      "packsswh   %[src1],          %[dest2_u],            %[dest3_u]      \n\t"
+      "packushb   %[dest0_u],       %[dest0_u],            %[src1]         \n\t"
+      "gssdlc1    %[dest0_u],       0x07(%[dst_u])                         \n\t"
+      "gssdrc1    %[dest0_u],       0x00(%[dst_u])                         \n\t"
+      "packsswh   %[src1],          %[dest0_v],            %[dest1_v]      \n\t"
+      "packushb   %[dest0_v],       %[dest1_u],            %[src1]         \n\t"
+      "gssdlc1    %[dest0_v],       0x07(%[dst_v])                         \n\t"
+      "gssdrc1    %[dest0_v],       0x00(%[dst_v])                         \n\t"
+
+      "daddiu    %[src_argb1555],   %[src_argb1555],       0x20            \n\t"
+      "daddiu    %[next_argb1555],  %[next_argb1555],      0x20            \n\t"
+      "daddiu    %[dst_u],          %[dst_u],              0x08            \n\t"
+      "daddiu    %[dst_v],          %[dst_v],              0x08            \n\t"
+      "daddiu    %[width],          %[width],             -0x10            \n\t"
+      "bgtz      %[width],          1b                                     \n\t"
+      : [src0] "=&f"(ftmp[0]), [src1] "=&f"(ftmp[1]), [b0] "=&f"(ftmp[2]),
+        [g0] "=&f"(ftmp[3]), [r0] "=&f"(ftmp[4]), [dest0_u] "=&f"(ftmp[5]),
+        [dest1_u] "=&f"(ftmp[6]), [dest2_u] "=&f"(ftmp[7]),
+        [dest3_u] "=&f"(ftmp[8]), [dest0_v] "=&f"(ftmp[9]),
+        [dest1_v] "=&f"(ftmp[10])
+      : [src_argb1555] "r"(src_argb1555),
+        [next_argb1555] "r"(src_stride_argb1555), [dst_u] "r"(dst_u),
+        [dst_v] "r"(dst_v), [width] "r"(width), [value] "f"(value),
+        [c0] "f"(c0), [c1] "f"(c1), [c2] "f"(c2), [c3] "f"(c3),
+        [mask] "f"(mask), [mask_u] "f"(mask_u), [mask_v] "f"(mask_v),
+        [eight] "f"(0x08), [six] "f"(0x06), [five] "f"(0x05), [three] "f"(0x03),
+        [two] "f"(0x02), [one] "f"(0x01)
+      : "memory");
+}
+
+void ARGB4444ToUVRow_MMI(const uint8_t* src_argb4444,
+                         int src_stride_argb4444,
+                         uint8_t* dst_u,
+                         uint8_t* dst_v,
+                         int width) {
+  uint64_t ftmp[13];
+  uint64_t value = 0x2020202020202020;
+  uint64_t mask_u = 0x0026004a00700002;
+  uint64_t mask_v = 0x00020070005e0012;
+  uint64_t mask = 0x93;
+  uint64_t c0 = 0x000f000f000f000f;
+  uint64_t c1 = 0x00ff00ff00ff00ff;
+  __asm__ volatile(
+      "daddu      %[next_argb4444], %[src_argb4444],      %[next_argb4444] \n\t"
+      "1:                                                                  \n\t"
+      "gsldrc1    %[src0],          0x00(%[src_argb4444])                  \n\t"
+      "gsldlc1    %[src0],          0x07(%[src_argb4444])                  \n\t"
+      "gsldrc1    %[src1],          0x00(%[next_argb4444])                 \n\t"
+      "gsldlc1    %[src1],          0x07(%[next_argb4444])                 \n\t"
+      "psrlh      %[dest0_u],       %[src0],               %[eight]        \n\t"
+      "and        %[b0],            %[src0],               %[c0]           \n\t"
+      "and        %[src0],          %[src0],               %[c1]           \n\t"
+      "psrlh      %[g0],            %[src0],               %[four]         \n\t"
+      "and        %[r0],            %[dest0_u],            %[c0]           \n\t"
+      "psrlh      %[src0],          %[src1],               %[eight]        \n\t"
+      "and        %[dest0_u],       %[src1],               %[c0]           \n\t"
+      "and        %[src1],          %[src1],               %[c1]           \n\t"
+      "psrlh      %[dest0_v],       %[src1],               %[four]         \n\t"
+      "and        %[src0],          %[src0],               %[c0]           \n\t"
+      "paddh      %[b0],            %[b0],                 %[dest0_u]      \n\t"
+      "paddh      %[g0],            %[g0],                 %[dest0_v]      \n\t"
+      "paddh      %[r0],            %[r0],                 %[src0]         \n\t"
+      "punpcklhw  %[src0],          %[b0],                 %[r0]           \n\t"
+      "punpckhhw  %[src1],          %[b0],                 %[r0]           \n\t"
+      "punpcklwd  %[dest0_u],       %[src0],               %[src1]         \n\t"
+      "punpckhwd  %[dest0_v],       %[src0],               %[src1]         \n\t"
+      "paddh      %[src0],          %[dest0_u],            %[dest0_v]      \n\t"
+      "psrlh      %[b0],            %[src0],               %[four]         \n\t"
+      "psllh      %[r0],            %[src0],               %[two]          \n\t"
+      "or         %[b0],            %[b0],                 %[r0]           \n\t"
+      "psrlh      %[r0],            %[g0],                 %[four]         \n\t"
+      "psllh      %[g0],            %[g0],                 %[two]          \n\t"
+      "or         %[g0],            %[g0],                 %[r0]           \n\t"
+      "punpcklhw  %[src0],          %[g0],                 %[value]        \n\t"
+      "punpckhhw  %[src1],          %[g0],                 %[value]        \n\t"
+      "punpcklwd  %[dest0_u],       %[src0],               %[src1]         \n\t"
+      "punpckhwd  %[dest0_v],       %[src0],               %[src1]         \n\t"
+      "paddh      %[g0],            %[dest0_u],            %[dest0_v]      \n\t"
+      "punpcklhw  %[src0],          %[b0],                 %[g0]           \n\t"
+      "punpckhhw  %[src1],          %[b0],                 %[g0]           \n\t"
+
+      "pmaddhw    %[dest0_v],       %[src0],               %[mask_v]       \n\t"
+      "pshufh     %[dest0_u],       %[src0],               %[mask]         \n\t"
+      "pmaddhw    %[dest0_u],       %[dest0_u],            %[mask_u]       \n\t"
+      "pmaddhw    %[g0],            %[src1],               %[mask_v]       \n\t"
+      "pshufh     %[b0],            %[src1],               %[mask]         \n\t"
+      "pmaddhw    %[b0],            %[b0],                 %[mask_u]       \n\t"
+
+      "punpcklwd  %[src0],          %[dest0_u],            %[b0]           \n\t"
+      "punpckhwd  %[src1],          %[dest0_u],            %[b0]           \n\t"
+      "psubw      %[dest0_u],       %[src0],               %[src1]         \n\t"
+      "psraw      %[dest0_u],       %[dest0_u],            %[eight]        \n\t"
+      "punpcklwd  %[src0],          %[dest0_v],            %[g0]           \n\t"
+      "punpckhwd  %[src1],          %[dest0_v],            %[g0]           \n\t"
+      "psubw      %[dest0_v],       %[src1],               %[src0]         \n\t"
+      "psraw      %[dest0_v],       %[dest0_v],            %[eight]        \n\t"
+
+      "gsldrc1    %[src0],          0x08(%[src_argb4444])                  \n\t"
+      "gsldlc1    %[src0],          0x0f(%[src_argb4444])                  \n\t"
+      "gsldrc1    %[src1],          0x08(%[next_argb4444])                 \n\t"
+      "gsldlc1    %[src1],          0x0f(%[next_argb4444])                 \n\t"
+      "psrlh      %[dest1_u],       %[src0],               %[eight]        \n\t"
+      "and        %[b0],            %[src0],               %[c0]           \n\t"
+      "and        %[src0],          %[src0],               %[c1]           \n\t"
+      "psrlh      %[g0],            %[src0],               %[four]         \n\t"
+      "and        %[r0],            %[dest1_u],            %[c0]           \n\t"
+      "psrlh      %[src0],          %[src1],               %[eight]        \n\t"
+      "and        %[dest1_u],       %[src1],               %[c0]           \n\t"
+      "and        %[src1],          %[src1],               %[c1]           \n\t"
+      "psrlh      %[dest1_v],       %[src1],               %[four]         \n\t"
+      "and        %[src0],          %[src0],               %[c0]           \n\t"
+      "paddh      %[b0],            %[b0],                 %[dest1_u]      \n\t"
+      "paddh      %[g0],            %[g0],                 %[dest1_v]      \n\t"
+      "paddh      %[r0],            %[r0],                 %[src0]         \n\t"
+      "punpcklhw  %[src0],          %[b0],                 %[r0]           \n\t"
+      "punpckhhw  %[src1],          %[b0],                 %[r0]           \n\t"
+      "punpcklwd  %[dest1_u],       %[src0],               %[src1]         \n\t"
+      "punpckhwd  %[dest1_v],       %[src0],               %[src1]         \n\t"
+      "paddh      %[src0],          %[dest1_u],            %[dest1_v]      \n\t"
+      "psrlh      %[b0],            %[src0],               %[four]         \n\t"
+      "psllh      %[r0],            %[src0],               %[two]          \n\t"
+      "or         %[b0],            %[b0],                 %[r0]           \n\t"
+      "psrlh      %[r0],            %[g0],                 %[four]         \n\t"
+      "psllh      %[g0],            %[g0],                 %[two]          \n\t"
+      "or         %[g0],            %[g0],                 %[r0]           \n\t"
+      "punpcklhw  %[src0],          %[g0],                 %[value]        \n\t"
+      "punpckhhw  %[src1],          %[g0],                 %[value]        \n\t"
+      "punpcklwd  %[dest1_u],       %[src0],               %[src1]         \n\t"
+      "punpckhwd  %[dest1_v],       %[src0],               %[src1]         \n\t"
+      "paddh      %[g0],            %[dest1_u],            %[dest1_v]      \n\t"
+      "punpcklhw  %[src0],          %[b0],                 %[g0]           \n\t"
+      "punpckhhw  %[src1],          %[b0],                 %[g0]           \n\t"
+
+      "pmaddhw    %[dest1_v],       %[src0],               %[mask_v]       \n\t"
+      "pshufh     %[dest1_u],       %[src0],               %[mask]         \n\t"
+      "pmaddhw    %[dest1_u],       %[dest1_u],            %[mask_u]       \n\t"
+      "pmaddhw    %[g0],            %[src1],               %[mask_v]       \n\t"
+      "pshufh     %[b0],            %[src1],               %[mask]         \n\t"
+      "pmaddhw    %[b0],            %[b0],                 %[mask_u]       \n\t"
+
+      "punpcklwd  %[src0],          %[dest1_u],            %[b0]           \n\t"
+      "punpckhwd  %[src1],          %[dest1_u],            %[b0]           \n\t"
+      "psubw      %[dest1_u],       %[src0],               %[src1]         \n\t"
+      "psraw      %[dest1_u],       %[dest1_u],            %[eight]        \n\t"
+      "punpcklwd  %[src0],          %[dest1_v],            %[g0]           \n\t"
+      "punpckhwd  %[src1],          %[dest1_v],            %[g0]           \n\t"
+      "psubw      %[dest1_v],       %[src1],               %[src0]         \n\t"
+      "psraw      %[dest1_v],       %[dest1_v],            %[eight]        \n\t"
+
+      "gsldrc1    %[src0],          0x10(%[src_argb4444])                  \n\t"
+      "gsldlc1    %[src0],          0x17(%[src_argb4444])                  \n\t"
+      "gsldrc1    %[src1],          0x10(%[next_argb4444])                 \n\t"
+      "gsldlc1    %[src1],          0x17(%[next_argb4444])                 \n\t"
+      "psrlh      %[dest2_u],       %[src0],               %[eight]        \n\t"
+      "and        %[b0],            %[src0],               %[c0]           \n\t"
+      "and        %[src0],          %[src0],               %[c1]           \n\t"
+      "psrlh      %[g0],            %[src0],               %[four]         \n\t"
+      "and        %[r0],            %[dest2_u],            %[c0]           \n\t"
+      "psrlh      %[src0],          %[src1],               %[eight]        \n\t"
+      "and        %[dest2_u],       %[src1],               %[c0]           \n\t"
+      "and        %[src1],          %[src1],               %[c1]           \n\t"
+      "psrlh      %[dest2_v],       %[src1],               %[four]         \n\t"
+      "and        %[src0],          %[src0],               %[c0]           \n\t"
+      "paddh      %[b0],            %[b0],                 %[dest2_u]      \n\t"
+      "paddh      %[g0],            %[g0],                 %[dest2_v]      \n\t"
+      "paddh      %[r0],            %[r0],                 %[src0]         \n\t"
+      "punpcklhw  %[src0],          %[b0],                 %[r0]           \n\t"
+      "punpckhhw  %[src1],          %[b0],                 %[r0]           \n\t"
+      "punpcklwd  %[dest2_u],       %[src0],               %[src1]         \n\t"
+      "punpckhwd  %[dest2_v],       %[src0],               %[src1]         \n\t"
+      "paddh      %[src0],          %[dest2_u],            %[dest2_v]      \n\t"
+      "psrlh      %[b0],            %[src0],               %[four]         \n\t"
+      "psllh      %[r0],            %[src0],               %[two]          \n\t"
+      "or         %[b0],            %[b0],                 %[r0]           \n\t"
+      "psrlh      %[r0],            %[g0],                 %[four]         \n\t"
+      "psllh      %[g0],            %[g0],                 %[two]          \n\t"
+      "or         %[g0],            %[g0],                 %[r0]           \n\t"
+      "punpcklhw  %[src0],          %[g0],                 %[value]        \n\t"
+      "punpckhhw  %[src1],          %[g0],                 %[value]        \n\t"
+      "punpcklwd  %[dest2_u],       %[src0],               %[src1]         \n\t"
+      "punpckhwd  %[dest2_v],       %[src0],               %[src1]         \n\t"
+      "paddh      %[g0],            %[dest2_u],            %[dest2_v]      \n\t"
+      "punpcklhw  %[src0],          %[b0],                 %[g0]           \n\t"
+      "punpckhhw  %[src1],          %[b0],                 %[g0]           \n\t"
+
+      "pmaddhw    %[dest2_v],       %[src0],               %[mask_v]       \n\t"
+      "pshufh     %[dest2_u],       %[src0],               %[mask]         \n\t"
+      "pmaddhw    %[dest2_u],       %[dest2_u],            %[mask_u]       \n\t"
+      "pmaddhw    %[g0],            %[src1],               %[mask_v]       \n\t"
+      "pshufh     %[b0],            %[src1],               %[mask]         \n\t"
+      "pmaddhw    %[b0],            %[b0],                 %[mask_u]       \n\t"
+
+      "punpcklwd  %[src0],          %[dest2_u],            %[b0]           \n\t"
+      "punpckhwd  %[src1],          %[dest2_u],            %[b0]           \n\t"
+      "psubw      %[dest2_u],       %[src0],               %[src1]         \n\t"
+      "psraw      %[dest2_u],       %[dest2_u],            %[eight]        \n\t"
+      "punpcklwd  %[src0],          %[dest2_v],            %[g0]           \n\t"
+      "punpckhwd  %[src1],          %[dest2_v],            %[g0]           \n\t"
+      "psubw      %[dest2_v],       %[src1],               %[src0]         \n\t"
+      "psraw      %[dest2_v],       %[dest2_v],            %[eight]        \n\t"
+
+      "gsldrc1    %[src0],          0x18(%[src_argb4444])                  \n\t"
+      "gsldlc1    %[src0],          0x1f(%[src_argb4444])                  \n\t"
+      "gsldrc1    %[src1],          0x18(%[next_argb4444])                 \n\t"
+      "gsldlc1    %[src1],          0x1f(%[next_argb4444])                 \n\t"
+      "psrlh      %[dest3_u],       %[src0],               %[eight]        \n\t"
+      "and        %[b0],            %[src0],               %[c0]           \n\t"
+      "and        %[src0],          %[src0],               %[c1]           \n\t"
+      "psrlh      %[g0],            %[src0],               %[four]         \n\t"
+      "and        %[r0],            %[dest3_u],            %[c0]           \n\t"
+      "psrlh      %[src0],          %[src1],               %[eight]        \n\t"
+      "and        %[dest3_u],       %[src1],               %[c0]           \n\t"
+      "and        %[src1],          %[src1],               %[c1]           \n\t"
+      "psrlh      %[dest3_v],       %[src1],               %[four]         \n\t"
+      "and        %[src0],          %[src0],               %[c0]           \n\t"
+      "paddh      %[b0],            %[b0],                 %[dest3_u]      \n\t"
+      "paddh      %[g0],            %[g0],                 %[dest3_v]      \n\t"
+      "paddh      %[r0],            %[r0],                 %[src0]         \n\t"
+      "punpcklhw  %[src0],          %[b0],                 %[r0]           \n\t"
+      "punpckhhw  %[src1],          %[b0],                 %[r0]           \n\t"
+      "punpcklwd  %[dest3_u],       %[src0],               %[src1]         \n\t"
+      "punpckhwd  %[dest3_v],       %[src0],               %[src1]         \n\t"
+      "paddh      %[src0],          %[dest3_u],            %[dest3_v]      \n\t"
+      "psrlh      %[b0],            %[src0],               %[four]         \n\t"
+      "psllh      %[r0],            %[src0],               %[two]          \n\t"
+      "or         %[b0],            %[b0],                 %[r0]           \n\t"
+      "psrlh      %[r0],            %[g0],                 %[four]         \n\t"
+      "psllh      %[g0],            %[g0],                 %[two]          \n\t"
+      "or         %[g0],            %[g0],                 %[r0]           \n\t"
+      "punpcklhw  %[src0],          %[g0],                 %[value]        \n\t"
+      "punpckhhw  %[src1],          %[g0],                 %[value]        \n\t"
+      "punpcklwd  %[dest3_u],       %[src0],               %[src1]         \n\t"
+      "punpckhwd  %[dest3_v],       %[src0],               %[src1]         \n\t"
+      "paddh      %[g0],            %[dest3_u],            %[dest3_v]      \n\t"
+      "punpcklhw  %[src0],          %[b0],                 %[g0]           \n\t"
+      "punpckhhw  %[src1],          %[b0],                 %[g0]           \n\t"
+
+      "pmaddhw    %[dest3_v],       %[src0],               %[mask_v]       \n\t"
+      "pshufh     %[dest3_u],       %[src0],               %[mask]         \n\t"
+      "pmaddhw    %[dest3_u],       %[dest3_u],            %[mask_u]       \n\t"
+      "pmaddhw    %[g0],            %[src1],               %[mask_v]       \n\t"
+      "pshufh     %[b0],            %[src1],               %[mask]         \n\t"
+      "pmaddhw    %[b0],            %[b0],                 %[mask_u]       \n\t"
+
+      "punpcklwd  %[src0],          %[dest3_u],            %[b0]           \n\t"
+      "punpckhwd  %[src1],          %[dest3_u],            %[b0]           \n\t"
+      "psubw      %[dest3_u],       %[src0],               %[src1]         \n\t"
+      "psraw      %[dest3_u],       %[dest3_u],            %[eight]        \n\t"
+      "punpcklwd  %[src0],          %[dest3_v],            %[g0]           \n\t"
+      "punpckhwd  %[src1],          %[dest3_v],            %[g0]           \n\t"
+      "psubw      %[dest3_v],       %[src1],               %[src0]         \n\t"
+      "psraw      %[dest3_v],       %[dest3_v],            %[eight]        \n\t"
+
+      "packsswh   %[src0],          %[dest0_u],            %[dest1_u]      \n\t"
+      "packsswh   %[src1],          %[dest2_u],            %[dest3_u]      \n\t"
+      "packushb   %[dest0_u],       %[src0],               %[src1]         \n\t"
+      "gssdlc1    %[dest0_u],       0x07(%[dst_u])                         \n\t"
+      "gssdrc1    %[dest0_u],       0x00(%[dst_u])                         \n\t"
+      "packsswh   %[src0],          %[dest0_v],            %[dest1_v]      \n\t"
+      "packsswh   %[src1],          %[dest2_v],            %[dest3_v]      \n\t"
+      "packushb   %[dest0_v],       %[src0],               %[src1]         \n\t"
+      "gssdlc1    %[dest0_v],       0x07(%[dst_v])                         \n\t"
+      "gssdrc1    %[dest0_v],       0x00(%[dst_v])                         \n\t"
+
+      "daddiu    %[src_argb4444],   %[src_argb4444],       0x20            \n\t"
+      "daddiu    %[next_argb4444],  %[next_argb4444],      0x20            \n\t"
+      "daddiu    %[dst_u],          %[dst_u],              0x08            \n\t"
+      "daddiu    %[dst_v],          %[dst_v],              0x08            \n\t"
+      "daddiu    %[width],          %[width],             -0x10            \n\t"
+      "bgtz      %[width],          1b                                     \n\t"
+      : [src0] "=&f"(ftmp[0]), [src1] "=&f"(ftmp[1]), [b0] "=&f"(ftmp[2]),
+        [g0] "=&f"(ftmp[3]), [r0] "=&f"(ftmp[4]), [dest0_u] "=&f"(ftmp[5]),
+        [dest1_u] "=&f"(ftmp[6]), [dest2_u] "=&f"(ftmp[7]),
+        [dest3_u] "=&f"(ftmp[8]), [dest0_v] "=&f"(ftmp[9]),
+        [dest1_v] "=&f"(ftmp[10]), [dest2_v] "=&f"(ftmp[11]),
+        [dest3_v] "=&f"(ftmp[12])
+      : [src_argb4444] "r"(src_argb4444),
+        [next_argb4444] "r"(src_stride_argb4444), [dst_u] "r"(dst_u),
+        [dst_v] "r"(dst_v), [width] "r"(width), [value] "f"(value),
+        [c0] "f"(c0), [c1] "f"(c1), [mask] "f"(mask), [mask_u] "f"(mask_u),
+        [mask_v] "f"(mask_v), [eight] "f"(0x08), [four] "f"(0x04),
+        [two] "f"(0x02)
+      : "memory");
+}
+
+void ARGBToUV444Row_MMI(const uint8_t* src_argb,
+                        uint8_t* dst_u,
+                        uint8_t* dst_v,
+                        int width) {
+  uint64_t ftmp[12];
+  const uint64_t value = 0x4040;
+  const uint64_t mask_u = 0x0026004a00700002;
+  const uint64_t mask_v = 0x00020070005e0012;
+
+  __asm__ volatile(
+      "1:                                                               \n\t"
+      "gsldrc1    %[src0],         0x00(%[src_argb])                    \n\t"
+      "gsldlc1    %[src0],         0x07(%[src_argb])                    \n\t"
+      "punpcklbh  %[src_lo],       %[src0],           %[zero]           \n\t"
+      "punpckhbh  %[src_hi],       %[src0],           %[zero]           \n\t"
+      "dsll       %[dest0_u],      %[src_lo],         %[sixteen]        \n\t"
+      "pinsrh_0   %[dest0_u],      %[dest0_u],        %[value]          \n\t"
+      "pinsrh_3   %[dest0_v],      %[src_lo],         %[value]          \n\t"
+      "pmaddhw    %[dest0_u],      %[dest0_u],        %[mask_u]         \n\t"
+      "pmaddhw    %[dest0_v],      %[dest0_v],        %[mask_v]         \n\t"
+
+      "dsll       %[src_lo],       %[src_hi],         %[sixteen]        \n\t"
+      "pinsrh_0   %[src_lo],       %[src_lo],         %[value]          \n\t"
+      "pinsrh_3   %[src_hi],       %[src_hi],         %[value]          \n\t"
+      "pmaddhw    %[src_lo],       %[src_lo],         %[mask_u]         \n\t"
+      "pmaddhw    %[src_hi],       %[src_hi],         %[mask_v]         \n\t"
+
+      "punpcklwd  %[src0],         %[dest0_u],        %[src_lo]         \n\t"
+      "punpckhwd  %[src1],         %[dest0_u],        %[src_lo]         \n\t"
+      "psubw      %[dest0_u],      %[src0],           %[src1]           \n\t"
+      "psraw      %[dest0_u],      %[dest0_u],        %[eight]          \n\t"
+      "punpcklwd  %[src0],         %[dest0_v],        %[src_hi]         \n\t"
+      "punpckhwd  %[src1],         %[dest0_v],        %[src_hi]         \n\t"
+      "psubw      %[dest0_v],      %[src1],           %[src0]           \n\t"
+      "psraw      %[dest0_v],      %[dest0_v],        %[eight]          \n\t"
+
+      "gsldrc1    %[src0],         0x08(%[src_argb])                    \n\t"
+      "gsldlc1    %[src0],         0x0f(%[src_argb])                    \n\t"
+      "punpcklbh  %[src_lo],       %[src0],           %[zero]           \n\t"
+      "punpckhbh  %[src_hi],       %[src0],           %[zero]           \n\t"
+      "dsll       %[dest1_u],      %[src_lo],         %[sixteen]        \n\t"
+      "pinsrh_0   %[dest1_u],      %[dest1_u],        %[value]          \n\t"
+      "pinsrh_3   %[dest1_v],      %[src_lo],         %[value]          \n\t"
+      "pmaddhw    %[dest1_u],      %[dest1_u],        %[mask_u]         \n\t"
+      "pmaddhw    %[dest1_v],      %[dest1_v],        %[mask_v]         \n\t"
+      "dsll       %[src_lo],       %[src_hi],         %[sixteen]        \n\t"
+      "pinsrh_0   %[src_lo],       %[src_lo],         %[value]          \n\t"
+      "pinsrh_3   %[src_hi],       %[src_hi],         %[value]          \n\t"
+      "pmaddhw    %[src_lo],       %[src_lo],         %[mask_u]         \n\t"
+      "pmaddhw    %[src_hi],       %[src_hi],         %[mask_v]         \n\t"
+
+      "punpcklwd  %[src0],         %[dest1_u],        %[src_lo]         \n\t"
+      "punpckhwd  %[src1],         %[dest1_u],        %[src_lo]         \n\t"
+      "psubw      %[dest1_u],      %[src0],           %[src1]           \n\t"
+      "psraw      %[dest1_u],      %[dest1_u],        %[eight]          \n\t"
+      "punpcklwd  %[src0],         %[dest1_v],        %[src_hi]         \n\t"
+      "punpckhwd  %[src1],         %[dest1_v],        %[src_hi]         \n\t"
+      "psubw      %[dest1_v],      %[src1],           %[src0]           \n\t"
+      "psraw      %[dest1_v],      %[dest1_v],        %[eight]          \n\t"
+
+      "gsldrc1    %[src0],         0x10(%[src_argb])                    \n\t"
+      "gsldlc1    %[src0],         0x17(%[src_argb])                    \n\t"
+      "punpcklbh  %[src_lo],       %[src0],           %[zero]           \n\t"
+      "punpckhbh  %[src_hi],       %[src0],           %[zero]           \n\t"
+      "dsll       %[dest2_u],      %[src_lo],         %[sixteen]        \n\t"
+      "pinsrh_0   %[dest2_u],      %[dest2_u],        %[value]          \n\t"
+      "pinsrh_3   %[dest2_v],      %[src_lo],         %[value]          \n\t"
+      "pmaddhw    %[dest2_u],      %[dest2_u],        %[mask_u]         \n\t"
+      "pmaddhw    %[dest2_v],      %[dest2_v],        %[mask_v]         \n\t"
+      "dsll       %[src_lo],       %[src_hi],         %[sixteen]        \n\t"
+      "pinsrh_0   %[src_lo],       %[src_lo],         %[value]          \n\t"
+      "pinsrh_3   %[src_hi],       %[src_hi],         %[value]          \n\t"
+      "pmaddhw    %[src_lo],       %[src_lo],         %[mask_u]         \n\t"
+      "pmaddhw    %[src_hi],       %[src_hi],         %[mask_v]         \n\t"
+
+      "punpcklwd  %[src0],         %[dest2_u],        %[src_lo]         \n\t"
+      "punpckhwd  %[src1],         %[dest2_u],        %[src_lo]         \n\t"
+      "psubw      %[dest2_u],      %[src0],           %[src1]           \n\t"
+      "psraw      %[dest2_u],      %[dest2_u],        %[eight]          \n\t"
+      "punpcklwd  %[src0],         %[dest2_v],        %[src_hi]         \n\t"
+      "punpckhwd  %[src1],         %[dest2_v],        %[src_hi]         \n\t"
+      "psubw      %[dest2_v],      %[src1],           %[src0]           \n\t"
+      "psraw      %[dest2_v],      %[dest2_v],        %[eight]          \n\t"
+
+      "gsldrc1    %[src0],         0x18(%[src_argb])                    \n\t"
+      "gsldlc1    %[src0],         0x1f(%[src_argb])                    \n\t"
+      "punpcklbh  %[src_lo],       %[src0],           %[zero]           \n\t"
+      "punpckhbh  %[src_hi],       %[src0],           %[zero]           \n\t"
+      "dsll       %[dest3_u],      %[src_lo],         %[sixteen]        \n\t"
+      "pinsrh_0   %[dest3_u],      %[dest3_u],        %[value]          \n\t"
+      "pinsrh_3   %[dest3_v],      %[src_lo],         %[value]          \n\t"
+      "pmaddhw    %[dest3_u],      %[dest3_u],        %[mask_u]         \n\t"
+      "pmaddhw    %[dest3_v],      %[dest3_v],        %[mask_v]         \n\t"
+      "dsll       %[src_lo],       %[src_hi],         %[sixteen]        \n\t"
+      "pinsrh_0   %[src_lo],       %[src_lo],         %[value]          \n\t"
+      "pinsrh_3   %[src_hi],       %[src_hi],         %[value]          \n\t"
+      "pmaddhw    %[src_lo],       %[src_lo],         %[mask_u]         \n\t"
+      "pmaddhw    %[src_hi],       %[src_hi],         %[mask_v]         \n\t"
+
+      "punpcklwd  %[src0],         %[dest3_u],        %[src_lo]         \n\t"
+      "punpckhwd  %[src1],         %[dest3_u],        %[src_lo]         \n\t"
+      "psubw      %[dest3_u],      %[src0],           %[src1]           \n\t"
+      "psraw      %[dest3_u],      %[dest3_u],        %[eight]          \n\t"
+      "punpcklwd  %[src0],         %[dest3_v],        %[src_hi]         \n\t"
+      "punpckhwd  %[src1],         %[dest3_v],        %[src_hi]         \n\t"
+      "psubw      %[dest3_v],      %[src1],           %[src0]           \n\t"
+      "psraw      %[dest3_v],      %[dest3_v],        %[eight]          \n\t"
+
+      "packsswh   %[src0],         %[dest0_u],        %[dest1_u]        \n\t"
+      "packsswh   %[src1],         %[dest2_u],        %[dest3_u]        \n\t"
+      "packushb   %[dest0_u],      %[src0],           %[src1]           \n\t"
+      "gssdlc1    %[dest0_u],      0x07(%[dst_u])                       \n\t"
+      "gssdrc1    %[dest0_u],      0x00(%[dst_u])                       \n\t"
+
+      "packsswh   %[src0],         %[dest0_v],        %[dest1_v]        \n\t"
+      "packsswh   %[src1],         %[dest2_v],        %[dest3_v]        \n\t"
+      "packushb   %[dest0_v],      %[src0],           %[src1]           \n\t"
+      "gssdlc1    %[dest0_v],      0x07(%[dst_v])                       \n\t"
+      "gssdrc1    %[dest0_v],      0x00(%[dst_v])                       \n\t"
+
+      "daddiu     %[src_argb],     %[src_argb],       0x20              \n\t"
+      "daddiu     %[dst_u],        %[dst_u],          0x08              \n\t"
+      "daddiu     %[dst_v],        %[dst_v],          0x08              \n\t"
+      "daddi      %[width],        %[width],         -0x08              \n\t"
+      "bgtz       %[width],        1b                                   \n\t"
+      : [src0] "=&f"(ftmp[0]), [src1] "=&f"(ftmp[1]), [src_lo] "=&f"(ftmp[2]),
+        [src_hi] "=&f"(ftmp[3]), [dest0_u] "=&f"(ftmp[4]),
+        [dest0_v] "=&f"(ftmp[5]), [dest1_u] "=&f"(ftmp[6]),
+        [dest1_v] "=&f"(ftmp[7]), [dest2_u] "=&f"(ftmp[8]),
+        [dest2_v] "=&f"(ftmp[9]), [dest3_u] "=&f"(ftmp[10]),
+        [dest3_v] "=&f"(ftmp[11])
+      : [src_argb] "r"(src_argb), [dst_u] "r"(dst_u), [dst_v] "r"(dst_v),
+        [width] "r"(width), [mask_u] "f"(mask_u), [mask_v] "f"(mask_v),
+        [value] "f"(value), [zero] "f"(0x00), [sixteen] "f"(0x10),
+        [eight] "f"(0x08)
+      : "memory");
+}
+
+void ARGBGrayRow_MMI(const uint8_t* src_argb, uint8_t* dst_argb, int width) {
+  uint64_t src, src_lo, src_hi, src37, dest, dest_lo, dest_hi;
+  uint64_t tmp0, tmp1;
+  const uint64_t mask0 = 0x0;
+  const uint64_t mask1 = 0x01;
+  const uint64_t mask2 = 0x0080004D0096001DULL;
+  const uint64_t mask3 = 0xFF000000FF000000ULL;
+  const uint64_t mask4 = ~mask3;
+  const uint64_t shift = 0x08;
+
+  __asm__ volatile(
+      "1:                                                           \n\t"
+      "gsldlc1    %[src],          0x07(%[src_ptr])                 \n\t"
+      "gsldrc1    %[src],          0x00(%[src_ptr])                 \n\t"
+
+      "and        %[src37],        %[src],            %[mask3]      \n\t"
+
+      "punpcklbh  %[src_lo],       %[src],            %[mask0]      \n\t"
+      "pinsrh_3   %[src_lo],       %[src_lo],         %[mask1]      \n\t"
+      "pmaddhw    %[dest_lo],      %[src_lo],         %[mask2]      \n\t"
+      "punpcklwd  %[tmp0],         %[dest_lo],        %[dest_lo]    \n\t"
+      "punpckhwd  %[tmp1],         %[dest_lo],        %[dest_lo]    \n\t"
+      "paddw      %[dest_lo],      %[tmp0],           %[tmp1]       \n\t"
+      "psrlw      %[dest_lo],      %[dest_lo],        %[shift]      \n\t"
+      "packsswh   %[dest_lo],      %[dest_lo],        %[dest_lo]    \n\t"
+
+      "punpckhbh  %[src_hi],       %[src],            %[mask0]      \n\t"
+      "pinsrh_3   %[src_hi],       %[src_hi],         %[mask1]      \n\t"
+      "pmaddhw    %[dest_hi],      %[src_hi],         %[mask2]      \n\t"
+      "punpcklwd  %[tmp0],         %[dest_hi],        %[dest_hi]    \n\t"
+      "punpckhwd  %[tmp1],         %[dest_hi],        %[dest_hi]    \n\t"
+      "paddw      %[dest_hi],      %[tmp0],           %[tmp1]       \n\t"
+      "psrlw      %[dest_hi],      %[dest_hi],        %[shift]      \n\t"
+      "packsswh   %[dest_hi],      %[dest_hi],        %[dest_hi]    \n\t"
+
+      "packushb   %[dest],         %[dest_lo],        %[dest_hi]    \n\t"
+      "and        %[dest],         %[dest],           %[mask4]      \n\t"
+      "or         %[dest],         %[dest],           %[src37]      \n\t"
+
+      "gssdlc1    %[dest],         0x07(%[dst_ptr])                 \n\t"
+      "gssdrc1    %[dest],         0x00(%[dst_ptr])                 \n\t"
+
+      "daddiu     %[src_ptr],      %[src_ptr],        0x08          \n\t"
+      "daddiu     %[dst_ptr],      %[dst_ptr],        0x08          \n\t"
+      "daddi      %[width],        %[width],         -0x02          \n\t"
+      "bnez       %[width],        1b                               \n\t"
+      : [dest_hi] "=&f"(dest_hi), [dest_lo] "=&f"(dest_lo),
+        [src_hi] "=&f"(src_hi), [src_lo] "=&f"(src_lo), [tmp0] "=&f"(tmp0),
+        [tmp1] "=&f"(tmp1), [src] "=&f"(src), [dest] "=&f"(dest),
+        [src37] "=&f"(src37)
+      : [src_ptr] "r"(src_argb), [dst_ptr] "r"(dst_argb), [width] "r"(width),
+        [shift] "f"(shift), [mask0] "f"(mask0), [mask1] "f"(mask1),
+        [mask2] "f"(mask2), [mask3] "f"(mask3), [mask4] "f"(mask4)
+      : "memory");
+}
+
+// Convert a row of image to Sepia tone.
+void ARGBSepiaRow_MMI(uint8_t* dst_argb, int width) {
+  uint64_t dest, dest_lo, dest_hi, dest37, dest0, dest1, dest2;
+  uint64_t tmp0, tmp1;
+  const uint64_t mask0 = 0x0;
+  const uint64_t mask1 = 0x002300440011ULL;
+  const uint64_t mask2 = 0x002D00580016ULL;
+  const uint64_t mask3 = 0x003200620018ULL;
+  const uint64_t mask4 = 0xFF000000FF000000ULL;
+  const uint64_t shift = 0x07;
+
+  __asm__ volatile(
+      "1:                                                           \n\t"
+      "gsldlc1    %[dest],         0x07(%[dst_ptr])                 \n\t"
+      "gsldrc1    %[dest],         0x00(%[dst_ptr])                 \n\t"
+
+      "and        %[dest37],       %[dest],           %[mask4]      \n\t"
+
+      "punpcklbh  %[dest_lo],      %[dest],           %[mask0]      \n\t"
+      "pmaddhw    %[dest0],        %[dest_lo],        %[mask1]      \n\t"
+      "pmaddhw    %[dest1],        %[dest_lo],        %[mask2]      \n\t"
+      "pmaddhw    %[dest2],        %[dest_lo],        %[mask3]      \n\t"
+      "punpcklwd  %[tmp0],         %[dest0],          %[dest1]      \n\t"
+      "punpckhwd  %[tmp1],         %[dest0],          %[dest1]      \n\t"
+      "paddw      %[dest0],        %[tmp0],           %[tmp1]       \n\t"
+      "psrlw      %[dest0],        %[dest0],          %[shift]      \n\t"
+      "punpcklwd  %[tmp0],         %[dest2],          %[mask0]      \n\t"
+      "punpckhwd  %[tmp1],         %[dest2],          %[mask0]      \n\t"
+      "paddw      %[dest1],        %[tmp0],           %[tmp1]       \n\t"
+      "psrlw      %[dest1],        %[dest1],          %[shift]      \n\t"
+      "packsswh   %[dest_lo],      %[dest0],          %[dest1]      \n\t"
+
+      "punpckhbh  %[dest_hi],      %[dest],           %[mask0]      \n\t"
+      "pmaddhw    %[dest0],        %[dest_hi],        %[mask1]      \n\t"
+      "pmaddhw    %[dest1],        %[dest_hi],        %[mask2]      \n\t"
+      "pmaddhw    %[dest2],        %[dest_hi],        %[mask3]      \n\t"
+      "punpcklwd  %[tmp0],         %[dest0],          %[dest1]      \n\t"
+      "punpckhwd  %[tmp1],         %[dest0],          %[dest1]      \n\t"
+      "paddw      %[dest0],        %[tmp0],           %[tmp1]       \n\t"
+      "psrlw      %[dest0],        %[dest0],          %[shift]      \n\t"
+      "punpcklwd  %[tmp0],         %[dest2],          %[mask0]      \n\t"
+      "punpckhwd  %[tmp1],         %[dest2],          %[mask0]      \n\t"
+      "paddw      %[dest1],        %[tmp0],           %[tmp1]       \n\t"
+      "psrlw      %[dest1],        %[dest1],          %[shift]      \n\t"
+      "packsswh   %[dest_hi],      %[dest0],          %[dest1]      \n\t"
+
+      "packushb   %[dest],         %[dest_lo],        %[dest_hi]    \n\t"
+      "or         %[dest],         %[dest],           %[dest37]     \n\t"
+
+      "gssdlc1    %[dest],         0x07(%[dst_ptr])                 \n\t"
+      "gssdrc1    %[dest],         0x00(%[dst_ptr])                 \n\t"
+
+      "daddiu     %[dst_ptr],      %[dst_ptr],        0x08          \n\t"
+      "daddi      %[width],        %[width],         -0x02          \n\t"
+      "bnez       %[width],        1b                               \n\t"
+      : [dest_hi] "=&f"(dest_hi), [dest_lo] "=&f"(dest_lo),
+        [dest0] "=&f"(dest0), [dest1] "=&f"(dest1), [dest2] "=&f"(dest2),
+        [dest37] "=&f"(dest37), [tmp0] "=&f"(tmp0), [tmp1] "=&f"(tmp1),
+        [dest] "=&f"(dest)
+      : [dst_ptr] "r"(dst_argb), [width] "r"(width), [mask0] "f"(mask0),
+        [mask1] "f"(mask1), [mask2] "f"(mask2), [mask3] "f"(mask3),
+        [mask4] "f"(mask4), [shift] "f"(shift)
+      : "memory");
+}
+
+// Apply color matrix to a row of image. Matrix is signed.
+// TODO(fbarchard): Consider adding rounding (+32).
+void ARGBColorMatrixRow_MMI(const uint8_t* src_argb,
+                            uint8_t* dst_argb,
+                            const int8_t* matrix_argb,
+                            int width) {
+  uint64_t src, src_hi, src_lo, dest, dest_lo, dest_hi, dest0, dest1, dest2,
+      dest3;
+  uint64_t matrix, matrix_hi, matrix_lo;
+  uint64_t tmp0, tmp1;
+  const uint64_t shift0 = 0x06;
+  const uint64_t shift1 = 0x08;
+  const uint64_t mask0 = 0x0;
+  const uint64_t mask1 = 0x08;
+
+  __asm__ volatile(
+      "1:                                                           \n\t"
+      "gsldlc1    %[src],          0x07(%[src_ptr])                 \n\t"
+      "gsldrc1    %[src],          0x00(%[src_ptr])                 \n\t"
+
+      "punpcklbh  %[src_lo],       %[src],            %[mask0]      \n\t"
+
+      "gsldlc1    %[matrix],       0x07(%[matrix_ptr])              \n\t"
+      "gsldrc1    %[matrix],       0x00(%[matrix_ptr])              \n\t"
+      "punpcklbh  %[matrix_lo],    %[matrix],         %[mask0]      \n\t"
+      "psllh      %[matrix_lo],    %[matrix_lo],      %[shift1]     \n\t"
+      "psrah      %[matrix_lo],    %[matrix_lo],      %[shift1]     \n\t"
+      "punpckhbh  %[matrix_hi],    %[matrix],         %[mask0]      \n\t"
+      "psllh      %[matrix_hi],    %[matrix_hi],      %[shift1]     \n\t"
+      "psrah      %[matrix_hi],    %[matrix_hi],      %[shift1]     \n\t"
+      "pmaddhw    %[dest_lo],      %[src_lo],         %[matrix_lo]  \n\t"
+      "pmaddhw    %[dest_hi],      %[src_lo],         %[matrix_hi]  \n\t"
+      "punpcklwd  %[tmp0],         %[dest_lo],        %[dest_hi]    \n\t"
+      "punpckhwd  %[tmp1],         %[dest_lo],        %[dest_hi]    \n\t"
+      "paddw      %[dest0],        %[tmp0],           %[tmp1]       \n\t"
+      "psraw      %[dest0],        %[dest0],          %[shift0]     \n\t"
+
+      "gsldlc1    %[matrix],       0x0f(%[matrix_ptr])              \n\t"
+      "gsldrc1    %[matrix],       0x08(%[matrix_ptr])              \n\t"
+      "punpcklbh  %[matrix_lo],    %[matrix],         %[mask0]      \n\t"
+      "psllh      %[matrix_lo],    %[matrix_lo],      %[shift1]     \n\t"
+      "psrah      %[matrix_lo],    %[matrix_lo],      %[shift1]     \n\t"
+      "punpckhbh  %[matrix_hi],    %[matrix],         %[mask0]      \n\t"
+      "psllh      %[matrix_hi],    %[matrix_hi],      %[shift1]     \n\t"
+      "psrah      %[matrix_hi],    %[matrix_hi],      %[shift1]     \n\t"
+      "pmaddhw    %[dest_lo],      %[src_lo],         %[matrix_lo]  \n\t"
+      "pmaddhw    %[dest_hi],      %[src_lo],         %[matrix_hi]  \n\t"
+      "punpcklwd  %[tmp0],         %[dest_lo],        %[dest_hi]    \n\t"
+      "punpckhwd  %[tmp1],         %[dest_lo],        %[dest_hi]    \n\t"
+      "paddw      %[dest1],        %[tmp0],           %[tmp1]       \n\t"
+      "psraw      %[dest1],        %[dest1],          %[shift0]     \n\t"
+
+      "punpckhbh  %[src_hi],       %[src],            %[mask0]      \n\t"
+
+      "gsldlc1    %[matrix],       0x07(%[matrix_ptr])              \n\t"
+      "gsldrc1    %[matrix],       0x00(%[matrix_ptr])              \n\t"
+      "punpcklbh  %[matrix_lo],    %[matrix],         %[mask0]      \n\t"
+      "psllh      %[matrix_lo],    %[matrix_lo],      %[shift1]     \n\t"
+      "psrah      %[matrix_lo],    %[matrix_lo],      %[shift1]     \n\t"
+      "punpckhbh  %[matrix_hi],    %[matrix],         %[mask0]      \n\t"
+      "psllh      %[matrix_hi],    %[matrix_hi],      %[shift1]     \n\t"
+      "psrah      %[matrix_hi],    %[matrix_hi],      %[shift1]     \n\t"
+      "pmaddhw    %[dest_lo],      %[src_hi],         %[matrix_lo]  \n\t"
+      "pmaddhw    %[dest_hi],      %[src_hi],         %[matrix_hi]  \n\t"
+      "punpcklwd  %[tmp0],         %[dest_lo],        %[dest_hi]    \n\t"
+      "punpckhwd  %[tmp1],         %[dest_lo],        %[dest_hi]    \n\t"
+      "paddw      %[dest2],        %[tmp0],           %[tmp1]       \n\t"
+      "psraw      %[dest2],        %[dest2],          %[shift0]     \n\t"
+
+      "gsldlc1    %[matrix],       0x0f(%[matrix_ptr])              \n\t"
+      "gsldrc1    %[matrix],       0x08(%[matrix_ptr])              \n\t"
+      "punpcklbh  %[matrix_lo],    %[matrix],         %[mask0]      \n\t"
+      "psllh      %[matrix_lo],    %[matrix_lo],      %[shift1]     \n\t"
+      "psrah      %[matrix_lo],    %[matrix_lo],      %[shift1]     \n\t"
+      "punpckhbh  %[matrix_hi],    %[matrix],         %[mask0]      \n\t"
+      "psllh      %[matrix_hi],    %[matrix_hi],      %[shift1]     \n\t"
+      "psrah      %[matrix_hi],    %[matrix_hi],      %[shift1]     \n\t"
+      "pmaddhw    %[dest_lo],      %[src_hi],         %[matrix_lo]  \n\t"
+      "pmaddhw    %[dest_hi],      %[src_hi],         %[matrix_hi]  \n\t"
+      "punpcklwd  %[tmp0],         %[dest_lo],        %[dest_hi]    \n\t"
+      "punpckhwd  %[tmp1],         %[dest_lo],        %[dest_hi]    \n\t"
+      "paddw      %[dest3],        %[tmp0],           %[tmp1]       \n\t"
+      "psraw      %[dest3],        %[dest3],          %[shift0]     \n\t"
+
+      "packsswh   %[tmp0],         %[dest0],          %[dest1]      \n\t"
+      "packsswh   %[tmp1],         %[dest2],          %[dest3]      \n\t"
+      "packushb   %[dest],         %[tmp0],           %[tmp1]       \n\t"
+
+      "gssdlc1    %[dest],         0x07(%[dst_ptr])                 \n\t"
+      "gssdrc1    %[dest],         0x00(%[dst_ptr])                 \n\t"
+
+      "daddiu     %[src_ptr],      %[src_ptr],        0x08          \n\t"
+      "daddiu     %[dst_ptr],      %[dst_ptr],        0x08          \n\t"
+      "daddi      %[width],        %[width],         -0x02          \n\t"
+      "bnez       %[width],        1b                               \n\t"
+      : [src_hi] "=&f"(src_hi), [src_lo] "=&f"(src_lo),
+        [dest_hi] "=&f"(dest_hi), [dest_lo] "=&f"(dest_lo),
+        [dest0] "=&f"(dest0), [dest1] "=&f"(dest1), [dest2] "=&f"(dest2),
+        [dest3] "=&f"(dest3), [src] "=&f"(src), [dest] "=&f"(dest),
+        [tmp0] "=&f"(tmp0), [tmp1] "=&f"(tmp1), [matrix_hi] "=&f"(matrix_hi),
+        [matrix_lo] "=&f"(matrix_lo), [matrix] "=&f"(matrix)
+      : [src_ptr] "r"(src_argb), [matrix_ptr] "r"(matrix_argb),
+        [dst_ptr] "r"(dst_argb), [width] "r"(width), [shift0] "f"(shift0),
+        [shift1] "f"(shift1), [mask0] "f"(mask0), [mask1] "f"(mask1)
+      : "memory");
+}
+
+void ARGBShadeRow_MMI(const uint8_t* src_argb,
+                      uint8_t* dst_argb,
+                      int width,
+                      uint32_t value) {
+  uint64_t src, src_hi, src_lo, dest, dest_lo, dest_hi;
+  const uint64_t shift = 0x08;
+
+  __asm__ volatile(
+      "1:                                                           \n\t"
+      "gsldlc1    %[src],          0x07(%[src_ptr])                 \n\t"
+      "gsldrc1    %[src],          0x00(%[src_ptr])                 \n\t"
+      "punpcklbh  %[src_lo],       %[src],            %[src]        \n\t"
+      "punpckhbh  %[src_hi],       %[src],            %[src]        \n\t"
+
+      "punpcklbh  %[value],        %[value],          %[value]      \n\t"
+
+      "pmulhuh    %[dest_lo],      %[src_lo],         %[value]      \n\t"
+      "psrlh      %[dest_lo],      %[dest_lo],        %[shift]      \n\t"
+      "pmulhuh    %[dest_hi],      %[src_hi],         %[value]      \n\t"
+      "psrlh      %[dest_hi],      %[dest_hi],        %[shift]      \n\t"
+      "packushb   %[dest],         %[dest_lo],        %[dest_hi]    \n\t"
+
+      "gssdlc1    %[dest],         0x07(%[dst_ptr])                 \n\t"
+      "gssdrc1    %[dest],         0x00(%[dst_ptr])                 \n\t"
+
+      "daddiu     %[src_ptr],      %[src_ptr],        0x08          \n\t"
+      "daddiu     %[dst_ptr],      %[dst_ptr],        0x08          \n\t"
+      "daddi      %[width],        %[width],         -0x02          \n\t"
+      "bnez       %[width],        1b                               \n\t"
+      : [src_hi] "=&f"(src_hi), [src_lo] "=&f"(src_lo),
+        [dest_hi] "=&f"(dest_hi), [dest_lo] "=&f"(dest_lo), [src] "=&f"(src),
+        [dest] "=&f"(dest)
+      : [src_ptr] "r"(src_argb), [dst_ptr] "r"(dst_argb), [width] "r"(width),
+        [value] "f"(value), [shift] "f"(shift)
+      : "memory");
+}
+
+void ARGBMultiplyRow_MMI(const uint8_t* src_argb,
+                         const uint8_t* src_argb1,
+                         uint8_t* dst_argb,
+                         int width) {
+  uint64_t src0, src0_hi, src0_lo, src1, src1_hi, src1_lo;
+  uint64_t dest, dest_lo, dest_hi;
+  const uint64_t mask = 0x0;
+
+  __asm__ volatile(
+      "1:                                                           \n\t"
+      "gsldlc1    %[src0],         0x07(%[src0_ptr])                \n\t"
+      "gsldrc1    %[src0],         0x00(%[src0_ptr])                \n\t"
+      "punpcklbh  %[src0_lo],      %[src0],           %[src0]       \n\t"
+      "punpckhbh  %[src0_hi],      %[src0],           %[src0]       \n\t"
+
+      "gsldlc1    %[src1],         0x07(%[src1_ptr])                \n\t"
+      "gsldrc1    %[src1],         0x00(%[src1_ptr])                \n\t"
+      "punpcklbh  %[src1_lo],      %[src1],           %[mask]       \n\t"
+      "punpckhbh  %[src1_hi],      %[src1],           %[mask]       \n\t"
+
+      "pmulhuh    %[dest_lo],      %[src0_lo],        %[src1_lo]    \n\t"
+      "pmulhuh    %[dest_hi],      %[src0_hi],        %[src1_hi]    \n\t"
+      "packushb   %[dest],         %[dest_lo],        %[dest_hi]    \n\t"
+
+      "gssdlc1    %[dest],         0x07(%[dst_ptr])                 \n\t"
+      "gssdrc1    %[dest],         0x00(%[dst_ptr])                 \n\t"
+
+      "daddiu     %[src0_ptr],     %[src0_ptr],       0x08          \n\t"
+      "daddiu     %[src1_ptr],     %[src1_ptr],       0x08          \n\t"
+      "daddiu     %[dst_ptr],      %[dst_ptr],        0x08          \n\t"
+      "daddi      %[width],        %[width],         -0x02          \n\t"
+      "bnez       %[width],        1b                               \n\t"
+      : [src0_hi] "=&f"(src0_hi), [src0_lo] "=&f"(src0_lo),
+        [src1_hi] "=&f"(src1_hi), [src1_lo] "=&f"(src1_lo),
+        [dest_hi] "=&f"(dest_hi), [dest_lo] "=&f"(dest_lo), [src0] "=&f"(src0),
+        [src1] "=&f"(src1), [dest] "=&f"(dest)
+      : [src0_ptr] "r"(src_argb), [src1_ptr] "r"(src_argb1),
+        [dst_ptr] "r"(dst_argb), [width] "r"(width), [mask] "f"(mask)
+      : "memory");
+}
+
+void ARGBAddRow_MMI(const uint8_t* src_argb,
+                    const uint8_t* src_argb1,
+                    uint8_t* dst_argb,
+                    int width) {
+  uint64_t src0, src1, dest;
+
+  __asm__ volatile(
+      "1:                                                           \n\t"
+      "gsldlc1    %[src0],         0x07(%[src0_ptr])                \n\t"
+      "gsldrc1    %[src0],         0x00(%[src0_ptr])                \n\t"
+      "gsldlc1    %[src1],         0x07(%[src1_ptr])                \n\t"
+      "gsldrc1    %[src1],         0x00(%[src1_ptr])                \n\t"
+      "paddusb    %[dest],         %[src0],           %[src1]       \n\t"
+      "gssdlc1    %[dest],         0x07(%[dst_ptr])                 \n\t"
+      "gssdrc1    %[dest],         0x00(%[dst_ptr])                 \n\t"
+
+      "daddiu     %[src0_ptr],     %[src0_ptr],       0x08          \n\t"
+      "daddiu     %[src1_ptr],     %[src1_ptr],       0x08          \n\t"
+      "daddiu     %[dst_ptr],      %[dst_ptr],        0x08          \n\t"
+      "daddi      %[width],        %[width],         -0x02          \n\t"
+      "bnez       %[width],        1b                               \n\t"
+      : [src0] "=&f"(src0), [src1] "=&f"(src1), [dest] "=&f"(dest)
+      : [src0_ptr] "r"(src_argb), [src1_ptr] "r"(src_argb1),
+        [dst_ptr] "r"(dst_argb), [width] "r"(width)
+      : "memory");
+}
+
+void ARGBSubtractRow_MMI(const uint8_t* src_argb,
+                         const uint8_t* src_argb1,
+                         uint8_t* dst_argb,
+                         int width) {
+  uint64_t src0, src1, dest;
+
+  __asm__ volatile(
+      "1:                                                           \n\t"
+      "gsldlc1    %[src0],         0x07(%[src0_ptr])                \n\t"
+      "gsldrc1    %[src0],         0x00(%[src0_ptr])                \n\t"
+      "gsldlc1    %[src1],         0x07(%[src1_ptr])                \n\t"
+      "gsldrc1    %[src1],         0x00(%[src1_ptr])                \n\t"
+      "psubusb    %[dest],         %[src0],           %[src1]       \n\t"
+      "gssdlc1    %[dest],         0x07(%[dst_ptr])                 \n\t"
+      "gssdrc1    %[dest],         0x00(%[dst_ptr])                 \n\t"
+
+      "daddiu     %[src0_ptr],     %[src0_ptr],       0x08          \n\t"
+      "daddiu     %[src1_ptr],     %[src1_ptr],       0x08          \n\t"
+      "daddiu     %[dst_ptr],      %[dst_ptr],        0x08          \n\t"
+      "daddi      %[width],        %[width],         -0x02          \n\t"
+      "bnez       %[width],        1b                               \n\t"
+      : [src0] "=&f"(src0), [src1] "=&f"(src1), [dest] "=&f"(dest)
+      : [src0_ptr] "r"(src_argb), [src1_ptr] "r"(src_argb1),
+        [dst_ptr] "r"(dst_argb), [width] "r"(width)
+      : "memory");
+}
+
+// Sobel functions which mimics SSSE3.
+void SobelXRow_MMI(const uint8_t* src_y0,
+                   const uint8_t* src_y1,
+                   const uint8_t* src_y2,
+                   uint8_t* dst_sobelx,
+                   int width) {
+  uint64_t y00 = 0, y10 = 0, y20 = 0;
+  uint64_t y02 = 0, y12 = 0, y22 = 0;
+  uint64_t zero = 0x0;
+  uint64_t sobel = 0x0;
+  __asm__ volatile(
+      "1:	                                         \n\t"
+      "gsldlc1   %[y00],        0x07(%[src_y0])          \n\t"  // a=src_y0[i]
+      "gsldrc1   %[y00],        0x00(%[src_y0])          \n\t"
+      "gsldlc1   %[y02],        0x09(%[src_y0])          \n\t"  // a_sub=src_y0[i+2]
+      "gsldrc1   %[y02],        0x02(%[src_y0])          \n\t"
+
+      "gsldlc1   %[y10],        0x07(%[src_y1])          \n\t"  // b=src_y1[i]
+      "gsldrc1   %[y10],        0x00(%[src_y1])          \n\t"
+      "gsldlc1   %[y12],        0x09(%[src_y1])          \n\t"  // b_sub=src_y1[i+2]
+      "gsldrc1   %[y12],        0x02(%[src_y1])          \n\t"
+
+      "gsldlc1   %[y20],        0x07(%[src_y2])          \n\t"  // c=src_y2[i]
+      "gsldrc1   %[y20],        0x00(%[src_y2])          \n\t"
+      "gsldlc1   %[y22],        0x09(%[src_y2])          \n\t"  // c_sub=src_y2[i+2]
+      "gsldrc1   %[y22],        0x02(%[src_y2])          \n\t"
+
+      "punpcklbh %[y00],        %[y00],          %[zero] \n\t"
+      "punpcklbh %[y10],        %[y10],          %[zero] \n\t"
+      "punpcklbh %[y20],        %[y20],          %[zero] \n\t"
+
+      "punpcklbh %[y02],        %[y02],          %[zero] \n\t"
+      "punpcklbh %[y12],        %[y12],          %[zero] \n\t"
+      "punpcklbh %[y22],        %[y22],          %[zero] \n\t"
+
+      "paddh     %[y00],        %[y00],          %[y10]  \n\t"  // a+b
+      "paddh     %[y20],        %[y20],          %[y10]  \n\t"  // c+b
+      "paddh     %[y00],        %[y00],          %[y20]  \n\t"  // a+2b+c
+
+      "paddh     %[y02],        %[y02],          %[y12]  \n\t"  // a_sub+b_sub
+      "paddh     %[y22],        %[y22],          %[y12]  \n\t"  // c_sub+b_sub
+      "paddh     %[y02],        %[y02],          %[y22]  \n\t"  // a_sub+2b_sub+c_sub
+
+      "pmaxsh    %[y10],        %[y00],          %[y02]  \n\t"
+      "pminsh    %[y20],        %[y00],          %[y02]  \n\t"
+      "psubh     %[sobel],      %[y10],          %[y20]  \n\t"  // Abs
+
+      "gsldlc1   %[y00],        0x0B(%[src_y0])          \n\t"
+      "gsldrc1   %[y00],        0x04(%[src_y0])          \n\t"
+      "gsldlc1   %[y02],        0x0D(%[src_y0])          \n\t"
+      "gsldrc1   %[y02],        0x06(%[src_y0])          \n\t"
+
+      "gsldlc1   %[y10],        0x0B(%[src_y1])          \n\t"
+      "gsldrc1   %[y10],        0x04(%[src_y1])          \n\t"
+      "gsldlc1   %[y12],        0x0D(%[src_y1])          \n\t"
+      "gsldrc1   %[y12],        0x06(%[src_y1])          \n\t"
+
+      "gsldlc1   %[y20],        0x0B(%[src_y2])          \n\t"
+      "gsldrc1   %[y20],        0x04(%[src_y2])          \n\t"
+      "gsldlc1   %[y22],        0x0D(%[src_y2])          \n\t"
+      "gsldrc1   %[y22],        0x06(%[src_y2])          \n\t"
+
+      "punpcklbh %[y00],        %[y00],          %[zero] \n\t"
+      "punpcklbh %[y10],        %[y10],          %[zero] \n\t"
+      "punpcklbh %[y20],        %[y20],          %[zero] \n\t"
+
+      "punpcklbh %[y02],        %[y02],          %[zero] \n\t"
+      "punpcklbh %[y12],        %[y12],          %[zero] \n\t"
+      "punpcklbh %[y22],        %[y22],          %[zero] \n\t"
+
+      "paddh     %[y00],        %[y00],          %[y10]  \n\t"
+      "paddh     %[y20],        %[y20],          %[y10]  \n\t"
+      "paddh     %[y00],        %[y00],          %[y20]  \n\t"
+
+      "paddh     %[y02],        %[y02],          %[y12]  \n\t"
+      "paddh     %[y22],        %[y22],          %[y12]  \n\t"
+      "paddh     %[y02],        %[y02],          %[y22]  \n\t"
+
+      "pmaxsh    %[y10],        %[y00],          %[y02]  \n\t"
+      "pminsh    %[y20],        %[y00],          %[y02]  \n\t"
+      "psubh     %[y00],        %[y10],          %[y20]  \n\t"
+
+      "packushb  %[sobel],      %[sobel],        %[y00]  \n\t"  // clamp255
+      "gssdrc1   %[sobel],      0(%[dst_sobelx])         \n\t"
+      "gssdlc1   %[sobel],      7(%[dst_sobelx])         \n\t"
+
+      "daddiu    %[src_y0],     %[src_y0],      8        \n\t"
+      "daddiu    %[src_y1],     %[src_y1],      8        \n\t"
+      "daddiu    %[src_y2],     %[src_y2],      8        \n\t"
+      "daddiu    %[dst_sobelx], %[dst_sobelx],  8        \n\t"
+      "daddiu    %[width],      %[width],      -8        \n\t"
+      "bgtz      %[width],      1b                       \n\t"
+      "nop                                               \n\t"
+      : [sobel] "=&f"(sobel), [y00] "=&f"(y00), [y10] "=&f"(y10),
+        [y20] "=&f"(y20), [y02] "=&f"(y02), [y12] "=&f"(y12), [y22] "=&f"(y22)
+      : [src_y0] "r"(src_y0), [src_y1] "r"(src_y1), [src_y2] "r"(src_y2),
+        [dst_sobelx] "r"(dst_sobelx), [width] "r"(width), [zero] "f"(zero)
+      : "memory");
+}
+
+void SobelYRow_MMI(const uint8_t* src_y0,
+                   const uint8_t* src_y1,
+                   uint8_t* dst_sobely,
+                   int width) {
+  uint64_t y00 = 0, y01 = 0, y02 = 0;
+  uint64_t y10 = 0, y11 = 0, y12 = 0;
+  uint64_t zero = 0x0;
+  uint64_t sobel = 0x0;
+  __asm__ volatile(
+      "1:	                                        \n\t"
+      "gsldlc1   %[y00],        0x07(%[src_y0])         \n\t"  // a=src_y0[i]
+      "gsldrc1   %[y00],        0x00(%[src_y0])         \n\t"
+      "gsldlc1   %[y01],        0x08(%[src_y0])         \n\t"  // b=src_y0[i+1]
+      "gsldrc1   %[y01],        0x01(%[src_y0])         \n\t"
+      "gsldlc1   %[y02],        0x09(%[src_y0])         \n\t"  // c=src_y0[i+2]
+      "gsldrc1   %[y02],        0x02(%[src_y0])         \n\t"
+
+      "gsldlc1   %[y10],        0x07(%[src_y1])         \n\t"  // a_sub=src_y1[i]
+      "gsldrc1   %[y10],        0x00(%[src_y1])         \n\t"
+      "gsldlc1   %[y11],        0x08(%[src_y1])         \n\t"  // b_sub=src_y1[i+1]
+      "gsldrc1   %[y11],        0x01(%[src_y1])         \n\t"
+      "gsldlc1   %[y12],        0x09(%[src_y1])         \n\t"  // c_sub=src_y1[i+2]
+      "gsldrc1   %[y12],        0x02(%[src_y1])         \n\t"
+
+      "punpcklbh %[y00],        %[y00],         %[zero] \n\t"
+      "punpcklbh %[y01],        %[y01],         %[zero] \n\t"
+      "punpcklbh %[y02],        %[y02],         %[zero] \n\t"
+
+      "punpcklbh %[y10],        %[y10],         %[zero] \n\t"
+      "punpcklbh %[y11],        %[y11],         %[zero] \n\t"
+      "punpcklbh %[y12],        %[y12],         %[zero] \n\t"
+
+      "paddh     %[y00],        %[y00],         %[y01]  \n\t"  // a+b
+      "paddh     %[y02],        %[y02],         %[y01]  \n\t"  // c+b
+      "paddh     %[y00],        %[y00],         %[y02]  \n\t"  // a+2b+c
+
+      "paddh     %[y10],        %[y10],         %[y11]  \n\t"  // a_sub+b_sub
+      "paddh     %[y12],        %[y12],         %[y11]  \n\t"  // c_sub+b_sub
+      "paddh     %[y10],        %[y10],         %[y12]  \n\t"  // a_sub+2b_sub+c_sub
+
+      "pmaxsh    %[y02],        %[y00],         %[y10]  \n\t"
+      "pminsh    %[y12],        %[y00],         %[y10]  \n\t"
+      "psubh     %[sobel],      %[y02],         %[y12]  \n\t"  // Abs
+
+      "gsldlc1   %[y00],        0x0B(%[src_y0])         \n\t"
+      "gsldrc1   %[y00],        0x04(%[src_y0])         \n\t"
+      "gsldlc1   %[y01],        0x0C(%[src_y0])         \n\t"
+      "gsldrc1   %[y01],        0x05(%[src_y0])         \n\t"
+      "gsldlc1   %[y02],        0x0D(%[src_y0])         \n\t"
+      "gsldrc1   %[y02],        0x06(%[src_y0])         \n\t"
+
+      "gsldlc1   %[y10],        0x0B(%[src_y1])         \n\t"
+      "gsldrc1   %[y10],        0x04(%[src_y1])         \n\t"
+      "gsldlc1   %[y11],        0x0C(%[src_y1])         \n\t"
+      "gsldrc1   %[y11],        0x05(%[src_y1])         \n\t"
+      "gsldlc1   %[y12],        0x0D(%[src_y1])         \n\t"
+      "gsldrc1   %[y12],        0x06(%[src_y1])         \n\t"
+
+      "punpcklbh %[y00],        %[y00],         %[zero] \n\t"
+      "punpcklbh %[y01],        %[y01],         %[zero] \n\t"
+      "punpcklbh %[y02],        %[y02],         %[zero] \n\t"
+
+      "punpcklbh %[y10],        %[y10],         %[zero] \n\t"
+      "punpcklbh %[y11],        %[y11],         %[zero] \n\t"
+      "punpcklbh %[y12],        %[y12],         %[zero] \n\t"
+
+      "paddh     %[y00],        %[y00],         %[y01]  \n\t"
+      "paddh     %[y02],        %[y02],         %[y01]  \n\t"
+      "paddh     %[y00],        %[y00],         %[y02]  \n\t"
+
+      "paddh     %[y10],        %[y10],         %[y11]  \n\t"
+      "paddh     %[y12],        %[y12],         %[y11]  \n\t"
+      "paddh     %[y10],        %[y10],         %[y12]  \n\t"
+
+      "pmaxsh    %[y02],        %[y00],         %[y10]  \n\t"
+      "pminsh    %[y12],        %[y00],         %[y10]  \n\t"
+      "psubh     %[y00],        %[y02],         %[y12]  \n\t"
+
+      "packushb  %[sobel],      %[sobel],       %[y00]  \n\t"  // clamp255
+      "gssdrc1   %[sobel],      0(%[dst_sobely])        \n\t"
+      "gssdlc1   %[sobel],      7(%[dst_sobely])        \n\t"
+
+      "daddiu    %[src_y0],     %[src_y0],      8       \n\t"
+      "daddiu    %[src_y1],     %[src_y1],      8       \n\t"
+      "daddiu    %[dst_sobely], %[dst_sobely],  8       \n\t"
+      "daddiu    %[width],      %[width],      -8       \n\t"
+      "bgtz      %[width],      1b                      \n\t"
+      "nop                                              \n\t"
+      : [sobel] "=&f"(sobel), [y00] "=&f"(y00), [y01] "=&f"(y01),
+        [y02] "=&f"(y02), [y10] "=&f"(y10), [y11] "=&f"(y11), [y12] "=&f"(y12)
+      : [src_y0] "r"(src_y0), [src_y1] "r"(src_y1),
+        [dst_sobely] "r"(dst_sobely), [width] "r"(width), [zero] "f"(zero)
+      : "memory");
+}
+
+void SobelRow_MMI(const uint8_t* src_sobelx,
+                  const uint8_t* src_sobely,
+                  uint8_t* dst_argb,
+                  int width) {
+  double temp[3];
+  uint64_t c1 = 0xff000000ff000000;
+  __asm__ volatile(
+      "1:	                                          \n\t"
+      "gsldlc1   %[t0],         0x07(%[src_sobelx])       \n\t"  // a=src_sobelx[i]
+      "gsldrc1   %[t0],         0x00(%[src_sobelx])       \n\t"
+      "gsldlc1   %[t1],         0x07(%[src_sobely])       \n\t"  // b=src_sobely[i]
+      "gsldrc1   %[t1],         0x00(%[src_sobely])       \n\t"
+      // s7 s6 s5 s4 s3 s2 s1 s0 = a+b
+      "paddusb   %[t2] ,        %[t0],              %[t1] \n\t"
+
+      // s3 s2 s1 s0->s3 s3 s2 s2 s1 s1 s0 s0
+      "punpcklbh %[t0],         %[t2],              %[t2] \n\t"
+
+      // s1 s1 s0 s0->s1 s2 s1 s1 s0 s0 s0 s0
+      "punpcklbh %[t1],         %[t0],              %[t0] \n\t"
+      "or        %[t1],         %[t1],              %[c1] \n\t"
+      // 255 s1 s1 s1 s55 s0 s0 s0
+      "gssdrc1   %[t1],         0x00(%[dst_argb])	  \n\t"
+      "gssdlc1   %[t1],         0x07(%[dst_argb])         \n\t"
+
+      // s3 s3 s2 s2->s3 s3 s3 s3 s2 s2 s2 s2
+      "punpckhbh %[t1],         %[t0],              %[t0] \n\t"
+      "or        %[t1],         %[t1],              %[c1] \n\t"
+      // 255 s3 s3 s3 255 s2 s2 s2
+      "gssdrc1   %[t1],         0x08(%[dst_argb])	  \n\t"
+      "gssdlc1   %[t1],         0x0f(%[dst_argb])         \n\t"
+
+      // s7 s6 s5 s4->s7 s7 s6 s6 s5 s5 s4 s4
+      "punpckhbh %[t0],         %[t2],              %[t2] \n\t"
+
+      // s5 s5 s4 s4->s5 s5 s5 s5 s4 s4 s4 s4
+      "punpcklbh %[t1],         %[t0],              %[t0] \n\t"
+      "or        %[t1],         %[t1],              %[c1] \n\t"
+      "gssdrc1   %[t1],         0x10(%[dst_argb])	  \n\t"
+      "gssdlc1   %[t1],         0x17(%[dst_argb])         \n\t"
+
+      // s7 s7 s6 s6->s7 s7 s7 s7 s6 s6 s6 s6
+      "punpckhbh %[t1],         %[t0],              %[t0] \n\t"
+      "or        %[t1],         %[t1],              %[c1] \n\t"
+      "gssdrc1   %[t1],         0x18(%[dst_argb])	  \n\t"
+      "gssdlc1   %[t1],         0x1f(%[dst_argb])         \n\t"
+
+      "daddiu    %[dst_argb],   %[dst_argb],        32    \n\t"
+      "daddiu    %[src_sobelx], %[src_sobelx],      8     \n\t"
+      "daddiu    %[src_sobely], %[src_sobely],      8     \n\t"
+      "daddiu    %[width],      %[width],          -8     \n\t"
+      "bgtz      %[width],      1b                        \n\t"
+      "nop                                                \n\t"
+      : [t0] "=&f"(temp[0]), [t1] "=&f"(temp[1]), [t2] "=&f"(temp[2])
+      : [src_sobelx] "r"(src_sobelx), [src_sobely] "r"(src_sobely),
+        [dst_argb] "r"(dst_argb), [width] "r"(width), [c1] "f"(c1)
+      : "memory");
+}
+
+void SobelToPlaneRow_MMI(const uint8_t* src_sobelx,
+                         const uint8_t* src_sobely,
+                         uint8_t* dst_y,
+                         int width) {
+  uint64_t tr = 0;
+  uint64_t tb = 0;
+  __asm__ volatile(
+      "1:	                                       \n\t"
+      "gsldrc1 %[tr],         0x0(%[src_sobelx])       \n\t"
+      "gsldlc1 %[tr],         0x7(%[src_sobelx])       \n\t"  // r=src_sobelx[i]
+      "gsldrc1 %[tb],         0x0(%[src_sobely])       \n\t"
+      "gsldlc1 %[tb],         0x7(%[src_sobely])       \n\t"  // b=src_sobely[i]
+      "paddusb %[tr],         %[tr],             %[tb] \n\t"  // g
+      "gssdrc1 %[tr],         0x0(%[dst_y])	       \n\t"
+      "gssdlc1 %[tr],         0x7(%[dst_y])            \n\t"
+
+      "daddiu  %[dst_y],      %[dst_y],          8     \n\t"
+      "daddiu  %[src_sobelx], %[src_sobelx],     8     \n\t"
+      "daddiu  %[src_sobely], %[src_sobely],     8     \n\t"
+      "daddiu  %[width],      %[width],         -8     \n\t"
+      "bgtz    %[width],      1b                       \n\t"
+      "nop                                             \n\t"
+      : [tr] "=&f"(tr), [tb] "=&f"(tb)
+      : [src_sobelx] "r"(src_sobelx), [src_sobely] "r"(src_sobely),
+        [dst_y] "r"(dst_y), [width] "r"(width)
+      : "memory");
+}
+
+void SobelXYRow_MMI(const uint8_t* src_sobelx,
+                    const uint8_t* src_sobely,
+                    uint8_t* dst_argb,
+                    int width) {
+  uint64_t temp[3];
+  uint64_t result = 0;
+  uint64_t gb = 0;
+  uint64_t cr = 0;
+  uint64_t c1 = 0xffffffffffffffff;
+  __asm__ volatile(
+      "1:	                                          \n\t"
+      "gsldlc1   %[tr],         0x07(%[src_sobelx])       \n\t"  // r=src_sobelx[i]
+      "gsldrc1   %[tr],         0x00(%[src_sobelx])       \n\t"
+      "gsldlc1   %[tb],         0x07(%[src_sobely])       \n\t"  // b=src_sobely[i]
+      "gsldrc1   %[tb],         0x00(%[src_sobely])       \n\t"
+      "paddusb   %[tg] ,        %[tr],              %[tb] \n\t"  // g
+
+      // g3 b3 g2 b2 g1 b1 g0 b0
+      "punpcklbh %[gb],         %[tb],              %[tg] \n\t"
+      // c3 r3 r2 r2 c1 r1 c0 r0
+      "punpcklbh %[cr],         %[tr],              %[c1] \n\t"
+      // c1 r1 g1 b1 c0 r0 g0 b0
+      "punpcklhw %[result],     %[gb],              %[cr] \n\t"
+      "gssdrc1   %[result],     0x00(%[dst_argb])	  \n\t"
+      "gssdlc1   %[result],     0x07(%[dst_argb])         \n\t"
+      // c3 r3 g3 b3 c2 r2 g2 b2
+      "punpckhhw %[result],     %[gb],              %[cr] \n\t"
+      "gssdrc1   %[result],     0x08(%[dst_argb])	  \n\t"
+      "gssdlc1   %[result],     0x0f(%[dst_argb])         \n\t"
+
+      // g7 b7 g6 b6 g5 b5 g4 b4
+      "punpckhbh %[gb],         %[tb],              %[tg] \n\t"
+      // c7 r7 c6 r6 c5 r5 c4 r4
+      "punpckhbh %[cr],         %[tr],              %[c1] \n\t"
+      // c5 r5 g5 b5 c4 r4 g4 b4
+      "punpcklhw %[result],     %[gb],              %[cr] \n\t"
+      "gssdrc1   %[result],     0x10(%[dst_argb])	  \n\t"
+      "gssdlc1   %[result],     0x17(%[dst_argb])         \n\t"
+      // c7 r7 g7 b7 c6 r6 g6 b6
+      "punpckhhw %[result],     %[gb],              %[cr] \n\t"
+      "gssdrc1   %[result],     0x18(%[dst_argb])	  \n\t"
+      "gssdlc1   %[result],     0x1f(%[dst_argb])         \n\t"
+
+      "daddiu    %[dst_argb],   %[dst_argb],        32    \n\t"
+      "daddiu    %[src_sobelx], %[src_sobelx],      8     \n\t"
+      "daddiu    %[src_sobely], %[src_sobely],      8     \n\t"
+      "daddiu    %[width],      %[width],          -8     \n\t"
+      "bgtz      %[width],      1b                        \n\t"
+      "nop                                                \n\t"
+      : [tr] "=&f"(temp[0]), [tb] "=&f"(temp[1]), [tg] "=&f"(temp[2]),
+        [gb] "=&f"(gb), [cr] "=&f"(cr), [result] "=&f"(result)
+      : [src_sobelx] "r"(src_sobelx), [src_sobely] "r"(src_sobely),
+        [dst_argb] "r"(dst_argb), [width] "r"(width), [c1] "f"(c1)
+      : "memory");
+}
+
+void J400ToARGBRow_MMI(const uint8_t* src_y, uint8_t* dst_argb, int width) {
+  // Copy a Y to RGB.
+  uint64_t src, dest;
+  const uint64_t mask0 = 0x00ffffff00ffffffULL;
+  const uint64_t mask1 = ~mask0;
+
+  __asm__ volatile(
+      "1:                                                           \n\t"
+      "gslwlc1    %[src],          0x03(%[src_ptr])                 \n\t"
+      "gslwrc1    %[src],          0x00(%[src_ptr])                 \n\t"
+      "punpcklbh  %[src],          %[src],            %[src]        \n\t"
+      "punpcklhw  %[dest],         %[src],            %[src]        \n\t"
+      "and        %[dest],         %[dest],           %[mask0]      \n\t"
+      "or         %[dest],         %[dest],           %[mask1]      \n\t"
+      "gssdrc1    %[dest],         0x00(%[dst_ptr])                 \n\t"
+      "gssdlc1    %[dest],         0x07(%[dst_ptr])                 \n\t"
+
+      "punpckhhw  %[dest],         %[src],            %[src]        \n\t"
+      "and        %[dest],         %[dest],           %[mask0]      \n\t"
+      "or         %[dest],         %[dest],           %[mask1]      \n\t"
+      "gssdrc1    %[dest],         0x08(%[dst_ptr])                 \n\t"
+      "gssdlc1    %[dest],         0x0f(%[dst_ptr])                 \n\t"
+
+      "daddiu     %[src_ptr],      %[src_ptr],        0x04          \n\t"
+      "daddiu     %[dst_ptr],      %[dst_ptr],        0x10          \n\t"
+      "daddi      %[width],        %[width],         -0x04          \n\t"
+      "bnez       %[width],        1b                               \n\t"
+      : [src] "=&f"(src), [dest] "=&f"(dest)
+      : [src_ptr] "r"(src_y), [dst_ptr] "r"(dst_argb), [mask0] "f"(mask0),
+        [mask1] "f"(mask1), [width] "r"(width)
+      : "memory");
+}
+
+// TODO - respect YuvConstants
+void I400ToARGBRow_MMI(const uint8_t* src_y, uint8_t* rgb_buf,
+                       const struct YuvConstants*, int width) {
+  uint64_t src, src_lo, src_hi, dest, dest_lo, dest_hi;
+  const uint64_t mask0 = 0x0;
+  const uint64_t mask1 = 0x55;
+  const uint64_t mask2 = 0xAA;
+  const uint64_t mask3 = 0xFF;
+  const uint64_t mask4 = 0x4A354A354A354A35ULL;
+  const uint64_t mask5 = 0x0488048804880488ULL;
+  const uint64_t shift0 = 0x08;
+  const uint64_t shift1 = 0x06;
+
+  __asm__ volatile(
+      "1:                                                           \n\t"
+      "gsldlc1    %[src],          0x07(%[src_ptr])                 \n\t"
+      "gsldrc1    %[src],          0x00(%[src_ptr])                 \n\t"
+      "punpcklbh  %[src_lo],       %[src],            %[mask0]      \n\t"
+      "punpckhbh  %[src_hi],       %[src],            %[mask0]      \n\t"
+
+      "pshufh     %[src],          %[src_lo],         %[mask0]      \n\t"
+      "psllh      %[dest_lo],      %[src],            %[shift0]     \n\t"
+      "paddush    %[dest_lo],      %[dest_lo],        %[src]        \n\t"
+      "pmulhuh    %[dest_lo],      %[dest_lo],        %[mask4]      \n\t"
+      "psubh      %[dest_lo],      %[dest_lo],        %[mask5]      \n\t"
+      "psrah      %[dest_lo],      %[dest_lo],        %[shift1]     \n\t"
+      "pinsrh_3   %[dest_lo],      %[dest_lo],        %[mask3]      \n\t"
+      "pshufh     %[src],          %[src_lo],         %[mask1]      \n\t"
+      "psllh      %[dest_hi],      %[src],            %[shift0]     \n\t"
+      "paddush    %[dest_hi],      %[dest_hi],        %[src]        \n\t"
+      "pmulhuh    %[dest_hi],      %[dest_hi],        %[mask4]      \n\t"
+      "psubh      %[dest_hi],      %[dest_hi],        %[mask5]      \n\t"
+      "psrah      %[dest_hi],      %[dest_hi],        %[shift1]     \n\t"
+      "pinsrh_3   %[dest_hi],      %[dest_hi],        %[mask3]      \n\t"
+      "packushb   %[dest],         %[dest_lo],        %[dest_hi]    \n\t"
+      "gssdlc1    %[dest],         0x07(%[dst_ptr])                 \n\t"
+      "gssdrc1    %[dest],         0x00(%[dst_ptr])                 \n\t"
+
+      "pshufh     %[src],          %[src_lo],         %[mask2]      \n\t"
+      "psllh      %[dest_lo],      %[src],            %[shift0]     \n\t"
+      "paddush    %[dest_lo],      %[dest_lo],        %[src]        \n\t"
+      "pmulhuh    %[dest_lo],      %[dest_lo],        %[mask4]      \n\t"
+      "psubh      %[dest_lo],      %[dest_lo],        %[mask5]      \n\t"
+      "psrah      %[dest_lo],      %[dest_lo],        %[shift1]     \n\t"
+      "pinsrh_3   %[dest_lo],      %[dest_lo],        %[mask3]      \n\t"
+      "pshufh     %[src],          %[src_lo],         %[mask3]      \n\t"
+      "psllh      %[dest_hi],      %[src],            %[shift0]     \n\t"
+      "paddush    %[dest_hi],      %[dest_hi],        %[src]        \n\t"
+      "pmulhuh    %[dest_hi],      %[dest_hi],        %[mask4]      \n\t"
+      "psubh      %[dest_hi],      %[dest_hi],        %[mask5]      \n\t"
+      "psrah      %[dest_hi],      %[dest_hi],        %[shift1]     \n\t"
+      "pinsrh_3   %[dest_hi],      %[dest_hi],        %[mask3]      \n\t"
+      "packushb   %[dest],         %[dest_lo],        %[dest_hi]    \n\t"
+      "gssdlc1    %[dest],         0x0f(%[dst_ptr])                 \n\t"
+      "gssdrc1    %[dest],         0x08(%[dst_ptr])                 \n\t"
+
+      "pshufh     %[src],          %[src_hi],         %[mask0]      \n\t"
+      "psllh      %[dest_lo],      %[src],            %[shift0]     \n\t"
+      "paddush    %[dest_lo],      %[dest_lo],        %[src]        \n\t"
+      "pmulhuh    %[dest_lo],      %[dest_lo],        %[mask4]      \n\t"
+      "psubh      %[dest_lo],      %[dest_lo],        %[mask5]      \n\t"
+      "psrah      %[dest_lo],      %[dest_lo],        %[shift1]     \n\t"
+      "pinsrh_3   %[dest_lo],      %[dest_lo],        %[mask3]      \n\t"
+      "pshufh     %[src],          %[src_hi],         %[mask1]      \n\t"
+      "psllh      %[dest_hi],      %[src],            %[shift0]     \n\t"
+      "paddush    %[dest_hi],      %[dest_hi],        %[src]        \n\t"
+      "pmulhuh    %[dest_hi],      %[dest_hi],        %[mask4]      \n\t"
+      "psubh      %[dest_hi],      %[dest_hi],        %[mask5]      \n\t"
+      "psrah      %[dest_hi],      %[dest_hi],        %[shift1]     \n\t"
+      "pinsrh_3   %[dest_hi],      %[dest_hi],        %[mask3]      \n\t"
+      "packushb   %[dest],         %[dest_lo],        %[dest_hi]    \n\t"
+      "gssdlc1    %[dest],         0x17(%[dst_ptr])                 \n\t"
+      "gssdrc1    %[dest],         0x10(%[dst_ptr])                 \n\t"
+
+      "pshufh     %[src],          %[src_hi],         %[mask2]      \n\t"
+      "psllh      %[dest_lo],      %[src],            %[shift0]     \n\t"
+      "paddush    %[dest_lo],      %[dest_lo],        %[src]        \n\t"
+      "pmulhuh    %[dest_lo],      %[dest_lo],        %[mask4]      \n\t"
+      "psubh      %[dest_lo],      %[dest_lo],        %[mask5]      \n\t"
+      "psrah      %[dest_lo],      %[dest_lo],        %[shift1]     \n\t"
+      "pinsrh_3   %[dest_lo],      %[dest_lo],        %[mask3]      \n\t"
+      "pshufh     %[src],          %[src_hi],         %[mask3]      \n\t"
+      "psllh      %[dest_hi],      %[src],            %[shift0]     \n\t"
+      "paddush    %[dest_hi],      %[dest_hi],        %[src]        \n\t"
+      "pmulhuh    %[dest_hi],      %[dest_hi],        %[mask4]      \n\t"
+      "psubh      %[dest_hi],      %[dest_hi],        %[mask5]      \n\t"
+      "psrah      %[dest_hi],      %[dest_hi],        %[shift1]     \n\t"
+      "pinsrh_3   %[dest_hi],      %[dest_hi],        %[mask3]      \n\t"
+      "packushb   %[dest],         %[dest_lo],        %[dest_hi]    \n\t"
+      "gssdlc1    %[dest],         0x1f(%[dst_ptr])                 \n\t"
+      "gssdrc1    %[dest],         0x18(%[dst_ptr])                 \n\t"
+
+      "daddi      %[src_ptr],      %[src_ptr],        0x08          \n\t"
+      "daddiu     %[dst_ptr],      %[dst_ptr],        0x20          \n\t"
+      "daddi      %[width],        %[width],         -0x08          \n\t"
+      "bnez       %[width],        1b                               \n\t"
+      : [src] "=&f"(src), [dest] "=&f"(dest), [src_hi] "=&f"(src_hi),
+        [src_lo] "=&f"(src_lo), [dest_hi] "=&f"(dest_hi),
+        [dest_lo] "=&f"(dest_lo)
+      : [src_ptr] "r"(src_y), [dst_ptr] "r"(rgb_buf), [mask0] "f"(mask0),
+        [mask1] "f"(mask1), [mask2] "f"(mask2), [mask3] "f"(mask3),
+        [mask4] "f"(mask4), [mask5] "f"(mask5), [shift0] "f"(shift0),
+        [shift1] "f"(shift1), [width] "r"(width)
+      : "memory");
+}
+
+void MirrorRow_MMI(const uint8_t* src, uint8_t* dst, int width) {
+  uint64_t source, src0, src1, dest;
+  const uint64_t mask0 = 0x0;
+  const uint64_t mask1 = 0x1b;
+
+  src += width - 1;
+  __asm__ volatile(
+      "1:                                                           \n\t"
+      "gsldlc1    %[source],       0(%[src_ptr])                    \n\t"
+      "gsldrc1    %[source],       -7(%[src_ptr])                   \n\t"
+      "punpcklbh  %[src0],         %[source],         %[mask0]      \n\t"
+      "pshufh     %[src0],         %[src0],           %[mask1]      \n\t"
+      "punpckhbh  %[src1],         %[source],         %[mask0]      \n\t"
+      "pshufh     %[src1],         %[src1],           %[mask1]      \n\t"
+      "packushb   %[dest],         %[src1],           %[src0]       \n\t"
+
+      "gssdlc1    %[dest],         0x07(%[dst_ptr])                 \n\t"
+      "gssdrc1    %[dest],         0x00(%[dst_ptr])                 \n\t"
+
+      "daddi      %[src_ptr],      %[src_ptr],       -0x08          \n\t"
+      "daddiu     %[dst_ptr],      %[dst_ptr],        0x08          \n\t"
+      "daddi      %[width],        %[width],         -0x08          \n\t"
+      "bnez       %[width],        1b                               \n\t"
+      : [source] "=&f"(source), [dest] "=&f"(dest), [src0] "=&f"(src0),
+        [src1] "=&f"(src1)
+      : [src_ptr] "r"(src), [dst_ptr] "r"(dst), [mask0] "f"(mask0),
+        [mask1] "f"(mask1), [width] "r"(width)
+      : "memory");
+}
+
+void MirrorSplitUVRow_MMI(const uint8_t* src_uv,
+                          uint8_t* dst_u,
+                          uint8_t* dst_v,
+                          int width) {
+  uint64_t src0, src1, dest0, dest1;
+  const uint64_t mask0 = 0x00ff00ff00ff00ffULL;
+  const uint64_t mask1 = 0x1b;
+  const uint64_t shift = 0x08;
+
+  src_uv += (width - 1) << 1;
+
+  __asm__ volatile(
+      "1:                                                           \n\t"
+      "gsldlc1    %[src0],         1(%[src_ptr])                    \n\t"
+      "gsldrc1    %[src0],         -6(%[src_ptr])                   \n\t"
+      "gsldlc1    %[src1],         -7(%[src_ptr])                   \n\t"
+      "gsldrc1    %[src1],         -14(%[src_ptr])                  \n\t"
+
+      "and        %[dest0],        %[src0],           %[mask0]      \n\t"
+      "pshufh     %[dest0],        %[dest0],          %[mask1]      \n\t"
+      "and        %[dest1],        %[src1],           %[mask0]      \n\t"
+      "pshufh     %[dest1],        %[dest1],          %[mask1]      \n\t"
+      "packushb   %[dest0],        %[dest0],          %[dest1]      \n\t"
+      "gssdlc1    %[dest0],        0x07(%[dstu_ptr])                \n\t"
+      "gssdrc1    %[dest0],        0x00(%[dstu_ptr])                \n\t"
+
+      "psrlh      %[dest0],        %[src0],           %[shift]      \n\t"
+      "pshufh     %[dest0],        %[dest0],          %[mask1]      \n\t"
+      "psrlh      %[dest1],        %[src1],           %[shift]      \n\t"
+      "pshufh     %[dest1],        %[dest1],          %[mask1]      \n\t"
+      "packushb   %[dest0],        %[dest0],          %[dest1]      \n\t"
+      "gssdlc1    %[dest0],        0x07(%[dstv_ptr])                \n\t"
+      "gssdrc1    %[dest0],        0x00(%[dstv_ptr])                \n\t"
+
+      "daddi      %[src_ptr],      %[src_ptr],       -0x10          \n\t"
+      "daddiu     %[dstu_ptr],     %[dstu_ptr],       0x08          \n\t"
+      "daddiu     %[dstv_ptr],     %[dstv_ptr],       0x08          \n\t"
+      "daddi      %[width],        %[width],         -0x08          \n\t"
+      "bnez       %[width],        1b                               \n\t"
+      : [dest0] "=&f"(dest0), [dest1] "=&f"(dest1), [src0] "=&f"(src0),
+        [src1] "=&f"(src1)
+      : [src_ptr] "r"(src_uv), [dstu_ptr] "r"(dst_u), [dstv_ptr] "r"(dst_v),
+        [width] "r"(width), [mask0] "f"(mask0), [mask1] "f"(mask1),
+        [shift] "f"(shift)
+      : "memory");
+}
+
+void ARGBMirrorRow_MMI(const uint8_t* src, uint8_t* dst, int width) {
+  src += (width - 1) * 4;
+  uint64_t temp = 0x0;
+  uint64_t shuff = 0x4e;  // 01 00 11 10
+  __asm__ volatile(
+      "1:                                      \n\t"
+      "gsldlc1 %[temp],  3(%[src])     	       \n\t"
+      "gsldrc1 %[temp], -4(%[src])     	       \n\t"
+      "pshufh  %[temp],  %[temp],    %[shuff]  \n\t"
+      "gssdrc1 %[temp],  0x0(%[dst])           \n\t"
+      "gssdlc1 %[temp],  0x7(%[dst])           \n\t"
+
+      "daddiu  %[src],   %[src],    -0x08      \n\t"
+      "daddiu  %[dst],   %[dst],     0x08      \n\t"
+      "daddiu  %[width], %[width],  -0x02      \n\t"
+      "bnez    %[width], 1b                    \n\t"
+      : [temp] "=&f"(temp)
+      : [src] "r"(src), [dst] "r"(dst), [width] "r"(width), [shuff] "f"(shuff)
+      : "memory");
+}
+
+void SplitUVRow_MMI(const uint8_t* src_uv,
+                    uint8_t* dst_u,
+                    uint8_t* dst_v,
+                    int width) {
+  uint64_t c0 = 0x00ff00ff00ff00ff;
+  uint64_t temp[4];
+  uint64_t shift = 0x08;
+  __asm__ volatile(
+      "1:	                                    \n\t"
+      "gsldrc1  %[t0],     0x00(%[src_uv])          \n\t"
+      "gsldlc1  %[t0],     0x07(%[src_uv])          \n\t"
+      "gsldrc1  %[t1],     0x08(%[src_uv])          \n\t"
+      "gsldlc1  %[t1],     0x0f(%[src_uv])          \n\t"
+
+      "and      %[t2],     %[t0],          %[c0]    \n\t"
+      "and      %[t3],     %[t1],          %[c0]    \n\t"
+      "packushb %[t2],     %[t2],          %[t3]    \n\t"
+      "gssdrc1  %[t2],     0x0(%[dst_u])	    \n\t"
+      "gssdlc1  %[t2],     0x7(%[dst_u])            \n\t"
+
+      "psrlh    %[t2],     %[t0],          %[shift] \n\t"
+      "psrlh    %[t3],     %[t1],          %[shift] \n\t"
+      "packushb %[t2],     %[t2],          %[t3]    \n\t"
+      "gssdrc1  %[t2],     0x0(%[dst_v])            \n\t"
+      "gssdlc1  %[t2],     0x7(%[dst_v])            \n\t"
+
+      "daddiu   %[src_uv], %[src_uv],      16       \n\t"
+      "daddiu   %[dst_u],  %[dst_u],       8        \n\t"
+      "daddiu   %[dst_v],  %[dst_v],       8        \n\t"
+      "daddiu   %[width],  %[width],      -8        \n\t"
+      "bgtz     %[width],  1b                       \n\t"
+      "nop                                          \n\t"
+      : [t0] "=&f"(temp[0]), [t1] "=&f"(temp[1]), [t2] "=&f"(temp[2]),
+        [t3] "=&f"(temp[3])
+      : [src_uv] "r"(src_uv), [dst_u] "r"(dst_u), [dst_v] "r"(dst_v),
+        [width] "r"(width), [c0] "f"(c0), [shift] "f"(shift)
+      : "memory");
+}
+
+void MergeUVRow_MMI(const uint8_t* src_u,
+                    const uint8_t* src_v,
+                    uint8_t* dst_uv,
+                    int width) {
+  uint64_t temp[3];
+  __asm__ volatile(
+      "1:	                                 \n\t"
+      "gsldrc1   %[t0],     0x0(%[src_u])        \n\t"
+      "gsldlc1   %[t0],     0x7(%[src_u])        \n\t"
+      "gsldrc1   %[t1],     0x0(%[src_v])        \n\t"
+      "gsldlc1   %[t1],     0x7(%[src_v])        \n\t"
+      "punpcklbh %[t2],     %[t0],         %[t1] \n\t"
+      "gssdrc1   %[t2],     0x0(%[dst_uv])	 \n\t"
+      "gssdlc1   %[t2],     0x7(%[dst_uv])       \n\t"
+      "punpckhbh %[t2],     %[t0],         %[t1] \n\t"
+      "gssdrc1   %[t2],     0x8(%[dst_uv])	 \n\t"
+      "gssdlc1   %[t2],     0xf(%[dst_uv])       \n\t"
+
+      "daddiu    %[src_u],  %[src_u],      8     \n\t"
+      "daddiu    %[src_v],  %[src_v],      8     \n\t"
+      "daddiu    %[dst_uv], %[dst_uv],     16    \n\t"
+      "daddiu    %[width],  %[width],     -8     \n\t"
+      "bgtz      %[width],  1b                   \n\t"
+      "nop                                       \n\t"
+      : [t0] "=&f"(temp[0]), [t1] "=&f"(temp[1]), [t2] "=&f"(temp[2])
+      : [dst_uv] "r"(dst_uv), [src_u] "r"(src_u), [src_v] "r"(src_v),
+        [width] "r"(width)
+      : "memory");
+}
+
+void SplitRGBRow_MMI(const uint8_t* src_rgb,
+                     uint8_t* dst_r,
+                     uint8_t* dst_g,
+                     uint8_t* dst_b,
+                     int width) {
+  uint64_t src[4];
+  uint64_t dest_hi, dest_lo, dest;
+
+  __asm__ volatile(
+      "1:                                                           \n\t"
+      "gslwlc1    %[src0],         0x03(%[src_ptr])                 \n\t"
+      "gslwrc1    %[src0],         0x00(%[src_ptr])                 \n\t"
+      "gslwlc1    %[src1],         0x06(%[src_ptr])                 \n\t"
+      "gslwrc1    %[src1],         0x03(%[src_ptr])                 \n\t"
+      "punpcklbh  %[dest_lo],      %[src0],           %[src1]       \n\t"
+      "gslwlc1    %[src2],         0x09(%[src_ptr])                 \n\t"
+      "gslwrc1    %[src2],         0x06(%[src_ptr])                 \n\t"
+      "gslwlc1    %[src3],         0x0c(%[src_ptr])                 \n\t"
+      "gslwrc1    %[src3],         0x09(%[src_ptr])                 \n\t"
+      "punpcklbh  %[dest_hi],      %[src2],           %[src3]       \n\t"
+
+      "punpcklhw  %[dest],         %[dest_lo],        %[dest_hi]    \n\t"
+      "gsswlc1    %[dest],         0x03(%[dstr_ptr])                \n\t"
+      "gsswrc1    %[dest],         0x00(%[dstr_ptr])                \n\t"
+      "punpckhwd  %[dest],         %[dest],           %[dest]       \n\t"
+      "gsswlc1    %[dest],         0x03(%[dstg_ptr])                \n\t"
+      "gsswrc1    %[dest],         0x00(%[dstg_ptr])                \n\t"
+      "punpckhhw  %[dest],         %[dest_lo],        %[dest_hi]    \n\t"
+      "gsswlc1    %[dest],         0x03(%[dstb_ptr])                \n\t"
+      "gsswrc1    %[dest],         0x00(%[dstb_ptr])                \n\t"
+
+      "daddiu     %[src_ptr],      %[src_ptr],        0x0c          \n\t"
+      "daddiu     %[dstr_ptr],     %[dstr_ptr],       0x04          \n\t"
+      "daddiu     %[dstg_ptr],     %[dstg_ptr],       0x04          \n\t"
+      "daddiu     %[dstb_ptr],     %[dstb_ptr],       0x04          \n\t"
+      "daddi      %[width],        %[width],         -0x04          \n\t"
+      "bnez       %[width],        1b                               \n\t"
+      : [src0] "=&f"(src[0]), [src1] "=&f"(src[1]), [src2] "=&f"(src[2]),
+        [src3] "=&f"(src[3]), [dest_hi] "=&f"(dest_hi),
+        [dest_lo] "=&f"(dest_lo), [dest] "=&f"(dest)
+      : [src_ptr] "r"(src_rgb), [dstr_ptr] "r"(dst_r), [dstg_ptr] "r"(dst_g),
+        [dstb_ptr] "r"(dst_b), [width] "r"(width)
+      : "memory");
+}
+
+void MergeRGBRow_MMI(const uint8_t* src_r,
+                     const uint8_t* src_g,
+                     const uint8_t* src_b,
+                     uint8_t* dst_rgb,
+                     int width) {
+  uint64_t srcr, srcg, srcb, dest;
+  uint64_t srcrg_hi, srcrg_lo, srcbz_hi, srcbz_lo;
+  const uint64_t temp = 0x0;
+
+  __asm__ volatile(
+      "1:                                                           \n\t"
+      "gsldlc1    %[srcr],         0x07(%[srcr_ptr])                \n\t"
+      "gsldrc1    %[srcr],         0x00(%[srcr_ptr])                \n\t"
+      "gsldlc1    %[srcg],         0x07(%[srcg_ptr])                \n\t"
+      "gsldrc1    %[srcg],         0x00(%[srcg_ptr])                \n\t"
+      "punpcklbh  %[srcrg_lo],     %[srcr],           %[srcg]       \n\t"
+      "punpckhbh  %[srcrg_hi],     %[srcr],           %[srcg]       \n\t"
+
+      "gsldlc1    %[srcb],         0x07(%[srcb_ptr])                \n\t"
+      "gsldrc1    %[srcb],         0x00(%[srcb_ptr])                \n\t"
+      "punpcklbh  %[srcbz_lo],     %[srcb],           %[temp]       \n\t"
+      "punpckhbh  %[srcbz_hi],     %[srcb],           %[temp]       \n\t"
+
+      "punpcklhw  %[dest],         %[srcrg_lo],       %[srcbz_lo]   \n\t"
+      "gsswlc1    %[dest],         0x03(%[dst_ptr])                 \n\t"
+      "gsswrc1    %[dest],         0x00(%[dst_ptr])                 \n\t"
+      "punpckhwd  %[dest],         %[dest],           %[dest]       \n\t"
+      "gsswlc1    %[dest],         0x06(%[dst_ptr])                 \n\t"
+      "gsswrc1    %[dest],         0x03(%[dst_ptr])                 \n\t"
+      "punpckhhw  %[dest],         %[srcrg_lo],       %[srcbz_lo]   \n\t"
+      "gsswlc1    %[dest],         0x09(%[dst_ptr])                 \n\t"
+      "gsswrc1    %[dest],         0x06(%[dst_ptr])                 \n\t"
+      "punpckhwd  %[dest],         %[dest],           %[dest]       \n\t"
+      "gsswlc1    %[dest],         0x0c(%[dst_ptr])                 \n\t"
+      "gsswrc1    %[dest],         0x09(%[dst_ptr])                 \n\t"
+      "punpcklhw  %[dest],         %[srcrg_hi],       %[srcbz_hi]   \n\t"
+      "gsswlc1    %[dest],         0x0f(%[dst_ptr])                 \n\t"
+      "gsswrc1    %[dest],         0x0c(%[dst_ptr])                 \n\t"
+      "punpckhwd  %[dest],         %[dest],           %[dest]       \n\t"
+      "gsswlc1    %[dest],         0x12(%[dst_ptr])                 \n\t"
+      "gsswrc1    %[dest],         0x0f(%[dst_ptr])                 \n\t"
+      "punpckhhw  %[dest],         %[srcrg_hi],       %[srcbz_hi]   \n\t"
+      "gsswlc1    %[dest],         0x15(%[dst_ptr])                 \n\t"
+      "gsswrc1    %[dest],         0x12(%[dst_ptr])                 \n\t"
+      "punpckhwd  %[dest],         %[dest],           %[dest]       \n\t"
+      "gsswlc1    %[dest],         0x18(%[dst_ptr])                 \n\t"
+      "gsswrc1    %[dest],         0x15(%[dst_ptr])                 \n\t"
+
+      "daddiu     %[srcr_ptr],     %[srcr_ptr],       0x08          \n\t"
+      "daddiu     %[srcg_ptr],     %[srcg_ptr],       0x08          \n\t"
+      "daddiu     %[srcb_ptr],     %[srcb_ptr],       0x08          \n\t"
+      "daddiu     %[dst_ptr],      %[dst_ptr],        0x18          \n\t"
+      "daddi      %[width],        %[width],         -0x08          \n\t"
+      "bnez       %[width],        1b                               \n\t"
+      : [srcr] "=&f"(srcr), [srcg] "=&f"(srcg), [srcb] "=&f"(srcb),
+        [dest] "=&f"(dest), [srcrg_hi] "=&f"(srcrg_hi),
+        [srcrg_lo] "=&f"(srcrg_lo), [srcbz_hi] "=&f"(srcbz_hi),
+        [srcbz_lo] "=&f"(srcbz_lo)
+      : [srcr_ptr] "r"(src_r), [srcg_ptr] "r"(src_g), [srcb_ptr] "r"(src_b),
+        [dst_ptr] "r"(dst_rgb), [width] "r"(width), [temp] "f"(temp)
+      : "memory");
+}
+
+// Filter 2 rows of YUY2 UV's (422) into U and V (420).
+void YUY2ToUVRow_MMI(const uint8_t* src_yuy2,
+                     int src_stride_yuy2,
+                     uint8_t* dst_u,
+                     uint8_t* dst_v,
+                     int width) {
+  uint64_t c0 = 0xff00ff00ff00ff00;
+  uint64_t c1 = 0x00ff00ff00ff00ff;
+  uint64_t temp[3];
+  uint64_t data[4];
+  uint64_t shift = 0x08;
+  uint64_t src_stride = 0x0;
+  __asm__ volatile(
+      "1:	                                                     \n\t"
+      "gsldrc1  %[t0],         0x00(%[src_yuy2])                     \n\t"
+      "gsldlc1  %[t0],         0x07(%[src_yuy2])                     \n\t"
+      "daddu    %[src_stride], %[src_yuy2],       %[src_stride_yuy2] \n\t"
+      "gsldrc1  %[t1],         0x00(%[src_stride])                   \n\t"
+      "gsldlc1  %[t1],         0x07(%[src_stride])                   \n\t"
+      "pavgb    %[t0],         %[t0],             %[t1]              \n\t"
+
+      "gsldrc1  %[t2],         0x08(%[src_yuy2])                     \n\t"
+      "gsldlc1  %[t2],         0x0f(%[src_yuy2])                     \n\t"
+      "gsldrc1  %[t1],         0x08(%[src_stride])                   \n\t"
+      "gsldlc1  %[t1],         0x0f(%[src_stride])                   \n\t"
+      "pavgb    %[t1],         %[t2],             %[t1]              \n\t"
+
+      "and      %[t0],         %[t0],             %[c0]              \n\t"
+      "and      %[t1],         %[t1],             %[c0]              \n\t"
+      "psrlh    %[t0],         %[t0],             %[shift]           \n\t"
+      "psrlh    %[t1],         %[t1],             %[shift]           \n\t"
+      "packushb %[t0],         %[t0],             %[t1]              \n\t"
+      "mov.s    %[t1],         %[t0]                                 \n\t"
+      "and      %[d0],         %[t0],             %[c1]              \n\t"
+      "psrlh    %[d1],         %[t1],             %[shift]           \n\t"
+
+      "gsldrc1  %[t0],         0x10(%[src_yuy2])                     \n\t"
+      "gsldlc1  %[t0],         0x17(%[src_yuy2])                     \n\t"
+      "gsldrc1  %[t1],         0x10(%[src_stride])                   \n\t"
+      "gsldlc1  %[t1],         0x17(%[src_stride])                   \n\t"
+      "pavgb    %[t0],         %[t0],              %[t1]             \n\t"
+
+      "gsldrc1  %[t2],         0x18(%[src_yuy2])                     \n\t"
+      "gsldlc1  %[t2],         0x1f(%[src_yuy2])                     \n\t"
+      "gsldrc1  %[t1],         0x18(%[src_stride])                   \n\t"
+      "gsldlc1  %[t1],         0x1f(%[src_stride])                   \n\t"
+      "pavgb    %[t1],         %[t2],              %[t1]             \n\t"
+
+      "and      %[t0],         %[t0],              %[c0]             \n\t"
+      "and      %[t1],         %[t1],              %[c0]             \n\t"
+      "psrlh    %[t0],         %[t0],              %[shift]          \n\t"
+      "psrlh    %[t1],         %[t1],              %[shift]          \n\t"
+      "packushb %[t0],         %[t0],              %[t1]             \n\t"
+      "mov.s    %[t1],         %[t0]                                 \n\t"
+      "and      %[d2],         %[t0],              %[c1]             \n\t"
+      "psrlh    %[d3],         %[t1],              %[shift]          \n\t"
+
+      "packushb %[d0],         %[d0],              %[d2]             \n\t"
+      "packushb %[d1],         %[d1],              %[d3]             \n\t"
+      "gssdrc1  %[d0],         0x0(%[dst_u])	                     \n\t"
+      "gssdlc1  %[d0],         0x7(%[dst_u])                         \n\t"
+      "gssdrc1  %[d1],         0x0(%[dst_v])	                     \n\t"
+      "gssdlc1  %[d1],         0x7(%[dst_v])                         \n\t"
+      "daddiu   %[src_yuy2],   %[src_yuy2],        32                \n\t"
+      "daddiu   %[dst_u],      %[dst_u],           8                 \n\t"
+      "daddiu   %[dst_v],      %[dst_v],           8                 \n\t"
+      "daddiu   %[width],      %[width],          -16                \n\t"
+      "bgtz     %[width],      1b                                    \n\t"
+      "nop                                                           \n\t"
+      : [t0] "=&f"(temp[0]), [t1] "=&f"(temp[1]), [t2] "=&f"(temp[2]),
+        [d0] "=&f"(data[0]), [d1] "=&f"(data[1]), [d2] "=&f"(data[2]),
+        [d3] "=&f"(data[3]), [src_stride] "=&r"(src_stride)
+      : [src_yuy2] "r"(src_yuy2), [src_stride_yuy2] "r"(src_stride_yuy2),
+        [dst_u] "r"(dst_u), [dst_v] "r"(dst_v), [width] "r"(width),
+        [c0] "f"(c0), [c1] "f"(c1), [shift] "f"(shift)
+      : "memory");
+}
+
+// Copy row of YUY2 UV's (422) into U and V (422).
+void YUY2ToUV422Row_MMI(const uint8_t* src_yuy2,
+                        uint8_t* dst_u,
+                        uint8_t* dst_v,
+                        int width) {
+  uint64_t c0 = 0xff00ff00ff00ff00;
+  uint64_t c1 = 0x00ff00ff00ff00ff;
+  uint64_t temp[2];
+  uint64_t data[4];
+  uint64_t shift = 0x08;
+  __asm__ volatile(
+      "1:	                                        \n\t"
+      "gsldrc1  %[t0],       0x00(%[src_yuy2])          \n\t"
+      "gsldlc1  %[t0],       0x07(%[src_yuy2])          \n\t"
+      "gsldrc1  %[t1],       0x08(%[src_yuy2])          \n\t"
+      "gsldlc1  %[t1],       0x0f(%[src_yuy2])          \n\t"
+      "and      %[t0],       %[t0],            %[c0]    \n\t"
+      "and      %[t1],       %[t1],            %[c0]    \n\t"
+      "psrlh    %[t0],       %[t0],            %[shift] \n\t"
+      "psrlh    %[t1],       %[t1],            %[shift] \n\t"
+      "packushb %[t0],       %[t0],            %[t1]    \n\t"
+      "mov.s    %[t1],       %[t0]                      \n\t"
+      "and      %[d0],       %[t0],            %[c1]    \n\t"
+      "psrlh    %[d1],       %[t1],            %[shift] \n\t"
+
+      "gsldrc1  %[t0],       0x10(%[src_yuy2])          \n\t"
+      "gsldlc1  %[t0],       0x17(%[src_yuy2])          \n\t"
+      "gsldrc1  %[t1],       0x18(%[src_yuy2])          \n\t"
+      "gsldlc1  %[t1],       0x1f(%[src_yuy2])          \n\t"
+      "and      %[t0],       %[t0],            %[c0]    \n\t"
+      "and      %[t1],       %[t1],            %[c0]    \n\t"
+      "psrlh    %[t0],       %[t0],            %[shift] \n\t"
+      "psrlh    %[t1],       %[t1],            %[shift] \n\t"
+      "packushb %[t0],       %[t0],            %[t1]    \n\t"
+      "mov.s    %[t1],       %[t0]                      \n\t"
+      "and      %[d2],       %[t0],            %[c1]    \n\t"
+      "psrlh    %[d3],       %[t1],            %[shift] \n\t"
+
+      "packushb %[d0],       %[d0],            %[d2]    \n\t"
+      "packushb %[d1],       %[d1],            %[d3]    \n\t"
+      "gssdrc1  %[d0],       0x0(%[dst_u])	        \n\t"
+      "gssdlc1  %[d0],       0x7(%[dst_u])              \n\t"
+      "gssdrc1  %[d1],       0x0(%[dst_v])	        \n\t"
+      "gssdlc1  %[d1],       0x7(%[dst_v])              \n\t"
+      "daddiu   %[src_yuy2], %[src_yuy2],      32       \n\t"
+      "daddiu   %[dst_u],    %[dst_u],         8        \n\t"
+      "daddiu   %[dst_v],    %[dst_v],         8        \n\t"
+      "daddiu   %[width],    %[width],        -16       \n\t"
+      "bgtz     %[width],    1b                         \n\t"
+      "nop                                              \n\t"
+      : [t0] "=&f"(temp[0]), [t1] "=&f"(temp[1]), [d0] "=&f"(data[0]),
+        [d1] "=&f"(data[1]), [d2] "=&f"(data[2]), [d3] "=&f"(data[3])
+      : [src_yuy2] "r"(src_yuy2), [dst_u] "r"(dst_u), [dst_v] "r"(dst_v),
+        [width] "r"(width), [c0] "f"(c0), [c1] "f"(c1), [shift] "f"(shift)
+      : "memory");
+}
+
+// Copy row of YUY2 Y's (422) into Y (420/422).
+void YUY2ToYRow_MMI(const uint8_t* src_yuy2, uint8_t* dst_y, int width) {
+  uint64_t c0 = 0x00ff00ff00ff00ff;
+  uint64_t temp[2];
+  __asm__ volatile(
+      "1:	                                     \n\t"
+      "gsldrc1  %[t0],       0x00(%[src_yuy2])       \n\t"
+      "gsldlc1  %[t0],       0x07(%[src_yuy2])       \n\t"
+      "gsldrc1  %[t1],       0x08(%[src_yuy2])       \n\t"
+      "gsldlc1  %[t1],       0x0f(%[src_yuy2])       \n\t"
+      "and      %[t0],       %[t0],            %[c0] \n\t"
+      "and      %[t1],       %[t1],            %[c0] \n\t"
+      "packushb %[t0],       %[t0],            %[t1] \n\t"
+      "gssdrc1  %[t0],       0x0(%[dst_y])	     \n\t"
+      "gssdlc1  %[t0],       0x7(%[dst_y])           \n\t"
+      "daddiu   %[src_yuy2], %[src_yuy2],      16    \n\t"
+      "daddiu   %[dst_y],    %[dst_y],         8     \n\t"
+      "daddiu   %[width],    %[width],        -8     \n\t"
+      "bgtz     %[width],    1b                      \n\t"
+      "nop                                           \n\t"
+      : [t0] "=&f"(temp[0]), [t1] "=&f"(temp[1])
+      : [src_yuy2] "r"(src_yuy2), [dst_y] "r"(dst_y), [width] "r"(width),
+        [c0] "f"(c0)
+      : "memory");
+}
+
+// Filter 2 rows of UYVY UV's (422) into U and V (420).
+void UYVYToUVRow_MMI(const uint8_t* src_uyvy,
+                     int src_stride_uyvy,
+                     uint8_t* dst_u,
+                     uint8_t* dst_v,
+                     int width) {
+  // Output a row of UV values.
+  uint64_t c0 = 0x00ff00ff00ff00ff;
+  uint64_t temp[3];
+  uint64_t data[4];
+  uint64_t shift = 0x08;
+  uint64_t src_stride = 0x0;
+  __asm__ volatile(
+      "1:	                                                      \n\t"
+      "gsldrc1  %[t0],         0x00(%[src_uyvy])                      \n\t"
+      "gsldlc1  %[t0],         0x07(%[src_uyvy])                      \n\t"
+      "daddu    %[src_stride], %[src_uyvy],        %[src_stride_uyvy] \n\t"
+      "gsldrc1  %[t1],         0x00(%[src_stride])                    \n\t"
+      "gsldlc1  %[t1],         0x07(%[src_stride])                    \n\t"
+      "pavgb    %[t0],         %[t0],              %[t1]              \n\t"
+
+      "gsldrc1  %[t2],         0x08(%[src_uyvy])                      \n\t"
+      "gsldlc1  %[t2],         0x0f(%[src_uyvy])                      \n\t"
+      "gsldrc1  %[t1],         0x08(%[src_stride])                    \n\t"
+      "gsldlc1  %[t1],         0x0f(%[src_stride])                    \n\t"
+      "pavgb    %[t1],         %[t2],              %[t1]              \n\t"
+
+      "and      %[t0],         %[t0],              %[c0]              \n\t"
+      "and      %[t1],         %[t1],              %[c0]              \n\t"
+      "packushb %[t0],         %[t0],              %[t1]              \n\t"
+      "mov.s    %[t1],         %[t0]                                  \n\t"
+      "and      %[d0],         %[t0],              %[c0]              \n\t"
+      "psrlh    %[d1],         %[t1],              %[shift]           \n\t"
+
+      "gsldrc1  %[t0],         0x10(%[src_uyvy])                      \n\t"
+      "gsldlc1  %[t0],         0x17(%[src_uyvy])                      \n\t"
+      "gsldrc1  %[t1],         0x10(%[src_stride])                    \n\t"
+      "gsldlc1  %[t1],         0x17(%[src_stride])                    \n\t"
+      "pavgb    %[t0],         %[t0],              %[t1]              \n\t"
+
+      "gsldrc1  %[t2],         0x18(%[src_uyvy])                      \n\t"
+      "gsldlc1  %[t2],         0x1f(%[src_uyvy])                      \n\t"
+      "gsldrc1  %[t1],         0x18(%[src_stride])                    \n\t"
+      "gsldlc1  %[t1],         0x1f(%[src_stride])                    \n\t"
+      "pavgb    %[t1],         %[t2],              %[t1]              \n\t"
+
+      "and      %[t0],         %[t0],              %[c0]              \n\t"
+      "and      %[t1],         %[t1],              %[c0]              \n\t"
+      "packushb %[t0],         %[t0],              %[t1]              \n\t"
+      "mov.s    %[t1],         %[t0]                                  \n\t"
+      "and      %[d2],         %[t0],              %[c0]              \n\t"
+      "psrlh    %[d3],         %[t1],              %[shift]           \n\t"
+
+      "packushb %[d0],         %[d0],              %[d2]              \n\t"
+      "packushb %[d1],         %[d1],              %[d3]              \n\t"
+      "gssdrc1  %[d0],         0x0(%[dst_u])	                      \n\t"
+      "gssdlc1  %[d0],         0x7(%[dst_u])                          \n\t"
+      "gssdrc1  %[d1],         0x0(%[dst_v])	                      \n\t"
+      "gssdlc1  %[d1],         0x7(%[dst_v])                          \n\t"
+      "daddiu   %[src_uyvy],   %[src_uyvy],        32                 \n\t"
+      "daddiu   %[dst_u],      %[dst_u],           8                  \n\t"
+      "daddiu   %[dst_v],      %[dst_v],           8                  \n\t"
+      "daddiu   %[width],      %[width],          -16                 \n\t"
+      "bgtz     %[width],      1b                                     \n\t"
+      "nop                                                            \n\t"
+      : [t0] "=&f"(temp[0]), [t1] "=&f"(temp[1]), [t2] "=&f"(temp[2]),
+        [d0] "=&f"(data[0]), [d1] "=&f"(data[1]), [d2] "=&f"(data[2]),
+        [d3] "=&f"(data[3]), [src_stride] "=&r"(src_stride)
+      : [src_uyvy] "r"(src_uyvy), [src_stride_uyvy] "r"(src_stride_uyvy),
+        [dst_u] "r"(dst_u), [dst_v] "r"(dst_v), [width] "r"(width),
+        [c0] "f"(c0), [shift] "f"(shift)
+      : "memory");
+}
+
+// Copy row of UYVY UV's (422) into U and V (422).
+void UYVYToUV422Row_MMI(const uint8_t* src_uyvy,
+                        uint8_t* dst_u,
+                        uint8_t* dst_v,
+                        int width) {
+  // Output a row of UV values.
+  uint64_t c0 = 0x00ff00ff00ff00ff;
+  uint64_t temp[2];
+  uint64_t data[4];
+  uint64_t shift = 0x08;
+  __asm__ volatile(
+      "1:	                                        \n\t"
+      "gsldrc1  %[t0],       0x00(%[src_uyvy])          \n\t"
+      "gsldlc1  %[t0],       0x07(%[src_uyvy])          \n\t"
+      "gsldrc1  %[t1],       0x08(%[src_uyvy])          \n\t"
+      "gsldlc1  %[t1],       0x0f(%[src_uyvy])          \n\t"
+      "and      %[t0],       %[t0],            %[c0]    \n\t"
+      "and      %[t1],       %[t1],            %[c0]    \n\t"
+      "packushb %[t0],       %[t0],            %[t1]    \n\t"
+      "mov.s    %[t1],       %[t0]                      \n\t"
+      "and      %[d0],       %[t0],            %[c0]    \n\t"
+      "psrlh    %[d1],       %[t1],            %[shift] \n\t"
+
+      "gsldrc1  %[t0],       0x10(%[src_uyvy])          \n\t"
+      "gsldlc1  %[t0],       0x17(%[src_uyvy])          \n\t"
+      "gsldrc1  %[t1],       0x18(%[src_uyvy])          \n\t"
+      "gsldlc1  %[t1],       0x1f(%[src_uyvy])          \n\t"
+      "and      %[t0],       %[t0],            %[c0]    \n\t"
+      "and      %[t1],       %[t1],            %[c0]    \n\t"
+      "packushb %[t0],       %[t0],            %[t1]    \n\t"
+      "mov.s    %[t1],       %[t0]                      \n\t"
+      "and      %[d2],       %[t0],            %[c0]    \n\t"
+      "psrlh    %[d3],       %[t1],            %[shift] \n\t"
+
+      "packushb %[d0],       %[d0],            %[d2]    \n\t"
+      "packushb %[d1],       %[d1],            %[d3]    \n\t"
+      "gssdrc1  %[d0],       0x0(%[dst_u])	        \n\t"
+      "gssdlc1  %[d0],       0x7(%[dst_u])              \n\t"
+      "gssdrc1  %[d1],       0x0(%[dst_v])	        \n\t"
+      "gssdlc1  %[d1],       0x7(%[dst_v])              \n\t"
+      "daddiu   %[src_uyvy], %[src_uyvy],      32       \n\t"
+      "daddiu   %[dst_u],    %[dst_u],         8        \n\t"
+      "daddiu   %[dst_v],    %[dst_v],         8        \n\t"
+      "daddiu   %[width],    %[width],        -16       \n\t"
+      "bgtz     %[width],    1b                         \n\t"
+      "nop                                              \n\t"
+      : [t0] "=&f"(temp[0]), [t1] "=&f"(temp[1]), [d0] "=&f"(data[0]),
+        [d1] "=&f"(data[1]), [d2] "=&f"(data[2]), [d3] "=&f"(data[3])
+      : [src_uyvy] "r"(src_uyvy), [dst_u] "r"(dst_u), [dst_v] "r"(dst_v),
+        [width] "r"(width), [c0] "f"(c0), [shift] "f"(shift)
+      : "memory");
+}
+
+// Copy row of UYVY Y's (422) into Y (420/422).
+void UYVYToYRow_MMI(const uint8_t* src_uyvy, uint8_t* dst_y, int width) {
+  // Output a row of Y values.
+  uint64_t c0 = 0x00ff00ff00ff00ff;
+  uint64_t shift = 0x08;
+  uint64_t temp[2];
+  __asm__ volatile(
+      "1:	                                        \n\t"
+      "gsldrc1  %[t0],       0x00(%[src_uyvy])          \n\t"
+      "gsldlc1  %[t0],       0x07(%[src_uyvy])          \n\t"
+      "gsldrc1  %[t1],       0x08(%[src_uyvy])          \n\t"
+      "gsldlc1  %[t1],       0x0f(%[src_uyvy])          \n\t"
+      "dsrl     %[t0],       %[t0],            %[shift] \n\t"
+      "dsrl     %[t1],       %[t1],            %[shift] \n\t"
+      "and      %[t0],       %[t0],            %[c0]    \n\t"
+      "and      %[t1],       %[t1],            %[c0]    \n\t"
+      "and      %[t1],       %[t1],            %[c0]    \n\t"
+      "packushb %[t0],       %[t0],            %[t1]    \n\t"
+      "gssdrc1  %[t0],       0x0(%[dst_y])	        \n\t"
+      "gssdlc1  %[t0],       0x7(%[dst_y])              \n\t"
+      "daddiu   %[src_uyvy], %[src_uyvy],      16       \n\t"
+      "daddiu   %[dst_y],    %[dst_y],         8        \n\t"
+      "daddiu   %[width],    %[width],        -8        \n\t"
+      "bgtz     %[width],    1b                         \n\t"
+      "nop                                              \n\t"
+      : [t0] "=&f"(temp[0]), [t1] "=&f"(temp[1])
+      : [src_uyvy] "r"(src_uyvy), [dst_y] "r"(dst_y), [width] "r"(width),
+        [c0] "f"(c0), [shift] "f"(shift)
+      : "memory");
+}
+
+// Blend src_argb over src_argb1 and store to dst_argb.
+// dst_argb may be src_argb or src_argb1.
+// This code mimics the SSSE3 version for better testability.
+void ARGBBlendRow_MMI(const uint8_t* src_argb,
+                      const uint8_t* src_argb1,
+                      uint8_t* dst_argb,
+                      int width) {
+  uint64_t src0, src1, dest, alpha, src0_hi, src0_lo, src1_hi, src1_lo, dest_hi,
+      dest_lo;
+  const uint64_t mask0 = 0x0;
+  const uint64_t mask1 = 0x00FFFFFF00FFFFFFULL;
+  const uint64_t mask2 = 0x00FF00FF00FF00FFULL;
+  const uint64_t mask3 = 0xFF;
+  const uint64_t mask4 = ~mask1;
+  const uint64_t shift = 0x08;
+
+  __asm__ volatile(
+      "1:                                                           \n\t"
+      "gsldlc1    %[src0],         0x07(%[src0_ptr])                \n\t"
+      "gsldrc1    %[src0],         0x00(%[src0_ptr])                \n\t"
+      "punpcklbh  %[src0_lo],      %[src0],           %[mask0]      \n\t"
+
+      "gsldlc1    %[src1],         0x07(%[src1_ptr])                \n\t"
+      "gsldrc1    %[src1],         0x00(%[src1_ptr])                \n\t"
+      "punpcklbh  %[src1_lo],      %[src1],           %[mask0]      \n\t"
+
+      "psubush    %[alpha],        %[mask2],          %[src0_lo]    \n\t"
+      "pshufh     %[alpha],        %[alpha],          %[mask3]      \n\t"
+      "pmullh     %[dest_lo],      %[src1_lo],        %[alpha]      \n\t"
+      "psrlh      %[dest_lo],      %[dest_lo],        %[shift]      \n\t"
+      "paddush    %[dest_lo],      %[dest_lo],        %[src0_lo]    \n\t"
+
+      "punpckhbh  %[src0_hi],      %[src0],           %[mask0]      \n\t"
+      "punpckhbh  %[src1_hi],      %[src1],           %[mask0]      \n\t"
+
+      "psubush    %[alpha],        %[mask2],          %[src0_hi]    \n\t"
+      "pshufh     %[alpha],        %[alpha],          %[mask3]      \n\t"
+      "pmullh     %[dest_hi],      %[src1_hi],        %[alpha]      \n\t"
+      "psrlh      %[dest_hi],      %[dest_hi],        %[shift]      \n\t"
+      "paddush    %[dest_hi],      %[dest_hi],        %[src0_hi]    \n\t"
+
+      "packushb   %[dest],         %[dest_lo],        %[dest_hi]    \n\t"
+      "and        %[dest],         %[dest],           %[mask1]      \n\t"
+      "or         %[dest],         %[dest],           %[mask4]      \n\t"
+      "gssdlc1    %[dest],         0x07(%[dst_ptr])                 \n\t"
+      "gssdrc1    %[dest],         0x00(%[dst_ptr])                 \n\t"
+
+      "daddiu     %[src0_ptr],     %[src0_ptr],       0x08          \n\t"
+      "daddiu     %[src1_ptr],     %[src1_ptr],       0x08          \n\t"
+      "daddiu     %[dst_ptr],      %[dst_ptr],        0x08          \n\t"
+      "daddi      %[width],        %[width],         -0x02          \n\t"
+      "bnez       %[width],        1b                               \n\t"
+      : [src0] "=&f"(src0), [src1] "=&f"(src1), [alpha] "=&f"(alpha),
+        [dest] "=&f"(dest), [src0_hi] "=&f"(src0_hi), [src0_lo] "=&f"(src0_lo),
+        [src1_hi] "=&f"(src1_hi), [src1_lo] "=&f"(src1_lo),
+        [dest_hi] "=&f"(dest_hi), [dest_lo] "=&f"(dest_lo)
+      : [src0_ptr] "r"(src_argb), [src1_ptr] "r"(src_argb1),
+        [dst_ptr] "r"(dst_argb), [mask0] "f"(mask0), [mask1] "f"(mask1),
+        [mask2] "f"(mask2), [mask3] "f"(mask3), [mask4] "f"(mask4),
+        [shift] "f"(shift), [width] "r"(width)
+      : "memory");
+}
+
+void BlendPlaneRow_MMI(const uint8_t* src0,
+                       const uint8_t* src1,
+                       const uint8_t* alpha,
+                       uint8_t* dst,
+                       int width) {
+  uint64_t source0, source1, dest, alph;
+  uint64_t src0_hi, src0_lo, src1_hi, src1_lo, alpha_hi, alpha_lo, dest_hi,
+      dest_lo;
+  uint64_t alpha_rev, alpha_rev_lo, alpha_rev_hi;
+  const uint64_t mask0 = 0x0;
+  const uint64_t mask1 = 0xFFFFFFFFFFFFFFFFULL;
+  const uint64_t mask2 = 0x00FF00FF00FF00FFULL;
+  const uint64_t shift = 0x08;
+
+  __asm__ volatile(
+      "1:                                                           \n\t"
+      "gsldlc1    %[src0],         0x07(%[src0_ptr])                \n\t"
+      "gsldrc1    %[src0],         0x00(%[src0_ptr])                \n\t"
+      "punpcklbh  %[src0_lo],      %[src0],           %[mask0]      \n\t"
+      "punpckhbh  %[src0_hi],      %[src0],           %[mask0]      \n\t"
+
+      "gsldlc1    %[src1],         0x07(%[src1_ptr])                \n\t"
+      "gsldrc1    %[src1],         0x00(%[src1_ptr])                \n\t"
+      "punpcklbh  %[src1_lo],      %[src1],           %[mask0]      \n\t"
+      "punpckhbh  %[src1_hi],      %[src1],           %[mask0]      \n\t"
+
+      "gsldlc1    %[alpha],        0x07(%[alpha_ptr])               \n\t"
+      "gsldrc1    %[alpha],        0x00(%[alpha_ptr])               \n\t"
+      "psubusb    %[alpha_r],      %[mask1],          %[alpha]      \n\t"
+      "punpcklbh  %[alpha_lo],     %[alpha],          %[mask0]      \n\t"
+      "punpckhbh  %[alpha_hi],     %[alpha],          %[mask0]      \n\t"
+      "punpcklbh  %[alpha_rlo],    %[alpha_r],        %[mask0]      \n\t"
+      "punpckhbh  %[alpha_rhi],    %[alpha_r],        %[mask0]      \n\t"
+
+      "pmullh     %[dest_lo],      %[src0_lo],        %[alpha_lo]   \n\t"
+      "pmullh     %[dest],         %[src1_lo],        %[alpha_rlo]  \n\t"
+      "paddush    %[dest_lo],      %[dest_lo],        %[dest]       \n\t"
+      "paddush    %[dest_lo],      %[dest_lo],        %[mask2]      \n\t"
+      "psrlh      %[dest_lo],      %[dest_lo],        %[shift]      \n\t"
+
+      "pmullh     %[dest_hi],      %[src0_hi],        %[alpha_hi]   \n\t"
+      "pmullh     %[dest],         %[src1_hi],        %[alpha_rhi]  \n\t"
+      "paddush    %[dest_hi],      %[dest_hi],        %[dest]       \n\t"
+      "paddush    %[dest_hi],      %[dest_hi],        %[mask2]      \n\t"
+      "psrlh      %[dest_hi],      %[dest_hi],        %[shift]      \n\t"
+
+      "packushb   %[dest],         %[dest_lo],        %[dest_hi]    \n\t"
+      "gssdlc1    %[dest],         0x07(%[dst_ptr])                 \n\t"
+      "gssdrc1    %[dest],         0x00(%[dst_ptr])                 \n\t"
+
+      "daddiu     %[src0_ptr],     %[src0_ptr],       0x08          \n\t"
+      "daddiu     %[src1_ptr],     %[src1_ptr],       0x08          \n\t"
+      "daddiu     %[alpha_ptr],    %[alpha_ptr],      0x08          \n\t"
+      "daddiu     %[dst_ptr],      %[dst_ptr],        0x08          \n\t"
+      "daddi      %[width],        %[width],         -0x08          \n\t"
+      "bnez       %[width],        1b                               \n\t"
+      : [src0] "=&f"(source0), [src1] "=&f"(source1), [alpha] "=&f"(alph),
+        [dest] "=&f"(dest), [src0_hi] "=&f"(src0_hi), [src0_lo] "=&f"(src0_lo),
+        [src1_hi] "=&f"(src1_hi), [src1_lo] "=&f"(src1_lo),
+        [alpha_hi] "=&f"(alpha_hi), [alpha_lo] "=&f"(alpha_lo),
+        [dest_hi] "=&f"(dest_hi), [dest_lo] "=&f"(dest_lo),
+        [alpha_rlo] "=&f"(alpha_rev_lo), [alpha_rhi] "=&f"(alpha_rev_hi),
+        [alpha_r] "=&f"(alpha_rev)
+      : [src0_ptr] "r"(src0), [src1_ptr] "r"(src1), [alpha_ptr] "r"(alpha),
+        [dst_ptr] "r"(dst), [mask0] "f"(mask0), [mask1] "f"(mask1),
+        [mask2] "f"(mask2), [shift] "f"(shift), [width] "r"(width)
+      : "memory");
+}
+
+// Multiply source RGB by alpha and store to destination.
+// This code mimics the SSSE3 version for better testability.
+void ARGBAttenuateRow_MMI(const uint8_t* src_argb,
+                          uint8_t* dst_argb,
+                          int width) {
+  uint64_t src, src_hi, src_lo, dest, dest_hi, dest_lo, alpha;
+  const uint64_t mask0 = 0xFF;
+  const uint64_t mask1 = 0xFF000000FF000000ULL;
+  const uint64_t mask2 = ~mask1;
+  const uint64_t shift = 0x08;
+
+  __asm__ volatile(
+      "1:                                                           \n\t"
+      "gsldlc1    %[src],          0x07(%[src_ptr])                 \n\t"
+      "gsldrc1    %[src],          0x00(%[src_ptr])                 \n\t"
+      "punpcklbh  %[src_lo],       %[src],            %[src]        \n\t"
+      "punpckhbh  %[src_hi],       %[src],            %[src]        \n\t"
+
+      "pshufh     %[alpha],        %[src_lo],         %[mask0]      \n\t"
+      "pmulhuh    %[dest_lo],      %[alpha],          %[src_lo]     \n\t"
+      "psrlh      %[dest_lo],      %[dest_lo],        %[shift]      \n\t"
+      "pshufh     %[alpha],        %[src_hi],         %[mask0]      \n\t"
+      "pmulhuh    %[dest_hi],      %[alpha],          %[src_hi]     \n\t"
+      "psrlh      %[dest_hi],      %[dest_hi],        %[shift]      \n\t"
+
+      "packushb   %[dest],         %[dest_lo],        %[dest_hi]    \n\t"
+      "and        %[dest],         %[dest],           %[mask2]      \n\t"
+      "and        %[src],          %[src],            %[mask1]      \n\t"
+      "or         %[dest],         %[dest],           %[src]        \n\t"
+      "gssdlc1    %[dest],         0x07(%[dst_ptr])                 \n\t"
+      "gssdrc1    %[dest],         0x00(%[dst_ptr])                 \n\t"
+
+      "daddiu     %[src_ptr],      %[src_ptr],        0x08          \n\t"
+      "daddiu     %[dst_ptr],      %[dst_ptr],        0x08          \n\t"
+      "daddi      %[width],        %[width],         -0x02          \n\t"
+      "bnez       %[width],        1b                               \n\t"
+      : [src] "=&f"(src), [dest] "=&f"(dest), [src_hi] "=&f"(src_hi),
+        [src_lo] "=&f"(src_lo), [dest_hi] "=&f"(dest_hi),
+        [dest_lo] "=&f"(dest_lo), [alpha] "=&f"(alpha)
+      : [src_ptr] "r"(src_argb), [dst_ptr] "r"(dst_argb), [mask0] "f"(mask0),
+        [mask1] "f"(mask1), [mask2] "f"(mask2), [shift] "f"(shift),
+        [width] "r"(width)
+      : "memory");
+}
+
+void ComputeCumulativeSumRow_MMI(const uint8_t* row,
+                                 int32_t* cumsum,
+                                 const int32_t* previous_cumsum,
+                                 int width) {
+  int64_t row_sum[2] = {0, 0};
+  uint64_t src, dest0, dest1, presrc0, presrc1, dest;
+  const uint64_t mask = 0x0;
+
+  __asm__ volatile(
+      "xor        %[row_sum0],     %[row_sum0],       %[row_sum0]   \n\t"
+      "xor        %[row_sum1],     %[row_sum1],       %[row_sum1]   \n\t"
+
+      "1:                                                           \n\t"
+      "gslwlc1    %[src],          0x03(%[row_ptr])                 \n\t"
+      "gslwrc1    %[src],          0x00(%[row_ptr])                 \n\t"
+
+      "punpcklbh  %[src],          %[src],            %[mask]       \n\t"
+      "punpcklhw  %[dest0],        %[src],            %[mask]       \n\t"
+      "punpckhhw  %[dest1],        %[src],            %[mask]       \n\t"
+
+      "paddw      %[row_sum0],     %[row_sum0],       %[dest0]      \n\t"
+      "paddw      %[row_sum1],     %[row_sum1],       %[dest1]      \n\t"
+
+      "gsldlc1    %[presrc0],      0x07(%[pre_ptr])                 \n\t"
+      "gsldrc1    %[presrc0],      0x00(%[pre_ptr])                 \n\t"
+      "gsldlc1    %[presrc1],      0x0f(%[pre_ptr])                 \n\t"
+      "gsldrc1    %[presrc1],      0x08(%[pre_ptr])                 \n\t"
+
+      "paddw      %[dest0],        %[row_sum0],       %[presrc0]    \n\t"
+      "paddw      %[dest1],        %[row_sum1],       %[presrc1]    \n\t"
+
+      "gssdlc1    %[dest0],        0x07(%[dst_ptr])                 \n\t"
+      "gssdrc1    %[dest0],        0x00(%[dst_ptr])                 \n\t"
+      "gssdlc1    %[dest1],        0x0f(%[dst_ptr])                 \n\t"
+      "gssdrc1    %[dest1],        0x08(%[dst_ptr])                 \n\t"
+
+      "daddiu     %[row_ptr],      %[row_ptr],        0x04          \n\t"
+      "daddiu     %[pre_ptr],      %[pre_ptr],        0x10          \n\t"
+      "daddiu     %[dst_ptr],      %[dst_ptr],        0x10          \n\t"
+      "daddi      %[width],        %[width],         -0x01          \n\t"
+      "bnez       %[width],        1b                               \n\t"
+      : [src] "=&f"(src), [dest] "=&f"(dest), [dest0] "=&f"(dest0),
+        [dest1] "=&f"(dest1), [row_sum0] "+&f"(row_sum[0]),
+        [row_sum1] "+&f"(row_sum[1]), [presrc0] "=&f"(presrc0),
+        [presrc1] "=&f"(presrc1)
+      : [row_ptr] "r"(row), [pre_ptr] "r"(previous_cumsum),
+        [dst_ptr] "r"(cumsum), [width] "r"(width), [mask] "f"(mask)
+      : "memory");
+}
+
+// C version 2x2 -> 2x1.
+void InterpolateRow_MMI(uint8_t* dst_ptr,
+                        const uint8_t* src_ptr,
+                        ptrdiff_t src_stride,
+                        int width,
+                        int source_y_fraction) {
+  if (source_y_fraction == 0) {
+    __asm__ volatile(
+        "1:	                              \n\t"
+        "ld     $t0,        0x0(%[src_ptr])   \n\t"
+        "sd     $t0,        0x0(%[dst_ptr])   \n\t"
+        "daddiu %[src_ptr], %[src_ptr],     8 \n\t"
+        "daddiu %[dst_ptr], %[dst_ptr],     8 \n\t"
+        "daddiu %[width],   %[width],      -8 \n\t"
+        "bgtz   %[width],   1b                \n\t"
+        "nop                                  \n\t"
+        :
+        : [dst_ptr] "r"(dst_ptr), [src_ptr] "r"(src_ptr), [width] "r"(width)
+        : "memory");
+    return;
+  }
+  if (source_y_fraction == 128) {
+    uint64_t uv = 0x0;
+    uint64_t uv_stride = 0x0;
+    __asm__ volatile(
+        "1:	                                            \n\t"
+        "gsldrc1 %[uv],        0x0(%[src_ptr])              \n\t"
+        "gsldlc1 %[uv],        0x7(%[src_ptr])              \n\t"
+        "daddu   $t0,          %[src_ptr],     %[stride]    \n\t"
+        "gsldrc1 %[uv_stride], 0x0($t0)                     \n\t"
+        "gsldlc1 %[uv_stride], 0x7($t0)                     \n\t"
+
+        "pavgb   %[uv],        %[uv],          %[uv_stride] \n\t"
+        "gssdrc1 %[uv],        0x0(%[dst_ptr])              \n\t"
+        "gssdlc1 %[uv],        0x7(%[dst_ptr])              \n\t"
+
+        "daddiu  %[src_ptr],   %[src_ptr],     8            \n\t"
+        "daddiu  %[dst_ptr],   %[dst_ptr],     8            \n\t"
+        "daddiu  %[width],     %[width],      -8            \n\t"
+        "bgtz    %[width],     1b                           \n\t"
+        "nop                                                \n\t"
+        : [uv] "=&f"(uv), [uv_stride] "=&f"(uv_stride)
+        : [src_ptr] "r"(src_ptr), [dst_ptr] "r"(dst_ptr), [width] "r"(width),
+          [stride] "r"((int64_t)src_stride)
+        : "memory");
+    return;
+  }
+  const uint8_t* src_ptr1 = src_ptr + src_stride;
+  uint64_t temp;
+  uint64_t data[4];
+  uint64_t zero = 0x0;
+  uint64_t c0 = 0x0080008000800080;
+  uint64_t fy0 = 0x0100010001000100;
+  uint64_t shift = 0x8;
+  __asm__ volatile(
+      "pshufh    %[fy1],      %[fy1],          %[zero]  \n\t"
+      "psubh     %[fy0],      %[fy0],          %[fy1]   \n\t"
+      "1:	                                        \n\t"
+      "gsldrc1   %[t0],       0x0(%[src_ptr])           \n\t"
+      "gsldlc1   %[t0],       0x7(%[src_ptr])           \n\t"
+      "punpcklbh %[d0],       %[t0],           %[zero]  \n\t"
+      "punpckhbh %[d1],       %[t0],           %[zero]  \n\t"
+      "gsldrc1   %[t0],       0x0(%[src_ptr1])          \n\t"
+      "gsldlc1   %[t0],       0x7(%[src_ptr1])          \n\t"
+      "punpcklbh %[d2],       %[t0],           %[zero]  \n\t"
+      "punpckhbh %[d3],       %[t0],           %[zero]  \n\t"
+
+      "pmullh    %[d0],       %[d0],           %[fy0]   \n\t"
+      "pmullh    %[d2],       %[d2],           %[fy1]   \n\t"
+      "paddh     %[d0],       %[d0],           %[d2]    \n\t"
+      "paddh     %[d0],       %[d0],           %[c0]    \n\t"
+      "psrlh     %[d0],       %[d0],           %[shift] \n\t"
+
+      "pmullh    %[d1],       %[d1],           %[fy0]   \n\t"
+      "pmullh    %[d3],       %[d3],           %[fy1]   \n\t"
+      "paddh     %[d1],       %[d1],           %[d3]    \n\t"
+      "paddh     %[d1],       %[d1],           %[c0]    \n\t"
+      "psrlh     %[d1],       %[d1],           %[shift] \n\t"
+
+      "packushb  %[d0],       %[d0],           %[d1]    \n\t"
+      "gssdrc1   %[d0],       0x0(%[dst_ptr])           \n\t"
+      "gssdlc1   %[d0],       0x7(%[dst_ptr])           \n\t"
+      "daddiu    %[src_ptr],  %[src_ptr],      8        \n\t"
+      "daddiu    %[src_ptr1], %[src_ptr1],     8        \n\t"
+      "daddiu    %[dst_ptr],  %[dst_ptr],      8        \n\t"
+      "daddiu    %[width],    %[width],       -8        \n\t"
+      "bgtz      %[width],    1b                        \n\t"
+      "nop                                              \n\t"
+      : [t0] "=&f"(temp), [d0] "=&f"(data[0]), [d1] "=&f"(data[1]),
+        [d2] "=&f"(data[2]), [d3] "=&f"(data[3])
+      : [src_ptr] "r"(src_ptr), [src_ptr1] "r"(src_ptr1),
+        [dst_ptr] "r"(dst_ptr), [width] "r"(width),
+        [fy1] "f"(source_y_fraction), [fy0] "f"(fy0), [c0] "f"(c0),
+        [shift] "f"(shift), [zero] "f"(zero)
+      : "memory");
+}
+
+// Use first 4 shuffler values to reorder ARGB channels.
+void ARGBShuffleRow_MMI(const uint8_t* src_argb,
+                        uint8_t* dst_argb,
+                        const uint8_t* shuffler,
+                        int width) {
+  uint64_t source, dest0, dest1, dest;
+  const uint64_t mask0 = 0x0;
+  const uint64_t mask1 = (shuffler[0] & 0x03) | ((shuffler[1] & 0x03) << 2) |
+                         ((shuffler[2] & 0x03) << 4) |
+                         ((shuffler[3] & 0x03) << 6);
+
+  __asm__ volatile(
+      "1:                                                           \n\t"
+      "gsldlc1    %[src],          0x07(%[src_ptr])                 \n\t"
+      "gsldrc1    %[src],          0x00(%[src_ptr])                 \n\t"
+
+      "punpcklbh  %[dest0],        %[src],            %[mask0]      \n\t"
+      "pshufh     %[dest0],        %[dest0],          %[mask1]      \n\t"
+      "punpckhbh  %[dest1],        %[src],            %[mask0]      \n\t"
+      "pshufh     %[dest1],        %[dest1],          %[mask1]      \n\t"
+      "packushb   %[dest],         %[dest0],          %[dest1]      \n\t"
+
+      "gssdlc1    %[dest],         0x07(%[dst_ptr])                 \n\t"
+      "gssdrc1    %[dest],         0x00(%[dst_ptr])                 \n\t"
+
+      "daddiu     %[src_ptr],      %[src_ptr],        0x08          \n\t"
+      "daddiu     %[dst_ptr],      %[dst_ptr],        0x08          \n\t"
+      "daddi      %[width],        %[width],         -0x02          \n\t"
+      "bnez       %[width],        1b                               \n\t"
+      : [src] "=&f"(source), [dest] "=&f"(dest), [dest0] "=&f"(dest0),
+        [dest1] "=&f"(dest1)
+      : [src_ptr] "r"(src_argb), [dst_ptr] "r"(dst_argb), [mask0] "f"(mask0),
+        [mask1] "f"(mask1), [width] "r"(width)
+      : "memory");
+}
+
+void I422ToYUY2Row_MMI(const uint8_t* src_y,
+                       const uint8_t* src_u,
+                       const uint8_t* src_v,
+                       uint8_t* dst_frame,
+                       int width) {
+  uint64_t temp[3];
+  uint64_t vu = 0x0;
+  __asm__ volatile(
+      "1:	                                        \n\t"
+      "gsldlc1   %[ty],        0x7(%[src_y])            \n\t"  // r=src_sobelx[i]
+      "gsldrc1   %[ty],        0x0(%[src_y])            \n\t"  // r=src_sobelx[i]
+      "gslwlc1   %[tu],        0x3(%[src_u])            \n\t"  // b=src_sobely[i]
+      "gslwrc1   %[tu],        0x0(%[src_u])            \n\t"  // b=src_sobely[i]
+      "gslwlc1   %[tv],        0x3(%[src_v])            \n\t"  // b=src_sobely[i]
+      "gslwrc1   %[tv],        0x0(%[src_v])            \n\t"  // b=src_sobely[i]
+      "punpcklbh %[vu],        %[tu],             %[tv]	\n\t"  // g
+      "punpcklbh %[tu],        %[ty],             %[vu]	\n\t"  // g
+      "gssdlc1   %[tu],        0x7(%[dst_frame])        \n\t"
+      "gssdrc1   %[tu],        0x0(%[dst_frame])        \n\t"
+      "punpckhbh %[tu],        %[ty],             %[vu]	\n\t"  // g
+      "gssdlc1   %[tu],        0x0F(%[dst_frame])       \n\t"
+      "gssdrc1   %[tu],        0x08(%[dst_frame])       \n\t"
+      "daddiu    %[src_y],     %[src_y],          8     \n\t"
+      "daddiu    %[src_u],     %[src_u],          4     \n\t"
+      "daddiu    %[src_v],     %[src_v],          4     \n\t"
+      "daddiu    %[dst_frame], %[dst_frame],      16    \n\t"
+      "daddiu    %[width],     %[width],         -8     \n\t"
+      "bgtz      %[width],     1b                       \n\t"
+      "nop                                              \n\t"
+      : [ty] "=&f"(temp[1]), [tu] "=&f"(temp[1]), [tv] "=&f"(temp[1]),
+        [vu] "=&f"(vu)
+      : [src_y] "r"(src_y), [src_u] "r"(src_u), [src_v] "r"(src_v),
+        [dst_frame] "r"(dst_frame), [width] "r"(width)
+      : "memory");
+}
+
+void I422ToUYVYRow_MMI(const uint8_t* src_y,
+                       const uint8_t* src_u,
+                       const uint8_t* src_v,
+                       uint8_t* dst_frame,
+                       int width) {
+  uint64_t temp[3];
+  uint64_t vu = 0x0;
+  __asm__ volatile(
+      "1:	                                        \n\t"
+      "gsldlc1   %[ty],        0x7(%[src_y])            \n\t"  // r=src_sobelx[i]
+      "gsldrc1   %[ty],        0x0(%[src_y])            \n\t"  // r=src_sobelx[i]
+      "gslwlc1   %[tu],        0x3(%[src_u])            \n\t"  // b=src_sobely[i]
+      "gslwrc1   %[tu],        0x0(%[src_u])            \n\t"  // b=src_sobely[i]
+      "gslwlc1   %[tv],        0x3(%[src_v])            \n\t"  // b=src_sobely[i]
+      "gslwrc1   %[tv],        0x0(%[src_v])            \n\t"  // b=src_sobely[i]
+      "punpcklbh %[vu],        %[tu],             %[tv]	\n\t"  // g
+      "punpcklbh %[tu],        %[vu],             %[ty]	\n\t"  // g
+      "gssdlc1   %[tu],        0x7(%[dst_frame])        \n\t"
+      "gssdrc1   %[tu],        0x0(%[dst_frame])        \n\t"
+      "punpckhbh %[tu],        %[vu],             %[ty]	\n\t"  // g
+      "gssdlc1   %[tu],        0x0F(%[dst_frame])       \n\t"
+      "gssdrc1   %[tu],        0x08(%[dst_frame])       \n\t"
+      "daddiu    %[src_y],     %[src_y],          8     \n\t"
+      "daddiu    %[src_u],     %[src_u],          4     \n\t"
+      "daddiu    %[src_v],     %[src_v],          4     \n\t"
+      "daddiu    %[dst_frame], %[dst_frame],      16    \n\t"
+      "daddiu    %[width],     %[width],         -8     \n\t"
+      "bgtz      %[width],     1b                       \n\t"
+      "nop                                              \n\t"
+      : [ty] "=&f"(temp[1]), [tu] "=&f"(temp[1]), [tv] "=&f"(temp[1]),
+        [vu] "=&f"(vu)
+      : [src_y] "r"(src_y), [src_u] "r"(src_u), [src_v] "r"(src_v),
+        [dst_frame] "r"(dst_frame), [width] "r"(width)
+      : "memory");
+}
+
+void ARGBCopyAlphaRow_MMI(const uint8_t* src, uint8_t* dst, int width) {
+  uint64_t source, dest;
+  const uint64_t mask0 = 0xff000000ff000000ULL;
+  const uint64_t mask1 = ~mask0;
+
+  __asm__ volatile(
+      "1:                                                           \n\t"
+      "gsldlc1    %[src],          0x07(%[src_ptr])                 \n\t"
+      "gsldrc1    %[src],          0x00(%[src_ptr])                 \n\t"
+      "gsldlc1    %[dest],         0x07(%[dst_ptr])                 \n\t"
+      "gsldrc1    %[dest],         0x00(%[dst_ptr])                 \n\t"
+
+      "and        %[src],          %[src],            %[mask0]      \n\t"
+      "and        %[dest],         %[dest],           %[mask1]      \n\t"
+      "or         %[dest],         %[src],            %[dest]       \n\t"
+      "gssdlc1    %[dest],         0x07(%[dst_ptr])                 \n\t"
+      "gssdrc1    %[dest],         0x00(%[dst_ptr])                 \n\t"
+
+      "daddiu     %[src_ptr],      %[src_ptr],        0x08          \n\t"
+      "daddiu     %[dst_ptr],      %[dst_ptr],        0x08          \n\t"
+      "daddi      %[width],        %[width],         -0x02          \n\t"
+      "bnez       %[width],        1b                               \n\t"
+      : [src] "=&f"(source), [dest] "=&f"(dest)
+      : [src_ptr] "r"(src), [dst_ptr] "r"(dst), [mask0] "f"(mask0),
+        [mask1] "f"(mask1), [width] "r"(width)
+      : "memory");
+}
+
+void ARGBExtractAlphaRow_MMI(const uint8_t* src_argb,
+                             uint8_t* dst_a,
+                             int width) {
+  uint64_t src, dest0, dest1, dest_lo, dest_hi, dest;
+  const uint64_t mask = 0xff000000ff000000ULL;
+  const uint64_t shift = 0x18;
+
+  __asm__ volatile(
+      "1:                                                           \n\t"
+      "gsldlc1    %[src],          0x07(%[src_ptr])                 \n\t"
+      "gsldrc1    %[src],          0x00(%[src_ptr])                 \n\t"
+      "and        %[dest0],        %[src],            %[mask]       \n\t"
+      "psrlw      %[dest0],        %[dest0],          %[shift]      \n\t"
+      "gsldlc1    %[src],          0x0f(%[src_ptr])                 \n\t"
+      "gsldrc1    %[src],          0x08(%[src_ptr])                 \n\t"
+      "and        %[dest1],        %[src],            %[mask]       \n\t"
+      "psrlw      %[dest1],        %[dest1],          %[shift]      \n\t"
+      "packsswh   %[dest_lo],      %[dest0],          %[dest1]      \n\t"
+
+      "gsldlc1    %[src],          0x17(%[src_ptr])                 \n\t"
+      "gsldrc1    %[src],          0x10(%[src_ptr])                 \n\t"
+      "and        %[dest0],        %[src],            %[mask]       \n\t"
+      "psrlw      %[dest0],        %[dest0],          %[shift]      \n\t"
+      "gsldlc1    %[src],          0x1f(%[src_ptr])                 \n\t"
+      "gsldrc1    %[src],          0x18(%[src_ptr])                 \n\t"
+      "and        %[dest1],        %[src],            %[mask]       \n\t"
+      "psrlw      %[dest1],        %[dest1],          %[shift]      \n\t"
+      "packsswh   %[dest_hi],      %[dest0],          %[dest1]      \n\t"
+
+      "packushb   %[dest],         %[dest_lo],        %[dest_hi]    \n\t"
+
+      "gssdlc1    %[dest],         0x07(%[dst_ptr])                 \n\t"
+      "gssdrc1    %[dest],         0x00(%[dst_ptr])                 \n\t"
+
+      "daddiu     %[src_ptr],      %[src_ptr],        0x20          \n\t"
+      "daddiu     %[dst_ptr],      %[dst_ptr],        0x08          \n\t"
+      "daddi      %[width],        %[width],         -0x08          \n\t"
+      "bnez       %[width],        1b                               \n\t"
+      : [src] "=&f"(src), [dest] "=&f"(dest), [dest0] "=&f"(dest0),
+        [dest1] "=&f"(dest1), [dest_lo] "=&f"(dest_lo), [dest_hi] "=&f"(dest_hi)
+      : [src_ptr] "r"(src_argb), [dst_ptr] "r"(dst_a), [mask] "f"(mask),
+        [shift] "f"(shift), [width] "r"(width)
+      : "memory");
+}
+
+void ARGBCopyYToAlphaRow_MMI(const uint8_t* src, uint8_t* dst, int width) {
+  uint64_t source, dest0, dest1, dest;
+  const uint64_t mask0 = 0x0;
+  const uint64_t mask1 = 0x00ffffff00ffffffULL;
+
+  __asm__ volatile(
+      "1:                                                           \n\t"
+      "gsldlc1    %[src],          0x07(%[src_ptr])                 \n\t"
+      "gsldrc1    %[src],          0x00(%[src_ptr])                 \n\t"
+
+      "punpcklbh  %[dest0],        %[mask0],          %[src]        \n\t"
+      "punpcklhw  %[dest1],        %[mask0],          %[dest0]      \n\t"
+      "gsldlc1    %[dest],         0x07(%[dst_ptr])                 \n\t"
+      "gsldrc1    %[dest],         0x00(%[dst_ptr])                 \n\t"
+      "and        %[dest],         %[dest],           %[mask1]      \n\t"
+      "or         %[dest],         %[dest],           %[dest1]      \n\t"
+      "gssdlc1    %[dest],         0x07(%[dst_ptr])                 \n\t"
+      "gssdrc1    %[dest],         0x00(%[dst_ptr])                 \n\t"
+      "punpckhhw  %[dest1],        %[mask0],          %[dest0]      \n\t"
+      "gsldlc1    %[dest],         0x0f(%[dst_ptr])                 \n\t"
+      "gsldrc1    %[dest],         0x08(%[dst_ptr])                 \n\t"
+      "and        %[dest],         %[dest],           %[mask1]      \n\t"
+      "or         %[dest],         %[dest],           %[dest1]      \n\t"
+      "gssdlc1    %[dest],         0x0f(%[dst_ptr])                 \n\t"
+      "gssdrc1    %[dest],         0x08(%[dst_ptr])                 \n\t"
+
+      "punpckhbh  %[dest0],        %[mask0],          %[src]        \n\t"
+      "punpcklhw  %[dest1],        %[mask0],          %[dest0]      \n\t"
+      "gsldlc1    %[dest],         0x17(%[dst_ptr])                 \n\t"
+      "gsldrc1    %[dest],         0x10(%[dst_ptr])                 \n\t"
+      "and        %[dest],         %[dest],           %[mask1]      \n\t"
+      "or         %[dest],         %[dest],           %[dest1]      \n\t"
+      "gssdlc1    %[dest],         0x17(%[dst_ptr])                 \n\t"
+      "gssdrc1    %[dest],         0x10(%[dst_ptr])                 \n\t"
+      "punpckhhw  %[dest1],        %[mask0],          %[dest0]      \n\t"
+      "gsldlc1    %[dest],         0x1f(%[dst_ptr])                 \n\t"
+      "gsldrc1    %[dest],         0x18(%[dst_ptr])                 \n\t"
+      "and        %[dest],         %[dest],           %[mask1]      \n\t"
+      "or         %[dest],         %[dest],           %[dest1]      \n\t"
+      "gssdlc1    %[dest],         0x1f(%[dst_ptr])                 \n\t"
+      "gssdrc1    %[dest],         0x18(%[dst_ptr])                 \n\t"
+
+      "daddiu     %[src_ptr],      %[src_ptr],        0x08          \n\t"
+      "daddiu     %[dst_ptr],      %[dst_ptr],        0x20          \n\t"
+      "daddi      %[width],        %[width],         -0x08          \n\t"
+      "bnez       %[width],        1b                               \n\t"
+      : [src] "=&f"(source), [dest] "=&f"(dest), [dest0] "=&f"(dest0),
+        [dest1] "=&f"(dest1)
+      : [src_ptr] "r"(src), [dst_ptr] "r"(dst), [mask0] "f"(mask0),
+        [mask1] "f"(mask1), [width] "r"(width)
+      : "memory");
+}
+
+void I444ToARGBRow_MMI(const uint8_t* src_y,
+                       const uint8_t* src_u,
+                       const uint8_t* src_v,
+                       uint8_t* rgb_buf,
+                       const struct YuvConstants* yuvconstants,
+                       int width) {
+  uint64_t y,u,v;
+  uint64_t b_vec[2],g_vec[2],r_vec[2];
+  uint64_t mask = 0xff00ff00ff00ff00ULL;
+  uint64_t ub,ug,vg,vr,bb,bg,br,yg;
+  __asm__ volatile (
+    "ldc1       %[yg],           0xc0(%[yuvcons_ptr])             \n\t"//yg
+    "ldc1       %[bb],           0x60(%[yuvcons_ptr])             \n\t"//bb
+    "ldc1       %[ub],           0x00(%[yuvcons_ptr])             \n\t"//ub
+    "or         %[ub],           %[ub],             %[mask]       \n\t"//must sign extension
+    "ldc1       %[bg],           0x80(%[yuvcons_ptr])             \n\t"//bg
+    "ldc1       %[ug],           0x20(%[yuvcons_ptr])             \n\t"//ug
+    "punpcklbh  %[ug],           %[ug],             %[zero]       \n\t"
+    "pshufh     %[ug],           %[ug],             %[zero]       \n\t"
+    "ldc1       %[vg],           0x20(%[yuvcons_ptr])             \n\t"//vg
+    "punpcklbh  %[vg],           %[vg],             %[zero]       \n\t"
+    "pshufh     %[vg],           %[vg],             %[five]       \n\t"
+    "ldc1       %[br],           0xa0(%[yuvcons_ptr])             \n\t"//br
+    "ldc1       %[vr],           0x40(%[yuvcons_ptr])             \n\t"//vr
+    "punpcklbh  %[vr],           %[vr],             %[zero]       \n\t"
+    "pshufh     %[vr],           %[vr],             %[five]       \n\t"
+    "or         %[vr],           %[vr],             %[mask]       \n\t"//sign extension
+
+    "1:                                                           \n\t"
+    "gslwlc1    %[y],            0x03(%[y_ptr])                   \n\t"
+    "gslwrc1    %[y],            0x00(%[y_ptr])                   \n\t"
+    "gslwlc1    %[u],            0x03(%[u_ptr])                   \n\t"
+    "gslwrc1    %[u],            0x00(%[u_ptr])                   \n\t"
+    "gslwlc1    %[v],            0x03(%[v_ptr])                   \n\t"
+    "gslwrc1    %[v],            0x00(%[v_ptr])                   \n\t"
+
+    "punpcklbh  %[y],            %[y],              %[y]          \n\t"//y*0x0101
+    "pmulhuh    %[y],            %[y],              %[yg]         \n\t"//y1
+
+    "punpcklbh  %[u],            %[u],              %[zero]       \n\t"//u
+    "paddsh     %[b_vec0],       %[y],              %[bb]         \n\t"
+    "pmullh     %[b_vec1],       %[u],              %[ub]         \n\t"
+    "psubsh     %[b_vec0],       %[b_vec0],         %[b_vec1]     \n\t"
+    "psrah      %[b_vec0],       %[b_vec0],         %[six]        \n\t"
+
+    "punpcklbh  %[v],            %[v],              %[zero]       \n\t"//v
+    "paddsh     %[g_vec0],       %[y],              %[bg]         \n\t"
+    "pmullh     %[g_vec1],       %[u],              %[ug]         \n\t"//u*ug
+    "psubsh     %[g_vec0],       %[g_vec0],         %[g_vec1]     \n\t"
+    "pmullh     %[g_vec1],       %[v],              %[vg]         \n\t"//v*vg
+    "psubsh     %[g_vec0],       %[g_vec0],         %[g_vec1]     \n\t"
+    "psrah      %[g_vec0],       %[g_vec0],         %[six]        \n\t"
+
+    "paddsh     %[r_vec0],       %[y],              %[br]         \n\t"
+    "pmullh     %[r_vec1],       %[v],              %[vr]         \n\t"//v*vr
+    "psubsh     %[r_vec0],       %[r_vec0],         %[r_vec1]     \n\t"
+    "psrah      %[r_vec0],       %[r_vec0],         %[six]        \n\t"
+
+    "packushb   %[r_vec0],       %[b_vec0],         %[r_vec0]     \n\t"//rrrrbbbb
+    "packushb   %[g_vec0],       %[g_vec0],         %[alpha]      \n\t"//ffffgggg
+    "punpcklwd  %[g_vec0],       %[g_vec0],         %[alpha]      \n\t"
+    "punpcklbh  %[b_vec0],       %[r_vec0],         %[g_vec0]     \n\t"//gbgbgbgb
+    "punpckhbh  %[r_vec0],       %[r_vec0],         %[g_vec0]     \n\t"//frfrfrfr
+    "punpcklhw  %[g_vec0],       %[b_vec0],         %[r_vec0]     \n\t"//frgbfrgb
+    "punpckhhw  %[g_vec1],       %[b_vec0],         %[r_vec0]     \n\t"//frgbfrgb
+    "gssdlc1    %[g_vec0],       0x07(%[rgbbuf_ptr])              \n\t"
+    "gssdrc1    %[g_vec0],       0x00(%[rgbbuf_ptr])              \n\t"
+    "gssdlc1    %[g_vec1],       0x0f(%[rgbbuf_ptr])              \n\t"
+    "gssdrc1    %[g_vec1],       0x08(%[rgbbuf_ptr])              \n\t"
+
+    "daddiu     %[y_ptr],        %[y_ptr],          0x04          \n\t"
+    "daddiu     %[u_ptr],        %[u_ptr],          0x04          \n\t"
+    "daddiu     %[v_ptr],        %[v_ptr],          0x04          \n\t"
+    "daddiu     %[rgbbuf_ptr],   %[rgbbuf_ptr],     0x10          \n\t"
+    "daddi      %[width],        %[width],          -0x04         \n\t"
+    "bnez       %[width],        1b                               \n\t"
+    : [y]"=&f"(y),
+      [u]"=&f"(u),                         [v]"=&f"(v),
+      [b_vec0]"=&f"(b_vec[0]),             [b_vec1]"=&f"(b_vec[1]),
+      [g_vec0]"=&f"(g_vec[0]),             [g_vec1]"=&f"(g_vec[1]),
+      [r_vec0]"=&f"(r_vec[0]),             [r_vec1]"=&f"(r_vec[1]),
+      [ub]"=&f"(ub),                       [ug]"=&f"(ug),
+      [vg]"=&f"(vg),                       [vr]"=&f"(vr),
+      [bb]"=&f"(bb),                       [bg]"=&f"(bg),
+      [br]"=&f"(br),                       [yg]"=&f"(yg)
+    : [y_ptr]"r"(src_y),                   [u_ptr]"r"(src_u),
+      [v_ptr]"r"(src_v),                   [rgbbuf_ptr]"r"(rgb_buf),
+      [yuvcons_ptr]"r"(yuvconstants),      [width]"r"(width),
+      [zero]"f"(0x00),                     [alpha]"f"(-1),
+      [six]"f"(0x6),                       [five]"f"(0x55),
+      [mask]"f"(mask)
+    : "memory"
+  );
+}
+
+// Also used for 420
+void I422ToARGBRow_MMI(const uint8_t* src_y,
+                       const uint8_t* src_u,
+                       const uint8_t* src_v,
+                       uint8_t* rgb_buf,
+                       const struct YuvConstants* yuvconstants,
+                       int width) {
+  uint64_t y,u,v;
+  uint64_t b_vec[2],g_vec[2],r_vec[2];
+  uint64_t mask = 0xff00ff00ff00ff00ULL;
+  uint64_t ub,ug,vg,vr,bb,bg,br,yg;
+
+  __asm__ volatile(
+    "ldc1       %[yg],           0xc0(%[yuvcons_ptr])             \n\t"//yg
+    "ldc1       %[bb],           0x60(%[yuvcons_ptr])             \n\t"//bb
+    "ldc1       %[ub],           0x00(%[yuvcons_ptr])             \n\t"//ub
+    "or         %[ub],           %[ub],             %[mask]       \n\t"//must sign extension
+    "ldc1       %[bg],           0x80(%[yuvcons_ptr])             \n\t"//bg
+    "ldc1       %[ug],           0x20(%[yuvcons_ptr])             \n\t"//ug
+    "punpcklbh  %[ug],           %[ug],             %[zero]       \n\t"
+    "pshufh     %[ug],           %[ug],             %[zero]       \n\t"
+    "ldc1       %[vg],           0x20(%[yuvcons_ptr])             \n\t"//vg
+    "punpcklbh  %[vg],           %[vg],             %[zero]       \n\t"
+    "pshufh     %[vg],           %[vg],             %[five]       \n\t"
+    "ldc1       %[br],           0xa0(%[yuvcons_ptr])             \n\t"//br
+    "ldc1       %[vr],           0x40(%[yuvcons_ptr])             \n\t"//vr
+    "punpcklbh  %[vr],           %[vr],             %[zero]       \n\t"
+    "pshufh     %[vr],           %[vr],             %[five]       \n\t"
+    "or         %[vr],           %[vr],             %[mask]       \n\t"//sign extension
+
+    "1:                                                           \n\t"
+    "gslwlc1    %[y],            0x03(%[y_ptr])                   \n\t"
+    "gslwrc1    %[y],            0x00(%[y_ptr])                   \n\t"
+    "gslwlc1    %[u],            0x03(%[u_ptr])                   \n\t"
+    "gslwrc1    %[u],            0x00(%[u_ptr])                   \n\t"
+    "gslwlc1    %[v],            0x03(%[v_ptr])                   \n\t"
+    "gslwrc1    %[v],            0x00(%[v_ptr])                   \n\t"
+
+    "punpcklbh  %[y],            %[y],              %[y]          \n\t"//y*0x0101
+    "pmulhuh    %[y],            %[y],              %[yg]         \n\t"//y1
+
+    //u3|u2|u1|u0 --> u1|u1|u0|u0
+    "punpcklbh  %[u],            %[u],              %[u]          \n\t"//u
+    "punpcklbh  %[u],            %[u],              %[zero]       \n\t"
+    "paddsh     %[b_vec0],       %[y],              %[bb]         \n\t"
+    "pmullh     %[b_vec1],       %[u],              %[ub]         \n\t"
+    "psubsh     %[b_vec0],       %[b_vec0],         %[b_vec1]     \n\t"
+    "psrah      %[b_vec0],       %[b_vec0],         %[six]        \n\t"
+
+    //v3|v2|v1|v0 --> v1|v1|v0|v0
+    "punpcklbh  %[v],            %[v],              %[v]          \n\t"//v
+    "punpcklbh  %[v],            %[v],              %[zero]       \n\t"
+    "paddsh     %[g_vec0],       %[y],              %[bg]         \n\t"
+    "pmullh     %[g_vec1],       %[u],              %[ug]         \n\t"//u*ug
+    "psubsh     %[g_vec0],       %[g_vec0],         %[g_vec1]     \n\t"
+    "pmullh     %[g_vec1],       %[v],              %[vg]         \n\t"//v*vg
+    "psubsh     %[g_vec0],       %[g_vec0],         %[g_vec1]     \n\t"
+    "psrah      %[g_vec0],       %[g_vec0],         %[six]        \n\t"
+
+    "paddsh     %[r_vec0],       %[y],              %[br]         \n\t"
+    "pmullh     %[r_vec1],       %[v],              %[vr]         \n\t"//v*vr
+    "psubsh     %[r_vec0],       %[r_vec0],         %[r_vec1]     \n\t"
+    "psrah      %[r_vec0],       %[r_vec0],         %[six]        \n\t"
+
+    "packushb   %[r_vec0],       %[b_vec0],         %[r_vec0]     \n\t"//rrrrbbbb
+    "packushb   %[g_vec0],       %[g_vec0],         %[alpha]      \n\t"//ffffgggg
+    "punpcklwd  %[g_vec0],       %[g_vec0],         %[alpha]      \n\t"
+    "punpcklbh  %[b_vec0],       %[r_vec0],         %[g_vec0]     \n\t"//gbgbgbgb
+    "punpckhbh  %[r_vec0],       %[r_vec0],         %[g_vec0]     \n\t"//frfrfrfr
+    "punpcklhw  %[g_vec0],       %[b_vec0],         %[r_vec0]     \n\t"//frgbfrgb
+    "punpckhhw  %[g_vec1],       %[b_vec0],         %[r_vec0]     \n\t"//frgbfrgb
+    "gssdlc1    %[g_vec0],       0x07(%[rgbbuf_ptr])              \n\t"
+    "gssdrc1    %[g_vec0],       0x00(%[rgbbuf_ptr])              \n\t"
+    "gssdlc1    %[g_vec1],       0x0f(%[rgbbuf_ptr])              \n\t"
+    "gssdrc1    %[g_vec1],       0x08(%[rgbbuf_ptr])              \n\t"
+
+    "daddiu     %[y_ptr],        %[y_ptr],          0x04          \n\t"
+    "daddiu     %[u_ptr],        %[u_ptr],          0x02          \n\t"
+    "daddiu     %[v_ptr],        %[v_ptr],          0x02          \n\t"
+    "daddiu     %[rgbbuf_ptr],   %[rgbbuf_ptr],     0x10          \n\t"
+    "daddi      %[width],        %[width],          -0x04         \n\t"
+    "bnez       %[width],        1b                               \n\t"
+
+    : [y]"=&f"(y),
+      [u]"=&f"(u),                         [v]"=&f"(v),
+      [b_vec0]"=&f"(b_vec[0]),             [b_vec1]"=&f"(b_vec[1]),
+      [g_vec0]"=&f"(g_vec[0]),             [g_vec1]"=&f"(g_vec[1]),
+      [r_vec0]"=&f"(r_vec[0]),             [r_vec1]"=&f"(r_vec[1]),
+      [ub]"=&f"(ub),                       [ug]"=&f"(ug),
+      [vg]"=&f"(vg),                       [vr]"=&f"(vr),
+      [bb]"=&f"(bb),                       [bg]"=&f"(bg),
+      [br]"=&f"(br),                       [yg]"=&f"(yg)
+    : [y_ptr]"r"(src_y),                   [u_ptr]"r"(src_u),
+      [v_ptr]"r"(src_v),                   [rgbbuf_ptr]"r"(rgb_buf),
+      [yuvcons_ptr]"r"(yuvconstants),      [width]"r"(width),
+      [zero]"f"(0x00),                     [alpha]"f"(-1),
+      [six]"f"(0x6),                       [five]"f"(0x55),
+      [mask]"f"(mask)
+    : "memory"
+  );
+}
+
+// 10 bit YUV to ARGB
+void I210ToARGBRow_MMI(const uint16_t* src_y,
+                       const uint16_t* src_u,
+                       const uint16_t* src_v,
+                       uint8_t* rgb_buf,
+                       const struct YuvConstants* yuvconstants,
+                       int width) {
+  uint64_t y,u,v;
+  uint64_t b_vec[2],g_vec[2],r_vec[2];
+  uint64_t mask = 0xff00ff00ff00ff00ULL;
+  uint64_t ub,ug,vg,vr,bb,bg,br,yg;
+
+  __asm__ volatile(
+    "ldc1       %[yg],           0xc0(%[yuvcons_ptr])             \n\t"
+    "ldc1       %[bb],           0x60(%[yuvcons_ptr])             \n\t"
+    "ldc1       %[ub],           0x00(%[yuvcons_ptr])             \n\t"
+    "or         %[ub],           %[ub],             %[mask]       \n\t"
+    "ldc1       %[bg],           0x80(%[yuvcons_ptr])             \n\t"
+    "ldc1       %[ug],           0x20(%[yuvcons_ptr])             \n\t"
+    "punpcklbh  %[ug],           %[ug],             %[zero]       \n\t"
+    "pshufh     %[ug],           %[ug],             %[zero]       \n\t"
+    "ldc1       %[vg],           0x20(%[yuvcons_ptr])             \n\t"
+    "punpcklbh  %[vg],           %[vg],             %[zero]       \n\t"
+    "pshufh     %[vg],           %[vg],             %[five]       \n\t"
+    "ldc1       %[br],           0xa0(%[yuvcons_ptr])             \n\t"
+    "ldc1       %[vr],           0x40(%[yuvcons_ptr])             \n\t"
+    "punpcklbh  %[vr],           %[vr],             %[zero]       \n\t"
+    "pshufh     %[vr],           %[vr],             %[five]       \n\t"
+    "or         %[vr],           %[vr],             %[mask]       \n\t"
+
+    "1:                                                           \n\t"
+    "gsldlc1    %[y],            0x07(%[y_ptr])                   \n\t"
+    "gsldrc1    %[y],            0x00(%[y_ptr])                   \n\t"
+    "gslwlc1    %[u],            0x03(%[u_ptr])                   \n\t"
+    "gslwrc1    %[u],            0x00(%[u_ptr])                   \n\t"
+    "gslwlc1    %[v],            0x03(%[v_ptr])                   \n\t"
+    "gslwrc1    %[v],            0x00(%[v_ptr])                   \n\t"
+
+    "psllh      %[y],            %[y],              %[six]        \n\t"
+    "pmulhuh    %[y],            %[y],              %[yg]         \n\t"
+
+    "punpcklhw  %[u],            %[u],              %[u]          \n\t"
+    "psrah      %[u],            %[u],              %[two]        \n\t"
+    "punpcklhw  %[v],            %[v],              %[v]          \n\t"
+    "psrah      %[v],            %[v],              %[two]        \n\t"
+    "pminsh     %[u],            %[u],              %[mask1]      \n\t"
+    "pminsh     %[v],            %[v],              %[mask1]      \n\t"
+
+    "paddsh     %[b_vec0],       %[y],              %[bb]         \n\t"
+    "pmullh     %[b_vec1],       %[u],              %[ub]         \n\t"
+    "psubsh     %[b_vec0],       %[b_vec0],         %[b_vec1]     \n\t"
+
+    "paddsh     %[g_vec0],       %[y],              %[bg]         \n\t"
+    "pmullh     %[g_vec1],       %[u],              %[ug]         \n\t"
+    "psubsh     %[g_vec0],       %[g_vec0],         %[g_vec1]     \n\t"
+    "pmullh     %[g_vec1],       %[v],              %[vg]         \n\t"
+    "psubsh     %[g_vec0],       %[g_vec0],         %[g_vec1]     \n\t"
+
+    "paddsh     %[r_vec0],       %[y],              %[br]         \n\t"
+    "pmullh     %[r_vec1],       %[v],              %[vr]         \n\t"
+    "psubsh     %[r_vec0],       %[r_vec0],         %[r_vec1]     \n\t"
+
+    "psrah      %[b_vec0],       %[b_vec0],         %[six]        \n\t"
+    "psrah      %[g_vec0],       %[g_vec0],         %[six]        \n\t"
+    "psrah      %[r_vec0],       %[r_vec0],         %[six]        \n\t"
+
+    "packushb   %[r_vec0],       %[b_vec0],         %[r_vec0]     \n\t"
+    "packushb   %[g_vec0],       %[g_vec0],         %[alpha]      \n\t"
+    "punpcklwd  %[g_vec0],       %[g_vec0],         %[alpha]      \n\t"
+    "punpcklbh  %[b_vec0],       %[r_vec0],         %[g_vec0]     \n\t"
+    "punpckhbh  %[r_vec0],       %[r_vec0],         %[g_vec0]     \n\t"
+    "punpcklhw  %[g_vec0],       %[b_vec0],         %[r_vec0]     \n\t"
+    "punpckhhw  %[g_vec1],       %[b_vec0],         %[r_vec0]     \n\t"
+    "gssdlc1    %[g_vec0],       0x07(%[rgbbuf_ptr])              \n\t"
+    "gssdrc1    %[g_vec0],       0x00(%[rgbbuf_ptr])              \n\t"
+    "gssdlc1    %[g_vec1],       0x0f(%[rgbbuf_ptr])              \n\t"
+    "gssdrc1    %[g_vec1],       0x08(%[rgbbuf_ptr])              \n\t"
+
+    "daddiu     %[y_ptr],        %[y_ptr],          0x08          \n\t"
+    "daddiu     %[u_ptr],        %[u_ptr],          0x04          \n\t"
+    "daddiu     %[v_ptr],        %[v_ptr],          0x04          \n\t"
+    "daddiu     %[rgbbuf_ptr],   %[rgbbuf_ptr],     0x10          \n\t"
+    "daddi      %[width],        %[width],          -0x04         \n\t"
+    "bnez       %[width],        1b                               \n\t"
+
+    : [y]"=&f"(y),
+      [u]"=&f"(u),                         [v]"=&f"(v),
+      [b_vec0]"=&f"(b_vec[0]),             [b_vec1]"=&f"(b_vec[1]),
+      [g_vec0]"=&f"(g_vec[0]),             [g_vec1]"=&f"(g_vec[1]),
+      [r_vec0]"=&f"(r_vec[0]),             [r_vec1]"=&f"(r_vec[1]),
+      [ub]"=&f"(ub),                       [ug]"=&f"(ug),
+      [vg]"=&f"(vg),                       [vr]"=&f"(vr),
+      [bb]"=&f"(bb),                       [bg]"=&f"(bg),
+      [br]"=&f"(br),                       [yg]"=&f"(yg)
+    : [y_ptr]"r"(src_y),                   [u_ptr]"r"(src_u),
+      [v_ptr]"r"(src_v),                   [rgbbuf_ptr]"r"(rgb_buf),
+      [yuvcons_ptr]"r"(yuvconstants),      [width]"r"(width),
+      [zero]"f"(0x00),                     [alpha]"f"(-1),
+      [six]"f"(0x6),                       [five]"f"(0x55),
+      [mask]"f"(mask),                     [two]"f"(0x02),
+      [mask1]"f"(0x00ff00ff00ff00ff)
+    : "memory"
+  );
+}
+
+void I422AlphaToARGBRow_MMI(const uint8_t* src_y,
+                            const uint8_t* src_u,
+                            const uint8_t* src_v,
+                            const uint8_t* src_a,
+                            uint8_t* rgb_buf,
+                            const struct YuvConstants* yuvconstants,
+                            int width) {
+  uint64_t y,u,v,a;
+  uint64_t b_vec[2],g_vec[2],r_vec[2];
+  uint64_t mask = 0xff00ff00ff00ff00ULL;
+  uint64_t ub,ug,vg,vr,bb,bg,br,yg;
+
+  __asm__ volatile(
+    "ldc1       %[yg],           0xc0(%[yuvcons_ptr])             \n\t"
+    "ldc1       %[bb],           0x60(%[yuvcons_ptr])             \n\t"
+    "ldc1       %[ub],           0x00(%[yuvcons_ptr])             \n\t"
+    "or         %[ub],           %[ub],             %[mask]       \n\t"
+    "ldc1       %[bg],           0x80(%[yuvcons_ptr])             \n\t"
+    "ldc1       %[ug],           0x20(%[yuvcons_ptr])             \n\t"
+    "punpcklbh  %[ug],           %[ug],             %[zero]       \n\t"
+    "pshufh     %[ug],           %[ug],             %[zero]       \n\t"
+    "ldc1       %[vg],           0x20(%[yuvcons_ptr])             \n\t"
+    "punpcklbh  %[vg],           %[vg],             %[zero]       \n\t"
+    "pshufh     %[vg],           %[vg],             %[five]       \n\t"
+    "ldc1       %[br],           0xa0(%[yuvcons_ptr])             \n\t"
+    "ldc1       %[vr],           0x40(%[yuvcons_ptr])             \n\t"
+    "punpcklbh  %[vr],           %[vr],             %[zero]       \n\t"
+    "pshufh     %[vr],           %[vr],             %[five]       \n\t"
+    "or         %[vr],           %[vr],             %[mask]       \n\t"
+
+    "1:                                                           \n\t"
+    "gslwlc1    %[y],            0x03(%[y_ptr])                   \n\t"
+    "gslwrc1    %[y],            0x00(%[y_ptr])                   \n\t"
+    "gslwlc1    %[u],            0x03(%[u_ptr])                   \n\t"
+    "gslwrc1    %[u],            0x00(%[u_ptr])                   \n\t"
+    "gslwlc1    %[v],            0x03(%[v_ptr])                   \n\t"
+    "gslwrc1    %[v],            0x00(%[v_ptr])                   \n\t"
+    "gslwlc1    %[a],            0x03(%[a_ptr])                   \n\t"
+    "gslwrc1    %[a],            0x00(%[a_ptr])                   \n\t"
+
+    "punpcklbh  %[y],            %[y],              %[y]          \n\t"//y*0x0101
+    "pmulhuh    %[y],            %[y],              %[yg]         \n\t"//y1
+
+    //u3|u2|u1|u0 --> u1|u1|u0|u0
+    "punpcklbh  %[u],            %[u],              %[u]          \n\t"//u
+    "punpcklbh  %[u],            %[u],              %[zero]       \n\t"
+    "paddsh     %[b_vec0],       %[y],              %[bb]         \n\t"
+    "pmullh     %[b_vec1],       %[u],              %[ub]         \n\t"
+    "psubsh     %[b_vec0],       %[b_vec0],         %[b_vec1]     \n\t"
+    "psrah      %[b_vec0],       %[b_vec0],         %[six]        \n\t"
+
+    //v3|v2|v1|v0 --> v1|v1|v0|v0
+    "punpcklbh  %[v],            %[v],              %[v]          \n\t"
+    "punpcklbh  %[v],            %[v],              %[zero]       \n\t"
+    "paddsh     %[g_vec0],       %[y],              %[bg]         \n\t"
+    "pmullh     %[g_vec1],       %[u],              %[ug]         \n\t"
+    "psubsh     %[g_vec0],       %[g_vec0],         %[g_vec1]     \n\t"
+    "pmullh     %[g_vec1],       %[v],              %[vg]         \n\t"
+    "psubsh     %[g_vec0],       %[g_vec0],         %[g_vec1]     \n\t"
+    "psrah      %[g_vec0],       %[g_vec0],         %[six]        \n\t"
+
+    "paddsh     %[r_vec0],       %[y],              %[br]         \n\t"
+    "pmullh     %[r_vec1],       %[v],              %[vr]         \n\t"
+    "psubsh     %[r_vec0],       %[r_vec0],         %[r_vec1]     \n\t"
+    "psrah      %[r_vec0],       %[r_vec0],         %[six]        \n\t"
+
+    "packushb   %[r_vec0],       %[b_vec0],         %[r_vec0]     \n\t"//rrrrbbbb
+    "packushb   %[g_vec0],       %[g_vec0],         %[a]          \n\t"
+    "punpcklwd  %[g_vec0],       %[g_vec0],         %[a]          \n\t"//aaaagggg
+    "punpcklbh  %[b_vec0],       %[r_vec0],         %[g_vec0]     \n\t"
+    "punpckhbh  %[r_vec0],       %[r_vec0],         %[g_vec0]     \n\t"
+    "punpcklhw  %[g_vec0],       %[b_vec0],         %[r_vec0]     \n\t"
+    "punpckhhw  %[g_vec1],       %[b_vec0],         %[r_vec0]     \n\t"
+    "gssdlc1    %[g_vec0],       0x07(%[rgbbuf_ptr])              \n\t"
+    "gssdrc1    %[g_vec0],       0x00(%[rgbbuf_ptr])              \n\t"
+    "gssdlc1    %[g_vec1],       0x0f(%[rgbbuf_ptr])              \n\t"
+    "gssdrc1    %[g_vec1],       0x08(%[rgbbuf_ptr])              \n\t"
+
+    "daddiu     %[y_ptr],        %[y_ptr],          0x04          \n\t"
+    "daddiu     %[a_ptr],        %[a_ptr],          0x04          \n\t"
+    "daddiu     %[u_ptr],        %[u_ptr],          0x02          \n\t"
+    "daddiu     %[v_ptr],        %[v_ptr],          0x02          \n\t"
+    "daddiu     %[rgbbuf_ptr],   %[rgbbuf_ptr],     0x10          \n\t"
+    "daddi      %[width],        %[width],          -0x04         \n\t"
+    "bnez       %[width],        1b                               \n\t"
+
+    : [y]"=&f"(y),                         [u]"=&f"(u),
+      [v]"=&f"(v),                         [a]"=&f"(a),
+      [b_vec0]"=&f"(b_vec[0]),             [b_vec1]"=&f"(b_vec[1]),
+      [g_vec0]"=&f"(g_vec[0]),             [g_vec1]"=&f"(g_vec[1]),
+      [r_vec0]"=&f"(r_vec[0]),             [r_vec1]"=&f"(r_vec[1]),
+      [ub]"=&f"(ub),                       [ug]"=&f"(ug),
+      [vg]"=&f"(vg),                       [vr]"=&f"(vr),
+      [bb]"=&f"(bb),                       [bg]"=&f"(bg),
+      [br]"=&f"(br),                       [yg]"=&f"(yg)
+    : [y_ptr]"r"(src_y),                   [u_ptr]"r"(src_u),
+      [v_ptr]"r"(src_v),                   [rgbbuf_ptr]"r"(rgb_buf),
+      [yuvcons_ptr]"r"(yuvconstants),      [width]"r"(width),
+      [a_ptr]"r"(src_a),                   [zero]"f"(0x00),
+      [six]"f"(0x6),                       [five]"f"(0x55),
+      [mask]"f"(mask)
+    : "memory"
+  );
+}
+
+void I422ToRGB24Row_MMI(const uint8_t* src_y,
+                        const uint8_t* src_u,
+                        const uint8_t* src_v,
+                        uint8_t* rgb_buf,
+                        const struct YuvConstants* yuvconstants,
+                        int width) {
+  uint64_t y,u,v;
+  uint64_t b_vec[2],g_vec[2],r_vec[2];
+  uint64_t mask = 0xff00ff00ff00ff00ULL;
+  uint64_t ub,ug,vg,vr,bb,bg,br,yg;
+
+  __asm__ volatile(
+    "ldc1       %[yg],           0xc0(%[yuvcons_ptr])             \n\t"
+    "ldc1       %[bb],           0x60(%[yuvcons_ptr])             \n\t"
+    "ldc1       %[ub],           0x00(%[yuvcons_ptr])             \n\t"
+    "or         %[ub],           %[ub],             %[mask]       \n\t"
+    "ldc1       %[bg],           0x80(%[yuvcons_ptr])             \n\t"
+    "ldc1       %[ug],           0x20(%[yuvcons_ptr])             \n\t"
+    "punpcklbh  %[ug],           %[ug],             %[zero]       \n\t"
+    "pshufh     %[ug],           %[ug],             %[zero]       \n\t"
+    "ldc1       %[vg],           0x20(%[yuvcons_ptr])             \n\t"
+    "punpcklbh  %[vg],           %[vg],             %[zero]       \n\t"
+    "pshufh     %[vg],           %[vg],             %[five]       \n\t"
+    "ldc1       %[br],           0xa0(%[yuvcons_ptr])             \n\t"
+    "ldc1       %[vr],           0x40(%[yuvcons_ptr])             \n\t"
+    "punpcklbh  %[vr],           %[vr],             %[zero]       \n\t"
+    "pshufh     %[vr],           %[vr],             %[five]       \n\t"
+    "or         %[vr],           %[vr],             %[mask]       \n\t"
+
+    "1:                                                           \n\t"
+    "gslwlc1    %[y],            0x03(%[y_ptr])                   \n\t"
+    "gslwrc1    %[y],            0x00(%[y_ptr])                   \n\t"
+    "gslwlc1    %[u],            0x03(%[u_ptr])                   \n\t"
+    "gslwrc1    %[u],            0x00(%[u_ptr])                   \n\t"
+    "gslwlc1    %[v],            0x03(%[v_ptr])                   \n\t"
+    "gslwrc1    %[v],            0x00(%[v_ptr])                   \n\t"
+
+    "punpcklbh  %[y],            %[y],              %[y]          \n\t"//y*0x0101
+    "pmulhuh    %[y],            %[y],              %[yg]         \n\t"//y1
+
+    //u3|u2|u1|u0 --> u1|u1|u0|u0
+    "punpcklbh  %[u],            %[u],              %[u]          \n\t"//u
+    "punpcklbh  %[u],            %[u],              %[zero]       \n\t"
+    "paddsh     %[b_vec0],       %[y],              %[bb]         \n\t"
+    "pmullh     %[b_vec1],       %[u],              %[ub]         \n\t"
+    "psubsh     %[b_vec0],       %[b_vec0],         %[b_vec1]     \n\t"
+    "psrah      %[b_vec0],       %[b_vec0],         %[six]        \n\t"
+
+    //v3|v2|v1|v0 --> v1|v1|v0|v0
+    "punpcklbh  %[v],            %[v],              %[v]          \n\t"
+    "punpcklbh  %[v],            %[v],              %[zero]       \n\t"
+    "paddsh     %[g_vec0],       %[y],              %[bg]         \n\t"
+    "pmullh     %[g_vec1],       %[u],              %[ug]         \n\t"
+    "psubsh     %[g_vec0],       %[g_vec0],         %[g_vec1]     \n\t"
+    "pmullh     %[g_vec1],       %[v],              %[vg]         \n\t"
+    "psubsh     %[g_vec0],       %[g_vec0],         %[g_vec1]     \n\t"
+    "psrah      %[g_vec0],       %[g_vec0],         %[six]        \n\t"
+
+    "paddsh     %[r_vec0],       %[y],              %[br]         \n\t"
+    "pmullh     %[r_vec1],       %[v],              %[vr]         \n\t"
+    "psubsh     %[r_vec0],       %[r_vec0],         %[r_vec1]     \n\t"
+    "psrah      %[r_vec0],       %[r_vec0],         %[six]        \n\t"
+
+    "packushb   %[r_vec0],       %[b_vec0],         %[r_vec0]     \n\t"
+    "packushb   %[g_vec0],       %[g_vec0],         %[zero]       \n\t"
+    "punpcklbh  %[b_vec0],       %[r_vec0],         %[g_vec0]     \n\t"
+    "punpckhbh  %[r_vec0],       %[r_vec0],         %[g_vec0]     \n\t"
+    "punpcklhw  %[g_vec0],       %[b_vec0],         %[r_vec0]     \n\t"
+    "punpckhhw  %[g_vec1],       %[b_vec0],         %[r_vec0]     \n\t"
+
+    "punpckhwd  %[r_vec0],       %[g_vec0],         %[g_vec0]     \n\t"
+    "psllw      %[r_vec1],       %[r_vec0],         %[lmove1]     \n\t"
+    "or         %[g_vec0],       %[g_vec0],         %[r_vec1]     \n\t"
+    "psrlw      %[r_vec1],       %[r_vec0],         %[rmove1]     \n\t"
+    "pextrh     %[r_vec1],       %[r_vec1],         %[zero]       \n\t"
+    "pinsrh_2   %[g_vec0],       %[g_vec0],         %[r_vec1]     \n\t"
+    "pextrh     %[r_vec1],       %[g_vec1],         %[zero]       \n\t"
+    "pinsrh_3   %[g_vec0],       %[g_vec0],         %[r_vec1]     \n\t"
+    "pextrh     %[r_vec1],       %[g_vec1],         %[one]        \n\t"
+    "punpckhwd  %[g_vec1],       %[g_vec1],         %[g_vec1]     \n\t"
+    "psllw      %[g_vec1],       %[g_vec1],         %[rmove1]     \n\t"
+    "or         %[g_vec1],       %[g_vec1],         %[r_vec1]     \n\t"
+    "gssdlc1    %[g_vec0],       0x07(%[rgbbuf_ptr])              \n\t"
+    "gssdrc1    %[g_vec0],       0x00(%[rgbbuf_ptr])              \n\t"
+    "gsswlc1    %[g_vec1],       0x0b(%[rgbbuf_ptr])              \n\t"
+    "gsswrc1    %[g_vec1],       0x08(%[rgbbuf_ptr])              \n\t"
+
+
+    "daddiu     %[y_ptr],        %[y_ptr],          0x04          \n\t"
+    "daddiu     %[u_ptr],        %[u_ptr],          0x02          \n\t"
+    "daddiu     %[v_ptr],        %[v_ptr],          0x02          \n\t"
+    "daddiu     %[rgbbuf_ptr],   %[rgbbuf_ptr],     0x0c          \n\t"
+    "daddi      %[width],        %[width],          -0x04         \n\t"
+    "bnez       %[width],        1b                               \n\t"
+
+    : [y]"=&f"(y),                         [u]"=&f"(u),
+      [v]"=&f"(v),
+      [b_vec0]"=&f"(b_vec[0]),             [b_vec1]"=&f"(b_vec[1]),
+      [g_vec0]"=&f"(g_vec[0]),             [g_vec1]"=&f"(g_vec[1]),
+      [r_vec0]"=&f"(r_vec[0]),             [r_vec1]"=&f"(r_vec[1]),
+      [ub]"=&f"(ub),                       [ug]"=&f"(ug),
+      [vg]"=&f"(vg),                       [vr]"=&f"(vr),
+      [bb]"=&f"(bb),                       [bg]"=&f"(bg),
+      [br]"=&f"(br),                       [yg]"=&f"(yg)
+    : [y_ptr]"r"(src_y),                   [u_ptr]"r"(src_u),
+      [v_ptr]"r"(src_v),                   [rgbbuf_ptr]"r"(rgb_buf),
+      [yuvcons_ptr]"r"(yuvconstants),      [width]"r"(width),
+      [zero]"f"(0x00),                     [five]"f"(0x55),
+      [six]"f"(0x6),                       [mask]"f"(mask),
+      [lmove1]"f"(0x18),                   [rmove1]"f"(0x8),
+      [one]"f"(0x1)
+    : "memory"
+  );
+}
+
+void I422ToARGB4444Row_MMI(const uint8_t* src_y,
+                           const uint8_t* src_u,
+                           const uint8_t* src_v,
+                           uint8_t* dst_argb4444,
+                           const struct YuvConstants* yuvconstants,
+                           int width) {
+  uint64_t y, u, v;
+  uint64_t b_vec, g_vec, r_vec, temp;
+  uint64_t ub,ug,vg,vr,bb,bg,br,yg;
+
+  __asm__ volatile(
+    "ldc1       %[yg],           0xc0(%[yuvcons_ptr])             \n\t"
+    "ldc1       %[bb],           0x60(%[yuvcons_ptr])             \n\t"
+    "ldc1       %[ub],           0x00(%[yuvcons_ptr])             \n\t"
+    "or         %[ub],           %[ub],             %[mask]       \n\t"
+    "ldc1       %[bg],           0x80(%[yuvcons_ptr])             \n\t"
+    "ldc1       %[ug],           0x20(%[yuvcons_ptr])             \n\t"
+    "punpcklbh  %[ug],           %[ug],             %[zero]       \n\t"
+    "pshufh     %[ug],           %[ug],             %[zero]       \n\t"
+    "ldc1       %[vg],           0x20(%[yuvcons_ptr])             \n\t"
+    "punpcklbh  %[vg],           %[vg],             %[zero]       \n\t"
+    "pshufh     %[vg],           %[vg],             %[five]       \n\t"
+    "ldc1       %[br],           0xa0(%[yuvcons_ptr])             \n\t"
+    "ldc1       %[vr],           0x40(%[yuvcons_ptr])             \n\t"
+    "punpcklbh  %[vr],           %[vr],             %[zero]       \n\t"
+    "pshufh     %[vr],           %[vr],             %[five]       \n\t"
+    "or         %[vr],           %[vr],             %[mask]       \n\t"
+
+    "1:                                                           \n\t"
+    "gslwlc1    %[y],            0x03(%[y_ptr])                   \n\t"
+    "gslwrc1    %[y],            0x00(%[y_ptr])                   \n\t"
+    "gslwlc1    %[u],            0x03(%[u_ptr])                   \n\t"
+    "gslwrc1    %[u],            0x00(%[u_ptr])                   \n\t"
+    "gslwlc1    %[v],            0x03(%[v_ptr])                   \n\t"
+    "gslwrc1    %[v],            0x00(%[v_ptr])                   \n\t"
+
+    "punpcklbh  %[y],            %[y],              %[y]          \n\t"//y*0x0101
+    "pmulhuh    %[y],            %[y],              %[yg]         \n\t"//y1
+
+    //u3|u2|u1|u0 --> u1|u1|u0|u0
+    "punpcklbh  %[u],            %[u],              %[u]          \n\t"//u
+    "punpcklbh  %[u],            %[u],              %[zero]       \n\t"
+    "paddsh     %[b_vec],        %[y],              %[bb]         \n\t"
+    "pmullh     %[temp],         %[u],              %[ub]         \n\t"
+    "psubsh     %[b_vec],        %[b_vec],          %[temp]       \n\t"
+    "psrah      %[b_vec],        %[b_vec],          %[six]        \n\t"
+
+    //v3|v2|v1|v0 --> v1|v1|v0|v0
+    "punpcklbh  %[v],            %[v],              %[v]          \n\t"
+    "punpcklbh  %[v],            %[v],              %[zero]       \n\t"
+    "paddsh     %[g_vec],        %[y],              %[bg]         \n\t"
+    "pmullh     %[temp],         %[u],              %[ug]         \n\t"
+    "psubsh     %[g_vec],        %[g_vec],          %[temp]       \n\t"
+    "pmullh     %[temp],         %[v],              %[vg]         \n\t"
+    "psubsh     %[g_vec],        %[g_vec],          %[temp]       \n\t"
+    "psrah      %[g_vec],        %[g_vec],          %[six]        \n\t"
+
+    "paddsh     %[r_vec],        %[y],              %[br]         \n\t"
+    "pmullh     %[temp],         %[v],              %[vr]         \n\t"
+    "psubsh     %[r_vec],        %[r_vec],          %[temp]       \n\t"
+    "psrah      %[r_vec],        %[r_vec],          %[six]        \n\t"
+
+    "packushb   %[r_vec],        %[b_vec],          %[r_vec]      \n\t"
+    "packushb   %[g_vec],        %[g_vec],          %[zero]       \n\t"
+    "punpcklwd  %[g_vec],        %[g_vec],          %[alpha]      \n\t"
+    "punpcklbh  %[b_vec],        %[r_vec],          %[g_vec]      \n\t"
+    "punpckhbh  %[r_vec],        %[r_vec],          %[g_vec]      \n\t"
+    "punpcklhw  %[g_vec],        %[b_vec],          %[r_vec]      \n\t"
+    "punpckhhw  %[b_vec],        %[b_vec],          %[r_vec]      \n\t"
+
+    "and        %[g_vec],        %[g_vec],          %[mask1]      \n\t"
+    "psrlw      %[g_vec],        %[g_vec],          %[four]       \n\t"
+    "psrlw      %[r_vec],        %[g_vec],          %[four]       \n\t"
+    "or         %[g_vec],        %[g_vec],          %[r_vec]      \n\t"
+    "punpcklbh  %[r_vec],        %[alpha],          %[zero]       \n\t"
+    "and        %[g_vec],        %[g_vec],          %[r_vec]      \n\t"
+
+    "and        %[b_vec],        %[b_vec],          %[mask1]      \n\t"
+    "psrlw      %[b_vec],        %[b_vec],          %[four]       \n\t"
+    "psrlw      %[r_vec],        %[b_vec],          %[four]       \n\t"
+    "or         %[b_vec],        %[b_vec],          %[r_vec]      \n\t"
+    "punpcklbh  %[r_vec],        %[alpha],          %[zero]       \n\t"
+    "and        %[b_vec],        %[b_vec],          %[r_vec]      \n\t"
+    "packushb   %[g_vec],        %[g_vec],          %[b_vec]      \n\t"
+
+    "gssdlc1    %[g_vec],        0x07(%[dst_argb4444])            \n\t"
+    "gssdrc1    %[g_vec],        0x00(%[dst_argb4444])            \n\t"
+
+    "daddiu     %[y_ptr],        %[y_ptr],          0x04          \n\t"
+    "daddiu     %[u_ptr],        %[u_ptr],          0x02          \n\t"
+    "daddiu     %[v_ptr],        %[v_ptr],          0x02          \n\t"
+    "daddiu     %[dst_argb4444], %[dst_argb4444],   0x08          \n\t"
+    "daddi      %[width],        %[width],          -0x04         \n\t"
+    "bnez       %[width],        1b                               \n\t"
+
+    : [y]"=&f"(y),                         [u]"=&f"(u),
+      [v]"=&f"(v),
+      [b_vec]"=&f"(b_vec),                 [g_vec]"=&f"(g_vec),
+      [r_vec]"=&f"(r_vec),                 [temp]"=&f"(temp),
+      [ub]"=&f"(ub),                       [ug]"=&f"(ug),
+      [vg]"=&f"(vg),                       [vr]"=&f"(vr),
+      [bb]"=&f"(bb),                       [bg]"=&f"(bg),
+      [br]"=&f"(br),                       [yg]"=&f"(yg)
+    : [y_ptr]"r"(src_y),                   [u_ptr]"r"(src_u),
+      [v_ptr]"r"(src_v),                   [dst_argb4444]"r"(dst_argb4444),
+      [yuvcons_ptr]"r"(yuvconstants),      [width]"r"(width),
+      [zero]"f"(0x00),                     [five]"f"(0x55),
+      [six]"f"(0x6),                       [mask]"f"(0xff00ff00ff00ff00),
+      [four]"f"(0x4),                      [mask1]"f"(0xf0f0f0f0f0f0f0f0),
+      [alpha]"f"(-1)
+    : "memory"
+  );
+}
+
+void I422ToARGB1555Row_MMI(const uint8_t* src_y,
+                           const uint8_t* src_u,
+                           const uint8_t* src_v,
+                           uint8_t* dst_argb1555,
+                           const struct YuvConstants* yuvconstants,
+                           int width) {
+  uint64_t y, u, v;
+  uint64_t b_vec, g_vec, r_vec, temp;
+  uint64_t ub,ug,vg,vr,bb,bg,br,yg;
+
+  __asm__ volatile(
+    "ldc1       %[yg],           0xc0(%[yuvcons_ptr])             \n\t"
+    "ldc1       %[bb],           0x60(%[yuvcons_ptr])             \n\t"
+    "ldc1       %[ub],           0x00(%[yuvcons_ptr])             \n\t"
+    "or         %[ub],           %[ub],             %[mask1]      \n\t"
+    "ldc1       %[bg],           0x80(%[yuvcons_ptr])             \n\t"
+    "ldc1       %[ug],           0x20(%[yuvcons_ptr])             \n\t"
+    "punpcklbh  %[ug],           %[ug],             %[zero]       \n\t"
+    "pshufh     %[ug],           %[ug],             %[zero]       \n\t"
+    "ldc1       %[vg],           0x20(%[yuvcons_ptr])             \n\t"
+    "punpcklbh  %[vg],           %[vg],             %[zero]       \n\t"
+    "pshufh     %[vg],           %[vg],             %[five]       \n\t"
+    "ldc1       %[br],           0xa0(%[yuvcons_ptr])             \n\t"
+    "ldc1       %[vr],           0x40(%[yuvcons_ptr])             \n\t"
+    "punpcklbh  %[vr],           %[vr],             %[zero]       \n\t"
+    "pshufh     %[vr],           %[vr],             %[five]       \n\t"
+    "or         %[vr],           %[vr],             %[mask1]      \n\t"
+
+    "1:                                                           \n\t"
+    "gslwlc1    %[y],            0x03(%[y_ptr])                   \n\t"
+    "gslwrc1    %[y],            0x00(%[y_ptr])                   \n\t"
+    "gslwlc1    %[u],            0x03(%[u_ptr])                   \n\t"
+    "gslwrc1    %[u],            0x00(%[u_ptr])                   \n\t"
+    "gslwlc1    %[v],            0x03(%[v_ptr])                   \n\t"
+    "gslwrc1    %[v],            0x00(%[v_ptr])                   \n\t"
+
+    "punpcklbh  %[y],            %[y],              %[y]          \n\t"
+    "pmulhuh    %[y],            %[y],              %[yg]         \n\t"
+
+    //u3|u2|u1|u0 --> u1|u1|u0|u0
+    "punpcklbh  %[u],            %[u],              %[u]          \n\t"
+    "punpcklbh  %[u],            %[u],              %[zero]       \n\t"
+    "paddsh     %[b_vec],        %[y],              %[bb]         \n\t"
+    "pmullh     %[temp],         %[u],              %[ub]         \n\t"
+    "psubsh     %[b_vec],        %[b_vec],          %[temp]       \n\t"
+    "psrah      %[b_vec],        %[b_vec],          %[six]        \n\t"
+
+    //v3|v2|v1|v0 --> v1|v1|v0|v0
+    "punpcklbh  %[v],            %[v],              %[v]          \n\t"
+    "punpcklbh  %[v],            %[v],              %[zero]       \n\t"
+    "paddsh     %[g_vec],        %[y],              %[bg]         \n\t"
+    "pmullh     %[temp],         %[u],              %[ug]         \n\t"
+    "psubsh     %[g_vec],        %[g_vec],          %[temp]       \n\t"
+    "pmullh     %[temp],         %[v],              %[vg]         \n\t"
+    "psubsh     %[g_vec],        %[g_vec],          %[temp]       \n\t"
+    "psrah      %[g_vec],        %[g_vec],          %[six]        \n\t"
+
+    "paddsh     %[r_vec],        %[y],              %[br]         \n\t"
+    "pmullh     %[temp],         %[v],              %[vr]         \n\t"
+    "psubsh     %[r_vec],        %[r_vec],          %[temp]       \n\t"
+    "psrah      %[r_vec],        %[r_vec],          %[six]        \n\t"
+
+    "packushb   %[r_vec],        %[b_vec],          %[r_vec]      \n\t"
+    "packushb   %[g_vec],        %[g_vec],          %[zero]       \n\t"
+    "punpcklbh  %[b_vec],        %[r_vec],          %[g_vec]      \n\t"
+    "punpckhbh  %[r_vec],        %[r_vec],          %[g_vec]      \n\t"
+    "punpcklhw  %[g_vec],        %[b_vec],          %[r_vec]      \n\t"
+    "punpckhhw  %[b_vec],        %[b_vec],          %[r_vec]      \n\t"
+
+    "psrlw      %[temp],         %[g_vec],          %[three]      \n\t"
+    "and        %[g_vec],        %[temp],           %[mask2]      \n\t"
+    "psrlw      %[temp],         %[temp],           %[eight]      \n\t"
+    "and        %[r_vec],        %[temp],           %[mask2]      \n\t"
+    "psllw      %[r_vec],        %[r_vec],          %[lmove5]     \n\t"
+    "or         %[g_vec],        %[g_vec],          %[r_vec]      \n\t"
+    "psrlw      %[temp],         %[temp],           %[eight]      \n\t"
+    "and        %[r_vec],        %[temp],           %[mask2]      \n\t"
+    "psllw      %[r_vec],        %[r_vec],          %[lmove5]     \n\t"
+    "psllw      %[r_vec],        %[r_vec],          %[lmove5]     \n\t"
+    "or         %[g_vec],        %[g_vec],          %[r_vec]      \n\t"
+    "or         %[g_vec],        %[g_vec],          %[mask3]      \n\t"
+
+    "psrlw      %[temp],         %[b_vec],          %[three]      \n\t"
+    "and        %[b_vec],        %[temp],           %[mask2]      \n\t"
+    "psrlw      %[temp],         %[temp],           %[eight]      \n\t"
+    "and        %[r_vec],        %[temp],           %[mask2]      \n\t"
+    "psllw      %[r_vec],        %[r_vec],          %[lmove5]     \n\t"
+    "or         %[b_vec],        %[b_vec],          %[r_vec]      \n\t"
+    "psrlw      %[temp],         %[temp],           %[eight]      \n\t"
+    "and        %[r_vec],        %[temp],           %[mask2]      \n\t"
+    "psllw      %[r_vec],        %[r_vec],          %[lmove5]     \n\t"
+    "psllw      %[r_vec],        %[r_vec],          %[lmove5]     \n\t"
+    "or         %[b_vec],        %[b_vec],          %[r_vec]      \n\t"
+    "or         %[b_vec],        %[b_vec],          %[mask3]      \n\t"
+
+    "punpcklhw  %[r_vec],        %[g_vec],          %[b_vec]      \n\t"
+    "punpckhhw  %[b_vec],        %[g_vec],          %[b_vec]      \n\t"
+    "punpcklhw  %[g_vec],        %[r_vec],          %[b_vec]      \n\t"
+
+    "gssdlc1    %[g_vec],        0x07(%[dst_argb1555])            \n\t"
+    "gssdrc1    %[g_vec],        0x00(%[dst_argb1555])            \n\t"
+
+    "daddiu     %[y_ptr],        %[y_ptr],          0x04          \n\t"
+    "daddiu     %[u_ptr],        %[u_ptr],          0x02          \n\t"
+    "daddiu     %[v_ptr],        %[v_ptr],          0x02          \n\t"
+    "daddiu     %[dst_argb1555], %[dst_argb1555],   0x08          \n\t"
+    "daddi      %[width],        %[width],          -0x04         \n\t"
+    "bnez       %[width],        1b                               \n\t"
+
+    : [y]"=&f"(y),                         [u]"=&f"(u),
+      [v]"=&f"(v),
+      [b_vec]"=&f"(b_vec),                 [g_vec]"=&f"(g_vec),
+      [r_vec]"=&f"(r_vec),                 [temp]"=&f"(temp),
+      [ub]"=&f"(ub),                       [ug]"=&f"(ug),
+      [vg]"=&f"(vg),                       [vr]"=&f"(vr),
+      [bb]"=&f"(bb),                       [bg]"=&f"(bg),
+      [br]"=&f"(br),                       [yg]"=&f"(yg)
+    : [y_ptr]"r"(src_y),                   [u_ptr]"r"(src_u),
+      [v_ptr]"r"(src_v),                   [dst_argb1555]"r"(dst_argb1555),
+      [yuvcons_ptr]"r"(yuvconstants),      [width]"r"(width),
+      [zero]"f"(0x00),                     [five]"f"(0x55),
+      [six]"f"(0x6),                       [mask1]"f"(0xff00ff00ff00ff00),
+      [three]"f"(0x3),                     [mask2]"f"(0x1f0000001f),
+      [eight]"f"(0x8),                     [mask3]"f"(0x800000008000),
+      [lmove5]"f"(0x5)
+    : "memory"
+  );
+}
+
+void I422ToRGB565Row_MMI(const uint8_t* src_y,
+                         const uint8_t* src_u,
+                         const uint8_t* src_v,
+                         uint8_t* dst_rgb565,
+                         const struct YuvConstants* yuvconstants,
+                         int width) {
+  uint64_t y, u, v;
+  uint64_t b_vec, g_vec, r_vec, temp;
+  uint64_t ub,ug,vg,vr,bb,bg,br,yg;
+
+  __asm__ volatile(
+    "ldc1       %[yg],           0xc0(%[yuvcons_ptr])             \n\t"
+    "ldc1       %[bb],           0x60(%[yuvcons_ptr])             \n\t"
+    "ldc1       %[ub],           0x00(%[yuvcons_ptr])             \n\t"
+    "or         %[ub],           %[ub],             %[mask1]      \n\t"
+    "ldc1       %[bg],           0x80(%[yuvcons_ptr])             \n\t"
+    "ldc1       %[ug],           0x20(%[yuvcons_ptr])             \n\t"
+    "punpcklbh  %[ug],           %[ug],             %[zero]       \n\t"
+    "pshufh     %[ug],           %[ug],             %[zero]       \n\t"
+    "ldc1       %[vg],           0x20(%[yuvcons_ptr])             \n\t"
+    "punpcklbh  %[vg],           %[vg],             %[zero]       \n\t"
+    "pshufh     %[vg],           %[vg],             %[five]       \n\t"
+    "ldc1       %[br],           0xa0(%[yuvcons_ptr])             \n\t"
+    "ldc1       %[vr],           0x40(%[yuvcons_ptr])             \n\t"
+    "punpcklbh  %[vr],           %[vr],             %[zero]       \n\t"
+    "pshufh     %[vr],           %[vr],             %[five]       \n\t"
+    "or         %[vr],           %[vr],             %[mask1]      \n\t"
+
+    "1:                                                           \n\t"
+    "gslwlc1    %[y],            0x03(%[y_ptr])                   \n\t"
+    "gslwrc1    %[y],            0x00(%[y_ptr])                   \n\t"
+    "gslwlc1    %[u],            0x03(%[u_ptr])                   \n\t"
+    "gslwrc1    %[u],            0x00(%[u_ptr])                   \n\t"
+    "gslwlc1    %[v],            0x03(%[v_ptr])                   \n\t"
+    "gslwrc1    %[v],            0x00(%[v_ptr])                   \n\t"
+
+    "punpcklbh  %[y],            %[y],              %[y]          \n\t"
+    "pmulhuh    %[y],            %[y],              %[yg]         \n\t"
+
+    //u3|u2|u1|u0 --> u1|u1|u0|u0
+    "punpcklbh  %[u],            %[u],              %[u]          \n\t"
+    "punpcklbh  %[u],            %[u],              %[zero]       \n\t"
+    "paddsh     %[b_vec],        %[y],              %[bb]         \n\t"
+    "pmullh     %[temp],         %[u],              %[ub]         \n\t"
+    "psubsh     %[b_vec],        %[b_vec],          %[temp]       \n\t"
+    "psrah      %[b_vec],        %[b_vec],          %[six]        \n\t"
+
+    //v3|v2|v1|v0 --> v1|v1|v0|v0
+    "punpcklbh  %[v],            %[v],              %[v]          \n\t"
+    "punpcklbh  %[v],            %[v],              %[zero]       \n\t"
+    "paddsh     %[g_vec],        %[y],              %[bg]         \n\t"
+    "pmullh     %[temp],         %[u],              %[ug]         \n\t"
+    "psubsh     %[g_vec],        %[g_vec],          %[temp]       \n\t"
+    "pmullh     %[temp],         %[v],              %[vg]         \n\t"
+    "psubsh     %[g_vec],        %[g_vec],          %[temp]       \n\t"
+    "psrah      %[g_vec],        %[g_vec],          %[six]        \n\t"
+
+    "paddsh     %[r_vec],        %[y],              %[br]         \n\t"
+    "pmullh     %[temp],         %[v],              %[vr]         \n\t"
+    "psubsh     %[r_vec],        %[r_vec],          %[temp]       \n\t"
+    "psrah      %[r_vec],        %[r_vec],          %[six]        \n\t"
+
+    "packushb   %[r_vec],        %[b_vec],          %[r_vec]      \n\t"
+    "packushb   %[g_vec],        %[g_vec],          %[zero]       \n\t"
+    "punpcklbh  %[b_vec],        %[r_vec],          %[g_vec]      \n\t"
+    "punpckhbh  %[r_vec],        %[r_vec],          %[g_vec]      \n\t"
+    "punpcklhw  %[g_vec],        %[b_vec],          %[r_vec]      \n\t"
+    "punpckhhw  %[b_vec],        %[b_vec],          %[r_vec]      \n\t"
+
+    "psrlh      %[temp],         %[g_vec],          %[three]      \n\t"
+    "and        %[g_vec],        %[temp],           %[mask2]      \n\t"
+    "psrlw      %[temp],         %[temp],           %[seven]      \n\t"
+    "psrlw      %[r_vec],        %[mask1],          %[eight]      \n\t"
+    "and        %[r_vec],        %[temp],           %[r_vec]      \n\t"
+    "psllw      %[r_vec],        %[r_vec],          %[lmove5]     \n\t"
+    "or         %[g_vec],        %[g_vec],          %[r_vec]      \n\t"
+    "paddb      %[r_vec],        %[three],          %[six]        \n\t"
+    "psrlw      %[temp],         %[temp],           %[r_vec]      \n\t"
+    "and        %[r_vec],        %[temp],           %[mask2]      \n\t"
+    "paddb      %[temp],         %[three],          %[eight]      \n\t"
+    "psllw      %[r_vec],        %[r_vec],          %[temp]       \n\t"
+    "or         %[g_vec],        %[g_vec],          %[r_vec]      \n\t"
+
+    "psrlh      %[temp],         %[b_vec],          %[three]      \n\t"
+    "and        %[b_vec],        %[temp],           %[mask2]      \n\t"
+    "psrlw      %[temp],         %[temp],           %[seven]      \n\t"
+    "psrlw      %[r_vec],        %[mask1],          %[eight]      \n\t"
+    "and        %[r_vec],        %[temp],           %[r_vec]      \n\t"
+    "psllw      %[r_vec],        %[r_vec],          %[lmove5]     \n\t"
+    "or         %[b_vec],        %[b_vec],          %[r_vec]      \n\t"
+    "paddb      %[r_vec],        %[three],          %[six]        \n\t"
+    "psrlw      %[temp],         %[temp],           %[r_vec]      \n\t"
+    "and        %[r_vec],        %[temp],           %[mask2]      \n\t"
+    "paddb      %[temp],         %[three],          %[eight]      \n\t"
+    "psllw      %[r_vec],        %[r_vec],          %[temp]       \n\t"
+    "or         %[b_vec],        %[b_vec],          %[r_vec]      \n\t"
+
+    "punpcklhw  %[r_vec],        %[g_vec],          %[b_vec]      \n\t"
+    "punpckhhw  %[b_vec],        %[g_vec],          %[b_vec]      \n\t"
+    "punpcklhw  %[g_vec],        %[r_vec],          %[b_vec]      \n\t"
+
+    "gssdlc1    %[g_vec],        0x07(%[dst_rgb565])             \n\t"
+    "gssdrc1    %[g_vec],        0x00(%[dst_rgb565])             \n\t"
+
+    "daddiu     %[y_ptr],        %[y_ptr],          0x04          \n\t"
+    "daddiu     %[u_ptr],        %[u_ptr],          0x02          \n\t"
+    "daddiu     %[v_ptr],        %[v_ptr],          0x02          \n\t"
+    "daddiu     %[dst_rgb565],   %[dst_rgb565],     0x08          \n\t"
+    "daddi      %[width],        %[width],          -0x04         \n\t"
+    "bnez       %[width],        1b                               \n\t"
+
+    : [y]"=&f"(y),                         [u]"=&f"(u),
+      [v]"=&f"(v),
+      [b_vec]"=&f"(b_vec),                 [g_vec]"=&f"(g_vec),
+      [r_vec]"=&f"(r_vec),                 [temp]"=&f"(temp),
+      [ub]"=&f"(ub),                       [ug]"=&f"(ug),
+      [vg]"=&f"(vg),                       [vr]"=&f"(vr),
+      [bb]"=&f"(bb),                       [bg]"=&f"(bg),
+      [br]"=&f"(br),                       [yg]"=&f"(yg)
+    : [y_ptr]"r"(src_y),                   [u_ptr]"r"(src_u),
+      [v_ptr]"r"(src_v),                   [dst_rgb565]"r"(dst_rgb565),
+      [yuvcons_ptr]"r"(yuvconstants),      [width]"r"(width),
+      [zero]"f"(0x00),                     [five]"f"(0x55),
+      [six]"f"(0x6),                       [mask1]"f"(0xff00ff00ff00ff00),
+      [three]"f"(0x3),                     [mask2]"f"(0x1f0000001f),
+      [eight]"f"(0x8),                     [seven]"f"(0x7),
+      [lmove5]"f"(0x5)
+    : "memory"
+  );
+}
+
+void NV12ToARGBRow_MMI(const uint8_t* src_y,
+                       const uint8_t* src_uv,
+                       uint8_t* rgb_buf,
+                       const struct YuvConstants* yuvconstants,
+                       int width) {
+  uint64_t y, u, v;
+  uint64_t b_vec, g_vec, r_vec, temp;
+  uint64_t ub,ug,vg,vr,bb,bg,br,yg;
+
+  __asm__ volatile(
+    "ldc1       %[yg],           0xc0(%[yuvcons_ptr])             \n\t"
+    "ldc1       %[bb],           0x60(%[yuvcons_ptr])             \n\t"
+    "ldc1       %[ub],           0x00(%[yuvcons_ptr])             \n\t"
+    "or         %[ub],           %[ub],             %[mask1]      \n\t"
+    "ldc1       %[bg],           0x80(%[yuvcons_ptr])             \n\t"
+    "ldc1       %[ug],           0x20(%[yuvcons_ptr])             \n\t"
+    "punpcklbh  %[ug],           %[ug],             %[zero]       \n\t"
+    "pshufh     %[ug],           %[ug],             %[zero]       \n\t"
+    "ldc1       %[vg],           0x20(%[yuvcons_ptr])             \n\t"
+    "punpcklbh  %[vg],           %[vg],             %[zero]       \n\t"
+    "pshufh     %[vg],           %[vg],             %[five]       \n\t"
+    "ldc1       %[br],           0xa0(%[yuvcons_ptr])             \n\t"
+    "ldc1       %[vr],           0x40(%[yuvcons_ptr])             \n\t"
+    "punpcklbh  %[vr],           %[vr],             %[zero]       \n\t"
+    "pshufh     %[vr],           %[vr],             %[five]       \n\t"
+    "or         %[vr],           %[vr],             %[mask1]      \n\t"
+
+    "1:                                                           \n\t"
+    "gslwlc1    %[y],            0x03(%[y_ptr])                   \n\t"
+    "gslwrc1    %[y],            0x00(%[y_ptr])                   \n\t"
+    "gslwlc1    %[u],            0x03(%[uv_ptr])                  \n\t"
+    "gslwrc1    %[u],            0x00(%[uv_ptr])                  \n\t"
+    "punpcklbh  %[u],            %[u],              %[zero]       \n\t"
+    "pshufh     %[v],            %[u],              %[vshu]       \n\t"
+    "pshufh     %[u],            %[u],              %[ushu]       \n\t"
+
+    "punpcklbh  %[y],            %[y],              %[y]          \n\t"
+    "pmulhuh    %[y],            %[y],              %[yg]         \n\t"
+
+    "paddsh     %[b_vec],        %[y],              %[bb]         \n\t"
+    "pmullh     %[temp],         %[u],              %[ub]         \n\t"
+    "psubsh     %[b_vec],        %[b_vec],          %[temp]       \n\t"
+    "psrah      %[b_vec],        %[b_vec],          %[six]        \n\t"
+
+    "paddsh     %[g_vec],        %[y],              %[bg]         \n\t"
+    "pmullh     %[temp],         %[u],              %[ug]         \n\t"
+    "psubsh     %[g_vec],        %[g_vec],          %[temp]       \n\t"
+    "pmullh     %[temp],         %[v],              %[vg]         \n\t"
+    "psubsh     %[g_vec],        %[g_vec],          %[temp]       \n\t"
+    "psrah      %[g_vec],        %[g_vec],          %[six]        \n\t"
+
+    "paddsh     %[r_vec],        %[y],              %[br]         \n\t"
+    "pmullh     %[temp],         %[v],              %[vr]         \n\t"
+    "psubsh     %[r_vec],        %[r_vec],          %[temp]       \n\t"
+    "psrah      %[r_vec],        %[r_vec],          %[six]        \n\t"
+
+    "packushb   %[r_vec],        %[b_vec],          %[r_vec]      \n\t"
+    "packushb   %[g_vec],        %[g_vec],          %[zero]       \n\t"
+    "punpcklwd  %[g_vec],        %[g_vec],          %[alpha]      \n\t"
+    "punpcklbh  %[b_vec],        %[r_vec],          %[g_vec]      \n\t"
+    "punpckhbh  %[r_vec],        %[r_vec],          %[g_vec]      \n\t"
+    "punpcklhw  %[g_vec],        %[b_vec],          %[r_vec]      \n\t"
+    "punpckhhw  %[b_vec],        %[b_vec],          %[r_vec]      \n\t"
+
+    "gssdlc1    %[g_vec],       0x07(%[rgbbuf_ptr])               \n\t"
+    "gssdrc1    %[g_vec],       0x00(%[rgbbuf_ptr])               \n\t"
+    "gssdlc1    %[b_vec],       0x0f(%[rgbbuf_ptr])               \n\t"
+    "gssdrc1    %[b_vec],       0x08(%[rgbbuf_ptr])               \n\t"
+
+    "daddiu     %[y_ptr],        %[y_ptr],          0x04          \n\t"
+    "daddiu     %[uv_ptr],       %[uv_ptr],         0x04          \n\t"
+    "daddiu     %[rgbbuf_ptr],   %[rgbbuf_ptr],     0x10          \n\t"
+    "daddi      %[width],        %[width],          -0x04         \n\t"
+    "bnez       %[width],        1b                               \n\t"
+
+    : [y]"=&f"(y),                         [u]"=&f"(u),
+      [v]"=&f"(v),
+      [b_vec]"=&f"(b_vec),                 [g_vec]"=&f"(g_vec),
+      [r_vec]"=&f"(r_vec),                 [temp]"=&f"(temp),
+      [ub]"=&f"(ub),                       [ug]"=&f"(ug),
+      [vg]"=&f"(vg),                       [vr]"=&f"(vr),
+      [bb]"=&f"(bb),                       [bg]"=&f"(bg),
+      [br]"=&f"(br),                       [yg]"=&f"(yg)
+    : [y_ptr]"r"(src_y),                   [uv_ptr]"r"(src_uv),
+      [rgbbuf_ptr]"r"(rgb_buf),
+      [yuvcons_ptr]"r"(yuvconstants),      [width]"r"(width),
+      [zero]"f"(0x00),                     [five]"f"(0x55),
+      [six]"f"(0x6),                       [mask1]"f"(0xff00ff00ff00ff00),
+      [ushu]"f"(0xA0),                     [vshu]"f"(0xf5),
+      [alpha]"f"(-1)
+    : "memory"
+  );
+}
+
+void NV21ToARGBRow_MMI(const uint8_t* src_y,
+                       const uint8_t* src_vu,
+                       uint8_t* rgb_buf,
+                       const struct YuvConstants* yuvconstants,
+                       int width) {
+  uint64_t y, u, v;
+  uint64_t b_vec, g_vec, r_vec, temp;
+  uint64_t ub,ug,vg,vr,bb,bg,br,yg;
+
+  __asm__ volatile(
+    "ldc1       %[yg],           0xc0(%[yuvcons_ptr])             \n\t"
+    "ldc1       %[bb],           0x60(%[yuvcons_ptr])             \n\t"
+    "ldc1       %[ub],           0x00(%[yuvcons_ptr])             \n\t"
+    "or         %[ub],           %[ub],             %[mask1]      \n\t"
+    "ldc1       %[bg],           0x80(%[yuvcons_ptr])             \n\t"
+    "ldc1       %[ug],           0x20(%[yuvcons_ptr])             \n\t"
+    "punpcklbh  %[ug],           %[ug],             %[zero]       \n\t"
+    "pshufh     %[ug],           %[ug],             %[zero]       \n\t"
+    "ldc1       %[vg],           0x20(%[yuvcons_ptr])             \n\t"
+    "punpcklbh  %[vg],           %[vg],             %[zero]       \n\t"
+    "pshufh     %[vg],           %[vg],             %[five]       \n\t"
+    "ldc1       %[br],           0xa0(%[yuvcons_ptr])             \n\t"
+    "ldc1       %[vr],           0x40(%[yuvcons_ptr])             \n\t"
+    "punpcklbh  %[vr],           %[vr],             %[zero]       \n\t"
+    "pshufh     %[vr],           %[vr],             %[five]       \n\t"
+    "or         %[vr],           %[vr],             %[mask1]      \n\t"
+
+    "1:                                                           \n\t"
+    "gslwlc1    %[y],            0x03(%[y_ptr])                   \n\t"
+    "gslwrc1    %[y],            0x00(%[y_ptr])                   \n\t"
+    "gslwlc1    %[u],            0x03(%[vu_ptr])                  \n\t"
+    "gslwrc1    %[u],            0x00(%[vu_ptr])                  \n\t"
+    "punpcklbh  %[u],            %[u],              %[zero]       \n\t"
+    "pshufh     %[v],            %[u],              %[ushu]       \n\t"
+    "pshufh     %[u],            %[u],              %[vshu]       \n\t"
+
+    "punpcklbh  %[y],            %[y],              %[y]          \n\t"
+    "pmulhuh    %[y],            %[y],              %[yg]         \n\t"
+
+    "paddsh     %[b_vec],        %[y],              %[bb]         \n\t"
+    "pmullh     %[temp],         %[u],              %[ub]         \n\t"
+    "psubsh     %[b_vec],        %[b_vec],          %[temp]       \n\t"
+    "psrah      %[b_vec],        %[b_vec],          %[six]        \n\t"
+
+    "paddsh     %[g_vec],        %[y],              %[bg]         \n\t"
+    "pmullh     %[temp],         %[u],              %[ug]         \n\t"
+    "psubsh     %[g_vec],        %[g_vec],          %[temp]       \n\t"
+    "pmullh     %[temp],         %[v],              %[vg]         \n\t"
+    "psubsh     %[g_vec],        %[g_vec],          %[temp]       \n\t"
+    "psrah      %[g_vec],        %[g_vec],          %[six]        \n\t"
+
+    "paddsh     %[r_vec],        %[y],              %[br]         \n\t"
+    "pmullh     %[temp],         %[v],              %[vr]         \n\t"
+    "psubsh     %[r_vec],        %[r_vec],          %[temp]       \n\t"
+    "psrah      %[r_vec],        %[r_vec],          %[six]        \n\t"
+
+    "packushb   %[r_vec],        %[b_vec],          %[r_vec]      \n\t"
+    "packushb   %[g_vec],        %[g_vec],          %[zero]       \n\t"
+    "punpcklwd  %[g_vec],        %[g_vec],          %[alpha]      \n\t"
+    "punpcklbh  %[b_vec],        %[r_vec],          %[g_vec]      \n\t"
+    "punpckhbh  %[r_vec],        %[r_vec],          %[g_vec]      \n\t"
+    "punpcklhw  %[g_vec],        %[b_vec],          %[r_vec]      \n\t"
+    "punpckhhw  %[b_vec],        %[b_vec],          %[r_vec]      \n\t"
+
+    "gssdlc1    %[g_vec],       0x07(%[rgbbuf_ptr])               \n\t"
+    "gssdrc1    %[g_vec],       0x00(%[rgbbuf_ptr])               \n\t"
+    "gssdlc1    %[b_vec],       0x0f(%[rgbbuf_ptr])               \n\t"
+    "gssdrc1    %[b_vec],       0x08(%[rgbbuf_ptr])               \n\t"
+
+    "daddiu     %[y_ptr],        %[y_ptr],          0x04          \n\t"
+    "daddiu     %[vu_ptr],       %[vu_ptr],         0x04          \n\t"
+    "daddiu     %[rgbbuf_ptr],   %[rgbbuf_ptr],     0x10          \n\t"
+    "daddi      %[width],        %[width],          -0x04         \n\t"
+    "bnez       %[width],        1b                               \n\t"
+
+    : [y]"=&f"(y),                         [u]"=&f"(u),
+      [v]"=&f"(v),
+      [b_vec]"=&f"(b_vec),                 [g_vec]"=&f"(g_vec),
+      [r_vec]"=&f"(r_vec),                 [temp]"=&f"(temp),
+      [ub]"=&f"(ub),                       [ug]"=&f"(ug),
+      [vg]"=&f"(vg),                       [vr]"=&f"(vr),
+      [bb]"=&f"(bb),                       [bg]"=&f"(bg),
+      [br]"=&f"(br),                       [yg]"=&f"(yg)
+    : [y_ptr]"r"(src_y),                   [vu_ptr]"r"(src_vu),
+      [rgbbuf_ptr]"r"(rgb_buf),
+      [yuvcons_ptr]"r"(yuvconstants),      [width]"r"(width),
+      [zero]"f"(0x00),                     [five]"f"(0x55),
+      [six]"f"(0x6),                       [mask1]"f"(0xff00ff00ff00ff00),
+      [ushu]"f"(0xA0),                     [vshu]"f"(0xf5),
+      [alpha]"f"(-1)
+    : "memory"
+  );
+}
+
+void NV12ToRGB24Row_MMI(const uint8_t* src_y,
+                        const uint8_t* src_uv,
+                        uint8_t* rgb_buf,
+                        const struct YuvConstants* yuvconstants,
+                        int width) {
+  uint64_t y, u, v;
+  uint64_t b_vec, g_vec, r_vec, temp;
+  uint64_t ub,ug,vg,vr,bb,bg,br,yg;
+
+  __asm__ volatile(
+    "ldc1       %[yg],           0xc0(%[yuvcons_ptr])             \n\t"
+    "ldc1       %[bb],           0x60(%[yuvcons_ptr])             \n\t"
+    "ldc1       %[ub],           0x00(%[yuvcons_ptr])             \n\t"
+    "or         %[ub],           %[ub],             %[mask1]      \n\t"
+    "ldc1       %[bg],           0x80(%[yuvcons_ptr])             \n\t"
+    "ldc1       %[ug],           0x20(%[yuvcons_ptr])             \n\t"
+    "punpcklbh  %[ug],           %[ug],             %[zero]       \n\t"
+    "pshufh     %[ug],           %[ug],             %[zero]       \n\t"
+    "ldc1       %[vg],           0x20(%[yuvcons_ptr])             \n\t"
+    "punpcklbh  %[vg],           %[vg],             %[zero]       \n\t"
+    "pshufh     %[vg],           %[vg],             %[five]       \n\t"
+    "ldc1       %[br],           0xa0(%[yuvcons_ptr])             \n\t"
+    "ldc1       %[vr],           0x40(%[yuvcons_ptr])             \n\t"
+    "punpcklbh  %[vr],           %[vr],             %[zero]       \n\t"
+    "pshufh     %[vr],           %[vr],             %[five]       \n\t"
+    "or         %[vr],           %[vr],             %[mask1]      \n\t"
+
+    "1:                                                           \n\t"
+    "gslwlc1    %[y],            0x03(%[y_ptr])                   \n\t"
+    "gslwrc1    %[y],            0x00(%[y_ptr])                   \n\t"
+    "gslwlc1    %[u],            0x03(%[uv_ptr])                  \n\t"
+    "gslwrc1    %[u],            0x00(%[uv_ptr])                  \n\t"
+    "punpcklbh  %[u],            %[u],              %[zero]       \n\t"
+    "pshufh     %[v],            %[u],              %[vshu]       \n\t"
+    "pshufh     %[u],            %[u],              %[ushu]       \n\t"
+
+    "punpcklbh  %[y],            %[y],              %[y]          \n\t"
+    "pmulhuh    %[y],            %[y],              %[yg]         \n\t"
+
+    "paddsh     %[b_vec],        %[y],              %[bb]         \n\t"
+    "pmullh     %[temp],         %[u],              %[ub]         \n\t"
+    "psubsh     %[b_vec],        %[b_vec],          %[temp]       \n\t"
+    "psrah      %[b_vec],        %[b_vec],          %[six]        \n\t"
+
+    "paddsh     %[g_vec],        %[y],              %[bg]         \n\t"
+    "pmullh     %[temp],         %[u],              %[ug]         \n\t"
+    "psubsh     %[g_vec],        %[g_vec],          %[temp]       \n\t"
+    "pmullh     %[temp],         %[v],              %[vg]         \n\t"
+    "psubsh     %[g_vec],        %[g_vec],          %[temp]       \n\t"
+    "psrah      %[g_vec],        %[g_vec],          %[six]        \n\t"
+
+    "paddsh     %[r_vec],        %[y],              %[br]         \n\t"
+    "pmullh     %[temp],         %[v],              %[vr]         \n\t"
+    "psubsh     %[r_vec],        %[r_vec],          %[temp]       \n\t"
+    "psrah      %[r_vec],        %[r_vec],          %[six]        \n\t"
+
+    "packushb   %[r_vec],        %[b_vec],          %[r_vec]      \n\t"
+    "packushb   %[g_vec],        %[g_vec],          %[zero]       \n\t"
+    "punpcklbh  %[b_vec],        %[r_vec],          %[g_vec]      \n\t"
+    "punpckhbh  %[r_vec],        %[r_vec],          %[g_vec]      \n\t"
+    "punpcklhw  %[g_vec],        %[b_vec],          %[r_vec]      \n\t"
+    "punpckhhw  %[b_vec],        %[b_vec],          %[r_vec]      \n\t"
+
+    "punpckhwd  %[r_vec],        %[g_vec],          %[g_vec]      \n\t"
+    "psllw      %[temp],         %[r_vec],          %[lmove1]     \n\t"
+    "or         %[g_vec],        %[g_vec],          %[temp]       \n\t"
+    "psrlw      %[temp],         %[r_vec],          %[rmove1]     \n\t"
+    "pextrh     %[temp],         %[temp],           %[zero]       \n\t"
+    "pinsrh_2   %[g_vec],        %[g_vec],          %[temp]       \n\t"
+    "pextrh     %[temp],         %[b_vec],          %[zero]       \n\t"
+    "pinsrh_3   %[g_vec],        %[g_vec],          %[temp]       \n\t"
+    "pextrh     %[temp],         %[b_vec],          %[one]        \n\t"
+    "punpckhwd  %[b_vec],        %[b_vec],          %[b_vec]      \n\t"
+    "psllw      %[b_vec],        %[b_vec],          %[rmove1]     \n\t"
+    "or         %[b_vec],        %[b_vec],          %[temp]       \n\t"
+    "gssdlc1    %[g_vec],        0x07(%[rgbbuf_ptr])              \n\t"
+    "gssdrc1    %[g_vec],        0x00(%[rgbbuf_ptr])              \n\t"
+    "gsswlc1    %[b_vec],        0x0b(%[rgbbuf_ptr])              \n\t"
+    "gsswrc1    %[b_vec],        0x08(%[rgbbuf_ptr])              \n\t"
+
+    "daddiu     %[y_ptr],        %[y_ptr],          0x04          \n\t"
+    "daddiu     %[uv_ptr],       %[uv_ptr],         0x04          \n\t"
+    "daddiu     %[rgbbuf_ptr],   %[rgbbuf_ptr],     0x0C          \n\t"
+    "daddi      %[width],        %[width],          -0x04         \n\t"
+    "bnez       %[width],        1b                               \n\t"
+
+    : [y]"=&f"(y),                         [u]"=&f"(u),
+      [v]"=&f"(v),
+      [b_vec]"=&f"(b_vec),                 [g_vec]"=&f"(g_vec),
+      [r_vec]"=&f"(r_vec),                 [temp]"=&f"(temp),
+      [ub]"=&f"(ub),                       [ug]"=&f"(ug),
+      [vg]"=&f"(vg),                       [vr]"=&f"(vr),
+      [bb]"=&f"(bb),                       [bg]"=&f"(bg),
+      [br]"=&f"(br),                       [yg]"=&f"(yg)
+    : [y_ptr]"r"(src_y),                   [uv_ptr]"r"(src_uv),
+      [rgbbuf_ptr]"r"(rgb_buf),
+      [yuvcons_ptr]"r"(yuvconstants),      [width]"r"(width),
+      [zero]"f"(0x00),                     [five]"f"(0x55),
+      [six]"f"(0x6),                       [mask1]"f"(0xff00ff00ff00ff00),
+      [ushu]"f"(0xA0),                     [vshu]"f"(0xf5),
+      [alpha]"f"(-1),                      [lmove1]"f"(0x18),
+      [one]"f"(0x1),                       [rmove1]"f"(0x8)
+    : "memory"
+  );
+}
+
+void NV21ToRGB24Row_MMI(const uint8_t* src_y,
+                        const uint8_t* src_vu,
+                        uint8_t* rgb_buf,
+                        const struct YuvConstants* yuvconstants,
+                        int width) {
+  uint64_t y, u, v;
+  uint64_t b_vec, g_vec, r_vec, temp;
+  uint64_t ub,ug,vg,vr,bb,bg,br,yg;
+
+  __asm__ volatile(
+    "ldc1       %[yg],           0xc0(%[yuvcons_ptr])             \n\t"
+    "ldc1       %[bb],           0x60(%[yuvcons_ptr])             \n\t"
+    "ldc1       %[ub],           0x00(%[yuvcons_ptr])             \n\t"
+    "or         %[ub],           %[ub],             %[mask1]      \n\t"
+    "ldc1       %[bg],           0x80(%[yuvcons_ptr])             \n\t"
+    "ldc1       %[ug],           0x20(%[yuvcons_ptr])             \n\t"
+    "punpcklbh  %[ug],           %[ug],             %[zero]       \n\t"
+    "pshufh     %[ug],           %[ug],             %[zero]       \n\t"
+    "ldc1       %[vg],           0x20(%[yuvcons_ptr])             \n\t"
+    "punpcklbh  %[vg],           %[vg],             %[zero]       \n\t"
+    "pshufh     %[vg],           %[vg],             %[five]       \n\t"
+    "ldc1       %[br],           0xa0(%[yuvcons_ptr])             \n\t"
+    "ldc1       %[vr],           0x40(%[yuvcons_ptr])             \n\t"
+    "punpcklbh  %[vr],           %[vr],             %[zero]       \n\t"
+    "pshufh     %[vr],           %[vr],             %[five]       \n\t"
+    "or         %[vr],           %[vr],             %[mask1]      \n\t"
+
+    "1:                                                           \n\t"
+    "gslwlc1    %[y],            0x03(%[y_ptr])                   \n\t"
+    "gslwrc1    %[y],            0x00(%[y_ptr])                   \n\t"
+    "gslwlc1    %[u],            0x03(%[vu_ptr])                  \n\t"
+    "gslwrc1    %[u],            0x00(%[vu_ptr])                  \n\t"
+    "punpcklbh  %[u],            %[u],              %[zero]       \n\t"
+    "pshufh     %[v],            %[u],              %[ushu]       \n\t"
+    "pshufh     %[u],            %[u],              %[vshu]       \n\t"
+
+    "punpcklbh  %[y],            %[y],              %[y]          \n\t"
+    "pmulhuh    %[y],            %[y],              %[yg]         \n\t"
+
+    "paddsh     %[b_vec],        %[y],              %[bb]         \n\t"
+    "pmullh     %[temp],         %[u],              %[ub]         \n\t"
+    "psubsh     %[b_vec],        %[b_vec],          %[temp]       \n\t"
+    "psrah      %[b_vec],        %[b_vec],          %[six]        \n\t"
+
+    "paddsh     %[g_vec],        %[y],              %[bg]         \n\t"
+    "pmullh     %[temp],         %[u],              %[ug]         \n\t"
+    "psubsh     %[g_vec],        %[g_vec],          %[temp]       \n\t"
+    "pmullh     %[temp],         %[v],              %[vg]         \n\t"
+    "psubsh     %[g_vec],        %[g_vec],          %[temp]       \n\t"
+    "psrah      %[g_vec],        %[g_vec],          %[six]        \n\t"
+
+    "paddsh     %[r_vec],        %[y],              %[br]         \n\t"
+    "pmullh     %[temp],         %[v],              %[vr]         \n\t"
+    "psubsh     %[r_vec],        %[r_vec],          %[temp]       \n\t"
+    "psrah      %[r_vec],        %[r_vec],          %[six]        \n\t"
+
+    "packushb   %[r_vec],        %[b_vec],          %[r_vec]      \n\t"
+    "packushb   %[g_vec],        %[g_vec],          %[zero]       \n\t"
+    "punpcklbh  %[b_vec],        %[r_vec],          %[g_vec]      \n\t"
+    "punpckhbh  %[r_vec],        %[r_vec],          %[g_vec]      \n\t"
+    "punpcklhw  %[g_vec],        %[b_vec],          %[r_vec]      \n\t"
+    "punpckhhw  %[b_vec],        %[b_vec],          %[r_vec]      \n\t"
+
+    "punpckhwd  %[r_vec],        %[g_vec],          %[g_vec]      \n\t"
+    "psllw      %[temp],         %[r_vec],          %[lmove1]     \n\t"
+    "or         %[g_vec],        %[g_vec],          %[temp]       \n\t"
+    "psrlw      %[temp],         %[r_vec],          %[rmove1]     \n\t"
+    "pextrh     %[temp],         %[temp],           %[zero]       \n\t"
+    "pinsrh_2   %[g_vec],        %[g_vec],          %[temp]       \n\t"
+    "pextrh     %[temp],         %[b_vec],          %[zero]       \n\t"
+    "pinsrh_3   %[g_vec],        %[g_vec],          %[temp]       \n\t"
+    "pextrh     %[temp],         %[b_vec],          %[one]        \n\t"
+    "punpckhwd  %[b_vec],        %[b_vec],          %[b_vec]      \n\t"
+    "psllw      %[b_vec],        %[b_vec],          %[rmove1]     \n\t"
+    "or         %[b_vec],        %[b_vec],          %[temp]       \n\t"
+    "gssdlc1    %[g_vec],        0x07(%[rgbbuf_ptr])              \n\t"
+    "gssdrc1    %[g_vec],        0x00(%[rgbbuf_ptr])              \n\t"
+    "gsswlc1    %[b_vec],        0x0b(%[rgbbuf_ptr])              \n\t"
+    "gsswrc1    %[b_vec],        0x08(%[rgbbuf_ptr])              \n\t"
+
+    "daddiu     %[y_ptr],        %[y_ptr],          0x04          \n\t"
+    "daddiu     %[vu_ptr],       %[vu_ptr],         0x04          \n\t"
+    "daddiu     %[rgbbuf_ptr],   %[rgbbuf_ptr],     0x0C          \n\t"
+    "daddi      %[width],        %[width],          -0x04         \n\t"
+    "bnez       %[width],        1b                               \n\t"
+
+    : [y]"=&f"(y),                         [u]"=&f"(u),
+      [v]"=&f"(v),
+      [b_vec]"=&f"(b_vec),                 [g_vec]"=&f"(g_vec),
+      [r_vec]"=&f"(r_vec),                 [temp]"=&f"(temp),
+      [ub]"=&f"(ub),                       [ug]"=&f"(ug),
+      [vg]"=&f"(vg),                       [vr]"=&f"(vr),
+      [bb]"=&f"(bb),                       [bg]"=&f"(bg),
+      [br]"=&f"(br),                       [yg]"=&f"(yg)
+    : [y_ptr]"r"(src_y),                   [vu_ptr]"r"(src_vu),
+      [rgbbuf_ptr]"r"(rgb_buf),
+      [yuvcons_ptr]"r"(yuvconstants),      [width]"r"(width),
+      [zero]"f"(0x00),                     [five]"f"(0x55),
+      [six]"f"(0x6),                       [mask1]"f"(0xff00ff00ff00ff00),
+      [ushu]"f"(0xA0),                     [vshu]"f"(0xf5),
+      [lmove1]"f"(0x18),                   [rmove1]"f"(0x8),
+      [one]"f"(0x1)
+    : "memory"
+  );
+}
+
+void NV12ToRGB565Row_MMI(const uint8_t* src_y,
+                         const uint8_t* src_uv,
+                         uint8_t* dst_rgb565,
+                         const struct YuvConstants* yuvconstants,
+                         int width) {
+  uint64_t y, u, v;
+  uint64_t b_vec, g_vec, r_vec, temp;
+  uint64_t ub,ug,vg,vr,bb,bg,br,yg;
+
+  __asm__ volatile(
+    "ldc1       %[yg],           0xc0(%[yuvcons_ptr])             \n\t"
+    "ldc1       %[bb],           0x60(%[yuvcons_ptr])             \n\t"
+    "ldc1       %[ub],           0x00(%[yuvcons_ptr])             \n\t"
+    "or         %[ub],           %[ub],             %[mask1]      \n\t"
+    "ldc1       %[bg],           0x80(%[yuvcons_ptr])             \n\t"
+    "ldc1       %[ug],           0x20(%[yuvcons_ptr])             \n\t"
+    "punpcklbh  %[ug],           %[ug],             %[zero]       \n\t"
+    "pshufh     %[ug],           %[ug],             %[zero]       \n\t"
+    "ldc1       %[vg],           0x20(%[yuvcons_ptr])             \n\t"
+    "punpcklbh  %[vg],           %[vg],             %[zero]       \n\t"
+    "pshufh     %[vg],           %[vg],             %[five]       \n\t"
+    "ldc1       %[br],           0xa0(%[yuvcons_ptr])             \n\t"
+    "ldc1       %[vr],           0x40(%[yuvcons_ptr])             \n\t"
+    "punpcklbh  %[vr],           %[vr],             %[zero]       \n\t"
+    "pshufh     %[vr],           %[vr],             %[five]       \n\t"
+    "or         %[vr],           %[vr],             %[mask1]      \n\t"
+
+    "1:                                                           \n\t"
+    "gslwlc1    %[y],            0x03(%[y_ptr])                   \n\t"
+    "gslwrc1    %[y],            0x00(%[y_ptr])                   \n\t"
+    "gslwlc1    %[u],            0x03(%[uv_ptr])                  \n\t"
+    "gslwrc1    %[u],            0x00(%[uv_ptr])                  \n\t"
+    "punpcklbh  %[u],            %[u],              %[zero]       \n\t"
+    "pshufh     %[v],            %[u],              %[vshu]       \n\t"
+    "pshufh     %[u],            %[u],              %[ushu]       \n\t"
+
+    "punpcklbh  %[y],            %[y],              %[y]          \n\t"
+    "pmulhuh    %[y],            %[y],              %[yg]         \n\t"
+
+    "paddsh     %[b_vec],        %[y],              %[bb]         \n\t"
+    "pmullh     %[temp],         %[u],              %[ub]         \n\t"
+    "psubsh     %[b_vec],        %[b_vec],          %[temp]       \n\t"
+    "psrah      %[b_vec],        %[b_vec],          %[six]        \n\t"
+
+    "paddsh     %[g_vec],        %[y],              %[bg]         \n\t"
+    "pmullh     %[temp],         %[u],              %[ug]         \n\t"
+    "psubsh     %[g_vec],        %[g_vec],          %[temp]       \n\t"
+    "pmullh     %[temp],         %[v],              %[vg]         \n\t"
+    "psubsh     %[g_vec],        %[g_vec],          %[temp]       \n\t"
+    "psrah      %[g_vec],        %[g_vec],          %[six]        \n\t"
+
+    "paddsh     %[r_vec],        %[y],              %[br]         \n\t"
+    "pmullh     %[temp],         %[v],              %[vr]         \n\t"
+    "psubsh     %[r_vec],        %[r_vec],          %[temp]       \n\t"
+    "psrah      %[r_vec],        %[r_vec],          %[six]        \n\t"
+
+    "packushb   %[r_vec],        %[b_vec],          %[r_vec]      \n\t"
+    "packushb   %[g_vec],        %[g_vec],          %[zero]       \n\t"
+    "punpcklbh  %[b_vec],        %[r_vec],          %[g_vec]      \n\t"
+    "punpckhbh  %[r_vec],        %[r_vec],          %[g_vec]      \n\t"
+    "punpcklhw  %[g_vec],        %[b_vec],          %[r_vec]      \n\t"
+    "punpckhhw  %[b_vec],        %[b_vec],          %[r_vec]      \n\t"
+
+    "psrlh      %[temp],         %[g_vec],          %[three]      \n\t"
+    "and        %[g_vec],        %[temp],           %[mask2]      \n\t"
+    "psrlw      %[temp],         %[temp],           %[seven]      \n\t"
+    "psrlw      %[r_vec],        %[mask1],          %[eight]      \n\t"
+    "and        %[r_vec],        %[temp],           %[r_vec]      \n\t"
+    "psubb      %[y],            %[eight],          %[three]      \n\t"//5
+    "psllw      %[r_vec],        %[r_vec],          %[y]          \n\t"
+    "or         %[g_vec],        %[g_vec],          %[r_vec]      \n\t"
+    "paddb      %[r_vec],        %[three],          %[six]        \n\t"
+    "psrlw      %[temp],         %[temp],           %[r_vec]      \n\t"
+    "and        %[r_vec],        %[temp],           %[mask2]      \n\t"
+    "paddb      %[temp],         %[three],          %[eight]      \n\t"
+    "psllw      %[r_vec],        %[r_vec],          %[temp]       \n\t"
+    "or         %[g_vec],        %[g_vec],          %[r_vec]      \n\t"
+
+    "psrlh      %[temp],         %[b_vec],          %[three]      \n\t"
+    "and        %[b_vec],        %[temp],           %[mask2]      \n\t"
+    "psrlw      %[temp],         %[temp],           %[seven]      \n\t"
+    "psrlw      %[r_vec],        %[mask1],          %[eight]      \n\t"
+    "and        %[r_vec],        %[temp],           %[r_vec]      \n\t"
+    "psubb      %[y],            %[eight],          %[three]      \n\t"//5
+    "psllw      %[r_vec],        %[r_vec],          %[y]          \n\t"
+    "or         %[b_vec],        %[b_vec],          %[r_vec]      \n\t"
+    "paddb      %[r_vec],        %[three],          %[six]        \n\t"
+    "psrlw      %[temp],         %[temp],           %[r_vec]      \n\t"
+    "and        %[r_vec],        %[temp],           %[mask2]      \n\t"
+    "paddb      %[temp],         %[three],          %[eight]      \n\t"
+    "psllw      %[r_vec],        %[r_vec],          %[temp]       \n\t"
+    "or         %[b_vec],        %[b_vec],          %[r_vec]      \n\t"
+
+    "punpcklhw  %[r_vec],        %[g_vec],          %[b_vec]      \n\t"
+    "punpckhhw  %[b_vec],        %[g_vec],          %[b_vec]      \n\t"
+    "punpcklhw  %[g_vec],        %[r_vec],          %[b_vec]      \n\t"
+
+    "gssdlc1    %[g_vec],        0x07(%[dst_rgb565])             \n\t"
+    "gssdrc1    %[g_vec],        0x00(%[dst_rgb565])             \n\t"
+
+    "daddiu     %[y_ptr],        %[y_ptr],          0x04          \n\t"
+	"daddiu     %[uv_ptr],       %[uv_ptr],         0x04          \n\t"
+    "daddiu     %[dst_rgb565],   %[dst_rgb565],     0x08          \n\t"
+    "daddi      %[width],        %[width],          -0x04         \n\t"
+    "bnez       %[width],        1b                               \n\t"
+
+    : [y]"=&f"(y),                         [u]"=&f"(u),
+      [v]"=&f"(v),
+      [b_vec]"=&f"(b_vec),                 [g_vec]"=&f"(g_vec),
+      [r_vec]"=&f"(r_vec),                 [temp]"=&f"(temp),
+      [ub]"=&f"(ub),                       [ug]"=&f"(ug),
+      [vg]"=&f"(vg),                       [vr]"=&f"(vr),
+      [bb]"=&f"(bb),                       [bg]"=&f"(bg),
+      [br]"=&f"(br),                       [yg]"=&f"(yg)
+    : [y_ptr]"r"(src_y),                   [uv_ptr]"r"(src_uv),
+      [dst_rgb565]"r"(dst_rgb565),
+      [yuvcons_ptr]"r"(yuvconstants),      [width]"r"(width),
+      [zero]"f"(0x00),                     [five]"f"(0x55),
+      [six]"f"(0x6),                       [mask1]"f"(0xff00ff00ff00ff00),
+      [ushu]"f"(0xA0),                     [vshu]"f"(0xf5),
+      [three]"f"(0x3),                     [mask2]"f"(0x1f0000001f),
+      [eight]"f"(0x8),                     [seven]"f"(0x7)
+    : "memory"
+  );
+}
+
+void YUY2ToARGBRow_MMI(const uint8_t* src_yuy2,
+                       uint8_t* rgb_buf,
+                       const struct YuvConstants* yuvconstants,
+                       int width) {
+  uint64_t y, u, v;
+  uint64_t b_vec, g_vec, r_vec, temp;
+  uint64_t ub,ug,vg,vr,bb,bg,br,yg;
+
+  __asm__ volatile(
+    "ldc1       %[yg],           0xc0(%[yuvcons_ptr])             \n\t"
+    "ldc1       %[bb],           0x60(%[yuvcons_ptr])             \n\t"
+    "ldc1       %[ub],           0x00(%[yuvcons_ptr])             \n\t"
+    "or         %[ub],           %[ub],             %[mask1]      \n\t"
+    "ldc1       %[bg],           0x80(%[yuvcons_ptr])             \n\t"
+    "ldc1       %[ug],           0x20(%[yuvcons_ptr])             \n\t"
+    "punpcklbh  %[ug],           %[ug],             %[zero]       \n\t"
+    "pshufh     %[ug],           %[ug],             %[zero]       \n\t"
+    "ldc1       %[vg],           0x20(%[yuvcons_ptr])             \n\t"
+    "punpcklbh  %[vg],           %[vg],             %[zero]       \n\t"
+    "pshufh     %[vg],           %[vg],             %[five]       \n\t"
+    "ldc1       %[br],           0xa0(%[yuvcons_ptr])             \n\t"
+    "ldc1       %[vr],           0x40(%[yuvcons_ptr])             \n\t"
+    "punpcklbh  %[vr],           %[vr],             %[zero]       \n\t"
+    "pshufh     %[vr],           %[vr],             %[five]       \n\t"
+    "or         %[vr],           %[vr],             %[mask1]      \n\t"
+
+    "1:                                                           \n\t"
+    "gsldlc1    %[y],            0x07(%[yuy2_ptr])                \n\t"
+    "gsldrc1    %[y],            0x00(%[yuy2_ptr])                \n\t"
+    "psrlh      %[temp],         %[y],              %[eight]      \n\t"
+    "pshufh     %[u],            %[temp],           %[ushu]       \n\t"
+    "pshufh     %[v],            %[temp],           %[vshu]       \n\t"
+
+    "psrlh      %[temp],         %[mask1],          %[eight]      \n\t"
+    "and        %[y],            %[y],              %[temp]       \n\t"
+    "psllh      %[temp],         %[y],              %[eight]      \n\t"
+    "or         %[y],            %[y],              %[temp]       \n\t"
+    "pmulhuh    %[y],            %[y],              %[yg]         \n\t"
+
+    "paddsh     %[b_vec],        %[y],              %[bb]         \n\t"
+    "pmullh     %[temp],         %[u],              %[ub]         \n\t"
+    "psubsh     %[b_vec],        %[b_vec],          %[temp]       \n\t"
+    "psrah      %[b_vec],        %[b_vec],          %[six]        \n\t"
+
+    "paddsh     %[g_vec],        %[y],              %[bg]         \n\t"
+    "pmullh     %[temp],         %[u],              %[ug]         \n\t"
+    "psubsh     %[g_vec],        %[g_vec],          %[temp]       \n\t"
+    "pmullh     %[temp],         %[v],              %[vg]         \n\t"
+    "psubsh     %[g_vec],        %[g_vec],          %[temp]       \n\t"
+    "psrah      %[g_vec],        %[g_vec],          %[six]        \n\t"
+
+    "paddsh     %[r_vec],        %[y],              %[br]         \n\t"
+    "pmullh     %[temp],         %[v],              %[vr]         \n\t"
+    "psubsh     %[r_vec],        %[r_vec],          %[temp]       \n\t"
+    "psrah      %[r_vec],        %[r_vec],          %[six]        \n\t"
+
+    "packushb   %[r_vec],        %[b_vec],          %[r_vec]      \n\t"
+    "packushb   %[g_vec],        %[g_vec],          %[zero]       \n\t"
+    "punpcklwd  %[g_vec],        %[g_vec],          %[alpha]      \n\t"
+    "punpcklbh  %[b_vec],        %[r_vec],          %[g_vec]      \n\t"
+    "punpckhbh  %[r_vec],        %[r_vec],          %[g_vec]      \n\t"
+    "punpcklhw  %[g_vec],        %[b_vec],          %[r_vec]      \n\t"
+    "punpckhhw  %[b_vec],        %[b_vec],          %[r_vec]      \n\t"
+
+    "gssdlc1    %[g_vec],        0x07(%[rgbbuf_ptr])              \n\t"
+    "gssdrc1    %[g_vec],        0x00(%[rgbbuf_ptr])              \n\t"
+    "gssdlc1    %[b_vec],        0x0f(%[rgbbuf_ptr])              \n\t"
+    "gssdrc1    %[b_vec],        0x08(%[rgbbuf_ptr])              \n\t"
+
+    "daddiu     %[yuy2_ptr],     %[yuy2_ptr],       0x08          \n\t"
+    "daddiu     %[rgbbuf_ptr],   %[rgbbuf_ptr],     0x10          \n\t"
+    "daddi      %[width],        %[width],          -0x04         \n\t"
+    "bnez       %[width],        1b                               \n\t"
+
+    : [y]"=&f"(y),                         [u]"=&f"(u),
+      [v]"=&f"(v),
+      [b_vec]"=&f"(b_vec),                 [g_vec]"=&f"(g_vec),
+      [r_vec]"=&f"(r_vec),                 [temp]"=&f"(temp),
+      [ub]"=&f"(ub),                       [ug]"=&f"(ug),
+      [vg]"=&f"(vg),                       [vr]"=&f"(vr),
+      [bb]"=&f"(bb),                       [bg]"=&f"(bg),
+      [br]"=&f"(br),                       [yg]"=&f"(yg)
+    : [yuy2_ptr]"r"(src_yuy2),             [rgbbuf_ptr]"r"(rgb_buf),
+      [yuvcons_ptr]"r"(yuvconstants),      [width]"r"(width),
+      [zero]"f"(0x00),                     [five]"f"(0x55),
+      [six]"f"(0x6),                       [mask1]"f"(0xff00ff00ff00ff00),
+      [ushu]"f"(0xA0),                     [vshu]"f"(0xf5),
+      [alpha]"f"(-1),                      [eight]"f"(0x8)
+    : "memory"
+  );
+}
+
+void UYVYToARGBRow_MMI(const uint8_t* src_uyvy,
+                       uint8_t* rgb_buf,
+                       const struct YuvConstants* yuvconstants,
+                       int width) {
+  uint64_t y, u, v;
+  uint64_t b_vec, g_vec, r_vec, temp;
+  uint64_t ub,ug,vg,vr,bb,bg,br,yg;
+
+  __asm__ volatile(
+    "ldc1       %[yg],           0xc0(%[yuvcons_ptr])             \n\t"
+    "ldc1       %[bb],           0x60(%[yuvcons_ptr])             \n\t"
+    "ldc1       %[ub],           0x00(%[yuvcons_ptr])             \n\t"
+    "or         %[ub],           %[ub],             %[mask1]      \n\t"
+    "ldc1       %[bg],           0x80(%[yuvcons_ptr])             \n\t"
+    "ldc1       %[ug],           0x20(%[yuvcons_ptr])             \n\t"
+    "punpcklbh  %[ug],           %[ug],             %[zero]       \n\t"
+    "pshufh     %[ug],           %[ug],             %[zero]       \n\t"
+    "ldc1       %[vg],           0x20(%[yuvcons_ptr])             \n\t"
+    "punpcklbh  %[vg],           %[vg],             %[zero]       \n\t"
+    "pshufh     %[vg],           %[vg],             %[five]       \n\t"
+    "ldc1       %[br],           0xa0(%[yuvcons_ptr])             \n\t"
+    "ldc1       %[vr],           0x40(%[yuvcons_ptr])             \n\t"
+    "punpcklbh  %[vr],           %[vr],             %[zero]       \n\t"
+    "pshufh     %[vr],           %[vr],             %[five]       \n\t"
+    "or         %[vr],           %[vr],             %[mask1]      \n\t"
+
+    "1:                                                           \n\t"
+    "gsldlc1    %[y],            0x07(%[uyvy_ptr])                \n\t"
+    "gsldrc1    %[y],            0x00(%[uyvy_ptr])                \n\t"
+    "psrlh      %[temp],         %[mask1],          %[eight]      \n\t"
+    "and        %[temp],         %[y],              %[temp]       \n\t"
+    "pshufh     %[u],            %[temp],           %[ushu]       \n\t"
+    "pshufh     %[v],            %[temp],           %[vshu]       \n\t"
+
+    "psrlh      %[y],            %[y],              %[eight]      \n\t"
+    "psllh      %[temp],         %[y],              %[eight]      \n\t"
+    "or         %[y],            %[y],              %[temp]       \n\t"
+    "pmulhuh    %[y],            %[y],              %[yg]         \n\t"
+
+    "paddsh     %[b_vec],        %[y],              %[bb]         \n\t"
+    "pmullh     %[temp],         %[u],              %[ub]         \n\t"
+    "psubsh     %[b_vec],        %[b_vec],          %[temp]       \n\t"
+    "psrah      %[b_vec],        %[b_vec],          %[six]        \n\t"
+
+    "paddsh     %[g_vec],        %[y],              %[bg]         \n\t"
+    "pmullh     %[temp],         %[u],              %[ug]         \n\t"
+    "psubsh     %[g_vec],        %[g_vec],          %[temp]       \n\t"
+    "pmullh     %[temp],         %[v],              %[vg]         \n\t"
+    "psubsh     %[g_vec],        %[g_vec],          %[temp]       \n\t"
+    "psrah      %[g_vec],        %[g_vec],          %[six]        \n\t"
+
+    "paddsh     %[r_vec],        %[y],              %[br]         \n\t"
+    "pmullh     %[temp],         %[v],              %[vr]         \n\t"
+    "psubsh     %[r_vec],        %[r_vec],          %[temp]       \n\t"
+    "psrah      %[r_vec],        %[r_vec],          %[six]        \n\t"
+
+    "packushb   %[r_vec],        %[b_vec],          %[r_vec]      \n\t"
+    "packushb   %[g_vec],        %[g_vec],          %[zero]       \n\t"
+    "punpcklwd  %[g_vec],        %[g_vec],          %[alpha]      \n\t"
+    "punpcklbh  %[b_vec],        %[r_vec],          %[g_vec]      \n\t"
+    "punpckhbh  %[r_vec],        %[r_vec],          %[g_vec]      \n\t"
+    "punpcklhw  %[g_vec],        %[b_vec],          %[r_vec]      \n\t"
+    "punpckhhw  %[b_vec],        %[b_vec],          %[r_vec]      \n\t"
+
+    "gssdlc1    %[g_vec],        0x07(%[rgbbuf_ptr])              \n\t"
+    "gssdrc1    %[g_vec],        0x00(%[rgbbuf_ptr])              \n\t"
+    "gssdlc1    %[b_vec],        0x0f(%[rgbbuf_ptr])              \n\t"
+    "gssdrc1    %[b_vec],        0x08(%[rgbbuf_ptr])              \n\t"
+
+    "daddiu     %[uyvy_ptr],     %[uyvy_ptr],       0x08          \n\t"
+    "daddiu     %[rgbbuf_ptr],   %[rgbbuf_ptr],     0x10          \n\t"
+    "daddi      %[width],        %[width],          -0x04         \n\t"
+    "bnez       %[width],        1b                               \n\t"
+
+    : [y]"=&f"(y),                         [u]"=&f"(u),
+      [v]"=&f"(v),
+      [b_vec]"=&f"(b_vec),                 [g_vec]"=&f"(g_vec),
+      [r_vec]"=&f"(r_vec),                 [temp]"=&f"(temp),
+      [ub]"=&f"(ub),                       [ug]"=&f"(ug),
+      [vg]"=&f"(vg),                       [vr]"=&f"(vr),
+      [bb]"=&f"(bb),                       [bg]"=&f"(bg),
+      [br]"=&f"(br),                       [yg]"=&f"(yg)
+    : [uyvy_ptr]"r"(src_uyvy),             [rgbbuf_ptr]"r"(rgb_buf),
+      [yuvcons_ptr]"r"(yuvconstants),      [width]"r"(width),
+      [zero]"f"(0x00),                     [five]"f"(0x55),
+      [six]"f"(0x6),                       [mask1]"f"(0xff00ff00ff00ff00),
+      [ushu]"f"(0xA0),                     [vshu]"f"(0xf5),
+      [alpha]"f"(-1),                      [eight]"f"(0x8)
+    : "memory"
+  );
+}
+
+void I422ToRGBARow_MMI(const uint8_t* src_y,
+                       const uint8_t* src_u,
+                       const uint8_t* src_v,
+                       uint8_t* rgb_buf,
+                       const struct YuvConstants* yuvconstants,
+                       int width) {
+  uint64_t y, u, v;
+  uint64_t b_vec, g_vec, r_vec, temp;
+  uint64_t ub,ug,vg,vr,bb,bg,br,yg;
+
+  __asm__ volatile(
+    "ldc1       %[yg],           0xc0(%[yuvcons_ptr])             \n\t"
+    "ldc1       %[bb],           0x60(%[yuvcons_ptr])             \n\t"
+    "ldc1       %[ub],           0x00(%[yuvcons_ptr])             \n\t"
+    "or         %[ub],           %[ub],             %[mask1]      \n\t"
+    "ldc1       %[bg],           0x80(%[yuvcons_ptr])             \n\t"
+    "ldc1       %[ug],           0x20(%[yuvcons_ptr])             \n\t"
+    "punpcklbh  %[ug],           %[ug],             %[zero]       \n\t"
+    "pshufh     %[ug],           %[ug],             %[zero]       \n\t"
+    "ldc1       %[vg],           0x20(%[yuvcons_ptr])             \n\t"
+    "punpcklbh  %[vg],           %[vg],             %[zero]       \n\t"
+    "pshufh     %[vg],           %[vg],             %[five]       \n\t"
+    "ldc1       %[br],           0xa0(%[yuvcons_ptr])             \n\t"
+    "ldc1       %[vr],           0x40(%[yuvcons_ptr])             \n\t"
+    "punpcklbh  %[vr],           %[vr],             %[zero]       \n\t"
+    "pshufh     %[vr],           %[vr],             %[five]       \n\t"
+    "or         %[vr],           %[vr],             %[mask1]      \n\t"
+
+    "1:                                                           \n\t"
+    "gslwlc1    %[y],            0x03(%[y_ptr])                   \n\t"
+    "gslwrc1    %[y],            0x00(%[y_ptr])                   \n\t"
+    "gslwlc1    %[u],            0x03(%[u_ptr])                   \n\t"
+    "gslwrc1    %[u],            0x00(%[u_ptr])                   \n\t"
+    "gslwlc1    %[v],            0x03(%[v_ptr])                   \n\t"
+    "gslwrc1    %[v],            0x00(%[v_ptr])                   \n\t"
+
+    "punpcklbh  %[y],            %[y],              %[y]          \n\t"
+    "pmulhuh    %[y],            %[y],              %[yg]         \n\t"
+
+    "punpcklbh  %[u],            %[u],              %[u]          \n\t"
+    "punpcklbh  %[u],            %[u],              %[zero]       \n\t"
+    "paddsh     %[b_vec],        %[y],              %[bb]         \n\t"
+    "pmullh     %[temp],         %[u],              %[ub]         \n\t"
+    "psubsh     %[b_vec],        %[b_vec],          %[temp]       \n\t"
+    "psrah      %[b_vec],        %[b_vec],          %[six]        \n\t"
+
+    "punpcklbh  %[v],            %[v],              %[v]          \n\t"
+    "punpcklbh  %[v],            %[v],              %[zero]       \n\t"
+    "paddsh     %[g_vec],        %[y],              %[bg]         \n\t"
+    "pmullh     %[temp],         %[u],              %[ug]         \n\t"
+    "psubsh     %[g_vec],        %[g_vec],          %[temp]       \n\t"
+    "pmullh     %[temp],         %[v],              %[vg]         \n\t"
+    "psubsh     %[g_vec],        %[g_vec],          %[temp]       \n\t"
+    "psrah      %[g_vec],        %[g_vec],          %[six]        \n\t"
+
+    "paddsh     %[r_vec],        %[y],              %[br]         \n\t"
+    "pmullh     %[temp],         %[v],              %[vr]         \n\t"
+    "psubsh     %[r_vec],        %[r_vec],          %[temp]       \n\t"
+    "psrah      %[r_vec],        %[r_vec],          %[six]        \n\t"
+
+    "packushb   %[r_vec],        %[b_vec],          %[r_vec]      \n\t"
+    "packushb   %[g_vec],        %[g_vec],          %[zero]       \n\t"
+    "punpcklwd  %[g_vec],        %[alpha],          %[g_vec]      \n\t"
+    "punpcklbh  %[b_vec],        %[g_vec],          %[r_vec]      \n\t"
+    "punpckhbh  %[r_vec],        %[g_vec],          %[r_vec]      \n\t"
+    "punpcklhw  %[g_vec],        %[b_vec],          %[r_vec]      \n\t"
+    "punpckhhw  %[b_vec],        %[b_vec],          %[r_vec]      \n\t"
+
+    "gssdlc1    %[g_vec],       0x07(%[rgbbuf_ptr])               \n\t"
+    "gssdrc1    %[g_vec],       0x00(%[rgbbuf_ptr])               \n\t"
+    "gssdlc1    %[b_vec],       0x0f(%[rgbbuf_ptr])               \n\t"
+    "gssdrc1    %[b_vec],       0x08(%[rgbbuf_ptr])               \n\t"
+
+    "daddiu     %[y_ptr],        %[y_ptr],          0x04          \n\t"
+    "daddiu     %[u_ptr],        %[u_ptr],          0x02          \n\t"
+    "daddiu     %[v_ptr],        %[v_ptr],          0x02          \n\t"
+    "daddiu     %[rgbbuf_ptr],   %[rgbbuf_ptr],     0x10          \n\t"
+    "daddi      %[width],        %[width],          -0x04         \n\t"
+    "bnez       %[width],        1b                               \n\t"
+
+    : [y]"=&f"(y),                         [u]"=&f"(u),
+      [v]"=&f"(v),
+      [b_vec]"=&f"(b_vec),                 [g_vec]"=&f"(g_vec),
+      [r_vec]"=&f"(r_vec),                 [temp]"=&f"(temp),
+      [ub]"=&f"(ub),                       [ug]"=&f"(ug),
+      [vg]"=&f"(vg),                       [vr]"=&f"(vr),
+      [bb]"=&f"(bb),                       [bg]"=&f"(bg),
+      [br]"=&f"(br),                       [yg]"=&f"(yg)
+    : [y_ptr]"r"(src_y),                   [u_ptr]"r"(src_u),
+      [v_ptr]"r"(src_v),                   [rgbbuf_ptr]"r"(rgb_buf),
+      [yuvcons_ptr]"r"(yuvconstants),      [width]"r"(width),
+      [zero]"f"(0x00),                     [five]"f"(0x55),
+      [six]"f"(0x6),                       [mask1]"f"(0xff00ff00ff00ff00),
+      [alpha]"f"(-1)
+    : "memory"
+  );
+}
+
+void ARGBSetRow_MMI(uint8_t* dst_argb, uint32_t v32, int width) {
+  __asm__ volatile (
+    "punpcklwd  %[v32],          %[v32],            %[v32]        \n\t"
+    "1:                                                           \n\t"
+    "gssdlc1    %[v32],          0x07(%[dst_ptr])                 \n\t"
+    "gssdrc1    %[v32],          0x00(%[dst_ptr])                 \n\t"
+    "gssdlc1    %[v32],          0x0f(%[dst_ptr])                 \n\t"
+    "gssdrc1    %[v32],          0x08(%[dst_ptr])                 \n\t"
+
+    "daddi      %[width],        %[width],         -0x04          \n\t"
+    "daddiu     %[dst_ptr],      %[dst_ptr],        0x10          \n\t"
+    "bnez       %[width],        1b                               \n\t"
+    : [v32]"+&f"(v32)
+    : [dst_ptr]"r"(dst_argb),           [width]"r"(width)
+    : "memory"
+  );
+}
+// clang-format on
+
+// 10 bit YUV to ARGB
+#endif  // !defined(LIBYUV_DISABLE_MMI) && defined(_MIPS_ARCH_LOONGSON3A)
+
+#ifdef __cplusplus
+}  // extern "C"
+}  // namespace libyuv
+#endif
diff --git a/3rdparty/libyuv/src/source/row_msa.cc b/3rdparty/libyuv/src/source/row_msa.cc
new file mode 100644
index 00000000..b7d5bb5e
--- /dev/null
+++ b/3rdparty/libyuv/src/source/row_msa.cc
@@ -0,0 +1,3597 @@
+/*
+ *  Copyright 2016 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include <string.h>
+
+#include "libyuv/row.h"
+
+// This module is for GCC MSA
+#if !defined(LIBYUV_DISABLE_MSA) && defined(__mips_msa)
+#include "libyuv/macros_msa.h"
+
+#ifdef __cplusplus
+namespace libyuv {
+extern "C" {
+#endif
+
+#define ALPHA_VAL (-1)
+
+// Fill YUV -> RGB conversion constants into vectors
+#define YUVTORGB_SETUP(yuvconst, ub, vr, ug, vg, yg, yb) \
+  {                                                      \
+    ub = __msa_fill_w(yuvconst->kUVToB[0]);              \
+    vr = __msa_fill_w(yuvconst->kUVToR[1]);              \
+    ug = __msa_fill_w(yuvconst->kUVToG[0]);              \
+    vg = __msa_fill_w(yuvconst->kUVToG[1]);              \
+    yg = __msa_fill_w(yuvconst->kYToRgb[0]);             \
+    yb = __msa_fill_w(yuvconst->kYBiasToRgb[0]);         \
+  }
+
+// Load YUV 422 pixel data
+#define READYUV422(psrc_y, psrc_u, psrc_v, out_y, out_u, out_v)    \
+  {                                                                \
+    uint64_t y_m;                                                  \
+    uint32_t u_m, v_m;                                             \
+    v4i32 zero_m = {0};                                            \
+    y_m = LD(psrc_y);                                              \
+    u_m = LW(psrc_u);                                              \
+    v_m = LW(psrc_v);                                              \
+    out_y = (v16u8)__msa_insert_d((v2i64)zero_m, 0, (int64_t)y_m); \
+    out_u = (v16u8)__msa_insert_w(zero_m, 0, (int32_t)u_m);        \
+    out_v = (v16u8)__msa_insert_w(zero_m, 0, (int32_t)v_m);        \
+  }
+
+// Clip input vector elements between 0 to 255
+#define CLIP_0TO255(in0, in1, in2, in3, in4, in5) \
+  {                                               \
+    v4i32 max_m = __msa_ldi_w(0xFF);              \
+                                                  \
+    in0 = __msa_maxi_s_w(in0, 0);                 \
+    in1 = __msa_maxi_s_w(in1, 0);                 \
+    in2 = __msa_maxi_s_w(in2, 0);                 \
+    in3 = __msa_maxi_s_w(in3, 0);                 \
+    in4 = __msa_maxi_s_w(in4, 0);                 \
+    in5 = __msa_maxi_s_w(in5, 0);                 \
+    in0 = __msa_min_s_w(max_m, in0);              \
+    in1 = __msa_min_s_w(max_m, in1);              \
+    in2 = __msa_min_s_w(max_m, in2);              \
+    in3 = __msa_min_s_w(max_m, in3);              \
+    in4 = __msa_min_s_w(max_m, in4);              \
+    in5 = __msa_min_s_w(max_m, in5);              \
+  }
+
+// Convert 8 pixels of YUV 420 to RGB.
+#define YUVTORGB(in_y, in_uv, ubvr, ugvg, yg, yb, out_b, out_g, out_r) \
+  {                                                                    \
+    v8i16 vec0_m, vec1_m;                                              \
+    v4i32 reg0_m, reg1_m, reg2_m, reg3_m, reg4_m;                      \
+    v4i32 reg5_m, reg6_m, reg7_m;                                      \
+    v16i8 temp_m, zero_m = {0};                                        \
+                                                                       \
+    vec0_m = (v8i16)__msa_ilvr_b((v16i8)in_y, (v16i8)in_y);            \
+    vec1_m = (v8i16)__msa_ilvr_b((v16i8)zero_m, (v16i8)in_uv);         \
+    reg0_m = (v4i32)__msa_ilvr_h((v8i16)zero_m, (v8i16)vec0_m);        \
+    reg1_m = (v4i32)__msa_ilvl_h((v8i16)zero_m, (v8i16)vec0_m);        \
+    vec1_m = (v8i16)__msa_subv_h(vec1_m, const_0x80);                  \
+    temp_m = (v16i8)__msa_clti_s_h(vec1_m, 0);                         \
+    reg2_m = (v4i32)__msa_ilvr_h((v8i16)temp_m, (v8i16)vec1_m);        \
+    reg3_m = (v4i32)__msa_ilvl_h((v8i16)temp_m, (v8i16)vec1_m);        \
+    reg0_m *= yg;                                                      \
+    reg1_m *= yg;                                                      \
+    reg2_m *= ubvr;                                                    \
+    reg3_m *= ubvr;                                                    \
+    reg0_m = __msa_srai_w(reg0_m, 16);                                 \
+    reg1_m = __msa_srai_w(reg1_m, 16);                                 \
+    reg0_m += yb;                                                      \
+    reg1_m += yb;                                                      \
+    reg4_m = __msa_dotp_s_w((v8i16)vec1_m, (v8i16)ugvg);               \
+    reg5_m = __msa_ilvev_w(reg2_m, reg2_m);                            \
+    reg6_m = __msa_ilvev_w(reg3_m, reg3_m);                            \
+    reg7_m = __msa_ilvr_w(reg4_m, reg4_m);                             \
+    reg2_m = __msa_ilvod_w(reg2_m, reg2_m);                            \
+    reg3_m = __msa_ilvod_w(reg3_m, reg3_m);                            \
+    reg4_m = __msa_ilvl_w(reg4_m, reg4_m);                             \
+    reg5_m = reg0_m + reg5_m;                                          \
+    reg6_m = reg1_m + reg6_m;                                          \
+    reg2_m = reg0_m + reg2_m;                                          \
+    reg3_m = reg1_m + reg3_m;                                          \
+    reg7_m = reg0_m - reg7_m;                                          \
+    reg4_m = reg1_m - reg4_m;                                          \
+    reg5_m = __msa_srai_w(reg5_m, 6);                                  \
+    reg6_m = __msa_srai_w(reg6_m, 6);                                  \
+    reg7_m = __msa_srai_w(reg7_m, 6);                                  \
+    reg4_m = __msa_srai_w(reg4_m, 6);                                  \
+    reg2_m = __msa_srai_w(reg2_m, 6);                                  \
+    reg3_m = __msa_srai_w(reg3_m, 6);                                  \
+    CLIP_0TO255(reg5_m, reg6_m, reg7_m, reg4_m, reg2_m, reg3_m);       \
+    out_b = __msa_pckev_h((v8i16)reg6_m, (v8i16)reg5_m);               \
+    out_g = __msa_pckev_h((v8i16)reg4_m, (v8i16)reg7_m);               \
+    out_r = __msa_pckev_h((v8i16)reg3_m, (v8i16)reg2_m);               \
+  }
+
+// Pack and Store 8 ARGB values.
+#define STOREARGB(in0, in1, in2, in3, pdst_argb)           \
+  {                                                        \
+    v8i16 vec0_m, vec1_m;                                  \
+    v16u8 dst0_m, dst1_m;                                  \
+    vec0_m = (v8i16)__msa_ilvev_b((v16i8)in1, (v16i8)in0); \
+    vec1_m = (v8i16)__msa_ilvev_b((v16i8)in3, (v16i8)in2); \
+    dst0_m = (v16u8)__msa_ilvr_h(vec1_m, vec0_m);          \
+    dst1_m = (v16u8)__msa_ilvl_h(vec1_m, vec0_m);          \
+    ST_UB2(dst0_m, dst1_m, pdst_argb, 16);                 \
+  }
+
+// Takes ARGB input and calculates Y.
+#define ARGBTOY(argb0, argb1, argb2, argb3, const0, const1, const2, shift, \
+                y_out)                                                     \
+  {                                                                        \
+    v16u8 vec0_m, vec1_m, vec2_m, vec3_m;                                  \
+    v8u16 reg0_m, reg1_m;                                                  \
+                                                                           \
+    vec0_m = (v16u8)__msa_pckev_h((v8i16)argb1, (v8i16)argb0);             \
+    vec1_m = (v16u8)__msa_pckev_h((v8i16)argb3, (v8i16)argb2);             \
+    vec2_m = (v16u8)__msa_pckod_h((v8i16)argb1, (v8i16)argb0);             \
+    vec3_m = (v16u8)__msa_pckod_h((v8i16)argb3, (v8i16)argb2);             \
+    reg0_m = __msa_dotp_u_h(vec0_m, const0);                               \
+    reg1_m = __msa_dotp_u_h(vec1_m, const0);                               \
+    reg0_m = __msa_dpadd_u_h(reg0_m, vec2_m, const1);                      \
+    reg1_m = __msa_dpadd_u_h(reg1_m, vec3_m, const1);                      \
+    reg0_m += const2;                                                      \
+    reg1_m += const2;                                                      \
+    reg0_m = (v8u16)__msa_srai_h((v8i16)reg0_m, shift);                    \
+    reg1_m = (v8u16)__msa_srai_h((v8i16)reg1_m, shift);                    \
+    y_out = (v16u8)__msa_pckev_b((v16i8)reg1_m, (v16i8)reg0_m);            \
+  }
+
+// Loads current and next row of ARGB input and averages it to calculate U and V
+#define READ_ARGB(s_ptr, t_ptr, argb0, argb1, argb2, argb3, const_0x0101) \
+  {                                                                       \
+    v16u8 src0_m, src1_m, src2_m, src3_m, src4_m, src5_m, src6_m, src7_m; \
+    v16u8 vec0_m, vec1_m, vec2_m, vec3_m, vec4_m, vec5_m, vec6_m, vec7_m; \
+    v8u16 reg0_m, reg1_m, reg2_m, reg3_m, reg4_m, reg5_m, reg6_m, reg7_m; \
+    v8u16 reg8_m, reg9_m;                                                 \
+                                                                          \
+    src0_m = (v16u8)__msa_ld_b((void*)s, 0);                              \
+    src1_m = (v16u8)__msa_ld_b((void*)s, 16);                             \
+    src2_m = (v16u8)__msa_ld_b((void*)s, 32);                             \
+    src3_m = (v16u8)__msa_ld_b((void*)s, 48);                             \
+    src4_m = (v16u8)__msa_ld_b((void*)t, 0);                              \
+    src5_m = (v16u8)__msa_ld_b((void*)t, 16);                             \
+    src6_m = (v16u8)__msa_ld_b((void*)t, 32);                             \
+    src7_m = (v16u8)__msa_ld_b((void*)t, 48);                             \
+    vec0_m = (v16u8)__msa_ilvr_b((v16i8)src0_m, (v16i8)src4_m);           \
+    vec1_m = (v16u8)__msa_ilvr_b((v16i8)src1_m, (v16i8)src5_m);           \
+    vec2_m = (v16u8)__msa_ilvr_b((v16i8)src2_m, (v16i8)src6_m);           \
+    vec3_m = (v16u8)__msa_ilvr_b((v16i8)src3_m, (v16i8)src7_m);           \
+    vec4_m = (v16u8)__msa_ilvl_b((v16i8)src0_m, (v16i8)src4_m);           \
+    vec5_m = (v16u8)__msa_ilvl_b((v16i8)src1_m, (v16i8)src5_m);           \
+    vec6_m = (v16u8)__msa_ilvl_b((v16i8)src2_m, (v16i8)src6_m);           \
+    vec7_m = (v16u8)__msa_ilvl_b((v16i8)src3_m, (v16i8)src7_m);           \
+    reg0_m = __msa_hadd_u_h(vec0_m, vec0_m);                              \
+    reg1_m = __msa_hadd_u_h(vec1_m, vec1_m);                              \
+    reg2_m = __msa_hadd_u_h(vec2_m, vec2_m);                              \
+    reg3_m = __msa_hadd_u_h(vec3_m, vec3_m);                              \
+    reg4_m = __msa_hadd_u_h(vec4_m, vec4_m);                              \
+    reg5_m = __msa_hadd_u_h(vec5_m, vec5_m);                              \
+    reg6_m = __msa_hadd_u_h(vec6_m, vec6_m);                              \
+    reg7_m = __msa_hadd_u_h(vec7_m, vec7_m);                              \
+    reg8_m = (v8u16)__msa_pckev_d((v2i64)reg4_m, (v2i64)reg0_m);          \
+    reg9_m = (v8u16)__msa_pckev_d((v2i64)reg5_m, (v2i64)reg1_m);          \
+    reg8_m += (v8u16)__msa_pckod_d((v2i64)reg4_m, (v2i64)reg0_m);         \
+    reg9_m += (v8u16)__msa_pckod_d((v2i64)reg5_m, (v2i64)reg1_m);         \
+    reg0_m = (v8u16)__msa_pckev_d((v2i64)reg6_m, (v2i64)reg2_m);          \
+    reg1_m = (v8u16)__msa_pckev_d((v2i64)reg7_m, (v2i64)reg3_m);          \
+    reg0_m += (v8u16)__msa_pckod_d((v2i64)reg6_m, (v2i64)reg2_m);         \
+    reg1_m += (v8u16)__msa_pckod_d((v2i64)reg7_m, (v2i64)reg3_m);         \
+    reg8_m += const_0x0101;                                               \
+    reg9_m += const_0x0101;                                               \
+    reg0_m += const_0x0101;                                               \
+    reg1_m += const_0x0101;                                               \
+    argb0 = (v8u16)__msa_srai_h((v8i16)reg8_m, 1);                        \
+    argb1 = (v8u16)__msa_srai_h((v8i16)reg9_m, 1);                        \
+    argb2 = (v8u16)__msa_srai_h((v8i16)reg0_m, 1);                        \
+    argb3 = (v8u16)__msa_srai_h((v8i16)reg1_m, 1);                        \
+  }
+
+#define ARGBTOUV(argb0, argb1, argb2, argb3, const0, const1, const2, const3, \
+                 shf0, shf1, shf2, shf3, shift, u_out, v_out)                \
+  {                                                                          \
+    v8u16 vec0_m, vec1_m, vec2_m, vec3_m, vec4_m, vec5_m, vec6_m, vec7_m;    \
+    v4u32 reg0_m, reg1_m, reg2_m, reg3_m;                                    \
+                                                                             \
+    vec0_m = (v8u16)__msa_vshf_h(shf0, (v16i8)argb1, (v16i8)argb0);          \
+    vec1_m = (v8u16)__msa_vshf_h(shf0, (v16i8)argb3, (v16i8)argb2);          \
+    vec2_m = (v8u16)__msa_vshf_h(shf1, (v16i8)argb1, (v16i8)argb0);          \
+    vec3_m = (v8u16)__msa_vshf_h(shf1, (v16i8)argb3, (v16i8)argb2);          \
+    vec4_m = (v8u16)__msa_vshf_h(shf2, (v16i8)argb1, (v16i8)argb0);          \
+    vec5_m = (v8u16)__msa_vshf_h(shf2, (v16i8)argb3, (v16i8)argb2);          \
+    vec6_m = (v8u16)__msa_vshf_h(shf3, (v16i8)argb1, (v16i8)argb0);          \
+    vec7_m = (v8u16)__msa_vshf_h(shf3, (v16i8)argb3, (v16i8)argb2);          \
+    reg0_m = __msa_dotp_u_w(vec0_m, const0);                                 \
+    reg1_m = __msa_dotp_u_w(vec1_m, const0);                                 \
+    reg2_m = __msa_dotp_u_w(vec4_m, const0);                                 \
+    reg3_m = __msa_dotp_u_w(vec5_m, const0);                                 \
+    reg0_m += const1;                                                        \
+    reg1_m += const1;                                                        \
+    reg2_m += const1;                                                        \
+    reg3_m += const1;                                                        \
+    reg0_m -= (v4u32)__msa_dotp_u_w(vec2_m, const2);                         \
+    reg1_m -= (v4u32)__msa_dotp_u_w(vec3_m, const2);                         \
+    reg2_m -= (v4u32)__msa_dotp_u_w(vec6_m, const3);                         \
+    reg3_m -= (v4u32)__msa_dotp_u_w(vec7_m, const3);                         \
+    reg0_m = __msa_srl_w(reg0_m, shift);                                     \
+    reg1_m = __msa_srl_w(reg1_m, shift);                                     \
+    reg2_m = __msa_srl_w(reg2_m, shift);                                     \
+    reg3_m = __msa_srl_w(reg3_m, shift);                                     \
+    u_out = (v8u16)__msa_pckev_h((v8i16)reg1_m, (v8i16)reg0_m);              \
+    v_out = (v8u16)__msa_pckev_h((v8i16)reg3_m, (v8i16)reg2_m);              \
+  }
+
+// Takes ARGB input and calculates U and V.
+#define ARGBTOUV_H(argb0, argb1, argb2, argb3, const0, const1, const2, const3, \
+                   shf0, shf1, shf2, shf3, v_out, u_out)                       \
+  {                                                                            \
+    v8u16 vec0_m, vec1_m, vec2_m, vec3_m, vec4_m, vec5_m, vec6_m, vec7_m;      \
+    v4u32 reg0_m, reg1_m, reg2_m, reg3_m;                                      \
+                                                                               \
+    vec0_m = __msa_vshf_h(shf0, (v16i8)argb1, (v16i8)argb0);                   \
+    vec1_m = __msa_vshf_h(shf0, (v16i8)argb3, (v16i8)argb2);                   \
+    vec2_m = __msa_vshf_h(shf1, (v16i8)argb1, (v16i8)argb0);                   \
+    vec3_m = __msa_vshf_h(shf1, (v16i8)argb3, (v16i8)argb2);                   \
+    vec4_m = __msa_vshf_h(shf2, (v16i8)argb1, (v16i8)argb0);                   \
+    vec5_m = __msa_vshf_h(shf2, (v16i8)argb3, (v16i8)argb2);                   \
+    vec6_m = __msa_vshf_h(shf3, (v16i8)argb1, (v16i8)argb0);                   \
+    vec7_m = __msa_vshf_h(shf3, (v16i8)argb3, (v16i8)argb2);                   \
+    reg0_m = __msa_dotp_u_w(vec0_m, const1);                                   \
+    reg1_m = __msa_dotp_u_w(vec1_m, const1);                                   \
+    reg2_m = __msa_dotp_u_w(vec4_m, const1);                                   \
+    reg3_m = __msa_dotp_u_w(vec5_m, const1);                                   \
+    reg0_m += (v4u32)const3;                                                   \
+    reg1_m += (v4u32)const3;                                                   \
+    reg2_m += (v4u32)const3;                                                   \
+    reg3_m += (v4u32)const3;                                                   \
+    reg0_m -= __msa_dotp_u_w(vec2_m, const0);                                  \
+    reg1_m -= __msa_dotp_u_w(vec3_m, const0);                                  \
+    reg2_m -= __msa_dotp_u_w(vec6_m, const2);                                  \
+    reg3_m -= __msa_dotp_u_w(vec7_m, const2);                                  \
+    u_out = (v16u8)__msa_pckev_h((v8i16)reg3_m, (v8i16)reg2_m);                \
+    v_out = (v16u8)__msa_pckev_h((v8i16)reg1_m, (v8i16)reg0_m);                \
+    u_out = (v16u8)__msa_pckod_b((v16i8)u_out, (v16i8)u_out);                  \
+    v_out = (v16u8)__msa_pckod_b((v16i8)v_out, (v16i8)v_out);                  \
+  }
+
+// Load I444 pixel data
+#define READI444(psrc_y, psrc_u, psrc_v, out_y, out_u, out_v) \
+  {                                                           \
+    uint64_t y_m, u_m, v_m;                                   \
+    v2i64 zero_m = {0};                                       \
+    y_m = LD(psrc_y);                                         \
+    u_m = LD(psrc_u);                                         \
+    v_m = LD(psrc_v);                                         \
+    out_y = (v16u8)__msa_insert_d(zero_m, 0, (int64_t)y_m);   \
+    out_u = (v16u8)__msa_insert_d(zero_m, 0, (int64_t)u_m);   \
+    out_v = (v16u8)__msa_insert_d(zero_m, 0, (int64_t)v_m);   \
+  }
+
+#define RGBTOUV(_tmpb, _tmpg, _tmpr, _nexb, _nexg, _nexr, _dst0) \
+  {                                                              \
+    v16u8 _tmp0, _tmp1, _tmp2, _tmp3, _tmp4, _tmp5;              \
+    v8i16 _reg0, _reg1, _reg2, _reg3, _reg4, _reg5;              \
+    _tmp0 = (v16u8)__msa_ilvev_b(_tmpb, _nexb);                  \
+    _tmp1 = (v16u8)__msa_ilvod_b(_tmpb, _nexb);                  \
+    _tmp2 = (v16u8)__msa_ilvev_b(_tmpg, _nexg);                  \
+    _tmp3 = (v16u8)__msa_ilvod_b(_tmpg, _nexg);                  \
+    _tmp4 = (v16u8)__msa_ilvev_b(_tmpr, _nexr);                  \
+    _tmp5 = (v16u8)__msa_ilvod_b(_tmpr, _nexr);                  \
+    _reg0 = (v8i16)__msa_hadd_u_h(_tmp0, _tmp0);                 \
+    _reg1 = (v8i16)__msa_hadd_u_h(_tmp1, _tmp1);                 \
+    _reg2 = (v8i16)__msa_hadd_u_h(_tmp2, _tmp2);                 \
+    _reg3 = (v8i16)__msa_hadd_u_h(_tmp3, _tmp3);                 \
+    _reg4 = (v8i16)__msa_hadd_u_h(_tmp4, _tmp4);                 \
+    _reg5 = (v8i16)__msa_hadd_u_h(_tmp5, _tmp5);                 \
+    _reg0 = (v8i16)__msa_aver_u_h(_reg0, _reg1);                 \
+    _reg2 = (v8i16)__msa_aver_u_h(_reg2, _reg3);                 \
+    _reg4 = (v8i16)__msa_aver_u_h(_reg4, _reg5);                 \
+    _reg1 = const_8080 + const_112 * _reg0;                      \
+    _reg3 = const_8080 + const_112 * _reg4;                      \
+    _reg1 = (v8i16)__msa_msubv_h(_reg1, const_74, _reg2);        \
+    _reg3 = (v8i16)__msa_msubv_h(_reg3, const_94, _reg2);        \
+    _reg1 = (v8i16)__msa_msubv_h(_reg1, const_38, _reg4);        \
+    _reg3 = (v8i16)__msa_msubv_h(_reg3, const_18, _reg0);        \
+    _dst0 = (v16u8)__msa_pckod_b(_reg3, _reg1);                  \
+  }
+
+void MirrorRow_MSA(const uint8_t* src, uint8_t* dst, int width) {
+  int x;
+  v16u8 src0, src1, src2, src3;
+  v16u8 dst0, dst1, dst2, dst3;
+  v16i8 shuffler = {15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0};
+  src += width - 64;
+
+  for (x = 0; x < width; x += 64) {
+    LD_UB4(src, 16, src3, src2, src1, src0);
+    VSHF_B2_UB(src3, src3, src2, src2, shuffler, shuffler, dst3, dst2);
+    VSHF_B2_UB(src1, src1, src0, src0, shuffler, shuffler, dst1, dst0);
+    ST_UB4(dst0, dst1, dst2, dst3, dst, 16);
+    dst += 64;
+    src -= 64;
+  }
+}
+
+void MirrorUVRow_MSA(const uint8_t* src_uv, uint8_t* dst_uv, int width) {
+  int x;
+  v8u16 src, dst;
+  v8u16 shuffler = {7, 6, 5, 4, 3, 2, 1, 0};
+  src_uv += (width - 8) << 1;
+  for (x = 0; x < width; x += 8) {
+    src = LD_UH(src_uv);
+    dst = __msa_vshf_h(shuffler, src, src);
+    ST_UH(dst, dst_uv);
+    src_uv -= 16;
+    dst_uv += 16;
+  }
+}
+
+void ARGBMirrorRow_MSA(const uint8_t* src, uint8_t* dst, int width) {
+  int x;
+  v16u8 src0, src1, src2, src3;
+  v16u8 dst0, dst1, dst2, dst3;
+  v16i8 shuffler = {12, 13, 14, 15, 8, 9, 10, 11, 4, 5, 6, 7, 0, 1, 2, 3};
+  src += width * 4 - 64;
+
+  for (x = 0; x < width; x += 16) {
+    LD_UB4(src, 16, src3, src2, src1, src0);
+    VSHF_B2_UB(src3, src3, src2, src2, shuffler, shuffler, dst3, dst2);
+    VSHF_B2_UB(src1, src1, src0, src0, shuffler, shuffler, dst1, dst0);
+    ST_UB4(dst0, dst1, dst2, dst3, dst, 16);
+    dst += 64;
+    src -= 64;
+  }
+}
+
+void I422ToYUY2Row_MSA(const uint8_t* src_y,
+                       const uint8_t* src_u,
+                       const uint8_t* src_v,
+                       uint8_t* dst_yuy2,
+                       int width) {
+  int x;
+  v16u8 src_u0, src_v0, src_y0, src_y1, vec_uv0, vec_uv1;
+  v16u8 dst_yuy2_0, dst_yuy2_1, dst_yuy2_2, dst_yuy2_3;
+
+  for (x = 0; x < width; x += 32) {
+    src_u0 = LD_UB(src_u);
+    src_v0 = LD_UB(src_v);
+    LD_UB2(src_y, 16, src_y0, src_y1);
+    ILVRL_B2_UB(src_v0, src_u0, vec_uv0, vec_uv1);
+    ILVRL_B2_UB(vec_uv0, src_y0, dst_yuy2_0, dst_yuy2_1);
+    ILVRL_B2_UB(vec_uv1, src_y1, dst_yuy2_2, dst_yuy2_3);
+    ST_UB4(dst_yuy2_0, dst_yuy2_1, dst_yuy2_2, dst_yuy2_3, dst_yuy2, 16);
+    src_u += 16;
+    src_v += 16;
+    src_y += 32;
+    dst_yuy2 += 64;
+  }
+}
+
+void I422ToUYVYRow_MSA(const uint8_t* src_y,
+                       const uint8_t* src_u,
+                       const uint8_t* src_v,
+                       uint8_t* dst_uyvy,
+                       int width) {
+  int x;
+  v16u8 src_u0, src_v0, src_y0, src_y1, vec_uv0, vec_uv1;
+  v16u8 dst_uyvy0, dst_uyvy1, dst_uyvy2, dst_uyvy3;
+
+  for (x = 0; x < width; x += 32) {
+    src_u0 = LD_UB(src_u);
+    src_v0 = LD_UB(src_v);
+    LD_UB2(src_y, 16, src_y0, src_y1);
+    ILVRL_B2_UB(src_v0, src_u0, vec_uv0, vec_uv1);
+    ILVRL_B2_UB(src_y0, vec_uv0, dst_uyvy0, dst_uyvy1);
+    ILVRL_B2_UB(src_y1, vec_uv1, dst_uyvy2, dst_uyvy3);
+    ST_UB4(dst_uyvy0, dst_uyvy1, dst_uyvy2, dst_uyvy3, dst_uyvy, 16);
+    src_u += 16;
+    src_v += 16;
+    src_y += 32;
+    dst_uyvy += 64;
+  }
+}
+
+void I422ToARGBRow_MSA(const uint8_t* src_y,
+                       const uint8_t* src_u,
+                       const uint8_t* src_v,
+                       uint8_t* dst_argb,
+                       const struct YuvConstants* yuvconstants,
+                       int width) {
+  int x;
+  v16u8 src0, src1, src2;
+  v8i16 vec0, vec1, vec2;
+  v4i32 vec_ub, vec_vr, vec_ug, vec_vg, vec_yg, vec_yb;
+  v4i32 vec_ubvr, vec_ugvg;
+  v16u8 alpha = (v16u8)__msa_ldi_b(ALPHA_VAL);
+  v8i16 const_0x80 = __msa_ldi_h(0x80);
+
+  YUVTORGB_SETUP(yuvconstants, vec_ub, vec_vr, vec_ug, vec_vg, vec_yg, vec_yb);
+  vec_ubvr = __msa_ilvr_w(vec_vr, vec_ub);
+  vec_ugvg = (v4i32)__msa_ilvev_h((v8i16)vec_vg, (v8i16)vec_ug);
+
+  for (x = 0; x < width; x += 8) {
+    READYUV422(src_y, src_u, src_v, src0, src1, src2);
+    src1 = (v16u8)__msa_ilvr_b((v16i8)src2, (v16i8)src1);
+    YUVTORGB(src0, src1, vec_ubvr, vec_ugvg, vec_yg, vec_yb, vec0, vec1, vec2);
+    STOREARGB(vec0, vec1, vec2, alpha, dst_argb);
+    src_y += 8;
+    src_u += 4;
+    src_v += 4;
+    dst_argb += 32;
+  }
+}
+
+void I422ToRGBARow_MSA(const uint8_t* src_y,
+                       const uint8_t* src_u,
+                       const uint8_t* src_v,
+                       uint8_t* dst_argb,
+                       const struct YuvConstants* yuvconstants,
+                       int width) {
+  int x;
+  v16u8 src0, src1, src2;
+  v8i16 vec0, vec1, vec2;
+  v4i32 vec_ub, vec_vr, vec_ug, vec_vg, vec_yg, vec_yb;
+  v4i32 vec_ubvr, vec_ugvg;
+  v16u8 alpha = (v16u8)__msa_ldi_b(ALPHA_VAL);
+  v8i16 const_0x80 = __msa_ldi_h(0x80);
+
+  YUVTORGB_SETUP(yuvconstants, vec_ub, vec_vr, vec_ug, vec_vg, vec_yg, vec_yb);
+  vec_ubvr = __msa_ilvr_w(vec_vr, vec_ub);
+  vec_ugvg = (v4i32)__msa_ilvev_h((v8i16)vec_vg, (v8i16)vec_ug);
+
+  for (x = 0; x < width; x += 8) {
+    READYUV422(src_y, src_u, src_v, src0, src1, src2);
+    src1 = (v16u8)__msa_ilvr_b((v16i8)src2, (v16i8)src1);
+    YUVTORGB(src0, src1, vec_ubvr, vec_ugvg, vec_yg, vec_yb, vec0, vec1, vec2);
+    STOREARGB(alpha, vec0, vec1, vec2, dst_argb);
+    src_y += 8;
+    src_u += 4;
+    src_v += 4;
+    dst_argb += 32;
+  }
+}
+
+void I422AlphaToARGBRow_MSA(const uint8_t* src_y,
+                            const uint8_t* src_u,
+                            const uint8_t* src_v,
+                            const uint8_t* src_a,
+                            uint8_t* dst_argb,
+                            const struct YuvConstants* yuvconstants,
+                            int width) {
+  int x;
+  int64_t data_a;
+  v16u8 src0, src1, src2, src3;
+  v8i16 vec0, vec1, vec2;
+  v4i32 vec_ub, vec_vr, vec_ug, vec_vg, vec_yg, vec_yb;
+  v4i32 vec_ubvr, vec_ugvg;
+  v4i32 zero = {0};
+  v8i16 const_0x80 = __msa_ldi_h(0x80);
+
+  YUVTORGB_SETUP(yuvconstants, vec_ub, vec_vr, vec_ug, vec_vg, vec_yg, vec_yb);
+  vec_ubvr = __msa_ilvr_w(vec_vr, vec_ub);
+  vec_ugvg = (v4i32)__msa_ilvev_h((v8i16)vec_vg, (v8i16)vec_ug);
+
+  for (x = 0; x < width; x += 8) {
+    data_a = LD(src_a);
+    READYUV422(src_y, src_u, src_v, src0, src1, src2);
+    src1 = (v16u8)__msa_ilvr_b((v16i8)src2, (v16i8)src1);
+    src3 = (v16u8)__msa_insert_d((v2i64)zero, 0, data_a);
+    YUVTORGB(src0, src1, vec_ubvr, vec_ugvg, vec_yg, vec_yb, vec0, vec1, vec2);
+    src3 = (v16u8)__msa_ilvr_b((v16i8)src3, (v16i8)src3);
+    STOREARGB(vec0, vec1, vec2, src3, dst_argb);
+    src_y += 8;
+    src_u += 4;
+    src_v += 4;
+    src_a += 8;
+    dst_argb += 32;
+  }
+}
+
+void I422ToRGB24Row_MSA(const uint8_t* src_y,
+                        const uint8_t* src_u,
+                        const uint8_t* src_v,
+                        uint8_t* dst_argb,
+                        const struct YuvConstants* yuvconstants,
+                        int32_t width) {
+  int x;
+  int64_t data_u, data_v;
+  v16u8 src0, src1, src2, src3, src4, dst0, dst1, dst2;
+  v8i16 vec0, vec1, vec2, vec3, vec4, vec5;
+  v4i32 vec_ub, vec_vr, vec_ug, vec_vg, vec_yg, vec_yb;
+  v4i32 vec_ubvr, vec_ugvg;
+  v16u8 reg0, reg1, reg2, reg3;
+  v2i64 zero = {0};
+  v8i16 const_0x80 = __msa_ldi_h(0x80);
+  v16i8 shuffler0 = {0, 1, 16, 2, 3, 17, 4, 5, 18, 6, 7, 19, 8, 9, 20, 10};
+  v16i8 shuffler1 = {0, 21, 1, 2, 22, 3, 4, 23, 5, 6, 24, 7, 8, 25, 9, 10};
+  v16i8 shuffler2 = {26, 6,  7,  27, 8,  9,  28, 10,
+                     11, 29, 12, 13, 30, 14, 15, 31};
+
+  YUVTORGB_SETUP(yuvconstants, vec_ub, vec_vr, vec_ug, vec_vg, vec_yg, vec_yb);
+  vec_ubvr = __msa_ilvr_w(vec_vr, vec_ub);
+  vec_ugvg = (v4i32)__msa_ilvev_h((v8i16)vec_vg, (v8i16)vec_ug);
+
+  for (x = 0; x < width; x += 16) {
+    src0 = (v16u8)__msa_ld_b((v16u8*)src_y, 0);
+    data_u = LD(src_u);
+    data_v = LD(src_v);
+    src1 = (v16u8)__msa_insert_d(zero, 0, data_u);
+    src2 = (v16u8)__msa_insert_d(zero, 0, data_v);
+    src1 = (v16u8)__msa_ilvr_b((v16i8)src2, (v16i8)src1);
+    src3 = (v16u8)__msa_sldi_b((v16i8)src0, (v16i8)src0, 8);
+    src4 = (v16u8)__msa_sldi_b((v16i8)src1, (v16i8)src1, 8);
+    YUVTORGB(src0, src1, vec_ubvr, vec_ugvg, vec_yg, vec_yb, vec0, vec1, vec2);
+    YUVTORGB(src3, src4, vec_ubvr, vec_ugvg, vec_yg, vec_yb, vec3, vec4, vec5);
+    reg0 = (v16u8)__msa_ilvev_b((v16i8)vec1, (v16i8)vec0);
+    reg2 = (v16u8)__msa_ilvev_b((v16i8)vec4, (v16i8)vec3);
+    reg3 = (v16u8)__msa_pckev_b((v16i8)vec5, (v16i8)vec2);
+    reg1 = (v16u8)__msa_sldi_b((v16i8)reg2, (v16i8)reg0, 11);
+    dst0 = (v16u8)__msa_vshf_b(shuffler0, (v16i8)reg3, (v16i8)reg0);
+    dst1 = (v16u8)__msa_vshf_b(shuffler1, (v16i8)reg3, (v16i8)reg1);
+    dst2 = (v16u8)__msa_vshf_b(shuffler2, (v16i8)reg3, (v16i8)reg2);
+    ST_UB2(dst0, dst1, dst_argb, 16);
+    ST_UB(dst2, (dst_argb + 32));
+    src_y += 16;
+    src_u += 8;
+    src_v += 8;
+    dst_argb += 48;
+  }
+}
+
+// TODO(fbarchard): Consider AND instead of shift to isolate 5 upper bits of R.
+void I422ToRGB565Row_MSA(const uint8_t* src_y,
+                         const uint8_t* src_u,
+                         const uint8_t* src_v,
+                         uint8_t* dst_rgb565,
+                         const struct YuvConstants* yuvconstants,
+                         int width) {
+  int x;
+  v16u8 src0, src1, src2, dst0;
+  v8i16 vec0, vec1, vec2;
+  v4i32 vec_ub, vec_vr, vec_ug, vec_vg, vec_yg, vec_yb;
+  v4i32 vec_ubvr, vec_ugvg;
+  v8i16 const_0x80 = __msa_ldi_h(0x80);
+
+  YUVTORGB_SETUP(yuvconstants, vec_ub, vec_vr, vec_ug, vec_vg, vec_yg, vec_yb);
+  vec_ubvr = __msa_ilvr_w(vec_vr, vec_ub);
+  vec_ugvg = (v4i32)__msa_ilvev_h((v8i16)vec_vg, (v8i16)vec_ug);
+
+  for (x = 0; x < width; x += 8) {
+    READYUV422(src_y, src_u, src_v, src0, src1, src2);
+    src1 = (v16u8)__msa_ilvr_b((v16i8)src2, (v16i8)src1);
+    YUVTORGB(src0, src1, vec_ubvr, vec_ugvg, vec_yg, vec_yb, vec0, vec1, vec2);
+    vec0 = __msa_srli_h(vec0, 3);
+    vec1 = __msa_srli_h(vec1, 2);
+    vec2 = __msa_srli_h(vec2, 3);
+    vec2 = __msa_slli_h(vec2, 11);
+    vec1 = __msa_slli_h(vec1, 5);
+    vec0 |= vec1;
+    dst0 = (v16u8)(vec2 | vec0);
+    ST_UB(dst0, dst_rgb565);
+    src_y += 8;
+    src_u += 4;
+    src_v += 4;
+    dst_rgb565 += 16;
+  }
+}
+
+// TODO(fbarchard): Consider AND instead of shift to isolate 4 upper bits of G.
+void I422ToARGB4444Row_MSA(const uint8_t* src_y,
+                           const uint8_t* src_u,
+                           const uint8_t* src_v,
+                           uint8_t* dst_argb4444,
+                           const struct YuvConstants* yuvconstants,
+                           int width) {
+  int x;
+  v16u8 src0, src1, src2, dst0;
+  v8i16 vec0, vec1, vec2;
+  v8u16 reg0, reg1, reg2;
+  v4i32 vec_ub, vec_vr, vec_ug, vec_vg, vec_yg, vec_yb;
+  v4i32 vec_ubvr, vec_ugvg;
+  v8u16 const_0xF000 = (v8u16)__msa_fill_h(0xF000);
+  v8u16 mask = (v8u16)__msa_fill_h(0x00F0);
+  v8i16 const_0x80 = __msa_ldi_h(0x80);
+
+  YUVTORGB_SETUP(yuvconstants, vec_ub, vec_vr, vec_ug, vec_vg, vec_yg, vec_yb);
+  vec_ubvr = __msa_ilvr_w(vec_vr, vec_ub);
+  vec_ugvg = (v4i32)__msa_ilvev_h((v8i16)vec_vg, (v8i16)vec_ug);
+
+  for (x = 0; x < width; x += 8) {
+    READYUV422(src_y, src_u, src_v, src0, src1, src2);
+    src1 = (v16u8)__msa_ilvr_b((v16i8)src2, (v16i8)src1);
+    YUVTORGB(src0, src1, vec_ubvr, vec_ugvg, vec_yg, vec_yb, vec0, vec1, vec2);
+    reg0 = (v8u16)__msa_srli_h(vec0, 4);
+    reg2 = (v8u16)__msa_srli_h(vec2, 4);
+    reg1 = (v8u16)__msa_and_v(vec1, mask);
+    reg2 = (v8u16)__msa_slli_h(reg2, 8);
+    reg1 |= const_0xF000;
+    reg0 |= reg2;
+    dst0 = (v16u8)(reg1 | reg0);
+    ST_UB(dst0, dst_argb4444);
+    src_y += 8;
+    src_u += 4;
+    src_v += 4;
+    dst_argb4444 += 16;
+  }
+}
+
+void I422ToARGB1555Row_MSA(const uint8_t* src_y,
+                           const uint8_t* src_u,
+                           const uint8_t* src_v,
+                           uint8_t* dst_argb1555,
+                           const struct YuvConstants* yuvconstants,
+                           int width) {
+  int x;
+  v16u8 src0, src1, src2, dst0;
+  v8i16 vec0, vec1, vec2;
+  v8u16 reg0, reg1, reg2;
+  v4i32 vec_ub, vec_vr, vec_ug, vec_vg, vec_yg, vec_yb;
+  v4i32 vec_ubvr, vec_ugvg;
+  v8u16 const_0x8000 = (v8u16)__msa_fill_h(0x8000);
+  v8i16 const_0x80 = __msa_ldi_h(0x80);
+
+  YUVTORGB_SETUP(yuvconstants, vec_ub, vec_vr, vec_ug, vec_vg, vec_yg, vec_yb);
+  vec_ubvr = __msa_ilvr_w(vec_vr, vec_ub);
+  vec_ugvg = (v4i32)__msa_ilvev_h((v8i16)vec_vg, (v8i16)vec_ug);
+
+  for (x = 0; x < width; x += 8) {
+    READYUV422(src_y, src_u, src_v, src0, src1, src2);
+    src1 = (v16u8)__msa_ilvr_b((v16i8)src2, (v16i8)src1);
+    YUVTORGB(src0, src1, vec_ubvr, vec_ugvg, vec_yg, vec_yb, vec0, vec1, vec2);
+    reg0 = (v8u16)__msa_srli_h(vec0, 3);
+    reg1 = (v8u16)__msa_srli_h(vec1, 3);
+    reg2 = (v8u16)__msa_srli_h(vec2, 3);
+    reg1 = (v8u16)__msa_slli_h((v8i16)reg1, 5);
+    reg2 = (v8u16)__msa_slli_h((v8i16)reg2, 10);
+    reg1 |= const_0x8000;
+    reg0 |= reg2;
+    dst0 = (v16u8)(reg1 | reg0);
+    ST_UB(dst0, dst_argb1555);
+    src_y += 8;
+    src_u += 4;
+    src_v += 4;
+    dst_argb1555 += 16;
+  }
+}
+
+void YUY2ToYRow_MSA(const uint8_t* src_yuy2, uint8_t* dst_y, int width) {
+  int x;
+  v16u8 src0, src1, src2, src3, dst0, dst1;
+
+  for (x = 0; x < width; x += 32) {
+    LD_UB4(src_yuy2, 16, src0, src1, src2, src3);
+    dst0 = (v16u8)__msa_pckev_b((v16i8)src1, (v16i8)src0);
+    dst1 = (v16u8)__msa_pckev_b((v16i8)src3, (v16i8)src2);
+    ST_UB2(dst0, dst1, dst_y, 16);
+    src_yuy2 += 64;
+    dst_y += 32;
+  }
+}
+
+void YUY2ToUVRow_MSA(const uint8_t* src_yuy2,
+                     int src_stride_yuy2,
+                     uint8_t* dst_u,
+                     uint8_t* dst_v,
+                     int width) {
+  const uint8_t* src_yuy2_next = src_yuy2 + src_stride_yuy2;
+  int x;
+  v16u8 src0, src1, src2, src3, src4, src5, src6, src7;
+  v16u8 vec0, vec1, dst0, dst1;
+
+  for (x = 0; x < width; x += 32) {
+    LD_UB4(src_yuy2, 16, src0, src1, src2, src3);
+    LD_UB4(src_yuy2_next, 16, src4, src5, src6, src7);
+    src0 = (v16u8)__msa_pckod_b((v16i8)src1, (v16i8)src0);
+    src1 = (v16u8)__msa_pckod_b((v16i8)src3, (v16i8)src2);
+    src2 = (v16u8)__msa_pckod_b((v16i8)src5, (v16i8)src4);
+    src3 = (v16u8)__msa_pckod_b((v16i8)src7, (v16i8)src6);
+    vec0 = __msa_aver_u_b(src0, src2);
+    vec1 = __msa_aver_u_b(src1, src3);
+    dst0 = (v16u8)__msa_pckev_b((v16i8)vec1, (v16i8)vec0);
+    dst1 = (v16u8)__msa_pckod_b((v16i8)vec1, (v16i8)vec0);
+    ST_UB(dst0, dst_u);
+    ST_UB(dst1, dst_v);
+    src_yuy2 += 64;
+    src_yuy2_next += 64;
+    dst_u += 16;
+    dst_v += 16;
+  }
+}
+
+void YUY2ToUV422Row_MSA(const uint8_t* src_yuy2,
+                        uint8_t* dst_u,
+                        uint8_t* dst_v,
+                        int width) {
+  int x;
+  v16u8 src0, src1, src2, src3, dst0, dst1;
+
+  for (x = 0; x < width; x += 32) {
+    LD_UB4(src_yuy2, 16, src0, src1, src2, src3);
+    src0 = (v16u8)__msa_pckod_b((v16i8)src1, (v16i8)src0);
+    src1 = (v16u8)__msa_pckod_b((v16i8)src3, (v16i8)src2);
+    dst0 = (v16u8)__msa_pckev_b((v16i8)src1, (v16i8)src0);
+    dst1 = (v16u8)__msa_pckod_b((v16i8)src1, (v16i8)src0);
+    ST_UB(dst0, dst_u);
+    ST_UB(dst1, dst_v);
+    src_yuy2 += 64;
+    dst_u += 16;
+    dst_v += 16;
+  }
+}
+
+void UYVYToYRow_MSA(const uint8_t* src_uyvy, uint8_t* dst_y, int width) {
+  int x;
+  v16u8 src0, src1, src2, src3, dst0, dst1;
+
+  for (x = 0; x < width; x += 32) {
+    LD_UB4(src_uyvy, 16, src0, src1, src2, src3);
+    dst0 = (v16u8)__msa_pckod_b((v16i8)src1, (v16i8)src0);
+    dst1 = (v16u8)__msa_pckod_b((v16i8)src3, (v16i8)src2);
+    ST_UB2(dst0, dst1, dst_y, 16);
+    src_uyvy += 64;
+    dst_y += 32;
+  }
+}
+
+void UYVYToUVRow_MSA(const uint8_t* src_uyvy,
+                     int src_stride_uyvy,
+                     uint8_t* dst_u,
+                     uint8_t* dst_v,
+                     int width) {
+  const uint8_t* src_uyvy_next = src_uyvy + src_stride_uyvy;
+  int x;
+  v16u8 src0, src1, src2, src3, src4, src5, src6, src7;
+  v16u8 vec0, vec1, dst0, dst1;
+
+  for (x = 0; x < width; x += 32) {
+    LD_UB4(src_uyvy, 16, src0, src1, src2, src3);
+    LD_UB4(src_uyvy_next, 16, src4, src5, src6, src7);
+    src0 = (v16u8)__msa_pckev_b((v16i8)src1, (v16i8)src0);
+    src1 = (v16u8)__msa_pckev_b((v16i8)src3, (v16i8)src2);
+    src2 = (v16u8)__msa_pckev_b((v16i8)src5, (v16i8)src4);
+    src3 = (v16u8)__msa_pckev_b((v16i8)src7, (v16i8)src6);
+    vec0 = __msa_aver_u_b(src0, src2);
+    vec1 = __msa_aver_u_b(src1, src3);
+    dst0 = (v16u8)__msa_pckev_b((v16i8)vec1, (v16i8)vec0);
+    dst1 = (v16u8)__msa_pckod_b((v16i8)vec1, (v16i8)vec0);
+    ST_UB(dst0, dst_u);
+    ST_UB(dst1, dst_v);
+    src_uyvy += 64;
+    src_uyvy_next += 64;
+    dst_u += 16;
+    dst_v += 16;
+  }
+}
+
+void UYVYToUV422Row_MSA(const uint8_t* src_uyvy,
+                        uint8_t* dst_u,
+                        uint8_t* dst_v,
+                        int width) {
+  int x;
+  v16u8 src0, src1, src2, src3, dst0, dst1;
+
+  for (x = 0; x < width; x += 32) {
+    LD_UB4(src_uyvy, 16, src0, src1, src2, src3);
+    src0 = (v16u8)__msa_pckev_b((v16i8)src1, (v16i8)src0);
+    src1 = (v16u8)__msa_pckev_b((v16i8)src3, (v16i8)src2);
+    dst0 = (v16u8)__msa_pckev_b((v16i8)src1, (v16i8)src0);
+    dst1 = (v16u8)__msa_pckod_b((v16i8)src1, (v16i8)src0);
+    ST_UB(dst0, dst_u);
+    ST_UB(dst1, dst_v);
+    src_uyvy += 64;
+    dst_u += 16;
+    dst_v += 16;
+  }
+}
+
+void ARGBToYRow_MSA(const uint8_t* src_argb, uint8_t* dst_y, int width) {
+  int x;
+  v16u8 src0, src1, src2, src3, vec0, vec1, vec2, vec3, dst0;
+  v8u16 reg0, reg1, reg2, reg3, reg4, reg5;
+  v16i8 zero = {0};
+  v8u16 const_0x19 = (v8u16)__msa_ldi_h(0x19);
+  v8u16 const_0x81 = (v8u16)__msa_ldi_h(0x81);
+  v8u16 const_0x42 = (v8u16)__msa_ldi_h(0x42);
+  v8u16 const_0x1080 = (v8u16)__msa_fill_h(0x1080);
+
+  for (x = 0; x < width; x += 16) {
+    src0 = (v16u8)__msa_ld_b((v16u8*)src_argb, 0);
+    src1 = (v16u8)__msa_ld_b((v16u8*)src_argb, 16);
+    src2 = (v16u8)__msa_ld_b((v16u8*)src_argb, 32);
+    src3 = (v16u8)__msa_ld_b((v16u8*)src_argb, 48);
+    vec0 = (v16u8)__msa_pckev_b((v16i8)src1, (v16i8)src0);
+    vec1 = (v16u8)__msa_pckev_b((v16i8)src3, (v16i8)src2);
+    vec2 = (v16u8)__msa_pckod_b((v16i8)src1, (v16i8)src0);
+    vec3 = (v16u8)__msa_pckod_b((v16i8)src3, (v16i8)src2);
+    reg0 = (v8u16)__msa_ilvev_b(zero, (v16i8)vec0);
+    reg1 = (v8u16)__msa_ilvev_b(zero, (v16i8)vec1);
+    reg2 = (v8u16)__msa_ilvev_b(zero, (v16i8)vec2);
+    reg3 = (v8u16)__msa_ilvev_b(zero, (v16i8)vec3);
+    reg4 = (v8u16)__msa_ilvod_b(zero, (v16i8)vec0);
+    reg5 = (v8u16)__msa_ilvod_b(zero, (v16i8)vec1);
+    reg0 *= const_0x19;
+    reg1 *= const_0x19;
+    reg2 *= const_0x81;
+    reg3 *= const_0x81;
+    reg4 *= const_0x42;
+    reg5 *= const_0x42;
+    reg0 += reg2;
+    reg1 += reg3;
+    reg0 += reg4;
+    reg1 += reg5;
+    reg0 += const_0x1080;
+    reg1 += const_0x1080;
+    reg0 = (v8u16)__msa_srai_h((v8i16)reg0, 8);
+    reg1 = (v8u16)__msa_srai_h((v8i16)reg1, 8);
+    dst0 = (v16u8)__msa_pckev_b((v16i8)reg1, (v16i8)reg0);
+    ST_UB(dst0, dst_y);
+    src_argb += 64;
+    dst_y += 16;
+  }
+}
+
+void ARGBToUVRow_MSA(const uint8_t* src_argb,
+                     int src_stride_argb,
+                     uint8_t* dst_u,
+                     uint8_t* dst_v,
+                     int width) {
+  int x;
+  const uint8_t* src_argb_next = src_argb + src_stride_argb;
+  v16u8 src0, src1, src2, src3, src4, src5, src6, src7;
+  v16u8 vec0, vec1, vec2, vec3, vec4, vec5, vec6, vec7, vec8, vec9;
+  v8u16 reg0, reg1, reg2, reg3, reg4, reg5, reg6, reg7, reg8, reg9;
+  v16u8 dst0, dst1;
+  v8u16 const_0x70 = (v8u16)__msa_ldi_h(0x38);
+  v8u16 const_0x4A = (v8u16)__msa_ldi_h(0x25);
+  v8u16 const_0x26 = (v8u16)__msa_ldi_h(0x13);
+  v8u16 const_0x5E = (v8u16)__msa_ldi_h(0x2f);
+  v8u16 const_0x12 = (v8u16)__msa_ldi_h(0x09);
+  v8u16 const_0x8080 = (v8u16)__msa_fill_h(0x8080);
+  v8u16 const_0x0001 = (v8u16)__msa_fill_h(0x0001);
+
+  for (x = 0; x < width; x += 32) {
+    src0 = (v16u8)__msa_ld_b((v16u8*)src_argb, 0);
+    src1 = (v16u8)__msa_ld_b((v16u8*)src_argb, 16);
+    src2 = (v16u8)__msa_ld_b((v16u8*)src_argb, 32);
+    src3 = (v16u8)__msa_ld_b((v16u8*)src_argb, 48);
+    src4 = (v16u8)__msa_ld_b((v16u8*)src_argb, 64);
+    src5 = (v16u8)__msa_ld_b((v16u8*)src_argb, 80);
+    src6 = (v16u8)__msa_ld_b((v16u8*)src_argb, 96);
+    src7 = (v16u8)__msa_ld_b((v16u8*)src_argb, 112);
+    vec0 = (v16u8)__msa_pckev_b((v16i8)src1, (v16i8)src0);
+    vec1 = (v16u8)__msa_pckev_b((v16i8)src3, (v16i8)src2);
+    vec2 = (v16u8)__msa_pckev_b((v16i8)src5, (v16i8)src4);
+    vec3 = (v16u8)__msa_pckev_b((v16i8)src7, (v16i8)src6);
+    vec4 = (v16u8)__msa_pckod_b((v16i8)src1, (v16i8)src0);
+    vec5 = (v16u8)__msa_pckod_b((v16i8)src3, (v16i8)src2);
+    vec6 = (v16u8)__msa_pckod_b((v16i8)src5, (v16i8)src4);
+    vec7 = (v16u8)__msa_pckod_b((v16i8)src7, (v16i8)src6);
+    vec8 = (v16u8)__msa_pckev_b((v16i8)vec1, (v16i8)vec0);
+    vec9 = (v16u8)__msa_pckev_b((v16i8)vec3, (v16i8)vec2);
+    vec4 = (v16u8)__msa_pckev_b((v16i8)vec5, (v16i8)vec4);
+    vec5 = (v16u8)__msa_pckev_b((v16i8)vec7, (v16i8)vec6);
+    vec0 = (v16u8)__msa_pckod_b((v16i8)vec1, (v16i8)vec0);
+    vec1 = (v16u8)__msa_pckod_b((v16i8)vec3, (v16i8)vec2);
+    reg0 = __msa_hadd_u_h(vec8, vec8);
+    reg1 = __msa_hadd_u_h(vec9, vec9);
+    reg2 = __msa_hadd_u_h(vec4, vec4);
+    reg3 = __msa_hadd_u_h(vec5, vec5);
+    reg4 = __msa_hadd_u_h(vec0, vec0);
+    reg5 = __msa_hadd_u_h(vec1, vec1);
+    src0 = (v16u8)__msa_ld_b((v16u8*)src_argb_next, 0);
+    src1 = (v16u8)__msa_ld_b((v16u8*)src_argb_next, 16);
+    src2 = (v16u8)__msa_ld_b((v16u8*)src_argb_next, 32);
+    src3 = (v16u8)__msa_ld_b((v16u8*)src_argb_next, 48);
+    src4 = (v16u8)__msa_ld_b((v16u8*)src_argb_next, 64);
+    src5 = (v16u8)__msa_ld_b((v16u8*)src_argb_next, 80);
+    src6 = (v16u8)__msa_ld_b((v16u8*)src_argb_next, 96);
+    src7 = (v16u8)__msa_ld_b((v16u8*)src_argb_next, 112);
+    vec0 = (v16u8)__msa_pckev_b((v16i8)src1, (v16i8)src0);
+    vec1 = (v16u8)__msa_pckev_b((v16i8)src3, (v16i8)src2);
+    vec2 = (v16u8)__msa_pckev_b((v16i8)src5, (v16i8)src4);
+    vec3 = (v16u8)__msa_pckev_b((v16i8)src7, (v16i8)src6);
+    vec4 = (v16u8)__msa_pckod_b((v16i8)src1, (v16i8)src0);
+    vec5 = (v16u8)__msa_pckod_b((v16i8)src3, (v16i8)src2);
+    vec6 = (v16u8)__msa_pckod_b((v16i8)src5, (v16i8)src4);
+    vec7 = (v16u8)__msa_pckod_b((v16i8)src7, (v16i8)src6);
+    vec8 = (v16u8)__msa_pckev_b((v16i8)vec1, (v16i8)vec0);
+    vec9 = (v16u8)__msa_pckev_b((v16i8)vec3, (v16i8)vec2);
+    vec4 = (v16u8)__msa_pckev_b((v16i8)vec5, (v16i8)vec4);
+    vec5 = (v16u8)__msa_pckev_b((v16i8)vec7, (v16i8)vec6);
+    vec0 = (v16u8)__msa_pckod_b((v16i8)vec1, (v16i8)vec0);
+    vec1 = (v16u8)__msa_pckod_b((v16i8)vec3, (v16i8)vec2);
+    reg0 += __msa_hadd_u_h(vec8, vec8);
+    reg1 += __msa_hadd_u_h(vec9, vec9);
+    reg2 += __msa_hadd_u_h(vec4, vec4);
+    reg3 += __msa_hadd_u_h(vec5, vec5);
+    reg4 += __msa_hadd_u_h(vec0, vec0);
+    reg5 += __msa_hadd_u_h(vec1, vec1);
+    reg0 += const_0x0001;
+    reg1 += const_0x0001;
+    reg2 += const_0x0001;
+    reg3 += const_0x0001;
+    reg4 += const_0x0001;
+    reg5 += const_0x0001;
+    reg0 = (v8u16)__msa_srai_h((v8i16)reg0, 1);
+    reg1 = (v8u16)__msa_srai_h((v8i16)reg1, 1);
+    reg2 = (v8u16)__msa_srai_h((v8i16)reg2, 1);
+    reg3 = (v8u16)__msa_srai_h((v8i16)reg3, 1);
+    reg4 = (v8u16)__msa_srai_h((v8i16)reg4, 1);
+    reg5 = (v8u16)__msa_srai_h((v8i16)reg5, 1);
+    reg6 = reg0 * const_0x70;
+    reg7 = reg1 * const_0x70;
+    reg8 = reg2 * const_0x4A;
+    reg9 = reg3 * const_0x4A;
+    reg6 += const_0x8080;
+    reg7 += const_0x8080;
+    reg8 += reg4 * const_0x26;
+    reg9 += reg5 * const_0x26;
+    reg0 *= const_0x12;
+    reg1 *= const_0x12;
+    reg2 *= const_0x5E;
+    reg3 *= const_0x5E;
+    reg4 *= const_0x70;
+    reg5 *= const_0x70;
+    reg2 += reg0;
+    reg3 += reg1;
+    reg4 += const_0x8080;
+    reg5 += const_0x8080;
+    reg6 -= reg8;
+    reg7 -= reg9;
+    reg4 -= reg2;
+    reg5 -= reg3;
+    reg6 = (v8u16)__msa_srai_h((v8i16)reg6, 8);
+    reg7 = (v8u16)__msa_srai_h((v8i16)reg7, 8);
+    reg4 = (v8u16)__msa_srai_h((v8i16)reg4, 8);
+    reg5 = (v8u16)__msa_srai_h((v8i16)reg5, 8);
+    dst0 = (v16u8)__msa_pckev_b((v16i8)reg7, (v16i8)reg6);
+    dst1 = (v16u8)__msa_pckev_b((v16i8)reg5, (v16i8)reg4);
+    ST_UB(dst0, dst_u);
+    ST_UB(dst1, dst_v);
+    src_argb += 128;
+    src_argb_next += 128;
+    dst_u += 16;
+    dst_v += 16;
+  }
+}
+
+void ARGBToRGB24Row_MSA(const uint8_t* src_argb, uint8_t* dst_rgb, int width) {
+  int x;
+  v16u8 src0, src1, src2, src3, dst0, dst1, dst2;
+  v16i8 shuffler0 = {0, 1, 2, 4, 5, 6, 8, 9, 10, 12, 13, 14, 16, 17, 18, 20};
+  v16i8 shuffler1 = {5,  6,  8,  9,  10, 12, 13, 14,
+                     16, 17, 18, 20, 21, 22, 24, 25};
+  v16i8 shuffler2 = {10, 12, 13, 14, 16, 17, 18, 20,
+                     21, 22, 24, 25, 26, 28, 29, 30};
+
+  for (x = 0; x < width; x += 16) {
+    src0 = (v16u8)__msa_ld_b((void*)src_argb, 0);
+    src1 = (v16u8)__msa_ld_b((void*)src_argb, 16);
+    src2 = (v16u8)__msa_ld_b((void*)src_argb, 32);
+    src3 = (v16u8)__msa_ld_b((void*)src_argb, 48);
+    dst0 = (v16u8)__msa_vshf_b(shuffler0, (v16i8)src1, (v16i8)src0);
+    dst1 = (v16u8)__msa_vshf_b(shuffler1, (v16i8)src2, (v16i8)src1);
+    dst2 = (v16u8)__msa_vshf_b(shuffler2, (v16i8)src3, (v16i8)src2);
+    ST_UB2(dst0, dst1, dst_rgb, 16);
+    ST_UB(dst2, (dst_rgb + 32));
+    src_argb += 64;
+    dst_rgb += 48;
+  }
+}
+
+void ARGBToRAWRow_MSA(const uint8_t* src_argb, uint8_t* dst_rgb, int width) {
+  int x;
+  v16u8 src0, src1, src2, src3, dst0, dst1, dst2;
+  v16i8 shuffler0 = {2, 1, 0, 6, 5, 4, 10, 9, 8, 14, 13, 12, 18, 17, 16, 22};
+  v16i8 shuffler1 = {5,  4,  10, 9,  8,  14, 13, 12,
+                     18, 17, 16, 22, 21, 20, 26, 25};
+  v16i8 shuffler2 = {8,  14, 13, 12, 18, 17, 16, 22,
+                     21, 20, 26, 25, 24, 30, 29, 28};
+
+  for (x = 0; x < width; x += 16) {
+    src0 = (v16u8)__msa_ld_b((void*)src_argb, 0);
+    src1 = (v16u8)__msa_ld_b((void*)src_argb, 16);
+    src2 = (v16u8)__msa_ld_b((void*)src_argb, 32);
+    src3 = (v16u8)__msa_ld_b((void*)src_argb, 48);
+    dst0 = (v16u8)__msa_vshf_b(shuffler0, (v16i8)src1, (v16i8)src0);
+    dst1 = (v16u8)__msa_vshf_b(shuffler1, (v16i8)src2, (v16i8)src1);
+    dst2 = (v16u8)__msa_vshf_b(shuffler2, (v16i8)src3, (v16i8)src2);
+    ST_UB2(dst0, dst1, dst_rgb, 16);
+    ST_UB(dst2, (dst_rgb + 32));
+    src_argb += 64;
+    dst_rgb += 48;
+  }
+}
+
+void ARGBToRGB565Row_MSA(const uint8_t* src_argb, uint8_t* dst_rgb, int width) {
+  int x;
+  v16u8 src0, src1, dst0;
+  v16u8 vec0, vec1, vec2, vec3, vec4, vec5, vec6, vec7;
+  v16i8 zero = {0};
+
+  for (x = 0; x < width; x += 8) {
+    src0 = (v16u8)__msa_ld_b((void*)src_argb, 0);
+    src1 = (v16u8)__msa_ld_b((void*)src_argb, 16);
+    vec0 = (v16u8)__msa_srai_b((v16i8)src0, 3);
+    vec1 = (v16u8)__msa_slli_b((v16i8)src0, 3);
+    vec2 = (v16u8)__msa_srai_b((v16i8)src0, 5);
+    vec4 = (v16u8)__msa_srai_b((v16i8)src1, 3);
+    vec5 = (v16u8)__msa_slli_b((v16i8)src1, 3);
+    vec6 = (v16u8)__msa_srai_b((v16i8)src1, 5);
+    vec1 = (v16u8)__msa_sldi_b(zero, (v16i8)vec1, 1);
+    vec2 = (v16u8)__msa_sldi_b(zero, (v16i8)vec2, 1);
+    vec5 = (v16u8)__msa_sldi_b(zero, (v16i8)vec5, 1);
+    vec6 = (v16u8)__msa_sldi_b(zero, (v16i8)vec6, 1);
+    vec3 = (v16u8)__msa_sldi_b(zero, (v16i8)src0, 2);
+    vec7 = (v16u8)__msa_sldi_b(zero, (v16i8)src1, 2);
+    vec0 = __msa_binsli_b(vec0, vec1, 2);
+    vec1 = __msa_binsli_b(vec2, vec3, 4);
+    vec4 = __msa_binsli_b(vec4, vec5, 2);
+    vec5 = __msa_binsli_b(vec6, vec7, 4);
+    vec0 = (v16u8)__msa_ilvev_b((v16i8)vec1, (v16i8)vec0);
+    vec4 = (v16u8)__msa_ilvev_b((v16i8)vec5, (v16i8)vec4);
+    dst0 = (v16u8)__msa_pckev_h((v8i16)vec4, (v8i16)vec0);
+    ST_UB(dst0, dst_rgb);
+    src_argb += 32;
+    dst_rgb += 16;
+  }
+}
+
+void ARGBToARGB1555Row_MSA(const uint8_t* src_argb,
+                           uint8_t* dst_rgb,
+                           int width) {
+  int x;
+  v16u8 src0, src1, dst0;
+  v16u8 vec0, vec1, vec2, vec3, vec4, vec5, vec6, vec7, vec8, vec9;
+  v16i8 zero = {0};
+
+  for (x = 0; x < width; x += 8) {
+    src0 = (v16u8)__msa_ld_b((void*)src_argb, 0);
+    src1 = (v16u8)__msa_ld_b((void*)src_argb, 16);
+    vec0 = (v16u8)__msa_srai_b((v16i8)src0, 3);
+    vec1 = (v16u8)__msa_slli_b((v16i8)src0, 2);
+    vec2 = (v16u8)__msa_srai_b((v16i8)vec0, 3);
+    vec1 = (v16u8)__msa_sldi_b(zero, (v16i8)vec1, 1);
+    vec2 = (v16u8)__msa_sldi_b(zero, (v16i8)vec2, 1);
+    vec3 = (v16u8)__msa_srai_b((v16i8)src0, 1);
+    vec5 = (v16u8)__msa_srai_b((v16i8)src1, 3);
+    vec6 = (v16u8)__msa_slli_b((v16i8)src1, 2);
+    vec7 = (v16u8)__msa_srai_b((v16i8)vec5, 3);
+    vec6 = (v16u8)__msa_sldi_b(zero, (v16i8)vec6, 1);
+    vec7 = (v16u8)__msa_sldi_b(zero, (v16i8)vec7, 1);
+    vec8 = (v16u8)__msa_srai_b((v16i8)src1, 1);
+    vec3 = (v16u8)__msa_sldi_b(zero, (v16i8)vec3, 2);
+    vec8 = (v16u8)__msa_sldi_b(zero, (v16i8)vec8, 2);
+    vec4 = (v16u8)__msa_sldi_b(zero, (v16i8)src0, 3);
+    vec9 = (v16u8)__msa_sldi_b(zero, (v16i8)src1, 3);
+    vec0 = __msa_binsli_b(vec0, vec1, 2);
+    vec5 = __msa_binsli_b(vec5, vec6, 2);
+    vec1 = __msa_binsli_b(vec2, vec3, 5);
+    vec6 = __msa_binsli_b(vec7, vec8, 5);
+    vec1 = __msa_binsli_b(vec1, vec4, 0);
+    vec6 = __msa_binsli_b(vec6, vec9, 0);
+    vec0 = (v16u8)__msa_ilvev_b((v16i8)vec1, (v16i8)vec0);
+    vec1 = (v16u8)__msa_ilvev_b((v16i8)vec6, (v16i8)vec5);
+    dst0 = (v16u8)__msa_pckev_h((v8i16)vec1, (v8i16)vec0);
+    ST_UB(dst0, dst_rgb);
+    src_argb += 32;
+    dst_rgb += 16;
+  }
+}
+
+void ARGBToARGB4444Row_MSA(const uint8_t* src_argb,
+                           uint8_t* dst_rgb,
+                           int width) {
+  int x;
+  v16u8 src0, src1;
+  v16u8 vec0, vec1;
+  v16u8 dst0;
+  v16i8 zero = {0};
+
+  for (x = 0; x < width; x += 8) {
+    src0 = (v16u8)__msa_ld_b((void*)src_argb, 0);
+    src1 = (v16u8)__msa_ld_b((void*)src_argb, 16);
+    vec0 = (v16u8)__msa_srai_b((v16i8)src0, 4);
+    vec1 = (v16u8)__msa_srai_b((v16i8)src1, 4);
+    src0 = (v16u8)__msa_sldi_b(zero, (v16i8)src0, 1);
+    src1 = (v16u8)__msa_sldi_b(zero, (v16i8)src1, 1);
+    vec0 = __msa_binsli_b(vec0, src0, 3);
+    vec1 = __msa_binsli_b(vec1, src1, 3);
+    dst0 = (v16u8)__msa_pckev_b((v16i8)vec1, (v16i8)vec0);
+    ST_UB(dst0, dst_rgb);
+    src_argb += 32;
+    dst_rgb += 16;
+  }
+}
+
+void ARGBToUV444Row_MSA(const uint8_t* src_argb,
+                        uint8_t* dst_u,
+                        uint8_t* dst_v,
+                        int32_t width) {
+  int32_t x;
+  v16u8 src0, src1, src2, src3, reg0, reg1, reg2, reg3, dst0, dst1;
+  v8u16 vec0, vec1, vec2, vec3, vec4, vec5, vec6, vec7;
+  v8u16 vec8, vec9, vec10, vec11;
+  v8u16 const_112 = (v8u16)__msa_ldi_h(112);
+  v8u16 const_74 = (v8u16)__msa_ldi_h(74);
+  v8u16 const_38 = (v8u16)__msa_ldi_h(38);
+  v8u16 const_94 = (v8u16)__msa_ldi_h(94);
+  v8u16 const_18 = (v8u16)__msa_ldi_h(18);
+  v8u16 const_32896 = (v8u16)__msa_fill_h(32896);
+  v16i8 zero = {0};
+
+  for (x = width; x > 0; x -= 16) {
+    src0 = (v16u8)__msa_ld_b((void*)src_argb, 0);
+    src1 = (v16u8)__msa_ld_b((void*)src_argb, 16);
+    src2 = (v16u8)__msa_ld_b((void*)src_argb, 32);
+    src3 = (v16u8)__msa_ld_b((void*)src_argb, 48);
+    reg0 = (v16u8)__msa_pckev_b((v16i8)src1, (v16i8)src0);
+    reg1 = (v16u8)__msa_pckev_b((v16i8)src3, (v16i8)src2);
+    reg2 = (v16u8)__msa_pckod_b((v16i8)src1, (v16i8)src0);
+    reg3 = (v16u8)__msa_pckod_b((v16i8)src3, (v16i8)src2);
+    src0 = (v16u8)__msa_pckev_b((v16i8)reg1, (v16i8)reg0);
+    src1 = (v16u8)__msa_pckev_b((v16i8)reg3, (v16i8)reg2);
+    src2 = (v16u8)__msa_pckod_b((v16i8)reg1, (v16i8)reg0);
+    vec0 = (v8u16)__msa_ilvr_b(zero, (v16i8)src0);
+    vec1 = (v8u16)__msa_ilvl_b(zero, (v16i8)src0);
+    vec2 = (v8u16)__msa_ilvr_b(zero, (v16i8)src1);
+    vec3 = (v8u16)__msa_ilvl_b(zero, (v16i8)src1);
+    vec4 = (v8u16)__msa_ilvr_b(zero, (v16i8)src2);
+    vec5 = (v8u16)__msa_ilvl_b(zero, (v16i8)src2);
+    vec10 = vec0 * const_18;
+    vec11 = vec1 * const_18;
+    vec8 = vec2 * const_94;
+    vec9 = vec3 * const_94;
+    vec6 = vec4 * const_112;
+    vec7 = vec5 * const_112;
+    vec0 *= const_112;
+    vec1 *= const_112;
+    vec2 *= const_74;
+    vec3 *= const_74;
+    vec4 *= const_38;
+    vec5 *= const_38;
+    vec8 += vec10;
+    vec9 += vec11;
+    vec6 += const_32896;
+    vec7 += const_32896;
+    vec0 += const_32896;
+    vec1 += const_32896;
+    vec2 += vec4;
+    vec3 += vec5;
+    vec0 -= vec2;
+    vec1 -= vec3;
+    vec6 -= vec8;
+    vec7 -= vec9;
+    vec0 = (v8u16)__msa_srai_h((v8i16)vec0, 8);
+    vec1 = (v8u16)__msa_srai_h((v8i16)vec1, 8);
+    vec6 = (v8u16)__msa_srai_h((v8i16)vec6, 8);
+    vec7 = (v8u16)__msa_srai_h((v8i16)vec7, 8);
+    dst0 = (v16u8)__msa_pckev_b((v16i8)vec1, (v16i8)vec0);
+    dst1 = (v16u8)__msa_pckev_b((v16i8)vec7, (v16i8)vec6);
+    ST_UB(dst0, dst_u);
+    ST_UB(dst1, dst_v);
+    src_argb += 64;
+    dst_u += 16;
+    dst_v += 16;
+  }
+}
+
+void ARGBMultiplyRow_MSA(const uint8_t* src_argb,
+                         const uint8_t* src_argb1,
+                         uint8_t* dst_argb,
+                         int width) {
+  int x;
+  v16u8 src0, src1, dst0;
+  v8u16 vec0, vec1, vec2, vec3;
+  v4u32 reg0, reg1, reg2, reg3;
+  v8i16 zero = {0};
+
+  for (x = 0; x < width; x += 4) {
+    src0 = (v16u8)__msa_ld_b((void*)src_argb, 0);
+    src1 = (v16u8)__msa_ld_b((void*)src_argb1, 0);
+    vec0 = (v8u16)__msa_ilvr_b((v16i8)src0, (v16i8)src0);
+    vec1 = (v8u16)__msa_ilvl_b((v16i8)src0, (v16i8)src0);
+    vec2 = (v8u16)__msa_ilvr_b((v16i8)zero, (v16i8)src1);
+    vec3 = (v8u16)__msa_ilvl_b((v16i8)zero, (v16i8)src1);
+    reg0 = (v4u32)__msa_ilvr_h(zero, (v8i16)vec0);
+    reg1 = (v4u32)__msa_ilvl_h(zero, (v8i16)vec0);
+    reg2 = (v4u32)__msa_ilvr_h(zero, (v8i16)vec1);
+    reg3 = (v4u32)__msa_ilvl_h(zero, (v8i16)vec1);
+    reg0 *= (v4u32)__msa_ilvr_h(zero, (v8i16)vec2);
+    reg1 *= (v4u32)__msa_ilvl_h(zero, (v8i16)vec2);
+    reg2 *= (v4u32)__msa_ilvr_h(zero, (v8i16)vec3);
+    reg3 *= (v4u32)__msa_ilvl_h(zero, (v8i16)vec3);
+    reg0 = (v4u32)__msa_srai_w((v4i32)reg0, 16);
+    reg1 = (v4u32)__msa_srai_w((v4i32)reg1, 16);
+    reg2 = (v4u32)__msa_srai_w((v4i32)reg2, 16);
+    reg3 = (v4u32)__msa_srai_w((v4i32)reg3, 16);
+    vec0 = (v8u16)__msa_pckev_h((v8i16)reg1, (v8i16)reg0);
+    vec1 = (v8u16)__msa_pckev_h((v8i16)reg3, (v8i16)reg2);
+    dst0 = (v16u8)__msa_pckev_b((v16i8)vec1, (v16i8)vec0);
+    ST_UB(dst0, dst_argb);
+    src_argb += 16;
+    src_argb1 += 16;
+    dst_argb += 16;
+  }
+}
+
+void ARGBAddRow_MSA(const uint8_t* src_argb,
+                    const uint8_t* src_argb1,
+                    uint8_t* dst_argb,
+                    int width) {
+  int x;
+  v16u8 src0, src1, src2, src3, dst0, dst1;
+
+  for (x = 0; x < width; x += 8) {
+    src0 = (v16u8)__msa_ld_b((void*)src_argb, 0);
+    src1 = (v16u8)__msa_ld_b((void*)src_argb, 16);
+    src2 = (v16u8)__msa_ld_b((void*)src_argb1, 0);
+    src3 = (v16u8)__msa_ld_b((void*)src_argb1, 16);
+    dst0 = __msa_adds_u_b(src0, src2);
+    dst1 = __msa_adds_u_b(src1, src3);
+    ST_UB2(dst0, dst1, dst_argb, 16);
+    src_argb += 32;
+    src_argb1 += 32;
+    dst_argb += 32;
+  }
+}
+
+void ARGBSubtractRow_MSA(const uint8_t* src_argb,
+                         const uint8_t* src_argb1,
+                         uint8_t* dst_argb,
+                         int width) {
+  int x;
+  v16u8 src0, src1, src2, src3, dst0, dst1;
+
+  for (x = 0; x < width; x += 8) {
+    src0 = (v16u8)__msa_ld_b((void*)src_argb, 0);
+    src1 = (v16u8)__msa_ld_b((void*)src_argb, 16);
+    src2 = (v16u8)__msa_ld_b((void*)src_argb1, 0);
+    src3 = (v16u8)__msa_ld_b((void*)src_argb1, 16);
+    dst0 = __msa_subs_u_b(src0, src2);
+    dst1 = __msa_subs_u_b(src1, src3);
+    ST_UB2(dst0, dst1, dst_argb, 16);
+    src_argb += 32;
+    src_argb1 += 32;
+    dst_argb += 32;
+  }
+}
+
+void ARGBAttenuateRow_MSA(const uint8_t* src_argb,
+                          uint8_t* dst_argb,
+                          int width) {
+  int x;
+  v16u8 src0, src1, dst0, dst1;
+  v8u16 vec0, vec1, vec2, vec3, vec4, vec5, vec6, vec7, vec8, vec9;
+  v4u32 reg0, reg1, reg2, reg3, reg4, reg5, reg6, reg7;
+  v8i16 zero = {0};
+  v16u8 mask = {0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 255};
+
+  for (x = 0; x < width; x += 8) {
+    src0 = (v16u8)__msa_ld_b((void*)src_argb, 0);
+    src1 = (v16u8)__msa_ld_b((void*)src_argb, 16);
+    vec0 = (v8u16)__msa_ilvr_b((v16i8)src0, (v16i8)src0);
+    vec1 = (v8u16)__msa_ilvl_b((v16i8)src0, (v16i8)src0);
+    vec2 = (v8u16)__msa_ilvr_b((v16i8)src1, (v16i8)src1);
+    vec3 = (v8u16)__msa_ilvl_b((v16i8)src1, (v16i8)src1);
+    vec4 = (v8u16)__msa_fill_h(vec0[3]);
+    vec5 = (v8u16)__msa_fill_h(vec0[7]);
+    vec6 = (v8u16)__msa_fill_h(vec1[3]);
+    vec7 = (v8u16)__msa_fill_h(vec1[7]);
+    vec4 = (v8u16)__msa_pckev_d((v2i64)vec5, (v2i64)vec4);
+    vec5 = (v8u16)__msa_pckev_d((v2i64)vec7, (v2i64)vec6);
+    vec6 = (v8u16)__msa_fill_h(vec2[3]);
+    vec7 = (v8u16)__msa_fill_h(vec2[7]);
+    vec8 = (v8u16)__msa_fill_h(vec3[3]);
+    vec9 = (v8u16)__msa_fill_h(vec3[7]);
+    vec6 = (v8u16)__msa_pckev_d((v2i64)vec7, (v2i64)vec6);
+    vec7 = (v8u16)__msa_pckev_d((v2i64)vec9, (v2i64)vec8);
+    reg0 = (v4u32)__msa_ilvr_h(zero, (v8i16)vec4);
+    reg1 = (v4u32)__msa_ilvl_h(zero, (v8i16)vec4);
+    reg2 = (v4u32)__msa_ilvr_h(zero, (v8i16)vec5);
+    reg3 = (v4u32)__msa_ilvl_h(zero, (v8i16)vec5);
+    reg4 = (v4u32)__msa_ilvr_h(zero, (v8i16)vec6);
+    reg5 = (v4u32)__msa_ilvl_h(zero, (v8i16)vec6);
+    reg6 = (v4u32)__msa_ilvr_h(zero, (v8i16)vec7);
+    reg7 = (v4u32)__msa_ilvl_h(zero, (v8i16)vec7);
+    reg0 *= (v4u32)__msa_ilvr_h(zero, (v8i16)vec0);
+    reg1 *= (v4u32)__msa_ilvl_h(zero, (v8i16)vec0);
+    reg2 *= (v4u32)__msa_ilvr_h(zero, (v8i16)vec1);
+    reg3 *= (v4u32)__msa_ilvl_h(zero, (v8i16)vec1);
+    reg4 *= (v4u32)__msa_ilvr_h(zero, (v8i16)vec2);
+    reg5 *= (v4u32)__msa_ilvl_h(zero, (v8i16)vec2);
+    reg6 *= (v4u32)__msa_ilvr_h(zero, (v8i16)vec3);
+    reg7 *= (v4u32)__msa_ilvl_h(zero, (v8i16)vec3);
+    reg0 = (v4u32)__msa_srai_w((v4i32)reg0, 24);
+    reg1 = (v4u32)__msa_srai_w((v4i32)reg1, 24);
+    reg2 = (v4u32)__msa_srai_w((v4i32)reg2, 24);
+    reg3 = (v4u32)__msa_srai_w((v4i32)reg3, 24);
+    reg4 = (v4u32)__msa_srai_w((v4i32)reg4, 24);
+    reg5 = (v4u32)__msa_srai_w((v4i32)reg5, 24);
+    reg6 = (v4u32)__msa_srai_w((v4i32)reg6, 24);
+    reg7 = (v4u32)__msa_srai_w((v4i32)reg7, 24);
+    vec0 = (v8u16)__msa_pckev_h((v8i16)reg1, (v8i16)reg0);
+    vec1 = (v8u16)__msa_pckev_h((v8i16)reg3, (v8i16)reg2);
+    vec2 = (v8u16)__msa_pckev_h((v8i16)reg5, (v8i16)reg4);
+    vec3 = (v8u16)__msa_pckev_h((v8i16)reg7, (v8i16)reg6);
+    dst0 = (v16u8)__msa_pckev_b((v16i8)vec1, (v16i8)vec0);
+    dst1 = (v16u8)__msa_pckev_b((v16i8)vec3, (v16i8)vec2);
+    dst0 = __msa_bmnz_v(dst0, src0, mask);
+    dst1 = __msa_bmnz_v(dst1, src1, mask);
+    ST_UB2(dst0, dst1, dst_argb, 16);
+    src_argb += 32;
+    dst_argb += 32;
+  }
+}
+
+void ARGBToRGB565DitherRow_MSA(const uint8_t* src_argb,
+                               uint8_t* dst_rgb,
+                               uint32_t dither4,
+                               int width) {
+  int x;
+  v16u8 src0, src1, dst0, vec0, vec1;
+  v8i16 vec_d0;
+  v8i16 reg0, reg1, reg2;
+  v16i8 zero = {0};
+  v8i16 max = __msa_ldi_h(0xFF);
+
+  vec_d0 = (v8i16)__msa_fill_w(dither4);
+  vec_d0 = (v8i16)__msa_ilvr_b(zero, (v16i8)vec_d0);
+
+  for (x = 0; x < width; x += 8) {
+    src0 = (v16u8)__msa_ld_b((void*)src_argb, 0);
+    src1 = (v16u8)__msa_ld_b((void*)src_argb, 16);
+    vec0 = (v16u8)__msa_pckev_b((v16i8)src1, (v16i8)src0);
+    vec1 = (v16u8)__msa_pckod_b((v16i8)src1, (v16i8)src0);
+    reg0 = (v8i16)__msa_ilvev_b(zero, (v16i8)vec0);
+    reg1 = (v8i16)__msa_ilvev_b(zero, (v16i8)vec1);
+    reg2 = (v8i16)__msa_ilvod_b(zero, (v16i8)vec0);
+    reg0 += vec_d0;
+    reg1 += vec_d0;
+    reg2 += vec_d0;
+    reg0 = __msa_maxi_s_h((v8i16)reg0, 0);
+    reg1 = __msa_maxi_s_h((v8i16)reg1, 0);
+    reg2 = __msa_maxi_s_h((v8i16)reg2, 0);
+    reg0 = __msa_min_s_h((v8i16)max, (v8i16)reg0);
+    reg1 = __msa_min_s_h((v8i16)max, (v8i16)reg1);
+    reg2 = __msa_min_s_h((v8i16)max, (v8i16)reg2);
+    reg0 = __msa_srai_h(reg0, 3);
+    reg2 = __msa_srai_h(reg2, 3);
+    reg1 = __msa_srai_h(reg1, 2);
+    reg2 = __msa_slli_h(reg2, 11);
+    reg1 = __msa_slli_h(reg1, 5);
+    reg0 |= reg1;
+    dst0 = (v16u8)(reg0 | reg2);
+    ST_UB(dst0, dst_rgb);
+    src_argb += 32;
+    dst_rgb += 16;
+  }
+}
+
+void ARGBShuffleRow_MSA(const uint8_t* src_argb,
+                        uint8_t* dst_argb,
+                        const uint8_t* shuffler,
+                        int width) {
+  int x;
+  v16u8 src0, src1, dst0, dst1;
+  v16i8 vec0;
+  v16i8 shuffler_vec = {0, 0, 0, 0, 4, 4, 4, 4, 8, 8, 8, 8, 12, 12, 12, 12};
+  int32_t val = LW((int32_t*)shuffler);
+
+  vec0 = (v16i8)__msa_fill_w(val);
+  shuffler_vec += vec0;
+
+  for (x = 0; x < width; x += 8) {
+    src0 = (v16u8)__msa_ld_b((v16u8*)src_argb, 0);
+    src1 = (v16u8)__msa_ld_b((v16u8*)src_argb, 16);
+    dst0 = (v16u8)__msa_vshf_b(shuffler_vec, (v16i8)src0, (v16i8)src0);
+    dst1 = (v16u8)__msa_vshf_b(shuffler_vec, (v16i8)src1, (v16i8)src1);
+    ST_UB2(dst0, dst1, dst_argb, 16);
+    src_argb += 32;
+    dst_argb += 32;
+  }
+}
+
+void ARGBShadeRow_MSA(const uint8_t* src_argb,
+                      uint8_t* dst_argb,
+                      int width,
+                      uint32_t value) {
+  int x;
+  v16u8 src0, dst0;
+  v8u16 vec0, vec1;
+  v4u32 reg0, reg1, reg2, reg3, rgba_scale;
+  v8i16 zero = {0};
+
+  rgba_scale[0] = value;
+  rgba_scale = (v4u32)__msa_ilvr_b((v16i8)rgba_scale, (v16i8)rgba_scale);
+  rgba_scale = (v4u32)__msa_ilvr_h(zero, (v8i16)rgba_scale);
+
+  for (x = 0; x < width; x += 4) {
+    src0 = (v16u8)__msa_ld_b((v16u8*)src_argb, 0);
+    vec0 = (v8u16)__msa_ilvr_b((v16i8)src0, (v16i8)src0);
+    vec1 = (v8u16)__msa_ilvl_b((v16i8)src0, (v16i8)src0);
+    reg0 = (v4u32)__msa_ilvr_h(zero, (v8i16)vec0);
+    reg1 = (v4u32)__msa_ilvl_h(zero, (v8i16)vec0);
+    reg2 = (v4u32)__msa_ilvr_h(zero, (v8i16)vec1);
+    reg3 = (v4u32)__msa_ilvl_h(zero, (v8i16)vec1);
+    reg0 *= rgba_scale;
+    reg1 *= rgba_scale;
+    reg2 *= rgba_scale;
+    reg3 *= rgba_scale;
+    reg0 = (v4u32)__msa_srai_w((v4i32)reg0, 24);
+    reg1 = (v4u32)__msa_srai_w((v4i32)reg1, 24);
+    reg2 = (v4u32)__msa_srai_w((v4i32)reg2, 24);
+    reg3 = (v4u32)__msa_srai_w((v4i32)reg3, 24);
+    vec0 = (v8u16)__msa_pckev_h((v8i16)reg1, (v8i16)reg0);
+    vec1 = (v8u16)__msa_pckev_h((v8i16)reg3, (v8i16)reg2);
+    dst0 = (v16u8)__msa_pckev_b((v16i8)vec1, (v16i8)vec0);
+    ST_UB(dst0, dst_argb);
+    src_argb += 16;
+    dst_argb += 16;
+  }
+}
+
+void ARGBGrayRow_MSA(const uint8_t* src_argb, uint8_t* dst_argb, int width) {
+  int x;
+  v16u8 src0, src1, vec0, vec1, dst0, dst1;
+  v8u16 reg0;
+  v16u8 const_0x4D = (v16u8)__msa_ldi_h(0x4D);
+  v16u8 const_0x961D = (v16u8)__msa_fill_h(0x961D);
+
+  for (x = 0; x < width; x += 8) {
+    src0 = (v16u8)__msa_ld_b((v16u8*)src_argb, 0);
+    src1 = (v16u8)__msa_ld_b((v16u8*)src_argb, 16);
+    vec0 = (v16u8)__msa_pckev_h((v8i16)src1, (v8i16)src0);
+    vec1 = (v16u8)__msa_pckod_h((v8i16)src1, (v8i16)src0);
+    reg0 = __msa_dotp_u_h(vec0, const_0x961D);
+    reg0 = __msa_dpadd_u_h(reg0, vec1, const_0x4D);
+    reg0 = (v8u16)__msa_srari_h((v8i16)reg0, 8);
+    vec0 = (v16u8)__msa_ilvev_b((v16i8)reg0, (v16i8)reg0);
+    vec1 = (v16u8)__msa_ilvod_b((v16i8)vec1, (v16i8)vec0);
+    dst0 = (v16u8)__msa_ilvr_b((v16i8)vec1, (v16i8)vec0);
+    dst1 = (v16u8)__msa_ilvl_b((v16i8)vec1, (v16i8)vec0);
+    ST_UB2(dst0, dst1, dst_argb, 16);
+    src_argb += 32;
+    dst_argb += 32;
+  }
+}
+
+void ARGBSepiaRow_MSA(uint8_t* dst_argb, int width) {
+  int x;
+  v16u8 src0, src1, dst0, dst1, vec0, vec1, vec2, vec3, vec4, vec5;
+  v8u16 reg0, reg1, reg2;
+  v16u8 const_0x4411 = (v16u8)__msa_fill_h(0x4411);
+  v16u8 const_0x23 = (v16u8)__msa_ldi_h(0x23);
+  v16u8 const_0x5816 = (v16u8)__msa_fill_h(0x5816);
+  v16u8 const_0x2D = (v16u8)__msa_ldi_h(0x2D);
+  v16u8 const_0x6218 = (v16u8)__msa_fill_h(0x6218);
+  v16u8 const_0x32 = (v16u8)__msa_ldi_h(0x32);
+  v8u16 const_0xFF = (v8u16)__msa_ldi_h(0xFF);
+
+  for (x = 0; x < width; x += 8) {
+    src0 = (v16u8)__msa_ld_b((v16u8*)dst_argb, 0);
+    src1 = (v16u8)__msa_ld_b((v16u8*)dst_argb, 16);
+    vec0 = (v16u8)__msa_pckev_h((v8i16)src1, (v8i16)src0);
+    vec1 = (v16u8)__msa_pckod_h((v8i16)src1, (v8i16)src0);
+    vec3 = (v16u8)__msa_pckod_b((v16i8)vec1, (v16i8)vec1);
+    reg0 = (v8u16)__msa_dotp_u_h(vec0, const_0x4411);
+    reg1 = (v8u16)__msa_dotp_u_h(vec0, const_0x5816);
+    reg2 = (v8u16)__msa_dotp_u_h(vec0, const_0x6218);
+    reg0 = (v8u16)__msa_dpadd_u_h(reg0, vec1, const_0x23);
+    reg1 = (v8u16)__msa_dpadd_u_h(reg1, vec1, const_0x2D);
+    reg2 = (v8u16)__msa_dpadd_u_h(reg2, vec1, const_0x32);
+    reg0 = (v8u16)__msa_srai_h((v8i16)reg0, 7);
+    reg1 = (v8u16)__msa_srai_h((v8i16)reg1, 7);
+    reg2 = (v8u16)__msa_srai_h((v8i16)reg2, 7);
+    reg1 = (v8u16)__msa_min_u_h((v8u16)reg1, const_0xFF);
+    reg2 = (v8u16)__msa_min_u_h((v8u16)reg2, const_0xFF);
+    vec0 = (v16u8)__msa_pckev_b((v16i8)reg0, (v16i8)reg0);
+    vec1 = (v16u8)__msa_pckev_b((v16i8)reg1, (v16i8)reg1);
+    vec2 = (v16u8)__msa_pckev_b((v16i8)reg2, (v16i8)reg2);
+    vec4 = (v16u8)__msa_ilvr_b((v16i8)vec2, (v16i8)vec0);
+    vec5 = (v16u8)__msa_ilvr_b((v16i8)vec3, (v16i8)vec1);
+    dst0 = (v16u8)__msa_ilvr_b((v16i8)vec5, (v16i8)vec4);
+    dst1 = (v16u8)__msa_ilvl_b((v16i8)vec5, (v16i8)vec4);
+    ST_UB2(dst0, dst1, dst_argb, 16);
+    dst_argb += 32;
+  }
+}
+
+void ARGB4444ToARGBRow_MSA(const uint8_t* src_argb4444,
+                           uint8_t* dst_argb,
+                           int width) {
+  int x;
+  v16u8 src0, src1;
+  v8u16 vec0, vec1, vec2, vec3;
+  v16u8 dst0, dst1, dst2, dst3;
+
+  for (x = 0; x < width; x += 16) {
+    src0 = (v16u8)__msa_ld_b((v16u8*)src_argb4444, 0);
+    src1 = (v16u8)__msa_ld_b((v16u8*)src_argb4444, 16);
+    vec0 = (v8u16)__msa_andi_b(src0, 0x0F);
+    vec1 = (v8u16)__msa_andi_b(src1, 0x0F);
+    vec2 = (v8u16)__msa_andi_b(src0, 0xF0);
+    vec3 = (v8u16)__msa_andi_b(src1, 0xF0);
+    vec0 |= (v8u16)__msa_slli_b((v16i8)vec0, 4);
+    vec1 |= (v8u16)__msa_slli_b((v16i8)vec1, 4);
+    vec2 |= (v8u16)__msa_srli_b((v16i8)vec2, 4);
+    vec3 |= (v8u16)__msa_srli_b((v16i8)vec3, 4);
+    dst0 = (v16u8)__msa_ilvr_b((v16i8)vec2, (v16i8)vec0);
+    dst1 = (v16u8)__msa_ilvl_b((v16i8)vec2, (v16i8)vec0);
+    dst2 = (v16u8)__msa_ilvr_b((v16i8)vec3, (v16i8)vec1);
+    dst3 = (v16u8)__msa_ilvl_b((v16i8)vec3, (v16i8)vec1);
+    ST_UB4(dst0, dst1, dst2, dst3, dst_argb, 16);
+    src_argb4444 += 32;
+    dst_argb += 64;
+  }
+}
+
+void ARGB1555ToARGBRow_MSA(const uint8_t* src_argb1555,
+                           uint8_t* dst_argb,
+                           int width) {
+  int x;
+  v8u16 src0, src1;
+  v8u16 vec0, vec1, vec2, vec3, vec4, vec5;
+  v16u8 reg0, reg1, reg2, reg3, reg4, reg5, reg6;
+  v16u8 dst0, dst1, dst2, dst3;
+  v8u16 const_0x1F = (v8u16)__msa_ldi_h(0x1F);
+
+  for (x = 0; x < width; x += 16) {
+    src0 = (v8u16)__msa_ld_h((void*)src_argb1555, 0);
+    src1 = (v8u16)__msa_ld_h((void*)src_argb1555, 16);
+    vec0 = src0 & const_0x1F;
+    vec1 = src1 & const_0x1F;
+    src0 = (v8u16)__msa_srli_h((v8i16)src0, 5);
+    src1 = (v8u16)__msa_srli_h((v8i16)src1, 5);
+    vec2 = src0 & const_0x1F;
+    vec3 = src1 & const_0x1F;
+    src0 = (v8u16)__msa_srli_h((v8i16)src0, 5);
+    src1 = (v8u16)__msa_srli_h((v8i16)src1, 5);
+    vec4 = src0 & const_0x1F;
+    vec5 = src1 & const_0x1F;
+    src0 = (v8u16)__msa_srli_h((v8i16)src0, 5);
+    src1 = (v8u16)__msa_srli_h((v8i16)src1, 5);
+    reg0 = (v16u8)__msa_pckev_b((v16i8)vec1, (v16i8)vec0);
+    reg1 = (v16u8)__msa_pckev_b((v16i8)vec3, (v16i8)vec2);
+    reg2 = (v16u8)__msa_pckev_b((v16i8)vec5, (v16i8)vec4);
+    reg3 = (v16u8)__msa_pckev_b((v16i8)src1, (v16i8)src0);
+    reg4 = (v16u8)__msa_slli_b((v16i8)reg0, 3);
+    reg5 = (v16u8)__msa_slli_b((v16i8)reg1, 3);
+    reg6 = (v16u8)__msa_slli_b((v16i8)reg2, 3);
+    reg4 |= (v16u8)__msa_srai_b((v16i8)reg0, 2);
+    reg5 |= (v16u8)__msa_srai_b((v16i8)reg1, 2);
+    reg6 |= (v16u8)__msa_srai_b((v16i8)reg2, 2);
+    reg3 = -reg3;
+    reg0 = (v16u8)__msa_ilvr_b((v16i8)reg6, (v16i8)reg4);
+    reg1 = (v16u8)__msa_ilvl_b((v16i8)reg6, (v16i8)reg4);
+    reg2 = (v16u8)__msa_ilvr_b((v16i8)reg3, (v16i8)reg5);
+    reg3 = (v16u8)__msa_ilvl_b((v16i8)reg3, (v16i8)reg5);
+    dst0 = (v16u8)__msa_ilvr_b((v16i8)reg2, (v16i8)reg0);
+    dst1 = (v16u8)__msa_ilvl_b((v16i8)reg2, (v16i8)reg0);
+    dst2 = (v16u8)__msa_ilvr_b((v16i8)reg3, (v16i8)reg1);
+    dst3 = (v16u8)__msa_ilvl_b((v16i8)reg3, (v16i8)reg1);
+    ST_UB4(dst0, dst1, dst2, dst3, dst_argb, 16);
+    src_argb1555 += 32;
+    dst_argb += 64;
+  }
+}
+
+void RGB565ToARGBRow_MSA(const uint8_t* src_rgb565,
+                         uint8_t* dst_argb,
+                         int width) {
+  int x;
+  v8u16 src0, src1, vec0, vec1, vec2, vec3, vec4, vec5;
+  v8u16 reg0, reg1, reg2, reg3, reg4, reg5;
+  v16u8 res0, res1, res2, res3, dst0, dst1, dst2, dst3;
+  v16u8 alpha = (v16u8)__msa_ldi_b(ALPHA_VAL);
+  v8u16 const_0x1F = (v8u16)__msa_ldi_h(0x1F);
+  v8u16 const_0x7E0 = (v8u16)__msa_fill_h(0x7E0);
+  v8u16 const_0xF800 = (v8u16)__msa_fill_h(0xF800);
+
+  for (x = 0; x < width; x += 16) {
+    src0 = (v8u16)__msa_ld_h((void*)src_rgb565, 0);
+    src1 = (v8u16)__msa_ld_h((void*)src_rgb565, 16);
+    vec0 = src0 & const_0x1F;
+    vec1 = src0 & const_0x7E0;
+    vec2 = src0 & const_0xF800;
+    vec3 = src1 & const_0x1F;
+    vec4 = src1 & const_0x7E0;
+    vec5 = src1 & const_0xF800;
+    reg0 = (v8u16)__msa_slli_h((v8i16)vec0, 3);
+    reg1 = (v8u16)__msa_srli_h((v8i16)vec1, 3);
+    reg2 = (v8u16)__msa_srli_h((v8i16)vec2, 8);
+    reg3 = (v8u16)__msa_slli_h((v8i16)vec3, 3);
+    reg4 = (v8u16)__msa_srli_h((v8i16)vec4, 3);
+    reg5 = (v8u16)__msa_srli_h((v8i16)vec5, 8);
+    reg0 |= (v8u16)__msa_srli_h((v8i16)vec0, 2);
+    reg1 |= (v8u16)__msa_srli_h((v8i16)vec1, 9);
+    reg2 |= (v8u16)__msa_srli_h((v8i16)vec2, 13);
+    reg3 |= (v8u16)__msa_srli_h((v8i16)vec3, 2);
+    reg4 |= (v8u16)__msa_srli_h((v8i16)vec4, 9);
+    reg5 |= (v8u16)__msa_srli_h((v8i16)vec5, 13);
+    res0 = (v16u8)__msa_ilvev_b((v16i8)reg2, (v16i8)reg0);
+    res1 = (v16u8)__msa_ilvev_b((v16i8)alpha, (v16i8)reg1);
+    res2 = (v16u8)__msa_ilvev_b((v16i8)reg5, (v16i8)reg3);
+    res3 = (v16u8)__msa_ilvev_b((v16i8)alpha, (v16i8)reg4);
+    dst0 = (v16u8)__msa_ilvr_b((v16i8)res1, (v16i8)res0);
+    dst1 = (v16u8)__msa_ilvl_b((v16i8)res1, (v16i8)res0);
+    dst2 = (v16u8)__msa_ilvr_b((v16i8)res3, (v16i8)res2);
+    dst3 = (v16u8)__msa_ilvl_b((v16i8)res3, (v16i8)res2);
+    ST_UB4(dst0, dst1, dst2, dst3, dst_argb, 16);
+    src_rgb565 += 32;
+    dst_argb += 64;
+  }
+}
+
+void RGB24ToARGBRow_MSA(const uint8_t* src_rgb24,
+                        uint8_t* dst_argb,
+                        int width) {
+  int x;
+  v16u8 src0, src1, src2;
+  v16u8 vec0, vec1, vec2;
+  v16u8 dst0, dst1, dst2, dst3;
+  v16u8 alpha = (v16u8)__msa_ldi_b(ALPHA_VAL);
+  v16i8 shuffler = {0, 1, 2, 16, 3, 4, 5, 17, 6, 7, 8, 18, 9, 10, 11, 19};
+
+  for (x = 0; x < width; x += 16) {
+    src0 = (v16u8)__msa_ld_b((void*)src_rgb24, 0);
+    src1 = (v16u8)__msa_ld_b((void*)src_rgb24, 16);
+    src2 = (v16u8)__msa_ld_b((void*)src_rgb24, 32);
+    vec0 = (v16u8)__msa_sldi_b((v16i8)src1, (v16i8)src0, 12);
+    vec1 = (v16u8)__msa_sldi_b((v16i8)src2, (v16i8)src1, 8);
+    vec2 = (v16u8)__msa_sldi_b((v16i8)src2, (v16i8)src2, 4);
+    dst0 = (v16u8)__msa_vshf_b(shuffler, (v16i8)alpha, (v16i8)src0);
+    dst1 = (v16u8)__msa_vshf_b(shuffler, (v16i8)alpha, (v16i8)vec0);
+    dst2 = (v16u8)__msa_vshf_b(shuffler, (v16i8)alpha, (v16i8)vec1);
+    dst3 = (v16u8)__msa_vshf_b(shuffler, (v16i8)alpha, (v16i8)vec2);
+    ST_UB4(dst0, dst1, dst2, dst3, dst_argb, 16);
+    src_rgb24 += 48;
+    dst_argb += 64;
+  }
+}
+
+void RAWToARGBRow_MSA(const uint8_t* src_raw, uint8_t* dst_argb, int width) {
+  int x;
+  v16u8 src0, src1, src2;
+  v16u8 vec0, vec1, vec2;
+  v16u8 dst0, dst1, dst2, dst3;
+  v16u8 alpha = (v16u8)__msa_ldi_b(ALPHA_VAL);
+  v16i8 mask = {2, 1, 0, 16, 5, 4, 3, 17, 8, 7, 6, 18, 11, 10, 9, 19};
+
+  for (x = 0; x < width; x += 16) {
+    src0 = (v16u8)__msa_ld_b((void*)src_raw, 0);
+    src1 = (v16u8)__msa_ld_b((void*)src_raw, 16);
+    src2 = (v16u8)__msa_ld_b((void*)src_raw, 32);
+    vec0 = (v16u8)__msa_sldi_b((v16i8)src1, (v16i8)src0, 12);
+    vec1 = (v16u8)__msa_sldi_b((v16i8)src2, (v16i8)src1, 8);
+    vec2 = (v16u8)__msa_sldi_b((v16i8)src2, (v16i8)src2, 4);
+    dst0 = (v16u8)__msa_vshf_b(mask, (v16i8)alpha, (v16i8)src0);
+    dst1 = (v16u8)__msa_vshf_b(mask, (v16i8)alpha, (v16i8)vec0);
+    dst2 = (v16u8)__msa_vshf_b(mask, (v16i8)alpha, (v16i8)vec1);
+    dst3 = (v16u8)__msa_vshf_b(mask, (v16i8)alpha, (v16i8)vec2);
+    ST_UB4(dst0, dst1, dst2, dst3, dst_argb, 16);
+    src_raw += 48;
+    dst_argb += 64;
+  }
+}
+
+void ARGB1555ToYRow_MSA(const uint8_t* src_argb1555,
+                        uint8_t* dst_y,
+                        int width) {
+  int x;
+  v16u8 src0, src1, tmp0, tmp1, tmpb, tmpg, tmpr;
+  v16u8 reg0, reg1, reg2, dst;
+  v8i16 tmpr_l, tmpr_r, tmpg_l, tmpg_r, tmpb_l, tmpb_r;
+  v8i16 res0, res1;
+  v8i16 const_66 = (v8i16)__msa_ldi_h(66);
+  v8i16 const_129 = (v8i16)__msa_ldi_h(129);
+  v8i16 const_25 = (v8i16)__msa_ldi_h(25);
+  v8u16 const_1080 = (v8u16)__msa_fill_h(0x1080);
+  v16u8 zero = (v16u8)__msa_ldi_b(0);
+
+  for (x = 0; x < width; x += 16) {
+    src0 = (v16u8)__msa_ld_b((void*)src_argb1555, 0);
+    src1 = (v16u8)__msa_ld_b((void*)src_argb1555, 16);
+    tmp0 = (v16u8)__msa_pckev_b(src1, src0);
+    tmp1 = (v16u8)__msa_pckod_b(src1, src0);
+    tmpb = (v16u8)__msa_andi_b(tmp0, 0x1F);
+    tmpg = (v16u8)__msa_srli_b(tmp0, 5);
+    reg0 = (v16u8)__msa_andi_b(tmp1, 0x03);
+    reg0 = (v16u8)__msa_slli_b(reg0, 3);
+    tmpg = (v16u8)__msa_or_v(tmpg, reg0);
+    reg1 = (v16u8)__msa_andi_b(tmp1, 0x7C);
+    tmpr = (v16u8)__msa_srli_b(reg1, 2);
+    reg0 = (v16u8)__msa_slli_b(tmpb, 3);
+    reg1 = (v16u8)__msa_slli_b(tmpg, 3);
+    reg2 = (v16u8)__msa_slli_b(tmpr, 3);
+    tmpb = (v16u8)__msa_srli_b(tmpb, 2);
+    tmpg = (v16u8)__msa_srli_b(tmpg, 2);
+    tmpr = (v16u8)__msa_srli_b(tmpr, 2);
+    tmpb = (v16u8)__msa_or_v(reg0, tmpb);
+    tmpg = (v16u8)__msa_or_v(reg1, tmpg);
+    tmpr = (v16u8)__msa_or_v(reg2, tmpr);
+    tmpb_r = (v8i16)__msa_ilvr_b(zero, tmpb);
+    tmpb_l = (v8i16)__msa_ilvl_b(zero, tmpb);
+    tmpg_r = (v8i16)__msa_ilvr_b(zero, tmpg);
+    tmpg_l = (v8i16)__msa_ilvl_b(zero, tmpg);
+    tmpr_r = (v8i16)__msa_ilvr_b(zero, tmpr);
+    tmpr_l = (v8i16)__msa_ilvl_b(zero, tmpr);
+    res0 = const_1080 + const_25 * tmpb_r;
+    res1 = const_1080 + const_25 * tmpb_l;
+    res0 += const_129 * tmpg_r;
+    res1 += const_129 * tmpg_l;
+    res0 += const_66 * tmpr_r;
+    res1 += const_66 * tmpr_l;
+    dst = (v16u8)__msa_pckod_b(res1, res0);
+    ST_UB(dst, dst_y);
+    src_argb1555 += 32;
+    dst_y += 16;
+  }
+}
+
+void RGB565ToYRow_MSA(const uint8_t* src_rgb565, uint8_t* dst_y, int width) {
+  int x;
+  v16u8 src0, src1, tmp0, tmp1, tmpb, tmpg, tmpr;
+  v16u8 reg0, reg1, dst;
+  v8i16 tmpr_l, tmpr_r, tmpg_l, tmpg_r, tmpb_l, tmpb_r;
+  v8i16 res0, res1;
+  v8i16 const_66 = (v8i16)__msa_ldi_h(66);
+  v8i16 const_129 = (v8i16)__msa_ldi_h(129);
+  v8i16 const_25 = (v8i16)__msa_ldi_h(25);
+  v8i16 const_1080 = (v8i16)__msa_fill_h(0x1080);
+  v16u8 zero = __msa_ldi_b(0);
+
+  for (x = 0; x < width; x += 16) {
+    src0 = (v16u8)__msa_ld_b((void*)src_rgb565, 0);
+    src1 = (v16u8)__msa_ld_b((void*)src_rgb565, 16);
+    tmp0 = (v16u8)__msa_pckev_b(src1, src0);
+    tmp1 = (v16u8)__msa_pckod_b(src1, src0);
+    tmpb = (v16u8)__msa_andi_b(tmp0, 0x1F);
+    tmpr = (v16u8)__msa_andi_b(tmp1, 0xF8);
+    reg1 = (v16u8)__msa_andi_b(tmp1, 0x07);
+    reg0 = (v16u8)__msa_srli_b(tmp0, 5);
+    reg1 = (v16u8)__msa_slli_b(reg1, 3);
+    tmpg = (v16u8)__msa_or_v(reg1, reg0);
+    reg0 = (v16u8)__msa_slli_b(tmpb, 3);
+    reg1 = (v16u8)__msa_srli_b(tmpb, 2);
+    tmpb = (v16u8)__msa_or_v(reg1, reg0);
+    reg0 = (v16u8)__msa_slli_b(tmpg, 2);
+    reg1 = (v16u8)__msa_srli_b(tmpg, 4);
+    tmpg = (v16u8)__msa_or_v(reg1, reg0);
+    reg0 = (v16u8)__msa_srli_b(tmpr, 5);
+    tmpr = (v16u8)__msa_or_v(tmpr, reg0);
+    tmpb_r = (v8i16)__msa_ilvr_b(zero, tmpb);
+    tmpb_l = (v8i16)__msa_ilvl_b(zero, tmpb);
+    tmpg_r = (v8i16)__msa_ilvr_b(zero, tmpg);
+    tmpg_l = (v8i16)__msa_ilvl_b(zero, tmpg);
+    tmpr_r = (v8i16)__msa_ilvr_b(zero, tmpr);
+    tmpr_l = (v8i16)__msa_ilvl_b(zero, tmpr);
+    res0 = const_1080 + const_25 * tmpb_r;
+    res1 = const_1080 + const_25 * tmpb_l;
+    res0 += const_129 * tmpg_r;
+    res1 += const_129 * tmpg_l;
+    res0 += const_66 * tmpr_r;
+    res1 += const_66 * tmpr_l;
+    dst = (v16u8)__msa_pckod_b(res1, res0);
+    ST_UB(dst, dst_y);
+    src_rgb565 += 32;
+    dst_y += 16;
+  }
+}
+
+void RGB24ToYRow_MSA(const uint8_t* src_argb, uint8_t* dst_y, int width) {
+  int x;
+  v16u8 src0, src1, src2, reg0, reg1, reg2, reg3, dst0;
+  v8u16 vec0, vec1, vec2, vec3;
+  v8u16 const_0x8119 = (v8u16)__msa_fill_h(0x8119);
+  v8u16 const_0x42 = (v8u16)__msa_fill_h(0x42);
+  v8u16 const_0x1080 = (v8u16)__msa_fill_h(0x1080);
+  v16i8 mask0 = {0, 1, 2, 3, 3, 4, 5, 6, 6, 7, 8, 9, 9, 10, 11, 12};
+  v16i8 mask1 = {12, 13, 14, 15, 15, 16, 17, 18,
+                 18, 19, 20, 21, 21, 22, 23, 24};
+  v16i8 mask2 = {8, 9, 10, 11, 11, 12, 13, 14, 14, 15, 16, 17, 17, 18, 19, 20};
+  v16i8 mask3 = {4, 5, 6, 7, 7, 8, 9, 10, 10, 11, 12, 13, 13, 14, 15, 16};
+  v16i8 zero = {0};
+
+  for (x = 0; x < width; x += 16) {
+    src0 = (v16u8)__msa_ld_b((void*)src_argb, 0);
+    src1 = (v16u8)__msa_ld_b((void*)src_argb, 16);
+    src2 = (v16u8)__msa_ld_b((void*)src_argb, 32);
+    reg0 = (v16u8)__msa_vshf_b(mask0, zero, (v16i8)src0);
+    reg1 = (v16u8)__msa_vshf_b(mask1, (v16i8)src1, (v16i8)src0);
+    reg2 = (v16u8)__msa_vshf_b(mask2, (v16i8)src2, (v16i8)src1);
+    reg3 = (v16u8)__msa_vshf_b(mask3, zero, (v16i8)src2);
+    vec0 = (v8u16)__msa_pckev_h((v8i16)reg1, (v8i16)reg0);
+    vec1 = (v8u16)__msa_pckev_h((v8i16)reg3, (v8i16)reg2);
+    vec2 = (v8u16)__msa_pckod_h((v8i16)reg1, (v8i16)reg0);
+    vec3 = (v8u16)__msa_pckod_h((v8i16)reg3, (v8i16)reg2);
+    vec0 = __msa_dotp_u_h((v16u8)vec0, (v16u8)const_0x8119);
+    vec1 = __msa_dotp_u_h((v16u8)vec1, (v16u8)const_0x8119);
+    vec0 = __msa_dpadd_u_h(vec0, (v16u8)vec2, (v16u8)const_0x42);
+    vec1 = __msa_dpadd_u_h(vec1, (v16u8)vec3, (v16u8)const_0x42);
+    vec0 += const_0x1080;
+    vec1 += const_0x1080;
+    vec0 = (v8u16)__msa_srai_h((v8i16)vec0, 8);
+    vec1 = (v8u16)__msa_srai_h((v8i16)vec1, 8);
+    dst0 = (v16u8)__msa_pckev_b((v16i8)vec1, (v16i8)vec0);
+    ST_UB(dst0, dst_y);
+    src_argb += 48;
+    dst_y += 16;
+  }
+}
+
+void RAWToYRow_MSA(const uint8_t* src_argb, uint8_t* dst_y, int width) {
+  int x;
+  v16u8 src0, src1, src2, reg0, reg1, reg2, reg3, dst0;
+  v8u16 vec0, vec1, vec2, vec3;
+  v8u16 const_0x8142 = (v8u16)__msa_fill_h(0x8142);
+  v8u16 const_0x19 = (v8u16)__msa_fill_h(0x19);
+  v8u16 const_0x1080 = (v8u16)__msa_fill_h(0x1080);
+  v16i8 mask0 = {0, 1, 2, 3, 3, 4, 5, 6, 6, 7, 8, 9, 9, 10, 11, 12};
+  v16i8 mask1 = {12, 13, 14, 15, 15, 16, 17, 18,
+                 18, 19, 20, 21, 21, 22, 23, 24};
+  v16i8 mask2 = {8, 9, 10, 11, 11, 12, 13, 14, 14, 15, 16, 17, 17, 18, 19, 20};
+  v16i8 mask3 = {4, 5, 6, 7, 7, 8, 9, 10, 10, 11, 12, 13, 13, 14, 15, 16};
+  v16i8 zero = {0};
+
+  for (x = 0; x < width; x += 16) {
+    src0 = (v16u8)__msa_ld_b((void*)src_argb, 0);
+    src1 = (v16u8)__msa_ld_b((void*)src_argb, 16);
+    src2 = (v16u8)__msa_ld_b((void*)src_argb, 32);
+    reg0 = (v16u8)__msa_vshf_b(mask0, zero, (v16i8)src0);
+    reg1 = (v16u8)__msa_vshf_b(mask1, (v16i8)src1, (v16i8)src0);
+    reg2 = (v16u8)__msa_vshf_b(mask2, (v16i8)src2, (v16i8)src1);
+    reg3 = (v16u8)__msa_vshf_b(mask3, zero, (v16i8)src2);
+    vec0 = (v8u16)__msa_pckev_h((v8i16)reg1, (v8i16)reg0);
+    vec1 = (v8u16)__msa_pckev_h((v8i16)reg3, (v8i16)reg2);
+    vec2 = (v8u16)__msa_pckod_h((v8i16)reg1, (v8i16)reg0);
+    vec3 = (v8u16)__msa_pckod_h((v8i16)reg3, (v8i16)reg2);
+    vec0 = __msa_dotp_u_h((v16u8)vec0, (v16u8)const_0x8142);
+    vec1 = __msa_dotp_u_h((v16u8)vec1, (v16u8)const_0x8142);
+    vec0 = __msa_dpadd_u_h(vec0, (v16u8)vec2, (v16u8)const_0x19);
+    vec1 = __msa_dpadd_u_h(vec1, (v16u8)vec3, (v16u8)const_0x19);
+    vec0 += const_0x1080;
+    vec1 += const_0x1080;
+    vec0 = (v8u16)__msa_srai_h((v8i16)vec0, 8);
+    vec1 = (v8u16)__msa_srai_h((v8i16)vec1, 8);
+    dst0 = (v16u8)__msa_pckev_b((v16i8)vec1, (v16i8)vec0);
+    ST_UB(dst0, dst_y);
+    src_argb += 48;
+    dst_y += 16;
+  }
+}
+
+void ARGB1555ToUVRow_MSA(const uint8_t* src_argb1555,
+                         int src_stride_argb1555,
+                         uint8_t* dst_u,
+                         uint8_t* dst_v,
+                         int width) {
+  int x;
+  const uint16_t* s = (const uint16_t*)src_argb1555;
+  const uint16_t* t = (const uint16_t*)(src_argb1555 + src_stride_argb1555);
+  int64_t res0, res1;
+  v16u8 src0, src1, src2, src3, dst;
+  v16u8 tmp0, tmp1, tmp2, tmp3;
+  v16u8 reg0, reg1, reg2, reg3;
+  v16u8 tmpb, tmpg, tmpr, nexb, nexg, nexr;
+  v8i16 const_112 = (v8i16)__msa_ldi_h(0x38);
+  v8i16 const_74 = (v8i16)__msa_ldi_h(0x25);
+  v8i16 const_38 = (v8i16)__msa_ldi_h(0x13);
+  v8i16 const_94 = (v8i16)__msa_ldi_h(0x2F);
+  v8i16 const_18 = (v8i16)__msa_ldi_h(0x09);
+  v8u16 const_8080 = (v8u16)__msa_fill_h(0x8080);
+
+  for (x = 0; x < width; x += 16) {
+    src0 = (v8u16)__msa_ld_b((void*)s, 0);
+    src1 = (v8u16)__msa_ld_b((void*)s, 16);
+    src2 = (v8u16)__msa_ld_b((void*)t, 0);
+    src3 = (v8u16)__msa_ld_b((void*)t, 16);
+    tmp0 = (v16u8)__msa_pckev_b(src1, src0);
+    tmp1 = (v16u8)__msa_pckod_b(src1, src0);
+    tmp2 = (v16u8)__msa_pckev_b(src3, src2);
+    tmp3 = (v16u8)__msa_pckod_b(src3, src2);
+    tmpb = (v16u8)__msa_andi_b(tmp0, 0x1F);
+    nexb = (v16u8)__msa_andi_b(tmp2, 0x1F);
+    tmpg = (v16u8)__msa_srli_b(tmp0, 5);
+    nexg = (v16u8)__msa_srli_b(tmp2, 5);
+    reg0 = (v16u8)__msa_andi_b(tmp1, 0x03);
+    reg2 = (v16u8)__msa_andi_b(tmp3, 0x03);
+    reg0 = (v16u8)__msa_slli_b(reg0, 3);
+    reg2 = (v16u8)__msa_slli_b(reg2, 3);
+    tmpg = (v16u8)__msa_or_v(tmpg, reg0);
+    nexg = (v16u8)__msa_or_v(nexg, reg2);
+    reg1 = (v16u8)__msa_andi_b(tmp1, 0x7C);
+    reg3 = (v16u8)__msa_andi_b(tmp3, 0x7C);
+    tmpr = (v16u8)__msa_srli_b(reg1, 2);
+    nexr = (v16u8)__msa_srli_b(reg3, 2);
+    reg0 = (v16u8)__msa_slli_b(tmpb, 3);
+    reg1 = (v16u8)__msa_slli_b(tmpg, 3);
+    reg2 = (v16u8)__msa_slli_b(tmpr, 3);
+    tmpb = (v16u8)__msa_srli_b(tmpb, 2);
+    tmpg = (v16u8)__msa_srli_b(tmpg, 2);
+    tmpr = (v16u8)__msa_srli_b(tmpr, 2);
+    tmpb = (v16u8)__msa_or_v(reg0, tmpb);
+    tmpg = (v16u8)__msa_or_v(reg1, tmpg);
+    tmpr = (v16u8)__msa_or_v(reg2, tmpr);
+    reg0 = (v16u8)__msa_slli_b(nexb, 3);
+    reg1 = (v16u8)__msa_slli_b(nexg, 3);
+    reg2 = (v16u8)__msa_slli_b(nexr, 3);
+    nexb = (v16u8)__msa_srli_b(nexb, 2);
+    nexg = (v16u8)__msa_srli_b(nexg, 2);
+    nexr = (v16u8)__msa_srli_b(nexr, 2);
+    nexb = (v16u8)__msa_or_v(reg0, nexb);
+    nexg = (v16u8)__msa_or_v(reg1, nexg);
+    nexr = (v16u8)__msa_or_v(reg2, nexr);
+    RGBTOUV(tmpb, tmpg, tmpr, nexb, nexg, nexr, dst);
+    res0 = __msa_copy_u_d((v2i64)dst, 0);
+    res1 = __msa_copy_u_d((v2i64)dst, 1);
+    SD(res0, dst_u);
+    SD(res1, dst_v);
+    s += 16;
+    t += 16;
+    dst_u += 8;
+    dst_v += 8;
+  }
+}
+
+void RGB565ToUVRow_MSA(const uint8_t* src_rgb565,
+                       int src_stride_rgb565,
+                       uint8_t* dst_u,
+                       uint8_t* dst_v,
+                       int width) {
+  int x;
+  const uint16_t* s = (const uint16_t*)src_rgb565;
+  const uint16_t* t = (const uint16_t*)(src_rgb565 + src_stride_rgb565);
+  int64_t res0, res1;
+  v16u8 src0, src1, src2, src3, dst;
+  v16u8 tmp0, tmp1, tmp2, tmp3;
+  v16u8 reg0, reg1, reg2, reg3;
+  v16u8 tmpb, tmpg, tmpr, nexb, nexg, nexr;
+  v8i16 const_112 = (v8i16)__msa_ldi_h(0x38);
+  v8i16 const_74 = (v8i16)__msa_ldi_h(0x25);
+  v8i16 const_38 = (v8i16)__msa_ldi_h(0x13);
+  v8i16 const_94 = (v8i16)__msa_ldi_h(0x2F);
+  v8i16 const_18 = (v8i16)__msa_ldi_h(0x09);
+  v8u16 const_8080 = (v8u16)__msa_fill_h(0x8080);
+
+  for (x = 0; x < width; x += 16) {
+    src0 = (v16u8)__msa_ld_b((void*)s, 0);
+    src1 = (v16u8)__msa_ld_b((void*)s, 16);
+    src2 = (v16u8)__msa_ld_b((void*)t, 0);
+    src3 = (v16u8)__msa_ld_b((void*)t, 16);
+    tmp0 = (v16u8)__msa_pckev_b(src1, src0);
+    tmp1 = (v16u8)__msa_pckod_b(src1, src0);
+    tmp2 = (v16u8)__msa_pckev_b(src3, src2);
+    tmp3 = (v16u8)__msa_pckod_b(src3, src2);
+    tmpb = (v16u8)__msa_andi_b(tmp0, 0x1F);
+    tmpr = (v16u8)__msa_andi_b(tmp1, 0xF8);
+    nexb = (v16u8)__msa_andi_b(tmp2, 0x1F);
+    nexr = (v16u8)__msa_andi_b(tmp3, 0xF8);
+    reg1 = (v16u8)__msa_andi_b(tmp1, 0x07);
+    reg3 = (v16u8)__msa_andi_b(tmp3, 0x07);
+    reg0 = (v16u8)__msa_srli_b(tmp0, 5);
+    reg1 = (v16u8)__msa_slli_b(reg1, 3);
+    reg2 = (v16u8)__msa_srli_b(tmp2, 5);
+    reg3 = (v16u8)__msa_slli_b(reg3, 3);
+    tmpg = (v16u8)__msa_or_v(reg1, reg0);
+    nexg = (v16u8)__msa_or_v(reg2, reg3);
+    reg0 = (v16u8)__msa_slli_b(tmpb, 3);
+    reg1 = (v16u8)__msa_srli_b(tmpb, 2);
+    reg2 = (v16u8)__msa_slli_b(nexb, 3);
+    reg3 = (v16u8)__msa_srli_b(nexb, 2);
+    tmpb = (v16u8)__msa_or_v(reg1, reg0);
+    nexb = (v16u8)__msa_or_v(reg2, reg3);
+    reg0 = (v16u8)__msa_slli_b(tmpg, 2);
+    reg1 = (v16u8)__msa_srli_b(tmpg, 4);
+    reg2 = (v16u8)__msa_slli_b(nexg, 2);
+    reg3 = (v16u8)__msa_srli_b(nexg, 4);
+    tmpg = (v16u8)__msa_or_v(reg1, reg0);
+    nexg = (v16u8)__msa_or_v(reg2, reg3);
+    reg0 = (v16u8)__msa_srli_b(tmpr, 5);
+    reg2 = (v16u8)__msa_srli_b(nexr, 5);
+    tmpr = (v16u8)__msa_or_v(tmpr, reg0);
+    nexr = (v16u8)__msa_or_v(nexr, reg2);
+    RGBTOUV(tmpb, tmpg, tmpr, nexb, nexg, nexr, dst);
+    res0 = __msa_copy_u_d((v2i64)dst, 0);
+    res1 = __msa_copy_u_d((v2i64)dst, 1);
+    SD(res0, dst_u);
+    SD(res1, dst_v);
+    s += 16;
+    t += 16;
+    dst_u += 8;
+    dst_v += 8;
+  }
+}
+
+void RGB24ToUVRow_MSA(const uint8_t* src_rgb,
+                      int src_stride_rgb,
+                      uint8_t* dst_u,
+                      uint8_t* dst_v,
+                      int width) {
+  int x;
+  const uint8_t* s = src_rgb;
+  const uint8_t* t = src_rgb + src_stride_rgb;
+  int64_t res0, res1;
+  v16u8 src0, src1, src2, src3, src4, src5, src6, src7;
+  v16u8 inp0, inp1, inp2, inp3, inp4, inp5;
+  v8u16 vec0, vec1, vec2, vec3, vec4, vec5, vec6, vec7;
+  v8i16 reg0, reg1, reg2, reg3;
+  v16u8 dst0;
+  v8u16 const_0x70 = (v8u16)__msa_fill_h(0x38);
+  v8u16 const_0x4A = (v8u16)__msa_fill_h(0x25);
+  v8u16 const_0x26 = (v8u16)__msa_fill_h(0x13);
+  v8u16 const_0x5E = (v8u16)__msa_fill_h(0x2f);
+  v8u16 const_0x12 = (v8u16)__msa_fill_h(0x09);
+  v8u16 const_0x8080 = (v8u16)__msa_fill_h(0x8080);
+  v8u16 const_0x0001 = (v8u16)__msa_fill_h(0x0001);
+  v16i8 mask = {0, 1, 2, 16, 3, 4, 5, 17, 6, 7, 8, 18, 9, 10, 11, 19};
+  v16i8 zero = {0};
+
+  for (x = 0; x < width; x += 16) {
+    inp0 = (v16u8)__msa_ld_b((void*)s, 0);
+    inp1 = (v16u8)__msa_ld_b((void*)s, 16);
+    inp2 = (v16u8)__msa_ld_b((void*)s, 32);
+    inp3 = (v16u8)__msa_ld_b((void*)t, 0);
+    inp4 = (v16u8)__msa_ld_b((void*)t, 16);
+    inp5 = (v16u8)__msa_ld_b((void*)t, 32);
+    src1 = (v16u8)__msa_sldi_b((v16i8)inp1, (v16i8)inp0, 12);
+    src5 = (v16u8)__msa_sldi_b((v16i8)inp4, (v16i8)inp3, 12);
+    src2 = (v16u8)__msa_sldi_b((v16i8)inp2, (v16i8)inp1, 8);
+    src6 = (v16u8)__msa_sldi_b((v16i8)inp5, (v16i8)inp4, 8);
+    src3 = (v16u8)__msa_sldi_b((v16i8)inp2, (v16i8)inp2, 4);
+    src7 = (v16u8)__msa_sldi_b((v16i8)inp5, (v16i8)inp5, 4);
+    src0 = (v16u8)__msa_vshf_b(mask, (v16i8)zero, (v16i8)inp0);
+    src1 = (v16u8)__msa_vshf_b(mask, (v16i8)zero, (v16i8)src1);
+    src2 = (v16u8)__msa_vshf_b(mask, (v16i8)zero, (v16i8)src2);
+    src3 = (v16u8)__msa_vshf_b(mask, (v16i8)zero, (v16i8)src3);
+    src4 = (v16u8)__msa_vshf_b(mask, (v16i8)zero, (v16i8)inp3);
+    src5 = (v16u8)__msa_vshf_b(mask, (v16i8)zero, (v16i8)src5);
+    src6 = (v16u8)__msa_vshf_b(mask, (v16i8)zero, (v16i8)src6);
+    src7 = (v16u8)__msa_vshf_b(mask, (v16i8)zero, (v16i8)src7);
+    vec0 = (v8u16)__msa_ilvr_b((v16i8)src4, (v16i8)src0);
+    vec1 = (v8u16)__msa_ilvl_b((v16i8)src4, (v16i8)src0);
+    vec2 = (v8u16)__msa_ilvr_b((v16i8)src5, (v16i8)src1);
+    vec3 = (v8u16)__msa_ilvl_b((v16i8)src5, (v16i8)src1);
+    vec4 = (v8u16)__msa_ilvr_b((v16i8)src6, (v16i8)src2);
+    vec5 = (v8u16)__msa_ilvl_b((v16i8)src6, (v16i8)src2);
+    vec6 = (v8u16)__msa_ilvr_b((v16i8)src7, (v16i8)src3);
+    vec7 = (v8u16)__msa_ilvl_b((v16i8)src7, (v16i8)src3);
+    vec0 = (v8u16)__msa_hadd_u_h((v16u8)vec0, (v16u8)vec0);
+    vec1 = (v8u16)__msa_hadd_u_h((v16u8)vec1, (v16u8)vec1);
+    vec2 = (v8u16)__msa_hadd_u_h((v16u8)vec2, (v16u8)vec2);
+    vec3 = (v8u16)__msa_hadd_u_h((v16u8)vec3, (v16u8)vec3);
+    vec4 = (v8u16)__msa_hadd_u_h((v16u8)vec4, (v16u8)vec4);
+    vec5 = (v8u16)__msa_hadd_u_h((v16u8)vec5, (v16u8)vec5);
+    vec6 = (v8u16)__msa_hadd_u_h((v16u8)vec6, (v16u8)vec6);
+    vec7 = (v8u16)__msa_hadd_u_h((v16u8)vec7, (v16u8)vec7);
+    reg0 = (v8i16)__msa_pckev_d((v2i64)vec1, (v2i64)vec0);
+    reg1 = (v8i16)__msa_pckev_d((v2i64)vec3, (v2i64)vec2);
+    reg2 = (v8i16)__msa_pckev_d((v2i64)vec5, (v2i64)vec4);
+    reg3 = (v8i16)__msa_pckev_d((v2i64)vec7, (v2i64)vec6);
+    reg0 += (v8i16)__msa_pckod_d((v2i64)vec1, (v2i64)vec0);
+    reg1 += (v8i16)__msa_pckod_d((v2i64)vec3, (v2i64)vec2);
+    reg2 += (v8i16)__msa_pckod_d((v2i64)vec5, (v2i64)vec4);
+    reg3 += (v8i16)__msa_pckod_d((v2i64)vec7, (v2i64)vec6);
+    reg0 += const_0x0001;
+    reg1 += const_0x0001;
+    reg2 += const_0x0001;
+    reg3 += const_0x0001;
+    reg0 = __msa_srai_h((v8i16)reg0, 1);
+    reg1 = __msa_srai_h((v8i16)reg1, 1);
+    reg2 = __msa_srai_h((v8i16)reg2, 1);
+    reg3 = __msa_srai_h((v8i16)reg3, 1);
+    vec4 = (v8u16)__msa_pckev_h(reg1, reg0);
+    vec5 = (v8u16)__msa_pckev_h(reg3, reg2);
+    vec6 = (v8u16)__msa_pckod_h(reg1, reg0);
+    vec7 = (v8u16)__msa_pckod_h(reg3, reg2);
+    vec0 = (v8u16)__msa_pckev_h((v8i16)vec5, (v8i16)vec4);
+    vec1 = (v8u16)__msa_pckev_h((v8i16)vec7, (v8i16)vec6);
+    vec2 = (v8u16)__msa_pckod_h((v8i16)vec5, (v8i16)vec4);
+    vec3 = vec0 * const_0x70;
+    vec4 = vec1 * const_0x4A;
+    vec5 = vec2 * const_0x26;
+    vec2 *= const_0x70;
+    vec1 *= const_0x5E;
+    vec0 *= const_0x12;
+    reg0 = __msa_subv_h((v8i16)vec3, (v8i16)vec4);
+    reg1 = __msa_subv_h((v8i16)const_0x8080, (v8i16)vec5);
+    reg2 = __msa_subv_h((v8i16)vec2, (v8i16)vec1);
+    reg3 = __msa_subv_h((v8i16)const_0x8080, (v8i16)vec0);
+    reg0 += reg1;
+    reg2 += reg3;
+    reg0 = __msa_srai_h(reg0, 8);
+    reg2 = __msa_srai_h(reg2, 8);
+    dst0 = (v16u8)__msa_pckev_b((v16i8)reg2, (v16i8)reg0);
+    res0 = __msa_copy_u_d((v2i64)dst0, 0);
+    res1 = __msa_copy_u_d((v2i64)dst0, 1);
+    SD(res0, dst_u);
+    SD(res1, dst_v);
+    t += 48;
+    s += 48;
+    dst_u += 8;
+    dst_v += 8;
+  }
+}
+
+void RAWToUVRow_MSA(const uint8_t* src_rgb,
+                    int src_stride_rgb,
+                    uint8_t* dst_u,
+                    uint8_t* dst_v,
+                    int width) {
+  int x;
+  const uint8_t* s = src_rgb;
+  const uint8_t* t = src_rgb + src_stride_rgb;
+  int64_t res0, res1;
+  v16u8 inp0, inp1, inp2, inp3, inp4, inp5;
+  v16u8 src0, src1, src2, src3, src4, src5, src6, src7;
+  v8u16 vec0, vec1, vec2, vec3, vec4, vec5, vec6, vec7;
+  v8i16 reg0, reg1, reg2, reg3;
+  v16u8 dst0;
+  v8u16 const_0x70 = (v8u16)__msa_fill_h(0x38);
+  v8u16 const_0x4A = (v8u16)__msa_fill_h(0x25);
+  v8u16 const_0x26 = (v8u16)__msa_fill_h(0x13);
+  v8u16 const_0x5E = (v8u16)__msa_fill_h(0x2f);
+  v8u16 const_0x12 = (v8u16)__msa_fill_h(0x09);
+  v8u16 const_0x8080 = (v8u16)__msa_fill_h(0x8080);
+  v8u16 const_0x0001 = (v8u16)__msa_fill_h(0x0001);
+  v16i8 mask = {0, 1, 2, 16, 3, 4, 5, 17, 6, 7, 8, 18, 9, 10, 11, 19};
+  v16i8 zero = {0};
+
+  for (x = 0; x < width; x += 16) {
+    inp0 = (v16u8)__msa_ld_b((void*)s, 0);
+    inp1 = (v16u8)__msa_ld_b((void*)s, 16);
+    inp2 = (v16u8)__msa_ld_b((void*)s, 32);
+    inp3 = (v16u8)__msa_ld_b((void*)t, 0);
+    inp4 = (v16u8)__msa_ld_b((void*)t, 16);
+    inp5 = (v16u8)__msa_ld_b((void*)t, 32);
+    src1 = (v16u8)__msa_sldi_b((v16i8)inp1, (v16i8)inp0, 12);
+    src5 = (v16u8)__msa_sldi_b((v16i8)inp4, (v16i8)inp3, 12);
+    src2 = (v16u8)__msa_sldi_b((v16i8)inp2, (v16i8)inp1, 8);
+    src6 = (v16u8)__msa_sldi_b((v16i8)inp5, (v16i8)inp4, 8);
+    src3 = (v16u8)__msa_sldi_b((v16i8)inp2, (v16i8)inp2, 4);
+    src7 = (v16u8)__msa_sldi_b((v16i8)inp5, (v16i8)inp5, 4);
+    src0 = (v16u8)__msa_vshf_b(mask, (v16i8)zero, (v16i8)inp0);
+    src1 = (v16u8)__msa_vshf_b(mask, (v16i8)zero, (v16i8)src1);
+    src2 = (v16u8)__msa_vshf_b(mask, (v16i8)zero, (v16i8)src2);
+    src3 = (v16u8)__msa_vshf_b(mask, (v16i8)zero, (v16i8)src3);
+    src4 = (v16u8)__msa_vshf_b(mask, (v16i8)zero, (v16i8)inp3);
+    src5 = (v16u8)__msa_vshf_b(mask, (v16i8)zero, (v16i8)src5);
+    src6 = (v16u8)__msa_vshf_b(mask, (v16i8)zero, (v16i8)src6);
+    src7 = (v16u8)__msa_vshf_b(mask, (v16i8)zero, (v16i8)src7);
+    vec0 = (v8u16)__msa_ilvr_b((v16i8)src4, (v16i8)src0);
+    vec1 = (v8u16)__msa_ilvl_b((v16i8)src4, (v16i8)src0);
+    vec2 = (v8u16)__msa_ilvr_b((v16i8)src5, (v16i8)src1);
+    vec3 = (v8u16)__msa_ilvl_b((v16i8)src5, (v16i8)src1);
+    vec4 = (v8u16)__msa_ilvr_b((v16i8)src6, (v16i8)src2);
+    vec5 = (v8u16)__msa_ilvl_b((v16i8)src6, (v16i8)src2);
+    vec6 = (v8u16)__msa_ilvr_b((v16i8)src7, (v16i8)src3);
+    vec7 = (v8u16)__msa_ilvl_b((v16i8)src7, (v16i8)src3);
+    vec0 = (v8u16)__msa_hadd_u_h((v16u8)vec0, (v16u8)vec0);
+    vec1 = (v8u16)__msa_hadd_u_h((v16u8)vec1, (v16u8)vec1);
+    vec2 = (v8u16)__msa_hadd_u_h((v16u8)vec2, (v16u8)vec2);
+    vec3 = (v8u16)__msa_hadd_u_h((v16u8)vec3, (v16u8)vec3);
+    vec4 = (v8u16)__msa_hadd_u_h((v16u8)vec4, (v16u8)vec4);
+    vec5 = (v8u16)__msa_hadd_u_h((v16u8)vec5, (v16u8)vec5);
+    vec6 = (v8u16)__msa_hadd_u_h((v16u8)vec6, (v16u8)vec6);
+    vec7 = (v8u16)__msa_hadd_u_h((v16u8)vec7, (v16u8)vec7);
+    reg0 = (v8i16)__msa_pckev_d((v2i64)vec1, (v2i64)vec0);
+    reg1 = (v8i16)__msa_pckev_d((v2i64)vec3, (v2i64)vec2);
+    reg2 = (v8i16)__msa_pckev_d((v2i64)vec5, (v2i64)vec4);
+    reg3 = (v8i16)__msa_pckev_d((v2i64)vec7, (v2i64)vec6);
+    reg0 += (v8i16)__msa_pckod_d((v2i64)vec1, (v2i64)vec0);
+    reg1 += (v8i16)__msa_pckod_d((v2i64)vec3, (v2i64)vec2);
+    reg2 += (v8i16)__msa_pckod_d((v2i64)vec5, (v2i64)vec4);
+    reg3 += (v8i16)__msa_pckod_d((v2i64)vec7, (v2i64)vec6);
+    reg0 += const_0x0001;
+    reg1 += const_0x0001;
+    reg2 += const_0x0001;
+    reg3 += const_0x0001;
+    reg0 = __msa_srai_h(reg0, 1);
+    reg1 = __msa_srai_h(reg1, 1);
+    reg2 = __msa_srai_h(reg2, 1);
+    reg3 = __msa_srai_h(reg3, 1);
+    vec4 = (v8u16)__msa_pckev_h((v8i16)reg1, (v8i16)reg0);
+    vec5 = (v8u16)__msa_pckev_h((v8i16)reg3, (v8i16)reg2);
+    vec6 = (v8u16)__msa_pckod_h((v8i16)reg1, (v8i16)reg0);
+    vec7 = (v8u16)__msa_pckod_h((v8i16)reg3, (v8i16)reg2);
+    vec0 = (v8u16)__msa_pckod_h((v8i16)vec5, (v8i16)vec4);
+    vec1 = (v8u16)__msa_pckev_h((v8i16)vec7, (v8i16)vec6);
+    vec2 = (v8u16)__msa_pckev_h((v8i16)vec5, (v8i16)vec4);
+    vec3 = vec0 * const_0x70;
+    vec4 = vec1 * const_0x4A;
+    vec5 = vec2 * const_0x26;
+    vec2 *= const_0x70;
+    vec1 *= const_0x5E;
+    vec0 *= const_0x12;
+    reg0 = __msa_subv_h((v8i16)vec3, (v8i16)vec4);
+    reg1 = __msa_subv_h((v8i16)const_0x8080, (v8i16)vec5);
+    reg2 = __msa_subv_h((v8i16)vec2, (v8i16)vec1);
+    reg3 = __msa_subv_h((v8i16)const_0x8080, (v8i16)vec0);
+    reg0 += reg1;
+    reg2 += reg3;
+    reg0 = __msa_srai_h(reg0, 8);
+    reg2 = __msa_srai_h(reg2, 8);
+    dst0 = (v16u8)__msa_pckev_b((v16i8)reg2, (v16i8)reg0);
+    res0 = __msa_copy_u_d((v2i64)dst0, 0);
+    res1 = __msa_copy_u_d((v2i64)dst0, 1);
+    SD(res0, dst_u);
+    SD(res1, dst_v);
+    t += 48;
+    s += 48;
+    dst_u += 8;
+    dst_v += 8;
+  }
+}
+
+void NV12ToARGBRow_MSA(const uint8_t* src_y,
+                       const uint8_t* src_uv,
+                       uint8_t* dst_argb,
+                       const struct YuvConstants* yuvconstants,
+                       int width) {
+  int x;
+  uint64_t val0, val1;
+  v16u8 src0, src1, res0, res1, dst0, dst1;
+  v8i16 vec0, vec1, vec2;
+  v4i32 vec_ub, vec_vr, vec_ug, vec_vg, vec_yg, vec_yb;
+  v4i32 vec_ubvr, vec_ugvg;
+  v16u8 zero = {0};
+  v16u8 alpha = (v16u8)__msa_ldi_b(ALPHA_VAL);
+  v8i16 const_0x80 = __msa_ldi_h(0x80);
+
+  YUVTORGB_SETUP(yuvconstants, vec_ub, vec_vr, vec_ug, vec_vg, vec_yg, vec_yb);
+  vec_ubvr = __msa_ilvr_w(vec_vr, vec_ub);
+  vec_ugvg = (v4i32)__msa_ilvev_h((v8i16)vec_vg, (v8i16)vec_ug);
+
+  for (x = 0; x < width; x += 8) {
+    val0 = LD(src_y);
+    val1 = LD(src_uv);
+    src0 = (v16u8)__msa_insert_d((v2i64)zero, 0, val0);
+    src1 = (v16u8)__msa_insert_d((v2i64)zero, 0, val1);
+    YUVTORGB(src0, src1, vec_ubvr, vec_ugvg, vec_yg, vec_yb, vec0, vec1, vec2);
+    res0 = (v16u8)__msa_ilvev_b((v16i8)vec2, (v16i8)vec0);
+    res1 = (v16u8)__msa_ilvev_b((v16i8)alpha, (v16i8)vec1);
+    dst0 = (v16u8)__msa_ilvr_b((v16i8)res1, (v16i8)res0);
+    dst1 = (v16u8)__msa_ilvl_b((v16i8)res1, (v16i8)res0);
+    ST_UB2(dst0, dst1, dst_argb, 16);
+    src_y += 8;
+    src_uv += 8;
+    dst_argb += 32;
+  }
+}
+
+void NV12ToRGB565Row_MSA(const uint8_t* src_y,
+                         const uint8_t* src_uv,
+                         uint8_t* dst_rgb565,
+                         const struct YuvConstants* yuvconstants,
+                         int width) {
+  int x;
+  uint64_t val0, val1;
+  v16u8 src0, src1, dst0;
+  v8i16 vec0, vec1, vec2;
+  v4i32 vec_ub, vec_vr, vec_ug, vec_vg, vec_yg, vec_yb;
+  v4i32 vec_ubvr, vec_ugvg;
+  v8i16 const_0x80 = __msa_ldi_h(0x80);
+  v16u8 zero = {0};
+
+  YUVTORGB_SETUP(yuvconstants, vec_ub, vec_vr, vec_ug, vec_vg, vec_yg, vec_yb);
+  vec_ubvr = __msa_ilvr_w(vec_vr, vec_ub);
+  vec_ugvg = (v4i32)__msa_ilvev_h((v8i16)vec_vg, (v8i16)vec_ug);
+
+  for (x = 0; x < width; x += 8) {
+    val0 = LD(src_y);
+    val1 = LD(src_uv);
+    src0 = (v16u8)__msa_insert_d((v2i64)zero, 0, val0);
+    src1 = (v16u8)__msa_insert_d((v2i64)zero, 0, val1);
+    YUVTORGB(src0, src1, vec_ubvr, vec_ugvg, vec_yg, vec_yb, vec0, vec1, vec2);
+    vec0 = vec0 >> 3;
+    vec1 = (vec1 >> 2) << 5;
+    vec2 = (vec2 >> 3) << 11;
+    dst0 = (v16u8)(vec0 | vec1 | vec2);
+    ST_UB(dst0, dst_rgb565);
+    src_y += 8;
+    src_uv += 8;
+    dst_rgb565 += 16;
+  }
+}
+
+void NV21ToARGBRow_MSA(const uint8_t* src_y,
+                       const uint8_t* src_vu,
+                       uint8_t* dst_argb,
+                       const struct YuvConstants* yuvconstants,
+                       int width) {
+  int x;
+  uint64_t val0, val1;
+  v16u8 src0, src1, res0, res1, dst0, dst1;
+  v8i16 vec0, vec1, vec2;
+  v4i32 vec_ub, vec_vr, vec_ug, vec_vg, vec_yg, vec_yb;
+  v4i32 vec_ubvr, vec_ugvg;
+  v16u8 alpha = (v16u8)__msa_ldi_b(ALPHA_VAL);
+  v16u8 zero = {0};
+  v16i8 shuffler = {1, 0, 3, 2, 5, 4, 7, 6, 9, 8, 11, 10, 13, 12, 15, 14};
+  v8i16 const_0x80 = __msa_ldi_h(0x80);
+
+  YUVTORGB_SETUP(yuvconstants, vec_ub, vec_vr, vec_ug, vec_vg, vec_yg, vec_yb);
+  vec_ubvr = __msa_ilvr_w(vec_vr, vec_ub);
+  vec_ugvg = (v4i32)__msa_ilvev_h((v8i16)vec_vg, (v8i16)vec_ug);
+
+  for (x = 0; x < width; x += 8) {
+    val0 = LD(src_y);
+    val1 = LD(src_vu);
+    src0 = (v16u8)__msa_insert_d((v2i64)zero, 0, val0);
+    src1 = (v16u8)__msa_insert_d((v2i64)zero, 0, val1);
+    src1 = (v16u8)__msa_vshf_b(shuffler, (v16i8)src1, (v16i8)src1);
+    YUVTORGB(src0, src1, vec_ubvr, vec_ugvg, vec_yg, vec_yb, vec0, vec1, vec2);
+    res0 = (v16u8)__msa_ilvev_b((v16i8)vec2, (v16i8)vec0);
+    res1 = (v16u8)__msa_ilvev_b((v16i8)alpha, (v16i8)vec1);
+    dst0 = (v16u8)__msa_ilvr_b((v16i8)res1, (v16i8)res0);
+    dst1 = (v16u8)__msa_ilvl_b((v16i8)res1, (v16i8)res0);
+    ST_UB2(dst0, dst1, dst_argb, 16);
+    src_y += 8;
+    src_vu += 8;
+    dst_argb += 32;
+  }
+}
+
+void SobelRow_MSA(const uint8_t* src_sobelx,
+                  const uint8_t* src_sobely,
+                  uint8_t* dst_argb,
+                  int width) {
+  int x;
+  v16u8 src0, src1, vec0, dst0, dst1, dst2, dst3;
+  v16i8 mask0 = {0, 0, 0, 16, 1, 1, 1, 16, 2, 2, 2, 16, 3, 3, 3, 16};
+  v16i8 const_0x4 = __msa_ldi_b(0x4);
+  v16i8 mask1 = mask0 + const_0x4;
+  v16i8 mask2 = mask1 + const_0x4;
+  v16i8 mask3 = mask2 + const_0x4;
+  v16u8 alpha = (v16u8)__msa_ldi_b(ALPHA_VAL);
+
+  for (x = 0; x < width; x += 16) {
+    src0 = (v16u8)__msa_ld_b((void*)src_sobelx, 0);
+    src1 = (v16u8)__msa_ld_b((void*)src_sobely, 0);
+    vec0 = __msa_adds_u_b(src0, src1);
+    dst0 = (v16u8)__msa_vshf_b(mask0, (v16i8)alpha, (v16i8)vec0);
+    dst1 = (v16u8)__msa_vshf_b(mask1, (v16i8)alpha, (v16i8)vec0);
+    dst2 = (v16u8)__msa_vshf_b(mask2, (v16i8)alpha, (v16i8)vec0);
+    dst3 = (v16u8)__msa_vshf_b(mask3, (v16i8)alpha, (v16i8)vec0);
+    ST_UB4(dst0, dst1, dst2, dst3, dst_argb, 16);
+    src_sobelx += 16;
+    src_sobely += 16;
+    dst_argb += 64;
+  }
+}
+
+void SobelToPlaneRow_MSA(const uint8_t* src_sobelx,
+                         const uint8_t* src_sobely,
+                         uint8_t* dst_y,
+                         int width) {
+  int x;
+  v16u8 src0, src1, src2, src3, dst0, dst1;
+
+  for (x = 0; x < width; x += 32) {
+    src0 = (v16u8)__msa_ld_b((void*)src_sobelx, 0);
+    src1 = (v16u8)__msa_ld_b((void*)src_sobelx, 16);
+    src2 = (v16u8)__msa_ld_b((void*)src_sobely, 0);
+    src3 = (v16u8)__msa_ld_b((void*)src_sobely, 16);
+    dst0 = __msa_adds_u_b(src0, src2);
+    dst1 = __msa_adds_u_b(src1, src3);
+    ST_UB2(dst0, dst1, dst_y, 16);
+    src_sobelx += 32;
+    src_sobely += 32;
+    dst_y += 32;
+  }
+}
+
+void SobelXYRow_MSA(const uint8_t* src_sobelx,
+                    const uint8_t* src_sobely,
+                    uint8_t* dst_argb,
+                    int width) {
+  int x;
+  v16u8 src0, src1, vec0, vec1, vec2;
+  v16u8 reg0, reg1, dst0, dst1, dst2, dst3;
+  v16u8 alpha = (v16u8)__msa_ldi_b(ALPHA_VAL);
+
+  for (x = 0; x < width; x += 16) {
+    src0 = (v16u8)__msa_ld_b((void*)src_sobelx, 0);
+    src1 = (v16u8)__msa_ld_b((void*)src_sobely, 0);
+    vec0 = __msa_adds_u_b(src0, src1);
+    vec1 = (v16u8)__msa_ilvr_b((v16i8)src0, (v16i8)src1);
+    vec2 = (v16u8)__msa_ilvl_b((v16i8)src0, (v16i8)src1);
+    reg0 = (v16u8)__msa_ilvr_b((v16i8)alpha, (v16i8)vec0);
+    reg1 = (v16u8)__msa_ilvl_b((v16i8)alpha, (v16i8)vec0);
+    dst0 = (v16u8)__msa_ilvr_b((v16i8)reg0, (v16i8)vec1);
+    dst1 = (v16u8)__msa_ilvl_b((v16i8)reg0, (v16i8)vec1);
+    dst2 = (v16u8)__msa_ilvr_b((v16i8)reg1, (v16i8)vec2);
+    dst3 = (v16u8)__msa_ilvl_b((v16i8)reg1, (v16i8)vec2);
+    ST_UB4(dst0, dst1, dst2, dst3, dst_argb, 16);
+    src_sobelx += 16;
+    src_sobely += 16;
+    dst_argb += 64;
+  }
+}
+
+void ARGBToYJRow_MSA(const uint8_t* src_argb, uint8_t* dst_y, int width) {
+  int x;
+  v16u8 src0, src1, src2, src3, dst0;
+  v16u8 const_0x961D = (v16u8)__msa_fill_h(0x961D);
+  v16u8 const_0x4D = (v16u8)__msa_fill_h(0x4D);
+  v8u16 const_0x80 = (v8u16)__msa_fill_h(0x80);
+
+  for (x = 0; x < width; x += 16) {
+    src0 = (v16u8)__msa_ld_b((void*)src_argb, 0);
+    src1 = (v16u8)__msa_ld_b((void*)src_argb, 16);
+    src2 = (v16u8)__msa_ld_b((void*)src_argb, 32);
+    src3 = (v16u8)__msa_ld_b((void*)src_argb, 48);
+    ARGBTOY(src0, src1, src2, src3, const_0x961D, const_0x4D, const_0x80, 8,
+            dst0);
+    ST_UB(dst0, dst_y);
+    src_argb += 64;
+    dst_y += 16;
+  }
+}
+
+void BGRAToYRow_MSA(const uint8_t* src_argb, uint8_t* dst_y, int width) {
+  int x;
+  v16u8 src0, src1, src2, src3, dst0;
+  v16u8 const_0x4200 = (v16u8)__msa_fill_h(0x4200);
+  v16u8 const_0x1981 = (v16u8)__msa_fill_h(0x1981);
+  v8u16 const_0x1080 = (v8u16)__msa_fill_h(0x1080);
+
+  for (x = 0; x < width; x += 16) {
+    src0 = (v16u8)__msa_ld_b((void*)src_argb, 0);
+    src1 = (v16u8)__msa_ld_b((void*)src_argb, 16);
+    src2 = (v16u8)__msa_ld_b((void*)src_argb, 32);
+    src3 = (v16u8)__msa_ld_b((void*)src_argb, 48);
+    ARGBTOY(src0, src1, src2, src3, const_0x4200, const_0x1981, const_0x1080, 8,
+            dst0);
+    ST_UB(dst0, dst_y);
+    src_argb += 64;
+    dst_y += 16;
+  }
+}
+
+void ABGRToYRow_MSA(const uint8_t* src_argb, uint8_t* dst_y, int width) {
+  int x;
+  v16u8 src0, src1, src2, src3, dst0;
+  v16u8 const_0x8142 = (v16u8)__msa_fill_h(0x8142);
+  v16u8 const_0x19 = (v16u8)__msa_fill_h(0x19);
+  v8u16 const_0x1080 = (v8u16)__msa_fill_h(0x1080);
+
+  for (x = 0; x < width; x += 16) {
+    src0 = (v16u8)__msa_ld_b((void*)src_argb, 0);
+    src1 = (v16u8)__msa_ld_b((void*)src_argb, 16);
+    src2 = (v16u8)__msa_ld_b((void*)src_argb, 32);
+    src3 = (v16u8)__msa_ld_b((void*)src_argb, 48);
+    ARGBTOY(src0, src1, src2, src3, const_0x8142, const_0x19, const_0x1080, 8,
+            dst0);
+    ST_UB(dst0, dst_y);
+    src_argb += 64;
+    dst_y += 16;
+  }
+}
+
+void RGBAToYRow_MSA(const uint8_t* src_argb, uint8_t* dst_y, int width) {
+  int x;
+  v16u8 src0, src1, src2, src3, dst0;
+  v16u8 const_0x1900 = (v16u8)__msa_fill_h(0x1900);
+  v16u8 const_0x4281 = (v16u8)__msa_fill_h(0x4281);
+  v8u16 const_0x1080 = (v8u16)__msa_fill_h(0x1080);
+
+  for (x = 0; x < width; x += 16) {
+    src0 = (v16u8)__msa_ld_b((void*)src_argb, 0);
+    src1 = (v16u8)__msa_ld_b((void*)src_argb, 16);
+    src2 = (v16u8)__msa_ld_b((void*)src_argb, 32);
+    src3 = (v16u8)__msa_ld_b((void*)src_argb, 48);
+    ARGBTOY(src0, src1, src2, src3, const_0x1900, const_0x4281, const_0x1080, 8,
+            dst0);
+    ST_UB(dst0, dst_y);
+    src_argb += 64;
+    dst_y += 16;
+  }
+}
+
+void ARGBToUVJRow_MSA(const uint8_t* src_rgb,
+                      int src_stride_rgb,
+                      uint8_t* dst_u,
+                      uint8_t* dst_v,
+                      int width) {
+  int x;
+  const uint8_t* s = src_rgb;
+  const uint8_t* t = src_rgb + src_stride_rgb;
+  v8u16 src0, src1, src2, src3, src4, src5, src6, src7;
+  v8u16 vec0, vec1, vec2, vec3;
+  v8u16 dst0, dst1, dst2, dst3;
+  v16u8 zero = {0};
+  v8i16 shuffler0 = {0, 3, 4, 7, 8, 11, 12, 15};
+  v8i16 shuffler1 = {1, 2, 5, 6, 9, 10, 13, 14};
+  v8i16 shuffler2 = {2, 3, 6, 7, 10, 11, 14, 15};
+  v8i16 shuffler3 = {0, 1, 4, 5, 8, 9, 12, 13};
+  v8u16 const_0x0000003f = (v8u16)__msa_fill_w(0x0000003f);
+  v4u32 const_0x00008080 = (v8u16)__msa_fill_w(0x00008080);
+  v8u16 const_0x0015002a = (v8u16)__msa_fill_w(0x0015002a);
+  v8u16 const_0x0035000a = (v8u16)__msa_fill_w(0x0035000a);
+  v4i32 shift = __msa_fill_w(0x00000008);
+
+  for (x = 0; x < width; x += 32) {
+    src1 = __msa_ld_b((void*)s, 0);
+    src3 = __msa_ld_b((void*)s, 16);
+    src5 = __msa_ld_b((void*)t, 0);
+    src7 = __msa_ld_b((void*)t, 16);
+    src0 = __msa_ilvr_b(zero, src1);
+    src1 = __msa_ilvl_b(zero, src1);
+    src2 = __msa_ilvr_b(zero, src3);
+    src3 = __msa_ilvl_b(zero, src3);
+    src4 = __msa_ilvr_b(zero, src5);
+    src5 = __msa_ilvl_b(zero, src5);
+    src6 = __msa_ilvr_b(zero, src7);
+    src7 = __msa_ilvl_b(zero, src7);
+    src0 += src4;
+    src1 += src5;
+    src2 += src6;
+    src3 += src7;
+    src4 = __msa_ilvev_d(src1, src0);
+    src5 = __msa_ilvod_d(src1, src0);
+    src6 = __msa_ilvev_d(src3, src2);
+    src7 = __msa_ilvod_d(src3, src2);
+    vec0 = __msa_aver_u_h(src4, src5);
+    vec1 = __msa_aver_u_h(src6, src7);
+
+    src1 = __msa_ld_b((void*)s, 32);
+    src3 = __msa_ld_b((void*)s, 48);
+    src5 = __msa_ld_b((void*)t, 32);
+    src7 = __msa_ld_b((void*)t, 48);
+    src0 = __msa_ilvr_b(zero, src1);
+    src1 = __msa_ilvl_b(zero, src1);
+    src2 = __msa_ilvr_b(zero, src3);
+    src3 = __msa_ilvl_b(zero, src3);
+    src4 = __msa_ilvr_b(zero, src5);
+    src5 = __msa_ilvl_b(zero, src5);
+    src6 = __msa_ilvr_b(zero, src7);
+    src7 = __msa_ilvl_b(zero, src7);
+    src0 += src4;
+    src1 += src5;
+    src2 += src6;
+    src3 += src7;
+    src4 = __msa_ilvev_d(src1, src0);
+    src5 = __msa_ilvod_d(src1, src0);
+    src6 = __msa_ilvev_d(src3, src2);
+    src7 = __msa_ilvod_d(src3, src2);
+    vec2 = __msa_aver_u_h(src4, src5);
+    vec3 = __msa_aver_u_h(src6, src7);
+    ARGBTOUV(vec0, vec1, vec2, vec3, const_0x0000003f, const_0x00008080,
+             const_0x0015002a, const_0x0035000a, shuffler0, shuffler1,
+             shuffler2, shuffler3, shift, dst0, dst1);
+
+    src1 = __msa_ld_b((void*)s, 64);
+    src3 = __msa_ld_b((void*)s, 80);
+    src5 = __msa_ld_b((void*)t, 64);
+    src7 = __msa_ld_b((void*)t, 80);
+    src0 = __msa_ilvr_b(zero, src1);
+    src1 = __msa_ilvl_b(zero, src1);
+    src2 = __msa_ilvr_b(zero, src3);
+    src3 = __msa_ilvl_b(zero, src3);
+    src4 = __msa_ilvr_b(zero, src5);
+    src5 = __msa_ilvl_b(zero, src5);
+    src6 = __msa_ilvr_b(zero, src7);
+    src7 = __msa_ilvl_b(zero, src7);
+    src0 += src4;
+    src1 += src5;
+    src2 += src6;
+    src3 += src7;
+    src4 = __msa_ilvev_d(src1, src0);
+    src5 = __msa_ilvod_d(src1, src0);
+    src6 = __msa_ilvev_d(src3, src2);
+    src7 = __msa_ilvod_d(src3, src2);
+    vec0 = __msa_aver_u_h(src4, src5);
+    vec1 = __msa_aver_u_h(src6, src7);
+
+    src1 = __msa_ld_b((void*)s, 96);
+    src3 = __msa_ld_b((void*)s, 112);
+    src5 = __msa_ld_b((void*)t, 96);
+    src7 = __msa_ld_b((void*)t, 112);
+    src0 = __msa_ilvr_b(zero, src1);
+    src1 = __msa_ilvl_b(zero, src1);
+    src2 = __msa_ilvr_b(zero, src3);
+    src3 = __msa_ilvl_b(zero, src3);
+    src4 = __msa_ilvr_b(zero, src5);
+    src5 = __msa_ilvl_b(zero, src5);
+    src6 = __msa_ilvr_b(zero, src7);
+    src7 = __msa_ilvl_b(zero, src7);
+    src0 += src4;
+    src1 += src5;
+    src2 += src6;
+    src3 += src7;
+    src4 = __msa_ilvev_d(src1, src0);
+    src5 = __msa_ilvod_d(src1, src0);
+    src6 = __msa_ilvev_d(src3, src2);
+    src7 = __msa_ilvod_d(src3, src2);
+    vec2 = __msa_aver_u_h(src4, src5);
+    vec3 = __msa_aver_u_h(src6, src7);
+    ARGBTOUV(vec0, vec1, vec2, vec3, const_0x0000003f, const_0x00008080,
+             const_0x0015002a, const_0x0035000a, shuffler0, shuffler1,
+             shuffler2, shuffler3, shift, dst2, dst3);
+
+    dst0 = (v8u16)__msa_pckev_b(dst2, dst0);
+    dst1 = (v8u16)__msa_pckev_b(dst3, dst1);
+    ST_UB(dst0, dst_u);
+    ST_UB(dst1, dst_v);
+    s += 128;
+    t += 128;
+    dst_v += 16;
+    dst_u += 16;
+  }
+}
+
+void BGRAToUVRow_MSA(const uint8_t* src_rgb,
+                     int src_stride_rgb,
+                     uint8_t* dst_u,
+                     uint8_t* dst_v,
+                     int width) {
+  int x;
+  const uint8_t* s = src_rgb;
+  const uint8_t* t = src_rgb + src_stride_rgb;
+  const uint8_t unused = 0xf;
+  v8u16 src0, src1, src2, src3;
+  v16u8 dst0, dst1;
+  v8i16 shuffler0 = {1, unused, 5, unused, 9, unused, 13, unused};
+  v8i16 shuffler1 = {2, 3, 6, 7, 10, 11, 14, 15};
+  v8i16 shuffler2 = {3, unused, 7, unused, 11, unused, 15, unused};
+  v8i16 shuffler3 = {1, 2, 5, 6, 9, 10, 13, 14};
+  v8u16 const_0x09002f = (v8u16)__msa_fill_w(0x09002f);
+  v8u16 const_0x000038 = (v8u16)__msa_fill_w(0x0038);
+  v8u16 const_0x250013 = (v8u16)__msa_fill_w(0x250013);
+  v4u32 const_0x008080 = (v4u32)__msa_fill_w(0x8080);
+  v8u16 const_0x0001 = (v8u16)__msa_fill_h(0x0001);
+
+  for (x = 0; x < width; x += 16) {
+    READ_ARGB(s, t, src0, src1, src2, src3, const_0x0001);
+    ARGBTOUV_H(src0, src1, src2, src3, const_0x09002f, const_0x000038,
+               const_0x250013, const_0x008080, shuffler0, shuffler1, shuffler2,
+               shuffler3, dst0, dst1);
+    *((uint64_t*)dst_v) = __msa_copy_u_d((v2i64)dst0, 0);
+    *((uint64_t*)dst_u) = __msa_copy_u_d((v2i64)dst1, 0);
+    s += 64;
+    t += 64;
+    dst_u += 8;
+    dst_v += 8;
+  }
+}
+
+void ABGRToUVRow_MSA(const uint8_t* src_rgb,
+                     int src_stride_rgb,
+                     uint8_t* dst_u,
+                     uint8_t* dst_v,
+                     int width) {
+  int x;
+  const uint8_t* s = src_rgb;
+  const uint8_t* t = src_rgb + src_stride_rgb;
+  const uint8_t unused = 0xf;
+  v8u16 src0, src1, src2, src3;
+  v16u8 dst0, dst1;
+  v8i16 shuffler0 = {0, unused, 4, unused, 8, unused, 12, unused};
+  v8i16 shuffler1 = {1, 2, 5, 6, 9, 10, 13, 14};
+  v8i16 shuffler2 = {2, unused, 6, unused, 10, unused, 14, unused};
+  v8i16 shuffler3 = {0, 1, 4, 5, 8, 9, 12, 13};
+  v8u16 const_0x09002f = (v8u16)__msa_fill_w(0x09002f);
+  v8u16 const_0x000038 = (v8u16)__msa_fill_w(0x0038);
+  v8u16 const_0x250013 = (v8u16)__msa_fill_w(0x250013);
+  v4u32 const_0x008080 = (v4u32)__msa_fill_w(0x8080);
+  v8u16 const_0x0001 = (v8u16)__msa_fill_h(0x0001);
+
+  for (x = 0; x < width; x += 16) {
+    READ_ARGB(s, t, src0, src1, src2, src3, const_0x0001);
+    ARGBTOUV_H(src0, src1, src2, src3, const_0x09002f, const_0x000038,
+               const_0x250013, const_0x008080, shuffler0, shuffler1, shuffler2,
+               shuffler3, dst0, dst1);
+    *((uint64_t*)dst_v) = __msa_copy_u_d((v2i64)dst0, 0);
+    *((uint64_t*)dst_u) = __msa_copy_u_d((v2i64)dst1, 0);
+    s += 64;
+    t += 64;
+    dst_u += 8;
+    dst_v += 8;
+  }
+}
+
+void RGBAToUVRow_MSA(const uint8_t* src_rgb,
+                     int src_stride_rgb,
+                     uint8_t* dst_u,
+                     uint8_t* dst_v,
+                     int width) {
+  int x;
+  const uint8_t* s = src_rgb;
+  const uint8_t* t = src_rgb + src_stride_rgb;
+  const uint8_t unused = 0xf;
+  v8u16 src0, src1, src2, src3;
+  v16u8 dst0, dst1;
+  v8i16 shuffler0 = {3, unused, 7, unused, 11, unused, 15, unused};
+  v8i16 shuffler1 = {2, 1, 6, 5, 10, 9, 14, 13};
+  v8i16 shuffler2 = {1, unused, 5, unused, 9, unused, 13, unused};
+  v8i16 shuffler3 = {3, 2, 7, 6, 11, 10, 15, 14};
+  v8u16 const_0x09002f = (v8u16)__msa_fill_w(0x09002f);
+  v8u16 const_0x000038 = (v8u16)__msa_fill_w(0x0038);
+  v8u16 const_0x250013 = (v8u16)__msa_fill_w(0x250013);
+  v4u32 const_0x008080 = (v4u32)__msa_fill_w(0x8080);
+  v8u16 const_0x0001 = (v8u16)__msa_fill_h(0x0001);
+
+  for (x = 0; x < width; x += 16) {
+    READ_ARGB(s, t, src0, src1, src2, src3, const_0x0001);
+    ARGBTOUV_H(src0, src1, src2, src3, const_0x09002f, const_0x000038,
+               const_0x250013, const_0x008080, shuffler0, shuffler1, shuffler2,
+               shuffler3, dst0, dst1);
+    *((uint64_t*)dst_v) = __msa_copy_u_d((v2i64)dst0, 0);
+    *((uint64_t*)dst_u) = __msa_copy_u_d((v2i64)dst1, 0);
+    s += 64;
+    t += 64;
+    dst_u += 8;
+    dst_v += 8;
+  }
+}
+
+void I444ToARGBRow_MSA(const uint8_t* src_y,
+                       const uint8_t* src_u,
+                       const uint8_t* src_v,
+                       uint8_t* dst_argb,
+                       const struct YuvConstants* yuvconstants,
+                       int width) {
+  int x;
+  v16u8 src0, src1, src2, dst0, dst1;
+  v8i16 vec0, vec1, vec2;
+  v4i32 reg0, reg1, reg2, reg3, reg4, reg5, reg6, reg7, reg8, reg9;
+  v4i32 tmp0, tmp1, tmp2, tmp3, tmp4, tmp5;
+  v4i32 vec_ub, vec_vr, vec_ug, vec_vg, vec_yg, vec_yb;
+  v16u8 alpha = (v16u8)__msa_ldi_b(ALPHA_VAL);
+  v8i16 zero = {0};
+  v4i32 const_0x80 = __msa_fill_w(0x80);
+
+  YUVTORGB_SETUP(yuvconstants, vec_ub, vec_vr, vec_ug, vec_vg, vec_yg, vec_yb);
+
+  for (x = 0; x < width; x += 8) {
+    READI444(src_y, src_u, src_v, src0, src1, src2);
+    vec0 = (v8i16)__msa_ilvr_b((v16i8)src0, (v16i8)src0);
+    reg0 = (v4i32)__msa_ilvr_h((v8i16)zero, (v8i16)vec0);
+    reg1 = (v4i32)__msa_ilvl_h((v8i16)zero, (v8i16)vec0);
+    reg0 *= vec_yg;
+    reg1 *= vec_yg;
+    reg0 = __msa_srai_w(reg0, 16);
+    reg1 = __msa_srai_w(reg1, 16);
+    reg0 += vec_yb;
+    reg1 += vec_yb;
+    vec0 = (v8u16)__msa_ilvr_b((v16i8)zero, (v16i8)src1);
+    vec1 = (v8u16)__msa_ilvr_b((v16i8)zero, (v16i8)src2);
+    reg6 = (v4i32)__msa_ilvr_h((v8i16)zero, (v8i16)vec0);
+    reg7 = (v4i32)__msa_ilvl_h((v8i16)zero, (v8i16)vec0);
+    reg8 = (v4i32)__msa_ilvr_h((v8i16)zero, (v8i16)vec1);
+    reg9 = (v4i32)__msa_ilvl_h((v8i16)zero, (v8i16)vec1);
+    reg6 -= const_0x80;
+    reg7 -= const_0x80;
+    reg8 -= const_0x80;
+    reg9 -= const_0x80;
+    tmp0 = reg0 + reg6 * vec_ub;
+    tmp1 = reg1 + reg7 * vec_ub;
+    tmp2 = reg0 + reg8 * vec_vr;
+    tmp3 = reg1 + reg9 * vec_vr;
+    tmp4 = reg6 * vec_ug;
+    tmp5 = reg7 * vec_ug;
+    tmp4 += reg8 * vec_vg;
+    tmp5 += reg9 * vec_vg;
+    tmp4 = reg0 - tmp4;
+    tmp5 = reg1 - tmp5;
+    reg0 = __msa_srai_w(tmp0, 6);
+    reg1 = __msa_srai_w(tmp1, 6);
+    reg2 = __msa_srai_w(tmp2, 6);
+    reg3 = __msa_srai_w(tmp3, 6);
+    reg4 = __msa_srai_w(tmp4, 6);
+    reg5 = __msa_srai_w(tmp5, 6);
+    CLIP_0TO255(reg0, reg1, reg2, reg3, reg4, reg5);
+    vec0 = (v8u16)__msa_pckev_h((v8i16)reg1, (v8i16)reg0);
+    vec1 = (v8u16)__msa_pckev_h((v8i16)reg5, (v8i16)reg4);
+    vec2 = (v8u16)__msa_pckev_h((v8i16)reg3, (v8i16)reg2);
+    vec0 = (v8u16)__msa_ilvev_b((v16i8)vec1, (v16i8)vec0);
+    vec1 = (v8u16)__msa_ilvev_b((v16i8)alpha, (v16i8)vec2);
+    dst0 = (v16u8)__msa_ilvr_h((v8i16)vec1, (v8i16)vec0);
+    dst1 = (v16u8)__msa_ilvl_h((v8i16)vec1, (v8i16)vec0);
+    ST_UB2(dst0, dst1, dst_argb, 16);
+    src_y += 8;
+    src_u += 8;
+    src_v += 8;
+    dst_argb += 32;
+  }
+}
+
+// TODO - respect YuvConstants
+void I400ToARGBRow_MSA(const uint8_t* src_y,
+                       uint8_t* dst_argb,
+                       const struct YuvConstants* yuvconstants,
+                       int width) {
+  int x;
+#if defined(__aarch64__) || defined(__arm__)
+  int ygb = yuvconstants->kUVBiasBGR[3];
+  int yg = yuvconstants->kYToRgb[1];
+#else
+  int ygb = yuvconstants->kYBiasToRgb[0];
+  int yg = yuvconstants->kYToRgb[0];
+#endif
+  v16u8 src0, res0, res1, res2, res3, res4, dst0, dst1, dst2, dst3;
+  v8i16 vec0, vec1;
+  v4i32 reg0, reg1, reg2, reg3;
+  v4i32 vec_yg = __msa_fill_w(yg);
+  v8i16 vec_ygb = __msa_fill_h(ygb);
+  v16u8 alpha = (v16u8)__msa_ldi_b(ALPHA_VAL);
+  v8i16 max = __msa_ldi_h(0xFF);
+  v8i16 zero = {0};
+
+  for (x = 0; x < width; x += 16) {
+    src0 = (v16u8)__msa_ld_b((void*)src_y, 0);
+    vec0 = (v8i16)__msa_ilvr_b((v16i8)src0, (v16i8)src0);
+    vec1 = (v8i16)__msa_ilvl_b((v16i8)src0, (v16i8)src0);
+    reg0 = (v4i32)__msa_ilvr_h(zero, vec0);
+    reg1 = (v4i32)__msa_ilvl_h(zero, vec0);
+    reg2 = (v4i32)__msa_ilvr_h(zero, vec1);
+    reg3 = (v4i32)__msa_ilvl_h(zero, vec1);
+    reg0 *= vec_yg;
+    reg1 *= vec_yg;
+    reg2 *= vec_yg;
+    reg3 *= vec_yg;
+    reg0 = __msa_srai_w(reg0, 16);
+    reg1 = __msa_srai_w(reg1, 16);
+    reg2 = __msa_srai_w(reg2, 16);
+    reg3 = __msa_srai_w(reg3, 16);
+    vec0 = (v8i16)__msa_pckev_h((v8i16)reg1, (v8i16)reg0);
+    vec1 = (v8i16)__msa_pckev_h((v8i16)reg3, (v8i16)reg2);
+    vec0 += vec_ygb;
+    vec1 += vec_ygb;
+    vec0 = __msa_srai_h(vec0, 6);
+    vec1 = __msa_srai_h(vec1, 6);
+    vec0 = __msa_maxi_s_h(vec0, 0);
+    vec1 = __msa_maxi_s_h(vec1, 0);
+    vec0 = __msa_min_s_h(max, vec0);
+    vec1 = __msa_min_s_h(max, vec1);
+    res0 = (v16u8)__msa_pckev_b((v16i8)vec1, (v16i8)vec0);
+    res1 = (v16u8)__msa_ilvr_b((v16i8)res0, (v16i8)res0);
+    res2 = (v16u8)__msa_ilvl_b((v16i8)res0, (v16i8)res0);
+    res3 = (v16u8)__msa_ilvr_b((v16i8)alpha, (v16i8)res0);
+    res4 = (v16u8)__msa_ilvl_b((v16i8)alpha, (v16i8)res0);
+    dst0 = (v16u8)__msa_ilvr_b((v16i8)res3, (v16i8)res1);
+    dst1 = (v16u8)__msa_ilvl_b((v16i8)res3, (v16i8)res1);
+    dst2 = (v16u8)__msa_ilvr_b((v16i8)res4, (v16i8)res2);
+    dst3 = (v16u8)__msa_ilvl_b((v16i8)res4, (v16i8)res2);
+    ST_UB4(dst0, dst1, dst2, dst3, dst_argb, 16);
+    src_y += 16;
+    dst_argb += 64;
+  }
+}
+
+void J400ToARGBRow_MSA(const uint8_t* src_y, uint8_t* dst_argb, int width) {
+  int x;
+  v16u8 src0, vec0, vec1, vec2, vec3, dst0, dst1, dst2, dst3;
+  v16u8 alpha = (v16u8)__msa_ldi_b(ALPHA_VAL);
+
+  for (x = 0; x < width; x += 16) {
+    src0 = (v16u8)__msa_ld_b((void*)src_y, 0);
+    vec0 = (v16u8)__msa_ilvr_b((v16i8)src0, (v16i8)src0);
+    vec1 = (v16u8)__msa_ilvl_b((v16i8)src0, (v16i8)src0);
+    vec2 = (v16u8)__msa_ilvr_b((v16i8)alpha, (v16i8)src0);
+    vec3 = (v16u8)__msa_ilvl_b((v16i8)alpha, (v16i8)src0);
+    dst0 = (v16u8)__msa_ilvr_b((v16i8)vec2, (v16i8)vec0);
+    dst1 = (v16u8)__msa_ilvl_b((v16i8)vec2, (v16i8)vec0);
+    dst2 = (v16u8)__msa_ilvr_b((v16i8)vec3, (v16i8)vec1);
+    dst3 = (v16u8)__msa_ilvl_b((v16i8)vec3, (v16i8)vec1);
+    ST_UB4(dst0, dst1, dst2, dst3, dst_argb, 16);
+    src_y += 16;
+    dst_argb += 64;
+  }
+}
+
+void YUY2ToARGBRow_MSA(const uint8_t* src_yuy2,
+                       uint8_t* dst_argb,
+                       const struct YuvConstants* yuvconstants,
+                       int width) {
+  int x;
+  v16u8 src0, src1, src2;
+  v8i16 vec0, vec1, vec2;
+  v4i32 vec_ub, vec_vr, vec_ug, vec_vg, vec_yg, vec_yb;
+  v4i32 vec_ubvr, vec_ugvg;
+  v16u8 alpha = (v16u8)__msa_ldi_b(ALPHA_VAL);
+  v8i16 const_0x80 = __msa_ldi_h(0x80);
+
+  YUVTORGB_SETUP(yuvconstants, vec_ub, vec_vr, vec_ug, vec_vg, vec_yg, vec_yb);
+  vec_ubvr = __msa_ilvr_w(vec_vr, vec_ub);
+  vec_ugvg = (v4i32)__msa_ilvev_h((v8i16)vec_vg, (v8i16)vec_ug);
+
+  for (x = 0; x < width; x += 8) {
+    src0 = (v16u8)__msa_ld_b((void*)src_yuy2, 0);
+    src1 = (v16u8)__msa_pckev_b((v16i8)src0, (v16i8)src0);
+    src2 = (v16u8)__msa_pckod_b((v16i8)src0, (v16i8)src0);
+    YUVTORGB(src1, src2, vec_ubvr, vec_ugvg, vec_yg, vec_yb, vec0, vec1, vec2);
+    STOREARGB(vec0, vec1, vec2, alpha, dst_argb);
+    src_yuy2 += 16;
+    dst_argb += 32;
+  }
+}
+
+void UYVYToARGBRow_MSA(const uint8_t* src_uyvy,
+                       uint8_t* dst_argb,
+                       const struct YuvConstants* yuvconstants,
+                       int width) {
+  int x;
+  v16u8 src0, src1, src2;
+  v8i16 vec0, vec1, vec2;
+  v4i32 vec_ub, vec_vr, vec_ug, vec_vg, vec_yg, vec_yb;
+  v4i32 vec_ubvr, vec_ugvg;
+  v8i16 const_0x80 = __msa_ldi_h(0x80);
+  v16u8 alpha = (v16u8)__msa_ldi_b(ALPHA_VAL);
+
+  YUVTORGB_SETUP(yuvconstants, vec_ub, vec_vr, vec_ug, vec_vg, vec_yg, vec_yb);
+  vec_ubvr = __msa_ilvr_w(vec_vr, vec_ub);
+  vec_ugvg = (v4i32)__msa_ilvev_h((v8i16)vec_vg, (v8i16)vec_ug);
+
+  for (x = 0; x < width; x += 8) {
+    src0 = (v16u8)__msa_ld_b((void*)src_uyvy, 0);
+    src1 = (v16u8)__msa_pckod_b((v16i8)src0, (v16i8)src0);
+    src2 = (v16u8)__msa_pckev_b((v16i8)src0, (v16i8)src0);
+    YUVTORGB(src1, src2, vec_ubvr, vec_ugvg, vec_yg, vec_yb, vec0, vec1, vec2);
+    STOREARGB(vec0, vec1, vec2, alpha, dst_argb);
+    src_uyvy += 16;
+    dst_argb += 32;
+  }
+}
+
+void InterpolateRow_MSA(uint8_t* dst_ptr,
+                        const uint8_t* src_ptr,
+                        ptrdiff_t src_stride,
+                        int width,
+                        int32_t source_y_fraction) {
+  int32_t y1_fraction = source_y_fraction;
+  int32_t y0_fraction = 256 - y1_fraction;
+  uint16_t y_fractions;
+  const uint8_t* s = src_ptr;
+  const uint8_t* t = src_ptr + src_stride;
+  int x;
+  v16u8 src0, src1, src2, src3, dst0, dst1;
+  v8u16 vec0, vec1, vec2, vec3, y_frac;
+
+  if (0 == y1_fraction) {
+    memcpy(dst_ptr, src_ptr, width);
+    return;
+  }
+
+  if (128 == y1_fraction) {
+    for (x = 0; x < width; x += 32) {
+      src0 = (v16u8)__msa_ld_b((void*)s, 0);
+      src1 = (v16u8)__msa_ld_b((void*)s, 16);
+      src2 = (v16u8)__msa_ld_b((void*)t, 0);
+      src3 = (v16u8)__msa_ld_b((void*)t, 16);
+      dst0 = __msa_aver_u_b(src0, src2);
+      dst1 = __msa_aver_u_b(src1, src3);
+      ST_UB2(dst0, dst1, dst_ptr, 16);
+      s += 32;
+      t += 32;
+      dst_ptr += 32;
+    }
+    return;
+  }
+
+  y_fractions = (uint16_t)(y0_fraction + (y1_fraction << 8));
+  y_frac = (v8u16)__msa_fill_h(y_fractions);
+
+  for (x = 0; x < width; x += 32) {
+    src0 = (v16u8)__msa_ld_b((void*)s, 0);
+    src1 = (v16u8)__msa_ld_b((void*)s, 16);
+    src2 = (v16u8)__msa_ld_b((void*)t, 0);
+    src3 = (v16u8)__msa_ld_b((void*)t, 16);
+    vec0 = (v8u16)__msa_ilvr_b((v16i8)src2, (v16i8)src0);
+    vec1 = (v8u16)__msa_ilvl_b((v16i8)src2, (v16i8)src0);
+    vec2 = (v8u16)__msa_ilvr_b((v16i8)src3, (v16i8)src1);
+    vec3 = (v8u16)__msa_ilvl_b((v16i8)src3, (v16i8)src1);
+    vec0 = (v8u16)__msa_dotp_u_h((v16u8)vec0, (v16u8)y_frac);
+    vec1 = (v8u16)__msa_dotp_u_h((v16u8)vec1, (v16u8)y_frac);
+    vec2 = (v8u16)__msa_dotp_u_h((v16u8)vec2, (v16u8)y_frac);
+    vec3 = (v8u16)__msa_dotp_u_h((v16u8)vec3, (v16u8)y_frac);
+    vec0 = (v8u16)__msa_srari_h((v8i16)vec0, 8);
+    vec1 = (v8u16)__msa_srari_h((v8i16)vec1, 8);
+    vec2 = (v8u16)__msa_srari_h((v8i16)vec2, 8);
+    vec3 = (v8u16)__msa_srari_h((v8i16)vec3, 8);
+    dst0 = (v16u8)__msa_pckev_b((v16i8)vec1, (v16i8)vec0);
+    dst1 = (v16u8)__msa_pckev_b((v16i8)vec3, (v16i8)vec2);
+    ST_UB2(dst0, dst1, dst_ptr, 16);
+    s += 32;
+    t += 32;
+    dst_ptr += 32;
+  }
+}
+
+void ARGBSetRow_MSA(uint8_t* dst_argb, uint32_t v32, int width) {
+  int x;
+  v4i32 dst0 = __builtin_msa_fill_w(v32);
+
+  for (x = 0; x < width; x += 4) {
+    ST_UB(dst0, dst_argb);
+    dst_argb += 16;
+  }
+}
+
+void RAWToRGB24Row_MSA(const uint8_t* src_raw, uint8_t* dst_rgb24, int width) {
+  int x;
+  v16u8 src0, src1, src2, src3, src4, dst0, dst1, dst2;
+  v16i8 shuffler0 = {2, 1, 0, 5, 4, 3, 8, 7, 6, 11, 10, 9, 14, 13, 12, 17};
+  v16i8 shuffler1 = {8,  7,  12, 11, 10, 15, 14, 13,
+                     18, 17, 16, 21, 20, 19, 24, 23};
+  v16i8 shuffler2 = {14, 19, 18, 17, 22, 21, 20, 25,
+                     24, 23, 28, 27, 26, 31, 30, 29};
+
+  for (x = 0; x < width; x += 16) {
+    src0 = (v16u8)__msa_ld_b((void*)src_raw, 0);
+    src1 = (v16u8)__msa_ld_b((void*)src_raw, 16);
+    src2 = (v16u8)__msa_ld_b((void*)src_raw, 32);
+    src3 = (v16u8)__msa_sldi_b((v16i8)src1, (v16i8)src0, 8);
+    src4 = (v16u8)__msa_sldi_b((v16i8)src2, (v16i8)src1, 8);
+    dst0 = (v16u8)__msa_vshf_b(shuffler0, (v16i8)src1, (v16i8)src0);
+    dst1 = (v16u8)__msa_vshf_b(shuffler1, (v16i8)src4, (v16i8)src3);
+    dst2 = (v16u8)__msa_vshf_b(shuffler2, (v16i8)src2, (v16i8)src1);
+    ST_UB2(dst0, dst1, dst_rgb24, 16);
+    ST_UB(dst2, (dst_rgb24 + 32));
+    src_raw += 48;
+    dst_rgb24 += 48;
+  }
+}
+
+void MergeUVRow_MSA(const uint8_t* src_u,
+                    const uint8_t* src_v,
+                    uint8_t* dst_uv,
+                    int width) {
+  int x;
+  v16u8 src0, src1, dst0, dst1;
+
+  for (x = 0; x < width; x += 16) {
+    src0 = (v16u8)__msa_ld_b((void*)src_u, 0);
+    src1 = (v16u8)__msa_ld_b((void*)src_v, 0);
+    dst0 = (v16u8)__msa_ilvr_b((v16i8)src1, (v16i8)src0);
+    dst1 = (v16u8)__msa_ilvl_b((v16i8)src1, (v16i8)src0);
+    ST_UB2(dst0, dst1, dst_uv, 16);
+    src_u += 16;
+    src_v += 16;
+    dst_uv += 32;
+  }
+}
+
+void ARGBExtractAlphaRow_MSA(const uint8_t* src_argb,
+                             uint8_t* dst_a,
+                             int width) {
+  int i;
+  v16u8 src0, src1, src2, src3, vec0, vec1, dst0;
+
+  for (i = 0; i < width; i += 16) {
+    src0 = (v16u8)__msa_ld_b((void*)src_argb, 0);
+    src1 = (v16u8)__msa_ld_b((void*)src_argb, 16);
+    src2 = (v16u8)__msa_ld_b((void*)src_argb, 32);
+    src3 = (v16u8)__msa_ld_b((void*)src_argb, 48);
+    vec0 = (v16u8)__msa_pckod_b((v16i8)src1, (v16i8)src0);
+    vec1 = (v16u8)__msa_pckod_b((v16i8)src3, (v16i8)src2);
+    dst0 = (v16u8)__msa_pckod_b((v16i8)vec1, (v16i8)vec0);
+    ST_UB(dst0, dst_a);
+    src_argb += 64;
+    dst_a += 16;
+  }
+}
+
+void ARGBBlendRow_MSA(const uint8_t* src_argb,
+                      const uint8_t* src_argb1,
+                      uint8_t* dst_argb,
+                      int width) {
+  int x;
+  v16u8 src0, src1, src2, src3, dst0, dst1, dst2, dst3;
+  v8u16 vec0, vec1, vec2, vec3, vec4, vec5, vec6, vec7;
+  v8u16 vec8, vec9, vec10, vec11, vec12, vec13;
+  v8u16 const_256 = (v8u16)__msa_ldi_h(256);
+  v16u8 const_255 = (v16u8)__msa_ldi_b(255);
+  v16u8 mask = {0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 255};
+  v16i8 zero = {0};
+
+  for (x = 0; x < width; x += 8) {
+    src0 = (v16u8)__msa_ld_b((void*)src_argb, 0);
+    src1 = (v16u8)__msa_ld_b((void*)src_argb, 16);
+    src2 = (v16u8)__msa_ld_b((void*)src_argb1, 0);
+    src3 = (v16u8)__msa_ld_b((void*)src_argb1, 16);
+    vec0 = (v8u16)__msa_ilvr_b(zero, (v16i8)src0);
+    vec1 = (v8u16)__msa_ilvl_b(zero, (v16i8)src0);
+    vec2 = (v8u16)__msa_ilvr_b(zero, (v16i8)src1);
+    vec3 = (v8u16)__msa_ilvl_b(zero, (v16i8)src1);
+    vec4 = (v8u16)__msa_ilvr_b(zero, (v16i8)src2);
+    vec5 = (v8u16)__msa_ilvl_b(zero, (v16i8)src2);
+    vec6 = (v8u16)__msa_ilvr_b(zero, (v16i8)src3);
+    vec7 = (v8u16)__msa_ilvl_b(zero, (v16i8)src3);
+    vec8 = (v8u16)__msa_fill_h(vec0[3]);
+    vec9 = (v8u16)__msa_fill_h(vec0[7]);
+    vec10 = (v8u16)__msa_fill_h(vec1[3]);
+    vec11 = (v8u16)__msa_fill_h(vec1[7]);
+    vec8 = (v8u16)__msa_pckev_d((v2i64)vec9, (v2i64)vec8);
+    vec9 = (v8u16)__msa_pckev_d((v2i64)vec11, (v2i64)vec10);
+    vec10 = (v8u16)__msa_fill_h(vec2[3]);
+    vec11 = (v8u16)__msa_fill_h(vec2[7]);
+    vec12 = (v8u16)__msa_fill_h(vec3[3]);
+    vec13 = (v8u16)__msa_fill_h(vec3[7]);
+    vec10 = (v8u16)__msa_pckev_d((v2i64)vec11, (v2i64)vec10);
+    vec11 = (v8u16)__msa_pckev_d((v2i64)vec13, (v2i64)vec12);
+    vec8 = const_256 - vec8;
+    vec9 = const_256 - vec9;
+    vec10 = const_256 - vec10;
+    vec11 = const_256 - vec11;
+    vec8 *= vec4;
+    vec9 *= vec5;
+    vec10 *= vec6;
+    vec11 *= vec7;
+    vec8 = (v8u16)__msa_srai_h((v8i16)vec8, 8);
+    vec9 = (v8u16)__msa_srai_h((v8i16)vec9, 8);
+    vec10 = (v8u16)__msa_srai_h((v8i16)vec10, 8);
+    vec11 = (v8u16)__msa_srai_h((v8i16)vec11, 8);
+    dst0 = (v16u8)__msa_pckev_b((v16i8)vec1, (v16i8)vec0);
+    dst1 = (v16u8)__msa_pckev_b((v16i8)vec3, (v16i8)vec2);
+    dst2 = (v16u8)__msa_pckev_b((v16i8)vec9, (v16i8)vec8);
+    dst3 = (v16u8)__msa_pckev_b((v16i8)vec11, (v16i8)vec10);
+    dst0 = (v16u8)__msa_adds_u_b(dst0, dst2);
+    dst1 = (v16u8)__msa_adds_u_b(dst1, dst3);
+    dst0 = __msa_bmnz_v(dst0, const_255, mask);
+    dst1 = __msa_bmnz_v(dst1, const_255, mask);
+    ST_UB2(dst0, dst1, dst_argb, 16);
+    src_argb += 32;
+    src_argb1 += 32;
+    dst_argb += 32;
+  }
+}
+
+void ARGBQuantizeRow_MSA(uint8_t* dst_argb,
+                         int scale,
+                         int interval_size,
+                         int interval_offset,
+                         int width) {
+  int x;
+  v16u8 src0, src1, src2, src3, dst0, dst1, dst2, dst3;
+  v8i16 vec0, vec1, vec2, vec3, vec4, vec5, vec6, vec7;
+  v4i32 tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
+  v4i32 tmp8, tmp9, tmp10, tmp11, tmp12, tmp13, tmp14, tmp15;
+  v4i32 vec_scale = __msa_fill_w(scale);
+  v16u8 vec_int_sz = (v16u8)__msa_fill_b(interval_size);
+  v16u8 vec_int_ofst = (v16u8)__msa_fill_b(interval_offset);
+  v16i8 mask = {0, 1, 2, 19, 4, 5, 6, 23, 8, 9, 10, 27, 12, 13, 14, 31};
+  v16i8 zero = {0};
+
+  for (x = 0; x < width; x += 16) {
+    src0 = (v16u8)__msa_ld_b((void*)dst_argb, 0);
+    src1 = (v16u8)__msa_ld_b((void*)dst_argb, 16);
+    src2 = (v16u8)__msa_ld_b((void*)dst_argb, 32);
+    src3 = (v16u8)__msa_ld_b((void*)dst_argb, 48);
+    vec0 = (v8i16)__msa_ilvr_b(zero, (v16i8)src0);
+    vec1 = (v8i16)__msa_ilvl_b(zero, (v16i8)src0);
+    vec2 = (v8i16)__msa_ilvr_b(zero, (v16i8)src1);
+    vec3 = (v8i16)__msa_ilvl_b(zero, (v16i8)src1);
+    vec4 = (v8i16)__msa_ilvr_b(zero, (v16i8)src2);
+    vec5 = (v8i16)__msa_ilvl_b(zero, (v16i8)src2);
+    vec6 = (v8i16)__msa_ilvr_b(zero, (v16i8)src3);
+    vec7 = (v8i16)__msa_ilvl_b(zero, (v16i8)src3);
+    tmp0 = (v4i32)__msa_ilvr_h((v8i16)zero, (v8i16)vec0);
+    tmp1 = (v4i32)__msa_ilvl_h((v8i16)zero, (v8i16)vec0);
+    tmp2 = (v4i32)__msa_ilvr_h((v8i16)zero, (v8i16)vec1);
+    tmp3 = (v4i32)__msa_ilvl_h((v8i16)zero, (v8i16)vec1);
+    tmp4 = (v4i32)__msa_ilvr_h((v8i16)zero, (v8i16)vec2);
+    tmp5 = (v4i32)__msa_ilvl_h((v8i16)zero, (v8i16)vec2);
+    tmp6 = (v4i32)__msa_ilvr_h((v8i16)zero, (v8i16)vec3);
+    tmp7 = (v4i32)__msa_ilvl_h((v8i16)zero, (v8i16)vec3);
+    tmp8 = (v4i32)__msa_ilvr_h((v8i16)zero, (v8i16)vec4);
+    tmp9 = (v4i32)__msa_ilvl_h((v8i16)zero, (v8i16)vec4);
+    tmp10 = (v4i32)__msa_ilvr_h((v8i16)zero, (v8i16)vec5);
+    tmp11 = (v4i32)__msa_ilvl_h((v8i16)zero, (v8i16)vec5);
+    tmp12 = (v4i32)__msa_ilvr_h((v8i16)zero, (v8i16)vec6);
+    tmp13 = (v4i32)__msa_ilvl_h((v8i16)zero, (v8i16)vec6);
+    tmp14 = (v4i32)__msa_ilvr_h((v8i16)zero, (v8i16)vec7);
+    tmp15 = (v4i32)__msa_ilvl_h((v8i16)zero, (v8i16)vec7);
+    tmp0 *= vec_scale;
+    tmp1 *= vec_scale;
+    tmp2 *= vec_scale;
+    tmp3 *= vec_scale;
+    tmp4 *= vec_scale;
+    tmp5 *= vec_scale;
+    tmp6 *= vec_scale;
+    tmp7 *= vec_scale;
+    tmp8 *= vec_scale;
+    tmp9 *= vec_scale;
+    tmp10 *= vec_scale;
+    tmp11 *= vec_scale;
+    tmp12 *= vec_scale;
+    tmp13 *= vec_scale;
+    tmp14 *= vec_scale;
+    tmp15 *= vec_scale;
+    tmp0 >>= 16;
+    tmp1 >>= 16;
+    tmp2 >>= 16;
+    tmp3 >>= 16;
+    tmp4 >>= 16;
+    tmp5 >>= 16;
+    tmp6 >>= 16;
+    tmp7 >>= 16;
+    tmp8 >>= 16;
+    tmp9 >>= 16;
+    tmp10 >>= 16;
+    tmp11 >>= 16;
+    tmp12 >>= 16;
+    tmp13 >>= 16;
+    tmp14 >>= 16;
+    tmp15 >>= 16;
+    vec0 = (v8i16)__msa_pckev_h((v8i16)tmp1, (v8i16)tmp0);
+    vec1 = (v8i16)__msa_pckev_h((v8i16)tmp3, (v8i16)tmp2);
+    vec2 = (v8i16)__msa_pckev_h((v8i16)tmp5, (v8i16)tmp4);
+    vec3 = (v8i16)__msa_pckev_h((v8i16)tmp7, (v8i16)tmp6);
+    vec4 = (v8i16)__msa_pckev_h((v8i16)tmp9, (v8i16)tmp8);
+    vec5 = (v8i16)__msa_pckev_h((v8i16)tmp11, (v8i16)tmp10);
+    vec6 = (v8i16)__msa_pckev_h((v8i16)tmp13, (v8i16)tmp12);
+    vec7 = (v8i16)__msa_pckev_h((v8i16)tmp15, (v8i16)tmp14);
+    dst0 = (v16u8)__msa_pckev_b((v16i8)vec1, (v16i8)vec0);
+    dst1 = (v16u8)__msa_pckev_b((v16i8)vec3, (v16i8)vec2);
+    dst2 = (v16u8)__msa_pckev_b((v16i8)vec5, (v16i8)vec4);
+    dst3 = (v16u8)__msa_pckev_b((v16i8)vec7, (v16i8)vec6);
+    dst0 *= vec_int_sz;
+    dst1 *= vec_int_sz;
+    dst2 *= vec_int_sz;
+    dst3 *= vec_int_sz;
+    dst0 += vec_int_ofst;
+    dst1 += vec_int_ofst;
+    dst2 += vec_int_ofst;
+    dst3 += vec_int_ofst;
+    dst0 = (v16u8)__msa_vshf_b(mask, (v16i8)src0, (v16i8)dst0);
+    dst1 = (v16u8)__msa_vshf_b(mask, (v16i8)src1, (v16i8)dst1);
+    dst2 = (v16u8)__msa_vshf_b(mask, (v16i8)src2, (v16i8)dst2);
+    dst3 = (v16u8)__msa_vshf_b(mask, (v16i8)src3, (v16i8)dst3);
+    ST_UB4(dst0, dst1, dst2, dst3, dst_argb, 16);
+    dst_argb += 64;
+  }
+}
+
+void ARGBColorMatrixRow_MSA(const uint8_t* src_argb,
+                            uint8_t* dst_argb,
+                            const int8_t* matrix_argb,
+                            int width) {
+  int32_t x;
+  v16i8 src0;
+  v16u8 src1, src2, dst0, dst1;
+  v8i16 vec0, vec1, vec2, vec3, vec4, vec5, vec6, vec7, vec8, vec9;
+  v8i16 vec10, vec11, vec12, vec13, vec14, vec15, vec16, vec17;
+  v4i32 tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
+  v4i32 tmp8, tmp9, tmp10, tmp11, tmp12, tmp13, tmp14, tmp15;
+  v16i8 zero = {0};
+  v8i16 max = __msa_ldi_h(255);
+
+  src0 = __msa_ld_b((void*)matrix_argb, 0);
+  vec0 = (v8i16)__msa_ilvr_b(zero, src0);
+  vec1 = (v8i16)__msa_ilvl_b(zero, src0);
+
+  for (x = 0; x < width; x += 8) {
+    src1 = (v16u8)__msa_ld_b((void*)src_argb, 0);
+    src2 = (v16u8)__msa_ld_b((void*)src_argb, 16);
+    vec2 = (v8i16)__msa_ilvr_b(zero, (v16i8)src1);
+    vec3 = (v8i16)__msa_ilvl_b(zero, (v16i8)src1);
+    vec4 = (v8i16)__msa_ilvr_b(zero, (v16i8)src2);
+    vec5 = (v8i16)__msa_ilvl_b(zero, (v16i8)src2);
+    vec6 = (v8i16)__msa_pckod_d((v2i64)vec2, (v2i64)vec2);
+    vec7 = (v8i16)__msa_pckod_d((v2i64)vec3, (v2i64)vec3);
+    vec8 = (v8i16)__msa_pckod_d((v2i64)vec4, (v2i64)vec4);
+    vec9 = (v8i16)__msa_pckod_d((v2i64)vec5, (v2i64)vec5);
+    vec2 = (v8i16)__msa_pckev_d((v2i64)vec2, (v2i64)vec2);
+    vec3 = (v8i16)__msa_pckev_d((v2i64)vec3, (v2i64)vec3);
+    vec4 = (v8i16)__msa_pckev_d((v2i64)vec4, (v2i64)vec4);
+    vec5 = (v8i16)__msa_pckev_d((v2i64)vec5, (v2i64)vec5);
+    vec10 = vec2 * vec0;
+    vec11 = vec2 * vec1;
+    vec12 = vec6 * vec0;
+    vec13 = vec6 * vec1;
+    tmp0 = __msa_hadd_s_w(vec10, vec10);
+    tmp1 = __msa_hadd_s_w(vec11, vec11);
+    tmp2 = __msa_hadd_s_w(vec12, vec12);
+    tmp3 = __msa_hadd_s_w(vec13, vec13);
+    vec14 = vec3 * vec0;
+    vec15 = vec3 * vec1;
+    vec16 = vec7 * vec0;
+    vec17 = vec7 * vec1;
+    tmp4 = __msa_hadd_s_w(vec14, vec14);
+    tmp5 = __msa_hadd_s_w(vec15, vec15);
+    tmp6 = __msa_hadd_s_w(vec16, vec16);
+    tmp7 = __msa_hadd_s_w(vec17, vec17);
+    vec10 = __msa_pckev_h((v8i16)tmp1, (v8i16)tmp0);
+    vec11 = __msa_pckev_h((v8i16)tmp3, (v8i16)tmp2);
+    vec12 = __msa_pckev_h((v8i16)tmp5, (v8i16)tmp4);
+    vec13 = __msa_pckev_h((v8i16)tmp7, (v8i16)tmp6);
+    tmp0 = __msa_hadd_s_w(vec10, vec10);
+    tmp1 = __msa_hadd_s_w(vec11, vec11);
+    tmp2 = __msa_hadd_s_w(vec12, vec12);
+    tmp3 = __msa_hadd_s_w(vec13, vec13);
+    tmp0 = __msa_srai_w(tmp0, 6);
+    tmp1 = __msa_srai_w(tmp1, 6);
+    tmp2 = __msa_srai_w(tmp2, 6);
+    tmp3 = __msa_srai_w(tmp3, 6);
+    vec2 = vec4 * vec0;
+    vec6 = vec4 * vec1;
+    vec3 = vec8 * vec0;
+    vec7 = vec8 * vec1;
+    tmp8 = __msa_hadd_s_w(vec2, vec2);
+    tmp9 = __msa_hadd_s_w(vec6, vec6);
+    tmp10 = __msa_hadd_s_w(vec3, vec3);
+    tmp11 = __msa_hadd_s_w(vec7, vec7);
+    vec4 = vec5 * vec0;
+    vec8 = vec5 * vec1;
+    vec5 = vec9 * vec0;
+    vec9 = vec9 * vec1;
+    tmp12 = __msa_hadd_s_w(vec4, vec4);
+    tmp13 = __msa_hadd_s_w(vec8, vec8);
+    tmp14 = __msa_hadd_s_w(vec5, vec5);
+    tmp15 = __msa_hadd_s_w(vec9, vec9);
+    vec14 = __msa_pckev_h((v8i16)tmp9, (v8i16)tmp8);
+    vec15 = __msa_pckev_h((v8i16)tmp11, (v8i16)tmp10);
+    vec16 = __msa_pckev_h((v8i16)tmp13, (v8i16)tmp12);
+    vec17 = __msa_pckev_h((v8i16)tmp15, (v8i16)tmp14);
+    tmp4 = __msa_hadd_s_w(vec14, vec14);
+    tmp5 = __msa_hadd_s_w(vec15, vec15);
+    tmp6 = __msa_hadd_s_w(vec16, vec16);
+    tmp7 = __msa_hadd_s_w(vec17, vec17);
+    tmp4 = __msa_srai_w(tmp4, 6);
+    tmp5 = __msa_srai_w(tmp5, 6);
+    tmp6 = __msa_srai_w(tmp6, 6);
+    tmp7 = __msa_srai_w(tmp7, 6);
+    vec10 = __msa_pckev_h((v8i16)tmp1, (v8i16)tmp0);
+    vec11 = __msa_pckev_h((v8i16)tmp3, (v8i16)tmp2);
+    vec12 = __msa_pckev_h((v8i16)tmp5, (v8i16)tmp4);
+    vec13 = __msa_pckev_h((v8i16)tmp7, (v8i16)tmp6);
+    vec10 = __msa_maxi_s_h(vec10, 0);
+    vec11 = __msa_maxi_s_h(vec11, 0);
+    vec12 = __msa_maxi_s_h(vec12, 0);
+    vec13 = __msa_maxi_s_h(vec13, 0);
+    vec10 = __msa_min_s_h(vec10, max);
+    vec11 = __msa_min_s_h(vec11, max);
+    vec12 = __msa_min_s_h(vec12, max);
+    vec13 = __msa_min_s_h(vec13, max);
+    dst0 = (v16u8)__msa_pckev_b((v16i8)vec11, (v16i8)vec10);
+    dst1 = (v16u8)__msa_pckev_b((v16i8)vec13, (v16i8)vec12);
+    ST_UB2(dst0, dst1, dst_argb, 16);
+    src_argb += 32;
+    dst_argb += 32;
+  }
+}
+
+void SplitUVRow_MSA(const uint8_t* src_uv,
+                    uint8_t* dst_u,
+                    uint8_t* dst_v,
+                    int width) {
+  int x;
+  v16u8 src0, src1, src2, src3, dst0, dst1, dst2, dst3;
+
+  for (x = 0; x < width; x += 32) {
+    src0 = (v16u8)__msa_ld_b((void*)src_uv, 0);
+    src1 = (v16u8)__msa_ld_b((void*)src_uv, 16);
+    src2 = (v16u8)__msa_ld_b((void*)src_uv, 32);
+    src3 = (v16u8)__msa_ld_b((void*)src_uv, 48);
+    dst0 = (v16u8)__msa_pckev_b((v16i8)src1, (v16i8)src0);
+    dst1 = (v16u8)__msa_pckev_b((v16i8)src3, (v16i8)src2);
+    dst2 = (v16u8)__msa_pckod_b((v16i8)src1, (v16i8)src0);
+    dst3 = (v16u8)__msa_pckod_b((v16i8)src3, (v16i8)src2);
+    ST_UB2(dst0, dst1, dst_u, 16);
+    ST_UB2(dst2, dst3, dst_v, 16);
+    src_uv += 64;
+    dst_u += 32;
+    dst_v += 32;
+  }
+}
+
+void SetRow_MSA(uint8_t* dst, uint8_t v8, int width) {
+  int x;
+  v16u8 dst0 = (v16u8)__msa_fill_b(v8);
+
+  for (x = 0; x < width; x += 16) {
+    ST_UB(dst0, dst);
+    dst += 16;
+  }
+}
+
+void MirrorSplitUVRow_MSA(const uint8_t* src_uv,
+                          uint8_t* dst_u,
+                          uint8_t* dst_v,
+                          int width) {
+  int x;
+  v16u8 src0, src1, src2, src3;
+  v16u8 dst0, dst1, dst2, dst3;
+  v16i8 mask0 = {30, 28, 26, 24, 22, 20, 18, 16, 14, 12, 10, 8, 6, 4, 2, 0};
+  v16i8 mask1 = {31, 29, 27, 25, 23, 21, 19, 17, 15, 13, 11, 9, 7, 5, 3, 1};
+
+  src_uv += (2 * width);
+
+  for (x = 0; x < width; x += 32) {
+    src_uv -= 64;
+    src2 = (v16u8)__msa_ld_b((void*)src_uv, 0);
+    src3 = (v16u8)__msa_ld_b((void*)src_uv, 16);
+    src0 = (v16u8)__msa_ld_b((void*)src_uv, 32);
+    src1 = (v16u8)__msa_ld_b((void*)src_uv, 48);
+    dst0 = (v16u8)__msa_vshf_b(mask1, (v16i8)src1, (v16i8)src0);
+    dst1 = (v16u8)__msa_vshf_b(mask1, (v16i8)src3, (v16i8)src2);
+    dst2 = (v16u8)__msa_vshf_b(mask0, (v16i8)src1, (v16i8)src0);
+    dst3 = (v16u8)__msa_vshf_b(mask0, (v16i8)src3, (v16i8)src2);
+    ST_UB2(dst0, dst1, dst_v, 16);
+    ST_UB2(dst2, dst3, dst_u, 16);
+    dst_u += 32;
+    dst_v += 32;
+  }
+}
+
+void SobelXRow_MSA(const uint8_t* src_y0,
+                   const uint8_t* src_y1,
+                   const uint8_t* src_y2,
+                   uint8_t* dst_sobelx,
+                   int32_t width) {
+  int x;
+  v16u8 src0, src1, src2, src3, src4, src5, dst0;
+  v8i16 vec0, vec1, vec2, vec3, vec4, vec5;
+  v16i8 mask0 = {0, 2, 1, 3, 2, 4, 3, 5, 4, 6, 5, 7, 6, 8, 7, 9};
+  v16i8 tmp = __msa_ldi_b(8);
+  v16i8 mask1 = mask0 + tmp;
+  v8i16 zero = {0};
+  v8i16 max = __msa_ldi_h(255);
+
+  for (x = 0; x < width; x += 16) {
+    src0 = (v16u8)__msa_ld_b((void*)src_y0, 0);
+    src1 = (v16u8)__msa_ld_b((void*)src_y0, 16);
+    src2 = (v16u8)__msa_ld_b((void*)src_y1, 0);
+    src3 = (v16u8)__msa_ld_b((void*)src_y1, 16);
+    src4 = (v16u8)__msa_ld_b((void*)src_y2, 0);
+    src5 = (v16u8)__msa_ld_b((void*)src_y2, 16);
+    vec0 = (v8i16)__msa_vshf_b(mask0, (v16i8)src1, (v16i8)src0);
+    vec1 = (v8i16)__msa_vshf_b(mask1, (v16i8)src1, (v16i8)src0);
+    vec2 = (v8i16)__msa_vshf_b(mask0, (v16i8)src3, (v16i8)src2);
+    vec3 = (v8i16)__msa_vshf_b(mask1, (v16i8)src3, (v16i8)src2);
+    vec4 = (v8i16)__msa_vshf_b(mask0, (v16i8)src5, (v16i8)src4);
+    vec5 = (v8i16)__msa_vshf_b(mask1, (v16i8)src5, (v16i8)src4);
+    vec0 = (v8i16)__msa_hsub_u_h((v16u8)vec0, (v16u8)vec0);
+    vec1 = (v8i16)__msa_hsub_u_h((v16u8)vec1, (v16u8)vec1);
+    vec2 = (v8i16)__msa_hsub_u_h((v16u8)vec2, (v16u8)vec2);
+    vec3 = (v8i16)__msa_hsub_u_h((v16u8)vec3, (v16u8)vec3);
+    vec4 = (v8i16)__msa_hsub_u_h((v16u8)vec4, (v16u8)vec4);
+    vec5 = (v8i16)__msa_hsub_u_h((v16u8)vec5, (v16u8)vec5);
+    vec0 += vec2;
+    vec1 += vec3;
+    vec4 += vec2;
+    vec5 += vec3;
+    vec0 += vec4;
+    vec1 += vec5;
+    vec0 = __msa_add_a_h(zero, vec0);
+    vec1 = __msa_add_a_h(zero, vec1);
+    vec0 = __msa_maxi_s_h(vec0, 0);
+    vec1 = __msa_maxi_s_h(vec1, 0);
+    vec0 = __msa_min_s_h(max, vec0);
+    vec1 = __msa_min_s_h(max, vec1);
+    dst0 = (v16u8)__msa_pckev_b((v16i8)vec1, (v16i8)vec0);
+    ST_UB(dst0, dst_sobelx);
+    src_y0 += 16;
+    src_y1 += 16;
+    src_y2 += 16;
+    dst_sobelx += 16;
+  }
+}
+
+void SobelYRow_MSA(const uint8_t* src_y0,
+                   const uint8_t* src_y1,
+                   uint8_t* dst_sobely,
+                   int32_t width) {
+  int x;
+  v16u8 src0, src1, dst0;
+  v8i16 vec0, vec1, vec2, vec3, vec4, vec5, vec6;
+  v8i16 zero = {0};
+  v8i16 max = __msa_ldi_h(255);
+
+  for (x = 0; x < width; x += 16) {
+    src0 = (v16u8)__msa_ld_b((void*)src_y0, 0);
+    src1 = (v16u8)__msa_ld_b((void*)src_y1, 0);
+    vec0 = (v8i16)__msa_ilvr_b((v16i8)zero, (v16i8)src0);
+    vec1 = (v8i16)__msa_ilvl_b((v16i8)zero, (v16i8)src0);
+    vec2 = (v8i16)__msa_ilvr_b((v16i8)zero, (v16i8)src1);
+    vec3 = (v8i16)__msa_ilvl_b((v16i8)zero, (v16i8)src1);
+    vec0 -= vec2;
+    vec1 -= vec3;
+    vec6[0] = src_y0[16] - src_y1[16];
+    vec6[1] = src_y0[17] - src_y1[17];
+    vec2 = (v8i16)__msa_sldi_b((v16i8)vec1, (v16i8)vec0, 2);
+    vec3 = (v8i16)__msa_sldi_b((v16i8)vec6, (v16i8)vec1, 2);
+    vec4 = (v8i16)__msa_sldi_b((v16i8)vec1, (v16i8)vec0, 4);
+    vec5 = (v8i16)__msa_sldi_b((v16i8)vec6, (v16i8)vec1, 4);
+    vec0 += vec2;
+    vec1 += vec3;
+    vec4 += vec2;
+    vec5 += vec3;
+    vec0 += vec4;
+    vec1 += vec5;
+    vec0 = __msa_add_a_h(zero, vec0);
+    vec1 = __msa_add_a_h(zero, vec1);
+    vec0 = __msa_maxi_s_h(vec0, 0);
+    vec1 = __msa_maxi_s_h(vec1, 0);
+    vec0 = __msa_min_s_h(max, vec0);
+    vec1 = __msa_min_s_h(max, vec1);
+    dst0 = (v16u8)__msa_pckev_b((v16i8)vec1, (v16i8)vec0);
+    ST_UB(dst0, dst_sobely);
+    src_y0 += 16;
+    src_y1 += 16;
+    dst_sobely += 16;
+  }
+}
+
+void HalfFloatRow_MSA(const uint16_t* src,
+                      uint16_t* dst,
+                      float scale,
+                      int width) {
+  int i;
+  v8u16 src0, src1, src2, src3, dst0, dst1, dst2, dst3;
+  v4u32 vec0, vec1, vec2, vec3, vec4, vec5, vec6, vec7;
+  v4f32 fvec0, fvec1, fvec2, fvec3, fvec4, fvec5, fvec6, fvec7;
+  v4f32 mult_vec;
+  v8i16 zero = {0};
+  mult_vec[0] = 1.9259299444e-34f * scale;
+  mult_vec = (v4f32)__msa_splati_w((v4i32)mult_vec, 0);
+
+  for (i = 0; i < width; i += 32) {
+    src0 = (v8u16)__msa_ld_h((void*)src, 0);
+    src1 = (v8u16)__msa_ld_h((void*)src, 16);
+    src2 = (v8u16)__msa_ld_h((void*)src, 32);
+    src3 = (v8u16)__msa_ld_h((void*)src, 48);
+    vec0 = (v4u32)__msa_ilvr_h(zero, (v8i16)src0);
+    vec1 = (v4u32)__msa_ilvl_h(zero, (v8i16)src0);
+    vec2 = (v4u32)__msa_ilvr_h(zero, (v8i16)src1);
+    vec3 = (v4u32)__msa_ilvl_h(zero, (v8i16)src1);
+    vec4 = (v4u32)__msa_ilvr_h(zero, (v8i16)src2);
+    vec5 = (v4u32)__msa_ilvl_h(zero, (v8i16)src2);
+    vec6 = (v4u32)__msa_ilvr_h(zero, (v8i16)src3);
+    vec7 = (v4u32)__msa_ilvl_h(zero, (v8i16)src3);
+    fvec0 = __msa_ffint_u_w(vec0);
+    fvec1 = __msa_ffint_u_w(vec1);
+    fvec2 = __msa_ffint_u_w(vec2);
+    fvec3 = __msa_ffint_u_w(vec3);
+    fvec4 = __msa_ffint_u_w(vec4);
+    fvec5 = __msa_ffint_u_w(vec5);
+    fvec6 = __msa_ffint_u_w(vec6);
+    fvec7 = __msa_ffint_u_w(vec7);
+    fvec0 *= mult_vec;
+    fvec1 *= mult_vec;
+    fvec2 *= mult_vec;
+    fvec3 *= mult_vec;
+    fvec4 *= mult_vec;
+    fvec5 *= mult_vec;
+    fvec6 *= mult_vec;
+    fvec7 *= mult_vec;
+    vec0 = ((v4u32)fvec0) >> 13;
+    vec1 = ((v4u32)fvec1) >> 13;
+    vec2 = ((v4u32)fvec2) >> 13;
+    vec3 = ((v4u32)fvec3) >> 13;
+    vec4 = ((v4u32)fvec4) >> 13;
+    vec5 = ((v4u32)fvec5) >> 13;
+    vec6 = ((v4u32)fvec6) >> 13;
+    vec7 = ((v4u32)fvec7) >> 13;
+    dst0 = (v8u16)__msa_pckev_h((v8i16)vec1, (v8i16)vec0);
+    dst1 = (v8u16)__msa_pckev_h((v8i16)vec3, (v8i16)vec2);
+    dst2 = (v8u16)__msa_pckev_h((v8i16)vec5, (v8i16)vec4);
+    dst3 = (v8u16)__msa_pckev_h((v8i16)vec7, (v8i16)vec6);
+    ST_UH2(dst0, dst1, dst, 8);
+    ST_UH2(dst2, dst3, dst + 16, 8);
+    src += 32;
+    dst += 32;
+  }
+}
+
+#ifdef __cplusplus
+}  // extern "C"
+}  // namespace libyuv
+#endif
+
+#endif  // !defined(LIBYUV_DISABLE_MSA) && defined(__mips_msa)
diff --git a/3rdparty/libyuv/src/source/row_neon.cc b/3rdparty/libyuv/src/source/row_neon.cc
new file mode 100644
index 00000000..56a16cb3
--- /dev/null
+++ b/3rdparty/libyuv/src/source/row_neon.cc
@@ -0,0 +1,3746 @@
+/*
+ *  Copyright 2011 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include "libyuv/row.h"
+
+#ifdef __cplusplus
+namespace libyuv {
+extern "C" {
+#endif
+
+// This module is for GCC Neon
+#if !defined(LIBYUV_DISABLE_NEON) && defined(__ARM_NEON__) && \
+    !defined(__aarch64__)
+
+// d8-d15, r4-r11,r14(lr) need to be preserved if used. r13(sp),r15(pc) are
+// reserved.
+
+// q0: Y uint16x8_t
+// d2: U uint8x8_t
+// d3: V uint8x8_t
+
+// Read 8 Y, 4 U and 4 V from 422
+#define READYUV422                               \
+  "vld1.8     {d0}, [%[src_y]]!              \n" \
+  "vld1.32    {d2[0]}, [%[src_u]]!           \n" \
+  "vld1.32    {d2[1]}, [%[src_v]]!           \n" \
+  "vmov.u8    d1, d0                         \n" \
+  "vmovl.u8   q1, d2                         \n" \
+  "vzip.u8    d0, d1                         \n" \
+  "vsli.u16   q1, q1, #8                     \n"
+
+// Read 8 Y, 8 U and 8 V from 444
+#define READYUV444                               \
+  "vld1.8     {d0}, [%[src_y]]!              \n" \
+  "vld1.8     {d2}, [%[src_u]]!              \n" \
+  "vmovl.u8   q0, d0                         \n" \
+  "vld1.8     {d3}, [%[src_v]]!              \n" \
+  "vsli.u16   q0, q0, #8                     \n"
+
+// Read 8 Y, and set 4 U and 4 V to 128
+#define READYUV400                               \
+  "vld1.8     {d0}, [%[src_y]]!              \n" \
+  "vmov.u8    q1, #128                       \n" \
+  "vmovl.u8   q0, d0                         \n" \
+  "vsli.u16   q0, q0, #8                     \n"
+
+// Read 8 Y and 4 UV from NV12
+#define READNV12                                                              \
+  "vld1.8     {d0}, [%[src_y]]!              \n"                              \
+  "vld1.8     {d2}, [%[src_uv]]!             \n"                              \
+  "vmov.u8    d1, d0                         \n"                              \
+  "vmov.u8    d3, d2                         \n"                              \
+  "vzip.u8    d0, d1                         \n"                              \
+  "vsli.u16   d2, d2, #8                     \n" /* Duplicate low byte (U) */ \
+  "vsri.u16   d3, d3, #8                     \n" /* Duplicate high byte (V) */
+
+// Read 8 Y and 4 VU from NV21
+#define READNV21                                                               \
+  "vld1.8     {d0}, [%[src_y]]!              \n"                               \
+  "vld1.8     {d2}, [%[src_vu]]!             \n"                               \
+  "vmov.u8    d1, d0                         \n"                               \
+  "vmov.u8    d3, d2                         \n"                               \
+  "vzip.u8    d0, d1                         \n"                               \
+  "vsri.u16   d2, d2, #8                     \n" /* Duplicate high byte (U) */ \
+  "vsli.u16   d3, d3, #8                     \n" /* Duplicate low byte (V) */
+
+// Read 8 YUY2
+#define READYUY2                                 \
+  "vld2.8     {d0, d2}, [%[src_yuy2]]!       \n" \
+  "vmovl.u8   q0, d0                         \n" \
+  "vmov.u8    d3, d2                         \n" \
+  "vsli.u16   q0, q0, #8                     \n" \
+  "vsli.u16   d2, d2, #8                     \n" \
+  "vsri.u16   d3, d3, #8                     \n"
+
+// Read 8 UYVY
+#define READUYVY                                 \
+  "vld2.8     {d2, d3}, [%[src_uyvy]]!       \n" \
+  "vmovl.u8   q0, d3                         \n" \
+  "vmov.u8    d3, d2                         \n" \
+  "vsli.u16   q0, q0, #8                     \n" \
+  "vsli.u16   d2, d2, #8                     \n" \
+  "vsri.u16   d3, d3, #8                     \n"
+
+#define YUVTORGB_SETUP                                        \
+  "vld4.8     {d26[], d27[], d28[], d29[]}, [%[kUVCoeff]] \n" \
+  "vld1.16    {d31[]}, [%[kRGBCoeffBias]]!   \n"              \
+  "vld1.16    {d20[], d21[]}, [%[kRGBCoeffBias]]! \n"         \
+  "vld1.16    {d22[], d23[]}, [%[kRGBCoeffBias]]! \n"         \
+  "vld1.16    {d24[], d25[]}, [%[kRGBCoeffBias]] \n"
+
+// q0: B uint16x8_t
+// q1: G uint16x8_t
+// q2: R uint16x8_t
+
+// Convert from YUV to 2.14 fixed point RGB
+#define YUVTORGB                                           \
+  "vmull.u16  q2, d1, d31                    \n"           \
+  "vmull.u8   q8, d3, d29                    \n" /* DGV */ \
+  "vmull.u16  q0, d0, d31                    \n"           \
+  "vmlal.u8   q8, d2, d28                    \n" /* DG */  \
+  "vqshrn.u32 d0, q0, #16                    \n"           \
+  "vqshrn.u32 d1, q2, #16                    \n" /* Y */   \
+  "vmull.u8   q9, d2, d26                    \n" /* DB */  \
+  "vmull.u8   q2, d3, d27                    \n" /* DR */  \
+  "vadd.u16   q4, q0, q11                    \n" /* G */   \
+  "vadd.u16   q2, q0, q2                     \n" /* R */   \
+  "vadd.u16   q0, q0, q9                     \n" /* B */   \
+  "vqsub.u16  q1, q4, q8                     \n" /* G */   \
+  "vqsub.u16  q0, q0, q10                    \n" /* B */   \
+  "vqsub.u16  q2, q2, q12                    \n" /* R */
+
+// Convert from 2.14 fixed point RGB To 8 bit RGB
+#define RGBTORGB8                                        \
+  "vqshrn.u16 d4, q2, #6                     \n" /* R */ \
+  "vqshrn.u16 d2, q1, #6                     \n" /* G */ \
+  "vqshrn.u16 d0, q0, #6                     \n" /* B */
+
+#define YUVTORGB_REGS \
+  "q0", "q1", "q2", "q4", "q8", "q9", "q10", "q11", "q12", "q13", "q14", "d31"
+
+#define STORERGBA                                \
+  "vmov.u8    d1, d0                         \n" \
+  "vmov.u8    d3, d4                         \n" \
+  "vmov.u8    d0, d6                         \n" \
+  "vst4.8     {d0, d1, d2, d3}, [%[dst_rgba]]! \n"
+
+void I444ToARGBRow_NEON(const uint8_t* src_y,
+                        const uint8_t* src_u,
+                        const uint8_t* src_v,
+                        uint8_t* dst_argb,
+                        const struct YuvConstants* yuvconstants,
+                        int width) {
+  asm volatile(
+      YUVTORGB_SETUP
+      "vmov.u8     d6, #255                      \n"
+      "1:                                        \n" READYUV444 YUVTORGB
+          RGBTORGB8
+      "subs        %[width], %[width], #8        \n"
+      "vst4.8      {d0, d2, d4, d6}, [%[dst_argb]]! \n"
+      "bgt         1b                            \n"
+      : [src_y] "+r"(src_y),                               // %[src_y]
+        [src_u] "+r"(src_u),                               // %[src_u]
+        [src_v] "+r"(src_v),                               // %[src_v]
+        [dst_argb] "+r"(dst_argb),                         // %[dst_argb]
+        [width] "+r"(width)                                // %[width]
+      : [kUVCoeff] "r"(&yuvconstants->kUVCoeff),           // %[kUVCoeff]
+        [kRGBCoeffBias] "r"(&yuvconstants->kRGBCoeffBias)  // %[kRGBCoeffBias]
+      : "cc", "memory", YUVTORGB_REGS, "d6");
+}
+
+void I422ToARGBRow_NEON(const uint8_t* src_y,
+                        const uint8_t* src_u,
+                        const uint8_t* src_v,
+                        uint8_t* dst_argb,
+                        const struct YuvConstants* yuvconstants,
+                        int width) {
+  asm volatile(
+      YUVTORGB_SETUP
+      "vmov.u8     d6, #255                      \n"
+      "1:                                        \n" READYUV422 YUVTORGB
+          RGBTORGB8
+      "subs        %[width], %[width], #8        \n"
+      "vst4.8      {d0, d2, d4, d6}, [%[dst_argb]]! \n"
+      "bgt         1b                            \n"
+      : [src_y] "+r"(src_y),                               // %[src_y]
+        [src_u] "+r"(src_u),                               // %[src_u]
+        [src_v] "+r"(src_v),                               // %[src_v]
+        [dst_argb] "+r"(dst_argb),                         // %[dst_argb]
+        [width] "+r"(width)                                // %[width]
+      : [kUVCoeff] "r"(&yuvconstants->kUVCoeff),           // %[kUVCoeff]
+        [kRGBCoeffBias] "r"(&yuvconstants->kRGBCoeffBias)  // %[kRGBCoeffBias]
+      : "cc", "memory", YUVTORGB_REGS, "d6");
+}
+
+void I444AlphaToARGBRow_NEON(const uint8_t* src_y,
+                             const uint8_t* src_u,
+                             const uint8_t* src_v,
+                             const uint8_t* src_a,
+                             uint8_t* dst_argb,
+                             const struct YuvConstants* yuvconstants,
+                             int width) {
+  asm volatile(
+      YUVTORGB_SETUP
+      "1:                                        \n" READYUV444 YUVTORGB
+          RGBTORGB8
+      "vld1.8      {d6}, [%[src_a]]!             \n"
+      "subs        %[width], %[width], #8        \n"
+      "vst4.8      {d0, d2, d4, d6}, [%[dst_argb]]! \n"
+      "bgt         1b                            \n"
+      : [src_y] "+r"(src_y),                               // %[src_y]
+        [src_u] "+r"(src_u),                               // %[src_u]
+        [src_v] "+r"(src_v),                               // %[src_v]
+        [src_a] "+r"(src_a),                               // %[src_a]
+        [dst_argb] "+r"(dst_argb),                         // %[dst_argb]
+        [width] "+r"(width)                                // %[width]
+      : [kUVCoeff] "r"(&yuvconstants->kUVCoeff),           // %[kUVCoeff]
+        [kRGBCoeffBias] "r"(&yuvconstants->kRGBCoeffBias)  // %[kRGBCoeffBias]
+      : "cc", "memory", YUVTORGB_REGS, "d6");
+}
+
+void I422AlphaToARGBRow_NEON(const uint8_t* src_y,
+                             const uint8_t* src_u,
+                             const uint8_t* src_v,
+                             const uint8_t* src_a,
+                             uint8_t* dst_argb,
+                             const struct YuvConstants* yuvconstants,
+                             int width) {
+  asm volatile(
+      YUVTORGB_SETUP
+      "1:                                        \n" READYUV422 YUVTORGB
+          RGBTORGB8
+      "vld1.8      {d6}, [%[src_a]]!             \n"
+      "subs        %[width], %[width], #8        \n"
+      "vst4.8      {d0, d2, d4, d6}, [%[dst_argb]]! \n"
+      "bgt         1b                            \n"
+      : [src_y] "+r"(src_y),                               // %[src_y]
+        [src_u] "+r"(src_u),                               // %[src_u]
+        [src_v] "+r"(src_v),                               // %[src_v]
+        [src_a] "+r"(src_a),                               // %[src_a]
+        [dst_argb] "+r"(dst_argb),                         // %[dst_argb]
+        [width] "+r"(width)                                // %[width]
+      : [kUVCoeff] "r"(&yuvconstants->kUVCoeff),           // %[kUVCoeff]
+        [kRGBCoeffBias] "r"(&yuvconstants->kRGBCoeffBias)  // %[kRGBCoeffBias]
+      : "cc", "memory", YUVTORGB_REGS, "d6");
+}
+
+void I422ToRGBARow_NEON(const uint8_t* src_y,
+                        const uint8_t* src_u,
+                        const uint8_t* src_v,
+                        uint8_t* dst_rgba,
+                        const struct YuvConstants* yuvconstants,
+                        int width) {
+  asm volatile(
+      YUVTORGB_SETUP
+      "vmov.u8     d6, #255                      \n"
+      "1:                                        \n" READYUV422 YUVTORGB
+          RGBTORGB8 "subs        %[width], %[width], #8        \n" STORERGBA
+      "bgt         1b                            \n"
+      : [src_y] "+r"(src_y),                               // %[src_y]
+        [src_u] "+r"(src_u),                               // %[src_u]
+        [src_v] "+r"(src_v),                               // %[src_v]
+        [dst_rgba] "+r"(dst_rgba),                         // %[dst_rgba]
+        [width] "+r"(width)                                // %[width]
+      : [kUVCoeff] "r"(&yuvconstants->kUVCoeff),           // %[kUVCoeff]
+        [kRGBCoeffBias] "r"(&yuvconstants->kRGBCoeffBias)  // %[kRGBCoeffBias]
+      : "cc", "memory", YUVTORGB_REGS, "d6");
+}
+
+void I422ToRGB24Row_NEON(const uint8_t* src_y,
+                         const uint8_t* src_u,
+                         const uint8_t* src_v,
+                         uint8_t* dst_rgb24,
+                         const struct YuvConstants* yuvconstants,
+                         int width) {
+  asm volatile(
+      YUVTORGB_SETUP
+      "vmov.u8     d6, #255                      \n"
+      "1:                                        \n" READYUV422 YUVTORGB
+          RGBTORGB8
+      "subs        %[width], %[width], #8        \n"
+      "vst3.8      {d0, d2, d4}, [%[dst_rgb24]]! \n"
+      "bgt         1b                            \n"
+      : [src_y] "+r"(src_y),                               // %[src_y]
+        [src_u] "+r"(src_u),                               // %[src_u]
+        [src_v] "+r"(src_v),                               // %[src_v]
+        [dst_rgb24] "+r"(dst_rgb24),                       // %[dst_rgb24]
+        [width] "+r"(width)                                // %[width]
+      : [kUVCoeff] "r"(&yuvconstants->kUVCoeff),           // %[kUVCoeff]
+        [kRGBCoeffBias] "r"(&yuvconstants->kRGBCoeffBias)  // %[kRGBCoeffBias]
+      : "cc", "memory", YUVTORGB_REGS);
+}
+
+#define ARGBTORGB565                                                        \
+  "vshll.u8    q2, d4, #8                    \n" /* R                    */ \
+  "vshll.u8    q1, d2, #8                    \n" /* G                    */ \
+  "vshll.u8    q0, d0, #8                    \n" /* B                    */ \
+  "vsri.16     q2, q1, #5                    \n" /* RG                   */ \
+  "vsri.16     q2, q0, #11                   \n" /* RGB                  */
+
+void I422ToRGB565Row_NEON(const uint8_t* src_y,
+                          const uint8_t* src_u,
+                          const uint8_t* src_v,
+                          uint8_t* dst_rgb565,
+                          const struct YuvConstants* yuvconstants,
+                          int width) {
+  asm volatile(
+      YUVTORGB_SETUP
+      "vmov.u8     d6, #255                      \n"
+      "1:                                        \n" READYUV422 YUVTORGB
+          RGBTORGB8 "subs        %[width], %[width], #8        \n" ARGBTORGB565
+      "vst1.8      {q2}, [%[dst_rgb565]]!        \n"  // store 8 pixels RGB565.
+      "bgt         1b                            \n"
+      : [src_y] "+r"(src_y),                               // %[src_y]
+        [src_u] "+r"(src_u),                               // %[src_u]
+        [src_v] "+r"(src_v),                               // %[src_v]
+        [dst_rgb565] "+r"(dst_rgb565),                     // %[dst_rgb565]
+        [width] "+r"(width)                                // %[width]
+      : [kUVCoeff] "r"(&yuvconstants->kUVCoeff),           // %[kUVCoeff]
+        [kRGBCoeffBias] "r"(&yuvconstants->kRGBCoeffBias)  // %[kRGBCoeffBias]
+      : "cc", "memory", YUVTORGB_REGS);
+}
+
+#define ARGBTOARGB1555                                                      \
+  "vshll.u8    q3, d6, #8                    \n" /* A                    */ \
+  "vshll.u8    q2, d4, #8                    \n" /* R                    */ \
+  "vshll.u8    q1, d2, #8                    \n" /* G                    */ \
+  "vshll.u8    q0, d0, #8                    \n" /* B                    */ \
+  "vsri.16     q3, q2, #1                    \n" /* AR                   */ \
+  "vsri.16     q3, q1, #6                    \n" /* ARG                  */ \
+  "vsri.16     q3, q0, #11                   \n" /* ARGB                 */
+
+void I422ToARGB1555Row_NEON(const uint8_t* src_y,
+                            const uint8_t* src_u,
+                            const uint8_t* src_v,
+                            uint8_t* dst_argb1555,
+                            const struct YuvConstants* yuvconstants,
+                            int width) {
+  asm volatile(
+      YUVTORGB_SETUP
+      "1:                                        \n" READYUV422 YUVTORGB
+          RGBTORGB8
+      "subs        %[width], %[width], #8        \n"
+      "vmov.u8     d6, #0xff                     \n" ARGBTOARGB1555
+      "vst1.8      {q3}, [%[dst_argb1555]]!      \n"  // store 8 pixels RGB1555.
+      "bgt         1b                            \n"
+      : [src_y] "+r"(src_y),                               // %[src_y]
+        [src_u] "+r"(src_u),                               // %[src_u]
+        [src_v] "+r"(src_v),                               // %[src_v]
+        [dst_argb1555] "+r"(dst_argb1555),                 // %[dst_argb1555]
+        [width] "+r"(width)                                // %[width]
+      : [kUVCoeff] "r"(&yuvconstants->kUVCoeff),           // %[kUVCoeff]
+        [kRGBCoeffBias] "r"(&yuvconstants->kRGBCoeffBias)  // %[kRGBCoeffBias]
+      : "cc", "memory", YUVTORGB_REGS, "q3");
+}
+
+#define ARGBTOARGB4444                                                      \
+  "vshr.u8    d0, d0, #4                     \n" /* B                    */ \
+  "vbic.32    d2, d2, d7                     \n" /* G                    */ \
+  "vshr.u8    d4, d4, #4                     \n" /* R                    */ \
+  "vbic.32    d6, d6, d7                     \n" /* A                    */ \
+  "vorr       d0, d0, d2                     \n" /* BG                   */ \
+  "vorr       d1, d4, d6                     \n" /* RA                   */ \
+  "vzip.u8    d0, d1                         \n" /* BGRA                 */
+
+void I422ToARGB4444Row_NEON(const uint8_t* src_y,
+                            const uint8_t* src_u,
+                            const uint8_t* src_v,
+                            uint8_t* dst_argb4444,
+                            const struct YuvConstants* yuvconstants,
+                            int width) {
+  asm volatile(
+      YUVTORGB_SETUP
+      "vmov.u8     d6, #255                      \n"
+      "vmov.u8     d7, #0x0f                     \n"  // vbic bits to clear
+      "1:                                        \n" READYUV422 YUVTORGB
+          RGBTORGB8
+      "subs        %[width], %[width], #8        \n" ARGBTOARGB4444
+      "vst1.8      {q0}, [%[dst_argb4444]]!      \n"  // store 8 pixels
+      "bgt         1b                            \n"
+      : [src_y] "+r"(src_y),                               // %[src_y]
+        [src_u] "+r"(src_u),                               // %[src_u]
+        [src_v] "+r"(src_v),                               // %[src_v]
+        [dst_argb4444] "+r"(dst_argb4444),                 // %[dst_argb4444]
+        [width] "+r"(width)                                // %[width]
+      : [kUVCoeff] "r"(&yuvconstants->kUVCoeff),           // %[kUVCoeff]
+        [kRGBCoeffBias] "r"(&yuvconstants->kRGBCoeffBias)  // %[kRGBCoeffBias]
+      : "cc", "memory", YUVTORGB_REGS, "q3");
+}
+
+void I400ToARGBRow_NEON(const uint8_t* src_y,
+                        uint8_t* dst_argb,
+                        const struct YuvConstants* yuvconstants,
+                        int width) {
+  asm volatile(
+      YUVTORGB_SETUP
+      "vmov.u8     d6, #255                      \n"
+      "1:                                        \n" READYUV400 YUVTORGB
+          RGBTORGB8
+      "subs        %[width], %[width], #8        \n"
+      "vst4.8      {d0, d2, d4, d6}, [%[dst_argb]]! \n"
+      "bgt         1b                            \n"
+      : [src_y] "+r"(src_y),                               // %[src_y]
+        [dst_argb] "+r"(dst_argb),                         // %[dst_argb]
+        [width] "+r"(width)                                // %[width]
+      : [kUVCoeff] "r"(&yuvconstants->kUVCoeff),           // %[kUVCoeff]
+        [kRGBCoeffBias] "r"(&yuvconstants->kRGBCoeffBias)  // %[kRGBCoeffBias]
+      : "cc", "memory", YUVTORGB_REGS, "d6");
+}
+
+void J400ToARGBRow_NEON(const uint8_t* src_y, uint8_t* dst_argb, int width) {
+  asm volatile(
+      "vmov.u8     d23, #255                     \n"
+      "1:                                        \n"
+      "vld1.8      {d20}, [%0]!                  \n"
+      "vmov        d21, d20                      \n"
+      "vmov        d22, d20                      \n"
+      "subs        %2, %2, #8                    \n"
+      "vst4.8      {d20, d21, d22, d23}, [%1]!   \n"
+      "bgt         1b                            \n"
+      : "+r"(src_y),     // %0
+        "+r"(dst_argb),  // %1
+        "+r"(width)      // %2
+      :
+      : "cc", "memory", "d20", "d21", "d22", "d23");
+}
+
+void NV12ToARGBRow_NEON(const uint8_t* src_y,
+                        const uint8_t* src_uv,
+                        uint8_t* dst_argb,
+                        const struct YuvConstants* yuvconstants,
+                        int width) {
+  asm volatile(
+      YUVTORGB_SETUP
+      "vmov.u8     d6, #255                      \n"
+      "1:                                        \n" READNV12 YUVTORGB RGBTORGB8
+      "subs        %[width], %[width], #8        \n"
+      "vst4.8      {d0, d2, d4, d6}, [%[dst_argb]]! \n"
+      "bgt         1b                            \n"
+      : [src_y] "+r"(src_y),                               // %[src_y]
+        [src_uv] "+r"(src_uv),                             // %[src_uv]
+        [dst_argb] "+r"(dst_argb),                         // %[dst_argb]
+        [width] "+r"(width)                                // %[width]
+      : [kUVCoeff] "r"(&yuvconstants->kUVCoeff),           // %[kUVCoeff]
+        [kRGBCoeffBias] "r"(&yuvconstants->kRGBCoeffBias)  // %[kRGBCoeffBias]
+      : "cc", "memory", YUVTORGB_REGS, "d6");
+}
+
+void NV21ToARGBRow_NEON(const uint8_t* src_y,
+                        const uint8_t* src_vu,
+                        uint8_t* dst_argb,
+                        const struct YuvConstants* yuvconstants,
+                        int width) {
+  asm volatile(
+      YUVTORGB_SETUP
+      "vmov.u8     d6, #255                      \n"
+      "1:                                        \n" READNV21 YUVTORGB RGBTORGB8
+      "subs        %[width], %[width], #8        \n"
+      "vst4.8      {d0, d2, d4, d6}, [%[dst_argb]]! \n"
+      "bgt         1b                            \n"
+      : [src_y] "+r"(src_y),                               // %[src_y]
+        [src_vu] "+r"(src_vu),                             // %[src_vu]
+        [dst_argb] "+r"(dst_argb),                         // %[dst_argb]
+        [width] "+r"(width)                                // %[width]
+      : [kUVCoeff] "r"(&yuvconstants->kUVCoeff),           // %[kUVCoeff]
+        [kRGBCoeffBias] "r"(&yuvconstants->kRGBCoeffBias)  // %[kRGBCoeffBias]
+      : "cc", "memory", YUVTORGB_REGS, "d6");
+}
+
+void NV12ToRGB24Row_NEON(const uint8_t* src_y,
+                         const uint8_t* src_uv,
+                         uint8_t* dst_rgb24,
+                         const struct YuvConstants* yuvconstants,
+                         int width) {
+  asm volatile(
+      YUVTORGB_SETUP
+      "vmov.u8     d6, #255                      \n"
+      "1:                                        \n" READNV12 YUVTORGB RGBTORGB8
+      "subs        %[width], %[width], #8        \n"
+      "vst3.8      {d0, d2, d4}, [%[dst_rgb24]]! \n"
+      "bgt         1b                            \n"
+      : [src_y] "+r"(src_y),                               // %[src_y]
+        [src_uv] "+r"(src_uv),                             // %[src_uv]
+        [dst_rgb24] "+r"(dst_rgb24),                       // %[dst_rgb24]
+        [width] "+r"(width)                                // %[width]
+      : [kUVCoeff] "r"(&yuvconstants->kUVCoeff),           // %[kUVCoeff]
+        [kRGBCoeffBias] "r"(&yuvconstants->kRGBCoeffBias)  // %[kRGBCoeffBias]
+      : "cc", "memory", YUVTORGB_REGS);
+}
+
+void NV21ToRGB24Row_NEON(const uint8_t* src_y,
+                         const uint8_t* src_vu,
+                         uint8_t* dst_rgb24,
+                         const struct YuvConstants* yuvconstants,
+                         int width) {
+  asm volatile(
+      YUVTORGB_SETUP
+      "vmov.u8     d6, #255                      \n"
+      "1:                                        \n" READNV21 YUVTORGB RGBTORGB8
+      "subs        %[width], %[width], #8        \n"
+      "vst3.8      {d0, d2, d4}, [%[dst_rgb24]]! \n"
+      "bgt         1b                            \n"
+      : [src_y] "+r"(src_y),                               // %[src_y]
+        [src_vu] "+r"(src_vu),                             // %[src_vu]
+        [dst_rgb24] "+r"(dst_rgb24),                       // %[dst_rgb24]
+        [width] "+r"(width)                                // %[width]
+      : [kUVCoeff] "r"(&yuvconstants->kUVCoeff),           // %[kUVCoeff]
+        [kRGBCoeffBias] "r"(&yuvconstants->kRGBCoeffBias)  // %[kRGBCoeffBias]
+      : "cc", "memory", YUVTORGB_REGS);
+}
+
+void NV12ToRGB565Row_NEON(const uint8_t* src_y,
+                          const uint8_t* src_uv,
+                          uint8_t* dst_rgb565,
+                          const struct YuvConstants* yuvconstants,
+                          int width) {
+  asm volatile(
+      YUVTORGB_SETUP
+      "vmov.u8     d6, #255                      \n"
+      "1:                                        \n" READNV12 YUVTORGB RGBTORGB8
+      "subs        %[width], %[width], #8        \n" ARGBTORGB565
+      "vst1.8      {q2}, [%[dst_rgb565]]!        \n"  // store 8 pixels RGB565.
+      "bgt         1b                            \n"
+      : [src_y] "+r"(src_y),                               // %[src_y]
+        [src_uv] "+r"(src_uv),                             // %[src_uv]
+        [dst_rgb565] "+r"(dst_rgb565),                     // %[dst_rgb565]
+        [width] "+r"(width)                                // %[width]
+      : [kUVCoeff] "r"(&yuvconstants->kUVCoeff),           // %[kUVCoeff]
+        [kRGBCoeffBias] "r"(&yuvconstants->kRGBCoeffBias)  // %[kRGBCoeffBias]
+      : "cc", "memory", YUVTORGB_REGS);
+}
+
+void YUY2ToARGBRow_NEON(const uint8_t* src_yuy2,
+                        uint8_t* dst_argb,
+                        const struct YuvConstants* yuvconstants,
+                        int width) {
+  asm volatile(
+      YUVTORGB_SETUP
+      "vmov.u8     d6, #255                      \n"
+      "1:                                        \n" READYUY2 YUVTORGB RGBTORGB8
+      "subs        %[width], %[width], #8        \n"
+      "vst4.8      {d0, d2, d4, d6}, [%[dst_argb]]! \n"
+      "bgt         1b                            \n"
+      : [src_yuy2] "+r"(src_yuy2),                         // %[src_yuy2]
+        [dst_argb] "+r"(dst_argb),                         // %[dst_argb]
+        [width] "+r"(width)                                // %[width]
+      : [kUVCoeff] "r"(&yuvconstants->kUVCoeff),           // %[kUVCoeff]
+        [kRGBCoeffBias] "r"(&yuvconstants->kRGBCoeffBias)  // %[kRGBCoeffBias]
+      : "cc", "memory", YUVTORGB_REGS, "d6");
+}
+
+void UYVYToARGBRow_NEON(const uint8_t* src_uyvy,
+                        uint8_t* dst_argb,
+                        const struct YuvConstants* yuvconstants,
+                        int width) {
+  asm volatile(
+      YUVTORGB_SETUP
+      "vmov.u8     d6, #255                      \n"
+      "1:                                        \n" READUYVY YUVTORGB RGBTORGB8
+      "subs        %[width], %[width], #8        \n"
+      "vst4.8      {d0, d2, d4, d6}, [%[dst_argb]]! \n"
+      "bgt         1b                            \n"
+      : [src_uyvy] "+r"(src_uyvy),                         // %[src_uyvy]
+        [dst_argb] "+r"(dst_argb),                         // %[dst_argb]
+        [width] "+r"(width)                                // %[width]
+      : [kUVCoeff] "r"(&yuvconstants->kUVCoeff),           // %[kUVCoeff]
+        [kRGBCoeffBias] "r"(&yuvconstants->kRGBCoeffBias)  // %[kRGBCoeffBias]
+      : "cc", "memory", YUVTORGB_REGS, "d6");
+}
+
+// Reads 16 pairs of UV and write even values to dst_u and odd to dst_v.
+void SplitUVRow_NEON(const uint8_t* src_uv,
+                     uint8_t* dst_u,
+                     uint8_t* dst_v,
+                     int width) {
+  asm volatile(
+      "1:                                        \n"
+      "vld2.8      {q0, q1}, [%0]!               \n"  // load 16 pairs of UV
+      "subs        %3, %3, #16                   \n"  // 16 processed per loop
+      "vst1.8      {q0}, [%1]!                   \n"  // store U
+      "vst1.8      {q1}, [%2]!                   \n"  // store V
+      "bgt         1b                            \n"
+      : "+r"(src_uv),               // %0
+        "+r"(dst_u),                // %1
+        "+r"(dst_v),                // %2
+        "+r"(width)                 // %3  // Output registers
+      :                             // Input registers
+      : "cc", "memory", "q0", "q1"  // Clobber List
+  );
+}
+
+// Reads 16 byte Y's from tile and writes out 16 Y's.
+// MM21 Y tiles are 16x32 so src_tile_stride = 512 bytes
+// MM21 UV tiles are 8x16 so src_tile_stride = 256 bytes
+// width measured in bytes so 8 UV = 16.
+void DetileRow_NEON(const uint8_t* src,
+                    ptrdiff_t src_tile_stride,
+                    uint8_t* dst,
+                    int width) {
+  asm volatile(
+      "1:                                        \n"
+      "vld1.16     {q0}, [%0], %3                \n"  // load 16 bytes
+      "subs        %2, %2, #16                   \n"  // 16 processed per loop
+      "pld         [%0, #1792]                    \n"
+      "vst1.16     {q0}, [%1]!                   \n"  // store 16 bytes
+      "bgt         1b                            \n"
+      : "+r"(src),            // %0
+        "+r"(dst),            // %1
+        "+r"(width)           // %2
+      : "r"(src_tile_stride)  // %3
+      : "cc", "memory", "q0"  // Clobber List
+  );
+}
+
+// Read 16 bytes of UV, detile, and write 8 bytes of U and 8 bytes of V.
+void DetileSplitUVRow_NEON(const uint8_t* src_uv,
+                           ptrdiff_t src_tile_stride,
+                           uint8_t* dst_u,
+                           uint8_t* dst_v,
+                           int width) {
+  asm volatile(
+      "1:                                        \n"
+      "vld2.8      {d0, d1}, [%0], %4            \n"
+      "subs        %3, %3, #16                   \n"
+      "pld         [%0, #1792]                    \n"
+      "vst1.8      {d0}, [%1]!                   \n"
+      "vst1.8      {d1}, [%2]!                   \n"
+      "bgt         1b                            \n"
+      : "+r"(src_uv),               // %0
+        "+r"(dst_u),                // %1
+        "+r"(dst_v),                // %2
+        "+r"(width)                 // %3
+      : "r"(src_tile_stride)        // %4
+      : "cc", "memory", "d0", "d1"  // Clobber List
+  );
+}
+
+// Reads 16 U's and V's and writes out 16 pairs of UV.
+void MergeUVRow_NEON(const uint8_t* src_u,
+                     const uint8_t* src_v,
+                     uint8_t* dst_uv,
+                     int width) {
+  asm volatile(
+      "1:                                        \n"
+      "vld1.8      {q0}, [%0]!                   \n"  // load U
+      "vld1.8      {q1}, [%1]!                   \n"  // load V
+      "subs        %3, %3, #16                   \n"  // 16 processed per loop
+      "vst2.8      {q0, q1}, [%2]!               \n"  // store 16 pairs of UV
+      "bgt         1b                            \n"
+      : "+r"(src_u),                // %0
+        "+r"(src_v),                // %1
+        "+r"(dst_uv),               // %2
+        "+r"(width)                 // %3  // Output registers
+      :                             // Input registers
+      : "cc", "memory", "q0", "q1"  // Clobber List
+  );
+}
+
+// Reads 16 packed RGB and write to planar dst_r, dst_g, dst_b.
+void SplitRGBRow_NEON(const uint8_t* src_rgb,
+                      uint8_t* dst_r,
+                      uint8_t* dst_g,
+                      uint8_t* dst_b,
+                      int width) {
+  asm volatile(
+      "1:                                        \n"
+      "vld3.8      {d0, d2, d4}, [%0]!           \n"  // load 8 RGB
+      "vld3.8      {d1, d3, d5}, [%0]!           \n"  // next 8 RGB
+      "subs        %4, %4, #16                   \n"  // 16 processed per loop
+      "vst1.8      {q0}, [%1]!                   \n"  // store R
+      "vst1.8      {q1}, [%2]!                   \n"  // store G
+      "vst1.8      {q2}, [%3]!                   \n"  // store B
+      "bgt         1b                            \n"
+      : "+r"(src_rgb),                    // %0
+        "+r"(dst_r),                      // %1
+        "+r"(dst_g),                      // %2
+        "+r"(dst_b),                      // %3
+        "+r"(width)                       // %4
+      :                                   // Input registers
+      : "cc", "memory", "d0", "d1", "d2"  // Clobber List
+  );
+}
+
+// Reads 16 planar R's, G's and B's and writes out 16 packed RGB at a time
+void MergeRGBRow_NEON(const uint8_t* src_r,
+                      const uint8_t* src_g,
+                      const uint8_t* src_b,
+                      uint8_t* dst_rgb,
+                      int width) {
+  asm volatile(
+      "1:                                        \n"
+      "vld1.8      {q0}, [%0]!                   \n"  // load R
+      "vld1.8      {q1}, [%1]!                   \n"  // load G
+      "vld1.8      {q2}, [%2]!                   \n"  // load B
+      "subs        %4, %4, #16                   \n"  // 16 processed per loop
+      "vst3.8      {d0, d2, d4}, [%3]!           \n"  // store 8 RGB
+      "vst3.8      {d1, d3, d5}, [%3]!           \n"  // next 8 RGB
+      "bgt         1b                            \n"
+      : "+r"(src_r),                      // %0
+        "+r"(src_g),                      // %1
+        "+r"(src_b),                      // %2
+        "+r"(dst_rgb),                    // %3
+        "+r"(width)                       // %4
+      :                                   // Input registers
+      : "cc", "memory", "q0", "q1", "q2"  // Clobber List
+  );
+}
+
+// Reads 16 packed ARGB and write to planar dst_r, dst_g, dst_b, dst_a.
+void SplitARGBRow_NEON(const uint8_t* src_argb,
+                       uint8_t* dst_r,
+                       uint8_t* dst_g,
+                       uint8_t* dst_b,
+                       uint8_t* dst_a,
+                       int width) {
+  asm volatile(
+      "1:                                        \n"
+      "vld4.8      {d0, d2, d4, d6}, [%0]!       \n"  // load 8 ARGB
+      "vld4.8      {d1, d3, d5, d7}, [%0]!       \n"  // next 8 ARGB
+      "subs        %5, %5, #16                   \n"  // 16 processed per loop
+      "vst1.8      {q0}, [%3]!                   \n"  // store B
+      "vst1.8      {q1}, [%2]!                   \n"  // store G
+      "vst1.8      {q2}, [%1]!                   \n"  // store R
+      "vst1.8      {q3}, [%4]!                   \n"  // store A
+      "bgt         1b                            \n"
+      : "+r"(src_argb),                         // %0
+        "+r"(dst_r),                            // %1
+        "+r"(dst_g),                            // %2
+        "+r"(dst_b),                            // %3
+        "+r"(dst_a),                            // %4
+        "+r"(width)                             // %5
+      :                                         // Input registers
+      : "cc", "memory", "q0", "q1", "q2", "q3"  // Clobber List
+  );
+}
+
+// Reads 16 planar R's, G's and B's and writes out 16 packed ARGB at a time
+void MergeARGBRow_NEON(const uint8_t* src_r,
+                       const uint8_t* src_g,
+                       const uint8_t* src_b,
+                       const uint8_t* src_a,
+                       uint8_t* dst_argb,
+                       int width) {
+  asm volatile(
+      "1:                                        \n"
+      "vld1.8      {q2}, [%0]!                   \n"  // load R
+      "vld1.8      {q1}, [%1]!                   \n"  // load G
+      "vld1.8      {q0}, [%2]!                   \n"  // load B
+      "vld1.8      {q3}, [%3]!                   \n"  // load A
+      "subs        %5, %5, #16                   \n"  // 16 processed per loop
+      "vst4.8      {d0, d2, d4, d6}, [%4]!       \n"  // store 8 ARGB
+      "vst4.8      {d1, d3, d5, d7}, [%4]!       \n"  // next 8 ARGB
+      "bgt         1b                            \n"
+      : "+r"(src_r),                            // %0
+        "+r"(src_g),                            // %1
+        "+r"(src_b),                            // %2
+        "+r"(src_a),                            // %3
+        "+r"(dst_argb),                         // %4
+        "+r"(width)                             // %5
+      :                                         // Input registers
+      : "cc", "memory", "q0", "q1", "q2", "q3"  // Clobber List
+  );
+}
+
+// Reads 16 packed ARGB and write to planar dst_r, dst_g, dst_b.
+void SplitXRGBRow_NEON(const uint8_t* src_argb,
+                       uint8_t* dst_r,
+                       uint8_t* dst_g,
+                       uint8_t* dst_b,
+                       int width) {
+  asm volatile(
+      "1:                                        \n"
+      "vld4.8      {d0, d2, d4, d6}, [%0]!       \n"  // load 8 ARGB
+      "vld4.8      {d1, d3, d5, d7}, [%0]!       \n"  // next 8 ARGB
+      "subs        %4, %4, #16                   \n"  // 16 processed per loop
+      "vst1.8      {q0}, [%3]!                   \n"  // store B
+      "vst1.8      {q1}, [%2]!                   \n"  // store G
+      "vst1.8      {q2}, [%1]!                   \n"  // store R
+      "bgt         1b                            \n"
+      : "+r"(src_argb),                         // %0
+        "+r"(dst_r),                            // %1
+        "+r"(dst_g),                            // %2
+        "+r"(dst_b),                            // %3
+        "+r"(width)                             // %4
+      :                                         // Input registers
+      : "cc", "memory", "q0", "q1", "q2", "q3"  // Clobber List
+  );
+}
+
+// Reads 16 planar R's, G's, B's and A's and writes out 16 packed ARGB at a time
+void MergeXRGBRow_NEON(const uint8_t* src_r,
+                       const uint8_t* src_g,
+                       const uint8_t* src_b,
+                       uint8_t* dst_argb,
+                       int width) {
+  asm volatile(
+      "vmov.u8     q3, #255                      \n"  // load A(255)
+      "1:                                        \n"
+      "vld1.8      {q2}, [%0]!                   \n"  // load R
+      "vld1.8      {q1}, [%1]!                   \n"  // load G
+      "vld1.8      {q0}, [%2]!                   \n"  // load B
+      "subs        %4, %4, #16                   \n"  // 16 processed per loop
+      "vst4.8      {d0, d2, d4, d6}, [%3]!       \n"  // store 8 ARGB
+      "vst4.8      {d1, d3, d5, d7}, [%3]!       \n"  // next 8 ARGB
+      "bgt         1b                            \n"
+      : "+r"(src_r),                            // %0
+        "+r"(src_g),                            // %1
+        "+r"(src_b),                            // %2
+        "+r"(dst_argb),                         // %3
+        "+r"(width)                             // %4
+      :                                         // Input registers
+      : "cc", "memory", "q0", "q1", "q2", "q3"  // Clobber List
+  );
+}
+
+void MergeXR30Row_NEON(const uint16_t* src_r,
+                       const uint16_t* src_g,
+                       const uint16_t* src_b,
+                       uint8_t* dst_ar30,
+                       int depth,
+                       int width) {
+  int shift = 10 - depth;
+  asm volatile(
+      "vmov.u32    q14, #1023                    \n"
+      "vdup.32     q15, %5                       \n"
+      "1:                                        \n"
+      "vld1.16     {d4}, [%2]!                   \n"  // B
+      "vld1.16     {d2}, [%1]!                   \n"  // G
+      "vld1.16     {d0}, [%0]!                   \n"  // R
+      "vmovl.u16   q2, d4                        \n"  // B
+      "vmovl.u16   q1, d2                        \n"  // G
+      "vmovl.u16   q0, d0                        \n"  // R
+      "vshl.u32    q2, q2, q15                   \n"  // 000B
+      "vshl.u32    q1, q1, q15                   \n"
+      "vshl.u32    q0, q0, q15                   \n"
+      "vmin.u32    q2, q2, q14                   \n"
+      "vmin.u32    q1, q1, q14                   \n"
+      "vmin.u32    q0, q0, q14                   \n"
+      "vsli.u32    q2, q1, #10                   \n"  // 00GB
+      "vsli.u32    q2, q0, #20                   \n"  // 0RGB
+      "vorr.u32    q2, #0xc0000000               \n"  // ARGB (AR30)
+      "subs        %4, %4, #4                    \n"
+      "vst1.8      {q2}, [%3]!                   \n"
+      "bgt         1b                            \n"
+      : "+r"(src_r),     // %0
+        "+r"(src_g),     // %1
+        "+r"(src_b),     // %2
+        "+r"(dst_ar30),  // %3
+        "+r"(width)      // %4
+      : "r"(shift)       // %5
+      : "memory", "cc", "q0", "q1", "q2", "q14", "q15");
+}
+
+void MergeXR30Row_10_NEON(const uint16_t* src_r,
+                          const uint16_t* src_g,
+                          const uint16_t* src_b,
+                          uint8_t* dst_ar30,
+                          int /* depth */,
+                          int width) {
+  asm volatile(
+      "vmov.u32    q14, #1023                    \n"
+      "1:                                        \n"
+      "vld1.16     {d4}, [%2]!                   \n"  // B
+      "vld1.16     {d2}, [%1]!                   \n"  // G
+      "vld1.16     {d0}, [%0]!                   \n"  // R
+      "vmovl.u16   q2, d4                        \n"  // 000B
+      "vmovl.u16   q1, d2                        \n"  // G
+      "vmovl.u16   q0, d0                        \n"  // R
+      "vmin.u32    q2, q2, q14                   \n"
+      "vmin.u32    q1, q1, q14                   \n"
+      "vmin.u32    q0, q0, q14                   \n"
+      "vsli.u32    q2, q1, #10                   \n"  // 00GB
+      "vsli.u32    q2, q0, #20                   \n"  // 0RGB
+      "vorr.u32    q2, #0xc0000000               \n"  // ARGB (AR30)
+      "subs        %4, %4, #4                    \n"
+      "vst1.8      {q2}, [%3]!                   \n"
+      "bgt         1b                            \n"
+      "3:                                        \n"
+      : "+r"(src_r),     // %0
+        "+r"(src_g),     // %1
+        "+r"(src_b),     // %2
+        "+r"(dst_ar30),  // %3
+        "+r"(width)      // %4
+      :
+      : "memory", "cc", "q0", "q1", "q2", "q14");
+}
+
+void MergeAR64Row_NEON(const uint16_t* src_r,
+                       const uint16_t* src_g,
+                       const uint16_t* src_b,
+                       const uint16_t* src_a,
+                       uint16_t* dst_ar64,
+                       int depth,
+                       int width) {
+  int shift = 16 - depth;
+  int mask = (1 << depth) - 1;
+  asm volatile(
+
+      "vdup.u16    q15, %6                       \n"
+      "vdup.u16    q14, %7                       \n"
+      "1:                                        \n"
+      "vld1.16     {q2}, [%0]!                   \n"  // R
+      "vld1.16     {q1}, [%1]!                   \n"  // G
+      "vld1.16     {q0}, [%2]!                   \n"  // B
+      "vld1.16     {q3}, [%3]!                   \n"  // A
+      "vmin.u16    q2, q2, q14                   \n"
+      "vmin.u16    q1, q1, q14                   \n"
+      "vmin.u16    q0, q0, q14                   \n"
+      "vmin.u16    q3, q3, q14                   \n"
+      "vshl.u16    q2, q2, q15                   \n"
+      "vshl.u16    q1, q1, q15                   \n"
+      "vshl.u16    q0, q0, q15                   \n"
+      "vshl.u16    q3, q3, q15                   \n"
+      "subs        %5, %5, #8                    \n"
+      "vst4.16     {d0, d2, d4, d6}, [%4]!       \n"
+      "vst4.16     {d1, d3, d5, d7}, [%4]!       \n"
+      "bgt         1b                            \n"
+      : "+r"(src_r),     // %0
+        "+r"(src_g),     // %1
+        "+r"(src_b),     // %2
+        "+r"(src_a),     // %3
+        "+r"(dst_ar64),  // %4
+        "+r"(width)      // %5
+      : "r"(shift),      // %6
+        "r"(mask)        // %7
+      : "memory", "cc", "q0", "q1", "q2", "q3", "q15");
+}
+
+void MergeXR64Row_NEON(const uint16_t* src_r,
+                       const uint16_t* src_g,
+                       const uint16_t* src_b,
+                       uint16_t* dst_ar64,
+                       int depth,
+                       int width) {
+  int shift = 16 - depth;
+  int mask = (1 << depth) - 1;
+  asm volatile(
+
+      "vmov.u8     q3, #0xff                     \n"  // A (0xffff)
+      "vdup.u16    q15, %5                       \n"
+      "vdup.u16    q14, %6                       \n"
+      "1:                                        \n"
+      "vld1.16     {q2}, [%0]!                   \n"  // R
+      "vld1.16     {q1}, [%1]!                   \n"  // G
+      "vld1.16     {q0}, [%2]!                   \n"  // B
+      "vmin.u16    q2, q2, q14                   \n"
+      "vmin.u16    q1, q1, q14                   \n"
+      "vmin.u16    q0, q0, q14                   \n"
+      "vshl.u16    q2, q2, q15                   \n"
+      "vshl.u16    q1, q1, q15                   \n"
+      "vshl.u16    q0, q0, q15                   \n"
+      "subs        %4, %4, #8                    \n"
+      "vst4.16     {d0, d2, d4, d6}, [%3]!       \n"
+      "vst4.16     {d1, d3, d5, d7}, [%3]!       \n"
+      "bgt         1b                            \n"
+      : "+r"(src_r),     // %0
+        "+r"(src_g),     // %1
+        "+r"(src_b),     // %2
+        "+r"(dst_ar64),  // %3
+        "+r"(width)      // %4
+      : "r"(shift),      // %5
+        "r"(mask)        // %6
+      : "memory", "cc", "q0", "q1", "q2", "q3", "q15");
+}
+
+void MergeARGB16To8Row_NEON(const uint16_t* src_r,
+                            const uint16_t* src_g,
+                            const uint16_t* src_b,
+                            const uint16_t* src_a,
+                            uint8_t* dst_argb,
+                            int depth,
+                            int width) {
+  int shift = 8 - depth;
+  asm volatile(
+
+      "vdup.16     q15, %6                       \n"
+      "1:                                        \n"
+      "vld1.16     {q2}, [%0]!                   \n"  // R
+      "vld1.16     {q1}, [%1]!                   \n"  // G
+      "vld1.16     {q0}, [%2]!                   \n"  // B
+      "vld1.16     {q3}, [%3]!                   \n"  // A
+      "vshl.u16    q2, q2, q15                   \n"
+      "vshl.u16    q1, q1, q15                   \n"
+      "vshl.u16    q0, q0, q15                   \n"
+      "vshl.u16    q3, q3, q15                   \n"
+      "vqmovn.u16  d0, q0                        \n"
+      "vqmovn.u16  d1, q1                        \n"
+      "vqmovn.u16  d2, q2                        \n"
+      "vqmovn.u16  d3, q3                        \n"
+      "subs        %5, %5, #8                    \n"
+      "vst4.8      {d0, d1, d2, d3}, [%4]!       \n"
+      "bgt         1b                            \n"
+      : "+r"(src_r),     // %0
+        "+r"(src_g),     // %1
+        "+r"(src_b),     // %2
+        "+r"(src_a),     // %3
+        "+r"(dst_argb),  // %4
+        "+r"(width)      // %5
+      : "r"(shift)       // %6
+      : "memory", "cc", "q0", "q1", "q2", "q3", "q15");
+}
+
+void MergeXRGB16To8Row_NEON(const uint16_t* src_r,
+                            const uint16_t* src_g,
+                            const uint16_t* src_b,
+                            uint8_t* dst_argb,
+                            int depth,
+                            int width) {
+  int shift = 8 - depth;
+  asm volatile(
+
+      "vdup.16     q15, %5                       \n"
+      "vmov.u8     d6, #0xff                     \n"  // A (0xff)
+      "1:                                        \n"
+      "vld1.16     {q2}, [%0]!                   \n"  // R
+      "vld1.16     {q1}, [%1]!                   \n"  // G
+      "vld1.16     {q0}, [%2]!                   \n"  // B
+      "vshl.u16    q2, q2, q15                   \n"
+      "vshl.u16    q1, q1, q15                   \n"
+      "vshl.u16    q0, q0, q15                   \n"
+      "vqmovn.u16  d5, q2                        \n"
+      "vqmovn.u16  d4, q1                        \n"
+      "vqmovn.u16  d3, q0                        \n"
+      "subs        %4, %4, #8                    \n"
+      "vst4.u8     {d3, d4, d5, d6}, [%3]!       \n"
+      "bgt         1b                            \n"
+      : "+r"(src_r),     // %0
+        "+r"(src_g),     // %1
+        "+r"(src_b),     // %2
+        "+r"(dst_argb),  // %3
+        "+r"(width)      // %4
+      : "r"(shift)       // %5
+      : "memory", "cc", "q0", "q1", "q2", "d6", "q15");
+}
+
+// Copy multiple of 32.  vld4.8  allow unaligned and is fastest on a15.
+void CopyRow_NEON(const uint8_t* src, uint8_t* dst, int width) {
+  asm volatile(
+      "1:                                        \n"
+      "vld1.8      {d0, d1, d2, d3}, [%0]!       \n"  // load 32
+      "subs        %2, %2, #32                   \n"  // 32 processed per loop
+      "vst1.8      {d0, d1, d2, d3}, [%1]!       \n"  // store 32
+      "bgt         1b                            \n"
+      : "+r"(src),                  // %0
+        "+r"(dst),                  // %1
+        "+r"(width)                 // %2  // Output registers
+      :                             // Input registers
+      : "cc", "memory", "q0", "q1"  // Clobber List
+  );
+}
+
+// SetRow writes 'width' bytes using an 8 bit value repeated.
+void SetRow_NEON(uint8_t* dst, uint8_t v8, int width) {
+  asm volatile(
+      "vdup.8      q0, %2                        \n"  // duplicate 16 bytes
+      "1:                                        \n"
+      "subs        %1, %1, #16                   \n"  // 16 bytes per loop
+      "vst1.8      {q0}, [%0]!                   \n"  // store
+      "bgt         1b                            \n"
+      : "+r"(dst),   // %0
+        "+r"(width)  // %1
+      : "r"(v8)      // %2
+      : "cc", "memory", "q0");
+}
+
+// ARGBSetRow writes 'width' pixels using an 32 bit value repeated.
+void ARGBSetRow_NEON(uint8_t* dst, uint32_t v32, int width) {
+  asm volatile(
+      "vdup.u32    q0, %2                        \n"  // duplicate 4 ints
+      "1:                                        \n"
+      "subs        %1, %1, #4                    \n"  // 4 pixels per loop
+      "vst1.8      {q0}, [%0]!                   \n"  // store
+      "bgt         1b                            \n"
+      : "+r"(dst),   // %0
+        "+r"(width)  // %1
+      : "r"(v32)     // %2
+      : "cc", "memory", "q0");
+}
+
+void MirrorRow_NEON(const uint8_t* src, uint8_t* dst, int width) {
+  asm volatile(
+      // Start at end of source row.
+      "add         %0, %0, %2                    \n"
+      "sub         %0, %0, #32                   \n"  // 32 bytes per loop
+
+      "1:                                        \n"
+      "vld1.8      {q1, q2}, [%0], %3            \n"  // src -= 32
+      "subs        %2, #32                       \n"  // 32 pixels per loop.
+      "vrev64.8    q0, q2                        \n"
+      "vrev64.8    q1, q1                        \n"
+      "vswp        d0, d1                        \n"
+      "vswp        d2, d3                        \n"
+      "vst1.8      {q0, q1}, [%1]!               \n"  // dst += 32
+      "bgt         1b                            \n"
+      : "+r"(src),   // %0
+        "+r"(dst),   // %1
+        "+r"(width)  // %2
+      : "r"(-32)     // %3
+      : "cc", "memory", "q0", "q1", "q2");
+}
+
+void MirrorUVRow_NEON(const uint8_t* src_uv, uint8_t* dst_uv, int width) {
+  asm volatile(
+      // Start at end of source row.
+      "mov         r12, #-16                     \n"
+      "add         %0, %0, %2, lsl #1            \n"
+      "sub         %0, #16                       \n"
+
+      "1:                                        \n"
+      "vld2.8      {d0, d1}, [%0], r12           \n"  // src -= 16
+      "subs        %2, #8                        \n"  // 8 pixels per loop.
+      "vrev64.8    q0, q0                        \n"
+      "vst2.8      {d0, d1}, [%1]!               \n"  // dst += 16
+      "bgt         1b                            \n"
+      : "+r"(src_uv),  // %0
+        "+r"(dst_uv),  // %1
+        "+r"(width)    // %2
+      :
+      : "cc", "memory", "r12", "q0");
+}
+
+void MirrorSplitUVRow_NEON(const uint8_t* src_uv,
+                           uint8_t* dst_u,
+                           uint8_t* dst_v,
+                           int width) {
+  asm volatile(
+      // Start at end of source row.
+      "mov         r12, #-16                     \n"
+      "add         %0, %0, %3, lsl #1            \n"
+      "sub         %0, #16                       \n"
+
+      "1:                                        \n"
+      "vld2.8      {d0, d1}, [%0], r12           \n"  // src -= 16
+      "subs        %3, #8                        \n"  // 8 pixels per loop.
+      "vrev64.8    q0, q0                        \n"
+      "vst1.8      {d0}, [%1]!                   \n"  // dst += 8
+      "vst1.8      {d1}, [%2]!                   \n"
+      "bgt         1b                            \n"
+      : "+r"(src_uv),  // %0
+        "+r"(dst_u),   // %1
+        "+r"(dst_v),   // %2
+        "+r"(width)    // %3
+      :
+      : "cc", "memory", "r12", "q0");
+}
+
+void ARGBMirrorRow_NEON(const uint8_t* src_argb, uint8_t* dst_argb, int width) {
+  asm volatile(
+      "add         %0, %0, %2, lsl #2            \n"
+      "sub         %0, #32                       \n"
+
+      "1:                                        \n"
+      "vld4.8      {d0, d1, d2, d3}, [%0], %3    \n"  // src -= 32
+      "subs        %2, #8                        \n"  // 8 pixels per loop.
+      "vrev64.8    d0, d0                        \n"
+      "vrev64.8    d1, d1                        \n"
+      "vrev64.8    d2, d2                        \n"
+      "vrev64.8    d3, d3                        \n"
+      "vst4.8      {d0, d1, d2, d3}, [%1]!       \n"  // dst += 32
+      "bgt         1b                            \n"
+      : "+r"(src_argb),  // %0
+        "+r"(dst_argb),  // %1
+        "+r"(width)      // %2
+      : "r"(-32)         // %3
+      : "cc", "memory", "d0", "d1", "d2", "d3");
+}
+
+void RGB24MirrorRow_NEON(const uint8_t* src_rgb24,
+                         uint8_t* dst_rgb24,
+                         int width) {
+  src_rgb24 += width * 3 - 24;
+  asm volatile(
+      "1:                                        \n"
+      "vld3.8      {d0, d1, d2}, [%0], %3        \n"  // src -= 24
+      "subs        %2, #8                        \n"  // 8 pixels per loop.
+      "vrev64.8    d0, d0                        \n"
+      "vrev64.8    d1, d1                        \n"
+      "vrev64.8    d2, d2                        \n"
+      "vst3.8      {d0, d1, d2}, [%1]!           \n"  // dst += 24
+      "bgt         1b                            \n"
+      : "+r"(src_rgb24),  // %0
+        "+r"(dst_rgb24),  // %1
+        "+r"(width)       // %2
+      : "r"(-24)          // %3
+      : "cc", "memory", "d0", "d1", "d2");
+}
+
+void RGB24ToARGBRow_NEON(const uint8_t* src_rgb24,
+                         uint8_t* dst_argb,
+                         int width) {
+  asm volatile(
+      "vmov.u8     d4, #255                      \n"  // Alpha
+      "1:                                        \n"
+      "vld3.8      {d1, d2, d3}, [%0]!           \n"  // load 8 pixels of RGB24.
+      "subs        %2, %2, #8                    \n"  // 8 processed per loop.
+      "vst4.8      {d1, d2, d3, d4}, [%1]!       \n"  // store 8 pixels of ARGB.
+      "bgt         1b                            \n"
+      : "+r"(src_rgb24),  // %0
+        "+r"(dst_argb),   // %1
+        "+r"(width)       // %2
+      :
+      : "cc", "memory", "d1", "d2", "d3", "d4"  // Clobber List
+  );
+}
+
+void RAWToARGBRow_NEON(const uint8_t* src_raw, uint8_t* dst_argb, int width) {
+  asm volatile(
+      "vmov.u8     d4, #255                      \n"  // Alpha
+      "1:                                        \n"
+      "vld3.8      {d1, d2, d3}, [%0]!           \n"  // load 8 pixels of RAW.
+      "subs        %2, %2, #8                    \n"  // 8 processed per loop.
+      "vswp.u8     d1, d3                        \n"  // swap R, B
+      "vst4.8      {d1, d2, d3, d4}, [%1]!       \n"  // store 8 pixels of ARGB.
+      "bgt         1b                            \n"
+      : "+r"(src_raw),   // %0
+        "+r"(dst_argb),  // %1
+        "+r"(width)      // %2
+      :
+      : "cc", "memory", "d1", "d2", "d3", "d4"  // Clobber List
+  );
+}
+
+void RAWToRGBARow_NEON(const uint8_t* src_raw, uint8_t* dst_rgba, int width) {
+  asm volatile(
+      "vmov.u8     d0, #255                      \n"  // Alpha
+      "1:                                        \n"
+      "vld3.8      {d1, d2, d3}, [%0]!           \n"  // load 8 pixels of RAW.
+      "subs        %2, %2, #8                    \n"  // 8 processed per loop.
+      "vswp.u8     d1, d3                        \n"  // swap R, B
+      "vst4.8      {d0, d1, d2, d3}, [%1]!       \n"  // store 8 pixels of RGBA.
+      "bgt         1b                            \n"
+      : "+r"(src_raw),   // %0
+        "+r"(dst_rgba),  // %1
+        "+r"(width)      // %2
+      :
+      : "cc", "memory", "d0", "d1", "d2", "d3"  // Clobber List
+  );
+}
+void RAWToRGB24Row_NEON(const uint8_t* src_raw, uint8_t* dst_rgb24, int width) {
+  asm volatile(
+      "1:                                        \n"
+      "vld3.8      {d1, d2, d3}, [%0]!           \n"  // load 8 pixels of RAW.
+      "subs        %2, %2, #8                    \n"  // 8 processed per loop.
+      "vswp.u8     d1, d3                        \n"  // swap R, B
+      "vst3.8      {d1, d2, d3}, [%1]!           \n"  // store 8 pixels of
+                                                      // RGB24.
+      "bgt         1b                            \n"
+      : "+r"(src_raw),    // %0
+        "+r"(dst_rgb24),  // %1
+        "+r"(width)       // %2
+      :
+      : "cc", "memory", "d1", "d2", "d3"  // Clobber List
+  );
+}
+
+#define RGB565TOARGB                                                        \
+  "vshrn.u16  d6, q0, #5                     \n" /* G xxGGGGGG           */ \
+  "vuzp.u8    d0, d1                         \n" /* d0 xxxBBBBB RRRRRxxx */ \
+  "vshl.u8    d6, d6, #2                     \n" /* G GGGGGG00 upper 6   */ \
+  "vshr.u8    d1, d1, #3                     \n" /* R 000RRRRR lower 5   */ \
+  "vshl.u8    q0, q0, #3                     \n" /* B,R BBBBB000 upper 5 */ \
+  "vshr.u8    q2, q0, #5                     \n" /* B,R 00000BBB lower 3 */ \
+  "vorr.u8    d0, d0, d4                     \n" /* B                    */ \
+  "vshr.u8    d4, d6, #6                     \n" /* G 000000GG lower 2   */ \
+  "vorr.u8    d2, d1, d5                     \n" /* R                    */ \
+  "vorr.u8    d1, d4, d6                     \n" /* G                    */
+
+void RGB565ToARGBRow_NEON(const uint8_t* src_rgb565,
+                          uint8_t* dst_argb,
+                          int width) {
+  asm volatile(
+      "vmov.u8     d3, #255                      \n"  // Alpha
+      "1:                                        \n"
+      "vld1.8      {q0}, [%0]!                   \n"  // load 8 RGB565 pixels.
+      "subs        %2, %2, #8                    \n"  // 8 processed per loop.
+      RGB565TOARGB
+      "vst4.8      {d0, d1, d2, d3}, [%1]!       \n"  // store 8 pixels of ARGB.
+      "bgt         1b                            \n"
+      : "+r"(src_rgb565),  // %0
+        "+r"(dst_argb),    // %1
+        "+r"(width)        // %2
+      :
+      : "cc", "memory", "q0", "q1", "q2", "q3"  // Clobber List
+  );
+}
+
+#define ARGB1555TOARGB                                                      \
+  "vshrn.u16  d7, q0, #8                     \n" /* A Arrrrrxx           */ \
+  "vshr.u8    d6, d7, #2                     \n" /* R xxxRRRRR           */ \
+  "vshrn.u16  d5, q0, #5                     \n" /* G xxxGGGGG           */ \
+  "vmovn.u16  d4, q0                         \n" /* B xxxBBBBB           */ \
+  "vshr.u8    d7, d7, #7                     \n" /* A 0000000A           */ \
+  "vneg.s8    d7, d7                         \n" /* A AAAAAAAA upper 8   */ \
+  "vshl.u8    d6, d6, #3                     \n" /* R RRRRR000 upper 5   */ \
+  "vshr.u8    q1, q3, #5                     \n" /* R,A 00000RRR lower 3 */ \
+  "vshl.u8    q0, q2, #3                     \n" /* B,G BBBBB000 upper 5 */ \
+  "vshr.u8    q2, q0, #5                     \n" /* B,G 00000BBB lower 3 */ \
+  "vorr.u8    q1, q1, q3                     \n" /* R,A                  */ \
+  "vorr.u8    q0, q0, q2                     \n" /* B,G                  */
+
+// RGB555TOARGB is same as ARGB1555TOARGB but ignores alpha.
+#define RGB555TOARGB                                                        \
+  "vshrn.u16  d6, q0, #5                     \n" /* G xxxGGGGG           */ \
+  "vuzp.u8    d0, d1                         \n" /* d0 xxxBBBBB xRRRRRxx */ \
+  "vshl.u8    d6, d6, #3                     \n" /* G GGGGG000 upper 5   */ \
+  "vshr.u8    d1, d1, #2                     \n" /* R 00xRRRRR lower 5   */ \
+  "vshl.u8    q0, q0, #3                     \n" /* B,R BBBBB000 upper 5 */ \
+  "vshr.u8    q2, q0, #5                     \n" /* B,R 00000BBB lower 3 */ \
+  "vorr.u8    d0, d0, d4                     \n" /* B                    */ \
+  "vshr.u8    d4, d6, #5                     \n" /* G 00000GGG lower 3   */ \
+  "vorr.u8    d2, d1, d5                     \n" /* R                    */ \
+  "vorr.u8    d1, d4, d6                     \n" /* G                    */
+
+void ARGB1555ToARGBRow_NEON(const uint8_t* src_argb1555,
+                            uint8_t* dst_argb,
+                            int width) {
+  asm volatile(
+      "vmov.u8     d3, #255                      \n"  // Alpha
+      "1:                                        \n"
+      "vld1.8      {q0}, [%0]!                   \n"  // load 8 ARGB1555 pixels.
+      "subs        %2, %2, #8                    \n"  // 8 processed per loop.
+      ARGB1555TOARGB
+      "vst4.8      {d0, d1, d2, d3}, [%1]!       \n"  // store 8 pixels of ARGB.
+      "bgt         1b                            \n"
+      : "+r"(src_argb1555),  // %0
+        "+r"(dst_argb),      // %1
+        "+r"(width)          // %2
+      :
+      : "cc", "memory", "q0", "q1", "q2", "q3"  // Clobber List
+  );
+}
+
+#define ARGB4444TOARGB                                                      \
+  "vuzp.u8    d0, d1                         \n" /* d0 BG, d1 RA         */ \
+  "vshl.u8    q2, q0, #4                     \n" /* B,R BBBB0000         */ \
+  "vshr.u8    q1, q0, #4                     \n" /* G,A 0000GGGG         */ \
+  "vshr.u8    q0, q2, #4                     \n" /* B,R 0000BBBB         */ \
+  "vorr.u8    q0, q0, q2                     \n" /* B,R BBBBBBBB         */ \
+  "vshl.u8    q2, q1, #4                     \n" /* G,A GGGG0000         */ \
+  "vorr.u8    q1, q1, q2                     \n" /* G,A GGGGGGGG         */ \
+  "vswp.u8    d1, d2                         \n" /* B,R,G,A -> B,G,R,A   */
+
+void ARGB4444ToARGBRow_NEON(const uint8_t* src_argb4444,
+                            uint8_t* dst_argb,
+                            int width) {
+  asm volatile(
+      "vmov.u8     d3, #255                      \n"  // Alpha
+      "1:                                        \n"
+      "vld1.8      {q0}, [%0]!                   \n"  // load 8 ARGB4444 pixels.
+      "subs        %2, %2, #8                    \n"  // 8 processed per loop.
+      ARGB4444TOARGB
+      "vst4.8      {d0, d1, d2, d3}, [%1]!       \n"  // store 8 pixels of ARGB.
+      "bgt         1b                            \n"
+      : "+r"(src_argb4444),  // %0
+        "+r"(dst_argb),      // %1
+        "+r"(width)          // %2
+      :
+      : "cc", "memory", "q0", "q1", "q2"  // Clobber List
+  );
+}
+
+void ARGBToRGB24Row_NEON(const uint8_t* src_argb,
+                         uint8_t* dst_rgb24,
+                         int width) {
+  asm volatile(
+      "1:                                        \n"
+      "vld4.8      {d0, d2, d4, d6}, [%0]!       \n"  // load 16 pixels of ARGB.
+      "vld4.8      {d1, d3, d5, d7}, [%0]!       \n"
+      "subs        %2, %2, #16                   \n"  // 16 processed per loop.
+      "vst3.8      {d0, d2, d4}, [%1]!           \n"  // store 16 RGB24 pixels.
+      "vst3.8      {d1, d3, d5}, [%1]!           \n"
+      "bgt         1b                            \n"
+      : "+r"(src_argb),   // %0
+        "+r"(dst_rgb24),  // %1
+        "+r"(width)       // %2
+      :
+      : "cc", "memory", "q0", "q1", "q2", "q3"  // Clobber List
+  );
+}
+
+void ARGBToRAWRow_NEON(const uint8_t* src_argb, uint8_t* dst_raw, int width) {
+  asm volatile(
+      "1:                                        \n"
+      "vld4.8      {d1, d2, d3, d4}, [%0]!       \n"  // load 8 pixels of ARGB.
+      "subs        %2, %2, #8                    \n"  // 8 processed per loop.
+      "vswp.u8     d1, d3                        \n"  // swap R, B
+      "vst3.8      {d1, d2, d3}, [%1]!           \n"  // store 8 pixels of RAW.
+      "bgt         1b                            \n"
+      : "+r"(src_argb),  // %0
+        "+r"(dst_raw),   // %1
+        "+r"(width)      // %2
+      :
+      : "cc", "memory", "d1", "d2", "d3", "d4"  // Clobber List
+  );
+}
+
+void YUY2ToYRow_NEON(const uint8_t* src_yuy2, uint8_t* dst_y, int width) {
+  asm volatile(
+      "1:                                        \n"
+      "vld2.8      {q0, q1}, [%0]!               \n"  // load 16 pixels of YUY2.
+      "subs        %2, %2, #16                   \n"  // 16 processed per loop.
+      "vst1.8      {q0}, [%1]!                   \n"  // store 16 pixels of Y.
+      "bgt         1b                            \n"
+      : "+r"(src_yuy2),  // %0
+        "+r"(dst_y),     // %1
+        "+r"(width)      // %2
+      :
+      : "cc", "memory", "q0", "q1"  // Clobber List
+  );
+}
+
+void UYVYToYRow_NEON(const uint8_t* src_uyvy, uint8_t* dst_y, int width) {
+  asm volatile(
+      "1:                                        \n"
+      "vld2.8      {q0, q1}, [%0]!               \n"  // load 16 pixels of UYVY.
+      "subs        %2, %2, #16                   \n"  // 16 processed per loop.
+      "vst1.8      {q1}, [%1]!                   \n"  // store 16 pixels of Y.
+      "bgt         1b                            \n"
+      : "+r"(src_uyvy),  // %0
+        "+r"(dst_y),     // %1
+        "+r"(width)      // %2
+      :
+      : "cc", "memory", "q0", "q1"  // Clobber List
+  );
+}
+
+void YUY2ToUV422Row_NEON(const uint8_t* src_yuy2,
+                         uint8_t* dst_u,
+                         uint8_t* dst_v,
+                         int width) {
+  asm volatile(
+      "1:                                        \n"
+      "vld4.8      {d0, d1, d2, d3}, [%0]!       \n"  // load 16 pixels of YUY2.
+      "subs        %3, %3, #16                   \n"  // 16 pixels = 8 UVs.
+      "vst1.8      {d1}, [%1]!                   \n"  // store 8 U.
+      "vst1.8      {d3}, [%2]!                   \n"  // store 8 V.
+      "bgt         1b                            \n"
+      : "+r"(src_yuy2),  // %0
+        "+r"(dst_u),     // %1
+        "+r"(dst_v),     // %2
+        "+r"(width)      // %3
+      :
+      : "cc", "memory", "d0", "d1", "d2", "d3"  // Clobber List
+  );
+}
+
+void UYVYToUV422Row_NEON(const uint8_t* src_uyvy,
+                         uint8_t* dst_u,
+                         uint8_t* dst_v,
+                         int width) {
+  asm volatile(
+      "1:                                        \n"
+      "vld4.8      {d0, d1, d2, d3}, [%0]!       \n"  // load 16 pixels of UYVY.
+      "subs        %3, %3, #16                   \n"  // 16 pixels = 8 UVs.
+      "vst1.8      {d0}, [%1]!                   \n"  // store 8 U.
+      "vst1.8      {d2}, [%2]!                   \n"  // store 8 V.
+      "bgt         1b                            \n"
+      : "+r"(src_uyvy),  // %0
+        "+r"(dst_u),     // %1
+        "+r"(dst_v),     // %2
+        "+r"(width)      // %3
+      :
+      : "cc", "memory", "d0", "d1", "d2", "d3"  // Clobber List
+  );
+}
+
+void YUY2ToUVRow_NEON(const uint8_t* src_yuy2,
+                      int stride_yuy2,
+                      uint8_t* dst_u,
+                      uint8_t* dst_v,
+                      int width) {
+  asm volatile(
+      "add         %1, %0, %1                    \n"  // stride + src_yuy2
+      "1:                                        \n"
+      "vld4.8      {d0, d1, d2, d3}, [%0]!       \n"  // load 16 pixels of YUY2.
+      "subs        %4, %4, #16                   \n"  // 16 pixels = 8 UVs.
+      "vld4.8      {d4, d5, d6, d7}, [%1]!       \n"  // load next row YUY2.
+      "vrhadd.u8   d1, d1, d5                    \n"  // average rows of U
+      "vrhadd.u8   d3, d3, d7                    \n"  // average rows of V
+      "vst1.8      {d1}, [%2]!                   \n"  // store 8 U.
+      "vst1.8      {d3}, [%3]!                   \n"  // store 8 V.
+      "bgt         1b                            \n"
+      : "+r"(src_yuy2),     // %0
+        "+r"(stride_yuy2),  // %1
+        "+r"(dst_u),        // %2
+        "+r"(dst_v),        // %3
+        "+r"(width)         // %4
+      :
+      : "cc", "memory", "d0", "d1", "d2", "d3", "d4", "d5", "d6",
+        "d7"  // Clobber List
+  );
+}
+
+void UYVYToUVRow_NEON(const uint8_t* src_uyvy,
+                      int stride_uyvy,
+                      uint8_t* dst_u,
+                      uint8_t* dst_v,
+                      int width) {
+  asm volatile(
+      "add         %1, %0, %1                    \n"  // stride + src_uyvy
+      "1:                                        \n"
+      "vld4.8      {d0, d1, d2, d3}, [%0]!       \n"  // load 16 pixels of UYVY.
+      "subs        %4, %4, #16                   \n"  // 16 pixels = 8 UVs.
+      "vld4.8      {d4, d5, d6, d7}, [%1]!       \n"  // load next row UYVY.
+      "vrhadd.u8   d0, d0, d4                    \n"  // average rows of U
+      "vrhadd.u8   d2, d2, d6                    \n"  // average rows of V
+      "vst1.8      {d0}, [%2]!                   \n"  // store 8 U.
+      "vst1.8      {d2}, [%3]!                   \n"  // store 8 V.
+      "bgt         1b                            \n"
+      : "+r"(src_uyvy),     // %0
+        "+r"(stride_uyvy),  // %1
+        "+r"(dst_u),        // %2
+        "+r"(dst_v),        // %3
+        "+r"(width)         // %4
+      :
+      : "cc", "memory", "d0", "d1", "d2", "d3", "d4", "d5", "d6",
+        "d7"  // Clobber List
+  );
+}
+
+// For BGRAToARGB, ABGRToARGB, RGBAToARGB, and ARGBToRGBA.
+void ARGBShuffleRow_NEON(const uint8_t* src_argb,
+                         uint8_t* dst_argb,
+                         const uint8_t* shuffler,
+                         int width) {
+  asm volatile(
+      "vld1.8      {q2}, [%3]                    \n"  // shuffler
+      "1:                                        \n"
+      "vld1.8      {q0}, [%0]!                   \n"  // load 4 pixels.
+      "subs        %2, %2, #4                    \n"  // 4 processed per loop
+      "vtbl.8      d2, {d0, d1}, d4              \n"  // look up 2 first pixels
+      "vtbl.8      d3, {d0, d1}, d5              \n"  // look up 2 next pixels
+      "vst1.8      {q1}, [%1]!                   \n"  // store 4.
+      "bgt         1b                            \n"
+      : "+r"(src_argb),                   // %0
+        "+r"(dst_argb),                   // %1
+        "+r"(width)                       // %2
+      : "r"(shuffler)                     // %3
+      : "cc", "memory", "q0", "q1", "q2"  // Clobber List
+  );
+}
+
+void I422ToYUY2Row_NEON(const uint8_t* src_y,
+                        const uint8_t* src_u,
+                        const uint8_t* src_v,
+                        uint8_t* dst_yuy2,
+                        int width) {
+  asm volatile(
+      "1:                                        \n"
+      "vld2.8      {d0, d2}, [%0]!               \n"  // load 16 Ys
+      "vld1.8      {d1}, [%1]!                   \n"  // load 8 Us
+      "vld1.8      {d3}, [%2]!                   \n"  // load 8 Vs
+      "subs        %4, %4, #16                   \n"  // 16 pixels
+      "vst4.8      {d0, d1, d2, d3}, [%3]!       \n"  // Store 8 YUY2/16 pixels.
+      "bgt         1b                            \n"
+      : "+r"(src_y),     // %0
+        "+r"(src_u),     // %1
+        "+r"(src_v),     // %2
+        "+r"(dst_yuy2),  // %3
+        "+r"(width)      // %4
+      :
+      : "cc", "memory", "d0", "d1", "d2", "d3");
+}
+
+void I422ToUYVYRow_NEON(const uint8_t* src_y,
+                        const uint8_t* src_u,
+                        const uint8_t* src_v,
+                        uint8_t* dst_uyvy,
+                        int width) {
+  asm volatile(
+      "1:                                        \n"
+      "vld2.8      {d1, d3}, [%0]!               \n"  // load 16 Ys
+      "vld1.8      {d0}, [%1]!                   \n"  // load 8 Us
+      "vld1.8      {d2}, [%2]!                   \n"  // load 8 Vs
+      "subs        %4, %4, #16                   \n"  // 16 pixels
+      "vst4.8      {d0, d1, d2, d3}, [%3]!       \n"  // Store 8 UYVY/16 pixels.
+      "bgt         1b                            \n"
+      : "+r"(src_y),     // %0
+        "+r"(src_u),     // %1
+        "+r"(src_v),     // %2
+        "+r"(dst_uyvy),  // %3
+        "+r"(width)      // %4
+      :
+      : "cc", "memory", "d0", "d1", "d2", "d3");
+}
+
+void ARGBToRGB565Row_NEON(const uint8_t* src_argb,
+                          uint8_t* dst_rgb565,
+                          int width) {
+  asm volatile(
+      "1:                                        \n"
+      "vld4.8      {d0, d2, d4, d6}, [%0]!       \n"  // load 8 pixels of ARGB.
+      "subs        %2, %2, #8                    \n"  // 8 processed per loop.
+      ARGBTORGB565
+      "vst1.8      {q2}, [%1]!                   \n"  // store 8 pixels RGB565.
+      "bgt         1b                            \n"
+      : "+r"(src_argb),    // %0
+        "+r"(dst_rgb565),  // %1
+        "+r"(width)        // %2
+      :
+      : "cc", "memory", "q0", "q1", "q2", "d6");
+}
+
+void ARGBToRGB565DitherRow_NEON(const uint8_t* src_argb,
+                                uint8_t* dst_rgb,
+                                const uint32_t dither4,
+                                int width) {
+  asm volatile(
+      "vdup.32     d7, %2                        \n"  // dither4
+      "1:                                        \n"
+      "vld4.8      {d0, d2, d4, d6}, [%1]!       \n"  // load 8 pixels of ARGB.
+      "subs        %3, %3, #8                    \n"  // 8 processed per loop.
+      "vqadd.u8    d0, d0, d7                    \n"
+      "vqadd.u8    d2, d2, d7                    \n"
+      "vqadd.u8    d4, d4, d7                    \n"  // add for dither
+      ARGBTORGB565
+      "vst1.8      {q2}, [%0]!                   \n"  // store 8 RGB565.
+      "bgt         1b                            \n"
+      : "+r"(dst_rgb)   // %0
+      : "r"(src_argb),  // %1
+        "r"(dither4),   // %2
+        "r"(width)      // %3
+      : "cc", "memory", "q0", "q1", "q2", "q3");
+}
+
+void ARGBToARGB1555Row_NEON(const uint8_t* src_argb,
+                            uint8_t* dst_argb1555,
+                            int width) {
+  asm volatile(
+      "1:                                        \n"
+      "vld4.8      {d0, d2, d4, d6}, [%0]!       \n"  // load 8 pixels of ARGB.
+      "subs        %2, %2, #8                    \n"  // 8 processed per loop.
+      ARGBTOARGB1555
+      "vst1.8      {q3}, [%1]!                   \n"  // store 8 ARGB1555.
+      "bgt         1b                            \n"
+      : "+r"(src_argb),      // %0
+        "+r"(dst_argb1555),  // %1
+        "+r"(width)          // %2
+      :
+      : "cc", "memory", "q0", "q1", "q2", "q3");
+}
+
+void ARGBToARGB4444Row_NEON(const uint8_t* src_argb,
+                            uint8_t* dst_argb4444,
+                            int width) {
+  asm volatile(
+      "vmov.u8     d7, #0x0f                     \n"  // bits to clear with
+                                                      // vbic.
+      "1:                                        \n"
+      "vld4.8      {d0, d2, d4, d6}, [%0]!       \n"  // load 8 pixels of ARGB.
+      "subs        %2, %2, #8                    \n"  // 8 processed per loop.
+      ARGBTOARGB4444
+      "vst1.8      {q0}, [%1]!                   \n"  // store 8 ARGB4444.
+      "bgt         1b                            \n"
+      : "+r"(src_argb),      // %0
+        "+r"(dst_argb4444),  // %1
+        "+r"(width)          // %2
+      :
+      : "cc", "memory", "q0", "q1", "q2", "q3");
+}
+
+void ARGBExtractAlphaRow_NEON(const uint8_t* src_argb,
+                              uint8_t* dst_a,
+                              int width) {
+  asm volatile(
+      "1:                                        \n"
+      "vld4.8      {d0, d2, d4, d6}, [%0]!       \n"  // load 8 ARGB pixels
+      "vld4.8      {d1, d3, d5, d7}, [%0]!       \n"  // load next 8 ARGB pixels
+      "subs        %2, %2, #16                   \n"  // 16 processed per loop
+      "vst1.8      {q3}, [%1]!                   \n"  // store 16 A's.
+      "bgt         1b                            \n"
+      : "+r"(src_argb),  // %0
+        "+r"(dst_a),     // %1
+        "+r"(width)      // %2
+      :
+      : "cc", "memory", "q0", "q1", "q2", "q3"  // Clobber List
+  );
+}
+
+// 8x1 pixels.
+void ARGBToUV444Row_NEON(const uint8_t* src_argb,
+                         uint8_t* dst_u,
+                         uint8_t* dst_v,
+                         int width) {
+  asm volatile(
+      "vmov.u8     d24, #112                     \n"  // UB / VR 0.875
+                                                      // coefficient
+      "vmov.u8     d25, #74                      \n"  // UG -0.5781 coefficient
+      "vmov.u8     d26, #38                      \n"  // UR -0.2969 coefficient
+      "vmov.u8     d27, #18                      \n"  // VB -0.1406 coefficient
+      "vmov.u8     d28, #94                      \n"  // VG -0.7344 coefficient
+      "vmov.u16    q15, #0x8080                  \n"  // 128.5
+      "1:                                        \n"
+      "vld4.8      {d0, d1, d2, d3}, [%0]!       \n"  // load 8 ARGB pixels.
+      "subs        %3, %3, #8                    \n"  // 8 processed per loop.
+      "vmull.u8    q2, d0, d24                   \n"  // B
+      "vmlsl.u8    q2, d1, d25                   \n"  // G
+      "vmlsl.u8    q2, d2, d26                   \n"  // R
+
+      "vmull.u8    q3, d2, d24                   \n"  // R
+      "vmlsl.u8    q3, d1, d28                   \n"  // G
+      "vmlsl.u8    q3, d0, d27                   \n"  // B
+
+      "vaddhn.u16  d0, q2, q15                   \n"  // +128 -> unsigned
+      "vaddhn.u16  d1, q3, q15                   \n"  // +128 -> unsigned
+
+      "vst1.8      {d0}, [%1]!                   \n"  // store 8 pixels U.
+      "vst1.8      {d1}, [%2]!                   \n"  // store 8 pixels V.
+      "bgt         1b                            \n"
+      : "+r"(src_argb),  // %0
+        "+r"(dst_u),     // %1
+        "+r"(dst_v),     // %2
+        "+r"(width)      // %3
+      :
+      : "cc", "memory", "q0", "q1", "q2", "q3", "q4", "q12", "q13", "q14",
+        "q15");
+}
+
+// clang-format off
+// 16x2 pixels -> 8x1.  width is number of argb pixels. e.g. 16.
+#define RGBTOUV(QB, QG, QR)                                                 \
+  "vmul.s16   q8, " #QB ", q10               \n" /* B                    */ \
+  "vmls.s16   q8, " #QG ", q11               \n" /* G                    */ \
+  "vmls.s16   q8, " #QR ", q12               \n" /* R                    */ \
+  "vmul.s16   q9, " #QR ", q10               \n" /* R                    */ \
+  "vmls.s16   q9, " #QG ", q14               \n" /* G                    */ \
+  "vmls.s16   q9, " #QB ", q13               \n" /* B                    */ \
+  "vaddhn.u16 d0, q8, q15                    \n" /* +128 -> unsigned     */ \
+  "vaddhn.u16 d1, q9, q15                    \n" /* +128 -> unsigned     */
+// clang-format on
+
+// TODO(fbarchard): Consider vhadd vertical, then vpaddl horizontal, avoid shr.
+void ARGBToUVRow_NEON(const uint8_t* src_argb,
+                      int src_stride_argb,
+                      uint8_t* dst_u,
+                      uint8_t* dst_v,
+                      int width) {
+  asm volatile (
+      "add         %1, %0, %1                    \n"  // src_stride + src_argb
+      "vmov.s16    q10, #112 / 2                 \n"  // UB / VR 0.875 coefficient
+      "vmov.s16    q11, #74 / 2                  \n"  // UG -0.5781 coefficient
+      "vmov.s16    q12, #38 / 2                  \n"  // UR -0.2969 coefficient
+      "vmov.s16    q13, #18 / 2                  \n"  // VB -0.1406 coefficient
+      "vmov.s16    q14, #94 / 2                  \n"  // VG -0.7344 coefficient
+      "vmov.u16    q15, #0x8080                  \n"  // 128.5
+      "1:                                        \n"
+      "vld4.8      {d0, d2, d4, d6}, [%0]!       \n"  // load 8 ARGB pixels.
+      "vld4.8      {d1, d3, d5, d7}, [%0]!       \n"  // load next 8 ARGB pixels.
+      "vpaddl.u8   q0, q0                        \n"  // B 16 bytes -> 8 shorts.
+      "vpaddl.u8   q1, q1                        \n"  // G 16 bytes -> 8 shorts.
+      "vpaddl.u8   q2, q2                        \n"  // R 16 bytes -> 8 shorts.
+      "vld4.8      {d8, d10, d12, d14}, [%1]!    \n"  // load 8 more ARGB pixels.
+      "vld4.8      {d9, d11, d13, d15}, [%1]!    \n"  // load last 8 ARGB pixels.
+      "vpadal.u8   q0, q4                        \n"  // B 16 bytes -> 8 shorts.
+      "vpadal.u8   q1, q5                        \n"  // G 16 bytes -> 8 shorts.
+      "vpadal.u8   q2, q6                        \n"  // R 16 bytes -> 8 shorts.
+
+      "vrshr.u16   q0, q0, #1                    \n"  // 2x average
+      "vrshr.u16   q1, q1, #1                    \n"
+      "vrshr.u16   q2, q2, #1                    \n"
+
+      "subs        %4, %4, #16                   \n"  // 16 processed per loop.
+    RGBTOUV(q0, q1, q2)
+      "vst1.8      {d0}, [%2]!                   \n"  // store 8 pixels U.
+      "vst1.8      {d1}, [%3]!                   \n"  // store 8 pixels V.
+      "bgt         1b                            \n"
+  : "+r"(src_argb),  // %0
+    "+r"(src_stride_argb),  // %1
+    "+r"(dst_u),     // %2
+    "+r"(dst_v),     // %3
+    "+r"(width)        // %4
+  :
+  : "cc", "memory", "q0", "q1", "q2", "q3", "q4", "q5", "q6", "q7",
+    "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
+  );
+}
+
+// TODO(fbarchard): Subsample match C code.
+void ARGBToUVJRow_NEON(const uint8_t* src_argb,
+                       int src_stride_argb,
+                       uint8_t* dst_u,
+                       uint8_t* dst_v,
+                       int width) {
+  asm volatile (
+      "add         %1, %0, %1                    \n"  // src_stride + src_argb
+      "vmov.s16    q10, #127 / 2                 \n"  // UB / VR 0.500 coefficient
+      "vmov.s16    q11, #84 / 2                  \n"  // UG -0.33126 coefficient
+      "vmov.s16    q12, #43 / 2                  \n"  // UR -0.16874 coefficient
+      "vmov.s16    q13, #20 / 2                  \n"  // VB -0.08131 coefficient
+      "vmov.s16    q14, #107 / 2                 \n"  // VG -0.41869 coefficient
+      "vmov.u16    q15, #0x8080                  \n"  // 128.5
+      "1:                                        \n"
+      "vld4.8      {d0, d2, d4, d6}, [%0]!       \n"  // load 8 ARGB pixels.
+      "vld4.8      {d1, d3, d5, d7}, [%0]!       \n"  // load next 8 ARGB pixels.
+      "vpaddl.u8   q0, q0                        \n"  // B 16 bytes -> 8 shorts.
+      "vpaddl.u8   q1, q1                        \n"  // G 16 bytes -> 8 shorts.
+      "vpaddl.u8   q2, q2                        \n"  // R 16 bytes -> 8 shorts.
+      "vld4.8      {d8, d10, d12, d14}, [%1]!    \n"  // load 8 more ARGB pixels.
+      "vld4.8      {d9, d11, d13, d15}, [%1]!    \n"  // load last 8 ARGB pixels.
+      "vpadal.u8   q0, q4                        \n"  // B 16 bytes -> 8 shorts.
+      "vpadal.u8   q1, q5                        \n"  // G 16 bytes -> 8 shorts.
+      "vpadal.u8   q2, q6                        \n"  // R 16 bytes -> 8 shorts.
+
+      "vrshr.u16   q0, q0, #1                    \n"  // 2x average
+      "vrshr.u16   q1, q1, #1                    \n"
+      "vrshr.u16   q2, q2, #1                    \n"
+
+      "subs        %4, %4, #16                   \n"  // 16 processed per loop.
+    RGBTOUV(q0, q1, q2)
+      "vst1.8      {d0}, [%2]!                   \n"  // store 8 pixels U.
+      "vst1.8      {d1}, [%3]!                   \n"  // store 8 pixels V.
+      "bgt         1b                            \n"
+  : "+r"(src_argb),  // %0
+    "+r"(src_stride_argb),  // %1
+    "+r"(dst_u),     // %2
+    "+r"(dst_v),     // %3
+    "+r"(width)        // %4
+  :
+  : "cc", "memory", "q0", "q1", "q2", "q3", "q4", "q5", "q6", "q7",
+    "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
+  );
+}
+
+// TODO(fbarchard): Subsample match C code.
+void RGB24ToUVJRow_NEON(const uint8_t* src_rgb24,
+                        int src_stride_rgb24,
+                        uint8_t* dst_u,
+                        uint8_t* dst_v,
+                        int width) {
+  asm volatile (
+      "add         %1, %0, %1                    \n"  // src_stride + src_rgb24
+      "vmov.s16    q10, #127 / 2                 \n"  // UB / VR 0.500 coefficient
+      "vmov.s16    q11, #84 / 2                  \n"  // UG -0.33126 coefficient
+      "vmov.s16    q12, #43 / 2                  \n"  // UR -0.16874 coefficient
+      "vmov.s16    q13, #20 / 2                  \n"  // VB -0.08131 coefficient
+      "vmov.s16    q14, #107 / 2                 \n"  // VG -0.41869 coefficient
+      "vmov.u16    q15, #0x8080                  \n"  // 128.5
+      "1:                                        \n"
+      "vld3.8      {d0, d2, d4}, [%0]!           \n"  // load 8 RGB24 pixels.
+      "vld3.8      {d1, d3, d5}, [%0]!           \n"  // load next 8 RGB24 pixels.
+      "vpaddl.u8   q0, q0                        \n"  // B 16 bytes -> 8 shorts.
+      "vpaddl.u8   q1, q1                        \n"  // G 16 bytes -> 8 shorts.
+      "vpaddl.u8   q2, q2                        \n"  // R 16 bytes -> 8 shorts.
+      "vld3.8      {d8, d10, d12}, [%1]!         \n"  // load 8 more RGB24 pixels.
+      "vld3.8      {d9, d11, d13}, [%1]!         \n"  // load last 8 RGB24 pixels.
+      "vpadal.u8   q0, q4                        \n"  // B 16 bytes -> 8 shorts.
+      "vpadal.u8   q1, q5                        \n"  // G 16 bytes -> 8 shorts.
+      "vpadal.u8   q2, q6                        \n"  // R 16 bytes -> 8 shorts.
+
+      "vrshr.u16   q0, q0, #1                    \n"  // 2x average
+      "vrshr.u16   q1, q1, #1                    \n"
+      "vrshr.u16   q2, q2, #1                    \n"
+
+      "subs        %4, %4, #16                   \n"  // 16 processed per loop.
+    RGBTOUV(q0, q1, q2)
+      "vst1.8      {d0}, [%2]!                   \n"  // store 8 pixels U.
+      "vst1.8      {d1}, [%3]!                   \n"  // store 8 pixels V.
+      "bgt         1b                            \n"
+  : "+r"(src_rgb24),  // %0
+    "+r"(src_stride_rgb24),  // %1
+    "+r"(dst_u),     // %2
+    "+r"(dst_v),     // %3
+    "+r"(width)        // %4
+  :
+  : "cc", "memory", "q0", "q1", "q2", "q3", "q4", "q5", "q6", "q7",
+    "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
+  );
+}
+
+// TODO(fbarchard): Subsample match C code.
+void RAWToUVJRow_NEON(const uint8_t* src_raw,
+                      int src_stride_raw,
+                      uint8_t* dst_u,
+                      uint8_t* dst_v,
+                      int width) {
+  asm volatile (
+      "add         %1, %0, %1                    \n"  // src_stride + src_raw
+      "vmov.s16    q10, #127 / 2                 \n"  // UB / VR 0.500 coefficient
+      "vmov.s16    q11, #84 / 2                  \n"  // UG -0.33126 coefficient
+      "vmov.s16    q12, #43 / 2                  \n"  // UR -0.16874 coefficient
+      "vmov.s16    q13, #20 / 2                  \n"  // VB -0.08131 coefficient
+      "vmov.s16    q14, #107 / 2                 \n"  // VG -0.41869 coefficient
+      "vmov.u16    q15, #0x8080                  \n"  // 128.5
+      "1:                                        \n"
+      "vld3.8      {d0, d2, d4}, [%0]!           \n"  // load 8 RAW pixels.
+      "vld3.8      {d1, d3, d5}, [%0]!           \n"  // load next 8 RAW pixels.
+      "vpaddl.u8   q0, q0                        \n"  // B 16 bytes -> 8 shorts.
+      "vpaddl.u8   q1, q1                        \n"  // G 16 bytes -> 8 shorts.
+      "vpaddl.u8   q2, q2                        \n"  // R 16 bytes -> 8 shorts.
+      "vld3.8      {d8, d10, d12}, [%1]!         \n"  // load 8 more RAW pixels.
+      "vld3.8      {d9, d11, d13}, [%1]!         \n"  // load last 8 RAW pixels.
+      "vpadal.u8   q0, q4                        \n"  // B 16 bytes -> 8 shorts.
+      "vpadal.u8   q1, q5                        \n"  // G 16 bytes -> 8 shorts.
+      "vpadal.u8   q2, q6                        \n"  // R 16 bytes -> 8 shorts.
+
+      "vrshr.u16   q0, q0, #1                    \n"  // 2x average
+      "vrshr.u16   q1, q1, #1                    \n"
+      "vrshr.u16   q2, q2, #1                    \n"
+
+      "subs        %4, %4, #16                   \n"  // 16 processed per loop.
+    RGBTOUV(q2, q1, q0)
+      "vst1.8      {d0}, [%2]!                   \n"  // store 8 pixels U.
+      "vst1.8      {d1}, [%3]!                   \n"  // store 8 pixels V.
+      "bgt         1b                            \n"
+  : "+r"(src_raw),  // %0
+    "+r"(src_stride_raw),  // %1
+    "+r"(dst_u),     // %2
+    "+r"(dst_v),     // %3
+    "+r"(width)        // %4
+  :
+  : "cc", "memory", "q0", "q1", "q2", "q3", "q4", "q5", "q6", "q7",
+    "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
+  );
+}
+
+void BGRAToUVRow_NEON(const uint8_t* src_bgra,
+                      int src_stride_bgra,
+                      uint8_t* dst_u,
+                      uint8_t* dst_v,
+                      int width) {
+  asm volatile (
+      "add         %1, %0, %1                    \n"  // src_stride + src_bgra
+      "vmov.s16    q10, #112 / 2                 \n"  // UB / VR 0.875 coefficient
+      "vmov.s16    q11, #74 / 2                  \n"  // UG -0.5781 coefficient
+      "vmov.s16    q12, #38 / 2                  \n"  // UR -0.2969 coefficient
+      "vmov.s16    q13, #18 / 2                  \n"  // VB -0.1406 coefficient
+      "vmov.s16    q14, #94 / 2                  \n"  // VG -0.7344 coefficient
+      "vmov.u16    q15, #0x8080                  \n"  // 128.5
+      "1:                                        \n"
+      "vld4.8      {d0, d2, d4, d6}, [%0]!       \n"  // load 8 BGRA pixels.
+      "vld4.8      {d1, d3, d5, d7}, [%0]!       \n"  // load next 8 BGRA pixels.
+      "vpaddl.u8   q3, q3                        \n"  // B 16 bytes -> 8 shorts.
+      "vpaddl.u8   q2, q2                        \n"  // G 16 bytes -> 8 shorts.
+      "vpaddl.u8   q1, q1                        \n"  // R 16 bytes -> 8 shorts.
+      "vld4.8      {d8, d10, d12, d14}, [%1]!    \n"  // load 8 more BGRA pixels.
+      "vld4.8      {d9, d11, d13, d15}, [%1]!    \n"  // load last 8 BGRA pixels.
+      "vpadal.u8   q3, q7                        \n"  // B 16 bytes -> 8 shorts.
+      "vpadal.u8   q2, q6                        \n"  // G 16 bytes -> 8 shorts.
+      "vpadal.u8   q1, q5                        \n"  // R 16 bytes -> 8 shorts.
+
+      "vrshr.u16   q1, q1, #1                    \n"  // 2x average
+      "vrshr.u16   q2, q2, #1                    \n"
+      "vrshr.u16   q3, q3, #1                    \n"
+
+      "subs        %4, %4, #16                   \n"  // 16 processed per loop.
+    RGBTOUV(q3, q2, q1)
+      "vst1.8      {d0}, [%2]!                   \n"  // store 8 pixels U.
+      "vst1.8      {d1}, [%3]!                   \n"  // store 8 pixels V.
+      "bgt         1b                            \n"
+  : "+r"(src_bgra),  // %0
+    "+r"(src_stride_bgra),  // %1
+    "+r"(dst_u),     // %2
+    "+r"(dst_v),     // %3
+    "+r"(width)        // %4
+  :
+  : "cc", "memory", "q0", "q1", "q2", "q3", "q4", "q5", "q6", "q7",
+    "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
+  );
+}
+
+void ABGRToUVRow_NEON(const uint8_t* src_abgr,
+                      int src_stride_abgr,
+                      uint8_t* dst_u,
+                      uint8_t* dst_v,
+                      int width) {
+  asm volatile (
+      "add         %1, %0, %1                    \n"  // src_stride + src_abgr
+      "vmov.s16    q10, #112 / 2                 \n"  // UB / VR 0.875 coefficient
+      "vmov.s16    q11, #74 / 2                  \n"  // UG -0.5781 coefficient
+      "vmov.s16    q12, #38 / 2                  \n"  // UR -0.2969 coefficient
+      "vmov.s16    q13, #18 / 2                  \n"  // VB -0.1406 coefficient
+      "vmov.s16    q14, #94 / 2                  \n"  // VG -0.7344 coefficient
+      "vmov.u16    q15, #0x8080                  \n"  // 128.5
+      "1:                                        \n"
+      "vld4.8      {d0, d2, d4, d6}, [%0]!       \n"  // load 8 ABGR pixels.
+      "vld4.8      {d1, d3, d5, d7}, [%0]!       \n"  // load next 8 ABGR pixels.
+      "vpaddl.u8   q2, q2                        \n"  // B 16 bytes -> 8 shorts.
+      "vpaddl.u8   q1, q1                        \n"  // G 16 bytes -> 8 shorts.
+      "vpaddl.u8   q0, q0                        \n"  // R 16 bytes -> 8 shorts.
+      "vld4.8      {d8, d10, d12, d14}, [%1]!    \n"  // load 8 more ABGR pixels.
+      "vld4.8      {d9, d11, d13, d15}, [%1]!    \n"  // load last 8 ABGR pixels.
+      "vpadal.u8   q2, q6                        \n"  // B 16 bytes -> 8 shorts.
+      "vpadal.u8   q1, q5                        \n"  // G 16 bytes -> 8 shorts.
+      "vpadal.u8   q0, q4                        \n"  // R 16 bytes -> 8 shorts.
+
+      "vrshr.u16   q0, q0, #1                    \n"  // 2x average
+      "vrshr.u16   q1, q1, #1                    \n"
+      "vrshr.u16   q2, q2, #1                    \n"
+
+      "subs        %4, %4, #16                   \n"  // 16 processed per loop.
+    RGBTOUV(q2, q1, q0)
+      "vst1.8      {d0}, [%2]!                   \n"  // store 8 pixels U.
+      "vst1.8      {d1}, [%3]!                   \n"  // store 8 pixels V.
+      "bgt         1b                            \n"
+  : "+r"(src_abgr),  // %0
+    "+r"(src_stride_abgr),  // %1
+    "+r"(dst_u),     // %2
+    "+r"(dst_v),     // %3
+    "+r"(width)        // %4
+  :
+  : "cc", "memory", "q0", "q1", "q2", "q3", "q4", "q5", "q6", "q7",
+    "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
+  );
+}
+
+void RGBAToUVRow_NEON(const uint8_t* src_rgba,
+                      int src_stride_rgba,
+                      uint8_t* dst_u,
+                      uint8_t* dst_v,
+                      int width) {
+  asm volatile (
+      "add         %1, %0, %1                    \n"  // src_stride + src_rgba
+      "vmov.s16    q10, #112 / 2                 \n"  // UB / VR 0.875 coefficient
+      "vmov.s16    q11, #74 / 2                  \n"  // UG -0.5781 coefficient
+      "vmov.s16    q12, #38 / 2                  \n"  // UR -0.2969 coefficient
+      "vmov.s16    q13, #18 / 2                  \n"  // VB -0.1406 coefficient
+      "vmov.s16    q14, #94 / 2                  \n"  // VG -0.7344 coefficient
+      "vmov.u16    q15, #0x8080                  \n"  // 128.5
+      "1:                                        \n"
+      "vld4.8      {d0, d2, d4, d6}, [%0]!       \n"  // load 8 RGBA pixels.
+      "vld4.8      {d1, d3, d5, d7}, [%0]!       \n"  // load next 8 RGBA pixels.
+      "vpaddl.u8   q0, q1                        \n"  // B 16 bytes -> 8 shorts.
+      "vpaddl.u8   q1, q2                        \n"  // G 16 bytes -> 8 shorts.
+      "vpaddl.u8   q2, q3                        \n"  // R 16 bytes -> 8 shorts.
+      "vld4.8      {d8, d10, d12, d14}, [%1]!    \n"  // load 8 more RGBA pixels.
+      "vld4.8      {d9, d11, d13, d15}, [%1]!    \n"  // load last 8 RGBA pixels.
+      "vpadal.u8   q0, q5                        \n"  // B 16 bytes -> 8 shorts.
+      "vpadal.u8   q1, q6                        \n"  // G 16 bytes -> 8 shorts.
+      "vpadal.u8   q2, q7                        \n"  // R 16 bytes -> 8 shorts.
+
+      "vrshr.u16   q0, q0, #1                    \n"  // 2x average
+      "vrshr.u16   q1, q1, #1                    \n"
+      "vrshr.u16   q2, q2, #1                    \n"
+
+      "subs        %4, %4, #16                   \n"  // 16 processed per loop.
+    RGBTOUV(q0, q1, q2)
+      "vst1.8      {d0}, [%2]!                   \n"  // store 8 pixels U.
+      "vst1.8      {d1}, [%3]!                   \n"  // store 8 pixels V.
+      "bgt         1b                            \n"
+  : "+r"(src_rgba),  // %0
+    "+r"(src_stride_rgba),  // %1
+    "+r"(dst_u),     // %2
+    "+r"(dst_v),     // %3
+    "+r"(width)        // %4
+  :
+  : "cc", "memory", "q0", "q1", "q2", "q3", "q4", "q5", "q6", "q7",
+    "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
+  );
+}
+
+void RGB24ToUVRow_NEON(const uint8_t* src_rgb24,
+                       int src_stride_rgb24,
+                       uint8_t* dst_u,
+                       uint8_t* dst_v,
+                       int width) {
+  asm volatile (
+      "add         %1, %0, %1                    \n"  // src_stride + src_rgb24
+      "vmov.s16    q10, #112 / 2                 \n"  // UB / VR 0.875 coefficient
+      "vmov.s16    q11, #74 / 2                  \n"  // UG -0.5781 coefficient
+      "vmov.s16    q12, #38 / 2                  \n"  // UR -0.2969 coefficient
+      "vmov.s16    q13, #18 / 2                  \n"  // VB -0.1406 coefficient
+      "vmov.s16    q14, #94 / 2                  \n"  // VG -0.7344 coefficient
+      "vmov.u16    q15, #0x8080                  \n"  // 128.5
+      "1:                                        \n"
+      "vld3.8      {d0, d2, d4}, [%0]!           \n"  // load 8 RGB24 pixels.
+      "vld3.8      {d1, d3, d5}, [%0]!           \n"  // load next 8 RGB24 pixels.
+      "vpaddl.u8   q0, q0                        \n"  // B 16 bytes -> 8 shorts.
+      "vpaddl.u8   q1, q1                        \n"  // G 16 bytes -> 8 shorts.
+      "vpaddl.u8   q2, q2                        \n"  // R 16 bytes -> 8 shorts.
+      "vld3.8      {d8, d10, d12}, [%1]!         \n"  // load 8 more RGB24 pixels.
+      "vld3.8      {d9, d11, d13}, [%1]!         \n"  // load last 8 RGB24 pixels.
+      "vpadal.u8   q0, q4                        \n"  // B 16 bytes -> 8 shorts.
+      "vpadal.u8   q1, q5                        \n"  // G 16 bytes -> 8 shorts.
+      "vpadal.u8   q2, q6                        \n"  // R 16 bytes -> 8 shorts.
+
+      "vrshr.u16   q0, q0, #1                    \n"  // 2x average
+      "vrshr.u16   q1, q1, #1                    \n"
+      "vrshr.u16   q2, q2, #1                    \n"
+
+      "subs        %4, %4, #16                   \n"  // 16 processed per loop.
+    RGBTOUV(q0, q1, q2)
+      "vst1.8      {d0}, [%2]!                   \n"  // store 8 pixels U.
+      "vst1.8      {d1}, [%3]!                   \n"  // store 8 pixels V.
+      "bgt         1b                            \n"
+  : "+r"(src_rgb24),  // %0
+    "+r"(src_stride_rgb24),  // %1
+    "+r"(dst_u),     // %2
+    "+r"(dst_v),     // %3
+    "+r"(width)        // %4
+  :
+  : "cc", "memory", "q0", "q1", "q2", "q3", "q4", "q5", "q6", "q7",
+    "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
+  );
+}
+
+void RAWToUVRow_NEON(const uint8_t* src_raw,
+                     int src_stride_raw,
+                     uint8_t* dst_u,
+                     uint8_t* dst_v,
+                     int width) {
+  asm volatile (
+      "add         %1, %0, %1                    \n"  // src_stride + src_raw
+      "vmov.s16    q10, #112 / 2                 \n"  // UB / VR 0.875 coefficient
+      "vmov.s16    q11, #74 / 2                  \n"  // UG -0.5781 coefficient
+      "vmov.s16    q12, #38 / 2                  \n"  // UR -0.2969 coefficient
+      "vmov.s16    q13, #18 / 2                  \n"  // VB -0.1406 coefficient
+      "vmov.s16    q14, #94 / 2                  \n"  // VG -0.7344 coefficient
+      "vmov.u16    q15, #0x8080                  \n"  // 128.5
+      "1:                                        \n"
+      "vld3.8      {d0, d2, d4}, [%0]!           \n"  // load 8 RAW pixels.
+      "vld3.8      {d1, d3, d5}, [%0]!           \n"  // load next 8 RAW pixels.
+      "vpaddl.u8   q2, q2                        \n"  // B 16 bytes -> 8 shorts.
+      "vpaddl.u8   q1, q1                        \n"  // G 16 bytes -> 8 shorts.
+      "vpaddl.u8   q0, q0                        \n"  // R 16 bytes -> 8 shorts.
+      "vld3.8      {d8, d10, d12}, [%1]!         \n"  // load 8 more RAW pixels.
+      "vld3.8      {d9, d11, d13}, [%1]!         \n"  // load last 8 RAW pixels.
+      "vpadal.u8   q2, q6                        \n"  // B 16 bytes -> 8 shorts.
+      "vpadal.u8   q1, q5                        \n"  // G 16 bytes -> 8 shorts.
+      "vpadal.u8   q0, q4                        \n"  // R 16 bytes -> 8 shorts.
+
+      "vrshr.u16   q0, q0, #1                    \n"  // 2x average
+      "vrshr.u16   q1, q1, #1                    \n"
+      "vrshr.u16   q2, q2, #1                    \n"
+
+      "subs        %4, %4, #16                   \n"  // 16 processed per loop.
+    RGBTOUV(q2, q1, q0)
+      "vst1.8      {d0}, [%2]!                   \n"  // store 8 pixels U.
+      "vst1.8      {d1}, [%3]!                   \n"  // store 8 pixels V.
+      "bgt         1b                            \n"
+  : "+r"(src_raw),  // %0
+    "+r"(src_stride_raw),  // %1
+    "+r"(dst_u),     // %2
+    "+r"(dst_v),     // %3
+    "+r"(width)        // %4
+  :
+  : "cc", "memory", "q0", "q1", "q2", "q3", "q4", "q5", "q6", "q7",
+    "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
+  );
+}
+
+// 16x2 pixels -> 8x1.  width is number of argb pixels. e.g. 16.
+void RGB565ToUVRow_NEON(const uint8_t* src_rgb565,
+                        int src_stride_rgb565,
+                        uint8_t* dst_u,
+                        uint8_t* dst_v,
+                        int width) {
+  asm volatile(
+      "add         %1, %0, %1                    \n"  // src_stride + src_argb
+      "vmov.s16    q10, #112 / 2                 \n"  // UB / VR 0.875
+                                                      // coefficient
+      "vmov.s16    q11, #74 / 2                  \n"  // UG -0.5781 coefficient
+      "vmov.s16    q12, #38 / 2                  \n"  // UR -0.2969 coefficient
+      "vmov.s16    q13, #18 / 2                  \n"  // VB -0.1406 coefficient
+      "vmov.s16    q14, #94 / 2                  \n"  // VG -0.7344 coefficient
+      "vmov.u16    q15, #0x8080                  \n"  // 128.5
+      "1:                                        \n"
+      "vld1.8      {q0}, [%0]!                   \n"  // load 8 RGB565 pixels.
+      RGB565TOARGB
+      "vpaddl.u8   d8, d0                        \n"  // B 8 bytes -> 4 shorts.
+      "vpaddl.u8   d10, d1                       \n"  // G 8 bytes -> 4 shorts.
+      "vpaddl.u8   d12, d2                       \n"  // R 8 bytes -> 4 shorts.
+      "vld1.8      {q0}, [%0]!                   \n"  // next 8 RGB565 pixels.
+      RGB565TOARGB
+      "vpaddl.u8   d9, d0                        \n"  // B 8 bytes -> 4 shorts.
+      "vpaddl.u8   d11, d1                       \n"  // G 8 bytes -> 4 shorts.
+      "vpaddl.u8   d13, d2                       \n"  // R 8 bytes -> 4 shorts.
+
+      "vld1.8      {q0}, [%1]!                   \n"  // load 8 RGB565 pixels.
+      RGB565TOARGB
+      "vpadal.u8   d8, d0                        \n"  // B 8 bytes -> 4 shorts.
+      "vpadal.u8   d10, d1                       \n"  // G 8 bytes -> 4 shorts.
+      "vpadal.u8   d12, d2                       \n"  // R 8 bytes -> 4 shorts.
+      "vld1.8      {q0}, [%1]!                   \n"  // next 8 RGB565 pixels.
+      RGB565TOARGB
+      "vpadal.u8   d9, d0                        \n"  // B 8 bytes -> 4 shorts.
+      "vpadal.u8   d11, d1                       \n"  // G 8 bytes -> 4 shorts.
+      "vpadal.u8   d13, d2                       \n"  // R 8 bytes -> 4 shorts.
+
+      "vrshr.u16   q4, q4, #1                    \n"  // 2x average
+      "vrshr.u16   q5, q5, #1                    \n"
+      "vrshr.u16   q6, q6, #1                    \n"
+
+      "subs        %4, %4, #16                   \n"  // 16 processed per loop.
+      "vmul.s16    q8, q4, q10                   \n"  // B
+      "vmls.s16    q8, q5, q11                   \n"  // G
+      "vmls.s16    q8, q6, q12                   \n"  // R
+      "vadd.u16    q8, q8, q15                   \n"  // +128 -> unsigned
+      "vmul.s16    q9, q6, q10                   \n"  // R
+      "vmls.s16    q9, q5, q14                   \n"  // G
+      "vmls.s16    q9, q4, q13                   \n"  // B
+      "vadd.u16    q9, q9, q15                   \n"  // +128 -> unsigned
+      "vqshrn.u16  d0, q8, #8                    \n"  // 16 bit to 8 bit U
+      "vqshrn.u16  d1, q9, #8                    \n"  // 16 bit to 8 bit V
+      "vst1.8      {d0}, [%2]!                   \n"  // store 8 pixels U.
+      "vst1.8      {d1}, [%3]!                   \n"  // store 8 pixels V.
+      "bgt         1b                            \n"
+      : "+r"(src_rgb565),         // %0
+        "+r"(src_stride_rgb565),  // %1
+        "+r"(dst_u),              // %2
+        "+r"(dst_v),              // %3
+        "+r"(width)               // %4
+      :
+      : "cc", "memory", "q0", "q1", "q2", "q3", "q4", "q5", "q6", "q7", "q8",
+        "q9", "q10", "q11", "q12", "q13", "q14", "q15");
+}
+
+// 16x2 pixels -> 8x1.  width is number of argb pixels. e.g. 16.
+void ARGB1555ToUVRow_NEON(const uint8_t* src_argb1555,
+                          int src_stride_argb1555,
+                          uint8_t* dst_u,
+                          uint8_t* dst_v,
+                          int width) {
+  asm volatile(
+      "add         %1, %0, %1                    \n"  // src_stride + src_argb
+      "vmov.s16    q10, #112 / 2                 \n"  // UB / VR 0.875
+                                                      // coefficient
+      "vmov.s16    q11, #74 / 2                  \n"  // UG -0.5781 coefficient
+      "vmov.s16    q12, #38 / 2                  \n"  // UR -0.2969 coefficient
+      "vmov.s16    q13, #18 / 2                  \n"  // VB -0.1406 coefficient
+      "vmov.s16    q14, #94 / 2                  \n"  // VG -0.7344 coefficient
+      "vmov.u16    q15, #0x8080                  \n"  // 128.5
+      "1:                                        \n"
+      "vld1.8      {q0}, [%0]!                   \n"  // load 8 ARGB1555 pixels.
+      RGB555TOARGB
+      "vpaddl.u8   d8, d0                        \n"  // B 8 bytes -> 4 shorts.
+      "vpaddl.u8   d10, d1                       \n"  // G 8 bytes -> 4 shorts.
+      "vpaddl.u8   d12, d2                       \n"  // R 8 bytes -> 4 shorts.
+      "vld1.8      {q0}, [%0]!                   \n"  // next 8 ARGB1555 pixels.
+      RGB555TOARGB
+      "vpaddl.u8   d9, d0                        \n"  // B 8 bytes -> 4 shorts.
+      "vpaddl.u8   d11, d1                       \n"  // G 8 bytes -> 4 shorts.
+      "vpaddl.u8   d13, d2                       \n"  // R 8 bytes -> 4 shorts.
+
+      "vld1.8      {q0}, [%1]!                   \n"  // load 8 ARGB1555 pixels.
+      RGB555TOARGB
+      "vpadal.u8   d8, d0                        \n"  // B 8 bytes -> 4 shorts.
+      "vpadal.u8   d10, d1                       \n"  // G 8 bytes -> 4 shorts.
+      "vpadal.u8   d12, d2                       \n"  // R 8 bytes -> 4 shorts.
+      "vld1.8      {q0}, [%1]!                   \n"  // next 8 ARGB1555 pixels.
+      RGB555TOARGB
+      "vpadal.u8   d9, d0                        \n"  // B 8 bytes -> 4 shorts.
+      "vpadal.u8   d11, d1                       \n"  // G 8 bytes -> 4 shorts.
+      "vpadal.u8   d13, d2                       \n"  // R 8 bytes -> 4 shorts.
+
+      "vrshr.u16   q4, q4, #1                    \n"  // 2x average
+      "vrshr.u16   q5, q5, #1                    \n"
+      "vrshr.u16   q6, q6, #1                    \n"
+
+      "subs        %4, %4, #16                   \n"  // 16 processed per loop.
+      "vmul.s16    q8, q4, q10                   \n"  // B
+      "vmls.s16    q8, q5, q11                   \n"  // G
+      "vmls.s16    q8, q6, q12                   \n"  // R
+      "vadd.u16    q8, q8, q15                   \n"  // +128 -> unsigned
+      "vmul.s16    q9, q6, q10                   \n"  // R
+      "vmls.s16    q9, q5, q14                   \n"  // G
+      "vmls.s16    q9, q4, q13                   \n"  // B
+      "vadd.u16    q9, q9, q15                   \n"  // +128 -> unsigned
+      "vqshrn.u16  d0, q8, #8                    \n"  // 16 bit to 8 bit U
+      "vqshrn.u16  d1, q9, #8                    \n"  // 16 bit to 8 bit V
+      "vst1.8      {d0}, [%2]!                   \n"  // store 8 pixels U.
+      "vst1.8      {d1}, [%3]!                   \n"  // store 8 pixels V.
+      "bgt         1b                            \n"
+      : "+r"(src_argb1555),         // %0
+        "+r"(src_stride_argb1555),  // %1
+        "+r"(dst_u),                // %2
+        "+r"(dst_v),                // %3
+        "+r"(width)                 // %4
+      :
+      : "cc", "memory", "q0", "q1", "q2", "q3", "q4", "q5", "q6", "q7", "q8",
+        "q9", "q10", "q11", "q12", "q13", "q14", "q15");
+}
+
+// 16x2 pixels -> 8x1.  width is number of argb pixels. e.g. 16.
+void ARGB4444ToUVRow_NEON(const uint8_t* src_argb4444,
+                          int src_stride_argb4444,
+                          uint8_t* dst_u,
+                          uint8_t* dst_v,
+                          int width) {
+  asm volatile(
+      "add         %1, %0, %1                    \n"  // src_stride + src_argb
+      "vmov.s16    q10, #112 / 2                 \n"  // UB / VR 0.875
+                                                      // coefficient
+      "vmov.s16    q11, #74 / 2                  \n"  // UG -0.5781 coefficient
+      "vmov.s16    q12, #38 / 2                  \n"  // UR -0.2969 coefficient
+      "vmov.s16    q13, #18 / 2                  \n"  // VB -0.1406 coefficient
+      "vmov.s16    q14, #94 / 2                  \n"  // VG -0.7344 coefficient
+      "vmov.u16    q15, #0x8080                  \n"  // 128.5
+      "1:                                        \n"
+      "vld1.8      {q0}, [%0]!                   \n"  // load 8 ARGB4444 pixels.
+      ARGB4444TOARGB
+      "vpaddl.u8   d8, d0                        \n"  // B 8 bytes -> 4 shorts.
+      "vpaddl.u8   d10, d1                       \n"  // G 8 bytes -> 4 shorts.
+      "vpaddl.u8   d12, d2                       \n"  // R 8 bytes -> 4 shorts.
+      "vld1.8      {q0}, [%0]!                   \n"  // next 8 ARGB4444 pixels.
+      ARGB4444TOARGB
+      "vpaddl.u8   d9, d0                        \n"  // B 8 bytes -> 4 shorts.
+      "vpaddl.u8   d11, d1                       \n"  // G 8 bytes -> 4 shorts.
+      "vpaddl.u8   d13, d2                       \n"  // R 8 bytes -> 4 shorts.
+
+      "vld1.8      {q0}, [%1]!                   \n"  // load 8 ARGB4444 pixels.
+      ARGB4444TOARGB
+      "vpadal.u8   d8, d0                        \n"  // B 8 bytes -> 4 shorts.
+      "vpadal.u8   d10, d1                       \n"  // G 8 bytes -> 4 shorts.
+      "vpadal.u8   d12, d2                       \n"  // R 8 bytes -> 4 shorts.
+      "vld1.8      {q0}, [%1]!                   \n"  // next 8 ARGB4444 pixels.
+      ARGB4444TOARGB
+      "vpadal.u8   d9, d0                        \n"  // B 8 bytes -> 4 shorts.
+      "vpadal.u8   d11, d1                       \n"  // G 8 bytes -> 4 shorts.
+      "vpadal.u8   d13, d2                       \n"  // R 8 bytes -> 4 shorts.
+
+      "vrshr.u16   q0, q4, #1                    \n"  // 2x average
+      "vrshr.u16   q1, q5, #1                    \n"
+      "vrshr.u16   q2, q6, #1                    \n"
+
+      "subs        %4, %4, #16                   \n"  // 16 processed per loop.
+      RGBTOUV(q0, q1, q2)
+      "vst1.8      {d0}, [%2]!                   \n"  // store 8 pixels U.
+      "vst1.8      {d1}, [%3]!                   \n"  // store 8 pixels V.
+      "bgt         1b                            \n"
+      : "+r"(src_argb4444),         // %0
+        "+r"(src_stride_argb4444),  // %1
+        "+r"(dst_u),                // %2
+        "+r"(dst_v),                // %3
+        "+r"(width)                 // %4
+      :
+      : "cc", "memory", "q0", "q1", "q2", "q3", "q4", "q5", "q6", "q7", "q8",
+        "q9", "q10", "q11", "q12", "q13", "q14", "q15");
+}
+
+void RGB565ToYRow_NEON(const uint8_t* src_rgb565, uint8_t* dst_y, int width) {
+  asm volatile(
+      "vmov.u8     d24, #25                      \n"  // B * 0.1016 coefficient
+      "vmov.u8     d25, #129                     \n"  // G * 0.5078 coefficient
+      "vmov.u8     d26, #66                      \n"  // R * 0.2578 coefficient
+      "vmov.u8     d27, #16                      \n"  // Add 16 constant
+      "1:                                        \n"
+      "vld1.8      {q0}, [%0]!                   \n"  // load 8 RGB565 pixels.
+      "subs        %2, %2, #8                    \n"  // 8 processed per loop.
+      RGB565TOARGB
+      "vmull.u8    q2, d0, d24                   \n"  // B
+      "vmlal.u8    q2, d1, d25                   \n"  // G
+      "vmlal.u8    q2, d2, d26                   \n"  // R
+      "vqrshrn.u16 d0, q2, #8                    \n"  // 16 bit to 8 bit Y
+      "vqadd.u8    d0, d27                       \n"
+      "vst1.8      {d0}, [%1]!                   \n"  // store 8 pixels Y.
+      "bgt         1b                            \n"
+      : "+r"(src_rgb565),  // %0
+        "+r"(dst_y),       // %1
+        "+r"(width)        // %2
+      :
+      : "cc", "memory", "q0", "q1", "q2", "q3", "q12", "q13");
+}
+
+void ARGB1555ToYRow_NEON(const uint8_t* src_argb1555,
+                         uint8_t* dst_y,
+                         int width) {
+  asm volatile(
+      "vmov.u8     d24, #25                      \n"  // B * 0.1016 coefficient
+      "vmov.u8     d25, #129                     \n"  // G * 0.5078 coefficient
+      "vmov.u8     d26, #66                      \n"  // R * 0.2578 coefficient
+      "vmov.u8     d27, #16                      \n"  // Add 16 constant
+      "1:                                        \n"
+      "vld1.8      {q0}, [%0]!                   \n"  // load 8 ARGB1555 pixels.
+      "subs        %2, %2, #8                    \n"  // 8 processed per loop.
+      ARGB1555TOARGB
+      "vmull.u8    q2, d0, d24                   \n"  // B
+      "vmlal.u8    q2, d1, d25                   \n"  // G
+      "vmlal.u8    q2, d2, d26                   \n"  // R
+      "vqrshrn.u16 d0, q2, #8                    \n"  // 16 bit to 8 bit Y
+      "vqadd.u8    d0, d27                       \n"
+      "vst1.8      {d0}, [%1]!                   \n"  // store 8 pixels Y.
+      "bgt         1b                            \n"
+      : "+r"(src_argb1555),  // %0
+        "+r"(dst_y),         // %1
+        "+r"(width)          // %2
+      :
+      : "cc", "memory", "q0", "q1", "q2", "q3", "q12", "q13");
+}
+
+void ARGB4444ToYRow_NEON(const uint8_t* src_argb4444,
+                         uint8_t* dst_y,
+                         int width) {
+  asm volatile(
+      "vmov.u8     d24, #25                      \n"  // B * 0.1016 coefficient
+      "vmov.u8     d25, #129                     \n"  // G * 0.5078 coefficient
+      "vmov.u8     d26, #66                      \n"  // R * 0.2578 coefficient
+      "vmov.u8     d27, #16                      \n"  // Add 16 constant
+      "1:                                        \n"
+      "vld1.8      {q0}, [%0]!                   \n"  // load 8 ARGB4444 pixels.
+      "subs        %2, %2, #8                    \n"  // 8 processed per loop.
+      ARGB4444TOARGB
+      "vmull.u8    q2, d0, d24                   \n"  // B
+      "vmlal.u8    q2, d1, d25                   \n"  // G
+      "vmlal.u8    q2, d2, d26                   \n"  // R
+      "vqrshrn.u16 d0, q2, #8                    \n"  // 16 bit to 8 bit Y
+      "vqadd.u8    d0, d27                       \n"
+      "vst1.8      {d0}, [%1]!                   \n"  // store 8 pixels Y.
+      "bgt         1b                            \n"
+      : "+r"(src_argb4444),  // %0
+        "+r"(dst_y),         // %1
+        "+r"(width)          // %2
+      :
+      : "cc", "memory", "q0", "q1", "q2", "q3", "q12", "q13");
+}
+
+void ARGBToAR64Row_NEON(const uint8_t* src_argb,
+                        uint16_t* dst_ar64,
+                        int width) {
+  asm volatile(
+      "1:                                        \n"
+      "vld1.8      {q0}, [%0]!                   \n"
+      "vld1.8      {q2}, [%0]!                   \n"
+      "vmov.u8     q1, q0                        \n"
+      "vmov.u8     q3, q2                        \n"
+      "subs        %2, %2, #8                    \n"  // 8 processed per loop.
+      "vst2.8      {q0, q1}, [%1]!               \n"  // store 4 pixels
+      "vst2.8      {q2, q3}, [%1]!               \n"  // store 4 pixels
+      "bgt         1b                            \n"
+      : "+r"(src_argb),  // %0
+        "+r"(dst_ar64),  // %1
+        "+r"(width)      // %2
+      :
+      : "cc", "memory", "q0", "q1", "q2", "q3");
+}
+
+static const uvec8 kShuffleARGBToABGR = {2,  1, 0, 3,  6,  5,  4,  7,
+                                         10, 9, 8, 11, 14, 13, 12, 15};
+
+void ARGBToAB64Row_NEON(const uint8_t* src_argb,
+                        uint16_t* dst_ab64,
+                        int width) {
+  asm volatile(
+      "vld1.8      {q4}, [%3]                    \n"  // shuffler
+
+      "1:                                        \n"
+      "vld1.8      {q0}, [%0]!                   \n"
+      "vld1.8      {q2}, [%0]!                   \n"
+      "vtbl.8      d2, {d0, d1}, d8              \n"
+      "vtbl.8      d3, {d0, d1}, d9              \n"
+      "vtbl.8      d6, {d4, d5}, d8              \n"
+      "vtbl.8      d7, {d4, d5}, d9              \n"
+      "vmov.u8     q0, q1                        \n"
+      "vmov.u8     q2, q3                        \n"
+      "subs        %2, %2, #8                    \n"  // 8 processed per loop.
+      "vst2.8      {q0, q1}, [%1]!               \n"  // store 4 pixels
+      "vst2.8      {q2, q3}, [%1]!               \n"  // store 4 pixels
+      "bgt         1b                            \n"
+      : "+r"(src_argb),           // %0
+        "+r"(dst_ab64),           // %1
+        "+r"(width)               // %2
+      : "r"(&kShuffleARGBToABGR)  // %3
+      : "cc", "memory", "q0", "q1", "q2", "q3", "q4");
+}
+
+void AR64ToARGBRow_NEON(const uint16_t* src_ar64,
+                        uint8_t* dst_argb,
+                        int width) {
+  asm volatile(
+      "1:                                        \n"
+      "vld1.16     {q0}, [%0]!                   \n"
+      "vld1.16     {q1}, [%0]!                   \n"
+      "vld1.16     {q2}, [%0]!                   \n"
+      "vld1.16     {q3}, [%0]!                   \n"
+      "vshrn.u16   d0, q0, #8                    \n"
+      "vshrn.u16   d1, q1, #8                    \n"
+      "vshrn.u16   d4, q2, #8                    \n"
+      "vshrn.u16   d5, q3, #8                    \n"
+      "subs        %2, %2, #8                    \n"  // 8 processed per loop.
+      "vst1.8      {q0}, [%1]!                   \n"  // store 4 pixels
+      "vst1.8      {q2}, [%1]!                   \n"  // store 4 pixels
+      "bgt         1b                            \n"
+      : "+r"(src_ar64),  // %0
+        "+r"(dst_argb),  // %1
+        "+r"(width)      // %2
+      :
+      : "cc", "memory", "q0", "q1", "q2", "q3");
+}
+
+static const uvec8 kShuffleAB64ToARGB = {5, 3, 1, 7, 13, 11, 9, 15};
+
+void AB64ToARGBRow_NEON(const uint16_t* src_ab64,
+                        uint8_t* dst_argb,
+                        int width) {
+  asm volatile(
+      "vld1.8      {d8}, [%3]                    \n"  // shuffler
+
+      "1:                                        \n"
+      "vld1.16     {q0}, [%0]!                   \n"
+      "vld1.16     {q1}, [%0]!                   \n"
+      "vld1.16     {q2}, [%0]!                   \n"
+      "vld1.16     {q3}, [%0]!                   \n"
+      "vtbl.8      d0, {d0, d1}, d8              \n"
+      "vtbl.8      d1, {d2, d3}, d8              \n"
+      "vtbl.8      d4, {d4, d5}, d8              \n"
+      "vtbl.8      d5, {d6, d7}, d8              \n"
+      "subs        %2, %2, #8                    \n"  // 8 processed per loop.
+      "vst1.8      {q0}, [%1]!                   \n"  // store 4 pixels
+      "vst1.8      {q2}, [%1]!                   \n"  // store 4 pixels
+      "bgt         1b                            \n"
+      : "+r"(src_ab64),           // %0
+        "+r"(dst_argb),           // %1
+        "+r"(width)               // %2
+      : "r"(&kShuffleAB64ToARGB)  // %3
+      : "cc", "memory", "q0", "q1", "q2", "q3", "q4");
+}
+
+struct RgbConstants {
+  uint8_t kRGBToY[4];
+  uint16_t kAddY;
+  uint16_t pad;
+};
+
+// RGB to JPeg coefficients
+// B * 0.1140 coefficient = 29
+// G * 0.5870 coefficient = 150
+// R * 0.2990 coefficient = 77
+// Add 0.5 = 0x80
+static const struct RgbConstants kRgb24JPEGConstants = {{29, 150, 77, 0}, 128};
+
+static const struct RgbConstants kRawJPEGConstants = {{77, 150, 29, 0}, 128};
+
+// RGB to BT.601 coefficients
+// B * 0.1016 coefficient = 25
+// G * 0.5078 coefficient = 129
+// R * 0.2578 coefficient = 66
+// Add 16.5 = 0x1080
+
+static const struct RgbConstants kRgb24I601Constants = {{25, 129, 66, 0},
+                                                        0x1080};
+
+static const struct RgbConstants kRawI601Constants = {{66, 129, 25, 0}, 0x1080};
+
+// ARGB expects first 3 values to contain RGB and 4th value is ignored.
+void ARGBToYMatrixRow_NEON(const uint8_t* src_argb,
+                           uint8_t* dst_y,
+                           int width,
+                           const struct RgbConstants* rgbconstants) {
+  asm volatile(
+      "vld1.8      {d0}, [%3]                    \n"  // load rgbconstants
+      "vdup.u8     d20, d0[0]                    \n"
+      "vdup.u8     d21, d0[1]                    \n"
+      "vdup.u8     d22, d0[2]                    \n"
+      "vdup.u16    q12, d0[2]                    \n"
+      "1:                                        \n"
+      "vld4.8      {d0, d2, d4, d6}, [%0]!       \n"  // load 16 pixels of ARGB
+      "vld4.8      {d1, d3, d5, d7}, [%0]!       \n"
+      "subs        %2, %2, #16                   \n"  // 16 processed per loop.
+      "vmull.u8    q8, d0, d20                   \n"  // B
+      "vmull.u8    q9, d1, d20                   \n"
+      "vmlal.u8    q8, d2, d21                   \n"  // G
+      "vmlal.u8    q9, d3, d21                   \n"
+      "vmlal.u8    q8, d4, d22                   \n"  // R
+      "vmlal.u8    q9, d5, d22                   \n"
+      "vaddhn.u16  d0, q8, q12                   \n"  // 16 bit to 8 bit Y
+      "vaddhn.u16  d1, q9, q12                   \n"
+      "vst1.8      {d0, d1}, [%1]!               \n"  // store 16 pixels Y.
+      "bgt         1b                            \n"
+      : "+r"(src_argb),    // %0
+        "+r"(dst_y),       // %1
+        "+r"(width)        // %2
+      : "r"(rgbconstants)  // %3
+      : "cc", "memory", "q0", "q1", "q2", "q3", "q8", "q9", "d20", "d21", "d22",
+        "q12");
+}
+
+void ARGBToYRow_NEON(const uint8_t* src_argb, uint8_t* dst_y, int width) {
+  ARGBToYMatrixRow_NEON(src_argb, dst_y, width, &kRgb24I601Constants);
+}
+
+void ARGBToYJRow_NEON(const uint8_t* src_argb, uint8_t* dst_yj, int width) {
+  ARGBToYMatrixRow_NEON(src_argb, dst_yj, width, &kRgb24JPEGConstants);
+}
+
+void ABGRToYRow_NEON(const uint8_t* src_abgr, uint8_t* dst_y, int width) {
+  ARGBToYMatrixRow_NEON(src_abgr, dst_y, width, &kRawI601Constants);
+}
+
+// RGBA expects first value to be A and ignored, then 3 values to contain RGB.
+// Same code as ARGB, except the LD4
+void RGBAToYMatrixRow_NEON(const uint8_t* src_rgba,
+                           uint8_t* dst_y,
+                           int width,
+                           const struct RgbConstants* rgbconstants) {
+  asm volatile(
+      "vld1.8      {d0}, [%3]                    \n"  // load rgbconstants
+      "vdup.u8     d20, d0[0]                    \n"
+      "vdup.u8     d21, d0[1]                    \n"
+      "vdup.u8     d22, d0[2]                    \n"
+      "vdup.u16    q12, d0[2]                    \n"
+      "1:                                        \n"
+      "vld4.8      {d0, d2, d4, d6}, [%0]!       \n"  // load 16 pixels of RGBA
+      "vld4.8      {d1, d3, d5, d7}, [%0]!       \n"
+      "subs        %2, %2, #16                   \n"  // 16 processed per loop.
+      "vmull.u8    q8, d2, d20                   \n"  // B
+      "vmull.u8    q9, d3, d20                   \n"
+      "vmlal.u8    q8, d4, d21                   \n"  // G
+      "vmlal.u8    q9, d5, d21                   \n"
+      "vmlal.u8    q8, d6, d22                   \n"  // R
+      "vmlal.u8    q9, d7, d22                   \n"
+      "vaddhn.u16  d0, q8, q12                   \n"  // 16 bit to 8 bit Y
+      "vaddhn.u16  d1, q9, q12                   \n"
+      "vst1.8      {d0, d1}, [%1]!               \n"  // store 16 pixels Y.
+      "bgt         1b                            \n"
+      : "+r"(src_rgba),    // %0
+        "+r"(dst_y),       // %1
+        "+r"(width)        // %2
+      : "r"(rgbconstants)  // %3
+      : "cc", "memory", "q0", "q1", "q2", "q3", "q8", "q9", "d20", "d21", "d22",
+        "q12");
+}
+
+void RGBAToYRow_NEON(const uint8_t* src_rgba, uint8_t* dst_y, int width) {
+  RGBAToYMatrixRow_NEON(src_rgba, dst_y, width, &kRgb24I601Constants);
+}
+
+void RGBAToYJRow_NEON(const uint8_t* src_rgba, uint8_t* dst_yj, int width) {
+  RGBAToYMatrixRow_NEON(src_rgba, dst_yj, width, &kRgb24JPEGConstants);
+}
+
+void BGRAToYRow_NEON(const uint8_t* src_bgra, uint8_t* dst_y, int width) {
+  RGBAToYMatrixRow_NEON(src_bgra, dst_y, width, &kRawI601Constants);
+}
+
+void RGBToYMatrixRow_NEON(const uint8_t* src_rgb,
+                          uint8_t* dst_y,
+                          int width,
+                          const struct RgbConstants* rgbconstants) {
+  asm volatile(
+      "vld1.8      {d0}, [%3]                    \n"  // load rgbconstants
+      "vdup.u8     d20, d0[0]                    \n"
+      "vdup.u8     d21, d0[1]                    \n"
+      "vdup.u8     d22, d0[2]                    \n"
+      "vdup.u16    q12, d0[2]                    \n"
+      "1:                                        \n"
+      "vld3.8      {d2, d4, d6}, [%0]!           \n"  // load 16 pixels of
+                                                      // RGB24.
+      "vld3.8      {d3, d5, d7}, [%0]!           \n"
+      "subs        %2, %2, #16                   \n"  // 16 processed per loop.
+      "vmull.u8    q8, d2, d20                   \n"  // B
+      "vmull.u8    q9, d3, d20                   \n"
+      "vmlal.u8    q8, d4, d21                   \n"  // G
+      "vmlal.u8    q9, d5, d21                   \n"
+      "vmlal.u8    q8, d6, d22                   \n"  // R
+      "vmlal.u8    q9, d7, d22                   \n"
+      "vaddhn.u16  d0, q8, q12                   \n"  // 16 bit to 8 bit Y
+      "vaddhn.u16  d1, q9, q12                   \n"
+      "vst1.8      {d0, d1}, [%1]!               \n"  // store 16 pixels Y.
+      "bgt         1b                            \n"
+      : "+r"(src_rgb),     // %0
+        "+r"(dst_y),       // %1
+        "+r"(width)        // %2
+      : "r"(rgbconstants)  // %3
+      : "cc", "memory", "q0", "q1", "q2", "q3", "q8", "q9", "d20", "d21", "d22",
+        "q12");
+}
+
+void RGB24ToYJRow_NEON(const uint8_t* src_rgb24, uint8_t* dst_yj, int width) {
+  RGBToYMatrixRow_NEON(src_rgb24, dst_yj, width, &kRgb24JPEGConstants);
+}
+
+void RAWToYJRow_NEON(const uint8_t* src_raw, uint8_t* dst_yj, int width) {
+  RGBToYMatrixRow_NEON(src_raw, dst_yj, width, &kRawJPEGConstants);
+}
+
+void RGB24ToYRow_NEON(const uint8_t* src_rgb24, uint8_t* dst_y, int width) {
+  RGBToYMatrixRow_NEON(src_rgb24, dst_y, width, &kRgb24I601Constants);
+}
+
+void RAWToYRow_NEON(const uint8_t* src_raw, uint8_t* dst_y, int width) {
+  RGBToYMatrixRow_NEON(src_raw, dst_y, width, &kRawI601Constants);
+}
+
+// Bilinear filter 16x2 -> 16x1
+void InterpolateRow_NEON(uint8_t* dst_ptr,
+                         const uint8_t* src_ptr,
+                         ptrdiff_t src_stride,
+                         int dst_width,
+                         int source_y_fraction) {
+  int y1_fraction = source_y_fraction;
+  asm volatile(
+      "cmp         %4, #0                        \n"
+      "beq         100f                          \n"
+      "add         %2, %1                        \n"
+      "cmp         %4, #128                      \n"
+      "beq         50f                           \n"
+
+      "vdup.8      d5, %4                        \n"
+      "rsb         %4, #256                      \n"
+      "vdup.8      d4, %4                        \n"
+      // General purpose row blend.
+      "1:                                        \n"
+      "vld1.8      {q0}, [%1]!                   \n"
+      "vld1.8      {q1}, [%2]!                   \n"
+      "subs        %3, %3, #16                   \n"
+      "vmull.u8    q13, d0, d4                   \n"
+      "vmull.u8    q14, d1, d4                   \n"
+      "vmlal.u8    q13, d2, d5                   \n"
+      "vmlal.u8    q14, d3, d5                   \n"
+      "vrshrn.u16  d0, q13, #8                   \n"
+      "vrshrn.u16  d1, q14, #8                   \n"
+      "vst1.8      {q0}, [%0]!                   \n"
+      "bgt         1b                            \n"
+      "b           99f                           \n"
+
+      // Blend 50 / 50.
+      "50:                                       \n"
+      "vld1.8      {q0}, [%1]!                   \n"
+      "vld1.8      {q1}, [%2]!                   \n"
+      "subs        %3, %3, #16                   \n"
+      "vrhadd.u8   q0, q1                        \n"
+      "vst1.8      {q0}, [%0]!                   \n"
+      "bgt         50b                           \n"
+      "b           99f                           \n"
+
+      // Blend 100 / 0 - Copy row unchanged.
+      "100:                                      \n"
+      "vld1.8      {q0}, [%1]!                   \n"
+      "subs        %3, %3, #16                   \n"
+      "vst1.8      {q0}, [%0]!                   \n"
+      "bgt         100b                          \n"
+
+      "99:                                       \n"
+      : "+r"(dst_ptr),     // %0
+        "+r"(src_ptr),     // %1
+        "+r"(src_stride),  // %2
+        "+r"(dst_width),   // %3
+        "+r"(y1_fraction)  // %4
+      :
+      : "cc", "memory", "q0", "q1", "d4", "d5", "q13", "q14");
+}
+
+// Bilinear filter 8x2 -> 8x1
+void InterpolateRow_16_NEON(uint16_t* dst_ptr,
+                            const uint16_t* src_ptr,
+                            ptrdiff_t src_stride,
+                            int dst_width,
+                            int source_y_fraction) {
+  int y1_fraction = source_y_fraction;
+  int y0_fraction = 256 - y1_fraction;
+  const uint16_t* src_ptr1 = src_ptr + src_stride;
+
+  asm volatile(
+      "cmp         %4, #0                        \n"
+      "beq         100f                          \n"
+      "cmp         %4, #128                      \n"
+      "beq         50f                           \n"
+
+      "vdup.16     d17, %4                       \n"
+      "vdup.16     d16, %5                       \n"
+      // General purpose row blend.
+      "1:                                        \n"
+      "vld1.16     {q0}, [%1]!                   \n"
+      "vld1.16     {q1}, [%2]!                   \n"
+      "subs        %3, %3, #8                    \n"
+      "vmull.u16   q2, d0, d16                   \n"
+      "vmull.u16   q3, d1, d16                   \n"
+      "vmlal.u16   q2, d2, d17                   \n"
+      "vmlal.u16   q3, d3, d17                   \n"
+      "vrshrn.u32  d0, q2, #8                    \n"
+      "vrshrn.u32  d1, q3, #8                    \n"
+      "vst1.16     {q0}, [%0]!                   \n"
+      "bgt         1b                            \n"
+      "b           99f                           \n"
+
+      // Blend 50 / 50.
+      "50:                                       \n"
+      "vld1.16     {q0}, [%1]!                   \n"
+      "vld1.16     {q1}, [%2]!                   \n"
+      "subs        %3, %3, #8                    \n"
+      "vrhadd.u16  q0, q1                        \n"
+      "vst1.16     {q0}, [%0]!                   \n"
+      "bgt         50b                           \n"
+      "b           99f                           \n"
+
+      // Blend 100 / 0 - Copy row unchanged.
+      "100:                                      \n"
+      "vld1.16     {q0}, [%1]!                   \n"
+      "subs        %3, %3, #8                    \n"
+      "vst1.16     {q0}, [%0]!                   \n"
+      "bgt         100b                          \n"
+
+      "99:                                       \n"
+      : "+r"(dst_ptr),     // %0
+        "+r"(src_ptr),     // %1
+        "+r"(src_ptr1),    // %2
+        "+r"(dst_width)    // %3
+      : "r"(y1_fraction),  // %4
+        "r"(y0_fraction)   // %5
+      : "cc", "memory", "q0", "q1", "q2", "q3", "q8");
+}
+
+// dr * (256 - sa) / 256 + sr = dr - dr * sa / 256 + sr
+void ARGBBlendRow_NEON(const uint8_t* src_argb,
+                       const uint8_t* src_argb1,
+                       uint8_t* dst_argb,
+                       int width) {
+  asm volatile(
+      "subs        %3, #8                        \n"
+      "blt         89f                           \n"
+      // Blend 8 pixels.
+      "8:                                        \n"
+      "vld4.8      {d0, d1, d2, d3}, [%0]!       \n"  // load 8 pixels of ARGB0.
+      "vld4.8      {d4, d5, d6, d7}, [%1]!       \n"  // load 8 pixels of ARGB1.
+      "subs        %3, %3, #8                    \n"  // 8 processed per loop.
+      "vmull.u8    q10, d4, d3                   \n"  // db * a
+      "vmull.u8    q11, d5, d3                   \n"  // dg * a
+      "vmull.u8    q12, d6, d3                   \n"  // dr * a
+      "vqrshrn.u16 d20, q10, #8                  \n"  // db >>= 8
+      "vqrshrn.u16 d21, q11, #8                  \n"  // dg >>= 8
+      "vqrshrn.u16 d22, q12, #8                  \n"  // dr >>= 8
+      "vqsub.u8    q2, q2, q10                   \n"  // dbg - dbg * a / 256
+      "vqsub.u8    d6, d6, d22                   \n"  // dr - dr * a / 256
+      "vqadd.u8    q0, q0, q2                    \n"  // + sbg
+      "vqadd.u8    d2, d2, d6                    \n"  // + sr
+      "vmov.u8     d3, #255                      \n"  // a = 255
+      "vst4.8      {d0, d1, d2, d3}, [%2]!       \n"  // store 8 pixels of ARGB.
+      "bge         8b                            \n"
+
+      "89:                                       \n"
+      "adds        %3, #8-1                      \n"
+      "blt         99f                           \n"
+
+      // Blend 1 pixels.
+      "1:                                        \n"
+      "vld4.8      {d0[0],d1[0],d2[0],d3[0]}, [%0]! \n"  // load 1 pixel ARGB0.
+      "vld4.8      {d4[0],d5[0],d6[0],d7[0]}, [%1]! \n"  // load 1 pixel ARGB1.
+      "subs        %3, %3, #1                    \n"  // 1 processed per loop.
+      "vmull.u8    q10, d4, d3                   \n"  // db * a
+      "vmull.u8    q11, d5, d3                   \n"  // dg * a
+      "vmull.u8    q12, d6, d3                   \n"  // dr * a
+      "vqrshrn.u16 d20, q10, #8                  \n"  // db >>= 8
+      "vqrshrn.u16 d21, q11, #8                  \n"  // dg >>= 8
+      "vqrshrn.u16 d22, q12, #8                  \n"  // dr >>= 8
+      "vqsub.u8    q2, q2, q10                   \n"  // dbg - dbg * a / 256
+      "vqsub.u8    d6, d6, d22                   \n"  // dr - dr * a / 256
+      "vqadd.u8    q0, q0, q2                    \n"  // + sbg
+      "vqadd.u8    d2, d2, d6                    \n"  // + sr
+      "vmov.u8     d3, #255                      \n"  // a = 255
+      "vst4.8      {d0[0],d1[0],d2[0],d3[0]}, [%2]! \n"  // store 1 pixel.
+      "bge         1b                            \n"
+
+      "99:                                       \n"
+
+      : "+r"(src_argb),   // %0
+        "+r"(src_argb1),  // %1
+        "+r"(dst_argb),   // %2
+        "+r"(width)       // %3
+      :
+      : "cc", "memory", "q0", "q1", "q2", "q3", "q10", "q11", "q12");
+}
+
+// Attenuate 8 pixels at a time.
+void ARGBAttenuateRow_NEON(const uint8_t* src_argb,
+                           uint8_t* dst_argb,
+                           int width) {
+  asm volatile(
+      // Attenuate 8 pixels.
+      "1:                                        \n"
+      "vld4.8      {d0, d1, d2, d3}, [%0]!       \n"  // load 8 pixels of ARGB.
+      "subs        %2, %2, #8                    \n"  // 8 processed per loop.
+      "vmull.u8    q10, d0, d3                   \n"  // b * a
+      "vmull.u8    q11, d1, d3                   \n"  // g * a
+      "vmull.u8    q12, d2, d3                   \n"  // r * a
+      "vqrshrn.u16 d0, q10, #8                   \n"  // b >>= 8
+      "vqrshrn.u16 d1, q11, #8                   \n"  // g >>= 8
+      "vqrshrn.u16 d2, q12, #8                   \n"  // r >>= 8
+      "vst4.8      {d0, d1, d2, d3}, [%1]!       \n"  // store 8 pixels of ARGB.
+      "bgt         1b                            \n"
+      : "+r"(src_argb),  // %0
+        "+r"(dst_argb),  // %1
+        "+r"(width)      // %2
+      :
+      : "cc", "memory", "q0", "q1", "q10", "q11", "q12");
+}
+
+// Quantize 8 ARGB pixels (32 bytes).
+// dst = (dst * scale >> 16) * interval_size + interval_offset;
+void ARGBQuantizeRow_NEON(uint8_t* dst_argb,
+                          int scale,
+                          int interval_size,
+                          int interval_offset,
+                          int width) {
+  asm volatile(
+      "vdup.u16    q8, %2                        \n"
+      "vshr.u16    q8, q8, #1                    \n"  // scale >>= 1
+      "vdup.u16    q9, %3                        \n"  // interval multiply.
+      "vdup.u16    q10, %4                       \n"  // interval add
+
+      // 8 pixel loop.
+      "1:                                        \n"
+      "vld4.8      {d0, d2, d4, d6}, [%0]        \n"  // load 8 pixels of ARGB.
+      "subs        %1, %1, #8                    \n"  // 8 processed per loop.
+      "vmovl.u8    q0, d0                        \n"  // b (0 .. 255)
+      "vmovl.u8    q1, d2                        \n"
+      "vmovl.u8    q2, d4                        \n"
+      "vqdmulh.s16 q0, q0, q8                    \n"  // b * scale
+      "vqdmulh.s16 q1, q1, q8                    \n"  // g
+      "vqdmulh.s16 q2, q2, q8                    \n"  // r
+      "vmul.u16    q0, q0, q9                    \n"  // b * interval_size
+      "vmul.u16    q1, q1, q9                    \n"  // g
+      "vmul.u16    q2, q2, q9                    \n"  // r
+      "vadd.u16    q0, q0, q10                   \n"  // b + interval_offset
+      "vadd.u16    q1, q1, q10                   \n"  // g
+      "vadd.u16    q2, q2, q10                   \n"  // r
+      "vqmovn.u16  d0, q0                        \n"
+      "vqmovn.u16  d2, q1                        \n"
+      "vqmovn.u16  d4, q2                        \n"
+      "vst4.8      {d0, d2, d4, d6}, [%0]!       \n"  // store 8 pixels of ARGB.
+      "bgt         1b                            \n"
+      : "+r"(dst_argb),       // %0
+        "+r"(width)           // %1
+      : "r"(scale),           // %2
+        "r"(interval_size),   // %3
+        "r"(interval_offset)  // %4
+      : "cc", "memory", "q0", "q1", "q2", "q3", "q8", "q9", "q10");
+}
+
+// Shade 8 pixels at a time by specified value.
+// NOTE vqrdmulh.s16 q10, q10, d0[0] must use a scaler register from 0 to 8.
+// Rounding in vqrdmulh does +1 to high if high bit of low s16 is set.
+void ARGBShadeRow_NEON(const uint8_t* src_argb,
+                       uint8_t* dst_argb,
+                       int width,
+                       uint32_t value) {
+  asm volatile(
+      "vdup.u32    q0, %3                        \n"  // duplicate scale value.
+      "vzip.u8     d0, d1                        \n"  // d0 aarrggbb.
+      "vshr.u16    q0, q0, #1                    \n"  // scale / 2.
+
+      // 8 pixel loop.
+      "1:                                        \n"
+      "vld4.8      {d20, d22, d24, d26}, [%0]!   \n"  // load 8 pixels of ARGB.
+      "subs        %2, %2, #8                    \n"  // 8 processed per loop.
+      "vmovl.u8    q10, d20                      \n"  // b (0 .. 255)
+      "vmovl.u8    q11, d22                      \n"
+      "vmovl.u8    q12, d24                      \n"
+      "vmovl.u8    q13, d26                      \n"
+      "vqrdmulh.s16 q10, q10, d0[0]              \n"  // b * scale * 2
+      "vqrdmulh.s16 q11, q11, d0[1]              \n"  // g
+      "vqrdmulh.s16 q12, q12, d0[2]              \n"  // r
+      "vqrdmulh.s16 q13, q13, d0[3]              \n"  // a
+      "vqmovn.u16  d20, q10                      \n"
+      "vqmovn.u16  d22, q11                      \n"
+      "vqmovn.u16  d24, q12                      \n"
+      "vqmovn.u16  d26, q13                      \n"
+      "vst4.8      {d20, d22, d24, d26}, [%1]!   \n"  // store 8 pixels of ARGB.
+      "bgt         1b                            \n"
+      : "+r"(src_argb),  // %0
+        "+r"(dst_argb),  // %1
+        "+r"(width)      // %2
+      : "r"(value)       // %3
+      : "cc", "memory", "q0", "q10", "q11", "q12", "q13");
+}
+
+// Convert 8 ARGB pixels (64 bytes) to 8 Gray ARGB pixels
+// Similar to ARGBToYJ but stores ARGB.
+// C code is (29 * b + 150 * g + 77 * r + 128) >> 8;
+void ARGBGrayRow_NEON(const uint8_t* src_argb, uint8_t* dst_argb, int width) {
+  asm volatile(
+      "vmov.u8     d24, #29                      \n"  // B * 0.1140 coefficient
+      "vmov.u8     d25, #150                     \n"  // G * 0.5870 coefficient
+      "vmov.u8     d26, #77                      \n"  // R * 0.2990 coefficient
+      "1:                                        \n"
+      "vld4.8      {d0, d1, d2, d3}, [%0]!       \n"  // load 8 ARGB pixels.
+      "subs        %2, %2, #8                    \n"  // 8 processed per loop.
+      "vmull.u8    q2, d0, d24                   \n"  // B
+      "vmlal.u8    q2, d1, d25                   \n"  // G
+      "vmlal.u8    q2, d2, d26                   \n"  // R
+      "vqrshrn.u16 d0, q2, #8                    \n"  // 16 bit to 8 bit B
+      "vmov        d1, d0                        \n"  // G
+      "vmov        d2, d0                        \n"  // R
+      "vst4.8      {d0, d1, d2, d3}, [%1]!       \n"  // store 8 ARGB pixels.
+      "bgt         1b                            \n"
+      : "+r"(src_argb),  // %0
+        "+r"(dst_argb),  // %1
+        "+r"(width)      // %2
+      :
+      : "cc", "memory", "q0", "q1", "q2", "q12", "q13");
+}
+
+// Convert 8 ARGB pixels (32 bytes) to 8 Sepia ARGB pixels.
+//    b = (r * 35 + g * 68 + b * 17) >> 7
+//    g = (r * 45 + g * 88 + b * 22) >> 7
+//    r = (r * 50 + g * 98 + b * 24) >> 7
+void ARGBSepiaRow_NEON(uint8_t* dst_argb, int width) {
+  asm volatile(
+      "vmov.u8     d20, #17                      \n"  // BB coefficient
+      "vmov.u8     d21, #68                      \n"  // BG coefficient
+      "vmov.u8     d22, #35                      \n"  // BR coefficient
+      "vmov.u8     d24, #22                      \n"  // GB coefficient
+      "vmov.u8     d25, #88                      \n"  // GG coefficient
+      "vmov.u8     d26, #45                      \n"  // GR coefficient
+      "vmov.u8     d28, #24                      \n"  // BB coefficient
+      "vmov.u8     d29, #98                      \n"  // BG coefficient
+      "vmov.u8     d30, #50                      \n"  // BR coefficient
+      "1:                                        \n"
+      "vld4.8      {d0, d1, d2, d3}, [%0]        \n"  // load 8 ARGB pixels.
+      "subs        %1, %1, #8                    \n"  // 8 processed per loop.
+      "vmull.u8    q2, d0, d20                   \n"  // B to Sepia B
+      "vmlal.u8    q2, d1, d21                   \n"  // G
+      "vmlal.u8    q2, d2, d22                   \n"  // R
+      "vmull.u8    q3, d0, d24                   \n"  // B to Sepia G
+      "vmlal.u8    q3, d1, d25                   \n"  // G
+      "vmlal.u8    q3, d2, d26                   \n"  // R
+      "vmull.u8    q8, d0, d28                   \n"  // B to Sepia R
+      "vmlal.u8    q8, d1, d29                   \n"  // G
+      "vmlal.u8    q8, d2, d30                   \n"  // R
+      "vqshrn.u16  d0, q2, #7                    \n"  // 16 bit to 8 bit B
+      "vqshrn.u16  d1, q3, #7                    \n"  // 16 bit to 8 bit G
+      "vqshrn.u16  d2, q8, #7                    \n"  // 16 bit to 8 bit R
+      "vst4.8      {d0, d1, d2, d3}, [%0]!       \n"  // store 8 ARGB pixels.
+      "bgt         1b                            \n"
+      : "+r"(dst_argb),  // %0
+        "+r"(width)      // %1
+      :
+      : "cc", "memory", "q0", "q1", "q2", "q3", "q10", "q11", "q12", "q13",
+        "q14", "q15");
+}
+
+// Tranform 8 ARGB pixels (32 bytes) with color matrix.
+// TODO(fbarchard): Was same as Sepia except matrix is provided.  This function
+// needs to saturate.  Consider doing a non-saturating version.
+void ARGBColorMatrixRow_NEON(const uint8_t* src_argb,
+                             uint8_t* dst_argb,
+                             const int8_t* matrix_argb,
+                             int width) {
+  asm volatile(
+      "vld1.8      {q2}, [%3]                    \n"  // load 3 ARGB vectors.
+      "vmovl.s8    q0, d4                        \n"  // B,G coefficients s16.
+      "vmovl.s8    q1, d5                        \n"  // R,A coefficients s16.
+
+      "1:                                        \n"
+      "vld4.8      {d16, d18, d20, d22}, [%0]!   \n"  // load 8 ARGB pixels.
+      "subs        %2, %2, #8                    \n"  // 8 processed per loop.
+      "vmovl.u8    q8, d16                       \n"  // b (0 .. 255) 16 bit
+      "vmovl.u8    q9, d18                       \n"  // g
+      "vmovl.u8    q10, d20                      \n"  // r
+      "vmovl.u8    q11, d22                      \n"  // a
+      "vmul.s16    q12, q8, d0[0]                \n"  // B = B * Matrix B
+      "vmul.s16    q13, q8, d1[0]                \n"  // G = B * Matrix G
+      "vmul.s16    q14, q8, d2[0]                \n"  // R = B * Matrix R
+      "vmul.s16    q15, q8, d3[0]                \n"  // A = B * Matrix A
+      "vmul.s16    q4, q9, d0[1]                 \n"  // B += G * Matrix B
+      "vmul.s16    q5, q9, d1[1]                 \n"  // G += G * Matrix G
+      "vmul.s16    q6, q9, d2[1]                 \n"  // R += G * Matrix R
+      "vmul.s16    q7, q9, d3[1]                 \n"  // A += G * Matrix A
+      "vqadd.s16   q12, q12, q4                  \n"  // Accumulate B
+      "vqadd.s16   q13, q13, q5                  \n"  // Accumulate G
+      "vqadd.s16   q14, q14, q6                  \n"  // Accumulate R
+      "vqadd.s16   q15, q15, q7                  \n"  // Accumulate A
+      "vmul.s16    q4, q10, d0[2]                \n"  // B += R * Matrix B
+      "vmul.s16    q5, q10, d1[2]                \n"  // G += R * Matrix G
+      "vmul.s16    q6, q10, d2[2]                \n"  // R += R * Matrix R
+      "vmul.s16    q7, q10, d3[2]                \n"  // A += R * Matrix A
+      "vqadd.s16   q12, q12, q4                  \n"  // Accumulate B
+      "vqadd.s16   q13, q13, q5                  \n"  // Accumulate G
+      "vqadd.s16   q14, q14, q6                  \n"  // Accumulate R
+      "vqadd.s16   q15, q15, q7                  \n"  // Accumulate A
+      "vmul.s16    q4, q11, d0[3]                \n"  // B += A * Matrix B
+      "vmul.s16    q5, q11, d1[3]                \n"  // G += A * Matrix G
+      "vmul.s16    q6, q11, d2[3]                \n"  // R += A * Matrix R
+      "vmul.s16    q7, q11, d3[3]                \n"  // A += A * Matrix A
+      "vqadd.s16   q12, q12, q4                  \n"  // Accumulate B
+      "vqadd.s16   q13, q13, q5                  \n"  // Accumulate G
+      "vqadd.s16   q14, q14, q6                  \n"  // Accumulate R
+      "vqadd.s16   q15, q15, q7                  \n"  // Accumulate A
+      "vqshrun.s16 d16, q12, #6                  \n"  // 16 bit to 8 bit B
+      "vqshrun.s16 d18, q13, #6                  \n"  // 16 bit to 8 bit G
+      "vqshrun.s16 d20, q14, #6                  \n"  // 16 bit to 8 bit R
+      "vqshrun.s16 d22, q15, #6                  \n"  // 16 bit to 8 bit A
+      "vst4.8      {d16, d18, d20, d22}, [%1]!   \n"  // store 8 ARGB pixels.
+      "bgt         1b                            \n"
+      : "+r"(src_argb),   // %0
+        "+r"(dst_argb),   // %1
+        "+r"(width)       // %2
+      : "r"(matrix_argb)  // %3
+      : "cc", "memory", "q0", "q1", "q2", "q4", "q5", "q6", "q7", "q8", "q9",
+        "q10", "q11", "q12", "q13", "q14", "q15");
+}
+
+// Multiply 2 rows of ARGB pixels together, 8 pixels at a time.
+void ARGBMultiplyRow_NEON(const uint8_t* src_argb,
+                          const uint8_t* src_argb1,
+                          uint8_t* dst_argb,
+                          int width) {
+  asm volatile(
+      // 8 pixel loop.
+      "1:                                        \n"
+      "vld4.8      {d0, d2, d4, d6}, [%0]!       \n"  // load 8 ARGB pixels.
+      "vld4.8      {d1, d3, d5, d7}, [%1]!       \n"  // load 8 more ARGB
+      "subs        %3, %3, #8                    \n"  // 8 processed per loop.
+      "vmull.u8    q0, d0, d1                    \n"  // multiply B
+      "vmull.u8    q1, d2, d3                    \n"  // multiply G
+      "vmull.u8    q2, d4, d5                    \n"  // multiply R
+      "vmull.u8    q3, d6, d7                    \n"  // multiply A
+      "vrshrn.u16  d0, q0, #8                    \n"  // 16 bit to 8 bit B
+      "vrshrn.u16  d1, q1, #8                    \n"  // 16 bit to 8 bit G
+      "vrshrn.u16  d2, q2, #8                    \n"  // 16 bit to 8 bit R
+      "vrshrn.u16  d3, q3, #8                    \n"  // 16 bit to 8 bit A
+      "vst4.8      {d0, d1, d2, d3}, [%2]!       \n"  // store 8 ARGB pixels.
+      "bgt         1b                            \n"
+      : "+r"(src_argb),   // %0
+        "+r"(src_argb1),  // %1
+        "+r"(dst_argb),   // %2
+        "+r"(width)       // %3
+      :
+      : "cc", "memory", "q0", "q1", "q2", "q3");
+}
+
+// Add 2 rows of ARGB pixels together, 8 pixels at a time.
+void ARGBAddRow_NEON(const uint8_t* src_argb,
+                     const uint8_t* src_argb1,
+                     uint8_t* dst_argb,
+                     int width) {
+  asm volatile(
+      // 8 pixel loop.
+      "1:                                        \n"
+      "vld4.8      {d0, d1, d2, d3}, [%0]!       \n"  // load 8 ARGB pixels.
+      "vld4.8      {d4, d5, d6, d7}, [%1]!       \n"  // load 8 more ARGB
+      "subs        %3, %3, #8                    \n"  // 8 processed per loop.
+      "vqadd.u8    q0, q0, q2                    \n"  // add B, G
+      "vqadd.u8    q1, q1, q3                    \n"  // add R, A
+      "vst4.8      {d0, d1, d2, d3}, [%2]!       \n"  // store 8 ARGB pixels.
+      "bgt         1b                            \n"
+      : "+r"(src_argb),   // %0
+        "+r"(src_argb1),  // %1
+        "+r"(dst_argb),   // %2
+        "+r"(width)       // %3
+      :
+      : "cc", "memory", "q0", "q1", "q2", "q3");
+}
+
+// Subtract 2 rows of ARGB pixels, 8 pixels at a time.
+void ARGBSubtractRow_NEON(const uint8_t* src_argb,
+                          const uint8_t* src_argb1,
+                          uint8_t* dst_argb,
+                          int width) {
+  asm volatile(
+      // 8 pixel loop.
+      "1:                                        \n"
+      "vld4.8      {d0, d1, d2, d3}, [%0]!       \n"  // load 8 ARGB pixels.
+      "vld4.8      {d4, d5, d6, d7}, [%1]!       \n"  // load 8 more ARGB
+      "subs        %3, %3, #8                    \n"  // 8 processed per loop.
+      "vqsub.u8    q0, q0, q2                    \n"  // subtract B, G
+      "vqsub.u8    q1, q1, q3                    \n"  // subtract R, A
+      "vst4.8      {d0, d1, d2, d3}, [%2]!       \n"  // store 8 ARGB pixels.
+      "bgt         1b                            \n"
+      : "+r"(src_argb),   // %0
+        "+r"(src_argb1),  // %1
+        "+r"(dst_argb),   // %2
+        "+r"(width)       // %3
+      :
+      : "cc", "memory", "q0", "q1", "q2", "q3");
+}
+
+// Adds Sobel X and Sobel Y and stores Sobel into ARGB.
+// A = 255
+// R = Sobel
+// G = Sobel
+// B = Sobel
+void SobelRow_NEON(const uint8_t* src_sobelx,
+                   const uint8_t* src_sobely,
+                   uint8_t* dst_argb,
+                   int width) {
+  asm volatile(
+      "vmov.u8     d3, #255                      \n"  // alpha
+      // 8 pixel loop.
+      "1:                                        \n"
+      "vld1.8      {d0}, [%0]!                   \n"  // load 8 sobelx.
+      "vld1.8      {d1}, [%1]!                   \n"  // load 8 sobely.
+      "subs        %3, %3, #8                    \n"  // 8 processed per loop.
+      "vqadd.u8    d0, d0, d1                    \n"  // add
+      "vmov.u8     d1, d0                        \n"
+      "vmov.u8     d2, d0                        \n"
+      "vst4.8      {d0, d1, d2, d3}, [%2]!       \n"  // store 8 ARGB pixels.
+      "bgt         1b                            \n"
+      : "+r"(src_sobelx),  // %0
+        "+r"(src_sobely),  // %1
+        "+r"(dst_argb),    // %2
+        "+r"(width)        // %3
+      :
+      : "cc", "memory", "q0", "q1");
+}
+
+// Adds Sobel X and Sobel Y and stores Sobel into plane.
+void SobelToPlaneRow_NEON(const uint8_t* src_sobelx,
+                          const uint8_t* src_sobely,
+                          uint8_t* dst_y,
+                          int width) {
+  asm volatile(
+      // 16 pixel loop.
+      "1:                                        \n"
+      "vld1.8      {q0}, [%0]!                   \n"  // load 16 sobelx.
+      "vld1.8      {q1}, [%1]!                   \n"  // load 16 sobely.
+      "subs        %3, %3, #16                   \n"  // 16 processed per loop.
+      "vqadd.u8    q0, q0, q1                    \n"  // add
+      "vst1.8      {q0}, [%2]!                   \n"  // store 16 pixels.
+      "bgt         1b                            \n"
+      : "+r"(src_sobelx),  // %0
+        "+r"(src_sobely),  // %1
+        "+r"(dst_y),       // %2
+        "+r"(width)        // %3
+      :
+      : "cc", "memory", "q0", "q1");
+}
+
+// Mixes Sobel X, Sobel Y and Sobel into ARGB.
+// A = 255
+// R = Sobel X
+// G = Sobel
+// B = Sobel Y
+void SobelXYRow_NEON(const uint8_t* src_sobelx,
+                     const uint8_t* src_sobely,
+                     uint8_t* dst_argb,
+                     int width) {
+  asm volatile(
+      "vmov.u8     d3, #255                      \n"  // alpha
+      // 8 pixel loop.
+      "1:                                        \n"
+      "vld1.8      {d2}, [%0]!                   \n"  // load 8 sobelx.
+      "vld1.8      {d0}, [%1]!                   \n"  // load 8 sobely.
+      "subs        %3, %3, #8                    \n"  // 8 processed per loop.
+      "vqadd.u8    d1, d0, d2                    \n"  // add
+      "vst4.8      {d0, d1, d2, d3}, [%2]!       \n"  // store 8 ARGB pixels.
+      "bgt         1b                            \n"
+      : "+r"(src_sobelx),  // %0
+        "+r"(src_sobely),  // %1
+        "+r"(dst_argb),    // %2
+        "+r"(width)        // %3
+      :
+      : "cc", "memory", "q0", "q1");
+}
+
+// SobelX as a matrix is
+// -1  0  1
+// -2  0  2
+// -1  0  1
+void SobelXRow_NEON(const uint8_t* src_y0,
+                    const uint8_t* src_y1,
+                    const uint8_t* src_y2,
+                    uint8_t* dst_sobelx,
+                    int width) {
+  asm volatile(
+      "1:                                        \n"
+      "vld1.8      {d0}, [%0],%5                 \n"  // top
+      "vld1.8      {d1}, [%0],%6                 \n"
+      "vsubl.u8    q0, d0, d1                    \n"
+      "vld1.8      {d2}, [%1],%5                 \n"  // center * 2
+      "vld1.8      {d3}, [%1],%6                 \n"
+      "vsubl.u8    q1, d2, d3                    \n"
+      "vadd.s16    q0, q0, q1                    \n"
+      "vadd.s16    q0, q0, q1                    \n"
+      "vld1.8      {d2}, [%2],%5                 \n"  // bottom
+      "vld1.8      {d3}, [%2],%6                 \n"
+      "subs        %4, %4, #8                    \n"  // 8 pixels
+      "vsubl.u8    q1, d2, d3                    \n"
+      "vadd.s16    q0, q0, q1                    \n"
+      "vabs.s16    q0, q0                        \n"
+      "vqmovn.u16  d0, q0                        \n"
+      "vst1.8      {d0}, [%3]!                   \n"  // store 8 sobelx
+      "bgt         1b                            \n"
+      : "+r"(src_y0),               // %0
+        "+r"(src_y1),               // %1
+        "+r"(src_y2),               // %2
+        "+r"(dst_sobelx),           // %3
+        "+r"(width)                 // %4
+      : "r"(2),                     // %5
+        "r"(6)                      // %6
+      : "cc", "memory", "q0", "q1"  // Clobber List
+  );
+}
+
+// SobelY as a matrix is
+// -1 -2 -1
+//  0  0  0
+//  1  2  1
+void SobelYRow_NEON(const uint8_t* src_y0,
+                    const uint8_t* src_y1,
+                    uint8_t* dst_sobely,
+                    int width) {
+  asm volatile(
+      "1:                                        \n"
+      "vld1.8      {d0}, [%0],%4                 \n"  // left
+      "vld1.8      {d1}, [%1],%4                 \n"
+      "vsubl.u8    q0, d0, d1                    \n"
+      "vld1.8      {d2}, [%0],%4                 \n"  // center * 2
+      "vld1.8      {d3}, [%1],%4                 \n"
+      "vsubl.u8    q1, d2, d3                    \n"
+      "vadd.s16    q0, q0, q1                    \n"
+      "vadd.s16    q0, q0, q1                    \n"
+      "vld1.8      {d2}, [%0],%5                 \n"  // right
+      "vld1.8      {d3}, [%1],%5                 \n"
+      "subs        %3, %3, #8                    \n"  // 8 pixels
+      "vsubl.u8    q1, d2, d3                    \n"
+      "vadd.s16    q0, q0, q1                    \n"
+      "vabs.s16    q0, q0                        \n"
+      "vqmovn.u16  d0, q0                        \n"
+      "vst1.8      {d0}, [%2]!                   \n"  // store 8 sobely
+      "bgt         1b                            \n"
+      : "+r"(src_y0),               // %0
+        "+r"(src_y1),               // %1
+        "+r"(dst_sobely),           // %2
+        "+r"(width)                 // %3
+      : "r"(1),                     // %4
+        "r"(6)                      // %5
+      : "cc", "memory", "q0", "q1"  // Clobber List
+  );
+}
+
+// %y passes a float as a scalar vector for vector * scalar multiply.
+// the regoster must be d0 to d15 and indexed with [0] or [1] to access
+// the float in the first or second float of the d-reg
+
+void HalfFloat1Row_NEON(const uint16_t* src,
+                        uint16_t* dst,
+                        float /*unused*/,
+                        int width) {
+  asm volatile(
+
+      "1:                                        \n"
+      "vld1.8      {q1}, [%0]!                   \n"  // load 8 shorts
+      "subs        %2, %2, #8                    \n"  // 8 pixels per loop
+      "vmovl.u16   q2, d2                        \n"  // 8 int's
+      "vmovl.u16   q3, d3                        \n"
+      "vcvt.f32.u32 q2, q2                       \n"  // 8 floats
+      "vcvt.f32.u32 q3, q3                       \n"
+      "vmul.f32    q2, q2, %y3                   \n"  // adjust exponent
+      "vmul.f32    q3, q3, %y3                   \n"
+      "vqshrn.u32  d2, q2, #13                   \n"  // isolate halffloat
+      "vqshrn.u32  d3, q3, #13                   \n"
+      "vst1.8      {q1}, [%1]!                   \n"
+      "bgt         1b                            \n"
+      : "+r"(src),              // %0
+        "+r"(dst),              // %1
+        "+r"(width)             // %2
+      : "w"(1.9259299444e-34f)  // %3
+      : "cc", "memory", "q1", "q2", "q3");
+}
+
+void HalfFloatRow_NEON(const uint16_t* src,
+                       uint16_t* dst,
+                       float scale,
+                       int width) {
+  asm volatile(
+
+      "1:                                        \n"
+      "vld1.8      {q1}, [%0]!                   \n"  // load 8 shorts
+      "subs        %2, %2, #8                    \n"  // 8 pixels per loop
+      "vmovl.u16   q2, d2                        \n"  // 8 int's
+      "vmovl.u16   q3, d3                        \n"
+      "vcvt.f32.u32 q2, q2                       \n"  // 8 floats
+      "vcvt.f32.u32 q3, q3                       \n"
+      "vmul.f32    q2, q2, %y3                   \n"  // adjust exponent
+      "vmul.f32    q3, q3, %y3                   \n"
+      "vqshrn.u32  d2, q2, #13                   \n"  // isolate halffloat
+      "vqshrn.u32  d3, q3, #13                   \n"
+      "vst1.8      {q1}, [%1]!                   \n"
+      "bgt         1b                            \n"
+      : "+r"(src),                      // %0
+        "+r"(dst),                      // %1
+        "+r"(width)                     // %2
+      : "w"(scale * 1.9259299444e-34f)  // %3
+      : "cc", "memory", "q1", "q2", "q3");
+}
+
+void ByteToFloatRow_NEON(const uint8_t* src,
+                         float* dst,
+                         float scale,
+                         int width) {
+  asm volatile(
+
+      "1:                                        \n"
+      "vld1.8      {d2}, [%0]!                   \n"  // load 8 bytes
+      "subs        %2, %2, #8                    \n"  // 8 pixels per loop
+      "vmovl.u8    q1, d2                        \n"  // 8 shorts
+      "vmovl.u16   q2, d2                        \n"  // 8 ints
+      "vmovl.u16   q3, d3                        \n"
+      "vcvt.f32.u32 q2, q2                       \n"  // 8 floats
+      "vcvt.f32.u32 q3, q3                       \n"
+      "vmul.f32    q2, q2, %y3                   \n"  // scale
+      "vmul.f32    q3, q3, %y3                   \n"
+      "vst1.8      {q2, q3}, [%1]!               \n"  // store 8 floats
+      "bgt         1b                            \n"
+      : "+r"(src),   // %0
+        "+r"(dst),   // %1
+        "+r"(width)  // %2
+      : "w"(scale)   // %3
+      : "cc", "memory", "q1", "q2", "q3");
+}
+
+// filter 5 rows with 1, 4, 6, 4, 1 coefficients to produce 1 row.
+void GaussCol_NEON(const uint16_t* src0,
+                   const uint16_t* src1,
+                   const uint16_t* src2,
+                   const uint16_t* src3,
+                   const uint16_t* src4,
+                   uint32_t* dst,
+                   int width) {
+  asm volatile(
+      "vmov.u16    d6, #4                        \n"  // constant 4
+      "vmov.u16    d7, #6                        \n"  // constant 6
+
+      "1:                                        \n"
+      "vld1.16     {q1}, [%0]!                   \n"  // load 8 samples, 5 rows
+      "vld1.16     {q2}, [%4]!                   \n"
+      "vaddl.u16   q0, d2, d4                    \n"  // * 1
+      "vaddl.u16   q1, d3, d5                    \n"  // * 1
+      "vld1.16     {q2}, [%1]!                   \n"
+      "vmlal.u16   q0, d4, d6                    \n"  // * 4
+      "vmlal.u16   q1, d5, d6                    \n"  // * 4
+      "vld1.16     {q2}, [%2]!                   \n"
+      "vmlal.u16   q0, d4, d7                    \n"  // * 6
+      "vmlal.u16   q1, d5, d7                    \n"  // * 6
+      "vld1.16     {q2}, [%3]!                   \n"
+      "vmlal.u16   q0, d4, d6                    \n"  // * 4
+      "vmlal.u16   q1, d5, d6                    \n"  // * 4
+      "subs        %6, %6, #8                    \n"  // 8 processed per loop
+      "vst1.32     {q0, q1}, [%5]!               \n"  // store 8 samples
+      "bgt         1b                            \n"
+      : "+r"(src0),  // %0
+        "+r"(src1),  // %1
+        "+r"(src2),  // %2
+        "+r"(src3),  // %3
+        "+r"(src4),  // %4
+        "+r"(dst),   // %5
+        "+r"(width)  // %6
+      :
+      : "cc", "memory", "q0", "q1", "q2", "q3");
+}
+
+// filter 5 rows with 1, 4, 6, 4, 1 coefficients to produce 1 row.
+void GaussRow_NEON(const uint32_t* src, uint16_t* dst, int width) {
+  const uint32_t* src1 = src + 1;
+  const uint32_t* src2 = src + 2;
+  const uint32_t* src3 = src + 3;
+  asm volatile(
+      "vmov.u32    q10, #4                       \n"  // constant 4
+      "vmov.u32    q11, #6                       \n"  // constant 6
+
+      "1:                                        \n"
+      "vld1.32     {q0, q1}, [%0]!               \n"  // load 12 source samples
+      "vld1.32     {q2}, [%0]                    \n"
+      "vadd.u32    q0, q0, q1                    \n"  // * 1
+      "vadd.u32    q1, q1, q2                    \n"  // * 1
+      "vld1.32     {q2, q3}, [%2]!               \n"
+      "vmla.u32    q0, q2, q11                   \n"  // * 6
+      "vmla.u32    q1, q3, q11                   \n"  // * 6
+      "vld1.32     {q2, q3}, [%1]!               \n"
+      "vld1.32     {q8, q9}, [%3]!               \n"
+      "vadd.u32    q2, q2, q8                    \n"  // add rows for * 4
+      "vadd.u32    q3, q3, q9                    \n"
+      "vmla.u32    q0, q2, q10                   \n"  // * 4
+      "vmla.u32    q1, q3, q10                   \n"  // * 4
+      "subs        %5, %5, #8                    \n"  // 8 processed per loop
+      "vqshrn.u32  d0, q0, #8                    \n"  // round and pack
+      "vqshrn.u32  d1, q1, #8                    \n"
+      "vst1.u16    {q0}, [%4]!                   \n"  // store 8 samples
+      "bgt         1b                            \n"
+      : "+r"(src),   // %0
+        "+r"(src1),  // %1
+        "+r"(src2),  // %2
+        "+r"(src3),  // %3
+        "+r"(dst),   // %4
+        "+r"(width)  // %5
+      :
+      : "cc", "memory", "q0", "q1", "q2", "q3", "q8", "q9", "q10", "q11");
+}
+
+// Convert biplanar NV21 to packed YUV24
+void NV21ToYUV24Row_NEON(const uint8_t* src_y,
+                         const uint8_t* src_vu,
+                         uint8_t* dst_yuv24,
+                         int width) {
+  asm volatile(
+      "1:                                        \n"
+      "vld1.8      {q2}, [%0]!                   \n"  // load 16 Y values
+      "vld2.8      {d0, d2}, [%1]!               \n"  // load 8 VU values
+      "vmov        d1, d0                        \n"
+      "vzip.u8     d0, d1                        \n"  // VV
+      "vmov        d3, d2                        \n"
+      "vzip.u8     d2, d3                        \n"  // UU
+      "subs        %3, %3, #16                   \n"  // 16 pixels per loop
+      "vst3.8      {d0, d2, d4}, [%2]!           \n"  // store 16 YUV pixels
+      "vst3.8      {d1, d3, d5}, [%2]!           \n"
+      "bgt         1b                            \n"
+      : "+r"(src_y),      // %0
+        "+r"(src_vu),     // %1
+        "+r"(dst_yuv24),  // %2
+        "+r"(width)       // %3
+      :
+      : "cc", "memory", "q0", "q1", "q2");
+}
+
+void AYUVToUVRow_NEON(const uint8_t* src_ayuv,
+                      int src_stride_ayuv,
+                      uint8_t* dst_uv,
+                      int width) {
+  asm volatile(
+      "add         %1, %0, %1                    \n"  // src_stride + src_AYUV
+      "1:                                        \n"
+      "vld4.8      {d0, d2, d4, d6}, [%0]!       \n"  // load 8 AYUV pixels.
+      "vld4.8      {d1, d3, d5, d7}, [%0]!       \n"  // load next 8 AYUV
+                                                      // pixels.
+      "vpaddl.u8   q0, q0                        \n"  // V 16 bytes -> 8 shorts.
+      "vpaddl.u8   q1, q1                        \n"  // U 16 bytes -> 8 shorts.
+      "vld4.8      {d8, d10, d12, d14}, [%1]!    \n"  // load 8 more AYUV
+                                                      // pixels.
+      "vld4.8      {d9, d11, d13, d15}, [%1]!    \n"  // load last 8 AYUV
+                                                      // pixels.
+      "vpadal.u8   q0, q4                        \n"  // B 16 bytes -> 8 shorts.
+      "vpadal.u8   q1, q5                        \n"  // G 16 bytes -> 8 shorts.
+      "vqrshrun.s16 d1, q0, #2                   \n"  // 2x2 average
+      "vqrshrun.s16 d0, q1, #2                   \n"
+      "subs        %3, %3, #16                   \n"  // 16 processed per loop.
+      "vst2.8      {d0, d1}, [%2]!               \n"  // store 8 pixels UV.
+      "bgt         1b                            \n"
+      : "+r"(src_ayuv),         // %0
+        "+r"(src_stride_ayuv),  // %1
+        "+r"(dst_uv),           // %2
+        "+r"(width)             // %3
+      :
+      : "cc", "memory", "q0", "q1", "q2", "q3", "q4", "q5", "q6", "q7");
+}
+
+void AYUVToVURow_NEON(const uint8_t* src_ayuv,
+                      int src_stride_ayuv,
+                      uint8_t* dst_vu,
+                      int width) {
+  asm volatile(
+      "add         %1, %0, %1                    \n"  // src_stride + src_AYUV
+      "1:                                        \n"
+      "vld4.8      {d0, d2, d4, d6}, [%0]!       \n"  // load 8 AYUV pixels.
+      "vld4.8      {d1, d3, d5, d7}, [%0]!       \n"  // load next 8 AYUV
+                                                      // pixels.
+      "vpaddl.u8   q0, q0                        \n"  // V 16 bytes -> 8 shorts.
+      "vpaddl.u8   q1, q1                        \n"  // U 16 bytes -> 8 shorts.
+      "vld4.8      {d8, d10, d12, d14}, [%1]!    \n"  // load 8 more AYUV
+                                                      // pixels.
+      "vld4.8      {d9, d11, d13, d15}, [%1]!    \n"  // load last 8 AYUV
+                                                      // pixels.
+      "vpadal.u8   q0, q4                        \n"  // B 16 bytes -> 8 shorts.
+      "vpadal.u8   q1, q5                        \n"  // G 16 bytes -> 8 shorts.
+      "vqrshrun.s16 d0, q0, #2                   \n"  // 2x2 average
+      "vqrshrun.s16 d1, q1, #2                   \n"
+      "subs        %3, %3, #16                   \n"  // 16 processed per loop.
+      "vst2.8      {d0, d1}, [%2]!               \n"  // store 8 pixels VU.
+      "bgt         1b                            \n"
+      : "+r"(src_ayuv),         // %0
+        "+r"(src_stride_ayuv),  // %1
+        "+r"(dst_vu),           // %2
+        "+r"(width)             // %3
+      :
+      : "cc", "memory", "q0", "q1", "q2", "q3", "q4", "q5", "q6", "q7");
+}
+
+// Copy row of AYUV Y's into Y.
+// Similar to ARGBExtractAlphaRow_NEON
+void AYUVToYRow_NEON(const uint8_t* src_ayuv, uint8_t* dst_y, int width) {
+  asm volatile(
+      "1:                                        \n"
+      "vld4.8      {d0, d2, d4, d6}, [%0]!       \n"  // load 8 AYUV pixels
+      "vld4.8      {d1, d3, d5, d7}, [%0]!       \n"  // load next 8 AYUV pixels
+      "subs        %2, %2, #16                   \n"  // 16 processed per loop
+      "vst1.8      {q2}, [%1]!                   \n"  // store 16 Y's.
+      "bgt         1b                            \n"
+      : "+r"(src_ayuv),  // %0
+        "+r"(dst_y),     // %1
+        "+r"(width)      // %2
+      :
+      : "cc", "memory", "q0", "q1", "q2", "q3");
+}
+
+// Convert UV plane of NV12 to VU of NV21.
+void SwapUVRow_NEON(const uint8_t* src_uv, uint8_t* dst_vu, int width) {
+  asm volatile(
+      "1:                                        \n"
+      "vld2.8      {d0, d2}, [%0]!               \n"  // load 16 UV values
+      "vld2.8      {d1, d3}, [%0]!               \n"
+      "vorr.u8     q2, q0, q0                    \n"  // move U after V
+      "subs        %2, %2, #16                   \n"  // 16 pixels per loop
+      "vst2.8      {q1, q2}, [%1]!               \n"  // store 16 VU pixels
+      "bgt         1b                            \n"
+      : "+r"(src_uv),  // %0
+        "+r"(dst_vu),  // %1
+        "+r"(width)    // %2
+      :
+      : "cc", "memory", "q0", "q1", "q2");
+}
+
+void HalfMergeUVRow_NEON(const uint8_t* src_u,
+                         int src_stride_u,
+                         const uint8_t* src_v,
+                         int src_stride_v,
+                         uint8_t* dst_uv,
+                         int width) {
+  const uint8_t* src_u_1 = src_u + src_stride_u;
+  const uint8_t* src_v_1 = src_v + src_stride_v;
+  asm volatile(
+      "1:                                        \n"
+      "vld1.8      {q0}, [%0]!                   \n"  // load 16 U values
+      "vld1.8      {q1}, [%2]!                   \n"  // load 16 V values
+      "vld1.8      {q2}, [%1]!                   \n"
+      "vld1.8      {q3}, [%3]!                   \n"
+      "vpaddl.u8   q0, q0                        \n"  // half size
+      "vpaddl.u8   q1, q1                        \n"
+      "vpadal.u8   q0, q2                        \n"
+      "vpadal.u8   q1, q3                        \n"
+      "vqrshrn.u16 d0, q0, #2                    \n"
+      "vqrshrn.u16 d1, q1, #2                    \n"
+      "subs        %5, %5, #16                   \n"  // 16 src pixels per loop
+      "vst2.8      {d0, d1}, [%4]!               \n"  // store 8 UV pixels
+      "bgt         1b                            \n"
+      : "+r"(src_u),    // %0
+        "+r"(src_u_1),  // %1
+        "+r"(src_v),    // %2
+        "+r"(src_v_1),  // %3
+        "+r"(dst_uv),   // %4
+        "+r"(width)     // %5
+      :
+      : "cc", "memory", "q0", "q1", "q2", "q3");
+}
+
+void SplitUVRow_16_NEON(const uint16_t* src_uv,
+                        uint16_t* dst_u,
+                        uint16_t* dst_v,
+                        int depth,
+                        int width) {
+  int shift = depth - 16;  // Negative for right shift.
+  asm volatile(
+      "vdup.16     q2, %4                        \n"
+      "1:                                        \n"
+      "vld2.16     {q0, q1}, [%0]!               \n"  // load 8 UV
+      "vshl.u16    q0, q0, q2                    \n"
+      "vshl.u16    q1, q1, q2                    \n"
+      "subs        %3, %3, #8                    \n"  // 8 src pixels per loop
+      "vst1.16     {q0}, [%1]!                   \n"  // store 8 U pixels
+      "vst1.16     {q1}, [%2]!                   \n"  // store 8 V pixels
+      "bgt         1b                            \n"
+      : "+r"(src_uv),  // %0
+        "+r"(dst_u),   // %1
+        "+r"(dst_v),   // %2
+        "+r"(width)    // %3
+      : "r"(shift)     // %4
+      : "cc", "memory", "q0", "q1", "q2", "q3", "q4");
+}
+
+void MergeUVRow_16_NEON(const uint16_t* src_u,
+                        const uint16_t* src_v,
+                        uint16_t* dst_uv,
+                        int depth,
+                        int width) {
+  int shift = 16 - depth;
+  asm volatile(
+      "vdup.16     q2, %4                        \n"
+      "1:                                        \n"
+      "vld1.16     {q0}, [%0]!                   \n"  // load 8 U
+      "vld1.16     {q1}, [%1]!                   \n"  // load 8 V
+      "vshl.u16    q0, q0, q2                    \n"
+      "vshl.u16    q1, q1, q2                    \n"
+      "subs        %3, %3, #8                    \n"  // 8 src pixels per loop
+      "vst2.16     {q0, q1}, [%2]!               \n"  // store 8 UV pixels
+      "bgt         1b                            \n"
+      : "+r"(src_u),   // %0
+        "+r"(src_v),   // %1
+        "+r"(dst_uv),  // %2
+        "+r"(width)    // %3
+      : "r"(shift)     // %4
+      : "cc", "memory", "q0", "q1", "q2");
+}
+
+void MultiplyRow_16_NEON(const uint16_t* src_y,
+                         uint16_t* dst_y,
+                         int scale,
+                         int width) {
+  asm volatile(
+      "vdup.16     q2, %3                        \n"
+      "1:                                        \n"
+      "vld1.16     {q0}, [%0]!                   \n"
+      "vld1.16     {q1}, [%0]!                   \n"
+      "vmul.u16    q0, q0, q2                    \n"
+      "vmul.u16    q1, q1, q2                    \n"
+      "vst1.16     {q0}, [%1]!                   \n"
+      "vst1.16     {q1}, [%1]!                   \n"
+      "subs        %2, %2, #16                   \n"  // 16 src pixels per loop
+      "bgt         1b                            \n"
+      : "+r"(src_y),  // %0
+        "+r"(dst_y),  // %1
+        "+r"(width)   // %2
+      : "r"(scale)    // %3
+      : "cc", "memory", "q0", "q1", "q2");
+}
+
+void DivideRow_16_NEON(const uint16_t* src_y,
+                       uint16_t* dst_y,
+                       int scale,
+                       int width) {
+  asm volatile(
+      "vdup.16     q0, %3                        \n"
+      "1:                                        \n"
+      "vld1.16     {q1}, [%0]!                   \n"
+      "vld1.16     {q2}, [%0]!                   \n"
+      "vmovl.u16   q3, d2                        \n"
+      "vmovl.u16   q1, d3                        \n"
+      "vmovl.u16   q4, d4                        \n"
+      "vmovl.u16   q2, d5                        \n"
+      "vshl.u32    q3, q3, q0                    \n"
+      "vshl.u32    q4, q4, q0                    \n"
+      "vshl.u32    q1, q1, q0                    \n"
+      "vshl.u32    q2, q2, q0                    \n"
+      "vmovn.u32   d2, q3                        \n"
+      "vmovn.u32   d3, q1                        \n"
+      "vmovn.u32   d4, q4                        \n"
+      "vmovn.u32   d5, q2                        \n"
+      "vst1.16     {q1}, [%1]!                   \n"
+      "vst1.16     {q2}, [%1]!                   \n"
+      "subs        %2, %2, #16                   \n"  // 16 src pixels per loop
+      "bgt         1b                            \n"
+      : "+r"(src_y),  // %0
+        "+r"(dst_y),  // %1
+        "+r"(width)   // %2
+      : "r"(scale)    // %3
+      : "cc", "memory", "q0", "q1", "q2", "q3", "q4");
+}
+
+// Use scale to convert lsb formats to msb, depending how many bits there are:
+// 32768 = 9 bits = shr 1
+// 16384 = 10 bits = shr 2
+// 4096 = 12 bits = shr 4
+// 256 = 16 bits = shr 8
+void Convert16To8Row_NEON(const uint16_t* src_y,
+                          uint8_t* dst_y,
+                          int scale,
+                          int width) {
+  int shift = 15 - __builtin_clz((int32_t)scale);  // Negative shl is shr
+  asm volatile(
+      "vdup.16     q2, %3                        \n"
+      "1:                                        \n"
+      "vld1.16     {q0}, [%0]!                   \n"
+      "vld1.16     {q1}, [%0]!                   \n"
+      "vshl.u16    q0, q0, q2                    \n"  // shr = q2 is negative
+      "vshl.u16    q1, q1, q2                    \n"
+      "vqmovn.u16  d0, q0                        \n"
+      "vqmovn.u16  d1, q1                        \n"
+      "subs        %2, %2, #16                   \n"  // 16 src pixels per loop
+      "vst1.8      {q0}, [%1]!                   \n"
+      "bgt         1b                            \n"
+      : "+r"(src_y),  // %0
+        "+r"(dst_y),  // %1
+        "+r"(width)   // %2
+      : "r"(shift)    // %3
+      : "cc", "memory", "q0", "q1", "q2");
+}
+
+#endif  // !defined(LIBYUV_DISABLE_NEON) && defined(__ARM_NEON__)..
+
+#ifdef __cplusplus
+}  // extern "C"
+}  // namespace libyuv
+#endif
diff --git a/3rdparty/libyuv/src/source/row_neon64.cc b/3rdparty/libyuv/src/source/row_neon64.cc
new file mode 100644
index 00000000..a5313b7e
--- /dev/null
+++ b/3rdparty/libyuv/src/source/row_neon64.cc
@@ -0,0 +1,4299 @@
+/*
+ *  Copyright 2014 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include "libyuv/row.h"
+
+#ifdef __cplusplus
+namespace libyuv {
+extern "C" {
+#endif
+
+// Enable LIBYUV_USE_ST2, LIBYUV_USE_ST3, LIBYUV_USE_ST4 for CPUs that prefer
+// STn over ZIP1+ST1
+// Exynos M1, M2, M3 are slow with ST2, ST3 and ST4 instructions.
+
+// This module is for GCC Neon armv8 64 bit.
+#if !defined(LIBYUV_DISABLE_NEON) && defined(__aarch64__)
+
+// v0.8h: Y
+// v1.16b: 8U, 8V
+
+// Read 8 Y, 4 U and 4 V from 422
+#define READYUV422                               \
+  "ldr        d0, [%[src_y]], #8             \n" \
+  "ld1        {v1.s}[0], [%[src_u]], #4      \n" \
+  "ld1        {v1.s}[1], [%[src_v]], #4      \n" \
+  "zip1       v0.16b, v0.16b, v0.16b         \n" \
+  "prfm       pldl1keep, [%[src_y], 448]     \n" \
+  "zip1       v1.16b, v1.16b, v1.16b         \n" \
+  "prfm       pldl1keep, [%[src_u], 128]     \n" \
+  "prfm       pldl1keep, [%[src_v], 128]     \n"
+
+// Read 8 Y, 8 U and 8 V from 444
+#define READYUV444                               \
+  "ldr        d0, [%[src_y]], #8             \n" \
+  "ld1        {v1.d}[0], [%[src_u]], #8      \n" \
+  "prfm       pldl1keep, [%[src_y], 448]     \n" \
+  "ld1        {v1.d}[1], [%[src_v]], #8      \n" \
+  "prfm       pldl1keep, [%[src_u], 448]     \n" \
+  "zip1       v0.16b, v0.16b, v0.16b         \n" \
+  "prfm       pldl1keep, [%[src_v], 448]     \n"
+
+// Read 8 Y, and set 4 U and 4 V to 128
+#define READYUV400                               \
+  "ldr        d0, [%[src_y]], #8             \n" \
+  "movi       v1.16b, #128                   \n" \
+  "prfm       pldl1keep, [%[src_y], 448]     \n" \
+  "zip1       v0.16b, v0.16b, v0.16b         \n"
+
+static const uvec8 kNV12Table = {0, 0, 2, 2, 4, 4, 6, 6,
+                                 1, 1, 3, 3, 5, 5, 7, 7};
+static const uvec8 kNV21Table = {1, 1, 3, 3, 5, 5, 7, 7,
+                                 0, 0, 2, 2, 4, 4, 6, 6};
+
+// Read 8 Y and 4 UV from NV12 or NV21
+#define READNV12                                 \
+  "ldr        d0, [%[src_y]], #8             \n" \
+  "ldr        d1, [%[src_uv]], #8            \n" \
+  "zip1       v0.16b, v0.16b, v0.16b         \n" \
+  "prfm       pldl1keep, [%[src_y], 448]     \n" \
+  "tbl        v1.16b, {v1.16b}, v2.16b       \n" \
+  "prfm       pldl1keep, [%[src_uv], 448]    \n"
+
+// Read 8 YUY2
+#define READYUY2                                     \
+  "ld2        {v0.8b, v1.8b}, [%[src_yuy2]], #16 \n" \
+  "zip1       v0.16b, v0.16b, v0.16b         \n"     \
+  "prfm       pldl1keep, [%[src_yuy2], 448]  \n"     \
+  "tbl        v1.16b, {v1.16b}, v2.16b       \n"
+
+// Read 8 UYVY
+#define READUYVY                                     \
+  "ld2        {v3.8b, v4.8b}, [%[src_uyvy]], #16 \n" \
+  "zip1       v0.16b, v4.16b, v4.16b         \n"     \
+  "prfm       pldl1keep, [%[src_uyvy], 448]  \n"     \
+  "tbl        v1.16b, {v3.16b}, v2.16b       \n"
+
+// UB VR UG VG
+// YG BB BG BR
+#define YUVTORGB_SETUP                                                \
+  "ld4r       {v28.16b, v29.16b, v30.16b, v31.16b}, [%[kUVCoeff]] \n" \
+  "ld4r       {v24.8h, v25.8h, v26.8h, v27.8h}, [%[kRGBCoeffBias]] \n"
+
+// v16.8h: B
+// v17.8h: G
+// v18.8h: R
+
+// Convert from YUV to 2.14 fixed point RGB
+#define YUVTORGB                                          \
+  "umull2     v3.4s, v0.8h, v24.8h           \n"          \
+  "umull      v6.8h, v1.8b, v30.8b           \n"          \
+  "umull      v0.4s, v0.4h, v24.4h           \n"          \
+  "umlal2     v6.8h, v1.16b, v31.16b         \n" /* DG */ \
+  "uqshrn     v0.4h, v0.4s, #16              \n"          \
+  "uqshrn2    v0.8h, v3.4s, #16              \n" /* Y */  \
+  "umull      v4.8h, v1.8b, v28.8b           \n" /* DB */ \
+  "umull2     v5.8h, v1.16b, v29.16b         \n" /* DR */ \
+  "add        v17.8h, v0.8h, v26.8h          \n" /* G */  \
+  "add        v16.8h, v0.8h, v4.8h           \n" /* B */  \
+  "add        v18.8h, v0.8h, v5.8h           \n" /* R */  \
+  "uqsub      v17.8h, v17.8h, v6.8h          \n" /* G */  \
+  "uqsub      v16.8h, v16.8h, v25.8h         \n" /* B */  \
+  "uqsub      v18.8h, v18.8h, v27.8h         \n" /* R */
+
+// Convert from 2.14 fixed point RGB To 8 bit RGB
+#define RGBTORGB8                                \
+  "uqshrn     v17.8b, v17.8h, #6             \n" \
+  "uqshrn     v16.8b, v16.8h, #6             \n" \
+  "uqshrn     v18.8b, v18.8h, #6             \n"
+
+#define YUVTORGB_REGS                                                          \
+  "v0", "v1", "v3", "v4", "v5", "v6", "v7", "v16", "v17", "v18", "v24", "v25", \
+      "v26", "v27", "v28", "v29", "v30", "v31"
+
+void I444ToARGBRow_NEON(const uint8_t* src_y,
+                        const uint8_t* src_u,
+                        const uint8_t* src_v,
+                        uint8_t* dst_argb,
+                        const struct YuvConstants* yuvconstants,
+                        int width) {
+  asm volatile(
+      YUVTORGB_SETUP
+      "movi        v19.8b, #255                  \n" /* A */
+      "1:                                        \n" READYUV444 YUVTORGB
+          RGBTORGB8
+      "subs        %w[width], %w[width], #8      \n"
+      "st4         {v16.8b,v17.8b,v18.8b,v19.8b}, [%[dst_argb]], #32 \n"
+      "b.gt        1b                            \n"
+      : [src_y] "+r"(src_y),                               // %[src_y]
+        [src_u] "+r"(src_u),                               // %[src_u]
+        [src_v] "+r"(src_v),                               // %[src_v]
+        [dst_argb] "+r"(dst_argb),                         // %[dst_argb]
+        [width] "+r"(width)                                // %[width]
+      : [kUVCoeff] "r"(&yuvconstants->kUVCoeff),           // %[kUVCoeff]
+        [kRGBCoeffBias] "r"(&yuvconstants->kRGBCoeffBias)  // %[kRGBCoeffBias]
+      : "cc", "memory", YUVTORGB_REGS, "v19");
+}
+
+void I422ToARGBRow_NEON(const uint8_t* src_y,
+                        const uint8_t* src_u,
+                        const uint8_t* src_v,
+                        uint8_t* dst_argb,
+                        const struct YuvConstants* yuvconstants,
+                        int width) {
+  asm volatile(
+      YUVTORGB_SETUP
+      "movi        v19.8b, #255                  \n" /* A */
+      "1:                                        \n" READYUV422 YUVTORGB
+          RGBTORGB8
+      "subs        %w[width], %w[width], #8      \n"
+      "st4         {v16.8b,v17.8b,v18.8b,v19.8b}, [%[dst_argb]], #32 \n"
+      "b.gt        1b                            \n"
+      : [src_y] "+r"(src_y),                               // %[src_y]
+        [src_u] "+r"(src_u),                               // %[src_u]
+        [src_v] "+r"(src_v),                               // %[src_v]
+        [dst_argb] "+r"(dst_argb),                         // %[dst_argb]
+        [width] "+r"(width)                                // %[width]
+      : [kUVCoeff] "r"(&yuvconstants->kUVCoeff),           // %[kUVCoeff]
+        [kRGBCoeffBias] "r"(&yuvconstants->kRGBCoeffBias)  // %[kRGBCoeffBias]
+      : "cc", "memory", YUVTORGB_REGS, "v19");
+}
+
+void I444AlphaToARGBRow_NEON(const uint8_t* src_y,
+                             const uint8_t* src_u,
+                             const uint8_t* src_v,
+                             const uint8_t* src_a,
+                             uint8_t* dst_argb,
+                             const struct YuvConstants* yuvconstants,
+                             int width) {
+  asm volatile(
+      YUVTORGB_SETUP
+      "1:                                        \n"
+      "ld1         {v19.8b}, [%[src_a]], #8      \n" READYUV444
+      "prfm        pldl1keep, [%[src_a], 448]    \n" YUVTORGB RGBTORGB8
+      "subs        %w[width], %w[width], #8      \n"
+      "st4         {v16.8b,v17.8b,v18.8b,v19.8b}, [%[dst_argb]], #32 \n"
+      "b.gt        1b                            \n"
+      : [src_y] "+r"(src_y),                               // %[src_y]
+        [src_u] "+r"(src_u),                               // %[src_u]
+        [src_v] "+r"(src_v),                               // %[src_v]
+        [src_a] "+r"(src_a),                               // %[src_a]
+        [dst_argb] "+r"(dst_argb),                         // %[dst_argb]
+        [width] "+r"(width)                                // %[width]
+      : [kUVCoeff] "r"(&yuvconstants->kUVCoeff),           // %[kUVCoeff]
+        [kRGBCoeffBias] "r"(&yuvconstants->kRGBCoeffBias)  // %[kRGBCoeffBias]
+      : "cc", "memory", YUVTORGB_REGS, "v19");
+}
+
+void I422AlphaToARGBRow_NEON(const uint8_t* src_y,
+                             const uint8_t* src_u,
+                             const uint8_t* src_v,
+                             const uint8_t* src_a,
+                             uint8_t* dst_argb,
+                             const struct YuvConstants* yuvconstants,
+                             int width) {
+  asm volatile(
+      YUVTORGB_SETUP
+      "1:                                        \n"
+      "ld1         {v19.8b}, [%[src_a]], #8      \n" READYUV422
+      "prfm        pldl1keep, [%[src_a], 448]    \n" YUVTORGB RGBTORGB8
+      "subs        %w[width], %w[width], #8      \n"
+      "st4         {v16.8b,v17.8b,v18.8b,v19.8b}, [%[dst_argb]], #32 \n"
+      "b.gt        1b                            \n"
+      : [src_y] "+r"(src_y),                               // %[src_y]
+        [src_u] "+r"(src_u),                               // %[src_u]
+        [src_v] "+r"(src_v),                               // %[src_v]
+        [src_a] "+r"(src_a),                               // %[src_a]
+        [dst_argb] "+r"(dst_argb),                         // %[dst_argb]
+        [width] "+r"(width)                                // %[width]
+      : [kUVCoeff] "r"(&yuvconstants->kUVCoeff),           // %[kUVCoeff]
+        [kRGBCoeffBias] "r"(&yuvconstants->kRGBCoeffBias)  // %[kRGBCoeffBias]
+      : "cc", "memory", YUVTORGB_REGS, "v19");
+}
+
+void I422ToRGBARow_NEON(const uint8_t* src_y,
+                        const uint8_t* src_u,
+                        const uint8_t* src_v,
+                        uint8_t* dst_rgba,
+                        const struct YuvConstants* yuvconstants,
+                        int width) {
+  asm volatile(
+      YUVTORGB_SETUP
+      "movi        v15.8b, #255                  \n" /* A */
+      "1:                                        \n" READYUV422 YUVTORGB
+          RGBTORGB8
+      "subs        %w[width], %w[width], #8      \n"
+      "st4         {v15.8b,v16.8b,v17.8b,v18.8b}, [%[dst_rgba]], #32 \n"
+      "b.gt        1b                            \n"
+      : [src_y] "+r"(src_y),                               // %[src_y]
+        [src_u] "+r"(src_u),                               // %[src_u]
+        [src_v] "+r"(src_v),                               // %[src_v]
+        [dst_rgba] "+r"(dst_rgba),                         // %[dst_rgba]
+        [width] "+r"(width)                                // %[width]
+      : [kUVCoeff] "r"(&yuvconstants->kUVCoeff),           // %[kUVCoeff]
+        [kRGBCoeffBias] "r"(&yuvconstants->kRGBCoeffBias)  // %[kRGBCoeffBias]
+      : "cc", "memory", YUVTORGB_REGS, "v15");
+}
+
+void I422ToRGB24Row_NEON(const uint8_t* src_y,
+                         const uint8_t* src_u,
+                         const uint8_t* src_v,
+                         uint8_t* dst_rgb24,
+                         const struct YuvConstants* yuvconstants,
+                         int width) {
+  asm volatile(
+      YUVTORGB_SETUP
+      "1:                                        \n" READYUV422 YUVTORGB
+          RGBTORGB8
+      "subs        %w[width], %w[width], #8      \n"
+      "st3         {v16.8b,v17.8b,v18.8b}, [%[dst_rgb24]], #24 \n"
+      "b.gt        1b                            \n"
+      : [src_y] "+r"(src_y),                               // %[src_y]
+        [src_u] "+r"(src_u),                               // %[src_u]
+        [src_v] "+r"(src_v),                               // %[src_v]
+        [dst_rgb24] "+r"(dst_rgb24),                       // %[dst_rgb24]
+        [width] "+r"(width)                                // %[width]
+      : [kUVCoeff] "r"(&yuvconstants->kUVCoeff),           // %[kUVCoeff]
+        [kRGBCoeffBias] "r"(&yuvconstants->kRGBCoeffBias)  // %[kRGBCoeffBias]
+      : "cc", "memory", YUVTORGB_REGS);
+}
+
+#define ARGBTORGB565                                                        \
+  "shll       v18.8h, v18.8b, #8             \n" /* R                    */ \
+  "shll       v17.8h, v17.8b, #8             \n" /* G                    */ \
+  "shll       v16.8h, v16.8b, #8             \n" /* B                    */ \
+  "sri        v18.8h, v17.8h, #5             \n" /* RG                   */ \
+  "sri        v18.8h, v16.8h, #11            \n" /* RGB                  */
+
+void I422ToRGB565Row_NEON(const uint8_t* src_y,
+                          const uint8_t* src_u,
+                          const uint8_t* src_v,
+                          uint8_t* dst_rgb565,
+                          const struct YuvConstants* yuvconstants,
+                          int width) {
+  asm volatile(
+      YUVTORGB_SETUP
+      "1:                                        \n" READYUV422 YUVTORGB
+      RGBTORGB8 "subs        %w[width], %w[width], #8      \n" ARGBTORGB565
+      "st1         {v18.8h}, [%[dst_rgb565]], #16 \n"  // store 8 pixels RGB565.
+      "b.gt        1b                            \n"
+      : [src_y] "+r"(src_y),                               // %[src_y]
+        [src_u] "+r"(src_u),                               // %[src_u]
+        [src_v] "+r"(src_v),                               // %[src_v]
+        [dst_rgb565] "+r"(dst_rgb565),                     // %[dst_rgb565]
+        [width] "+r"(width)                                // %[width]
+      : [kUVCoeff] "r"(&yuvconstants->kUVCoeff),           // %[kUVCoeff]
+        [kRGBCoeffBias] "r"(&yuvconstants->kRGBCoeffBias)  // %[kRGBCoeffBias]
+      : "cc", "memory", YUVTORGB_REGS);
+}
+
+#define ARGBTOARGB1555                                                      \
+  "shll       v0.8h,  v19.8b, #8             \n" /* A                    */ \
+  "shll       v18.8h, v18.8b, #8             \n" /* R                    */ \
+  "shll       v17.8h, v17.8b, #8             \n" /* G                    */ \
+  "shll       v16.8h, v16.8b, #8             \n" /* B                    */ \
+  "sri        v0.8h,  v18.8h, #1             \n" /* AR                   */ \
+  "sri        v0.8h,  v17.8h, #6             \n" /* ARG                  */ \
+  "sri        v0.8h,  v16.8h, #11            \n" /* ARGB                 */
+
+void I422ToARGB1555Row_NEON(const uint8_t* src_y,
+                            const uint8_t* src_u,
+                            const uint8_t* src_v,
+                            uint8_t* dst_argb1555,
+                            const struct YuvConstants* yuvconstants,
+                            int width) {
+  asm volatile(
+      YUVTORGB_SETUP
+      "movi        v19.8b, #255                  \n"
+      "1:                                        \n" READYUV422 YUVTORGB
+          RGBTORGB8
+      "subs        %w[width], %w[width], #8      \n" ARGBTOARGB1555
+      "st1         {v0.8h}, [%[dst_argb1555]], #16 \n"  // store 8 pixels
+                                                        // RGB565.
+      "b.gt        1b                            \n"
+      : [src_y] "+r"(src_y),                               // %[src_y]
+        [src_u] "+r"(src_u),                               // %[src_u]
+        [src_v] "+r"(src_v),                               // %[src_v]
+        [dst_argb1555] "+r"(dst_argb1555),                 // %[dst_argb1555]
+        [width] "+r"(width)                                // %[width]
+      : [kUVCoeff] "r"(&yuvconstants->kUVCoeff),           // %[kUVCoeff]
+        [kRGBCoeffBias] "r"(&yuvconstants->kRGBCoeffBias)  // %[kRGBCoeffBias]
+      : "cc", "memory", YUVTORGB_REGS, "v19");
+}
+
+#define ARGBTOARGB4444                                                       \
+  /* Input v16.8b<=B, v17.8b<=G, v18.8b<=R, v19.8b<=A, v23.8b<=0x0f       */ \
+  "ushr       v16.8b, v16.8b, #4             \n" /* B                    */  \
+  "bic        v17.8b, v17.8b, v23.8b         \n" /* G                    */  \
+  "ushr       v18.8b, v18.8b, #4             \n" /* R                    */  \
+  "bic        v19.8b, v19.8b, v23.8b         \n" /* A                    */  \
+  "orr        v0.8b,  v16.8b, v17.8b         \n" /* BG                   */  \
+  "orr        v1.8b,  v18.8b, v19.8b         \n" /* RA                   */  \
+  "zip1       v0.16b, v0.16b, v1.16b         \n" /* BGRA                 */
+
+void I422ToARGB4444Row_NEON(const uint8_t* src_y,
+                            const uint8_t* src_u,
+                            const uint8_t* src_v,
+                            uint8_t* dst_argb4444,
+                            const struct YuvConstants* yuvconstants,
+                            int width) {
+  asm volatile(
+      YUVTORGB_SETUP
+      "movi        v23.16b, #0x0f                \n"  // bits to clear with
+                                                      // vbic.
+      "1:                                        \n" READYUV422 YUVTORGB
+          RGBTORGB8
+      "subs        %w[width], %w[width], #8      \n"
+      "movi        v19.8b, #255                  \n" ARGBTOARGB4444
+      "st1         {v0.8h}, [%[dst_argb4444]], #16 \n"  // store 8
+                                                        // pixels
+                                                        // ARGB4444.
+      "b.gt        1b                            \n"
+      : [src_y] "+r"(src_y),                               // %[src_y]
+        [src_u] "+r"(src_u),                               // %[src_u]
+        [src_v] "+r"(src_v),                               // %[src_v]
+        [dst_argb4444] "+r"(dst_argb4444),                 // %[dst_argb4444]
+        [width] "+r"(width)                                // %[width]
+      : [kUVCoeff] "r"(&yuvconstants->kUVCoeff),           // %[kUVCoeff]
+        [kRGBCoeffBias] "r"(&yuvconstants->kRGBCoeffBias)  // %[kRGBCoeffBias]
+      : "cc", "memory", YUVTORGB_REGS, "v19", "v23");
+}
+
+void I400ToARGBRow_NEON(const uint8_t* src_y,
+                        uint8_t* dst_argb,
+                        const struct YuvConstants* yuvconstants,
+                        int width) {
+  asm volatile(
+      YUVTORGB_SETUP
+      "movi        v19.8b, #255                  \n"
+      "1:                                        \n" READYUV400 YUVTORGB
+          RGBTORGB8
+      "subs        %w[width], %w[width], #8      \n"
+      "st4         {v16.8b,v17.8b,v18.8b,v19.8b}, [%[dst_argb]], #32 \n"
+      "b.gt        1b                            \n"
+      : [src_y] "+r"(src_y),                               // %[src_y]
+        [dst_argb] "+r"(dst_argb),                         // %[dst_argb]
+        [width] "+r"(width)                                // %[width]
+      : [kUVCoeff] "r"(&yuvconstants->kUVCoeff),           // %[kUVCoeff]
+        [kRGBCoeffBias] "r"(&yuvconstants->kRGBCoeffBias)  // %[kRGBCoeffBias]
+      : "cc", "memory", YUVTORGB_REGS, "v19");
+}
+
+#if LIBYUV_USE_ST4
+void J400ToARGBRow_NEON(const uint8_t* src_y, uint8_t* dst_argb, int width) {
+  asm volatile(
+      "movi        v23.8b, #255                  \n"
+      "1:                                        \n"
+      "ld1         {v20.8b}, [%0], #8            \n"
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "orr         v21.8b, v20.8b, v20.8b        \n"
+      "orr         v22.8b, v20.8b, v20.8b        \n"
+      "subs        %w2, %w2, #8                  \n"
+      "st4         {v20.8b,v21.8b,v22.8b,v23.8b}, [%1], #32 \n"
+      "b.gt        1b                            \n"
+      : "+r"(src_y),     // %0
+        "+r"(dst_argb),  // %1
+        "+r"(width)      // %2
+      :
+      : "cc", "memory", "v20", "v21", "v22", "v23");
+}
+#else
+void J400ToARGBRow_NEON(const uint8_t* src_y, uint8_t* dst_argb, int width) {
+  asm volatile(
+      "movi        v20.8b, #255                  \n"
+      "1:                                        \n"
+      "ldr         d16, [%0], #8                 \n"
+      "subs        %w2, %w2, #8                  \n"
+      "zip1        v18.16b, v16.16b, v16.16b     \n"  // YY
+      "zip1        v19.16b, v16.16b, v20.16b     \n"  // YA
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "zip1        v16.16b, v18.16b, v19.16b     \n"  // YYYA
+      "zip2        v17.16b, v18.16b, v19.16b     \n"
+      "stp         q16, q17, [%1], #32           \n"
+      "b.gt        1b                            \n"
+      : "+r"(src_y),     // %0
+        "+r"(dst_argb),  // %1
+        "+r"(width)      // %2
+      :
+      : "cc", "memory", "v16", "v17", "v18", "v19", "v20");
+}
+#endif  // LIBYUV_USE_ST4
+
+void NV12ToARGBRow_NEON(const uint8_t* src_y,
+                        const uint8_t* src_uv,
+                        uint8_t* dst_argb,
+                        const struct YuvConstants* yuvconstants,
+                        int width) {
+  asm volatile(
+      YUVTORGB_SETUP
+      "movi        v19.8b, #255                  \n"
+      "ldr         q2, [%[kNV12Table]]           \n"
+      "1:                                        \n" READNV12 YUVTORGB RGBTORGB8
+      "subs        %w[width], %w[width], #8      \n"
+      "st4         {v16.8b,v17.8b,v18.8b,v19.8b}, [%[dst_argb]], #32 \n"
+      "b.gt        1b                            \n"
+      : [src_y] "+r"(src_y),                                // %[src_y]
+        [src_uv] "+r"(src_uv),                              // %[src_uv]
+        [dst_argb] "+r"(dst_argb),                          // %[dst_argb]
+        [width] "+r"(width)                                 // %[width]
+      : [kUVCoeff] "r"(&yuvconstants->kUVCoeff),            // %[kUVCoeff]
+        [kRGBCoeffBias] "r"(&yuvconstants->kRGBCoeffBias),  // %[kRGBCoeffBias]
+        [kNV12Table] "r"(&kNV12Table)
+      : "cc", "memory", YUVTORGB_REGS, "v2", "v19");
+}
+
+void NV21ToARGBRow_NEON(const uint8_t* src_y,
+                        const uint8_t* src_vu,
+                        uint8_t* dst_argb,
+                        const struct YuvConstants* yuvconstants,
+                        int width) {
+  asm volatile(
+      YUVTORGB_SETUP
+      "movi        v19.8b, #255                  \n"
+      "ldr         q2, [%[kNV12Table]]           \n"
+      "1:                                        \n" READNV12 YUVTORGB RGBTORGB8
+      "subs        %w[width], %w[width], #8      \n"
+      "st4         {v16.8b,v17.8b,v18.8b,v19.8b}, [%[dst_argb]], #32 \n"
+      "b.gt        1b                            \n"
+      : [src_y] "+r"(src_y),                                // %[src_y]
+        [src_uv] "+r"(src_vu),                              // %[src_uv]
+        [dst_argb] "+r"(dst_argb),                          // %[dst_argb]
+        [width] "+r"(width)                                 // %[width]
+      : [kUVCoeff] "r"(&yuvconstants->kUVCoeff),            // %[kUVCoeff]
+        [kRGBCoeffBias] "r"(&yuvconstants->kRGBCoeffBias),  // %[kRGBCoeffBias]
+        [kNV12Table] "r"(&kNV21Table)
+      : "cc", "memory", YUVTORGB_REGS, "v2", "v19");
+}
+
+void NV12ToRGB24Row_NEON(const uint8_t* src_y,
+                         const uint8_t* src_uv,
+                         uint8_t* dst_rgb24,
+                         const struct YuvConstants* yuvconstants,
+                         int width) {
+  asm volatile(
+      YUVTORGB_SETUP
+      "ldr         q2, [%[kNV12Table]]           \n"
+      "1:                                        \n" READNV12 YUVTORGB RGBTORGB8
+      "subs        %w[width], %w[width], #8      \n"
+      "st3         {v16.8b,v17.8b,v18.8b}, [%[dst_rgb24]], #24 \n"
+      "b.gt        1b                            \n"
+      : [src_y] "+r"(src_y),                                // %[src_y]
+        [src_uv] "+r"(src_uv),                              // %[src_uv]
+        [dst_rgb24] "+r"(dst_rgb24),                        // %[dst_rgb24]
+        [width] "+r"(width)                                 // %[width]
+      : [kUVCoeff] "r"(&yuvconstants->kUVCoeff),            // %[kUVCoeff]
+        [kRGBCoeffBias] "r"(&yuvconstants->kRGBCoeffBias),  // %[kRGBCoeffBias]
+        [kNV12Table] "r"(&kNV12Table)
+      : "cc", "memory", YUVTORGB_REGS, "v2");
+}
+
+void NV21ToRGB24Row_NEON(const uint8_t* src_y,
+                         const uint8_t* src_vu,
+                         uint8_t* dst_rgb24,
+                         const struct YuvConstants* yuvconstants,
+                         int width) {
+  asm volatile(
+      YUVTORGB_SETUP
+      "ldr         q2, [%[kNV12Table]]           \n"
+      "1:                                        \n" READNV12 YUVTORGB RGBTORGB8
+      "subs        %w[width], %w[width], #8      \n"
+      "st3         {v16.8b,v17.8b,v18.8b}, [%[dst_rgb24]], #24 \n"
+      "b.gt        1b                            \n"
+      : [src_y] "+r"(src_y),                                // %[src_y]
+        [src_uv] "+r"(src_vu),                              // %[src_uv]
+        [dst_rgb24] "+r"(dst_rgb24),                        // %[dst_rgb24]
+        [width] "+r"(width)                                 // %[width]
+      : [kUVCoeff] "r"(&yuvconstants->kUVCoeff),            // %[kUVCoeff]
+        [kRGBCoeffBias] "r"(&yuvconstants->kRGBCoeffBias),  // %[kRGBCoeffBias]
+        [kNV12Table] "r"(&kNV21Table)
+      : "cc", "memory", YUVTORGB_REGS, "v2");
+}
+
+void NV12ToRGB565Row_NEON(const uint8_t* src_y,
+                          const uint8_t* src_uv,
+                          uint8_t* dst_rgb565,
+                          const struct YuvConstants* yuvconstants,
+                          int width) {
+  asm volatile(
+      YUVTORGB_SETUP
+      "ldr         q2, [%[kNV12Table]]           \n"
+      "1:                                        \n" READNV12 YUVTORGB RGBTORGB8
+      "subs        %w[width], %w[width], #8      \n" ARGBTORGB565
+      "st1         {v18.8h}, [%[dst_rgb565]], #16 \n"  // store 8
+                                                       // pixels
+                                                       // RGB565.
+      "b.gt        1b                            \n"
+      : [src_y] "+r"(src_y),                                // %[src_y]
+        [src_uv] "+r"(src_uv),                              // %[src_uv]
+        [dst_rgb565] "+r"(dst_rgb565),                      // %[dst_rgb565]
+        [width] "+r"(width)                                 // %[width]
+      : [kUVCoeff] "r"(&yuvconstants->kUVCoeff),            // %[kUVCoeff]
+        [kRGBCoeffBias] "r"(&yuvconstants->kRGBCoeffBias),  // %[kRGBCoeffBias]
+        [kNV12Table] "r"(&kNV12Table)
+      : "cc", "memory", YUVTORGB_REGS, "v2");
+}
+
+void YUY2ToARGBRow_NEON(const uint8_t* src_yuy2,
+                        uint8_t* dst_argb,
+                        const struct YuvConstants* yuvconstants,
+                        int width) {
+  asm volatile(
+      YUVTORGB_SETUP
+      "movi        v19.8b, #255                  \n"
+      "ldr         q2, [%[kNV12Table]]           \n"
+      "1:                                        \n" READYUY2 YUVTORGB RGBTORGB8
+      "subs        %w[width], %w[width], #8      \n"
+      "st4         {v16.8b,v17.8b,v18.8b,v19.8b}, [%[dst_argb]], #32 \n"
+      "b.gt        1b                            \n"
+      : [src_yuy2] "+r"(src_yuy2),                          // %[src_yuy2]
+        [dst_argb] "+r"(dst_argb),                          // %[dst_argb]
+        [width] "+r"(width)                                 // %[width]
+      : [kUVCoeff] "r"(&yuvconstants->kUVCoeff),            // %[kUVCoeff]
+        [kRGBCoeffBias] "r"(&yuvconstants->kRGBCoeffBias),  // %[kRGBCoeffBias]
+        [kNV12Table] "r"(&kNV12Table)
+      : "cc", "memory", YUVTORGB_REGS, "v2", "v19");
+}
+
+void UYVYToARGBRow_NEON(const uint8_t* src_uyvy,
+                        uint8_t* dst_argb,
+                        const struct YuvConstants* yuvconstants,
+                        int width) {
+  asm volatile(
+      YUVTORGB_SETUP
+      "movi        v19.8b, #255                  \n"
+      "ldr         q2, [%[kNV12Table]]           \n"
+      "1:                                        \n" READUYVY YUVTORGB RGBTORGB8
+      "subs        %w[width], %w[width], #8      \n"
+      "st4         {v16.8b,v17.8b,v18.8b,v19.8b}, [%[dst_argb]], #32 \n"
+      "b.gt        1b                            \n"
+      : [src_uyvy] "+r"(src_uyvy),                          // %[src_yuy2]
+        [dst_argb] "+r"(dst_argb),                          // %[dst_argb]
+        [width] "+r"(width)                                 // %[width]
+      : [kUVCoeff] "r"(&yuvconstants->kUVCoeff),            // %[kUVCoeff]
+        [kRGBCoeffBias] "r"(&yuvconstants->kRGBCoeffBias),  // %[kRGBCoeffBias]
+        [kNV12Table] "r"(&kNV12Table)
+      : "cc", "memory", YUVTORGB_REGS, "v2", "v19");
+}
+
+// Reads 16 pairs of UV and write even values to dst_u and odd to dst_v.
+void SplitUVRow_NEON(const uint8_t* src_uv,
+                     uint8_t* dst_u,
+                     uint8_t* dst_v,
+                     int width) {
+  asm volatile(
+      "1:                                        \n"
+      "ld2         {v0.16b,v1.16b}, [%0], #32    \n"  // load 16 pairs of UV
+      "subs        %w3, %w3, #16                 \n"  // 16 processed per loop
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "st1         {v0.16b}, [%1], #16           \n"  // store U
+      "st1         {v1.16b}, [%2], #16           \n"  // store V
+      "b.gt        1b                            \n"
+      : "+r"(src_uv),               // %0
+        "+r"(dst_u),                // %1
+        "+r"(dst_v),                // %2
+        "+r"(width)                 // %3  // Output registers
+      :                             // Input registers
+      : "cc", "memory", "v0", "v1"  // Clobber List
+  );
+}
+
+// Reads 16 byte Y's from tile and writes out 16 Y's.
+// MM21 Y tiles are 16x32 so src_tile_stride = 512 bytes
+// MM21 UV tiles are 8x16 so src_tile_stride = 256 bytes
+// width measured in bytes so 8 UV = 16.
+void DetileRow_NEON(const uint8_t* src,
+                    ptrdiff_t src_tile_stride,
+                    uint8_t* dst,
+                    int width) {
+  asm volatile(
+      "1:                                        \n"
+      "ld1         {v0.16b}, [%0], %3            \n"  // load 16 bytes
+      "subs        %w2, %w2, #16                 \n"  // 16 processed per loop
+      "prfm        pldl1keep, [%0, 1792]         \n"  // 7 tiles of 256b ahead
+      "st1         {v0.16b}, [%1], #16           \n"  // store 16 bytes
+      "b.gt        1b                            \n"
+      : "+r"(src),            // %0
+        "+r"(dst),            // %1
+        "+r"(width)           // %2
+      : "r"(src_tile_stride)  // %3
+      : "cc", "memory", "v0"  // Clobber List
+  );
+}
+
+// Read 16 bytes of UV, detile, and write 8 bytes of U and 8 bytes of V.
+void DetileSplitUVRow_NEON(const uint8_t* src_uv,
+                           ptrdiff_t src_tile_stride,
+                           uint8_t* dst_u,
+                           uint8_t* dst_v,
+                           int width) {
+  asm volatile(
+      "1:                                        \n"
+      "ld2         {v0.8b,v1.8b}, [%0], %4       \n"
+      "subs        %w3, %w3, #16                 \n"
+      "prfm        pldl1keep, [%0, 1792]         \n"
+      "st1         {v0.8b}, [%1], #8             \n"
+      "st1         {v1.8b}, [%2], #8             \n"
+      "b.gt        1b                            \n"
+      : "+r"(src_uv),               // %0
+        "+r"(dst_u),                // %1
+        "+r"(dst_v),                // %2
+        "+r"(width)                 // %3
+      : "r"(src_tile_stride)        // %4
+      : "cc", "memory", "v0", "v1"  // Clobber List
+  );
+}
+
+#if LIBYUV_USE_ST2
+// Reads 16 U's and V's and writes out 16 pairs of UV.
+void MergeUVRow_NEON(const uint8_t* src_u,
+                     const uint8_t* src_v,
+                     uint8_t* dst_uv,
+                     int width) {
+  asm volatile(
+      "1:                                        \n"
+      "ld1         {v0.16b}, [%0], #16           \n"  // load U
+      "ld1         {v1.16b}, [%1], #16           \n"  // load V
+      "subs        %w3, %w3, #16                 \n"  // 16 processed per loop
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "prfm        pldl1keep, [%1, 448]          \n"
+      "st2         {v0.16b,v1.16b}, [%2], #32    \n"  // store 16 pairs of UV
+      "b.gt        1b                            \n"
+      : "+r"(src_u),                // %0
+        "+r"(src_v),                // %1
+        "+r"(dst_uv),               // %2
+        "+r"(width)                 // %3  // Output registers
+      :                             // Input registers
+      : "cc", "memory", "v0", "v1"  // Clobber List
+  );
+}
+
+void MergeUVRow_16_NEON(const uint16_t* src_u,
+                        const uint16_t* src_v,
+                        uint16_t* dst_uv,
+                        int depth,
+                        int width) {
+  int shift = 16 - depth;
+  asm volatile(
+      "dup         v2.8h, %w4                    \n"
+      "1:                                        \n"
+      "ld1         {v0.8h}, [%0], #16            \n"  // load 8 U
+      "subs        %w3, %w3, #8                  \n"  // 8 src pixels per loop
+      "ld1         {v1.8h}, [%1], #16            \n"  // load 8 V
+      "ushl        v0.8h, v0.8h, v2.8h           \n"
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "ushl        v1.8h, v1.8h, v2.8h           \n"
+      "prfm        pldl1keep, [%1, 448]          \n"
+      "st2         {v0.8h, v1.8h}, [%2], #32     \n"  // store 8 UV pixels
+      "b.gt        1b                            \n"
+      : "+r"(src_u),   // %0
+        "+r"(src_v),   // %1
+        "+r"(dst_uv),  // %2
+        "+r"(width)    // %3
+      : "r"(shift)     // %4
+      : "cc", "memory", "v0", "v1", "v2");
+}
+#else
+// Reads 16 U's and V's and writes out 16 pairs of UV.
+void MergeUVRow_NEON(const uint8_t* src_u,
+                     const uint8_t* src_v,
+                     uint8_t* dst_uv,
+                     int width) {
+  asm volatile(
+      "1:                                        \n"
+      "ld1         {v0.16b}, [%0], #16           \n"  // load U
+      "ld1         {v1.16b}, [%1], #16           \n"  // load V
+      "subs        %w3, %w3, #16                 \n"  // 16 processed per loop
+      "zip1        v2.16b, v0.16b, v1.16b        \n"
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "zip2        v3.16b, v0.16b, v1.16b        \n"
+      "prfm        pldl1keep, [%1, 448]          \n"
+      "st1         {v2.16b,v3.16b}, [%2], #32    \n"  // store 16 pairs of UV
+      "b.gt        1b                            \n"
+      : "+r"(src_u),                            // %0
+        "+r"(src_v),                            // %1
+        "+r"(dst_uv),                           // %2
+        "+r"(width)                             // %3  // Output registers
+      :                                         // Input registers
+      : "cc", "memory", "v0", "v1", "v2", "v3"  // Clobber List
+  );
+}
+
+void MergeUVRow_16_NEON(const uint16_t* src_u,
+                        const uint16_t* src_v,
+                        uint16_t* dst_uv,
+                        int depth,
+                        int width) {
+  int shift = 16 - depth;
+  asm volatile(
+      "dup         v4.8h, %w4                    \n"
+      "1:                                        \n"
+      "ld1         {v0.8h}, [%0], #16            \n"  // load 8 U
+      "subs        %w3, %w3, #8                  \n"  // 8 src pixels per loop
+      "ld1         {v1.8h}, [%1], #16            \n"  // load 8 V
+      "ushl        v0.8h, v0.8h, v4.8h           \n"
+      "ushl        v1.8h, v1.8h, v4.8h           \n"
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "zip1        v2.8h, v0.8h, v1.8h           \n"
+      "zip2        v3.8h, v0.8h, v1.8h           \n"
+      "prfm        pldl1keep, [%1, 448]          \n"
+      "st1         {v2.8h, v3.8h}, [%2], #32     \n"  // store 8 UV pixels
+      "b.gt        1b                            \n"
+      : "+r"(src_u),   // %0
+        "+r"(src_v),   // %1
+        "+r"(dst_uv),  // %2
+        "+r"(width)    // %3
+      : "r"(shift)     // %4
+      : "cc", "memory", "v0", "v1", "v2", "v1", "v2", "v3", "v4");
+}
+#endif  // LIBYUV_USE_ST2
+
+// Reads 16 packed RGB and write to planar dst_r, dst_g, dst_b.
+void SplitRGBRow_NEON(const uint8_t* src_rgb,
+                      uint8_t* dst_r,
+                      uint8_t* dst_g,
+                      uint8_t* dst_b,
+                      int width) {
+  asm volatile(
+      "1:                                        \n"
+      "ld3         {v0.16b,v1.16b,v2.16b}, [%0], #48 \n"  // load 16 RGB
+      "subs        %w4, %w4, #16                 \n"  // 16 processed per loop
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "st1         {v0.16b}, [%1], #16           \n"  // store R
+      "st1         {v1.16b}, [%2], #16           \n"  // store G
+      "st1         {v2.16b}, [%3], #16           \n"  // store B
+      "b.gt        1b                            \n"
+      : "+r"(src_rgb),                    // %0
+        "+r"(dst_r),                      // %1
+        "+r"(dst_g),                      // %2
+        "+r"(dst_b),                      // %3
+        "+r"(width)                       // %4
+      :                                   // Input registers
+      : "cc", "memory", "v0", "v1", "v2"  // Clobber List
+  );
+}
+
+// Reads 16 planar R's, G's and B's and writes out 16 packed RGB at a time
+void MergeRGBRow_NEON(const uint8_t* src_r,
+                      const uint8_t* src_g,
+                      const uint8_t* src_b,
+                      uint8_t* dst_rgb,
+                      int width) {
+  asm volatile(
+      "1:                                        \n"
+      "ld1         {v0.16b}, [%0], #16           \n"  // load R
+      "ld1         {v1.16b}, [%1], #16           \n"  // load G
+      "ld1         {v2.16b}, [%2], #16           \n"  // load B
+      "subs        %w4, %w4, #16                 \n"  // 16 processed per loop
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "prfm        pldl1keep, [%1, 448]          \n"
+      "prfm        pldl1keep, [%2, 448]          \n"
+      "st3         {v0.16b,v1.16b,v2.16b}, [%3], #48 \n"  // store 16 RGB
+      "b.gt        1b                            \n"
+      : "+r"(src_r),                      // %0
+        "+r"(src_g),                      // %1
+        "+r"(src_b),                      // %2
+        "+r"(dst_rgb),                    // %3
+        "+r"(width)                       // %4
+      :                                   // Input registers
+      : "cc", "memory", "v0", "v1", "v2"  // Clobber List
+  );
+}
+
+// Reads 16 packed ARGB and write to planar dst_r, dst_g, dst_b, dst_a.
+void SplitARGBRow_NEON(const uint8_t* src_rgba,
+                       uint8_t* dst_r,
+                       uint8_t* dst_g,
+                       uint8_t* dst_b,
+                       uint8_t* dst_a,
+                       int width) {
+  asm volatile(
+      "1:                                        \n"
+      "ld4         {v0.16b,v1.16b,v2.16b,v3.16b}, [%0], #64 \n"  // load 16 ARGB
+      "subs        %w5, %w5, #16                 \n"  // 16 processed per loop
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "st1         {v0.16b}, [%3], #16           \n"  // store B
+      "st1         {v1.16b}, [%2], #16           \n"  // store G
+      "st1         {v2.16b}, [%1], #16           \n"  // store R
+      "st1         {v3.16b}, [%4], #16           \n"  // store A
+      "b.gt        1b                            \n"
+      : "+r"(src_rgba),                         // %0
+        "+r"(dst_r),                            // %1
+        "+r"(dst_g),                            // %2
+        "+r"(dst_b),                            // %3
+        "+r"(dst_a),                            // %4
+        "+r"(width)                             // %5
+      :                                         // Input registers
+      : "cc", "memory", "v0", "v1", "v2", "v3"  // Clobber List
+  );
+}
+
+#if LIBYUV_USE_ST4
+// Reads 16 planar R's, G's, B's and A's and writes out 16 packed ARGB at a time
+void MergeARGBRow_NEON(const uint8_t* src_r,
+                       const uint8_t* src_g,
+                       const uint8_t* src_b,
+                       const uint8_t* src_a,
+                       uint8_t* dst_argb,
+                       int width) {
+  asm volatile(
+      "1:                                        \n"
+      "ld1         {v0.16b}, [%2], #16           \n"  // load B
+      "ld1         {v1.16b}, [%1], #16           \n"  // load G
+      "ld1         {v2.16b}, [%0], #16           \n"  // load R
+      "ld1         {v3.16b}, [%3], #16           \n"  // load A
+      "subs        %w5, %w5, #16                 \n"  // 16 processed per loop
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "prfm        pldl1keep, [%1, 448]          \n"
+      "prfm        pldl1keep, [%2, 448]          \n"
+      "prfm        pldl1keep, [%3, 448]          \n"
+      "st4         {v0.16b,v1.16b,v2.16b,v3.16b}, [%4], #64 \n"  // store 16ARGB
+      "b.gt        1b                            \n"
+      : "+r"(src_r),                            // %0
+        "+r"(src_g),                            // %1
+        "+r"(src_b),                            // %2
+        "+r"(src_a),                            // %3
+        "+r"(dst_argb),                         // %4
+        "+r"(width)                             // %5
+      :                                         // Input registers
+      : "cc", "memory", "v0", "v1", "v2", "v3"  // Clobber List
+  );
+}
+#else
+// Reads 16 planar R's, G's, B's and A's and writes out 16 packed ARGB at a time
+void MergeARGBRow_NEON(const uint8_t* src_r,
+                       const uint8_t* src_g,
+                       const uint8_t* src_b,
+                       const uint8_t* src_a,
+                       uint8_t* dst_argb,
+                       int width) {
+  asm volatile(
+      "1:                                        \n"
+      "ld1         {v0.16b}, [%2], #16           \n"  // load B
+      "ld1         {v1.16b}, [%1], #16           \n"  // load G
+      "ld1         {v2.16b}, [%0], #16           \n"  // load R
+      "ld1         {v3.16b}, [%3], #16           \n"  // load A
+      "subs        %w5, %w5, #16                 \n"  // 16 processed per loop
+      "prfm        pldl1keep, [%2, 448]          \n"
+      "zip1        v4.16b, v0.16b, v1.16b        \n"  // BG
+      "zip1        v5.16b, v2.16b, v3.16b        \n"  // RA
+      "prfm        pldl1keep, [%1, 448]          \n"
+      "zip2        v6.16b, v0.16b, v1.16b        \n"  // BG
+      "zip2        v7.16b, v2.16b, v3.16b        \n"  // RA
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "zip1        v0.8h, v4.8h, v5.8h           \n"  // BGRA
+      "zip2        v1.8h, v4.8h, v5.8h           \n"
+      "prfm        pldl1keep, [%3, 448]          \n"
+      "zip1        v2.8h, v6.8h, v7.8h           \n"
+      "zip2        v3.8h, v6.8h, v7.8h           \n"
+      "st1         {v0.16b,v1.16b,v2.16b,v3.16b}, [%4], #64 \n"  // store 16ARGB
+      "b.gt        1b                            \n"
+      : "+r"(src_r),     // %0
+        "+r"(src_g),     // %1
+        "+r"(src_b),     // %2
+        "+r"(src_a),     // %3
+        "+r"(dst_argb),  // %4
+        "+r"(width)      // %5
+      :                  // Input registers
+      : "cc", "memory", "v0", "v1", "v2", "v3", "v4", "v5", "v6",
+        "v7"  // Clobber List
+  );
+}
+#endif  // LIBYUV_USE_ST4
+
+// Reads 16 packed ARGB and write to planar dst_r, dst_g, dst_b.
+void SplitXRGBRow_NEON(const uint8_t* src_rgba,
+                       uint8_t* dst_r,
+                       uint8_t* dst_g,
+                       uint8_t* dst_b,
+                       int width) {
+  asm volatile(
+      "1:                                        \n"
+      "ld4         {v0.16b,v1.16b,v2.16b,v3.16b}, [%0], #64 \n"  // load 16 ARGB
+      "subs        %w4, %w4, #16                 \n"  // 16 processed per loop
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "st1         {v0.16b}, [%3], #16           \n"  // store B
+      "st1         {v1.16b}, [%2], #16           \n"  // store G
+      "st1         {v2.16b}, [%1], #16           \n"  // store R
+      "b.gt        1b                            \n"
+      : "+r"(src_rgba),                         // %0
+        "+r"(dst_r),                            // %1
+        "+r"(dst_g),                            // %2
+        "+r"(dst_b),                            // %3
+        "+r"(width)                             // %4
+      :                                         // Input registers
+      : "cc", "memory", "v0", "v1", "v2", "v3"  // Clobber List
+  );
+}
+
+// Reads 16 planar R's, G's and B's and writes out 16 packed ARGB at a time
+void MergeXRGBRow_NEON(const uint8_t* src_r,
+                       const uint8_t* src_g,
+                       const uint8_t* src_b,
+                       uint8_t* dst_argb,
+                       int width) {
+  asm volatile(
+      "movi        v3.16b, #255                  \n"  // load A(255)
+      "1:                                        \n"
+      "ld1         {v2.16b}, [%0], #16           \n"  // load R
+      "ld1         {v1.16b}, [%1], #16           \n"  // load G
+      "ld1         {v0.16b}, [%2], #16           \n"  // load B
+      "subs        %w4, %w4, #16                 \n"  // 16 processed per loop
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "prfm        pldl1keep, [%1, 448]          \n"
+      "prfm        pldl1keep, [%2, 448]          \n"
+      "st4         {v0.16b,v1.16b,v2.16b,v3.16b}, [%3], #64 \n"  // store 16ARGB
+      "b.gt        1b                            \n"
+      : "+r"(src_r),                            // %0
+        "+r"(src_g),                            // %1
+        "+r"(src_b),                            // %2
+        "+r"(dst_argb),                         // %3
+        "+r"(width)                             // %4
+      :                                         // Input registers
+      : "cc", "memory", "v0", "v1", "v2", "v3"  // Clobber List
+  );
+}
+
+void MergeXR30Row_NEON(const uint16_t* src_r,
+                       const uint16_t* src_g,
+                       const uint16_t* src_b,
+                       uint8_t* dst_ar30,
+                       int depth,
+                       int width) {
+  int shift = 10 - depth;
+  asm volatile(
+      "movi        v30.16b, #255                 \n"
+      "ushr        v30.4s, v30.4s, #22           \n"  // 1023
+      "dup         v31.4s, %w5                   \n"
+      "1:                                        \n"
+      "ldr         d2, [%2], #8                  \n"  // B
+      "ldr         d1, [%1], #8                  \n"  // G
+      "ldr         d0, [%0], #8                  \n"  // R
+      "ushll       v2.4s, v2.4h, #0              \n"  // B
+      "ushll       v1.4s, v1.4h, #0              \n"  // G
+      "ushll       v0.4s, v0.4h, #0              \n"  // R
+      "ushl        v2.4s, v2.4s, v31.4s          \n"  // 000B
+      "ushl        v1.4s, v1.4s, v31.4s          \n"  // G
+      "ushl        v0.4s, v0.4s, v31.4s          \n"  // R
+      "umin        v2.4s, v2.4s, v30.4s          \n"
+      "umin        v1.4s, v1.4s, v30.4s          \n"
+      "umin        v0.4s, v0.4s, v30.4s          \n"
+      "sli         v2.4s, v1.4s, #10             \n"  // 00GB
+      "sli         v2.4s, v0.4s, #20             \n"  // 0RGB
+      "orr         v2.4s, #0xc0, lsl #24         \n"  // ARGB (AR30)
+      "subs        %w4, %w4, #4                  \n"
+      "str         q2, [%3], #16                 \n"
+      "b.gt        1b                            \n"
+      : "+r"(src_r),     // %0
+        "+r"(src_g),     // %1
+        "+r"(src_b),     // %2
+        "+r"(dst_ar30),  // %3
+        "+r"(width)      // %4
+      : "r"(shift)       // %5
+      : "memory", "cc", "v0", "v1", "v2", "v30", "v31");
+}
+
+void MergeXR30Row_10_NEON(const uint16_t* src_r,
+                          const uint16_t* src_g,
+                          const uint16_t* src_b,
+                          uint8_t* dst_ar30,
+                          int /* depth */,
+                          int width) {
+  asm volatile(
+      "movi        v30.16b, #255                 \n"
+      "ushr        v30.4s, v30.4s, #22           \n"  // 1023
+      "1:                                        \n"
+      "ldr         d2, [%2], #8                  \n"  // B
+      "ldr         d1, [%1], #8                  \n"  // G
+      "ldr         d0, [%0], #8                  \n"  // R
+      "ushll       v2.4s, v2.4h, #0              \n"  // 000B
+      "ushll       v1.4s, v1.4h, #0              \n"  // G
+      "ushll       v0.4s, v0.4h, #0              \n"  // R
+      "umin        v2.4s, v2.4s, v30.4s          \n"
+      "umin        v1.4s, v1.4s, v30.4s          \n"
+      "umin        v0.4s, v0.4s, v30.4s          \n"
+      "sli         v2.4s, v1.4s, #10             \n"  // 00GB
+      "sli         v2.4s, v0.4s, #20             \n"  // 0RGB
+      "orr         v2.4s, #0xc0, lsl #24         \n"  // ARGB (AR30)
+      "subs        %w4, %w4, #4                  \n"
+      "str         q2, [%3], #16                 \n"
+      "b.gt        1b                            \n"
+      : "+r"(src_r),     // %0
+        "+r"(src_g),     // %1
+        "+r"(src_b),     // %2
+        "+r"(dst_ar30),  // %3
+        "+r"(width)      // %4
+      :
+      : "memory", "cc", "v0", "v1", "v2", "v30");
+}
+
+void MergeAR64Row_NEON(const uint16_t* src_r,
+                       const uint16_t* src_g,
+                       const uint16_t* src_b,
+                       const uint16_t* src_a,
+                       uint16_t* dst_ar64,
+                       int depth,
+                       int width) {
+  int shift = 16 - depth;
+  int mask = (1 << depth) - 1;
+  asm volatile(
+
+      "dup         v30.8h, %w7                   \n"
+      "dup         v31.8h, %w6                   \n"
+      "1:                                        \n"
+      "ldr         q2, [%0], #16                 \n"  // R
+      "ldr         q1, [%1], #16                 \n"  // G
+      "ldr         q0, [%2], #16                 \n"  // B
+      "ldr         q3, [%3], #16                 \n"  // A
+      "umin        v2.8h, v2.8h, v30.8h          \n"
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "umin        v1.8h, v1.8h, v30.8h          \n"
+      "prfm        pldl1keep, [%1, 448]          \n"
+      "umin        v0.8h, v0.8h, v30.8h          \n"
+      "prfm        pldl1keep, [%2, 448]          \n"
+      "umin        v3.8h, v3.8h, v30.8h          \n"
+      "prfm        pldl1keep, [%3, 448]          \n"
+      "ushl        v2.8h, v2.8h, v31.8h          \n"
+      "ushl        v1.8h, v1.8h, v31.8h          \n"
+      "ushl        v0.8h, v0.8h, v31.8h          \n"
+      "ushl        v3.8h, v3.8h, v31.8h          \n"
+      "subs        %w5, %w5, #8                  \n"
+      "st4         {v0.8h, v1.8h, v2.8h, v3.8h}, [%4], #64 \n"
+      "b.gt        1b                            \n"
+      : "+r"(src_r),     // %0
+        "+r"(src_g),     // %1
+        "+r"(src_b),     // %2
+        "+r"(src_a),     // %3
+        "+r"(dst_ar64),  // %4
+        "+r"(width)      // %5
+      : "r"(shift),      // %6
+        "r"(mask)        // %7
+      : "memory", "cc", "v0", "v1", "v2", "v3", "v31");
+}
+
+void MergeXR64Row_NEON(const uint16_t* src_r,
+                       const uint16_t* src_g,
+                       const uint16_t* src_b,
+                       uint16_t* dst_ar64,
+                       int depth,
+                       int width) {
+  int shift = 16 - depth;
+  int mask = (1 << depth) - 1;
+  asm volatile(
+
+      "movi        v3.16b, #0xff                 \n"  // A (0xffff)
+      "dup         v30.8h, %w6                   \n"
+      "dup         v31.8h, %w5                   \n"
+
+      "1:                                        \n"
+      "ldr         q2, [%0], #16                 \n"  // R
+      "ldr         q1, [%1], #16                 \n"  // G
+      "ldr         q0, [%2], #16                 \n"  // B
+      "umin        v2.8h, v2.8h, v30.8h          \n"
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "umin        v1.8h, v1.8h, v30.8h          \n"
+      "prfm        pldl1keep, [%1, 448]          \n"
+      "umin        v0.8h, v0.8h, v30.8h          \n"
+      "prfm        pldl1keep, [%2, 448]          \n"
+      "ushl        v2.8h, v2.8h, v31.8h          \n"
+      "ushl        v1.8h, v1.8h, v31.8h          \n"
+      "ushl        v0.8h, v0.8h, v31.8h          \n"
+      "subs        %w4, %w4, #8                  \n"
+      "st4         {v0.8h, v1.8h, v2.8h, v3.8h}, [%3], #64 \n"
+      "b.gt        1b                            \n"
+      : "+r"(src_r),     // %0
+        "+r"(src_g),     // %1
+        "+r"(src_b),     // %2
+        "+r"(dst_ar64),  // %3
+        "+r"(width)      // %4
+      : "r"(shift),      // %5
+        "r"(mask)        // %6
+      : "memory", "cc", "v0", "v1", "v2", "v3", "v31");
+}
+
+void MergeARGB16To8Row_NEON(const uint16_t* src_r,
+                            const uint16_t* src_g,
+                            const uint16_t* src_b,
+                            const uint16_t* src_a,
+                            uint8_t* dst_argb,
+                            int depth,
+                            int width) {
+  int shift = 8 - depth;
+  asm volatile(
+
+      "dup         v31.8h, %w6                   \n"
+      "1:                                        \n"
+      "ldr         q2, [%0], #16                 \n"  // R
+      "ldr         q1, [%1], #16                 \n"  // G
+      "ldr         q0, [%2], #16                 \n"  // B
+      "ldr         q3, [%3], #16                 \n"  // A
+      "ushl        v2.8h, v2.8h, v31.8h          \n"
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "ushl        v1.8h, v1.8h, v31.8h          \n"
+      "prfm        pldl1keep, [%1, 448]          \n"
+      "ushl        v0.8h, v0.8h, v31.8h          \n"
+      "prfm        pldl1keep, [%2, 448]          \n"
+      "ushl        v3.8h, v3.8h, v31.8h          \n"
+      "prfm        pldl1keep, [%3, 448]          \n"
+      "uqxtn       v2.8b, v2.8h                  \n"
+      "uqxtn       v1.8b, v1.8h                  \n"
+      "uqxtn       v0.8b, v0.8h                  \n"
+      "uqxtn       v3.8b, v3.8h                  \n"
+      "subs        %w5, %w5, #8                  \n"
+      "st4         {v0.8b, v1.8b, v2.8b, v3.8b}, [%4], #32 \n"
+      "b.gt        1b                            \n"
+      : "+r"(src_r),     // %0
+        "+r"(src_g),     // %1
+        "+r"(src_b),     // %2
+        "+r"(src_a),     // %3
+        "+r"(dst_argb),  // %4
+        "+r"(width)      // %5
+      : "r"(shift)       // %6
+      : "memory", "cc", "v0", "v1", "v2", "v3", "v31");
+}
+
+void MergeXRGB16To8Row_NEON(const uint16_t* src_r,
+                            const uint16_t* src_g,
+                            const uint16_t* src_b,
+                            uint8_t* dst_argb,
+                            int depth,
+                            int width) {
+  int shift = 8 - depth;
+  asm volatile(
+
+      "dup         v31.8h, %w5                   \n"
+      "movi        v3.8b, #0xff                  \n"  // A (0xff)
+      "1:                                        \n"
+      "ldr         q2, [%0], #16                 \n"  // R
+      "ldr         q1, [%1], #16                 \n"  // G
+      "ldr         q0, [%2], #16                 \n"  // B
+      "ushl        v2.8h, v2.8h, v31.8h          \n"
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "ushl        v1.8h, v1.8h, v31.8h          \n"
+      "prfm        pldl1keep, [%1, 448]          \n"
+      "ushl        v0.8h, v0.8h, v31.8h          \n"
+      "prfm        pldl1keep, [%2, 448]          \n"
+      "uqxtn       v2.8b, v2.8h                  \n"
+      "uqxtn       v1.8b, v1.8h                  \n"
+      "uqxtn       v0.8b, v0.8h                  \n"
+      "subs        %w4, %w4, #8                  \n"
+      "st4         {v0.8b, v1.8b, v2.8b, v3.8b}, [%3], #32 \n"
+      "b.gt        1b                            \n"
+      : "+r"(src_r),     // %0
+        "+r"(src_g),     // %1
+        "+r"(src_b),     // %2
+        "+r"(dst_argb),  // %3
+        "+r"(width)      // %4
+      : "r"(shift)       // %5
+      : "memory", "cc", "v0", "v1", "v2", "v3", "v31");
+}
+
+// Copy multiple of 32.
+void CopyRow_NEON(const uint8_t* src, uint8_t* dst, int width) {
+  asm volatile(
+      "1:                                        \n"
+      "ldp         q0, q1, [%0], #32             \n"
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "subs        %w2, %w2, #32                 \n"  // 32 processed per loop
+      "stp         q0, q1, [%1], #32             \n"
+      "b.gt        1b                            \n"
+      : "+r"(src),                  // %0
+        "+r"(dst),                  // %1
+        "+r"(width)                 // %2  // Output registers
+      :                             // Input registers
+      : "cc", "memory", "v0", "v1"  // Clobber List
+  );
+}
+
+// SetRow writes 'width' bytes using an 8 bit value repeated.
+void SetRow_NEON(uint8_t* dst, uint8_t v8, int width) {
+  asm volatile(
+      "dup         v0.16b, %w2                   \n"  // duplicate 16 bytes
+      "1:                                        \n"
+      "subs        %w1, %w1, #16                 \n"  // 16 bytes per loop
+      "st1         {v0.16b}, [%0], #16           \n"  // store
+      "b.gt        1b                            \n"
+      : "+r"(dst),   // %0
+        "+r"(width)  // %1
+      : "r"(v8)      // %2
+      : "cc", "memory", "v0");
+}
+
+void ARGBSetRow_NEON(uint8_t* dst, uint32_t v32, int width) {
+  asm volatile(
+      "dup         v0.4s, %w2                    \n"  // duplicate 4 ints
+      "1:                                        \n"
+      "subs        %w1, %w1, #4                  \n"  // 4 ints per loop
+      "st1         {v0.16b}, [%0], #16           \n"  // store
+      "b.gt        1b                            \n"
+      : "+r"(dst),   // %0
+        "+r"(width)  // %1
+      : "r"(v32)     // %2
+      : "cc", "memory", "v0");
+}
+
+// Shuffle table for reversing the bytes.
+static const uvec8 kShuffleMirror = {15u, 14u, 13u, 12u, 11u, 10u, 9u, 8u,
+                                     7u,  6u,  5u,  4u,  3u,  2u,  1u, 0u};
+
+void MirrorRow_NEON(const uint8_t* src, uint8_t* dst, int width) {
+  asm volatile(
+      // Start at end of source row.
+      "ld1         {v3.16b}, [%3]                \n"  // shuffler
+      "add         %0, %0, %w2, sxtw             \n"
+      "sub         %0, %0, #32                   \n"
+      "1:                                        \n"
+      "ldr         q2, [%0, 16]                  \n"
+      "ldr         q1, [%0], -32                 \n"  // src -= 32
+      "subs        %w2, %w2, #32                 \n"  // 32 pixels per loop.
+      "tbl         v0.16b, {v2.16b}, v3.16b      \n"
+      "tbl         v1.16b, {v1.16b}, v3.16b      \n"
+      "st1         {v0.16b, v1.16b}, [%1], #32   \n"  // store 32 pixels
+      "b.gt        1b                            \n"
+      : "+r"(src),            // %0
+        "+r"(dst),            // %1
+        "+r"(width)           // %2
+      : "r"(&kShuffleMirror)  // %3
+      : "cc", "memory", "v0", "v1", "v2", "v3");
+}
+
+// Shuffle table for reversing the UV.
+static const uvec8 kShuffleMirrorUV = {14u, 15u, 12u, 13u, 10u, 11u, 8u, 9u,
+                                       6u,  7u,  4u,  5u,  2u,  3u,  0u, 1u};
+
+void MirrorUVRow_NEON(const uint8_t* src_uv, uint8_t* dst_uv, int width) {
+  asm volatile(
+      // Start at end of source row.
+      "ld1         {v4.16b}, [%3]                \n"  // shuffler
+      "add         %0, %0, %w2, sxtw #1          \n"
+      "sub         %0, %0, #32                   \n"
+      "1:                                        \n"
+      "ldr         q1, [%0, 16]                  \n"
+      "ldr         q0, [%0], -32                 \n"  // src -= 32
+      "subs        %w2, %w2, #16                 \n"  // 16 pixels per loop.
+      "tbl         v2.16b, {v1.16b}, v4.16b      \n"
+      "tbl         v3.16b, {v0.16b}, v4.16b      \n"
+      "st1         {v2.16b, v3.16b}, [%1], #32   \n"  // dst += 32
+      "b.gt        1b                            \n"
+      : "+r"(src_uv),           // %0
+        "+r"(dst_uv),           // %1
+        "+r"(width)             // %2
+      : "r"(&kShuffleMirrorUV)  // %3
+      : "cc", "memory", "v0", "v1", "v2", "v3", "v4");
+}
+
+void MirrorSplitUVRow_NEON(const uint8_t* src_uv,
+                           uint8_t* dst_u,
+                           uint8_t* dst_v,
+                           int width) {
+  asm volatile(
+      // Start at end of source row.
+      "ld1         {v4.16b}, [%4]                \n"  // shuffler
+      "add         %0, %0, %w3, sxtw #1          \n"
+      "sub         %0, %0, #32                   \n"
+      "1:                                        \n"
+      "ldr         q1, [%0, 16]                  \n"
+      "ldr         q0, [%0], -32                 \n"  // src -= 32
+      "subs        %w3, %w3, #16                 \n"  // 16 pixels per loop.
+      "tbl         v2.16b, {v1.16b}, v4.16b      \n"
+      "tbl         v3.16b, {v0.16b}, v4.16b      \n"
+      "uzp1        v0.16b, v2.16b, v3.16b        \n"  // U
+      "uzp2        v1.16b, v2.16b, v3.16b        \n"  // V
+      "st1         {v0.16b}, [%1], #16           \n"  // dst += 16
+      "st1         {v1.16b}, [%2], #16           \n"
+      "b.gt        1b                            \n"
+      : "+r"(src_uv),           // %0
+        "+r"(dst_u),            // %1
+        "+r"(dst_v),            // %2
+        "+r"(width)             // %3
+      : "r"(&kShuffleMirrorUV)  // %4
+      : "cc", "memory", "v0", "v1", "v2", "v3", "v4");
+}
+
+// Shuffle table for reversing the ARGB.
+static const uvec8 kShuffleMirrorARGB = {12u, 13u, 14u, 15u, 8u, 9u, 10u, 11u,
+                                         4u,  5u,  6u,  7u,  0u, 1u, 2u,  3u};
+
+void ARGBMirrorRow_NEON(const uint8_t* src_argb, uint8_t* dst_argb, int width) {
+  asm volatile(
+      // Start at end of source row.
+      "ld1         {v4.16b}, [%3]                \n"  // shuffler
+      "add         %0, %0, %w2, sxtw #2          \n"
+      "sub         %0, %0, #32                   \n"
+      "1:                                        \n"
+      "ldr         q1, [%0, 16]                  \n"
+      "ldr         q0, [%0], -32                 \n"  // src -= 32
+      "subs        %w2, %w2, #8                  \n"  // 8 pixels per loop.
+      "tbl         v2.16b, {v1.16b}, v4.16b      \n"
+      "tbl         v3.16b, {v0.16b}, v4.16b      \n"
+      "st1         {v2.16b, v3.16b}, [%1], #32   \n"  // dst += 32
+      "b.gt        1b                            \n"
+      : "+r"(src_argb),           // %0
+        "+r"(dst_argb),           // %1
+        "+r"(width)               // %2
+      : "r"(&kShuffleMirrorARGB)  // %3
+      : "cc", "memory", "v0", "v1", "v2", "v3", "v4");
+}
+
+void RGB24MirrorRow_NEON(const uint8_t* src_rgb24,
+                         uint8_t* dst_rgb24,
+                         int width) {
+  asm volatile(
+      "ld1         {v3.16b}, [%4]                \n"  // shuffler
+      "add         %0, %0, %w2, sxtw #1          \n"  // Start at end of row.
+      "add         %0, %0, %w2, sxtw             \n"
+      "sub         %0, %0, #48                   \n"
+
+      "1:                                        \n"
+      "ld3         {v0.16b, v1.16b, v2.16b}, [%0], %3 \n"  // src -= 48
+      "subs        %w2, %w2, #16                 \n"  // 16 pixels per loop.
+      "tbl         v0.16b, {v0.16b}, v3.16b      \n"
+      "tbl         v1.16b, {v1.16b}, v3.16b      \n"
+      "tbl         v2.16b, {v2.16b}, v3.16b      \n"
+      "st3         {v0.16b, v1.16b, v2.16b}, [%1], #48 \n"  // dst += 48
+      "b.gt        1b                            \n"
+      : "+r"(src_rgb24),      // %0
+        "+r"(dst_rgb24),      // %1
+        "+r"(width)           // %2
+      : "r"((ptrdiff_t)-48),  // %3
+        "r"(&kShuffleMirror)  // %4
+      : "cc", "memory", "v0", "v1", "v2", "v3");
+}
+
+void RGB24ToARGBRow_NEON(const uint8_t* src_rgb24,
+                         uint8_t* dst_argb,
+                         int width) {
+  asm volatile(
+      "movi        v4.8b, #255                   \n"  // Alpha
+      "1:                                        \n"
+      "ld3         {v1.8b,v2.8b,v3.8b}, [%0], #24 \n"  // load 8 pixels of
+                                                       // RGB24.
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "subs        %w2, %w2, #8                  \n"  // 8 processed per loop.
+      "st4         {v1.8b,v2.8b,v3.8b,v4.8b}, [%1], #32 \n"  // store 8 ARGB
+      "b.gt        1b                            \n"
+      : "+r"(src_rgb24),  // %0
+        "+r"(dst_argb),   // %1
+        "+r"(width)       // %2
+      :
+      : "cc", "memory", "v1", "v2", "v3", "v4"  // Clobber List
+  );
+}
+
+void RAWToARGBRow_NEON(const uint8_t* src_raw, uint8_t* dst_argb, int width) {
+  asm volatile(
+      "movi        v5.8b, #255                   \n"  // Alpha
+      "1:                                        \n"
+      "ld3         {v0.8b,v1.8b,v2.8b}, [%0], #24 \n"  // read r g b
+      "subs        %w2, %w2, #8                  \n"   // 8 processed per loop.
+      "orr         v3.8b, v1.8b, v1.8b           \n"   // move g
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "orr         v4.8b, v0.8b, v0.8b           \n"         // move r
+      "st4         {v2.8b,v3.8b,v4.8b,v5.8b}, [%1], #32 \n"  // store b g r a
+      "b.gt        1b                            \n"
+      : "+r"(src_raw),   // %0
+        "+r"(dst_argb),  // %1
+        "+r"(width)      // %2
+      :
+      : "cc", "memory", "v0", "v1", "v2", "v3", "v4", "v5"  // Clobber List
+  );
+}
+
+void RAWToRGBARow_NEON(const uint8_t* src_raw, uint8_t* dst_rgba, int width) {
+  asm volatile(
+      "movi        v0.8b, #255                   \n"  // Alpha
+      "1:                                        \n"
+      "ld3         {v3.8b,v4.8b,v5.8b}, [%0], #24 \n"  // read r g b
+      "subs        %w2, %w2, #8                  \n"   // 8 processed per loop.
+      "orr         v2.8b, v4.8b, v4.8b           \n"   // move g
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "orr         v1.8b, v5.8b, v5.8b           \n"         // move r
+      "st4         {v0.8b,v1.8b,v2.8b,v3.8b}, [%1], #32 \n"  // store a b g r
+      "b.gt        1b                            \n"
+      : "+r"(src_raw),   // %0
+        "+r"(dst_rgba),  // %1
+        "+r"(width)      // %2
+      :
+      : "cc", "memory", "v0", "v1", "v2", "v3", "v4", "v5"  // Clobber List
+  );
+}
+
+void RAWToRGB24Row_NEON(const uint8_t* src_raw, uint8_t* dst_rgb24, int width) {
+  asm volatile(
+      "1:                                        \n"
+      "ld3         {v0.8b,v1.8b,v2.8b}, [%0], #24 \n"  // read r g b
+      "subs        %w2, %w2, #8                  \n"   // 8 processed per loop.
+      "orr         v3.8b, v1.8b, v1.8b           \n"   // move g
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "orr         v4.8b, v0.8b, v0.8b           \n"   // move r
+      "st3         {v2.8b,v3.8b,v4.8b}, [%1], #24 \n"  // store b g r
+      "b.gt        1b                            \n"
+      : "+r"(src_raw),    // %0
+        "+r"(dst_rgb24),  // %1
+        "+r"(width)       // %2
+      :
+      : "cc", "memory", "v0", "v1", "v2", "v3", "v4"  // Clobber List
+  );
+}
+
+#define RGB565TOARGB                                                        \
+  "shrn       v6.8b, v0.8h, #5               \n" /* G xxGGGGGG           */ \
+  "shl        v6.8b, v6.8b, #2               \n" /* G GGGGGG00 upper 6   */ \
+  "ushr       v4.8b, v6.8b, #6               \n" /* G 000000GG lower 2   */ \
+  "orr        v1.8b, v4.8b, v6.8b            \n" /* G                    */ \
+  "xtn        v2.8b, v0.8h                   \n" /* B xxxBBBBB           */ \
+  "ushr       v0.8h, v0.8h, #11              \n" /* R 000RRRRR           */ \
+  "xtn2       v2.16b,v0.8h                   \n" /* R in upper part      */ \
+  "shl        v2.16b, v2.16b, #3             \n" /* R,B BBBBB000 upper 5 */ \
+  "ushr       v0.16b, v2.16b, #5             \n" /* R,B 00000BBB lower 3 */ \
+  "orr        v0.16b, v0.16b, v2.16b         \n" /* R,B                  */ \
+  "dup        v2.2D, v0.D[1]                 \n" /* R                    */
+
+void RGB565ToARGBRow_NEON(const uint8_t* src_rgb565,
+                          uint8_t* dst_argb,
+                          int width) {
+  asm volatile(
+      "movi        v3.8b, #255                   \n"  // Alpha
+      "1:                                        \n"
+      "ld1         {v0.16b}, [%0], #16           \n"  // load 8 RGB565 pixels.
+      "subs        %w2, %w2, #8                  \n"  // 8 processed per loop.
+      "prfm        pldl1keep, [%0, 448]          \n" RGB565TOARGB
+      "st4         {v0.8b,v1.8b,v2.8b,v3.8b}, [%1], #32 \n"  // store 8 ARGB
+      "b.gt        1b                            \n"
+      : "+r"(src_rgb565),  // %0
+        "+r"(dst_argb),    // %1
+        "+r"(width)        // %2
+      :
+      : "cc", "memory", "v0", "v1", "v2", "v3", "v4", "v6"  // Clobber List
+  );
+}
+
+#define ARGB1555TOARGB                                                      \
+  "ushr       v2.8h, v0.8h, #10              \n" /* R xxxRRRRR           */ \
+  "shl        v2.8h, v2.8h, #3               \n" /* R RRRRR000 upper 5   */ \
+  "xtn        v3.8b, v2.8h                   \n" /* RRRRR000 AAAAAAAA    */ \
+                                                                            \
+  "sshr       v2.8h, v0.8h, #15              \n" /* A AAAAAAAA           */ \
+  "xtn2       v3.16b, v2.8h                  \n"                            \
+                                                                            \
+  "xtn        v2.8b, v0.8h                   \n" /* B xxxBBBBB           */ \
+  "shrn2      v2.16b,v0.8h, #5               \n" /* G xxxGGGGG           */ \
+                                                                            \
+  "ushr       v1.16b, v3.16b, #5             \n" /* R,A 00000RRR lower 3 */ \
+  "shl        v0.16b, v2.16b, #3             \n" /* B,G BBBBB000 upper 5 */ \
+  "ushr       v2.16b, v0.16b, #5             \n" /* B,G 00000BBB lower 3 */ \
+                                                                            \
+  "orr        v0.16b, v0.16b, v2.16b         \n" /* B,G                  */ \
+  "orr        v2.16b, v1.16b, v3.16b         \n" /* R,A                  */ \
+  "dup        v1.2D, v0.D[1]                 \n"                            \
+  "dup        v3.2D, v2.D[1]                 \n"
+
+// RGB555TOARGB is same as ARGB1555TOARGB but ignores alpha.
+#define RGB555TOARGB                                                        \
+  "ushr       v2.8h, v0.8h, #10              \n" /* R xxxRRRRR           */ \
+  "shl        v2.8h, v2.8h, #3               \n" /* R RRRRR000 upper 5   */ \
+  "xtn        v3.8b, v2.8h                   \n" /* RRRRR000             */ \
+                                                                            \
+  "xtn        v2.8b, v0.8h                   \n" /* B xxxBBBBB           */ \
+  "shrn2      v2.16b,v0.8h, #5               \n" /* G xxxGGGGG           */ \
+                                                                            \
+  "ushr       v1.16b, v3.16b, #5             \n" /* R   00000RRR lower 3 */ \
+  "shl        v0.16b, v2.16b, #3             \n" /* B,G BBBBB000 upper 5 */ \
+  "ushr       v2.16b, v0.16b, #5             \n" /* B,G 00000BBB lower 3 */ \
+                                                                            \
+  "orr        v0.16b, v0.16b, v2.16b         \n" /* B,G                  */ \
+  "orr        v2.16b, v1.16b, v3.16b         \n" /* R                    */ \
+  "dup        v1.2D, v0.D[1]                 \n" /* G */
+
+void ARGB1555ToARGBRow_NEON(const uint8_t* src_argb1555,
+                            uint8_t* dst_argb,
+                            int width) {
+  asm volatile(
+      "movi        v3.8b, #255                   \n"  // Alpha
+      "1:                                        \n"
+      "ld1         {v0.16b}, [%0], #16           \n"  // load 8 ARGB1555 pixels.
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "subs        %w2, %w2, #8                  \n"  // 8 processed per loop.
+      ARGB1555TOARGB
+      "st4         {v0.8b,v1.8b,v2.8b,v3.8b}, [%1], #32 \n"  // store 8 ARGB
+      "b.gt        1b                            \n"
+      : "+r"(src_argb1555),  // %0
+        "+r"(dst_argb),      // %1
+        "+r"(width)          // %2
+      :
+      : "cc", "memory", "v0", "v1", "v2", "v3"  // Clobber List
+  );
+}
+
+// Convert v0.8h to b = v0.8b g = v1.8b r = v2.8b
+// clobbers v3
+#define ARGB4444TOARGB                                                      \
+  "shrn       v1.8b,  v0.8h, #8              \n" /* v1(l) AR             */ \
+  "xtn2       v1.16b, v0.8h                  \n" /* v1(h) GB             */ \
+  "shl        v2.16b, v1.16b, #4             \n" /* B,R BBBB0000         */ \
+  "ushr       v3.16b, v1.16b, #4             \n" /* G,A 0000GGGG         */ \
+  "ushr       v0.16b, v2.16b, #4             \n" /* B,R 0000BBBB         */ \
+  "shl        v1.16b, v3.16b, #4             \n" /* G,A GGGG0000         */ \
+  "orr        v2.16b, v0.16b, v2.16b         \n" /* B,R BBBBBBBB         */ \
+  "orr        v3.16b, v1.16b, v3.16b         \n" /* G,A GGGGGGGG         */ \
+  "dup        v0.2D, v2.D[1]                 \n"                            \
+  "dup        v1.2D, v3.D[1]                 \n"
+
+void ARGB4444ToARGBRow_NEON(const uint8_t* src_argb4444,
+                            uint8_t* dst_argb,
+                            int width) {
+  asm volatile(
+      "1:                                        \n"
+      "ld1         {v0.16b}, [%0], #16           \n"  // load 8 ARGB4444 pixels.
+      "subs        %w2, %w2, #8                  \n"  // 8 processed per loop.
+      "prfm        pldl1keep, [%0, 448]          \n" ARGB4444TOARGB
+      "st4         {v0.8b,v1.8b,v2.8b,v3.8b}, [%1], #32 \n"  // store 8 ARGB
+      "b.gt        1b                            \n"
+      : "+r"(src_argb4444),  // %0
+        "+r"(dst_argb),      // %1
+        "+r"(width)          // %2
+      :
+      : "cc", "memory", "v0", "v1", "v2", "v3", "v4"  // Clobber List
+  );
+}
+
+void ARGBToRGB24Row_NEON(const uint8_t* src_argb,
+                         uint8_t* dst_rgb24,
+                         int width) {
+  asm volatile(
+      "1:                                        \n"
+      "ld4         {v0.16b,v1.16b,v2.16b,v3.16b}, [%0], #64 \n"  // load 16 ARGB
+      "subs        %w2, %w2, #16                 \n"  // 16 pixels per loop.
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "st3         {v0.16b,v1.16b,v2.16b}, [%1], #48 \n"  // store 8 RGB24
+      "b.gt        1b                            \n"
+      : "+r"(src_argb),   // %0
+        "+r"(dst_rgb24),  // %1
+        "+r"(width)       // %2
+      :
+      : "cc", "memory", "v0", "v1", "v2", "v3"  // Clobber List
+  );
+}
+
+void ARGBToRAWRow_NEON(const uint8_t* src_argb, uint8_t* dst_raw, int width) {
+  asm volatile(
+      "1:                                        \n"
+      "ld4         {v1.8b,v2.8b,v3.8b,v4.8b}, [%0], #32 \n"  // load b g r a
+      "subs        %w2, %w2, #8                  \n"  // 8 processed per loop.
+      "orr         v4.8b, v2.8b, v2.8b           \n"  // mov g
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "orr         v5.8b, v1.8b, v1.8b           \n"   // mov b
+      "st3         {v3.8b,v4.8b,v5.8b}, [%1], #24 \n"  // store r g b
+      "b.gt        1b                            \n"
+      : "+r"(src_argb),  // %0
+        "+r"(dst_raw),   // %1
+        "+r"(width)      // %2
+      :
+      : "cc", "memory", "v1", "v2", "v3", "v4", "v5"  // Clobber List
+  );
+}
+
+void YUY2ToYRow_NEON(const uint8_t* src_yuy2, uint8_t* dst_y, int width) {
+  asm volatile(
+      "1:                                        \n"
+      "ld2         {v0.16b,v1.16b}, [%0], #32    \n"  // load 16 pixels of YUY2.
+      "subs        %w2, %w2, #16                 \n"  // 16 processed per loop.
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "st1         {v0.16b}, [%1], #16           \n"  // store 16 pixels of Y.
+      "b.gt        1b                            \n"
+      : "+r"(src_yuy2),  // %0
+        "+r"(dst_y),     // %1
+        "+r"(width)      // %2
+      :
+      : "cc", "memory", "v0", "v1"  // Clobber List
+  );
+}
+
+void UYVYToYRow_NEON(const uint8_t* src_uyvy, uint8_t* dst_y, int width) {
+  asm volatile(
+      "1:                                        \n"
+      "ld2         {v0.16b,v1.16b}, [%0], #32    \n"  // load 16 pixels of UYVY.
+      "subs        %w2, %w2, #16                 \n"  // 16 processed per loop.
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "st1         {v1.16b}, [%1], #16           \n"  // store 16 pixels of Y.
+      "b.gt        1b                            \n"
+      : "+r"(src_uyvy),  // %0
+        "+r"(dst_y),     // %1
+        "+r"(width)      // %2
+      :
+      : "cc", "memory", "v0", "v1"  // Clobber List
+  );
+}
+
+void YUY2ToUV422Row_NEON(const uint8_t* src_yuy2,
+                         uint8_t* dst_u,
+                         uint8_t* dst_v,
+                         int width) {
+  asm volatile(
+      "1:                                        \n"
+      "ld4         {v0.8b,v1.8b,v2.8b,v3.8b}, [%0], #32 \n"  // load 16 YUY2
+      "subs        %w3, %w3, #16                 \n"  // 16 pixels = 8 UVs.
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "st1         {v1.8b}, [%1], #8             \n"  // store 8 U.
+      "st1         {v3.8b}, [%2], #8             \n"  // store 8 V.
+      "b.gt        1b                            \n"
+      : "+r"(src_yuy2),  // %0
+        "+r"(dst_u),     // %1
+        "+r"(dst_v),     // %2
+        "+r"(width)      // %3
+      :
+      : "cc", "memory", "v0", "v1", "v2", "v3"  // Clobber List
+  );
+}
+
+void UYVYToUV422Row_NEON(const uint8_t* src_uyvy,
+                         uint8_t* dst_u,
+                         uint8_t* dst_v,
+                         int width) {
+  asm volatile(
+      "1:                                        \n"
+      "ld4         {v0.8b,v1.8b,v2.8b,v3.8b}, [%0], #32 \n"  // load 16 UYVY
+      "subs        %w3, %w3, #16                 \n"  // 16 pixels = 8 UVs.
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "st1         {v0.8b}, [%1], #8             \n"  // store 8 U.
+      "st1         {v2.8b}, [%2], #8             \n"  // store 8 V.
+      "b.gt        1b                            \n"
+      : "+r"(src_uyvy),  // %0
+        "+r"(dst_u),     // %1
+        "+r"(dst_v),     // %2
+        "+r"(width)      // %3
+      :
+      : "cc", "memory", "v0", "v1", "v2", "v3"  // Clobber List
+  );
+}
+
+void YUY2ToUVRow_NEON(const uint8_t* src_yuy2,
+                      int stride_yuy2,
+                      uint8_t* dst_u,
+                      uint8_t* dst_v,
+                      int width) {
+  const uint8_t* src_yuy2b = src_yuy2 + stride_yuy2;
+  asm volatile(
+      "1:                                        \n"
+      "ld4         {v0.8b,v1.8b,v2.8b,v3.8b}, [%0], #32 \n"  // load 16 pixels
+      "subs        %w4, %w4, #16                 \n"  // 16 pixels = 8 UVs.
+      "ld4         {v4.8b,v5.8b,v6.8b,v7.8b}, [%1], #32 \n"  // load next row
+      "urhadd      v1.8b, v1.8b, v5.8b           \n"  // average rows of U
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "urhadd      v3.8b, v3.8b, v7.8b           \n"  // average rows of V
+      "st1         {v1.8b}, [%2], #8             \n"  // store 8 U.
+      "st1         {v3.8b}, [%3], #8             \n"  // store 8 V.
+      "b.gt        1b                            \n"
+      : "+r"(src_yuy2),   // %0
+        "+r"(src_yuy2b),  // %1
+        "+r"(dst_u),      // %2
+        "+r"(dst_v),      // %3
+        "+r"(width)       // %4
+      :
+      : "cc", "memory", "v0", "v1", "v2", "v3", "v4", "v5", "v6",
+        "v7"  // Clobber List
+  );
+}
+
+void UYVYToUVRow_NEON(const uint8_t* src_uyvy,
+                      int stride_uyvy,
+                      uint8_t* dst_u,
+                      uint8_t* dst_v,
+                      int width) {
+  const uint8_t* src_uyvyb = src_uyvy + stride_uyvy;
+  asm volatile(
+      "1:                                        \n"
+      "ld4         {v0.8b,v1.8b,v2.8b,v3.8b}, [%0], #32 \n"  // load 16 pixels
+      "subs        %w4, %w4, #16                 \n"  // 16 pixels = 8 UVs.
+      "ld4         {v4.8b,v5.8b,v6.8b,v7.8b}, [%1], #32 \n"  // load next row
+      "urhadd      v0.8b, v0.8b, v4.8b           \n"  // average rows of U
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "urhadd      v2.8b, v2.8b, v6.8b           \n"  // average rows of V
+      "st1         {v0.8b}, [%2], #8             \n"  // store 8 U.
+      "st1         {v2.8b}, [%3], #8             \n"  // store 8 V.
+      "b.gt        1b                            \n"
+      : "+r"(src_uyvy),   // %0
+        "+r"(src_uyvyb),  // %1
+        "+r"(dst_u),      // %2
+        "+r"(dst_v),      // %3
+        "+r"(width)       // %4
+      :
+      : "cc", "memory", "v0", "v1", "v2", "v3", "v4", "v5", "v6",
+        "v7"  // Clobber List
+  );
+}
+
+// For BGRAToARGB, ABGRToARGB, RGBAToARGB, and ARGBToRGBA.
+void ARGBShuffleRow_NEON(const uint8_t* src_argb,
+                         uint8_t* dst_argb,
+                         const uint8_t* shuffler,
+                         int width) {
+  asm volatile(
+      "ld1         {v2.16b}, [%3]                \n"  // shuffler
+      "1:                                        \n"
+      "ld1         {v0.16b}, [%0], #16           \n"  // load 4 pixels.
+      "subs        %w2, %w2, #4                  \n"  // 4 processed per loop
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "tbl         v1.16b, {v0.16b}, v2.16b      \n"  // look up 4 pixels
+      "st1         {v1.16b}, [%1], #16           \n"  // store 4.
+      "b.gt        1b                            \n"
+      : "+r"(src_argb),                   // %0
+        "+r"(dst_argb),                   // %1
+        "+r"(width)                       // %2
+      : "r"(shuffler)                     // %3
+      : "cc", "memory", "v0", "v1", "v2"  // Clobber List
+  );
+}
+
+void I422ToYUY2Row_NEON(const uint8_t* src_y,
+                        const uint8_t* src_u,
+                        const uint8_t* src_v,
+                        uint8_t* dst_yuy2,
+                        int width) {
+  asm volatile(
+      "1:                                        \n"
+      "ld2         {v0.8b, v1.8b}, [%0], #16     \n"  // load 16 Ys
+      "subs        %w4, %w4, #16                 \n"  // 16 pixels
+      "orr         v2.8b, v1.8b, v1.8b           \n"
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "ld1         {v1.8b}, [%1], #8             \n"         // load 8 Us
+      "ld1         {v3.8b}, [%2], #8             \n"         // load 8 Vs
+      "st4         {v0.8b,v1.8b,v2.8b,v3.8b}, [%3], #32 \n"  // Store 16 pixels.
+      "b.gt        1b                            \n"
+      : "+r"(src_y),     // %0
+        "+r"(src_u),     // %1
+        "+r"(src_v),     // %2
+        "+r"(dst_yuy2),  // %3
+        "+r"(width)      // %4
+      :
+      : "cc", "memory", "v0", "v1", "v2", "v3");
+}
+
+void I422ToUYVYRow_NEON(const uint8_t* src_y,
+                        const uint8_t* src_u,
+                        const uint8_t* src_v,
+                        uint8_t* dst_uyvy,
+                        int width) {
+  asm volatile(
+      "1:                                        \n"
+      "ld2         {v1.8b,v2.8b}, [%0], #16      \n"  // load 16 Ys
+      "orr         v3.8b, v2.8b, v2.8b           \n"
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "ld1         {v0.8b}, [%1], #8             \n"         // load 8 Us
+      "ld1         {v2.8b}, [%2], #8             \n"         // load 8 Vs
+      "subs        %w4, %w4, #16                 \n"         // 16 pixels
+      "st4         {v0.8b,v1.8b,v2.8b,v3.8b}, [%3], #32 \n"  // Store 16 pixels.
+      "b.gt        1b                            \n"
+      : "+r"(src_y),     // %0
+        "+r"(src_u),     // %1
+        "+r"(src_v),     // %2
+        "+r"(dst_uyvy),  // %3
+        "+r"(width)      // %4
+      :
+      : "cc", "memory", "v0", "v1", "v2", "v3");
+}
+
+void ARGBToRGB565Row_NEON(const uint8_t* src_argb,
+                          uint8_t* dst_rgb565,
+                          int width) {
+  asm volatile(
+      "1:                                        \n"
+      "ld4         {v16.8b,v17.8b,v18.8b,v19.8b}, [%0], #32 \n"  // load 8
+                                                                 // pixels
+      "subs        %w2, %w2, #8                  \n"  // 8 processed per loop.
+      "prfm        pldl1keep, [%0, 448]          \n" ARGBTORGB565
+      "st1         {v18.16b}, [%1], #16          \n"  // store 8 pixels RGB565.
+      "b.gt        1b                            \n"
+      : "+r"(src_argb),    // %0
+        "+r"(dst_rgb565),  // %1
+        "+r"(width)        // %2
+      :
+      : "cc", "memory", "v16", "v17", "v18", "v19");
+}
+
+void ARGBToRGB565DitherRow_NEON(const uint8_t* src_argb,
+                                uint8_t* dst_rgb,
+                                const uint32_t dither4,
+                                int width) {
+  asm volatile(
+      "dup         v1.4s, %w2                    \n"  // dither4
+      "1:                                        \n"
+      "ld4         {v16.8b,v17.8b,v18.8b,v19.8b}, [%1], #32 \n"  // load 8
+                                                                 // pixels
+      "subs        %w3, %w3, #8                  \n"  // 8 processed per loop.
+      "uqadd       v16.8b, v16.8b, v1.8b         \n"
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "uqadd       v17.8b, v17.8b, v1.8b         \n"
+      "uqadd       v18.8b, v18.8b, v1.8b         \n" ARGBTORGB565
+      "st1         {v18.16b}, [%0], #16          \n"  // store 8 pixels RGB565.
+      "b.gt        1b                            \n"
+      : "+r"(dst_rgb)   // %0
+      : "r"(src_argb),  // %1
+        "r"(dither4),   // %2
+        "r"(width)      // %3
+      : "cc", "memory", "v1", "v16", "v17", "v18", "v19");
+}
+
+void ARGBToARGB1555Row_NEON(const uint8_t* src_argb,
+                            uint8_t* dst_argb1555,
+                            int width) {
+  asm volatile(
+      "1:                                        \n"
+      "ld4         {v16.8b,v17.8b,v18.8b,v19.8b}, [%0], #32 \n"  // load 8
+                                                                 // pixels
+      "subs        %w2, %w2, #8                  \n"  // 8 processed per loop.
+      "prfm        pldl1keep, [%0, 448]          \n" ARGBTOARGB1555
+      "st1         {v0.16b}, [%1], #16           \n"  // store 8 pixels
+      "b.gt        1b                            \n"
+      : "+r"(src_argb),      // %0
+        "+r"(dst_argb1555),  // %1
+        "+r"(width)          // %2
+      :
+      : "cc", "memory", "v0", "v16", "v17", "v18", "v19");
+}
+
+void ARGBToARGB4444Row_NEON(const uint8_t* src_argb,
+                            uint8_t* dst_argb4444,
+                            int width) {
+  asm volatile(
+      "movi        v23.16b, #0x0f                \n"  // bits to clear with
+                                                      // vbic.
+      "1:                                        \n"
+      "ld4         {v16.8b,v17.8b,v18.8b,v19.8b}, [%0], #32 \n"  // load 8
+                                                                 // pixels
+      "subs        %w2, %w2, #8                  \n"  // 8 processed per loop.
+      "prfm        pldl1keep, [%0, 448]          \n" ARGBTOARGB4444
+      "st1         {v0.16b}, [%1], #16           \n"  // store 8 pixels
+      "b.gt        1b                            \n"
+      : "+r"(src_argb),      // %0
+        "+r"(dst_argb4444),  // %1
+        "+r"(width)          // %2
+      :
+      : "cc", "memory", "v0", "v1", "v16", "v17", "v18", "v19", "v23");
+}
+
+#if LIBYUV_USE_ST2
+void ARGBToAR64Row_NEON(const uint8_t* src_argb,
+                        uint16_t* dst_ar64,
+                        int width) {
+  asm volatile(
+      "1:                                        \n"
+      "ldp         q0, q2, [%0], #32             \n"  // load 8 pixels
+      "mov         v1.16b, v0.16b                \n"
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "mov         v3.16b, v2.16b                \n"
+      "subs        %w2, %w2, #8                  \n"  // 8 processed per loop.
+      "st2         {v0.16b, v1.16b}, [%1], #32   \n"  // store 4 pixels
+      "st2         {v2.16b, v3.16b}, [%1], #32   \n"  // store 4 pixels
+      "b.gt        1b                            \n"
+      : "+r"(src_argb),  // %0
+        "+r"(dst_ar64),  // %1
+        "+r"(width)      // %2
+      :
+      : "cc", "memory", "v0", "v1", "v2", "v3");
+}
+
+static const uvec8 kShuffleARGBToABGR = {2,  1, 0, 3,  6,  5,  4,  7,
+                                         10, 9, 8, 11, 14, 13, 12, 15};
+
+void ARGBToAB64Row_NEON(const uint8_t* src_argb,
+                        uint16_t* dst_ab64,
+                        int width) {
+  asm volatile(
+      "ldr         q4, [%3]                      \n"  // shuffler
+      "1:                                        \n"
+      "ldp         q0, q2, [%0], #32             \n"  // load 8 pixels
+      "tbl         v0.16b, {v0.16b}, v4.16b      \n"
+      "tbl         v2.16b, {v2.16b}, v4.16b      \n"
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "mov         v1.16b, v0.16b                \n"
+      "mov         v3.16b, v2.16b                \n"
+      "subs        %w2, %w2, #8                  \n"  // 8 processed per loop.
+      "st2         {v0.16b, v1.16b}, [%1], #32   \n"  // store 4 pixels
+      "st2         {v2.16b, v3.16b}, [%1], #32   \n"  // store 4 pixels
+      "b.gt        1b                            \n"
+      : "+r"(src_argb),           // %0
+        "+r"(dst_ab64),           // %1
+        "+r"(width)               // %2
+      : "r"(&kShuffleARGBToABGR)  // %3
+      : "cc", "memory", "v0", "v1", "v2", "v3", "v4");
+}
+#else
+void ARGBToAR64Row_NEON(const uint8_t* src_argb,
+                        uint16_t* dst_ar64,
+                        int width) {
+  asm volatile(
+      "1:                                        \n"
+      "ldp         q0, q1, [%0], #32             \n"  // load 8 ARGB pixels
+      "subs        %w2, %w2, #8                  \n"  // 8 processed per loop.
+      "zip1        v2.16b, v0.16b, v0.16b        \n"
+      "zip2        v3.16b, v0.16b, v0.16b        \n"
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "zip1        v4.16b, v1.16b, v1.16b        \n"
+      "zip2        v5.16b, v1.16b, v1.16b        \n"
+      "st1         {v2.8h, v3.8h, v4.8h, v5.8h}, [%1], #64 \n"  // 8 AR64
+      "b.gt        1b                            \n"
+      : "+r"(src_argb),  // %0
+        "+r"(dst_ar64),  // %1
+        "+r"(width)      // %2
+      :
+      : "cc", "memory", "v0", "v1", "v2", "v3", "v4", "v5");
+}
+
+static const uvec8 kShuffleARGBToAB64[2] = {
+    {2, 2, 1, 1, 0, 0, 3, 3, 6, 6, 5, 5, 4, 4, 7, 7},
+    {10, 10, 9, 9, 8, 8, 11, 11, 14, 14, 13, 13, 12, 12, 15, 15}};
+
+void ARGBToAB64Row_NEON(const uint8_t* src_argb,
+                        uint16_t* dst_ab64,
+                        int width) {
+  asm volatile(
+      "ldp         q6, q7, [%3]                  \n"  // 2 shufflers
+      "1:                                        \n"
+      "ldp         q0, q1, [%0], #32             \n"  // load 8 pixels
+      "subs        %w2, %w2, #8                  \n"  // 8 processed per loop.
+      "tbl         v2.16b, {v0.16b}, v6.16b      \n"  // ARGB to AB64
+      "tbl         v3.16b, {v0.16b}, v7.16b      \n"
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "tbl         v4.16b, {v1.16b}, v6.16b      \n"
+      "tbl         v5.16b, {v1.16b}, v7.16b      \n"
+      "st1         {v2.8h, v3.8h, v4.8h, v5.8h}, [%1], #64 \n"  // 8 AR64
+      "b.gt        1b                            \n"
+      : "+r"(src_argb),              // %0
+        "+r"(dst_ab64),              // %1
+        "+r"(width)                  // %2
+      : "r"(&kShuffleARGBToAB64[0])  // %3
+      : "cc", "memory", "v0", "v1", "v2", "v3", "v4");
+}
+#endif  // LIBYUV_USE_ST2
+
+static const uvec8 kShuffleAR64ToARGB = {1,  3,  5,  7,  9,  11, 13, 15,
+                                         17, 19, 21, 23, 25, 27, 29, 31};
+
+void AR64ToARGBRow_NEON(const uint16_t* src_ar64,
+                        uint8_t* dst_argb,
+                        int width) {
+  asm volatile(
+      "ldr         q4, [%3]                      \n"  // shuffler
+      "1:                                        \n"
+      "ldp         q0, q1, [%0], #32             \n"  // load 4 pixels
+      "ldp         q2, q3, [%0], #32             \n"  // load 4 pixels
+      "tbl         v0.16b, {v0.16b, v1.16b}, v4.16b \n"
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "tbl         v2.16b, {v2.16b, v3.16b}, v4.16b \n"
+      "subs        %w2, %w2, #8                  \n"  // 8 processed per loop.
+      "stp         q0, q2, [%1], #32             \n"  // store 8 pixels
+      "b.gt        1b                            \n"
+      : "+r"(src_ar64),           // %0
+        "+r"(dst_argb),           // %1
+        "+r"(width)               // %2
+      : "r"(&kShuffleAR64ToARGB)  // %3
+      : "cc", "memory", "v0", "v1", "v2", "v3", "v4");
+}
+
+static const uvec8 kShuffleAB64ToARGB = {5,  3,  1,  7,  13, 11, 9,  15,
+                                         21, 19, 17, 23, 29, 27, 25, 31};
+
+void AB64ToARGBRow_NEON(const uint16_t* src_ab64,
+                        uint8_t* dst_argb,
+                        int width) {
+  asm volatile(
+      "ldr         q4, [%3]                      \n"  // shuffler
+      "1:                                        \n"
+      "ldp         q0, q1, [%0], #32             \n"  // load 4 pixels
+      "ldp         q2, q3, [%0], #32             \n"  // load 4 pixels
+      "tbl         v0.16b, {v0.16b, v1.16b}, v4.16b \n"
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "tbl         v2.16b, {v2.16b, v3.16b}, v4.16b \n"
+      "subs        %w2, %w2, #8                  \n"  // 8 processed per loop.
+      "stp         q0, q2, [%1], #32             \n"  // store 8 pixels
+      "b.gt        1b                            \n"
+      : "+r"(src_ab64),           // %0
+        "+r"(dst_argb),           // %1
+        "+r"(width)               // %2
+      : "r"(&kShuffleAB64ToARGB)  // %3
+      : "cc", "memory", "v0", "v1", "v2", "v3", "v4");
+}
+
+void ARGBExtractAlphaRow_NEON(const uint8_t* src_argb,
+                              uint8_t* dst_a,
+                              int width) {
+  asm volatile(
+      "1:                                        \n"
+      "ld4         {v0.16b,v1.16b,v2.16b,v3.16b}, [%0], #64 \n"  // load 16
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "subs        %w2, %w2, #16                 \n"  // 16 processed per loop
+      "st1         {v3.16b}, [%1], #16           \n"  // store 16 A's.
+      "b.gt        1b                            \n"
+      : "+r"(src_argb),  // %0
+        "+r"(dst_a),     // %1
+        "+r"(width)      // %2
+      :
+      : "cc", "memory", "v0", "v1", "v2", "v3"  // Clobber List
+  );
+}
+
+// 8x1 pixels.
+void ARGBToUV444Row_NEON(const uint8_t* src_argb,
+                         uint8_t* dst_u,
+                         uint8_t* dst_v,
+                         int width) {
+  asm volatile(
+      "movi        v24.8b, #112                  \n"  // UB / VR 0.875
+                                                      // coefficient
+      "movi        v25.8b, #74                   \n"  // UG -0.5781 coefficient
+      "movi        v26.8b, #38                   \n"  // UR -0.2969 coefficient
+      "movi        v27.8b, #18                   \n"  // VB -0.1406 coefficient
+      "movi        v28.8b, #94                   \n"  // VG -0.7344 coefficient
+      "movi        v29.16b,#0x80                 \n"  // 128.5
+      "1:                                        \n"
+      "ld4         {v0.8b,v1.8b,v2.8b,v3.8b}, [%0], #32 \n"  // load 8 ARGB
+      "subs        %w3, %w3, #8                  \n"  // 8 processed per loop.
+      "umull       v4.8h, v0.8b, v24.8b          \n"  // B
+      "umlsl       v4.8h, v1.8b, v25.8b          \n"  // G
+      "umlsl       v4.8h, v2.8b, v26.8b          \n"  // R
+      "prfm        pldl1keep, [%0, 448]          \n"
+
+      "umull       v3.8h, v2.8b, v24.8b          \n"  // R
+      "umlsl       v3.8h, v1.8b, v28.8b          \n"  // G
+      "umlsl       v3.8h, v0.8b, v27.8b          \n"  // B
+
+      "addhn       v0.8b, v4.8h, v29.8h          \n"  // +128 -> unsigned
+      "addhn       v1.8b, v3.8h, v29.8h          \n"  // +128 -> unsigned
+
+      "st1         {v0.8b}, [%1], #8             \n"  // store 8 pixels U.
+      "st1         {v1.8b}, [%2], #8             \n"  // store 8 pixels V.
+      "b.gt        1b                            \n"
+      : "+r"(src_argb),  // %0
+        "+r"(dst_u),     // %1
+        "+r"(dst_v),     // %2
+        "+r"(width)      // %3
+      :
+      : "cc", "memory", "v0", "v1", "v2", "v3", "v4", "v24", "v25", "v26",
+        "v27", "v28", "v29");
+}
+
+#define RGBTOUV_SETUP_REG                                                  \
+  "movi       v20.8h, #56, lsl #0  \n" /* UB/VR coefficient (0.875) / 2 */ \
+  "movi       v21.8h, #37, lsl #0  \n" /* UG coefficient (-0.5781) / 2  */ \
+  "movi       v22.8h, #19, lsl #0  \n" /* UR coefficient (-0.2969) / 2  */ \
+  "movi       v23.8h, #9,  lsl #0  \n" /* VB coefficient (-0.1406) / 2  */ \
+  "movi       v24.8h, #47, lsl #0  \n" /* VG coefficient (-0.7344) / 2  */ \
+  "movi       v25.16b, #0x80       \n" /* 128.5 (0x8080 in 16-bit)      */
+
+// 16x2 pixels -> 8x1.  width is number of argb pixels. e.g. 16.
+// clang-format off
+#define RGBTOUV(QB, QG, QR)                                                 \
+  "mul        v3.8h, " #QB ",v20.8h          \n" /* B                    */ \
+  "mul        v4.8h, " #QR ",v20.8h          \n" /* R                    */ \
+  "mls        v3.8h, " #QG ",v21.8h          \n" /* G                    */ \
+  "mls        v4.8h, " #QG ",v24.8h          \n" /* G                    */ \
+  "mls        v3.8h, " #QR ",v22.8h          \n" /* R                    */ \
+  "mls        v4.8h, " #QB ",v23.8h          \n" /* B                    */ \
+  "addhn      v0.8b, v3.8h, v25.8h           \n" /* +128 -> unsigned     */ \
+  "addhn      v1.8b, v4.8h, v25.8h           \n" /* +128 -> unsigned     */
+// clang-format on
+
+// TODO(fbarchard): Consider vhadd vertical, then vpaddl horizontal, avoid shr.
+// TODO(fbarchard): consider ptrdiff_t for all strides.
+
+void ARGBToUVRow_NEON(const uint8_t* src_argb,
+                      int src_stride_argb,
+                      uint8_t* dst_u,
+                      uint8_t* dst_v,
+                      int width) {
+  const uint8_t* src_argb_1 = src_argb + src_stride_argb;
+  asm volatile (
+    RGBTOUV_SETUP_REG
+      "1:                                        \n"
+      "ld4         {v0.16b,v1.16b,v2.16b,v3.16b}, [%0], #64 \n"  // load 16 pixels.
+      "uaddlp      v0.8h, v0.16b                 \n"  // B 16 bytes -> 8 shorts.
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "uaddlp      v1.8h, v1.16b                 \n"  // G 16 bytes -> 8 shorts.
+      "uaddlp      v2.8h, v2.16b                 \n"  // R 16 bytes -> 8 shorts.
+
+      "ld4         {v4.16b,v5.16b,v6.16b,v7.16b}, [%1], #64 \n"  // load next 16
+      "uadalp      v0.8h, v4.16b                 \n"  // B 16 bytes -> 8 shorts.
+      "prfm        pldl1keep, [%1, 448]          \n"
+      "uadalp      v1.8h, v5.16b                 \n"  // G 16 bytes -> 8 shorts.
+      "uadalp      v2.8h, v6.16b                 \n"  // R 16 bytes -> 8 shorts.
+
+      "urshr       v0.8h, v0.8h, #1              \n"  // 2x average
+      "urshr       v1.8h, v1.8h, #1              \n"
+      "urshr       v2.8h, v2.8h, #1              \n"
+
+      "subs        %w4, %w4, #16                 \n"  // 16 processed per loop.
+    RGBTOUV(v0.8h, v1.8h, v2.8h)
+      "st1         {v0.8b}, [%2], #8             \n"  // store 8 pixels U.
+      "st1         {v1.8b}, [%3], #8             \n"  // store 8 pixels V.
+      "b.gt        1b                            \n"
+  : "+r"(src_argb),  // %0
+    "+r"(src_argb_1),  // %1
+    "+r"(dst_u),     // %2
+    "+r"(dst_v),     // %3
+    "+r"(width)        // %4
+  :
+  : "cc", "memory", "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
+    "v20", "v21", "v22", "v23", "v24", "v25"
+  );
+}
+
+void ARGBToUVJRow_NEON(const uint8_t* src_argb,
+                       int src_stride_argb,
+                       uint8_t* dst_u,
+                       uint8_t* dst_v,
+                       int width) {
+  const uint8_t* src_argb_1 = src_argb + src_stride_argb;
+  asm volatile (
+      "movi        v20.8h, #63, lsl #0           \n"  // UB/VR coeff (0.500) / 2
+      "movi        v21.8h, #42, lsl #0           \n"  // UG coeff (-0.33126) / 2
+      "movi        v22.8h, #21, lsl #0           \n"  // UR coeff (-0.16874) / 2
+      "movi        v23.8h, #10, lsl #0           \n"  // VB coeff (-0.08131) / 2
+      "movi        v24.8h, #53, lsl #0           \n"  // VG coeff (-0.41869) / 2
+      "movi        v25.16b, #0x80                \n"  // 128.5 (0x8080 in 16-bit)
+      "1:                                        \n"
+      "ld4         {v0.16b,v1.16b,v2.16b,v3.16b}, [%0], #64 \n"  // load 16 pixels.
+      "uaddlp      v0.8h, v0.16b                 \n"  // B 16 bytes -> 8 shorts.
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "uaddlp      v1.8h, v1.16b                 \n"  // G 16 bytes -> 8 shorts.
+      "uaddlp      v2.8h, v2.16b                 \n"  // R 16 bytes -> 8 shorts.
+      "ld4         {v4.16b,v5.16b,v6.16b,v7.16b}, [%1], #64 \n"  // load next 16
+      "uadalp      v0.8h, v4.16b                 \n"  // B 16 bytes -> 8 shorts.
+      "prfm        pldl1keep, [%1, 448]          \n"
+      "uadalp      v1.8h, v5.16b                 \n"  // G 16 bytes -> 8 shorts.
+      "uadalp      v2.8h, v6.16b                 \n"  // R 16 bytes -> 8 shorts.
+
+      "urshr       v0.8h, v0.8h, #1              \n"  // 2x average
+      "urshr       v1.8h, v1.8h, #1              \n"
+      "urshr       v2.8h, v2.8h, #1              \n"
+
+      "subs        %w4, %w4, #16                 \n"  // 16 processed per loop.
+    RGBTOUV(v0.8h, v1.8h, v2.8h)
+      "st1         {v0.8b}, [%2], #8             \n"  // store 8 pixels U.
+      "st1         {v1.8b}, [%3], #8             \n"  // store 8 pixels V.
+      "b.gt        1b                            \n"
+  : "+r"(src_argb),  // %0
+    "+r"(src_argb_1),  // %1
+    "+r"(dst_u),     // %2
+    "+r"(dst_v),     // %3
+    "+r"(width)        // %4
+  :
+  : "cc", "memory", "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
+    "v20", "v21", "v22", "v23", "v24", "v25"
+  );
+}
+
+void RGB24ToUVJRow_NEON(const uint8_t* src_rgb24,
+                        int src_stride_rgb24,
+                        uint8_t* dst_u,
+                        uint8_t* dst_v,
+                        int width) {
+  const uint8_t* src_rgb24_1 = src_rgb24 + src_stride_rgb24;
+  asm volatile (
+      "movi        v20.8h, #63, lsl #0           \n"  // UB/VR coeff (0.500) / 2
+      "movi        v21.8h, #42, lsl #0           \n"  // UG coeff (-0.33126) / 2
+      "movi        v22.8h, #21, lsl #0           \n"  // UR coeff (-0.16874) / 2
+      "movi        v23.8h, #10, lsl #0           \n"  // VB coeff (-0.08131) / 2
+      "movi        v24.8h, #53, lsl #0           \n"  // VG coeff (-0.41869) / 2
+      "movi        v25.16b, #0x80                \n"  // 128.5 (0x8080 in 16-bit)
+      "1:                                        \n"
+      "ld3         {v0.16b,v1.16b,v2.16b}, [%0], #48 \n"  // load 16 pixels.
+      "uaddlp      v0.8h, v0.16b                 \n"  // B 16 bytes -> 8 shorts.
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "uaddlp      v1.8h, v1.16b                 \n"  // G 16 bytes -> 8 shorts.
+      "uaddlp      v2.8h, v2.16b                 \n"  // R 16 bytes -> 8 shorts.
+      "ld3         {v4.16b,v5.16b,v6.16b}, [%1], #48 \n"  // load next 16
+      "uadalp      v0.8h, v4.16b                 \n"  // B 16 bytes -> 8 shorts.
+      "prfm        pldl1keep, [%1, 448]          \n"
+      "uadalp      v1.8h, v5.16b                 \n"  // G 16 bytes -> 8 shorts.
+      "uadalp      v2.8h, v6.16b                 \n"  // R 16 bytes -> 8 shorts.
+
+      "urshr       v0.8h, v0.8h, #1              \n"  // 2x average
+      "urshr       v1.8h, v1.8h, #1              \n"
+      "urshr       v2.8h, v2.8h, #1              \n"
+
+      "subs        %w4, %w4, #16                 \n"  // 16 processed per loop.
+    RGBTOUV(v0.8h, v1.8h, v2.8h)
+      "st1         {v0.8b}, [%2], #8             \n"  // store 8 pixels U.
+      "st1         {v1.8b}, [%3], #8             \n"  // store 8 pixels V.
+      "b.gt        1b                            \n"
+  : "+r"(src_rgb24),  // %0
+    "+r"(src_rgb24_1),  // %1
+    "+r"(dst_u),     // %2
+    "+r"(dst_v),     // %3
+    "+r"(width)        // %4
+  :
+  : "cc", "memory", "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
+    "v20", "v21", "v22", "v23", "v24", "v25"
+  );
+}
+
+void RAWToUVJRow_NEON(const uint8_t* src_raw,
+                      int src_stride_raw,
+                      uint8_t* dst_u,
+                      uint8_t* dst_v,
+                      int width) {
+  const uint8_t* src_raw_1 = src_raw + src_stride_raw;
+  asm volatile (
+      "movi        v20.8h, #63, lsl #0           \n"  // UB/VR coeff (0.500) / 2
+      "movi        v21.8h, #42, lsl #0           \n"  // UG coeff (-0.33126) / 2
+      "movi        v22.8h, #21, lsl #0           \n"  // UR coeff (-0.16874) / 2
+      "movi        v23.8h, #10, lsl #0           \n"  // VB coeff (-0.08131) / 2
+      "movi        v24.8h, #53, lsl #0           \n"  // VG coeff (-0.41869) / 2
+      "movi        v25.16b, #0x80                \n"  // 128.5 (0x8080 in 16-bit)
+      "1:                                        \n"
+      "ld3         {v0.16b,v1.16b,v2.16b}, [%0], #48 \n"  // load 16 pixels.
+      "uaddlp      v0.8h, v0.16b                 \n"  // B 16 bytes -> 8 shorts.
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "uaddlp      v1.8h, v1.16b                 \n"  // G 16 bytes -> 8 shorts.
+      "uaddlp      v2.8h, v2.16b                 \n"  // R 16 bytes -> 8 shorts.
+      "ld3         {v4.16b,v5.16b,v6.16b}, [%1], #48 \n"  // load next 16
+      "uadalp      v0.8h, v4.16b                 \n"  // B 16 bytes -> 8 shorts.
+      "prfm        pldl1keep, [%1, 448]          \n"
+      "uadalp      v1.8h, v5.16b                 \n"  // G 16 bytes -> 8 shorts.
+      "uadalp      v2.8h, v6.16b                 \n"  // R 16 bytes -> 8 shorts.
+
+      "urshr       v0.8h, v0.8h, #1              \n"  // 2x average
+      "urshr       v1.8h, v1.8h, #1              \n"
+      "urshr       v2.8h, v2.8h, #1              \n"
+
+      "subs        %w4, %w4, #16                 \n"  // 16 processed per loop.
+    RGBTOUV(v2.8h, v1.8h, v0.8h)
+      "st1         {v0.8b}, [%2], #8             \n"  // store 8 pixels U.
+      "st1         {v1.8b}, [%3], #8             \n"  // store 8 pixels V.
+      "b.gt        1b                            \n"
+  : "+r"(src_raw),  // %0
+    "+r"(src_raw_1),  // %1
+    "+r"(dst_u),     // %2
+    "+r"(dst_v),     // %3
+    "+r"(width)        // %4
+  :
+  : "cc", "memory", "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
+    "v20", "v21", "v22", "v23", "v24", "v25"
+  );
+}
+
+void BGRAToUVRow_NEON(const uint8_t* src_bgra,
+                      int src_stride_bgra,
+                      uint8_t* dst_u,
+                      uint8_t* dst_v,
+                      int width) {
+  const uint8_t* src_bgra_1 = src_bgra + src_stride_bgra;
+  asm volatile (
+    RGBTOUV_SETUP_REG
+      "1:                                        \n"
+      "ld4         {v0.16b,v1.16b,v2.16b,v3.16b}, [%0], #64 \n"  // load 16 pixels.
+      "uaddlp      v0.8h, v3.16b                 \n"  // B 16 bytes -> 8 shorts.
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "uaddlp      v3.8h, v2.16b                 \n"  // G 16 bytes -> 8 shorts.
+      "uaddlp      v2.8h, v1.16b                 \n"  // R 16 bytes -> 8 shorts.
+      "ld4         {v4.16b,v5.16b,v6.16b,v7.16b}, [%1], #64 \n"  // load 16 more
+      "uadalp      v0.8h, v7.16b                 \n"  // B 16 bytes -> 8 shorts.
+      "prfm        pldl1keep, [%1, 448]          \n"
+      "uadalp      v3.8h, v6.16b                 \n"  // G 16 bytes -> 8 shorts.
+      "uadalp      v2.8h, v5.16b                 \n"  // R 16 bytes -> 8 shorts.
+
+      "urshr       v0.8h, v0.8h, #1              \n"  // 2x average
+      "urshr       v1.8h, v3.8h, #1              \n"
+      "urshr       v2.8h, v2.8h, #1              \n"
+
+      "subs        %w4, %w4, #16                 \n"  // 16 processed per loop.
+    RGBTOUV(v0.8h, v1.8h, v2.8h)
+      "st1         {v0.8b}, [%2], #8             \n"  // store 8 pixels U.
+      "st1         {v1.8b}, [%3], #8             \n"  // store 8 pixels V.
+      "b.gt        1b                            \n"
+  : "+r"(src_bgra),  // %0
+    "+r"(src_bgra_1),  // %1
+    "+r"(dst_u),     // %2
+    "+r"(dst_v),     // %3
+    "+r"(width)        // %4
+  :
+  : "cc", "memory", "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
+    "v20", "v21", "v22", "v23", "v24", "v25"
+  );
+}
+
+void ABGRToUVRow_NEON(const uint8_t* src_abgr,
+                      int src_stride_abgr,
+                      uint8_t* dst_u,
+                      uint8_t* dst_v,
+                      int width) {
+  const uint8_t* src_abgr_1 = src_abgr + src_stride_abgr;
+  asm volatile (
+    RGBTOUV_SETUP_REG
+      "1:                                        \n"
+      "ld4         {v0.16b,v1.16b,v2.16b,v3.16b}, [%0], #64 \n"  // load 16 pixels.
+      "uaddlp      v3.8h, v2.16b                 \n"  // B 16 bytes -> 8 shorts.
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "uaddlp      v2.8h, v1.16b                 \n"  // G 16 bytes -> 8 shorts.
+      "uaddlp      v1.8h, v0.16b                 \n"  // R 16 bytes -> 8 shorts.
+      "ld4         {v4.16b,v5.16b,v6.16b,v7.16b}, [%1], #64 \n"  // load 16 more.
+      "uadalp      v3.8h, v6.16b                 \n"  // B 16 bytes -> 8 shorts.
+      "prfm        pldl1keep, [%1, 448]          \n"
+      "uadalp      v2.8h, v5.16b                 \n"  // G 16 bytes -> 8 shorts.
+      "uadalp      v1.8h, v4.16b                 \n"  // R 16 bytes -> 8 shorts.
+
+      "urshr       v0.8h, v3.8h, #1              \n"  // 2x average
+      "urshr       v2.8h, v2.8h, #1              \n"
+      "urshr       v1.8h, v1.8h, #1              \n"
+
+      "subs        %w4, %w4, #16                 \n"  // 16 processed per loop.
+    RGBTOUV(v0.8h, v2.8h, v1.8h)
+      "st1         {v0.8b}, [%2], #8             \n"  // store 8 pixels U.
+      "st1         {v1.8b}, [%3], #8             \n"  // store 8 pixels V.
+      "b.gt        1b                            \n"
+  : "+r"(src_abgr),  // %0
+    "+r"(src_abgr_1),  // %1
+    "+r"(dst_u),     // %2
+    "+r"(dst_v),     // %3
+    "+r"(width)        // %4
+  :
+  : "cc", "memory", "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
+    "v20", "v21", "v22", "v23", "v24", "v25"
+  );
+}
+
+void RGBAToUVRow_NEON(const uint8_t* src_rgba,
+                      int src_stride_rgba,
+                      uint8_t* dst_u,
+                      uint8_t* dst_v,
+                      int width) {
+  const uint8_t* src_rgba_1 = src_rgba + src_stride_rgba;
+  asm volatile (
+    RGBTOUV_SETUP_REG
+      "1:                                        \n"
+      "ld4         {v0.16b,v1.16b,v2.16b,v3.16b}, [%0], #64 \n"  // load 16 pixels.
+      "uaddlp      v0.8h, v1.16b                 \n"  // B 16 bytes -> 8 shorts.
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "uaddlp      v1.8h, v2.16b                 \n"  // G 16 bytes -> 8 shorts.
+      "uaddlp      v2.8h, v3.16b                 \n"  // R 16 bytes -> 8 shorts.
+      "ld4         {v4.16b,v5.16b,v6.16b,v7.16b}, [%1], #64 \n"  // load 16 more.
+      "uadalp      v0.8h, v5.16b                 \n"  // B 16 bytes -> 8 shorts.
+      "prfm        pldl1keep, [%1, 448]          \n"
+      "uadalp      v1.8h, v6.16b                 \n"  // G 16 bytes -> 8 shorts.
+      "uadalp      v2.8h, v7.16b                 \n"  // R 16 bytes -> 8 shorts.
+
+      "urshr       v0.8h, v0.8h, #1              \n"  // 2x average
+      "urshr       v1.8h, v1.8h, #1              \n"
+      "urshr       v2.8h, v2.8h, #1              \n"
+
+      "subs        %w4, %w4, #16                 \n"  // 16 processed per loop.
+    RGBTOUV(v0.8h, v1.8h, v2.8h)
+      "st1         {v0.8b}, [%2], #8             \n"  // store 8 pixels U.
+      "st1         {v1.8b}, [%3], #8             \n"  // store 8 pixels V.
+      "b.gt        1b                            \n"
+  : "+r"(src_rgba),  // %0
+    "+r"(src_rgba_1),  // %1
+    "+r"(dst_u),     // %2
+    "+r"(dst_v),     // %3
+    "+r"(width)        // %4
+  :
+  : "cc", "memory", "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
+    "v20", "v21", "v22", "v23", "v24", "v25"
+  );
+}
+
+void RGB24ToUVRow_NEON(const uint8_t* src_rgb24,
+                       int src_stride_rgb24,
+                       uint8_t* dst_u,
+                       uint8_t* dst_v,
+                       int width) {
+  const uint8_t* src_rgb24_1 = src_rgb24 + src_stride_rgb24;
+  asm volatile (
+    RGBTOUV_SETUP_REG
+      "1:                                        \n"
+      "ld3         {v0.16b,v1.16b,v2.16b}, [%0], #48 \n"  // load 16 pixels.
+      "uaddlp      v0.8h, v0.16b                 \n"  // B 16 bytes -> 8 shorts.
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "uaddlp      v1.8h, v1.16b                 \n"  // G 16 bytes -> 8 shorts.
+      "uaddlp      v2.8h, v2.16b                 \n"  // R 16 bytes -> 8 shorts.
+      "ld3         {v4.16b,v5.16b,v6.16b}, [%1], #48 \n"  // load 16 more.
+      "uadalp      v0.8h, v4.16b                 \n"  // B 16 bytes -> 8 shorts.
+      "prfm        pldl1keep, [%1, 448]          \n"
+      "uadalp      v1.8h, v5.16b                 \n"  // G 16 bytes -> 8 shorts.
+      "uadalp      v2.8h, v6.16b                 \n"  // R 16 bytes -> 8 shorts.
+
+      "urshr       v0.8h, v0.8h, #1              \n"  // 2x average
+      "urshr       v1.8h, v1.8h, #1              \n"
+      "urshr       v2.8h, v2.8h, #1              \n"
+
+      "subs        %w4, %w4, #16                 \n"  // 16 processed per loop.
+    RGBTOUV(v0.8h, v1.8h, v2.8h)
+      "st1         {v0.8b}, [%2], #8             \n"  // store 8 pixels U.
+      "st1         {v1.8b}, [%3], #8             \n"  // store 8 pixels V.
+      "b.gt        1b                            \n"
+  : "+r"(src_rgb24),  // %0
+    "+r"(src_rgb24_1),  // %1
+    "+r"(dst_u),     // %2
+    "+r"(dst_v),     // %3
+    "+r"(width)        // %4
+  :
+  : "cc", "memory", "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
+    "v20", "v21", "v22", "v23", "v24", "v25"
+  );
+}
+
+void RAWToUVRow_NEON(const uint8_t* src_raw,
+                     int src_stride_raw,
+                     uint8_t* dst_u,
+                     uint8_t* dst_v,
+                     int width) {
+  const uint8_t* src_raw_1 = src_raw + src_stride_raw;
+  asm volatile (
+    RGBTOUV_SETUP_REG
+      "1:                                        \n"
+      "ld3         {v0.16b,v1.16b,v2.16b}, [%0], #48 \n"  // load 16 RAW pixels.
+      "uaddlp      v2.8h, v2.16b                 \n"  // B 16 bytes -> 8 shorts.
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "uaddlp      v1.8h, v1.16b                 \n"  // G 16 bytes -> 8 shorts.
+      "uaddlp      v0.8h, v0.16b                 \n"  // R 16 bytes -> 8 shorts.
+      "ld3         {v4.16b,v5.16b,v6.16b}, [%1], #48 \n"  // load 8 more RAW pixels
+      "uadalp      v2.8h, v6.16b                 \n"  // B 16 bytes -> 8 shorts.
+      "prfm        pldl1keep, [%1, 448]          \n"
+      "uadalp      v1.8h, v5.16b                 \n"  // G 16 bytes -> 8 shorts.
+      "uadalp      v0.8h, v4.16b                 \n"  // R 16 bytes -> 8 shorts.
+
+      "urshr       v2.8h, v2.8h, #1              \n"  // 2x average
+      "urshr       v1.8h, v1.8h, #1              \n"
+      "urshr       v0.8h, v0.8h, #1              \n"
+
+      "subs        %w4, %w4, #16                 \n"  // 16 processed per loop.
+    RGBTOUV(v2.8h, v1.8h, v0.8h)
+      "st1         {v0.8b}, [%2], #8             \n"  // store 8 pixels U.
+      "st1         {v1.8b}, [%3], #8             \n"  // store 8 pixels V.
+      "b.gt        1b                            \n"
+  : "+r"(src_raw),  // %0
+    "+r"(src_raw_1),  // %1
+    "+r"(dst_u),     // %2
+    "+r"(dst_v),     // %3
+    "+r"(width)        // %4
+  :
+  : "cc", "memory", "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
+    "v20", "v21", "v22", "v23", "v24", "v25"
+  );
+}
+
+// 16x2 pixels -> 8x1.  width is number of rgb pixels. e.g. 16.
+void RGB565ToUVRow_NEON(const uint8_t* src_rgb565,
+                        int src_stride_rgb565,
+                        uint8_t* dst_u,
+                        uint8_t* dst_v,
+                        int width) {
+  const uint8_t* src_rgb565_1 = src_rgb565 + src_stride_rgb565;
+  asm volatile(
+      RGBTOUV_SETUP_REG
+      "1:                                        \n"
+      "ld1         {v0.16b}, [%0], #16           \n"  // load 8 RGB565 pixels.
+      RGB565TOARGB
+      "uaddlp      v16.4h, v0.8b                 \n"  // B 8 bytes -> 4 shorts.
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "uaddlp      v17.4h, v1.8b                 \n"  // G 8 bytes -> 4 shorts.
+      "uaddlp      v18.4h, v2.8b                 \n"  // R 8 bytes -> 4 shorts.
+      "ld1         {v0.16b}, [%0], #16           \n"  // next 8 RGB565 pixels.
+      RGB565TOARGB
+      "uaddlp      v26.4h, v0.8b                 \n"  // B 8 bytes -> 4 shorts.
+      "uaddlp      v27.4h, v1.8b                 \n"  // G 8 bytes -> 4 shorts.
+      "uaddlp      v28.4h, v2.8b                 \n"  // R 8 bytes -> 4 shorts.
+
+      "ld1         {v0.16b}, [%1], #16           \n"  // load 8 RGB565 pixels.
+      RGB565TOARGB
+      "uadalp      v16.4h, v0.8b                 \n"  // B 8 bytes -> 4 shorts.
+      "prfm        pldl1keep, [%1, 448]          \n"
+      "uadalp      v17.4h, v1.8b                 \n"  // G 8 bytes -> 4 shorts.
+      "uadalp      v18.4h, v2.8b                 \n"  // R 8 bytes -> 4 shorts.
+      "ld1         {v0.16b}, [%1], #16           \n"  // next 8 RGB565 pixels.
+      RGB565TOARGB
+      "uadalp      v26.4h, v0.8b                 \n"  // B 8 bytes -> 4 shorts.
+      "uadalp      v27.4h, v1.8b                 \n"  // G 8 bytes -> 4 shorts.
+      "uadalp      v28.4h, v2.8b                 \n"  // R 8 bytes -> 4 shorts.
+
+      "ins         v16.D[1], v26.D[0]            \n"
+      "ins         v17.D[1], v27.D[0]            \n"
+      "ins         v18.D[1], v28.D[0]            \n"
+
+      "urshr       v0.8h, v16.8h, #1             \n"  // 2x average
+      "urshr       v1.8h, v17.8h, #1             \n"
+      "urshr       v2.8h, v18.8h, #1             \n"
+
+      "subs        %w4, %w4, #16                 \n"  // 16 processed per loop.
+      RGBTOUV(v0.8h, v1.8h, v2.8h)
+      "st1         {v0.8b}, [%2], #8             \n"  // store 8 pixels U.
+      "st1         {v1.8b}, [%3], #8             \n"  // store 8 pixels V.
+      "b.gt        1b                            \n"
+      : "+r"(src_rgb565),    // %0
+        "+r"(src_rgb565_1),  // %1
+        "+r"(dst_u),           // %2
+        "+r"(dst_v),           // %3
+        "+r"(width)            // %4
+      :
+      : "cc", "memory", "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v16", "v17",
+        "v18", "v19", "v20", "v21", "v22", "v23", "v24", "v25", "v26", "v27",
+        "v28");
+}
+
+// 16x2 pixels -> 8x1.  width is number of argb pixels. e.g. 16.
+void ARGB1555ToUVRow_NEON(const uint8_t* src_argb1555,
+                          int src_stride_argb1555,
+                          uint8_t* dst_u,
+                          uint8_t* dst_v,
+                          int width) {
+  const uint8_t* src_argb1555_1 = src_argb1555 + src_stride_argb1555;
+  asm volatile(
+      RGBTOUV_SETUP_REG
+      "1:                                        \n"
+      "ld1         {v0.16b}, [%0], #16           \n"  // load 8 ARGB1555 pixels.
+      RGB555TOARGB
+      "uaddlp      v16.4h, v0.8b                 \n"  // B 8 bytes -> 4 shorts.
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "uaddlp      v17.4h, v1.8b                 \n"  // G 8 bytes -> 4 shorts.
+      "uaddlp      v18.4h, v2.8b                 \n"  // R 8 bytes -> 4 shorts.
+      "ld1         {v0.16b}, [%0], #16           \n"  // next 8 ARGB1555 pixels.
+      RGB555TOARGB
+      "uaddlp      v26.4h, v0.8b                 \n"  // B 8 bytes -> 4 shorts.
+      "uaddlp      v27.4h, v1.8b                 \n"  // G 8 bytes -> 4 shorts.
+      "uaddlp      v28.4h, v2.8b                 \n"  // R 8 bytes -> 4 shorts.
+
+      "ld1         {v0.16b}, [%1], #16           \n"  // load 8 ARGB1555 pixels.
+      RGB555TOARGB
+      "uadalp      v16.4h, v0.8b                 \n"  // B 8 bytes -> 4 shorts.
+      "prfm        pldl1keep, [%1, 448]          \n"
+      "uadalp      v17.4h, v1.8b                 \n"  // G 8 bytes -> 4 shorts.
+      "uadalp      v18.4h, v2.8b                 \n"  // R 8 bytes -> 4 shorts.
+      "ld1         {v0.16b}, [%1], #16           \n"  // next 8 ARGB1555 pixels.
+      RGB555TOARGB
+      "uadalp      v26.4h, v0.8b                 \n"  // B 8 bytes -> 4 shorts.
+      "uadalp      v27.4h, v1.8b                 \n"  // G 8 bytes -> 4 shorts.
+      "uadalp      v28.4h, v2.8b                 \n"  // R 8 bytes -> 4 shorts.
+
+      "ins         v16.D[1], v26.D[0]            \n"
+      "ins         v17.D[1], v27.D[0]            \n"
+      "ins         v18.D[1], v28.D[0]            \n"
+
+      "urshr       v0.8h, v16.8h, #1             \n"  // 2x average
+      "urshr       v1.8h, v17.8h, #1             \n"
+      "urshr       v2.8h, v18.8h, #1             \n"
+
+      "subs        %w4, %w4, #16                 \n"  // 16 processed per loop.
+      RGBTOUV(v0.8h, v1.8h, v2.8h)
+      "st1         {v0.8b}, [%2], #8             \n"  // store 8 pixels U.
+      "st1         {v1.8b}, [%3], #8             \n"  // store 8 pixels V.
+      "b.gt        1b                            \n"
+      : "+r"(src_argb1555),    // %0
+        "+r"(src_argb1555_1),  // %1
+        "+r"(dst_u),           // %2
+        "+r"(dst_v),           // %3
+        "+r"(width)            // %4
+      :
+      : "cc", "memory", "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v16", "v17",
+        "v18", "v19", "v20", "v21", "v22", "v23", "v24", "v25", "v26", "v27",
+        "v28");
+}
+
+// 16x2 pixels -> 8x1.  width is number of argb pixels. e.g. 16.
+void ARGB4444ToUVRow_NEON(const uint8_t* src_argb4444,
+                          int src_stride_argb4444,
+                          uint8_t* dst_u,
+                          uint8_t* dst_v,
+                          int width) {
+  const uint8_t* src_argb4444_1 = src_argb4444 + src_stride_argb4444;
+  asm volatile(
+      RGBTOUV_SETUP_REG  // sets v20-v25
+      "1:                                        \n"
+      "ld1         {v0.16b}, [%0], #16           \n"  // load 8 ARGB4444 pixels.
+      ARGB4444TOARGB
+      "uaddlp      v16.4h, v0.8b                 \n"  // B 8 bytes -> 4 shorts.
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "uaddlp      v17.4h, v1.8b                 \n"  // G 8 bytes -> 4 shorts.
+      "uaddlp      v18.4h, v2.8b                 \n"  // R 8 bytes -> 4 shorts.
+      "ld1         {v0.16b}, [%0], #16           \n"  // next 8 ARGB4444 pixels.
+      ARGB4444TOARGB
+      "uaddlp      v26.4h, v0.8b                 \n"  // B 8 bytes -> 4 shorts.
+      "uaddlp      v27.4h, v1.8b                 \n"  // G 8 bytes -> 4 shorts.
+      "uaddlp      v28.4h, v2.8b                 \n"  // R 8 bytes -> 4 shorts.
+
+      "ld1         {v0.16b}, [%1], #16           \n"  // load 8 ARGB4444 pixels.
+      ARGB4444TOARGB
+      "uadalp      v16.4h, v0.8b                 \n"  // B 8 bytes -> 4 shorts.
+      "prfm        pldl1keep, [%1, 448]          \n"
+      "uadalp      v17.4h, v1.8b                 \n"  // G 8 bytes -> 4 shorts.
+      "uadalp      v18.4h, v2.8b                 \n"  // R 8 bytes -> 4 shorts.
+      "ld1         {v0.16b}, [%1], #16           \n"  // next 8 ARGB4444 pixels.
+      ARGB4444TOARGB
+      "uadalp      v26.4h, v0.8b                 \n"  // B 8 bytes -> 4 shorts.
+      "uadalp      v27.4h, v1.8b                 \n"  // G 8 bytes -> 4 shorts.
+      "uadalp      v28.4h, v2.8b                 \n"  // R 8 bytes -> 4 shorts.
+
+      "ins         v16.D[1], v26.D[0]            \n"
+      "ins         v17.D[1], v27.D[0]            \n"
+      "ins         v18.D[1], v28.D[0]            \n"
+
+      "urshr       v0.8h, v16.8h, #1             \n"  // 2x average
+      "urshr       v1.8h, v17.8h, #1             \n"
+      "urshr       v2.8h, v18.8h, #1             \n"
+
+      "subs        %w4, %w4, #16                 \n"  // 16 processed per loop.
+      RGBTOUV(v0.8h, v1.8h, v2.8h)
+      "st1         {v0.8b}, [%2], #8             \n"  // store 8 pixels U.
+      "st1         {v1.8b}, [%3], #8             \n"  // store 8 pixels V.
+      "b.gt        1b                            \n"
+      : "+r"(src_argb4444),    // %0
+        "+r"(src_argb4444_1),  // %1
+        "+r"(dst_u),           // %2
+        "+r"(dst_v),           // %3
+        "+r"(width)            // %4
+      :
+      : "cc", "memory", "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v16", "v17",
+        "v18", "v19", "v20", "v21", "v22", "v23", "v24", "v25", "v26", "v27",
+        "v28"
+
+  );
+}
+
+void RGB565ToYRow_NEON(const uint8_t* src_rgb565, uint8_t* dst_y, int width) {
+  asm volatile(
+      "movi        v24.8b, #25                   \n"  // B * 0.1016 coefficient
+      "movi        v25.8b, #129                  \n"  // G * 0.5078 coefficient
+      "movi        v26.8b, #66                   \n"  // R * 0.2578 coefficient
+      "movi        v27.8b, #16                   \n"  // Add 16 constant
+      "1:                                        \n"
+      "ld1         {v0.16b}, [%0], #16           \n"  // load 8 RGB565 pixels.
+      "subs        %w2, %w2, #8                  \n"  // 8 processed per loop.
+      RGB565TOARGB
+      "umull       v3.8h, v0.8b, v24.8b          \n"  // B
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "umlal       v3.8h, v1.8b, v25.8b          \n"  // G
+      "umlal       v3.8h, v2.8b, v26.8b          \n"  // R
+      "uqrshrn     v0.8b, v3.8h, #8              \n"  // 16 bit to 8 bit Y
+      "uqadd       v0.8b, v0.8b, v27.8b          \n"
+      "st1         {v0.8b}, [%1], #8             \n"  // store 8 pixels Y.
+      "b.gt        1b                            \n"
+      : "+r"(src_rgb565),  // %0
+        "+r"(dst_y),       // %1
+        "+r"(width)        // %2
+      :
+      : "cc", "memory", "v0", "v1", "v2", "v3", "v4", "v6", "v24", "v25", "v26",
+        "v27");
+}
+
+void ARGB1555ToYRow_NEON(const uint8_t* src_argb1555,
+                         uint8_t* dst_y,
+                         int width) {
+  asm volatile(
+      "movi        v4.8b, #25                    \n"  // B * 0.1016 coefficient
+      "movi        v5.8b, #129                   \n"  // G * 0.5078 coefficient
+      "movi        v6.8b, #66                    \n"  // R * 0.2578 coefficient
+      "movi        v7.8b, #16                    \n"  // Add 16 constant
+      "1:                                        \n"
+      "ld1         {v0.16b}, [%0], #16           \n"  // load 8 ARGB1555 pixels.
+      "subs        %w2, %w2, #8                  \n"  // 8 processed per loop.
+      ARGB1555TOARGB
+      "umull       v3.8h, v0.8b, v4.8b           \n"  // B
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "umlal       v3.8h, v1.8b, v5.8b           \n"  // G
+      "umlal       v3.8h, v2.8b, v6.8b           \n"  // R
+      "uqrshrn     v0.8b, v3.8h, #8              \n"  // 16 bit to 8 bit Y
+      "uqadd       v0.8b, v0.8b, v7.8b           \n"
+      "st1         {v0.8b}, [%1], #8             \n"  // store 8 pixels Y.
+      "b.gt        1b                            \n"
+      : "+r"(src_argb1555),  // %0
+        "+r"(dst_y),         // %1
+        "+r"(width)          // %2
+      :
+      : "cc", "memory", "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7");
+}
+
+void ARGB4444ToYRow_NEON(const uint8_t* src_argb4444,
+                         uint8_t* dst_y,
+                         int width) {
+  asm volatile(
+      "movi        v24.8b, #25                   \n"  // B * 0.1016 coefficient
+      "movi        v25.8b, #129                  \n"  // G * 0.5078 coefficient
+      "movi        v26.8b, #66                   \n"  // R * 0.2578 coefficient
+      "movi        v27.8b, #16                   \n"  // Add 16 constant
+      "1:                                        \n"
+      "ld1         {v0.16b}, [%0], #16           \n"  // load 8 ARGB4444 pixels.
+      "subs        %w2, %w2, #8                  \n"  // 8 processed per loop.
+      ARGB4444TOARGB
+      "umull       v3.8h, v0.8b, v24.8b          \n"  // B
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "umlal       v3.8h, v1.8b, v25.8b          \n"  // G
+      "umlal       v3.8h, v2.8b, v26.8b          \n"  // R
+      "uqrshrn     v0.8b, v3.8h, #8              \n"  // 16 bit to 8 bit Y
+      "uqadd       v0.8b, v0.8b, v27.8b          \n"
+      "st1         {v0.8b}, [%1], #8             \n"  // store 8 pixels Y.
+      "b.gt        1b                            \n"
+      : "+r"(src_argb4444),  // %0
+        "+r"(dst_y),         // %1
+        "+r"(width)          // %2
+      :
+      : "cc", "memory", "v0", "v1", "v2", "v3", "v24", "v25", "v26", "v27");
+}
+
+struct RgbConstants {
+  uint8_t kRGBToY[4];
+  uint16_t kAddY;
+  uint16_t pad;
+};
+
+// RGB to JPeg coefficients
+// B * 0.1140 coefficient = 29
+// G * 0.5870 coefficient = 150
+// R * 0.2990 coefficient = 77
+// Add 0.5 = 0x80
+static const struct RgbConstants kRgb24JPEGConstants = {{29, 150, 77, 0}, 128};
+
+static const struct RgbConstants kRawJPEGConstants = {{77, 150, 29, 0}, 128};
+
+// RGB to BT.601 coefficients
+// B * 0.1016 coefficient = 25
+// G * 0.5078 coefficient = 129
+// R * 0.2578 coefficient = 66
+// Add 16.5 = 0x1080
+
+static const struct RgbConstants kRgb24I601Constants = {{25, 129, 66, 0},
+                                                        0x1080};
+
+static const struct RgbConstants kRawI601Constants = {{66, 129, 25, 0}, 0x1080};
+
+// ARGB expects first 3 values to contain RGB and 4th value is ignored.
+void ARGBToYMatrixRow_NEON(const uint8_t* src_argb,
+                           uint8_t* dst_y,
+                           int width,
+                           const struct RgbConstants* rgbconstants) {
+  asm volatile(
+      "ldr         d0, [%3]                      \n"  // load rgbconstants
+      "dup         v6.16b, v0.b[0]               \n"
+      "dup         v7.16b, v0.b[1]               \n"
+      "dup         v16.16b, v0.b[2]              \n"
+      "dup         v17.8h,  v0.h[2]              \n"
+      "1:                                        \n"
+      "ld4         {v2.16b,v3.16b,v4.16b,v5.16b}, [%0], #64 \n"  // load 16
+                                                                 // pixels.
+      "subs        %w2, %w2, #16                 \n"  // 16 processed per loop.
+      "umull       v0.8h, v2.8b, v6.8b           \n"  // B
+      "umull2      v1.8h, v2.16b, v6.16b         \n"
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "umlal       v0.8h, v3.8b, v7.8b           \n"  // G
+      "umlal2      v1.8h, v3.16b, v7.16b         \n"
+      "umlal       v0.8h, v4.8b, v16.8b          \n"  // R
+      "umlal2      v1.8h, v4.16b, v16.16b        \n"
+      "addhn       v0.8b, v0.8h, v17.8h          \n"  // 16 bit to 8 bit Y
+      "addhn       v1.8b, v1.8h, v17.8h          \n"
+      "st1         {v0.8b, v1.8b}, [%1], #16     \n"  // store 16 pixels Y.
+      "b.gt        1b                            \n"
+      : "+r"(src_argb),    // %0
+        "+r"(dst_y),       // %1
+        "+r"(width)        // %2
+      : "r"(rgbconstants)  // %3
+      : "cc", "memory", "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7", "v16",
+        "v17");
+}
+
+void ARGBToYRow_NEON(const uint8_t* src_argb, uint8_t* dst_y, int width) {
+  ARGBToYMatrixRow_NEON(src_argb, dst_y, width, &kRgb24I601Constants);
+}
+
+void ARGBToYJRow_NEON(const uint8_t* src_argb, uint8_t* dst_yj, int width) {
+  ARGBToYMatrixRow_NEON(src_argb, dst_yj, width, &kRgb24JPEGConstants);
+}
+
+void ABGRToYRow_NEON(const uint8_t* src_abgr, uint8_t* dst_y, int width) {
+  ARGBToYMatrixRow_NEON(src_abgr, dst_y, width, &kRawI601Constants);
+}
+
+// RGBA expects first value to be A and ignored, then 3 values to contain RGB.
+// Same code as ARGB, except the LD4
+void RGBAToYMatrixRow_NEON(const uint8_t* src_rgba,
+                           uint8_t* dst_y,
+                           int width,
+                           const struct RgbConstants* rgbconstants) {
+  asm volatile(
+      "ldr         d0, [%3]                      \n"  // load rgbconstants
+      "dup         v6.16b, v0.b[0]               \n"
+      "dup         v7.16b, v0.b[1]               \n"
+      "dup         v16.16b, v0.b[2]              \n"
+      "dup         v17.8h,  v0.h[2]              \n"
+      "1:                                        \n"
+      "ld4         {v1.16b,v2.16b,v3.16b,v4.16b}, [%0], #64 \n"  // load 16
+                                                                 // pixels.
+      "subs        %w2, %w2, #16                 \n"  // 16 processed per loop.
+      "umull       v0.8h, v2.8b, v6.8b           \n"  // B
+      "umull2      v1.8h, v2.16b, v6.16b         \n"
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "umlal       v0.8h, v3.8b, v7.8b           \n"  // G
+      "umlal2      v1.8h, v3.16b, v7.16b         \n"
+      "umlal       v0.8h, v4.8b, v16.8b          \n"  // R
+      "umlal2      v1.8h, v4.16b, v16.16b        \n"
+      "addhn       v0.8b, v0.8h, v17.8h          \n"  // 16 bit to 8 bit Y
+      "addhn       v1.8b, v1.8h, v17.8h          \n"
+      "st1         {v0.8b, v1.8b}, [%1], #16     \n"  // store 16 pixels Y.
+      "b.gt        1b                            \n"
+      : "+r"(src_rgba),    // %0
+        "+r"(dst_y),       // %1
+        "+r"(width)        // %2
+      : "r"(rgbconstants)  // %3
+      : "cc", "memory", "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7", "v16",
+        "v17");
+}
+
+void RGBAToYRow_NEON(const uint8_t* src_rgba, uint8_t* dst_y, int width) {
+  RGBAToYMatrixRow_NEON(src_rgba, dst_y, width, &kRgb24I601Constants);
+}
+
+void RGBAToYJRow_NEON(const uint8_t* src_rgba, uint8_t* dst_yj, int width) {
+  RGBAToYMatrixRow_NEON(src_rgba, dst_yj, width, &kRgb24JPEGConstants);
+}
+
+void BGRAToYRow_NEON(const uint8_t* src_bgra, uint8_t* dst_y, int width) {
+  RGBAToYMatrixRow_NEON(src_bgra, dst_y, width, &kRawI601Constants);
+}
+
+void RGBToYMatrixRow_NEON(const uint8_t* src_rgb,
+                          uint8_t* dst_y,
+                          int width,
+                          const struct RgbConstants* rgbconstants) {
+  asm volatile(
+      "ldr         d0, [%3]                      \n"  // load rgbconstants
+      "dup         v5.16b, v0.b[0]               \n"
+      "dup         v6.16b, v0.b[1]               \n"
+      "dup         v7.16b, v0.b[2]               \n"
+      "dup         v16.8h,  v0.h[2]              \n"
+      "1:                                        \n"
+      "ld3         {v2.16b,v3.16b,v4.16b}, [%0], #48 \n"  // load 16 pixels.
+      "subs        %w2, %w2, #16                 \n"  // 16 processed per loop.
+      "umull       v0.8h, v2.8b, v5.8b           \n"  // B
+      "umull2      v1.8h, v2.16b, v5.16b         \n"
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "umlal       v0.8h, v3.8b, v6.8b           \n"  // G
+      "umlal2      v1.8h, v3.16b, v6.16b         \n"
+      "umlal       v0.8h, v4.8b, v7.8b           \n"  // R
+      "umlal2      v1.8h, v4.16b, v7.16b         \n"
+      "addhn       v0.8b, v0.8h, v16.8h          \n"  // 16 bit to 8 bit Y
+      "addhn       v1.8b, v1.8h, v16.8h          \n"
+      "st1         {v0.8b, v1.8b}, [%1], #16     \n"  // store 16 pixels Y.
+      "b.gt        1b                            \n"
+      : "+r"(src_rgb),     // %0
+        "+r"(dst_y),       // %1
+        "+r"(width)        // %2
+      : "r"(rgbconstants)  // %3
+      : "cc", "memory", "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7", "v16");
+}
+
+void RGB24ToYJRow_NEON(const uint8_t* src_rgb24, uint8_t* dst_yj, int width) {
+  RGBToYMatrixRow_NEON(src_rgb24, dst_yj, width, &kRgb24JPEGConstants);
+}
+
+void RAWToYJRow_NEON(const uint8_t* src_raw, uint8_t* dst_yj, int width) {
+  RGBToYMatrixRow_NEON(src_raw, dst_yj, width, &kRawJPEGConstants);
+}
+
+void RGB24ToYRow_NEON(const uint8_t* src_rgb24, uint8_t* dst_y, int width) {
+  RGBToYMatrixRow_NEON(src_rgb24, dst_y, width, &kRgb24I601Constants);
+}
+
+void RAWToYRow_NEON(const uint8_t* src_raw, uint8_t* dst_y, int width) {
+  RGBToYMatrixRow_NEON(src_raw, dst_y, width, &kRawI601Constants);
+}
+
+// Bilinear filter 16x2 -> 16x1
+void InterpolateRow_NEON(uint8_t* dst_ptr,
+                         const uint8_t* src_ptr,
+                         ptrdiff_t src_stride,
+                         int dst_width,
+                         int source_y_fraction) {
+  int y1_fraction = source_y_fraction;
+  int y0_fraction = 256 - y1_fraction;
+  const uint8_t* src_ptr1 = src_ptr + src_stride;
+  asm volatile(
+      "cmp         %w4, #0                       \n"
+      "b.eq        100f                          \n"
+      "cmp         %w4, #128                     \n"
+      "b.eq        50f                           \n"
+
+      "dup         v5.16b, %w4                   \n"
+      "dup         v4.16b, %w5                   \n"
+      // General purpose row blend.
+      "1:                                        \n"
+      "ld1         {v0.16b}, [%1], #16           \n"
+      "ld1         {v1.16b}, [%2], #16           \n"
+      "subs        %w3, %w3, #16                 \n"
+      "umull       v2.8h, v0.8b,  v4.8b          \n"
+      "prfm        pldl1keep, [%1, 448]          \n"
+      "umull2      v3.8h, v0.16b, v4.16b         \n"
+      "prfm        pldl1keep, [%2, 448]          \n"
+      "umlal       v2.8h, v1.8b,  v5.8b          \n"
+      "umlal2      v3.8h, v1.16b, v5.16b         \n"
+      "rshrn       v0.8b,  v2.8h, #8             \n"
+      "rshrn2      v0.16b, v3.8h, #8             \n"
+      "st1         {v0.16b}, [%0], #16           \n"
+      "b.gt        1b                            \n"
+      "b           99f                           \n"
+
+      // Blend 50 / 50.
+      "50:                                       \n"
+      "ld1         {v0.16b}, [%1], #16           \n"
+      "ld1         {v1.16b}, [%2], #16           \n"
+      "subs        %w3, %w3, #16                 \n"
+      "prfm        pldl1keep, [%1, 448]          \n"
+      "urhadd      v0.16b, v0.16b, v1.16b        \n"
+      "prfm        pldl1keep, [%2, 448]          \n"
+      "st1         {v0.16b}, [%0], #16           \n"
+      "b.gt        50b                           \n"
+      "b           99f                           \n"
+
+      // Blend 100 / 0 - Copy row unchanged.
+      "100:                                      \n"
+      "ld1         {v0.16b}, [%1], #16           \n"
+      "subs        %w3, %w3, #16                 \n"
+      "prfm        pldl1keep, [%1, 448]          \n"
+      "st1         {v0.16b}, [%0], #16           \n"
+      "b.gt        100b                          \n"
+
+      "99:                                       \n"
+      : "+r"(dst_ptr),      // %0
+        "+r"(src_ptr),      // %1
+        "+r"(src_ptr1),     // %2
+        "+r"(dst_width),    // %3
+        "+r"(y1_fraction),  // %4
+        "+r"(y0_fraction)   // %5
+      :
+      : "cc", "memory", "v0", "v1", "v3", "v4", "v5");
+}
+
+// Bilinear filter 8x2 -> 8x1
+void InterpolateRow_16_NEON(uint16_t* dst_ptr,
+                            const uint16_t* src_ptr,
+                            ptrdiff_t src_stride,
+                            int dst_width,
+                            int source_y_fraction) {
+  int y1_fraction = source_y_fraction;
+  int y0_fraction = 256 - y1_fraction;
+  const uint16_t* src_ptr1 = src_ptr + src_stride;
+
+  asm volatile(
+      "cmp         %w4, #0                       \n"
+      "b.eq        100f                          \n"
+      "cmp         %w4, #128                     \n"
+      "b.eq        50f                           \n"
+
+      "dup         v5.8h, %w4                    \n"
+      "dup         v4.8h, %w5                    \n"
+      // General purpose row blend.
+      "1:                                        \n"
+      "ld1         {v0.8h}, [%1], #16            \n"
+      "ld1         {v1.8h}, [%2], #16            \n"
+      "subs        %w3, %w3, #8                  \n"
+      "umull       v2.4s, v0.4h, v4.4h           \n"
+      "prfm        pldl1keep, [%1, 448]          \n"
+      "umull2      v3.4s, v0.8h, v4.8h           \n"
+      "prfm        pldl1keep, [%2, 448]          \n"
+      "umlal       v2.4s, v1.4h, v5.4h           \n"
+      "umlal2      v3.4s, v1.8h, v5.8h           \n"
+      "rshrn       v0.4h, v2.4s, #8              \n"
+      "rshrn2      v0.8h, v3.4s, #8              \n"
+      "st1         {v0.8h}, [%0], #16            \n"
+      "b.gt        1b                            \n"
+      "b           99f                           \n"
+
+      // Blend 50 / 50.
+      "50:                                       \n"
+      "ld1         {v0.8h}, [%1], #16            \n"
+      "ld1         {v1.8h}, [%2], #16            \n"
+      "subs        %w3, %w3, #8                  \n"
+      "prfm        pldl1keep, [%1, 448]          \n"
+      "urhadd      v0.8h, v0.8h, v1.8h           \n"
+      "prfm        pldl1keep, [%2, 448]          \n"
+      "st1         {v0.8h}, [%0], #16            \n"
+      "b.gt        50b                           \n"
+      "b           99f                           \n"
+
+      // Blend 100 / 0 - Copy row unchanged.
+      "100:                                      \n"
+      "ld1         {v0.8h}, [%1], #16            \n"
+      "subs        %w3, %w3, #8                  \n"
+      "prfm        pldl1keep, [%1, 448]          \n"
+      "st1         {v0.8h}, [%0], #16            \n"
+      "b.gt        100b                          \n"
+
+      "99:                                       \n"
+      : "+r"(dst_ptr),     // %0
+        "+r"(src_ptr),     // %1
+        "+r"(src_ptr1),    // %2
+        "+r"(dst_width)    // %3
+      : "r"(y1_fraction),  // %4
+        "r"(y0_fraction)   // %5
+      : "cc", "memory", "v0", "v1", "v2", "v3", "v4", "v5");
+}
+
+// Bilinear filter 8x2 -> 8x1
+// Use scale to convert lsb formats to msb, depending how many bits there are:
+// 32768 = 9 bits
+// 16384 = 10 bits
+// 4096 = 12 bits
+// 256 = 16 bits
+void InterpolateRow_16To8_NEON(uint8_t* dst_ptr,
+                               const uint16_t* src_ptr,
+                               ptrdiff_t src_stride,
+                               int scale,
+                               int dst_width,
+                               int source_y_fraction) {
+  int y1_fraction = source_y_fraction;
+  int y0_fraction = 256 - y1_fraction;
+  const uint16_t* src_ptr1 = src_ptr + src_stride;
+  int shift = 15 - __builtin_clz((int32_t)scale);  // Negative shl is shr
+
+  asm volatile(
+      "dup         v6.8h, %w6                    \n"
+      "cmp         %w4, #0                       \n"
+      "b.eq        100f                          \n"
+      "cmp         %w4, #128                     \n"
+      "b.eq        50f                           \n"
+
+      "dup         v5.8h, %w4                    \n"
+      "dup         v4.8h, %w5                    \n"
+      // General purpose row blend.
+      "1:                                        \n"
+      "ld1         {v0.8h}, [%1], #16            \n"
+      "ld1         {v1.8h}, [%2], #16            \n"
+      "subs        %w3, %w3, #8                  \n"
+      "umull       v2.4s, v0.4h, v4.4h           \n"
+      "prfm        pldl1keep, [%1, 448]          \n"
+      "umull2      v3.4s, v0.8h, v4.8h           \n"
+      "prfm        pldl1keep, [%2, 448]          \n"
+      "umlal       v2.4s, v1.4h, v5.4h           \n"
+      "umlal2      v3.4s, v1.8h, v5.8h           \n"
+      "rshrn       v0.4h, v2.4s, #8              \n"
+      "rshrn2      v0.8h, v3.4s, #8              \n"
+      "ushl        v0.8h, v0.8h, v6.8h           \n"
+      "uqxtn       v0.8b, v0.8h                  \n"
+      "st1         {v0.8b}, [%0], #8             \n"
+      "b.gt        1b                            \n"
+      "b           99f                           \n"
+
+      // Blend 50 / 50.
+      "50:                                       \n"
+      "ld1         {v0.8h}, [%1], #16            \n"
+      "ld1         {v1.8h}, [%2], #16            \n"
+      "subs        %w3, %w3, #8                  \n"
+      "prfm        pldl1keep, [%1, 448]          \n"
+      "urhadd      v0.8h, v0.8h, v1.8h           \n"
+      "prfm        pldl1keep, [%2, 448]          \n"
+      "ushl        v0.8h, v0.8h, v6.8h           \n"
+      "uqxtn       v0.8b, v0.8h                  \n"
+      "st1         {v0.8b}, [%0], #8             \n"
+      "b.gt        50b                           \n"
+      "b           99f                           \n"
+
+      // Blend 100 / 0 - Copy row unchanged.
+      "100:                                      \n"
+      "ldr         q0, [%1], #16                 \n"
+      "ushl        v0.8h, v0.8h, v2.8h           \n"  // shr = v2 is negative
+      "prfm        pldl1keep, [%1, 448]          \n"
+      "uqxtn       v0.8b, v0.8h                  \n"
+      "subs        %w3, %w3, #8                  \n"  // 8 src pixels per loop
+      "str         d0, [%0], #8                  \n"  // store 8 pixels
+      "b.gt        100b                          \n"
+
+      "99:                                       \n"
+      : "+r"(dst_ptr),     // %0
+        "+r"(src_ptr),     // %1
+        "+r"(src_ptr1),    // %2
+        "+r"(dst_width)    // %3
+      : "r"(y1_fraction),  // %4
+        "r"(y0_fraction),  // %5
+        "r"(shift)         // %6
+      : "cc", "memory", "v0", "v1", "v2", "v3", "v4", "v5", "v6");
+}
+
+// dr * (256 - sa) / 256 + sr = dr - dr * sa / 256 + sr
+void ARGBBlendRow_NEON(const uint8_t* src_argb,
+                       const uint8_t* src_argb1,
+                       uint8_t* dst_argb,
+                       int width) {
+  asm volatile(
+      "subs        %w3, %w3, #8                  \n"
+      "b.lt        89f                           \n"
+      // Blend 8 pixels.
+      "8:                                        \n"
+      "ld4         {v0.8b,v1.8b,v2.8b,v3.8b}, [%0], #32 \n"  // load 8 ARGB0
+      "ld4         {v4.8b,v5.8b,v6.8b,v7.8b}, [%1], #32 \n"  // load 8 ARGB1
+      "subs        %w3, %w3, #8                  \n"  // 8 processed per loop.
+      "umull       v16.8h, v4.8b, v3.8b          \n"  // db * a
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "umull       v17.8h, v5.8b, v3.8b          \n"  // dg * a
+      "prfm        pldl1keep, [%1, 448]          \n"
+      "umull       v18.8h, v6.8b, v3.8b          \n"  // dr * a
+      "uqrshrn     v16.8b, v16.8h, #8            \n"  // db >>= 8
+      "uqrshrn     v17.8b, v17.8h, #8            \n"  // dg >>= 8
+      "uqrshrn     v18.8b, v18.8h, #8            \n"  // dr >>= 8
+      "uqsub       v4.8b, v4.8b, v16.8b          \n"  // db - (db * a / 256)
+      "uqsub       v5.8b, v5.8b, v17.8b          \n"  // dg - (dg * a / 256)
+      "uqsub       v6.8b, v6.8b, v18.8b          \n"  // dr - (dr * a / 256)
+      "uqadd       v0.8b, v0.8b, v4.8b           \n"  // + sb
+      "uqadd       v1.8b, v1.8b, v5.8b           \n"  // + sg
+      "uqadd       v2.8b, v2.8b, v6.8b           \n"  // + sr
+      "movi        v3.8b, #255                   \n"  // a = 255
+      "st4         {v0.8b,v1.8b,v2.8b,v3.8b}, [%2], #32 \n"  // store 8 ARGB
+                                                             // pixels
+      "b.ge        8b                            \n"
+
+      "89:                                       \n"
+      "adds        %w3, %w3, #8-1                \n"
+      "b.lt        99f                           \n"
+
+      // Blend 1 pixels.
+      "1:                                        \n"
+      "ld4         {v0.b,v1.b,v2.b,v3.b}[0], [%0], #4 \n"  // load 1 pixel
+                                                           // ARGB0.
+      "ld4         {v4.b,v5.b,v6.b,v7.b}[0], [%1], #4 \n"  // load 1 pixel
+                                                           // ARGB1.
+      "subs        %w3, %w3, #1                  \n"  // 1 processed per loop.
+      "umull       v16.8h, v4.8b, v3.8b          \n"  // db * a
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "umull       v17.8h, v5.8b, v3.8b          \n"  // dg * a
+      "prfm        pldl1keep, [%1, 448]          \n"
+      "umull       v18.8h, v6.8b, v3.8b          \n"  // dr * a
+      "uqrshrn     v16.8b, v16.8h, #8            \n"  // db >>= 8
+      "uqrshrn     v17.8b, v17.8h, #8            \n"  // dg >>= 8
+      "uqrshrn     v18.8b, v18.8h, #8            \n"  // dr >>= 8
+      "uqsub       v4.8b, v4.8b, v16.8b          \n"  // db - (db * a / 256)
+      "uqsub       v5.8b, v5.8b, v17.8b          \n"  // dg - (dg * a / 256)
+      "uqsub       v6.8b, v6.8b, v18.8b          \n"  // dr - (dr * a / 256)
+      "uqadd       v0.8b, v0.8b, v4.8b           \n"  // + sb
+      "uqadd       v1.8b, v1.8b, v5.8b           \n"  // + sg
+      "uqadd       v2.8b, v2.8b, v6.8b           \n"  // + sr
+      "movi        v3.8b, #255                   \n"  // a = 255
+      "st4         {v0.b,v1.b,v2.b,v3.b}[0], [%2], #4 \n"  // store 1 pixel.
+      "b.ge        1b                            \n"
+
+      "99:                                       \n"
+
+      : "+r"(src_argb),   // %0
+        "+r"(src_argb1),  // %1
+        "+r"(dst_argb),   // %2
+        "+r"(width)       // %3
+      :
+      : "cc", "memory", "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7", "v16",
+        "v17", "v18");
+}
+
+// Attenuate 8 pixels at a time.
+void ARGBAttenuateRow_NEON(const uint8_t* src_argb,
+                           uint8_t* dst_argb,
+                           int width) {
+  asm volatile(
+      // Attenuate 8 pixels.
+      "1:                                        \n"
+      "ld4         {v0.8b,v1.8b,v2.8b,v3.8b}, [%0], #32 \n"  // load 8 ARGB
+      "subs        %w2, %w2, #8                  \n"  // 8 processed per loop.
+      "umull       v4.8h, v0.8b, v3.8b           \n"  // b * a
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "umull       v5.8h, v1.8b, v3.8b           \n"         // g * a
+      "umull       v6.8h, v2.8b, v3.8b           \n"         // r * a
+      "uqrshrn     v0.8b, v4.8h, #8              \n"         // b >>= 8
+      "uqrshrn     v1.8b, v5.8h, #8              \n"         // g >>= 8
+      "uqrshrn     v2.8b, v6.8h, #8              \n"         // r >>= 8
+      "st4         {v0.8b,v1.8b,v2.8b,v3.8b}, [%1], #32 \n"  // store 8 ARGB
+      "b.gt        1b                            \n"
+      : "+r"(src_argb),  // %0
+        "+r"(dst_argb),  // %1
+        "+r"(width)      // %2
+      :
+      : "cc", "memory", "v0", "v1", "v2", "v3", "v4", "v5", "v6");
+}
+
+// Quantize 8 ARGB pixels (32 bytes).
+// dst = (dst * scale >> 16) * interval_size + interval_offset;
+void ARGBQuantizeRow_NEON(uint8_t* dst_argb,
+                          int scale,
+                          int interval_size,
+                          int interval_offset,
+                          int width) {
+  asm volatile(
+      "dup         v4.8h, %w2                    \n"
+      "ushr        v4.8h, v4.8h, #1              \n"  // scale >>= 1
+      "dup         v5.8h, %w3                    \n"  // interval multiply.
+      "dup         v6.8h, %w4                    \n"  // interval add
+
+      // 8 pixel loop.
+      "1:                                        \n"
+      "ld4         {v0.8b,v1.8b,v2.8b,v3.8b}, [%0] \n"  // load 8  ARGB.
+      "subs        %w1, %w1, #8                  \n"    // 8 processed per loop.
+      "uxtl        v0.8h, v0.8b                  \n"    // b (0 .. 255)
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "uxtl        v1.8h, v1.8b                  \n"
+      "uxtl        v2.8h, v2.8b                  \n"
+      "sqdmulh     v0.8h, v0.8h, v4.8h           \n"  // b * scale
+      "sqdmulh     v1.8h, v1.8h, v4.8h           \n"  // g
+      "sqdmulh     v2.8h, v2.8h, v4.8h           \n"  // r
+      "mul         v0.8h, v0.8h, v5.8h           \n"  // b * interval_size
+      "mul         v1.8h, v1.8h, v5.8h           \n"  // g
+      "mul         v2.8h, v2.8h, v5.8h           \n"  // r
+      "add         v0.8h, v0.8h, v6.8h           \n"  // b + interval_offset
+      "add         v1.8h, v1.8h, v6.8h           \n"  // g
+      "add         v2.8h, v2.8h, v6.8h           \n"  // r
+      "uqxtn       v0.8b, v0.8h                  \n"
+      "uqxtn       v1.8b, v1.8h                  \n"
+      "uqxtn       v2.8b, v2.8h                  \n"
+      "st4         {v0.8b,v1.8b,v2.8b,v3.8b}, [%0], #32 \n"  // store 8 ARGB
+      "b.gt        1b                            \n"
+      : "+r"(dst_argb),       // %0
+        "+r"(width)           // %1
+      : "r"(scale),           // %2
+        "r"(interval_size),   // %3
+        "r"(interval_offset)  // %4
+      : "cc", "memory", "v0", "v1", "v2", "v3", "v4", "v5", "v6");
+}
+
+// Shade 8 pixels at a time by specified value.
+// NOTE vqrdmulh.s16 q10, q10, d0[0] must use a scaler register from 0 to 8.
+// Rounding in vqrdmulh does +1 to high if high bit of low s16 is set.
+void ARGBShadeRow_NEON(const uint8_t* src_argb,
+                       uint8_t* dst_argb,
+                       int width,
+                       uint32_t value) {
+  asm volatile(
+      "dup         v0.4s, %w3                    \n"  // duplicate scale value.
+      "zip1        v0.8b, v0.8b, v0.8b           \n"  // v0.8b aarrggbb.
+      "ushr        v0.8h, v0.8h, #1              \n"  // scale / 2.
+
+      // 8 pixel loop.
+      "1:                                        \n"
+      "ld4         {v4.8b,v5.8b,v6.8b,v7.8b}, [%0], #32 \n"  // load 8 ARGB
+      "subs        %w2, %w2, #8                  \n"  // 8 processed per loop.
+      "uxtl        v4.8h, v4.8b                  \n"  // b (0 .. 255)
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "uxtl        v5.8h, v5.8b                  \n"
+      "uxtl        v6.8h, v6.8b                  \n"
+      "uxtl        v7.8h, v7.8b                  \n"
+      "sqrdmulh    v4.8h, v4.8h, v0.h[0]         \n"  // b * scale * 2
+      "sqrdmulh    v5.8h, v5.8h, v0.h[1]         \n"  // g
+      "sqrdmulh    v6.8h, v6.8h, v0.h[2]         \n"  // r
+      "sqrdmulh    v7.8h, v7.8h, v0.h[3]         \n"  // a
+      "uqxtn       v4.8b, v4.8h                  \n"
+      "uqxtn       v5.8b, v5.8h                  \n"
+      "uqxtn       v6.8b, v6.8h                  \n"
+      "uqxtn       v7.8b, v7.8h                  \n"
+      "st4         {v4.8b,v5.8b,v6.8b,v7.8b}, [%1], #32 \n"  // store 8 ARGB
+      "b.gt        1b                            \n"
+      : "+r"(src_argb),  // %0
+        "+r"(dst_argb),  // %1
+        "+r"(width)      // %2
+      : "r"(value)       // %3
+      : "cc", "memory", "v0", "v4", "v5", "v6", "v7");
+}
+
+// Convert 8 ARGB pixels (64 bytes) to 8 Gray ARGB pixels
+// Similar to ARGBToYJ but stores ARGB.
+// C code is (29 * b + 150 * g + 77 * r + 128) >> 8;
+void ARGBGrayRow_NEON(const uint8_t* src_argb, uint8_t* dst_argb, int width) {
+  asm volatile(
+      "movi        v24.8b, #29                   \n"  // B * 0.1140 coefficient
+      "movi        v25.8b, #150                  \n"  // G * 0.5870 coefficient
+      "movi        v26.8b, #77                   \n"  // R * 0.2990 coefficient
+      "1:                                        \n"
+      "ld4         {v0.8b,v1.8b,v2.8b,v3.8b}, [%0], #32 \n"  // load 8 ARGB
+      "subs        %w2, %w2, #8                  \n"  // 8 processed per loop.
+      "umull       v4.8h, v0.8b, v24.8b          \n"  // B
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "umlal       v4.8h, v1.8b, v25.8b          \n"  // G
+      "umlal       v4.8h, v2.8b, v26.8b          \n"  // R
+      "uqrshrn     v0.8b, v4.8h, #8              \n"  // 16 bit to 8 bit B
+      "orr         v1.8b, v0.8b, v0.8b           \n"  // G
+      "orr         v2.8b, v0.8b, v0.8b           \n"  // R
+      "st4         {v0.8b,v1.8b,v2.8b,v3.8b}, [%1], #32 \n"  // store 8 pixels.
+      "b.gt        1b                            \n"
+      : "+r"(src_argb),  // %0
+        "+r"(dst_argb),  // %1
+        "+r"(width)      // %2
+      :
+      : "cc", "memory", "v0", "v1", "v2", "v3", "v4", "v24", "v25", "v26");
+}
+
+// Convert 8 ARGB pixels (32 bytes) to 8 Sepia ARGB pixels.
+//    b = (r * 35 + g * 68 + b * 17) >> 7
+//    g = (r * 45 + g * 88 + b * 22) >> 7
+//    r = (r * 50 + g * 98 + b * 24) >> 7
+
+void ARGBSepiaRow_NEON(uint8_t* dst_argb, int width) {
+  asm volatile(
+      "movi        v20.8b, #17                   \n"  // BB coefficient
+      "movi        v21.8b, #68                   \n"  // BG coefficient
+      "movi        v22.8b, #35                   \n"  // BR coefficient
+      "movi        v24.8b, #22                   \n"  // GB coefficient
+      "movi        v25.8b, #88                   \n"  // GG coefficient
+      "movi        v26.8b, #45                   \n"  // GR coefficient
+      "movi        v28.8b, #24                   \n"  // BB coefficient
+      "movi        v29.8b, #98                   \n"  // BG coefficient
+      "movi        v30.8b, #50                   \n"  // BR coefficient
+      "1:                                        \n"
+      "ld4         {v0.8b,v1.8b,v2.8b,v3.8b}, [%0] \n"  // load 8 ARGB pixels.
+      "subs        %w1, %w1, #8                  \n"    // 8 processed per loop.
+      "umull       v4.8h, v0.8b, v20.8b          \n"    // B to Sepia B
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "umlal       v4.8h, v1.8b, v21.8b          \n"  // G
+      "umlal       v4.8h, v2.8b, v22.8b          \n"  // R
+      "umull       v5.8h, v0.8b, v24.8b          \n"  // B to Sepia G
+      "umlal       v5.8h, v1.8b, v25.8b          \n"  // G
+      "umlal       v5.8h, v2.8b, v26.8b          \n"  // R
+      "umull       v6.8h, v0.8b, v28.8b          \n"  // B to Sepia R
+      "umlal       v6.8h, v1.8b, v29.8b          \n"  // G
+      "umlal       v6.8h, v2.8b, v30.8b          \n"  // R
+      "uqshrn      v0.8b, v4.8h, #7              \n"  // 16 bit to 8 bit B
+      "uqshrn      v1.8b, v5.8h, #7              \n"  // 16 bit to 8 bit G
+      "uqshrn      v2.8b, v6.8h, #7              \n"  // 16 bit to 8 bit R
+      "st4         {v0.8b,v1.8b,v2.8b,v3.8b}, [%0], #32 \n"  // store 8 pixels.
+      "b.gt        1b                            \n"
+      : "+r"(dst_argb),  // %0
+        "+r"(width)      // %1
+      :
+      : "cc", "memory", "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7", "v20",
+        "v21", "v22", "v24", "v25", "v26", "v28", "v29", "v30");
+}
+
+// Tranform 8 ARGB pixels (32 bytes) with color matrix.
+// TODO(fbarchard): Was same as Sepia except matrix is provided.  This function
+// needs to saturate.  Consider doing a non-saturating version.
+void ARGBColorMatrixRow_NEON(const uint8_t* src_argb,
+                             uint8_t* dst_argb,
+                             const int8_t* matrix_argb,
+                             int width) {
+  asm volatile(
+      "ld1         {v2.16b}, [%3]                \n"  // load 3 ARGB vectors.
+      "sxtl        v0.8h, v2.8b                  \n"  // B,G coefficients s16.
+      "sxtl2       v1.8h, v2.16b                 \n"  // R,A coefficients s16.
+
+      "1:                                        \n"
+      "ld4         {v16.8b,v17.8b,v18.8b,v19.8b}, [%0], #32 \n"  // load 8 ARGB
+      "subs        %w2, %w2, #8                  \n"  // 8 processed per loop.
+      "uxtl        v16.8h, v16.8b                \n"  // b (0 .. 255) 16 bit
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "uxtl        v17.8h, v17.8b                \n"  // g
+      "uxtl        v18.8h, v18.8b                \n"  // r
+      "uxtl        v19.8h, v19.8b                \n"  // a
+      "mul         v22.8h, v16.8h, v0.h[0]       \n"  // B = B * Matrix B
+      "mul         v23.8h, v16.8h, v0.h[4]       \n"  // G = B * Matrix G
+      "mul         v24.8h, v16.8h, v1.h[0]       \n"  // R = B * Matrix R
+      "mul         v25.8h, v16.8h, v1.h[4]       \n"  // A = B * Matrix A
+      "mul         v4.8h, v17.8h, v0.h[1]        \n"  // B += G * Matrix B
+      "mul         v5.8h, v17.8h, v0.h[5]        \n"  // G += G * Matrix G
+      "mul         v6.8h, v17.8h, v1.h[1]        \n"  // R += G * Matrix R
+      "mul         v7.8h, v17.8h, v1.h[5]        \n"  // A += G * Matrix A
+      "sqadd       v22.8h, v22.8h, v4.8h         \n"  // Accumulate B
+      "sqadd       v23.8h, v23.8h, v5.8h         \n"  // Accumulate G
+      "sqadd       v24.8h, v24.8h, v6.8h         \n"  // Accumulate R
+      "sqadd       v25.8h, v25.8h, v7.8h         \n"  // Accumulate A
+      "mul         v4.8h, v18.8h, v0.h[2]        \n"  // B += R * Matrix B
+      "mul         v5.8h, v18.8h, v0.h[6]        \n"  // G += R * Matrix G
+      "mul         v6.8h, v18.8h, v1.h[2]        \n"  // R += R * Matrix R
+      "mul         v7.8h, v18.8h, v1.h[6]        \n"  // A += R * Matrix A
+      "sqadd       v22.8h, v22.8h, v4.8h         \n"  // Accumulate B
+      "sqadd       v23.8h, v23.8h, v5.8h         \n"  // Accumulate G
+      "sqadd       v24.8h, v24.8h, v6.8h         \n"  // Accumulate R
+      "sqadd       v25.8h, v25.8h, v7.8h         \n"  // Accumulate A
+      "mul         v4.8h, v19.8h, v0.h[3]        \n"  // B += A * Matrix B
+      "mul         v5.8h, v19.8h, v0.h[7]        \n"  // G += A * Matrix G
+      "mul         v6.8h, v19.8h, v1.h[3]        \n"  // R += A * Matrix R
+      "mul         v7.8h, v19.8h, v1.h[7]        \n"  // A += A * Matrix A
+      "sqadd       v22.8h, v22.8h, v4.8h         \n"  // Accumulate B
+      "sqadd       v23.8h, v23.8h, v5.8h         \n"  // Accumulate G
+      "sqadd       v24.8h, v24.8h, v6.8h         \n"  // Accumulate R
+      "sqadd       v25.8h, v25.8h, v7.8h         \n"  // Accumulate A
+      "sqshrun     v16.8b, v22.8h, #6            \n"  // 16 bit to 8 bit B
+      "sqshrun     v17.8b, v23.8h, #6            \n"  // 16 bit to 8 bit G
+      "sqshrun     v18.8b, v24.8h, #6            \n"  // 16 bit to 8 bit R
+      "sqshrun     v19.8b, v25.8h, #6            \n"  // 16 bit to 8 bit A
+      "st4         {v16.8b,v17.8b,v18.8b,v19.8b}, [%1], #32 \n"  // store 8 ARGB
+      "b.gt        1b                            \n"
+      : "+r"(src_argb),   // %0
+        "+r"(dst_argb),   // %1
+        "+r"(width)       // %2
+      : "r"(matrix_argb)  // %3
+      : "cc", "memory", "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7", "v16",
+        "v17", "v18", "v19", "v22", "v23", "v24", "v25");
+}
+
+// TODO(fbarchard): fix vqshrun in ARGBMultiplyRow_NEON and reenable.
+// Multiply 2 rows of ARGB pixels together, 8 pixels at a time.
+void ARGBMultiplyRow_NEON(const uint8_t* src_argb,
+                          const uint8_t* src_argb1,
+                          uint8_t* dst_argb,
+                          int width) {
+  asm volatile(
+      // 8 pixel loop.
+      "1:                                        \n"
+      "ld4         {v0.8b,v1.8b,v2.8b,v3.8b}, [%0], #32 \n"  // load 8 ARGB
+      "ld4         {v4.8b,v5.8b,v6.8b,v7.8b}, [%1], #32 \n"  // load 8 more
+      "subs        %w3, %w3, #8                  \n"  // 8 processed per loop.
+      "umull       v0.8h, v0.8b, v4.8b           \n"  // multiply B
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "umull       v1.8h, v1.8b, v5.8b           \n"  // multiply G
+      "prfm        pldl1keep, [%1, 448]          \n"
+      "umull       v2.8h, v2.8b, v6.8b           \n"  // multiply R
+      "umull       v3.8h, v3.8b, v7.8b           \n"  // multiply A
+      "rshrn       v0.8b, v0.8h, #8              \n"  // 16 bit to 8 bit B
+      "rshrn       v1.8b, v1.8h, #8              \n"  // 16 bit to 8 bit G
+      "rshrn       v2.8b, v2.8h, #8              \n"  // 16 bit to 8 bit R
+      "rshrn       v3.8b, v3.8h, #8              \n"  // 16 bit to 8 bit A
+      "st4         {v0.8b,v1.8b,v2.8b,v3.8b}, [%2], #32 \n"  // store 8 ARGB
+      "b.gt        1b                            \n"
+      : "+r"(src_argb),   // %0
+        "+r"(src_argb1),  // %1
+        "+r"(dst_argb),   // %2
+        "+r"(width)       // %3
+      :
+      : "cc", "memory", "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7");
+}
+
+// Add 2 rows of ARGB pixels together, 8 pixels at a time.
+void ARGBAddRow_NEON(const uint8_t* src_argb,
+                     const uint8_t* src_argb1,
+                     uint8_t* dst_argb,
+                     int width) {
+  asm volatile(
+      // 8 pixel loop.
+      "1:                                        \n"
+      "ld4         {v0.8b,v1.8b,v2.8b,v3.8b}, [%0], #32 \n"  // load 8 ARGB
+      "ld4         {v4.8b,v5.8b,v6.8b,v7.8b}, [%1], #32 \n"  // load 8 more
+      "subs        %w3, %w3, #8                  \n"  // 8 processed per loop.
+      "uqadd       v0.8b, v0.8b, v4.8b           \n"
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "uqadd       v1.8b, v1.8b, v5.8b           \n"
+      "prfm        pldl1keep, [%1, 448]          \n"
+      "uqadd       v2.8b, v2.8b, v6.8b           \n"
+      "uqadd       v3.8b, v3.8b, v7.8b           \n"
+      "st4         {v0.8b,v1.8b,v2.8b,v3.8b}, [%2], #32 \n"  // store 8 ARGB
+      "b.gt        1b                            \n"
+      : "+r"(src_argb),   // %0
+        "+r"(src_argb1),  // %1
+        "+r"(dst_argb),   // %2
+        "+r"(width)       // %3
+      :
+      : "cc", "memory", "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7");
+}
+
+// Subtract 2 rows of ARGB pixels, 8 pixels at a time.
+void ARGBSubtractRow_NEON(const uint8_t* src_argb,
+                          const uint8_t* src_argb1,
+                          uint8_t* dst_argb,
+                          int width) {
+  asm volatile(
+      // 8 pixel loop.
+      "1:                                        \n"
+      "ld4         {v0.8b,v1.8b,v2.8b,v3.8b}, [%0], #32 \n"  // load 8 ARGB
+      "ld4         {v4.8b,v5.8b,v6.8b,v7.8b}, [%1], #32 \n"  // load 8 more
+      "subs        %w3, %w3, #8                  \n"  // 8 processed per loop.
+      "uqsub       v0.8b, v0.8b, v4.8b           \n"
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "uqsub       v1.8b, v1.8b, v5.8b           \n"
+      "prfm        pldl1keep, [%1, 448]          \n"
+      "uqsub       v2.8b, v2.8b, v6.8b           \n"
+      "uqsub       v3.8b, v3.8b, v7.8b           \n"
+      "st4         {v0.8b,v1.8b,v2.8b,v3.8b}, [%2], #32 \n"  // store 8 ARGB
+      "b.gt        1b                            \n"
+      : "+r"(src_argb),   // %0
+        "+r"(src_argb1),  // %1
+        "+r"(dst_argb),   // %2
+        "+r"(width)       // %3
+      :
+      : "cc", "memory", "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7");
+}
+
+// Adds Sobel X and Sobel Y and stores Sobel into ARGB.
+// A = 255
+// R = Sobel
+// G = Sobel
+// B = Sobel
+void SobelRow_NEON(const uint8_t* src_sobelx,
+                   const uint8_t* src_sobely,
+                   uint8_t* dst_argb,
+                   int width) {
+  asm volatile(
+      "movi        v3.8b, #255                   \n"  // alpha
+      // 8 pixel loop.
+      "1:                                        \n"
+      "ld1         {v0.8b}, [%0], #8             \n"  // load 8 sobelx.
+      "ld1         {v1.8b}, [%1], #8             \n"  // load 8 sobely.
+      "subs        %w3, %w3, #8                  \n"  // 8 processed per loop.
+      "uqadd       v0.8b, v0.8b, v1.8b           \n"  // add
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "orr         v1.8b, v0.8b, v0.8b           \n"
+      "prfm        pldl1keep, [%1, 448]          \n"
+      "orr         v2.8b, v0.8b, v0.8b           \n"
+      "st4         {v0.8b,v1.8b,v2.8b,v3.8b}, [%2], #32 \n"  // store 8 ARGB
+      "b.gt        1b                            \n"
+      : "+r"(src_sobelx),  // %0
+        "+r"(src_sobely),  // %1
+        "+r"(dst_argb),    // %2
+        "+r"(width)        // %3
+      :
+      : "cc", "memory", "v0", "v1", "v2", "v3");
+}
+
+// Adds Sobel X and Sobel Y and stores Sobel into plane.
+void SobelToPlaneRow_NEON(const uint8_t* src_sobelx,
+                          const uint8_t* src_sobely,
+                          uint8_t* dst_y,
+                          int width) {
+  asm volatile(
+      // 16 pixel loop.
+      "1:                                        \n"
+      "ld1         {v0.16b}, [%0], #16           \n"  // load 16 sobelx.
+      "ld1         {v1.16b}, [%1], #16           \n"  // load 16 sobely.
+      "subs        %w3, %w3, #16                 \n"  // 16 processed per loop.
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "uqadd       v0.16b, v0.16b, v1.16b        \n"  // add
+      "prfm        pldl1keep, [%1, 448]          \n"
+      "st1         {v0.16b}, [%2], #16           \n"  // store 16 pixels.
+      "b.gt        1b                            \n"
+      : "+r"(src_sobelx),  // %0
+        "+r"(src_sobely),  // %1
+        "+r"(dst_y),       // %2
+        "+r"(width)        // %3
+      :
+      : "cc", "memory", "v0", "v1");
+}
+
+// Mixes Sobel X, Sobel Y and Sobel into ARGB.
+// A = 255
+// R = Sobel X
+// G = Sobel
+// B = Sobel Y
+void SobelXYRow_NEON(const uint8_t* src_sobelx,
+                     const uint8_t* src_sobely,
+                     uint8_t* dst_argb,
+                     int width) {
+  asm volatile(
+      "movi        v3.8b, #255                   \n"  // alpha
+      // 8 pixel loop.
+      "1:                                        \n"
+      "ld1         {v2.8b}, [%0], #8             \n"  // load 8 sobelx.
+      "ld1         {v0.8b}, [%1], #8             \n"  // load 8 sobely.
+      "subs        %w3, %w3, #8                  \n"  // 8 processed per loop.
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "uqadd       v1.8b, v0.8b, v2.8b           \n"  // add
+      "prfm        pldl1keep, [%1, 448]          \n"
+      "st4         {v0.8b,v1.8b,v2.8b,v3.8b}, [%2], #32 \n"  // store 8 ARGB
+      "b.gt        1b                            \n"
+      : "+r"(src_sobelx),  // %0
+        "+r"(src_sobely),  // %1
+        "+r"(dst_argb),    // %2
+        "+r"(width)        // %3
+      :
+      : "cc", "memory", "v0", "v1", "v2", "v3");
+}
+
+// SobelX as a matrix is
+// -1  0  1
+// -2  0  2
+// -1  0  1
+void SobelXRow_NEON(const uint8_t* src_y0,
+                    const uint8_t* src_y1,
+                    const uint8_t* src_y2,
+                    uint8_t* dst_sobelx,
+                    int width) {
+  asm volatile(
+      "1:                                        \n"
+      "ld1         {v0.8b}, [%0],%5              \n"  // top
+      "ld1         {v1.8b}, [%0],%6              \n"
+      "usubl       v0.8h, v0.8b, v1.8b           \n"
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "ld1         {v2.8b}, [%1],%5              \n"  // center * 2
+      "ld1         {v3.8b}, [%1],%6              \n"
+      "usubl       v1.8h, v2.8b, v3.8b           \n"
+      "prfm        pldl1keep, [%1, 448]          \n"
+      "add         v0.8h, v0.8h, v1.8h           \n"
+      "add         v0.8h, v0.8h, v1.8h           \n"
+      "ld1         {v2.8b}, [%2],%5              \n"  // bottom
+      "ld1         {v3.8b}, [%2],%6              \n"
+      "subs        %w4, %w4, #8                  \n"  // 8 pixels
+      "prfm        pldl1keep, [%2, 448]          \n"
+      "usubl       v1.8h, v2.8b, v3.8b           \n"
+      "add         v0.8h, v0.8h, v1.8h           \n"
+      "abs         v0.8h, v0.8h                  \n"
+      "uqxtn       v0.8b, v0.8h                  \n"
+      "st1         {v0.8b}, [%3], #8             \n"  // store 8 sobelx
+      "b.gt        1b                            \n"
+      : "+r"(src_y0),                           // %0
+        "+r"(src_y1),                           // %1
+        "+r"(src_y2),                           // %2
+        "+r"(dst_sobelx),                       // %3
+        "+r"(width)                             // %4
+      : "r"(2LL),                               // %5
+        "r"(6LL)                                // %6
+      : "cc", "memory", "v0", "v1", "v2", "v3"  // Clobber List
+  );
+}
+
+// SobelY as a matrix is
+// -1 -2 -1
+//  0  0  0
+//  1  2  1
+void SobelYRow_NEON(const uint8_t* src_y0,
+                    const uint8_t* src_y1,
+                    uint8_t* dst_sobely,
+                    int width) {
+  asm volatile(
+      "1:                                        \n"
+      "ld1         {v0.8b}, [%0],%4              \n"  // left
+      "ld1         {v1.8b}, [%1],%4              \n"
+      "usubl       v0.8h, v0.8b, v1.8b           \n"
+      "ld1         {v2.8b}, [%0],%4              \n"  // center * 2
+      "ld1         {v3.8b}, [%1],%4              \n"
+      "usubl       v1.8h, v2.8b, v3.8b           \n"
+      "add         v0.8h, v0.8h, v1.8h           \n"
+      "add         v0.8h, v0.8h, v1.8h           \n"
+      "ld1         {v2.8b}, [%0],%5              \n"  // right
+      "ld1         {v3.8b}, [%1],%5              \n"
+      "subs        %w3, %w3, #8                  \n"  // 8 pixels
+      "usubl       v1.8h, v2.8b, v3.8b           \n"
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "add         v0.8h, v0.8h, v1.8h           \n"
+      "prfm        pldl1keep, [%1, 448]          \n"
+      "abs         v0.8h, v0.8h                  \n"
+      "uqxtn       v0.8b, v0.8h                  \n"
+      "st1         {v0.8b}, [%2], #8             \n"  // store 8 sobely
+      "b.gt        1b                            \n"
+      : "+r"(src_y0),                           // %0
+        "+r"(src_y1),                           // %1
+        "+r"(dst_sobely),                       // %2
+        "+r"(width)                             // %3
+      : "r"(1LL),                               // %4
+        "r"(6LL)                                // %5
+      : "cc", "memory", "v0", "v1", "v2", "v3"  // Clobber List
+  );
+}
+
+// Caveat - rounds float to half float whereas scaling version truncates.
+void HalfFloat1Row_NEON(const uint16_t* src,
+                        uint16_t* dst,
+                        float /*unused*/,
+                        int width) {
+  asm volatile(
+      "1:                                        \n"
+      "ld1         {v1.16b}, [%0], #16           \n"  // load 8 shorts
+      "subs        %w2, %w2, #8                  \n"  // 8 pixels per loop
+      "uxtl        v2.4s, v1.4h                  \n"  // 8 int's
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "uxtl2       v3.4s, v1.8h                  \n"
+      "scvtf       v2.4s, v2.4s                  \n"  // 8 floats
+      "scvtf       v3.4s, v3.4s                  \n"
+      "fcvtn       v1.4h, v2.4s                  \n"  // 8 half floats
+      "fcvtn2      v1.8h, v3.4s                  \n"
+      "st1         {v1.16b}, [%1], #16           \n"  // store 8 shorts
+      "b.gt        1b                            \n"
+      : "+r"(src),   // %0
+        "+r"(dst),   // %1
+        "+r"(width)  // %2
+      :
+      : "cc", "memory", "v1", "v2", "v3");
+}
+
+void HalfFloatRow_NEON(const uint16_t* src,
+                       uint16_t* dst,
+                       float scale,
+                       int width) {
+  asm volatile(
+      "1:                                        \n"
+      "ld1         {v1.16b}, [%0], #16           \n"  // load 8 shorts
+      "subs        %w2, %w2, #8                  \n"  // 8 pixels per loop
+      "uxtl        v2.4s, v1.4h                  \n"  // 8 int's
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "uxtl2       v3.4s, v1.8h                  \n"
+      "scvtf       v2.4s, v2.4s                  \n"  // 8 floats
+      "scvtf       v3.4s, v3.4s                  \n"
+      "fmul        v2.4s, v2.4s, %3.s[0]         \n"  // adjust exponent
+      "fmul        v3.4s, v3.4s, %3.s[0]         \n"
+      "uqshrn      v1.4h, v2.4s, #13             \n"  // isolate halffloat
+      "uqshrn2     v1.8h, v3.4s, #13             \n"
+      "st1         {v1.16b}, [%1], #16           \n"  // store 8 shorts
+      "b.gt        1b                            \n"
+      : "+r"(src),                      // %0
+        "+r"(dst),                      // %1
+        "+r"(width)                     // %2
+      : "w"(scale * 1.9259299444e-34f)  // %3
+      : "cc", "memory", "v1", "v2", "v3");
+}
+
+void ByteToFloatRow_NEON(const uint8_t* src,
+                         float* dst,
+                         float scale,
+                         int width) {
+  asm volatile(
+      "1:                                        \n"
+      "ld1         {v1.8b}, [%0], #8             \n"  // load 8 bytes
+      "subs        %w2, %w2, #8                  \n"  // 8 pixels per loop
+      "uxtl        v1.8h, v1.8b                  \n"  // 8 shorts
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "uxtl        v2.4s, v1.4h                  \n"  // 8 ints
+      "uxtl2       v3.4s, v1.8h                  \n"
+      "scvtf       v2.4s, v2.4s                  \n"  // 8 floats
+      "scvtf       v3.4s, v3.4s                  \n"
+      "fmul        v2.4s, v2.4s, %3.s[0]         \n"  // scale
+      "fmul        v3.4s, v3.4s, %3.s[0]         \n"
+      "st1         {v2.16b, v3.16b}, [%1], #32   \n"  // store 8 floats
+      "b.gt        1b                            \n"
+      : "+r"(src),   // %0
+        "+r"(dst),   // %1
+        "+r"(width)  // %2
+      : "w"(scale)   // %3
+      : "cc", "memory", "v1", "v2", "v3");
+}
+
+float ScaleMaxSamples_NEON(const float* src,
+                           float* dst,
+                           float scale,
+                           int width) {
+  float fmax;
+  asm volatile(
+      "movi        v5.4s, #0                     \n"  // max
+      "movi        v6.4s, #0                     \n"
+
+      "1:                                        \n"
+      "ld1         {v1.4s, v2.4s}, [%0], #32     \n"  // load 8 samples
+      "subs        %w2, %w2, #8                  \n"  // 8 processed per loop
+      "fmul        v3.4s, v1.4s, %4.s[0]         \n"  // scale
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "fmul        v4.4s, v2.4s, %4.s[0]         \n"  // scale
+      "fmax        v5.4s, v5.4s, v1.4s           \n"  // max
+      "fmax        v6.4s, v6.4s, v2.4s           \n"
+      "st1         {v3.4s, v4.4s}, [%1], #32     \n"  // store 8 samples
+      "b.gt        1b                            \n"
+      "fmax        v5.4s, v5.4s, v6.4s           \n"  // max
+      "fmaxv       %s3, v5.4s                    \n"  // signed max acculator
+      : "+r"(src),                                    // %0
+        "+r"(dst),                                    // %1
+        "+r"(width),                                  // %2
+        "=w"(fmax)                                    // %3
+      : "w"(scale)                                    // %4
+      : "cc", "memory", "v1", "v2", "v3", "v4", "v5", "v6");
+  return fmax;
+}
+
+float ScaleSumSamples_NEON(const float* src,
+                           float* dst,
+                           float scale,
+                           int width) {
+  float fsum;
+  asm volatile(
+      "movi        v5.4s, #0                     \n"  // max
+      "movi        v6.4s, #0                     \n"  // max
+
+      "1:                                        \n"
+      "ld1         {v1.4s, v2.4s}, [%0], #32     \n"  // load 8 samples
+      "subs        %w2, %w2, #8                  \n"  // 8 processed per loop
+      "fmul        v3.4s, v1.4s, %4.s[0]         \n"  // scale
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "fmul        v4.4s, v2.4s, %4.s[0]         \n"
+      "fmla        v5.4s, v1.4s, v1.4s           \n"  // sum of squares
+      "fmla        v6.4s, v2.4s, v2.4s           \n"
+      "st1         {v3.4s, v4.4s}, [%1], #32     \n"  // store 8 samples
+      "b.gt        1b                            \n"
+      "faddp       v5.4s, v5.4s, v6.4s           \n"
+      "faddp       v5.4s, v5.4s, v5.4s           \n"
+      "faddp       %3.4s, v5.4s, v5.4s           \n"  // sum
+      : "+r"(src),                                    // %0
+        "+r"(dst),                                    // %1
+        "+r"(width),                                  // %2
+        "=w"(fsum)                                    // %3
+      : "w"(scale)                                    // %4
+      : "cc", "memory", "v1", "v2", "v3", "v4", "v5", "v6");
+  return fsum;
+}
+
+void ScaleSamples_NEON(const float* src, float* dst, float scale, int width) {
+  asm volatile(
+      "1:                                        \n"
+      "ld1         {v1.4s, v2.4s}, [%0], #32     \n"  // load 8 samples
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "subs        %w2, %w2, #8                  \n"  // 8 processed per loop
+      "fmul        v1.4s, v1.4s, %3.s[0]         \n"  // scale
+      "fmul        v2.4s, v2.4s, %3.s[0]         \n"  // scale
+      "st1         {v1.4s, v2.4s}, [%1], #32     \n"  // store 8 samples
+      "b.gt        1b                            \n"
+      : "+r"(src),   // %0
+        "+r"(dst),   // %1
+        "+r"(width)  // %2
+      : "w"(scale)   // %3
+      : "cc", "memory", "v1", "v2");
+}
+
+// filter 5 rows with 1, 4, 6, 4, 1 coefficients to produce 1 row.
+void GaussCol_NEON(const uint16_t* src0,
+                   const uint16_t* src1,
+                   const uint16_t* src2,
+                   const uint16_t* src3,
+                   const uint16_t* src4,
+                   uint32_t* dst,
+                   int width) {
+  asm volatile(
+      "movi        v6.8h, #4                     \n"  // constant 4
+      "movi        v7.8h, #6                     \n"  // constant 6
+
+      "1:                                        \n"
+      "ld1         {v1.8h}, [%0], #16            \n"  // load 8 samples, 5 rows
+      "ld1         {v2.8h}, [%4], #16            \n"
+      "uaddl       v0.4s, v1.4h, v2.4h           \n"  // * 1
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "uaddl2      v1.4s, v1.8h, v2.8h           \n"  // * 1
+      "ld1         {v2.8h}, [%1], #16            \n"
+      "umlal       v0.4s, v2.4h, v6.4h           \n"  // * 4
+      "prfm        pldl1keep, [%1, 448]          \n"
+      "umlal2      v1.4s, v2.8h, v6.8h           \n"  // * 4
+      "ld1         {v2.8h}, [%2], #16            \n"
+      "umlal       v0.4s, v2.4h, v7.4h           \n"  // * 6
+      "prfm        pldl1keep, [%2, 448]          \n"
+      "umlal2      v1.4s, v2.8h, v7.8h           \n"  // * 6
+      "ld1         {v2.8h}, [%3], #16            \n"
+      "umlal       v0.4s, v2.4h, v6.4h           \n"  // * 4
+      "prfm        pldl1keep, [%3, 448]          \n"
+      "umlal2      v1.4s, v2.8h, v6.8h           \n"  // * 4
+      "subs        %w6, %w6, #8                  \n"  // 8 processed per loop
+      "st1         {v0.4s,v1.4s}, [%5], #32      \n"  // store 8 samples
+      "prfm        pldl1keep, [%4, 448]          \n"
+      "b.gt        1b                            \n"
+      : "+r"(src0),  // %0
+        "+r"(src1),  // %1
+        "+r"(src2),  // %2
+        "+r"(src3),  // %3
+        "+r"(src4),  // %4
+        "+r"(dst),   // %5
+        "+r"(width)  // %6
+      :
+      : "cc", "memory", "v0", "v1", "v2", "v6", "v7");
+}
+
+// filter 5 rows with 1, 4, 6, 4, 1 coefficients to produce 1 row.
+void GaussRow_NEON(const uint32_t* src, uint16_t* dst, int width) {
+  const uint32_t* src1 = src + 1;
+  const uint32_t* src2 = src + 2;
+  const uint32_t* src3 = src + 3;
+  asm volatile(
+      "movi        v6.4s, #4                     \n"  // constant 4
+      "movi        v7.4s, #6                     \n"  // constant 6
+
+      "1:                                        \n"
+      "ld1         {v0.4s,v1.4s,v2.4s}, [%0], %6 \n"  // load 12 source samples
+      "add         v0.4s, v0.4s, v1.4s           \n"  // * 1
+      "add         v1.4s, v1.4s, v2.4s           \n"  // * 1
+      "ld1         {v2.4s,v3.4s}, [%2], #32      \n"
+      "mla         v0.4s, v2.4s, v7.4s           \n"  // * 6
+      "mla         v1.4s, v3.4s, v7.4s           \n"  // * 6
+      "ld1         {v2.4s,v3.4s}, [%1], #32      \n"
+      "ld1         {v4.4s,v5.4s}, [%3], #32      \n"
+      "add         v2.4s, v2.4s, v4.4s           \n"  // add rows for * 4
+      "add         v3.4s, v3.4s, v5.4s           \n"
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "mla         v0.4s, v2.4s, v6.4s           \n"  // * 4
+      "mla         v1.4s, v3.4s, v6.4s           \n"  // * 4
+      "subs        %w5, %w5, #8                  \n"  // 8 processed per loop
+      "uqrshrn     v0.4h, v0.4s, #8              \n"  // round and pack
+      "uqrshrn2    v0.8h, v1.4s, #8              \n"
+      "st1         {v0.8h}, [%4], #16            \n"  // store 8 samples
+      "b.gt        1b                            \n"
+      : "+r"(src),   // %0
+        "+r"(src1),  // %1
+        "+r"(src2),  // %2
+        "+r"(src3),  // %3
+        "+r"(dst),   // %4
+        "+r"(width)  // %5
+      : "r"(32LL)    // %6
+      : "cc", "memory", "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7");
+}
+
+static const vecf32 kGaussCoefficients = {4.0f, 6.0f, 1.0f / 256.0f, 0.0f};
+
+// filter 5 rows with 1, 4, 6, 4, 1 coefficients to produce 1 row.
+void GaussCol_F32_NEON(const float* src0,
+                       const float* src1,
+                       const float* src2,
+                       const float* src3,
+                       const float* src4,
+                       float* dst,
+                       int width) {
+  asm volatile(
+      "ld2r        {v6.4s, v7.4s}, [%7]          \n"  // constants 4 and 6
+
+      "1:                                        \n"
+      "ld1         {v0.4s, v1.4s}, [%0], #32     \n"  // load 8 samples, 5 rows
+      "ld1         {v2.4s, v3.4s}, [%1], #32     \n"
+      "fmla        v0.4s, v2.4s, v6.4s           \n"  // * 4
+      "ld1         {v4.4s, v5.4s}, [%2], #32     \n"
+      "fmla        v1.4s, v3.4s, v6.4s           \n"
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "fmla        v0.4s, v4.4s, v7.4s           \n"  // * 6
+      "ld1         {v2.4s, v3.4s}, [%3], #32     \n"
+      "fmla        v1.4s, v5.4s, v7.4s           \n"
+      "prfm        pldl1keep, [%1, 448]          \n"
+      "fmla        v0.4s, v2.4s, v6.4s           \n"  // * 4
+      "ld1         {v4.4s, v5.4s}, [%4], #32     \n"
+      "fmla        v1.4s, v3.4s, v6.4s           \n"
+      "prfm        pldl1keep, [%2, 448]          \n"
+      "fadd        v0.4s, v0.4s, v4.4s           \n"  // * 1
+      "prfm        pldl1keep, [%3, 448]          \n"
+      "fadd        v1.4s, v1.4s, v5.4s           \n"
+      "prfm        pldl1keep, [%4, 448]          \n"
+      "subs        %w6, %w6, #8                  \n"  // 8 processed per loop
+      "st1         {v0.4s, v1.4s}, [%5], #32     \n"  // store 8 samples
+      "b.gt        1b                            \n"
+      : "+r"(src0),               // %0
+        "+r"(src1),               // %1
+        "+r"(src2),               // %2
+        "+r"(src3),               // %3
+        "+r"(src4),               // %4
+        "+r"(dst),                // %5
+        "+r"(width)               // %6
+      : "r"(&kGaussCoefficients)  // %7
+      : "cc", "memory", "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7");
+}
+
+// filter 5 rows with 1, 4, 6, 4, 1 coefficients to produce 1 row.
+void GaussRow_F32_NEON(const float* src, float* dst, int width) {
+  asm volatile(
+      "ld3r        {v6.4s, v7.4s, v8.4s}, [%3]   \n"  // constants 4, 6, 1/256
+
+      "1:                                        \n"
+      "ld1         {v0.4s, v1.4s, v2.4s}, [%0], %4 \n"  // load 12 samples, 5
+                                                        // rows
+      "fadd        v0.4s, v0.4s, v1.4s           \n"    // * 1
+      "ld1         {v4.4s, v5.4s}, [%0], %5      \n"
+      "fadd        v1.4s, v1.4s, v2.4s           \n"
+      "fmla        v0.4s, v4.4s, v7.4s           \n"  // * 6
+      "ld1         {v2.4s, v3.4s}, [%0], %4      \n"
+      "fmla        v1.4s, v5.4s, v7.4s           \n"
+      "ld1         {v4.4s, v5.4s}, [%0], %6      \n"
+      "fadd        v2.4s, v2.4s, v4.4s           \n"
+      "fadd        v3.4s, v3.4s, v5.4s           \n"
+      "fmla        v0.4s, v2.4s, v6.4s           \n"  // * 4
+      "fmla        v1.4s, v3.4s, v6.4s           \n"
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "fmul        v0.4s, v0.4s, v8.4s           \n"  // / 256
+      "fmul        v1.4s, v1.4s, v8.4s           \n"
+      "subs        %w2, %w2, #8                  \n"  // 8 processed per loop
+      "st1         {v0.4s, v1.4s}, [%1], #32     \n"  // store 8 samples
+      "b.gt        1b                            \n"
+      : "+r"(src),                 // %0
+        "+r"(dst),                 // %1
+        "+r"(width)                // %2
+      : "r"(&kGaussCoefficients),  // %3
+        "r"(8LL),                  // %4
+        "r"(-4LL),                 // %5
+        "r"(20LL)                  // %6
+      : "cc", "memory", "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7", "v8");
+}
+
+#if LIBYUV_USE_ST3
+// Convert biplanar NV21 to packed YUV24
+void NV21ToYUV24Row_NEON(const uint8_t* src_y,
+                         const uint8_t* src_vu,
+                         uint8_t* dst_yuv24,
+                         int width) {
+  asm volatile(
+      "1:                                        \n"
+      "ld1         {v2.16b}, [%0], #16           \n"  // load 16 Y values
+      "ld2         {v0.8b, v1.8b}, [%1], #16     \n"  // load 8 VU values
+      "zip1        v0.16b, v0.16b, v0.16b        \n"  // replicate V values
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "zip1        v1.16b, v1.16b, v1.16b        \n"  // replicate U values
+      "prfm        pldl1keep, [%1, 448]          \n"
+      "subs        %w3, %w3, #16                 \n"      // 16 pixels per loop
+      "st3         {v0.16b,v1.16b,v2.16b}, [%2], #48 \n"  // store 16 YUV pixels
+      "b.gt        1b                            \n"
+      : "+r"(src_y),      // %0
+        "+r"(src_vu),     // %1
+        "+r"(dst_yuv24),  // %2
+        "+r"(width)       // %3
+      :
+      : "cc", "memory", "v0", "v1", "v2");
+}
+#else
+static const uvec8 kYUV24Shuffle[3] = {
+    {16, 17, 0, 16, 17, 1, 18, 19, 2, 18, 19, 3, 20, 21, 4, 20},
+    {21, 5, 22, 23, 6, 22, 23, 7, 24, 25, 8, 24, 25, 9, 26, 27},
+    {10, 26, 27, 11, 28, 29, 12, 28, 29, 13, 30, 31, 14, 30, 31, 15}};
+
+// Convert biplanar NV21 to packed YUV24
+// NV21 has VU in memory for chroma.
+// YUV24 is VUY in memory
+void NV21ToYUV24Row_NEON(const uint8_t* src_y,
+                         const uint8_t* src_vu,
+                         uint8_t* dst_yuv24,
+                         int width) {
+  asm volatile(
+      "ld1         {v5.16b,v6.16b,v7.16b}, [%4]  \n"  // 3 shuffler constants
+      "1:                                        \n"
+      "ld1         {v0.16b}, [%0], #16           \n"    // load 16 Y values
+      "ld1         {v1.16b}, [%1], #16           \n"    // load 8 VU values
+      "tbl         v2.16b, {v0.16b,v1.16b}, v5.16b \n"  // weave into YUV24
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "tbl         v3.16b, {v0.16b,v1.16b}, v6.16b \n"
+      "prfm        pldl1keep, [%1, 448]          \n"
+      "tbl         v4.16b, {v0.16b,v1.16b}, v7.16b \n"
+      "subs        %w3, %w3, #16                 \n"      // 16 pixels per loop
+      "st1         {v2.16b,v3.16b,v4.16b}, [%2], #48 \n"  // store 16 YUV pixels
+      "b.gt        1b                            \n"
+      : "+r"(src_y),            // %0
+        "+r"(src_vu),           // %1
+        "+r"(dst_yuv24),        // %2
+        "+r"(width)             // %3
+      : "r"(&kYUV24Shuffle[0])  // %4
+      : "cc", "memory", "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7");
+}
+#endif  // LIBYUV_USE_ST3
+
+// Note ST2 8b version is faster than zip+ST1
+
+// AYUV is VUYA in memory.  UV for NV12 is UV order in memory.
+void AYUVToUVRow_NEON(const uint8_t* src_ayuv,
+                      int src_stride_ayuv,
+                      uint8_t* dst_uv,
+                      int width) {
+  const uint8_t* src_ayuv_1 = src_ayuv + src_stride_ayuv;
+  asm volatile(
+
+      "1:                                        \n"
+      "ld4         {v0.16b,v1.16b,v2.16b,v3.16b}, [%0], #64 \n"  // load 16 ayuv
+      "uaddlp      v0.8h, v0.16b                 \n"  // V 16 bytes -> 8 shorts.
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "uaddlp      v1.8h, v1.16b                 \n"  // U 16 bytes -> 8 shorts.
+      "ld4         {v4.16b,v5.16b,v6.16b,v7.16b}, [%1], #64 \n"  // load next 16
+      "uadalp      v0.8h, v4.16b                 \n"  // V 16 bytes -> 8 shorts.
+      "uadalp      v1.8h, v5.16b                 \n"  // U 16 bytes -> 8 shorts.
+      "prfm        pldl1keep, [%1, 448]          \n"
+      "uqrshrn     v3.8b, v0.8h, #2              \n"  // 2x2 average
+      "uqrshrn     v2.8b, v1.8h, #2              \n"
+      "subs        %w3, %w3, #16                 \n"  // 16 processed per loop.
+      "st2         {v2.8b,v3.8b}, [%2], #16      \n"  // store 8 pixels UV.
+      "b.gt        1b                            \n"
+      : "+r"(src_ayuv),    // %0
+        "+r"(src_ayuv_1),  // %1
+        "+r"(dst_uv),      // %2
+        "+r"(width)        // %3
+      :
+      : "cc", "memory", "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7");
+}
+
+void AYUVToVURow_NEON(const uint8_t* src_ayuv,
+                      int src_stride_ayuv,
+                      uint8_t* dst_vu,
+                      int width) {
+  const uint8_t* src_ayuv_1 = src_ayuv + src_stride_ayuv;
+  asm volatile(
+
+      "1:                                        \n"
+      "ld4         {v0.16b,v1.16b,v2.16b,v3.16b}, [%0], #64 \n"  // load 16 ayuv
+      "uaddlp      v0.8h, v0.16b                 \n"  // V 16 bytes -> 8 shorts.
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "uaddlp      v1.8h, v1.16b                 \n"  // U 16 bytes -> 8 shorts.
+      "ld4         {v4.16b,v5.16b,v6.16b,v7.16b}, [%1], #64 \n"  // load next 16
+      "uadalp      v0.8h, v4.16b                 \n"  // V 16 bytes -> 8 shorts.
+      "uadalp      v1.8h, v5.16b                 \n"  // U 16 bytes -> 8 shorts.
+      "prfm        pldl1keep, [%1, 448]          \n"
+      "uqrshrn     v0.8b, v0.8h, #2              \n"  // 2x2 average
+      "uqrshrn     v1.8b, v1.8h, #2              \n"
+      "subs        %w3, %w3, #16                 \n"  // 16 processed per loop.
+      "st2         {v0.8b,v1.8b}, [%2], #16      \n"  // store 8 pixels VU.
+      "b.gt        1b                            \n"
+      : "+r"(src_ayuv),    // %0
+        "+r"(src_ayuv_1),  // %1
+        "+r"(dst_vu),      // %2
+        "+r"(width)        // %3
+      :
+      : "cc", "memory", "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7");
+}
+
+// Copy row of AYUV Y's into Y
+void AYUVToYRow_NEON(const uint8_t* src_ayuv, uint8_t* dst_y, int width) {
+  asm volatile(
+      "1:                                        \n"
+      "ld4         {v0.16b,v1.16b,v2.16b,v3.16b}, [%0], #64 \n"  // load 16
+      "subs        %w2, %w2, #16                 \n"  // 16 pixels per loop
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "st1         {v2.16b}, [%1], #16           \n"  // store 16 Y pixels
+      "b.gt        1b                            \n"
+      : "+r"(src_ayuv),  // %0
+        "+r"(dst_y),     // %1
+        "+r"(width)      // %2
+      :
+      : "cc", "memory", "v0", "v1", "v2", "v3");
+}
+
+// Shuffle table for swapping UV bytes.
+static const uvec8 kShuffleSwapUV = {1u, 0u, 3u,  2u,  5u,  4u,  7u,  6u,
+                                     9u, 8u, 11u, 10u, 13u, 12u, 15u, 14u};
+
+// Convert UV plane of NV12 to VU of NV21.
+void SwapUVRow_NEON(const uint8_t* src_uv, uint8_t* dst_vu, int width) {
+  asm volatile(
+      "ld1         {v2.16b}, [%3]                \n"  // shuffler
+      "1:                                        \n"
+      "ld1         {v0.16b}, [%0], 16            \n"  // load 16 UV values
+      "ld1         {v1.16b}, [%0], 16            \n"
+      "subs        %w2, %w2, #16                 \n"  // 16 pixels per loop
+      "tbl         v0.16b, {v0.16b}, v2.16b      \n"
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "tbl         v1.16b, {v1.16b}, v2.16b      \n"
+      "stp         q0, q1, [%1], 32              \n"  // store 16 VU pixels
+      "b.gt        1b                            \n"
+      : "+r"(src_uv),         // %0
+        "+r"(dst_vu),         // %1
+        "+r"(width)           // %2
+      : "r"(&kShuffleSwapUV)  // %3
+      : "cc", "memory", "v0", "v1", "v2");
+}
+
+void HalfMergeUVRow_NEON(const uint8_t* src_u,
+                         int src_stride_u,
+                         const uint8_t* src_v,
+                         int src_stride_v,
+                         uint8_t* dst_uv,
+                         int width) {
+  const uint8_t* src_u_1 = src_u + src_stride_u;
+  const uint8_t* src_v_1 = src_v + src_stride_v;
+  asm volatile(
+      "1:                                        \n"
+      "ld1         {v0.16b}, [%0], #16           \n"  // load 16 U values
+      "ld1         {v1.16b}, [%2], #16           \n"  // load 16 V values
+      "ld1         {v2.16b}, [%1], #16           \n"
+      "ld1         {v3.16b}, [%3], #16           \n"
+      "uaddlp      v0.8h, v0.16b                 \n"  // half size
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "uaddlp      v1.8h, v1.16b                 \n"
+      "prfm        pldl1keep, [%2, 448]          \n"
+      "uadalp      v0.8h, v2.16b                 \n"
+      "prfm        pldl1keep, [%1, 448]          \n"
+      "uadalp      v1.8h, v3.16b                 \n"
+      "prfm        pldl1keep, [%3, 448]          \n"
+      "uqrshrn     v0.8b, v0.8h, #2              \n"
+      "uqrshrn     v1.8b, v1.8h, #2              \n"
+      "subs        %w5, %w5, #16                 \n"  // 16 src pixels per loop
+      "st2         {v0.8b, v1.8b}, [%4], #16     \n"  // store 8 UV pixels
+      "b.gt        1b                            \n"
+      : "+r"(src_u),    // %0
+        "+r"(src_u_1),  // %1
+        "+r"(src_v),    // %2
+        "+r"(src_v_1),  // %3
+        "+r"(dst_uv),   // %4
+        "+r"(width)     // %5
+      :
+      : "cc", "memory", "v0", "v1", "v2", "v3");
+}
+
+void SplitUVRow_16_NEON(const uint16_t* src_uv,
+                        uint16_t* dst_u,
+                        uint16_t* dst_v,
+                        int depth,
+                        int width) {
+  int shift = depth - 16;  // Negative for right shift.
+  asm volatile(
+      "dup         v2.8h, %w4                    \n"
+      "1:                                        \n"
+      "ld2         {v0.8h, v1.8h}, [%0], #32     \n"  // load 8 UV
+      "subs        %w3, %w3, #8                  \n"  // 8 src pixels per loop
+      "ushl        v0.8h, v0.8h, v2.8h           \n"
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "ushl        v1.8h, v1.8h, v2.8h           \n"
+      "st1         {v0.8h}, [%1], #16            \n"  // store 8 U pixels
+      "st1         {v1.8h}, [%2], #16            \n"  // store 8 V pixels
+      "b.gt        1b                            \n"
+      : "+r"(src_uv),  // %0
+        "+r"(dst_u),   // %1
+        "+r"(dst_v),   // %2
+        "+r"(width)    // %3
+      : "r"(shift)     // %4
+      : "cc", "memory", "v0", "v1", "v2");
+}
+
+void MultiplyRow_16_NEON(const uint16_t* src_y,
+                         uint16_t* dst_y,
+                         int scale,
+                         int width) {
+  asm volatile(
+      "dup         v2.8h, %w3                    \n"
+      "1:                                        \n"
+      "ldp         q0, q1, [%0], #32             \n"
+      "mul         v0.8h, v0.8h, v2.8h           \n"
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "mul         v1.8h, v1.8h, v2.8h           \n"
+      "stp         q0, q1, [%1], #32             \n"  // store 16 pixels
+      "subs        %w2, %w2, #16                 \n"  // 16 src pixels per loop
+      "b.gt        1b                            \n"
+      : "+r"(src_y),  // %0
+        "+r"(dst_y),  // %1
+        "+r"(width)   // %2
+      : "r"(scale)    // %3
+      : "cc", "memory", "v0", "v1", "v2");
+}
+
+void DivideRow_16_NEON(const uint16_t* src_y,
+                       uint16_t* dst_y,
+                       int scale,
+                       int width) {
+  asm volatile(
+      "dup         v0.8h, %w3                    \n"
+      "1:                                        \n"
+      "ldp         q1, q2, [%0], #32             \n"
+      "ushll       v3.4s, v1.4h, #0              \n"
+      "ushll       v4.4s, v2.4h, #0              \n"
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "ushll2      v1.4s, v1.8h, #0              \n"
+      "ushll2      v2.4s, v2.8h, #0              \n"
+      "mul         v3.4s, v0.4s, v3.4s           \n"
+      "mul         v4.4s, v0.4s, v4.4s           \n"
+      "mul         v1.4s, v0.4s, v1.4s           \n"
+      "mul         v2.4s, v0.4s, v2.4s           \n"
+      "shrn        v3.4h, v3.4s, #16             \n"
+      "shrn        v4.4h, v4.4s, #16             \n"
+      "shrn2       v3.8h, v1.4s, #16             \n"
+      "shrn2       v4.8h, v2.4s, #16             \n"
+      "stp         q3, q3, [%1], #32             \n"  // store 16 pixels
+      "subs        %w2, %w2, #16                 \n"  // 16 src pixels per loop
+      "b.gt        1b                            \n"
+      : "+r"(src_y),  // %0
+        "+r"(dst_y),  // %1
+        "+r"(width)   // %2
+      : "r"(scale)    // %3
+      : "cc", "memory", "v0", "v1", "v2", "v3", "v4");
+}
+
+// Use scale to convert lsb formats to msb, depending how many bits there are:
+// 32768 = 9 bits = shr 1
+// 16384 = 10 bits = shr 2
+// 4096 = 12 bits = shr 4
+// 256 = 16 bits = shr 8
+void Convert16To8Row_NEON(const uint16_t* src_y,
+                          uint8_t* dst_y,
+                          int scale,
+                          int width) {
+  int shift = 15 - __builtin_clz((int32_t)scale);  // Negative shl is shr
+  asm volatile(
+      "dup         v2.8h, %w3                    \n"
+      "1:                                        \n"
+      "ldp         q0, q1, [%0], #32             \n"
+      "ushl        v0.8h, v0.8h, v2.8h           \n"  // shr = v2 is negative
+      "ushl        v1.8h, v1.8h, v2.8h           \n"
+      "prfm        pldl1keep, [%0, 448]          \n"
+      "uqxtn       v0.8b, v0.8h                  \n"
+      "uqxtn2      v0.16b, v1.8h                 \n"
+      "subs        %w2, %w2, #16                 \n"  // 16 src pixels per loop
+      "str         q0, [%1], #16                 \n"  // store 16 pixels
+      "b.gt        1b                            \n"
+      : "+r"(src_y),  // %0
+        "+r"(dst_y),  // %1
+        "+r"(width)   // %2
+      : "r"(shift)    // %3
+      : "cc", "memory", "v0", "v1", "v2");
+}
+
+#endif  // !defined(LIBYUV_DISABLE_NEON) && defined(__aarch64__)
+
+#ifdef __cplusplus
+}  // extern "C"
+}  // namespace libyuv
+#endif
diff --git a/3rdparty/libyuv/src/source/row_win.cc b/3rdparty/libyuv/src/source/row_win.cc
new file mode 100644
index 00000000..7dccacc7
--- /dev/null
+++ b/3rdparty/libyuv/src/source/row_win.cc
@@ -0,0 +1,6403 @@
+/*
+ *  Copyright 2011 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include "libyuv/row.h"
+
+// This module is for Visual C 32/64 bit
+#if !defined(LIBYUV_DISABLE_X86) && defined(_MSC_VER) && \
+    !defined(__clang__) && (defined(_M_IX86) || defined(_M_X64))
+
+#if defined(_M_X64)
+#include <emmintrin.h>
+#include <tmmintrin.h>  // For _mm_maddubs_epi16
+#endif
+
+#ifdef __cplusplus
+namespace libyuv {
+extern "C" {
+#endif
+
+// 64 bit
+#if defined(_M_X64)
+
+// Read 8 UV from 444
+#define READYUV444                                    \
+  xmm3 = _mm_loadl_epi64((__m128i*)u_buf);            \
+  xmm1 = _mm_loadl_epi64((__m128i*)(u_buf + offset)); \
+  xmm3 = _mm_unpacklo_epi8(xmm3, xmm1);               \
+  u_buf += 8;                                         \
+  xmm4 = _mm_loadl_epi64((__m128i*)y_buf);            \
+  xmm4 = _mm_unpacklo_epi8(xmm4, xmm4);               \
+  y_buf += 8;
+
+// Read 8 UV from 444, With 8 Alpha.
+#define READYUVA444                                   \
+  xmm3 = _mm_loadl_epi64((__m128i*)u_buf);            \
+  xmm1 = _mm_loadl_epi64((__m128i*)(u_buf + offset)); \
+  xmm3 = _mm_unpacklo_epi8(xmm3, xmm1);               \
+  u_buf += 8;                                         \
+  xmm4 = _mm_loadl_epi64((__m128i*)y_buf);            \
+  xmm4 = _mm_unpacklo_epi8(xmm4, xmm4);               \
+  y_buf += 8;                                         \
+  xmm5 = _mm_loadl_epi64((__m128i*)a_buf);            \
+  a_buf += 8;
+
+// Read 4 UV from 422, upsample to 8 UV.
+#define READYUV422                                        \
+  xmm3 = _mm_cvtsi32_si128(*(uint32_t*)u_buf);            \
+  xmm1 = _mm_cvtsi32_si128(*(uint32_t*)(u_buf + offset)); \
+  xmm3 = _mm_unpacklo_epi8(xmm3, xmm1);                   \
+  xmm3 = _mm_unpacklo_epi16(xmm3, xmm3);                  \
+  u_buf += 4;                                             \
+  xmm4 = _mm_loadl_epi64((__m128i*)y_buf);                \
+  xmm4 = _mm_unpacklo_epi8(xmm4, xmm4);                   \
+  y_buf += 8;
+
+// Read 4 UV from 422, upsample to 8 UV.  With 8 Alpha.
+#define READYUVA422                                       \
+  xmm3 = _mm_cvtsi32_si128(*(uint32_t*)u_buf);            \
+  xmm1 = _mm_cvtsi32_si128(*(uint32_t*)(u_buf + offset)); \
+  xmm3 = _mm_unpacklo_epi8(xmm3, xmm1);                   \
+  xmm3 = _mm_unpacklo_epi16(xmm3, xmm3);                  \
+  u_buf += 4;                                             \
+  xmm4 = _mm_loadl_epi64((__m128i*)y_buf);                \
+  xmm4 = _mm_unpacklo_epi8(xmm4, xmm4);                   \
+  y_buf += 8;                                             \
+  xmm5 = _mm_loadl_epi64((__m128i*)a_buf);                \
+  a_buf += 8;
+
+// Convert 8 pixels: 8 UV and 8 Y.
+#define YUVTORGB(yuvconstants)                                      \
+  xmm3 = _mm_sub_epi8(xmm3, _mm_set1_epi8(0x80));                   \
+  xmm4 = _mm_mulhi_epu16(xmm4, *(__m128i*)yuvconstants->kYToRgb);   \
+  xmm4 = _mm_add_epi16(xmm4, *(__m128i*)yuvconstants->kYBiasToRgb); \
+  xmm0 = _mm_maddubs_epi16(*(__m128i*)yuvconstants->kUVToB, xmm3);  \
+  xmm1 = _mm_maddubs_epi16(*(__m128i*)yuvconstants->kUVToG, xmm3);  \
+  xmm2 = _mm_maddubs_epi16(*(__m128i*)yuvconstants->kUVToR, xmm3);  \
+  xmm0 = _mm_adds_epi16(xmm4, xmm0);                                \
+  xmm1 = _mm_subs_epi16(xmm4, xmm1);                                \
+  xmm2 = _mm_adds_epi16(xmm4, xmm2);                                \
+  xmm0 = _mm_srai_epi16(xmm0, 6);                                   \
+  xmm1 = _mm_srai_epi16(xmm1, 6);                                   \
+  xmm2 = _mm_srai_epi16(xmm2, 6);                                   \
+  xmm0 = _mm_packus_epi16(xmm0, xmm0);                              \
+  xmm1 = _mm_packus_epi16(xmm1, xmm1);                              \
+  xmm2 = _mm_packus_epi16(xmm2, xmm2);
+
+// Store 8 ARGB values.
+#define STOREARGB                                    \
+  xmm0 = _mm_unpacklo_epi8(xmm0, xmm1);              \
+  xmm2 = _mm_unpacklo_epi8(xmm2, xmm5);              \
+  xmm1 = _mm_loadu_si128(&xmm0);                     \
+  xmm0 = _mm_unpacklo_epi16(xmm0, xmm2);             \
+  xmm1 = _mm_unpackhi_epi16(xmm1, xmm2);             \
+  _mm_storeu_si128((__m128i*)dst_argb, xmm0);        \
+  _mm_storeu_si128((__m128i*)(dst_argb + 16), xmm1); \
+  dst_argb += 32;
+
+#if defined(HAS_I422TOARGBROW_SSSE3)
+void I422ToARGBRow_SSSE3(const uint8_t* y_buf,
+                         const uint8_t* u_buf,
+                         const uint8_t* v_buf,
+                         uint8_t* dst_argb,
+                         const struct YuvConstants* yuvconstants,
+                         int width) {
+  __m128i xmm0, xmm1, xmm2, xmm3, xmm4;
+  const __m128i xmm5 = _mm_set1_epi8(-1);
+  const ptrdiff_t offset = (uint8_t*)v_buf - (uint8_t*)u_buf;
+  while (width > 0) {
+    READYUV422
+    YUVTORGB(yuvconstants)
+    STOREARGB
+    width -= 8;
+  }
+}
+#endif
+
+#if defined(HAS_I422ALPHATOARGBROW_SSSE3)
+void I422AlphaToARGBRow_SSSE3(const uint8_t* y_buf,
+                              const uint8_t* u_buf,
+                              const uint8_t* v_buf,
+                              const uint8_t* a_buf,
+                              uint8_t* dst_argb,
+                              const struct YuvConstants* yuvconstants,
+                              int width) {
+  __m128i xmm0, xmm1, xmm2, xmm3, xmm4, xmm5;
+  const ptrdiff_t offset = (uint8_t*)v_buf - (uint8_t*)u_buf;
+  while (width > 0) {
+    READYUVA422
+    YUVTORGB(yuvconstants)
+    STOREARGB
+    width -= 8;
+  }
+}
+#endif
+
+#if defined(HAS_I444TOARGBROW_SSSE3)
+void I444ToARGBRow_SSSE3(const uint8_t* y_buf,
+                         const uint8_t* u_buf,
+                         const uint8_t* v_buf,
+                         uint8_t* dst_argb,
+                         const struct YuvConstants* yuvconstants,
+                         int width) {
+  __m128i xmm0, xmm1, xmm2, xmm3, xmm4;
+  const __m128i xmm5 = _mm_set1_epi8(-1);
+  const ptrdiff_t offset = (uint8_t*)v_buf - (uint8_t*)u_buf;
+  while (width > 0) {
+    READYUV444
+    YUVTORGB(yuvconstants)
+    STOREARGB
+    width -= 8;
+  }
+}
+#endif
+
+#if defined(HAS_I444ALPHATOARGBROW_SSSE3)
+void I444AlphaToARGBRow_SSSE3(const uint8_t* y_buf,
+                              const uint8_t* u_buf,
+                              const uint8_t* v_buf,
+                              const uint8_t* a_buf,
+                              uint8_t* dst_argb,
+                              const struct YuvConstants* yuvconstants,
+                              int width) {
+  __m128i xmm0, xmm1, xmm2, xmm3, xmm4, xmm5;
+  const ptrdiff_t offset = (uint8_t*)v_buf - (uint8_t*)u_buf;
+  while (width > 0) {
+    READYUVA444
+    YUVTORGB(yuvconstants)
+    STOREARGB
+    width -= 8;
+  }
+}
+#endif
+
+// 32 bit
+#else  // defined(_M_X64)
+#ifdef HAS_ARGBTOYROW_SSSE3
+
+// Constants for ARGB.
+static const vec8 kARGBToY = {13, 65, 33, 0, 13, 65, 33, 0,
+                              13, 65, 33, 0, 13, 65, 33, 0};
+
+// JPeg full range.
+static const vec8 kARGBToYJ = {15, 75, 38, 0, 15, 75, 38, 0,
+                               15, 75, 38, 0, 15, 75, 38, 0};
+
+static const vec8 kARGBToU = {112, -74, -38, 0, 112, -74, -38, 0,
+                              112, -74, -38, 0, 112, -74, -38, 0};
+
+static const vec8 kARGBToUJ = {127, -84, -43, 0, 127, -84, -43, 0,
+                               127, -84, -43, 0, 127, -84, -43, 0};
+
+static const vec8 kARGBToV = {
+    -18, -94, 112, 0, -18, -94, 112, 0, -18, -94, 112, 0, -18, -94, 112, 0,
+};
+
+static const vec8 kARGBToVJ = {-20, -107, 127, 0, -20, -107, 127, 0,
+                               -20, -107, 127, 0, -20, -107, 127, 0};
+
+// vpshufb for vphaddw + vpackuswb packed to shorts.
+static const lvec8 kShufARGBToUV_AVX = {
+    0, 1, 8, 9, 2, 3, 10, 11, 4, 5, 12, 13, 6, 7, 14, 15,
+    0, 1, 8, 9, 2, 3, 10, 11, 4, 5, 12, 13, 6, 7, 14, 15};
+
+// Constants for BGRA.
+static const vec8 kBGRAToY = {0, 33, 65, 13, 0, 33, 65, 13,
+                              0, 33, 65, 13, 0, 33, 65, 13};
+
+static const vec8 kBGRAToU = {0, -38, -74, 112, 0, -38, -74, 112,
+                              0, -38, -74, 112, 0, -38, -74, 112};
+
+static const vec8 kBGRAToV = {0, 112, -94, -18, 0, 112, -94, -18,
+                              0, 112, -94, -18, 0, 112, -94, -18};
+
+// Constants for ABGR.
+static const vec8 kABGRToY = {33, 65, 13, 0, 33, 65, 13, 0,
+                              33, 65, 13, 0, 33, 65, 13, 0};
+
+static const vec8 kABGRToU = {-38, -74, 112, 0, -38, -74, 112, 0,
+                              -38, -74, 112, 0, -38, -74, 112, 0};
+
+static const vec8 kABGRToV = {112, -94, -18, 0, 112, -94, -18, 0,
+                              112, -94, -18, 0, 112, -94, -18, 0};
+
+// Constants for RGBA.
+static const vec8 kRGBAToY = {0, 13, 65, 33, 0, 13, 65, 33,
+                              0, 13, 65, 33, 0, 13, 65, 33};
+
+static const vec8 kRGBAToU = {0, 112, -74, -38, 0, 112, -74, -38,
+                              0, 112, -74, -38, 0, 112, -74, -38};
+
+static const vec8 kRGBAToV = {0, -18, -94, 112, 0, -18, -94, 112,
+                              0, -18, -94, 112, 0, -18, -94, 112};
+
+static const uvec8 kAddY16 = {16u, 16u, 16u, 16u, 16u, 16u, 16u, 16u,
+                              16u, 16u, 16u, 16u, 16u, 16u, 16u, 16u};
+
+// 7 bit fixed point 0.5.
+static const vec16 kAddYJ64 = {64, 64, 64, 64, 64, 64, 64, 64};
+
+// 8 bit fixed point 0.5, for bias of UV.
+static const ulvec8 kBiasUV128 = {
+    0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
+    0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
+    0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80};
+
+// Shuffle table for converting RGB24 to ARGB.
+static const uvec8 kShuffleMaskRGB24ToARGB = {
+    0u, 1u, 2u, 12u, 3u, 4u, 5u, 13u, 6u, 7u, 8u, 14u, 9u, 10u, 11u, 15u};
+
+// Shuffle table for converting RAW to ARGB.
+static const uvec8 kShuffleMaskRAWToARGB = {2u, 1u, 0u, 12u, 5u,  4u,  3u, 13u,
+                                            8u, 7u, 6u, 14u, 11u, 10u, 9u, 15u};
+
+// Shuffle table for converting RAW to RGB24.  First 8.
+static const uvec8 kShuffleMaskRAWToRGB24_0 = {
+    2u,   1u,   0u,   5u,   4u,   3u,   8u,   7u,
+    128u, 128u, 128u, 128u, 128u, 128u, 128u, 128u};
+
+// Shuffle table for converting RAW to RGB24.  Middle 8.
+static const uvec8 kShuffleMaskRAWToRGB24_1 = {
+    2u,   7u,   6u,   5u,   10u,  9u,   8u,   13u,
+    128u, 128u, 128u, 128u, 128u, 128u, 128u, 128u};
+
+// Shuffle table for converting RAW to RGB24.  Last 8.
+static const uvec8 kShuffleMaskRAWToRGB24_2 = {
+    8u,   7u,   12u,  11u,  10u,  15u,  14u,  13u,
+    128u, 128u, 128u, 128u, 128u, 128u, 128u, 128u};
+
+// Shuffle table for converting ARGB to RGB24.
+static const uvec8 kShuffleMaskARGBToRGB24 = {
+    0u, 1u, 2u, 4u, 5u, 6u, 8u, 9u, 10u, 12u, 13u, 14u, 128u, 128u, 128u, 128u};
+
+// Shuffle table for converting ARGB to RAW.
+static const uvec8 kShuffleMaskARGBToRAW = {
+    2u, 1u, 0u, 6u, 5u, 4u, 10u, 9u, 8u, 14u, 13u, 12u, 128u, 128u, 128u, 128u};
+
+// Shuffle table for converting ARGBToRGB24 for I422ToRGB24.  First 8 + next 4
+static const uvec8 kShuffleMaskARGBToRGB24_0 = {
+    0u, 1u, 2u, 4u, 5u, 6u, 8u, 9u, 128u, 128u, 128u, 128u, 10u, 12u, 13u, 14u};
+
+// YUY2 shuf 16 Y to 32 Y.
+static const lvec8 kShuffleYUY2Y = {0,  0,  2,  2,  4,  4,  6,  6,  8,  8, 10,
+                                    10, 12, 12, 14, 14, 0,  0,  2,  2,  4, 4,
+                                    6,  6,  8,  8,  10, 10, 12, 12, 14, 14};
+
+// YUY2 shuf 8 UV to 16 UV.
+static const lvec8 kShuffleYUY2UV = {1,  3,  1,  3,  5,  7,  5,  7,  9,  11, 9,
+                                     11, 13, 15, 13, 15, 1,  3,  1,  3,  5,  7,
+                                     5,  7,  9,  11, 9,  11, 13, 15, 13, 15};
+
+// UYVY shuf 16 Y to 32 Y.
+static const lvec8 kShuffleUYVYY = {1,  1,  3,  3,  5,  5,  7,  7,  9,  9, 11,
+                                    11, 13, 13, 15, 15, 1,  1,  3,  3,  5, 5,
+                                    7,  7,  9,  9,  11, 11, 13, 13, 15, 15};
+
+// UYVY shuf 8 UV to 16 UV.
+static const lvec8 kShuffleUYVYUV = {0,  2,  0,  2,  4,  6,  4,  6,  8,  10, 8,
+                                     10, 12, 14, 12, 14, 0,  2,  0,  2,  4,  6,
+                                     4,  6,  8,  10, 8,  10, 12, 14, 12, 14};
+
+// NV21 shuf 8 VU to 16 UV.
+static const lvec8 kShuffleNV21 = {
+    1, 0, 1, 0, 3, 2, 3, 2, 5, 4, 5, 4, 7, 6, 7, 6,
+    1, 0, 1, 0, 3, 2, 3, 2, 5, 4, 5, 4, 7, 6, 7, 6,
+};
+
+// Duplicates gray value 3 times and fills in alpha opaque.
+__declspec(naked) void J400ToARGBRow_SSE2(const uint8_t* src_y,
+                                          uint8_t* dst_argb,
+                                          int width) {
+  __asm {
+    mov        eax, [esp + 4]  // src_y
+    mov        edx, [esp + 8]  // dst_argb
+    mov        ecx, [esp + 12]  // width
+    pcmpeqb    xmm5, xmm5  // generate mask 0xff000000
+    pslld      xmm5, 24
+
+  convertloop:
+    movq       xmm0, qword ptr [eax]
+    lea        eax,  [eax + 8]
+    punpcklbw  xmm0, xmm0
+    movdqa     xmm1, xmm0
+    punpcklwd  xmm0, xmm0
+    punpckhwd  xmm1, xmm1
+    por        xmm0, xmm5
+    por        xmm1, xmm5
+    movdqu     [edx], xmm0
+    movdqu     [edx + 16], xmm1
+    lea        edx, [edx + 32]
+    sub        ecx, 8
+    jg         convertloop
+    ret
+  }
+}
+
+#ifdef HAS_J400TOARGBROW_AVX2
+// Duplicates gray value 3 times and fills in alpha opaque.
+__declspec(naked) void J400ToARGBRow_AVX2(const uint8_t* src_y,
+                                          uint8_t* dst_argb,
+                                          int width) {
+  __asm {
+    mov         eax, [esp + 4]  // src_y
+    mov         edx, [esp + 8]  // dst_argb
+    mov         ecx, [esp + 12]  // width
+    vpcmpeqb    ymm5, ymm5, ymm5  // generate mask 0xff000000
+    vpslld      ymm5, ymm5, 24
+
+  convertloop:
+    vmovdqu     xmm0, [eax]
+    lea         eax,  [eax + 16]
+    vpermq      ymm0, ymm0, 0xd8
+    vpunpcklbw  ymm0, ymm0, ymm0
+    vpermq      ymm0, ymm0, 0xd8
+    vpunpckhwd  ymm1, ymm0, ymm0
+    vpunpcklwd  ymm0, ymm0, ymm0
+    vpor        ymm0, ymm0, ymm5
+    vpor        ymm1, ymm1, ymm5
+    vmovdqu     [edx], ymm0
+    vmovdqu     [edx + 32], ymm1
+    lea         edx, [edx + 64]
+    sub         ecx, 16
+    jg          convertloop
+    vzeroupper
+    ret
+  }
+}
+#endif  // HAS_J400TOARGBROW_AVX2
+
+__declspec(naked) void RGB24ToARGBRow_SSSE3(const uint8_t* src_rgb24,
+                                            uint8_t* dst_argb,
+                                            int width) {
+  __asm {
+    mov       eax, [esp + 4]  // src_rgb24
+    mov       edx, [esp + 8]  // dst_argb
+    mov       ecx, [esp + 12]  // width
+    pcmpeqb   xmm5, xmm5  // generate mask 0xff000000
+    pslld     xmm5, 24
+    movdqa    xmm4, xmmword ptr kShuffleMaskRGB24ToARGB
+
+ convertloop:
+    movdqu    xmm0, [eax]
+    movdqu    xmm1, [eax + 16]
+    movdqu    xmm3, [eax + 32]
+    lea       eax, [eax + 48]
+    movdqa    xmm2, xmm3
+    palignr   xmm2, xmm1, 8  // xmm2 = { xmm3[0:3] xmm1[8:15]}
+    pshufb    xmm2, xmm4
+    por       xmm2, xmm5
+    palignr   xmm1, xmm0, 12  // xmm1 = { xmm3[0:7] xmm0[12:15]}
+    pshufb    xmm0, xmm4
+    movdqu    [edx + 32], xmm2
+    por       xmm0, xmm5
+    pshufb    xmm1, xmm4
+    movdqu    [edx], xmm0
+    por       xmm1, xmm5
+    palignr   xmm3, xmm3, 4  // xmm3 = { xmm3[4:15]}
+    pshufb    xmm3, xmm4
+    movdqu    [edx + 16], xmm1
+    por       xmm3, xmm5
+    movdqu    [edx + 48], xmm3
+    lea       edx, [edx + 64]
+    sub       ecx, 16
+    jg        convertloop
+    ret
+  }
+}
+
+__declspec(naked) void RAWToARGBRow_SSSE3(const uint8_t* src_raw,
+                                          uint8_t* dst_argb,
+                                          int width) {
+  __asm {
+    mov       eax, [esp + 4]  // src_raw
+    mov       edx, [esp + 8]  // dst_argb
+    mov       ecx, [esp + 12]  // width
+    pcmpeqb   xmm5, xmm5  // generate mask 0xff000000
+    pslld     xmm5, 24
+    movdqa    xmm4, xmmword ptr kShuffleMaskRAWToARGB
+
+ convertloop:
+    movdqu    xmm0, [eax]
+    movdqu    xmm1, [eax + 16]
+    movdqu    xmm3, [eax + 32]
+    lea       eax, [eax + 48]
+    movdqa    xmm2, xmm3
+    palignr   xmm2, xmm1, 8  // xmm2 = { xmm3[0:3] xmm1[8:15]}
+    pshufb    xmm2, xmm4
+    por       xmm2, xmm5
+    palignr   xmm1, xmm0, 12  // xmm1 = { xmm3[0:7] xmm0[12:15]}
+    pshufb    xmm0, xmm4
+    movdqu    [edx + 32], xmm2
+    por       xmm0, xmm5
+    pshufb    xmm1, xmm4
+    movdqu    [edx], xmm0
+    por       xmm1, xmm5
+    palignr   xmm3, xmm3, 4  // xmm3 = { xmm3[4:15]}
+    pshufb    xmm3, xmm4
+    movdqu    [edx + 16], xmm1
+    por       xmm3, xmm5
+    movdqu    [edx + 48], xmm3
+    lea       edx, [edx + 64]
+    sub       ecx, 16
+    jg        convertloop
+    ret
+  }
+}
+
+__declspec(naked) void RAWToRGB24Row_SSSE3(const uint8_t* src_raw,
+                                           uint8_t* dst_rgb24,
+                                           int width) {
+  __asm {
+    mov       eax, [esp + 4]  // src_raw
+    mov       edx, [esp + 8]  // dst_rgb24
+    mov       ecx, [esp + 12]  // width
+    movdqa    xmm3, xmmword ptr kShuffleMaskRAWToRGB24_0
+    movdqa    xmm4, xmmword ptr kShuffleMaskRAWToRGB24_1
+    movdqa    xmm5, xmmword ptr kShuffleMaskRAWToRGB24_2
+
+ convertloop:
+    movdqu    xmm0, [eax]
+    movdqu    xmm1, [eax + 4]
+    movdqu    xmm2, [eax + 8]
+    lea       eax, [eax + 24]
+    pshufb    xmm0, xmm3
+    pshufb    xmm1, xmm4
+    pshufb    xmm2, xmm5
+    movq      qword ptr [edx], xmm0
+    movq      qword ptr [edx + 8], xmm1
+    movq      qword ptr [edx + 16], xmm2
+    lea       edx, [edx + 24]
+    sub       ecx, 8
+    jg        convertloop
+    ret
+  }
+}
+
+// pmul method to replicate bits.
+// Math to replicate bits:
+// (v << 8) | (v << 3)
+// v * 256 + v * 8
+// v * (256 + 8)
+// G shift of 5 is incorporated, so shift is 5 + 8 and 5 + 3
+// 20 instructions.
+__declspec(naked) void RGB565ToARGBRow_SSE2(const uint8_t* src_rgb565,
+                                            uint8_t* dst_argb,
+                                            int width) {
+  __asm {
+    mov       eax, 0x01080108  // generate multiplier to repeat 5 bits
+    movd      xmm5, eax
+    pshufd    xmm5, xmm5, 0
+    mov       eax, 0x20802080  // multiplier shift by 5 and then repeat 6 bits
+    movd      xmm6, eax
+    pshufd    xmm6, xmm6, 0
+    pcmpeqb   xmm3, xmm3  // generate mask 0xf800f800 for Red
+    psllw     xmm3, 11
+    pcmpeqb   xmm4, xmm4  // generate mask 0x07e007e0 for Green
+    psllw     xmm4, 10
+    psrlw     xmm4, 5
+    pcmpeqb   xmm7, xmm7  // generate mask 0xff00ff00 for Alpha
+    psllw     xmm7, 8
+
+    mov       eax, [esp + 4]  // src_rgb565
+    mov       edx, [esp + 8]  // dst_argb
+    mov       ecx, [esp + 12]  // width
+    sub       edx, eax
+    sub       edx, eax
+
+ convertloop:
+    movdqu    xmm0, [eax]  // fetch 8 pixels of bgr565
+    movdqa    xmm1, xmm0
+    movdqa    xmm2, xmm0
+    pand      xmm1, xmm3  // R in upper 5 bits
+    psllw     xmm2, 11  // B in upper 5 bits
+    pmulhuw   xmm1, xmm5  // * (256 + 8)
+    pmulhuw   xmm2, xmm5  // * (256 + 8)
+    psllw     xmm1, 8
+    por       xmm1, xmm2  // RB
+    pand      xmm0, xmm4  // G in middle 6 bits
+    pmulhuw   xmm0, xmm6  // << 5 * (256 + 4)
+    por       xmm0, xmm7  // AG
+    movdqa    xmm2, xmm1
+    punpcklbw xmm1, xmm0
+    punpckhbw xmm2, xmm0
+    movdqu    [eax * 2 + edx], xmm1  // store 4 pixels of ARGB
+    movdqu    [eax * 2 + edx + 16], xmm2  // store next 4 pixels of ARGB
+    lea       eax, [eax + 16]
+    sub       ecx, 8
+    jg        convertloop
+    ret
+  }
+}
+
+#ifdef HAS_RGB565TOARGBROW_AVX2
+// pmul method to replicate bits.
+// Math to replicate bits:
+// (v << 8) | (v << 3)
+// v * 256 + v * 8
+// v * (256 + 8)
+// G shift of 5 is incorporated, so shift is 5 + 8 and 5 + 3
+__declspec(naked) void RGB565ToARGBRow_AVX2(const uint8_t* src_rgb565,
+                                            uint8_t* dst_argb,
+                                            int width) {
+  __asm {
+    mov        eax, 0x01080108  // generate multiplier to repeat 5 bits
+    vmovd      xmm5, eax
+    vbroadcastss ymm5, xmm5
+    mov        eax, 0x20802080  // multiplier shift by 5 and then repeat 6 bits
+    vmovd      xmm6, eax
+    vbroadcastss ymm6, xmm6
+    vpcmpeqb   ymm3, ymm3, ymm3  // generate mask 0xf800f800 for Red
+    vpsllw     ymm3, ymm3, 11
+    vpcmpeqb   ymm4, ymm4, ymm4  // generate mask 0x07e007e0 for Green
+    vpsllw     ymm4, ymm4, 10
+    vpsrlw     ymm4, ymm4, 5
+    vpcmpeqb   ymm7, ymm7, ymm7  // generate mask 0xff00ff00 for Alpha
+    vpsllw     ymm7, ymm7, 8
+
+    mov        eax, [esp + 4]  // src_rgb565
+    mov        edx, [esp + 8]  // dst_argb
+    mov        ecx, [esp + 12]  // width
+    sub        edx, eax
+    sub        edx, eax
+
+ convertloop:
+    vmovdqu    ymm0, [eax]  // fetch 16 pixels of bgr565
+    vpand      ymm1, ymm0, ymm3  // R in upper 5 bits
+    vpsllw     ymm2, ymm0, 11  // B in upper 5 bits
+    vpmulhuw   ymm1, ymm1, ymm5  // * (256 + 8)
+    vpmulhuw   ymm2, ymm2, ymm5  // * (256 + 8)
+    vpsllw     ymm1, ymm1, 8
+    vpor       ymm1, ymm1, ymm2  // RB
+    vpand      ymm0, ymm0, ymm4  // G in middle 6 bits
+    vpmulhuw   ymm0, ymm0, ymm6  // << 5 * (256 + 4)
+    vpor       ymm0, ymm0, ymm7  // AG
+    vpermq     ymm0, ymm0, 0xd8  // mutate for unpack
+    vpermq     ymm1, ymm1, 0xd8
+    vpunpckhbw ymm2, ymm1, ymm0
+    vpunpcklbw ymm1, ymm1, ymm0
+    vmovdqu    [eax * 2 + edx], ymm1  // store 4 pixels of ARGB
+    vmovdqu    [eax * 2 + edx + 32], ymm2  // store next 4 pixels of ARGB
+    lea       eax, [eax + 32]
+    sub       ecx, 16
+    jg        convertloop
+    vzeroupper
+    ret
+  }
+}
+#endif  // HAS_RGB565TOARGBROW_AVX2
+
+#ifdef HAS_ARGB1555TOARGBROW_AVX2
+__declspec(naked) void ARGB1555ToARGBRow_AVX2(const uint8_t* src_argb1555,
+                                              uint8_t* dst_argb,
+                                              int width) {
+  __asm {
+    mov        eax, 0x01080108  // generate multiplier to repeat 5 bits
+    vmovd      xmm5, eax
+    vbroadcastss ymm5, xmm5
+    mov        eax, 0x42004200  // multiplier shift by 6 and then repeat 5 bits
+    vmovd      xmm6, eax
+    vbroadcastss ymm6, xmm6
+    vpcmpeqb   ymm3, ymm3, ymm3  // generate mask 0xf800f800 for Red
+    vpsllw     ymm3, ymm3, 11
+    vpsrlw     ymm4, ymm3, 6  // generate mask 0x03e003e0 for Green
+    vpcmpeqb   ymm7, ymm7, ymm7  // generate mask 0xff00ff00 for Alpha
+    vpsllw     ymm7, ymm7, 8
+
+    mov        eax,  [esp + 4]  // src_argb1555
+    mov        edx,  [esp + 8]  // dst_argb
+    mov        ecx,  [esp + 12]  // width
+    sub        edx,  eax
+    sub        edx,  eax
+
+ convertloop:
+    vmovdqu    ymm0, [eax]  // fetch 16 pixels of 1555
+    vpsllw     ymm1, ymm0, 1  // R in upper 5 bits
+    vpsllw     ymm2, ymm0, 11  // B in upper 5 bits
+    vpand      ymm1, ymm1, ymm3
+    vpmulhuw   ymm2, ymm2, ymm5  // * (256 + 8)
+    vpmulhuw   ymm1, ymm1, ymm5  // * (256 + 8)
+    vpsllw     ymm1, ymm1, 8
+    vpor       ymm1, ymm1, ymm2  // RB
+    vpsraw     ymm2, ymm0, 8  // A
+    vpand      ymm0, ymm0, ymm4  // G in middle 5 bits
+    vpmulhuw   ymm0, ymm0, ymm6  // << 6 * (256 + 8)
+    vpand      ymm2, ymm2, ymm7
+    vpor       ymm0, ymm0, ymm2  // AG
+    vpermq     ymm0, ymm0, 0xd8  // mutate for unpack
+    vpermq     ymm1, ymm1, 0xd8
+    vpunpckhbw ymm2, ymm1, ymm0
+    vpunpcklbw ymm1, ymm1, ymm0
+    vmovdqu    [eax * 2 + edx], ymm1  // store 8 pixels of ARGB
+    vmovdqu    [eax * 2 + edx + 32], ymm2  // store next 8 pixels of ARGB
+    lea       eax, [eax + 32]
+    sub       ecx, 16
+    jg        convertloop
+    vzeroupper
+    ret
+  }
+}
+#endif  // HAS_ARGB1555TOARGBROW_AVX2
+
+#ifdef HAS_ARGB4444TOARGBROW_AVX2
+__declspec(naked) void ARGB4444ToARGBRow_AVX2(const uint8_t* src_argb4444,
+                                              uint8_t* dst_argb,
+                                              int width) {
+  __asm {
+    mov       eax,  0x0f0f0f0f  // generate mask 0x0f0f0f0f
+    vmovd     xmm4, eax
+    vbroadcastss ymm4, xmm4
+    vpslld    ymm5, ymm4, 4  // 0xf0f0f0f0 for high nibbles
+    mov       eax,  [esp + 4]  // src_argb4444
+    mov       edx,  [esp + 8]  // dst_argb
+    mov       ecx,  [esp + 12]  // width
+    sub       edx,  eax
+    sub       edx,  eax
+
+ convertloop:
+    vmovdqu    ymm0, [eax]  // fetch 16 pixels of bgra4444
+    vpand      ymm2, ymm0, ymm5  // mask high nibbles
+    vpand      ymm0, ymm0, ymm4  // mask low nibbles
+    vpsrlw     ymm3, ymm2, 4
+    vpsllw     ymm1, ymm0, 4
+    vpor       ymm2, ymm2, ymm3
+    vpor       ymm0, ymm0, ymm1
+    vpermq     ymm0, ymm0, 0xd8  // mutate for unpack
+    vpermq     ymm2, ymm2, 0xd8
+    vpunpckhbw ymm1, ymm0, ymm2
+    vpunpcklbw ymm0, ymm0, ymm2
+    vmovdqu    [eax * 2 + edx], ymm0  // store 8 pixels of ARGB
+    vmovdqu    [eax * 2 + edx + 32], ymm1  // store next 8 pixels of ARGB
+    lea       eax, [eax + 32]
+    sub       ecx, 16
+    jg        convertloop
+    vzeroupper
+    ret
+  }
+}
+#endif  // HAS_ARGB4444TOARGBROW_AVX2
+
+// 24 instructions
+__declspec(naked) void ARGB1555ToARGBRow_SSE2(const uint8_t* src_argb1555,
+                                              uint8_t* dst_argb,
+                                              int width) {
+  __asm {
+    mov       eax, 0x01080108  // generate multiplier to repeat 5 bits
+    movd      xmm5, eax
+    pshufd    xmm5, xmm5, 0
+    mov       eax, 0x42004200  // multiplier shift by 6 and then repeat 5 bits
+    movd      xmm6, eax
+    pshufd    xmm6, xmm6, 0
+    pcmpeqb   xmm3, xmm3  // generate mask 0xf800f800 for Red
+    psllw     xmm3, 11
+    movdqa    xmm4, xmm3  // generate mask 0x03e003e0 for Green
+    psrlw     xmm4, 6
+    pcmpeqb   xmm7, xmm7  // generate mask 0xff00ff00 for Alpha
+    psllw     xmm7, 8
+
+    mov       eax, [esp + 4]  // src_argb1555
+    mov       edx, [esp + 8]  // dst_argb
+    mov       ecx, [esp + 12]  // width
+    sub       edx, eax
+    sub       edx, eax
+
+ convertloop:
+    movdqu    xmm0, [eax]  // fetch 8 pixels of 1555
+    movdqa    xmm1, xmm0
+    movdqa    xmm2, xmm0
+    psllw     xmm1, 1  // R in upper 5 bits
+    psllw     xmm2, 11  // B in upper 5 bits
+    pand      xmm1, xmm3
+    pmulhuw   xmm2, xmm5  // * (256 + 8)
+    pmulhuw   xmm1, xmm5  // * (256 + 8)
+    psllw     xmm1, 8
+    por       xmm1, xmm2  // RB
+    movdqa    xmm2, xmm0
+    pand      xmm0, xmm4  // G in middle 5 bits
+    psraw     xmm2, 8  // A
+    pmulhuw   xmm0, xmm6  // << 6 * (256 + 8)
+    pand      xmm2, xmm7
+    por       xmm0, xmm2  // AG
+    movdqa    xmm2, xmm1
+    punpcklbw xmm1, xmm0
+    punpckhbw xmm2, xmm0
+    movdqu    [eax * 2 + edx], xmm1  // store 4 pixels of ARGB
+    movdqu    [eax * 2 + edx + 16], xmm2  // store next 4 pixels of ARGB
+    lea       eax, [eax + 16]
+    sub       ecx, 8
+    jg        convertloop
+    ret
+  }
+}
+
+// 18 instructions.
+__declspec(naked) void ARGB4444ToARGBRow_SSE2(const uint8_t* src_argb4444,
+                                              uint8_t* dst_argb,
+                                              int width) {
+  __asm {
+    mov       eax, 0x0f0f0f0f  // generate mask 0x0f0f0f0f
+    movd      xmm4, eax
+    pshufd    xmm4, xmm4, 0
+    movdqa    xmm5, xmm4  // 0xf0f0f0f0 for high nibbles
+    pslld     xmm5, 4
+    mov       eax, [esp + 4]  // src_argb4444
+    mov       edx, [esp + 8]  // dst_argb
+    mov       ecx, [esp + 12]  // width
+    sub       edx, eax
+    sub       edx, eax
+
+ convertloop:
+    movdqu    xmm0, [eax]  // fetch 8 pixels of bgra4444
+    movdqa    xmm2, xmm0
+    pand      xmm0, xmm4  // mask low nibbles
+    pand      xmm2, xmm5  // mask high nibbles
+    movdqa    xmm1, xmm0
+    movdqa    xmm3, xmm2
+    psllw     xmm1, 4
+    psrlw     xmm3, 4
+    por       xmm0, xmm1
+    por       xmm2, xmm3
+    movdqa    xmm1, xmm0
+    punpcklbw xmm0, xmm2
+    punpckhbw xmm1, xmm2
+    movdqu    [eax * 2 + edx], xmm0  // store 4 pixels of ARGB
+    movdqu    [eax * 2 + edx + 16], xmm1  // store next 4 pixels of ARGB
+    lea       eax, [eax + 16]
+    sub       ecx, 8
+    jg        convertloop
+    ret
+  }
+}
+
+__declspec(naked) void ARGBToRGB24Row_SSSE3(const uint8_t* src_argb,
+                                            uint8_t* dst_rgb,
+                                            int width) {
+  __asm {
+    mov       eax, [esp + 4]  // src_argb
+    mov       edx, [esp + 8]  // dst_rgb
+    mov       ecx, [esp + 12]  // width
+    movdqa    xmm6, xmmword ptr kShuffleMaskARGBToRGB24
+
+ convertloop:
+    movdqu    xmm0, [eax]  // fetch 16 pixels of argb
+    movdqu    xmm1, [eax + 16]
+    movdqu    xmm2, [eax + 32]
+    movdqu    xmm3, [eax + 48]
+    lea       eax, [eax + 64]
+    pshufb    xmm0, xmm6  // pack 16 bytes of ARGB to 12 bytes of RGB
+    pshufb    xmm1, xmm6
+    pshufb    xmm2, xmm6
+    pshufb    xmm3, xmm6
+    movdqa    xmm4, xmm1  // 4 bytes from 1 for 0
+    psrldq    xmm1, 4  // 8 bytes from 1
+    pslldq    xmm4, 12  // 4 bytes from 1 for 0
+    movdqa    xmm5, xmm2  // 8 bytes from 2 for 1
+    por       xmm0, xmm4  // 4 bytes from 1 for 0
+    pslldq    xmm5, 8  // 8 bytes from 2 for 1
+    movdqu    [edx], xmm0  // store 0
+    por       xmm1, xmm5  // 8 bytes from 2 for 1
+    psrldq    xmm2, 8  // 4 bytes from 2
+    pslldq    xmm3, 4  // 12 bytes from 3 for 2
+    por       xmm2, xmm3  // 12 bytes from 3 for 2
+    movdqu    [edx + 16], xmm1  // store 1
+    movdqu    [edx + 32], xmm2  // store 2
+    lea       edx, [edx + 48]
+    sub       ecx, 16
+    jg        convertloop
+    ret
+  }
+}
+
+__declspec(naked) void ARGBToRAWRow_SSSE3(const uint8_t* src_argb,
+                                          uint8_t* dst_rgb,
+                                          int width) {
+  __asm {
+    mov       eax, [esp + 4]  // src_argb
+    mov       edx, [esp + 8]  // dst_rgb
+    mov       ecx, [esp + 12]  // width
+    movdqa    xmm6, xmmword ptr kShuffleMaskARGBToRAW
+
+ convertloop:
+    movdqu    xmm0, [eax]  // fetch 16 pixels of argb
+    movdqu    xmm1, [eax + 16]
+    movdqu    xmm2, [eax + 32]
+    movdqu    xmm3, [eax + 48]
+    lea       eax, [eax + 64]
+    pshufb    xmm0, xmm6  // pack 16 bytes of ARGB to 12 bytes of RGB
+    pshufb    xmm1, xmm6
+    pshufb    xmm2, xmm6
+    pshufb    xmm3, xmm6
+    movdqa    xmm4, xmm1  // 4 bytes from 1 for 0
+    psrldq    xmm1, 4  // 8 bytes from 1
+    pslldq    xmm4, 12  // 4 bytes from 1 for 0
+    movdqa    xmm5, xmm2  // 8 bytes from 2 for 1
+    por       xmm0, xmm4  // 4 bytes from 1 for 0
+    pslldq    xmm5, 8  // 8 bytes from 2 for 1
+    movdqu    [edx], xmm0  // store 0
+    por       xmm1, xmm5  // 8 bytes from 2 for 1
+    psrldq    xmm2, 8  // 4 bytes from 2
+    pslldq    xmm3, 4  // 12 bytes from 3 for 2
+    por       xmm2, xmm3  // 12 bytes from 3 for 2
+    movdqu    [edx + 16], xmm1  // store 1
+    movdqu    [edx + 32], xmm2  // store 2
+    lea       edx, [edx + 48]
+    sub       ecx, 16
+    jg        convertloop
+    ret
+  }
+}
+
+__declspec(naked) void ARGBToRGB565Row_SSE2(const uint8_t* src_argb,
+                                            uint8_t* dst_rgb,
+                                            int width) {
+  __asm {
+    mov       eax, [esp + 4]  // src_argb
+    mov       edx, [esp + 8]  // dst_rgb
+    mov       ecx, [esp + 12]  // width
+    pcmpeqb   xmm3, xmm3  // generate mask 0x0000001f
+    psrld     xmm3, 27
+    pcmpeqb   xmm4, xmm4  // generate mask 0x000007e0
+    psrld     xmm4, 26
+    pslld     xmm4, 5
+    pcmpeqb   xmm5, xmm5  // generate mask 0xfffff800
+    pslld     xmm5, 11
+
+ convertloop:
+    movdqu    xmm0, [eax]  // fetch 4 pixels of argb
+    movdqa    xmm1, xmm0  // B
+    movdqa    xmm2, xmm0  // G
+    pslld     xmm0, 8  // R
+    psrld     xmm1, 3  // B
+    psrld     xmm2, 5  // G
+    psrad     xmm0, 16  // R
+    pand      xmm1, xmm3  // B
+    pand      xmm2, xmm4  // G
+    pand      xmm0, xmm5  // R
+    por       xmm1, xmm2  // BG
+    por       xmm0, xmm1  // BGR
+    packssdw  xmm0, xmm0
+    lea       eax, [eax + 16]
+    movq      qword ptr [edx], xmm0  // store 4 pixels of RGB565
+    lea       edx, [edx + 8]
+    sub       ecx, 4
+    jg        convertloop
+    ret
+  }
+}
+
+__declspec(naked) void ARGBToRGB565DitherRow_SSE2(const uint8_t* src_argb,
+                                                  uint8_t* dst_rgb,
+                                                  const uint32_t dither4,
+                                                  int width) {
+  __asm {
+
+    mov       eax, [esp + 4]  // src_argb
+    mov       edx, [esp + 8]  // dst_rgb
+    movd      xmm6, [esp + 12]  // dither4
+    mov       ecx, [esp + 16]  // width
+    punpcklbw xmm6, xmm6  // make dither 16 bytes
+    movdqa    xmm7, xmm6
+    punpcklwd xmm6, xmm6
+    punpckhwd xmm7, xmm7
+    pcmpeqb   xmm3, xmm3  // generate mask 0x0000001f
+    psrld     xmm3, 27
+    pcmpeqb   xmm4, xmm4  // generate mask 0x000007e0
+    psrld     xmm4, 26
+    pslld     xmm4, 5
+    pcmpeqb   xmm5, xmm5  // generate mask 0xfffff800
+    pslld     xmm5, 11
+
+ convertloop:
+    movdqu    xmm0, [eax]  // fetch 4 pixels of argb
+    paddusb   xmm0, xmm6  // add dither
+    movdqa    xmm1, xmm0  // B
+    movdqa    xmm2, xmm0  // G
+    pslld     xmm0, 8  // R
+    psrld     xmm1, 3  // B
+    psrld     xmm2, 5  // G
+    psrad     xmm0, 16  // R
+    pand      xmm1, xmm3  // B
+    pand      xmm2, xmm4  // G
+    pand      xmm0, xmm5  // R
+    por       xmm1, xmm2  // BG
+    por       xmm0, xmm1  // BGR
+    packssdw  xmm0, xmm0
+    lea       eax, [eax + 16]
+    movq      qword ptr [edx], xmm0  // store 4 pixels of RGB565
+    lea       edx, [edx + 8]
+    sub       ecx, 4
+    jg        convertloop
+    ret
+  }
+}
+
+#ifdef HAS_ARGBTORGB565DITHERROW_AVX2
+__declspec(naked) void ARGBToRGB565DitherRow_AVX2(const uint8_t* src_argb,
+                                                  uint8_t* dst_rgb,
+                                                  const uint32_t dither4,
+                                                  int width) {
+  __asm {
+    mov        eax, [esp + 4]  // src_argb
+    mov        edx, [esp + 8]  // dst_rgb
+    vbroadcastss xmm6, [esp + 12]  // dither4
+    mov        ecx, [esp + 16]  // width
+    vpunpcklbw xmm6, xmm6, xmm6  // make dither 32 bytes
+    vpermq     ymm6, ymm6, 0xd8
+    vpunpcklwd ymm6, ymm6, ymm6
+    vpcmpeqb   ymm3, ymm3, ymm3  // generate mask 0x0000001f
+    vpsrld     ymm3, ymm3, 27
+    vpcmpeqb   ymm4, ymm4, ymm4  // generate mask 0x000007e0
+    vpsrld     ymm4, ymm4, 26
+    vpslld     ymm4, ymm4, 5
+    vpslld     ymm5, ymm3, 11  // generate mask 0x0000f800
+
+ convertloop:
+    vmovdqu    ymm0, [eax]  // fetch 8 pixels of argb
+    vpaddusb   ymm0, ymm0, ymm6  // add dither
+    vpsrld     ymm2, ymm0, 5  // G
+    vpsrld     ymm1, ymm0, 3  // B
+    vpsrld     ymm0, ymm0, 8  // R
+    vpand      ymm2, ymm2, ymm4  // G
+    vpand      ymm1, ymm1, ymm3  // B
+    vpand      ymm0, ymm0, ymm5  // R
+    vpor       ymm1, ymm1, ymm2  // BG
+    vpor       ymm0, ymm0, ymm1  // BGR
+    vpackusdw  ymm0, ymm0, ymm0
+    vpermq     ymm0, ymm0, 0xd8
+    lea        eax, [eax + 32]
+    vmovdqu    [edx], xmm0  // store 8 pixels of RGB565
+    lea        edx, [edx + 16]
+    sub        ecx, 8
+    jg         convertloop
+    vzeroupper
+    ret
+  }
+}
+#endif  // HAS_ARGBTORGB565DITHERROW_AVX2
+
+// TODO(fbarchard): Improve sign extension/packing.
+__declspec(naked) void ARGBToARGB1555Row_SSE2(const uint8_t* src_argb,
+                                              uint8_t* dst_rgb,
+                                              int width) {
+  __asm {
+    mov       eax, [esp + 4]  // src_argb
+    mov       edx, [esp + 8]  // dst_rgb
+    mov       ecx, [esp + 12]  // width
+    pcmpeqb   xmm4, xmm4  // generate mask 0x0000001f
+    psrld     xmm4, 27
+    movdqa    xmm5, xmm4  // generate mask 0x000003e0
+    pslld     xmm5, 5
+    movdqa    xmm6, xmm4  // generate mask 0x00007c00
+    pslld     xmm6, 10
+    pcmpeqb   xmm7, xmm7  // generate mask 0xffff8000
+    pslld     xmm7, 15
+
+ convertloop:
+    movdqu    xmm0, [eax]  // fetch 4 pixels of argb
+    movdqa    xmm1, xmm0  // B
+    movdqa    xmm2, xmm0  // G
+    movdqa    xmm3, xmm0  // R
+    psrad     xmm0, 16  // A
+    psrld     xmm1, 3  // B
+    psrld     xmm2, 6  // G
+    psrld     xmm3, 9  // R
+    pand      xmm0, xmm7  // A
+    pand      xmm1, xmm4  // B
+    pand      xmm2, xmm5  // G
+    pand      xmm3, xmm6  // R
+    por       xmm0, xmm1  // BA
+    por       xmm2, xmm3  // GR
+    por       xmm0, xmm2  // BGRA
+    packssdw  xmm0, xmm0
+    lea       eax, [eax + 16]
+    movq      qword ptr [edx], xmm0  // store 4 pixels of ARGB1555
+    lea       edx, [edx + 8]
+    sub       ecx, 4
+    jg        convertloop
+    ret
+  }
+}
+
+__declspec(naked) void ARGBToARGB4444Row_SSE2(const uint8_t* src_argb,
+                                              uint8_t* dst_rgb,
+                                              int width) {
+  __asm {
+    mov       eax, [esp + 4]  // src_argb
+    mov       edx, [esp + 8]  // dst_rgb
+    mov       ecx, [esp + 12]  // width
+    pcmpeqb   xmm4, xmm4  // generate mask 0xf000f000
+    psllw     xmm4, 12
+    movdqa    xmm3, xmm4  // generate mask 0x00f000f0
+    psrlw     xmm3, 8
+
+ convertloop:
+    movdqu    xmm0, [eax]  // fetch 4 pixels of argb
+    movdqa    xmm1, xmm0
+    pand      xmm0, xmm3  // low nibble
+    pand      xmm1, xmm4  // high nibble
+    psrld     xmm0, 4
+    psrld     xmm1, 8
+    por       xmm0, xmm1
+    packuswb  xmm0, xmm0
+    lea       eax, [eax + 16]
+    movq      qword ptr [edx], xmm0  // store 4 pixels of ARGB4444
+    lea       edx, [edx + 8]
+    sub       ecx, 4
+    jg        convertloop
+    ret
+  }
+}
+
+#ifdef HAS_ARGBTORGB565ROW_AVX2
+__declspec(naked) void ARGBToRGB565Row_AVX2(const uint8_t* src_argb,
+                                            uint8_t* dst_rgb,
+                                            int width) {
+  __asm {
+    mov        eax, [esp + 4]  // src_argb
+    mov        edx, [esp + 8]  // dst_rgb
+    mov        ecx, [esp + 12]  // width
+    vpcmpeqb   ymm3, ymm3, ymm3  // generate mask 0x0000001f
+    vpsrld     ymm3, ymm3, 27
+    vpcmpeqb   ymm4, ymm4, ymm4  // generate mask 0x000007e0
+    vpsrld     ymm4, ymm4, 26
+    vpslld     ymm4, ymm4, 5
+    vpslld     ymm5, ymm3, 11  // generate mask 0x0000f800
+
+ convertloop:
+    vmovdqu    ymm0, [eax]  // fetch 8 pixels of argb
+    vpsrld     ymm2, ymm0, 5  // G
+    vpsrld     ymm1, ymm0, 3  // B
+    vpsrld     ymm0, ymm0, 8  // R
+    vpand      ymm2, ymm2, ymm4  // G
+    vpand      ymm1, ymm1, ymm3  // B
+    vpand      ymm0, ymm0, ymm5  // R
+    vpor       ymm1, ymm1, ymm2  // BG
+    vpor       ymm0, ymm0, ymm1  // BGR
+    vpackusdw  ymm0, ymm0, ymm0
+    vpermq     ymm0, ymm0, 0xd8
+    lea        eax, [eax + 32]
+    vmovdqu    [edx], xmm0  // store 8 pixels of RGB565
+    lea        edx, [edx + 16]
+    sub        ecx, 8
+    jg         convertloop
+    vzeroupper
+    ret
+  }
+}
+#endif  // HAS_ARGBTORGB565ROW_AVX2
+
+#ifdef HAS_ARGBTOARGB1555ROW_AVX2
+__declspec(naked) void ARGBToARGB1555Row_AVX2(const uint8_t* src_argb,
+                                              uint8_t* dst_rgb,
+                                              int width) {
+  __asm {
+    mov        eax, [esp + 4]  // src_argb
+    mov        edx, [esp + 8]  // dst_rgb
+    mov        ecx, [esp + 12]  // width
+    vpcmpeqb   ymm4, ymm4, ymm4
+    vpsrld     ymm4, ymm4, 27  // generate mask 0x0000001f
+    vpslld     ymm5, ymm4, 5  // generate mask 0x000003e0
+    vpslld     ymm6, ymm4, 10  // generate mask 0x00007c00
+    vpcmpeqb   ymm7, ymm7, ymm7  // generate mask 0xffff8000
+    vpslld     ymm7, ymm7, 15
+
+ convertloop:
+    vmovdqu    ymm0, [eax]  // fetch 8 pixels of argb
+    vpsrld     ymm3, ymm0, 9  // R
+    vpsrld     ymm2, ymm0, 6  // G
+    vpsrld     ymm1, ymm0, 3  // B
+    vpsrad     ymm0, ymm0, 16  // A
+    vpand      ymm3, ymm3, ymm6  // R
+    vpand      ymm2, ymm2, ymm5  // G
+    vpand      ymm1, ymm1, ymm4  // B
+    vpand      ymm0, ymm0, ymm7  // A
+    vpor       ymm0, ymm0, ymm1  // BA
+    vpor       ymm2, ymm2, ymm3  // GR
+    vpor       ymm0, ymm0, ymm2  // BGRA
+    vpackssdw  ymm0, ymm0, ymm0
+    vpermq     ymm0, ymm0, 0xd8
+    lea        eax, [eax + 32]
+    vmovdqu    [edx], xmm0  // store 8 pixels of ARGB1555
+    lea        edx, [edx + 16]
+    sub        ecx, 8
+    jg         convertloop
+    vzeroupper
+    ret
+  }
+}
+#endif  // HAS_ARGBTOARGB1555ROW_AVX2
+
+#ifdef HAS_ARGBTOARGB4444ROW_AVX2
+__declspec(naked) void ARGBToARGB4444Row_AVX2(const uint8_t* src_argb,
+                                              uint8_t* dst_rgb,
+                                              int width) {
+  __asm {
+    mov        eax, [esp + 4]  // src_argb
+    mov        edx, [esp + 8]  // dst_rgb
+    mov        ecx, [esp + 12]  // width
+    vpcmpeqb   ymm4, ymm4, ymm4  // generate mask 0xf000f000
+    vpsllw     ymm4, ymm4, 12
+    vpsrlw     ymm3, ymm4, 8  // generate mask 0x00f000f0
+
+ convertloop:
+    vmovdqu    ymm0, [eax]  // fetch 8 pixels of argb
+    vpand      ymm1, ymm0, ymm4  // high nibble
+    vpand      ymm0, ymm0, ymm3  // low nibble
+    vpsrld     ymm1, ymm1, 8
+    vpsrld     ymm0, ymm0, 4
+    vpor       ymm0, ymm0, ymm1
+    vpackuswb  ymm0, ymm0, ymm0
+    vpermq     ymm0, ymm0, 0xd8
+    lea        eax, [eax + 32]
+    vmovdqu    [edx], xmm0  // store 8 pixels of ARGB4444
+    lea        edx, [edx + 16]
+    sub        ecx, 8
+    jg         convertloop
+    vzeroupper
+    ret
+  }
+}
+#endif  // HAS_ARGBTOARGB4444ROW_AVX2
+
+// Convert 16 ARGB pixels (64 bytes) to 16 Y values.
+__declspec(naked) void ARGBToYRow_SSSE3(const uint8_t* src_argb,
+                                        uint8_t* dst_y,
+                                        int width) {
+  __asm {
+    mov        eax, [esp + 4] /* src_argb */
+    mov        edx, [esp + 8] /* dst_y */
+    mov        ecx, [esp + 12] /* width */
+    movdqa     xmm4, xmmword ptr kARGBToY
+    movdqa     xmm5, xmmword ptr kAddY16
+
+ convertloop:
+    movdqu     xmm0, [eax]
+    movdqu     xmm1, [eax + 16]
+    movdqu     xmm2, [eax + 32]
+    movdqu     xmm3, [eax + 48]
+    pmaddubsw  xmm0, xmm4
+    pmaddubsw  xmm1, xmm4
+    pmaddubsw  xmm2, xmm4
+    pmaddubsw  xmm3, xmm4
+    lea        eax, [eax + 64]
+    phaddw     xmm0, xmm1
+    phaddw     xmm2, xmm3
+    psrlw      xmm0, 7
+    psrlw      xmm2, 7
+    packuswb   xmm0, xmm2
+    paddb      xmm0, xmm5
+    movdqu     [edx], xmm0
+    lea        edx, [edx + 16]
+    sub        ecx, 16
+    jg         convertloop
+    ret
+  }
+}
+
+// Convert 16 ARGB pixels (64 bytes) to 16 YJ values.
+// Same as ARGBToYRow but different coefficients, no add 16, but do rounding.
+__declspec(naked) void ARGBToYJRow_SSSE3(const uint8_t* src_argb,
+                                         uint8_t* dst_y,
+                                         int width) {
+  __asm {
+    mov        eax, [esp + 4] /* src_argb */
+    mov        edx, [esp + 8] /* dst_y */
+    mov        ecx, [esp + 12] /* width */
+    movdqa     xmm4, xmmword ptr kARGBToYJ
+    movdqa     xmm5, xmmword ptr kAddYJ64
+
+ convertloop:
+    movdqu     xmm0, [eax]
+    movdqu     xmm1, [eax + 16]
+    movdqu     xmm2, [eax + 32]
+    movdqu     xmm3, [eax + 48]
+    pmaddubsw  xmm0, xmm4
+    pmaddubsw  xmm1, xmm4
+    pmaddubsw  xmm2, xmm4
+    pmaddubsw  xmm3, xmm4
+    lea        eax, [eax + 64]
+    phaddw     xmm0, xmm1
+    phaddw     xmm2, xmm3
+    paddw      xmm0, xmm5  // Add .5 for rounding.
+    paddw      xmm2, xmm5
+    psrlw      xmm0, 7
+    psrlw      xmm2, 7
+    packuswb   xmm0, xmm2
+    movdqu     [edx], xmm0
+    lea        edx, [edx + 16]
+    sub        ecx, 16
+    jg         convertloop
+    ret
+  }
+}
+
+#ifdef HAS_ARGBTOYROW_AVX2
+// vpermd for vphaddw + vpackuswb vpermd.
+static const lvec32 kPermdARGBToY_AVX = {0, 4, 1, 5, 2, 6, 3, 7};
+
+// Convert 32 ARGB pixels (128 bytes) to 32 Y values.
+__declspec(naked) void ARGBToYRow_AVX2(const uint8_t* src_argb,
+                                       uint8_t* dst_y,
+                                       int width) {
+  __asm {
+    mov        eax, [esp + 4] /* src_argb */
+    mov        edx, [esp + 8] /* dst_y */
+    mov        ecx, [esp + 12] /* width */
+    vbroadcastf128 ymm4, xmmword ptr kARGBToY
+    vbroadcastf128 ymm5, xmmword ptr kAddY16
+    vmovdqu    ymm6, ymmword ptr kPermdARGBToY_AVX
+
+ convertloop:
+    vmovdqu    ymm0, [eax]
+    vmovdqu    ymm1, [eax + 32]
+    vmovdqu    ymm2, [eax + 64]
+    vmovdqu    ymm3, [eax + 96]
+    vpmaddubsw ymm0, ymm0, ymm4
+    vpmaddubsw ymm1, ymm1, ymm4
+    vpmaddubsw ymm2, ymm2, ymm4
+    vpmaddubsw ymm3, ymm3, ymm4
+    lea        eax, [eax + 128]
+    vphaddw    ymm0, ymm0, ymm1  // mutates.
+    vphaddw    ymm2, ymm2, ymm3
+    vpsrlw     ymm0, ymm0, 7
+    vpsrlw     ymm2, ymm2, 7
+    vpackuswb  ymm0, ymm0, ymm2  // mutates.
+    vpermd     ymm0, ymm6, ymm0  // For vphaddw + vpackuswb mutation.
+    vpaddb     ymm0, ymm0, ymm5  // add 16 for Y
+    vmovdqu    [edx], ymm0
+    lea        edx, [edx + 32]
+    sub        ecx, 32
+    jg         convertloop
+    vzeroupper
+    ret
+  }
+}
+#endif  //  HAS_ARGBTOYROW_AVX2
+
+#ifdef HAS_ARGBTOYJROW_AVX2
+// Convert 32 ARGB pixels (128 bytes) to 32 Y values.
+__declspec(naked) void ARGBToYJRow_AVX2(const uint8_t* src_argb,
+                                        uint8_t* dst_y,
+                                        int width) {
+  __asm {
+    mov        eax, [esp + 4] /* src_argb */
+    mov        edx, [esp + 8] /* dst_y */
+    mov        ecx, [esp + 12] /* width */
+    vbroadcastf128 ymm4, xmmword ptr kARGBToYJ
+    vbroadcastf128 ymm5, xmmword ptr kAddYJ64
+    vmovdqu    ymm6, ymmword ptr kPermdARGBToY_AVX
+
+ convertloop:
+    vmovdqu    ymm0, [eax]
+    vmovdqu    ymm1, [eax + 32]
+    vmovdqu    ymm2, [eax + 64]
+    vmovdqu    ymm3, [eax + 96]
+    vpmaddubsw ymm0, ymm0, ymm4
+    vpmaddubsw ymm1, ymm1, ymm4
+    vpmaddubsw ymm2, ymm2, ymm4
+    vpmaddubsw ymm3, ymm3, ymm4
+    lea        eax, [eax + 128]
+    vphaddw    ymm0, ymm0, ymm1  // mutates.
+    vphaddw    ymm2, ymm2, ymm3
+    vpaddw     ymm0, ymm0, ymm5  // Add .5 for rounding.
+    vpaddw     ymm2, ymm2, ymm5
+    vpsrlw     ymm0, ymm0, 7
+    vpsrlw     ymm2, ymm2, 7
+    vpackuswb  ymm0, ymm0, ymm2  // mutates.
+    vpermd     ymm0, ymm6, ymm0  // For vphaddw + vpackuswb mutation.
+    vmovdqu    [edx], ymm0
+    lea        edx, [edx + 32]
+    sub        ecx, 32
+    jg         convertloop
+
+    vzeroupper
+    ret
+  }
+}
+#endif  //  HAS_ARGBTOYJROW_AVX2
+
+__declspec(naked) void BGRAToYRow_SSSE3(const uint8_t* src_argb,
+                                        uint8_t* dst_y,
+                                        int width) {
+  __asm {
+    mov        eax, [esp + 4] /* src_argb */
+    mov        edx, [esp + 8] /* dst_y */
+    mov        ecx, [esp + 12] /* width */
+    movdqa     xmm4, xmmword ptr kBGRAToY
+    movdqa     xmm5, xmmword ptr kAddY16
+
+ convertloop:
+    movdqu     xmm0, [eax]
+    movdqu     xmm1, [eax + 16]
+    movdqu     xmm2, [eax + 32]
+    movdqu     xmm3, [eax + 48]
+    pmaddubsw  xmm0, xmm4
+    pmaddubsw  xmm1, xmm4
+    pmaddubsw  xmm2, xmm4
+    pmaddubsw  xmm3, xmm4
+    lea        eax, [eax + 64]
+    phaddw     xmm0, xmm1
+    phaddw     xmm2, xmm3
+    psrlw      xmm0, 7
+    psrlw      xmm2, 7
+    packuswb   xmm0, xmm2
+    paddb      xmm0, xmm5
+    movdqu     [edx], xmm0
+    lea        edx, [edx + 16]
+    sub        ecx, 16
+    jg         convertloop
+    ret
+  }
+}
+
+__declspec(naked) void ABGRToYRow_SSSE3(const uint8_t* src_argb,
+                                        uint8_t* dst_y,
+                                        int width) {
+  __asm {
+    mov        eax, [esp + 4] /* src_argb */
+    mov        edx, [esp + 8] /* dst_y */
+    mov        ecx, [esp + 12] /* width */
+    movdqa     xmm4, xmmword ptr kABGRToY
+    movdqa     xmm5, xmmword ptr kAddY16
+
+ convertloop:
+    movdqu     xmm0, [eax]
+    movdqu     xmm1, [eax + 16]
+    movdqu     xmm2, [eax + 32]
+    movdqu     xmm3, [eax + 48]
+    pmaddubsw  xmm0, xmm4
+    pmaddubsw  xmm1, xmm4
+    pmaddubsw  xmm2, xmm4
+    pmaddubsw  xmm3, xmm4
+    lea        eax, [eax + 64]
+    phaddw     xmm0, xmm1
+    phaddw     xmm2, xmm3
+    psrlw      xmm0, 7
+    psrlw      xmm2, 7
+    packuswb   xmm0, xmm2
+    paddb      xmm0, xmm5
+    movdqu     [edx], xmm0
+    lea        edx, [edx + 16]
+    sub        ecx, 16
+    jg         convertloop
+    ret
+  }
+}
+
+__declspec(naked) void RGBAToYRow_SSSE3(const uint8_t* src_argb,
+                                        uint8_t* dst_y,
+                                        int width) {
+  __asm {
+    mov        eax, [esp + 4] /* src_argb */
+    mov        edx, [esp + 8] /* dst_y */
+    mov        ecx, [esp + 12] /* width */
+    movdqa     xmm4, xmmword ptr kRGBAToY
+    movdqa     xmm5, xmmword ptr kAddY16
+
+ convertloop:
+    movdqu     xmm0, [eax]
+    movdqu     xmm1, [eax + 16]
+    movdqu     xmm2, [eax + 32]
+    movdqu     xmm3, [eax + 48]
+    pmaddubsw  xmm0, xmm4
+    pmaddubsw  xmm1, xmm4
+    pmaddubsw  xmm2, xmm4
+    pmaddubsw  xmm3, xmm4
+    lea        eax, [eax + 64]
+    phaddw     xmm0, xmm1
+    phaddw     xmm2, xmm3
+    psrlw      xmm0, 7
+    psrlw      xmm2, 7
+    packuswb   xmm0, xmm2
+    paddb      xmm0, xmm5
+    movdqu     [edx], xmm0
+    lea        edx, [edx + 16]
+    sub        ecx, 16
+    jg         convertloop
+    ret
+  }
+}
+
+__declspec(naked) void ARGBToUVRow_SSSE3(const uint8_t* src_argb,
+                                         int src_stride_argb,
+                                         uint8_t* dst_u,
+                                         uint8_t* dst_v,
+                                         int width) {
+  __asm {
+    push       esi
+    push       edi
+    mov        eax, [esp + 8 + 4]  // src_argb
+    mov        esi, [esp + 8 + 8]  // src_stride_argb
+    mov        edx, [esp + 8 + 12]  // dst_u
+    mov        edi, [esp + 8 + 16]  // dst_v
+    mov        ecx, [esp + 8 + 20]  // width
+    movdqa     xmm5, xmmword ptr kBiasUV128
+    movdqa     xmm6, xmmword ptr kARGBToV
+    movdqa     xmm7, xmmword ptr kARGBToU
+    sub        edi, edx  // stride from u to v
+
+ convertloop:
+         /* step 1 - subsample 16x2 argb pixels to 8x1 */
+    movdqu     xmm0, [eax]
+    movdqu     xmm4, [eax + esi]
+    pavgb      xmm0, xmm4
+    movdqu     xmm1, [eax + 16]
+    movdqu     xmm4, [eax + esi + 16]
+    pavgb      xmm1, xmm4
+    movdqu     xmm2, [eax + 32]
+    movdqu     xmm4, [eax + esi + 32]
+    pavgb      xmm2, xmm4
+    movdqu     xmm3, [eax + 48]
+    movdqu     xmm4, [eax + esi + 48]
+    pavgb      xmm3, xmm4
+
+    lea        eax,  [eax + 64]
+    movdqa     xmm4, xmm0
+    shufps     xmm0, xmm1, 0x88
+    shufps     xmm4, xmm1, 0xdd
+    pavgb      xmm0, xmm4
+    movdqa     xmm4, xmm2
+    shufps     xmm2, xmm3, 0x88
+    shufps     xmm4, xmm3, 0xdd
+    pavgb      xmm2, xmm4
+
+        // step 2 - convert to U and V
+        // from here down is very similar to Y code except
+        // instead of 16 different pixels, its 8 pixels of U and 8 of V
+    movdqa     xmm1, xmm0
+    movdqa     xmm3, xmm2
+    pmaddubsw  xmm0, xmm7  // U
+    pmaddubsw  xmm2, xmm7
+    pmaddubsw  xmm1, xmm6  // V
+    pmaddubsw  xmm3, xmm6
+    phaddw     xmm0, xmm2
+    phaddw     xmm1, xmm3
+    psraw      xmm0, 8
+    psraw      xmm1, 8
+    packsswb   xmm0, xmm1
+    paddb      xmm0, xmm5  // -> unsigned
+
+        // step 3 - store 8 U and 8 V values
+    movlps     qword ptr [edx], xmm0  // U
+    movhps     qword ptr [edx + edi], xmm0  // V
+    lea        edx, [edx + 8]
+    sub        ecx, 16
+    jg         convertloop
+
+    pop        edi
+    pop        esi
+    ret
+  }
+}
+
+__declspec(naked) void ARGBToUVJRow_SSSE3(const uint8_t* src_argb,
+                                          int src_stride_argb,
+                                          uint8_t* dst_u,
+                                          uint8_t* dst_v,
+                                          int width) {
+  __asm {
+    push       esi
+    push       edi
+    mov        eax, [esp + 8 + 4]  // src_argb
+    mov        esi, [esp + 8 + 8]  // src_stride_argb
+    mov        edx, [esp + 8 + 12]  // dst_u
+    mov        edi, [esp + 8 + 16]  // dst_v
+    mov        ecx, [esp + 8 + 20]  // width
+    movdqa     xmm5, xmmword ptr kBiasUV128
+    movdqa     xmm6, xmmword ptr kARGBToVJ
+    movdqa     xmm7, xmmword ptr kARGBToUJ
+    sub        edi, edx  // stride from u to v
+
+ convertloop:
+         /* step 1 - subsample 16x2 argb pixels to 8x1 */
+    movdqu     xmm0, [eax]
+    movdqu     xmm4, [eax + esi]
+    pavgb      xmm0, xmm4
+    movdqu     xmm1, [eax + 16]
+    movdqu     xmm4, [eax + esi + 16]
+    pavgb      xmm1, xmm4
+    movdqu     xmm2, [eax + 32]
+    movdqu     xmm4, [eax + esi + 32]
+    pavgb      xmm2, xmm4
+    movdqu     xmm3, [eax + 48]
+    movdqu     xmm4, [eax + esi + 48]
+    pavgb      xmm3, xmm4
+
+    lea        eax,  [eax + 64]
+    movdqa     xmm4, xmm0
+    shufps     xmm0, xmm1, 0x88
+    shufps     xmm4, xmm1, 0xdd
+    pavgb      xmm0, xmm4
+    movdqa     xmm4, xmm2
+    shufps     xmm2, xmm3, 0x88
+    shufps     xmm4, xmm3, 0xdd
+    pavgb      xmm2, xmm4
+
+        // step 2 - convert to U and V
+        // from here down is very similar to Y code except
+        // instead of 16 different pixels, its 8 pixels of U and 8 of V
+    movdqa     xmm1, xmm0
+    movdqa     xmm3, xmm2
+    pmaddubsw  xmm0, xmm7  // U
+    pmaddubsw  xmm2, xmm7
+    pmaddubsw  xmm1, xmm6  // V
+    pmaddubsw  xmm3, xmm6
+    phaddw     xmm0, xmm2
+    phaddw     xmm1, xmm3
+    paddw      xmm0, xmm5  // +.5 rounding -> unsigned
+    paddw      xmm1, xmm5
+    psraw      xmm0, 8
+    psraw      xmm1, 8
+    packsswb   xmm0, xmm1
+
+        // step 3 - store 8 U and 8 V values
+    movlps     qword ptr [edx], xmm0  // U
+    movhps     qword ptr [edx + edi], xmm0  // V
+    lea        edx, [edx + 8]
+    sub        ecx, 16
+    jg         convertloop
+
+    pop        edi
+    pop        esi
+    ret
+  }
+}
+
+#ifdef HAS_ARGBTOUVROW_AVX2
+__declspec(naked) void ARGBToUVRow_AVX2(const uint8_t* src_argb,
+                                        int src_stride_argb,
+                                        uint8_t* dst_u,
+                                        uint8_t* dst_v,
+                                        int width) {
+  __asm {
+    push       esi
+    push       edi
+    mov        eax, [esp + 8 + 4]  // src_argb
+    mov        esi, [esp + 8 + 8]  // src_stride_argb
+    mov        edx, [esp + 8 + 12]  // dst_u
+    mov        edi, [esp + 8 + 16]  // dst_v
+    mov        ecx, [esp + 8 + 20]  // width
+    vbroadcastf128 ymm5, xmmword ptr kBiasUV128
+    vbroadcastf128 ymm6, xmmword ptr kARGBToV
+    vbroadcastf128 ymm7, xmmword ptr kARGBToU
+    sub        edi, edx   // stride from u to v
+
+ convertloop:
+        /* step 1 - subsample 32x2 argb pixels to 16x1 */
+    vmovdqu    ymm0, [eax]
+    vmovdqu    ymm1, [eax + 32]
+    vmovdqu    ymm2, [eax + 64]
+    vmovdqu    ymm3, [eax + 96]
+    vpavgb     ymm0, ymm0, [eax + esi]
+    vpavgb     ymm1, ymm1, [eax + esi + 32]
+    vpavgb     ymm2, ymm2, [eax + esi + 64]
+    vpavgb     ymm3, ymm3, [eax + esi + 96]
+    lea        eax,  [eax + 128]
+    vshufps    ymm4, ymm0, ymm1, 0x88
+    vshufps    ymm0, ymm0, ymm1, 0xdd
+    vpavgb     ymm0, ymm0, ymm4  // mutated by vshufps
+    vshufps    ymm4, ymm2, ymm3, 0x88
+    vshufps    ymm2, ymm2, ymm3, 0xdd
+    vpavgb     ymm2, ymm2, ymm4  // mutated by vshufps
+
+        // step 2 - convert to U and V
+        // from here down is very similar to Y code except
+        // instead of 32 different pixels, its 16 pixels of U and 16 of V
+    vpmaddubsw ymm1, ymm0, ymm7  // U
+    vpmaddubsw ymm3, ymm2, ymm7
+    vpmaddubsw ymm0, ymm0, ymm6  // V
+    vpmaddubsw ymm2, ymm2, ymm6
+    vphaddw    ymm1, ymm1, ymm3  // mutates
+    vphaddw    ymm0, ymm0, ymm2
+    vpsraw     ymm1, ymm1, 8
+    vpsraw     ymm0, ymm0, 8
+    vpacksswb  ymm0, ymm1, ymm0  // mutates
+    vpermq     ymm0, ymm0, 0xd8  // For vpacksswb
+    vpshufb    ymm0, ymm0, ymmword ptr kShufARGBToUV_AVX  // for vshufps/vphaddw
+    vpaddb     ymm0, ymm0, ymm5  // -> unsigned
+
+        // step 3 - store 16 U and 16 V values
+    vextractf128 [edx], ymm0, 0  // U
+    vextractf128 [edx + edi], ymm0, 1  // V
+    lea        edx, [edx + 16]
+    sub        ecx, 32
+    jg         convertloop
+
+    pop        edi
+    pop        esi
+    vzeroupper
+    ret
+  }
+}
+#endif  // HAS_ARGBTOUVROW_AVX2
+
+#ifdef HAS_ARGBTOUVJROW_AVX2
+__declspec(naked) void ARGBToUVJRow_AVX2(const uint8_t* src_argb,
+                                         int src_stride_argb,
+                                         uint8_t* dst_u,
+                                         uint8_t* dst_v,
+                                         int width) {
+  __asm {
+    push       esi
+    push       edi
+    mov        eax, [esp + 8 + 4]  // src_argb
+    mov        esi, [esp + 8 + 8]  // src_stride_argb
+    mov        edx, [esp + 8 + 12]  // dst_u
+    mov        edi, [esp + 8 + 16]  // dst_v
+    mov        ecx, [esp + 8 + 20]  // width
+    vbroadcastf128 ymm5, xmmword ptr kBiasUV128
+    vbroadcastf128 ymm6, xmmword ptr kARGBToVJ
+    vbroadcastf128 ymm7, xmmword ptr kARGBToUJ
+    sub        edi, edx   // stride from u to v
+
+ convertloop:
+        /* step 1 - subsample 32x2 argb pixels to 16x1 */
+    vmovdqu    ymm0, [eax]
+    vmovdqu    ymm1, [eax + 32]
+    vmovdqu    ymm2, [eax + 64]
+    vmovdqu    ymm3, [eax + 96]
+    vpavgb     ymm0, ymm0, [eax + esi]
+    vpavgb     ymm1, ymm1, [eax + esi + 32]
+    vpavgb     ymm2, ymm2, [eax + esi + 64]
+    vpavgb     ymm3, ymm3, [eax + esi + 96]
+    lea        eax,  [eax + 128]
+    vshufps    ymm4, ymm0, ymm1, 0x88
+    vshufps    ymm0, ymm0, ymm1, 0xdd
+    vpavgb     ymm0, ymm0, ymm4  // mutated by vshufps
+    vshufps    ymm4, ymm2, ymm3, 0x88
+    vshufps    ymm2, ymm2, ymm3, 0xdd
+    vpavgb     ymm2, ymm2, ymm4  // mutated by vshufps
+
+        // step 2 - convert to U and V
+        // from here down is very similar to Y code except
+        // instead of 32 different pixels, its 16 pixels of U and 16 of V
+    vpmaddubsw ymm1, ymm0, ymm7  // U
+    vpmaddubsw ymm3, ymm2, ymm7
+    vpmaddubsw ymm0, ymm0, ymm6  // V
+    vpmaddubsw ymm2, ymm2, ymm6
+    vphaddw    ymm1, ymm1, ymm3  // mutates
+    vphaddw    ymm0, ymm0, ymm2
+    vpaddw     ymm1, ymm1, ymm5  // +.5 rounding -> unsigned
+    vpaddw     ymm0, ymm0, ymm5
+    vpsraw     ymm1, ymm1, 8
+    vpsraw     ymm0, ymm0, 8
+    vpacksswb  ymm0, ymm1, ymm0  // mutates
+    vpermq     ymm0, ymm0, 0xd8  // For vpacksswb
+    vpshufb    ymm0, ymm0, ymmword ptr kShufARGBToUV_AVX  // for vshufps/vphaddw
+
+        // step 3 - store 16 U and 16 V values
+    vextractf128 [edx], ymm0, 0  // U
+    vextractf128 [edx + edi], ymm0, 1  // V
+    lea        edx, [edx + 16]
+    sub        ecx, 32
+    jg         convertloop
+
+    pop        edi
+    pop        esi
+    vzeroupper
+    ret
+  }
+}
+#endif  // HAS_ARGBTOUVJROW_AVX2
+
+__declspec(naked) void ARGBToUV444Row_SSSE3(const uint8_t* src_argb,
+                                            uint8_t* dst_u,
+                                            uint8_t* dst_v,
+                                            int width) {
+  __asm {
+    push       edi
+    mov        eax, [esp + 4 + 4]  // src_argb
+    mov        edx, [esp + 4 + 8]  // dst_u
+    mov        edi, [esp + 4 + 12]  // dst_v
+    mov        ecx, [esp + 4 + 16]  // width
+    movdqa     xmm5, xmmword ptr kBiasUV128
+    movdqa     xmm6, xmmword ptr kARGBToV
+    movdqa     xmm7, xmmword ptr kARGBToU
+    sub        edi, edx    // stride from u to v
+
+ convertloop:
+        /* convert to U and V */
+    movdqu     xmm0, [eax]  // U
+    movdqu     xmm1, [eax + 16]
+    movdqu     xmm2, [eax + 32]
+    movdqu     xmm3, [eax + 48]
+    pmaddubsw  xmm0, xmm7
+    pmaddubsw  xmm1, xmm7
+    pmaddubsw  xmm2, xmm7
+    pmaddubsw  xmm3, xmm7
+    phaddw     xmm0, xmm1
+    phaddw     xmm2, xmm3
+    psraw      xmm0, 8
+    psraw      xmm2, 8
+    packsswb   xmm0, xmm2
+    paddb      xmm0, xmm5
+    movdqu     [edx], xmm0
+
+    movdqu     xmm0, [eax]  // V
+    movdqu     xmm1, [eax + 16]
+    movdqu     xmm2, [eax + 32]
+    movdqu     xmm3, [eax + 48]
+    pmaddubsw  xmm0, xmm6
+    pmaddubsw  xmm1, xmm6
+    pmaddubsw  xmm2, xmm6
+    pmaddubsw  xmm3, xmm6
+    phaddw     xmm0, xmm1
+    phaddw     xmm2, xmm3
+    psraw      xmm0, 8
+    psraw      xmm2, 8
+    packsswb   xmm0, xmm2
+    paddb      xmm0, xmm5
+    lea        eax,  [eax + 64]
+    movdqu     [edx + edi], xmm0
+    lea        edx,  [edx + 16]
+    sub        ecx,  16
+    jg         convertloop
+
+    pop        edi
+    ret
+  }
+}
+
+__declspec(naked) void BGRAToUVRow_SSSE3(const uint8_t* src_argb,
+                                         int src_stride_argb,
+                                         uint8_t* dst_u,
+                                         uint8_t* dst_v,
+                                         int width) {
+  __asm {
+    push       esi
+    push       edi
+    mov        eax, [esp + 8 + 4]  // src_argb
+    mov        esi, [esp + 8 + 8]  // src_stride_argb
+    mov        edx, [esp + 8 + 12]  // dst_u
+    mov        edi, [esp + 8 + 16]  // dst_v
+    mov        ecx, [esp + 8 + 20]  // width
+    movdqa     xmm5, xmmword ptr kBiasUV128
+    movdqa     xmm6, xmmword ptr kBGRAToV
+    movdqa     xmm7, xmmword ptr kBGRAToU
+    sub        edi, edx  // stride from u to v
+
+ convertloop:
+         /* step 1 - subsample 16x2 argb pixels to 8x1 */
+    movdqu     xmm0, [eax]
+    movdqu     xmm4, [eax + esi]
+    pavgb      xmm0, xmm4
+    movdqu     xmm1, [eax + 16]
+    movdqu     xmm4, [eax + esi + 16]
+    pavgb      xmm1, xmm4
+    movdqu     xmm2, [eax + 32]
+    movdqu     xmm4, [eax + esi + 32]
+    pavgb      xmm2, xmm4
+    movdqu     xmm3, [eax + 48]
+    movdqu     xmm4, [eax + esi + 48]
+    pavgb      xmm3, xmm4
+
+    lea        eax,  [eax + 64]
+    movdqa     xmm4, xmm0
+    shufps     xmm0, xmm1, 0x88
+    shufps     xmm4, xmm1, 0xdd
+    pavgb      xmm0, xmm4
+    movdqa     xmm4, xmm2
+    shufps     xmm2, xmm3, 0x88
+    shufps     xmm4, xmm3, 0xdd
+    pavgb      xmm2, xmm4
+
+        // step 2 - convert to U and V
+        // from here down is very similar to Y code except
+        // instead of 16 different pixels, its 8 pixels of U and 8 of V
+    movdqa     xmm1, xmm0
+    movdqa     xmm3, xmm2
+    pmaddubsw  xmm0, xmm7  // U
+    pmaddubsw  xmm2, xmm7
+    pmaddubsw  xmm1, xmm6  // V
+    pmaddubsw  xmm3, xmm6
+    phaddw     xmm0, xmm2
+    phaddw     xmm1, xmm3
+    psraw      xmm0, 8
+    psraw      xmm1, 8
+    packsswb   xmm0, xmm1
+    paddb      xmm0, xmm5  // -> unsigned
+
+        // step 3 - store 8 U and 8 V values
+    movlps     qword ptr [edx], xmm0  // U
+    movhps     qword ptr [edx + edi], xmm0  // V
+    lea        edx, [edx + 8]
+    sub        ecx, 16
+    jg         convertloop
+
+    pop        edi
+    pop        esi
+    ret
+  }
+}
+
+__declspec(naked) void ABGRToUVRow_SSSE3(const uint8_t* src_argb,
+                                         int src_stride_argb,
+                                         uint8_t* dst_u,
+                                         uint8_t* dst_v,
+                                         int width) {
+  __asm {
+    push       esi
+    push       edi
+    mov        eax, [esp + 8 + 4]  // src_argb
+    mov        esi, [esp + 8 + 8]  // src_stride_argb
+    mov        edx, [esp + 8 + 12]  // dst_u
+    mov        edi, [esp + 8 + 16]  // dst_v
+    mov        ecx, [esp + 8 + 20]  // width
+    movdqa     xmm5, xmmword ptr kBiasUV128
+    movdqa     xmm6, xmmword ptr kABGRToV
+    movdqa     xmm7, xmmword ptr kABGRToU
+    sub        edi, edx  // stride from u to v
+
+ convertloop:
+         /* step 1 - subsample 16x2 argb pixels to 8x1 */
+    movdqu     xmm0, [eax]
+    movdqu     xmm4, [eax + esi]
+    pavgb      xmm0, xmm4
+    movdqu     xmm1, [eax + 16]
+    movdqu     xmm4, [eax + esi + 16]
+    pavgb      xmm1, xmm4
+    movdqu     xmm2, [eax + 32]
+    movdqu     xmm4, [eax + esi + 32]
+    pavgb      xmm2, xmm4
+    movdqu     xmm3, [eax + 48]
+    movdqu     xmm4, [eax + esi + 48]
+    pavgb      xmm3, xmm4
+
+    lea        eax,  [eax + 64]
+    movdqa     xmm4, xmm0
+    shufps     xmm0, xmm1, 0x88
+    shufps     xmm4, xmm1, 0xdd
+    pavgb      xmm0, xmm4
+    movdqa     xmm4, xmm2
+    shufps     xmm2, xmm3, 0x88
+    shufps     xmm4, xmm3, 0xdd
+    pavgb      xmm2, xmm4
+
+        // step 2 - convert to U and V
+        // from here down is very similar to Y code except
+        // instead of 16 different pixels, its 8 pixels of U and 8 of V
+    movdqa     xmm1, xmm0
+    movdqa     xmm3, xmm2
+    pmaddubsw  xmm0, xmm7  // U
+    pmaddubsw  xmm2, xmm7
+    pmaddubsw  xmm1, xmm6  // V
+    pmaddubsw  xmm3, xmm6
+    phaddw     xmm0, xmm2
+    phaddw     xmm1, xmm3
+    psraw      xmm0, 8
+    psraw      xmm1, 8
+    packsswb   xmm0, xmm1
+    paddb      xmm0, xmm5  // -> unsigned
+
+        // step 3 - store 8 U and 8 V values
+    movlps     qword ptr [edx], xmm0  // U
+    movhps     qword ptr [edx + edi], xmm0  // V
+    lea        edx, [edx + 8]
+    sub        ecx, 16
+    jg         convertloop
+
+    pop        edi
+    pop        esi
+    ret
+  }
+}
+
+__declspec(naked) void RGBAToUVRow_SSSE3(const uint8_t* src_argb,
+                                         int src_stride_argb,
+                                         uint8_t* dst_u,
+                                         uint8_t* dst_v,
+                                         int width) {
+  __asm {
+    push       esi
+    push       edi
+    mov        eax, [esp + 8 + 4]  // src_argb
+    mov        esi, [esp + 8 + 8]  // src_stride_argb
+    mov        edx, [esp + 8 + 12]  // dst_u
+    mov        edi, [esp + 8 + 16]  // dst_v
+    mov        ecx, [esp + 8 + 20]  // width
+    movdqa     xmm5, xmmword ptr kBiasUV128
+    movdqa     xmm6, xmmword ptr kRGBAToV
+    movdqa     xmm7, xmmword ptr kRGBAToU
+    sub        edi, edx  // stride from u to v
+
+ convertloop:
+         /* step 1 - subsample 16x2 argb pixels to 8x1 */
+    movdqu     xmm0, [eax]
+    movdqu     xmm4, [eax + esi]
+    pavgb      xmm0, xmm4
+    movdqu     xmm1, [eax + 16]
+    movdqu     xmm4, [eax + esi + 16]
+    pavgb      xmm1, xmm4
+    movdqu     xmm2, [eax + 32]
+    movdqu     xmm4, [eax + esi + 32]
+    pavgb      xmm2, xmm4
+    movdqu     xmm3, [eax + 48]
+    movdqu     xmm4, [eax + esi + 48]
+    pavgb      xmm3, xmm4
+
+    lea        eax,  [eax + 64]
+    movdqa     xmm4, xmm0
+    shufps     xmm0, xmm1, 0x88
+    shufps     xmm4, xmm1, 0xdd
+    pavgb      xmm0, xmm4
+    movdqa     xmm4, xmm2
+    shufps     xmm2, xmm3, 0x88
+    shufps     xmm4, xmm3, 0xdd
+    pavgb      xmm2, xmm4
+
+        // step 2 - convert to U and V
+        // from here down is very similar to Y code except
+        // instead of 16 different pixels, its 8 pixels of U and 8 of V
+    movdqa     xmm1, xmm0
+    movdqa     xmm3, xmm2
+    pmaddubsw  xmm0, xmm7  // U
+    pmaddubsw  xmm2, xmm7
+    pmaddubsw  xmm1, xmm6  // V
+    pmaddubsw  xmm3, xmm6
+    phaddw     xmm0, xmm2
+    phaddw     xmm1, xmm3
+    psraw      xmm0, 8
+    psraw      xmm1, 8
+    packsswb   xmm0, xmm1
+    paddb      xmm0, xmm5  // -> unsigned
+
+        // step 3 - store 8 U and 8 V values
+    movlps     qword ptr [edx], xmm0  // U
+    movhps     qword ptr [edx + edi], xmm0  // V
+    lea        edx, [edx + 8]
+    sub        ecx, 16
+    jg         convertloop
+
+    pop        edi
+    pop        esi
+    ret
+  }
+}
+#endif  // HAS_ARGBTOYROW_SSSE3
+
+// Read 16 UV from 444
+#define READYUV444_AVX2 \
+  __asm {                                                                      \
+    __asm vmovdqu    xmm3, [esi] /* U */                                       \
+    __asm vmovdqu    xmm1, [esi + edi] /* V */                                 \
+    __asm lea        esi,  [esi + 16]                                          \
+    __asm vpermq     ymm3, ymm3, 0xd8                                          \
+    __asm vpermq     ymm1, ymm1, 0xd8                                          \
+    __asm vpunpcklbw ymm3, ymm3, ymm1 /* UV */                                 \
+    __asm vmovdqu    xmm4, [eax] /* Y */                                       \
+    __asm vpermq     ymm4, ymm4, 0xd8                                          \
+    __asm vpunpcklbw ymm4, ymm4, ymm4                                          \
+    __asm lea        eax, [eax + 16]}
+
+// Read 16 UV from 444.  With 16 Alpha.
+#define READYUVA444_AVX2 \
+  __asm {                                                                      \
+    __asm vmovdqu    xmm3, [esi] /* U */                                       \
+    __asm vmovdqu    xmm1, [esi + edi] /* V */                                 \
+    __asm lea        esi,  [esi + 16]                                          \
+    __asm vpermq     ymm3, ymm3, 0xd8                                          \
+    __asm vpermq     ymm1, ymm1, 0xd8                                          \
+    __asm vpunpcklbw ymm3, ymm3, ymm1 /* UV */                                 \
+    __asm vmovdqu    xmm4, [eax] /* Y */                                       \
+    __asm vpermq     ymm4, ymm4, 0xd8                                          \
+    __asm vpunpcklbw ymm4, ymm4, ymm4                                          \
+    __asm lea        eax, [eax + 16]                                           \
+    __asm vmovdqu    xmm5, [ebp] /* A */                                       \
+    __asm vpermq     ymm5, ymm5, 0xd8                                          \
+    __asm lea        ebp, [ebp + 16]}
+
+// Read 8 UV from 422, upsample to 16 UV.
+#define READYUV422_AVX2 \
+  __asm {                                                                      \
+    __asm vmovq      xmm3, qword ptr [esi] /* U */                             \
+    __asm vmovq      xmm1, qword ptr [esi + edi] /* V */                       \
+    __asm lea        esi,  [esi + 8]                                           \
+    __asm vpunpcklbw ymm3, ymm3, ymm1 /* UV */                                 \
+    __asm vpermq     ymm3, ymm3, 0xd8                                          \
+    __asm vpunpcklwd ymm3, ymm3, ymm3 /* UVUV (upsample) */                    \
+    __asm vmovdqu    xmm4, [eax] /* Y */                                       \
+    __asm vpermq     ymm4, ymm4, 0xd8                                          \
+    __asm vpunpcklbw ymm4, ymm4, ymm4                                          \
+    __asm lea        eax, [eax + 16]}
+
+// Read 8 UV from 422, upsample to 16 UV.  With 16 Alpha.
+#define READYUVA422_AVX2 \
+  __asm {                                                                      \
+    __asm vmovq      xmm3, qword ptr [esi] /* U */                             \
+    __asm vmovq      xmm1, qword ptr [esi + edi] /* V */                       \
+    __asm lea        esi,  [esi + 8]                                           \
+    __asm vpunpcklbw ymm3, ymm3, ymm1 /* UV */                                 \
+    __asm vpermq     ymm3, ymm3, 0xd8                                          \
+    __asm vpunpcklwd ymm3, ymm3, ymm3 /* UVUV (upsample) */                    \
+    __asm vmovdqu    xmm4, [eax] /* Y */                                       \
+    __asm vpermq     ymm4, ymm4, 0xd8                                          \
+    __asm vpunpcklbw ymm4, ymm4, ymm4                                          \
+    __asm lea        eax, [eax + 16]                                           \
+    __asm vmovdqu    xmm5, [ebp] /* A */                                       \
+    __asm vpermq     ymm5, ymm5, 0xd8                                          \
+    __asm lea        ebp, [ebp + 16]}
+
+// Read 8 UV from NV12, upsample to 16 UV.
+#define READNV12_AVX2 \
+  __asm {                                                                      \
+    __asm vmovdqu    xmm3, [esi] /* UV */                                      \
+    __asm lea        esi,  [esi + 16]                                          \
+    __asm vpermq     ymm3, ymm3, 0xd8                                          \
+    __asm vpunpcklwd ymm3, ymm3, ymm3 /* UVUV (upsample) */                    \
+    __asm vmovdqu    xmm4, [eax] /* Y */                                       \
+    __asm vpermq     ymm4, ymm4, 0xd8                                          \
+    __asm vpunpcklbw ymm4, ymm4, ymm4                                          \
+    __asm lea        eax, [eax + 16]}
+
+// Read 8 UV from NV21, upsample to 16 UV.
+#define READNV21_AVX2 \
+  __asm {                                                                      \
+    __asm vmovdqu    xmm3, [esi] /* UV */                                      \
+    __asm lea        esi,  [esi + 16]                                          \
+    __asm vpermq     ymm3, ymm3, 0xd8                                          \
+    __asm vpshufb    ymm3, ymm3, ymmword ptr kShuffleNV21                      \
+    __asm vmovdqu    xmm4, [eax] /* Y */                                       \
+    __asm vpermq     ymm4, ymm4, 0xd8                                          \
+    __asm vpunpcklbw ymm4, ymm4, ymm4                                          \
+    __asm lea        eax, [eax + 16]}
+
+// Read 8 YUY2 with 16 Y and upsample 8 UV to 16 UV.
+#define READYUY2_AVX2 \
+  __asm {                                                                      \
+    __asm vmovdqu    ymm4, [eax] /* YUY2 */                                    \
+    __asm vpshufb    ymm4, ymm4, ymmword ptr kShuffleYUY2Y                     \
+    __asm vmovdqu    ymm3, [eax] /* UV */                                      \
+    __asm vpshufb    ymm3, ymm3, ymmword ptr kShuffleYUY2UV                    \
+    __asm lea        eax, [eax + 32]}
+
+// Read 8 UYVY with 16 Y and upsample 8 UV to 16 UV.
+#define READUYVY_AVX2 \
+  __asm {                                                                      \
+    __asm vmovdqu    ymm4, [eax] /* UYVY */                                    \
+    __asm vpshufb    ymm4, ymm4, ymmword ptr kShuffleUYVYY                     \
+    __asm vmovdqu    ymm3, [eax] /* UV */                                      \
+    __asm vpshufb    ymm3, ymm3, ymmword ptr kShuffleUYVYUV                    \
+    __asm lea        eax, [eax + 32]}
+
+// Convert 16 pixels: 16 UV and 16 Y.
+#define YUVTORGB_AVX2(YuvConstants) \
+  __asm {                                                                      \
+    __asm vpsubb     ymm3, ymm3, ymmword ptr kBiasUV128                        \
+    __asm vpmulhuw   ymm4, ymm4, ymmword ptr [YuvConstants + KYTORGB]          \
+    __asm vmovdqa    ymm0, ymmword ptr [YuvConstants + KUVTOB]                 \
+    __asm vmovdqa    ymm1, ymmword ptr [YuvConstants + KUVTOG]                 \
+    __asm vmovdqa    ymm2, ymmword ptr [YuvConstants + KUVTOR]                 \
+    __asm vpmaddubsw ymm0, ymm0, ymm3 /* B UV */                               \
+    __asm vpmaddubsw ymm1, ymm1, ymm3 /* G UV */                               \
+    __asm vpmaddubsw ymm2, ymm2, ymm3 /* B UV */                               \
+    __asm vmovdqu    ymm3, ymmword ptr [YuvConstants + KYBIASTORGB]            \
+    __asm vpaddw     ymm4, ymm3, ymm4                                          \
+    __asm vpaddsw    ymm0, ymm0, ymm4                                          \
+    __asm vpsubsw    ymm1, ymm4, ymm1                                          \
+    __asm vpaddsw    ymm2, ymm2, ymm4                                          \
+    __asm vpsraw     ymm0, ymm0, 6                                             \
+    __asm vpsraw     ymm1, ymm1, 6                                             \
+    __asm vpsraw     ymm2, ymm2, 6                                             \
+    __asm vpackuswb  ymm0, ymm0, ymm0                                          \
+    __asm vpackuswb  ymm1, ymm1, ymm1                                          \
+    __asm vpackuswb  ymm2, ymm2, ymm2}
+
+// Store 16 ARGB values.
+#define STOREARGB_AVX2 \
+  __asm {                                                                      \
+    __asm vpunpcklbw ymm0, ymm0, ymm1 /* BG */                                 \
+    __asm vpermq     ymm0, ymm0, 0xd8                                          \
+    __asm vpunpcklbw ymm2, ymm2, ymm5 /* RA */                                 \
+    __asm vpermq     ymm2, ymm2, 0xd8                                          \
+    __asm vpunpcklwd ymm1, ymm0, ymm2 /* BGRA first 8 pixels */                \
+    __asm vpunpckhwd ymm0, ymm0, ymm2 /* BGRA next 8 pixels */                 \
+    __asm vmovdqu    0[edx], ymm1                                              \
+    __asm vmovdqu    32[edx], ymm0                                             \
+    __asm lea        edx,  [edx + 64]}
+
+// Store 16 RGBA values.
+#define STORERGBA_AVX2 \
+  __asm {                                                                      \
+    __asm vpunpcklbw ymm1, ymm1, ymm2 /* GR */                                 \
+    __asm vpermq     ymm1, ymm1, 0xd8                                          \
+    __asm vpunpcklbw ymm2, ymm5, ymm0 /* AB */                                 \
+    __asm vpermq     ymm2, ymm2, 0xd8                                          \
+    __asm vpunpcklwd ymm0, ymm2, ymm1 /* ABGR first 8 pixels */                \
+    __asm vpunpckhwd ymm1, ymm2, ymm1 /* ABGR next 8 pixels */                 \
+    __asm vmovdqu    [edx], ymm0                                               \
+    __asm vmovdqu    [edx + 32], ymm1                                          \
+    __asm lea        edx,  [edx + 64]}
+
+#ifdef HAS_I422TOARGBROW_AVX2
+// 16 pixels
+// 8 UV values upsampled to 16 UV, mixed with 16 Y producing 16 ARGB (64 bytes).
+__declspec(naked) void I422ToARGBRow_AVX2(
+    const uint8_t* y_buf,
+    const uint8_t* u_buf,
+    const uint8_t* v_buf,
+    uint8_t* dst_argb,
+    const struct YuvConstants* yuvconstants,
+    int width) {
+  __asm {
+    push       esi
+    push       edi
+    push       ebx
+    mov        eax, [esp + 12 + 4]  // Y
+    mov        esi, [esp + 12 + 8]  // U
+    mov        edi, [esp + 12 + 12]  // V
+    mov        edx, [esp + 12 + 16]  // argb
+    mov        ebx, [esp + 12 + 20]  // yuvconstants
+    mov        ecx, [esp + 12 + 24]  // width
+    sub        edi, esi
+    vpcmpeqb   ymm5, ymm5, ymm5  // generate 0xffffffffffffffff for alpha
+
+ convertloop:
+    READYUV422_AVX2
+    YUVTORGB_AVX2(ebx)
+    STOREARGB_AVX2
+
+    sub        ecx, 16
+    jg         convertloop
+
+    pop        ebx
+    pop        edi
+    pop        esi
+    vzeroupper
+    ret
+  }
+}
+#endif  // HAS_I422TOARGBROW_AVX2
+
+#ifdef HAS_I422ALPHATOARGBROW_AVX2
+// 16 pixels
+// 8 UV values upsampled to 16 UV, mixed with 16 Y and 16 A producing 16 ARGB.
+__declspec(naked) void I422AlphaToARGBRow_AVX2(
+    const uint8_t* y_buf,
+    const uint8_t* u_buf,
+    const uint8_t* v_buf,
+    const uint8_t* a_buf,
+    uint8_t* dst_argb,
+    const struct YuvConstants* yuvconstants,
+    int width) {
+  __asm {
+    push       esi
+    push       edi
+    push       ebx
+    push       ebp
+    mov        eax, [esp + 16 + 4]  // Y
+    mov        esi, [esp + 16 + 8]  // U
+    mov        edi, [esp + 16 + 12]  // V
+    mov        ebp, [esp + 16 + 16]  // A
+    mov        edx, [esp + 16 + 20]  // argb
+    mov        ebx, [esp + 16 + 24]  // yuvconstants
+    mov        ecx, [esp + 16 + 28]  // width
+    sub        edi, esi
+
+ convertloop:
+    READYUVA422_AVX2
+    YUVTORGB_AVX2(ebx)
+    STOREARGB_AVX2
+
+    sub        ecx, 16
+    jg         convertloop
+
+    pop        ebp
+    pop        ebx
+    pop        edi
+    pop        esi
+    vzeroupper
+    ret
+  }
+}
+#endif  // HAS_I422ALPHATOARGBROW_AVX2
+
+#ifdef HAS_I444TOARGBROW_AVX2
+// 16 pixels
+// 16 UV values with 16 Y producing 16 ARGB (64 bytes).
+__declspec(naked) void I444ToARGBRow_AVX2(
+    const uint8_t* y_buf,
+    const uint8_t* u_buf,
+    const uint8_t* v_buf,
+    uint8_t* dst_argb,
+    const struct YuvConstants* yuvconstants,
+    int width) {
+  __asm {
+    push       esi
+    push       edi
+    push       ebx
+    mov        eax, [esp + 12 + 4]  // Y
+    mov        esi, [esp + 12 + 8]  // U
+    mov        edi, [esp + 12 + 12]  // V
+    mov        edx, [esp + 12 + 16]  // argb
+    mov        ebx, [esp + 12 + 20]  // yuvconstants
+    mov        ecx, [esp + 12 + 24]  // width
+    sub        edi, esi
+    vpcmpeqb   ymm5, ymm5, ymm5  // generate 0xffffffffffffffff for alpha
+ convertloop:
+    READYUV444_AVX2
+    YUVTORGB_AVX2(ebx)
+    STOREARGB_AVX2
+
+    sub        ecx, 16
+    jg         convertloop
+
+    pop        ebx
+    pop        edi
+    pop        esi
+    vzeroupper
+    ret
+  }
+}
+#endif  // HAS_I444TOARGBROW_AVX2
+
+#ifdef HAS_I444ALPHATOARGBROW_AVX2
+// 16 pixels
+// 16 UV values with 16 Y producing 16 ARGB (64 bytes).
+__declspec(naked) void I444AlphaToARGBRow_AVX2(
+    const uint8_t* y_buf,
+    const uint8_t* u_buf,
+    const uint8_t* v_buf,
+    const uint8_t* a_buf,
+    uint8_t* dst_argb,
+    const struct YuvConstants* yuvconstants,
+    int width) {
+  __asm {
+  push       esi
+  push       edi
+  push       ebx
+  push       ebp
+  mov        eax, [esp + 16 + 4]  // Y
+  mov        esi, [esp + 16 + 8]  // U
+  mov        edi, [esp + 16 + 12]  // V
+  mov        ebp, [esp + 16 + 16]  // A
+  mov        edx, [esp + 16 + 20]  // argb
+  mov        ebx, [esp + 16 + 24]  // yuvconstants
+  mov        ecx, [esp + 16 + 28]  // width
+  sub        edi, esi
+  convertloop:
+  READYUVA444_AVX2
+  YUVTORGB_AVX2(ebx)
+  STOREARGB_AVX2
+
+  sub        ecx, 16
+  jg         convertloop
+
+  pop        ebp
+  pop        ebx
+  pop        edi
+  pop        esi
+  vzeroupper
+  ret
+  }
+}
+#endif  // HAS_I444AlphaTOARGBROW_AVX2
+
+#ifdef HAS_NV12TOARGBROW_AVX2
+// 16 pixels.
+// 8 UV values upsampled to 16 UV, mixed with 16 Y producing 16 ARGB (64 bytes).
+__declspec(naked) void NV12ToARGBRow_AVX2(
+    const uint8_t* y_buf,
+    const uint8_t* uv_buf,
+    uint8_t* dst_argb,
+    const struct YuvConstants* yuvconstants,
+    int width) {
+  __asm {
+    push       esi
+    push       ebx
+    mov        eax, [esp + 8 + 4]  // Y
+    mov        esi, [esp + 8 + 8]  // UV
+    mov        edx, [esp + 8 + 12]  // argb
+    mov        ebx, [esp + 8 + 16]  // yuvconstants
+    mov        ecx, [esp + 8 + 20]  // width
+    vpcmpeqb   ymm5, ymm5, ymm5  // generate 0xffffffffffffffff for alpha
+
+ convertloop:
+    READNV12_AVX2
+    YUVTORGB_AVX2(ebx)
+    STOREARGB_AVX2
+
+    sub        ecx, 16
+    jg         convertloop
+
+    pop        ebx
+    pop        esi
+    vzeroupper
+    ret
+  }
+}
+#endif  // HAS_NV12TOARGBROW_AVX2
+
+#ifdef HAS_NV21TOARGBROW_AVX2
+// 16 pixels.
+// 8 VU values upsampled to 16 UV, mixed with 16 Y producing 16 ARGB (64 bytes).
+__declspec(naked) void NV21ToARGBRow_AVX2(
+    const uint8_t* y_buf,
+    const uint8_t* vu_buf,
+    uint8_t* dst_argb,
+    const struct YuvConstants* yuvconstants,
+    int width) {
+  __asm {
+    push       esi
+    push       ebx
+    mov        eax, [esp + 8 + 4]  // Y
+    mov        esi, [esp + 8 + 8]  // VU
+    mov        edx, [esp + 8 + 12]  // argb
+    mov        ebx, [esp + 8 + 16]  // yuvconstants
+    mov        ecx, [esp + 8 + 20]  // width
+    vpcmpeqb   ymm5, ymm5, ymm5  // generate 0xffffffffffffffff for alpha
+
+ convertloop:
+    READNV21_AVX2
+    YUVTORGB_AVX2(ebx)
+    STOREARGB_AVX2
+
+    sub        ecx, 16
+    jg         convertloop
+
+    pop        ebx
+    pop        esi
+    vzeroupper
+    ret
+  }
+}
+#endif  // HAS_NV21TOARGBROW_AVX2
+
+#ifdef HAS_YUY2TOARGBROW_AVX2
+// 16 pixels.
+// 8 YUY2 values with 16 Y and 8 UV producing 16 ARGB (64 bytes).
+__declspec(naked) void YUY2ToARGBRow_AVX2(
+    const uint8_t* src_yuy2,
+    uint8_t* dst_argb,
+    const struct YuvConstants* yuvconstants,
+    int width) {
+  __asm {
+    push       ebx
+    mov        eax, [esp + 4 + 4]  // yuy2
+    mov        edx, [esp + 4 + 8]  // argb
+    mov        ebx, [esp + 4 + 12]  // yuvconstants
+    mov        ecx, [esp + 4 + 16]  // width
+    vpcmpeqb   ymm5, ymm5, ymm5  // generate 0xffffffffffffffff for alpha
+
+ convertloop:
+    READYUY2_AVX2
+    YUVTORGB_AVX2(ebx)
+    STOREARGB_AVX2
+
+    sub        ecx, 16
+    jg         convertloop
+
+    pop        ebx
+    vzeroupper
+    ret
+  }
+}
+#endif  // HAS_YUY2TOARGBROW_AVX2
+
+#ifdef HAS_UYVYTOARGBROW_AVX2
+// 16 pixels.
+// 8 UYVY values with 16 Y and 8 UV producing 16 ARGB (64 bytes).
+__declspec(naked) void UYVYToARGBRow_AVX2(
+    const uint8_t* src_uyvy,
+    uint8_t* dst_argb,
+    const struct YuvConstants* yuvconstants,
+    int width) {
+  __asm {
+    push       ebx
+    mov        eax, [esp + 4 + 4]  // uyvy
+    mov        edx, [esp + 4 + 8]  // argb
+    mov        ebx, [esp + 4 + 12]  // yuvconstants
+    mov        ecx, [esp + 4 + 16]  // width
+    vpcmpeqb   ymm5, ymm5, ymm5  // generate 0xffffffffffffffff for alpha
+
+ convertloop:
+    READUYVY_AVX2
+    YUVTORGB_AVX2(ebx)
+    STOREARGB_AVX2
+
+    sub        ecx, 16
+    jg         convertloop
+
+    pop        ebx
+    vzeroupper
+    ret
+  }
+}
+#endif  // HAS_UYVYTOARGBROW_AVX2
+
+#ifdef HAS_I422TORGBAROW_AVX2
+// 16 pixels
+// 8 UV values upsampled to 16 UV, mixed with 16 Y producing 16 RGBA (64 bytes).
+__declspec(naked) void I422ToRGBARow_AVX2(
+    const uint8_t* y_buf,
+    const uint8_t* u_buf,
+    const uint8_t* v_buf,
+    uint8_t* dst_argb,
+    const struct YuvConstants* yuvconstants,
+    int width) {
+  __asm {
+    push       esi
+    push       edi
+    push       ebx
+    mov        eax, [esp + 12 + 4]  // Y
+    mov        esi, [esp + 12 + 8]  // U
+    mov        edi, [esp + 12 + 12]  // V
+    mov        edx, [esp + 12 + 16]  // abgr
+    mov        ebx, [esp + 12 + 20]  // yuvconstants
+    mov        ecx, [esp + 12 + 24]  // width
+    sub        edi, esi
+    vpcmpeqb   ymm5, ymm5, ymm5  // generate 0xffffffffffffffff for alpha
+
+ convertloop:
+    READYUV422_AVX2
+    YUVTORGB_AVX2(ebx)
+    STORERGBA_AVX2
+
+    sub        ecx, 16
+    jg         convertloop
+
+    pop        ebx
+    pop        edi
+    pop        esi
+    vzeroupper
+    ret
+  }
+}
+#endif  // HAS_I422TORGBAROW_AVX2
+
+#if defined(HAS_I422TOARGBROW_SSSE3)
+// TODO(fbarchard): Read that does half size on Y and treats 420 as 444.
+// Allows a conversion with half size scaling.
+
+// Read 8 UV from 444.
+#define READYUV444 \
+  __asm {                                                                      \
+    __asm movq       xmm3, qword ptr [esi] /* U */                             \
+    __asm movq       xmm1, qword ptr [esi + edi] /* V */                       \
+    __asm lea        esi,  [esi + 8]                                           \
+    __asm punpcklbw  xmm3, xmm1 /* UV */                                       \
+    __asm movq       xmm4, qword ptr [eax]                                     \
+    __asm punpcklbw  xmm4, xmm4                                                \
+    __asm lea        eax, [eax + 8]}
+
+// Read 4 UV from 444.  With 8 Alpha.
+#define READYUVA444 \
+  __asm {                                                                      \
+    __asm movq       xmm3, qword ptr [esi] /* U */                             \
+    __asm movq       xmm1, qword ptr [esi + edi] /* V */                       \
+    __asm lea        esi,  [esi + 8]                                           \
+    __asm punpcklbw  xmm3, xmm1 /* UV */                                       \
+    __asm movq       xmm4, qword ptr [eax]                                     \
+    __asm punpcklbw  xmm4, xmm4                                                \
+    __asm lea        eax, [eax + 8]                                            \
+    __asm movq       xmm5, qword ptr [ebp] /* A */                             \
+    __asm lea        ebp, [ebp + 8]}
+
+// Read 4 UV from 422, upsample to 8 UV.
+#define READYUV422 \
+  __asm {                                                                      \
+    __asm movd       xmm3, [esi] /* U */                                       \
+    __asm movd       xmm1, [esi + edi] /* V */                                 \
+    __asm lea        esi,  [esi + 4]                                           \
+    __asm punpcklbw  xmm3, xmm1 /* UV */                                       \
+    __asm punpcklwd  xmm3, xmm3 /* UVUV (upsample) */                          \
+    __asm movq       xmm4, qword ptr [eax]                                     \
+    __asm punpcklbw  xmm4, xmm4                                                \
+    __asm lea        eax, [eax + 8]}
+
+// Read 4 UV from 422, upsample to 8 UV.  With 8 Alpha.
+#define READYUVA422 \
+  __asm {                                                                      \
+    __asm movd       xmm3, [esi] /* U */                                       \
+    __asm movd       xmm1, [esi + edi] /* V */                                 \
+    __asm lea        esi,  [esi + 4]                                           \
+    __asm punpcklbw  xmm3, xmm1 /* UV */                                       \
+    __asm punpcklwd  xmm3, xmm3 /* UVUV (upsample) */                          \
+    __asm movq       xmm4, qword ptr [eax] /* Y */                             \
+    __asm punpcklbw  xmm4, xmm4                                                \
+    __asm lea        eax, [eax + 8]                                            \
+    __asm movq       xmm5, qword ptr [ebp] /* A */                             \
+    __asm lea        ebp, [ebp + 8]}
+
+// Read 4 UV from NV12, upsample to 8 UV.
+#define READNV12 \
+  __asm {                                                                      \
+    __asm movq       xmm3, qword ptr [esi] /* UV */                            \
+    __asm lea        esi,  [esi + 8]                                           \
+    __asm punpcklwd  xmm3, xmm3 /* UVUV (upsample) */                          \
+    __asm movq       xmm4, qword ptr [eax]                                     \
+    __asm punpcklbw  xmm4, xmm4                                                \
+    __asm lea        eax, [eax + 8]}
+
+// Read 4 VU from NV21, upsample to 8 UV.
+#define READNV21 \
+  __asm {                                                                      \
+    __asm movq       xmm3, qword ptr [esi] /* UV */                            \
+    __asm lea        esi,  [esi + 8]                                           \
+    __asm pshufb     xmm3, xmmword ptr kShuffleNV21                            \
+    __asm movq       xmm4, qword ptr [eax]                                     \
+    __asm punpcklbw  xmm4, xmm4                                                \
+    __asm lea        eax, [eax + 8]}
+
+// Read 4 YUY2 with 8 Y and upsample 4 UV to 8 UV.
+#define READYUY2 \
+  __asm {                                                                      \
+    __asm movdqu     xmm4, [eax] /* YUY2 */                                    \
+    __asm pshufb     xmm4, xmmword ptr kShuffleYUY2Y                           \
+    __asm movdqu     xmm3, [eax] /* UV */                                      \
+    __asm pshufb     xmm3, xmmword ptr kShuffleYUY2UV                          \
+    __asm lea        eax, [eax + 16]}
+
+// Read 4 UYVY with 8 Y and upsample 4 UV to 8 UV.
+#define READUYVY \
+  __asm {                                                                      \
+    __asm movdqu     xmm4, [eax] /* UYVY */                                    \
+    __asm pshufb     xmm4, xmmword ptr kShuffleUYVYY                           \
+    __asm movdqu     xmm3, [eax] /* UV */                                      \
+    __asm pshufb     xmm3, xmmword ptr kShuffleUYVYUV                          \
+    __asm lea        eax, [eax + 16]}
+
+// Convert 8 pixels: 8 UV and 8 Y.
+#define YUVTORGB(YuvConstants) \
+  __asm {                                                                      \
+    __asm psubb      xmm3, xmmword ptr kBiasUV128                              \
+    __asm pmulhuw    xmm4, xmmword ptr [YuvConstants + KYTORGB]                \
+    __asm movdqa     xmm0, xmmword ptr [YuvConstants + KUVTOB]                 \
+    __asm movdqa     xmm1, xmmword ptr [YuvConstants + KUVTOG]                 \
+    __asm movdqa     xmm2, xmmword ptr [YuvConstants + KUVTOR]                 \
+    __asm pmaddubsw  xmm0, xmm3                                                \
+    __asm pmaddubsw  xmm1, xmm3                                                \
+    __asm pmaddubsw  xmm2, xmm3                                                \
+    __asm movdqa     xmm3, xmmword ptr [YuvConstants + KYBIASTORGB]            \
+    __asm paddw      xmm4, xmm3                                                \
+    __asm paddsw     xmm0, xmm4                                                \
+    __asm paddsw     xmm2, xmm4                                                \
+    __asm psubsw     xmm4, xmm1                                                \
+    __asm movdqa     xmm1, xmm4                                                \
+    __asm psraw      xmm0, 6                                                   \
+    __asm psraw      xmm1, 6                                                   \
+    __asm psraw      xmm2, 6                                                   \
+    __asm packuswb   xmm0, xmm0 /* B */                                        \
+    __asm packuswb   xmm1, xmm1 /* G */                                        \
+    __asm packuswb   xmm2, xmm2 /* R */             \
+  }
+
+// Store 8 ARGB values.
+#define STOREARGB \
+  __asm {                                                                      \
+    __asm punpcklbw  xmm0, xmm1 /* BG */                                       \
+    __asm punpcklbw  xmm2, xmm5 /* RA */                                       \
+    __asm movdqa     xmm1, xmm0                                                \
+    __asm punpcklwd  xmm0, xmm2 /* BGRA first 4 pixels */                      \
+    __asm punpckhwd  xmm1, xmm2 /* BGRA next 4 pixels */                       \
+    __asm movdqu     0[edx], xmm0                                              \
+    __asm movdqu     16[edx], xmm1                                             \
+    __asm lea        edx,  [edx + 32]}
+
+// Store 8 BGRA values.
+#define STOREBGRA \
+  __asm {                                                                      \
+    __asm pcmpeqb    xmm5, xmm5 /* generate 0xffffffff for alpha */            \
+    __asm punpcklbw  xmm1, xmm0 /* GB */                                       \
+    __asm punpcklbw  xmm5, xmm2 /* AR */                                       \
+    __asm movdqa     xmm0, xmm5                                                \
+    __asm punpcklwd  xmm5, xmm1 /* BGRA first 4 pixels */                      \
+    __asm punpckhwd  xmm0, xmm1 /* BGRA next 4 pixels */                       \
+    __asm movdqu     0[edx], xmm5                                              \
+    __asm movdqu     16[edx], xmm0                                             \
+    __asm lea        edx,  [edx + 32]}
+
+// Store 8 RGBA values.
+#define STORERGBA \
+  __asm {                                                                      \
+    __asm pcmpeqb    xmm5, xmm5 /* generate 0xffffffff for alpha */            \
+    __asm punpcklbw  xmm1, xmm2 /* GR */                                       \
+    __asm punpcklbw  xmm5, xmm0 /* AB */                                       \
+    __asm movdqa     xmm0, xmm5                                                \
+    __asm punpcklwd  xmm5, xmm1 /* RGBA first 4 pixels */                      \
+    __asm punpckhwd  xmm0, xmm1 /* RGBA next 4 pixels */                       \
+    __asm movdqu     0[edx], xmm5                                              \
+    __asm movdqu     16[edx], xmm0                                             \
+    __asm lea        edx,  [edx + 32]}
+
+// Store 8 RGB24 values.
+#define STORERGB24 \
+  __asm {/* Weave into RRGB */                                                 \
+    __asm punpcklbw  xmm0, xmm1 /* BG */                                       \
+    __asm punpcklbw  xmm2, xmm2 /* RR */                                       \
+    __asm movdqa     xmm1, xmm0                                                \
+    __asm punpcklwd  xmm0, xmm2 /* BGRR first 4 pixels */                      \
+    __asm punpckhwd  xmm1, xmm2 /* BGRR next 4 pixels */ /* RRGB -> RGB24 */   \
+    __asm pshufb     xmm0, xmm5 /* Pack first 8 and last 4 bytes. */           \
+    __asm pshufb     xmm1, xmm6 /* Pack first 12 bytes. */                     \
+    __asm palignr    xmm1, xmm0, 12 /* last 4 bytes of xmm0 + 12 xmm1 */       \
+    __asm movq       qword ptr 0[edx], xmm0 /* First 8 bytes */                \
+    __asm movdqu     8[edx], xmm1 /* Last 16 bytes */                          \
+    __asm lea        edx,  [edx + 24]}
+
+// Store 8 RGB565 values.
+#define STORERGB565 \
+  __asm {/* Weave into RRGB */                                                 \
+    __asm punpcklbw  xmm0, xmm1 /* BG */                                       \
+    __asm punpcklbw  xmm2, xmm2 /* RR */                                       \
+    __asm movdqa     xmm1, xmm0                                                \
+    __asm punpcklwd  xmm0, xmm2 /* BGRR first 4 pixels */                      \
+    __asm punpckhwd  xmm1, xmm2 /* BGRR next 4 pixels */ /* RRGB -> RGB565 */  \
+    __asm movdqa     xmm3, xmm0 /* B  first 4 pixels of argb */                \
+    __asm movdqa     xmm2, xmm0 /* G */                                        \
+    __asm pslld      xmm0, 8 /* R */                                           \
+    __asm psrld      xmm3, 3 /* B */                                           \
+    __asm psrld      xmm2, 5 /* G */                                           \
+    __asm psrad      xmm0, 16 /* R */                                          \
+    __asm pand       xmm3, xmm5 /* B */                                        \
+    __asm pand       xmm2, xmm6 /* G */                                        \
+    __asm pand       xmm0, xmm7 /* R */                                        \
+    __asm por        xmm3, xmm2 /* BG */                                       \
+    __asm por        xmm0, xmm3 /* BGR */                                      \
+    __asm movdqa     xmm3, xmm1 /* B  next 4 pixels of argb */                 \
+    __asm movdqa     xmm2, xmm1 /* G */                                        \
+    __asm pslld      xmm1, 8 /* R */                                           \
+    __asm psrld      xmm3, 3 /* B */                                           \
+    __asm psrld      xmm2, 5 /* G */                                           \
+    __asm psrad      xmm1, 16 /* R */                                          \
+    __asm pand       xmm3, xmm5 /* B */                                        \
+    __asm pand       xmm2, xmm6 /* G */                                        \
+    __asm pand       xmm1, xmm7 /* R */                                        \
+    __asm por        xmm3, xmm2 /* BG */                                       \
+    __asm por        xmm1, xmm3 /* BGR */                                      \
+    __asm packssdw   xmm0, xmm1                                                \
+    __asm movdqu     0[edx], xmm0 /* store 8 pixels of RGB565 */               \
+    __asm lea        edx, [edx + 16]}
+
+// 8 pixels.
+// 8 UV values, mixed with 8 Y producing 8 ARGB (32 bytes).
+__declspec(naked) void I444ToARGBRow_SSSE3(
+    const uint8_t* y_buf,
+    const uint8_t* u_buf,
+    const uint8_t* v_buf,
+    uint8_t* dst_argb,
+    const struct YuvConstants* yuvconstants,
+    int width) {
+  __asm {
+    push       esi
+    push       edi
+    push       ebx
+    mov        eax, [esp + 12 + 4]  // Y
+    mov        esi, [esp + 12 + 8]  // U
+    mov        edi, [esp + 12 + 12]  // V
+    mov        edx, [esp + 12 + 16]  // argb
+    mov        ebx, [esp + 12 + 20]  // yuvconstants
+    mov        ecx, [esp + 12 + 24]  // width
+    sub        edi, esi
+    pcmpeqb    xmm5, xmm5  // generate 0xffffffff for alpha
+
+ convertloop:
+    READYUV444
+    YUVTORGB(ebx)
+    STOREARGB
+
+    sub        ecx, 8
+    jg         convertloop
+
+    pop        ebx
+    pop        edi
+    pop        esi
+    ret
+  }
+}
+
+// 8 pixels.
+// 8 UV values, mixed with 8 Y and 8A producing 8 ARGB (32 bytes).
+__declspec(naked) void I444AlphaToARGBRow_SSSE3(
+    const uint8_t* y_buf,
+    const uint8_t* u_buf,
+    const uint8_t* v_buf,
+    const uint8_t* a_buf,
+    uint8_t* dst_argb,
+    const struct YuvConstants* yuvconstants,
+    int width) {
+  __asm {
+    push       esi
+    push       edi
+    push       ebx
+    push       ebp
+    mov        eax, [esp + 16 + 4]  // Y
+    mov        esi, [esp + 16 + 8]  // U
+    mov        edi, [esp + 16 + 12]  // V
+    mov        ebp, [esp + 16 + 16]  // A
+    mov        edx, [esp + 16 + 20]  // argb
+    mov        ebx, [esp + 16 + 24]  // yuvconstants
+    mov        ecx, [esp + 16 + 28]  // width
+    sub        edi, esi
+
+ convertloop:
+    READYUVA444
+    YUVTORGB(ebx)
+    STOREARGB
+
+    sub        ecx, 8
+    jg         convertloop
+
+    pop        ebp
+    pop        ebx
+    pop        edi
+    pop        esi
+    ret
+  }
+}
+
+// 8 pixels.
+// 4 UV values upsampled to 8 UV, mixed with 8 Y producing 8 RGB24 (24 bytes).
+__declspec(naked) void I422ToRGB24Row_SSSE3(
+    const uint8_t* y_buf,
+    const uint8_t* u_buf,
+    const uint8_t* v_buf,
+    uint8_t* dst_rgb24,
+    const struct YuvConstants* yuvconstants,
+    int width) {
+  __asm {
+    push       esi
+    push       edi
+    push       ebx
+    mov        eax, [esp + 12 + 4]  // Y
+    mov        esi, [esp + 12 + 8]  // U
+    mov        edi, [esp + 12 + 12]  // V
+    mov        edx, [esp + 12 + 16]  // argb
+    mov        ebx, [esp + 12 + 20]  // yuvconstants
+    mov        ecx, [esp + 12 + 24]  // width
+    sub        edi, esi
+    movdqa     xmm5, xmmword ptr kShuffleMaskARGBToRGB24_0
+    movdqa     xmm6, xmmword ptr kShuffleMaskARGBToRGB24
+
+ convertloop:
+    READYUV422
+    YUVTORGB(ebx)
+    STORERGB24
+
+    sub        ecx, 8
+    jg         convertloop
+
+    pop        ebx
+    pop        edi
+    pop        esi
+    ret
+  }
+}
+
+// 8 pixels
+// 4 UV values upsampled to 8 UV, mixed with 8 Y producing 8 RGB565 (16 bytes).
+__declspec(naked) void I422ToRGB565Row_SSSE3(
+    const uint8_t* y_buf,
+    const uint8_t* u_buf,
+    const uint8_t* v_buf,
+    uint8_t* rgb565_buf,
+    const struct YuvConstants* yuvconstants,
+    int width) {
+  __asm {
+    push       esi
+    push       edi
+    push       ebx
+    mov        eax, [esp + 12 + 4]  // Y
+    mov        esi, [esp + 12 + 8]  // U
+    mov        edi, [esp + 12 + 12]  // V
+    mov        edx, [esp + 12 + 16]  // argb
+    mov        ebx, [esp + 12 + 20]  // yuvconstants
+    mov        ecx, [esp + 12 + 24]  // width
+    sub        edi, esi
+    pcmpeqb    xmm5, xmm5  // generate mask 0x0000001f
+    psrld      xmm5, 27
+    pcmpeqb    xmm6, xmm6  // generate mask 0x000007e0
+    psrld      xmm6, 26
+    pslld      xmm6, 5
+    pcmpeqb    xmm7, xmm7  // generate mask 0xfffff800
+    pslld      xmm7, 11
+
+ convertloop:
+    READYUV422
+    YUVTORGB(ebx)
+    STORERGB565
+
+    sub        ecx, 8
+    jg         convertloop
+
+    pop        ebx
+    pop        edi
+    pop        esi
+    ret
+  }
+}
+
+// 8 pixels.
+// 4 UV values upsampled to 8 UV, mixed with 8 Y producing 8 ARGB (32 bytes).
+__declspec(naked) void I422ToARGBRow_SSSE3(
+    const uint8_t* y_buf,
+    const uint8_t* u_buf,
+    const uint8_t* v_buf,
+    uint8_t* dst_argb,
+    const struct YuvConstants* yuvconstants,
+    int width) {
+  __asm {
+    push       esi
+    push       edi
+    push       ebx
+    mov        eax, [esp + 12 + 4]  // Y
+    mov        esi, [esp + 12 + 8]  // U
+    mov        edi, [esp + 12 + 12]  // V
+    mov        edx, [esp + 12 + 16]  // argb
+    mov        ebx, [esp + 12 + 20]  // yuvconstants
+    mov        ecx, [esp + 12 + 24]  // width
+    sub        edi, esi
+    pcmpeqb    xmm5, xmm5  // generate 0xffffffff for alpha
+
+ convertloop:
+    READYUV422
+    YUVTORGB(ebx)
+    STOREARGB
+
+    sub        ecx, 8
+    jg         convertloop
+
+    pop        ebx
+    pop        edi
+    pop        esi
+    ret
+  }
+}
+
+// 8 pixels.
+// 4 UV values upsampled to 8 UV, mixed with 8 Y and 8 A producing 8 ARGB.
+__declspec(naked) void I422AlphaToARGBRow_SSSE3(
+    const uint8_t* y_buf,
+    const uint8_t* u_buf,
+    const uint8_t* v_buf,
+    const uint8_t* a_buf,
+    uint8_t* dst_argb,
+    const struct YuvConstants* yuvconstants,
+    int width) {
+  __asm {
+    push       esi
+    push       edi
+    push       ebx
+    push       ebp
+    mov        eax, [esp + 16 + 4]  // Y
+    mov        esi, [esp + 16 + 8]  // U
+    mov        edi, [esp + 16 + 12]  // V
+    mov        ebp, [esp + 16 + 16]  // A
+    mov        edx, [esp + 16 + 20]  // argb
+    mov        ebx, [esp + 16 + 24]  // yuvconstants
+    mov        ecx, [esp + 16 + 28]  // width
+    sub        edi, esi
+
+ convertloop:
+    READYUVA422
+    YUVTORGB(ebx)
+    STOREARGB
+
+    sub        ecx, 8
+    jg         convertloop
+
+    pop        ebp
+    pop        ebx
+    pop        edi
+    pop        esi
+    ret
+  }
+}
+
+// 8 pixels.
+// 4 UV values upsampled to 8 UV, mixed with 8 Y producing 8 ARGB (32 bytes).
+__declspec(naked) void NV12ToARGBRow_SSSE3(
+    const uint8_t* y_buf,
+    const uint8_t* uv_buf,
+    uint8_t* dst_argb,
+    const struct YuvConstants* yuvconstants,
+    int width) {
+  __asm {
+    push       esi
+    push       ebx
+    mov        eax, [esp + 8 + 4]  // Y
+    mov        esi, [esp + 8 + 8]  // UV
+    mov        edx, [esp + 8 + 12]  // argb
+    mov        ebx, [esp + 8 + 16]  // yuvconstants
+    mov        ecx, [esp + 8 + 20]  // width
+    pcmpeqb    xmm5, xmm5  // generate 0xffffffff for alpha
+
+ convertloop:
+    READNV12
+    YUVTORGB(ebx)
+    STOREARGB
+
+    sub        ecx, 8
+    jg         convertloop
+
+    pop        ebx
+    pop        esi
+    ret
+  }
+}
+
+// 8 pixels.
+// 4 UV values upsampled to 8 UV, mixed with 8 Y producing 8 ARGB (32 bytes).
+__declspec(naked) void NV21ToARGBRow_SSSE3(
+    const uint8_t* y_buf,
+    const uint8_t* vu_buf,
+    uint8_t* dst_argb,
+    const struct YuvConstants* yuvconstants,
+    int width) {
+  __asm {
+    push       esi
+    push       ebx
+    mov        eax, [esp + 8 + 4]  // Y
+    mov        esi, [esp + 8 + 8]  // VU
+    mov        edx, [esp + 8 + 12]  // argb
+    mov        ebx, [esp + 8 + 16]  // yuvconstants
+    mov        ecx, [esp + 8 + 20]  // width
+    pcmpeqb    xmm5, xmm5  // generate 0xffffffff for alpha
+
+ convertloop:
+    READNV21
+    YUVTORGB(ebx)
+    STOREARGB
+
+    sub        ecx, 8
+    jg         convertloop
+
+    pop        ebx
+    pop        esi
+    ret
+  }
+}
+
+// 8 pixels.
+// 4 YUY2 values with 8 Y and 4 UV producing 8 ARGB (32 bytes).
+__declspec(naked) void YUY2ToARGBRow_SSSE3(
+    const uint8_t* src_yuy2,
+    uint8_t* dst_argb,
+    const struct YuvConstants* yuvconstants,
+    int width) {
+  __asm {
+    push       ebx
+    mov        eax, [esp + 4 + 4]  // yuy2
+    mov        edx, [esp + 4 + 8]  // argb
+    mov        ebx, [esp + 4 + 12]  // yuvconstants
+    mov        ecx, [esp + 4 + 16]  // width
+    pcmpeqb    xmm5, xmm5  // generate 0xffffffff for alpha
+
+ convertloop:
+    READYUY2
+    YUVTORGB(ebx)
+    STOREARGB
+
+    sub        ecx, 8
+    jg         convertloop
+
+    pop        ebx
+    ret
+  }
+}
+
+// 8 pixels.
+// 4 UYVY values with 8 Y and 4 UV producing 8 ARGB (32 bytes).
+__declspec(naked) void UYVYToARGBRow_SSSE3(
+    const uint8_t* src_uyvy,
+    uint8_t* dst_argb,
+    const struct YuvConstants* yuvconstants,
+    int width) {
+  __asm {
+    push       ebx
+    mov        eax, [esp + 4 + 4]  // uyvy
+    mov        edx, [esp + 4 + 8]  // argb
+    mov        ebx, [esp + 4 + 12]  // yuvconstants
+    mov        ecx, [esp + 4 + 16]  // width
+    pcmpeqb    xmm5, xmm5  // generate 0xffffffff for alpha
+
+ convertloop:
+    READUYVY
+    YUVTORGB(ebx)
+    STOREARGB
+
+    sub        ecx, 8
+    jg         convertloop
+
+    pop        ebx
+    ret
+  }
+}
+
+__declspec(naked) void I422ToRGBARow_SSSE3(
+    const uint8_t* y_buf,
+    const uint8_t* u_buf,
+    const uint8_t* v_buf,
+    uint8_t* dst_rgba,
+    const struct YuvConstants* yuvconstants,
+    int width) {
+  __asm {
+    push       esi
+    push       edi
+    push       ebx
+    mov        eax, [esp + 12 + 4]  // Y
+    mov        esi, [esp + 12 + 8]  // U
+    mov        edi, [esp + 12 + 12]  // V
+    mov        edx, [esp + 12 + 16]  // argb
+    mov        ebx, [esp + 12 + 20]  // yuvconstants
+    mov        ecx, [esp + 12 + 24]  // width
+    sub        edi, esi
+
+ convertloop:
+    READYUV422
+    YUVTORGB(ebx)
+    STORERGBA
+
+    sub        ecx, 8
+    jg         convertloop
+
+    pop        ebx
+    pop        edi
+    pop        esi
+    ret
+  }
+}
+#endif  // HAS_I422TOARGBROW_SSSE3
+
+// I400ToARGBRow_SSE2 is disabled due to new yuvconstant parameter
+#ifdef HAS_I400TOARGBROW_SSE2
+// 8 pixels of Y converted to 8 pixels of ARGB (32 bytes).
+__declspec(naked) void I400ToARGBRow_SSE2(const uint8_t* y_buf,
+                                          uint8_t* rgb_buf,
+                                          const struct YuvConstants*,
+                                          int width) {
+  __asm {
+    mov        eax, 0x4a354a35  // 4a35 = 18997 = round(1.164 * 64 * 256)
+    movd       xmm2, eax
+    pshufd     xmm2, xmm2,0
+    mov        eax, 0x04880488  // 0488 = 1160 = round(1.164 * 64 * 16)
+    movd       xmm3, eax
+    pshufd     xmm3, xmm3, 0
+    pcmpeqb    xmm4, xmm4  // generate mask 0xff000000
+    pslld      xmm4, 24
+
+    mov        eax, [esp + 4]  // Y
+    mov        edx, [esp + 8]  // rgb
+    mov        ecx, [esp + 12]  // width
+
+ convertloop:
+        // Step 1: Scale Y contribution to 8 G values. G = (y - 16) * 1.164
+    movq       xmm0, qword ptr [eax]
+    lea        eax, [eax + 8]
+    punpcklbw  xmm0, xmm0  // Y.Y
+    pmulhuw    xmm0, xmm2
+    psubusw    xmm0, xmm3
+    psrlw      xmm0, 6
+    packuswb   xmm0, xmm0        // G
+
+        // Step 2: Weave into ARGB
+    punpcklbw  xmm0, xmm0  // GG
+    movdqa     xmm1, xmm0
+    punpcklwd  xmm0, xmm0  // BGRA first 4 pixels
+    punpckhwd  xmm1, xmm1  // BGRA next 4 pixels
+    por        xmm0, xmm4
+    por        xmm1, xmm4
+    movdqu     [edx], xmm0
+    movdqu     [edx + 16], xmm1
+    lea        edx,  [edx + 32]
+    sub        ecx, 8
+    jg         convertloop
+    ret
+  }
+}
+#endif  // HAS_I400TOARGBROW_SSE2
+
+#ifdef HAS_I400TOARGBROW_AVX2
+// 16 pixels of Y converted to 16 pixels of ARGB (64 bytes).
+// note: vpunpcklbw mutates and vpackuswb unmutates.
+__declspec(naked) void I400ToARGBRow_AVX2(const uint8_t* y_buf,
+                                          uint8_t* rgb_buf,
+                                          const struct YuvConstants*,
+                                          int width) {
+  __asm {
+    mov        eax, 0x4a354a35  // 4a35 = 18997 = round(1.164 * 64 * 256)
+    vmovd      xmm2, eax
+    vbroadcastss ymm2, xmm2
+    mov        eax, 0x04880488  // 0488 = 1160 = round(1.164 * 64 * 16)
+    vmovd      xmm3, eax
+    vbroadcastss ymm3, xmm3
+    vpcmpeqb   ymm4, ymm4, ymm4  // generate mask 0xff000000
+    vpslld     ymm4, ymm4, 24
+
+    mov        eax, [esp + 4]  // Y
+    mov        edx, [esp + 8]  // rgb
+    mov        ecx, [esp + 12]  // width
+
+ convertloop:
+        // Step 1: Scale Y contriportbution to 16 G values. G = (y - 16) * 1.164
+    vmovdqu    xmm0, [eax]
+    lea        eax, [eax + 16]
+    vpermq     ymm0, ymm0, 0xd8  // vpunpcklbw mutates
+    vpunpcklbw ymm0, ymm0, ymm0  // Y.Y
+    vpmulhuw   ymm0, ymm0, ymm2
+    vpsubusw   ymm0, ymm0, ymm3
+    vpsrlw     ymm0, ymm0, 6
+    vpackuswb  ymm0, ymm0, ymm0        // G.  still mutated: 3120
+
+        // TODO(fbarchard): Weave alpha with unpack.
+        // Step 2: Weave into ARGB
+    vpunpcklbw ymm1, ymm0, ymm0  // GG - mutates
+    vpermq     ymm1, ymm1, 0xd8
+    vpunpcklwd ymm0, ymm1, ymm1  // GGGG first 8 pixels
+    vpunpckhwd ymm1, ymm1, ymm1  // GGGG next 8 pixels
+    vpor       ymm0, ymm0, ymm4
+    vpor       ymm1, ymm1, ymm4
+    vmovdqu    [edx], ymm0
+    vmovdqu    [edx + 32], ymm1
+    lea        edx,  [edx + 64]
+    sub        ecx, 16
+    jg         convertloop
+    vzeroupper
+    ret
+  }
+}
+#endif  // HAS_I400TOARGBROW_AVX2
+
+#ifdef HAS_MIRRORROW_SSSE3
+// Shuffle table for reversing the bytes.
+static const uvec8 kShuffleMirror = {15u, 14u, 13u, 12u, 11u, 10u, 9u, 8u,
+                                     7u,  6u,  5u,  4u,  3u,  2u,  1u, 0u};
+
+// TODO(fbarchard): Replace lea with -16 offset.
+__declspec(naked) void MirrorRow_SSSE3(const uint8_t* src,
+                                       uint8_t* dst,
+                                       int width) {
+  __asm {
+    mov       eax, [esp + 4]  // src
+    mov       edx, [esp + 8]  // dst
+    mov       ecx, [esp + 12]  // width
+    movdqa    xmm5, xmmword ptr kShuffleMirror
+
+ convertloop:
+    movdqu    xmm0, [eax - 16 + ecx]
+    pshufb    xmm0, xmm5
+    movdqu    [edx], xmm0
+    lea       edx, [edx + 16]
+    sub       ecx, 16
+    jg        convertloop
+    ret
+  }
+}
+#endif  // HAS_MIRRORROW_SSSE3
+
+#ifdef HAS_MIRRORROW_AVX2
+__declspec(naked) void MirrorRow_AVX2(const uint8_t* src,
+                                      uint8_t* dst,
+                                      int width) {
+  __asm {
+    mov       eax, [esp + 4]  // src
+    mov       edx, [esp + 8]  // dst
+    mov       ecx, [esp + 12]  // width
+    vbroadcastf128 ymm5, xmmword ptr kShuffleMirror
+
+ convertloop:
+    vmovdqu   ymm0, [eax - 32 + ecx]
+    vpshufb   ymm0, ymm0, ymm5
+    vpermq    ymm0, ymm0, 0x4e  // swap high and low halfs
+    vmovdqu   [edx], ymm0
+    lea       edx, [edx + 32]
+    sub       ecx, 32
+    jg        convertloop
+    vzeroupper
+    ret
+  }
+}
+#endif  // HAS_MIRRORROW_AVX2
+
+#ifdef HAS_MIRRORSPLITUVROW_SSSE3
+// Shuffle table for reversing the bytes of UV channels.
+static const uvec8 kShuffleMirrorUV = {14u, 12u, 10u, 8u, 6u, 4u, 2u, 0u,
+                                       15u, 13u, 11u, 9u, 7u, 5u, 3u, 1u};
+
+__declspec(naked) void MirrorSplitUVRow_SSSE3(const uint8_t* src,
+                                              uint8_t* dst_u,
+                                              uint8_t* dst_v,
+                                              int width) {
+  __asm {
+    push      edi
+    mov       eax, [esp + 4 + 4]  // src
+    mov       edx, [esp + 4 + 8]  // dst_u
+    mov       edi, [esp + 4 + 12]  // dst_v
+    mov       ecx, [esp + 4 + 16]  // width
+    movdqa    xmm1, xmmword ptr kShuffleMirrorUV
+    lea       eax, [eax + ecx * 2 - 16]
+    sub       edi, edx
+
+ convertloop:
+    movdqu    xmm0, [eax]
+    lea       eax, [eax - 16]
+    pshufb    xmm0, xmm1
+    movlpd    qword ptr [edx], xmm0
+    movhpd    qword ptr [edx + edi], xmm0
+    lea       edx, [edx + 8]
+    sub       ecx, 8
+    jg        convertloop
+
+    pop       edi
+    ret
+  }
+}
+#endif  // HAS_MIRRORSPLITUVROW_SSSE3
+
+#ifdef HAS_ARGBMIRRORROW_SSE2
+__declspec(naked) void ARGBMirrorRow_SSE2(const uint8_t* src,
+                                          uint8_t* dst,
+                                          int width) {
+  __asm {
+    mov       eax, [esp + 4]  // src
+    mov       edx, [esp + 8]  // dst
+    mov       ecx, [esp + 12]  // width
+    lea       eax, [eax - 16 + ecx * 4]  // last 4 pixels.
+
+ convertloop:
+    movdqu    xmm0, [eax]
+    lea       eax, [eax - 16]
+    pshufd    xmm0, xmm0, 0x1b
+    movdqu    [edx], xmm0
+    lea       edx, [edx + 16]
+    sub       ecx, 4
+    jg        convertloop
+    ret
+  }
+}
+#endif  // HAS_ARGBMIRRORROW_SSE2
+
+#ifdef HAS_ARGBMIRRORROW_AVX2
+// Shuffle table for reversing the bytes.
+static const ulvec32 kARGBShuffleMirror_AVX2 = {7u, 6u, 5u, 4u, 3u, 2u, 1u, 0u};
+
+__declspec(naked) void ARGBMirrorRow_AVX2(const uint8_t* src,
+                                          uint8_t* dst,
+                                          int width) {
+  __asm {
+    mov       eax, [esp + 4]  // src
+    mov       edx, [esp + 8]  // dst
+    mov       ecx, [esp + 12]  // width
+    vmovdqu   ymm5, ymmword ptr kARGBShuffleMirror_AVX2
+
+ convertloop:
+    vpermd    ymm0, ymm5, [eax - 32 + ecx * 4]  // permute dword order
+    vmovdqu   [edx], ymm0
+    lea       edx, [edx + 32]
+    sub       ecx, 8
+    jg        convertloop
+    vzeroupper
+    ret
+  }
+}
+#endif  // HAS_ARGBMIRRORROW_AVX2
+
+#ifdef HAS_SPLITUVROW_SSE2
+__declspec(naked) void SplitUVRow_SSE2(const uint8_t* src_uv,
+                                       uint8_t* dst_u,
+                                       uint8_t* dst_v,
+                                       int width) {
+  __asm {
+    push       edi
+    mov        eax, [esp + 4 + 4]  // src_uv
+    mov        edx, [esp + 4 + 8]  // dst_u
+    mov        edi, [esp + 4 + 12]  // dst_v
+    mov        ecx, [esp + 4 + 16]  // width
+    pcmpeqb    xmm5, xmm5  // generate mask 0x00ff00ff
+    psrlw      xmm5, 8
+    sub        edi, edx
+
+  convertloop:
+    movdqu     xmm0, [eax]
+    movdqu     xmm1, [eax + 16]
+    lea        eax,  [eax + 32]
+    movdqa     xmm2, xmm0
+    movdqa     xmm3, xmm1
+    pand       xmm0, xmm5  // even bytes
+    pand       xmm1, xmm5
+    packuswb   xmm0, xmm1
+    psrlw      xmm2, 8  // odd bytes
+    psrlw      xmm3, 8
+    packuswb   xmm2, xmm3
+    movdqu     [edx], xmm0
+    movdqu     [edx + edi], xmm2
+    lea        edx, [edx + 16]
+    sub        ecx, 16
+    jg         convertloop
+
+    pop        edi
+    ret
+  }
+}
+
+#endif  // HAS_SPLITUVROW_SSE2
+
+#ifdef HAS_SPLITUVROW_AVX2
+__declspec(naked) void SplitUVRow_AVX2(const uint8_t* src_uv,
+                                       uint8_t* dst_u,
+                                       uint8_t* dst_v,
+                                       int width) {
+  __asm {
+    push       edi
+    mov        eax, [esp + 4 + 4]  // src_uv
+    mov        edx, [esp + 4 + 8]  // dst_u
+    mov        edi, [esp + 4 + 12]  // dst_v
+    mov        ecx, [esp + 4 + 16]  // width
+    vpcmpeqb   ymm5, ymm5, ymm5  // generate mask 0x00ff00ff
+    vpsrlw     ymm5, ymm5, 8
+    sub        edi, edx
+
+  convertloop:
+    vmovdqu    ymm0, [eax]
+    vmovdqu    ymm1, [eax + 32]
+    lea        eax,  [eax + 64]
+    vpsrlw     ymm2, ymm0, 8  // odd bytes
+    vpsrlw     ymm3, ymm1, 8
+    vpand      ymm0, ymm0, ymm5  // even bytes
+    vpand      ymm1, ymm1, ymm5
+    vpackuswb  ymm0, ymm0, ymm1
+    vpackuswb  ymm2, ymm2, ymm3
+    vpermq     ymm0, ymm0, 0xd8
+    vpermq     ymm2, ymm2, 0xd8
+    vmovdqu    [edx], ymm0
+    vmovdqu    [edx + edi], ymm2
+    lea        edx, [edx + 32]
+    sub        ecx, 32
+    jg         convertloop
+
+    pop        edi
+    vzeroupper
+    ret
+  }
+}
+#endif  // HAS_SPLITUVROW_AVX2
+
+#ifdef HAS_MERGEUVROW_SSE2
+__declspec(naked) void MergeUVRow_SSE2(const uint8_t* src_u,
+                                       const uint8_t* src_v,
+                                       uint8_t* dst_uv,
+                                       int width) {
+  __asm {
+    push       edi
+    mov        eax, [esp + 4 + 4]  // src_u
+    mov        edx, [esp + 4 + 8]  // src_v
+    mov        edi, [esp + 4 + 12]  // dst_uv
+    mov        ecx, [esp + 4 + 16]  // width
+    sub        edx, eax
+
+  convertloop:
+    movdqu     xmm0, [eax]  // read 16 U's
+    movdqu     xmm1, [eax + edx]  // and 16 V's
+    lea        eax,  [eax + 16]
+    movdqa     xmm2, xmm0
+    punpcklbw  xmm0, xmm1  // first 8 UV pairs
+    punpckhbw  xmm2, xmm1  // next 8 UV pairs
+    movdqu     [edi], xmm0
+    movdqu     [edi + 16], xmm2
+    lea        edi, [edi + 32]
+    sub        ecx, 16
+    jg         convertloop
+
+    pop        edi
+    ret
+  }
+}
+#endif  //  HAS_MERGEUVROW_SSE2
+
+#ifdef HAS_MERGEUVROW_AVX2
+__declspec(naked) void MergeUVRow_AVX2(const uint8_t* src_u,
+                                       const uint8_t* src_v,
+                                       uint8_t* dst_uv,
+                                       int width) {
+  __asm {
+    push       edi
+    mov        eax, [esp + 4 + 4]  // src_u
+    mov        edx, [esp + 4 + 8]  // src_v
+    mov        edi, [esp + 4 + 12]  // dst_uv
+    mov        ecx, [esp + 4 + 16]  // width
+    sub        edx, eax
+
+  convertloop:
+    vmovdqu    ymm0, [eax]  // read 32 U's
+    vmovdqu    ymm1, [eax + edx]  // and 32 V's
+    lea        eax,  [eax + 32]
+    vpunpcklbw ymm2, ymm0, ymm1  // low 16 UV pairs. mutated qqword 0,2
+    vpunpckhbw ymm0, ymm0, ymm1  // high 16 UV pairs. mutated qqword 1,3
+    vextractf128 [edi], ymm2, 0  // bytes 0..15
+    vextractf128 [edi + 16], ymm0, 0  // bytes 16..31
+    vextractf128 [edi + 32], ymm2, 1  // bytes 32..47
+    vextractf128 [edi + 48], ymm0, 1  // bytes 47..63
+    lea        edi, [edi + 64]
+    sub        ecx, 32
+    jg         convertloop
+
+    pop        edi
+    vzeroupper
+    ret
+  }
+}
+#endif  //  HAS_MERGEUVROW_AVX2
+
+#ifdef HAS_COPYROW_SSE2
+// CopyRow copys 'width' bytes using a 16 byte load/store, 32 bytes at time.
+__declspec(naked) void CopyRow_SSE2(const uint8_t* src,
+                                    uint8_t* dst,
+                                    int width) {
+  __asm {
+    mov        eax, [esp + 4]  // src
+    mov        edx, [esp + 8]  // dst
+    mov        ecx, [esp + 12]  // width
+    test       eax, 15
+    jne        convertloopu
+    test       edx, 15
+    jne        convertloopu
+
+  convertloopa:
+    movdqa     xmm0, [eax]
+    movdqa     xmm1, [eax + 16]
+    lea        eax, [eax + 32]
+    movdqa     [edx], xmm0
+    movdqa     [edx + 16], xmm1
+    lea        edx, [edx + 32]
+    sub        ecx, 32
+    jg         convertloopa
+    ret
+
+  convertloopu:
+    movdqu     xmm0, [eax]
+    movdqu     xmm1, [eax + 16]
+    lea        eax, [eax + 32]
+    movdqu     [edx], xmm0
+    movdqu     [edx + 16], xmm1
+    lea        edx, [edx + 32]
+    sub        ecx, 32
+    jg         convertloopu
+    ret
+  }
+}
+#endif  // HAS_COPYROW_SSE2
+
+#ifdef HAS_COPYROW_AVX
+// CopyRow copys 'width' bytes using a 32 byte load/store, 64 bytes at time.
+__declspec(naked) void CopyRow_AVX(const uint8_t* src,
+                                   uint8_t* dst,
+                                   int width) {
+  __asm {
+    mov        eax, [esp + 4]  // src
+    mov        edx, [esp + 8]  // dst
+    mov        ecx, [esp + 12]  // width
+
+  convertloop:
+    vmovdqu    ymm0, [eax]
+    vmovdqu    ymm1, [eax + 32]
+    lea        eax, [eax + 64]
+    vmovdqu    [edx], ymm0
+    vmovdqu    [edx + 32], ymm1
+    lea        edx, [edx + 64]
+    sub        ecx, 64
+    jg         convertloop
+
+    vzeroupper
+    ret
+  }
+}
+#endif  // HAS_COPYROW_AVX
+
+// Multiple of 1.
+__declspec(naked) void CopyRow_ERMS(const uint8_t* src,
+                                    uint8_t* dst,
+                                    int width) {
+  __asm {
+    mov        eax, esi
+    mov        edx, edi
+    mov        esi, [esp + 4]  // src
+    mov        edi, [esp + 8]  // dst
+    mov        ecx, [esp + 12]  // width
+    rep movsb
+    mov        edi, edx
+    mov        esi, eax
+    ret
+  }
+}
+
+#ifdef HAS_ARGBCOPYALPHAROW_SSE2
+// width in pixels
+__declspec(naked) void ARGBCopyAlphaRow_SSE2(const uint8_t* src,
+                                             uint8_t* dst,
+                                             int width) {
+  __asm {
+    mov        eax, [esp + 4]  // src
+    mov        edx, [esp + 8]  // dst
+    mov        ecx, [esp + 12]  // width
+    pcmpeqb    xmm0, xmm0  // generate mask 0xff000000
+    pslld      xmm0, 24
+    pcmpeqb    xmm1, xmm1  // generate mask 0x00ffffff
+    psrld      xmm1, 8
+
+  convertloop:
+    movdqu     xmm2, [eax]
+    movdqu     xmm3, [eax + 16]
+    lea        eax, [eax + 32]
+    movdqu     xmm4, [edx]
+    movdqu     xmm5, [edx + 16]
+    pand       xmm2, xmm0
+    pand       xmm3, xmm0
+    pand       xmm4, xmm1
+    pand       xmm5, xmm1
+    por        xmm2, xmm4
+    por        xmm3, xmm5
+    movdqu     [edx], xmm2
+    movdqu     [edx + 16], xmm3
+    lea        edx, [edx + 32]
+    sub        ecx, 8
+    jg         convertloop
+
+    ret
+  }
+}
+#endif  // HAS_ARGBCOPYALPHAROW_SSE2
+
+#ifdef HAS_ARGBCOPYALPHAROW_AVX2
+// width in pixels
+__declspec(naked) void ARGBCopyAlphaRow_AVX2(const uint8_t* src,
+                                             uint8_t* dst,
+                                             int width) {
+  __asm {
+    mov        eax, [esp + 4]  // src
+    mov        edx, [esp + 8]  // dst
+    mov        ecx, [esp + 12]  // width
+    vpcmpeqb   ymm0, ymm0, ymm0
+    vpsrld     ymm0, ymm0, 8  // generate mask 0x00ffffff
+
+  convertloop:
+    vmovdqu    ymm1, [eax]
+    vmovdqu    ymm2, [eax + 32]
+    lea        eax, [eax + 64]
+    vpblendvb  ymm1, ymm1, [edx], ymm0
+    vpblendvb  ymm2, ymm2, [edx + 32], ymm0
+    vmovdqu    [edx], ymm1
+    vmovdqu    [edx + 32], ymm2
+    lea        edx, [edx + 64]
+    sub        ecx, 16
+    jg         convertloop
+
+    vzeroupper
+    ret
+  }
+}
+#endif  // HAS_ARGBCOPYALPHAROW_AVX2
+
+#ifdef HAS_ARGBEXTRACTALPHAROW_SSE2
+// width in pixels
+__declspec(naked) void ARGBExtractAlphaRow_SSE2(const uint8_t* src_argb,
+                                                uint8_t* dst_a,
+                                                int width) {
+  __asm {
+    mov        eax, [esp + 4]  // src_argb
+    mov        edx, [esp + 8]  // dst_a
+    mov        ecx, [esp + 12]  // width
+
+  extractloop:
+    movdqu     xmm0, [eax]
+    movdqu     xmm1, [eax + 16]
+    lea        eax, [eax + 32]
+    psrld      xmm0, 24
+    psrld      xmm1, 24
+    packssdw   xmm0, xmm1
+    packuswb   xmm0, xmm0
+    movq       qword ptr [edx], xmm0
+    lea        edx, [edx + 8]
+    sub        ecx, 8
+    jg         extractloop
+
+    ret
+  }
+}
+#endif  // HAS_ARGBEXTRACTALPHAROW_SSE2
+
+#ifdef HAS_ARGBEXTRACTALPHAROW_AVX2
+// width in pixels
+__declspec(naked) void ARGBExtractAlphaRow_AVX2(const uint8_t* src_argb,
+                                                uint8_t* dst_a,
+                                                int width) {
+  __asm {
+    mov        eax, [esp + 4]  // src_argb
+    mov        edx, [esp + 8]  // dst_a
+    mov        ecx, [esp + 12]  // width
+    vmovdqa    ymm4, ymmword ptr kPermdARGBToY_AVX
+
+  extractloop:
+    vmovdqu    ymm0, [eax]
+    vmovdqu    ymm1, [eax + 32]
+    vpsrld     ymm0, ymm0, 24
+    vpsrld     ymm1, ymm1, 24
+    vmovdqu    ymm2, [eax + 64]
+    vmovdqu    ymm3, [eax + 96]
+    lea        eax, [eax + 128]
+    vpackssdw  ymm0, ymm0, ymm1  // mutates
+    vpsrld     ymm2, ymm2, 24
+    vpsrld     ymm3, ymm3, 24
+    vpackssdw  ymm2, ymm2, ymm3  // mutates
+    vpackuswb  ymm0, ymm0, ymm2  // mutates
+    vpermd     ymm0, ymm4, ymm0  // unmutate
+    vmovdqu    [edx], ymm0
+    lea        edx, [edx + 32]
+    sub        ecx, 32
+    jg         extractloop
+
+    vzeroupper
+    ret
+  }
+}
+#endif  // HAS_ARGBEXTRACTALPHAROW_AVX2
+
+#ifdef HAS_ARGBCOPYYTOALPHAROW_SSE2
+// width in pixels
+__declspec(naked) void ARGBCopyYToAlphaRow_SSE2(const uint8_t* src,
+                                                uint8_t* dst,
+                                                int width) {
+  __asm {
+    mov        eax, [esp + 4]  // src
+    mov        edx, [esp + 8]  // dst
+    mov        ecx, [esp + 12]  // width
+    pcmpeqb    xmm0, xmm0  // generate mask 0xff000000
+    pslld      xmm0, 24
+    pcmpeqb    xmm1, xmm1  // generate mask 0x00ffffff
+    psrld      xmm1, 8
+
+  convertloop:
+    movq       xmm2, qword ptr [eax]  // 8 Y's
+    lea        eax, [eax + 8]
+    punpcklbw  xmm2, xmm2
+    punpckhwd  xmm3, xmm2
+    punpcklwd  xmm2, xmm2
+    movdqu     xmm4, [edx]
+    movdqu     xmm5, [edx + 16]
+    pand       xmm2, xmm0
+    pand       xmm3, xmm0
+    pand       xmm4, xmm1
+    pand       xmm5, xmm1
+    por        xmm2, xmm4
+    por        xmm3, xmm5
+    movdqu     [edx], xmm2
+    movdqu     [edx + 16], xmm3
+    lea        edx, [edx + 32]
+    sub        ecx, 8
+    jg         convertloop
+
+    ret
+  }
+}
+#endif  // HAS_ARGBCOPYYTOALPHAROW_SSE2
+
+#ifdef HAS_ARGBCOPYYTOALPHAROW_AVX2
+// width in pixels
+__declspec(naked) void ARGBCopyYToAlphaRow_AVX2(const uint8_t* src,
+                                                uint8_t* dst,
+                                                int width) {
+  __asm {
+    mov        eax, [esp + 4]  // src
+    mov        edx, [esp + 8]  // dst
+    mov        ecx, [esp + 12]  // width
+    vpcmpeqb   ymm0, ymm0, ymm0
+    vpsrld     ymm0, ymm0, 8  // generate mask 0x00ffffff
+
+  convertloop:
+    vpmovzxbd  ymm1, qword ptr [eax]
+    vpmovzxbd  ymm2, qword ptr [eax + 8]
+    lea        eax, [eax + 16]
+    vpslld     ymm1, ymm1, 24
+    vpslld     ymm2, ymm2, 24
+    vpblendvb  ymm1, ymm1, [edx], ymm0
+    vpblendvb  ymm2, ymm2, [edx + 32], ymm0
+    vmovdqu    [edx], ymm1
+    vmovdqu    [edx + 32], ymm2
+    lea        edx, [edx + 64]
+    sub        ecx, 16
+    jg         convertloop
+
+    vzeroupper
+    ret
+  }
+}
+#endif  // HAS_ARGBCOPYYTOALPHAROW_AVX2
+
+#ifdef HAS_SETROW_X86
+// Write 'width' bytes using an 8 bit value repeated.
+// width should be multiple of 4.
+__declspec(naked) void SetRow_X86(uint8_t* dst, uint8_t v8, int width) {
+  __asm {
+    movzx      eax, byte ptr [esp + 8]  // v8
+    mov        edx, 0x01010101  // Duplicate byte to all bytes.
+    mul        edx  // overwrites edx with upper part of result.
+    mov        edx, edi
+    mov        edi, [esp + 4]  // dst
+    mov        ecx, [esp + 12]  // width
+    shr        ecx, 2
+    rep stosd
+    mov        edi, edx
+    ret
+  }
+}
+
+// Write 'width' bytes using an 8 bit value repeated.
+__declspec(naked) void SetRow_ERMS(uint8_t* dst, uint8_t v8, int width) {
+  __asm {
+    mov        edx, edi
+    mov        edi, [esp + 4]  // dst
+    mov        eax, [esp + 8]  // v8
+    mov        ecx, [esp + 12]  // width
+    rep stosb
+    mov        edi, edx
+    ret
+  }
+}
+
+// Write 'width' 32 bit values.
+__declspec(naked) void ARGBSetRow_X86(uint8_t* dst_argb,
+                                      uint32_t v32,
+                                      int width) {
+  __asm {
+    mov        edx, edi
+    mov        edi, [esp + 4]  // dst
+    mov        eax, [esp + 8]  // v32
+    mov        ecx, [esp + 12]  // width
+    rep stosd
+    mov        edi, edx
+    ret
+  }
+}
+#endif  // HAS_SETROW_X86
+
+#ifdef HAS_YUY2TOYROW_AVX2
+__declspec(naked) void YUY2ToYRow_AVX2(const uint8_t* src_yuy2,
+                                       uint8_t* dst_y,
+                                       int width) {
+  __asm {
+    mov        eax, [esp + 4]  // src_yuy2
+    mov        edx, [esp + 8]  // dst_y
+    mov        ecx, [esp + 12]  // width
+    vpcmpeqb   ymm5, ymm5, ymm5  // generate mask 0x00ff00ff
+    vpsrlw     ymm5, ymm5, 8
+
+  convertloop:
+    vmovdqu    ymm0, [eax]
+    vmovdqu    ymm1, [eax + 32]
+    lea        eax,  [eax + 64]
+    vpand      ymm0, ymm0, ymm5  // even bytes are Y
+    vpand      ymm1, ymm1, ymm5
+    vpackuswb  ymm0, ymm0, ymm1  // mutates.
+    vpermq     ymm0, ymm0, 0xd8
+    vmovdqu    [edx], ymm0
+    lea        edx, [edx + 32]
+    sub        ecx, 32
+    jg         convertloop
+    vzeroupper
+    ret
+  }
+}
+
+__declspec(naked) void YUY2ToUVRow_AVX2(const uint8_t* src_yuy2,
+                                        int stride_yuy2,
+                                        uint8_t* dst_u,
+                                        uint8_t* dst_v,
+                                        int width) {
+  __asm {
+    push       esi
+    push       edi
+    mov        eax, [esp + 8 + 4]  // src_yuy2
+    mov        esi, [esp + 8 + 8]  // stride_yuy2
+    mov        edx, [esp + 8 + 12]  // dst_u
+    mov        edi, [esp + 8 + 16]  // dst_v
+    mov        ecx, [esp + 8 + 20]  // width
+    vpcmpeqb   ymm5, ymm5, ymm5  // generate mask 0x00ff00ff
+    vpsrlw     ymm5, ymm5, 8
+    sub        edi, edx
+
+  convertloop:
+    vmovdqu    ymm0, [eax]
+    vmovdqu    ymm1, [eax + 32]
+    vpavgb     ymm0, ymm0, [eax + esi]
+    vpavgb     ymm1, ymm1, [eax + esi + 32]
+    lea        eax,  [eax + 64]
+    vpsrlw     ymm0, ymm0, 8  // YUYV -> UVUV
+    vpsrlw     ymm1, ymm1, 8
+    vpackuswb  ymm0, ymm0, ymm1  // mutates.
+    vpermq     ymm0, ymm0, 0xd8
+    vpand      ymm1, ymm0, ymm5  // U
+    vpsrlw     ymm0, ymm0, 8  // V
+    vpackuswb  ymm1, ymm1, ymm1  // mutates.
+    vpackuswb  ymm0, ymm0, ymm0  // mutates.
+    vpermq     ymm1, ymm1, 0xd8
+    vpermq     ymm0, ymm0, 0xd8
+    vextractf128 [edx], ymm1, 0  // U
+    vextractf128 [edx + edi], ymm0, 0  // V
+    lea        edx, [edx + 16]
+    sub        ecx, 32
+    jg         convertloop
+
+    pop        edi
+    pop        esi
+    vzeroupper
+    ret
+  }
+}
+
+__declspec(naked) void YUY2ToUV422Row_AVX2(const uint8_t* src_yuy2,
+                                           uint8_t* dst_u,
+                                           uint8_t* dst_v,
+                                           int width) {
+  __asm {
+    push       edi
+    mov        eax, [esp + 4 + 4]  // src_yuy2
+    mov        edx, [esp + 4 + 8]  // dst_u
+    mov        edi, [esp + 4 + 12]  // dst_v
+    mov        ecx, [esp + 4 + 16]  // width
+    vpcmpeqb   ymm5, ymm5, ymm5  // generate mask 0x00ff00ff
+    vpsrlw     ymm5, ymm5, 8
+    sub        edi, edx
+
+  convertloop:
+    vmovdqu    ymm0, [eax]
+    vmovdqu    ymm1, [eax + 32]
+    lea        eax,  [eax + 64]
+    vpsrlw     ymm0, ymm0, 8  // YUYV -> UVUV
+    vpsrlw     ymm1, ymm1, 8
+    vpackuswb  ymm0, ymm0, ymm1  // mutates.
+    vpermq     ymm0, ymm0, 0xd8
+    vpand      ymm1, ymm0, ymm5  // U
+    vpsrlw     ymm0, ymm0, 8  // V
+    vpackuswb  ymm1, ymm1, ymm1  // mutates.
+    vpackuswb  ymm0, ymm0, ymm0  // mutates.
+    vpermq     ymm1, ymm1, 0xd8
+    vpermq     ymm0, ymm0, 0xd8
+    vextractf128 [edx], ymm1, 0  // U
+    vextractf128 [edx + edi], ymm0, 0  // V
+    lea        edx, [edx + 16]
+    sub        ecx, 32
+    jg         convertloop
+
+    pop        edi
+    vzeroupper
+    ret
+  }
+}
+
+__declspec(naked) void UYVYToYRow_AVX2(const uint8_t* src_uyvy,
+                                       uint8_t* dst_y,
+                                       int width) {
+  __asm {
+    mov        eax, [esp + 4]  // src_uyvy
+    mov        edx, [esp + 8]  // dst_y
+    mov        ecx, [esp + 12]  // width
+
+  convertloop:
+    vmovdqu    ymm0, [eax]
+    vmovdqu    ymm1, [eax + 32]
+    lea        eax,  [eax + 64]
+    vpsrlw     ymm0, ymm0, 8  // odd bytes are Y
+    vpsrlw     ymm1, ymm1, 8
+    vpackuswb  ymm0, ymm0, ymm1  // mutates.
+    vpermq     ymm0, ymm0, 0xd8
+    vmovdqu    [edx], ymm0
+    lea        edx, [edx + 32]
+    sub        ecx, 32
+    jg         convertloop
+    vzeroupper
+    ret
+  }
+}
+
+__declspec(naked) void UYVYToUVRow_AVX2(const uint8_t* src_uyvy,
+                                        int stride_uyvy,
+                                        uint8_t* dst_u,
+                                        uint8_t* dst_v,
+                                        int width) {
+  __asm {
+    push       esi
+    push       edi
+    mov        eax, [esp + 8 + 4]  // src_yuy2
+    mov        esi, [esp + 8 + 8]  // stride_yuy2
+    mov        edx, [esp + 8 + 12]  // dst_u
+    mov        edi, [esp + 8 + 16]  // dst_v
+    mov        ecx, [esp + 8 + 20]  // width
+    vpcmpeqb   ymm5, ymm5, ymm5  // generate mask 0x00ff00ff
+    vpsrlw     ymm5, ymm5, 8
+    sub        edi, edx
+
+  convertloop:
+    vmovdqu    ymm0, [eax]
+    vmovdqu    ymm1, [eax + 32]
+    vpavgb     ymm0, ymm0, [eax + esi]
+    vpavgb     ymm1, ymm1, [eax + esi + 32]
+    lea        eax,  [eax + 64]
+    vpand      ymm0, ymm0, ymm5  // UYVY -> UVUV
+    vpand      ymm1, ymm1, ymm5
+    vpackuswb  ymm0, ymm0, ymm1  // mutates.
+    vpermq     ymm0, ymm0, 0xd8
+    vpand      ymm1, ymm0, ymm5  // U
+    vpsrlw     ymm0, ymm0, 8  // V
+    vpackuswb  ymm1, ymm1, ymm1  // mutates.
+    vpackuswb  ymm0, ymm0, ymm0  // mutates.
+    vpermq     ymm1, ymm1, 0xd8
+    vpermq     ymm0, ymm0, 0xd8
+    vextractf128 [edx], ymm1, 0  // U
+    vextractf128 [edx + edi], ymm0, 0  // V
+    lea        edx, [edx + 16]
+    sub        ecx, 32
+    jg         convertloop
+
+    pop        edi
+    pop        esi
+    vzeroupper
+    ret
+  }
+}
+
+__declspec(naked) void UYVYToUV422Row_AVX2(const uint8_t* src_uyvy,
+                                           uint8_t* dst_u,
+                                           uint8_t* dst_v,
+                                           int width) {
+  __asm {
+    push       edi
+    mov        eax, [esp + 4 + 4]  // src_yuy2
+    mov        edx, [esp + 4 + 8]  // dst_u
+    mov        edi, [esp + 4 + 12]  // dst_v
+    mov        ecx, [esp + 4 + 16]  // width
+    vpcmpeqb   ymm5, ymm5, ymm5  // generate mask 0x00ff00ff
+    vpsrlw     ymm5, ymm5, 8
+    sub        edi, edx
+
+  convertloop:
+    vmovdqu    ymm0, [eax]
+    vmovdqu    ymm1, [eax + 32]
+    lea        eax,  [eax + 64]
+    vpand      ymm0, ymm0, ymm5  // UYVY -> UVUV
+    vpand      ymm1, ymm1, ymm5
+    vpackuswb  ymm0, ymm0, ymm1  // mutates.
+    vpermq     ymm0, ymm0, 0xd8
+    vpand      ymm1, ymm0, ymm5  // U
+    vpsrlw     ymm0, ymm0, 8  // V
+    vpackuswb  ymm1, ymm1, ymm1  // mutates.
+    vpackuswb  ymm0, ymm0, ymm0  // mutates.
+    vpermq     ymm1, ymm1, 0xd8
+    vpermq     ymm0, ymm0, 0xd8
+    vextractf128 [edx], ymm1, 0  // U
+    vextractf128 [edx + edi], ymm0, 0  // V
+    lea        edx, [edx + 16]
+    sub        ecx, 32
+    jg         convertloop
+
+    pop        edi
+    vzeroupper
+    ret
+  }
+}
+#endif  // HAS_YUY2TOYROW_AVX2
+
+#ifdef HAS_YUY2TOYROW_SSE2
+__declspec(naked) void YUY2ToYRow_SSE2(const uint8_t* src_yuy2,
+                                       uint8_t* dst_y,
+                                       int width) {
+  __asm {
+    mov        eax, [esp + 4]  // src_yuy2
+    mov        edx, [esp + 8]  // dst_y
+    mov        ecx, [esp + 12]  // width
+    pcmpeqb    xmm5, xmm5  // generate mask 0x00ff00ff
+    psrlw      xmm5, 8
+
+  convertloop:
+    movdqu     xmm0, [eax]
+    movdqu     xmm1, [eax + 16]
+    lea        eax,  [eax + 32]
+    pand       xmm0, xmm5  // even bytes are Y
+    pand       xmm1, xmm5
+    packuswb   xmm0, xmm1
+    movdqu     [edx], xmm0
+    lea        edx, [edx + 16]
+    sub        ecx, 16
+    jg         convertloop
+    ret
+  }
+}
+
+__declspec(naked) void YUY2ToUVRow_SSE2(const uint8_t* src_yuy2,
+                                        int stride_yuy2,
+                                        uint8_t* dst_u,
+                                        uint8_t* dst_v,
+                                        int width) {
+  __asm {
+    push       esi
+    push       edi
+    mov        eax, [esp + 8 + 4]  // src_yuy2
+    mov        esi, [esp + 8 + 8]  // stride_yuy2
+    mov        edx, [esp + 8 + 12]  // dst_u
+    mov        edi, [esp + 8 + 16]  // dst_v
+    mov        ecx, [esp + 8 + 20]  // width
+    pcmpeqb    xmm5, xmm5  // generate mask 0x00ff00ff
+    psrlw      xmm5, 8
+    sub        edi, edx
+
+  convertloop:
+    movdqu     xmm0, [eax]
+    movdqu     xmm1, [eax + 16]
+    movdqu     xmm2, [eax + esi]
+    movdqu     xmm3, [eax + esi + 16]
+    lea        eax,  [eax + 32]
+    pavgb      xmm0, xmm2
+    pavgb      xmm1, xmm3
+    psrlw      xmm0, 8  // YUYV -> UVUV
+    psrlw      xmm1, 8
+    packuswb   xmm0, xmm1
+    movdqa     xmm1, xmm0
+    pand       xmm0, xmm5  // U
+    packuswb   xmm0, xmm0
+    psrlw      xmm1, 8  // V
+    packuswb   xmm1, xmm1
+    movq       qword ptr [edx], xmm0
+    movq       qword ptr [edx + edi], xmm1
+    lea        edx, [edx + 8]
+    sub        ecx, 16
+    jg         convertloop
+
+    pop        edi
+    pop        esi
+    ret
+  }
+}
+
+__declspec(naked) void YUY2ToUV422Row_SSE2(const uint8_t* src_yuy2,
+                                           uint8_t* dst_u,
+                                           uint8_t* dst_v,
+                                           int width) {
+  __asm {
+    push       edi
+    mov        eax, [esp + 4 + 4]  // src_yuy2
+    mov        edx, [esp + 4 + 8]  // dst_u
+    mov        edi, [esp + 4 + 12]  // dst_v
+    mov        ecx, [esp + 4 + 16]  // width
+    pcmpeqb    xmm5, xmm5  // generate mask 0x00ff00ff
+    psrlw      xmm5, 8
+    sub        edi, edx
+
+  convertloop:
+    movdqu     xmm0, [eax]
+    movdqu     xmm1, [eax + 16]
+    lea        eax,  [eax + 32]
+    psrlw      xmm0, 8  // YUYV -> UVUV
+    psrlw      xmm1, 8
+    packuswb   xmm0, xmm1
+    movdqa     xmm1, xmm0
+    pand       xmm0, xmm5  // U
+    packuswb   xmm0, xmm0
+    psrlw      xmm1, 8  // V
+    packuswb   xmm1, xmm1
+    movq       qword ptr [edx], xmm0
+    movq       qword ptr [edx + edi], xmm1
+    lea        edx, [edx + 8]
+    sub        ecx, 16
+    jg         convertloop
+
+    pop        edi
+    ret
+  }
+}
+
+__declspec(naked) void UYVYToYRow_SSE2(const uint8_t* src_uyvy,
+                                       uint8_t* dst_y,
+                                       int width) {
+  __asm {
+    mov        eax, [esp + 4]  // src_uyvy
+    mov        edx, [esp + 8]  // dst_y
+    mov        ecx, [esp + 12]  // width
+
+  convertloop:
+    movdqu     xmm0, [eax]
+    movdqu     xmm1, [eax + 16]
+    lea        eax,  [eax + 32]
+    psrlw      xmm0, 8  // odd bytes are Y
+    psrlw      xmm1, 8
+    packuswb   xmm0, xmm1
+    movdqu     [edx], xmm0
+    lea        edx, [edx + 16]
+    sub        ecx, 16
+    jg         convertloop
+    ret
+  }
+}
+
+__declspec(naked) void UYVYToUVRow_SSE2(const uint8_t* src_uyvy,
+                                        int stride_uyvy,
+                                        uint8_t* dst_u,
+                                        uint8_t* dst_v,
+                                        int width) {
+  __asm {
+    push       esi
+    push       edi
+    mov        eax, [esp + 8 + 4]  // src_yuy2
+    mov        esi, [esp + 8 + 8]  // stride_yuy2
+    mov        edx, [esp + 8 + 12]  // dst_u
+    mov        edi, [esp + 8 + 16]  // dst_v
+    mov        ecx, [esp + 8 + 20]  // width
+    pcmpeqb    xmm5, xmm5  // generate mask 0x00ff00ff
+    psrlw      xmm5, 8
+    sub        edi, edx
+
+  convertloop:
+    movdqu     xmm0, [eax]
+    movdqu     xmm1, [eax + 16]
+    movdqu     xmm2, [eax + esi]
+    movdqu     xmm3, [eax + esi + 16]
+    lea        eax,  [eax + 32]
+    pavgb      xmm0, xmm2
+    pavgb      xmm1, xmm3
+    pand       xmm0, xmm5  // UYVY -> UVUV
+    pand       xmm1, xmm5
+    packuswb   xmm0, xmm1
+    movdqa     xmm1, xmm0
+    pand       xmm0, xmm5  // U
+    packuswb   xmm0, xmm0
+    psrlw      xmm1, 8  // V
+    packuswb   xmm1, xmm1
+    movq       qword ptr [edx], xmm0
+    movq       qword ptr [edx + edi], xmm1
+    lea        edx, [edx + 8]
+    sub        ecx, 16
+    jg         convertloop
+
+    pop        edi
+    pop        esi
+    ret
+  }
+}
+
+__declspec(naked) void UYVYToUV422Row_SSE2(const uint8_t* src_uyvy,
+                                           uint8_t* dst_u,
+                                           uint8_t* dst_v,
+                                           int width) {
+  __asm {
+    push       edi
+    mov        eax, [esp + 4 + 4]  // src_yuy2
+    mov        edx, [esp + 4 + 8]  // dst_u
+    mov        edi, [esp + 4 + 12]  // dst_v
+    mov        ecx, [esp + 4 + 16]  // width
+    pcmpeqb    xmm5, xmm5  // generate mask 0x00ff00ff
+    psrlw      xmm5, 8
+    sub        edi, edx
+
+  convertloop:
+    movdqu     xmm0, [eax]
+    movdqu     xmm1, [eax + 16]
+    lea        eax,  [eax + 32]
+    pand       xmm0, xmm5  // UYVY -> UVUV
+    pand       xmm1, xmm5
+    packuswb   xmm0, xmm1
+    movdqa     xmm1, xmm0
+    pand       xmm0, xmm5  // U
+    packuswb   xmm0, xmm0
+    psrlw      xmm1, 8  // V
+    packuswb   xmm1, xmm1
+    movq       qword ptr [edx], xmm0
+    movq       qword ptr [edx + edi], xmm1
+    lea        edx, [edx + 8]
+    sub        ecx, 16
+    jg         convertloop
+
+    pop        edi
+    ret
+  }
+}
+#endif  // HAS_YUY2TOYROW_SSE2
+
+#ifdef HAS_BLENDPLANEROW_SSSE3
+// Blend 8 pixels at a time.
+// unsigned version of math
+// =((A2*C2)+(B2*(255-C2))+255)/256
+// signed version of math
+// =(((A2-128)*C2)+((B2-128)*(255-C2))+32768+127)/256
+__declspec(naked) void BlendPlaneRow_SSSE3(const uint8_t* src0,
+                                           const uint8_t* src1,
+                                           const uint8_t* alpha,
+                                           uint8_t* dst,
+                                           int width) {
+  __asm {
+    push       esi
+    push       edi
+    pcmpeqb    xmm5, xmm5  // generate mask 0xff00ff00
+    psllw      xmm5, 8
+    mov        eax, 0x80808080  // 128 for biasing image to signed.
+    movd       xmm6, eax
+    pshufd     xmm6, xmm6, 0x00
+
+    mov        eax, 0x807f807f  // 32768 + 127 for unbias and round.
+    movd       xmm7, eax
+    pshufd     xmm7, xmm7, 0x00
+    mov        eax, [esp + 8 + 4]  // src0
+    mov        edx, [esp + 8 + 8]  // src1
+    mov        esi, [esp + 8 + 12]  // alpha
+    mov        edi, [esp + 8 + 16]  // dst
+    mov        ecx, [esp + 8 + 20]  // width
+    sub        eax, esi
+    sub        edx, esi
+    sub        edi, esi
+
+        // 8 pixel loop.
+  convertloop8:
+    movq       xmm0, qword ptr [esi]  // alpha
+    punpcklbw  xmm0, xmm0
+    pxor       xmm0, xmm5  // a, 255-a
+    movq       xmm1, qword ptr [eax + esi]  // src0
+    movq       xmm2, qword ptr [edx + esi]  // src1
+    punpcklbw  xmm1, xmm2
+    psubb      xmm1, xmm6  // bias src0/1 - 128
+    pmaddubsw  xmm0, xmm1
+    paddw      xmm0, xmm7  // unbias result - 32768 and round.
+    psrlw      xmm0, 8
+    packuswb   xmm0, xmm0
+    movq       qword ptr [edi + esi], xmm0
+    lea        esi, [esi + 8]
+    sub        ecx, 8
+    jg         convertloop8
+
+    pop        edi
+    pop        esi
+    ret
+  }
+}
+#endif  // HAS_BLENDPLANEROW_SSSE3
+
+#ifdef HAS_BLENDPLANEROW_AVX2
+// Blend 32 pixels at a time.
+// unsigned version of math
+// =((A2*C2)+(B2*(255-C2))+255)/256
+// signed version of math
+// =(((A2-128)*C2)+((B2-128)*(255-C2))+32768+127)/256
+__declspec(naked) void BlendPlaneRow_AVX2(const uint8_t* src0,
+                                          const uint8_t* src1,
+                                          const uint8_t* alpha,
+                                          uint8_t* dst,
+                                          int width) {
+  __asm {
+    push        esi
+    push        edi
+    vpcmpeqb    ymm5, ymm5, ymm5  // generate mask 0xff00ff00
+    vpsllw      ymm5, ymm5, 8
+    mov         eax, 0x80808080  // 128 for biasing image to signed.
+    vmovd       xmm6, eax
+    vbroadcastss ymm6, xmm6
+    mov         eax, 0x807f807f  // 32768 + 127 for unbias and round.
+    vmovd       xmm7, eax
+    vbroadcastss ymm7, xmm7
+    mov         eax, [esp + 8 + 4]  // src0
+    mov         edx, [esp + 8 + 8]  // src1
+    mov         esi, [esp + 8 + 12]  // alpha
+    mov         edi, [esp + 8 + 16]  // dst
+    mov         ecx, [esp + 8 + 20]  // width
+    sub         eax, esi
+    sub         edx, esi
+    sub         edi, esi
+
+        // 32 pixel loop.
+  convertloop32:
+    vmovdqu     ymm0, [esi]  // alpha
+    vpunpckhbw  ymm3, ymm0, ymm0  // 8..15, 24..31
+    vpunpcklbw  ymm0, ymm0, ymm0  // 0..7, 16..23
+    vpxor       ymm3, ymm3, ymm5  // a, 255-a
+    vpxor       ymm0, ymm0, ymm5  // a, 255-a
+    vmovdqu     ymm1, [eax + esi]  // src0
+    vmovdqu     ymm2, [edx + esi]  // src1
+    vpunpckhbw  ymm4, ymm1, ymm2
+    vpunpcklbw  ymm1, ymm1, ymm2
+    vpsubb      ymm4, ymm4, ymm6  // bias src0/1 - 128
+    vpsubb      ymm1, ymm1, ymm6  // bias src0/1 - 128
+    vpmaddubsw  ymm3, ymm3, ymm4
+    vpmaddubsw  ymm0, ymm0, ymm1
+    vpaddw      ymm3, ymm3, ymm7  // unbias result - 32768 and round.
+    vpaddw      ymm0, ymm0, ymm7  // unbias result - 32768 and round.
+    vpsrlw      ymm3, ymm3, 8
+    vpsrlw      ymm0, ymm0, 8
+    vpackuswb   ymm0, ymm0, ymm3
+    vmovdqu     [edi + esi], ymm0
+    lea         esi, [esi + 32]
+    sub         ecx, 32
+    jg          convertloop32
+
+    pop         edi
+    pop         esi
+    vzeroupper
+    ret
+  }
+}
+#endif  // HAS_BLENDPLANEROW_AVX2
+
+#ifdef HAS_ARGBBLENDROW_SSSE3
+// Shuffle table for isolating alpha.
+static const uvec8 kShuffleAlpha = {3u,  0x80, 3u,  0x80, 7u,  0x80, 7u,  0x80,
+                                    11u, 0x80, 11u, 0x80, 15u, 0x80, 15u, 0x80};
+
+// Blend 8 pixels at a time.
+__declspec(naked) void ARGBBlendRow_SSSE3(const uint8_t* src_argb,
+                                          const uint8_t* src_argb1,
+                                          uint8_t* dst_argb,
+                                          int width) {
+  __asm {
+    push       esi
+    mov        eax, [esp + 4 + 4]  // src_argb
+    mov        esi, [esp + 4 + 8]  // src_argb1
+    mov        edx, [esp + 4 + 12]  // dst_argb
+    mov        ecx, [esp + 4 + 16]  // width
+    pcmpeqb    xmm7, xmm7  // generate constant 0x0001
+    psrlw      xmm7, 15
+    pcmpeqb    xmm6, xmm6  // generate mask 0x00ff00ff
+    psrlw      xmm6, 8
+    pcmpeqb    xmm5, xmm5  // generate mask 0xff00ff00
+    psllw      xmm5, 8
+    pcmpeqb    xmm4, xmm4  // generate mask 0xff000000
+    pslld      xmm4, 24
+    sub        ecx, 4
+    jl         convertloop4b  // less than 4 pixels?
+
+        // 4 pixel loop.
+  convertloop4:
+    movdqu     xmm3, [eax]  // src argb
+    lea        eax, [eax + 16]
+    movdqa     xmm0, xmm3  // src argb
+    pxor       xmm3, xmm4  // ~alpha
+    movdqu     xmm2, [esi]  // _r_b
+    pshufb     xmm3, xmmword ptr kShuffleAlpha  // alpha
+    pand       xmm2, xmm6  // _r_b
+    paddw      xmm3, xmm7  // 256 - alpha
+    pmullw     xmm2, xmm3  // _r_b * alpha
+    movdqu     xmm1, [esi]  // _a_g
+    lea        esi, [esi + 16]
+    psrlw      xmm1, 8  // _a_g
+    por        xmm0, xmm4  // set alpha to 255
+    pmullw     xmm1, xmm3  // _a_g * alpha
+    psrlw      xmm2, 8  // _r_b convert to 8 bits again
+    paddusb    xmm0, xmm2  // + src argb
+    pand       xmm1, xmm5  // a_g_ convert to 8 bits again
+    paddusb    xmm0, xmm1  // + src argb
+    movdqu     [edx], xmm0
+    lea        edx, [edx + 16]
+    sub        ecx, 4
+    jge        convertloop4
+
+  convertloop4b:
+    add        ecx, 4 - 1
+    jl         convertloop1b
+
+            // 1 pixel loop.
+  convertloop1:
+    movd       xmm3, [eax]  // src argb
+    lea        eax, [eax + 4]
+    movdqa     xmm0, xmm3  // src argb
+    pxor       xmm3, xmm4  // ~alpha
+    movd       xmm2, [esi]  // _r_b
+    pshufb     xmm3, xmmword ptr kShuffleAlpha  // alpha
+    pand       xmm2, xmm6  // _r_b
+    paddw      xmm3, xmm7  // 256 - alpha
+    pmullw     xmm2, xmm3  // _r_b * alpha
+    movd       xmm1, [esi]  // _a_g
+    lea        esi, [esi + 4]
+    psrlw      xmm1, 8  // _a_g
+    por        xmm0, xmm4  // set alpha to 255
+    pmullw     xmm1, xmm3  // _a_g * alpha
+    psrlw      xmm2, 8  // _r_b convert to 8 bits again
+    paddusb    xmm0, xmm2  // + src argb
+    pand       xmm1, xmm5  // a_g_ convert to 8 bits again
+    paddusb    xmm0, xmm1  // + src argb
+    movd       [edx], xmm0
+    lea        edx, [edx + 4]
+    sub        ecx, 1
+    jge        convertloop1
+
+  convertloop1b:
+    pop        esi
+    ret
+  }
+}
+#endif  // HAS_ARGBBLENDROW_SSSE3
+
+#ifdef HAS_ARGBATTENUATEROW_SSSE3
+// Shuffle table duplicating alpha.
+static const uvec8 kShuffleAlpha0 = {
+    3u, 3u, 3u, 3u, 3u, 3u, 128u, 128u, 7u, 7u, 7u, 7u, 7u, 7u, 128u, 128u,
+};
+static const uvec8 kShuffleAlpha1 = {
+    11u, 11u, 11u, 11u, 11u, 11u, 128u, 128u,
+    15u, 15u, 15u, 15u, 15u, 15u, 128u, 128u,
+};
+__declspec(naked) void ARGBAttenuateRow_SSSE3(const uint8_t* src_argb,
+                                              uint8_t* dst_argb,
+                                              int width) {
+  __asm {
+    mov        eax, [esp + 4]  // src_argb
+    mov        edx, [esp + 8]  // dst_argb
+    mov        ecx, [esp + 12]  // width
+    pcmpeqb    xmm3, xmm3  // generate mask 0xff000000
+    pslld      xmm3, 24
+    movdqa     xmm4, xmmword ptr kShuffleAlpha0
+    movdqa     xmm5, xmmword ptr kShuffleAlpha1
+
+ convertloop:
+    movdqu     xmm0, [eax]  // read 4 pixels
+    pshufb     xmm0, xmm4  // isolate first 2 alphas
+    movdqu     xmm1, [eax]  // read 4 pixels
+    punpcklbw  xmm1, xmm1  // first 2 pixel rgbs
+    pmulhuw    xmm0, xmm1  // rgb * a
+    movdqu     xmm1, [eax]  // read 4 pixels
+    pshufb     xmm1, xmm5  // isolate next 2 alphas
+    movdqu     xmm2, [eax]  // read 4 pixels
+    punpckhbw  xmm2, xmm2  // next 2 pixel rgbs
+    pmulhuw    xmm1, xmm2  // rgb * a
+    movdqu     xmm2, [eax]  // mask original alpha
+    lea        eax, [eax + 16]
+    pand       xmm2, xmm3
+    psrlw      xmm0, 8
+    psrlw      xmm1, 8
+    packuswb   xmm0, xmm1
+    por        xmm0, xmm2  // copy original alpha
+    movdqu     [edx], xmm0
+    lea        edx, [edx + 16]
+    sub        ecx, 4
+    jg         convertloop
+
+    ret
+  }
+}
+#endif  // HAS_ARGBATTENUATEROW_SSSE3
+
+#ifdef HAS_ARGBATTENUATEROW_AVX2
+// Shuffle table duplicating alpha.
+static const uvec8 kShuffleAlpha_AVX2 = {6u,   7u,   6u,   7u,  6u,  7u,
+                                         128u, 128u, 14u,  15u, 14u, 15u,
+                                         14u,  15u,  128u, 128u};
+__declspec(naked) void ARGBAttenuateRow_AVX2(const uint8_t* src_argb,
+                                             uint8_t* dst_argb,
+                                             int width) {
+  __asm {
+    mov        eax, [esp + 4]  // src_argb
+    mov        edx, [esp + 8]  // dst_argb
+    mov        ecx, [esp + 12]  // width
+    sub        edx, eax
+    vbroadcastf128 ymm4, xmmword ptr kShuffleAlpha_AVX2
+    vpcmpeqb   ymm5, ymm5, ymm5  // generate mask 0xff000000
+    vpslld     ymm5, ymm5, 24
+
+ convertloop:
+    vmovdqu    ymm6, [eax]  // read 8 pixels.
+    vpunpcklbw ymm0, ymm6, ymm6  // low 4 pixels. mutated.
+    vpunpckhbw ymm1, ymm6, ymm6  // high 4 pixels. mutated.
+    vpshufb    ymm2, ymm0, ymm4  // low 4 alphas
+    vpshufb    ymm3, ymm1, ymm4  // high 4 alphas
+    vpmulhuw   ymm0, ymm0, ymm2  // rgb * a
+    vpmulhuw   ymm1, ymm1, ymm3  // rgb * a
+    vpand      ymm6, ymm6, ymm5  // isolate alpha
+    vpsrlw     ymm0, ymm0, 8
+    vpsrlw     ymm1, ymm1, 8
+    vpackuswb  ymm0, ymm0, ymm1  // unmutated.
+    vpor       ymm0, ymm0, ymm6  // copy original alpha
+    vmovdqu    [eax + edx], ymm0
+    lea        eax, [eax + 32]
+    sub        ecx, 8
+    jg         convertloop
+
+    vzeroupper
+    ret
+  }
+}
+#endif  // HAS_ARGBATTENUATEROW_AVX2
+
+#ifdef HAS_ARGBUNATTENUATEROW_SSE2
+// Unattenuate 4 pixels at a time.
+__declspec(naked) void ARGBUnattenuateRow_SSE2(const uint8_t* src_argb,
+                                               uint8_t* dst_argb,
+                                               int width) {
+  __asm {
+    push       ebx
+    push       esi
+    push       edi
+    mov        eax, [esp + 12 + 4]  // src_argb
+    mov        edx, [esp + 12 + 8]  // dst_argb
+    mov        ecx, [esp + 12 + 12]  // width
+    lea        ebx, fixed_invtbl8
+
+ convertloop:
+    movdqu     xmm0, [eax]  // read 4 pixels
+    movzx      esi, byte ptr [eax + 3]  // first alpha
+    movzx      edi, byte ptr [eax + 7]  // second alpha
+    punpcklbw  xmm0, xmm0  // first 2
+    movd       xmm2, dword ptr [ebx + esi * 4]
+    movd       xmm3, dword ptr [ebx + edi * 4]
+    pshuflw    xmm2, xmm2, 040h  // first 4 inv_alpha words.  1, a, a, a
+    pshuflw    xmm3, xmm3, 040h  // next 4 inv_alpha words
+    movlhps    xmm2, xmm3
+    pmulhuw    xmm0, xmm2  // rgb * a
+
+    movdqu     xmm1, [eax]  // read 4 pixels
+    movzx      esi, byte ptr [eax + 11]  // third alpha
+    movzx      edi, byte ptr [eax + 15]  // forth alpha
+    punpckhbw  xmm1, xmm1  // next 2
+    movd       xmm2, dword ptr [ebx + esi * 4]
+    movd       xmm3, dword ptr [ebx + edi * 4]
+    pshuflw    xmm2, xmm2, 040h  // first 4 inv_alpha words
+    pshuflw    xmm3, xmm3, 040h  // next 4 inv_alpha words
+    movlhps    xmm2, xmm3
+    pmulhuw    xmm1, xmm2  // rgb * a
+    lea        eax, [eax + 16]
+    packuswb   xmm0, xmm1
+    movdqu     [edx], xmm0
+    lea        edx, [edx + 16]
+    sub        ecx, 4
+    jg         convertloop
+
+    pop        edi
+    pop        esi
+    pop        ebx
+    ret
+  }
+}
+#endif  // HAS_ARGBUNATTENUATEROW_SSE2
+
+#ifdef HAS_ARGBUNATTENUATEROW_AVX2
+// Shuffle table duplicating alpha.
+static const uvec8 kUnattenShuffleAlpha_AVX2 = {
+    0u, 1u, 0u, 1u, 0u, 1u, 6u, 7u, 8u, 9u, 8u, 9u, 8u, 9u, 14u, 15u};
+// TODO(fbarchard): Enable USE_GATHER for future hardware if faster.
+// USE_GATHER is not on by default, due to being a slow instruction.
+#ifdef USE_GATHER
+__declspec(naked) void ARGBUnattenuateRow_AVX2(const uint8_t* src_argb,
+                                               uint8_t* dst_argb,
+                                               int width) {
+  __asm {
+    mov        eax, [esp + 4]  // src_argb
+    mov        edx, [esp + 8]  // dst_argb
+    mov        ecx, [esp + 12]  // width
+    sub        edx, eax
+    vbroadcastf128 ymm4, xmmword ptr kUnattenShuffleAlpha_AVX2
+
+ convertloop:
+    vmovdqu    ymm6, [eax]  // read 8 pixels.
+    vpcmpeqb   ymm5, ymm5, ymm5  // generate mask 0xffffffff for gather.
+    vpsrld     ymm2, ymm6, 24  // alpha in low 8 bits.
+    vpunpcklbw ymm0, ymm6, ymm6  // low 4 pixels. mutated.
+    vpunpckhbw ymm1, ymm6, ymm6  // high 4 pixels. mutated.
+    vpgatherdd ymm3, [ymm2 * 4 + fixed_invtbl8], ymm5  // ymm5 cleared.  1, a
+    vpunpcklwd ymm2, ymm3, ymm3  // low 4 inverted alphas. mutated. 1, 1, a, a
+    vpunpckhwd ymm3, ymm3, ymm3  // high 4 inverted alphas. mutated.
+    vpshufb    ymm2, ymm2, ymm4  // replicate low 4 alphas. 1, a, a, a
+    vpshufb    ymm3, ymm3, ymm4  // replicate high 4 alphas
+    vpmulhuw   ymm0, ymm0, ymm2  // rgb * ia
+    vpmulhuw   ymm1, ymm1, ymm3  // rgb * ia
+    vpackuswb  ymm0, ymm0, ymm1  // unmutated.
+    vmovdqu    [eax + edx], ymm0
+    lea        eax, [eax + 32]
+    sub        ecx, 8
+    jg         convertloop
+
+    vzeroupper
+    ret
+  }
+}
+#else   // USE_GATHER
+__declspec(naked) void ARGBUnattenuateRow_AVX2(const uint8_t* src_argb,
+                                               uint8_t* dst_argb,
+                                               int width) {
+  __asm {
+
+    push       ebx
+    push       esi
+    push       edi
+    mov        eax, [esp + 12 + 4]  // src_argb
+    mov        edx, [esp + 12 + 8]  // dst_argb
+    mov        ecx, [esp + 12 + 12]  // width
+    sub        edx, eax
+    lea        ebx, fixed_invtbl8
+    vbroadcastf128 ymm5, xmmword ptr kUnattenShuffleAlpha_AVX2
+
+ convertloop:
+        // replace VPGATHER
+    movzx      esi, byte ptr [eax + 3]  // alpha0
+    movzx      edi, byte ptr [eax + 7]  // alpha1
+    vmovd      xmm0, dword ptr [ebx + esi * 4]  // [1,a0]
+    vmovd      xmm1, dword ptr [ebx + edi * 4]  // [1,a1]
+    movzx      esi, byte ptr [eax + 11]  // alpha2
+    movzx      edi, byte ptr [eax + 15]  // alpha3
+    vpunpckldq xmm6, xmm0, xmm1  // [1,a1,1,a0]
+    vmovd      xmm2, dword ptr [ebx + esi * 4]  // [1,a2]
+    vmovd      xmm3, dword ptr [ebx + edi * 4]  // [1,a3]
+    movzx      esi, byte ptr [eax + 19]  // alpha4
+    movzx      edi, byte ptr [eax + 23]  // alpha5
+    vpunpckldq xmm7, xmm2, xmm3  // [1,a3,1,a2]
+    vmovd      xmm0, dword ptr [ebx + esi * 4]  // [1,a4]
+    vmovd      xmm1, dword ptr [ebx + edi * 4]  // [1,a5]
+    movzx      esi, byte ptr [eax + 27]  // alpha6
+    movzx      edi, byte ptr [eax + 31]  // alpha7
+    vpunpckldq xmm0, xmm0, xmm1  // [1,a5,1,a4]
+    vmovd      xmm2, dword ptr [ebx + esi * 4]  // [1,a6]
+    vmovd      xmm3, dword ptr [ebx + edi * 4]  // [1,a7]
+    vpunpckldq xmm2, xmm2, xmm3  // [1,a7,1,a6]
+    vpunpcklqdq xmm3, xmm6, xmm7  // [1,a3,1,a2,1,a1,1,a0]
+    vpunpcklqdq xmm0, xmm0, xmm2  // [1,a7,1,a6,1,a5,1,a4]
+    vinserti128 ymm3, ymm3, xmm0, 1                // [1,a7,1,a6,1,a5,1,a4,1,a3,1,a2,1,a1,1,a0]
+    // end of VPGATHER
+
+    vmovdqu    ymm6, [eax]  // read 8 pixels.
+    vpunpcklbw ymm0, ymm6, ymm6  // low 4 pixels. mutated.
+    vpunpckhbw ymm1, ymm6, ymm6  // high 4 pixels. mutated.
+    vpunpcklwd ymm2, ymm3, ymm3  // low 4 inverted alphas. mutated. 1, 1, a, a
+    vpunpckhwd ymm3, ymm3, ymm3  // high 4 inverted alphas. mutated.
+    vpshufb    ymm2, ymm2, ymm5  // replicate low 4 alphas. 1, a, a, a
+    vpshufb    ymm3, ymm3, ymm5  // replicate high 4 alphas
+    vpmulhuw   ymm0, ymm0, ymm2  // rgb * ia
+    vpmulhuw   ymm1, ymm1, ymm3  // rgb * ia
+    vpackuswb  ymm0, ymm0, ymm1             // unmutated.
+    vmovdqu    [eax + edx], ymm0
+    lea        eax, [eax + 32]
+    sub        ecx, 8
+    jg         convertloop
+
+    pop        edi
+    pop        esi
+    pop        ebx
+    vzeroupper
+    ret
+  }
+}
+#endif  // USE_GATHER
+#endif  // HAS_ARGBATTENUATEROW_AVX2
+
+#ifdef HAS_ARGBGRAYROW_SSSE3
+// Convert 8 ARGB pixels (64 bytes) to 8 Gray ARGB pixels.
+__declspec(naked) void ARGBGrayRow_SSSE3(const uint8_t* src_argb,
+                                         uint8_t* dst_argb,
+                                         int width) {
+  __asm {
+    mov        eax, [esp + 4] /* src_argb */
+    mov        edx, [esp + 8] /* dst_argb */
+    mov        ecx, [esp + 12] /* width */
+    movdqa     xmm4, xmmword ptr kARGBToYJ
+    movdqa     xmm5, xmmword ptr kAddYJ64
+
+ convertloop:
+    movdqu     xmm0, [eax]  // G
+    movdqu     xmm1, [eax + 16]
+    pmaddubsw  xmm0, xmm4
+    pmaddubsw  xmm1, xmm4
+    phaddw     xmm0, xmm1
+    paddw      xmm0, xmm5  // Add .5 for rounding.
+    psrlw      xmm0, 7
+    packuswb   xmm0, xmm0  // 8 G bytes
+    movdqu     xmm2, [eax]  // A
+    movdqu     xmm3, [eax + 16]
+    lea        eax, [eax + 32]
+    psrld      xmm2, 24
+    psrld      xmm3, 24
+    packuswb   xmm2, xmm3
+    packuswb   xmm2, xmm2  // 8 A bytes
+    movdqa     xmm3, xmm0  // Weave into GG, GA, then GGGA
+    punpcklbw  xmm0, xmm0  // 8 GG words
+    punpcklbw  xmm3, xmm2  // 8 GA words
+    movdqa     xmm1, xmm0
+    punpcklwd  xmm0, xmm3  // GGGA first 4
+    punpckhwd  xmm1, xmm3  // GGGA next 4
+    movdqu     [edx], xmm0
+    movdqu     [edx + 16], xmm1
+    lea        edx, [edx + 32]
+    sub        ecx, 8
+    jg         convertloop
+    ret
+  }
+}
+#endif  // HAS_ARGBGRAYROW_SSSE3
+
+#ifdef HAS_ARGBSEPIAROW_SSSE3
+//    b = (r * 35 + g * 68 + b * 17) >> 7
+//    g = (r * 45 + g * 88 + b * 22) >> 7
+//    r = (r * 50 + g * 98 + b * 24) >> 7
+// Constant for ARGB color to sepia tone.
+static const vec8 kARGBToSepiaB = {17, 68, 35, 0, 17, 68, 35, 0,
+                                   17, 68, 35, 0, 17, 68, 35, 0};
+
+static const vec8 kARGBToSepiaG = {22, 88, 45, 0, 22, 88, 45, 0,
+                                   22, 88, 45, 0, 22, 88, 45, 0};
+
+static const vec8 kARGBToSepiaR = {24, 98, 50, 0, 24, 98, 50, 0,
+                                   24, 98, 50, 0, 24, 98, 50, 0};
+
+// Convert 8 ARGB pixels (32 bytes) to 8 Sepia ARGB pixels.
+__declspec(naked) void ARGBSepiaRow_SSSE3(uint8_t* dst_argb, int width) {
+  __asm {
+    mov        eax, [esp + 4] /* dst_argb */
+    mov        ecx, [esp + 8] /* width */
+    movdqa     xmm2, xmmword ptr kARGBToSepiaB
+    movdqa     xmm3, xmmword ptr kARGBToSepiaG
+    movdqa     xmm4, xmmword ptr kARGBToSepiaR
+
+ convertloop:
+    movdqu     xmm0, [eax]  // B
+    movdqu     xmm6, [eax + 16]
+    pmaddubsw  xmm0, xmm2
+    pmaddubsw  xmm6, xmm2
+    phaddw     xmm0, xmm6
+    psrlw      xmm0, 7
+    packuswb   xmm0, xmm0  // 8 B values
+    movdqu     xmm5, [eax]  // G
+    movdqu     xmm1, [eax + 16]
+    pmaddubsw  xmm5, xmm3
+    pmaddubsw  xmm1, xmm3
+    phaddw     xmm5, xmm1
+    psrlw      xmm5, 7
+    packuswb   xmm5, xmm5  // 8 G values
+    punpcklbw  xmm0, xmm5  // 8 BG values
+    movdqu     xmm5, [eax]  // R
+    movdqu     xmm1, [eax + 16]
+    pmaddubsw  xmm5, xmm4
+    pmaddubsw  xmm1, xmm4
+    phaddw     xmm5, xmm1
+    psrlw      xmm5, 7
+    packuswb   xmm5, xmm5  // 8 R values
+    movdqu     xmm6, [eax]  // A
+    movdqu     xmm1, [eax + 16]
+    psrld      xmm6, 24
+    psrld      xmm1, 24
+    packuswb   xmm6, xmm1
+    packuswb   xmm6, xmm6  // 8 A values
+    punpcklbw  xmm5, xmm6  // 8 RA values
+    movdqa     xmm1, xmm0  // Weave BG, RA together
+    punpcklwd  xmm0, xmm5  // BGRA first 4
+    punpckhwd  xmm1, xmm5  // BGRA next 4
+    movdqu     [eax], xmm0
+    movdqu     [eax + 16], xmm1
+    lea        eax, [eax + 32]
+    sub        ecx, 8
+    jg         convertloop
+    ret
+  }
+}
+#endif  // HAS_ARGBSEPIAROW_SSSE3
+
+#ifdef HAS_ARGBCOLORMATRIXROW_SSSE3
+// Tranform 8 ARGB pixels (32 bytes) with color matrix.
+// Same as Sepia except matrix is provided.
+// TODO(fbarchard): packuswbs only use half of the reg. To make RGBA, combine R
+// and B into a high and low, then G/A, unpackl/hbw and then unpckl/hwd.
+__declspec(naked) void ARGBColorMatrixRow_SSSE3(const uint8_t* src_argb,
+                                                uint8_t* dst_argb,
+                                                const int8_t* matrix_argb,
+                                                int width) {
+  __asm {
+    mov        eax, [esp + 4] /* src_argb */
+    mov        edx, [esp + 8] /* dst_argb */
+    mov        ecx, [esp + 12] /* matrix_argb */
+    movdqu     xmm5, [ecx]
+    pshufd     xmm2, xmm5, 0x00
+    pshufd     xmm3, xmm5, 0x55
+    pshufd     xmm4, xmm5, 0xaa
+    pshufd     xmm5, xmm5, 0xff
+    mov        ecx, [esp + 16] /* width */
+
+ convertloop:
+    movdqu     xmm0, [eax]  // B
+    movdqu     xmm7, [eax + 16]
+    pmaddubsw  xmm0, xmm2
+    pmaddubsw  xmm7, xmm2
+    movdqu     xmm6, [eax]  // G
+    movdqu     xmm1, [eax + 16]
+    pmaddubsw  xmm6, xmm3
+    pmaddubsw  xmm1, xmm3
+    phaddsw    xmm0, xmm7  // B
+    phaddsw    xmm6, xmm1  // G
+    psraw      xmm0, 6  // B
+    psraw      xmm6, 6  // G
+    packuswb   xmm0, xmm0  // 8 B values
+    packuswb   xmm6, xmm6  // 8 G values
+    punpcklbw  xmm0, xmm6  // 8 BG values
+    movdqu     xmm1, [eax]  // R
+    movdqu     xmm7, [eax + 16]
+    pmaddubsw  xmm1, xmm4
+    pmaddubsw  xmm7, xmm4
+    phaddsw    xmm1, xmm7  // R
+    movdqu     xmm6, [eax]  // A
+    movdqu     xmm7, [eax + 16]
+    pmaddubsw  xmm6, xmm5
+    pmaddubsw  xmm7, xmm5
+    phaddsw    xmm6, xmm7  // A
+    psraw      xmm1, 6  // R
+    psraw      xmm6, 6  // A
+    packuswb   xmm1, xmm1  // 8 R values
+    packuswb   xmm6, xmm6  // 8 A values
+    punpcklbw  xmm1, xmm6  // 8 RA values
+    movdqa     xmm6, xmm0  // Weave BG, RA together
+    punpcklwd  xmm0, xmm1  // BGRA first 4
+    punpckhwd  xmm6, xmm1  // BGRA next 4
+    movdqu     [edx], xmm0
+    movdqu     [edx + 16], xmm6
+    lea        eax, [eax + 32]
+    lea        edx, [edx + 32]
+    sub        ecx, 8
+    jg         convertloop
+    ret
+  }
+}
+#endif  // HAS_ARGBCOLORMATRIXROW_SSSE3
+
+#ifdef HAS_ARGBQUANTIZEROW_SSE2
+// Quantize 4 ARGB pixels (16 bytes).
+__declspec(naked) void ARGBQuantizeRow_SSE2(uint8_t* dst_argb,
+                                            int scale,
+                                            int interval_size,
+                                            int interval_offset,
+                                            int width) {
+  __asm {
+    mov        eax, [esp + 4] /* dst_argb */
+    movd       xmm2, [esp + 8] /* scale */
+    movd       xmm3, [esp + 12] /* interval_size */
+    movd       xmm4, [esp + 16] /* interval_offset */
+    mov        ecx, [esp + 20] /* width */
+    pshuflw    xmm2, xmm2, 040h
+    pshufd     xmm2, xmm2, 044h
+    pshuflw    xmm3, xmm3, 040h
+    pshufd     xmm3, xmm3, 044h
+    pshuflw    xmm4, xmm4, 040h
+    pshufd     xmm4, xmm4, 044h
+    pxor       xmm5, xmm5  // constant 0
+    pcmpeqb    xmm6, xmm6  // generate mask 0xff000000
+    pslld      xmm6, 24
+
+ convertloop:
+    movdqu     xmm0, [eax]  // read 4 pixels
+    punpcklbw  xmm0, xmm5  // first 2 pixels
+    pmulhuw    xmm0, xmm2  // pixel * scale >> 16
+    movdqu     xmm1, [eax]  // read 4 pixels
+    punpckhbw  xmm1, xmm5  // next 2 pixels
+    pmulhuw    xmm1, xmm2
+    pmullw     xmm0, xmm3  // * interval_size
+    movdqu     xmm7, [eax]  // read 4 pixels
+    pmullw     xmm1, xmm3
+    pand       xmm7, xmm6  // mask alpha
+    paddw      xmm0, xmm4  // + interval_size / 2
+    paddw      xmm1, xmm4
+    packuswb   xmm0, xmm1
+    por        xmm0, xmm7
+    movdqu     [eax], xmm0
+    lea        eax, [eax + 16]
+    sub        ecx, 4
+    jg         convertloop
+    ret
+  }
+}
+#endif  // HAS_ARGBQUANTIZEROW_SSE2
+
+#ifdef HAS_ARGBSHADEROW_SSE2
+// Shade 4 pixels at a time by specified value.
+__declspec(naked) void ARGBShadeRow_SSE2(const uint8_t* src_argb,
+                                         uint8_t* dst_argb,
+                                         int width,
+                                         uint32_t value) {
+  __asm {
+    mov        eax, [esp + 4]  // src_argb
+    mov        edx, [esp + 8]  // dst_argb
+    mov        ecx, [esp + 12]  // width
+    movd       xmm2, [esp + 16]  // value
+    punpcklbw  xmm2, xmm2
+    punpcklqdq xmm2, xmm2
+
+ convertloop:
+    movdqu     xmm0, [eax]  // read 4 pixels
+    lea        eax, [eax + 16]
+    movdqa     xmm1, xmm0
+    punpcklbw  xmm0, xmm0  // first 2
+    punpckhbw  xmm1, xmm1  // next 2
+    pmulhuw    xmm0, xmm2  // argb * value
+    pmulhuw    xmm1, xmm2  // argb * value
+    psrlw      xmm0, 8
+    psrlw      xmm1, 8
+    packuswb   xmm0, xmm1
+    movdqu     [edx], xmm0
+    lea        edx, [edx + 16]
+    sub        ecx, 4
+    jg         convertloop
+
+    ret
+  }
+}
+#endif  // HAS_ARGBSHADEROW_SSE2
+
+#ifdef HAS_ARGBMULTIPLYROW_SSE2
+// Multiply 2 rows of ARGB pixels together, 4 pixels at a time.
+__declspec(naked) void ARGBMultiplyRow_SSE2(const uint8_t* src_argb,
+                                            const uint8_t* src_argb1,
+                                            uint8_t* dst_argb,
+                                            int width) {
+  __asm {
+    push       esi
+    mov        eax, [esp + 4 + 4]  // src_argb
+    mov        esi, [esp + 4 + 8]  // src_argb1
+    mov        edx, [esp + 4 + 12]  // dst_argb
+    mov        ecx, [esp + 4 + 16]  // width
+    pxor       xmm5, xmm5  // constant 0
+
+ convertloop:
+    movdqu     xmm0, [eax]  // read 4 pixels from src_argb
+    movdqu     xmm2, [esi]  // read 4 pixels from src_argb1
+    movdqu     xmm1, xmm0
+    movdqu     xmm3, xmm2
+    punpcklbw  xmm0, xmm0  // first 2
+    punpckhbw  xmm1, xmm1  // next 2
+    punpcklbw  xmm2, xmm5  // first 2
+    punpckhbw  xmm3, xmm5  // next 2
+    pmulhuw    xmm0, xmm2  // src_argb * src_argb1 first 2
+    pmulhuw    xmm1, xmm3  // src_argb * src_argb1 next 2
+    lea        eax, [eax + 16]
+    lea        esi, [esi + 16]
+    packuswb   xmm0, xmm1
+    movdqu     [edx], xmm0
+    lea        edx, [edx + 16]
+    sub        ecx, 4
+    jg         convertloop
+
+    pop        esi
+    ret
+  }
+}
+#endif  // HAS_ARGBMULTIPLYROW_SSE2
+
+#ifdef HAS_ARGBADDROW_SSE2
+// Add 2 rows of ARGB pixels together, 4 pixels at a time.
+// TODO(fbarchard): Port this to posix, neon and other math functions.
+__declspec(naked) void ARGBAddRow_SSE2(const uint8_t* src_argb,
+                                       const uint8_t* src_argb1,
+                                       uint8_t* dst_argb,
+                                       int width) {
+  __asm {
+    push       esi
+    mov        eax, [esp + 4 + 4]  // src_argb
+    mov        esi, [esp + 4 + 8]  // src_argb1
+    mov        edx, [esp + 4 + 12]  // dst_argb
+    mov        ecx, [esp + 4 + 16]  // width
+
+    sub        ecx, 4
+    jl         convertloop49
+
+ convertloop4:
+    movdqu     xmm0, [eax]  // read 4 pixels from src_argb
+    lea        eax, [eax + 16]
+    movdqu     xmm1, [esi]  // read 4 pixels from src_argb1
+    lea        esi, [esi + 16]
+    paddusb    xmm0, xmm1  // src_argb + src_argb1
+    movdqu     [edx], xmm0
+    lea        edx, [edx + 16]
+    sub        ecx, 4
+    jge        convertloop4
+
+ convertloop49:
+    add        ecx, 4 - 1
+    jl         convertloop19
+
+ convertloop1:
+    movd       xmm0, [eax]  // read 1 pixels from src_argb
+    lea        eax, [eax + 4]
+    movd       xmm1, [esi]  // read 1 pixels from src_argb1
+    lea        esi, [esi + 4]
+    paddusb    xmm0, xmm1  // src_argb + src_argb1
+    movd       [edx], xmm0
+    lea        edx, [edx + 4]
+    sub        ecx, 1
+    jge        convertloop1
+
+ convertloop19:
+    pop        esi
+    ret
+  }
+}
+#endif  // HAS_ARGBADDROW_SSE2
+
+#ifdef HAS_ARGBSUBTRACTROW_SSE2
+// Subtract 2 rows of ARGB pixels together, 4 pixels at a time.
+__declspec(naked) void ARGBSubtractRow_SSE2(const uint8_t* src_argb,
+                                            const uint8_t* src_argb1,
+                                            uint8_t* dst_argb,
+                                            int width) {
+  __asm {
+    push       esi
+    mov        eax, [esp + 4 + 4]  // src_argb
+    mov        esi, [esp + 4 + 8]  // src_argb1
+    mov        edx, [esp + 4 + 12]  // dst_argb
+    mov        ecx, [esp + 4 + 16]  // width
+
+ convertloop:
+    movdqu     xmm0, [eax]  // read 4 pixels from src_argb
+    lea        eax, [eax + 16]
+    movdqu     xmm1, [esi]  // read 4 pixels from src_argb1
+    lea        esi, [esi + 16]
+    psubusb    xmm0, xmm1  // src_argb - src_argb1
+    movdqu     [edx], xmm0
+    lea        edx, [edx + 16]
+    sub        ecx, 4
+    jg         convertloop
+
+    pop        esi
+    ret
+  }
+}
+#endif  // HAS_ARGBSUBTRACTROW_SSE2
+
+#ifdef HAS_ARGBMULTIPLYROW_AVX2
+// Multiply 2 rows of ARGB pixels together, 8 pixels at a time.
+__declspec(naked) void ARGBMultiplyRow_AVX2(const uint8_t* src_argb,
+                                            const uint8_t* src_argb1,
+                                            uint8_t* dst_argb,
+                                            int width) {
+  __asm {
+    push       esi
+    mov        eax, [esp + 4 + 4]  // src_argb
+    mov        esi, [esp + 4 + 8]  // src_argb1
+    mov        edx, [esp + 4 + 12]  // dst_argb
+    mov        ecx, [esp + 4 + 16]  // width
+    vpxor      ymm5, ymm5, ymm5  // constant 0
+
+ convertloop:
+    vmovdqu    ymm1, [eax]  // read 8 pixels from src_argb
+    lea        eax, [eax + 32]
+    vmovdqu    ymm3, [esi]  // read 8 pixels from src_argb1
+    lea        esi, [esi + 32]
+    vpunpcklbw ymm0, ymm1, ymm1  // low 4
+    vpunpckhbw ymm1, ymm1, ymm1  // high 4
+    vpunpcklbw ymm2, ymm3, ymm5  // low 4
+    vpunpckhbw ymm3, ymm3, ymm5  // high 4
+    vpmulhuw   ymm0, ymm0, ymm2  // src_argb * src_argb1 low 4
+    vpmulhuw   ymm1, ymm1, ymm3  // src_argb * src_argb1 high 4
+    vpackuswb  ymm0, ymm0, ymm1
+    vmovdqu    [edx], ymm0
+    lea        edx, [edx + 32]
+    sub        ecx, 8
+    jg         convertloop
+
+    pop        esi
+    vzeroupper
+    ret
+  }
+}
+#endif  // HAS_ARGBMULTIPLYROW_AVX2
+
+#ifdef HAS_ARGBADDROW_AVX2
+// Add 2 rows of ARGB pixels together, 8 pixels at a time.
+__declspec(naked) void ARGBAddRow_AVX2(const uint8_t* src_argb,
+                                       const uint8_t* src_argb1,
+                                       uint8_t* dst_argb,
+                                       int width) {
+  __asm {
+    push       esi
+    mov        eax, [esp + 4 + 4]  // src_argb
+    mov        esi, [esp + 4 + 8]  // src_argb1
+    mov        edx, [esp + 4 + 12]  // dst_argb
+    mov        ecx, [esp + 4 + 16]  // width
+
+ convertloop:
+    vmovdqu    ymm0, [eax]  // read 8 pixels from src_argb
+    lea        eax, [eax + 32]
+    vpaddusb   ymm0, ymm0, [esi]  // add 8 pixels from src_argb1
+    lea        esi, [esi + 32]
+    vmovdqu    [edx], ymm0
+    lea        edx, [edx + 32]
+    sub        ecx, 8
+    jg         convertloop
+
+    pop        esi
+    vzeroupper
+    ret
+  }
+}
+#endif  // HAS_ARGBADDROW_AVX2
+
+#ifdef HAS_ARGBSUBTRACTROW_AVX2
+// Subtract 2 rows of ARGB pixels together, 8 pixels at a time.
+__declspec(naked) void ARGBSubtractRow_AVX2(const uint8_t* src_argb,
+                                            const uint8_t* src_argb1,
+                                            uint8_t* dst_argb,
+                                            int width) {
+  __asm {
+    push       esi
+    mov        eax, [esp + 4 + 4]  // src_argb
+    mov        esi, [esp + 4 + 8]  // src_argb1
+    mov        edx, [esp + 4 + 12]  // dst_argb
+    mov        ecx, [esp + 4 + 16]  // width
+
+ convertloop:
+    vmovdqu    ymm0, [eax]  // read 8 pixels from src_argb
+    lea        eax, [eax + 32]
+    vpsubusb   ymm0, ymm0, [esi]  // src_argb - src_argb1
+    lea        esi, [esi + 32]
+    vmovdqu    [edx], ymm0
+    lea        edx, [edx + 32]
+    sub        ecx, 8
+    jg         convertloop
+
+    pop        esi
+    vzeroupper
+    ret
+  }
+}
+#endif  // HAS_ARGBSUBTRACTROW_AVX2
+
+#ifdef HAS_SOBELXROW_SSE2
+// SobelX as a matrix is
+// -1  0  1
+// -2  0  2
+// -1  0  1
+__declspec(naked) void SobelXRow_SSE2(const uint8_t* src_y0,
+                                      const uint8_t* src_y1,
+                                      const uint8_t* src_y2,
+                                      uint8_t* dst_sobelx,
+                                      int width) {
+  __asm {
+    push       esi
+    push       edi
+    mov        eax, [esp + 8 + 4]  // src_y0
+    mov        esi, [esp + 8 + 8]  // src_y1
+    mov        edi, [esp + 8 + 12]  // src_y2
+    mov        edx, [esp + 8 + 16]  // dst_sobelx
+    mov        ecx, [esp + 8 + 20]  // width
+    sub        esi, eax
+    sub        edi, eax
+    sub        edx, eax
+    pxor       xmm5, xmm5  // constant 0
+
+ convertloop:
+    movq       xmm0, qword ptr [eax]  // read 8 pixels from src_y0[0]
+    movq       xmm1, qword ptr [eax + 2]  // read 8 pixels from src_y0[2]
+    punpcklbw  xmm0, xmm5
+    punpcklbw  xmm1, xmm5
+    psubw      xmm0, xmm1
+    movq       xmm1, qword ptr [eax + esi]  // read 8 pixels from src_y1[0]
+    movq       xmm2, qword ptr [eax + esi + 2]  // read 8 pixels from src_y1[2]
+    punpcklbw  xmm1, xmm5
+    punpcklbw  xmm2, xmm5
+    psubw      xmm1, xmm2
+    movq       xmm2, qword ptr [eax + edi]  // read 8 pixels from src_y2[0]
+    movq       xmm3, qword ptr [eax + edi + 2]  // read 8 pixels from src_y2[2]
+    punpcklbw  xmm2, xmm5
+    punpcklbw  xmm3, xmm5
+    psubw      xmm2, xmm3
+    paddw      xmm0, xmm2
+    paddw      xmm0, xmm1
+    paddw      xmm0, xmm1
+    pxor       xmm1, xmm1  // abs = max(xmm0, -xmm0).  SSSE3 could use pabsw
+    psubw      xmm1, xmm0
+    pmaxsw     xmm0, xmm1
+    packuswb   xmm0, xmm0
+    movq       qword ptr [eax + edx], xmm0
+    lea        eax, [eax + 8]
+    sub        ecx, 8
+    jg         convertloop
+
+    pop        edi
+    pop        esi
+    ret
+  }
+}
+#endif  // HAS_SOBELXROW_SSE2
+
+#ifdef HAS_SOBELYROW_SSE2
+// SobelY as a matrix is
+// -1 -2 -1
+//  0  0  0
+//  1  2  1
+__declspec(naked) void SobelYRow_SSE2(const uint8_t* src_y0,
+                                      const uint8_t* src_y1,
+                                      uint8_t* dst_sobely,
+                                      int width) {
+  __asm {
+    push       esi
+    mov        eax, [esp + 4 + 4]  // src_y0
+    mov        esi, [esp + 4 + 8]  // src_y1
+    mov        edx, [esp + 4 + 12]  // dst_sobely
+    mov        ecx, [esp + 4 + 16]  // width
+    sub        esi, eax
+    sub        edx, eax
+    pxor       xmm5, xmm5  // constant 0
+
+ convertloop:
+    movq       xmm0, qword ptr [eax]  // read 8 pixels from src_y0[0]
+    movq       xmm1, qword ptr [eax + esi]  // read 8 pixels from src_y1[0]
+    punpcklbw  xmm0, xmm5
+    punpcklbw  xmm1, xmm5
+    psubw      xmm0, xmm1
+    movq       xmm1, qword ptr [eax + 1]  // read 8 pixels from src_y0[1]
+    movq       xmm2, qword ptr [eax + esi + 1]  // read 8 pixels from src_y1[1]
+    punpcklbw  xmm1, xmm5
+    punpcklbw  xmm2, xmm5
+    psubw      xmm1, xmm2
+    movq       xmm2, qword ptr [eax + 2]  // read 8 pixels from src_y0[2]
+    movq       xmm3, qword ptr [eax + esi + 2]  // read 8 pixels from src_y1[2]
+    punpcklbw  xmm2, xmm5
+    punpcklbw  xmm3, xmm5
+    psubw      xmm2, xmm3
+    paddw      xmm0, xmm2
+    paddw      xmm0, xmm1
+    paddw      xmm0, xmm1
+    pxor       xmm1, xmm1  // abs = max(xmm0, -xmm0).  SSSE3 could use pabsw
+    psubw      xmm1, xmm0
+    pmaxsw     xmm0, xmm1
+    packuswb   xmm0, xmm0
+    movq       qword ptr [eax + edx], xmm0
+    lea        eax, [eax + 8]
+    sub        ecx, 8
+    jg         convertloop
+
+    pop        esi
+    ret
+  }
+}
+#endif  // HAS_SOBELYROW_SSE2
+
+#ifdef HAS_SOBELROW_SSE2
+// Adds Sobel X and Sobel Y and stores Sobel into ARGB.
+// A = 255
+// R = Sobel
+// G = Sobel
+// B = Sobel
+__declspec(naked) void SobelRow_SSE2(const uint8_t* src_sobelx,
+                                     const uint8_t* src_sobely,
+                                     uint8_t* dst_argb,
+                                     int width) {
+  __asm {
+    push       esi
+    mov        eax, [esp + 4 + 4]  // src_sobelx
+    mov        esi, [esp + 4 + 8]  // src_sobely
+    mov        edx, [esp + 4 + 12]  // dst_argb
+    mov        ecx, [esp + 4 + 16]  // width
+    sub        esi, eax
+    pcmpeqb    xmm5, xmm5  // alpha 255
+    pslld      xmm5, 24  // 0xff000000
+
+ convertloop:
+    movdqu     xmm0, [eax]  // read 16 pixels src_sobelx
+    movdqu     xmm1, [eax + esi]  // read 16 pixels src_sobely
+    lea        eax, [eax + 16]
+    paddusb    xmm0, xmm1  // sobel = sobelx + sobely
+    movdqa     xmm2, xmm0  // GG
+    punpcklbw  xmm2, xmm0  // First 8
+    punpckhbw  xmm0, xmm0  // Next 8
+    movdqa     xmm1, xmm2  // GGGG
+    punpcklwd  xmm1, xmm2  // First 4
+    punpckhwd  xmm2, xmm2  // Next 4
+    por        xmm1, xmm5  // GGGA
+    por        xmm2, xmm5
+    movdqa     xmm3, xmm0  // GGGG
+    punpcklwd  xmm3, xmm0  // Next 4
+    punpckhwd  xmm0, xmm0  // Last 4
+    por        xmm3, xmm5  // GGGA
+    por        xmm0, xmm5
+    movdqu     [edx], xmm1
+    movdqu     [edx + 16], xmm2
+    movdqu     [edx + 32], xmm3
+    movdqu     [edx + 48], xmm0
+    lea        edx, [edx + 64]
+    sub        ecx, 16
+    jg         convertloop
+
+    pop        esi
+    ret
+  }
+}
+#endif  // HAS_SOBELROW_SSE2
+
+#ifdef HAS_SOBELTOPLANEROW_SSE2
+// Adds Sobel X and Sobel Y and stores Sobel into a plane.
+__declspec(naked) void SobelToPlaneRow_SSE2(const uint8_t* src_sobelx,
+                                            const uint8_t* src_sobely,
+                                            uint8_t* dst_y,
+                                            int width) {
+  __asm {
+    push       esi
+    mov        eax, [esp + 4 + 4]  // src_sobelx
+    mov        esi, [esp + 4 + 8]  // src_sobely
+    mov        edx, [esp + 4 + 12]  // dst_argb
+    mov        ecx, [esp + 4 + 16]  // width
+    sub        esi, eax
+
+ convertloop:
+    movdqu     xmm0, [eax]  // read 16 pixels src_sobelx
+    movdqu     xmm1, [eax + esi]  // read 16 pixels src_sobely
+    lea        eax, [eax + 16]
+    paddusb    xmm0, xmm1  // sobel = sobelx + sobely
+    movdqu     [edx], xmm0
+    lea        edx, [edx + 16]
+    sub        ecx, 16
+    jg         convertloop
+
+    pop        esi
+    ret
+  }
+}
+#endif  // HAS_SOBELTOPLANEROW_SSE2
+
+#ifdef HAS_SOBELXYROW_SSE2
+// Mixes Sobel X, Sobel Y and Sobel into ARGB.
+// A = 255
+// R = Sobel X
+// G = Sobel
+// B = Sobel Y
+__declspec(naked) void SobelXYRow_SSE2(const uint8_t* src_sobelx,
+                                       const uint8_t* src_sobely,
+                                       uint8_t* dst_argb,
+                                       int width) {
+  __asm {
+    push       esi
+    mov        eax, [esp + 4 + 4]  // src_sobelx
+    mov        esi, [esp + 4 + 8]  // src_sobely
+    mov        edx, [esp + 4 + 12]  // dst_argb
+    mov        ecx, [esp + 4 + 16]  // width
+    sub        esi, eax
+    pcmpeqb    xmm5, xmm5  // alpha 255
+
+ convertloop:
+    movdqu     xmm0, [eax]  // read 16 pixels src_sobelx
+    movdqu     xmm1, [eax + esi]  // read 16 pixels src_sobely
+    lea        eax, [eax + 16]
+    movdqa     xmm2, xmm0
+    paddusb    xmm2, xmm1  // sobel = sobelx + sobely
+    movdqa     xmm3, xmm0  // XA
+    punpcklbw  xmm3, xmm5
+    punpckhbw  xmm0, xmm5
+    movdqa     xmm4, xmm1  // YS
+    punpcklbw  xmm4, xmm2
+    punpckhbw  xmm1, xmm2
+    movdqa     xmm6, xmm4  // YSXA
+    punpcklwd  xmm6, xmm3  // First 4
+    punpckhwd  xmm4, xmm3  // Next 4
+    movdqa     xmm7, xmm1  // YSXA
+    punpcklwd  xmm7, xmm0  // Next 4
+    punpckhwd  xmm1, xmm0  // Last 4
+    movdqu     [edx], xmm6
+    movdqu     [edx + 16], xmm4
+    movdqu     [edx + 32], xmm7
+    movdqu     [edx + 48], xmm1
+    lea        edx, [edx + 64]
+    sub        ecx, 16
+    jg         convertloop
+
+    pop        esi
+    ret
+  }
+}
+#endif  // HAS_SOBELXYROW_SSE2
+
+#ifdef HAS_CUMULATIVESUMTOAVERAGEROW_SSE2
+// Consider float CumulativeSum.
+// Consider calling CumulativeSum one row at time as needed.
+// Consider circular CumulativeSum buffer of radius * 2 + 1 height.
+// Convert cumulative sum for an area to an average for 1 pixel.
+// topleft is pointer to top left of CumulativeSum buffer for area.
+// botleft is pointer to bottom left of CumulativeSum buffer.
+// width is offset from left to right of area in CumulativeSum buffer measured
+//   in number of ints.
+// area is the number of pixels in the area being averaged.
+// dst points to pixel to store result to.
+// count is number of averaged pixels to produce.
+// Does 4 pixels at a time.
+// This function requires alignment on accumulation buffer pointers.
+void CumulativeSumToAverageRow_SSE2(const int32_t* topleft,
+                                    const int32_t* botleft,
+                                    int width,
+                                    int area,
+                                    uint8_t* dst,
+                                    int count) {
+  __asm {
+    mov        eax, topleft  // eax topleft
+    mov        esi, botleft  // esi botleft
+    mov        edx, width
+    movd       xmm5, area
+    mov        edi, dst
+    mov        ecx, count
+    cvtdq2ps   xmm5, xmm5
+    rcpss      xmm4, xmm5  // 1.0f / area
+    pshufd     xmm4, xmm4, 0
+    sub        ecx, 4
+    jl         l4b
+
+    cmp        area, 128  // 128 pixels will not overflow 15 bits.
+    ja         l4
+
+    pshufd     xmm5, xmm5, 0  // area
+    pcmpeqb    xmm6, xmm6  // constant of 65536.0 - 1 = 65535.0
+    psrld      xmm6, 16
+    cvtdq2ps   xmm6, xmm6
+    addps      xmm5, xmm6  // (65536.0 + area - 1)
+    mulps      xmm5, xmm4  // (65536.0 + area - 1) * 1 / area
+    cvtps2dq   xmm5, xmm5  // 0.16 fixed point
+    packssdw   xmm5, xmm5  // 16 bit shorts
+
+        // 4 pixel loop small blocks.
+  s4:
+        // top left
+    movdqu     xmm0, [eax]
+    movdqu     xmm1, [eax + 16]
+    movdqu     xmm2, [eax + 32]
+    movdqu     xmm3, [eax + 48]
+
+    // - top right
+    psubd      xmm0, [eax + edx * 4]
+    psubd      xmm1, [eax + edx * 4 + 16]
+    psubd      xmm2, [eax + edx * 4 + 32]
+    psubd      xmm3, [eax + edx * 4 + 48]
+    lea        eax, [eax + 64]
+
+    // - bottom left
+    psubd      xmm0, [esi]
+    psubd      xmm1, [esi + 16]
+    psubd      xmm2, [esi + 32]
+    psubd      xmm3, [esi + 48]
+
+    // + bottom right
+    paddd      xmm0, [esi + edx * 4]
+    paddd      xmm1, [esi + edx * 4 + 16]
+    paddd      xmm2, [esi + edx * 4 + 32]
+    paddd      xmm3, [esi + edx * 4 + 48]
+    lea        esi, [esi + 64]
+
+    packssdw   xmm0, xmm1  // pack 4 pixels into 2 registers
+    packssdw   xmm2, xmm3
+
+    pmulhuw    xmm0, xmm5
+    pmulhuw    xmm2, xmm5
+
+    packuswb   xmm0, xmm2
+    movdqu     [edi], xmm0
+    lea        edi, [edi + 16]
+    sub        ecx, 4
+    jge        s4
+
+    jmp        l4b
+
+            // 4 pixel loop
+  l4:
+        // top left
+    movdqu     xmm0, [eax]
+    movdqu     xmm1, [eax + 16]
+    movdqu     xmm2, [eax + 32]
+    movdqu     xmm3, [eax + 48]
+
+    // - top right
+    psubd      xmm0, [eax + edx * 4]
+    psubd      xmm1, [eax + edx * 4 + 16]
+    psubd      xmm2, [eax + edx * 4 + 32]
+    psubd      xmm3, [eax + edx * 4 + 48]
+    lea        eax, [eax + 64]
+
+    // - bottom left
+    psubd      xmm0, [esi]
+    psubd      xmm1, [esi + 16]
+    psubd      xmm2, [esi + 32]
+    psubd      xmm3, [esi + 48]
+
+    // + bottom right
+    paddd      xmm0, [esi + edx * 4]
+    paddd      xmm1, [esi + edx * 4 + 16]
+    paddd      xmm2, [esi + edx * 4 + 32]
+    paddd      xmm3, [esi + edx * 4 + 48]
+    lea        esi, [esi + 64]
+
+    cvtdq2ps   xmm0, xmm0  // Average = Sum * 1 / Area
+    cvtdq2ps   xmm1, xmm1
+    mulps      xmm0, xmm4
+    mulps      xmm1, xmm4
+    cvtdq2ps   xmm2, xmm2
+    cvtdq2ps   xmm3, xmm3
+    mulps      xmm2, xmm4
+    mulps      xmm3, xmm4
+    cvtps2dq   xmm0, xmm0
+    cvtps2dq   xmm1, xmm1
+    cvtps2dq   xmm2, xmm2
+    cvtps2dq   xmm3, xmm3
+    packssdw   xmm0, xmm1
+    packssdw   xmm2, xmm3
+    packuswb   xmm0, xmm2
+    movdqu     [edi], xmm0
+    lea        edi, [edi + 16]
+    sub        ecx, 4
+    jge        l4
+
+  l4b:
+    add        ecx, 4 - 1
+    jl         l1b
+
+            // 1 pixel loop
+  l1:
+    movdqu     xmm0, [eax]
+    psubd      xmm0, [eax + edx * 4]
+    lea        eax, [eax + 16]
+    psubd      xmm0, [esi]
+    paddd      xmm0, [esi + edx * 4]
+    lea        esi, [esi + 16]
+    cvtdq2ps   xmm0, xmm0
+    mulps      xmm0, xmm4
+    cvtps2dq   xmm0, xmm0
+    packssdw   xmm0, xmm0
+    packuswb   xmm0, xmm0
+    movd       dword ptr [edi], xmm0
+    lea        edi, [edi + 4]
+    sub        ecx, 1
+    jge        l1
+  l1b:
+  }
+}
+#endif  // HAS_CUMULATIVESUMTOAVERAGEROW_SSE2
+
+#ifdef HAS_COMPUTECUMULATIVESUMROW_SSE2
+// Creates a table of cumulative sums where each value is a sum of all values
+// above and to the left of the value.
+void ComputeCumulativeSumRow_SSE2(const uint8_t* row,
+                                  int32_t* cumsum,
+                                  const int32_t* previous_cumsum,
+                                  int width) {
+  __asm {
+    mov        eax, row
+    mov        edx, cumsum
+    mov        esi, previous_cumsum
+    mov        ecx, width
+    pxor       xmm0, xmm0
+    pxor       xmm1, xmm1
+
+    sub        ecx, 4
+    jl         l4b
+    test       edx, 15
+    jne        l4b
+
+        // 4 pixel loop
+  l4:
+    movdqu     xmm2, [eax]  // 4 argb pixels 16 bytes.
+    lea        eax, [eax + 16]
+    movdqa     xmm4, xmm2
+
+    punpcklbw  xmm2, xmm1
+    movdqa     xmm3, xmm2
+    punpcklwd  xmm2, xmm1
+    punpckhwd  xmm3, xmm1
+
+    punpckhbw  xmm4, xmm1
+    movdqa     xmm5, xmm4
+    punpcklwd  xmm4, xmm1
+    punpckhwd  xmm5, xmm1
+
+    paddd      xmm0, xmm2
+    movdqu     xmm2, [esi]  // previous row above.
+    paddd      xmm2, xmm0
+
+    paddd      xmm0, xmm3
+    movdqu     xmm3, [esi + 16]
+    paddd      xmm3, xmm0
+
+    paddd      xmm0, xmm4
+    movdqu     xmm4, [esi + 32]
+    paddd      xmm4, xmm0
+
+    paddd      xmm0, xmm5
+    movdqu     xmm5, [esi + 48]
+    lea        esi, [esi + 64]
+    paddd      xmm5, xmm0
+
+    movdqu     [edx], xmm2
+    movdqu     [edx + 16], xmm3
+    movdqu     [edx + 32], xmm4
+    movdqu     [edx + 48], xmm5
+
+    lea        edx, [edx + 64]
+    sub        ecx, 4
+    jge        l4
+
+  l4b:
+    add        ecx, 4 - 1
+    jl         l1b
+
+            // 1 pixel loop
+  l1:
+    movd       xmm2, dword ptr [eax]  // 1 argb pixel
+    lea        eax, [eax + 4]
+    punpcklbw  xmm2, xmm1
+    punpcklwd  xmm2, xmm1
+    paddd      xmm0, xmm2
+    movdqu     xmm2, [esi]
+    lea        esi, [esi + 16]
+    paddd      xmm2, xmm0
+    movdqu     [edx], xmm2
+    lea        edx, [edx + 16]
+    sub        ecx, 1
+    jge        l1
+
+ l1b:
+  }
+}
+#endif  // HAS_COMPUTECUMULATIVESUMROW_SSE2
+
+#ifdef HAS_ARGBAFFINEROW_SSE2
+// Copy ARGB pixels from source image with slope to a row of destination.
+__declspec(naked) LIBYUV_API void ARGBAffineRow_SSE2(const uint8_t* src_argb,
+                                                     int src_argb_stride,
+                                                     uint8_t* dst_argb,
+                                                     const float* uv_dudv,
+                                                     int width) {
+  __asm {
+    push       esi
+    push       edi
+    mov        eax, [esp + 12]  // src_argb
+    mov        esi, [esp + 16]  // stride
+    mov        edx, [esp + 20]  // dst_argb
+    mov        ecx, [esp + 24]  // pointer to uv_dudv
+    movq       xmm2, qword ptr [ecx]  // uv
+    movq       xmm7, qword ptr [ecx + 8]  // dudv
+    mov        ecx, [esp + 28]  // width
+    shl        esi, 16  // 4, stride
+    add        esi, 4
+    movd       xmm5, esi
+    sub        ecx, 4
+    jl         l4b
+
+        // setup for 4 pixel loop
+    pshufd     xmm7, xmm7, 0x44  // dup dudv
+    pshufd     xmm5, xmm5, 0  // dup 4, stride
+    movdqa     xmm0, xmm2  // x0, y0, x1, y1
+    addps      xmm0, xmm7
+    movlhps    xmm2, xmm0
+    movdqa     xmm4, xmm7
+    addps      xmm4, xmm4  // dudv *= 2
+    movdqa     xmm3, xmm2  // x2, y2, x3, y3
+    addps      xmm3, xmm4
+    addps      xmm4, xmm4  // dudv *= 4
+
+        // 4 pixel loop
+  l4:
+    cvttps2dq  xmm0, xmm2  // x, y float to int first 2
+    cvttps2dq  xmm1, xmm3  // x, y float to int next 2
+    packssdw   xmm0, xmm1  // x, y as 8 shorts
+    pmaddwd    xmm0, xmm5  // offsets = x * 4 + y * stride.
+    movd       esi, xmm0
+    pshufd     xmm0, xmm0, 0x39  // shift right
+    movd       edi, xmm0
+    pshufd     xmm0, xmm0, 0x39  // shift right
+    movd       xmm1, [eax + esi]  // read pixel 0
+    movd       xmm6, [eax + edi]  // read pixel 1
+    punpckldq  xmm1, xmm6  // combine pixel 0 and 1
+    addps      xmm2, xmm4  // x, y += dx, dy first 2
+    movq       qword ptr [edx], xmm1
+    movd       esi, xmm0
+    pshufd     xmm0, xmm0, 0x39  // shift right
+    movd       edi, xmm0
+    movd       xmm6, [eax + esi]  // read pixel 2
+    movd       xmm0, [eax + edi]  // read pixel 3
+    punpckldq  xmm6, xmm0  // combine pixel 2 and 3
+    addps      xmm3, xmm4  // x, y += dx, dy next 2
+    movq       qword ptr 8[edx], xmm6
+    lea        edx, [edx + 16]
+    sub        ecx, 4
+    jge        l4
+
+  l4b:
+    add        ecx, 4 - 1
+    jl         l1b
+
+            // 1 pixel loop
+  l1:
+    cvttps2dq  xmm0, xmm2  // x, y float to int
+    packssdw   xmm0, xmm0  // x, y as shorts
+    pmaddwd    xmm0, xmm5  // offset = x * 4 + y * stride
+    addps      xmm2, xmm7  // x, y += dx, dy
+    movd       esi, xmm0
+    movd       xmm0, [eax + esi]  // copy a pixel
+    movd       [edx], xmm0
+    lea        edx, [edx + 4]
+    sub        ecx, 1
+    jge        l1
+  l1b:
+    pop        edi
+    pop        esi
+    ret
+  }
+}
+#endif  // HAS_ARGBAFFINEROW_SSE2
+
+#ifdef HAS_INTERPOLATEROW_AVX2
+// Bilinear filter 32x2 -> 32x1
+__declspec(naked) void InterpolateRow_AVX2(uint8_t* dst_ptr,
+                                           const uint8_t* src_ptr,
+                                           ptrdiff_t src_stride,
+                                           int dst_width,
+                                           int source_y_fraction) {
+  __asm {
+    push       esi
+    push       edi
+    mov        edi, [esp + 8 + 4]  // dst_ptr
+    mov        esi, [esp + 8 + 8]  // src_ptr
+    mov        edx, [esp + 8 + 12]  // src_stride
+    mov        ecx, [esp + 8 + 16]  // dst_width
+    mov        eax, [esp + 8 + 20]  // source_y_fraction (0..255)
+    // Dispatch to specialized filters if applicable.
+    cmp        eax, 0
+    je         xloop100  // 0 / 256.  Blend 100 / 0.
+    sub        edi, esi
+    cmp        eax, 128
+    je         xloop50  // 128 /256 is 0.50.  Blend 50 / 50.
+
+    vmovd      xmm0, eax  // high fraction 0..255
+    neg        eax
+    add        eax, 256
+    vmovd      xmm5, eax  // low fraction 256..1
+    vpunpcklbw xmm5, xmm5, xmm0
+    vpunpcklwd xmm5, xmm5, xmm5
+    vbroadcastss ymm5, xmm5
+
+    mov        eax, 0x80808080  // 128b for bias and rounding.
+    vmovd      xmm4, eax
+    vbroadcastss ymm4, xmm4
+
+  xloop:
+    vmovdqu    ymm0, [esi]
+    vmovdqu    ymm2, [esi + edx]
+    vpunpckhbw ymm1, ymm0, ymm2  // mutates
+    vpunpcklbw ymm0, ymm0, ymm2
+    vpsubb     ymm1, ymm1, ymm4  // bias to signed image
+    vpsubb     ymm0, ymm0, ymm4
+    vpmaddubsw ymm1, ymm5, ymm1
+    vpmaddubsw ymm0, ymm5, ymm0
+    vpaddw     ymm1, ymm1, ymm4  // unbias and round
+    vpaddw     ymm0, ymm0, ymm4
+    vpsrlw     ymm1, ymm1, 8
+    vpsrlw     ymm0, ymm0, 8
+    vpackuswb  ymm0, ymm0, ymm1            // unmutates
+    vmovdqu    [esi + edi], ymm0
+    lea        esi, [esi + 32]
+    sub        ecx, 32
+    jg         xloop
+    jmp        xloop99
+
+        // Blend 50 / 50.
+ xloop50:
+   vmovdqu    ymm0, [esi]
+   vpavgb     ymm0, ymm0, [esi + edx]
+   vmovdqu    [esi + edi], ymm0
+   lea        esi, [esi + 32]
+   sub        ecx, 32
+   jg         xloop50
+   jmp        xloop99
+
+        // Blend 100 / 0 - Copy row unchanged.
+ xloop100:
+   rep movsb
+
+  xloop99:
+    pop        edi
+    pop        esi
+    vzeroupper
+    ret
+  }
+}
+#endif  // HAS_INTERPOLATEROW_AVX2
+
+// Bilinear filter 16x2 -> 16x1
+// TODO(fbarchard): Consider allowing 256 using memcpy.
+__declspec(naked) void InterpolateRow_SSSE3(uint8_t* dst_ptr,
+                                            const uint8_t* src_ptr,
+                                            ptrdiff_t src_stride,
+                                            int dst_width,
+                                            int source_y_fraction) {
+  __asm {
+    push       esi
+    push       edi
+
+    mov        edi, [esp + 8 + 4]  // dst_ptr
+    mov        esi, [esp + 8 + 8]  // src_ptr
+    mov        edx, [esp + 8 + 12]  // src_stride
+    mov        ecx, [esp + 8 + 16]  // dst_width
+    mov        eax, [esp + 8 + 20]  // source_y_fraction (0..255)
+    sub        edi, esi
+        // Dispatch to specialized filters if applicable.
+    cmp        eax, 0
+    je         xloop100  // 0 /256.  Blend 100 / 0.
+    cmp        eax, 128
+    je         xloop50  // 128 / 256 is 0.50.  Blend 50 / 50.
+
+    movd       xmm0, eax  // high fraction 0..255
+    neg        eax
+    add        eax, 256
+    movd       xmm5, eax  // low fraction 255..1
+    punpcklbw  xmm5, xmm0
+    punpcklwd  xmm5, xmm5
+    pshufd     xmm5, xmm5, 0
+    mov        eax, 0x80808080  // 128 for biasing image to signed.
+    movd       xmm4, eax
+    pshufd     xmm4, xmm4, 0x00
+
+  xloop:
+    movdqu     xmm0, [esi]
+    movdqu     xmm2, [esi + edx]
+    movdqu     xmm1, xmm0
+    punpcklbw  xmm0, xmm2
+    punpckhbw  xmm1, xmm2
+    psubb      xmm0, xmm4            // bias image by -128
+    psubb      xmm1, xmm4
+    movdqa     xmm2, xmm5
+    movdqa     xmm3, xmm5
+    pmaddubsw  xmm2, xmm0
+    pmaddubsw  xmm3, xmm1
+    paddw      xmm2, xmm4
+    paddw      xmm3, xmm4
+    psrlw      xmm2, 8
+    psrlw      xmm3, 8
+    packuswb   xmm2, xmm3
+    movdqu     [esi + edi], xmm2
+    lea        esi, [esi + 16]
+    sub        ecx, 16
+    jg         xloop
+    jmp        xloop99
+
+        // Blend 50 / 50.
+  xloop50:
+    movdqu     xmm0, [esi]
+    movdqu     xmm1, [esi + edx]
+    pavgb      xmm0, xmm1
+    movdqu     [esi + edi], xmm0
+    lea        esi, [esi + 16]
+    sub        ecx, 16
+    jg         xloop50
+    jmp        xloop99
+
+        // Blend 100 / 0 - Copy row unchanged.
+  xloop100:
+    movdqu     xmm0, [esi]
+    movdqu     [esi + edi], xmm0
+    lea        esi, [esi + 16]
+    sub        ecx, 16
+    jg         xloop100
+
+  xloop99:
+    pop        edi
+    pop        esi
+    ret
+  }
+}
+
+// For BGRAToARGB, ABGRToARGB, RGBAToARGB, and ARGBToRGBA.
+__declspec(naked) void ARGBShuffleRow_SSSE3(const uint8_t* src_argb,
+                                            uint8_t* dst_argb,
+                                            const uint8_t* shuffler,
+                                            int width) {
+  __asm {
+    mov        eax, [esp + 4]  // src_argb
+    mov        edx, [esp + 8]  // dst_argb
+    mov        ecx, [esp + 12]  // shuffler
+    movdqu     xmm5, [ecx]
+    mov        ecx, [esp + 16]  // width
+
+  wloop:
+    movdqu     xmm0, [eax]
+    movdqu     xmm1, [eax + 16]
+    lea        eax, [eax + 32]
+    pshufb     xmm0, xmm5
+    pshufb     xmm1, xmm5
+    movdqu     [edx], xmm0
+    movdqu     [edx + 16], xmm1
+    lea        edx, [edx + 32]
+    sub        ecx, 8
+    jg         wloop
+    ret
+  }
+}
+
+#ifdef HAS_ARGBSHUFFLEROW_AVX2
+__declspec(naked) void ARGBShuffleRow_AVX2(const uint8_t* src_argb,
+                                           uint8_t* dst_argb,
+                                           const uint8_t* shuffler,
+                                           int width) {
+  __asm {
+    mov        eax, [esp + 4]  // src_argb
+    mov        edx, [esp + 8]  // dst_argb
+    mov        ecx, [esp + 12]  // shuffler
+    vbroadcastf128 ymm5, [ecx]  // same shuffle in high as low.
+    mov        ecx, [esp + 16]  // width
+
+  wloop:
+    vmovdqu    ymm0, [eax]
+    vmovdqu    ymm1, [eax + 32]
+    lea        eax, [eax + 64]
+    vpshufb    ymm0, ymm0, ymm5
+    vpshufb    ymm1, ymm1, ymm5
+    vmovdqu    [edx], ymm0
+    vmovdqu    [edx + 32], ymm1
+    lea        edx, [edx + 64]
+    sub        ecx, 16
+    jg         wloop
+
+    vzeroupper
+    ret
+  }
+}
+#endif  // HAS_ARGBSHUFFLEROW_AVX2
+
+// YUY2 - Macro-pixel = 2 image pixels
+// Y0U0Y1V0....Y2U2Y3V2...Y4U4Y5V4....
+
+// UYVY - Macro-pixel = 2 image pixels
+// U0Y0V0Y1
+
+__declspec(naked) void I422ToYUY2Row_SSE2(const uint8_t* src_y,
+                                          const uint8_t* src_u,
+                                          const uint8_t* src_v,
+                                          uint8_t* dst_frame,
+                                          int width) {
+  __asm {
+    push       esi
+    push       edi
+    mov        eax, [esp + 8 + 4]  // src_y
+    mov        esi, [esp + 8 + 8]  // src_u
+    mov        edx, [esp + 8 + 12]  // src_v
+    mov        edi, [esp + 8 + 16]  // dst_frame
+    mov        ecx, [esp + 8 + 20]  // width
+    sub        edx, esi
+
+  convertloop:
+    movq       xmm2, qword ptr [esi]  // U
+    movq       xmm3, qword ptr [esi + edx]  // V
+    lea        esi, [esi + 8]
+    punpcklbw  xmm2, xmm3  // UV
+    movdqu     xmm0, [eax]  // Y
+    lea        eax, [eax + 16]
+    movdqa     xmm1, xmm0
+    punpcklbw  xmm0, xmm2  // YUYV
+    punpckhbw  xmm1, xmm2
+    movdqu     [edi], xmm0
+    movdqu     [edi + 16], xmm1
+    lea        edi, [edi + 32]
+    sub        ecx, 16
+    jg         convertloop
+
+    pop        edi
+    pop        esi
+    ret
+  }
+}
+
+__declspec(naked) void I422ToUYVYRow_SSE2(const uint8_t* src_y,
+                                          const uint8_t* src_u,
+                                          const uint8_t* src_v,
+                                          uint8_t* dst_frame,
+                                          int width) {
+  __asm {
+    push       esi
+    push       edi
+    mov        eax, [esp + 8 + 4]  // src_y
+    mov        esi, [esp + 8 + 8]  // src_u
+    mov        edx, [esp + 8 + 12]  // src_v
+    mov        edi, [esp + 8 + 16]  // dst_frame
+    mov        ecx, [esp + 8 + 20]  // width
+    sub        edx, esi
+
+  convertloop:
+    movq       xmm2, qword ptr [esi]  // U
+    movq       xmm3, qword ptr [esi + edx]  // V
+    lea        esi, [esi + 8]
+    punpcklbw  xmm2, xmm3  // UV
+    movdqu     xmm0, [eax]  // Y
+    movdqa     xmm1, xmm2
+    lea        eax, [eax + 16]
+    punpcklbw  xmm1, xmm0  // UYVY
+    punpckhbw  xmm2, xmm0
+    movdqu     [edi], xmm1
+    movdqu     [edi + 16], xmm2
+    lea        edi, [edi + 32]
+    sub        ecx, 16
+    jg         convertloop
+
+    pop        edi
+    pop        esi
+    ret
+  }
+}
+
+#ifdef HAS_ARGBPOLYNOMIALROW_SSE2
+__declspec(naked) void ARGBPolynomialRow_SSE2(const uint8_t* src_argb,
+                                              uint8_t* dst_argb,
+                                              const float* poly,
+                                              int width) {
+  __asm {
+    push       esi
+    mov        eax, [esp + 4 + 4] /* src_argb */
+    mov        edx, [esp + 4 + 8] /* dst_argb */
+    mov        esi, [esp + 4 + 12] /* poly */
+    mov        ecx, [esp + 4 + 16] /* width */
+    pxor       xmm3, xmm3  // 0 constant for zero extending bytes to ints.
+
+        // 2 pixel loop.
+ convertloop:
+        //    pmovzxbd  xmm0, dword ptr [eax]  // BGRA pixel
+        //    pmovzxbd  xmm4, dword ptr [eax + 4]  // BGRA pixel
+    movq       xmm0, qword ptr [eax]  // BGRABGRA
+    lea        eax, [eax + 8]
+    punpcklbw  xmm0, xmm3
+    movdqa     xmm4, xmm0
+    punpcklwd  xmm0, xmm3  // pixel 0
+    punpckhwd  xmm4, xmm3  // pixel 1
+    cvtdq2ps   xmm0, xmm0  // 4 floats
+    cvtdq2ps   xmm4, xmm4
+    movdqa     xmm1, xmm0  // X
+    movdqa     xmm5, xmm4
+    mulps      xmm0, [esi + 16]  // C1 * X
+    mulps      xmm4, [esi + 16]
+    addps      xmm0, [esi]  // result = C0 + C1 * X
+    addps      xmm4, [esi]
+    movdqa     xmm2, xmm1
+    movdqa     xmm6, xmm5
+    mulps      xmm2, xmm1  // X * X
+    mulps      xmm6, xmm5
+    mulps      xmm1, xmm2  // X * X * X
+    mulps      xmm5, xmm6
+    mulps      xmm2, [esi + 32]  // C2 * X * X
+    mulps      xmm6, [esi + 32]
+    mulps      xmm1, [esi + 48]  // C3 * X * X * X
+    mulps      xmm5, [esi + 48]
+    addps      xmm0, xmm2  // result += C2 * X * X
+    addps      xmm4, xmm6
+    addps      xmm0, xmm1  // result += C3 * X * X * X
+    addps      xmm4, xmm5
+    cvttps2dq  xmm0, xmm0
+    cvttps2dq  xmm4, xmm4
+    packuswb   xmm0, xmm4
+    packuswb   xmm0, xmm0
+    movq       qword ptr [edx], xmm0
+    lea        edx, [edx + 8]
+    sub        ecx, 2
+    jg         convertloop
+    pop        esi
+    ret
+  }
+}
+#endif  // HAS_ARGBPOLYNOMIALROW_SSE2
+
+#ifdef HAS_ARGBPOLYNOMIALROW_AVX2
+__declspec(naked) void ARGBPolynomialRow_AVX2(const uint8_t* src_argb,
+                                              uint8_t* dst_argb,
+                                              const float* poly,
+                                              int width) {
+  __asm {
+    mov        eax, [esp + 4] /* src_argb */
+    mov        edx, [esp + 8] /* dst_argb */
+    mov        ecx, [esp + 12] /* poly */
+    vbroadcastf128 ymm4, [ecx]  // C0
+    vbroadcastf128 ymm5, [ecx + 16]  // C1
+    vbroadcastf128 ymm6, [ecx + 32]  // C2
+    vbroadcastf128 ymm7, [ecx + 48]  // C3
+    mov        ecx, [esp + 16] /* width */
+
+    // 2 pixel loop.
+ convertloop:
+    vpmovzxbd   ymm0, qword ptr [eax]  // 2 BGRA pixels
+    lea         eax, [eax + 8]
+    vcvtdq2ps   ymm0, ymm0  // X 8 floats
+    vmulps      ymm2, ymm0, ymm0  // X * X
+    vmulps      ymm3, ymm0, ymm7  // C3 * X
+    vfmadd132ps ymm0, ymm4, ymm5  // result = C0 + C1 * X
+    vfmadd231ps ymm0, ymm2, ymm6  // result += C2 * X * X
+    vfmadd231ps ymm0, ymm2, ymm3  // result += C3 * X * X * X
+    vcvttps2dq  ymm0, ymm0
+    vpackusdw   ymm0, ymm0, ymm0  // b0g0r0a0_00000000_b0g0r0a0_00000000
+    vpermq      ymm0, ymm0, 0xd8  // b0g0r0a0_b0g0r0a0_00000000_00000000
+    vpackuswb   xmm0, xmm0, xmm0  // bgrabgra_00000000_00000000_00000000
+    vmovq       qword ptr [edx], xmm0
+    lea         edx, [edx + 8]
+    sub         ecx, 2
+    jg          convertloop
+    vzeroupper
+    ret
+  }
+}
+#endif  // HAS_ARGBPOLYNOMIALROW_AVX2
+
+#ifdef HAS_HALFFLOATROW_SSE2
+static float kExpBias = 1.9259299444e-34f;
+__declspec(naked) void HalfFloatRow_SSE2(const uint16_t* src,
+                                         uint16_t* dst,
+                                         float scale,
+                                         int width) {
+  __asm {
+    mov        eax, [esp + 4] /* src */
+    mov        edx, [esp + 8] /* dst */
+    movd       xmm4, dword ptr [esp + 12] /* scale */
+    mov        ecx, [esp + 16] /* width */
+    mulss      xmm4, kExpBias
+    pshufd     xmm4, xmm4, 0
+    pxor       xmm5, xmm5
+    sub        edx, eax
+
+        // 8 pixel loop.
+ convertloop:
+    movdqu      xmm2, xmmword ptr [eax]  // 8 shorts
+    add         eax, 16
+    movdqa      xmm3, xmm2
+    punpcklwd   xmm2, xmm5
+    cvtdq2ps    xmm2, xmm2  // convert 8 ints to floats
+    punpckhwd   xmm3, xmm5
+    cvtdq2ps    xmm3, xmm3
+    mulps       xmm2, xmm4
+    mulps       xmm3, xmm4
+    psrld       xmm2, 13
+    psrld       xmm3, 13
+    packssdw    xmm2, xmm3
+    movdqu      [eax + edx - 16], xmm2
+    sub         ecx, 8
+    jg          convertloop
+    ret
+  }
+}
+#endif  // HAS_HALFFLOATROW_SSE2
+
+#ifdef HAS_HALFFLOATROW_AVX2
+__declspec(naked) void HalfFloatRow_AVX2(const uint16_t* src,
+                                         uint16_t* dst,
+                                         float scale,
+                                         int width) {
+  __asm {
+    mov        eax, [esp + 4] /* src */
+    mov        edx, [esp + 8] /* dst */
+    movd       xmm4, dword ptr [esp + 12] /* scale */
+    mov        ecx, [esp + 16] /* width */
+
+    vmulss     xmm4, xmm4, kExpBias
+    vbroadcastss ymm4, xmm4
+    vpxor      ymm5, ymm5, ymm5
+    sub        edx, eax
+
+        // 16 pixel loop.
+ convertloop:
+    vmovdqu     ymm2, [eax]  // 16 shorts
+    add         eax, 32
+    vpunpckhwd  ymm3, ymm2, ymm5  // convert 16 shorts to 16 ints
+    vpunpcklwd  ymm2, ymm2, ymm5
+    vcvtdq2ps   ymm3, ymm3  // convert 16 ints to floats
+    vcvtdq2ps   ymm2, ymm2
+    vmulps      ymm3, ymm3, ymm4  // scale to adjust exponent for 5 bit range.
+    vmulps      ymm2, ymm2, ymm4
+    vpsrld      ymm3, ymm3, 13  // float convert to 8 half floats truncate
+    vpsrld      ymm2, ymm2, 13
+    vpackssdw   ymm2, ymm2, ymm3
+    vmovdqu     [eax + edx - 32], ymm2
+    sub         ecx, 16
+    jg          convertloop
+    vzeroupper
+    ret
+  }
+}
+#endif  // HAS_HALFFLOATROW_AVX2
+
+#ifdef HAS_HALFFLOATROW_F16C
+__declspec(naked) void HalfFloatRow_F16C(const uint16_t* src,
+                                         uint16_t* dst,
+                                         float scale,
+                                         int width) {
+  __asm {
+    mov        eax, [esp + 4] /* src */
+    mov        edx, [esp + 8] /* dst */
+    vbroadcastss ymm4, [esp + 12] /* scale */
+    mov        ecx, [esp + 16] /* width */
+    sub        edx, eax
+
+        // 16 pixel loop.
+ convertloop:
+    vpmovzxwd   ymm2, xmmword ptr [eax]  // 8 shorts -> 8 ints
+    vpmovzxwd   ymm3, xmmword ptr [eax + 16]  // 8 more shorts
+    add         eax, 32
+    vcvtdq2ps   ymm2, ymm2  // convert 8 ints to floats
+    vcvtdq2ps   ymm3, ymm3
+    vmulps      ymm2, ymm2, ymm4  // scale to normalized range 0 to 1
+    vmulps      ymm3, ymm3, ymm4
+    vcvtps2ph   xmm2, ymm2, 3  // float convert to 8 half floats truncate
+    vcvtps2ph   xmm3, ymm3, 3
+    vmovdqu     [eax + edx + 32], xmm2
+    vmovdqu     [eax + edx + 32 + 16], xmm3
+    sub         ecx, 16
+    jg          convertloop
+    vzeroupper
+    ret
+  }
+}
+#endif  // HAS_HALFFLOATROW_F16C
+
+#ifdef HAS_ARGBCOLORTABLEROW_X86
+// Tranform ARGB pixels with color table.
+__declspec(naked) void ARGBColorTableRow_X86(uint8_t* dst_argb,
+                                             const uint8_t* table_argb,
+                                             int width) {
+  __asm {
+    push       esi
+    mov        eax, [esp + 4 + 4] /* dst_argb */
+    mov        esi, [esp + 4 + 8] /* table_argb */
+    mov        ecx, [esp + 4 + 12] /* width */
+
+    // 1 pixel loop.
+  convertloop:
+    movzx      edx, byte ptr [eax]
+    lea        eax, [eax + 4]
+    movzx      edx, byte ptr [esi + edx * 4]
+    mov        byte ptr [eax - 4], dl
+    movzx      edx, byte ptr [eax - 4 + 1]
+    movzx      edx, byte ptr [esi + edx * 4 + 1]
+    mov        byte ptr [eax - 4 + 1], dl
+    movzx      edx, byte ptr [eax - 4 + 2]
+    movzx      edx, byte ptr [esi + edx * 4 + 2]
+    mov        byte ptr [eax - 4 + 2], dl
+    movzx      edx, byte ptr [eax - 4 + 3]
+    movzx      edx, byte ptr [esi + edx * 4 + 3]
+    mov        byte ptr [eax - 4 + 3], dl
+    dec        ecx
+    jg         convertloop
+    pop        esi
+    ret
+  }
+}
+#endif  // HAS_ARGBCOLORTABLEROW_X86
+
+#ifdef HAS_RGBCOLORTABLEROW_X86
+// Tranform RGB pixels with color table.
+__declspec(naked) void RGBColorTableRow_X86(uint8_t* dst_argb,
+                                            const uint8_t* table_argb,
+                                            int width) {
+  __asm {
+    push       esi
+    mov        eax, [esp + 4 + 4] /* dst_argb */
+    mov        esi, [esp + 4 + 8] /* table_argb */
+    mov        ecx, [esp + 4 + 12] /* width */
+
+    // 1 pixel loop.
+  convertloop:
+    movzx      edx, byte ptr [eax]
+    lea        eax, [eax + 4]
+    movzx      edx, byte ptr [esi + edx * 4]
+    mov        byte ptr [eax - 4], dl
+    movzx      edx, byte ptr [eax - 4 + 1]
+    movzx      edx, byte ptr [esi + edx * 4 + 1]
+    mov        byte ptr [eax - 4 + 1], dl
+    movzx      edx, byte ptr [eax - 4 + 2]
+    movzx      edx, byte ptr [esi + edx * 4 + 2]
+    mov        byte ptr [eax - 4 + 2], dl
+    dec        ecx
+    jg         convertloop
+
+    pop        esi
+    ret
+  }
+}
+#endif  // HAS_RGBCOLORTABLEROW_X86
+
+#ifdef HAS_ARGBLUMACOLORTABLEROW_SSSE3
+// Tranform RGB pixels with luma table.
+__declspec(naked) void ARGBLumaColorTableRow_SSSE3(const uint8_t* src_argb,
+                                                   uint8_t* dst_argb,
+                                                   int width,
+                                                   const uint8_t* luma,
+                                                   uint32_t lumacoeff) {
+  __asm {
+    push       esi
+    push       edi
+    mov        eax, [esp + 8 + 4] /* src_argb */
+    mov        edi, [esp + 8 + 8] /* dst_argb */
+    mov        ecx, [esp + 8 + 12] /* width */
+    movd       xmm2, dword ptr [esp + 8 + 16]  // luma table
+    movd       xmm3, dword ptr [esp + 8 + 20]  // lumacoeff
+    pshufd     xmm2, xmm2, 0
+    pshufd     xmm3, xmm3, 0
+    pcmpeqb    xmm4, xmm4  // generate mask 0xff00ff00
+    psllw      xmm4, 8
+    pxor       xmm5, xmm5
+
+        // 4 pixel loop.
+  convertloop:
+    movdqu     xmm0, xmmword ptr [eax]  // generate luma ptr
+    pmaddubsw  xmm0, xmm3
+    phaddw     xmm0, xmm0
+    pand       xmm0, xmm4  // mask out low bits
+    punpcklwd  xmm0, xmm5
+    paddd      xmm0, xmm2  // add table base
+    movd       esi, xmm0
+    pshufd     xmm0, xmm0, 0x39  // 00111001 to rotate right 32
+
+    movzx      edx, byte ptr [eax]
+    movzx      edx, byte ptr [esi + edx]
+    mov        byte ptr [edi], dl
+    movzx      edx, byte ptr [eax + 1]
+    movzx      edx, byte ptr [esi + edx]
+    mov        byte ptr [edi + 1], dl
+    movzx      edx, byte ptr [eax + 2]
+    movzx      edx, byte ptr [esi + edx]
+    mov        byte ptr [edi + 2], dl
+    movzx      edx, byte ptr [eax + 3]  // copy alpha.
+    mov        byte ptr [edi + 3], dl
+
+    movd       esi, xmm0
+    pshufd     xmm0, xmm0, 0x39  // 00111001 to rotate right 32
+
+    movzx      edx, byte ptr [eax + 4]
+    movzx      edx, byte ptr [esi + edx]
+    mov        byte ptr [edi + 4], dl
+    movzx      edx, byte ptr [eax + 5]
+    movzx      edx, byte ptr [esi + edx]
+    mov        byte ptr [edi + 5], dl
+    movzx      edx, byte ptr [eax + 6]
+    movzx      edx, byte ptr [esi + edx]
+    mov        byte ptr [edi + 6], dl
+    movzx      edx, byte ptr [eax + 7]  // copy alpha.
+    mov        byte ptr [edi + 7], dl
+
+    movd       esi, xmm0
+    pshufd     xmm0, xmm0, 0x39  // 00111001 to rotate right 32
+
+    movzx      edx, byte ptr [eax + 8]
+    movzx      edx, byte ptr [esi + edx]
+    mov        byte ptr [edi + 8], dl
+    movzx      edx, byte ptr [eax + 9]
+    movzx      edx, byte ptr [esi + edx]
+    mov        byte ptr [edi + 9], dl
+    movzx      edx, byte ptr [eax + 10]
+    movzx      edx, byte ptr [esi + edx]
+    mov        byte ptr [edi + 10], dl
+    movzx      edx, byte ptr [eax + 11]  // copy alpha.
+    mov        byte ptr [edi + 11], dl
+
+    movd       esi, xmm0
+
+    movzx      edx, byte ptr [eax + 12]
+    movzx      edx, byte ptr [esi + edx]
+    mov        byte ptr [edi + 12], dl
+    movzx      edx, byte ptr [eax + 13]
+    movzx      edx, byte ptr [esi + edx]
+    mov        byte ptr [edi + 13], dl
+    movzx      edx, byte ptr [eax + 14]
+    movzx      edx, byte ptr [esi + edx]
+    mov        byte ptr [edi + 14], dl
+    movzx      edx, byte ptr [eax + 15]  // copy alpha.
+    mov        byte ptr [edi + 15], dl
+
+    lea        eax, [eax + 16]
+    lea        edi, [edi + 16]
+    sub        ecx, 4
+    jg         convertloop
+
+    pop        edi
+    pop        esi
+    ret
+  }
+}
+#endif  // HAS_ARGBLUMACOLORTABLEROW_SSSE3
+
+#endif  // defined(_M_X64)
+
+#ifdef __cplusplus
+}  // extern "C"
+}  // namespace libyuv
+#endif
+
+#endif  // !defined(LIBYUV_DISABLE_X86) && (defined(_M_IX86) || defined(_M_X64))
diff --git a/3rdparty/libyuv/src/source/scale.cc b/3rdparty/libyuv/src/source/scale.cc
new file mode 100644
index 00000000..8147c291
--- /dev/null
+++ b/3rdparty/libyuv/src/source/scale.cc
@@ -0,0 +1,2537 @@
+/*
+ *  Copyright 2011 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include "libyuv/scale.h"
+
+#include <assert.h>
+#include <string.h>
+
+#include "libyuv/cpu_id.h"
+#include "libyuv/planar_functions.h"  // For CopyPlane
+#include "libyuv/row.h"
+#include "libyuv/scale_row.h"
+#include "libyuv/scale_uv.h"  // For UVScale
+
+#ifdef __cplusplus
+namespace libyuv {
+extern "C" {
+#endif
+
+static __inline int Abs(int v) {
+  return v >= 0 ? v : -v;
+}
+
+#define SUBSAMPLE(v, a, s) (v < 0) ? (-((-v + a) >> s)) : ((v + a) >> s)
+#define CENTERSTART(dx, s) (dx < 0) ? -((-dx >> 1) + s) : ((dx >> 1) + s)
+
+// Scale plane, 1/2
+// This is an optimized version for scaling down a plane to 1/2 of
+// its original size.
+
+static void ScalePlaneDown2(int src_width,
+                            int src_height,
+                            int dst_width,
+                            int dst_height,
+                            int src_stride,
+                            int dst_stride,
+                            const uint8_t* src_ptr,
+                            uint8_t* dst_ptr,
+                            enum FilterMode filtering) {
+  int y;
+  void (*ScaleRowDown2)(const uint8_t* src_ptr, ptrdiff_t src_stride,
+                        uint8_t* dst_ptr, int dst_width) =
+      filtering == kFilterNone
+          ? ScaleRowDown2_C
+          : (filtering == kFilterLinear ? ScaleRowDown2Linear_C
+                                        : ScaleRowDown2Box_C);
+  int row_stride = src_stride * 2;
+  (void)src_width;
+  (void)src_height;
+  if (!filtering) {
+    src_ptr += src_stride;  // Point to odd rows.
+    src_stride = 0;
+  }
+
+#if defined(HAS_SCALEROWDOWN2_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    ScaleRowDown2 =
+        filtering == kFilterNone
+            ? ScaleRowDown2_Any_NEON
+            : (filtering == kFilterLinear ? ScaleRowDown2Linear_Any_NEON
+                                          : ScaleRowDown2Box_Any_NEON);
+    if (IS_ALIGNED(dst_width, 16)) {
+      ScaleRowDown2 = filtering == kFilterNone ? ScaleRowDown2_NEON
+                                               : (filtering == kFilterLinear
+                                                      ? ScaleRowDown2Linear_NEON
+                                                      : ScaleRowDown2Box_NEON);
+    }
+  }
+#endif
+#if defined(HAS_SCALEROWDOWN2_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    ScaleRowDown2 =
+        filtering == kFilterNone
+            ? ScaleRowDown2_Any_SSSE3
+            : (filtering == kFilterLinear ? ScaleRowDown2Linear_Any_SSSE3
+                                          : ScaleRowDown2Box_Any_SSSE3);
+    if (IS_ALIGNED(dst_width, 16)) {
+      ScaleRowDown2 =
+          filtering == kFilterNone
+              ? ScaleRowDown2_SSSE3
+              : (filtering == kFilterLinear ? ScaleRowDown2Linear_SSSE3
+                                            : ScaleRowDown2Box_SSSE3);
+    }
+  }
+#endif
+#if defined(HAS_SCALEROWDOWN2_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ScaleRowDown2 =
+        filtering == kFilterNone
+            ? ScaleRowDown2_Any_AVX2
+            : (filtering == kFilterLinear ? ScaleRowDown2Linear_Any_AVX2
+                                          : ScaleRowDown2Box_Any_AVX2);
+    if (IS_ALIGNED(dst_width, 32)) {
+      ScaleRowDown2 = filtering == kFilterNone ? ScaleRowDown2_AVX2
+                                               : (filtering == kFilterLinear
+                                                      ? ScaleRowDown2Linear_AVX2
+                                                      : ScaleRowDown2Box_AVX2);
+    }
+  }
+#endif
+#if defined(HAS_SCALEROWDOWN2_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    ScaleRowDown2 =
+        filtering == kFilterNone
+            ? ScaleRowDown2_Any_MSA
+            : (filtering == kFilterLinear ? ScaleRowDown2Linear_Any_MSA
+                                          : ScaleRowDown2Box_Any_MSA);
+    if (IS_ALIGNED(dst_width, 32)) {
+      ScaleRowDown2 = filtering == kFilterNone ? ScaleRowDown2_MSA
+                                               : (filtering == kFilterLinear
+                                                      ? ScaleRowDown2Linear_MSA
+                                                      : ScaleRowDown2Box_MSA);
+    }
+  }
+#endif
+#if defined(HAS_SCALEROWDOWN2_LSX)
+  if (TestCpuFlag(kCpuHasLSX)) {
+    ScaleRowDown2 =
+        filtering == kFilterNone
+            ? ScaleRowDown2_Any_LSX
+            : (filtering == kFilterLinear ? ScaleRowDown2Linear_Any_LSX
+                                          : ScaleRowDown2Box_Any_LSX);
+    if (IS_ALIGNED(dst_width, 32)) {
+      ScaleRowDown2 = filtering == kFilterNone ? ScaleRowDown2_LSX
+                                               : (filtering == kFilterLinear
+                                                      ? ScaleRowDown2Linear_LSX
+                                                      : ScaleRowDown2Box_LSX);
+    }
+  }
+#endif
+
+  if (filtering == kFilterLinear) {
+    src_stride = 0;
+  }
+  // TODO(fbarchard): Loop through source height to allow odd height.
+  for (y = 0; y < dst_height; ++y) {
+    ScaleRowDown2(src_ptr, src_stride, dst_ptr, dst_width);
+    src_ptr += row_stride;
+    dst_ptr += dst_stride;
+  }
+}
+
+static void ScalePlaneDown2_16(int src_width,
+                               int src_height,
+                               int dst_width,
+                               int dst_height,
+                               int src_stride,
+                               int dst_stride,
+                               const uint16_t* src_ptr,
+                               uint16_t* dst_ptr,
+                               enum FilterMode filtering) {
+  int y;
+  void (*ScaleRowDown2)(const uint16_t* src_ptr, ptrdiff_t src_stride,
+                        uint16_t* dst_ptr, int dst_width) =
+      filtering == kFilterNone
+          ? ScaleRowDown2_16_C
+          : (filtering == kFilterLinear ? ScaleRowDown2Linear_16_C
+                                        : ScaleRowDown2Box_16_C);
+  int row_stride = src_stride * 2;
+  (void)src_width;
+  (void)src_height;
+  if (!filtering) {
+    src_ptr += src_stride;  // Point to odd rows.
+    src_stride = 0;
+  }
+
+#if defined(HAS_SCALEROWDOWN2_16_NEON)
+  if (TestCpuFlag(kCpuHasNEON) && IS_ALIGNED(dst_width, 16)) {
+    ScaleRowDown2 =
+        filtering ? ScaleRowDown2Box_16_NEON : ScaleRowDown2_16_NEON;
+  }
+#endif
+#if defined(HAS_SCALEROWDOWN2_16_SSE2)
+  if (TestCpuFlag(kCpuHasSSE2) && IS_ALIGNED(dst_width, 16)) {
+    ScaleRowDown2 =
+        filtering == kFilterNone
+            ? ScaleRowDown2_16_SSE2
+            : (filtering == kFilterLinear ? ScaleRowDown2Linear_16_SSE2
+                                          : ScaleRowDown2Box_16_SSE2);
+  }
+#endif
+
+  if (filtering == kFilterLinear) {
+    src_stride = 0;
+  }
+  // TODO(fbarchard): Loop through source height to allow odd height.
+  for (y = 0; y < dst_height; ++y) {
+    ScaleRowDown2(src_ptr, src_stride, dst_ptr, dst_width);
+    src_ptr += row_stride;
+    dst_ptr += dst_stride;
+  }
+}
+
+// Scale plane, 1/4
+// This is an optimized version for scaling down a plane to 1/4 of
+// its original size.
+
+static void ScalePlaneDown4(int src_width,
+                            int src_height,
+                            int dst_width,
+                            int dst_height,
+                            int src_stride,
+                            int dst_stride,
+                            const uint8_t* src_ptr,
+                            uint8_t* dst_ptr,
+                            enum FilterMode filtering) {
+  int y;
+  void (*ScaleRowDown4)(const uint8_t* src_ptr, ptrdiff_t src_stride,
+                        uint8_t* dst_ptr, int dst_width) =
+      filtering ? ScaleRowDown4Box_C : ScaleRowDown4_C;
+  int row_stride = src_stride * 4;
+  (void)src_width;
+  (void)src_height;
+  if (!filtering) {
+    src_ptr += src_stride * 2;  // Point to row 2.
+    src_stride = 0;
+  }
+#if defined(HAS_SCALEROWDOWN4_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    ScaleRowDown4 =
+        filtering ? ScaleRowDown4Box_Any_NEON : ScaleRowDown4_Any_NEON;
+    if (IS_ALIGNED(dst_width, 8)) {
+      ScaleRowDown4 = filtering ? ScaleRowDown4Box_NEON : ScaleRowDown4_NEON;
+    }
+  }
+#endif
+#if defined(HAS_SCALEROWDOWN4_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    ScaleRowDown4 =
+        filtering ? ScaleRowDown4Box_Any_SSSE3 : ScaleRowDown4_Any_SSSE3;
+    if (IS_ALIGNED(dst_width, 8)) {
+      ScaleRowDown4 = filtering ? ScaleRowDown4Box_SSSE3 : ScaleRowDown4_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_SCALEROWDOWN4_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ScaleRowDown4 =
+        filtering ? ScaleRowDown4Box_Any_AVX2 : ScaleRowDown4_Any_AVX2;
+    if (IS_ALIGNED(dst_width, 16)) {
+      ScaleRowDown4 = filtering ? ScaleRowDown4Box_AVX2 : ScaleRowDown4_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_SCALEROWDOWN4_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    ScaleRowDown4 =
+        filtering ? ScaleRowDown4Box_Any_MSA : ScaleRowDown4_Any_MSA;
+    if (IS_ALIGNED(dst_width, 16)) {
+      ScaleRowDown4 = filtering ? ScaleRowDown4Box_MSA : ScaleRowDown4_MSA;
+    }
+  }
+#endif
+#if defined(HAS_SCALEROWDOWN4_LSX)
+  if (TestCpuFlag(kCpuHasLSX)) {
+    ScaleRowDown4 =
+        filtering ? ScaleRowDown4Box_Any_LSX : ScaleRowDown4_Any_LSX;
+    if (IS_ALIGNED(dst_width, 16)) {
+      ScaleRowDown4 = filtering ? ScaleRowDown4Box_LSX : ScaleRowDown4_LSX;
+    }
+  }
+#endif
+
+  if (filtering == kFilterLinear) {
+    src_stride = 0;
+  }
+  for (y = 0; y < dst_height; ++y) {
+    ScaleRowDown4(src_ptr, src_stride, dst_ptr, dst_width);
+    src_ptr += row_stride;
+    dst_ptr += dst_stride;
+  }
+}
+
+static void ScalePlaneDown4_16(int src_width,
+                               int src_height,
+                               int dst_width,
+                               int dst_height,
+                               int src_stride,
+                               int dst_stride,
+                               const uint16_t* src_ptr,
+                               uint16_t* dst_ptr,
+                               enum FilterMode filtering) {
+  int y;
+  void (*ScaleRowDown4)(const uint16_t* src_ptr, ptrdiff_t src_stride,
+                        uint16_t* dst_ptr, int dst_width) =
+      filtering ? ScaleRowDown4Box_16_C : ScaleRowDown4_16_C;
+  int row_stride = src_stride * 4;
+  (void)src_width;
+  (void)src_height;
+  if (!filtering) {
+    src_ptr += src_stride * 2;  // Point to row 2.
+    src_stride = 0;
+  }
+#if defined(HAS_SCALEROWDOWN4_16_NEON)
+  if (TestCpuFlag(kCpuHasNEON) && IS_ALIGNED(dst_width, 8)) {
+    ScaleRowDown4 =
+        filtering ? ScaleRowDown4Box_16_NEON : ScaleRowDown4_16_NEON;
+  }
+#endif
+#if defined(HAS_SCALEROWDOWN4_16_SSE2)
+  if (TestCpuFlag(kCpuHasSSE2) && IS_ALIGNED(dst_width, 8)) {
+    ScaleRowDown4 =
+        filtering ? ScaleRowDown4Box_16_SSE2 : ScaleRowDown4_16_SSE2;
+  }
+#endif
+
+  if (filtering == kFilterLinear) {
+    src_stride = 0;
+  }
+  for (y = 0; y < dst_height; ++y) {
+    ScaleRowDown4(src_ptr, src_stride, dst_ptr, dst_width);
+    src_ptr += row_stride;
+    dst_ptr += dst_stride;
+  }
+}
+
+// Scale plane down, 3/4
+static void ScalePlaneDown34(int src_width,
+                             int src_height,
+                             int dst_width,
+                             int dst_height,
+                             int src_stride,
+                             int dst_stride,
+                             const uint8_t* src_ptr,
+                             uint8_t* dst_ptr,
+                             enum FilterMode filtering) {
+  int y;
+  void (*ScaleRowDown34_0)(const uint8_t* src_ptr, ptrdiff_t src_stride,
+                           uint8_t* dst_ptr, int dst_width);
+  void (*ScaleRowDown34_1)(const uint8_t* src_ptr, ptrdiff_t src_stride,
+                           uint8_t* dst_ptr, int dst_width);
+  const int filter_stride = (filtering == kFilterLinear) ? 0 : src_stride;
+  (void)src_width;
+  (void)src_height;
+  assert(dst_width % 3 == 0);
+  if (!filtering) {
+    ScaleRowDown34_0 = ScaleRowDown34_C;
+    ScaleRowDown34_1 = ScaleRowDown34_C;
+  } else {
+    ScaleRowDown34_0 = ScaleRowDown34_0_Box_C;
+    ScaleRowDown34_1 = ScaleRowDown34_1_Box_C;
+  }
+#if defined(HAS_SCALEROWDOWN34_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    if (!filtering) {
+      ScaleRowDown34_0 = ScaleRowDown34_Any_NEON;
+      ScaleRowDown34_1 = ScaleRowDown34_Any_NEON;
+    } else {
+      ScaleRowDown34_0 = ScaleRowDown34_0_Box_Any_NEON;
+      ScaleRowDown34_1 = ScaleRowDown34_1_Box_Any_NEON;
+    }
+    if (dst_width % 24 == 0) {
+      if (!filtering) {
+        ScaleRowDown34_0 = ScaleRowDown34_NEON;
+        ScaleRowDown34_1 = ScaleRowDown34_NEON;
+      } else {
+        ScaleRowDown34_0 = ScaleRowDown34_0_Box_NEON;
+        ScaleRowDown34_1 = ScaleRowDown34_1_Box_NEON;
+      }
+    }
+  }
+#endif
+#if defined(HAS_SCALEROWDOWN34_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    if (!filtering) {
+      ScaleRowDown34_0 = ScaleRowDown34_Any_MSA;
+      ScaleRowDown34_1 = ScaleRowDown34_Any_MSA;
+    } else {
+      ScaleRowDown34_0 = ScaleRowDown34_0_Box_Any_MSA;
+      ScaleRowDown34_1 = ScaleRowDown34_1_Box_Any_MSA;
+    }
+    if (dst_width % 48 == 0) {
+      if (!filtering) {
+        ScaleRowDown34_0 = ScaleRowDown34_MSA;
+        ScaleRowDown34_1 = ScaleRowDown34_MSA;
+      } else {
+        ScaleRowDown34_0 = ScaleRowDown34_0_Box_MSA;
+        ScaleRowDown34_1 = ScaleRowDown34_1_Box_MSA;
+      }
+    }
+  }
+#endif
+#if defined(HAS_SCALEROWDOWN34_LSX)
+  if (TestCpuFlag(kCpuHasLSX)) {
+    if (!filtering) {
+      ScaleRowDown34_0 = ScaleRowDown34_Any_LSX;
+      ScaleRowDown34_1 = ScaleRowDown34_Any_LSX;
+    } else {
+      ScaleRowDown34_0 = ScaleRowDown34_0_Box_Any_LSX;
+      ScaleRowDown34_1 = ScaleRowDown34_1_Box_Any_LSX;
+    }
+    if (dst_width % 48 == 0) {
+      if (!filtering) {
+        ScaleRowDown34_0 = ScaleRowDown34_LSX;
+        ScaleRowDown34_1 = ScaleRowDown34_LSX;
+      } else {
+        ScaleRowDown34_0 = ScaleRowDown34_0_Box_LSX;
+        ScaleRowDown34_1 = ScaleRowDown34_1_Box_LSX;
+      }
+    }
+  }
+#endif
+#if defined(HAS_SCALEROWDOWN34_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    if (!filtering) {
+      ScaleRowDown34_0 = ScaleRowDown34_Any_SSSE3;
+      ScaleRowDown34_1 = ScaleRowDown34_Any_SSSE3;
+    } else {
+      ScaleRowDown34_0 = ScaleRowDown34_0_Box_Any_SSSE3;
+      ScaleRowDown34_1 = ScaleRowDown34_1_Box_Any_SSSE3;
+    }
+    if (dst_width % 24 == 0) {
+      if (!filtering) {
+        ScaleRowDown34_0 = ScaleRowDown34_SSSE3;
+        ScaleRowDown34_1 = ScaleRowDown34_SSSE3;
+      } else {
+        ScaleRowDown34_0 = ScaleRowDown34_0_Box_SSSE3;
+        ScaleRowDown34_1 = ScaleRowDown34_1_Box_SSSE3;
+      }
+    }
+  }
+#endif
+
+  for (y = 0; y < dst_height - 2; y += 3) {
+    ScaleRowDown34_0(src_ptr, filter_stride, dst_ptr, dst_width);
+    src_ptr += src_stride;
+    dst_ptr += dst_stride;
+    ScaleRowDown34_1(src_ptr, filter_stride, dst_ptr, dst_width);
+    src_ptr += src_stride;
+    dst_ptr += dst_stride;
+    ScaleRowDown34_0(src_ptr + src_stride, -filter_stride, dst_ptr, dst_width);
+    src_ptr += src_stride * 2;
+    dst_ptr += dst_stride;
+  }
+
+  // Remainder 1 or 2 rows with last row vertically unfiltered
+  if ((dst_height % 3) == 2) {
+    ScaleRowDown34_0(src_ptr, filter_stride, dst_ptr, dst_width);
+    src_ptr += src_stride;
+    dst_ptr += dst_stride;
+    ScaleRowDown34_1(src_ptr, 0, dst_ptr, dst_width);
+  } else if ((dst_height % 3) == 1) {
+    ScaleRowDown34_0(src_ptr, 0, dst_ptr, dst_width);
+  }
+}
+
+static void ScalePlaneDown34_16(int src_width,
+                                int src_height,
+                                int dst_width,
+                                int dst_height,
+                                int src_stride,
+                                int dst_stride,
+                                const uint16_t* src_ptr,
+                                uint16_t* dst_ptr,
+                                enum FilterMode filtering) {
+  int y;
+  void (*ScaleRowDown34_0)(const uint16_t* src_ptr, ptrdiff_t src_stride,
+                           uint16_t* dst_ptr, int dst_width);
+  void (*ScaleRowDown34_1)(const uint16_t* src_ptr, ptrdiff_t src_stride,
+                           uint16_t* dst_ptr, int dst_width);
+  const int filter_stride = (filtering == kFilterLinear) ? 0 : src_stride;
+  (void)src_width;
+  (void)src_height;
+  assert(dst_width % 3 == 0);
+  if (!filtering) {
+    ScaleRowDown34_0 = ScaleRowDown34_16_C;
+    ScaleRowDown34_1 = ScaleRowDown34_16_C;
+  } else {
+    ScaleRowDown34_0 = ScaleRowDown34_0_Box_16_C;
+    ScaleRowDown34_1 = ScaleRowDown34_1_Box_16_C;
+  }
+#if defined(HAS_SCALEROWDOWN34_16_NEON)
+  if (TestCpuFlag(kCpuHasNEON) && (dst_width % 24 == 0)) {
+    if (!filtering) {
+      ScaleRowDown34_0 = ScaleRowDown34_16_NEON;
+      ScaleRowDown34_1 = ScaleRowDown34_16_NEON;
+    } else {
+      ScaleRowDown34_0 = ScaleRowDown34_0_Box_16_NEON;
+      ScaleRowDown34_1 = ScaleRowDown34_1_Box_16_NEON;
+    }
+  }
+#endif
+#if defined(HAS_SCALEROWDOWN34_16_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3) && (dst_width % 24 == 0)) {
+    if (!filtering) {
+      ScaleRowDown34_0 = ScaleRowDown34_16_SSSE3;
+      ScaleRowDown34_1 = ScaleRowDown34_16_SSSE3;
+    } else {
+      ScaleRowDown34_0 = ScaleRowDown34_0_Box_16_SSSE3;
+      ScaleRowDown34_1 = ScaleRowDown34_1_Box_16_SSSE3;
+    }
+  }
+#endif
+
+  for (y = 0; y < dst_height - 2; y += 3) {
+    ScaleRowDown34_0(src_ptr, filter_stride, dst_ptr, dst_width);
+    src_ptr += src_stride;
+    dst_ptr += dst_stride;
+    ScaleRowDown34_1(src_ptr, filter_stride, dst_ptr, dst_width);
+    src_ptr += src_stride;
+    dst_ptr += dst_stride;
+    ScaleRowDown34_0(src_ptr + src_stride, -filter_stride, dst_ptr, dst_width);
+    src_ptr += src_stride * 2;
+    dst_ptr += dst_stride;
+  }
+
+  // Remainder 1 or 2 rows with last row vertically unfiltered
+  if ((dst_height % 3) == 2) {
+    ScaleRowDown34_0(src_ptr, filter_stride, dst_ptr, dst_width);
+    src_ptr += src_stride;
+    dst_ptr += dst_stride;
+    ScaleRowDown34_1(src_ptr, 0, dst_ptr, dst_width);
+  } else if ((dst_height % 3) == 1) {
+    ScaleRowDown34_0(src_ptr, 0, dst_ptr, dst_width);
+  }
+}
+
+// Scale plane, 3/8
+// This is an optimized version for scaling down a plane to 3/8
+// of its original size.
+//
+// Uses box filter arranges like this
+// aaabbbcc -> abc
+// aaabbbcc    def
+// aaabbbcc    ghi
+// dddeeeff
+// dddeeeff
+// dddeeeff
+// ggghhhii
+// ggghhhii
+// Boxes are 3x3, 2x3, 3x2 and 2x2
+
+static void ScalePlaneDown38(int src_width,
+                             int src_height,
+                             int dst_width,
+                             int dst_height,
+                             int src_stride,
+                             int dst_stride,
+                             const uint8_t* src_ptr,
+                             uint8_t* dst_ptr,
+                             enum FilterMode filtering) {
+  int y;
+  void (*ScaleRowDown38_3)(const uint8_t* src_ptr, ptrdiff_t src_stride,
+                           uint8_t* dst_ptr, int dst_width);
+  void (*ScaleRowDown38_2)(const uint8_t* src_ptr, ptrdiff_t src_stride,
+                           uint8_t* dst_ptr, int dst_width);
+  const int filter_stride = (filtering == kFilterLinear) ? 0 : src_stride;
+  assert(dst_width % 3 == 0);
+  (void)src_width;
+  (void)src_height;
+  if (!filtering) {
+    ScaleRowDown38_3 = ScaleRowDown38_C;
+    ScaleRowDown38_2 = ScaleRowDown38_C;
+  } else {
+    ScaleRowDown38_3 = ScaleRowDown38_3_Box_C;
+    ScaleRowDown38_2 = ScaleRowDown38_2_Box_C;
+  }
+
+#if defined(HAS_SCALEROWDOWN38_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    if (!filtering) {
+      ScaleRowDown38_3 = ScaleRowDown38_Any_NEON;
+      ScaleRowDown38_2 = ScaleRowDown38_Any_NEON;
+    } else {
+      ScaleRowDown38_3 = ScaleRowDown38_3_Box_Any_NEON;
+      ScaleRowDown38_2 = ScaleRowDown38_2_Box_Any_NEON;
+    }
+    if (dst_width % 12 == 0) {
+      if (!filtering) {
+        ScaleRowDown38_3 = ScaleRowDown38_NEON;
+        ScaleRowDown38_2 = ScaleRowDown38_NEON;
+      } else {
+        ScaleRowDown38_3 = ScaleRowDown38_3_Box_NEON;
+        ScaleRowDown38_2 = ScaleRowDown38_2_Box_NEON;
+      }
+    }
+  }
+#endif
+#if defined(HAS_SCALEROWDOWN38_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    if (!filtering) {
+      ScaleRowDown38_3 = ScaleRowDown38_Any_SSSE3;
+      ScaleRowDown38_2 = ScaleRowDown38_Any_SSSE3;
+    } else {
+      ScaleRowDown38_3 = ScaleRowDown38_3_Box_Any_SSSE3;
+      ScaleRowDown38_2 = ScaleRowDown38_2_Box_Any_SSSE3;
+    }
+    if (dst_width % 12 == 0 && !filtering) {
+      ScaleRowDown38_3 = ScaleRowDown38_SSSE3;
+      ScaleRowDown38_2 = ScaleRowDown38_SSSE3;
+    }
+    if (dst_width % 6 == 0 && filtering) {
+      ScaleRowDown38_3 = ScaleRowDown38_3_Box_SSSE3;
+      ScaleRowDown38_2 = ScaleRowDown38_2_Box_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_SCALEROWDOWN38_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    if (!filtering) {
+      ScaleRowDown38_3 = ScaleRowDown38_Any_MSA;
+      ScaleRowDown38_2 = ScaleRowDown38_Any_MSA;
+    } else {
+      ScaleRowDown38_3 = ScaleRowDown38_3_Box_Any_MSA;
+      ScaleRowDown38_2 = ScaleRowDown38_2_Box_Any_MSA;
+    }
+    if (dst_width % 12 == 0) {
+      if (!filtering) {
+        ScaleRowDown38_3 = ScaleRowDown38_MSA;
+        ScaleRowDown38_2 = ScaleRowDown38_MSA;
+      } else {
+        ScaleRowDown38_3 = ScaleRowDown38_3_Box_MSA;
+        ScaleRowDown38_2 = ScaleRowDown38_2_Box_MSA;
+      }
+    }
+  }
+#endif
+#if defined(HAS_SCALEROWDOWN38_LSX)
+  if (TestCpuFlag(kCpuHasLSX)) {
+    if (!filtering) {
+      ScaleRowDown38_3 = ScaleRowDown38_Any_LSX;
+      ScaleRowDown38_2 = ScaleRowDown38_Any_LSX;
+    } else {
+      ScaleRowDown38_3 = ScaleRowDown38_3_Box_Any_LSX;
+      ScaleRowDown38_2 = ScaleRowDown38_2_Box_Any_LSX;
+    }
+    if (dst_width % 12 == 0) {
+      if (!filtering) {
+        ScaleRowDown38_3 = ScaleRowDown38_LSX;
+        ScaleRowDown38_2 = ScaleRowDown38_LSX;
+      } else {
+        ScaleRowDown38_3 = ScaleRowDown38_3_Box_LSX;
+        ScaleRowDown38_2 = ScaleRowDown38_2_Box_LSX;
+      }
+    }
+  }
+#endif
+
+  for (y = 0; y < dst_height - 2; y += 3) {
+    ScaleRowDown38_3(src_ptr, filter_stride, dst_ptr, dst_width);
+    src_ptr += src_stride * 3;
+    dst_ptr += dst_stride;
+    ScaleRowDown38_3(src_ptr, filter_stride, dst_ptr, dst_width);
+    src_ptr += src_stride * 3;
+    dst_ptr += dst_stride;
+    ScaleRowDown38_2(src_ptr, filter_stride, dst_ptr, dst_width);
+    src_ptr += src_stride * 2;
+    dst_ptr += dst_stride;
+  }
+
+  // Remainder 1 or 2 rows with last row vertically unfiltered
+  if ((dst_height % 3) == 2) {
+    ScaleRowDown38_3(src_ptr, filter_stride, dst_ptr, dst_width);
+    src_ptr += src_stride * 3;
+    dst_ptr += dst_stride;
+    ScaleRowDown38_3(src_ptr, 0, dst_ptr, dst_width);
+  } else if ((dst_height % 3) == 1) {
+    ScaleRowDown38_3(src_ptr, 0, dst_ptr, dst_width);
+  }
+}
+
+static void ScalePlaneDown38_16(int src_width,
+                                int src_height,
+                                int dst_width,
+                                int dst_height,
+                                int src_stride,
+                                int dst_stride,
+                                const uint16_t* src_ptr,
+                                uint16_t* dst_ptr,
+                                enum FilterMode filtering) {
+  int y;
+  void (*ScaleRowDown38_3)(const uint16_t* src_ptr, ptrdiff_t src_stride,
+                           uint16_t* dst_ptr, int dst_width);
+  void (*ScaleRowDown38_2)(const uint16_t* src_ptr, ptrdiff_t src_stride,
+                           uint16_t* dst_ptr, int dst_width);
+  const int filter_stride = (filtering == kFilterLinear) ? 0 : src_stride;
+  (void)src_width;
+  (void)src_height;
+  assert(dst_width % 3 == 0);
+  if (!filtering) {
+    ScaleRowDown38_3 = ScaleRowDown38_16_C;
+    ScaleRowDown38_2 = ScaleRowDown38_16_C;
+  } else {
+    ScaleRowDown38_3 = ScaleRowDown38_3_Box_16_C;
+    ScaleRowDown38_2 = ScaleRowDown38_2_Box_16_C;
+  }
+#if defined(HAS_SCALEROWDOWN38_16_NEON)
+  if (TestCpuFlag(kCpuHasNEON) && (dst_width % 12 == 0)) {
+    if (!filtering) {
+      ScaleRowDown38_3 = ScaleRowDown38_16_NEON;
+      ScaleRowDown38_2 = ScaleRowDown38_16_NEON;
+    } else {
+      ScaleRowDown38_3 = ScaleRowDown38_3_Box_16_NEON;
+      ScaleRowDown38_2 = ScaleRowDown38_2_Box_16_NEON;
+    }
+  }
+#endif
+#if defined(HAS_SCALEROWDOWN38_16_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3) && (dst_width % 24 == 0)) {
+    if (!filtering) {
+      ScaleRowDown38_3 = ScaleRowDown38_16_SSSE3;
+      ScaleRowDown38_2 = ScaleRowDown38_16_SSSE3;
+    } else {
+      ScaleRowDown38_3 = ScaleRowDown38_3_Box_16_SSSE3;
+      ScaleRowDown38_2 = ScaleRowDown38_2_Box_16_SSSE3;
+    }
+  }
+#endif
+
+  for (y = 0; y < dst_height - 2; y += 3) {
+    ScaleRowDown38_3(src_ptr, filter_stride, dst_ptr, dst_width);
+    src_ptr += src_stride * 3;
+    dst_ptr += dst_stride;
+    ScaleRowDown38_3(src_ptr, filter_stride, dst_ptr, dst_width);
+    src_ptr += src_stride * 3;
+    dst_ptr += dst_stride;
+    ScaleRowDown38_2(src_ptr, filter_stride, dst_ptr, dst_width);
+    src_ptr += src_stride * 2;
+    dst_ptr += dst_stride;
+  }
+
+  // Remainder 1 or 2 rows with last row vertically unfiltered
+  if ((dst_height % 3) == 2) {
+    ScaleRowDown38_3(src_ptr, filter_stride, dst_ptr, dst_width);
+    src_ptr += src_stride * 3;
+    dst_ptr += dst_stride;
+    ScaleRowDown38_3(src_ptr, 0, dst_ptr, dst_width);
+  } else if ((dst_height % 3) == 1) {
+    ScaleRowDown38_3(src_ptr, 0, dst_ptr, dst_width);
+  }
+}
+
+#define MIN1(x) ((x) < 1 ? 1 : (x))
+
+static __inline uint32_t SumPixels(int iboxwidth, const uint16_t* src_ptr) {
+  uint32_t sum = 0u;
+  int x;
+  assert(iboxwidth > 0);
+  for (x = 0; x < iboxwidth; ++x) {
+    sum += src_ptr[x];
+  }
+  return sum;
+}
+
+static __inline uint32_t SumPixels_16(int iboxwidth, const uint32_t* src_ptr) {
+  uint32_t sum = 0u;
+  int x;
+  assert(iboxwidth > 0);
+  for (x = 0; x < iboxwidth; ++x) {
+    sum += src_ptr[x];
+  }
+  return sum;
+}
+
+static void ScaleAddCols2_C(int dst_width,
+                            int boxheight,
+                            int x,
+                            int dx,
+                            const uint16_t* src_ptr,
+                            uint8_t* dst_ptr) {
+  int i;
+  int scaletbl[2];
+  int minboxwidth = dx >> 16;
+  int boxwidth;
+  scaletbl[0] = 65536 / (MIN1(minboxwidth) * boxheight);
+  scaletbl[1] = 65536 / (MIN1(minboxwidth + 1) * boxheight);
+  for (i = 0; i < dst_width; ++i) {
+    int ix = x >> 16;
+    x += dx;
+    boxwidth = MIN1((x >> 16) - ix);
+    *dst_ptr++ =
+        SumPixels(boxwidth, src_ptr + ix) * scaletbl[boxwidth - minboxwidth] >>
+        16;
+  }
+}
+
+static void ScaleAddCols2_16_C(int dst_width,
+                               int boxheight,
+                               int x,
+                               int dx,
+                               const uint32_t* src_ptr,
+                               uint16_t* dst_ptr) {
+  int i;
+  int scaletbl[2];
+  int minboxwidth = dx >> 16;
+  int boxwidth;
+  scaletbl[0] = 65536 / (MIN1(minboxwidth) * boxheight);
+  scaletbl[1] = 65536 / (MIN1(minboxwidth + 1) * boxheight);
+  for (i = 0; i < dst_width; ++i) {
+    int ix = x >> 16;
+    x += dx;
+    boxwidth = MIN1((x >> 16) - ix);
+    *dst_ptr++ = SumPixels_16(boxwidth, src_ptr + ix) *
+                     scaletbl[boxwidth - minboxwidth] >>
+                 16;
+  }
+}
+
+static void ScaleAddCols0_C(int dst_width,
+                            int boxheight,
+                            int x,
+                            int dx,
+                            const uint16_t* src_ptr,
+                            uint8_t* dst_ptr) {
+  int scaleval = 65536 / boxheight;
+  int i;
+  (void)dx;
+  src_ptr += (x >> 16);
+  for (i = 0; i < dst_width; ++i) {
+    *dst_ptr++ = src_ptr[i] * scaleval >> 16;
+  }
+}
+
+static void ScaleAddCols1_C(int dst_width,
+                            int boxheight,
+                            int x,
+                            int dx,
+                            const uint16_t* src_ptr,
+                            uint8_t* dst_ptr) {
+  int boxwidth = MIN1(dx >> 16);
+  int scaleval = 65536 / (boxwidth * boxheight);
+  int i;
+  x >>= 16;
+  for (i = 0; i < dst_width; ++i) {
+    *dst_ptr++ = SumPixels(boxwidth, src_ptr + x) * scaleval >> 16;
+    x += boxwidth;
+  }
+}
+
+static void ScaleAddCols1_16_C(int dst_width,
+                               int boxheight,
+                               int x,
+                               int dx,
+                               const uint32_t* src_ptr,
+                               uint16_t* dst_ptr) {
+  int boxwidth = MIN1(dx >> 16);
+  int scaleval = 65536 / (boxwidth * boxheight);
+  int i;
+  for (i = 0; i < dst_width; ++i) {
+    *dst_ptr++ = SumPixels_16(boxwidth, src_ptr + x) * scaleval >> 16;
+    x += boxwidth;
+  }
+}
+
+// Scale plane down to any dimensions, with interpolation.
+// (boxfilter).
+//
+// Same method as SimpleScale, which is fixed point, outputting
+// one pixel of destination using fixed point (16.16) to step
+// through source, sampling a box of pixel with simple
+// averaging.
+static void ScalePlaneBox(int src_width,
+                          int src_height,
+                          int dst_width,
+                          int dst_height,
+                          int src_stride,
+                          int dst_stride,
+                          const uint8_t* src_ptr,
+                          uint8_t* dst_ptr) {
+  int j, k;
+  // Initial source x/y coordinate and step values as 16.16 fixed point.
+  int x = 0;
+  int y = 0;
+  int dx = 0;
+  int dy = 0;
+  const int max_y = (src_height << 16);
+  ScaleSlope(src_width, src_height, dst_width, dst_height, kFilterBox, &x, &y,
+             &dx, &dy);
+  src_width = Abs(src_width);
+  {
+    // Allocate a row buffer of uint16_t.
+    align_buffer_64(row16, src_width * 2);
+    void (*ScaleAddCols)(int dst_width, int boxheight, int x, int dx,
+                         const uint16_t* src_ptr, uint8_t* dst_ptr) =
+        (dx & 0xffff) ? ScaleAddCols2_C
+                      : ((dx != 0x10000) ? ScaleAddCols1_C : ScaleAddCols0_C);
+    void (*ScaleAddRow)(const uint8_t* src_ptr, uint16_t* dst_ptr,
+                        int src_width) = ScaleAddRow_C;
+#if defined(HAS_SCALEADDROW_SSE2)
+    if (TestCpuFlag(kCpuHasSSE2)) {
+      ScaleAddRow = ScaleAddRow_Any_SSE2;
+      if (IS_ALIGNED(src_width, 16)) {
+        ScaleAddRow = ScaleAddRow_SSE2;
+      }
+    }
+#endif
+#if defined(HAS_SCALEADDROW_AVX2)
+    if (TestCpuFlag(kCpuHasAVX2)) {
+      ScaleAddRow = ScaleAddRow_Any_AVX2;
+      if (IS_ALIGNED(src_width, 32)) {
+        ScaleAddRow = ScaleAddRow_AVX2;
+      }
+    }
+#endif
+#if defined(HAS_SCALEADDROW_NEON)
+    if (TestCpuFlag(kCpuHasNEON)) {
+      ScaleAddRow = ScaleAddRow_Any_NEON;
+      if (IS_ALIGNED(src_width, 16)) {
+        ScaleAddRow = ScaleAddRow_NEON;
+      }
+    }
+#endif
+#if defined(HAS_SCALEADDROW_MSA)
+    if (TestCpuFlag(kCpuHasMSA)) {
+      ScaleAddRow = ScaleAddRow_Any_MSA;
+      if (IS_ALIGNED(src_width, 16)) {
+        ScaleAddRow = ScaleAddRow_MSA;
+      }
+    }
+#endif
+#if defined(HAS_SCALEADDROW_LSX)
+    if (TestCpuFlag(kCpuHasLSX)) {
+      ScaleAddRow = ScaleAddRow_Any_LSX;
+      if (IS_ALIGNED(src_width, 16)) {
+        ScaleAddRow = ScaleAddRow_LSX;
+      }
+    }
+#endif
+
+    for (j = 0; j < dst_height; ++j) {
+      int boxheight;
+      int iy = y >> 16;
+      const uint8_t* src = src_ptr + iy * (int64_t)src_stride;
+      y += dy;
+      if (y > max_y) {
+        y = max_y;
+      }
+      boxheight = MIN1((y >> 16) - iy);
+      memset(row16, 0, src_width * 2);
+      for (k = 0; k < boxheight; ++k) {
+        ScaleAddRow(src, (uint16_t*)(row16), src_width);
+        src += src_stride;
+      }
+      ScaleAddCols(dst_width, boxheight, x, dx, (uint16_t*)(row16), dst_ptr);
+      dst_ptr += dst_stride;
+    }
+    free_aligned_buffer_64(row16);
+  }
+}
+
+static void ScalePlaneBox_16(int src_width,
+                             int src_height,
+                             int dst_width,
+                             int dst_height,
+                             int src_stride,
+                             int dst_stride,
+                             const uint16_t* src_ptr,
+                             uint16_t* dst_ptr) {
+  int j, k;
+  // Initial source x/y coordinate and step values as 16.16 fixed point.
+  int x = 0;
+  int y = 0;
+  int dx = 0;
+  int dy = 0;
+  const int max_y = (src_height << 16);
+  ScaleSlope(src_width, src_height, dst_width, dst_height, kFilterBox, &x, &y,
+             &dx, &dy);
+  src_width = Abs(src_width);
+  {
+    // Allocate a row buffer of uint32_t.
+    align_buffer_64(row32, src_width * 4);
+    void (*ScaleAddCols)(int dst_width, int boxheight, int x, int dx,
+                         const uint32_t* src_ptr, uint16_t* dst_ptr) =
+        (dx & 0xffff) ? ScaleAddCols2_16_C : ScaleAddCols1_16_C;
+    void (*ScaleAddRow)(const uint16_t* src_ptr, uint32_t* dst_ptr,
+                        int src_width) = ScaleAddRow_16_C;
+
+#if defined(HAS_SCALEADDROW_16_SSE2)
+    if (TestCpuFlag(kCpuHasSSE2) && IS_ALIGNED(src_width, 16)) {
+      ScaleAddRow = ScaleAddRow_16_SSE2;
+    }
+#endif
+
+    for (j = 0; j < dst_height; ++j) {
+      int boxheight;
+      int iy = y >> 16;
+      const uint16_t* src = src_ptr + iy * (int64_t)src_stride;
+      y += dy;
+      if (y > max_y) {
+        y = max_y;
+      }
+      boxheight = MIN1((y >> 16) - iy);
+      memset(row32, 0, src_width * 4);
+      for (k = 0; k < boxheight; ++k) {
+        ScaleAddRow(src, (uint32_t*)(row32), src_width);
+        src += src_stride;
+      }
+      ScaleAddCols(dst_width, boxheight, x, dx, (uint32_t*)(row32), dst_ptr);
+      dst_ptr += dst_stride;
+    }
+    free_aligned_buffer_64(row32);
+  }
+}
+
+// Scale plane down with bilinear interpolation.
+void ScalePlaneBilinearDown(int src_width,
+                            int src_height,
+                            int dst_width,
+                            int dst_height,
+                            int src_stride,
+                            int dst_stride,
+                            const uint8_t* src_ptr,
+                            uint8_t* dst_ptr,
+                            enum FilterMode filtering) {
+  // Initial source x/y coordinate and step values as 16.16 fixed point.
+  int x = 0;
+  int y = 0;
+  int dx = 0;
+  int dy = 0;
+  // TODO(fbarchard): Consider not allocating row buffer for kFilterLinear.
+  // Allocate a row buffer.
+  align_buffer_64(row, src_width);
+
+  const int max_y = (src_height - 1) << 16;
+  int j;
+  void (*ScaleFilterCols)(uint8_t * dst_ptr, const uint8_t* src_ptr,
+                          int dst_width, int x, int dx) =
+      (src_width >= 32768) ? ScaleFilterCols64_C : ScaleFilterCols_C;
+  void (*InterpolateRow)(uint8_t * dst_ptr, const uint8_t* src_ptr,
+                         ptrdiff_t src_stride, int dst_width,
+                         int source_y_fraction) = InterpolateRow_C;
+  ScaleSlope(src_width, src_height, dst_width, dst_height, filtering, &x, &y,
+             &dx, &dy);
+  src_width = Abs(src_width);
+
+#if defined(HAS_INTERPOLATEROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    InterpolateRow = InterpolateRow_Any_SSSE3;
+    if (IS_ALIGNED(src_width, 16)) {
+      InterpolateRow = InterpolateRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_INTERPOLATEROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    InterpolateRow = InterpolateRow_Any_AVX2;
+    if (IS_ALIGNED(src_width, 32)) {
+      InterpolateRow = InterpolateRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_INTERPOLATEROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    InterpolateRow = InterpolateRow_Any_NEON;
+    if (IS_ALIGNED(src_width, 16)) {
+      InterpolateRow = InterpolateRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_INTERPOLATEROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    InterpolateRow = InterpolateRow_Any_MSA;
+    if (IS_ALIGNED(src_width, 32)) {
+      InterpolateRow = InterpolateRow_MSA;
+    }
+  }
+#endif
+#if defined(HAS_INTERPOLATEROW_LSX)
+  if (TestCpuFlag(kCpuHasLSX)) {
+    InterpolateRow = InterpolateRow_Any_LSX;
+    if (IS_ALIGNED(src_width, 32)) {
+      InterpolateRow = InterpolateRow_LSX;
+    }
+  }
+#endif
+
+#if defined(HAS_SCALEFILTERCOLS_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3) && src_width < 32768) {
+    ScaleFilterCols = ScaleFilterCols_SSSE3;
+  }
+#endif
+#if defined(HAS_SCALEFILTERCOLS_NEON)
+  if (TestCpuFlag(kCpuHasNEON) && src_width < 32768) {
+    ScaleFilterCols = ScaleFilterCols_Any_NEON;
+    if (IS_ALIGNED(dst_width, 8)) {
+      ScaleFilterCols = ScaleFilterCols_NEON;
+    }
+  }
+#endif
+#if defined(HAS_SCALEFILTERCOLS_MSA)
+  if (TestCpuFlag(kCpuHasMSA) && src_width < 32768) {
+    ScaleFilterCols = ScaleFilterCols_Any_MSA;
+    if (IS_ALIGNED(dst_width, 16)) {
+      ScaleFilterCols = ScaleFilterCols_MSA;
+    }
+  }
+#endif
+#if defined(HAS_SCALEFILTERCOLS_LSX)
+  if (TestCpuFlag(kCpuHasLSX) && src_width < 32768) {
+    ScaleFilterCols = ScaleFilterCols_Any_LSX;
+    if (IS_ALIGNED(dst_width, 16)) {
+      ScaleFilterCols = ScaleFilterCols_LSX;
+    }
+  }
+#endif
+  if (y > max_y) {
+    y = max_y;
+  }
+
+  for (j = 0; j < dst_height; ++j) {
+    int yi = y >> 16;
+    const uint8_t* src = src_ptr + yi * (int64_t)src_stride;
+    if (filtering == kFilterLinear) {
+      ScaleFilterCols(dst_ptr, src, dst_width, x, dx);
+    } else {
+      int yf = (y >> 8) & 255;
+      InterpolateRow(row, src, src_stride, src_width, yf);
+      ScaleFilterCols(dst_ptr, row, dst_width, x, dx);
+    }
+    dst_ptr += dst_stride;
+    y += dy;
+    if (y > max_y) {
+      y = max_y;
+    }
+  }
+  free_aligned_buffer_64(row);
+}
+
+void ScalePlaneBilinearDown_16(int src_width,
+                               int src_height,
+                               int dst_width,
+                               int dst_height,
+                               int src_stride,
+                               int dst_stride,
+                               const uint16_t* src_ptr,
+                               uint16_t* dst_ptr,
+                               enum FilterMode filtering) {
+  // Initial source x/y coordinate and step values as 16.16 fixed point.
+  int x = 0;
+  int y = 0;
+  int dx = 0;
+  int dy = 0;
+  // TODO(fbarchard): Consider not allocating row buffer for kFilterLinear.
+  // Allocate a row buffer.
+  align_buffer_64(row, src_width * 2);
+
+  const int max_y = (src_height - 1) << 16;
+  int j;
+  void (*ScaleFilterCols)(uint16_t * dst_ptr, const uint16_t* src_ptr,
+                          int dst_width, int x, int dx) =
+      (src_width >= 32768) ? ScaleFilterCols64_16_C : ScaleFilterCols_16_C;
+  void (*InterpolateRow)(uint16_t * dst_ptr, const uint16_t* src_ptr,
+                         ptrdiff_t src_stride, int dst_width,
+                         int source_y_fraction) = InterpolateRow_16_C;
+  ScaleSlope(src_width, src_height, dst_width, dst_height, filtering, &x, &y,
+             &dx, &dy);
+  src_width = Abs(src_width);
+
+#if defined(HAS_INTERPOLATEROW_16_SSE2)
+  if (TestCpuFlag(kCpuHasSSE2)) {
+    InterpolateRow = InterpolateRow_16_Any_SSE2;
+    if (IS_ALIGNED(src_width, 16)) {
+      InterpolateRow = InterpolateRow_16_SSE2;
+    }
+  }
+#endif
+#if defined(HAS_INTERPOLATEROW_16_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    InterpolateRow = InterpolateRow_16_Any_SSSE3;
+    if (IS_ALIGNED(src_width, 16)) {
+      InterpolateRow = InterpolateRow_16_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_INTERPOLATEROW_16_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    InterpolateRow = InterpolateRow_16_Any_AVX2;
+    if (IS_ALIGNED(src_width, 32)) {
+      InterpolateRow = InterpolateRow_16_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_INTERPOLATEROW_16_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    InterpolateRow = InterpolateRow_16_Any_NEON;
+    if (IS_ALIGNED(src_width, 16)) {
+      InterpolateRow = InterpolateRow_16_NEON;
+    }
+  }
+#endif
+
+#if defined(HAS_SCALEFILTERCOLS_16_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3) && src_width < 32768) {
+    ScaleFilterCols = ScaleFilterCols_16_SSSE3;
+  }
+#endif
+  if (y > max_y) {
+    y = max_y;
+  }
+
+  for (j = 0; j < dst_height; ++j) {
+    int yi = y >> 16;
+    const uint16_t* src = src_ptr + yi * (int64_t)src_stride;
+    if (filtering == kFilterLinear) {
+      ScaleFilterCols(dst_ptr, src, dst_width, x, dx);
+    } else {
+      int yf = (y >> 8) & 255;
+      InterpolateRow((uint16_t*)row, src, src_stride, src_width, yf);
+      ScaleFilterCols(dst_ptr, (uint16_t*)row, dst_width, x, dx);
+    }
+    dst_ptr += dst_stride;
+    y += dy;
+    if (y > max_y) {
+      y = max_y;
+    }
+  }
+  free_aligned_buffer_64(row);
+}
+
+// Scale up down with bilinear interpolation.
+void ScalePlaneBilinearUp(int src_width,
+                          int src_height,
+                          int dst_width,
+                          int dst_height,
+                          int src_stride,
+                          int dst_stride,
+                          const uint8_t* src_ptr,
+                          uint8_t* dst_ptr,
+                          enum FilterMode filtering) {
+  int j;
+  // Initial source x/y coordinate and step values as 16.16 fixed point.
+  int x = 0;
+  int y = 0;
+  int dx = 0;
+  int dy = 0;
+  const int max_y = (src_height - 1) << 16;
+  void (*InterpolateRow)(uint8_t * dst_ptr, const uint8_t* src_ptr,
+                         ptrdiff_t src_stride, int dst_width,
+                         int source_y_fraction) = InterpolateRow_C;
+  void (*ScaleFilterCols)(uint8_t * dst_ptr, const uint8_t* src_ptr,
+                          int dst_width, int x, int dx) =
+      filtering ? ScaleFilterCols_C : ScaleCols_C;
+  ScaleSlope(src_width, src_height, dst_width, dst_height, filtering, &x, &y,
+             &dx, &dy);
+  src_width = Abs(src_width);
+
+#if defined(HAS_INTERPOLATEROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    InterpolateRow = InterpolateRow_Any_SSSE3;
+    if (IS_ALIGNED(dst_width, 16)) {
+      InterpolateRow = InterpolateRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_INTERPOLATEROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    InterpolateRow = InterpolateRow_Any_AVX2;
+    if (IS_ALIGNED(dst_width, 32)) {
+      InterpolateRow = InterpolateRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_INTERPOLATEROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    InterpolateRow = InterpolateRow_Any_NEON;
+    if (IS_ALIGNED(dst_width, 16)) {
+      InterpolateRow = InterpolateRow_NEON;
+    }
+  }
+#endif
+
+  if (filtering && src_width >= 32768) {
+    ScaleFilterCols = ScaleFilterCols64_C;
+  }
+#if defined(HAS_SCALEFILTERCOLS_SSSE3)
+  if (filtering && TestCpuFlag(kCpuHasSSSE3) && src_width < 32768) {
+    ScaleFilterCols = ScaleFilterCols_SSSE3;
+  }
+#endif
+#if defined(HAS_SCALEFILTERCOLS_NEON)
+  if (filtering && TestCpuFlag(kCpuHasNEON) && src_width < 32768) {
+    ScaleFilterCols = ScaleFilterCols_Any_NEON;
+    if (IS_ALIGNED(dst_width, 8)) {
+      ScaleFilterCols = ScaleFilterCols_NEON;
+    }
+  }
+#endif
+#if defined(HAS_SCALEFILTERCOLS_MSA)
+  if (filtering && TestCpuFlag(kCpuHasMSA) && src_width < 32768) {
+    ScaleFilterCols = ScaleFilterCols_Any_MSA;
+    if (IS_ALIGNED(dst_width, 16)) {
+      ScaleFilterCols = ScaleFilterCols_MSA;
+    }
+  }
+#endif
+#if defined(HAS_SCALEFILTERCOLS_LSX)
+  if (filtering && TestCpuFlag(kCpuHasLSX) && src_width < 32768) {
+    ScaleFilterCols = ScaleFilterCols_Any_LSX;
+    if (IS_ALIGNED(dst_width, 16)) {
+      ScaleFilterCols = ScaleFilterCols_LSX;
+    }
+  }
+#endif
+  if (!filtering && src_width * 2 == dst_width && x < 0x8000) {
+    ScaleFilterCols = ScaleColsUp2_C;
+#if defined(HAS_SCALECOLS_SSE2)
+    if (TestCpuFlag(kCpuHasSSE2) && IS_ALIGNED(dst_width, 8)) {
+      ScaleFilterCols = ScaleColsUp2_SSE2;
+    }
+#endif
+  }
+
+  if (y > max_y) {
+    y = max_y;
+  }
+  {
+    int yi = y >> 16;
+    const uint8_t* src = src_ptr + yi * (int64_t)src_stride;
+
+    // Allocate 2 row buffers.
+    const int kRowSize = (dst_width + 31) & ~31;
+    align_buffer_64(row, kRowSize * 2);
+
+    uint8_t* rowptr = row;
+    int rowstride = kRowSize;
+    int lasty = yi;
+
+    ScaleFilterCols(rowptr, src, dst_width, x, dx);
+    if (src_height > 1) {
+      src += src_stride;
+    }
+    ScaleFilterCols(rowptr + rowstride, src, dst_width, x, dx);
+    if (src_height > 2) {
+      src += src_stride;
+    }
+
+    for (j = 0; j < dst_height; ++j) {
+      yi = y >> 16;
+      if (yi != lasty) {
+        if (y > max_y) {
+          y = max_y;
+          yi = y >> 16;
+          src = src_ptr + yi * (int64_t)src_stride;
+        }
+        if (yi != lasty) {
+          ScaleFilterCols(rowptr, src, dst_width, x, dx);
+          rowptr += rowstride;
+          rowstride = -rowstride;
+          lasty = yi;
+          if ((y + 65536) < max_y) {
+            src += src_stride;
+          }
+        }
+      }
+      if (filtering == kFilterLinear) {
+        InterpolateRow(dst_ptr, rowptr, 0, dst_width, 0);
+      } else {
+        int yf = (y >> 8) & 255;
+        InterpolateRow(dst_ptr, rowptr, rowstride, dst_width, yf);
+      }
+      dst_ptr += dst_stride;
+      y += dy;
+    }
+    free_aligned_buffer_64(row);
+  }
+}
+
+// Scale plane, horizontally up by 2 times.
+// Uses linear filter horizontally, nearest vertically.
+// This is an optimized version for scaling up a plane to 2 times of
+// its original width, using linear interpolation.
+// This is used to scale U and V planes of I422 to I444.
+void ScalePlaneUp2_Linear(int src_width,
+                          int src_height,
+                          int dst_width,
+                          int dst_height,
+                          int src_stride,
+                          int dst_stride,
+                          const uint8_t* src_ptr,
+                          uint8_t* dst_ptr) {
+  void (*ScaleRowUp)(const uint8_t* src_ptr, uint8_t* dst_ptr, int dst_width) =
+      ScaleRowUp2_Linear_Any_C;
+  int i;
+  int y;
+  int dy;
+
+  // This function can only scale up by 2 times horizontally.
+  assert(src_width == ((dst_width + 1) / 2));
+
+#ifdef HAS_SCALEROWUP2LINEAR_SSE2
+  if (TestCpuFlag(kCpuHasSSE2)) {
+    ScaleRowUp = ScaleRowUp2_Linear_Any_SSE2;
+  }
+#endif
+
+#ifdef HAS_SCALEROWUP2LINEAR_SSSE3
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    ScaleRowUp = ScaleRowUp2_Linear_Any_SSSE3;
+  }
+#endif
+
+#ifdef HAS_SCALEROWUP2LINEAR_AVX2
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ScaleRowUp = ScaleRowUp2_Linear_Any_AVX2;
+  }
+#endif
+
+#ifdef HAS_SCALEROWUP2LINEAR_NEON
+  if (TestCpuFlag(kCpuHasNEON)) {
+    ScaleRowUp = ScaleRowUp2_Linear_Any_NEON;
+  }
+#endif
+
+  if (dst_height == 1) {
+    ScaleRowUp(src_ptr + ((src_height - 1) / 2) * (int64_t)src_stride, dst_ptr,
+               dst_width);
+  } else {
+    dy = FixedDiv(src_height - 1, dst_height - 1);
+    y = (1 << 15) - 1;
+    for (i = 0; i < dst_height; ++i) {
+      ScaleRowUp(src_ptr + (y >> 16) * (int64_t)src_stride, dst_ptr, dst_width);
+      dst_ptr += dst_stride;
+      y += dy;
+    }
+  }
+}
+
+// Scale plane, up by 2 times.
+// This is an optimized version for scaling up a plane to 2 times of
+// its original size, using bilinear interpolation.
+// This is used to scale U and V planes of I420 to I444.
+void ScalePlaneUp2_Bilinear(int src_width,
+                            int src_height,
+                            int dst_width,
+                            int dst_height,
+                            int src_stride,
+                            int dst_stride,
+                            const uint8_t* src_ptr,
+                            uint8_t* dst_ptr) {
+  void (*Scale2RowUp)(const uint8_t* src_ptr, ptrdiff_t src_stride,
+                      uint8_t* dst_ptr, ptrdiff_t dst_stride, int dst_width) =
+      ScaleRowUp2_Bilinear_Any_C;
+  int x;
+
+  // This function can only scale up by 2 times.
+  assert(src_width == ((dst_width + 1) / 2));
+  assert(src_height == ((dst_height + 1) / 2));
+
+#ifdef HAS_SCALEROWUP2BILINEAR_SSE2
+  if (TestCpuFlag(kCpuHasSSE2)) {
+    Scale2RowUp = ScaleRowUp2_Bilinear_Any_SSE2;
+  }
+#endif
+
+#ifdef HAS_SCALEROWUP2BILINEAR_SSSE3
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    Scale2RowUp = ScaleRowUp2_Bilinear_Any_SSSE3;
+  }
+#endif
+
+#ifdef HAS_SCALEROWUP2BILINEAR_AVX2
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    Scale2RowUp = ScaleRowUp2_Bilinear_Any_AVX2;
+  }
+#endif
+
+#ifdef HAS_SCALEROWUP2BILINEAR_NEON
+  if (TestCpuFlag(kCpuHasNEON)) {
+    Scale2RowUp = ScaleRowUp2_Bilinear_Any_NEON;
+  }
+#endif
+
+  Scale2RowUp(src_ptr, 0, dst_ptr, 0, dst_width);
+  dst_ptr += dst_stride;
+  for (x = 0; x < src_height - 1; ++x) {
+    Scale2RowUp(src_ptr, src_stride, dst_ptr, dst_stride, dst_width);
+    src_ptr += src_stride;
+    // TODO(fbarchard): Test performance of writing one row of destination at a
+    // time.
+    dst_ptr += 2 * dst_stride;
+  }
+  if (!(dst_height & 1)) {
+    Scale2RowUp(src_ptr, 0, dst_ptr, 0, dst_width);
+  }
+}
+
+// Scale at most 14 bit plane, horizontally up by 2 times.
+// This is an optimized version for scaling up a plane to 2 times of
+// its original width, using linear interpolation.
+// stride is in count of uint16_t.
+// This is used to scale U and V planes of I210 to I410 and I212 to I412.
+void ScalePlaneUp2_12_Linear(int src_width,
+                             int src_height,
+                             int dst_width,
+                             int dst_height,
+                             int src_stride,
+                             int dst_stride,
+                             const uint16_t* src_ptr,
+                             uint16_t* dst_ptr) {
+  void (*ScaleRowUp)(const uint16_t* src_ptr, uint16_t* dst_ptr,
+                     int dst_width) = ScaleRowUp2_Linear_16_Any_C;
+  int i;
+  int y;
+  int dy;
+
+  // This function can only scale up by 2 times horizontally.
+  assert(src_width == ((dst_width + 1) / 2));
+
+#ifdef HAS_SCALEROWUP2LINEAR_12_SSSE3
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    ScaleRowUp = ScaleRowUp2_Linear_12_Any_SSSE3;
+  }
+#endif
+
+#ifdef HAS_SCALEROWUP2LINEAR_12_AVX2
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ScaleRowUp = ScaleRowUp2_Linear_12_Any_AVX2;
+  }
+#endif
+
+#ifdef HAS_SCALEROWUP2LINEAR_12_NEON
+  if (TestCpuFlag(kCpuHasNEON)) {
+    ScaleRowUp = ScaleRowUp2_Linear_12_Any_NEON;
+  }
+#endif
+
+  if (dst_height == 1) {
+    ScaleRowUp(src_ptr + ((src_height - 1) / 2) * (int64_t)src_stride, dst_ptr,
+               dst_width);
+  } else {
+    dy = FixedDiv(src_height - 1, dst_height - 1);
+    y = (1 << 15) - 1;
+    for (i = 0; i < dst_height; ++i) {
+      ScaleRowUp(src_ptr + (y >> 16) * (int64_t)src_stride, dst_ptr, dst_width);
+      dst_ptr += dst_stride;
+      y += dy;
+    }
+  }
+}
+
+// Scale at most 12 bit plane, up by 2 times.
+// This is an optimized version for scaling up a plane to 2 times of
+// its original size, using bilinear interpolation.
+// stride is in count of uint16_t.
+// This is used to scale U and V planes of I010 to I410 and I012 to I412.
+void ScalePlaneUp2_12_Bilinear(int src_width,
+                               int src_height,
+                               int dst_width,
+                               int dst_height,
+                               int src_stride,
+                               int dst_stride,
+                               const uint16_t* src_ptr,
+                               uint16_t* dst_ptr) {
+  void (*Scale2RowUp)(const uint16_t* src_ptr, ptrdiff_t src_stride,
+                      uint16_t* dst_ptr, ptrdiff_t dst_stride, int dst_width) =
+      ScaleRowUp2_Bilinear_16_Any_C;
+  int x;
+
+  // This function can only scale up by 2 times.
+  assert(src_width == ((dst_width + 1) / 2));
+  assert(src_height == ((dst_height + 1) / 2));
+
+#ifdef HAS_SCALEROWUP2BILINEAR_12_SSSE3
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    Scale2RowUp = ScaleRowUp2_Bilinear_12_Any_SSSE3;
+  }
+#endif
+
+#ifdef HAS_SCALEROWUP2BILINEAR_12_AVX2
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    Scale2RowUp = ScaleRowUp2_Bilinear_12_Any_AVX2;
+  }
+#endif
+
+#ifdef HAS_SCALEROWUP2BILINEAR_12_NEON
+  if (TestCpuFlag(kCpuHasNEON)) {
+    Scale2RowUp = ScaleRowUp2_Bilinear_12_Any_NEON;
+  }
+#endif
+
+  Scale2RowUp(src_ptr, 0, dst_ptr, 0, dst_width);
+  dst_ptr += dst_stride;
+  for (x = 0; x < src_height - 1; ++x) {
+    Scale2RowUp(src_ptr, src_stride, dst_ptr, dst_stride, dst_width);
+    src_ptr += src_stride;
+    dst_ptr += 2 * dst_stride;
+  }
+  if (!(dst_height & 1)) {
+    Scale2RowUp(src_ptr, 0, dst_ptr, 0, dst_width);
+  }
+}
+
+void ScalePlaneUp2_16_Linear(int src_width,
+                             int src_height,
+                             int dst_width,
+                             int dst_height,
+                             int src_stride,
+                             int dst_stride,
+                             const uint16_t* src_ptr,
+                             uint16_t* dst_ptr) {
+  void (*ScaleRowUp)(const uint16_t* src_ptr, uint16_t* dst_ptr,
+                     int dst_width) = ScaleRowUp2_Linear_16_Any_C;
+  int i;
+  int y;
+  int dy;
+
+  // This function can only scale up by 2 times horizontally.
+  assert(src_width == ((dst_width + 1) / 2));
+
+#ifdef HAS_SCALEROWUP2LINEAR_16_SSE2
+  if (TestCpuFlag(kCpuHasSSE2)) {
+    ScaleRowUp = ScaleRowUp2_Linear_16_Any_SSE2;
+  }
+#endif
+
+#ifdef HAS_SCALEROWUP2LINEAR_16_AVX2
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ScaleRowUp = ScaleRowUp2_Linear_16_Any_AVX2;
+  }
+#endif
+
+#ifdef HAS_SCALEROWUP2LINEAR_16_NEON
+  if (TestCpuFlag(kCpuHasNEON)) {
+    ScaleRowUp = ScaleRowUp2_Linear_16_Any_NEON;
+  }
+#endif
+
+  if (dst_height == 1) {
+    ScaleRowUp(src_ptr + ((src_height - 1) / 2) * (int64_t)src_stride, dst_ptr,
+               dst_width);
+  } else {
+    dy = FixedDiv(src_height - 1, dst_height - 1);
+    y = (1 << 15) - 1;
+    for (i = 0; i < dst_height; ++i) {
+      ScaleRowUp(src_ptr + (y >> 16) * (int64_t)src_stride, dst_ptr, dst_width);
+      dst_ptr += dst_stride;
+      y += dy;
+    }
+  }
+}
+
+void ScalePlaneUp2_16_Bilinear(int src_width,
+                               int src_height,
+                               int dst_width,
+                               int dst_height,
+                               int src_stride,
+                               int dst_stride,
+                               const uint16_t* src_ptr,
+                               uint16_t* dst_ptr) {
+  void (*Scale2RowUp)(const uint16_t* src_ptr, ptrdiff_t src_stride,
+                      uint16_t* dst_ptr, ptrdiff_t dst_stride, int dst_width) =
+      ScaleRowUp2_Bilinear_16_Any_C;
+  int x;
+
+  // This function can only scale up by 2 times.
+  assert(src_width == ((dst_width + 1) / 2));
+  assert(src_height == ((dst_height + 1) / 2));
+
+#ifdef HAS_SCALEROWUP2BILINEAR_16_SSE2
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    Scale2RowUp = ScaleRowUp2_Bilinear_16_Any_SSSE3;
+  }
+#endif
+
+#ifdef HAS_SCALEROWUP2BILINEAR_16_AVX2
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    Scale2RowUp = ScaleRowUp2_Bilinear_16_Any_AVX2;
+  }
+#endif
+
+#ifdef HAS_SCALEROWUP2BILINEAR_16_NEON
+  if (TestCpuFlag(kCpuHasNEON)) {
+    Scale2RowUp = ScaleRowUp2_Bilinear_16_Any_NEON;
+  }
+#endif
+
+  Scale2RowUp(src_ptr, 0, dst_ptr, 0, dst_width);
+  dst_ptr += dst_stride;
+  for (x = 0; x < src_height - 1; ++x) {
+    Scale2RowUp(src_ptr, src_stride, dst_ptr, dst_stride, dst_width);
+    src_ptr += src_stride;
+    dst_ptr += 2 * dst_stride;
+  }
+  if (!(dst_height & 1)) {
+    Scale2RowUp(src_ptr, 0, dst_ptr, 0, dst_width);
+  }
+}
+
+void ScalePlaneBilinearUp_16(int src_width,
+                             int src_height,
+                             int dst_width,
+                             int dst_height,
+                             int src_stride,
+                             int dst_stride,
+                             const uint16_t* src_ptr,
+                             uint16_t* dst_ptr,
+                             enum FilterMode filtering) {
+  int j;
+  // Initial source x/y coordinate and step values as 16.16 fixed point.
+  int x = 0;
+  int y = 0;
+  int dx = 0;
+  int dy = 0;
+  const int max_y = (src_height - 1) << 16;
+  void (*InterpolateRow)(uint16_t * dst_ptr, const uint16_t* src_ptr,
+                         ptrdiff_t src_stride, int dst_width,
+                         int source_y_fraction) = InterpolateRow_16_C;
+  void (*ScaleFilterCols)(uint16_t * dst_ptr, const uint16_t* src_ptr,
+                          int dst_width, int x, int dx) =
+      filtering ? ScaleFilterCols_16_C : ScaleCols_16_C;
+  ScaleSlope(src_width, src_height, dst_width, dst_height, filtering, &x, &y,
+             &dx, &dy);
+  src_width = Abs(src_width);
+
+#if defined(HAS_INTERPOLATEROW_16_SSE2)
+  if (TestCpuFlag(kCpuHasSSE2)) {
+    InterpolateRow = InterpolateRow_16_Any_SSE2;
+    if (IS_ALIGNED(dst_width, 16)) {
+      InterpolateRow = InterpolateRow_16_SSE2;
+    }
+  }
+#endif
+#if defined(HAS_INTERPOLATEROW_16_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    InterpolateRow = InterpolateRow_16_Any_SSSE3;
+    if (IS_ALIGNED(dst_width, 16)) {
+      InterpolateRow = InterpolateRow_16_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_INTERPOLATEROW_16_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    InterpolateRow = InterpolateRow_16_Any_AVX2;
+    if (IS_ALIGNED(dst_width, 32)) {
+      InterpolateRow = InterpolateRow_16_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_INTERPOLATEROW_16_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    InterpolateRow = InterpolateRow_16_Any_NEON;
+    if (IS_ALIGNED(dst_width, 16)) {
+      InterpolateRow = InterpolateRow_16_NEON;
+    }
+  }
+#endif
+
+  if (filtering && src_width >= 32768) {
+    ScaleFilterCols = ScaleFilterCols64_16_C;
+  }
+#if defined(HAS_SCALEFILTERCOLS_16_SSSE3)
+  if (filtering && TestCpuFlag(kCpuHasSSSE3) && src_width < 32768) {
+    ScaleFilterCols = ScaleFilterCols_16_SSSE3;
+  }
+#endif
+  if (!filtering && src_width * 2 == dst_width && x < 0x8000) {
+    ScaleFilterCols = ScaleColsUp2_16_C;
+#if defined(HAS_SCALECOLS_16_SSE2)
+    if (TestCpuFlag(kCpuHasSSE2) && IS_ALIGNED(dst_width, 8)) {
+      ScaleFilterCols = ScaleColsUp2_16_SSE2;
+    }
+#endif
+  }
+
+  if (y > max_y) {
+    y = max_y;
+  }
+  {
+    int yi = y >> 16;
+    const uint16_t* src = src_ptr + yi * (int64_t)src_stride;
+
+    // Allocate 2 row buffers.
+    const int kRowSize = (dst_width + 31) & ~31;
+    align_buffer_64(row, kRowSize * 4);
+
+    uint16_t* rowptr = (uint16_t*)row;
+    int rowstride = kRowSize;
+    int lasty = yi;
+
+    ScaleFilterCols(rowptr, src, dst_width, x, dx);
+    if (src_height > 1) {
+      src += src_stride;
+    }
+    ScaleFilterCols(rowptr + rowstride, src, dst_width, x, dx);
+    if (src_height > 2) {
+      src += src_stride;
+    }
+
+    for (j = 0; j < dst_height; ++j) {
+      yi = y >> 16;
+      if (yi != lasty) {
+        if (y > max_y) {
+          y = max_y;
+          yi = y >> 16;
+          src = src_ptr + yi * (int64_t)src_stride;
+        }
+        if (yi != lasty) {
+          ScaleFilterCols(rowptr, src, dst_width, x, dx);
+          rowptr += rowstride;
+          rowstride = -rowstride;
+          lasty = yi;
+          if ((y + 65536) < max_y) {
+            src += src_stride;
+          }
+        }
+      }
+      if (filtering == kFilterLinear) {
+        InterpolateRow(dst_ptr, rowptr, 0, dst_width, 0);
+      } else {
+        int yf = (y >> 8) & 255;
+        InterpolateRow(dst_ptr, rowptr, rowstride, dst_width, yf);
+      }
+      dst_ptr += dst_stride;
+      y += dy;
+    }
+    free_aligned_buffer_64(row);
+  }
+}
+
+// Scale Plane to/from any dimensions, without interpolation.
+// Fixed point math is used for performance: The upper 16 bits
+// of x and dx is the integer part of the source position and
+// the lower 16 bits are the fixed decimal part.
+
+static void ScalePlaneSimple(int src_width,
+                             int src_height,
+                             int dst_width,
+                             int dst_height,
+                             int src_stride,
+                             int dst_stride,
+                             const uint8_t* src_ptr,
+                             uint8_t* dst_ptr) {
+  int i;
+  void (*ScaleCols)(uint8_t * dst_ptr, const uint8_t* src_ptr, int dst_width,
+                    int x, int dx) = ScaleCols_C;
+  // Initial source x/y coordinate and step values as 16.16 fixed point.
+  int x = 0;
+  int y = 0;
+  int dx = 0;
+  int dy = 0;
+  ScaleSlope(src_width, src_height, dst_width, dst_height, kFilterNone, &x, &y,
+             &dx, &dy);
+  src_width = Abs(src_width);
+
+  if (src_width * 2 == dst_width && x < 0x8000) {
+    ScaleCols = ScaleColsUp2_C;
+#if defined(HAS_SCALECOLS_SSE2)
+    if (TestCpuFlag(kCpuHasSSE2) && IS_ALIGNED(dst_width, 8)) {
+      ScaleCols = ScaleColsUp2_SSE2;
+    }
+#endif
+  }
+
+  for (i = 0; i < dst_height; ++i) {
+    ScaleCols(dst_ptr, src_ptr + (y >> 16) * (int64_t)src_stride, dst_width, x,
+              dx);
+    dst_ptr += dst_stride;
+    y += dy;
+  }
+}
+
+static void ScalePlaneSimple_16(int src_width,
+                                int src_height,
+                                int dst_width,
+                                int dst_height,
+                                int src_stride,
+                                int dst_stride,
+                                const uint16_t* src_ptr,
+                                uint16_t* dst_ptr) {
+  int i;
+  void (*ScaleCols)(uint16_t * dst_ptr, const uint16_t* src_ptr, int dst_width,
+                    int x, int dx) = ScaleCols_16_C;
+  // Initial source x/y coordinate and step values as 16.16 fixed point.
+  int x = 0;
+  int y = 0;
+  int dx = 0;
+  int dy = 0;
+  ScaleSlope(src_width, src_height, dst_width, dst_height, kFilterNone, &x, &y,
+             &dx, &dy);
+  src_width = Abs(src_width);
+
+  if (src_width * 2 == dst_width && x < 0x8000) {
+    ScaleCols = ScaleColsUp2_16_C;
+#if defined(HAS_SCALECOLS_16_SSE2)
+    if (TestCpuFlag(kCpuHasSSE2) && IS_ALIGNED(dst_width, 8)) {
+      ScaleCols = ScaleColsUp2_16_SSE2;
+    }
+#endif
+  }
+
+  for (i = 0; i < dst_height; ++i) {
+    ScaleCols(dst_ptr, src_ptr + (y >> 16) * (int64_t)src_stride, dst_width, x,
+              dx);
+    dst_ptr += dst_stride;
+    y += dy;
+  }
+}
+
+// Scale a plane.
+// This function dispatches to a specialized scaler based on scale factor.
+LIBYUV_API
+void ScalePlane(const uint8_t* src,
+                int src_stride,
+                int src_width,
+                int src_height,
+                uint8_t* dst,
+                int dst_stride,
+                int dst_width,
+                int dst_height,
+                enum FilterMode filtering) {
+  // Simplify filtering when possible.
+  filtering = ScaleFilterReduce(src_width, src_height, dst_width, dst_height,
+                                filtering);
+
+  // Negative height means invert the image.
+  if (src_height < 0) {
+    src_height = -src_height;
+    src = src + (src_height - 1) * (int64_t)src_stride;
+    src_stride = -src_stride;
+  }
+
+  // Use specialized scales to improve performance for common resolutions.
+  // For example, all the 1/2 scalings will use ScalePlaneDown2()
+  if (dst_width == src_width && dst_height == src_height) {
+    // Straight copy.
+    CopyPlane(src, src_stride, dst, dst_stride, dst_width, dst_height);
+    return;
+  }
+  if (dst_width == src_width && filtering != kFilterBox) {
+    int dy = 0;
+    int y = 0;
+    // When scaling down, use the center 2 rows to filter.
+    // When scaling up, last row of destination uses the last 2 source rows.
+    if (dst_height <= src_height) {
+      dy = FixedDiv(src_height, dst_height);
+      y = CENTERSTART(dy, -32768);  // Subtract 0.5 (32768) to center filter.
+    } else if (src_height > 1 && dst_height > 1) {
+      dy = FixedDiv1(src_height, dst_height);
+    }
+    // Arbitrary scale vertically, but unscaled horizontally.
+    ScalePlaneVertical(src_height, dst_width, dst_height, src_stride,
+                       dst_stride, src, dst, 0, y, dy, /*bpp=*/1, filtering);
+    return;
+  }
+  if (dst_width <= Abs(src_width) && dst_height <= src_height) {
+    // Scale down.
+    if (4 * dst_width == 3 * src_width && 4 * dst_height == 3 * src_height) {
+      // optimized, 3/4
+      ScalePlaneDown34(src_width, src_height, dst_width, dst_height, src_stride,
+                       dst_stride, src, dst, filtering);
+      return;
+    }
+    if (2 * dst_width == src_width && 2 * dst_height == src_height) {
+      // optimized, 1/2
+      ScalePlaneDown2(src_width, src_height, dst_width, dst_height, src_stride,
+                      dst_stride, src, dst, filtering);
+      return;
+    }
+    // 3/8 rounded up for odd sized chroma height.
+    if (8 * dst_width == 3 * src_width && 8 * dst_height == 3 * src_height) {
+      // optimized, 3/8
+      ScalePlaneDown38(src_width, src_height, dst_width, dst_height, src_stride,
+                       dst_stride, src, dst, filtering);
+      return;
+    }
+    if (4 * dst_width == src_width && 4 * dst_height == src_height &&
+        (filtering == kFilterBox || filtering == kFilterNone)) {
+      // optimized, 1/4
+      ScalePlaneDown4(src_width, src_height, dst_width, dst_height, src_stride,
+                      dst_stride, src, dst, filtering);
+      return;
+    }
+  }
+  if (filtering == kFilterBox && dst_height * 2 < src_height) {
+    ScalePlaneBox(src_width, src_height, dst_width, dst_height, src_stride,
+                  dst_stride, src, dst);
+    return;
+  }
+  if ((dst_width + 1) / 2 == src_width && filtering == kFilterLinear) {
+    ScalePlaneUp2_Linear(src_width, src_height, dst_width, dst_height,
+                         src_stride, dst_stride, src, dst);
+    return;
+  }
+  if ((dst_height + 1) / 2 == src_height && (dst_width + 1) / 2 == src_width &&
+      (filtering == kFilterBilinear || filtering == kFilterBox)) {
+    ScalePlaneUp2_Bilinear(src_width, src_height, dst_width, dst_height,
+                           src_stride, dst_stride, src, dst);
+    return;
+  }
+  if (filtering && dst_height > src_height) {
+    ScalePlaneBilinearUp(src_width, src_height, dst_width, dst_height,
+                         src_stride, dst_stride, src, dst, filtering);
+    return;
+  }
+  if (filtering) {
+    ScalePlaneBilinearDown(src_width, src_height, dst_width, dst_height,
+                           src_stride, dst_stride, src, dst, filtering);
+    return;
+  }
+  ScalePlaneSimple(src_width, src_height, dst_width, dst_height, src_stride,
+                   dst_stride, src, dst);
+}
+
+LIBYUV_API
+void ScalePlane_16(const uint16_t* src,
+                   int src_stride,
+                   int src_width,
+                   int src_height,
+                   uint16_t* dst,
+                   int dst_stride,
+                   int dst_width,
+                   int dst_height,
+                   enum FilterMode filtering) {
+  // Simplify filtering when possible.
+  filtering = ScaleFilterReduce(src_width, src_height, dst_width, dst_height,
+                                filtering);
+
+  // Negative height means invert the image.
+  if (src_height < 0) {
+    src_height = -src_height;
+    src = src + (src_height - 1) * (int64_t)src_stride;
+    src_stride = -src_stride;
+  }
+
+  // Use specialized scales to improve performance for common resolutions.
+  // For example, all the 1/2 scalings will use ScalePlaneDown2()
+  if (dst_width == src_width && dst_height == src_height) {
+    // Straight copy.
+    CopyPlane_16(src, src_stride, dst, dst_stride, dst_width, dst_height);
+    return;
+  }
+  if (dst_width == src_width && filtering != kFilterBox) {
+    int dy = 0;
+    int y = 0;
+    // When scaling down, use the center 2 rows to filter.
+    // When scaling up, last row of destination uses the last 2 source rows.
+    if (dst_height <= src_height) {
+      dy = FixedDiv(src_height, dst_height);
+      y = CENTERSTART(dy, -32768);  // Subtract 0.5 (32768) to center filter.
+      // When scaling up, ensure the last row of destination uses the last
+      // source. Avoid divide by zero for dst_height but will do no scaling
+      // later.
+    } else if (src_height > 1 && dst_height > 1) {
+      dy = FixedDiv1(src_height, dst_height);
+    }
+    // Arbitrary scale vertically, but unscaled horizontally.
+    ScalePlaneVertical_16(src_height, dst_width, dst_height, src_stride,
+                          dst_stride, src, dst, 0, y, dy, /*bpp=*/1, filtering);
+    return;
+  }
+  if (dst_width <= Abs(src_width) && dst_height <= src_height) {
+    // Scale down.
+    if (4 * dst_width == 3 * src_width && 4 * dst_height == 3 * src_height) {
+      // optimized, 3/4
+      ScalePlaneDown34_16(src_width, src_height, dst_width, dst_height,
+                          src_stride, dst_stride, src, dst, filtering);
+      return;
+    }
+    if (2 * dst_width == src_width && 2 * dst_height == src_height) {
+      // optimized, 1/2
+      ScalePlaneDown2_16(src_width, src_height, dst_width, dst_height,
+                         src_stride, dst_stride, src, dst, filtering);
+      return;
+    }
+    // 3/8 rounded up for odd sized chroma height.
+    if (8 * dst_width == 3 * src_width && 8 * dst_height == 3 * src_height) {
+      // optimized, 3/8
+      ScalePlaneDown38_16(src_width, src_height, dst_width, dst_height,
+                          src_stride, dst_stride, src, dst, filtering);
+      return;
+    }
+    if (4 * dst_width == src_width && 4 * dst_height == src_height &&
+        (filtering == kFilterBox || filtering == kFilterNone)) {
+      // optimized, 1/4
+      ScalePlaneDown4_16(src_width, src_height, dst_width, dst_height,
+                         src_stride, dst_stride, src, dst, filtering);
+      return;
+    }
+  }
+  if (filtering == kFilterBox && dst_height * 2 < src_height) {
+    ScalePlaneBox_16(src_width, src_height, dst_width, dst_height, src_stride,
+                     dst_stride, src, dst);
+    return;
+  }
+  if ((dst_width + 1) / 2 == src_width && filtering == kFilterLinear) {
+    ScalePlaneUp2_16_Linear(src_width, src_height, dst_width, dst_height,
+                            src_stride, dst_stride, src, dst);
+    return;
+  }
+  if ((dst_height + 1) / 2 == src_height && (dst_width + 1) / 2 == src_width &&
+      (filtering == kFilterBilinear || filtering == kFilterBox)) {
+    ScalePlaneUp2_16_Bilinear(src_width, src_height, dst_width, dst_height,
+                              src_stride, dst_stride, src, dst);
+    return;
+  }
+  if (filtering && dst_height > src_height) {
+    ScalePlaneBilinearUp_16(src_width, src_height, dst_width, dst_height,
+                            src_stride, dst_stride, src, dst, filtering);
+    return;
+  }
+  if (filtering) {
+    ScalePlaneBilinearDown_16(src_width, src_height, dst_width, dst_height,
+                              src_stride, dst_stride, src, dst, filtering);
+    return;
+  }
+  ScalePlaneSimple_16(src_width, src_height, dst_width, dst_height, src_stride,
+                      dst_stride, src, dst);
+}
+
+LIBYUV_API
+void ScalePlane_12(const uint16_t* src,
+                   int src_stride,
+                   int src_width,
+                   int src_height,
+                   uint16_t* dst,
+                   int dst_stride,
+                   int dst_width,
+                   int dst_height,
+                   enum FilterMode filtering) {
+  // Simplify filtering when possible.
+  filtering = ScaleFilterReduce(src_width, src_height, dst_width, dst_height,
+                                filtering);
+
+  // Negative height means invert the image.
+  if (src_height < 0) {
+    src_height = -src_height;
+    src = src + (src_height - 1) * (int64_t)src_stride;
+    src_stride = -src_stride;
+  }
+
+  if ((dst_width + 1) / 2 == src_width && filtering == kFilterLinear) {
+    ScalePlaneUp2_12_Linear(src_width, src_height, dst_width, dst_height,
+                            src_stride, dst_stride, src, dst);
+    return;
+  }
+  if ((dst_height + 1) / 2 == src_height && (dst_width + 1) / 2 == src_width &&
+      (filtering == kFilterBilinear || filtering == kFilterBox)) {
+    ScalePlaneUp2_12_Bilinear(src_width, src_height, dst_width, dst_height,
+                              src_stride, dst_stride, src, dst);
+    return;
+  }
+
+  ScalePlane_16(src, src_stride, src_width, src_height, dst, dst_stride,
+                dst_width, dst_height, filtering);
+}
+
+// Scale an I420 image.
+// This function in turn calls a scaling function for each plane.
+
+LIBYUV_API
+int I420Scale(const uint8_t* src_y,
+              int src_stride_y,
+              const uint8_t* src_u,
+              int src_stride_u,
+              const uint8_t* src_v,
+              int src_stride_v,
+              int src_width,
+              int src_height,
+              uint8_t* dst_y,
+              int dst_stride_y,
+              uint8_t* dst_u,
+              int dst_stride_u,
+              uint8_t* dst_v,
+              int dst_stride_v,
+              int dst_width,
+              int dst_height,
+              enum FilterMode filtering) {
+  int src_halfwidth = SUBSAMPLE(src_width, 1, 1);
+  int src_halfheight = SUBSAMPLE(src_height, 1, 1);
+  int dst_halfwidth = SUBSAMPLE(dst_width, 1, 1);
+  int dst_halfheight = SUBSAMPLE(dst_height, 1, 1);
+
+  if (!src_y || !src_u || !src_v || src_width <= 0 || src_height == 0 ||
+      src_width > 32768 || src_height > 32768 || !dst_y || !dst_u || !dst_v ||
+      dst_width <= 0 || dst_height <= 0) {
+    return -1;
+  }
+
+  ScalePlane(src_y, src_stride_y, src_width, src_height, dst_y, dst_stride_y,
+             dst_width, dst_height, filtering);
+  ScalePlane(src_u, src_stride_u, src_halfwidth, src_halfheight, dst_u,
+             dst_stride_u, dst_halfwidth, dst_halfheight, filtering);
+  ScalePlane(src_v, src_stride_v, src_halfwidth, src_halfheight, dst_v,
+             dst_stride_v, dst_halfwidth, dst_halfheight, filtering);
+  return 0;
+}
+
+LIBYUV_API
+int I420Scale_16(const uint16_t* src_y,
+                 int src_stride_y,
+                 const uint16_t* src_u,
+                 int src_stride_u,
+                 const uint16_t* src_v,
+                 int src_stride_v,
+                 int src_width,
+                 int src_height,
+                 uint16_t* dst_y,
+                 int dst_stride_y,
+                 uint16_t* dst_u,
+                 int dst_stride_u,
+                 uint16_t* dst_v,
+                 int dst_stride_v,
+                 int dst_width,
+                 int dst_height,
+                 enum FilterMode filtering) {
+  int src_halfwidth = SUBSAMPLE(src_width, 1, 1);
+  int src_halfheight = SUBSAMPLE(src_height, 1, 1);
+  int dst_halfwidth = SUBSAMPLE(dst_width, 1, 1);
+  int dst_halfheight = SUBSAMPLE(dst_height, 1, 1);
+
+  if (!src_y || !src_u || !src_v || src_width <= 0 || src_height == 0 ||
+      src_width > 32768 || src_height > 32768 || !dst_y || !dst_u || !dst_v ||
+      dst_width <= 0 || dst_height <= 0) {
+    return -1;
+  }
+
+  ScalePlane_16(src_y, src_stride_y, src_width, src_height, dst_y, dst_stride_y,
+                dst_width, dst_height, filtering);
+  ScalePlane_16(src_u, src_stride_u, src_halfwidth, src_halfheight, dst_u,
+                dst_stride_u, dst_halfwidth, dst_halfheight, filtering);
+  ScalePlane_16(src_v, src_stride_v, src_halfwidth, src_halfheight, dst_v,
+                dst_stride_v, dst_halfwidth, dst_halfheight, filtering);
+  return 0;
+}
+
+LIBYUV_API
+int I420Scale_12(const uint16_t* src_y,
+                 int src_stride_y,
+                 const uint16_t* src_u,
+                 int src_stride_u,
+                 const uint16_t* src_v,
+                 int src_stride_v,
+                 int src_width,
+                 int src_height,
+                 uint16_t* dst_y,
+                 int dst_stride_y,
+                 uint16_t* dst_u,
+                 int dst_stride_u,
+                 uint16_t* dst_v,
+                 int dst_stride_v,
+                 int dst_width,
+                 int dst_height,
+                 enum FilterMode filtering) {
+  int src_halfwidth = SUBSAMPLE(src_width, 1, 1);
+  int src_halfheight = SUBSAMPLE(src_height, 1, 1);
+  int dst_halfwidth = SUBSAMPLE(dst_width, 1, 1);
+  int dst_halfheight = SUBSAMPLE(dst_height, 1, 1);
+
+  if (!src_y || !src_u || !src_v || src_width <= 0 || src_height == 0 ||
+      src_width > 32768 || src_height > 32768 || !dst_y || !dst_u || !dst_v ||
+      dst_width <= 0 || dst_height <= 0) {
+    return -1;
+  }
+
+  ScalePlane_12(src_y, src_stride_y, src_width, src_height, dst_y, dst_stride_y,
+                dst_width, dst_height, filtering);
+  ScalePlane_12(src_u, src_stride_u, src_halfwidth, src_halfheight, dst_u,
+                dst_stride_u, dst_halfwidth, dst_halfheight, filtering);
+  ScalePlane_12(src_v, src_stride_v, src_halfwidth, src_halfheight, dst_v,
+                dst_stride_v, dst_halfwidth, dst_halfheight, filtering);
+  return 0;
+}
+
+// Scale an I444 image.
+// This function in turn calls a scaling function for each plane.
+
+LIBYUV_API
+int I444Scale(const uint8_t* src_y,
+              int src_stride_y,
+              const uint8_t* src_u,
+              int src_stride_u,
+              const uint8_t* src_v,
+              int src_stride_v,
+              int src_width,
+              int src_height,
+              uint8_t* dst_y,
+              int dst_stride_y,
+              uint8_t* dst_u,
+              int dst_stride_u,
+              uint8_t* dst_v,
+              int dst_stride_v,
+              int dst_width,
+              int dst_height,
+              enum FilterMode filtering) {
+  if (!src_y || !src_u || !src_v || src_width <= 0 || src_height == 0 ||
+      src_width > 32768 || src_height > 32768 || !dst_y || !dst_u || !dst_v ||
+      dst_width <= 0 || dst_height <= 0) {
+    return -1;
+  }
+
+  ScalePlane(src_y, src_stride_y, src_width, src_height, dst_y, dst_stride_y,
+             dst_width, dst_height, filtering);
+  ScalePlane(src_u, src_stride_u, src_width, src_height, dst_u, dst_stride_u,
+             dst_width, dst_height, filtering);
+  ScalePlane(src_v, src_stride_v, src_width, src_height, dst_v, dst_stride_v,
+             dst_width, dst_height, filtering);
+  return 0;
+}
+
+LIBYUV_API
+int I444Scale_16(const uint16_t* src_y,
+                 int src_stride_y,
+                 const uint16_t* src_u,
+                 int src_stride_u,
+                 const uint16_t* src_v,
+                 int src_stride_v,
+                 int src_width,
+                 int src_height,
+                 uint16_t* dst_y,
+                 int dst_stride_y,
+                 uint16_t* dst_u,
+                 int dst_stride_u,
+                 uint16_t* dst_v,
+                 int dst_stride_v,
+                 int dst_width,
+                 int dst_height,
+                 enum FilterMode filtering) {
+  if (!src_y || !src_u || !src_v || src_width <= 0 || src_height == 0 ||
+      src_width > 32768 || src_height > 32768 || !dst_y || !dst_u || !dst_v ||
+      dst_width <= 0 || dst_height <= 0) {
+    return -1;
+  }
+
+  ScalePlane_16(src_y, src_stride_y, src_width, src_height, dst_y, dst_stride_y,
+                dst_width, dst_height, filtering);
+  ScalePlane_16(src_u, src_stride_u, src_width, src_height, dst_u, dst_stride_u,
+                dst_width, dst_height, filtering);
+  ScalePlane_16(src_v, src_stride_v, src_width, src_height, dst_v, dst_stride_v,
+                dst_width, dst_height, filtering);
+  return 0;
+}
+
+LIBYUV_API
+int I444Scale_12(const uint16_t* src_y,
+                 int src_stride_y,
+                 const uint16_t* src_u,
+                 int src_stride_u,
+                 const uint16_t* src_v,
+                 int src_stride_v,
+                 int src_width,
+                 int src_height,
+                 uint16_t* dst_y,
+                 int dst_stride_y,
+                 uint16_t* dst_u,
+                 int dst_stride_u,
+                 uint16_t* dst_v,
+                 int dst_stride_v,
+                 int dst_width,
+                 int dst_height,
+                 enum FilterMode filtering) {
+  if (!src_y || !src_u || !src_v || src_width <= 0 || src_height == 0 ||
+      src_width > 32768 || src_height > 32768 || !dst_y || !dst_u || !dst_v ||
+      dst_width <= 0 || dst_height <= 0) {
+    return -1;
+  }
+
+  ScalePlane_12(src_y, src_stride_y, src_width, src_height, dst_y, dst_stride_y,
+                dst_width, dst_height, filtering);
+  ScalePlane_12(src_u, src_stride_u, src_width, src_height, dst_u, dst_stride_u,
+                dst_width, dst_height, filtering);
+  ScalePlane_12(src_v, src_stride_v, src_width, src_height, dst_v, dst_stride_v,
+                dst_width, dst_height, filtering);
+  return 0;
+}
+
+// Scale an I422 image.
+// This function in turn calls a scaling function for each plane.
+
+LIBYUV_API
+int I422Scale(const uint8_t* src_y,
+              int src_stride_y,
+              const uint8_t* src_u,
+              int src_stride_u,
+              const uint8_t* src_v,
+              int src_stride_v,
+              int src_width,
+              int src_height,
+              uint8_t* dst_y,
+              int dst_stride_y,
+              uint8_t* dst_u,
+              int dst_stride_u,
+              uint8_t* dst_v,
+              int dst_stride_v,
+              int dst_width,
+              int dst_height,
+              enum FilterMode filtering) {
+  int src_halfwidth = SUBSAMPLE(src_width, 1, 1);
+  int dst_halfwidth = SUBSAMPLE(dst_width, 1, 1);
+
+  if (!src_y || !src_u || !src_v || src_width <= 0 || src_height == 0 ||
+      src_width > 32768 || src_height > 32768 || !dst_y || !dst_u || !dst_v ||
+      dst_width <= 0 || dst_height <= 0) {
+    return -1;
+  }
+
+  ScalePlane(src_y, src_stride_y, src_width, src_height, dst_y, dst_stride_y,
+             dst_width, dst_height, filtering);
+  ScalePlane(src_u, src_stride_u, src_halfwidth, src_height, dst_u,
+             dst_stride_u, dst_halfwidth, dst_height, filtering);
+  ScalePlane(src_v, src_stride_v, src_halfwidth, src_height, dst_v,
+             dst_stride_v, dst_halfwidth, dst_height, filtering);
+  return 0;
+}
+
+LIBYUV_API
+int I422Scale_16(const uint16_t* src_y,
+                 int src_stride_y,
+                 const uint16_t* src_u,
+                 int src_stride_u,
+                 const uint16_t* src_v,
+                 int src_stride_v,
+                 int src_width,
+                 int src_height,
+                 uint16_t* dst_y,
+                 int dst_stride_y,
+                 uint16_t* dst_u,
+                 int dst_stride_u,
+                 uint16_t* dst_v,
+                 int dst_stride_v,
+                 int dst_width,
+                 int dst_height,
+                 enum FilterMode filtering) {
+  int src_halfwidth = SUBSAMPLE(src_width, 1, 1);
+  int dst_halfwidth = SUBSAMPLE(dst_width, 1, 1);
+
+  if (!src_y || !src_u || !src_v || src_width <= 0 || src_height == 0 ||
+      src_width > 32768 || src_height > 32768 || !dst_y || !dst_u || !dst_v ||
+      dst_width <= 0 || dst_height <= 0) {
+    return -1;
+  }
+
+  ScalePlane_16(src_y, src_stride_y, src_width, src_height, dst_y, dst_stride_y,
+                dst_width, dst_height, filtering);
+  ScalePlane_16(src_u, src_stride_u, src_halfwidth, src_height, dst_u,
+                dst_stride_u, dst_halfwidth, dst_height, filtering);
+  ScalePlane_16(src_v, src_stride_v, src_halfwidth, src_height, dst_v,
+                dst_stride_v, dst_halfwidth, dst_height, filtering);
+  return 0;
+}
+
+LIBYUV_API
+int I422Scale_12(const uint16_t* src_y,
+                 int src_stride_y,
+                 const uint16_t* src_u,
+                 int src_stride_u,
+                 const uint16_t* src_v,
+                 int src_stride_v,
+                 int src_width,
+                 int src_height,
+                 uint16_t* dst_y,
+                 int dst_stride_y,
+                 uint16_t* dst_u,
+                 int dst_stride_u,
+                 uint16_t* dst_v,
+                 int dst_stride_v,
+                 int dst_width,
+                 int dst_height,
+                 enum FilterMode filtering) {
+  int src_halfwidth = SUBSAMPLE(src_width, 1, 1);
+  int dst_halfwidth = SUBSAMPLE(dst_width, 1, 1);
+
+  if (!src_y || !src_u || !src_v || src_width <= 0 || src_height == 0 ||
+      src_width > 32768 || src_height > 32768 || !dst_y || !dst_u || !dst_v ||
+      dst_width <= 0 || dst_height <= 0) {
+    return -1;
+  }
+
+  ScalePlane_12(src_y, src_stride_y, src_width, src_height, dst_y, dst_stride_y,
+                dst_width, dst_height, filtering);
+  ScalePlane_12(src_u, src_stride_u, src_halfwidth, src_height, dst_u,
+                dst_stride_u, dst_halfwidth, dst_height, filtering);
+  ScalePlane_12(src_v, src_stride_v, src_halfwidth, src_height, dst_v,
+                dst_stride_v, dst_halfwidth, dst_height, filtering);
+  return 0;
+}
+
+// Scale an NV12 image.
+// This function in turn calls a scaling function for each plane.
+
+LIBYUV_API
+int NV12Scale(const uint8_t* src_y,
+              int src_stride_y,
+              const uint8_t* src_uv,
+              int src_stride_uv,
+              int src_width,
+              int src_height,
+              uint8_t* dst_y,
+              int dst_stride_y,
+              uint8_t* dst_uv,
+              int dst_stride_uv,
+              int dst_width,
+              int dst_height,
+              enum FilterMode filtering) {
+  int src_halfwidth = SUBSAMPLE(src_width, 1, 1);
+  int src_halfheight = SUBSAMPLE(src_height, 1, 1);
+  int dst_halfwidth = SUBSAMPLE(dst_width, 1, 1);
+  int dst_halfheight = SUBSAMPLE(dst_height, 1, 1);
+
+  if (!src_y || !src_uv || src_width <= 0 || src_height == 0 ||
+      src_width > 32768 || src_height > 32768 || !dst_y || !dst_uv ||
+      dst_width <= 0 || dst_height <= 0) {
+    return -1;
+  }
+
+  ScalePlane(src_y, src_stride_y, src_width, src_height, dst_y, dst_stride_y,
+             dst_width, dst_height, filtering);
+  UVScale(src_uv, src_stride_uv, src_halfwidth, src_halfheight, dst_uv,
+          dst_stride_uv, dst_halfwidth, dst_halfheight, filtering);
+  return 0;
+}
+
+// Deprecated api
+LIBYUV_API
+int Scale(const uint8_t* src_y,
+          const uint8_t* src_u,
+          const uint8_t* src_v,
+          int src_stride_y,
+          int src_stride_u,
+          int src_stride_v,
+          int src_width,
+          int src_height,
+          uint8_t* dst_y,
+          uint8_t* dst_u,
+          uint8_t* dst_v,
+          int dst_stride_y,
+          int dst_stride_u,
+          int dst_stride_v,
+          int dst_width,
+          int dst_height,
+          LIBYUV_BOOL interpolate) {
+  return I420Scale(src_y, src_stride_y, src_u, src_stride_u, src_v,
+                   src_stride_v, src_width, src_height, dst_y, dst_stride_y,
+                   dst_u, dst_stride_u, dst_v, dst_stride_v, dst_width,
+                   dst_height, interpolate ? kFilterBox : kFilterNone);
+}
+
+#ifdef __cplusplus
+}  // extern "C"
+}  // namespace libyuv
+#endif
diff --git a/3rdparty/libyuv/src/source/scale_any.cc b/3rdparty/libyuv/src/source/scale_any.cc
new file mode 100644
index 00000000..e820584b
--- /dev/null
+++ b/3rdparty/libyuv/src/source/scale_any.cc
@@ -0,0 +1,1062 @@
+/*
+ *  Copyright 2015 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include <string.h>  // For memset/memcpy
+
+#include "libyuv/scale.h"
+#include "libyuv/scale_row.h"
+
+#include "libyuv/basic_types.h"
+
+#ifdef __cplusplus
+namespace libyuv {
+extern "C" {
+#endif
+
+// Fixed scale down.
+// Mask may be non-power of 2, so use MOD
+#define SDANY(NAMEANY, SCALEROWDOWN_SIMD, SCALEROWDOWN_C, FACTOR, BPP, MASK)   \
+  void NAMEANY(const uint8_t* src_ptr, ptrdiff_t src_stride, uint8_t* dst_ptr, \
+               int dst_width) {                                                \
+    int r = (int)((unsigned int)dst_width % (MASK + 1)); /* NOLINT */          \
+    int n = dst_width - r;                                                     \
+    if (n > 0) {                                                               \
+      SCALEROWDOWN_SIMD(src_ptr, src_stride, dst_ptr, n);                      \
+    }                                                                          \
+    SCALEROWDOWN_C(src_ptr + (n * FACTOR) * BPP, src_stride,                   \
+                   dst_ptr + n * BPP, r);                                      \
+  }
+
+// Fixed scale down for odd source width.  Used by I420Blend subsampling.
+// Since dst_width is (width + 1) / 2, this function scales one less pixel
+// and copies the last pixel.
+#define SDODD(NAMEANY, SCALEROWDOWN_SIMD, SCALEROWDOWN_C, FACTOR, BPP, MASK)   \
+  void NAMEANY(const uint8_t* src_ptr, ptrdiff_t src_stride, uint8_t* dst_ptr, \
+               int dst_width) {                                                \
+    int r = (int)((unsigned int)(dst_width - 1) % (MASK + 1)); /* NOLINT */    \
+    int n = (dst_width - 1) - r;                                               \
+    if (n > 0) {                                                               \
+      SCALEROWDOWN_SIMD(src_ptr, src_stride, dst_ptr, n);                      \
+    }                                                                          \
+    SCALEROWDOWN_C(src_ptr + (n * FACTOR) * BPP, src_stride,                   \
+                   dst_ptr + n * BPP, r + 1);                                  \
+  }
+
+#ifdef HAS_SCALEROWDOWN2_SSSE3
+SDANY(ScaleRowDown2_Any_SSSE3, ScaleRowDown2_SSSE3, ScaleRowDown2_C, 2, 1, 15)
+SDANY(ScaleRowDown2Linear_Any_SSSE3,
+      ScaleRowDown2Linear_SSSE3,
+      ScaleRowDown2Linear_C,
+      2,
+      1,
+      15)
+SDANY(ScaleRowDown2Box_Any_SSSE3,
+      ScaleRowDown2Box_SSSE3,
+      ScaleRowDown2Box_C,
+      2,
+      1,
+      15)
+SDODD(ScaleRowDown2Box_Odd_SSSE3,
+      ScaleRowDown2Box_SSSE3,
+      ScaleRowDown2Box_Odd_C,
+      2,
+      1,
+      15)
+#endif
+#ifdef HAS_SCALEUVROWDOWN2BOX_SSSE3
+SDANY(ScaleUVRowDown2Box_Any_SSSE3,
+      ScaleUVRowDown2Box_SSSE3,
+      ScaleUVRowDown2Box_C,
+      2,
+      2,
+      3)
+#endif
+#ifdef HAS_SCALEUVROWDOWN2BOX_AVX2
+SDANY(ScaleUVRowDown2Box_Any_AVX2,
+      ScaleUVRowDown2Box_AVX2,
+      ScaleUVRowDown2Box_C,
+      2,
+      2,
+      7)
+#endif
+#ifdef HAS_SCALEROWDOWN2_AVX2
+SDANY(ScaleRowDown2_Any_AVX2, ScaleRowDown2_AVX2, ScaleRowDown2_C, 2, 1, 31)
+SDANY(ScaleRowDown2Linear_Any_AVX2,
+      ScaleRowDown2Linear_AVX2,
+      ScaleRowDown2Linear_C,
+      2,
+      1,
+      31)
+SDANY(ScaleRowDown2Box_Any_AVX2,
+      ScaleRowDown2Box_AVX2,
+      ScaleRowDown2Box_C,
+      2,
+      1,
+      31)
+SDODD(ScaleRowDown2Box_Odd_AVX2,
+      ScaleRowDown2Box_AVX2,
+      ScaleRowDown2Box_Odd_C,
+      2,
+      1,
+      31)
+#endif
+#ifdef HAS_SCALEROWDOWN2_NEON
+SDANY(ScaleRowDown2_Any_NEON, ScaleRowDown2_NEON, ScaleRowDown2_C, 2, 1, 15)
+SDANY(ScaleRowDown2Linear_Any_NEON,
+      ScaleRowDown2Linear_NEON,
+      ScaleRowDown2Linear_C,
+      2,
+      1,
+      15)
+SDANY(ScaleRowDown2Box_Any_NEON,
+      ScaleRowDown2Box_NEON,
+      ScaleRowDown2Box_C,
+      2,
+      1,
+      15)
+SDODD(ScaleRowDown2Box_Odd_NEON,
+      ScaleRowDown2Box_NEON,
+      ScaleRowDown2Box_Odd_C,
+      2,
+      1,
+      15)
+#endif
+#ifdef HAS_SCALEUVROWDOWN2BOX_NEON
+SDANY(ScaleUVRowDown2Box_Any_NEON,
+      ScaleUVRowDown2Box_NEON,
+      ScaleUVRowDown2Box_C,
+      2,
+      2,
+      7)
+#endif
+
+#ifdef HAS_SCALEROWDOWN2_MSA
+SDANY(ScaleRowDown2_Any_MSA, ScaleRowDown2_MSA, ScaleRowDown2_C, 2, 1, 31)
+SDANY(ScaleRowDown2Linear_Any_MSA,
+      ScaleRowDown2Linear_MSA,
+      ScaleRowDown2Linear_C,
+      2,
+      1,
+      31)
+SDANY(ScaleRowDown2Box_Any_MSA,
+      ScaleRowDown2Box_MSA,
+      ScaleRowDown2Box_C,
+      2,
+      1,
+      31)
+#endif
+#ifdef HAS_SCALEROWDOWN2_LSX
+SDANY(ScaleRowDown2_Any_LSX, ScaleRowDown2_LSX, ScaleRowDown2_C, 2, 1, 31)
+SDANY(ScaleRowDown2Linear_Any_LSX,
+      ScaleRowDown2Linear_LSX,
+      ScaleRowDown2Linear_C,
+      2,
+      1,
+      31)
+SDANY(ScaleRowDown2Box_Any_LSX,
+      ScaleRowDown2Box_LSX,
+      ScaleRowDown2Box_C,
+      2,
+      1,
+      31)
+#endif
+#ifdef HAS_SCALEROWDOWN4_SSSE3
+SDANY(ScaleRowDown4_Any_SSSE3, ScaleRowDown4_SSSE3, ScaleRowDown4_C, 4, 1, 7)
+SDANY(ScaleRowDown4Box_Any_SSSE3,
+      ScaleRowDown4Box_SSSE3,
+      ScaleRowDown4Box_C,
+      4,
+      1,
+      7)
+#endif
+#ifdef HAS_SCALEROWDOWN4_AVX2
+SDANY(ScaleRowDown4_Any_AVX2, ScaleRowDown4_AVX2, ScaleRowDown4_C, 4, 1, 15)
+SDANY(ScaleRowDown4Box_Any_AVX2,
+      ScaleRowDown4Box_AVX2,
+      ScaleRowDown4Box_C,
+      4,
+      1,
+      15)
+#endif
+#ifdef HAS_SCALEROWDOWN4_NEON
+SDANY(ScaleRowDown4_Any_NEON, ScaleRowDown4_NEON, ScaleRowDown4_C, 4, 1, 7)
+SDANY(ScaleRowDown4Box_Any_NEON,
+      ScaleRowDown4Box_NEON,
+      ScaleRowDown4Box_C,
+      4,
+      1,
+      7)
+#endif
+#ifdef HAS_SCALEROWDOWN4_MSA
+SDANY(ScaleRowDown4_Any_MSA, ScaleRowDown4_MSA, ScaleRowDown4_C, 4, 1, 15)
+SDANY(ScaleRowDown4Box_Any_MSA,
+      ScaleRowDown4Box_MSA,
+      ScaleRowDown4Box_C,
+      4,
+      1,
+      15)
+#endif
+#ifdef HAS_SCALEROWDOWN4_LSX
+SDANY(ScaleRowDown4_Any_LSX, ScaleRowDown4_LSX, ScaleRowDown4_C, 4, 1, 15)
+SDANY(ScaleRowDown4Box_Any_LSX,
+      ScaleRowDown4Box_LSX,
+      ScaleRowDown4Box_C,
+      4,
+      1,
+      15)
+#endif
+#ifdef HAS_SCALEROWDOWN34_SSSE3
+SDANY(ScaleRowDown34_Any_SSSE3,
+      ScaleRowDown34_SSSE3,
+      ScaleRowDown34_C,
+      4 / 3,
+      1,
+      23)
+SDANY(ScaleRowDown34_0_Box_Any_SSSE3,
+      ScaleRowDown34_0_Box_SSSE3,
+      ScaleRowDown34_0_Box_C,
+      4 / 3,
+      1,
+      23)
+SDANY(ScaleRowDown34_1_Box_Any_SSSE3,
+      ScaleRowDown34_1_Box_SSSE3,
+      ScaleRowDown34_1_Box_C,
+      4 / 3,
+      1,
+      23)
+#endif
+#ifdef HAS_SCALEROWDOWN34_NEON
+SDANY(ScaleRowDown34_Any_NEON,
+      ScaleRowDown34_NEON,
+      ScaleRowDown34_C,
+      4 / 3,
+      1,
+      23)
+SDANY(ScaleRowDown34_0_Box_Any_NEON,
+      ScaleRowDown34_0_Box_NEON,
+      ScaleRowDown34_0_Box_C,
+      4 / 3,
+      1,
+      23)
+SDANY(ScaleRowDown34_1_Box_Any_NEON,
+      ScaleRowDown34_1_Box_NEON,
+      ScaleRowDown34_1_Box_C,
+      4 / 3,
+      1,
+      23)
+#endif
+#ifdef HAS_SCALEROWDOWN34_MSA
+SDANY(ScaleRowDown34_Any_MSA,
+      ScaleRowDown34_MSA,
+      ScaleRowDown34_C,
+      4 / 3,
+      1,
+      47)
+SDANY(ScaleRowDown34_0_Box_Any_MSA,
+      ScaleRowDown34_0_Box_MSA,
+      ScaleRowDown34_0_Box_C,
+      4 / 3,
+      1,
+      47)
+SDANY(ScaleRowDown34_1_Box_Any_MSA,
+      ScaleRowDown34_1_Box_MSA,
+      ScaleRowDown34_1_Box_C,
+      4 / 3,
+      1,
+      47)
+#endif
+#ifdef HAS_SCALEROWDOWN34_LSX
+SDANY(ScaleRowDown34_Any_LSX,
+      ScaleRowDown34_LSX,
+      ScaleRowDown34_C,
+      4 / 3,
+      1,
+      47)
+SDANY(ScaleRowDown34_0_Box_Any_LSX,
+      ScaleRowDown34_0_Box_LSX,
+      ScaleRowDown34_0_Box_C,
+      4 / 3,
+      1,
+      47)
+SDANY(ScaleRowDown34_1_Box_Any_LSX,
+      ScaleRowDown34_1_Box_LSX,
+      ScaleRowDown34_1_Box_C,
+      4 / 3,
+      1,
+      47)
+#endif
+#ifdef HAS_SCALEROWDOWN38_SSSE3
+SDANY(ScaleRowDown38_Any_SSSE3,
+      ScaleRowDown38_SSSE3,
+      ScaleRowDown38_C,
+      8 / 3,
+      1,
+      11)
+SDANY(ScaleRowDown38_3_Box_Any_SSSE3,
+      ScaleRowDown38_3_Box_SSSE3,
+      ScaleRowDown38_3_Box_C,
+      8 / 3,
+      1,
+      5)
+SDANY(ScaleRowDown38_2_Box_Any_SSSE3,
+      ScaleRowDown38_2_Box_SSSE3,
+      ScaleRowDown38_2_Box_C,
+      8 / 3,
+      1,
+      5)
+#endif
+#ifdef HAS_SCALEROWDOWN38_NEON
+SDANY(ScaleRowDown38_Any_NEON,
+      ScaleRowDown38_NEON,
+      ScaleRowDown38_C,
+      8 / 3,
+      1,
+      11)
+SDANY(ScaleRowDown38_3_Box_Any_NEON,
+      ScaleRowDown38_3_Box_NEON,
+      ScaleRowDown38_3_Box_C,
+      8 / 3,
+      1,
+      11)
+SDANY(ScaleRowDown38_2_Box_Any_NEON,
+      ScaleRowDown38_2_Box_NEON,
+      ScaleRowDown38_2_Box_C,
+      8 / 3,
+      1,
+      11)
+#endif
+#ifdef HAS_SCALEROWDOWN38_MSA
+SDANY(ScaleRowDown38_Any_MSA,
+      ScaleRowDown38_MSA,
+      ScaleRowDown38_C,
+      8 / 3,
+      1,
+      11)
+SDANY(ScaleRowDown38_3_Box_Any_MSA,
+      ScaleRowDown38_3_Box_MSA,
+      ScaleRowDown38_3_Box_C,
+      8 / 3,
+      1,
+      11)
+SDANY(ScaleRowDown38_2_Box_Any_MSA,
+      ScaleRowDown38_2_Box_MSA,
+      ScaleRowDown38_2_Box_C,
+      8 / 3,
+      1,
+      11)
+#endif
+#ifdef HAS_SCALEROWDOWN38_LSX
+SDANY(ScaleRowDown38_Any_LSX,
+      ScaleRowDown38_LSX,
+      ScaleRowDown38_C,
+      8 / 3,
+      1,
+      11)
+SDANY(ScaleRowDown38_3_Box_Any_LSX,
+      ScaleRowDown38_3_Box_LSX,
+      ScaleRowDown38_3_Box_C,
+      8 / 3,
+      1,
+      11)
+SDANY(ScaleRowDown38_2_Box_Any_LSX,
+      ScaleRowDown38_2_Box_LSX,
+      ScaleRowDown38_2_Box_C,
+      8 / 3,
+      1,
+      11)
+#endif
+
+#ifdef HAS_SCALEARGBROWDOWN2_SSE2
+SDANY(ScaleARGBRowDown2_Any_SSE2,
+      ScaleARGBRowDown2_SSE2,
+      ScaleARGBRowDown2_C,
+      2,
+      4,
+      3)
+SDANY(ScaleARGBRowDown2Linear_Any_SSE2,
+      ScaleARGBRowDown2Linear_SSE2,
+      ScaleARGBRowDown2Linear_C,
+      2,
+      4,
+      3)
+SDANY(ScaleARGBRowDown2Box_Any_SSE2,
+      ScaleARGBRowDown2Box_SSE2,
+      ScaleARGBRowDown2Box_C,
+      2,
+      4,
+      3)
+#endif
+#ifdef HAS_SCALEARGBROWDOWN2_NEON
+SDANY(ScaleARGBRowDown2_Any_NEON,
+      ScaleARGBRowDown2_NEON,
+      ScaleARGBRowDown2_C,
+      2,
+      4,
+      7)
+SDANY(ScaleARGBRowDown2Linear_Any_NEON,
+      ScaleARGBRowDown2Linear_NEON,
+      ScaleARGBRowDown2Linear_C,
+      2,
+      4,
+      7)
+SDANY(ScaleARGBRowDown2Box_Any_NEON,
+      ScaleARGBRowDown2Box_NEON,
+      ScaleARGBRowDown2Box_C,
+      2,
+      4,
+      7)
+#endif
+#ifdef HAS_SCALEARGBROWDOWN2_MSA
+SDANY(ScaleARGBRowDown2_Any_MSA,
+      ScaleARGBRowDown2_MSA,
+      ScaleARGBRowDown2_C,
+      2,
+      4,
+      3)
+SDANY(ScaleARGBRowDown2Linear_Any_MSA,
+      ScaleARGBRowDown2Linear_MSA,
+      ScaleARGBRowDown2Linear_C,
+      2,
+      4,
+      3)
+SDANY(ScaleARGBRowDown2Box_Any_MSA,
+      ScaleARGBRowDown2Box_MSA,
+      ScaleARGBRowDown2Box_C,
+      2,
+      4,
+      3)
+#endif
+#ifdef HAS_SCALEARGBROWDOWN2_LSX
+SDANY(ScaleARGBRowDown2_Any_LSX,
+      ScaleARGBRowDown2_LSX,
+      ScaleARGBRowDown2_C,
+      2,
+      4,
+      3)
+SDANY(ScaleARGBRowDown2Linear_Any_LSX,
+      ScaleARGBRowDown2Linear_LSX,
+      ScaleARGBRowDown2Linear_C,
+      2,
+      4,
+      3)
+SDANY(ScaleARGBRowDown2Box_Any_LSX,
+      ScaleARGBRowDown2Box_LSX,
+      ScaleARGBRowDown2Box_C,
+      2,
+      4,
+      3)
+#endif
+#undef SDANY
+
+// Scale down by even scale factor.
+#define SDAANY(NAMEANY, SCALEROWDOWN_SIMD, SCALEROWDOWN_C, BPP, MASK)       \
+  void NAMEANY(const uint8_t* src_ptr, ptrdiff_t src_stride, int src_stepx, \
+               uint8_t* dst_ptr, int dst_width) {                           \
+    int r = dst_width & MASK;                                               \
+    int n = dst_width & ~MASK;                                              \
+    if (n > 0) {                                                            \
+      SCALEROWDOWN_SIMD(src_ptr, src_stride, src_stepx, dst_ptr, n);        \
+    }                                                                       \
+    SCALEROWDOWN_C(src_ptr + (n * src_stepx) * BPP, src_stride, src_stepx,  \
+                   dst_ptr + n * BPP, r);                                   \
+  }
+
+#ifdef HAS_SCALEARGBROWDOWNEVEN_SSE2
+SDAANY(ScaleARGBRowDownEven_Any_SSE2,
+       ScaleARGBRowDownEven_SSE2,
+       ScaleARGBRowDownEven_C,
+       4,
+       3)
+SDAANY(ScaleARGBRowDownEvenBox_Any_SSE2,
+       ScaleARGBRowDownEvenBox_SSE2,
+       ScaleARGBRowDownEvenBox_C,
+       4,
+       3)
+#endif
+#ifdef HAS_SCALEARGBROWDOWNEVEN_NEON
+SDAANY(ScaleARGBRowDownEven_Any_NEON,
+       ScaleARGBRowDownEven_NEON,
+       ScaleARGBRowDownEven_C,
+       4,
+       3)
+SDAANY(ScaleARGBRowDownEvenBox_Any_NEON,
+       ScaleARGBRowDownEvenBox_NEON,
+       ScaleARGBRowDownEvenBox_C,
+       4,
+       3)
+#endif
+#ifdef HAS_SCALEARGBROWDOWNEVEN_MSA
+SDAANY(ScaleARGBRowDownEven_Any_MSA,
+       ScaleARGBRowDownEven_MSA,
+       ScaleARGBRowDownEven_C,
+       4,
+       3)
+SDAANY(ScaleARGBRowDownEvenBox_Any_MSA,
+       ScaleARGBRowDownEvenBox_MSA,
+       ScaleARGBRowDownEvenBox_C,
+       4,
+       3)
+#endif
+#ifdef HAS_SCALEARGBROWDOWNEVEN_LSX
+SDAANY(ScaleARGBRowDownEven_Any_LSX,
+       ScaleARGBRowDownEven_LSX,
+       ScaleARGBRowDownEven_C,
+       4,
+       3)
+SDAANY(ScaleARGBRowDownEvenBox_Any_LSX,
+       ScaleARGBRowDownEvenBox_LSX,
+       ScaleARGBRowDownEvenBox_C,
+       4,
+       3)
+#endif
+#ifdef HAS_SCALEUVROWDOWNEVEN_NEON
+SDAANY(ScaleUVRowDownEven_Any_NEON,
+       ScaleUVRowDownEven_NEON,
+       ScaleUVRowDownEven_C,
+       2,
+       3)
+#endif
+
+#ifdef SASIMDONLY
+// This also works and uses memcpy and SIMD instead of C, but is slower on ARM
+
+// Add rows box filter scale down.  Using macro from row_any
+#define SAROW(NAMEANY, ANY_SIMD, SBPP, BPP, MASK)                      \
+  void NAMEANY(const uint8_t* src_ptr, uint16_t* dst_ptr, int width) { \
+    SIMD_ALIGNED(uint16_t dst_temp[32]);                               \
+    SIMD_ALIGNED(uint8_t src_temp[32]);                                \
+    memset(dst_temp, 0, 32 * 2); /* for msan */                        \
+    int r = width & MASK;                                              \
+    int n = width & ~MASK;                                             \
+    if (n > 0) {                                                       \
+      ANY_SIMD(src_ptr, dst_ptr, n);                                   \
+    }                                                                  \
+    memcpy(src_temp, src_ptr + n * SBPP, r * SBPP);                    \
+    memcpy(dst_temp, dst_ptr + n * BPP, r * BPP);                      \
+    ANY_SIMD(src_temp, dst_temp, MASK + 1);                            \
+    memcpy(dst_ptr + n * BPP, dst_temp, r * BPP);                      \
+  }
+
+#ifdef HAS_SCALEADDROW_SSE2
+SAROW(ScaleAddRow_Any_SSE2, ScaleAddRow_SSE2, 1, 2, 15)
+#endif
+#ifdef HAS_SCALEADDROW_AVX2
+SAROW(ScaleAddRow_Any_AVX2, ScaleAddRow_AVX2, 1, 2, 31)
+#endif
+#ifdef HAS_SCALEADDROW_NEON
+SAROW(ScaleAddRow_Any_NEON, ScaleAddRow_NEON, 1, 2, 15)
+#endif
+#ifdef HAS_SCALEADDROW_MSA
+SAROW(ScaleAddRow_Any_MSA, ScaleAddRow_MSA, 1, 2, 15)
+#endif
+#ifdef HAS_SCALEADDROW_LSX
+SAROW(ScaleAddRow_Any_LSX, ScaleAddRow_LSX, 1, 2, 15)
+#endif
+#undef SAANY
+
+#else
+
+// Add rows box filter scale down.
+#define SAANY(NAMEANY, SCALEADDROW_SIMD, SCALEADDROW_C, MASK)              \
+  void NAMEANY(const uint8_t* src_ptr, uint16_t* dst_ptr, int src_width) { \
+    int n = src_width & ~MASK;                                             \
+    if (n > 0) {                                                           \
+      SCALEADDROW_SIMD(src_ptr, dst_ptr, n);                               \
+    }                                                                      \
+    SCALEADDROW_C(src_ptr + n, dst_ptr + n, src_width & MASK);             \
+  }
+
+#ifdef HAS_SCALEADDROW_SSE2
+SAANY(ScaleAddRow_Any_SSE2, ScaleAddRow_SSE2, ScaleAddRow_C, 15)
+#endif
+#ifdef HAS_SCALEADDROW_AVX2
+SAANY(ScaleAddRow_Any_AVX2, ScaleAddRow_AVX2, ScaleAddRow_C, 31)
+#endif
+#ifdef HAS_SCALEADDROW_NEON
+SAANY(ScaleAddRow_Any_NEON, ScaleAddRow_NEON, ScaleAddRow_C, 15)
+#endif
+#ifdef HAS_SCALEADDROW_MSA
+SAANY(ScaleAddRow_Any_MSA, ScaleAddRow_MSA, ScaleAddRow_C, 15)
+#endif
+#ifdef HAS_SCALEADDROW_LSX
+SAANY(ScaleAddRow_Any_LSX, ScaleAddRow_LSX, ScaleAddRow_C, 15)
+#endif
+#undef SAANY
+
+#endif  // SASIMDONLY
+
+// Definition for ScaleFilterCols, ScaleARGBCols and ScaleARGBFilterCols
+#define CANY(NAMEANY, TERP_SIMD, TERP_C, BPP, MASK)                            \
+  void NAMEANY(uint8_t* dst_ptr, const uint8_t* src_ptr, int dst_width, int x, \
+               int dx) {                                                       \
+    int r = dst_width & MASK;                                                  \
+    int n = dst_width & ~MASK;                                                 \
+    if (n > 0) {                                                               \
+      TERP_SIMD(dst_ptr, src_ptr, n, x, dx);                                   \
+    }                                                                          \
+    TERP_C(dst_ptr + n * BPP, src_ptr, r, x + n * dx, dx);                     \
+  }
+
+#ifdef HAS_SCALEFILTERCOLS_NEON
+CANY(ScaleFilterCols_Any_NEON, ScaleFilterCols_NEON, ScaleFilterCols_C, 1, 7)
+#endif
+#ifdef HAS_SCALEFILTERCOLS_MSA
+CANY(ScaleFilterCols_Any_MSA, ScaleFilterCols_MSA, ScaleFilterCols_C, 1, 15)
+#endif
+#ifdef HAS_SCALEFILTERCOLS_LSX
+CANY(ScaleFilterCols_Any_LSX, ScaleFilterCols_LSX, ScaleFilterCols_C, 1, 15)
+#endif
+#ifdef HAS_SCALEARGBCOLS_NEON
+CANY(ScaleARGBCols_Any_NEON, ScaleARGBCols_NEON, ScaleARGBCols_C, 4, 7)
+#endif
+#ifdef HAS_SCALEARGBCOLS_MSA
+CANY(ScaleARGBCols_Any_MSA, ScaleARGBCols_MSA, ScaleARGBCols_C, 4, 3)
+#endif
+#ifdef HAS_SCALEARGBCOLS_LSX
+CANY(ScaleARGBCols_Any_LSX, ScaleARGBCols_LSX, ScaleARGBCols_C, 4, 3)
+#endif
+#ifdef HAS_SCALEARGBFILTERCOLS_NEON
+CANY(ScaleARGBFilterCols_Any_NEON,
+     ScaleARGBFilterCols_NEON,
+     ScaleARGBFilterCols_C,
+     4,
+     3)
+#endif
+#ifdef HAS_SCALEARGBFILTERCOLS_MSA
+CANY(ScaleARGBFilterCols_Any_MSA,
+     ScaleARGBFilterCols_MSA,
+     ScaleARGBFilterCols_C,
+     4,
+     7)
+#endif
+#ifdef HAS_SCALEARGBFILTERCOLS_LSX
+CANY(ScaleARGBFilterCols_Any_LSX,
+     ScaleARGBFilterCols_LSX,
+     ScaleARGBFilterCols_C,
+     4,
+     7)
+#endif
+#undef CANY
+
+// Scale up horizontally 2 times using linear filter.
+#define SUH2LANY(NAME, SIMD, C, MASK, PTYPE)                       \
+  void NAME(const PTYPE* src_ptr, PTYPE* dst_ptr, int dst_width) { \
+    int work_width = (dst_width - 1) & ~1;                         \
+    int r = work_width & MASK;                                     \
+    int n = work_width & ~MASK;                                    \
+    dst_ptr[0] = src_ptr[0];                                       \
+    if (work_width > 0) {                                          \
+      if (n != 0) {                                                \
+        SIMD(src_ptr, dst_ptr + 1, n);                             \
+      }                                                            \
+      C(src_ptr + (n / 2), dst_ptr + n + 1, r);                    \
+    }                                                              \
+    dst_ptr[dst_width - 1] = src_ptr[(dst_width - 1) / 2];         \
+  }
+
+// Even the C versions need to be wrapped, because boundary pixels have to
+// be handled differently
+
+SUH2LANY(ScaleRowUp2_Linear_Any_C,
+         ScaleRowUp2_Linear_C,
+         ScaleRowUp2_Linear_C,
+         0,
+         uint8_t)
+
+SUH2LANY(ScaleRowUp2_Linear_16_Any_C,
+         ScaleRowUp2_Linear_16_C,
+         ScaleRowUp2_Linear_16_C,
+         0,
+         uint16_t)
+
+#ifdef HAS_SCALEROWUP2LINEAR_SSE2
+SUH2LANY(ScaleRowUp2_Linear_Any_SSE2,
+         ScaleRowUp2_Linear_SSE2,
+         ScaleRowUp2_Linear_C,
+         15,
+         uint8_t)
+#endif
+
+#ifdef HAS_SCALEROWUP2LINEAR_SSSE3
+SUH2LANY(ScaleRowUp2_Linear_Any_SSSE3,
+         ScaleRowUp2_Linear_SSSE3,
+         ScaleRowUp2_Linear_C,
+         15,
+         uint8_t)
+#endif
+
+#ifdef HAS_SCALEROWUP2LINEAR_12_SSSE3
+SUH2LANY(ScaleRowUp2_Linear_12_Any_SSSE3,
+         ScaleRowUp2_Linear_12_SSSE3,
+         ScaleRowUp2_Linear_16_C,
+         15,
+         uint16_t)
+#endif
+
+#ifdef HAS_SCALEROWUP2LINEAR_16_SSE2
+SUH2LANY(ScaleRowUp2_Linear_16_Any_SSE2,
+         ScaleRowUp2_Linear_16_SSE2,
+         ScaleRowUp2_Linear_16_C,
+         7,
+         uint16_t)
+#endif
+
+#ifdef HAS_SCALEROWUP2LINEAR_AVX2
+SUH2LANY(ScaleRowUp2_Linear_Any_AVX2,
+         ScaleRowUp2_Linear_AVX2,
+         ScaleRowUp2_Linear_C,
+         31,
+         uint8_t)
+#endif
+
+#ifdef HAS_SCALEROWUP2LINEAR_12_AVX2
+SUH2LANY(ScaleRowUp2_Linear_12_Any_AVX2,
+         ScaleRowUp2_Linear_12_AVX2,
+         ScaleRowUp2_Linear_16_C,
+         31,
+         uint16_t)
+#endif
+
+#ifdef HAS_SCALEROWUP2LINEAR_16_AVX2
+SUH2LANY(ScaleRowUp2_Linear_16_Any_AVX2,
+         ScaleRowUp2_Linear_16_AVX2,
+         ScaleRowUp2_Linear_16_C,
+         15,
+         uint16_t)
+#endif
+
+#ifdef HAS_SCALEROWUP2LINEAR_NEON
+SUH2LANY(ScaleRowUp2_Linear_Any_NEON,
+         ScaleRowUp2_Linear_NEON,
+         ScaleRowUp2_Linear_C,
+         15,
+         uint8_t)
+#endif
+
+#ifdef HAS_SCALEROWUP2LINEAR_12_NEON
+SUH2LANY(ScaleRowUp2_Linear_12_Any_NEON,
+         ScaleRowUp2_Linear_12_NEON,
+         ScaleRowUp2_Linear_16_C,
+         15,
+         uint16_t)
+#endif
+
+#ifdef HAS_SCALEROWUP2LINEAR_16_NEON
+SUH2LANY(ScaleRowUp2_Linear_16_Any_NEON,
+         ScaleRowUp2_Linear_16_NEON,
+         ScaleRowUp2_Linear_16_C,
+         15,
+         uint16_t)
+#endif
+
+#undef SUH2LANY
+
+// Scale up 2 times using bilinear filter.
+// This function produces 2 rows at a time.
+#define SU2BLANY(NAME, SIMD, C, MASK, PTYPE)                              \
+  void NAME(const PTYPE* src_ptr, ptrdiff_t src_stride, PTYPE* dst_ptr,   \
+            ptrdiff_t dst_stride, int dst_width) {                        \
+    int work_width = (dst_width - 1) & ~1;                                \
+    int r = work_width & MASK;                                            \
+    int n = work_width & ~MASK;                                           \
+    const PTYPE* sa = src_ptr;                                            \
+    const PTYPE* sb = src_ptr + src_stride;                               \
+    PTYPE* da = dst_ptr;                                                  \
+    PTYPE* db = dst_ptr + dst_stride;                                     \
+    da[0] = (3 * sa[0] + sb[0] + 2) >> 2;                                 \
+    db[0] = (sa[0] + 3 * sb[0] + 2) >> 2;                                 \
+    if (work_width > 0) {                                                 \
+      if (n != 0) {                                                       \
+        SIMD(sa, sb - sa, da + 1, db - da, n);                            \
+      }                                                                   \
+      C(sa + (n / 2), sb - sa, da + n + 1, db - da, r);                   \
+    }                                                                     \
+    da[dst_width - 1] =                                                   \
+        (3 * sa[(dst_width - 1) / 2] + sb[(dst_width - 1) / 2] + 2) >> 2; \
+    db[dst_width - 1] =                                                   \
+        (sa[(dst_width - 1) / 2] + 3 * sb[(dst_width - 1) / 2] + 2) >> 2; \
+  }
+
+SU2BLANY(ScaleRowUp2_Bilinear_Any_C,
+         ScaleRowUp2_Bilinear_C,
+         ScaleRowUp2_Bilinear_C,
+         0,
+         uint8_t)
+
+SU2BLANY(ScaleRowUp2_Bilinear_16_Any_C,
+         ScaleRowUp2_Bilinear_16_C,
+         ScaleRowUp2_Bilinear_16_C,
+         0,
+         uint16_t)
+
+#ifdef HAS_SCALEROWUP2BILINEAR_SSE2
+SU2BLANY(ScaleRowUp2_Bilinear_Any_SSE2,
+         ScaleRowUp2_Bilinear_SSE2,
+         ScaleRowUp2_Bilinear_C,
+         15,
+         uint8_t)
+#endif
+
+#ifdef HAS_SCALEROWUP2BILINEAR_12_SSSE3
+SU2BLANY(ScaleRowUp2_Bilinear_12_Any_SSSE3,
+         ScaleRowUp2_Bilinear_12_SSSE3,
+         ScaleRowUp2_Bilinear_16_C,
+         15,
+         uint16_t)
+#endif
+
+#ifdef HAS_SCALEROWUP2BILINEAR_16_SSE2
+SU2BLANY(ScaleRowUp2_Bilinear_16_Any_SSSE3,
+         ScaleRowUp2_Bilinear_16_SSE2,
+         ScaleRowUp2_Bilinear_16_C,
+         7,
+         uint16_t)
+#endif
+
+#ifdef HAS_SCALEROWUP2BILINEAR_SSSE3
+SU2BLANY(ScaleRowUp2_Bilinear_Any_SSSE3,
+         ScaleRowUp2_Bilinear_SSSE3,
+         ScaleRowUp2_Bilinear_C,
+         15,
+         uint8_t)
+#endif
+
+#ifdef HAS_SCALEROWUP2BILINEAR_AVX2
+SU2BLANY(ScaleRowUp2_Bilinear_Any_AVX2,
+         ScaleRowUp2_Bilinear_AVX2,
+         ScaleRowUp2_Bilinear_C,
+         31,
+         uint8_t)
+#endif
+
+#ifdef HAS_SCALEROWUP2BILINEAR_12_AVX2
+SU2BLANY(ScaleRowUp2_Bilinear_12_Any_AVX2,
+         ScaleRowUp2_Bilinear_12_AVX2,
+         ScaleRowUp2_Bilinear_16_C,
+         15,
+         uint16_t)
+#endif
+
+#ifdef HAS_SCALEROWUP2BILINEAR_16_AVX2
+SU2BLANY(ScaleRowUp2_Bilinear_16_Any_AVX2,
+         ScaleRowUp2_Bilinear_16_AVX2,
+         ScaleRowUp2_Bilinear_16_C,
+         15,
+         uint16_t)
+#endif
+
+#ifdef HAS_SCALEROWUP2BILINEAR_NEON
+SU2BLANY(ScaleRowUp2_Bilinear_Any_NEON,
+         ScaleRowUp2_Bilinear_NEON,
+         ScaleRowUp2_Bilinear_C,
+         15,
+         uint8_t)
+#endif
+
+#ifdef HAS_SCALEROWUP2BILINEAR_12_NEON
+SU2BLANY(ScaleRowUp2_Bilinear_12_Any_NEON,
+         ScaleRowUp2_Bilinear_12_NEON,
+         ScaleRowUp2_Bilinear_16_C,
+         15,
+         uint16_t)
+#endif
+
+#ifdef HAS_SCALEROWUP2BILINEAR_16_NEON
+SU2BLANY(ScaleRowUp2_Bilinear_16_Any_NEON,
+         ScaleRowUp2_Bilinear_16_NEON,
+         ScaleRowUp2_Bilinear_16_C,
+         7,
+         uint16_t)
+#endif
+
+#undef SU2BLANY
+
+// Scale bi-planar plane up horizontally 2 times using linear filter.
+#define SBUH2LANY(NAME, SIMD, C, MASK, PTYPE)                         \
+  void NAME(const PTYPE* src_ptr, PTYPE* dst_ptr, int dst_width) {    \
+    int work_width = (dst_width - 1) & ~1;                            \
+    int r = work_width & MASK;                                        \
+    int n = work_width & ~MASK;                                       \
+    dst_ptr[0] = src_ptr[0];                                          \
+    dst_ptr[1] = src_ptr[1];                                          \
+    if (work_width > 0) {                                             \
+      if (n != 0) {                                                   \
+        SIMD(src_ptr, dst_ptr + 2, n);                                \
+      }                                                               \
+      C(src_ptr + n, dst_ptr + 2 * n + 2, r);                         \
+    }                                                                 \
+    dst_ptr[2 * dst_width - 2] = src_ptr[((dst_width + 1) & ~1) - 2]; \
+    dst_ptr[2 * dst_width - 1] = src_ptr[((dst_width + 1) & ~1) - 1]; \
+  }
+
+SBUH2LANY(ScaleUVRowUp2_Linear_Any_C,
+          ScaleUVRowUp2_Linear_C,
+          ScaleUVRowUp2_Linear_C,
+          0,
+          uint8_t)
+
+SBUH2LANY(ScaleUVRowUp2_Linear_16_Any_C,
+          ScaleUVRowUp2_Linear_16_C,
+          ScaleUVRowUp2_Linear_16_C,
+          0,
+          uint16_t)
+
+#ifdef HAS_SCALEUVROWUP2LINEAR_SSSE3
+SBUH2LANY(ScaleUVRowUp2_Linear_Any_SSSE3,
+          ScaleUVRowUp2_Linear_SSSE3,
+          ScaleUVRowUp2_Linear_C,
+          7,
+          uint8_t)
+#endif
+
+#ifdef HAS_SCALEUVROWUP2LINEAR_AVX2
+SBUH2LANY(ScaleUVRowUp2_Linear_Any_AVX2,
+          ScaleUVRowUp2_Linear_AVX2,
+          ScaleUVRowUp2_Linear_C,
+          15,
+          uint8_t)
+#endif
+
+#ifdef HAS_SCALEUVROWUP2LINEAR_16_SSE41
+SBUH2LANY(ScaleUVRowUp2_Linear_16_Any_SSE41,
+          ScaleUVRowUp2_Linear_16_SSE41,
+          ScaleUVRowUp2_Linear_16_C,
+          3,
+          uint16_t)
+#endif
+
+#ifdef HAS_SCALEUVROWUP2LINEAR_16_AVX2
+SBUH2LANY(ScaleUVRowUp2_Linear_16_Any_AVX2,
+          ScaleUVRowUp2_Linear_16_AVX2,
+          ScaleUVRowUp2_Linear_16_C,
+          7,
+          uint16_t)
+#endif
+
+#ifdef HAS_SCALEUVROWUP2LINEAR_NEON
+SBUH2LANY(ScaleUVRowUp2_Linear_Any_NEON,
+          ScaleUVRowUp2_Linear_NEON,
+          ScaleUVRowUp2_Linear_C,
+          15,
+          uint8_t)
+#endif
+
+#ifdef HAS_SCALEUVROWUP2LINEAR_16_NEON
+SBUH2LANY(ScaleUVRowUp2_Linear_16_Any_NEON,
+          ScaleUVRowUp2_Linear_16_NEON,
+          ScaleUVRowUp2_Linear_16_C,
+          15,
+          uint16_t)
+#endif
+
+#undef SBUH2LANY
+
+// Scale bi-planar plane up 2 times using bilinear filter.
+// This function produces 2 rows at a time.
+#define SBU2BLANY(NAME, SIMD, C, MASK, PTYPE)                           \
+  void NAME(const PTYPE* src_ptr, ptrdiff_t src_stride, PTYPE* dst_ptr, \
+            ptrdiff_t dst_stride, int dst_width) {                      \
+    int work_width = (dst_width - 1) & ~1;                              \
+    int r = work_width & MASK;                                          \
+    int n = work_width & ~MASK;                                         \
+    const PTYPE* sa = src_ptr;                                          \
+    const PTYPE* sb = src_ptr + src_stride;                             \
+    PTYPE* da = dst_ptr;                                                \
+    PTYPE* db = dst_ptr + dst_stride;                                   \
+    da[0] = (3 * sa[0] + sb[0] + 2) >> 2;                               \
+    db[0] = (sa[0] + 3 * sb[0] + 2) >> 2;                               \
+    da[1] = (3 * sa[1] + sb[1] + 2) >> 2;                               \
+    db[1] = (sa[1] + 3 * sb[1] + 2) >> 2;                               \
+    if (work_width > 0) {                                               \
+      if (n != 0) {                                                     \
+        SIMD(sa, sb - sa, da + 2, db - da, n);                          \
+      }                                                                 \
+      C(sa + n, sb - sa, da + 2 * n + 2, db - da, r);                   \
+    }                                                                   \
+    da[2 * dst_width - 2] = (3 * sa[((dst_width + 1) & ~1) - 2] +       \
+                             sb[((dst_width + 1) & ~1) - 2] + 2) >>     \
+                            2;                                          \
+    db[2 * dst_width - 2] = (sa[((dst_width + 1) & ~1) - 2] +           \
+                             3 * sb[((dst_width + 1) & ~1) - 2] + 2) >> \
+                            2;                                          \
+    da[2 * dst_width - 1] = (3 * sa[((dst_width + 1) & ~1) - 1] +       \
+                             sb[((dst_width + 1) & ~1) - 1] + 2) >>     \
+                            2;                                          \
+    db[2 * dst_width - 1] = (sa[((dst_width + 1) & ~1) - 1] +           \
+                             3 * sb[((dst_width + 1) & ~1) - 1] + 2) >> \
+                            2;                                          \
+  }
+
+SBU2BLANY(ScaleUVRowUp2_Bilinear_Any_C,
+          ScaleUVRowUp2_Bilinear_C,
+          ScaleUVRowUp2_Bilinear_C,
+          0,
+          uint8_t)
+
+SBU2BLANY(ScaleUVRowUp2_Bilinear_16_Any_C,
+          ScaleUVRowUp2_Bilinear_16_C,
+          ScaleUVRowUp2_Bilinear_16_C,
+          0,
+          uint16_t)
+
+#ifdef HAS_SCALEUVROWUP2BILINEAR_SSSE3
+SBU2BLANY(ScaleUVRowUp2_Bilinear_Any_SSSE3,
+          ScaleUVRowUp2_Bilinear_SSSE3,
+          ScaleUVRowUp2_Bilinear_C,
+          7,
+          uint8_t)
+#endif
+
+#ifdef HAS_SCALEUVROWUP2BILINEAR_AVX2
+SBU2BLANY(ScaleUVRowUp2_Bilinear_Any_AVX2,
+          ScaleUVRowUp2_Bilinear_AVX2,
+          ScaleUVRowUp2_Bilinear_C,
+          15,
+          uint8_t)
+#endif
+
+#ifdef HAS_SCALEUVROWUP2BILINEAR_16_SSE41
+SBU2BLANY(ScaleUVRowUp2_Bilinear_16_Any_SSE41,
+          ScaleUVRowUp2_Bilinear_16_SSE41,
+          ScaleUVRowUp2_Bilinear_16_C,
+          7,
+          uint16_t)
+#endif
+
+#ifdef HAS_SCALEUVROWUP2BILINEAR_16_AVX2
+SBU2BLANY(ScaleUVRowUp2_Bilinear_16_Any_AVX2,
+          ScaleUVRowUp2_Bilinear_16_AVX2,
+          ScaleUVRowUp2_Bilinear_16_C,
+          7,
+          uint16_t)
+#endif
+
+#ifdef HAS_SCALEUVROWUP2BILINEAR_NEON
+SBU2BLANY(ScaleUVRowUp2_Bilinear_Any_NEON,
+          ScaleUVRowUp2_Bilinear_NEON,
+          ScaleUVRowUp2_Bilinear_C,
+          7,
+          uint8_t)
+#endif
+
+#ifdef HAS_SCALEUVROWUP2BILINEAR_16_NEON
+SBU2BLANY(ScaleUVRowUp2_Bilinear_16_Any_NEON,
+          ScaleUVRowUp2_Bilinear_16_NEON,
+          ScaleUVRowUp2_Bilinear_16_C,
+          7,
+          uint16_t)
+#endif
+
+#undef SBU2BLANY
+
+#ifdef __cplusplus
+}  // extern "C"
+}  // namespace libyuv
+#endif
diff --git a/3rdparty/libyuv/src/source/scale_argb.cc b/3rdparty/libyuv/src/source/scale_argb.cc
new file mode 100644
index 00000000..9c3acf7f
--- /dev/null
+++ b/3rdparty/libyuv/src/source/scale_argb.cc
@@ -0,0 +1,1129 @@
+/*
+ *  Copyright 2011 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include "libyuv/scale.h"
+
+#include <assert.h>
+#include <string.h>
+
+#include "libyuv/cpu_id.h"
+#include "libyuv/planar_functions.h"  // For CopyARGB
+#include "libyuv/row.h"
+#include "libyuv/scale_row.h"
+
+#ifdef __cplusplus
+namespace libyuv {
+extern "C" {
+#endif
+
+static __inline int Abs(int v) {
+  return v >= 0 ? v : -v;
+}
+
+// ScaleARGB ARGB, 1/2
+// This is an optimized version for scaling down a ARGB to 1/2 of
+// its original size.
+static void ScaleARGBDown2(int src_width,
+                           int src_height,
+                           int dst_width,
+                           int dst_height,
+                           int src_stride,
+                           int dst_stride,
+                           const uint8_t* src_argb,
+                           uint8_t* dst_argb,
+                           int x,
+                           int dx,
+                           int y,
+                           int dy,
+                           enum FilterMode filtering) {
+  int j;
+  int row_stride = src_stride * (dy >> 16);
+  void (*ScaleARGBRowDown2)(const uint8_t* src_argb, ptrdiff_t src_stride,
+                            uint8_t* dst_argb, int dst_width) =
+      filtering == kFilterNone
+          ? ScaleARGBRowDown2_C
+          : (filtering == kFilterLinear ? ScaleARGBRowDown2Linear_C
+                                        : ScaleARGBRowDown2Box_C);
+  (void)src_width;
+  (void)src_height;
+  (void)dx;
+  assert(dx == 65536 * 2);      // Test scale factor of 2.
+  assert((dy & 0x1ffff) == 0);  // Test vertical scale is multiple of 2.
+  // Advance to odd row, even column.
+  if (filtering == kFilterBilinear) {
+    src_argb += (y >> 16) * (int64_t)src_stride + (x >> 16) * 4;
+  } else {
+    src_argb += (y >> 16) * (int64_t)src_stride + ((x >> 16) - 1) * 4;
+  }
+
+#if defined(HAS_SCALEARGBROWDOWN2_SSE2)
+  if (TestCpuFlag(kCpuHasSSE2)) {
+    ScaleARGBRowDown2 =
+        filtering == kFilterNone
+            ? ScaleARGBRowDown2_Any_SSE2
+            : (filtering == kFilterLinear ? ScaleARGBRowDown2Linear_Any_SSE2
+                                          : ScaleARGBRowDown2Box_Any_SSE2);
+    if (IS_ALIGNED(dst_width, 4)) {
+      ScaleARGBRowDown2 =
+          filtering == kFilterNone
+              ? ScaleARGBRowDown2_SSE2
+              : (filtering == kFilterLinear ? ScaleARGBRowDown2Linear_SSE2
+                                            : ScaleARGBRowDown2Box_SSE2);
+    }
+  }
+#endif
+#if defined(HAS_SCALEARGBROWDOWN2_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    ScaleARGBRowDown2 =
+        filtering == kFilterNone
+            ? ScaleARGBRowDown2_Any_NEON
+            : (filtering == kFilterLinear ? ScaleARGBRowDown2Linear_Any_NEON
+                                          : ScaleARGBRowDown2Box_Any_NEON);
+    if (IS_ALIGNED(dst_width, 8)) {
+      ScaleARGBRowDown2 =
+          filtering == kFilterNone
+              ? ScaleARGBRowDown2_NEON
+              : (filtering == kFilterLinear ? ScaleARGBRowDown2Linear_NEON
+                                            : ScaleARGBRowDown2Box_NEON);
+    }
+  }
+#endif
+#if defined(HAS_SCALEARGBROWDOWN2_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    ScaleARGBRowDown2 =
+        filtering == kFilterNone
+            ? ScaleARGBRowDown2_Any_MSA
+            : (filtering == kFilterLinear ? ScaleARGBRowDown2Linear_Any_MSA
+                                          : ScaleARGBRowDown2Box_Any_MSA);
+    if (IS_ALIGNED(dst_width, 4)) {
+      ScaleARGBRowDown2 =
+          filtering == kFilterNone
+              ? ScaleARGBRowDown2_MSA
+              : (filtering == kFilterLinear ? ScaleARGBRowDown2Linear_MSA
+                                            : ScaleARGBRowDown2Box_MSA);
+    }
+  }
+#endif
+#if defined(HAS_SCALEARGBROWDOWN2_LSX)
+  if (TestCpuFlag(kCpuHasLSX)) {
+    ScaleARGBRowDown2 =
+        filtering == kFilterNone
+            ? ScaleARGBRowDown2_Any_LSX
+            : (filtering == kFilterLinear ? ScaleARGBRowDown2Linear_Any_LSX
+                                          : ScaleARGBRowDown2Box_Any_LSX);
+    if (IS_ALIGNED(dst_width, 4)) {
+      ScaleARGBRowDown2 =
+          filtering == kFilterNone
+              ? ScaleARGBRowDown2_LSX
+              : (filtering == kFilterLinear ? ScaleARGBRowDown2Linear_LSX
+                                            : ScaleARGBRowDown2Box_LSX);
+    }
+  }
+#endif
+
+  if (filtering == kFilterLinear) {
+    src_stride = 0;
+  }
+  for (j = 0; j < dst_height; ++j) {
+    ScaleARGBRowDown2(src_argb, src_stride, dst_argb, dst_width);
+    src_argb += row_stride;
+    dst_argb += dst_stride;
+  }
+}
+
+// ScaleARGB ARGB, 1/4
+// This is an optimized version for scaling down a ARGB to 1/4 of
+// its original size.
+static void ScaleARGBDown4Box(int src_width,
+                              int src_height,
+                              int dst_width,
+                              int dst_height,
+                              int src_stride,
+                              int dst_stride,
+                              const uint8_t* src_argb,
+                              uint8_t* dst_argb,
+                              int x,
+                              int dx,
+                              int y,
+                              int dy) {
+  int j;
+  // Allocate 2 rows of ARGB.
+  const int kRowSize = (dst_width * 2 * 4 + 31) & ~31;
+  align_buffer_64(row, kRowSize * 2);
+  int row_stride = src_stride * (dy >> 16);
+  void (*ScaleARGBRowDown2)(const uint8_t* src_argb, ptrdiff_t src_stride,
+                            uint8_t* dst_argb, int dst_width) =
+      ScaleARGBRowDown2Box_C;
+  // Advance to odd row, even column.
+  src_argb += (y >> 16) * (int64_t)src_stride + (x >> 16) * 4;
+  (void)src_width;
+  (void)src_height;
+  (void)dx;
+  assert(dx == 65536 * 4);      // Test scale factor of 4.
+  assert((dy & 0x3ffff) == 0);  // Test vertical scale is multiple of 4.
+#if defined(HAS_SCALEARGBROWDOWN2_SSE2)
+  if (TestCpuFlag(kCpuHasSSE2)) {
+    ScaleARGBRowDown2 = ScaleARGBRowDown2Box_Any_SSE2;
+    if (IS_ALIGNED(dst_width, 4)) {
+      ScaleARGBRowDown2 = ScaleARGBRowDown2Box_SSE2;
+    }
+  }
+#endif
+#if defined(HAS_SCALEARGBROWDOWN2_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    ScaleARGBRowDown2 = ScaleARGBRowDown2Box_Any_NEON;
+    if (IS_ALIGNED(dst_width, 8)) {
+      ScaleARGBRowDown2 = ScaleARGBRowDown2Box_NEON;
+    }
+  }
+#endif
+
+  for (j = 0; j < dst_height; ++j) {
+    ScaleARGBRowDown2(src_argb, src_stride, row, dst_width * 2);
+    ScaleARGBRowDown2(src_argb + src_stride * 2, src_stride, row + kRowSize,
+                      dst_width * 2);
+    ScaleARGBRowDown2(row, kRowSize, dst_argb, dst_width);
+    src_argb += row_stride;
+    dst_argb += dst_stride;
+  }
+  free_aligned_buffer_64(row);
+}
+
+// ScaleARGB ARGB Even
+// This is an optimized version for scaling down a ARGB to even
+// multiple of its original size.
+static void ScaleARGBDownEven(int src_width,
+                              int src_height,
+                              int dst_width,
+                              int dst_height,
+                              int src_stride,
+                              int dst_stride,
+                              const uint8_t* src_argb,
+                              uint8_t* dst_argb,
+                              int x,
+                              int dx,
+                              int y,
+                              int dy,
+                              enum FilterMode filtering) {
+  int j;
+  int col_step = dx >> 16;
+  int row_stride = (dy >> 16) * (int64_t)src_stride;
+  void (*ScaleARGBRowDownEven)(const uint8_t* src_argb, ptrdiff_t src_stride,
+                               int src_step, uint8_t* dst_argb, int dst_width) =
+      filtering ? ScaleARGBRowDownEvenBox_C : ScaleARGBRowDownEven_C;
+  (void)src_width;
+  (void)src_height;
+  assert(IS_ALIGNED(src_width, 2));
+  assert(IS_ALIGNED(src_height, 2));
+  src_argb += (y >> 16) * (int64_t)src_stride + (x >> 16) * 4;
+#if defined(HAS_SCALEARGBROWDOWNEVEN_SSE2)
+  if (TestCpuFlag(kCpuHasSSE2)) {
+    ScaleARGBRowDownEven = filtering ? ScaleARGBRowDownEvenBox_Any_SSE2
+                                     : ScaleARGBRowDownEven_Any_SSE2;
+    if (IS_ALIGNED(dst_width, 4)) {
+      ScaleARGBRowDownEven =
+          filtering ? ScaleARGBRowDownEvenBox_SSE2 : ScaleARGBRowDownEven_SSE2;
+    }
+  }
+#endif
+#if defined(HAS_SCALEARGBROWDOWNEVEN_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    ScaleARGBRowDownEven = filtering ? ScaleARGBRowDownEvenBox_Any_NEON
+                                     : ScaleARGBRowDownEven_Any_NEON;
+    if (IS_ALIGNED(dst_width, 4)) {
+      ScaleARGBRowDownEven =
+          filtering ? ScaleARGBRowDownEvenBox_NEON : ScaleARGBRowDownEven_NEON;
+    }
+  }
+#endif
+#if defined(HAS_SCALEARGBROWDOWNEVEN_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    ScaleARGBRowDownEven = filtering ? ScaleARGBRowDownEvenBox_Any_MSA
+                                     : ScaleARGBRowDownEven_Any_MSA;
+    if (IS_ALIGNED(dst_width, 4)) {
+      ScaleARGBRowDownEven =
+          filtering ? ScaleARGBRowDownEvenBox_MSA : ScaleARGBRowDownEven_MSA;
+    }
+  }
+#endif
+#if defined(HAS_SCALEARGBROWDOWNEVEN_LSX)
+  if (TestCpuFlag(kCpuHasLSX)) {
+    ScaleARGBRowDownEven = filtering ? ScaleARGBRowDownEvenBox_Any_LSX
+                                     : ScaleARGBRowDownEven_Any_LSX;
+    if (IS_ALIGNED(dst_width, 4)) {
+      ScaleARGBRowDownEven =
+          filtering ? ScaleARGBRowDownEvenBox_LSX : ScaleARGBRowDownEven_LSX;
+    }
+  }
+#endif
+
+  if (filtering == kFilterLinear) {
+    src_stride = 0;
+  }
+  for (j = 0; j < dst_height; ++j) {
+    ScaleARGBRowDownEven(src_argb, src_stride, col_step, dst_argb, dst_width);
+    src_argb += row_stride;
+    dst_argb += dst_stride;
+  }
+}
+
+// Scale ARGB down with bilinear interpolation.
+static void ScaleARGBBilinearDown(int src_width,
+                                  int src_height,
+                                  int dst_width,
+                                  int dst_height,
+                                  int src_stride,
+                                  int dst_stride,
+                                  const uint8_t* src_argb,
+                                  uint8_t* dst_argb,
+                                  int x,
+                                  int dx,
+                                  int y,
+                                  int dy,
+                                  enum FilterMode filtering) {
+  int j;
+  void (*InterpolateRow)(uint8_t * dst_argb, const uint8_t* src_argb,
+                         ptrdiff_t src_stride, int dst_width,
+                         int source_y_fraction) = InterpolateRow_C;
+  void (*ScaleARGBFilterCols)(uint8_t * dst_argb, const uint8_t* src_argb,
+                              int dst_width, int x, int dx) =
+      (src_width >= 32768) ? ScaleARGBFilterCols64_C : ScaleARGBFilterCols_C;
+  int64_t xlast = x + (int64_t)(dst_width - 1) * dx;
+  int64_t xl = (dx >= 0) ? x : xlast;
+  int64_t xr = (dx >= 0) ? xlast : x;
+  int clip_src_width;
+  xl = (xl >> 16) & ~3;    // Left edge aligned.
+  xr = (xr >> 16) + 1;     // Right most pixel used.  Bilinear uses 2 pixels.
+  xr = (xr + 1 + 3) & ~3;  // 1 beyond 4 pixel aligned right most pixel.
+  if (xr > src_width) {
+    xr = src_width;
+  }
+  clip_src_width = (int)(xr - xl) * 4;  // Width aligned to 4.
+  src_argb += xl * 4;
+  x -= (int)(xl << 16);
+#if defined(HAS_INTERPOLATEROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    InterpolateRow = InterpolateRow_Any_SSSE3;
+    if (IS_ALIGNED(clip_src_width, 16)) {
+      InterpolateRow = InterpolateRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_INTERPOLATEROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    InterpolateRow = InterpolateRow_Any_AVX2;
+    if (IS_ALIGNED(clip_src_width, 32)) {
+      InterpolateRow = InterpolateRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_INTERPOLATEROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    InterpolateRow = InterpolateRow_Any_NEON;
+    if (IS_ALIGNED(clip_src_width, 16)) {
+      InterpolateRow = InterpolateRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_INTERPOLATEROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    InterpolateRow = InterpolateRow_Any_MSA;
+    if (IS_ALIGNED(clip_src_width, 32)) {
+      InterpolateRow = InterpolateRow_MSA;
+    }
+  }
+#endif
+#if defined(HAS_INTERPOLATEROW_LSX)
+  if (TestCpuFlag(kCpuHasLSX)) {
+    InterpolateRow = InterpolateRow_Any_LSX;
+    if (IS_ALIGNED(clip_src_width, 32)) {
+      InterpolateRow = InterpolateRow_LSX;
+    }
+  }
+#endif
+#if defined(HAS_SCALEARGBFILTERCOLS_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3) && src_width < 32768) {
+    ScaleARGBFilterCols = ScaleARGBFilterCols_SSSE3;
+  }
+#endif
+#if defined(HAS_SCALEARGBFILTERCOLS_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    ScaleARGBFilterCols = ScaleARGBFilterCols_Any_NEON;
+    if (IS_ALIGNED(dst_width, 4)) {
+      ScaleARGBFilterCols = ScaleARGBFilterCols_NEON;
+    }
+  }
+#endif
+#if defined(HAS_SCALEARGBFILTERCOLS_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    ScaleARGBFilterCols = ScaleARGBFilterCols_Any_MSA;
+    if (IS_ALIGNED(dst_width, 8)) {
+      ScaleARGBFilterCols = ScaleARGBFilterCols_MSA;
+    }
+  }
+#endif
+#if defined(HAS_SCALEARGBFILTERCOLS_LSX)
+  if (TestCpuFlag(kCpuHasLSX)) {
+    ScaleARGBFilterCols = ScaleARGBFilterCols_Any_LSX;
+    if (IS_ALIGNED(dst_width, 8)) {
+      ScaleARGBFilterCols = ScaleARGBFilterCols_LSX;
+    }
+  }
+#endif
+  // TODO(fbarchard): Consider not allocating row buffer for kFilterLinear.
+  // Allocate a row of ARGB.
+  {
+    align_buffer_64(row, clip_src_width * 4);
+
+    const int max_y = (src_height - 1) << 16;
+    if (y > max_y) {
+      y = max_y;
+    }
+    for (j = 0; j < dst_height; ++j) {
+      int yi = y >> 16;
+      const uint8_t* src = src_argb + yi * (int64_t)src_stride;
+      if (filtering == kFilterLinear) {
+        ScaleARGBFilterCols(dst_argb, src, dst_width, x, dx);
+      } else {
+        int yf = (y >> 8) & 255;
+        InterpolateRow(row, src, src_stride, clip_src_width, yf);
+        ScaleARGBFilterCols(dst_argb, row, dst_width, x, dx);
+      }
+      dst_argb += dst_stride;
+      y += dy;
+      if (y > max_y) {
+        y = max_y;
+      }
+    }
+    free_aligned_buffer_64(row);
+  }
+}
+
+// Scale ARGB up with bilinear interpolation.
+static void ScaleARGBBilinearUp(int src_width,
+                                int src_height,
+                                int dst_width,
+                                int dst_height,
+                                int src_stride,
+                                int dst_stride,
+                                const uint8_t* src_argb,
+                                uint8_t* dst_argb,
+                                int x,
+                                int dx,
+                                int y,
+                                int dy,
+                                enum FilterMode filtering) {
+  int j;
+  void (*InterpolateRow)(uint8_t * dst_argb, const uint8_t* src_argb,
+                         ptrdiff_t src_stride, int dst_width,
+                         int source_y_fraction) = InterpolateRow_C;
+  void (*ScaleARGBFilterCols)(uint8_t * dst_argb, const uint8_t* src_argb,
+                              int dst_width, int x, int dx) =
+      filtering ? ScaleARGBFilterCols_C : ScaleARGBCols_C;
+  const int max_y = (src_height - 1) << 16;
+#if defined(HAS_INTERPOLATEROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    InterpolateRow = InterpolateRow_Any_SSSE3;
+    if (IS_ALIGNED(dst_width, 4)) {
+      InterpolateRow = InterpolateRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_INTERPOLATEROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    InterpolateRow = InterpolateRow_Any_AVX2;
+    if (IS_ALIGNED(dst_width, 8)) {
+      InterpolateRow = InterpolateRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_INTERPOLATEROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    InterpolateRow = InterpolateRow_Any_NEON;
+    if (IS_ALIGNED(dst_width, 4)) {
+      InterpolateRow = InterpolateRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_INTERPOLATEROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    InterpolateRow = InterpolateRow_Any_MSA;
+    if (IS_ALIGNED(dst_width, 8)) {
+      InterpolateRow = InterpolateRow_MSA;
+    }
+  }
+#endif
+#if defined(HAS_INTERPOLATEROW_LSX)
+  if (TestCpuFlag(kCpuHasLSX)) {
+    InterpolateRow = InterpolateRow_Any_LSX;
+    if (IS_ALIGNED(dst_width, 8)) {
+      InterpolateRow = InterpolateRow_LSX;
+    }
+  }
+#endif
+  if (src_width >= 32768) {
+    ScaleARGBFilterCols =
+        filtering ? ScaleARGBFilterCols64_C : ScaleARGBCols64_C;
+  }
+#if defined(HAS_SCALEARGBFILTERCOLS_SSSE3)
+  if (filtering && TestCpuFlag(kCpuHasSSSE3) && src_width < 32768) {
+    ScaleARGBFilterCols = ScaleARGBFilterCols_SSSE3;
+  }
+#endif
+#if defined(HAS_SCALEARGBFILTERCOLS_NEON)
+  if (filtering && TestCpuFlag(kCpuHasNEON)) {
+    ScaleARGBFilterCols = ScaleARGBFilterCols_Any_NEON;
+    if (IS_ALIGNED(dst_width, 4)) {
+      ScaleARGBFilterCols = ScaleARGBFilterCols_NEON;
+    }
+  }
+#endif
+#if defined(HAS_SCALEARGBFILTERCOLS_MSA)
+  if (filtering && TestCpuFlag(kCpuHasMSA)) {
+    ScaleARGBFilterCols = ScaleARGBFilterCols_Any_MSA;
+    if (IS_ALIGNED(dst_width, 8)) {
+      ScaleARGBFilterCols = ScaleARGBFilterCols_MSA;
+    }
+  }
+#endif
+#if defined(HAS_SCALEARGBFILTERCOLS_LSX)
+  if (filtering && TestCpuFlag(kCpuHasLSX)) {
+    ScaleARGBFilterCols = ScaleARGBFilterCols_Any_LSX;
+    if (IS_ALIGNED(dst_width, 8)) {
+      ScaleARGBFilterCols = ScaleARGBFilterCols_LSX;
+    }
+  }
+#endif
+#if defined(HAS_SCALEARGBCOLS_SSE2)
+  if (!filtering && TestCpuFlag(kCpuHasSSE2) && src_width < 32768) {
+    ScaleARGBFilterCols = ScaleARGBCols_SSE2;
+  }
+#endif
+#if defined(HAS_SCALEARGBCOLS_NEON)
+  if (!filtering && TestCpuFlag(kCpuHasNEON)) {
+    ScaleARGBFilterCols = ScaleARGBCols_Any_NEON;
+    if (IS_ALIGNED(dst_width, 8)) {
+      ScaleARGBFilterCols = ScaleARGBCols_NEON;
+    }
+  }
+#endif
+#if defined(HAS_SCALEARGBCOLS_MSA)
+  if (!filtering && TestCpuFlag(kCpuHasMSA)) {
+    ScaleARGBFilterCols = ScaleARGBCols_Any_MSA;
+    if (IS_ALIGNED(dst_width, 4)) {
+      ScaleARGBFilterCols = ScaleARGBCols_MSA;
+    }
+  }
+#endif
+#if defined(HAS_SCALEARGBCOLS_LSX)
+  if (!filtering && TestCpuFlag(kCpuHasLSX)) {
+    ScaleARGBFilterCols = ScaleARGBCols_Any_LSX;
+    if (IS_ALIGNED(dst_width, 4)) {
+      ScaleARGBFilterCols = ScaleARGBCols_LSX;
+    }
+  }
+#endif
+  if (!filtering && src_width * 2 == dst_width && x < 0x8000) {
+    ScaleARGBFilterCols = ScaleARGBColsUp2_C;
+#if defined(HAS_SCALEARGBCOLSUP2_SSE2)
+    if (TestCpuFlag(kCpuHasSSE2) && IS_ALIGNED(dst_width, 8)) {
+      ScaleARGBFilterCols = ScaleARGBColsUp2_SSE2;
+    }
+#endif
+  }
+
+  if (y > max_y) {
+    y = max_y;
+  }
+
+  {
+    int yi = y >> 16;
+    const uint8_t* src = src_argb + yi * (int64_t)src_stride;
+
+    // Allocate 2 rows of ARGB.
+    const int kRowSize = (dst_width * 4 + 31) & ~31;
+    align_buffer_64(row, kRowSize * 2);
+
+    uint8_t* rowptr = row;
+    int rowstride = kRowSize;
+    int lasty = yi;
+
+    ScaleARGBFilterCols(rowptr, src, dst_width, x, dx);
+    if (src_height > 1) {
+      src += src_stride;
+    }
+    ScaleARGBFilterCols(rowptr + rowstride, src, dst_width, x, dx);
+    if (src_height > 2) {
+      src += src_stride;
+    }
+
+    for (j = 0; j < dst_height; ++j) {
+      yi = y >> 16;
+      if (yi != lasty) {
+        if (y > max_y) {
+          y = max_y;
+          yi = y >> 16;
+          src = src_argb + yi * (int64_t)src_stride;
+        }
+        if (yi != lasty) {
+          ScaleARGBFilterCols(rowptr, src, dst_width, x, dx);
+          rowptr += rowstride;
+          rowstride = -rowstride;
+          lasty = yi;
+          if ((y + 65536) < max_y) {
+            src += src_stride;
+          }
+        }
+      }
+      if (filtering == kFilterLinear) {
+        InterpolateRow(dst_argb, rowptr, 0, dst_width * 4, 0);
+      } else {
+        int yf = (y >> 8) & 255;
+        InterpolateRow(dst_argb, rowptr, rowstride, dst_width * 4, yf);
+      }
+      dst_argb += dst_stride;
+      y += dy;
+    }
+    free_aligned_buffer_64(row);
+  }
+}
+
+#ifdef YUVSCALEUP
+// Scale YUV to ARGB up with bilinear interpolation.
+static void ScaleYUVToARGBBilinearUp(int src_width,
+                                     int src_height,
+                                     int dst_width,
+                                     int dst_height,
+                                     int src_stride_y,
+                                     int src_stride_u,
+                                     int src_stride_v,
+                                     int dst_stride_argb,
+                                     const uint8_t* src_y,
+                                     const uint8_t* src_u,
+                                     const uint8_t* src_v,
+                                     uint8_t* dst_argb,
+                                     int x,
+                                     int dx,
+                                     int y,
+                                     int dy,
+                                     enum FilterMode filtering) {
+  int j;
+  void (*I422ToARGBRow)(const uint8_t* y_buf, const uint8_t* u_buf,
+                        const uint8_t* v_buf, uint8_t* rgb_buf, int width) =
+      I422ToARGBRow_C;
+#if defined(HAS_I422TOARGBROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    I422ToARGBRow = I422ToARGBRow_Any_SSSE3;
+    if (IS_ALIGNED(src_width, 8)) {
+      I422ToARGBRow = I422ToARGBRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_I422TOARGBROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    I422ToARGBRow = I422ToARGBRow_Any_AVX2;
+    if (IS_ALIGNED(src_width, 16)) {
+      I422ToARGBRow = I422ToARGBRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_I422TOARGBROW_AVX512BW)
+  if (TestCpuFlag(kCpuHasAVX512BW | kCpuHasAVX512VL) ==
+      (kCpuHasAVX512BW | kCpuHasAVX512VL)) {
+    I422ToARGBRow = I422ToARGBRow_Any_AVX512BW;
+    if (IS_ALIGNED(src_width, 32)) {
+      I422ToARGBRow = I422ToARGBRow_AVX512BW;
+    }
+  }
+#endif
+#if defined(HAS_I422TOARGBROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    I422ToARGBRow = I422ToARGBRow_Any_NEON;
+    if (IS_ALIGNED(src_width, 8)) {
+      I422ToARGBRow = I422ToARGBRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_I422TOARGBROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    I422ToARGBRow = I422ToARGBRow_Any_MSA;
+    if (IS_ALIGNED(src_width, 8)) {
+      I422ToARGBRow = I422ToARGBRow_MSA;
+    }
+  }
+#endif
+#if defined(HAS_I422TOARGBROW_LASX)
+  if (TestCpuFlag(kCpuHasLASX)) {
+    I422ToARGBRow = I422ToARGBRow_Any_LASX;
+    if (IS_ALIGNED(src_width, 32)) {
+      I422ToARGBRow = I422ToARGBRow_LASX;
+    }
+  }
+#endif
+
+  void (*InterpolateRow)(uint8_t * dst_argb, const uint8_t* src_argb,
+                         ptrdiff_t src_stride, int dst_width,
+                         int source_y_fraction) = InterpolateRow_C;
+#if defined(HAS_INTERPOLATEROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    InterpolateRow = InterpolateRow_Any_SSSE3;
+    if (IS_ALIGNED(dst_width, 4)) {
+      InterpolateRow = InterpolateRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_INTERPOLATEROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    InterpolateRow = InterpolateRow_Any_AVX2;
+    if (IS_ALIGNED(dst_width, 8)) {
+      InterpolateRow = InterpolateRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_INTERPOLATEROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    InterpolateRow = InterpolateRow_Any_NEON;
+    if (IS_ALIGNED(dst_width, 4)) {
+      InterpolateRow = InterpolateRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_INTERPOLATEROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    InterpolateRow = InterpolateRow_Any_MSA;
+    if (IS_ALIGNED(dst_width, 8)) {
+      InterpolateRow = InterpolateRow_MSA;
+    }
+  }
+#endif
+#if defined(HAS_INTERPOLATEROW_LSX)
+  if (TestCpuFlag(kCpuHasLSX)) {
+    InterpolateRow = InterpolateRow_Any_LSX;
+    if (IS_ALIGNED(dst_width, 8)) {
+      InterpolateRow = InterpolateRow_LSX;
+    }
+  }
+#endif
+
+  void (*ScaleARGBFilterCols)(uint8_t * dst_argb, const uint8_t* src_argb,
+                              int dst_width, int x, int dx) =
+      filtering ? ScaleARGBFilterCols_C : ScaleARGBCols_C;
+  if (src_width >= 32768) {
+    ScaleARGBFilterCols =
+        filtering ? ScaleARGBFilterCols64_C : ScaleARGBCols64_C;
+  }
+#if defined(HAS_SCALEARGBFILTERCOLS_SSSE3)
+  if (filtering && TestCpuFlag(kCpuHasSSSE3) && src_width < 32768) {
+    ScaleARGBFilterCols = ScaleARGBFilterCols_SSSE3;
+  }
+#endif
+#if defined(HAS_SCALEARGBFILTERCOLS_NEON)
+  if (filtering && TestCpuFlag(kCpuHasNEON)) {
+    ScaleARGBFilterCols = ScaleARGBFilterCols_Any_NEON;
+    if (IS_ALIGNED(dst_width, 4)) {
+      ScaleARGBFilterCols = ScaleARGBFilterCols_NEON;
+    }
+  }
+#endif
+#if defined(HAS_SCALEARGBFILTERCOLS_MSA)
+  if (filtering && TestCpuFlag(kCpuHasMSA)) {
+    ScaleARGBFilterCols = ScaleARGBFilterCols_Any_MSA;
+    if (IS_ALIGNED(dst_width, 8)) {
+      ScaleARGBFilterCols = ScaleARGBFilterCols_MSA;
+    }
+  }
+#endif
+#if defined(HAS_SCALEARGBFILTERCOLS_LSX)
+  if (filtering && TestCpuFlag(kCpuHasLSX)) {
+    ScaleARGBFilterCols = ScaleARGBFilterCols_Any_LSX;
+    if (IS_ALIGNED(dst_width, 8)) {
+      ScaleARGBFilterCols = ScaleARGBFilterCols_LSX;
+    }
+  }
+#endif
+#if defined(HAS_SCALEARGBCOLS_SSE2)
+  if (!filtering && TestCpuFlag(kCpuHasSSE2) && src_width < 32768) {
+    ScaleARGBFilterCols = ScaleARGBCols_SSE2;
+  }
+#endif
+#if defined(HAS_SCALEARGBCOLS_NEON)
+  if (!filtering && TestCpuFlag(kCpuHasNEON)) {
+    ScaleARGBFilterCols = ScaleARGBCols_Any_NEON;
+    if (IS_ALIGNED(dst_width, 8)) {
+      ScaleARGBFilterCols = ScaleARGBCols_NEON;
+    }
+  }
+#endif
+#if defined(HAS_SCALEARGBCOLS_MSA)
+  if (!filtering && TestCpuFlag(kCpuHasMSA)) {
+    ScaleARGBFilterCols = ScaleARGBCols_Any_MSA;
+    if (IS_ALIGNED(dst_width, 4)) {
+      ScaleARGBFilterCols = ScaleARGBCols_MSA;
+    }
+  }
+#endif
+#if defined(HAS_SCALEARGBCOLS_LSX)
+  if (!filtering && TestCpuFlag(kCpuHasLSX)) {
+    ScaleARGBFilterCols = ScaleARGBCols_Any_LSX;
+    if (IS_ALIGNED(dst_width, 4)) {
+      ScaleARGBFilterCols = ScaleARGBCols_LSX;
+    }
+  }
+#endif
+  if (!filtering && src_width * 2 == dst_width && x < 0x8000) {
+    ScaleARGBFilterCols = ScaleARGBColsUp2_C;
+#if defined(HAS_SCALEARGBCOLSUP2_SSE2)
+    if (TestCpuFlag(kCpuHasSSE2) && IS_ALIGNED(dst_width, 8)) {
+      ScaleARGBFilterCols = ScaleARGBColsUp2_SSE2;
+    }
+#endif
+  }
+
+  const int max_y = (src_height - 1) << 16;
+  if (y > max_y) {
+    y = max_y;
+  }
+  const int kYShift = 1;  // Shift Y by 1 to convert Y plane to UV coordinate.
+  int yi = y >> 16;
+  int uv_yi = yi >> kYShift;
+  const uint8_t* src_row_y = src_y + yi * (int64_t)src_stride_y;
+  const uint8_t* src_row_u = src_u + uv_yi * (int64_t)src_stride_u;
+  const uint8_t* src_row_v = src_v + uv_yi * (int64_t)src_stride_v;
+
+  // Allocate 2 rows of ARGB.
+  const int kRowSize = (dst_width * 4 + 31) & ~31;
+  align_buffer_64(row, kRowSize * 2);
+
+  // Allocate 1 row of ARGB for source conversion.
+  align_buffer_64(argb_row, src_width * 4);
+
+  uint8_t* rowptr = row;
+  int rowstride = kRowSize;
+  int lasty = yi;
+
+  // TODO(fbarchard): Convert first 2 rows of YUV to ARGB.
+  ScaleARGBFilterCols(rowptr, src_row_y, dst_width, x, dx);
+  if (src_height > 1) {
+    src_row_y += src_stride_y;
+    if (yi & 1) {
+      src_row_u += src_stride_u;
+      src_row_v += src_stride_v;
+    }
+  }
+  ScaleARGBFilterCols(rowptr + rowstride, src_row_y, dst_width, x, dx);
+  if (src_height > 2) {
+    src_row_y += src_stride_y;
+    if (!(yi & 1)) {
+      src_row_u += src_stride_u;
+      src_row_v += src_stride_v;
+    }
+  }
+
+  for (j = 0; j < dst_height; ++j) {
+    yi = y >> 16;
+    if (yi != lasty) {
+      if (y > max_y) {
+        y = max_y;
+        yi = y >> 16;
+        uv_yi = yi >> kYShift;
+        src_row_y = src_y + yi * (int64_t)src_stride_y;
+        src_row_u = src_u + uv_yi * (int64_t)src_stride_u;
+        src_row_v = src_v + uv_yi * (int64_t)src_stride_v;
+      }
+      if (yi != lasty) {
+        // TODO(fbarchard): Convert the clipped region of row.
+        I422ToARGBRow(src_row_y, src_row_u, src_row_v, argb_row, src_width);
+        ScaleARGBFilterCols(rowptr, argb_row, dst_width, x, dx);
+        rowptr += rowstride;
+        rowstride = -rowstride;
+        lasty = yi;
+        src_row_y += src_stride_y;
+        if (yi & 1) {
+          src_row_u += src_stride_u;
+          src_row_v += src_stride_v;
+        }
+      }
+    }
+    if (filtering == kFilterLinear) {
+      InterpolateRow(dst_argb, rowptr, 0, dst_width * 4, 0);
+    } else {
+      int yf = (y >> 8) & 255;
+      InterpolateRow(dst_argb, rowptr, rowstride, dst_width * 4, yf);
+    }
+    dst_argb += dst_stride_argb;
+    y += dy;
+  }
+  free_aligned_buffer_64(row);
+  free_aligned_buffer_64(row_argb);
+}
+#endif
+
+// Scale ARGB to/from any dimensions, without interpolation.
+// Fixed point math is used for performance: The upper 16 bits
+// of x and dx is the integer part of the source position and
+// the lower 16 bits are the fixed decimal part.
+
+static void ScaleARGBSimple(int src_width,
+                            int src_height,
+                            int dst_width,
+                            int dst_height,
+                            int src_stride,
+                            int dst_stride,
+                            const uint8_t* src_argb,
+                            uint8_t* dst_argb,
+                            int x,
+                            int dx,
+                            int y,
+                            int dy) {
+  int j;
+  void (*ScaleARGBCols)(uint8_t * dst_argb, const uint8_t* src_argb,
+                        int dst_width, int x, int dx) =
+      (src_width >= 32768) ? ScaleARGBCols64_C : ScaleARGBCols_C;
+  (void)src_height;
+#if defined(HAS_SCALEARGBCOLS_SSE2)
+  if (TestCpuFlag(kCpuHasSSE2) && src_width < 32768) {
+    ScaleARGBCols = ScaleARGBCols_SSE2;
+  }
+#endif
+#if defined(HAS_SCALEARGBCOLS_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    ScaleARGBCols = ScaleARGBCols_Any_NEON;
+    if (IS_ALIGNED(dst_width, 8)) {
+      ScaleARGBCols = ScaleARGBCols_NEON;
+    }
+  }
+#endif
+#if defined(HAS_SCALEARGBCOLS_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    ScaleARGBCols = ScaleARGBCols_Any_MSA;
+    if (IS_ALIGNED(dst_width, 4)) {
+      ScaleARGBCols = ScaleARGBCols_MSA;
+    }
+  }
+#endif
+#if defined(HAS_SCALEARGBCOLS_LSX)
+  if (TestCpuFlag(kCpuHasLSX)) {
+    ScaleARGBCols = ScaleARGBCols_Any_LSX;
+    if (IS_ALIGNED(dst_width, 4)) {
+      ScaleARGBCols = ScaleARGBCols_LSX;
+    }
+  }
+#endif
+  if (src_width * 2 == dst_width && x < 0x8000) {
+    ScaleARGBCols = ScaleARGBColsUp2_C;
+#if defined(HAS_SCALEARGBCOLSUP2_SSE2)
+    if (TestCpuFlag(kCpuHasSSE2) && IS_ALIGNED(dst_width, 8)) {
+      ScaleARGBCols = ScaleARGBColsUp2_SSE2;
+    }
+#endif
+  }
+
+  for (j = 0; j < dst_height; ++j) {
+    ScaleARGBCols(dst_argb, src_argb + (y >> 16) * (int64_t)src_stride,
+                  dst_width, x, dx);
+    dst_argb += dst_stride;
+    y += dy;
+  }
+}
+
+// ScaleARGB a ARGB.
+// This function in turn calls a scaling function
+// suitable for handling the desired resolutions.
+static void ScaleARGB(const uint8_t* src,
+                      int src_stride,
+                      int src_width,
+                      int src_height,
+                      uint8_t* dst,
+                      int dst_stride,
+                      int dst_width,
+                      int dst_height,
+                      int clip_x,
+                      int clip_y,
+                      int clip_width,
+                      int clip_height,
+                      enum FilterMode filtering) {
+  // Initial source x/y coordinate and step values as 16.16 fixed point.
+  int x = 0;
+  int y = 0;
+  int dx = 0;
+  int dy = 0;
+  // ARGB does not support box filter yet, but allow the user to pass it.
+  // Simplify filtering when possible.
+  filtering = ScaleFilterReduce(src_width, src_height, dst_width, dst_height,
+                                filtering);
+
+  // Negative src_height means invert the image.
+  if (src_height < 0) {
+    src_height = -src_height;
+    src = src + (src_height - 1) * (int64_t)src_stride;
+    src_stride = -src_stride;
+  }
+  ScaleSlope(src_width, src_height, dst_width, dst_height, filtering, &x, &y,
+             &dx, &dy);
+  src_width = Abs(src_width);
+  if (clip_x) {
+    int64_t clipf = (int64_t)(clip_x)*dx;
+    x += (clipf & 0xffff);
+    src += (clipf >> 16) * 4;
+    dst += clip_x * 4;
+  }
+  if (clip_y) {
+    int64_t clipf = (int64_t)(clip_y)*dy;
+    y += (clipf & 0xffff);
+    src += (clipf >> 16) * (int64_t)src_stride;
+    dst += clip_y * dst_stride;
+  }
+
+  // Special case for integer step values.
+  if (((dx | dy) & 0xffff) == 0) {
+    if (!dx || !dy) {  // 1 pixel wide and/or tall.
+      filtering = kFilterNone;
+    } else {
+      // Optimized even scale down. ie 2, 4, 6, 8, 10x.
+      if (!(dx & 0x10000) && !(dy & 0x10000)) {
+        if (dx == 0x20000) {
+          // Optimized 1/2 downsample.
+          ScaleARGBDown2(src_width, src_height, clip_width, clip_height,
+                         src_stride, dst_stride, src, dst, x, dx, y, dy,
+                         filtering);
+          return;
+        }
+        if (dx == 0x40000 && filtering == kFilterBox) {
+          // Optimized 1/4 box downsample.
+          ScaleARGBDown4Box(src_width, src_height, clip_width, clip_height,
+                            src_stride, dst_stride, src, dst, x, dx, y, dy);
+          return;
+        }
+        ScaleARGBDownEven(src_width, src_height, clip_width, clip_height,
+                          src_stride, dst_stride, src, dst, x, dx, y, dy,
+                          filtering);
+        return;
+      }
+      // Optimized odd scale down. ie 3, 5, 7, 9x.
+      if ((dx & 0x10000) && (dy & 0x10000)) {
+        filtering = kFilterNone;
+        if (dx == 0x10000 && dy == 0x10000) {
+          // Straight copy.
+          ARGBCopy(src + (y >> 16) * (int64_t)src_stride + (x >> 16) * 4,
+                   src_stride, dst, dst_stride, clip_width, clip_height);
+          return;
+        }
+      }
+    }
+  }
+  if (dx == 0x10000 && (x & 0xffff) == 0) {
+    // Arbitrary scale vertically, but unscaled horizontally.
+    ScalePlaneVertical(src_height, clip_width, clip_height, src_stride,
+                       dst_stride, src, dst, x, y, dy, /*bpp=*/4, filtering);
+    return;
+  }
+  if (filtering && dy < 65536) {
+    ScaleARGBBilinearUp(src_width, src_height, clip_width, clip_height,
+                        src_stride, dst_stride, src, dst, x, dx, y, dy,
+                        filtering);
+    return;
+  }
+  if (filtering) {
+    ScaleARGBBilinearDown(src_width, src_height, clip_width, clip_height,
+                          src_stride, dst_stride, src, dst, x, dx, y, dy,
+                          filtering);
+    return;
+  }
+  ScaleARGBSimple(src_width, src_height, clip_width, clip_height, src_stride,
+                  dst_stride, src, dst, x, dx, y, dy);
+}
+
+LIBYUV_API
+int ARGBScaleClip(const uint8_t* src_argb,
+                  int src_stride_argb,
+                  int src_width,
+                  int src_height,
+                  uint8_t* dst_argb,
+                  int dst_stride_argb,
+                  int dst_width,
+                  int dst_height,
+                  int clip_x,
+                  int clip_y,
+                  int clip_width,
+                  int clip_height,
+                  enum FilterMode filtering) {
+  if (!src_argb || src_width == 0 || src_height == 0 || !dst_argb ||
+      dst_width <= 0 || dst_height <= 0 || clip_x < 0 || clip_y < 0 ||
+      clip_width > 32768 || clip_height > 32768 ||
+      (clip_x + clip_width) > dst_width ||
+      (clip_y + clip_height) > dst_height) {
+    return -1;
+  }
+  ScaleARGB(src_argb, src_stride_argb, src_width, src_height, dst_argb,
+            dst_stride_argb, dst_width, dst_height, clip_x, clip_y, clip_width,
+            clip_height, filtering);
+  return 0;
+}
+
+// Scale an ARGB image.
+LIBYUV_API
+int ARGBScale(const uint8_t* src_argb,
+              int src_stride_argb,
+              int src_width,
+              int src_height,
+              uint8_t* dst_argb,
+              int dst_stride_argb,
+              int dst_width,
+              int dst_height,
+              enum FilterMode filtering) {
+  if (!src_argb || src_width == 0 || src_height == 0 || src_width > 32768 ||
+      src_height > 32768 || !dst_argb || dst_width <= 0 || dst_height <= 0) {
+    return -1;
+  }
+  ScaleARGB(src_argb, src_stride_argb, src_width, src_height, dst_argb,
+            dst_stride_argb, dst_width, dst_height, 0, 0, dst_width, dst_height,
+            filtering);
+  return 0;
+}
+
+// Scale with YUV conversion to ARGB and clipping.
+LIBYUV_API
+int YUVToARGBScaleClip(const uint8_t* src_y,
+                       int src_stride_y,
+                       const uint8_t* src_u,
+                       int src_stride_u,
+                       const uint8_t* src_v,
+                       int src_stride_v,
+                       uint32_t src_fourcc,
+                       int src_width,
+                       int src_height,
+                       uint8_t* dst_argb,
+                       int dst_stride_argb,
+                       uint32_t dst_fourcc,
+                       int dst_width,
+                       int dst_height,
+                       int clip_x,
+                       int clip_y,
+                       int clip_width,
+                       int clip_height,
+                       enum FilterMode filtering) {
+  uint8_t* argb_buffer = (uint8_t*)malloc(src_width * src_height * 4);
+  int r;
+  (void)src_fourcc;  // TODO(fbarchard): implement and/or assert.
+  (void)dst_fourcc;
+  I420ToARGB(src_y, src_stride_y, src_u, src_stride_u, src_v, src_stride_v,
+             argb_buffer, src_width * 4, src_width, src_height);
+
+  r = ARGBScaleClip(argb_buffer, src_width * 4, src_width, src_height, dst_argb,
+                    dst_stride_argb, dst_width, dst_height, clip_x, clip_y,
+                    clip_width, clip_height, filtering);
+  free(argb_buffer);
+  return r;
+}
+
+#ifdef __cplusplus
+}  // extern "C"
+}  // namespace libyuv
+#endif
diff --git a/3rdparty/libyuv/src/source/scale_common.cc b/3rdparty/libyuv/src/source/scale_common.cc
new file mode 100644
index 00000000..b02bdafd
--- /dev/null
+++ b/3rdparty/libyuv/src/source/scale_common.cc
@@ -0,0 +1,1834 @@
+/*
+ *  Copyright 2013 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include "libyuv/scale.h"
+
+#include <assert.h>
+#include <string.h>
+
+#include "libyuv/cpu_id.h"
+#include "libyuv/planar_functions.h"  // For CopyARGB
+#include "libyuv/row.h"
+#include "libyuv/scale_row.h"
+
+#ifdef __cplusplus
+namespace libyuv {
+extern "C" {
+#endif
+
+static __inline int Abs(int v) {
+  return v >= 0 ? v : -v;
+}
+
+// CPU agnostic row functions
+void ScaleRowDown2_C(const uint8_t* src_ptr,
+                     ptrdiff_t src_stride,
+                     uint8_t* dst,
+                     int dst_width) {
+  int x;
+  (void)src_stride;
+  for (x = 0; x < dst_width - 1; x += 2) {
+    dst[0] = src_ptr[1];
+    dst[1] = src_ptr[3];
+    dst += 2;
+    src_ptr += 4;
+  }
+  if (dst_width & 1) {
+    dst[0] = src_ptr[1];
+  }
+}
+
+void ScaleRowDown2_16_C(const uint16_t* src_ptr,
+                        ptrdiff_t src_stride,
+                        uint16_t* dst,
+                        int dst_width) {
+  int x;
+  (void)src_stride;
+  for (x = 0; x < dst_width - 1; x += 2) {
+    dst[0] = src_ptr[1];
+    dst[1] = src_ptr[3];
+    dst += 2;
+    src_ptr += 4;
+  }
+  if (dst_width & 1) {
+    dst[0] = src_ptr[1];
+  }
+}
+
+void ScaleRowDown2Linear_C(const uint8_t* src_ptr,
+                           ptrdiff_t src_stride,
+                           uint8_t* dst,
+                           int dst_width) {
+  const uint8_t* s = src_ptr;
+  int x;
+  (void)src_stride;
+  for (x = 0; x < dst_width - 1; x += 2) {
+    dst[0] = (s[0] + s[1] + 1) >> 1;
+    dst[1] = (s[2] + s[3] + 1) >> 1;
+    dst += 2;
+    s += 4;
+  }
+  if (dst_width & 1) {
+    dst[0] = (s[0] + s[1] + 1) >> 1;
+  }
+}
+
+void ScaleRowDown2Linear_16_C(const uint16_t* src_ptr,
+                              ptrdiff_t src_stride,
+                              uint16_t* dst,
+                              int dst_width) {
+  const uint16_t* s = src_ptr;
+  int x;
+  (void)src_stride;
+  for (x = 0; x < dst_width - 1; x += 2) {
+    dst[0] = (s[0] + s[1] + 1) >> 1;
+    dst[1] = (s[2] + s[3] + 1) >> 1;
+    dst += 2;
+    s += 4;
+  }
+  if (dst_width & 1) {
+    dst[0] = (s[0] + s[1] + 1) >> 1;
+  }
+}
+
+void ScaleRowDown2Box_C(const uint8_t* src_ptr,
+                        ptrdiff_t src_stride,
+                        uint8_t* dst,
+                        int dst_width) {
+  const uint8_t* s = src_ptr;
+  const uint8_t* t = src_ptr + src_stride;
+  int x;
+  for (x = 0; x < dst_width - 1; x += 2) {
+    dst[0] = (s[0] + s[1] + t[0] + t[1] + 2) >> 2;
+    dst[1] = (s[2] + s[3] + t[2] + t[3] + 2) >> 2;
+    dst += 2;
+    s += 4;
+    t += 4;
+  }
+  if (dst_width & 1) {
+    dst[0] = (s[0] + s[1] + t[0] + t[1] + 2) >> 2;
+  }
+}
+
+void ScaleRowDown2Box_Odd_C(const uint8_t* src_ptr,
+                            ptrdiff_t src_stride,
+                            uint8_t* dst,
+                            int dst_width) {
+  const uint8_t* s = src_ptr;
+  const uint8_t* t = src_ptr + src_stride;
+  int x;
+  dst_width -= 1;
+  for (x = 0; x < dst_width - 1; x += 2) {
+    dst[0] = (s[0] + s[1] + t[0] + t[1] + 2) >> 2;
+    dst[1] = (s[2] + s[3] + t[2] + t[3] + 2) >> 2;
+    dst += 2;
+    s += 4;
+    t += 4;
+  }
+  if (dst_width & 1) {
+    dst[0] = (s[0] + s[1] + t[0] + t[1] + 2) >> 2;
+    dst += 1;
+    s += 2;
+    t += 2;
+  }
+  dst[0] = (s[0] + t[0] + 1) >> 1;
+}
+
+void ScaleRowDown2Box_16_C(const uint16_t* src_ptr,
+                           ptrdiff_t src_stride,
+                           uint16_t* dst,
+                           int dst_width) {
+  const uint16_t* s = src_ptr;
+  const uint16_t* t = src_ptr + src_stride;
+  int x;
+  for (x = 0; x < dst_width - 1; x += 2) {
+    dst[0] = (s[0] + s[1] + t[0] + t[1] + 2) >> 2;
+    dst[1] = (s[2] + s[3] + t[2] + t[3] + 2) >> 2;
+    dst += 2;
+    s += 4;
+    t += 4;
+  }
+  if (dst_width & 1) {
+    dst[0] = (s[0] + s[1] + t[0] + t[1] + 2) >> 2;
+  }
+}
+
+void ScaleRowDown4_C(const uint8_t* src_ptr,
+                     ptrdiff_t src_stride,
+                     uint8_t* dst,
+                     int dst_width) {
+  int x;
+  (void)src_stride;
+  for (x = 0; x < dst_width - 1; x += 2) {
+    dst[0] = src_ptr[2];
+    dst[1] = src_ptr[6];
+    dst += 2;
+    src_ptr += 8;
+  }
+  if (dst_width & 1) {
+    dst[0] = src_ptr[2];
+  }
+}
+
+void ScaleRowDown4_16_C(const uint16_t* src_ptr,
+                        ptrdiff_t src_stride,
+                        uint16_t* dst,
+                        int dst_width) {
+  int x;
+  (void)src_stride;
+  for (x = 0; x < dst_width - 1; x += 2) {
+    dst[0] = src_ptr[2];
+    dst[1] = src_ptr[6];
+    dst += 2;
+    src_ptr += 8;
+  }
+  if (dst_width & 1) {
+    dst[0] = src_ptr[2];
+  }
+}
+
+void ScaleRowDown4Box_C(const uint8_t* src_ptr,
+                        ptrdiff_t src_stride,
+                        uint8_t* dst,
+                        int dst_width) {
+  intptr_t stride = src_stride;
+  int x;
+  for (x = 0; x < dst_width - 1; x += 2) {
+    dst[0] = (src_ptr[0] + src_ptr[1] + src_ptr[2] + src_ptr[3] +
+              src_ptr[stride + 0] + src_ptr[stride + 1] + src_ptr[stride + 2] +
+              src_ptr[stride + 3] + src_ptr[stride * 2 + 0] +
+              src_ptr[stride * 2 + 1] + src_ptr[stride * 2 + 2] +
+              src_ptr[stride * 2 + 3] + src_ptr[stride * 3 + 0] +
+              src_ptr[stride * 3 + 1] + src_ptr[stride * 3 + 2] +
+              src_ptr[stride * 3 + 3] + 8) >>
+             4;
+    dst[1] = (src_ptr[4] + src_ptr[5] + src_ptr[6] + src_ptr[7] +
+              src_ptr[stride + 4] + src_ptr[stride + 5] + src_ptr[stride + 6] +
+              src_ptr[stride + 7] + src_ptr[stride * 2 + 4] +
+              src_ptr[stride * 2 + 5] + src_ptr[stride * 2 + 6] +
+              src_ptr[stride * 2 + 7] + src_ptr[stride * 3 + 4] +
+              src_ptr[stride * 3 + 5] + src_ptr[stride * 3 + 6] +
+              src_ptr[stride * 3 + 7] + 8) >>
+             4;
+    dst += 2;
+    src_ptr += 8;
+  }
+  if (dst_width & 1) {
+    dst[0] = (src_ptr[0] + src_ptr[1] + src_ptr[2] + src_ptr[3] +
+              src_ptr[stride + 0] + src_ptr[stride + 1] + src_ptr[stride + 2] +
+              src_ptr[stride + 3] + src_ptr[stride * 2 + 0] +
+              src_ptr[stride * 2 + 1] + src_ptr[stride * 2 + 2] +
+              src_ptr[stride * 2 + 3] + src_ptr[stride * 3 + 0] +
+              src_ptr[stride * 3 + 1] + src_ptr[stride * 3 + 2] +
+              src_ptr[stride * 3 + 3] + 8) >>
+             4;
+  }
+}
+
+void ScaleRowDown4Box_16_C(const uint16_t* src_ptr,
+                           ptrdiff_t src_stride,
+                           uint16_t* dst,
+                           int dst_width) {
+  intptr_t stride = src_stride;
+  int x;
+  for (x = 0; x < dst_width - 1; x += 2) {
+    dst[0] = (src_ptr[0] + src_ptr[1] + src_ptr[2] + src_ptr[3] +
+              src_ptr[stride + 0] + src_ptr[stride + 1] + src_ptr[stride + 2] +
+              src_ptr[stride + 3] + src_ptr[stride * 2 + 0] +
+              src_ptr[stride * 2 + 1] + src_ptr[stride * 2 + 2] +
+              src_ptr[stride * 2 + 3] + src_ptr[stride * 3 + 0] +
+              src_ptr[stride * 3 + 1] + src_ptr[stride * 3 + 2] +
+              src_ptr[stride * 3 + 3] + 8) >>
+             4;
+    dst[1] = (src_ptr[4] + src_ptr[5] + src_ptr[6] + src_ptr[7] +
+              src_ptr[stride + 4] + src_ptr[stride + 5] + src_ptr[stride + 6] +
+              src_ptr[stride + 7] + src_ptr[stride * 2 + 4] +
+              src_ptr[stride * 2 + 5] + src_ptr[stride * 2 + 6] +
+              src_ptr[stride * 2 + 7] + src_ptr[stride * 3 + 4] +
+              src_ptr[stride * 3 + 5] + src_ptr[stride * 3 + 6] +
+              src_ptr[stride * 3 + 7] + 8) >>
+             4;
+    dst += 2;
+    src_ptr += 8;
+  }
+  if (dst_width & 1) {
+    dst[0] = (src_ptr[0] + src_ptr[1] + src_ptr[2] + src_ptr[3] +
+              src_ptr[stride + 0] + src_ptr[stride + 1] + src_ptr[stride + 2] +
+              src_ptr[stride + 3] + src_ptr[stride * 2 + 0] +
+              src_ptr[stride * 2 + 1] + src_ptr[stride * 2 + 2] +
+              src_ptr[stride * 2 + 3] + src_ptr[stride * 3 + 0] +
+              src_ptr[stride * 3 + 1] + src_ptr[stride * 3 + 2] +
+              src_ptr[stride * 3 + 3] + 8) >>
+             4;
+  }
+}
+
+void ScaleRowDown34_C(const uint8_t* src_ptr,
+                      ptrdiff_t src_stride,
+                      uint8_t* dst,
+                      int dst_width) {
+  int x;
+  (void)src_stride;
+  assert((dst_width % 3 == 0) && (dst_width > 0));
+  for (x = 0; x < dst_width; x += 3) {
+    dst[0] = src_ptr[0];
+    dst[1] = src_ptr[1];
+    dst[2] = src_ptr[3];
+    dst += 3;
+    src_ptr += 4;
+  }
+}
+
+void ScaleRowDown34_16_C(const uint16_t* src_ptr,
+                         ptrdiff_t src_stride,
+                         uint16_t* dst,
+                         int dst_width) {
+  int x;
+  (void)src_stride;
+  assert((dst_width % 3 == 0) && (dst_width > 0));
+  for (x = 0; x < dst_width; x += 3) {
+    dst[0] = src_ptr[0];
+    dst[1] = src_ptr[1];
+    dst[2] = src_ptr[3];
+    dst += 3;
+    src_ptr += 4;
+  }
+}
+
+// Filter rows 0 and 1 together, 3 : 1
+void ScaleRowDown34_0_Box_C(const uint8_t* src_ptr,
+                            ptrdiff_t src_stride,
+                            uint8_t* d,
+                            int dst_width) {
+  const uint8_t* s = src_ptr;
+  const uint8_t* t = src_ptr + src_stride;
+  int x;
+  assert((dst_width % 3 == 0) && (dst_width > 0));
+  for (x = 0; x < dst_width; x += 3) {
+    uint8_t a0 = (s[0] * 3 + s[1] * 1 + 2) >> 2;
+    uint8_t a1 = (s[1] * 1 + s[2] * 1 + 1) >> 1;
+    uint8_t a2 = (s[2] * 1 + s[3] * 3 + 2) >> 2;
+    uint8_t b0 = (t[0] * 3 + t[1] * 1 + 2) >> 2;
+    uint8_t b1 = (t[1] * 1 + t[2] * 1 + 1) >> 1;
+    uint8_t b2 = (t[2] * 1 + t[3] * 3 + 2) >> 2;
+    d[0] = (a0 * 3 + b0 + 2) >> 2;
+    d[1] = (a1 * 3 + b1 + 2) >> 2;
+    d[2] = (a2 * 3 + b2 + 2) >> 2;
+    d += 3;
+    s += 4;
+    t += 4;
+  }
+}
+
+void ScaleRowDown34_0_Box_16_C(const uint16_t* src_ptr,
+                               ptrdiff_t src_stride,
+                               uint16_t* d,
+                               int dst_width) {
+  const uint16_t* s = src_ptr;
+  const uint16_t* t = src_ptr + src_stride;
+  int x;
+  assert((dst_width % 3 == 0) && (dst_width > 0));
+  for (x = 0; x < dst_width; x += 3) {
+    uint16_t a0 = (s[0] * 3 + s[1] * 1 + 2) >> 2;
+    uint16_t a1 = (s[1] * 1 + s[2] * 1 + 1) >> 1;
+    uint16_t a2 = (s[2] * 1 + s[3] * 3 + 2) >> 2;
+    uint16_t b0 = (t[0] * 3 + t[1] * 1 + 2) >> 2;
+    uint16_t b1 = (t[1] * 1 + t[2] * 1 + 1) >> 1;
+    uint16_t b2 = (t[2] * 1 + t[3] * 3 + 2) >> 2;
+    d[0] = (a0 * 3 + b0 + 2) >> 2;
+    d[1] = (a1 * 3 + b1 + 2) >> 2;
+    d[2] = (a2 * 3 + b2 + 2) >> 2;
+    d += 3;
+    s += 4;
+    t += 4;
+  }
+}
+
+// Filter rows 1 and 2 together, 1 : 1
+void ScaleRowDown34_1_Box_C(const uint8_t* src_ptr,
+                            ptrdiff_t src_stride,
+                            uint8_t* d,
+                            int dst_width) {
+  const uint8_t* s = src_ptr;
+  const uint8_t* t = src_ptr + src_stride;
+  int x;
+  assert((dst_width % 3 == 0) && (dst_width > 0));
+  for (x = 0; x < dst_width; x += 3) {
+    uint8_t a0 = (s[0] * 3 + s[1] * 1 + 2) >> 2;
+    uint8_t a1 = (s[1] * 1 + s[2] * 1 + 1) >> 1;
+    uint8_t a2 = (s[2] * 1 + s[3] * 3 + 2) >> 2;
+    uint8_t b0 = (t[0] * 3 + t[1] * 1 + 2) >> 2;
+    uint8_t b1 = (t[1] * 1 + t[2] * 1 + 1) >> 1;
+    uint8_t b2 = (t[2] * 1 + t[3] * 3 + 2) >> 2;
+    d[0] = (a0 + b0 + 1) >> 1;
+    d[1] = (a1 + b1 + 1) >> 1;
+    d[2] = (a2 + b2 + 1) >> 1;
+    d += 3;
+    s += 4;
+    t += 4;
+  }
+}
+
+void ScaleRowDown34_1_Box_16_C(const uint16_t* src_ptr,
+                               ptrdiff_t src_stride,
+                               uint16_t* d,
+                               int dst_width) {
+  const uint16_t* s = src_ptr;
+  const uint16_t* t = src_ptr + src_stride;
+  int x;
+  assert((dst_width % 3 == 0) && (dst_width > 0));
+  for (x = 0; x < dst_width; x += 3) {
+    uint16_t a0 = (s[0] * 3 + s[1] * 1 + 2) >> 2;
+    uint16_t a1 = (s[1] * 1 + s[2] * 1 + 1) >> 1;
+    uint16_t a2 = (s[2] * 1 + s[3] * 3 + 2) >> 2;
+    uint16_t b0 = (t[0] * 3 + t[1] * 1 + 2) >> 2;
+    uint16_t b1 = (t[1] * 1 + t[2] * 1 + 1) >> 1;
+    uint16_t b2 = (t[2] * 1 + t[3] * 3 + 2) >> 2;
+    d[0] = (a0 + b0 + 1) >> 1;
+    d[1] = (a1 + b1 + 1) >> 1;
+    d[2] = (a2 + b2 + 1) >> 1;
+    d += 3;
+    s += 4;
+    t += 4;
+  }
+}
+
+// Sample position: (O is src sample position, X is dst sample position)
+//
+//      v dst_ptr at here           v stop at here
+//  X O X   X O X   X O X   X O X   X O X
+//    ^ src_ptr at here
+void ScaleRowUp2_Linear_C(const uint8_t* src_ptr,
+                          uint8_t* dst_ptr,
+                          int dst_width) {
+  int src_width = dst_width >> 1;
+  int x;
+  assert((dst_width % 2 == 0) && (dst_width >= 0));
+  for (x = 0; x < src_width; ++x) {
+    dst_ptr[2 * x + 0] = (src_ptr[x + 0] * 3 + src_ptr[x + 1] * 1 + 2) >> 2;
+    dst_ptr[2 * x + 1] = (src_ptr[x + 0] * 1 + src_ptr[x + 1] * 3 + 2) >> 2;
+  }
+}
+
+// Sample position: (O is src sample position, X is dst sample position)
+//
+//    src_ptr at here
+//  X v X   X   X   X   X   X   X   X   X
+//    O       O       O       O       O
+//  X   X   X   X   X   X   X   X   X   X
+//      ^ dst_ptr at here           ^ stop at here
+//  X   X   X   X   X   X   X   X   X   X
+//    O       O       O       O       O
+//  X   X   X   X   X   X   X   X   X   X
+void ScaleRowUp2_Bilinear_C(const uint8_t* src_ptr,
+                            ptrdiff_t src_stride,
+                            uint8_t* dst_ptr,
+                            ptrdiff_t dst_stride,
+                            int dst_width) {
+  const uint8_t* s = src_ptr;
+  const uint8_t* t = src_ptr + src_stride;
+  uint8_t* d = dst_ptr;
+  uint8_t* e = dst_ptr + dst_stride;
+  int src_width = dst_width >> 1;
+  int x;
+  assert((dst_width % 2 == 0) && (dst_width >= 0));
+  for (x = 0; x < src_width; ++x) {
+    d[2 * x + 0] =
+        (s[x + 0] * 9 + s[x + 1] * 3 + t[x + 0] * 3 + t[x + 1] * 1 + 8) >> 4;
+    d[2 * x + 1] =
+        (s[x + 0] * 3 + s[x + 1] * 9 + t[x + 0] * 1 + t[x + 1] * 3 + 8) >> 4;
+    e[2 * x + 0] =
+        (s[x + 0] * 3 + s[x + 1] * 1 + t[x + 0] * 9 + t[x + 1] * 3 + 8) >> 4;
+    e[2 * x + 1] =
+        (s[x + 0] * 1 + s[x + 1] * 3 + t[x + 0] * 3 + t[x + 1] * 9 + 8) >> 4;
+  }
+}
+
+// Only suitable for at most 14 bit range.
+void ScaleRowUp2_Linear_16_C(const uint16_t* src_ptr,
+                             uint16_t* dst_ptr,
+                             int dst_width) {
+  int src_width = dst_width >> 1;
+  int x;
+  assert((dst_width % 2 == 0) && (dst_width >= 0));
+  for (x = 0; x < src_width; ++x) {
+    dst_ptr[2 * x + 0] = (src_ptr[x + 0] * 3 + src_ptr[x + 1] * 1 + 2) >> 2;
+    dst_ptr[2 * x + 1] = (src_ptr[x + 0] * 1 + src_ptr[x + 1] * 3 + 2) >> 2;
+  }
+}
+
+// Only suitable for at most 12bit range.
+void ScaleRowUp2_Bilinear_16_C(const uint16_t* src_ptr,
+                               ptrdiff_t src_stride,
+                               uint16_t* dst_ptr,
+                               ptrdiff_t dst_stride,
+                               int dst_width) {
+  const uint16_t* s = src_ptr;
+  const uint16_t* t = src_ptr + src_stride;
+  uint16_t* d = dst_ptr;
+  uint16_t* e = dst_ptr + dst_stride;
+  int src_width = dst_width >> 1;
+  int x;
+  assert((dst_width % 2 == 0) && (dst_width >= 0));
+  for (x = 0; x < src_width; ++x) {
+    d[2 * x + 0] =
+        (s[x + 0] * 9 + s[x + 1] * 3 + t[x + 0] * 3 + t[x + 1] * 1 + 8) >> 4;
+    d[2 * x + 1] =
+        (s[x + 0] * 3 + s[x + 1] * 9 + t[x + 0] * 1 + t[x + 1] * 3 + 8) >> 4;
+    e[2 * x + 0] =
+        (s[x + 0] * 3 + s[x + 1] * 1 + t[x + 0] * 9 + t[x + 1] * 3 + 8) >> 4;
+    e[2 * x + 1] =
+        (s[x + 0] * 1 + s[x + 1] * 3 + t[x + 0] * 3 + t[x + 1] * 9 + 8) >> 4;
+  }
+}
+
+// Scales a single row of pixels using point sampling.
+void ScaleCols_C(uint8_t* dst_ptr,
+                 const uint8_t* src_ptr,
+                 int dst_width,
+                 int x,
+                 int dx) {
+  int j;
+  for (j = 0; j < dst_width - 1; j += 2) {
+    dst_ptr[0] = src_ptr[x >> 16];
+    x += dx;
+    dst_ptr[1] = src_ptr[x >> 16];
+    x += dx;
+    dst_ptr += 2;
+  }
+  if (dst_width & 1) {
+    dst_ptr[0] = src_ptr[x >> 16];
+  }
+}
+
+void ScaleCols_16_C(uint16_t* dst_ptr,
+                    const uint16_t* src_ptr,
+                    int dst_width,
+                    int x,
+                    int dx) {
+  int j;
+  for (j = 0; j < dst_width - 1; j += 2) {
+    dst_ptr[0] = src_ptr[x >> 16];
+    x += dx;
+    dst_ptr[1] = src_ptr[x >> 16];
+    x += dx;
+    dst_ptr += 2;
+  }
+  if (dst_width & 1) {
+    dst_ptr[0] = src_ptr[x >> 16];
+  }
+}
+
+// Scales a single row of pixels up by 2x using point sampling.
+void ScaleColsUp2_C(uint8_t* dst_ptr,
+                    const uint8_t* src_ptr,
+                    int dst_width,
+                    int x,
+                    int dx) {
+  int j;
+  (void)x;
+  (void)dx;
+  for (j = 0; j < dst_width - 1; j += 2) {
+    dst_ptr[1] = dst_ptr[0] = src_ptr[0];
+    src_ptr += 1;
+    dst_ptr += 2;
+  }
+  if (dst_width & 1) {
+    dst_ptr[0] = src_ptr[0];
+  }
+}
+
+void ScaleColsUp2_16_C(uint16_t* dst_ptr,
+                       const uint16_t* src_ptr,
+                       int dst_width,
+                       int x,
+                       int dx) {
+  int j;
+  (void)x;
+  (void)dx;
+  for (j = 0; j < dst_width - 1; j += 2) {
+    dst_ptr[1] = dst_ptr[0] = src_ptr[0];
+    src_ptr += 1;
+    dst_ptr += 2;
+  }
+  if (dst_width & 1) {
+    dst_ptr[0] = src_ptr[0];
+  }
+}
+
+// (1-f)a + fb can be replaced with a + f(b-a)
+#if defined(__arm__) || defined(__aarch64__)
+#define BLENDER(a, b, f) \
+  (uint8_t)((int)(a) + ((((int)((f)) * ((int)(b) - (int)(a))) + 0x8000) >> 16))
+#else
+// Intel uses 7 bit math with rounding.
+#define BLENDER(a, b, f) \
+  (uint8_t)((int)(a) + (((int)((f) >> 9) * ((int)(b) - (int)(a)) + 0x40) >> 7))
+#endif
+
+void ScaleFilterCols_C(uint8_t* dst_ptr,
+                       const uint8_t* src_ptr,
+                       int dst_width,
+                       int x,
+                       int dx) {
+  int j;
+  for (j = 0; j < dst_width - 1; j += 2) {
+    int xi = x >> 16;
+    int a = src_ptr[xi];
+    int b = src_ptr[xi + 1];
+    dst_ptr[0] = BLENDER(a, b, x & 0xffff);
+    x += dx;
+    xi = x >> 16;
+    a = src_ptr[xi];
+    b = src_ptr[xi + 1];
+    dst_ptr[1] = BLENDER(a, b, x & 0xffff);
+    x += dx;
+    dst_ptr += 2;
+  }
+  if (dst_width & 1) {
+    int xi = x >> 16;
+    int a = src_ptr[xi];
+    int b = src_ptr[xi + 1];
+    dst_ptr[0] = BLENDER(a, b, x & 0xffff);
+  }
+}
+
+void ScaleFilterCols64_C(uint8_t* dst_ptr,
+                         const uint8_t* src_ptr,
+                         int dst_width,
+                         int x32,
+                         int dx) {
+  int64_t x = (int64_t)(x32);
+  int j;
+  for (j = 0; j < dst_width - 1; j += 2) {
+    int64_t xi = x >> 16;
+    int a = src_ptr[xi];
+    int b = src_ptr[xi + 1];
+    dst_ptr[0] = BLENDER(a, b, x & 0xffff);
+    x += dx;
+    xi = x >> 16;
+    a = src_ptr[xi];
+    b = src_ptr[xi + 1];
+    dst_ptr[1] = BLENDER(a, b, x & 0xffff);
+    x += dx;
+    dst_ptr += 2;
+  }
+  if (dst_width & 1) {
+    int64_t xi = x >> 16;
+    int a = src_ptr[xi];
+    int b = src_ptr[xi + 1];
+    dst_ptr[0] = BLENDER(a, b, x & 0xffff);
+  }
+}
+#undef BLENDER
+
+// Same as 8 bit arm blender but return is cast to uint16_t
+#define BLENDER(a, b, f) \
+  (uint16_t)(            \
+      (int)(a) +         \
+      (int)((((int64_t)((f)) * ((int64_t)(b) - (int)(a))) + 0x8000) >> 16))
+
+void ScaleFilterCols_16_C(uint16_t* dst_ptr,
+                          const uint16_t* src_ptr,
+                          int dst_width,
+                          int x,
+                          int dx) {
+  int j;
+  for (j = 0; j < dst_width - 1; j += 2) {
+    int xi = x >> 16;
+    int a = src_ptr[xi];
+    int b = src_ptr[xi + 1];
+    dst_ptr[0] = BLENDER(a, b, x & 0xffff);
+    x += dx;
+    xi = x >> 16;
+    a = src_ptr[xi];
+    b = src_ptr[xi + 1];
+    dst_ptr[1] = BLENDER(a, b, x & 0xffff);
+    x += dx;
+    dst_ptr += 2;
+  }
+  if (dst_width & 1) {
+    int xi = x >> 16;
+    int a = src_ptr[xi];
+    int b = src_ptr[xi + 1];
+    dst_ptr[0] = BLENDER(a, b, x & 0xffff);
+  }
+}
+
+void ScaleFilterCols64_16_C(uint16_t* dst_ptr,
+                            const uint16_t* src_ptr,
+                            int dst_width,
+                            int x32,
+                            int dx) {
+  int64_t x = (int64_t)(x32);
+  int j;
+  for (j = 0; j < dst_width - 1; j += 2) {
+    int64_t xi = x >> 16;
+    int a = src_ptr[xi];
+    int b = src_ptr[xi + 1];
+    dst_ptr[0] = BLENDER(a, b, x & 0xffff);
+    x += dx;
+    xi = x >> 16;
+    a = src_ptr[xi];
+    b = src_ptr[xi + 1];
+    dst_ptr[1] = BLENDER(a, b, x & 0xffff);
+    x += dx;
+    dst_ptr += 2;
+  }
+  if (dst_width & 1) {
+    int64_t xi = x >> 16;
+    int a = src_ptr[xi];
+    int b = src_ptr[xi + 1];
+    dst_ptr[0] = BLENDER(a, b, x & 0xffff);
+  }
+}
+#undef BLENDER
+
+void ScaleRowDown38_C(const uint8_t* src_ptr,
+                      ptrdiff_t src_stride,
+                      uint8_t* dst,
+                      int dst_width) {
+  int x;
+  (void)src_stride;
+  assert(dst_width % 3 == 0);
+  for (x = 0; x < dst_width; x += 3) {
+    dst[0] = src_ptr[0];
+    dst[1] = src_ptr[3];
+    dst[2] = src_ptr[6];
+    dst += 3;
+    src_ptr += 8;
+  }
+}
+
+void ScaleRowDown38_16_C(const uint16_t* src_ptr,
+                         ptrdiff_t src_stride,
+                         uint16_t* dst,
+                         int dst_width) {
+  int x;
+  (void)src_stride;
+  assert(dst_width % 3 == 0);
+  for (x = 0; x < dst_width; x += 3) {
+    dst[0] = src_ptr[0];
+    dst[1] = src_ptr[3];
+    dst[2] = src_ptr[6];
+    dst += 3;
+    src_ptr += 8;
+  }
+}
+
+// 8x3 -> 3x1
+void ScaleRowDown38_3_Box_C(const uint8_t* src_ptr,
+                            ptrdiff_t src_stride,
+                            uint8_t* dst_ptr,
+                            int dst_width) {
+  intptr_t stride = src_stride;
+  int i;
+  assert((dst_width % 3 == 0) && (dst_width > 0));
+  for (i = 0; i < dst_width; i += 3) {
+    dst_ptr[0] =
+        (src_ptr[0] + src_ptr[1] + src_ptr[2] + src_ptr[stride + 0] +
+         src_ptr[stride + 1] + src_ptr[stride + 2] + src_ptr[stride * 2 + 0] +
+         src_ptr[stride * 2 + 1] + src_ptr[stride * 2 + 2]) *
+            (65536 / 9) >>
+        16;
+    dst_ptr[1] =
+        (src_ptr[3] + src_ptr[4] + src_ptr[5] + src_ptr[stride + 3] +
+         src_ptr[stride + 4] + src_ptr[stride + 5] + src_ptr[stride * 2 + 3] +
+         src_ptr[stride * 2 + 4] + src_ptr[stride * 2 + 5]) *
+            (65536 / 9) >>
+        16;
+    dst_ptr[2] =
+        (src_ptr[6] + src_ptr[7] + src_ptr[stride + 6] + src_ptr[stride + 7] +
+         src_ptr[stride * 2 + 6] + src_ptr[stride * 2 + 7]) *
+            (65536 / 6) >>
+        16;
+    src_ptr += 8;
+    dst_ptr += 3;
+  }
+}
+
+void ScaleRowDown38_3_Box_16_C(const uint16_t* src_ptr,
+                               ptrdiff_t src_stride,
+                               uint16_t* dst_ptr,
+                               int dst_width) {
+  intptr_t stride = src_stride;
+  int i;
+  assert((dst_width % 3 == 0) && (dst_width > 0));
+  for (i = 0; i < dst_width; i += 3) {
+    dst_ptr[0] =
+        (src_ptr[0] + src_ptr[1] + src_ptr[2] + src_ptr[stride + 0] +
+         src_ptr[stride + 1] + src_ptr[stride + 2] + src_ptr[stride * 2 + 0] +
+         src_ptr[stride * 2 + 1] + src_ptr[stride * 2 + 2]) *
+            (65536u / 9u) >>
+        16;
+    dst_ptr[1] =
+        (src_ptr[3] + src_ptr[4] + src_ptr[5] + src_ptr[stride + 3] +
+         src_ptr[stride + 4] + src_ptr[stride + 5] + src_ptr[stride * 2 + 3] +
+         src_ptr[stride * 2 + 4] + src_ptr[stride * 2 + 5]) *
+            (65536u / 9u) >>
+        16;
+    dst_ptr[2] =
+        (src_ptr[6] + src_ptr[7] + src_ptr[stride + 6] + src_ptr[stride + 7] +
+         src_ptr[stride * 2 + 6] + src_ptr[stride * 2 + 7]) *
+            (65536u / 6u) >>
+        16;
+    src_ptr += 8;
+    dst_ptr += 3;
+  }
+}
+
+// 8x2 -> 3x1
+void ScaleRowDown38_2_Box_C(const uint8_t* src_ptr,
+                            ptrdiff_t src_stride,
+                            uint8_t* dst_ptr,
+                            int dst_width) {
+  intptr_t stride = src_stride;
+  int i;
+  assert((dst_width % 3 == 0) && (dst_width > 0));
+  for (i = 0; i < dst_width; i += 3) {
+    dst_ptr[0] = (src_ptr[0] + src_ptr[1] + src_ptr[2] + src_ptr[stride + 0] +
+                  src_ptr[stride + 1] + src_ptr[stride + 2]) *
+                     (65536 / 6) >>
+                 16;
+    dst_ptr[1] = (src_ptr[3] + src_ptr[4] + src_ptr[5] + src_ptr[stride + 3] +
+                  src_ptr[stride + 4] + src_ptr[stride + 5]) *
+                     (65536 / 6) >>
+                 16;
+    dst_ptr[2] =
+        (src_ptr[6] + src_ptr[7] + src_ptr[stride + 6] + src_ptr[stride + 7]) *
+            (65536 / 4) >>
+        16;
+    src_ptr += 8;
+    dst_ptr += 3;
+  }
+}
+
+void ScaleRowDown38_2_Box_16_C(const uint16_t* src_ptr,
+                               ptrdiff_t src_stride,
+                               uint16_t* dst_ptr,
+                               int dst_width) {
+  intptr_t stride = src_stride;
+  int i;
+  assert((dst_width % 3 == 0) && (dst_width > 0));
+  for (i = 0; i < dst_width; i += 3) {
+    dst_ptr[0] = (src_ptr[0] + src_ptr[1] + src_ptr[2] + src_ptr[stride + 0] +
+                  src_ptr[stride + 1] + src_ptr[stride + 2]) *
+                     (65536u / 6u) >>
+                 16;
+    dst_ptr[1] = (src_ptr[3] + src_ptr[4] + src_ptr[5] + src_ptr[stride + 3] +
+                  src_ptr[stride + 4] + src_ptr[stride + 5]) *
+                     (65536u / 6u) >>
+                 16;
+    dst_ptr[2] =
+        (src_ptr[6] + src_ptr[7] + src_ptr[stride + 6] + src_ptr[stride + 7]) *
+            (65536u / 4u) >>
+        16;
+    src_ptr += 8;
+    dst_ptr += 3;
+  }
+}
+
+void ScaleAddRow_C(const uint8_t* src_ptr, uint16_t* dst_ptr, int src_width) {
+  int x;
+  assert(src_width > 0);
+  for (x = 0; x < src_width - 1; x += 2) {
+    dst_ptr[0] += src_ptr[0];
+    dst_ptr[1] += src_ptr[1];
+    src_ptr += 2;
+    dst_ptr += 2;
+  }
+  if (src_width & 1) {
+    dst_ptr[0] += src_ptr[0];
+  }
+}
+
+void ScaleAddRow_16_C(const uint16_t* src_ptr,
+                      uint32_t* dst_ptr,
+                      int src_width) {
+  int x;
+  assert(src_width > 0);
+  for (x = 0; x < src_width - 1; x += 2) {
+    dst_ptr[0] += src_ptr[0];
+    dst_ptr[1] += src_ptr[1];
+    src_ptr += 2;
+    dst_ptr += 2;
+  }
+  if (src_width & 1) {
+    dst_ptr[0] += src_ptr[0];
+  }
+}
+
+// ARGB scale row functions
+
+void ScaleARGBRowDown2_C(const uint8_t* src_argb,
+                         ptrdiff_t src_stride,
+                         uint8_t* dst_argb,
+                         int dst_width) {
+  const uint32_t* src = (const uint32_t*)(src_argb);
+  uint32_t* dst = (uint32_t*)(dst_argb);
+  int x;
+  (void)src_stride;
+  for (x = 0; x < dst_width - 1; x += 2) {
+    dst[0] = src[1];
+    dst[1] = src[3];
+    src += 4;
+    dst += 2;
+  }
+  if (dst_width & 1) {
+    dst[0] = src[1];
+  }
+}
+
+void ScaleARGBRowDown2Linear_C(const uint8_t* src_argb,
+                               ptrdiff_t src_stride,
+                               uint8_t* dst_argb,
+                               int dst_width) {
+  int x;
+  (void)src_stride;
+  for (x = 0; x < dst_width; ++x) {
+    dst_argb[0] = (src_argb[0] + src_argb[4] + 1) >> 1;
+    dst_argb[1] = (src_argb[1] + src_argb[5] + 1) >> 1;
+    dst_argb[2] = (src_argb[2] + src_argb[6] + 1) >> 1;
+    dst_argb[3] = (src_argb[3] + src_argb[7] + 1) >> 1;
+    src_argb += 8;
+    dst_argb += 4;
+  }
+}
+
+void ScaleARGBRowDown2Box_C(const uint8_t* src_argb,
+                            ptrdiff_t src_stride,
+                            uint8_t* dst_argb,
+                            int dst_width) {
+  int x;
+  for (x = 0; x < dst_width; ++x) {
+    dst_argb[0] = (src_argb[0] + src_argb[4] + src_argb[src_stride] +
+                   src_argb[src_stride + 4] + 2) >>
+                  2;
+    dst_argb[1] = (src_argb[1] + src_argb[5] + src_argb[src_stride + 1] +
+                   src_argb[src_stride + 5] + 2) >>
+                  2;
+    dst_argb[2] = (src_argb[2] + src_argb[6] + src_argb[src_stride + 2] +
+                   src_argb[src_stride + 6] + 2) >>
+                  2;
+    dst_argb[3] = (src_argb[3] + src_argb[7] + src_argb[src_stride + 3] +
+                   src_argb[src_stride + 7] + 2) >>
+                  2;
+    src_argb += 8;
+    dst_argb += 4;
+  }
+}
+
+void ScaleARGBRowDownEven_C(const uint8_t* src_argb,
+                            ptrdiff_t src_stride,
+                            int src_stepx,
+                            uint8_t* dst_argb,
+                            int dst_width) {
+  const uint32_t* src = (const uint32_t*)(src_argb);
+  uint32_t* dst = (uint32_t*)(dst_argb);
+  (void)src_stride;
+  int x;
+  for (x = 0; x < dst_width - 1; x += 2) {
+    dst[0] = src[0];
+    dst[1] = src[src_stepx];
+    src += src_stepx * 2;
+    dst += 2;
+  }
+  if (dst_width & 1) {
+    dst[0] = src[0];
+  }
+}
+
+void ScaleARGBRowDownEvenBox_C(const uint8_t* src_argb,
+                               ptrdiff_t src_stride,
+                               int src_stepx,
+                               uint8_t* dst_argb,
+                               int dst_width) {
+  int x;
+  for (x = 0; x < dst_width; ++x) {
+    dst_argb[0] = (src_argb[0] + src_argb[4] + src_argb[src_stride] +
+                   src_argb[src_stride + 4] + 2) >>
+                  2;
+    dst_argb[1] = (src_argb[1] + src_argb[5] + src_argb[src_stride + 1] +
+                   src_argb[src_stride + 5] + 2) >>
+                  2;
+    dst_argb[2] = (src_argb[2] + src_argb[6] + src_argb[src_stride + 2] +
+                   src_argb[src_stride + 6] + 2) >>
+                  2;
+    dst_argb[3] = (src_argb[3] + src_argb[7] + src_argb[src_stride + 3] +
+                   src_argb[src_stride + 7] + 2) >>
+                  2;
+    src_argb += src_stepx * 4;
+    dst_argb += 4;
+  }
+}
+
+// Scales a single row of pixels using point sampling.
+void ScaleARGBCols_C(uint8_t* dst_argb,
+                     const uint8_t* src_argb,
+                     int dst_width,
+                     int x,
+                     int dx) {
+  const uint32_t* src = (const uint32_t*)(src_argb);
+  uint32_t* dst = (uint32_t*)(dst_argb);
+  int j;
+  for (j = 0; j < dst_width - 1; j += 2) {
+    dst[0] = src[x >> 16];
+    x += dx;
+    dst[1] = src[x >> 16];
+    x += dx;
+    dst += 2;
+  }
+  if (dst_width & 1) {
+    dst[0] = src[x >> 16];
+  }
+}
+
+void ScaleARGBCols64_C(uint8_t* dst_argb,
+                       const uint8_t* src_argb,
+                       int dst_width,
+                       int x32,
+                       int dx) {
+  int64_t x = (int64_t)(x32);
+  const uint32_t* src = (const uint32_t*)(src_argb);
+  uint32_t* dst = (uint32_t*)(dst_argb);
+  int j;
+  for (j = 0; j < dst_width - 1; j += 2) {
+    dst[0] = src[x >> 16];
+    x += dx;
+    dst[1] = src[x >> 16];
+    x += dx;
+    dst += 2;
+  }
+  if (dst_width & 1) {
+    dst[0] = src[x >> 16];
+  }
+}
+
+// Scales a single row of pixels up by 2x using point sampling.
+void ScaleARGBColsUp2_C(uint8_t* dst_argb,
+                        const uint8_t* src_argb,
+                        int dst_width,
+                        int x,
+                        int dx) {
+  const uint32_t* src = (const uint32_t*)(src_argb);
+  uint32_t* dst = (uint32_t*)(dst_argb);
+  int j;
+  (void)x;
+  (void)dx;
+  for (j = 0; j < dst_width - 1; j += 2) {
+    dst[1] = dst[0] = src[0];
+    src += 1;
+    dst += 2;
+  }
+  if (dst_width & 1) {
+    dst[0] = src[0];
+  }
+}
+
+// TODO(fbarchard): Replace 0x7f ^ f with 128-f.  bug=607.
+// Mimics SSSE3 blender
+#define BLENDER1(a, b, f) ((a) * (0x7f ^ f) + (b)*f) >> 7
+#define BLENDERC(a, b, f, s) \
+  (uint32_t)(BLENDER1(((a) >> s) & 255, ((b) >> s) & 255, f) << s)
+#define BLENDER(a, b, f)                                                 \
+  BLENDERC(a, b, f, 24) | BLENDERC(a, b, f, 16) | BLENDERC(a, b, f, 8) | \
+      BLENDERC(a, b, f, 0)
+
+void ScaleARGBFilterCols_C(uint8_t* dst_argb,
+                           const uint8_t* src_argb,
+                           int dst_width,
+                           int x,
+                           int dx) {
+  const uint32_t* src = (const uint32_t*)(src_argb);
+  uint32_t* dst = (uint32_t*)(dst_argb);
+  int j;
+  for (j = 0; j < dst_width - 1; j += 2) {
+    int xi = x >> 16;
+    int xf = (x >> 9) & 0x7f;
+    uint32_t a = src[xi];
+    uint32_t b = src[xi + 1];
+    dst[0] = BLENDER(a, b, xf);
+    x += dx;
+    xi = x >> 16;
+    xf = (x >> 9) & 0x7f;
+    a = src[xi];
+    b = src[xi + 1];
+    dst[1] = BLENDER(a, b, xf);
+    x += dx;
+    dst += 2;
+  }
+  if (dst_width & 1) {
+    int xi = x >> 16;
+    int xf = (x >> 9) & 0x7f;
+    uint32_t a = src[xi];
+    uint32_t b = src[xi + 1];
+    dst[0] = BLENDER(a, b, xf);
+  }
+}
+
+void ScaleARGBFilterCols64_C(uint8_t* dst_argb,
+                             const uint8_t* src_argb,
+                             int dst_width,
+                             int x32,
+                             int dx) {
+  int64_t x = (int64_t)(x32);
+  const uint32_t* src = (const uint32_t*)(src_argb);
+  uint32_t* dst = (uint32_t*)(dst_argb);
+  int j;
+  for (j = 0; j < dst_width - 1; j += 2) {
+    int64_t xi = x >> 16;
+    int xf = (x >> 9) & 0x7f;
+    uint32_t a = src[xi];
+    uint32_t b = src[xi + 1];
+    dst[0] = BLENDER(a, b, xf);
+    x += dx;
+    xi = x >> 16;
+    xf = (x >> 9) & 0x7f;
+    a = src[xi];
+    b = src[xi + 1];
+    dst[1] = BLENDER(a, b, xf);
+    x += dx;
+    dst += 2;
+  }
+  if (dst_width & 1) {
+    int64_t xi = x >> 16;
+    int xf = (x >> 9) & 0x7f;
+    uint32_t a = src[xi];
+    uint32_t b = src[xi + 1];
+    dst[0] = BLENDER(a, b, xf);
+  }
+}
+#undef BLENDER1
+#undef BLENDERC
+#undef BLENDER
+
+// UV scale row functions
+// same as ARGB but 2 channels
+
+void ScaleUVRowDown2_C(const uint8_t* src_uv,
+                       ptrdiff_t src_stride,
+                       uint8_t* dst_uv,
+                       int dst_width) {
+  const uint16_t* src = (const uint16_t*)(src_uv);
+  uint16_t* dst = (uint16_t*)(dst_uv);
+  int x;
+  (void)src_stride;
+  for (x = 0; x < dst_width - 1; x += 2) {
+    dst[0] = src[1];
+    dst[1] = src[3];
+    src += 2;
+    dst += 2;
+  }
+  if (dst_width & 1) {
+    dst[0] = src[1];
+  }
+}
+
+void ScaleUVRowDown2Linear_C(const uint8_t* src_uv,
+                             ptrdiff_t src_stride,
+                             uint8_t* dst_uv,
+                             int dst_width) {
+  int x;
+  (void)src_stride;
+  for (x = 0; x < dst_width; ++x) {
+    dst_uv[0] = (src_uv[0] + src_uv[2] + 1) >> 1;
+    dst_uv[1] = (src_uv[1] + src_uv[3] + 1) >> 1;
+    src_uv += 4;
+    dst_uv += 2;
+  }
+}
+
+void ScaleUVRowDown2Box_C(const uint8_t* src_uv,
+                          ptrdiff_t src_stride,
+                          uint8_t* dst_uv,
+                          int dst_width) {
+  int x;
+  for (x = 0; x < dst_width; ++x) {
+    dst_uv[0] = (src_uv[0] + src_uv[2] + src_uv[src_stride] +
+                 src_uv[src_stride + 2] + 2) >>
+                2;
+    dst_uv[1] = (src_uv[1] + src_uv[3] + src_uv[src_stride + 1] +
+                 src_uv[src_stride + 3] + 2) >>
+                2;
+    src_uv += 4;
+    dst_uv += 2;
+  }
+}
+
+void ScaleUVRowDownEven_C(const uint8_t* src_uv,
+                          ptrdiff_t src_stride,
+                          int src_stepx,
+                          uint8_t* dst_uv,
+                          int dst_width) {
+  const uint16_t* src = (const uint16_t*)(src_uv);
+  uint16_t* dst = (uint16_t*)(dst_uv);
+  (void)src_stride;
+  int x;
+  for (x = 0; x < dst_width - 1; x += 2) {
+    dst[0] = src[0];
+    dst[1] = src[src_stepx];
+    src += src_stepx * 2;
+    dst += 2;
+  }
+  if (dst_width & 1) {
+    dst[0] = src[0];
+  }
+}
+
+void ScaleUVRowDownEvenBox_C(const uint8_t* src_uv,
+                             ptrdiff_t src_stride,
+                             int src_stepx,
+                             uint8_t* dst_uv,
+                             int dst_width) {
+  int x;
+  for (x = 0; x < dst_width; ++x) {
+    dst_uv[0] = (src_uv[0] + src_uv[2] + src_uv[src_stride] +
+                 src_uv[src_stride + 2] + 2) >>
+                2;
+    dst_uv[1] = (src_uv[1] + src_uv[3] + src_uv[src_stride + 1] +
+                 src_uv[src_stride + 3] + 2) >>
+                2;
+    src_uv += src_stepx * 2;
+    dst_uv += 2;
+  }
+}
+
+void ScaleUVRowUp2_Linear_C(const uint8_t* src_ptr,
+                            uint8_t* dst_ptr,
+                            int dst_width) {
+  int src_width = dst_width >> 1;
+  int x;
+  assert((dst_width % 2 == 0) && (dst_width >= 0));
+  for (x = 0; x < src_width; ++x) {
+    dst_ptr[4 * x + 0] =
+        (src_ptr[2 * x + 0] * 3 + src_ptr[2 * x + 2] * 1 + 2) >> 2;
+    dst_ptr[4 * x + 1] =
+        (src_ptr[2 * x + 1] * 3 + src_ptr[2 * x + 3] * 1 + 2) >> 2;
+    dst_ptr[4 * x + 2] =
+        (src_ptr[2 * x + 0] * 1 + src_ptr[2 * x + 2] * 3 + 2) >> 2;
+    dst_ptr[4 * x + 3] =
+        (src_ptr[2 * x + 1] * 1 + src_ptr[2 * x + 3] * 3 + 2) >> 2;
+  }
+}
+
+void ScaleUVRowUp2_Bilinear_C(const uint8_t* src_ptr,
+                              ptrdiff_t src_stride,
+                              uint8_t* dst_ptr,
+                              ptrdiff_t dst_stride,
+                              int dst_width) {
+  const uint8_t* s = src_ptr;
+  const uint8_t* t = src_ptr + src_stride;
+  uint8_t* d = dst_ptr;
+  uint8_t* e = dst_ptr + dst_stride;
+  int src_width = dst_width >> 1;
+  int x;
+  assert((dst_width % 2 == 0) && (dst_width >= 0));
+  for (x = 0; x < src_width; ++x) {
+    d[4 * x + 0] = (s[2 * x + 0] * 9 + s[2 * x + 2] * 3 + t[2 * x + 0] * 3 +
+                    t[2 * x + 2] * 1 + 8) >>
+                   4;
+    d[4 * x + 1] = (s[2 * x + 1] * 9 + s[2 * x + 3] * 3 + t[2 * x + 1] * 3 +
+                    t[2 * x + 3] * 1 + 8) >>
+                   4;
+    d[4 * x + 2] = (s[2 * x + 0] * 3 + s[2 * x + 2] * 9 + t[2 * x + 0] * 1 +
+                    t[2 * x + 2] * 3 + 8) >>
+                   4;
+    d[4 * x + 3] = (s[2 * x + 1] * 3 + s[2 * x + 3] * 9 + t[2 * x + 1] * 1 +
+                    t[2 * x + 3] * 3 + 8) >>
+                   4;
+    e[4 * x + 0] = (s[2 * x + 0] * 3 + s[2 * x + 2] * 1 + t[2 * x + 0] * 9 +
+                    t[2 * x + 2] * 3 + 8) >>
+                   4;
+    e[4 * x + 1] = (s[2 * x + 1] * 3 + s[2 * x + 3] * 1 + t[2 * x + 1] * 9 +
+                    t[2 * x + 3] * 3 + 8) >>
+                   4;
+    e[4 * x + 2] = (s[2 * x + 0] * 1 + s[2 * x + 2] * 3 + t[2 * x + 0] * 3 +
+                    t[2 * x + 2] * 9 + 8) >>
+                   4;
+    e[4 * x + 3] = (s[2 * x + 1] * 1 + s[2 * x + 3] * 3 + t[2 * x + 1] * 3 +
+                    t[2 * x + 3] * 9 + 8) >>
+                   4;
+  }
+}
+
+void ScaleUVRowUp2_Linear_16_C(const uint16_t* src_ptr,
+                               uint16_t* dst_ptr,
+                               int dst_width) {
+  int src_width = dst_width >> 1;
+  int x;
+  assert((dst_width % 2 == 0) && (dst_width >= 0));
+  for (x = 0; x < src_width; ++x) {
+    dst_ptr[4 * x + 0] =
+        (src_ptr[2 * x + 0] * 3 + src_ptr[2 * x + 2] * 1 + 2) >> 2;
+    dst_ptr[4 * x + 1] =
+        (src_ptr[2 * x + 1] * 3 + src_ptr[2 * x + 3] * 1 + 2) >> 2;
+    dst_ptr[4 * x + 2] =
+        (src_ptr[2 * x + 0] * 1 + src_ptr[2 * x + 2] * 3 + 2) >> 2;
+    dst_ptr[4 * x + 3] =
+        (src_ptr[2 * x + 1] * 1 + src_ptr[2 * x + 3] * 3 + 2) >> 2;
+  }
+}
+
+void ScaleUVRowUp2_Bilinear_16_C(const uint16_t* src_ptr,
+                                 ptrdiff_t src_stride,
+                                 uint16_t* dst_ptr,
+                                 ptrdiff_t dst_stride,
+                                 int dst_width) {
+  const uint16_t* s = src_ptr;
+  const uint16_t* t = src_ptr + src_stride;
+  uint16_t* d = dst_ptr;
+  uint16_t* e = dst_ptr + dst_stride;
+  int src_width = dst_width >> 1;
+  int x;
+  assert((dst_width % 2 == 0) && (dst_width >= 0));
+  for (x = 0; x < src_width; ++x) {
+    d[4 * x + 0] = (s[2 * x + 0] * 9 + s[2 * x + 2] * 3 + t[2 * x + 0] * 3 +
+                    t[2 * x + 2] * 1 + 8) >>
+                   4;
+    d[4 * x + 1] = (s[2 * x + 1] * 9 + s[2 * x + 3] * 3 + t[2 * x + 1] * 3 +
+                    t[2 * x + 3] * 1 + 8) >>
+                   4;
+    d[4 * x + 2] = (s[2 * x + 0] * 3 + s[2 * x + 2] * 9 + t[2 * x + 0] * 1 +
+                    t[2 * x + 2] * 3 + 8) >>
+                   4;
+    d[4 * x + 3] = (s[2 * x + 1] * 3 + s[2 * x + 3] * 9 + t[2 * x + 1] * 1 +
+                    t[2 * x + 3] * 3 + 8) >>
+                   4;
+    e[4 * x + 0] = (s[2 * x + 0] * 3 + s[2 * x + 2] * 1 + t[2 * x + 0] * 9 +
+                    t[2 * x + 2] * 3 + 8) >>
+                   4;
+    e[4 * x + 1] = (s[2 * x + 1] * 3 + s[2 * x + 3] * 1 + t[2 * x + 1] * 9 +
+                    t[2 * x + 3] * 3 + 8) >>
+                   4;
+    e[4 * x + 2] = (s[2 * x + 0] * 1 + s[2 * x + 2] * 3 + t[2 * x + 0] * 3 +
+                    t[2 * x + 2] * 9 + 8) >>
+                   4;
+    e[4 * x + 3] = (s[2 * x + 1] * 1 + s[2 * x + 3] * 3 + t[2 * x + 1] * 3 +
+                    t[2 * x + 3] * 9 + 8) >>
+                   4;
+  }
+}
+
+// Scales a single row of pixels using point sampling.
+void ScaleUVCols_C(uint8_t* dst_uv,
+                   const uint8_t* src_uv,
+                   int dst_width,
+                   int x,
+                   int dx) {
+  const uint16_t* src = (const uint16_t*)(src_uv);
+  uint16_t* dst = (uint16_t*)(dst_uv);
+  int j;
+  for (j = 0; j < dst_width - 1; j += 2) {
+    dst[0] = src[x >> 16];
+    x += dx;
+    dst[1] = src[x >> 16];
+    x += dx;
+    dst += 2;
+  }
+  if (dst_width & 1) {
+    dst[0] = src[x >> 16];
+  }
+}
+
+void ScaleUVCols64_C(uint8_t* dst_uv,
+                     const uint8_t* src_uv,
+                     int dst_width,
+                     int x32,
+                     int dx) {
+  int64_t x = (int64_t)(x32);
+  const uint16_t* src = (const uint16_t*)(src_uv);
+  uint16_t* dst = (uint16_t*)(dst_uv);
+  int j;
+  for (j = 0; j < dst_width - 1; j += 2) {
+    dst[0] = src[x >> 16];
+    x += dx;
+    dst[1] = src[x >> 16];
+    x += dx;
+    dst += 2;
+  }
+  if (dst_width & 1) {
+    dst[0] = src[x >> 16];
+  }
+}
+
+// Scales a single row of pixels up by 2x using point sampling.
+void ScaleUVColsUp2_C(uint8_t* dst_uv,
+                      const uint8_t* src_uv,
+                      int dst_width,
+                      int x,
+                      int dx) {
+  const uint16_t* src = (const uint16_t*)(src_uv);
+  uint16_t* dst = (uint16_t*)(dst_uv);
+  int j;
+  (void)x;
+  (void)dx;
+  for (j = 0; j < dst_width - 1; j += 2) {
+    dst[1] = dst[0] = src[0];
+    src += 1;
+    dst += 2;
+  }
+  if (dst_width & 1) {
+    dst[0] = src[0];
+  }
+}
+
+// TODO(fbarchard): Replace 0x7f ^ f with 128-f.  bug=607.
+// Mimics SSSE3 blender
+#define BLENDER1(a, b, f) ((a) * (0x7f ^ f) + (b)*f) >> 7
+#define BLENDERC(a, b, f, s) \
+  (uint16_t)(BLENDER1(((a) >> s) & 255, ((b) >> s) & 255, f) << s)
+#define BLENDER(a, b, f) BLENDERC(a, b, f, 8) | BLENDERC(a, b, f, 0)
+
+void ScaleUVFilterCols_C(uint8_t* dst_uv,
+                         const uint8_t* src_uv,
+                         int dst_width,
+                         int x,
+                         int dx) {
+  const uint16_t* src = (const uint16_t*)(src_uv);
+  uint16_t* dst = (uint16_t*)(dst_uv);
+  int j;
+  for (j = 0; j < dst_width - 1; j += 2) {
+    int xi = x >> 16;
+    int xf = (x >> 9) & 0x7f;
+    uint16_t a = src[xi];
+    uint16_t b = src[xi + 1];
+    dst[0] = BLENDER(a, b, xf);
+    x += dx;
+    xi = x >> 16;
+    xf = (x >> 9) & 0x7f;
+    a = src[xi];
+    b = src[xi + 1];
+    dst[1] = BLENDER(a, b, xf);
+    x += dx;
+    dst += 2;
+  }
+  if (dst_width & 1) {
+    int xi = x >> 16;
+    int xf = (x >> 9) & 0x7f;
+    uint16_t a = src[xi];
+    uint16_t b = src[xi + 1];
+    dst[0] = BLENDER(a, b, xf);
+  }
+}
+
+void ScaleUVFilterCols64_C(uint8_t* dst_uv,
+                           const uint8_t* src_uv,
+                           int dst_width,
+                           int x32,
+                           int dx) {
+  int64_t x = (int64_t)(x32);
+  const uint16_t* src = (const uint16_t*)(src_uv);
+  uint16_t* dst = (uint16_t*)(dst_uv);
+  int j;
+  for (j = 0; j < dst_width - 1; j += 2) {
+    int64_t xi = x >> 16;
+    int xf = (x >> 9) & 0x7f;
+    uint16_t a = src[xi];
+    uint16_t b = src[xi + 1];
+    dst[0] = BLENDER(a, b, xf);
+    x += dx;
+    xi = x >> 16;
+    xf = (x >> 9) & 0x7f;
+    a = src[xi];
+    b = src[xi + 1];
+    dst[1] = BLENDER(a, b, xf);
+    x += dx;
+    dst += 2;
+  }
+  if (dst_width & 1) {
+    int64_t xi = x >> 16;
+    int xf = (x >> 9) & 0x7f;
+    uint16_t a = src[xi];
+    uint16_t b = src[xi + 1];
+    dst[0] = BLENDER(a, b, xf);
+  }
+}
+#undef BLENDER1
+#undef BLENDERC
+#undef BLENDER
+
+// Scale plane vertically with bilinear interpolation.
+void ScalePlaneVertical(int src_height,
+                        int dst_width,
+                        int dst_height,
+                        int src_stride,
+                        int dst_stride,
+                        const uint8_t* src_argb,
+                        uint8_t* dst_argb,
+                        int x,
+                        int y,
+                        int dy,
+                        int bpp,  // bytes per pixel. 4 for ARGB.
+                        enum FilterMode filtering) {
+  // TODO(fbarchard): Allow higher bpp.
+  int dst_width_bytes = dst_width * bpp;
+  void (*InterpolateRow)(uint8_t * dst_argb, const uint8_t* src_argb,
+                         ptrdiff_t src_stride, int dst_width,
+                         int source_y_fraction) = InterpolateRow_C;
+  const int max_y = (src_height > 1) ? ((src_height - 1) << 16) - 1 : 0;
+  int j;
+  assert(bpp >= 1 && bpp <= 4);
+  assert(src_height != 0);
+  assert(dst_width > 0);
+  assert(dst_height > 0);
+  src_argb += (x >> 16) * bpp;
+#if defined(HAS_INTERPOLATEROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    InterpolateRow = InterpolateRow_Any_SSSE3;
+    if (IS_ALIGNED(dst_width_bytes, 16)) {
+      InterpolateRow = InterpolateRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_INTERPOLATEROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    InterpolateRow = InterpolateRow_Any_AVX2;
+    if (IS_ALIGNED(dst_width_bytes, 32)) {
+      InterpolateRow = InterpolateRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_INTERPOLATEROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    InterpolateRow = InterpolateRow_Any_NEON;
+    if (IS_ALIGNED(dst_width_bytes, 16)) {
+      InterpolateRow = InterpolateRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_INTERPOLATEROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    InterpolateRow = InterpolateRow_Any_MSA;
+    if (IS_ALIGNED(dst_width_bytes, 32)) {
+      InterpolateRow = InterpolateRow_MSA;
+    }
+  }
+#endif
+#if defined(HAS_INTERPOLATEROW_LSX)
+  if (TestCpuFlag(kCpuHasLSX)) {
+    InterpolateRow = InterpolateRow_Any_LSX;
+    if (IS_ALIGNED(dst_width_bytes, 32)) {
+      InterpolateRow = InterpolateRow_LSX;
+    }
+  }
+#endif
+  for (j = 0; j < dst_height; ++j) {
+    int yi;
+    int yf;
+    if (y > max_y) {
+      y = max_y;
+    }
+    yi = y >> 16;
+    yf = filtering ? ((y >> 8) & 255) : 0;
+    InterpolateRow(dst_argb, src_argb + yi * src_stride, src_stride,
+                   dst_width_bytes, yf);
+    dst_argb += dst_stride;
+    y += dy;
+  }
+}
+
+void ScalePlaneVertical_16(int src_height,
+                           int dst_width,
+                           int dst_height,
+                           int src_stride,
+                           int dst_stride,
+                           const uint16_t* src_argb,
+                           uint16_t* dst_argb,
+                           int x,
+                           int y,
+                           int dy,
+                           int wpp, /* words per pixel. normally 1 */
+                           enum FilterMode filtering) {
+  // TODO(fbarchard): Allow higher wpp.
+  int dst_width_words = dst_width * wpp;
+  void (*InterpolateRow)(uint16_t * dst_argb, const uint16_t* src_argb,
+                         ptrdiff_t src_stride, int dst_width,
+                         int source_y_fraction) = InterpolateRow_16_C;
+  const int max_y = (src_height > 1) ? ((src_height - 1) << 16) - 1 : 0;
+  int j;
+  assert(wpp >= 1 && wpp <= 2);
+  assert(src_height != 0);
+  assert(dst_width > 0);
+  assert(dst_height > 0);
+  src_argb += (x >> 16) * wpp;
+#if defined(HAS_INTERPOLATEROW_16_SSE2)
+  if (TestCpuFlag(kCpuHasSSE2)) {
+    InterpolateRow = InterpolateRow_16_Any_SSE2;
+    if (IS_ALIGNED(dst_width_words, 16)) {
+      InterpolateRow = InterpolateRow_16_SSE2;
+    }
+  }
+#endif
+#if defined(HAS_INTERPOLATEROW_16_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    InterpolateRow = InterpolateRow_16_Any_SSSE3;
+    if (IS_ALIGNED(dst_width_words, 16)) {
+      InterpolateRow = InterpolateRow_16_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_INTERPOLATEROW_16_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    InterpolateRow = InterpolateRow_16_Any_AVX2;
+    if (IS_ALIGNED(dst_width_words, 32)) {
+      InterpolateRow = InterpolateRow_16_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_INTERPOLATEROW_16_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    InterpolateRow = InterpolateRow_16_Any_NEON;
+    if (IS_ALIGNED(dst_width_words, 8)) {
+      InterpolateRow = InterpolateRow_16_NEON;
+    }
+  }
+#endif
+  for (j = 0; j < dst_height; ++j) {
+    int yi;
+    int yf;
+    if (y > max_y) {
+      y = max_y;
+    }
+    yi = y >> 16;
+    yf = filtering ? ((y >> 8) & 255) : 0;
+    InterpolateRow(dst_argb, src_argb + yi * src_stride, src_stride,
+                   dst_width_words, yf);
+    dst_argb += dst_stride;
+    y += dy;
+  }
+}
+
+// Use scale to convert lsb formats to msb, depending how many bits there are:
+// 32768 = 9 bits
+// 16384 = 10 bits
+// 4096 = 12 bits
+// 256 = 16 bits
+// TODO(fbarchard): change scale to bits
+void ScalePlaneVertical_16To8(int src_height,
+                              int dst_width,
+                              int dst_height,
+                              int src_stride,
+                              int dst_stride,
+                              const uint16_t* src_argb,
+                              uint8_t* dst_argb,
+                              int x,
+                              int y,
+                              int dy,
+                              int wpp, /* words per pixel. normally 1 */
+                              int scale,
+                              enum FilterMode filtering) {
+  // TODO(fbarchard): Allow higher wpp.
+  int dst_width_words = dst_width * wpp;
+  // TODO(https://crbug.com/libyuv/931): Add NEON 32 bit and AVX2 versions.
+  void (*InterpolateRow_16To8)(uint8_t * dst_argb, const uint16_t* src_argb,
+                               ptrdiff_t src_stride, int scale, int dst_width,
+                               int source_y_fraction) = InterpolateRow_16To8_C;
+  const int max_y = (src_height > 1) ? ((src_height - 1) << 16) - 1 : 0;
+  int j;
+  assert(wpp >= 1 && wpp <= 2);
+  assert(src_height != 0);
+  assert(dst_width > 0);
+  assert(dst_height > 0);
+  src_argb += (x >> 16) * wpp;
+
+#if defined(HAS_INTERPOLATEROW_16TO8_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    InterpolateRow_16To8 = InterpolateRow_16To8_Any_NEON;
+    if (IS_ALIGNED(dst_width, 8)) {
+      InterpolateRow_16To8 = InterpolateRow_16To8_NEON;
+    }
+  }
+#endif
+#if defined(HAS_INTERPOLATEROW_16TO8_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    InterpolateRow_16To8 = InterpolateRow_16To8_Any_AVX2;
+    if (IS_ALIGNED(dst_width, 32)) {
+      InterpolateRow_16To8 = InterpolateRow_16To8_AVX2;
+    }
+  }
+#endif
+  for (j = 0; j < dst_height; ++j) {
+    int yi;
+    int yf;
+    if (y > max_y) {
+      y = max_y;
+    }
+    yi = y >> 16;
+    yf = filtering ? ((y >> 8) & 255) : 0;
+    InterpolateRow_16To8(dst_argb, src_argb + yi * src_stride, src_stride,
+                         scale, dst_width_words, yf);
+    dst_argb += dst_stride;
+    y += dy;
+  }
+}
+
+// Simplify the filtering based on scale factors.
+enum FilterMode ScaleFilterReduce(int src_width,
+                                  int src_height,
+                                  int dst_width,
+                                  int dst_height,
+                                  enum FilterMode filtering) {
+  if (src_width < 0) {
+    src_width = -src_width;
+  }
+  if (src_height < 0) {
+    src_height = -src_height;
+  }
+  if (filtering == kFilterBox) {
+    // If scaling either axis to 0.5 or larger, switch from Box to Bilinear.
+    if (dst_width * 2 >= src_width || dst_height * 2 >= src_height) {
+      filtering = kFilterBilinear;
+    }
+  }
+  if (filtering == kFilterBilinear) {
+    if (src_height == 1) {
+      filtering = kFilterLinear;
+    }
+    // TODO(fbarchard): Detect any odd scale factor and reduce to Linear.
+    if (dst_height == src_height || dst_height * 3 == src_height) {
+      filtering = kFilterLinear;
+    }
+    // TODO(fbarchard): Remove 1 pixel wide filter restriction, which is to
+    // avoid reading 2 pixels horizontally that causes memory exception.
+    if (src_width == 1) {
+      filtering = kFilterNone;
+    }
+  }
+  if (filtering == kFilterLinear) {
+    if (src_width == 1) {
+      filtering = kFilterNone;
+    }
+    // TODO(fbarchard): Detect any odd scale factor and reduce to None.
+    if (dst_width == src_width || dst_width * 3 == src_width) {
+      filtering = kFilterNone;
+    }
+  }
+  return filtering;
+}
+
+// Divide num by div and return as 16.16 fixed point result.
+int FixedDiv_C(int num, int div) {
+  return (int)(((int64_t)(num) << 16) / div);
+}
+
+// Divide num - 1 by div - 1 and return as 16.16 fixed point result.
+int FixedDiv1_C(int num, int div) {
+  return (int)((((int64_t)(num) << 16) - 0x00010001) / (div - 1));
+}
+
+#define CENTERSTART(dx, s) (dx < 0) ? -((-dx >> 1) + s) : ((dx >> 1) + s)
+
+// Compute slope values for stepping.
+void ScaleSlope(int src_width,
+                int src_height,
+                int dst_width,
+                int dst_height,
+                enum FilterMode filtering,
+                int* x,
+                int* y,
+                int* dx,
+                int* dy) {
+  assert(x != NULL);
+  assert(y != NULL);
+  assert(dx != NULL);
+  assert(dy != NULL);
+  assert(src_width != 0);
+  assert(src_height != 0);
+  assert(dst_width > 0);
+  assert(dst_height > 0);
+  // Check for 1 pixel and avoid FixedDiv overflow.
+  if (dst_width == 1 && src_width >= 32768) {
+    dst_width = src_width;
+  }
+  if (dst_height == 1 && src_height >= 32768) {
+    dst_height = src_height;
+  }
+  if (filtering == kFilterBox) {
+    // Scale step for point sampling duplicates all pixels equally.
+    *dx = FixedDiv(Abs(src_width), dst_width);
+    *dy = FixedDiv(src_height, dst_height);
+    *x = 0;
+    *y = 0;
+  } else if (filtering == kFilterBilinear) {
+    // Scale step for bilinear sampling renders last pixel once for upsample.
+    if (dst_width <= Abs(src_width)) {
+      *dx = FixedDiv(Abs(src_width), dst_width);
+      *x = CENTERSTART(*dx, -32768);  // Subtract 0.5 (32768) to center filter.
+    } else if (src_width > 1 && dst_width > 1) {
+      *dx = FixedDiv1(Abs(src_width), dst_width);
+      *x = 0;
+    }
+    if (dst_height <= src_height) {
+      *dy = FixedDiv(src_height, dst_height);
+      *y = CENTERSTART(*dy, -32768);  // Subtract 0.5 (32768) to center filter.
+    } else if (src_height > 1 && dst_height > 1) {
+      *dy = FixedDiv1(src_height, dst_height);
+      *y = 0;
+    }
+  } else if (filtering == kFilterLinear) {
+    // Scale step for bilinear sampling renders last pixel once for upsample.
+    if (dst_width <= Abs(src_width)) {
+      *dx = FixedDiv(Abs(src_width), dst_width);
+      *x = CENTERSTART(*dx, -32768);  // Subtract 0.5 (32768) to center filter.
+    } else if (src_width > 1 && dst_width > 1) {
+      *dx = FixedDiv1(Abs(src_width), dst_width);
+      *x = 0;
+    }
+    *dy = FixedDiv(src_height, dst_height);
+    *y = *dy >> 1;
+  } else {
+    // Scale step for point sampling duplicates all pixels equally.
+    *dx = FixedDiv(Abs(src_width), dst_width);
+    *dy = FixedDiv(src_height, dst_height);
+    *x = CENTERSTART(*dx, 0);
+    *y = CENTERSTART(*dy, 0);
+  }
+  // Negative src_width means horizontally mirror.
+  if (src_width < 0) {
+    *x += (dst_width - 1) * *dx;
+    *dx = -*dx;
+    // src_width = -src_width;   // Caller must do this.
+  }
+}
+#undef CENTERSTART
+
+// Read 8x2 upsample with filtering and write 16x1.
+// actually reads an extra pixel, so 9x2.
+void ScaleRowUp2_16_C(const uint16_t* src_ptr,
+                      ptrdiff_t src_stride,
+                      uint16_t* dst,
+                      int dst_width) {
+  const uint16_t* src2 = src_ptr + src_stride;
+
+  int x;
+  for (x = 0; x < dst_width - 1; x += 2) {
+    uint16_t p0 = src_ptr[0];
+    uint16_t p1 = src_ptr[1];
+    uint16_t p2 = src2[0];
+    uint16_t p3 = src2[1];
+    dst[0] = (p0 * 9 + p1 * 3 + p2 * 3 + p3 + 8) >> 4;
+    dst[1] = (p0 * 3 + p1 * 9 + p2 + p3 * 3 + 8) >> 4;
+    ++src_ptr;
+    ++src2;
+    dst += 2;
+  }
+  if (dst_width & 1) {
+    uint16_t p0 = src_ptr[0];
+    uint16_t p1 = src_ptr[1];
+    uint16_t p2 = src2[0];
+    uint16_t p3 = src2[1];
+    dst[0] = (p0 * 9 + p1 * 3 + p2 * 3 + p3 + 8) >> 4;
+  }
+}
+
+#ifdef __cplusplus
+}  // extern "C"
+}  // namespace libyuv
+#endif
diff --git a/3rdparty/libyuv/src/source/scale_gcc.cc b/3rdparty/libyuv/src/source/scale_gcc.cc
new file mode 100644
index 00000000..d827c0e7
--- /dev/null
+++ b/3rdparty/libyuv/src/source/scale_gcc.cc
@@ -0,0 +1,2946 @@
+/*
+ *  Copyright 2013 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include "libyuv/row.h"
+#include "libyuv/scale_row.h"
+
+#ifdef __cplusplus
+namespace libyuv {
+extern "C" {
+#endif
+
+// This module is for GCC x86 and x64.
+#if !defined(LIBYUV_DISABLE_X86) && (defined(__x86_64__) || defined(__i386__))
+
+// Offsets for source bytes 0 to 9
+static const uvec8 kShuf0 = {0,   1,   3,   4,   5,   7,   8,   9,
+                             128, 128, 128, 128, 128, 128, 128, 128};
+
+// Offsets for source bytes 11 to 20 with 8 subtracted = 3 to 12.
+static const uvec8 kShuf1 = {3,   4,   5,   7,   8,   9,   11,  12,
+                             128, 128, 128, 128, 128, 128, 128, 128};
+
+// Offsets for source bytes 21 to 31 with 16 subtracted = 5 to 31.
+static const uvec8 kShuf2 = {5,   7,   8,   9,   11,  12,  13,  15,
+                             128, 128, 128, 128, 128, 128, 128, 128};
+
+// Offsets for source bytes 0 to 10
+static const uvec8 kShuf01 = {0, 1, 1, 2, 2, 3, 4, 5, 5, 6, 6, 7, 8, 9, 9, 10};
+
+// Offsets for source bytes 10 to 21 with 8 subtracted = 3 to 13.
+static const uvec8 kShuf11 = {2, 3, 4, 5,  5,  6,  6,  7,
+                              8, 9, 9, 10, 10, 11, 12, 13};
+
+// Offsets for source bytes 21 to 31 with 16 subtracted = 5 to 31.
+static const uvec8 kShuf21 = {5,  6,  6,  7,  8,  9,  9,  10,
+                              10, 11, 12, 13, 13, 14, 14, 15};
+
+// Coefficients for source bytes 0 to 10
+static const uvec8 kMadd01 = {3, 1, 2, 2, 1, 3, 3, 1, 2, 2, 1, 3, 3, 1, 2, 2};
+
+// Coefficients for source bytes 10 to 21
+static const uvec8 kMadd11 = {1, 3, 3, 1, 2, 2, 1, 3, 3, 1, 2, 2, 1, 3, 3, 1};
+
+// Coefficients for source bytes 21 to 31
+static const uvec8 kMadd21 = {2, 2, 1, 3, 3, 1, 2, 2, 1, 3, 3, 1, 2, 2, 1, 3};
+
+// Coefficients for source bytes 21 to 31
+static const vec16 kRound34 = {2, 2, 2, 2, 2, 2, 2, 2};
+
+static const uvec8 kShuf38a = {0,   3,   6,   8,   11,  14,  128, 128,
+                               128, 128, 128, 128, 128, 128, 128, 128};
+
+static const uvec8 kShuf38b = {128, 128, 128, 128, 128, 128, 0,   3,
+                               6,   8,   11,  14,  128, 128, 128, 128};
+
+// Arrange words 0,3,6 into 0,1,2
+static const uvec8 kShufAc = {0,   1,   6,   7,   12,  13,  128, 128,
+                              128, 128, 128, 128, 128, 128, 128, 128};
+
+// Arrange words 0,3,6 into 3,4,5
+static const uvec8 kShufAc3 = {128, 128, 128, 128, 128, 128, 0,   1,
+                               6,   7,   12,  13,  128, 128, 128, 128};
+
+// Scaling values for boxes of 3x3 and 2x3
+static const uvec16 kScaleAc33 = {65536 / 9, 65536 / 9, 65536 / 6, 65536 / 9,
+                                  65536 / 9, 65536 / 6, 0,         0};
+
+// Arrange first value for pixels 0,1,2,3,4,5
+static const uvec8 kShufAb0 = {0,  128, 3,  128, 6,   128, 8,   128,
+                               11, 128, 14, 128, 128, 128, 128, 128};
+
+// Arrange second value for pixels 0,1,2,3,4,5
+static const uvec8 kShufAb1 = {1,  128, 4,  128, 7,   128, 9,   128,
+                               12, 128, 15, 128, 128, 128, 128, 128};
+
+// Arrange third value for pixels 0,1,2,3,4,5
+static const uvec8 kShufAb2 = {2,  128, 5,   128, 128, 128, 10,  128,
+                               13, 128, 128, 128, 128, 128, 128, 128};
+
+// Scaling values for boxes of 3x2 and 2x2
+static const uvec16 kScaleAb2 = {65536 / 3, 65536 / 3, 65536 / 2, 65536 / 3,
+                                 65536 / 3, 65536 / 2, 0,         0};
+
+// GCC versions of row functions are verbatim conversions from Visual C.
+// Generated using gcc disassembly on Visual C object file:
+// objdump -D yuvscaler.obj >yuvscaler.txt
+
+void ScaleRowDown2_SSSE3(const uint8_t* src_ptr,
+                         ptrdiff_t src_stride,
+                         uint8_t* dst_ptr,
+                         int dst_width) {
+  (void)src_stride;
+  asm volatile(
+      // 16 pixel loop.
+      LABELALIGN
+      "1:                                        \n"
+      "movdqu      (%0),%%xmm0                   \n"
+      "movdqu      0x10(%0),%%xmm1               \n"
+      "lea         0x20(%0),%0                   \n"
+      "psrlw       $0x8,%%xmm0                   \n"
+      "psrlw       $0x8,%%xmm1                   \n"
+      "packuswb    %%xmm1,%%xmm0                 \n"
+      "movdqu      %%xmm0,(%1)                   \n"
+      "lea         0x10(%1),%1                   \n"
+      "sub         $0x10,%2                      \n"
+      "jg          1b                            \n"
+      : "+r"(src_ptr),   // %0
+        "+r"(dst_ptr),   // %1
+        "+r"(dst_width)  // %2
+        ::"memory",
+        "cc", "xmm0", "xmm1");
+}
+
+void ScaleRowDown2Linear_SSSE3(const uint8_t* src_ptr,
+                               ptrdiff_t src_stride,
+                               uint8_t* dst_ptr,
+                               int dst_width) {
+  (void)src_stride;
+  asm volatile(
+      "pcmpeqb     %%xmm4,%%xmm4                 \n"
+      "psrlw       $0xf,%%xmm4                   \n"
+      "packuswb    %%xmm4,%%xmm4                 \n"
+      "pxor        %%xmm5,%%xmm5                 \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "movdqu      (%0),%%xmm0                   \n"
+      "movdqu      0x10(%0),%%xmm1               \n"
+      "lea         0x20(%0),%0                   \n"
+      "pmaddubsw   %%xmm4,%%xmm0                 \n"
+      "pmaddubsw   %%xmm4,%%xmm1                 \n"
+      "pavgw       %%xmm5,%%xmm0                 \n"
+      "pavgw       %%xmm5,%%xmm1                 \n"
+      "packuswb    %%xmm1,%%xmm0                 \n"
+      "movdqu      %%xmm0,(%1)                   \n"
+      "lea         0x10(%1),%1                   \n"
+      "sub         $0x10,%2                      \n"
+      "jg          1b                            \n"
+      : "+r"(src_ptr),   // %0
+        "+r"(dst_ptr),   // %1
+        "+r"(dst_width)  // %2
+        ::"memory",
+        "cc", "xmm0", "xmm1", "xmm4", "xmm5");
+}
+
+void ScaleRowDown2Box_SSSE3(const uint8_t* src_ptr,
+                            ptrdiff_t src_stride,
+                            uint8_t* dst_ptr,
+                            int dst_width) {
+  asm volatile(
+      "pcmpeqb     %%xmm4,%%xmm4                 \n"
+      "psrlw       $0xf,%%xmm4                   \n"
+      "packuswb    %%xmm4,%%xmm4                 \n"
+      "pxor        %%xmm5,%%xmm5                 \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "movdqu      (%0),%%xmm0                   \n"
+      "movdqu      0x10(%0),%%xmm1               \n"
+      "movdqu      0x00(%0,%3,1),%%xmm2          \n"
+      "movdqu      0x10(%0,%3,1),%%xmm3          \n"
+      "lea         0x20(%0),%0                   \n"
+      "pmaddubsw   %%xmm4,%%xmm0                 \n"
+      "pmaddubsw   %%xmm4,%%xmm1                 \n"
+      "pmaddubsw   %%xmm4,%%xmm2                 \n"
+      "pmaddubsw   %%xmm4,%%xmm3                 \n"
+      "paddw       %%xmm2,%%xmm0                 \n"
+      "paddw       %%xmm3,%%xmm1                 \n"
+      "psrlw       $0x1,%%xmm0                   \n"
+      "psrlw       $0x1,%%xmm1                   \n"
+      "pavgw       %%xmm5,%%xmm0                 \n"
+      "pavgw       %%xmm5,%%xmm1                 \n"
+      "packuswb    %%xmm1,%%xmm0                 \n"
+      "movdqu      %%xmm0,(%1)                   \n"
+      "lea         0x10(%1),%1                   \n"
+      "sub         $0x10,%2                      \n"
+      "jg          1b                            \n"
+      : "+r"(src_ptr),               // %0
+        "+r"(dst_ptr),               // %1
+        "+r"(dst_width)              // %2
+      : "r"((intptr_t)(src_stride))  // %3
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm5");
+}
+
+#ifdef HAS_SCALEROWDOWN2_AVX2
+void ScaleRowDown2_AVX2(const uint8_t* src_ptr,
+                        ptrdiff_t src_stride,
+                        uint8_t* dst_ptr,
+                        int dst_width) {
+  (void)src_stride;
+  asm volatile(LABELALIGN
+      "1:                                        \n"
+      "vmovdqu     (%0),%%ymm0                   \n"
+      "vmovdqu     0x20(%0),%%ymm1               \n"
+      "lea         0x40(%0),%0                   \n"
+      "vpsrlw      $0x8,%%ymm0,%%ymm0            \n"
+      "vpsrlw      $0x8,%%ymm1,%%ymm1            \n"
+      "vpackuswb   %%ymm1,%%ymm0,%%ymm0          \n"
+      "vpermq      $0xd8,%%ymm0,%%ymm0           \n"
+      "vmovdqu     %%ymm0,(%1)                   \n"
+      "lea         0x20(%1),%1                   \n"
+      "sub         $0x20,%2                      \n"
+      "jg          1b                            \n"
+      "vzeroupper                                \n"
+               : "+r"(src_ptr),   // %0
+                 "+r"(dst_ptr),   // %1
+                 "+r"(dst_width)  // %2
+                 ::"memory",
+                 "cc", "xmm0", "xmm1");
+}
+
+void ScaleRowDown2Linear_AVX2(const uint8_t* src_ptr,
+                              ptrdiff_t src_stride,
+                              uint8_t* dst_ptr,
+                              int dst_width) {
+  (void)src_stride;
+  asm volatile(
+      "vpcmpeqb    %%ymm4,%%ymm4,%%ymm4          \n"
+      "vpsrlw      $0xf,%%ymm4,%%ymm4            \n"
+      "vpackuswb   %%ymm4,%%ymm4,%%ymm4          \n"
+      "vpxor       %%ymm5,%%ymm5,%%ymm5          \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "vmovdqu     (%0),%%ymm0                   \n"
+      "vmovdqu     0x20(%0),%%ymm1               \n"
+      "lea         0x40(%0),%0                   \n"
+      "vpmaddubsw  %%ymm4,%%ymm0,%%ymm0          \n"
+      "vpmaddubsw  %%ymm4,%%ymm1,%%ymm1          \n"
+      "vpavgw      %%ymm5,%%ymm0,%%ymm0          \n"
+      "vpavgw      %%ymm5,%%ymm1,%%ymm1          \n"
+      "vpackuswb   %%ymm1,%%ymm0,%%ymm0          \n"
+      "vpermq      $0xd8,%%ymm0,%%ymm0           \n"
+      "vmovdqu     %%ymm0,(%1)                   \n"
+      "lea         0x20(%1),%1                   \n"
+      "sub         $0x20,%2                      \n"
+      "jg          1b                            \n"
+      "vzeroupper                                \n"
+      : "+r"(src_ptr),   // %0
+        "+r"(dst_ptr),   // %1
+        "+r"(dst_width)  // %2
+        ::"memory",
+        "cc", "xmm0", "xmm1", "xmm4", "xmm5");
+}
+
+void ScaleRowDown2Box_AVX2(const uint8_t* src_ptr,
+                           ptrdiff_t src_stride,
+                           uint8_t* dst_ptr,
+                           int dst_width) {
+  asm volatile(
+      "vpcmpeqb    %%ymm4,%%ymm4,%%ymm4          \n"
+      "vpsrlw      $0xf,%%ymm4,%%ymm4            \n"
+      "vpackuswb   %%ymm4,%%ymm4,%%ymm4          \n"
+      "vpxor       %%ymm5,%%ymm5,%%ymm5          \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "vmovdqu     (%0),%%ymm0                   \n"
+      "vmovdqu     0x20(%0),%%ymm1               \n"
+      "vmovdqu     0x00(%0,%3,1),%%ymm2          \n"
+      "vmovdqu     0x20(%0,%3,1),%%ymm3          \n"
+      "lea         0x40(%0),%0                   \n"
+      "vpmaddubsw  %%ymm4,%%ymm0,%%ymm0          \n"
+      "vpmaddubsw  %%ymm4,%%ymm1,%%ymm1          \n"
+      "vpmaddubsw  %%ymm4,%%ymm2,%%ymm2          \n"
+      "vpmaddubsw  %%ymm4,%%ymm3,%%ymm3          \n"
+      "vpaddw      %%ymm2,%%ymm0,%%ymm0          \n"
+      "vpaddw      %%ymm3,%%ymm1,%%ymm1          \n"
+      "vpsrlw      $0x1,%%ymm0,%%ymm0            \n"
+      "vpsrlw      $0x1,%%ymm1,%%ymm1            \n"
+      "vpavgw      %%ymm5,%%ymm0,%%ymm0          \n"
+      "vpavgw      %%ymm5,%%ymm1,%%ymm1          \n"
+      "vpackuswb   %%ymm1,%%ymm0,%%ymm0          \n"
+      "vpermq      $0xd8,%%ymm0,%%ymm0           \n"
+      "vmovdqu     %%ymm0,(%1)                   \n"
+      "lea         0x20(%1),%1                   \n"
+      "sub         $0x20,%2                      \n"
+      "jg          1b                            \n"
+      "vzeroupper                                \n"
+      : "+r"(src_ptr),               // %0
+        "+r"(dst_ptr),               // %1
+        "+r"(dst_width)              // %2
+      : "r"((intptr_t)(src_stride))  // %3
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm5");
+}
+#endif  // HAS_SCALEROWDOWN2_AVX2
+
+void ScaleRowDown4_SSSE3(const uint8_t* src_ptr,
+                         ptrdiff_t src_stride,
+                         uint8_t* dst_ptr,
+                         int dst_width) {
+  (void)src_stride;
+  asm volatile(
+      "pcmpeqb     %%xmm5,%%xmm5                 \n"
+      "psrld       $0x18,%%xmm5                  \n"
+      "pslld       $0x10,%%xmm5                  \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "movdqu      (%0),%%xmm0                   \n"
+      "movdqu      0x10(%0),%%xmm1               \n"
+      "lea         0x20(%0),%0                   \n"
+      "pand        %%xmm5,%%xmm0                 \n"
+      "pand        %%xmm5,%%xmm1                 \n"
+      "packuswb    %%xmm1,%%xmm0                 \n"
+      "psrlw       $0x8,%%xmm0                   \n"
+      "packuswb    %%xmm0,%%xmm0                 \n"
+      "movq        %%xmm0,(%1)                   \n"
+      "lea         0x8(%1),%1                    \n"
+      "sub         $0x8,%2                       \n"
+      "jg          1b                            \n"
+      : "+r"(src_ptr),   // %0
+        "+r"(dst_ptr),   // %1
+        "+r"(dst_width)  // %2
+        ::"memory",
+        "cc", "xmm0", "xmm1", "xmm5");
+}
+
+void ScaleRowDown4Box_SSSE3(const uint8_t* src_ptr,
+                            ptrdiff_t src_stride,
+                            uint8_t* dst_ptr,
+                            int dst_width) {
+  intptr_t stridex3;
+  asm volatile(
+      "pcmpeqb     %%xmm4,%%xmm4                 \n"
+      "psrlw       $0xf,%%xmm4                   \n"
+      "movdqa      %%xmm4,%%xmm5                 \n"
+      "packuswb    %%xmm4,%%xmm4                 \n"
+      "psllw       $0x3,%%xmm5                   \n"
+      "lea         0x00(%4,%4,2),%3              \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "movdqu      (%0),%%xmm0                   \n"
+      "movdqu      0x10(%0),%%xmm1               \n"
+      "movdqu      0x00(%0,%4,1),%%xmm2          \n"
+      "movdqu      0x10(%0,%4,1),%%xmm3          \n"
+      "pmaddubsw   %%xmm4,%%xmm0                 \n"
+      "pmaddubsw   %%xmm4,%%xmm1                 \n"
+      "pmaddubsw   %%xmm4,%%xmm2                 \n"
+      "pmaddubsw   %%xmm4,%%xmm3                 \n"
+      "paddw       %%xmm2,%%xmm0                 \n"
+      "paddw       %%xmm3,%%xmm1                 \n"
+      "movdqu      0x00(%0,%4,2),%%xmm2          \n"
+      "movdqu      0x10(%0,%4,2),%%xmm3          \n"
+      "pmaddubsw   %%xmm4,%%xmm2                 \n"
+      "pmaddubsw   %%xmm4,%%xmm3                 \n"
+      "paddw       %%xmm2,%%xmm0                 \n"
+      "paddw       %%xmm3,%%xmm1                 \n"
+      "movdqu      0x00(%0,%3,1),%%xmm2          \n"
+      "movdqu      0x10(%0,%3,1),%%xmm3          \n"
+      "lea         0x20(%0),%0                   \n"
+      "pmaddubsw   %%xmm4,%%xmm2                 \n"
+      "pmaddubsw   %%xmm4,%%xmm3                 \n"
+      "paddw       %%xmm2,%%xmm0                 \n"
+      "paddw       %%xmm3,%%xmm1                 \n"
+      "phaddw      %%xmm1,%%xmm0                 \n"
+      "paddw       %%xmm5,%%xmm0                 \n"
+      "psrlw       $0x4,%%xmm0                   \n"
+      "packuswb    %%xmm0,%%xmm0                 \n"
+      "movq        %%xmm0,(%1)                   \n"
+      "lea         0x8(%1),%1                    \n"
+      "sub         $0x8,%2                       \n"
+      "jg          1b                            \n"
+      : "+r"(src_ptr),               // %0
+        "+r"(dst_ptr),               // %1
+        "+r"(dst_width),             // %2
+        "=&r"(stridex3)              // %3
+      : "r"((intptr_t)(src_stride))  // %4
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5");
+}
+
+#ifdef HAS_SCALEROWDOWN4_AVX2
+void ScaleRowDown4_AVX2(const uint8_t* src_ptr,
+                        ptrdiff_t src_stride,
+                        uint8_t* dst_ptr,
+                        int dst_width) {
+  (void)src_stride;
+  asm volatile(
+      "vpcmpeqb    %%ymm5,%%ymm5,%%ymm5          \n"
+      "vpsrld      $0x18,%%ymm5,%%ymm5           \n"
+      "vpslld      $0x10,%%ymm5,%%ymm5           \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "vmovdqu     (%0),%%ymm0                   \n"
+      "vmovdqu     0x20(%0),%%ymm1               \n"
+      "lea         0x40(%0),%0                   \n"
+      "vpand       %%ymm5,%%ymm0,%%ymm0          \n"
+      "vpand       %%ymm5,%%ymm1,%%ymm1          \n"
+      "vpackuswb   %%ymm1,%%ymm0,%%ymm0          \n"
+      "vpermq      $0xd8,%%ymm0,%%ymm0           \n"
+      "vpsrlw      $0x8,%%ymm0,%%ymm0            \n"
+      "vpackuswb   %%ymm0,%%ymm0,%%ymm0          \n"
+      "vpermq      $0xd8,%%ymm0,%%ymm0           \n"
+      "vmovdqu     %%xmm0,(%1)                   \n"
+      "lea         0x10(%1),%1                   \n"
+      "sub         $0x10,%2                      \n"
+      "jg          1b                            \n"
+      "vzeroupper                                \n"
+      : "+r"(src_ptr),   // %0
+        "+r"(dst_ptr),   // %1
+        "+r"(dst_width)  // %2
+        ::"memory",
+        "cc", "xmm0", "xmm1", "xmm5");
+}
+
+void ScaleRowDown4Box_AVX2(const uint8_t* src_ptr,
+                           ptrdiff_t src_stride,
+                           uint8_t* dst_ptr,
+                           int dst_width) {
+  asm volatile(
+      "vpcmpeqb    %%ymm4,%%ymm4,%%ymm4          \n"
+      "vpsrlw      $0xf,%%ymm4,%%ymm4            \n"
+      "vpsllw      $0x3,%%ymm4,%%ymm5            \n"
+      "vpackuswb   %%ymm4,%%ymm4,%%ymm4          \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "vmovdqu     (%0),%%ymm0                   \n"
+      "vmovdqu     0x20(%0),%%ymm1               \n"
+      "vmovdqu     0x00(%0,%3,1),%%ymm2          \n"
+      "vmovdqu     0x20(%0,%3,1),%%ymm3          \n"
+      "vpmaddubsw  %%ymm4,%%ymm0,%%ymm0          \n"
+      "vpmaddubsw  %%ymm4,%%ymm1,%%ymm1          \n"
+      "vpmaddubsw  %%ymm4,%%ymm2,%%ymm2          \n"
+      "vpmaddubsw  %%ymm4,%%ymm3,%%ymm3          \n"
+      "vpaddw      %%ymm2,%%ymm0,%%ymm0          \n"
+      "vpaddw      %%ymm3,%%ymm1,%%ymm1          \n"
+      "vmovdqu     0x00(%0,%3,2),%%ymm2          \n"
+      "vmovdqu     0x20(%0,%3,2),%%ymm3          \n"
+      "vpmaddubsw  %%ymm4,%%ymm2,%%ymm2          \n"
+      "vpmaddubsw  %%ymm4,%%ymm3,%%ymm3          \n"
+      "vpaddw      %%ymm2,%%ymm0,%%ymm0          \n"
+      "vpaddw      %%ymm3,%%ymm1,%%ymm1          \n"
+      "vmovdqu     0x00(%0,%4,1),%%ymm2          \n"
+      "vmovdqu     0x20(%0,%4,1),%%ymm3          \n"
+      "lea         0x40(%0),%0                   \n"
+      "vpmaddubsw  %%ymm4,%%ymm2,%%ymm2          \n"
+      "vpmaddubsw  %%ymm4,%%ymm3,%%ymm3          \n"
+      "vpaddw      %%ymm2,%%ymm0,%%ymm0          \n"
+      "vpaddw      %%ymm3,%%ymm1,%%ymm1          \n"
+      "vphaddw     %%ymm1,%%ymm0,%%ymm0          \n"
+      "vpermq      $0xd8,%%ymm0,%%ymm0           \n"
+      "vpaddw      %%ymm5,%%ymm0,%%ymm0          \n"
+      "vpsrlw      $0x4,%%ymm0,%%ymm0            \n"
+      "vpackuswb   %%ymm0,%%ymm0,%%ymm0          \n"
+      "vpermq      $0xd8,%%ymm0,%%ymm0           \n"
+      "vmovdqu     %%xmm0,(%1)                   \n"
+      "lea         0x10(%1),%1                   \n"
+      "sub         $0x10,%2                      \n"
+      "jg          1b                            \n"
+      "vzeroupper                                \n"
+      : "+r"(src_ptr),                   // %0
+        "+r"(dst_ptr),                   // %1
+        "+r"(dst_width)                  // %2
+      : "r"((intptr_t)(src_stride)),     // %3
+        "r"((intptr_t)(src_stride * 3))  // %4
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5");
+}
+#endif  // HAS_SCALEROWDOWN4_AVX2
+
+void ScaleRowDown34_SSSE3(const uint8_t* src_ptr,
+                          ptrdiff_t src_stride,
+                          uint8_t* dst_ptr,
+                          int dst_width) {
+  (void)src_stride;
+  asm volatile(
+      "movdqa      %0,%%xmm3                     \n"
+      "movdqa      %1,%%xmm4                     \n"
+      "movdqa      %2,%%xmm5                     \n"
+      :
+      : "m"(kShuf0),  // %0
+        "m"(kShuf1),  // %1
+        "m"(kShuf2)   // %2
+  );
+  asm volatile(LABELALIGN
+      "1:                                        \n"
+      "movdqu      (%0),%%xmm0                   \n"
+      "movdqu      0x10(%0),%%xmm2               \n"
+      "lea         0x20(%0),%0                   \n"
+      "movdqa      %%xmm2,%%xmm1                 \n"
+      "palignr     $0x8,%%xmm0,%%xmm1            \n"
+      "pshufb      %%xmm3,%%xmm0                 \n"
+      "pshufb      %%xmm4,%%xmm1                 \n"
+      "pshufb      %%xmm5,%%xmm2                 \n"
+      "movq        %%xmm0,(%1)                   \n"
+      "movq        %%xmm1,0x8(%1)                \n"
+      "movq        %%xmm2,0x10(%1)               \n"
+      "lea         0x18(%1),%1                   \n"
+      "sub         $0x18,%2                      \n"
+      "jg          1b                            \n"
+               : "+r"(src_ptr),   // %0
+                 "+r"(dst_ptr),   // %1
+                 "+r"(dst_width)  // %2
+                 ::"memory",
+                 "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5");
+}
+
+void ScaleRowDown34_1_Box_SSSE3(const uint8_t* src_ptr,
+                                ptrdiff_t src_stride,
+                                uint8_t* dst_ptr,
+                                int dst_width) {
+  asm volatile(
+      "movdqa      %0,%%xmm2                     \n"  // kShuf01
+      "movdqa      %1,%%xmm3                     \n"  // kShuf11
+      "movdqa      %2,%%xmm4                     \n"  // kShuf21
+      :
+      : "m"(kShuf01),  // %0
+        "m"(kShuf11),  // %1
+        "m"(kShuf21)   // %2
+  );
+  asm volatile(
+      "movdqa      %0,%%xmm5                     \n"  // kMadd01
+      "movdqa      %1,%%xmm0                     \n"  // kMadd11
+      "movdqa      %2,%%xmm1                     \n"  // kRound34
+      :
+      : "m"(kMadd01),  // %0
+        "m"(kMadd11),  // %1
+        "m"(kRound34)  // %2
+  );
+  asm volatile(LABELALIGN
+      "1:                                        \n"
+      "movdqu      (%0),%%xmm6                   \n"
+      "movdqu      0x00(%0,%3,1),%%xmm7          \n"
+      "pavgb       %%xmm7,%%xmm6                 \n"
+      "pshufb      %%xmm2,%%xmm6                 \n"
+      "pmaddubsw   %%xmm5,%%xmm6                 \n"
+      "paddsw      %%xmm1,%%xmm6                 \n"
+      "psrlw       $0x2,%%xmm6                   \n"
+      "packuswb    %%xmm6,%%xmm6                 \n"
+      "movq        %%xmm6,(%1)                   \n"
+      "movdqu      0x8(%0),%%xmm6                \n"
+      "movdqu      0x8(%0,%3,1),%%xmm7           \n"
+      "pavgb       %%xmm7,%%xmm6                 \n"
+      "pshufb      %%xmm3,%%xmm6                 \n"
+      "pmaddubsw   %%xmm0,%%xmm6                 \n"
+      "paddsw      %%xmm1,%%xmm6                 \n"
+      "psrlw       $0x2,%%xmm6                   \n"
+      "packuswb    %%xmm6,%%xmm6                 \n"
+      "movq        %%xmm6,0x8(%1)                \n"
+      "movdqu      0x10(%0),%%xmm6               \n"
+      "movdqu      0x10(%0,%3,1),%%xmm7          \n"
+      "lea         0x20(%0),%0                   \n"
+      "pavgb       %%xmm7,%%xmm6                 \n"
+      "pshufb      %%xmm4,%%xmm6                 \n"
+      "pmaddubsw   %4,%%xmm6                     \n"
+      "paddsw      %%xmm1,%%xmm6                 \n"
+      "psrlw       $0x2,%%xmm6                   \n"
+      "packuswb    %%xmm6,%%xmm6                 \n"
+      "movq        %%xmm6,0x10(%1)               \n"
+      "lea         0x18(%1),%1                   \n"
+      "sub         $0x18,%2                      \n"
+      "jg          1b                            \n"
+               : "+r"(src_ptr),                // %0
+                 "+r"(dst_ptr),                // %1
+                 "+r"(dst_width)               // %2
+               : "r"((intptr_t)(src_stride)),  // %3
+                 "m"(kMadd21)                  // %4
+               : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5",
+                 "xmm6", "xmm7");
+}
+
+void ScaleRowDown34_0_Box_SSSE3(const uint8_t* src_ptr,
+                                ptrdiff_t src_stride,
+                                uint8_t* dst_ptr,
+                                int dst_width) {
+  asm volatile(
+      "movdqa      %0,%%xmm2                     \n"  // kShuf01
+      "movdqa      %1,%%xmm3                     \n"  // kShuf11
+      "movdqa      %2,%%xmm4                     \n"  // kShuf21
+      :
+      : "m"(kShuf01),  // %0
+        "m"(kShuf11),  // %1
+        "m"(kShuf21)   // %2
+  );
+  asm volatile(
+      "movdqa      %0,%%xmm5                     \n"  // kMadd01
+      "movdqa      %1,%%xmm0                     \n"  // kMadd11
+      "movdqa      %2,%%xmm1                     \n"  // kRound34
+      :
+      : "m"(kMadd01),  // %0
+        "m"(kMadd11),  // %1
+        "m"(kRound34)  // %2
+  );
+
+  asm volatile(LABELALIGN
+      "1:                                        \n"
+      "movdqu      (%0),%%xmm6                   \n"
+      "movdqu      0x00(%0,%3,1),%%xmm7          \n"
+      "pavgb       %%xmm6,%%xmm7                 \n"
+      "pavgb       %%xmm7,%%xmm6                 \n"
+      "pshufb      %%xmm2,%%xmm6                 \n"
+      "pmaddubsw   %%xmm5,%%xmm6                 \n"
+      "paddsw      %%xmm1,%%xmm6                 \n"
+      "psrlw       $0x2,%%xmm6                   \n"
+      "packuswb    %%xmm6,%%xmm6                 \n"
+      "movq        %%xmm6,(%1)                   \n"
+      "movdqu      0x8(%0),%%xmm6                \n"
+      "movdqu      0x8(%0,%3,1),%%xmm7           \n"
+      "pavgb       %%xmm6,%%xmm7                 \n"
+      "pavgb       %%xmm7,%%xmm6                 \n"
+      "pshufb      %%xmm3,%%xmm6                 \n"
+      "pmaddubsw   %%xmm0,%%xmm6                 \n"
+      "paddsw      %%xmm1,%%xmm6                 \n"
+      "psrlw       $0x2,%%xmm6                   \n"
+      "packuswb    %%xmm6,%%xmm6                 \n"
+      "movq        %%xmm6,0x8(%1)                \n"
+      "movdqu      0x10(%0),%%xmm6               \n"
+      "movdqu      0x10(%0,%3,1),%%xmm7          \n"
+      "lea         0x20(%0),%0                   \n"
+      "pavgb       %%xmm6,%%xmm7                 \n"
+      "pavgb       %%xmm7,%%xmm6                 \n"
+      "pshufb      %%xmm4,%%xmm6                 \n"
+      "pmaddubsw   %4,%%xmm6                     \n"
+      "paddsw      %%xmm1,%%xmm6                 \n"
+      "psrlw       $0x2,%%xmm6                   \n"
+      "packuswb    %%xmm6,%%xmm6                 \n"
+      "movq        %%xmm6,0x10(%1)               \n"
+      "lea         0x18(%1),%1                   \n"
+      "sub         $0x18,%2                      \n"
+      "jg          1b                            \n"
+               : "+r"(src_ptr),                // %0
+                 "+r"(dst_ptr),                // %1
+                 "+r"(dst_width)               // %2
+               : "r"((intptr_t)(src_stride)),  // %3
+                 "m"(kMadd21)                  // %4
+               : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5",
+                 "xmm6", "xmm7");
+}
+
+void ScaleRowDown38_SSSE3(const uint8_t* src_ptr,
+                          ptrdiff_t src_stride,
+                          uint8_t* dst_ptr,
+                          int dst_width) {
+  (void)src_stride;
+  asm volatile(
+      "movdqa      %3,%%xmm4                     \n"
+      "movdqa      %4,%%xmm5                     \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "movdqu      (%0),%%xmm0                   \n"
+      "movdqu      0x10(%0),%%xmm1               \n"
+      "lea         0x20(%0),%0                   \n"
+      "pshufb      %%xmm4,%%xmm0                 \n"
+      "pshufb      %%xmm5,%%xmm1                 \n"
+      "paddusb     %%xmm1,%%xmm0                 \n"
+      "movq        %%xmm0,(%1)                   \n"
+      "movhlps     %%xmm0,%%xmm1                 \n"
+      "movd        %%xmm1,0x8(%1)                \n"
+      "lea         0xc(%1),%1                    \n"
+      "sub         $0xc,%2                       \n"
+      "jg          1b                            \n"
+      : "+r"(src_ptr),   // %0
+        "+r"(dst_ptr),   // %1
+        "+r"(dst_width)  // %2
+      : "m"(kShuf38a),   // %3
+        "m"(kShuf38b)    // %4
+      : "memory", "cc", "xmm0", "xmm1", "xmm4", "xmm5");
+}
+
+void ScaleRowDown38_2_Box_SSSE3(const uint8_t* src_ptr,
+                                ptrdiff_t src_stride,
+                                uint8_t* dst_ptr,
+                                int dst_width) {
+  asm volatile(
+      "movdqa      %0,%%xmm2                     \n"
+      "movdqa      %1,%%xmm3                     \n"
+      "movdqa      %2,%%xmm4                     \n"
+      "movdqa      %3,%%xmm5                     \n"
+      :
+      : "m"(kShufAb0),  // %0
+        "m"(kShufAb1),  // %1
+        "m"(kShufAb2),  // %2
+        "m"(kScaleAb2)  // %3
+  );
+  asm volatile(LABELALIGN
+      "1:                                        \n"
+      "movdqu      (%0),%%xmm0                   \n"
+      "movdqu      0x00(%0,%3,1),%%xmm1          \n"
+      "lea         0x10(%0),%0                   \n"
+      "pavgb       %%xmm1,%%xmm0                 \n"
+      "movdqa      %%xmm0,%%xmm1                 \n"
+      "pshufb      %%xmm2,%%xmm1                 \n"
+      "movdqa      %%xmm0,%%xmm6                 \n"
+      "pshufb      %%xmm3,%%xmm6                 \n"
+      "paddusw     %%xmm6,%%xmm1                 \n"
+      "pshufb      %%xmm4,%%xmm0                 \n"
+      "paddusw     %%xmm0,%%xmm1                 \n"
+      "pmulhuw     %%xmm5,%%xmm1                 \n"
+      "packuswb    %%xmm1,%%xmm1                 \n"
+      "movd        %%xmm1,(%1)                   \n"
+      "psrlq       $0x10,%%xmm1                  \n"
+      "movd        %%xmm1,0x2(%1)                \n"
+      "lea         0x6(%1),%1                    \n"
+      "sub         $0x6,%2                       \n"
+      "jg          1b                            \n"
+               : "+r"(src_ptr),               // %0
+                 "+r"(dst_ptr),               // %1
+                 "+r"(dst_width)              // %2
+               : "r"((intptr_t)(src_stride))  // %3
+               : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5",
+                 "xmm6");
+}
+
+void ScaleRowDown38_3_Box_SSSE3(const uint8_t* src_ptr,
+                                ptrdiff_t src_stride,
+                                uint8_t* dst_ptr,
+                                int dst_width) {
+  asm volatile(
+      "movdqa      %0,%%xmm2                     \n"
+      "movdqa      %1,%%xmm3                     \n"
+      "movdqa      %2,%%xmm4                     \n"
+      "pxor        %%xmm5,%%xmm5                 \n"
+      :
+      : "m"(kShufAc),    // %0
+        "m"(kShufAc3),   // %1
+        "m"(kScaleAc33)  // %2
+  );
+  asm volatile(LABELALIGN
+      "1:                                        \n"
+      "movdqu      (%0),%%xmm0                   \n"
+      "movdqu      0x00(%0,%3,1),%%xmm6          \n"
+      "movhlps     %%xmm0,%%xmm1                 \n"
+      "movhlps     %%xmm6,%%xmm7                 \n"
+      "punpcklbw   %%xmm5,%%xmm0                 \n"
+      "punpcklbw   %%xmm5,%%xmm1                 \n"
+      "punpcklbw   %%xmm5,%%xmm6                 \n"
+      "punpcklbw   %%xmm5,%%xmm7                 \n"
+      "paddusw     %%xmm6,%%xmm0                 \n"
+      "paddusw     %%xmm7,%%xmm1                 \n"
+      "movdqu      0x00(%0,%3,2),%%xmm6          \n"
+      "lea         0x10(%0),%0                   \n"
+      "movhlps     %%xmm6,%%xmm7                 \n"
+      "punpcklbw   %%xmm5,%%xmm6                 \n"
+      "punpcklbw   %%xmm5,%%xmm7                 \n"
+      "paddusw     %%xmm6,%%xmm0                 \n"
+      "paddusw     %%xmm7,%%xmm1                 \n"
+      "movdqa      %%xmm0,%%xmm6                 \n"
+      "psrldq      $0x2,%%xmm0                   \n"
+      "paddusw     %%xmm0,%%xmm6                 \n"
+      "psrldq      $0x2,%%xmm0                   \n"
+      "paddusw     %%xmm0,%%xmm6                 \n"
+      "pshufb      %%xmm2,%%xmm6                 \n"
+      "movdqa      %%xmm1,%%xmm7                 \n"
+      "psrldq      $0x2,%%xmm1                   \n"
+      "paddusw     %%xmm1,%%xmm7                 \n"
+      "psrldq      $0x2,%%xmm1                   \n"
+      "paddusw     %%xmm1,%%xmm7                 \n"
+      "pshufb      %%xmm3,%%xmm7                 \n"
+      "paddusw     %%xmm7,%%xmm6                 \n"
+      "pmulhuw     %%xmm4,%%xmm6                 \n"
+      "packuswb    %%xmm6,%%xmm6                 \n"
+      "movd        %%xmm6,(%1)                   \n"
+      "psrlq       $0x10,%%xmm6                  \n"
+      "movd        %%xmm6,0x2(%1)                \n"
+      "lea         0x6(%1),%1                    \n"
+      "sub         $0x6,%2                       \n"
+      "jg          1b                            \n"
+               : "+r"(src_ptr),               // %0
+                 "+r"(dst_ptr),               // %1
+                 "+r"(dst_width)              // %2
+               : "r"((intptr_t)(src_stride))  // %3
+               : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5",
+                 "xmm6", "xmm7");
+}
+
+static const uvec8 kLinearShuffleFar = {2,  3,  0, 1, 6,  7,  4,  5,
+                                        10, 11, 8, 9, 14, 15, 12, 13};
+
+static const uvec8 kLinearMadd31 = {3, 1, 1, 3, 3, 1, 1, 3,
+                                    3, 1, 1, 3, 3, 1, 1, 3};
+
+#ifdef HAS_SCALEROWUP2LINEAR_SSE2
+void ScaleRowUp2_Linear_SSE2(const uint8_t* src_ptr,
+                             uint8_t* dst_ptr,
+                             int dst_width) {
+  asm volatile(
+      "pxor        %%xmm0,%%xmm0                 \n"  // 0
+      "pcmpeqw     %%xmm6,%%xmm6                 \n"
+      "psrlw       $15,%%xmm6                    \n"
+      "psllw       $1,%%xmm6                     \n"  // all 2
+
+      LABELALIGN
+      "1:                                        \n"
+      "movq        (%0),%%xmm1                   \n"  // 01234567
+      "movq        1(%0),%%xmm2                  \n"  // 12345678
+      "movdqa      %%xmm1,%%xmm3                 \n"
+      "punpcklbw   %%xmm2,%%xmm3                 \n"  // 0112233445566778
+      "punpcklbw   %%xmm1,%%xmm1                 \n"  // 0011223344556677
+      "punpcklbw   %%xmm2,%%xmm2                 \n"  // 1122334455667788
+      "movdqa      %%xmm1,%%xmm4                 \n"
+      "punpcklbw   %%xmm0,%%xmm4                 \n"  // 00112233 (16)
+      "movdqa      %%xmm2,%%xmm5                 \n"
+      "punpcklbw   %%xmm0,%%xmm5                 \n"  // 11223344 (16)
+      "paddw       %%xmm5,%%xmm4                 \n"
+      "movdqa      %%xmm3,%%xmm5                 \n"
+      "paddw       %%xmm6,%%xmm4                 \n"
+      "punpcklbw   %%xmm0,%%xmm5                 \n"  // 01122334 (16)
+      "paddw       %%xmm5,%%xmm5                 \n"
+      "paddw       %%xmm4,%%xmm5                 \n"  // 3*near+far+2 (lo)
+      "psrlw       $2,%%xmm5                     \n"  // 3/4*near+1/4*far (lo)
+
+      "punpckhbw   %%xmm0,%%xmm1                 \n"  // 44556677 (16)
+      "punpckhbw   %%xmm0,%%xmm2                 \n"  // 55667788 (16)
+      "paddw       %%xmm2,%%xmm1                 \n"
+      "punpckhbw   %%xmm0,%%xmm3                 \n"  // 45566778 (16)
+      "paddw       %%xmm6,%%xmm1                 \n"
+      "paddw       %%xmm3,%%xmm3                 \n"
+      "paddw       %%xmm3,%%xmm1                 \n"  // 3*near+far+2 (hi)
+      "psrlw       $2,%%xmm1                     \n"  // 3/4*near+1/4*far (hi)
+
+      "packuswb    %%xmm1,%%xmm5                 \n"
+      "movdqu      %%xmm5,(%1)                   \n"
+
+      "lea         0x8(%0),%0                    \n"
+      "lea         0x10(%1),%1                   \n"  // 8 sample to 16 sample
+      "sub         $0x10,%2                      \n"
+      "jg          1b                            \n"
+      : "+r"(src_ptr),   // %0
+        "+r"(dst_ptr),   // %1
+        "+r"(dst_width)  // %2
+      :
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6");
+}
+#endif
+
+#ifdef HAS_SCALEROWUP2BILINEAR_SSE2
+void ScaleRowUp2_Bilinear_SSE2(const uint8_t* src_ptr,
+                               ptrdiff_t src_stride,
+                               uint8_t* dst_ptr,
+                               ptrdiff_t dst_stride,
+                               int dst_width) {
+  asm volatile(
+      LABELALIGN
+      "1:                                        \n"
+      "pxor        %%xmm0,%%xmm0                 \n"  // 0
+      // above line
+      "movq        (%0),%%xmm1                   \n"  // 01234567
+      "movq        1(%0),%%xmm2                  \n"  // 12345678
+      "movdqa      %%xmm1,%%xmm3                 \n"
+      "punpcklbw   %%xmm2,%%xmm3                 \n"  // 0112233445566778
+      "punpcklbw   %%xmm1,%%xmm1                 \n"  // 0011223344556677
+      "punpcklbw   %%xmm2,%%xmm2                 \n"  // 1122334455667788
+
+      "movdqa      %%xmm1,%%xmm4                 \n"
+      "punpcklbw   %%xmm0,%%xmm4                 \n"  // 00112233 (16)
+      "movdqa      %%xmm2,%%xmm5                 \n"
+      "punpcklbw   %%xmm0,%%xmm5                 \n"  // 11223344 (16)
+      "paddw       %%xmm5,%%xmm4                 \n"  // near+far
+      "movdqa      %%xmm3,%%xmm5                 \n"
+      "punpcklbw   %%xmm0,%%xmm5                 \n"  // 01122334 (16)
+      "paddw       %%xmm5,%%xmm5                 \n"  // 2*near
+      "paddw       %%xmm5,%%xmm4                 \n"  // 3*near+far (1, lo)
+
+      "punpckhbw   %%xmm0,%%xmm1                 \n"  // 44556677 (16)
+      "punpckhbw   %%xmm0,%%xmm2                 \n"  // 55667788 (16)
+      "paddw       %%xmm2,%%xmm1                 \n"
+      "punpckhbw   %%xmm0,%%xmm3                 \n"  // 45566778 (16)
+      "paddw       %%xmm3,%%xmm3                 \n"  // 2*near
+      "paddw       %%xmm3,%%xmm1                 \n"  // 3*near+far (1, hi)
+
+      // below line
+      "movq        (%0,%3),%%xmm6                \n"  // 01234567
+      "movq        1(%0,%3),%%xmm2               \n"  // 12345678
+      "movdqa      %%xmm6,%%xmm3                 \n"
+      "punpcklbw   %%xmm2,%%xmm3                 \n"  // 0112233445566778
+      "punpcklbw   %%xmm6,%%xmm6                 \n"  // 0011223344556677
+      "punpcklbw   %%xmm2,%%xmm2                 \n"  // 1122334455667788
+
+      "movdqa      %%xmm6,%%xmm5                 \n"
+      "punpcklbw   %%xmm0,%%xmm5                 \n"  // 00112233 (16)
+      "movdqa      %%xmm2,%%xmm7                 \n"
+      "punpcklbw   %%xmm0,%%xmm7                 \n"  // 11223344 (16)
+      "paddw       %%xmm7,%%xmm5                 \n"  // near+far
+      "movdqa      %%xmm3,%%xmm7                 \n"
+      "punpcklbw   %%xmm0,%%xmm7                 \n"  // 01122334 (16)
+      "paddw       %%xmm7,%%xmm7                 \n"  // 2*near
+      "paddw       %%xmm7,%%xmm5                 \n"  // 3*near+far (2, lo)
+
+      "punpckhbw   %%xmm0,%%xmm6                 \n"  // 44556677 (16)
+      "punpckhbw   %%xmm0,%%xmm2                 \n"  // 55667788 (16)
+      "paddw       %%xmm6,%%xmm2                 \n"  // near+far
+      "punpckhbw   %%xmm0,%%xmm3                 \n"  // 45566778 (16)
+      "paddw       %%xmm3,%%xmm3                 \n"  // 2*near
+      "paddw       %%xmm3,%%xmm2                 \n"  // 3*near+far (2, hi)
+
+      // xmm4 xmm1
+      // xmm5 xmm2
+      "pcmpeqw     %%xmm0,%%xmm0                 \n"
+      "psrlw       $15,%%xmm0                    \n"
+      "psllw       $3,%%xmm0                     \n"  // all 8
+
+      "movdqa      %%xmm4,%%xmm3                 \n"
+      "movdqa      %%xmm5,%%xmm6                 \n"
+      "paddw       %%xmm3,%%xmm3                 \n"  // 6*near+2*far (1, lo)
+      "paddw       %%xmm0,%%xmm6                 \n"  // 3*near+far+8 (2, lo)
+      "paddw       %%xmm4,%%xmm3                 \n"  // 9*near+3*far (1, lo)
+      "paddw       %%xmm6,%%xmm3                 \n"  // 9 3 3 1 + 8 (1, lo)
+      "psrlw       $4,%%xmm3                     \n"  // ^ div by 16
+
+      "movdqa      %%xmm1,%%xmm7                 \n"
+      "movdqa      %%xmm2,%%xmm6                 \n"
+      "paddw       %%xmm7,%%xmm7                 \n"  // 6*near+2*far (1, hi)
+      "paddw       %%xmm0,%%xmm6                 \n"  // 3*near+far+8 (2, hi)
+      "paddw       %%xmm1,%%xmm7                 \n"  // 9*near+3*far (1, hi)
+      "paddw       %%xmm6,%%xmm7                 \n"  // 9 3 3 1 + 8 (1, hi)
+      "psrlw       $4,%%xmm7                     \n"  // ^ div by 16
+
+      "packuswb    %%xmm7,%%xmm3                 \n"
+      "movdqu      %%xmm3,(%1)                   \n"  // save above line
+
+      "movdqa      %%xmm5,%%xmm3                 \n"
+      "paddw       %%xmm0,%%xmm4                 \n"  // 3*near+far+8 (1, lo)
+      "paddw       %%xmm3,%%xmm3                 \n"  // 6*near+2*far (2, lo)
+      "paddw       %%xmm3,%%xmm5                 \n"  // 9*near+3*far (2, lo)
+      "paddw       %%xmm4,%%xmm5                 \n"  // 9 3 3 1 + 8 (lo)
+      "psrlw       $4,%%xmm5                     \n"  // ^ div by 16
+
+      "movdqa      %%xmm2,%%xmm3                 \n"
+      "paddw       %%xmm0,%%xmm1                 \n"  // 3*near+far+8 (1, hi)
+      "paddw       %%xmm3,%%xmm3                 \n"  // 6*near+2*far (2, hi)
+      "paddw       %%xmm3,%%xmm2                 \n"  // 9*near+3*far (2, hi)
+      "paddw       %%xmm1,%%xmm2                 \n"  // 9 3 3 1 + 8 (hi)
+      "psrlw       $4,%%xmm2                     \n"  // ^ div by 16
+
+      "packuswb    %%xmm2,%%xmm5                 \n"
+      "movdqu      %%xmm5,(%1,%4)                \n"  // save below line
+
+      "lea         0x8(%0),%0                    \n"
+      "lea         0x10(%1),%1                   \n"  // 8 sample to 16 sample
+      "sub         $0x10,%2                      \n"
+      "jg          1b                            \n"
+      : "+r"(src_ptr),                // %0
+        "+r"(dst_ptr),                // %1
+        "+r"(dst_width)               // %2
+      : "r"((intptr_t)(src_stride)),  // %3
+        "r"((intptr_t)(dst_stride))   // %4
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6",
+        "xmm7");
+}
+#endif
+
+#ifdef HAS_SCALEROWUP2LINEAR_12_SSSE3
+void ScaleRowUp2_Linear_12_SSSE3(const uint16_t* src_ptr,
+                                 uint16_t* dst_ptr,
+                                 int dst_width) {
+  asm volatile(
+      "movdqa      %3,%%xmm5                     \n"
+      "pcmpeqw     %%xmm4,%%xmm4                 \n"
+      "psrlw       $15,%%xmm4                    \n"
+      "psllw       $1,%%xmm4                     \n"  // all 2
+
+      LABELALIGN
+      "1:                                        \n"
+      "movdqu      (%0),%%xmm0                   \n"  // 01234567 (16)
+      "movdqu      2(%0),%%xmm1                  \n"  // 12345678 (16)
+
+      "movdqa      %%xmm0,%%xmm2                 \n"
+      "punpckhwd   %%xmm1,%%xmm2                 \n"  // 45566778 (16)
+      "punpcklwd   %%xmm1,%%xmm0                 \n"  // 01122334 (16)
+
+      "movdqa      %%xmm2,%%xmm3                 \n"
+      "movdqa      %%xmm0,%%xmm1                 \n"
+      "pshufb      %%xmm5,%%xmm3                 \n"  // 54657687 (far)
+      "pshufb      %%xmm5,%%xmm1                 \n"  // 10213243 (far)
+
+      "paddw       %%xmm4,%%xmm1                 \n"  // far+2
+      "paddw       %%xmm4,%%xmm3                 \n"  // far+2
+      "paddw       %%xmm0,%%xmm1                 \n"  // near+far+2
+      "paddw       %%xmm2,%%xmm3                 \n"  // near+far+2
+      "paddw       %%xmm0,%%xmm0                 \n"  // 2*near
+      "paddw       %%xmm2,%%xmm2                 \n"  // 2*near
+      "paddw       %%xmm1,%%xmm0                 \n"  // 3*near+far+2 (lo)
+      "paddw       %%xmm3,%%xmm2                 \n"  // 3*near+far+2 (hi)
+
+      "psrlw       $2,%%xmm0                     \n"  // 3/4*near+1/4*far
+      "psrlw       $2,%%xmm2                     \n"  // 3/4*near+1/4*far
+      "movdqu      %%xmm0,(%1)                   \n"
+      "movdqu      %%xmm2,16(%1)                 \n"
+
+      "lea         0x10(%0),%0                   \n"
+      "lea         0x20(%1),%1                   \n"  // 8 sample to 16 sample
+      "sub         $0x10,%2                      \n"
+      "jg          1b                            \n"
+      : "+r"(src_ptr),          // %0
+        "+r"(dst_ptr),          // %1
+        "+r"(dst_width)         // %2
+      : "m"(kLinearShuffleFar)  // %3
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5");
+}
+#endif
+
+#ifdef HAS_SCALEROWUP2BILINEAR_12_SSSE3
+void ScaleRowUp2_Bilinear_12_SSSE3(const uint16_t* src_ptr,
+                                   ptrdiff_t src_stride,
+                                   uint16_t* dst_ptr,
+                                   ptrdiff_t dst_stride,
+                                   int dst_width) {
+  asm volatile(
+      "pcmpeqw     %%xmm7,%%xmm7                 \n"
+      "psrlw       $15,%%xmm7                    \n"
+      "psllw       $3,%%xmm7                     \n"  // all 8
+      "movdqa      %5,%%xmm6                     \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      // above line
+      "movdqu      (%0),%%xmm0                   \n"  // 01234567 (16)
+      "movdqu      2(%0),%%xmm1                  \n"  // 12345678 (16)
+      "movdqa      %%xmm0,%%xmm2                 \n"
+      "punpckhwd   %%xmm1,%%xmm2                 \n"  // 45566778 (16)
+      "punpcklwd   %%xmm1,%%xmm0                 \n"  // 01122334 (16)
+      "movdqa      %%xmm2,%%xmm3                 \n"
+      "movdqa      %%xmm0,%%xmm1                 \n"
+      "pshufb      %%xmm6,%%xmm3                 \n"  // 54657687 (far)
+      "pshufb      %%xmm6,%%xmm1                 \n"  // 10213243 (far)
+      "paddw       %%xmm0,%%xmm1                 \n"  // near+far
+      "paddw       %%xmm2,%%xmm3                 \n"  // near+far
+      "paddw       %%xmm0,%%xmm0                 \n"  // 2*near
+      "paddw       %%xmm2,%%xmm2                 \n"  // 2*near
+      "paddw       %%xmm1,%%xmm0                 \n"  // 3*near+far (1, lo)
+      "paddw       %%xmm3,%%xmm2                 \n"  // 3*near+far (1, hi)
+
+      // below line
+      "movdqu      (%0,%3,2),%%xmm1              \n"  // 01234567 (16)
+      "movdqu      2(%0,%3,2),%%xmm4             \n"  // 12345678 (16)
+      "movdqa      %%xmm1,%%xmm3                 \n"
+      "punpckhwd   %%xmm4,%%xmm3                 \n"  // 45566778 (16)
+      "punpcklwd   %%xmm4,%%xmm1                 \n"  // 01122334 (16)
+      "movdqa      %%xmm3,%%xmm5                 \n"
+      "movdqa      %%xmm1,%%xmm4                 \n"
+      "pshufb      %%xmm6,%%xmm5                 \n"  // 54657687 (far)
+      "pshufb      %%xmm6,%%xmm4                 \n"  // 10213243 (far)
+      "paddw       %%xmm1,%%xmm4                 \n"  // near+far
+      "paddw       %%xmm3,%%xmm5                 \n"  // near+far
+      "paddw       %%xmm1,%%xmm1                 \n"  // 2*near
+      "paddw       %%xmm3,%%xmm3                 \n"  // 2*near
+      "paddw       %%xmm4,%%xmm1                 \n"  // 3*near+far (2, lo)
+      "paddw       %%xmm5,%%xmm3                 \n"  // 3*near+far (2, hi)
+
+      // xmm0 xmm2
+      // xmm1 xmm3
+
+      "movdqa      %%xmm0,%%xmm4                 \n"
+      "movdqa      %%xmm1,%%xmm5                 \n"
+      "paddw       %%xmm4,%%xmm4                 \n"  // 6*near+2*far (1, lo)
+      "paddw       %%xmm7,%%xmm5                 \n"  // 3*near+far+8 (2, lo)
+      "paddw       %%xmm0,%%xmm4                 \n"  // 9*near+3*far (1, lo)
+      "paddw       %%xmm5,%%xmm4                 \n"  // 9 3 3 1 + 8 (1, lo)
+      "psrlw       $4,%%xmm4                     \n"  // ^ div by 16
+      "movdqu      %%xmm4,(%1)                   \n"
+
+      "movdqa      %%xmm2,%%xmm4                 \n"
+      "movdqa      %%xmm3,%%xmm5                 \n"
+      "paddw       %%xmm4,%%xmm4                 \n"  // 6*near+2*far (1, hi)
+      "paddw       %%xmm7,%%xmm5                 \n"  // 3*near+far+8 (2, hi)
+      "paddw       %%xmm2,%%xmm4                 \n"  // 9*near+3*far (1, hi)
+      "paddw       %%xmm5,%%xmm4                 \n"  // 9 3 3 1 + 8 (1, hi)
+      "psrlw       $4,%%xmm4                     \n"  // ^ div by 16
+      "movdqu      %%xmm4,0x10(%1)               \n"
+
+      "movdqa      %%xmm1,%%xmm4                 \n"
+      "paddw       %%xmm7,%%xmm0                 \n"  // 3*near+far+8 (1, lo)
+      "paddw       %%xmm4,%%xmm4                 \n"  // 6*near+2*far (2, lo)
+      "paddw       %%xmm4,%%xmm1                 \n"  // 9*near+3*far (2, lo)
+      "paddw       %%xmm0,%%xmm1                 \n"  // 9 3 3 1 + 8 (2, lo)
+      "psrlw       $4,%%xmm1                     \n"  // ^ div by 16
+      "movdqu      %%xmm1,(%1,%4,2)              \n"
+
+      "movdqa      %%xmm3,%%xmm4                 \n"
+      "paddw       %%xmm7,%%xmm2                 \n"  // 3*near+far+8 (1, hi)
+      "paddw       %%xmm4,%%xmm4                 \n"  // 6*near+2*far (2, hi)
+      "paddw       %%xmm4,%%xmm3                 \n"  // 9*near+3*far (2, hi)
+      "paddw       %%xmm2,%%xmm3                 \n"  // 9 3 3 1 + 8 (2, hi)
+      "psrlw       $4,%%xmm3                     \n"  // ^ div by 16
+      "movdqu      %%xmm3,0x10(%1,%4,2)          \n"
+
+      "lea         0x10(%0),%0                   \n"
+      "lea         0x20(%1),%1                   \n"  // 8 sample to 16 sample
+      "sub         $0x10,%2                      \n"
+      "jg          1b                            \n"
+      : "+r"(src_ptr),                // %0
+        "+r"(dst_ptr),                // %1
+        "+r"(dst_width)               // %2
+      : "r"((intptr_t)(src_stride)),  // %3
+        "r"((intptr_t)(dst_stride)),  // %4
+        "m"(kLinearShuffleFar)        // %5
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6");
+}
+#endif
+
+#ifdef HAS_SCALEROWUP2LINEAR_16_SSE2
+void ScaleRowUp2_Linear_16_SSE2(const uint16_t* src_ptr,
+                                uint16_t* dst_ptr,
+                                int dst_width) {
+  asm volatile(
+      "pxor        %%xmm5,%%xmm5                 \n"
+      "pcmpeqd     %%xmm4,%%xmm4                 \n"
+      "psrld       $31,%%xmm4                    \n"
+      "pslld       $1,%%xmm4                     \n"  // all 2
+
+      LABELALIGN
+      "1:                                        \n"
+      "movq        (%0),%%xmm0                   \n"  // 0123 (16b)
+      "movq        2(%0),%%xmm1                  \n"  // 1234 (16b)
+
+      "punpcklwd   %%xmm5,%%xmm0                 \n"  // 0123 (32b)
+      "punpcklwd   %%xmm5,%%xmm1                 \n"  // 1234 (32b)
+
+      "movdqa      %%xmm0,%%xmm2                 \n"
+      "movdqa      %%xmm1,%%xmm3                 \n"
+
+      "pshufd      $0b10110001,%%xmm2,%%xmm2     \n"  // 1032 (even, far)
+      "pshufd      $0b10110001,%%xmm3,%%xmm3     \n"  // 2143 (odd, far)
+
+      "paddd       %%xmm4,%%xmm2                 \n"  // far+2 (lo)
+      "paddd       %%xmm4,%%xmm3                 \n"  // far+2 (hi)
+      "paddd       %%xmm0,%%xmm2                 \n"  // near+far+2 (lo)
+      "paddd       %%xmm1,%%xmm3                 \n"  // near+far+2 (hi)
+      "paddd       %%xmm0,%%xmm0                 \n"  // 2*near (lo)
+      "paddd       %%xmm1,%%xmm1                 \n"  // 2*near (hi)
+      "paddd       %%xmm2,%%xmm0                 \n"  // 3*near+far+2 (lo)
+      "paddd       %%xmm3,%%xmm1                 \n"  // 3*near+far+2 (hi)
+
+      "psrld       $2,%%xmm0                     \n"  // 3/4*near+1/4*far (lo)
+      "psrld       $2,%%xmm1                     \n"  // 3/4*near+1/4*far (hi)
+      "packssdw    %%xmm1,%%xmm0                 \n"
+      "pshufd      $0b11011000,%%xmm0,%%xmm0     \n"
+      "movdqu      %%xmm0,(%1)                   \n"
+
+      "lea         0x8(%0),%0                    \n"
+      "lea         0x10(%1),%1                   \n"  // 4 pixel to 8 pixel
+      "sub         $0x8,%2                       \n"
+      "jg          1b                            \n"
+      : "+r"(src_ptr),   // %0
+        "+r"(dst_ptr),   // %1
+        "+r"(dst_width)  // %2
+      :
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5");
+}
+#endif
+
+#ifdef HAS_SCALEROWUP2BILINEAR_16_SSE2
+void ScaleRowUp2_Bilinear_16_SSE2(const uint16_t* src_ptr,
+                                  ptrdiff_t src_stride,
+                                  uint16_t* dst_ptr,
+                                  ptrdiff_t dst_stride,
+                                  int dst_width) {
+  asm volatile(
+      "pxor        %%xmm7,%%xmm7                 \n"
+      "pcmpeqd     %%xmm6,%%xmm6                 \n"
+      "psrld       $31,%%xmm6                    \n"
+      "pslld       $3,%%xmm6                     \n"  // all 8
+
+      LABELALIGN
+      "1:                                        \n"
+      "movq        (%0),%%xmm0                   \n"  // 0011 (16b, 1u1v)
+      "movq        4(%0),%%xmm1                  \n"  // 1122 (16b, 1u1v)
+      "punpcklwd   %%xmm7,%%xmm0                 \n"  // 0011 (near) (32b, 1u1v)
+      "punpcklwd   %%xmm7,%%xmm1                 \n"  // 1122 (near) (32b, 1u1v)
+      "movdqa      %%xmm0,%%xmm2                 \n"
+      "movdqa      %%xmm1,%%xmm3                 \n"
+      "pshufd      $0b01001110,%%xmm2,%%xmm2     \n"  // 1100 (far) (1, lo)
+      "pshufd      $0b01001110,%%xmm3,%%xmm3     \n"  // 2211 (far) (1, hi)
+      "paddd       %%xmm0,%%xmm2                 \n"  // near+far (1, lo)
+      "paddd       %%xmm1,%%xmm3                 \n"  // near+far (1, hi)
+      "paddd       %%xmm0,%%xmm0                 \n"  // 2*near (1, lo)
+      "paddd       %%xmm1,%%xmm1                 \n"  // 2*near (1, hi)
+      "paddd       %%xmm2,%%xmm0                 \n"  // 3*near+far (1, lo)
+      "paddd       %%xmm3,%%xmm1                 \n"  // 3*near+far (1, hi)
+
+      "movq        (%0),%%xmm0                   \n"  // 0123 (16b)
+      "movq        2(%0),%%xmm1                  \n"  // 1234 (16b)
+      "punpcklwd   %%xmm7,%%xmm0                 \n"  // 0123 (32b)
+      "punpcklwd   %%xmm7,%%xmm1                 \n"  // 1234 (32b)
+      "movdqa      %%xmm0,%%xmm2                 \n"
+      "movdqa      %%xmm1,%%xmm3                 \n"
+      "pshufd      $0b10110001,%%xmm2,%%xmm2     \n"  // 1032 (even, far)
+      "pshufd      $0b10110001,%%xmm3,%%xmm3     \n"  // 2143 (odd, far)
+      "paddd       %%xmm0,%%xmm2                 \n"  // near+far (lo)
+      "paddd       %%xmm1,%%xmm3                 \n"  // near+far (hi)
+      "paddd       %%xmm0,%%xmm0                 \n"  // 2*near (lo)
+      "paddd       %%xmm1,%%xmm1                 \n"  // 2*near (hi)
+      "paddd       %%xmm2,%%xmm0                 \n"  // 3*near+far (1, lo)
+      "paddd       %%xmm3,%%xmm1                 \n"  // 3*near+far (1, hi)
+
+      "movq        (%0,%3,2),%%xmm2              \n"
+      "movq        2(%0,%3,2),%%xmm3             \n"
+      "punpcklwd   %%xmm7,%%xmm2                 \n"  // 0123 (32b)
+      "punpcklwd   %%xmm7,%%xmm3                 \n"  // 1234 (32b)
+      "movdqa      %%xmm2,%%xmm4                 \n"
+      "movdqa      %%xmm3,%%xmm5                 \n"
+      "pshufd      $0b10110001,%%xmm4,%%xmm4     \n"  // 1032 (even, far)
+      "pshufd      $0b10110001,%%xmm5,%%xmm5     \n"  // 2143 (odd, far)
+      "paddd       %%xmm2,%%xmm4                 \n"  // near+far (lo)
+      "paddd       %%xmm3,%%xmm5                 \n"  // near+far (hi)
+      "paddd       %%xmm2,%%xmm2                 \n"  // 2*near (lo)
+      "paddd       %%xmm3,%%xmm3                 \n"  // 2*near (hi)
+      "paddd       %%xmm4,%%xmm2                 \n"  // 3*near+far (2, lo)
+      "paddd       %%xmm5,%%xmm3                 \n"  // 3*near+far (2, hi)
+
+      "movdqa      %%xmm0,%%xmm4                 \n"
+      "movdqa      %%xmm2,%%xmm5                 \n"
+      "paddd       %%xmm0,%%xmm4                 \n"  // 6*near+2*far (1, lo)
+      "paddd       %%xmm6,%%xmm5                 \n"  // 3*near+far+8 (2, lo)
+      "paddd       %%xmm0,%%xmm4                 \n"  // 9*near+3*far (1, lo)
+      "paddd       %%xmm5,%%xmm4                 \n"  // 9 3 3 1 + 8 (1, lo)
+      "psrld       $4,%%xmm4                     \n"  // ^ div by 16 (1, lo)
+
+      "movdqa      %%xmm2,%%xmm5                 \n"
+      "paddd       %%xmm2,%%xmm5                 \n"  // 6*near+2*far (2, lo)
+      "paddd       %%xmm6,%%xmm0                 \n"  // 3*near+far+8 (1, lo)
+      "paddd       %%xmm2,%%xmm5                 \n"  // 9*near+3*far (2, lo)
+      "paddd       %%xmm0,%%xmm5                 \n"  // 9 3 3 1 + 8 (2, lo)
+      "psrld       $4,%%xmm5                     \n"  // ^ div by 16 (2, lo)
+
+      "movdqa      %%xmm1,%%xmm0                 \n"
+      "movdqa      %%xmm3,%%xmm2                 \n"
+      "paddd       %%xmm1,%%xmm0                 \n"  // 6*near+2*far (1, hi)
+      "paddd       %%xmm6,%%xmm2                 \n"  // 3*near+far+8 (2, hi)
+      "paddd       %%xmm1,%%xmm0                 \n"  // 9*near+3*far (1, hi)
+      "paddd       %%xmm2,%%xmm0                 \n"  // 9 3 3 1 + 8 (1, hi)
+      "psrld       $4,%%xmm0                     \n"  // ^ div by 16 (1, hi)
+
+      "movdqa      %%xmm3,%%xmm2                 \n"
+      "paddd       %%xmm3,%%xmm2                 \n"  // 6*near+2*far (2, hi)
+      "paddd       %%xmm6,%%xmm1                 \n"  // 3*near+far+8 (1, hi)
+      "paddd       %%xmm3,%%xmm2                 \n"  // 9*near+3*far (2, hi)
+      "paddd       %%xmm1,%%xmm2                 \n"  // 9 3 3 1 + 8 (2, hi)
+      "psrld       $4,%%xmm2                     \n"  // ^ div by 16 (2, hi)
+
+      "packssdw    %%xmm0,%%xmm4                 \n"
+      "pshufd      $0b11011000,%%xmm4,%%xmm4     \n"
+      "movdqu      %%xmm4,(%1)                   \n"  // store above
+      "packssdw    %%xmm2,%%xmm5                 \n"
+      "pshufd      $0b11011000,%%xmm4,%%xmm4     \n"
+      "movdqu      %%xmm5,(%1,%4,2)              \n"  // store below
+
+      "lea         0x8(%0),%0                    \n"
+      "lea         0x10(%1),%1                   \n"  // 4 pixel to 8 pixel
+      "sub         $0x8,%2                       \n"
+      "jg          1b                            \n"
+      : "+r"(src_ptr),                // %0
+        "+r"(dst_ptr),                // %1
+        "+r"(dst_width)               // %2
+      : "r"((intptr_t)(src_stride)),  // %3
+        "r"((intptr_t)(dst_stride))   // %4
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6");
+}
+#endif
+
+#ifdef HAS_SCALEROWUP2LINEAR_SSSE3
+void ScaleRowUp2_Linear_SSSE3(const uint8_t* src_ptr,
+                              uint8_t* dst_ptr,
+                              int dst_width) {
+  asm volatile(
+      "pcmpeqw     %%xmm4,%%xmm4                 \n"
+      "psrlw       $15,%%xmm4                    \n"
+      "psllw       $1,%%xmm4                     \n"  // all 2
+      "movdqa      %3,%%xmm3                     \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "movq        (%0),%%xmm0                   \n"  // 01234567
+      "movq        1(%0),%%xmm1                  \n"  // 12345678
+      "punpcklwd   %%xmm0,%%xmm0                 \n"  // 0101232345456767
+      "punpcklwd   %%xmm1,%%xmm1                 \n"  // 1212343456567878
+      "movdqa      %%xmm0,%%xmm2                 \n"
+      "punpckhdq   %%xmm1,%%xmm2                 \n"  // 4545565667677878
+      "punpckldq   %%xmm1,%%xmm0                 \n"  // 0101121223233434
+      "pmaddubsw   %%xmm3,%%xmm2                 \n"  // 3*near+far (hi)
+      "pmaddubsw   %%xmm3,%%xmm0                 \n"  // 3*near+far (lo)
+      "paddw       %%xmm4,%%xmm0                 \n"  // 3*near+far+2 (lo)
+      "paddw       %%xmm4,%%xmm2                 \n"  // 3*near+far+2 (hi)
+      "psrlw       $2,%%xmm0                     \n"  // 3/4*near+1/4*far (lo)
+      "psrlw       $2,%%xmm2                     \n"  // 3/4*near+1/4*far (hi)
+      "packuswb    %%xmm2,%%xmm0                 \n"
+      "movdqu      %%xmm0,(%1)                   \n"
+      "lea         0x8(%0),%0                    \n"
+      "lea         0x10(%1),%1                   \n"  // 8 sample to 16 sample
+      "sub         $0x10,%2                      \n"
+      "jg          1b                            \n"
+      : "+r"(src_ptr),      // %0
+        "+r"(dst_ptr),      // %1
+        "+r"(dst_width)     // %2
+      : "m"(kLinearMadd31)  // %3
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6");
+}
+#endif
+
+#ifdef HAS_SCALEROWUP2BILINEAR_SSSE3
+void ScaleRowUp2_Bilinear_SSSE3(const uint8_t* src_ptr,
+                                ptrdiff_t src_stride,
+                                uint8_t* dst_ptr,
+                                ptrdiff_t dst_stride,
+                                int dst_width) {
+  asm volatile(
+      "pcmpeqw     %%xmm6,%%xmm6                 \n"
+      "psrlw       $15,%%xmm6                    \n"
+      "psllw       $3,%%xmm6                     \n"  // all 8
+      "movdqa      %5,%%xmm7                     \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "movq        (%0),%%xmm0                   \n"  // 01234567
+      "movq        1(%0),%%xmm1                  \n"  // 12345678
+      "punpcklwd   %%xmm0,%%xmm0                 \n"  // 0101232345456767
+      "punpcklwd   %%xmm1,%%xmm1                 \n"  // 1212343456567878
+      "movdqa      %%xmm0,%%xmm2                 \n"
+      "punpckhdq   %%xmm1,%%xmm2                 \n"  // 4545565667677878
+      "punpckldq   %%xmm1,%%xmm0                 \n"  // 0101121223233434
+      "pmaddubsw   %%xmm7,%%xmm2                 \n"  // 3*near+far (1, hi)
+      "pmaddubsw   %%xmm7,%%xmm0                 \n"  // 3*near+far (1, lo)
+
+      "movq        (%0,%3),%%xmm1                \n"
+      "movq        1(%0,%3),%%xmm4               \n"
+      "punpcklwd   %%xmm1,%%xmm1                 \n"
+      "punpcklwd   %%xmm4,%%xmm4                 \n"
+      "movdqa      %%xmm1,%%xmm3                 \n"
+      "punpckhdq   %%xmm4,%%xmm3                 \n"
+      "punpckldq   %%xmm4,%%xmm1                 \n"
+      "pmaddubsw   %%xmm7,%%xmm3                 \n"  // 3*near+far (2, hi)
+      "pmaddubsw   %%xmm7,%%xmm1                 \n"  // 3*near+far (2, lo)
+
+      // xmm0 xmm2
+      // xmm1 xmm3
+
+      "movdqa      %%xmm0,%%xmm4                 \n"
+      "movdqa      %%xmm1,%%xmm5                 \n"
+      "paddw       %%xmm0,%%xmm4                 \n"  // 6*near+2*far (1, lo)
+      "paddw       %%xmm6,%%xmm5                 \n"  // 3*near+far+8 (2, lo)
+      "paddw       %%xmm0,%%xmm4                 \n"  // 9*near+3*far (1, lo)
+      "paddw       %%xmm5,%%xmm4                 \n"  // 9 3 3 1 + 8 (1, lo)
+      "psrlw       $4,%%xmm4                     \n"  // ^ div by 16 (1, lo)
+
+      "movdqa      %%xmm1,%%xmm5                 \n"
+      "paddw       %%xmm1,%%xmm5                 \n"  // 6*near+2*far (2, lo)
+      "paddw       %%xmm6,%%xmm0                 \n"  // 3*near+far+8 (1, lo)
+      "paddw       %%xmm1,%%xmm5                 \n"  // 9*near+3*far (2, lo)
+      "paddw       %%xmm0,%%xmm5                 \n"  // 9 3 3 1 + 8 (2, lo)
+      "psrlw       $4,%%xmm5                     \n"  // ^ div by 16 (2, lo)
+
+      "movdqa      %%xmm2,%%xmm0                 \n"
+      "movdqa      %%xmm3,%%xmm1                 \n"
+      "paddw       %%xmm2,%%xmm0                 \n"  // 6*near+2*far (1, hi)
+      "paddw       %%xmm6,%%xmm1                 \n"  // 3*near+far+8 (2, hi)
+      "paddw       %%xmm2,%%xmm0                 \n"  // 9*near+3*far (1, hi)
+      "paddw       %%xmm1,%%xmm0                 \n"  // 9 3 3 1 + 8 (1, hi)
+      "psrlw       $4,%%xmm0                     \n"  // ^ div by 16 (1, hi)
+
+      "movdqa      %%xmm3,%%xmm1                 \n"
+      "paddw       %%xmm3,%%xmm1                 \n"  // 6*near+2*far (2, hi)
+      "paddw       %%xmm6,%%xmm2                 \n"  // 3*near+far+8 (1, hi)
+      "paddw       %%xmm3,%%xmm1                 \n"  // 9*near+3*far (2, hi)
+      "paddw       %%xmm2,%%xmm1                 \n"  // 9 3 3 1 + 8 (2, hi)
+      "psrlw       $4,%%xmm1                     \n"  // ^ div by 16 (2, hi)
+
+      "packuswb    %%xmm0,%%xmm4                 \n"
+      "movdqu      %%xmm4,(%1)                   \n"  // store above
+      "packuswb    %%xmm1,%%xmm5                 \n"
+      "movdqu      %%xmm5,(%1,%4)                \n"  // store below
+
+      "lea         0x8(%0),%0                    \n"
+      "lea         0x10(%1),%1                   \n"  // 8 sample to 16 sample
+      "sub         $0x10,%2                      \n"
+      "jg          1b                            \n"
+      : "+r"(src_ptr),                // %0
+        "+r"(dst_ptr),                // %1
+        "+r"(dst_width)               // %2
+      : "r"((intptr_t)(src_stride)),  // %3
+        "r"((intptr_t)(dst_stride)),  // %4
+        "m"(kLinearMadd31)            // %5
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6",
+        "xmm7");
+}
+#endif
+
+#ifdef HAS_SCALEROWUP2LINEAR_AVX2
+void ScaleRowUp2_Linear_AVX2(const uint8_t* src_ptr,
+                             uint8_t* dst_ptr,
+                             int dst_width) {
+  asm volatile(
+      "vpcmpeqw    %%ymm4,%%ymm4,%%ymm4          \n"
+      "vpsrlw      $15,%%ymm4,%%ymm4             \n"
+      "vpsllw      $1,%%ymm4,%%ymm4              \n"  // all 2
+      "vbroadcastf128 %3,%%ymm3                  \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "vmovdqu     (%0),%%xmm0                   \n"  // 0123456789ABCDEF
+      "vmovdqu     1(%0),%%xmm1                  \n"  // 123456789ABCDEF0
+      "vpermq      $0b11011000,%%ymm0,%%ymm0     \n"
+      "vpermq      $0b11011000,%%ymm1,%%ymm1     \n"
+      "vpunpcklwd  %%ymm0,%%ymm0,%%ymm0          \n"
+      "vpunpcklwd  %%ymm1,%%ymm1,%%ymm1          \n"
+      "vpunpckhdq  %%ymm1,%%ymm0,%%ymm2          \n"
+      "vpunpckldq  %%ymm1,%%ymm0,%%ymm0          \n"
+      "vpmaddubsw  %%ymm3,%%ymm2,%%ymm1          \n"  // 3*near+far (hi)
+      "vpmaddubsw  %%ymm3,%%ymm0,%%ymm0          \n"  // 3*near+far (lo)
+      "vpaddw      %%ymm4,%%ymm0,%%ymm0          \n"  // 3*near+far+2 (lo)
+      "vpaddw      %%ymm4,%%ymm1,%%ymm1          \n"  // 3*near+far+2 (hi)
+      "vpsrlw      $2,%%ymm0,%%ymm0              \n"  // 3/4*near+1/4*far (lo)
+      "vpsrlw      $2,%%ymm1,%%ymm1              \n"  // 3/4*near+1/4*far (hi)
+      "vpackuswb   %%ymm1,%%ymm0,%%ymm0          \n"
+      "vmovdqu     %%ymm0,(%1)                   \n"
+
+      "lea         0x10(%0),%0                   \n"
+      "lea         0x20(%1),%1                   \n"  // 16 sample to 32 sample
+      "sub         $0x20,%2                      \n"
+      "jg          1b                            \n"
+      "vzeroupper                                \n"
+      : "+r"(src_ptr),      // %0
+        "+r"(dst_ptr),      // %1
+        "+r"(dst_width)     // %2
+      : "m"(kLinearMadd31)  // %3
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4");
+}
+#endif
+
+#ifdef HAS_SCALEROWUP2BILINEAR_AVX2
+void ScaleRowUp2_Bilinear_AVX2(const uint8_t* src_ptr,
+                               ptrdiff_t src_stride,
+                               uint8_t* dst_ptr,
+                               ptrdiff_t dst_stride,
+                               int dst_width) {
+  asm volatile(
+      "vpcmpeqw    %%ymm6,%%ymm6,%%ymm6          \n"
+      "vpsrlw      $15,%%ymm6,%%ymm6             \n"
+      "vpsllw      $3,%%ymm6,%%ymm6              \n"  // all 8
+      "vbroadcastf128 %5,%%ymm7                  \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "vmovdqu     (%0),%%xmm0                   \n"  // 0123456789ABCDEF
+      "vmovdqu     1(%0),%%xmm1                  \n"  // 123456789ABCDEF0
+      "vpermq      $0b11011000,%%ymm0,%%ymm0     \n"
+      "vpermq      $0b11011000,%%ymm1,%%ymm1     \n"
+      "vpunpcklwd  %%ymm0,%%ymm0,%%ymm0          \n"
+      "vpunpcklwd  %%ymm1,%%ymm1,%%ymm1          \n"
+      "vpunpckhdq  %%ymm1,%%ymm0,%%ymm2          \n"
+      "vpunpckldq  %%ymm1,%%ymm0,%%ymm0          \n"
+      "vpmaddubsw  %%ymm7,%%ymm2,%%ymm1          \n"  // 3*near+far (1, hi)
+      "vpmaddubsw  %%ymm7,%%ymm0,%%ymm0          \n"  // 3*near+far (1, lo)
+
+      "vmovdqu     (%0,%3),%%xmm2                \n"  // 0123456789ABCDEF
+      "vmovdqu     1(%0,%3),%%xmm3               \n"  // 123456789ABCDEF0
+      "vpermq      $0b11011000,%%ymm2,%%ymm2     \n"
+      "vpermq      $0b11011000,%%ymm3,%%ymm3     \n"
+      "vpunpcklwd  %%ymm2,%%ymm2,%%ymm2          \n"
+      "vpunpcklwd  %%ymm3,%%ymm3,%%ymm3          \n"
+      "vpunpckhdq  %%ymm3,%%ymm2,%%ymm4          \n"
+      "vpunpckldq  %%ymm3,%%ymm2,%%ymm2          \n"
+      "vpmaddubsw  %%ymm7,%%ymm4,%%ymm3          \n"  // 3*near+far (2, hi)
+      "vpmaddubsw  %%ymm7,%%ymm2,%%ymm2          \n"  // 3*near+far (2, lo)
+
+      // ymm0 ymm1
+      // ymm2 ymm3
+
+      "vpaddw      %%ymm0,%%ymm0,%%ymm4          \n"  // 6*near+2*far (1, lo)
+      "vpaddw      %%ymm6,%%ymm2,%%ymm5          \n"  // 3*near+far+8 (2, lo)
+      "vpaddw      %%ymm4,%%ymm0,%%ymm4          \n"  // 9*near+3*far (1, lo)
+      "vpaddw      %%ymm4,%%ymm5,%%ymm4          \n"  // 9 3 3 1 + 8 (1, lo)
+      "vpsrlw      $4,%%ymm4,%%ymm4              \n"  // ^ div by 16 (1, lo)
+
+      "vpaddw      %%ymm2,%%ymm2,%%ymm5          \n"  // 6*near+2*far (2, lo)
+      "vpaddw      %%ymm6,%%ymm0,%%ymm0          \n"  // 3*near+far+8 (1, lo)
+      "vpaddw      %%ymm5,%%ymm2,%%ymm5          \n"  // 9*near+3*far (2, lo)
+      "vpaddw      %%ymm5,%%ymm0,%%ymm5          \n"  // 9 3 3 1 + 8 (2, lo)
+      "vpsrlw      $4,%%ymm5,%%ymm5              \n"  // ^ div by 16 (2, lo)
+
+      "vpaddw      %%ymm1,%%ymm1,%%ymm0          \n"  // 6*near+2*far (1, hi)
+      "vpaddw      %%ymm6,%%ymm3,%%ymm2          \n"  // 3*near+far+8 (2, hi)
+      "vpaddw      %%ymm0,%%ymm1,%%ymm0          \n"  // 9*near+3*far (1, hi)
+      "vpaddw      %%ymm0,%%ymm2,%%ymm0          \n"  // 9 3 3 1 + 8 (1, hi)
+      "vpsrlw      $4,%%ymm0,%%ymm0              \n"  // ^ div by 16 (1, hi)
+
+      "vpaddw      %%ymm3,%%ymm3,%%ymm2          \n"  // 6*near+2*far (2, hi)
+      "vpaddw      %%ymm6,%%ymm1,%%ymm1          \n"  // 3*near+far+8 (1, hi)
+      "vpaddw      %%ymm2,%%ymm3,%%ymm2          \n"  // 9*near+3*far (2, hi)
+      "vpaddw      %%ymm2,%%ymm1,%%ymm2          \n"  // 9 3 3 1 + 8 (2, hi)
+      "vpsrlw      $4,%%ymm2,%%ymm2              \n"  // ^ div by 16 (2, hi)
+
+      "vpackuswb   %%ymm0,%%ymm4,%%ymm4          \n"
+      "vmovdqu     %%ymm4,(%1)                   \n"  // store above
+      "vpackuswb   %%ymm2,%%ymm5,%%ymm5          \n"
+      "vmovdqu     %%ymm5,(%1,%4)                \n"  // store below
+
+      "lea         0x10(%0),%0                   \n"
+      "lea         0x20(%1),%1                   \n"  // 16 sample to 32 sample
+      "sub         $0x20,%2                      \n"
+      "jg          1b                            \n"
+      "vzeroupper                                \n"
+      : "+r"(src_ptr),                // %0
+        "+r"(dst_ptr),                // %1
+        "+r"(dst_width)               // %2
+      : "r"((intptr_t)(src_stride)),  // %3
+        "r"((intptr_t)(dst_stride)),  // %4
+        "m"(kLinearMadd31)            // %5
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6",
+        "xmm7");
+}
+#endif
+
+#ifdef HAS_SCALEROWUP2LINEAR_12_AVX2
+void ScaleRowUp2_Linear_12_AVX2(const uint16_t* src_ptr,
+                                uint16_t* dst_ptr,
+                                int dst_width) {
+  asm volatile(
+      "vbroadcastf128 %3,%%ymm5                  \n"
+      "vpcmpeqw    %%ymm4,%%ymm4,%%ymm4          \n"
+      "vpsrlw      $15,%%ymm4,%%ymm4             \n"
+      "vpsllw      $1,%%ymm4,%%ymm4              \n"  // all 2
+
+      LABELALIGN
+      "1:                                        \n"
+      "vmovdqu     (%0),%%ymm0                   \n"  // 0123456789ABCDEF (16b)
+      "vmovdqu     2(%0),%%ymm1                  \n"  // 123456789ABCDEF0 (16b)
+
+      "vpermq      $0b11011000,%%ymm0,%%ymm0     \n"  // 012389AB4567CDEF
+      "vpermq      $0b11011000,%%ymm1,%%ymm1     \n"  // 12349ABC5678DEF0
+
+      "vpunpckhwd  %%ymm1,%%ymm0,%%ymm2          \n"  // 899AABBCCDDEEFF0 (near)
+      "vpunpcklwd  %%ymm1,%%ymm0,%%ymm0          \n"  // 0112233445566778 (near)
+      "vpshufb     %%ymm5,%%ymm2,%%ymm3          \n"  // 98A9BACBDCEDFE0F (far)
+      "vpshufb     %%ymm5,%%ymm0,%%ymm1          \n"  // 1021324354657687 (far)
+
+      "vpaddw      %%ymm4,%%ymm1,%%ymm1          \n"  // far+2
+      "vpaddw      %%ymm4,%%ymm3,%%ymm3          \n"  // far+2
+      "vpaddw      %%ymm0,%%ymm1,%%ymm1          \n"  // near+far+2
+      "vpaddw      %%ymm2,%%ymm3,%%ymm3          \n"  // near+far+2
+      "vpaddw      %%ymm0,%%ymm0,%%ymm0          \n"  // 2*near
+      "vpaddw      %%ymm2,%%ymm2,%%ymm2          \n"  // 2*near
+      "vpaddw      %%ymm0,%%ymm1,%%ymm0          \n"  // 3*near+far+2
+      "vpaddw      %%ymm2,%%ymm3,%%ymm2          \n"  // 3*near+far+2
+
+      "vpsrlw      $2,%%ymm0,%%ymm0              \n"  // 3/4*near+1/4*far
+      "vpsrlw      $2,%%ymm2,%%ymm2              \n"  // 3/4*near+1/4*far
+      "vmovdqu     %%ymm0,(%1)                   \n"
+      "vmovdqu     %%ymm2,32(%1)                 \n"
+
+      "lea         0x20(%0),%0                   \n"
+      "lea         0x40(%1),%1                   \n"  // 16 sample to 32 sample
+      "sub         $0x20,%2                      \n"
+      "jg          1b                            \n"
+      "vzeroupper                                \n"
+      : "+r"(src_ptr),          // %0
+        "+r"(dst_ptr),          // %1
+        "+r"(dst_width)         // %2
+      : "m"(kLinearShuffleFar)  // %3
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5");
+}
+#endif
+
+#ifdef HAS_SCALEROWUP2BILINEAR_12_AVX2
+void ScaleRowUp2_Bilinear_12_AVX2(const uint16_t* src_ptr,
+                                  ptrdiff_t src_stride,
+                                  uint16_t* dst_ptr,
+                                  ptrdiff_t dst_stride,
+                                  int dst_width) {
+  asm volatile(
+      "vbroadcastf128 %5,%%ymm5                  \n"
+      "vpcmpeqw    %%ymm4,%%ymm4,%%ymm4          \n"
+      "vpsrlw      $15,%%ymm4,%%ymm4             \n"
+      "vpsllw      $3,%%ymm4,%%ymm4              \n"  // all 8
+
+      LABELALIGN
+      "1:                                        \n"
+
+      "vmovdqu     (%0),%%xmm0                   \n"  // 01234567 (16b)
+      "vmovdqu     2(%0),%%xmm1                  \n"  // 12345678 (16b)
+      "vpermq      $0b11011000,%%ymm0,%%ymm0     \n"  // 0123000045670000
+      "vpermq      $0b11011000,%%ymm1,%%ymm1     \n"  // 1234000056780000
+      "vpunpcklwd  %%ymm1,%%ymm0,%%ymm0          \n"  // 0112233445566778 (near)
+      "vpshufb     %%ymm5,%%ymm0,%%ymm1          \n"  // 1021324354657687 (far)
+      "vpaddw      %%ymm0,%%ymm1,%%ymm1          \n"  // near+far
+      "vpaddw      %%ymm0,%%ymm0,%%ymm0          \n"  // 2*near
+      "vpaddw      %%ymm0,%%ymm1,%%ymm2          \n"  // 3*near+far (1)
+
+      "vmovdqu     (%0,%3,2),%%xmm0              \n"  // 01234567 (16b)
+      "vmovdqu     2(%0,%3,2),%%xmm1             \n"  // 12345678 (16b)
+      "vpermq      $0b11011000,%%ymm0,%%ymm0     \n"  // 0123000045670000
+      "vpermq      $0b11011000,%%ymm1,%%ymm1     \n"  // 1234000056780000
+      "vpunpcklwd  %%ymm1,%%ymm0,%%ymm0          \n"  // 0112233445566778 (near)
+      "vpshufb     %%ymm5,%%ymm0,%%ymm1          \n"  // 1021324354657687 (far)
+      "vpaddw      %%ymm0,%%ymm1,%%ymm1          \n"  // near+far
+      "vpaddw      %%ymm0,%%ymm0,%%ymm0          \n"  // 2*near
+      "vpaddw      %%ymm0,%%ymm1,%%ymm3          \n"  // 3*near+far (2)
+
+      "vpaddw      %%ymm2,%%ymm2,%%ymm0          \n"  // 6*near+2*far (1)
+      "vpaddw      %%ymm4,%%ymm3,%%ymm1          \n"  // 3*near+far+8 (2)
+      "vpaddw      %%ymm0,%%ymm2,%%ymm0          \n"  // 9*near+3*far (1)
+      "vpaddw      %%ymm0,%%ymm1,%%ymm0          \n"  // 9 3 3 1 + 8 (1)
+      "vpsrlw      $4,%%ymm0,%%ymm0              \n"  // ^ div by 16
+      "vmovdqu     %%ymm0,(%1)                   \n"  // store above
+
+      "vpaddw      %%ymm3,%%ymm3,%%ymm0          \n"  // 6*near+2*far (2)
+      "vpaddw      %%ymm4,%%ymm2,%%ymm1          \n"  // 3*near+far+8 (1)
+      "vpaddw      %%ymm0,%%ymm3,%%ymm0          \n"  // 9*near+3*far (2)
+      "vpaddw      %%ymm0,%%ymm1,%%ymm0          \n"  // 9 3 3 1 + 8 (2)
+      "vpsrlw      $4,%%ymm0,%%ymm0              \n"  // ^ div by 16
+      "vmovdqu     %%ymm0,(%1,%4,2)              \n"  // store below
+
+      "lea         0x10(%0),%0                   \n"
+      "lea         0x20(%1),%1                   \n"  // 8 sample to 16 sample
+      "sub         $0x10,%2                      \n"
+      "jg          1b                            \n"
+      "vzeroupper                                \n"
+      : "+r"(src_ptr),                // %0
+        "+r"(dst_ptr),                // %1
+        "+r"(dst_width)               // %2
+      : "r"((intptr_t)(src_stride)),  // %3
+        "r"((intptr_t)(dst_stride)),  // %4
+        "m"(kLinearShuffleFar)        // %5
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5");
+}
+#endif
+
+#ifdef HAS_SCALEROWUP2LINEAR_16_AVX2
+void ScaleRowUp2_Linear_16_AVX2(const uint16_t* src_ptr,
+                                uint16_t* dst_ptr,
+                                int dst_width) {
+  asm volatile(
+      "vpcmpeqd    %%ymm4,%%ymm4,%%ymm4          \n"
+      "vpsrld      $31,%%ymm4,%%ymm4             \n"
+      "vpslld      $1,%%ymm4,%%ymm4              \n"  // all 2
+
+      LABELALIGN
+      "1:                                        \n"
+      "vmovdqu     (%0),%%xmm0                   \n"  // 01234567 (16b, 1u1v)
+      "vmovdqu     2(%0),%%xmm1                  \n"  // 12345678 (16b, 1u1v)
+
+      "vpmovzxwd   %%xmm0,%%ymm0                 \n"  // 01234567 (32b, 1u1v)
+      "vpmovzxwd   %%xmm1,%%ymm1                 \n"  // 12345678 (32b, 1u1v)
+
+      "vpshufd     $0b10110001,%%ymm0,%%ymm2     \n"  // 10325476 (lo, far)
+      "vpshufd     $0b10110001,%%ymm1,%%ymm3     \n"  // 21436587 (hi, far)
+
+      "vpaddd      %%ymm4,%%ymm2,%%ymm2          \n"  // far+2 (lo)
+      "vpaddd      %%ymm4,%%ymm3,%%ymm3          \n"  // far+2 (hi)
+      "vpaddd      %%ymm0,%%ymm2,%%ymm2          \n"  // near+far+2 (lo)
+      "vpaddd      %%ymm1,%%ymm3,%%ymm3          \n"  // near+far+2 (hi)
+      "vpaddd      %%ymm0,%%ymm0,%%ymm0          \n"  // 2*near (lo)
+      "vpaddd      %%ymm1,%%ymm1,%%ymm1          \n"  // 2*near (hi)
+      "vpaddd      %%ymm0,%%ymm2,%%ymm0          \n"  // 3*near+far+2 (lo)
+      "vpaddd      %%ymm1,%%ymm3,%%ymm1          \n"  // 3*near+far+2 (hi)
+
+      "vpsrld      $2,%%ymm0,%%ymm0              \n"  // 3/4*near+1/4*far (lo)
+      "vpsrld      $2,%%ymm1,%%ymm1              \n"  // 3/4*near+1/4*far (hi)
+      "vpackusdw   %%ymm1,%%ymm0,%%ymm0          \n"
+      "vpshufd     $0b11011000,%%ymm0,%%ymm0     \n"
+      "vmovdqu     %%ymm0,(%1)                   \n"
+
+      "lea         0x10(%0),%0                   \n"
+      "lea         0x20(%1),%1                   \n"  // 8 pixel to 16 pixel
+      "sub         $0x10,%2                      \n"
+      "jg          1b                            \n"
+      "vzeroupper                                \n"
+      : "+r"(src_ptr),   // %0
+        "+r"(dst_ptr),   // %1
+        "+r"(dst_width)  // %2
+      :
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4");
+}
+#endif
+
+#ifdef HAS_SCALEROWUP2BILINEAR_16_AVX2
+void ScaleRowUp2_Bilinear_16_AVX2(const uint16_t* src_ptr,
+                                  ptrdiff_t src_stride,
+                                  uint16_t* dst_ptr,
+                                  ptrdiff_t dst_stride,
+                                  int dst_width) {
+  asm volatile(
+      "vpcmpeqd    %%ymm6,%%ymm6,%%ymm6          \n"
+      "vpsrld      $31,%%ymm6,%%ymm6             \n"
+      "vpslld      $3,%%ymm6,%%ymm6              \n"  // all 8
+
+      LABELALIGN
+      "1:                                        \n"
+
+      "vmovdqu     (%0),%%xmm0                   \n"  // 01234567 (16b, 1u1v)
+      "vmovdqu     2(%0),%%xmm1                  \n"  // 12345678 (16b, 1u1v)
+      "vpmovzxwd   %%xmm0,%%ymm0                 \n"  // 01234567 (32b, 1u1v)
+      "vpmovzxwd   %%xmm1,%%ymm1                 \n"  // 12345678 (32b, 1u1v)
+      "vpshufd     $0b10110001,%%ymm0,%%ymm2     \n"  // 10325476 (lo, far)
+      "vpshufd     $0b10110001,%%ymm1,%%ymm3     \n"  // 21436587 (hi, far)
+      "vpaddd      %%ymm0,%%ymm2,%%ymm2          \n"  // near+far (lo)
+      "vpaddd      %%ymm1,%%ymm3,%%ymm3          \n"  // near+far (hi)
+      "vpaddd      %%ymm0,%%ymm0,%%ymm0          \n"  // 2*near (lo)
+      "vpaddd      %%ymm1,%%ymm1,%%ymm1          \n"  // 2*near (hi)
+      "vpaddd      %%ymm0,%%ymm2,%%ymm0          \n"  // 3*near+far (1, lo)
+      "vpaddd      %%ymm1,%%ymm3,%%ymm1          \n"  // 3*near+far (1, hi)
+
+      "vmovdqu     (%0,%3,2),%%xmm2              \n"  // 01234567 (16b, 1u1v)
+      "vmovdqu     2(%0,%3,2),%%xmm3             \n"  // 12345678 (16b, 1u1v)
+      "vpmovzxwd   %%xmm2,%%ymm2                 \n"  // 01234567 (32b, 1u1v)
+      "vpmovzxwd   %%xmm3,%%ymm3                 \n"  // 12345678 (32b, 1u1v)
+      "vpshufd     $0b10110001,%%ymm2,%%ymm4     \n"  // 10325476 (lo, far)
+      "vpshufd     $0b10110001,%%ymm3,%%ymm5     \n"  // 21436587 (hi, far)
+      "vpaddd      %%ymm2,%%ymm4,%%ymm4          \n"  // near+far (lo)
+      "vpaddd      %%ymm3,%%ymm5,%%ymm5          \n"  // near+far (hi)
+      "vpaddd      %%ymm2,%%ymm2,%%ymm2          \n"  // 2*near (lo)
+      "vpaddd      %%ymm3,%%ymm3,%%ymm3          \n"  // 2*near (hi)
+      "vpaddd      %%ymm2,%%ymm4,%%ymm2          \n"  // 3*near+far (2, lo)
+      "vpaddd      %%ymm3,%%ymm5,%%ymm3          \n"  // 3*near+far (2, hi)
+
+      "vpaddd      %%ymm0,%%ymm0,%%ymm4          \n"  // 6*near+2*far (1, lo)
+      "vpaddd      %%ymm6,%%ymm2,%%ymm5          \n"  // 3*near+far+8 (2, lo)
+      "vpaddd      %%ymm4,%%ymm0,%%ymm4          \n"  // 9*near+3*far (1, lo)
+      "vpaddd      %%ymm4,%%ymm5,%%ymm4          \n"  // 9 3 3 1 + 8 (1, lo)
+      "vpsrld      $4,%%ymm4,%%ymm4              \n"  // ^ div by 16 (1, lo)
+
+      "vpaddd      %%ymm2,%%ymm2,%%ymm5          \n"  // 6*near+2*far (2, lo)
+      "vpaddd      %%ymm6,%%ymm0,%%ymm0          \n"  // 3*near+far+8 (1, lo)
+      "vpaddd      %%ymm5,%%ymm2,%%ymm5          \n"  // 9*near+3*far (2, lo)
+      "vpaddd      %%ymm5,%%ymm0,%%ymm5          \n"  // 9 3 3 1 + 8 (2, lo)
+      "vpsrld      $4,%%ymm5,%%ymm5              \n"  // ^ div by 16 (2, lo)
+
+      "vpaddd      %%ymm1,%%ymm1,%%ymm0          \n"  // 6*near+2*far (1, hi)
+      "vpaddd      %%ymm6,%%ymm3,%%ymm2          \n"  // 3*near+far+8 (2, hi)
+      "vpaddd      %%ymm0,%%ymm1,%%ymm0          \n"  // 9*near+3*far (1, hi)
+      "vpaddd      %%ymm0,%%ymm2,%%ymm0          \n"  // 9 3 3 1 + 8 (1, hi)
+      "vpsrld      $4,%%ymm0,%%ymm0              \n"  // ^ div by 16 (1, hi)
+
+      "vpaddd      %%ymm3,%%ymm3,%%ymm2          \n"  // 6*near+2*far (2, hi)
+      "vpaddd      %%ymm6,%%ymm1,%%ymm1          \n"  // 3*near+far+8 (1, hi)
+      "vpaddd      %%ymm2,%%ymm3,%%ymm2          \n"  // 9*near+3*far (2, hi)
+      "vpaddd      %%ymm2,%%ymm1,%%ymm2          \n"  // 9 3 3 1 + 8 (2, hi)
+      "vpsrld      $4,%%ymm2,%%ymm2              \n"  // ^ div by 16 (2, hi)
+
+      "vpackusdw   %%ymm0,%%ymm4,%%ymm4          \n"
+      "vpshufd     $0b11011000,%%ymm4,%%ymm4     \n"
+      "vmovdqu     %%ymm4,(%1)                   \n"  // store above
+      "vpackusdw   %%ymm2,%%ymm5,%%ymm5          \n"
+      "vpshufd     $0b11011000,%%ymm5,%%ymm5     \n"
+      "vmovdqu     %%ymm5,(%1,%4,2)              \n"  // store below
+
+      "lea         0x10(%0),%0                   \n"
+      "lea         0x20(%1),%1                   \n"  // 8 pixel to 16 pixel
+      "sub         $0x10,%2                      \n"
+      "jg          1b                            \n"
+      "vzeroupper                                \n"
+      : "+r"(src_ptr),                // %0
+        "+r"(dst_ptr),                // %1
+        "+r"(dst_width)               // %2
+      : "r"((intptr_t)(src_stride)),  // %3
+        "r"((intptr_t)(dst_stride))   // %4
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6");
+}
+#endif
+
+// Reads 16xN bytes and produces 16 shorts at a time.
+void ScaleAddRow_SSE2(const uint8_t* src_ptr,
+                      uint16_t* dst_ptr,
+                      int src_width) {
+      asm volatile("pxor        %%xmm5,%%xmm5                 \n"
+
+               // 16 pixel loop.
+               LABELALIGN
+      "1:                                        \n"
+      "movdqu      (%0),%%xmm3                   \n"
+      "lea         0x10(%0),%0                   \n"  // src_ptr += 16
+      "movdqu      (%1),%%xmm0                   \n"
+      "movdqu      0x10(%1),%%xmm1               \n"
+      "movdqa      %%xmm3,%%xmm2                 \n"
+      "punpcklbw   %%xmm5,%%xmm2                 \n"
+      "punpckhbw   %%xmm5,%%xmm3                 \n"
+      "paddusw     %%xmm2,%%xmm0                 \n"
+      "paddusw     %%xmm3,%%xmm1                 \n"
+      "movdqu      %%xmm0,(%1)                   \n"
+      "movdqu      %%xmm1,0x10(%1)               \n"
+      "lea         0x20(%1),%1                   \n"
+      "sub         $0x10,%2                      \n"
+      "jg          1b                            \n"
+               : "+r"(src_ptr),   // %0
+                 "+r"(dst_ptr),   // %1
+                 "+r"(src_width)  // %2
+               :
+               : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm5");
+}
+
+#ifdef HAS_SCALEADDROW_AVX2
+// Reads 32 bytes and accumulates to 32 shorts at a time.
+void ScaleAddRow_AVX2(const uint8_t* src_ptr,
+                      uint16_t* dst_ptr,
+                      int src_width) {
+      asm volatile("vpxor       %%ymm5,%%ymm5,%%ymm5          \n"
+
+               LABELALIGN
+      "1:                                        \n"
+      "vmovdqu     (%0),%%ymm3                   \n"
+      "lea         0x20(%0),%0                   \n"  // src_ptr += 32
+      "vpermq      $0xd8,%%ymm3,%%ymm3           \n"
+      "vpunpcklbw  %%ymm5,%%ymm3,%%ymm2          \n"
+      "vpunpckhbw  %%ymm5,%%ymm3,%%ymm3          \n"
+      "vpaddusw    (%1),%%ymm2,%%ymm0            \n"
+      "vpaddusw    0x20(%1),%%ymm3,%%ymm1        \n"
+      "vmovdqu     %%ymm0,(%1)                   \n"
+      "vmovdqu     %%ymm1,0x20(%1)               \n"
+      "lea         0x40(%1),%1                   \n"
+      "sub         $0x20,%2                      \n"
+      "jg          1b                            \n"
+      "vzeroupper                                \n"
+               : "+r"(src_ptr),   // %0
+                 "+r"(dst_ptr),   // %1
+                 "+r"(src_width)  // %2
+               :
+               : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm5");
+}
+#endif  // HAS_SCALEADDROW_AVX2
+
+// Constant for making pixels signed to avoid pmaddubsw
+// saturation.
+static const uvec8 kFsub80 = {0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
+                              0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80};
+
+// Constant for making pixels unsigned and adding .5 for rounding.
+static const uvec16 kFadd40 = {0x4040, 0x4040, 0x4040, 0x4040,
+                               0x4040, 0x4040, 0x4040, 0x4040};
+
+// Bilinear column filtering. SSSE3 version.
+void ScaleFilterCols_SSSE3(uint8_t* dst_ptr,
+                           const uint8_t* src_ptr,
+                           int dst_width,
+                           int x,
+                           int dx) {
+  intptr_t x0, x1, temp_pixel;
+  asm volatile(
+      "movd        %6,%%xmm2                     \n"
+      "movd        %7,%%xmm3                     \n"
+      "movl        $0x04040000,%k2               \n"
+      "movd        %k2,%%xmm5                    \n"
+      "pcmpeqb     %%xmm6,%%xmm6                 \n"
+      "psrlw       $0x9,%%xmm6                   \n"  // 0x007f007f
+      "pcmpeqb     %%xmm7,%%xmm7                 \n"
+      "psrlw       $15,%%xmm7                    \n"  // 0x00010001
+
+      "pextrw      $0x1,%%xmm2,%k3               \n"
+      "subl        $0x2,%5                       \n"
+      "jl          29f                           \n"
+      "movdqa      %%xmm2,%%xmm0                 \n"
+      "paddd       %%xmm3,%%xmm0                 \n"
+      "punpckldq   %%xmm0,%%xmm2                 \n"
+      "punpckldq   %%xmm3,%%xmm3                 \n"
+      "paddd       %%xmm3,%%xmm3                 \n"
+      "pextrw      $0x3,%%xmm2,%k4               \n"
+
+      LABELALIGN
+      "2:                                        \n"
+      "movdqa      %%xmm2,%%xmm1                 \n"
+      "paddd       %%xmm3,%%xmm2                 \n"
+      "movzwl      0x00(%1,%3,1),%k2             \n"
+      "movd        %k2,%%xmm0                    \n"
+      "psrlw       $0x9,%%xmm1                   \n"
+      "movzwl      0x00(%1,%4,1),%k2             \n"
+      "movd        %k2,%%xmm4                    \n"
+      "pshufb      %%xmm5,%%xmm1                 \n"
+      "punpcklwd   %%xmm4,%%xmm0                 \n"
+      "psubb       %8,%%xmm0                     \n"  // make pixels signed.
+      "pxor        %%xmm6,%%xmm1                 \n"  // 128 - f = (f ^ 127 ) +
+                                                      // 1
+      "paddusb     %%xmm7,%%xmm1                 \n"
+      "pmaddubsw   %%xmm0,%%xmm1                 \n"
+      "pextrw      $0x1,%%xmm2,%k3               \n"
+      "pextrw      $0x3,%%xmm2,%k4               \n"
+      "paddw       %9,%%xmm1                     \n"  // make pixels unsigned.
+      "psrlw       $0x7,%%xmm1                   \n"
+      "packuswb    %%xmm1,%%xmm1                 \n"
+      "movd        %%xmm1,%k2                    \n"
+      "mov         %w2,(%0)                      \n"
+      "lea         0x2(%0),%0                    \n"
+      "subl        $0x2,%5                       \n"
+      "jge         2b                            \n"
+
+      LABELALIGN
+      "29:                                       \n"
+      "addl        $0x1,%5                       \n"
+      "jl          99f                           \n"
+      "movzwl      0x00(%1,%3,1),%k2             \n"
+      "movd        %k2,%%xmm0                    \n"
+      "psrlw       $0x9,%%xmm2                   \n"
+      "pshufb      %%xmm5,%%xmm2                 \n"
+      "psubb       %8,%%xmm0                     \n"  // make pixels signed.
+      "pxor        %%xmm6,%%xmm2                 \n"
+      "paddusb     %%xmm7,%%xmm2                 \n"
+      "pmaddubsw   %%xmm0,%%xmm2                 \n"
+      "paddw       %9,%%xmm2                     \n"  // make pixels unsigned.
+      "psrlw       $0x7,%%xmm2                   \n"
+      "packuswb    %%xmm2,%%xmm2                 \n"
+      "movd        %%xmm2,%k2                    \n"
+      "mov         %b2,(%0)                      \n"
+      "99:                                       \n"
+      : "+r"(dst_ptr),      // %0
+        "+r"(src_ptr),      // %1
+        "=&a"(temp_pixel),  // %2
+        "=&r"(x0),          // %3
+        "=&r"(x1),          // %4
+#if defined(__x86_64__)
+        "+rm"(dst_width)  // %5
+#else
+        "+m"(dst_width)  // %5
+#endif
+      : "rm"(x),   // %6
+        "rm"(dx),  // %7
+#if defined(__x86_64__)
+        "x"(kFsub80),  // %8
+        "x"(kFadd40)   // %9
+#else
+        "m"(kFsub80),    // %8
+        "m"(kFadd40)     // %9
+#endif
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6",
+        "xmm7");
+}
+
+// Reads 4 pixels, duplicates them and writes 8 pixels.
+// Alignment requirement: src_argb 16 byte aligned, dst_argb 16 byte aligned.
+void ScaleColsUp2_SSE2(uint8_t* dst_ptr,
+                       const uint8_t* src_ptr,
+                       int dst_width,
+                       int x,
+                       int dx) {
+  (void)x;
+  (void)dx;
+  asm volatile(LABELALIGN
+      "1:                                        \n"
+      "movdqu      (%1),%%xmm0                   \n"
+      "lea         0x10(%1),%1                   \n"
+      "movdqa      %%xmm0,%%xmm1                 \n"
+      "punpcklbw   %%xmm0,%%xmm0                 \n"
+      "punpckhbw   %%xmm1,%%xmm1                 \n"
+      "movdqu      %%xmm0,(%0)                   \n"
+      "movdqu      %%xmm1,0x10(%0)               \n"
+      "lea         0x20(%0),%0                   \n"
+      "sub         $0x20,%2                      \n"
+      "jg          1b                            \n"
+
+               : "+r"(dst_ptr),   // %0
+                 "+r"(src_ptr),   // %1
+                 "+r"(dst_width)  // %2
+                 ::"memory",
+                 "cc", "xmm0", "xmm1");
+}
+
+void ScaleARGBRowDown2_SSE2(const uint8_t* src_argb,
+                            ptrdiff_t src_stride,
+                            uint8_t* dst_argb,
+                            int dst_width) {
+  (void)src_stride;
+  asm volatile(LABELALIGN
+      "1:                                        \n"
+      "movdqu      (%0),%%xmm0                   \n"
+      "movdqu      0x10(%0),%%xmm1               \n"
+      "lea         0x20(%0),%0                   \n"
+      "shufps      $0xdd,%%xmm1,%%xmm0           \n"
+      "movdqu      %%xmm0,(%1)                   \n"
+      "lea         0x10(%1),%1                   \n"
+      "sub         $0x4,%2                       \n"
+      "jg          1b                            \n"
+               : "+r"(src_argb),  // %0
+                 "+r"(dst_argb),  // %1
+                 "+r"(dst_width)  // %2
+                 ::"memory",
+                 "cc", "xmm0", "xmm1");
+}
+
+void ScaleARGBRowDown2Linear_SSE2(const uint8_t* src_argb,
+                                  ptrdiff_t src_stride,
+                                  uint8_t* dst_argb,
+                                  int dst_width) {
+  (void)src_stride;
+  asm volatile(LABELALIGN
+      "1:                                        \n"
+      "movdqu      (%0),%%xmm0                   \n"
+      "movdqu      0x10(%0),%%xmm1               \n"
+      "lea         0x20(%0),%0                   \n"
+      "movdqa      %%xmm0,%%xmm2                 \n"
+      "shufps      $0x88,%%xmm1,%%xmm0           \n"
+      "shufps      $0xdd,%%xmm1,%%xmm2           \n"
+      "pavgb       %%xmm2,%%xmm0                 \n"
+      "movdqu      %%xmm0,(%1)                   \n"
+      "lea         0x10(%1),%1                   \n"
+      "sub         $0x4,%2                       \n"
+      "jg          1b                            \n"
+               : "+r"(src_argb),  // %0
+                 "+r"(dst_argb),  // %1
+                 "+r"(dst_width)  // %2
+                 ::"memory",
+                 "cc", "xmm0", "xmm1");
+}
+
+void ScaleARGBRowDown2Box_SSE2(const uint8_t* src_argb,
+                               ptrdiff_t src_stride,
+                               uint8_t* dst_argb,
+                               int dst_width) {
+  asm volatile(LABELALIGN
+      "1:                                        \n"
+      "movdqu      (%0),%%xmm0                   \n"
+      "movdqu      0x10(%0),%%xmm1               \n"
+      "movdqu      0x00(%0,%3,1),%%xmm2          \n"
+      "movdqu      0x10(%0,%3,1),%%xmm3          \n"
+      "lea         0x20(%0),%0                   \n"
+      "pavgb       %%xmm2,%%xmm0                 \n"
+      "pavgb       %%xmm3,%%xmm1                 \n"
+      "movdqa      %%xmm0,%%xmm2                 \n"
+      "shufps      $0x88,%%xmm1,%%xmm0           \n"
+      "shufps      $0xdd,%%xmm1,%%xmm2           \n"
+      "pavgb       %%xmm2,%%xmm0                 \n"
+      "movdqu      %%xmm0,(%1)                   \n"
+      "lea         0x10(%1),%1                   \n"
+      "sub         $0x4,%2                       \n"
+      "jg          1b                            \n"
+               : "+r"(src_argb),              // %0
+                 "+r"(dst_argb),              // %1
+                 "+r"(dst_width)              // %2
+               : "r"((intptr_t)(src_stride))  // %3
+               : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3");
+}
+
+// Reads 4 pixels at a time.
+// Alignment requirement: dst_argb 16 byte aligned.
+void ScaleARGBRowDownEven_SSE2(const uint8_t* src_argb,
+                               ptrdiff_t src_stride,
+                               int src_stepx,
+                               uint8_t* dst_argb,
+                               int dst_width) {
+  intptr_t src_stepx_x4 = (intptr_t)(src_stepx);
+  intptr_t src_stepx_x12;
+  (void)src_stride;
+  asm volatile(
+      "lea         0x00(,%1,4),%1                \n"
+      "lea         0x00(%1,%1,2),%4              \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "movd        (%0),%%xmm0                   \n"
+      "movd        0x00(%0,%1,1),%%xmm1          \n"
+      "punpckldq   %%xmm1,%%xmm0                 \n"
+      "movd        0x00(%0,%1,2),%%xmm2          \n"
+      "movd        0x00(%0,%4,1),%%xmm3          \n"
+      "lea         0x00(%0,%1,4),%0              \n"
+      "punpckldq   %%xmm3,%%xmm2                 \n"
+      "punpcklqdq  %%xmm2,%%xmm0                 \n"
+      "movdqu      %%xmm0,(%2)                   \n"
+      "lea         0x10(%2),%2                   \n"
+      "sub         $0x4,%3                       \n"
+      "jg          1b                            \n"
+      : "+r"(src_argb),       // %0
+        "+r"(src_stepx_x4),   // %1
+        "+r"(dst_argb),       // %2
+        "+r"(dst_width),      // %3
+        "=&r"(src_stepx_x12)  // %4
+        ::"memory",
+        "cc", "xmm0", "xmm1", "xmm2", "xmm3");
+}
+
+// Blends four 2x2 to 4x1.
+// Alignment requirement: dst_argb 16 byte aligned.
+void ScaleARGBRowDownEvenBox_SSE2(const uint8_t* src_argb,
+                                  ptrdiff_t src_stride,
+                                  int src_stepx,
+                                  uint8_t* dst_argb,
+                                  int dst_width) {
+  intptr_t src_stepx_x4 = (intptr_t)(src_stepx);
+  intptr_t src_stepx_x12;
+  intptr_t row1 = (intptr_t)(src_stride);
+  asm volatile(
+      "lea         0x00(,%1,4),%1                \n"
+      "lea         0x00(%1,%1,2),%4              \n"
+      "lea         0x00(%0,%5,1),%5              \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "movq        (%0),%%xmm0                   \n"
+      "movhps      0x00(%0,%1,1),%%xmm0          \n"
+      "movq        0x00(%0,%1,2),%%xmm1          \n"
+      "movhps      0x00(%0,%4,1),%%xmm1          \n"
+      "lea         0x00(%0,%1,4),%0              \n"
+      "movq        (%5),%%xmm2                   \n"
+      "movhps      0x00(%5,%1,1),%%xmm2          \n"
+      "movq        0x00(%5,%1,2),%%xmm3          \n"
+      "movhps      0x00(%5,%4,1),%%xmm3          \n"
+      "lea         0x00(%5,%1,4),%5              \n"
+      "pavgb       %%xmm2,%%xmm0                 \n"
+      "pavgb       %%xmm3,%%xmm1                 \n"
+      "movdqa      %%xmm0,%%xmm2                 \n"
+      "shufps      $0x88,%%xmm1,%%xmm0           \n"
+      "shufps      $0xdd,%%xmm1,%%xmm2           \n"
+      "pavgb       %%xmm2,%%xmm0                 \n"
+      "movdqu      %%xmm0,(%2)                   \n"
+      "lea         0x10(%2),%2                   \n"
+      "sub         $0x4,%3                       \n"
+      "jg          1b                            \n"
+      : "+r"(src_argb),        // %0
+        "+r"(src_stepx_x4),    // %1
+        "+r"(dst_argb),        // %2
+        "+rm"(dst_width),      // %3
+        "=&r"(src_stepx_x12),  // %4
+        "+r"(row1)             // %5
+        ::"memory",
+        "cc", "xmm0", "xmm1", "xmm2", "xmm3");
+}
+
+void ScaleARGBCols_SSE2(uint8_t* dst_argb,
+                        const uint8_t* src_argb,
+                        int dst_width,
+                        int x,
+                        int dx) {
+  intptr_t x0, x1;
+  asm volatile(
+      "movd        %5,%%xmm2                     \n"
+      "movd        %6,%%xmm3                     \n"
+      "pshufd      $0x0,%%xmm2,%%xmm2            \n"
+      "pshufd      $0x11,%%xmm3,%%xmm0           \n"
+      "paddd       %%xmm0,%%xmm2                 \n"
+      "paddd       %%xmm3,%%xmm3                 \n"
+      "pshufd      $0x5,%%xmm3,%%xmm0            \n"
+      "paddd       %%xmm0,%%xmm2                 \n"
+      "paddd       %%xmm3,%%xmm3                 \n"
+      "pshufd      $0x0,%%xmm3,%%xmm3            \n"
+      "pextrw      $0x1,%%xmm2,%k0               \n"
+      "pextrw      $0x3,%%xmm2,%k1               \n"
+      "cmp         $0x0,%4                       \n"
+      "jl          99f                           \n"
+      "sub         $0x4,%4                       \n"
+      "jl          49f                           \n"
+
+      LABELALIGN
+      "40:                                       \n"
+      "movd        0x00(%3,%0,4),%%xmm0          \n"
+      "movd        0x00(%3,%1,4),%%xmm1          \n"
+      "pextrw      $0x5,%%xmm2,%k0               \n"
+      "pextrw      $0x7,%%xmm2,%k1               \n"
+      "paddd       %%xmm3,%%xmm2                 \n"
+      "punpckldq   %%xmm1,%%xmm0                 \n"
+      "movd        0x00(%3,%0,4),%%xmm1          \n"
+      "movd        0x00(%3,%1,4),%%xmm4          \n"
+      "pextrw      $0x1,%%xmm2,%k0               \n"
+      "pextrw      $0x3,%%xmm2,%k1               \n"
+      "punpckldq   %%xmm4,%%xmm1                 \n"
+      "punpcklqdq  %%xmm1,%%xmm0                 \n"
+      "movdqu      %%xmm0,(%2)                   \n"
+      "lea         0x10(%2),%2                   \n"
+      "sub         $0x4,%4                       \n"
+      "jge         40b                           \n"
+
+      "49:                                       \n"
+      "test        $0x2,%4                       \n"
+      "je          29f                           \n"
+      "movd        0x00(%3,%0,4),%%xmm0          \n"
+      "movd        0x00(%3,%1,4),%%xmm1          \n"
+      "pextrw      $0x5,%%xmm2,%k0               \n"
+      "punpckldq   %%xmm1,%%xmm0                 \n"
+      "movq        %%xmm0,(%2)                   \n"
+      "lea         0x8(%2),%2                    \n"
+      "29:                                       \n"
+      "test        $0x1,%4                       \n"
+      "je          99f                           \n"
+      "movd        0x00(%3,%0,4),%%xmm0          \n"
+      "movd        %%xmm0,(%2)                   \n"
+      "99:                                       \n"
+      : "=&a"(x0),       // %0
+        "=&d"(x1),       // %1
+        "+r"(dst_argb),  // %2
+        "+r"(src_argb),  // %3
+        "+r"(dst_width)  // %4
+      : "rm"(x),         // %5
+        "rm"(dx)         // %6
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4");
+}
+
+// Reads 4 pixels, duplicates them and writes 8 pixels.
+// Alignment requirement: src_argb 16 byte aligned, dst_argb 16 byte aligned.
+void ScaleARGBColsUp2_SSE2(uint8_t* dst_argb,
+                           const uint8_t* src_argb,
+                           int dst_width,
+                           int x,
+                           int dx) {
+  (void)x;
+  (void)dx;
+  asm volatile(LABELALIGN
+      "1:                                        \n"
+      "movdqu      (%1),%%xmm0                   \n"
+      "lea         0x10(%1),%1                   \n"
+      "movdqa      %%xmm0,%%xmm1                 \n"
+      "punpckldq   %%xmm0,%%xmm0                 \n"
+      "punpckhdq   %%xmm1,%%xmm1                 \n"
+      "movdqu      %%xmm0,(%0)                   \n"
+      "movdqu      %%xmm1,0x10(%0)               \n"
+      "lea         0x20(%0),%0                   \n"
+      "sub         $0x8,%2                       \n"
+      "jg          1b                            \n"
+
+               : "+r"(dst_argb),  // %0
+                 "+r"(src_argb),  // %1
+                 "+r"(dst_width)  // %2
+                 ::"memory",
+                 "cc", "xmm0", "xmm1");
+}
+
+// Shuffle table for arranging 2 pixels into pairs for pmaddubsw
+static const uvec8 kShuffleColARGB = {
+    0u, 4u,  1u, 5u,  2u,  6u,  3u,  7u,  // bbggrraa 1st pixel
+    8u, 12u, 9u, 13u, 10u, 14u, 11u, 15u  // bbggrraa 2nd pixel
+};
+
+// Shuffle table for duplicating 2 fractions into 8 bytes each
+static const uvec8 kShuffleFractions = {
+    0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 4u, 4u, 4u, 4u, 4u, 4u, 4u, 4u,
+};
+
+// Bilinear row filtering combines 4x2 -> 4x1. SSSE3 version
+void ScaleARGBFilterCols_SSSE3(uint8_t* dst_argb,
+                               const uint8_t* src_argb,
+                               int dst_width,
+                               int x,
+                               int dx) {
+  intptr_t x0, x1;
+  asm volatile(
+      "movdqa      %0,%%xmm4                     \n"
+      "movdqa      %1,%%xmm5                     \n"
+      :
+      : "m"(kShuffleColARGB),   // %0
+        "m"(kShuffleFractions)  // %1
+  );
+
+  asm volatile(
+      "movd        %5,%%xmm2                     \n"
+      "movd        %6,%%xmm3                     \n"
+      "pcmpeqb     %%xmm6,%%xmm6                 \n"
+      "psrlw       $0x9,%%xmm6                   \n"
+      "pextrw      $0x1,%%xmm2,%k3               \n"
+      "sub         $0x2,%2                       \n"
+      "jl          29f                           \n"
+      "movdqa      %%xmm2,%%xmm0                 \n"
+      "paddd       %%xmm3,%%xmm0                 \n"
+      "punpckldq   %%xmm0,%%xmm2                 \n"
+      "punpckldq   %%xmm3,%%xmm3                 \n"
+      "paddd       %%xmm3,%%xmm3                 \n"
+      "pextrw      $0x3,%%xmm2,%k4               \n"
+
+      LABELALIGN
+      "2:                                        \n"
+      "movdqa      %%xmm2,%%xmm1                 \n"
+      "paddd       %%xmm3,%%xmm2                 \n"
+      "movq        0x00(%1,%3,4),%%xmm0          \n"
+      "psrlw       $0x9,%%xmm1                   \n"
+      "movhps      0x00(%1,%4,4),%%xmm0          \n"
+      "pshufb      %%xmm5,%%xmm1                 \n"
+      "pshufb      %%xmm4,%%xmm0                 \n"
+      "pxor        %%xmm6,%%xmm1                 \n"
+      "pmaddubsw   %%xmm1,%%xmm0                 \n"
+      "psrlw       $0x7,%%xmm0                   \n"
+      "pextrw      $0x1,%%xmm2,%k3               \n"
+      "pextrw      $0x3,%%xmm2,%k4               \n"
+      "packuswb    %%xmm0,%%xmm0                 \n"
+      "movq        %%xmm0,(%0)                   \n"
+      "lea         0x8(%0),%0                    \n"
+      "sub         $0x2,%2                       \n"
+      "jge         2b                            \n"
+
+      LABELALIGN
+      "29:                                       \n"
+      "add         $0x1,%2                       \n"
+      "jl          99f                           \n"
+      "psrlw       $0x9,%%xmm2                   \n"
+      "movq        0x00(%1,%3,4),%%xmm0          \n"
+      "pshufb      %%xmm5,%%xmm2                 \n"
+      "pshufb      %%xmm4,%%xmm0                 \n"
+      "pxor        %%xmm6,%%xmm2                 \n"
+      "pmaddubsw   %%xmm2,%%xmm0                 \n"
+      "psrlw       $0x7,%%xmm0                   \n"
+      "packuswb    %%xmm0,%%xmm0                 \n"
+      "movd        %%xmm0,(%0)                   \n"
+
+      LABELALIGN
+      "99:                                       \n"  // clang-format error.
+
+      : "+r"(dst_argb),    // %0
+        "+r"(src_argb),    // %1
+        "+rm"(dst_width),  // %2
+        "=&r"(x0),         // %3
+        "=&r"(x1)          // %4
+      : "rm"(x),           // %5
+        "rm"(dx)           // %6
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6");
+}
+
+// Divide num by div and return as 16.16 fixed point result.
+int FixedDiv_X86(int num, int div) {
+  asm volatile(
+      "cdq                                       \n"
+      "shld        $0x10,%%eax,%%edx             \n"
+      "shl         $0x10,%%eax                   \n"
+      "idiv        %1                            \n"
+      "mov         %0, %%eax                     \n"
+      : "+a"(num)  // %0
+      : "c"(div)   // %1
+      : "memory", "cc", "edx");
+  return num;
+}
+
+// Divide num - 1 by div - 1 and return as 16.16 fixed point result.
+int FixedDiv1_X86(int num, int div) {
+  asm volatile(
+      "cdq                                       \n"
+      "shld        $0x10,%%eax,%%edx             \n"
+      "shl         $0x10,%%eax                   \n"
+      "sub         $0x10001,%%eax                \n"
+      "sbb         $0x0,%%edx                    \n"
+      "sub         $0x1,%1                       \n"
+      "idiv        %1                            \n"
+      "mov         %0, %%eax                     \n"
+      : "+a"(num)  // %0
+      : "c"(div)   // %1
+      : "memory", "cc", "edx");
+  return num;
+}
+
+#ifdef HAS_SCALEUVROWDOWN2BOX_SSSE3
+// Shuffle table for splitting UV into upper and lower part of register.
+static const uvec8 kShuffleSplitUV = {0u, 2u, 4u, 6u, 8u, 10u, 12u, 14u,
+                                      1u, 3u, 5u, 7u, 9u, 11u, 13u, 15u};
+static const uvec8 kShuffleMergeUV = {0u,   8u,   2u,   10u,  4u,   12u,
+                                      6u,   14u,  0x80, 0x80, 0x80, 0x80,
+                                      0x80, 0x80, 0x80, 0x80};
+
+void ScaleUVRowDown2Box_SSSE3(const uint8_t* src_ptr,
+                              ptrdiff_t src_stride,
+                              uint8_t* dst_ptr,
+                              int dst_width) {
+  asm volatile(
+      "pcmpeqb     %%xmm4,%%xmm4                 \n"  // 01010101
+      "psrlw       $0xf,%%xmm4                   \n"
+      "packuswb    %%xmm4,%%xmm4                 \n"
+      "pxor        %%xmm5, %%xmm5                \n"  // zero
+      "movdqa      %4,%%xmm1                     \n"  // split shuffler
+      "movdqa      %5,%%xmm3                     \n"  // merge shuffler
+
+      LABELALIGN
+      "1:                                        \n"
+      "movdqu      (%0),%%xmm0                   \n"  // 8 UV row 0
+      "movdqu      0x00(%0,%3,1),%%xmm2          \n"  // 8 UV row 1
+      "lea         0x10(%0),%0                   \n"
+      "pshufb      %%xmm1,%%xmm0                 \n"  // uuuuvvvv
+      "pshufb      %%xmm1,%%xmm2                 \n"
+      "pmaddubsw   %%xmm4,%%xmm0                 \n"  // horizontal add
+      "pmaddubsw   %%xmm4,%%xmm2                 \n"
+      "paddw       %%xmm2,%%xmm0                 \n"  // vertical add
+      "psrlw       $0x1,%%xmm0                   \n"  // round
+      "pavgw       %%xmm5,%%xmm0                 \n"
+      "pshufb      %%xmm3,%%xmm0                 \n"  // merge uv
+      "movq        %%xmm0,(%1)                   \n"
+      "lea         0x8(%1),%1                    \n"  // 4 UV
+      "sub         $0x4,%2                       \n"
+      "jg          1b                            \n"
+      : "+r"(src_ptr),                // %0
+        "+r"(dst_ptr),                // %1
+        "+r"(dst_width)               // %2
+      : "r"((intptr_t)(src_stride)),  // %3
+        "m"(kShuffleSplitUV),         // %4
+        "m"(kShuffleMergeUV)          // %5
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5");
+}
+#endif  // HAS_SCALEUVROWDOWN2BOX_SSSE3
+
+#ifdef HAS_SCALEUVROWDOWN2BOX_AVX2
+void ScaleUVRowDown2Box_AVX2(const uint8_t* src_ptr,
+                             ptrdiff_t src_stride,
+                             uint8_t* dst_ptr,
+                             int dst_width) {
+  asm volatile(
+      "vpcmpeqb    %%ymm4,%%ymm4,%%ymm4          \n"  // 01010101
+      "vpsrlw      $0xf,%%ymm4,%%ymm4            \n"
+      "vpackuswb   %%ymm4,%%ymm4,%%ymm4          \n"
+      "vpxor       %%ymm5,%%ymm5,%%ymm5          \n"  // zero
+      "vbroadcastf128 %4,%%ymm1                  \n"  // split shuffler
+      "vbroadcastf128 %5,%%ymm3                  \n"  // merge shuffler
+
+      LABELALIGN
+      "1:                                        \n"
+      "vmovdqu     (%0),%%ymm0                   \n"  // 16 UV row 0
+      "vmovdqu     0x00(%0,%3,1),%%ymm2          \n"  // 16 UV row 1
+      "lea         0x20(%0),%0                   \n"
+      "vpshufb     %%ymm1,%%ymm0,%%ymm0          \n"  // uuuuvvvv
+      "vpshufb     %%ymm1,%%ymm2,%%ymm2          \n"
+      "vpmaddubsw  %%ymm4,%%ymm0,%%ymm0          \n"  // horizontal add
+      "vpmaddubsw  %%ymm4,%%ymm2,%%ymm2          \n"
+      "vpaddw      %%ymm2,%%ymm0,%%ymm0          \n"  // vertical add
+      "vpsrlw      $0x1,%%ymm0,%%ymm0            \n"  // round
+      "vpavgw      %%ymm5,%%ymm0,%%ymm0          \n"
+      "vpshufb     %%ymm3,%%ymm0,%%ymm0          \n"  // merge uv
+      "vpermq      $0xd8,%%ymm0,%%ymm0           \n"  // combine qwords
+      "vmovdqu     %%xmm0,(%1)                   \n"
+      "lea         0x10(%1),%1                   \n"  // 8 UV
+      "sub         $0x8,%2                       \n"
+      "jg          1b                            \n"
+      "vzeroupper                                \n"
+      : "+r"(src_ptr),                // %0
+        "+r"(dst_ptr),                // %1
+        "+r"(dst_width)               // %2
+      : "r"((intptr_t)(src_stride)),  // %3
+        "m"(kShuffleSplitUV),         // %4
+        "m"(kShuffleMergeUV)          // %5
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5");
+}
+#endif  // HAS_SCALEUVROWDOWN2BOX_AVX2
+
+static const uvec8 kUVLinearMadd31 = {3, 1, 3, 1, 1, 3, 1, 3,
+                                      3, 1, 3, 1, 1, 3, 1, 3};
+
+#ifdef HAS_SCALEUVROWUP2LINEAR_SSSE3
+void ScaleUVRowUp2_Linear_SSSE3(const uint8_t* src_ptr,
+                                uint8_t* dst_ptr,
+                                int dst_width) {
+  asm volatile(
+      "pcmpeqw     %%xmm4,%%xmm4                 \n"
+      "psrlw       $15,%%xmm4                    \n"
+      "psllw       $1,%%xmm4                     \n"  // all 2
+      "movdqa      %3,%%xmm3                     \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "movq        (%0),%%xmm0                   \n"  // 00112233 (1u1v)
+      "movq        2(%0),%%xmm1                  \n"  // 11223344 (1u1v)
+      "punpcklbw   %%xmm1,%%xmm0                 \n"  // 0101121223233434 (2u2v)
+      "movdqa      %%xmm0,%%xmm2                 \n"
+      "punpckhdq   %%xmm0,%%xmm2                 \n"  // 2323232334343434 (2u2v)
+      "punpckldq   %%xmm0,%%xmm0                 \n"  // 0101010112121212 (2u2v)
+      "pmaddubsw   %%xmm3,%%xmm2                 \n"  // 3*near+far (1u1v16, hi)
+      "pmaddubsw   %%xmm3,%%xmm0                 \n"  // 3*near+far (1u1v16, lo)
+      "paddw       %%xmm4,%%xmm0                 \n"  // 3*near+far+2 (lo)
+      "paddw       %%xmm4,%%xmm2                 \n"  // 3*near+far+2 (hi)
+      "psrlw       $2,%%xmm0                     \n"  // 3/4*near+1/4*far (lo)
+      "psrlw       $2,%%xmm2                     \n"  // 3/4*near+1/4*far (hi)
+      "packuswb    %%xmm2,%%xmm0                 \n"
+      "movdqu      %%xmm0,(%1)                   \n"
+
+      "lea         0x8(%0),%0                    \n"
+      "lea         0x10(%1),%1                   \n"  // 4 uv to 8 uv
+      "sub         $0x8,%2                       \n"
+      "jg          1b                            \n"
+      : "+r"(src_ptr),        // %0
+        "+r"(dst_ptr),        // %1
+        "+r"(dst_width)       // %2
+      : "m"(kUVLinearMadd31)  // %3
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6");
+}
+#endif
+
+#ifdef HAS_SCALEUVROWUP2BILINEAR_SSSE3
+void ScaleUVRowUp2_Bilinear_SSSE3(const uint8_t* src_ptr,
+                                  ptrdiff_t src_stride,
+                                  uint8_t* dst_ptr,
+                                  ptrdiff_t dst_stride,
+                                  int dst_width) {
+  asm volatile(
+      "pcmpeqw     %%xmm6,%%xmm6                 \n"
+      "psrlw       $15,%%xmm6                    \n"
+      "psllw       $3,%%xmm6                     \n"  // all 8
+      "movdqa      %5,%%xmm7                     \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "movq        (%0),%%xmm0                   \n"  // 00112233 (1u1v)
+      "movq        2(%0),%%xmm1                  \n"  // 11223344 (1u1v)
+      "punpcklbw   %%xmm1,%%xmm0                 \n"  // 0101121223233434 (2u2v)
+      "movdqa      %%xmm0,%%xmm2                 \n"
+      "punpckhdq   %%xmm0,%%xmm2                 \n"  // 2323232334343434 (2u2v)
+      "punpckldq   %%xmm0,%%xmm0                 \n"  // 0101010112121212 (2u2v)
+      "pmaddubsw   %%xmm7,%%xmm2                 \n"  // 3*near+far (1u1v16, hi)
+      "pmaddubsw   %%xmm7,%%xmm0                 \n"  // 3*near+far (1u1v16, lo)
+
+      "movq        (%0,%3),%%xmm1                \n"
+      "movq        2(%0,%3),%%xmm4               \n"
+      "punpcklbw   %%xmm4,%%xmm1                 \n"
+      "movdqa      %%xmm1,%%xmm3                 \n"
+      "punpckhdq   %%xmm1,%%xmm3                 \n"
+      "punpckldq   %%xmm1,%%xmm1                 \n"
+      "pmaddubsw   %%xmm7,%%xmm3                 \n"  // 3*near+far (2, hi)
+      "pmaddubsw   %%xmm7,%%xmm1                 \n"  // 3*near+far (2, lo)
+
+      // xmm0 xmm2
+      // xmm1 xmm3
+
+      "movdqa      %%xmm0,%%xmm4                 \n"
+      "movdqa      %%xmm1,%%xmm5                 \n"
+      "paddw       %%xmm0,%%xmm4                 \n"  // 6*near+2*far (1, lo)
+      "paddw       %%xmm6,%%xmm5                 \n"  // 3*near+far+8 (2, lo)
+      "paddw       %%xmm0,%%xmm4                 \n"  // 9*near+3*far (1, lo)
+      "paddw       %%xmm5,%%xmm4                 \n"  // 9 3 3 1 + 8 (1, lo)
+      "psrlw       $4,%%xmm4                     \n"  // ^ div by 16 (1, lo)
+
+      "movdqa      %%xmm1,%%xmm5                 \n"
+      "paddw       %%xmm1,%%xmm5                 \n"  // 6*near+2*far (2, lo)
+      "paddw       %%xmm6,%%xmm0                 \n"  // 3*near+far+8 (1, lo)
+      "paddw       %%xmm1,%%xmm5                 \n"  // 9*near+3*far (2, lo)
+      "paddw       %%xmm0,%%xmm5                 \n"  // 9 3 3 1 + 8 (2, lo)
+      "psrlw       $4,%%xmm5                     \n"  // ^ div by 16 (2, lo)
+
+      "movdqa      %%xmm2,%%xmm0                 \n"
+      "movdqa      %%xmm3,%%xmm1                 \n"
+      "paddw       %%xmm2,%%xmm0                 \n"  // 6*near+2*far (1, hi)
+      "paddw       %%xmm6,%%xmm1                 \n"  // 3*near+far+8 (2, hi)
+      "paddw       %%xmm2,%%xmm0                 \n"  // 9*near+3*far (1, hi)
+      "paddw       %%xmm1,%%xmm0                 \n"  // 9 3 3 1 + 8 (1, hi)
+      "psrlw       $4,%%xmm0                     \n"  // ^ div by 16 (1, hi)
+
+      "movdqa      %%xmm3,%%xmm1                 \n"
+      "paddw       %%xmm3,%%xmm1                 \n"  // 6*near+2*far (2, hi)
+      "paddw       %%xmm6,%%xmm2                 \n"  // 3*near+far+8 (1, hi)
+      "paddw       %%xmm3,%%xmm1                 \n"  // 9*near+3*far (2, hi)
+      "paddw       %%xmm2,%%xmm1                 \n"  // 9 3 3 1 + 8 (2, hi)
+      "psrlw       $4,%%xmm1                     \n"  // ^ div by 16 (2, hi)
+
+      "packuswb    %%xmm0,%%xmm4                 \n"
+      "movdqu      %%xmm4,(%1)                   \n"  // store above
+      "packuswb    %%xmm1,%%xmm5                 \n"
+      "movdqu      %%xmm5,(%1,%4)                \n"  // store below
+
+      "lea         0x8(%0),%0                    \n"
+      "lea         0x10(%1),%1                   \n"  // 4 uv to 8 uv
+      "sub         $0x8,%2                       \n"
+      "jg          1b                            \n"
+      : "+r"(src_ptr),                // %0
+        "+r"(dst_ptr),                // %1
+        "+r"(dst_width)               // %2
+      : "r"((intptr_t)(src_stride)),  // %3
+        "r"((intptr_t)(dst_stride)),  // %4
+        "m"(kUVLinearMadd31)          // %5
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6",
+        "xmm7");
+}
+#endif
+
+#ifdef HAS_SCALEUVROWUP2LINEAR_AVX2
+
+void ScaleUVRowUp2_Linear_AVX2(const uint8_t* src_ptr,
+                               uint8_t* dst_ptr,
+                               int dst_width) {
+  asm volatile(
+      "vpcmpeqw    %%ymm4,%%ymm4,%%ymm4          \n"
+      "vpsrlw      $15,%%ymm4,%%ymm4             \n"
+      "vpsllw      $1,%%ymm4,%%ymm4              \n"  // all 2
+      "vbroadcastf128 %3,%%ymm3                  \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "vmovdqu     (%0),%%xmm0                   \n"
+      "vmovdqu     2(%0),%%xmm1                  \n"
+      "vpermq      $0b11011000,%%ymm0,%%ymm0     \n"
+      "vpermq      $0b11011000,%%ymm1,%%ymm1     \n"
+      "vpunpcklbw  %%ymm1,%%ymm0,%%ymm0          \n"
+      "vpunpckhdq  %%ymm0,%%ymm0,%%ymm2          \n"
+      "vpunpckldq  %%ymm0,%%ymm0,%%ymm0          \n"
+      "vpmaddubsw  %%ymm3,%%ymm2,%%ymm1          \n"  // 3*near+far (hi)
+      "vpmaddubsw  %%ymm3,%%ymm0,%%ymm0          \n"  // 3*near+far (lo)
+      "vpaddw      %%ymm4,%%ymm0,%%ymm0          \n"  // 3*near+far+2 (lo)
+      "vpaddw      %%ymm4,%%ymm1,%%ymm1          \n"  // 3*near+far+2 (hi)
+      "vpsrlw      $2,%%ymm0,%%ymm0              \n"  // 3/4*near+1/4*far (lo)
+      "vpsrlw      $2,%%ymm1,%%ymm1              \n"  // 3/4*near+1/4*far (hi)
+      "vpackuswb   %%ymm1,%%ymm0,%%ymm0          \n"
+      "vmovdqu     %%ymm0,(%1)                   \n"
+
+      "lea         0x10(%0),%0                   \n"
+      "lea         0x20(%1),%1                   \n"  // 8 uv to 16 uv
+      "sub         $0x10,%2                      \n"
+      "jg          1b                            \n"
+      "vzeroupper                                \n"
+      : "+r"(src_ptr),        // %0
+        "+r"(dst_ptr),        // %1
+        "+r"(dst_width)       // %2
+      : "m"(kUVLinearMadd31)  // %3
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4");
+}
+#endif
+
+#ifdef HAS_SCALEUVROWUP2BILINEAR_AVX2
+void ScaleUVRowUp2_Bilinear_AVX2(const uint8_t* src_ptr,
+                                 ptrdiff_t src_stride,
+                                 uint8_t* dst_ptr,
+                                 ptrdiff_t dst_stride,
+                                 int dst_width) {
+  asm volatile(
+      "vpcmpeqw    %%ymm6,%%ymm6,%%ymm6          \n"
+      "vpsrlw      $15,%%ymm6,%%ymm6             \n"
+      "vpsllw      $3,%%ymm6,%%ymm6              \n"  // all 8
+      "vbroadcastf128 %5,%%ymm7                  \n"
+
+      LABELALIGN
+      "1:                                        \n"
+      "vmovdqu     (%0),%%xmm0                   \n"
+      "vmovdqu     2(%0),%%xmm1                  \n"
+      "vpermq      $0b11011000,%%ymm0,%%ymm0     \n"
+      "vpermq      $0b11011000,%%ymm1,%%ymm1     \n"
+      "vpunpcklbw  %%ymm1,%%ymm0,%%ymm0          \n"
+      "vpunpckhdq  %%ymm0,%%ymm0,%%ymm2          \n"
+      "vpunpckldq  %%ymm0,%%ymm0,%%ymm0          \n"
+      "vpmaddubsw  %%ymm7,%%ymm2,%%ymm1          \n"  // 3*near+far (1, hi)
+      "vpmaddubsw  %%ymm7,%%ymm0,%%ymm0          \n"  // 3*near+far (1, lo)
+
+      "vmovdqu     (%0,%3),%%xmm2                \n"  // 0123456789ABCDEF
+      "vmovdqu     2(%0,%3),%%xmm3               \n"  // 123456789ABCDEF0
+      "vpermq      $0b11011000,%%ymm2,%%ymm2     \n"
+      "vpermq      $0b11011000,%%ymm3,%%ymm3     \n"
+      "vpunpcklbw  %%ymm3,%%ymm2,%%ymm2          \n"
+      "vpunpckhdq  %%ymm2,%%ymm2,%%ymm4          \n"
+      "vpunpckldq  %%ymm2,%%ymm2,%%ymm2          \n"
+      "vpmaddubsw  %%ymm7,%%ymm4,%%ymm3          \n"  // 3*near+far (2, hi)
+      "vpmaddubsw  %%ymm7,%%ymm2,%%ymm2          \n"  // 3*near+far (2, lo)
+
+      // ymm0 ymm1
+      // ymm2 ymm3
+
+      "vpaddw      %%ymm0,%%ymm0,%%ymm4          \n"  // 6*near+2*far (1, lo)
+      "vpaddw      %%ymm6,%%ymm2,%%ymm5          \n"  // 3*near+far+8 (2, lo)
+      "vpaddw      %%ymm4,%%ymm0,%%ymm4          \n"  // 9*near+3*far (1, lo)
+      "vpaddw      %%ymm4,%%ymm5,%%ymm4          \n"  // 9 3 3 1 + 8 (1, lo)
+      "vpsrlw      $4,%%ymm4,%%ymm4              \n"  // ^ div by 16 (1, lo)
+
+      "vpaddw      %%ymm2,%%ymm2,%%ymm5          \n"  // 6*near+2*far (2, lo)
+      "vpaddw      %%ymm6,%%ymm0,%%ymm0          \n"  // 3*near+far+8 (1, lo)
+      "vpaddw      %%ymm5,%%ymm2,%%ymm5          \n"  // 9*near+3*far (2, lo)
+      "vpaddw      %%ymm5,%%ymm0,%%ymm5          \n"  // 9 3 3 1 + 8 (2, lo)
+      "vpsrlw      $4,%%ymm5,%%ymm5              \n"  // ^ div by 16 (2, lo)
+
+      "vpaddw      %%ymm1,%%ymm1,%%ymm0          \n"  // 6*near+2*far (1, hi)
+      "vpaddw      %%ymm6,%%ymm3,%%ymm2          \n"  // 3*near+far+8 (2, hi)
+      "vpaddw      %%ymm0,%%ymm1,%%ymm0          \n"  // 9*near+3*far (1, hi)
+      "vpaddw      %%ymm0,%%ymm2,%%ymm0          \n"  // 9 3 3 1 + 8 (1, hi)
+      "vpsrlw      $4,%%ymm0,%%ymm0              \n"  // ^ div by 16 (1, hi)
+
+      "vpaddw      %%ymm3,%%ymm3,%%ymm2          \n"  // 6*near+2*far (2, hi)
+      "vpaddw      %%ymm6,%%ymm1,%%ymm1          \n"  // 3*near+far+8 (1, hi)
+      "vpaddw      %%ymm2,%%ymm3,%%ymm2          \n"  // 9*near+3*far (2, hi)
+      "vpaddw      %%ymm2,%%ymm1,%%ymm2          \n"  // 9 3 3 1 + 8 (2, hi)
+      "vpsrlw      $4,%%ymm2,%%ymm2              \n"  // ^ div by 16 (2, hi)
+
+      "vpackuswb   %%ymm0,%%ymm4,%%ymm4          \n"
+      "vmovdqu     %%ymm4,(%1)                   \n"  // store above
+      "vpackuswb   %%ymm2,%%ymm5,%%ymm5          \n"
+      "vmovdqu     %%ymm5,(%1,%4)                \n"  // store below
+
+      "lea         0x10(%0),%0                   \n"
+      "lea         0x20(%1),%1                   \n"  // 8 uv to 16 uv
+      "sub         $0x10,%2                      \n"
+      "jg          1b                            \n"
+      "vzeroupper                                \n"
+      : "+r"(src_ptr),                // %0
+        "+r"(dst_ptr),                // %1
+        "+r"(dst_width)               // %2
+      : "r"((intptr_t)(src_stride)),  // %3
+        "r"((intptr_t)(dst_stride)),  // %4
+        "m"(kUVLinearMadd31)          // %5
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6",
+        "xmm7");
+}
+#endif
+
+#ifdef HAS_SCALEUVROWUP2LINEAR_16_SSE41
+void ScaleUVRowUp2_Linear_16_SSE41(const uint16_t* src_ptr,
+                                   uint16_t* dst_ptr,
+                                   int dst_width) {
+  asm volatile(
+      "pxor        %%xmm5,%%xmm5                 \n"
+      "pcmpeqd     %%xmm4,%%xmm4                 \n"
+      "psrld       $31,%%xmm4                    \n"
+      "pslld       $1,%%xmm4                     \n"  // all 2
+
+      LABELALIGN
+      "1:                                        \n"
+      "movq        (%0),%%xmm0                   \n"  // 0011 (16b, 1u1v)
+      "movq        4(%0),%%xmm1                  \n"  // 1122 (16b, 1u1v)
+
+      "punpcklwd   %%xmm5,%%xmm0                 \n"  // 0011 (32b, 1u1v)
+      "punpcklwd   %%xmm5,%%xmm1                 \n"  // 1122 (32b, 1u1v)
+
+      "movdqa      %%xmm0,%%xmm2                 \n"
+      "movdqa      %%xmm1,%%xmm3                 \n"
+
+      "pshufd      $0b01001110,%%xmm2,%%xmm2     \n"  // 1100 (lo, far)
+      "pshufd      $0b01001110,%%xmm3,%%xmm3     \n"  // 2211 (hi, far)
+
+      "paddd       %%xmm4,%%xmm2                 \n"  // far+2 (lo)
+      "paddd       %%xmm4,%%xmm3                 \n"  // far+2 (hi)
+      "paddd       %%xmm0,%%xmm2                 \n"  // near+far+2 (lo)
+      "paddd       %%xmm1,%%xmm3                 \n"  // near+far+2 (hi)
+      "paddd       %%xmm0,%%xmm0                 \n"  // 2*near (lo)
+      "paddd       %%xmm1,%%xmm1                 \n"  // 2*near (hi)
+      "paddd       %%xmm2,%%xmm0                 \n"  // 3*near+far+2 (lo)
+      "paddd       %%xmm3,%%xmm1                 \n"  // 3*near+far+2 (hi)
+
+      "psrld       $2,%%xmm0                     \n"  // 3/4*near+1/4*far (lo)
+      "psrld       $2,%%xmm1                     \n"  // 3/4*near+1/4*far (hi)
+      "packusdw    %%xmm1,%%xmm0                 \n"
+      "movdqu      %%xmm0,(%1)                   \n"
+
+      "lea         0x8(%0),%0                    \n"
+      "lea         0x10(%1),%1                   \n"  // 2 uv to 4 uv
+      "sub         $0x4,%2                       \n"
+      "jg          1b                            \n"
+      : "+r"(src_ptr),   // %0
+        "+r"(dst_ptr),   // %1
+        "+r"(dst_width)  // %2
+      :
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5");
+}
+#endif
+
+#ifdef HAS_SCALEUVROWUP2BILINEAR_16_SSE41
+void ScaleUVRowUp2_Bilinear_16_SSE41(const uint16_t* src_ptr,
+                                     ptrdiff_t src_stride,
+                                     uint16_t* dst_ptr,
+                                     ptrdiff_t dst_stride,
+                                     int dst_width) {
+  asm volatile(
+      "pxor        %%xmm7,%%xmm7                 \n"
+      "pcmpeqd     %%xmm6,%%xmm6                 \n"
+      "psrld       $31,%%xmm6                    \n"
+      "pslld       $3,%%xmm6                     \n"  // all 8
+
+      LABELALIGN
+      "1:                                        \n"
+      "movq        (%0),%%xmm0                   \n"  // 0011 (16b, 1u1v)
+      "movq        4(%0),%%xmm1                  \n"  // 1122 (16b, 1u1v)
+      "punpcklwd   %%xmm7,%%xmm0                 \n"  // 0011 (near) (32b, 1u1v)
+      "punpcklwd   %%xmm7,%%xmm1                 \n"  // 1122 (near) (32b, 1u1v)
+      "movdqa      %%xmm0,%%xmm2                 \n"
+      "movdqa      %%xmm1,%%xmm3                 \n"
+      "pshufd      $0b01001110,%%xmm2,%%xmm2     \n"  // 1100 (far) (1, lo)
+      "pshufd      $0b01001110,%%xmm3,%%xmm3     \n"  // 2211 (far) (1, hi)
+      "paddd       %%xmm0,%%xmm2                 \n"  // near+far (1, lo)
+      "paddd       %%xmm1,%%xmm3                 \n"  // near+far (1, hi)
+      "paddd       %%xmm0,%%xmm0                 \n"  // 2*near (1, lo)
+      "paddd       %%xmm1,%%xmm1                 \n"  // 2*near (1, hi)
+      "paddd       %%xmm2,%%xmm0                 \n"  // 3*near+far (1, lo)
+      "paddd       %%xmm3,%%xmm1                 \n"  // 3*near+far (1, hi)
+
+      "movq        (%0,%3,2),%%xmm2              \n"
+      "movq        4(%0,%3,2),%%xmm3             \n"
+      "punpcklwd   %%xmm7,%%xmm2                 \n"
+      "punpcklwd   %%xmm7,%%xmm3                 \n"
+      "movdqa      %%xmm2,%%xmm4                 \n"
+      "movdqa      %%xmm3,%%xmm5                 \n"
+      "pshufd      $0b01001110,%%xmm4,%%xmm4     \n"  // 1100 (far) (2, lo)
+      "pshufd      $0b01001110,%%xmm5,%%xmm5     \n"  // 2211 (far) (2, hi)
+      "paddd       %%xmm2,%%xmm4                 \n"  // near+far (2, lo)
+      "paddd       %%xmm3,%%xmm5                 \n"  // near+far (2, hi)
+      "paddd       %%xmm2,%%xmm2                 \n"  // 2*near (2, lo)
+      "paddd       %%xmm3,%%xmm3                 \n"  // 2*near (2, hi)
+      "paddd       %%xmm4,%%xmm2                 \n"  // 3*near+far (2, lo)
+      "paddd       %%xmm5,%%xmm3                 \n"  // 3*near+far (2, hi)
+
+      "movdqa      %%xmm0,%%xmm4                 \n"
+      "movdqa      %%xmm2,%%xmm5                 \n"
+      "paddd       %%xmm0,%%xmm4                 \n"  // 6*near+2*far (1, lo)
+      "paddd       %%xmm6,%%xmm5                 \n"  // 3*near+far+8 (2, lo)
+      "paddd       %%xmm0,%%xmm4                 \n"  // 9*near+3*far (1, lo)
+      "paddd       %%xmm5,%%xmm4                 \n"  // 9 3 3 1 + 8 (1, lo)
+      "psrld       $4,%%xmm4                     \n"  // ^ div by 16 (1, lo)
+
+      "movdqa      %%xmm2,%%xmm5                 \n"
+      "paddd       %%xmm2,%%xmm5                 \n"  // 6*near+2*far (2, lo)
+      "paddd       %%xmm6,%%xmm0                 \n"  // 3*near+far+8 (1, lo)
+      "paddd       %%xmm2,%%xmm5                 \n"  // 9*near+3*far (2, lo)
+      "paddd       %%xmm0,%%xmm5                 \n"  // 9 3 3 1 + 8 (2, lo)
+      "psrld       $4,%%xmm5                     \n"  // ^ div by 16 (2, lo)
+
+      "movdqa      %%xmm1,%%xmm0                 \n"
+      "movdqa      %%xmm3,%%xmm2                 \n"
+      "paddd       %%xmm1,%%xmm0                 \n"  // 6*near+2*far (1, hi)
+      "paddd       %%xmm6,%%xmm2                 \n"  // 3*near+far+8 (2, hi)
+      "paddd       %%xmm1,%%xmm0                 \n"  // 9*near+3*far (1, hi)
+      "paddd       %%xmm2,%%xmm0                 \n"  // 9 3 3 1 + 8 (1, hi)
+      "psrld       $4,%%xmm0                     \n"  // ^ div by 16 (1, hi)
+
+      "movdqa      %%xmm3,%%xmm2                 \n"
+      "paddd       %%xmm3,%%xmm2                 \n"  // 6*near+2*far (2, hi)
+      "paddd       %%xmm6,%%xmm1                 \n"  // 3*near+far+8 (1, hi)
+      "paddd       %%xmm3,%%xmm2                 \n"  // 9*near+3*far (2, hi)
+      "paddd       %%xmm1,%%xmm2                 \n"  // 9 3 3 1 + 8 (2, hi)
+      "psrld       $4,%%xmm2                     \n"  // ^ div by 16 (2, hi)
+
+      "packusdw    %%xmm0,%%xmm4                 \n"
+      "movdqu      %%xmm4,(%1)                   \n"  // store above
+      "packusdw    %%xmm2,%%xmm5                 \n"
+      "movdqu      %%xmm5,(%1,%4,2)              \n"  // store below
+
+      "lea         0x8(%0),%0                    \n"
+      "lea         0x10(%1),%1                   \n"  // 2 uv to 4 uv
+      "sub         $0x4,%2                       \n"
+      "jg          1b                            \n"
+      : "+r"(src_ptr),                // %0
+        "+r"(dst_ptr),                // %1
+        "+r"(dst_width)               // %2
+      : "r"((intptr_t)(src_stride)),  // %3
+        "r"((intptr_t)(dst_stride))   // %4
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6",
+        "xmm7");
+}
+#endif
+
+#ifdef HAS_SCALEUVROWUP2LINEAR_16_AVX2
+void ScaleUVRowUp2_Linear_16_AVX2(const uint16_t* src_ptr,
+                                  uint16_t* dst_ptr,
+                                  int dst_width) {
+  asm volatile(
+      "vpcmpeqd    %%ymm4,%%ymm4,%%ymm4          \n"
+      "vpsrld      $31,%%ymm4,%%ymm4             \n"
+      "vpslld      $1,%%ymm4,%%ymm4              \n"  // all 2
+
+      LABELALIGN
+      "1:                                        \n"
+      "vmovdqu     (%0),%%xmm0                   \n"  // 00112233 (16b, 1u1v)
+      "vmovdqu     4(%0),%%xmm1                  \n"  // 11223344 (16b, 1u1v)
+
+      "vpmovzxwd   %%xmm0,%%ymm0                 \n"  // 01234567 (32b, 1u1v)
+      "vpmovzxwd   %%xmm1,%%ymm1                 \n"  // 12345678 (32b, 1u1v)
+
+      "vpshufd     $0b01001110,%%ymm0,%%ymm2     \n"  // 11003322 (lo, far)
+      "vpshufd     $0b01001110,%%ymm1,%%ymm3     \n"  // 22114433 (hi, far)
+
+      "vpaddd      %%ymm4,%%ymm2,%%ymm2          \n"  // far+2 (lo)
+      "vpaddd      %%ymm4,%%ymm3,%%ymm3          \n"  // far+2 (hi)
+      "vpaddd      %%ymm0,%%ymm2,%%ymm2          \n"  // near+far+2 (lo)
+      "vpaddd      %%ymm1,%%ymm3,%%ymm3          \n"  // near+far+2 (hi)
+      "vpaddd      %%ymm0,%%ymm0,%%ymm0          \n"  // 2*near (lo)
+      "vpaddd      %%ymm1,%%ymm1,%%ymm1          \n"  // 2*near (hi)
+      "vpaddd      %%ymm0,%%ymm2,%%ymm0          \n"  // 3*near+far+2 (lo)
+      "vpaddd      %%ymm1,%%ymm3,%%ymm1          \n"  // 3*near+far+2 (hi)
+
+      "vpsrld      $2,%%ymm0,%%ymm0              \n"  // 3/4*near+1/4*far (lo)
+      "vpsrld      $2,%%ymm1,%%ymm1              \n"  // 3/4*near+1/4*far (hi)
+      "vpackusdw   %%ymm1,%%ymm0,%%ymm0          \n"
+      "vmovdqu     %%ymm0,(%1)                   \n"
+
+      "lea         0x10(%0),%0                   \n"
+      "lea         0x20(%1),%1                   \n"  // 4 uv to 8 uv
+      "sub         $0x8,%2                       \n"
+      "jg          1b                            \n"
+      "vzeroupper                                \n"
+      : "+r"(src_ptr),   // %0
+        "+r"(dst_ptr),   // %1
+        "+r"(dst_width)  // %2
+      :
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4");
+}
+#endif
+
+#ifdef HAS_SCALEUVROWUP2BILINEAR_16_AVX2
+void ScaleUVRowUp2_Bilinear_16_AVX2(const uint16_t* src_ptr,
+                                    ptrdiff_t src_stride,
+                                    uint16_t* dst_ptr,
+                                    ptrdiff_t dst_stride,
+                                    int dst_width) {
+  asm volatile(
+      "vpcmpeqd    %%ymm6,%%ymm6,%%ymm6          \n"
+      "vpsrld      $31,%%ymm6,%%ymm6             \n"
+      "vpslld      $3,%%ymm6,%%ymm6              \n"  // all 8
+
+      LABELALIGN
+      "1:                                        \n"
+
+      "vmovdqu     (%0),%%xmm0                   \n"  // 00112233 (16b, 1u1v)
+      "vmovdqu     4(%0),%%xmm1                  \n"  // 11223344 (16b, 1u1v)
+      "vpmovzxwd   %%xmm0,%%ymm0                 \n"  // 01234567 (32b, 1u1v)
+      "vpmovzxwd   %%xmm1,%%ymm1                 \n"  // 12345678 (32b, 1u1v)
+      "vpshufd     $0b01001110,%%ymm0,%%ymm2     \n"  // 11003322 (lo, far)
+      "vpshufd     $0b01001110,%%ymm1,%%ymm3     \n"  // 22114433 (hi, far)
+      "vpaddd      %%ymm0,%%ymm2,%%ymm2          \n"  // near+far (lo)
+      "vpaddd      %%ymm1,%%ymm3,%%ymm3          \n"  // near+far (hi)
+      "vpaddd      %%ymm0,%%ymm0,%%ymm0          \n"  // 2*near (lo)
+      "vpaddd      %%ymm1,%%ymm1,%%ymm1          \n"  // 2*near (hi)
+      "vpaddd      %%ymm0,%%ymm2,%%ymm0          \n"  // 3*near+far (lo)
+      "vpaddd      %%ymm1,%%ymm3,%%ymm1          \n"  // 3*near+far (hi)
+
+      "vmovdqu     (%0,%3,2),%%xmm2              \n"  // 00112233 (16b, 1u1v)
+      "vmovdqu     4(%0,%3,2),%%xmm3             \n"  // 11223344 (16b, 1u1v)
+      "vpmovzxwd   %%xmm2,%%ymm2                 \n"  // 01234567 (32b, 1u1v)
+      "vpmovzxwd   %%xmm3,%%ymm3                 \n"  // 12345678 (32b, 1u1v)
+      "vpshufd     $0b01001110,%%ymm2,%%ymm4     \n"  // 11003322 (lo, far)
+      "vpshufd     $0b01001110,%%ymm3,%%ymm5     \n"  // 22114433 (hi, far)
+      "vpaddd      %%ymm2,%%ymm4,%%ymm4          \n"  // near+far (lo)
+      "vpaddd      %%ymm3,%%ymm5,%%ymm5          \n"  // near+far (hi)
+      "vpaddd      %%ymm2,%%ymm2,%%ymm2          \n"  // 2*near (lo)
+      "vpaddd      %%ymm3,%%ymm3,%%ymm3          \n"  // 2*near (hi)
+      "vpaddd      %%ymm2,%%ymm4,%%ymm2          \n"  // 3*near+far (lo)
+      "vpaddd      %%ymm3,%%ymm5,%%ymm3          \n"  // 3*near+far (hi)
+
+      "vpaddd      %%ymm0,%%ymm0,%%ymm4          \n"  // 6*near+2*far (1, lo)
+      "vpaddd      %%ymm6,%%ymm2,%%ymm5          \n"  // 3*near+far+8 (2, lo)
+      "vpaddd      %%ymm4,%%ymm0,%%ymm4          \n"  // 9*near+3*far (1, lo)
+      "vpaddd      %%ymm4,%%ymm5,%%ymm4          \n"  // 9 3 3 1 + 8 (1, lo)
+      "vpsrld      $4,%%ymm4,%%ymm4              \n"  // ^ div by 16 (1, lo)
+
+      "vpaddd      %%ymm2,%%ymm2,%%ymm5          \n"  // 6*near+2*far (2, lo)
+      "vpaddd      %%ymm6,%%ymm0,%%ymm0          \n"  // 3*near+far+8 (1, lo)
+      "vpaddd      %%ymm5,%%ymm2,%%ymm5          \n"  // 9*near+3*far (2, lo)
+      "vpaddd      %%ymm5,%%ymm0,%%ymm5          \n"  // 9 3 3 1 + 8 (2, lo)
+      "vpsrld      $4,%%ymm5,%%ymm5              \n"  // ^ div by 16 (2, lo)
+
+      "vpaddd      %%ymm1,%%ymm1,%%ymm0          \n"  // 6*near+2*far (1, hi)
+      "vpaddd      %%ymm6,%%ymm3,%%ymm2          \n"  // 3*near+far+8 (2, hi)
+      "vpaddd      %%ymm0,%%ymm1,%%ymm0          \n"  // 9*near+3*far (1, hi)
+      "vpaddd      %%ymm0,%%ymm2,%%ymm0          \n"  // 9 3 3 1 + 8 (1, hi)
+      "vpsrld      $4,%%ymm0,%%ymm0              \n"  // ^ div by 16 (1, hi)
+
+      "vpaddd      %%ymm3,%%ymm3,%%ymm2          \n"  // 6*near+2*far (2, hi)
+      "vpaddd      %%ymm6,%%ymm1,%%ymm1          \n"  // 3*near+far+8 (1, hi)
+      "vpaddd      %%ymm2,%%ymm3,%%ymm2          \n"  // 9*near+3*far (2, hi)
+      "vpaddd      %%ymm2,%%ymm1,%%ymm2          \n"  // 9 3 3 1 + 8 (2, hi)
+      "vpsrld      $4,%%ymm2,%%ymm2              \n"  // ^ div by 16 (2, hi)
+
+      "vpackusdw   %%ymm0,%%ymm4,%%ymm4          \n"
+      "vmovdqu     %%ymm4,(%1)                   \n"  // store above
+      "vpackusdw   %%ymm2,%%ymm5,%%ymm5          \n"
+      "vmovdqu     %%ymm5,(%1,%4,2)              \n"  // store below
+
+      "lea         0x10(%0),%0                   \n"
+      "lea         0x20(%1),%1                   \n"  // 4 uv to 8 uv
+      "sub         $0x8,%2                       \n"
+      "jg          1b                            \n"
+      "vzeroupper                                \n"
+      : "+r"(src_ptr),                // %0
+        "+r"(dst_ptr),                // %1
+        "+r"(dst_width)               // %2
+      : "r"((intptr_t)(src_stride)),  // %3
+        "r"((intptr_t)(dst_stride))   // %4
+      : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6");
+}
+#endif
+
+#endif  // defined(__x86_64__) || defined(__i386__)
+
+#ifdef __cplusplus
+}  // extern "C"
+}  // namespace libyuv
+#endif
diff --git a/3rdparty/libyuv/src/source/scale_lsx.cc b/3rdparty/libyuv/src/source/scale_lsx.cc
new file mode 100644
index 00000000..bfe5e9fb
--- /dev/null
+++ b/3rdparty/libyuv/src/source/scale_lsx.cc
@@ -0,0 +1,739 @@
+/*
+ *  Copyright 2022 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Copyright (c) 2022 Loongson Technology Corporation Limited
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include <assert.h>
+
+#include "libyuv/scale_row.h"
+
+#if !defined(LIBYUV_DISABLE_LSX) && defined(__loongarch_sx)
+#include "libyuv/loongson_intrinsics.h"
+
+#ifdef __cplusplus
+namespace libyuv {
+extern "C" {
+#endif
+
+#define LOAD_DATA(_src, _in, _out)                                       \
+  {                                                                      \
+    int _tmp1, _tmp2, _tmp3, _tmp4;                                      \
+    DUP4_ARG2(__lsx_vpickve2gr_w, _in, 0, _in, 1, _in, 2, _in, 3, _tmp1, \
+              _tmp2, _tmp3, _tmp4);                                      \
+    _out = __lsx_vinsgr2vr_w(_out, _src[_tmp1], 0);                      \
+    _out = __lsx_vinsgr2vr_w(_out, _src[_tmp2], 1);                      \
+    _out = __lsx_vinsgr2vr_w(_out, _src[_tmp3], 2);                      \
+    _out = __lsx_vinsgr2vr_w(_out, _src[_tmp4], 3);                      \
+  }
+
+void ScaleARGBRowDown2_LSX(const uint8_t* src_argb,
+                           ptrdiff_t src_stride,
+                           uint8_t* dst_argb,
+                           int dst_width) {
+  int x;
+  int len = dst_width / 4;
+  (void)src_stride;
+  __m128i src0, src1, dst0;
+
+  for (x = 0; x < len; x++) {
+    DUP2_ARG2(__lsx_vld, src_argb, 0, src_argb, 16, src0, src1);
+    dst0 = __lsx_vpickod_w(src1, src0);
+    __lsx_vst(dst0, dst_argb, 0);
+    src_argb += 32;
+    dst_argb += 16;
+  }
+}
+
+void ScaleARGBRowDown2Linear_LSX(const uint8_t* src_argb,
+                                 ptrdiff_t src_stride,
+                                 uint8_t* dst_argb,
+                                 int dst_width) {
+  int x;
+  int len = dst_width / 4;
+  (void)src_stride;
+  __m128i src0, src1, tmp0, tmp1, dst0;
+
+  for (x = 0; x < len; x++) {
+    DUP2_ARG2(__lsx_vld, src_argb, 0, src_argb, 16, src0, src1);
+    tmp0 = __lsx_vpickev_w(src1, src0);
+    tmp1 = __lsx_vpickod_w(src1, src0);
+    dst0 = __lsx_vavgr_bu(tmp1, tmp0);
+    __lsx_vst(dst0, dst_argb, 0);
+    src_argb += 32;
+    dst_argb += 16;
+  }
+}
+
+void ScaleARGBRowDown2Box_LSX(const uint8_t* src_argb,
+                              ptrdiff_t src_stride,
+                              uint8_t* dst_argb,
+                              int dst_width) {
+  int x;
+  int len = dst_width / 4;
+  const uint8_t* s = src_argb;
+  const uint8_t* t = src_argb + src_stride;
+  __m128i src0, src1, src2, src3, tmp0, tmp1, tmp2, tmp3, dst0;
+  __m128i reg0, reg1, reg2, reg3;
+  __m128i shuff = {0x0703060205010400, 0x0F0B0E0A0D090C08};
+
+  for (x = 0; x < len; x++) {
+    DUP2_ARG2(__lsx_vld, s, 0, s, 16, src0, src1);
+    DUP2_ARG2(__lsx_vld, t, 0, t, 16, src2, src3);
+    DUP4_ARG3(__lsx_vshuf_b, src0, src0, shuff, src1, src1, shuff, src2, src2,
+              shuff, src3, src3, shuff, tmp0, tmp1, tmp2, tmp3);
+    DUP4_ARG2(__lsx_vhaddw_hu_bu, tmp0, tmp0, tmp1, tmp1, tmp2, tmp2, tmp3,
+              tmp3, reg0, reg1, reg2, reg3);
+    DUP2_ARG2(__lsx_vsadd_hu, reg0, reg2, reg1, reg3, reg0, reg1);
+    dst0 = __lsx_vsrarni_b_h(reg1, reg0, 2);
+    __lsx_vst(dst0, dst_argb, 0);
+    s += 32;
+    t += 32;
+    dst_argb += 16;
+  }
+}
+
+void ScaleARGBRowDownEven_LSX(const uint8_t* src_argb,
+                              ptrdiff_t src_stride,
+                              int32_t src_stepx,
+                              uint8_t* dst_argb,
+                              int dst_width) {
+  int x;
+  int len = dst_width / 4;
+  int32_t stepx = src_stepx << 2;
+  (void)src_stride;
+  __m128i dst0, dst1, dst2, dst3;
+
+  for (x = 0; x < len; x++) {
+    dst0 = __lsx_vldrepl_w(src_argb, 0);
+    src_argb += stepx;
+    dst1 = __lsx_vldrepl_w(src_argb, 0);
+    src_argb += stepx;
+    dst2 = __lsx_vldrepl_w(src_argb, 0);
+    src_argb += stepx;
+    dst3 = __lsx_vldrepl_w(src_argb, 0);
+    src_argb += stepx;
+    __lsx_vstelm_w(dst0, dst_argb, 0, 0);
+    __lsx_vstelm_w(dst1, dst_argb, 4, 0);
+    __lsx_vstelm_w(dst2, dst_argb, 8, 0);
+    __lsx_vstelm_w(dst3, dst_argb, 12, 0);
+    dst_argb += 16;
+  }
+}
+
+void ScaleARGBRowDownEvenBox_LSX(const uint8_t* src_argb,
+                                 ptrdiff_t src_stride,
+                                 int src_stepx,
+                                 uint8_t* dst_argb,
+                                 int dst_width) {
+  int x;
+  int len = dst_width / 4;
+  int32_t stepx = src_stepx * 4;
+  const uint8_t* next_argb = src_argb + src_stride;
+  __m128i src0, src1, src2, src3;
+  __m128i tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
+  __m128i reg0, reg1, dst0;
+
+  for (x = 0; x < len; x++) {
+    tmp0 = __lsx_vldrepl_d(src_argb, 0);
+    src_argb += stepx;
+    tmp1 = __lsx_vldrepl_d(src_argb, 0);
+    src_argb += stepx;
+    tmp2 = __lsx_vldrepl_d(src_argb, 0);
+    src_argb += stepx;
+    tmp3 = __lsx_vldrepl_d(src_argb, 0);
+    src_argb += stepx;
+    tmp4 = __lsx_vldrepl_d(next_argb, 0);
+    next_argb += stepx;
+    tmp5 = __lsx_vldrepl_d(next_argb, 0);
+    next_argb += stepx;
+    tmp6 = __lsx_vldrepl_d(next_argb, 0);
+    next_argb += stepx;
+    tmp7 = __lsx_vldrepl_d(next_argb, 0);
+    next_argb += stepx;
+    DUP4_ARG2(__lsx_vilvl_d, tmp1, tmp0, tmp3, tmp2, tmp5, tmp4, tmp7, tmp6,
+              src0, src1, src2, src3);
+    DUP2_ARG2(__lsx_vaddwev_h_bu, src0, src2, src1, src3, tmp0, tmp2);
+    DUP2_ARG2(__lsx_vaddwod_h_bu, src0, src2, src1, src3, tmp1, tmp3);
+    DUP2_ARG2(__lsx_vpackev_w, tmp1, tmp0, tmp3, tmp2, reg0, reg1);
+    DUP2_ARG2(__lsx_vpackod_w, tmp1, tmp0, tmp3, tmp2, tmp4, tmp5);
+    DUP2_ARG2(__lsx_vadd_h, reg0, tmp4, reg1, tmp5, reg0, reg1);
+    dst0 = __lsx_vsrarni_b_h(reg1, reg0, 2);
+    dst0 = __lsx_vshuf4i_b(dst0, 0xD8);
+    __lsx_vst(dst0, dst_argb, 0);
+    dst_argb += 16;
+  }
+}
+
+void ScaleRowDown2_LSX(const uint8_t* src_ptr,
+                       ptrdiff_t src_stride,
+                       uint8_t* dst,
+                       int dst_width) {
+  int x;
+  int len = dst_width / 32;
+  __m128i src0, src1, src2, src3, dst0, dst1;
+  (void)src_stride;
+
+  for (x = 0; x < len; x++) {
+    DUP4_ARG2(__lsx_vld, src_ptr, 0, src_ptr, 16, src_ptr, 32, src_ptr, 48,
+              src0, src1, src2, src3);
+    DUP2_ARG2(__lsx_vpickod_b, src1, src0, src3, src2, dst0, dst1);
+    __lsx_vst(dst0, dst, 0);
+    __lsx_vst(dst1, dst, 16);
+    src_ptr += 64;
+    dst += 32;
+  }
+}
+
+void ScaleRowDown2Linear_LSX(const uint8_t* src_ptr,
+                             ptrdiff_t src_stride,
+                             uint8_t* dst,
+                             int dst_width) {
+  int x;
+  int len = dst_width / 32;
+  __m128i src0, src1, src2, src3;
+  __m128i tmp0, tmp1, tmp2, tmp3, dst0, dst1;
+  (void)src_stride;
+
+  for (x = 0; x < len; x++) {
+    DUP4_ARG2(__lsx_vld, src_ptr, 0, src_ptr, 16, src_ptr, 32, src_ptr, 48,
+              src0, src1, src2, src3);
+    DUP2_ARG2(__lsx_vpickev_b, src1, src0, src3, src2, tmp0, tmp2);
+    DUP2_ARG2(__lsx_vpickod_b, src1, src0, src3, src2, tmp1, tmp3);
+    DUP2_ARG2(__lsx_vavgr_bu, tmp0, tmp1, tmp2, tmp3, dst0, dst1);
+    __lsx_vst(dst0, dst, 0);
+    __lsx_vst(dst1, dst, 16);
+    src_ptr += 64;
+    dst += 32;
+  }
+}
+
+void ScaleRowDown2Box_LSX(const uint8_t* src_ptr,
+                          ptrdiff_t src_stride,
+                          uint8_t* dst,
+                          int dst_width) {
+  int x;
+  int len = dst_width / 32;
+  const uint8_t* src_nex = src_ptr + src_stride;
+  __m128i src0, src1, src2, src3, src4, src5, src6, src7;
+  __m128i tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
+  __m128i dst0, dst1;
+
+  for (x = 0; x < len; x++) {
+    DUP4_ARG2(__lsx_vld, src_ptr, 0, src_ptr, 16, src_ptr, 32, src_ptr, 48,
+              src0, src1, src2, src3);
+    DUP4_ARG2(__lsx_vld, src_nex, 0, src_nex, 16, src_nex, 32, src_nex, 48,
+              src4, src5, src6, src7);
+    DUP4_ARG2(__lsx_vaddwev_h_bu, src0, src4, src1, src5, src2, src6, src3,
+              src7, tmp0, tmp2, tmp4, tmp6);
+    DUP4_ARG2(__lsx_vaddwod_h_bu, src0, src4, src1, src5, src2, src6, src3,
+              src7, tmp1, tmp3, tmp5, tmp7);
+    DUP4_ARG2(__lsx_vadd_h, tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7,
+              tmp0, tmp1, tmp2, tmp3);
+    DUP2_ARG3(__lsx_vsrarni_b_h, tmp1, tmp0, 2, tmp3, tmp2, 2, dst0, dst1);
+    __lsx_vst(dst0, dst, 0);
+    __lsx_vst(dst1, dst, 16);
+    src_ptr += 64;
+    src_nex += 64;
+    dst += 32;
+  }
+}
+
+void ScaleRowDown4_LSX(const uint8_t* src_ptr,
+                       ptrdiff_t src_stride,
+                       uint8_t* dst,
+                       int dst_width) {
+  int x;
+  int len = dst_width / 16;
+  __m128i src0, src1, src2, src3, tmp0, tmp1, dst0;
+  (void)src_stride;
+
+  for (x = 0; x < len; x++) {
+    DUP4_ARG2(__lsx_vld, src_ptr, 0, src_ptr, 16, src_ptr, 32, src_ptr, 48,
+              src0, src1, src2, src3);
+    DUP2_ARG2(__lsx_vpickev_b, src1, src0, src3, src2, tmp0, tmp1);
+    dst0 = __lsx_vpickod_b(tmp1, tmp0);
+    __lsx_vst(dst0, dst, 0);
+    src_ptr += 64;
+    dst += 16;
+  }
+}
+
+void ScaleRowDown4Box_LSX(const uint8_t* src_ptr,
+                          ptrdiff_t src_stride,
+                          uint8_t* dst,
+                          int dst_width) {
+  int x;
+  int len = dst_width / 16;
+  const uint8_t* ptr1 = src_ptr + src_stride;
+  const uint8_t* ptr2 = ptr1 + src_stride;
+  const uint8_t* ptr3 = ptr2 + src_stride;
+  __m128i src0, src1, src2, src3, src4, src5, src6, src7;
+  __m128i tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
+  __m128i reg0, reg1, reg2, reg3, reg4, reg5, reg6, reg7, dst0;
+
+  for (x = 0; x < len; x++) {
+    DUP4_ARG2(__lsx_vld, src_ptr, 0, src_ptr, 16, src_ptr, 32, src_ptr, 48,
+              src0, src1, src2, src3);
+    DUP4_ARG2(__lsx_vld, ptr1, 0, ptr1, 16, ptr1, 32, ptr1, 48, src4, src5,
+              src6, src7);
+    DUP4_ARG2(__lsx_vaddwev_h_bu, src0, src4, src1, src5, src2, src6, src3,
+              src7, tmp0, tmp2, tmp4, tmp6);
+    DUP4_ARG2(__lsx_vaddwod_h_bu, src0, src4, src1, src5, src2, src6, src3,
+              src7, tmp1, tmp3, tmp5, tmp7);
+    DUP4_ARG2(__lsx_vadd_h, tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7,
+              reg0, reg1, reg2, reg3);
+    DUP4_ARG2(__lsx_vld, ptr2, 0, ptr2, 16, ptr2, 32, ptr2, 48, src0, src1,
+              src2, src3);
+    DUP4_ARG2(__lsx_vld, ptr3, 0, ptr3, 16, ptr3, 32, ptr3, 48, src4, src5,
+              src6, src7);
+    DUP4_ARG2(__lsx_vaddwev_h_bu, src0, src4, src1, src5, src2, src6, src3,
+              src7, tmp0, tmp2, tmp4, tmp6);
+    DUP4_ARG2(__lsx_vaddwod_h_bu, src0, src4, src1, src5, src2, src6, src3,
+              src7, tmp1, tmp3, tmp5, tmp7);
+    DUP4_ARG2(__lsx_vadd_h, tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7,
+              reg4, reg5, reg6, reg7);
+    DUP4_ARG2(__lsx_vadd_h, reg0, reg4, reg1, reg5, reg2, reg6, reg3, reg7,
+              reg0, reg1, reg2, reg3);
+    DUP4_ARG2(__lsx_vhaddw_wu_hu, reg0, reg0, reg1, reg1, reg2, reg2, reg3,
+              reg3, reg0, reg1, reg2, reg3);
+    DUP2_ARG3(__lsx_vsrarni_h_w, reg1, reg0, 4, reg3, reg2, 4, tmp0, tmp1);
+    dst0 = __lsx_vpickev_b(tmp1, tmp0);
+    __lsx_vst(dst0, dst, 0);
+    src_ptr += 64;
+    ptr1 += 64;
+    ptr2 += 64;
+    ptr3 += 64;
+    dst += 16;
+  }
+}
+
+void ScaleRowDown38_LSX(const uint8_t* src_ptr,
+                        ptrdiff_t src_stride,
+                        uint8_t* dst,
+                        int dst_width) {
+  int x, len;
+  __m128i src0, src1, tmp0;
+  __m128i shuff = {0x13100E0B08060300, 0x000000001E1B1816};
+
+  assert(dst_width % 3 == 0);
+  len = dst_width / 12;
+  (void)src_stride;
+
+  for (x = 0; x < len; x++) {
+    DUP2_ARG2(__lsx_vld, src_ptr, 0, src_ptr, 16, src0, src1);
+    tmp0 = __lsx_vshuf_b(src1, src0, shuff);
+    __lsx_vstelm_d(tmp0, dst, 0, 0);
+    __lsx_vstelm_w(tmp0, dst, 8, 2);
+    src_ptr += 32;
+    dst += 12;
+  }
+}
+
+void ScaleRowDown38_2_Box_LSX(const uint8_t* src_ptr,
+                              ptrdiff_t src_stride,
+                              uint8_t* dst_ptr,
+                              int dst_width) {
+  int x, len;
+  const uint8_t* src_nex = src_ptr + src_stride;
+  __m128i src0, src1, src2, src3, dst0;
+  __m128i tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
+  __m128i reg0, reg1, reg2, reg3;
+  __m128i shuff = {0x0A08160604120200, 0x000000001E0E0C1A};
+  __m128i const_0x2AAA = __lsx_vreplgr2vr_h(0x2AAA);
+  __m128i const_0x4000 = __lsx_vreplgr2vr_w(0x4000);
+
+  assert((dst_width % 3 == 0) && (dst_width > 0));
+  len = dst_width / 12;
+
+  for (x = 0; x < len; x++) {
+    DUP4_ARG2(__lsx_vld, src_ptr, 0, src_ptr, 16, src_nex, 0, src_nex, 16, src0,
+              src1, src2, src3);
+    DUP2_ARG2(__lsx_vaddwev_h_bu, src0, src2, src1, src3, tmp0, tmp2);
+    DUP2_ARG2(__lsx_vaddwod_h_bu, src0, src2, src1, src3, tmp1, tmp3);
+    DUP2_ARG2(__lsx_vpickev_h, tmp2, tmp0, tmp3, tmp1, reg0, reg1);
+    DUP2_ARG2(__lsx_vpackod_h, tmp1, tmp0, tmp3, tmp2, reg2, reg3);
+    tmp4 = __lsx_vpickev_w(reg3, reg2);
+    tmp5 = __lsx_vadd_h(reg0, reg1);
+    tmp6 = __lsx_vadd_h(tmp5, tmp4);
+    tmp7 = __lsx_vmuh_h(tmp6, const_0x2AAA);
+    tmp0 = __lsx_vpickod_w(reg3, reg2);
+    tmp1 = __lsx_vhaddw_wu_hu(tmp0, tmp0);
+    tmp2 = __lsx_vmul_w(tmp1, const_0x4000);
+    dst0 = __lsx_vshuf_b(tmp2, tmp7, shuff);
+    __lsx_vstelm_d(dst0, dst_ptr, 0, 0);
+    __lsx_vstelm_w(dst0, dst_ptr, 8, 2);
+    src_ptr += 32;
+    src_nex += 32;
+    dst_ptr += 12;
+  }
+}
+
+void ScaleRowDown38_3_Box_LSX(const uint8_t* src_ptr,
+                              ptrdiff_t src_stride,
+                              uint8_t* dst_ptr,
+                              int dst_width) {
+  int x, len;
+  const uint8_t* ptr1 = src_ptr + src_stride;
+  const uint8_t* ptr2 = ptr1 + src_stride;
+  __m128i src0, src1, src2, src3, src4, src5;
+  __m128i tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
+  __m128i reg0, reg1, reg2, reg3, dst0;
+  __m128i zero = __lsx_vldi(0);
+  __m128i shuff = {0x0A08160604120200, 0x000000001E0E0C1A};
+  __m128i const_0x1C71 = __lsx_vreplgr2vr_h(0x1C71);
+  __m128i const_0x2AAA = __lsx_vreplgr2vr_w(0x2AAA);
+
+  assert((dst_width % 3 == 0) && (dst_width > 0));
+  len = dst_width / 12;
+
+  for (x = 0; x < len; x++) {
+    DUP4_ARG2(__lsx_vld, src_ptr, 0, src_ptr, 16, ptr1, 0, ptr1, 16, src0, src1,
+              src2, src3);
+    DUP2_ARG2(__lsx_vld, ptr2, 0, ptr2, 16, src4, src5);
+    DUP2_ARG2(__lsx_vaddwev_h_bu, src0, src2, src1, src3, tmp0, tmp2);
+    DUP2_ARG2(__lsx_vaddwod_h_bu, src0, src2, src1, src3, tmp1, tmp3);
+    DUP2_ARG2(__lsx_vpackev_b, zero, src4, zero, src5, tmp4, tmp6);
+    DUP2_ARG2(__lsx_vpackod_b, zero, src4, zero, src5, tmp5, tmp7);
+    DUP4_ARG2(__lsx_vadd_h, tmp0, tmp4, tmp1, tmp5, tmp2, tmp6, tmp3, tmp7,
+              tmp0, tmp1, tmp2, tmp3);
+    DUP2_ARG2(__lsx_vpickev_h, tmp2, tmp0, tmp3, tmp1, reg0, reg1);
+    DUP2_ARG2(__lsx_vpackod_h, tmp1, tmp0, tmp3, tmp2, reg2, reg3);
+    tmp4 = __lsx_vpickev_w(reg3, reg2);
+    tmp5 = __lsx_vadd_h(reg0, reg1);
+    tmp6 = __lsx_vadd_h(tmp5, tmp4);
+    tmp7 = __lsx_vmuh_h(tmp6, const_0x1C71);
+    tmp0 = __lsx_vpickod_w(reg3, reg2);
+    tmp1 = __lsx_vhaddw_wu_hu(tmp0, tmp0);
+    tmp2 = __lsx_vmul_w(tmp1, const_0x2AAA);
+    dst0 = __lsx_vshuf_b(tmp2, tmp7, shuff);
+    __lsx_vstelm_d(dst0, dst_ptr, 0, 0);
+    __lsx_vstelm_w(dst0, dst_ptr, 8, 2);
+    src_ptr += 32;
+    ptr1 += 32;
+    ptr2 += 32;
+    dst_ptr += 12;
+  }
+}
+
+void ScaleAddRow_LSX(const uint8_t* src_ptr, uint16_t* dst_ptr, int src_width) {
+  int x;
+  int len = src_width / 16;
+  __m128i src0, tmp0, tmp1, dst0, dst1;
+  __m128i zero = __lsx_vldi(0);
+
+  assert(src_width > 0);
+
+  for (x = 0; x < len; x++) {
+    src0 = __lsx_vld(src_ptr, 0);
+    DUP2_ARG2(__lsx_vld, dst_ptr, 0, dst_ptr, 16, dst0, dst1);
+    tmp0 = __lsx_vilvl_b(zero, src0);
+    tmp1 = __lsx_vilvh_b(zero, src0);
+    DUP2_ARG2(__lsx_vadd_h, dst0, tmp0, dst1, tmp1, dst0, dst1);
+    __lsx_vst(dst0, dst_ptr, 0);
+    __lsx_vst(dst1, dst_ptr, 16);
+    src_ptr += 16;
+    dst_ptr += 16;
+  }
+}
+
+void ScaleFilterCols_LSX(uint8_t* dst_ptr,
+                         const uint8_t* src_ptr,
+                         int dst_width,
+                         int x,
+                         int dx) {
+  int j;
+  int len = dst_width / 16;
+  __m128i tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
+  __m128i reg0, reg1, reg2, reg3, reg4, reg5, reg6, reg7;
+  __m128i vec0, vec1, dst0;
+  __m128i vec_x = __lsx_vreplgr2vr_w(x);
+  __m128i vec_dx = __lsx_vreplgr2vr_w(dx);
+  __m128i const1 = __lsx_vreplgr2vr_w(0xFFFF);
+  __m128i const2 = __lsx_vreplgr2vr_w(0x40);
+  __m128i const_tmp = {0x0000000100000000, 0x0000000300000002};
+
+  vec0 = __lsx_vmul_w(vec_dx, const_tmp);
+  vec1 = __lsx_vslli_w(vec_dx, 2);
+  vec_x = __lsx_vadd_w(vec_x, vec0);
+
+  for (j = 0; j < len; j++) {
+    tmp0 = __lsx_vsrai_w(vec_x, 16);
+    tmp4 = __lsx_vand_v(vec_x, const1);
+    vec_x = __lsx_vadd_w(vec_x, vec1);
+    tmp1 = __lsx_vsrai_w(vec_x, 16);
+    tmp5 = __lsx_vand_v(vec_x, const1);
+    vec_x = __lsx_vadd_w(vec_x, vec1);
+    tmp2 = __lsx_vsrai_w(vec_x, 16);
+    tmp6 = __lsx_vand_v(vec_x, const1);
+    vec_x = __lsx_vadd_w(vec_x, vec1);
+    tmp3 = __lsx_vsrai_w(vec_x, 16);
+    tmp7 = __lsx_vand_v(vec_x, const1);
+    vec_x = __lsx_vadd_w(vec_x, vec1);
+    DUP4_ARG2(__lsx_vsrai_w, tmp4, 9, tmp5, 9, tmp6, 9, tmp7, 9, tmp4, tmp5,
+              tmp6, tmp7);
+    LOAD_DATA(src_ptr, tmp0, reg0);
+    LOAD_DATA(src_ptr, tmp1, reg1);
+    LOAD_DATA(src_ptr, tmp2, reg2);
+    LOAD_DATA(src_ptr, tmp3, reg3);
+    DUP4_ARG2(__lsx_vaddi_wu, tmp0, 1, tmp1, 1, tmp2, 1, tmp3, 1, tmp0, tmp1,
+              tmp2, tmp3);
+    LOAD_DATA(src_ptr, tmp0, reg4);
+    LOAD_DATA(src_ptr, tmp1, reg5);
+    LOAD_DATA(src_ptr, tmp2, reg6);
+    LOAD_DATA(src_ptr, tmp3, reg7);
+    DUP4_ARG2(__lsx_vsub_w, reg4, reg0, reg5, reg1, reg6, reg2, reg7, reg3,
+              reg4, reg5, reg6, reg7);
+    DUP4_ARG2(__lsx_vmul_w, reg4, tmp4, reg5, tmp5, reg6, tmp6, reg7, tmp7,
+              reg4, reg5, reg6, reg7);
+    DUP4_ARG2(__lsx_vadd_w, reg4, const2, reg5, const2, reg6, const2, reg7,
+              const2, reg4, reg5, reg6, reg7);
+    DUP4_ARG2(__lsx_vsrai_w, reg4, 7, reg5, 7, reg6, 7, reg7, 7, reg4, reg5,
+              reg6, reg7);
+    DUP4_ARG2(__lsx_vadd_w, reg0, reg4, reg1, reg5, reg2, reg6, reg3, reg7,
+              reg0, reg1, reg2, reg3);
+    DUP2_ARG2(__lsx_vpickev_h, reg1, reg0, reg3, reg2, tmp0, tmp1);
+    dst0 = __lsx_vpickev_b(tmp1, tmp0);
+    __lsx_vst(dst0, dst_ptr, 0);
+    dst_ptr += 16;
+  }
+}
+
+void ScaleARGBCols_LSX(uint8_t* dst_argb,
+                       const uint8_t* src_argb,
+                       int dst_width,
+                       int x,
+                       int dx) {
+  const uint32_t* src = (const uint32_t*)src_argb;
+  uint32_t* dst = (uint32_t*)dst_argb;
+  int j;
+  int len = dst_width / 4;
+  __m128i tmp0, tmp1, tmp2, dst0;
+  __m128i vec_x = __lsx_vreplgr2vr_w(x);
+  __m128i vec_dx = __lsx_vreplgr2vr_w(dx);
+  __m128i const_tmp = {0x0000000100000000, 0x0000000300000002};
+
+  tmp0 = __lsx_vmul_w(vec_dx, const_tmp);
+  tmp1 = __lsx_vslli_w(vec_dx, 2);
+  vec_x = __lsx_vadd_w(vec_x, tmp0);
+
+  for (j = 0; j < len; j++) {
+    tmp2 = __lsx_vsrai_w(vec_x, 16);
+    vec_x = __lsx_vadd_w(vec_x, tmp1);
+    LOAD_DATA(src, tmp2, dst0);
+    __lsx_vst(dst0, dst, 0);
+    dst += 4;
+  }
+}
+
+void ScaleARGBFilterCols_LSX(uint8_t* dst_argb,
+                             const uint8_t* src_argb,
+                             int dst_width,
+                             int x,
+                             int dx) {
+  const uint32_t* src = (const uint32_t*)src_argb;
+  int j;
+  int len = dst_width / 8;
+  __m128i src0, src1, src2, src3;
+  __m128i tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
+  __m128i reg0, reg1, reg2, reg3, reg4, reg5, reg6, reg7;
+  __m128i vec0, vec1, dst0, dst1;
+  __m128i vec_x = __lsx_vreplgr2vr_w(x);
+  __m128i vec_dx = __lsx_vreplgr2vr_w(dx);
+  __m128i const_tmp = {0x0000000100000000, 0x0000000300000002};
+  __m128i const_7f = __lsx_vldi(0x7F);
+
+  vec0 = __lsx_vmul_w(vec_dx, const_tmp);
+  vec1 = __lsx_vslli_w(vec_dx, 2);
+  vec_x = __lsx_vadd_w(vec_x, vec0);
+
+  for (j = 0; j < len; j++) {
+    tmp0 = __lsx_vsrai_w(vec_x, 16);
+    reg0 = __lsx_vsrai_w(vec_x, 9);
+    vec_x = __lsx_vadd_w(vec_x, vec1);
+    tmp1 = __lsx_vsrai_w(vec_x, 16);
+    reg1 = __lsx_vsrai_w(vec_x, 9);
+    vec_x = __lsx_vadd_w(vec_x, vec1);
+    DUP2_ARG2(__lsx_vand_v, reg0, const_7f, reg1, const_7f, reg0, reg1);
+    DUP2_ARG2(__lsx_vshuf4i_b, reg0, 0, reg1, 0, reg0, reg1);
+    DUP2_ARG2(__lsx_vxor_v, reg0, const_7f, reg1, const_7f, reg2, reg3);
+    DUP2_ARG2(__lsx_vilvl_b, reg0, reg2, reg1, reg3, reg4, reg6);
+    DUP2_ARG2(__lsx_vilvh_b, reg0, reg2, reg1, reg3, reg5, reg7);
+    LOAD_DATA(src, tmp0, src0);
+    LOAD_DATA(src, tmp1, src1);
+    DUP2_ARG2(__lsx_vaddi_wu, tmp0, 1, tmp1, 1, tmp0, tmp1);
+    LOAD_DATA(src, tmp0, src2);
+    LOAD_DATA(src, tmp1, src3);
+    DUP2_ARG2(__lsx_vilvl_b, src2, src0, src3, src1, tmp4, tmp6);
+    DUP2_ARG2(__lsx_vilvh_b, src2, src0, src3, src1, tmp5, tmp7);
+    DUP4_ARG2(__lsx_vdp2_h_bu, tmp4, reg4, tmp5, reg5, tmp6, reg6, tmp7, reg7,
+              tmp0, tmp1, tmp2, tmp3);
+    DUP2_ARG3(__lsx_vsrani_b_h, tmp1, tmp0, 7, tmp3, tmp2, 7, dst0, dst1);
+    __lsx_vst(dst0, dst_argb, 0);
+    __lsx_vst(dst1, dst_argb, 16);
+    dst_argb += 32;
+  }
+}
+
+void ScaleRowDown34_LSX(const uint8_t* src_ptr,
+                        ptrdiff_t src_stride,
+                        uint8_t* dst,
+                        int dst_width) {
+  int x;
+  (void)src_stride;
+  __m128i src0, src1, src2, src3;
+  __m128i dst0, dst1, dst2;
+  __m128i shuff0 = {0x0908070504030100, 0x141311100F0D0C0B};
+  __m128i shuff1 = {0x0F0D0C0B09080705, 0x1918171514131110};
+  __m128i shuff2 = {0x141311100F0D0C0B, 0x1F1D1C1B19181715};
+
+  assert((dst_width % 3 == 0) && (dst_width > 0));
+
+  for (x = 0; x < dst_width; x += 48) {
+    DUP4_ARG2(__lsx_vld, src_ptr, 0, src_ptr, 16, src_ptr, 32, src_ptr, 48,
+              src0, src1, src2, src3);
+    DUP2_ARG3(__lsx_vshuf_b, src1, src0, shuff0, src2, src1, shuff1, dst0,
+              dst1);
+    dst2 = __lsx_vshuf_b(src3, src2, shuff2);
+    __lsx_vst(dst0, dst, 0);
+    __lsx_vst(dst1, dst, 16);
+    __lsx_vst(dst2, dst, 32);
+    src_ptr += 64;
+    dst += 48;
+  }
+}
+
+void ScaleRowDown34_0_Box_LSX(const uint8_t* src_ptr,
+                              ptrdiff_t src_stride,
+                              uint8_t* d,
+                              int dst_width) {
+  const uint8_t* src_nex = src_ptr + src_stride;
+  int x;
+  __m128i src0, src1, src2, src3, src4, src5, src6, src7;
+  __m128i tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7, tmp8, tmp9;
+  __m128i tmp10, tmp11, dst0, dst1, dst2;
+  __m128i const0 = {0x0103030101010103, 0x0101010303010101};
+  __m128i const1 = {0x0301010101030301, 0x0103030101010103};
+  __m128i const2 = {0x0101010303010101, 0x0301010101030301};
+  __m128i shuff0 = {0x0504030202010100, 0x0A09090807060605};
+  __m128i shuff1 = {0x0F0E0E0D0D0C0B0A, 0x1514131212111110};
+  __m128i shuff2 = {0x0A09090807060605, 0x0F0E0E0D0D0C0B0A};
+  __m128i shift0 = {0x0002000200010002, 0x0001000200020001};
+  __m128i shift1 = {0x0002000100020002, 0x0002000200010002};
+  __m128i shift2 = {0x0001000200020001, 0x0002000100020002};
+
+  assert((dst_width % 3 == 0) && (dst_width > 0));
+
+  for (x = 0; x < dst_width; x += 48) {
+    DUP4_ARG2(__lsx_vld, src_ptr, 0, src_ptr, 16, src_ptr, 32, src_ptr, 48,
+              src0, src1, src2, src3);
+    DUP4_ARG2(__lsx_vld, src_nex, 0, src_nex, 16, src_nex, 32, src_nex, 48,
+              src4, src5, src6, src7);
+    DUP4_ARG3(__lsx_vshuf_b, src0, src0, shuff0, src1, src0, shuff1, src1, src1,
+              shuff2, src2, src2, shuff0, tmp0, tmp1, tmp2, tmp3);
+    DUP4_ARG3(__lsx_vshuf_b, src3, src2, shuff1, src3, src3, shuff2, src4, src4,
+              shuff0, src5, src4, shuff1, tmp4, tmp5, tmp6, tmp7);
+    DUP4_ARG3(__lsx_vshuf_b, src5, src5, shuff2, src6, src6, shuff0, src7, src6,
+              shuff1, src7, src7, shuff2, tmp8, tmp9, tmp10, tmp11);
+    DUP4_ARG2(__lsx_vdp2_h_bu, tmp0, const0, tmp1, const1, tmp2, const2, tmp3,
+              const0, src0, src1, src2, src3);
+    DUP4_ARG2(__lsx_vdp2_h_bu, tmp4, const1, tmp5, const2, tmp6, const0, tmp7,
+              const1, src4, src5, src6, src7);
+    DUP4_ARG2(__lsx_vdp2_h_bu, tmp8, const2, tmp9, const0, tmp10, const1, tmp11,
+              const2, tmp0, tmp1, tmp2, tmp3);
+    DUP4_ARG2(__lsx_vsrar_h, src0, shift0, src1, shift1, src2, shift2, src3,
+              shift0, src0, src1, src2, src3);
+    DUP4_ARG2(__lsx_vsrar_h, src4, shift1, src5, shift2, src6, shift0, src7,
+              shift1, src4, src5, src6, src7);
+    DUP4_ARG2(__lsx_vsrar_h, tmp0, shift2, tmp1, shift0, tmp2, shift1, tmp3,
+              shift2, tmp0, tmp1, tmp2, tmp3);
+    DUP4_ARG2(__lsx_vslli_h, src0, 1, src1, 1, src2, 1, src3, 1, tmp5, tmp6,
+              tmp7, tmp8);
+    DUP2_ARG2(__lsx_vslli_h, src4, 1, src5, 1, tmp9, tmp10);
+    DUP4_ARG2(__lsx_vadd_h, src0, tmp5, src1, tmp6, src2, tmp7, src3, tmp8,
+              src0, src1, src2, src3);
+    DUP2_ARG2(__lsx_vadd_h, src4, tmp9, src5, tmp10, src4, src5);
+    DUP4_ARG2(__lsx_vadd_h, src0, src6, src1, src7, src2, tmp0, src3, tmp1,
+              src0, src1, src2, src3);
+    DUP2_ARG2(__lsx_vadd_h, src4, tmp2, src5, tmp3, src4, src5);
+    DUP2_ARG3(__lsx_vsrarni_b_h, src1, src0, 2, src3, src2, 2, dst0, dst1);
+    dst2 = __lsx_vsrarni_b_h(src5, src4, 2);
+    __lsx_vst(dst0, d, 0);
+    __lsx_vst(dst1, d, 16);
+    __lsx_vst(dst2, d, 32);
+    src_ptr += 64;
+    src_nex += 64;
+    d += 48;
+  }
+}
+
+void ScaleRowDown34_1_Box_LSX(const uint8_t* src_ptr,
+                              ptrdiff_t src_stride,
+                              uint8_t* d,
+                              int dst_width) {
+  const uint8_t* src_nex = src_ptr + src_stride;
+  int x;
+  __m128i src0, src1, src2, src3, src4, src5, src6, src7;
+  __m128i tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7, tmp8, tmp9;
+  __m128i tmp10, tmp11, dst0, dst1, dst2;
+  __m128i const0 = {0x0103030101010103, 0x0101010303010101};
+  __m128i const1 = {0x0301010101030301, 0x0103030101010103};
+  __m128i const2 = {0x0101010303010101, 0x0301010101030301};
+  __m128i shuff0 = {0x0504030202010100, 0x0A09090807060605};
+  __m128i shuff1 = {0x0F0E0E0D0D0C0B0A, 0x1514131212111110};
+  __m128i shuff2 = {0x0A09090807060605, 0x0F0E0E0D0D0C0B0A};
+  __m128i shift0 = {0x0002000200010002, 0x0001000200020001};
+  __m128i shift1 = {0x0002000100020002, 0x0002000200010002};
+  __m128i shift2 = {0x0001000200020001, 0x0002000100020002};
+
+  assert((dst_width % 3 == 0) && (dst_width > 0));
+
+  for (x = 0; x < dst_width; x += 48) {
+    DUP4_ARG2(__lsx_vld, src_ptr, 0, src_ptr, 16, src_ptr, 32, src_ptr, 48,
+              src0, src1, src2, src3);
+    DUP4_ARG2(__lsx_vld, src_nex, 0, src_nex, 16, src_nex, 32, src_nex, 48,
+              src4, src5, src6, src7);
+    DUP4_ARG3(__lsx_vshuf_b, src0, src0, shuff0, src1, src0, shuff1, src1, src1,
+              shuff2, src2, src2, shuff0, tmp0, tmp1, tmp2, tmp3);
+    DUP4_ARG3(__lsx_vshuf_b, src3, src2, shuff1, src3, src3, shuff2, src4, src4,
+              shuff0, src5, src4, shuff1, tmp4, tmp5, tmp6, tmp7);
+    DUP4_ARG3(__lsx_vshuf_b, src5, src5, shuff2, src6, src6, shuff0, src7, src6,
+              shuff1, src7, src7, shuff2, tmp8, tmp9, tmp10, tmp11);
+    DUP4_ARG2(__lsx_vdp2_h_bu, tmp0, const0, tmp1, const1, tmp2, const2, tmp3,
+              const0, src0, src1, src2, src3);
+    DUP4_ARG2(__lsx_vdp2_h_bu, tmp4, const1, tmp5, const2, tmp6, const0, tmp7,
+              const1, src4, src5, src6, src7);
+    DUP4_ARG2(__lsx_vdp2_h_bu, tmp8, const2, tmp9, const0, tmp10, const1, tmp11,
+              const2, tmp0, tmp1, tmp2, tmp3);
+    DUP4_ARG2(__lsx_vsrar_h, src0, shift0, src1, shift1, src2, shift2, src3,
+              shift0, src0, src1, src2, src3);
+    DUP4_ARG2(__lsx_vsrar_h, src4, shift1, src5, shift2, src6, shift0, src7,
+              shift1, src4, src5, src6, src7);
+    DUP4_ARG2(__lsx_vsrar_h, tmp0, shift2, tmp1, shift0, tmp2, shift1, tmp3,
+              shift2, tmp0, tmp1, tmp2, tmp3);
+    DUP4_ARG2(__lsx_vadd_h, src0, src6, src1, src7, src2, tmp0, src3, tmp1,
+              src0, src1, src2, src3);
+    DUP2_ARG2(__lsx_vadd_h, src4, tmp2, src5, tmp3, src4, src5);
+    DUP2_ARG3(__lsx_vsrarni_b_h, src1, src0, 1, src3, src2, 1, dst0, dst1);
+    dst2 = __lsx_vsrarni_b_h(src5, src4, 1);
+    __lsx_vst(dst0, d, 0);
+    __lsx_vst(dst1, d, 16);
+    __lsx_vst(dst2, d, 32);
+    src_ptr += 64;
+    src_nex += 64;
+    d += 48;
+  }
+}
+
+#ifdef __cplusplus
+}  // extern "C"
+}  // namespace libyuv
+#endif
+
+#endif  // !defined(LIBYUV_DISABLE_LSX) && defined(__loongarch_sx)
diff --git a/3rdparty/libyuv/src/source/scale_mmi.cc b/3rdparty/libyuv/src/source/scale_mmi.cc
new file mode 100644
index 00000000..1226ef3e
--- /dev/null
+++ b/3rdparty/libyuv/src/source/scale_mmi.cc
@@ -0,0 +1,1168 @@
+/*
+ *  Copyright 2013 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include "libyuv/scale.h"
+
+#include <assert.h>
+#include <string.h>
+
+#include "libyuv/cpu_id.h"
+#include "libyuv/planar_functions.h"  // For CopyARGB
+#include "libyuv/row.h"
+#include "libyuv/scale_row.h"
+
+#ifdef __cplusplus
+namespace libyuv {
+extern "C" {
+#endif
+
+// This module is for Mips MMI.
+#if !defined(LIBYUV_DISABLE_MMI) && defined(_MIPS_ARCH_LOONGSON3A)
+
+// clang-format off
+
+// CPU agnostic row functions
+void ScaleRowDown2_MMI(const uint8_t* src_ptr,
+                       ptrdiff_t src_stride,
+                       uint8_t* dst,
+                       int dst_width) {
+  (void)src_stride;
+
+  uint64_t src0, src1, dest;
+  const uint64_t shift = 0x8ULL;
+
+  __asm__ volatile(
+      "1:                                                           \n\t"
+      "gsldrc1    %[src0],         0x00(%[src_ptr])                 \n\t"
+      "gsldlc1    %[src0],         0x07(%[src_ptr])                 \n\t"
+      "psrlh      %[src0],         %[src0],           %[shift]      \n\t"
+
+      "gsldrc1    %[src1],         0x08(%[src_ptr])                 \n\t"
+      "gsldlc1    %[src1],         0x0f(%[src_ptr])                 \n\t"
+      "psrlh      %[src1],         %[src1],           %[shift]      \n\t"
+
+      "packushb   %[dest],         %[src0],           %[src1]       \n\t"
+      "gssdlc1    %[dest],         0x07(%[dst_ptr])                 \n\t"
+      "gssdrc1    %[dest],         0x00(%[dst_ptr])                 \n\t"
+
+      "daddiu     %[src_ptr],      %[src_ptr],        0x10          \n\t"
+      "daddiu     %[dst_ptr],      %[dst_ptr],        0x08          \n\t"
+      "daddi      %[width],        %[width],         -0x08          \n\t"
+      "bnez       %[width],        1b                               \n\t"
+      : [src0] "=&f"(src0), [src1] "=&f"(src1), [dest] "=&f"(dest)
+      : [src_ptr] "r"(src_ptr), [dst_ptr] "r"(dst), [width] "r"(dst_width),
+        [shift] "f"(shift)
+      : "memory");
+}
+
+void ScaleRowDown2Linear_MMI(const uint8_t* src_ptr,
+                             ptrdiff_t src_stride,
+                             uint8_t* dst,
+                             int dst_width) {
+  (void)src_stride;
+
+  uint64_t src0, src1;
+  uint64_t dest, dest0, dest1;
+
+  const uint64_t mask = 0x00ff00ff00ff00ffULL;
+  const uint64_t shift = 0x8ULL;
+
+  __asm__ volatile(
+      "1:                                                           \n\t"
+      "gsldrc1    %[src0],          0x00(%[src_ptr])                \n\t"
+      "gsldlc1    %[src0],          0x07(%[src_ptr])                \n\t"
+      "and        %[dest0],         %[src0],          %[mask]       \n\t"
+      "gsldrc1    %[src1],          0x08(%[src_ptr])                \n\t"
+      "gsldlc1    %[src1],          0x0f(%[src_ptr])                \n\t"
+      "and        %[dest1],         %[src1],          %[mask]       \n\t"
+      "packushb   %[dest0],         %[dest0],         %[dest1]      \n\t"
+
+      "psrlh      %[src0],          %[src0],          %[shift]      \n\t"
+      "psrlh      %[src1],          %[src1],          %[shift]      \n\t"
+      "packushb   %[dest1],         %[src0],          %[src1]       \n\t"
+
+      "pavgb      %[dest],          %[dest0],         %[dest1]      \n\t"
+      "gssdlc1    %[dest],          0x07(%[dst_ptr])                \n\t"
+      "gssdrc1    %[dest],          0x00(%[dst_ptr])                \n\t"
+
+      "daddiu     %[src_ptr],       %[src_ptr],        0x10         \n\t"
+      "daddiu     %[dst_ptr],       %[dst_ptr],        0x08         \n\t"
+      "daddi      %[width],         %[width],         -0x08         \n\t"
+      "bnez       %[width],         1b                              \n\t"
+      : [src0] "=&f"(src0), [src1] "=&f"(src1), [dest0] "=&f"(dest0),
+        [dest1] "=&f"(dest1), [dest] "=&f"(dest)
+      : [src_ptr] "r"(src_ptr), [dst_ptr] "r"(dst), [mask] "f"(mask),
+        [shift] "f"(shift), [width] "r"(dst_width)
+      : "memory");
+}
+
+void ScaleRowDown2Box_MMI(const uint8_t* src_ptr,
+                          ptrdiff_t src_stride,
+                          uint8_t* dst,
+                          int dst_width) {
+  const uint8_t* s = src_ptr;
+  const uint8_t* t = src_ptr + src_stride;
+
+  uint64_t s0, s1, t0, t1;
+  uint64_t dest, dest0, dest1;
+
+  const uint64_t ph = 0x0002000200020002ULL;
+  const uint64_t mask = 0x00ff00ff00ff00ffULL;
+  const uint64_t shift0 = 0x2ULL;
+  const uint64_t shift1 = 0x8ULL;
+
+  __asm__ volatile(
+      "1:                                                           \n\t"
+      "gsldrc1    %[s0],            0x00(%[s])                      \n\t"
+      "gsldlc1    %[s0],            0x07(%[s])                      \n\t"
+      "psrlh      %[s1],            %[s0],            %[shift1]     \n\t"
+      "and        %[s0],            %[s0],            %[mask]       \n\t"
+
+      "gsldrc1    %[t0],            0x00(%[t])                      \n\t"
+      "gsldlc1    %[t0],            0x07(%[t])                      \n\t"
+      "psrlh      %[t1],            %[t0],            %[shift1]     \n\t"
+      "and        %[t0],            %[t0],            %[mask]       \n\t"
+
+      "paddh      %[dest0],         %[s0],            %[s1]         \n\t"
+      "paddh      %[dest0],         %[dest0],         %[t0]         \n\t"
+      "paddh      %[dest0],         %[dest0],         %[t1]         \n\t"
+      "paddh      %[dest0],         %[dest0],         %[ph]         \n\t"
+      "psrlh      %[dest0],         %[dest0],         %[shift0]     \n\t"
+
+      "gsldrc1    %[s0],            0x08(%[s])                      \n\t"
+      "gsldlc1    %[s0],            0x0f(%[s])                      \n\t"
+      "psrlh      %[s1],            %[s0],            %[shift1]     \n\t"
+      "and        %[s0],            %[s0],            %[mask]       \n\t"
+
+      "gsldrc1    %[t0],            0x08(%[t])                      \n\t"
+      "gsldlc1    %[t0],            0x0f(%[t])                      \n\t"
+      "psrlh      %[t1],            %[t0],            %[shift1]     \n\t"
+      "and        %[t0],            %[t0],            %[mask]       \n\t"
+
+      "paddh      %[dest1],         %[s0],            %[s1]         \n\t"
+      "paddh      %[dest1],         %[dest1],         %[t0]         \n\t"
+      "paddh      %[dest1],         %[dest1],         %[t1]         \n\t"
+      "paddh      %[dest1],         %[dest1],         %[ph]         \n\t"
+      "psrlh      %[dest1],         %[dest1],         %[shift0]     \n\t"
+
+      "packushb   %[dest],          %[dest0],         %[dest1]      \n\t"
+      "gssdlc1    %[dest],         0x07(%[dst_ptr])                 \n\t"
+      "gssdrc1    %[dest],         0x00(%[dst_ptr])                 \n\t"
+
+      "daddiu     %[s],            %[s],              0x10          \n\t"
+      "daddiu     %[t],            %[t],              0x10          \n\t"
+      "daddiu     %[dst_ptr],      %[dst_ptr],        0x08          \n\t"
+      "daddi      %[width],        %[width],         -0x08          \n\t"
+      "bnez       %[width],        1b                               \n\t"
+      : [s0] "=&f"(s0), [s1] "=&f"(s1), [t0] "=&f"(t0), [t1] "=&f"(t1),
+        [dest0] "=&f"(dest0), [dest1] "=&f"(dest1), [dest] "=&f"(dest)
+      : [s] "r"(s), [t] "r"(t), [dst_ptr] "r"(dst), [width] "r"(dst_width),
+        [shift0] "f"(shift0), [shift1] "f"(shift1), [ph] "f"(ph),
+        [mask] "f"(mask)
+      : "memory");
+}
+
+void ScaleARGBRowDown2_MMI(const uint8_t* src_argb,
+                           ptrdiff_t src_stride,
+                           uint8_t* dst_argb,
+                           int dst_width) {
+  (void)src_stride;
+
+  const uint32_t* src = (const uint32_t*)(src_argb);
+  uint32_t* dst = (uint32_t*)(dst_argb);
+
+  uint64_t src0, src1, dest;
+
+  __asm__ volatile(
+      "1:                                                           \n\t"
+      "gsldrc1    %[src0],         0x00(%[src_ptr])                 \n\t"
+      "gsldlc1    %[src0],         0x07(%[src_ptr])                 \n\t"
+      "gsldrc1    %[src1],         0x08(%[src_ptr])                 \n\t"
+      "gsldlc1    %[src1],         0x0f(%[src_ptr])                 \n\t"
+      "punpckhwd  %[dest],         %[src0],           %[src1]       \n\t"
+
+      "gssdlc1    %[dest],         0x07(%[dst_ptr])                 \n\t"
+      "gssdrc1    %[dest],         0x00(%[dst_ptr])                 \n\t"
+
+      "daddiu     %[src_ptr],      %[src_ptr],        0x10          \n\t"
+      "daddiu     %[dst_ptr],      %[dst_ptr],        0x08          \n\t"
+      "daddi      %[width],        %[width],         -0x02          \n\t"
+      "bnez       %[width],        1b                               \n\t"
+      : [src0] "=&f"(src0), [src1] "=&f"(src1), [dest] "=&f"(dest)
+      : [src_ptr] "r"(src), [dst_ptr] "r"(dst), [width] "r"(dst_width)
+      : "memory");
+}
+
+void ScaleARGBRowDown2Linear_MMI(const uint8_t* src_argb,
+                                 ptrdiff_t src_stride,
+                                 uint8_t* dst_argb,
+                                 int dst_width) {
+  (void)src_stride;
+
+  uint64_t src0, src1;
+  uint64_t dest, dest_hi, dest_lo;
+
+  __asm__ volatile(
+      "1:                                                           \n\t"
+      "lwc1       %[src0],         0x00(%[src_ptr])                 \n\t"
+      "lwc1       %[src1],         0x08(%[src_ptr])                 \n\t"
+      "punpcklwd  %[dest_lo],      %[src0],           %[src1]       \n\t"
+      "lwc1       %[src0],         0x04(%[src_ptr])                 \n\t"
+      "lwc1       %[src1],         0x0c(%[src_ptr])                 \n\t"
+      "punpcklwd  %[dest_hi],      %[src0],           %[src1]       \n\t"
+
+      "pavgb      %[dest],         %[dest_lo],        %[dest_hi]    \n\t"
+      "gssdlc1    %[dest],         0x07(%[dst_ptr])                 \n\t"
+      "gssdrc1    %[dest],         0x00(%[dst_ptr])                 \n\t"
+
+      "daddiu     %[src_ptr],      %[src_ptr],        0x10          \n\t"
+      "daddiu     %[dst_ptr],      %[dst_ptr],        0x08          \n\t"
+      "daddi      %[width],        %[width],         -0x02          \n\t"
+      "bnez       %[width],        1b                               \n\t"
+      : [src0] "=&f"(src0), [src1] "=&f"(src1), [dest_hi] "=&f"(dest_hi),
+        [dest_lo] "=&f"(dest_lo), [dest] "=&f"(dest)
+      : [src_ptr] "r"(src_argb), [dst_ptr] "r"(dst_argb), [width] "r"(dst_width)
+      : "memory");
+}
+
+void ScaleARGBRowDown2Box_MMI(const uint8_t* src_argb,
+                              ptrdiff_t src_stride,
+                              uint8_t* dst_argb,
+                              int dst_width) {
+  const uint8_t* s = src_argb;
+  const uint8_t* t = src_argb + src_stride;
+
+  uint64_t s0, s_hi, s_lo;
+  uint64_t t0, t_hi, t_lo;
+  uint64_t dest, dest_hi, dest_lo;
+
+  const uint64_t mask = 0x0ULL;
+  const uint64_t ph = 0x0002000200020002ULL;
+  const uint64_t shfit = 0x2ULL;
+
+  __asm__ volatile(
+      "1:                                                           \n\t"
+      "gsldrc1    %[s0],            0x00(%[s])                      \n\t"
+      "gsldlc1    %[s0],            0x07(%[s])                      \n\t"
+      "punpcklbh  %[s_lo],          %[s0],           %[mask]        \n\t"
+      "punpckhbh  %[s_hi],          %[s0],           %[mask]        \n\t"
+      "paddh      %[dest_lo],       %[s_lo],         %[s_hi]        \n\t"
+
+      "gsldrc1    %[t0],            0x00(%[t])                      \n\t"
+      "gsldlc1    %[t0],            0x07(%[t])                      \n\t"
+      "punpcklbh  %[t_lo],          %[t0],           %[mask]        \n\t"
+      "punpckhbh  %[t_hi],          %[t0],           %[mask]        \n\t"
+      "paddh      %[dest_lo],       %[dest_lo],      %[t_lo]        \n\t"
+      "paddh      %[dest_lo],       %[dest_lo],      %[t_hi]        \n\t"
+
+      "paddh      %[dest_lo],      %[dest_lo],       %[ph]          \n\t"
+      "psrlh      %[dest_lo],      %[dest_lo],       %[shfit]       \n\t"
+
+      "gsldrc1    %[s0],            0x08(%[s])                      \n\t"
+      "gsldlc1    %[s0],            0x0f(%[s])                      \n\t"
+      "punpcklbh  %[s_lo],          %[s0],           %[mask]        \n\t"
+      "punpckhbh  %[s_hi],          %[s0],           %[mask]        \n\t"
+      "paddh      %[dest_hi],       %[s_lo],         %[s_hi]        \n\t"
+
+      "gsldrc1    %[t0],            0x08(%[t])                      \n\t"
+      "gsldlc1    %[t0],            0x0f(%[t])                      \n\t"
+      "punpcklbh  %[t_lo],          %[t0],           %[mask]        \n\t"
+      "punpckhbh  %[t_hi],          %[t0],           %[mask]        \n\t"
+      "paddh      %[dest_hi],       %[dest_hi],      %[t_lo]        \n\t"
+      "paddh      %[dest_hi],       %[dest_hi],      %[t_hi]        \n\t"
+
+      "paddh      %[dest_hi],      %[dest_hi],       %[ph]          \n\t"
+      "psrlh      %[dest_hi],      %[dest_hi],       %[shfit]       \n\t"
+
+      "packushb   %[dest],         %[dest_lo],       %[dest_hi]     \n\t"
+      "gssdlc1    %[dest],         0x07(%[dst_ptr])                 \n\t"
+      "gssdrc1    %[dest],         0x00(%[dst_ptr])                 \n\t"
+
+      "daddiu     %[s],            %[s],              0x10          \n\t"
+      "daddiu     %[t],            %[t],              0x10          \n\t"
+      "daddiu     %[dst_ptr],      %[dst_ptr],        0x08          \n\t"
+      "daddi      %[width],        %[width],         -0x02          \n\t"
+      "bnez       %[width],        1b                               \n\t"
+      : [s0] "=&f"(s0), [t0] "=&f"(t0), [dest_hi] "=&f"(dest_hi),
+        [dest_lo] "=&f"(dest_lo), [s_hi] "=&f"(s_hi), [s_lo] "=&f"(s_lo),
+        [t_hi] "=&f"(t_hi), [t_lo] "=&f"(t_lo), [dest] "=&f"(dest)
+      : [s] "r"(s), [t] "r"(t), [dst_ptr] "r"(dst_argb), [width] "r"(dst_width),
+        [mask] "f"(mask), [ph] "f"(ph), [shfit] "f"(shfit)
+      : "memory");
+}
+
+void ScaleRowDown2_16_MMI(const uint16_t* src_ptr,
+                          ptrdiff_t src_stride,
+                          uint16_t* dst,
+                          int dst_width) {
+  (void)src_stride;
+
+  uint64_t src0, src1, dest;
+  const uint64_t shift = 0x10ULL;
+
+  __asm__ volatile(
+      "1:                                                           \n\t"
+      "gsldrc1    %[src0],         0x00(%[src_ptr])                 \n\t"
+      "gsldlc1    %[src0],         0x07(%[src_ptr])                 \n\t"
+      "psrlw      %[src0],         %[src0],           %[shift]      \n\t"
+
+      "gsldrc1    %[src1],         0x08(%[src_ptr])                 \n\t"
+      "gsldlc1    %[src1],         0x0f(%[src_ptr])                 \n\t"
+      "psrlw      %[src1],         %[src1],           %[shift]      \n\t"
+
+      "packsswh   %[dest],         %[src0],           %[src1]       \n\t"
+      "gssdlc1    %[dest],         0x07(%[dst_ptr])                 \n\t"
+      "gssdrc1    %[dest],         0x00(%[dst_ptr])                 \n\t"
+
+      "daddiu     %[src_ptr],      %[src_ptr],        0x10          \n\t"
+      "daddiu     %[dst_ptr],      %[dst_ptr],        0x08          \n\t"
+      "daddi      %[width],        %[width],         -0x04          \n\t"
+      "bnez       %[width],        1b                               \n\t"
+      : [src0] "=&f"(src0), [src1] "=&f"(src1), [dest] "=&f"(dest)
+      : [src_ptr] "r"(src_ptr), [dst_ptr] "r"(dst), [width] "r"(dst_width),
+        [shift] "f"(shift)
+      : "memory");
+}
+
+void ScaleRowDown2Linear_16_MMI(const uint16_t* src_ptr,
+                                ptrdiff_t src_stride,
+                                uint16_t* dst,
+                                int dst_width) {
+  (void)src_stride;
+
+  uint64_t src0, src1;
+  uint64_t dest, dest_hi, dest_lo;
+
+  __asm__ volatile(
+      "1:                                                           \n\t"
+      "gsldrc1    %[src0],         0x00(%[src_ptr])                 \n\t"
+      "gsldlc1    %[src0],         0x07(%[src_ptr])                 \n\t"
+      "gsldrc1    %[src1],         0x08(%[src_ptr])                 \n\t"
+      "gsldlc1    %[src1],         0x0f(%[src_ptr])                 \n\t"
+      "punpcklhw  %[dest_lo],      %[src0],           %[src1]       \n\t"
+      "punpckhhw  %[dest_hi],      %[src0],           %[src1]       \n\t"
+
+      "punpcklhw  %[src0],         %[dest_lo],        %[dest_hi]    \n\t"
+      "punpckhhw  %[src1],         %[dest_lo],        %[dest_hi]    \n\t"
+
+      "pavgh      %[dest],         %[src0],           %[src1]       \n\t"
+      "gssdlc1    %[dest],         0x07(%[dst_ptr])                 \n\t"
+      "gssdrc1    %[dest],         0x00(%[dst_ptr])                 \n\t"
+
+      "daddiu     %[src_ptr],      %[src_ptr],        0x10          \n\t"
+      "daddiu     %[dst_ptr],      %[dst_ptr],        0x08          \n\t"
+      "daddi      %[width],        %[width],         -0x04          \n\t"
+      "bnez       %[width],        1b                               \n\t"
+      : [src0] "=&f"(src0), [src1] "=&f"(src1), [dest_hi] "=&f"(dest_hi),
+        [dest_lo] "=&f"(dest_lo), [dest] "=&f"(dest)
+      : [src_ptr] "r"(src_ptr), [dst_ptr] "r"(dst), [width] "r"(dst_width)
+      : "memory");
+}
+
+void ScaleRowDown2Box_16_MMI(const uint16_t* src_ptr,
+                             ptrdiff_t src_stride,
+                             uint16_t* dst,
+                             int dst_width) {
+  const uint16_t* s = src_ptr;
+  const uint16_t* t = src_ptr + src_stride;
+
+  uint64_t s0, s1, s_hi, s_lo;
+  uint64_t t0, t1, t_hi, t_lo;
+  uint64_t dest, dest0, dest1;
+
+  const uint64_t ph = 0x0000000200000002ULL;
+  const uint64_t mask = 0x0000ffff0000ffffULL;
+  const uint64_t shift0 = 0x10ULL;
+  const uint64_t shift1 = 0x2ULL;
+
+  __asm__ volatile(
+      "1:                                                           \n\t"
+      "gsldrc1    %[s0],            0x00(%[s])                      \n\t"
+      "gsldlc1    %[s0],            0x07(%[s])                      \n\t"
+      "psrlw      %[s1],            %[s0],            %[shift0]     \n\t"
+      "and        %[s0],            %[s0],            %[mask]       \n\t"
+
+      "gsldrc1    %[t0],            0x00(%[t])                      \n\t"
+      "gsldlc1    %[t0],            0x07(%[t])                      \n\t"
+      "psrlw      %[t1],            %[t0],            %[shift0]     \n\t"
+      "and        %[t0],            %[t0],            %[mask]       \n\t"
+
+      "paddw      %[dest0],         %[s0],            %[s1]         \n\t"
+      "paddw      %[dest0],         %[dest0],         %[t0]         \n\t"
+      "paddw      %[dest0],         %[dest0],         %[t1]         \n\t"
+      "paddw      %[dest0],         %[dest0],         %[ph]         \n\t"
+      "psrlw      %[dest0],         %[dest0],         %[shift1]     \n\t"
+
+      "gsldrc1    %[s0],            0x08(%[s])                      \n\t"
+      "gsldlc1    %[s0],            0x0f(%[s])                      \n\t"
+      "psrlw      %[s1],            %[s0],            %[shift0]     \n\t"
+      "and        %[s0],            %[s0],            %[mask]       \n\t"
+
+      "gsldrc1    %[t0],            0x08(%[t])                      \n\t"
+      "gsldlc1    %[t0],            0x0f(%[t])                      \n\t"
+      "psrlw      %[t1],            %[t0],            %[shift0]     \n\t"
+      "and        %[t0],            %[t0],            %[mask]       \n\t"
+
+      "paddw      %[dest1],         %[s0],            %[s1]         \n\t"
+      "paddw      %[dest1],         %[dest1],         %[t0]         \n\t"
+      "paddw      %[dest1],         %[dest1],         %[t1]         \n\t"
+      "paddw      %[dest1],         %[dest1],         %[ph]         \n\t"
+      "psrlw      %[dest1],         %[dest1],         %[shift1]     \n\t"
+
+      "packsswh   %[dest],          %[dest0],         %[dest1]      \n\t"
+      "gssdlc1    %[dest],          0x07(%[dst_ptr])                \n\t"
+      "gssdrc1    %[dest],          0x00(%[dst_ptr])                \n\t"
+
+      "daddiu     %[s],             %[s],              0x10         \n\t"
+      "daddiu     %[t],             %[t],              0x10         \n\t"
+      "daddiu     %[dst_ptr],       %[dst_ptr],        0x08         \n\t"
+      "daddi      %[width],         %[width],         -0x04         \n\t"
+      "bnez       %[width],         1b                              \n\t"
+      : [s0] "=&f"(s0), [s1] "=&f"(s1), [t0] "=&f"(t0), [t1] "=&f"(t1),
+        [s_hi] "=&f"(s_hi), [s_lo] "=&f"(s_lo), [t_hi] "=&f"(t_hi),
+        [t_lo] "=&f"(t_lo), [dest0] "=&f"(dest0), [dest1] "=&f"(dest1),
+        [dest] "=&f"(dest)
+      : [s] "r"(s), [t] "r"(t), [dst_ptr] "r"(dst), [width] "r"(dst_width),
+        [shift0] "f"(shift0), [shift1] "f"(shift1), [ph] "f"(ph),
+        [mask] "f"(mask)
+      : "memory");
+}
+
+void ScaleRowDown4_MMI(const uint8_t* src_ptr,
+                       ptrdiff_t src_stride,
+                       uint8_t* dst,
+                       int dst_width) {
+  (void)src_stride;
+
+  uint64_t src0, src1;
+  uint64_t dest, dest_hi, dest_lo;
+
+  const uint64_t shift = 0x10ULL;
+  const uint64_t mask = 0x000000ff000000ffULL;
+
+  __asm__ volatile(
+      "1:                                                           \n\t"
+      "gsldrc1    %[src0],         0x00(%[src_ptr])                 \n\t"
+      "gsldlc1    %[src0],         0x07(%[src_ptr])                 \n\t"
+      "psrlw      %[src0],         %[src0],           %[shift]      \n\t"
+      "and        %[src0],         %[src0],           %[mask]       \n\t"
+      "gsldrc1    %[src1],         0x08(%[src_ptr])                 \n\t"
+      "gsldlc1    %[src1],         0x0f(%[src_ptr])                 \n\t"
+      "psrlw      %[src1],         %[src1],           %[shift]      \n\t"
+      "and        %[src1],         %[src1],           %[mask]       \n\t"
+      "packsswh   %[dest_lo],      %[src0],           %[src1]       \n\t"
+
+      "gsldrc1    %[src0],         0x10(%[src_ptr])                 \n\t"
+      "gsldlc1    %[src0],         0x17(%[src_ptr])                 \n\t"
+      "psrlw      %[src0],         %[src0],           %[shift]      \n\t"
+      "and        %[src0],         %[src0],           %[mask]       \n\t"
+      "gsldrc1    %[src1],         0x18(%[src_ptr])                 \n\t"
+      "gsldlc1    %[src1],         0x1f(%[src_ptr])                 \n\t"
+      "psrlw      %[src1],         %[src1],           %[shift]      \n\t"
+      "and        %[src1],         %[src1],           %[mask]       \n\t"
+      "packsswh   %[dest_hi],      %[src0],           %[src1]       \n\t"
+
+      "packushb   %[dest],         %[dest_lo],         %[dest_hi]   \n\t"
+      "gssdlc1    %[dest],         0x07(%[dst_ptr])                 \n\t"
+      "gssdrc1    %[dest],         0x00(%[dst_ptr])                 \n\t"
+
+      "daddiu     %[src_ptr],      %[src_ptr],        0x20          \n\t"
+      "daddiu     %[dst_ptr],      %[dst_ptr],        0x08          \n\t"
+      "daddi      %[width],        %[width],         -0x08          \n\t"
+      "bnez       %[width],        1b                               \n\t"
+      : [src0] "=&f"(src0), [src1] "=&f"(src1), [dest_hi] "=&f"(dest_hi),
+        [dest_lo] "=&f"(dest_lo), [dest] "=&f"(dest)
+      : [src_ptr] "r"(src_ptr), [dst_ptr] "r"(dst), [width] "r"(dst_width),
+        [shift] "f"(shift), [mask] "f"(mask)
+      : "memory");
+}
+
+void ScaleRowDown4_16_MMI(const uint16_t* src_ptr,
+                          ptrdiff_t src_stride,
+                          uint16_t* dst,
+                          int dst_width) {
+  (void)src_stride;
+
+  uint64_t src0, src1;
+  uint64_t dest, dest_hi, dest_lo;
+
+  const uint64_t mask = 0x0ULL;
+
+  __asm__ volatile(
+      "1:                                                           \n\t"
+      "gsldrc1    %[src0],         0x00(%[src_ptr])                 \n\t"
+      "gsldlc1    %[src0],         0x07(%[src_ptr])                 \n\t"
+      "gsldrc1    %[src1],         0x08(%[src_ptr])                 \n\t"
+      "gsldlc1    %[src1],         0x0f(%[src_ptr])                 \n\t"
+      "punpckhhw  %[dest_lo],      %[src0],           %[src1]       \n\t"
+      "punpcklhw  %[dest_lo],      %[dest_lo],        %[mask]       \n\t"
+
+      "gsldrc1    %[src0],         0x10(%[src_ptr])                 \n\t"
+      "gsldlc1    %[src0],         0x17(%[src_ptr])                 \n\t"
+      "gsldrc1    %[src1],         0x18(%[src_ptr])                 \n\t"
+      "gsldlc1    %[src1],         0x1f(%[src_ptr])                 \n\t"
+      "punpckhhw  %[dest_hi],      %[src0],           %[src1]       \n\t"
+      "punpcklhw  %[dest_hi],      %[dest_hi],        %[mask]       \n\t"
+
+      "packushb   %[dest],         %[dest_lo],        %[dest_hi]    \n\t"
+      "gssdlc1    %[dest],         0x07(%[dst_ptr])                 \n\t"
+      "gssdrc1    %[dest],         0x00(%[dst_ptr])                 \n\t"
+
+      "daddiu     %[src_ptr],      %[src_ptr],        0x20          \n\t"
+      "daddiu     %[dst_ptr],      %[dst_ptr],        0x08          \n\t"
+      "daddi      %[width],        %[width],         -0x04          \n\t"
+      "bnez       %[width],        1b                               \n\t"
+      : [src0] "=&f"(src0), [src1] "=&f"(src1), [dest_hi] "=&f"(dest_hi),
+        [dest_lo] "=&f"(dest_lo), [dest] "=&f"(dest)
+      : [src_ptr] "r"(src_ptr), [dst_ptr] "r"(dst), [width] "r"(dst_width),
+        [mask] "f"(mask)
+      : "memory");
+}
+
+#define DO_SCALEROWDOWN4BOX_PUNPCKADD()                              \
+  "punpcklbh  %[src_lo],       %[src],           %[mask0]      \n\t" \
+  "punpckhbh  %[src_hi],       %[src],           %[mask0]      \n\t" \
+  "paddh      %[dest_lo],      %[dest_lo],       %[src_lo]     \n\t" \
+  "paddh      %[dest_hi],      %[dest_hi],       %[src_hi]     \n\t"
+
+#define DO_SCALEROWDOWN4BOX_LOOP(reg)                                \
+  "ldc1       %[src],          0x00(%[src0_ptr])               \n\t" \
+  "punpcklbh  %[dest_lo],      %[src],           %[mask0]      \n\t" \
+  "punpckhbh  %[dest_hi],      %[src],           %[mask0]      \n\t" \
+                                                                     \
+  "ldc1       %[src],          0x00(%[src1_ptr])               \n\t" \
+  DO_SCALEROWDOWN4BOX_PUNPCKADD()                                    \
+                                                                     \
+  "ldc1       %[src],          0x00(%[src2_ptr])               \n\t" \
+  DO_SCALEROWDOWN4BOX_PUNPCKADD()                                    \
+                                                                     \
+  "ldc1       %[src],          0x00(%[src3_ptr])               \n\t" \
+  DO_SCALEROWDOWN4BOX_PUNPCKADD()                                    \
+                                                                     \
+  "pmaddhw    %[dest_lo],      %[dest_lo],       %[mask1]      \n\t" \
+  "pmaddhw    %[dest_hi],      %[dest_hi],       %[mask1]      \n\t" \
+  "packsswh   " #reg   ",      %[dest_lo],       %[dest_hi]    \n\t" \
+  "pmaddhw    " #reg   ",      " #reg   ",       %[mask1]      \n\t" \
+  "paddh      " #reg   ",      " #reg   ",       %[ph]         \n\t" \
+  "psrlh      " #reg   ",      " #reg   ",       %[shift]      \n\t" \
+                                                                     \
+  "daddiu     %[src0_ptr],     %[src0_ptr],      0x08          \n\t" \
+  "daddiu     %[src1_ptr],     %[src1_ptr],      0x08          \n\t" \
+  "daddiu     %[src2_ptr],     %[src2_ptr],      0x08          \n\t" \
+  "daddiu     %[src3_ptr],     %[src3_ptr],      0x08          \n\t"
+
+/* LibYUVScaleTest.ScaleDownBy4_Box */
+void ScaleRowDown4Box_MMI(const uint8_t* src_ptr,
+                          ptrdiff_t src_stride,
+                          uint8_t* dst,
+                          int dst_width) {
+  const uint8_t* src0_ptr = src_ptr;
+  const uint8_t* src1_ptr = src_ptr + src_stride;
+  const uint8_t* src2_ptr = src_ptr + src_stride * 2;
+  const uint8_t* src3_ptr = src_ptr + src_stride * 3;
+
+  uint64_t src, src_hi, src_lo;
+  uint64_t dest, dest_hi, dest_lo, dest0, dest1, dest2, dest3;
+
+  const uint64_t mask0 = 0x0ULL;
+  const uint64_t mask1 = 0x0001000100010001ULL;
+  const uint64_t ph = 0x0008000800080008ULL;
+  const uint64_t shift = 0x4ULL;
+
+  __asm__ volatile(
+      "1:                                                           \n\t"
+
+      DO_SCALEROWDOWN4BOX_LOOP(%[dest0])
+      DO_SCALEROWDOWN4BOX_LOOP(%[dest1])
+      DO_SCALEROWDOWN4BOX_LOOP(%[dest2])
+      DO_SCALEROWDOWN4BOX_LOOP(%[dest3])
+
+      "packsswh   %[dest_lo],      %[dest0],          %[dest1]      \n\t"
+      "packsswh   %[dest_hi],      %[dest2],          %[dest3]      \n\t"
+
+      "packushb   %[dest],         %[dest_lo],        %[dest_hi]    \n\t"
+      "gssdlc1    %[dest],         0x07(%[dst_ptr])                 \n\t"
+      "gssdrc1    %[dest],         0x00(%[dst_ptr])                 \n\t"
+
+      "daddiu     %[dst_ptr],      %[dst_ptr],        0x08          \n\t"
+      "daddi      %[width],        %[width],         -0x08          \n\t"
+      "bnez       %[width],        1b                               \n\t"
+      : [src_hi] "=&f"(src_hi), [src_lo] "=&f"(src_lo),
+        [dest_hi] "=&f"(dest_hi), [dest_lo] "=&f"(dest_lo),
+        [dest0] "=&f"(dest0), [dest1] "=&f"(dest1), [dest2] "=&f"(dest2),
+        [dest3] "=&f"(dest3), [src] "=&f"(src), [dest] "=&f"(dest)
+      : [src0_ptr] "r"(src0_ptr), [src1_ptr] "r"(src1_ptr),
+        [src2_ptr] "r"(src2_ptr), [src3_ptr] "r"(src3_ptr), [dst_ptr] "r"(dst),
+        [width] "r"(dst_width), [shift] "f"(shift), [mask0] "f"(mask0),
+        [ph] "f"(ph), [mask1] "f"(mask1)
+      : "memory");
+}
+
+#define DO_SCALEROWDOWN4BOX_16_PUNPCKADD()                            \
+  "punpcklbh  %[src_lo],       %[src],            %[mask0]      \n\t" \
+  "punpckhbh  %[src_hi],       %[src],            %[mask0]      \n\t" \
+  "paddh      %[dest_lo],      %[dest_lo],        %[src_lo]     \n\t" \
+  "paddh      %[dest_hi],      %[dest_hi],        %[src_hi]     \n\t"
+
+#define DO_SCALEROWDOWN4BOX_16_LOOP(reg)                              \
+  "ldc1       %[src],          0x00(%[src0_ptr])                \n\t" \
+  "punpcklbh  %[dest_lo],      %[src],            %[mask0]      \n\t" \
+  "punpckhbh  %[dest_hi],      %[src],            %[mask0]      \n\t" \
+                                                                      \
+  "ldc1       %[src],          0x00(%[src1_ptr])                \n\t" \
+  DO_SCALEROWDOWN4BOX_16_PUNPCKADD()                                  \
+                                                                      \
+  "ldc1       %[src],          0x00(%[src2_ptr])                \n\t" \
+  DO_SCALEROWDOWN4BOX_16_PUNPCKADD()                                  \
+                                                                      \
+  "ldc1       %[src],          0x00(%[src3_ptr])                \n\t" \
+  DO_SCALEROWDOWN4BOX_16_PUNPCKADD()                                  \
+                                                                      \
+  "paddw      %[dest],         %[dest_lo],        %[dest_hi]    \n\t" \
+  "punpckhwd  %[dest_hi],      %[dest],           %[dest]       \n\t" \
+  "paddw      %[dest],         %[dest_hi],        %[dest]       \n\t" \
+  "paddw      %[dest],         %[dest],           %[ph]         \n\t" \
+  "psraw      %[dest],         %[dest],           %[shift]      \n\t" \
+  "and        " #reg ",        %[dest],           %[mask1]      \n\t" \
+                                                                      \
+  "daddiu     %[src0_ptr],     %[src0_ptr],       0x08          \n\t" \
+  "daddiu     %[src1_ptr],     %[src1_ptr],       0x08          \n\t" \
+  "daddiu     %[src2_ptr],     %[src2_ptr],       0x08          \n\t" \
+  "daddiu     %[src3_ptr],     %[src3_ptr],       0x08          \n\t"
+
+/* LibYUVScaleTest.ScaleDownBy4_Box_16 */
+void ScaleRowDown4Box_16_MMI(const uint16_t* src_ptr,
+                             ptrdiff_t src_stride,
+                             uint16_t* dst,
+                             int dst_width) {
+  const uint16_t* src0_ptr = src_ptr;
+  const uint16_t* src1_ptr = src_ptr + src_stride;
+  const uint16_t* src2_ptr = src_ptr + src_stride * 2;
+  const uint16_t* src3_ptr = src_ptr + src_stride * 3;
+
+  uint64_t src, src_hi, src_lo;
+  uint64_t dest, dest_hi, dest_lo, dest0, dest1, dest2, dest3;
+
+  const uint64_t mask0 = 0x0ULL;
+  const uint64_t mask1 = 0x00000000ffffffffULL;
+  const uint64_t ph = 0x0000000800000008ULL;
+  const uint64_t shift = 0x04ULL;
+
+  __asm__ volatile(
+      "1:                                                        \n\t"
+
+      DO_SCALEROWDOWN4BOX_16_LOOP(%[dest0])
+      DO_SCALEROWDOWN4BOX_16_LOOP(%[dest1])
+      DO_SCALEROWDOWN4BOX_16_LOOP(%[dest2])
+      DO_SCALEROWDOWN4BOX_16_LOOP(%[dest3])
+      "punpcklwd  %[dest_lo],      %[dest0],          %[dest1]   \n\t"
+      "punpcklwd  %[dest_hi],      %[dest2],          %[dest3]   \n\t"
+
+      "packushb   %[dest],         %[dest_lo],        %[dest_hi] \n\t"
+      "gssdlc1    %[dest],         0x07(%[dst_ptr])              \n\t"
+      "gssdrc1    %[dest],         0x00(%[dst_ptr])              \n\t"
+
+      "daddiu     %[dst_ptr],      %[dst_ptr],        0x08       \n\t"
+      "daddi      %[width],        %[width],         -0x04       \n\t"
+      "bnez       %[width],        1b                            \n\t"
+      : [src_hi] "=&f"(src_hi), [src_lo] "=&f"(src_lo),
+        [dest_hi] "=&f"(dest_hi), [dest_lo] "=&f"(dest_lo),
+        [dest0] "=&f"(dest0), [dest1] "=&f"(dest1), [dest2] "=&f"(dest2),
+        [dest3] "=&f"(dest3), [src] "=&f"(src), [dest] "=&f"(dest)
+      : [src0_ptr] "r"(src0_ptr), [src1_ptr] "r"(src1_ptr),
+        [src2_ptr] "r"(src2_ptr), [src3_ptr] "r"(src3_ptr), [dst_ptr] "r"(dst),
+        [width] "r"(dst_width), [shift] "f"(shift), [mask0] "f"(mask0),
+        [ph] "f"(ph), [mask1] "f"(mask1)
+      : "memory");
+}
+
+// Scales a single row of pixels up by 2x using point sampling.
+void ScaleColsUp2_MMI(uint8_t* dst_ptr,
+                      const uint8_t* src_ptr,
+                      int dst_width,
+                      int x,
+                      int dx) {
+  uint64_t src, dest;
+
+  (void)x;
+  (void)dx;
+
+  __asm__ volatile(
+      "1:                                                           \n\t"
+      "lwc1       %[src],          0x00(%[src_ptr])                 \n\t"
+
+      "punpcklbh  %[dest],         %[src],            %[src]        \n\t"
+      "gssdlc1    %[dest],         0x07(%[dst_ptr])                 \n\t"
+      "gssdrc1    %[dest],         0x00(%[dst_ptr])                 \n\t"
+
+      "daddiu     %[src_ptr],      %[src_ptr],        0x04          \n\t"
+      "daddiu     %[dst_ptr],      %[dst_ptr],        0x08          \n\t"
+      "daddi      %[width],        %[width],         -0x08          \n\t"
+      "bnez       %[width],        1b                               \n\t"
+      : [src] "=&f"(src), [dest] "=&f"(dest)
+      : [src_ptr] "r"(src_ptr), [dst_ptr] "r"(dst_ptr), [width] "r"(dst_width)
+      : "memory");
+}
+
+void ScaleColsUp2_16_MMI(uint16_t* dst_ptr,
+                         const uint16_t* src_ptr,
+                         int dst_width,
+                         int x,
+                         int dx) {
+  uint64_t src, dest;
+
+  (void)x;
+  (void)dx;
+
+  __asm__ volatile(
+      "1:                                                           \n\t"
+      "gsldrc1    %[src],          0x00(%[src_ptr])                 \n\t"
+      "gsldlc1    %[src],          0x07(%[src_ptr])                 \n\t"
+
+      "punpcklhw  %[dest],         %[src],            %[src]        \n\t"
+      "gssdlc1    %[dest],         0x07(%[dst_ptr])                 \n\t"
+      "gssdrc1    %[dest],         0x00(%[dst_ptr])                 \n\t"
+
+      "punpckhhw  %[dest],         %[src],            %[src]        \n\t"
+      "gssdlc1    %[dest],         0x0f(%[dst_ptr])                 \n\t"
+      "gssdrc1    %[dest],         0x08(%[dst_ptr])                 \n\t"
+
+      "daddiu     %[src_ptr],      %[src_ptr],        0x08          \n\t"
+      "daddiu     %[dst_ptr],      %[dst_ptr],        0x10          \n\t"
+      "daddi      %[width],        %[width],         -0x08          \n\t"
+      "bnez       %[width],        1b                               \n\t"
+      : [src] "=&f"(src), [dest] "=&f"(dest)
+      : [src_ptr] "r"(src_ptr), [dst_ptr] "r"(dst_ptr), [width] "r"(dst_width)
+      : "memory");
+}
+
+void ScaleAddRow_MMI(const uint8_t* src_ptr, uint16_t* dst_ptr, int src_width) {
+  uint64_t src, src_hi, src_lo, dest0, dest1;
+  const uint64_t mask = 0x0ULL;
+
+  __asm__ volatile(
+      "1:                                                           \n\t"
+      "gsldlc1    %[src],          0x07(%[src_ptr])                 \n\t"
+      "gsldrc1    %[src],          0x00(%[src_ptr])                 \n\t"
+      "punpcklbh  %[src_lo],       %[src],            %[mask]       \n\t"
+      "punpckhbh  %[src_hi],       %[src],            %[mask]       \n\t"
+
+      "gsldrc1    %[dest0],        0x00(%[dst_ptr])                 \n\t"
+      "gsldlc1    %[dest0],        0x07(%[dst_ptr])                 \n\t"
+      "paddush    %[dest0],        %[dest0],          %[src_lo]     \n\t"
+      "gsldrc1    %[dest1],        0x08(%[dst_ptr])                 \n\t"
+      "gsldlc1    %[dest1],        0x0f(%[dst_ptr])                 \n\t"
+      "paddush    %[dest1],        %[dest1],          %[src_hi]     \n\t"
+
+      "gssdlc1    %[dest0],        0x07(%[dst_ptr])                 \n\t"
+      "gssdrc1    %[dest0],        0x00(%[dst_ptr])                 \n\t"
+      "gssdlc1    %[dest1],        0x0f(%[dst_ptr])                 \n\t"
+      "gssdrc1    %[dest1],        0x08(%[dst_ptr])                 \n\t"
+
+      "daddiu     %[src_ptr],      %[src_ptr],        0x08          \n\t"
+      "daddiu     %[dst_ptr],      %[dst_ptr],        0x10          \n\t"
+      "daddi      %[width],        %[width],         -0x08          \n\t"
+      "bnez       %[width],        1b                               \n\t"
+      : [dest0] "=&f"(dest0), [dest1] "=&f"(dest1), [src_hi] "=&f"(src_hi),
+        [src_lo] "=&f"(src_lo), [src] "=&f"(src)
+      : [src_ptr] "r"(src_ptr), [dst_ptr] "r"(dst_ptr), [width] "r"(src_width),
+        [mask] "f"(mask)
+      : "memory");
+}
+
+void ScaleAddRow_16_MMI(const uint16_t* src_ptr,
+                        uint32_t* dst_ptr,
+                        int src_width) {
+  uint64_t src, src_hi, src_lo, dest0, dest1;
+  const uint64_t mask = 0x0ULL;
+
+  __asm__ volatile(
+      "1:                                                           \n\t"
+      "gsldrc1    %[src],          0x00(%[src_ptr])                 \n\t"
+      "gsldlc1    %[src],          0x07(%[src_ptr])                 \n\t"
+      "punpcklhw  %[src_lo],       %[src],            %[mask]       \n\t"
+      "punpckhhw  %[src_hi],       %[src],            %[mask]       \n\t"
+
+      "gsldrc1    %[dest0],        0x00(%[dst_ptr])                 \n\t"
+      "gsldlc1    %[dest0],        0x07(%[dst_ptr])                 \n\t"
+      "paddw      %[dest0],        %[dest0],          %[src_lo]     \n\t"
+      "gssdlc1    %[dest0],        0x07(%[dst_ptr])                 \n\t"
+      "gssdrc1    %[dest0],        0x00(%[dst_ptr])                 \n\t"
+
+      "gsldrc1    %[dest1],        0x08(%[dst_ptr])                 \n\t"
+      "gsldlc1    %[dest1],        0x0f(%[dst_ptr])                 \n\t"
+      "paddw      %[dest1],        %[dest1],          %[src_hi]     \n\t"
+      "gssdlc1    %[dest1],        0x0f(%[dst_ptr])                 \n\t"
+      "gssdrc1    %[dest1],        0x08(%[dst_ptr])                 \n\t"
+
+      "daddiu     %[src_ptr],      %[src_ptr],        0x08          \n\t"
+      "daddiu     %[dst_ptr],      %[dst_ptr],        0x10          \n\t"
+      "daddi      %[width],        %[width],         -0x04          \n\t"
+      "bnez       %[width],        1b                               \n\t"
+      : [dest0] "=&f"(dest0), [dest1] "=&f"(dest1), [src_hi] "=&f"(src_hi),
+        [src_lo] "=&f"(src_lo), [src] "=&f"(src)
+      : [src_ptr] "r"(src_ptr), [dst_ptr] "r"(dst_ptr), [width] "r"(src_width),
+        [mask] "f"(mask)
+      : "memory");
+}
+
+void ScaleARGBRowDownEven_MMI(const uint8_t* src_argb,
+                              ptrdiff_t src_stride,
+                              int src_stepx,
+                              uint8_t* dst_argb,
+                              int dst_width) {
+  (void)src_stride;
+
+  uint64_t src0, src1, dest;
+
+  __asm__ volatile(
+      "1:                                                           \n\t"
+      "lwc1       %[src0],          0x00(%[src_ptr])                \n\t"
+      "dadd       %[src_ptr],       %[src_ptr],       %[src_stepx_4]\n\t"
+      "lwc1       %[src1],          0x00(%[src_ptr])                \n\t"
+      "punpcklwd  %[dest],          %[src0],          %[src1]       \n\t"
+
+      "gssdlc1    %[dest],          0x07(%[dst_ptr])                \n\t"
+      "gssdrc1    %[dest],          0x00(%[dst_ptr])                \n\t"
+
+      "dadd       %[src_ptr],       %[src_ptr],       %[src_stepx_4]\n\t"
+      "daddiu     %[dst_ptr],       %[dst_ptr],       0x08          \n\t"
+      "daddi      %[width],         %[width],        -0x02          \n\t"
+      "bnez       %[width],         1b                              \n\t"
+      : [src0] "=&f"(src0), [src1] "=&f"(src1), [dest] "=&f"(dest)
+      : [src_ptr] "r"(src_argb), [dst_ptr] "r"(dst_argb),
+        [src_stepx_4] "r"(src_stepx << 2), [width] "r"(dst_width)
+      : "memory");
+}
+
+void ScaleARGBRowDownEvenBox_MMI(const uint8_t* src_argb,
+                                 ptrdiff_t src_stride,
+                                 int src_stepx,
+                                 uint8_t* dst_argb,
+                                 int dst_width) {
+  const uint8_t* src0_ptr = src_argb;
+  const uint8_t* src1_ptr = src_argb + src_stride;
+
+  uint64_t src0, src1, src_hi, src_lo;
+  uint64_t dest, dest_hi, dest_lo, dest0, dest1;
+
+  const uint64_t mask = 0x0ULL;
+  const uint64_t ph = 0x0002000200020002ULL;
+  const uint64_t shift = 0x2ULL;
+
+  __asm__ volatile(
+      "1:                                                           \n\t"
+
+      "lwc1       %[src0],         0x00(%[src0_ptr])                \n\t"
+      "punpcklbh  %[dest_lo],      %[src0],          %[mask]        \n\t"
+      "lwc1       %[src0],         0x04(%[src0_ptr])                \n\t"
+      "punpcklbh  %[dest_hi],      %[src0],          %[mask]        \n\t"
+
+      "lwc1       %[src1],         0x00(%[src1_ptr])                \n\t"
+      "punpcklbh  %[src_lo],       %[src1],          %[mask]        \n\t"
+      "lwc1       %[src1],         0x04(%[src1_ptr])                \n\t"
+      "punpcklbh  %[src_hi],       %[src1],          %[mask]        \n\t"
+      "paddh      %[dest_lo],      %[dest_lo],       %[src_lo]      \n\t"
+      "paddh      %[dest_hi],      %[dest_hi],       %[src_hi]      \n\t"
+      "paddh      %[dest0],        %[dest_hi],       %[dest_lo]     \n\t"
+      "paddh      %[dest0],        %[dest0],         %[ph]          \n\t"
+      "psrlh      %[dest0],        %[dest0],         %[shift]       \n\t"
+
+      "dadd       %[src0_ptr],     %[src0_ptr],      %[src_stepx_4] \n\t"
+      "dadd       %[src1_ptr],     %[src1_ptr],      %[src_stepx_4] \n\t"
+
+      "lwc1       %[src0],         0x00(%[src0_ptr])                \n\t"
+      "punpcklbh  %[dest_lo],      %[src0],          %[mask]        \n\t"
+      "lwc1       %[src0],         0x04(%[src0_ptr])                \n\t"
+      "punpcklbh  %[dest_hi],      %[src0],          %[mask]        \n\t"
+
+      "lwc1       %[src1],         0x00(%[src1_ptr])                \n\t"
+      "punpcklbh  %[src_lo],       %[src1],          %[mask]        \n\t"
+      "lwc1       %[src1],         0x04(%[src1_ptr])                \n\t"
+      "punpcklbh  %[src_hi],       %[src1],          %[mask]        \n\t"
+      "paddh      %[dest_lo],      %[dest_lo],       %[src_lo]      \n\t"
+      "paddh      %[dest_hi],      %[dest_hi],       %[src_hi]      \n\t"
+      "paddh      %[dest1],        %[dest_hi],       %[dest_lo]     \n\t"
+      "paddh      %[dest1],        %[dest1],         %[ph]          \n\t"
+      "psrlh      %[dest1],        %[dest1],         %[shift]       \n\t"
+
+      "packushb   %[dest],         %[dest0],          %[dest1]      \n\t"
+      "gssdlc1    %[dest],         0x07(%[dst_ptr])                 \n\t"
+      "gssdrc1    %[dest],         0x00(%[dst_ptr])                 \n\t"
+
+      "dadd       %[src0_ptr],     %[src0_ptr],      %[src_stepx_4] \n\t"
+      "dadd       %[src1_ptr],     %[src1_ptr],      %[src_stepx_4] \n\t"
+      "daddiu     %[dst_ptr],      %[dst_ptr],        0x08          \n\t"
+      "daddi      %[width],        %[width],         -0x02          \n\t"
+      "bnez       %[width],        1b                               \n\t"
+      : [src_hi] "=&f"(src_hi), [src_lo] "=&f"(src_lo),
+        [dest_hi] "=&f"(dest_hi), [dest_lo] "=&f"(dest_lo),
+        [dest0] "=&f"(dest0), [dest1] "=&f"(dest1), [src0] "=&f"(src0),
+        [src1] "=&f"(src1), [dest] "=&f"(dest)
+      : [src0_ptr] "r"(src0_ptr), [src1_ptr] "r"(src1_ptr),
+        [dst_ptr] "r"(dst_argb), [width] "r"(dst_width),
+        [src_stepx_4] "r"(src_stepx << 2), [shift] "f"(shift), [mask] "f"(mask),
+        [ph] "f"(ph)
+      : "memory");
+}
+
+// Scales a single row of pixels using point sampling.
+void ScaleARGBCols_MMI(uint8_t* dst_argb,
+                       const uint8_t* src_argb,
+                       int dst_width,
+                       int x,
+                       int dx) {
+  const uint32_t* src = (const uint32_t*)(src_argb);
+  uint32_t* dst = (uint32_t*)(dst_argb);
+
+  const uint32_t* src_tmp;
+
+  uint64_t dest, offset;
+
+  const uint64_t shift0 = 16;
+  const uint64_t shift1 = 2;
+
+  __asm__ volatile(
+      "1:                                                           \n\t"
+      "srav       %[offset],        %[x],             %[shift0]     \n\t"
+      "sllv       %[offset],        %[offset],        %[shift1]     \n\t"
+      "dadd       %[src_tmp],       %[src_ptr],       %[offset]     \n\t"
+      "lwc1       %[dest],          0x00(%[src_tmp])                \n\t"
+      "swc1       %[dest],          0x00(%[dst_ptr])                \n\t"
+
+      "dadd       %[x],             %[x],             %[dx]         \n\t"
+
+      "daddiu     %[dst_ptr],       %[dst_ptr],       0x04          \n\t"
+      "daddi      %[width],         %[width],        -0x01          \n\t"
+      "bnez       %[width],         1b                              \n\t"
+      : [dest] "=&f"(dest), [offset] "=&r"(offset), [src_tmp] "=&r"(src_tmp)
+      : [src_ptr] "r"(src), [dst_ptr] "r"(dst), [width] "r"(dst_width),
+        [dx] "r"(dx), [x] "r"(x), [shift0] "r"(shift0), [shift1] "r"(shift1)
+      : "memory");
+}
+
+// Scales a single row of pixels up by 2x using point sampling.
+void ScaleARGBColsUp2_MMI(uint8_t* dst_argb,
+                          const uint8_t* src_argb,
+                          int dst_width,
+                          int x,
+                          int dx) {
+  uint64_t src, dest0, dest1;
+  (void)x;
+  (void)dx;
+
+  __asm__ volatile(
+      "1:                                                           \n\t"
+      "gsldrc1    %[src],           0x00(%[src_ptr])                \n\t"
+      "gsldlc1    %[src],           0x07(%[src_ptr])                \n\t"
+      "punpcklwd  %[dest0],         %[src],           %[src]        \n\t"
+      "gssdlc1    %[dest0],         0x07(%[dst_ptr])                \n\t"
+      "gssdrc1    %[dest0],         0x00(%[dst_ptr])                \n\t"
+      "punpckhwd  %[dest1],         %[src],           %[src]        \n\t"
+      "gssdlc1    %[dest1],         0x0f(%[dst_ptr])                \n\t"
+      "gssdrc1    %[dest1],         0x08(%[dst_ptr])                \n\t"
+
+      "daddiu     %[src_ptr],       %[src_ptr],       0x08          \n\t"
+      "daddiu     %[dst_ptr],       %[dst_ptr],       0x10          \n\t"
+      "daddi      %[width],         %[width],        -0x04          \n\t"
+      "bnez       %[width],         1b                              \n\t"
+      : [dest0] "=&f"(dest0), [dest1] "=&f"(dest1), [src] "=&f"(src)
+      : [src_ptr] "r"(src_argb), [dst_ptr] "r"(dst_argb), [width] "r"(dst_width)
+      : "memory");
+}
+
+// Divide num by div and return as 16.16 fixed point result.
+/* LibYUVBaseTest.TestFixedDiv */
+int FixedDiv_MIPS(int num, int div) {
+  int quotient = 0;
+  const int shift = 16;
+
+  asm(
+      "dsll    %[num],     %[num],     %[shift]    \n\t"
+      "ddiv    %[num],     %[div]                  \t\n"
+      "mflo    %[quo]                              \t\n"
+      : [quo] "+&r"(quotient)
+      : [num] "r"(num), [div] "r"(div), [shift] "r"(shift));
+
+  return quotient;
+}
+
+// Divide num by div and return as 16.16 fixed point result.
+/* LibYUVScaleTest.ARGBScaleTo320x240_Linear */
+int FixedDiv1_MIPS(int num, int div) {
+  int quotient = 0;
+  const int shift = 16;
+  const int val1 = 1;
+  const int64_t val11 = 0x00010001ULL;
+
+  asm(
+      "dsll    %[num],     %[num],     %[shift]    \n\t"
+      "dsub    %[num],     %[num],     %[val11]    \n\t"
+      "dsub    %[div],     %[div],     %[val1]     \n\t"
+      "ddiv    %[num],     %[div]                  \t\n"
+      "mflo    %[quo]                              \t\n"
+      : [quo] "+&r"(quotient)
+      : [num] "r"(num), [div] "r"(div), [val1] "r"(val1), [val11] "r"(val11),
+        [shift] "r"(shift));
+
+  return quotient;
+}
+
+// Read 8x2 upsample with filtering and write 16x1.
+// actually reads an extra pixel, so 9x2.
+void ScaleRowUp2_16_MMI(const uint16_t* src_ptr,
+                        ptrdiff_t src_stride,
+                        uint16_t* dst,
+                        int dst_width) {
+  const uint16_t* src2_ptr = src_ptr + src_stride;
+
+  uint64_t src0, src1;
+  uint64_t dest, dest04, dest15, dest26, dest37;
+  uint64_t tmp0, tmp1, tmp2, tmp3;
+
+  const uint64_t mask0 = 0x0003000900030009ULL;
+  const uint64_t mask1 = 0x0001000300010003ULL;
+  const uint64_t mask2 = 0x0009000300090003ULL;
+  const uint64_t mask3 = 0x0003000100030001ULL;
+  const uint64_t ph = 0x0000000800000008ULL;
+  const uint64_t shift = 4;
+
+  __asm__ volatile(
+      "1:                                                           \n\t"
+      "gsldrc1    %[src0],          0x00(%[src1_ptr])               \n\t"
+      "gsldlc1    %[src0],          0x07(%[src1_ptr])               \n\t"
+      "pmaddhw    %[dest04],        %[src0],          %[mask0]      \n\t"
+      "gsldrc1    %[src1],          0x00(%[src2_ptr])               \n\t"
+      "gsldlc1    %[src1],          0x07(%[src2_ptr])               \n\t"
+      "pmaddhw    %[dest],          %[src1],          %[mask1]      \n\t"
+      "paddw      %[dest04],        %[dest04],        %[dest]       \n\t"
+      "paddw      %[dest04],        %[dest04],        %[ph]         \n\t"
+      "psrlw      %[dest04],        %[dest04],        %[shift]      \n\t"
+
+      "pmaddhw    %[dest15],        %[src0],          %[mask2]      \n\t"
+      "pmaddhw    %[dest],          %[src1],          %[mask3]      \n\t"
+      "paddw      %[dest15],        %[dest15],        %[dest]       \n\t"
+      "paddw      %[dest15],        %[dest15],        %[ph]         \n\t"
+      "psrlw      %[dest15],        %[dest15],        %[shift]      \n\t"
+
+      "gsldrc1    %[src0],          0x02(%[src1_ptr])               \n\t"
+      "gsldlc1    %[src0],          0x09(%[src1_ptr])               \n\t"
+      "pmaddhw    %[dest26],        %[src0],          %[mask0]      \n\t"
+      "gsldrc1    %[src1],          0x02(%[src2_ptr])               \n\t"
+      "gsldlc1    %[src1],          0x09(%[src2_ptr])               \n\t"
+      "pmaddhw    %[dest],          %[src1],          %[mask1]      \n\t"
+      "paddw      %[dest26],        %[dest26],        %[dest]       \n\t"
+      "paddw      %[dest26],        %[dest26],        %[ph]         \n\t"
+      "psrlw      %[dest26],        %[dest26],        %[shift]      \n\t"
+
+      "pmaddhw    %[dest37],        %[src0],          %[mask2]      \n\t"
+      "pmaddhw    %[dest],          %[src1],          %[mask3]      \n\t"
+      "paddw      %[dest37],        %[dest37],        %[dest]       \n\t"
+      "paddw      %[dest37],        %[dest37],        %[ph]         \n\t"
+      "psrlw      %[dest37],        %[dest37],        %[shift]      \n\t"
+
+      /* tmp0 = ( 00 04 02 06 ) */
+      "packsswh   %[tmp0],          %[dest04],        %[dest26]     \n\t"
+      /* tmp1 = ( 01 05 03 07 ) */
+      "packsswh   %[tmp1],          %[dest15],        %[dest37]     \n\t"
+
+      /* tmp2 = ( 00 01 04 05 )*/
+      "punpcklhw  %[tmp2],          %[tmp0],          %[tmp1]       \n\t"
+      /* tmp3 = ( 02 03 06 07 )*/
+      "punpckhhw  %[tmp3],          %[tmp0],          %[tmp1]       \n\t"
+
+      /* ( 00 01 02 03 ) */
+      "punpcklwd  %[dest],          %[tmp2],          %[tmp3]       \n\t"
+      "gssdlc1    %[dest],          0x07(%[dst_ptr])                \n\t"
+      "gssdrc1    %[dest],          0x00(%[dst_ptr])                \n\t"
+
+      /* ( 04 05 06 07 ) */
+      "punpckhwd  %[dest],          %[tmp2],          %[tmp3]       \n\t"
+      "gssdlc1    %[dest],          0x0f(%[dst_ptr])                \n\t"
+      "gssdrc1    %[dest],          0x08(%[dst_ptr])                \n\t"
+
+      "daddiu     %[src1_ptr],      %[src1_ptr],      0x08          \n\t"
+      "daddiu     %[src2_ptr],      %[src2_ptr],      0x08          \n\t"
+      "daddiu     %[dst_ptr],       %[dst_ptr],       0x10          \n\t"
+      "daddi      %[width],         %[width],        -0x08          \n\t"
+      "bnez       %[width],         1b                              \n\t"
+      : [src0] "=&f"(src0), [src1] "=&f"(src1), [dest04] "=&f"(dest04),
+        [dest15] "=&f"(dest15), [dest26] "=&f"(dest26), [dest37] "=&f"(dest37),
+        [tmp0] "=&f"(tmp0), [tmp1] "=&f"(tmp1), [tmp2] "=&f"(tmp2),
+        [tmp3] "=&f"(tmp3), [dest] "=&f"(dest)
+      : [src1_ptr] "r"(src_ptr), [src2_ptr] "r"(src2_ptr), [dst_ptr] "r"(dst),
+        [width] "r"(dst_width), [mask0] "f"(mask0), [mask1] "f"(mask1),
+        [mask2] "f"(mask2), [mask3] "f"(mask3), [shift] "f"(shift), [ph] "f"(ph)
+      : "memory");
+}
+
+void ScaleRowDown34_MMI(const uint8_t* src_ptr,
+                      ptrdiff_t src_stride,
+                      uint8_t* dst,
+                      int dst_width) {
+  (void)src_stride;
+  assert((dst_width % 3 == 0) && (dst_width > 0));
+  uint64_t src[2];
+  uint64_t tmp[2];
+  __asm__ volatile (
+    "1:                                                           \n\t"
+    "gsldlc1    %[src0],         0x07(%[src_ptr])                 \n\t"
+    "gsldrc1    %[src0],         0x00(%[src_ptr])                 \n\t"
+    "gsldlc1    %[src1],         0x0f(%[src_ptr])                 \n\t"
+    "gsldrc1    %[src1],         0x08(%[src_ptr])                 \n\t"
+    "and        %[tmp1],         %[src0],        %[mask1]         \n\t"
+    "psrlw      %[tmp0],         %[src0],        %[rmov]          \n\t"
+    "psllw      %[tmp0],         %[tmp0],        %[lmov1]         \n\t"
+    "or         %[src0],         %[tmp0],        %[tmp1]          \n\t"
+    "punpckhwd  %[tmp0],         %[src0],        %[src0]          \n\t"
+    "psllw      %[tmp1],         %[tmp0],        %[rmov]          \n\t"
+    "or         %[src0],         %[src0],        %[tmp1]          \n\t"
+    "psrlw      %[tmp0],         %[tmp0],        %[rmov8]         \n\t"
+    "pextrh     %[tmp0],         %[tmp0],        %[zero]          \n\t"
+    "pinsrh_2   %[src0],         %[src0],        %[tmp0]          \n\t"
+    "pextrh     %[tmp0],         %[src1],        %[zero]          \n\t"
+    "pinsrh_3   %[src0],         %[src0],        %[tmp0]          \n\t"
+
+    "punpckhwd  %[tmp0],         %[src1],        %[src1]          \n\t"
+    "pextrh     %[tmp1],         %[tmp0],        %[zero]          \n\t"
+    "psrlw      %[src1],         %[src1],        %[rmov]          \n\t"
+    "psllw      %[tmp1],         %[tmp1],        %[rmov8]         \n\t"
+    "or         %[src1],         %[src1],        %[tmp1]          \n\t"
+    "and        %[tmp0],         %[tmp0],        %[mask2]         \n\t"
+    "or         %[src1],         %[src1],        %[tmp0]          \n\t"
+
+    "gssdlc1    %[src0],         0x07(%[dst_ptr])                 \n\t"
+    "gssdrc1    %[src0],         0x00(%[dst_ptr])                 \n\t"
+    "gsswlc1    %[src1],         0x0b(%[dst_ptr])                 \n\t"
+    "gsswrc1    %[src1],         0x08(%[dst_ptr])                 \n\t"
+
+    "daddiu     %[src_ptr],      %[src_ptr],     0x10             \n\t"
+    "daddi      %[width],        %[width],      -0x0c             \n\t"
+    "daddiu     %[dst_ptr],      %[dst_ptr],     0x0c             \n\t"
+    "bnez       %[width],        1b                               \n\t"
+
+    : [src0]"=&f"(src[0]),              [src1]"=&f"(src[1]),
+      [tmp0]"=&f"(tmp[0]),              [tmp1]"=&f"(tmp[1])
+    : [src_ptr]"r"(src_ptr),            [dst_ptr]"r"(dst),
+      [lmov]"f"(0xc),                   [rmov]"f"(0x18),
+      [mask1]"f"(0xffff0000ffff),       [rmov8]"f"(0x8),
+      [zero]"f"(0x0),                   [mask2]"f"(0xff000000),
+      [width]"r"(dst_width),            [lmov1]"f"(0x10)
+    : "memory"
+  );
+}
+// clang-format on
+
+#endif  // !defined(LIBYUV_DISABLE_MMI) && defined(_MIPS_ARCH_LOONGSON3A)
+
+#ifdef __cplusplus
+}  // extern "C"
+}  // namespace libyuv
+#endif
diff --git a/3rdparty/libyuv/src/source/scale_msa.cc b/3rdparty/libyuv/src/source/scale_msa.cc
new file mode 100644
index 00000000..482a521f
--- /dev/null
+++ b/3rdparty/libyuv/src/source/scale_msa.cc
@@ -0,0 +1,949 @@
+/*
+ *  Copyright 2016 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include <assert.h>
+
+#include "libyuv/scale_row.h"
+
+// This module is for GCC MSA
+#if !defined(LIBYUV_DISABLE_MSA) && defined(__mips_msa)
+#include "libyuv/macros_msa.h"
+
+#ifdef __cplusplus
+namespace libyuv {
+extern "C" {
+#endif
+
+#define LOAD_INDEXED_DATA(srcp, indx0, out0) \
+  {                                          \
+    out0[0] = srcp[indx0[0]];                \
+    out0[1] = srcp[indx0[1]];                \
+    out0[2] = srcp[indx0[2]];                \
+    out0[3] = srcp[indx0[3]];                \
+  }
+
+void ScaleARGBRowDown2_MSA(const uint8_t* src_argb,
+                           ptrdiff_t src_stride,
+                           uint8_t* dst_argb,
+                           int dst_width) {
+  int x;
+  v16u8 src0, src1, dst0;
+  (void)src_stride;
+
+  for (x = 0; x < dst_width; x += 4) {
+    src0 = (v16u8)__msa_ld_b((v16i8*)src_argb, 0);
+    src1 = (v16u8)__msa_ld_b((v16i8*)src_argb, 16);
+    dst0 = (v16u8)__msa_pckod_w((v4i32)src1, (v4i32)src0);
+    ST_UB(dst0, dst_argb);
+    src_argb += 32;
+    dst_argb += 16;
+  }
+}
+
+void ScaleARGBRowDown2Linear_MSA(const uint8_t* src_argb,
+                                 ptrdiff_t src_stride,
+                                 uint8_t* dst_argb,
+                                 int dst_width) {
+  int x;
+  v16u8 src0, src1, vec0, vec1, dst0;
+  (void)src_stride;
+
+  for (x = 0; x < dst_width; x += 4) {
+    src0 = (v16u8)__msa_ld_b((v16i8*)src_argb, 0);
+    src1 = (v16u8)__msa_ld_b((v16i8*)src_argb, 16);
+    vec0 = (v16u8)__msa_pckev_w((v4i32)src1, (v4i32)src0);
+    vec1 = (v16u8)__msa_pckod_w((v4i32)src1, (v4i32)src0);
+    dst0 = (v16u8)__msa_aver_u_b((v16u8)vec0, (v16u8)vec1);
+    ST_UB(dst0, dst_argb);
+    src_argb += 32;
+    dst_argb += 16;
+  }
+}
+
+void ScaleARGBRowDown2Box_MSA(const uint8_t* src_argb,
+                              ptrdiff_t src_stride,
+                              uint8_t* dst_argb,
+                              int dst_width) {
+  int x;
+  const uint8_t* s = src_argb;
+  const uint8_t* t = src_argb + src_stride;
+  v16u8 src0, src1, src2, src3, vec0, vec1, vec2, vec3, dst0;
+  v8u16 reg0, reg1, reg2, reg3;
+  v16i8 shuffler = {0, 4, 1, 5, 2, 6, 3, 7, 8, 12, 9, 13, 10, 14, 11, 15};
+
+  for (x = 0; x < dst_width; x += 4) {
+    src0 = (v16u8)__msa_ld_b((v16i8*)s, 0);
+    src1 = (v16u8)__msa_ld_b((v16i8*)s, 16);
+    src2 = (v16u8)__msa_ld_b((v16i8*)t, 0);
+    src3 = (v16u8)__msa_ld_b((v16i8*)t, 16);
+    vec0 = (v16u8)__msa_vshf_b(shuffler, (v16i8)src0, (v16i8)src0);
+    vec1 = (v16u8)__msa_vshf_b(shuffler, (v16i8)src1, (v16i8)src1);
+    vec2 = (v16u8)__msa_vshf_b(shuffler, (v16i8)src2, (v16i8)src2);
+    vec3 = (v16u8)__msa_vshf_b(shuffler, (v16i8)src3, (v16i8)src3);
+    reg0 = __msa_hadd_u_h(vec0, vec0);
+    reg1 = __msa_hadd_u_h(vec1, vec1);
+    reg2 = __msa_hadd_u_h(vec2, vec2);
+    reg3 = __msa_hadd_u_h(vec3, vec3);
+    reg0 += reg2;
+    reg1 += reg3;
+    reg0 = (v8u16)__msa_srari_h((v8i16)reg0, 2);
+    reg1 = (v8u16)__msa_srari_h((v8i16)reg1, 2);
+    dst0 = (v16u8)__msa_pckev_b((v16i8)reg1, (v16i8)reg0);
+    ST_UB(dst0, dst_argb);
+    s += 32;
+    t += 32;
+    dst_argb += 16;
+  }
+}
+
+void ScaleARGBRowDownEven_MSA(const uint8_t* src_argb,
+                              ptrdiff_t src_stride,
+                              int32_t src_stepx,
+                              uint8_t* dst_argb,
+                              int dst_width) {
+  int x;
+  int32_t stepx = src_stepx * 4;
+  int32_t data0, data1, data2, data3;
+  (void)src_stride;
+
+  for (x = 0; x < dst_width; x += 4) {
+    data0 = LW(src_argb);
+    data1 = LW(src_argb + stepx);
+    data2 = LW(src_argb + stepx * 2);
+    data3 = LW(src_argb + stepx * 3);
+    SW(data0, dst_argb);
+    SW(data1, dst_argb + 4);
+    SW(data2, dst_argb + 8);
+    SW(data3, dst_argb + 12);
+    src_argb += stepx * 4;
+    dst_argb += 16;
+  }
+}
+
+void ScaleARGBRowDownEvenBox_MSA(const uint8_t* src_argb,
+                                 ptrdiff_t src_stride,
+                                 int src_stepx,
+                                 uint8_t* dst_argb,
+                                 int dst_width) {
+  int x;
+  const uint8_t* nxt_argb = src_argb + src_stride;
+  int32_t stepx = src_stepx * 4;
+  int64_t data0, data1, data2, data3;
+  v16u8 src0 = {0}, src1 = {0}, src2 = {0}, src3 = {0};
+  v16u8 vec0, vec1, vec2, vec3;
+  v8u16 reg0, reg1, reg2, reg3, reg4, reg5, reg6, reg7;
+  v16u8 dst0;
+
+  for (x = 0; x < dst_width; x += 4) {
+    data0 = LD(src_argb);
+    data1 = LD(src_argb + stepx);
+    data2 = LD(src_argb + stepx * 2);
+    data3 = LD(src_argb + stepx * 3);
+    src0 = (v16u8)__msa_insert_d((v2i64)src0, 0, data0);
+    src0 = (v16u8)__msa_insert_d((v2i64)src0, 1, data1);
+    src1 = (v16u8)__msa_insert_d((v2i64)src1, 0, data2);
+    src1 = (v16u8)__msa_insert_d((v2i64)src1, 1, data3);
+    data0 = LD(nxt_argb);
+    data1 = LD(nxt_argb + stepx);
+    data2 = LD(nxt_argb + stepx * 2);
+    data3 = LD(nxt_argb + stepx * 3);
+    src2 = (v16u8)__msa_insert_d((v2i64)src2, 0, data0);
+    src2 = (v16u8)__msa_insert_d((v2i64)src2, 1, data1);
+    src3 = (v16u8)__msa_insert_d((v2i64)src3, 0, data2);
+    src3 = (v16u8)__msa_insert_d((v2i64)src3, 1, data3);
+    vec0 = (v16u8)__msa_ilvr_b((v16i8)src2, (v16i8)src0);
+    vec1 = (v16u8)__msa_ilvr_b((v16i8)src3, (v16i8)src1);
+    vec2 = (v16u8)__msa_ilvl_b((v16i8)src2, (v16i8)src0);
+    vec3 = (v16u8)__msa_ilvl_b((v16i8)src3, (v16i8)src1);
+    reg0 = __msa_hadd_u_h(vec0, vec0);
+    reg1 = __msa_hadd_u_h(vec1, vec1);
+    reg2 = __msa_hadd_u_h(vec2, vec2);
+    reg3 = __msa_hadd_u_h(vec3, vec3);
+    reg4 = (v8u16)__msa_pckev_d((v2i64)reg2, (v2i64)reg0);
+    reg5 = (v8u16)__msa_pckev_d((v2i64)reg3, (v2i64)reg1);
+    reg6 = (v8u16)__msa_pckod_d((v2i64)reg2, (v2i64)reg0);
+    reg7 = (v8u16)__msa_pckod_d((v2i64)reg3, (v2i64)reg1);
+    reg4 += reg6;
+    reg5 += reg7;
+    reg4 = (v8u16)__msa_srari_h((v8i16)reg4, 2);
+    reg5 = (v8u16)__msa_srari_h((v8i16)reg5, 2);
+    dst0 = (v16u8)__msa_pckev_b((v16i8)reg5, (v16i8)reg4);
+    ST_UB(dst0, dst_argb);
+    src_argb += stepx * 4;
+    nxt_argb += stepx * 4;
+    dst_argb += 16;
+  }
+}
+
+void ScaleRowDown2_MSA(const uint8_t* src_ptr,
+                       ptrdiff_t src_stride,
+                       uint8_t* dst,
+                       int dst_width) {
+  int x;
+  v16u8 src0, src1, src2, src3, dst0, dst1;
+  (void)src_stride;
+
+  for (x = 0; x < dst_width; x += 32) {
+    src0 = (v16u8)__msa_ld_b((v16i8*)src_ptr, 0);
+    src1 = (v16u8)__msa_ld_b((v16i8*)src_ptr, 16);
+    src2 = (v16u8)__msa_ld_b((v16i8*)src_ptr, 32);
+    src3 = (v16u8)__msa_ld_b((v16i8*)src_ptr, 48);
+    dst0 = (v16u8)__msa_pckod_b((v16i8)src1, (v16i8)src0);
+    dst1 = (v16u8)__msa_pckod_b((v16i8)src3, (v16i8)src2);
+    ST_UB2(dst0, dst1, dst, 16);
+    src_ptr += 64;
+    dst += 32;
+  }
+}
+
+void ScaleRowDown2Linear_MSA(const uint8_t* src_ptr,
+                             ptrdiff_t src_stride,
+                             uint8_t* dst,
+                             int dst_width) {
+  int x;
+  v16u8 src0, src1, src2, src3, vec0, vec1, vec2, vec3, dst0, dst1;
+  (void)src_stride;
+
+  for (x = 0; x < dst_width; x += 32) {
+    src0 = (v16u8)__msa_ld_b((v16i8*)src_ptr, 0);
+    src1 = (v16u8)__msa_ld_b((v16i8*)src_ptr, 16);
+    src2 = (v16u8)__msa_ld_b((v16i8*)src_ptr, 32);
+    src3 = (v16u8)__msa_ld_b((v16i8*)src_ptr, 48);
+    vec0 = (v16u8)__msa_pckev_b((v16i8)src1, (v16i8)src0);
+    vec2 = (v16u8)__msa_pckev_b((v16i8)src3, (v16i8)src2);
+    vec1 = (v16u8)__msa_pckod_b((v16i8)src1, (v16i8)src0);
+    vec3 = (v16u8)__msa_pckod_b((v16i8)src3, (v16i8)src2);
+    dst0 = __msa_aver_u_b(vec1, vec0);
+    dst1 = __msa_aver_u_b(vec3, vec2);
+    ST_UB2(dst0, dst1, dst, 16);
+    src_ptr += 64;
+    dst += 32;
+  }
+}
+
+void ScaleRowDown2Box_MSA(const uint8_t* src_ptr,
+                          ptrdiff_t src_stride,
+                          uint8_t* dst,
+                          int dst_width) {
+  int x;
+  const uint8_t* s = src_ptr;
+  const uint8_t* t = src_ptr + src_stride;
+  v16u8 src0, src1, src2, src3, src4, src5, src6, src7, dst0, dst1;
+  v8u16 vec0, vec1, vec2, vec3;
+
+  for (x = 0; x < dst_width; x += 32) {
+    src0 = (v16u8)__msa_ld_b((v16i8*)s, 0);
+    src1 = (v16u8)__msa_ld_b((v16i8*)s, 16);
+    src2 = (v16u8)__msa_ld_b((v16i8*)s, 32);
+    src3 = (v16u8)__msa_ld_b((v16i8*)s, 48);
+    src4 = (v16u8)__msa_ld_b((v16i8*)t, 0);
+    src5 = (v16u8)__msa_ld_b((v16i8*)t, 16);
+    src6 = (v16u8)__msa_ld_b((v16i8*)t, 32);
+    src7 = (v16u8)__msa_ld_b((v16i8*)t, 48);
+    vec0 = __msa_hadd_u_h(src0, src0);
+    vec1 = __msa_hadd_u_h(src1, src1);
+    vec2 = __msa_hadd_u_h(src2, src2);
+    vec3 = __msa_hadd_u_h(src3, src3);
+    vec0 += __msa_hadd_u_h(src4, src4);
+    vec1 += __msa_hadd_u_h(src5, src5);
+    vec2 += __msa_hadd_u_h(src6, src6);
+    vec3 += __msa_hadd_u_h(src7, src7);
+    vec0 = (v8u16)__msa_srari_h((v8i16)vec0, 2);
+    vec1 = (v8u16)__msa_srari_h((v8i16)vec1, 2);
+    vec2 = (v8u16)__msa_srari_h((v8i16)vec2, 2);
+    vec3 = (v8u16)__msa_srari_h((v8i16)vec3, 2);
+    dst0 = (v16u8)__msa_pckev_b((v16i8)vec1, (v16i8)vec0);
+    dst1 = (v16u8)__msa_pckev_b((v16i8)vec3, (v16i8)vec2);
+    ST_UB2(dst0, dst1, dst, 16);
+    s += 64;
+    t += 64;
+    dst += 32;
+  }
+}
+
+void ScaleRowDown4_MSA(const uint8_t* src_ptr,
+                       ptrdiff_t src_stride,
+                       uint8_t* dst,
+                       int dst_width) {
+  int x;
+  v16u8 src0, src1, src2, src3, vec0, vec1, dst0;
+  (void)src_stride;
+
+  for (x = 0; x < dst_width; x += 16) {
+    src0 = (v16u8)__msa_ld_b((v16i8*)src_ptr, 0);
+    src1 = (v16u8)__msa_ld_b((v16i8*)src_ptr, 16);
+    src2 = (v16u8)__msa_ld_b((v16i8*)src_ptr, 32);
+    src3 = (v16u8)__msa_ld_b((v16i8*)src_ptr, 48);
+    vec0 = (v16u8)__msa_pckev_b((v16i8)src1, (v16i8)src0);
+    vec1 = (v16u8)__msa_pckev_b((v16i8)src3, (v16i8)src2);
+    dst0 = (v16u8)__msa_pckod_b((v16i8)vec1, (v16i8)vec0);
+    ST_UB(dst0, dst);
+    src_ptr += 64;
+    dst += 16;
+  }
+}
+
+void ScaleRowDown4Box_MSA(const uint8_t* src_ptr,
+                          ptrdiff_t src_stride,
+                          uint8_t* dst,
+                          int dst_width) {
+  int x;
+  const uint8_t* s = src_ptr;
+  const uint8_t* t0 = s + src_stride;
+  const uint8_t* t1 = s + src_stride * 2;
+  const uint8_t* t2 = s + src_stride * 3;
+  v16u8 src0, src1, src2, src3, src4, src5, src6, src7, dst0;
+  v8u16 vec0, vec1, vec2, vec3;
+  v4u32 reg0, reg1, reg2, reg3;
+
+  for (x = 0; x < dst_width; x += 16) {
+    src0 = (v16u8)__msa_ld_b((v16i8*)s, 0);
+    src1 = (v16u8)__msa_ld_b((v16i8*)s, 16);
+    src2 = (v16u8)__msa_ld_b((v16i8*)s, 32);
+    src3 = (v16u8)__msa_ld_b((v16i8*)s, 48);
+    src4 = (v16u8)__msa_ld_b((v16i8*)t0, 0);
+    src5 = (v16u8)__msa_ld_b((v16i8*)t0, 16);
+    src6 = (v16u8)__msa_ld_b((v16i8*)t0, 32);
+    src7 = (v16u8)__msa_ld_b((v16i8*)t0, 48);
+    vec0 = __msa_hadd_u_h(src0, src0);
+    vec1 = __msa_hadd_u_h(src1, src1);
+    vec2 = __msa_hadd_u_h(src2, src2);
+    vec3 = __msa_hadd_u_h(src3, src3);
+    vec0 += __msa_hadd_u_h(src4, src4);
+    vec1 += __msa_hadd_u_h(src5, src5);
+    vec2 += __msa_hadd_u_h(src6, src6);
+    vec3 += __msa_hadd_u_h(src7, src7);
+    src0 = (v16u8)__msa_ld_b((v16i8*)t1, 0);
+    src1 = (v16u8)__msa_ld_b((v16i8*)t1, 16);
+    src2 = (v16u8)__msa_ld_b((v16i8*)t1, 32);
+    src3 = (v16u8)__msa_ld_b((v16i8*)t1, 48);
+    src4 = (v16u8)__msa_ld_b((v16i8*)t2, 0);
+    src5 = (v16u8)__msa_ld_b((v16i8*)t2, 16);
+    src6 = (v16u8)__msa_ld_b((v16i8*)t2, 32);
+    src7 = (v16u8)__msa_ld_b((v16i8*)t2, 48);
+    vec0 += __msa_hadd_u_h(src0, src0);
+    vec1 += __msa_hadd_u_h(src1, src1);
+    vec2 += __msa_hadd_u_h(src2, src2);
+    vec3 += __msa_hadd_u_h(src3, src3);
+    vec0 += __msa_hadd_u_h(src4, src4);
+    vec1 += __msa_hadd_u_h(src5, src5);
+    vec2 += __msa_hadd_u_h(src6, src6);
+    vec3 += __msa_hadd_u_h(src7, src7);
+    reg0 = __msa_hadd_u_w(vec0, vec0);
+    reg1 = __msa_hadd_u_w(vec1, vec1);
+    reg2 = __msa_hadd_u_w(vec2, vec2);
+    reg3 = __msa_hadd_u_w(vec3, vec3);
+    reg0 = (v4u32)__msa_srari_w((v4i32)reg0, 4);
+    reg1 = (v4u32)__msa_srari_w((v4i32)reg1, 4);
+    reg2 = (v4u32)__msa_srari_w((v4i32)reg2, 4);
+    reg3 = (v4u32)__msa_srari_w((v4i32)reg3, 4);
+    vec0 = (v8u16)__msa_pckev_h((v8i16)reg1, (v8i16)reg0);
+    vec1 = (v8u16)__msa_pckev_h((v8i16)reg3, (v8i16)reg2);
+    dst0 = (v16u8)__msa_pckev_b((v16i8)vec1, (v16i8)vec0);
+    ST_UB(dst0, dst);
+    s += 64;
+    t0 += 64;
+    t1 += 64;
+    t2 += 64;
+    dst += 16;
+  }
+}
+
+void ScaleRowDown38_MSA(const uint8_t* src_ptr,
+                        ptrdiff_t src_stride,
+                        uint8_t* dst,
+                        int dst_width) {
+  int x, width;
+  uint64_t dst0;
+  uint32_t dst1;
+  v16u8 src0, src1, vec0;
+  v16i8 mask = {0, 3, 6, 8, 11, 14, 16, 19, 22, 24, 27, 30, 0, 0, 0, 0};
+  (void)src_stride;
+
+  assert(dst_width % 3 == 0);
+  width = dst_width / 3;
+
+  for (x = 0; x < width; x += 4) {
+    src0 = (v16u8)__msa_ld_b((v16i8*)src_ptr, 0);
+    src1 = (v16u8)__msa_ld_b((v16i8*)src_ptr, 16);
+    vec0 = (v16u8)__msa_vshf_b(mask, (v16i8)src1, (v16i8)src0);
+    dst0 = __msa_copy_u_d((v2i64)vec0, 0);
+    dst1 = __msa_copy_u_w((v4i32)vec0, 2);
+    SD(dst0, dst);
+    SW(dst1, dst + 8);
+    src_ptr += 32;
+    dst += 12;
+  }
+}
+
+void ScaleRowDown38_2_Box_MSA(const uint8_t* src_ptr,
+                              ptrdiff_t src_stride,
+                              uint8_t* dst_ptr,
+                              int dst_width) {
+  int x, width;
+  const uint8_t* s = src_ptr;
+  const uint8_t* t = src_ptr + src_stride;
+  uint64_t dst0;
+  uint32_t dst1;
+  v16u8 src0, src1, src2, src3, out;
+  v8u16 vec0, vec1, vec2, vec3, vec4, vec5, vec6, vec7;
+  v4u32 tmp0, tmp1, tmp2, tmp3, tmp4;
+  v8i16 zero = {0};
+  v8i16 mask = {0, 1, 2, 8, 3, 4, 5, 9};
+  v16i8 dst_mask = {0, 2, 16, 4, 6, 18, 8, 10, 20, 12, 14, 22, 0, 0, 0, 0};
+  v4u32 const_0x2AAA = (v4u32)__msa_fill_w(0x2AAA);
+  v4u32 const_0x4000 = (v4u32)__msa_fill_w(0x4000);
+
+  assert((dst_width % 3 == 0) && (dst_width > 0));
+  width = dst_width / 3;
+
+  for (x = 0; x < width; x += 4) {
+    src0 = (v16u8)__msa_ld_b((v16i8*)s, 0);
+    src1 = (v16u8)__msa_ld_b((v16i8*)s, 16);
+    src2 = (v16u8)__msa_ld_b((v16i8*)t, 0);
+    src3 = (v16u8)__msa_ld_b((v16i8*)t, 16);
+    vec0 = (v8u16)__msa_ilvr_b((v16i8)src2, (v16i8)src0);
+    vec1 = (v8u16)__msa_ilvl_b((v16i8)src2, (v16i8)src0);
+    vec2 = (v8u16)__msa_ilvr_b((v16i8)src3, (v16i8)src1);
+    vec3 = (v8u16)__msa_ilvl_b((v16i8)src3, (v16i8)src1);
+    vec0 = __msa_hadd_u_h((v16u8)vec0, (v16u8)vec0);
+    vec1 = __msa_hadd_u_h((v16u8)vec1, (v16u8)vec1);
+    vec2 = __msa_hadd_u_h((v16u8)vec2, (v16u8)vec2);
+    vec3 = __msa_hadd_u_h((v16u8)vec3, (v16u8)vec3);
+    vec4 = (v8u16)__msa_vshf_h(mask, zero, (v8i16)vec0);
+    vec5 = (v8u16)__msa_vshf_h(mask, zero, (v8i16)vec1);
+    vec6 = (v8u16)__msa_vshf_h(mask, zero, (v8i16)vec2);
+    vec7 = (v8u16)__msa_vshf_h(mask, zero, (v8i16)vec3);
+    vec0 = (v8u16)__msa_pckod_w((v4i32)vec1, (v4i32)vec0);
+    vec1 = (v8u16)__msa_pckod_w((v4i32)vec3, (v4i32)vec2);
+    vec0 = (v8u16)__msa_pckod_w((v4i32)vec1, (v4i32)vec0);
+    tmp0 = __msa_hadd_u_w(vec4, vec4);
+    tmp1 = __msa_hadd_u_w(vec5, vec5);
+    tmp2 = __msa_hadd_u_w(vec6, vec6);
+    tmp3 = __msa_hadd_u_w(vec7, vec7);
+    tmp4 = __msa_hadd_u_w(vec0, vec0);
+    vec0 = (v8u16)__msa_pckev_h((v8i16)tmp1, (v8i16)tmp0);
+    vec1 = (v8u16)__msa_pckev_h((v8i16)tmp3, (v8i16)tmp2);
+    tmp0 = __msa_hadd_u_w(vec0, vec0);
+    tmp1 = __msa_hadd_u_w(vec1, vec1);
+    tmp0 *= const_0x2AAA;
+    tmp1 *= const_0x2AAA;
+    tmp4 *= const_0x4000;
+    tmp0 = (v4u32)__msa_srai_w((v4i32)tmp0, 16);
+    tmp1 = (v4u32)__msa_srai_w((v4i32)tmp1, 16);
+    tmp4 = (v4u32)__msa_srai_w((v4i32)tmp4, 16);
+    vec0 = (v8u16)__msa_pckev_h((v8i16)tmp1, (v8i16)tmp0);
+    vec1 = (v8u16)__msa_pckev_h((v8i16)tmp4, (v8i16)tmp4);
+    out = (v16u8)__msa_vshf_b(dst_mask, (v16i8)vec1, (v16i8)vec0);
+    dst0 = __msa_copy_u_d((v2i64)out, 0);
+    dst1 = __msa_copy_u_w((v4i32)out, 2);
+    SD(dst0, dst_ptr);
+    SW(dst1, dst_ptr + 8);
+    s += 32;
+    t += 32;
+    dst_ptr += 12;
+  }
+}
+
+void ScaleRowDown38_3_Box_MSA(const uint8_t* src_ptr,
+                              ptrdiff_t src_stride,
+                              uint8_t* dst_ptr,
+                              int dst_width) {
+  int x, width;
+  const uint8_t* s = src_ptr;
+  const uint8_t* t0 = s + src_stride;
+  const uint8_t* t1 = s + src_stride * 2;
+  uint64_t dst0;
+  uint32_t dst1;
+  v16u8 src0, src1, src2, src3, src4, src5, out;
+  v8u16 vec0, vec1, vec2, vec3, vec4, vec5, vec6, vec7;
+  v4u32 tmp0, tmp1, tmp2, tmp3, tmp4;
+  v8u16 zero = {0};
+  v8i16 mask = {0, 1, 2, 8, 3, 4, 5, 9};
+  v16i8 dst_mask = {0, 2, 16, 4, 6, 18, 8, 10, 20, 12, 14, 22, 0, 0, 0, 0};
+  v4u32 const_0x1C71 = (v4u32)__msa_fill_w(0x1C71);
+  v4u32 const_0x2AAA = (v4u32)__msa_fill_w(0x2AAA);
+
+  assert((dst_width % 3 == 0) && (dst_width > 0));
+  width = dst_width / 3;
+
+  for (x = 0; x < width; x += 4) {
+    src0 = (v16u8)__msa_ld_b((v16i8*)s, 0);
+    src1 = (v16u8)__msa_ld_b((v16i8*)s, 16);
+    src2 = (v16u8)__msa_ld_b((v16i8*)t0, 0);
+    src3 = (v16u8)__msa_ld_b((v16i8*)t0, 16);
+    src4 = (v16u8)__msa_ld_b((v16i8*)t1, 0);
+    src5 = (v16u8)__msa_ld_b((v16i8*)t1, 16);
+    vec0 = (v8u16)__msa_ilvr_b((v16i8)src2, (v16i8)src0);
+    vec1 = (v8u16)__msa_ilvl_b((v16i8)src2, (v16i8)src0);
+    vec2 = (v8u16)__msa_ilvr_b((v16i8)src3, (v16i8)src1);
+    vec3 = (v8u16)__msa_ilvl_b((v16i8)src3, (v16i8)src1);
+    vec4 = (v8u16)__msa_ilvr_b((v16i8)zero, (v16i8)src4);
+    vec5 = (v8u16)__msa_ilvl_b((v16i8)zero, (v16i8)src4);
+    vec6 = (v8u16)__msa_ilvr_b((v16i8)zero, (v16i8)src5);
+    vec7 = (v8u16)__msa_ilvl_b((v16i8)zero, (v16i8)src5);
+    vec0 = __msa_hadd_u_h((v16u8)vec0, (v16u8)vec0);
+    vec1 = __msa_hadd_u_h((v16u8)vec1, (v16u8)vec1);
+    vec2 = __msa_hadd_u_h((v16u8)vec2, (v16u8)vec2);
+    vec3 = __msa_hadd_u_h((v16u8)vec3, (v16u8)vec3);
+    vec0 += __msa_hadd_u_h((v16u8)vec4, (v16u8)vec4);
+    vec1 += __msa_hadd_u_h((v16u8)vec5, (v16u8)vec5);
+    vec2 += __msa_hadd_u_h((v16u8)vec6, (v16u8)vec6);
+    vec3 += __msa_hadd_u_h((v16u8)vec7, (v16u8)vec7);
+    vec4 = (v8u16)__msa_vshf_h(mask, (v8i16)zero, (v8i16)vec0);
+    vec5 = (v8u16)__msa_vshf_h(mask, (v8i16)zero, (v8i16)vec1);
+    vec6 = (v8u16)__msa_vshf_h(mask, (v8i16)zero, (v8i16)vec2);
+    vec7 = (v8u16)__msa_vshf_h(mask, (v8i16)zero, (v8i16)vec3);
+    vec0 = (v8u16)__msa_pckod_w((v4i32)vec1, (v4i32)vec0);
+    vec1 = (v8u16)__msa_pckod_w((v4i32)vec3, (v4i32)vec2);
+    vec0 = (v8u16)__msa_pckod_w((v4i32)vec1, (v4i32)vec0);
+    tmp0 = __msa_hadd_u_w(vec4, vec4);
+    tmp1 = __msa_hadd_u_w(vec5, vec5);
+    tmp2 = __msa_hadd_u_w(vec6, vec6);
+    tmp3 = __msa_hadd_u_w(vec7, vec7);
+    tmp4 = __msa_hadd_u_w(vec0, vec0);
+    vec0 = (v8u16)__msa_pckev_h((v8i16)tmp1, (v8i16)tmp0);
+    vec1 = (v8u16)__msa_pckev_h((v8i16)tmp3, (v8i16)tmp2);
+    tmp0 = __msa_hadd_u_w(vec0, vec0);
+    tmp1 = __msa_hadd_u_w(vec1, vec1);
+    tmp0 *= const_0x1C71;
+    tmp1 *= const_0x1C71;
+    tmp4 *= const_0x2AAA;
+    tmp0 = (v4u32)__msa_srai_w((v4i32)tmp0, 16);
+    tmp1 = (v4u32)__msa_srai_w((v4i32)tmp1, 16);
+    tmp4 = (v4u32)__msa_srai_w((v4i32)tmp4, 16);
+    vec0 = (v8u16)__msa_pckev_h((v8i16)tmp1, (v8i16)tmp0);
+    vec1 = (v8u16)__msa_pckev_h((v8i16)tmp4, (v8i16)tmp4);
+    out = (v16u8)__msa_vshf_b(dst_mask, (v16i8)vec1, (v16i8)vec0);
+    dst0 = __msa_copy_u_d((v2i64)out, 0);
+    dst1 = __msa_copy_u_w((v4i32)out, 2);
+    SD(dst0, dst_ptr);
+    SW(dst1, dst_ptr + 8);
+    s += 32;
+    t0 += 32;
+    t1 += 32;
+    dst_ptr += 12;
+  }
+}
+
+void ScaleAddRow_MSA(const uint8_t* src_ptr, uint16_t* dst_ptr, int src_width) {
+  int x;
+  v16u8 src0;
+  v8u16 dst0, dst1;
+  v16i8 zero = {0};
+
+  assert(src_width > 0);
+
+  for (x = 0; x < src_width; x += 16) {
+    src0 = LD_UB(src_ptr);
+    dst0 = (v8u16)__msa_ld_h((v8i16*)dst_ptr, 0);
+    dst1 = (v8u16)__msa_ld_h((v8i16*)dst_ptr, 16);
+    dst0 += (v8u16)__msa_ilvr_b(zero, (v16i8)src0);
+    dst1 += (v8u16)__msa_ilvl_b(zero, (v16i8)src0);
+    ST_UH2(dst0, dst1, dst_ptr, 8);
+    src_ptr += 16;
+    dst_ptr += 16;
+  }
+}
+
+void ScaleFilterCols_MSA(uint8_t* dst_ptr,
+                         const uint8_t* src_ptr,
+                         int dst_width,
+                         int x,
+                         int dx) {
+  int j;
+  v4i32 vec_x = __msa_fill_w(x);
+  v4i32 vec_dx = __msa_fill_w(dx);
+  v4i32 vec_const = {0, 1, 2, 3};
+  v4i32 vec0, vec1, vec2, vec3, vec4, vec5, vec6, vec7, vec8, vec9;
+  v4i32 tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
+  v8u16 reg0, reg1;
+  v16u8 dst0;
+  v4i32 const_0xFFFF = __msa_fill_w(0xFFFF);
+  v4i32 const_0x40 = __msa_fill_w(0x40);
+
+  vec0 = vec_dx * vec_const;
+  vec1 = vec_dx * 4;
+  vec_x += vec0;
+
+  for (j = 0; j < dst_width - 1; j += 16) {
+    vec2 = vec_x >> 16;
+    vec6 = vec_x & const_0xFFFF;
+    vec_x += vec1;
+    vec3 = vec_x >> 16;
+    vec7 = vec_x & const_0xFFFF;
+    vec_x += vec1;
+    vec4 = vec_x >> 16;
+    vec8 = vec_x & const_0xFFFF;
+    vec_x += vec1;
+    vec5 = vec_x >> 16;
+    vec9 = vec_x & const_0xFFFF;
+    vec_x += vec1;
+    vec6 >>= 9;
+    vec7 >>= 9;
+    vec8 >>= 9;
+    vec9 >>= 9;
+    LOAD_INDEXED_DATA(src_ptr, vec2, tmp0);
+    LOAD_INDEXED_DATA(src_ptr, vec3, tmp1);
+    LOAD_INDEXED_DATA(src_ptr, vec4, tmp2);
+    LOAD_INDEXED_DATA(src_ptr, vec5, tmp3);
+    vec2 += 1;
+    vec3 += 1;
+    vec4 += 1;
+    vec5 += 1;
+    LOAD_INDEXED_DATA(src_ptr, vec2, tmp4);
+    LOAD_INDEXED_DATA(src_ptr, vec3, tmp5);
+    LOAD_INDEXED_DATA(src_ptr, vec4, tmp6);
+    LOAD_INDEXED_DATA(src_ptr, vec5, tmp7);
+    tmp4 -= tmp0;
+    tmp5 -= tmp1;
+    tmp6 -= tmp2;
+    tmp7 -= tmp3;
+    tmp4 *= vec6;
+    tmp5 *= vec7;
+    tmp6 *= vec8;
+    tmp7 *= vec9;
+    tmp4 += const_0x40;
+    tmp5 += const_0x40;
+    tmp6 += const_0x40;
+    tmp7 += const_0x40;
+    tmp4 >>= 7;
+    tmp5 >>= 7;
+    tmp6 >>= 7;
+    tmp7 >>= 7;
+    tmp0 += tmp4;
+    tmp1 += tmp5;
+    tmp2 += tmp6;
+    tmp3 += tmp7;
+    reg0 = (v8u16)__msa_pckev_h((v8i16)tmp1, (v8i16)tmp0);
+    reg1 = (v8u16)__msa_pckev_h((v8i16)tmp3, (v8i16)tmp2);
+    dst0 = (v16u8)__msa_pckev_b((v16i8)reg1, (v16i8)reg0);
+    __msa_st_b(dst0, dst_ptr, 0);
+    dst_ptr += 16;
+  }
+}
+
+void ScaleARGBCols_MSA(uint8_t* dst_argb,
+                       const uint8_t* src_argb,
+                       int dst_width,
+                       int x,
+                       int dx) {
+  const uint32_t* src = (const uint32_t*)(src_argb);
+  uint32_t* dst = (uint32_t*)(dst_argb);
+  int j;
+  v4i32 x_vec = __msa_fill_w(x);
+  v4i32 dx_vec = __msa_fill_w(dx);
+  v4i32 const_vec = {0, 1, 2, 3};
+  v4i32 vec0, vec1, vec2;
+  v4i32 dst0;
+
+  vec0 = dx_vec * const_vec;
+  vec1 = dx_vec * 4;
+  x_vec += vec0;
+
+  for (j = 0; j < dst_width; j += 4) {
+    vec2 = x_vec >> 16;
+    x_vec += vec1;
+    LOAD_INDEXED_DATA(src, vec2, dst0);
+    __msa_st_w(dst0, dst, 0);
+    dst += 4;
+  }
+}
+
+void ScaleARGBFilterCols_MSA(uint8_t* dst_argb,
+                             const uint8_t* src_argb,
+                             int dst_width,
+                             int x,
+                             int dx) {
+  const uint32_t* src = (const uint32_t*)(src_argb);
+  int j;
+  v4u32 src0, src1, src2, src3;
+  v4u32 vec0, vec1, vec2, vec3;
+  v16u8 reg0, reg1, reg2, reg3, reg4, reg5, reg6, reg7;
+  v16u8 mult0, mult1, mult2, mult3;
+  v8u16 tmp0, tmp1, tmp2, tmp3;
+  v16u8 dst0, dst1;
+  v4u32 vec_x = (v4u32)__msa_fill_w(x);
+  v4u32 vec_dx = (v4u32)__msa_fill_w(dx);
+  v4u32 vec_const = {0, 1, 2, 3};
+  v16u8 const_0x7f = (v16u8)__msa_fill_b(0x7f);
+
+  vec0 = vec_dx * vec_const;
+  vec1 = vec_dx * 4;
+  vec_x += vec0;
+
+  for (j = 0; j < dst_width - 1; j += 8) {
+    vec2 = vec_x >> 16;
+    reg0 = (v16u8)(vec_x >> 9);
+    vec_x += vec1;
+    vec3 = vec_x >> 16;
+    reg1 = (v16u8)(vec_x >> 9);
+    vec_x += vec1;
+    reg0 = reg0 & const_0x7f;
+    reg1 = reg1 & const_0x7f;
+    reg0 = (v16u8)__msa_shf_b((v16i8)reg0, 0);
+    reg1 = (v16u8)__msa_shf_b((v16i8)reg1, 0);
+    reg2 = reg0 ^ const_0x7f;
+    reg3 = reg1 ^ const_0x7f;
+    mult0 = (v16u8)__msa_ilvr_b((v16i8)reg0, (v16i8)reg2);
+    mult1 = (v16u8)__msa_ilvl_b((v16i8)reg0, (v16i8)reg2);
+    mult2 = (v16u8)__msa_ilvr_b((v16i8)reg1, (v16i8)reg3);
+    mult3 = (v16u8)__msa_ilvl_b((v16i8)reg1, (v16i8)reg3);
+    LOAD_INDEXED_DATA(src, vec2, src0);
+    LOAD_INDEXED_DATA(src, vec3, src1);
+    vec2 += 1;
+    vec3 += 1;
+    LOAD_INDEXED_DATA(src, vec2, src2);
+    LOAD_INDEXED_DATA(src, vec3, src3);
+    reg4 = (v16u8)__msa_ilvr_b((v16i8)src2, (v16i8)src0);
+    reg5 = (v16u8)__msa_ilvl_b((v16i8)src2, (v16i8)src0);
+    reg6 = (v16u8)__msa_ilvr_b((v16i8)src3, (v16i8)src1);
+    reg7 = (v16u8)__msa_ilvl_b((v16i8)src3, (v16i8)src1);
+    tmp0 = __msa_dotp_u_h(reg4, mult0);
+    tmp1 = __msa_dotp_u_h(reg5, mult1);
+    tmp2 = __msa_dotp_u_h(reg6, mult2);
+    tmp3 = __msa_dotp_u_h(reg7, mult3);
+    tmp0 >>= 7;
+    tmp1 >>= 7;
+    tmp2 >>= 7;
+    tmp3 >>= 7;
+    dst0 = (v16u8)__msa_pckev_b((v16i8)tmp1, (v16i8)tmp0);
+    dst1 = (v16u8)__msa_pckev_b((v16i8)tmp3, (v16i8)tmp2);
+    __msa_st_b(dst0, dst_argb, 0);
+    __msa_st_b(dst1, dst_argb, 16);
+    dst_argb += 32;
+  }
+}
+
+void ScaleRowDown34_MSA(const uint8_t* src_ptr,
+                        ptrdiff_t src_stride,
+                        uint8_t* dst,
+                        int dst_width) {
+  int x;
+  (void)src_stride;
+  v16u8 src0, src1, src2, src3;
+  v16u8 vec0, vec1, vec2;
+  v16i8 mask0 = {0, 1, 3, 4, 5, 7, 8, 9, 11, 12, 13, 15, 16, 17, 19, 20};
+  v16i8 mask1 = {5, 7, 8, 9, 11, 12, 13, 15, 16, 17, 19, 20, 21, 23, 24, 25};
+  v16i8 mask2 = {11, 12, 13, 15, 16, 17, 19, 20,
+                 21, 23, 24, 25, 27, 28, 29, 31};
+
+  assert((dst_width % 3 == 0) && (dst_width > 0));
+
+  for (x = 0; x < dst_width; x += 48) {
+    src0 = (v16u8)__msa_ld_b((v16i8*)src_ptr, 0);
+    src1 = (v16u8)__msa_ld_b((v16i8*)src_ptr, 16);
+    src2 = (v16u8)__msa_ld_b((v16i8*)src_ptr, 32);
+    src3 = (v16u8)__msa_ld_b((v16i8*)src_ptr, 48);
+    vec0 = (v16u8)__msa_vshf_b(mask0, (v16i8)src1, (v16i8)src0);
+    vec1 = (v16u8)__msa_vshf_b(mask1, (v16i8)src2, (v16i8)src1);
+    vec2 = (v16u8)__msa_vshf_b(mask2, (v16i8)src3, (v16i8)src2);
+    __msa_st_b((v16i8)vec0, dst, 0);
+    __msa_st_b((v16i8)vec1, dst, 16);
+    __msa_st_b((v16i8)vec2, dst, 32);
+    src_ptr += 64;
+    dst += 48;
+  }
+}
+
+void ScaleRowDown34_0_Box_MSA(const uint8_t* src_ptr,
+                              ptrdiff_t src_stride,
+                              uint8_t* d,
+                              int dst_width) {
+  const uint8_t* s = src_ptr;
+  const uint8_t* t = src_ptr + src_stride;
+  int x;
+  v16u8 src0, src1, src2, src3, src4, src5, src6, src7, dst0, dst1, dst2;
+  v16u8 vec0, vec1, vec2, vec3, vec4, vec5;
+  v16u8 vec6, vec7, vec8, vec9, vec10, vec11;
+  v8i16 reg0, reg1, reg2, reg3, reg4, reg5;
+  v8i16 reg6, reg7, reg8, reg9, reg10, reg11;
+  v16u8 const0 = {3, 1, 1, 1, 1, 3, 3, 1, 1, 1, 1, 3, 3, 1, 1, 1};
+  v16u8 const1 = {1, 3, 3, 1, 1, 1, 1, 3, 3, 1, 1, 1, 1, 3, 3, 1};
+  v16u8 const2 = {1, 1, 1, 3, 3, 1, 1, 1, 1, 3, 3, 1, 1, 1, 1, 3};
+  v16i8 mask0 = {0, 1, 1, 2, 2, 3, 4, 5, 5, 6, 6, 7, 8, 9, 9, 10};
+  v16i8 mask1 = {10, 11, 12, 13, 13, 14, 14, 15,
+                 16, 17, 17, 18, 18, 19, 20, 21};
+  v16i8 mask2 = {5, 6, 6, 7, 8, 9, 9, 10, 10, 11, 12, 13, 13, 14, 14, 15};
+  v8i16 shft0 = {2, 1, 2, 2, 1, 2, 2, 1};
+  v8i16 shft1 = {2, 2, 1, 2, 2, 1, 2, 2};
+  v8i16 shft2 = {1, 2, 2, 1, 2, 2, 1, 2};
+
+  assert((dst_width % 3 == 0) && (dst_width > 0));
+
+  for (x = 0; x < dst_width; x += 48) {
+    src0 = (v16u8)__msa_ld_b((v16i8*)s, 0);
+    src1 = (v16u8)__msa_ld_b((v16i8*)s, 16);
+    src2 = (v16u8)__msa_ld_b((v16i8*)s, 32);
+    src3 = (v16u8)__msa_ld_b((v16i8*)s, 48);
+    src4 = (v16u8)__msa_ld_b((v16i8*)t, 0);
+    src5 = (v16u8)__msa_ld_b((v16i8*)t, 16);
+    src6 = (v16u8)__msa_ld_b((v16i8*)t, 32);
+    src7 = (v16u8)__msa_ld_b((v16i8*)t, 48);
+    vec0 = (v16u8)__msa_vshf_b(mask0, (v16i8)src0, (v16i8)src0);
+    vec1 = (v16u8)__msa_vshf_b(mask1, (v16i8)src1, (v16i8)src0);
+    vec2 = (v16u8)__msa_vshf_b(mask2, (v16i8)src1, (v16i8)src1);
+    vec3 = (v16u8)__msa_vshf_b(mask0, (v16i8)src2, (v16i8)src2);
+    vec4 = (v16u8)__msa_vshf_b(mask1, (v16i8)src3, (v16i8)src2);
+    vec5 = (v16u8)__msa_vshf_b(mask2, (v16i8)src3, (v16i8)src3);
+    vec6 = (v16u8)__msa_vshf_b(mask0, (v16i8)src4, (v16i8)src4);
+    vec7 = (v16u8)__msa_vshf_b(mask1, (v16i8)src5, (v16i8)src4);
+    vec8 = (v16u8)__msa_vshf_b(mask2, (v16i8)src5, (v16i8)src5);
+    vec9 = (v16u8)__msa_vshf_b(mask0, (v16i8)src6, (v16i8)src6);
+    vec10 = (v16u8)__msa_vshf_b(mask1, (v16i8)src7, (v16i8)src6);
+    vec11 = (v16u8)__msa_vshf_b(mask2, (v16i8)src7, (v16i8)src7);
+    reg0 = (v8i16)__msa_dotp_u_h(vec0, const0);
+    reg1 = (v8i16)__msa_dotp_u_h(vec1, const1);
+    reg2 = (v8i16)__msa_dotp_u_h(vec2, const2);
+    reg3 = (v8i16)__msa_dotp_u_h(vec3, const0);
+    reg4 = (v8i16)__msa_dotp_u_h(vec4, const1);
+    reg5 = (v8i16)__msa_dotp_u_h(vec5, const2);
+    reg6 = (v8i16)__msa_dotp_u_h(vec6, const0);
+    reg7 = (v8i16)__msa_dotp_u_h(vec7, const1);
+    reg8 = (v8i16)__msa_dotp_u_h(vec8, const2);
+    reg9 = (v8i16)__msa_dotp_u_h(vec9, const0);
+    reg10 = (v8i16)__msa_dotp_u_h(vec10, const1);
+    reg11 = (v8i16)__msa_dotp_u_h(vec11, const2);
+    reg0 = __msa_srar_h(reg0, shft0);
+    reg1 = __msa_srar_h(reg1, shft1);
+    reg2 = __msa_srar_h(reg2, shft2);
+    reg3 = __msa_srar_h(reg3, shft0);
+    reg4 = __msa_srar_h(reg4, shft1);
+    reg5 = __msa_srar_h(reg5, shft2);
+    reg6 = __msa_srar_h(reg6, shft0);
+    reg7 = __msa_srar_h(reg7, shft1);
+    reg8 = __msa_srar_h(reg8, shft2);
+    reg9 = __msa_srar_h(reg9, shft0);
+    reg10 = __msa_srar_h(reg10, shft1);
+    reg11 = __msa_srar_h(reg11, shft2);
+    reg0 = reg0 * 3 + reg6;
+    reg1 = reg1 * 3 + reg7;
+    reg2 = reg2 * 3 + reg8;
+    reg3 = reg3 * 3 + reg9;
+    reg4 = reg4 * 3 + reg10;
+    reg5 = reg5 * 3 + reg11;
+    reg0 = __msa_srari_h(reg0, 2);
+    reg1 = __msa_srari_h(reg1, 2);
+    reg2 = __msa_srari_h(reg2, 2);
+    reg3 = __msa_srari_h(reg3, 2);
+    reg4 = __msa_srari_h(reg4, 2);
+    reg5 = __msa_srari_h(reg5, 2);
+    dst0 = (v16u8)__msa_pckev_b((v16i8)reg1, (v16i8)reg0);
+    dst1 = (v16u8)__msa_pckev_b((v16i8)reg3, (v16i8)reg2);
+    dst2 = (v16u8)__msa_pckev_b((v16i8)reg5, (v16i8)reg4);
+    __msa_st_b((v16i8)dst0, d, 0);
+    __msa_st_b((v16i8)dst1, d, 16);
+    __msa_st_b((v16i8)dst2, d, 32);
+    s += 64;
+    t += 64;
+    d += 48;
+  }
+}
+
+void ScaleRowDown34_1_Box_MSA(const uint8_t* src_ptr,
+                              ptrdiff_t src_stride,
+                              uint8_t* d,
+                              int dst_width) {
+  const uint8_t* s = src_ptr;
+  const uint8_t* t = src_ptr + src_stride;
+  int x;
+  v16u8 src0, src1, src2, src3, src4, src5, src6, src7, dst0, dst1, dst2;
+  v16u8 vec0, vec1, vec2, vec3, vec4, vec5;
+  v16u8 vec6, vec7, vec8, vec9, vec10, vec11;
+  v8i16 reg0, reg1, reg2, reg3, reg4, reg5;
+  v8i16 reg6, reg7, reg8, reg9, reg10, reg11;
+  v16u8 const0 = {3, 1, 1, 1, 1, 3, 3, 1, 1, 1, 1, 3, 3, 1, 1, 1};
+  v16u8 const1 = {1, 3, 3, 1, 1, 1, 1, 3, 3, 1, 1, 1, 1, 3, 3, 1};
+  v16u8 const2 = {1, 1, 1, 3, 3, 1, 1, 1, 1, 3, 3, 1, 1, 1, 1, 3};
+  v16i8 mask0 = {0, 1, 1, 2, 2, 3, 4, 5, 5, 6, 6, 7, 8, 9, 9, 10};
+  v16i8 mask1 = {10, 11, 12, 13, 13, 14, 14, 15,
+                 16, 17, 17, 18, 18, 19, 20, 21};
+  v16i8 mask2 = {5, 6, 6, 7, 8, 9, 9, 10, 10, 11, 12, 13, 13, 14, 14, 15};
+  v8i16 shft0 = {2, 1, 2, 2, 1, 2, 2, 1};
+  v8i16 shft1 = {2, 2, 1, 2, 2, 1, 2, 2};
+  v8i16 shft2 = {1, 2, 2, 1, 2, 2, 1, 2};
+
+  assert((dst_width % 3 == 0) && (dst_width > 0));
+
+  for (x = 0; x < dst_width; x += 48) {
+    src0 = (v16u8)__msa_ld_b((v16i8*)s, 0);
+    src1 = (v16u8)__msa_ld_b((v16i8*)s, 16);
+    src2 = (v16u8)__msa_ld_b((v16i8*)s, 32);
+    src3 = (v16u8)__msa_ld_b((v16i8*)s, 48);
+    src4 = (v16u8)__msa_ld_b((v16i8*)t, 0);
+    src5 = (v16u8)__msa_ld_b((v16i8*)t, 16);
+    src6 = (v16u8)__msa_ld_b((v16i8*)t, 32);
+    src7 = (v16u8)__msa_ld_b((v16i8*)t, 48);
+    vec0 = (v16u8)__msa_vshf_b(mask0, (v16i8)src0, (v16i8)src0);
+    vec1 = (v16u8)__msa_vshf_b(mask1, (v16i8)src1, (v16i8)src0);
+    vec2 = (v16u8)__msa_vshf_b(mask2, (v16i8)src1, (v16i8)src1);
+    vec3 = (v16u8)__msa_vshf_b(mask0, (v16i8)src2, (v16i8)src2);
+    vec4 = (v16u8)__msa_vshf_b(mask1, (v16i8)src3, (v16i8)src2);
+    vec5 = (v16u8)__msa_vshf_b(mask2, (v16i8)src3, (v16i8)src3);
+    vec6 = (v16u8)__msa_vshf_b(mask0, (v16i8)src4, (v16i8)src4);
+    vec7 = (v16u8)__msa_vshf_b(mask1, (v16i8)src5, (v16i8)src4);
+    vec8 = (v16u8)__msa_vshf_b(mask2, (v16i8)src5, (v16i8)src5);
+    vec9 = (v16u8)__msa_vshf_b(mask0, (v16i8)src6, (v16i8)src6);
+    vec10 = (v16u8)__msa_vshf_b(mask1, (v16i8)src7, (v16i8)src6);
+    vec11 = (v16u8)__msa_vshf_b(mask2, (v16i8)src7, (v16i8)src7);
+    reg0 = (v8i16)__msa_dotp_u_h(vec0, const0);
+    reg1 = (v8i16)__msa_dotp_u_h(vec1, const1);
+    reg2 = (v8i16)__msa_dotp_u_h(vec2, const2);
+    reg3 = (v8i16)__msa_dotp_u_h(vec3, const0);
+    reg4 = (v8i16)__msa_dotp_u_h(vec4, const1);
+    reg5 = (v8i16)__msa_dotp_u_h(vec5, const2);
+    reg6 = (v8i16)__msa_dotp_u_h(vec6, const0);
+    reg7 = (v8i16)__msa_dotp_u_h(vec7, const1);
+    reg8 = (v8i16)__msa_dotp_u_h(vec8, const2);
+    reg9 = (v8i16)__msa_dotp_u_h(vec9, const0);
+    reg10 = (v8i16)__msa_dotp_u_h(vec10, const1);
+    reg11 = (v8i16)__msa_dotp_u_h(vec11, const2);
+    reg0 = __msa_srar_h(reg0, shft0);
+    reg1 = __msa_srar_h(reg1, shft1);
+    reg2 = __msa_srar_h(reg2, shft2);
+    reg3 = __msa_srar_h(reg3, shft0);
+    reg4 = __msa_srar_h(reg4, shft1);
+    reg5 = __msa_srar_h(reg5, shft2);
+    reg6 = __msa_srar_h(reg6, shft0);
+    reg7 = __msa_srar_h(reg7, shft1);
+    reg8 = __msa_srar_h(reg8, shft2);
+    reg9 = __msa_srar_h(reg9, shft0);
+    reg10 = __msa_srar_h(reg10, shft1);
+    reg11 = __msa_srar_h(reg11, shft2);
+    reg0 += reg6;
+    reg1 += reg7;
+    reg2 += reg8;
+    reg3 += reg9;
+    reg4 += reg10;
+    reg5 += reg11;
+    reg0 = __msa_srari_h(reg0, 1);
+    reg1 = __msa_srari_h(reg1, 1);
+    reg2 = __msa_srari_h(reg2, 1);
+    reg3 = __msa_srari_h(reg3, 1);
+    reg4 = __msa_srari_h(reg4, 1);
+    reg5 = __msa_srari_h(reg5, 1);
+    dst0 = (v16u8)__msa_pckev_b((v16i8)reg1, (v16i8)reg0);
+    dst1 = (v16u8)__msa_pckev_b((v16i8)reg3, (v16i8)reg2);
+    dst2 = (v16u8)__msa_pckev_b((v16i8)reg5, (v16i8)reg4);
+    __msa_st_b((v16i8)dst0, d, 0);
+    __msa_st_b((v16i8)dst1, d, 16);
+    __msa_st_b((v16i8)dst2, d, 32);
+    s += 64;
+    t += 64;
+    d += 48;
+  }
+}
+
+#ifdef __cplusplus
+}  // extern "C"
+}  // namespace libyuv
+#endif
+
+#endif  // !defined(LIBYUV_DISABLE_MSA) && defined(__mips_msa)
diff --git a/3rdparty/libyuv/src/source/scale_neon.cc b/3rdparty/libyuv/src/source/scale_neon.cc
new file mode 100644
index 00000000..6a0d6e1b
--- /dev/null
+++ b/3rdparty/libyuv/src/source/scale_neon.cc
@@ -0,0 +1,1494 @@
+/*
+ *  Copyright 2011 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include "libyuv/row.h"
+
+#ifdef __cplusplus
+namespace libyuv {
+extern "C" {
+#endif
+
+// This module is for GCC Neon.
+#if !defined(LIBYUV_DISABLE_NEON) && defined(__ARM_NEON__) && \
+    !defined(__aarch64__)
+
+// NEON downscalers with interpolation.
+// Provided by Fritz Koenig
+
+// Read 32x1 throw away even pixels, and write 16x1.
+void ScaleRowDown2_NEON(const uint8_t* src_ptr,
+                        ptrdiff_t src_stride,
+                        uint8_t* dst,
+                        int dst_width) {
+  (void)src_stride;
+  asm volatile(
+      "1:                                        \n"
+      // load even pixels into q0, odd into q1
+      "vld2.8      {q0, q1}, [%0]!               \n"
+      "subs        %2, %2, #16                   \n"  // 16 processed per loop
+      "vst1.8      {q1}, [%1]!                   \n"  // store odd pixels
+      "bgt         1b                            \n"
+      : "+r"(src_ptr),   // %0
+        "+r"(dst),       // %1
+        "+r"(dst_width)  // %2
+      :
+      : "q0", "q1"  // Clobber List
+  );
+}
+
+// Read 32x1 average down and write 16x1.
+void ScaleRowDown2Linear_NEON(const uint8_t* src_ptr,
+                              ptrdiff_t src_stride,
+                              uint8_t* dst,
+                              int dst_width) {
+  (void)src_stride;
+  asm volatile(
+      "1:                                        \n"
+      "vld2.8      {q0, q1}, [%0]!               \n"  // load 32 pixels
+      "subs        %2, %2, #16                   \n"  // 16 processed per loop
+      "vrhadd.u8   q0, q0, q1                    \n"  // rounding half add
+      "vst1.8      {q0}, [%1]!                   \n"
+      "bgt         1b                            \n"
+      : "+r"(src_ptr),   // %0
+        "+r"(dst),       // %1
+        "+r"(dst_width)  // %2
+      :
+      : "q0", "q1"  // Clobber List
+  );
+}
+
+// Read 32x2 average down and write 16x1.
+void ScaleRowDown2Box_NEON(const uint8_t* src_ptr,
+                           ptrdiff_t src_stride,
+                           uint8_t* dst,
+                           int dst_width) {
+  asm volatile(
+      // change the stride to row 2 pointer
+      "add         %1, %0                        \n"
+      "1:                                        \n"
+      "vld1.8      {q0, q1}, [%0]!               \n"  // load row 1 and post inc
+      "vld1.8      {q2, q3}, [%1]!               \n"  // load row 2 and post inc
+      "subs        %3, %3, #16                   \n"  // 16 processed per loop
+      "vpaddl.u8   q0, q0                        \n"  // row 1 add adjacent
+      "vpaddl.u8   q1, q1                        \n"
+      "vpadal.u8   q0, q2                        \n"  // row 2 add adjacent +
+                                                      // row1
+      "vpadal.u8   q1, q3                        \n"
+      "vrshrn.u16  d0, q0, #2                    \n"  // downshift, round and
+                                                      // pack
+      "vrshrn.u16  d1, q1, #2                    \n"
+      "vst1.8      {q0}, [%2]!                   \n"
+      "bgt         1b                            \n"
+      : "+r"(src_ptr),     // %0
+        "+r"(src_stride),  // %1
+        "+r"(dst),         // %2
+        "+r"(dst_width)    // %3
+      :
+      : "q0", "q1", "q2", "q3"  // Clobber List
+  );
+}
+
+void ScaleRowDown4_NEON(const uint8_t* src_ptr,
+                        ptrdiff_t src_stride,
+                        uint8_t* dst_ptr,
+                        int dst_width) {
+  (void)src_stride;
+  asm volatile(
+      "1:                                        \n"
+      "vld4.8      {d0, d1, d2, d3}, [%0]!       \n"  // src line 0
+      "subs        %2, %2, #8                    \n"  // 8 processed per loop
+      "vst1.8      {d2}, [%1]!                   \n"
+      "bgt         1b                            \n"
+      : "+r"(src_ptr),   // %0
+        "+r"(dst_ptr),   // %1
+        "+r"(dst_width)  // %2
+      :
+      : "q0", "q1", "memory", "cc");
+}
+
+void ScaleRowDown4Box_NEON(const uint8_t* src_ptr,
+                           ptrdiff_t src_stride,
+                           uint8_t* dst_ptr,
+                           int dst_width) {
+  const uint8_t* src_ptr1 = src_ptr + src_stride;
+  const uint8_t* src_ptr2 = src_ptr + src_stride * 2;
+  const uint8_t* src_ptr3 = src_ptr + src_stride * 3;
+  asm volatile(
+      "1:                                        \n"
+      "vld1.8      {q0}, [%0]!                   \n"  // load up 16x4
+      "vld1.8      {q1}, [%3]!                   \n"
+      "vld1.8      {q2}, [%4]!                   \n"
+      "vld1.8      {q3}, [%5]!                   \n"
+      "subs        %2, %2, #4                    \n"
+      "vpaddl.u8   q0, q0                        \n"
+      "vpadal.u8   q0, q1                        \n"
+      "vpadal.u8   q0, q2                        \n"
+      "vpadal.u8   q0, q3                        \n"
+      "vpaddl.u16  q0, q0                        \n"
+      "vrshrn.u32  d0, q0, #4                    \n"  // divide by 16 w/rounding
+      "vmovn.u16   d0, q0                        \n"
+      "vst1.32     {d0[0]}, [%1]!                \n"
+      "bgt         1b                            \n"
+      : "+r"(src_ptr),    // %0
+        "+r"(dst_ptr),    // %1
+        "+r"(dst_width),  // %2
+        "+r"(src_ptr1),   // %3
+        "+r"(src_ptr2),   // %4
+        "+r"(src_ptr3)    // %5
+      :
+      : "q0", "q1", "q2", "q3", "memory", "cc");
+}
+
+// Down scale from 4 to 3 pixels. Use the neon multilane read/write
+// to load up the every 4th pixel into a 4 different registers.
+// Point samples 32 pixels to 24 pixels.
+void ScaleRowDown34_NEON(const uint8_t* src_ptr,
+                         ptrdiff_t src_stride,
+                         uint8_t* dst_ptr,
+                         int dst_width) {
+  (void)src_stride;
+  asm volatile(
+      "1:                                        \n"
+      "vld4.8      {d0, d1, d2, d3}, [%0]!       \n"  // src line 0
+      "subs        %2, %2, #24                   \n"
+      "vmov        d2, d3                        \n"  // order d0, d1, d2
+      "vst3.8      {d0, d1, d2}, [%1]!           \n"
+      "bgt         1b                            \n"
+      : "+r"(src_ptr),   // %0
+        "+r"(dst_ptr),   // %1
+        "+r"(dst_width)  // %2
+      :
+      : "d0", "d1", "d2", "d3", "memory", "cc");
+}
+
+void ScaleRowDown34_0_Box_NEON(const uint8_t* src_ptr,
+                               ptrdiff_t src_stride,
+                               uint8_t* dst_ptr,
+                               int dst_width) {
+  asm volatile(
+      "vmov.u8     d24, #3                       \n"
+      "add         %3, %0                        \n"
+      "1:                                        \n"
+      "vld4.8      {d0, d1, d2, d3}, [%0]!       \n"  // src line 0
+      "vld4.8      {d4, d5, d6, d7}, [%3]!       \n"  // src line 1
+      "subs        %2, %2, #24                   \n"
+
+      // filter src line 0 with src line 1
+      // expand chars to shorts to allow for room
+      // when adding lines together
+      "vmovl.u8    q8, d4                        \n"
+      "vmovl.u8    q9, d5                        \n"
+      "vmovl.u8    q10, d6                       \n"
+      "vmovl.u8    q11, d7                       \n"
+
+      // 3 * line_0 + line_1
+      "vmlal.u8    q8, d0, d24                   \n"
+      "vmlal.u8    q9, d1, d24                   \n"
+      "vmlal.u8    q10, d2, d24                  \n"
+      "vmlal.u8    q11, d3, d24                  \n"
+
+      // (3 * line_0 + line_1 + 2) >> 2
+      "vqrshrn.u16 d0, q8, #2                    \n"
+      "vqrshrn.u16 d1, q9, #2                    \n"
+      "vqrshrn.u16 d2, q10, #2                   \n"
+      "vqrshrn.u16 d3, q11, #2                   \n"
+
+      // a0 = (src[0] * 3 + s[1] * 1 + 2) >> 2
+      "vmovl.u8    q8, d1                        \n"
+      "vmlal.u8    q8, d0, d24                   \n"
+      "vqrshrn.u16 d0, q8, #2                    \n"
+
+      // a1 = (src[1] * 1 + s[2] * 1 + 1) >> 1
+      "vrhadd.u8   d1, d1, d2                    \n"
+
+      // a2 = (src[2] * 1 + s[3] * 3 + 2) >> 2
+      "vmovl.u8    q8, d2                        \n"
+      "vmlal.u8    q8, d3, d24                   \n"
+      "vqrshrn.u16 d2, q8, #2                    \n"
+
+      "vst3.8      {d0, d1, d2}, [%1]!           \n"
+
+      "bgt         1b                            \n"
+      : "+r"(src_ptr),    // %0
+        "+r"(dst_ptr),    // %1
+        "+r"(dst_width),  // %2
+        "+r"(src_stride)  // %3
+      :
+      : "q0", "q1", "q2", "q3", "q8", "q9", "q10", "q11", "d24", "memory",
+        "cc");
+}
+
+void ScaleRowDown34_1_Box_NEON(const uint8_t* src_ptr,
+                               ptrdiff_t src_stride,
+                               uint8_t* dst_ptr,
+                               int dst_width) {
+  asm volatile(
+      "vmov.u8     d24, #3                       \n"
+      "add         %3, %0                        \n"
+      "1:                                        \n"
+      "vld4.8      {d0, d1, d2, d3}, [%0]!       \n"  // src line 0
+      "vld4.8      {d4, d5, d6, d7}, [%3]!       \n"  // src line 1
+      "subs        %2, %2, #24                   \n"
+      // average src line 0 with src line 1
+      "vrhadd.u8   q0, q0, q2                    \n"
+      "vrhadd.u8   q1, q1, q3                    \n"
+
+      // a0 = (src[0] * 3 + s[1] * 1 + 2) >> 2
+      "vmovl.u8    q3, d1                        \n"
+      "vmlal.u8    q3, d0, d24                   \n"
+      "vqrshrn.u16 d0, q3, #2                    \n"
+
+      // a1 = (src[1] * 1 + s[2] * 1 + 1) >> 1
+      "vrhadd.u8   d1, d1, d2                    \n"
+
+      // a2 = (src[2] * 1 + s[3] * 3 + 2) >> 2
+      "vmovl.u8    q3, d2                        \n"
+      "vmlal.u8    q3, d3, d24                   \n"
+      "vqrshrn.u16 d2, q3, #2                    \n"
+
+      "vst3.8      {d0, d1, d2}, [%1]!           \n"
+      "bgt         1b                            \n"
+      : "+r"(src_ptr),    // %0
+        "+r"(dst_ptr),    // %1
+        "+r"(dst_width),  // %2
+        "+r"(src_stride)  // %3
+      :
+      : "r4", "q0", "q1", "q2", "q3", "d24", "memory", "cc");
+}
+
+#define HAS_SCALEROWDOWN38_NEON
+static const uvec8 kShuf38 = {0,  3,  6,  8,  11, 14, 16, 19,
+                              22, 24, 27, 30, 0,  0,  0,  0};
+static const uvec8 kShuf38_2 = {0,  8, 16, 2,  10, 17, 4, 12,
+                                18, 6, 14, 19, 0,  0,  0, 0};
+static const vec16 kMult38_Div6 = {65536 / 12, 65536 / 12, 65536 / 12,
+                                   65536 / 12, 65536 / 12, 65536 / 12,
+                                   65536 / 12, 65536 / 12};
+static const vec16 kMult38_Div9 = {65536 / 18, 65536 / 18, 65536 / 18,
+                                   65536 / 18, 65536 / 18, 65536 / 18,
+                                   65536 / 18, 65536 / 18};
+
+// 32 -> 12
+void ScaleRowDown38_NEON(const uint8_t* src_ptr,
+                         ptrdiff_t src_stride,
+                         uint8_t* dst_ptr,
+                         int dst_width) {
+  (void)src_stride;
+  asm volatile(
+      "vld1.8      {q3}, [%3]                    \n"
+      "1:                                        \n"
+      "vld1.8      {d0, d1, d2, d3}, [%0]!       \n"
+      "subs        %2, %2, #12                   \n"
+      "vtbl.u8     d4, {d0, d1, d2, d3}, d6      \n"
+      "vtbl.u8     d5, {d0, d1, d2, d3}, d7      \n"
+      "vst1.8      {d4}, [%1]!                   \n"
+      "vst1.32     {d5[0]}, [%1]!                \n"
+      "bgt         1b                            \n"
+      : "+r"(src_ptr),   // %0
+        "+r"(dst_ptr),   // %1
+        "+r"(dst_width)  // %2
+      : "r"(&kShuf38)    // %3
+      : "d0", "d1", "d2", "d3", "d4", "d5", "memory", "cc");
+}
+
+// 32x3 -> 12x1
+void OMITFP ScaleRowDown38_3_Box_NEON(const uint8_t* src_ptr,
+                                      ptrdiff_t src_stride,
+                                      uint8_t* dst_ptr,
+                                      int dst_width) {
+  const uint8_t* src_ptr1 = src_ptr + src_stride * 2;
+
+  asm volatile(
+      "vld1.16     {q13}, [%5]                   \n"
+      "vld1.8      {q14}, [%6]                   \n"
+      "vld1.8      {q15}, [%7]                   \n"
+      "add         %3, %0                        \n"
+      "1:                                        \n"
+
+      // d0 = 00 40 01 41 02 42 03 43
+      // d1 = 10 50 11 51 12 52 13 53
+      // d2 = 20 60 21 61 22 62 23 63
+      // d3 = 30 70 31 71 32 72 33 73
+      "vld4.8      {d0, d1, d2, d3}, [%0]!       \n"
+      "vld4.8      {d4, d5, d6, d7}, [%3]!       \n"
+      "vld4.8      {d16, d17, d18, d19}, [%4]!   \n"
+      "subs        %2, %2, #12                   \n"
+
+      // Shuffle the input data around to get align the data
+      //  so adjacent data can be added. 0,1 - 2,3 - 4,5 - 6,7
+      // d0 = 00 10 01 11 02 12 03 13
+      // d1 = 40 50 41 51 42 52 43 53
+      "vtrn.u8     d0, d1                        \n"
+      "vtrn.u8     d4, d5                        \n"
+      "vtrn.u8     d16, d17                      \n"
+
+      // d2 = 20 30 21 31 22 32 23 33
+      // d3 = 60 70 61 71 62 72 63 73
+      "vtrn.u8     d2, d3                        \n"
+      "vtrn.u8     d6, d7                        \n"
+      "vtrn.u8     d18, d19                      \n"
+
+      // d0 = 00+10 01+11 02+12 03+13
+      // d2 = 40+50 41+51 42+52 43+53
+      "vpaddl.u8   q0, q0                        \n"
+      "vpaddl.u8   q2, q2                        \n"
+      "vpaddl.u8   q8, q8                        \n"
+
+      // d3 = 60+70 61+71 62+72 63+73
+      "vpaddl.u8   d3, d3                        \n"
+      "vpaddl.u8   d7, d7                        \n"
+      "vpaddl.u8   d19, d19                      \n"
+
+      // combine source lines
+      "vadd.u16    q0, q2                        \n"
+      "vadd.u16    q0, q8                        \n"
+      "vadd.u16    d4, d3, d7                    \n"
+      "vadd.u16    d4, d19                       \n"
+
+      // dst_ptr[3] = (s[6 + st * 0] + s[7 + st * 0]
+      //             + s[6 + st * 1] + s[7 + st * 1]
+      //             + s[6 + st * 2] + s[7 + st * 2]) / 6
+      "vqrdmulh.s16 q2, q2, q13                  \n"
+      "vmovn.u16   d4, q2                        \n"
+
+      // Shuffle 2,3 reg around so that 2 can be added to the
+      //  0,1 reg and 3 can be added to the 4,5 reg. This
+      //  requires expanding from u8 to u16 as the 0,1 and 4,5
+      //  registers are already expanded. Then do transposes
+      //  to get aligned.
+      // q2 = xx 20 xx 30 xx 21 xx 31 xx 22 xx 32 xx 23 xx 33
+      "vmovl.u8    q1, d2                        \n"
+      "vmovl.u8    q3, d6                        \n"
+      "vmovl.u8    q9, d18                       \n"
+
+      // combine source lines
+      "vadd.u16    q1, q3                        \n"
+      "vadd.u16    q1, q9                        \n"
+
+      // d4 = xx 20 xx 30 xx 22 xx 32
+      // d5 = xx 21 xx 31 xx 23 xx 33
+      "vtrn.u32    d2, d3                        \n"
+
+      // d4 = xx 20 xx 21 xx 22 xx 23
+      // d5 = xx 30 xx 31 xx 32 xx 33
+      "vtrn.u16    d2, d3                        \n"
+
+      // 0+1+2, 3+4+5
+      "vadd.u16    q0, q1                        \n"
+
+      // Need to divide, but can't downshift as the the value
+      //  isn't a power of 2. So multiply by 65536 / n
+      //  and take the upper 16 bits.
+      "vqrdmulh.s16 q0, q0, q15                  \n"
+
+      // Align for table lookup, vtbl requires registers to
+      //  be adjacent
+      "vmov.u8     d2, d4                        \n"
+
+      "vtbl.u8     d3, {d0, d1, d2}, d28         \n"
+      "vtbl.u8     d4, {d0, d1, d2}, d29         \n"
+
+      "vst1.8      {d3}, [%1]!                   \n"
+      "vst1.32     {d4[0]}, [%1]!                \n"
+      "bgt         1b                            \n"
+      : "+r"(src_ptr),       // %0
+        "+r"(dst_ptr),       // %1
+        "+r"(dst_width),     // %2
+        "+r"(src_stride),    // %3
+        "+r"(src_ptr1)       // %4
+      : "r"(&kMult38_Div6),  // %5
+        "r"(&kShuf38_2),     // %6
+        "r"(&kMult38_Div9)   // %7
+      : "q0", "q1", "q2", "q3", "q8", "q9", "q13", "q14", "q15", "memory",
+        "cc");
+}
+
+// 32x2 -> 12x1
+void ScaleRowDown38_2_Box_NEON(const uint8_t* src_ptr,
+                               ptrdiff_t src_stride,
+                               uint8_t* dst_ptr,
+                               int dst_width) {
+  asm volatile(
+      "vld1.16     {q13}, [%4]                   \n"
+      "vld1.8      {q14}, [%5]                   \n"
+      "add         %3, %0                        \n"
+      "1:                                        \n"
+
+      // d0 = 00 40 01 41 02 42 03 43
+      // d1 = 10 50 11 51 12 52 13 53
+      // d2 = 20 60 21 61 22 62 23 63
+      // d3 = 30 70 31 71 32 72 33 73
+      "vld4.8      {d0, d1, d2, d3}, [%0]!       \n"
+      "vld4.8      {d4, d5, d6, d7}, [%3]!       \n"
+      "subs        %2, %2, #12                   \n"
+
+      // Shuffle the input data around to get align the data
+      //  so adjacent data can be added. 0,1 - 2,3 - 4,5 - 6,7
+      // d0 = 00 10 01 11 02 12 03 13
+      // d1 = 40 50 41 51 42 52 43 53
+      "vtrn.u8     d0, d1                        \n"
+      "vtrn.u8     d4, d5                        \n"
+
+      // d2 = 20 30 21 31 22 32 23 33
+      // d3 = 60 70 61 71 62 72 63 73
+      "vtrn.u8     d2, d3                        \n"
+      "vtrn.u8     d6, d7                        \n"
+
+      // d0 = 00+10 01+11 02+12 03+13
+      // d2 = 40+50 41+51 42+52 43+53
+      "vpaddl.u8   q0, q0                        \n"
+      "vpaddl.u8   q2, q2                        \n"
+
+      // d3 = 60+70 61+71 62+72 63+73
+      "vpaddl.u8   d3, d3                        \n"
+      "vpaddl.u8   d7, d7                        \n"
+
+      // combine source lines
+      "vadd.u16    q0, q2                        \n"
+      "vadd.u16    d4, d3, d7                    \n"
+
+      // dst_ptr[3] = (s[6] + s[7] + s[6+st] + s[7+st]) / 4
+      "vqrshrn.u16 d4, q2, #2                    \n"
+
+      // Shuffle 2,3 reg around so that 2 can be added to the
+      //  0,1 reg and 3 can be added to the 4,5 reg. This
+      //  requires expanding from u8 to u16 as the 0,1 and 4,5
+      //  registers are already expanded. Then do transposes
+      //  to get aligned.
+      // q2 = xx 20 xx 30 xx 21 xx 31 xx 22 xx 32 xx 23 xx 33
+      "vmovl.u8    q1, d2                        \n"
+      "vmovl.u8    q3, d6                        \n"
+
+      // combine source lines
+      "vadd.u16    q1, q3                        \n"
+
+      // d4 = xx 20 xx 30 xx 22 xx 32
+      // d5 = xx 21 xx 31 xx 23 xx 33
+      "vtrn.u32    d2, d3                        \n"
+
+      // d4 = xx 20 xx 21 xx 22 xx 23
+      // d5 = xx 30 xx 31 xx 32 xx 33
+      "vtrn.u16    d2, d3                        \n"
+
+      // 0+1+2, 3+4+5
+      "vadd.u16    q0, q1                        \n"
+
+      // Need to divide, but can't downshift as the the value
+      //  isn't a power of 2. So multiply by 65536 / n
+      //  and take the upper 16 bits.
+      "vqrdmulh.s16 q0, q0, q13                  \n"
+
+      // Align for table lookup, vtbl requires registers to
+      //  be adjacent
+      "vmov.u8     d2, d4                        \n"
+
+      "vtbl.u8     d3, {d0, d1, d2}, d28         \n"
+      "vtbl.u8     d4, {d0, d1, d2}, d29         \n"
+
+      "vst1.8      {d3}, [%1]!                   \n"
+      "vst1.32     {d4[0]}, [%1]!                \n"
+      "bgt         1b                            \n"
+      : "+r"(src_ptr),       // %0
+        "+r"(dst_ptr),       // %1
+        "+r"(dst_width),     // %2
+        "+r"(src_stride)     // %3
+      : "r"(&kMult38_Div6),  // %4
+        "r"(&kShuf38_2)      // %5
+      : "q0", "q1", "q2", "q3", "q13", "q14", "memory", "cc");
+}
+
+void ScaleRowUp2_Linear_NEON(const uint8_t* src_ptr,
+                             uint8_t* dst_ptr,
+                             int dst_width) {
+  const uint8_t* src_temp = src_ptr + 1;
+  asm volatile(
+      "vmov.u8     d30, #3                       \n"
+
+      "1:                                        \n"
+      "vld1.8      {d4}, [%0]!                   \n"  // 01234567
+      "vld1.8      {d5}, [%3]!                   \n"  // 12345678
+
+      "vmovl.u8    q0, d4                        \n"  // 01234567 (16b)
+      "vmovl.u8    q1, d5                        \n"  // 12345678 (16b)
+      "vmlal.u8    q0, d5, d30                   \n"  // 3*near+far (odd)
+      "vmlal.u8    q1, d4, d30                   \n"  // 3*near+far (even)
+
+      "vrshrn.u16  d1, q0, #2                    \n"  // 3/4*near+1/4*far (odd)
+      "vrshrn.u16  d0, q1, #2                    \n"  // 3/4*near+1/4*far (even)
+
+      "vst2.8      {d0, d1}, [%1]!               \n"  // store
+      "subs        %2, %2, #16                   \n"  // 8 sample -> 16 sample
+      "bgt         1b                            \n"
+      : "+r"(src_ptr),    // %0
+        "+r"(dst_ptr),    // %1
+        "+r"(dst_width),  // %2
+        "+r"(src_temp)    // %3
+      :
+      : "memory", "cc", "q0", "q1", "q2", "q15"  // Clobber List
+  );
+}
+
+void ScaleRowUp2_Bilinear_NEON(const uint8_t* src_ptr,
+                               ptrdiff_t src_stride,
+                               uint8_t* dst_ptr,
+                               ptrdiff_t dst_stride,
+                               int dst_width) {
+  const uint8_t* src_ptr1 = src_ptr + src_stride;
+  uint8_t* dst_ptr1 = dst_ptr + dst_stride;
+  const uint8_t* src_temp = src_ptr + 1;
+  const uint8_t* src_temp1 = src_ptr1 + 1;
+
+  asm volatile(
+      "vmov.u16    q15, #3                       \n"
+      "vmov.u8     d28, #3                       \n"
+
+      "1:                                        \n"
+      "vld1.8      {d4}, [%0]!                   \n"  // 01234567
+      "vld1.8      {d5}, [%5]!                   \n"  // 12345678
+
+      "vmovl.u8    q0, d4                        \n"  // 01234567 (16b)
+      "vmovl.u8    q1, d5                        \n"  // 12345678 (16b)
+      "vmlal.u8    q0, d5, d28                   \n"  // 3*near+far (1, odd)
+      "vmlal.u8    q1, d4, d28                   \n"  // 3*near+far (1, even)
+
+      "vld1.8      {d8}, [%1]!                   \n"
+      "vld1.8      {d9}, [%6]!                   \n"
+
+      "vmovl.u8    q2, d8                        \n"
+      "vmovl.u8    q3, d9                        \n"
+      "vmlal.u8    q2, d9, d28                   \n"  // 3*near+far (2, odd)
+      "vmlal.u8    q3, d8, d28                   \n"  // 3*near+far (2, even)
+
+      // e  o
+      // q1 q0
+      // q3 q2
+
+      "vmovq       q4, q2                        \n"
+      "vmovq       q5, q3                        \n"
+      "vmla.u16    q4, q0, q15                   \n"  // 9 3 3 1 (1, odd)
+      "vmla.u16    q5, q1, q15                   \n"  // 9 3 3 1 (1, even)
+      "vmla.u16    q0, q2, q15                   \n"  // 9 3 3 1 (2, odd)
+      "vmla.u16    q1, q3, q15                   \n"  // 9 3 3 1 (2, even)
+
+      // e  o
+      // q5 q4
+      // q1 q0
+
+      "vrshrn.u16  d2, q1, #4                    \n"  // 2, even
+      "vrshrn.u16  d3, q0, #4                    \n"  // 2, odd
+      "vrshrn.u16  d0, q5, #4                    \n"  // 1, even
+      "vrshrn.u16  d1, q4, #4                    \n"  // 1, odd
+
+      "vst2.8      {d0, d1}, [%2]!               \n"  // store
+      "vst2.8      {d2, d3}, [%3]!               \n"  // store
+      "subs        %4, %4, #16                   \n"  // 8 sample -> 16 sample
+      "bgt         1b                            \n"
+      : "+r"(src_ptr),    // %0
+        "+r"(src_ptr1),   // %1
+        "+r"(dst_ptr),    // %2
+        "+r"(dst_ptr1),   // %3
+        "+r"(dst_width),  // %4
+        "+r"(src_temp),   // %5
+        "+r"(src_temp1)   // %6
+      :
+      : "memory", "cc", "q0", "q1", "q2", "q3", "q4", "q5", "d28",
+        "q15"  // Clobber List
+  );
+}
+
+void ScaleRowUp2_Linear_12_NEON(const uint16_t* src_ptr,
+                                uint16_t* dst_ptr,
+                                int dst_width) {
+  const uint16_t* src_temp = src_ptr + 1;
+  asm volatile(
+      "vmov.u16    q15, #3                       \n"
+
+      "1:                                        \n"
+      "vld1.16     {q1}, [%0]!                   \n"  // 01234567 (16b)
+      "vld1.16     {q0}, [%3]!                   \n"  // 12345678 (16b)
+
+      "vmovq       q2, q0                        \n"
+      "vmla.u16    q0, q1, q15                   \n"  // 3*near+far (odd)
+      "vmla.u16    q1, q2, q15                   \n"  // 3*near+far (even)
+
+      "vrshr.u16   q0, q0, #2                    \n"  // 3/4*near+1/4*far (odd)
+      "vrshr.u16   q1, q1, #2                    \n"  // 3/4*near+1/4*far (even)
+
+      "vst2.16     {d0, d1, d2, d3}, [%1]!       \n"  // store
+      "subs        %2, %2, #16                   \n"  // 8 sample -> 16 sample
+      "bgt         1b                            \n"
+      : "+r"(src_ptr),    // %0
+        "+r"(dst_ptr),    // %1
+        "+r"(dst_width),  // %2
+        "+r"(src_temp)    // %3
+      :
+      : "memory", "cc", "q0", "q1", "q2", "q15"  // Clobber List
+  );
+}
+
+void ScaleRowUp2_Bilinear_12_NEON(const uint16_t* src_ptr,
+                                  ptrdiff_t src_stride,
+                                  uint16_t* dst_ptr,
+                                  ptrdiff_t dst_stride,
+                                  int dst_width) {
+  const uint16_t* src_ptr1 = src_ptr + src_stride;
+  uint16_t* dst_ptr1 = dst_ptr + dst_stride;
+  const uint16_t* src_temp = src_ptr + 1;
+  const uint16_t* src_temp1 = src_ptr1 + 1;
+
+  asm volatile(
+      "vmov.u16    q15, #3                       \n"
+
+      "1:                                        \n"
+      "vld1.16     {q0}, [%0]!                   \n"  // 01234567 (16b)
+      "vld1.16     {q1}, [%5]!                   \n"  // 12345678 (16b)
+
+      "vmovq       q2, q0                        \n"
+      "vmla.u16    q0, q1, q15                   \n"  // 3*near+far (odd)
+      "vmla.u16    q1, q2, q15                   \n"  // 3*near+far (even)
+
+      "vld1.16     {q2}, [%1]!                   \n"  // 01234567 (16b)
+      "vld1.16     {q3}, [%6]!                   \n"  // 12345678 (16b)
+
+      "vmovq       q4, q2                        \n"
+      "vmla.u16    q2, q3, q15                   \n"  // 3*near+far (odd)
+      "vmla.u16    q3, q4, q15                   \n"  // 3*near+far (even)
+
+      "vmovq       q4, q2                        \n"
+      "vmovq       q5, q3                        \n"
+      "vmla.u16    q4, q0, q15                   \n"  // 9 3 3 1 (1, odd)
+      "vmla.u16    q5, q1, q15                   \n"  // 9 3 3 1 (1, even)
+      "vmla.u16    q0, q2, q15                   \n"  // 9 3 3 1 (2, odd)
+      "vmla.u16    q1, q3, q15                   \n"  // 9 3 3 1 (2, even)
+
+      "vrshr.u16   q2, q1, #4                    \n"  // 2, even
+      "vrshr.u16   q3, q0, #4                    \n"  // 2, odd
+      "vrshr.u16   q0, q5, #4                    \n"  // 1, even
+      "vrshr.u16   q1, q4, #4                    \n"  // 1, odd
+
+      "vst2.16     {d0, d1, d2, d3}, [%2]!       \n"  // store
+      "vst2.16     {d4, d5, d6, d7}, [%3]!       \n"  // store
+      "subs        %4, %4, #16                   \n"  // 8 sample -> 16 sample
+      "bgt         1b                            \n"
+      : "+r"(src_ptr),    // %0
+        "+r"(src_ptr1),   // %1
+        "+r"(dst_ptr),    // %2
+        "+r"(dst_ptr1),   // %3
+        "+r"(dst_width),  // %4
+        "+r"(src_temp),   // %5
+        "+r"(src_temp1)   // %6
+      :
+      : "memory", "cc", "q0", "q1", "q2", "q3", "q4", "q5",
+        "q15"  // Clobber List
+  );
+}
+
+void ScaleRowUp2_Linear_16_NEON(const uint16_t* src_ptr,
+                                uint16_t* dst_ptr,
+                                int dst_width) {
+  const uint16_t* src_temp = src_ptr + 1;
+  asm volatile(
+      "vmov.u16    d31, #3                       \n"
+
+      "1:                                        \n"
+      "vld1.16     {q0}, [%0]!                   \n"  // 01234567 (16b)
+      "vld1.16     {q1}, [%3]!                   \n"  // 12345678 (16b)
+
+      "vmovl.u16   q2, d0                        \n"  // 0123 (32b)
+      "vmovl.u16   q3, d1                        \n"  // 4567 (32b)
+      "vmovl.u16   q4, d2                        \n"  // 1234 (32b)
+      "vmovl.u16   q5, d3                        \n"  // 5678 (32b)
+
+      "vmlal.u16   q2, d2, d31                   \n"
+      "vmlal.u16   q3, d3, d31                   \n"
+      "vmlal.u16   q4, d0, d31                   \n"
+      "vmlal.u16   q5, d1, d31                   \n"
+
+      "vrshrn.u32  d0, q4, #2                    \n"
+      "vrshrn.u32  d1, q5, #2                    \n"
+      "vrshrn.u32  d2, q2, #2                    \n"
+      "vrshrn.u32  d3, q3, #2                    \n"
+
+      "vst2.16     {q0, q1}, [%1]!               \n"  // store
+      "subs        %2, %2, #16                   \n"  // 8 sample -> 16 sample
+      "bgt         1b                            \n"
+      : "+r"(src_ptr),    // %0
+        "+r"(dst_ptr),    // %1
+        "+r"(dst_width),  // %2
+        "+r"(src_temp)    // %3
+      :
+      : "memory", "cc", "q0", "q1", "q2", "q15"  // Clobber List
+  );
+}
+
+void ScaleRowUp2_Bilinear_16_NEON(const uint16_t* src_ptr,
+                                  ptrdiff_t src_stride,
+                                  uint16_t* dst_ptr,
+                                  ptrdiff_t dst_stride,
+                                  int dst_width) {
+  const uint16_t* src_ptr1 = src_ptr + src_stride;
+  uint16_t* dst_ptr1 = dst_ptr + dst_stride;
+  const uint16_t* src_temp = src_ptr + 1;
+  const uint16_t* src_temp1 = src_ptr1 + 1;
+
+  asm volatile(
+      "vmov.u16    d31, #3                       \n"
+      "vmov.u32    q14, #3                       \n"
+
+      "1:                                        \n"
+      "vld1.16     {d0}, [%0]!                   \n"  // 0123 (16b)
+      "vld1.16     {d1}, [%5]!                   \n"  // 1234 (16b)
+      "vmovl.u16   q2, d0                        \n"  // 0123 (32b)
+      "vmovl.u16   q3, d1                        \n"  // 1234 (32b)
+      "vmlal.u16   q2, d1, d31                   \n"
+      "vmlal.u16   q3, d0, d31                   \n"
+
+      "vld1.16     {d0}, [%1]!                   \n"  // 0123 (16b)
+      "vld1.16     {d1}, [%6]!                   \n"  // 1234 (16b)
+      "vmovl.u16   q4, d0                        \n"  // 0123 (32b)
+      "vmovl.u16   q5, d1                        \n"  // 1234 (32b)
+      "vmlal.u16   q4, d1, d31                   \n"
+      "vmlal.u16   q5, d0, d31                   \n"
+
+      "vmovq       q0, q4                        \n"
+      "vmovq       q1, q5                        \n"
+      "vmla.u32    q4, q2, q14                   \n"
+      "vmla.u32    q5, q3, q14                   \n"
+      "vmla.u32    q2, q0, q14                   \n"
+      "vmla.u32    q3, q1, q14                   \n"
+
+      "vrshrn.u32  d1, q4, #4                    \n"
+      "vrshrn.u32  d0, q5, #4                    \n"
+      "vrshrn.u32  d3, q2, #4                    \n"
+      "vrshrn.u32  d2, q3, #4                    \n"
+
+      "vst2.16     {d0, d1}, [%2]!               \n"  // store
+      "vst2.16     {d2, d3}, [%3]!               \n"  // store
+      "subs        %4, %4, #8                    \n"  // 4 sample -> 8 sample
+      "bgt         1b                            \n"
+      : "+r"(src_ptr),    // %0
+        "+r"(src_ptr1),   // %1
+        "+r"(dst_ptr),    // %2
+        "+r"(dst_ptr1),   // %3
+        "+r"(dst_width),  // %4
+        "+r"(src_temp),   // %5
+        "+r"(src_temp1)   // %6
+      :
+      : "memory", "cc", "q0", "q1", "q2", "q3", "q4", "q5", "q14",
+        "d31"  // Clobber List
+  );
+}
+
+void ScaleUVRowUp2_Linear_NEON(const uint8_t* src_ptr,
+                               uint8_t* dst_ptr,
+                               int dst_width) {
+  const uint8_t* src_temp = src_ptr + 2;
+  asm volatile(
+      "vmov.u8     d30, #3                       \n"
+
+      "1:                                        \n"
+      "vld1.8      {d4}, [%0]!                   \n"  // 00112233 (1u1v)
+      "vld1.8      {d5}, [%3]!                   \n"  // 11223344 (1u1v)
+
+      "vmovl.u8    q0, d4                        \n"  // 00112233 (1u1v, 16b)
+      "vmovl.u8    q1, d5                        \n"  // 11223344 (1u1v, 16b)
+      "vmlal.u8    q0, d5, d30                   \n"  // 3*near+far (odd)
+      "vmlal.u8    q1, d4, d30                   \n"  // 3*near+far (even)
+
+      "vrshrn.u16  d1, q0, #2                    \n"  // 3/4*near+1/4*far (odd)
+      "vrshrn.u16  d0, q1, #2                    \n"  // 3/4*near+1/4*far (even)
+
+      "vst2.16     {d0, d1}, [%1]!               \n"  // store
+      "subs        %2, %2, #8                    \n"  // 4 uv -> 8 uv
+      "bgt         1b                            \n"
+      : "+r"(src_ptr),    // %0
+        "+r"(dst_ptr),    // %1
+        "+r"(dst_width),  // %2
+        "+r"(src_temp)    // %3
+      :
+      : "memory", "cc", "q0", "q1", "q2", "d30"  // Clobber List
+  );
+}
+
+void ScaleUVRowUp2_Bilinear_NEON(const uint8_t* src_ptr,
+                                 ptrdiff_t src_stride,
+                                 uint8_t* dst_ptr,
+                                 ptrdiff_t dst_stride,
+                                 int dst_width) {
+  const uint8_t* src_ptr1 = src_ptr + src_stride;
+  uint8_t* dst_ptr1 = dst_ptr + dst_stride;
+  const uint8_t* src_temp = src_ptr + 2;
+  const uint8_t* src_temp1 = src_ptr1 + 2;
+
+  asm volatile(
+      "vmov.u16    q15, #3                       \n"
+      "vmov.u8     d28, #3                       \n"
+
+      "1:                                        \n"
+      "vld1.8      {d4}, [%0]!                   \n"  // 00112233 (1u1v)
+      "vld1.8      {d5}, [%5]!                   \n"  // 11223344 (1u1v)
+
+      "vmovl.u8    q0, d4                        \n"  // 00112233 (1u1v, 16b)
+      "vmovl.u8    q1, d5                        \n"  // 11223344 (1u1v, 16b)
+      "vmlal.u8    q0, d5, d28                   \n"  // 3*near+far (1, odd)
+      "vmlal.u8    q1, d4, d28                   \n"  // 3*near+far (1, even)
+
+      "vld1.8      {d8}, [%1]!                   \n"  // 00112233 (1u1v)
+      "vld1.8      {d9}, [%6]!                   \n"  // 11223344 (1u1v)
+
+      "vmovl.u8    q2, d8                        \n"  // 00112233 (1u1v, 16b)
+      "vmovl.u8    q3, d9                        \n"  // 11223344 (1u1v, 16b)
+      "vmlal.u8    q2, d9, d28                   \n"  // 3*near+far (2, odd)
+      "vmlal.u8    q3, d8, d28                   \n"  // 3*near+far (2, even)
+
+      // e  o
+      // q1 q0
+      // q3 q2
+
+      "vmovq       q4, q2                        \n"
+      "vmovq       q5, q3                        \n"
+      "vmla.u16    q4, q0, q15                   \n"  // 9 3 3 1 (1, odd)
+      "vmla.u16    q5, q1, q15                   \n"  // 9 3 3 1 (1, even)
+      "vmla.u16    q0, q2, q15                   \n"  // 9 3 3 1 (2, odd)
+      "vmla.u16    q1, q3, q15                   \n"  // 9 3 3 1 (2, even)
+
+      // e  o
+      // q5 q4
+      // q1 q0
+
+      "vrshrn.u16  d2, q1, #4                    \n"  // 2, even
+      "vrshrn.u16  d3, q0, #4                    \n"  // 2, odd
+      "vrshrn.u16  d0, q5, #4                    \n"  // 1, even
+      "vrshrn.u16  d1, q4, #4                    \n"  // 1, odd
+
+      "vst2.16     {d0, d1}, [%2]!               \n"  // store
+      "vst2.16     {d2, d3}, [%3]!               \n"  // store
+      "subs        %4, %4, #8                    \n"  // 4 uv -> 8 uv
+      "bgt         1b                            \n"
+      : "+r"(src_ptr),    // %0
+        "+r"(src_ptr1),   // %1
+        "+r"(dst_ptr),    // %2
+        "+r"(dst_ptr1),   // %3
+        "+r"(dst_width),  // %4
+        "+r"(src_temp),   // %5
+        "+r"(src_temp1)   // %6
+      :
+      : "memory", "cc", "q0", "q1", "q2", "q3", "q4", "q5", "d28",
+        "q15"  // Clobber List
+  );
+}
+
+void ScaleUVRowUp2_Linear_16_NEON(const uint16_t* src_ptr,
+                                  uint16_t* dst_ptr,
+                                  int dst_width) {
+  const uint16_t* src_temp = src_ptr + 2;
+  asm volatile(
+      "vmov.u16    d30, #3                       \n"
+
+      "1:                                        \n"
+      "vld1.16     {q0}, [%0]!                   \n"  // 00112233 (1u1v, 16)
+      "vld1.16     {q1}, [%3]!                   \n"  // 11223344 (1u1v, 16)
+
+      "vmovl.u16   q2, d0                        \n"  // 0011 (1u1v, 32b)
+      "vmovl.u16   q3, d2                        \n"  // 1122 (1u1v, 32b)
+      "vmovl.u16   q4, d1                        \n"  // 2233 (1u1v, 32b)
+      "vmovl.u16   q5, d3                        \n"  // 3344 (1u1v, 32b)
+      "vmlal.u16   q2, d2, d30                   \n"  // 3*near+far (odd)
+      "vmlal.u16   q3, d0, d30                   \n"  // 3*near+far (even)
+      "vmlal.u16   q4, d3, d30                   \n"  // 3*near+far (odd)
+      "vmlal.u16   q5, d1, d30                   \n"  // 3*near+far (even)
+
+      "vrshrn.u32  d1, q2, #2                    \n"  // 3/4*near+1/4*far (odd)
+      "vrshrn.u32  d0, q3, #2                    \n"  // 3/4*near+1/4*far (even)
+      "vrshrn.u32  d3, q4, #2                    \n"  // 3/4*near+1/4*far (odd)
+      "vrshrn.u32  d2, q5, #2                    \n"  // 3/4*near+1/4*far (even)
+
+      "vst2.32     {d0, d1}, [%1]!               \n"  // store
+      "vst2.32     {d2, d3}, [%1]!               \n"  // store
+      "subs        %2, %2, #8                    \n"  // 4 uv -> 8 uv
+      "bgt         1b                            \n"
+      : "+r"(src_ptr),    // %0
+        "+r"(dst_ptr),    // %1
+        "+r"(dst_width),  // %2
+        "+r"(src_temp)    // %3
+      :
+      : "memory", "cc", "q0", "q1", "q2", "q3", "q4", "q5",
+        "d30"  // Clobber List
+  );
+}
+
+void ScaleUVRowUp2_Bilinear_16_NEON(const uint16_t* src_ptr,
+                                    ptrdiff_t src_stride,
+                                    uint16_t* dst_ptr,
+                                    ptrdiff_t dst_stride,
+                                    int dst_width) {
+  const uint16_t* src_ptr1 = src_ptr + src_stride;
+  uint16_t* dst_ptr1 = dst_ptr + dst_stride;
+  const uint16_t* src_temp = src_ptr + 2;
+  const uint16_t* src_temp1 = src_ptr1 + 2;
+
+  asm volatile(
+      "vmov.u16    d30, #3                       \n"
+      "vmov.u32    q14, #3                       \n"
+
+      "1:                                        \n"
+      "vld1.8      {d0}, [%0]!                   \n"  // 0011 (1u1v)
+      "vld1.8      {d1}, [%5]!                   \n"  // 1122 (1u1v)
+      "vmovl.u16   q2, d0                        \n"  // 0011 (1u1v, 32b)
+      "vmovl.u16   q3, d1                        \n"  // 1122 (1u1v, 32b)
+      "vmlal.u16   q2, d1, d30                   \n"  // 3*near+far (1, odd)
+      "vmlal.u16   q3, d0, d30                   \n"  // 3*near+far (1, even)
+
+      "vld1.8      {d0}, [%1]!                   \n"  // 0011 (1u1v)
+      "vld1.8      {d1}, [%6]!                   \n"  // 1122 (1u1v)
+      "vmovl.u16   q4, d0                        \n"  // 0011 (1u1v, 32b)
+      "vmovl.u16   q5, d1                        \n"  // 1122 (1u1v, 32b)
+      "vmlal.u16   q4, d1, d30                   \n"  // 3*near+far (2, odd)
+      "vmlal.u16   q5, d0, d30                   \n"  // 3*near+far (2, even)
+
+      "vmovq       q0, q4                        \n"
+      "vmovq       q1, q5                        \n"
+      "vmla.u32    q4, q2, q14                   \n"  // 9 3 3 1 (1, odd)
+      "vmla.u32    q5, q3, q14                   \n"  // 9 3 3 1 (1, even)
+      "vmla.u32    q2, q0, q14                   \n"  // 9 3 3 1 (2, odd)
+      "vmla.u32    q3, q1, q14                   \n"  // 9 3 3 1 (2, even)
+
+      "vrshrn.u32  d1, q4, #4                    \n"  // 1, odd
+      "vrshrn.u32  d0, q5, #4                    \n"  // 1, even
+      "vrshrn.u32  d3, q2, #4                    \n"  // 2, odd
+      "vrshrn.u32  d2, q3, #4                    \n"  // 2, even
+
+      "vst2.32     {d0, d1}, [%2]!               \n"  // store
+      "vst2.32     {d2, d3}, [%3]!               \n"  // store
+      "subs        %4, %4, #4                    \n"  // 2 uv -> 4 uv
+      "bgt         1b                            \n"
+      : "+r"(src_ptr),    // %0
+        "+r"(src_ptr1),   // %1
+        "+r"(dst_ptr),    // %2
+        "+r"(dst_ptr1),   // %3
+        "+r"(dst_width),  // %4
+        "+r"(src_temp),   // %5
+        "+r"(src_temp1)   // %6
+      :
+      : "memory", "cc", "q0", "q1", "q2", "q3", "q4", "q5", "q14",
+        "d30"  // Clobber List
+  );
+}
+
+// Add a row of bytes to a row of shorts.  Used for box filter.
+// Reads 16 bytes and accumulates to 16 shorts at a time.
+void ScaleAddRow_NEON(const uint8_t* src_ptr,
+                      uint16_t* dst_ptr,
+                      int src_width) {
+  asm volatile(
+      "1:                                        \n"
+      "vld1.16     {q1, q2}, [%1]                \n"  // load accumulator
+      "vld1.8      {q0}, [%0]!                   \n"  // load 16 bytes
+      "vaddw.u8    q2, q2, d1                    \n"  // add
+      "vaddw.u8    q1, q1, d0                    \n"
+      "vst1.16     {q1, q2}, [%1]!               \n"  // store accumulator
+      "subs        %2, %2, #16                   \n"  // 16 processed per loop
+      "bgt         1b                            \n"
+      : "+r"(src_ptr),   // %0
+        "+r"(dst_ptr),   // %1
+        "+r"(src_width)  // %2
+      :
+      : "memory", "cc", "q0", "q1", "q2"  // Clobber List
+  );
+}
+
+// TODO(Yang Zhang): Investigate less load instructions for
+// the x/dx stepping
+#define LOAD2_DATA8_LANE(n)                      \
+  "lsr        %5, %3, #16                    \n" \
+  "add        %6, %1, %5                     \n" \
+  "add        %3, %3, %4                     \n" \
+  "vld2.8     {d6[" #n "], d7[" #n "]}, [%6] \n"
+
+// The NEON version mimics this formula (from row_common.cc):
+// #define BLENDER(a, b, f) (uint8_t)((int)(a) +
+//    ((((int)((f)) * ((int)(b) - (int)(a))) + 0x8000) >> 16))
+
+void ScaleFilterCols_NEON(uint8_t* dst_ptr,
+                          const uint8_t* src_ptr,
+                          int dst_width,
+                          int x,
+                          int dx) {
+  int dx_offset[4] = {0, 1, 2, 3};
+  int* tmp = dx_offset;
+  const uint8_t* src_tmp = src_ptr;
+  asm volatile (
+      "vdup.32     q0, %3                        \n"  // x
+      "vdup.32     q1, %4                        \n"  // dx
+      "vld1.32     {q2}, [%5]                    \n"  // 0 1 2 3
+      "vshl.i32    q3, q1, #2                    \n"  // 4 * dx
+      "vmul.s32    q1, q1, q2                    \n"
+    // x         , x + 1 * dx, x + 2 * dx, x + 3 * dx
+      "vadd.s32    q1, q1, q0                    \n"
+    // x + 4 * dx, x + 5 * dx, x + 6 * dx, x + 7 * dx
+      "vadd.s32    q2, q1, q3                    \n"
+      "vshl.i32    q0, q3, #1                    \n"  // 8 * dx
+      "1:                                        \n"
+    LOAD2_DATA8_LANE(0)
+    LOAD2_DATA8_LANE(1)
+    LOAD2_DATA8_LANE(2)
+    LOAD2_DATA8_LANE(3)
+    LOAD2_DATA8_LANE(4)
+    LOAD2_DATA8_LANE(5)
+    LOAD2_DATA8_LANE(6)
+    LOAD2_DATA8_LANE(7)
+      "vmov        q10, q1                       \n"
+      "vmov        q11, q2                       \n"
+      "vuzp.16     q10, q11                      \n"
+      "vmovl.u8    q8, d6                        \n"
+      "vmovl.u8    q9, d7                        \n"
+      "vsubl.s16   q11, d18, d16                 \n"
+      "vsubl.s16   q12, d19, d17                 \n"
+      "vmovl.u16   q13, d20                      \n"
+      "vmovl.u16   q10, d21                      \n"
+      "vmul.s32    q11, q11, q13                 \n"
+      "vmul.s32    q12, q12, q10                 \n"
+      "vrshrn.s32  d18, q11, #16                 \n"
+      "vrshrn.s32  d19, q12, #16                 \n"
+      "vadd.s16    q8, q8, q9                    \n"
+      "vmovn.s16   d6, q8                        \n"
+
+      "vst1.8      {d6}, [%0]!                   \n"  // store pixels
+      "vadd.s32    q1, q1, q0                    \n"
+      "vadd.s32    q2, q2, q0                    \n"
+      "subs        %2, %2, #8                    \n"  // 8 processed per loop
+      "bgt         1b                            \n"
+  : "+r"(dst_ptr),          // %0
+    "+r"(src_ptr),          // %1
+    "+r"(dst_width),        // %2
+    "+r"(x),                // %3
+    "+r"(dx),               // %4
+    "+r"(tmp),              // %5
+    "+r"(src_tmp)           // %6
+  :
+  : "memory", "cc", "q0", "q1", "q2", "q3",
+    "q8", "q9", "q10", "q11", "q12", "q13"
+  );
+}
+
+#undef LOAD2_DATA8_LANE
+
+// 16x2 -> 16x1
+void ScaleFilterRows_NEON(uint8_t* dst_ptr,
+                          const uint8_t* src_ptr,
+                          ptrdiff_t src_stride,
+                          int dst_width,
+                          int source_y_fraction) {
+  asm volatile(
+      "cmp         %4, #0                        \n"
+      "beq         100f                          \n"
+      "add         %2, %1                        \n"
+      "cmp         %4, #64                       \n"
+      "beq         75f                           \n"
+      "cmp         %4, #128                      \n"
+      "beq         50f                           \n"
+      "cmp         %4, #192                      \n"
+      "beq         25f                           \n"
+
+      "vdup.8      d5, %4                        \n"
+      "rsb         %4, #256                      \n"
+      "vdup.8      d4, %4                        \n"
+      // General purpose row blend.
+      "1:                                        \n"
+      "vld1.8      {q0}, [%1]!                   \n"
+      "vld1.8      {q1}, [%2]!                   \n"
+      "subs        %3, %3, #16                   \n"
+      "vmull.u8    q13, d0, d4                   \n"
+      "vmull.u8    q14, d1, d4                   \n"
+      "vmlal.u8    q13, d2, d5                   \n"
+      "vmlal.u8    q14, d3, d5                   \n"
+      "vrshrn.u16  d0, q13, #8                   \n"
+      "vrshrn.u16  d1, q14, #8                   \n"
+      "vst1.8      {q0}, [%0]!                   \n"
+      "bgt         1b                            \n"
+      "b           99f                           \n"
+
+      // Blend 25 / 75.
+      "25:                                       \n"
+      "vld1.8      {q0}, [%1]!                   \n"
+      "vld1.8      {q1}, [%2]!                   \n"
+      "subs        %3, %3, #16                   \n"
+      "vrhadd.u8   q0, q1                        \n"
+      "vrhadd.u8   q0, q1                        \n"
+      "vst1.8      {q0}, [%0]!                   \n"
+      "bgt         25b                           \n"
+      "b           99f                           \n"
+
+      // Blend 50 / 50.
+      "50:                                       \n"
+      "vld1.8      {q0}, [%1]!                   \n"
+      "vld1.8      {q1}, [%2]!                   \n"
+      "subs        %3, %3, #16                   \n"
+      "vrhadd.u8   q0, q1                        \n"
+      "vst1.8      {q0}, [%0]!                   \n"
+      "bgt         50b                           \n"
+      "b           99f                           \n"
+
+      // Blend 75 / 25.
+      "75:                                       \n"
+      "vld1.8      {q1}, [%1]!                   \n"
+      "vld1.8      {q0}, [%2]!                   \n"
+      "subs        %3, %3, #16                   \n"
+      "vrhadd.u8   q0, q1                        \n"
+      "vrhadd.u8   q0, q1                        \n"
+      "vst1.8      {q0}, [%0]!                   \n"
+      "bgt         75b                           \n"
+      "b           99f                           \n"
+
+      // Blend 100 / 0 - Copy row unchanged.
+      "100:                                      \n"
+      "vld1.8      {q0}, [%1]!                   \n"
+      "subs        %3, %3, #16                   \n"
+      "vst1.8      {q0}, [%0]!                   \n"
+      "bgt         100b                          \n"
+
+      "99:                                       \n"
+      "vst1.8      {d1[7]}, [%0]                 \n"
+      : "+r"(dst_ptr),           // %0
+        "+r"(src_ptr),           // %1
+        "+r"(src_stride),        // %2
+        "+r"(dst_width),         // %3
+        "+r"(source_y_fraction)  // %4
+      :
+      : "q0", "q1", "d4", "d5", "q13", "q14", "memory", "cc");
+}
+
+void ScaleARGBRowDown2_NEON(const uint8_t* src_ptr,
+                            ptrdiff_t src_stride,
+                            uint8_t* dst,
+                            int dst_width) {
+  (void)src_stride;
+  asm volatile(
+      "1:                                        \n"
+      "vld4.32     {d0, d2, d4, d6}, [%0]!       \n"  // load 8 ARGB pixels.
+      "vld4.32     {d1, d3, d5, d7}, [%0]!       \n"  // load next 8 ARGB
+      "subs        %2, %2, #8                    \n"  // 8 processed per loop
+      "vmov        q2, q1                        \n"  // load next 8 ARGB
+      "vst2.32     {q2, q3}, [%1]!               \n"  // store odd pixels
+      "bgt         1b                            \n"
+      : "+r"(src_ptr),   // %0
+        "+r"(dst),       // %1
+        "+r"(dst_width)  // %2
+      :
+      : "memory", "cc", "q0", "q1", "q2", "q3"  // Clobber List
+  );
+}
+
+//  46:  f964 018d   vld4.32  {d16,d18,d20,d22}, [r4]!
+//  4a:  3e04        subs  r6, #4
+//  4c:  f964 118d   vld4.32  {d17,d19,d21,d23}, [r4]!
+//  50:  ef64 21f4   vorr  q9, q10, q10
+//  54:  f942 038d   vst2.32  {d16-d19}, [r2]!
+//  58:  d1f5        bne.n  46 <ScaleARGBRowDown2_C+0x46>
+
+void ScaleARGBRowDown2Linear_NEON(const uint8_t* src_argb,
+                                  ptrdiff_t src_stride,
+                                  uint8_t* dst_argb,
+                                  int dst_width) {
+  (void)src_stride;
+  asm volatile(
+      "1:                                        \n"
+      "vld4.32     {d0, d2, d4, d6}, [%0]!       \n"  // load 8 ARGB pixels.
+      "vld4.32     {d1, d3, d5, d7}, [%0]!       \n"  // load next 8 ARGB
+      "subs        %2, %2, #8                    \n"  // 8 processed per loop
+      "vrhadd.u8   q0, q0, q1                    \n"  // rounding half add
+      "vrhadd.u8   q1, q2, q3                    \n"  // rounding half add
+      "vst2.32     {q0, q1}, [%1]!               \n"
+      "bgt         1b                            \n"
+      : "+r"(src_argb),  // %0
+        "+r"(dst_argb),  // %1
+        "+r"(dst_width)  // %2
+      :
+      : "memory", "cc", "q0", "q1", "q2", "q3"  // Clobber List
+  );
+}
+
+void ScaleARGBRowDown2Box_NEON(const uint8_t* src_ptr,
+                               ptrdiff_t src_stride,
+                               uint8_t* dst,
+                               int dst_width) {
+  asm volatile(
+      // change the stride to row 2 pointer
+      "add         %1, %1, %0                    \n"
+      "1:                                        \n"
+      "vld4.8      {d0, d2, d4, d6}, [%0]!       \n"  // load 8 ARGB pixels.
+      "vld4.8      {d1, d3, d5, d7}, [%0]!       \n"  // load next 8 ARGB
+      "subs        %3, %3, #8                    \n"  // 8 processed per loop.
+      "vpaddl.u8   q0, q0                        \n"  // B 16 bytes -> 8 shorts.
+      "vpaddl.u8   q1, q1                        \n"  // G 16 bytes -> 8 shorts.
+      "vpaddl.u8   q2, q2                        \n"  // R 16 bytes -> 8 shorts.
+      "vpaddl.u8   q3, q3                        \n"  // A 16 bytes -> 8 shorts.
+      "vld4.8      {d16, d18, d20, d22}, [%1]!   \n"  // load 8 more ARGB
+      "vld4.8      {d17, d19, d21, d23}, [%1]!   \n"  // load last 8 ARGB
+      "vpadal.u8   q0, q8                        \n"  // B 16 bytes -> 8 shorts.
+      "vpadal.u8   q1, q9                        \n"  // G 16 bytes -> 8 shorts.
+      "vpadal.u8   q2, q10                       \n"  // R 16 bytes -> 8 shorts.
+      "vpadal.u8   q3, q11                       \n"  // A 16 bytes -> 8 shorts.
+      "vrshrn.u16  d0, q0, #2                    \n"  // round and pack to bytes
+      "vrshrn.u16  d1, q1, #2                    \n"
+      "vrshrn.u16  d2, q2, #2                    \n"
+      "vrshrn.u16  d3, q3, #2                    \n"
+      "vst4.8      {d0, d1, d2, d3}, [%2]!       \n"
+      "bgt         1b                            \n"
+      : "+r"(src_ptr),     // %0
+        "+r"(src_stride),  // %1
+        "+r"(dst),         // %2
+        "+r"(dst_width)    // %3
+      :
+      : "memory", "cc", "q0", "q1", "q2", "q3", "q8", "q9", "q10", "q11");
+}
+
+// Reads 4 pixels at a time.
+// Alignment requirement: src_argb 4 byte aligned.
+void ScaleARGBRowDownEven_NEON(const uint8_t* src_argb,
+                               ptrdiff_t src_stride,
+                               int src_stepx,
+                               uint8_t* dst_argb,
+                               int dst_width) {
+  (void)src_stride;
+  asm volatile(
+      "mov         r12, %3, lsl #2               \n"
+      "1:                                        \n"
+      "vld1.32     {d0[0]}, [%0], r12            \n"
+      "vld1.32     {d0[1]}, [%0], r12            \n"
+      "vld1.32     {d1[0]}, [%0], r12            \n"
+      "vld1.32     {d1[1]}, [%0], r12            \n"
+      "subs        %2, %2, #4                    \n"  // 4 pixels per loop.
+      "vst1.8      {q0}, [%1]!                   \n"
+      "bgt         1b                            \n"
+      : "+r"(src_argb),  // %0
+        "+r"(dst_argb),  // %1
+        "+r"(dst_width)  // %2
+      : "r"(src_stepx)   // %3
+      : "memory", "cc", "r12", "q0");
+}
+
+// Reads 4 pixels at a time.
+// Alignment requirement: src_argb 4 byte aligned.
+void ScaleARGBRowDownEvenBox_NEON(const uint8_t* src_argb,
+                                  ptrdiff_t src_stride,
+                                  int src_stepx,
+                                  uint8_t* dst_argb,
+                                  int dst_width) {
+  asm volatile(
+      "mov         r12, %4, lsl #2               \n"
+      "add         %1, %1, %0                    \n"
+      "1:                                        \n"
+      "vld1.8      {d0}, [%0], r12               \n"  // 4 2x2 blocks -> 2x1
+      "vld1.8      {d1}, [%1], r12               \n"
+      "vld1.8      {d2}, [%0], r12               \n"
+      "vld1.8      {d3}, [%1], r12               \n"
+      "vld1.8      {d4}, [%0], r12               \n"
+      "vld1.8      {d5}, [%1], r12               \n"
+      "vld1.8      {d6}, [%0], r12               \n"
+      "vld1.8      {d7}, [%1], r12               \n"
+      "vaddl.u8    q0, d0, d1                    \n"
+      "vaddl.u8    q1, d2, d3                    \n"
+      "vaddl.u8    q2, d4, d5                    \n"
+      "vaddl.u8    q3, d6, d7                    \n"
+      "vswp.8      d1, d2                        \n"  // ab_cd -> ac_bd
+      "vswp.8      d5, d6                        \n"  // ef_gh -> eg_fh
+      "vadd.u16    q0, q0, q1                    \n"  // (a+b)_(c+d)
+      "vadd.u16    q2, q2, q3                    \n"  // (e+f)_(g+h)
+      "vrshrn.u16  d0, q0, #2                    \n"  // first 2 pixels.
+      "vrshrn.u16  d1, q2, #2                    \n"  // next 2 pixels.
+      "subs        %3, %3, #4                    \n"  // 4 pixels per loop.
+      "vst1.8      {q0}, [%2]!                   \n"
+      "bgt         1b                            \n"
+      : "+r"(src_argb),    // %0
+        "+r"(src_stride),  // %1
+        "+r"(dst_argb),    // %2
+        "+r"(dst_width)    // %3
+      : "r"(src_stepx)     // %4
+      : "memory", "cc", "r12", "q0", "q1", "q2", "q3");
+}
+
+// TODO(Yang Zhang): Investigate less load instructions for
+// the x/dx stepping
+#define LOAD1_DATA32_LANE(dn, n)                 \
+  "lsr        %5, %3, #16                    \n" \
+  "add        %6, %1, %5, lsl #2             \n" \
+  "add        %3, %3, %4                     \n" \
+  "vld1.32    {" #dn "[" #n "]}, [%6]        \n"
+
+void ScaleARGBCols_NEON(uint8_t* dst_argb,
+                        const uint8_t* src_argb,
+                        int dst_width,
+                        int x,
+                        int dx) {
+  int tmp;
+  const uint8_t* src_tmp = src_argb;
+  asm volatile(
+      "1:                                        \n"
+      // clang-format off
+      LOAD1_DATA32_LANE(d0, 0)
+      LOAD1_DATA32_LANE(d0, 1)
+      LOAD1_DATA32_LANE(d1, 0)
+      LOAD1_DATA32_LANE(d1, 1)
+      LOAD1_DATA32_LANE(d2, 0)
+      LOAD1_DATA32_LANE(d2, 1)
+      LOAD1_DATA32_LANE(d3, 0)
+      LOAD1_DATA32_LANE(d3, 1)
+      // clang-format on
+      "vst1.32     {q0, q1}, [%0]!               \n"  // store pixels
+      "subs        %2, %2, #8                    \n"  // 8 processed per loop
+      "bgt         1b                            \n"
+      : "+r"(dst_argb),   // %0
+        "+r"(src_argb),   // %1
+        "+r"(dst_width),  // %2
+        "+r"(x),          // %3
+        "+r"(dx),         // %4
+        "=&r"(tmp),       // %5
+        "+r"(src_tmp)     // %6
+      :
+      : "memory", "cc", "q0", "q1");
+}
+
+#undef LOAD1_DATA32_LANE
+
+// TODO(Yang Zhang): Investigate less load instructions for
+// the x/dx stepping
+#define LOAD2_DATA32_LANE(dn1, dn2, n)                       \
+  "lsr        %5, %3, #16                                \n" \
+  "add        %6, %1, %5, lsl #2                         \n" \
+  "add        %3, %3, %4                                 \n" \
+  "vld2.32    {" #dn1 "[" #n "], " #dn2 "[" #n "]}, [%6] \n"
+
+void ScaleARGBFilterCols_NEON(uint8_t* dst_argb,
+                              const uint8_t* src_argb,
+                              int dst_width,
+                              int x,
+                              int dx) {
+  int dx_offset[4] = {0, 1, 2, 3};
+  int* tmp = dx_offset;
+  const uint8_t* src_tmp = src_argb;
+  asm volatile (
+      "vdup.32     q0, %3                        \n"  // x
+      "vdup.32     q1, %4                        \n"  // dx
+      "vld1.32     {q2}, [%5]                    \n"  // 0 1 2 3
+      "vshl.i32    q9, q1, #2                    \n"  // 4 * dx
+      "vmul.s32    q1, q1, q2                    \n"
+      "vmov.i8     q3, #0x7f                     \n"  // 0x7F
+      "vmov.i16    q15, #0x7f                    \n"  // 0x7F
+    // x         , x + 1 * dx, x + 2 * dx, x + 3 * dx
+      "vadd.s32    q8, q1, q0                    \n"
+      "1:                                        \n"
+    // d0, d1: a
+    // d2, d3: b
+    LOAD2_DATA32_LANE(d0, d2, 0)
+    LOAD2_DATA32_LANE(d0, d2, 1)
+    LOAD2_DATA32_LANE(d1, d3, 0)
+    LOAD2_DATA32_LANE(d1, d3, 1)
+    "vshrn.i32   d22, q8, #9                   \n"
+    "vand.16     d22, d22, d30                 \n"
+    "vdup.8      d24, d22[0]                   \n"
+    "vdup.8      d25, d22[2]                   \n"
+    "vdup.8      d26, d22[4]                   \n"
+    "vdup.8      d27, d22[6]                   \n"
+    "vext.8      d4, d24, d25, #4              \n"
+    "vext.8      d5, d26, d27, #4              \n"  // f
+    "veor.8      q10, q2, q3                   \n"  // 0x7f ^ f
+    "vmull.u8    q11, d0, d20                  \n"
+    "vmull.u8    q12, d1, d21                  \n"
+    "vmull.u8    q13, d2, d4                   \n"
+    "vmull.u8    q14, d3, d5                   \n"
+    "vadd.i16    q11, q11, q13                 \n"
+    "vadd.i16    q12, q12, q14                 \n"
+    "vshrn.i16   d0, q11, #7                   \n"
+    "vshrn.i16   d1, q12, #7                   \n"
+
+    "vst1.32     {d0, d1}, [%0]!               \n"  // store pixels
+    "vadd.s32    q8, q8, q9                    \n"
+    "subs        %2, %2, #4                    \n"  // 4 processed per loop
+    "bgt         1b                            \n"
+  : "+r"(dst_argb),         // %0
+    "+r"(src_argb),         // %1
+    "+r"(dst_width),        // %2
+    "+r"(x),                // %3
+    "+r"(dx),               // %4
+    "+r"(tmp),              // %5
+    "+r"(src_tmp)           // %6
+  :
+  : "memory", "cc", "q0", "q1", "q2", "q3", "q8", "q9",
+    "q10", "q11", "q12", "q13", "q14", "q15"
+  );
+}
+
+#undef LOAD2_DATA32_LANE
+
+void ScaleUVRowDown2Box_NEON(const uint8_t* src_ptr,
+                             ptrdiff_t src_stride,
+                             uint8_t* dst,
+                             int dst_width) {
+  asm volatile(
+      // change the stride to row 2 pointer
+      "add         %1, %1, %0                    \n"
+      "1:                                        \n"
+      "vld2.8      {d0, d2}, [%0]!               \n"  // load 8 UV pixels.
+      "vld2.8      {d1, d3}, [%0]!               \n"  // load next 8 UV
+      "subs        %3, %3, #8                    \n"  // 8 processed per loop.
+      "vpaddl.u8   q0, q0                        \n"  // U 16 bytes -> 8 shorts.
+      "vpaddl.u8   q1, q1                        \n"  // V 16 bytes -> 8 shorts.
+      "vld2.8      {d16, d18}, [%1]!             \n"  // load 8 more UV
+      "vld2.8      {d17, d19}, [%1]!             \n"  // load last 8 UV
+      "vpadal.u8   q0, q8                        \n"  // U 16 bytes -> 8 shorts.
+      "vpadal.u8   q1, q9                        \n"  // V 16 bytes -> 8 shorts.
+      "vrshrn.u16  d0, q0, #2                    \n"  // round and pack to bytes
+      "vrshrn.u16  d1, q1, #2                    \n"
+      "vst2.8      {d0, d1}, [%2]!               \n"
+      "bgt         1b                            \n"
+      : "+r"(src_ptr),     // %0
+        "+r"(src_stride),  // %1
+        "+r"(dst),         // %2
+        "+r"(dst_width)    // %3
+      :
+      : "memory", "cc", "q0", "q1", "q8", "q9");
+}
+
+// Reads 4 pixels at a time.
+void ScaleUVRowDownEven_NEON(const uint8_t* src_ptr,
+                             ptrdiff_t src_stride,
+                             int src_stepx,  // pixel step
+                             uint8_t* dst_ptr,
+                             int dst_width) {
+  const uint8_t* src1_ptr = src_ptr + src_stepx * 2;
+  const uint8_t* src2_ptr = src_ptr + src_stepx * 4;
+  const uint8_t* src3_ptr = src_ptr + src_stepx * 6;
+  (void)src_stride;
+  asm volatile(
+      "1:                                        \n"
+      "vld1.16     {d0[0]}, [%0], %6             \n"
+      "vld1.16     {d0[1]}, [%1], %6             \n"
+      "vld1.16     {d0[2]}, [%2], %6             \n"
+      "vld1.16     {d0[3]}, [%3], %6             \n"
+      "subs        %5, %5, #4                    \n"  // 4 pixels per loop.
+      "vst1.8      {d0}, [%4]!                   \n"
+      "bgt         1b                            \n"
+      : "+r"(src_ptr),      // %0
+        "+r"(src1_ptr),     // %1
+        "+r"(src2_ptr),     // %2
+        "+r"(src3_ptr),     // %3
+        "+r"(dst_ptr),      // %4
+        "+r"(dst_width)     // %5
+      : "r"(src_stepx * 8)  // %6
+      : "memory", "cc", "d0");
+}
+
+#endif  // defined(__ARM_NEON__) && !defined(__aarch64__)
+
+#ifdef __cplusplus
+}  // extern "C"
+}  // namespace libyuv
+#endif
diff --git a/3rdparty/libyuv/src/source/scale_neon64.cc b/3rdparty/libyuv/src/source/scale_neon64.cc
new file mode 100644
index 00000000..9f9636e6
--- /dev/null
+++ b/3rdparty/libyuv/src/source/scale_neon64.cc
@@ -0,0 +1,1634 @@
+/*
+ *  Copyright 2014 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include "libyuv/row.h"
+#include "libyuv/scale.h"
+#include "libyuv/scale_row.h"
+
+#ifdef __cplusplus
+namespace libyuv {
+extern "C" {
+#endif
+
+// This module is for GCC Neon armv8 64 bit.
+#if !defined(LIBYUV_DISABLE_NEON) && defined(__aarch64__)
+
+// Read 32x1 throw away even pixels, and write 16x1.
+void ScaleRowDown2_NEON(const uint8_t* src_ptr,
+                        ptrdiff_t src_stride,
+                        uint8_t* dst,
+                        int dst_width) {
+  (void)src_stride;
+  asm volatile(
+      "1:                                        \n"
+      // load even pixels into v0, odd into v1
+      "ld2         {v0.16b,v1.16b}, [%0], #32    \n"
+      "subs        %w2, %w2, #16                 \n"  // 16 processed per loop
+      "prfm        pldl1keep, [%0, 448]          \n"  // prefetch 7 lines ahead
+      "st1         {v1.16b}, [%1], #16           \n"  // store odd pixels
+      "b.gt        1b                            \n"
+      : "+r"(src_ptr),   // %0
+        "+r"(dst),       // %1
+        "+r"(dst_width)  // %2
+      :
+      : "v0", "v1"  // Clobber List
+  );
+}
+
+// Read 32x1 average down and write 16x1.
+void ScaleRowDown2Linear_NEON(const uint8_t* src_ptr,
+                              ptrdiff_t src_stride,
+                              uint8_t* dst,
+                              int dst_width) {
+  (void)src_stride;
+  asm volatile(
+      "1:                                        \n"
+      // load even pixels into v0, odd into v1
+      "ld2         {v0.16b,v1.16b}, [%0], #32    \n"
+      "subs        %w2, %w2, #16                 \n"  // 16 processed per loop
+      "urhadd      v0.16b, v0.16b, v1.16b        \n"  // rounding half add
+      "prfm        pldl1keep, [%0, 448]          \n"  // prefetch 7 lines ahead
+      "st1         {v0.16b}, [%1], #16           \n"
+      "b.gt        1b                            \n"
+      : "+r"(src_ptr),   // %0
+        "+r"(dst),       // %1
+        "+r"(dst_width)  // %2
+      :
+      : "v0", "v1"  // Clobber List
+  );
+}
+
+// Read 32x2 average down and write 16x1.
+void ScaleRowDown2Box_NEON(const uint8_t* src_ptr,
+                           ptrdiff_t src_stride,
+                           uint8_t* dst,
+                           int dst_width) {
+  asm volatile(
+      // change the stride to row 2 pointer
+      "add         %1, %1, %0                    \n"
+      "1:                                        \n"
+      "ld1         {v0.16b, v1.16b}, [%0], #32   \n"  // load row 1 and post inc
+      "ld1         {v2.16b, v3.16b}, [%1], #32   \n"  // load row 2 and post inc
+      "subs        %w3, %w3, #16                 \n"  // 16 processed per loop
+      "uaddlp      v0.8h, v0.16b                 \n"  // row 1 add adjacent
+      "prfm        pldl1keep, [%0, 448]          \n"  // prefetch 7 lines ahead
+      "uaddlp      v1.8h, v1.16b                 \n"
+      "prfm        pldl1keep, [%1, 448]          \n"
+      "uadalp      v0.8h, v2.16b                 \n"  // += row 2 add adjacent
+      "uadalp      v1.8h, v3.16b                 \n"
+      "rshrn       v0.8b, v0.8h, #2              \n"  // round and pack
+      "rshrn2      v0.16b, v1.8h, #2             \n"
+      "st1         {v0.16b}, [%2], #16           \n"
+      "b.gt        1b                            \n"
+      : "+r"(src_ptr),     // %0
+        "+r"(src_stride),  // %1
+        "+r"(dst),         // %2
+        "+r"(dst_width)    // %3
+      :
+      : "v0", "v1", "v2", "v3"  // Clobber List
+  );
+}
+
+void ScaleRowDown4_NEON(const uint8_t* src_ptr,
+                        ptrdiff_t src_stride,
+                        uint8_t* dst_ptr,
+                        int dst_width) {
+  (void)src_stride;
+  asm volatile(
+      "1:                                        \n"
+      "ld4         {v0.8b,v1.8b,v2.8b,v3.8b}, [%0], #32 \n"  // src line 0
+      "subs        %w2, %w2, #8                  \n"  // 8 processed per loop
+      "prfm        pldl1keep, [%0, 448]          \n"  // prefetch 7 lines ahead
+      "st1         {v2.8b}, [%1], #8             \n"
+      "b.gt        1b                            \n"
+      : "+r"(src_ptr),   // %0
+        "+r"(dst_ptr),   // %1
+        "+r"(dst_width)  // %2
+      :
+      : "v0", "v1", "v2", "v3", "memory", "cc");
+}
+
+void ScaleRowDown4Box_NEON(const uint8_t* src_ptr,
+                           ptrdiff_t src_stride,
+                           uint8_t* dst_ptr,
+                           int dst_width) {
+  const uint8_t* src_ptr1 = src_ptr + src_stride;
+  const uint8_t* src_ptr2 = src_ptr + src_stride * 2;
+  const uint8_t* src_ptr3 = src_ptr + src_stride * 3;
+  asm volatile(
+      "1:                                        \n"
+      "ld1         {v0.16b}, [%0], #16           \n"  // load up 16x4
+      "ld1         {v1.16b}, [%2], #16           \n"
+      "ld1         {v2.16b}, [%3], #16           \n"
+      "ld1         {v3.16b}, [%4], #16           \n"
+      "subs        %w5, %w5, #4                  \n"
+      "uaddlp      v0.8h, v0.16b                 \n"
+      "prfm        pldl1keep, [%0, 448]          \n"  // prefetch 7 lines ahead
+      "uadalp      v0.8h, v1.16b                 \n"
+      "prfm        pldl1keep, [%2, 448]          \n"
+      "uadalp      v0.8h, v2.16b                 \n"
+      "prfm        pldl1keep, [%3, 448]          \n"
+      "uadalp      v0.8h, v3.16b                 \n"
+      "prfm        pldl1keep, [%4, 448]          \n"
+      "addp        v0.8h, v0.8h, v0.8h           \n"
+      "rshrn       v0.8b, v0.8h, #4              \n"  // divide by 16 w/rounding
+      "st1         {v0.s}[0], [%1], #4           \n"
+      "b.gt        1b                            \n"
+      : "+r"(src_ptr),   // %0
+        "+r"(dst_ptr),   // %1
+        "+r"(src_ptr1),  // %2
+        "+r"(src_ptr2),  // %3
+        "+r"(src_ptr3),  // %4
+        "+r"(dst_width)  // %5
+      :
+      : "v0", "v1", "v2", "v3", "memory", "cc");
+}
+
+// Down scale from 4 to 3 pixels. Use the neon multilane read/write
+// to load up the every 4th pixel into a 4 different registers.
+// Point samples 32 pixels to 24 pixels.
+void ScaleRowDown34_NEON(const uint8_t* src_ptr,
+                         ptrdiff_t src_stride,
+                         uint8_t* dst_ptr,
+                         int dst_width) {
+  (void)src_stride;
+  asm volatile(
+      "1:                                        \n"
+      "ld4         {v0.8b,v1.8b,v2.8b,v3.8b}, [%0], #32 \n"  // src line 0
+      "subs        %w2, %w2, #24                 \n"
+      "orr         v2.16b, v3.16b, v3.16b        \n"  // order v0,v1,v2
+      "prfm        pldl1keep, [%0, 448]          \n"  // prefetch 7 lines ahead
+      "st3         {v0.8b,v1.8b,v2.8b}, [%1], #24 \n"
+      "b.gt        1b                            \n"
+      : "+r"(src_ptr),   // %0
+        "+r"(dst_ptr),   // %1
+        "+r"(dst_width)  // %2
+      :
+      : "v0", "v1", "v2", "v3", "memory", "cc");
+}
+
+void ScaleRowDown34_0_Box_NEON(const uint8_t* src_ptr,
+                               ptrdiff_t src_stride,
+                               uint8_t* dst_ptr,
+                               int dst_width) {
+  asm volatile(
+      "movi        v20.8b, #3                    \n"
+      "add         %3, %3, %0                    \n"
+      "1:                                        \n"
+      "ld4         {v0.8b,v1.8b,v2.8b,v3.8b}, [%0], #32 \n"  // src line 0
+      "ld4         {v4.8b,v5.8b,v6.8b,v7.8b}, [%3], #32 \n"  // src line 1
+      "subs        %w2, %w2, #24                 \n"
+
+      // filter src line 0 with src line 1
+      // expand chars to shorts to allow for room
+      // when adding lines together
+      "ushll       v16.8h, v4.8b, #0             \n"
+      "ushll       v17.8h, v5.8b, #0             \n"
+      "ushll       v18.8h, v6.8b, #0             \n"
+      "ushll       v19.8h, v7.8b, #0             \n"
+
+      // 3 * line_0 + line_1
+      "umlal       v16.8h, v0.8b, v20.8b         \n"
+      "umlal       v17.8h, v1.8b, v20.8b         \n"
+      "umlal       v18.8h, v2.8b, v20.8b         \n"
+      "umlal       v19.8h, v3.8b, v20.8b         \n"
+      "prfm        pldl1keep, [%0, 448]          \n"  // prefetch 7 lines ahead
+
+      // (3 * line_0 + line_1 + 2) >> 2
+      "uqrshrn     v0.8b, v16.8h, #2             \n"
+      "uqrshrn     v1.8b, v17.8h, #2             \n"
+      "uqrshrn     v2.8b, v18.8h, #2             \n"
+      "uqrshrn     v3.8b, v19.8h, #2             \n"
+      "prfm        pldl1keep, [%3, 448]          \n"
+
+      // a0 = (src[0] * 3 + s[1] * 1 + 2) >> 2
+      "ushll       v16.8h, v1.8b, #0             \n"
+      "umlal       v16.8h, v0.8b, v20.8b         \n"
+      "uqrshrn     v0.8b, v16.8h, #2             \n"
+
+      // a1 = (src[1] * 1 + s[2] * 1 + 1) >> 1
+      "urhadd      v1.8b, v1.8b, v2.8b           \n"
+
+      // a2 = (src[2] * 1 + s[3] * 3 + 2) >> 2
+      "ushll       v16.8h, v2.8b, #0             \n"
+      "umlal       v16.8h, v3.8b, v20.8b         \n"
+      "uqrshrn     v2.8b, v16.8h, #2             \n"
+
+      "st3         {v0.8b,v1.8b,v2.8b}, [%1], #24 \n"
+
+      "b.gt        1b                            \n"
+      : "+r"(src_ptr),    // %0
+        "+r"(dst_ptr),    // %1
+        "+r"(dst_width),  // %2
+        "+r"(src_stride)  // %3
+      :
+      : "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7", "v16", "v17", "v18",
+        "v19", "v20", "memory", "cc");
+}
+
+void ScaleRowDown34_1_Box_NEON(const uint8_t* src_ptr,
+                               ptrdiff_t src_stride,
+                               uint8_t* dst_ptr,
+                               int dst_width) {
+  asm volatile(
+      "movi        v20.8b, #3                    \n"
+      "add         %3, %3, %0                    \n"
+      "1:                                        \n"
+      "ld4         {v0.8b,v1.8b,v2.8b,v3.8b}, [%0], #32 \n"  // src line 0
+      "ld4         {v4.8b,v5.8b,v6.8b,v7.8b}, [%3], #32 \n"  // src line 1
+      "subs        %w2, %w2, #24                 \n"
+      // average src line 0 with src line 1
+      "urhadd      v0.8b, v0.8b, v4.8b           \n"
+      "urhadd      v1.8b, v1.8b, v5.8b           \n"
+      "urhadd      v2.8b, v2.8b, v6.8b           \n"
+      "urhadd      v3.8b, v3.8b, v7.8b           \n"
+      "prfm        pldl1keep, [%0, 448]          \n"  // prefetch 7 lines ahead
+
+      // a0 = (src[0] * 3 + s[1] * 1 + 2) >> 2
+      "ushll       v4.8h, v1.8b, #0              \n"
+      "umlal       v4.8h, v0.8b, v20.8b          \n"
+      "uqrshrn     v0.8b, v4.8h, #2              \n"
+      "prfm        pldl1keep, [%3, 448]          \n"
+
+      // a1 = (src[1] * 1 + s[2] * 1 + 1) >> 1
+      "urhadd      v1.8b, v1.8b, v2.8b           \n"
+
+      // a2 = (src[2] * 1 + s[3] * 3 + 2) >> 2
+      "ushll       v4.8h, v2.8b, #0              \n"
+      "umlal       v4.8h, v3.8b, v20.8b          \n"
+      "uqrshrn     v2.8b, v4.8h, #2              \n"
+
+      "st3         {v0.8b,v1.8b,v2.8b}, [%1], #24 \n"
+      "b.gt        1b                            \n"
+      : "+r"(src_ptr),    // %0
+        "+r"(dst_ptr),    // %1
+        "+r"(dst_width),  // %2
+        "+r"(src_stride)  // %3
+      :
+      : "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7", "v20", "memory", "cc");
+}
+
+static const uvec8 kShuf38 = {0,  3,  6,  8,  11, 14, 16, 19,
+                              22, 24, 27, 30, 0,  0,  0,  0};
+static const uvec8 kShuf38_2 = {0,  16, 32, 2,  18, 33, 4, 20,
+                                34, 6,  22, 35, 0,  0,  0, 0};
+static const vec16 kMult38_Div6 = {65536 / 12, 65536 / 12, 65536 / 12,
+                                   65536 / 12, 65536 / 12, 65536 / 12,
+                                   65536 / 12, 65536 / 12};
+static const vec16 kMult38_Div9 = {65536 / 18, 65536 / 18, 65536 / 18,
+                                   65536 / 18, 65536 / 18, 65536 / 18,
+                                   65536 / 18, 65536 / 18};
+
+// 32 -> 12
+void ScaleRowDown38_NEON(const uint8_t* src_ptr,
+                         ptrdiff_t src_stride,
+                         uint8_t* dst_ptr,
+                         int dst_width) {
+  (void)src_stride;
+  asm volatile(
+      "ld1         {v3.16b}, [%3]                \n"
+      "1:                                        \n"
+      "ld1         {v0.16b,v1.16b}, [%0], #32    \n"
+      "subs        %w2, %w2, #12                 \n"
+      "tbl         v2.16b, {v0.16b,v1.16b}, v3.16b \n"
+      "prfm        pldl1keep, [%0, 448]          \n"  // prefetch 7 lines ahead
+      "st1         {v2.8b}, [%1], #8             \n"
+      "st1         {v2.s}[2], [%1], #4           \n"
+      "b.gt        1b                            \n"
+      : "+r"(src_ptr),   // %0
+        "+r"(dst_ptr),   // %1
+        "+r"(dst_width)  // %2
+      : "r"(&kShuf38)    // %3
+      : "v0", "v1", "v2", "v3", "memory", "cc");
+}
+
+// 32x3 -> 12x1
+void OMITFP ScaleRowDown38_3_Box_NEON(const uint8_t* src_ptr,
+                                      ptrdiff_t src_stride,
+                                      uint8_t* dst_ptr,
+                                      int dst_width) {
+  const uint8_t* src_ptr1 = src_ptr + src_stride * 2;
+  ptrdiff_t tmp_src_stride = src_stride;
+
+  asm volatile(
+      "ld1         {v29.8h}, [%5]                \n"
+      "ld1         {v30.16b}, [%6]               \n"
+      "ld1         {v31.8h}, [%7]                \n"
+      "add         %2, %2, %0                    \n"
+      "1:                                        \n"
+
+      // 00 40 01 41 02 42 03 43
+      // 10 50 11 51 12 52 13 53
+      // 20 60 21 61 22 62 23 63
+      // 30 70 31 71 32 72 33 73
+      "ld4         {v0.8b,v1.8b,v2.8b,v3.8b}, [%0], #32 \n"
+      "ld4         {v4.8b,v5.8b,v6.8b,v7.8b}, [%2], #32 \n"
+      "ld4         {v16.8b,v17.8b,v18.8b,v19.8b}, [%3], #32 \n"
+      "subs        %w4, %w4, #12                 \n"
+
+      // Shuffle the input data around to get align the data
+      //  so adjacent data can be added. 0,1 - 2,3 - 4,5 - 6,7
+      // 00 10 01 11 02 12 03 13
+      // 40 50 41 51 42 52 43 53
+      "trn1        v20.8b, v0.8b, v1.8b          \n"
+      "trn2        v21.8b, v0.8b, v1.8b          \n"
+      "trn1        v22.8b, v4.8b, v5.8b          \n"
+      "trn2        v23.8b, v4.8b, v5.8b          \n"
+      "trn1        v24.8b, v16.8b, v17.8b        \n"
+      "trn2        v25.8b, v16.8b, v17.8b        \n"
+
+      // 20 30 21 31 22 32 23 33
+      // 60 70 61 71 62 72 63 73
+      "trn1        v0.8b, v2.8b, v3.8b           \n"
+      "trn2        v1.8b, v2.8b, v3.8b           \n"
+      "trn1        v4.8b, v6.8b, v7.8b           \n"
+      "trn2        v5.8b, v6.8b, v7.8b           \n"
+      "trn1        v16.8b, v18.8b, v19.8b        \n"
+      "trn2        v17.8b, v18.8b, v19.8b        \n"
+
+      // 00+10 01+11 02+12 03+13
+      // 40+50 41+51 42+52 43+53
+      "uaddlp      v20.4h, v20.8b                \n"
+      "uaddlp      v21.4h, v21.8b                \n"
+      "uaddlp      v22.4h, v22.8b                \n"
+      "uaddlp      v23.4h, v23.8b                \n"
+      "uaddlp      v24.4h, v24.8b                \n"
+      "uaddlp      v25.4h, v25.8b                \n"
+
+      // 60+70 61+71 62+72 63+73
+      "uaddlp      v1.4h, v1.8b                  \n"
+      "uaddlp      v5.4h, v5.8b                  \n"
+      "uaddlp      v17.4h, v17.8b                \n"
+
+      // combine source lines
+      "add         v20.4h, v20.4h, v22.4h        \n"
+      "add         v21.4h, v21.4h, v23.4h        \n"
+      "add         v20.4h, v20.4h, v24.4h        \n"
+      "add         v21.4h, v21.4h, v25.4h        \n"
+      "add         v2.4h, v1.4h, v5.4h           \n"
+      "add         v2.4h, v2.4h, v17.4h          \n"
+
+      // dst_ptr[3] = (s[6 + st * 0] + s[7 + st * 0]
+      //             + s[6 + st * 1] + s[7 + st * 1]
+      //             + s[6 + st * 2] + s[7 + st * 2]) / 6
+      "sqrdmulh    v2.8h, v2.8h, v29.8h          \n"
+      "xtn         v2.8b,  v2.8h                 \n"
+
+      // Shuffle 2,3 reg around so that 2 can be added to the
+      //  0,1 reg and 3 can be added to the 4,5 reg. This
+      //  requires expanding from u8 to u16 as the 0,1 and 4,5
+      //  registers are already expanded. Then do transposes
+      //  to get aligned.
+      // xx 20 xx 30 xx 21 xx 31 xx 22 xx 32 xx 23 xx 33
+      "ushll       v16.8h, v16.8b, #0            \n"
+      "uaddl       v0.8h, v0.8b, v4.8b           \n"
+
+      // combine source lines
+      "add         v0.8h, v0.8h, v16.8h          \n"
+
+      // xx 20 xx 21 xx 22 xx 23
+      // xx 30 xx 31 xx 32 xx 33
+      "trn1        v1.8h, v0.8h, v0.8h           \n"
+      "trn2        v4.8h, v0.8h, v0.8h           \n"
+      "xtn         v0.4h, v1.4s                  \n"
+      "xtn         v4.4h, v4.4s                  \n"
+      "prfm        pldl1keep, [%0, 448]          \n"  // prefetch 7 lines ahead
+
+      // 0+1+2, 3+4+5
+      "add         v20.8h, v20.8h, v0.8h         \n"
+      "add         v21.8h, v21.8h, v4.8h         \n"
+      "prfm        pldl1keep, [%2, 448]          \n"
+
+      // Need to divide, but can't downshift as the the value
+      //  isn't a power of 2. So multiply by 65536 / n
+      //  and take the upper 16 bits.
+      "sqrdmulh    v0.8h, v20.8h, v31.8h         \n"
+      "sqrdmulh    v1.8h, v21.8h, v31.8h         \n"
+      "prfm        pldl1keep, [%3, 448]          \n"
+
+      // Align for table lookup, vtbl requires registers to be adjacent
+      "tbl         v3.16b, {v0.16b, v1.16b, v2.16b}, v30.16b \n"
+
+      "st1         {v3.8b}, [%1], #8             \n"
+      "st1         {v3.s}[2], [%1], #4           \n"
+      "b.gt        1b                            \n"
+      : "+r"(src_ptr),         // %0
+        "+r"(dst_ptr),         // %1
+        "+r"(tmp_src_stride),  // %2
+        "+r"(src_ptr1),        // %3
+        "+r"(dst_width)        // %4
+      : "r"(&kMult38_Div6),    // %5
+        "r"(&kShuf38_2),       // %6
+        "r"(&kMult38_Div9)     // %7
+      : "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7", "v16", "v17", "v18",
+        "v19", "v20", "v21", "v22", "v23", "v24", "v25", "v29", "v30", "v31",
+        "memory", "cc");
+}
+
+// 32x2 -> 12x1
+void ScaleRowDown38_2_Box_NEON(const uint8_t* src_ptr,
+                               ptrdiff_t src_stride,
+                               uint8_t* dst_ptr,
+                               int dst_width) {
+  // TODO(fbarchard): use src_stride directly for clang 3.5+.
+  ptrdiff_t tmp_src_stride = src_stride;
+  asm volatile(
+      "ld1         {v30.8h}, [%4]                \n"
+      "ld1         {v31.16b}, [%5]               \n"
+      "add         %2, %2, %0                    \n"
+      "1:                                        \n"
+
+      // 00 40 01 41 02 42 03 43
+      // 10 50 11 51 12 52 13 53
+      // 20 60 21 61 22 62 23 63
+      // 30 70 31 71 32 72 33 73
+      "ld4         {v0.8b,v1.8b,v2.8b,v3.8b}, [%0], #32 \n"
+      "ld4         {v4.8b,v5.8b,v6.8b,v7.8b}, [%2], #32 \n"
+      "subs        %w3, %w3, #12                 \n"
+
+      // Shuffle the input data around to get align the data
+      //  so adjacent data can be added. 0,1 - 2,3 - 4,5 - 6,7
+      // 00 10 01 11 02 12 03 13
+      // 40 50 41 51 42 52 43 53
+      "trn1        v16.8b, v0.8b, v1.8b          \n"
+      "trn2        v17.8b, v0.8b, v1.8b          \n"
+      "trn1        v18.8b, v4.8b, v5.8b          \n"
+      "trn2        v19.8b, v4.8b, v5.8b          \n"
+
+      // 20 30 21 31 22 32 23 33
+      // 60 70 61 71 62 72 63 73
+      "trn1        v0.8b, v2.8b, v3.8b           \n"
+      "trn2        v1.8b, v2.8b, v3.8b           \n"
+      "trn1        v4.8b, v6.8b, v7.8b           \n"
+      "trn2        v5.8b, v6.8b, v7.8b           \n"
+
+      // 00+10 01+11 02+12 03+13
+      // 40+50 41+51 42+52 43+53
+      "uaddlp      v16.4h, v16.8b                \n"
+      "uaddlp      v17.4h, v17.8b                \n"
+      "uaddlp      v18.4h, v18.8b                \n"
+      "uaddlp      v19.4h, v19.8b                \n"
+
+      // 60+70 61+71 62+72 63+73
+      "uaddlp      v1.4h, v1.8b                  \n"
+      "uaddlp      v5.4h, v5.8b                  \n"
+
+      // combine source lines
+      "add         v16.4h, v16.4h, v18.4h        \n"
+      "add         v17.4h, v17.4h, v19.4h        \n"
+      "add         v2.4h, v1.4h, v5.4h           \n"
+
+      // dst_ptr[3] = (s[6] + s[7] + s[6+st] + s[7+st]) / 4
+      "uqrshrn     v2.8b, v2.8h, #2              \n"
+
+      // Shuffle 2,3 reg around so that 2 can be added to the
+      //  0,1 reg and 3 can be added to the 4,5 reg. This
+      //  requires expanding from u8 to u16 as the 0,1 and 4,5
+      //  registers are already expanded. Then do transposes
+      //  to get aligned.
+      // xx 20 xx 30 xx 21 xx 31 xx 22 xx 32 xx 23 xx 33
+
+      // combine source lines
+      "uaddl       v0.8h, v0.8b, v4.8b           \n"
+
+      // xx 20 xx 21 xx 22 xx 23
+      // xx 30 xx 31 xx 32 xx 33
+      "trn1        v1.8h, v0.8h, v0.8h           \n"
+      "trn2        v4.8h, v0.8h, v0.8h           \n"
+      "xtn         v0.4h, v1.4s                  \n"
+      "xtn         v4.4h, v4.4s                  \n"
+      "prfm        pldl1keep, [%0, 448]          \n"  // prefetch 7 lines ahead
+
+      // 0+1+2, 3+4+5
+      "add         v16.8h, v16.8h, v0.8h         \n"
+      "add         v17.8h, v17.8h, v4.8h         \n"
+      "prfm        pldl1keep, [%2, 448]          \n"
+
+      // Need to divide, but can't downshift as the the value
+      //  isn't a power of 2. So multiply by 65536 / n
+      //  and take the upper 16 bits.
+      "sqrdmulh    v0.8h, v16.8h, v30.8h         \n"
+      "sqrdmulh    v1.8h, v17.8h, v30.8h         \n"
+
+      // Align for table lookup, vtbl requires registers to
+      //  be adjacent
+
+      "tbl         v3.16b, {v0.16b, v1.16b, v2.16b}, v31.16b \n"
+
+      "st1         {v3.8b}, [%1], #8             \n"
+      "st1         {v3.s}[2], [%1], #4           \n"
+      "b.gt        1b                            \n"
+      : "+r"(src_ptr),         // %0
+        "+r"(dst_ptr),         // %1
+        "+r"(tmp_src_stride),  // %2
+        "+r"(dst_width)        // %3
+      : "r"(&kMult38_Div6),    // %4
+        "r"(&kShuf38_2)        // %5
+      : "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7", "v16", "v17", "v18",
+        "v19", "v30", "v31", "memory", "cc");
+}
+
+void ScaleRowUp2_Linear_NEON(const uint8_t* src_ptr,
+                             uint8_t* dst_ptr,
+                             int dst_width) {
+  const uint8_t* src_temp = src_ptr + 1;
+  asm volatile(
+      "movi        v31.8b, #3                    \n"
+
+      "1:                                        \n"
+      "ldr         d0, [%0], #8                  \n"  // 01234567
+      "ldr         d1, [%1], #8                  \n"  // 12345678
+      "prfm        pldl1keep, [%0, 448]          \n"  // prefetch 7 lines ahead
+
+      "ushll       v2.8h, v0.8b, #0              \n"  // 01234567 (16b)
+      "ushll       v3.8h, v1.8b, #0              \n"  // 12345678 (16b)
+
+      "umlal       v2.8h, v1.8b, v31.8b          \n"  // 3*near+far (odd)
+      "umlal       v3.8h, v0.8b, v31.8b          \n"  // 3*near+far (even)
+
+      "rshrn       v2.8b, v2.8h, #2              \n"  // 3/4*near+1/4*far (odd)
+      "rshrn       v1.8b, v3.8h, #2              \n"  // 3/4*near+1/4*far (even)
+
+      "st2         {v1.8b, v2.8b}, [%2], #16     \n"  // store
+      "subs        %w3, %w3, #16                 \n"  // 8 sample -> 16 sample
+      "b.gt        1b                            \n"
+      : "+r"(src_ptr),   // %0
+        "+r"(src_temp),  // %1
+        "+r"(dst_ptr),   // %2
+        "+r"(dst_width)  // %3
+      :
+      : "memory", "cc", "v0", "v1", "v2", "v3", "v31"  // Clobber List
+  );
+}
+
+void ScaleRowUp2_Bilinear_NEON(const uint8_t* src_ptr,
+                               ptrdiff_t src_stride,
+                               uint8_t* dst_ptr,
+                               ptrdiff_t dst_stride,
+                               int dst_width) {
+  const uint8_t* src_ptr1 = src_ptr + src_stride;
+  uint8_t* dst_ptr1 = dst_ptr + dst_stride;
+  const uint8_t* src_temp = src_ptr + 1;
+  const uint8_t* src_temp1 = src_ptr1 + 1;
+
+  asm volatile(
+      "movi        v31.8b, #3                    \n"
+      "movi        v30.8h, #3                    \n"
+
+      "1:                                        \n"
+      "ldr         d0, [%0], #8                  \n"  // 01234567
+      "ldr         d1, [%2], #8                  \n"  // 12345678
+      "prfm        pldl1keep, [%0, 448]          \n"  // prefetch 7 lines ahead
+
+      "ushll       v2.8h, v0.8b, #0              \n"  // 01234567 (16b)
+      "ushll       v3.8h, v1.8b, #0              \n"  // 12345678 (16b)
+      "umlal       v2.8h, v1.8b, v31.8b          \n"  // 3*near+far (1, odd)
+      "umlal       v3.8h, v0.8b, v31.8b          \n"  // 3*near+far (1, even)
+
+      "ldr         d0, [%1], #8                  \n"
+      "ldr         d1, [%3], #8                  \n"
+      "prfm        pldl1keep, [%1, 448]          \n"  // prefetch 7 lines ahead
+
+      "ushll       v4.8h, v0.8b, #0              \n"  // 01234567 (16b)
+      "ushll       v5.8h, v1.8b, #0              \n"  // 12345678 (16b)
+      "umlal       v4.8h, v1.8b, v31.8b          \n"  // 3*near+far (2, odd)
+      "umlal       v5.8h, v0.8b, v31.8b          \n"  // 3*near+far (2, even)
+
+      "mov         v0.16b, v4.16b                \n"
+      "mov         v1.16b, v5.16b                \n"
+      "mla         v4.8h, v2.8h, v30.8h          \n"  // 9 3 3 1 (1, odd)
+      "mla         v5.8h, v3.8h, v30.8h          \n"  // 9 3 3 1 (1, even)
+      "mla         v2.8h, v0.8h, v30.8h          \n"  // 9 3 3 1 (2, odd)
+      "mla         v3.8h, v1.8h, v30.8h          \n"  // 9 3 3 1 (2, even)
+
+      "rshrn       v2.8b, v2.8h, #4              \n"  // 2, odd
+      "rshrn       v1.8b, v3.8h, #4              \n"  // 2, even
+      "rshrn       v4.8b, v4.8h, #4              \n"  // 1, odd
+      "rshrn       v3.8b, v5.8h, #4              \n"  // 1, even
+
+      "st2         {v1.8b, v2.8b}, [%5], #16     \n"  // store 1
+      "st2         {v3.8b, v4.8b}, [%4], #16     \n"  // store 2
+      "subs        %w6, %w6, #16                 \n"  // 8 sample -> 16 sample
+      "b.gt        1b                            \n"
+      : "+r"(src_ptr),    // %0
+        "+r"(src_ptr1),   // %1
+        "+r"(src_temp),   // %2
+        "+r"(src_temp1),  // %3
+        "+r"(dst_ptr),    // %4
+        "+r"(dst_ptr1),   // %5
+        "+r"(dst_width)   // %6
+      :
+      : "memory", "cc", "v0", "v1", "v2", "v3", "v4", "v5", "v30",
+        "v31"  // Clobber List
+  );
+}
+
+void ScaleRowUp2_Linear_12_NEON(const uint16_t* src_ptr,
+                                uint16_t* dst_ptr,
+                                int dst_width) {
+  const uint16_t* src_temp = src_ptr + 1;
+  asm volatile(
+      "movi        v31.8h, #3                    \n"
+
+      "1:                                        \n"
+      "ld1         {v0.8h}, [%0], #16            \n"  // 01234567 (16b)
+      "ld1         {v1.8h}, [%1], #16            \n"  // 12345678 (16b)
+      "prfm        pldl1keep, [%0, 448]          \n"  // prefetch 7 lines ahead
+
+      "mov         v2.16b, v0.16b                \n"
+      "mla         v0.8h, v1.8h, v31.8h          \n"  // 3*near+far (odd)
+      "mla         v1.8h, v2.8h, v31.8h          \n"  // 3*near+far (even)
+
+      "urshr       v2.8h, v0.8h, #2              \n"  // 3/4*near+1/4*far (odd)
+      "urshr       v1.8h, v1.8h, #2              \n"  // 3/4*near+1/4*far (even)
+
+      "st2         {v1.8h, v2.8h}, [%2], #32     \n"  // store
+      "subs        %w3, %w3, #16                 \n"  // 8 sample -> 16 sample
+      "b.gt        1b                            \n"
+      : "+r"(src_ptr),   // %0
+        "+r"(src_temp),  // %1
+        "+r"(dst_ptr),   // %2
+        "+r"(dst_width)  // %3
+      :
+      : "memory", "cc", "v0", "v1", "v2", "v31"  // Clobber List
+  );
+}
+
+void ScaleRowUp2_Bilinear_12_NEON(const uint16_t* src_ptr,
+                                  ptrdiff_t src_stride,
+                                  uint16_t* dst_ptr,
+                                  ptrdiff_t dst_stride,
+                                  int dst_width) {
+  const uint16_t* src_ptr1 = src_ptr + src_stride;
+  uint16_t* dst_ptr1 = dst_ptr + dst_stride;
+  const uint16_t* src_temp = src_ptr + 1;
+  const uint16_t* src_temp1 = src_ptr1 + 1;
+
+  asm volatile(
+      "movi        v31.8h, #3                    \n"
+
+      "1:                                        \n"
+      "ld1         {v2.8h}, [%0], #16            \n"  // 01234567 (16b)
+      "ld1         {v3.8h}, [%2], #16            \n"  // 12345678 (16b)
+      "prfm        pldl1keep, [%0, 448]          \n"  // prefetch 7 lines ahead
+
+      "mov         v0.16b, v2.16b                \n"
+      "mla         v2.8h, v3.8h, v31.8h          \n"  // 3*near+far (odd)
+      "mla         v3.8h, v0.8h, v31.8h          \n"  // 3*near+far (even)
+
+      "ld1         {v4.8h}, [%1], #16            \n"  // 01234567 (16b)
+      "ld1         {v5.8h}, [%3], #16            \n"  // 12345678 (16b)
+      "prfm        pldl1keep, [%1, 448]          \n"  // prefetch 7 lines ahead
+
+      "mov         v0.16b, v4.16b                \n"
+      "mla         v4.8h, v5.8h, v31.8h          \n"  // 3*near+far (odd)
+      "mla         v5.8h, v0.8h, v31.8h          \n"  // 3*near+far (even)
+
+      "mov         v0.16b, v4.16b                \n"
+      "mov         v1.16b, v5.16b                \n"
+      "mla         v4.8h, v2.8h, v31.8h          \n"  // 9 3 3 1 (1, odd)
+      "mla         v5.8h, v3.8h, v31.8h          \n"  // 9 3 3 1 (1, even)
+      "mla         v2.8h, v0.8h, v31.8h          \n"  // 9 3 3 1 (2, odd)
+      "mla         v3.8h, v1.8h, v31.8h          \n"  // 9 3 3 1 (2, even)
+
+      "urshr       v2.8h, v2.8h, #4              \n"  // 2, odd
+      "urshr       v1.8h, v3.8h, #4              \n"  // 2, even
+      "urshr       v4.8h, v4.8h, #4              \n"  // 1, odd
+      "urshr       v3.8h, v5.8h, #4              \n"  // 1, even
+
+      "st2         {v3.8h, v4.8h}, [%4], #32     \n"  // store 1
+      "st2         {v1.8h, v2.8h}, [%5], #32     \n"  // store 2
+
+      "subs        %w6, %w6, #16                 \n"  // 8 sample -> 16 sample
+      "b.gt        1b                            \n"
+      : "+r"(src_ptr),    // %0
+        "+r"(src_ptr1),   // %1
+        "+r"(src_temp),   // %2
+        "+r"(src_temp1),  // %3
+        "+r"(dst_ptr),    // %4
+        "+r"(dst_ptr1),   // %5
+        "+r"(dst_width)   // %6
+      :
+      : "memory", "cc", "v0", "v1", "v2", "v3", "v4", "v5",
+        "v31"  // Clobber List
+  );
+}
+
+void ScaleRowUp2_Linear_16_NEON(const uint16_t* src_ptr,
+                                uint16_t* dst_ptr,
+                                int dst_width) {
+  const uint16_t* src_temp = src_ptr + 1;
+  asm volatile(
+      "movi        v31.8h, #3                    \n"
+
+      "1:                                        \n"
+      "ld1         {v0.8h}, [%0], #16            \n"  // 01234567 (16b)
+      "ld1         {v1.8h}, [%1], #16            \n"  // 12345678 (16b)
+      "prfm        pldl1keep, [%0, 448]          \n"  // prefetch 7 lines ahead
+
+      "ushll       v2.4s, v0.4h, #0              \n"  // 0123 (32b)
+      "ushll2      v3.4s, v0.8h, #0              \n"  // 4567 (32b)
+      "ushll       v4.4s, v1.4h, #0              \n"  // 1234 (32b)
+      "ushll2      v5.4s, v1.8h, #0              \n"  // 5678 (32b)
+
+      "umlal       v2.4s, v1.4h, v31.4h          \n"  // 3*near+far (1, odd)
+      "umlal2      v3.4s, v1.8h, v31.8h          \n"  // 3*near+far (2, odd)
+      "umlal       v4.4s, v0.4h, v31.4h          \n"  // 3*near+far (1, even)
+      "umlal2      v5.4s, v0.8h, v31.8h          \n"  // 3*near+far (2, even)
+
+      "rshrn       v0.4h, v4.4s, #2              \n"  // 3/4*near+1/4*far
+      "rshrn2      v0.8h, v5.4s, #2              \n"  // 3/4*near+1/4*far (even)
+      "rshrn       v1.4h, v2.4s, #2              \n"  // 3/4*near+1/4*far
+      "rshrn2      v1.8h, v3.4s, #2              \n"  // 3/4*near+1/4*far (odd)
+
+      "st2         {v0.8h, v1.8h}, [%2], #32     \n"  // store
+      "subs        %w3, %w3, #16                 \n"  // 8 sample -> 16 sample
+      "b.gt        1b                            \n"
+      : "+r"(src_ptr),   // %0
+        "+r"(src_temp),  // %1
+        "+r"(dst_ptr),   // %2
+        "+r"(dst_width)  // %3
+      :
+      : "memory", "cc", "v0", "v1", "v2", "v31"  // Clobber List
+  );
+}
+
+void ScaleRowUp2_Bilinear_16_NEON(const uint16_t* src_ptr,
+                                  ptrdiff_t src_stride,
+                                  uint16_t* dst_ptr,
+                                  ptrdiff_t dst_stride,
+                                  int dst_width) {
+  const uint16_t* src_ptr1 = src_ptr + src_stride;
+  uint16_t* dst_ptr1 = dst_ptr + dst_stride;
+  const uint16_t* src_temp = src_ptr + 1;
+  const uint16_t* src_temp1 = src_ptr1 + 1;
+
+  asm volatile(
+      "movi        v31.4h, #3                    \n"
+      "movi        v30.4s, #3                    \n"
+
+      "1:                                        \n"
+      "ldr         d0, [%0], #8                  \n"  // 0123 (16b)
+      "ldr         d1, [%2], #8                  \n"  // 1234 (16b)
+      "prfm        pldl1keep, [%0, 448]          \n"  // prefetch 7 lines ahead
+      "ushll       v2.4s, v0.4h, #0              \n"  // 0123 (32b)
+      "ushll       v3.4s, v1.4h, #0              \n"  // 1234 (32b)
+      "umlal       v2.4s, v1.4h, v31.4h          \n"  // 3*near+far (1, odd)
+      "umlal       v3.4s, v0.4h, v31.4h          \n"  // 3*near+far (1, even)
+
+      "ldr         d0, [%1], #8                  \n"  // 0123 (16b)
+      "ldr         d1, [%3], #8                  \n"  // 1234 (16b)
+      "prfm        pldl1keep, [%1, 448]          \n"  // prefetch 7 lines ahead
+      "ushll       v4.4s, v0.4h, #0              \n"  // 0123 (32b)
+      "ushll       v5.4s, v1.4h, #0              \n"  // 1234 (32b)
+      "umlal       v4.4s, v1.4h, v31.4h          \n"  // 3*near+far (2, odd)
+      "umlal       v5.4s, v0.4h, v31.4h          \n"  // 3*near+far (2, even)
+
+      "mov         v0.16b, v4.16b                \n"
+      "mov         v1.16b, v5.16b                \n"
+      "mla         v4.4s, v2.4s, v30.4s          \n"  // 9 3 3 1 (1, odd)
+      "mla         v5.4s, v3.4s, v30.4s          \n"  // 9 3 3 1 (1, even)
+      "mla         v2.4s, v0.4s, v30.4s          \n"  // 9 3 3 1 (2, odd)
+      "mla         v3.4s, v1.4s, v30.4s          \n"  // 9 3 3 1 (2, even)
+
+      "rshrn       v1.4h, v4.4s, #4              \n"  // 3/4*near+1/4*far
+      "rshrn       v0.4h, v5.4s, #4              \n"  // 3/4*near+1/4*far
+      "rshrn       v5.4h, v2.4s, #4              \n"  // 3/4*near+1/4*far
+      "rshrn       v4.4h, v3.4s, #4              \n"  // 3/4*near+1/4*far
+
+      "st2         {v0.4h, v1.4h}, [%4], #16     \n"  // store 1
+      "st2         {v4.4h, v5.4h}, [%5], #16     \n"  // store 2
+
+      "subs        %w6, %w6, #8                  \n"  // 4 sample -> 8 sample
+      "b.gt        1b                            \n"
+      : "+r"(src_ptr),    // %0
+        "+r"(src_ptr1),   // %1
+        "+r"(src_temp),   // %2
+        "+r"(src_temp1),  // %3
+        "+r"(dst_ptr),    // %4
+        "+r"(dst_ptr1),   // %5
+        "+r"(dst_width)   // %6
+      :
+      : "memory", "cc", "v0", "v1", "v2", "v3", "v4", "v5", "v30",
+        "v31"  // Clobber List
+  );
+}
+
+void ScaleUVRowUp2_Linear_NEON(const uint8_t* src_ptr,
+                               uint8_t* dst_ptr,
+                               int dst_width) {
+  const uint8_t* src_temp = src_ptr + 2;
+  asm volatile(
+      "movi        v31.8b, #3                    \n"
+
+      "1:                                        \n"
+      "ldr         d0, [%0], #8                  \n"  // 00112233 (1u1v)
+      "ldr         d1, [%1], #8                  \n"  // 11223344 (1u1v)
+      "prfm        pldl1keep, [%0, 448]          \n"  // prefetch 7 lines ahead
+
+      "ushll       v2.8h, v0.8b, #0              \n"  // 00112233 (1u1v, 16b)
+      "ushll       v3.8h, v1.8b, #0              \n"  // 11223344 (1u1v, 16b)
+
+      "umlal       v2.8h, v1.8b, v31.8b          \n"  // 3*near+far (odd)
+      "umlal       v3.8h, v0.8b, v31.8b          \n"  // 3*near+far (even)
+
+      "rshrn       v2.8b, v2.8h, #2              \n"  // 3/4*near+1/4*far (odd)
+      "rshrn       v1.8b, v3.8h, #2              \n"  // 3/4*near+1/4*far (even)
+
+      "st2         {v1.4h, v2.4h}, [%2], #16     \n"  // store
+      "subs        %w3, %w3, #8                  \n"  // 4 uv -> 8 uv
+      "b.gt        1b                            \n"
+      : "+r"(src_ptr),   // %0
+        "+r"(src_temp),  // %1
+        "+r"(dst_ptr),   // %2
+        "+r"(dst_width)  // %3
+      :
+      : "memory", "cc", "v0", "v1", "v2", "v3", "v31"  // Clobber List
+  );
+}
+
+void ScaleUVRowUp2_Bilinear_NEON(const uint8_t* src_ptr,
+                                 ptrdiff_t src_stride,
+                                 uint8_t* dst_ptr,
+                                 ptrdiff_t dst_stride,
+                                 int dst_width) {
+  const uint8_t* src_ptr1 = src_ptr + src_stride;
+  uint8_t* dst_ptr1 = dst_ptr + dst_stride;
+  const uint8_t* src_temp = src_ptr + 2;
+  const uint8_t* src_temp1 = src_ptr1 + 2;
+
+  asm volatile(
+      "movi        v31.8b, #3                    \n"
+      "movi        v30.8h, #3                    \n"
+
+      "1:                                        \n"
+      "ldr         d0, [%0], #8                  \n"
+      "ldr         d1, [%2], #8                  \n"
+      "prfm        pldl1keep, [%0, 448]          \n"  // prefetch 7 lines ahead
+
+      "ushll       v2.8h, v0.8b, #0              \n"
+      "ushll       v3.8h, v1.8b, #0              \n"
+      "umlal       v2.8h, v1.8b, v31.8b          \n"  // 3*near+far (1, odd)
+      "umlal       v3.8h, v0.8b, v31.8b          \n"  // 3*near+far (1, even)
+
+      "ldr         d0, [%1], #8                  \n"
+      "ldr         d1, [%3], #8                  \n"
+      "prfm        pldl1keep, [%1, 448]          \n"  // prefetch 7 lines ahead
+
+      "ushll       v4.8h, v0.8b, #0              \n"
+      "ushll       v5.8h, v1.8b, #0              \n"
+      "umlal       v4.8h, v1.8b, v31.8b          \n"  // 3*near+far (2, odd)
+      "umlal       v5.8h, v0.8b, v31.8b          \n"  // 3*near+far (2, even)
+
+      "mov         v0.16b, v4.16b                \n"
+      "mov         v1.16b, v5.16b                \n"
+      "mla         v4.8h, v2.8h, v30.8h          \n"  // 9 3 3 1 (1, odd)
+      "mla         v5.8h, v3.8h, v30.8h          \n"  // 9 3 3 1 (1, even)
+      "mla         v2.8h, v0.8h, v30.8h          \n"  // 9 3 3 1 (2, odd)
+      "mla         v3.8h, v1.8h, v30.8h          \n"  // 9 3 3 1 (2, even)
+
+      "rshrn       v2.8b, v2.8h, #4              \n"  // 2, odd
+      "rshrn       v1.8b, v3.8h, #4              \n"  // 2, even
+      "rshrn       v4.8b, v4.8h, #4              \n"  // 1, odd
+      "rshrn       v3.8b, v5.8h, #4              \n"  // 1, even
+
+      "st2         {v1.4h, v2.4h}, [%5], #16     \n"  // store 2
+      "st2         {v3.4h, v4.4h}, [%4], #16     \n"  // store 1
+      "subs        %w6, %w6, #8                  \n"  // 4 uv -> 8 uv
+      "b.gt        1b                            \n"
+      : "+r"(src_ptr),    // %0
+        "+r"(src_ptr1),   // %1
+        "+r"(src_temp),   // %2
+        "+r"(src_temp1),  // %3
+        "+r"(dst_ptr),    // %4
+        "+r"(dst_ptr1),   // %5
+        "+r"(dst_width)   // %6
+      :
+      : "memory", "cc", "v0", "v1", "v2", "v3", "v4", "v5", "v30",
+        "v31"  // Clobber List
+  );
+}
+
+void ScaleUVRowUp2_Linear_16_NEON(const uint16_t* src_ptr,
+                                  uint16_t* dst_ptr,
+                                  int dst_width) {
+  const uint16_t* src_temp = src_ptr + 2;
+  asm volatile(
+      "movi        v31.8h, #3                    \n"
+
+      "1:                                        \n"
+      "ld1         {v0.8h}, [%0], #16            \n"  // 01234567 (16b)
+      "ld1         {v1.8h}, [%1], #16            \n"  // 12345678 (16b)
+      "prfm        pldl1keep, [%0, 448]          \n"  // prefetch 7 lines ahead
+
+      "ushll       v2.4s, v0.4h, #0              \n"  // 0011 (1u1v, 32b)
+      "ushll       v3.4s, v1.4h, #0              \n"  // 1122 (1u1v, 32b)
+      "ushll2      v4.4s, v0.8h, #0              \n"  // 2233 (1u1v, 32b)
+      "ushll2      v5.4s, v1.8h, #0              \n"  // 3344 (1u1v, 32b)
+
+      "umlal       v2.4s, v1.4h, v31.4h          \n"  // 3*near+far (odd)
+      "umlal       v3.4s, v0.4h, v31.4h          \n"  // 3*near+far (even)
+      "umlal2      v4.4s, v1.8h, v31.8h          \n"  // 3*near+far (odd)
+      "umlal2      v5.4s, v0.8h, v31.8h          \n"  // 3*near+far (even)
+
+      "rshrn       v2.4h, v2.4s, #2              \n"  // 3/4*near+1/4*far (odd)
+      "rshrn       v1.4h, v3.4s, #2              \n"  // 3/4*near+1/4*far (even)
+      "rshrn       v4.4h, v4.4s, #2              \n"  // 3/4*near+1/4*far (odd)
+      "rshrn       v3.4h, v5.4s, #2              \n"  // 3/4*near+1/4*far (even)
+
+      "st2         {v1.2s, v2.2s}, [%2], #16     \n"  // store
+      "st2         {v3.2s, v4.2s}, [%2], #16     \n"  // store
+      "subs        %w3, %w3, #8                  \n"  // 4 uv -> 8 uv
+      "b.gt        1b                            \n"
+      : "+r"(src_ptr),   // %0
+        "+r"(src_temp),  // %1
+        "+r"(dst_ptr),   // %2
+        "+r"(dst_width)  // %3
+      :
+      : "memory", "cc", "v0", "v1", "v2", "v3", "v4", "v5",
+        "v31"  // Clobber List
+  );
+}
+
+void ScaleUVRowUp2_Bilinear_16_NEON(const uint16_t* src_ptr,
+                                    ptrdiff_t src_stride,
+                                    uint16_t* dst_ptr,
+                                    ptrdiff_t dst_stride,
+                                    int dst_width) {
+  const uint16_t* src_ptr1 = src_ptr + src_stride;
+  uint16_t* dst_ptr1 = dst_ptr + dst_stride;
+  const uint16_t* src_temp = src_ptr + 2;
+  const uint16_t* src_temp1 = src_ptr1 + 2;
+
+  asm volatile(
+      "movi        v31.4h, #3                    \n"
+      "movi        v30.4s, #3                    \n"
+
+      "1:                                        \n"
+      "ldr         d0, [%0], #8                  \n"
+      "ldr         d1, [%2], #8                  \n"
+      "prfm        pldl1keep, [%0, 448]          \n"  // prefetch 7 lines ahead
+      "ushll       v2.4s, v0.4h, #0              \n"  // 0011 (1u1v, 32b)
+      "ushll       v3.4s, v1.4h, #0              \n"  // 1122 (1u1v, 32b)
+      "umlal       v2.4s, v1.4h, v31.4h          \n"  // 3*near+far (1, odd)
+      "umlal       v3.4s, v0.4h, v31.4h          \n"  // 3*near+far (1, even)
+
+      "ldr         d0, [%1], #8                  \n"
+      "ldr         d1, [%3], #8                  \n"
+      "prfm        pldl1keep, [%1, 448]          \n"  // prefetch 7 lines ahead
+      "ushll       v4.4s, v0.4h, #0              \n"  // 0011 (1u1v, 32b)
+      "ushll       v5.4s, v1.4h, #0              \n"  // 1122 (1u1v, 32b)
+      "umlal       v4.4s, v1.4h, v31.4h          \n"  // 3*near+far (2, odd)
+      "umlal       v5.4s, v0.4h, v31.4h          \n"  // 3*near+far (2, even)
+
+      "mov         v0.16b, v4.16b                \n"
+      "mov         v1.16b, v5.16b                \n"
+      "mla         v4.4s, v2.4s, v30.4s          \n"  // 9 3 3 1 (1, odd)
+      "mla         v5.4s, v3.4s, v30.4s          \n"  // 9 3 3 1 (1, even)
+      "mla         v2.4s, v0.4s, v30.4s          \n"  // 9 3 3 1 (2, odd)
+      "mla         v3.4s, v1.4s, v30.4s          \n"  // 9 3 3 1 (2, even)
+
+      "rshrn       v1.4h, v2.4s, #4              \n"  // 2, odd
+      "rshrn       v0.4h, v3.4s, #4              \n"  // 2, even
+      "rshrn       v3.4h, v4.4s, #4              \n"  // 1, odd
+      "rshrn       v2.4h, v5.4s, #4              \n"  // 1, even
+
+      "st2         {v0.2s, v1.2s}, [%5], #16     \n"  // store 2
+      "st2         {v2.2s, v3.2s}, [%4], #16     \n"  // store 1
+      "subs        %w6, %w6, #4                  \n"  // 2 uv -> 4 uv
+      "b.gt        1b                            \n"
+      : "+r"(src_ptr),    // %0
+        "+r"(src_ptr1),   // %1
+        "+r"(src_temp),   // %2
+        "+r"(src_temp1),  // %3
+        "+r"(dst_ptr),    // %4
+        "+r"(dst_ptr1),   // %5
+        "+r"(dst_width)   // %6
+      :
+      : "memory", "cc", "v0", "v1", "v2", "v3", "v4", "v5", "v30",
+        "v31"  // Clobber List
+  );
+}
+
+// Add a row of bytes to a row of shorts.  Used for box filter.
+// Reads 16 bytes and accumulates to 16 shorts at a time.
+void ScaleAddRow_NEON(const uint8_t* src_ptr,
+                      uint16_t* dst_ptr,
+                      int src_width) {
+  asm volatile(
+      "1:                                        \n"
+      "ld1         {v1.8h, v2.8h}, [%1]          \n"  // load accumulator
+      "ld1         {v0.16b}, [%0], #16           \n"  // load 16 bytes
+      "uaddw2      v2.8h, v2.8h, v0.16b          \n"  // add
+      "prfm        pldl1keep, [%0, 448]          \n"  // prefetch 7 lines ahead
+      "uaddw       v1.8h, v1.8h, v0.8b           \n"
+      "st1         {v1.8h, v2.8h}, [%1], #32     \n"  // store accumulator
+      "subs        %w2, %w2, #16                 \n"  // 16 processed per loop
+      "b.gt        1b                            \n"
+      : "+r"(src_ptr),   // %0
+        "+r"(dst_ptr),   // %1
+        "+r"(src_width)  // %2
+      :
+      : "memory", "cc", "v0", "v1", "v2"  // Clobber List
+  );
+}
+
+// TODO(Yang Zhang): Investigate less load instructions for
+// the x/dx stepping
+#define LOAD2_DATA8_LANE(n)                      \
+  "lsr        %5, %3, #16                    \n" \
+  "add        %6, %1, %5                     \n" \
+  "add        %3, %3, %4                     \n" \
+  "ld2        {v4.b, v5.b}[" #n "], [%6]     \n"
+
+// The NEON version mimics this formula (from row_common.cc):
+// #define BLENDER(a, b, f) (uint8_t)((int)(a) +
+//    ((((int)((f)) * ((int)(b) - (int)(a))) + 0x8000) >> 16))
+
+void ScaleFilterCols_NEON(uint8_t* dst_ptr,
+                          const uint8_t* src_ptr,
+                          int dst_width,
+                          int x,
+                          int dx) {
+  int dx_offset[4] = {0, 1, 2, 3};
+  int* tmp = dx_offset;
+  const uint8_t* src_tmp = src_ptr;
+  int64_t x64 = (int64_t)x;    // NOLINT
+  int64_t dx64 = (int64_t)dx;  // NOLINT
+  asm volatile (
+      "dup         v0.4s, %w3                    \n"  // x
+      "dup         v1.4s, %w4                    \n"  // dx
+      "ld1         {v2.4s}, [%5]                 \n"  // 0 1 2 3
+      "shl         v3.4s, v1.4s, #2              \n"  // 4 * dx
+      "mul         v1.4s, v1.4s, v2.4s           \n"
+    // x         , x + 1 * dx, x + 2 * dx, x + 3 * dx
+      "add         v1.4s, v1.4s, v0.4s           \n"
+    // x + 4 * dx, x + 5 * dx, x + 6 * dx, x + 7 * dx
+      "add         v2.4s, v1.4s, v3.4s           \n"
+      "shl         v0.4s, v3.4s, #1              \n"  // 8 * dx
+      "1:                                        \n"
+    LOAD2_DATA8_LANE(0)
+    LOAD2_DATA8_LANE(1)
+    LOAD2_DATA8_LANE(2)
+    LOAD2_DATA8_LANE(3)
+    LOAD2_DATA8_LANE(4)
+    LOAD2_DATA8_LANE(5)
+    LOAD2_DATA8_LANE(6)
+    LOAD2_DATA8_LANE(7)
+      "mov         v6.16b, v1.16b                \n"
+      "mov         v7.16b, v2.16b                \n"
+      "uzp1        v6.8h, v6.8h, v7.8h           \n"
+      "ushll       v4.8h, v4.8b, #0              \n"
+      "ushll       v5.8h, v5.8b, #0              \n"
+      "ssubl       v16.4s, v5.4h, v4.4h          \n"
+      "ssubl2      v17.4s, v5.8h, v4.8h          \n"
+      "ushll       v7.4s, v6.4h, #0              \n"
+      "ushll2      v6.4s, v6.8h, #0              \n"
+      "mul         v16.4s, v16.4s, v7.4s         \n"
+      "mul         v17.4s, v17.4s, v6.4s         \n"
+      "rshrn       v6.4h, v16.4s, #16            \n"
+      "rshrn2      v6.8h, v17.4s, #16            \n"
+      "add         v4.8h, v4.8h, v6.8h           \n"
+      "xtn         v4.8b, v4.8h                  \n"
+
+      "st1         {v4.8b}, [%0], #8             \n"  // store pixels
+      "add         v1.4s, v1.4s, v0.4s           \n"
+      "add         v2.4s, v2.4s, v0.4s           \n"
+      "subs        %w2, %w2, #8                  \n"  // 8 processed per loop
+      "b.gt        1b                            \n"
+  : "+r"(dst_ptr),          // %0
+    "+r"(src_ptr),          // %1
+    "+r"(dst_width),        // %2
+    "+r"(x64),              // %3
+    "+r"(dx64),             // %4
+    "+r"(tmp),              // %5
+    "+r"(src_tmp)           // %6
+  :
+  : "memory", "cc", "v0", "v1", "v2", "v3",
+    "v4", "v5", "v6", "v7", "v16", "v17"
+  );
+}
+
+#undef LOAD2_DATA8_LANE
+
+// 16x2 -> 16x1
+void ScaleFilterRows_NEON(uint8_t* dst_ptr,
+                          const uint8_t* src_ptr,
+                          ptrdiff_t src_stride,
+                          int dst_width,
+                          int source_y_fraction) {
+  int y_fraction = 256 - source_y_fraction;
+  asm volatile(
+      "cmp         %w4, #0                       \n"
+      "b.eq        100f                          \n"
+      "add         %2, %2, %1                    \n"
+      "cmp         %w4, #64                      \n"
+      "b.eq        75f                           \n"
+      "cmp         %w4, #128                     \n"
+      "b.eq        50f                           \n"
+      "cmp         %w4, #192                     \n"
+      "b.eq        25f                           \n"
+
+      "dup         v5.8b, %w4                    \n"
+      "dup         v4.8b, %w5                    \n"
+      // General purpose row blend.
+      "1:                                        \n"
+      "ld1         {v0.16b}, [%1], #16           \n"
+      "ld1         {v1.16b}, [%2], #16           \n"
+      "subs        %w3, %w3, #16                 \n"
+      "umull       v6.8h, v0.8b, v4.8b           \n"
+      "umull2      v7.8h, v0.16b, v4.16b         \n"
+      "prfm        pldl1keep, [%1, 448]          \n"  // prefetch 7 lines ahead
+      "umlal       v6.8h, v1.8b, v5.8b           \n"
+      "umlal2      v7.8h, v1.16b, v5.16b         \n"
+      "prfm        pldl1keep, [%2, 448]          \n"
+      "rshrn       v0.8b, v6.8h, #8              \n"
+      "rshrn2      v0.16b, v7.8h, #8             \n"
+      "st1         {v0.16b}, [%0], #16           \n"
+      "b.gt        1b                            \n"
+      "b           99f                           \n"
+
+      // Blend 25 / 75.
+      "25:                                       \n"
+      "ld1         {v0.16b}, [%1], #16           \n"
+      "ld1         {v1.16b}, [%2], #16           \n"
+      "subs        %w3, %w3, #16                 \n"
+      "urhadd      v0.16b, v0.16b, v1.16b        \n"
+      "prfm        pldl1keep, [%1, 448]          \n"  // prefetch 7 lines ahead
+      "urhadd      v0.16b, v0.16b, v1.16b        \n"
+      "prfm        pldl1keep, [%2, 448]          \n"
+      "st1         {v0.16b}, [%0], #16           \n"
+      "b.gt        25b                           \n"
+      "b           99f                           \n"
+
+      // Blend 50 / 50.
+      "50:                                       \n"
+      "ld1         {v0.16b}, [%1], #16           \n"
+      "ld1         {v1.16b}, [%2], #16           \n"
+      "subs        %w3, %w3, #16                 \n"
+      "prfm        pldl1keep, [%1, 448]          \n"  // prefetch 7 lines ahead
+      "urhadd      v0.16b, v0.16b, v1.16b        \n"
+      "prfm        pldl1keep, [%2, 448]          \n"
+      "st1         {v0.16b}, [%0], #16           \n"
+      "b.gt        50b                           \n"
+      "b           99f                           \n"
+
+      // Blend 75 / 25.
+      "75:                                       \n"
+      "ld1         {v1.16b}, [%1], #16           \n"
+      "ld1         {v0.16b}, [%2], #16           \n"
+      "subs        %w3, %w3, #16                 \n"
+      "urhadd      v0.16b, v0.16b, v1.16b        \n"
+      "prfm        pldl1keep, [%1, 448]          \n"  // prefetch 7 lines ahead
+      "urhadd      v0.16b, v0.16b, v1.16b        \n"
+      "prfm        pldl1keep, [%2, 448]          \n"
+      "st1         {v0.16b}, [%0], #16           \n"
+      "b.gt        75b                           \n"
+      "b           99f                           \n"
+
+      // Blend 100 / 0 - Copy row unchanged.
+      "100:                                      \n"
+      "ld1         {v0.16b}, [%1], #16           \n"
+      "subs        %w3, %w3, #16                 \n"
+      "prfm        pldl1keep, [%1, 448]          \n"  // prefetch 7 lines ahead
+      "st1         {v0.16b}, [%0], #16           \n"
+      "b.gt        100b                          \n"
+
+      "99:                                       \n"
+      "st1         {v0.b}[15], [%0]              \n"
+      : "+r"(dst_ptr),            // %0
+        "+r"(src_ptr),            // %1
+        "+r"(src_stride),         // %2
+        "+r"(dst_width),          // %3
+        "+r"(source_y_fraction),  // %4
+        "+r"(y_fraction)          // %5
+      :
+      : "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7", "memory", "cc");
+}
+
+void ScaleARGBRowDown2_NEON(const uint8_t* src_ptr,
+                            ptrdiff_t src_stride,
+                            uint8_t* dst,
+                            int dst_width) {
+  (void)src_stride;
+  asm volatile(
+      "1:                                        \n"
+      // load 16 ARGB pixels with even pixels into q0/q2, odd into q1/q3
+      "ld4         {v0.4s,v1.4s,v2.4s,v3.4s}, [%0], #64 \n"
+      "subs        %w2, %w2, #8                  \n"  // 8 processed per loop
+      "mov         v2.16b, v3.16b                \n"
+      "prfm        pldl1keep, [%0, 448]          \n"  // prefetch 7 lines ahead
+      "st2         {v1.4s,v2.4s}, [%1], #32      \n"  // store 8 odd pixels
+      "b.gt        1b                            \n"
+      : "+r"(src_ptr),   // %0
+        "+r"(dst),       // %1
+        "+r"(dst_width)  // %2
+      :
+      : "memory", "cc", "v0", "v1", "v2", "v3"  // Clobber List
+  );
+}
+
+void ScaleARGBRowDown2Linear_NEON(const uint8_t* src_argb,
+                                  ptrdiff_t src_stride,
+                                  uint8_t* dst_argb,
+                                  int dst_width) {
+  (void)src_stride;
+  asm volatile(
+      "1:                                        \n"
+      // load 16 ARGB pixels with even pixels into q0/q2, odd into q1/q3
+      "ld4         {v0.4s,v1.4s,v2.4s,v3.4s}, [%0], #64 \n"
+      "subs        %w2, %w2, #8                  \n"  // 8 processed per loop
+
+      "urhadd      v0.16b, v0.16b, v1.16b        \n"  // rounding half add
+      "prfm        pldl1keep, [%0, 448]          \n"  // prefetch 7 lines ahead
+      "urhadd      v1.16b, v2.16b, v3.16b        \n"
+      "st2         {v0.4s,v1.4s}, [%1], #32      \n"  // store 8 pixels
+      "b.gt        1b                            \n"
+      : "+r"(src_argb),  // %0
+        "+r"(dst_argb),  // %1
+        "+r"(dst_width)  // %2
+      :
+      : "memory", "cc", "v0", "v1", "v2", "v3"  // Clobber List
+  );
+}
+
+void ScaleARGBRowDown2Box_NEON(const uint8_t* src_ptr,
+                               ptrdiff_t src_stride,
+                               uint8_t* dst,
+                               int dst_width) {
+  asm volatile(
+      // change the stride to row 2 pointer
+      "add         %1, %1, %0                    \n"
+      "1:                                        \n"
+      "ld4         {v0.16b,v1.16b,v2.16b,v3.16b}, [%0], #64 \n"  // load 16 ARGB
+      "subs        %w3, %w3, #8                  \n"  // 8 processed per loop.
+      "uaddlp      v0.8h, v0.16b                 \n"  // B 16 bytes -> 8 shorts.
+      "uaddlp      v1.8h, v1.16b                 \n"  // G 16 bytes -> 8 shorts.
+      "uaddlp      v2.8h, v2.16b                 \n"  // R 16 bytes -> 8 shorts.
+      "uaddlp      v3.8h, v3.16b                 \n"  // A 16 bytes -> 8 shorts.
+      "ld4         {v16.16b,v17.16b,v18.16b,v19.16b}, [%1], #64 \n"  // load 8
+      "uadalp      v0.8h, v16.16b                \n"  // B 16 bytes -> 8 shorts.
+      "uadalp      v1.8h, v17.16b                \n"  // G 16 bytes -> 8 shorts.
+      "prfm        pldl1keep, [%0, 448]          \n"  // prefetch 7 lines ahead
+      "uadalp      v2.8h, v18.16b                \n"  // R 16 bytes -> 8 shorts.
+      "uadalp      v3.8h, v19.16b                \n"  // A 16 bytes -> 8 shorts.
+      "prfm        pldl1keep, [%1, 448]          \n"
+      "rshrn       v0.8b, v0.8h, #2              \n"  // round and pack
+      "rshrn       v1.8b, v1.8h, #2              \n"
+      "rshrn       v2.8b, v2.8h, #2              \n"
+      "rshrn       v3.8b, v3.8h, #2              \n"
+      "st4         {v0.8b,v1.8b,v2.8b,v3.8b}, [%2], #32 \n"
+      "b.gt        1b                            \n"
+      : "+r"(src_ptr),     // %0
+        "+r"(src_stride),  // %1
+        "+r"(dst),         // %2
+        "+r"(dst_width)    // %3
+      :
+      : "memory", "cc", "v0", "v1", "v2", "v3", "v16", "v17", "v18", "v19");
+}
+
+// Reads 4 pixels at a time.
+// Alignment requirement: src_argb 4 byte aligned.
+void ScaleARGBRowDownEven_NEON(const uint8_t* src_argb,
+                               ptrdiff_t src_stride,
+                               int src_stepx,
+                               uint8_t* dst_argb,
+                               int dst_width) {
+  (void)src_stride;
+  asm volatile(
+      "1:                                        \n"
+      "ld1         {v0.s}[0], [%0], %3           \n"
+      "ld1         {v0.s}[1], [%0], %3           \n"
+      "ld1         {v0.s}[2], [%0], %3           \n"
+      "ld1         {v0.s}[3], [%0], %3           \n"
+      "subs        %w2, %w2, #4                  \n"  // 4 pixels per loop.
+      "prfm        pldl1keep, [%0, 448]          \n"  // prefetch 7 lines ahead
+      "st1         {v0.16b}, [%1], #16           \n"
+      "b.gt        1b                            \n"
+      : "+r"(src_argb),                // %0
+        "+r"(dst_argb),                // %1
+        "+r"(dst_width)                // %2
+      : "r"((int64_t)(src_stepx * 4))  // %3
+      : "memory", "cc", "v0");
+}
+
+// Reads 4 pixels at a time.
+// Alignment requirement: src_argb 4 byte aligned.
+// TODO(Yang Zhang): Might be worth another optimization pass in future.
+// It could be upgraded to 8 pixels at a time to start with.
+void ScaleARGBRowDownEvenBox_NEON(const uint8_t* src_argb,
+                                  ptrdiff_t src_stride,
+                                  int src_stepx,
+                                  uint8_t* dst_argb,
+                                  int dst_width) {
+  asm volatile(
+      "add         %1, %1, %0                    \n"
+      "1:                                        \n"
+      "ld1         {v0.8b}, [%0], %4             \n"  // Read 4 2x2 -> 2x1
+      "ld1         {v1.8b}, [%1], %4             \n"
+      "ld1         {v2.8b}, [%0], %4             \n"
+      "ld1         {v3.8b}, [%1], %4             \n"
+      "ld1         {v4.8b}, [%0], %4             \n"
+      "ld1         {v5.8b}, [%1], %4             \n"
+      "ld1         {v6.8b}, [%0], %4             \n"
+      "ld1         {v7.8b}, [%1], %4             \n"
+      "uaddl       v0.8h, v0.8b, v1.8b           \n"
+      "uaddl       v2.8h, v2.8b, v3.8b           \n"
+      "uaddl       v4.8h, v4.8b, v5.8b           \n"
+      "uaddl       v6.8h, v6.8b, v7.8b           \n"
+      "prfm        pldl1keep, [%0, 448]          \n"  // prefetch 7 lines ahead
+      "mov         v16.d[1], v0.d[1]             \n"  // ab_cd -> ac_bd
+      "mov         v0.d[1], v2.d[0]              \n"
+      "mov         v2.d[0], v16.d[1]             \n"
+      "mov         v16.d[1], v4.d[1]             \n"  // ef_gh -> eg_fh
+      "mov         v4.d[1], v6.d[0]              \n"
+      "mov         v6.d[0], v16.d[1]             \n"
+      "prfm        pldl1keep, [%1, 448]          \n"
+      "add         v0.8h, v0.8h, v2.8h           \n"  // (a+b)_(c+d)
+      "add         v4.8h, v4.8h, v6.8h           \n"  // (e+f)_(g+h)
+      "rshrn       v0.8b, v0.8h, #2              \n"  // first 2 pixels.
+      "rshrn2      v0.16b, v4.8h, #2             \n"  // next 2 pixels.
+      "subs        %w3, %w3, #4                  \n"  // 4 pixels per loop.
+      "st1         {v0.16b}, [%2], #16           \n"
+      "b.gt        1b                            \n"
+      : "+r"(src_argb),                // %0
+        "+r"(src_stride),              // %1
+        "+r"(dst_argb),                // %2
+        "+r"(dst_width)                // %3
+      : "r"((int64_t)(src_stepx * 4))  // %4
+      : "memory", "cc", "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7", "v16");
+}
+
+// TODO(Yang Zhang): Investigate less load instructions for
+// the x/dx stepping
+#define LOAD1_DATA32_LANE(vn, n)                 \
+  "lsr        %5, %3, #16                    \n" \
+  "add        %6, %1, %5, lsl #2             \n" \
+  "add        %3, %3, %4                     \n" \
+  "ld1        {" #vn ".s}[" #n "], [%6]      \n"
+
+void ScaleARGBCols_NEON(uint8_t* dst_argb,
+                        const uint8_t* src_argb,
+                        int dst_width,
+                        int x,
+                        int dx) {
+  const uint8_t* src_tmp = src_argb;
+  int64_t x64 = (int64_t)x;    // NOLINT
+  int64_t dx64 = (int64_t)dx;  // NOLINT
+  int64_t tmp64;
+  asm volatile(
+      "1:                                        \n"
+      // clang-format off
+      LOAD1_DATA32_LANE(v0, 0)
+      LOAD1_DATA32_LANE(v0, 1)
+      LOAD1_DATA32_LANE(v0, 2)
+      LOAD1_DATA32_LANE(v0, 3)
+      LOAD1_DATA32_LANE(v1, 0)
+      LOAD1_DATA32_LANE(v1, 1)
+      LOAD1_DATA32_LANE(v1, 2)
+      LOAD1_DATA32_LANE(v1, 3)
+      "prfm        pldl1keep, [%1, 448]          \n"  // prefetch 7 lines ahead
+      // clang-format on
+      "st1         {v0.4s, v1.4s}, [%0], #32     \n"  // store pixels
+      "subs        %w2, %w2, #8                  \n"  // 8 processed per loop
+      "b.gt        1b                            \n"
+      : "+r"(dst_argb),   // %0
+        "+r"(src_argb),   // %1
+        "+r"(dst_width),  // %2
+        "+r"(x64),        // %3
+        "+r"(dx64),       // %4
+        "=&r"(tmp64),     // %5
+        "+r"(src_tmp)     // %6
+      :
+      : "memory", "cc", "v0", "v1");
+}
+
+#undef LOAD1_DATA32_LANE
+
+// TODO(Yang Zhang): Investigate less load instructions for
+// the x/dx stepping
+#define LOAD2_DATA32_LANE(vn1, vn2, n)                  \
+  "lsr        %5, %3, #16                           \n" \
+  "add        %6, %1, %5, lsl #2                    \n" \
+  "add        %3, %3, %4                            \n" \
+  "ld2        {" #vn1 ".s, " #vn2 ".s}[" #n "], [%6]  \n"
+
+void ScaleARGBFilterCols_NEON(uint8_t* dst_argb,
+                              const uint8_t* src_argb,
+                              int dst_width,
+                              int x,
+                              int dx) {
+  int dx_offset[4] = {0, 1, 2, 3};
+  int* tmp = dx_offset;
+  const uint8_t* src_tmp = src_argb;
+  int64_t x64 = (int64_t)x;    // NOLINT
+  int64_t dx64 = (int64_t)dx;  // NOLINT
+  asm volatile (
+      "dup         v0.4s, %w3                    \n"  // x
+      "dup         v1.4s, %w4                    \n"  // dx
+      "ld1         {v2.4s}, [%5]                 \n"  // 0 1 2 3
+      "shl         v6.4s, v1.4s, #2              \n"  // 4 * dx
+      "mul         v1.4s, v1.4s, v2.4s           \n"
+      "movi        v3.16b, #0x7f                 \n"  // 0x7F
+      "movi        v4.8h, #0x7f                  \n"  // 0x7F
+    // x         , x + 1 * dx, x + 2 * dx, x + 3 * dx
+      "add         v5.4s, v1.4s, v0.4s           \n"
+      "1:                                        \n"
+    // d0, d1: a
+    // d2, d3: b
+    LOAD2_DATA32_LANE(v0, v1, 0)
+    LOAD2_DATA32_LANE(v0, v1, 1)
+    LOAD2_DATA32_LANE(v0, v1, 2)
+    LOAD2_DATA32_LANE(v0, v1, 3)
+    "shrn       v2.4h, v5.4s, #9               \n"
+    "and        v2.8b, v2.8b, v4.8b            \n"
+    "dup        v16.8b, v2.b[0]                \n"
+    "dup        v17.8b, v2.b[2]                \n"
+    "dup        v18.8b, v2.b[4]                \n"
+    "dup        v19.8b, v2.b[6]                \n"
+    "ext        v2.8b, v16.8b, v17.8b, #4      \n"
+    "ext        v17.8b, v18.8b, v19.8b, #4     \n"
+    "ins        v2.d[1], v17.d[0]              \n"  // f
+    "eor        v7.16b, v2.16b, v3.16b         \n"  // 0x7f ^ f
+    "umull      v16.8h, v0.8b, v7.8b           \n"
+    "umull2     v17.8h, v0.16b, v7.16b         \n"
+    "umull      v18.8h, v1.8b, v2.8b           \n"
+    "umull2     v19.8h, v1.16b, v2.16b         \n"
+    "prfm       pldl1keep, [%1, 448]           \n"  // prefetch 7 lines ahead
+    "add        v16.8h, v16.8h, v18.8h         \n"
+    "add        v17.8h, v17.8h, v19.8h         \n"
+    "shrn       v0.8b, v16.8h, #7              \n"
+    "shrn2      v0.16b, v17.8h, #7             \n"
+    "st1     {v0.4s}, [%0], #16                \n"  // store pixels
+    "add     v5.4s, v5.4s, v6.4s               \n"
+    "subs    %w2, %w2, #4                      \n"  // 4 processed per loop
+    "b.gt       1b                             \n"
+  : "+r"(dst_argb),         // %0
+    "+r"(src_argb),         // %1
+    "+r"(dst_width),        // %2
+    "+r"(x64),              // %3
+    "+r"(dx64),             // %4
+    "+r"(tmp),              // %5
+    "+r"(src_tmp)           // %6
+  :
+  : "memory", "cc", "v0", "v1", "v2", "v3", "v4", "v5",
+    "v6", "v7", "v16", "v17", "v18", "v19"
+  );
+}
+
+#undef LOAD2_DATA32_LANE
+
+// Read 16x2 average down and write 8x1.
+void ScaleRowDown2Box_16_NEON(const uint16_t* src_ptr,
+                              ptrdiff_t src_stride,
+                              uint16_t* dst,
+                              int dst_width) {
+  asm volatile(
+      // change the stride to row 2 pointer
+      "add         %1, %0, %1, lsl #1            \n"  // ptr + stide * 2
+      "1:                                        \n"
+      "ld1         {v0.8h, v1.8h}, [%0], #32     \n"  // load row 1 and post inc
+      "ld1         {v2.8h, v3.8h}, [%1], #32     \n"  // load row 2 and post inc
+      "subs        %w3, %w3, #8                  \n"  // 8 processed per loop
+      "uaddlp      v0.4s, v0.8h                  \n"  // row 1 add adjacent
+      "uaddlp      v1.4s, v1.8h                  \n"
+      "prfm        pldl1keep, [%0, 448]          \n"  // prefetch 7 lines ahead
+      "uadalp      v0.4s, v2.8h                  \n"  // +row 2 add adjacent
+      "uadalp      v1.4s, v3.8h                  \n"
+      "prfm        pldl1keep, [%1, 448]          \n"
+      "rshrn       v0.4h, v0.4s, #2              \n"  // round and pack
+      "rshrn2      v0.8h, v1.4s, #2              \n"
+      "st1         {v0.8h}, [%2], #16            \n"
+      "b.gt        1b                            \n"
+      : "+r"(src_ptr),     // %0
+        "+r"(src_stride),  // %1
+        "+r"(dst),         // %2
+        "+r"(dst_width)    // %3
+      :
+      : "v0", "v1", "v2", "v3"  // Clobber List
+  );
+}
+
+// Read 8x2 upsample with filtering and write 16x1.
+// Actually reads an extra pixel, so 9x2.
+void ScaleRowUp2_16_NEON(const uint16_t* src_ptr,
+                         ptrdiff_t src_stride,
+                         uint16_t* dst,
+                         int dst_width) {
+  asm volatile(
+      "add         %1, %0, %1, lsl #1            \n"  // ptr + stide * 2
+      "movi        v0.8h, #9                     \n"  // constants
+      "movi        v1.4s, #3                     \n"
+
+      "1:                                        \n"
+      "ld1         {v3.8h}, [%0], %4             \n"  // TL read first 8
+      "ld1         {v4.8h}, [%0], %5             \n"  // TR read 8 offset by 1
+      "ld1         {v5.8h}, [%1], %4             \n"  // BL read 8 from next row
+      "ld1         {v6.8h}, [%1], %5             \n"  // BR offset by 1
+      "subs        %w3, %w3, #16                 \n"  // 16 dst pixels per loop
+      "umull       v16.4s, v3.4h, v0.4h          \n"
+      "umull2      v7.4s, v3.8h, v0.8h           \n"
+      "umull       v18.4s, v4.4h, v0.4h          \n"
+      "umull2      v17.4s, v4.8h, v0.8h          \n"
+      "prfm        pldl1keep, [%0, 448]          \n"  // prefetch 7 lines ahead
+      "uaddw       v16.4s, v16.4s, v6.4h         \n"
+      "uaddl2      v19.4s, v6.8h, v3.8h          \n"
+      "uaddl       v3.4s, v6.4h, v3.4h           \n"
+      "uaddw2      v6.4s, v7.4s, v6.8h           \n"
+      "uaddl2      v7.4s, v5.8h, v4.8h           \n"
+      "uaddl       v4.4s, v5.4h, v4.4h           \n"
+      "uaddw       v18.4s, v18.4s, v5.4h         \n"
+      "prfm        pldl1keep, [%1, 448]          \n"
+      "mla         v16.4s, v4.4s, v1.4s          \n"
+      "mla         v18.4s, v3.4s, v1.4s          \n"
+      "mla         v6.4s, v7.4s, v1.4s           \n"
+      "uaddw2      v4.4s, v17.4s, v5.8h          \n"
+      "uqrshrn     v16.4h,  v16.4s, #4           \n"
+      "mla         v4.4s, v19.4s, v1.4s          \n"
+      "uqrshrn2    v16.8h, v6.4s, #4             \n"
+      "uqrshrn     v17.4h, v18.4s, #4            \n"
+      "uqrshrn2    v17.8h, v4.4s, #4             \n"
+      "st2         {v16.8h-v17.8h}, [%2], #32    \n"
+      "b.gt        1b                            \n"
+      : "+r"(src_ptr),     // %0
+        "+r"(src_stride),  // %1
+        "+r"(dst),         // %2
+        "+r"(dst_width)    // %3
+      : "r"(2LL),          // %4
+        "r"(14LL)          // %5
+      : "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7", "v16", "v17", "v18",
+        "v19"  // Clobber List
+  );
+}
+
+void ScaleUVRowDown2Box_NEON(const uint8_t* src_ptr,
+                             ptrdiff_t src_stride,
+                             uint8_t* dst,
+                             int dst_width) {
+  asm volatile(
+      // change the stride to row 2 pointer
+      "add         %1, %1, %0                    \n"
+      "1:                                        \n"
+      "ld2         {v0.16b,v1.16b}, [%0], #32    \n"  // load 16 UV
+      "subs        %w3, %w3, #8                  \n"  // 8 processed per loop.
+      "uaddlp      v0.8h, v0.16b                 \n"  // U 16 bytes -> 8 shorts.
+      "uaddlp      v1.8h, v1.16b                 \n"  // V 16 bytes -> 8 shorts.
+      "ld2         {v16.16b,v17.16b}, [%1], #32  \n"  // load 16
+      "uadalp      v0.8h, v16.16b                \n"  // U 16 bytes -> 8 shorts.
+      "uadalp      v1.8h, v17.16b                \n"  // V 16 bytes -> 8 shorts.
+      "prfm        pldl1keep, [%0, 448]          \n"  // prefetch 7 lines ahead
+      "rshrn       v0.8b, v0.8h, #2              \n"  // round and pack
+      "prfm        pldl1keep, [%1, 448]          \n"
+      "rshrn       v1.8b, v1.8h, #2              \n"
+      "st2         {v0.8b,v1.8b}, [%2], #16      \n"
+      "b.gt        1b                            \n"
+      : "+r"(src_ptr),     // %0
+        "+r"(src_stride),  // %1
+        "+r"(dst),         // %2
+        "+r"(dst_width)    // %3
+      :
+      : "memory", "cc", "v0", "v1", "v16", "v17");
+}
+
+// Reads 4 pixels at a time.
+void ScaleUVRowDownEven_NEON(const uint8_t* src_ptr,
+                             ptrdiff_t src_stride,
+                             int src_stepx,  // pixel step
+                             uint8_t* dst_ptr,
+                             int dst_width) {
+  const uint8_t* src1_ptr = src_ptr + src_stepx * 2;
+  const uint8_t* src2_ptr = src_ptr + src_stepx * 4;
+  const uint8_t* src3_ptr = src_ptr + src_stepx * 6;
+  (void)src_stride;
+  asm volatile(
+      "1:                                        \n"
+      "ld1         {v0.h}[0], [%0], %6           \n"
+      "ld1         {v1.h}[0], [%1], %6           \n"
+      "ld1         {v2.h}[0], [%2], %6           \n"
+      "ld1         {v3.h}[0], [%3], %6           \n"
+      "subs        %w5, %w5, #4                  \n"  // 4 pixels per loop.
+      "st4         {v0.h, v1.h, v2.h, v3.h}[0], [%4], #8 \n"
+      "b.gt        1b                            \n"
+      : "+r"(src_ptr),                 // %0
+        "+r"(src1_ptr),                // %1
+        "+r"(src2_ptr),                // %2
+        "+r"(src3_ptr),                // %3
+        "+r"(dst_ptr),                 // %4
+        "+r"(dst_width)                // %5
+      : "r"((int64_t)(src_stepx * 8))  // %6
+      : "memory", "cc", "v0", "v1", "v2", "v3");
+}
+
+#endif  // !defined(LIBYUV_DISABLE_NEON) && defined(__aarch64__)
+
+#ifdef __cplusplus
+}  // extern "C"
+}  // namespace libyuv
+#endif
diff --git a/3rdparty/libyuv/src/source/scale_rgb.cc b/3rdparty/libyuv/src/source/scale_rgb.cc
new file mode 100644
index 00000000..8db59b56
--- /dev/null
+++ b/3rdparty/libyuv/src/source/scale_rgb.cc
@@ -0,0 +1,66 @@
+/*
+ *  Copyright 2022 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include "libyuv/scale.h" /* For FilterMode */
+
+#include <assert.h>
+#include <string.h>
+
+#include "libyuv/convert_argb.h"
+#include "libyuv/convert_from_argb.h"
+#include "libyuv/row.h"
+#include "libyuv/scale_argb.h"
+#include "libyuv/scale_rgb.h"
+
+#ifdef __cplusplus
+namespace libyuv {
+extern "C" {
+#endif
+
+// Scale a 24 bit image.
+// Converts to ARGB as intermediate step
+
+LIBYUV_API
+int RGBScale(const uint8_t* src_rgb,
+             int src_stride_rgb,
+             int src_width,
+             int src_height,
+             uint8_t* dst_rgb,
+             int dst_stride_rgb,
+             int dst_width,
+             int dst_height,
+             enum FilterMode filtering) {
+  int r;
+  uint8_t* src_argb =
+      (uint8_t*)malloc(src_width * src_height * 4 + dst_width * dst_height * 4);
+  uint8_t* dst_argb = src_argb + src_width * src_height * 4;
+
+  if (!src_argb) {
+    return 1;
+  }
+
+  r = RGB24ToARGB(src_rgb, src_stride_rgb, src_argb, src_width * 4, src_width,
+                  src_height);
+  if (!r) {
+    r = ARGBScale(src_argb, src_width * 4, src_width, src_height, dst_argb,
+                  dst_width * 4, dst_width, dst_height, filtering);
+    if (!r) {
+      r = ARGBToRGB24(dst_argb, dst_width * 4, dst_rgb, dst_stride_rgb,
+                      dst_width, dst_height);
+    }
+  }
+  free(src_argb);
+  return r;
+}
+
+#ifdef __cplusplus
+}  // extern "C"
+}  // namespace libyuv
+#endif
diff --git a/3rdparty/libyuv/src/source/scale_uv.cc b/3rdparty/libyuv/src/source/scale_uv.cc
new file mode 100644
index 00000000..3b3d7b8e
--- /dev/null
+++ b/3rdparty/libyuv/src/source/scale_uv.cc
@@ -0,0 +1,1161 @@
+/*
+ *  Copyright 2020 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include "libyuv/scale.h"
+
+#include <assert.h>
+#include <string.h>
+
+#include "libyuv/cpu_id.h"
+#include "libyuv/planar_functions.h"  // For CopyUV
+#include "libyuv/row.h"
+#include "libyuv/scale_row.h"
+
+#ifdef __cplusplus
+namespace libyuv {
+extern "C" {
+#endif
+
+// Macros to enable specialized scalers
+
+#ifndef HAS_SCALEUVDOWN2
+#define HAS_SCALEUVDOWN2 1
+#endif
+#ifndef HAS_SCALEUVDOWN4BOX
+#define HAS_SCALEUVDOWN4BOX 1
+#endif
+#ifndef HAS_SCALEUVDOWNEVEN
+#define HAS_SCALEUVDOWNEVEN 1
+#endif
+#ifndef HAS_SCALEUVBILINEARDOWN
+#define HAS_SCALEUVBILINEARDOWN 1
+#endif
+#ifndef HAS_SCALEUVBILINEARUP
+#define HAS_SCALEUVBILINEARUP 1
+#endif
+#ifndef HAS_UVCOPY
+#define HAS_UVCOPY 1
+#endif
+#ifndef HAS_SCALEPLANEVERTICAL
+#define HAS_SCALEPLANEVERTICAL 1
+#endif
+
+static __inline int Abs(int v) {
+  return v >= 0 ? v : -v;
+}
+
+// ScaleUV, 1/2
+// This is an optimized version for scaling down a UV to 1/2 of
+// its original size.
+#if HAS_SCALEUVDOWN2
+static void ScaleUVDown2(int src_width,
+                         int src_height,
+                         int dst_width,
+                         int dst_height,
+                         int src_stride,
+                         int dst_stride,
+                         const uint8_t* src_uv,
+                         uint8_t* dst_uv,
+                         int x,
+                         int dx,
+                         int y,
+                         int dy,
+                         enum FilterMode filtering) {
+  int j;
+  int row_stride = src_stride * (dy >> 16);
+  void (*ScaleUVRowDown2)(const uint8_t* src_uv, ptrdiff_t src_stride,
+                          uint8_t* dst_uv, int dst_width) =
+      filtering == kFilterNone
+          ? ScaleUVRowDown2_C
+          : (filtering == kFilterLinear ? ScaleUVRowDown2Linear_C
+                                        : ScaleUVRowDown2Box_C);
+  (void)src_width;
+  (void)src_height;
+  (void)dx;
+  assert(dx == 65536 * 2);      // Test scale factor of 2.
+  assert((dy & 0x1ffff) == 0);  // Test vertical scale is multiple of 2.
+  // Advance to odd row, even column.
+  if (filtering == kFilterBilinear) {
+    src_uv += (y >> 16) * (int64_t)src_stride + (x >> 16) * 2;
+  } else {
+    src_uv += (y >> 16) * (int64_t)src_stride + ((x >> 16) - 1) * 2;
+  }
+
+#if defined(HAS_SCALEUVROWDOWN2BOX_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3) && filtering) {
+    ScaleUVRowDown2 = ScaleUVRowDown2Box_Any_SSSE3;
+    if (IS_ALIGNED(dst_width, 4)) {
+      ScaleUVRowDown2 = ScaleUVRowDown2Box_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_SCALEUVROWDOWN2BOX_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2) && filtering) {
+    ScaleUVRowDown2 = ScaleUVRowDown2Box_Any_AVX2;
+    if (IS_ALIGNED(dst_width, 8)) {
+      ScaleUVRowDown2 = ScaleUVRowDown2Box_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_SCALEUVROWDOWN2BOX_NEON)
+  if (TestCpuFlag(kCpuHasNEON) && filtering) {
+    ScaleUVRowDown2 = ScaleUVRowDown2Box_Any_NEON;
+    if (IS_ALIGNED(dst_width, 8)) {
+      ScaleUVRowDown2 = ScaleUVRowDown2Box_NEON;
+    }
+  }
+#endif
+
+// This code is not enabled.  Only box filter is available at this time.
+#if defined(HAS_SCALEUVROWDOWN2_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    ScaleUVRowDown2 =
+        filtering == kFilterNone
+            ? ScaleUVRowDown2_Any_SSSE3
+            : (filtering == kFilterLinear ? ScaleUVRowDown2Linear_Any_SSSE3
+                                          : ScaleUVRowDown2Box_Any_SSSE3);
+    if (IS_ALIGNED(dst_width, 2)) {
+      ScaleUVRowDown2 =
+          filtering == kFilterNone
+              ? ScaleUVRowDown2_SSSE3
+              : (filtering == kFilterLinear ? ScaleUVRowDown2Linear_SSSE3
+                                            : ScaleUVRowDown2Box_SSSE3);
+    }
+  }
+#endif
+// This code is not enabled.  Only box filter is available at this time.
+#if defined(HAS_SCALEUVROWDOWN2_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    ScaleUVRowDown2 =
+        filtering == kFilterNone
+            ? ScaleUVRowDown2_Any_NEON
+            : (filtering == kFilterLinear ? ScaleUVRowDown2Linear_Any_NEON
+                                          : ScaleUVRowDown2Box_Any_NEON);
+    if (IS_ALIGNED(dst_width, 8)) {
+      ScaleUVRowDown2 =
+          filtering == kFilterNone
+              ? ScaleUVRowDown2_NEON
+              : (filtering == kFilterLinear ? ScaleUVRowDown2Linear_NEON
+                                            : ScaleUVRowDown2Box_NEON);
+    }
+  }
+#endif
+#if defined(HAS_SCALEUVROWDOWN2_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    ScaleUVRowDown2 =
+        filtering == kFilterNone
+            ? ScaleUVRowDown2_Any_MSA
+            : (filtering == kFilterLinear ? ScaleUVRowDown2Linear_Any_MSA
+                                          : ScaleUVRowDown2Box_Any_MSA);
+    if (IS_ALIGNED(dst_width, 2)) {
+      ScaleUVRowDown2 =
+          filtering == kFilterNone
+              ? ScaleUVRowDown2_MSA
+              : (filtering == kFilterLinear ? ScaleUVRowDown2Linear_MSA
+                                            : ScaleUVRowDown2Box_MSA);
+    }
+  }
+#endif
+
+  if (filtering == kFilterLinear) {
+    src_stride = 0;
+  }
+  for (j = 0; j < dst_height; ++j) {
+    ScaleUVRowDown2(src_uv, src_stride, dst_uv, dst_width);
+    src_uv += row_stride;
+    dst_uv += dst_stride;
+  }
+}
+#endif  // HAS_SCALEUVDOWN2
+
+// ScaleUV, 1/4
+// This is an optimized version for scaling down a UV to 1/4 of
+// its original size.
+#if HAS_SCALEUVDOWN4BOX
+static void ScaleUVDown4Box(int src_width,
+                            int src_height,
+                            int dst_width,
+                            int dst_height,
+                            int src_stride,
+                            int dst_stride,
+                            const uint8_t* src_uv,
+                            uint8_t* dst_uv,
+                            int x,
+                            int dx,
+                            int y,
+                            int dy) {
+  int j;
+  // Allocate 2 rows of UV.
+  const int kRowSize = (dst_width * 2 * 2 + 15) & ~15;
+  align_buffer_64(row, kRowSize * 2);
+  int row_stride = src_stride * (dy >> 16);
+  void (*ScaleUVRowDown2)(const uint8_t* src_uv, ptrdiff_t src_stride,
+                          uint8_t* dst_uv, int dst_width) =
+      ScaleUVRowDown2Box_C;
+  // Advance to odd row, even column.
+  src_uv += (y >> 16) * (int64_t)src_stride + (x >> 16) * 2;
+  (void)src_width;
+  (void)src_height;
+  (void)dx;
+  assert(dx == 65536 * 4);      // Test scale factor of 4.
+  assert((dy & 0x3ffff) == 0);  // Test vertical scale is multiple of 4.
+
+#if defined(HAS_SCALEUVROWDOWN2BOX_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    ScaleUVRowDown2 = ScaleUVRowDown2Box_Any_SSSE3;
+    if (IS_ALIGNED(dst_width, 4)) {
+      ScaleUVRowDown2 = ScaleUVRowDown2Box_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_SCALEUVROWDOWN2BOX_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ScaleUVRowDown2 = ScaleUVRowDown2Box_Any_AVX2;
+    if (IS_ALIGNED(dst_width, 8)) {
+      ScaleUVRowDown2 = ScaleUVRowDown2Box_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_SCALEUVROWDOWN2BOX_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    ScaleUVRowDown2 = ScaleUVRowDown2Box_Any_NEON;
+    if (IS_ALIGNED(dst_width, 8)) {
+      ScaleUVRowDown2 = ScaleUVRowDown2Box_NEON;
+    }
+  }
+#endif
+
+  for (j = 0; j < dst_height; ++j) {
+    ScaleUVRowDown2(src_uv, src_stride, row, dst_width * 2);
+    ScaleUVRowDown2(src_uv + src_stride * 2, src_stride, row + kRowSize,
+                    dst_width * 2);
+    ScaleUVRowDown2(row, kRowSize, dst_uv, dst_width);
+    src_uv += row_stride;
+    dst_uv += dst_stride;
+  }
+  free_aligned_buffer_64(row);
+}
+#endif  // HAS_SCALEUVDOWN4BOX
+
+// ScaleUV Even
+// This is an optimized version for scaling down a UV to even
+// multiple of its original size.
+#if HAS_SCALEUVDOWNEVEN
+static void ScaleUVDownEven(int src_width,
+                            int src_height,
+                            int dst_width,
+                            int dst_height,
+                            int src_stride,
+                            int dst_stride,
+                            const uint8_t* src_uv,
+                            uint8_t* dst_uv,
+                            int x,
+                            int dx,
+                            int y,
+                            int dy,
+                            enum FilterMode filtering) {
+  int j;
+  int col_step = dx >> 16;
+  int row_stride = (dy >> 16) * (int64_t)src_stride;
+  void (*ScaleUVRowDownEven)(const uint8_t* src_uv, ptrdiff_t src_stride,
+                             int src_step, uint8_t* dst_uv, int dst_width) =
+      filtering ? ScaleUVRowDownEvenBox_C : ScaleUVRowDownEven_C;
+  (void)src_width;
+  (void)src_height;
+  assert(IS_ALIGNED(src_width, 2));
+  assert(IS_ALIGNED(src_height, 2));
+  src_uv += (y >> 16) * (int64_t)src_stride + (x >> 16) * 2;
+#if defined(HAS_SCALEUVROWDOWNEVEN_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    ScaleUVRowDownEven = filtering ? ScaleUVRowDownEvenBox_Any_SSSE3
+                                   : ScaleUVRowDownEven_Any_SSSE3;
+    if (IS_ALIGNED(dst_width, 4)) {
+      ScaleUVRowDownEven =
+          filtering ? ScaleUVRowDownEvenBox_SSE2 : ScaleUVRowDownEven_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_SCALEUVROWDOWNEVEN_NEON)
+  if (TestCpuFlag(kCpuHasNEON) && !filtering) {
+    ScaleUVRowDownEven = ScaleUVRowDownEven_Any_NEON;
+    if (IS_ALIGNED(dst_width, 4)) {
+      ScaleUVRowDownEven = ScaleUVRowDownEven_NEON;
+    }
+  }
+#endif  // TODO(fbarchard): Enable Box filter
+#if defined(HAS_SCALEUVROWDOWNEVENBOX_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    ScaleUVRowDownEven = filtering ? ScaleUVRowDownEvenBox_Any_NEON
+                                   : ScaleUVRowDownEven_Any_NEON;
+    if (IS_ALIGNED(dst_width, 4)) {
+      ScaleUVRowDownEven =
+          filtering ? ScaleUVRowDownEvenBox_NEON : ScaleUVRowDownEven_NEON;
+    }
+  }
+#endif
+#if defined(HAS_SCALEUVROWDOWNEVEN_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    ScaleUVRowDownEven =
+        filtering ? ScaleUVRowDownEvenBox_Any_MSA : ScaleUVRowDownEven_Any_MSA;
+    if (IS_ALIGNED(dst_width, 4)) {
+      ScaleUVRowDownEven =
+          filtering ? ScaleUVRowDownEvenBox_MSA : ScaleUVRowDownEven_MSA;
+    }
+  }
+#endif
+
+  if (filtering == kFilterLinear) {
+    src_stride = 0;
+  }
+  for (j = 0; j < dst_height; ++j) {
+    ScaleUVRowDownEven(src_uv, src_stride, col_step, dst_uv, dst_width);
+    src_uv += row_stride;
+    dst_uv += dst_stride;
+  }
+}
+#endif
+
+// Scale UV down with bilinear interpolation.
+#if HAS_SCALEUVBILINEARDOWN
+static void ScaleUVBilinearDown(int src_width,
+                                int src_height,
+                                int dst_width,
+                                int dst_height,
+                                int src_stride,
+                                int dst_stride,
+                                const uint8_t* src_uv,
+                                uint8_t* dst_uv,
+                                int x,
+                                int dx,
+                                int y,
+                                int dy,
+                                enum FilterMode filtering) {
+  int j;
+  void (*InterpolateRow)(uint8_t * dst_uv, const uint8_t* src_uv,
+                         ptrdiff_t src_stride, int dst_width,
+                         int source_y_fraction) = InterpolateRow_C;
+  void (*ScaleUVFilterCols)(uint8_t * dst_uv, const uint8_t* src_uv,
+                            int dst_width, int x, int dx) =
+      (src_width >= 32768) ? ScaleUVFilterCols64_C : ScaleUVFilterCols_C;
+  int64_t xlast = x + (int64_t)(dst_width - 1) * dx;
+  int64_t xl = (dx >= 0) ? x : xlast;
+  int64_t xr = (dx >= 0) ? xlast : x;
+  int clip_src_width;
+  xl = (xl >> 16) & ~3;    // Left edge aligned.
+  xr = (xr >> 16) + 1;     // Right most pixel used.  Bilinear uses 2 pixels.
+  xr = (xr + 1 + 3) & ~3;  // 1 beyond 4 pixel aligned right most pixel.
+  if (xr > src_width) {
+    xr = src_width;
+  }
+  clip_src_width = (int)(xr - xl) * 2;  // Width aligned to 2.
+  src_uv += xl * 2;
+  x -= (int)(xl << 16);
+#if defined(HAS_INTERPOLATEROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    InterpolateRow = InterpolateRow_Any_SSSE3;
+    if (IS_ALIGNED(clip_src_width, 16)) {
+      InterpolateRow = InterpolateRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_INTERPOLATEROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    InterpolateRow = InterpolateRow_Any_AVX2;
+    if (IS_ALIGNED(clip_src_width, 32)) {
+      InterpolateRow = InterpolateRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_INTERPOLATEROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    InterpolateRow = InterpolateRow_Any_NEON;
+    if (IS_ALIGNED(clip_src_width, 16)) {
+      InterpolateRow = InterpolateRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_INTERPOLATEROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    InterpolateRow = InterpolateRow_Any_MSA;
+    if (IS_ALIGNED(clip_src_width, 32)) {
+      InterpolateRow = InterpolateRow_MSA;
+    }
+  }
+#endif
+#if defined(HAS_INTERPOLATEROW_LSX)
+  if (TestCpuFlag(kCpuHasLSX)) {
+    InterpolateRow = InterpolateRow_Any_LSX;
+    if (IS_ALIGNED(clip_src_width, 32)) {
+      InterpolateRow = InterpolateRow_LSX;
+    }
+  }
+#endif
+#if defined(HAS_SCALEUVFILTERCOLS_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3) && src_width < 32768) {
+    ScaleUVFilterCols = ScaleUVFilterCols_SSSE3;
+  }
+#endif
+#if defined(HAS_SCALEUVFILTERCOLS_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    ScaleUVFilterCols = ScaleUVFilterCols_Any_NEON;
+    if (IS_ALIGNED(dst_width, 4)) {
+      ScaleUVFilterCols = ScaleUVFilterCols_NEON;
+    }
+  }
+#endif
+#if defined(HAS_SCALEUVFILTERCOLS_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    ScaleUVFilterCols = ScaleUVFilterCols_Any_MSA;
+    if (IS_ALIGNED(dst_width, 8)) {
+      ScaleUVFilterCols = ScaleUVFilterCols_MSA;
+    }
+  }
+#endif
+  // TODO(fbarchard): Consider not allocating row buffer for kFilterLinear.
+  // Allocate a row of UV.
+  {
+    align_buffer_64(row, clip_src_width * 2);
+
+    const int max_y = (src_height - 1) << 16;
+    if (y > max_y) {
+      y = max_y;
+    }
+    for (j = 0; j < dst_height; ++j) {
+      int yi = y >> 16;
+      const uint8_t* src = src_uv + yi * (int64_t)src_stride;
+      if (filtering == kFilterLinear) {
+        ScaleUVFilterCols(dst_uv, src, dst_width, x, dx);
+      } else {
+        int yf = (y >> 8) & 255;
+        InterpolateRow(row, src, src_stride, clip_src_width, yf);
+        ScaleUVFilterCols(dst_uv, row, dst_width, x, dx);
+      }
+      dst_uv += dst_stride;
+      y += dy;
+      if (y > max_y) {
+        y = max_y;
+      }
+    }
+    free_aligned_buffer_64(row);
+  }
+}
+#endif
+
+// Scale UV up with bilinear interpolation.
+#if HAS_SCALEUVBILINEARUP
+static void ScaleUVBilinearUp(int src_width,
+                              int src_height,
+                              int dst_width,
+                              int dst_height,
+                              int src_stride,
+                              int dst_stride,
+                              const uint8_t* src_uv,
+                              uint8_t* dst_uv,
+                              int x,
+                              int dx,
+                              int y,
+                              int dy,
+                              enum FilterMode filtering) {
+  int j;
+  void (*InterpolateRow)(uint8_t * dst_uv, const uint8_t* src_uv,
+                         ptrdiff_t src_stride, int dst_width,
+                         int source_y_fraction) = InterpolateRow_C;
+  void (*ScaleUVFilterCols)(uint8_t * dst_uv, const uint8_t* src_uv,
+                            int dst_width, int x, int dx) =
+      filtering ? ScaleUVFilterCols_C : ScaleUVCols_C;
+  const int max_y = (src_height - 1) << 16;
+#if defined(HAS_INTERPOLATEROW_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    InterpolateRow = InterpolateRow_Any_SSSE3;
+    if (IS_ALIGNED(dst_width, 8)) {
+      InterpolateRow = InterpolateRow_SSSE3;
+    }
+  }
+#endif
+#if defined(HAS_INTERPOLATEROW_AVX2)
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    InterpolateRow = InterpolateRow_Any_AVX2;
+    if (IS_ALIGNED(dst_width, 16)) {
+      InterpolateRow = InterpolateRow_AVX2;
+    }
+  }
+#endif
+#if defined(HAS_INTERPOLATEROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    InterpolateRow = InterpolateRow_Any_NEON;
+    if (IS_ALIGNED(dst_width, 8)) {
+      InterpolateRow = InterpolateRow_NEON;
+    }
+  }
+#endif
+#if defined(HAS_INTERPOLATEROW_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    InterpolateRow = InterpolateRow_Any_MSA;
+    if (IS_ALIGNED(dst_width, 16)) {
+      InterpolateRow = InterpolateRow_MSA;
+    }
+  }
+#endif
+#if defined(HAS_INTERPOLATEROW_LSX)
+  if (TestCpuFlag(kCpuHasLSX)) {
+    InterpolateRow = InterpolateRow_Any_LSX;
+    if (IS_ALIGNED(dst_width, 16)) {
+      InterpolateRow = InterpolateRow_LSX;
+    }
+  }
+#endif
+  if (src_width >= 32768) {
+    ScaleUVFilterCols = filtering ? ScaleUVFilterCols64_C : ScaleUVCols64_C;
+  }
+#if defined(HAS_SCALEUVFILTERCOLS_SSSE3)
+  if (filtering && TestCpuFlag(kCpuHasSSSE3) && src_width < 32768) {
+    ScaleUVFilterCols = ScaleUVFilterCols_SSSE3;
+  }
+#endif
+#if defined(HAS_SCALEUVFILTERCOLS_NEON)
+  if (filtering && TestCpuFlag(kCpuHasNEON)) {
+    ScaleUVFilterCols = ScaleUVFilterCols_Any_NEON;
+    if (IS_ALIGNED(dst_width, 8)) {
+      ScaleUVFilterCols = ScaleUVFilterCols_NEON;
+    }
+  }
+#endif
+#if defined(HAS_SCALEUVFILTERCOLS_MSA)
+  if (filtering && TestCpuFlag(kCpuHasMSA)) {
+    ScaleUVFilterCols = ScaleUVFilterCols_Any_MSA;
+    if (IS_ALIGNED(dst_width, 16)) {
+      ScaleUVFilterCols = ScaleUVFilterCols_MSA;
+    }
+  }
+#endif
+#if defined(HAS_SCALEUVCOLS_SSSE3)
+  if (!filtering && TestCpuFlag(kCpuHasSSSE3) && src_width < 32768) {
+    ScaleUVFilterCols = ScaleUVCols_SSSE3;
+  }
+#endif
+#if defined(HAS_SCALEUVCOLS_NEON)
+  if (!filtering && TestCpuFlag(kCpuHasNEON)) {
+    ScaleUVFilterCols = ScaleUVCols_Any_NEON;
+    if (IS_ALIGNED(dst_width, 16)) {
+      ScaleUVFilterCols = ScaleUVCols_NEON;
+    }
+  }
+#endif
+#if defined(HAS_SCALEUVCOLS_MSA)
+  if (!filtering && TestCpuFlag(kCpuHasMSA)) {
+    ScaleUVFilterCols = ScaleUVCols_Any_MSA;
+    if (IS_ALIGNED(dst_width, 8)) {
+      ScaleUVFilterCols = ScaleUVCols_MSA;
+    }
+  }
+#endif
+  if (!filtering && src_width * 2 == dst_width && x < 0x8000) {
+    ScaleUVFilterCols = ScaleUVColsUp2_C;
+#if defined(HAS_SCALEUVCOLSUP2_SSSE3)
+    if (TestCpuFlag(kCpuHasSSSE3) && IS_ALIGNED(dst_width, 8)) {
+      ScaleUVFilterCols = ScaleUVColsUp2_SSSE3;
+    }
+#endif
+  }
+
+  if (y > max_y) {
+    y = max_y;
+  }
+
+  {
+    int yi = y >> 16;
+    const uint8_t* src = src_uv + yi * (int64_t)src_stride;
+
+    // Allocate 2 rows of UV.
+    const int kRowSize = (dst_width * 2 + 15) & ~15;
+    align_buffer_64(row, kRowSize * 2);
+
+    uint8_t* rowptr = row;
+    int rowstride = kRowSize;
+    int lasty = yi;
+
+    ScaleUVFilterCols(rowptr, src, dst_width, x, dx);
+    if (src_height > 1) {
+      src += src_stride;
+    }
+    ScaleUVFilterCols(rowptr + rowstride, src, dst_width, x, dx);
+    if (src_height > 2) {
+      src += src_stride;
+    }
+
+    for (j = 0; j < dst_height; ++j) {
+      yi = y >> 16;
+      if (yi != lasty) {
+        if (y > max_y) {
+          y = max_y;
+          yi = y >> 16;
+          src = src_uv + yi * (int64_t)src_stride;
+        }
+        if (yi != lasty) {
+          ScaleUVFilterCols(rowptr, src, dst_width, x, dx);
+          rowptr += rowstride;
+          rowstride = -rowstride;
+          lasty = yi;
+          if ((y + 65536) < max_y) {
+            src += src_stride;
+          }
+        }
+      }
+      if (filtering == kFilterLinear) {
+        InterpolateRow(dst_uv, rowptr, 0, dst_width * 2, 0);
+      } else {
+        int yf = (y >> 8) & 255;
+        InterpolateRow(dst_uv, rowptr, rowstride, dst_width * 2, yf);
+      }
+      dst_uv += dst_stride;
+      y += dy;
+    }
+    free_aligned_buffer_64(row);
+  }
+}
+#endif  // HAS_SCALEUVBILINEARUP
+
+// Scale UV, horizontally up by 2 times.
+// Uses linear filter horizontally, nearest vertically.
+// This is an optimized version for scaling up a plane to 2 times of
+// its original width, using linear interpolation.
+// This is used to scale U and V planes of NV16 to NV24.
+void ScaleUVLinearUp2(int src_width,
+                      int src_height,
+                      int dst_width,
+                      int dst_height,
+                      int src_stride,
+                      int dst_stride,
+                      const uint8_t* src_uv,
+                      uint8_t* dst_uv) {
+  void (*ScaleRowUp)(const uint8_t* src_uv, uint8_t* dst_uv, int dst_width) =
+      ScaleUVRowUp2_Linear_Any_C;
+  int i;
+  int y;
+  int dy;
+
+  // This function can only scale up by 2 times horizontally.
+  assert(src_width == ((dst_width + 1) / 2));
+
+#ifdef HAS_SCALEUVROWUP2LINEAR_SSSE3
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    ScaleRowUp = ScaleUVRowUp2_Linear_Any_SSSE3;
+  }
+#endif
+
+#ifdef HAS_SCALEUVROWUP2LINEAR_AVX2
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ScaleRowUp = ScaleUVRowUp2_Linear_Any_AVX2;
+  }
+#endif
+
+#ifdef HAS_SCALEUVROWUP2LINEAR_NEON
+  if (TestCpuFlag(kCpuHasNEON)) {
+    ScaleRowUp = ScaleUVRowUp2_Linear_Any_NEON;
+  }
+#endif
+
+  if (dst_height == 1) {
+    ScaleRowUp(src_uv + ((src_height - 1) / 2) * (int64_t)src_stride, dst_uv,
+               dst_width);
+  } else {
+    dy = FixedDiv(src_height - 1, dst_height - 1);
+    y = (1 << 15) - 1;
+    for (i = 0; i < dst_height; ++i) {
+      ScaleRowUp(src_uv + (y >> 16) * (int64_t)src_stride, dst_uv, dst_width);
+      dst_uv += dst_stride;
+      y += dy;
+    }
+  }
+}
+
+// Scale plane, up by 2 times.
+// This is an optimized version for scaling up a plane to 2 times of
+// its original size, using bilinear interpolation.
+// This is used to scale U and V planes of NV12 to NV24.
+void ScaleUVBilinearUp2(int src_width,
+                        int src_height,
+                        int dst_width,
+                        int dst_height,
+                        int src_stride,
+                        int dst_stride,
+                        const uint8_t* src_ptr,
+                        uint8_t* dst_ptr) {
+  void (*Scale2RowUp)(const uint8_t* src_ptr, ptrdiff_t src_stride,
+                      uint8_t* dst_ptr, ptrdiff_t dst_stride, int dst_width) =
+      ScaleUVRowUp2_Bilinear_Any_C;
+  int x;
+
+  // This function can only scale up by 2 times.
+  assert(src_width == ((dst_width + 1) / 2));
+  assert(src_height == ((dst_height + 1) / 2));
+
+#ifdef HAS_SCALEUVROWUP2BILINEAR_SSSE3
+  if (TestCpuFlag(kCpuHasSSSE3)) {
+    Scale2RowUp = ScaleUVRowUp2_Bilinear_Any_SSSE3;
+  }
+#endif
+
+#ifdef HAS_SCALEUVROWUP2BILINEAR_AVX2
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    Scale2RowUp = ScaleUVRowUp2_Bilinear_Any_AVX2;
+  }
+#endif
+
+#ifdef HAS_SCALEUVROWUP2BILINEAR_NEON
+  if (TestCpuFlag(kCpuHasNEON)) {
+    Scale2RowUp = ScaleUVRowUp2_Bilinear_Any_NEON;
+  }
+#endif
+
+  Scale2RowUp(src_ptr, 0, dst_ptr, 0, dst_width);
+  dst_ptr += dst_stride;
+  for (x = 0; x < src_height - 1; ++x) {
+    Scale2RowUp(src_ptr, src_stride, dst_ptr, dst_stride, dst_width);
+    src_ptr += src_stride;
+    // TODO(fbarchard): Test performance of writing one row of destination at a
+    // time.
+    dst_ptr += 2 * dst_stride;
+  }
+  if (!(dst_height & 1)) {
+    Scale2RowUp(src_ptr, 0, dst_ptr, 0, dst_width);
+  }
+}
+
+// Scale 16 bit UV, horizontally up by 2 times.
+// Uses linear filter horizontally, nearest vertically.
+// This is an optimized version for scaling up a plane to 2 times of
+// its original width, using linear interpolation.
+// This is used to scale U and V planes of P210 to P410.
+void ScaleUVLinearUp2_16(int src_width,
+                         int src_height,
+                         int dst_width,
+                         int dst_height,
+                         int src_stride,
+                         int dst_stride,
+                         const uint16_t* src_uv,
+                         uint16_t* dst_uv) {
+  void (*ScaleRowUp)(const uint16_t* src_uv, uint16_t* dst_uv, int dst_width) =
+      ScaleUVRowUp2_Linear_16_Any_C;
+  int i;
+  int y;
+  int dy;
+
+  // This function can only scale up by 2 times horizontally.
+  assert(src_width == ((dst_width + 1) / 2));
+
+#ifdef HAS_SCALEUVROWUP2LINEAR_16_SSE41
+  if (TestCpuFlag(kCpuHasSSE41)) {
+    ScaleRowUp = ScaleUVRowUp2_Linear_16_Any_SSE41;
+  }
+#endif
+
+#ifdef HAS_SCALEUVROWUP2LINEAR_16_AVX2
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    ScaleRowUp = ScaleUVRowUp2_Linear_16_Any_AVX2;
+  }
+#endif
+
+#ifdef HAS_SCALEUVROWUP2LINEAR_16_NEON
+  if (TestCpuFlag(kCpuHasNEON)) {
+    ScaleRowUp = ScaleUVRowUp2_Linear_16_Any_NEON;
+  }
+#endif
+
+  if (dst_height == 1) {
+    ScaleRowUp(src_uv + ((src_height - 1) / 2) * (int64_t)src_stride, dst_uv,
+               dst_width);
+  } else {
+    dy = FixedDiv(src_height - 1, dst_height - 1);
+    y = (1 << 15) - 1;
+    for (i = 0; i < dst_height; ++i) {
+      ScaleRowUp(src_uv + (y >> 16) * (int64_t)src_stride, dst_uv, dst_width);
+      dst_uv += dst_stride;
+      y += dy;
+    }
+  }
+}
+
+// Scale 16 bit UV, up by 2 times.
+// This is an optimized version for scaling up a plane to 2 times of
+// its original size, using bilinear interpolation.
+// This is used to scale U and V planes of P010 to P410.
+void ScaleUVBilinearUp2_16(int src_width,
+                           int src_height,
+                           int dst_width,
+                           int dst_height,
+                           int src_stride,
+                           int dst_stride,
+                           const uint16_t* src_ptr,
+                           uint16_t* dst_ptr) {
+  void (*Scale2RowUp)(const uint16_t* src_ptr, ptrdiff_t src_stride,
+                      uint16_t* dst_ptr, ptrdiff_t dst_stride, int dst_width) =
+      ScaleUVRowUp2_Bilinear_16_Any_C;
+  int x;
+
+  // This function can only scale up by 2 times.
+  assert(src_width == ((dst_width + 1) / 2));
+  assert(src_height == ((dst_height + 1) / 2));
+
+#ifdef HAS_SCALEUVROWUP2BILINEAR_16_SSE41
+  if (TestCpuFlag(kCpuHasSSE41)) {
+    Scale2RowUp = ScaleUVRowUp2_Bilinear_16_Any_SSE41;
+  }
+#endif
+
+#ifdef HAS_SCALEUVROWUP2BILINEAR_16_AVX2
+  if (TestCpuFlag(kCpuHasAVX2)) {
+    Scale2RowUp = ScaleUVRowUp2_Bilinear_16_Any_AVX2;
+  }
+#endif
+
+#ifdef HAS_SCALEUVROWUP2BILINEAR_16_NEON
+  if (TestCpuFlag(kCpuHasNEON)) {
+    Scale2RowUp = ScaleUVRowUp2_Bilinear_16_Any_NEON;
+  }
+#endif
+
+  Scale2RowUp(src_ptr, 0, dst_ptr, 0, dst_width);
+  dst_ptr += dst_stride;
+  for (x = 0; x < src_height - 1; ++x) {
+    Scale2RowUp(src_ptr, src_stride, dst_ptr, dst_stride, dst_width);
+    src_ptr += src_stride;
+    // TODO(fbarchard): Test performance of writing one row of destination at a
+    // time.
+    dst_ptr += 2 * dst_stride;
+  }
+  if (!(dst_height & 1)) {
+    Scale2RowUp(src_ptr, 0, dst_ptr, 0, dst_width);
+  }
+}
+
+// Scale UV to/from any dimensions, without interpolation.
+// Fixed point math is used for performance: The upper 16 bits
+// of x and dx is the integer part of the source position and
+// the lower 16 bits are the fixed decimal part.
+
+static void ScaleUVSimple(int src_width,
+                          int src_height,
+                          int dst_width,
+                          int dst_height,
+                          int src_stride,
+                          int dst_stride,
+                          const uint8_t* src_uv,
+                          uint8_t* dst_uv,
+                          int x,
+                          int dx,
+                          int y,
+                          int dy) {
+  int j;
+  void (*ScaleUVCols)(uint8_t * dst_uv, const uint8_t* src_uv, int dst_width,
+                      int x, int dx) =
+      (src_width >= 32768) ? ScaleUVCols64_C : ScaleUVCols_C;
+  (void)src_height;
+#if defined(HAS_SCALEUVCOLS_SSSE3)
+  if (TestCpuFlag(kCpuHasSSSE3) && src_width < 32768) {
+    ScaleUVCols = ScaleUVCols_SSSE3;
+  }
+#endif
+#if defined(HAS_SCALEUVCOLS_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    ScaleUVCols = ScaleUVCols_Any_NEON;
+    if (IS_ALIGNED(dst_width, 8)) {
+      ScaleUVCols = ScaleUVCols_NEON;
+    }
+  }
+#endif
+#if defined(HAS_SCALEUVCOLS_MSA)
+  if (TestCpuFlag(kCpuHasMSA)) {
+    ScaleUVCols = ScaleUVCols_Any_MSA;
+    if (IS_ALIGNED(dst_width, 4)) {
+      ScaleUVCols = ScaleUVCols_MSA;
+    }
+  }
+#endif
+  if (src_width * 2 == dst_width && x < 0x8000) {
+    ScaleUVCols = ScaleUVColsUp2_C;
+#if defined(HAS_SCALEUVCOLSUP2_SSSE3)
+    if (TestCpuFlag(kCpuHasSSSE3) && IS_ALIGNED(dst_width, 8)) {
+      ScaleUVCols = ScaleUVColsUp2_SSSE3;
+    }
+#endif
+  }
+
+  for (j = 0; j < dst_height; ++j) {
+    ScaleUVCols(dst_uv, src_uv + (y >> 16) * (int64_t)src_stride, dst_width, x,
+                dx);
+    dst_uv += dst_stride;
+    y += dy;
+  }
+}
+
+// Copy UV with optional flipping
+#if HAS_UVCOPY
+static int UVCopy(const uint8_t* src_uv,
+                  int src_stride_uv,
+                  uint8_t* dst_uv,
+                  int dst_stride_uv,
+                  int width,
+                  int height) {
+  if (!src_uv || !dst_uv || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    src_uv = src_uv + (height - 1) * (int64_t)src_stride_uv;
+    src_stride_uv = -src_stride_uv;
+  }
+
+  CopyPlane(src_uv, src_stride_uv, dst_uv, dst_stride_uv, width * 2, height);
+  return 0;
+}
+
+static int UVCopy_16(const uint16_t* src_uv,
+                     int src_stride_uv,
+                     uint16_t* dst_uv,
+                     int dst_stride_uv,
+                     int width,
+                     int height) {
+  if (!src_uv || !dst_uv || width <= 0 || height == 0) {
+    return -1;
+  }
+  // Negative height means invert the image.
+  if (height < 0) {
+    height = -height;
+    src_uv = src_uv + (height - 1) * (int64_t)src_stride_uv;
+    src_stride_uv = -src_stride_uv;
+  }
+
+  CopyPlane_16(src_uv, src_stride_uv, dst_uv, dst_stride_uv, width * 2, height);
+  return 0;
+}
+#endif  // HAS_UVCOPY
+
+// Scale a UV plane (from NV12)
+// This function in turn calls a scaling function
+// suitable for handling the desired resolutions.
+static void ScaleUV(const uint8_t* src,
+                    int src_stride,
+                    int src_width,
+                    int src_height,
+                    uint8_t* dst,
+                    int dst_stride,
+                    int dst_width,
+                    int dst_height,
+                    int clip_x,
+                    int clip_y,
+                    int clip_width,
+                    int clip_height,
+                    enum FilterMode filtering) {
+  // Initial source x/y coordinate and step values as 16.16 fixed point.
+  int x = 0;
+  int y = 0;
+  int dx = 0;
+  int dy = 0;
+  // UV does not support box filter yet, but allow the user to pass it.
+  // Simplify filtering when possible.
+  filtering = ScaleFilterReduce(src_width, src_height, dst_width, dst_height,
+                                filtering);
+
+  // Negative src_height means invert the image.
+  if (src_height < 0) {
+    src_height = -src_height;
+    src = src + (src_height - 1) * (int64_t)src_stride;
+    src_stride = -src_stride;
+  }
+  ScaleSlope(src_width, src_height, dst_width, dst_height, filtering, &x, &y,
+             &dx, &dy);
+  src_width = Abs(src_width);
+  if (clip_x) {
+    int64_t clipf = (int64_t)(clip_x)*dx;
+    x += (clipf & 0xffff);
+    src += (clipf >> 16) * 2;
+    dst += clip_x * 2;
+  }
+  if (clip_y) {
+    int64_t clipf = (int64_t)(clip_y)*dy;
+    y += (clipf & 0xffff);
+    src += (clipf >> 16) * (int64_t)src_stride;
+    dst += clip_y * dst_stride;
+  }
+
+  // Special case for integer step values.
+  if (((dx | dy) & 0xffff) == 0) {
+    if (!dx || !dy) {  // 1 pixel wide and/or tall.
+      filtering = kFilterNone;
+    } else {
+      // Optimized even scale down. ie 2, 4, 6, 8, 10x.
+      if (!(dx & 0x10000) && !(dy & 0x10000)) {
+#if HAS_SCALEUVDOWN2
+        if (dx == 0x20000) {
+          // Optimized 1/2 downsample.
+          ScaleUVDown2(src_width, src_height, clip_width, clip_height,
+                       src_stride, dst_stride, src, dst, x, dx, y, dy,
+                       filtering);
+          return;
+        }
+#endif
+#if HAS_SCALEUVDOWN4BOX
+        if (dx == 0x40000 && filtering == kFilterBox) {
+          // Optimized 1/4 box downsample.
+          ScaleUVDown4Box(src_width, src_height, clip_width, clip_height,
+                          src_stride, dst_stride, src, dst, x, dx, y, dy);
+          return;
+        }
+#endif
+#if HAS_SCALEUVDOWNEVEN
+        ScaleUVDownEven(src_width, src_height, clip_width, clip_height,
+                        src_stride, dst_stride, src, dst, x, dx, y, dy,
+                        filtering);
+        return;
+#endif
+      }
+      // Optimized odd scale down. ie 3, 5, 7, 9x.
+      if ((dx & 0x10000) && (dy & 0x10000)) {
+        filtering = kFilterNone;
+#ifdef HAS_UVCOPY
+        if (dx == 0x10000 && dy == 0x10000) {
+          // Straight copy.
+          UVCopy(src + (y >> 16) * (int64_t)src_stride + (x >> 16) * 2,
+                 src_stride, dst, dst_stride, clip_width, clip_height);
+          return;
+        }
+#endif
+      }
+    }
+  }
+  // HAS_SCALEPLANEVERTICAL
+  if (dx == 0x10000 && (x & 0xffff) == 0) {
+    // Arbitrary scale vertically, but unscaled horizontally.
+    ScalePlaneVertical(src_height, clip_width, clip_height, src_stride,
+                       dst_stride, src, dst, x, y, dy, /*bpp=*/2, filtering);
+    return;
+  }
+  if (filtering && (dst_width + 1) / 2 == src_width) {
+    ScaleUVLinearUp2(src_width, src_height, clip_width, clip_height, src_stride,
+                     dst_stride, src, dst);
+    return;
+  }
+  if ((clip_height + 1) / 2 == src_height &&
+      (clip_width + 1) / 2 == src_width &&
+      (filtering == kFilterBilinear || filtering == kFilterBox)) {
+    ScaleUVBilinearUp2(src_width, src_height, clip_width, clip_height,
+                       src_stride, dst_stride, src, dst);
+    return;
+  }
+#if HAS_SCALEUVBILINEARUP
+  if (filtering && dy < 65536) {
+    ScaleUVBilinearUp(src_width, src_height, clip_width, clip_height,
+                      src_stride, dst_stride, src, dst, x, dx, y, dy,
+                      filtering);
+    return;
+  }
+#endif
+#if HAS_SCALEUVBILINEARDOWN
+  if (filtering) {
+    ScaleUVBilinearDown(src_width, src_height, clip_width, clip_height,
+                        src_stride, dst_stride, src, dst, x, dx, y, dy,
+                        filtering);
+    return;
+  }
+#endif
+  ScaleUVSimple(src_width, src_height, clip_width, clip_height, src_stride,
+                dst_stride, src, dst, x, dx, y, dy);
+}
+
+// Scale an UV image.
+LIBYUV_API
+int UVScale(const uint8_t* src_uv,
+            int src_stride_uv,
+            int src_width,
+            int src_height,
+            uint8_t* dst_uv,
+            int dst_stride_uv,
+            int dst_width,
+            int dst_height,
+            enum FilterMode filtering) {
+  if (!src_uv || src_width <= 0 || src_height == 0 || src_width > 32768 ||
+      src_height > 32768 || !dst_uv || dst_width <= 0 || dst_height <= 0) {
+    return -1;
+  }
+  ScaleUV(src_uv, src_stride_uv, src_width, src_height, dst_uv, dst_stride_uv,
+          dst_width, dst_height, 0, 0, dst_width, dst_height, filtering);
+  return 0;
+}
+
+// Scale a 16 bit UV image.
+// This function is currently incomplete, it can't handle all cases.
+LIBYUV_API
+int UVScale_16(const uint16_t* src_uv,
+               int src_stride_uv,
+               int src_width,
+               int src_height,
+               uint16_t* dst_uv,
+               int dst_stride_uv,
+               int dst_width,
+               int dst_height,
+               enum FilterMode filtering) {
+  int dy = 0;
+
+  if (!src_uv || src_width <= 0 || src_height == 0 || src_width > 32768 ||
+      src_height > 32768 || !dst_uv || dst_width <= 0 || dst_height <= 0) {
+    return -1;
+  }
+
+  // UV does not support box filter yet, but allow the user to pass it.
+  // Simplify filtering when possible.
+  filtering = ScaleFilterReduce(src_width, src_height, dst_width, dst_height,
+                                filtering);
+
+  // Negative src_height means invert the image.
+  if (src_height < 0) {
+    src_height = -src_height;
+    src_uv = src_uv + (src_height - 1) * (int64_t)src_stride_uv;
+    src_stride_uv = -src_stride_uv;
+  }
+  src_width = Abs(src_width);
+
+#ifdef HAS_UVCOPY
+  if (!filtering && src_width == dst_width && (src_height % dst_height == 0)) {
+    if (dst_height == 1) {
+      UVCopy_16(src_uv + ((src_height - 1) / 2) * (int64_t)src_stride_uv,
+                src_stride_uv, dst_uv, dst_stride_uv, dst_width, dst_height);
+    } else {
+      dy = src_height / dst_height;
+      UVCopy_16(src_uv + ((dy - 1) / 2) * (int64_t)src_stride_uv,
+                dy * (int64_t)src_stride_uv, dst_uv, dst_stride_uv, dst_width,
+                dst_height);
+    }
+
+    return 0;
+  }
+#endif
+
+  if (filtering && (dst_width + 1) / 2 == src_width) {
+    ScaleUVLinearUp2_16(src_width, src_height, dst_width, dst_height,
+                        src_stride_uv, dst_stride_uv, src_uv, dst_uv);
+    return 0;
+  }
+
+  if ((dst_height + 1) / 2 == src_height && (dst_width + 1) / 2 == src_width &&
+      (filtering == kFilterBilinear || filtering == kFilterBox)) {
+    ScaleUVBilinearUp2_16(src_width, src_height, dst_width, dst_height,
+                          src_stride_uv, dst_stride_uv, src_uv, dst_uv);
+    return 0;
+  }
+
+  return -1;
+}
+
+#ifdef __cplusplus
+}  // extern "C"
+}  // namespace libyuv
+#endif
diff --git a/3rdparty/libyuv/src/source/scale_win.cc b/3rdparty/libyuv/src/source/scale_win.cc
new file mode 100644
index 00000000..ea1f95c6
--- /dev/null
+++ b/3rdparty/libyuv/src/source/scale_win.cc
@@ -0,0 +1,1392 @@
+/*
+ *  Copyright 2013 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include "libyuv/row.h"
+#include "libyuv/scale_row.h"
+
+#ifdef __cplusplus
+namespace libyuv {
+extern "C" {
+#endif
+
+// This module is for 32 bit Visual C x86
+#if !defined(LIBYUV_DISABLE_X86) && defined(_MSC_VER) && \
+    !defined(__clang__) && defined(_M_IX86)
+
+// Offsets for source bytes 0 to 9
+static const uvec8 kShuf0 = {0,   1,   3,   4,   5,   7,   8,   9,
+                             128, 128, 128, 128, 128, 128, 128, 128};
+
+// Offsets for source bytes 11 to 20 with 8 subtracted = 3 to 12.
+static const uvec8 kShuf1 = {3,   4,   5,   7,   8,   9,   11,  12,
+                             128, 128, 128, 128, 128, 128, 128, 128};
+
+// Offsets for source bytes 21 to 31 with 16 subtracted = 5 to 31.
+static const uvec8 kShuf2 = {5,   7,   8,   9,   11,  12,  13,  15,
+                             128, 128, 128, 128, 128, 128, 128, 128};
+
+// Offsets for source bytes 0 to 10
+static const uvec8 kShuf01 = {0, 1, 1, 2, 2, 3, 4, 5, 5, 6, 6, 7, 8, 9, 9, 10};
+
+// Offsets for source bytes 10 to 21 with 8 subtracted = 3 to 13.
+static const uvec8 kShuf11 = {2, 3, 4, 5,  5,  6,  6,  7,
+                              8, 9, 9, 10, 10, 11, 12, 13};
+
+// Offsets for source bytes 21 to 31 with 16 subtracted = 5 to 31.
+static const uvec8 kShuf21 = {5,  6,  6,  7,  8,  9,  9,  10,
+                              10, 11, 12, 13, 13, 14, 14, 15};
+
+// Coefficients for source bytes 0 to 10
+static const uvec8 kMadd01 = {3, 1, 2, 2, 1, 3, 3, 1, 2, 2, 1, 3, 3, 1, 2, 2};
+
+// Coefficients for source bytes 10 to 21
+static const uvec8 kMadd11 = {1, 3, 3, 1, 2, 2, 1, 3, 3, 1, 2, 2, 1, 3, 3, 1};
+
+// Coefficients for source bytes 21 to 31
+static const uvec8 kMadd21 = {2, 2, 1, 3, 3, 1, 2, 2, 1, 3, 3, 1, 2, 2, 1, 3};
+
+// Coefficients for source bytes 21 to 31
+static const vec16 kRound34 = {2, 2, 2, 2, 2, 2, 2, 2};
+
+static const uvec8 kShuf38a = {0,   3,   6,   8,   11,  14,  128, 128,
+                               128, 128, 128, 128, 128, 128, 128, 128};
+
+static const uvec8 kShuf38b = {128, 128, 128, 128, 128, 128, 0,   3,
+                               6,   8,   11,  14,  128, 128, 128, 128};
+
+// Arrange words 0,3,6 into 0,1,2
+static const uvec8 kShufAc = {0,   1,   6,   7,   12,  13,  128, 128,
+                              128, 128, 128, 128, 128, 128, 128, 128};
+
+// Arrange words 0,3,6 into 3,4,5
+static const uvec8 kShufAc3 = {128, 128, 128, 128, 128, 128, 0,   1,
+                               6,   7,   12,  13,  128, 128, 128, 128};
+
+// Scaling values for boxes of 3x3 and 2x3
+static const uvec16 kScaleAc33 = {65536 / 9, 65536 / 9, 65536 / 6, 65536 / 9,
+                                  65536 / 9, 65536 / 6, 0,         0};
+
+// Arrange first value for pixels 0,1,2,3,4,5
+static const uvec8 kShufAb0 = {0,  128, 3,  128, 6,   128, 8,   128,
+                               11, 128, 14, 128, 128, 128, 128, 128};
+
+// Arrange second value for pixels 0,1,2,3,4,5
+static const uvec8 kShufAb1 = {1,  128, 4,  128, 7,   128, 9,   128,
+                               12, 128, 15, 128, 128, 128, 128, 128};
+
+// Arrange third value for pixels 0,1,2,3,4,5
+static const uvec8 kShufAb2 = {2,  128, 5,   128, 128, 128, 10,  128,
+                               13, 128, 128, 128, 128, 128, 128, 128};
+
+// Scaling values for boxes of 3x2 and 2x2
+static const uvec16 kScaleAb2 = {65536 / 3, 65536 / 3, 65536 / 2, 65536 / 3,
+                                 65536 / 3, 65536 / 2, 0,         0};
+
+// Reads 32 pixels, throws half away and writes 16 pixels.
+__declspec(naked) void ScaleRowDown2_SSSE3(const uint8_t* src_ptr,
+                                           ptrdiff_t src_stride,
+                                           uint8_t* dst_ptr,
+                                           int dst_width) {
+  __asm {
+    mov        eax, [esp + 4]  // src_ptr
+    // src_stride ignored
+    mov        edx, [esp + 12]  // dst_ptr
+    mov        ecx, [esp + 16]  // dst_width
+
+  wloop:
+    movdqu     xmm0, [eax]
+    movdqu     xmm1, [eax + 16]
+    lea        eax,  [eax + 32]
+    psrlw      xmm0, 8          // isolate odd pixels.
+    psrlw      xmm1, 8
+    packuswb   xmm0, xmm1
+    movdqu     [edx], xmm0
+    lea        edx, [edx + 16]
+    sub        ecx, 16
+    jg         wloop
+
+    ret
+  }
+}
+
+// Blends 32x1 rectangle to 16x1.
+__declspec(naked) void ScaleRowDown2Linear_SSSE3(const uint8_t* src_ptr,
+                                                 ptrdiff_t src_stride,
+                                                 uint8_t* dst_ptr,
+                                                 int dst_width) {
+  __asm {
+    mov        eax, [esp + 4]  // src_ptr
+    // src_stride
+    mov        edx, [esp + 12]  // dst_ptr
+    mov        ecx, [esp + 16]  // dst_width
+
+    pcmpeqb    xmm4, xmm4  // constant 0x0101
+    psrlw      xmm4, 15
+    packuswb   xmm4, xmm4
+    pxor       xmm5, xmm5  // constant 0
+
+  wloop:
+    movdqu     xmm0, [eax]
+    movdqu     xmm1, [eax + 16]
+    lea        eax,  [eax + 32]
+    pmaddubsw  xmm0, xmm4  // horizontal add
+    pmaddubsw  xmm1, xmm4
+    pavgw      xmm0, xmm5       // (x + 1) / 2
+    pavgw      xmm1, xmm5
+    packuswb   xmm0, xmm1
+    movdqu     [edx], xmm0
+    lea        edx, [edx + 16]
+    sub        ecx, 16
+    jg         wloop
+
+    ret
+  }
+}
+
+// Blends 32x2 rectangle to 16x1.
+__declspec(naked) void ScaleRowDown2Box_SSSE3(const uint8_t* src_ptr,
+                                              ptrdiff_t src_stride,
+                                              uint8_t* dst_ptr,
+                                              int dst_width) {
+  __asm {
+    push       esi
+    mov        eax, [esp + 4 + 4]  // src_ptr
+    mov        esi, [esp + 4 + 8]  // src_stride
+    mov        edx, [esp + 4 + 12]  // dst_ptr
+    mov        ecx, [esp + 4 + 16]  // dst_width
+
+    pcmpeqb    xmm4, xmm4  // constant 0x0101
+    psrlw      xmm4, 15
+    packuswb   xmm4, xmm4
+    pxor       xmm5, xmm5  // constant 0
+
+  wloop:
+    movdqu     xmm0, [eax]
+    movdqu     xmm1, [eax + 16]
+    movdqu     xmm2, [eax + esi]
+    movdqu     xmm3, [eax + esi + 16]
+    lea        eax,  [eax + 32]
+    pmaddubsw  xmm0, xmm4  // horizontal add
+    pmaddubsw  xmm1, xmm4
+    pmaddubsw  xmm2, xmm4
+    pmaddubsw  xmm3, xmm4
+    paddw      xmm0, xmm2  // vertical add
+    paddw      xmm1, xmm3
+    psrlw      xmm0, 1
+    psrlw      xmm1, 1
+    pavgw      xmm0, xmm5  // (x + 1) / 2
+    pavgw      xmm1, xmm5
+    packuswb   xmm0, xmm1
+    movdqu     [edx], xmm0
+    lea        edx, [edx + 16]
+    sub        ecx, 16
+    jg         wloop
+
+    pop        esi
+    ret
+  }
+}
+
+#ifdef HAS_SCALEROWDOWN2_AVX2
+// Reads 64 pixels, throws half away and writes 32 pixels.
+__declspec(naked) void ScaleRowDown2_AVX2(const uint8_t* src_ptr,
+                                          ptrdiff_t src_stride,
+                                          uint8_t* dst_ptr,
+                                          int dst_width) {
+  __asm {
+    mov        eax, [esp + 4]  // src_ptr
+    // src_stride ignored
+    mov        edx, [esp + 12]  // dst_ptr
+    mov        ecx, [esp + 16]  // dst_width
+
+  wloop:
+    vmovdqu     ymm0, [eax]
+    vmovdqu     ymm1, [eax + 32]
+    lea         eax,  [eax + 64]
+    vpsrlw      ymm0, ymm0, 8  // isolate odd pixels.
+    vpsrlw      ymm1, ymm1, 8
+    vpackuswb   ymm0, ymm0, ymm1
+    vpermq      ymm0, ymm0, 0xd8       // unmutate vpackuswb
+    vmovdqu     [edx], ymm0
+    lea         edx, [edx + 32]
+    sub         ecx, 32
+    jg          wloop
+
+    vzeroupper
+    ret
+  }
+}
+
+// Blends 64x1 rectangle to 32x1.
+__declspec(naked) void ScaleRowDown2Linear_AVX2(const uint8_t* src_ptr,
+                                                ptrdiff_t src_stride,
+                                                uint8_t* dst_ptr,
+                                                int dst_width) {
+  __asm {
+    mov         eax, [esp + 4]  // src_ptr
+    // src_stride
+    mov         edx, [esp + 12]  // dst_ptr
+    mov         ecx, [esp + 16]  // dst_width
+
+    vpcmpeqb    ymm4, ymm4, ymm4  // '1' constant, 8b
+    vpsrlw      ymm4, ymm4, 15
+    vpackuswb   ymm4, ymm4, ymm4
+    vpxor       ymm5, ymm5, ymm5  // constant 0
+
+  wloop:
+    vmovdqu     ymm0, [eax]
+    vmovdqu     ymm1, [eax + 32]
+    lea         eax,  [eax + 64]
+    vpmaddubsw  ymm0, ymm0, ymm4  // horizontal add
+    vpmaddubsw  ymm1, ymm1, ymm4
+    vpavgw      ymm0, ymm0, ymm5  // (x + 1) / 2
+    vpavgw      ymm1, ymm1, ymm5
+    vpackuswb   ymm0, ymm0, ymm1
+    vpermq      ymm0, ymm0, 0xd8       // unmutate vpackuswb
+    vmovdqu     [edx], ymm0
+    lea         edx, [edx + 32]
+    sub         ecx, 32
+    jg          wloop
+
+    vzeroupper
+    ret
+  }
+}
+
+// For rounding, average = (sum + 2) / 4
+// becomes average((sum >> 1), 0)
+// Blends 64x2 rectangle to 32x1.
+__declspec(naked) void ScaleRowDown2Box_AVX2(const uint8_t* src_ptr,
+                                             ptrdiff_t src_stride,
+                                             uint8_t* dst_ptr,
+                                             int dst_width) {
+  __asm {
+    push        esi
+    mov         eax, [esp + 4 + 4]  // src_ptr
+    mov         esi, [esp + 4 + 8]  // src_stride
+    mov         edx, [esp + 4 + 12]  // dst_ptr
+    mov         ecx, [esp + 4 + 16]  // dst_width
+
+    vpcmpeqb    ymm4, ymm4, ymm4  // '1' constant, 8b
+    vpsrlw      ymm4, ymm4, 15
+    vpackuswb   ymm4, ymm4, ymm4
+    vpxor       ymm5, ymm5, ymm5  // constant 0
+
+  wloop:
+    vmovdqu     ymm0, [eax]
+    vmovdqu     ymm1, [eax + 32]
+    vmovdqu     ymm2, [eax + esi]
+    vmovdqu     ymm3, [eax + esi + 32]
+    lea         eax,  [eax + 64]
+    vpmaddubsw  ymm0, ymm0, ymm4  // horizontal add
+    vpmaddubsw  ymm1, ymm1, ymm4
+    vpmaddubsw  ymm2, ymm2, ymm4
+    vpmaddubsw  ymm3, ymm3, ymm4
+    vpaddw      ymm0, ymm0, ymm2  // vertical add
+    vpaddw      ymm1, ymm1, ymm3
+    vpsrlw      ymm0, ymm0, 1  // (x + 2) / 4 = (x / 2 + 1) / 2
+    vpsrlw      ymm1, ymm1, 1
+    vpavgw      ymm0, ymm0, ymm5  // (x + 1) / 2
+    vpavgw      ymm1, ymm1, ymm5
+    vpackuswb   ymm0, ymm0, ymm1
+    vpermq      ymm0, ymm0, 0xd8  // unmutate vpackuswb
+    vmovdqu     [edx], ymm0
+    lea         edx, [edx + 32]
+    sub         ecx, 32
+    jg          wloop
+
+    pop         esi
+    vzeroupper
+    ret
+  }
+}
+#endif  // HAS_SCALEROWDOWN2_AVX2
+
+// Point samples 32 pixels to 8 pixels.
+__declspec(naked) void ScaleRowDown4_SSSE3(const uint8_t* src_ptr,
+                                           ptrdiff_t src_stride,
+                                           uint8_t* dst_ptr,
+                                           int dst_width) {
+  __asm {
+    mov        eax, [esp + 4]  // src_ptr
+    // src_stride ignored
+    mov        edx, [esp + 12]  // dst_ptr
+    mov        ecx, [esp + 16]  // dst_width
+    pcmpeqb    xmm5, xmm5       // generate mask 0x00ff0000
+    psrld      xmm5, 24
+    pslld      xmm5, 16
+
+  wloop:
+    movdqu     xmm0, [eax]
+    movdqu     xmm1, [eax + 16]
+    lea        eax,  [eax + 32]
+    pand       xmm0, xmm5
+    pand       xmm1, xmm5
+    packuswb   xmm0, xmm1
+    psrlw      xmm0, 8
+    packuswb   xmm0, xmm0
+    movq       qword ptr [edx], xmm0
+    lea        edx, [edx + 8]
+    sub        ecx, 8
+    jg         wloop
+
+    ret
+  }
+}
+
+// Blends 32x4 rectangle to 8x1.
+__declspec(naked) void ScaleRowDown4Box_SSSE3(const uint8_t* src_ptr,
+                                              ptrdiff_t src_stride,
+                                              uint8_t* dst_ptr,
+                                              int dst_width) {
+  __asm {
+    push       esi
+    push       edi
+    mov        eax, [esp + 8 + 4]  // src_ptr
+    mov        esi, [esp + 8 + 8]  // src_stride
+    mov        edx, [esp + 8 + 12]  // dst_ptr
+    mov        ecx, [esp + 8 + 16]  // dst_width
+    lea        edi, [esi + esi * 2]  // src_stride * 3
+    pcmpeqb    xmm4, xmm4  // constant 0x0101
+    psrlw      xmm4, 15
+    movdqa     xmm5, xmm4
+    packuswb   xmm4, xmm4
+    psllw      xmm5, 3  // constant 0x0008
+
+  wloop:
+    movdqu     xmm0, [eax]  // average rows
+    movdqu     xmm1, [eax + 16]
+    movdqu     xmm2, [eax + esi]
+    movdqu     xmm3, [eax + esi + 16]
+    pmaddubsw  xmm0, xmm4  // horizontal add
+    pmaddubsw  xmm1, xmm4
+    pmaddubsw  xmm2, xmm4
+    pmaddubsw  xmm3, xmm4
+    paddw      xmm0, xmm2  // vertical add rows 0, 1
+    paddw      xmm1, xmm3
+    movdqu     xmm2, [eax + esi * 2]
+    movdqu     xmm3, [eax + esi * 2 + 16]
+    pmaddubsw  xmm2, xmm4
+    pmaddubsw  xmm3, xmm4
+    paddw      xmm0, xmm2  // add row 2
+    paddw      xmm1, xmm3
+    movdqu     xmm2, [eax + edi]
+    movdqu     xmm3, [eax + edi + 16]
+    lea        eax, [eax + 32]
+    pmaddubsw  xmm2, xmm4
+    pmaddubsw  xmm3, xmm4
+    paddw      xmm0, xmm2  // add row 3
+    paddw      xmm1, xmm3
+    phaddw     xmm0, xmm1
+    paddw      xmm0, xmm5  // + 8 for round
+    psrlw      xmm0, 4  // /16 for average of 4 * 4
+    packuswb   xmm0, xmm0
+    movq       qword ptr [edx], xmm0
+    lea        edx, [edx + 8]
+    sub        ecx, 8
+    jg         wloop
+
+    pop        edi
+    pop        esi
+    ret
+  }
+}
+
+#ifdef HAS_SCALEROWDOWN4_AVX2
+// Point samples 64 pixels to 16 pixels.
+__declspec(naked) void ScaleRowDown4_AVX2(const uint8_t* src_ptr,
+                                          ptrdiff_t src_stride,
+                                          uint8_t* dst_ptr,
+                                          int dst_width) {
+  __asm {
+    mov         eax, [esp + 4]  // src_ptr
+    // src_stride ignored
+    mov         edx, [esp + 12]  // dst_ptr
+    mov         ecx, [esp + 16]  // dst_width
+    vpcmpeqb    ymm5, ymm5, ymm5  // generate mask 0x00ff0000
+    vpsrld      ymm5, ymm5, 24
+    vpslld      ymm5, ymm5, 16
+
+  wloop:
+    vmovdqu     ymm0, [eax]
+    vmovdqu     ymm1, [eax + 32]
+    lea         eax,  [eax + 64]
+    vpand       ymm0, ymm0, ymm5
+    vpand       ymm1, ymm1, ymm5
+    vpackuswb   ymm0, ymm0, ymm1
+    vpermq      ymm0, ymm0, 0xd8  // unmutate vpackuswb
+    vpsrlw      ymm0, ymm0, 8
+    vpackuswb   ymm0, ymm0, ymm0
+    vpermq      ymm0, ymm0, 0xd8       // unmutate vpackuswb
+    vmovdqu     [edx], xmm0
+    lea         edx, [edx + 16]
+    sub         ecx, 16
+    jg          wloop
+
+    vzeroupper
+    ret
+  }
+}
+
+// Blends 64x4 rectangle to 16x1.
+__declspec(naked) void ScaleRowDown4Box_AVX2(const uint8_t* src_ptr,
+                                             ptrdiff_t src_stride,
+                                             uint8_t* dst_ptr,
+                                             int dst_width) {
+  __asm {
+    push        esi
+    push        edi
+    mov         eax, [esp + 8 + 4]  // src_ptr
+    mov         esi, [esp + 8 + 8]  // src_stride
+    mov         edx, [esp + 8 + 12]  // dst_ptr
+    mov         ecx, [esp + 8 + 16]  // dst_width
+    lea         edi, [esi + esi * 2]  // src_stride * 3
+    vpcmpeqb    ymm4, ymm4, ymm4  // constant 0x0101
+    vpsrlw      ymm4, ymm4, 15
+    vpsllw      ymm5, ymm4, 3  // constant 0x0008
+    vpackuswb   ymm4, ymm4, ymm4
+
+  wloop:
+    vmovdqu     ymm0, [eax]  // average rows
+    vmovdqu     ymm1, [eax + 32]
+    vmovdqu     ymm2, [eax + esi]
+    vmovdqu     ymm3, [eax + esi + 32]
+    vpmaddubsw  ymm0, ymm0, ymm4  // horizontal add
+    vpmaddubsw  ymm1, ymm1, ymm4
+    vpmaddubsw  ymm2, ymm2, ymm4
+    vpmaddubsw  ymm3, ymm3, ymm4
+    vpaddw      ymm0, ymm0, ymm2  // vertical add rows 0, 1
+    vpaddw      ymm1, ymm1, ymm3
+    vmovdqu     ymm2, [eax + esi * 2]
+    vmovdqu     ymm3, [eax + esi * 2 + 32]
+    vpmaddubsw  ymm2, ymm2, ymm4
+    vpmaddubsw  ymm3, ymm3, ymm4
+    vpaddw      ymm0, ymm0, ymm2  // add row 2
+    vpaddw      ymm1, ymm1, ymm3
+    vmovdqu     ymm2, [eax + edi]
+    vmovdqu     ymm3, [eax + edi + 32]
+    lea         eax,  [eax + 64]
+    vpmaddubsw  ymm2, ymm2, ymm4
+    vpmaddubsw  ymm3, ymm3, ymm4
+    vpaddw      ymm0, ymm0, ymm2  // add row 3
+    vpaddw      ymm1, ymm1, ymm3
+    vphaddw     ymm0, ymm0, ymm1  // mutates
+    vpermq      ymm0, ymm0, 0xd8  // unmutate vphaddw
+    vpaddw      ymm0, ymm0, ymm5  // + 8 for round
+    vpsrlw      ymm0, ymm0, 4  // /32 for average of 4 * 4
+    vpackuswb   ymm0, ymm0, ymm0
+    vpermq      ymm0, ymm0, 0xd8  // unmutate vpackuswb
+    vmovdqu     [edx], xmm0
+    lea         edx, [edx + 16]
+    sub         ecx, 16
+    jg          wloop
+
+    pop        edi
+    pop        esi
+    vzeroupper
+    ret
+  }
+}
+#endif  // HAS_SCALEROWDOWN4_AVX2
+
+// Point samples 32 pixels to 24 pixels.
+// Produces three 8 byte values. For each 8 bytes, 16 bytes are read.
+// Then shuffled to do the scaling.
+
+__declspec(naked) void ScaleRowDown34_SSSE3(const uint8_t* src_ptr,
+                                            ptrdiff_t src_stride,
+                                            uint8_t* dst_ptr,
+                                            int dst_width) {
+  __asm {
+    mov        eax, [esp + 4]   // src_ptr
+    // src_stride ignored
+    mov        edx, [esp + 12]  // dst_ptr
+    mov        ecx, [esp + 16]  // dst_width
+    movdqa     xmm3, xmmword ptr kShuf0
+    movdqa     xmm4, xmmword ptr kShuf1
+    movdqa     xmm5, xmmword ptr kShuf2
+
+  wloop:
+    movdqu     xmm0, [eax]
+    movdqu     xmm1, [eax + 16]
+    lea        eax,  [eax + 32]
+    movdqa     xmm2, xmm1
+    palignr    xmm1, xmm0, 8
+    pshufb     xmm0, xmm3
+    pshufb     xmm1, xmm4
+    pshufb     xmm2, xmm5
+    movq       qword ptr [edx], xmm0
+    movq       qword ptr [edx + 8], xmm1
+    movq       qword ptr [edx + 16], xmm2
+    lea        edx, [edx + 24]
+    sub        ecx, 24
+    jg         wloop
+
+    ret
+  }
+}
+
+// Blends 32x2 rectangle to 24x1
+// Produces three 8 byte values. For each 8 bytes, 16 bytes are read.
+// Then shuffled to do the scaling.
+
+// Register usage:
+// xmm0 src_row 0
+// xmm1 src_row 1
+// xmm2 shuf 0
+// xmm3 shuf 1
+// xmm4 shuf 2
+// xmm5 madd 0
+// xmm6 madd 1
+// xmm7 kRound34
+
+// Note that movdqa+palign may be better than movdqu.
+__declspec(naked) void ScaleRowDown34_1_Box_SSSE3(const uint8_t* src_ptr,
+                                                  ptrdiff_t src_stride,
+                                                  uint8_t* dst_ptr,
+                                                  int dst_width) {
+  __asm {
+    push       esi
+    mov        eax, [esp + 4 + 4]  // src_ptr
+    mov        esi, [esp + 4 + 8]  // src_stride
+    mov        edx, [esp + 4 + 12]  // dst_ptr
+    mov        ecx, [esp + 4 + 16]  // dst_width
+    movdqa     xmm2, xmmword ptr kShuf01
+    movdqa     xmm3, xmmword ptr kShuf11
+    movdqa     xmm4, xmmword ptr kShuf21
+    movdqa     xmm5, xmmword ptr kMadd01
+    movdqa     xmm6, xmmword ptr kMadd11
+    movdqa     xmm7, xmmword ptr kRound34
+
+  wloop:
+    movdqu     xmm0, [eax]  // pixels 0..7
+    movdqu     xmm1, [eax + esi]
+    pavgb      xmm0, xmm1
+    pshufb     xmm0, xmm2
+    pmaddubsw  xmm0, xmm5
+    paddsw     xmm0, xmm7
+    psrlw      xmm0, 2
+    packuswb   xmm0, xmm0
+    movq       qword ptr [edx], xmm0
+    movdqu     xmm0, [eax + 8]  // pixels 8..15
+    movdqu     xmm1, [eax + esi + 8]
+    pavgb      xmm0, xmm1
+    pshufb     xmm0, xmm3
+    pmaddubsw  xmm0, xmm6
+    paddsw     xmm0, xmm7
+    psrlw      xmm0, 2
+    packuswb   xmm0, xmm0
+    movq       qword ptr [edx + 8], xmm0
+    movdqu     xmm0, [eax + 16]  // pixels 16..23
+    movdqu     xmm1, [eax + esi + 16]
+    lea        eax, [eax + 32]
+    pavgb      xmm0, xmm1
+    pshufb     xmm0, xmm4
+    movdqa     xmm1, xmmword ptr kMadd21
+    pmaddubsw  xmm0, xmm1
+    paddsw     xmm0, xmm7
+    psrlw      xmm0, 2
+    packuswb   xmm0, xmm0
+    movq       qword ptr [edx + 16], xmm0
+    lea        edx, [edx + 24]
+    sub        ecx, 24
+    jg         wloop
+
+    pop        esi
+    ret
+  }
+}
+
+// Note that movdqa+palign may be better than movdqu.
+__declspec(naked) void ScaleRowDown34_0_Box_SSSE3(const uint8_t* src_ptr,
+                                                  ptrdiff_t src_stride,
+                                                  uint8_t* dst_ptr,
+                                                  int dst_width) {
+  __asm {
+    push       esi
+    mov        eax, [esp + 4 + 4]  // src_ptr
+    mov        esi, [esp + 4 + 8]  // src_stride
+    mov        edx, [esp + 4 + 12]  // dst_ptr
+    mov        ecx, [esp + 4 + 16]  // dst_width
+    movdqa     xmm2, xmmword ptr kShuf01
+    movdqa     xmm3, xmmword ptr kShuf11
+    movdqa     xmm4, xmmword ptr kShuf21
+    movdqa     xmm5, xmmword ptr kMadd01
+    movdqa     xmm6, xmmword ptr kMadd11
+    movdqa     xmm7, xmmword ptr kRound34
+
+  wloop:
+    movdqu     xmm0, [eax]  // pixels 0..7
+    movdqu     xmm1, [eax + esi]
+    pavgb      xmm1, xmm0
+    pavgb      xmm0, xmm1
+    pshufb     xmm0, xmm2
+    pmaddubsw  xmm0, xmm5
+    paddsw     xmm0, xmm7
+    psrlw      xmm0, 2
+    packuswb   xmm0, xmm0
+    movq       qword ptr [edx], xmm0
+    movdqu     xmm0, [eax + 8]  // pixels 8..15
+    movdqu     xmm1, [eax + esi + 8]
+    pavgb      xmm1, xmm0
+    pavgb      xmm0, xmm1
+    pshufb     xmm0, xmm3
+    pmaddubsw  xmm0, xmm6
+    paddsw     xmm0, xmm7
+    psrlw      xmm0, 2
+    packuswb   xmm0, xmm0
+    movq       qword ptr [edx + 8], xmm0
+    movdqu     xmm0, [eax + 16]  // pixels 16..23
+    movdqu     xmm1, [eax + esi + 16]
+    lea        eax, [eax + 32]
+    pavgb      xmm1, xmm0
+    pavgb      xmm0, xmm1
+    pshufb     xmm0, xmm4
+    movdqa     xmm1, xmmword ptr kMadd21
+    pmaddubsw  xmm0, xmm1
+    paddsw     xmm0, xmm7
+    psrlw      xmm0, 2
+    packuswb   xmm0, xmm0
+    movq       qword ptr [edx + 16], xmm0
+    lea        edx, [edx+24]
+    sub        ecx, 24
+    jg         wloop
+
+    pop        esi
+    ret
+  }
+}
+
+// 3/8 point sampler
+
+// Scale 32 pixels to 12
+__declspec(naked) void ScaleRowDown38_SSSE3(const uint8_t* src_ptr,
+                                            ptrdiff_t src_stride,
+                                            uint8_t* dst_ptr,
+                                            int dst_width) {
+  __asm {
+    mov        eax, [esp + 4]  // src_ptr
+    // src_stride ignored
+    mov        edx, [esp + 12]  // dst_ptr
+    mov        ecx, [esp + 16]  // dst_width
+    movdqa     xmm4, xmmword ptr kShuf38a
+    movdqa     xmm5, xmmword ptr kShuf38b
+
+  xloop:
+    movdqu     xmm0, [eax]  // 16 pixels -> 0,1,2,3,4,5
+    movdqu     xmm1, [eax + 16]  // 16 pixels -> 6,7,8,9,10,11
+    lea        eax, [eax + 32]
+    pshufb     xmm0, xmm4
+    pshufb     xmm1, xmm5
+    paddusb    xmm0, xmm1
+
+    movq       qword ptr [edx], xmm0       // write 12 pixels
+    movhlps    xmm1, xmm0
+    movd       [edx + 8], xmm1
+    lea        edx, [edx + 12]
+    sub        ecx, 12
+    jg         xloop
+
+    ret
+  }
+}
+
+// Scale 16x3 pixels to 6x1 with interpolation
+__declspec(naked) void ScaleRowDown38_3_Box_SSSE3(const uint8_t* src_ptr,
+                                                  ptrdiff_t src_stride,
+                                                  uint8_t* dst_ptr,
+                                                  int dst_width) {
+  __asm {
+    push       esi
+    mov        eax, [esp + 4 + 4]  // src_ptr
+    mov        esi, [esp + 4 + 8]  // src_stride
+    mov        edx, [esp + 4 + 12]  // dst_ptr
+    mov        ecx, [esp + 4 + 16]  // dst_width
+    movdqa     xmm2, xmmword ptr kShufAc
+    movdqa     xmm3, xmmword ptr kShufAc3
+    movdqa     xmm4, xmmword ptr kScaleAc33
+    pxor       xmm5, xmm5
+
+  xloop:
+    movdqu     xmm0, [eax]  // sum up 3 rows into xmm0/1
+    movdqu     xmm6, [eax + esi]
+    movhlps    xmm1, xmm0
+    movhlps    xmm7, xmm6
+    punpcklbw  xmm0, xmm5
+    punpcklbw  xmm1, xmm5
+    punpcklbw  xmm6, xmm5
+    punpcklbw  xmm7, xmm5
+    paddusw    xmm0, xmm6
+    paddusw    xmm1, xmm7
+    movdqu     xmm6, [eax + esi * 2]
+    lea        eax, [eax + 16]
+    movhlps    xmm7, xmm6
+    punpcklbw  xmm6, xmm5
+    punpcklbw  xmm7, xmm5
+    paddusw    xmm0, xmm6
+    paddusw    xmm1, xmm7
+
+    movdqa     xmm6, xmm0  // 8 pixels -> 0,1,2 of xmm6
+    psrldq     xmm0, 2
+    paddusw    xmm6, xmm0
+    psrldq     xmm0, 2
+    paddusw    xmm6, xmm0
+    pshufb     xmm6, xmm2
+
+    movdqa     xmm7, xmm1  // 8 pixels -> 3,4,5 of xmm6
+    psrldq     xmm1, 2
+    paddusw    xmm7, xmm1
+    psrldq     xmm1, 2
+    paddusw    xmm7, xmm1
+    pshufb     xmm7, xmm3
+    paddusw    xmm6, xmm7
+
+    pmulhuw    xmm6, xmm4  // divide by 9,9,6, 9,9,6
+    packuswb   xmm6, xmm6
+
+    movd       [edx], xmm6  // write 6 pixels
+    psrlq      xmm6, 16
+    movd       [edx + 2], xmm6
+    lea        edx, [edx + 6]
+    sub        ecx, 6
+    jg         xloop
+
+    pop        esi
+    ret
+  }
+}
+
+// Scale 16x2 pixels to 6x1 with interpolation
+__declspec(naked) void ScaleRowDown38_2_Box_SSSE3(const uint8_t* src_ptr,
+                                                  ptrdiff_t src_stride,
+                                                  uint8_t* dst_ptr,
+                                                  int dst_width) {
+  __asm {
+    push       esi
+    mov        eax, [esp + 4 + 4]  // src_ptr
+    mov        esi, [esp + 4 + 8]  // src_stride
+    mov        edx, [esp + 4 + 12]  // dst_ptr
+    mov        ecx, [esp + 4 + 16]  // dst_width
+    movdqa     xmm2, xmmword ptr kShufAb0
+    movdqa     xmm3, xmmword ptr kShufAb1
+    movdqa     xmm4, xmmword ptr kShufAb2
+    movdqa     xmm5, xmmword ptr kScaleAb2
+
+  xloop:
+    movdqu     xmm0, [eax]  // average 2 rows into xmm0
+    movdqu     xmm1, [eax + esi]
+    lea        eax, [eax + 16]
+    pavgb      xmm0, xmm1
+
+    movdqa     xmm1, xmm0  // 16 pixels -> 0,1,2,3,4,5 of xmm1
+    pshufb     xmm1, xmm2
+    movdqa     xmm6, xmm0
+    pshufb     xmm6, xmm3
+    paddusw    xmm1, xmm6
+    pshufb     xmm0, xmm4
+    paddusw    xmm1, xmm0
+
+    pmulhuw    xmm1, xmm5  // divide by 3,3,2, 3,3,2
+    packuswb   xmm1, xmm1
+
+    movd       [edx], xmm1  // write 6 pixels
+    psrlq      xmm1, 16
+    movd       [edx + 2], xmm1
+    lea        edx, [edx + 6]
+    sub        ecx, 6
+    jg         xloop
+
+    pop        esi
+    ret
+  }
+}
+
+// Reads 16 bytes and accumulates to 16 shorts at a time.
+__declspec(naked) void ScaleAddRow_SSE2(const uint8_t* src_ptr,
+                                        uint16_t* dst_ptr,
+                                        int src_width) {
+  __asm {
+    mov        eax, [esp + 4]  // src_ptr
+    mov        edx, [esp + 8]  // dst_ptr
+    mov        ecx, [esp + 12]  // src_width
+    pxor       xmm5, xmm5
+
+        // sum rows
+  xloop:
+    movdqu     xmm3, [eax]  // read 16 bytes
+    lea        eax, [eax + 16]
+    movdqu     xmm0, [edx]  // read 16 words from destination
+    movdqu     xmm1, [edx + 16]
+    movdqa     xmm2, xmm3
+    punpcklbw  xmm2, xmm5
+    punpckhbw  xmm3, xmm5
+    paddusw    xmm0, xmm2  // sum 16 words
+    paddusw    xmm1, xmm3
+    movdqu     [edx], xmm0  // write 16 words to destination
+    movdqu     [edx + 16], xmm1
+    lea        edx, [edx + 32]
+    sub        ecx, 16
+    jg         xloop
+    ret
+  }
+}
+
+#ifdef HAS_SCALEADDROW_AVX2
+// Reads 32 bytes and accumulates to 32 shorts at a time.
+__declspec(naked) void ScaleAddRow_AVX2(const uint8_t* src_ptr,
+                                        uint16_t* dst_ptr,
+                                        int src_width) {
+  __asm {
+    mov         eax, [esp + 4]  // src_ptr
+    mov         edx, [esp + 8]  // dst_ptr
+    mov         ecx, [esp + 12]  // src_width
+    vpxor       ymm5, ymm5, ymm5
+
+        // sum rows
+  xloop:
+    vmovdqu     ymm3, [eax]  // read 32 bytes
+    lea         eax, [eax + 32]
+    vpermq      ymm3, ymm3, 0xd8  // unmutate for vpunpck
+    vpunpcklbw  ymm2, ymm3, ymm5
+    vpunpckhbw  ymm3, ymm3, ymm5
+    vpaddusw    ymm0, ymm2, [edx]  // sum 16 words
+    vpaddusw    ymm1, ymm3, [edx + 32]
+    vmovdqu     [edx], ymm0  // write 32 words to destination
+    vmovdqu     [edx + 32], ymm1
+    lea         edx, [edx + 64]
+    sub         ecx, 32
+    jg          xloop
+
+    vzeroupper
+    ret
+  }
+}
+#endif  // HAS_SCALEADDROW_AVX2
+
+// Constant for making pixels signed to avoid pmaddubsw
+// saturation.
+static const uvec8 kFsub80 = {0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
+                              0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80};
+
+// Constant for making pixels unsigned and adding .5 for rounding.
+static const uvec16 kFadd40 = {0x4040, 0x4040, 0x4040, 0x4040,
+                               0x4040, 0x4040, 0x4040, 0x4040};
+
+// Bilinear column filtering. SSSE3 version.
+__declspec(naked) void ScaleFilterCols_SSSE3(uint8_t* dst_ptr,
+                                             const uint8_t* src_ptr,
+                                             int dst_width,
+                                             int x,
+                                             int dx) {
+  __asm {
+    push       ebx
+    push       esi
+    push       edi
+    mov        edi, [esp + 12 + 4]  // dst_ptr
+    mov        esi, [esp + 12 + 8]  // src_ptr
+    mov        ecx, [esp + 12 + 12]  // dst_width
+    movd       xmm2, [esp + 12 + 16]  // x
+    movd       xmm3, [esp + 12 + 20]  // dx
+    mov        eax, 0x04040000  // shuffle to line up fractions with pixel.
+    movd       xmm5, eax
+    pcmpeqb    xmm6, xmm6  // generate 0x007f for inverting fraction.
+    psrlw      xmm6, 9
+    pcmpeqb    xmm7, xmm7  // generate 0x0001
+    psrlw      xmm7, 15
+    pextrw     eax, xmm2, 1  // get x0 integer. preroll
+    sub        ecx, 2
+    jl         xloop29
+
+    movdqa     xmm0, xmm2  // x1 = x0 + dx
+    paddd      xmm0, xmm3
+    punpckldq  xmm2, xmm0  // x0 x1
+    punpckldq  xmm3, xmm3  // dx dx
+    paddd      xmm3, xmm3  // dx * 2, dx * 2
+    pextrw     edx, xmm2, 3  // get x1 integer. preroll
+
+    // 2 Pixel loop.
+  xloop2:
+    movdqa     xmm1, xmm2  // x0, x1 fractions.
+    paddd      xmm2, xmm3  // x += dx
+    movzx      ebx, word ptr [esi + eax]  // 2 source x0 pixels
+    movd       xmm0, ebx
+    psrlw      xmm1, 9  // 7 bit fractions.
+    movzx      ebx, word ptr [esi + edx]  // 2 source x1 pixels
+    movd       xmm4, ebx
+    pshufb     xmm1, xmm5  // 0011
+    punpcklwd  xmm0, xmm4
+    psubb      xmm0, xmmword ptr kFsub80  // make pixels signed.
+    pxor       xmm1, xmm6  // 0..7f and 7f..0
+    paddusb    xmm1, xmm7  // +1 so 0..7f and 80..1
+    pmaddubsw  xmm1, xmm0  // 16 bit, 2 pixels.
+    pextrw     eax, xmm2, 1  // get x0 integer. next iteration.
+    pextrw     edx, xmm2, 3  // get x1 integer. next iteration.
+    paddw      xmm1, xmmword ptr kFadd40  // make pixels unsigned and round.
+    psrlw      xmm1, 7  // 8.7 fixed point to low 8 bits.
+    packuswb   xmm1, xmm1  // 8 bits, 2 pixels.
+    movd       ebx, xmm1
+    mov        [edi], bx
+    lea        edi, [edi + 2]
+    sub        ecx, 2  // 2 pixels
+    jge        xloop2
+
+ xloop29:
+    add        ecx, 2 - 1
+    jl         xloop99
+
+            // 1 pixel remainder
+    movzx      ebx, word ptr [esi + eax]  // 2 source x0 pixels
+    movd       xmm0, ebx
+    psrlw      xmm2, 9  // 7 bit fractions.
+    pshufb     xmm2, xmm5  // 0011
+    psubb      xmm0, xmmword ptr kFsub80  // make pixels signed.
+    pxor       xmm2, xmm6  // 0..7f and 7f..0
+    paddusb    xmm2, xmm7  // +1 so 0..7f and 80..1
+    pmaddubsw  xmm2, xmm0  // 16 bit
+    paddw      xmm2, xmmword ptr kFadd40  // make pixels unsigned and round.
+    psrlw      xmm2, 7  // 8.7 fixed point to low 8 bits.
+    packuswb   xmm2, xmm2  // 8 bits
+    movd       ebx, xmm2
+    mov        [edi], bl
+
+ xloop99:
+
+    pop        edi
+    pop        esi
+    pop        ebx
+    ret
+  }
+}
+
+// Reads 16 pixels, duplicates them and writes 32 pixels.
+__declspec(naked) void ScaleColsUp2_SSE2(uint8_t* dst_ptr,
+                                         const uint8_t* src_ptr,
+                                         int dst_width,
+                                         int x,
+                                         int dx) {
+  __asm {
+    mov        edx, [esp + 4]  // dst_ptr
+    mov        eax, [esp + 8]  // src_ptr
+    mov        ecx, [esp + 12]  // dst_width
+
+  wloop:
+    movdqu     xmm0, [eax]
+    lea        eax,  [eax + 16]
+    movdqa     xmm1, xmm0
+    punpcklbw  xmm0, xmm0
+    punpckhbw  xmm1, xmm1
+    movdqu     [edx], xmm0
+    movdqu     [edx + 16], xmm1
+    lea        edx, [edx + 32]
+    sub        ecx, 32
+    jg         wloop
+
+    ret
+  }
+}
+
+// Reads 8 pixels, throws half away and writes 4 even pixels (0, 2, 4, 6)
+__declspec(naked) void ScaleARGBRowDown2_SSE2(const uint8_t* src_argb,
+                                              ptrdiff_t src_stride,
+                                              uint8_t* dst_argb,
+                                              int dst_width) {
+  __asm {
+    mov        eax, [esp + 4]   // src_argb
+    // src_stride ignored
+    mov        edx, [esp + 12]  // dst_argb
+    mov        ecx, [esp + 16]  // dst_width
+
+  wloop:
+    movdqu     xmm0, [eax]
+    movdqu     xmm1, [eax + 16]
+    lea        eax,  [eax + 32]
+    shufps     xmm0, xmm1, 0xdd
+    movdqu     [edx], xmm0
+    lea        edx, [edx + 16]
+    sub        ecx, 4
+    jg         wloop
+
+    ret
+  }
+}
+
+// Blends 8x1 rectangle to 4x1.
+__declspec(naked) void ScaleARGBRowDown2Linear_SSE2(const uint8_t* src_argb,
+                                                    ptrdiff_t src_stride,
+                                                    uint8_t* dst_argb,
+                                                    int dst_width) {
+  __asm {
+    mov        eax, [esp + 4]  // src_argb
+    // src_stride ignored
+    mov        edx, [esp + 12]  // dst_argb
+    mov        ecx, [esp + 16]  // dst_width
+
+  wloop:
+    movdqu     xmm0, [eax]
+    movdqu     xmm1, [eax + 16]
+    lea        eax,  [eax + 32]
+    movdqa     xmm2, xmm0
+    shufps     xmm0, xmm1, 0x88  // even pixels
+    shufps     xmm2, xmm1, 0xdd       // odd pixels
+    pavgb      xmm0, xmm2
+    movdqu     [edx], xmm0
+    lea        edx, [edx + 16]
+    sub        ecx, 4
+    jg         wloop
+
+    ret
+  }
+}
+
+// Blends 8x2 rectangle to 4x1.
+__declspec(naked) void ScaleARGBRowDown2Box_SSE2(const uint8_t* src_argb,
+                                                 ptrdiff_t src_stride,
+                                                 uint8_t* dst_argb,
+                                                 int dst_width) {
+  __asm {
+    push       esi
+    mov        eax, [esp + 4 + 4]  // src_argb
+    mov        esi, [esp + 4 + 8]  // src_stride
+    mov        edx, [esp + 4 + 12]  // dst_argb
+    mov        ecx, [esp + 4 + 16]  // dst_width
+
+  wloop:
+    movdqu     xmm0, [eax]
+    movdqu     xmm1, [eax + 16]
+    movdqu     xmm2, [eax + esi]
+    movdqu     xmm3, [eax + esi + 16]
+    lea        eax,  [eax + 32]
+    pavgb      xmm0, xmm2  // average rows
+    pavgb      xmm1, xmm3
+    movdqa     xmm2, xmm0  // average columns (8 to 4 pixels)
+    shufps     xmm0, xmm1, 0x88  // even pixels
+    shufps     xmm2, xmm1, 0xdd  // odd pixels
+    pavgb      xmm0, xmm2
+    movdqu     [edx], xmm0
+    lea        edx, [edx + 16]
+    sub        ecx, 4
+    jg         wloop
+
+    pop        esi
+    ret
+  }
+}
+
+// Reads 4 pixels at a time.
+__declspec(naked) void ScaleARGBRowDownEven_SSE2(const uint8_t* src_argb,
+                                                 ptrdiff_t src_stride,
+                                                 int src_stepx,
+                                                 uint8_t* dst_argb,
+                                                 int dst_width) {
+  __asm {
+    push       ebx
+    push       edi
+    mov        eax, [esp + 8 + 4]   // src_argb
+    // src_stride ignored
+    mov        ebx, [esp + 8 + 12]  // src_stepx
+    mov        edx, [esp + 8 + 16]  // dst_argb
+    mov        ecx, [esp + 8 + 20]  // dst_width
+    lea        ebx, [ebx * 4]
+    lea        edi, [ebx + ebx * 2]
+
+  wloop:
+    movd       xmm0, [eax]
+    movd       xmm1, [eax + ebx]
+    punpckldq  xmm0, xmm1
+    movd       xmm2, [eax + ebx * 2]
+    movd       xmm3, [eax + edi]
+    lea        eax,  [eax + ebx * 4]
+    punpckldq  xmm2, xmm3
+    punpcklqdq xmm0, xmm2
+    movdqu     [edx], xmm0
+    lea        edx, [edx + 16]
+    sub        ecx, 4
+    jg         wloop
+
+    pop        edi
+    pop        ebx
+    ret
+  }
+}
+
+// Blends four 2x2 to 4x1.
+__declspec(naked) void ScaleARGBRowDownEvenBox_SSE2(const uint8_t* src_argb,
+                                                    ptrdiff_t src_stride,
+                                                    int src_stepx,
+                                                    uint8_t* dst_argb,
+                                                    int dst_width) {
+  __asm {
+    push       ebx
+    push       esi
+    push       edi
+    mov        eax, [esp + 12 + 4]  // src_argb
+    mov        esi, [esp + 12 + 8]  // src_stride
+    mov        ebx, [esp + 12 + 12]  // src_stepx
+    mov        edx, [esp + 12 + 16]  // dst_argb
+    mov        ecx, [esp + 12 + 20]  // dst_width
+    lea        esi, [eax + esi]  // row1 pointer
+    lea        ebx, [ebx * 4]
+    lea        edi, [ebx + ebx * 2]
+
+  wloop:
+    movq       xmm0, qword ptr [eax]  // row0 4 pairs
+    movhps     xmm0, qword ptr [eax + ebx]
+    movq       xmm1, qword ptr [eax + ebx * 2]
+    movhps     xmm1, qword ptr [eax + edi]
+    lea        eax,  [eax + ebx * 4]
+    movq       xmm2, qword ptr [esi]  // row1 4 pairs
+    movhps     xmm2, qword ptr [esi + ebx]
+    movq       xmm3, qword ptr [esi + ebx * 2]
+    movhps     xmm3, qword ptr [esi + edi]
+    lea        esi,  [esi + ebx * 4]
+    pavgb      xmm0, xmm2  // average rows
+    pavgb      xmm1, xmm3
+    movdqa     xmm2, xmm0  // average columns (8 to 4 pixels)
+    shufps     xmm0, xmm1, 0x88  // even pixels
+    shufps     xmm2, xmm1, 0xdd  // odd pixels
+    pavgb      xmm0, xmm2
+    movdqu     [edx], xmm0
+    lea        edx, [edx + 16]
+    sub        ecx, 4
+    jg         wloop
+
+    pop        edi
+    pop        esi
+    pop        ebx
+    ret
+  }
+}
+
+// Column scaling unfiltered. SSE2 version.
+__declspec(naked) void ScaleARGBCols_SSE2(uint8_t* dst_argb,
+                                          const uint8_t* src_argb,
+                                          int dst_width,
+                                          int x,
+                                          int dx) {
+  __asm {
+    push       edi
+    push       esi
+    mov        edi, [esp + 8 + 4]  // dst_argb
+    mov        esi, [esp + 8 + 8]  // src_argb
+    mov        ecx, [esp + 8 + 12]  // dst_width
+    movd       xmm2, [esp + 8 + 16]  // x
+    movd       xmm3, [esp + 8 + 20]  // dx
+
+    pshufd     xmm2, xmm2, 0  // x0 x0 x0 x0
+    pshufd     xmm0, xmm3, 0x11  // dx  0 dx  0
+    paddd      xmm2, xmm0
+    paddd      xmm3, xmm3  // 0, 0, 0,  dx * 2
+    pshufd     xmm0, xmm3, 0x05  // dx * 2, dx * 2, 0, 0
+    paddd      xmm2, xmm0  // x3 x2 x1 x0
+    paddd      xmm3, xmm3  // 0, 0, 0,  dx * 4
+    pshufd     xmm3, xmm3, 0  // dx * 4, dx * 4, dx * 4, dx * 4
+
+    pextrw     eax, xmm2, 1  // get x0 integer.
+    pextrw     edx, xmm2, 3  // get x1 integer.
+
+    cmp        ecx, 0
+    jle        xloop99
+    sub        ecx, 4
+    jl         xloop49
+
+        // 4 Pixel loop.
+ xloop4:
+    movd       xmm0, [esi + eax * 4]  // 1 source x0 pixels
+    movd       xmm1, [esi + edx * 4]  // 1 source x1 pixels
+    pextrw     eax, xmm2, 5  // get x2 integer.
+    pextrw     edx, xmm2, 7  // get x3 integer.
+    paddd      xmm2, xmm3  // x += dx
+    punpckldq  xmm0, xmm1  // x0 x1
+
+    movd       xmm1, [esi + eax * 4]  // 1 source x2 pixels
+    movd       xmm4, [esi + edx * 4]  // 1 source x3 pixels
+    pextrw     eax, xmm2, 1  // get x0 integer. next iteration.
+    pextrw     edx, xmm2, 3  // get x1 integer. next iteration.
+    punpckldq  xmm1, xmm4  // x2 x3
+    punpcklqdq xmm0, xmm1  // x0 x1 x2 x3
+    movdqu     [edi], xmm0
+    lea        edi, [edi + 16]
+    sub        ecx, 4  // 4 pixels
+    jge        xloop4
+
+ xloop49:
+    test       ecx, 2
+    je         xloop29
+
+        // 2 Pixels.
+    movd       xmm0, [esi + eax * 4]  // 1 source x0 pixels
+    movd       xmm1, [esi + edx * 4]  // 1 source x1 pixels
+    pextrw     eax, xmm2, 5  // get x2 integer.
+    punpckldq  xmm0, xmm1  // x0 x1
+
+    movq       qword ptr [edi], xmm0
+    lea        edi, [edi + 8]
+
+ xloop29:
+    test       ecx, 1
+    je         xloop99
+
+        // 1 Pixels.
+    movd       xmm0, [esi + eax * 4]  // 1 source x2 pixels
+    movd       dword ptr [edi], xmm0
+ xloop99:
+
+    pop        esi
+    pop        edi
+    ret
+  }
+}
+
+// Bilinear row filtering combines 2x1 -> 1x1. SSSE3 version.
+// TODO(fbarchard): Port to Neon
+
+// Shuffle table for arranging 2 pixels into pairs for pmaddubsw
+static const uvec8 kShuffleColARGB = {
+    0u, 4u,  1u, 5u,  2u,  6u,  3u,  7u,  // bbggrraa 1st pixel
+    8u, 12u, 9u, 13u, 10u, 14u, 11u, 15u  // bbggrraa 2nd pixel
+};
+
+// Shuffle table for duplicating 2 fractions into 8 bytes each
+static const uvec8 kShuffleFractions = {
+    0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 4u, 4u, 4u, 4u, 4u, 4u, 4u, 4u,
+};
+
+__declspec(naked) void ScaleARGBFilterCols_SSSE3(uint8_t* dst_argb,
+                                                 const uint8_t* src_argb,
+                                                 int dst_width,
+                                                 int x,
+                                                 int dx) {
+  __asm {
+    push       esi
+    push       edi
+    mov        edi, [esp + 8 + 4]  // dst_argb
+    mov        esi, [esp + 8 + 8]  // src_argb
+    mov        ecx, [esp + 8 + 12]  // dst_width
+    movd       xmm2, [esp + 8 + 16]  // x
+    movd       xmm3, [esp + 8 + 20]  // dx
+    movdqa     xmm4, xmmword ptr kShuffleColARGB
+    movdqa     xmm5, xmmword ptr kShuffleFractions
+    pcmpeqb    xmm6, xmm6  // generate 0x007f for inverting fraction.
+    psrlw      xmm6, 9
+    pextrw     eax, xmm2, 1  // get x0 integer. preroll
+    sub        ecx, 2
+    jl         xloop29
+
+    movdqa     xmm0, xmm2  // x1 = x0 + dx
+    paddd      xmm0, xmm3
+    punpckldq  xmm2, xmm0  // x0 x1
+    punpckldq  xmm3, xmm3  // dx dx
+    paddd      xmm3, xmm3  // dx * 2, dx * 2
+    pextrw     edx, xmm2, 3  // get x1 integer. preroll
+
+    // 2 Pixel loop.
+  xloop2:
+    movdqa     xmm1, xmm2  // x0, x1 fractions.
+    paddd      xmm2, xmm3  // x += dx
+    movq       xmm0, qword ptr [esi + eax * 4]  // 2 source x0 pixels
+    psrlw      xmm1, 9  // 7 bit fractions.
+    movhps     xmm0, qword ptr [esi + edx * 4]  // 2 source x1 pixels
+    pshufb     xmm1, xmm5  // 0000000011111111
+    pshufb     xmm0, xmm4  // arrange pixels into pairs
+    pxor       xmm1, xmm6  // 0..7f and 7f..0
+    pmaddubsw  xmm0, xmm1  // argb_argb 16 bit, 2 pixels.
+    pextrw     eax, xmm2, 1  // get x0 integer. next iteration.
+    pextrw     edx, xmm2, 3  // get x1 integer. next iteration.
+    psrlw      xmm0, 7  // argb 8.7 fixed point to low 8 bits.
+    packuswb   xmm0, xmm0  // argb_argb 8 bits, 2 pixels.
+    movq       qword ptr [edi], xmm0
+    lea        edi, [edi + 8]
+    sub        ecx, 2  // 2 pixels
+    jge        xloop2
+
+ xloop29:
+
+    add        ecx, 2 - 1
+    jl         xloop99
+
+            // 1 pixel remainder
+    psrlw      xmm2, 9  // 7 bit fractions.
+    movq       xmm0, qword ptr [esi + eax * 4]  // 2 source x0 pixels
+    pshufb     xmm2, xmm5  // 00000000
+    pshufb     xmm0, xmm4  // arrange pixels into pairs
+    pxor       xmm2, xmm6  // 0..7f and 7f..0
+    pmaddubsw  xmm0, xmm2  // argb 16 bit, 1 pixel.
+    psrlw      xmm0, 7
+    packuswb   xmm0, xmm0  // argb 8 bits, 1 pixel.
+    movd       [edi], xmm0
+
+ xloop99:
+
+    pop        edi
+    pop        esi
+    ret
+  }
+}
+
+// Reads 4 pixels, duplicates them and writes 8 pixels.
+__declspec(naked) void ScaleARGBColsUp2_SSE2(uint8_t* dst_argb,
+                                             const uint8_t* src_argb,
+                                             int dst_width,
+                                             int x,
+                                             int dx) {
+  __asm {
+    mov        edx, [esp + 4]  // dst_argb
+    mov        eax, [esp + 8]  // src_argb
+    mov        ecx, [esp + 12]  // dst_width
+
+  wloop:
+    movdqu     xmm0, [eax]
+    lea        eax,  [eax + 16]
+    movdqa     xmm1, xmm0
+    punpckldq  xmm0, xmm0
+    punpckhdq  xmm1, xmm1
+    movdqu     [edx], xmm0
+    movdqu     [edx + 16], xmm1
+    lea        edx, [edx + 32]
+    sub        ecx, 8
+    jg         wloop
+
+    ret
+  }
+}
+
+// Divide num by div and return as 16.16 fixed point result.
+__declspec(naked) int FixedDiv_X86(int num, int div) {
+  __asm {
+    mov        eax, [esp + 4]  // num
+    cdq  // extend num to 64 bits
+    shld       edx, eax, 16  // 32.16
+    shl        eax, 16
+    idiv       dword ptr [esp + 8]
+    ret
+  }
+}
+
+// Divide num by div and return as 16.16 fixed point result.
+__declspec(naked) int FixedDiv1_X86(int num, int div) {
+  __asm {
+    mov        eax, [esp + 4]  // num
+    mov        ecx, [esp + 8]  // denom
+    cdq  // extend num to 64 bits
+    shld       edx, eax, 16  // 32.16
+    shl        eax, 16
+    sub        eax, 0x00010001
+    sbb        edx, 0
+    sub        ecx, 1
+    idiv       ecx
+    ret
+  }
+}
+#endif  // !defined(LIBYUV_DISABLE_X86) && defined(_M_IX86)
+
+#ifdef __cplusplus
+}  // extern "C"
+}  // namespace libyuv
+#endif
diff --git a/3rdparty/libyuv/src/source/test.sh b/3rdparty/libyuv/src/source/test.sh
new file mode 100644
index 00000000..7f12c3c1
--- /dev/null
+++ b/3rdparty/libyuv/src/source/test.sh
@@ -0,0 +1,35 @@
+#!/bin/bash
+set -x
+
+function runbenchmark1 {
+  perf record /google/src/cloud/fbarchard/clean/google3/blaze-bin/third_party/libyuv/libyuv_test --gunit_filter=*$1 --libyuv_width=1280 --libyuv_height=720 --libyuv_repeat=1000 --libyuv_flags=-1 --libyuv_cpu_info=-1
+  perf report | grep AVX
+}
+
+runbenchmark1 ABGRToI420
+runbenchmark1 Android420ToI420
+runbenchmark1 ARGBToI420
+runbenchmark1 Convert16To8Plane
+runbenchmark1 ConvertToARGB
+runbenchmark1 ConvertToI420
+runbenchmark1 CopyPlane
+runbenchmark1 H010ToAB30
+runbenchmark1 H010ToAR30
+runbenchmark1 HalfFloatPlane
+runbenchmark1 I010ToAB30
+runbenchmark1 I010ToAR30
+runbenchmark1 I420Copy
+runbenchmark1 I420Psnr
+runbenchmark1 I420Scale
+runbenchmark1 I420Ssim
+runbenchmark1 I420ToARGB
+runbenchmark1 I420ToNV12
+runbenchmark1 I420ToUYVY
+runbenchmark1 I422ToI420
+runbenchmark1 InitCpuFlags
+runbenchmark1 J420ToARGB
+runbenchmark1 NV12ToARGB
+runbenchmark1 NV12ToI420
+runbenchmark1 NV12ToI420Rotate
+runbenchmark1 SetCpuFlags
+runbenchmark1 YUY2ToI420
diff --git a/3rdparty/libyuv/src/source/video_common.cc b/3rdparty/libyuv/src/source/video_common.cc
new file mode 100644
index 00000000..92384c05
--- /dev/null
+++ b/3rdparty/libyuv/src/source/video_common.cc
@@ -0,0 +1,62 @@
+/*
+ *  Copyright 2011 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include "libyuv/video_common.h"
+
+#ifdef __cplusplus
+namespace libyuv {
+extern "C" {
+#endif
+
+struct FourCCAliasEntry {
+  uint32_t alias;
+  uint32_t canonical;
+};
+
+#define NUM_ALIASES 18
+static const struct FourCCAliasEntry kFourCCAliases[NUM_ALIASES] = {
+    {FOURCC_IYUV, FOURCC_I420},
+    {FOURCC_YU12, FOURCC_I420},
+    {FOURCC_YU16, FOURCC_I422},
+    {FOURCC_YU24, FOURCC_I444},
+    {FOURCC_YUYV, FOURCC_YUY2},
+    {FOURCC_YUVS, FOURCC_YUY2},  // kCMPixelFormat_422YpCbCr8_yuvs
+    {FOURCC_HDYC, FOURCC_UYVY},
+    {FOURCC_2VUY, FOURCC_UYVY},  // kCMPixelFormat_422YpCbCr8
+    {FOURCC_JPEG, FOURCC_MJPG},  // Note: JPEG has DHT while MJPG does not.
+    {FOURCC_DMB1, FOURCC_MJPG},
+    {FOURCC_BA81, FOURCC_BGGR},  // deprecated.
+    {FOURCC_RGB3, FOURCC_RAW},
+    {FOURCC_BGR3, FOURCC_24BG},
+    {FOURCC_CM32, FOURCC_BGRA},  // kCMPixelFormat_32ARGB
+    {FOURCC_CM24, FOURCC_RAW},   // kCMPixelFormat_24RGB
+    {FOURCC_L555, FOURCC_RGBO},  // kCMPixelFormat_16LE555
+    {FOURCC_L565, FOURCC_RGBP},  // kCMPixelFormat_16LE565
+    {FOURCC_5551, FOURCC_RGBO},  // kCMPixelFormat_16LE5551
+};
+// TODO(fbarchard): Consider mapping kCMPixelFormat_32BGRA to FOURCC_ARGB.
+//  {FOURCC_BGRA, FOURCC_ARGB},  // kCMPixelFormat_32BGRA
+
+LIBYUV_API
+uint32_t CanonicalFourCC(uint32_t fourcc) {
+  int i;
+  for (i = 0; i < NUM_ALIASES; ++i) {
+    if (kFourCCAliases[i].alias == fourcc) {
+      return kFourCCAliases[i].canonical;
+    }
+  }
+  // Not an alias, so return it as-is.
+  return fourcc;
+}
+
+#ifdef __cplusplus
+}  // extern "C"
+}  // namespace libyuv
+#endif
diff --git a/3rdparty/libyuv/src/tools_libyuv/OWNERS b/3rdparty/libyuv/src/tools_libyuv/OWNERS
new file mode 100644
index 00000000..aae4fb6e
--- /dev/null
+++ b/3rdparty/libyuv/src/tools_libyuv/OWNERS
@@ -0,0 +1,4 @@
+mbonadei@chromium.org
+fbarchard@chromium.org
+pbos@chromium.org
+
diff --git a/3rdparty/libyuv/src/tools_libyuv/autoroller/roll_deps.py b/3rdparty/libyuv/src/tools_libyuv/autoroller/roll_deps.py
new file mode 100644
index 00000000..977c86de
--- /dev/null
+++ b/3rdparty/libyuv/src/tools_libyuv/autoroller/roll_deps.py
@@ -0,0 +1,509 @@
+#!/usr/bin/env vpython3
+
+# Copyright 2017 The LibYuv Project Authors. All rights reserved.
+#
+# Use of this source code is governed by a BSD-style license
+# that can be found in the LICENSE file in the root of the source
+# tree. An additional intellectual property rights grant can be found
+# in the file PATENTS. All contributing project authors may
+# be found in the AUTHORS file in the root of the source tree.
+
+# This is a modified copy of the script in
+# https://webrtc.googlesource.com/src/+/master/tools_webrtc/autoroller/roll_deps.py
+# customized for libyuv.
+
+"""Script to automatically roll dependencies in the libyuv DEPS file."""
+
+import argparse
+import base64
+import collections
+import logging
+import os
+import re
+import subprocess
+import sys
+import urllib.request
+
+
+# Skip these dependencies (list without solution name prefix).
+DONT_AUTOROLL_THESE = [
+  'src/third_party/gflags/src',
+]
+
+LIBYUV_URL = 'https://chromium.googlesource.com/libyuv/libyuv'
+CHROMIUM_SRC_URL = 'https://chromium.googlesource.com/chromium/src'
+CHROMIUM_COMMIT_TEMPLATE = CHROMIUM_SRC_URL + '/+/%s'
+CHROMIUM_LOG_TEMPLATE = CHROMIUM_SRC_URL + '/+log/%s'
+CHROMIUM_FILE_TEMPLATE = CHROMIUM_SRC_URL + '/+/%s/%s'
+
+COMMIT_POSITION_RE = re.compile('^Cr-Commit-Position: .*#([0-9]+).*$')
+CLANG_REVISION_RE = re.compile(r'^CLANG_REVISION = \'([0-9a-z-]+)\'$')
+ROLL_BRANCH_NAME = 'roll_chromium_revision'
+
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+CHECKOUT_SRC_DIR = os.path.realpath(os.path.join(SCRIPT_DIR, os.pardir,
+                                                 os.pardir))
+CHECKOUT_ROOT_DIR = os.path.realpath(os.path.join(CHECKOUT_SRC_DIR, os.pardir))
+
+sys.path.append(os.path.join(CHECKOUT_SRC_DIR, 'build'))
+import find_depot_tools  # pylint: disable=wrong-import-position
+find_depot_tools.add_depot_tools_to_path()
+
+CLANG_UPDATE_SCRIPT_URL_PATH = 'tools/clang/scripts/update.py'
+CLANG_UPDATE_SCRIPT_LOCAL_PATH = os.path.join(CHECKOUT_SRC_DIR, 'tools',
+                                              'clang', 'scripts', 'update.py')
+
+DepsEntry = collections.namedtuple('DepsEntry', 'path url revision')
+ChangedDep = collections.namedtuple('ChangedDep',
+                                    'path url current_rev new_rev')
+
+class RollError(Exception):
+  pass
+
+
+def VarLookup(local_scope):
+  return lambda var_name: local_scope['vars'][var_name]
+
+
+def ParseDepsDict(deps_content):
+  local_scope = {}
+  global_scope = {
+    'Var': VarLookup(local_scope),
+    'Str': lambda s: s,
+    'deps_os': {},
+  }
+  exec(deps_content, global_scope, local_scope)
+  return local_scope
+
+
+def ParseLocalDepsFile(filename):
+  with open(filename, 'rb') as f:
+    deps_content = f.read().decode('utf-8')
+  return ParseDepsDict(deps_content)
+
+
+def ParseRemoteCrDepsFile(revision):
+  deps_content = ReadRemoteCrFile('DEPS', revision)
+  return ParseDepsDict(deps_content)
+
+
+def ParseCommitPosition(commit_message):
+  for line in reversed(commit_message.splitlines()):
+    m = COMMIT_POSITION_RE.match(line.strip())
+    if m:
+      return int(m.group(1))
+  logging.error('Failed to parse commit position id from:\n%s\n',
+                commit_message)
+  sys.exit(-1)
+
+
+def _RunCommand(command, working_dir=None, ignore_exit_code=False,
+                extra_env=None, input_data=None):
+  """Runs a command and returns the output from that command.
+
+  If the command fails (exit code != 0), the function will exit the process.
+
+  Returns:
+    A tuple containing the stdout and stderr outputs as strings.
+  """
+  working_dir = working_dir or CHECKOUT_SRC_DIR
+  logging.debug('CMD: %s CWD: %s', ' '.join(command), working_dir)
+  env = os.environ.copy()
+  if extra_env:
+    assert all(isinstance(value, str) for value in extra_env.values())
+    logging.debug('extra env: %s', extra_env)
+    env.update(extra_env)
+  p = subprocess.Popen(command,
+                       stdin=subprocess.PIPE,
+                       stdout=subprocess.PIPE,
+                       stderr=subprocess.PIPE,
+                       env=env,
+                       cwd=working_dir,
+                       universal_newlines=True)
+  std_output, err_output = p.communicate(input_data)
+  p.stdout.close()
+  p.stderr.close()
+  if not ignore_exit_code and p.returncode != 0:
+    logging.error('Command failed: %s\n'
+                  'stdout:\n%s\n'
+                  'stderr:\n%s\n', ' '.join(command), std_output, err_output)
+    sys.exit(p.returncode)
+  return std_output, err_output
+
+
+def _GetBranches():
+  """Returns a tuple of active,branches.
+
+  The 'active' is the name of the currently active branch and 'branches' is a
+  list of all branches.
+  """
+  lines = _RunCommand(['git', 'branch'])[0].split('\n')
+  branches = []
+  active = ''
+  for line in lines:
+    if '*' in line:
+      # The assumption is that the first char will always be the '*'.
+      active = line[1:].strip()
+      branches.append(active)
+    else:
+      branch = line.strip()
+      if branch:
+        branches.append(branch)
+  return active, branches
+
+
+def _ReadGitilesContent(url):
+  # Download and decode BASE64 content until
+  # https://code.google.com/p/gitiles/issues/detail?id=7 is fixed.
+  base64_content = ReadUrlContent(url + '?format=TEXT')
+  return base64.b64decode(base64_content[0]).decode('utf-8')
+
+
+def ReadRemoteCrFile(path_below_src, revision):
+  """Reads a remote Chromium file of a specific revision. Returns a string."""
+  return _ReadGitilesContent(CHROMIUM_FILE_TEMPLATE % (revision,
+                                                       path_below_src))
+
+
+def ReadRemoteCrCommit(revision):
+  """Reads a remote Chromium commit message. Returns a string."""
+  return _ReadGitilesContent(CHROMIUM_COMMIT_TEMPLATE % revision)
+
+
+def ReadUrlContent(url):
+  """Connect to a remote host and read the contents. Returns a list of lines."""
+  conn = urllib.request.urlopen(url)
+  try:
+    return conn.readlines()
+  except IOError as e:
+    logging.exception('Error connecting to %s. Error: %s', url, e)
+    raise
+  finally:
+    conn.close()
+
+
+def GetMatchingDepsEntries(depsentry_dict, dir_path):
+  """Gets all deps entries matching the provided path.
+
+  This list may contain more than one DepsEntry object.
+  Example: dir_path='src/testing' would give results containing both
+  'src/testing/gtest' and 'src/testing/gmock' deps entries for Chromium's DEPS.
+  Example 2: dir_path='src/build' should return 'src/build' but not
+  'src/buildtools'.
+
+  Returns:
+    A list of DepsEntry objects.
+  """
+  result = []
+  for path, depsentry in depsentry_dict.items():
+    if path == dir_path:
+      result.append(depsentry)
+    else:
+      parts = path.split('/')
+      if all(part == parts[i]
+             for i, part in enumerate(dir_path.split('/'))):
+        result.append(depsentry)
+  return result
+
+def BuildDepsentryDict(deps_dict):
+  """Builds a dict of paths to DepsEntry objects from a raw deps dict."""
+  result = {}
+
+  def AddDepsEntries(deps_subdict):
+    for path, deps_url_spec in deps_subdict.items():
+      if isinstance(deps_url_spec, dict):
+        if deps_url_spec.get('dep_type') == 'cipd':
+          continue
+        deps_url = deps_url_spec['url']
+      else:
+        deps_url = deps_url_spec
+      if not path in result:
+        url, revision = deps_url.split('@') if deps_url else (None, None)
+        result[path] = DepsEntry(path, url, revision)
+
+  AddDepsEntries(deps_dict['deps'])
+  for deps_os in ['win', 'mac', 'linux', 'android', 'ios', 'unix']:
+    AddDepsEntries(deps_dict.get('deps_os', {}).get(deps_os, {}))
+  return result
+
+
+def CalculateChangedDeps(libyuv_deps, new_cr_deps):
+  """
+  Calculate changed deps entries based on entries defined in the libyuv DEPS
+  file:
+     - If a shared dependency with the Chromium DEPS file: roll it to the same
+       revision as Chromium (i.e. entry in the new_cr_deps dict)
+     - If it's a Chromium sub-directory, roll it to the HEAD revision (notice
+       this means it may be ahead of the chromium_revision, but generally these
+       should be close).
+     - If it's another DEPS entry (not shared with Chromium), roll it to HEAD
+       unless it's configured to be skipped.
+
+  Returns:
+    A list of ChangedDep objects representing the changed deps.
+  """
+  result = []
+  libyuv_entries = BuildDepsentryDict(libyuv_deps)
+  new_cr_entries = BuildDepsentryDict(new_cr_deps)
+  for path, libyuv_deps_entry in libyuv_entries.items():
+    if path in DONT_AUTOROLL_THESE:
+      continue
+    cr_deps_entry = new_cr_entries.get(path)
+    if cr_deps_entry:
+      # Use the revision from Chromium's DEPS file.
+      new_rev = cr_deps_entry.revision
+      assert libyuv_deps_entry.url == cr_deps_entry.url, (
+        'Libyuv DEPS entry %s has a different URL (%s) than Chromium (%s).' %
+        (path, libyuv_deps_entry.url, cr_deps_entry.url))
+    else:
+      # Use the HEAD of the deps repo.
+      stdout, _ = _RunCommand(['git', 'ls-remote', libyuv_deps_entry.url,
+                               'HEAD'])
+      new_rev = stdout.strip().split('\t')[0]
+
+    # Check if an update is necessary.
+    if libyuv_deps_entry.revision != new_rev:
+      logging.debug('Roll dependency %s to %s', path, new_rev)
+      result.append(ChangedDep(path, libyuv_deps_entry.url,
+                               libyuv_deps_entry.revision, new_rev))
+  return sorted(result)
+
+
+def CalculateChangedClang(new_cr_rev):
+  def GetClangRev(lines):
+    for line in lines:
+      match = CLANG_REVISION_RE.match(line)
+      if match:
+        return match.group(1)
+    raise RollError('Could not parse Clang revision from:\n' + '\n'.join('  ' + l for l in lines))
+
+  with open(CLANG_UPDATE_SCRIPT_LOCAL_PATH, 'r') as f:
+    current_lines = f.readlines()
+  current_rev = GetClangRev(current_lines)
+
+  new_clang_update_py = ReadRemoteCrFile(CLANG_UPDATE_SCRIPT_URL_PATH,
+                                             new_cr_rev).splitlines()
+  new_rev = GetClangRev(new_clang_update_py)
+  return ChangedDep(CLANG_UPDATE_SCRIPT_LOCAL_PATH, None, current_rev, new_rev)
+
+
+def GenerateCommitMessage(current_cr_rev, new_cr_rev, current_commit_pos,
+                          new_commit_pos, changed_deps_list, clang_change):
+  current_cr_rev = current_cr_rev[0:10]
+  new_cr_rev = new_cr_rev[0:10]
+  rev_interval = '%s..%s' % (current_cr_rev, new_cr_rev)
+  git_number_interval = '%s:%s' % (current_commit_pos, new_commit_pos)
+
+  commit_msg = ['Roll chromium_revision %s (%s)\n' % (rev_interval,
+                                                    git_number_interval)]
+  commit_msg.append('Change log: %s' % (CHROMIUM_LOG_TEMPLATE % rev_interval))
+  commit_msg.append('Full diff: %s\n' % (CHROMIUM_COMMIT_TEMPLATE %
+                                         rev_interval))
+  if changed_deps_list:
+    commit_msg.append('Changed dependencies:')
+
+    for c in changed_deps_list:
+      commit_msg.append('* %s: %s/+log/%s..%s' % (c.path, c.url,
+                                                  c.current_rev[0:10],
+                                                  c.new_rev[0:10]))
+    change_url = CHROMIUM_FILE_TEMPLATE % (rev_interval, 'DEPS')
+    commit_msg.append('DEPS diff: %s\n' % change_url)
+  else:
+    commit_msg.append('No dependencies changed.')
+
+  if clang_change.current_rev != clang_change.new_rev:
+    commit_msg.append('Clang version changed %s:%s' %
+                      (clang_change.current_rev, clang_change.new_rev))
+    change_url = CHROMIUM_FILE_TEMPLATE % (rev_interval,
+                                           CLANG_UPDATE_SCRIPT_URL_PATH)
+    commit_msg.append('Details: %s\n' % change_url)
+  else:
+    commit_msg.append('No update to Clang.\n')
+
+  # TBR needs to be non-empty for Gerrit to process it.
+  git_author = _RunCommand(['git', 'config', 'user.email'],
+                           working_dir=CHECKOUT_SRC_DIR)[0].strip()
+  commit_msg.append('TBR=%s' % git_author)
+
+  commit_msg.append('BUG=None')
+  return '\n'.join(commit_msg)
+
+
+def UpdateDepsFile(deps_filename, old_cr_revision, new_cr_revision,
+                   changed_deps):
+  """Update the DEPS file with the new revision."""
+
+  # Update the chromium_revision variable.
+  with open(deps_filename, 'rb') as deps_file:
+    deps_content = deps_file.read().decode('utf-8')
+  deps_content = deps_content.replace(old_cr_revision, new_cr_revision)
+  with open(deps_filename, 'wb') as deps_file:
+    deps_file.write(deps_content.encode('utf-8'))
+
+  # Update each individual DEPS entry.
+  for dep in changed_deps:
+    local_dep_dir = os.path.join(CHECKOUT_ROOT_DIR, dep.path)
+    if not os.path.isdir(local_dep_dir):
+      raise RollError(
+          'Cannot find local directory %s. Make sure the .gclient file\n'
+          'contains all platforms in the target_os list, i.e.\n'
+          'target_os = ["android", "unix", "mac", "ios", "win"];\n'
+          'Then run "gclient sync" again.' % local_dep_dir)
+    _RunCommand(
+      ['gclient', 'setdep', '--revision', '%s@%s' % (dep.path, dep.new_rev)],
+      working_dir=CHECKOUT_SRC_DIR)
+
+
+def _IsTreeClean():
+  stdout, _ = _RunCommand(['git', 'status', '--porcelain'])
+  if len(stdout) == 0:
+    return True
+
+  logging.error('Dirty/unversioned files:\n%s', stdout)
+  return False
+
+
+def _EnsureUpdatedMasterBranch(dry_run):
+  current_branch = _RunCommand(
+      ['git', 'rev-parse', '--abbrev-ref', 'HEAD'])[0].splitlines()[0]
+  if current_branch != 'main':
+    logging.error('Please checkout the main branch and re-run this script.')
+    if not dry_run:
+      sys.exit(-1)
+
+  logging.info('Updating main branch...')
+  _RunCommand(['git', 'pull'])
+
+
+def _CreateRollBranch(dry_run):
+  logging.info('Creating roll branch: %s', ROLL_BRANCH_NAME)
+  if not dry_run:
+    _RunCommand(['git', 'checkout', '-b', ROLL_BRANCH_NAME])
+
+
+def _RemovePreviousRollBranch(dry_run):
+  active_branch, branches = _GetBranches()
+  if active_branch == ROLL_BRANCH_NAME:
+    active_branch = 'main'
+  if ROLL_BRANCH_NAME in branches:
+    logging.info('Removing previous roll branch (%s)', ROLL_BRANCH_NAME)
+    if not dry_run:
+      _RunCommand(['git', 'checkout', active_branch])
+      _RunCommand(['git', 'branch', '-D', ROLL_BRANCH_NAME])
+
+
+def _LocalCommit(commit_msg, dry_run):
+  logging.info('Committing changes locally.')
+  if not dry_run:
+    _RunCommand(['git', 'add', '--update', '.'])
+    _RunCommand(['git', 'commit', '-m', commit_msg])
+
+
+def ChooseCQMode(skip_cq, cq_over, current_commit_pos, new_commit_pos):
+  if skip_cq:
+    return 0
+  if (new_commit_pos - current_commit_pos) < cq_over:
+    return 1
+  return 2
+
+
+def _UploadCL(commit_queue_mode):
+  """Upload the committed changes as a changelist to Gerrit.
+
+  commit_queue_mode:
+    - 2: Submit to commit queue.
+    - 1: Run trybots but do not submit to CQ.
+    - 0: Skip CQ, upload only.
+  """
+  cmd = ['git', 'cl', 'upload', '--force', '--bypass-hooks', '--send-mail']
+  if commit_queue_mode >= 2:
+    logging.info('Sending the CL to the CQ...')
+    cmd.extend(['-o', 'label=Bot-Commit+1'])
+    cmd.extend(['-o', 'label=Commit-Queue+2'])
+  elif commit_queue_mode >= 1:
+    logging.info('Starting CQ dry run...')
+    cmd.extend(['-o', 'label=Commit-Queue+1'])
+  extra_env = {
+      'EDITOR': 'true',
+      'SKIP_GCE_AUTH_FOR_GIT': '1',
+  }
+  stdout, stderr = _RunCommand(cmd, extra_env=extra_env)
+  logging.debug('Output from "git cl upload":\nstdout:\n%s\n\nstderr:\n%s',
+      stdout, stderr)
+
+
+def main():
+  p = argparse.ArgumentParser()
+  p.add_argument('--clean', action='store_true', default=False,
+                 help='Removes any previous local roll branch.')
+  p.add_argument('-r', '--revision',
+                 help=('Chromium Git revision to roll to. Defaults to the '
+                       'Chromium HEAD revision if omitted.'))
+  p.add_argument('--dry-run', action='store_true', default=False,
+                 help=('Calculate changes and modify DEPS, but don\'t create '
+                       'any local branch, commit, upload CL or send any '
+                       'tryjobs.'))
+  p.add_argument('-i', '--ignore-unclean-workdir', action='store_true',
+                 default=False,
+                 help=('Ignore if the current branch is not main or if there '
+                       'are uncommitted changes (default: %(default)s).'))
+  grp = p.add_mutually_exclusive_group()
+  grp.add_argument('--skip-cq', action='store_true', default=False,
+                   help='Skip sending the CL to the CQ (default: %(default)s)')
+  grp.add_argument('--cq-over', type=int, default=1,
+                   help=('Commit queue dry run if the revision difference '
+                         'is below this number (default: %(default)s)'))
+  p.add_argument('-v', '--verbose', action='store_true', default=False,
+                 help='Be extra verbose in printing of log messages.')
+  opts = p.parse_args()
+
+  if opts.verbose:
+    logging.basicConfig(level=logging.DEBUG)
+  else:
+    logging.basicConfig(level=logging.INFO)
+
+  if not opts.ignore_unclean_workdir and not _IsTreeClean():
+    logging.error('Please clean your local checkout first.')
+    return 1
+
+  if opts.clean:
+    _RemovePreviousRollBranch(opts.dry_run)
+
+  if not opts.ignore_unclean_workdir:
+    _EnsureUpdatedMasterBranch(opts.dry_run)
+
+  new_cr_rev = opts.revision
+  if not new_cr_rev:
+    stdout, _ = _RunCommand(['git', 'ls-remote', CHROMIUM_SRC_URL, 'HEAD'])
+    head_rev = stdout.strip().split('\t')[0]
+    logging.info('No revision specified. Using HEAD: %s', head_rev)
+    new_cr_rev = head_rev
+
+  deps_filename = os.path.join(CHECKOUT_SRC_DIR, 'DEPS')
+  libyuv_deps = ParseLocalDepsFile(deps_filename)
+  current_cr_rev = libyuv_deps['vars']['chromium_revision']
+
+  current_commit_pos = ParseCommitPosition(ReadRemoteCrCommit(current_cr_rev))
+  new_commit_pos = ParseCommitPosition(ReadRemoteCrCommit(new_cr_rev))
+
+  new_cr_deps = ParseRemoteCrDepsFile(new_cr_rev)
+  changed_deps = CalculateChangedDeps(libyuv_deps, new_cr_deps)
+  clang_change = CalculateChangedClang(new_cr_rev)
+  commit_msg = GenerateCommitMessage(current_cr_rev, new_cr_rev,
+                                     current_commit_pos, new_commit_pos,
+                                     changed_deps, clang_change)
+  logging.debug('Commit message:\n%s', commit_msg)
+
+  _CreateRollBranch(opts.dry_run)
+  UpdateDepsFile(deps_filename, current_cr_rev, new_cr_rev, changed_deps)
+  _LocalCommit(commit_msg, opts.dry_run)
+  commit_queue_mode = ChooseCQMode(opts.skip_cq, opts.cq_over,
+                                   current_commit_pos, new_commit_pos)
+  logging.info('Uploading CL...')
+  if not opts.dry_run:
+    _UploadCL(commit_queue_mode)
+  return 0
+
+
+if __name__ == '__main__':
+  sys.exit(main())
diff --git a/3rdparty/libyuv/src/tools_libyuv/autoroller/unittests/roll_deps_test.py b/3rdparty/libyuv/src/tools_libyuv/autoroller/unittests/roll_deps_test.py
new file mode 100644
index 00000000..af86bdd5
--- /dev/null
+++ b/3rdparty/libyuv/src/tools_libyuv/autoroller/unittests/roll_deps_test.py
@@ -0,0 +1,148 @@
+#!/usr/bin/env vpython3
+
+# Copyright 2017 The LibYuv Project Authors. All rights reserved.
+#
+# Use of this source code is governed by a BSD-style license
+# that can be found in the LICENSE file in the root of the source
+# tree. An additional intellectual property rights grant can be found
+# in the file PATENTS. All contributing project authors may
+# be found in the AUTHORS file in the root of the source tree.
+
+import glob
+import os
+import shutil
+import sys
+import tempfile
+import unittest
+
+import roll_deps
+from roll_deps import CalculateChangedDeps, GetMatchingDepsEntries, \
+  ParseDepsDict, ParseLocalDepsFile, UpdateDepsFile
+
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+PARENT_DIR = os.path.join(SCRIPT_DIR, os.pardir)
+sys.path.append(PARENT_DIR)
+
+TEST_DATA_VARS = {
+  'chromium_git': 'https://chromium.googlesource.com',
+  'chromium_revision': '1b9c098a08e40114e44b6c1ec33ddf95c40b901d',
+}
+
+DEPS_ENTRIES = {
+  'src/build': 'https://build.com',
+  'src/buildtools': 'https://buildtools.com',
+  'src/testing/gtest': 'https://gtest.com',
+  'src/testing/gmock': 'https://gmock.com',
+}
+
+BUILD_OLD_REV = '52f7afeca991d96d68cf0507e20dbdd5b845691f'
+BUILD_NEW_REV = 'HEAD'
+BUILDTOOLS_OLD_REV = '64e38f0cebdde27aa0cfb405f330063582f9ac76'
+BUILDTOOLS_NEW_REV = '55ad626b08ef971fd82a62b7abb325359542952b'
+
+
+class TestError(Exception):
+  pass
+
+
+class FakeCmd():
+  def __init__(self):
+    self.expectations = []
+
+  def add_expectation(self, *args, **kwargs):
+    returns = kwargs.pop('_returns', None)
+    self.expectations.append((args, kwargs, returns))
+
+  def __call__(self, *args, **kwargs):
+    if not self.expectations:
+      raise TestError('Got unexpected\n%s\n%s' % (args, kwargs))
+    exp_args, exp_kwargs, exp_returns = self.expectations.pop(0)
+    if args != exp_args or kwargs != exp_kwargs:
+      message = 'Expected:\n  args: %s\n  kwargs: %s\n' % (exp_args, exp_kwargs)
+      message += 'Got:\n  args: %s\n  kwargs: %s\n' % (args, kwargs)
+      raise TestError(message)
+    return exp_returns
+
+
+class TestRollChromiumRevision(unittest.TestCase):
+  def setUp(self):
+    self._output_dir = tempfile.mkdtemp()
+    for test_file in glob.glob(os.path.join(SCRIPT_DIR, 'testdata', '*')):
+      shutil.copy(test_file, self._output_dir)
+    self._libyuv_depsfile = os.path.join(self._output_dir, 'DEPS')
+    self._old_cr_depsfile = os.path.join(self._output_dir, 'DEPS.chromium.old')
+    self._new_cr_depsfile = os.path.join(self._output_dir, 'DEPS.chromium.new')
+
+    self.fake = FakeCmd()
+    self.old_RunCommand = getattr(roll_deps, '_RunCommand')
+    setattr(roll_deps, '_RunCommand', self.fake)
+
+  def tearDown(self):
+    shutil.rmtree(self._output_dir, ignore_errors=True)
+    self.assertEqual(self.fake.expectations, [])
+    setattr(roll_deps, '_RunCommand', self.old_RunCommand)
+
+  def testVarLookup(self):
+    local_scope = {'foo': 'wrong', 'vars': {'foo': 'bar'}}
+    lookup = roll_deps.VarLookup(local_scope)
+    self.assertEqual(lookup('foo'), 'bar')
+
+  def testUpdateDepsFile(self):
+    new_rev = 'aaaaabbbbbcccccdddddeeeeefffff0000011111'
+
+    current_rev = TEST_DATA_VARS['chromium_revision']
+    UpdateDepsFile(self._libyuv_depsfile, current_rev, new_rev, [])
+    with open(self._libyuv_depsfile, 'r') as deps_file:
+      deps_contents = deps_file.read()
+      self.assertTrue(new_rev in deps_contents,
+                      'Failed to find %s in\n%s' % (new_rev, deps_contents))
+
+  def testParseDepsDict(self):
+    with open(self._libyuv_depsfile, 'r') as deps_file:
+      deps_contents = deps_file.read()
+    local_scope = ParseDepsDict(deps_contents)
+    vars_dict = local_scope['vars']
+
+    def assertVar(variable_name):
+      self.assertEqual(vars_dict[variable_name], TEST_DATA_VARS[variable_name])
+    assertVar('chromium_git')
+    assertVar('chromium_revision')
+    self.assertEqual(len(local_scope['deps']), 3)
+
+  def testGetMatchingDepsEntriesReturnsPathInSimpleCase(self):
+    entries = GetMatchingDepsEntries(DEPS_ENTRIES, 'src/testing/gtest')
+    self.assertEqual(len(entries), 1)
+    self.assertEqual(entries[0], DEPS_ENTRIES['src/testing/gtest'])
+
+  def testGetMatchingDepsEntriesHandlesSimilarStartingPaths(self):
+    entries = GetMatchingDepsEntries(DEPS_ENTRIES, 'src/testing')
+    self.assertEqual(len(entries), 2)
+
+  def testGetMatchingDepsEntriesHandlesTwoPathsWithIdenticalFirstParts(self):
+    entries = GetMatchingDepsEntries(DEPS_ENTRIES, 'src/build')
+    self.assertEqual(len(entries), 1)
+    self.assertEqual(entries[0], DEPS_ENTRIES['src/build'])
+
+  def testCalculateChangedDeps(self):
+    _SetupGitLsRemoteCall(self.fake,
+        'https://chromium.googlesource.com/chromium/src/build', BUILD_NEW_REV)
+    libyuv_deps = ParseLocalDepsFile(self._libyuv_depsfile)
+    new_cr_deps = ParseLocalDepsFile(self._new_cr_depsfile)
+    changed_deps = CalculateChangedDeps(libyuv_deps, new_cr_deps)
+    self.assertEqual(len(changed_deps), 2)
+    self.assertEqual(changed_deps[0].path, 'src/build')
+    self.assertEqual(changed_deps[0].current_rev, BUILD_OLD_REV)
+    self.assertEqual(changed_deps[0].new_rev, BUILD_NEW_REV)
+
+    self.assertEqual(changed_deps[1].path, 'src/buildtools')
+    self.assertEqual(changed_deps[1].current_rev, BUILDTOOLS_OLD_REV)
+    self.assertEqual(changed_deps[1].new_rev, BUILDTOOLS_NEW_REV)
+
+
+def _SetupGitLsRemoteCall(cmd_fake, url, revision):
+  cmd = ['git', 'ls-remote', url, revision]
+  cmd_fake.add_expectation(cmd, _returns=(revision, None))
+
+
+if __name__ == '__main__':
+  unittest.main()
diff --git a/3rdparty/libyuv/src/tools_libyuv/autoroller/unittests/testdata/DEPS b/3rdparty/libyuv/src/tools_libyuv/autoroller/unittests/testdata/DEPS
new file mode 100644
index 00000000..4f45860c
--- /dev/null
+++ b/3rdparty/libyuv/src/tools_libyuv/autoroller/unittests/testdata/DEPS
@@ -0,0 +1,21 @@
+# DEPS file for unit tests.
+
+vars = {
+  'chromium_git': 'https://chromium.googlesource.com',
+  'chromium_revision': '1b9c098a08e40114e44b6c1ec33ddf95c40b901d',
+  'ignored_str': Str(''),
+}
+
+deps = {
+  # Entry that is a directory in Chromium, so we're using a Git subtree mirror for it.
+  'src/build':
+    Var('chromium_git') + '/chromium/src/build' + '@' + '52f7afeca991d96d68cf0507e20dbdd5b845691f',
+
+  # Entry that's also a DEPS entry in the Chromium DEPS file.
+  'src/buildtools':
+    Var('chromium_git') + '/chromium/buildtools.git' + '@' + '64e38f0cebdde27aa0cfb405f330063582f9ac76',
+
+  # Entry only present in libyuv, not Chromium.
+  'src/third_party/gflags/src':
+    Var('chromium_git') + '/external/github.com/gflags/gflags@03bebcb065c83beff83d50ae025a55a4bf94dfca',
+}
diff --git a/3rdparty/libyuv/src/tools_libyuv/autoroller/unittests/testdata/DEPS.chromium.new b/3rdparty/libyuv/src/tools_libyuv/autoroller/unittests/testdata/DEPS.chromium.new
new file mode 100644
index 00000000..d53083ce
--- /dev/null
+++ b/3rdparty/libyuv/src/tools_libyuv/autoroller/unittests/testdata/DEPS.chromium.new
@@ -0,0 +1,13 @@
+# DEPS file for unit tests.
+
+vars = {
+  'chromium_git': 'https://chromium.googlesource.com',
+
+  # This is updated compared to the DEPS.chromium.old file.
+  'buildtools_revision': '55ad626b08ef971fd82a62b7abb325359542952b',
+}
+
+deps = {
+  'src/buildtools':
+    Var('chromium_git') + '/chromium/buildtools.git' + '@' +  Var('buildtools_revision'),
+}
diff --git a/3rdparty/libyuv/src/tools_libyuv/autoroller/unittests/testdata/DEPS.chromium.old b/3rdparty/libyuv/src/tools_libyuv/autoroller/unittests/testdata/DEPS.chromium.old
new file mode 100644
index 00000000..dd6ddaec
--- /dev/null
+++ b/3rdparty/libyuv/src/tools_libyuv/autoroller/unittests/testdata/DEPS.chromium.old
@@ -0,0 +1,13 @@
+# DEPS file for unit tests.
+
+vars = {
+  'chromium_git': 'https://chromium.googlesource.com',
+
+  # This is and older revision than DEPS.chromium.new file.
+  'buildtools_revision': '64e38f0cebdde27aa0cfb405f330063582f9ac76',
+}
+
+deps = {
+  'src/buildtools':
+    Var('chromium_git') + '/chromium/buildtools.git' + '@' +  Var('buildtools_revision'),
+}
diff --git a/3rdparty/libyuv/src/tools_libyuv/get_landmines.py b/3rdparty/libyuv/src/tools_libyuv/get_landmines.py
new file mode 100644
index 00000000..8b33483e
--- /dev/null
+++ b/3rdparty/libyuv/src/tools_libyuv/get_landmines.py
@@ -0,0 +1,39 @@
+#!/usr/bin/env python3
+
+# Copyright 2016 The LibYuv Project Authors. All rights reserved.
+#
+# Use of this source code is governed by a BSD-style license
+# that can be found in the LICENSE file in the root of the source
+# tree. An additional intellectual property rights grant can be found
+# in the file PATENTS. All contributing project authors may
+# be found in the AUTHORS file in the root of the source tree.
+
+"""
+This file emits the list of reasons why a particular build needs to be clobbered
+(or a list of 'landmines').
+"""
+
+import sys
+
+
+def print_landmines():
+  """
+  ALL LANDMINES ARE EMITTED FROM HERE.
+  """
+  # DO NOT add landmines as part of a regular CL. Landmines are a last-effort
+  # bandaid fix if a CL that got landed has a build dependency bug and all bots
+  # need to be cleaned up. If you're writing a new CL that causes build
+  # dependency problems, fix the dependency problems instead of adding a
+  # landmine.
+  # See the Chromium version in src/build/get_landmines.py for usage examples.
+  print('Clobber to remove GYP artifacts after switching bots to GN.')
+  print('Another try to remove GYP artifacts after switching bots to GN.')
+
+
+def main():
+  print_landmines()
+  return 0
+
+
+if __name__ == '__main__':
+  sys.exit(main())
diff --git a/3rdparty/libyuv/src/tools_libyuv/msan/OWNERS b/3rdparty/libyuv/src/tools_libyuv/msan/OWNERS
new file mode 100644
index 00000000..9b67a8f6
--- /dev/null
+++ b/3rdparty/libyuv/src/tools_libyuv/msan/OWNERS
@@ -0,0 +1,3 @@
+mbonadei@chromium.org
+fbarchard@chromium.org
+pbos@chromium.org
diff --git a/3rdparty/libyuv/src/tools_libyuv/msan/blacklist.txt b/3rdparty/libyuv/src/tools_libyuv/msan/blacklist.txt
new file mode 100644
index 00000000..8b5e42a7
--- /dev/null
+++ b/3rdparty/libyuv/src/tools_libyuv/msan/blacklist.txt
@@ -0,0 +1,9 @@
+# The rules in this file are only applied at compile time.
+# Because the Chrome buildsystem does not automatically touch the files
+# mentioned here, changing this file requires clobbering all MSan bots.
+#
+# Please think twice before you add or remove these rules.
+
+# This is a stripped down copy of Chromium's blacklist.txt, to enable
+# adding libyuv-specific blacklist entries.
+
diff --git a/3rdparty/libyuv/src/tools_libyuv/ubsan/OWNERS b/3rdparty/libyuv/src/tools_libyuv/ubsan/OWNERS
new file mode 100644
index 00000000..9b67a8f6
--- /dev/null
+++ b/3rdparty/libyuv/src/tools_libyuv/ubsan/OWNERS
@@ -0,0 +1,3 @@
+mbonadei@chromium.org
+fbarchard@chromium.org
+pbos@chromium.org
diff --git a/3rdparty/libyuv/src/tools_libyuv/ubsan/blacklist.txt b/3rdparty/libyuv/src/tools_libyuv/ubsan/blacklist.txt
new file mode 100644
index 00000000..8bcb2907
--- /dev/null
+++ b/3rdparty/libyuv/src/tools_libyuv/ubsan/blacklist.txt
@@ -0,0 +1,15 @@
+#############################################################################
+# UBSan blacklist.
+# Please think twice before you add or remove these rules.
+
+# This is a stripped down copy of Chromium's blacklist.txt, to enable
+# adding WebRTC-specific blacklist entries.
+
+#############################################################################
+# YASM does some funny things that UBsan doesn't like.
+# https://crbug.com/489901
+src:*/third_party/yasm/*
+
+#############################################################################
+# Ignore system libraries.
+src:*/usr/*
diff --git a/3rdparty/libyuv/src/tools_libyuv/ubsan/vptr_blacklist.txt b/3rdparty/libyuv/src/tools_libyuv/ubsan/vptr_blacklist.txt
new file mode 100644
index 00000000..23cfca53
--- /dev/null
+++ b/3rdparty/libyuv/src/tools_libyuv/ubsan/vptr_blacklist.txt
@@ -0,0 +1,25 @@
+#############################################################################
+# UBSan vptr blacklist.
+# Function and type based blacklisting use a mangled name, and it is especially
+# tricky to represent C++ types. For now, any possible changes by name manglings
+# are simply represented as wildcard expressions of regexp, and thus it might be
+# over-blacklisted.
+#
+# Please think twice before you add or remove these rules.
+#
+# This is a stripped down copy of Chromium's vptr_blacklist.txt, to enable
+# adding libyuv-specific blacklist entries.
+
+#############################################################################
+# Using raw pointer values.
+#
+# A raw pointer value (16) is used to infer the field offset by
+# GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET.
+
+# Example:
+# src:*/third_party/protobuf/src/google/protobuf/compiler/plugin.pb.cc
+
+#############################################################################
+# UBsan goes into an infinite recursion when __dynamic_cast instrumented with
+# "vptr". See crbug.com/609786.
+src:*/third_party/libc\+\+abi/trunk/src/private_typeinfo.cpp
diff --git a/3rdparty/libyuv/src/unit_test/basictypes_test.cc b/3rdparty/libyuv/src/unit_test/basictypes_test.cc
new file mode 100644
index 00000000..9aaa2dcd
--- /dev/null
+++ b/3rdparty/libyuv/src/unit_test/basictypes_test.cc
@@ -0,0 +1,43 @@
+/*
+ *  Copyright 2012 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include "../unit_test/unit_test.h"
+#include "libyuv/basic_types.h"
+
+namespace libyuv {
+
+TEST_F(LibYUVBaseTest, SizeOfTypes) {
+  int8_t i8 = -1;
+  uint8_t u8 = 1u;
+  int16_t i16 = -1;
+  uint16_t u16 = 1u;
+  int32_t i32 = -1;
+  uint32_t u32 = 1u;
+  int64_t i64 = -1;
+  uint64_t u64 = 1u;
+  EXPECT_EQ(1u, sizeof(i8));
+  EXPECT_EQ(1u, sizeof(u8));
+  EXPECT_EQ(2u, sizeof(i16));
+  EXPECT_EQ(2u, sizeof(u16));
+  EXPECT_EQ(4u, sizeof(i32));
+  EXPECT_EQ(4u, sizeof(u32));
+  EXPECT_EQ(8u, sizeof(i64));
+  EXPECT_EQ(8u, sizeof(u64));
+  EXPECT_GT(0, i8);
+  EXPECT_LT(0u, u8);
+  EXPECT_GT(0, i16);
+  EXPECT_LT(0u, u16);
+  EXPECT_GT(0, i32);
+  EXPECT_LT(0u, u32);
+  EXPECT_GT(0, i64);
+  EXPECT_LT(0u, u64);
+}
+
+}  // namespace libyuv
diff --git a/3rdparty/libyuv/src/unit_test/color_test.cc b/3rdparty/libyuv/src/unit_test/color_test.cc
new file mode 100644
index 00000000..01267ff1
--- /dev/null
+++ b/3rdparty/libyuv/src/unit_test/color_test.cc
@@ -0,0 +1,848 @@
+/*
+ *  Copyright 2015 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include <stdlib.h>
+
+#include "../unit_test/unit_test.h"
+#include "libyuv/basic_types.h"
+#include "libyuv/convert.h"
+#include "libyuv/convert_argb.h"
+#include "libyuv/convert_from.h"
+#include "libyuv/convert_from_argb.h"
+#include "libyuv/cpu_id.h"
+
+namespace libyuv {
+
+// TODO(fbarchard): clang x86 has a higher accuracy YUV to RGB.
+// Port to Visual C and other CPUs
+#if !defined(LIBYUV_BIT_EXACT) && !defined(LIBYUV_DISABLE_X86) && \
+    (defined(__x86_64__) || defined(__i386__))
+#define ERROR_FULL 5
+#define ERROR_J420 4
+#else
+#define ERROR_FULL 6
+#define ERROR_J420 6
+#endif
+#define ERROR_R 1
+#define ERROR_G 1
+#ifdef LIBYUV_UNLIMITED_DATA
+#define ERROR_B 1
+#else
+#define ERROR_B 18
+#endif
+
+#define TESTCS(TESTNAME, YUVTOARGB, ARGBTOYUV, HS1, HS, HN, DIFF)              \
+  TEST_F(LibYUVColorTest, TESTNAME) {                                          \
+    const int kPixels = benchmark_width_ * benchmark_height_;                  \
+    const int kHalfPixels =                                                    \
+        ((benchmark_width_ + 1) / 2) * ((benchmark_height_ + HS1) / HS);       \
+    align_buffer_page_end(orig_y, kPixels);                                    \
+    align_buffer_page_end(orig_u, kHalfPixels);                                \
+    align_buffer_page_end(orig_v, kHalfPixels);                                \
+    align_buffer_page_end(orig_pixels, kPixels * 4);                           \
+    align_buffer_page_end(temp_y, kPixels);                                    \
+    align_buffer_page_end(temp_u, kHalfPixels);                                \
+    align_buffer_page_end(temp_v, kHalfPixels);                                \
+    align_buffer_page_end(dst_pixels_opt, kPixels * 4);                        \
+    align_buffer_page_end(dst_pixels_c, kPixels * 4);                          \
+                                                                               \
+    MemRandomize(orig_pixels, kPixels * 4);                                    \
+    MemRandomize(orig_y, kPixels);                                             \
+    MemRandomize(orig_u, kHalfPixels);                                         \
+    MemRandomize(orig_v, kHalfPixels);                                         \
+    MemRandomize(temp_y, kPixels);                                             \
+    MemRandomize(temp_u, kHalfPixels);                                         \
+    MemRandomize(temp_v, kHalfPixels);                                         \
+    MemRandomize(dst_pixels_opt, kPixels * 4);                                 \
+    MemRandomize(dst_pixels_c, kPixels * 4);                                   \
+                                                                               \
+    /* The test is overall for color conversion matrix being reversible, so */ \
+    /* this initializes the pixel with 2x2 blocks to eliminate subsampling. */ \
+    uint8_t* p = orig_y;                                                       \
+    for (int y = 0; y < benchmark_height_ - HS1; y += HS) {                    \
+      for (int x = 0; x < benchmark_width_ - 1; x += 2) {                      \
+        uint8_t r = static_cast<uint8_t>(fastrand());                          \
+        p[0] = r;                                                              \
+        p[1] = r;                                                              \
+        p[HN] = r;                                                             \
+        p[HN + 1] = r;                                                         \
+        p += 2;                                                                \
+      }                                                                        \
+      if (benchmark_width_ & 1) {                                              \
+        uint8_t r = static_cast<uint8_t>(fastrand());                          \
+        p[0] = r;                                                              \
+        p[HN] = r;                                                             \
+        p += 1;                                                                \
+      }                                                                        \
+      p += HN;                                                                 \
+    }                                                                          \
+    if ((benchmark_height_ & 1) && HS == 2) {                                  \
+      for (int x = 0; x < benchmark_width_ - 1; x += 2) {                      \
+        uint8_t r = static_cast<uint8_t>(fastrand());                          \
+        p[0] = r;                                                              \
+        p[1] = r;                                                              \
+        p += 2;                                                                \
+      }                                                                        \
+      if (benchmark_width_ & 1) {                                              \
+        uint8_t r = static_cast<uint8_t>(fastrand());                          \
+        p[0] = r;                                                              \
+        p += 1;                                                                \
+      }                                                                        \
+    }                                                                          \
+    /* Start with YUV converted to ARGB. */                                    \
+    YUVTOARGB(orig_y, benchmark_width_, orig_u, (benchmark_width_ + 1) / 2,    \
+              orig_v, (benchmark_width_ + 1) / 2, orig_pixels,                 \
+              benchmark_width_ * 4, benchmark_width_, benchmark_height_);      \
+                                                                               \
+    ARGBTOYUV(orig_pixels, benchmark_width_ * 4, temp_y, benchmark_width_,     \
+              temp_u, (benchmark_width_ + 1) / 2, temp_v,                      \
+              (benchmark_width_ + 1) / 2, benchmark_width_,                    \
+              benchmark_height_);                                              \
+                                                                               \
+    MaskCpuFlags(disable_cpu_flags_);                                          \
+    YUVTOARGB(temp_y, benchmark_width_, temp_u, (benchmark_width_ + 1) / 2,    \
+              temp_v, (benchmark_width_ + 1) / 2, dst_pixels_c,                \
+              benchmark_width_ * 4, benchmark_width_, benchmark_height_);      \
+    MaskCpuFlags(benchmark_cpu_info_);                                         \
+                                                                               \
+    for (int i = 0; i < benchmark_iterations_; ++i) {                          \
+      YUVTOARGB(temp_y, benchmark_width_, temp_u, (benchmark_width_ + 1) / 2,  \
+                temp_v, (benchmark_width_ + 1) / 2, dst_pixels_opt,            \
+                benchmark_width_ * 4, benchmark_width_, benchmark_height_);    \
+    }                                                                          \
+    /* Test C and SIMD match. */                                               \
+    for (int i = 0; i < kPixels * 4; ++i) {                                    \
+      EXPECT_EQ(dst_pixels_c[i], dst_pixels_opt[i]);                           \
+    }                                                                          \
+    /* Test SIMD is close to original. */                                      \
+    for (int i = 0; i < kPixels * 4; ++i) {                                    \
+      EXPECT_NEAR(static_cast<int>(orig_pixels[i]),                            \
+                  static_cast<int>(dst_pixels_opt[i]), DIFF);                  \
+    }                                                                          \
+                                                                               \
+    free_aligned_buffer_page_end(orig_pixels);                                 \
+    free_aligned_buffer_page_end(orig_y);                                      \
+    free_aligned_buffer_page_end(orig_u);                                      \
+    free_aligned_buffer_page_end(orig_v);                                      \
+    free_aligned_buffer_page_end(temp_y);                                      \
+    free_aligned_buffer_page_end(temp_u);                                      \
+    free_aligned_buffer_page_end(temp_v);                                      \
+    free_aligned_buffer_page_end(dst_pixels_opt);                              \
+    free_aligned_buffer_page_end(dst_pixels_c);                                \
+  }
+
+TESTCS(TestI420, I420ToARGB, ARGBToI420, 1, 2, benchmark_width_, ERROR_FULL)
+TESTCS(TestI422, I422ToARGB, ARGBToI422, 0, 1, 0, ERROR_FULL)
+TESTCS(TestJ420, J420ToARGB, ARGBToJ420, 1, 2, benchmark_width_, ERROR_J420)
+TESTCS(TestJ422, J422ToARGB, ARGBToJ422, 0, 1, 0, ERROR_J420)
+
+static void YUVToRGB(int y, int u, int v, int* r, int* g, int* b) {
+  const int kWidth = 16;
+  const int kHeight = 1;
+  const int kPixels = kWidth * kHeight;
+  const int kHalfPixels = ((kWidth + 1) / 2) * ((kHeight + 1) / 2);
+
+  SIMD_ALIGNED(uint8_t orig_y[16]);
+  SIMD_ALIGNED(uint8_t orig_u[8]);
+  SIMD_ALIGNED(uint8_t orig_v[8]);
+  SIMD_ALIGNED(uint8_t orig_pixels[16 * 4]);
+  memset(orig_y, y, kPixels);
+  memset(orig_u, u, kHalfPixels);
+  memset(orig_v, v, kHalfPixels);
+
+  /* YUV converted to ARGB. */
+  I422ToARGB(orig_y, kWidth, orig_u, (kWidth + 1) / 2, orig_v, (kWidth + 1) / 2,
+             orig_pixels, kWidth * 4, kWidth, kHeight);
+
+  *b = orig_pixels[0];
+  *g = orig_pixels[1];
+  *r = orig_pixels[2];
+}
+
+static void YUVJToRGB(int y, int u, int v, int* r, int* g, int* b) {
+  const int kWidth = 16;
+  const int kHeight = 1;
+  const int kPixels = kWidth * kHeight;
+  const int kHalfPixels = ((kWidth + 1) / 2) * ((kHeight + 1) / 2);
+
+  SIMD_ALIGNED(uint8_t orig_y[16]);
+  SIMD_ALIGNED(uint8_t orig_u[8]);
+  SIMD_ALIGNED(uint8_t orig_v[8]);
+  SIMD_ALIGNED(uint8_t orig_pixels[16 * 4]);
+  memset(orig_y, y, kPixels);
+  memset(orig_u, u, kHalfPixels);
+  memset(orig_v, v, kHalfPixels);
+
+  /* YUV converted to ARGB. */
+  J422ToARGB(orig_y, kWidth, orig_u, (kWidth + 1) / 2, orig_v, (kWidth + 1) / 2,
+             orig_pixels, kWidth * 4, kWidth, kHeight);
+
+  *b = orig_pixels[0];
+  *g = orig_pixels[1];
+  *r = orig_pixels[2];
+}
+
+static void YUVHToRGB(int y, int u, int v, int* r, int* g, int* b) {
+  const int kWidth = 16;
+  const int kHeight = 1;
+  const int kPixels = kWidth * kHeight;
+  const int kHalfPixels = ((kWidth + 1) / 2) * ((kHeight + 1) / 2);
+
+  SIMD_ALIGNED(uint8_t orig_y[16]);
+  SIMD_ALIGNED(uint8_t orig_u[8]);
+  SIMD_ALIGNED(uint8_t orig_v[8]);
+  SIMD_ALIGNED(uint8_t orig_pixels[16 * 4]);
+  memset(orig_y, y, kPixels);
+  memset(orig_u, u, kHalfPixels);
+  memset(orig_v, v, kHalfPixels);
+
+  /* YUV converted to ARGB. */
+  H422ToARGB(orig_y, kWidth, orig_u, (kWidth + 1) / 2, orig_v, (kWidth + 1) / 2,
+             orig_pixels, kWidth * 4, kWidth, kHeight);
+
+  *b = orig_pixels[0];
+  *g = orig_pixels[1];
+  *r = orig_pixels[2];
+}
+
+#define F422ToARGB(a, b, c, d, e, f, g, h, i, j) \
+  I422ToARGBMatrix(a, b, c, d, e, f, g, h, &kYuvF709Constants, i, j)
+
+static void YUVFToRGB(int y, int u, int v, int* r, int* g, int* b) {
+  const int kWidth = 16;
+  const int kHeight = 1;
+  const int kPixels = kWidth * kHeight;
+  const int kHalfPixels = ((kWidth + 1) / 2) * ((kHeight + 1) / 2);
+
+  SIMD_ALIGNED(uint8_t orig_y[16]);
+  SIMD_ALIGNED(uint8_t orig_u[8]);
+  SIMD_ALIGNED(uint8_t orig_v[8]);
+  SIMD_ALIGNED(uint8_t orig_pixels[16 * 4]);
+  memset(orig_y, y, kPixels);
+  memset(orig_u, u, kHalfPixels);
+  memset(orig_v, v, kHalfPixels);
+
+  /* YUV converted to ARGB. */
+  F422ToARGB(orig_y, kWidth, orig_u, (kWidth + 1) / 2, orig_v, (kWidth + 1) / 2,
+             orig_pixels, kWidth * 4, kWidth, kHeight);
+
+  *b = orig_pixels[0];
+  *g = orig_pixels[1];
+  *r = orig_pixels[2];
+}
+
+static void YUVUToRGB(int y, int u, int v, int* r, int* g, int* b) {
+  const int kWidth = 16;
+  const int kHeight = 1;
+  const int kPixels = kWidth * kHeight;
+  const int kHalfPixels = ((kWidth + 1) / 2) * ((kHeight + 1) / 2);
+
+  SIMD_ALIGNED(uint8_t orig_y[16]);
+  SIMD_ALIGNED(uint8_t orig_u[8]);
+  SIMD_ALIGNED(uint8_t orig_v[8]);
+  SIMD_ALIGNED(uint8_t orig_pixels[16 * 4]);
+  memset(orig_y, y, kPixels);
+  memset(orig_u, u, kHalfPixels);
+  memset(orig_v, v, kHalfPixels);
+
+  /* YUV converted to ARGB. */
+  U422ToARGB(orig_y, kWidth, orig_u, (kWidth + 1) / 2, orig_v, (kWidth + 1) / 2,
+             orig_pixels, kWidth * 4, kWidth, kHeight);
+
+  *b = orig_pixels[0];
+  *g = orig_pixels[1];
+  *r = orig_pixels[2];
+}
+
+#define V422ToARGB(a, b, c, d, e, f, g, h, i, j) \
+  I422ToARGBMatrix(a, b, c, d, e, f, g, h, &kYuvV2020Constants, i, j)
+
+static void YUVVToRGB(int y, int u, int v, int* r, int* g, int* b) {
+  const int kWidth = 16;
+  const int kHeight = 1;
+  const int kPixels = kWidth * kHeight;
+  const int kHalfPixels = ((kWidth + 1) / 2) * ((kHeight + 1) / 2);
+
+  SIMD_ALIGNED(uint8_t orig_y[16]);
+  SIMD_ALIGNED(uint8_t orig_u[8]);
+  SIMD_ALIGNED(uint8_t orig_v[8]);
+  SIMD_ALIGNED(uint8_t orig_pixels[16 * 4]);
+  memset(orig_y, y, kPixels);
+  memset(orig_u, u, kHalfPixels);
+  memset(orig_v, v, kHalfPixels);
+
+  /* YUV converted to ARGB. */
+  V422ToARGB(orig_y, kWidth, orig_u, (kWidth + 1) / 2, orig_v, (kWidth + 1) / 2,
+             orig_pixels, kWidth * 4, kWidth, kHeight);
+
+  *b = orig_pixels[0];
+  *g = orig_pixels[1];
+  *r = orig_pixels[2];
+}
+
+static void YToRGB(int y, int* r, int* g, int* b) {
+  const int kWidth = 16;
+  const int kHeight = 1;
+  const int kPixels = kWidth * kHeight;
+
+  SIMD_ALIGNED(uint8_t orig_y[16]);
+  SIMD_ALIGNED(uint8_t orig_pixels[16 * 4]);
+  memset(orig_y, y, kPixels);
+
+  /* YUV converted to ARGB. */
+  I400ToARGB(orig_y, kWidth, orig_pixels, kWidth * 4, kWidth, kHeight);
+
+  *b = orig_pixels[0];
+  *g = orig_pixels[1];
+  *r = orig_pixels[2];
+}
+
+static void YJToRGB(int y, int* r, int* g, int* b) {
+  const int kWidth = 16;
+  const int kHeight = 1;
+  const int kPixels = kWidth * kHeight;
+
+  SIMD_ALIGNED(uint8_t orig_y[16]);
+  SIMD_ALIGNED(uint8_t orig_pixels[16 * 4]);
+  memset(orig_y, y, kPixels);
+
+  /* YUV converted to ARGB. */
+  J400ToARGB(orig_y, kWidth, orig_pixels, kWidth * 4, kWidth, kHeight);
+
+  *b = orig_pixels[0];
+  *g = orig_pixels[1];
+  *r = orig_pixels[2];
+}
+
+// Pick a method for clamping.
+//  #define CLAMPMETHOD_IF 1
+//  #define CLAMPMETHOD_TABLE 1
+#define CLAMPMETHOD_TERNARY 1
+//  #define CLAMPMETHOD_MASK 1
+
+// Pick a method for rounding.
+#define ROUND(f) static_cast<int>(f + 0.5f)
+//  #define ROUND(f) lrintf(f)
+//  #define ROUND(f) static_cast<int>(round(f))
+//  #define ROUND(f) _mm_cvt_ss2si(_mm_load_ss(&f))
+
+#if defined(CLAMPMETHOD_IF)
+static int RoundToByte(float f) {
+  int i = ROUND(f);
+  if (i < 0) {
+    i = 0;
+  }
+  if (i > 255) {
+    i = 255;
+  }
+  return i;
+}
+#elif defined(CLAMPMETHOD_TABLE)
+static const unsigned char clamptable[811] = {
+    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,   0,   0,   0,   0,   0,   0,   1,   2,   3,   4,   5,   6,   7,   8,
+    9,   10,  11,  12,  13,  14,  15,  16,  17,  18,  19,  20,  21,  22,  23,
+    24,  25,  26,  27,  28,  29,  30,  31,  32,  33,  34,  35,  36,  37,  38,
+    39,  40,  41,  42,  43,  44,  45,  46,  47,  48,  49,  50,  51,  52,  53,
+    54,  55,  56,  57,  58,  59,  60,  61,  62,  63,  64,  65,  66,  67,  68,
+    69,  70,  71,  72,  73,  74,  75,  76,  77,  78,  79,  80,  81,  82,  83,
+    84,  85,  86,  87,  88,  89,  90,  91,  92,  93,  94,  95,  96,  97,  98,
+    99,  100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113,
+    114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128,
+    129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143,
+    144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158,
+    159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173,
+    174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188,
+    189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203,
+    204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218,
+    219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233,
+    234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248,
+    249, 250, 251, 252, 253, 254, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255};
+
+static int RoundToByte(float f) {
+  return clamptable[ROUND(f) + 276];
+}
+#elif defined(CLAMPMETHOD_TERNARY)
+static int RoundToByte(float f) {
+  int i = ROUND(f);
+  return (i < 0) ? 0 : ((i > 255) ? 255 : i);
+}
+#elif defined(CLAMPMETHOD_MASK)
+static int RoundToByte(float f) {
+  int i = ROUND(f);
+  i = ((-(i) >> 31) & (i));                  // clamp to 0.
+  return (((255 - (i)) >> 31) | (i)) & 255;  // clamp to 255.
+}
+#endif
+
+#define RANDOM256(s) ((s & 1) ? ((s >> 1) ^ 0xb8) : (s >> 1))
+
+TEST_F(LibYUVColorTest, TestRoundToByte) {
+  int allb = 0;
+  int count = benchmark_width_ * benchmark_height_;
+  for (int i = 0; i < benchmark_iterations_; ++i) {
+    float f = (fastrand() & 255) * 3.14f - 260.f;
+    for (int j = 0; j < count; ++j) {
+      int b = RoundToByte(f);
+      f += 0.91f;
+      allb |= b;
+    }
+  }
+  EXPECT_GE(allb, 0);
+  EXPECT_LE(allb, 255);
+}
+
+// BT.601 limited range YUV to RGB reference
+static void YUVToRGBReference(int y, int u, int v, int* r, int* g, int* b) {
+  *r = RoundToByte((y - 16) * 1.164 - (v - 128) * -1.596);
+  *g = RoundToByte((y - 16) * 1.164 - (u - 128) * 0.391 - (v - 128) * 0.813);
+  *b = RoundToByte((y - 16) * 1.164 - (u - 128) * -2.018);
+}
+
+// BT.601 full range YUV to RGB reference (aka JPEG)
+static void YUVJToRGBReference(int y, int u, int v, int* r, int* g, int* b) {
+  *r = RoundToByte(y - (v - 128) * -1.40200);
+  *g = RoundToByte(y - (u - 128) * 0.34414 - (v - 128) * 0.71414);
+  *b = RoundToByte(y - (u - 128) * -1.77200);
+}
+
+// BT.709 limited range YUV to RGB reference
+// See also http://www.equasys.de/colorconversion.html
+static void YUVHToRGBReference(int y, int u, int v, int* r, int* g, int* b) {
+  *r = RoundToByte((y - 16) * 1.164 - (v - 128) * -1.793);
+  *g = RoundToByte((y - 16) * 1.164 - (u - 128) * 0.213 - (v - 128) * 0.533);
+  *b = RoundToByte((y - 16) * 1.164 - (u - 128) * -2.112);
+}
+
+// BT.709 full range YUV to RGB reference
+static void YUVFToRGBReference(int y, int u, int v, int* r, int* g, int* b) {
+  *r = RoundToByte(y - (v - 128) * -1.5748);
+  *g = RoundToByte(y - (u - 128) * 0.18732 - (v - 128) * 0.46812);
+  *b = RoundToByte(y - (u - 128) * -1.8556);
+}
+
+// BT.2020 limited range YUV to RGB reference
+static void YUVUToRGBReference(int y, int u, int v, int* r, int* g, int* b) {
+  *r = RoundToByte((y - 16) * 1.164384 - (v - 128) * -1.67867);
+  *g = RoundToByte((y - 16) * 1.164384 - (u - 128) * 0.187326 -
+                   (v - 128) * 0.65042);
+  *b = RoundToByte((y - 16) * 1.164384 - (u - 128) * -2.14177);
+}
+
+// BT.2020 full range YUV to RGB reference
+static void YUVVToRGBReference(int y, int u, int v, int* r, int* g, int* b) {
+  *r = RoundToByte(y + (v - 128) * 1.474600);
+  *g = RoundToByte(y - (u - 128) * 0.164553 - (v - 128) * 0.571353);
+  *b = RoundToByte(y + (u - 128) * 1.881400);
+}
+
+TEST_F(LibYUVColorTest, TestYUV) {
+  int r0, g0, b0, r1, g1, b1;
+
+  // cyan (less red)
+  YUVToRGBReference(240, 255, 0, &r0, &g0, &b0);
+  EXPECT_EQ(56, r0);
+  EXPECT_EQ(255, g0);
+  EXPECT_EQ(255, b0);
+
+  YUVToRGB(240, 255, 0, &r1, &g1, &b1);
+  EXPECT_EQ(57, r1);
+  EXPECT_EQ(255, g1);
+  EXPECT_EQ(255, b1);
+
+  // green (less red and blue)
+  YUVToRGBReference(240, 0, 0, &r0, &g0, &b0);
+  EXPECT_EQ(56, r0);
+  EXPECT_EQ(255, g0);
+  EXPECT_EQ(2, b0);
+
+  YUVToRGB(240, 0, 0, &r1, &g1, &b1);
+  EXPECT_EQ(57, r1);
+  EXPECT_EQ(255, g1);
+#ifdef LIBYUV_UNLIMITED_DATA
+  EXPECT_EQ(3, b1);
+#else
+  EXPECT_EQ(5, b1);
+#endif
+
+  for (int i = 0; i < 256; ++i) {
+    YUVToRGBReference(i, 128, 128, &r0, &g0, &b0);
+    YUVToRGB(i, 128, 128, &r1, &g1, &b1);
+    EXPECT_NEAR(r0, r1, ERROR_R);
+    EXPECT_NEAR(g0, g1, ERROR_G);
+    EXPECT_NEAR(b0, b1, ERROR_B);
+
+    YUVToRGBReference(i, 0, 0, &r0, &g0, &b0);
+    YUVToRGB(i, 0, 0, &r1, &g1, &b1);
+    EXPECT_NEAR(r0, r1, ERROR_R);
+    EXPECT_NEAR(g0, g1, ERROR_G);
+    EXPECT_NEAR(b0, b1, ERROR_B);
+
+    YUVToRGBReference(i, 0, 255, &r0, &g0, &b0);
+    YUVToRGB(i, 0, 255, &r1, &g1, &b1);
+    EXPECT_NEAR(r0, r1, ERROR_R);
+    EXPECT_NEAR(g0, g1, ERROR_G);
+    EXPECT_NEAR(b0, b1, ERROR_B);
+  }
+}
+
+TEST_F(LibYUVColorTest, TestGreyYUV) {
+  int r0, g0, b0, r1, g1, b1, r2, g2, b2;
+
+  // black
+  YUVToRGBReference(16, 128, 128, &r0, &g0, &b0);
+  EXPECT_EQ(0, r0);
+  EXPECT_EQ(0, g0);
+  EXPECT_EQ(0, b0);
+
+  YUVToRGB(16, 128, 128, &r1, &g1, &b1);
+  EXPECT_EQ(0, r1);
+  EXPECT_EQ(0, g1);
+  EXPECT_EQ(0, b1);
+
+  // white
+  YUVToRGBReference(240, 128, 128, &r0, &g0, &b0);
+  EXPECT_EQ(255, r0);
+  EXPECT_EQ(255, g0);
+  EXPECT_EQ(255, b0);
+
+  YUVToRGB(240, 128, 128, &r1, &g1, &b1);
+  EXPECT_EQ(255, r1);
+  EXPECT_EQ(255, g1);
+  EXPECT_EQ(255, b1);
+
+  // grey
+  YUVToRGBReference(128, 128, 128, &r0, &g0, &b0);
+  EXPECT_EQ(130, r0);
+  EXPECT_EQ(130, g0);
+  EXPECT_EQ(130, b0);
+
+  YUVToRGB(128, 128, 128, &r1, &g1, &b1);
+  EXPECT_EQ(130, r1);
+  EXPECT_EQ(130, g1);
+  EXPECT_EQ(130, b1);
+
+  for (int y = 0; y < 256; ++y) {
+    YUVToRGBReference(y, 128, 128, &r0, &g0, &b0);
+    YUVToRGB(y, 128, 128, &r1, &g1, &b1);
+    YToRGB(y, &r2, &g2, &b2);
+    EXPECT_EQ(r0, r1);
+    EXPECT_EQ(g0, g1);
+    EXPECT_EQ(b0, b1);
+    EXPECT_EQ(r0, r2);
+    EXPECT_EQ(g0, g2);
+    EXPECT_EQ(b0, b2);
+  }
+}
+
+static void PrintHistogram(int rh[256], int gh[256], int bh[256]) {
+  int i;
+  printf("hist ");
+  for (i = 0; i < 256; ++i) {
+    if (rh[i] || gh[i] || bh[i]) {
+      printf(" %8d", i - 128);
+    }
+  }
+  printf("\nred  ");
+  for (i = 0; i < 256; ++i) {
+    if (rh[i] || gh[i] || bh[i]) {
+      printf(" %8d", rh[i]);
+    }
+  }
+  printf("\ngreen");
+  for (i = 0; i < 256; ++i) {
+    if (rh[i] || gh[i] || bh[i]) {
+      printf(" %8d", gh[i]);
+    }
+  }
+  printf("\nblue ");
+  for (i = 0; i < 256; ++i) {
+    if (rh[i] || gh[i] || bh[i]) {
+      printf(" %8d", bh[i]);
+    }
+  }
+  printf("\n");
+}
+
+// Step by 5 on inner loop goes from 0 to 255 inclusive.
+// Set to 1 for better converage.  3, 5 or 17 for faster testing.
+#ifdef DISABLE_SLOW_TESTS
+#define FASTSTEP 5
+#else
+#define FASTSTEP 1
+#endif
+
+// BT.601 limited range.
+TEST_F(LibYUVColorTest, TestFullYUV) {
+  int rh[256] = {
+      0,
+  };
+  int gh[256] = {
+      0,
+  };
+  int bh[256] = {
+      0,
+  };
+  for (int u = 0; u < 256; ++u) {
+    for (int v = 0; v < 256; ++v) {
+      for (int y2 = 0; y2 < 256; y2 += FASTSTEP) {
+        int r0, g0, b0, r1, g1, b1;
+        int y = RANDOM256(y2);
+        YUVToRGBReference(y, u, v, &r0, &g0, &b0);
+        YUVToRGB(y, u, v, &r1, &g1, &b1);
+        EXPECT_NEAR(r0, r1, ERROR_R);
+        EXPECT_NEAR(g0, g1, ERROR_G);
+        EXPECT_NEAR(b0, b1, ERROR_B);
+        ++rh[r1 - r0 + 128];
+        ++gh[g1 - g0 + 128];
+        ++bh[b1 - b0 + 128];
+      }
+    }
+  }
+  PrintHistogram(rh, gh, bh);
+}
+
+// BT.601 full range.
+TEST_F(LibYUVColorTest, TestFullYUVJ) {
+  int rh[256] = {
+      0,
+  };
+  int gh[256] = {
+      0,
+  };
+  int bh[256] = {
+      0,
+  };
+  for (int u = 0; u < 256; ++u) {
+    for (int v = 0; v < 256; ++v) {
+      for (int y2 = 0; y2 < 256; y2 += FASTSTEP) {
+        int r0, g0, b0, r1, g1, b1;
+        int y = RANDOM256(y2);
+        YUVJToRGBReference(y, u, v, &r0, &g0, &b0);
+        YUVJToRGB(y, u, v, &r1, &g1, &b1);
+        EXPECT_NEAR(r0, r1, ERROR_R);
+        EXPECT_NEAR(g0, g1, ERROR_G);
+        EXPECT_NEAR(b0, b1, ERROR_B);
+        ++rh[r1 - r0 + 128];
+        ++gh[g1 - g0 + 128];
+        ++bh[b1 - b0 + 128];
+      }
+    }
+  }
+  PrintHistogram(rh, gh, bh);
+}
+
+// BT.709 limited range.
+TEST_F(LibYUVColorTest, TestFullYUVH) {
+  int rh[256] = {
+      0,
+  };
+  int gh[256] = {
+      0,
+  };
+  int bh[256] = {
+      0,
+  };
+  for (int u = 0; u < 256; ++u) {
+    for (int v = 0; v < 256; ++v) {
+      for (int y2 = 0; y2 < 256; y2 += FASTSTEP) {
+        int r0, g0, b0, r1, g1, b1;
+        int y = RANDOM256(y2);
+        YUVHToRGBReference(y, u, v, &r0, &g0, &b0);
+        YUVHToRGB(y, u, v, &r1, &g1, &b1);
+        EXPECT_NEAR(r0, r1, ERROR_R);
+        EXPECT_NEAR(g0, g1, ERROR_G);
+        EXPECT_NEAR(b0, b1, ERROR_B);
+        ++rh[r1 - r0 + 128];
+        ++gh[g1 - g0 + 128];
+        ++bh[b1 - b0 + 128];
+      }
+    }
+  }
+  PrintHistogram(rh, gh, bh);
+}
+
+// BT.709 full range.
+TEST_F(LibYUVColorTest, TestFullYUVF) {
+  int rh[256] = {
+      0,
+  };
+  int gh[256] = {
+      0,
+  };
+  int bh[256] = {
+      0,
+  };
+  for (int u = 0; u < 256; ++u) {
+    for (int v = 0; v < 256; ++v) {
+      for (int y2 = 0; y2 < 256; y2 += FASTSTEP) {
+        int r0, g0, b0, r1, g1, b1;
+        int y = RANDOM256(y2);
+        YUVFToRGBReference(y, u, v, &r0, &g0, &b0);
+        YUVFToRGB(y, u, v, &r1, &g1, &b1);
+        EXPECT_NEAR(r0, r1, ERROR_R);
+        EXPECT_NEAR(g0, g1, ERROR_G);
+        EXPECT_NEAR(b0, b1, ERROR_B);
+        ++rh[r1 - r0 + 128];
+        ++gh[g1 - g0 + 128];
+        ++bh[b1 - b0 + 128];
+      }
+    }
+  }
+  PrintHistogram(rh, gh, bh);
+}
+
+// BT.2020 limited range.
+TEST_F(LibYUVColorTest, TestFullYUVU) {
+  int rh[256] = {
+      0,
+  };
+  int gh[256] = {
+      0,
+  };
+  int bh[256] = {
+      0,
+  };
+  for (int u = 0; u < 256; ++u) {
+    for (int v = 0; v < 256; ++v) {
+      for (int y2 = 0; y2 < 256; y2 += FASTSTEP) {
+        int r0, g0, b0, r1, g1, b1;
+        int y = RANDOM256(y2);
+        YUVUToRGBReference(y, u, v, &r0, &g0, &b0);
+        YUVUToRGB(y, u, v, &r1, &g1, &b1);
+        EXPECT_NEAR(r0, r1, ERROR_R);
+        EXPECT_NEAR(g0, g1, ERROR_G);
+        EXPECT_NEAR(b0, b1, ERROR_B);
+        ++rh[r1 - r0 + 128];
+        ++gh[g1 - g0 + 128];
+        ++bh[b1 - b0 + 128];
+      }
+    }
+  }
+  PrintHistogram(rh, gh, bh);
+}
+
+// BT.2020 full range.
+TEST_F(LibYUVColorTest, TestFullYUVV) {
+  int rh[256] = {
+      0,
+  };
+  int gh[256] = {
+      0,
+  };
+  int bh[256] = {
+      0,
+  };
+  for (int u = 0; u < 256; ++u) {
+    for (int v = 0; v < 256; ++v) {
+      for (int y2 = 0; y2 < 256; y2 += FASTSTEP) {
+        int r0, g0, b0, r1, g1, b1;
+        int y = RANDOM256(y2);
+        YUVVToRGBReference(y, u, v, &r0, &g0, &b0);
+        YUVVToRGB(y, u, v, &r1, &g1, &b1);
+        EXPECT_NEAR(r0, r1, ERROR_R);
+        EXPECT_NEAR(g0, g1, 2);
+        EXPECT_NEAR(b0, b1, ERROR_B);
+        ++rh[r1 - r0 + 128];
+        ++gh[g1 - g0 + 128];
+        ++bh[b1 - b0 + 128];
+      }
+    }
+  }
+  PrintHistogram(rh, gh, bh);
+}
+#undef FASTSTEP
+
+TEST_F(LibYUVColorTest, TestGreyYUVJ) {
+  int r0, g0, b0, r1, g1, b1, r2, g2, b2;
+
+  // black
+  YUVJToRGBReference(0, 128, 128, &r0, &g0, &b0);
+  EXPECT_EQ(0, r0);
+  EXPECT_EQ(0, g0);
+  EXPECT_EQ(0, b0);
+
+  YUVJToRGB(0, 128, 128, &r1, &g1, &b1);
+  EXPECT_EQ(0, r1);
+  EXPECT_EQ(0, g1);
+  EXPECT_EQ(0, b1);
+
+  // white
+  YUVJToRGBReference(255, 128, 128, &r0, &g0, &b0);
+  EXPECT_EQ(255, r0);
+  EXPECT_EQ(255, g0);
+  EXPECT_EQ(255, b0);
+
+  YUVJToRGB(255, 128, 128, &r1, &g1, &b1);
+  EXPECT_EQ(255, r1);
+  EXPECT_EQ(255, g1);
+  EXPECT_EQ(255, b1);
+
+  // grey
+  YUVJToRGBReference(128, 128, 128, &r0, &g0, &b0);
+  EXPECT_EQ(128, r0);
+  EXPECT_EQ(128, g0);
+  EXPECT_EQ(128, b0);
+
+  YUVJToRGB(128, 128, 128, &r1, &g1, &b1);
+  EXPECT_EQ(128, r1);
+  EXPECT_EQ(128, g1);
+  EXPECT_EQ(128, b1);
+
+  for (int y = 0; y < 256; ++y) {
+    YUVJToRGBReference(y, 128, 128, &r0, &g0, &b0);
+    YUVJToRGB(y, 128, 128, &r1, &g1, &b1);
+    YJToRGB(y, &r2, &g2, &b2);
+    EXPECT_EQ(r0, r1);
+    EXPECT_EQ(g0, g1);
+    EXPECT_EQ(b0, b1);
+    EXPECT_EQ(r0, r2);
+    EXPECT_EQ(g0, g2);
+    EXPECT_EQ(b0, b2);
+  }
+}
+
+}  // namespace libyuv
diff --git a/3rdparty/libyuv/src/unit_test/compare_test.cc b/3rdparty/libyuv/src/unit_test/compare_test.cc
new file mode 100644
index 00000000..c29562cb
--- /dev/null
+++ b/3rdparty/libyuv/src/unit_test/compare_test.cc
@@ -0,0 +1,739 @@
+/*
+ *  Copyright 2011 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+
+#include "../unit_test/unit_test.h"
+#include "libyuv/basic_types.h"
+#include "libyuv/compare.h"
+#include "libyuv/cpu_id.h"
+#include "libyuv/video_common.h"
+
+#ifdef ENABLE_ROW_TESTS
+#include "libyuv/compare_row.h" /* For HammingDistance_C */
+#endif
+
+namespace libyuv {
+
+// hash seed of 5381 recommended.
+static uint32_t ReferenceHashDjb2(const uint8_t* src,
+                                  uint64_t count,
+                                  uint32_t seed) {
+  uint32_t hash = seed;
+  if (count > 0) {
+    do {
+      hash = hash * 33 + *src++;
+    } while (--count);
+  }
+  return hash;
+}
+
+TEST_F(LibYUVCompareTest, Djb2_Test) {
+  const int kMaxTest = benchmark_width_ * benchmark_height_;
+  align_buffer_page_end(src_a, kMaxTest);
+  align_buffer_page_end(src_b, kMaxTest);
+
+  const char* fox =
+      "The quick brown fox jumps over the lazy dog"
+      " and feels as if he were in the seventh heaven of typography"
+      " together with Hermann Zapf";
+  uint32_t foxhash = HashDjb2(reinterpret_cast<const uint8_t*>(fox), 131, 5381);
+  const uint32_t kExpectedFoxHash = 2611006483u;
+  EXPECT_EQ(kExpectedFoxHash, foxhash);
+
+  for (int i = 0; i < kMaxTest; ++i) {
+    src_a[i] = (fastrand() & 0xff);
+    src_b[i] = (fastrand() & 0xff);
+  }
+  // Compare different buffers. Expect hash is different.
+  uint32_t h1 = HashDjb2(src_a, kMaxTest, 5381);
+  uint32_t h2 = HashDjb2(src_b, kMaxTest, 5381);
+  EXPECT_NE(h1, h2);
+
+  // Make last half same. Expect hash is different.
+  memcpy(src_a + kMaxTest / 2, src_b + kMaxTest / 2, kMaxTest / 2);
+  h1 = HashDjb2(src_a, kMaxTest, 5381);
+  h2 = HashDjb2(src_b, kMaxTest, 5381);
+  EXPECT_NE(h1, h2);
+
+  // Make first half same. Expect hash is different.
+  memcpy(src_a + kMaxTest / 2, src_a, kMaxTest / 2);
+  memcpy(src_b + kMaxTest / 2, src_b, kMaxTest / 2);
+  memcpy(src_a, src_b, kMaxTest / 2);
+  h1 = HashDjb2(src_a, kMaxTest, 5381);
+  h2 = HashDjb2(src_b, kMaxTest, 5381);
+  EXPECT_NE(h1, h2);
+
+  // Make same. Expect hash is same.
+  memcpy(src_a, src_b, kMaxTest);
+  h1 = HashDjb2(src_a, kMaxTest, 5381);
+  h2 = HashDjb2(src_b, kMaxTest, 5381);
+  EXPECT_EQ(h1, h2);
+
+  // Mask seed different. Expect hash is different.
+  memcpy(src_a, src_b, kMaxTest);
+  h1 = HashDjb2(src_a, kMaxTest, 5381);
+  h2 = HashDjb2(src_b, kMaxTest, 1234);
+  EXPECT_NE(h1, h2);
+
+  // Make one byte different in middle. Expect hash is different.
+  memcpy(src_a, src_b, kMaxTest);
+  ++src_b[kMaxTest / 2];
+  h1 = HashDjb2(src_a, kMaxTest, 5381);
+  h2 = HashDjb2(src_b, kMaxTest, 5381);
+  EXPECT_NE(h1, h2);
+
+  // Make first byte different. Expect hash is different.
+  memcpy(src_a, src_b, kMaxTest);
+  ++src_b[0];
+  h1 = HashDjb2(src_a, kMaxTest, 5381);
+  h2 = HashDjb2(src_b, kMaxTest, 5381);
+  EXPECT_NE(h1, h2);
+
+  // Make last byte different. Expect hash is different.
+  memcpy(src_a, src_b, kMaxTest);
+  ++src_b[kMaxTest - 1];
+  h1 = HashDjb2(src_a, kMaxTest, 5381);
+  h2 = HashDjb2(src_b, kMaxTest, 5381);
+  EXPECT_NE(h1, h2);
+
+  // Make a zeros. Test different lengths. Expect hash is different.
+  memset(src_a, 0, kMaxTest);
+  h1 = HashDjb2(src_a, kMaxTest, 5381);
+  h2 = HashDjb2(src_a, kMaxTest / 2, 5381);
+  EXPECT_NE(h1, h2);
+
+  // Make a zeros and seed of zero. Test different lengths. Expect hash is same.
+  memset(src_a, 0, kMaxTest);
+  h1 = HashDjb2(src_a, kMaxTest, 0);
+  h2 = HashDjb2(src_a, kMaxTest / 2, 0);
+  EXPECT_EQ(h1, h2);
+
+  free_aligned_buffer_page_end(src_a);
+  free_aligned_buffer_page_end(src_b);
+}
+
+TEST_F(LibYUVCompareTest, BenchmarkDjb2_Opt) {
+  const int kMaxTest = benchmark_width_ * benchmark_height_;
+  align_buffer_page_end(src_a, kMaxTest);
+
+  for (int i = 0; i < kMaxTest; ++i) {
+    src_a[i] = i;
+  }
+  uint32_t h2 = ReferenceHashDjb2(src_a, kMaxTest, 5381);
+  uint32_t h1;
+  for (int i = 0; i < benchmark_iterations_; ++i) {
+    h1 = HashDjb2(src_a, kMaxTest, 5381);
+  }
+  EXPECT_EQ(h1, h2);
+  free_aligned_buffer_page_end(src_a);
+}
+
+TEST_F(LibYUVCompareTest, BenchmarkDjb2_Unaligned) {
+  const int kMaxTest = benchmark_width_ * benchmark_height_;
+  align_buffer_page_end(src_a, kMaxTest + 1);
+  for (int i = 0; i < kMaxTest; ++i) {
+    src_a[i + 1] = i;
+  }
+  uint32_t h2 = ReferenceHashDjb2(src_a + 1, kMaxTest, 5381);
+  uint32_t h1;
+  for (int i = 0; i < benchmark_iterations_; ++i) {
+    h1 = HashDjb2(src_a + 1, kMaxTest, 5381);
+  }
+  EXPECT_EQ(h1, h2);
+  free_aligned_buffer_page_end(src_a);
+}
+
+TEST_F(LibYUVCompareTest, BenchmarkARGBDetect_Opt) {
+  uint32_t fourcc;
+  const int kMaxTest = benchmark_width_ * benchmark_height_ * 4;
+  align_buffer_page_end(src_a, kMaxTest);
+  for (int i = 0; i < kMaxTest; ++i) {
+    src_a[i] = 255;
+  }
+
+  src_a[0] = 0;
+  fourcc = ARGBDetect(src_a, benchmark_width_ * 4, benchmark_width_,
+                      benchmark_height_);
+  EXPECT_EQ(static_cast<uint32_t>(libyuv::FOURCC_BGRA), fourcc);
+  src_a[0] = 255;
+  src_a[3] = 0;
+  fourcc = ARGBDetect(src_a, benchmark_width_ * 4, benchmark_width_,
+                      benchmark_height_);
+  EXPECT_EQ(static_cast<uint32_t>(libyuv::FOURCC_ARGB), fourcc);
+  src_a[3] = 255;
+
+  for (int i = 0; i < benchmark_iterations_; ++i) {
+    fourcc = ARGBDetect(src_a, benchmark_width_ * 4, benchmark_width_,
+                        benchmark_height_);
+  }
+  EXPECT_EQ(0u, fourcc);
+
+  free_aligned_buffer_page_end(src_a);
+}
+
+TEST_F(LibYUVCompareTest, BenchmarkARGBDetect_Unaligned) {
+  uint32_t fourcc;
+  const int kMaxTest = benchmark_width_ * benchmark_height_ * 4 + 1;
+  align_buffer_page_end(src_a, kMaxTest);
+  for (int i = 1; i < kMaxTest; ++i) {
+    src_a[i] = 255;
+  }
+
+  src_a[0 + 1] = 0;
+  fourcc = ARGBDetect(src_a + 1, benchmark_width_ * 4, benchmark_width_,
+                      benchmark_height_);
+  EXPECT_EQ(static_cast<uint32_t>(libyuv::FOURCC_BGRA), fourcc);
+  src_a[0 + 1] = 255;
+  src_a[3 + 1] = 0;
+  fourcc = ARGBDetect(src_a + 1, benchmark_width_ * 4, benchmark_width_,
+                      benchmark_height_);
+  EXPECT_EQ(static_cast<uint32_t>(libyuv::FOURCC_ARGB), fourcc);
+  src_a[3 + 1] = 255;
+
+  for (int i = 0; i < benchmark_iterations_; ++i) {
+    fourcc = ARGBDetect(src_a + 1, benchmark_width_ * 4, benchmark_width_,
+                        benchmark_height_);
+  }
+  EXPECT_EQ(0u, fourcc);
+
+  free_aligned_buffer_page_end(src_a);
+}
+
+#ifdef ENABLE_ROW_TESTS
+TEST_F(LibYUVCompareTest, BenchmarkHammingDistance_Opt) {
+  const int kMaxWidth = 4096 * 3;
+  align_buffer_page_end(src_a, kMaxWidth);
+  align_buffer_page_end(src_b, kMaxWidth);
+  memset(src_a, 0, kMaxWidth);
+  memset(src_b, 0, kMaxWidth);
+
+  // Test known value
+  memcpy(src_a, "test0123test4567", 16);
+  memcpy(src_b, "tick0123tock4567", 16);
+  uint32_t h1 = HammingDistance_C(src_a, src_b, 16);
+  EXPECT_EQ(16u, h1);
+
+  // Test C vs OPT on random buffer
+  MemRandomize(src_a, kMaxWidth);
+  MemRandomize(src_b, kMaxWidth);
+
+  uint32_t h0 = HammingDistance_C(src_a, src_b, kMaxWidth);
+
+  int count =
+      benchmark_iterations_ *
+      ((benchmark_width_ * benchmark_height_ + kMaxWidth - 1) / kMaxWidth);
+  for (int i = 0; i < count; ++i) {
+#if defined(HAS_HAMMINGDISTANCE_NEON)
+    h1 = HammingDistance_NEON(src_a, src_b, kMaxWidth);
+#elif defined(HAS_HAMMINGDISTANCE_AVX2)
+    int has_avx2 = TestCpuFlag(kCpuHasAVX2);
+    if (has_avx2) {
+      h1 = HammingDistance_AVX2(src_a, src_b, kMaxWidth);
+    } else {
+      int has_sse42 = TestCpuFlag(kCpuHasSSE42);
+      if (has_sse42) {
+        h1 = HammingDistance_SSE42(src_a, src_b, kMaxWidth);
+      } else {
+        int has_ssse3 = TestCpuFlag(kCpuHasSSSE3);
+        if (has_ssse3) {
+          h1 = HammingDistance_SSSE3(src_a, src_b, kMaxWidth);
+        } else {
+          h1 = HammingDistance_C(src_a, src_b, kMaxWidth);
+        }
+      }
+    }
+#elif defined(HAS_HAMMINGDISTANCE_SSE42)
+    int has_sse42 = TestCpuFlag(kCpuHasSSE42);
+    if (has_sse42) {
+      h1 = HammingDistance_SSE42(src_a, src_b, kMaxWidth);
+    } else {
+      h1 = HammingDistance_C(src_a, src_b, kMaxWidth);
+    }
+#else
+    h1 = HammingDistance_C(src_a, src_b, kMaxWidth);
+#endif
+  }
+  EXPECT_EQ(h0, h1);
+
+  free_aligned_buffer_page_end(src_a);
+  free_aligned_buffer_page_end(src_b);
+}
+
+TEST_F(LibYUVCompareTest, BenchmarkHammingDistance_C) {
+  const int kMaxWidth = 4096 * 3;
+  align_buffer_page_end(src_a, kMaxWidth);
+  align_buffer_page_end(src_b, kMaxWidth);
+  memset(src_a, 0, kMaxWidth);
+  memset(src_b, 0, kMaxWidth);
+
+  // Test known value
+  memcpy(src_a, "test0123test4567", 16);
+  memcpy(src_b, "tick0123tock4567", 16);
+  uint32_t h1 = HammingDistance_C(src_a, src_b, 16);
+  EXPECT_EQ(16u, h1);
+
+  // Test C vs OPT on random buffer
+  MemRandomize(src_a, kMaxWidth);
+  MemRandomize(src_b, kMaxWidth);
+
+  uint32_t h0 = HammingDistance_C(src_a, src_b, kMaxWidth);
+
+  int count =
+      benchmark_iterations_ *
+      ((benchmark_width_ * benchmark_height_ + kMaxWidth - 1) / kMaxWidth);
+  for (int i = 0; i < count; ++i) {
+    h1 = HammingDistance_C(src_a, src_b, kMaxWidth);
+  }
+
+  EXPECT_EQ(h0, h1);
+
+  free_aligned_buffer_page_end(src_a);
+  free_aligned_buffer_page_end(src_b);
+}
+
+TEST_F(LibYUVCompareTest, BenchmarkHammingDistance) {
+  const int kMaxWidth = 4096 * 3;
+  align_buffer_page_end(src_a, kMaxWidth);
+  align_buffer_page_end(src_b, kMaxWidth);
+  memset(src_a, 0, kMaxWidth);
+  memset(src_b, 0, kMaxWidth);
+
+  memcpy(src_a, "test0123test4567", 16);
+  memcpy(src_b, "tick0123tock4567", 16);
+  uint64_t h1 = ComputeHammingDistance(src_a, src_b, 16);
+  EXPECT_EQ(16u, h1);
+
+  // Test C vs OPT on random buffer
+  MemRandomize(src_a, kMaxWidth);
+  MemRandomize(src_b, kMaxWidth);
+
+  uint32_t h0 = HammingDistance_C(src_a, src_b, kMaxWidth);
+
+  int count =
+      benchmark_iterations_ *
+      ((benchmark_width_ * benchmark_height_ + kMaxWidth - 1) / kMaxWidth);
+  for (int i = 0; i < count; ++i) {
+    h1 = ComputeHammingDistance(src_a, src_b, kMaxWidth);
+  }
+
+  EXPECT_EQ(h0, h1);
+
+  free_aligned_buffer_page_end(src_a);
+  free_aligned_buffer_page_end(src_b);
+}
+
+// Tests low levels match reference C for specified size.
+// The opt implementations have size limitations
+// For NEON the counters are 16 bit so the shorts overflow after 65536 bytes.
+// So doing one less iteration of the loop is the maximum.
+#if defined(HAS_HAMMINGDISTANCE_NEON)
+static const int kMaxOptCount = 65536 - 32;  // 65504
+#else
+static const int kMaxOptCount = (1 << (32 - 3)) - 64;  // 536870848
+#endif
+
+TEST_F(LibYUVCompareTest, TestHammingDistance_Opt) {
+  uint32_t h1 = 0;
+  const int kMaxWidth = (benchmark_width_ * benchmark_height_ + 63) & ~63;
+  align_buffer_page_end(src_a, kMaxWidth);
+  align_buffer_page_end(src_b, kMaxWidth);
+  memset(src_a, 255u, kMaxWidth);
+  memset(src_b, 0u, kMaxWidth);
+
+  uint64_t h0 = ComputeHammingDistance(src_a, src_b, kMaxWidth);
+  EXPECT_EQ(kMaxWidth * 8ULL, h0);
+
+  for (int i = 0; i < benchmark_iterations_; ++i) {
+#if defined(HAS_HAMMINGDISTANCE_NEON)
+    h1 = HammingDistance_NEON(src_a, src_b, kMaxWidth);
+#elif defined(HAS_HAMMINGDISTANCE_AVX2)
+    int has_avx2 = TestCpuFlag(kCpuHasAVX2);
+    if (has_avx2) {
+      h1 = HammingDistance_AVX2(src_a, src_b, kMaxWidth);
+    } else {
+      int has_sse42 = TestCpuFlag(kCpuHasSSE42);
+      if (has_sse42) {
+        h1 = HammingDistance_SSE42(src_a, src_b, kMaxWidth);
+      } else {
+        int has_ssse3 = TestCpuFlag(kCpuHasSSSE3);
+        if (has_ssse3) {
+          h1 = HammingDistance_SSSE3(src_a, src_b, kMaxWidth);
+        } else {
+          h1 = HammingDistance_C(src_a, src_b, kMaxWidth);
+        }
+      }
+    }
+#elif defined(HAS_HAMMINGDISTANCE_SSE42)
+    int has_sse42 = TestCpuFlag(kCpuHasSSE42);
+    if (has_sse42) {
+      h1 = HammingDistance_SSE42(src_a, src_b, kMaxWidth);
+    } else {
+      h1 = HammingDistance_C(src_a, src_b, kMaxWidth);
+    }
+#else
+    h1 = HammingDistance_C(src_a, src_b, kMaxWidth);
+#endif
+  }
+
+  // A large count will cause the low level to potentially overflow so the
+  // result can not be expected to be correct.
+  // TODO(fbarchard): Consider expecting the low 16 bits to match.
+  if (kMaxWidth <= kMaxOptCount) {
+    EXPECT_EQ(kMaxWidth * 8U, h1);
+  } else {
+    if (kMaxWidth * 8ULL != static_cast<uint64_t>(h1)) {
+      printf(
+          "warning - HammingDistance_Opt %u does not match %llu "
+          "but length of %u is longer than guaranteed.\n",
+          h1, kMaxWidth * 8ULL, kMaxWidth);
+    } else {
+      printf(
+          "warning - HammingDistance_Opt %u matches but length of %u "
+          "is longer than guaranteed.\n",
+          h1, kMaxWidth);
+    }
+  }
+
+  free_aligned_buffer_page_end(src_a);
+  free_aligned_buffer_page_end(src_b);
+}
+#endif  // ENABLE_ROW_TESTS
+
+TEST_F(LibYUVCompareTest, TestHammingDistance) {
+  align_buffer_page_end(src_a, benchmark_width_ * benchmark_height_);
+  align_buffer_page_end(src_b, benchmark_width_ * benchmark_height_);
+  memset(src_a, 255u, benchmark_width_ * benchmark_height_);
+  memset(src_b, 0, benchmark_width_ * benchmark_height_);
+
+  uint64_t h1 = 0;
+  for (int i = 0; i < benchmark_iterations_; ++i) {
+    h1 = ComputeHammingDistance(src_a, src_b,
+                                benchmark_width_ * benchmark_height_);
+  }
+  EXPECT_EQ(benchmark_width_ * benchmark_height_ * 8ULL, h1);
+
+  free_aligned_buffer_page_end(src_a);
+  free_aligned_buffer_page_end(src_b);
+}
+
+TEST_F(LibYUVCompareTest, BenchmarkSumSquareError_Opt) {
+  const int kMaxWidth = 4096 * 3;
+  align_buffer_page_end(src_a, kMaxWidth);
+  align_buffer_page_end(src_b, kMaxWidth);
+  memset(src_a, 0, kMaxWidth);
+  memset(src_b, 0, kMaxWidth);
+
+  memcpy(src_a, "test0123test4567", 16);
+  memcpy(src_b, "tick0123tock4567", 16);
+  uint64_t h1 = ComputeSumSquareError(src_a, src_b, 16);
+  EXPECT_EQ(790u, h1);
+
+  for (int i = 0; i < kMaxWidth; ++i) {
+    src_a[i] = i;
+    src_b[i] = i;
+  }
+  memset(src_a, 0, kMaxWidth);
+  memset(src_b, 0, kMaxWidth);
+
+  int count =
+      benchmark_iterations_ *
+      ((benchmark_width_ * benchmark_height_ + kMaxWidth - 1) / kMaxWidth);
+  for (int i = 0; i < count; ++i) {
+    h1 = ComputeSumSquareError(src_a, src_b, kMaxWidth);
+  }
+
+  EXPECT_EQ(0u, h1);
+
+  free_aligned_buffer_page_end(src_a);
+  free_aligned_buffer_page_end(src_b);
+}
+
+TEST_F(LibYUVCompareTest, SumSquareError) {
+  const int kMaxWidth = 4096 * 3;
+  align_buffer_page_end(src_a, kMaxWidth);
+  align_buffer_page_end(src_b, kMaxWidth);
+  memset(src_a, 0, kMaxWidth);
+  memset(src_b, 0, kMaxWidth);
+
+  uint64_t err;
+  err = ComputeSumSquareError(src_a, src_b, kMaxWidth);
+
+  EXPECT_EQ(0u, err);
+
+  memset(src_a, 1, kMaxWidth);
+  err = ComputeSumSquareError(src_a, src_b, kMaxWidth);
+
+  EXPECT_EQ(static_cast<int>(err), kMaxWidth);
+
+  memset(src_a, 190, kMaxWidth);
+  memset(src_b, 193, kMaxWidth);
+  err = ComputeSumSquareError(src_a, src_b, kMaxWidth);
+
+  EXPECT_EQ(static_cast<int>(err), kMaxWidth * 3 * 3);
+
+  for (int i = 0; i < kMaxWidth; ++i) {
+    src_a[i] = (fastrand() & 0xff);
+    src_b[i] = (fastrand() & 0xff);
+  }
+
+  MaskCpuFlags(disable_cpu_flags_);
+  uint64_t c_err = ComputeSumSquareError(src_a, src_b, kMaxWidth);
+
+  MaskCpuFlags(benchmark_cpu_info_);
+  uint64_t opt_err = ComputeSumSquareError(src_a, src_b, kMaxWidth);
+
+  EXPECT_EQ(c_err, opt_err);
+
+  free_aligned_buffer_page_end(src_a);
+  free_aligned_buffer_page_end(src_b);
+}
+
+TEST_F(LibYUVCompareTest, BenchmarkPsnr_Opt) {
+  align_buffer_page_end(src_a, benchmark_width_ * benchmark_height_);
+  align_buffer_page_end(src_b, benchmark_width_ * benchmark_height_);
+  for (int i = 0; i < benchmark_width_ * benchmark_height_; ++i) {
+    src_a[i] = i;
+    src_b[i] = i;
+  }
+
+  MaskCpuFlags(benchmark_cpu_info_);
+
+  double opt_time = get_time();
+  for (int i = 0; i < benchmark_iterations_; ++i) {
+    CalcFramePsnr(src_a, benchmark_width_, src_b, benchmark_width_,
+                  benchmark_width_, benchmark_height_);
+  }
+
+  opt_time = (get_time() - opt_time) / benchmark_iterations_;
+  printf("BenchmarkPsnr_Opt - %8.2f us opt\n", opt_time * 1e6);
+
+  EXPECT_EQ(0, 0);
+
+  free_aligned_buffer_page_end(src_a);
+  free_aligned_buffer_page_end(src_b);
+}
+
+TEST_F(LibYUVCompareTest, BenchmarkPsnr_Unaligned) {
+  align_buffer_page_end(src_a, benchmark_width_ * benchmark_height_ + 1);
+  align_buffer_page_end(src_b, benchmark_width_ * benchmark_height_);
+  for (int i = 0; i < benchmark_width_ * benchmark_height_; ++i) {
+    src_a[i + 1] = i;
+    src_b[i] = i;
+  }
+
+  MaskCpuFlags(benchmark_cpu_info_);
+
+  double opt_time = get_time();
+  for (int i = 0; i < benchmark_iterations_; ++i) {
+    CalcFramePsnr(src_a + 1, benchmark_width_, src_b, benchmark_width_,
+                  benchmark_width_, benchmark_height_);
+  }
+
+  opt_time = (get_time() - opt_time) / benchmark_iterations_;
+  printf("BenchmarkPsnr_Opt - %8.2f us opt\n", opt_time * 1e6);
+
+  EXPECT_EQ(0, 0);
+
+  free_aligned_buffer_page_end(src_a);
+  free_aligned_buffer_page_end(src_b);
+}
+
+TEST_F(LibYUVCompareTest, Psnr) {
+  const int kSrcWidth = benchmark_width_;
+  const int kSrcHeight = benchmark_height_;
+  const int b = 128;
+  const int kSrcPlaneSize = (kSrcWidth + b * 2) * (kSrcHeight + b * 2);
+  const int kSrcStride = 2 * b + kSrcWidth;
+  align_buffer_page_end(src_a, kSrcPlaneSize);
+  align_buffer_page_end(src_b, kSrcPlaneSize);
+  memset(src_a, 0, kSrcPlaneSize);
+  memset(src_b, 0, kSrcPlaneSize);
+
+  double err;
+  err = CalcFramePsnr(src_a + kSrcStride * b + b, kSrcStride,
+                      src_b + kSrcStride * b + b, kSrcStride, kSrcWidth,
+                      kSrcHeight);
+
+  EXPECT_EQ(err, kMaxPsnr);
+
+  memset(src_a, 255, kSrcPlaneSize);
+
+  err = CalcFramePsnr(src_a + kSrcStride * b + b, kSrcStride,
+                      src_b + kSrcStride * b + b, kSrcStride, kSrcWidth,
+                      kSrcHeight);
+
+  EXPECT_EQ(err, 0.0);
+
+  memset(src_a, 1, kSrcPlaneSize);
+
+  err = CalcFramePsnr(src_a + kSrcStride * b + b, kSrcStride,
+                      src_b + kSrcStride * b + b, kSrcStride, kSrcWidth,
+                      kSrcHeight);
+
+  EXPECT_GT(err, 48.0);
+  EXPECT_LT(err, 49.0);
+
+  for (int i = 0; i < kSrcPlaneSize; ++i) {
+    src_a[i] = i;
+  }
+
+  err = CalcFramePsnr(src_a + kSrcStride * b + b, kSrcStride,
+                      src_b + kSrcStride * b + b, kSrcStride, kSrcWidth,
+                      kSrcHeight);
+
+  EXPECT_GT(err, 2.0);
+  if (kSrcWidth * kSrcHeight >= 256) {
+    EXPECT_LT(err, 6.0);
+  }
+
+  memset(src_a, 0, kSrcPlaneSize);
+  memset(src_b, 0, kSrcPlaneSize);
+
+  for (int i = b; i < (kSrcHeight + b); ++i) {
+    for (int j = b; j < (kSrcWidth + b); ++j) {
+      src_a[(i * kSrcStride) + j] = (fastrand() & 0xff);
+      src_b[(i * kSrcStride) + j] = (fastrand() & 0xff);
+    }
+  }
+
+  MaskCpuFlags(disable_cpu_flags_);
+  double c_err, opt_err;
+
+  c_err = CalcFramePsnr(src_a + kSrcStride * b + b, kSrcStride,
+                        src_b + kSrcStride * b + b, kSrcStride, kSrcWidth,
+                        kSrcHeight);
+
+  MaskCpuFlags(benchmark_cpu_info_);
+
+  opt_err = CalcFramePsnr(src_a + kSrcStride * b + b, kSrcStride,
+                          src_b + kSrcStride * b + b, kSrcStride, kSrcWidth,
+                          kSrcHeight);
+
+  EXPECT_EQ(opt_err, c_err);
+
+  free_aligned_buffer_page_end(src_a);
+  free_aligned_buffer_page_end(src_b);
+}
+
+TEST_F(LibYUVCompareTest, DISABLED_BenchmarkSsim_Opt) {
+  align_buffer_page_end(src_a, benchmark_width_ * benchmark_height_);
+  align_buffer_page_end(src_b, benchmark_width_ * benchmark_height_);
+  for (int i = 0; i < benchmark_width_ * benchmark_height_; ++i) {
+    src_a[i] = i;
+    src_b[i] = i;
+  }
+
+  MaskCpuFlags(benchmark_cpu_info_);
+
+  double opt_time = get_time();
+  for (int i = 0; i < benchmark_iterations_; ++i) {
+    CalcFrameSsim(src_a, benchmark_width_, src_b, benchmark_width_,
+                  benchmark_width_, benchmark_height_);
+  }
+
+  opt_time = (get_time() - opt_time) / benchmark_iterations_;
+  printf("BenchmarkSsim_Opt - %8.2f us opt\n", opt_time * 1e6);
+
+  EXPECT_EQ(0, 0);  // Pass if we get this far.
+
+  free_aligned_buffer_page_end(src_a);
+  free_aligned_buffer_page_end(src_b);
+}
+
+TEST_F(LibYUVCompareTest, Ssim) {
+  const int kSrcWidth = benchmark_width_;
+  const int kSrcHeight = benchmark_height_;
+  const int b = 128;
+  const int kSrcPlaneSize = (kSrcWidth + b * 2) * (kSrcHeight + b * 2);
+  const int kSrcStride = 2 * b + kSrcWidth;
+  align_buffer_page_end(src_a, kSrcPlaneSize);
+  align_buffer_page_end(src_b, kSrcPlaneSize);
+  memset(src_a, 0, kSrcPlaneSize);
+  memset(src_b, 0, kSrcPlaneSize);
+
+  if (kSrcWidth <= 8 || kSrcHeight <= 8) {
+    printf("warning - Ssim size too small.  Testing function executes.\n");
+  }
+
+  double err;
+  err = CalcFrameSsim(src_a + kSrcStride * b + b, kSrcStride,
+                      src_b + kSrcStride * b + b, kSrcStride, kSrcWidth,
+                      kSrcHeight);
+
+  if (kSrcWidth > 8 && kSrcHeight > 8) {
+    EXPECT_EQ(err, 1.0);
+  }
+
+  memset(src_a, 255, kSrcPlaneSize);
+
+  err = CalcFrameSsim(src_a + kSrcStride * b + b, kSrcStride,
+                      src_b + kSrcStride * b + b, kSrcStride, kSrcWidth,
+                      kSrcHeight);
+
+  if (kSrcWidth > 8 && kSrcHeight > 8) {
+    EXPECT_LT(err, 0.0001);
+  }
+
+  memset(src_a, 1, kSrcPlaneSize);
+
+  err = CalcFrameSsim(src_a + kSrcStride * b + b, kSrcStride,
+                      src_b + kSrcStride * b + b, kSrcStride, kSrcWidth,
+                      kSrcHeight);
+
+  if (kSrcWidth > 8 && kSrcHeight > 8) {
+    EXPECT_GT(err, 0.0001);
+    EXPECT_LT(err, 0.9);
+  }
+
+  for (int i = 0; i < kSrcPlaneSize; ++i) {
+    src_a[i] = i;
+  }
+
+  err = CalcFrameSsim(src_a + kSrcStride * b + b, kSrcStride,
+                      src_b + kSrcStride * b + b, kSrcStride, kSrcWidth,
+                      kSrcHeight);
+
+  if (kSrcWidth > 8 && kSrcHeight > 8) {
+    EXPECT_GT(err, 0.0);
+    EXPECT_LT(err, 0.01);
+  }
+
+  for (int i = b; i < (kSrcHeight + b); ++i) {
+    for (int j = b; j < (kSrcWidth + b); ++j) {
+      src_a[(i * kSrcStride) + j] = (fastrand() & 0xff);
+      src_b[(i * kSrcStride) + j] = (fastrand() & 0xff);
+    }
+  }
+
+  MaskCpuFlags(disable_cpu_flags_);
+  double c_err, opt_err;
+
+  c_err = CalcFrameSsim(src_a + kSrcStride * b + b, kSrcStride,
+                        src_b + kSrcStride * b + b, kSrcStride, kSrcWidth,
+                        kSrcHeight);
+
+  MaskCpuFlags(benchmark_cpu_info_);
+
+  opt_err = CalcFrameSsim(src_a + kSrcStride * b + b, kSrcStride,
+                          src_b + kSrcStride * b + b, kSrcStride, kSrcWidth,
+                          kSrcHeight);
+
+  if (kSrcWidth > 8 && kSrcHeight > 8) {
+    EXPECT_EQ(opt_err, c_err);
+  }
+
+  free_aligned_buffer_page_end(src_a);
+  free_aligned_buffer_page_end(src_b);
+}
+
+}  // namespace libyuv
diff --git a/3rdparty/libyuv/src/unit_test/convert_test.cc b/3rdparty/libyuv/src/unit_test/convert_test.cc
new file mode 100644
index 00000000..1f975825
--- /dev/null
+++ b/3rdparty/libyuv/src/unit_test/convert_test.cc
@@ -0,0 +1,4341 @@
+/*
+ *  Copyright 2011 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include <assert.h>
+#include <stdlib.h>
+#include <time.h>
+
+#include "libyuv/basic_types.h"
+#include "libyuv/compare.h"
+#include "libyuv/convert.h"
+#include "libyuv/convert_argb.h"
+#include "libyuv/convert_from.h"
+#include "libyuv/convert_from_argb.h"
+#include "libyuv/cpu_id.h"
+#ifdef HAVE_JPEG
+#include "libyuv/mjpeg_decoder.h"
+#endif
+#include "../unit_test/unit_test.h"
+#include "libyuv/planar_functions.h"
+#include "libyuv/rotate.h"
+#include "libyuv/video_common.h"
+
+#ifdef ENABLE_ROW_TESTS
+#include "libyuv/row.h" /* For ARGBToAR30Row_AVX2 */
+#endif
+
+// Some functions fail on big endian. Enable these tests on all cpus except
+// PowerPC, but they are not optimized so disabled by default.
+#if !defined(DISABLE_SLOW_TESTS) && !defined(__powerpc__)
+#define LITTLE_ENDIAN_ONLY_TEST 1
+#endif
+#if !defined(DISABLE_SLOW_TESTS) || defined(__x86_64__) || defined(__i386__)
+// SLOW TESTS are those that are unoptimized C code.
+// FULL TESTS are optimized but test many variations of the same code.
+#define ENABLE_FULL_TESTS
+#endif
+
+namespace libyuv {
+
+// Alias to copy pixels as is
+#define AR30ToAR30 ARGBCopy
+#define ABGRToABGR ARGBCopy
+
+#define SUBSAMPLE(v, a) ((((v) + (a)-1)) / (a))
+
+// Planar test
+
+#define TESTPLANARTOPI(SRC_FMT_PLANAR, SRC_T, SRC_BPC, SRC_SUBSAMP_X,         \
+                       SRC_SUBSAMP_Y, FMT_PLANAR, DST_T, DST_BPC,             \
+                       DST_SUBSAMP_X, DST_SUBSAMP_Y, W1280, N, NEG, OFF,      \
+                       SRC_DEPTH)                                             \
+  TEST_F(LibYUVConvertTest, SRC_FMT_PLANAR##To##FMT_PLANAR##N) {              \
+    static_assert(SRC_BPC == 1 || SRC_BPC == 2, "SRC BPC unsupported");       \
+    static_assert(DST_BPC == 1 || DST_BPC == 2, "DST BPC unsupported");       \
+    static_assert(SRC_SUBSAMP_X == 1 || SRC_SUBSAMP_X == 2,                   \
+                  "SRC_SUBSAMP_X unsupported");                               \
+    static_assert(SRC_SUBSAMP_Y == 1 || SRC_SUBSAMP_Y == 2,                   \
+                  "SRC_SUBSAMP_Y unsupported");                               \
+    static_assert(DST_SUBSAMP_X == 1 || DST_SUBSAMP_X == 2,                   \
+                  "DST_SUBSAMP_X unsupported");                               \
+    static_assert(DST_SUBSAMP_Y == 1 || DST_SUBSAMP_Y == 2,                   \
+                  "DST_SUBSAMP_Y unsupported");                               \
+    const int kWidth = W1280;                                                 \
+    const int kHeight = benchmark_height_;                                    \
+    const int kSrcHalfWidth = SUBSAMPLE(kWidth, SRC_SUBSAMP_X);               \
+    const int kSrcHalfHeight = SUBSAMPLE(kHeight, SRC_SUBSAMP_Y);             \
+    const int kDstHalfWidth = SUBSAMPLE(kWidth, DST_SUBSAMP_X);               \
+    const int kDstHalfHeight = SUBSAMPLE(kHeight, DST_SUBSAMP_Y);             \
+    align_buffer_page_end(src_y, kWidth* kHeight* SRC_BPC + OFF);             \
+    align_buffer_page_end(src_u,                                              \
+                          kSrcHalfWidth* kSrcHalfHeight* SRC_BPC + OFF);      \
+    align_buffer_page_end(src_v,                                              \
+                          kSrcHalfWidth* kSrcHalfHeight* SRC_BPC + OFF);      \
+    align_buffer_page_end(dst_y_c, kWidth* kHeight* DST_BPC);                 \
+    align_buffer_page_end(dst_u_c, kDstHalfWidth* kDstHalfHeight* DST_BPC);   \
+    align_buffer_page_end(dst_v_c, kDstHalfWidth* kDstHalfHeight* DST_BPC);   \
+    align_buffer_page_end(dst_y_opt, kWidth* kHeight* DST_BPC);               \
+    align_buffer_page_end(dst_u_opt, kDstHalfWidth* kDstHalfHeight* DST_BPC); \
+    align_buffer_page_end(dst_v_opt, kDstHalfWidth* kDstHalfHeight* DST_BPC); \
+    MemRandomize(src_y + OFF, kWidth * kHeight * SRC_BPC);                    \
+    MemRandomize(src_u + OFF, kSrcHalfWidth * kSrcHalfHeight * SRC_BPC);      \
+    MemRandomize(src_v + OFF, kSrcHalfWidth * kSrcHalfHeight * SRC_BPC);      \
+    SRC_T* src_y_p = reinterpret_cast<SRC_T*>(src_y + OFF);                   \
+    SRC_T* src_u_p = reinterpret_cast<SRC_T*>(src_u + OFF);                   \
+    SRC_T* src_v_p = reinterpret_cast<SRC_T*>(src_v + OFF);                   \
+    for (int i = 0; i < kWidth * kHeight; ++i) {                              \
+      src_y_p[i] = src_y_p[i] & ((1 << SRC_DEPTH) - 1);                       \
+    }                                                                         \
+    for (int i = 0; i < kSrcHalfWidth * kSrcHalfHeight; ++i) {                \
+      src_u_p[i] = src_u_p[i] & ((1 << SRC_DEPTH) - 1);                       \
+      src_v_p[i] = src_v_p[i] & ((1 << SRC_DEPTH) - 1);                       \
+    }                                                                         \
+    memset(dst_y_c, 1, kWidth* kHeight* DST_BPC);                             \
+    memset(dst_u_c, 2, kDstHalfWidth* kDstHalfHeight* DST_BPC);               \
+    memset(dst_v_c, 3, kDstHalfWidth* kDstHalfHeight* DST_BPC);               \
+    memset(dst_y_opt, 101, kWidth* kHeight* DST_BPC);                         \
+    memset(dst_u_opt, 102, kDstHalfWidth* kDstHalfHeight* DST_BPC);           \
+    memset(dst_v_opt, 103, kDstHalfWidth* kDstHalfHeight* DST_BPC);           \
+    MaskCpuFlags(disable_cpu_flags_);                                         \
+    SRC_FMT_PLANAR##To##FMT_PLANAR(                                           \
+        src_y_p, kWidth, src_u_p, kSrcHalfWidth, src_v_p, kSrcHalfWidth,      \
+        reinterpret_cast<DST_T*>(dst_y_c), kWidth,                            \
+        reinterpret_cast<DST_T*>(dst_u_c), kDstHalfWidth,                     \
+        reinterpret_cast<DST_T*>(dst_v_c), kDstHalfWidth, kWidth,             \
+        NEG kHeight);                                                         \
+    MaskCpuFlags(benchmark_cpu_info_);                                        \
+    for (int i = 0; i < benchmark_iterations_; ++i) {                         \
+      SRC_FMT_PLANAR##To##FMT_PLANAR(                                         \
+          src_y_p, kWidth, src_u_p, kSrcHalfWidth, src_v_p, kSrcHalfWidth,    \
+          reinterpret_cast<DST_T*>(dst_y_opt), kWidth,                        \
+          reinterpret_cast<DST_T*>(dst_u_opt), kDstHalfWidth,                 \
+          reinterpret_cast<DST_T*>(dst_v_opt), kDstHalfWidth, kWidth,         \
+          NEG kHeight);                                                       \
+    }                                                                         \
+    for (int i = 0; i < kHeight * kWidth * DST_BPC; ++i) {                    \
+      EXPECT_EQ(dst_y_c[i], dst_y_opt[i]);                                    \
+    }                                                                         \
+    for (int i = 0; i < kDstHalfWidth * kDstHalfHeight * DST_BPC; ++i) {      \
+      EXPECT_EQ(dst_u_c[i], dst_u_opt[i]);                                    \
+      EXPECT_EQ(dst_v_c[i], dst_v_opt[i]);                                    \
+    }                                                                         \
+    free_aligned_buffer_page_end(dst_y_c);                                    \
+    free_aligned_buffer_page_end(dst_u_c);                                    \
+    free_aligned_buffer_page_end(dst_v_c);                                    \
+    free_aligned_buffer_page_end(dst_y_opt);                                  \
+    free_aligned_buffer_page_end(dst_u_opt);                                  \
+    free_aligned_buffer_page_end(dst_v_opt);                                  \
+    free_aligned_buffer_page_end(src_y);                                      \
+    free_aligned_buffer_page_end(src_u);                                      \
+    free_aligned_buffer_page_end(src_v);                                      \
+  }
+
+#define TESTPLANARTOP(SRC_FMT_PLANAR, SRC_T, SRC_BPC, SRC_SUBSAMP_X,           \
+                      SRC_SUBSAMP_Y, FMT_PLANAR, DST_T, DST_BPC,               \
+                      DST_SUBSAMP_X, DST_SUBSAMP_Y, SRC_DEPTH)                 \
+  TESTPLANARTOPI(SRC_FMT_PLANAR, SRC_T, SRC_BPC, SRC_SUBSAMP_X, SRC_SUBSAMP_Y, \
+                 FMT_PLANAR, DST_T, DST_BPC, DST_SUBSAMP_X, DST_SUBSAMP_Y,     \
+                 benchmark_width_ + 1, _Any, +, 0, SRC_DEPTH)                  \
+  TESTPLANARTOPI(SRC_FMT_PLANAR, SRC_T, SRC_BPC, SRC_SUBSAMP_X, SRC_SUBSAMP_Y, \
+                 FMT_PLANAR, DST_T, DST_BPC, DST_SUBSAMP_X, DST_SUBSAMP_Y,     \
+                 benchmark_width_, _Unaligned, +, 2, SRC_DEPTH)                \
+  TESTPLANARTOPI(SRC_FMT_PLANAR, SRC_T, SRC_BPC, SRC_SUBSAMP_X, SRC_SUBSAMP_Y, \
+                 FMT_PLANAR, DST_T, DST_BPC, DST_SUBSAMP_X, DST_SUBSAMP_Y,     \
+                 benchmark_width_, _Invert, -, 0, SRC_DEPTH)                   \
+  TESTPLANARTOPI(SRC_FMT_PLANAR, SRC_T, SRC_BPC, SRC_SUBSAMP_X, SRC_SUBSAMP_Y, \
+                 FMT_PLANAR, DST_T, DST_BPC, DST_SUBSAMP_X, DST_SUBSAMP_Y,     \
+                 benchmark_width_, _Opt, +, 0, SRC_DEPTH)
+
+TESTPLANARTOP(I420, uint8_t, 1, 2, 2, I420, uint8_t, 1, 2, 2, 8)
+TESTPLANARTOP(I422, uint8_t, 1, 2, 1, I420, uint8_t, 1, 2, 2, 8)
+TESTPLANARTOP(I444, uint8_t, 1, 1, 1, I420, uint8_t, 1, 2, 2, 8)
+TESTPLANARTOP(I420, uint8_t, 1, 2, 2, I422, uint8_t, 1, 2, 1, 8)
+TESTPLANARTOP(I420, uint8_t, 1, 2, 2, I444, uint8_t, 1, 1, 1, 8)
+TESTPLANARTOP(I420, uint8_t, 1, 2, 2, I420Mirror, uint8_t, 1, 2, 2, 8)
+TESTPLANARTOP(I422, uint8_t, 1, 2, 1, I422, uint8_t, 1, 2, 1, 8)
+TESTPLANARTOP(I422, uint8_t, 1, 2, 1, I444, uint8_t, 1, 1, 1, 8)
+TESTPLANARTOP(I444, uint8_t, 1, 1, 1, I444, uint8_t, 1, 1, 1, 8)
+TESTPLANARTOP(I010, uint16_t, 2, 2, 2, I010, uint16_t, 2, 2, 2, 10)
+TESTPLANARTOP(I420, uint8_t, 1, 2, 2, I010, uint16_t, 2, 2, 2, 8)
+TESTPLANARTOP(I420, uint8_t, 1, 2, 2, I012, uint16_t, 2, 2, 2, 8)
+TESTPLANARTOP(H010, uint16_t, 2, 2, 2, H010, uint16_t, 2, 2, 2, 10)
+TESTPLANARTOP(H010, uint16_t, 2, 2, 2, H420, uint8_t, 1, 2, 2, 10)
+TESTPLANARTOP(H420, uint8_t, 1, 2, 2, H010, uint16_t, 2, 2, 2, 8)
+TESTPLANARTOP(H420, uint8_t, 1, 2, 2, H012, uint16_t, 2, 2, 2, 8)
+TESTPLANARTOP(I010, uint16_t, 2, 2, 2, I410, uint16_t, 2, 1, 1, 10)
+TESTPLANARTOP(I210, uint16_t, 2, 2, 1, I410, uint16_t, 2, 1, 1, 10)
+TESTPLANARTOP(I012, uint16_t, 2, 2, 2, I412, uint16_t, 2, 1, 1, 12)
+TESTPLANARTOP(I212, uint16_t, 2, 2, 1, I412, uint16_t, 2, 1, 1, 12)
+TESTPLANARTOP(I410, uint16_t, 2, 1, 1, I010, uint16_t, 2, 2, 2, 10)
+TESTPLANARTOP(I210, uint16_t, 2, 2, 1, I010, uint16_t, 2, 2, 2, 10)
+TESTPLANARTOP(I412, uint16_t, 2, 1, 1, I012, uint16_t, 2, 2, 2, 12)
+TESTPLANARTOP(I212, uint16_t, 2, 2, 1, I012, uint16_t, 2, 2, 2, 12)
+TESTPLANARTOP(I010, uint16_t, 2, 2, 2, I420, uint8_t, 1, 2, 2, 10)
+TESTPLANARTOP(I210, uint16_t, 2, 2, 1, I420, uint8_t, 1, 2, 2, 10)
+TESTPLANARTOP(I210, uint16_t, 2, 2, 1, I422, uint8_t, 1, 2, 1, 10)
+TESTPLANARTOP(I410, uint16_t, 2, 1, 1, I444, uint8_t, 1, 1, 1, 10)
+TESTPLANARTOP(I012, uint16_t, 2, 2, 2, I420, uint8_t, 1, 2, 2, 12)
+TESTPLANARTOP(I212, uint16_t, 2, 2, 1, I422, uint8_t, 1, 2, 1, 12)
+TESTPLANARTOP(I412, uint16_t, 2, 1, 1, I444, uint8_t, 1, 1, 1, 12)
+
+// Test Android 420 to I420
+#define TESTAPLANARTOPI(SRC_FMT_PLANAR, PIXEL_STRIDE, SRC_SUBSAMP_X,          \
+                        SRC_SUBSAMP_Y, FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y,      \
+                        W1280, N, NEG, OFF, PN, OFF_U, OFF_V)                 \
+  TEST_F(LibYUVConvertTest, SRC_FMT_PLANAR##To##FMT_PLANAR##To##PN##N) {      \
+    const int kWidth = W1280;                                                 \
+    const int kHeight = benchmark_height_;                                    \
+    const int kSizeUV =                                                       \
+        SUBSAMPLE(kWidth, SRC_SUBSAMP_X) * SUBSAMPLE(kHeight, SRC_SUBSAMP_Y); \
+    align_buffer_page_end(src_y, kWidth* kHeight + OFF);                      \
+    align_buffer_page_end(src_uv,                                             \
+                          kSizeUV*((PIXEL_STRIDE == 3) ? 3 : 2) + OFF);       \
+    align_buffer_page_end(dst_y_c, kWidth* kHeight);                          \
+    align_buffer_page_end(dst_u_c, SUBSAMPLE(kWidth, SUBSAMP_X) *             \
+                                       SUBSAMPLE(kHeight, SUBSAMP_Y));        \
+    align_buffer_page_end(dst_v_c, SUBSAMPLE(kWidth, SUBSAMP_X) *             \
+                                       SUBSAMPLE(kHeight, SUBSAMP_Y));        \
+    align_buffer_page_end(dst_y_opt, kWidth* kHeight);                        \
+    align_buffer_page_end(dst_u_opt, SUBSAMPLE(kWidth, SUBSAMP_X) *           \
+                                         SUBSAMPLE(kHeight, SUBSAMP_Y));      \
+    align_buffer_page_end(dst_v_opt, SUBSAMPLE(kWidth, SUBSAMP_X) *           \
+                                         SUBSAMPLE(kHeight, SUBSAMP_Y));      \
+    uint8_t* src_u = src_uv + OFF_U;                                          \
+    uint8_t* src_v = src_uv + (PIXEL_STRIDE == 1 ? kSizeUV : OFF_V);          \
+    int src_stride_uv = SUBSAMPLE(kWidth, SUBSAMP_X) * PIXEL_STRIDE;          \
+    for (int i = 0; i < kHeight; ++i)                                         \
+      for (int j = 0; j < kWidth; ++j)                                        \
+        src_y[i * kWidth + j + OFF] = (fastrand() & 0xff);                    \
+    for (int i = 0; i < SUBSAMPLE(kHeight, SRC_SUBSAMP_Y); ++i) {             \
+      for (int j = 0; j < SUBSAMPLE(kWidth, SRC_SUBSAMP_X); ++j) {            \
+        src_u[(i * src_stride_uv) + j * PIXEL_STRIDE + OFF] =                 \
+            (fastrand() & 0xff);                                              \
+        src_v[(i * src_stride_uv) + j * PIXEL_STRIDE + OFF] =                 \
+            (fastrand() & 0xff);                                              \
+      }                                                                       \
+    }                                                                         \
+    memset(dst_y_c, 1, kWidth* kHeight);                                      \
+    memset(dst_u_c, 2,                                                        \
+           SUBSAMPLE(kWidth, SUBSAMP_X) * SUBSAMPLE(kHeight, SUBSAMP_Y));     \
+    memset(dst_v_c, 3,                                                        \
+           SUBSAMPLE(kWidth, SUBSAMP_X) * SUBSAMPLE(kHeight, SUBSAMP_Y));     \
+    memset(dst_y_opt, 101, kWidth* kHeight);                                  \
+    memset(dst_u_opt, 102,                                                    \
+           SUBSAMPLE(kWidth, SUBSAMP_X) * SUBSAMPLE(kHeight, SUBSAMP_Y));     \
+    memset(dst_v_opt, 103,                                                    \
+           SUBSAMPLE(kWidth, SUBSAMP_X) * SUBSAMPLE(kHeight, SUBSAMP_Y));     \
+    MaskCpuFlags(disable_cpu_flags_);                                         \
+    SRC_FMT_PLANAR##To##FMT_PLANAR(                                           \
+        src_y + OFF, kWidth, src_u + OFF, SUBSAMPLE(kWidth, SRC_SUBSAMP_X),   \
+        src_v + OFF, SUBSAMPLE(kWidth, SRC_SUBSAMP_X), PIXEL_STRIDE, dst_y_c, \
+        kWidth, dst_u_c, SUBSAMPLE(kWidth, SUBSAMP_X), dst_v_c,               \
+        SUBSAMPLE(kWidth, SUBSAMP_X), kWidth, NEG kHeight);                   \
+    MaskCpuFlags(benchmark_cpu_info_);                                        \
+    for (int i = 0; i < benchmark_iterations_; ++i) {                         \
+      SRC_FMT_PLANAR##To##FMT_PLANAR(                                         \
+          src_y + OFF, kWidth, src_u + OFF, SUBSAMPLE(kWidth, SRC_SUBSAMP_X), \
+          src_v + OFF, SUBSAMPLE(kWidth, SRC_SUBSAMP_X), PIXEL_STRIDE,        \
+          dst_y_opt, kWidth, dst_u_opt, SUBSAMPLE(kWidth, SUBSAMP_X),         \
+          dst_v_opt, SUBSAMPLE(kWidth, SUBSAMP_X), kWidth, NEG kHeight);      \
+    }                                                                         \
+    for (int i = 0; i < kHeight; ++i) {                                       \
+      for (int j = 0; j < kWidth; ++j) {                                      \
+        EXPECT_EQ(dst_y_c[i * kWidth + j], dst_y_opt[i * kWidth + j]);        \
+      }                                                                       \
+    }                                                                         \
+    for (int i = 0; i < SUBSAMPLE(kHeight, SUBSAMP_Y); ++i) {                 \
+      for (int j = 0; j < SUBSAMPLE(kWidth, SUBSAMP_X); ++j) {                \
+        EXPECT_EQ(dst_u_c[i * SUBSAMPLE(kWidth, SUBSAMP_X) + j],              \
+                  dst_u_opt[i * SUBSAMPLE(kWidth, SUBSAMP_X) + j]);           \
+      }                                                                       \
+    }                                                                         \
+    for (int i = 0; i < SUBSAMPLE(kHeight, SUBSAMP_Y); ++i) {                 \
+      for (int j = 0; j < SUBSAMPLE(kWidth, SUBSAMP_X); ++j) {                \
+        EXPECT_EQ(dst_v_c[i * SUBSAMPLE(kWidth, SUBSAMP_X) + j],              \
+                  dst_v_opt[i * SUBSAMPLE(kWidth, SUBSAMP_X) + j]);           \
+      }                                                                       \
+    }                                                                         \
+    free_aligned_buffer_page_end(dst_y_c);                                    \
+    free_aligned_buffer_page_end(dst_u_c);                                    \
+    free_aligned_buffer_page_end(dst_v_c);                                    \
+    free_aligned_buffer_page_end(dst_y_opt);                                  \
+    free_aligned_buffer_page_end(dst_u_opt);                                  \
+    free_aligned_buffer_page_end(dst_v_opt);                                  \
+    free_aligned_buffer_page_end(src_y);                                      \
+    free_aligned_buffer_page_end(src_uv);                                     \
+  }
+
+#define TESTAPLANARTOP(SRC_FMT_PLANAR, PN, PIXEL_STRIDE, OFF_U, OFF_V,         \
+                       SRC_SUBSAMP_X, SRC_SUBSAMP_Y, FMT_PLANAR, SUBSAMP_X,    \
+                       SUBSAMP_Y)                                              \
+  TESTAPLANARTOPI(SRC_FMT_PLANAR, PIXEL_STRIDE, SRC_SUBSAMP_X, SRC_SUBSAMP_Y,  \
+                  FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, benchmark_width_ + 1,      \
+                  _Any, +, 0, PN, OFF_U, OFF_V)                                \
+  TESTAPLANARTOPI(SRC_FMT_PLANAR, PIXEL_STRIDE, SRC_SUBSAMP_X, SRC_SUBSAMP_Y,  \
+                  FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, benchmark_width_,          \
+                  _Unaligned, +, 2, PN, OFF_U, OFF_V)                          \
+  TESTAPLANARTOPI(SRC_FMT_PLANAR, PIXEL_STRIDE, SRC_SUBSAMP_X, SRC_SUBSAMP_Y,  \
+                  FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, benchmark_width_, _Invert, \
+                  -, 0, PN, OFF_U, OFF_V)                                      \
+  TESTAPLANARTOPI(SRC_FMT_PLANAR, PIXEL_STRIDE, SRC_SUBSAMP_X, SRC_SUBSAMP_Y,  \
+                  FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, benchmark_width_, _Opt, +, \
+                  0, PN, OFF_U, OFF_V)
+
+TESTAPLANARTOP(Android420, I420, 1, 0, 0, 2, 2, I420, 2, 2)
+TESTAPLANARTOP(Android420, NV12, 2, 0, 1, 2, 2, I420, 2, 2)
+TESTAPLANARTOP(Android420, NV21, 2, 1, 0, 2, 2, I420, 2, 2)
+#undef TESTAPLANARTOP
+#undef TESTAPLANARTOPI
+
+// wrapper to keep API the same
+int I400ToNV21(const uint8_t* src_y,
+               int src_stride_y,
+               const uint8_t* /* src_u */,
+               int /* src_stride_u */,
+               const uint8_t* /* src_v */,
+               int /* src_stride_v */,
+               uint8_t* dst_y,
+               int dst_stride_y,
+               uint8_t* dst_vu,
+               int dst_stride_vu,
+               int width,
+               int height) {
+  return I400ToNV21(src_y, src_stride_y, dst_y, dst_stride_y, dst_vu,
+                    dst_stride_vu, width, height);
+}
+
+#define TESTPLANARTOBPI(SRC_FMT_PLANAR, SRC_T, SRC_BPC, SRC_SUBSAMP_X,        \
+                        SRC_SUBSAMP_Y, FMT_PLANAR, DST_T, DST_BPC,            \
+                        DST_SUBSAMP_X, DST_SUBSAMP_Y, W1280, N, NEG, OFF,     \
+                        SRC_DEPTH)                                            \
+  TEST_F(LibYUVConvertTest, SRC_FMT_PLANAR##To##FMT_PLANAR##N) {              \
+    static_assert(SRC_BPC == 1 || SRC_BPC == 2, "SRC BPC unsupported");       \
+    static_assert(DST_BPC == 1 || DST_BPC == 2, "DST BPC unsupported");       \
+    static_assert(SRC_SUBSAMP_X == 1 || SRC_SUBSAMP_X == 2,                   \
+                  "SRC_SUBSAMP_X unsupported");                               \
+    static_assert(SRC_SUBSAMP_Y == 1 || SRC_SUBSAMP_Y == 2,                   \
+                  "SRC_SUBSAMP_Y unsupported");                               \
+    static_assert(DST_SUBSAMP_X == 1 || DST_SUBSAMP_X == 2,                   \
+                  "DST_SUBSAMP_X unsupported");                               \
+    static_assert(DST_SUBSAMP_Y == 1 || DST_SUBSAMP_Y == 2,                   \
+                  "DST_SUBSAMP_Y unsupported");                               \
+    const int kWidth = W1280;                                                 \
+    const int kHeight = benchmark_height_;                                    \
+    const int kSrcHalfWidth = SUBSAMPLE(kWidth, SRC_SUBSAMP_X);               \
+    const int kSrcHalfHeight = SUBSAMPLE(kHeight, SRC_SUBSAMP_Y);             \
+    const int kDstHalfWidth = SUBSAMPLE(kWidth, DST_SUBSAMP_X);               \
+    const int kDstHalfHeight = SUBSAMPLE(kHeight, DST_SUBSAMP_Y);             \
+    align_buffer_page_end(src_y, kWidth* kHeight* SRC_BPC + OFF);             \
+    align_buffer_page_end(src_u,                                              \
+                          kSrcHalfWidth* kSrcHalfHeight* SRC_BPC + OFF);      \
+    align_buffer_page_end(src_v,                                              \
+                          kSrcHalfWidth* kSrcHalfHeight* SRC_BPC + OFF);      \
+    align_buffer_page_end(dst_y_c, kWidth* kHeight* DST_BPC);                 \
+    align_buffer_page_end(dst_uv_c,                                           \
+                          kDstHalfWidth* kDstHalfHeight* DST_BPC * 2);        \
+    align_buffer_page_end(dst_y_opt, kWidth* kHeight* DST_BPC);               \
+    align_buffer_page_end(dst_uv_opt,                                         \
+                          kDstHalfWidth* kDstHalfHeight* DST_BPC * 2);        \
+    MemRandomize(src_y + OFF, kWidth * kHeight * SRC_BPC);                    \
+    MemRandomize(src_u + OFF, kSrcHalfWidth * kSrcHalfHeight * SRC_BPC);      \
+    MemRandomize(src_v + OFF, kSrcHalfWidth * kSrcHalfHeight * SRC_BPC);      \
+    SRC_T* src_y_p = reinterpret_cast<SRC_T*>(src_y + OFF);                   \
+    SRC_T* src_u_p = reinterpret_cast<SRC_T*>(src_u + OFF);                   \
+    SRC_T* src_v_p = reinterpret_cast<SRC_T*>(src_v + OFF);                   \
+    for (int i = 0; i < kWidth * kHeight; ++i) {                              \
+      src_y_p[i] = src_y_p[i] & ((1 << SRC_DEPTH) - 1);                       \
+    }                                                                         \
+    for (int i = 0; i < kSrcHalfWidth * kSrcHalfHeight; ++i) {                \
+      src_u_p[i] = src_u_p[i] & ((1 << SRC_DEPTH) - 1);                       \
+      src_v_p[i] = src_v_p[i] & ((1 << SRC_DEPTH) - 1);                       \
+    }                                                                         \
+    memset(dst_y_c, 1, kWidth* kHeight* DST_BPC);                             \
+    memset(dst_uv_c, 2, kDstHalfWidth* kDstHalfHeight* DST_BPC * 2);          \
+    memset(dst_y_opt, 101, kWidth* kHeight* DST_BPC);                         \
+    memset(dst_uv_opt, 102, kDstHalfWidth* kDstHalfHeight* DST_BPC * 2);      \
+    MaskCpuFlags(disable_cpu_flags_);                                         \
+    SRC_FMT_PLANAR##To##FMT_PLANAR(src_y_p, kWidth, src_u_p, kSrcHalfWidth,   \
+                                   src_v_p, kSrcHalfWidth,                    \
+                                   reinterpret_cast<DST_T*>(dst_y_c), kWidth, \
+                                   reinterpret_cast<DST_T*>(dst_uv_c),        \
+                                   kDstHalfWidth * 2, kWidth, NEG kHeight);   \
+    MaskCpuFlags(benchmark_cpu_info_);                                        \
+    for (int i = 0; i < benchmark_iterations_; ++i) {                         \
+      SRC_FMT_PLANAR##To##FMT_PLANAR(                                         \
+          src_y_p, kWidth, src_u_p, kSrcHalfWidth, src_v_p, kSrcHalfWidth,    \
+          reinterpret_cast<DST_T*>(dst_y_opt), kWidth,                        \
+          reinterpret_cast<DST_T*>(dst_uv_opt), kDstHalfWidth * 2, kWidth,    \
+          NEG kHeight);                                                       \
+    }                                                                         \
+    for (int i = 0; i < kHeight * kWidth * DST_BPC; ++i) {                    \
+      EXPECT_EQ(dst_y_c[i], dst_y_opt[i]);                                    \
+    }                                                                         \
+    for (int i = 0; i < kDstHalfWidth * kDstHalfHeight * DST_BPC * 2; ++i) {  \
+      EXPECT_EQ(dst_uv_c[i], dst_uv_opt[i]);                                  \
+    }                                                                         \
+    free_aligned_buffer_page_end(dst_y_c);                                    \
+    free_aligned_buffer_page_end(dst_uv_c);                                   \
+    free_aligned_buffer_page_end(dst_y_opt);                                  \
+    free_aligned_buffer_page_end(dst_uv_opt);                                 \
+    free_aligned_buffer_page_end(src_y);                                      \
+    free_aligned_buffer_page_end(src_u);                                      \
+    free_aligned_buffer_page_end(src_v);                                      \
+  }
+
+#define TESTPLANARTOBP(SRC_FMT_PLANAR, SRC_T, SRC_BPC, SRC_SUBSAMP_X,         \
+                       SRC_SUBSAMP_Y, FMT_PLANAR, DST_T, DST_BPC,             \
+                       DST_SUBSAMP_X, DST_SUBSAMP_Y, SRC_DEPTH)               \
+  TESTPLANARTOBPI(SRC_FMT_PLANAR, SRC_T, SRC_BPC, SRC_SUBSAMP_X,              \
+                  SRC_SUBSAMP_Y, FMT_PLANAR, DST_T, DST_BPC, DST_SUBSAMP_X,   \
+                  DST_SUBSAMP_Y, benchmark_width_ + 1, _Any, +, 0, SRC_DEPTH) \
+  TESTPLANARTOBPI(SRC_FMT_PLANAR, SRC_T, SRC_BPC, SRC_SUBSAMP_X,              \
+                  SRC_SUBSAMP_Y, FMT_PLANAR, DST_T, DST_BPC, DST_SUBSAMP_X,   \
+                  DST_SUBSAMP_Y, benchmark_width_, _Unaligned, +, 2,          \
+                  SRC_DEPTH)                                                  \
+  TESTPLANARTOBPI(SRC_FMT_PLANAR, SRC_T, SRC_BPC, SRC_SUBSAMP_X,              \
+                  SRC_SUBSAMP_Y, FMT_PLANAR, DST_T, DST_BPC, DST_SUBSAMP_X,   \
+                  DST_SUBSAMP_Y, benchmark_width_, _Invert, -, 0, SRC_DEPTH)  \
+  TESTPLANARTOBPI(SRC_FMT_PLANAR, SRC_T, SRC_BPC, SRC_SUBSAMP_X,              \
+                  SRC_SUBSAMP_Y, FMT_PLANAR, DST_T, DST_BPC, DST_SUBSAMP_X,   \
+                  DST_SUBSAMP_Y, benchmark_width_, _Opt, +, 0, SRC_DEPTH)
+
+TESTPLANARTOBP(I420, uint8_t, 1, 2, 2, NV12, uint8_t, 1, 2, 2, 8)
+TESTPLANARTOBP(I420, uint8_t, 1, 2, 2, NV21, uint8_t, 1, 2, 2, 8)
+TESTPLANARTOBP(I422, uint8_t, 1, 2, 1, NV21, uint8_t, 1, 2, 2, 8)
+TESTPLANARTOBP(I444, uint8_t, 1, 1, 1, NV12, uint8_t, 1, 2, 2, 8)
+TESTPLANARTOBP(I444, uint8_t, 1, 1, 1, NV21, uint8_t, 1, 2, 2, 8)
+TESTPLANARTOBP(I400, uint8_t, 1, 2, 2, NV21, uint8_t, 1, 2, 2, 8)
+TESTPLANARTOBP(I010, uint16_t, 2, 2, 2, P010, uint16_t, 2, 2, 2, 10)
+TESTPLANARTOBP(I210, uint16_t, 2, 2, 1, P210, uint16_t, 2, 2, 1, 10)
+TESTPLANARTOBP(I012, uint16_t, 2, 2, 2, P012, uint16_t, 2, 2, 2, 12)
+TESTPLANARTOBP(I212, uint16_t, 2, 2, 1, P212, uint16_t, 2, 2, 1, 12)
+
+#define TESTBIPLANARTOBPI(SRC_FMT_PLANAR, SRC_T, SRC_BPC, SRC_SUBSAMP_X,       \
+                          SRC_SUBSAMP_Y, FMT_PLANAR, DST_T, DST_BPC,           \
+                          DST_SUBSAMP_X, DST_SUBSAMP_Y, W1280, N, NEG, OFF,    \
+                          DOY, SRC_DEPTH, TILE_WIDTH, TILE_HEIGHT)             \
+  TEST_F(LibYUVConvertTest, SRC_FMT_PLANAR##To##FMT_PLANAR##N) {               \
+    static_assert(SRC_BPC == 1 || SRC_BPC == 2, "SRC BPC unsupported");        \
+    static_assert(DST_BPC == 1 || DST_BPC == 2, "DST BPC unsupported");        \
+    static_assert(SRC_SUBSAMP_X == 1 || SRC_SUBSAMP_X == 2,                    \
+                  "SRC_SUBSAMP_X unsupported");                                \
+    static_assert(SRC_SUBSAMP_Y == 1 || SRC_SUBSAMP_Y == 2,                    \
+                  "SRC_SUBSAMP_Y unsupported");                                \
+    static_assert(DST_SUBSAMP_X == 1 || DST_SUBSAMP_X == 2,                    \
+                  "DST_SUBSAMP_X unsupported");                                \
+    static_assert(DST_SUBSAMP_Y == 1 || DST_SUBSAMP_Y == 2,                    \
+                  "DST_SUBSAMP_Y unsupported");                                \
+    const int kWidth = W1280;                                                  \
+    const int kHeight = benchmark_height_;                                     \
+    const int kSrcHalfWidth = SUBSAMPLE(kWidth, SRC_SUBSAMP_X);                \
+    const int kDstHalfWidth = SUBSAMPLE(kWidth, DST_SUBSAMP_X);                \
+    const int kDstHalfHeight = SUBSAMPLE(kHeight, DST_SUBSAMP_Y);              \
+    const int kPaddedWidth = (kWidth + (TILE_WIDTH - 1)) & ~(TILE_WIDTH - 1);  \
+    const int kPaddedHeight =                                                  \
+        (kHeight + (TILE_HEIGHT - 1)) & ~(TILE_HEIGHT - 1);                    \
+    const int kSrcHalfPaddedWidth = SUBSAMPLE(kPaddedWidth, SRC_SUBSAMP_X);    \
+    const int kSrcHalfPaddedHeight = SUBSAMPLE(kPaddedHeight, SRC_SUBSAMP_Y);  \
+    align_buffer_page_end(src_y, kPaddedWidth* kPaddedHeight* SRC_BPC + OFF);  \
+    align_buffer_page_end(                                                     \
+        src_uv,                                                                \
+        2 * kSrcHalfPaddedWidth * kSrcHalfPaddedHeight * SRC_BPC + OFF);       \
+    align_buffer_page_end(dst_y_c, kWidth* kHeight* DST_BPC);                  \
+    align_buffer_page_end(dst_uv_c,                                            \
+                          2 * kDstHalfWidth * kDstHalfHeight * DST_BPC);       \
+    align_buffer_page_end(dst_y_opt, kWidth* kHeight* DST_BPC);                \
+    align_buffer_page_end(dst_uv_opt,                                          \
+                          2 * kDstHalfWidth * kDstHalfHeight * DST_BPC);       \
+    SRC_T* src_y_p = reinterpret_cast<SRC_T*>(src_y + OFF);                    \
+    SRC_T* src_uv_p = reinterpret_cast<SRC_T*>(src_uv + OFF);                  \
+    for (int i = 0; i < kPaddedWidth * kPaddedHeight; ++i) {                   \
+      src_y_p[i] =                                                             \
+          (fastrand() & (((SRC_T)(-1)) << ((8 * SRC_BPC) - SRC_DEPTH)));       \
+    }                                                                          \
+    for (int i = 0; i < kSrcHalfPaddedWidth * kSrcHalfPaddedHeight * 2; ++i) { \
+      src_uv_p[i] =                                                            \
+          (fastrand() & (((SRC_T)(-1)) << ((8 * SRC_BPC) - SRC_DEPTH)));       \
+    }                                                                          \
+    memset(dst_y_c, 1, kWidth* kHeight* DST_BPC);                              \
+    memset(dst_uv_c, 2, 2 * kDstHalfWidth * kDstHalfHeight * DST_BPC);         \
+    memset(dst_y_opt, 101, kWidth* kHeight* DST_BPC);                          \
+    memset(dst_uv_opt, 102, 2 * kDstHalfWidth * kDstHalfHeight * DST_BPC);     \
+    MaskCpuFlags(disable_cpu_flags_);                                          \
+    SRC_FMT_PLANAR##To##FMT_PLANAR(                                            \
+        src_y_p, kWidth, src_uv_p, 2 * kSrcHalfWidth,                          \
+        DOY ? reinterpret_cast<DST_T*>(dst_y_c) : NULL, kWidth,                \
+        reinterpret_cast<DST_T*>(dst_uv_c), 2 * kDstHalfWidth, kWidth,         \
+        NEG kHeight);                                                          \
+    MaskCpuFlags(benchmark_cpu_info_);                                         \
+    for (int i = 0; i < benchmark_iterations_; ++i) {                          \
+      SRC_FMT_PLANAR##To##FMT_PLANAR(                                          \
+          src_y_p, kWidth, src_uv_p, 2 * kSrcHalfWidth,                        \
+          DOY ? reinterpret_cast<DST_T*>(dst_y_opt) : NULL, kWidth,            \
+          reinterpret_cast<DST_T*>(dst_uv_opt), 2 * kDstHalfWidth, kWidth,     \
+          NEG kHeight);                                                        \
+    }                                                                          \
+    if (DOY) {                                                                 \
+      for (int i = 0; i < kHeight; ++i) {                                      \
+        for (int j = 0; j < kWidth; ++j) {                                     \
+          EXPECT_EQ(dst_y_c[i * kWidth + j], dst_y_opt[i * kWidth + j]);       \
+        }                                                                      \
+      }                                                                        \
+    }                                                                          \
+    for (int i = 0; i < kDstHalfHeight; ++i) {                                 \
+      for (int j = 0; j < 2 * kDstHalfWidth; ++j) {                            \
+        EXPECT_EQ(dst_uv_c[i * 2 * kDstHalfWidth + j],                         \
+                  dst_uv_opt[i * 2 * kDstHalfWidth + j]);                      \
+      }                                                                        \
+    }                                                                          \
+    free_aligned_buffer_page_end(dst_y_c);                                     \
+    free_aligned_buffer_page_end(dst_uv_c);                                    \
+    free_aligned_buffer_page_end(dst_y_opt);                                   \
+    free_aligned_buffer_page_end(dst_uv_opt);                                  \
+    free_aligned_buffer_page_end(src_y);                                       \
+    free_aligned_buffer_page_end(src_uv);                                      \
+  }
+
+#define TESTBIPLANARTOBP(SRC_FMT_PLANAR, SRC_T, SRC_BPC, SRC_SUBSAMP_X,        \
+                         SRC_SUBSAMP_Y, FMT_PLANAR, DST_T, DST_BPC,            \
+                         DST_SUBSAMP_X, DST_SUBSAMP_Y, SRC_DEPTH, TILE_WIDTH,  \
+                         TILE_HEIGHT)                                          \
+  TESTBIPLANARTOBPI(SRC_FMT_PLANAR, SRC_T, SRC_BPC, SRC_SUBSAMP_X,             \
+                    SRC_SUBSAMP_Y, FMT_PLANAR, DST_T, DST_BPC, DST_SUBSAMP_X,  \
+                    DST_SUBSAMP_Y, benchmark_width_ + 1, _Any, +, 0, 1,        \
+                    SRC_DEPTH, TILE_WIDTH, TILE_HEIGHT)                        \
+  TESTBIPLANARTOBPI(SRC_FMT_PLANAR, SRC_T, SRC_BPC, SRC_SUBSAMP_X,             \
+                    SRC_SUBSAMP_Y, FMT_PLANAR, DST_T, DST_BPC, DST_SUBSAMP_X,  \
+                    DST_SUBSAMP_Y, benchmark_width_, _Unaligned, +, 2, 1,      \
+                    SRC_DEPTH, TILE_WIDTH, TILE_HEIGHT)                        \
+  TESTBIPLANARTOBPI(SRC_FMT_PLANAR, SRC_T, SRC_BPC, SRC_SUBSAMP_X,             \
+                    SRC_SUBSAMP_Y, FMT_PLANAR, DST_T, DST_BPC, DST_SUBSAMP_X,  \
+                    DST_SUBSAMP_Y, benchmark_width_, _Invert, -, 0, 1,         \
+                    SRC_DEPTH, TILE_WIDTH, TILE_HEIGHT)                        \
+  TESTBIPLANARTOBPI(SRC_FMT_PLANAR, SRC_T, SRC_BPC, SRC_SUBSAMP_X,             \
+                    SRC_SUBSAMP_Y, FMT_PLANAR, DST_T, DST_BPC, DST_SUBSAMP_X,  \
+                    DST_SUBSAMP_Y, benchmark_width_, _Opt, +, 0, 1, SRC_DEPTH, \
+                    TILE_WIDTH, TILE_HEIGHT)                                   \
+  TESTBIPLANARTOBPI(SRC_FMT_PLANAR, SRC_T, SRC_BPC, SRC_SUBSAMP_X,             \
+                    SRC_SUBSAMP_Y, FMT_PLANAR, DST_T, DST_BPC, DST_SUBSAMP_X,  \
+                    DST_SUBSAMP_Y, benchmark_width_, _NullY, +, 0, 0,          \
+                    SRC_DEPTH, TILE_WIDTH, TILE_HEIGHT)
+
+TESTBIPLANARTOBP(NV21, uint8_t, 1, 2, 2, NV12, uint8_t, 1, 2, 2, 8, 1, 1)
+TESTBIPLANARTOBP(NV12, uint8_t, 1, 2, 2, NV12Mirror, uint8_t, 1, 2, 2, 8, 1, 1)
+TESTBIPLANARTOBP(NV12, uint8_t, 1, 2, 2, NV24, uint8_t, 1, 1, 1, 8, 1, 1)
+TESTBIPLANARTOBP(NV16, uint8_t, 1, 2, 1, NV24, uint8_t, 1, 1, 1, 8, 1, 1)
+TESTBIPLANARTOBP(P010, uint16_t, 2, 2, 2, P410, uint16_t, 2, 1, 1, 10, 1, 1)
+TESTBIPLANARTOBP(P210, uint16_t, 2, 2, 1, P410, uint16_t, 2, 1, 1, 10, 1, 1)
+TESTBIPLANARTOBP(P012, uint16_t, 2, 2, 2, P412, uint16_t, 2, 1, 1, 10, 1, 1)
+TESTBIPLANARTOBP(P212, uint16_t, 2, 2, 1, P412, uint16_t, 2, 1, 1, 12, 1, 1)
+TESTBIPLANARTOBP(P016, uint16_t, 2, 2, 2, P416, uint16_t, 2, 1, 1, 12, 1, 1)
+TESTBIPLANARTOBP(P216, uint16_t, 2, 2, 1, P416, uint16_t, 2, 1, 1, 12, 1, 1)
+TESTBIPLANARTOBP(MM21, uint8_t, 1, 2, 2, NV12, uint8_t, 1, 2, 2, 8, 16, 32)
+
+#define TESTBIPLANARTOPI(SRC_FMT_PLANAR, SRC_T, SRC_BPC, SRC_SUBSAMP_X,        \
+                         SRC_SUBSAMP_Y, FMT_PLANAR, DST_T, DST_BPC,            \
+                         DST_SUBSAMP_X, DST_SUBSAMP_Y, W1280, N, NEG, OFF,     \
+                         SRC_DEPTH, TILE_WIDTH, TILE_HEIGHT)                   \
+  TEST_F(LibYUVConvertTest, SRC_FMT_PLANAR##To##FMT_PLANAR##N) {               \
+    static_assert(SRC_BPC == 1 || SRC_BPC == 2, "SRC BPC unsupported");        \
+    static_assert(DST_BPC == 1 || DST_BPC == 2, "DST BPC unsupported");        \
+    static_assert(SRC_SUBSAMP_X == 1 || SRC_SUBSAMP_X == 2,                    \
+                  "SRC_SUBSAMP_X unsupported");                                \
+    static_assert(SRC_SUBSAMP_Y == 1 || SRC_SUBSAMP_Y == 2,                    \
+                  "SRC_SUBSAMP_Y unsupported");                                \
+    static_assert(DST_SUBSAMP_X == 1 || DST_SUBSAMP_X == 2,                    \
+                  "DST_SUBSAMP_X unsupported");                                \
+    static_assert(DST_SUBSAMP_Y == 1 || DST_SUBSAMP_Y == 2,                    \
+                  "DST_SUBSAMP_Y unsupported");                                \
+    const int kWidth = W1280;                                                  \
+    const int kHeight = benchmark_height_;                                     \
+    const int kSrcHalfWidth = SUBSAMPLE(kWidth, SRC_SUBSAMP_X);                \
+    const int kDstHalfWidth = SUBSAMPLE(kWidth, DST_SUBSAMP_X);                \
+    const int kDstHalfHeight = SUBSAMPLE(kHeight, DST_SUBSAMP_Y);              \
+    const int kPaddedWidth = (kWidth + (TILE_WIDTH - 1)) & ~(TILE_WIDTH - 1);  \
+    const int kPaddedHeight =                                                  \
+        (kHeight + (TILE_HEIGHT - 1)) & ~(TILE_HEIGHT - 1);                    \
+    const int kSrcHalfPaddedWidth = SUBSAMPLE(kPaddedWidth, SRC_SUBSAMP_X);    \
+    const int kSrcHalfPaddedHeight = SUBSAMPLE(kPaddedHeight, SRC_SUBSAMP_Y);  \
+    align_buffer_page_end(src_y, kPaddedWidth* kPaddedHeight* SRC_BPC + OFF);  \
+    align_buffer_page_end(                                                     \
+        src_uv, kSrcHalfPaddedWidth* kSrcHalfPaddedHeight* SRC_BPC * 2 + OFF); \
+    align_buffer_page_end(dst_y_c, kWidth* kHeight* DST_BPC);                  \
+    align_buffer_page_end(dst_u_c, kDstHalfWidth* kDstHalfHeight* DST_BPC);    \
+    align_buffer_page_end(dst_v_c, kDstHalfWidth* kDstHalfHeight* DST_BPC);    \
+    align_buffer_page_end(dst_y_opt, kWidth* kHeight* DST_BPC);                \
+    align_buffer_page_end(dst_u_opt, kDstHalfWidth* kDstHalfHeight* DST_BPC);  \
+    align_buffer_page_end(dst_v_opt, kDstHalfWidth* kDstHalfHeight* DST_BPC);  \
+    SRC_T* src_y_p = reinterpret_cast<SRC_T*>(src_y + OFF);                    \
+    SRC_T* src_uv_p = reinterpret_cast<SRC_T*>(src_uv + OFF);                  \
+    for (int i = 0; i < kPaddedWidth * kPaddedHeight; ++i) {                   \
+      src_y_p[i] =                                                             \
+          (fastrand() & (((SRC_T)(-1)) << ((8 * SRC_BPC) - SRC_DEPTH)));       \
+    }                                                                          \
+    for (int i = 0; i < kSrcHalfPaddedWidth * kSrcHalfPaddedHeight * 2; ++i) { \
+      src_uv_p[i] =                                                            \
+          (fastrand() & (((SRC_T)(-1)) << ((8 * SRC_BPC) - SRC_DEPTH)));       \
+    }                                                                          \
+    memset(dst_y_c, 1, kWidth* kHeight* DST_BPC);                              \
+    memset(dst_u_c, 2, kDstHalfWidth* kDstHalfHeight* DST_BPC);                \
+    memset(dst_v_c, 3, kDstHalfWidth* kDstHalfHeight* DST_BPC);                \
+    memset(dst_y_opt, 101, kWidth* kHeight* DST_BPC);                          \
+    memset(dst_u_opt, 102, kDstHalfWidth* kDstHalfHeight* DST_BPC);            \
+    memset(dst_v_opt, 103, kDstHalfWidth* kDstHalfHeight* DST_BPC);            \
+    MaskCpuFlags(disable_cpu_flags_);                                          \
+    SRC_FMT_PLANAR##To##FMT_PLANAR(                                            \
+        src_y_p, kWidth, src_uv_p, kSrcHalfWidth * 2,                          \
+        reinterpret_cast<DST_T*>(dst_y_c), kWidth,                             \
+        reinterpret_cast<DST_T*>(dst_u_c), kDstHalfWidth,                      \
+        reinterpret_cast<DST_T*>(dst_v_c), kDstHalfWidth, kWidth,              \
+        NEG kHeight);                                                          \
+    MaskCpuFlags(benchmark_cpu_info_);                                         \
+    for (int i = 0; i < benchmark_iterations_; ++i) {                          \
+      SRC_FMT_PLANAR##To##FMT_PLANAR(                                          \
+          src_y_p, kWidth, src_uv_p, kSrcHalfWidth * 2,                        \
+          reinterpret_cast<DST_T*>(dst_y_opt), kWidth,                         \
+          reinterpret_cast<DST_T*>(dst_u_opt), kDstHalfWidth,                  \
+          reinterpret_cast<DST_T*>(dst_v_opt), kDstHalfWidth, kWidth,          \
+          NEG kHeight);                                                        \
+    }                                                                          \
+    for (int i = 0; i < kHeight * kWidth * DST_BPC; ++i) {                     \
+      EXPECT_EQ(dst_y_c[i], dst_y_opt[i]);                                     \
+    }                                                                          \
+    for (int i = 0; i < kDstHalfWidth * kDstHalfHeight * DST_BPC; ++i) {       \
+      EXPECT_EQ(dst_u_c[i], dst_u_opt[i]);                                     \
+      EXPECT_EQ(dst_v_c[i], dst_v_opt[i]);                                     \
+    }                                                                          \
+    free_aligned_buffer_page_end(dst_y_c);                                     \
+    free_aligned_buffer_page_end(dst_u_c);                                     \
+    free_aligned_buffer_page_end(dst_v_c);                                     \
+    free_aligned_buffer_page_end(dst_y_opt);                                   \
+    free_aligned_buffer_page_end(dst_u_opt);                                   \
+    free_aligned_buffer_page_end(dst_v_opt);                                   \
+    free_aligned_buffer_page_end(src_y);                                       \
+    free_aligned_buffer_page_end(src_uv);                                      \
+  }
+
+#define TESTBIPLANARTOP(SRC_FMT_PLANAR, SRC_T, SRC_BPC, SRC_SUBSAMP_X,         \
+                        SRC_SUBSAMP_Y, FMT_PLANAR, DST_T, DST_BPC,             \
+                        DST_SUBSAMP_X, DST_SUBSAMP_Y, SRC_DEPTH, TILE_WIDTH,   \
+                        TILE_HEIGHT)                                           \
+  TESTBIPLANARTOPI(SRC_FMT_PLANAR, SRC_T, SRC_BPC, SRC_SUBSAMP_X,              \
+                   SRC_SUBSAMP_Y, FMT_PLANAR, DST_T, DST_BPC, DST_SUBSAMP_X,   \
+                   DST_SUBSAMP_Y, benchmark_width_ + 1, _Any, +, 0, SRC_DEPTH, \
+                   TILE_WIDTH, TILE_HEIGHT)                                    \
+  TESTBIPLANARTOPI(SRC_FMT_PLANAR, SRC_T, SRC_BPC, SRC_SUBSAMP_X,              \
+                   SRC_SUBSAMP_Y, FMT_PLANAR, DST_T, DST_BPC, DST_SUBSAMP_X,   \
+                   DST_SUBSAMP_Y, benchmark_width_, _Unaligned, +, 2,          \
+                   SRC_DEPTH, TILE_WIDTH, TILE_HEIGHT)                         \
+  TESTBIPLANARTOPI(SRC_FMT_PLANAR, SRC_T, SRC_BPC, SRC_SUBSAMP_X,              \
+                   SRC_SUBSAMP_Y, FMT_PLANAR, DST_T, DST_BPC, DST_SUBSAMP_X,   \
+                   DST_SUBSAMP_Y, benchmark_width_, _Invert, -, 0, SRC_DEPTH,  \
+                   TILE_WIDTH, TILE_HEIGHT)                                    \
+  TESTBIPLANARTOPI(SRC_FMT_PLANAR, SRC_T, SRC_BPC, SRC_SUBSAMP_X,              \
+                   SRC_SUBSAMP_Y, FMT_PLANAR, DST_T, DST_BPC, DST_SUBSAMP_X,   \
+                   DST_SUBSAMP_Y, benchmark_width_, _Opt, +, 0, SRC_DEPTH,     \
+                   TILE_WIDTH, TILE_HEIGHT)
+
+TESTBIPLANARTOP(NV12, uint8_t, 1, 2, 2, I420, uint8_t, 1, 2, 2, 8, 1, 1)
+TESTBIPLANARTOP(NV21, uint8_t, 1, 2, 2, I420, uint8_t, 1, 2, 2, 8, 1, 1)
+TESTBIPLANARTOP(MM21, uint8_t, 1, 2, 2, I420, uint8_t, 1, 2, 2, 8, 16, 32)
+
+// Provide matrix wrappers for full range bt.709
+#define F420ToABGR(a, b, c, d, e, f, g, h, i, j) \
+  I420ToARGBMatrix(a, b, e, f, c, d, g, h, &kYvuF709Constants, i, j)
+#define F420ToARGB(a, b, c, d, e, f, g, h, i, j) \
+  I420ToARGBMatrix(a, b, c, d, e, f, g, h, &kYuvF709Constants, i, j)
+#define F422ToABGR(a, b, c, d, e, f, g, h, i, j) \
+  I422ToARGBMatrix(a, b, e, f, c, d, g, h, &kYvuF709Constants, i, j)
+#define F422ToARGB(a, b, c, d, e, f, g, h, i, j) \
+  I422ToARGBMatrix(a, b, c, d, e, f, g, h, &kYuvF709Constants, i, j)
+#define F444ToABGR(a, b, c, d, e, f, g, h, i, j) \
+  I444ToARGBMatrix(a, b, e, f, c, d, g, h, &kYvuF709Constants, i, j)
+#define F444ToARGB(a, b, c, d, e, f, g, h, i, j) \
+  I444ToARGBMatrix(a, b, c, d, e, f, g, h, &kYuvF709Constants, i, j)
+
+// Provide matrix wrappers for full range bt.2020
+#define V420ToABGR(a, b, c, d, e, f, g, h, i, j) \
+  I420ToARGBMatrix(a, b, e, f, c, d, g, h, &kYvuV2020Constants, i, j)
+#define V420ToARGB(a, b, c, d, e, f, g, h, i, j) \
+  I420ToARGBMatrix(a, b, c, d, e, f, g, h, &kYuvV2020Constants, i, j)
+#define V422ToABGR(a, b, c, d, e, f, g, h, i, j) \
+  I422ToARGBMatrix(a, b, e, f, c, d, g, h, &kYvuV2020Constants, i, j)
+#define V422ToARGB(a, b, c, d, e, f, g, h, i, j) \
+  I422ToARGBMatrix(a, b, c, d, e, f, g, h, &kYuvV2020Constants, i, j)
+#define V444ToABGR(a, b, c, d, e, f, g, h, i, j) \
+  I444ToARGBMatrix(a, b, e, f, c, d, g, h, &kYvuV2020Constants, i, j)
+#define V444ToARGB(a, b, c, d, e, f, g, h, i, j) \
+  I444ToARGBMatrix(a, b, c, d, e, f, g, h, &kYuvV2020Constants, i, j)
+
+#define I420ToARGBFilter(a, b, c, d, e, f, g, h, i, j)                     \
+  I420ToARGBMatrixFilter(a, b, c, d, e, f, g, h, &kYuvI601Constants, i, j, \
+                         kFilterBilinear)
+#define I422ToARGBFilter(a, b, c, d, e, f, g, h, i, j)                     \
+  I422ToARGBMatrixFilter(a, b, c, d, e, f, g, h, &kYuvI601Constants, i, j, \
+                         kFilterBilinear)
+
+#define ALIGNINT(V, ALIGN) (((V) + (ALIGN)-1) / (ALIGN) * (ALIGN))
+
+#define TESTPLANARTOBI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN, \
+                       YALIGN, W1280, N, NEG, OFF)                            \
+  TEST_F(LibYUVConvertTest, FMT_PLANAR##To##FMT_B##N) {                       \
+    const int kWidth = W1280;                                                 \
+    const int kHeight = ALIGNINT(benchmark_height_, YALIGN);                  \
+    const int kStrideB = ALIGNINT(kWidth * BPP_B, ALIGN);                     \
+    const int kStrideUV = SUBSAMPLE(kWidth, SUBSAMP_X);                       \
+    const int kSizeUV = kStrideUV * SUBSAMPLE(kHeight, SUBSAMP_Y);            \
+    align_buffer_page_end(src_y, kWidth* kHeight + OFF);                      \
+    align_buffer_page_end(src_u, kSizeUV + OFF);                              \
+    align_buffer_page_end(src_v, kSizeUV + OFF);                              \
+    align_buffer_page_end(dst_argb_c, kStrideB* kHeight + OFF);               \
+    align_buffer_page_end(dst_argb_opt, kStrideB* kHeight + OFF);             \
+    for (int i = 0; i < kWidth * kHeight; ++i) {                              \
+      src_y[i + OFF] = (fastrand() & 0xff);                                   \
+    }                                                                         \
+    for (int i = 0; i < kSizeUV; ++i) {                                       \
+      src_u[i + OFF] = (fastrand() & 0xff);                                   \
+      src_v[i + OFF] = (fastrand() & 0xff);                                   \
+    }                                                                         \
+    memset(dst_argb_c + OFF, 1, kStrideB * kHeight);                          \
+    memset(dst_argb_opt + OFF, 101, kStrideB * kHeight);                      \
+    MaskCpuFlags(disable_cpu_flags_);                                         \
+    double time0 = get_time();                                                \
+    FMT_PLANAR##To##FMT_B(src_y + OFF, kWidth, src_u + OFF, kStrideUV,        \
+                          src_v + OFF, kStrideUV, dst_argb_c + OFF, kStrideB, \
+                          kWidth, NEG kHeight);                               \
+    double time1 = get_time();                                                \
+    MaskCpuFlags(benchmark_cpu_info_);                                        \
+    for (int i = 0; i < benchmark_iterations_; ++i) {                         \
+      FMT_PLANAR##To##FMT_B(src_y + OFF, kWidth, src_u + OFF, kStrideUV,      \
+                            src_v + OFF, kStrideUV, dst_argb_opt + OFF,       \
+                            kStrideB, kWidth, NEG kHeight);                   \
+    }                                                                         \
+    double time2 = get_time();                                                \
+    printf(" %8d us C - %8d us OPT\n",                                        \
+           static_cast<int>((time1 - time0) * 1e6),                           \
+           static_cast<int>((time2 - time1) * 1e6 / benchmark_iterations_));  \
+    for (int i = 0; i < kWidth * BPP_B * kHeight; ++i) {                      \
+      EXPECT_EQ(dst_argb_c[i + OFF], dst_argb_opt[i + OFF]);                  \
+    }                                                                         \
+    free_aligned_buffer_page_end(src_y);                                      \
+    free_aligned_buffer_page_end(src_u);                                      \
+    free_aligned_buffer_page_end(src_v);                                      \
+    free_aligned_buffer_page_end(dst_argb_c);                                 \
+    free_aligned_buffer_page_end(dst_argb_opt);                               \
+  }
+
+#if defined(ENABLE_FULL_TESTS)
+#define TESTPLANARTOB(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN, \
+                      YALIGN)                                                \
+  TESTPLANARTOBI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN,      \
+                 YALIGN, benchmark_width_ + 1, _Any, +, 0)                   \
+  TESTPLANARTOBI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN,      \
+                 YALIGN, benchmark_width_, _Unaligned, +, 4)                 \
+  TESTPLANARTOBI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN,      \
+                 YALIGN, benchmark_width_, _Invert, -, 0)                    \
+  TESTPLANARTOBI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN,      \
+                 YALIGN, benchmark_width_, _Opt, +, 0)
+#else
+#define TESTPLANARTOB(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN, \
+                      YALIGN)                                                \
+  TESTPLANARTOBI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN,      \
+                 YALIGN, benchmark_width_ + 1, _Any, +, 0)                   \
+  TESTPLANARTOBI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN,      \
+                 YALIGN, benchmark_width_, _Opt, +, 0)
+#endif
+
+#if defined(ENABLE_FULL_TESTS)
+TESTPLANARTOB(I420, 2, 2, ARGB, 4, 4, 1)
+TESTPLANARTOB(I420, 2, 2, ABGR, 4, 4, 1)
+TESTPLANARTOB(J420, 2, 2, ARGB, 4, 4, 1)
+TESTPLANARTOB(J420, 2, 2, ABGR, 4, 4, 1)
+TESTPLANARTOB(F420, 2, 2, ARGB, 4, 4, 1)
+TESTPLANARTOB(F420, 2, 2, ABGR, 4, 4, 1)
+TESTPLANARTOB(H420, 2, 2, ARGB, 4, 4, 1)
+TESTPLANARTOB(H420, 2, 2, ABGR, 4, 4, 1)
+TESTPLANARTOB(U420, 2, 2, ARGB, 4, 4, 1)
+TESTPLANARTOB(U420, 2, 2, ABGR, 4, 4, 1)
+TESTPLANARTOB(V420, 2, 2, ARGB, 4, 4, 1)
+TESTPLANARTOB(V420, 2, 2, ABGR, 4, 4, 1)
+TESTPLANARTOB(I420, 2, 2, BGRA, 4, 4, 1)
+TESTPLANARTOB(I420, 2, 2, RGBA, 4, 4, 1)
+TESTPLANARTOB(I420, 2, 2, RAW, 3, 3, 1)
+TESTPLANARTOB(I420, 2, 2, RGB24, 3, 3, 1)
+TESTPLANARTOB(J420, 2, 2, RAW, 3, 3, 1)
+TESTPLANARTOB(J420, 2, 2, RGB24, 3, 3, 1)
+TESTPLANARTOB(H420, 2, 2, RAW, 3, 3, 1)
+TESTPLANARTOB(H420, 2, 2, RGB24, 3, 3, 1)
+#ifdef LITTLE_ENDIAN_ONLY_TEST
+TESTPLANARTOB(I420, 2, 2, RGB565, 2, 2, 1)
+TESTPLANARTOB(J420, 2, 2, RGB565, 2, 2, 1)
+TESTPLANARTOB(H420, 2, 2, RGB565, 2, 2, 1)
+TESTPLANARTOB(I420, 2, 2, ARGB1555, 2, 2, 1)
+TESTPLANARTOB(I420, 2, 2, ARGB4444, 2, 2, 1)
+TESTPLANARTOB(I422, 2, 1, RGB565, 2, 2, 1)
+#endif
+TESTPLANARTOB(I422, 2, 1, ARGB, 4, 4, 1)
+TESTPLANARTOB(I422, 2, 1, ABGR, 4, 4, 1)
+TESTPLANARTOB(J422, 2, 1, ARGB, 4, 4, 1)
+TESTPLANARTOB(J422, 2, 1, ABGR, 4, 4, 1)
+TESTPLANARTOB(H422, 2, 1, ARGB, 4, 4, 1)
+TESTPLANARTOB(H422, 2, 1, ABGR, 4, 4, 1)
+TESTPLANARTOB(U422, 2, 1, ARGB, 4, 4, 1)
+TESTPLANARTOB(U422, 2, 1, ABGR, 4, 4, 1)
+TESTPLANARTOB(V422, 2, 1, ARGB, 4, 4, 1)
+TESTPLANARTOB(V422, 2, 1, ABGR, 4, 4, 1)
+TESTPLANARTOB(I422, 2, 1, BGRA, 4, 4, 1)
+TESTPLANARTOB(I422, 2, 1, RGBA, 4, 4, 1)
+TESTPLANARTOB(I444, 1, 1, ARGB, 4, 4, 1)
+TESTPLANARTOB(I444, 1, 1, ABGR, 4, 4, 1)
+TESTPLANARTOB(J444, 1, 1, ARGB, 4, 4, 1)
+TESTPLANARTOB(J444, 1, 1, ABGR, 4, 4, 1)
+TESTPLANARTOB(H444, 1, 1, ARGB, 4, 4, 1)
+TESTPLANARTOB(H444, 1, 1, ABGR, 4, 4, 1)
+TESTPLANARTOB(U444, 1, 1, ARGB, 4, 4, 1)
+TESTPLANARTOB(U444, 1, 1, ABGR, 4, 4, 1)
+TESTPLANARTOB(V444, 1, 1, ARGB, 4, 4, 1)
+TESTPLANARTOB(V444, 1, 1, ABGR, 4, 4, 1)
+TESTPLANARTOB(I420, 2, 2, YUY2, 2, 4, 1)
+TESTPLANARTOB(I420, 2, 2, UYVY, 2, 4, 1)
+TESTPLANARTOB(I422, 2, 1, YUY2, 2, 4, 1)
+TESTPLANARTOB(I422, 2, 1, UYVY, 2, 4, 1)
+TESTPLANARTOB(I420, 2, 2, I400, 1, 1, 1)
+TESTPLANARTOB(J420, 2, 2, J400, 1, 1, 1)
+#ifdef LITTLE_ENDIAN_ONLY_TEST
+TESTPLANARTOB(I420, 2, 2, AR30, 4, 4, 1)
+TESTPLANARTOB(H420, 2, 2, AR30, 4, 4, 1)
+TESTPLANARTOB(I420, 2, 2, AB30, 4, 4, 1)
+TESTPLANARTOB(H420, 2, 2, AB30, 4, 4, 1)
+#endif
+TESTPLANARTOB(I420, 2, 2, ARGBFilter, 4, 4, 1)
+TESTPLANARTOB(I422, 2, 1, ARGBFilter, 4, 4, 1)
+#else
+TESTPLANARTOB(I420, 2, 2, ABGR, 4, 4, 1)
+TESTPLANARTOB(I420, 2, 2, ARGB, 4, 4, 1)
+TESTPLANARTOB(I420, 2, 2, BGRA, 4, 4, 1)
+TESTPLANARTOB(I420, 2, 2, RAW, 3, 3, 1)
+TESTPLANARTOB(I420, 2, 2, RGB24, 3, 3, 1)
+TESTPLANARTOB(I420, 2, 2, RGBA, 4, 4, 1)
+#ifdef LITTLE_ENDIAN_ONLY_TEST
+TESTPLANARTOB(I420, 2, 2, RGB565, 2, 2, 1)
+TESTPLANARTOB(I420, 2, 2, ARGB1555, 2, 2, 1)
+TESTPLANARTOB(I420, 2, 2, ARGB4444, 2, 2, 1)
+TESTPLANARTOB(I422, 2, 1, RGB565, 2, 2, 1)
+#endif
+TESTPLANARTOB(I420, 2, 2, I400, 1, 1, 1)
+TESTPLANARTOB(I420, 2, 2, UYVY, 2, 4, 1)
+TESTPLANARTOB(I420, 2, 2, YUY2, 2, 4, 1)
+TESTPLANARTOB(I420, 2, 2, ARGBFilter, 4, 4, 1)
+TESTPLANARTOB(I422, 2, 1, ABGR, 4, 4, 1)
+TESTPLANARTOB(I422, 2, 1, ARGB, 4, 4, 1)
+TESTPLANARTOB(I422, 2, 1, BGRA, 4, 4, 1)
+TESTPLANARTOB(I422, 2, 1, RGBA, 4, 4, 1)
+TESTPLANARTOB(I422, 2, 1, UYVY, 2, 4, 1)
+TESTPLANARTOB(I422, 2, 1, YUY2, 2, 4, 1)
+TESTPLANARTOB(I422, 2, 1, ARGBFilter, 4, 4, 1)
+TESTPLANARTOB(I444, 1, 1, ABGR, 4, 4, 1)
+TESTPLANARTOB(I444, 1, 1, ARGB, 4, 4, 1)
+#endif
+
+#define TESTQPLANARTOBI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN, \
+                        YALIGN, W1280, N, NEG, OFF, ATTEN)                     \
+  TEST_F(LibYUVConvertTest, FMT_PLANAR##To##FMT_B##N) {                        \
+    const int kWidth = W1280;                                                  \
+    const int kHeight = ALIGNINT(benchmark_height_, YALIGN);                   \
+    const int kStrideB = ALIGNINT(kWidth * BPP_B, ALIGN);                      \
+    const int kStrideUV = SUBSAMPLE(kWidth, SUBSAMP_X);                        \
+    const int kSizeUV = kStrideUV * SUBSAMPLE(kHeight, SUBSAMP_Y);             \
+    align_buffer_page_end(src_y, kWidth* kHeight + OFF);                       \
+    align_buffer_page_end(src_u, kSizeUV + OFF);                               \
+    align_buffer_page_end(src_v, kSizeUV + OFF);                               \
+    align_buffer_page_end(src_a, kWidth* kHeight + OFF);                       \
+    align_buffer_page_end(dst_argb_c, kStrideB* kHeight + OFF);                \
+    align_buffer_page_end(dst_argb_opt, kStrideB* kHeight + OFF);              \
+    for (int i = 0; i < kWidth * kHeight; ++i) {                               \
+      src_y[i + OFF] = (fastrand() & 0xff);                                    \
+      src_a[i + OFF] = (fastrand() & 0xff);                                    \
+    }                                                                          \
+    for (int i = 0; i < kSizeUV; ++i) {                                        \
+      src_u[i + OFF] = (fastrand() & 0xff);                                    \
+      src_v[i + OFF] = (fastrand() & 0xff);                                    \
+    }                                                                          \
+    memset(dst_argb_c + OFF, 1, kStrideB * kHeight);                           \
+    memset(dst_argb_opt + OFF, 101, kStrideB * kHeight);                       \
+    MaskCpuFlags(disable_cpu_flags_);                                          \
+    FMT_PLANAR##To##FMT_B(src_y + OFF, kWidth, src_u + OFF, kStrideUV,         \
+                          src_v + OFF, kStrideUV, src_a + OFF, kWidth,         \
+                          dst_argb_c + OFF, kStrideB, kWidth, NEG kHeight,     \
+                          ATTEN);                                              \
+    MaskCpuFlags(benchmark_cpu_info_);                                         \
+    for (int i = 0; i < benchmark_iterations_; ++i) {                          \
+      FMT_PLANAR##To##FMT_B(src_y + OFF, kWidth, src_u + OFF, kStrideUV,       \
+                            src_v + OFF, kStrideUV, src_a + OFF, kWidth,       \
+                            dst_argb_opt + OFF, kStrideB, kWidth, NEG kHeight, \
+                            ATTEN);                                            \
+    }                                                                          \
+    for (int i = 0; i < kWidth * BPP_B * kHeight; ++i) {                       \
+      EXPECT_EQ(dst_argb_c[i + OFF], dst_argb_opt[i + OFF]);                   \
+    }                                                                          \
+    free_aligned_buffer_page_end(src_y);                                       \
+    free_aligned_buffer_page_end(src_u);                                       \
+    free_aligned_buffer_page_end(src_v);                                       \
+    free_aligned_buffer_page_end(src_a);                                       \
+    free_aligned_buffer_page_end(dst_argb_c);                                  \
+    free_aligned_buffer_page_end(dst_argb_opt);                                \
+  }
+
+#if defined(ENABLE_FULL_TESTS)
+#define TESTQPLANARTOB(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN, \
+                       YALIGN)                                                \
+  TESTQPLANARTOBI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN,      \
+                  YALIGN, benchmark_width_ + 1, _Any, +, 0, 0)                \
+  TESTQPLANARTOBI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN,      \
+                  YALIGN, benchmark_width_, _Unaligned, +, 2, 0)              \
+  TESTQPLANARTOBI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN,      \
+                  YALIGN, benchmark_width_, _Invert, -, 0, 0)                 \
+  TESTQPLANARTOBI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN,      \
+                  YALIGN, benchmark_width_, _Opt, +, 0, 0)                    \
+  TESTQPLANARTOBI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN,      \
+                  YALIGN, benchmark_width_, _Premult, +, 0, 1)
+#else
+#define TESTQPLANARTOB(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN, \
+                       YALIGN)                                                \
+  TESTQPLANARTOBI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN,      \
+                  YALIGN, benchmark_width_, _Opt, +, 0, 0)
+#endif
+
+#define J420AlphaToARGB(a, b, c, d, e, f, g, h, i, j, k, l, m)               \
+  I420AlphaToARGBMatrix(a, b, c, d, e, f, g, h, i, j, &kYuvJPEGConstants, k, \
+                        l, m)
+#define J420AlphaToABGR(a, b, c, d, e, f, g, h, i, j, k, l, m)               \
+  I420AlphaToABGRMatrix(a, b, c, d, e, f, g, h, i, j, &kYuvJPEGConstants, k, \
+                        l, m)
+#define F420AlphaToARGB(a, b, c, d, e, f, g, h, i, j, k, l, m)               \
+  I420AlphaToARGBMatrix(a, b, c, d, e, f, g, h, i, j, &kYuvF709Constants, k, \
+                        l, m)
+#define F420AlphaToABGR(a, b, c, d, e, f, g, h, i, j, k, l, m)               \
+  I420AlphaToABGRMatrix(a, b, c, d, e, f, g, h, i, j, &kYuvF709Constants, k, \
+                        l, m)
+#define H420AlphaToARGB(a, b, c, d, e, f, g, h, i, j, k, l, m)               \
+  I420AlphaToARGBMatrix(a, b, c, d, e, f, g, h, i, j, &kYuvH709Constants, k, \
+                        l, m)
+#define H420AlphaToABGR(a, b, c, d, e, f, g, h, i, j, k, l, m)               \
+  I420AlphaToABGRMatrix(a, b, c, d, e, f, g, h, i, j, &kYuvH709Constants, k, \
+                        l, m)
+#define U420AlphaToARGB(a, b, c, d, e, f, g, h, i, j, k, l, m)               \
+  I420AlphaToARGBMatrix(a, b, c, d, e, f, g, h, i, j, &kYuv2020Constants, k, \
+                        l, m)
+#define U420AlphaToABGR(a, b, c, d, e, f, g, h, i, j, k, l, m)               \
+  I420AlphaToABGRMatrix(a, b, c, d, e, f, g, h, i, j, &kYuv2020Constants, k, \
+                        l, m)
+#define V420AlphaToARGB(a, b, c, d, e, f, g, h, i, j, k, l, m)                \
+  I420AlphaToARGBMatrix(a, b, c, d, e, f, g, h, i, j, &kYuvV2020Constants, k, \
+                        l, m)
+#define V420AlphaToABGR(a, b, c, d, e, f, g, h, i, j, k, l, m)                \
+  I420AlphaToABGRMatrix(a, b, c, d, e, f, g, h, i, j, &kYuvV2020Constants, k, \
+                        l, m)
+#define J422AlphaToARGB(a, b, c, d, e, f, g, h, i, j, k, l, m)               \
+  I422AlphaToARGBMatrix(a, b, c, d, e, f, g, h, i, j, &kYuvJPEGConstants, k, \
+                        l, m)
+#define J422AlphaToABGR(a, b, c, d, e, f, g, h, i, j, k, l, m)               \
+  I422AlphaToABGRMatrix(a, b, c, d, e, f, g, h, i, j, &kYuvJPEGConstants, k, \
+                        l, m)
+#define F422AlphaToARGB(a, b, c, d, e, f, g, h, i, j, k, l, m)               \
+  I422AlphaToARGBMatrix(a, b, c, d, e, f, g, h, i, j, &kYuvF709Constants, k, \
+                        l, m)
+#define F422AlphaToABGR(a, b, c, d, e, f, g, h, i, j, k, l, m)               \
+  I422AlphaToABGRMatrix(a, b, c, d, e, f, g, h, i, j, &kYuvF709Constants, k, \
+                        l, m)
+#define H422AlphaToARGB(a, b, c, d, e, f, g, h, i, j, k, l, m)               \
+  I422AlphaToARGBMatrix(a, b, c, d, e, f, g, h, i, j, &kYuvH709Constants, k, \
+                        l, m)
+#define H422AlphaToABGR(a, b, c, d, e, f, g, h, i, j, k, l, m)               \
+  I422AlphaToABGRMatrix(a, b, c, d, e, f, g, h, i, j, &kYuvH709Constants, k, \
+                        l, m)
+#define U422AlphaToARGB(a, b, c, d, e, f, g, h, i, j, k, l, m)               \
+  I422AlphaToARGBMatrix(a, b, c, d, e, f, g, h, i, j, &kYuv2020Constants, k, \
+                        l, m)
+#define U422AlphaToABGR(a, b, c, d, e, f, g, h, i, j, k, l, m)               \
+  I422AlphaToABGRMatrix(a, b, c, d, e, f, g, h, i, j, &kYuv2020Constants, k, \
+                        l, m)
+#define V422AlphaToARGB(a, b, c, d, e, f, g, h, i, j, k, l, m)                \
+  I422AlphaToARGBMatrix(a, b, c, d, e, f, g, h, i, j, &kYuvV2020Constants, k, \
+                        l, m)
+#define V422AlphaToABGR(a, b, c, d, e, f, g, h, i, j, k, l, m)                \
+  I422AlphaToABGRMatrix(a, b, c, d, e, f, g, h, i, j, &kYuvV2020Constants, k, \
+                        l, m)
+#define J444AlphaToARGB(a, b, c, d, e, f, g, h, i, j, k, l, m)               \
+  I444AlphaToARGBMatrix(a, b, c, d, e, f, g, h, i, j, &kYuvJPEGConstants, k, \
+                        l, m)
+#define J444AlphaToABGR(a, b, c, d, e, f, g, h, i, j, k, l, m)               \
+  I444AlphaToABGRMatrix(a, b, c, d, e, f, g, h, i, j, &kYuvJPEGConstants, k, \
+                        l, m)
+#define F444AlphaToARGB(a, b, c, d, e, f, g, h, i, j, k, l, m)               \
+  I444AlphaToARGBMatrix(a, b, c, d, e, f, g, h, i, j, &kYuvF709Constants, k, \
+                        l, m)
+#define F444AlphaToABGR(a, b, c, d, e, f, g, h, i, j, k, l, m)               \
+  I444AlphaToABGRMatrix(a, b, c, d, e, f, g, h, i, j, &kYuvF709Constants, k, \
+                        l, m)
+#define H444AlphaToARGB(a, b, c, d, e, f, g, h, i, j, k, l, m)               \
+  I444AlphaToARGBMatrix(a, b, c, d, e, f, g, h, i, j, &kYuvH709Constants, k, \
+                        l, m)
+#define H444AlphaToABGR(a, b, c, d, e, f, g, h, i, j, k, l, m)               \
+  I444AlphaToABGRMatrix(a, b, c, d, e, f, g, h, i, j, &kYuvH709Constants, k, \
+                        l, m)
+#define U444AlphaToARGB(a, b, c, d, e, f, g, h, i, j, k, l, m)               \
+  I444AlphaToARGBMatrix(a, b, c, d, e, f, g, h, i, j, &kYuv2020Constants, k, \
+                        l, m)
+#define U444AlphaToABGR(a, b, c, d, e, f, g, h, i, j, k, l, m)               \
+  I444AlphaToABGRMatrix(a, b, c, d, e, f, g, h, i, j, &kYuv2020Constants, k, \
+                        l, m)
+#define V444AlphaToARGB(a, b, c, d, e, f, g, h, i, j, k, l, m)                \
+  I444AlphaToARGBMatrix(a, b, c, d, e, f, g, h, i, j, &kYuvV2020Constants, k, \
+                        l, m)
+#define V444AlphaToABGR(a, b, c, d, e, f, g, h, i, j, k, l, m)                \
+  I444AlphaToABGRMatrix(a, b, c, d, e, f, g, h, i, j, &kYuvV2020Constants, k, \
+                        l, m)
+
+#define I420AlphaToARGBFilter(a, b, c, d, e, f, g, h, i, j, k, l, m) \
+  I420AlphaToARGBMatrixFilter(a, b, c, d, e, f, g, h, i, j,          \
+                              &kYuvI601Constants, k, l, m, kFilterBilinear)
+#define I422AlphaToARGBFilter(a, b, c, d, e, f, g, h, i, j, k, l, m) \
+  I422AlphaToARGBMatrixFilter(a, b, c, d, e, f, g, h, i, j,          \
+                              &kYuvI601Constants, k, l, m, kFilterBilinear)
+
+#if defined(ENABLE_FULL_TESTS)
+TESTQPLANARTOB(I420Alpha, 2, 2, ARGB, 4, 4, 1)
+TESTQPLANARTOB(I420Alpha, 2, 2, ABGR, 4, 4, 1)
+TESTQPLANARTOB(J420Alpha, 2, 2, ARGB, 4, 4, 1)
+TESTQPLANARTOB(J420Alpha, 2, 2, ABGR, 4, 4, 1)
+TESTQPLANARTOB(H420Alpha, 2, 2, ARGB, 4, 4, 1)
+TESTQPLANARTOB(H420Alpha, 2, 2, ABGR, 4, 4, 1)
+TESTQPLANARTOB(F420Alpha, 2, 2, ARGB, 4, 4, 1)
+TESTQPLANARTOB(F420Alpha, 2, 2, ABGR, 4, 4, 1)
+TESTQPLANARTOB(U420Alpha, 2, 2, ARGB, 4, 4, 1)
+TESTQPLANARTOB(U420Alpha, 2, 2, ABGR, 4, 4, 1)
+TESTQPLANARTOB(V420Alpha, 2, 2, ARGB, 4, 4, 1)
+TESTQPLANARTOB(V420Alpha, 2, 2, ABGR, 4, 4, 1)
+TESTQPLANARTOB(I422Alpha, 2, 1, ARGB, 4, 4, 1)
+TESTQPLANARTOB(I422Alpha, 2, 1, ABGR, 4, 4, 1)
+TESTQPLANARTOB(J422Alpha, 2, 1, ARGB, 4, 4, 1)
+TESTQPLANARTOB(J422Alpha, 2, 1, ABGR, 4, 4, 1)
+TESTQPLANARTOB(H422Alpha, 2, 1, ARGB, 4, 4, 1)
+TESTQPLANARTOB(H422Alpha, 2, 1, ABGR, 4, 4, 1)
+TESTQPLANARTOB(F422Alpha, 2, 1, ARGB, 4, 4, 1)
+TESTQPLANARTOB(F422Alpha, 2, 1, ABGR, 4, 4, 1)
+TESTQPLANARTOB(U422Alpha, 2, 1, ARGB, 4, 4, 1)
+TESTQPLANARTOB(U422Alpha, 2, 1, ABGR, 4, 4, 1)
+TESTQPLANARTOB(V422Alpha, 2, 1, ARGB, 4, 4, 1)
+TESTQPLANARTOB(V422Alpha, 2, 1, ABGR, 4, 4, 1)
+TESTQPLANARTOB(I444Alpha, 1, 1, ARGB, 4, 4, 1)
+TESTQPLANARTOB(I444Alpha, 1, 1, ABGR, 4, 4, 1)
+TESTQPLANARTOB(J444Alpha, 1, 1, ARGB, 4, 4, 1)
+TESTQPLANARTOB(J444Alpha, 1, 1, ABGR, 4, 4, 1)
+TESTQPLANARTOB(H444Alpha, 1, 1, ARGB, 4, 4, 1)
+TESTQPLANARTOB(H444Alpha, 1, 1, ABGR, 4, 4, 1)
+TESTQPLANARTOB(F444Alpha, 1, 1, ARGB, 4, 4, 1)
+TESTQPLANARTOB(F444Alpha, 1, 1, ABGR, 4, 4, 1)
+TESTQPLANARTOB(U444Alpha, 1, 1, ARGB, 4, 4, 1)
+TESTQPLANARTOB(U444Alpha, 1, 1, ABGR, 4, 4, 1)
+TESTQPLANARTOB(V444Alpha, 1, 1, ARGB, 4, 4, 1)
+TESTQPLANARTOB(V444Alpha, 1, 1, ABGR, 4, 4, 1)
+TESTQPLANARTOB(I420Alpha, 2, 2, ARGBFilter, 4, 4, 1)
+TESTQPLANARTOB(I422Alpha, 2, 1, ARGBFilter, 4, 4, 1)
+#else
+TESTQPLANARTOB(I420Alpha, 2, 2, ARGB, 4, 4, 1)
+TESTQPLANARTOB(I422Alpha, 2, 1, ARGB, 4, 4, 1)
+TESTQPLANARTOB(I444Alpha, 1, 1, ARGB, 4, 4, 1)
+TESTQPLANARTOB(I420Alpha, 2, 2, ARGBFilter, 4, 4, 1)
+TESTQPLANARTOB(I422Alpha, 2, 1, ARGBFilter, 4, 4, 1)
+#endif
+
+#define TESTBIPLANARTOBI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, FMT_C,       \
+                         BPP_B, W1280, N, NEG, OFF)                            \
+  TEST_F(LibYUVConvertTest, FMT_PLANAR##To##FMT_B##N) {                        \
+    const int kWidth = W1280;                                                  \
+    const int kHeight = benchmark_height_;                                     \
+    const int kStrideB = kWidth * BPP_B;                                       \
+    const int kStrideUV = SUBSAMPLE(kWidth, SUBSAMP_X);                        \
+    align_buffer_page_end(src_y, kWidth* kHeight + OFF);                       \
+    align_buffer_page_end(src_uv,                                              \
+                          kStrideUV* SUBSAMPLE(kHeight, SUBSAMP_Y) * 2 + OFF); \
+    align_buffer_page_end(dst_argb_c, kStrideB* kHeight);                      \
+    align_buffer_page_end(dst_argb_opt, kStrideB* kHeight);                    \
+    for (int i = 0; i < kHeight; ++i)                                          \
+      for (int j = 0; j < kWidth; ++j)                                         \
+        src_y[i * kWidth + j + OFF] = (fastrand() & 0xff);                     \
+    for (int i = 0; i < SUBSAMPLE(kHeight, SUBSAMP_Y); ++i) {                  \
+      for (int j = 0; j < kStrideUV * 2; ++j) {                                \
+        src_uv[i * kStrideUV * 2 + j + OFF] = (fastrand() & 0xff);             \
+      }                                                                        \
+    }                                                                          \
+    memset(dst_argb_c, 1, kStrideB* kHeight);                                  \
+    memset(dst_argb_opt, 101, kStrideB* kHeight);                              \
+    MaskCpuFlags(disable_cpu_flags_);                                          \
+    FMT_PLANAR##To##FMT_B(src_y + OFF, kWidth, src_uv + OFF, kStrideUV * 2,    \
+                          dst_argb_c, kWidth * BPP_B, kWidth, NEG kHeight);    \
+    MaskCpuFlags(benchmark_cpu_info_);                                         \
+    for (int i = 0; i < benchmark_iterations_; ++i) {                          \
+      FMT_PLANAR##To##FMT_B(src_y + OFF, kWidth, src_uv + OFF, kStrideUV * 2,  \
+                            dst_argb_opt, kWidth * BPP_B, kWidth,              \
+                            NEG kHeight);                                      \
+    }                                                                          \
+    /* Convert to ARGB so 565 is expanded to bytes that can be compared. */    \
+    align_buffer_page_end(dst_argb32_c, kWidth * 4 * kHeight);                 \
+    align_buffer_page_end(dst_argb32_opt, kWidth * 4 * kHeight);               \
+    memset(dst_argb32_c, 2, kWidth * 4 * kHeight);                             \
+    memset(dst_argb32_opt, 102, kWidth * 4 * kHeight);                         \
+    FMT_C##ToARGB(dst_argb_c, kStrideB, dst_argb32_c, kWidth * 4, kWidth,      \
+                  kHeight);                                                    \
+    FMT_C##ToARGB(dst_argb_opt, kStrideB, dst_argb32_opt, kWidth * 4, kWidth,  \
+                  kHeight);                                                    \
+    for (int i = 0; i < kHeight; ++i) {                                        \
+      for (int j = 0; j < kWidth * 4; ++j) {                                   \
+        EXPECT_EQ(dst_argb32_c[i * kWidth * 4 + j],                            \
+                  dst_argb32_opt[i * kWidth * 4 + j]);                         \
+      }                                                                        \
+    }                                                                          \
+    free_aligned_buffer_page_end(src_y);                                       \
+    free_aligned_buffer_page_end(src_uv);                                      \
+    free_aligned_buffer_page_end(dst_argb_c);                                  \
+    free_aligned_buffer_page_end(dst_argb_opt);                                \
+    free_aligned_buffer_page_end(dst_argb32_c);                                \
+    free_aligned_buffer_page_end(dst_argb32_opt);                              \
+  }
+
+#define TESTBIPLANARTOB(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, FMT_C, BPP_B) \
+  TESTBIPLANARTOBI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, FMT_C, BPP_B,      \
+                   benchmark_width_ + 1, _Any, +, 0)                           \
+  TESTBIPLANARTOBI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, FMT_C, BPP_B,      \
+                   benchmark_width_, _Unaligned, +, 2)                         \
+  TESTBIPLANARTOBI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, FMT_C, BPP_B,      \
+                   benchmark_width_, _Invert, -, 0)                            \
+  TESTBIPLANARTOBI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, FMT_C, BPP_B,      \
+                   benchmark_width_, _Opt, +, 0)
+
+#define JNV12ToARGB(a, b, c, d, e, f, g, h) \
+  NV12ToARGBMatrix(a, b, c, d, e, f, &kYuvJPEGConstants, g, h)
+#define JNV21ToARGB(a, b, c, d, e, f, g, h) \
+  NV21ToARGBMatrix(a, b, c, d, e, f, &kYuvJPEGConstants, g, h)
+#define JNV12ToABGR(a, b, c, d, e, f, g, h) \
+  NV21ToARGBMatrix(a, b, c, d, e, f, &kYvuJPEGConstants, g, h)
+#define JNV21ToABGR(a, b, c, d, e, f, g, h) \
+  NV12ToARGBMatrix(a, b, c, d, e, f, &kYvuJPEGConstants, g, h)
+#define JNV12ToRGB24(a, b, c, d, e, f, g, h) \
+  NV12ToRGB24Matrix(a, b, c, d, e, f, &kYuvJPEGConstants, g, h)
+#define JNV21ToRGB24(a, b, c, d, e, f, g, h) \
+  NV21ToRGB24Matrix(a, b, c, d, e, f, &kYuvJPEGConstants, g, h)
+#define JNV12ToRAW(a, b, c, d, e, f, g, h) \
+  NV21ToRGB24Matrix(a, b, c, d, e, f, &kYvuJPEGConstants, g, h)
+#define JNV21ToRAW(a, b, c, d, e, f, g, h) \
+  NV12ToRGB24Matrix(a, b, c, d, e, f, &kYvuJPEGConstants, g, h)
+#define JNV12ToRGB565(a, b, c, d, e, f, g, h) \
+  NV12ToRGB565Matrix(a, b, c, d, e, f, &kYuvJPEGConstants, g, h)
+
+TESTBIPLANARTOB(JNV12, 2, 2, ARGB, ARGB, 4)
+TESTBIPLANARTOB(JNV21, 2, 2, ARGB, ARGB, 4)
+TESTBIPLANARTOB(JNV12, 2, 2, ABGR, ABGR, 4)
+TESTBIPLANARTOB(JNV21, 2, 2, ABGR, ABGR, 4)
+TESTBIPLANARTOB(JNV12, 2, 2, RGB24, RGB24, 3)
+TESTBIPLANARTOB(JNV21, 2, 2, RGB24, RGB24, 3)
+TESTBIPLANARTOB(JNV12, 2, 2, RAW, RAW, 3)
+TESTBIPLANARTOB(JNV21, 2, 2, RAW, RAW, 3)
+#ifdef LITTLE_ENDIAN_ONLY_TEST
+TESTBIPLANARTOB(JNV12, 2, 2, RGB565, RGB565, 2)
+#endif
+
+TESTBIPLANARTOB(NV12, 2, 2, ARGB, ARGB, 4)
+TESTBIPLANARTOB(NV21, 2, 2, ARGB, ARGB, 4)
+TESTBIPLANARTOB(NV12, 2, 2, ABGR, ABGR, 4)
+TESTBIPLANARTOB(NV21, 2, 2, ABGR, ABGR, 4)
+TESTBIPLANARTOB(NV12, 2, 2, RGB24, RGB24, 3)
+TESTBIPLANARTOB(NV21, 2, 2, RGB24, RGB24, 3)
+TESTBIPLANARTOB(NV12, 2, 2, RAW, RAW, 3)
+TESTBIPLANARTOB(NV21, 2, 2, RAW, RAW, 3)
+TESTBIPLANARTOB(NV21, 2, 2, YUV24, RAW, 3)
+#ifdef LITTLE_ENDIAN_ONLY_TEST
+TESTBIPLANARTOB(NV12, 2, 2, RGB565, RGB565, 2)
+#endif
+
+#define TESTATOPLANARI(FMT_A, BPP_A, YALIGN, FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, \
+                       W1280, N, NEG, OFF)                                     \
+  TEST_F(LibYUVConvertTest, FMT_A##To##FMT_PLANAR##N) {                        \
+    const int kWidth = W1280;                                                  \
+    const int kHeight = ALIGNINT(benchmark_height_, YALIGN);                   \
+    const int kStrideUV = SUBSAMPLE(kWidth, SUBSAMP_X);                        \
+    const int kStride = (kStrideUV * SUBSAMP_X * 8 * BPP_A + 7) / 8;           \
+    align_buffer_page_end(src_argb, kStride* kHeight + OFF);                   \
+    align_buffer_page_end(dst_y_c, kWidth* kHeight);                           \
+    align_buffer_page_end(dst_uv_c,                                            \
+                          kStrideUV * 2 * SUBSAMPLE(kHeight, SUBSAMP_Y));      \
+    align_buffer_page_end(dst_y_opt, kWidth* kHeight);                         \
+    align_buffer_page_end(dst_uv_opt,                                          \
+                          kStrideUV * 2 * SUBSAMPLE(kHeight, SUBSAMP_Y));      \
+    memset(dst_y_c, 1, kWidth* kHeight);                                       \
+    memset(dst_uv_c, 2, kStrideUV * 2 * SUBSAMPLE(kHeight, SUBSAMP_Y));        \
+    memset(dst_y_opt, 101, kWidth* kHeight);                                   \
+    memset(dst_uv_opt, 102, kStrideUV * 2 * SUBSAMPLE(kHeight, SUBSAMP_Y));    \
+    for (int i = 0; i < kHeight; ++i)                                          \
+      for (int j = 0; j < kStride; ++j)                                        \
+        src_argb[(i * kStride) + j + OFF] = (fastrand() & 0xff);               \
+    MaskCpuFlags(disable_cpu_flags_);                                          \
+    FMT_A##To##FMT_PLANAR(src_argb + OFF, kStride, dst_y_c, kWidth, dst_uv_c,  \
+                          kStrideUV * 2, dst_uv_c + kStrideUV, kStrideUV * 2,  \
+                          kWidth, NEG kHeight);                                \
+    MaskCpuFlags(benchmark_cpu_info_);                                         \
+    for (int i = 0; i < benchmark_iterations_; ++i) {                          \
+      FMT_A##To##FMT_PLANAR(src_argb + OFF, kStride, dst_y_opt, kWidth,        \
+                            dst_uv_opt, kStrideUV * 2, dst_uv_opt + kStrideUV, \
+                            kStrideUV * 2, kWidth, NEG kHeight);               \
+    }                                                                          \
+    for (int i = 0; i < kHeight; ++i) {                                        \
+      for (int j = 0; j < kWidth; ++j) {                                       \
+        EXPECT_EQ(dst_y_c[i * kWidth + j], dst_y_opt[i * kWidth + j]);         \
+      }                                                                        \
+    }                                                                          \
+    for (int i = 0; i < SUBSAMPLE(kHeight, SUBSAMP_Y) * 2; ++i) {              \
+      for (int j = 0; j < kStrideUV; ++j) {                                    \
+        EXPECT_EQ(dst_uv_c[i * kStrideUV + j], dst_uv_opt[i * kStrideUV + j]); \
+      }                                                                        \
+    }                                                                          \
+    free_aligned_buffer_page_end(dst_y_c);                                     \
+    free_aligned_buffer_page_end(dst_uv_c);                                    \
+    free_aligned_buffer_page_end(dst_y_opt);                                   \
+    free_aligned_buffer_page_end(dst_uv_opt);                                  \
+    free_aligned_buffer_page_end(src_argb);                                    \
+  }
+
+#if defined(ENABLE_FULL_TESTS)
+#define TESTATOPLANAR(FMT_A, BPP_A, YALIGN, FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y) \
+  TESTATOPLANARI(FMT_A, BPP_A, YALIGN, FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y,      \
+                 benchmark_width_ + 1, _Any, +, 0)                            \
+  TESTATOPLANARI(FMT_A, BPP_A, YALIGN, FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y,      \
+                 benchmark_width_, _Unaligned, +, 2)                          \
+  TESTATOPLANARI(FMT_A, BPP_A, YALIGN, FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y,      \
+                 benchmark_width_, _Invert, -, 0)                             \
+  TESTATOPLANARI(FMT_A, BPP_A, YALIGN, FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y,      \
+                 benchmark_width_, _Opt, +, 0)
+#else
+#define TESTATOPLANAR(FMT_A, BPP_A, YALIGN, FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y) \
+  TESTATOPLANARI(FMT_A, BPP_A, YALIGN, FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y,      \
+                 benchmark_width_ + 1, _Any, +, 0)                            \
+  TESTATOPLANARI(FMT_A, BPP_A, YALIGN, FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y,      \
+                 benchmark_width_, _Opt, +, 0)
+#endif
+
+TESTATOPLANAR(ABGR, 4, 1, I420, 2, 2)
+TESTATOPLANAR(ARGB, 4, 1, I420, 2, 2)
+TESTATOPLANAR(ARGB, 4, 1, I422, 2, 1)
+TESTATOPLANAR(ARGB, 4, 1, I444, 1, 1)
+TESTATOPLANAR(ARGB, 4, 1, J420, 2, 2)
+TESTATOPLANAR(ARGB, 4, 1, J422, 2, 1)
+#ifdef LITTLE_ENDIAN_ONLY_TEST
+TESTATOPLANAR(ARGB4444, 2, 1, I420, 2, 2)
+TESTATOPLANAR(RGB565, 2, 1, I420, 2, 2)
+TESTATOPLANAR(ARGB1555, 2, 1, I420, 2, 2)
+#endif
+TESTATOPLANAR(BGRA, 4, 1, I420, 2, 2)
+TESTATOPLANAR(I400, 1, 1, I420, 2, 2)
+TESTATOPLANAR(J400, 1, 1, J420, 2, 2)
+TESTATOPLANAR(RAW, 3, 1, I420, 2, 2)
+TESTATOPLANAR(RAW, 3, 1, J420, 2, 2)
+TESTATOPLANAR(RGB24, 3, 1, I420, 2, 2)
+TESTATOPLANAR(RGB24, 3, 1, J420, 2, 2)
+TESTATOPLANAR(RGBA, 4, 1, I420, 2, 2)
+TESTATOPLANAR(UYVY, 2, 1, I420, 2, 2)
+TESTATOPLANAR(UYVY, 2, 1, I422, 2, 1)
+TESTATOPLANAR(YUY2, 2, 1, I420, 2, 2)
+TESTATOPLANAR(YUY2, 2, 1, I422, 2, 1)
+
+#define TESTATOBIPLANARI(FMT_A, SUB_A, BPP_A, FMT_PLANAR, SUBSAMP_X,          \
+                         SUBSAMP_Y, W1280, N, NEG, OFF)                       \
+  TEST_F(LibYUVConvertTest, FMT_A##To##FMT_PLANAR##N) {                       \
+    const int kWidth = W1280;                                                 \
+    const int kHeight = benchmark_height_;                                    \
+    const int kStride = SUBSAMPLE(kWidth, SUB_A) * BPP_A;                     \
+    const int kStrideUV = SUBSAMPLE(kWidth, SUBSAMP_X);                       \
+    align_buffer_page_end(src_argb, kStride* kHeight + OFF);                  \
+    align_buffer_page_end(dst_y_c, kWidth* kHeight);                          \
+    align_buffer_page_end(dst_uv_c,                                           \
+                          kStrideUV * 2 * SUBSAMPLE(kHeight, SUBSAMP_Y));     \
+    align_buffer_page_end(dst_y_opt, kWidth* kHeight);                        \
+    align_buffer_page_end(dst_uv_opt,                                         \
+                          kStrideUV * 2 * SUBSAMPLE(kHeight, SUBSAMP_Y));     \
+    for (int i = 0; i < kHeight; ++i)                                         \
+      for (int j = 0; j < kStride; ++j)                                       \
+        src_argb[(i * kStride) + j + OFF] = (fastrand() & 0xff);              \
+    memset(dst_y_c, 1, kWidth* kHeight);                                      \
+    memset(dst_uv_c, 2, kStrideUV * 2 * SUBSAMPLE(kHeight, SUBSAMP_Y));       \
+    memset(dst_y_opt, 101, kWidth* kHeight);                                  \
+    memset(dst_uv_opt, 102, kStrideUV * 2 * SUBSAMPLE(kHeight, SUBSAMP_Y));   \
+    MaskCpuFlags(disable_cpu_flags_);                                         \
+    FMT_A##To##FMT_PLANAR(src_argb + OFF, kStride, dst_y_c, kWidth, dst_uv_c, \
+                          kStrideUV * 2, kWidth, NEG kHeight);                \
+    MaskCpuFlags(benchmark_cpu_info_);                                        \
+    for (int i = 0; i < benchmark_iterations_; ++i) {                         \
+      FMT_A##To##FMT_PLANAR(src_argb + OFF, kStride, dst_y_opt, kWidth,       \
+                            dst_uv_opt, kStrideUV * 2, kWidth, NEG kHeight);  \
+    }                                                                         \
+    for (int i = 0; i < kHeight; ++i) {                                       \
+      for (int j = 0; j < kWidth; ++j) {                                      \
+        EXPECT_EQ(dst_y_c[i * kWidth + j], dst_y_opt[i * kWidth + j]);        \
+      }                                                                       \
+    }                                                                         \
+    for (int i = 0; i < SUBSAMPLE(kHeight, SUBSAMP_Y); ++i) {                 \
+      for (int j = 0; j < kStrideUV * 2; ++j) {                               \
+        EXPECT_EQ(dst_uv_c[i * kStrideUV * 2 + j],                            \
+                  dst_uv_opt[i * kStrideUV * 2 + j]);                         \
+      }                                                                       \
+    }                                                                         \
+    free_aligned_buffer_page_end(dst_y_c);                                    \
+    free_aligned_buffer_page_end(dst_uv_c);                                   \
+    free_aligned_buffer_page_end(dst_y_opt);                                  \
+    free_aligned_buffer_page_end(dst_uv_opt);                                 \
+    free_aligned_buffer_page_end(src_argb);                                   \
+  }
+
+#define TESTATOBIPLANAR(FMT_A, SUB_A, BPP_A, FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y) \
+  TESTATOBIPLANARI(FMT_A, SUB_A, BPP_A, FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y,      \
+                   benchmark_width_ + 1, _Any, +, 0)                           \
+  TESTATOBIPLANARI(FMT_A, SUB_A, BPP_A, FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y,      \
+                   benchmark_width_, _Unaligned, +, 2)                         \
+  TESTATOBIPLANARI(FMT_A, SUB_A, BPP_A, FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y,      \
+                   benchmark_width_, _Invert, -, 0)                            \
+  TESTATOBIPLANARI(FMT_A, SUB_A, BPP_A, FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y,      \
+                   benchmark_width_, _Opt, +, 0)
+
+TESTATOBIPLANAR(ARGB, 1, 4, NV12, 2, 2)
+TESTATOBIPLANAR(ARGB, 1, 4, NV21, 2, 2)
+TESTATOBIPLANAR(ABGR, 1, 4, NV12, 2, 2)
+TESTATOBIPLANAR(ABGR, 1, 4, NV21, 2, 2)
+TESTATOBIPLANAR(RAW, 1, 3, JNV21, 2, 2)
+TESTATOBIPLANAR(YUY2, 2, 4, NV12, 2, 2)
+TESTATOBIPLANAR(UYVY, 2, 4, NV12, 2, 2)
+TESTATOBIPLANAR(AYUV, 1, 4, NV12, 2, 2)
+TESTATOBIPLANAR(AYUV, 1, 4, NV21, 2, 2)
+
+#define TESTATOBI(FMT_A, TYPE_A, EPP_A, STRIDE_A, HEIGHT_A, FMT_B, TYPE_B,     \
+                  EPP_B, STRIDE_B, HEIGHT_B, W1280, N, NEG, OFF)               \
+  TEST_F(LibYUVConvertTest, FMT_A##To##FMT_B##N) {                             \
+    const int kWidth = W1280;                                                  \
+    const int kHeight = benchmark_height_;                                     \
+    const int kHeightA = (kHeight + HEIGHT_A - 1) / HEIGHT_A * HEIGHT_A;       \
+    const int kHeightB = (kHeight + HEIGHT_B - 1) / HEIGHT_B * HEIGHT_B;       \
+    const int kStrideA =                                                       \
+        (kWidth * EPP_A + STRIDE_A - 1) / STRIDE_A * STRIDE_A;                 \
+    const int kStrideB =                                                       \
+        (kWidth * EPP_B + STRIDE_B - 1) / STRIDE_B * STRIDE_B;                 \
+    align_buffer_page_end(src_argb,                                            \
+                          kStrideA* kHeightA*(int)sizeof(TYPE_A) + OFF);       \
+    align_buffer_page_end(dst_argb_c, kStrideB* kHeightB*(int)sizeof(TYPE_B)); \
+    align_buffer_page_end(dst_argb_opt,                                        \
+                          kStrideB* kHeightB*(int)sizeof(TYPE_B));             \
+    for (int i = 0; i < kStrideA * kHeightA * (int)sizeof(TYPE_A); ++i) {      \
+      src_argb[i + OFF] = (fastrand() & 0xff);                                 \
+    }                                                                          \
+    memset(dst_argb_c, 1, kStrideB* kHeightB);                                 \
+    memset(dst_argb_opt, 101, kStrideB* kHeightB);                             \
+    MaskCpuFlags(disable_cpu_flags_);                                          \
+    FMT_A##To##FMT_B((TYPE_A*)(src_argb + OFF), kStrideA, (TYPE_B*)dst_argb_c, \
+                     kStrideB, kWidth, NEG kHeight);                           \
+    MaskCpuFlags(benchmark_cpu_info_);                                         \
+    for (int i = 0; i < benchmark_iterations_; ++i) {                          \
+      FMT_A##To##FMT_B((TYPE_A*)(src_argb + OFF), kStrideA,                    \
+                       (TYPE_B*)dst_argb_opt, kStrideB, kWidth, NEG kHeight);  \
+    }                                                                          \
+    for (int i = 0; i < kStrideB * kHeightB * (int)sizeof(TYPE_B); ++i) {      \
+      EXPECT_EQ(dst_argb_c[i], dst_argb_opt[i]);                               \
+    }                                                                          \
+    free_aligned_buffer_page_end(src_argb);                                    \
+    free_aligned_buffer_page_end(dst_argb_c);                                  \
+    free_aligned_buffer_page_end(dst_argb_opt);                                \
+  }
+
+#define TESTATOBRANDOM(FMT_A, TYPE_A, EPP_A, STRIDE_A, HEIGHT_A, FMT_B,        \
+                       TYPE_B, EPP_B, STRIDE_B, HEIGHT_B)                      \
+  TEST_F(LibYUVConvertTest, FMT_A##To##FMT_B##_Random) {                       \
+    for (int times = 0; times < benchmark_iterations_; ++times) {              \
+      const int kWidth = (fastrand() & 63) + 1;                                \
+      const int kHeight = (fastrand() & 31) + 1;                               \
+      const int kHeightA = (kHeight + HEIGHT_A - 1) / HEIGHT_A * HEIGHT_A;     \
+      const int kHeightB = (kHeight + HEIGHT_B - 1) / HEIGHT_B * HEIGHT_B;     \
+      const int kStrideA =                                                     \
+          (kWidth * EPP_A + STRIDE_A - 1) / STRIDE_A * STRIDE_A;               \
+      const int kStrideB =                                                     \
+          (kWidth * EPP_B + STRIDE_B - 1) / STRIDE_B * STRIDE_B;               \
+      align_buffer_page_end(src_argb, kStrideA* kHeightA*(int)sizeof(TYPE_A)); \
+      align_buffer_page_end(dst_argb_c,                                        \
+                            kStrideB* kHeightB*(int)sizeof(TYPE_B));           \
+      align_buffer_page_end(dst_argb_opt,                                      \
+                            kStrideB* kHeightB*(int)sizeof(TYPE_B));           \
+      for (int i = 0; i < kStrideA * kHeightA * (int)sizeof(TYPE_A); ++i) {    \
+        src_argb[i] = 0xfe;                                                    \
+      }                                                                        \
+      memset(dst_argb_c, 123, kStrideB* kHeightB);                             \
+      memset(dst_argb_opt, 123, kStrideB* kHeightB);                           \
+      MaskCpuFlags(disable_cpu_flags_);                                        \
+      FMT_A##To##FMT_B((TYPE_A*)src_argb, kStrideA, (TYPE_B*)dst_argb_c,       \
+                       kStrideB, kWidth, kHeight);                             \
+      MaskCpuFlags(benchmark_cpu_info_);                                       \
+      FMT_A##To##FMT_B((TYPE_A*)src_argb, kStrideA, (TYPE_B*)dst_argb_opt,     \
+                       kStrideB, kWidth, kHeight);                             \
+      for (int i = 0; i < kStrideB * kHeightB * (int)sizeof(TYPE_B); ++i) {    \
+        EXPECT_EQ(dst_argb_c[i], dst_argb_opt[i]);                             \
+      }                                                                        \
+      free_aligned_buffer_page_end(src_argb);                                  \
+      free_aligned_buffer_page_end(dst_argb_c);                                \
+      free_aligned_buffer_page_end(dst_argb_opt);                              \
+    }                                                                          \
+  }
+
+#if defined(ENABLE_FULL_TESTS)
+#define TESTATOB(FMT_A, TYPE_A, EPP_A, STRIDE_A, HEIGHT_A, FMT_B, TYPE_B,   \
+                 EPP_B, STRIDE_B, HEIGHT_B)                                 \
+  TESTATOBI(FMT_A, TYPE_A, EPP_A, STRIDE_A, HEIGHT_A, FMT_B, TYPE_B, EPP_B, \
+            STRIDE_B, HEIGHT_B, benchmark_width_ + 1, _Any, +, 0)           \
+  TESTATOBI(FMT_A, TYPE_A, EPP_A, STRIDE_A, HEIGHT_A, FMT_B, TYPE_B, EPP_B, \
+            STRIDE_B, HEIGHT_B, benchmark_width_, _Unaligned, +, 4)         \
+  TESTATOBI(FMT_A, TYPE_A, EPP_A, STRIDE_A, HEIGHT_A, FMT_B, TYPE_B, EPP_B, \
+            STRIDE_B, HEIGHT_B, benchmark_width_, _Invert, -, 0)            \
+  TESTATOBI(FMT_A, TYPE_A, EPP_A, STRIDE_A, HEIGHT_A, FMT_B, TYPE_B, EPP_B, \
+            STRIDE_B, HEIGHT_B, benchmark_width_, _Opt, +, 0)               \
+  TESTATOBRANDOM(FMT_A, TYPE_A, EPP_A, STRIDE_A, HEIGHT_A, FMT_B, TYPE_B,   \
+                 EPP_B, STRIDE_B, HEIGHT_B)
+#else
+#define TESTATOB(FMT_A, TYPE_A, EPP_A, STRIDE_A, HEIGHT_A, FMT_B, TYPE_B,   \
+                 EPP_B, STRIDE_B, HEIGHT_B)                                 \
+  TESTATOBI(FMT_A, TYPE_A, EPP_A, STRIDE_A, HEIGHT_A, FMT_B, TYPE_B, EPP_B, \
+            STRIDE_B, HEIGHT_B, benchmark_width_, _Opt, +, 0)
+#endif
+
+TESTATOB(AB30, uint8_t, 4, 4, 1, ABGR, uint8_t, 4, 4, 1)
+TESTATOB(AB30, uint8_t, 4, 4, 1, ARGB, uint8_t, 4, 4, 1)
+#ifdef LITTLE_ENDIAN_ONLY_TEST
+TESTATOB(ABGR, uint8_t, 4, 4, 1, AR30, uint8_t, 4, 4, 1)
+#endif
+TESTATOB(ABGR, uint8_t, 4, 4, 1, ARGB, uint8_t, 4, 4, 1)
+#ifdef LITTLE_ENDIAN_ONLY_TEST
+TESTATOB(AR30, uint8_t, 4, 4, 1, AB30, uint8_t, 4, 4, 1)
+#endif
+TESTATOB(AR30, uint8_t, 4, 4, 1, ABGR, uint8_t, 4, 4, 1)
+#ifdef LITTLE_ENDIAN_ONLY_TEST
+TESTATOB(AR30, uint8_t, 4, 4, 1, AR30, uint8_t, 4, 4, 1)
+TESTATOB(AR30, uint8_t, 4, 4, 1, ARGB, uint8_t, 4, 4, 1)
+#endif
+TESTATOB(ARGB, uint8_t, 4, 4, 1, ABGR, uint8_t, 4, 4, 1)
+#ifdef LITTLE_ENDIAN_ONLY_TEST
+TESTATOB(ARGB, uint8_t, 4, 4, 1, AR30, uint8_t, 4, 4, 1)
+#endif
+TESTATOB(ARGB, uint8_t, 4, 4, 1, ARGB, uint8_t, 4, 4, 1)
+TESTATOB(ARGB, uint8_t, 4, 4, 1, ARGB1555, uint8_t, 2, 2, 1)
+TESTATOB(ARGB, uint8_t, 4, 4, 1, ARGB4444, uint8_t, 2, 2, 1)
+TESTATOB(ARGB, uint8_t, 4, 4, 1, ARGBMirror, uint8_t, 4, 4, 1)
+TESTATOB(ARGB, uint8_t, 4, 4, 1, BGRA, uint8_t, 4, 4, 1)
+TESTATOB(ARGB, uint8_t, 4, 4, 1, I400, uint8_t, 1, 1, 1)
+TESTATOB(ARGB, uint8_t, 4, 4, 1, J400, uint8_t, 1, 1, 1)
+TESTATOB(RGBA, uint8_t, 4, 4, 1, J400, uint8_t, 1, 1, 1)
+TESTATOB(ARGB, uint8_t, 4, 4, 1, RAW, uint8_t, 3, 3, 1)
+TESTATOB(ARGB, uint8_t, 4, 4, 1, RGB24, uint8_t, 3, 3, 1)
+TESTATOB(ABGR, uint8_t, 4, 4, 1, RAW, uint8_t, 3, 3, 1)
+TESTATOB(ABGR, uint8_t, 4, 4, 1, RGB24, uint8_t, 3, 3, 1)
+#ifdef LITTLE_ENDIAN_ONLY_TEST
+TESTATOB(ARGB, uint8_t, 4, 4, 1, RGB565, uint8_t, 2, 2, 1)
+#endif
+TESTATOB(ARGB, uint8_t, 4, 4, 1, RGBA, uint8_t, 4, 4, 1)
+TESTATOB(ARGB, uint8_t, 4, 4, 1, UYVY, uint8_t, 2, 4, 1)
+TESTATOB(ARGB, uint8_t, 4, 4, 1, YUY2, uint8_t, 2, 4, 1)  // 4
+TESTATOB(ARGB1555, uint8_t, 2, 2, 1, ARGB, uint8_t, 4, 4, 1)
+TESTATOB(ARGB4444, uint8_t, 2, 2, 1, ARGB, uint8_t, 4, 4, 1)
+TESTATOB(BGRA, uint8_t, 4, 4, 1, ARGB, uint8_t, 4, 4, 1)
+TESTATOB(I400, uint8_t, 1, 1, 1, ARGB, uint8_t, 4, 4, 1)
+TESTATOB(I400, uint8_t, 1, 1, 1, I400, uint8_t, 1, 1, 1)
+TESTATOB(I400, uint8_t, 1, 1, 1, I400Mirror, uint8_t, 1, 1, 1)
+TESTATOB(J400, uint8_t, 1, 1, 1, ARGB, uint8_t, 4, 4, 1)
+TESTATOB(J400, uint8_t, 1, 1, 1, J400, uint8_t, 1, 1, 1)
+TESTATOB(RAW, uint8_t, 3, 3, 1, ARGB, uint8_t, 4, 4, 1)
+TESTATOB(RAW, uint8_t, 3, 3, 1, RGBA, uint8_t, 4, 4, 1)
+TESTATOB(RAW, uint8_t, 3, 3, 1, RGB24, uint8_t, 3, 3, 1)
+TESTATOB(RGB24, uint8_t, 3, 3, 1, ARGB, uint8_t, 4, 4, 1)
+TESTATOB(RGB24, uint8_t, 3, 3, 1, J400, uint8_t, 1, 1, 1)
+TESTATOB(RGB24, uint8_t, 3, 3, 1, RGB24Mirror, uint8_t, 3, 3, 1)
+TESTATOB(RAW, uint8_t, 3, 3, 1, J400, uint8_t, 1, 1, 1)
+#ifdef LITTLE_ENDIAN_ONLY_TEST
+TESTATOB(RGB565, uint8_t, 2, 2, 1, ARGB, uint8_t, 4, 4, 1)
+#endif
+TESTATOB(RGBA, uint8_t, 4, 4, 1, ARGB, uint8_t, 4, 4, 1)
+TESTATOB(UYVY, uint8_t, 2, 4, 1, ARGB, uint8_t, 4, 4, 1)
+TESTATOB(YUY2, uint8_t, 2, 4, 1, ARGB, uint8_t, 4, 4, 1)
+TESTATOB(YUY2, uint8_t, 2, 4, 1, Y, uint8_t, 1, 1, 1)
+TESTATOB(ARGB, uint8_t, 4, 4, 1, AR64, uint16_t, 4, 4, 1)
+TESTATOB(ARGB, uint8_t, 4, 4, 1, AB64, uint16_t, 4, 4, 1)
+TESTATOB(ABGR, uint8_t, 4, 4, 1, AR64, uint16_t, 4, 4, 1)
+TESTATOB(ABGR, uint8_t, 4, 4, 1, AB64, uint16_t, 4, 4, 1)
+TESTATOB(AR64, uint16_t, 4, 4, 1, ARGB, uint8_t, 4, 4, 1)
+TESTATOB(AB64, uint16_t, 4, 4, 1, ARGB, uint8_t, 4, 4, 1)
+TESTATOB(AR64, uint16_t, 4, 4, 1, ABGR, uint8_t, 4, 4, 1)
+TESTATOB(AB64, uint16_t, 4, 4, 1, ABGR, uint8_t, 4, 4, 1)
+TESTATOB(AR64, uint16_t, 4, 4, 1, AB64, uint16_t, 4, 4, 1)
+TESTATOB(AB64, uint16_t, 4, 4, 1, AR64, uint16_t, 4, 4, 1)
+
+#define TESTATOBDI(FMT_A, BPP_A, STRIDE_A, HEIGHT_A, FMT_B, BPP_B, STRIDE_B, \
+                   HEIGHT_B, W1280, N, NEG, OFF)                             \
+  TEST_F(LibYUVConvertTest, FMT_A##To##FMT_B##Dither##N) {                   \
+    const int kWidth = W1280;                                                \
+    const int kHeight = benchmark_height_;                                   \
+    const int kHeightA = (kHeight + HEIGHT_A - 1) / HEIGHT_A * HEIGHT_A;     \
+    const int kHeightB = (kHeight + HEIGHT_B - 1) / HEIGHT_B * HEIGHT_B;     \
+    const int kStrideA =                                                     \
+        (kWidth * BPP_A + STRIDE_A - 1) / STRIDE_A * STRIDE_A;               \
+    const int kStrideB =                                                     \
+        (kWidth * BPP_B + STRIDE_B - 1) / STRIDE_B * STRIDE_B;               \
+    align_buffer_page_end(src_argb, kStrideA* kHeightA + OFF);               \
+    align_buffer_page_end(dst_argb_c, kStrideB* kHeightB);                   \
+    align_buffer_page_end(dst_argb_opt, kStrideB* kHeightB);                 \
+    for (int i = 0; i < kStrideA * kHeightA; ++i) {                          \
+      src_argb[i + OFF] = (fastrand() & 0xff);                               \
+    }                                                                        \
+    memset(dst_argb_c, 1, kStrideB* kHeightB);                               \
+    memset(dst_argb_opt, 101, kStrideB* kHeightB);                           \
+    MaskCpuFlags(disable_cpu_flags_);                                        \
+    FMT_A##To##FMT_B##Dither(src_argb + OFF, kStrideA, dst_argb_c, kStrideB, \
+                             NULL, kWidth, NEG kHeight);                     \
+    MaskCpuFlags(benchmark_cpu_info_);                                       \
+    for (int i = 0; i < benchmark_iterations_; ++i) {                        \
+      FMT_A##To##FMT_B##Dither(src_argb + OFF, kStrideA, dst_argb_opt,       \
+                               kStrideB, NULL, kWidth, NEG kHeight);         \
+    }                                                                        \
+    for (int i = 0; i < kStrideB * kHeightB; ++i) {                          \
+      EXPECT_EQ(dst_argb_c[i], dst_argb_opt[i]);                             \
+    }                                                                        \
+    free_aligned_buffer_page_end(src_argb);                                  \
+    free_aligned_buffer_page_end(dst_argb_c);                                \
+    free_aligned_buffer_page_end(dst_argb_opt);                              \
+  }
+
+#define TESTATOBDRANDOM(FMT_A, BPP_A, STRIDE_A, HEIGHT_A, FMT_B, BPP_B,        \
+                        STRIDE_B, HEIGHT_B)                                    \
+  TEST_F(LibYUVConvertTest, FMT_A##To##FMT_B##Dither_Random) {                 \
+    for (int times = 0; times < benchmark_iterations_; ++times) {              \
+      const int kWidth = (fastrand() & 63) + 1;                                \
+      const int kHeight = (fastrand() & 31) + 1;                               \
+      const int kHeightA = (kHeight + HEIGHT_A - 1) / HEIGHT_A * HEIGHT_A;     \
+      const int kHeightB = (kHeight + HEIGHT_B - 1) / HEIGHT_B * HEIGHT_B;     \
+      const int kStrideA =                                                     \
+          (kWidth * BPP_A + STRIDE_A - 1) / STRIDE_A * STRIDE_A;               \
+      const int kStrideB =                                                     \
+          (kWidth * BPP_B + STRIDE_B - 1) / STRIDE_B * STRIDE_B;               \
+      align_buffer_page_end(src_argb, kStrideA* kHeightA);                     \
+      align_buffer_page_end(dst_argb_c, kStrideB* kHeightB);                   \
+      align_buffer_page_end(dst_argb_opt, kStrideB* kHeightB);                 \
+      for (int i = 0; i < kStrideA * kHeightA; ++i) {                          \
+        src_argb[i] = (fastrand() & 0xff);                                     \
+      }                                                                        \
+      memset(dst_argb_c, 123, kStrideB* kHeightB);                             \
+      memset(dst_argb_opt, 123, kStrideB* kHeightB);                           \
+      MaskCpuFlags(disable_cpu_flags_);                                        \
+      FMT_A##To##FMT_B##Dither(src_argb, kStrideA, dst_argb_c, kStrideB, NULL, \
+                               kWidth, kHeight);                               \
+      MaskCpuFlags(benchmark_cpu_info_);                                       \
+      FMT_A##To##FMT_B##Dither(src_argb, kStrideA, dst_argb_opt, kStrideB,     \
+                               NULL, kWidth, kHeight);                         \
+      for (int i = 0; i < kStrideB * kHeightB; ++i) {                          \
+        EXPECT_EQ(dst_argb_c[i], dst_argb_opt[i]);                             \
+      }                                                                        \
+      free_aligned_buffer_page_end(src_argb);                                  \
+      free_aligned_buffer_page_end(dst_argb_c);                                \
+      free_aligned_buffer_page_end(dst_argb_opt);                              \
+    }                                                                          \
+  }
+
+#define TESTATOBD(FMT_A, BPP_A, STRIDE_A, HEIGHT_A, FMT_B, BPP_B, STRIDE_B, \
+                  HEIGHT_B)                                                 \
+  TESTATOBDI(FMT_A, BPP_A, STRIDE_A, HEIGHT_A, FMT_B, BPP_B, STRIDE_B,      \
+             HEIGHT_B, benchmark_width_ + 1, _Any, +, 0)                    \
+  TESTATOBDI(FMT_A, BPP_A, STRIDE_A, HEIGHT_A, FMT_B, BPP_B, STRIDE_B,      \
+             HEIGHT_B, benchmark_width_, _Unaligned, +, 2)                  \
+  TESTATOBDI(FMT_A, BPP_A, STRIDE_A, HEIGHT_A, FMT_B, BPP_B, STRIDE_B,      \
+             HEIGHT_B, benchmark_width_, _Invert, -, 0)                     \
+  TESTATOBDI(FMT_A, BPP_A, STRIDE_A, HEIGHT_A, FMT_B, BPP_B, STRIDE_B,      \
+             HEIGHT_B, benchmark_width_, _Opt, +, 0)                        \
+  TESTATOBDRANDOM(FMT_A, BPP_A, STRIDE_A, HEIGHT_A, FMT_B, BPP_B, STRIDE_B, \
+                  HEIGHT_B)
+
+#ifdef LITTLE_ENDIAN_ONLY_TEST
+TESTATOBD(ARGB, 4, 4, 1, RGB565, 2, 2, 1)
+#endif
+
+// These conversions called twice, produce the original result.
+// e.g. endian swap twice.
+#define TESTENDI(FMT_ATOB, TYPE_A, EPP_A, STRIDE_A, HEIGHT_A, W1280, N, NEG,   \
+                 OFF)                                                          \
+  TEST_F(LibYUVConvertTest, FMT_ATOB##_Endswap##N) {                           \
+    const int kWidth = W1280;                                                  \
+    const int kHeight = benchmark_height_;                                     \
+    const int kHeightA = (kHeight + HEIGHT_A - 1) / HEIGHT_A * HEIGHT_A;       \
+    const int kStrideA =                                                       \
+        (kWidth * EPP_A + STRIDE_A - 1) / STRIDE_A * STRIDE_A;                 \
+    align_buffer_page_end(src_argb,                                            \
+                          kStrideA* kHeightA*(int)sizeof(TYPE_A) + OFF);       \
+    align_buffer_page_end(dst_argb_c, kStrideA* kHeightA*(int)sizeof(TYPE_A)); \
+    align_buffer_page_end(dst_argb_opt,                                        \
+                          kStrideA* kHeightA*(int)sizeof(TYPE_A));             \
+    for (int i = 0; i < kStrideA * kHeightA * (int)sizeof(TYPE_A); ++i) {      \
+      src_argb[i + OFF] = (fastrand() & 0xff);                                 \
+    }                                                                          \
+    memset(dst_argb_c, 1, kStrideA* kHeightA);                                 \
+    memset(dst_argb_opt, 101, kStrideA* kHeightA);                             \
+    MaskCpuFlags(disable_cpu_flags_);                                          \
+    FMT_ATOB((TYPE_A*)(src_argb + OFF), kStrideA, (TYPE_A*)dst_argb_c,         \
+             kStrideA, kWidth, NEG kHeight);                                   \
+    MaskCpuFlags(benchmark_cpu_info_);                                         \
+    for (int i = 0; i < benchmark_iterations_; ++i) {                          \
+      FMT_ATOB((TYPE_A*)(src_argb + OFF), kStrideA, (TYPE_A*)dst_argb_opt,     \
+               kStrideA, kWidth, NEG kHeight);                                 \
+    }                                                                          \
+    MaskCpuFlags(disable_cpu_flags_);                                          \
+    FMT_ATOB((TYPE_A*)dst_argb_c, kStrideA, (TYPE_A*)dst_argb_c, kStrideA,     \
+             kWidth, NEG kHeight);                                             \
+    MaskCpuFlags(benchmark_cpu_info_);                                         \
+    FMT_ATOB((TYPE_A*)dst_argb_opt, kStrideA, (TYPE_A*)dst_argb_opt, kStrideA, \
+             kWidth, NEG kHeight);                                             \
+    for (int i = 0; i < kStrideA * kHeightA * (int)sizeof(TYPE_A); ++i) {      \
+      EXPECT_EQ(src_argb[i + OFF], dst_argb_opt[i]);                           \
+      EXPECT_EQ(dst_argb_c[i], dst_argb_opt[i]);                               \
+    }                                                                          \
+    free_aligned_buffer_page_end(src_argb);                                    \
+    free_aligned_buffer_page_end(dst_argb_c);                                  \
+    free_aligned_buffer_page_end(dst_argb_opt);                                \
+  }
+
+#if defined(ENABLE_FULL_TESTS)
+#define TESTEND(FMT_ATOB, TYPE_A, EPP_A, STRIDE_A, HEIGHT_A)                  \
+  TESTENDI(FMT_ATOB, TYPE_A, EPP_A, STRIDE_A, HEIGHT_A, benchmark_width_ + 1, \
+           _Any, +, 0)                                                        \
+  TESTENDI(FMT_ATOB, TYPE_A, EPP_A, STRIDE_A, HEIGHT_A, benchmark_width_,     \
+           _Unaligned, +, 2)                                                  \
+  TESTENDI(FMT_ATOB, TYPE_A, EPP_A, STRIDE_A, HEIGHT_A, benchmark_width_,     \
+           _Opt, +, 0)
+#else
+#define TESTEND(FMT_ATOB, TYPE_A, EPP_A, STRIDE_A, HEIGHT_A)              \
+  TESTENDI(FMT_ATOB, TYPE_A, EPP_A, STRIDE_A, HEIGHT_A, benchmark_width_, \
+           _Opt, +, 0)
+#endif
+
+TESTEND(ARGBToBGRA, uint8_t, 4, 4, 1)
+TESTEND(ARGBToABGR, uint8_t, 4, 4, 1)
+TESTEND(BGRAToARGB, uint8_t, 4, 4, 1)
+TESTEND(ABGRToARGB, uint8_t, 4, 4, 1)
+TESTEND(AB64ToAR64, uint16_t, 4, 4, 1)
+
+#ifdef HAVE_JPEG
+TEST_F(LibYUVConvertTest, ValidateJpeg) {
+  const int kOff = 10;
+  const int kMinJpeg = 64;
+  const int kImageSize = benchmark_width_ * benchmark_height_ >= kMinJpeg
+                             ? benchmark_width_ * benchmark_height_
+                             : kMinJpeg;
+  const int kSize = kImageSize + kOff;
+  align_buffer_page_end(orig_pixels, kSize);
+
+  // No SOI or EOI. Expect fail.
+  memset(orig_pixels, 0, kSize);
+  EXPECT_FALSE(ValidateJpeg(orig_pixels, kSize));
+
+  // Test special value that matches marker start.
+  memset(orig_pixels, 0xff, kSize);
+  EXPECT_FALSE(ValidateJpeg(orig_pixels, kSize));
+
+  // EOI, SOI. Expect pass.
+  orig_pixels[0] = 0xff;
+  orig_pixels[1] = 0xd8;  // SOI.
+  orig_pixels[2] = 0xff;
+  orig_pixels[kSize - kOff + 0] = 0xff;
+  orig_pixels[kSize - kOff + 1] = 0xd9;  // EOI.
+  for (int times = 0; times < benchmark_iterations_; ++times) {
+    EXPECT_TRUE(ValidateJpeg(orig_pixels, kSize));
+  }
+  free_aligned_buffer_page_end(orig_pixels);
+}
+
+TEST_F(LibYUVConvertTest, ValidateJpegLarge) {
+  const int kOff = 10;
+  const int kMinJpeg = 64;
+  const int kImageSize = benchmark_width_ * benchmark_height_ >= kMinJpeg
+                             ? benchmark_width_ * benchmark_height_
+                             : kMinJpeg;
+  const int kSize = kImageSize + kOff;
+  const int kMultiple = 10;
+  const int kBufSize = kImageSize * kMultiple + kOff;
+  align_buffer_page_end(orig_pixels, kBufSize);
+
+  // No SOI or EOI. Expect fail.
+  memset(orig_pixels, 0, kBufSize);
+  EXPECT_FALSE(ValidateJpeg(orig_pixels, kBufSize));
+
+  // EOI, SOI. Expect pass.
+  orig_pixels[0] = 0xff;
+  orig_pixels[1] = 0xd8;  // SOI.
+  orig_pixels[2] = 0xff;
+  orig_pixels[kSize - kOff + 0] = 0xff;
+  orig_pixels[kSize - kOff + 1] = 0xd9;  // EOI.
+  for (int times = 0; times < benchmark_iterations_; ++times) {
+    EXPECT_TRUE(ValidateJpeg(orig_pixels, kBufSize));
+  }
+  free_aligned_buffer_page_end(orig_pixels);
+}
+
+TEST_F(LibYUVConvertTest, InvalidateJpeg) {
+  const int kOff = 10;
+  const int kMinJpeg = 64;
+  const int kImageSize = benchmark_width_ * benchmark_height_ >= kMinJpeg
+                             ? benchmark_width_ * benchmark_height_
+                             : kMinJpeg;
+  const int kSize = kImageSize + kOff;
+  align_buffer_page_end(orig_pixels, kSize);
+
+  // NULL pointer. Expect fail.
+  EXPECT_FALSE(ValidateJpeg(NULL, kSize));
+
+  // Negative size. Expect fail.
+  EXPECT_FALSE(ValidateJpeg(orig_pixels, -1));
+
+  // Too large size. Expect fail.
+  EXPECT_FALSE(ValidateJpeg(orig_pixels, 0xfb000000ull));
+
+  // No SOI or EOI. Expect fail.
+  memset(orig_pixels, 0, kSize);
+  EXPECT_FALSE(ValidateJpeg(orig_pixels, kSize));
+
+  // SOI but no EOI. Expect fail.
+  orig_pixels[0] = 0xff;
+  orig_pixels[1] = 0xd8;  // SOI.
+  orig_pixels[2] = 0xff;
+  for (int times = 0; times < benchmark_iterations_; ++times) {
+    EXPECT_FALSE(ValidateJpeg(orig_pixels, kSize));
+  }
+
+  // EOI but no SOI. Expect fail.
+  orig_pixels[0] = 0;
+  orig_pixels[1] = 0;
+  orig_pixels[kSize - kOff + 0] = 0xff;
+  orig_pixels[kSize - kOff + 1] = 0xd9;  // EOI.
+  EXPECT_FALSE(ValidateJpeg(orig_pixels, kSize));
+
+  free_aligned_buffer_page_end(orig_pixels);
+}
+
+TEST_F(LibYUVConvertTest, FuzzJpeg) {
+  // SOI but no EOI. Expect fail.
+  for (int times = 0; times < benchmark_iterations_; ++times) {
+    const int kSize = fastrand() % 5000 + 3;
+    align_buffer_page_end(orig_pixels, kSize);
+    MemRandomize(orig_pixels, kSize);
+
+    // Add SOI so frame will be scanned.
+    orig_pixels[0] = 0xff;
+    orig_pixels[1] = 0xd8;  // SOI.
+    orig_pixels[2] = 0xff;
+    orig_pixels[kSize - 1] = 0xff;
+    ValidateJpeg(orig_pixels,
+                 kSize);  // Failure normally expected.
+    free_aligned_buffer_page_end(orig_pixels);
+  }
+}
+
+// Test data created in GIMP.  In export jpeg, disable
+// thumbnails etc, choose a subsampling, and use low quality
+// (50) to keep size small. Generated with xxd -i test.jpg
+// test 0 is J400
+static const uint8_t kTest0Jpg[] = {
+    0xff, 0xd8, 0xff, 0xe0, 0x00, 0x10, 0x4a, 0x46, 0x49, 0x46, 0x00, 0x01,
+    0x01, 0x01, 0x00, 0x48, 0x00, 0x48, 0x00, 0x00, 0xff, 0xdb, 0x00, 0x43,
+    0x00, 0x10, 0x0b, 0x0c, 0x0e, 0x0c, 0x0a, 0x10, 0x0e, 0x0d, 0x0e, 0x12,
+    0x11, 0x10, 0x13, 0x18, 0x28, 0x1a, 0x18, 0x16, 0x16, 0x18, 0x31, 0x23,
+    0x25, 0x1d, 0x28, 0x3a, 0x33, 0x3d, 0x3c, 0x39, 0x33, 0x38, 0x37, 0x40,
+    0x48, 0x5c, 0x4e, 0x40, 0x44, 0x57, 0x45, 0x37, 0x38, 0x50, 0x6d, 0x51,
+    0x57, 0x5f, 0x62, 0x67, 0x68, 0x67, 0x3e, 0x4d, 0x71, 0x79, 0x70, 0x64,
+    0x78, 0x5c, 0x65, 0x67, 0x63, 0xff, 0xc2, 0x00, 0x0b, 0x08, 0x00, 0x10,
+    0x00, 0x20, 0x01, 0x01, 0x11, 0x00, 0xff, 0xc4, 0x00, 0x17, 0x00, 0x01,
+    0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x03, 0x04, 0x01, 0x02, 0xff, 0xda, 0x00, 0x08, 0x01,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x43, 0x7e, 0xa7, 0x97, 0x57, 0xff, 0xc4,
+    0x00, 0x1b, 0x10, 0x00, 0x03, 0x00, 0x02, 0x03, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x11, 0x00, 0x03,
+    0x10, 0x12, 0x13, 0xff, 0xda, 0x00, 0x08, 0x01, 0x01, 0x00, 0x01, 0x05,
+    0x02, 0x3b, 0xc0, 0x6f, 0x66, 0x76, 0x56, 0x23, 0x87, 0x99, 0x0d, 0x26,
+    0x62, 0xf6, 0xbf, 0xff, 0xc4, 0x00, 0x1e, 0x10, 0x00, 0x02, 0x01, 0x03,
+    0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x11, 0x21, 0x02, 0x12, 0x32, 0x10, 0x31, 0x71, 0x81, 0xa1, 0xff,
+    0xda, 0x00, 0x08, 0x01, 0x01, 0x00, 0x06, 0x3f, 0x02, 0x4b, 0xb3, 0x28,
+    0x32, 0xd2, 0xed, 0xf9, 0x1d, 0x3e, 0x13, 0x51, 0x73, 0x83, 0xff, 0xc4,
+    0x00, 0x1c, 0x10, 0x01, 0x01, 0x01, 0x00, 0x02, 0x03, 0x01, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x11, 0x00, 0x21, 0x51,
+    0x31, 0x61, 0x81, 0xf0, 0xff, 0xda, 0x00, 0x08, 0x01, 0x01, 0x00, 0x01,
+    0x3f, 0x21, 0x65, 0x6e, 0x31, 0x86, 0x28, 0xf9, 0x30, 0xdc, 0x27, 0xdb,
+    0xa9, 0x01, 0xf3, 0xde, 0x02, 0xa0, 0xed, 0x1e, 0x34, 0x68, 0x23, 0xf9,
+    0xc6, 0x48, 0x5d, 0x7a, 0x35, 0x02, 0xf5, 0x6f, 0xff, 0xda, 0x00, 0x08,
+    0x01, 0x01, 0x00, 0x00, 0x00, 0x10, 0x35, 0xff, 0xc4, 0x00, 0x1f, 0x10,
+    0x01, 0x00, 0x02, 0x01, 0x04, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x11, 0x31, 0x41, 0x61, 0x71, 0x91,
+    0x21, 0x81, 0xd1, 0xb1, 0xff, 0xda, 0x00, 0x08, 0x01, 0x01, 0x00, 0x01,
+    0x3f, 0x10, 0x0b, 0x30, 0xe9, 0x58, 0xbe, 0x1a, 0xfd, 0x88, 0xab, 0x8b,
+    0x34, 0x74, 0x80, 0x4b, 0xb5, 0xd5, 0xab, 0xcd, 0x46, 0x96, 0x2e, 0xec,
+    0xbd, 0xaa, 0x78, 0x47, 0x5c, 0x47, 0xa7, 0x30, 0x49, 0xad, 0x88, 0x7c,
+    0x40, 0x74, 0x30, 0xff, 0x00, 0x23, 0x1d, 0x03, 0x0b, 0xb7, 0xd4, 0xff,
+    0xd9};
+static const size_t kTest0JpgLen = 421;
+
+// test 1 is J444
+static const uint8_t kTest1Jpg[] = {
+    0xff, 0xd8, 0xff, 0xe0, 0x00, 0x10, 0x4a, 0x46, 0x49, 0x46, 0x00, 0x01,
+    0x01, 0x01, 0x00, 0x48, 0x00, 0x48, 0x00, 0x00, 0xff, 0xdb, 0x00, 0x43,
+    0x00, 0x10, 0x0b, 0x0c, 0x0e, 0x0c, 0x0a, 0x10, 0x0e, 0x0d, 0x0e, 0x12,
+    0x11, 0x10, 0x13, 0x18, 0x28, 0x1a, 0x18, 0x16, 0x16, 0x18, 0x31, 0x23,
+    0x25, 0x1d, 0x28, 0x3a, 0x33, 0x3d, 0x3c, 0x39, 0x33, 0x38, 0x37, 0x40,
+    0x48, 0x5c, 0x4e, 0x40, 0x44, 0x57, 0x45, 0x37, 0x38, 0x50, 0x6d, 0x51,
+    0x57, 0x5f, 0x62, 0x67, 0x68, 0x67, 0x3e, 0x4d, 0x71, 0x79, 0x70, 0x64,
+    0x78, 0x5c, 0x65, 0x67, 0x63, 0xff, 0xdb, 0x00, 0x43, 0x01, 0x11, 0x12,
+    0x12, 0x18, 0x15, 0x18, 0x2f, 0x1a, 0x1a, 0x2f, 0x63, 0x42, 0x38, 0x42,
+    0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
+    0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
+    0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
+    0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
+    0x63, 0x63, 0xff, 0xc2, 0x00, 0x11, 0x08, 0x00, 0x10, 0x00, 0x20, 0x03,
+    0x01, 0x11, 0x00, 0x02, 0x11, 0x01, 0x03, 0x11, 0x01, 0xff, 0xc4, 0x00,
+    0x17, 0x00, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x04, 0x01, 0x02, 0xff, 0xc4,
+    0x00, 0x16, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x01, 0x03, 0xff, 0xda,
+    0x00, 0x0c, 0x03, 0x01, 0x00, 0x02, 0x10, 0x03, 0x10, 0x00, 0x00, 0x01,
+    0x40, 0x8f, 0x26, 0xe8, 0xf4, 0xcc, 0xf9, 0x69, 0x2b, 0x1b, 0x2a, 0xcb,
+    0xff, 0xc4, 0x00, 0x1b, 0x10, 0x00, 0x03, 0x00, 0x02, 0x03, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x11,
+    0x00, 0x03, 0x10, 0x12, 0x13, 0xff, 0xda, 0x00, 0x08, 0x01, 0x01, 0x00,
+    0x01, 0x05, 0x02, 0x3b, 0x80, 0x6f, 0x56, 0x76, 0x56, 0x23, 0x87, 0x99,
+    0x0d, 0x26, 0x62, 0xf6, 0xbf, 0xff, 0xc4, 0x00, 0x19, 0x11, 0x01, 0x00,
+    0x03, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x10, 0x11, 0x02, 0x12, 0xff, 0xda, 0x00, 0x08,
+    0x01, 0x03, 0x01, 0x01, 0x3f, 0x01, 0xf1, 0x00, 0x27, 0x45, 0xbb, 0x31,
+    0xaf, 0xff, 0xc4, 0x00, 0x1a, 0x11, 0x00, 0x02, 0x03, 0x01, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+    0x02, 0x10, 0x11, 0x41, 0x12, 0xff, 0xda, 0x00, 0x08, 0x01, 0x02, 0x01,
+    0x01, 0x3f, 0x01, 0xf6, 0x4b, 0x5f, 0x48, 0xb3, 0x69, 0x63, 0x35, 0x72,
+    0xbf, 0xff, 0xc4, 0x00, 0x1e, 0x10, 0x00, 0x02, 0x01, 0x03, 0x05, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11,
+    0x21, 0x02, 0x12, 0x32, 0x10, 0x31, 0x71, 0x81, 0xa1, 0xff, 0xda, 0x00,
+    0x08, 0x01, 0x01, 0x00, 0x06, 0x3f, 0x02, 0x4b, 0xb3, 0x28, 0x32, 0xd2,
+    0xed, 0xf9, 0x1d, 0x3e, 0x13, 0x51, 0x73, 0x83, 0xff, 0xc4, 0x00, 0x1c,
+    0x10, 0x01, 0x01, 0x01, 0x00, 0x02, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x11, 0x00, 0x21, 0x51, 0x31, 0x61,
+    0x81, 0xf0, 0xff, 0xda, 0x00, 0x08, 0x01, 0x01, 0x00, 0x01, 0x3f, 0x21,
+    0x75, 0x6e, 0x31, 0x94, 0x28, 0xf9, 0x30, 0xdc, 0x27, 0xdb, 0xa9, 0x01,
+    0xf3, 0xde, 0x02, 0xa0, 0xed, 0x1e, 0x34, 0x68, 0x23, 0xf9, 0xc6, 0x48,
+    0x5d, 0x7a, 0x35, 0x02, 0xf5, 0x6f, 0xff, 0xda, 0x00, 0x0c, 0x03, 0x01,
+    0x00, 0x02, 0x00, 0x03, 0x00, 0x00, 0x00, 0x10, 0x26, 0x61, 0xd4, 0xff,
+    0xc4, 0x00, 0x1a, 0x11, 0x00, 0x03, 0x01, 0x00, 0x03, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x11, 0x21,
+    0x31, 0x41, 0x51, 0xff, 0xda, 0x00, 0x08, 0x01, 0x03, 0x01, 0x01, 0x3f,
+    0x10, 0x54, 0xa8, 0xbf, 0x50, 0x87, 0xb0, 0x9d, 0x8b, 0xc4, 0x6a, 0x26,
+    0x6b, 0x2a, 0x9c, 0x1f, 0xff, 0xc4, 0x00, 0x18, 0x11, 0x01, 0x01, 0x01,
+    0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x11, 0x21, 0x51, 0xff, 0xda, 0x00, 0x08, 0x01, 0x02,
+    0x01, 0x01, 0x3f, 0x10, 0x70, 0xe1, 0x3e, 0xd1, 0x8e, 0x0d, 0xe1, 0xb5,
+    0xd5, 0x91, 0x76, 0x43, 0x82, 0x45, 0x4c, 0x7b, 0x7f, 0xff, 0xc4, 0x00,
+    0x1f, 0x10, 0x01, 0x00, 0x02, 0x01, 0x04, 0x03, 0x01, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x11, 0x31, 0x41, 0x61,
+    0x71, 0x91, 0x21, 0x81, 0xd1, 0xb1, 0xff, 0xda, 0x00, 0x08, 0x01, 0x01,
+    0x00, 0x01, 0x3f, 0x10, 0x1b, 0x30, 0xe9, 0x58, 0xbe, 0x1a, 0xfd, 0x8a,
+    0xeb, 0x8b, 0x34, 0x74, 0x80, 0x4b, 0xb5, 0xd5, 0xab, 0xcd, 0x46, 0x96,
+    0x2e, 0xec, 0xbd, 0xaa, 0x78, 0x47, 0x5c, 0x47, 0xa7, 0x30, 0x49, 0xad,
+    0x88, 0x7c, 0x40, 0x74, 0x30, 0xff, 0x00, 0x23, 0x1d, 0x03, 0x0b, 0xb7,
+    0xd4, 0xff, 0xd9};
+static const size_t kTest1JpgLen = 735;
+
+// test 2 is J420
+static const uint8_t kTest2Jpg[] = {
+    0xff, 0xd8, 0xff, 0xe0, 0x00, 0x10, 0x4a, 0x46, 0x49, 0x46, 0x00, 0x01,
+    0x01, 0x01, 0x00, 0x48, 0x00, 0x48, 0x00, 0x00, 0xff, 0xdb, 0x00, 0x43,
+    0x00, 0x10, 0x0b, 0x0c, 0x0e, 0x0c, 0x0a, 0x10, 0x0e, 0x0d, 0x0e, 0x12,
+    0x11, 0x10, 0x13, 0x18, 0x28, 0x1a, 0x18, 0x16, 0x16, 0x18, 0x31, 0x23,
+    0x25, 0x1d, 0x28, 0x3a, 0x33, 0x3d, 0x3c, 0x39, 0x33, 0x38, 0x37, 0x40,
+    0x48, 0x5c, 0x4e, 0x40, 0x44, 0x57, 0x45, 0x37, 0x38, 0x50, 0x6d, 0x51,
+    0x57, 0x5f, 0x62, 0x67, 0x68, 0x67, 0x3e, 0x4d, 0x71, 0x79, 0x70, 0x64,
+    0x78, 0x5c, 0x65, 0x67, 0x63, 0xff, 0xdb, 0x00, 0x43, 0x01, 0x11, 0x12,
+    0x12, 0x18, 0x15, 0x18, 0x2f, 0x1a, 0x1a, 0x2f, 0x63, 0x42, 0x38, 0x42,
+    0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
+    0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
+    0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
+    0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
+    0x63, 0x63, 0xff, 0xc2, 0x00, 0x11, 0x08, 0x00, 0x10, 0x00, 0x20, 0x03,
+    0x01, 0x22, 0x00, 0x02, 0x11, 0x01, 0x03, 0x11, 0x01, 0xff, 0xc4, 0x00,
+    0x18, 0x00, 0x00, 0x02, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x05, 0x01, 0x02, 0x04, 0xff,
+    0xc4, 0x00, 0x16, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x01, 0x02, 0xff,
+    0xda, 0x00, 0x0c, 0x03, 0x01, 0x00, 0x02, 0x10, 0x03, 0x10, 0x00, 0x00,
+    0x01, 0x20, 0xe7, 0x28, 0xa3, 0x0b, 0x2e, 0x2d, 0xcf, 0xff, 0xc4, 0x00,
+    0x1b, 0x10, 0x00, 0x03, 0x00, 0x02, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x11, 0x00, 0x03, 0x10,
+    0x12, 0x13, 0xff, 0xda, 0x00, 0x08, 0x01, 0x01, 0x00, 0x01, 0x05, 0x02,
+    0x3b, 0x80, 0x6f, 0x56, 0x76, 0x56, 0x23, 0x87, 0x99, 0x0d, 0x26, 0x62,
+    0xf6, 0xbf, 0xff, 0xc4, 0x00, 0x17, 0x11, 0x01, 0x00, 0x03, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x01, 0x11, 0x21, 0xff, 0xda, 0x00, 0x08, 0x01, 0x03, 0x01, 0x01, 0x3f,
+    0x01, 0xc8, 0x53, 0xff, 0xc4, 0x00, 0x16, 0x11, 0x01, 0x01, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x11, 0x32, 0xff, 0xda, 0x00, 0x08, 0x01, 0x02, 0x01, 0x01, 0x3f,
+    0x01, 0xd2, 0xc7, 0xff, 0xc4, 0x00, 0x1e, 0x10, 0x00, 0x02, 0x01, 0x03,
+    0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x11, 0x21, 0x02, 0x12, 0x32, 0x10, 0x31, 0x71, 0x81, 0xa1, 0xff,
+    0xda, 0x00, 0x08, 0x01, 0x01, 0x00, 0x06, 0x3f, 0x02, 0x4b, 0xb3, 0x28,
+    0x32, 0xd2, 0xed, 0xf9, 0x1d, 0x3e, 0x13, 0x51, 0x73, 0x83, 0xff, 0xc4,
+    0x00, 0x1c, 0x10, 0x01, 0x01, 0x01, 0x00, 0x02, 0x03, 0x01, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x11, 0x00, 0x21, 0x51,
+    0x31, 0x61, 0x81, 0xf0, 0xff, 0xda, 0x00, 0x08, 0x01, 0x01, 0x00, 0x01,
+    0x3f, 0x21, 0x75, 0x6e, 0x31, 0x94, 0x28, 0xf9, 0x30, 0xdc, 0x27, 0xdb,
+    0xa9, 0x01, 0xf3, 0xde, 0x02, 0xa0, 0xed, 0x1e, 0x34, 0x68, 0x23, 0xf9,
+    0xc6, 0x48, 0x5d, 0x7a, 0x35, 0x02, 0xf5, 0x6f, 0xff, 0xda, 0x00, 0x0c,
+    0x03, 0x01, 0x00, 0x02, 0x00, 0x03, 0x00, 0x00, 0x00, 0x10, 0x13, 0x5f,
+    0xff, 0xc4, 0x00, 0x17, 0x11, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x11,
+    0x21, 0xff, 0xda, 0x00, 0x08, 0x01, 0x03, 0x01, 0x01, 0x3f, 0x10, 0x0e,
+    0xa1, 0x3a, 0x76, 0xff, 0xc4, 0x00, 0x17, 0x11, 0x01, 0x01, 0x01, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x21, 0x11, 0xff, 0xda, 0x00, 0x08, 0x01, 0x02, 0x01, 0x01,
+    0x3f, 0x10, 0x57, 0x0b, 0x08, 0x70, 0xdb, 0xff, 0xc4, 0x00, 0x1f, 0x10,
+    0x01, 0x00, 0x02, 0x01, 0x04, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x11, 0x31, 0x41, 0x61, 0x71, 0x91,
+    0x21, 0x81, 0xd1, 0xb1, 0xff, 0xda, 0x00, 0x08, 0x01, 0x01, 0x00, 0x01,
+    0x3f, 0x10, 0x1b, 0x30, 0xe9, 0x58, 0xbe, 0x1a, 0xfd, 0x8a, 0xeb, 0x8b,
+    0x34, 0x74, 0x80, 0x4b, 0xb5, 0xd5, 0xab, 0xcd, 0x46, 0x96, 0x2e, 0xec,
+    0xbd, 0xaa, 0x78, 0x47, 0x5c, 0x47, 0xa7, 0x30, 0x49, 0xad, 0x88, 0x7c,
+    0x40, 0x74, 0x30, 0xff, 0x00, 0x23, 0x1d, 0x03, 0x0b, 0xb7, 0xd4, 0xff,
+    0xd9};
+static const size_t kTest2JpgLen = 685;
+
+// test 3 is J422
+static const uint8_t kTest3Jpg[] = {
+    0xff, 0xd8, 0xff, 0xe0, 0x00, 0x10, 0x4a, 0x46, 0x49, 0x46, 0x00, 0x01,
+    0x01, 0x01, 0x00, 0x48, 0x00, 0x48, 0x00, 0x00, 0xff, 0xdb, 0x00, 0x43,
+    0x00, 0x10, 0x0b, 0x0c, 0x0e, 0x0c, 0x0a, 0x10, 0x0e, 0x0d, 0x0e, 0x12,
+    0x11, 0x10, 0x13, 0x18, 0x28, 0x1a, 0x18, 0x16, 0x16, 0x18, 0x31, 0x23,
+    0x25, 0x1d, 0x28, 0x3a, 0x33, 0x3d, 0x3c, 0x39, 0x33, 0x38, 0x37, 0x40,
+    0x48, 0x5c, 0x4e, 0x40, 0x44, 0x57, 0x45, 0x37, 0x38, 0x50, 0x6d, 0x51,
+    0x57, 0x5f, 0x62, 0x67, 0x68, 0x67, 0x3e, 0x4d, 0x71, 0x79, 0x70, 0x64,
+    0x78, 0x5c, 0x65, 0x67, 0x63, 0xff, 0xdb, 0x00, 0x43, 0x01, 0x11, 0x12,
+    0x12, 0x18, 0x15, 0x18, 0x2f, 0x1a, 0x1a, 0x2f, 0x63, 0x42, 0x38, 0x42,
+    0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
+    0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
+    0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
+    0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
+    0x63, 0x63, 0xff, 0xc2, 0x00, 0x11, 0x08, 0x00, 0x10, 0x00, 0x20, 0x03,
+    0x01, 0x21, 0x00, 0x02, 0x11, 0x01, 0x03, 0x11, 0x01, 0xff, 0xc4, 0x00,
+    0x17, 0x00, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x04, 0x01, 0x02, 0xff, 0xc4,
+    0x00, 0x17, 0x01, 0x00, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x00, 0xff,
+    0xda, 0x00, 0x0c, 0x03, 0x01, 0x00, 0x02, 0x10, 0x03, 0x10, 0x00, 0x00,
+    0x01, 0x43, 0x8d, 0x1f, 0xa2, 0xb3, 0xca, 0x1b, 0x57, 0x0f, 0xff, 0xc4,
+    0x00, 0x1b, 0x10, 0x00, 0x03, 0x00, 0x02, 0x03, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x11, 0x00, 0x03,
+    0x10, 0x12, 0x13, 0xff, 0xda, 0x00, 0x08, 0x01, 0x01, 0x00, 0x01, 0x05,
+    0x02, 0x3b, 0x80, 0x6f, 0x56, 0x76, 0x56, 0x23, 0x87, 0x99, 0x0d, 0x26,
+    0x62, 0xf6, 0xbf, 0xff, 0xc4, 0x00, 0x19, 0x11, 0x00, 0x02, 0x03, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x01, 0x02, 0x10, 0x11, 0x21, 0xff, 0xda, 0x00, 0x08, 0x01, 0x03,
+    0x01, 0x01, 0x3f, 0x01, 0x51, 0xce, 0x8c, 0x75, 0xff, 0xc4, 0x00, 0x18,
+    0x11, 0x00, 0x03, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x61, 0x21, 0xff, 0xda,
+    0x00, 0x08, 0x01, 0x02, 0x01, 0x01, 0x3f, 0x01, 0xa6, 0xd9, 0x2f, 0x84,
+    0xe8, 0xf0, 0xff, 0xc4, 0x00, 0x1e, 0x10, 0x00, 0x02, 0x01, 0x03, 0x05,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x11, 0x21, 0x02, 0x12, 0x32, 0x10, 0x31, 0x71, 0x81, 0xa1, 0xff, 0xda,
+    0x00, 0x08, 0x01, 0x01, 0x00, 0x06, 0x3f, 0x02, 0x4b, 0xb3, 0x28, 0x32,
+    0xd2, 0xed, 0xf9, 0x1d, 0x3e, 0x13, 0x51, 0x73, 0x83, 0xff, 0xc4, 0x00,
+    0x1c, 0x10, 0x01, 0x01, 0x01, 0x00, 0x02, 0x03, 0x01, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x11, 0x00, 0x21, 0x51, 0x31,
+    0x61, 0x81, 0xf0, 0xff, 0xda, 0x00, 0x08, 0x01, 0x01, 0x00, 0x01, 0x3f,
+    0x21, 0x75, 0x6e, 0x31, 0x94, 0x28, 0xf9, 0x30, 0xdc, 0x27, 0xdb, 0xa9,
+    0x01, 0xf3, 0xde, 0x02, 0xa0, 0xed, 0x1e, 0x34, 0x68, 0x23, 0xf9, 0xc6,
+    0x48, 0x5d, 0x7a, 0x35, 0x02, 0xf5, 0x6f, 0xff, 0xda, 0x00, 0x0c, 0x03,
+    0x01, 0x00, 0x02, 0x00, 0x03, 0x00, 0x00, 0x00, 0x10, 0x2e, 0x45, 0xff,
+    0xc4, 0x00, 0x18, 0x11, 0x00, 0x03, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x11, 0x21,
+    0x31, 0xff, 0xda, 0x00, 0x08, 0x01, 0x03, 0x01, 0x01, 0x3f, 0x10, 0x53,
+    0x50, 0xba, 0x54, 0xc1, 0x67, 0x4f, 0xff, 0xc4, 0x00, 0x18, 0x11, 0x00,
+    0x03, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x01, 0x11, 0x21, 0x00, 0x10, 0xff, 0xda, 0x00, 0x08,
+    0x01, 0x02, 0x01, 0x01, 0x3f, 0x10, 0x18, 0x81, 0x5c, 0x04, 0x1a, 0xca,
+    0x91, 0xbf, 0xff, 0xc4, 0x00, 0x1f, 0x10, 0x01, 0x00, 0x02, 0x01, 0x04,
+    0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x11, 0x31, 0x41, 0x61, 0x71, 0x91, 0x21, 0x81, 0xd1, 0xb1, 0xff,
+    0xda, 0x00, 0x08, 0x01, 0x01, 0x00, 0x01, 0x3f, 0x10, 0x1b, 0x30, 0xe9,
+    0x58, 0xbe, 0x1a, 0xfd, 0x8a, 0xeb, 0x8b, 0x34, 0x74, 0x80, 0x4b, 0xb5,
+    0xd5, 0xab, 0xcd, 0x46, 0x96, 0x2e, 0xec, 0xbd, 0xaa, 0x78, 0x47, 0x5c,
+    0x47, 0xa7, 0x30, 0x49, 0xad, 0x88, 0x7c, 0x40, 0x74, 0x30, 0xff, 0x00,
+    0x23, 0x1d, 0x03, 0x0b, 0xb7, 0xd4, 0xff, 0xd9};
+static const size_t kTest3JpgLen = 704;
+
+// test 4 is J422 vertical - not supported
+static const uint8_t kTest4Jpg[] = {
+    0xff, 0xd8, 0xff, 0xe0, 0x00, 0x10, 0x4a, 0x46, 0x49, 0x46, 0x00, 0x01,
+    0x01, 0x01, 0x00, 0x48, 0x00, 0x48, 0x00, 0x00, 0xff, 0xdb, 0x00, 0x43,
+    0x00, 0x10, 0x0b, 0x0c, 0x0e, 0x0c, 0x0a, 0x10, 0x0e, 0x0d, 0x0e, 0x12,
+    0x11, 0x10, 0x13, 0x18, 0x28, 0x1a, 0x18, 0x16, 0x16, 0x18, 0x31, 0x23,
+    0x25, 0x1d, 0x28, 0x3a, 0x33, 0x3d, 0x3c, 0x39, 0x33, 0x38, 0x37, 0x40,
+    0x48, 0x5c, 0x4e, 0x40, 0x44, 0x57, 0x45, 0x37, 0x38, 0x50, 0x6d, 0x51,
+    0x57, 0x5f, 0x62, 0x67, 0x68, 0x67, 0x3e, 0x4d, 0x71, 0x79, 0x70, 0x64,
+    0x78, 0x5c, 0x65, 0x67, 0x63, 0xff, 0xdb, 0x00, 0x43, 0x01, 0x11, 0x12,
+    0x12, 0x18, 0x15, 0x18, 0x2f, 0x1a, 0x1a, 0x2f, 0x63, 0x42, 0x38, 0x42,
+    0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
+    0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
+    0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
+    0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
+    0x63, 0x63, 0xff, 0xc2, 0x00, 0x11, 0x08, 0x00, 0x10, 0x00, 0x20, 0x03,
+    0x01, 0x12, 0x00, 0x02, 0x11, 0x01, 0x03, 0x11, 0x01, 0xff, 0xc4, 0x00,
+    0x18, 0x00, 0x00, 0x02, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x05, 0x01, 0x02, 0x03, 0xff,
+    0xc4, 0x00, 0x16, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x03, 0xff,
+    0xda, 0x00, 0x0c, 0x03, 0x01, 0x00, 0x02, 0x10, 0x03, 0x10, 0x00, 0x00,
+    0x01, 0xd2, 0x98, 0xe9, 0x03, 0x0c, 0x00, 0x46, 0x21, 0xd9, 0xff, 0xc4,
+    0x00, 0x1b, 0x10, 0x00, 0x03, 0x00, 0x02, 0x03, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x11, 0x00, 0x03,
+    0x10, 0x12, 0x13, 0xff, 0xda, 0x00, 0x08, 0x01, 0x01, 0x00, 0x01, 0x05,
+    0x02, 0x3b, 0x80, 0x6f, 0x56, 0x76, 0x56, 0x23, 0x87, 0x99, 0x0d, 0x26,
+    0x62, 0xf6, 0xbf, 0xff, 0xc4, 0x00, 0x17, 0x11, 0x01, 0x01, 0x01, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x11, 0x01, 0x21, 0xff, 0xda, 0x00, 0x08, 0x01, 0x03, 0x01, 0x01,
+    0x3f, 0x01, 0x98, 0xb1, 0xbd, 0x47, 0xff, 0xc4, 0x00, 0x18, 0x11, 0x00,
+    0x03, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x01, 0x12, 0x11, 0x21, 0xff, 0xda, 0x00, 0x08,
+    0x01, 0x02, 0x01, 0x01, 0x3f, 0x01, 0xb6, 0x35, 0xa2, 0xe1, 0x47, 0xff,
+    0xc4, 0x00, 0x1e, 0x10, 0x00, 0x02, 0x01, 0x03, 0x05, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x21, 0x02,
+    0x12, 0x32, 0x10, 0x31, 0x71, 0x81, 0xa1, 0xff, 0xda, 0x00, 0x08, 0x01,
+    0x01, 0x00, 0x06, 0x3f, 0x02, 0x4b, 0xb3, 0x28, 0x32, 0xd2, 0xed, 0xf9,
+    0x1d, 0x3e, 0x13, 0x51, 0x73, 0x83, 0xff, 0xc4, 0x00, 0x1c, 0x10, 0x01,
+    0x01, 0x01, 0x00, 0x02, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x01, 0x11, 0x00, 0x21, 0x51, 0x31, 0x61, 0x81, 0xf0,
+    0xff, 0xda, 0x00, 0x08, 0x01, 0x01, 0x00, 0x01, 0x3f, 0x21, 0x75, 0x6e,
+    0x31, 0x94, 0x28, 0xf9, 0x30, 0xdc, 0x27, 0xdb, 0xa9, 0x01, 0xf3, 0xde,
+    0x02, 0xa0, 0xed, 0x1e, 0x34, 0x68, 0x23, 0xf9, 0xc6, 0x48, 0x5d, 0x7a,
+    0x35, 0x02, 0xf5, 0x6f, 0xff, 0xda, 0x00, 0x0c, 0x03, 0x01, 0x00, 0x02,
+    0x00, 0x03, 0x00, 0x00, 0x00, 0x10, 0x24, 0xaf, 0xff, 0xc4, 0x00, 0x19,
+    0x11, 0x00, 0x03, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x11, 0x51, 0x21, 0x31, 0xff,
+    0xda, 0x00, 0x08, 0x01, 0x03, 0x01, 0x01, 0x3f, 0x10, 0x59, 0x11, 0xca,
+    0x42, 0x60, 0x9f, 0x69, 0xff, 0xc4, 0x00, 0x19, 0x11, 0x00, 0x02, 0x03,
+    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x11, 0x21, 0x31, 0x61, 0xff, 0xda, 0x00, 0x08, 0x01,
+    0x02, 0x01, 0x01, 0x3f, 0x10, 0xb0, 0xd7, 0x27, 0x51, 0xb6, 0x41, 0xff,
+    0xc4, 0x00, 0x1f, 0x10, 0x01, 0x00, 0x02, 0x01, 0x04, 0x03, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x11, 0x31,
+    0x41, 0x61, 0x71, 0x91, 0x21, 0x81, 0xd1, 0xb1, 0xff, 0xda, 0x00, 0x08,
+    0x01, 0x01, 0x00, 0x01, 0x3f, 0x10, 0x1b, 0x30, 0xe9, 0x58, 0xbe, 0x1a,
+    0xfd, 0x8a, 0xeb, 0x8b, 0x34, 0x74, 0x80, 0x4b, 0xb5, 0xd5, 0xab, 0xcd,
+    0x46, 0x96, 0x2e, 0xec, 0xbd, 0xaa, 0x78, 0x47, 0x5c, 0x47, 0xa7, 0x30,
+    0x49, 0xad, 0x88, 0x7c, 0x40, 0x74, 0x30, 0xff, 0x00, 0x23, 0x1d, 0x03,
+    0x0b, 0xb7, 0xd4, 0xff, 0xd9};
+static const size_t kTest4JpgLen = 701;
+
+TEST_F(LibYUVConvertTest, TestMJPGSize) {
+  int width = 0;
+  int height = 0;
+  int ret = MJPGSize(kTest2Jpg, kTest2JpgLen, &width, &height);
+  EXPECT_EQ(0, ret);
+
+  printf("test jpeg size %d x %d\n", width, height);
+}
+
+TEST_F(LibYUVConvertTest, TestMJPGToI420) {
+  int width = 0;
+  int height = 0;
+  int ret = MJPGSize(kTest2Jpg, kTest2JpgLen, &width, &height);
+  EXPECT_EQ(0, ret);
+
+  int half_width = (width + 1) / 2;
+  int half_height = (height + 1) / 2;
+  int benchmark_iterations = benchmark_iterations_ * benchmark_width_ *
+                             benchmark_height_ / (width * height);
+
+  align_buffer_page_end(dst_y, width * height);
+  align_buffer_page_end(dst_u, half_width * half_height);
+  align_buffer_page_end(dst_v, half_width * half_height);
+  for (int times = 0; times < benchmark_iterations; ++times) {
+    ret = MJPGToI420(kTest2Jpg, kTest2JpgLen, dst_y, width, dst_u, half_width,
+                     dst_v, half_width, width, height, width, height);
+  }
+  // Expect sucesss
+  EXPECT_EQ(0, ret);
+
+  // Test result matches known hash value.
+  uint32_t dst_y_hash = HashDjb2(dst_y, width * height, 5381);
+  uint32_t dst_u_hash = HashDjb2(dst_u, half_width * half_height, 5381);
+  uint32_t dst_v_hash = HashDjb2(dst_v, half_width * half_height, 5381);
+  EXPECT_EQ(dst_y_hash, 2682851208u);
+  EXPECT_EQ(dst_u_hash, 2501859930u);
+  EXPECT_EQ(dst_v_hash, 2126459123u);
+
+  free_aligned_buffer_page_end(dst_y);
+  free_aligned_buffer_page_end(dst_u);
+  free_aligned_buffer_page_end(dst_v);
+}
+
+TEST_F(LibYUVConvertTest, TestMJPGToI420_NV21) {
+  int width = 0;
+  int height = 0;
+  int ret = MJPGSize(kTest2Jpg, kTest2JpgLen, &width, &height);
+  EXPECT_EQ(0, ret);
+
+  int half_width = (width + 1) / 2;
+  int half_height = (height + 1) / 2;
+  int benchmark_iterations = benchmark_iterations_ * benchmark_width_ *
+                             benchmark_height_ / (width * height);
+
+  // Convert to NV21
+  align_buffer_page_end(dst_y, width * height);
+  align_buffer_page_end(dst_vu, half_width * half_height * 2);
+
+  for (int times = 0; times < benchmark_iterations; ++times) {
+    ret = MJPGToNV21(kTest2Jpg, kTest2JpgLen, dst_y, width, dst_vu,
+                     half_width * 2, width, height, width, height);
+  }
+  // Expect sucesss
+  EXPECT_EQ(0, ret);
+
+  // Convert to I420
+  align_buffer_page_end(dst2_y, width * height);
+  align_buffer_page_end(dst2_u, half_width * half_height);
+  align_buffer_page_end(dst2_v, half_width * half_height);
+  for (int times = 0; times < benchmark_iterations; ++times) {
+    ret = MJPGToI420(kTest2Jpg, kTest2JpgLen, dst2_y, width, dst2_u, half_width,
+                     dst2_v, half_width, width, height, width, height);
+  }
+  // Expect sucesss
+  EXPECT_EQ(0, ret);
+
+  // Convert I420 to NV21
+  align_buffer_page_end(dst3_y, width * height);
+  align_buffer_page_end(dst3_vu, half_width * half_height * 2);
+
+  I420ToNV21(dst2_y, width, dst2_u, half_width, dst2_v, half_width, dst3_y,
+             width, dst3_vu, half_width * 2, width, height);
+
+  for (int i = 0; i < width * height; ++i) {
+    EXPECT_EQ(dst_y[i], dst3_y[i]);
+  }
+  for (int i = 0; i < half_width * half_height * 2; ++i) {
+    EXPECT_EQ(dst_vu[i], dst3_vu[i]);
+    EXPECT_EQ(dst_vu[i], dst3_vu[i]);
+  }
+
+  free_aligned_buffer_page_end(dst3_y);
+  free_aligned_buffer_page_end(dst3_vu);
+
+  free_aligned_buffer_page_end(dst2_y);
+  free_aligned_buffer_page_end(dst2_u);
+  free_aligned_buffer_page_end(dst2_v);
+
+  free_aligned_buffer_page_end(dst_y);
+  free_aligned_buffer_page_end(dst_vu);
+}
+
+TEST_F(LibYUVConvertTest, TestMJPGToI420_NV12) {
+  int width = 0;
+  int height = 0;
+  int ret = MJPGSize(kTest2Jpg, kTest2JpgLen, &width, &height);
+  EXPECT_EQ(0, ret);
+
+  int half_width = (width + 1) / 2;
+  int half_height = (height + 1) / 2;
+  int benchmark_iterations = benchmark_iterations_ * benchmark_width_ *
+                             benchmark_height_ / (width * height);
+
+  // Convert to NV12
+  align_buffer_page_end(dst_y, width * height);
+  align_buffer_page_end(dst_uv, half_width * half_height * 2);
+
+  for (int times = 0; times < benchmark_iterations; ++times) {
+    ret = MJPGToNV12(kTest2Jpg, kTest2JpgLen, dst_y, width, dst_uv,
+                     half_width * 2, width, height, width, height);
+  }
+  // Expect sucesss
+  EXPECT_EQ(0, ret);
+
+  // Convert to I420
+  align_buffer_page_end(dst2_y, width * height);
+  align_buffer_page_end(dst2_u, half_width * half_height);
+  align_buffer_page_end(dst2_v, half_width * half_height);
+  for (int times = 0; times < benchmark_iterations; ++times) {
+    ret = MJPGToI420(kTest2Jpg, kTest2JpgLen, dst2_y, width, dst2_u, half_width,
+                     dst2_v, half_width, width, height, width, height);
+  }
+  // Expect sucesss
+  EXPECT_EQ(0, ret);
+
+  // Convert I420 to NV12
+  align_buffer_page_end(dst3_y, width * height);
+  align_buffer_page_end(dst3_uv, half_width * half_height * 2);
+
+  I420ToNV12(dst2_y, width, dst2_u, half_width, dst2_v, half_width, dst3_y,
+             width, dst3_uv, half_width * 2, width, height);
+
+  for (int i = 0; i < width * height; ++i) {
+    EXPECT_EQ(dst_y[i], dst3_y[i]);
+  }
+  for (int i = 0; i < half_width * half_height * 2; ++i) {
+    EXPECT_EQ(dst_uv[i], dst3_uv[i]);
+    EXPECT_EQ(dst_uv[i], dst3_uv[i]);
+  }
+
+  free_aligned_buffer_page_end(dst3_y);
+  free_aligned_buffer_page_end(dst3_uv);
+
+  free_aligned_buffer_page_end(dst2_y);
+  free_aligned_buffer_page_end(dst2_u);
+  free_aligned_buffer_page_end(dst2_v);
+
+  free_aligned_buffer_page_end(dst_y);
+  free_aligned_buffer_page_end(dst_uv);
+}
+
+TEST_F(LibYUVConvertTest, TestMJPGToNV21_420) {
+  int width = 0;
+  int height = 0;
+  int ret = MJPGSize(kTest2Jpg, kTest2JpgLen, &width, &height);
+  EXPECT_EQ(0, ret);
+
+  int half_width = (width + 1) / 2;
+  int half_height = (height + 1) / 2;
+  int benchmark_iterations = benchmark_iterations_ * benchmark_width_ *
+                             benchmark_height_ / (width * height);
+
+  align_buffer_page_end(dst_y, width * height);
+  align_buffer_page_end(dst_uv, half_width * half_height * 2);
+  for (int times = 0; times < benchmark_iterations; ++times) {
+    ret = MJPGToNV21(kTest2Jpg, kTest2JpgLen, dst_y, width, dst_uv,
+                     half_width * 2, width, height, width, height);
+  }
+  // Expect sucesss
+  EXPECT_EQ(0, ret);
+
+  // Test result matches known hash value.
+  uint32_t dst_y_hash = HashDjb2(dst_y, width * height, 5381);
+  uint32_t dst_uv_hash = HashDjb2(dst_uv, half_width * half_height * 2, 5381);
+  EXPECT_EQ(dst_y_hash, 2682851208u);
+  EXPECT_EQ(dst_uv_hash, 1069662856u);
+
+  free_aligned_buffer_page_end(dst_y);
+  free_aligned_buffer_page_end(dst_uv);
+}
+
+TEST_F(LibYUVConvertTest, TestMJPGToNV12_420) {
+  int width = 0;
+  int height = 0;
+  int ret = MJPGSize(kTest2Jpg, kTest2JpgLen, &width, &height);
+  EXPECT_EQ(0, ret);
+
+  int half_width = (width + 1) / 2;
+  int half_height = (height + 1) / 2;
+  int benchmark_iterations = benchmark_iterations_ * benchmark_width_ *
+                             benchmark_height_ / (width * height);
+
+  align_buffer_page_end(dst_y, width * height);
+  align_buffer_page_end(dst_uv, half_width * half_height * 2);
+  for (int times = 0; times < benchmark_iterations; ++times) {
+    ret = MJPGToNV12(kTest2Jpg, kTest2JpgLen, dst_y, width, dst_uv,
+                     half_width * 2, width, height, width, height);
+  }
+  // Expect sucesss
+  EXPECT_EQ(0, ret);
+
+  // Test result matches known hash value. Hashes are for VU so flip the plane.
+  uint32_t dst_y_hash = HashDjb2(dst_y, width * height, 5381);
+  align_buffer_page_end(dst_vu, half_width * half_height * 2);
+  SwapUVPlane(dst_uv, half_width * 2, dst_vu, half_width * 2, half_width,
+              half_height);
+  uint32_t dst_vu_hash = HashDjb2(dst_vu, half_width * half_height * 2, 5381);
+  EXPECT_EQ(dst_y_hash, 2682851208u);
+  EXPECT_EQ(dst_vu_hash, 1069662856u);
+
+  free_aligned_buffer_page_end(dst_y);
+  free_aligned_buffer_page_end(dst_uv);
+  free_aligned_buffer_page_end(dst_vu);
+}
+
+// TODO(fbarchard): Improve test to compare against I422, not checksum
+TEST_F(LibYUVConvertTest, DISABLED_TestMJPGToNV21_422) {
+  int width = 0;
+  int height = 0;
+  int ret = MJPGSize(kTest3Jpg, kTest3JpgLen, &width, &height);
+  EXPECT_EQ(0, ret);
+
+  int half_width = (width + 1) / 2;
+  int half_height = (height + 1) / 2;
+  int benchmark_iterations = benchmark_iterations_ * benchmark_width_ *
+                             benchmark_height_ / (width * height);
+
+  align_buffer_page_end(dst_y, width * height);
+  align_buffer_page_end(dst_uv, half_width * half_height * 2);
+  for (int times = 0; times < benchmark_iterations; ++times) {
+    ret = MJPGToNV21(kTest3Jpg, kTest3JpgLen, dst_y, width, dst_uv,
+                     half_width * 2, width, height, width, height);
+  }
+  // Expect sucesss
+  EXPECT_EQ(0, ret);
+
+  // Test result matches known hash value.
+  uint32_t dst_y_hash = HashDjb2(dst_y, width * height, 5381);
+  uint32_t dst_uv_hash = HashDjb2(dst_uv, half_width * half_height * 2, 5381);
+  EXPECT_EQ(dst_y_hash, 2682851208u);
+  EXPECT_EQ(dst_uv_hash, 493520167u);
+
+  free_aligned_buffer_page_end(dst_y);
+  free_aligned_buffer_page_end(dst_uv);
+}
+
+TEST_F(LibYUVConvertTest, DISABLED_TestMJPGToNV12_422) {
+  int width = 0;
+  int height = 0;
+  int ret = MJPGSize(kTest3Jpg, kTest3JpgLen, &width, &height);
+  EXPECT_EQ(0, ret);
+
+  int half_width = (width + 1) / 2;
+  int half_height = (height + 1) / 2;
+  int benchmark_iterations = benchmark_iterations_ * benchmark_width_ *
+                             benchmark_height_ / (width * height);
+
+  align_buffer_page_end(dst_y, width * height);
+  align_buffer_page_end(dst_uv, half_width * half_height * 2);
+  for (int times = 0; times < benchmark_iterations; ++times) {
+    ret = MJPGToNV12(kTest3Jpg, kTest3JpgLen, dst_y, width, dst_uv,
+                     half_width * 2, width, height, width, height);
+  }
+  // Expect sucesss
+  EXPECT_EQ(0, ret);
+
+  // Test result matches known hash value. Hashes are for VU so flip the plane.
+  uint32_t dst_y_hash = HashDjb2(dst_y, width * height, 5381);
+  align_buffer_page_end(dst_vu, half_width * half_height * 2);
+  SwapUVPlane(dst_uv, half_width * 2, dst_vu, half_width * 2, half_width,
+              half_height);
+  uint32_t dst_vu_hash = HashDjb2(dst_vu, half_width * half_height * 2, 5381);
+  EXPECT_EQ(dst_y_hash, 2682851208u);
+  EXPECT_EQ(dst_vu_hash, 493520167u);
+
+  free_aligned_buffer_page_end(dst_y);
+  free_aligned_buffer_page_end(dst_uv);
+  free_aligned_buffer_page_end(dst_vu);
+}
+
+TEST_F(LibYUVConvertTest, TestMJPGToNV21_400) {
+  int width = 0;
+  int height = 0;
+  int ret = MJPGSize(kTest0Jpg, kTest0JpgLen, &width, &height);
+  EXPECT_EQ(0, ret);
+
+  int half_width = (width + 1) / 2;
+  int half_height = (height + 1) / 2;
+  int benchmark_iterations = benchmark_iterations_ * benchmark_width_ *
+                             benchmark_height_ / (width * height);
+
+  align_buffer_page_end(dst_y, width * height);
+  align_buffer_page_end(dst_uv, half_width * half_height * 2);
+  for (int times = 0; times < benchmark_iterations; ++times) {
+    ret = MJPGToNV21(kTest0Jpg, kTest0JpgLen, dst_y, width, dst_uv,
+                     half_width * 2, width, height, width, height);
+  }
+  // Expect sucesss
+  EXPECT_EQ(0, ret);
+
+  // Test result matches known hash value.
+  uint32_t dst_y_hash = HashDjb2(dst_y, width * height, 5381);
+  uint32_t dst_uv_hash = HashDjb2(dst_uv, half_width * half_height * 2, 5381);
+  EXPECT_EQ(dst_y_hash, 330644005u);
+  EXPECT_EQ(dst_uv_hash, 135214341u);
+
+  free_aligned_buffer_page_end(dst_y);
+  free_aligned_buffer_page_end(dst_uv);
+}
+
+TEST_F(LibYUVConvertTest, TestMJPGToNV12_400) {
+  int width = 0;
+  int height = 0;
+  int ret = MJPGSize(kTest0Jpg, kTest0JpgLen, &width, &height);
+  EXPECT_EQ(0, ret);
+
+  int half_width = (width + 1) / 2;
+  int half_height = (height + 1) / 2;
+  int benchmark_iterations = benchmark_iterations_ * benchmark_width_ *
+                             benchmark_height_ / (width * height);
+
+  align_buffer_page_end(dst_y, width * height);
+  align_buffer_page_end(dst_uv, half_width * half_height * 2);
+  for (int times = 0; times < benchmark_iterations; ++times) {
+    ret = MJPGToNV12(kTest0Jpg, kTest0JpgLen, dst_y, width, dst_uv,
+                     half_width * 2, width, height, width, height);
+  }
+  // Expect sucesss
+  EXPECT_EQ(0, ret);
+
+  // Test result matches known hash value. Hashes are for VU so flip the plane.
+  uint32_t dst_y_hash = HashDjb2(dst_y, width * height, 5381);
+  align_buffer_page_end(dst_vu, half_width * half_height * 2);
+  SwapUVPlane(dst_uv, half_width * 2, dst_vu, half_width * 2, half_width,
+              half_height);
+  uint32_t dst_vu_hash = HashDjb2(dst_vu, half_width * half_height * 2, 5381);
+  EXPECT_EQ(dst_y_hash, 330644005u);
+  EXPECT_EQ(dst_vu_hash, 135214341u);
+
+  free_aligned_buffer_page_end(dst_y);
+  free_aligned_buffer_page_end(dst_uv);
+  free_aligned_buffer_page_end(dst_vu);
+}
+
+TEST_F(LibYUVConvertTest, TestMJPGToNV21_444) {
+  int width = 0;
+  int height = 0;
+  int ret = MJPGSize(kTest1Jpg, kTest1JpgLen, &width, &height);
+  EXPECT_EQ(0, ret);
+
+  int half_width = (width + 1) / 2;
+  int half_height = (height + 1) / 2;
+  int benchmark_iterations = benchmark_iterations_ * benchmark_width_ *
+                             benchmark_height_ / (width * height);
+
+  align_buffer_page_end(dst_y, width * height);
+  align_buffer_page_end(dst_uv, half_width * half_height * 2);
+  for (int times = 0; times < benchmark_iterations; ++times) {
+    ret = MJPGToNV21(kTest1Jpg, kTest1JpgLen, dst_y, width, dst_uv,
+                     half_width * 2, width, height, width, height);
+  }
+  // Expect sucesss
+  EXPECT_EQ(0, ret);
+
+  // Test result matches known hash value.
+  uint32_t dst_y_hash = HashDjb2(dst_y, width * height, 5381);
+  uint32_t dst_uv_hash = HashDjb2(dst_uv, half_width * half_height * 2, 5381);
+  EXPECT_EQ(dst_y_hash, 2682851208u);
+  EXPECT_EQ(dst_uv_hash, 506143297u);
+
+  free_aligned_buffer_page_end(dst_y);
+  free_aligned_buffer_page_end(dst_uv);
+}
+
+TEST_F(LibYUVConvertTest, TestMJPGToNV12_444) {
+  int width = 0;
+  int height = 0;
+  int ret = MJPGSize(kTest1Jpg, kTest1JpgLen, &width, &height);
+  EXPECT_EQ(0, ret);
+
+  int half_width = (width + 1) / 2;
+  int half_height = (height + 1) / 2;
+  int benchmark_iterations = benchmark_iterations_ * benchmark_width_ *
+                             benchmark_height_ / (width * height);
+
+  align_buffer_page_end(dst_y, width * height);
+  align_buffer_page_end(dst_uv, half_width * half_height * 2);
+  for (int times = 0; times < benchmark_iterations; ++times) {
+    ret = MJPGToNV12(kTest1Jpg, kTest1JpgLen, dst_y, width, dst_uv,
+                     half_width * 2, width, height, width, height);
+  }
+  // Expect sucesss
+  EXPECT_EQ(0, ret);
+
+  // Test result matches known hash value. Hashes are for VU so flip the plane.
+  uint32_t dst_y_hash = HashDjb2(dst_y, width * height, 5381);
+  align_buffer_page_end(dst_vu, half_width * half_height * 2);
+  SwapUVPlane(dst_uv, half_width * 2, dst_vu, half_width * 2, half_width,
+              half_height);
+  uint32_t dst_vu_hash = HashDjb2(dst_vu, half_width * half_height * 2, 5381);
+  EXPECT_EQ(dst_y_hash, 2682851208u);
+  EXPECT_EQ(dst_vu_hash, 506143297u);
+
+  free_aligned_buffer_page_end(dst_y);
+  free_aligned_buffer_page_end(dst_uv);
+  free_aligned_buffer_page_end(dst_vu);
+}
+
+TEST_F(LibYUVConvertTest, TestMJPGToARGB) {
+  int width = 0;
+  int height = 0;
+  int ret = MJPGSize(kTest3Jpg, kTest3JpgLen, &width, &height);
+  EXPECT_EQ(0, ret);
+
+  int benchmark_iterations = benchmark_iterations_ * benchmark_width_ *
+                             benchmark_height_ / (width * height);
+
+  align_buffer_page_end(dst_argb, width * height * 4);
+  for (int times = 0; times < benchmark_iterations; ++times) {
+    ret = MJPGToARGB(kTest3Jpg, kTest3JpgLen, dst_argb, width * 4, width,
+                     height, width, height);
+  }
+  // Expect sucesss
+  EXPECT_EQ(0, ret);
+
+  // Test result matches known hash value.
+  uint32_t dst_argb_hash = HashDjb2(dst_argb, width * height, 5381);
+#ifdef LIBYUV_UNLIMITED_DATA
+  EXPECT_EQ(dst_argb_hash, 3900633302u);
+#else
+  EXPECT_EQ(dst_argb_hash, 2355976473u);
+#endif
+
+  free_aligned_buffer_page_end(dst_argb);
+}
+
+static int ShowJPegInfo(const uint8_t* sample, size_t sample_size) {
+  MJpegDecoder mjpeg_decoder;
+  LIBYUV_BOOL ret = mjpeg_decoder.LoadFrame(sample, sample_size);
+
+  int width = mjpeg_decoder.GetWidth();
+  int height = mjpeg_decoder.GetHeight();
+
+  // YUV420
+  if (mjpeg_decoder.GetColorSpace() == MJpegDecoder::kColorSpaceYCbCr &&
+      mjpeg_decoder.GetNumComponents() == 3 &&
+      mjpeg_decoder.GetVertSampFactor(0) == 2 &&
+      mjpeg_decoder.GetHorizSampFactor(0) == 2 &&
+      mjpeg_decoder.GetVertSampFactor(1) == 1 &&
+      mjpeg_decoder.GetHorizSampFactor(1) == 1 &&
+      mjpeg_decoder.GetVertSampFactor(2) == 1 &&
+      mjpeg_decoder.GetHorizSampFactor(2) == 1) {
+    printf("JPeg is J420, %dx%d %d bytes\n", width, height,
+           static_cast<int>(sample_size));
+    // YUV422
+  } else if (mjpeg_decoder.GetColorSpace() == MJpegDecoder::kColorSpaceYCbCr &&
+             mjpeg_decoder.GetNumComponents() == 3 &&
+             mjpeg_decoder.GetVertSampFactor(0) == 1 &&
+             mjpeg_decoder.GetHorizSampFactor(0) == 2 &&
+             mjpeg_decoder.GetVertSampFactor(1) == 1 &&
+             mjpeg_decoder.GetHorizSampFactor(1) == 1 &&
+             mjpeg_decoder.GetVertSampFactor(2) == 1 &&
+             mjpeg_decoder.GetHorizSampFactor(2) == 1) {
+    printf("JPeg is J422, %dx%d %d bytes\n", width, height,
+           static_cast<int>(sample_size));
+    // YUV444
+  } else if (mjpeg_decoder.GetColorSpace() == MJpegDecoder::kColorSpaceYCbCr &&
+             mjpeg_decoder.GetNumComponents() == 3 &&
+             mjpeg_decoder.GetVertSampFactor(0) == 1 &&
+             mjpeg_decoder.GetHorizSampFactor(0) == 1 &&
+             mjpeg_decoder.GetVertSampFactor(1) == 1 &&
+             mjpeg_decoder.GetHorizSampFactor(1) == 1 &&
+             mjpeg_decoder.GetVertSampFactor(2) == 1 &&
+             mjpeg_decoder.GetHorizSampFactor(2) == 1) {
+    printf("JPeg is J444, %dx%d %d bytes\n", width, height,
+           static_cast<int>(sample_size));
+    // YUV400
+  } else if (mjpeg_decoder.GetColorSpace() ==
+                 MJpegDecoder::kColorSpaceGrayscale &&
+             mjpeg_decoder.GetNumComponents() == 1 &&
+             mjpeg_decoder.GetVertSampFactor(0) == 1 &&
+             mjpeg_decoder.GetHorizSampFactor(0) == 1) {
+    printf("JPeg is J400, %dx%d %d bytes\n", width, height,
+           static_cast<int>(sample_size));
+  } else {
+    // Unknown colorspace.
+    printf("JPeg is Unknown colorspace.\n");
+  }
+  mjpeg_decoder.UnloadFrame();
+  return ret;
+}
+
+TEST_F(LibYUVConvertTest, TestMJPGInfo) {
+  EXPECT_EQ(1, ShowJPegInfo(kTest0Jpg, kTest0JpgLen));
+  EXPECT_EQ(1, ShowJPegInfo(kTest1Jpg, kTest1JpgLen));
+  EXPECT_EQ(1, ShowJPegInfo(kTest2Jpg, kTest2JpgLen));
+  EXPECT_EQ(1, ShowJPegInfo(kTest3Jpg, kTest3JpgLen));
+  EXPECT_EQ(1, ShowJPegInfo(kTest4Jpg,
+                            kTest4JpgLen));  // Valid but unsupported.
+}
+#endif  // HAVE_JPEG
+
+TEST_F(LibYUVConvertTest, NV12Crop) {
+  const int SUBSAMP_X = 2;
+  const int SUBSAMP_Y = 2;
+  const int kWidth = benchmark_width_;
+  const int kHeight = benchmark_height_;
+  const int crop_y =
+      ((benchmark_height_ - (benchmark_height_ * 360 / 480)) / 2 + 1) & ~1;
+  const int kDestWidth = benchmark_width_;
+  const int kDestHeight = benchmark_height_ - crop_y * 2;
+  const int kStrideUV = SUBSAMPLE(kWidth, SUBSAMP_X);
+  const int sample_size =
+      kWidth * kHeight + kStrideUV * SUBSAMPLE(kHeight, SUBSAMP_Y) * 2;
+  align_buffer_page_end(src_y, sample_size);
+  uint8_t* src_uv = src_y + kWidth * kHeight;
+
+  align_buffer_page_end(dst_y, kDestWidth * kDestHeight);
+  align_buffer_page_end(dst_u, SUBSAMPLE(kDestWidth, SUBSAMP_X) *
+                                   SUBSAMPLE(kDestHeight, SUBSAMP_Y));
+  align_buffer_page_end(dst_v, SUBSAMPLE(kDestWidth, SUBSAMP_X) *
+                                   SUBSAMPLE(kDestHeight, SUBSAMP_Y));
+
+  align_buffer_page_end(dst_y_2, kDestWidth * kDestHeight);
+  align_buffer_page_end(dst_u_2, SUBSAMPLE(kDestWidth, SUBSAMP_X) *
+                                     SUBSAMPLE(kDestHeight, SUBSAMP_Y));
+  align_buffer_page_end(dst_v_2, SUBSAMPLE(kDestWidth, SUBSAMP_X) *
+                                     SUBSAMPLE(kDestHeight, SUBSAMP_Y));
+
+  for (int i = 0; i < kHeight * kWidth; ++i) {
+    src_y[i] = (fastrand() & 0xff);
+  }
+  for (int i = 0; i < (SUBSAMPLE(kHeight, SUBSAMP_Y) * kStrideUV) * 2; ++i) {
+    src_uv[i] = (fastrand() & 0xff);
+  }
+  memset(dst_y, 1, kDestWidth * kDestHeight);
+  memset(dst_u, 2,
+         SUBSAMPLE(kDestWidth, SUBSAMP_X) * SUBSAMPLE(kDestHeight, SUBSAMP_Y));
+  memset(dst_v, 3,
+         SUBSAMPLE(kDestWidth, SUBSAMP_X) * SUBSAMPLE(kDestHeight, SUBSAMP_Y));
+  memset(dst_y_2, 1, kDestWidth * kDestHeight);
+  memset(dst_u_2, 2,
+         SUBSAMPLE(kDestWidth, SUBSAMP_X) * SUBSAMPLE(kDestHeight, SUBSAMP_Y));
+  memset(dst_v_2, 3,
+         SUBSAMPLE(kDestWidth, SUBSAMP_X) * SUBSAMPLE(kDestHeight, SUBSAMP_Y));
+
+  ConvertToI420(src_y, sample_size, dst_y_2, kDestWidth, dst_u_2,
+                SUBSAMPLE(kDestWidth, SUBSAMP_X), dst_v_2,
+                SUBSAMPLE(kDestWidth, SUBSAMP_X), 0, crop_y, kWidth, kHeight,
+                kDestWidth, kDestHeight, libyuv::kRotate0, libyuv::FOURCC_NV12);
+
+  NV12ToI420(src_y + crop_y * kWidth, kWidth,
+             src_uv + (crop_y / 2) * kStrideUV * 2, kStrideUV * 2, dst_y,
+             kDestWidth, dst_u, SUBSAMPLE(kDestWidth, SUBSAMP_X), dst_v,
+             SUBSAMPLE(kDestWidth, SUBSAMP_X), kDestWidth, kDestHeight);
+
+  for (int i = 0; i < kDestHeight; ++i) {
+    for (int j = 0; j < kDestWidth; ++j) {
+      EXPECT_EQ(dst_y[i * kWidth + j], dst_y_2[i * kWidth + j]);
+    }
+  }
+  for (int i = 0; i < SUBSAMPLE(kDestHeight, SUBSAMP_Y); ++i) {
+    for (int j = 0; j < SUBSAMPLE(kDestWidth, SUBSAMP_X); ++j) {
+      EXPECT_EQ(dst_u[i * SUBSAMPLE(kDestWidth, SUBSAMP_X) + j],
+                dst_u_2[i * SUBSAMPLE(kDestWidth, SUBSAMP_X) + j]);
+    }
+  }
+  for (int i = 0; i < SUBSAMPLE(kDestHeight, SUBSAMP_Y); ++i) {
+    for (int j = 0; j < SUBSAMPLE(kDestWidth, SUBSAMP_X); ++j) {
+      EXPECT_EQ(dst_v[i * SUBSAMPLE(kDestWidth, SUBSAMP_X) + j],
+                dst_v_2[i * SUBSAMPLE(kDestWidth, SUBSAMP_X) + j]);
+    }
+  }
+  free_aligned_buffer_page_end(dst_y);
+  free_aligned_buffer_page_end(dst_u);
+  free_aligned_buffer_page_end(dst_v);
+  free_aligned_buffer_page_end(dst_y_2);
+  free_aligned_buffer_page_end(dst_u_2);
+  free_aligned_buffer_page_end(dst_v_2);
+  free_aligned_buffer_page_end(src_y);
+}
+
+TEST_F(LibYUVConvertTest, I420CropOddY) {
+  const int SUBSAMP_X = 2;
+  const int SUBSAMP_Y = 2;
+  const int kWidth = benchmark_width_;
+  const int kHeight = benchmark_height_;
+  const int crop_y = benchmark_height_ > 1 ? 1 : 0;
+  const int kDestWidth = benchmark_width_;
+  const int kDestHeight = benchmark_height_ - crop_y * 2;
+  const int kStrideU = SUBSAMPLE(kWidth, SUBSAMP_X);
+  const int kStrideV = SUBSAMPLE(kWidth, SUBSAMP_X);
+  const int sample_size = kWidth * kHeight +
+                          kStrideU * SUBSAMPLE(kHeight, SUBSAMP_Y) +
+                          kStrideV * SUBSAMPLE(kHeight, SUBSAMP_Y);
+  align_buffer_page_end(src_y, sample_size);
+  uint8_t* src_u = src_y + kWidth * kHeight;
+  uint8_t* src_v = src_u + kStrideU * SUBSAMPLE(kHeight, SUBSAMP_Y);
+
+  align_buffer_page_end(dst_y, kDestWidth * kDestHeight);
+  align_buffer_page_end(dst_u, SUBSAMPLE(kDestWidth, SUBSAMP_X) *
+                                   SUBSAMPLE(kDestHeight, SUBSAMP_Y));
+  align_buffer_page_end(dst_v, SUBSAMPLE(kDestWidth, SUBSAMP_X) *
+                                   SUBSAMPLE(kDestHeight, SUBSAMP_Y));
+
+  for (int i = 0; i < kHeight * kWidth; ++i) {
+    src_y[i] = (fastrand() & 0xff);
+  }
+  for (int i = 0; i < SUBSAMPLE(kHeight, SUBSAMP_Y) * kStrideU; ++i) {
+    src_u[i] = (fastrand() & 0xff);
+  }
+  for (int i = 0; i < SUBSAMPLE(kHeight, SUBSAMP_Y) * kStrideV; ++i) {
+    src_v[i] = (fastrand() & 0xff);
+  }
+  memset(dst_y, 1, kDestWidth * kDestHeight);
+  memset(dst_u, 2,
+         SUBSAMPLE(kDestWidth, SUBSAMP_X) * SUBSAMPLE(kDestHeight, SUBSAMP_Y));
+  memset(dst_v, 3,
+         SUBSAMPLE(kDestWidth, SUBSAMP_X) * SUBSAMPLE(kDestHeight, SUBSAMP_Y));
+
+  MaskCpuFlags(benchmark_cpu_info_);
+  for (int i = 0; i < benchmark_iterations_; ++i) {
+    ConvertToI420(src_y, sample_size, dst_y, kDestWidth, dst_u,
+                  SUBSAMPLE(kDestWidth, SUBSAMP_X), dst_v,
+                  SUBSAMPLE(kDestWidth, SUBSAMP_X), 0, crop_y, kWidth, kHeight,
+                  kDestWidth, kDestHeight, libyuv::kRotate0,
+                  libyuv::FOURCC_I420);
+  }
+
+  for (int i = 0; i < kDestHeight; ++i) {
+    for (int j = 0; j < kDestWidth; ++j) {
+      EXPECT_EQ(src_y[crop_y * kWidth + i * kWidth + j],
+                dst_y[i * kDestWidth + j]);
+    }
+  }
+  for (int i = 0; i < SUBSAMPLE(kDestHeight, SUBSAMP_Y); ++i) {
+    for (int j = 0; j < SUBSAMPLE(kDestWidth, SUBSAMP_X); ++j) {
+      EXPECT_EQ(src_u[(crop_y / 2 + i) * kStrideU + j],
+                dst_u[i * SUBSAMPLE(kDestWidth, SUBSAMP_X) + j]);
+    }
+  }
+  for (int i = 0; i < SUBSAMPLE(kDestHeight, SUBSAMP_Y); ++i) {
+    for (int j = 0; j < SUBSAMPLE(kDestWidth, SUBSAMP_X); ++j) {
+      EXPECT_EQ(src_v[(crop_y / 2 + i) * kStrideV + j],
+                dst_v[i * SUBSAMPLE(kDestWidth, SUBSAMP_X) + j]);
+    }
+  }
+
+  free_aligned_buffer_page_end(dst_y);
+  free_aligned_buffer_page_end(dst_u);
+  free_aligned_buffer_page_end(dst_v);
+  free_aligned_buffer_page_end(src_y);
+}
+
+TEST_F(LibYUVConvertTest, TestYToARGB) {
+  uint8_t y[32];
+  uint8_t expectedg[32];
+  for (int i = 0; i < 32; ++i) {
+    y[i] = i * 5 + 17;
+    expectedg[i] = static_cast<int>((y[i] - 16) * 1.164f + 0.5f);
+  }
+  uint8_t argb[32 * 4];
+  YToARGB(y, 0, argb, 0, 32, 1);
+
+  for (int i = 0; i < 32; ++i) {
+    printf("%2d %d: %d <-> %d,%d,%d,%d\n", i, y[i], expectedg[i],
+           argb[i * 4 + 0], argb[i * 4 + 1], argb[i * 4 + 2], argb[i * 4 + 3]);
+  }
+  for (int i = 0; i < 32; ++i) {
+    EXPECT_EQ(expectedg[i], argb[i * 4 + 0]);
+  }
+}
+
+static const uint8_t kNoDither4x4[16] = {
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+};
+
+TEST_F(LibYUVConvertTest, TestNoDither) {
+  align_buffer_page_end(src_argb, benchmark_width_ * benchmark_height_ * 4);
+  align_buffer_page_end(dst_rgb565, benchmark_width_ * benchmark_height_ * 2);
+  align_buffer_page_end(dst_rgb565dither,
+                        benchmark_width_ * benchmark_height_ * 2);
+  MemRandomize(src_argb, benchmark_width_ * benchmark_height_ * 4);
+  MemRandomize(dst_rgb565, benchmark_width_ * benchmark_height_ * 2);
+  MemRandomize(dst_rgb565dither, benchmark_width_ * benchmark_height_ * 2);
+  ARGBToRGB565(src_argb, benchmark_width_ * 4, dst_rgb565, benchmark_width_ * 2,
+               benchmark_width_, benchmark_height_);
+  ARGBToRGB565Dither(src_argb, benchmark_width_ * 4, dst_rgb565dither,
+                     benchmark_width_ * 2, kNoDither4x4, benchmark_width_,
+                     benchmark_height_);
+  for (int i = 0; i < benchmark_width_ * benchmark_height_ * 2; ++i) {
+    EXPECT_EQ(dst_rgb565[i], dst_rgb565dither[i]);
+  }
+
+  free_aligned_buffer_page_end(src_argb);
+  free_aligned_buffer_page_end(dst_rgb565);
+  free_aligned_buffer_page_end(dst_rgb565dither);
+}
+
+// Ordered 4x4 dither for 888 to 565.  Values from 0 to 7.
+static const uint8_t kDither565_4x4[16] = {
+    0, 4, 1, 5, 6, 2, 7, 3, 1, 5, 0, 4, 7, 3, 6, 2,
+};
+
+TEST_F(LibYUVConvertTest, TestDither) {
+  align_buffer_page_end(src_argb, benchmark_width_ * benchmark_height_ * 4);
+  align_buffer_page_end(dst_rgb565, benchmark_width_ * benchmark_height_ * 2);
+  align_buffer_page_end(dst_rgb565dither,
+                        benchmark_width_ * benchmark_height_ * 2);
+  align_buffer_page_end(dst_argb, benchmark_width_ * benchmark_height_ * 4);
+  align_buffer_page_end(dst_argbdither,
+                        benchmark_width_ * benchmark_height_ * 4);
+  MemRandomize(src_argb, benchmark_width_ * benchmark_height_ * 4);
+  MemRandomize(dst_rgb565, benchmark_width_ * benchmark_height_ * 2);
+  MemRandomize(dst_rgb565dither, benchmark_width_ * benchmark_height_ * 2);
+  MemRandomize(dst_argb, benchmark_width_ * benchmark_height_ * 4);
+  MemRandomize(dst_argbdither, benchmark_width_ * benchmark_height_ * 4);
+  ARGBToRGB565(src_argb, benchmark_width_ * 4, dst_rgb565, benchmark_width_ * 2,
+               benchmark_width_, benchmark_height_);
+  ARGBToRGB565Dither(src_argb, benchmark_width_ * 4, dst_rgb565dither,
+                     benchmark_width_ * 2, kDither565_4x4, benchmark_width_,
+                     benchmark_height_);
+  RGB565ToARGB(dst_rgb565, benchmark_width_ * 2, dst_argb, benchmark_width_ * 4,
+               benchmark_width_, benchmark_height_);
+  RGB565ToARGB(dst_rgb565dither, benchmark_width_ * 2, dst_argbdither,
+               benchmark_width_ * 4, benchmark_width_, benchmark_height_);
+
+  for (int i = 0; i < benchmark_width_ * benchmark_height_ * 4; ++i) {
+    EXPECT_NEAR(dst_argb[i], dst_argbdither[i], 9);
+  }
+  free_aligned_buffer_page_end(src_argb);
+  free_aligned_buffer_page_end(dst_rgb565);
+  free_aligned_buffer_page_end(dst_rgb565dither);
+  free_aligned_buffer_page_end(dst_argb);
+  free_aligned_buffer_page_end(dst_argbdither);
+}
+
+#define TESTPLANARTOBID(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN, \
+                        YALIGN, W1280, N, NEG, OFF, FMT_C, BPP_C)              \
+  TEST_F(LibYUVConvertTest, FMT_PLANAR##To##FMT_B##Dither##N) {                \
+    const int kWidth = W1280;                                                  \
+    const int kHeight = ALIGNINT(benchmark_height_, YALIGN);                   \
+    const int kStrideB = ALIGNINT(kWidth * BPP_B, ALIGN);                      \
+    const int kStrideUV = SUBSAMPLE(kWidth, SUBSAMP_X);                        \
+    const int kSizeUV = kStrideUV * SUBSAMPLE(kHeight, SUBSAMP_Y);             \
+    align_buffer_page_end(src_y, kWidth* kHeight + OFF);                       \
+    align_buffer_page_end(src_u, kSizeUV + OFF);                               \
+    align_buffer_page_end(src_v, kSizeUV + OFF);                               \
+    align_buffer_page_end(dst_argb_c, kStrideB* kHeight + OFF);                \
+    align_buffer_page_end(dst_argb_opt, kStrideB* kHeight + OFF);              \
+    for (int i = 0; i < kWidth * kHeight; ++i) {                               \
+      src_y[i + OFF] = (fastrand() & 0xff);                                    \
+    }                                                                          \
+    for (int i = 0; i < kSizeUV; ++i) {                                        \
+      src_u[i + OFF] = (fastrand() & 0xff);                                    \
+      src_v[i + OFF] = (fastrand() & 0xff);                                    \
+    }                                                                          \
+    memset(dst_argb_c + OFF, 1, kStrideB * kHeight);                           \
+    memset(dst_argb_opt + OFF, 101, kStrideB * kHeight);                       \
+    MaskCpuFlags(disable_cpu_flags_);                                          \
+    FMT_PLANAR##To##FMT_B##Dither(src_y + OFF, kWidth, src_u + OFF, kStrideUV, \
+                                  src_v + OFF, kStrideUV, dst_argb_c + OFF,    \
+                                  kStrideB, NULL, kWidth, NEG kHeight);        \
+    MaskCpuFlags(benchmark_cpu_info_);                                         \
+    for (int i = 0; i < benchmark_iterations_; ++i) {                          \
+      FMT_PLANAR##To##FMT_B##Dither(                                           \
+          src_y + OFF, kWidth, src_u + OFF, kStrideUV, src_v + OFF, kStrideUV, \
+          dst_argb_opt + OFF, kStrideB, NULL, kWidth, NEG kHeight);            \
+    }                                                                          \
+    /* Convert to ARGB so 565 is expanded to bytes that can be compared. */    \
+    align_buffer_page_end(dst_argb32_c, kWidth* BPP_C* kHeight);               \
+    align_buffer_page_end(dst_argb32_opt, kWidth* BPP_C* kHeight);             \
+    memset(dst_argb32_c, 2, kWidth* BPP_C* kHeight);                           \
+    memset(dst_argb32_opt, 102, kWidth* BPP_C* kHeight);                       \
+    FMT_B##To##FMT_C(dst_argb_c + OFF, kStrideB, dst_argb32_c, kWidth * BPP_C, \
+                     kWidth, kHeight);                                         \
+    FMT_B##To##FMT_C(dst_argb_opt + OFF, kStrideB, dst_argb32_opt,             \
+                     kWidth * BPP_C, kWidth, kHeight);                         \
+    for (int i = 0; i < kWidth * BPP_C * kHeight; ++i) {                       \
+      EXPECT_EQ(dst_argb32_c[i], dst_argb32_opt[i]);                           \
+    }                                                                          \
+    free_aligned_buffer_page_end(src_y);                                       \
+    free_aligned_buffer_page_end(src_u);                                       \
+    free_aligned_buffer_page_end(src_v);                                       \
+    free_aligned_buffer_page_end(dst_argb_c);                                  \
+    free_aligned_buffer_page_end(dst_argb_opt);                                \
+    free_aligned_buffer_page_end(dst_argb32_c);                                \
+    free_aligned_buffer_page_end(dst_argb32_opt);                              \
+  }
+
+#define TESTPLANARTOBD(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN, \
+                       YALIGN, FMT_C, BPP_C)                                  \
+  TESTPLANARTOBID(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN,      \
+                  YALIGN, benchmark_width_ + 1, _Any, +, 0, FMT_C, BPP_C)     \
+  TESTPLANARTOBID(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN,      \
+                  YALIGN, benchmark_width_, _Unaligned, +, 2, FMT_C, BPP_C)   \
+  TESTPLANARTOBID(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN,      \
+                  YALIGN, benchmark_width_, _Invert, -, 0, FMT_C, BPP_C)      \
+  TESTPLANARTOBID(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN,      \
+                  YALIGN, benchmark_width_, _Opt, +, 0, FMT_C, BPP_C)
+
+#ifdef LITTLE_ENDIAN_ONLY_TEST
+TESTPLANARTOBD(I420, 2, 2, RGB565, 2, 2, 1, ARGB, 4)
+#endif
+
+#define TESTPTOB(NAME, UYVYTOI420, UYVYTONV12)                                \
+  TEST_F(LibYUVConvertTest, NAME) {                                           \
+    const int kWidth = benchmark_width_;                                      \
+    const int kHeight = benchmark_height_;                                    \
+                                                                              \
+    align_buffer_page_end(orig_uyvy, 4 * SUBSAMPLE(kWidth, 2) * kHeight);     \
+    align_buffer_page_end(orig_y, kWidth* kHeight);                           \
+    align_buffer_page_end(orig_u,                                             \
+                          SUBSAMPLE(kWidth, 2) * SUBSAMPLE(kHeight, 2));      \
+    align_buffer_page_end(orig_v,                                             \
+                          SUBSAMPLE(kWidth, 2) * SUBSAMPLE(kHeight, 2));      \
+                                                                              \
+    align_buffer_page_end(dst_y_orig, kWidth* kHeight);                       \
+    align_buffer_page_end(dst_uv_orig,                                        \
+                          2 * SUBSAMPLE(kWidth, 2) * SUBSAMPLE(kHeight, 2));  \
+                                                                              \
+    align_buffer_page_end(dst_y, kWidth* kHeight);                            \
+    align_buffer_page_end(dst_uv,                                             \
+                          2 * SUBSAMPLE(kWidth, 2) * SUBSAMPLE(kHeight, 2));  \
+                                                                              \
+    MemRandomize(orig_uyvy, 4 * SUBSAMPLE(kWidth, 2) * kHeight);              \
+                                                                              \
+    /* Convert UYVY to NV12 in 2 steps for reference */                       \
+    libyuv::UYVYTOI420(orig_uyvy, 4 * SUBSAMPLE(kWidth, 2), orig_y, kWidth,   \
+                       orig_u, SUBSAMPLE(kWidth, 2), orig_v,                  \
+                       SUBSAMPLE(kWidth, 2), kWidth, kHeight);                \
+    libyuv::I420ToNV12(orig_y, kWidth, orig_u, SUBSAMPLE(kWidth, 2), orig_v,  \
+                       SUBSAMPLE(kWidth, 2), dst_y_orig, kWidth, dst_uv_orig, \
+                       2 * SUBSAMPLE(kWidth, 2), kWidth, kHeight);            \
+                                                                              \
+    /* Convert to NV12 */                                                     \
+    for (int i = 0; i < benchmark_iterations_; ++i) {                         \
+      libyuv::UYVYTONV12(orig_uyvy, 4 * SUBSAMPLE(kWidth, 2), dst_y, kWidth,  \
+                         dst_uv, 2 * SUBSAMPLE(kWidth, 2), kWidth, kHeight);  \
+    }                                                                         \
+                                                                              \
+    for (int i = 0; i < kWidth * kHeight; ++i) {                              \
+      EXPECT_EQ(orig_y[i], dst_y[i]);                                         \
+    }                                                                         \
+    for (int i = 0; i < kWidth * kHeight; ++i) {                              \
+      EXPECT_EQ(dst_y_orig[i], dst_y[i]);                                     \
+    }                                                                         \
+    for (int i = 0; i < 2 * SUBSAMPLE(kWidth, 2) * SUBSAMPLE(kHeight, 2);     \
+         ++i) {                                                               \
+      EXPECT_EQ(dst_uv_orig[i], dst_uv[i]);                                   \
+    }                                                                         \
+                                                                              \
+    free_aligned_buffer_page_end(orig_uyvy);                                  \
+    free_aligned_buffer_page_end(orig_y);                                     \
+    free_aligned_buffer_page_end(orig_u);                                     \
+    free_aligned_buffer_page_end(orig_v);                                     \
+    free_aligned_buffer_page_end(dst_y_orig);                                 \
+    free_aligned_buffer_page_end(dst_uv_orig);                                \
+    free_aligned_buffer_page_end(dst_y);                                      \
+    free_aligned_buffer_page_end(dst_uv);                                     \
+  }
+
+TESTPTOB(TestYUY2ToNV12, YUY2ToI420, YUY2ToNV12)
+TESTPTOB(TestUYVYToNV12, UYVYToI420, UYVYToNV12)
+
+// Transitive test.  A to B to C is same as A to C.
+// Benchmarks A To B to C for comparison to 1 step, benchmarked elsewhere.
+#define TESTPLANARTOEI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, SUB_B, BPP_B, \
+                       W1280, N, NEG, OFF, FMT_C, BPP_C)                      \
+  TEST_F(LibYUVConvertTest, FMT_PLANAR##To##FMT_B##To##FMT_C##N) {            \
+    const int kWidth = W1280;                                                 \
+    const int kHeight = benchmark_height_;                                    \
+    const int kStrideB = SUBSAMPLE(kWidth, SUB_B) * BPP_B;                    \
+    const int kStrideUV = SUBSAMPLE(kWidth, SUBSAMP_X);                       \
+    const int kSizeUV = kStrideUV * SUBSAMPLE(kHeight, SUBSAMP_Y);            \
+    align_buffer_page_end(src_y, kWidth* kHeight + OFF);                      \
+    align_buffer_page_end(src_u, kSizeUV + OFF);                              \
+    align_buffer_page_end(src_v, kSizeUV + OFF);                              \
+    align_buffer_page_end(dst_argb_b, kStrideB* kHeight + OFF);               \
+    for (int i = 0; i < kWidth * kHeight; ++i) {                              \
+      src_y[i + OFF] = (fastrand() & 0xff);                                   \
+    }                                                                         \
+    for (int i = 0; i < kSizeUV; ++i) {                                       \
+      src_u[i + OFF] = (fastrand() & 0xff);                                   \
+      src_v[i + OFF] = (fastrand() & 0xff);                                   \
+    }                                                                         \
+    memset(dst_argb_b + OFF, 1, kStrideB * kHeight);                          \
+    FMT_PLANAR##To##FMT_B(src_y + OFF, kWidth, src_u + OFF, kStrideUV,        \
+                          src_v + OFF, kStrideUV, dst_argb_b + OFF, kStrideB, \
+                          kWidth, NEG kHeight);                               \
+    /* Convert to a 3rd format in 1 step and 2 steps and compare  */          \
+    const int kStrideC = kWidth * BPP_C;                                      \
+    align_buffer_page_end(dst_argb_c, kStrideC* kHeight + OFF);               \
+    align_buffer_page_end(dst_argb_bc, kStrideC* kHeight + OFF);              \
+    memset(dst_argb_c + OFF, 2, kStrideC * kHeight);                          \
+    memset(dst_argb_bc + OFF, 3, kStrideC * kHeight);                         \
+    for (int i = 0; i < benchmark_iterations_; ++i) {                         \
+      FMT_PLANAR##To##FMT_C(src_y + OFF, kWidth, src_u + OFF, kStrideUV,      \
+                            src_v + OFF, kStrideUV, dst_argb_c + OFF,         \
+                            kStrideC, kWidth, NEG kHeight);                   \
+      /* Convert B to C */                                                    \
+      FMT_B##To##FMT_C(dst_argb_b + OFF, kStrideB, dst_argb_bc + OFF,         \
+                       kStrideC, kWidth, kHeight);                            \
+    }                                                                         \
+    for (int i = 0; i < kStrideC * kHeight; ++i) {                            \
+      EXPECT_EQ(dst_argb_c[i + OFF], dst_argb_bc[i + OFF]);                   \
+    }                                                                         \
+    free_aligned_buffer_page_end(src_y);                                      \
+    free_aligned_buffer_page_end(src_u);                                      \
+    free_aligned_buffer_page_end(src_v);                                      \
+    free_aligned_buffer_page_end(dst_argb_b);                                 \
+    free_aligned_buffer_page_end(dst_argb_c);                                 \
+    free_aligned_buffer_page_end(dst_argb_bc);                                \
+  }
+
+#if defined(ENABLE_FULL_TESTS)
+#define TESTPLANARTOE(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, SUB_B, BPP_B, \
+                      FMT_C, BPP_C)                                          \
+  TESTPLANARTOEI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, SUB_B, BPP_B,      \
+                 benchmark_width_ + 1, _Any, +, 0, FMT_C, BPP_C)             \
+  TESTPLANARTOEI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, SUB_B, BPP_B,      \
+                 benchmark_width_, _Unaligned, +, 2, FMT_C, BPP_C)           \
+  TESTPLANARTOEI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, SUB_B, BPP_B,      \
+                 benchmark_width_, _Invert, -, 0, FMT_C, BPP_C)              \
+  TESTPLANARTOEI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, SUB_B, BPP_B,      \
+                 benchmark_width_, _Opt, +, 0, FMT_C, BPP_C)
+#else
+#define TESTPLANARTOE(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, SUB_B, BPP_B, \
+                      FMT_C, BPP_C)                                          \
+  TESTPLANARTOEI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, SUB_B, BPP_B,      \
+                 benchmark_width_, _Opt, +, 0, FMT_C, BPP_C)
+#endif
+
+#if defined(ENABLE_FULL_TESTS)
+TESTPLANARTOE(I420, 2, 2, ABGR, 1, 4, ARGB, 4)
+TESTPLANARTOE(I420, 2, 2, ARGB, 1, 4, ABGR, 4)
+TESTPLANARTOE(I420, 2, 2, ARGB, 1, 4, RAW, 3)
+TESTPLANARTOE(I420, 2, 2, ARGB, 1, 4, RGB24, 3)
+TESTPLANARTOE(I420, 2, 2, BGRA, 1, 4, ARGB, 4)
+TESTPLANARTOE(I420, 2, 2, RAW, 1, 3, ARGB, 4)
+TESTPLANARTOE(I420, 2, 2, RAW, 1, 3, RGB24, 3)
+TESTPLANARTOE(I420, 2, 2, RGB24, 1, 3, ARGB, 4)
+TESTPLANARTOE(I420, 2, 2, RGB24, 1, 3, RAW, 3)
+TESTPLANARTOE(I420, 2, 2, RGBA, 1, 4, ARGB, 4)
+TESTPLANARTOE(H420, 2, 2, ABGR, 1, 4, ARGB, 4)
+TESTPLANARTOE(H420, 2, 2, ARGB, 1, 4, ABGR, 4)
+TESTPLANARTOE(H420, 2, 2, ARGB, 1, 4, RAW, 3)
+TESTPLANARTOE(H420, 2, 2, ARGB, 1, 4, RGB24, 3)
+TESTPLANARTOE(H420, 2, 2, RAW, 1, 3, ARGB, 4)
+TESTPLANARTOE(H420, 2, 2, RAW, 1, 3, RGB24, 3)
+TESTPLANARTOE(H420, 2, 2, RGB24, 1, 3, ARGB, 4)
+TESTPLANARTOE(H420, 2, 2, RGB24, 1, 3, RAW, 3)
+TESTPLANARTOE(J420, 2, 2, ABGR, 1, 4, ARGB, 4)
+TESTPLANARTOE(J420, 2, 2, ARGB, 1, 4, ARGB, 4)
+TESTPLANARTOE(U420, 2, 2, ABGR, 1, 4, ARGB, 4)
+TESTPLANARTOE(U420, 2, 2, ARGB, 1, 4, ARGB, 4)
+#ifdef LITTLE_ENDIAN_ONLY_TEST
+TESTPLANARTOE(I420, 2, 2, ARGB, 1, 4, RGB565, 2)
+TESTPLANARTOE(I420, 2, 2, ARGB, 1, 4, ARGB1555, 2)
+TESTPLANARTOE(I420, 2, 2, ARGB, 1, 4, ARGB4444, 2)
+TESTPLANARTOE(I422, 2, 1, ARGB, 1, 4, RGB565, 2)
+#endif
+TESTPLANARTOE(I422, 2, 1, ARGB, 1, 4, ABGR, 4)
+TESTPLANARTOE(I422, 2, 1, ABGR, 1, 4, ARGB, 4)
+TESTPLANARTOE(J422, 2, 1, ARGB, 1, 4, ARGB, 4)
+TESTPLANARTOE(J422, 2, 1, ABGR, 1, 4, ARGB, 4)
+TESTPLANARTOE(H422, 2, 1, ARGB, 1, 4, ARGB, 4)
+TESTPLANARTOE(H422, 2, 1, ABGR, 1, 4, ARGB, 4)
+TESTPLANARTOE(U422, 2, 1, ARGB, 1, 4, ARGB, 4)
+TESTPLANARTOE(U422, 2, 1, ABGR, 1, 4, ARGB, 4)
+TESTPLANARTOE(V422, 2, 1, ARGB, 1, 4, ARGB, 4)
+TESTPLANARTOE(V422, 2, 1, ABGR, 1, 4, ARGB, 4)
+TESTPLANARTOE(I422, 2, 1, BGRA, 1, 4, ARGB, 4)
+TESTPLANARTOE(I422, 2, 1, RGBA, 1, 4, ARGB, 4)
+TESTPLANARTOE(I444, 1, 1, ARGB, 1, 4, ABGR, 4)
+TESTPLANARTOE(I444, 1, 1, ABGR, 1, 4, ARGB, 4)
+TESTPLANARTOE(J444, 1, 1, ARGB, 1, 4, ARGB, 4)
+TESTPLANARTOE(J444, 1, 1, ABGR, 1, 4, ARGB, 4)
+TESTPLANARTOE(H444, 1, 1, ARGB, 1, 4, ARGB, 4)
+TESTPLANARTOE(H444, 1, 1, ABGR, 1, 4, ARGB, 4)
+TESTPLANARTOE(U444, 1, 1, ARGB, 1, 4, ARGB, 4)
+TESTPLANARTOE(U444, 1, 1, ABGR, 1, 4, ARGB, 4)
+TESTPLANARTOE(V444, 1, 1, ARGB, 1, 4, ARGB, 4)
+TESTPLANARTOE(V444, 1, 1, ABGR, 1, 4, ARGB, 4)
+TESTPLANARTOE(I420, 2, 2, YUY2, 2, 4, ARGB, 4)
+TESTPLANARTOE(I420, 2, 2, UYVY, 2, 4, ARGB, 4)
+TESTPLANARTOE(I422, 2, 1, YUY2, 2, 4, ARGB, 4)
+TESTPLANARTOE(I422, 2, 1, UYVY, 2, 4, ARGB, 4)
+#else
+TESTPLANARTOE(I420, 2, 2, ABGR, 1, 4, ARGB, 4)
+TESTPLANARTOE(I420, 2, 2, ARGB, 1, 4, ARGB1555, 2)
+TESTPLANARTOE(I420, 2, 2, ARGB, 1, 4, ARGB4444, 2)
+TESTPLANARTOE(I420, 2, 2, ARGB, 1, 4, RAW, 3)
+TESTPLANARTOE(I420, 2, 2, ARGB, 1, 4, RGB24, 3)
+TESTPLANARTOE(I420, 2, 2, ARGB, 1, 4, RGB565, 2)
+TESTPLANARTOE(I420, 2, 2, BGRA, 1, 4, ARGB, 4)
+TESTPLANARTOE(I420, 2, 2, RAW, 1, 3, ARGB, 4)
+TESTPLANARTOE(I420, 2, 2, RAW, 1, 3, RGB24, 3)
+TESTPLANARTOE(I420, 2, 2, RGB24, 1, 3, ARGB, 4)
+TESTPLANARTOE(I420, 2, 2, RGB24, 1, 3, RAW, 3)
+TESTPLANARTOE(I420, 2, 2, RGBA, 1, 4, ARGB, 4)
+TESTPLANARTOE(I420, 2, 2, UYVY, 2, 4, ARGB, 4)
+TESTPLANARTOE(I420, 2, 2, YUY2, 2, 4, ARGB, 4)
+TESTPLANARTOE(I422, 2, 1, ABGR, 1, 4, ARGB, 4)
+TESTPLANARTOE(I422, 2, 1, ARGB, 1, 4, RGB565, 2)
+TESTPLANARTOE(I422, 2, 1, BGRA, 1, 4, ARGB, 4)
+TESTPLANARTOE(I422, 2, 1, RGBA, 1, 4, ARGB, 4)
+TESTPLANARTOE(I422, 2, 1, UYVY, 2, 4, ARGB, 4)
+TESTPLANARTOE(I422, 2, 1, YUY2, 2, 4, ARGB, 4)
+TESTPLANARTOE(I444, 1, 1, ABGR, 1, 4, ARGB, 4)
+#endif
+
+// Transitive test: Compare 1 step vs 2 step conversion for YUVA to ARGB.
+// Benchmark 2 step conversion for comparison to 1 step conversion.
+#define TESTQPLANARTOEI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, SUB_B, BPP_B, \
+                        W1280, N, NEG, OFF, FMT_C, BPP_C, ATTEN)               \
+  TEST_F(LibYUVConvertTest, FMT_PLANAR##To##FMT_B##To##FMT_C##N) {             \
+    const int kWidth = W1280;                                                  \
+    const int kHeight = benchmark_height_;                                     \
+    const int kStrideB = SUBSAMPLE(kWidth, SUB_B) * BPP_B;                     \
+    const int kSizeUV =                                                        \
+        SUBSAMPLE(kWidth, SUBSAMP_X) * SUBSAMPLE(kHeight, SUBSAMP_Y);          \
+    align_buffer_page_end(src_y, kWidth* kHeight + OFF);                       \
+    align_buffer_page_end(src_u, kSizeUV + OFF);                               \
+    align_buffer_page_end(src_v, kSizeUV + OFF);                               \
+    align_buffer_page_end(src_a, kWidth* kHeight + OFF);                       \
+    align_buffer_page_end(dst_argb_b, kStrideB* kHeight + OFF);                \
+    const int kStrideC = kWidth * BPP_C;                                       \
+    align_buffer_page_end(dst_argb_c, kStrideC* kHeight + OFF);                \
+    align_buffer_page_end(dst_argb_bc, kStrideC* kHeight + OFF);               \
+    memset(dst_argb_c + OFF, 2, kStrideC * kHeight);                           \
+    memset(dst_argb_b + OFF, 1, kStrideB * kHeight);                           \
+    memset(dst_argb_bc + OFF, 3, kStrideC * kHeight);                          \
+    for (int i = 0; i < kWidth * kHeight; ++i) {                               \
+      src_y[i + OFF] = (fastrand() & 0xff);                                    \
+      src_a[i + OFF] = (fastrand() & 0xff);                                    \
+    }                                                                          \
+    for (int i = 0; i < kSizeUV; ++i) {                                        \
+      src_u[i + OFF] = (fastrand() & 0xff);                                    \
+      src_v[i + OFF] = (fastrand() & 0xff);                                    \
+    }                                                                          \
+    for (int i = 0; i < benchmark_iterations_; ++i) {                          \
+      /* Convert A to B */                                                     \
+      FMT_PLANAR##To##FMT_B(                                                   \
+          src_y + OFF, kWidth, src_u + OFF, SUBSAMPLE(kWidth, SUBSAMP_X),      \
+          src_v + OFF, SUBSAMPLE(kWidth, SUBSAMP_X), src_a + OFF, kWidth,      \
+          dst_argb_b + OFF, kStrideB, kWidth, NEG kHeight, ATTEN);             \
+      /* Convert B to C */                                                     \
+      FMT_B##To##FMT_C(dst_argb_b + OFF, kStrideB, dst_argb_bc + OFF,          \
+                       kStrideC, kWidth, kHeight);                             \
+    }                                                                          \
+    /* Convert A to C */                                                       \
+    FMT_PLANAR##To##FMT_C(                                                     \
+        src_y + OFF, kWidth, src_u + OFF, SUBSAMPLE(kWidth, SUBSAMP_X),        \
+        src_v + OFF, SUBSAMPLE(kWidth, SUBSAMP_X), src_a + OFF, kWidth,        \
+        dst_argb_c + OFF, kStrideC, kWidth, NEG kHeight, ATTEN);               \
+    for (int i = 0; i < kStrideC * kHeight; ++i) {                             \
+      EXPECT_EQ(dst_argb_c[i + OFF], dst_argb_bc[i + OFF]);                    \
+    }                                                                          \
+    free_aligned_buffer_page_end(src_y);                                       \
+    free_aligned_buffer_page_end(src_u);                                       \
+    free_aligned_buffer_page_end(src_v);                                       \
+    free_aligned_buffer_page_end(src_a);                                       \
+    free_aligned_buffer_page_end(dst_argb_b);                                  \
+    free_aligned_buffer_page_end(dst_argb_c);                                  \
+    free_aligned_buffer_page_end(dst_argb_bc);                                 \
+  }
+
+#if defined(ENABLE_FULL_TESTS)
+#define TESTQPLANARTOE(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, SUB_B, BPP_B, \
+                       FMT_C, BPP_C)                                          \
+  TESTQPLANARTOEI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, SUB_B, BPP_B,      \
+                  benchmark_width_ + 1, _Any, +, 0, FMT_C, BPP_C, 0)          \
+  TESTQPLANARTOEI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, SUB_B, BPP_B,      \
+                  benchmark_width_, _Unaligned, +, 2, FMT_C, BPP_C, 0)        \
+  TESTQPLANARTOEI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, SUB_B, BPP_B,      \
+                  benchmark_width_, _Invert, -, 0, FMT_C, BPP_C, 0)           \
+  TESTQPLANARTOEI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, SUB_B, BPP_B,      \
+                  benchmark_width_, _Opt, +, 0, FMT_C, BPP_C, 0)              \
+  TESTQPLANARTOEI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, SUB_B, BPP_B,      \
+                  benchmark_width_, _Premult, +, 0, FMT_C, BPP_C, 1)
+#else
+#define TESTQPLANARTOE(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, SUB_B, BPP_B, \
+                       FMT_C, BPP_C)                                          \
+  TESTQPLANARTOEI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, SUB_B, BPP_B,      \
+                  benchmark_width_, _Opt, +, 0, FMT_C, BPP_C, 0)
+#endif
+
+#if defined(ENABLE_FULL_TESTS)
+TESTQPLANARTOE(I420Alpha, 2, 2, ARGB, 1, 4, ABGR, 4)
+TESTQPLANARTOE(I420Alpha, 2, 2, ABGR, 1, 4, ARGB, 4)
+TESTQPLANARTOE(J420Alpha, 2, 2, ARGB, 1, 4, ABGR, 4)
+TESTQPLANARTOE(J420Alpha, 2, 2, ABGR, 1, 4, ARGB, 4)
+TESTQPLANARTOE(H420Alpha, 2, 2, ARGB, 1, 4, ABGR, 4)
+TESTQPLANARTOE(H420Alpha, 2, 2, ABGR, 1, 4, ARGB, 4)
+TESTQPLANARTOE(F420Alpha, 2, 2, ARGB, 1, 4, ABGR, 4)
+TESTQPLANARTOE(F420Alpha, 2, 2, ABGR, 1, 4, ARGB, 4)
+TESTQPLANARTOE(U420Alpha, 2, 2, ARGB, 1, 4, ABGR, 4)
+TESTQPLANARTOE(U420Alpha, 2, 2, ABGR, 1, 4, ARGB, 4)
+TESTQPLANARTOE(V420Alpha, 2, 2, ARGB, 1, 4, ABGR, 4)
+TESTQPLANARTOE(V420Alpha, 2, 2, ABGR, 1, 4, ARGB, 4)
+TESTQPLANARTOE(I422Alpha, 2, 1, ARGB, 1, 4, ABGR, 4)
+TESTQPLANARTOE(I422Alpha, 2, 1, ABGR, 1, 4, ARGB, 4)
+TESTQPLANARTOE(J422Alpha, 2, 1, ARGB, 1, 4, ABGR, 4)
+TESTQPLANARTOE(J422Alpha, 2, 1, ABGR, 1, 4, ARGB, 4)
+TESTQPLANARTOE(F422Alpha, 2, 1, ARGB, 1, 4, ABGR, 4)
+TESTQPLANARTOE(F422Alpha, 2, 1, ABGR, 1, 4, ARGB, 4)
+TESTQPLANARTOE(H422Alpha, 2, 1, ARGB, 1, 4, ABGR, 4)
+TESTQPLANARTOE(H422Alpha, 2, 1, ABGR, 1, 4, ARGB, 4)
+TESTQPLANARTOE(U422Alpha, 2, 1, ARGB, 1, 4, ABGR, 4)
+TESTQPLANARTOE(U422Alpha, 2, 1, ABGR, 1, 4, ARGB, 4)
+TESTQPLANARTOE(V422Alpha, 2, 1, ARGB, 1, 4, ABGR, 4)
+TESTQPLANARTOE(V422Alpha, 2, 1, ABGR, 1, 4, ARGB, 4)
+TESTQPLANARTOE(I444Alpha, 1, 1, ARGB, 1, 4, ABGR, 4)
+TESTQPLANARTOE(I444Alpha, 1, 1, ABGR, 1, 4, ARGB, 4)
+TESTQPLANARTOE(J444Alpha, 1, 1, ARGB, 1, 4, ABGR, 4)
+TESTQPLANARTOE(J444Alpha, 1, 1, ABGR, 1, 4, ARGB, 4)
+TESTQPLANARTOE(H444Alpha, 1, 1, ARGB, 1, 4, ABGR, 4)
+TESTQPLANARTOE(H444Alpha, 1, 1, ABGR, 1, 4, ARGB, 4)
+TESTQPLANARTOE(U444Alpha, 1, 1, ARGB, 1, 4, ABGR, 4)
+TESTQPLANARTOE(U444Alpha, 1, 1, ABGR, 1, 4, ARGB, 4)
+TESTQPLANARTOE(V444Alpha, 1, 1, ARGB, 1, 4, ABGR, 4)
+TESTQPLANARTOE(V444Alpha, 1, 1, ABGR, 1, 4, ARGB, 4)
+#else
+TESTQPLANARTOE(I420Alpha, 2, 2, ABGR, 1, 4, ARGB, 4)
+TESTQPLANARTOE(I422Alpha, 2, 1, ABGR, 1, 4, ARGB, 4)
+TESTQPLANARTOE(I444Alpha, 1, 1, ABGR, 1, 4, ARGB, 4)
+#endif
+
+#define TESTPLANETOEI(FMT_A, SUB_A, BPP_A, FMT_B, SUB_B, BPP_B, W1280, N, NEG, \
+                      OFF, FMT_C, BPP_C)                                       \
+  TEST_F(LibYUVConvertTest, FMT_A##To##FMT_B##To##FMT_C##N) {                  \
+    const int kWidth = W1280;                                                  \
+    const int kHeight = benchmark_height_;                                     \
+    const int kStrideA = SUBSAMPLE(kWidth, SUB_A) * BPP_A;                     \
+    const int kStrideB = SUBSAMPLE(kWidth, SUB_B) * BPP_B;                     \
+    align_buffer_page_end(src_argb_a, kStrideA* kHeight + OFF);                \
+    align_buffer_page_end(dst_argb_b, kStrideB* kHeight + OFF);                \
+    MemRandomize(src_argb_a + OFF, kStrideA * kHeight);                        \
+    memset(dst_argb_b + OFF, 1, kStrideB * kHeight);                           \
+    FMT_A##To##FMT_B(src_argb_a + OFF, kStrideA, dst_argb_b + OFF, kStrideB,   \
+                     kWidth, NEG kHeight);                                     \
+    /* Convert to a 3rd format in 1 step and 2 steps and compare  */           \
+    const int kStrideC = kWidth * BPP_C;                                       \
+    align_buffer_page_end(dst_argb_c, kStrideC* kHeight + OFF);                \
+    align_buffer_page_end(dst_argb_bc, kStrideC* kHeight + OFF);               \
+    memset(dst_argb_c + OFF, 2, kStrideC * kHeight);                           \
+    memset(dst_argb_bc + OFF, 3, kStrideC * kHeight);                          \
+    for (int i = 0; i < benchmark_iterations_; ++i) {                          \
+      FMT_A##To##FMT_C(src_argb_a + OFF, kStrideA, dst_argb_c + OFF, kStrideC, \
+                       kWidth, NEG kHeight);                                   \
+      /* Convert B to C */                                                     \
+      FMT_B##To##FMT_C(dst_argb_b + OFF, kStrideB, dst_argb_bc + OFF,          \
+                       kStrideC, kWidth, kHeight);                             \
+    }                                                                          \
+    for (int i = 0; i < kStrideC * kHeight; i += 4) {                          \
+      EXPECT_EQ(dst_argb_c[i + OFF + 0], dst_argb_bc[i + OFF + 0]);            \
+      EXPECT_EQ(dst_argb_c[i + OFF + 1], dst_argb_bc[i + OFF + 1]);            \
+      EXPECT_EQ(dst_argb_c[i + OFF + 2], dst_argb_bc[i + OFF + 2]);            \
+      EXPECT_NEAR(dst_argb_c[i + OFF + 3], dst_argb_bc[i + OFF + 3], 64);      \
+    }                                                                          \
+    free_aligned_buffer_page_end(src_argb_a);                                  \
+    free_aligned_buffer_page_end(dst_argb_b);                                  \
+    free_aligned_buffer_page_end(dst_argb_c);                                  \
+    free_aligned_buffer_page_end(dst_argb_bc);                                 \
+  }
+
+#define TESTPLANETOE(FMT_A, SUB_A, BPP_A, FMT_B, SUB_B, BPP_B, FMT_C, BPP_C) \
+  TESTPLANETOEI(FMT_A, SUB_A, BPP_A, FMT_B, SUB_B, BPP_B,                    \
+                benchmark_width_ + 1, _Any, +, 0, FMT_C, BPP_C)              \
+  TESTPLANETOEI(FMT_A, SUB_A, BPP_A, FMT_B, SUB_B, BPP_B, benchmark_width_,  \
+                _Unaligned, +, 4, FMT_C, BPP_C)                              \
+  TESTPLANETOEI(FMT_A, SUB_A, BPP_A, FMT_B, SUB_B, BPP_B, benchmark_width_,  \
+                _Invert, -, 0, FMT_C, BPP_C)                                 \
+  TESTPLANETOEI(FMT_A, SUB_A, BPP_A, FMT_B, SUB_B, BPP_B, benchmark_width_,  \
+                _Opt, +, 0, FMT_C, BPP_C)
+
+// Caveat: Destination needs to be 4 bytes
+#ifdef LITTLE_ENDIAN_ONLY_TEST
+TESTPLANETOE(ARGB, 1, 4, AR30, 1, 4, ARGB, 4)
+TESTPLANETOE(ABGR, 1, 4, AR30, 1, 4, ABGR, 4)
+TESTPLANETOE(AR30, 1, 4, ARGB, 1, 4, ABGR, 4)
+TESTPLANETOE(AR30, 1, 4, ABGR, 1, 4, ARGB, 4)
+TESTPLANETOE(ARGB, 1, 4, AB30, 1, 4, ARGB, 4)
+TESTPLANETOE(ABGR, 1, 4, AB30, 1, 4, ABGR, 4)
+TESTPLANETOE(AB30, 1, 4, ARGB, 1, 4, ABGR, 4)
+TESTPLANETOE(AB30, 1, 4, ABGR, 1, 4, ARGB, 4)
+#endif
+
+TEST_F(LibYUVConvertTest, RotateWithARGBSource) {
+  // 2x2 frames
+  uint32_t src[4];
+  uint32_t dst[4];
+  // some random input
+  src[0] = 0x11000000;
+  src[1] = 0x00450000;
+  src[2] = 0x00009f00;
+  src[3] = 0x000000ff;
+  // zeros on destination
+  dst[0] = 0x00000000;
+  dst[1] = 0x00000000;
+  dst[2] = 0x00000000;
+  dst[3] = 0x00000000;
+
+  int r = ConvertToARGB(reinterpret_cast<uint8_t*>(src),
+                        16,  // input size
+                        reinterpret_cast<uint8_t*>(dst),
+                        8,  // destination stride
+                        0,  // crop_x
+                        0,  // crop_y
+                        2,  // width
+                        2,  // height
+                        2,  // crop width
+                        2,  // crop height
+                        kRotate90, FOURCC_ARGB);
+
+  EXPECT_EQ(r, 0);
+  // 90 degrees rotation, no conversion
+  EXPECT_EQ(dst[0], src[2]);
+  EXPECT_EQ(dst[1], src[0]);
+  EXPECT_EQ(dst[2], src[3]);
+  EXPECT_EQ(dst[3], src[1]);
+}
+
+#ifdef HAS_ARGBTOAR30ROW_AVX2
+TEST_F(LibYUVConvertTest, ARGBToAR30Row_Opt) {
+  // ARGBToAR30Row_AVX2 expects a multiple of 8 pixels.
+  const int kPixels = (benchmark_width_ * benchmark_height_ + 7) & ~7;
+  align_buffer_page_end(src, kPixels * 4);
+  align_buffer_page_end(dst_opt, kPixels * 4);
+  align_buffer_page_end(dst_c, kPixels * 4);
+  MemRandomize(src, kPixels * 4);
+  memset(dst_opt, 0, kPixels * 4);
+  memset(dst_c, 1, kPixels * 4);
+
+  ARGBToAR30Row_C(src, dst_c, kPixels);
+
+  int has_avx2 = TestCpuFlag(kCpuHasAVX2);
+  int has_ssse3 = TestCpuFlag(kCpuHasSSSE3);
+  for (int i = 0; i < benchmark_iterations_; ++i) {
+    if (has_avx2) {
+      ARGBToAR30Row_AVX2(src, dst_opt, kPixels);
+    } else if (has_ssse3) {
+      ARGBToAR30Row_SSSE3(src, dst_opt, kPixels);
+    } else {
+      ARGBToAR30Row_C(src, dst_opt, kPixels);
+    }
+  }
+  for (int i = 0; i < kPixels * 4; ++i) {
+    EXPECT_EQ(dst_opt[i], dst_c[i]);
+  }
+
+  free_aligned_buffer_page_end(src);
+  free_aligned_buffer_page_end(dst_opt);
+  free_aligned_buffer_page_end(dst_c);
+}
+#endif  // HAS_ARGBTOAR30ROW_AVX2
+
+#ifdef HAS_ABGRTOAR30ROW_AVX2
+TEST_F(LibYUVConvertTest, ABGRToAR30Row_Opt) {
+  // ABGRToAR30Row_AVX2 expects a multiple of 8 pixels.
+  const int kPixels = (benchmark_width_ * benchmark_height_ + 7) & ~7;
+  align_buffer_page_end(src, kPixels * 4);
+  align_buffer_page_end(dst_opt, kPixels * 4);
+  align_buffer_page_end(dst_c, kPixels * 4);
+  MemRandomize(src, kPixels * 4);
+  memset(dst_opt, 0, kPixels * 4);
+  memset(dst_c, 1, kPixels * 4);
+
+  ABGRToAR30Row_C(src, dst_c, kPixels);
+
+  int has_avx2 = TestCpuFlag(kCpuHasAVX2);
+  int has_ssse3 = TestCpuFlag(kCpuHasSSSE3);
+  for (int i = 0; i < benchmark_iterations_; ++i) {
+    if (has_avx2) {
+      ABGRToAR30Row_AVX2(src, dst_opt, kPixels);
+    } else if (has_ssse3) {
+      ABGRToAR30Row_SSSE3(src, dst_opt, kPixels);
+    } else {
+      ABGRToAR30Row_C(src, dst_opt, kPixels);
+    }
+  }
+  for (int i = 0; i < kPixels * 4; ++i) {
+    EXPECT_EQ(dst_opt[i], dst_c[i]);
+  }
+
+  free_aligned_buffer_page_end(src);
+  free_aligned_buffer_page_end(dst_opt);
+  free_aligned_buffer_page_end(dst_c);
+}
+#endif  // HAS_ABGRTOAR30ROW_AVX2
+
+// Provide matrix wrappers for 12 bit YUV
+#define I012ToARGB(a, b, c, d, e, f, g, h, i, j) \
+  I012ToARGBMatrix(a, b, c, d, e, f, g, h, &kYuvI601Constants, i, j)
+#define I012ToAR30(a, b, c, d, e, f, g, h, i, j) \
+  I012ToAR30Matrix(a, b, c, d, e, f, g, h, &kYuvI601Constants, i, j)
+
+#define I410ToARGB(a, b, c, d, e, f, g, h, i, j) \
+  I410ToARGBMatrix(a, b, c, d, e, f, g, h, &kYuvI601Constants, i, j)
+#define I410ToABGR(a, b, c, d, e, f, g, h, i, j) \
+  I410ToABGRMatrix(a, b, c, d, e, f, g, h, &kYuvI601Constants, i, j)
+#define H410ToARGB(a, b, c, d, e, f, g, h, i, j) \
+  I410ToARGBMatrix(a, b, c, d, e, f, g, h, &kYuvH709Constants, i, j)
+#define H410ToABGR(a, b, c, d, e, f, g, h, i, j) \
+  I410ToABGRMatrix(a, b, c, d, e, f, g, h, &kYuvH709Constants, i, j)
+#define U410ToARGB(a, b, c, d, e, f, g, h, i, j) \
+  I410ToARGBMatrix(a, b, c, d, e, f, g, h, &kYuv2020Constants, i, j)
+#define U410ToABGR(a, b, c, d, e, f, g, h, i, j) \
+  I410ToABGRMatrix(a, b, c, d, e, f, g, h, &kYuv2020Constants, i, j)
+#define I410ToAR30(a, b, c, d, e, f, g, h, i, j) \
+  I410ToAR30Matrix(a, b, c, d, e, f, g, h, &kYuvI601Constants, i, j)
+#define I410ToAB30(a, b, c, d, e, f, g, h, i, j) \
+  I410ToAB30Matrix(a, b, c, d, e, f, g, h, &kYuvI601Constants, i, j)
+#define H410ToAR30(a, b, c, d, e, f, g, h, i, j) \
+  I410ToAR30Matrix(a, b, c, d, e, f, g, h, &kYuvH709Constants, i, j)
+#define H410ToAB30(a, b, c, d, e, f, g, h, i, j) \
+  I410ToAB30Matrix(a, b, c, d, e, f, g, h, &kYuvH709Constants, i, j)
+#define U410ToAR30(a, b, c, d, e, f, g, h, i, j) \
+  I410ToAR30Matrix(a, b, c, d, e, f, g, h, &kYuv2020Constants, i, j)
+#define U410ToAB30(a, b, c, d, e, f, g, h, i, j) \
+  I410ToAB30Matrix(a, b, c, d, e, f, g, h, &kYuv2020Constants, i, j)
+
+#define I010ToARGBFilter(a, b, c, d, e, f, g, h, i, j)                     \
+  I010ToARGBMatrixFilter(a, b, c, d, e, f, g, h, &kYuvI601Constants, i, j, \
+                         kFilterBilinear)
+#define I010ToAR30Filter(a, b, c, d, e, f, g, h, i, j)                     \
+  I010ToAR30MatrixFilter(a, b, c, d, e, f, g, h, &kYuvI601Constants, i, j, \
+                         kFilterBilinear)
+#define I210ToARGBFilter(a, b, c, d, e, f, g, h, i, j)                     \
+  I210ToARGBMatrixFilter(a, b, c, d, e, f, g, h, &kYuvI601Constants, i, j, \
+                         kFilterBilinear)
+#define I210ToAR30Filter(a, b, c, d, e, f, g, h, i, j)                     \
+  I210ToAR30MatrixFilter(a, b, c, d, e, f, g, h, &kYuvI601Constants, i, j, \
+                         kFilterBilinear)
+
+// TODO(fbarchard): Fix clamping issue affected by U channel.
+#define TESTPLANAR16TOBI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_MASK, FMT_B,   \
+                         BPP_B, ALIGN, YALIGN, W1280, N, NEG, SOFF, DOFF)     \
+  TEST_F(LibYUVConvertTest, FMT_PLANAR##To##FMT_B##N) {                       \
+    const int kWidth = W1280;                                                 \
+    const int kHeight = ALIGNINT(benchmark_height_, YALIGN);                  \
+    const int kStrideB = ALIGNINT(kWidth * BPP_B, ALIGN);                     \
+    const int kStrideUV = SUBSAMPLE(kWidth, SUBSAMP_X);                       \
+    const int kSizeUV = kStrideUV * SUBSAMPLE(kHeight, SUBSAMP_Y);            \
+    const int kBpc = 2;                                                       \
+    align_buffer_page_end(src_y, kWidth* kHeight* kBpc + SOFF);               \
+    align_buffer_page_end(src_u, kSizeUV* kBpc + SOFF);                       \
+    align_buffer_page_end(src_v, kSizeUV* kBpc + SOFF);                       \
+    align_buffer_page_end(dst_argb_c, kStrideB* kHeight + DOFF);              \
+    align_buffer_page_end(dst_argb_opt, kStrideB* kHeight + DOFF);            \
+    for (int i = 0; i < kWidth * kHeight; ++i) {                              \
+      reinterpret_cast<uint16_t*>(src_y + SOFF)[i] = (fastrand() & FMT_MASK); \
+    }                                                                         \
+    for (int i = 0; i < kSizeUV; ++i) {                                       \
+      reinterpret_cast<uint16_t*>(src_u + SOFF)[i] = (fastrand() & FMT_MASK); \
+      reinterpret_cast<uint16_t*>(src_v + SOFF)[i] = (fastrand() & FMT_MASK); \
+    }                                                                         \
+    memset(dst_argb_c + DOFF, 1, kStrideB * kHeight);                         \
+    memset(dst_argb_opt + DOFF, 101, kStrideB * kHeight);                     \
+    MaskCpuFlags(disable_cpu_flags_);                                         \
+    FMT_PLANAR##To##FMT_B(                                                    \
+        reinterpret_cast<uint16_t*>(src_y + SOFF), kWidth,                    \
+        reinterpret_cast<uint16_t*>(src_u + SOFF), kStrideUV,                 \
+        reinterpret_cast<uint16_t*>(src_v + SOFF), kStrideUV,                 \
+        dst_argb_c + DOFF, kStrideB, kWidth, NEG kHeight);                    \
+    MaskCpuFlags(benchmark_cpu_info_);                                        \
+    for (int i = 0; i < benchmark_iterations_; ++i) {                         \
+      FMT_PLANAR##To##FMT_B(                                                  \
+          reinterpret_cast<uint16_t*>(src_y + SOFF), kWidth,                  \
+          reinterpret_cast<uint16_t*>(src_u + SOFF), kStrideUV,               \
+          reinterpret_cast<uint16_t*>(src_v + SOFF), kStrideUV,               \
+          dst_argb_opt + DOFF, kStrideB, kWidth, NEG kHeight);                \
+    }                                                                         \
+    for (int i = 0; i < kWidth * BPP_B * kHeight; ++i) {                      \
+      EXPECT_EQ(dst_argb_c[i + DOFF], dst_argb_opt[i + DOFF]);                \
+    }                                                                         \
+    free_aligned_buffer_page_end(src_y);                                      \
+    free_aligned_buffer_page_end(src_u);                                      \
+    free_aligned_buffer_page_end(src_v);                                      \
+    free_aligned_buffer_page_end(dst_argb_c);                                 \
+    free_aligned_buffer_page_end(dst_argb_opt);                               \
+  }
+
+#define TESTPLANAR16TOB(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_MASK, FMT_B,   \
+                        BPP_B, ALIGN, YALIGN)                                \
+  TESTPLANAR16TOBI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_MASK, FMT_B, BPP_B, \
+                   ALIGN, YALIGN, benchmark_width_ + 1, _Any, +, 0, 0)       \
+  TESTPLANAR16TOBI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_MASK, FMT_B, BPP_B, \
+                   ALIGN, YALIGN, benchmark_width_, _Unaligned, +, 4, 4)     \
+  TESTPLANAR16TOBI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_MASK, FMT_B, BPP_B, \
+                   ALIGN, YALIGN, benchmark_width_, _Invert, -, 0, 0)        \
+  TESTPLANAR16TOBI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_MASK, FMT_B, BPP_B, \
+                   ALIGN, YALIGN, benchmark_width_, _Opt, +, 0, 0)
+
+// These conversions are only optimized for x86
+#if !defined(DISABLE_SLOW_TESTS) || defined(__x86_64__) || defined(__i386__)
+TESTPLANAR16TOB(I010, 2, 2, 0x3ff, ARGB, 4, 4, 1)
+TESTPLANAR16TOB(I010, 2, 2, 0x3ff, ABGR, 4, 4, 1)
+TESTPLANAR16TOB(H010, 2, 2, 0x3ff, ARGB, 4, 4, 1)
+TESTPLANAR16TOB(H010, 2, 2, 0x3ff, ABGR, 4, 4, 1)
+TESTPLANAR16TOB(U010, 2, 2, 0x3ff, ARGB, 4, 4, 1)
+TESTPLANAR16TOB(U010, 2, 2, 0x3ff, ABGR, 4, 4, 1)
+TESTPLANAR16TOB(I210, 2, 1, 0x3ff, ARGB, 4, 4, 1)
+TESTPLANAR16TOB(I210, 2, 1, 0x3ff, ABGR, 4, 4, 1)
+TESTPLANAR16TOB(H210, 2, 1, 0x3ff, ARGB, 4, 4, 1)
+TESTPLANAR16TOB(H210, 2, 1, 0x3ff, ABGR, 4, 4, 1)
+TESTPLANAR16TOB(U210, 2, 1, 0x3ff, ARGB, 4, 4, 1)
+TESTPLANAR16TOB(U210, 2, 1, 0x3ff, ABGR, 4, 4, 1)
+TESTPLANAR16TOB(I410, 1, 1, 0x3ff, ARGB, 4, 4, 1)
+TESTPLANAR16TOB(I410, 1, 1, 0x3ff, ABGR, 4, 4, 1)
+TESTPLANAR16TOB(H410, 1, 1, 0x3ff, ARGB, 4, 4, 1)
+TESTPLANAR16TOB(H410, 1, 1, 0x3ff, ABGR, 4, 4, 1)
+TESTPLANAR16TOB(U410, 1, 1, 0x3ff, ARGB, 4, 4, 1)
+TESTPLANAR16TOB(U410, 1, 1, 0x3ff, ABGR, 4, 4, 1)
+TESTPLANAR16TOB(I012, 2, 2, 0xfff, ARGB, 4, 4, 1)
+TESTPLANAR16TOB(I010, 2, 2, 0x3ff, ARGBFilter, 4, 4, 1)
+TESTPLANAR16TOB(I210, 2, 1, 0x3ff, ARGBFilter, 4, 4, 1)
+
+#ifdef LITTLE_ENDIAN_ONLY_TEST
+TESTPLANAR16TOB(I010, 2, 2, 0x3ff, AR30, 4, 4, 1)
+TESTPLANAR16TOB(I010, 2, 2, 0x3ff, AB30, 4, 4, 1)
+TESTPLANAR16TOB(H010, 2, 2, 0x3ff, AR30, 4, 4, 1)
+TESTPLANAR16TOB(H010, 2, 2, 0x3ff, AB30, 4, 4, 1)
+TESTPLANAR16TOB(U010, 2, 2, 0x3ff, AR30, 4, 4, 1)
+TESTPLANAR16TOB(U010, 2, 2, 0x3ff, AB30, 4, 4, 1)
+TESTPLANAR16TOB(I210, 2, 1, 0x3ff, AR30, 4, 4, 1)
+TESTPLANAR16TOB(I210, 2, 1, 0x3ff, AB30, 4, 4, 1)
+TESTPLANAR16TOB(H210, 2, 1, 0x3ff, AR30, 4, 4, 1)
+TESTPLANAR16TOB(H210, 2, 1, 0x3ff, AB30, 4, 4, 1)
+TESTPLANAR16TOB(U210, 2, 1, 0x3ff, AR30, 4, 4, 1)
+TESTPLANAR16TOB(U210, 2, 1, 0x3ff, AB30, 4, 4, 1)
+TESTPLANAR16TOB(I410, 1, 1, 0x3ff, AR30, 4, 4, 1)
+TESTPLANAR16TOB(I410, 1, 1, 0x3ff, AB30, 4, 4, 1)
+TESTPLANAR16TOB(H410, 1, 1, 0x3ff, AR30, 4, 4, 1)
+TESTPLANAR16TOB(H410, 1, 1, 0x3ff, AB30, 4, 4, 1)
+TESTPLANAR16TOB(U410, 1, 1, 0x3ff, AR30, 4, 4, 1)
+TESTPLANAR16TOB(U410, 1, 1, 0x3ff, AB30, 4, 4, 1)
+TESTPLANAR16TOB(I012, 2, 2, 0xfff, AR30, 4, 4, 1)
+TESTPLANAR16TOB(I010, 2, 2, 0x3ff, AR30Filter, 4, 4, 1)
+TESTPLANAR16TOB(I210, 2, 1, 0x3ff, AR30Filter, 4, 4, 1)
+#endif  // LITTLE_ENDIAN_ONLY_TEST
+#endif  // DISABLE_SLOW_TESTS
+
+#define TESTQPLANAR16TOBI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B,      \
+                          ALIGN, YALIGN, W1280, N, NEG, OFF, ATTEN, S_DEPTH)   \
+  TEST_F(LibYUVConvertTest, FMT_PLANAR##To##FMT_B##N) {                        \
+    const int kWidth = W1280;                                                  \
+    const int kHeight = ALIGNINT(benchmark_height_, YALIGN);                   \
+    const int kStrideB = ALIGNINT(kWidth * BPP_B, ALIGN);                      \
+    const int kStrideUV = SUBSAMPLE(kWidth, SUBSAMP_X);                        \
+    const int kSizeUV = kStrideUV * SUBSAMPLE(kHeight, SUBSAMP_Y);             \
+    const int kBpc = 2;                                                        \
+    align_buffer_page_end(src_y, kWidth* kHeight* kBpc + OFF);                 \
+    align_buffer_page_end(src_u, kSizeUV* kBpc + OFF);                         \
+    align_buffer_page_end(src_v, kSizeUV* kBpc + OFF);                         \
+    align_buffer_page_end(src_a, kWidth* kHeight* kBpc + OFF);                 \
+    align_buffer_page_end(dst_argb_c, kStrideB* kHeight + OFF);                \
+    align_buffer_page_end(dst_argb_opt, kStrideB* kHeight + OFF);              \
+    for (int i = 0; i < kWidth * kHeight; ++i) {                               \
+      reinterpret_cast<uint16_t*>(src_y + OFF)[i] =                            \
+          (fastrand() & ((1 << S_DEPTH) - 1));                                 \
+      reinterpret_cast<uint16_t*>(src_a + OFF)[i] =                            \
+          (fastrand() & ((1 << S_DEPTH) - 1));                                 \
+    }                                                                          \
+    for (int i = 0; i < kSizeUV; ++i) {                                        \
+      reinterpret_cast<uint16_t*>(src_u + OFF)[i] =                            \
+          (fastrand() & ((1 << S_DEPTH) - 1));                                 \
+      reinterpret_cast<uint16_t*>(src_v + OFF)[i] =                            \
+          (fastrand() & ((1 << S_DEPTH) - 1));                                 \
+    }                                                                          \
+    memset(dst_argb_c + OFF, 1, kStrideB * kHeight);                           \
+    memset(dst_argb_opt + OFF, 101, kStrideB * kHeight);                       \
+    MaskCpuFlags(disable_cpu_flags_);                                          \
+    FMT_PLANAR##To##FMT_B(reinterpret_cast<uint16_t*>(src_y + OFF), kWidth,    \
+                          reinterpret_cast<uint16_t*>(src_u + OFF), kStrideUV, \
+                          reinterpret_cast<uint16_t*>(src_v + OFF), kStrideUV, \
+                          reinterpret_cast<uint16_t*>(src_a + OFF), kWidth,    \
+                          dst_argb_c + OFF, kStrideB, kWidth, NEG kHeight,     \
+                          ATTEN);                                              \
+    MaskCpuFlags(benchmark_cpu_info_);                                         \
+    for (int i = 0; i < benchmark_iterations_; ++i) {                          \
+      FMT_PLANAR##To##FMT_B(                                                   \
+          reinterpret_cast<uint16_t*>(src_y + OFF), kWidth,                    \
+          reinterpret_cast<uint16_t*>(src_u + OFF), kStrideUV,                 \
+          reinterpret_cast<uint16_t*>(src_v + OFF), kStrideUV,                 \
+          reinterpret_cast<uint16_t*>(src_a + OFF), kWidth,                    \
+          dst_argb_opt + OFF, kStrideB, kWidth, NEG kHeight, ATTEN);           \
+    }                                                                          \
+    for (int i = 0; i < kWidth * BPP_B * kHeight; ++i) {                       \
+      EXPECT_EQ(dst_argb_c[i + OFF], dst_argb_opt[i + OFF]);                   \
+    }                                                                          \
+    free_aligned_buffer_page_end(src_y);                                       \
+    free_aligned_buffer_page_end(src_u);                                       \
+    free_aligned_buffer_page_end(src_v);                                       \
+    free_aligned_buffer_page_end(src_a);                                       \
+    free_aligned_buffer_page_end(dst_argb_c);                                  \
+    free_aligned_buffer_page_end(dst_argb_opt);                                \
+  }
+
+#if defined(ENABLE_FULL_TESTS)
+#define TESTQPLANAR16TOB(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B,    \
+                         ALIGN, YALIGN, S_DEPTH)                            \
+  TESTQPLANAR16TOBI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN,  \
+                    YALIGN, benchmark_width_ + 1, _Any, +, 0, 0, S_DEPTH)   \
+  TESTQPLANAR16TOBI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN,  \
+                    YALIGN, benchmark_width_, _Unaligned, +, 2, 0, S_DEPTH) \
+  TESTQPLANAR16TOBI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN,  \
+                    YALIGN, benchmark_width_, _Invert, -, 0, 0, S_DEPTH)    \
+  TESTQPLANAR16TOBI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN,  \
+                    YALIGN, benchmark_width_, _Opt, +, 0, 0, S_DEPTH)       \
+  TESTQPLANAR16TOBI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN,  \
+                    YALIGN, benchmark_width_, _Premult, +, 0, 1, S_DEPTH)
+#else
+#define TESTQPLANAR16TOB(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B,   \
+                         ALIGN, YALIGN, S_DEPTH)                           \
+  TESTQPLANAR16TOBI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN, \
+                    YALIGN, benchmark_width_, _Opt, +, 0, 0, S_DEPTH)
+#endif
+
+#define I010AlphaToARGB(a, b, c, d, e, f, g, h, i, j, k, l, m)               \
+  I010AlphaToARGBMatrix(a, b, c, d, e, f, g, h, i, j, &kYuvI601Constants, k, \
+                        l, m)
+#define I010AlphaToABGR(a, b, c, d, e, f, g, h, i, j, k, l, m)               \
+  I010AlphaToABGRMatrix(a, b, c, d, e, f, g, h, i, j, &kYuvI601Constants, k, \
+                        l, m)
+#define J010AlphaToARGB(a, b, c, d, e, f, g, h, i, j, k, l, m)               \
+  I010AlphaToARGBMatrix(a, b, c, d, e, f, g, h, i, j, &kYuvJPEGConstants, k, \
+                        l, m)
+#define J010AlphaToABGR(a, b, c, d, e, f, g, h, i, j, k, l, m)               \
+  I010AlphaToABGRMatrix(a, b, c, d, e, f, g, h, i, j, &kYuvJPEGConstants, k, \
+                        l, m)
+#define F010AlphaToARGB(a, b, c, d, e, f, g, h, i, j, k, l, m)               \
+  I010AlphaToARGBMatrix(a, b, c, d, e, f, g, h, i, j, &kYuvF709Constants, k, \
+                        l, m)
+#define F010AlphaToABGR(a, b, c, d, e, f, g, h, i, j, k, l, m)               \
+  I010AlphaToABGRMatrix(a, b, c, d, e, f, g, h, i, j, &kYuvF709Constants, k, \
+                        l, m)
+#define H010AlphaToARGB(a, b, c, d, e, f, g, h, i, j, k, l, m)               \
+  I010AlphaToARGBMatrix(a, b, c, d, e, f, g, h, i, j, &kYuvH709Constants, k, \
+                        l, m)
+#define H010AlphaToABGR(a, b, c, d, e, f, g, h, i, j, k, l, m)               \
+  I010AlphaToABGRMatrix(a, b, c, d, e, f, g, h, i, j, &kYuvH709Constants, k, \
+                        l, m)
+#define U010AlphaToARGB(a, b, c, d, e, f, g, h, i, j, k, l, m)               \
+  I010AlphaToARGBMatrix(a, b, c, d, e, f, g, h, i, j, &kYuv2020Constants, k, \
+                        l, m)
+#define U010AlphaToABGR(a, b, c, d, e, f, g, h, i, j, k, l, m)               \
+  I010AlphaToABGRMatrix(a, b, c, d, e, f, g, h, i, j, &kYuv2020Constants, k, \
+                        l, m)
+#define V010AlphaToARGB(a, b, c, d, e, f, g, h, i, j, k, l, m)                \
+  I010AlphaToARGBMatrix(a, b, c, d, e, f, g, h, i, j, &kYuvV2020Constants, k, \
+                        l, m)
+#define V010AlphaToABGR(a, b, c, d, e, f, g, h, i, j, k, l, m)                \
+  I010AlphaToABGRMatrix(a, b, c, d, e, f, g, h, i, j, &kYuvV2020Constants, k, \
+                        l, m)
+#define I210AlphaToARGB(a, b, c, d, e, f, g, h, i, j, k, l, m)               \
+  I210AlphaToARGBMatrix(a, b, c, d, e, f, g, h, i, j, &kYuvI601Constants, k, \
+                        l, m)
+#define I210AlphaToABGR(a, b, c, d, e, f, g, h, i, j, k, l, m)               \
+  I210AlphaToABGRMatrix(a, b, c, d, e, f, g, h, i, j, &kYuvI601Constants, k, \
+                        l, m)
+#define J210AlphaToARGB(a, b, c, d, e, f, g, h, i, j, k, l, m)               \
+  I210AlphaToARGBMatrix(a, b, c, d, e, f, g, h, i, j, &kYuvJPEGConstants, k, \
+                        l, m)
+#define J210AlphaToABGR(a, b, c, d, e, f, g, h, i, j, k, l, m)               \
+  I210AlphaToABGRMatrix(a, b, c, d, e, f, g, h, i, j, &kYuvJPEGConstants, k, \
+                        l, m)
+#define F210AlphaToARGB(a, b, c, d, e, f, g, h, i, j, k, l, m)               \
+  I210AlphaToARGBMatrix(a, b, c, d, e, f, g, h, i, j, &kYuvF709Constants, k, \
+                        l, m)
+#define F210AlphaToABGR(a, b, c, d, e, f, g, h, i, j, k, l, m)               \
+  I210AlphaToABGRMatrix(a, b, c, d, e, f, g, h, i, j, &kYuvF709Constants, k, \
+                        l, m)
+#define H210AlphaToARGB(a, b, c, d, e, f, g, h, i, j, k, l, m)               \
+  I210AlphaToARGBMatrix(a, b, c, d, e, f, g, h, i, j, &kYuvH709Constants, k, \
+                        l, m)
+#define H210AlphaToABGR(a, b, c, d, e, f, g, h, i, j, k, l, m)               \
+  I210AlphaToABGRMatrix(a, b, c, d, e, f, g, h, i, j, &kYuvH709Constants, k, \
+                        l, m)
+#define U210AlphaToARGB(a, b, c, d, e, f, g, h, i, j, k, l, m)               \
+  I210AlphaToARGBMatrix(a, b, c, d, e, f, g, h, i, j, &kYuv2020Constants, k, \
+                        l, m)
+#define U210AlphaToABGR(a, b, c, d, e, f, g, h, i, j, k, l, m)               \
+  I210AlphaToABGRMatrix(a, b, c, d, e, f, g, h, i, j, &kYuv2020Constants, k, \
+                        l, m)
+#define V210AlphaToARGB(a, b, c, d, e, f, g, h, i, j, k, l, m)                \
+  I210AlphaToARGBMatrix(a, b, c, d, e, f, g, h, i, j, &kYuvV2020Constants, k, \
+                        l, m)
+#define V210AlphaToABGR(a, b, c, d, e, f, g, h, i, j, k, l, m)                \
+  I210AlphaToABGRMatrix(a, b, c, d, e, f, g, h, i, j, &kYuvV2020Constants, k, \
+                        l, m)
+#define I410AlphaToARGB(a, b, c, d, e, f, g, h, i, j, k, l, m)               \
+  I410AlphaToARGBMatrix(a, b, c, d, e, f, g, h, i, j, &kYuvI601Constants, k, \
+                        l, m)
+#define I410AlphaToABGR(a, b, c, d, e, f, g, h, i, j, k, l, m)               \
+  I410AlphaToABGRMatrix(a, b, c, d, e, f, g, h, i, j, &kYuvI601Constants, k, \
+                        l, m)
+#define J410AlphaToARGB(a, b, c, d, e, f, g, h, i, j, k, l, m)               \
+  I410AlphaToARGBMatrix(a, b, c, d, e, f, g, h, i, j, &kYuvJPEGConstants, k, \
+                        l, m)
+#define J410AlphaToABGR(a, b, c, d, e, f, g, h, i, j, k, l, m)               \
+  I410AlphaToABGRMatrix(a, b, c, d, e, f, g, h, i, j, &kYuvJPEGConstants, k, \
+                        l, m)
+#define F410AlphaToARGB(a, b, c, d, e, f, g, h, i, j, k, l, m)               \
+  I410AlphaToARGBMatrix(a, b, c, d, e, f, g, h, i, j, &kYuvF709Constants, k, \
+                        l, m)
+#define F410AlphaToABGR(a, b, c, d, e, f, g, h, i, j, k, l, m)               \
+  I410AlphaToABGRMatrix(a, b, c, d, e, f, g, h, i, j, &kYuvF709Constants, k, \
+                        l, m)
+#define H410AlphaToARGB(a, b, c, d, e, f, g, h, i, j, k, l, m)               \
+  I410AlphaToARGBMatrix(a, b, c, d, e, f, g, h, i, j, &kYuvH709Constants, k, \
+                        l, m)
+#define H410AlphaToABGR(a, b, c, d, e, f, g, h, i, j, k, l, m)               \
+  I410AlphaToABGRMatrix(a, b, c, d, e, f, g, h, i, j, &kYuvH709Constants, k, \
+                        l, m)
+#define U410AlphaToARGB(a, b, c, d, e, f, g, h, i, j, k, l, m)               \
+  I410AlphaToARGBMatrix(a, b, c, d, e, f, g, h, i, j, &kYuv2020Constants, k, \
+                        l, m)
+#define U410AlphaToABGR(a, b, c, d, e, f, g, h, i, j, k, l, m)               \
+  I410AlphaToABGRMatrix(a, b, c, d, e, f, g, h, i, j, &kYuv2020Constants, k, \
+                        l, m)
+#define V410AlphaToARGB(a, b, c, d, e, f, g, h, i, j, k, l, m)                \
+  I410AlphaToARGBMatrix(a, b, c, d, e, f, g, h, i, j, &kYuvV2020Constants, k, \
+                        l, m)
+#define V410AlphaToABGR(a, b, c, d, e, f, g, h, i, j, k, l, m)                \
+  I410AlphaToABGRMatrix(a, b, c, d, e, f, g, h, i, j, &kYuvV2020Constants, k, \
+                        l, m)
+#define I010AlphaToARGBFilter(a, b, c, d, e, f, g, h, i, j, k, l, m) \
+  I010AlphaToARGBMatrixFilter(a, b, c, d, e, f, g, h, i, j,          \
+                              &kYuvI601Constants, k, l, m, kFilterBilinear)
+#define I210AlphaToARGBFilter(a, b, c, d, e, f, g, h, i, j, k, l, m) \
+  I010AlphaToARGBMatrixFilter(a, b, c, d, e, f, g, h, i, j,          \
+                              &kYuvI601Constants, k, l, m, kFilterBilinear)
+
+// These conversions are only optimized for x86
+#if !defined(DISABLE_SLOW_TESTS) || defined(__x86_64__) || defined(__i386__)
+TESTQPLANAR16TOB(I010Alpha, 2, 2, ARGB, 4, 4, 1, 10)
+TESTQPLANAR16TOB(I010Alpha, 2, 2, ABGR, 4, 4, 1, 10)
+TESTQPLANAR16TOB(J010Alpha, 2, 2, ARGB, 4, 4, 1, 10)
+TESTQPLANAR16TOB(J010Alpha, 2, 2, ABGR, 4, 4, 1, 10)
+TESTQPLANAR16TOB(H010Alpha, 2, 2, ARGB, 4, 4, 1, 10)
+TESTQPLANAR16TOB(H010Alpha, 2, 2, ABGR, 4, 4, 1, 10)
+TESTQPLANAR16TOB(F010Alpha, 2, 2, ARGB, 4, 4, 1, 10)
+TESTQPLANAR16TOB(F010Alpha, 2, 2, ABGR, 4, 4, 1, 10)
+TESTQPLANAR16TOB(U010Alpha, 2, 2, ARGB, 4, 4, 1, 10)
+TESTQPLANAR16TOB(U010Alpha, 2, 2, ABGR, 4, 4, 1, 10)
+TESTQPLANAR16TOB(V010Alpha, 2, 2, ARGB, 4, 4, 1, 10)
+TESTQPLANAR16TOB(V010Alpha, 2, 2, ABGR, 4, 4, 1, 10)
+TESTQPLANAR16TOB(I210Alpha, 2, 1, ARGB, 4, 4, 1, 10)
+TESTQPLANAR16TOB(I210Alpha, 2, 1, ABGR, 4, 4, 1, 10)
+TESTQPLANAR16TOB(J210Alpha, 2, 1, ARGB, 4, 4, 1, 10)
+TESTQPLANAR16TOB(J210Alpha, 2, 1, ABGR, 4, 4, 1, 10)
+TESTQPLANAR16TOB(H210Alpha, 2, 1, ARGB, 4, 4, 1, 10)
+TESTQPLANAR16TOB(H210Alpha, 2, 1, ABGR, 4, 4, 1, 10)
+TESTQPLANAR16TOB(F210Alpha, 2, 1, ARGB, 4, 4, 1, 10)
+TESTQPLANAR16TOB(F210Alpha, 2, 1, ABGR, 4, 4, 1, 10)
+TESTQPLANAR16TOB(U210Alpha, 2, 1, ARGB, 4, 4, 1, 10)
+TESTQPLANAR16TOB(U210Alpha, 2, 1, ABGR, 4, 4, 1, 10)
+TESTQPLANAR16TOB(V210Alpha, 2, 1, ARGB, 4, 4, 1, 10)
+TESTQPLANAR16TOB(V210Alpha, 2, 1, ABGR, 4, 4, 1, 10)
+TESTQPLANAR16TOB(I410Alpha, 1, 1, ARGB, 4, 4, 1, 10)
+TESTQPLANAR16TOB(I410Alpha, 1, 1, ABGR, 4, 4, 1, 10)
+TESTQPLANAR16TOB(J410Alpha, 1, 1, ARGB, 4, 4, 1, 10)
+TESTQPLANAR16TOB(J410Alpha, 1, 1, ABGR, 4, 4, 1, 10)
+TESTQPLANAR16TOB(H410Alpha, 1, 1, ARGB, 4, 4, 1, 10)
+TESTQPLANAR16TOB(H410Alpha, 1, 1, ABGR, 4, 4, 1, 10)
+TESTQPLANAR16TOB(F410Alpha, 1, 1, ARGB, 4, 4, 1, 10)
+TESTQPLANAR16TOB(F410Alpha, 1, 1, ABGR, 4, 4, 1, 10)
+TESTQPLANAR16TOB(U410Alpha, 1, 1, ARGB, 4, 4, 1, 10)
+TESTQPLANAR16TOB(U410Alpha, 1, 1, ABGR, 4, 4, 1, 10)
+TESTQPLANAR16TOB(V410Alpha, 1, 1, ARGB, 4, 4, 1, 10)
+TESTQPLANAR16TOB(V410Alpha, 1, 1, ABGR, 4, 4, 1, 10)
+TESTQPLANAR16TOB(I010Alpha, 2, 2, ARGBFilter, 4, 4, 1, 10)
+TESTQPLANAR16TOB(I210Alpha, 2, 1, ARGBFilter, 4, 4, 1, 10)
+#endif  // DISABLE_SLOW_TESTS
+
+#define TESTBIPLANAR16TOBI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B,     \
+                           ALIGN, YALIGN, W1280, N, NEG, SOFF, DOFF, S_DEPTH)  \
+  TEST_F(LibYUVConvertTest, FMT_PLANAR##To##FMT_B##N) {                        \
+    const int kWidth = W1280;                                                  \
+    const int kHeight = ALIGNINT(benchmark_height_, YALIGN);                   \
+    const int kStrideB = ALIGNINT(kWidth * BPP_B, ALIGN);                      \
+    const int kStrideUV = SUBSAMPLE(kWidth, SUBSAMP_X) * 2;                    \
+    const int kSizeUV = kStrideUV * SUBSAMPLE(kHeight, SUBSAMP_Y) * 2;         \
+    const int kBpc = 2;                                                        \
+    align_buffer_page_end(src_y, kWidth* kHeight* kBpc + SOFF);                \
+    align_buffer_page_end(src_uv, kSizeUV* kBpc + SOFF);                       \
+    align_buffer_page_end(dst_argb_c, kStrideB* kHeight + DOFF);               \
+    align_buffer_page_end(dst_argb_opt, kStrideB* kHeight + DOFF);             \
+    for (int i = 0; i < kWidth * kHeight; ++i) {                               \
+      reinterpret_cast<uint16_t*>(src_y + SOFF)[i] =                           \
+          (fastrand() & (((uint16_t)(-1)) << (16 - S_DEPTH)));                 \
+    }                                                                          \
+    for (int i = 0; i < kSizeUV; ++i) {                                        \
+      reinterpret_cast<uint16_t*>(src_uv + SOFF)[i] =                          \
+          (fastrand() & (((uint16_t)(-1)) << (16 - S_DEPTH)));                 \
+    }                                                                          \
+    memset(dst_argb_c + DOFF, 1, kStrideB * kHeight);                          \
+    memset(dst_argb_opt + DOFF, 101, kStrideB * kHeight);                      \
+    MaskCpuFlags(disable_cpu_flags_);                                          \
+    FMT_PLANAR##To##FMT_B(reinterpret_cast<uint16_t*>(src_y + SOFF), kWidth,   \
+                          reinterpret_cast<uint16_t*>(src_uv + SOFF),          \
+                          kStrideUV, dst_argb_c + DOFF, kStrideB, kWidth,      \
+                          NEG kHeight);                                        \
+    MaskCpuFlags(benchmark_cpu_info_);                                         \
+    for (int i = 0; i < benchmark_iterations_; ++i) {                          \
+      FMT_PLANAR##To##FMT_B(reinterpret_cast<uint16_t*>(src_y + SOFF), kWidth, \
+                            reinterpret_cast<uint16_t*>(src_uv + SOFF),        \
+                            kStrideUV, dst_argb_opt + DOFF, kStrideB, kWidth,  \
+                            NEG kHeight);                                      \
+    }                                                                          \
+    for (int i = 0; i < kWidth * BPP_B * kHeight; ++i) {                       \
+      EXPECT_EQ(dst_argb_c[i + DOFF], dst_argb_opt[i + DOFF]);                 \
+    }                                                                          \
+    free_aligned_buffer_page_end(src_y);                                       \
+    free_aligned_buffer_page_end(src_uv);                                      \
+    free_aligned_buffer_page_end(dst_argb_c);                                  \
+    free_aligned_buffer_page_end(dst_argb_opt);                                \
+  }
+
+#define TESTBIPLANAR16TOB(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B,    \
+                          ALIGN, YALIGN, S_DEPTH)                            \
+  TESTBIPLANAR16TOBI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN,  \
+                     YALIGN, benchmark_width_ + 1, _Any, +, 0, 0, S_DEPTH)   \
+  TESTBIPLANAR16TOBI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN,  \
+                     YALIGN, benchmark_width_, _Unaligned, +, 4, 4, S_DEPTH) \
+  TESTBIPLANAR16TOBI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN,  \
+                     YALIGN, benchmark_width_, _Invert, -, 0, 0, S_DEPTH)    \
+  TESTBIPLANAR16TOBI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN,  \
+                     YALIGN, benchmark_width_, _Opt, +, 0, 0, S_DEPTH)
+
+#define P010ToARGB(a, b, c, d, e, f, g, h) \
+  P010ToARGBMatrix(a, b, c, d, e, f, &kYuvH709Constants, g, h)
+#define P210ToARGB(a, b, c, d, e, f, g, h) \
+  P210ToARGBMatrix(a, b, c, d, e, f, &kYuvH709Constants, g, h)
+#define P010ToAR30(a, b, c, d, e, f, g, h) \
+  P010ToAR30Matrix(a, b, c, d, e, f, &kYuvH709Constants, g, h)
+#define P210ToAR30(a, b, c, d, e, f, g, h) \
+  P210ToAR30Matrix(a, b, c, d, e, f, &kYuvH709Constants, g, h)
+
+#define P012ToARGB(a, b, c, d, e, f, g, h) \
+  P012ToARGBMatrix(a, b, c, d, e, f, &kYuvH709Constants, g, h)
+#define P212ToARGB(a, b, c, d, e, f, g, h) \
+  P212ToARGBMatrix(a, b, c, d, e, f, &kYuvH709Constants, g, h)
+#define P012ToAR30(a, b, c, d, e, f, g, h) \
+  P012ToAR30Matrix(a, b, c, d, e, f, &kYuvH709Constants, g, h)
+#define P212ToAR30(a, b, c, d, e, f, g, h) \
+  P212ToAR30Matrix(a, b, c, d, e, f, &kYuvH709Constants, g, h)
+
+#define P016ToARGB(a, b, c, d, e, f, g, h) \
+  P016ToARGBMatrix(a, b, c, d, e, f, &kYuvH709Constants, g, h)
+#define P216ToARGB(a, b, c, d, e, f, g, h) \
+  P216ToARGBMatrix(a, b, c, d, e, f, &kYuvH709Constants, g, h)
+#define P016ToAR30(a, b, c, d, e, f, g, h) \
+  P016ToAR30Matrix(a, b, c, d, e, f, &kYuvH709Constants, g, h)
+#define P216ToAR30(a, b, c, d, e, f, g, h) \
+  P216ToAR30Matrix(a, b, c, d, e, f, &kYuvH709Constants, g, h)
+
+#define P010ToARGBFilter(a, b, c, d, e, f, g, h)                     \
+  P010ToARGBMatrixFilter(a, b, c, d, e, f, &kYuvH709Constants, g, h, \
+                         kFilterBilinear)
+#define P210ToARGBFilter(a, b, c, d, e, f, g, h)                     \
+  P210ToARGBMatrixFilter(a, b, c, d, e, f, &kYuvH709Constants, g, h, \
+                         kFilterBilinear)
+#define P010ToAR30Filter(a, b, c, d, e, f, g, h)                     \
+  P010ToAR30MatrixFilter(a, b, c, d, e, f, &kYuvH709Constants, g, h, \
+                         kFilterBilinear)
+#define P210ToAR30Filter(a, b, c, d, e, f, g, h)                     \
+  P210ToAR30MatrixFilter(a, b, c, d, e, f, &kYuvH709Constants, g, h, \
+                         kFilterBilinear)
+
+#if !defined(DISABLE_SLOW_TESTS) || defined(__x86_64__) || defined(__i386__)
+TESTBIPLANAR16TOB(P010, 2, 2, ARGB, 4, 4, 1, 10)
+TESTBIPLANAR16TOB(P210, 2, 1, ARGB, 4, 4, 1, 10)
+TESTBIPLANAR16TOB(P012, 2, 2, ARGB, 4, 4, 1, 12)
+TESTBIPLANAR16TOB(P212, 2, 1, ARGB, 4, 4, 1, 12)
+TESTBIPLANAR16TOB(P016, 2, 2, ARGB, 4, 4, 1, 16)
+TESTBIPLANAR16TOB(P216, 2, 1, ARGB, 4, 4, 1, 16)
+TESTBIPLANAR16TOB(P010, 2, 2, ARGBFilter, 4, 4, 1, 10)
+TESTBIPLANAR16TOB(P210, 2, 1, ARGBFilter, 4, 4, 1, 10)
+#ifdef LITTLE_ENDIAN_ONLY_TEST
+TESTBIPLANAR16TOB(P010, 2, 2, AR30, 4, 4, 1, 10)
+TESTBIPLANAR16TOB(P210, 2, 1, AR30, 4, 4, 1, 10)
+TESTBIPLANAR16TOB(P012, 2, 2, AR30, 4, 4, 1, 12)
+TESTBIPLANAR16TOB(P212, 2, 1, AR30, 4, 4, 1, 12)
+TESTBIPLANAR16TOB(P016, 2, 2, AR30, 4, 4, 1, 16)
+TESTBIPLANAR16TOB(P216, 2, 1, AR30, 4, 4, 1, 16)
+TESTBIPLANAR16TOB(P010, 2, 2, AR30Filter, 4, 4, 1, 10)
+TESTBIPLANAR16TOB(P210, 2, 1, AR30Filter, 4, 4, 1, 10)
+#endif  // LITTLE_ENDIAN_ONLY_TEST
+#endif  // DISABLE_SLOW_TESTS
+
+static int Clamp(int y) {
+  if (y < 0) {
+    y = 0;
+  }
+  if (y > 255) {
+    y = 255;
+  }
+  return y;
+}
+
+static int Clamp10(int y) {
+  if (y < 0) {
+    y = 0;
+  }
+  if (y > 1023) {
+    y = 1023;
+  }
+  return y;
+}
+
+// Test 8 bit YUV to 8 bit RGB
+TEST_F(LibYUVConvertTest, TestH420ToARGB) {
+  const int kSize = 256;
+  int histogram_b[256];
+  int histogram_g[256];
+  int histogram_r[256];
+  memset(histogram_b, 0, sizeof(histogram_b));
+  memset(histogram_g, 0, sizeof(histogram_g));
+  memset(histogram_r, 0, sizeof(histogram_r));
+  align_buffer_page_end(orig_yuv, kSize + kSize / 2 * 2);
+  align_buffer_page_end(argb_pixels, kSize * 4);
+  uint8_t* orig_y = orig_yuv;
+  uint8_t* orig_u = orig_y + kSize;
+  uint8_t* orig_v = orig_u + kSize / 2;
+
+  // Test grey scale
+  for (int i = 0; i < kSize; ++i) {
+    orig_y[i] = i;
+  }
+  for (int i = 0; i < kSize / 2; ++i) {
+    orig_u[i] = 128;  // 128 is 0.
+    orig_v[i] = 128;
+  }
+
+  H420ToARGB(orig_y, 0, orig_u, 0, orig_v, 0, argb_pixels, 0, kSize, 1);
+
+  for (int i = 0; i < kSize; ++i) {
+    int b = argb_pixels[i * 4 + 0];
+    int g = argb_pixels[i * 4 + 1];
+    int r = argb_pixels[i * 4 + 2];
+    int a = argb_pixels[i * 4 + 3];
+    ++histogram_b[b];
+    ++histogram_g[g];
+    ++histogram_r[r];
+    // Reference formula for Y channel contribution in YUV to RGB conversions:
+    int expected_y = Clamp(static_cast<int>((i - 16) * 1.164f + 0.5f));
+    EXPECT_EQ(b, expected_y);
+    EXPECT_EQ(g, expected_y);
+    EXPECT_EQ(r, expected_y);
+    EXPECT_EQ(a, 255);
+  }
+
+  int count_b = 0;
+  int count_g = 0;
+  int count_r = 0;
+  for (int i = 0; i < kSize; ++i) {
+    if (histogram_b[i]) {
+      ++count_b;
+    }
+    if (histogram_g[i]) {
+      ++count_g;
+    }
+    if (histogram_r[i]) {
+      ++count_r;
+    }
+  }
+  printf("uniques: B %d, G, %d, R %d\n", count_b, count_g, count_r);
+
+  free_aligned_buffer_page_end(orig_yuv);
+  free_aligned_buffer_page_end(argb_pixels);
+}
+
+// Test 10 bit YUV to 8 bit RGB
+TEST_F(LibYUVConvertTest, TestH010ToARGB) {
+  const int kSize = 1024;
+  int histogram_b[1024];
+  int histogram_g[1024];
+  int histogram_r[1024];
+  memset(histogram_b, 0, sizeof(histogram_b));
+  memset(histogram_g, 0, sizeof(histogram_g));
+  memset(histogram_r, 0, sizeof(histogram_r));
+  align_buffer_page_end(orig_yuv, kSize * 2 + kSize / 2 * 2 * 2);
+  align_buffer_page_end(argb_pixels, kSize * 4);
+  uint16_t* orig_y = reinterpret_cast<uint16_t*>(orig_yuv);
+  uint16_t* orig_u = orig_y + kSize;
+  uint16_t* orig_v = orig_u + kSize / 2;
+
+  // Test grey scale
+  for (int i = 0; i < kSize; ++i) {
+    orig_y[i] = i;
+  }
+  for (int i = 0; i < kSize / 2; ++i) {
+    orig_u[i] = 512;  // 512 is 0.
+    orig_v[i] = 512;
+  }
+
+  H010ToARGB(orig_y, 0, orig_u, 0, orig_v, 0, argb_pixels, 0, kSize, 1);
+
+  for (int i = 0; i < kSize; ++i) {
+    int b = argb_pixels[i * 4 + 0];
+    int g = argb_pixels[i * 4 + 1];
+    int r = argb_pixels[i * 4 + 2];
+    int a = argb_pixels[i * 4 + 3];
+    ++histogram_b[b];
+    ++histogram_g[g];
+    ++histogram_r[r];
+    int expected_y = Clamp(static_cast<int>((i - 64) * 1.164f / 4));
+    EXPECT_NEAR(b, expected_y, 1);
+    EXPECT_NEAR(g, expected_y, 1);
+    EXPECT_NEAR(r, expected_y, 1);
+    EXPECT_EQ(a, 255);
+  }
+
+  int count_b = 0;
+  int count_g = 0;
+  int count_r = 0;
+  for (int i = 0; i < kSize; ++i) {
+    if (histogram_b[i]) {
+      ++count_b;
+    }
+    if (histogram_g[i]) {
+      ++count_g;
+    }
+    if (histogram_r[i]) {
+      ++count_r;
+    }
+  }
+  printf("uniques: B %d, G, %d, R %d\n", count_b, count_g, count_r);
+
+  free_aligned_buffer_page_end(orig_yuv);
+  free_aligned_buffer_page_end(argb_pixels);
+}
+
+// Test 10 bit YUV to 10 bit RGB
+// Caveat: Result is near due to float rounding in expected
+// result.
+TEST_F(LibYUVConvertTest, TestH010ToAR30) {
+  const int kSize = 1024;
+  int histogram_b[1024];
+  int histogram_g[1024];
+  int histogram_r[1024];
+  memset(histogram_b, 0, sizeof(histogram_b));
+  memset(histogram_g, 0, sizeof(histogram_g));
+  memset(histogram_r, 0, sizeof(histogram_r));
+
+  align_buffer_page_end(orig_yuv, kSize * 2 + kSize / 2 * 2 * 2);
+  align_buffer_page_end(ar30_pixels, kSize * 4);
+  uint16_t* orig_y = reinterpret_cast<uint16_t*>(orig_yuv);
+  uint16_t* orig_u = orig_y + kSize;
+  uint16_t* orig_v = orig_u + kSize / 2;
+
+  // Test grey scale
+  for (int i = 0; i < kSize; ++i) {
+    orig_y[i] = i;
+  }
+  for (int i = 0; i < kSize / 2; ++i) {
+    orig_u[i] = 512;  // 512 is 0.
+    orig_v[i] = 512;
+  }
+
+  H010ToAR30(orig_y, 0, orig_u, 0, orig_v, 0, ar30_pixels, 0, kSize, 1);
+
+  for (int i = 0; i < kSize; ++i) {
+    int b10 = reinterpret_cast<uint32_t*>(ar30_pixels)[i] & 1023;
+    int g10 = (reinterpret_cast<uint32_t*>(ar30_pixels)[i] >> 10) & 1023;
+    int r10 = (reinterpret_cast<uint32_t*>(ar30_pixels)[i] >> 20) & 1023;
+    int a2 = (reinterpret_cast<uint32_t*>(ar30_pixels)[i] >> 30) & 3;
+    ++histogram_b[b10];
+    ++histogram_g[g10];
+    ++histogram_r[r10];
+    int expected_y = Clamp10(static_cast<int>((i - 64) * 1.164f + 0.5));
+    EXPECT_NEAR(b10, expected_y, 4);
+    EXPECT_NEAR(g10, expected_y, 4);
+    EXPECT_NEAR(r10, expected_y, 4);
+    EXPECT_EQ(a2, 3);
+  }
+
+  int count_b = 0;
+  int count_g = 0;
+  int count_r = 0;
+  for (int i = 0; i < kSize; ++i) {
+    if (histogram_b[i]) {
+      ++count_b;
+    }
+    if (histogram_g[i]) {
+      ++count_g;
+    }
+    if (histogram_r[i]) {
+      ++count_r;
+    }
+  }
+  printf("uniques: B %d, G, %d, R %d\n", count_b, count_g, count_r);
+
+  free_aligned_buffer_page_end(orig_yuv);
+  free_aligned_buffer_page_end(ar30_pixels);
+}
+
+// Test 10 bit YUV to 10 bit RGB
+// Caveat: Result is near due to float rounding in expected
+// result.
+TEST_F(LibYUVConvertTest, TestH010ToAB30) {
+  const int kSize = 1024;
+  int histogram_b[1024];
+  int histogram_g[1024];
+  int histogram_r[1024];
+  memset(histogram_b, 0, sizeof(histogram_b));
+  memset(histogram_g, 0, sizeof(histogram_g));
+  memset(histogram_r, 0, sizeof(histogram_r));
+
+  align_buffer_page_end(orig_yuv, kSize * 2 + kSize / 2 * 2 * 2);
+  align_buffer_page_end(ab30_pixels, kSize * 4);
+  uint16_t* orig_y = reinterpret_cast<uint16_t*>(orig_yuv);
+  uint16_t* orig_u = orig_y + kSize;
+  uint16_t* orig_v = orig_u + kSize / 2;
+
+  // Test grey scale
+  for (int i = 0; i < kSize; ++i) {
+    orig_y[i] = i;
+  }
+  for (int i = 0; i < kSize / 2; ++i) {
+    orig_u[i] = 512;  // 512 is 0.
+    orig_v[i] = 512;
+  }
+
+  H010ToAB30(orig_y, 0, orig_u, 0, orig_v, 0, ab30_pixels, 0, kSize, 1);
+
+  for (int i = 0; i < kSize; ++i) {
+    int r10 = reinterpret_cast<uint32_t*>(ab30_pixels)[i] & 1023;
+    int g10 = (reinterpret_cast<uint32_t*>(ab30_pixels)[i] >> 10) & 1023;
+    int b10 = (reinterpret_cast<uint32_t*>(ab30_pixels)[i] >> 20) & 1023;
+    int a2 = (reinterpret_cast<uint32_t*>(ab30_pixels)[i] >> 30) & 3;
+    ++histogram_b[b10];
+    ++histogram_g[g10];
+    ++histogram_r[r10];
+    int expected_y = Clamp10(static_cast<int>((i - 64) * 1.164f));
+    EXPECT_NEAR(b10, expected_y, 4);
+    EXPECT_NEAR(g10, expected_y, 4);
+    EXPECT_NEAR(r10, expected_y, 4);
+    EXPECT_EQ(a2, 3);
+  }
+
+  int count_b = 0;
+  int count_g = 0;
+  int count_r = 0;
+  for (int i = 0; i < kSize; ++i) {
+    if (histogram_b[i]) {
+      ++count_b;
+    }
+    if (histogram_g[i]) {
+      ++count_g;
+    }
+    if (histogram_r[i]) {
+      ++count_r;
+    }
+  }
+  printf("uniques: B %d, G, %d, R %d\n", count_b, count_g, count_r);
+
+  free_aligned_buffer_page_end(orig_yuv);
+  free_aligned_buffer_page_end(ab30_pixels);
+}
+
+// Test 8 bit YUV to 10 bit RGB
+TEST_F(LibYUVConvertTest, TestH420ToAR30) {
+  const int kSize = 256;
+  const int kHistSize = 1024;
+  int histogram_b[kHistSize];
+  int histogram_g[kHistSize];
+  int histogram_r[kHistSize];
+  memset(histogram_b, 0, sizeof(histogram_b));
+  memset(histogram_g, 0, sizeof(histogram_g));
+  memset(histogram_r, 0, sizeof(histogram_r));
+  align_buffer_page_end(orig_yuv, kSize + kSize / 2 * 2);
+  align_buffer_page_end(ar30_pixels, kSize * 4);
+  uint8_t* orig_y = orig_yuv;
+  uint8_t* orig_u = orig_y + kSize;
+  uint8_t* orig_v = orig_u + kSize / 2;
+
+  // Test grey scale
+  for (int i = 0; i < kSize; ++i) {
+    orig_y[i] = i;
+  }
+  for (int i = 0; i < kSize / 2; ++i) {
+    orig_u[i] = 128;  // 128 is 0.
+    orig_v[i] = 128;
+  }
+
+  H420ToAR30(orig_y, 0, orig_u, 0, orig_v, 0, ar30_pixels, 0, kSize, 1);
+
+  for (int i = 0; i < kSize; ++i) {
+    int b10 = reinterpret_cast<uint32_t*>(ar30_pixels)[i] & 1023;
+    int g10 = (reinterpret_cast<uint32_t*>(ar30_pixels)[i] >> 10) & 1023;
+    int r10 = (reinterpret_cast<uint32_t*>(ar30_pixels)[i] >> 20) & 1023;
+    int a2 = (reinterpret_cast<uint32_t*>(ar30_pixels)[i] >> 30) & 3;
+    ++histogram_b[b10];
+    ++histogram_g[g10];
+    ++histogram_r[r10];
+    int expected_y = Clamp10(static_cast<int>((i - 16) * 1.164f * 4.f));
+    EXPECT_NEAR(b10, expected_y, 4);
+    EXPECT_NEAR(g10, expected_y, 4);
+    EXPECT_NEAR(r10, expected_y, 4);
+    EXPECT_EQ(a2, 3);
+  }
+
+  int count_b = 0;
+  int count_g = 0;
+  int count_r = 0;
+  for (int i = 0; i < kHistSize; ++i) {
+    if (histogram_b[i]) {
+      ++count_b;
+    }
+    if (histogram_g[i]) {
+      ++count_g;
+    }
+    if (histogram_r[i]) {
+      ++count_r;
+    }
+  }
+  printf("uniques: B %d, G, %d, R %d\n", count_b, count_g, count_r);
+
+  free_aligned_buffer_page_end(orig_yuv);
+  free_aligned_buffer_page_end(ar30_pixels);
+}
+
+// Test I400 with jpeg matrix is same as J400
+TEST_F(LibYUVConvertTest, TestI400) {
+  const int kSize = 256;
+  align_buffer_page_end(orig_i400, kSize);
+  align_buffer_page_end(argb_pixels_i400, kSize * 4);
+  align_buffer_page_end(argb_pixels_j400, kSize * 4);
+  align_buffer_page_end(argb_pixels_jpeg_i400, kSize * 4);
+  align_buffer_page_end(argb_pixels_h709_i400, kSize * 4);
+  align_buffer_page_end(argb_pixels_2020_i400, kSize * 4);
+
+  // Test grey scale
+  for (int i = 0; i < kSize; ++i) {
+    orig_i400[i] = i;
+  }
+
+  J400ToARGB(orig_i400, 0, argb_pixels_j400, 0, kSize, 1);
+  I400ToARGB(orig_i400, 0, argb_pixels_i400, 0, kSize, 1);
+  I400ToARGBMatrix(orig_i400, 0, argb_pixels_jpeg_i400, 0, &kYuvJPEGConstants,
+                   kSize, 1);
+  I400ToARGBMatrix(orig_i400, 0, argb_pixels_h709_i400, 0, &kYuvH709Constants,
+                   kSize, 1);
+  I400ToARGBMatrix(orig_i400, 0, argb_pixels_2020_i400, 0, &kYuv2020Constants,
+                   kSize, 1);
+
+  EXPECT_EQ(0, argb_pixels_i400[0]);
+  EXPECT_EQ(0, argb_pixels_j400[0]);
+  EXPECT_EQ(0, argb_pixels_jpeg_i400[0]);
+  EXPECT_EQ(0, argb_pixels_h709_i400[0]);
+  EXPECT_EQ(0, argb_pixels_2020_i400[0]);
+  EXPECT_EQ(0, argb_pixels_i400[16 * 4]);
+  EXPECT_EQ(16, argb_pixels_j400[16 * 4]);
+  EXPECT_EQ(16, argb_pixels_jpeg_i400[16 * 4]);
+  EXPECT_EQ(0, argb_pixels_h709_i400[16 * 4]);
+  EXPECT_EQ(0, argb_pixels_2020_i400[16 * 4]);
+  EXPECT_EQ(130, argb_pixels_i400[128 * 4]);
+  EXPECT_EQ(128, argb_pixels_j400[128 * 4]);
+  EXPECT_EQ(128, argb_pixels_jpeg_i400[128 * 4]);
+  EXPECT_EQ(130, argb_pixels_h709_i400[128 * 4]);
+  EXPECT_EQ(130, argb_pixels_2020_i400[128 * 4]);
+  EXPECT_EQ(255, argb_pixels_i400[255 * 4]);
+  EXPECT_EQ(255, argb_pixels_j400[255 * 4]);
+  EXPECT_EQ(255, argb_pixels_jpeg_i400[255 * 4]);
+  EXPECT_EQ(255, argb_pixels_h709_i400[255 * 4]);
+  EXPECT_EQ(255, argb_pixels_2020_i400[255 * 4]);
+
+  for (int i = 0; i < kSize * 4; ++i) {
+    if ((i & 3) == 3) {
+      EXPECT_EQ(255, argb_pixels_j400[i]);
+    } else {
+      EXPECT_EQ(i / 4, argb_pixels_j400[i]);
+    }
+    EXPECT_EQ(argb_pixels_jpeg_i400[i], argb_pixels_j400[i]);
+  }
+
+  free_aligned_buffer_page_end(orig_i400);
+  free_aligned_buffer_page_end(argb_pixels_i400);
+  free_aligned_buffer_page_end(argb_pixels_j400);
+  free_aligned_buffer_page_end(argb_pixels_jpeg_i400);
+  free_aligned_buffer_page_end(argb_pixels_h709_i400);
+  free_aligned_buffer_page_end(argb_pixels_2020_i400);
+}
+
+// Test RGB24 to ARGB and back to RGB24
+TEST_F(LibYUVConvertTest, TestARGBToRGB24) {
+  const int kSize = 256;
+  align_buffer_page_end(orig_rgb24, kSize * 3);
+  align_buffer_page_end(argb_pixels, kSize * 4);
+  align_buffer_page_end(dest_rgb24, kSize * 3);
+
+  // Test grey scale
+  for (int i = 0; i < kSize * 3; ++i) {
+    orig_rgb24[i] = i;
+  }
+
+  RGB24ToARGB(orig_rgb24, 0, argb_pixels, 0, kSize, 1);
+  ARGBToRGB24(argb_pixels, 0, dest_rgb24, 0, kSize, 1);
+
+  for (int i = 0; i < kSize * 3; ++i) {
+    EXPECT_EQ(orig_rgb24[i], dest_rgb24[i]);
+  }
+
+  free_aligned_buffer_page_end(orig_rgb24);
+  free_aligned_buffer_page_end(argb_pixels);
+  free_aligned_buffer_page_end(dest_rgb24);
+}
+
+TEST_F(LibYUVConvertTest, Test565) {
+  SIMD_ALIGNED(uint8_t orig_pixels[256][4]);
+  SIMD_ALIGNED(uint8_t pixels565[256][2]);
+
+  for (int i = 0; i < 256; ++i) {
+    for (int j = 0; j < 4; ++j) {
+      orig_pixels[i][j] = i;
+    }
+  }
+  ARGBToRGB565(&orig_pixels[0][0], 0, &pixels565[0][0], 0, 256, 1);
+  uint32_t checksum = HashDjb2(&pixels565[0][0], sizeof(pixels565), 5381);
+  EXPECT_EQ(610919429u, checksum);
+}
+
+// Test RGB24 to J420 is exact
+#if defined(LIBYUV_BIT_EXACT)
+TEST_F(LibYUVConvertTest, TestRGB24ToJ420) {
+  const int kSize = 256;
+  align_buffer_page_end(orig_rgb24, kSize * 3 * 2);  // 2 rows of RGB24
+  align_buffer_page_end(dest_j420, kSize * 3 / 2 * 2);
+  int iterations256 = (benchmark_width_ * benchmark_height_ + (kSize * 2 - 1)) /
+                      (kSize * 2) * benchmark_iterations_;
+
+  for (int i = 0; i < kSize * 3 * 2; ++i) {
+    orig_rgb24[i] = i;
+  }
+
+  for (int i = 0; i < iterations256; ++i) {
+    RGB24ToJ420(orig_rgb24, kSize * 3, dest_j420, kSize,  // Y plane
+                dest_j420 + kSize * 2, kSize / 2,         // U plane
+                dest_j420 + kSize * 5 / 2, kSize / 2,     // V plane
+                kSize, 2);
+  }
+
+  uint32_t checksum = HashDjb2(dest_j420, kSize * 3 / 2 * 2, 5381);
+  EXPECT_EQ(2755440272u, checksum);
+
+  free_aligned_buffer_page_end(orig_rgb24);
+  free_aligned_buffer_page_end(dest_j420);
+}
+#endif
+
+// Test RGB24 to I420 is exact
+#if defined(LIBYUV_BIT_EXACT)
+TEST_F(LibYUVConvertTest, TestRGB24ToI420) {
+  const int kSize = 256;
+  align_buffer_page_end(orig_rgb24, kSize * 3 * 2);  // 2 rows of RGB24
+  align_buffer_page_end(dest_i420, kSize * 3 / 2 * 2);
+  int iterations256 = (benchmark_width_ * benchmark_height_ + (kSize * 2 - 1)) /
+                      (kSize * 2) * benchmark_iterations_;
+
+  for (int i = 0; i < kSize * 3 * 2; ++i) {
+    orig_rgb24[i] = i;
+  }
+
+  for (int i = 0; i < iterations256; ++i) {
+    RGB24ToI420(orig_rgb24, kSize * 3, dest_i420, kSize,  // Y plane
+                dest_i420 + kSize * 2, kSize / 2,         // U plane
+                dest_i420 + kSize * 5 / 2, kSize / 2,     // V plane
+                kSize, 2);
+  }
+
+  uint32_t checksum = HashDjb2(dest_i420, kSize * 3 / 2 * 2, 5381);
+  EXPECT_EQ(1526656597u, checksum);
+
+  free_aligned_buffer_page_end(orig_rgb24);
+  free_aligned_buffer_page_end(dest_i420);
+}
+#endif
+
+}  // namespace libyuv
diff --git a/3rdparty/libyuv/src/unit_test/cpu_test.cc b/3rdparty/libyuv/src/unit_test/cpu_test.cc
new file mode 100644
index 00000000..080778f5
--- /dev/null
+++ b/3rdparty/libyuv/src/unit_test/cpu_test.cc
@@ -0,0 +1,295 @@
+/*
+ *  Copyright 2012 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "../unit_test/unit_test.h"
+#include "libyuv/basic_types.h"
+#include "libyuv/cpu_id.h"
+#include "libyuv/version.h"
+
+namespace libyuv {
+
+TEST_F(LibYUVBaseTest, TestCpuHas) {
+  int cpu_flags = TestCpuFlag(-1);
+  printf("Cpu Flags %d\n", cpu_flags);
+#if defined(__arm__) || defined(__aarch64__)
+  int has_arm = TestCpuFlag(kCpuHasARM);
+  printf("Has ARM %d\n", has_arm);
+  int has_neon = TestCpuFlag(kCpuHasNEON);
+  printf("Has NEON %d\n", has_neon);
+#endif
+  int has_x86 = TestCpuFlag(kCpuHasX86);
+  int has_sse2 = TestCpuFlag(kCpuHasSSE2);
+  int has_ssse3 = TestCpuFlag(kCpuHasSSSE3);
+  int has_sse41 = TestCpuFlag(kCpuHasSSE41);
+  int has_sse42 = TestCpuFlag(kCpuHasSSE42);
+  int has_avx = TestCpuFlag(kCpuHasAVX);
+  int has_avx2 = TestCpuFlag(kCpuHasAVX2);
+  int has_erms = TestCpuFlag(kCpuHasERMS);
+  int has_fma3 = TestCpuFlag(kCpuHasFMA3);
+  int has_f16c = TestCpuFlag(kCpuHasF16C);
+  int has_gfni = TestCpuFlag(kCpuHasGFNI);
+  int has_avx512bw = TestCpuFlag(kCpuHasAVX512BW);
+  int has_avx512vl = TestCpuFlag(kCpuHasAVX512VL);
+  int has_avx512vnni = TestCpuFlag(kCpuHasAVX512VNNI);
+  int has_avx512vbmi = TestCpuFlag(kCpuHasAVX512VBMI);
+  int has_avx512vbmi2 = TestCpuFlag(kCpuHasAVX512VBMI2);
+  int has_avx512vbitalg = TestCpuFlag(kCpuHasAVX512VBITALG);
+  int has_avx512vpopcntdq = TestCpuFlag(kCpuHasAVX512VPOPCNTDQ);
+  printf("Has X86 %d\n", has_x86);
+  printf("Has SSE2 %d\n", has_sse2);
+  printf("Has SSSE3 %d\n", has_ssse3);
+  printf("Has SSE41 %d\n", has_sse41);
+  printf("Has SSE42 %d\n", has_sse42);
+  printf("Has AVX %d\n", has_avx);
+  printf("Has AVX2 %d\n", has_avx2);
+  printf("Has ERMS %d\n", has_erms);
+  printf("Has FMA3 %d\n", has_fma3);
+  printf("Has F16C %d\n", has_f16c);
+  printf("Has GFNI %d\n", has_gfni);
+  printf("Has AVX512BW %d\n", has_avx512bw);
+  printf("Has AVX512VL %d\n", has_avx512vl);
+  printf("Has AVX512VNNI %d\n", has_avx512vnni);
+  printf("Has AVX512VBMI %d\n", has_avx512vbmi);
+  printf("Has AVX512VBMI2 %d\n", has_avx512vbmi2);
+  printf("Has AVX512VBITALG %d\n", has_avx512vbitalg);
+  printf("Has AVX512VPOPCNTDQ %d\n", has_avx512vpopcntdq);
+
+#if defined(__mips__)
+  int has_mips = TestCpuFlag(kCpuHasMIPS);
+  printf("Has MIPS %d\n", has_mips);
+  int has_msa = TestCpuFlag(kCpuHasMSA);
+  printf("Has MSA %d\n", has_msa);
+#endif
+
+#if defined(__loongarch__)
+  int has_loongarch = TestCpuFlag(kCpuHasLOONGARCH);
+  printf("Has LOONGARCH %d\n", has_loongarch);
+  int has_lsx = TestCpuFlag(kCpuHasLSX);
+  printf("Has LSX %d\n", has_lsx);
+  int has_lasx = TestCpuFlag(kCpuHasLASX);
+  printf("Has LASX %d\n", has_lasx);
+#endif
+}
+
+TEST_F(LibYUVBaseTest, TestCompilerMacros) {
+  // Tests all macros used in public headers.
+#ifdef __ATOMIC_RELAXED
+  printf("__ATOMIC_RELAXED %d\n", __ATOMIC_RELAXED);
+#endif
+#ifdef __cplusplus
+  printf("__cplusplus %ld\n", __cplusplus);
+#endif
+#ifdef __clang_major__
+  printf("__clang_major__ %d\n", __clang_major__);
+#endif
+#ifdef __clang_minor__
+  printf("__clang_minor__ %d\n", __clang_minor__);
+#endif
+#ifdef __GNUC__
+  printf("__GNUC__ %d\n", __GNUC__);
+#endif
+#ifdef __GNUC_MINOR__
+  printf("__GNUC_MINOR__ %d\n", __GNUC_MINOR__);
+#endif
+#ifdef __i386__
+  printf("__i386__ %d\n", __i386__);
+#endif
+#ifdef __mips
+  printf("__mips %d\n", __mips);
+#endif
+#ifdef __mips_isa_rev
+  printf("__mips_isa_rev %d\n", __mips_isa_rev);
+#endif
+#ifdef __x86_64__
+  printf("__x86_64__ %d\n", __x86_64__);
+#endif
+#ifdef _MSC_VER
+  printf("_MSC_VER %d\n", _MSC_VER);
+#endif
+#ifdef __aarch64__
+  printf("__aarch64__ %d\n", __aarch64__);
+#endif
+#ifdef __APPLE__
+  printf("__APPLE__ %d\n", __APPLE__);
+#endif
+#ifdef __arm__
+  printf("__arm__ %d\n", __arm__);
+#endif
+#ifdef __clang__
+  printf("__clang__ %d\n", __clang__);
+#endif
+#ifdef __CLR_VER
+  printf("__CLR_VER %d\n", __CLR_VER);
+#endif
+#ifdef __CYGWIN__
+  printf("__CYGWIN__ %d\n", __CYGWIN__);
+#endif
+#ifdef __llvm__
+  printf("__llvm__ %d\n", __llvm__);
+#endif
+#ifdef __mips_msa
+  printf("__mips_msa %d\n", __mips_msa);
+#endif
+#ifdef __native_client__
+  printf("__native_client__ %d\n", __native_client__);
+#endif
+#ifdef __pic__
+  printf("__pic__ %d\n", __pic__);
+#endif
+#ifdef __pnacl__
+  printf("__pnacl__ %d\n", __pnacl__);
+#endif
+#ifdef _M_IX86
+  printf("_M_IX86 %d\n", _M_IX86);
+#endif
+#ifdef _M_X64
+  printf("_M_X64 %d\n", _M_X64);
+#endif
+#ifdef _MIPS_ARCH_LOONGSON3A
+  printf("_MIPS_ARCH_LOONGSON3A %d\n", _MIPS_ARCH_LOONGSON3A);
+#endif
+#ifdef __loongarch__
+  printf("__loongarch__ %d\n", __loongarch__);
+#endif
+#ifdef _WIN32
+  printf("_WIN32 %d\n", _WIN32);
+#endif
+#ifdef GG_LONGLONG
+  printf("GG_LONGLONG %d\n", GG_LONGLONG);
+#endif
+#ifdef INT_TYPES_DEFINED
+  printf("INT_TYPES_DEFINED\n");
+#endif
+#ifdef __has_feature
+  printf("__has_feature\n");
+#if __has_feature(memory_sanitizer)
+  printf("__has_feature(memory_sanitizer) %d\n",
+         __has_feature(memory_sanitizer));
+#endif
+#endif
+}
+
+#if defined(__i386__) || defined(__x86_64__) || defined(_M_IX86) || \
+    defined(_M_X64)
+TEST_F(LibYUVBaseTest, TestCpuId) {
+  int has_x86 = TestCpuFlag(kCpuHasX86);
+  if (has_x86) {
+    int cpu_info[4];
+    // Vendor ID:
+    // AuthenticAMD AMD processor
+    // CentaurHauls Centaur processor
+    // CyrixInstead Cyrix processor
+    // GenuineIntel Intel processor
+    // GenuineTMx86 Transmeta processor
+    // Geode by NSC National Semiconductor processor
+    // NexGenDriven NexGen processor
+    // RiseRiseRise Rise Technology processor
+    // SiS SiS SiS  SiS processor
+    // UMC UMC UMC  UMC processor
+    CpuId(0, 0, cpu_info);
+    cpu_info[0] = cpu_info[1];  // Reorder output
+    cpu_info[1] = cpu_info[3];
+    cpu_info[3] = 0;
+    printf("Cpu Vendor: %s %x %x %x\n", reinterpret_cast<char*>(&cpu_info[0]),
+           cpu_info[0], cpu_info[1], cpu_info[2]);
+    EXPECT_EQ(12u, strlen(reinterpret_cast<char*>(&cpu_info[0])));
+
+    // CPU Family and Model
+    // 3:0 - Stepping
+    // 7:4 - Model
+    // 11:8 - Family
+    // 13:12 - Processor Type
+    // 19:16 - Extended Model
+    // 27:20 - Extended Family
+    CpuId(1, 0, cpu_info);
+    int family = ((cpu_info[0] >> 8) & 0x0f) | ((cpu_info[0] >> 16) & 0xff0);
+    int model = ((cpu_info[0] >> 4) & 0x0f) | ((cpu_info[0] >> 12) & 0xf0);
+    printf("Cpu Family %d (0x%x), Model %d (0x%x)\n", family, family, model,
+           model);
+  }
+}
+#endif
+
+static int FileExists(const char* file_name) {
+  FILE* f = fopen(file_name, "r");
+  if (!f) {
+    return 0;
+  }
+  fclose(f);
+  return 1;
+}
+
+TEST_F(LibYUVBaseTest, TestLinuxNeon) {
+  if (FileExists("../../unit_test/testdata/arm_v7.txt")) {
+    printf("Note: testing to load \"../../unit_test/testdata/arm_v7.txt\"\n");
+
+    EXPECT_EQ(0, ArmCpuCaps("../../unit_test/testdata/arm_v7.txt"));
+    EXPECT_EQ(kCpuHasNEON, ArmCpuCaps("../../unit_test/testdata/tegra3.txt"));
+    EXPECT_EQ(kCpuHasNEON, ArmCpuCaps("../../unit_test/testdata/juno.txt"));
+  } else {
+    printf("WARNING: unable to load \"../../unit_test/testdata/arm_v7.txt\"\n");
+  }
+#if defined(__linux__) && defined(__ARM_NEON__)
+  if (FileExists("/proc/cpuinfo")) {
+    if (kCpuHasNEON != ArmCpuCaps("/proc/cpuinfo")) {
+      // This can happen on ARM emulator but /proc/cpuinfo is from host.
+      printf("WARNING: Neon build enabled but CPU does not have NEON\n");
+    }
+  } else {
+    printf("WARNING: unable to load \"/proc/cpuinfo\"\n");
+  }
+#endif
+}
+
+TEST_F(LibYUVBaseTest, TestLinuxMipsMsa) {
+  if (FileExists("../../unit_test/testdata/mips.txt")) {
+    printf("Note: testing to load \"../../unit_test/testdata/mips.txt\"\n");
+
+    EXPECT_EQ(0, MipsCpuCaps("../../unit_test/testdata/mips.txt"));
+    EXPECT_EQ(kCpuHasMSA, MipsCpuCaps("../../unit_test/testdata/mips_msa.txt"));
+    EXPECT_EQ(kCpuHasMSA,
+              MipsCpuCaps("../../unit_test/testdata/mips_loongson2k.txt"));
+  } else {
+    printf("WARNING: unable to load \"../../unit_test/testdata/mips.txt\"\n");
+  }
+}
+
+// TODO(fbarchard): Fix clangcl test of cpuflags.
+#ifdef _MSC_VER
+TEST_F(LibYUVBaseTest, DISABLED_TestSetCpuFlags) {
+#else
+TEST_F(LibYUVBaseTest, TestSetCpuFlags) {
+#endif
+  // Reset any masked flags that may have been set so auto init is enabled.
+  MaskCpuFlags(0);
+
+  int original_cpu_flags = TestCpuFlag(-1);
+
+  // Test setting different CPU configurations.
+  int cpu_flags = kCpuHasARM | kCpuHasNEON | kCpuInitialized;
+  SetCpuFlags(cpu_flags);
+  EXPECT_EQ(cpu_flags, TestCpuFlag(-1));
+
+  cpu_flags = kCpuHasX86 | kCpuInitialized;
+  SetCpuFlags(cpu_flags);
+  EXPECT_EQ(cpu_flags, TestCpuFlag(-1));
+
+  // Test that setting 0 turns auto-init back on.
+  SetCpuFlags(0);
+  EXPECT_EQ(original_cpu_flags, TestCpuFlag(-1));
+
+  // Restore the CPU flag mask.
+  MaskCpuFlags(benchmark_cpu_info_);
+}
+
+}  // namespace libyuv
diff --git a/3rdparty/libyuv/src/unit_test/cpu_thread_test.cc b/3rdparty/libyuv/src/unit_test/cpu_thread_test.cc
new file mode 100644
index 00000000..69aab74e
--- /dev/null
+++ b/3rdparty/libyuv/src/unit_test/cpu_thread_test.cc
@@ -0,0 +1,63 @@
+/*
+ *  Copyright 2017 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include <gtest/gtest.h>
+
+#include "libyuv/cpu_id.h"
+
+#if defined(__clang__) && !defined(__wasm__)
+#if __has_include(<pthread.h>)
+#define LIBYUV_HAVE_PTHREAD 1
+#endif
+#elif defined(__linux__)
+#define LIBYUV_HAVE_PTHREAD 1
+#endif
+
+#ifdef LIBYUV_HAVE_PTHREAD
+#include <pthread.h>
+#endif
+
+namespace libyuv {
+
+#ifdef LIBYUV_HAVE_PTHREAD
+void* ThreadMain(void* arg) {
+  int* flags = static_cast<int*>(arg);
+
+  *flags = TestCpuFlag(kCpuInitialized);
+  return nullptr;
+}
+#endif  // LIBYUV_HAVE_PTHREAD
+
+// Call TestCpuFlag() from two threads. ThreadSanitizer should not report any
+// data race.
+TEST(LibYUVCpuThreadTest, TestCpuFlagMultipleThreads) {
+#ifdef LIBYUV_HAVE_PTHREAD
+  int cpu_flags1;
+  int cpu_flags2;
+  int ret;
+  pthread_t thread1;
+  pthread_t thread2;
+
+  MaskCpuFlags(0);  // Reset to 0 to allow auto detect.
+  ret = pthread_create(&thread1, nullptr, ThreadMain, &cpu_flags1);
+  ASSERT_EQ(ret, 0);
+  ret = pthread_create(&thread2, nullptr, ThreadMain, &cpu_flags2);
+  ASSERT_EQ(ret, 0);
+  ret = pthread_join(thread1, nullptr);
+  EXPECT_EQ(ret, 0);
+  ret = pthread_join(thread2, nullptr);
+  EXPECT_EQ(ret, 0);
+  EXPECT_EQ(cpu_flags1, cpu_flags2);
+#else
+  printf("pthread unavailable; Test skipped.");
+#endif  // LIBYUV_HAVE_PTHREAD
+}
+
+}  // namespace libyuv
diff --git a/3rdparty/libyuv/src/unit_test/math_test.cc b/3rdparty/libyuv/src/unit_test/math_test.cc
new file mode 100644
index 00000000..a1544c12
--- /dev/null
+++ b/3rdparty/libyuv/src/unit_test/math_test.cc
@@ -0,0 +1,160 @@
+/*
+ *  Copyright 2013 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+
+#include "../unit_test/unit_test.h"
+#include "libyuv/basic_types.h"
+#include "libyuv/cpu_id.h"
+#include "libyuv/scale.h"
+
+#ifdef ENABLE_ROW_TESTS
+#include "libyuv/scale_row.h"
+#endif
+
+namespace libyuv {
+
+#ifdef ENABLE_ROW_TESTS
+TEST_F(LibYUVBaseTest, TestFixedDiv) {
+  int num[1280];
+  int div[1280];
+  int result_opt[1280];
+  int result_c[1280];
+
+  EXPECT_EQ(0x10000, libyuv::FixedDiv(1, 1));
+  EXPECT_EQ(0x7fff0000, libyuv::FixedDiv(0x7fff, 1));
+  // TODO(fbarchard): Avoid the following that throw exceptions.
+  // EXPECT_EQ(0x100000000, libyuv::FixedDiv(0x10000, 1));
+  // EXPECT_EQ(0x80000000, libyuv::FixedDiv(0x8000, 1));
+
+  EXPECT_EQ(0x20000, libyuv::FixedDiv(640 * 2, 640));
+  EXPECT_EQ(0x30000, libyuv::FixedDiv(640 * 3, 640));
+  EXPECT_EQ(0x40000, libyuv::FixedDiv(640 * 4, 640));
+  EXPECT_EQ(0x50000, libyuv::FixedDiv(640 * 5, 640));
+  EXPECT_EQ(0x60000, libyuv::FixedDiv(640 * 6, 640));
+  EXPECT_EQ(0x70000, libyuv::FixedDiv(640 * 7, 640));
+  EXPECT_EQ(0x80000, libyuv::FixedDiv(640 * 8, 640));
+  EXPECT_EQ(0xa0000, libyuv::FixedDiv(640 * 10, 640));
+  EXPECT_EQ(0x20000, libyuv::FixedDiv(960 * 2, 960));
+  EXPECT_EQ(0x08000, libyuv::FixedDiv(640 / 2, 640));
+  EXPECT_EQ(0x04000, libyuv::FixedDiv(640 / 4, 640));
+  EXPECT_EQ(0x20000, libyuv::FixedDiv(1080 * 2, 1080));
+  EXPECT_EQ(0x20000, libyuv::FixedDiv(200000, 100000));
+  EXPECT_EQ(0x18000, libyuv::FixedDiv(150000, 100000));
+  EXPECT_EQ(0x20000, libyuv::FixedDiv(40000, 20000));
+  EXPECT_EQ(0x20000, libyuv::FixedDiv(-40000, -20000));
+  EXPECT_EQ(-0x20000, libyuv::FixedDiv(40000, -20000));
+  EXPECT_EQ(-0x20000, libyuv::FixedDiv(-40000, 20000));
+  EXPECT_EQ(0x10000, libyuv::FixedDiv(4095, 4095));
+  EXPECT_EQ(0x10000, libyuv::FixedDiv(4096, 4096));
+  EXPECT_EQ(0x10000, libyuv::FixedDiv(4097, 4097));
+  EXPECT_EQ(123 * 65536, libyuv::FixedDiv(123, 1));
+
+  for (int i = 1; i < 4100; ++i) {
+    EXPECT_EQ(0x10000, libyuv::FixedDiv(i, i));
+    EXPECT_EQ(0x20000, libyuv::FixedDiv(i * 2, i));
+    EXPECT_EQ(0x30000, libyuv::FixedDiv(i * 3, i));
+    EXPECT_EQ(0x40000, libyuv::FixedDiv(i * 4, i));
+    EXPECT_EQ(0x08000, libyuv::FixedDiv(i, i * 2));
+    EXPECT_NEAR(16384 * 65536 / i, libyuv::FixedDiv(16384, i), 1);
+  }
+  EXPECT_EQ(123 * 65536, libyuv::FixedDiv(123, 1));
+
+  MemRandomize(reinterpret_cast<uint8_t*>(&num[0]), sizeof(num));
+  MemRandomize(reinterpret_cast<uint8_t*>(&div[0]), sizeof(div));
+  for (int j = 0; j < 1280; ++j) {
+    if (div[j] == 0) {
+      div[j] = 1280;
+    }
+    num[j] &= 0xffff;  // Clamp to avoid divide overflow.
+  }
+  for (int i = 0; i < benchmark_pixels_div1280_; ++i) {
+    for (int j = 0; j < 1280; ++j) {
+      result_opt[j] = libyuv::FixedDiv(num[j], div[j]);
+    }
+  }
+  for (int j = 0; j < 1280; ++j) {
+    result_c[j] = libyuv::FixedDiv_C(num[j], div[j]);
+    EXPECT_NEAR(result_c[j], result_opt[j], 1);
+  }
+}
+
+TEST_F(LibYUVBaseTest, TestFixedDiv_Opt) {
+  int num[1280];
+  int div[1280];
+  int result_opt[1280];
+  int result_c[1280];
+
+  MemRandomize(reinterpret_cast<uint8_t*>(&num[0]), sizeof(num));
+  MemRandomize(reinterpret_cast<uint8_t*>(&div[0]), sizeof(div));
+  for (int j = 0; j < 1280; ++j) {
+    num[j] &= 4095;  // Make numerator smaller.
+    div[j] &= 4095;  // Make divisor smaller.
+    if (div[j] == 0) {
+      div[j] = 1280;
+    }
+  }
+
+  int has_x86 = TestCpuFlag(kCpuHasX86);
+  for (int i = 0; i < benchmark_pixels_div1280_; ++i) {
+    if (has_x86) {
+      for (int j = 0; j < 1280; ++j) {
+        result_opt[j] = libyuv::FixedDiv(num[j], div[j]);
+      }
+    } else {
+      for (int j = 0; j < 1280; ++j) {
+        result_opt[j] = libyuv::FixedDiv_C(num[j], div[j]);
+      }
+    }
+  }
+  for (int j = 0; j < 1280; ++j) {
+    result_c[j] = libyuv::FixedDiv_C(num[j], div[j]);
+    EXPECT_NEAR(result_c[j], result_opt[j], 1);
+  }
+}
+
+TEST_F(LibYUVBaseTest, TestFixedDiv1_Opt) {
+  int num[1280];
+  int div[1280];
+  int result_opt[1280];
+  int result_c[1280];
+
+  MemRandomize(reinterpret_cast<uint8_t*>(&num[0]), sizeof(num));
+  MemRandomize(reinterpret_cast<uint8_t*>(&div[0]), sizeof(div));
+  for (int j = 0; j < 1280; ++j) {
+    num[j] &= 4095;  // Make numerator smaller.
+    div[j] &= 4095;  // Make divisor smaller.
+    if (div[j] <= 1) {
+      div[j] = 1280;
+    }
+  }
+
+  int has_x86 = TestCpuFlag(kCpuHasX86);
+  for (int i = 0; i < benchmark_pixels_div1280_; ++i) {
+    if (has_x86) {
+      for (int j = 0; j < 1280; ++j) {
+        result_opt[j] = libyuv::FixedDiv1(num[j], div[j]);
+      }
+    } else {
+      for (int j = 0; j < 1280; ++j) {
+        result_opt[j] = libyuv::FixedDiv1_C(num[j], div[j]);
+      }
+    }
+  }
+  for (int j = 0; j < 1280; ++j) {
+    result_c[j] = libyuv::FixedDiv1_C(num[j], div[j]);
+    EXPECT_NEAR(result_c[j], result_opt[j], 1);
+  }
+}
+#endif  // ENABLE_ROW_TESTS
+
+}  // namespace libyuv
diff --git a/3rdparty/libyuv/src/unit_test/planar_test.cc b/3rdparty/libyuv/src/unit_test/planar_test.cc
new file mode 100644
index 00000000..42166d0d
--- /dev/null
+++ b/3rdparty/libyuv/src/unit_test/planar_test.cc
@@ -0,0 +1,4436 @@
+/*
+ *  Copyright 2011 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include <math.h>
+#include <stdlib.h>
+#include <time.h>
+
+#include "../unit_test/unit_test.h"
+#include "libyuv/compare.h"
+#include "libyuv/convert.h"
+#include "libyuv/convert_argb.h"
+#include "libyuv/convert_from.h"
+#include "libyuv/convert_from_argb.h"
+#include "libyuv/cpu_id.h"
+#include "libyuv/planar_functions.h"
+#include "libyuv/rotate.h"
+#include "libyuv/scale.h"
+
+#ifdef ENABLE_ROW_TESTS
+// row.h defines SIMD_ALIGNED, overriding unit_test.h
+// TODO(fbarchard): Remove row.h from unittests.  Test public functions.
+#include "libyuv/row.h" /* For ScaleSumSamples_Neon */
+#endif
+
+#if defined(LIBYUV_BIT_EXACT)
+#define EXPECTED_ATTENUATE_DIFF 0
+#else
+#define EXPECTED_ATTENUATE_DIFF 2
+#endif
+
+namespace libyuv {
+
+TEST_F(LibYUVPlanarTest, TestAttenuate) {
+  const int kSize = 1280 * 4;
+  align_buffer_page_end(orig_pixels, kSize);
+  align_buffer_page_end(atten_pixels, kSize);
+  align_buffer_page_end(unatten_pixels, kSize);
+  align_buffer_page_end(atten2_pixels, kSize);
+
+  // Test unattenuation clamps
+  orig_pixels[0 * 4 + 0] = 200u;
+  orig_pixels[0 * 4 + 1] = 129u;
+  orig_pixels[0 * 4 + 2] = 127u;
+  orig_pixels[0 * 4 + 3] = 128u;
+  // Test unattenuation transparent and opaque are unaffected
+  orig_pixels[1 * 4 + 0] = 16u;
+  orig_pixels[1 * 4 + 1] = 64u;
+  orig_pixels[1 * 4 + 2] = 192u;
+  orig_pixels[1 * 4 + 3] = 0u;
+  orig_pixels[2 * 4 + 0] = 16u;
+  orig_pixels[2 * 4 + 1] = 64u;
+  orig_pixels[2 * 4 + 2] = 192u;
+  orig_pixels[2 * 4 + 3] = 255u;
+  orig_pixels[3 * 4 + 0] = 16u;
+  orig_pixels[3 * 4 + 1] = 64u;
+  orig_pixels[3 * 4 + 2] = 192u;
+  orig_pixels[3 * 4 + 3] = 128u;
+  ARGBUnattenuate(orig_pixels, 0, unatten_pixels, 0, 4, 1);
+  EXPECT_EQ(255u, unatten_pixels[0 * 4 + 0]);
+  EXPECT_EQ(255u, unatten_pixels[0 * 4 + 1]);
+  EXPECT_EQ(254u, unatten_pixels[0 * 4 + 2]);
+  EXPECT_EQ(128u, unatten_pixels[0 * 4 + 3]);
+  EXPECT_EQ(0u, unatten_pixels[1 * 4 + 0]);
+  EXPECT_EQ(0u, unatten_pixels[1 * 4 + 1]);
+  EXPECT_EQ(0u, unatten_pixels[1 * 4 + 2]);
+  EXPECT_EQ(0u, unatten_pixels[1 * 4 + 3]);
+  EXPECT_EQ(16u, unatten_pixels[2 * 4 + 0]);
+  EXPECT_EQ(64u, unatten_pixels[2 * 4 + 1]);
+  EXPECT_EQ(192u, unatten_pixels[2 * 4 + 2]);
+  EXPECT_EQ(255u, unatten_pixels[2 * 4 + 3]);
+  EXPECT_EQ(32u, unatten_pixels[3 * 4 + 0]);
+  EXPECT_EQ(128u, unatten_pixels[3 * 4 + 1]);
+  EXPECT_EQ(255u, unatten_pixels[3 * 4 + 2]);
+  EXPECT_EQ(128u, unatten_pixels[3 * 4 + 3]);
+
+  for (int i = 0; i < 1280; ++i) {
+    orig_pixels[i * 4 + 0] = i;
+    orig_pixels[i * 4 + 1] = i / 2;
+    orig_pixels[i * 4 + 2] = i / 3;
+    orig_pixels[i * 4 + 3] = i;
+  }
+  ARGBAttenuate(orig_pixels, 0, atten_pixels, 0, 1280, 1);
+  ARGBUnattenuate(atten_pixels, 0, unatten_pixels, 0, 1280, 1);
+  for (int i = 0; i < benchmark_pixels_div1280_; ++i) {
+    ARGBAttenuate(unatten_pixels, 0, atten2_pixels, 0, 1280, 1);
+  }
+  for (int i = 0; i < 1280; ++i) {
+    EXPECT_NEAR(atten_pixels[i * 4 + 0], atten2_pixels[i * 4 + 0], 2);
+    EXPECT_NEAR(atten_pixels[i * 4 + 1], atten2_pixels[i * 4 + 1], 2);
+    EXPECT_NEAR(atten_pixels[i * 4 + 2], atten2_pixels[i * 4 + 2], 2);
+    EXPECT_NEAR(atten_pixels[i * 4 + 3], atten2_pixels[i * 4 + 3], 2);
+  }
+  // Make sure transparent, 50% and opaque are fully accurate.
+  EXPECT_EQ(0, atten_pixels[0 * 4 + 0]);
+  EXPECT_EQ(0, atten_pixels[0 * 4 + 1]);
+  EXPECT_EQ(0, atten_pixels[0 * 4 + 2]);
+  EXPECT_EQ(0, atten_pixels[0 * 4 + 3]);
+  EXPECT_EQ(64, atten_pixels[128 * 4 + 0]);
+  EXPECT_EQ(32, atten_pixels[128 * 4 + 1]);
+  EXPECT_EQ(21, atten_pixels[128 * 4 + 2]);
+  EXPECT_EQ(128, atten_pixels[128 * 4 + 3]);
+  EXPECT_NEAR(254, atten_pixels[255 * 4 + 0], EXPECTED_ATTENUATE_DIFF);
+  EXPECT_NEAR(127, atten_pixels[255 * 4 + 1], EXPECTED_ATTENUATE_DIFF);
+  EXPECT_NEAR(85, atten_pixels[255 * 4 + 2], EXPECTED_ATTENUATE_DIFF);
+  EXPECT_EQ(255, atten_pixels[255 * 4 + 3]);
+
+  free_aligned_buffer_page_end(atten2_pixels);
+  free_aligned_buffer_page_end(unatten_pixels);
+  free_aligned_buffer_page_end(atten_pixels);
+  free_aligned_buffer_page_end(orig_pixels);
+}
+
+static int TestAttenuateI(int width,
+                          int height,
+                          int benchmark_iterations,
+                          int disable_cpu_flags,
+                          int benchmark_cpu_info,
+                          int invert,
+                          int off) {
+  if (width < 1) {
+    width = 1;
+  }
+  const int kBpp = 4;
+  const int kStride = width * kBpp;
+  align_buffer_page_end(src_argb, kStride * height + off);
+  align_buffer_page_end(dst_argb_c, kStride * height);
+  align_buffer_page_end(dst_argb_opt, kStride * height);
+  for (int i = 0; i < kStride * height; ++i) {
+    src_argb[i + off] = (fastrand() & 0xff);
+  }
+  memset(dst_argb_c, 0, kStride * height);
+  memset(dst_argb_opt, 0, kStride * height);
+
+  MaskCpuFlags(disable_cpu_flags);
+  ARGBAttenuate(src_argb + off, kStride, dst_argb_c, kStride, width,
+                invert * height);
+  MaskCpuFlags(benchmark_cpu_info);
+  for (int i = 0; i < benchmark_iterations; ++i) {
+    ARGBAttenuate(src_argb + off, kStride, dst_argb_opt, kStride, width,
+                  invert * height);
+  }
+  int max_diff = 0;
+  for (int i = 0; i < kStride * height; ++i) {
+    int abs_diff = abs(static_cast<int>(dst_argb_c[i]) -
+                       static_cast<int>(dst_argb_opt[i]));
+    if (abs_diff > max_diff) {
+      max_diff = abs_diff;
+    }
+  }
+  free_aligned_buffer_page_end(src_argb);
+  free_aligned_buffer_page_end(dst_argb_c);
+  free_aligned_buffer_page_end(dst_argb_opt);
+  return max_diff;
+}
+
+TEST_F(LibYUVPlanarTest, ARGBAttenuate_Any) {
+  int max_diff = TestAttenuateI(benchmark_width_ + 1, benchmark_height_,
+                                benchmark_iterations_, disable_cpu_flags_,
+                                benchmark_cpu_info_, +1, 0);
+
+  EXPECT_LE(max_diff, EXPECTED_ATTENUATE_DIFF);
+}
+
+TEST_F(LibYUVPlanarTest, ARGBAttenuate_Unaligned) {
+  int max_diff =
+      TestAttenuateI(benchmark_width_, benchmark_height_, benchmark_iterations_,
+                     disable_cpu_flags_, benchmark_cpu_info_, +1, 1);
+  EXPECT_LE(max_diff, EXPECTED_ATTENUATE_DIFF);
+}
+
+TEST_F(LibYUVPlanarTest, ARGBAttenuate_Invert) {
+  int max_diff =
+      TestAttenuateI(benchmark_width_, benchmark_height_, benchmark_iterations_,
+                     disable_cpu_flags_, benchmark_cpu_info_, -1, 0);
+  EXPECT_LE(max_diff, EXPECTED_ATTENUATE_DIFF);
+}
+
+TEST_F(LibYUVPlanarTest, ARGBAttenuate_Opt) {
+  int max_diff =
+      TestAttenuateI(benchmark_width_, benchmark_height_, benchmark_iterations_,
+                     disable_cpu_flags_, benchmark_cpu_info_, +1, 0);
+  EXPECT_LE(max_diff, EXPECTED_ATTENUATE_DIFF);
+}
+
+static int TestUnattenuateI(int width,
+                            int height,
+                            int benchmark_iterations,
+                            int disable_cpu_flags,
+                            int benchmark_cpu_info,
+                            int invert,
+                            int off) {
+  if (width < 1) {
+    width = 1;
+  }
+  const int kBpp = 4;
+  const int kStride = width * kBpp;
+  align_buffer_page_end(src_argb, kStride * height + off);
+  align_buffer_page_end(dst_argb_c, kStride * height);
+  align_buffer_page_end(dst_argb_opt, kStride * height);
+  for (int i = 0; i < kStride * height; ++i) {
+    src_argb[i + off] = (fastrand() & 0xff);
+  }
+  ARGBAttenuate(src_argb + off, kStride, src_argb + off, kStride, width,
+                height);
+  memset(dst_argb_c, 0, kStride * height);
+  memset(dst_argb_opt, 0, kStride * height);
+
+  MaskCpuFlags(disable_cpu_flags);
+  ARGBUnattenuate(src_argb + off, kStride, dst_argb_c, kStride, width,
+                  invert * height);
+  MaskCpuFlags(benchmark_cpu_info);
+  for (int i = 0; i < benchmark_iterations; ++i) {
+    ARGBUnattenuate(src_argb + off, kStride, dst_argb_opt, kStride, width,
+                    invert * height);
+  }
+  int max_diff = 0;
+  for (int i = 0; i < kStride * height; ++i) {
+    int abs_diff = abs(static_cast<int>(dst_argb_c[i]) -
+                       static_cast<int>(dst_argb_opt[i]));
+    if (abs_diff > max_diff) {
+      max_diff = abs_diff;
+    }
+  }
+  free_aligned_buffer_page_end(src_argb);
+  free_aligned_buffer_page_end(dst_argb_c);
+  free_aligned_buffer_page_end(dst_argb_opt);
+  return max_diff;
+}
+
+TEST_F(LibYUVPlanarTest, ARGBUnattenuate_Any) {
+  int max_diff = TestUnattenuateI(benchmark_width_ + 1, benchmark_height_,
+                                  benchmark_iterations_, disable_cpu_flags_,
+                                  benchmark_cpu_info_, +1, 0);
+  EXPECT_LE(max_diff, EXPECTED_ATTENUATE_DIFF);
+}
+
+TEST_F(LibYUVPlanarTest, ARGBUnattenuate_Unaligned) {
+  int max_diff = TestUnattenuateI(benchmark_width_, benchmark_height_,
+                                  benchmark_iterations_, disable_cpu_flags_,
+                                  benchmark_cpu_info_, +1, 1);
+  EXPECT_LE(max_diff, EXPECTED_ATTENUATE_DIFF);
+}
+
+TEST_F(LibYUVPlanarTest, ARGBUnattenuate_Invert) {
+  int max_diff = TestUnattenuateI(benchmark_width_, benchmark_height_,
+                                  benchmark_iterations_, disable_cpu_flags_,
+                                  benchmark_cpu_info_, -1, 0);
+  EXPECT_LE(max_diff, EXPECTED_ATTENUATE_DIFF);
+}
+
+TEST_F(LibYUVPlanarTest, ARGBUnattenuate_Opt) {
+  int max_diff = TestUnattenuateI(benchmark_width_, benchmark_height_,
+                                  benchmark_iterations_, disable_cpu_flags_,
+                                  benchmark_cpu_info_, +1, 0);
+  EXPECT_LE(max_diff, EXPECTED_ATTENUATE_DIFF);
+}
+
+TEST_F(LibYUVPlanarTest, TestARGBComputeCumulativeSum) {
+  SIMD_ALIGNED(uint8_t orig_pixels[16][16][4]);
+  SIMD_ALIGNED(int32_t added_pixels[16][16][4]);
+
+  for (int y = 0; y < 16; ++y) {
+    for (int x = 0; x < 16; ++x) {
+      orig_pixels[y][x][0] = 1u;
+      orig_pixels[y][x][1] = 2u;
+      orig_pixels[y][x][2] = 3u;
+      orig_pixels[y][x][3] = 255u;
+    }
+  }
+
+  ARGBComputeCumulativeSum(&orig_pixels[0][0][0], 16 * 4,
+                           &added_pixels[0][0][0], 16 * 4, 16, 16);
+
+  for (int y = 0; y < 16; ++y) {
+    for (int x = 0; x < 16; ++x) {
+      EXPECT_EQ((x + 1) * (y + 1), added_pixels[y][x][0]);
+      EXPECT_EQ((x + 1) * (y + 1) * 2, added_pixels[y][x][1]);
+      EXPECT_EQ((x + 1) * (y + 1) * 3, added_pixels[y][x][2]);
+      EXPECT_EQ((x + 1) * (y + 1) * 255, added_pixels[y][x][3]);
+    }
+  }
+}
+
+// near is for legacy platforms.
+TEST_F(LibYUVPlanarTest, TestARGBGray) {
+  SIMD_ALIGNED(uint8_t orig_pixels[1280][4]);
+  memset(orig_pixels, 0, sizeof(orig_pixels));
+
+  // Test blue
+  orig_pixels[0][0] = 255u;
+  orig_pixels[0][1] = 0u;
+  orig_pixels[0][2] = 0u;
+  orig_pixels[0][3] = 128u;
+  // Test green
+  orig_pixels[1][0] = 0u;
+  orig_pixels[1][1] = 255u;
+  orig_pixels[1][2] = 0u;
+  orig_pixels[1][3] = 0u;
+  // Test red
+  orig_pixels[2][0] = 0u;
+  orig_pixels[2][1] = 0u;
+  orig_pixels[2][2] = 255u;
+  orig_pixels[2][3] = 255u;
+  // Test black
+  orig_pixels[3][0] = 0u;
+  orig_pixels[3][1] = 0u;
+  orig_pixels[3][2] = 0u;
+  orig_pixels[3][3] = 255u;
+  // Test white
+  orig_pixels[4][0] = 255u;
+  orig_pixels[4][1] = 255u;
+  orig_pixels[4][2] = 255u;
+  orig_pixels[4][3] = 255u;
+  // Test color
+  orig_pixels[5][0] = 16u;
+  orig_pixels[5][1] = 64u;
+  orig_pixels[5][2] = 192u;
+  orig_pixels[5][3] = 224u;
+  // Do 16 to test asm version.
+  ARGBGray(&orig_pixels[0][0], 0, 0, 0, 16, 1);
+  EXPECT_NEAR(29u, orig_pixels[0][0], 1);
+  EXPECT_NEAR(29u, orig_pixels[0][1], 1);
+  EXPECT_NEAR(29u, orig_pixels[0][2], 1);
+  EXPECT_EQ(128u, orig_pixels[0][3]);
+  EXPECT_EQ(149u, orig_pixels[1][0]);
+  EXPECT_EQ(149u, orig_pixels[1][1]);
+  EXPECT_EQ(149u, orig_pixels[1][2]);
+  EXPECT_EQ(0u, orig_pixels[1][3]);
+  EXPECT_NEAR(77u, orig_pixels[2][0], 1);
+  EXPECT_NEAR(77u, orig_pixels[2][1], 1);
+  EXPECT_NEAR(77u, orig_pixels[2][2], 1);
+  EXPECT_EQ(255u, orig_pixels[2][3]);
+  EXPECT_EQ(0u, orig_pixels[3][0]);
+  EXPECT_EQ(0u, orig_pixels[3][1]);
+  EXPECT_EQ(0u, orig_pixels[3][2]);
+  EXPECT_EQ(255u, orig_pixels[3][3]);
+  EXPECT_EQ(255u, orig_pixels[4][0]);
+  EXPECT_EQ(255u, orig_pixels[4][1]);
+  EXPECT_EQ(255u, orig_pixels[4][2]);
+  EXPECT_EQ(255u, orig_pixels[4][3]);
+  EXPECT_NEAR(97u, orig_pixels[5][0], 1);
+  EXPECT_NEAR(97u, orig_pixels[5][1], 1);
+  EXPECT_NEAR(97u, orig_pixels[5][2], 1);
+  EXPECT_EQ(224u, orig_pixels[5][3]);
+  for (int i = 0; i < 1280; ++i) {
+    orig_pixels[i][0] = i;
+    orig_pixels[i][1] = i / 2;
+    orig_pixels[i][2] = i / 3;
+    orig_pixels[i][3] = i;
+  }
+  for (int i = 0; i < benchmark_pixels_div1280_; ++i) {
+    ARGBGray(&orig_pixels[0][0], 0, 0, 0, 1280, 1);
+  }
+}
+
+TEST_F(LibYUVPlanarTest, TestARGBGrayTo) {
+  SIMD_ALIGNED(uint8_t orig_pixels[1280][4]);
+  SIMD_ALIGNED(uint8_t gray_pixels[1280][4]);
+  memset(orig_pixels, 0, sizeof(orig_pixels));
+
+  // Test blue
+  orig_pixels[0][0] = 255u;
+  orig_pixels[0][1] = 0u;
+  orig_pixels[0][2] = 0u;
+  orig_pixels[0][3] = 128u;
+  // Test green
+  orig_pixels[1][0] = 0u;
+  orig_pixels[1][1] = 255u;
+  orig_pixels[1][2] = 0u;
+  orig_pixels[1][3] = 0u;
+  // Test red
+  orig_pixels[2][0] = 0u;
+  orig_pixels[2][1] = 0u;
+  orig_pixels[2][2] = 255u;
+  orig_pixels[2][3] = 255u;
+  // Test black
+  orig_pixels[3][0] = 0u;
+  orig_pixels[3][1] = 0u;
+  orig_pixels[3][2] = 0u;
+  orig_pixels[3][3] = 255u;
+  // Test white
+  orig_pixels[4][0] = 255u;
+  orig_pixels[4][1] = 255u;
+  orig_pixels[4][2] = 255u;
+  orig_pixels[4][3] = 255u;
+  // Test color
+  orig_pixels[5][0] = 16u;
+  orig_pixels[5][1] = 64u;
+  orig_pixels[5][2] = 192u;
+  orig_pixels[5][3] = 224u;
+  // Do 16 to test asm version.
+  ARGBGrayTo(&orig_pixels[0][0], 0, &gray_pixels[0][0], 0, 16, 1);
+  EXPECT_NEAR(30u, gray_pixels[0][0], 1);
+  EXPECT_NEAR(30u, gray_pixels[0][1], 1);
+  EXPECT_NEAR(30u, gray_pixels[0][2], 1);
+  EXPECT_NEAR(128u, gray_pixels[0][3], 1);
+  EXPECT_NEAR(149u, gray_pixels[1][0], 1);
+  EXPECT_NEAR(149u, gray_pixels[1][1], 1);
+  EXPECT_NEAR(149u, gray_pixels[1][2], 1);
+  EXPECT_NEAR(0u, gray_pixels[1][3], 1);
+  EXPECT_NEAR(76u, gray_pixels[2][0], 1);
+  EXPECT_NEAR(76u, gray_pixels[2][1], 1);
+  EXPECT_NEAR(76u, gray_pixels[2][2], 1);
+  EXPECT_NEAR(255u, gray_pixels[2][3], 1);
+  EXPECT_NEAR(0u, gray_pixels[3][0], 1);
+  EXPECT_NEAR(0u, gray_pixels[3][1], 1);
+  EXPECT_NEAR(0u, gray_pixels[3][2], 1);
+  EXPECT_NEAR(255u, gray_pixels[3][3], 1);
+  EXPECT_NEAR(255u, gray_pixels[4][0], 1);
+  EXPECT_NEAR(255u, gray_pixels[4][1], 1);
+  EXPECT_NEAR(255u, gray_pixels[4][2], 1);
+  EXPECT_NEAR(255u, gray_pixels[4][3], 1);
+  EXPECT_NEAR(96u, gray_pixels[5][0], 1);
+  EXPECT_NEAR(96u, gray_pixels[5][1], 1);
+  EXPECT_NEAR(96u, gray_pixels[5][2], 1);
+  EXPECT_NEAR(224u, gray_pixels[5][3], 1);
+  for (int i = 0; i < 1280; ++i) {
+    orig_pixels[i][0] = i;
+    orig_pixels[i][1] = i / 2;
+    orig_pixels[i][2] = i / 3;
+    orig_pixels[i][3] = i;
+  }
+  for (int i = 0; i < benchmark_pixels_div1280_; ++i) {
+    ARGBGrayTo(&orig_pixels[0][0], 0, &gray_pixels[0][0], 0, 1280, 1);
+  }
+
+  for (int i = 0; i < 256; ++i) {
+    orig_pixels[i][0] = i;
+    orig_pixels[i][1] = i;
+    orig_pixels[i][2] = i;
+    orig_pixels[i][3] = i;
+  }
+  ARGBGray(&orig_pixels[0][0], 0, 0, 0, 256, 1);
+  for (int i = 0; i < 256; ++i) {
+    EXPECT_EQ(i, orig_pixels[i][0]);
+    EXPECT_EQ(i, orig_pixels[i][1]);
+    EXPECT_EQ(i, orig_pixels[i][2]);
+    EXPECT_EQ(i, orig_pixels[i][3]);
+  }
+}
+
+TEST_F(LibYUVPlanarTest, TestARGBSepia) {
+  SIMD_ALIGNED(uint8_t orig_pixels[1280][4]);
+  memset(orig_pixels, 0, sizeof(orig_pixels));
+
+  // Test blue
+  orig_pixels[0][0] = 255u;
+  orig_pixels[0][1] = 0u;
+  orig_pixels[0][2] = 0u;
+  orig_pixels[0][3] = 128u;
+  // Test green
+  orig_pixels[1][0] = 0u;
+  orig_pixels[1][1] = 255u;
+  orig_pixels[1][2] = 0u;
+  orig_pixels[1][3] = 0u;
+  // Test red
+  orig_pixels[2][0] = 0u;
+  orig_pixels[2][1] = 0u;
+  orig_pixels[2][2] = 255u;
+  orig_pixels[2][3] = 255u;
+  // Test black
+  orig_pixels[3][0] = 0u;
+  orig_pixels[3][1] = 0u;
+  orig_pixels[3][2] = 0u;
+  orig_pixels[3][3] = 255u;
+  // Test white
+  orig_pixels[4][0] = 255u;
+  orig_pixels[4][1] = 255u;
+  orig_pixels[4][2] = 255u;
+  orig_pixels[4][3] = 255u;
+  // Test color
+  orig_pixels[5][0] = 16u;
+  orig_pixels[5][1] = 64u;
+  orig_pixels[5][2] = 192u;
+  orig_pixels[5][3] = 224u;
+  // Do 16 to test asm version.
+  ARGBSepia(&orig_pixels[0][0], 0, 0, 0, 16, 1);
+  EXPECT_EQ(33u, orig_pixels[0][0]);
+  EXPECT_EQ(43u, orig_pixels[0][1]);
+  EXPECT_EQ(47u, orig_pixels[0][2]);
+  EXPECT_EQ(128u, orig_pixels[0][3]);
+  EXPECT_EQ(135u, orig_pixels[1][0]);
+  EXPECT_EQ(175u, orig_pixels[1][1]);
+  EXPECT_EQ(195u, orig_pixels[1][2]);
+  EXPECT_EQ(0u, orig_pixels[1][3]);
+  EXPECT_EQ(69u, orig_pixels[2][0]);
+  EXPECT_EQ(89u, orig_pixels[2][1]);
+  EXPECT_EQ(99u, orig_pixels[2][2]);
+  EXPECT_EQ(255u, orig_pixels[2][3]);
+  EXPECT_EQ(0u, orig_pixels[3][0]);
+  EXPECT_EQ(0u, orig_pixels[3][1]);
+  EXPECT_EQ(0u, orig_pixels[3][2]);
+  EXPECT_EQ(255u, orig_pixels[3][3]);
+  EXPECT_EQ(239u, orig_pixels[4][0]);
+  EXPECT_EQ(255u, orig_pixels[4][1]);
+  EXPECT_EQ(255u, orig_pixels[4][2]);
+  EXPECT_EQ(255u, orig_pixels[4][3]);
+  EXPECT_EQ(88u, orig_pixels[5][0]);
+  EXPECT_EQ(114u, orig_pixels[5][1]);
+  EXPECT_EQ(127u, orig_pixels[5][2]);
+  EXPECT_EQ(224u, orig_pixels[5][3]);
+
+  for (int i = 0; i < 1280; ++i) {
+    orig_pixels[i][0] = i;
+    orig_pixels[i][1] = i / 2;
+    orig_pixels[i][2] = i / 3;
+    orig_pixels[i][3] = i;
+  }
+  for (int i = 0; i < benchmark_pixels_div1280_; ++i) {
+    ARGBSepia(&orig_pixels[0][0], 0, 0, 0, 1280, 1);
+  }
+}
+
+TEST_F(LibYUVPlanarTest, TestARGBColorMatrix) {
+  SIMD_ALIGNED(uint8_t orig_pixels[1280][4]);
+  SIMD_ALIGNED(uint8_t dst_pixels_opt[1280][4]);
+  SIMD_ALIGNED(uint8_t dst_pixels_c[1280][4]);
+
+  // Matrix for Sepia.
+  SIMD_ALIGNED(static const int8_t kRGBToSepia[]) = {
+      17 / 2, 68 / 2, 35 / 2, 0, 22 / 2, 88 / 2, 45 / 2, 0,
+      24 / 2, 98 / 2, 50 / 2, 0, 0,      0,      0,      64,  // Copy alpha.
+  };
+  memset(orig_pixels, 0, sizeof(orig_pixels));
+
+  // Test blue
+  orig_pixels[0][0] = 255u;
+  orig_pixels[0][1] = 0u;
+  orig_pixels[0][2] = 0u;
+  orig_pixels[0][3] = 128u;
+  // Test green
+  orig_pixels[1][0] = 0u;
+  orig_pixels[1][1] = 255u;
+  orig_pixels[1][2] = 0u;
+  orig_pixels[1][3] = 0u;
+  // Test red
+  orig_pixels[2][0] = 0u;
+  orig_pixels[2][1] = 0u;
+  orig_pixels[2][2] = 255u;
+  orig_pixels[2][3] = 255u;
+  // Test color
+  orig_pixels[3][0] = 16u;
+  orig_pixels[3][1] = 64u;
+  orig_pixels[3][2] = 192u;
+  orig_pixels[3][3] = 224u;
+  // Do 16 to test asm version.
+  ARGBColorMatrix(&orig_pixels[0][0], 0, &dst_pixels_opt[0][0], 0,
+                  &kRGBToSepia[0], 16, 1);
+  EXPECT_EQ(31u, dst_pixels_opt[0][0]);
+  EXPECT_EQ(43u, dst_pixels_opt[0][1]);
+  EXPECT_EQ(47u, dst_pixels_opt[0][2]);
+  EXPECT_EQ(128u, dst_pixels_opt[0][3]);
+  EXPECT_EQ(135u, dst_pixels_opt[1][0]);
+  EXPECT_EQ(175u, dst_pixels_opt[1][1]);
+  EXPECT_EQ(195u, dst_pixels_opt[1][2]);
+  EXPECT_EQ(0u, dst_pixels_opt[1][3]);
+  EXPECT_EQ(67u, dst_pixels_opt[2][0]);
+  EXPECT_EQ(87u, dst_pixels_opt[2][1]);
+  EXPECT_EQ(99u, dst_pixels_opt[2][2]);
+  EXPECT_EQ(255u, dst_pixels_opt[2][3]);
+  EXPECT_EQ(87u, dst_pixels_opt[3][0]);
+  EXPECT_EQ(112u, dst_pixels_opt[3][1]);
+  EXPECT_EQ(127u, dst_pixels_opt[3][2]);
+  EXPECT_EQ(224u, dst_pixels_opt[3][3]);
+
+  for (int i = 0; i < 1280; ++i) {
+    orig_pixels[i][0] = i;
+    orig_pixels[i][1] = i / 2;
+    orig_pixels[i][2] = i / 3;
+    orig_pixels[i][3] = i;
+  }
+  MaskCpuFlags(disable_cpu_flags_);
+  ARGBColorMatrix(&orig_pixels[0][0], 0, &dst_pixels_c[0][0], 0,
+                  &kRGBToSepia[0], 1280, 1);
+  MaskCpuFlags(benchmark_cpu_info_);
+
+  for (int i = 0; i < benchmark_pixels_div1280_; ++i) {
+    ARGBColorMatrix(&orig_pixels[0][0], 0, &dst_pixels_opt[0][0], 0,
+                    &kRGBToSepia[0], 1280, 1);
+  }
+
+  for (int i = 0; i < 1280; ++i) {
+    EXPECT_EQ(dst_pixels_c[i][0], dst_pixels_opt[i][0]);
+    EXPECT_EQ(dst_pixels_c[i][1], dst_pixels_opt[i][1]);
+    EXPECT_EQ(dst_pixels_c[i][2], dst_pixels_opt[i][2]);
+    EXPECT_EQ(dst_pixels_c[i][3], dst_pixels_opt[i][3]);
+  }
+}
+
+TEST_F(LibYUVPlanarTest, TestRGBColorMatrix) {
+  SIMD_ALIGNED(uint8_t orig_pixels[1280][4]);
+
+  // Matrix for Sepia.
+  SIMD_ALIGNED(static const int8_t kRGBToSepia[]) = {
+      17, 68, 35, 0, 22, 88, 45, 0,
+      24, 98, 50, 0, 0,  0,  0,  0,  // Unused but makes matrix 16 bytes.
+  };
+  memset(orig_pixels, 0, sizeof(orig_pixels));
+
+  // Test blue
+  orig_pixels[0][0] = 255u;
+  orig_pixels[0][1] = 0u;
+  orig_pixels[0][2] = 0u;
+  orig_pixels[0][3] = 128u;
+  // Test green
+  orig_pixels[1][0] = 0u;
+  orig_pixels[1][1] = 255u;
+  orig_pixels[1][2] = 0u;
+  orig_pixels[1][3] = 0u;
+  // Test red
+  orig_pixels[2][0] = 0u;
+  orig_pixels[2][1] = 0u;
+  orig_pixels[2][2] = 255u;
+  orig_pixels[2][3] = 255u;
+  // Test color
+  orig_pixels[3][0] = 16u;
+  orig_pixels[3][1] = 64u;
+  orig_pixels[3][2] = 192u;
+  orig_pixels[3][3] = 224u;
+  // Do 16 to test asm version.
+  RGBColorMatrix(&orig_pixels[0][0], 0, &kRGBToSepia[0], 0, 0, 16, 1);
+  EXPECT_EQ(31u, orig_pixels[0][0]);
+  EXPECT_EQ(43u, orig_pixels[0][1]);
+  EXPECT_EQ(47u, orig_pixels[0][2]);
+  EXPECT_EQ(128u, orig_pixels[0][3]);
+  EXPECT_EQ(135u, orig_pixels[1][0]);
+  EXPECT_EQ(175u, orig_pixels[1][1]);
+  EXPECT_EQ(195u, orig_pixels[1][2]);
+  EXPECT_EQ(0u, orig_pixels[1][3]);
+  EXPECT_EQ(67u, orig_pixels[2][0]);
+  EXPECT_EQ(87u, orig_pixels[2][1]);
+  EXPECT_EQ(99u, orig_pixels[2][2]);
+  EXPECT_EQ(255u, orig_pixels[2][3]);
+  EXPECT_EQ(87u, orig_pixels[3][0]);
+  EXPECT_EQ(112u, orig_pixels[3][1]);
+  EXPECT_EQ(127u, orig_pixels[3][2]);
+  EXPECT_EQ(224u, orig_pixels[3][3]);
+
+  for (int i = 0; i < 1280; ++i) {
+    orig_pixels[i][0] = i;
+    orig_pixels[i][1] = i / 2;
+    orig_pixels[i][2] = i / 3;
+    orig_pixels[i][3] = i;
+  }
+  for (int i = 0; i < benchmark_pixels_div1280_; ++i) {
+    RGBColorMatrix(&orig_pixels[0][0], 0, &kRGBToSepia[0], 0, 0, 1280, 1);
+  }
+}
+
+TEST_F(LibYUVPlanarTest, TestARGBColorTable) {
+  SIMD_ALIGNED(uint8_t orig_pixels[1280][4]);
+  memset(orig_pixels, 0, sizeof(orig_pixels));
+
+  // Matrix for Sepia.
+  static const uint8_t kARGBTable[256 * 4] = {
+      1u, 2u, 3u, 4u, 5u, 6u, 7u, 8u, 9u, 10u, 11u, 12u, 13u, 14u, 15u, 16u,
+  };
+
+  orig_pixels[0][0] = 0u;
+  orig_pixels[0][1] = 0u;
+  orig_pixels[0][2] = 0u;
+  orig_pixels[0][3] = 0u;
+  orig_pixels[1][0] = 1u;
+  orig_pixels[1][1] = 1u;
+  orig_pixels[1][2] = 1u;
+  orig_pixels[1][3] = 1u;
+  orig_pixels[2][0] = 2u;
+  orig_pixels[2][1] = 2u;
+  orig_pixels[2][2] = 2u;
+  orig_pixels[2][3] = 2u;
+  orig_pixels[3][0] = 0u;
+  orig_pixels[3][1] = 1u;
+  orig_pixels[3][2] = 2u;
+  orig_pixels[3][3] = 3u;
+  // Do 16 to test asm version.
+  ARGBColorTable(&orig_pixels[0][0], 0, &kARGBTable[0], 0, 0, 16, 1);
+  EXPECT_EQ(1u, orig_pixels[0][0]);
+  EXPECT_EQ(2u, orig_pixels[0][1]);
+  EXPECT_EQ(3u, orig_pixels[0][2]);
+  EXPECT_EQ(4u, orig_pixels[0][3]);
+  EXPECT_EQ(5u, orig_pixels[1][0]);
+  EXPECT_EQ(6u, orig_pixels[1][1]);
+  EXPECT_EQ(7u, orig_pixels[1][2]);
+  EXPECT_EQ(8u, orig_pixels[1][3]);
+  EXPECT_EQ(9u, orig_pixels[2][0]);
+  EXPECT_EQ(10u, orig_pixels[2][1]);
+  EXPECT_EQ(11u, orig_pixels[2][2]);
+  EXPECT_EQ(12u, orig_pixels[2][3]);
+  EXPECT_EQ(1u, orig_pixels[3][0]);
+  EXPECT_EQ(6u, orig_pixels[3][1]);
+  EXPECT_EQ(11u, orig_pixels[3][2]);
+  EXPECT_EQ(16u, orig_pixels[3][3]);
+
+  for (int i = 0; i < 1280; ++i) {
+    orig_pixels[i][0] = i;
+    orig_pixels[i][1] = i / 2;
+    orig_pixels[i][2] = i / 3;
+    orig_pixels[i][3] = i;
+  }
+  for (int i = 0; i < benchmark_pixels_div1280_; ++i) {
+    ARGBColorTable(&orig_pixels[0][0], 0, &kARGBTable[0], 0, 0, 1280, 1);
+  }
+}
+
+// Same as TestARGBColorTable except alpha does not change.
+TEST_F(LibYUVPlanarTest, TestRGBColorTable) {
+  SIMD_ALIGNED(uint8_t orig_pixels[1280][4]);
+  memset(orig_pixels, 0, sizeof(orig_pixels));
+
+  // Matrix for Sepia.
+  static const uint8_t kARGBTable[256 * 4] = {
+      1u, 2u, 3u, 4u, 5u, 6u, 7u, 8u, 9u, 10u, 11u, 12u, 13u, 14u, 15u, 16u,
+  };
+
+  orig_pixels[0][0] = 0u;
+  orig_pixels[0][1] = 0u;
+  orig_pixels[0][2] = 0u;
+  orig_pixels[0][3] = 0u;
+  orig_pixels[1][0] = 1u;
+  orig_pixels[1][1] = 1u;
+  orig_pixels[1][2] = 1u;
+  orig_pixels[1][3] = 1u;
+  orig_pixels[2][0] = 2u;
+  orig_pixels[2][1] = 2u;
+  orig_pixels[2][2] = 2u;
+  orig_pixels[2][3] = 2u;
+  orig_pixels[3][0] = 0u;
+  orig_pixels[3][1] = 1u;
+  orig_pixels[3][2] = 2u;
+  orig_pixels[3][3] = 3u;
+  // Do 16 to test asm version.
+  RGBColorTable(&orig_pixels[0][0], 0, &kARGBTable[0], 0, 0, 16, 1);
+  EXPECT_EQ(1u, orig_pixels[0][0]);
+  EXPECT_EQ(2u, orig_pixels[0][1]);
+  EXPECT_EQ(3u, orig_pixels[0][2]);
+  EXPECT_EQ(0u, orig_pixels[0][3]);  // Alpha unchanged.
+  EXPECT_EQ(5u, orig_pixels[1][0]);
+  EXPECT_EQ(6u, orig_pixels[1][1]);
+  EXPECT_EQ(7u, orig_pixels[1][2]);
+  EXPECT_EQ(1u, orig_pixels[1][3]);  // Alpha unchanged.
+  EXPECT_EQ(9u, orig_pixels[2][0]);
+  EXPECT_EQ(10u, orig_pixels[2][1]);
+  EXPECT_EQ(11u, orig_pixels[2][2]);
+  EXPECT_EQ(2u, orig_pixels[2][3]);  // Alpha unchanged.
+  EXPECT_EQ(1u, orig_pixels[3][0]);
+  EXPECT_EQ(6u, orig_pixels[3][1]);
+  EXPECT_EQ(11u, orig_pixels[3][2]);
+  EXPECT_EQ(3u, orig_pixels[3][3]);  // Alpha unchanged.
+
+  for (int i = 0; i < 1280; ++i) {
+    orig_pixels[i][0] = i;
+    orig_pixels[i][1] = i / 2;
+    orig_pixels[i][2] = i / 3;
+    orig_pixels[i][3] = i;
+  }
+  for (int i = 0; i < benchmark_pixels_div1280_; ++i) {
+    RGBColorTable(&orig_pixels[0][0], 0, &kARGBTable[0], 0, 0, 1280, 1);
+  }
+}
+
+TEST_F(LibYUVPlanarTest, TestARGBQuantize) {
+  SIMD_ALIGNED(uint8_t orig_pixels[1280][4]);
+
+  for (int i = 0; i < 1280; ++i) {
+    orig_pixels[i][0] = i;
+    orig_pixels[i][1] = i / 2;
+    orig_pixels[i][2] = i / 3;
+    orig_pixels[i][3] = i;
+  }
+  ARGBQuantize(&orig_pixels[0][0], 0, (65536 + (8 / 2)) / 8, 8, 8 / 2, 0, 0,
+               1280, 1);
+
+  for (int i = 0; i < 1280; ++i) {
+    EXPECT_EQ((i / 8 * 8 + 8 / 2) & 255, orig_pixels[i][0]);
+    EXPECT_EQ((i / 2 / 8 * 8 + 8 / 2) & 255, orig_pixels[i][1]);
+    EXPECT_EQ((i / 3 / 8 * 8 + 8 / 2) & 255, orig_pixels[i][2]);
+    EXPECT_EQ(i & 255, orig_pixels[i][3]);
+  }
+  for (int i = 0; i < benchmark_pixels_div1280_; ++i) {
+    ARGBQuantize(&orig_pixels[0][0], 0, (65536 + (8 / 2)) / 8, 8, 8 / 2, 0, 0,
+                 1280, 1);
+  }
+}
+
+TEST_F(LibYUVPlanarTest, ARGBMirror_Opt) {
+  align_buffer_page_end(src_pixels, benchmark_width_ * benchmark_height_ * 4);
+  align_buffer_page_end(dst_pixels_opt,
+                        benchmark_width_ * benchmark_height_ * 4);
+  align_buffer_page_end(dst_pixels_c, benchmark_width_ * benchmark_height_ * 4);
+
+  MemRandomize(src_pixels, benchmark_width_ * benchmark_height_ * 4);
+  MaskCpuFlags(disable_cpu_flags_);
+  ARGBMirror(src_pixels, benchmark_width_ * 4, dst_pixels_c,
+             benchmark_width_ * 4, benchmark_width_, benchmark_height_);
+  MaskCpuFlags(benchmark_cpu_info_);
+
+  for (int i = 0; i < benchmark_iterations_; ++i) {
+    ARGBMirror(src_pixels, benchmark_width_ * 4, dst_pixels_opt,
+               benchmark_width_ * 4, benchmark_width_, benchmark_height_);
+  }
+  for (int i = 0; i < benchmark_width_ * benchmark_height_ * 4; ++i) {
+    EXPECT_EQ(dst_pixels_c[i], dst_pixels_opt[i]);
+  }
+  free_aligned_buffer_page_end(src_pixels);
+  free_aligned_buffer_page_end(dst_pixels_opt);
+  free_aligned_buffer_page_end(dst_pixels_c);
+}
+
+TEST_F(LibYUVPlanarTest, MirrorPlane_Opt) {
+  align_buffer_page_end(src_pixels, benchmark_width_ * benchmark_height_);
+  align_buffer_page_end(dst_pixels_opt, benchmark_width_ * benchmark_height_);
+  align_buffer_page_end(dst_pixels_c, benchmark_width_ * benchmark_height_);
+
+  MemRandomize(src_pixels, benchmark_width_ * benchmark_height_);
+  MaskCpuFlags(disable_cpu_flags_);
+  MirrorPlane(src_pixels, benchmark_width_, dst_pixels_c, benchmark_width_,
+              benchmark_width_, benchmark_height_);
+  MaskCpuFlags(benchmark_cpu_info_);
+
+  for (int i = 0; i < benchmark_iterations_; ++i) {
+    MirrorPlane(src_pixels, benchmark_width_, dst_pixels_opt, benchmark_width_,
+                benchmark_width_, benchmark_height_);
+  }
+  for (int i = 0; i < benchmark_width_ * benchmark_height_; ++i) {
+    EXPECT_EQ(dst_pixels_c[i], dst_pixels_opt[i]);
+  }
+  free_aligned_buffer_page_end(src_pixels);
+  free_aligned_buffer_page_end(dst_pixels_opt);
+  free_aligned_buffer_page_end(dst_pixels_c);
+}
+
+TEST_F(LibYUVPlanarTest, MirrorUVPlane_Opt) {
+  align_buffer_page_end(src_pixels, benchmark_width_ * benchmark_height_ * 2);
+  align_buffer_page_end(dst_pixels_opt,
+                        benchmark_width_ * benchmark_height_ * 2);
+  align_buffer_page_end(dst_pixels_c, benchmark_width_ * benchmark_height_ * 2);
+
+  MemRandomize(src_pixels, benchmark_width_ * benchmark_height_ * 2);
+  MaskCpuFlags(disable_cpu_flags_);
+  MirrorUVPlane(src_pixels, benchmark_width_ * 2, dst_pixels_c,
+                benchmark_width_ * 2, benchmark_width_, benchmark_height_);
+  MaskCpuFlags(benchmark_cpu_info_);
+
+  for (int i = 0; i < benchmark_iterations_; ++i) {
+    MirrorUVPlane(src_pixels, benchmark_width_ * 2, dst_pixels_opt,
+                  benchmark_width_ * 2, benchmark_width_, benchmark_height_);
+  }
+  for (int i = 0; i < benchmark_width_ * benchmark_height_ * 2; ++i) {
+    EXPECT_EQ(dst_pixels_c[i], dst_pixels_opt[i]);
+  }
+  free_aligned_buffer_page_end(src_pixels);
+  free_aligned_buffer_page_end(dst_pixels_opt);
+  free_aligned_buffer_page_end(dst_pixels_c);
+}
+
+TEST_F(LibYUVPlanarTest, TestShade) {
+  SIMD_ALIGNED(uint8_t orig_pixels[1280][4]);
+  SIMD_ALIGNED(uint8_t shade_pixels[1280][4]);
+  memset(orig_pixels, 0, sizeof(orig_pixels));
+
+  orig_pixels[0][0] = 10u;
+  orig_pixels[0][1] = 20u;
+  orig_pixels[0][2] = 40u;
+  orig_pixels[0][3] = 80u;
+  orig_pixels[1][0] = 0u;
+  orig_pixels[1][1] = 0u;
+  orig_pixels[1][2] = 0u;
+  orig_pixels[1][3] = 255u;
+  orig_pixels[2][0] = 0u;
+  orig_pixels[2][1] = 0u;
+  orig_pixels[2][2] = 0u;
+  orig_pixels[2][3] = 0u;
+  orig_pixels[3][0] = 0u;
+  orig_pixels[3][1] = 0u;
+  orig_pixels[3][2] = 0u;
+  orig_pixels[3][3] = 0u;
+  // Do 8 pixels to allow opt version to be used.
+  ARGBShade(&orig_pixels[0][0], 0, &shade_pixels[0][0], 0, 8, 1, 0x80ffffff);
+  EXPECT_EQ(10u, shade_pixels[0][0]);
+  EXPECT_EQ(20u, shade_pixels[0][1]);
+  EXPECT_EQ(40u, shade_pixels[0][2]);
+  EXPECT_EQ(40u, shade_pixels[0][3]);
+  EXPECT_EQ(0u, shade_pixels[1][0]);
+  EXPECT_EQ(0u, shade_pixels[1][1]);
+  EXPECT_EQ(0u, shade_pixels[1][2]);
+  EXPECT_EQ(128u, shade_pixels[1][3]);
+  EXPECT_EQ(0u, shade_pixels[2][0]);
+  EXPECT_EQ(0u, shade_pixels[2][1]);
+  EXPECT_EQ(0u, shade_pixels[2][2]);
+  EXPECT_EQ(0u, shade_pixels[2][3]);
+  EXPECT_EQ(0u, shade_pixels[3][0]);
+  EXPECT_EQ(0u, shade_pixels[3][1]);
+  EXPECT_EQ(0u, shade_pixels[3][2]);
+  EXPECT_EQ(0u, shade_pixels[3][3]);
+
+  ARGBShade(&orig_pixels[0][0], 0, &shade_pixels[0][0], 0, 8, 1, 0x80808080);
+  EXPECT_EQ(5u, shade_pixels[0][0]);
+  EXPECT_EQ(10u, shade_pixels[0][1]);
+  EXPECT_EQ(20u, shade_pixels[0][2]);
+  EXPECT_EQ(40u, shade_pixels[0][3]);
+
+  ARGBShade(&orig_pixels[0][0], 0, &shade_pixels[0][0], 0, 8, 1, 0x10204080);
+  EXPECT_EQ(5u, shade_pixels[0][0]);
+  EXPECT_EQ(5u, shade_pixels[0][1]);
+  EXPECT_EQ(5u, shade_pixels[0][2]);
+  EXPECT_EQ(5u, shade_pixels[0][3]);
+
+  for (int i = 0; i < benchmark_pixels_div1280_; ++i) {
+    ARGBShade(&orig_pixels[0][0], 0, &shade_pixels[0][0], 0, 1280, 1,
+              0x80808080);
+  }
+}
+
+TEST_F(LibYUVPlanarTest, TestARGBInterpolate) {
+  SIMD_ALIGNED(uint8_t orig_pixels_0[1280][4]);
+  SIMD_ALIGNED(uint8_t orig_pixels_1[1280][4]);
+  SIMD_ALIGNED(uint8_t interpolate_pixels[1280][4]);
+  memset(orig_pixels_0, 0, sizeof(orig_pixels_0));
+  memset(orig_pixels_1, 0, sizeof(orig_pixels_1));
+
+  orig_pixels_0[0][0] = 16u;
+  orig_pixels_0[0][1] = 32u;
+  orig_pixels_0[0][2] = 64u;
+  orig_pixels_0[0][3] = 128u;
+  orig_pixels_0[1][0] = 0u;
+  orig_pixels_0[1][1] = 0u;
+  orig_pixels_0[1][2] = 0u;
+  orig_pixels_0[1][3] = 255u;
+  orig_pixels_0[2][0] = 0u;
+  orig_pixels_0[2][1] = 0u;
+  orig_pixels_0[2][2] = 0u;
+  orig_pixels_0[2][3] = 0u;
+  orig_pixels_0[3][0] = 0u;
+  orig_pixels_0[3][1] = 0u;
+  orig_pixels_0[3][2] = 0u;
+  orig_pixels_0[3][3] = 0u;
+
+  orig_pixels_1[0][0] = 0u;
+  orig_pixels_1[0][1] = 0u;
+  orig_pixels_1[0][2] = 0u;
+  orig_pixels_1[0][3] = 0u;
+  orig_pixels_1[1][0] = 0u;
+  orig_pixels_1[1][1] = 0u;
+  orig_pixels_1[1][2] = 0u;
+  orig_pixels_1[1][3] = 0u;
+  orig_pixels_1[2][0] = 0u;
+  orig_pixels_1[2][1] = 0u;
+  orig_pixels_1[2][2] = 0u;
+  orig_pixels_1[2][3] = 0u;
+  orig_pixels_1[3][0] = 255u;
+  orig_pixels_1[3][1] = 255u;
+  orig_pixels_1[3][2] = 255u;
+  orig_pixels_1[3][3] = 255u;
+
+  ARGBInterpolate(&orig_pixels_0[0][0], 0, &orig_pixels_1[0][0], 0,
+                  &interpolate_pixels[0][0], 0, 4, 1, 128);
+  EXPECT_EQ(8u, interpolate_pixels[0][0]);
+  EXPECT_EQ(16u, interpolate_pixels[0][1]);
+  EXPECT_EQ(32u, interpolate_pixels[0][2]);
+  EXPECT_EQ(64u, interpolate_pixels[0][3]);
+  EXPECT_EQ(0u, interpolate_pixels[1][0]);
+  EXPECT_EQ(0u, interpolate_pixels[1][1]);
+  EXPECT_EQ(0u, interpolate_pixels[1][2]);
+  EXPECT_EQ(128u, interpolate_pixels[1][3]);
+  EXPECT_EQ(0u, interpolate_pixels[2][0]);
+  EXPECT_EQ(0u, interpolate_pixels[2][1]);
+  EXPECT_EQ(0u, interpolate_pixels[2][2]);
+  EXPECT_EQ(0u, interpolate_pixels[2][3]);
+  EXPECT_EQ(128u, interpolate_pixels[3][0]);
+  EXPECT_EQ(128u, interpolate_pixels[3][1]);
+  EXPECT_EQ(128u, interpolate_pixels[3][2]);
+  EXPECT_EQ(128u, interpolate_pixels[3][3]);
+
+  ARGBInterpolate(&orig_pixels_0[0][0], 0, &orig_pixels_1[0][0], 0,
+                  &interpolate_pixels[0][0], 0, 4, 1, 0);
+  EXPECT_EQ(16u, interpolate_pixels[0][0]);
+  EXPECT_EQ(32u, interpolate_pixels[0][1]);
+  EXPECT_EQ(64u, interpolate_pixels[0][2]);
+  EXPECT_EQ(128u, interpolate_pixels[0][3]);
+
+  ARGBInterpolate(&orig_pixels_0[0][0], 0, &orig_pixels_1[0][0], 0,
+                  &interpolate_pixels[0][0], 0, 4, 1, 192);
+
+  EXPECT_EQ(4u, interpolate_pixels[0][0]);
+  EXPECT_EQ(8u, interpolate_pixels[0][1]);
+  EXPECT_EQ(16u, interpolate_pixels[0][2]);
+  EXPECT_EQ(32u, interpolate_pixels[0][3]);
+
+  for (int i = 0; i < benchmark_pixels_div1280_; ++i) {
+    ARGBInterpolate(&orig_pixels_0[0][0], 0, &orig_pixels_1[0][0], 0,
+                    &interpolate_pixels[0][0], 0, 1280, 1, 128);
+  }
+}
+
+TEST_F(LibYUVPlanarTest, TestInterpolatePlane) {
+  SIMD_ALIGNED(uint8_t orig_pixels_0[1280]);
+  SIMD_ALIGNED(uint8_t orig_pixels_1[1280]);
+  SIMD_ALIGNED(uint8_t interpolate_pixels[1280]);
+  memset(orig_pixels_0, 0, sizeof(orig_pixels_0));
+  memset(orig_pixels_1, 0, sizeof(orig_pixels_1));
+
+  orig_pixels_0[0] = 16u;
+  orig_pixels_0[1] = 32u;
+  orig_pixels_0[2] = 64u;
+  orig_pixels_0[3] = 128u;
+  orig_pixels_0[4] = 0u;
+  orig_pixels_0[5] = 0u;
+  orig_pixels_0[6] = 0u;
+  orig_pixels_0[7] = 255u;
+  orig_pixels_0[8] = 0u;
+  orig_pixels_0[9] = 0u;
+  orig_pixels_0[10] = 0u;
+  orig_pixels_0[11] = 0u;
+  orig_pixels_0[12] = 0u;
+  orig_pixels_0[13] = 0u;
+  orig_pixels_0[14] = 0u;
+  orig_pixels_0[15] = 0u;
+
+  orig_pixels_1[0] = 0u;
+  orig_pixels_1[1] = 0u;
+  orig_pixels_1[2] = 0u;
+  orig_pixels_1[3] = 0u;
+  orig_pixels_1[4] = 0u;
+  orig_pixels_1[5] = 0u;
+  orig_pixels_1[6] = 0u;
+  orig_pixels_1[7] = 0u;
+  orig_pixels_1[8] = 0u;
+  orig_pixels_1[9] = 0u;
+  orig_pixels_1[10] = 0u;
+  orig_pixels_1[11] = 0u;
+  orig_pixels_1[12] = 255u;
+  orig_pixels_1[13] = 255u;
+  orig_pixels_1[14] = 255u;
+  orig_pixels_1[15] = 255u;
+
+  InterpolatePlane(&orig_pixels_0[0], 0, &orig_pixels_1[0], 0,
+                   &interpolate_pixels[0], 0, 16, 1, 128);
+  EXPECT_EQ(8u, interpolate_pixels[0]);
+  EXPECT_EQ(16u, interpolate_pixels[1]);
+  EXPECT_EQ(32u, interpolate_pixels[2]);
+  EXPECT_EQ(64u, interpolate_pixels[3]);
+  EXPECT_EQ(0u, interpolate_pixels[4]);
+  EXPECT_EQ(0u, interpolate_pixels[5]);
+  EXPECT_EQ(0u, interpolate_pixels[6]);
+  EXPECT_EQ(128u, interpolate_pixels[7]);
+  EXPECT_EQ(0u, interpolate_pixels[8]);
+  EXPECT_EQ(0u, interpolate_pixels[9]);
+  EXPECT_EQ(0u, interpolate_pixels[10]);
+  EXPECT_EQ(0u, interpolate_pixels[11]);
+  EXPECT_EQ(128u, interpolate_pixels[12]);
+  EXPECT_EQ(128u, interpolate_pixels[13]);
+  EXPECT_EQ(128u, interpolate_pixels[14]);
+  EXPECT_EQ(128u, interpolate_pixels[15]);
+
+  InterpolatePlane(&orig_pixels_0[0], 0, &orig_pixels_1[0], 0,
+                   &interpolate_pixels[0], 0, 16, 1, 0);
+  EXPECT_EQ(16u, interpolate_pixels[0]);
+  EXPECT_EQ(32u, interpolate_pixels[1]);
+  EXPECT_EQ(64u, interpolate_pixels[2]);
+  EXPECT_EQ(128u, interpolate_pixels[3]);
+
+  InterpolatePlane(&orig_pixels_0[0], 0, &orig_pixels_1[0], 0,
+                   &interpolate_pixels[0], 0, 16, 1, 192);
+
+  EXPECT_EQ(4u, interpolate_pixels[0]);
+  EXPECT_EQ(8u, interpolate_pixels[1]);
+  EXPECT_EQ(16u, interpolate_pixels[2]);
+  EXPECT_EQ(32u, interpolate_pixels[3]);
+
+  for (int i = 0; i < benchmark_pixels_div1280_; ++i) {
+    InterpolatePlane(&orig_pixels_0[0], 0, &orig_pixels_1[0], 0,
+                     &interpolate_pixels[0], 0, 1280, 1, 123);
+  }
+}
+
+TEST_F(LibYUVPlanarTest, TestInterpolatePlane_16) {
+  SIMD_ALIGNED(uint16_t orig_pixels_0[1280]);
+  SIMD_ALIGNED(uint16_t orig_pixels_1[1280]);
+  SIMD_ALIGNED(uint16_t interpolate_pixels[1280]);
+  memset(orig_pixels_0, 0, sizeof(orig_pixels_0));
+  memset(orig_pixels_1, 0, sizeof(orig_pixels_1));
+
+  orig_pixels_0[0] = 16u;
+  orig_pixels_0[1] = 32u;
+  orig_pixels_0[2] = 64u;
+  orig_pixels_0[3] = 128u;
+  orig_pixels_0[4] = 0u;
+  orig_pixels_0[5] = 0u;
+  orig_pixels_0[6] = 0u;
+  orig_pixels_0[7] = 255u;
+  orig_pixels_0[8] = 0u;
+  orig_pixels_0[9] = 0u;
+  orig_pixels_0[10] = 0u;
+  orig_pixels_0[11] = 0u;
+  orig_pixels_0[12] = 0u;
+  orig_pixels_0[13] = 0u;
+  orig_pixels_0[14] = 0u;
+  orig_pixels_0[15] = 0u;
+
+  orig_pixels_1[0] = 0u;
+  orig_pixels_1[1] = 0u;
+  orig_pixels_1[2] = 0u;
+  orig_pixels_1[3] = 0u;
+  orig_pixels_1[4] = 0u;
+  orig_pixels_1[5] = 0u;
+  orig_pixels_1[6] = 0u;
+  orig_pixels_1[7] = 0u;
+  orig_pixels_1[8] = 0u;
+  orig_pixels_1[9] = 0u;
+  orig_pixels_1[10] = 0u;
+  orig_pixels_1[11] = 0u;
+  orig_pixels_1[12] = 255u;
+  orig_pixels_1[13] = 255u;
+  orig_pixels_1[14] = 255u;
+  orig_pixels_1[15] = 255u;
+
+  InterpolatePlane_16(&orig_pixels_0[0], 0, &orig_pixels_1[0], 0,
+                      &interpolate_pixels[0], 0, 16, 1, 128);
+  EXPECT_EQ(8u, interpolate_pixels[0]);
+  EXPECT_EQ(16u, interpolate_pixels[1]);
+  EXPECT_EQ(32u, interpolate_pixels[2]);
+  EXPECT_EQ(64u, interpolate_pixels[3]);
+  EXPECT_EQ(0u, interpolate_pixels[4]);
+  EXPECT_EQ(0u, interpolate_pixels[5]);
+  EXPECT_EQ(0u, interpolate_pixels[6]);
+  EXPECT_EQ(128u, interpolate_pixels[7]);
+  EXPECT_EQ(0u, interpolate_pixels[8]);
+  EXPECT_EQ(0u, interpolate_pixels[9]);
+  EXPECT_EQ(0u, interpolate_pixels[10]);
+  EXPECT_EQ(0u, interpolate_pixels[11]);
+  EXPECT_EQ(128u, interpolate_pixels[12]);
+  EXPECT_EQ(128u, interpolate_pixels[13]);
+  EXPECT_EQ(128u, interpolate_pixels[14]);
+  EXPECT_EQ(128u, interpolate_pixels[15]);
+
+  InterpolatePlane_16(&orig_pixels_0[0], 0, &orig_pixels_1[0], 0,
+                      &interpolate_pixels[0], 0, 16, 1, 0);
+  EXPECT_EQ(16u, interpolate_pixels[0]);
+  EXPECT_EQ(32u, interpolate_pixels[1]);
+  EXPECT_EQ(64u, interpolate_pixels[2]);
+  EXPECT_EQ(128u, interpolate_pixels[3]);
+
+  InterpolatePlane_16(&orig_pixels_0[0], 0, &orig_pixels_1[0], 0,
+                      &interpolate_pixels[0], 0, 16, 1, 192);
+
+  EXPECT_EQ(4u, interpolate_pixels[0]);
+  EXPECT_EQ(8u, interpolate_pixels[1]);
+  EXPECT_EQ(16u, interpolate_pixels[2]);
+  EXPECT_EQ(32u, interpolate_pixels[3]);
+
+  for (int i = 0; i < benchmark_pixels_div1280_; ++i) {
+    InterpolatePlane_16(&orig_pixels_0[0], 0, &orig_pixels_1[0], 0,
+                        &interpolate_pixels[0], 0, 1280, 1, 123);
+  }
+}
+
+#define TESTTERP(FMT_A, BPP_A, STRIDE_A, FMT_B, BPP_B, STRIDE_B, W1280, TERP, \
+                 N, NEG, OFF)                                                 \
+  TEST_F(LibYUVPlanarTest, ARGBInterpolate##TERP##N) {                        \
+    const int kWidth = W1280;                                                 \
+    const int kHeight = benchmark_height_;                                    \
+    const int kStrideA =                                                      \
+        (kWidth * BPP_A + STRIDE_A - 1) / STRIDE_A * STRIDE_A;                \
+    const int kStrideB =                                                      \
+        (kWidth * BPP_B + STRIDE_B - 1) / STRIDE_B * STRIDE_B;                \
+    align_buffer_page_end(src_argb_a, kStrideA* kHeight + OFF);               \
+    align_buffer_page_end(src_argb_b, kStrideA* kHeight + OFF);               \
+    align_buffer_page_end(dst_argb_c, kStrideB* kHeight);                     \
+    align_buffer_page_end(dst_argb_opt, kStrideB* kHeight);                   \
+    for (int i = 0; i < kStrideA * kHeight; ++i) {                            \
+      src_argb_a[i + OFF] = (fastrand() & 0xff);                              \
+      src_argb_b[i + OFF] = (fastrand() & 0xff);                              \
+    }                                                                         \
+    MaskCpuFlags(disable_cpu_flags_);                                         \
+    ARGBInterpolate(src_argb_a + OFF, kStrideA, src_argb_b + OFF, kStrideA,   \
+                    dst_argb_c, kStrideB, kWidth, NEG kHeight, TERP);         \
+    MaskCpuFlags(benchmark_cpu_info_);                                        \
+    for (int i = 0; i < benchmark_iterations_; ++i) {                         \
+      ARGBInterpolate(src_argb_a + OFF, kStrideA, src_argb_b + OFF, kStrideA, \
+                      dst_argb_opt, kStrideB, kWidth, NEG kHeight, TERP);     \
+    }                                                                         \
+    for (int i = 0; i < kStrideB * kHeight; ++i) {                            \
+      EXPECT_EQ(dst_argb_c[i], dst_argb_opt[i]);                              \
+    }                                                                         \
+    free_aligned_buffer_page_end(src_argb_a);                                 \
+    free_aligned_buffer_page_end(src_argb_b);                                 \
+    free_aligned_buffer_page_end(dst_argb_c);                                 \
+    free_aligned_buffer_page_end(dst_argb_opt);                               \
+  }
+
+#define TESTINTERPOLATE(TERP)                                                \
+  TESTTERP(ARGB, 4, 1, ARGB, 4, 1, benchmark_width_ + 1, TERP, _Any, +, 0)   \
+  TESTTERP(ARGB, 4, 1, ARGB, 4, 1, benchmark_width_, TERP, _Unaligned, +, 1) \
+  TESTTERP(ARGB, 4, 1, ARGB, 4, 1, benchmark_width_, TERP, _Invert, -, 0)    \
+  TESTTERP(ARGB, 4, 1, ARGB, 4, 1, benchmark_width_, TERP, _Opt, +, 0)
+
+TESTINTERPOLATE(0)
+TESTINTERPOLATE(64)
+TESTINTERPOLATE(128)
+TESTINTERPOLATE(192)
+TESTINTERPOLATE(255)
+
+static int TestBlend(int width,
+                     int height,
+                     int benchmark_iterations,
+                     int disable_cpu_flags,
+                     int benchmark_cpu_info,
+                     int invert,
+                     int off,
+                     int attenuate) {
+  if (width < 1) {
+    width = 1;
+  }
+  const int kBpp = 4;
+  const int kStride = width * kBpp;
+  align_buffer_page_end(src_argb_a, kStride * height + off);
+  align_buffer_page_end(src_argb_b, kStride * height + off);
+  align_buffer_page_end(dst_argb_c, kStride * height);
+  align_buffer_page_end(dst_argb_opt, kStride * height);
+  for (int i = 0; i < kStride * height; ++i) {
+    src_argb_a[i + off] = (fastrand() & 0xff);
+    src_argb_b[i + off] = (fastrand() & 0xff);
+  }
+  MemRandomize(src_argb_a, kStride * height + off);
+  MemRandomize(src_argb_b, kStride * height + off);
+  if (attenuate) {
+    ARGBAttenuate(src_argb_a + off, kStride, src_argb_a + off, kStride, width,
+                  height);
+  }
+  memset(dst_argb_c, 255, kStride * height);
+  memset(dst_argb_opt, 255, kStride * height);
+
+  MaskCpuFlags(disable_cpu_flags);
+  ARGBBlend(src_argb_a + off, kStride, src_argb_b + off, kStride, dst_argb_c,
+            kStride, width, invert * height);
+  MaskCpuFlags(benchmark_cpu_info);
+  for (int i = 0; i < benchmark_iterations; ++i) {
+    ARGBBlend(src_argb_a + off, kStride, src_argb_b + off, kStride,
+              dst_argb_opt, kStride, width, invert * height);
+  }
+  int max_diff = 0;
+  for (int i = 0; i < kStride * height; ++i) {
+    int abs_diff = abs(static_cast<int>(dst_argb_c[i]) -
+                       static_cast<int>(dst_argb_opt[i]));
+    if (abs_diff > max_diff) {
+      max_diff = abs_diff;
+    }
+  }
+  free_aligned_buffer_page_end(src_argb_a);
+  free_aligned_buffer_page_end(src_argb_b);
+  free_aligned_buffer_page_end(dst_argb_c);
+  free_aligned_buffer_page_end(dst_argb_opt);
+  return max_diff;
+}
+
+TEST_F(LibYUVPlanarTest, ARGBBlend_Any) {
+  int max_diff =
+      TestBlend(benchmark_width_ + 1, benchmark_height_, benchmark_iterations_,
+                disable_cpu_flags_, benchmark_cpu_info_, +1, 0, 1);
+  EXPECT_LE(max_diff, 1);
+}
+
+TEST_F(LibYUVPlanarTest, ARGBBlend_Unaligned) {
+  int max_diff =
+      TestBlend(benchmark_width_, benchmark_height_, benchmark_iterations_,
+                disable_cpu_flags_, benchmark_cpu_info_, +1, 1, 1);
+  EXPECT_LE(max_diff, 1);
+}
+
+TEST_F(LibYUVPlanarTest, ARGBBlend_Invert) {
+  int max_diff =
+      TestBlend(benchmark_width_, benchmark_height_, benchmark_iterations_,
+                disable_cpu_flags_, benchmark_cpu_info_, -1, 0, 1);
+  EXPECT_LE(max_diff, 1);
+}
+
+TEST_F(LibYUVPlanarTest, ARGBBlend_Unattenuated) {
+  int max_diff =
+      TestBlend(benchmark_width_, benchmark_height_, benchmark_iterations_,
+                disable_cpu_flags_, benchmark_cpu_info_, +1, 0, 0);
+  EXPECT_LE(max_diff, 1);
+}
+
+TEST_F(LibYUVPlanarTest, ARGBBlend_Opt) {
+  int max_diff =
+      TestBlend(benchmark_width_, benchmark_height_, benchmark_iterations_,
+                disable_cpu_flags_, benchmark_cpu_info_, +1, 0, 1);
+  EXPECT_LE(max_diff, 1);
+}
+
+static void TestBlendPlane(int width,
+                           int height,
+                           int benchmark_iterations,
+                           int disable_cpu_flags,
+                           int benchmark_cpu_info,
+                           int invert,
+                           int off) {
+  if (width < 1) {
+    width = 1;
+  }
+  const int kBpp = 1;
+  const int kStride = width * kBpp;
+  align_buffer_page_end(src_argb_a, kStride * height + off);
+  align_buffer_page_end(src_argb_b, kStride * height + off);
+  align_buffer_page_end(src_argb_alpha, kStride * height + off);
+  align_buffer_page_end(dst_argb_c, kStride * height + off);
+  align_buffer_page_end(dst_argb_opt, kStride * height + off);
+  memset(dst_argb_c, 255, kStride * height + off);
+  memset(dst_argb_opt, 255, kStride * height + off);
+
+  // Test source is maintained exactly if alpha is 255.
+  for (int i = 0; i < width; ++i) {
+    src_argb_a[i + off] = i & 255;
+    src_argb_b[i + off] = 255 - (i & 255);
+  }
+  memset(src_argb_alpha + off, 255, width);
+  BlendPlane(src_argb_a + off, width, src_argb_b + off, width,
+             src_argb_alpha + off, width, dst_argb_opt + off, width, width, 1);
+  for (int i = 0; i < width; ++i) {
+    EXPECT_EQ(src_argb_a[i + off], dst_argb_opt[i + off]);
+  }
+  // Test destination is maintained exactly if alpha is 0.
+  memset(src_argb_alpha + off, 0, width);
+  BlendPlane(src_argb_a + off, width, src_argb_b + off, width,
+             src_argb_alpha + off, width, dst_argb_opt + off, width, width, 1);
+  for (int i = 0; i < width; ++i) {
+    EXPECT_EQ(src_argb_b[i + off], dst_argb_opt[i + off]);
+  }
+  for (int i = 0; i < kStride * height; ++i) {
+    src_argb_a[i + off] = (fastrand() & 0xff);
+    src_argb_b[i + off] = (fastrand() & 0xff);
+    src_argb_alpha[i + off] = (fastrand() & 0xff);
+  }
+
+  MaskCpuFlags(disable_cpu_flags);
+  BlendPlane(src_argb_a + off, width, src_argb_b + off, width,
+             src_argb_alpha + off, width, dst_argb_c + off, width, width,
+             invert * height);
+  MaskCpuFlags(benchmark_cpu_info);
+  for (int i = 0; i < benchmark_iterations; ++i) {
+    BlendPlane(src_argb_a + off, width, src_argb_b + off, width,
+               src_argb_alpha + off, width, dst_argb_opt + off, width, width,
+               invert * height);
+  }
+  for (int i = 0; i < kStride * height; ++i) {
+    EXPECT_EQ(dst_argb_c[i + off], dst_argb_opt[i + off]);
+  }
+  free_aligned_buffer_page_end(src_argb_a);
+  free_aligned_buffer_page_end(src_argb_b);
+  free_aligned_buffer_page_end(src_argb_alpha);
+  free_aligned_buffer_page_end(dst_argb_c);
+  free_aligned_buffer_page_end(dst_argb_opt);
+}
+
+TEST_F(LibYUVPlanarTest, BlendPlane_Opt) {
+  TestBlendPlane(benchmark_width_, benchmark_height_, benchmark_iterations_,
+                 disable_cpu_flags_, benchmark_cpu_info_, +1, 0);
+}
+TEST_F(LibYUVPlanarTest, BlendPlane_Unaligned) {
+  TestBlendPlane(benchmark_width_, benchmark_height_, benchmark_iterations_,
+                 disable_cpu_flags_, benchmark_cpu_info_, +1, 1);
+}
+TEST_F(LibYUVPlanarTest, BlendPlane_Any) {
+  TestBlendPlane(benchmark_width_ + 1, benchmark_height_, benchmark_iterations_,
+                 disable_cpu_flags_, benchmark_cpu_info_, +1, 1);
+}
+TEST_F(LibYUVPlanarTest, BlendPlane_Invert) {
+  TestBlendPlane(benchmark_width_, benchmark_height_, benchmark_iterations_,
+                 disable_cpu_flags_, benchmark_cpu_info_, -1, 1);
+}
+
+#define SUBSAMPLE(v, a) ((((v) + (a)-1)) / (a))
+
+static void TestI420Blend(int width,
+                          int height,
+                          int benchmark_iterations,
+                          int disable_cpu_flags,
+                          int benchmark_cpu_info,
+                          int invert,
+                          int off) {
+  width = ((width) > 0) ? (width) : 1;
+  const int kStrideUV = SUBSAMPLE(width, 2);
+  const int kSizeUV = kStrideUV * SUBSAMPLE(height, 2);
+  align_buffer_page_end(src_y0, width * height + off);
+  align_buffer_page_end(src_u0, kSizeUV + off);
+  align_buffer_page_end(src_v0, kSizeUV + off);
+  align_buffer_page_end(src_y1, width * height + off);
+  align_buffer_page_end(src_u1, kSizeUV + off);
+  align_buffer_page_end(src_v1, kSizeUV + off);
+  align_buffer_page_end(src_a, width * height + off);
+  align_buffer_page_end(dst_y_c, width * height + off);
+  align_buffer_page_end(dst_u_c, kSizeUV + off);
+  align_buffer_page_end(dst_v_c, kSizeUV + off);
+  align_buffer_page_end(dst_y_opt, width * height + off);
+  align_buffer_page_end(dst_u_opt, kSizeUV + off);
+  align_buffer_page_end(dst_v_opt, kSizeUV + off);
+
+  MemRandomize(src_y0, width * height + off);
+  MemRandomize(src_u0, kSizeUV + off);
+  MemRandomize(src_v0, kSizeUV + off);
+  MemRandomize(src_y1, width * height + off);
+  MemRandomize(src_u1, kSizeUV + off);
+  MemRandomize(src_v1, kSizeUV + off);
+  MemRandomize(src_a, width * height + off);
+  memset(dst_y_c, 255, width * height + off);
+  memset(dst_u_c, 255, kSizeUV + off);
+  memset(dst_v_c, 255, kSizeUV + off);
+  memset(dst_y_opt, 255, width * height + off);
+  memset(dst_u_opt, 255, kSizeUV + off);
+  memset(dst_v_opt, 255, kSizeUV + off);
+
+  MaskCpuFlags(disable_cpu_flags);
+  I420Blend(src_y0 + off, width, src_u0 + off, kStrideUV, src_v0 + off,
+            kStrideUV, src_y1 + off, width, src_u1 + off, kStrideUV,
+            src_v1 + off, kStrideUV, src_a + off, width, dst_y_c + off, width,
+            dst_u_c + off, kStrideUV, dst_v_c + off, kStrideUV, width,
+            invert * height);
+  MaskCpuFlags(benchmark_cpu_info);
+  for (int i = 0; i < benchmark_iterations; ++i) {
+    I420Blend(src_y0 + off, width, src_u0 + off, kStrideUV, src_v0 + off,
+              kStrideUV, src_y1 + off, width, src_u1 + off, kStrideUV,
+              src_v1 + off, kStrideUV, src_a + off, width, dst_y_opt + off,
+              width, dst_u_opt + off, kStrideUV, dst_v_opt + off, kStrideUV,
+              width, invert * height);
+  }
+  for (int i = 0; i < width * height; ++i) {
+    EXPECT_EQ(dst_y_c[i + off], dst_y_opt[i + off]);
+  }
+  for (int i = 0; i < kSizeUV; ++i) {
+    EXPECT_EQ(dst_u_c[i + off], dst_u_opt[i + off]);
+    EXPECT_EQ(dst_v_c[i + off], dst_v_opt[i + off]);
+  }
+  free_aligned_buffer_page_end(src_y0);
+  free_aligned_buffer_page_end(src_u0);
+  free_aligned_buffer_page_end(src_v0);
+  free_aligned_buffer_page_end(src_y1);
+  free_aligned_buffer_page_end(src_u1);
+  free_aligned_buffer_page_end(src_v1);
+  free_aligned_buffer_page_end(src_a);
+  free_aligned_buffer_page_end(dst_y_c);
+  free_aligned_buffer_page_end(dst_u_c);
+  free_aligned_buffer_page_end(dst_v_c);
+  free_aligned_buffer_page_end(dst_y_opt);
+  free_aligned_buffer_page_end(dst_u_opt);
+  free_aligned_buffer_page_end(dst_v_opt);
+}
+
+TEST_F(LibYUVPlanarTest, I420Blend_Opt) {
+  TestI420Blend(benchmark_width_, benchmark_height_, benchmark_iterations_,
+                disable_cpu_flags_, benchmark_cpu_info_, +1, 0);
+}
+TEST_F(LibYUVPlanarTest, I420Blend_Unaligned) {
+  TestI420Blend(benchmark_width_, benchmark_height_, benchmark_iterations_,
+                disable_cpu_flags_, benchmark_cpu_info_, +1, 1);
+}
+
+// TODO(fbarchard): DISABLED because _Any uses C.  Avoid C and re-enable.
+TEST_F(LibYUVPlanarTest, DISABLED_I420Blend_Any) {
+  TestI420Blend(benchmark_width_ + 1, benchmark_height_, benchmark_iterations_,
+                disable_cpu_flags_, benchmark_cpu_info_, +1, 0);
+}
+TEST_F(LibYUVPlanarTest, I420Blend_Invert) {
+  TestI420Blend(benchmark_width_, benchmark_height_, benchmark_iterations_,
+                disable_cpu_flags_, benchmark_cpu_info_, -1, 0);
+}
+
+TEST_F(LibYUVPlanarTest, TestAffine) {
+  SIMD_ALIGNED(uint8_t orig_pixels_0[1280][4]);
+  SIMD_ALIGNED(uint8_t interpolate_pixels_C[1280][4]);
+
+  for (int i = 0; i < 1280; ++i) {
+    for (int j = 0; j < 4; ++j) {
+      orig_pixels_0[i][j] = i;
+    }
+  }
+
+  float uv_step[4] = {0.f, 0.f, 0.75f, 0.f};
+
+  ARGBAffineRow_C(&orig_pixels_0[0][0], 0, &interpolate_pixels_C[0][0], uv_step,
+                  1280);
+  EXPECT_EQ(0u, interpolate_pixels_C[0][0]);
+  EXPECT_EQ(96u, interpolate_pixels_C[128][0]);
+  EXPECT_EQ(191u, interpolate_pixels_C[255][3]);
+
+#if defined(HAS_ARGBAFFINEROW_SSE2)
+  SIMD_ALIGNED(uint8_t interpolate_pixels_Opt[1280][4]);
+  ARGBAffineRow_SSE2(&orig_pixels_0[0][0], 0, &interpolate_pixels_Opt[0][0],
+                     uv_step, 1280);
+  EXPECT_EQ(0, memcmp(interpolate_pixels_Opt, interpolate_pixels_C, 1280 * 4));
+
+  int has_sse2 = TestCpuFlag(kCpuHasSSE2);
+  if (has_sse2) {
+    for (int i = 0; i < benchmark_pixels_div1280_; ++i) {
+      ARGBAffineRow_SSE2(&orig_pixels_0[0][0], 0, &interpolate_pixels_Opt[0][0],
+                         uv_step, 1280);
+    }
+  }
+#endif
+}
+
+TEST_F(LibYUVPlanarTest, TestCopyPlane) {
+  int err = 0;
+  int yw = benchmark_width_;
+  int yh = benchmark_height_;
+  int b = 12;
+  int i, j;
+
+  int y_plane_size = (yw + b * 2) * (yh + b * 2);
+  align_buffer_page_end(orig_y, y_plane_size);
+  align_buffer_page_end(dst_c, y_plane_size);
+  align_buffer_page_end(dst_opt, y_plane_size);
+
+  memset(orig_y, 0, y_plane_size);
+  memset(dst_c, 0, y_plane_size);
+  memset(dst_opt, 0, y_plane_size);
+
+  // Fill image buffers with random data.
+  for (i = b; i < (yh + b); ++i) {
+    for (j = b; j < (yw + b); ++j) {
+      orig_y[i * (yw + b * 2) + j] = fastrand() & 0xff;
+    }
+  }
+
+  // Fill destination buffers with random data.
+  for (i = 0; i < y_plane_size; ++i) {
+    uint8_t random_number = fastrand() & 0x7f;
+    dst_c[i] = random_number;
+    dst_opt[i] = dst_c[i];
+  }
+
+  int y_off = b * (yw + b * 2) + b;
+
+  int y_st = yw + b * 2;
+  int stride = 8;
+
+  // Disable all optimizations.
+  MaskCpuFlags(disable_cpu_flags_);
+  for (j = 0; j < benchmark_iterations_; j++) {
+    CopyPlane(orig_y + y_off, y_st, dst_c + y_off, stride, yw, yh);
+  }
+
+  // Enable optimizations.
+  MaskCpuFlags(benchmark_cpu_info_);
+  for (j = 0; j < benchmark_iterations_; j++) {
+    CopyPlane(orig_y + y_off, y_st, dst_opt + y_off, stride, yw, yh);
+  }
+
+  for (i = 0; i < y_plane_size; ++i) {
+    if (dst_c[i] != dst_opt[i]) {
+      ++err;
+    }
+  }
+
+  free_aligned_buffer_page_end(orig_y);
+  free_aligned_buffer_page_end(dst_c);
+  free_aligned_buffer_page_end(dst_opt);
+
+  EXPECT_EQ(0, err);
+}
+
+TEST_F(LibYUVPlanarTest, CopyPlane_Opt) {
+  int i;
+  int y_plane_size = benchmark_width_ * benchmark_height_;
+  align_buffer_page_end(orig_y, y_plane_size);
+  align_buffer_page_end(dst_c, y_plane_size);
+  align_buffer_page_end(dst_opt, y_plane_size);
+
+  MemRandomize(orig_y, y_plane_size);
+  memset(dst_c, 1, y_plane_size);
+  memset(dst_opt, 2, y_plane_size);
+
+  // Disable all optimizations.
+  MaskCpuFlags(disable_cpu_flags_);
+  for (i = 0; i < benchmark_iterations_; i++) {
+    CopyPlane(orig_y, benchmark_width_, dst_c, benchmark_width_,
+              benchmark_width_, benchmark_height_);
+  }
+
+  // Enable optimizations.
+  MaskCpuFlags(benchmark_cpu_info_);
+  for (i = 0; i < benchmark_iterations_; i++) {
+    CopyPlane(orig_y, benchmark_width_, dst_opt, benchmark_width_,
+              benchmark_width_, benchmark_height_);
+  }
+
+  for (i = 0; i < y_plane_size; ++i) {
+    EXPECT_EQ(dst_c[i], dst_opt[i]);
+  }
+
+  free_aligned_buffer_page_end(orig_y);
+  free_aligned_buffer_page_end(dst_c);
+  free_aligned_buffer_page_end(dst_opt);
+}
+
+TEST_F(LibYUVPlanarTest, TestCopyPlaneZero) {
+  // Test to verify copying a rect with a zero height or width does
+  // not touch destination memory.
+  uint8_t src = 42;
+  uint8_t dst = 0;
+
+  // Disable all optimizations.
+  MaskCpuFlags(disable_cpu_flags_);
+  CopyPlane(&src, 0, &dst, 0, 0, 0);
+  EXPECT_EQ(src, 42);
+  EXPECT_EQ(dst, 0);
+
+  CopyPlane(&src, 1, &dst, 1, 1, 0);
+  EXPECT_EQ(src, 42);
+  EXPECT_EQ(dst, 0);
+
+  CopyPlane(&src, 1, &dst, 1, 0, 1);
+  EXPECT_EQ(src, 42);
+  EXPECT_EQ(dst, 0);
+
+  // Enable optimizations.
+  MaskCpuFlags(benchmark_cpu_info_);
+  CopyPlane(&src, 0, &dst, 0, 0, 0);
+  EXPECT_EQ(src, 42);
+  EXPECT_EQ(dst, 0);
+
+  CopyPlane(&src, 1, &dst, 1, 1, 0);
+  EXPECT_EQ(src, 42);
+  EXPECT_EQ(dst, 0);
+
+  CopyPlane(&src, 1, &dst, 1, 0, 1);
+  EXPECT_EQ(src, 42);
+  EXPECT_EQ(dst, 0);
+}
+
+TEST_F(LibYUVPlanarTest, TestDetilePlane) {
+  int i, j;
+
+  // orig is tiled.  Allocate enough memory for tiles.
+  int orig_width = (benchmark_width_ + 15) & ~15;
+  int orig_height = (benchmark_height_ + 15) & ~15;
+  int orig_plane_size = orig_width * orig_height;
+  int y_plane_size = benchmark_width_ * benchmark_height_;
+  align_buffer_page_end(orig_y, orig_plane_size);
+  align_buffer_page_end(dst_c, y_plane_size);
+  align_buffer_page_end(dst_opt, y_plane_size);
+
+  MemRandomize(orig_y, orig_plane_size);
+  memset(dst_c, 0, y_plane_size);
+  memset(dst_opt, 0, y_plane_size);
+
+  // Disable all optimizations.
+  MaskCpuFlags(disable_cpu_flags_);
+  for (j = 0; j < benchmark_iterations_; j++) {
+    DetilePlane(orig_y, orig_width, dst_c, benchmark_width_, benchmark_width_,
+                benchmark_height_, 16);
+  }
+
+  // Enable optimizations.
+  MaskCpuFlags(benchmark_cpu_info_);
+  for (j = 0; j < benchmark_iterations_; j++) {
+    DetilePlane(orig_y, orig_width, dst_opt, benchmark_width_, benchmark_width_,
+                benchmark_height_, 16);
+  }
+
+  for (i = 0; i < y_plane_size; ++i) {
+    EXPECT_EQ(dst_c[i], dst_opt[i]);
+  }
+
+  free_aligned_buffer_page_end(orig_y);
+  free_aligned_buffer_page_end(dst_c);
+  free_aligned_buffer_page_end(dst_opt);
+}
+
+TEST_F(LibYUVPlanarTest, TestDetileSplitUVPlane_Benchmark) {
+  int i, j;
+
+  // orig is tiled.  Allocate enough memory for tiles.
+  int orig_width = (benchmark_width_ + 15) & ~15;
+  int orig_height = (benchmark_height_ + 15) & ~15;
+  int orig_plane_size = orig_width * orig_height;
+  int u_plane_size = benchmark_width_ * benchmark_height_;
+  int v_plane_size = u_plane_size;
+  align_buffer_page_end(orig_uv, orig_plane_size);
+  align_buffer_page_end(dst_u_c, u_plane_size);
+  align_buffer_page_end(dst_u_opt, u_plane_size);
+  align_buffer_page_end(dst_v_c, v_plane_size);
+  align_buffer_page_end(dst_v_opt, v_plane_size);
+
+  MemRandomize(orig_uv, orig_plane_size);
+  memset(dst_u_c, 0, u_plane_size);
+  memset(dst_u_opt, 0, u_plane_size);
+  memset(dst_v_c, 0, v_plane_size);
+  memset(dst_v_opt, 0, v_plane_size);
+
+  // Disable all optimizations.
+  MaskCpuFlags(disable_cpu_flags_);
+  for (j = 0; j < benchmark_iterations_; j++) {
+    DetileSplitUVPlane(orig_uv, orig_width, dst_u_c, (benchmark_width_ + 1) / 2,
+                       dst_v_c, (benchmark_width_ + 1) / 2, benchmark_width_,
+                       benchmark_height_, 16);
+  }
+
+  // Enable optimizations.
+  MaskCpuFlags(benchmark_cpu_info_);
+  for (j = 0; j < benchmark_iterations_; j++) {
+    DetileSplitUVPlane(
+        orig_uv, orig_width, dst_u_opt, (benchmark_width_ + 1) / 2, dst_v_opt,
+        (benchmark_width_ + 1) / 2, benchmark_width_, benchmark_height_, 16);
+  }
+
+  for (i = 0; i < u_plane_size; ++i) {
+    EXPECT_EQ(dst_u_c[i], dst_u_opt[i]);
+  }
+  for (i = 0; i < v_plane_size; ++i) {
+    EXPECT_EQ(dst_v_c[i], dst_v_opt[i]);
+  }
+
+  free_aligned_buffer_page_end(orig_uv);
+  free_aligned_buffer_page_end(dst_u_c);
+  free_aligned_buffer_page_end(dst_u_opt);
+  free_aligned_buffer_page_end(dst_v_c);
+  free_aligned_buffer_page_end(dst_v_opt);
+}
+
+// TODO(b/228518489): Fix Segmentation fault in this test
+TEST_F(LibYUVPlanarTest, DISABLED_TestDetileSplitUVPlane_Correctness) {
+  int i, j;
+
+  // orig is tiled.  Allocate enough memory for tiles.
+  int orig_width = (benchmark_width_ + 15) & ~15;
+  int orig_height = (benchmark_height_ + 15) & ~15;
+  int orig_plane_size = orig_width * orig_height;
+  int u_plane_size = benchmark_width_ * benchmark_height_;
+  int v_plane_size = u_plane_size;
+  align_buffer_page_end(orig_uv, orig_plane_size);
+  align_buffer_page_end(detiled_uv, orig_plane_size);
+  align_buffer_page_end(dst_u_two_stage, u_plane_size);
+  align_buffer_page_end(dst_u_opt, u_plane_size);
+  align_buffer_page_end(dst_v_two_stage, v_plane_size);
+  align_buffer_page_end(dst_v_opt, v_plane_size);
+
+  MemRandomize(orig_uv, orig_plane_size);
+  memset(detiled_uv, 0, orig_plane_size);
+  memset(dst_u_two_stage, 0, u_plane_size);
+  memset(dst_u_opt, 0, u_plane_size);
+  memset(dst_v_two_stage, 0, v_plane_size);
+  memset(dst_v_opt, 0, v_plane_size);
+
+  for (j = 0; j < benchmark_iterations_; j++) {
+    DetileSplitUVPlane(
+        orig_uv, orig_width, dst_u_opt, (benchmark_width_ + 1) / 2, dst_v_opt,
+        (benchmark_width_ + 1) / 2, benchmark_width_, benchmark_height_, 16);
+  }
+
+  DetilePlane(orig_uv, orig_width, detiled_uv, benchmark_width_,
+              benchmark_width_, benchmark_height_, 16);
+  SplitUVPlane(detiled_uv, orig_width, dst_u_two_stage,
+               (benchmark_width_ + 1) / 2, dst_v_two_stage,
+               (benchmark_width_ + 1) / 2, benchmark_width_, benchmark_height_);
+
+  for (i = 0; i < u_plane_size; ++i) {
+    EXPECT_EQ(dst_u_two_stage[i], dst_u_opt[i]);
+  }
+  for (i = 0; i < v_plane_size; ++i) {
+    EXPECT_EQ(dst_v_two_stage[i], dst_v_opt[i]);
+  }
+
+  free_aligned_buffer_page_end(orig_uv);
+  free_aligned_buffer_page_end(detiled_uv);
+  free_aligned_buffer_page_end(dst_u_two_stage);
+  free_aligned_buffer_page_end(dst_u_opt);
+  free_aligned_buffer_page_end(dst_v_two_stage);
+  free_aligned_buffer_page_end(dst_v_opt);
+}
+
+static int TestMultiply(int width,
+                        int height,
+                        int benchmark_iterations,
+                        int disable_cpu_flags,
+                        int benchmark_cpu_info,
+                        int invert,
+                        int off) {
+  if (width < 1) {
+    width = 1;
+  }
+  const int kBpp = 4;
+  const int kStride = width * kBpp;
+  align_buffer_page_end(src_argb_a, kStride * height + off);
+  align_buffer_page_end(src_argb_b, kStride * height + off);
+  align_buffer_page_end(dst_argb_c, kStride * height);
+  align_buffer_page_end(dst_argb_opt, kStride * height);
+  for (int i = 0; i < kStride * height; ++i) {
+    src_argb_a[i + off] = (fastrand() & 0xff);
+    src_argb_b[i + off] = (fastrand() & 0xff);
+  }
+  memset(dst_argb_c, 0, kStride * height);
+  memset(dst_argb_opt, 0, kStride * height);
+
+  MaskCpuFlags(disable_cpu_flags);
+  ARGBMultiply(src_argb_a + off, kStride, src_argb_b + off, kStride, dst_argb_c,
+               kStride, width, invert * height);
+  MaskCpuFlags(benchmark_cpu_info);
+  for (int i = 0; i < benchmark_iterations; ++i) {
+    ARGBMultiply(src_argb_a + off, kStride, src_argb_b + off, kStride,
+                 dst_argb_opt, kStride, width, invert * height);
+  }
+  int max_diff = 0;
+  for (int i = 0; i < kStride * height; ++i) {
+    int abs_diff = abs(static_cast<int>(dst_argb_c[i]) -
+                       static_cast<int>(dst_argb_opt[i]));
+    if (abs_diff > max_diff) {
+      max_diff = abs_diff;
+    }
+  }
+  free_aligned_buffer_page_end(src_argb_a);
+  free_aligned_buffer_page_end(src_argb_b);
+  free_aligned_buffer_page_end(dst_argb_c);
+  free_aligned_buffer_page_end(dst_argb_opt);
+  return max_diff;
+}
+
+TEST_F(LibYUVPlanarTest, ARGBMultiply_Any) {
+  int max_diff = TestMultiply(benchmark_width_ + 1, benchmark_height_,
+                              benchmark_iterations_, disable_cpu_flags_,
+                              benchmark_cpu_info_, +1, 0);
+  EXPECT_LE(max_diff, 1);
+}
+
+TEST_F(LibYUVPlanarTest, ARGBMultiply_Unaligned) {
+  int max_diff =
+      TestMultiply(benchmark_width_, benchmark_height_, benchmark_iterations_,
+                   disable_cpu_flags_, benchmark_cpu_info_, +1, 1);
+  EXPECT_LE(max_diff, 1);
+}
+
+TEST_F(LibYUVPlanarTest, ARGBMultiply_Invert) {
+  int max_diff =
+      TestMultiply(benchmark_width_, benchmark_height_, benchmark_iterations_,
+                   disable_cpu_flags_, benchmark_cpu_info_, -1, 0);
+  EXPECT_LE(max_diff, 1);
+}
+
+TEST_F(LibYUVPlanarTest, ARGBMultiply_Opt) {
+  int max_diff =
+      TestMultiply(benchmark_width_, benchmark_height_, benchmark_iterations_,
+                   disable_cpu_flags_, benchmark_cpu_info_, +1, 0);
+  EXPECT_LE(max_diff, 1);
+}
+
+static int TestAdd(int width,
+                   int height,
+                   int benchmark_iterations,
+                   int disable_cpu_flags,
+                   int benchmark_cpu_info,
+                   int invert,
+                   int off) {
+  if (width < 1) {
+    width = 1;
+  }
+  const int kBpp = 4;
+  const int kStride = width * kBpp;
+  align_buffer_page_end(src_argb_a, kStride * height + off);
+  align_buffer_page_end(src_argb_b, kStride * height + off);
+  align_buffer_page_end(dst_argb_c, kStride * height);
+  align_buffer_page_end(dst_argb_opt, kStride * height);
+  for (int i = 0; i < kStride * height; ++i) {
+    src_argb_a[i + off] = (fastrand() & 0xff);
+    src_argb_b[i + off] = (fastrand() & 0xff);
+  }
+  memset(dst_argb_c, 0, kStride * height);
+  memset(dst_argb_opt, 0, kStride * height);
+
+  MaskCpuFlags(disable_cpu_flags);
+  ARGBAdd(src_argb_a + off, kStride, src_argb_b + off, kStride, dst_argb_c,
+          kStride, width, invert * height);
+  MaskCpuFlags(benchmark_cpu_info);
+  for (int i = 0; i < benchmark_iterations; ++i) {
+    ARGBAdd(src_argb_a + off, kStride, src_argb_b + off, kStride, dst_argb_opt,
+            kStride, width, invert * height);
+  }
+  int max_diff = 0;
+  for (int i = 0; i < kStride * height; ++i) {
+    int abs_diff = abs(static_cast<int>(dst_argb_c[i]) -
+                       static_cast<int>(dst_argb_opt[i]));
+    if (abs_diff > max_diff) {
+      max_diff = abs_diff;
+    }
+  }
+  free_aligned_buffer_page_end(src_argb_a);
+  free_aligned_buffer_page_end(src_argb_b);
+  free_aligned_buffer_page_end(dst_argb_c);
+  free_aligned_buffer_page_end(dst_argb_opt);
+  return max_diff;
+}
+
+TEST_F(LibYUVPlanarTest, ARGBAdd_Any) {
+  int max_diff =
+      TestAdd(benchmark_width_ + 1, benchmark_height_, benchmark_iterations_,
+              disable_cpu_flags_, benchmark_cpu_info_, +1, 0);
+  EXPECT_LE(max_diff, 1);
+}
+
+TEST_F(LibYUVPlanarTest, ARGBAdd_Unaligned) {
+  int max_diff =
+      TestAdd(benchmark_width_, benchmark_height_, benchmark_iterations_,
+              disable_cpu_flags_, benchmark_cpu_info_, +1, 1);
+  EXPECT_LE(max_diff, 1);
+}
+
+TEST_F(LibYUVPlanarTest, ARGBAdd_Invert) {
+  int max_diff =
+      TestAdd(benchmark_width_, benchmark_height_, benchmark_iterations_,
+              disable_cpu_flags_, benchmark_cpu_info_, -1, 0);
+  EXPECT_LE(max_diff, 1);
+}
+
+TEST_F(LibYUVPlanarTest, ARGBAdd_Opt) {
+  int max_diff =
+      TestAdd(benchmark_width_, benchmark_height_, benchmark_iterations_,
+              disable_cpu_flags_, benchmark_cpu_info_, +1, 0);
+  EXPECT_LE(max_diff, 1);
+}
+
+static int TestSubtract(int width,
+                        int height,
+                        int benchmark_iterations,
+                        int disable_cpu_flags,
+                        int benchmark_cpu_info,
+                        int invert,
+                        int off) {
+  if (width < 1) {
+    width = 1;
+  }
+  const int kBpp = 4;
+  const int kStride = width * kBpp;
+  align_buffer_page_end(src_argb_a, kStride * height + off);
+  align_buffer_page_end(src_argb_b, kStride * height + off);
+  align_buffer_page_end(dst_argb_c, kStride * height);
+  align_buffer_page_end(dst_argb_opt, kStride * height);
+  for (int i = 0; i < kStride * height; ++i) {
+    src_argb_a[i + off] = (fastrand() & 0xff);
+    src_argb_b[i + off] = (fastrand() & 0xff);
+  }
+  memset(dst_argb_c, 0, kStride * height);
+  memset(dst_argb_opt, 0, kStride * height);
+
+  MaskCpuFlags(disable_cpu_flags);
+  ARGBSubtract(src_argb_a + off, kStride, src_argb_b + off, kStride, dst_argb_c,
+               kStride, width, invert * height);
+  MaskCpuFlags(benchmark_cpu_info);
+  for (int i = 0; i < benchmark_iterations; ++i) {
+    ARGBSubtract(src_argb_a + off, kStride, src_argb_b + off, kStride,
+                 dst_argb_opt, kStride, width, invert * height);
+  }
+  int max_diff = 0;
+  for (int i = 0; i < kStride * height; ++i) {
+    int abs_diff = abs(static_cast<int>(dst_argb_c[i]) -
+                       static_cast<int>(dst_argb_opt[i]));
+    if (abs_diff > max_diff) {
+      max_diff = abs_diff;
+    }
+  }
+  free_aligned_buffer_page_end(src_argb_a);
+  free_aligned_buffer_page_end(src_argb_b);
+  free_aligned_buffer_page_end(dst_argb_c);
+  free_aligned_buffer_page_end(dst_argb_opt);
+  return max_diff;
+}
+
+TEST_F(LibYUVPlanarTest, ARGBSubtract_Any) {
+  int max_diff = TestSubtract(benchmark_width_ + 1, benchmark_height_,
+                              benchmark_iterations_, disable_cpu_flags_,
+                              benchmark_cpu_info_, +1, 0);
+  EXPECT_LE(max_diff, 1);
+}
+
+TEST_F(LibYUVPlanarTest, ARGBSubtract_Unaligned) {
+  int max_diff =
+      TestSubtract(benchmark_width_, benchmark_height_, benchmark_iterations_,
+                   disable_cpu_flags_, benchmark_cpu_info_, +1, 1);
+  EXPECT_LE(max_diff, 1);
+}
+
+TEST_F(LibYUVPlanarTest, ARGBSubtract_Invert) {
+  int max_diff =
+      TestSubtract(benchmark_width_, benchmark_height_, benchmark_iterations_,
+                   disable_cpu_flags_, benchmark_cpu_info_, -1, 0);
+  EXPECT_LE(max_diff, 1);
+}
+
+TEST_F(LibYUVPlanarTest, ARGBSubtract_Opt) {
+  int max_diff =
+      TestSubtract(benchmark_width_, benchmark_height_, benchmark_iterations_,
+                   disable_cpu_flags_, benchmark_cpu_info_, +1, 0);
+  EXPECT_LE(max_diff, 1);
+}
+
+static int TestSobel(int width,
+                     int height,
+                     int benchmark_iterations,
+                     int disable_cpu_flags,
+                     int benchmark_cpu_info,
+                     int invert,
+                     int off) {
+  if (width < 1) {
+    width = 1;
+  }
+  const int kBpp = 4;
+  const int kStride = width * kBpp;
+  align_buffer_page_end(src_argb_a, kStride * height + off);
+  align_buffer_page_end(dst_argb_c, kStride * height);
+  align_buffer_page_end(dst_argb_opt, kStride * height);
+  memset(src_argb_a, 0, kStride * height + off);
+  for (int i = 0; i < kStride * height; ++i) {
+    src_argb_a[i + off] = (fastrand() & 0xff);
+  }
+  memset(dst_argb_c, 0, kStride * height);
+  memset(dst_argb_opt, 0, kStride * height);
+
+  MaskCpuFlags(disable_cpu_flags);
+  ARGBSobel(src_argb_a + off, kStride, dst_argb_c, kStride, width,
+            invert * height);
+  MaskCpuFlags(benchmark_cpu_info);
+  for (int i = 0; i < benchmark_iterations; ++i) {
+    ARGBSobel(src_argb_a + off, kStride, dst_argb_opt, kStride, width,
+              invert * height);
+  }
+  int max_diff = 0;
+  for (int i = 0; i < kStride * height; ++i) {
+    int abs_diff = abs(static_cast<int>(dst_argb_c[i]) -
+                       static_cast<int>(dst_argb_opt[i]));
+    if (abs_diff > max_diff) {
+      max_diff = abs_diff;
+    }
+  }
+  free_aligned_buffer_page_end(src_argb_a);
+  free_aligned_buffer_page_end(dst_argb_c);
+  free_aligned_buffer_page_end(dst_argb_opt);
+  return max_diff;
+}
+
+TEST_F(LibYUVPlanarTest, ARGBSobel_Any) {
+  int max_diff =
+      TestSobel(benchmark_width_ + 1, benchmark_height_, benchmark_iterations_,
+                disable_cpu_flags_, benchmark_cpu_info_, +1, 0);
+  EXPECT_EQ(0, max_diff);
+}
+
+TEST_F(LibYUVPlanarTest, ARGBSobel_Unaligned) {
+  int max_diff =
+      TestSobel(benchmark_width_, benchmark_height_, benchmark_iterations_,
+                disable_cpu_flags_, benchmark_cpu_info_, +1, 1);
+  EXPECT_EQ(0, max_diff);
+}
+
+TEST_F(LibYUVPlanarTest, ARGBSobel_Invert) {
+  int max_diff =
+      TestSobel(benchmark_width_, benchmark_height_, benchmark_iterations_,
+                disable_cpu_flags_, benchmark_cpu_info_, -1, 0);
+  EXPECT_EQ(0, max_diff);
+}
+
+TEST_F(LibYUVPlanarTest, ARGBSobel_Opt) {
+  int max_diff =
+      TestSobel(benchmark_width_, benchmark_height_, benchmark_iterations_,
+                disable_cpu_flags_, benchmark_cpu_info_, +1, 0);
+  EXPECT_EQ(0, max_diff);
+}
+
+static int TestSobelToPlane(int width,
+                            int height,
+                            int benchmark_iterations,
+                            int disable_cpu_flags,
+                            int benchmark_cpu_info,
+                            int invert,
+                            int off) {
+  if (width < 1) {
+    width = 1;
+  }
+  const int kSrcBpp = 4;
+  const int kDstBpp = 1;
+  const int kSrcStride = (width * kSrcBpp + 15) & ~15;
+  const int kDstStride = (width * kDstBpp + 15) & ~15;
+  align_buffer_page_end(src_argb_a, kSrcStride * height + off);
+  align_buffer_page_end(dst_argb_c, kDstStride * height);
+  align_buffer_page_end(dst_argb_opt, kDstStride * height);
+  memset(src_argb_a, 0, kSrcStride * height + off);
+  for (int i = 0; i < kSrcStride * height; ++i) {
+    src_argb_a[i + off] = (fastrand() & 0xff);
+  }
+  memset(dst_argb_c, 0, kDstStride * height);
+  memset(dst_argb_opt, 0, kDstStride * height);
+
+  MaskCpuFlags(disable_cpu_flags);
+  ARGBSobelToPlane(src_argb_a + off, kSrcStride, dst_argb_c, kDstStride, width,
+                   invert * height);
+  MaskCpuFlags(benchmark_cpu_info);
+  for (int i = 0; i < benchmark_iterations; ++i) {
+    ARGBSobelToPlane(src_argb_a + off, kSrcStride, dst_argb_opt, kDstStride,
+                     width, invert * height);
+  }
+  int max_diff = 0;
+  for (int i = 0; i < kDstStride * height; ++i) {
+    int abs_diff = abs(static_cast<int>(dst_argb_c[i]) -
+                       static_cast<int>(dst_argb_opt[i]));
+    if (abs_diff > max_diff) {
+      max_diff = abs_diff;
+    }
+  }
+  free_aligned_buffer_page_end(src_argb_a);
+  free_aligned_buffer_page_end(dst_argb_c);
+  free_aligned_buffer_page_end(dst_argb_opt);
+  return max_diff;
+}
+
+TEST_F(LibYUVPlanarTest, ARGBSobelToPlane_Any) {
+  int max_diff = TestSobelToPlane(benchmark_width_ + 1, benchmark_height_,
+                                  benchmark_iterations_, disable_cpu_flags_,
+                                  benchmark_cpu_info_, +1, 0);
+  EXPECT_EQ(0, max_diff);
+}
+
+TEST_F(LibYUVPlanarTest, ARGBSobelToPlane_Unaligned) {
+  int max_diff = TestSobelToPlane(benchmark_width_, benchmark_height_,
+                                  benchmark_iterations_, disable_cpu_flags_,
+                                  benchmark_cpu_info_, +1, 1);
+  EXPECT_EQ(0, max_diff);
+}
+
+TEST_F(LibYUVPlanarTest, ARGBSobelToPlane_Invert) {
+  int max_diff = TestSobelToPlane(benchmark_width_, benchmark_height_,
+                                  benchmark_iterations_, disable_cpu_flags_,
+                                  benchmark_cpu_info_, -1, 0);
+  EXPECT_EQ(0, max_diff);
+}
+
+TEST_F(LibYUVPlanarTest, ARGBSobelToPlane_Opt) {
+  int max_diff = TestSobelToPlane(benchmark_width_, benchmark_height_,
+                                  benchmark_iterations_, disable_cpu_flags_,
+                                  benchmark_cpu_info_, +1, 0);
+  EXPECT_EQ(0, max_diff);
+}
+
+static int TestSobelXY(int width,
+                       int height,
+                       int benchmark_iterations,
+                       int disable_cpu_flags,
+                       int benchmark_cpu_info,
+                       int invert,
+                       int off) {
+  if (width < 1) {
+    width = 1;
+  }
+  const int kBpp = 4;
+  const int kStride = width * kBpp;
+  align_buffer_page_end(src_argb_a, kStride * height + off);
+  align_buffer_page_end(dst_argb_c, kStride * height);
+  align_buffer_page_end(dst_argb_opt, kStride * height);
+  memset(src_argb_a, 0, kStride * height + off);
+  for (int i = 0; i < kStride * height; ++i) {
+    src_argb_a[i + off] = (fastrand() & 0xff);
+  }
+  memset(dst_argb_c, 0, kStride * height);
+  memset(dst_argb_opt, 0, kStride * height);
+
+  MaskCpuFlags(disable_cpu_flags);
+  ARGBSobelXY(src_argb_a + off, kStride, dst_argb_c, kStride, width,
+              invert * height);
+  MaskCpuFlags(benchmark_cpu_info);
+  for (int i = 0; i < benchmark_iterations; ++i) {
+    ARGBSobelXY(src_argb_a + off, kStride, dst_argb_opt, kStride, width,
+                invert * height);
+  }
+  int max_diff = 0;
+  for (int i = 0; i < kStride * height; ++i) {
+    int abs_diff = abs(static_cast<int>(dst_argb_c[i]) -
+                       static_cast<int>(dst_argb_opt[i]));
+    if (abs_diff > max_diff) {
+      max_diff = abs_diff;
+    }
+  }
+  free_aligned_buffer_page_end(src_argb_a);
+  free_aligned_buffer_page_end(dst_argb_c);
+  free_aligned_buffer_page_end(dst_argb_opt);
+  return max_diff;
+}
+
+TEST_F(LibYUVPlanarTest, ARGBSobelXY_Any) {
+  int max_diff = TestSobelXY(benchmark_width_ + 1, benchmark_height_,
+                             benchmark_iterations_, disable_cpu_flags_,
+                             benchmark_cpu_info_, +1, 0);
+  EXPECT_EQ(0, max_diff);
+}
+
+TEST_F(LibYUVPlanarTest, ARGBSobelXY_Unaligned) {
+  int max_diff =
+      TestSobelXY(benchmark_width_, benchmark_height_, benchmark_iterations_,
+                  disable_cpu_flags_, benchmark_cpu_info_, +1, 1);
+  EXPECT_EQ(0, max_diff);
+}
+
+TEST_F(LibYUVPlanarTest, ARGBSobelXY_Invert) {
+  int max_diff =
+      TestSobelXY(benchmark_width_, benchmark_height_, benchmark_iterations_,
+                  disable_cpu_flags_, benchmark_cpu_info_, -1, 0);
+  EXPECT_EQ(0, max_diff);
+}
+
+TEST_F(LibYUVPlanarTest, ARGBSobelXY_Opt) {
+  int max_diff =
+      TestSobelXY(benchmark_width_, benchmark_height_, benchmark_iterations_,
+                  disable_cpu_flags_, benchmark_cpu_info_, +1, 0);
+  EXPECT_EQ(0, max_diff);
+}
+
+static int TestBlur(int width,
+                    int height,
+                    int benchmark_iterations,
+                    int disable_cpu_flags,
+                    int benchmark_cpu_info,
+                    int invert,
+                    int off,
+                    int radius) {
+  if (width < 1) {
+    width = 1;
+  }
+  const int kBpp = 4;
+  const int kStride = width * kBpp;
+  align_buffer_page_end(src_argb_a, kStride * height + off);
+  align_buffer_page_end(dst_cumsum, width * height * 16);
+  align_buffer_page_end(dst_argb_c, kStride * height);
+  align_buffer_page_end(dst_argb_opt, kStride * height);
+  for (int i = 0; i < kStride * height; ++i) {
+    src_argb_a[i + off] = (fastrand() & 0xff);
+  }
+  memset(dst_cumsum, 0, width * height * 16);
+  memset(dst_argb_c, 0, kStride * height);
+  memset(dst_argb_opt, 0, kStride * height);
+
+  MaskCpuFlags(disable_cpu_flags);
+  ARGBBlur(src_argb_a + off, kStride, dst_argb_c, kStride,
+           reinterpret_cast<int32_t*>(dst_cumsum), width * 4, width,
+           invert * height, radius);
+  MaskCpuFlags(benchmark_cpu_info);
+  for (int i = 0; i < benchmark_iterations; ++i) {
+    ARGBBlur(src_argb_a + off, kStride, dst_argb_opt, kStride,
+             reinterpret_cast<int32_t*>(dst_cumsum), width * 4, width,
+             invert * height, radius);
+  }
+  int max_diff = 0;
+  for (int i = 0; i < kStride * height; ++i) {
+    int abs_diff = abs(static_cast<int>(dst_argb_c[i]) -
+                       static_cast<int>(dst_argb_opt[i]));
+    if (abs_diff > max_diff) {
+      max_diff = abs_diff;
+    }
+  }
+  free_aligned_buffer_page_end(src_argb_a);
+  free_aligned_buffer_page_end(dst_cumsum);
+  free_aligned_buffer_page_end(dst_argb_c);
+  free_aligned_buffer_page_end(dst_argb_opt);
+  return max_diff;
+}
+
+#if !defined(DISABLE_SLOW_TESTS) || defined(__x86_64__) || defined(__i386__)
+#define DISABLED_ARM(name) name
+#else
+#define DISABLED_ARM(name) DISABLED_##name
+#endif
+
+static const int kBlurSize = 55;
+TEST_F(LibYUVPlanarTest, DISABLED_ARM(ARGBBlur_Any)) {
+  int max_diff =
+      TestBlur(benchmark_width_ + 1, benchmark_height_, benchmark_iterations_,
+               disable_cpu_flags_, benchmark_cpu_info_, +1, 0, kBlurSize);
+  EXPECT_LE(max_diff, 1);
+}
+
+TEST_F(LibYUVPlanarTest, DISABLED_ARM(ARGBBlur_Unaligned)) {
+  int max_diff =
+      TestBlur(benchmark_width_, benchmark_height_, benchmark_iterations_,
+               disable_cpu_flags_, benchmark_cpu_info_, +1, 1, kBlurSize);
+  EXPECT_LE(max_diff, 1);
+}
+
+TEST_F(LibYUVPlanarTest, DISABLED_ARM(ARGBBlur_Invert)) {
+  int max_diff =
+      TestBlur(benchmark_width_, benchmark_height_, benchmark_iterations_,
+               disable_cpu_flags_, benchmark_cpu_info_, -1, 0, kBlurSize);
+  EXPECT_LE(max_diff, 1);
+}
+
+TEST_F(LibYUVPlanarTest, DISABLED_ARM(ARGBBlur_Opt)) {
+  int max_diff =
+      TestBlur(benchmark_width_, benchmark_height_, benchmark_iterations_,
+               disable_cpu_flags_, benchmark_cpu_info_, +1, 0, kBlurSize);
+  EXPECT_LE(max_diff, 1);
+}
+
+static const int kBlurSmallSize = 5;
+TEST_F(LibYUVPlanarTest, DISABLED_ARM(ARGBBlurSmall_Any)) {
+  int max_diff =
+      TestBlur(benchmark_width_ + 1, benchmark_height_, benchmark_iterations_,
+               disable_cpu_flags_, benchmark_cpu_info_, +1, 0, kBlurSmallSize);
+  EXPECT_LE(max_diff, 1);
+}
+
+TEST_F(LibYUVPlanarTest, DISABLED_ARM(ARGBBlurSmall_Unaligned)) {
+  int max_diff =
+      TestBlur(benchmark_width_, benchmark_height_, benchmark_iterations_,
+               disable_cpu_flags_, benchmark_cpu_info_, +1, 1, kBlurSmallSize);
+  EXPECT_LE(max_diff, 1);
+}
+
+TEST_F(LibYUVPlanarTest, DISABLED_ARM(ARGBBlurSmall_Invert)) {
+  int max_diff =
+      TestBlur(benchmark_width_, benchmark_height_, benchmark_iterations_,
+               disable_cpu_flags_, benchmark_cpu_info_, -1, 0, kBlurSmallSize);
+  EXPECT_LE(max_diff, 1);
+}
+
+TEST_F(LibYUVPlanarTest, DISABLED_ARM(ARGBBlurSmall_Opt)) {
+  int max_diff =
+      TestBlur(benchmark_width_, benchmark_height_, benchmark_iterations_,
+               disable_cpu_flags_, benchmark_cpu_info_, +1, 0, kBlurSmallSize);
+  EXPECT_LE(max_diff, 1);
+}
+
+TEST_F(LibYUVPlanarTest, DISABLED_ARM(TestARGBPolynomial)) {
+  SIMD_ALIGNED(uint8_t orig_pixels[1280][4]);
+  SIMD_ALIGNED(uint8_t dst_pixels_opt[1280][4]);
+  SIMD_ALIGNED(uint8_t dst_pixels_c[1280][4]);
+  memset(orig_pixels, 0, sizeof(orig_pixels));
+
+  SIMD_ALIGNED(static const float kWarmifyPolynomial[16]) = {
+      0.94230f,  -3.03300f,    -2.92500f,    0.f,  // C0
+      0.584500f, 1.112000f,    1.535000f,    1.f,  // C1 x
+      0.001313f, -0.002503f,   -0.004496f,   0.f,  // C2 x * x
+      0.0f,      0.000006965f, 0.000008781f, 0.f,  // C3 x * x * x
+  };
+
+  // Test blue
+  orig_pixels[0][0] = 255u;
+  orig_pixels[0][1] = 0u;
+  orig_pixels[0][2] = 0u;
+  orig_pixels[0][3] = 128u;
+  // Test green
+  orig_pixels[1][0] = 0u;
+  orig_pixels[1][1] = 255u;
+  orig_pixels[1][2] = 0u;
+  orig_pixels[1][3] = 0u;
+  // Test red
+  orig_pixels[2][0] = 0u;
+  orig_pixels[2][1] = 0u;
+  orig_pixels[2][2] = 255u;
+  orig_pixels[2][3] = 255u;
+  // Test white
+  orig_pixels[3][0] = 255u;
+  orig_pixels[3][1] = 255u;
+  orig_pixels[3][2] = 255u;
+  orig_pixels[3][3] = 255u;
+  // Test color
+  orig_pixels[4][0] = 16u;
+  orig_pixels[4][1] = 64u;
+  orig_pixels[4][2] = 192u;
+  orig_pixels[4][3] = 224u;
+  // Do 16 to test asm version.
+  ARGBPolynomial(&orig_pixels[0][0], 0, &dst_pixels_opt[0][0], 0,
+                 &kWarmifyPolynomial[0], 16, 1);
+  EXPECT_EQ(235u, dst_pixels_opt[0][0]);
+  EXPECT_EQ(0u, dst_pixels_opt[0][1]);
+  EXPECT_EQ(0u, dst_pixels_opt[0][2]);
+  EXPECT_EQ(128u, dst_pixels_opt[0][3]);
+  EXPECT_EQ(0u, dst_pixels_opt[1][0]);
+  EXPECT_EQ(233u, dst_pixels_opt[1][1]);
+  EXPECT_EQ(0u, dst_pixels_opt[1][2]);
+  EXPECT_EQ(0u, dst_pixels_opt[1][3]);
+  EXPECT_EQ(0u, dst_pixels_opt[2][0]);
+  EXPECT_EQ(0u, dst_pixels_opt[2][1]);
+  EXPECT_EQ(241u, dst_pixels_opt[2][2]);
+  EXPECT_EQ(255u, dst_pixels_opt[2][3]);
+  EXPECT_EQ(235u, dst_pixels_opt[3][0]);
+  EXPECT_EQ(233u, dst_pixels_opt[3][1]);
+  EXPECT_EQ(241u, dst_pixels_opt[3][2]);
+  EXPECT_EQ(255u, dst_pixels_opt[3][3]);
+  EXPECT_EQ(10u, dst_pixels_opt[4][0]);
+  EXPECT_EQ(59u, dst_pixels_opt[4][1]);
+  EXPECT_EQ(188u, dst_pixels_opt[4][2]);
+  EXPECT_EQ(224u, dst_pixels_opt[4][3]);
+
+  for (int i = 0; i < 1280; ++i) {
+    orig_pixels[i][0] = i;
+    orig_pixels[i][1] = i / 2;
+    orig_pixels[i][2] = i / 3;
+    orig_pixels[i][3] = i;
+  }
+
+  MaskCpuFlags(disable_cpu_flags_);
+  ARGBPolynomial(&orig_pixels[0][0], 0, &dst_pixels_c[0][0], 0,
+                 &kWarmifyPolynomial[0], 1280, 1);
+  MaskCpuFlags(benchmark_cpu_info_);
+
+  for (int i = 0; i < benchmark_pixels_div1280_; ++i) {
+    ARGBPolynomial(&orig_pixels[0][0], 0, &dst_pixels_opt[0][0], 0,
+                   &kWarmifyPolynomial[0], 1280, 1);
+  }
+
+  for (int i = 0; i < 1280; ++i) {
+    EXPECT_EQ(dst_pixels_c[i][0], dst_pixels_opt[i][0]);
+    EXPECT_EQ(dst_pixels_c[i][1], dst_pixels_opt[i][1]);
+    EXPECT_EQ(dst_pixels_c[i][2], dst_pixels_opt[i][2]);
+    EXPECT_EQ(dst_pixels_c[i][3], dst_pixels_opt[i][3]);
+  }
+}
+
+int TestHalfFloatPlane(int benchmark_width,
+                       int benchmark_height,
+                       int benchmark_iterations,
+                       int disable_cpu_flags,
+                       int benchmark_cpu_info,
+                       float scale,
+                       int mask) {
+  int i, j;
+  const int y_plane_size = benchmark_width * benchmark_height * 2;
+
+  align_buffer_page_end(orig_y, y_plane_size * 3);
+  uint8_t* dst_opt = orig_y + y_plane_size;
+  uint8_t* dst_c = orig_y + y_plane_size * 2;
+
+  MemRandomize(orig_y, y_plane_size);
+  memset(dst_c, 0, y_plane_size);
+  memset(dst_opt, 1, y_plane_size);
+
+  for (i = 0; i < y_plane_size / 2; ++i) {
+    reinterpret_cast<uint16_t*>(orig_y)[i] &= mask;
+  }
+
+  // Disable all optimizations.
+  MaskCpuFlags(disable_cpu_flags);
+  for (j = 0; j < benchmark_iterations; j++) {
+    HalfFloatPlane(reinterpret_cast<uint16_t*>(orig_y), benchmark_width * 2,
+                   reinterpret_cast<uint16_t*>(dst_c), benchmark_width * 2,
+                   scale, benchmark_width, benchmark_height);
+  }
+
+  // Enable optimizations.
+  MaskCpuFlags(benchmark_cpu_info);
+  for (j = 0; j < benchmark_iterations; j++) {
+    HalfFloatPlane(reinterpret_cast<uint16_t*>(orig_y), benchmark_width * 2,
+                   reinterpret_cast<uint16_t*>(dst_opt), benchmark_width * 2,
+                   scale, benchmark_width, benchmark_height);
+  }
+
+  int max_diff = 0;
+  for (i = 0; i < y_plane_size / 2; ++i) {
+    int abs_diff =
+        abs(static_cast<int>(reinterpret_cast<uint16_t*>(dst_c)[i]) -
+            static_cast<int>(reinterpret_cast<uint16_t*>(dst_opt)[i]));
+    if (abs_diff > max_diff) {
+      max_diff = abs_diff;
+    }
+  }
+
+  free_aligned_buffer_page_end(orig_y);
+  return max_diff;
+}
+
+#if defined(__arm__)
+static void EnableFlushDenormalToZero(void) {
+  uint32_t cw;
+  __asm__ __volatile__(
+      "vmrs   %0, fpscr         \n"
+      "orr    %0, %0, #0x1000000        \n"
+      "vmsr   fpscr, %0         \n"
+      : "=r"(cw)::"memory");
+}
+#endif
+
+// 5 bit exponent with bias of 15 will underflow to a denormal if scale causes
+// exponent to be less than 0.  15 - log2(65536) = -1/  This shouldnt normally
+// happen since scale is 1/(1<<bits) where bits is 9, 10 or 12.
+
+TEST_F(LibYUVPlanarTest, TestHalfFloatPlane_16bit_denormal) {
+// 32 bit arm rounding on denormal case is off by 1 compared to C.
+#if defined(__arm__)
+  EnableFlushDenormalToZero();
+#endif
+  int diff = TestHalfFloatPlane(benchmark_width_, benchmark_height_,
+                                benchmark_iterations_, disable_cpu_flags_,
+                                benchmark_cpu_info_, 1.0f / 65536.0f, 65535);
+  EXPECT_EQ(0, diff);
+}
+
+TEST_F(LibYUVPlanarTest, TestHalfFloatPlane_16bit_One) {
+  int diff = TestHalfFloatPlane(benchmark_width_, benchmark_height_,
+                                benchmark_iterations_, disable_cpu_flags_,
+                                benchmark_cpu_info_, 1.0f, 65535);
+  EXPECT_LE(diff, 1);
+}
+
+TEST_F(LibYUVPlanarTest, TestHalfFloatPlane_16bit_Opt) {
+  int diff = TestHalfFloatPlane(benchmark_width_, benchmark_height_,
+                                benchmark_iterations_, disable_cpu_flags_,
+                                benchmark_cpu_info_, 1.0f / 4096.0f, 65535);
+  EXPECT_EQ(0, diff);
+}
+
+TEST_F(LibYUVPlanarTest, TestHalfFloatPlane_10bit_Opt) {
+  int diff = TestHalfFloatPlane(benchmark_width_, benchmark_height_,
+                                benchmark_iterations_, disable_cpu_flags_,
+                                benchmark_cpu_info_, 1.0f / 1024.0f, 1023);
+  EXPECT_EQ(0, diff);
+}
+
+TEST_F(LibYUVPlanarTest, TestHalfFloatPlane_9bit_Opt) {
+  int diff = TestHalfFloatPlane(benchmark_width_, benchmark_height_,
+                                benchmark_iterations_, disable_cpu_flags_,
+                                benchmark_cpu_info_, 1.0f / 512.0f, 511);
+  EXPECT_EQ(0, diff);
+}
+
+TEST_F(LibYUVPlanarTest, TestHalfFloatPlane_Opt) {
+  int diff = TestHalfFloatPlane(benchmark_width_, benchmark_height_,
+                                benchmark_iterations_, disable_cpu_flags_,
+                                benchmark_cpu_info_, 1.0f / 4096.0f, 4095);
+  EXPECT_EQ(0, diff);
+}
+
+TEST_F(LibYUVPlanarTest, TestHalfFloatPlane_Offby1) {
+  int diff = TestHalfFloatPlane(benchmark_width_, benchmark_height_,
+                                benchmark_iterations_, disable_cpu_flags_,
+                                benchmark_cpu_info_, 1.0f / 4095.0f, 4095);
+  EXPECT_EQ(0, diff);
+}
+
+TEST_F(LibYUVPlanarTest, TestHalfFloatPlane_One) {
+  int diff = TestHalfFloatPlane(benchmark_width_, benchmark_height_,
+                                benchmark_iterations_, disable_cpu_flags_,
+                                benchmark_cpu_info_, 1.0f, 2047);
+  EXPECT_EQ(0, diff);
+}
+
+TEST_F(LibYUVPlanarTest, TestHalfFloatPlane_12bit_One) {
+  int diff = TestHalfFloatPlane(benchmark_width_, benchmark_height_,
+                                benchmark_iterations_, disable_cpu_flags_,
+                                benchmark_cpu_info_, 1.0f, 4095);
+  EXPECT_LE(diff, 1);
+}
+
+float TestByteToFloat(int benchmark_width,
+                      int benchmark_height,
+                      int benchmark_iterations,
+                      int disable_cpu_flags,
+                      int benchmark_cpu_info,
+                      float scale) {
+  int i, j;
+  const int y_plane_size = benchmark_width * benchmark_height;
+
+  align_buffer_page_end(orig_y, y_plane_size * (1 + 4 + 4));
+  float* dst_opt = reinterpret_cast<float*>(orig_y + y_plane_size);
+  float* dst_c = reinterpret_cast<float*>(orig_y + y_plane_size * 5);
+
+  MemRandomize(orig_y, y_plane_size);
+  memset(dst_c, 0, y_plane_size * 4);
+  memset(dst_opt, 1, y_plane_size * 4);
+
+  // Disable all optimizations.
+  MaskCpuFlags(disable_cpu_flags);
+  ByteToFloat(orig_y, dst_c, scale, y_plane_size);
+
+  // Enable optimizations.
+  MaskCpuFlags(benchmark_cpu_info);
+  for (j = 0; j < benchmark_iterations; j++) {
+    ByteToFloat(orig_y, dst_opt, scale, y_plane_size);
+  }
+
+  float max_diff = 0;
+  for (i = 0; i < y_plane_size; ++i) {
+    float abs_diff = fabs(dst_c[i] - dst_opt[i]);
+    if (abs_diff > max_diff) {
+      max_diff = abs_diff;
+    }
+  }
+
+  free_aligned_buffer_page_end(orig_y);
+  return max_diff;
+}
+
+TEST_F(LibYUVPlanarTest, TestByteToFloat) {
+  float diff = TestByteToFloat(benchmark_width_, benchmark_height_,
+                               benchmark_iterations_, disable_cpu_flags_,
+                               benchmark_cpu_info_, 1.0f);
+  EXPECT_EQ(0.f, diff);
+}
+
+TEST_F(LibYUVPlanarTest, TestARGBLumaColorTable) {
+  SIMD_ALIGNED(uint8_t orig_pixels[1280][4]);
+  SIMD_ALIGNED(uint8_t dst_pixels_opt[1280][4]);
+  SIMD_ALIGNED(uint8_t dst_pixels_c[1280][4]);
+  memset(orig_pixels, 0, sizeof(orig_pixels));
+
+  align_buffer_page_end(lumacolortable, 32768);
+  int v = 0;
+  for (int i = 0; i < 32768; ++i) {
+    lumacolortable[i] = v;
+    v += 3;
+  }
+  // Test blue
+  orig_pixels[0][0] = 255u;
+  orig_pixels[0][1] = 0u;
+  orig_pixels[0][2] = 0u;
+  orig_pixels[0][3] = 128u;
+  // Test green
+  orig_pixels[1][0] = 0u;
+  orig_pixels[1][1] = 255u;
+  orig_pixels[1][2] = 0u;
+  orig_pixels[1][3] = 0u;
+  // Test red
+  orig_pixels[2][0] = 0u;
+  orig_pixels[2][1] = 0u;
+  orig_pixels[2][2] = 255u;
+  orig_pixels[2][3] = 255u;
+  // Test color
+  orig_pixels[3][0] = 16u;
+  orig_pixels[3][1] = 64u;
+  orig_pixels[3][2] = 192u;
+  orig_pixels[3][3] = 224u;
+  // Do 16 to test asm version.
+  ARGBLumaColorTable(&orig_pixels[0][0], 0, &dst_pixels_opt[0][0], 0,
+                     &lumacolortable[0], 16, 1);
+  EXPECT_EQ(253u, dst_pixels_opt[0][0]);
+  EXPECT_EQ(0u, dst_pixels_opt[0][1]);
+  EXPECT_EQ(0u, dst_pixels_opt[0][2]);
+  EXPECT_EQ(128u, dst_pixels_opt[0][3]);
+  EXPECT_EQ(0u, dst_pixels_opt[1][0]);
+  EXPECT_EQ(253u, dst_pixels_opt[1][1]);
+  EXPECT_EQ(0u, dst_pixels_opt[1][2]);
+  EXPECT_EQ(0u, dst_pixels_opt[1][3]);
+  EXPECT_EQ(0u, dst_pixels_opt[2][0]);
+  EXPECT_EQ(0u, dst_pixels_opt[2][1]);
+  EXPECT_EQ(253u, dst_pixels_opt[2][2]);
+  EXPECT_EQ(255u, dst_pixels_opt[2][3]);
+  EXPECT_EQ(48u, dst_pixels_opt[3][0]);
+  EXPECT_EQ(192u, dst_pixels_opt[3][1]);
+  EXPECT_EQ(64u, dst_pixels_opt[3][2]);
+  EXPECT_EQ(224u, dst_pixels_opt[3][3]);
+
+  for (int i = 0; i < 1280; ++i) {
+    orig_pixels[i][0] = i;
+    orig_pixels[i][1] = i / 2;
+    orig_pixels[i][2] = i / 3;
+    orig_pixels[i][3] = i;
+  }
+
+  MaskCpuFlags(disable_cpu_flags_);
+  ARGBLumaColorTable(&orig_pixels[0][0], 0, &dst_pixels_c[0][0], 0,
+                     lumacolortable, 1280, 1);
+  MaskCpuFlags(benchmark_cpu_info_);
+
+  for (int i = 0; i < benchmark_pixels_div1280_; ++i) {
+    ARGBLumaColorTable(&orig_pixels[0][0], 0, &dst_pixels_opt[0][0], 0,
+                       lumacolortable, 1280, 1);
+  }
+  for (int i = 0; i < 1280; ++i) {
+    EXPECT_EQ(dst_pixels_c[i][0], dst_pixels_opt[i][0]);
+    EXPECT_EQ(dst_pixels_c[i][1], dst_pixels_opt[i][1]);
+    EXPECT_EQ(dst_pixels_c[i][2], dst_pixels_opt[i][2]);
+    EXPECT_EQ(dst_pixels_c[i][3], dst_pixels_opt[i][3]);
+  }
+
+  free_aligned_buffer_page_end(lumacolortable);
+}
+
+TEST_F(LibYUVPlanarTest, TestARGBCopyAlpha) {
+  const int kSize = benchmark_width_ * benchmark_height_ * 4;
+  align_buffer_page_end(orig_pixels, kSize);
+  align_buffer_page_end(dst_pixels_opt, kSize);
+  align_buffer_page_end(dst_pixels_c, kSize);
+
+  MemRandomize(orig_pixels, kSize);
+  MemRandomize(dst_pixels_opt, kSize);
+  memcpy(dst_pixels_c, dst_pixels_opt, kSize);
+
+  MaskCpuFlags(disable_cpu_flags_);
+  ARGBCopyAlpha(orig_pixels, benchmark_width_ * 4, dst_pixels_c,
+                benchmark_width_ * 4, benchmark_width_, benchmark_height_);
+  MaskCpuFlags(benchmark_cpu_info_);
+
+  for (int i = 0; i < benchmark_iterations_; ++i) {
+    ARGBCopyAlpha(orig_pixels, benchmark_width_ * 4, dst_pixels_opt,
+                  benchmark_width_ * 4, benchmark_width_, benchmark_height_);
+  }
+  for (int i = 0; i < kSize; ++i) {
+    EXPECT_EQ(dst_pixels_c[i], dst_pixels_opt[i]);
+  }
+
+  free_aligned_buffer_page_end(dst_pixels_c);
+  free_aligned_buffer_page_end(dst_pixels_opt);
+  free_aligned_buffer_page_end(orig_pixels);
+}
+
+TEST_F(LibYUVPlanarTest, TestARGBExtractAlpha) {
+  const int kPixels = benchmark_width_ * benchmark_height_;
+  align_buffer_page_end(src_pixels, kPixels * 4);
+  align_buffer_page_end(dst_pixels_opt, kPixels);
+  align_buffer_page_end(dst_pixels_c, kPixels);
+
+  MemRandomize(src_pixels, kPixels * 4);
+  MemRandomize(dst_pixels_opt, kPixels);
+  memcpy(dst_pixels_c, dst_pixels_opt, kPixels);
+
+  MaskCpuFlags(disable_cpu_flags_);
+  ARGBExtractAlpha(src_pixels, benchmark_width_ * 4, dst_pixels_c,
+                   benchmark_width_, benchmark_width_, benchmark_height_);
+  MaskCpuFlags(benchmark_cpu_info_);
+
+  for (int i = 0; i < benchmark_iterations_; ++i) {
+    ARGBExtractAlpha(src_pixels, benchmark_width_ * 4, dst_pixels_opt,
+                     benchmark_width_, benchmark_width_, benchmark_height_);
+  }
+  for (int i = 0; i < kPixels; ++i) {
+    EXPECT_EQ(dst_pixels_c[i], dst_pixels_opt[i]);
+  }
+
+  free_aligned_buffer_page_end(dst_pixels_c);
+  free_aligned_buffer_page_end(dst_pixels_opt);
+  free_aligned_buffer_page_end(src_pixels);
+}
+
+TEST_F(LibYUVPlanarTest, TestARGBCopyYToAlpha) {
+  const int kPixels = benchmark_width_ * benchmark_height_;
+  align_buffer_page_end(orig_pixels, kPixels);
+  align_buffer_page_end(dst_pixels_opt, kPixels * 4);
+  align_buffer_page_end(dst_pixels_c, kPixels * 4);
+
+  MemRandomize(orig_pixels, kPixels);
+  MemRandomize(dst_pixels_opt, kPixels * 4);
+  memcpy(dst_pixels_c, dst_pixels_opt, kPixels * 4);
+
+  MaskCpuFlags(disable_cpu_flags_);
+  ARGBCopyYToAlpha(orig_pixels, benchmark_width_, dst_pixels_c,
+                   benchmark_width_ * 4, benchmark_width_, benchmark_height_);
+  MaskCpuFlags(benchmark_cpu_info_);
+
+  for (int i = 0; i < benchmark_iterations_; ++i) {
+    ARGBCopyYToAlpha(orig_pixels, benchmark_width_, dst_pixels_opt,
+                     benchmark_width_ * 4, benchmark_width_, benchmark_height_);
+  }
+  for (int i = 0; i < kPixels * 4; ++i) {
+    EXPECT_EQ(dst_pixels_c[i], dst_pixels_opt[i]);
+  }
+
+  free_aligned_buffer_page_end(dst_pixels_c);
+  free_aligned_buffer_page_end(dst_pixels_opt);
+  free_aligned_buffer_page_end(orig_pixels);
+}
+
+static int TestARGBRect(int width,
+                        int height,
+                        int benchmark_iterations,
+                        int disable_cpu_flags,
+                        int benchmark_cpu_info,
+                        int invert,
+                        int off,
+                        int bpp) {
+  if (width < 1) {
+    width = 1;
+  }
+  const int kStride = width * bpp;
+  const int kSize = kStride * height;
+  const uint32_t v32 = fastrand() & (bpp == 4 ? 0xffffffff : 0xff);
+
+  align_buffer_page_end(dst_argb_c, kSize + off);
+  align_buffer_page_end(dst_argb_opt, kSize + off);
+
+  MemRandomize(dst_argb_c + off, kSize);
+  memcpy(dst_argb_opt + off, dst_argb_c + off, kSize);
+
+  MaskCpuFlags(disable_cpu_flags);
+  if (bpp == 4) {
+    ARGBRect(dst_argb_c + off, kStride, 0, 0, width, invert * height, v32);
+  } else {
+    SetPlane(dst_argb_c + off, kStride, width, invert * height, v32);
+  }
+
+  MaskCpuFlags(benchmark_cpu_info);
+  for (int i = 0; i < benchmark_iterations; ++i) {
+    if (bpp == 4) {
+      ARGBRect(dst_argb_opt + off, kStride, 0, 0, width, invert * height, v32);
+    } else {
+      SetPlane(dst_argb_opt + off, kStride, width, invert * height, v32);
+    }
+  }
+  int max_diff = 0;
+  for (int i = 0; i < kStride * height; ++i) {
+    int abs_diff = abs(static_cast<int>(dst_argb_c[i + off]) -
+                       static_cast<int>(dst_argb_opt[i + off]));
+    if (abs_diff > max_diff) {
+      max_diff = abs_diff;
+    }
+  }
+  free_aligned_buffer_page_end(dst_argb_c);
+  free_aligned_buffer_page_end(dst_argb_opt);
+  return max_diff;
+}
+
+TEST_F(LibYUVPlanarTest, ARGBRect_Any) {
+  int max_diff = TestARGBRect(benchmark_width_ + 1, benchmark_height_,
+                              benchmark_iterations_, disable_cpu_flags_,
+                              benchmark_cpu_info_, +1, 0, 4);
+  EXPECT_EQ(0, max_diff);
+}
+
+TEST_F(LibYUVPlanarTest, ARGBRect_Unaligned) {
+  int max_diff =
+      TestARGBRect(benchmark_width_, benchmark_height_, benchmark_iterations_,
+                   disable_cpu_flags_, benchmark_cpu_info_, +1, 1, 4);
+  EXPECT_EQ(0, max_diff);
+}
+
+TEST_F(LibYUVPlanarTest, ARGBRect_Invert) {
+  int max_diff =
+      TestARGBRect(benchmark_width_, benchmark_height_, benchmark_iterations_,
+                   disable_cpu_flags_, benchmark_cpu_info_, -1, 0, 4);
+  EXPECT_EQ(0, max_diff);
+}
+
+TEST_F(LibYUVPlanarTest, ARGBRect_Opt) {
+  int max_diff =
+      TestARGBRect(benchmark_width_, benchmark_height_, benchmark_iterations_,
+                   disable_cpu_flags_, benchmark_cpu_info_, +1, 0, 4);
+  EXPECT_EQ(0, max_diff);
+}
+
+TEST_F(LibYUVPlanarTest, SetPlane_Any) {
+  int max_diff = TestARGBRect(benchmark_width_ + 1, benchmark_height_,
+                              benchmark_iterations_, disable_cpu_flags_,
+                              benchmark_cpu_info_, +1, 0, 1);
+  EXPECT_EQ(0, max_diff);
+}
+
+TEST_F(LibYUVPlanarTest, SetPlane_Unaligned) {
+  int max_diff =
+      TestARGBRect(benchmark_width_, benchmark_height_, benchmark_iterations_,
+                   disable_cpu_flags_, benchmark_cpu_info_, +1, 1, 1);
+  EXPECT_EQ(0, max_diff);
+}
+
+TEST_F(LibYUVPlanarTest, SetPlane_Invert) {
+  int max_diff =
+      TestARGBRect(benchmark_width_, benchmark_height_, benchmark_iterations_,
+                   disable_cpu_flags_, benchmark_cpu_info_, -1, 0, 1);
+  EXPECT_EQ(0, max_diff);
+}
+
+TEST_F(LibYUVPlanarTest, SetPlane_Opt) {
+  int max_diff =
+      TestARGBRect(benchmark_width_, benchmark_height_, benchmark_iterations_,
+                   disable_cpu_flags_, benchmark_cpu_info_, +1, 0, 1);
+  EXPECT_EQ(0, max_diff);
+}
+
+TEST_F(LibYUVPlanarTest, MergeUVPlane_Opt) {
+  const int kPixels = benchmark_width_ * benchmark_height_;
+  align_buffer_page_end(src_pixels_u, kPixels);
+  align_buffer_page_end(src_pixels_v, kPixels);
+  align_buffer_page_end(dst_pixels_opt, kPixels * 2);
+  align_buffer_page_end(dst_pixels_c, kPixels * 2);
+
+  MemRandomize(src_pixels_u, kPixels);
+  MemRandomize(src_pixels_v, kPixels);
+  MemRandomize(dst_pixels_opt, kPixels * 2);
+  MemRandomize(dst_pixels_c, kPixels * 2);
+
+  MaskCpuFlags(disable_cpu_flags_);
+  MergeUVPlane(src_pixels_u, benchmark_width_, src_pixels_v, benchmark_width_,
+               dst_pixels_c, benchmark_width_ * 2, benchmark_width_,
+               benchmark_height_);
+  MaskCpuFlags(benchmark_cpu_info_);
+
+  for (int i = 0; i < benchmark_iterations_; ++i) {
+    MergeUVPlane(src_pixels_u, benchmark_width_, src_pixels_v, benchmark_width_,
+                 dst_pixels_opt, benchmark_width_ * 2, benchmark_width_,
+                 benchmark_height_);
+  }
+
+  for (int i = 0; i < kPixels * 2; ++i) {
+    EXPECT_EQ(dst_pixels_c[i], dst_pixels_opt[i]);
+  }
+
+  free_aligned_buffer_page_end(src_pixels_u);
+  free_aligned_buffer_page_end(src_pixels_v);
+  free_aligned_buffer_page_end(dst_pixels_opt);
+  free_aligned_buffer_page_end(dst_pixels_c);
+}
+
+// 16 bit channel split and merge
+TEST_F(LibYUVPlanarTest, MergeUVPlane_16_Opt) {
+  const int kPixels = benchmark_width_ * benchmark_height_;
+  align_buffer_page_end(src_pixels_u, kPixels * 2);
+  align_buffer_page_end(src_pixels_v, kPixels * 2);
+  align_buffer_page_end(dst_pixels_opt, kPixels * 2 * 2);
+  align_buffer_page_end(dst_pixels_c, kPixels * 2 * 2);
+  MemRandomize(src_pixels_u, kPixels * 2);
+  MemRandomize(src_pixels_v, kPixels * 2);
+  MemRandomize(dst_pixels_opt, kPixels * 2 * 2);
+  MemRandomize(dst_pixels_c, kPixels * 2 * 2);
+
+  MaskCpuFlags(disable_cpu_flags_);
+  MergeUVPlane_16((const uint16_t*)src_pixels_u, benchmark_width_,
+                  (const uint16_t*)src_pixels_v, benchmark_width_,
+                  (uint16_t*)dst_pixels_c, benchmark_width_ * 2,
+                  benchmark_width_, benchmark_height_, 12);
+  MaskCpuFlags(benchmark_cpu_info_);
+
+  for (int i = 0; i < benchmark_iterations_; ++i) {
+    MergeUVPlane_16((const uint16_t*)src_pixels_u, benchmark_width_,
+                    (const uint16_t*)src_pixels_v, benchmark_width_,
+                    (uint16_t*)dst_pixels_opt, benchmark_width_ * 2,
+                    benchmark_width_, benchmark_height_, 12);
+  }
+
+  for (int i = 0; i < kPixels * 2 * 2; ++i) {
+    EXPECT_EQ(dst_pixels_c[i], dst_pixels_opt[i]);
+  }
+  free_aligned_buffer_page_end(src_pixels_u);
+  free_aligned_buffer_page_end(src_pixels_v);
+  free_aligned_buffer_page_end(dst_pixels_opt);
+  free_aligned_buffer_page_end(dst_pixels_c);
+}
+
+TEST_F(LibYUVPlanarTest, SplitUVPlane_Opt) {
+  const int kPixels = benchmark_width_ * benchmark_height_;
+  align_buffer_page_end(src_pixels, kPixels * 2);
+  align_buffer_page_end(dst_pixels_u_c, kPixels);
+  align_buffer_page_end(dst_pixels_v_c, kPixels);
+  align_buffer_page_end(dst_pixels_u_opt, kPixels);
+  align_buffer_page_end(dst_pixels_v_opt, kPixels);
+
+  MemRandomize(src_pixels, kPixels * 2);
+  MemRandomize(dst_pixels_u_c, kPixels);
+  MemRandomize(dst_pixels_v_c, kPixels);
+  MemRandomize(dst_pixels_u_opt, kPixels);
+  MemRandomize(dst_pixels_v_opt, kPixels);
+
+  MaskCpuFlags(disable_cpu_flags_);
+  SplitUVPlane(src_pixels, benchmark_width_ * 2, dst_pixels_u_c,
+               benchmark_width_, dst_pixels_v_c, benchmark_width_,
+               benchmark_width_, benchmark_height_);
+  MaskCpuFlags(benchmark_cpu_info_);
+
+  for (int i = 0; i < benchmark_iterations_; ++i) {
+    SplitUVPlane(src_pixels, benchmark_width_ * 2, dst_pixels_u_opt,
+                 benchmark_width_, dst_pixels_v_opt, benchmark_width_,
+                 benchmark_width_, benchmark_height_);
+  }
+
+  for (int i = 0; i < kPixels; ++i) {
+    EXPECT_EQ(dst_pixels_u_c[i], dst_pixels_u_opt[i]);
+    EXPECT_EQ(dst_pixels_v_c[i], dst_pixels_v_opt[i]);
+  }
+
+  free_aligned_buffer_page_end(src_pixels);
+  free_aligned_buffer_page_end(dst_pixels_u_c);
+  free_aligned_buffer_page_end(dst_pixels_v_c);
+  free_aligned_buffer_page_end(dst_pixels_u_opt);
+  free_aligned_buffer_page_end(dst_pixels_v_opt);
+}
+
+// 16 bit channel split
+TEST_F(LibYUVPlanarTest, SplitUVPlane_16_Opt) {
+  const int kPixels = benchmark_width_ * benchmark_height_;
+  align_buffer_page_end(src_pixels, kPixels * 2 * 2);
+  align_buffer_page_end(dst_pixels_u_c, kPixels * 2);
+  align_buffer_page_end(dst_pixels_v_c, kPixels * 2);
+  align_buffer_page_end(dst_pixels_u_opt, kPixels * 2);
+  align_buffer_page_end(dst_pixels_v_opt, kPixels * 2);
+  MemRandomize(src_pixels, kPixels * 2 * 2);
+  MemRandomize(dst_pixels_u_c, kPixels * 2);
+  MemRandomize(dst_pixels_v_c, kPixels * 2);
+  MemRandomize(dst_pixels_u_opt, kPixels * 2);
+  MemRandomize(dst_pixels_v_opt, kPixels * 2);
+
+  MaskCpuFlags(disable_cpu_flags_);
+  SplitUVPlane_16((const uint16_t*)src_pixels, benchmark_width_ * 2,
+                  (uint16_t*)dst_pixels_u_c, benchmark_width_,
+                  (uint16_t*)dst_pixels_v_c, benchmark_width_, benchmark_width_,
+                  benchmark_height_, 10);
+  MaskCpuFlags(benchmark_cpu_info_);
+
+  for (int i = 0; i < benchmark_iterations_; ++i) {
+    SplitUVPlane_16((const uint16_t*)src_pixels, benchmark_width_ * 2,
+                    (uint16_t*)dst_pixels_u_opt, benchmark_width_,
+                    (uint16_t*)dst_pixels_v_opt, benchmark_width_,
+                    benchmark_width_, benchmark_height_, 10);
+  }
+
+  for (int i = 0; i < kPixels * 2; ++i) {
+    EXPECT_EQ(dst_pixels_u_c[i], dst_pixels_u_opt[i]);
+    EXPECT_EQ(dst_pixels_v_c[i], dst_pixels_v_opt[i]);
+  }
+  free_aligned_buffer_page_end(src_pixels);
+  free_aligned_buffer_page_end(dst_pixels_u_c);
+  free_aligned_buffer_page_end(dst_pixels_v_c);
+  free_aligned_buffer_page_end(dst_pixels_u_opt);
+  free_aligned_buffer_page_end(dst_pixels_v_opt);
+}
+
+TEST_F(LibYUVPlanarTest, SwapUVPlane_Opt) {
+  // Round count up to multiple of 16
+  const int kPixels = benchmark_width_ * benchmark_height_;
+  align_buffer_page_end(src_pixels, kPixels * 2);
+  align_buffer_page_end(dst_pixels_opt, kPixels * 2);
+  align_buffer_page_end(dst_pixels_c, kPixels * 2);
+
+  MemRandomize(src_pixels, kPixels * 2);
+  MemRandomize(dst_pixels_opt, kPixels * 2);
+  MemRandomize(dst_pixels_c, kPixels * 2);
+
+  MaskCpuFlags(disable_cpu_flags_);
+  SwapUVPlane(src_pixels, benchmark_width_ * 2, dst_pixels_c,
+              benchmark_width_ * 2, benchmark_width_, benchmark_height_);
+  MaskCpuFlags(benchmark_cpu_info_);
+
+  for (int i = 0; i < benchmark_iterations_; ++i) {
+    SwapUVPlane(src_pixels, benchmark_width_ * 2, dst_pixels_opt,
+                benchmark_width_ * 2, benchmark_width_, benchmark_height_);
+  }
+
+  for (int i = 0; i < kPixels * 2; ++i) {
+    EXPECT_EQ(dst_pixels_c[i], dst_pixels_opt[i]);
+  }
+
+  free_aligned_buffer_page_end(src_pixels);
+  free_aligned_buffer_page_end(dst_pixels_opt);
+  free_aligned_buffer_page_end(dst_pixels_c);
+}
+
+TEST_F(LibYUVPlanarTest, MergeRGBPlane_Opt) {
+  // Round count up to multiple of 16
+  const int kPixels = benchmark_width_ * benchmark_height_;
+  align_buffer_page_end(src_pixels, kPixels * 3);
+  align_buffer_page_end(tmp_pixels_r, kPixels);
+  align_buffer_page_end(tmp_pixels_g, kPixels);
+  align_buffer_page_end(tmp_pixels_b, kPixels);
+  align_buffer_page_end(dst_pixels_opt, kPixels * 3);
+  align_buffer_page_end(dst_pixels_c, kPixels * 3);
+
+  MemRandomize(src_pixels, kPixels * 3);
+  MemRandomize(tmp_pixels_r, kPixels);
+  MemRandomize(tmp_pixels_g, kPixels);
+  MemRandomize(tmp_pixels_b, kPixels);
+  MemRandomize(dst_pixels_opt, kPixels * 3);
+  MemRandomize(dst_pixels_c, kPixels * 3);
+
+  MaskCpuFlags(disable_cpu_flags_);
+  SplitRGBPlane(src_pixels, benchmark_width_ * 3, tmp_pixels_r,
+                benchmark_width_, tmp_pixels_g, benchmark_width_, tmp_pixels_b,
+                benchmark_width_, benchmark_width_, benchmark_height_);
+  MergeRGBPlane(tmp_pixels_r, benchmark_width_, tmp_pixels_g, benchmark_width_,
+                tmp_pixels_b, benchmark_width_, dst_pixels_c,
+                benchmark_width_ * 3, benchmark_width_, benchmark_height_);
+  MaskCpuFlags(benchmark_cpu_info_);
+
+  SplitRGBPlane(src_pixels, benchmark_width_ * 3, tmp_pixels_r,
+                benchmark_width_, tmp_pixels_g, benchmark_width_, tmp_pixels_b,
+                benchmark_width_, benchmark_width_, benchmark_height_);
+
+  for (int i = 0; i < benchmark_iterations_; ++i) {
+    MergeRGBPlane(tmp_pixels_r, benchmark_width_, tmp_pixels_g,
+                  benchmark_width_, tmp_pixels_b, benchmark_width_,
+                  dst_pixels_opt, benchmark_width_ * 3, benchmark_width_,
+                  benchmark_height_);
+  }
+
+  for (int i = 0; i < kPixels * 3; ++i) {
+    EXPECT_EQ(dst_pixels_c[i], dst_pixels_opt[i]);
+  }
+
+  free_aligned_buffer_page_end(src_pixels);
+  free_aligned_buffer_page_end(tmp_pixels_r);
+  free_aligned_buffer_page_end(tmp_pixels_g);
+  free_aligned_buffer_page_end(tmp_pixels_b);
+  free_aligned_buffer_page_end(dst_pixels_opt);
+  free_aligned_buffer_page_end(dst_pixels_c);
+}
+
+TEST_F(LibYUVPlanarTest, SplitRGBPlane_Opt) {
+  // Round count up to multiple of 16
+  const int kPixels = benchmark_width_ * benchmark_height_;
+  align_buffer_page_end(src_pixels, kPixels * 3);
+  align_buffer_page_end(tmp_pixels_r, kPixels);
+  align_buffer_page_end(tmp_pixels_g, kPixels);
+  align_buffer_page_end(tmp_pixels_b, kPixels);
+  align_buffer_page_end(dst_pixels_opt, kPixels * 3);
+  align_buffer_page_end(dst_pixels_c, kPixels * 3);
+
+  MemRandomize(src_pixels, kPixels * 3);
+  MemRandomize(tmp_pixels_r, kPixels);
+  MemRandomize(tmp_pixels_g, kPixels);
+  MemRandomize(tmp_pixels_b, kPixels);
+  MemRandomize(dst_pixels_opt, kPixels * 3);
+  MemRandomize(dst_pixels_c, kPixels * 3);
+
+  MaskCpuFlags(disable_cpu_flags_);
+  SplitRGBPlane(src_pixels, benchmark_width_ * 3, tmp_pixels_r,
+                benchmark_width_, tmp_pixels_g, benchmark_width_, tmp_pixels_b,
+                benchmark_width_, benchmark_width_, benchmark_height_);
+  MergeRGBPlane(tmp_pixels_r, benchmark_width_, tmp_pixels_g, benchmark_width_,
+                tmp_pixels_b, benchmark_width_, dst_pixels_c,
+                benchmark_width_ * 3, benchmark_width_, benchmark_height_);
+  MaskCpuFlags(benchmark_cpu_info_);
+
+  for (int i = 0; i < benchmark_iterations_; ++i) {
+    SplitRGBPlane(src_pixels, benchmark_width_ * 3, tmp_pixels_r,
+                  benchmark_width_, tmp_pixels_g, benchmark_width_,
+                  tmp_pixels_b, benchmark_width_, benchmark_width_,
+                  benchmark_height_);
+  }
+  MergeRGBPlane(tmp_pixels_r, benchmark_width_, tmp_pixels_g, benchmark_width_,
+                tmp_pixels_b, benchmark_width_, dst_pixels_opt,
+                benchmark_width_ * 3, benchmark_width_, benchmark_height_);
+
+  for (int i = 0; i < kPixels * 3; ++i) {
+    EXPECT_EQ(dst_pixels_c[i], dst_pixels_opt[i]);
+  }
+
+  free_aligned_buffer_page_end(src_pixels);
+  free_aligned_buffer_page_end(tmp_pixels_r);
+  free_aligned_buffer_page_end(tmp_pixels_g);
+  free_aligned_buffer_page_end(tmp_pixels_b);
+  free_aligned_buffer_page_end(dst_pixels_opt);
+  free_aligned_buffer_page_end(dst_pixels_c);
+}
+
+TEST_F(LibYUVPlanarTest, MergeARGBPlane_Opt) {
+  const int kPixels = benchmark_width_ * benchmark_height_;
+  align_buffer_page_end(src_pixels, kPixels * 4);
+  align_buffer_page_end(tmp_pixels_r, kPixels);
+  align_buffer_page_end(tmp_pixels_g, kPixels);
+  align_buffer_page_end(tmp_pixels_b, kPixels);
+  align_buffer_page_end(tmp_pixels_a, kPixels);
+  align_buffer_page_end(dst_pixels_opt, kPixels * 4);
+  align_buffer_page_end(dst_pixels_c, kPixels * 4);
+
+  MemRandomize(src_pixels, kPixels * 4);
+  MemRandomize(tmp_pixels_r, kPixels);
+  MemRandomize(tmp_pixels_g, kPixels);
+  MemRandomize(tmp_pixels_b, kPixels);
+  MemRandomize(tmp_pixels_a, kPixels);
+  MemRandomize(dst_pixels_opt, kPixels * 4);
+  MemRandomize(dst_pixels_c, kPixels * 4);
+
+  MaskCpuFlags(disable_cpu_flags_);
+  SplitARGBPlane(src_pixels, benchmark_width_ * 4, tmp_pixels_r,
+                 benchmark_width_, tmp_pixels_g, benchmark_width_, tmp_pixels_b,
+                 benchmark_width_, tmp_pixels_a, benchmark_width_,
+                 benchmark_width_, benchmark_height_);
+  MergeARGBPlane(tmp_pixels_r, benchmark_width_, tmp_pixels_g, benchmark_width_,
+                 tmp_pixels_b, benchmark_width_, tmp_pixels_a, benchmark_width_,
+                 dst_pixels_c, benchmark_width_ * 4, benchmark_width_,
+                 benchmark_height_);
+
+  MaskCpuFlags(benchmark_cpu_info_);
+  SplitARGBPlane(src_pixels, benchmark_width_ * 4, tmp_pixels_r,
+                 benchmark_width_, tmp_pixels_g, benchmark_width_, tmp_pixels_b,
+                 benchmark_width_, tmp_pixels_a, benchmark_width_,
+                 benchmark_width_, benchmark_height_);
+
+  for (int i = 0; i < benchmark_iterations_; ++i) {
+    MergeARGBPlane(tmp_pixels_r, benchmark_width_, tmp_pixels_g,
+                   benchmark_width_, tmp_pixels_b, benchmark_width_,
+                   tmp_pixels_a, benchmark_width_, dst_pixels_opt,
+                   benchmark_width_ * 4, benchmark_width_, benchmark_height_);
+  }
+
+  for (int i = 0; i < kPixels * 4; ++i) {
+    EXPECT_EQ(dst_pixels_c[i], dst_pixels_opt[i]);
+  }
+
+  free_aligned_buffer_page_end(src_pixels);
+  free_aligned_buffer_page_end(tmp_pixels_r);
+  free_aligned_buffer_page_end(tmp_pixels_g);
+  free_aligned_buffer_page_end(tmp_pixels_b);
+  free_aligned_buffer_page_end(tmp_pixels_a);
+  free_aligned_buffer_page_end(dst_pixels_opt);
+  free_aligned_buffer_page_end(dst_pixels_c);
+}
+
+TEST_F(LibYUVPlanarTest, SplitARGBPlane_Opt) {
+  const int kPixels = benchmark_width_ * benchmark_height_;
+  align_buffer_page_end(src_pixels, kPixels * 4);
+  align_buffer_page_end(tmp_pixels_r, kPixels);
+  align_buffer_page_end(tmp_pixels_g, kPixels);
+  align_buffer_page_end(tmp_pixels_b, kPixels);
+  align_buffer_page_end(tmp_pixels_a, kPixels);
+  align_buffer_page_end(dst_pixels_opt, kPixels * 4);
+  align_buffer_page_end(dst_pixels_c, kPixels * 4);
+
+  MemRandomize(src_pixels, kPixels * 4);
+  MemRandomize(tmp_pixels_r, kPixels);
+  MemRandomize(tmp_pixels_g, kPixels);
+  MemRandomize(tmp_pixels_b, kPixels);
+  MemRandomize(tmp_pixels_a, kPixels);
+  MemRandomize(dst_pixels_opt, kPixels * 4);
+  MemRandomize(dst_pixels_c, kPixels * 4);
+
+  MaskCpuFlags(disable_cpu_flags_);
+  SplitARGBPlane(src_pixels, benchmark_width_ * 4, tmp_pixels_r,
+                 benchmark_width_, tmp_pixels_g, benchmark_width_, tmp_pixels_b,
+                 benchmark_width_, tmp_pixels_a, benchmark_width_,
+                 benchmark_width_, benchmark_height_);
+  MergeARGBPlane(tmp_pixels_r, benchmark_width_, tmp_pixels_g, benchmark_width_,
+                 tmp_pixels_b, benchmark_width_, tmp_pixels_a, benchmark_width_,
+                 dst_pixels_c, benchmark_width_ * 4, benchmark_width_,
+                 benchmark_height_);
+
+  MaskCpuFlags(benchmark_cpu_info_);
+  for (int i = 0; i < benchmark_iterations_; ++i) {
+    SplitARGBPlane(src_pixels, benchmark_width_ * 4, tmp_pixels_r,
+                   benchmark_width_, tmp_pixels_g, benchmark_width_,
+                   tmp_pixels_b, benchmark_width_, tmp_pixels_a,
+                   benchmark_width_, benchmark_width_, benchmark_height_);
+  }
+
+  MergeARGBPlane(tmp_pixels_r, benchmark_width_, tmp_pixels_g, benchmark_width_,
+                 tmp_pixels_b, benchmark_width_, tmp_pixels_a, benchmark_width_,
+                 dst_pixels_opt, benchmark_width_ * 4, benchmark_width_,
+                 benchmark_height_);
+
+  for (int i = 0; i < kPixels * 4; ++i) {
+    EXPECT_EQ(dst_pixels_c[i], dst_pixels_opt[i]);
+  }
+
+  free_aligned_buffer_page_end(src_pixels);
+  free_aligned_buffer_page_end(tmp_pixels_r);
+  free_aligned_buffer_page_end(tmp_pixels_g);
+  free_aligned_buffer_page_end(tmp_pixels_b);
+  free_aligned_buffer_page_end(tmp_pixels_a);
+  free_aligned_buffer_page_end(dst_pixels_opt);
+  free_aligned_buffer_page_end(dst_pixels_c);
+}
+
+TEST_F(LibYUVPlanarTest, MergeXRGBPlane_Opt) {
+  const int kPixels = benchmark_width_ * benchmark_height_;
+  align_buffer_page_end(src_pixels, kPixels * 4);
+  align_buffer_page_end(tmp_pixels_r, kPixels);
+  align_buffer_page_end(tmp_pixels_g, kPixels);
+  align_buffer_page_end(tmp_pixels_b, kPixels);
+  align_buffer_page_end(dst_pixels_opt, kPixels * 4);
+  align_buffer_page_end(dst_pixels_c, kPixels * 4);
+
+  MemRandomize(src_pixels, kPixels * 4);
+  MemRandomize(tmp_pixels_r, kPixels);
+  MemRandomize(tmp_pixels_g, kPixels);
+  MemRandomize(tmp_pixels_b, kPixels);
+  MemRandomize(dst_pixels_opt, kPixels * 4);
+  MemRandomize(dst_pixels_c, kPixels * 4);
+
+  MaskCpuFlags(disable_cpu_flags_);
+  SplitARGBPlane(src_pixels, benchmark_width_ * 4, tmp_pixels_r,
+                 benchmark_width_, tmp_pixels_g, benchmark_width_, tmp_pixels_b,
+                 benchmark_width_, NULL, 0, benchmark_width_,
+                 benchmark_height_);
+  MergeARGBPlane(tmp_pixels_r, benchmark_width_, tmp_pixels_g, benchmark_width_,
+                 tmp_pixels_b, benchmark_width_, NULL, 0, dst_pixels_c,
+                 benchmark_width_ * 4, benchmark_width_, benchmark_height_);
+
+  MaskCpuFlags(benchmark_cpu_info_);
+  SplitARGBPlane(src_pixels, benchmark_width_ * 4, tmp_pixels_r,
+                 benchmark_width_, tmp_pixels_g, benchmark_width_, tmp_pixels_b,
+                 benchmark_width_, NULL, 0, benchmark_width_,
+                 benchmark_height_);
+
+  for (int i = 0; i < benchmark_iterations_; ++i) {
+    MergeARGBPlane(tmp_pixels_r, benchmark_width_, tmp_pixels_g,
+                   benchmark_width_, tmp_pixels_b, benchmark_width_, NULL, 0,
+                   dst_pixels_opt, benchmark_width_ * 4, benchmark_width_,
+                   benchmark_height_);
+  }
+
+  for (int i = 0; i < kPixels * 4; ++i) {
+    EXPECT_EQ(dst_pixels_c[i], dst_pixels_opt[i]);
+  }
+
+  free_aligned_buffer_page_end(src_pixels);
+  free_aligned_buffer_page_end(tmp_pixels_r);
+  free_aligned_buffer_page_end(tmp_pixels_g);
+  free_aligned_buffer_page_end(tmp_pixels_b);
+  free_aligned_buffer_page_end(dst_pixels_opt);
+  free_aligned_buffer_page_end(dst_pixels_c);
+}
+
+TEST_F(LibYUVPlanarTest, SplitXRGBPlane_Opt) {
+  const int kPixels = benchmark_width_ * benchmark_height_;
+  align_buffer_page_end(src_pixels, kPixels * 4);
+  align_buffer_page_end(tmp_pixels_r, kPixels);
+  align_buffer_page_end(tmp_pixels_g, kPixels);
+  align_buffer_page_end(tmp_pixels_b, kPixels);
+  align_buffer_page_end(dst_pixels_opt, kPixels * 4);
+  align_buffer_page_end(dst_pixels_c, kPixels * 4);
+
+  MemRandomize(src_pixels, kPixels * 4);
+  MemRandomize(tmp_pixels_r, kPixels);
+  MemRandomize(tmp_pixels_g, kPixels);
+  MemRandomize(tmp_pixels_b, kPixels);
+  MemRandomize(dst_pixels_opt, kPixels * 4);
+  MemRandomize(dst_pixels_c, kPixels * 4);
+
+  MaskCpuFlags(disable_cpu_flags_);
+  SplitARGBPlane(src_pixels, benchmark_width_ * 4, tmp_pixels_r,
+                 benchmark_width_, tmp_pixels_g, benchmark_width_, tmp_pixels_b,
+                 benchmark_width_, NULL, 0, benchmark_width_,
+                 benchmark_height_);
+  MergeARGBPlane(tmp_pixels_r, benchmark_width_, tmp_pixels_g, benchmark_width_,
+                 tmp_pixels_b, benchmark_width_, NULL, 0, dst_pixels_c,
+                 benchmark_width_ * 4, benchmark_width_, benchmark_height_);
+
+  MaskCpuFlags(benchmark_cpu_info_);
+  for (int i = 0; i < benchmark_iterations_; ++i) {
+    SplitARGBPlane(src_pixels, benchmark_width_ * 4, tmp_pixels_r,
+                   benchmark_width_, tmp_pixels_g, benchmark_width_,
+                   tmp_pixels_b, benchmark_width_, NULL, 0, benchmark_width_,
+                   benchmark_height_);
+  }
+
+  MergeARGBPlane(tmp_pixels_r, benchmark_width_, tmp_pixels_g, benchmark_width_,
+                 tmp_pixels_b, benchmark_width_, NULL, 0, dst_pixels_opt,
+                 benchmark_width_ * 4, benchmark_width_, benchmark_height_);
+
+  for (int i = 0; i < kPixels * 4; ++i) {
+    EXPECT_EQ(dst_pixels_c[i], dst_pixels_opt[i]);
+  }
+
+  free_aligned_buffer_page_end(src_pixels);
+  free_aligned_buffer_page_end(tmp_pixels_r);
+  free_aligned_buffer_page_end(tmp_pixels_g);
+  free_aligned_buffer_page_end(tmp_pixels_b);
+  free_aligned_buffer_page_end(dst_pixels_opt);
+  free_aligned_buffer_page_end(dst_pixels_c);
+}
+
+// Merge 4 channels
+#define TESTQPLANARTOPI(FUNC, STYPE, DTYPE, DEPTH, W1280, N, NEG, OFF)      \
+  TEST_F(LibYUVPlanarTest, FUNC##Plane_##DEPTH##N) {                        \
+    const int kWidth = W1280;                                               \
+    const int kPixels = kWidth * benchmark_height_;                         \
+    align_buffer_page_end(src_memory_r, kPixels * sizeof(STYPE) + OFF);     \
+    align_buffer_page_end(src_memory_g, kPixels * sizeof(STYPE) + OFF);     \
+    align_buffer_page_end(src_memory_b, kPixels * sizeof(STYPE) + OFF);     \
+    align_buffer_page_end(src_memory_a, kPixels * sizeof(STYPE) + OFF);     \
+    align_buffer_page_end(dst_memory_c, kPixels * 4 * sizeof(DTYPE));       \
+    align_buffer_page_end(dst_memory_opt, kPixels * 4 * sizeof(DTYPE));     \
+    MemRandomize(src_memory_r, kPixels * sizeof(STYPE) + OFF);              \
+    MemRandomize(src_memory_g, kPixels * sizeof(STYPE) + OFF);              \
+    MemRandomize(src_memory_b, kPixels * sizeof(STYPE) + OFF);              \
+    MemRandomize(src_memory_a, kPixels * sizeof(STYPE) + OFF);              \
+    memset(dst_memory_c, 0, kPixels * 4 * sizeof(DTYPE));                   \
+    memset(dst_memory_opt, 0, kPixels * 4 * sizeof(DTYPE));                 \
+    STYPE* src_pixels_r = reinterpret_cast<STYPE*>(src_memory_r + OFF);     \
+    STYPE* src_pixels_g = reinterpret_cast<STYPE*>(src_memory_g + OFF);     \
+    STYPE* src_pixels_b = reinterpret_cast<STYPE*>(src_memory_b + OFF);     \
+    STYPE* src_pixels_a = reinterpret_cast<STYPE*>(src_memory_a + OFF);     \
+    DTYPE* dst_pixels_c = reinterpret_cast<DTYPE*>(dst_memory_c);           \
+    DTYPE* dst_pixels_opt = reinterpret_cast<DTYPE*>(dst_memory_opt);       \
+    MaskCpuFlags(disable_cpu_flags_);                                       \
+    FUNC##Plane(src_pixels_r, kWidth, src_pixels_g, kWidth, src_pixels_b,   \
+                kWidth, src_pixels_a, kWidth, dst_pixels_c, kWidth * 4,     \
+                kWidth, NEG benchmark_height_, DEPTH);                      \
+    MaskCpuFlags(benchmark_cpu_info_);                                      \
+    for (int i = 0; i < benchmark_iterations_; ++i) {                       \
+      FUNC##Plane(src_pixels_r, kWidth, src_pixels_g, kWidth, src_pixels_b, \
+                  kWidth, src_pixels_a, kWidth, dst_pixels_opt, kWidth * 4, \
+                  kWidth, NEG benchmark_height_, DEPTH);                    \
+    }                                                                       \
+    for (int i = 0; i < kPixels * 4; ++i) {                                 \
+      EXPECT_EQ(dst_pixels_c[i], dst_pixels_opt[i]);                        \
+    }                                                                       \
+    free_aligned_buffer_page_end(src_memory_r);                             \
+    free_aligned_buffer_page_end(src_memory_g);                             \
+    free_aligned_buffer_page_end(src_memory_b);                             \
+    free_aligned_buffer_page_end(src_memory_a);                             \
+    free_aligned_buffer_page_end(dst_memory_c);                             \
+    free_aligned_buffer_page_end(dst_memory_opt);                           \
+  }
+
+// Merge 3 channel RGB into 4 channel XRGB with opaque alpha
+#define TESTQPLANAROTOPI(FUNC, STYPE, DTYPE, DEPTH, W1280, N, NEG, OFF)     \
+  TEST_F(LibYUVPlanarTest, FUNC##Plane_Opaque_##DEPTH##N) {                 \
+    const int kWidth = W1280;                                               \
+    const int kPixels = kWidth * benchmark_height_;                         \
+    align_buffer_page_end(src_memory_r, kPixels * sizeof(STYPE) + OFF);     \
+    align_buffer_page_end(src_memory_g, kPixels * sizeof(STYPE) + OFF);     \
+    align_buffer_page_end(src_memory_b, kPixels * sizeof(STYPE) + OFF);     \
+    align_buffer_page_end(dst_memory_c, kPixels * 4 * sizeof(DTYPE));       \
+    align_buffer_page_end(dst_memory_opt, kPixels * 4 * sizeof(DTYPE));     \
+    MemRandomize(src_memory_r, kPixels * sizeof(STYPE) + OFF);              \
+    MemRandomize(src_memory_g, kPixels * sizeof(STYPE) + OFF);              \
+    MemRandomize(src_memory_b, kPixels * sizeof(STYPE) + OFF);              \
+    memset(dst_memory_c, 0, kPixels * 4 * sizeof(DTYPE));                   \
+    memset(dst_memory_opt, 0, kPixels * 4 * sizeof(DTYPE));                 \
+    STYPE* src_pixels_r = reinterpret_cast<STYPE*>(src_memory_r + OFF);     \
+    STYPE* src_pixels_g = reinterpret_cast<STYPE*>(src_memory_g + OFF);     \
+    STYPE* src_pixels_b = reinterpret_cast<STYPE*>(src_memory_b + OFF);     \
+    DTYPE* dst_pixels_c = reinterpret_cast<DTYPE*>(dst_memory_c);           \
+    DTYPE* dst_pixels_opt = reinterpret_cast<DTYPE*>(dst_memory_opt);       \
+    MaskCpuFlags(disable_cpu_flags_);                                       \
+    FUNC##Plane(src_pixels_r, kWidth, src_pixels_g, kWidth, src_pixels_b,   \
+                kWidth, NULL, 0, dst_pixels_c, kWidth * 4, kWidth,          \
+                NEG benchmark_height_, DEPTH);                              \
+    MaskCpuFlags(benchmark_cpu_info_);                                      \
+    for (int i = 0; i < benchmark_iterations_; ++i) {                       \
+      FUNC##Plane(src_pixels_r, kWidth, src_pixels_g, kWidth, src_pixels_b, \
+                  kWidth, NULL, 0, dst_pixels_opt, kWidth * 4, kWidth,      \
+                  NEG benchmark_height_, DEPTH);                            \
+    }                                                                       \
+    for (int i = 0; i < kPixels * 4; ++i) {                                 \
+      EXPECT_EQ(dst_pixels_c[i], dst_pixels_opt[i]);                        \
+    }                                                                       \
+    free_aligned_buffer_page_end(src_memory_r);                             \
+    free_aligned_buffer_page_end(src_memory_g);                             \
+    free_aligned_buffer_page_end(src_memory_b);                             \
+    free_aligned_buffer_page_end(dst_memory_c);                             \
+    free_aligned_buffer_page_end(dst_memory_opt);                           \
+  }
+
+#define TESTQPLANARTOP(FUNC, STYPE, DTYPE, DEPTH)                              \
+  TESTQPLANARTOPI(FUNC, STYPE, DTYPE, DEPTH, benchmark_width_ + 1, _Any, +, 0) \
+  TESTQPLANARTOPI(FUNC, STYPE, DTYPE, DEPTH, benchmark_width_, _Unaligned, +,  \
+                  2)                                                           \
+  TESTQPLANARTOPI(FUNC, STYPE, DTYPE, DEPTH, benchmark_width_, _Invert, -, 0)  \
+  TESTQPLANARTOPI(FUNC, STYPE, DTYPE, DEPTH, benchmark_width_, _Opt, +, 0)     \
+  TESTQPLANAROTOPI(FUNC, STYPE, DTYPE, DEPTH, benchmark_width_ + 1, _Any, +,   \
+                   0)                                                          \
+  TESTQPLANAROTOPI(FUNC, STYPE, DTYPE, DEPTH, benchmark_width_, _Unaligned, +, \
+                   2)                                                          \
+  TESTQPLANAROTOPI(FUNC, STYPE, DTYPE, DEPTH, benchmark_width_, _Invert, -, 0) \
+  TESTQPLANAROTOPI(FUNC, STYPE, DTYPE, DEPTH, benchmark_width_, _Opt, +, 0)
+
+TESTQPLANARTOP(MergeAR64, uint16_t, uint16_t, 10)
+TESTQPLANARTOP(MergeAR64, uint16_t, uint16_t, 12)
+TESTQPLANARTOP(MergeAR64, uint16_t, uint16_t, 16)
+TESTQPLANARTOP(MergeARGB16To8, uint16_t, uint8_t, 10)
+TESTQPLANARTOP(MergeARGB16To8, uint16_t, uint8_t, 12)
+TESTQPLANARTOP(MergeARGB16To8, uint16_t, uint8_t, 16)
+
+#define TESTTPLANARTOPI(FUNC, STYPE, DTYPE, DEPTH, W1280, N, NEG, OFF)      \
+  TEST_F(LibYUVPlanarTest, FUNC##Plane_##DEPTH##N) {                        \
+    const int kWidth = W1280;                                               \
+    const int kPixels = kWidth * benchmark_height_;                         \
+    align_buffer_page_end(src_memory_r, kPixels * sizeof(STYPE) + OFF);     \
+    align_buffer_page_end(src_memory_g, kPixels * sizeof(STYPE) + OFF);     \
+    align_buffer_page_end(src_memory_b, kPixels * sizeof(STYPE) + OFF);     \
+    align_buffer_page_end(dst_memory_c, kPixels * 4 * sizeof(DTYPE));       \
+    align_buffer_page_end(dst_memory_opt, kPixels * 4 * sizeof(DTYPE));     \
+    MemRandomize(src_memory_r, kPixels * sizeof(STYPE) + OFF);              \
+    MemRandomize(src_memory_g, kPixels * sizeof(STYPE) + OFF);              \
+    MemRandomize(src_memory_b, kPixels * sizeof(STYPE) + OFF);              \
+    STYPE* src_pixels_r = reinterpret_cast<STYPE*>(src_memory_r + OFF);     \
+    STYPE* src_pixels_g = reinterpret_cast<STYPE*>(src_memory_g + OFF);     \
+    STYPE* src_pixels_b = reinterpret_cast<STYPE*>(src_memory_b + OFF);     \
+    DTYPE* dst_pixels_c = reinterpret_cast<DTYPE*>(dst_memory_c);           \
+    DTYPE* dst_pixels_opt = reinterpret_cast<DTYPE*>(dst_memory_opt);       \
+    memset(dst_pixels_c, 1, kPixels * 4 * sizeof(DTYPE));                   \
+    memset(dst_pixels_opt, 2, kPixels * 4 * sizeof(DTYPE));                 \
+    MaskCpuFlags(disable_cpu_flags_);                                       \
+    FUNC##Plane(src_pixels_r, kWidth, src_pixels_g, kWidth, src_pixels_b,   \
+                kWidth, dst_pixels_c, kWidth * 4, kWidth,                   \
+                NEG benchmark_height_, DEPTH);                              \
+    MaskCpuFlags(benchmark_cpu_info_);                                      \
+    for (int i = 0; i < benchmark_iterations_; ++i) {                       \
+      FUNC##Plane(src_pixels_r, kWidth, src_pixels_g, kWidth, src_pixels_b, \
+                  kWidth, dst_pixels_opt, kWidth * 4, kWidth,               \
+                  NEG benchmark_height_, DEPTH);                            \
+    }                                                                       \
+    for (int i = 0; i < kPixels * 4; ++i) {                                 \
+      EXPECT_EQ(dst_pixels_c[i], dst_pixels_opt[i]);                        \
+    }                                                                       \
+    free_aligned_buffer_page_end(src_memory_r);                             \
+    free_aligned_buffer_page_end(src_memory_g);                             \
+    free_aligned_buffer_page_end(src_memory_b);                             \
+    free_aligned_buffer_page_end(dst_memory_c);                             \
+    free_aligned_buffer_page_end(dst_memory_opt);                           \
+  }
+
+#define TESTTPLANARTOP(FUNC, STYPE, DTYPE, DEPTH)                              \
+  TESTTPLANARTOPI(FUNC, STYPE, DTYPE, DEPTH, benchmark_width_ + 1, _Any, +, 0) \
+  TESTTPLANARTOPI(FUNC, STYPE, DTYPE, DEPTH, benchmark_width_, _Unaligned, +,  \
+                  2)                                                           \
+  TESTTPLANARTOPI(FUNC, STYPE, DTYPE, DEPTH, benchmark_width_, _Invert, -, 0)  \
+  TESTTPLANARTOPI(FUNC, STYPE, DTYPE, DEPTH, benchmark_width_, _Opt, +, 0)
+
+TESTTPLANARTOP(MergeXR30, uint16_t, uint8_t, 10)
+TESTTPLANARTOP(MergeXR30, uint16_t, uint8_t, 12)
+TESTTPLANARTOP(MergeXR30, uint16_t, uint8_t, 16)
+
+// TODO(fbarchard): improve test for platforms and cpu detect
+#ifdef HAS_MERGEUVROW_16_AVX2
+TEST_F(LibYUVPlanarTest, MergeUVRow_16_Opt) {
+  // Round count up to multiple of 16
+  const int kPixels = (benchmark_width_ * benchmark_height_ + 15) & ~15;
+
+  align_buffer_page_end(src_pixels_u, kPixels * 2);
+  align_buffer_page_end(src_pixels_v, kPixels * 2);
+  align_buffer_page_end(dst_pixels_uv_opt, kPixels * 2 * 2);
+  align_buffer_page_end(dst_pixels_uv_c, kPixels * 2 * 2);
+
+  MemRandomize(src_pixels_u, kPixels * 2);
+  MemRandomize(src_pixels_v, kPixels * 2);
+  memset(dst_pixels_uv_opt, 0, kPixels * 2 * 2);
+  memset(dst_pixels_uv_c, 1, kPixels * 2 * 2);
+
+  MergeUVRow_16_C(reinterpret_cast<const uint16_t*>(src_pixels_u),
+                  reinterpret_cast<const uint16_t*>(src_pixels_v),
+                  reinterpret_cast<uint16_t*>(dst_pixels_uv_c), 16, kPixels);
+
+  int has_avx2 = TestCpuFlag(kCpuHasAVX2);
+  for (int i = 0; i < benchmark_iterations_; ++i) {
+    if (has_avx2) {
+      MergeUVRow_16_AVX2(reinterpret_cast<const uint16_t*>(src_pixels_u),
+                         reinterpret_cast<const uint16_t*>(src_pixels_v),
+                         reinterpret_cast<uint16_t*>(dst_pixels_uv_opt), 16,
+                         kPixels);
+    } else {
+      MergeUVRow_16_C(reinterpret_cast<const uint16_t*>(src_pixels_u),
+                      reinterpret_cast<const uint16_t*>(src_pixels_v),
+                      reinterpret_cast<uint16_t*>(dst_pixels_uv_opt), 16,
+                      kPixels);
+    }
+  }
+
+  for (int i = 0; i < kPixels * 2 * 2; ++i) {
+    EXPECT_EQ(dst_pixels_uv_opt[i], dst_pixels_uv_c[i]);
+  }
+
+  free_aligned_buffer_page_end(src_pixels_u);
+  free_aligned_buffer_page_end(src_pixels_v);
+  free_aligned_buffer_page_end(dst_pixels_uv_opt);
+  free_aligned_buffer_page_end(dst_pixels_uv_c);
+}
+#endif
+
+// TODO(fbarchard): Improve test for more platforms.
+#ifdef HAS_MULTIPLYROW_16_AVX2
+TEST_F(LibYUVPlanarTest, MultiplyRow_16_Opt) {
+  // Round count up to multiple of 32
+  const int kPixels = (benchmark_width_ * benchmark_height_ + 31) & ~31;
+
+  align_buffer_page_end(src_pixels_y, kPixels * 2);
+  align_buffer_page_end(dst_pixels_y_opt, kPixels * 2);
+  align_buffer_page_end(dst_pixels_y_c, kPixels * 2);
+
+  MemRandomize(src_pixels_y, kPixels * 2);
+  memset(dst_pixels_y_opt, 0, kPixels * 2);
+  memset(dst_pixels_y_c, 1, kPixels * 2);
+
+  MultiplyRow_16_C(reinterpret_cast<const uint16_t*>(src_pixels_y),
+                   reinterpret_cast<uint16_t*>(dst_pixels_y_c), 64, kPixels);
+
+  int has_avx2 = TestCpuFlag(kCpuHasAVX2);
+  for (int i = 0; i < benchmark_iterations_; ++i) {
+    if (has_avx2) {
+      MultiplyRow_16_AVX2(reinterpret_cast<const uint16_t*>(src_pixels_y),
+                          reinterpret_cast<uint16_t*>(dst_pixels_y_opt), 64,
+                          kPixels);
+    } else {
+      MultiplyRow_16_C(reinterpret_cast<const uint16_t*>(src_pixels_y),
+                       reinterpret_cast<uint16_t*>(dst_pixels_y_opt), 64,
+                       kPixels);
+    }
+  }
+
+  for (int i = 0; i < kPixels * 2; ++i) {
+    EXPECT_EQ(dst_pixels_y_opt[i], dst_pixels_y_c[i]);
+  }
+
+  free_aligned_buffer_page_end(src_pixels_y);
+  free_aligned_buffer_page_end(dst_pixels_y_opt);
+  free_aligned_buffer_page_end(dst_pixels_y_c);
+}
+#endif  // HAS_MULTIPLYROW_16_AVX2
+
+TEST_F(LibYUVPlanarTest, Convert16To8Plane) {
+  const int kPixels = benchmark_width_ * benchmark_height_;
+  align_buffer_page_end(src_pixels_y, kPixels * 2);
+  align_buffer_page_end(dst_pixels_y_opt, kPixels);
+  align_buffer_page_end(dst_pixels_y_c, kPixels);
+
+  MemRandomize(src_pixels_y, kPixels * 2);
+  memset(dst_pixels_y_opt, 0, kPixels);
+  memset(dst_pixels_y_c, 1, kPixels);
+
+  MaskCpuFlags(disable_cpu_flags_);
+  Convert16To8Plane(reinterpret_cast<const uint16_t*>(src_pixels_y),
+                    benchmark_width_, dst_pixels_y_c, benchmark_width_, 16384,
+                    benchmark_width_, benchmark_height_);
+  MaskCpuFlags(benchmark_cpu_info_);
+
+  for (int i = 0; i < benchmark_iterations_; ++i) {
+    Convert16To8Plane(reinterpret_cast<const uint16_t*>(src_pixels_y),
+                      benchmark_width_, dst_pixels_y_opt, benchmark_width_,
+                      16384, benchmark_width_, benchmark_height_);
+  }
+
+  for (int i = 0; i < kPixels; ++i) {
+    EXPECT_EQ(dst_pixels_y_opt[i], dst_pixels_y_c[i]);
+  }
+
+  free_aligned_buffer_page_end(src_pixels_y);
+  free_aligned_buffer_page_end(dst_pixels_y_opt);
+  free_aligned_buffer_page_end(dst_pixels_y_c);
+}
+
+TEST_F(LibYUVPlanarTest, YUY2ToY) {
+  const int kPixels = benchmark_width_ * benchmark_height_;
+  align_buffer_page_end(src_pixels_y, kPixels * 2);
+  align_buffer_page_end(dst_pixels_y_opt, kPixels);
+  align_buffer_page_end(dst_pixels_y_c, kPixels);
+
+  MemRandomize(src_pixels_y, kPixels * 2);
+  memset(dst_pixels_y_opt, 0, kPixels);
+  memset(dst_pixels_y_c, 1, kPixels);
+
+  MaskCpuFlags(disable_cpu_flags_);
+  YUY2ToY(src_pixels_y, benchmark_width_ * 2, dst_pixels_y_c, benchmark_width_,
+          benchmark_width_, benchmark_height_);
+  MaskCpuFlags(benchmark_cpu_info_);
+
+  for (int i = 0; i < benchmark_iterations_; ++i) {
+    YUY2ToY(src_pixels_y, benchmark_width_ * 2, dst_pixels_y_opt,
+            benchmark_width_, benchmark_width_, benchmark_height_);
+  }
+
+  for (int i = 0; i < kPixels; ++i) {
+    EXPECT_EQ(dst_pixels_y_opt[i], dst_pixels_y_c[i]);
+  }
+
+  free_aligned_buffer_page_end(src_pixels_y);
+  free_aligned_buffer_page_end(dst_pixels_y_opt);
+  free_aligned_buffer_page_end(dst_pixels_y_c);
+}
+
+TEST_F(LibYUVPlanarTest, UYVYToY) {
+  const int kPixels = benchmark_width_ * benchmark_height_;
+  align_buffer_page_end(src_pixels_y, kPixels * 2);
+  align_buffer_page_end(dst_pixels_y_opt, kPixels);
+  align_buffer_page_end(dst_pixels_y_c, kPixels);
+
+  MemRandomize(src_pixels_y, kPixels * 2);
+  memset(dst_pixels_y_opt, 0, kPixels);
+  memset(dst_pixels_y_c, 1, kPixels);
+
+  MaskCpuFlags(disable_cpu_flags_);
+  UYVYToY(src_pixels_y, benchmark_width_ * 2, dst_pixels_y_c, benchmark_width_,
+          benchmark_width_, benchmark_height_);
+  MaskCpuFlags(benchmark_cpu_info_);
+
+  for (int i = 0; i < benchmark_iterations_; ++i) {
+    UYVYToY(src_pixels_y, benchmark_width_ * 2, dst_pixels_y_opt,
+            benchmark_width_, benchmark_width_, benchmark_height_);
+  }
+
+  for (int i = 0; i < kPixels; ++i) {
+    EXPECT_EQ(dst_pixels_y_opt[i], dst_pixels_y_c[i]);
+  }
+
+  free_aligned_buffer_page_end(src_pixels_y);
+  free_aligned_buffer_page_end(dst_pixels_y_opt);
+  free_aligned_buffer_page_end(dst_pixels_y_c);
+}
+
+#ifdef ENABLE_ROW_TESTS
+// TODO(fbarchard): Improve test for more platforms.
+#ifdef HAS_CONVERT16TO8ROW_AVX2
+TEST_F(LibYUVPlanarTest, Convert16To8Row_Opt) {
+  // AVX2 does multiple of 32, so round count up
+  const int kPixels = (benchmark_width_ * benchmark_height_ + 31) & ~31;
+  align_buffer_page_end(src_pixels_y, kPixels * 2);
+  align_buffer_page_end(dst_pixels_y_opt, kPixels);
+  align_buffer_page_end(dst_pixels_y_c, kPixels);
+
+  MemRandomize(src_pixels_y, kPixels * 2);
+  // clamp source range to 10 bits.
+  for (int i = 0; i < kPixels; ++i) {
+    reinterpret_cast<uint16_t*>(src_pixels_y)[i] &= 1023;
+  }
+
+  memset(dst_pixels_y_opt, 0, kPixels);
+  memset(dst_pixels_y_c, 1, kPixels);
+
+  Convert16To8Row_C(reinterpret_cast<const uint16_t*>(src_pixels_y),
+                    dst_pixels_y_c, 16384, kPixels);
+
+  int has_avx2 = TestCpuFlag(kCpuHasAVX2);
+  int has_ssse3 = TestCpuFlag(kCpuHasSSSE3);
+  for (int i = 0; i < benchmark_iterations_; ++i) {
+    if (has_avx2) {
+      Convert16To8Row_AVX2(reinterpret_cast<const uint16_t*>(src_pixels_y),
+                           dst_pixels_y_opt, 16384, kPixels);
+    } else if (has_ssse3) {
+      Convert16To8Row_SSSE3(reinterpret_cast<const uint16_t*>(src_pixels_y),
+                            dst_pixels_y_opt, 16384, kPixels);
+    } else {
+      Convert16To8Row_C(reinterpret_cast<const uint16_t*>(src_pixels_y),
+                        dst_pixels_y_opt, 16384, kPixels);
+    }
+  }
+
+  for (int i = 0; i < kPixels; ++i) {
+    EXPECT_EQ(dst_pixels_y_opt[i], dst_pixels_y_c[i]);
+  }
+
+  free_aligned_buffer_page_end(src_pixels_y);
+  free_aligned_buffer_page_end(dst_pixels_y_opt);
+  free_aligned_buffer_page_end(dst_pixels_y_c);
+}
+#endif  // HAS_CONVERT16TO8ROW_AVX2
+
+#ifdef HAS_UYVYTOYROW_NEON
+TEST_F(LibYUVPlanarTest, UYVYToYRow_Opt) {
+  // NEON does multiple of 16, so round count up
+  const int kPixels = (benchmark_width_ * benchmark_height_ + 15) & ~15;
+  align_buffer_page_end(src_pixels_y, kPixels * 2);
+  align_buffer_page_end(dst_pixels_y_opt, kPixels);
+  align_buffer_page_end(dst_pixels_y_c, kPixels);
+
+  MemRandomize(src_pixels_y, kPixels * 2);
+  memset(dst_pixels_y_opt, 0, kPixels);
+  memset(dst_pixels_y_c, 1, kPixels);
+
+  UYVYToYRow_C(src_pixels_y, dst_pixels_y_c, kPixels);
+
+  for (int i = 0; i < benchmark_iterations_; ++i) {
+    UYVYToYRow_NEON(src_pixels_y, dst_pixels_y_opt, kPixels);
+  }
+
+  for (int i = 0; i < kPixels; ++i) {
+    EXPECT_EQ(dst_pixels_y_opt[i], dst_pixels_y_c[i]);
+  }
+
+  free_aligned_buffer_page_end(src_pixels_y);
+  free_aligned_buffer_page_end(dst_pixels_y_opt);
+  free_aligned_buffer_page_end(dst_pixels_y_c);
+}
+#endif  // HAS_UYVYTOYROW_NEON
+
+#endif  // ENABLE_ROW_TESTS
+
+TEST_F(LibYUVPlanarTest, Convert8To16Plane) {
+  const int kPixels = benchmark_width_ * benchmark_height_;
+  align_buffer_page_end(src_pixels_y, kPixels);
+  align_buffer_page_end(dst_pixels_y_opt, kPixels * 2);
+  align_buffer_page_end(dst_pixels_y_c, kPixels * 2);
+
+  MemRandomize(src_pixels_y, kPixels);
+  memset(dst_pixels_y_opt, 0, kPixels * 2);
+  memset(dst_pixels_y_c, 1, kPixels * 2);
+
+  MaskCpuFlags(disable_cpu_flags_);
+  Convert8To16Plane(src_pixels_y, benchmark_width_,
+                    reinterpret_cast<uint16_t*>(dst_pixels_y_c),
+                    benchmark_width_, 1024, benchmark_width_,
+                    benchmark_height_);
+  MaskCpuFlags(benchmark_cpu_info_);
+
+  for (int i = 0; i < benchmark_iterations_; ++i) {
+    Convert8To16Plane(src_pixels_y, benchmark_width_,
+                      reinterpret_cast<uint16_t*>(dst_pixels_y_opt),
+                      benchmark_width_, 1024, benchmark_width_,
+                      benchmark_height_);
+  }
+
+  for (int i = 0; i < kPixels * 2; ++i) {
+    EXPECT_EQ(dst_pixels_y_opt[i], dst_pixels_y_c[i]);
+  }
+
+  free_aligned_buffer_page_end(src_pixels_y);
+  free_aligned_buffer_page_end(dst_pixels_y_opt);
+  free_aligned_buffer_page_end(dst_pixels_y_c);
+}
+
+#ifdef ENABLE_ROW_TESTS
+// TODO(fbarchard): Improve test for more platforms.
+#ifdef HAS_CONVERT8TO16ROW_AVX2
+TEST_F(LibYUVPlanarTest, Convert8To16Row_Opt) {
+  const int kPixels = (benchmark_width_ * benchmark_height_ + 31) & ~31;
+  align_buffer_page_end(src_pixels_y, kPixels);
+  align_buffer_page_end(dst_pixels_y_opt, kPixels * 2);
+  align_buffer_page_end(dst_pixels_y_c, kPixels * 2);
+
+  MemRandomize(src_pixels_y, kPixels);
+  memset(dst_pixels_y_opt, 0, kPixels * 2);
+  memset(dst_pixels_y_c, 1, kPixels * 2);
+
+  Convert8To16Row_C(src_pixels_y, reinterpret_cast<uint16_t*>(dst_pixels_y_c),
+                    1024, kPixels);
+
+  int has_avx2 = TestCpuFlag(kCpuHasAVX2);
+  int has_sse2 = TestCpuFlag(kCpuHasSSE2);
+  for (int i = 0; i < benchmark_iterations_; ++i) {
+    if (has_avx2) {
+      Convert8To16Row_AVX2(src_pixels_y,
+                           reinterpret_cast<uint16_t*>(dst_pixels_y_opt), 1024,
+                           kPixels);
+    } else if (has_sse2) {
+      Convert8To16Row_SSE2(src_pixels_y,
+                           reinterpret_cast<uint16_t*>(dst_pixels_y_opt), 1024,
+                           kPixels);
+    } else {
+      Convert8To16Row_C(src_pixels_y,
+                        reinterpret_cast<uint16_t*>(dst_pixels_y_opt), 1024,
+                        kPixels);
+    }
+  }
+
+  for (int i = 0; i < kPixels * 2; ++i) {
+    EXPECT_EQ(dst_pixels_y_opt[i], dst_pixels_y_c[i]);
+  }
+
+  free_aligned_buffer_page_end(src_pixels_y);
+  free_aligned_buffer_page_end(dst_pixels_y_opt);
+  free_aligned_buffer_page_end(dst_pixels_y_c);
+}
+#endif  // HAS_CONVERT8TO16ROW_AVX2
+
+float TestScaleMaxSamples(int benchmark_width,
+                          int benchmark_height,
+                          int benchmark_iterations,
+                          float scale,
+                          bool opt) {
+  int i, j;
+  float max_c, max_opt = 0.f;
+  // NEON does multiple of 8, so round count up
+  const int kPixels = (benchmark_width * benchmark_height + 7) & ~7;
+  align_buffer_page_end(orig_y, kPixels * 4 * 3 + 48);
+  uint8_t* dst_c = orig_y + kPixels * 4 + 16;
+  uint8_t* dst_opt = orig_y + kPixels * 4 * 2 + 32;
+
+  // Randomize works but may contain some denormals affecting performance.
+  // MemRandomize(orig_y, kPixels * 4);
+  // large values are problematic.  audio is really -1 to 1.
+  for (i = 0; i < kPixels; ++i) {
+    (reinterpret_cast<float*>(orig_y))[i] = sinf(static_cast<float>(i) * 0.1f);
+  }
+  memset(dst_c, 0, kPixels * 4);
+  memset(dst_opt, 1, kPixels * 4);
+
+  max_c = ScaleMaxSamples_C(reinterpret_cast<float*>(orig_y),
+                            reinterpret_cast<float*>(dst_c), scale, kPixels);
+
+  for (j = 0; j < benchmark_iterations; j++) {
+    if (opt) {
+#ifdef HAS_SCALESUMSAMPLES_NEON
+      max_opt = ScaleMaxSamples_NEON(reinterpret_cast<float*>(orig_y),
+                                     reinterpret_cast<float*>(dst_opt), scale,
+                                     kPixels);
+#else
+      max_opt =
+          ScaleMaxSamples_C(reinterpret_cast<float*>(orig_y),
+                            reinterpret_cast<float*>(dst_opt), scale, kPixels);
+#endif
+    } else {
+      max_opt =
+          ScaleMaxSamples_C(reinterpret_cast<float*>(orig_y),
+                            reinterpret_cast<float*>(dst_opt), scale, kPixels);
+    }
+  }
+
+  float max_diff = FAbs(max_opt - max_c);
+  for (i = 0; i < kPixels; ++i) {
+    float abs_diff = FAbs((reinterpret_cast<float*>(dst_c)[i]) -
+                          (reinterpret_cast<float*>(dst_opt)[i]));
+    if (abs_diff > max_diff) {
+      max_diff = abs_diff;
+    }
+  }
+
+  free_aligned_buffer_page_end(orig_y);
+  return max_diff;
+}
+
+TEST_F(LibYUVPlanarTest, TestScaleMaxSamples_C) {
+  float diff = TestScaleMaxSamples(benchmark_width_, benchmark_height_,
+                                   benchmark_iterations_, 1.2f, false);
+  EXPECT_EQ(0, diff);
+}
+
+TEST_F(LibYUVPlanarTest, TestScaleMaxSamples_Opt) {
+  float diff = TestScaleMaxSamples(benchmark_width_, benchmark_height_,
+                                   benchmark_iterations_, 1.2f, true);
+  EXPECT_EQ(0, diff);
+}
+
+float TestScaleSumSamples(int benchmark_width,
+                          int benchmark_height,
+                          int benchmark_iterations,
+                          float scale,
+                          bool opt) {
+  int i, j;
+  float sum_c, sum_opt = 0.f;
+  // NEON does multiple of 8, so round count up
+  const int kPixels = (benchmark_width * benchmark_height + 7) & ~7;
+  align_buffer_page_end(orig_y, kPixels * 4 * 3);
+  uint8_t* dst_c = orig_y + kPixels * 4;
+  uint8_t* dst_opt = orig_y + kPixels * 4 * 2;
+
+  // Randomize works but may contain some denormals affecting performance.
+  // MemRandomize(orig_y, kPixels * 4);
+  // large values are problematic.  audio is really -1 to 1.
+  for (i = 0; i < kPixels; ++i) {
+    (reinterpret_cast<float*>(orig_y))[i] = sinf(static_cast<float>(i) * 0.1f);
+  }
+  memset(dst_c, 0, kPixels * 4);
+  memset(dst_opt, 1, kPixels * 4);
+
+  sum_c = ScaleSumSamples_C(reinterpret_cast<float*>(orig_y),
+                            reinterpret_cast<float*>(dst_c), scale, kPixels);
+
+  for (j = 0; j < benchmark_iterations; j++) {
+    if (opt) {
+#ifdef HAS_SCALESUMSAMPLES_NEON
+      sum_opt = ScaleSumSamples_NEON(reinterpret_cast<float*>(orig_y),
+                                     reinterpret_cast<float*>(dst_opt), scale,
+                                     kPixels);
+#else
+      sum_opt =
+          ScaleSumSamples_C(reinterpret_cast<float*>(orig_y),
+                            reinterpret_cast<float*>(dst_opt), scale, kPixels);
+#endif
+    } else {
+      sum_opt =
+          ScaleSumSamples_C(reinterpret_cast<float*>(orig_y),
+                            reinterpret_cast<float*>(dst_opt), scale, kPixels);
+    }
+  }
+
+  float mse_opt = sum_opt / kPixels * 4;
+  float mse_c = sum_c / kPixels * 4;
+  float mse_error = FAbs(mse_opt - mse_c) / mse_c;
+
+  // If the sum of a float is more than 4 million, small adds are round down on
+  // float and produce different results with vectorized sum vs scalar sum.
+  // Ignore the difference if the sum is large.
+  float max_diff = 0.f;
+  if (mse_error > 0.0001 && sum_c < 4000000) {  // allow .01% difference of mse
+    max_diff = mse_error;
+  }
+
+  for (i = 0; i < kPixels; ++i) {
+    float abs_diff = FAbs((reinterpret_cast<float*>(dst_c)[i]) -
+                          (reinterpret_cast<float*>(dst_opt)[i]));
+    if (abs_diff > max_diff) {
+      max_diff = abs_diff;
+    }
+  }
+
+  free_aligned_buffer_page_end(orig_y);
+  return max_diff;
+}
+
+TEST_F(LibYUVPlanarTest, TestScaleSumSamples_C) {
+  float diff = TestScaleSumSamples(benchmark_width_, benchmark_height_,
+                                   benchmark_iterations_, 1.2f, false);
+  EXPECT_EQ(0, diff);
+}
+
+TEST_F(LibYUVPlanarTest, TestScaleSumSamples_Opt) {
+  float diff = TestScaleSumSamples(benchmark_width_, benchmark_height_,
+                                   benchmark_iterations_, 1.2f, true);
+  EXPECT_EQ(0, diff);
+}
+
+float TestScaleSamples(int benchmark_width,
+                       int benchmark_height,
+                       int benchmark_iterations,
+                       float scale,
+                       bool opt) {
+  int i, j;
+  // NEON does multiple of 8, so round count up
+  const int kPixels = (benchmark_width * benchmark_height + 7) & ~7;
+  align_buffer_page_end(orig_y, kPixels * 4 * 3);
+  uint8_t* dst_c = orig_y + kPixels * 4;
+  uint8_t* dst_opt = orig_y + kPixels * 4 * 2;
+
+  // Randomize works but may contain some denormals affecting performance.
+  // MemRandomize(orig_y, kPixels * 4);
+  // large values are problematic.  audio is really -1 to 1.
+  for (i = 0; i < kPixels; ++i) {
+    (reinterpret_cast<float*>(orig_y))[i] = sinf(static_cast<float>(i) * 0.1f);
+  }
+  memset(dst_c, 0, kPixels * 4);
+  memset(dst_opt, 1, kPixels * 4);
+
+  ScaleSamples_C(reinterpret_cast<float*>(orig_y),
+                 reinterpret_cast<float*>(dst_c), scale, kPixels);
+
+  for (j = 0; j < benchmark_iterations; j++) {
+    if (opt) {
+#ifdef HAS_SCALESUMSAMPLES_NEON
+      ScaleSamples_NEON(reinterpret_cast<float*>(orig_y),
+                        reinterpret_cast<float*>(dst_opt), scale, kPixels);
+#else
+      ScaleSamples_C(reinterpret_cast<float*>(orig_y),
+                     reinterpret_cast<float*>(dst_opt), scale, kPixels);
+#endif
+    } else {
+      ScaleSamples_C(reinterpret_cast<float*>(orig_y),
+                     reinterpret_cast<float*>(dst_opt), scale, kPixels);
+    }
+  }
+
+  float max_diff = 0.f;
+  for (i = 0; i < kPixels; ++i) {
+    float abs_diff = FAbs((reinterpret_cast<float*>(dst_c)[i]) -
+                          (reinterpret_cast<float*>(dst_opt)[i]));
+    if (abs_diff > max_diff) {
+      max_diff = abs_diff;
+    }
+  }
+
+  free_aligned_buffer_page_end(orig_y);
+  return max_diff;
+}
+
+TEST_F(LibYUVPlanarTest, TestScaleSamples_C) {
+  float diff = TestScaleSamples(benchmark_width_, benchmark_height_,
+                                benchmark_iterations_, 1.2f, false);
+  EXPECT_EQ(0, diff);
+}
+
+TEST_F(LibYUVPlanarTest, TestScaleSamples_Opt) {
+  float diff = TestScaleSamples(benchmark_width_, benchmark_height_,
+                                benchmark_iterations_, 1.2f, true);
+  EXPECT_EQ(0, diff);
+}
+
+float TestCopySamples(int benchmark_width,
+                      int benchmark_height,
+                      int benchmark_iterations,
+                      bool opt) {
+  int i, j;
+  // NEON does multiple of 16 floats, so round count up
+  const int kPixels = (benchmark_width * benchmark_height + 15) & ~15;
+  align_buffer_page_end(orig_y, kPixels * 4 * 3);
+  uint8_t* dst_c = orig_y + kPixels * 4;
+  uint8_t* dst_opt = orig_y + kPixels * 4 * 2;
+
+  // Randomize works but may contain some denormals affecting performance.
+  // MemRandomize(orig_y, kPixels * 4);
+  // large values are problematic.  audio is really -1 to 1.
+  for (i = 0; i < kPixels; ++i) {
+    (reinterpret_cast<float*>(orig_y))[i] = sinf(static_cast<float>(i) * 0.1f);
+  }
+  memset(dst_c, 0, kPixels * 4);
+  memset(dst_opt, 1, kPixels * 4);
+
+  memcpy(reinterpret_cast<void*>(dst_c), reinterpret_cast<void*>(orig_y),
+         kPixels * 4);
+
+  for (j = 0; j < benchmark_iterations; j++) {
+    if (opt) {
+#ifdef HAS_COPYROW_NEON
+      CopyRow_NEON(orig_y, dst_opt, kPixels * 4);
+#else
+      CopyRow_C(orig_y, dst_opt, kPixels * 4);
+#endif
+    } else {
+      CopyRow_C(orig_y, dst_opt, kPixels * 4);
+    }
+  }
+
+  float max_diff = 0.f;
+  for (i = 0; i < kPixels; ++i) {
+    float abs_diff = FAbs((reinterpret_cast<float*>(dst_c)[i]) -
+                          (reinterpret_cast<float*>(dst_opt)[i]));
+    if (abs_diff > max_diff) {
+      max_diff = abs_diff;
+    }
+  }
+
+  free_aligned_buffer_page_end(orig_y);
+  return max_diff;
+}
+
+TEST_F(LibYUVPlanarTest, TestCopySamples_C) {
+  float diff = TestCopySamples(benchmark_width_, benchmark_height_,
+                               benchmark_iterations_, false);
+  EXPECT_EQ(0, diff);
+}
+
+TEST_F(LibYUVPlanarTest, TestCopySamples_Opt) {
+  float diff = TestCopySamples(benchmark_width_, benchmark_height_,
+                               benchmark_iterations_, true);
+  EXPECT_EQ(0, diff);
+}
+
+extern "C" void GaussRow_NEON(const uint32_t* src, uint16_t* dst, int width);
+extern "C" void GaussRow_C(const uint32_t* src, uint16_t* dst, int width);
+
+TEST_F(LibYUVPlanarTest, TestGaussRow_Opt) {
+  SIMD_ALIGNED(uint32_t orig_pixels[1280 + 8]);
+  SIMD_ALIGNED(uint16_t dst_pixels_c[1280]);
+  SIMD_ALIGNED(uint16_t dst_pixels_opt[1280]);
+
+  memset(orig_pixels, 0, sizeof(orig_pixels));
+  memset(dst_pixels_c, 1, sizeof(dst_pixels_c));
+  memset(dst_pixels_opt, 2, sizeof(dst_pixels_opt));
+
+  for (int i = 0; i < 1280 + 8; ++i) {
+    orig_pixels[i] = i * 256;
+  }
+  GaussRow_C(&orig_pixels[0], &dst_pixels_c[0], 1280);
+  for (int i = 0; i < benchmark_pixels_div1280_; ++i) {
+#if !defined(LIBYUV_DISABLE_NEON) && \
+    (defined(__aarch64__) || defined(__ARM_NEON__) || defined(LIBYUV_NEON))
+    int has_neon = TestCpuFlag(kCpuHasNEON);
+    if (has_neon) {
+      GaussRow_NEON(&orig_pixels[0], &dst_pixels_opt[0], 1280);
+    } else {
+      GaussRow_C(&orig_pixels[0], &dst_pixels_opt[0], 1280);
+    }
+#else
+    GaussRow_C(&orig_pixels[0], &dst_pixels_opt[0], 1280);
+#endif
+  }
+
+  for (int i = 0; i < 1280; ++i) {
+    EXPECT_EQ(dst_pixels_c[i], dst_pixels_opt[i]);
+  }
+
+  EXPECT_EQ(dst_pixels_c[0],
+            static_cast<uint16_t>(0 * 1 + 1 * 4 + 2 * 6 + 3 * 4 + 4 * 1));
+  EXPECT_EQ(dst_pixels_c[639], static_cast<uint16_t>(10256));
+}
+
+extern "C" void GaussCol_NEON(const uint16_t* src0,
+                              const uint16_t* src1,
+                              const uint16_t* src2,
+                              const uint16_t* src3,
+                              const uint16_t* src4,
+                              uint32_t* dst,
+                              int width);
+
+extern "C" void GaussCol_C(const uint16_t* src0,
+                           const uint16_t* src1,
+                           const uint16_t* src2,
+                           const uint16_t* src3,
+                           const uint16_t* src4,
+                           uint32_t* dst,
+                           int width);
+
+TEST_F(LibYUVPlanarTest, TestGaussCol_Opt) {
+  SIMD_ALIGNED(uint16_t orig_pixels[1280 * 5]);
+  SIMD_ALIGNED(uint32_t dst_pixels_c[1280]);
+  SIMD_ALIGNED(uint32_t dst_pixels_opt[1280]);
+
+  memset(orig_pixels, 0, sizeof(orig_pixels));
+  memset(dst_pixels_c, 1, sizeof(dst_pixels_c));
+  memset(dst_pixels_opt, 2, sizeof(dst_pixels_opt));
+
+  for (int i = 0; i < 1280 * 5; ++i) {
+    orig_pixels[i] = static_cast<float>(i);
+  }
+  GaussCol_C(&orig_pixels[0], &orig_pixels[1280], &orig_pixels[1280 * 2],
+             &orig_pixels[1280 * 3], &orig_pixels[1280 * 4], &dst_pixels_c[0],
+             1280);
+  for (int i = 0; i < benchmark_pixels_div1280_; ++i) {
+#if !defined(LIBYUV_DISABLE_NEON) && \
+    (defined(__aarch64__) || defined(__ARM_NEON__) || defined(LIBYUV_NEON))
+    int has_neon = TestCpuFlag(kCpuHasNEON);
+    if (has_neon) {
+      GaussCol_NEON(&orig_pixels[0], &orig_pixels[1280], &orig_pixels[1280 * 2],
+                    &orig_pixels[1280 * 3], &orig_pixels[1280 * 4],
+                    &dst_pixels_opt[0], 1280);
+    } else {
+      GaussCol_C(&orig_pixels[0], &orig_pixels[1280], &orig_pixels[1280 * 2],
+                 &orig_pixels[1280 * 3], &orig_pixels[1280 * 4],
+                 &dst_pixels_opt[0], 1280);
+    }
+#else
+    GaussCol_C(&orig_pixels[0], &orig_pixels[1280], &orig_pixels[1280 * 2],
+               &orig_pixels[1280 * 3], &orig_pixels[1280 * 4],
+               &dst_pixels_opt[0], 1280);
+#endif
+  }
+
+  for (int i = 0; i < 1280; ++i) {
+    EXPECT_EQ(dst_pixels_c[i], dst_pixels_opt[i]);
+  }
+}
+
+TEST_F(LibYUVPlanarTest, TestGaussRow_F32_Opt) {
+  SIMD_ALIGNED(float orig_pixels[1280 + 4]);
+  SIMD_ALIGNED(float dst_pixels_c[1280]);
+  SIMD_ALIGNED(float dst_pixels_opt[1280]);
+
+  memset(orig_pixels, 0, sizeof(orig_pixels));
+  memset(dst_pixels_c, 1, sizeof(dst_pixels_c));
+  memset(dst_pixels_opt, 2, sizeof(dst_pixels_opt));
+
+  for (int i = 0; i < 1280 + 4; ++i) {
+    orig_pixels[i] = static_cast<float>(i);
+  }
+  GaussRow_F32_C(&orig_pixels[0], &dst_pixels_c[0], 1280);
+  for (int i = 0; i < benchmark_pixels_div1280_; ++i) {
+#if !defined(LIBYUV_DISABLE_NEON) && defined(__aarch64__)
+    int has_neon = TestCpuFlag(kCpuHasNEON);
+    if (has_neon) {
+      GaussRow_F32_NEON(&orig_pixels[0], &dst_pixels_opt[0], 1280);
+    } else {
+      GaussRow_F32_C(&orig_pixels[0], &dst_pixels_opt[0], 1280);
+    }
+#else
+    GaussRow_F32_C(&orig_pixels[0], &dst_pixels_opt[0], 1280);
+#endif
+  }
+
+  for (int i = 0; i < 1280; ++i) {
+    EXPECT_EQ(dst_pixels_c[i], dst_pixels_opt[i]);
+  }
+}
+
+TEST_F(LibYUVPlanarTest, TestGaussCol_F32_Opt) {
+  SIMD_ALIGNED(float dst_pixels_c[1280]);
+  SIMD_ALIGNED(float dst_pixels_opt[1280]);
+  align_buffer_page_end(orig_pixels_buf, 1280 * 5 * 4);  // 5 rows
+  float* orig_pixels = reinterpret_cast<float*>(orig_pixels_buf);
+
+  memset(orig_pixels, 0, 1280 * 5 * 4);
+  memset(dst_pixels_c, 1, sizeof(dst_pixels_c));
+  memset(dst_pixels_opt, 2, sizeof(dst_pixels_opt));
+
+  for (int i = 0; i < 1280 * 5; ++i) {
+    orig_pixels[i] = static_cast<float>(i);
+  }
+  GaussCol_F32_C(&orig_pixels[0], &orig_pixels[1280], &orig_pixels[1280 * 2],
+                 &orig_pixels[1280 * 3], &orig_pixels[1280 * 4],
+                 &dst_pixels_c[0], 1280);
+  for (int i = 0; i < benchmark_pixels_div1280_; ++i) {
+#if !defined(LIBYUV_DISABLE_NEON) && defined(__aarch64__)
+    int has_neon = TestCpuFlag(kCpuHasNEON);
+    if (has_neon) {
+      GaussCol_F32_NEON(&orig_pixels[0], &orig_pixels[1280],
+                        &orig_pixels[1280 * 2], &orig_pixels[1280 * 3],
+                        &orig_pixels[1280 * 4], &dst_pixels_opt[0], 1280);
+    } else {
+      GaussCol_F32_C(&orig_pixels[0], &orig_pixels[1280],
+                     &orig_pixels[1280 * 2], &orig_pixels[1280 * 3],
+                     &orig_pixels[1280 * 4], &dst_pixels_opt[0], 1280);
+    }
+#else
+    GaussCol_F32_C(&orig_pixels[0], &orig_pixels[1280], &orig_pixels[1280 * 2],
+                   &orig_pixels[1280 * 3], &orig_pixels[1280 * 4],
+                   &dst_pixels_opt[0], 1280);
+#endif
+  }
+
+  for (int i = 0; i < 1280; ++i) {
+    EXPECT_EQ(dst_pixels_c[i], dst_pixels_opt[i]);
+  }
+  free_aligned_buffer_page_end(orig_pixels_buf);
+}
+
+TEST_F(LibYUVPlanarTest, SwapUVRow) {
+  const int kPixels = benchmark_width_ * benchmark_height_;
+  void (*SwapUVRow)(const uint8_t* src_uv, uint8_t* dst_vu, int width) =
+      SwapUVRow_C;
+
+  align_buffer_page_end(src_pixels_vu, kPixels * 2);
+  align_buffer_page_end(dst_pixels_uv, kPixels * 2);
+  MemRandomize(src_pixels_vu, kPixels * 2);
+  memset(dst_pixels_uv, 1, kPixels * 2);
+
+#if defined(HAS_SWAPUVROW_NEON)
+  if (TestCpuFlag(kCpuHasNEON)) {
+    SwapUVRow = SwapUVRow_Any_NEON;
+    if (IS_ALIGNED(kPixels, 16)) {
+      SwapUVRow = SwapUVRow_NEON;
+    }
+  }
+#endif
+
+  for (int j = 0; j < benchmark_iterations_; j++) {
+    SwapUVRow(src_pixels_vu, dst_pixels_uv, kPixels);
+  }
+  for (int i = 0; i < kPixels; ++i) {
+    EXPECT_EQ(dst_pixels_uv[i * 2 + 0], src_pixels_vu[i * 2 + 1]);
+    EXPECT_EQ(dst_pixels_uv[i * 2 + 1], src_pixels_vu[i * 2 + 0]);
+  }
+
+  free_aligned_buffer_page_end(src_pixels_vu);
+  free_aligned_buffer_page_end(dst_pixels_uv);
+}
+#endif  // ENABLE_ROW_TESTS
+
+TEST_F(LibYUVPlanarTest, TestGaussPlane_F32) {
+  const int kSize = benchmark_width_ * benchmark_height_ * 4;
+  align_buffer_page_end(orig_pixels, kSize);
+  align_buffer_page_end(dst_pixels_opt, kSize);
+  align_buffer_page_end(dst_pixels_c, kSize);
+
+  for (int i = 0; i < benchmark_width_ * benchmark_height_; ++i) {
+    ((float*)(orig_pixels))[i] = (i & 1023) * 3.14f;
+  }
+  memset(dst_pixels_opt, 1, kSize);
+  memset(dst_pixels_c, 2, kSize);
+
+  MaskCpuFlags(disable_cpu_flags_);
+  GaussPlane_F32((const float*)(orig_pixels), benchmark_width_,
+                 (float*)(dst_pixels_c), benchmark_width_, benchmark_width_,
+                 benchmark_height_);
+  MaskCpuFlags(benchmark_cpu_info_);
+
+  for (int i = 0; i < benchmark_iterations_; ++i) {
+    GaussPlane_F32((const float*)(orig_pixels), benchmark_width_,
+                   (float*)(dst_pixels_opt), benchmark_width_, benchmark_width_,
+                   benchmark_height_);
+  }
+  for (int i = 0; i < benchmark_width_ * benchmark_height_; ++i) {
+    EXPECT_NEAR(((float*)(dst_pixels_c))[i], ((float*)(dst_pixels_opt))[i], 1.f)
+        << i;
+  }
+
+  free_aligned_buffer_page_end(dst_pixels_c);
+  free_aligned_buffer_page_end(dst_pixels_opt);
+  free_aligned_buffer_page_end(orig_pixels);
+}
+
+TEST_F(LibYUVPlanarTest, HalfMergeUVPlane_Opt) {
+  int dst_width = (benchmark_width_ + 1) / 2;
+  int dst_height = (benchmark_height_ + 1) / 2;
+  align_buffer_page_end(src_pixels_u, benchmark_width_ * benchmark_height_);
+  align_buffer_page_end(src_pixels_v, benchmark_width_ * benchmark_height_);
+  align_buffer_page_end(tmp_pixels_u, dst_width * dst_height);
+  align_buffer_page_end(tmp_pixels_v, dst_width * dst_height);
+  align_buffer_page_end(dst_pixels_uv_opt, dst_width * 2 * dst_height);
+  align_buffer_page_end(dst_pixels_uv_c, dst_width * 2 * dst_height);
+
+  MemRandomize(src_pixels_u, benchmark_width_ * benchmark_height_);
+  MemRandomize(src_pixels_v, benchmark_width_ * benchmark_height_);
+  MemRandomize(tmp_pixels_u, dst_width * dst_height);
+  MemRandomize(tmp_pixels_v, dst_width * dst_height);
+  MemRandomize(dst_pixels_uv_opt, dst_width * 2 * dst_height);
+  MemRandomize(dst_pixels_uv_c, dst_width * 2 * dst_height);
+
+  MaskCpuFlags(disable_cpu_flags_);
+  HalfMergeUVPlane(src_pixels_u, benchmark_width_, src_pixels_v,
+                   benchmark_width_, dst_pixels_uv_c, dst_width * 2,
+                   benchmark_width_, benchmark_height_);
+  MaskCpuFlags(benchmark_cpu_info_);
+
+  for (int i = 0; i < benchmark_iterations_; ++i) {
+    HalfMergeUVPlane(src_pixels_u, benchmark_width_, src_pixels_v,
+                     benchmark_width_, dst_pixels_uv_opt, dst_width * 2,
+                     benchmark_width_, benchmark_height_);
+  }
+
+  for (int i = 0; i < dst_width * 2 * dst_height; ++i) {
+    EXPECT_EQ(dst_pixels_uv_c[i], dst_pixels_uv_opt[i]);
+  }
+
+  free_aligned_buffer_page_end(src_pixels_u);
+  free_aligned_buffer_page_end(src_pixels_v);
+  free_aligned_buffer_page_end(tmp_pixels_u);
+  free_aligned_buffer_page_end(tmp_pixels_v);
+  free_aligned_buffer_page_end(dst_pixels_uv_opt);
+  free_aligned_buffer_page_end(dst_pixels_uv_c);
+}
+
+TEST_F(LibYUVPlanarTest, NV12Copy) {
+  const int halfwidth = (benchmark_width_ + 1) >> 1;
+  const int halfheight = (benchmark_height_ + 1) >> 1;
+  align_buffer_page_end(src_y, benchmark_width_ * benchmark_height_);
+  align_buffer_page_end(src_uv, halfwidth * 2 * halfheight);
+  align_buffer_page_end(dst_y, benchmark_width_ * benchmark_height_);
+  align_buffer_page_end(dst_uv, halfwidth * 2 * halfheight);
+
+  MemRandomize(src_y, benchmark_width_ * benchmark_height_);
+  MemRandomize(src_uv, halfwidth * 2 * halfheight);
+  MemRandomize(dst_y, benchmark_width_ * benchmark_height_);
+  MemRandomize(dst_uv, halfwidth * 2 * halfheight);
+
+  for (int i = 0; i < benchmark_iterations_; ++i) {
+    NV12Copy(src_y, benchmark_width_, src_uv, halfwidth * 2, dst_y,
+             benchmark_width_, dst_uv, halfwidth * 2, benchmark_width_,
+             benchmark_height_);
+  }
+
+  for (int i = 0; i < benchmark_width_ * benchmark_height_; ++i) {
+    EXPECT_EQ(src_y[i], dst_y[i]);
+  }
+  for (int i = 0; i < halfwidth * 2 * halfheight; ++i) {
+    EXPECT_EQ(src_uv[i], dst_uv[i]);
+  }
+
+  free_aligned_buffer_page_end(src_y);
+  free_aligned_buffer_page_end(src_uv);
+  free_aligned_buffer_page_end(dst_y);
+  free_aligned_buffer_page_end(dst_uv);
+}
+
+TEST_F(LibYUVPlanarTest, NV21Copy) {
+  const int halfwidth = (benchmark_width_ + 1) >> 1;
+  const int halfheight = (benchmark_height_ + 1) >> 1;
+  align_buffer_page_end(src_y, benchmark_width_ * benchmark_height_);
+  align_buffer_page_end(src_vu, halfwidth * 2 * halfheight);
+  align_buffer_page_end(dst_y, benchmark_width_ * benchmark_height_);
+  align_buffer_page_end(dst_vu, halfwidth * 2 * halfheight);
+
+  MemRandomize(src_y, benchmark_width_ * benchmark_height_);
+  MemRandomize(src_vu, halfwidth * 2 * halfheight);
+  MemRandomize(dst_y, benchmark_width_ * benchmark_height_);
+  MemRandomize(dst_vu, halfwidth * 2 * halfheight);
+
+  for (int i = 0; i < benchmark_iterations_; ++i) {
+    NV21Copy(src_y, benchmark_width_, src_vu, halfwidth * 2, dst_y,
+             benchmark_width_, dst_vu, halfwidth * 2, benchmark_width_,
+             benchmark_height_);
+  }
+
+  for (int i = 0; i < benchmark_width_ * benchmark_height_; ++i) {
+    EXPECT_EQ(src_y[i], dst_y[i]);
+  }
+  for (int i = 0; i < halfwidth * 2 * halfheight; ++i) {
+    EXPECT_EQ(src_vu[i], dst_vu[i]);
+  }
+
+  free_aligned_buffer_page_end(src_y);
+  free_aligned_buffer_page_end(src_vu);
+  free_aligned_buffer_page_end(dst_y);
+  free_aligned_buffer_page_end(dst_vu);
+}
+
+}  // namespace libyuv
diff --git a/3rdparty/libyuv/src/unit_test/rotate_argb_test.cc b/3rdparty/libyuv/src/unit_test/rotate_argb_test.cc
new file mode 100644
index 00000000..01ed69ca
--- /dev/null
+++ b/3rdparty/libyuv/src/unit_test/rotate_argb_test.cc
@@ -0,0 +1,228 @@
+/*
+ *  Copyright 2012 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include <stdlib.h>
+
+#include "../unit_test/unit_test.h"
+#include "libyuv/cpu_id.h"
+#include "libyuv/rotate_argb.h"
+
+namespace libyuv {
+
+void TestRotateBpp(int src_width,
+                   int src_height,
+                   int dst_width,
+                   int dst_height,
+                   libyuv::RotationMode mode,
+                   int benchmark_iterations,
+                   int disable_cpu_flags,
+                   int benchmark_cpu_info,
+                   const int kBpp) {
+  if (src_width < 1) {
+    src_width = 1;
+  }
+  if (src_height < 1) {
+    src_height = 1;
+  }
+  if (dst_width < 1) {
+    dst_width = 1;
+  }
+  if (dst_height < 1) {
+    dst_height = 1;
+  }
+  int src_stride_argb = src_width * kBpp;
+  int src_argb_plane_size = src_stride_argb * abs(src_height);
+  align_buffer_page_end(src_argb, src_argb_plane_size);
+  for (int i = 0; i < src_argb_plane_size; ++i) {
+    src_argb[i] = fastrand() & 0xff;
+  }
+
+  int dst_stride_argb = dst_width * kBpp;
+  int dst_argb_plane_size = dst_stride_argb * dst_height;
+  align_buffer_page_end(dst_argb_c, dst_argb_plane_size);
+  align_buffer_page_end(dst_argb_opt, dst_argb_plane_size);
+  memset(dst_argb_c, 2, dst_argb_plane_size);
+  memset(dst_argb_opt, 3, dst_argb_plane_size);
+
+  if (kBpp == 1) {
+    MaskCpuFlags(disable_cpu_flags);  // Disable all CPU optimization.
+    RotatePlane(src_argb, src_stride_argb, dst_argb_c, dst_stride_argb,
+                src_width, src_height, mode);
+
+    MaskCpuFlags(benchmark_cpu_info);  // Enable all CPU optimization.
+    for (int i = 0; i < benchmark_iterations; ++i) {
+      RotatePlane(src_argb, src_stride_argb, dst_argb_opt, dst_stride_argb,
+                  src_width, src_height, mode);
+    }
+  } else if (kBpp == 4) {
+    MaskCpuFlags(disable_cpu_flags);  // Disable all CPU optimization.
+    ARGBRotate(src_argb, src_stride_argb, dst_argb_c, dst_stride_argb,
+               src_width, src_height, mode);
+
+    MaskCpuFlags(benchmark_cpu_info);  // Enable all CPU optimization.
+    for (int i = 0; i < benchmark_iterations; ++i) {
+      ARGBRotate(src_argb, src_stride_argb, dst_argb_opt, dst_stride_argb,
+                 src_width, src_height, mode);
+    }
+  }
+
+  // Rotation should be exact.
+  for (int i = 0; i < dst_argb_plane_size; ++i) {
+    EXPECT_EQ(dst_argb_c[i], dst_argb_opt[i]);
+  }
+
+  free_aligned_buffer_page_end(dst_argb_c);
+  free_aligned_buffer_page_end(dst_argb_opt);
+  free_aligned_buffer_page_end(src_argb);
+}
+
+static void ARGBTestRotate(int src_width,
+                           int src_height,
+                           int dst_width,
+                           int dst_height,
+                           libyuv::RotationMode mode,
+                           int benchmark_iterations,
+                           int disable_cpu_flags,
+                           int benchmark_cpu_info) {
+  TestRotateBpp(src_width, src_height, dst_width, dst_height, mode,
+                benchmark_iterations, disable_cpu_flags, benchmark_cpu_info, 4);
+}
+
+TEST_F(LibYUVRotateTest, ARGBRotate0_Opt) {
+  ARGBTestRotate(benchmark_width_, benchmark_height_, benchmark_width_,
+                 benchmark_height_, kRotate0, benchmark_iterations_,
+                 disable_cpu_flags_, benchmark_cpu_info_);
+}
+
+TEST_F(LibYUVRotateTest, ARGBRotate90_Opt) {
+  ARGBTestRotate(benchmark_width_, benchmark_height_, benchmark_height_,
+                 benchmark_width_, kRotate90, benchmark_iterations_,
+                 disable_cpu_flags_, benchmark_cpu_info_);
+}
+
+TEST_F(LibYUVRotateTest, ARGBRotate180_Opt) {
+  ARGBTestRotate(benchmark_width_, benchmark_height_, benchmark_width_,
+                 benchmark_height_, kRotate180, benchmark_iterations_,
+                 disable_cpu_flags_, benchmark_cpu_info_);
+}
+
+TEST_F(LibYUVRotateTest, ARGBRotate270_Opt) {
+  ARGBTestRotate(benchmark_width_, benchmark_height_, benchmark_height_,
+                 benchmark_width_, kRotate270, benchmark_iterations_,
+                 disable_cpu_flags_, benchmark_cpu_info_);
+}
+
+static void TestRotatePlane(int src_width,
+                            int src_height,
+                            int dst_width,
+                            int dst_height,
+                            libyuv::RotationMode mode,
+                            int benchmark_iterations,
+                            int disable_cpu_flags,
+                            int benchmark_cpu_info) {
+  TestRotateBpp(src_width, src_height, dst_width, dst_height, mode,
+                benchmark_iterations, disable_cpu_flags, benchmark_cpu_info, 1);
+}
+
+TEST_F(LibYUVRotateTest, RotatePlane0_Opt) {
+  TestRotatePlane(benchmark_width_, benchmark_height_, benchmark_width_,
+                  benchmark_height_, kRotate0, benchmark_iterations_,
+                  disable_cpu_flags_, benchmark_cpu_info_);
+}
+
+TEST_F(LibYUVRotateTest, RotatePlane90_Opt) {
+  TestRotatePlane(benchmark_width_, benchmark_height_, benchmark_height_,
+                  benchmark_width_, kRotate90, benchmark_iterations_,
+                  disable_cpu_flags_, benchmark_cpu_info_);
+}
+
+TEST_F(LibYUVRotateTest, RotatePlane180_Opt) {
+  TestRotatePlane(benchmark_width_, benchmark_height_, benchmark_width_,
+                  benchmark_height_, kRotate180, benchmark_iterations_,
+                  disable_cpu_flags_, benchmark_cpu_info_);
+}
+
+TEST_F(LibYUVRotateTest, RotatePlane270_Opt) {
+  TestRotatePlane(benchmark_width_, benchmark_height_, benchmark_height_,
+                  benchmark_width_, kRotate270, benchmark_iterations_,
+                  disable_cpu_flags_, benchmark_cpu_info_);
+}
+
+TEST_F(LibYUVRotateTest, DISABLED_RotatePlane0_Odd) {
+  TestRotatePlane(benchmark_width_ + 1, benchmark_height_ + 1,
+                  benchmark_width_ + 1, benchmark_height_ + 1, kRotate0,
+                  benchmark_iterations_, disable_cpu_flags_,
+                  benchmark_cpu_info_);
+}
+
+TEST_F(LibYUVRotateTest, DISABLED_RotatePlane90_Odd) {
+  TestRotatePlane(benchmark_width_ + 1, benchmark_height_ + 1,
+                  benchmark_height_ + 1, benchmark_width_ + 1, kRotate90,
+                  benchmark_iterations_, disable_cpu_flags_,
+                  benchmark_cpu_info_);
+}
+
+TEST_F(LibYUVRotateTest, DISABLED_RotatePlane180_Odd) {
+  TestRotatePlane(benchmark_width_ + 1, benchmark_height_ + 1,
+                  benchmark_width_ + 1, benchmark_height_ + 1, kRotate180,
+                  benchmark_iterations_, disable_cpu_flags_,
+                  benchmark_cpu_info_);
+}
+
+TEST_F(LibYUVRotateTest, DISABLED_RotatePlane270_Odd) {
+  TestRotatePlane(benchmark_width_ + 1, benchmark_height_ + 1,
+                  benchmark_height_ + 1, benchmark_width_ + 1, kRotate270,
+                  benchmark_iterations_, disable_cpu_flags_,
+                  benchmark_cpu_info_);
+}
+
+TEST_F(LibYUVRotateTest, RotatePlane90_TestStride) {
+  int argb_plane_size = benchmark_width_ * 4 * abs(benchmark_height_);
+
+  align_buffer_page_end(src_argb, argb_plane_size);
+  align_buffer_page_end(dst_argb, argb_plane_size);
+
+  EXPECT_EQ(0, ARGBRotate(src_argb, benchmark_width_ * 4, dst_argb,
+                          benchmark_width_ * 4, benchmark_width_,
+                          benchmark_height_, kRotate0));
+
+  EXPECT_EQ(0, ARGBRotate(src_argb, benchmark_width_ * 4 - 1, dst_argb,
+                          benchmark_width_ * 4 - 1, benchmark_width_ - 1,
+                          benchmark_height_, kRotate0));
+
+  EXPECT_EQ(0, ARGBRotate(src_argb, benchmark_width_ * 4, dst_argb,
+                          benchmark_width_ * 4, benchmark_width_,
+                          benchmark_height_, kRotate180));
+
+  EXPECT_EQ(0, ARGBRotate(src_argb, benchmark_width_ * 4 - 1, dst_argb,
+                          benchmark_width_ * 4 - 1, benchmark_width_ - 1,
+                          benchmark_height_, kRotate180));
+
+  EXPECT_EQ(0, ARGBRotate(src_argb, benchmark_width_ * 4, dst_argb,
+                          abs(benchmark_height_) * 4, benchmark_width_,
+                          benchmark_height_, kRotate90));
+
+  EXPECT_EQ(-1, ARGBRotate(src_argb, benchmark_width_ * 4 - 1, dst_argb,
+                           abs(benchmark_height_) * 4, benchmark_width_ - 1,
+                           benchmark_height_, kRotate90));
+
+  EXPECT_EQ(0, ARGBRotate(src_argb, benchmark_width_ * 4, dst_argb,
+                          abs(benchmark_height_) * 4, benchmark_width_,
+                          benchmark_height_, kRotate270));
+
+  EXPECT_EQ(-1, ARGBRotate(src_argb, benchmark_width_ * 4 - 1, dst_argb,
+                           abs(benchmark_height_) * 4, benchmark_width_ - 1,
+                           benchmark_height_, kRotate270));
+
+  free_aligned_buffer_page_end(dst_argb);
+  free_aligned_buffer_page_end(src_argb);
+}
+
+}  // namespace libyuv
diff --git a/3rdparty/libyuv/src/unit_test/rotate_test.cc b/3rdparty/libyuv/src/unit_test/rotate_test.cc
new file mode 100644
index 00000000..d3887414
--- /dev/null
+++ b/3rdparty/libyuv/src/unit_test/rotate_test.cc
@@ -0,0 +1,599 @@
+/*
+ *  Copyright 2012 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include <stdlib.h>
+
+#include "../unit_test/unit_test.h"
+#include "libyuv/cpu_id.h"
+#include "libyuv/rotate.h"
+
+namespace libyuv {
+
+#define SUBSAMPLE(v, a) ((((v) + (a)-1)) / (a))
+
+static void I420TestRotate(int src_width,
+                           int src_height,
+                           int dst_width,
+                           int dst_height,
+                           libyuv::RotationMode mode,
+                           int benchmark_iterations,
+                           int disable_cpu_flags,
+                           int benchmark_cpu_info) {
+  if (src_width < 1) {
+    src_width = 1;
+  }
+  if (src_height == 0) {
+    src_height = 1;
+  }
+  if (dst_width < 1) {
+    dst_width = 1;
+  }
+  if (dst_height < 1) {
+    dst_height = 1;
+  }
+  int src_i420_y_size = src_width * Abs(src_height);
+  int src_i420_uv_size = ((src_width + 1) / 2) * ((Abs(src_height) + 1) / 2);
+  int src_i420_size = src_i420_y_size + src_i420_uv_size * 2;
+  align_buffer_page_end(src_i420, src_i420_size);
+  for (int i = 0; i < src_i420_size; ++i) {
+    src_i420[i] = fastrand() & 0xff;
+  }
+
+  int dst_i420_y_size = dst_width * dst_height;
+  int dst_i420_uv_size = ((dst_width + 1) / 2) * ((dst_height + 1) / 2);
+  int dst_i420_size = dst_i420_y_size + dst_i420_uv_size * 2;
+  align_buffer_page_end(dst_i420_c, dst_i420_size);
+  align_buffer_page_end(dst_i420_opt, dst_i420_size);
+  memset(dst_i420_c, 2, dst_i420_size);
+  memset(dst_i420_opt, 3, dst_i420_size);
+
+  MaskCpuFlags(disable_cpu_flags);  // Disable all CPU optimization.
+  I420Rotate(src_i420, src_width, src_i420 + src_i420_y_size,
+             (src_width + 1) / 2, src_i420 + src_i420_y_size + src_i420_uv_size,
+             (src_width + 1) / 2, dst_i420_c, dst_width,
+             dst_i420_c + dst_i420_y_size, (dst_width + 1) / 2,
+             dst_i420_c + dst_i420_y_size + dst_i420_uv_size,
+             (dst_width + 1) / 2, src_width, src_height, mode);
+
+  MaskCpuFlags(benchmark_cpu_info);  // Enable all CPU optimization.
+  for (int i = 0; i < benchmark_iterations; ++i) {
+    I420Rotate(
+        src_i420, src_width, src_i420 + src_i420_y_size, (src_width + 1) / 2,
+        src_i420 + src_i420_y_size + src_i420_uv_size, (src_width + 1) / 2,
+        dst_i420_opt, dst_width, dst_i420_opt + dst_i420_y_size,
+        (dst_width + 1) / 2, dst_i420_opt + dst_i420_y_size + dst_i420_uv_size,
+        (dst_width + 1) / 2, src_width, src_height, mode);
+  }
+
+  // Rotation should be exact.
+  for (int i = 0; i < dst_i420_size; ++i) {
+    EXPECT_EQ(dst_i420_c[i], dst_i420_opt[i]);
+  }
+
+  free_aligned_buffer_page_end(dst_i420_c);
+  free_aligned_buffer_page_end(dst_i420_opt);
+  free_aligned_buffer_page_end(src_i420);
+}
+
+TEST_F(LibYUVRotateTest, I420Rotate0_Opt) {
+  I420TestRotate(benchmark_width_, benchmark_height_, benchmark_width_,
+                 benchmark_height_, kRotate0, benchmark_iterations_,
+                 disable_cpu_flags_, benchmark_cpu_info_);
+}
+
+TEST_F(LibYUVRotateTest, I420Rotate90_Opt) {
+  I420TestRotate(benchmark_width_, benchmark_height_, benchmark_height_,
+                 benchmark_width_, kRotate90, benchmark_iterations_,
+                 disable_cpu_flags_, benchmark_cpu_info_);
+}
+
+TEST_F(LibYUVRotateTest, I420Rotate180_Opt) {
+  I420TestRotate(benchmark_width_, benchmark_height_, benchmark_width_,
+                 benchmark_height_, kRotate180, benchmark_iterations_,
+                 disable_cpu_flags_, benchmark_cpu_info_);
+}
+
+TEST_F(LibYUVRotateTest, I420Rotate270_Opt) {
+  I420TestRotate(benchmark_width_, benchmark_height_, benchmark_height_,
+                 benchmark_width_, kRotate270, benchmark_iterations_,
+                 disable_cpu_flags_, benchmark_cpu_info_);
+}
+
+// TODO(fbarchard): Remove odd width tests.
+// Odd width tests work but disabled because they use C code and can be
+// tested by passing an odd width command line or environment variable.
+TEST_F(LibYUVRotateTest, DISABLED_I420Rotate0_Odd) {
+  I420TestRotate(benchmark_width_ + 1, benchmark_height_ + 1,
+                 benchmark_width_ + 1, benchmark_height_ + 1, kRotate0,
+                 benchmark_iterations_, disable_cpu_flags_,
+                 benchmark_cpu_info_);
+}
+
+TEST_F(LibYUVRotateTest, DISABLED_I420Rotate90_Odd) {
+  I420TestRotate(benchmark_width_ + 1, benchmark_height_ + 1,
+                 benchmark_height_ + 1, benchmark_width_ + 1, kRotate90,
+                 benchmark_iterations_, disable_cpu_flags_,
+                 benchmark_cpu_info_);
+}
+
+TEST_F(LibYUVRotateTest, DISABLED_I420Rotate180_Odd) {
+  I420TestRotate(benchmark_width_ + 1, benchmark_height_ + 1,
+                 benchmark_width_ + 1, benchmark_height_ + 1, kRotate180,
+                 benchmark_iterations_, disable_cpu_flags_,
+                 benchmark_cpu_info_);
+}
+
+TEST_F(LibYUVRotateTest, DISABLED_I420Rotate270_Odd) {
+  I420TestRotate(benchmark_width_ + 1, benchmark_height_ + 1,
+                 benchmark_height_ + 1, benchmark_width_ + 1, kRotate270,
+                 benchmark_iterations_, disable_cpu_flags_,
+                 benchmark_cpu_info_);
+}
+
+static void I422TestRotate(int src_width,
+                           int src_height,
+                           int dst_width,
+                           int dst_height,
+                           libyuv::RotationMode mode,
+                           int benchmark_iterations,
+                           int disable_cpu_flags,
+                           int benchmark_cpu_info) {
+  if (src_width < 1) {
+    src_width = 1;
+  }
+  if (src_height == 0) {
+    src_height = 1;
+  }
+  if (dst_width < 1) {
+    dst_width = 1;
+  }
+  if (dst_height < 1) {
+    dst_height = 1;
+  }
+  int src_i422_y_size = src_width * Abs(src_height);
+  int src_i422_uv_size = ((src_width + 1) / 2) * Abs(src_height);
+  int src_i422_size = src_i422_y_size + src_i422_uv_size * 2;
+  align_buffer_page_end(src_i422, src_i422_size);
+  for (int i = 0; i < src_i422_size; ++i) {
+    src_i422[i] = fastrand() & 0xff;
+  }
+
+  int dst_i422_y_size = dst_width * dst_height;
+  int dst_i422_uv_size = ((dst_width + 1) / 2) * dst_height;
+  int dst_i422_size = dst_i422_y_size + dst_i422_uv_size * 2;
+  align_buffer_page_end(dst_i422_c, dst_i422_size);
+  align_buffer_page_end(dst_i422_opt, dst_i422_size);
+  memset(dst_i422_c, 2, dst_i422_size);
+  memset(dst_i422_opt, 3, dst_i422_size);
+
+  MaskCpuFlags(disable_cpu_flags);  // Disable all CPU optimization.
+  I422Rotate(src_i422, src_width, src_i422 + src_i422_y_size,
+             (src_width + 1) / 2, src_i422 + src_i422_y_size + src_i422_uv_size,
+             (src_width + 1) / 2, dst_i422_c, dst_width,
+             dst_i422_c + dst_i422_y_size, (dst_width + 1) / 2,
+             dst_i422_c + dst_i422_y_size + dst_i422_uv_size,
+             (dst_width + 1) / 2, src_width, src_height, mode);
+
+  MaskCpuFlags(benchmark_cpu_info);  // Enable all CPU optimization.
+  for (int i = 0; i < benchmark_iterations; ++i) {
+    I422Rotate(
+        src_i422, src_width, src_i422 + src_i422_y_size, (src_width + 1) / 2,
+        src_i422 + src_i422_y_size + src_i422_uv_size, (src_width + 1) / 2,
+        dst_i422_opt, dst_width, dst_i422_opt + dst_i422_y_size,
+        (dst_width + 1) / 2, dst_i422_opt + dst_i422_y_size + dst_i422_uv_size,
+        (dst_width + 1) / 2, src_width, src_height, mode);
+  }
+
+  // Rotation should be exact.
+  for (int i = 0; i < dst_i422_size; ++i) {
+    EXPECT_EQ(dst_i422_c[i], dst_i422_opt[i]);
+  }
+
+  free_aligned_buffer_page_end(dst_i422_c);
+  free_aligned_buffer_page_end(dst_i422_opt);
+  free_aligned_buffer_page_end(src_i422);
+}
+
+TEST_F(LibYUVRotateTest, I422Rotate0_Opt) {
+  I422TestRotate(benchmark_width_, benchmark_height_, benchmark_width_,
+                 benchmark_height_, kRotate0, benchmark_iterations_,
+                 disable_cpu_flags_, benchmark_cpu_info_);
+}
+
+TEST_F(LibYUVRotateTest, I422Rotate90_Opt) {
+  I422TestRotate(benchmark_width_, benchmark_height_, benchmark_height_,
+                 benchmark_width_, kRotate90, benchmark_iterations_,
+                 disable_cpu_flags_, benchmark_cpu_info_);
+}
+
+TEST_F(LibYUVRotateTest, I422Rotate180_Opt) {
+  I422TestRotate(benchmark_width_, benchmark_height_, benchmark_width_,
+                 benchmark_height_, kRotate180, benchmark_iterations_,
+                 disable_cpu_flags_, benchmark_cpu_info_);
+}
+
+TEST_F(LibYUVRotateTest, I422Rotate270_Opt) {
+  I422TestRotate(benchmark_width_, benchmark_height_, benchmark_height_,
+                 benchmark_width_, kRotate270, benchmark_iterations_,
+                 disable_cpu_flags_, benchmark_cpu_info_);
+}
+
+static void I444TestRotate(int src_width,
+                           int src_height,
+                           int dst_width,
+                           int dst_height,
+                           libyuv::RotationMode mode,
+                           int benchmark_iterations,
+                           int disable_cpu_flags,
+                           int benchmark_cpu_info) {
+  if (src_width < 1) {
+    src_width = 1;
+  }
+  if (src_height == 0) {
+    src_height = 1;
+  }
+  if (dst_width < 1) {
+    dst_width = 1;
+  }
+  if (dst_height < 1) {
+    dst_height = 1;
+  }
+  int src_i444_y_size = src_width * Abs(src_height);
+  int src_i444_uv_size = src_width * Abs(src_height);
+  int src_i444_size = src_i444_y_size + src_i444_uv_size * 2;
+  align_buffer_page_end(src_i444, src_i444_size);
+  for (int i = 0; i < src_i444_size; ++i) {
+    src_i444[i] = fastrand() & 0xff;
+  }
+
+  int dst_i444_y_size = dst_width * dst_height;
+  int dst_i444_uv_size = dst_width * dst_height;
+  int dst_i444_size = dst_i444_y_size + dst_i444_uv_size * 2;
+  align_buffer_page_end(dst_i444_c, dst_i444_size);
+  align_buffer_page_end(dst_i444_opt, dst_i444_size);
+  memset(dst_i444_c, 2, dst_i444_size);
+  memset(dst_i444_opt, 3, dst_i444_size);
+
+  MaskCpuFlags(disable_cpu_flags);  // Disable all CPU optimization.
+  I444Rotate(src_i444, src_width, src_i444 + src_i444_y_size, src_width,
+             src_i444 + src_i444_y_size + src_i444_uv_size, src_width,
+             dst_i444_c, dst_width, dst_i444_c + dst_i444_y_size, dst_width,
+             dst_i444_c + dst_i444_y_size + dst_i444_uv_size, dst_width,
+             src_width, src_height, mode);
+
+  MaskCpuFlags(benchmark_cpu_info);  // Enable all CPU optimization.
+  for (int i = 0; i < benchmark_iterations; ++i) {
+    I444Rotate(src_i444, src_width, src_i444 + src_i444_y_size, src_width,
+               src_i444 + src_i444_y_size + src_i444_uv_size, src_width,
+               dst_i444_opt, dst_width, dst_i444_opt + dst_i444_y_size,
+               dst_width, dst_i444_opt + dst_i444_y_size + dst_i444_uv_size,
+               dst_width, src_width, src_height, mode);
+  }
+
+  // Rotation should be exact.
+  for (int i = 0; i < dst_i444_size; ++i) {
+    EXPECT_EQ(dst_i444_c[i], dst_i444_opt[i]);
+  }
+
+  free_aligned_buffer_page_end(dst_i444_c);
+  free_aligned_buffer_page_end(dst_i444_opt);
+  free_aligned_buffer_page_end(src_i444);
+}
+
+TEST_F(LibYUVRotateTest, I444Rotate0_Opt) {
+  I444TestRotate(benchmark_width_, benchmark_height_, benchmark_width_,
+                 benchmark_height_, kRotate0, benchmark_iterations_,
+                 disable_cpu_flags_, benchmark_cpu_info_);
+}
+
+TEST_F(LibYUVRotateTest, I444Rotate90_Opt) {
+  I444TestRotate(benchmark_width_, benchmark_height_, benchmark_height_,
+                 benchmark_width_, kRotate90, benchmark_iterations_,
+                 disable_cpu_flags_, benchmark_cpu_info_);
+}
+
+TEST_F(LibYUVRotateTest, I444Rotate180_Opt) {
+  I444TestRotate(benchmark_width_, benchmark_height_, benchmark_width_,
+                 benchmark_height_, kRotate180, benchmark_iterations_,
+                 disable_cpu_flags_, benchmark_cpu_info_);
+}
+
+TEST_F(LibYUVRotateTest, I444Rotate270_Opt) {
+  I444TestRotate(benchmark_width_, benchmark_height_, benchmark_height_,
+                 benchmark_width_, kRotate270, benchmark_iterations_,
+                 disable_cpu_flags_, benchmark_cpu_info_);
+}
+
+// TODO(fbarchard): Remove odd width tests.
+// Odd width tests work but disabled because they use C code and can be
+// tested by passing an odd width command line or environment variable.
+TEST_F(LibYUVRotateTest, DISABLED_I444Rotate0_Odd) {
+  I444TestRotate(benchmark_width_ + 1, benchmark_height_ + 1,
+                 benchmark_width_ + 1, benchmark_height_ + 1, kRotate0,
+                 benchmark_iterations_, disable_cpu_flags_,
+                 benchmark_cpu_info_);
+}
+
+TEST_F(LibYUVRotateTest, DISABLED_I444Rotate90_Odd) {
+  I444TestRotate(benchmark_width_ + 1, benchmark_height_ + 1,
+                 benchmark_height_ + 1, benchmark_width_ + 1, kRotate90,
+                 benchmark_iterations_, disable_cpu_flags_,
+                 benchmark_cpu_info_);
+}
+
+TEST_F(LibYUVRotateTest, DISABLED_I444Rotate180_Odd) {
+  I444TestRotate(benchmark_width_ + 1, benchmark_height_ + 1,
+                 benchmark_width_ + 1, benchmark_height_ + 1, kRotate180,
+                 benchmark_iterations_, disable_cpu_flags_,
+                 benchmark_cpu_info_);
+}
+
+TEST_F(LibYUVRotateTest, DISABLED_I444Rotate270_Odd) {
+  I444TestRotate(benchmark_width_ + 1, benchmark_height_ + 1,
+                 benchmark_height_ + 1, benchmark_width_ + 1, kRotate270,
+                 benchmark_iterations_, disable_cpu_flags_,
+                 benchmark_cpu_info_);
+}
+
+static void NV12TestRotate(int src_width,
+                           int src_height,
+                           int dst_width,
+                           int dst_height,
+                           libyuv::RotationMode mode,
+                           int benchmark_iterations,
+                           int disable_cpu_flags,
+                           int benchmark_cpu_info) {
+  if (src_width < 1) {
+    src_width = 1;
+  }
+  if (src_height == 0) {  // allow negative for inversion test.
+    src_height = 1;
+  }
+  if (dst_width < 1) {
+    dst_width = 1;
+  }
+  if (dst_height < 1) {
+    dst_height = 1;
+  }
+  int src_nv12_y_size = src_width * Abs(src_height);
+  int src_nv12_uv_size =
+      ((src_width + 1) / 2) * ((Abs(src_height) + 1) / 2) * 2;
+  int src_nv12_size = src_nv12_y_size + src_nv12_uv_size;
+  align_buffer_page_end(src_nv12, src_nv12_size);
+  for (int i = 0; i < src_nv12_size; ++i) {
+    src_nv12[i] = fastrand() & 0xff;
+  }
+
+  int dst_i420_y_size = dst_width * dst_height;
+  int dst_i420_uv_size = ((dst_width + 1) / 2) * ((dst_height + 1) / 2);
+  int dst_i420_size = dst_i420_y_size + dst_i420_uv_size * 2;
+  align_buffer_page_end(dst_i420_c, dst_i420_size);
+  align_buffer_page_end(dst_i420_opt, dst_i420_size);
+  memset(dst_i420_c, 2, dst_i420_size);
+  memset(dst_i420_opt, 3, dst_i420_size);
+
+  MaskCpuFlags(disable_cpu_flags);  // Disable all CPU optimization.
+  NV12ToI420Rotate(src_nv12, src_width, src_nv12 + src_nv12_y_size,
+                   (src_width + 1) & ~1, dst_i420_c, dst_width,
+                   dst_i420_c + dst_i420_y_size, (dst_width + 1) / 2,
+                   dst_i420_c + dst_i420_y_size + dst_i420_uv_size,
+                   (dst_width + 1) / 2, src_width, src_height, mode);
+
+  MaskCpuFlags(benchmark_cpu_info);  // Enable all CPU optimization.
+  for (int i = 0; i < benchmark_iterations; ++i) {
+    NV12ToI420Rotate(src_nv12, src_width, src_nv12 + src_nv12_y_size,
+                     (src_width + 1) & ~1, dst_i420_opt, dst_width,
+                     dst_i420_opt + dst_i420_y_size, (dst_width + 1) / 2,
+                     dst_i420_opt + dst_i420_y_size + dst_i420_uv_size,
+                     (dst_width + 1) / 2, src_width, src_height, mode);
+  }
+
+  // Rotation should be exact.
+  for (int i = 0; i < dst_i420_size; ++i) {
+    EXPECT_EQ(dst_i420_c[i], dst_i420_opt[i]);
+  }
+
+  free_aligned_buffer_page_end(dst_i420_c);
+  free_aligned_buffer_page_end(dst_i420_opt);
+  free_aligned_buffer_page_end(src_nv12);
+}
+
+TEST_F(LibYUVRotateTest, NV12Rotate0_Opt) {
+  NV12TestRotate(benchmark_width_, benchmark_height_, benchmark_width_,
+                 benchmark_height_, kRotate0, benchmark_iterations_,
+                 disable_cpu_flags_, benchmark_cpu_info_);
+}
+
+TEST_F(LibYUVRotateTest, NV12Rotate90_Opt) {
+  NV12TestRotate(benchmark_width_, benchmark_height_, benchmark_height_,
+                 benchmark_width_, kRotate90, benchmark_iterations_,
+                 disable_cpu_flags_, benchmark_cpu_info_);
+}
+
+TEST_F(LibYUVRotateTest, NV12Rotate180_Opt) {
+  NV12TestRotate(benchmark_width_, benchmark_height_, benchmark_width_,
+                 benchmark_height_, kRotate180, benchmark_iterations_,
+                 disable_cpu_flags_, benchmark_cpu_info_);
+}
+
+TEST_F(LibYUVRotateTest, NV12Rotate270_Opt) {
+  NV12TestRotate(benchmark_width_, benchmark_height_, benchmark_height_,
+                 benchmark_width_, kRotate270, benchmark_iterations_,
+                 disable_cpu_flags_, benchmark_cpu_info_);
+}
+
+TEST_F(LibYUVRotateTest, DISABLED_NV12Rotate0_Odd) {
+  NV12TestRotate(benchmark_width_ + 1, benchmark_height_ + 1,
+                 benchmark_width_ + 1, benchmark_height_ + 1, kRotate0,
+                 benchmark_iterations_, disable_cpu_flags_,
+                 benchmark_cpu_info_);
+}
+
+TEST_F(LibYUVRotateTest, DISABLED_NV12Rotate90_Odd) {
+  NV12TestRotate(benchmark_width_ + 1, benchmark_height_ + 1,
+                 benchmark_height_ + 1, benchmark_width_ + 1, kRotate90,
+                 benchmark_iterations_, disable_cpu_flags_,
+                 benchmark_cpu_info_);
+}
+
+TEST_F(LibYUVRotateTest, DISABLED_NV12Rotate180_Odd) {
+  NV12TestRotate(benchmark_width_ + 1, benchmark_height_ + 1,
+                 benchmark_width_ + 1, benchmark_height_ + 1, kRotate180,
+                 benchmark_iterations_, disable_cpu_flags_,
+                 benchmark_cpu_info_);
+}
+
+TEST_F(LibYUVRotateTest, DISABLED_NV12Rotate270_Odd) {
+  NV12TestRotate(benchmark_width_ + 1, benchmark_height_ + 1,
+                 benchmark_height_ + 1, benchmark_width_ + 1, kRotate270,
+                 benchmark_iterations_, disable_cpu_flags_,
+                 benchmark_cpu_info_);
+}
+
+TEST_F(LibYUVRotateTest, NV12Rotate0_Invert) {
+  NV12TestRotate(benchmark_width_, -benchmark_height_, benchmark_width_,
+                 benchmark_height_, kRotate0, benchmark_iterations_,
+                 disable_cpu_flags_, benchmark_cpu_info_);
+}
+
+TEST_F(LibYUVRotateTest, NV12Rotate90_Invert) {
+  NV12TestRotate(benchmark_width_, -benchmark_height_, benchmark_height_,
+                 benchmark_width_, kRotate90, benchmark_iterations_,
+                 disable_cpu_flags_, benchmark_cpu_info_);
+}
+
+TEST_F(LibYUVRotateTest, NV12Rotate180_Invert) {
+  NV12TestRotate(benchmark_width_, -benchmark_height_, benchmark_width_,
+                 benchmark_height_, kRotate180, benchmark_iterations_,
+                 disable_cpu_flags_, benchmark_cpu_info_);
+}
+
+TEST_F(LibYUVRotateTest, NV12Rotate270_Invert) {
+  NV12TestRotate(benchmark_width_, -benchmark_height_, benchmark_height_,
+                 benchmark_width_, kRotate270, benchmark_iterations_,
+                 disable_cpu_flags_, benchmark_cpu_info_);
+}
+
+// Test Android 420 to I420 Rotate
+#define TESTAPLANARTOPI(SRC_FMT_PLANAR, PIXEL_STRIDE, SRC_SUBSAMP_X,          \
+                        SRC_SUBSAMP_Y, FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y,      \
+                        W1280, N, NEG, OFF, PN, OFF_U, OFF_V, ROT)            \
+  TEST_F(LibYUVRotateTest,                                                    \
+         SRC_FMT_PLANAR##To##FMT_PLANAR##Rotate##ROT##To##PN##N) {            \
+    const int kWidth = W1280;                                                 \
+    const int kHeight = benchmark_height_;                                    \
+    const int kSizeUV =                                                       \
+        SUBSAMPLE(kWidth, SRC_SUBSAMP_X) * SUBSAMPLE(kHeight, SRC_SUBSAMP_Y); \
+    align_buffer_page_end(src_y, kWidth* kHeight + OFF);                      \
+    align_buffer_page_end(src_uv,                                             \
+                          kSizeUV*((PIXEL_STRIDE == 3) ? 3 : 2) + OFF);       \
+    align_buffer_page_end(dst_y_c, kWidth* kHeight);                          \
+    align_buffer_page_end(dst_u_c, SUBSAMPLE(kWidth, SUBSAMP_X) *             \
+                                       SUBSAMPLE(kHeight, SUBSAMP_Y));        \
+    align_buffer_page_end(dst_v_c, SUBSAMPLE(kWidth, SUBSAMP_X) *             \
+                                       SUBSAMPLE(kHeight, SUBSAMP_Y));        \
+    align_buffer_page_end(dst_y_opt, kWidth* kHeight);                        \
+    align_buffer_page_end(dst_u_opt, SUBSAMPLE(kWidth, SUBSAMP_X) *           \
+                                         SUBSAMPLE(kHeight, SUBSAMP_Y));      \
+    align_buffer_page_end(dst_v_opt, SUBSAMPLE(kWidth, SUBSAMP_X) *           \
+                                         SUBSAMPLE(kHeight, SUBSAMP_Y));      \
+    uint8_t* src_u = src_uv + OFF_U;                                          \
+    uint8_t* src_v = src_uv + (PIXEL_STRIDE == 1 ? kSizeUV : OFF_V);          \
+    int src_stride_uv = SUBSAMPLE(kWidth, SUBSAMP_X) * PIXEL_STRIDE;          \
+    for (int i = 0; i < kHeight; ++i)                                         \
+      for (int j = 0; j < kWidth; ++j)                                        \
+        src_y[i * kWidth + j + OFF] = (fastrand() & 0xff);                    \
+    for (int i = 0; i < SUBSAMPLE(kHeight, SRC_SUBSAMP_Y); ++i) {             \
+      for (int j = 0; j < SUBSAMPLE(kWidth, SRC_SUBSAMP_X); ++j) {            \
+        src_u[(i * src_stride_uv) + j * PIXEL_STRIDE + OFF] =                 \
+            (fastrand() & 0xff);                                              \
+        src_v[(i * src_stride_uv) + j * PIXEL_STRIDE + OFF] =                 \
+            (fastrand() & 0xff);                                              \
+      }                                                                       \
+    }                                                                         \
+    memset(dst_y_c, 1, kWidth* kHeight);                                      \
+    memset(dst_u_c, 2,                                                        \
+           SUBSAMPLE(kWidth, SUBSAMP_X) * SUBSAMPLE(kHeight, SUBSAMP_Y));     \
+    memset(dst_v_c, 3,                                                        \
+           SUBSAMPLE(kWidth, SUBSAMP_X) * SUBSAMPLE(kHeight, SUBSAMP_Y));     \
+    memset(dst_y_opt, 101, kWidth* kHeight);                                  \
+    memset(dst_u_opt, 102,                                                    \
+           SUBSAMPLE(kWidth, SUBSAMP_X) * SUBSAMPLE(kHeight, SUBSAMP_Y));     \
+    memset(dst_v_opt, 103,                                                    \
+           SUBSAMPLE(kWidth, SUBSAMP_X) * SUBSAMPLE(kHeight, SUBSAMP_Y));     \
+    MaskCpuFlags(disable_cpu_flags_);                                         \
+    SRC_FMT_PLANAR##To##FMT_PLANAR##Rotate(                                   \
+        src_y + OFF, kWidth, src_u + OFF, SUBSAMPLE(kWidth, SRC_SUBSAMP_X),   \
+        src_v + OFF, SUBSAMPLE(kWidth, SRC_SUBSAMP_X), PIXEL_STRIDE, dst_y_c, \
+        kWidth, dst_u_c, SUBSAMPLE(kWidth, SUBSAMP_X), dst_v_c,               \
+        SUBSAMPLE(kWidth, SUBSAMP_X), kWidth, NEG kHeight,                    \
+        (libyuv::RotationMode)ROT);                                           \
+    MaskCpuFlags(benchmark_cpu_info_);                                        \
+    for (int i = 0; i < benchmark_iterations_; ++i) {                         \
+      SRC_FMT_PLANAR##To##FMT_PLANAR##Rotate(                                 \
+          src_y + OFF, kWidth, src_u + OFF, SUBSAMPLE(kWidth, SRC_SUBSAMP_X), \
+          src_v + OFF, SUBSAMPLE(kWidth, SRC_SUBSAMP_X), PIXEL_STRIDE,        \
+          dst_y_opt, kWidth, dst_u_opt, SUBSAMPLE(kWidth, SUBSAMP_X),         \
+          dst_v_opt, SUBSAMPLE(kWidth, SUBSAMP_X), kWidth, NEG kHeight,       \
+          (libyuv::RotationMode)ROT);                                         \
+    }                                                                         \
+    for (int i = 0; i < kHeight; ++i) {                                       \
+      for (int j = 0; j < kWidth; ++j) {                                      \
+        EXPECT_EQ(dst_y_c[i * kWidth + j], dst_y_opt[i * kWidth + j]);        \
+      }                                                                       \
+    }                                                                         \
+    for (int i = 0; i < SUBSAMPLE(kHeight, SUBSAMP_Y); ++i) {                 \
+      for (int j = 0; j < SUBSAMPLE(kWidth, SUBSAMP_X); ++j) {                \
+        EXPECT_EQ(dst_u_c[i * SUBSAMPLE(kWidth, SUBSAMP_X) + j],              \
+                  dst_u_opt[i * SUBSAMPLE(kWidth, SUBSAMP_X) + j]);           \
+      }                                                                       \
+    }                                                                         \
+    for (int i = 0; i < SUBSAMPLE(kHeight, SUBSAMP_Y); ++i) {                 \
+      for (int j = 0; j < SUBSAMPLE(kWidth, SUBSAMP_X); ++j) {                \
+        EXPECT_EQ(dst_v_c[i * SUBSAMPLE(kWidth, SUBSAMP_X) + j],              \
+                  dst_v_opt[i * SUBSAMPLE(kWidth, SUBSAMP_X) + j]);           \
+      }                                                                       \
+    }                                                                         \
+    free_aligned_buffer_page_end(dst_y_c);                                    \
+    free_aligned_buffer_page_end(dst_u_c);                                    \
+    free_aligned_buffer_page_end(dst_v_c);                                    \
+    free_aligned_buffer_page_end(dst_y_opt);                                  \
+    free_aligned_buffer_page_end(dst_u_opt);                                  \
+    free_aligned_buffer_page_end(dst_v_opt);                                  \
+    free_aligned_buffer_page_end(src_y);                                      \
+    free_aligned_buffer_page_end(src_uv);                                     \
+  }
+
+#define TESTAPLANARTOP(SRC_FMT_PLANAR, PN, PIXEL_STRIDE, OFF_U, OFF_V,         \
+                       SRC_SUBSAMP_X, SRC_SUBSAMP_Y, FMT_PLANAR, SUBSAMP_X,    \
+                       SUBSAMP_Y)                                              \
+  TESTAPLANARTOPI(SRC_FMT_PLANAR, PIXEL_STRIDE, SRC_SUBSAMP_X, SRC_SUBSAMP_Y,  \
+                  FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, benchmark_width_ + 1,      \
+                  _Any, +, 0, PN, OFF_U, OFF_V, 0)                             \
+  TESTAPLANARTOPI(SRC_FMT_PLANAR, PIXEL_STRIDE, SRC_SUBSAMP_X, SRC_SUBSAMP_Y,  \
+                  FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, benchmark_width_,          \
+                  _Unaligned, +, 2, PN, OFF_U, OFF_V, 0)                       \
+  TESTAPLANARTOPI(SRC_FMT_PLANAR, PIXEL_STRIDE, SRC_SUBSAMP_X, SRC_SUBSAMP_Y,  \
+                  FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, benchmark_width_, _Invert, \
+                  -, 0, PN, OFF_U, OFF_V, 0)                                   \
+  TESTAPLANARTOPI(SRC_FMT_PLANAR, PIXEL_STRIDE, SRC_SUBSAMP_X, SRC_SUBSAMP_Y,  \
+                  FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, benchmark_width_, _Opt, +, \
+                  0, PN, OFF_U, OFF_V, 0)                                      \
+  TESTAPLANARTOPI(SRC_FMT_PLANAR, PIXEL_STRIDE, SRC_SUBSAMP_X, SRC_SUBSAMP_Y,  \
+                  FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, benchmark_width_, _Opt, +, \
+                  0, PN, OFF_U, OFF_V, 180)
+
+TESTAPLANARTOP(Android420, I420, 1, 0, 0, 2, 2, I420, 2, 2)
+TESTAPLANARTOP(Android420, NV12, 2, 0, 1, 2, 2, I420, 2, 2)
+TESTAPLANARTOP(Android420, NV21, 2, 1, 0, 2, 2, I420, 2, 2)
+#undef TESTAPLANARTOP
+#undef TESTAPLANARTOPI
+
+}  // namespace libyuv
diff --git a/3rdparty/libyuv/src/unit_test/scale_argb_test.cc b/3rdparty/libyuv/src/unit_test/scale_argb_test.cc
new file mode 100644
index 00000000..9bd61414
--- /dev/null
+++ b/3rdparty/libyuv/src/unit_test/scale_argb_test.cc
@@ -0,0 +1,588 @@
+/*
+ *  Copyright 2011 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include <stdlib.h>
+#include <time.h>
+
+#include "../unit_test/unit_test.h"
+#include "libyuv/convert_argb.h"
+#include "libyuv/cpu_id.h"
+#include "libyuv/scale_argb.h"
+#include "libyuv/video_common.h"
+
+namespace libyuv {
+
+#define STRINGIZE(line) #line
+#define FILELINESTR(file, line) file ":" STRINGIZE(line)
+
+#if !defined(DISABLE_SLOW_TESTS) || defined(__x86_64__) || defined(__i386__)
+// SLOW TESTS are those that are unoptimized C code.
+// FULL TESTS are optimized but test many variations of the same code.
+#define ENABLE_FULL_TESTS
+#endif
+
+// Test scaling with C vs Opt and return maximum pixel difference. 0 = exact.
+static int ARGBTestFilter(int src_width,
+                          int src_height,
+                          int dst_width,
+                          int dst_height,
+                          FilterMode f,
+                          int benchmark_iterations,
+                          int disable_cpu_flags,
+                          int benchmark_cpu_info) {
+  if (!SizeValid(src_width, src_height, dst_width, dst_height)) {
+    return 0;
+  }
+
+  int i, j;
+  const int b = 0;  // 128 to test for padding/stride.
+  int64_t src_argb_plane_size =
+      (Abs(src_width) + b * 2) * (Abs(src_height) + b * 2) * 4LL;
+  int src_stride_argb = (b * 2 + Abs(src_width)) * 4;
+
+  align_buffer_page_end(src_argb, src_argb_plane_size);
+  if (!src_argb) {
+    printf("Skipped.  Alloc failed " FILELINESTR(__FILE__, __LINE__) "\n");
+    return 0;
+  }
+  MemRandomize(src_argb, src_argb_plane_size);
+
+  int64_t dst_argb_plane_size =
+      (dst_width + b * 2) * (dst_height + b * 2) * 4LL;
+  int dst_stride_argb = (b * 2 + dst_width) * 4;
+
+  align_buffer_page_end(dst_argb_c, dst_argb_plane_size);
+  align_buffer_page_end(dst_argb_opt, dst_argb_plane_size);
+  if (!dst_argb_c || !dst_argb_opt) {
+    printf("Skipped.  Alloc failed " FILELINESTR(__FILE__, __LINE__) "\n");
+    return 0;
+  }
+  memset(dst_argb_c, 2, dst_argb_plane_size);
+  memset(dst_argb_opt, 3, dst_argb_plane_size);
+
+  // Warm up both versions for consistent benchmarks.
+  MaskCpuFlags(disable_cpu_flags);  // Disable all CPU optimization.
+  ARGBScale(src_argb + (src_stride_argb * b) + b * 4, src_stride_argb,
+            src_width, src_height, dst_argb_c + (dst_stride_argb * b) + b * 4,
+            dst_stride_argb, dst_width, dst_height, f);
+  MaskCpuFlags(benchmark_cpu_info);  // Enable all CPU optimization.
+  ARGBScale(src_argb + (src_stride_argb * b) + b * 4, src_stride_argb,
+            src_width, src_height, dst_argb_opt + (dst_stride_argb * b) + b * 4,
+            dst_stride_argb, dst_width, dst_height, f);
+
+  MaskCpuFlags(disable_cpu_flags);  // Disable all CPU optimization.
+  double c_time = get_time();
+  ARGBScale(src_argb + (src_stride_argb * b) + b * 4, src_stride_argb,
+            src_width, src_height, dst_argb_c + (dst_stride_argb * b) + b * 4,
+            dst_stride_argb, dst_width, dst_height, f);
+
+  c_time = (get_time() - c_time);
+
+  MaskCpuFlags(benchmark_cpu_info);  // Enable all CPU optimization.
+  double opt_time = get_time();
+  for (i = 0; i < benchmark_iterations; ++i) {
+    ARGBScale(src_argb + (src_stride_argb * b) + b * 4, src_stride_argb,
+              src_width, src_height,
+              dst_argb_opt + (dst_stride_argb * b) + b * 4, dst_stride_argb,
+              dst_width, dst_height, f);
+  }
+  opt_time = (get_time() - opt_time) / benchmark_iterations;
+
+  // Report performance of C vs OPT
+  printf("filter %d - %8d us C - %8d us OPT\n", f,
+         static_cast<int>(c_time * 1e6), static_cast<int>(opt_time * 1e6));
+
+  // C version may be a little off from the optimized. Order of
+  //  operations may introduce rounding somewhere. So do a difference
+  //  of the buffers and look to see that the max difference isn't
+  //  over 2.
+  int max_diff = 0;
+  for (i = b; i < (dst_height + b); ++i) {
+    for (j = b * 4; j < (dst_width + b) * 4; ++j) {
+      int abs_diff = Abs(dst_argb_c[(i * dst_stride_argb) + j] -
+                         dst_argb_opt[(i * dst_stride_argb) + j]);
+      if (abs_diff > max_diff) {
+        max_diff = abs_diff;
+      }
+    }
+  }
+
+  free_aligned_buffer_page_end(dst_argb_c);
+  free_aligned_buffer_page_end(dst_argb_opt);
+  free_aligned_buffer_page_end(src_argb);
+  return max_diff;
+}
+
+static const int kTileX = 64;
+static const int kTileY = 64;
+
+static int TileARGBScale(const uint8_t* src_argb,
+                         int src_stride_argb,
+                         int src_width,
+                         int src_height,
+                         uint8_t* dst_argb,
+                         int dst_stride_argb,
+                         int dst_width,
+                         int dst_height,
+                         FilterMode filtering) {
+  for (int y = 0; y < dst_height; y += kTileY) {
+    for (int x = 0; x < dst_width; x += kTileX) {
+      int clip_width = kTileX;
+      if (x + clip_width > dst_width) {
+        clip_width = dst_width - x;
+      }
+      int clip_height = kTileY;
+      if (y + clip_height > dst_height) {
+        clip_height = dst_height - y;
+      }
+      int r = ARGBScaleClip(src_argb, src_stride_argb, src_width, src_height,
+                            dst_argb, dst_stride_argb, dst_width, dst_height, x,
+                            y, clip_width, clip_height, filtering);
+      if (r) {
+        return r;
+      }
+    }
+  }
+  return 0;
+}
+
+static int ARGBClipTestFilter(int src_width,
+                              int src_height,
+                              int dst_width,
+                              int dst_height,
+                              FilterMode f,
+                              int benchmark_iterations) {
+  if (!SizeValid(src_width, src_height, dst_width, dst_height)) {
+    return 0;
+  }
+
+  const int b = 128;
+  int64_t src_argb_plane_size =
+      (Abs(src_width) + b * 2) * (Abs(src_height) + b * 2) * 4;
+  int src_stride_argb = (b * 2 + Abs(src_width)) * 4;
+
+  align_buffer_page_end(src_argb, src_argb_plane_size);
+  if (!src_argb) {
+    printf("Skipped.  Alloc failed " FILELINESTR(__FILE__, __LINE__) "\n");
+    return 0;
+  }
+  memset(src_argb, 1, src_argb_plane_size);
+
+  int64_t dst_argb_plane_size = (dst_width + b * 2) * (dst_height + b * 2) * 4;
+  int dst_stride_argb = (b * 2 + dst_width) * 4;
+
+  int i, j;
+  for (i = b; i < (Abs(src_height) + b); ++i) {
+    for (j = b; j < (Abs(src_width) + b) * 4; ++j) {
+      src_argb[(i * src_stride_argb) + j] = (fastrand() & 0xff);
+    }
+  }
+
+  align_buffer_page_end(dst_argb_c, dst_argb_plane_size);
+  align_buffer_page_end(dst_argb_opt, dst_argb_plane_size);
+  if (!dst_argb_c || !dst_argb_opt) {
+    printf("Skipped.  Alloc failed " FILELINESTR(__FILE__, __LINE__) "\n");
+    return 0;
+  }
+  memset(dst_argb_c, 2, dst_argb_plane_size);
+  memset(dst_argb_opt, 3, dst_argb_plane_size);
+
+  // Do full image, no clipping.
+  double c_time = get_time();
+  ARGBScale(src_argb + (src_stride_argb * b) + b * 4, src_stride_argb,
+            src_width, src_height, dst_argb_c + (dst_stride_argb * b) + b * 4,
+            dst_stride_argb, dst_width, dst_height, f);
+  c_time = (get_time() - c_time);
+
+  // Do tiled image, clipping scale to a tile at a time.
+  double opt_time = get_time();
+  for (i = 0; i < benchmark_iterations; ++i) {
+    TileARGBScale(src_argb + (src_stride_argb * b) + b * 4, src_stride_argb,
+                  src_width, src_height,
+                  dst_argb_opt + (dst_stride_argb * b) + b * 4, dst_stride_argb,
+                  dst_width, dst_height, f);
+  }
+  opt_time = (get_time() - opt_time) / benchmark_iterations;
+
+  // Report performance of Full vs Tiled.
+  printf("filter %d - %8d us Full - %8d us Tiled\n", f,
+         static_cast<int>(c_time * 1e6), static_cast<int>(opt_time * 1e6));
+
+  // Compare full scaled image vs tiled image.
+  int max_diff = 0;
+  for (i = b; i < (dst_height + b); ++i) {
+    for (j = b * 4; j < (dst_width + b) * 4; ++j) {
+      int abs_diff = Abs(dst_argb_c[(i * dst_stride_argb) + j] -
+                         dst_argb_opt[(i * dst_stride_argb) + j]);
+      if (abs_diff > max_diff) {
+        max_diff = abs_diff;
+      }
+    }
+  }
+
+  free_aligned_buffer_page_end(dst_argb_c);
+  free_aligned_buffer_page_end(dst_argb_opt);
+  free_aligned_buffer_page_end(src_argb);
+  return max_diff;
+}
+
+// The following adjustments in dimensions ensure the scale factor will be
+// exactly achieved.
+#define DX(x, nom, denom) static_cast<int>((Abs(x) / nom) * nom)
+#define SX(x, nom, denom) static_cast<int>((x / nom) * denom)
+
+#define TEST_FACTOR1(DISABLED_, name, filter, nom, denom, max_diff)          \
+  TEST_F(LibYUVScaleTest, ARGBScaleDownBy##name##_##filter) {                \
+    int diff = ARGBTestFilter(                                               \
+        SX(benchmark_width_, nom, denom), SX(benchmark_height_, nom, denom), \
+        DX(benchmark_width_, nom, denom), DX(benchmark_height_, nom, denom), \
+        kFilter##filter, benchmark_iterations_, disable_cpu_flags_,          \
+        benchmark_cpu_info_);                                                \
+    EXPECT_LE(diff, max_diff);                                               \
+  }                                                                          \
+  TEST_F(LibYUVScaleTest, DISABLED_##ARGBScaleDownClipBy##name##_##filter) { \
+    int diff = ARGBClipTestFilter(                                           \
+        SX(benchmark_width_, nom, denom), SX(benchmark_height_, nom, denom), \
+        DX(benchmark_width_, nom, denom), DX(benchmark_height_, nom, denom), \
+        kFilter##filter, benchmark_iterations_);                             \
+    EXPECT_LE(diff, max_diff);                                               \
+  }
+
+// Test a scale factor with all 4 filters.  Expect unfiltered to be exact, but
+// filtering is different fixed point implementations for SSSE3, Neon and C.
+#ifndef DISABLE_SLOW_TESTS
+#define TEST_FACTOR(name, nom, denom)           \
+  TEST_FACTOR1(, name, None, nom, denom, 0)     \
+  TEST_FACTOR1(, name, Linear, nom, denom, 3)   \
+  TEST_FACTOR1(, name, Bilinear, nom, denom, 3) \
+  TEST_FACTOR1(, name, Box, nom, denom, 3)
+#else
+#if defined(ENABLE_FULL_TESTS)
+#define TEST_FACTOR(name, nom, denom)                    \
+  TEST_FACTOR1(DISABLED_, name, None, nom, denom, 0)     \
+  TEST_FACTOR1(DISABLED_, name, Linear, nom, denom, 3)   \
+  TEST_FACTOR1(DISABLED_, name, Bilinear, nom, denom, 3) \
+  TEST_FACTOR1(DISABLED_, name, Box, nom, denom, 3)
+#else
+#define TEST_FACTOR(name, nom, denom) \
+  TEST_FACTOR1(DISABLED_, name, Bilinear, nom, denom, 3)
+#endif
+#endif
+
+TEST_FACTOR(2, 1, 2)
+TEST_FACTOR(4, 1, 4)
+#ifndef DISABLE_SLOW_TESTS
+TEST_FACTOR(8, 1, 8)
+#endif
+TEST_FACTOR(3by4, 3, 4)
+TEST_FACTOR(3by8, 3, 8)
+TEST_FACTOR(3, 1, 3)
+#undef TEST_FACTOR1
+#undef TEST_FACTOR
+#undef SX
+#undef DX
+
+#define TEST_SCALETO1(DISABLED_, name, width, height, filter, max_diff)        \
+  TEST_F(LibYUVScaleTest, name##To##width##x##height##_##filter) {             \
+    int diff = ARGBTestFilter(benchmark_width_, benchmark_height_, width,      \
+                              height, kFilter##filter, benchmark_iterations_,  \
+                              disable_cpu_flags_, benchmark_cpu_info_);        \
+    EXPECT_LE(diff, max_diff);                                                 \
+  }                                                                            \
+  TEST_F(LibYUVScaleTest, name##From##width##x##height##_##filter) {           \
+    int diff = ARGBTestFilter(width, height, Abs(benchmark_width_),            \
+                              Abs(benchmark_height_), kFilter##filter,         \
+                              benchmark_iterations_, disable_cpu_flags_,       \
+                              benchmark_cpu_info_);                            \
+    EXPECT_LE(diff, max_diff);                                                 \
+  }                                                                            \
+  TEST_F(LibYUVScaleTest,                                                      \
+         DISABLED_##name##ClipTo##width##x##height##_##filter) {               \
+    int diff =                                                                 \
+        ARGBClipTestFilter(benchmark_width_, benchmark_height_, width, height, \
+                           kFilter##filter, benchmark_iterations_);            \
+    EXPECT_LE(diff, max_diff);                                                 \
+  }                                                                            \
+  TEST_F(LibYUVScaleTest,                                                      \
+         DISABLED_##name##ClipFrom##width##x##height##_##filter) {             \
+    int diff = ARGBClipTestFilter(width, height, Abs(benchmark_width_),        \
+                                  Abs(benchmark_height_), kFilter##filter,     \
+                                  benchmark_iterations_);                      \
+    EXPECT_LE(diff, max_diff);                                                 \
+  }
+
+#ifndef DISABLE_SLOW_TESTS
+// Test scale to a specified size with all 4 filters.
+#define TEST_SCALETO(name, width, height)         \
+  TEST_SCALETO1(, name, width, height, None, 0)   \
+  TEST_SCALETO1(, name, width, height, Linear, 3) \
+  TEST_SCALETO1(, name, width, height, Bilinear, 3)
+#else
+#if defined(ENABLE_FULL_TESTS)
+#define TEST_SCALETO(name, width, height)                  \
+  TEST_SCALETO1(DISABLED_, name, width, height, None, 0)   \
+  TEST_SCALETO1(DISABLED_, name, width, height, Linear, 3) \
+  TEST_SCALETO1(DISABLED_, name, width, height, Bilinear, 3)
+#else
+#define TEST_SCALETO(name, width, height) \
+  TEST_SCALETO1(DISABLED_, name, width, height, Bilinear, 3)
+#endif
+#endif
+
+TEST_SCALETO(ARGBScale, 1, 1)
+// TEST_SCALETO(ARGBScale, 256, 144) /* 128x72 * 2 */
+TEST_SCALETO(ARGBScale, 320, 240)
+TEST_SCALETO(ARGBScale, 569, 480)
+TEST_SCALETO(ARGBScale, 640, 360)
+#ifndef DISABLE_SLOW_TESTS
+TEST_SCALETO(ARGBScale, 1280, 720)
+TEST_SCALETO(ARGBScale, 1920, 1080)
+#endif  // DISABLE_SLOW_TESTS
+#undef TEST_SCALETO1
+#undef TEST_SCALETO
+
+#define TEST_SCALESWAPXY1(name, filter, max_diff)                       \
+  TEST_F(LibYUVScaleTest, name##SwapXY_##filter) {                      \
+    int diff = ARGBTestFilter(benchmark_width_, benchmark_height_,      \
+                              benchmark_height_, benchmark_width_,      \
+                              kFilter##filter, benchmark_iterations_,   \
+                              disable_cpu_flags_, benchmark_cpu_info_); \
+    EXPECT_LE(diff, max_diff);                                          \
+  }
+
+#if defined(ENABLE_FULL_TESTS)
+// Test scale with swapped width and height with all 3 filters.
+TEST_SCALESWAPXY1(ARGBScale, None, 0)
+TEST_SCALESWAPXY1(ARGBScale, Linear, 0)
+TEST_SCALESWAPXY1(ARGBScale, Bilinear, 0)
+#else
+TEST_SCALESWAPXY1(ARGBScale, Bilinear, 0)
+#endif
+#undef TEST_SCALESWAPXY1
+
+// Scale with YUV conversion to ARGB and clipping.
+// TODO(fbarchard): Add fourcc support.  All 4 ARGB formats is easy to support.
+LIBYUV_API
+int YUVToARGBScaleReference2(const uint8_t* src_y,
+                             int src_stride_y,
+                             const uint8_t* src_u,
+                             int src_stride_u,
+                             const uint8_t* src_v,
+                             int src_stride_v,
+                             uint32_t /* src_fourcc */,
+                             int src_width,
+                             int src_height,
+                             uint8_t* dst_argb,
+                             int dst_stride_argb,
+                             uint32_t /* dst_fourcc */,
+                             int dst_width,
+                             int dst_height,
+                             int clip_x,
+                             int clip_y,
+                             int clip_width,
+                             int clip_height,
+                             enum FilterMode filtering) {
+  uint8_t* argb_buffer =
+      static_cast<uint8_t*>(malloc(src_width * src_height * 4));
+  int r;
+  I420ToARGB(src_y, src_stride_y, src_u, src_stride_u, src_v, src_stride_v,
+             argb_buffer, src_width * 4, src_width, src_height);
+
+  r = ARGBScaleClip(argb_buffer, src_width * 4, src_width, src_height, dst_argb,
+                    dst_stride_argb, dst_width, dst_height, clip_x, clip_y,
+                    clip_width, clip_height, filtering);
+  free(argb_buffer);
+  return r;
+}
+
+static void FillRamp(uint8_t* buf,
+                     int width,
+                     int height,
+                     int v,
+                     int dx,
+                     int dy) {
+  int rv = v;
+  for (int y = 0; y < height; ++y) {
+    for (int x = 0; x < width; ++x) {
+      *buf++ = v;
+      v += dx;
+      if (v < 0 || v > 255) {
+        dx = -dx;
+        v += dx;
+      }
+    }
+    v = rv + dy;
+    if (v < 0 || v > 255) {
+      dy = -dy;
+      v += dy;
+    }
+    rv = v;
+  }
+}
+
+// Test scaling with C vs Opt and return maximum pixel difference. 0 = exact.
+static int YUVToARGBTestFilter(int src_width,
+                               int src_height,
+                               int dst_width,
+                               int dst_height,
+                               FilterMode f,
+                               int benchmark_iterations) {
+  int64_t src_y_plane_size = Abs(src_width) * Abs(src_height);
+  int64_t src_uv_plane_size =
+      ((Abs(src_width) + 1) / 2) * ((Abs(src_height) + 1) / 2);
+  int src_stride_y = Abs(src_width);
+  int src_stride_uv = (Abs(src_width) + 1) / 2;
+
+  align_buffer_page_end(src_y, src_y_plane_size);
+  align_buffer_page_end(src_u, src_uv_plane_size);
+  align_buffer_page_end(src_v, src_uv_plane_size);
+
+  int64_t dst_argb_plane_size = (dst_width) * (dst_height)*4LL;
+  int dst_stride_argb = (dst_width)*4;
+  align_buffer_page_end(dst_argb_c, dst_argb_plane_size);
+  align_buffer_page_end(dst_argb_opt, dst_argb_plane_size);
+  if (!dst_argb_c || !dst_argb_opt || !src_y || !src_u || !src_v) {
+    printf("Skipped.  Alloc failed " FILELINESTR(__FILE__, __LINE__) "\n");
+    return 0;
+  }
+  // Fill YUV image with continuous ramp, which is less sensitive to
+  // subsampling and filtering differences for test purposes.
+  FillRamp(src_y, Abs(src_width), Abs(src_height), 128, 1, 1);
+  FillRamp(src_u, (Abs(src_width) + 1) / 2, (Abs(src_height) + 1) / 2, 3, 1, 1);
+  FillRamp(src_v, (Abs(src_width) + 1) / 2, (Abs(src_height) + 1) / 2, 4, 1, 1);
+  memset(dst_argb_c, 2, dst_argb_plane_size);
+  memset(dst_argb_opt, 3, dst_argb_plane_size);
+
+  YUVToARGBScaleReference2(src_y, src_stride_y, src_u, src_stride_uv, src_v,
+                           src_stride_uv, libyuv::FOURCC_I420, src_width,
+                           src_height, dst_argb_c, dst_stride_argb,
+                           libyuv::FOURCC_I420, dst_width, dst_height, 0, 0,
+                           dst_width, dst_height, f);
+
+  for (int i = 0; i < benchmark_iterations; ++i) {
+    YUVToARGBScaleClip(src_y, src_stride_y, src_u, src_stride_uv, src_v,
+                       src_stride_uv, libyuv::FOURCC_I420, src_width,
+                       src_height, dst_argb_opt, dst_stride_argb,
+                       libyuv::FOURCC_I420, dst_width, dst_height, 0, 0,
+                       dst_width, dst_height, f);
+  }
+  int max_diff = 0;
+  for (int i = 0; i < dst_height; ++i) {
+    for (int j = 0; j < dst_width * 4; ++j) {
+      int abs_diff = Abs(dst_argb_c[(i * dst_stride_argb) + j] -
+                         dst_argb_opt[(i * dst_stride_argb) + j]);
+      if (abs_diff > max_diff) {
+        printf("error %d at %d,%d c %d opt %d", abs_diff, j, i,
+               dst_argb_c[(i * dst_stride_argb) + j],
+               dst_argb_opt[(i * dst_stride_argb) + j]);
+        EXPECT_LE(abs_diff, 40);
+        max_diff = abs_diff;
+      }
+    }
+  }
+
+  free_aligned_buffer_page_end(dst_argb_c);
+  free_aligned_buffer_page_end(dst_argb_opt);
+  free_aligned_buffer_page_end(src_y);
+  free_aligned_buffer_page_end(src_u);
+  free_aligned_buffer_page_end(src_v);
+  return max_diff;
+}
+
+TEST_F(LibYUVScaleTest, YUVToRGBScaleUp) {
+  int diff =
+      YUVToARGBTestFilter(benchmark_width_, benchmark_height_,
+                          benchmark_width_ * 3 / 2, benchmark_height_ * 3 / 2,
+                          libyuv::kFilterBilinear, benchmark_iterations_);
+  EXPECT_LE(diff, 10);
+}
+
+TEST_F(LibYUVScaleTest, YUVToRGBScaleDown) {
+  int diff = YUVToARGBTestFilter(
+      benchmark_width_ * 3 / 2, benchmark_height_ * 3 / 2, benchmark_width_,
+      benchmark_height_, libyuv::kFilterBilinear, benchmark_iterations_);
+  EXPECT_LE(diff, 10);
+}
+
+TEST_F(LibYUVScaleTest, ARGBTest3x) {
+  const int kSrcStride = 480 * 4;
+  const int kDstStride = 160 * 4;
+  const int kSize = kSrcStride * 3;
+  align_buffer_page_end(orig_pixels, kSize);
+  for (int i = 0; i < 480 * 3; ++i) {
+    orig_pixels[i * 4 + 0] = i;
+    orig_pixels[i * 4 + 1] = 255 - i;
+    orig_pixels[i * 4 + 2] = i + 1;
+    orig_pixels[i * 4 + 3] = i + 10;
+  }
+  align_buffer_page_end(dest_pixels, kDstStride);
+
+  int iterations160 = (benchmark_width_ * benchmark_height_ + (160 - 1)) / 160 *
+                      benchmark_iterations_;
+  for (int i = 0; i < iterations160; ++i) {
+    ARGBScale(orig_pixels, kSrcStride, 480, 3, dest_pixels, kDstStride, 160, 1,
+              kFilterBilinear);
+  }
+
+  EXPECT_EQ(225, dest_pixels[0]);
+  EXPECT_EQ(255 - 225, dest_pixels[1]);
+  EXPECT_EQ(226, dest_pixels[2]);
+  EXPECT_EQ(235, dest_pixels[3]);
+
+  ARGBScale(orig_pixels, kSrcStride, 480, 3, dest_pixels, kDstStride, 160, 1,
+            kFilterNone);
+
+  EXPECT_EQ(225, dest_pixels[0]);
+  EXPECT_EQ(255 - 225, dest_pixels[1]);
+  EXPECT_EQ(226, dest_pixels[2]);
+  EXPECT_EQ(235, dest_pixels[3]);
+
+  free_aligned_buffer_page_end(dest_pixels);
+  free_aligned_buffer_page_end(orig_pixels);
+}
+
+TEST_F(LibYUVScaleTest, ARGBTest4x) {
+  const int kSrcStride = 640 * 4;
+  const int kDstStride = 160 * 4;
+  const int kSize = kSrcStride * 4;
+  align_buffer_page_end(orig_pixels, kSize);
+  for (int i = 0; i < 640 * 4; ++i) {
+    orig_pixels[i * 4 + 0] = i;
+    orig_pixels[i * 4 + 1] = 255 - i;
+    orig_pixels[i * 4 + 2] = i + 1;
+    orig_pixels[i * 4 + 3] = i + 10;
+  }
+  align_buffer_page_end(dest_pixels, kDstStride);
+
+  int iterations160 = (benchmark_width_ * benchmark_height_ + (160 - 1)) / 160 *
+                      benchmark_iterations_;
+  for (int i = 0; i < iterations160; ++i) {
+    ARGBScale(orig_pixels, kSrcStride, 640, 4, dest_pixels, kDstStride, 160, 1,
+              kFilterBilinear);
+  }
+
+  EXPECT_NEAR(66, dest_pixels[0], 4);
+  EXPECT_NEAR(255 - 66, dest_pixels[1], 4);
+  EXPECT_NEAR(67, dest_pixels[2], 4);
+  EXPECT_NEAR(76, dest_pixels[3], 4);
+
+  ARGBScale(orig_pixels, kSrcStride, 640, 4, dest_pixels, kDstStride, 160, 1,
+            kFilterNone);
+
+  EXPECT_EQ(2, dest_pixels[0]);
+  EXPECT_EQ(255 - 2, dest_pixels[1]);
+  EXPECT_EQ(3, dest_pixels[2]);
+  EXPECT_EQ(12, dest_pixels[3]);
+
+  free_aligned_buffer_page_end(dest_pixels);
+  free_aligned_buffer_page_end(orig_pixels);
+}
+
+}  // namespace libyuv
diff --git a/3rdparty/libyuv/src/unit_test/scale_rgb_test.cc b/3rdparty/libyuv/src/unit_test/scale_rgb_test.cc
new file mode 100644
index 00000000..e4703ee7
--- /dev/null
+++ b/3rdparty/libyuv/src/unit_test/scale_rgb_test.cc
@@ -0,0 +1,282 @@
+/*
+ *  Copyright 2022 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include <stdlib.h>
+#include <time.h>
+
+#include "../unit_test/unit_test.h"
+#include "libyuv/cpu_id.h"
+#include "libyuv/scale_rgb.h"
+
+namespace libyuv {
+
+#define STRINGIZE(line) #line
+#define FILELINESTR(file, line) file ":" STRINGIZE(line)
+
+#if !defined(DISABLE_SLOW_TESTS) || defined(__x86_64__) || defined(__i386__)
+// SLOW TESTS are those that are unoptimized C code.
+// FULL TESTS are optimized but test many variations of the same code.
+#define ENABLE_FULL_TESTS
+#endif
+
+// Test scaling with C vs Opt and return maximum pixel difference. 0 = exact.
+static int RGBTestFilter(int src_width,
+                         int src_height,
+                         int dst_width,
+                         int dst_height,
+                         FilterMode f,
+                         int benchmark_iterations,
+                         int disable_cpu_flags,
+                         int benchmark_cpu_info) {
+  if (!SizeValid(src_width, src_height, dst_width, dst_height)) {
+    return 0;
+  }
+
+  int i, j;
+  const int b = 0;  // 128 to test for padding/stride.
+  int64_t src_rgb_plane_size =
+      (Abs(src_width) + b * 3) * (Abs(src_height) + b * 3) * 3LL;
+  int src_stride_rgb = (b * 3 + Abs(src_width)) * 3;
+
+  align_buffer_page_end(src_rgb, src_rgb_plane_size);
+  if (!src_rgb) {
+    printf("Skipped.  Alloc failed " FILELINESTR(__FILE__, __LINE__) "\n");
+    return 0;
+  }
+  MemRandomize(src_rgb, src_rgb_plane_size);
+
+  int64_t dst_rgb_plane_size = (dst_width + b * 3) * (dst_height + b * 3) * 3LL;
+  int dst_stride_rgb = (b * 3 + dst_width) * 3;
+
+  align_buffer_page_end(dst_rgb_c, dst_rgb_plane_size);
+  align_buffer_page_end(dst_rgb_opt, dst_rgb_plane_size);
+  if (!dst_rgb_c || !dst_rgb_opt) {
+    printf("Skipped.  Alloc failed " FILELINESTR(__FILE__, __LINE__) "\n");
+    return 0;
+  }
+  memset(dst_rgb_c, 2, dst_rgb_plane_size);
+  memset(dst_rgb_opt, 3, dst_rgb_plane_size);
+
+  // Warm up both versions for consistent benchmarks.
+  MaskCpuFlags(disable_cpu_flags);  // Disable all CPU optimization.
+  RGBScale(src_rgb + (src_stride_rgb * b) + b * 3, src_stride_rgb, src_width,
+           src_height, dst_rgb_c + (dst_stride_rgb * b) + b * 3, dst_stride_rgb,
+           dst_width, dst_height, f);
+  MaskCpuFlags(benchmark_cpu_info);  // Enable all CPU optimization.
+  RGBScale(src_rgb + (src_stride_rgb * b) + b * 3, src_stride_rgb, src_width,
+           src_height, dst_rgb_opt + (dst_stride_rgb * b) + b * 3,
+           dst_stride_rgb, dst_width, dst_height, f);
+
+  MaskCpuFlags(disable_cpu_flags);  // Disable all CPU optimization.
+  double c_time = get_time();
+  RGBScale(src_rgb + (src_stride_rgb * b) + b * 3, src_stride_rgb, src_width,
+           src_height, dst_rgb_c + (dst_stride_rgb * b) + b * 3, dst_stride_rgb,
+           dst_width, dst_height, f);
+
+  c_time = (get_time() - c_time);
+
+  MaskCpuFlags(benchmark_cpu_info);  // Enable all CPU optimization.
+  double opt_time = get_time();
+  for (i = 0; i < benchmark_iterations; ++i) {
+    RGBScale(src_rgb + (src_stride_rgb * b) + b * 3, src_stride_rgb, src_width,
+             src_height, dst_rgb_opt + (dst_stride_rgb * b) + b * 3,
+             dst_stride_rgb, dst_width, dst_height, f);
+  }
+  opt_time = (get_time() - opt_time) / benchmark_iterations;
+
+  // Report performance of C vs OPT
+  printf("filter %d - %8d us C - %8d us OPT\n", f,
+         static_cast<int>(c_time * 1e6), static_cast<int>(opt_time * 1e6));
+
+  // C version may be a little off from the optimized. Order of
+  //  operations may introduce rounding somewhere. So do a difference
+  //  of the buffers and look to see that the max difference isn't
+  //  over 2.
+  int max_diff = 0;
+  for (i = b; i < (dst_height + b); ++i) {
+    for (j = b * 3; j < (dst_width + b) * 3; ++j) {
+      int abs_diff = Abs(dst_rgb_c[(i * dst_stride_rgb) + j] -
+                         dst_rgb_opt[(i * dst_stride_rgb) + j]);
+      if (abs_diff > max_diff) {
+        max_diff = abs_diff;
+      }
+    }
+  }
+
+  free_aligned_buffer_page_end(dst_rgb_c);
+  free_aligned_buffer_page_end(dst_rgb_opt);
+  free_aligned_buffer_page_end(src_rgb);
+  return max_diff;
+}
+
+// The following adjustments in dimensions ensure the scale factor will be
+// exactly achieved.
+#define DX(x, nom, denom) static_cast<int>((Abs(x) / nom) * nom)
+#define SX(x, nom, denom) static_cast<int>((x / nom) * denom)
+
+#define TEST_FACTOR1(name, filter, nom, denom, max_diff)                     \
+  TEST_F(LibYUVScaleTest, RGBScaleDownBy##name##_##filter) {                 \
+    int diff = RGBTestFilter(                                                \
+        SX(benchmark_width_, nom, denom), SX(benchmark_height_, nom, denom), \
+        DX(benchmark_width_, nom, denom), DX(benchmark_height_, nom, denom), \
+        kFilter##filter, benchmark_iterations_, disable_cpu_flags_,          \
+        benchmark_cpu_info_);                                                \
+    EXPECT_LE(diff, max_diff);                                               \
+  }
+
+#if defined(ENABLE_FULL_TESTS)
+// Test a scale factor with all 4 filters.  Expect unfiltered to be exact, but
+// filtering is different fixed point implementations for SSSE3, Neon and C.
+#define TEST_FACTOR(name, nom, denom)         \
+  TEST_FACTOR1(name, None, nom, denom, 0)     \
+  TEST_FACTOR1(name, Linear, nom, denom, 3)   \
+  TEST_FACTOR1(name, Bilinear, nom, denom, 3) \
+  TEST_FACTOR1(name, Box, nom, denom, 3)
+#else
+// Test a scale factor with Bilinear.
+#define TEST_FACTOR(name, nom, denom) \
+  TEST_FACTOR1(name, Bilinear, nom, denom, 3)
+#endif
+
+TEST_FACTOR(2, 1, 2)
+#ifndef DISABLE_SLOW_TESTS
+TEST_FACTOR(4, 1, 4)
+// TEST_FACTOR(8, 1, 8)  Disable for benchmark performance.
+TEST_FACTOR(3by4, 3, 4)
+TEST_FACTOR(3by8, 3, 8)
+TEST_FACTOR(3, 1, 3)
+#endif
+#undef TEST_FACTOR1
+#undef TEST_FACTOR
+#undef SX
+#undef DX
+
+#define TEST_SCALETO1(name, width, height, filter, max_diff)                 \
+  TEST_F(LibYUVScaleTest, name##To##width##x##height##_##filter) {           \
+    int diff = RGBTestFilter(benchmark_width_, benchmark_height_, width,     \
+                             height, kFilter##filter, benchmark_iterations_, \
+                             disable_cpu_flags_, benchmark_cpu_info_);       \
+    EXPECT_LE(diff, max_diff);                                               \
+  }                                                                          \
+  TEST_F(LibYUVScaleTest, name##From##width##x##height##_##filter) {         \
+    int diff = RGBTestFilter(width, height, Abs(benchmark_width_),           \
+                             Abs(benchmark_height_), kFilter##filter,        \
+                             benchmark_iterations_, disable_cpu_flags_,      \
+                             benchmark_cpu_info_);                           \
+    EXPECT_LE(diff, max_diff);                                               \
+  }
+
+#if defined(ENABLE_FULL_TESTS)
+/// Test scale to a specified size with all 4 filters.
+#define TEST_SCALETO(name, width, height)       \
+  TEST_SCALETO1(name, width, height, None, 0)   \
+  TEST_SCALETO1(name, width, height, Linear, 3) \
+  TEST_SCALETO1(name, width, height, Bilinear, 3)
+#else
+#define TEST_SCALETO(name, width, height) \
+  TEST_SCALETO1(name, width, height, Bilinear, 3)
+#endif
+
+#ifndef DISABLE_SLOW_TESTS
+TEST_SCALETO(RGBScale, 1, 1)
+#endif
+// TEST_SCALETO(RGBScale, 256, 144) /* 128x72 * 3 */
+TEST_SCALETO(RGBScale, 320, 240)
+#ifndef DISABLE_SLOW_TESTS
+TEST_SCALETO(RGBScale, 569, 480)
+TEST_SCALETO(RGBScale, 640, 360)
+TEST_SCALETO(RGBScale, 1280, 720)
+TEST_SCALETO(RGBScale, 1920, 1080)
+#endif  // DISABLE_SLOW_TESTS
+#undef TEST_SCALETO1
+#undef TEST_SCALETO
+
+#define TEST_SCALESWAPXY1(name, filter, max_diff)                      \
+  TEST_F(LibYUVScaleTest, name##SwapXY_##filter) {                     \
+    int diff = RGBTestFilter(benchmark_width_, benchmark_height_,      \
+                             benchmark_height_, benchmark_width_,      \
+                             kFilter##filter, benchmark_iterations_,   \
+                             disable_cpu_flags_, benchmark_cpu_info_); \
+    EXPECT_LE(diff, max_diff);                                         \
+  }
+
+#if defined(ENABLE_FULL_TESTS)
+// Test scale with swapped width and height with all 3 filters.
+TEST_SCALESWAPXY1(RGBScale, None, 0)
+TEST_SCALESWAPXY1(RGBScale, Linear, 0)
+TEST_SCALESWAPXY1(RGBScale, Bilinear, 0)
+#else
+TEST_SCALESWAPXY1(RGBScale, Bilinear, 0)
+#endif
+#undef TEST_SCALESWAPXY1
+
+TEST_F(LibYUVScaleTest, RGBTest3x) {
+  const int kSrcStride = 480 * 3;
+  const int kDstStride = 160 * 3;
+  const int kSize = kSrcStride * 3;
+  align_buffer_page_end(orig_pixels, kSize);
+  for (int i = 0; i < 480 * 3; ++i) {
+    orig_pixels[i * 3 + 0] = i;
+    orig_pixels[i * 3 + 1] = 255 - i;
+  }
+  align_buffer_page_end(dest_pixels, kDstStride);
+
+  int iterations160 = (benchmark_width_ * benchmark_height_ + (160 - 1)) / 160 *
+                      benchmark_iterations_;
+  for (int i = 0; i < iterations160; ++i) {
+    RGBScale(orig_pixels, kSrcStride, 480, 3, dest_pixels, kDstStride, 160, 1,
+             kFilterBilinear);
+  }
+
+  EXPECT_EQ(225, dest_pixels[0]);
+  EXPECT_EQ(255 - 225, dest_pixels[1]);
+
+  RGBScale(orig_pixels, kSrcStride, 480, 3, dest_pixels, kDstStride, 160, 1,
+           kFilterNone);
+
+  EXPECT_EQ(225, dest_pixels[0]);
+  EXPECT_EQ(255 - 225, dest_pixels[1]);
+
+  free_aligned_buffer_page_end(dest_pixels);
+  free_aligned_buffer_page_end(orig_pixels);
+}
+
+TEST_F(LibYUVScaleTest, RGBTest4x) {
+  const int kSrcStride = 640 * 3;
+  const int kDstStride = 160 * 3;
+  const int kSize = kSrcStride * 4;
+  align_buffer_page_end(orig_pixels, kSize);
+  for (int i = 0; i < 640 * 4; ++i) {
+    orig_pixels[i * 3 + 0] = i;
+    orig_pixels[i * 3 + 1] = 255 - i;
+  }
+  align_buffer_page_end(dest_pixels, kDstStride);
+
+  int iterations160 = (benchmark_width_ * benchmark_height_ + (160 - 1)) / 160 *
+                      benchmark_iterations_;
+  for (int i = 0; i < iterations160; ++i) {
+    RGBScale(orig_pixels, kSrcStride, 640, 4, dest_pixels, kDstStride, 160, 1,
+             kFilterBilinear);
+  }
+
+  EXPECT_EQ(66, dest_pixels[0]);
+  EXPECT_EQ(190, dest_pixels[1]);
+
+  RGBScale(orig_pixels, kSrcStride, 64, 4, dest_pixels, kDstStride, 16, 1,
+           kFilterNone);
+
+  EXPECT_EQ(2, dest_pixels[0]);  // expect the 3rd pixel of the 3rd row
+  EXPECT_EQ(255 - 2, dest_pixels[1]);
+
+  free_aligned_buffer_page_end(dest_pixels);
+  free_aligned_buffer_page_end(orig_pixels);
+}
+
+}  // namespace libyuv
diff --git a/3rdparty/libyuv/src/unit_test/scale_test.cc b/3rdparty/libyuv/src/unit_test/scale_test.cc
new file mode 100644
index 00000000..81c839f4
--- /dev/null
+++ b/3rdparty/libyuv/src/unit_test/scale_test.cc
@@ -0,0 +1,1601 @@
+/*
+ *  Copyright 2011 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include <stdlib.h>
+#include <time.h>
+
+#include "../unit_test/unit_test.h"
+#include "libyuv/cpu_id.h"
+#include "libyuv/scale.h"
+
+#ifdef ENABLE_ROW_TESTS
+#include "libyuv/scale_row.h"  // For ScaleRowDown2Box_Odd_C
+#endif
+
+#define STRINGIZE(line) #line
+#define FILELINESTR(file, line) file ":" STRINGIZE(line)
+
+#if !defined(DISABLE_SLOW_TESTS) || defined(__x86_64__) || defined(__i386__)
+// SLOW TESTS are those that are unoptimized C code.
+// FULL TESTS are optimized but test many variations of the same code.
+#define ENABLE_FULL_TESTS
+#endif
+
+namespace libyuv {
+
+// Test scaling with C vs Opt and return maximum pixel difference. 0 = exact.
+static int I420TestFilter(int src_width,
+                          int src_height,
+                          int dst_width,
+                          int dst_height,
+                          FilterMode f,
+                          int benchmark_iterations,
+                          int disable_cpu_flags,
+                          int benchmark_cpu_info) {
+  if (!SizeValid(src_width, src_height, dst_width, dst_height)) {
+    return 0;
+  }
+
+  int i, j;
+  int src_width_uv = (Abs(src_width) + 1) >> 1;
+  int src_height_uv = (Abs(src_height) + 1) >> 1;
+
+  int64_t src_y_plane_size = (Abs(src_width)) * (Abs(src_height));
+  int64_t src_uv_plane_size = (src_width_uv) * (src_height_uv);
+
+  int src_stride_y = Abs(src_width);
+  int src_stride_uv = src_width_uv;
+
+  align_buffer_page_end(src_y, src_y_plane_size);
+  align_buffer_page_end(src_u, src_uv_plane_size);
+  align_buffer_page_end(src_v, src_uv_plane_size);
+  if (!src_y || !src_u || !src_v) {
+    printf("Skipped.  Alloc failed " FILELINESTR(__FILE__, __LINE__) "\n");
+    return 0;
+  }
+  MemRandomize(src_y, src_y_plane_size);
+  MemRandomize(src_u, src_uv_plane_size);
+  MemRandomize(src_v, src_uv_plane_size);
+
+  int dst_width_uv = (dst_width + 1) >> 1;
+  int dst_height_uv = (dst_height + 1) >> 1;
+
+  int64_t dst_y_plane_size = (dst_width) * (dst_height);
+  int64_t dst_uv_plane_size = (dst_width_uv) * (dst_height_uv);
+
+  int dst_stride_y = dst_width;
+  int dst_stride_uv = dst_width_uv;
+
+  align_buffer_page_end(dst_y_c, dst_y_plane_size);
+  align_buffer_page_end(dst_u_c, dst_uv_plane_size);
+  align_buffer_page_end(dst_v_c, dst_uv_plane_size);
+  align_buffer_page_end(dst_y_opt, dst_y_plane_size);
+  align_buffer_page_end(dst_u_opt, dst_uv_plane_size);
+  align_buffer_page_end(dst_v_opt, dst_uv_plane_size);
+  if (!dst_y_c || !dst_u_c || !dst_v_c || !dst_y_opt || !dst_u_opt ||
+      !dst_v_opt) {
+    printf("Skipped.  Alloc failed " FILELINESTR(__FILE__, __LINE__) "\n");
+    return 0;
+  }
+
+  MaskCpuFlags(disable_cpu_flags);  // Disable all CPU optimization.
+  double c_time = get_time();
+  I420Scale(src_y, src_stride_y, src_u, src_stride_uv, src_v, src_stride_uv,
+            src_width, src_height, dst_y_c, dst_stride_y, dst_u_c,
+            dst_stride_uv, dst_v_c, dst_stride_uv, dst_width, dst_height, f);
+  c_time = (get_time() - c_time);
+
+  MaskCpuFlags(benchmark_cpu_info);  // Enable all CPU optimization.
+  double opt_time = get_time();
+  for (i = 0; i < benchmark_iterations; ++i) {
+    I420Scale(src_y, src_stride_y, src_u, src_stride_uv, src_v, src_stride_uv,
+              src_width, src_height, dst_y_opt, dst_stride_y, dst_u_opt,
+              dst_stride_uv, dst_v_opt, dst_stride_uv, dst_width, dst_height,
+              f);
+  }
+  opt_time = (get_time() - opt_time) / benchmark_iterations;
+  // Report performance of C vs OPT.
+  printf("filter %d - %8d us C - %8d us OPT\n", f,
+         static_cast<int>(c_time * 1e6), static_cast<int>(opt_time * 1e6));
+
+  // C version may be a little off from the optimized. Order of
+  //  operations may introduce rounding somewhere. So do a difference
+  //  of the buffers and look to see that the max difference is not
+  //  over 3.
+  int max_diff = 0;
+  for (i = 0; i < (dst_height); ++i) {
+    for (j = 0; j < (dst_width); ++j) {
+      int abs_diff = Abs(dst_y_c[(i * dst_stride_y) + j] -
+                         dst_y_opt[(i * dst_stride_y) + j]);
+      if (abs_diff > max_diff) {
+        max_diff = abs_diff;
+      }
+    }
+  }
+
+  for (i = 0; i < (dst_height_uv); ++i) {
+    for (j = 0; j < (dst_width_uv); ++j) {
+      int abs_diff = Abs(dst_u_c[(i * dst_stride_uv) + j] -
+                         dst_u_opt[(i * dst_stride_uv) + j]);
+      if (abs_diff > max_diff) {
+        max_diff = abs_diff;
+      }
+      abs_diff = Abs(dst_v_c[(i * dst_stride_uv) + j] -
+                     dst_v_opt[(i * dst_stride_uv) + j]);
+      if (abs_diff > max_diff) {
+        max_diff = abs_diff;
+      }
+    }
+  }
+
+  free_aligned_buffer_page_end(dst_y_c);
+  free_aligned_buffer_page_end(dst_u_c);
+  free_aligned_buffer_page_end(dst_v_c);
+  free_aligned_buffer_page_end(dst_y_opt);
+  free_aligned_buffer_page_end(dst_u_opt);
+  free_aligned_buffer_page_end(dst_v_opt);
+  free_aligned_buffer_page_end(src_y);
+  free_aligned_buffer_page_end(src_u);
+  free_aligned_buffer_page_end(src_v);
+
+  return max_diff;
+}
+
+// Test scaling with 8 bit C vs 12 bit C and return maximum pixel difference.
+// 0 = exact.
+static int I420TestFilter_12(int src_width,
+                             int src_height,
+                             int dst_width,
+                             int dst_height,
+                             FilterMode f,
+                             int benchmark_iterations,
+                             int disable_cpu_flags,
+                             int benchmark_cpu_info) {
+  if (!SizeValid(src_width, src_height, dst_width, dst_height)) {
+    return 0;
+  }
+
+  int i;
+  int src_width_uv = (Abs(src_width) + 1) >> 1;
+  int src_height_uv = (Abs(src_height) + 1) >> 1;
+
+  int64_t src_y_plane_size = (Abs(src_width)) * (Abs(src_height));
+  int64_t src_uv_plane_size = (src_width_uv) * (src_height_uv);
+
+  int src_stride_y = Abs(src_width);
+  int src_stride_uv = src_width_uv;
+
+  align_buffer_page_end(src_y, src_y_plane_size);
+  align_buffer_page_end(src_u, src_uv_plane_size);
+  align_buffer_page_end(src_v, src_uv_plane_size);
+  align_buffer_page_end(src_y_12, src_y_plane_size * 2);
+  align_buffer_page_end(src_u_12, src_uv_plane_size * 2);
+  align_buffer_page_end(src_v_12, src_uv_plane_size * 2);
+  if (!src_y || !src_u || !src_v || !src_y_12 || !src_u_12 || !src_v_12) {
+    printf("Skipped.  Alloc failed " FILELINESTR(__FILE__, __LINE__) "\n");
+    return 0;
+  }
+  uint16_t* p_src_y_12 = reinterpret_cast<uint16_t*>(src_y_12);
+  uint16_t* p_src_u_12 = reinterpret_cast<uint16_t*>(src_u_12);
+  uint16_t* p_src_v_12 = reinterpret_cast<uint16_t*>(src_v_12);
+
+  MemRandomize(src_y, src_y_plane_size);
+  MemRandomize(src_u, src_uv_plane_size);
+  MemRandomize(src_v, src_uv_plane_size);
+
+  for (i = 0; i < src_y_plane_size; ++i) {
+    p_src_y_12[i] = src_y[i];
+  }
+  for (i = 0; i < src_uv_plane_size; ++i) {
+    p_src_u_12[i] = src_u[i];
+    p_src_v_12[i] = src_v[i];
+  }
+
+  int dst_width_uv = (dst_width + 1) >> 1;
+  int dst_height_uv = (dst_height + 1) >> 1;
+
+  int dst_y_plane_size = (dst_width) * (dst_height);
+  int dst_uv_plane_size = (dst_width_uv) * (dst_height_uv);
+
+  int dst_stride_y = dst_width;
+  int dst_stride_uv = dst_width_uv;
+
+  align_buffer_page_end(dst_y_8, dst_y_plane_size);
+  align_buffer_page_end(dst_u_8, dst_uv_plane_size);
+  align_buffer_page_end(dst_v_8, dst_uv_plane_size);
+  align_buffer_page_end(dst_y_12, dst_y_plane_size * 2);
+  align_buffer_page_end(dst_u_12, dst_uv_plane_size * 2);
+  align_buffer_page_end(dst_v_12, dst_uv_plane_size * 2);
+
+  uint16_t* p_dst_y_12 = reinterpret_cast<uint16_t*>(dst_y_12);
+  uint16_t* p_dst_u_12 = reinterpret_cast<uint16_t*>(dst_u_12);
+  uint16_t* p_dst_v_12 = reinterpret_cast<uint16_t*>(dst_v_12);
+
+  MaskCpuFlags(disable_cpu_flags);  // Disable all CPU optimization.
+  I420Scale(src_y, src_stride_y, src_u, src_stride_uv, src_v, src_stride_uv,
+            src_width, src_height, dst_y_8, dst_stride_y, dst_u_8,
+            dst_stride_uv, dst_v_8, dst_stride_uv, dst_width, dst_height, f);
+  MaskCpuFlags(benchmark_cpu_info);  // Enable all CPU optimization.
+  for (i = 0; i < benchmark_iterations; ++i) {
+    I420Scale_12(p_src_y_12, src_stride_y, p_src_u_12, src_stride_uv,
+                 p_src_v_12, src_stride_uv, src_width, src_height, p_dst_y_12,
+                 dst_stride_y, p_dst_u_12, dst_stride_uv, p_dst_v_12,
+                 dst_stride_uv, dst_width, dst_height, f);
+  }
+
+  // Expect an exact match.
+  int max_diff = 0;
+  for (i = 0; i < dst_y_plane_size; ++i) {
+    int abs_diff = Abs(dst_y_8[i] - p_dst_y_12[i]);
+    if (abs_diff > max_diff) {
+      max_diff = abs_diff;
+    }
+  }
+  for (i = 0; i < dst_uv_plane_size; ++i) {
+    int abs_diff = Abs(dst_u_8[i] - p_dst_u_12[i]);
+    if (abs_diff > max_diff) {
+      max_diff = abs_diff;
+    }
+    abs_diff = Abs(dst_v_8[i] - p_dst_v_12[i]);
+    if (abs_diff > max_diff) {
+      max_diff = abs_diff;
+    }
+  }
+
+  free_aligned_buffer_page_end(dst_y_8);
+  free_aligned_buffer_page_end(dst_u_8);
+  free_aligned_buffer_page_end(dst_v_8);
+  free_aligned_buffer_page_end(dst_y_12);
+  free_aligned_buffer_page_end(dst_u_12);
+  free_aligned_buffer_page_end(dst_v_12);
+  free_aligned_buffer_page_end(src_y);
+  free_aligned_buffer_page_end(src_u);
+  free_aligned_buffer_page_end(src_v);
+  free_aligned_buffer_page_end(src_y_12);
+  free_aligned_buffer_page_end(src_u_12);
+  free_aligned_buffer_page_end(src_v_12);
+
+  return max_diff;
+}
+
+// Test scaling with 8 bit C vs 16 bit C and return maximum pixel difference.
+// 0 = exact.
+static int I420TestFilter_16(int src_width,
+                             int src_height,
+                             int dst_width,
+                             int dst_height,
+                             FilterMode f,
+                             int benchmark_iterations,
+                             int disable_cpu_flags,
+                             int benchmark_cpu_info) {
+  if (!SizeValid(src_width, src_height, dst_width, dst_height)) {
+    return 0;
+  }
+
+  int i;
+  int src_width_uv = (Abs(src_width) + 1) >> 1;
+  int src_height_uv = (Abs(src_height) + 1) >> 1;
+
+  int64_t src_y_plane_size = (Abs(src_width)) * (Abs(src_height));
+  int64_t src_uv_plane_size = (src_width_uv) * (src_height_uv);
+
+  int src_stride_y = Abs(src_width);
+  int src_stride_uv = src_width_uv;
+
+  align_buffer_page_end(src_y, src_y_plane_size);
+  align_buffer_page_end(src_u, src_uv_plane_size);
+  align_buffer_page_end(src_v, src_uv_plane_size);
+  align_buffer_page_end(src_y_16, src_y_plane_size * 2);
+  align_buffer_page_end(src_u_16, src_uv_plane_size * 2);
+  align_buffer_page_end(src_v_16, src_uv_plane_size * 2);
+  if (!src_y || !src_u || !src_v || !src_y_16 || !src_u_16 || !src_v_16) {
+    printf("Skipped.  Alloc failed " FILELINESTR(__FILE__, __LINE__) "\n");
+    return 0;
+  }
+  uint16_t* p_src_y_16 = reinterpret_cast<uint16_t*>(src_y_16);
+  uint16_t* p_src_u_16 = reinterpret_cast<uint16_t*>(src_u_16);
+  uint16_t* p_src_v_16 = reinterpret_cast<uint16_t*>(src_v_16);
+
+  MemRandomize(src_y, src_y_plane_size);
+  MemRandomize(src_u, src_uv_plane_size);
+  MemRandomize(src_v, src_uv_plane_size);
+
+  for (i = 0; i < src_y_plane_size; ++i) {
+    p_src_y_16[i] = src_y[i];
+  }
+  for (i = 0; i < src_uv_plane_size; ++i) {
+    p_src_u_16[i] = src_u[i];
+    p_src_v_16[i] = src_v[i];
+  }
+
+  int dst_width_uv = (dst_width + 1) >> 1;
+  int dst_height_uv = (dst_height + 1) >> 1;
+
+  int dst_y_plane_size = (dst_width) * (dst_height);
+  int dst_uv_plane_size = (dst_width_uv) * (dst_height_uv);
+
+  int dst_stride_y = dst_width;
+  int dst_stride_uv = dst_width_uv;
+
+  align_buffer_page_end(dst_y_8, dst_y_plane_size);
+  align_buffer_page_end(dst_u_8, dst_uv_plane_size);
+  align_buffer_page_end(dst_v_8, dst_uv_plane_size);
+  align_buffer_page_end(dst_y_16, dst_y_plane_size * 2);
+  align_buffer_page_end(dst_u_16, dst_uv_plane_size * 2);
+  align_buffer_page_end(dst_v_16, dst_uv_plane_size * 2);
+
+  uint16_t* p_dst_y_16 = reinterpret_cast<uint16_t*>(dst_y_16);
+  uint16_t* p_dst_u_16 = reinterpret_cast<uint16_t*>(dst_u_16);
+  uint16_t* p_dst_v_16 = reinterpret_cast<uint16_t*>(dst_v_16);
+
+  MaskCpuFlags(disable_cpu_flags);  // Disable all CPU optimization.
+  I420Scale(src_y, src_stride_y, src_u, src_stride_uv, src_v, src_stride_uv,
+            src_width, src_height, dst_y_8, dst_stride_y, dst_u_8,
+            dst_stride_uv, dst_v_8, dst_stride_uv, dst_width, dst_height, f);
+  MaskCpuFlags(benchmark_cpu_info);  // Enable all CPU optimization.
+  for (i = 0; i < benchmark_iterations; ++i) {
+    I420Scale_16(p_src_y_16, src_stride_y, p_src_u_16, src_stride_uv,
+                 p_src_v_16, src_stride_uv, src_width, src_height, p_dst_y_16,
+                 dst_stride_y, p_dst_u_16, dst_stride_uv, p_dst_v_16,
+                 dst_stride_uv, dst_width, dst_height, f);
+  }
+
+  // Expect an exact match.
+  int max_diff = 0;
+  for (i = 0; i < dst_y_plane_size; ++i) {
+    int abs_diff = Abs(dst_y_8[i] - p_dst_y_16[i]);
+    if (abs_diff > max_diff) {
+      max_diff = abs_diff;
+    }
+  }
+  for (i = 0; i < dst_uv_plane_size; ++i) {
+    int abs_diff = Abs(dst_u_8[i] - p_dst_u_16[i]);
+    if (abs_diff > max_diff) {
+      max_diff = abs_diff;
+    }
+    abs_diff = Abs(dst_v_8[i] - p_dst_v_16[i]);
+    if (abs_diff > max_diff) {
+      max_diff = abs_diff;
+    }
+  }
+
+  free_aligned_buffer_page_end(dst_y_8);
+  free_aligned_buffer_page_end(dst_u_8);
+  free_aligned_buffer_page_end(dst_v_8);
+  free_aligned_buffer_page_end(dst_y_16);
+  free_aligned_buffer_page_end(dst_u_16);
+  free_aligned_buffer_page_end(dst_v_16);
+  free_aligned_buffer_page_end(src_y);
+  free_aligned_buffer_page_end(src_u);
+  free_aligned_buffer_page_end(src_v);
+  free_aligned_buffer_page_end(src_y_16);
+  free_aligned_buffer_page_end(src_u_16);
+  free_aligned_buffer_page_end(src_v_16);
+
+  return max_diff;
+}
+
+// Test scaling with C vs Opt and return maximum pixel difference. 0 = exact.
+static int I444TestFilter(int src_width,
+                          int src_height,
+                          int dst_width,
+                          int dst_height,
+                          FilterMode f,
+                          int benchmark_iterations,
+                          int disable_cpu_flags,
+                          int benchmark_cpu_info) {
+  if (!SizeValid(src_width, src_height, dst_width, dst_height)) {
+    return 0;
+  }
+
+  int i, j;
+  int src_width_uv = Abs(src_width);
+  int src_height_uv = Abs(src_height);
+
+  int64_t src_y_plane_size = (Abs(src_width)) * (Abs(src_height));
+  int64_t src_uv_plane_size = (src_width_uv) * (src_height_uv);
+
+  int src_stride_y = Abs(src_width);
+  int src_stride_uv = src_width_uv;
+
+  align_buffer_page_end(src_y, src_y_plane_size);
+  align_buffer_page_end(src_u, src_uv_plane_size);
+  align_buffer_page_end(src_v, src_uv_plane_size);
+  if (!src_y || !src_u || !src_v) {
+    printf("Skipped.  Alloc failed " FILELINESTR(__FILE__, __LINE__) "\n");
+    return 0;
+  }
+  MemRandomize(src_y, src_y_plane_size);
+  MemRandomize(src_u, src_uv_plane_size);
+  MemRandomize(src_v, src_uv_plane_size);
+
+  int dst_width_uv = dst_width;
+  int dst_height_uv = dst_height;
+
+  int64_t dst_y_plane_size = (dst_width) * (dst_height);
+  int64_t dst_uv_plane_size = (dst_width_uv) * (dst_height_uv);
+
+  int dst_stride_y = dst_width;
+  int dst_stride_uv = dst_width_uv;
+
+  align_buffer_page_end(dst_y_c, dst_y_plane_size);
+  align_buffer_page_end(dst_u_c, dst_uv_plane_size);
+  align_buffer_page_end(dst_v_c, dst_uv_plane_size);
+  align_buffer_page_end(dst_y_opt, dst_y_plane_size);
+  align_buffer_page_end(dst_u_opt, dst_uv_plane_size);
+  align_buffer_page_end(dst_v_opt, dst_uv_plane_size);
+  if (!dst_y_c || !dst_u_c || !dst_v_c || !dst_y_opt || !dst_u_opt ||
+      !dst_v_opt) {
+    printf("Skipped.  Alloc failed " FILELINESTR(__FILE__, __LINE__) "\n");
+    return 0;
+  }
+
+  MaskCpuFlags(disable_cpu_flags);  // Disable all CPU optimization.
+  double c_time = get_time();
+  I444Scale(src_y, src_stride_y, src_u, src_stride_uv, src_v, src_stride_uv,
+            src_width, src_height, dst_y_c, dst_stride_y, dst_u_c,
+            dst_stride_uv, dst_v_c, dst_stride_uv, dst_width, dst_height, f);
+  c_time = (get_time() - c_time);
+
+  MaskCpuFlags(benchmark_cpu_info);  // Enable all CPU optimization.
+  double opt_time = get_time();
+  for (i = 0; i < benchmark_iterations; ++i) {
+    I444Scale(src_y, src_stride_y, src_u, src_stride_uv, src_v, src_stride_uv,
+              src_width, src_height, dst_y_opt, dst_stride_y, dst_u_opt,
+              dst_stride_uv, dst_v_opt, dst_stride_uv, dst_width, dst_height,
+              f);
+  }
+  opt_time = (get_time() - opt_time) / benchmark_iterations;
+  // Report performance of C vs OPT.
+  printf("filter %d - %8d us C - %8d us OPT\n", f,
+         static_cast<int>(c_time * 1e6), static_cast<int>(opt_time * 1e6));
+
+  // C version may be a little off from the optimized. Order of
+  //  operations may introduce rounding somewhere. So do a difference
+  //  of the buffers and look to see that the max difference is not
+  //  over 3.
+  int max_diff = 0;
+  for (i = 0; i < (dst_height); ++i) {
+    for (j = 0; j < (dst_width); ++j) {
+      int abs_diff = Abs(dst_y_c[(i * dst_stride_y) + j] -
+                         dst_y_opt[(i * dst_stride_y) + j]);
+      if (abs_diff > max_diff) {
+        max_diff = abs_diff;
+      }
+    }
+  }
+
+  for (i = 0; i < (dst_height_uv); ++i) {
+    for (j = 0; j < (dst_width_uv); ++j) {
+      int abs_diff = Abs(dst_u_c[(i * dst_stride_uv) + j] -
+                         dst_u_opt[(i * dst_stride_uv) + j]);
+      if (abs_diff > max_diff) {
+        max_diff = abs_diff;
+      }
+      abs_diff = Abs(dst_v_c[(i * dst_stride_uv) + j] -
+                     dst_v_opt[(i * dst_stride_uv) + j]);
+      if (abs_diff > max_diff) {
+        max_diff = abs_diff;
+      }
+    }
+  }
+
+  free_aligned_buffer_page_end(dst_y_c);
+  free_aligned_buffer_page_end(dst_u_c);
+  free_aligned_buffer_page_end(dst_v_c);
+  free_aligned_buffer_page_end(dst_y_opt);
+  free_aligned_buffer_page_end(dst_u_opt);
+  free_aligned_buffer_page_end(dst_v_opt);
+  free_aligned_buffer_page_end(src_y);
+  free_aligned_buffer_page_end(src_u);
+  free_aligned_buffer_page_end(src_v);
+
+  return max_diff;
+}
+
+// Test scaling with 8 bit C vs 12 bit C and return maximum pixel difference.
+// 0 = exact.
+static int I444TestFilter_12(int src_width,
+                             int src_height,
+                             int dst_width,
+                             int dst_height,
+                             FilterMode f,
+                             int benchmark_iterations,
+                             int disable_cpu_flags,
+                             int benchmark_cpu_info) {
+  if (!SizeValid(src_width, src_height, dst_width, dst_height)) {
+    return 0;
+  }
+
+  int i;
+  int src_width_uv = Abs(src_width);
+  int src_height_uv = Abs(src_height);
+
+  int64_t src_y_plane_size = (Abs(src_width)) * (Abs(src_height));
+  int64_t src_uv_plane_size = (src_width_uv) * (src_height_uv);
+
+  int src_stride_y = Abs(src_width);
+  int src_stride_uv = src_width_uv;
+
+  align_buffer_page_end(src_y, src_y_plane_size);
+  align_buffer_page_end(src_u, src_uv_plane_size);
+  align_buffer_page_end(src_v, src_uv_plane_size);
+  align_buffer_page_end(src_y_12, src_y_plane_size * 2);
+  align_buffer_page_end(src_u_12, src_uv_plane_size * 2);
+  align_buffer_page_end(src_v_12, src_uv_plane_size * 2);
+  if (!src_y || !src_u || !src_v || !src_y_12 || !src_u_12 || !src_v_12) {
+    printf("Skipped.  Alloc failed " FILELINESTR(__FILE__, __LINE__) "\n");
+    return 0;
+  }
+  uint16_t* p_src_y_12 = reinterpret_cast<uint16_t*>(src_y_12);
+  uint16_t* p_src_u_12 = reinterpret_cast<uint16_t*>(src_u_12);
+  uint16_t* p_src_v_12 = reinterpret_cast<uint16_t*>(src_v_12);
+
+  MemRandomize(src_y, src_y_plane_size);
+  MemRandomize(src_u, src_uv_plane_size);
+  MemRandomize(src_v, src_uv_plane_size);
+
+  for (i = 0; i < src_y_plane_size; ++i) {
+    p_src_y_12[i] = src_y[i];
+  }
+  for (i = 0; i < src_uv_plane_size; ++i) {
+    p_src_u_12[i] = src_u[i];
+    p_src_v_12[i] = src_v[i];
+  }
+
+  int dst_width_uv = dst_width;
+  int dst_height_uv = dst_height;
+
+  int dst_y_plane_size = (dst_width) * (dst_height);
+  int dst_uv_plane_size = (dst_width_uv) * (dst_height_uv);
+
+  int dst_stride_y = dst_width;
+  int dst_stride_uv = dst_width_uv;
+
+  align_buffer_page_end(dst_y_8, dst_y_plane_size);
+  align_buffer_page_end(dst_u_8, dst_uv_plane_size);
+  align_buffer_page_end(dst_v_8, dst_uv_plane_size);
+  align_buffer_page_end(dst_y_12, dst_y_plane_size * 2);
+  align_buffer_page_end(dst_u_12, dst_uv_plane_size * 2);
+  align_buffer_page_end(dst_v_12, dst_uv_plane_size * 2);
+
+  uint16_t* p_dst_y_12 = reinterpret_cast<uint16_t*>(dst_y_12);
+  uint16_t* p_dst_u_12 = reinterpret_cast<uint16_t*>(dst_u_12);
+  uint16_t* p_dst_v_12 = reinterpret_cast<uint16_t*>(dst_v_12);
+
+  MaskCpuFlags(disable_cpu_flags);  // Disable all CPU optimization.
+  I444Scale(src_y, src_stride_y, src_u, src_stride_uv, src_v, src_stride_uv,
+            src_width, src_height, dst_y_8, dst_stride_y, dst_u_8,
+            dst_stride_uv, dst_v_8, dst_stride_uv, dst_width, dst_height, f);
+  MaskCpuFlags(benchmark_cpu_info);  // Enable all CPU optimization.
+  for (i = 0; i < benchmark_iterations; ++i) {
+    I444Scale_12(p_src_y_12, src_stride_y, p_src_u_12, src_stride_uv,
+                 p_src_v_12, src_stride_uv, src_width, src_height, p_dst_y_12,
+                 dst_stride_y, p_dst_u_12, dst_stride_uv, p_dst_v_12,
+                 dst_stride_uv, dst_width, dst_height, f);
+  }
+
+  // Expect an exact match.
+  int max_diff = 0;
+  for (i = 0; i < dst_y_plane_size; ++i) {
+    int abs_diff = Abs(dst_y_8[i] - p_dst_y_12[i]);
+    if (abs_diff > max_diff) {
+      max_diff = abs_diff;
+    }
+  }
+  for (i = 0; i < dst_uv_plane_size; ++i) {
+    int abs_diff = Abs(dst_u_8[i] - p_dst_u_12[i]);
+    if (abs_diff > max_diff) {
+      max_diff = abs_diff;
+    }
+    abs_diff = Abs(dst_v_8[i] - p_dst_v_12[i]);
+    if (abs_diff > max_diff) {
+      max_diff = abs_diff;
+    }
+  }
+
+  free_aligned_buffer_page_end(dst_y_8);
+  free_aligned_buffer_page_end(dst_u_8);
+  free_aligned_buffer_page_end(dst_v_8);
+  free_aligned_buffer_page_end(dst_y_12);
+  free_aligned_buffer_page_end(dst_u_12);
+  free_aligned_buffer_page_end(dst_v_12);
+  free_aligned_buffer_page_end(src_y);
+  free_aligned_buffer_page_end(src_u);
+  free_aligned_buffer_page_end(src_v);
+  free_aligned_buffer_page_end(src_y_12);
+  free_aligned_buffer_page_end(src_u_12);
+  free_aligned_buffer_page_end(src_v_12);
+
+  return max_diff;
+}
+
+// Test scaling with 8 bit C vs 16 bit C and return maximum pixel difference.
+// 0 = exact.
+static int I444TestFilter_16(int src_width,
+                             int src_height,
+                             int dst_width,
+                             int dst_height,
+                             FilterMode f,
+                             int benchmark_iterations,
+                             int disable_cpu_flags,
+                             int benchmark_cpu_info) {
+  if (!SizeValid(src_width, src_height, dst_width, dst_height)) {
+    return 0;
+  }
+
+  int i;
+  int src_width_uv = Abs(src_width);
+  int src_height_uv = Abs(src_height);
+
+  int64_t src_y_plane_size = (Abs(src_width)) * (Abs(src_height));
+  int64_t src_uv_plane_size = (src_width_uv) * (src_height_uv);
+
+  int src_stride_y = Abs(src_width);
+  int src_stride_uv = src_width_uv;
+
+  align_buffer_page_end(src_y, src_y_plane_size);
+  align_buffer_page_end(src_u, src_uv_plane_size);
+  align_buffer_page_end(src_v, src_uv_plane_size);
+  align_buffer_page_end(src_y_16, src_y_plane_size * 2);
+  align_buffer_page_end(src_u_16, src_uv_plane_size * 2);
+  align_buffer_page_end(src_v_16, src_uv_plane_size * 2);
+  if (!src_y || !src_u || !src_v || !src_y_16 || !src_u_16 || !src_v_16) {
+    printf("Skipped.  Alloc failed " FILELINESTR(__FILE__, __LINE__) "\n");
+    return 0;
+  }
+  uint16_t* p_src_y_16 = reinterpret_cast<uint16_t*>(src_y_16);
+  uint16_t* p_src_u_16 = reinterpret_cast<uint16_t*>(src_u_16);
+  uint16_t* p_src_v_16 = reinterpret_cast<uint16_t*>(src_v_16);
+
+  MemRandomize(src_y, src_y_plane_size);
+  MemRandomize(src_u, src_uv_plane_size);
+  MemRandomize(src_v, src_uv_plane_size);
+
+  for (i = 0; i < src_y_plane_size; ++i) {
+    p_src_y_16[i] = src_y[i];
+  }
+  for (i = 0; i < src_uv_plane_size; ++i) {
+    p_src_u_16[i] = src_u[i];
+    p_src_v_16[i] = src_v[i];
+  }
+
+  int dst_width_uv = dst_width;
+  int dst_height_uv = dst_height;
+
+  int dst_y_plane_size = (dst_width) * (dst_height);
+  int dst_uv_plane_size = (dst_width_uv) * (dst_height_uv);
+
+  int dst_stride_y = dst_width;
+  int dst_stride_uv = dst_width_uv;
+
+  align_buffer_page_end(dst_y_8, dst_y_plane_size);
+  align_buffer_page_end(dst_u_8, dst_uv_plane_size);
+  align_buffer_page_end(dst_v_8, dst_uv_plane_size);
+  align_buffer_page_end(dst_y_16, dst_y_plane_size * 2);
+  align_buffer_page_end(dst_u_16, dst_uv_plane_size * 2);
+  align_buffer_page_end(dst_v_16, dst_uv_plane_size * 2);
+
+  uint16_t* p_dst_y_16 = reinterpret_cast<uint16_t*>(dst_y_16);
+  uint16_t* p_dst_u_16 = reinterpret_cast<uint16_t*>(dst_u_16);
+  uint16_t* p_dst_v_16 = reinterpret_cast<uint16_t*>(dst_v_16);
+
+  MaskCpuFlags(disable_cpu_flags);  // Disable all CPU optimization.
+  I444Scale(src_y, src_stride_y, src_u, src_stride_uv, src_v, src_stride_uv,
+            src_width, src_height, dst_y_8, dst_stride_y, dst_u_8,
+            dst_stride_uv, dst_v_8, dst_stride_uv, dst_width, dst_height, f);
+  MaskCpuFlags(benchmark_cpu_info);  // Enable all CPU optimization.
+  for (i = 0; i < benchmark_iterations; ++i) {
+    I444Scale_16(p_src_y_16, src_stride_y, p_src_u_16, src_stride_uv,
+                 p_src_v_16, src_stride_uv, src_width, src_height, p_dst_y_16,
+                 dst_stride_y, p_dst_u_16, dst_stride_uv, p_dst_v_16,
+                 dst_stride_uv, dst_width, dst_height, f);
+  }
+
+  // Expect an exact match.
+  int max_diff = 0;
+  for (i = 0; i < dst_y_plane_size; ++i) {
+    int abs_diff = Abs(dst_y_8[i] - p_dst_y_16[i]);
+    if (abs_diff > max_diff) {
+      max_diff = abs_diff;
+    }
+  }
+  for (i = 0; i < dst_uv_plane_size; ++i) {
+    int abs_diff = Abs(dst_u_8[i] - p_dst_u_16[i]);
+    if (abs_diff > max_diff) {
+      max_diff = abs_diff;
+    }
+    abs_diff = Abs(dst_v_8[i] - p_dst_v_16[i]);
+    if (abs_diff > max_diff) {
+      max_diff = abs_diff;
+    }
+  }
+
+  free_aligned_buffer_page_end(dst_y_8);
+  free_aligned_buffer_page_end(dst_u_8);
+  free_aligned_buffer_page_end(dst_v_8);
+  free_aligned_buffer_page_end(dst_y_16);
+  free_aligned_buffer_page_end(dst_u_16);
+  free_aligned_buffer_page_end(dst_v_16);
+  free_aligned_buffer_page_end(src_y);
+  free_aligned_buffer_page_end(src_u);
+  free_aligned_buffer_page_end(src_v);
+  free_aligned_buffer_page_end(src_y_16);
+  free_aligned_buffer_page_end(src_u_16);
+  free_aligned_buffer_page_end(src_v_16);
+
+  return max_diff;
+}
+
+// Test scaling with C vs Opt and return maximum pixel difference. 0 = exact.
+static int NV12TestFilter(int src_width,
+                          int src_height,
+                          int dst_width,
+                          int dst_height,
+                          FilterMode f,
+                          int benchmark_iterations,
+                          int disable_cpu_flags,
+                          int benchmark_cpu_info) {
+  if (!SizeValid(src_width, src_height, dst_width, dst_height)) {
+    return 0;
+  }
+
+  int i, j;
+  int src_width_uv = (Abs(src_width) + 1) >> 1;
+  int src_height_uv = (Abs(src_height) + 1) >> 1;
+
+  int64_t src_y_plane_size = (Abs(src_width)) * (Abs(src_height));
+  int64_t src_uv_plane_size = (src_width_uv) * (src_height_uv)*2;
+
+  int src_stride_y = Abs(src_width);
+  int src_stride_uv = src_width_uv * 2;
+
+  align_buffer_page_end(src_y, src_y_plane_size);
+  align_buffer_page_end(src_uv, src_uv_plane_size);
+  if (!src_y || !src_uv) {
+    printf("Skipped.  Alloc failed " FILELINESTR(__FILE__, __LINE__) "\n");
+    return 0;
+  }
+  MemRandomize(src_y, src_y_plane_size);
+  MemRandomize(src_uv, src_uv_plane_size);
+
+  int dst_width_uv = (dst_width + 1) >> 1;
+  int dst_height_uv = (dst_height + 1) >> 1;
+
+  int64_t dst_y_plane_size = (dst_width) * (dst_height);
+  int64_t dst_uv_plane_size = (dst_width_uv) * (dst_height_uv)*2;
+
+  int dst_stride_y = dst_width;
+  int dst_stride_uv = dst_width_uv * 2;
+
+  align_buffer_page_end(dst_y_c, dst_y_plane_size);
+  align_buffer_page_end(dst_uv_c, dst_uv_plane_size);
+  align_buffer_page_end(dst_y_opt, dst_y_plane_size);
+  align_buffer_page_end(dst_uv_opt, dst_uv_plane_size);
+  if (!dst_y_c || !dst_uv_c || !dst_y_opt || !dst_uv_opt) {
+    printf("Skipped.  Alloc failed " FILELINESTR(__FILE__, __LINE__) "\n");
+    return 0;
+  }
+
+  MaskCpuFlags(disable_cpu_flags);  // Disable all CPU optimization.
+  double c_time = get_time();
+  NV12Scale(src_y, src_stride_y, src_uv, src_stride_uv, src_width, src_height,
+            dst_y_c, dst_stride_y, dst_uv_c, dst_stride_uv, dst_width,
+            dst_height, f);
+  c_time = (get_time() - c_time);
+
+  MaskCpuFlags(benchmark_cpu_info);  // Enable all CPU optimization.
+  double opt_time = get_time();
+  for (i = 0; i < benchmark_iterations; ++i) {
+    NV12Scale(src_y, src_stride_y, src_uv, src_stride_uv, src_width, src_height,
+              dst_y_opt, dst_stride_y, dst_uv_opt, dst_stride_uv, dst_width,
+              dst_height, f);
+  }
+  opt_time = (get_time() - opt_time) / benchmark_iterations;
+  // Report performance of C vs OPT.
+  printf("filter %d - %8d us C - %8d us OPT\n", f,
+         static_cast<int>(c_time * 1e6), static_cast<int>(opt_time * 1e6));
+
+  // C version may be a little off from the optimized. Order of
+  //  operations may introduce rounding somewhere. So do a difference
+  //  of the buffers and look to see that the max difference is not
+  //  over 3.
+  int max_diff = 0;
+  for (i = 0; i < (dst_height); ++i) {
+    for (j = 0; j < (dst_width); ++j) {
+      int abs_diff = Abs(dst_y_c[(i * dst_stride_y) + j] -
+                         dst_y_opt[(i * dst_stride_y) + j]);
+      if (abs_diff > max_diff) {
+        max_diff = abs_diff;
+      }
+    }
+  }
+
+  for (i = 0; i < (dst_height_uv); ++i) {
+    for (j = 0; j < (dst_width_uv * 2); ++j) {
+      int abs_diff = Abs(dst_uv_c[(i * dst_stride_uv) + j] -
+                         dst_uv_opt[(i * dst_stride_uv) + j]);
+      if (abs_diff > max_diff) {
+        max_diff = abs_diff;
+      }
+    }
+  }
+
+  free_aligned_buffer_page_end(dst_y_c);
+  free_aligned_buffer_page_end(dst_uv_c);
+  free_aligned_buffer_page_end(dst_y_opt);
+  free_aligned_buffer_page_end(dst_uv_opt);
+  free_aligned_buffer_page_end(src_y);
+  free_aligned_buffer_page_end(src_uv);
+
+  return max_diff;
+}
+
+// The following adjustments in dimensions ensure the scale factor will be
+// exactly achieved.
+// 2 is chroma subsample.
+#define DX(x, nom, denom) static_cast<int>(((Abs(x) / nom + 1) / 2) * nom * 2)
+#define SX(x, nom, denom) static_cast<int>(((x / nom + 1) / 2) * denom * 2)
+
+#define TEST_FACTOR1(DISABLED_, name, filter, nom, denom, max_diff)           \
+  TEST_F(LibYUVScaleTest, I420ScaleDownBy##name##_##filter) {                 \
+    int diff = I420TestFilter(                                                \
+        SX(benchmark_width_, nom, denom), SX(benchmark_height_, nom, denom),  \
+        DX(benchmark_width_, nom, denom), DX(benchmark_height_, nom, denom),  \
+        kFilter##filter, benchmark_iterations_, disable_cpu_flags_,           \
+        benchmark_cpu_info_);                                                 \
+    EXPECT_LE(diff, max_diff);                                                \
+  }                                                                           \
+  TEST_F(LibYUVScaleTest, I444ScaleDownBy##name##_##filter) {                 \
+    int diff = I444TestFilter(                                                \
+        SX(benchmark_width_, nom, denom), SX(benchmark_height_, nom, denom),  \
+        DX(benchmark_width_, nom, denom), DX(benchmark_height_, nom, denom),  \
+        kFilter##filter, benchmark_iterations_, disable_cpu_flags_,           \
+        benchmark_cpu_info_);                                                 \
+    EXPECT_LE(diff, max_diff);                                                \
+  }                                                                           \
+  TEST_F(LibYUVScaleTest, DISABLED_##I420ScaleDownBy##name##_##filter##_12) { \
+    int diff = I420TestFilter_12(                                             \
+        SX(benchmark_width_, nom, denom), SX(benchmark_height_, nom, denom),  \
+        DX(benchmark_width_, nom, denom), DX(benchmark_height_, nom, denom),  \
+        kFilter##filter, benchmark_iterations_, disable_cpu_flags_,           \
+        benchmark_cpu_info_);                                                 \
+    EXPECT_LE(diff, max_diff);                                                \
+  }                                                                           \
+  TEST_F(LibYUVScaleTest, DISABLED_##I444ScaleDownBy##name##_##filter##_12) { \
+    int diff = I444TestFilter_12(                                             \
+        SX(benchmark_width_, nom, denom), SX(benchmark_height_, nom, denom),  \
+        DX(benchmark_width_, nom, denom), DX(benchmark_height_, nom, denom),  \
+        kFilter##filter, benchmark_iterations_, disable_cpu_flags_,           \
+        benchmark_cpu_info_);                                                 \
+    EXPECT_LE(diff, max_diff);                                                \
+  }                                                                           \
+  TEST_F(LibYUVScaleTest, NV12ScaleDownBy##name##_##filter) {                 \
+    int diff = NV12TestFilter(                                                \
+        SX(benchmark_width_, nom, denom), SX(benchmark_height_, nom, denom),  \
+        DX(benchmark_width_, nom, denom), DX(benchmark_height_, nom, denom),  \
+        kFilter##filter, benchmark_iterations_, disable_cpu_flags_,           \
+        benchmark_cpu_info_);                                                 \
+    EXPECT_LE(diff, max_diff);                                                \
+  }
+
+// Test a scale factor with all 4 filters.  Expect unfiltered to be exact, but
+// filtering is different fixed point implementations for SSSE3, Neon and C.
+#ifndef DISABLE_SLOW_TESTS
+#define TEST_FACTOR(name, nom, denom, boxdiff)  \
+  TEST_FACTOR1(, name, None, nom, denom, 0)     \
+  TEST_FACTOR1(, name, Linear, nom, denom, 3)   \
+  TEST_FACTOR1(, name, Bilinear, nom, denom, 3) \
+  TEST_FACTOR1(, name, Box, nom, denom, boxdiff)
+#else
+#if defined(ENABLE_FULL_TESTS)
+#define TEST_FACTOR(name, nom, denom, boxdiff)           \
+  TEST_FACTOR1(DISABLED_, name, None, nom, denom, 0)     \
+  TEST_FACTOR1(DISABLED_, name, Linear, nom, denom, 3)   \
+  TEST_FACTOR1(DISABLED_, name, Bilinear, nom, denom, 3) \
+  TEST_FACTOR1(DISABLED_, name, Box, nom, denom, boxdiff)
+#else
+#define TEST_FACTOR(name, nom, denom, boxdiff)           \
+  TEST_FACTOR1(DISABLED_, name, Bilinear, nom, denom, 3) \
+  TEST_FACTOR1(DISABLED_, name, Box, nom, denom, boxdiff)
+#endif
+#endif
+
+TEST_FACTOR(2, 1, 2, 0)
+TEST_FACTOR(4, 1, 4, 0)
+#ifndef DISABLE_SLOW_TESTS
+TEST_FACTOR(8, 1, 8, 0)
+#endif
+TEST_FACTOR(3by4, 3, 4, 1)
+TEST_FACTOR(3by8, 3, 8, 1)
+TEST_FACTOR(3, 1, 3, 0)
+#undef TEST_FACTOR1
+#undef TEST_FACTOR
+#undef SX
+#undef DX
+
+#define TEST_SCALETO1(DISABLED_, name, width, height, filter, max_diff)       \
+  TEST_F(LibYUVScaleTest, I420##name##To##width##x##height##_##filter) {      \
+    int diff = I420TestFilter(benchmark_width_, benchmark_height_, width,     \
+                              height, kFilter##filter, benchmark_iterations_, \
+                              disable_cpu_flags_, benchmark_cpu_info_);       \
+    EXPECT_LE(diff, max_diff);                                                \
+  }                                                                           \
+  TEST_F(LibYUVScaleTest, I444##name##To##width##x##height##_##filter) {      \
+    int diff = I444TestFilter(benchmark_width_, benchmark_height_, width,     \
+                              height, kFilter##filter, benchmark_iterations_, \
+                              disable_cpu_flags_, benchmark_cpu_info_);       \
+    EXPECT_LE(diff, max_diff);                                                \
+  }                                                                           \
+  TEST_F(LibYUVScaleTest,                                                     \
+         DISABLED_##I420##name##To##width##x##height##_##filter##_12) {       \
+    int diff = I420TestFilter_12(                                             \
+        benchmark_width_, benchmark_height_, width, height, kFilter##filter,  \
+        benchmark_iterations_, disable_cpu_flags_, benchmark_cpu_info_);      \
+    EXPECT_LE(diff, max_diff);                                                \
+  }                                                                           \
+  TEST_F(LibYUVScaleTest,                                                     \
+         DISABLED_##I444##name##To##width##x##height##_##filter##_12) {       \
+    int diff = I444TestFilter_12(                                             \
+        benchmark_width_, benchmark_height_, width, height, kFilter##filter,  \
+        benchmark_iterations_, disable_cpu_flags_, benchmark_cpu_info_);      \
+    EXPECT_LE(diff, max_diff);                                                \
+  }                                                                           \
+  TEST_F(LibYUVScaleTest,                                                     \
+         DISABLED_##I420##name##To##width##x##height##_##filter##_16) {       \
+    int diff = I420TestFilter_16(                                             \
+        benchmark_width_, benchmark_height_, width, height, kFilter##filter,  \
+        benchmark_iterations_, disable_cpu_flags_, benchmark_cpu_info_);      \
+    EXPECT_LE(diff, max_diff);                                                \
+  }                                                                           \
+  TEST_F(LibYUVScaleTest,                                                     \
+         DISABLED_##I444##name##To##width##x##height##_##filter##_16) {       \
+    int diff = I444TestFilter_16(                                             \
+        benchmark_width_, benchmark_height_, width, height, kFilter##filter,  \
+        benchmark_iterations_, disable_cpu_flags_, benchmark_cpu_info_);      \
+    EXPECT_LE(diff, max_diff);                                                \
+  }                                                                           \
+  TEST_F(LibYUVScaleTest, NV12##name##To##width##x##height##_##filter) {      \
+    int diff = NV12TestFilter(benchmark_width_, benchmark_height_, width,     \
+                              height, kFilter##filter, benchmark_iterations_, \
+                              disable_cpu_flags_, benchmark_cpu_info_);       \
+    EXPECT_LE(diff, max_diff);                                                \
+  }                                                                           \
+  TEST_F(LibYUVScaleTest, I420##name##From##width##x##height##_##filter) {    \
+    int diff = I420TestFilter(width, height, Abs(benchmark_width_),           \
+                              Abs(benchmark_height_), kFilter##filter,        \
+                              benchmark_iterations_, disable_cpu_flags_,      \
+                              benchmark_cpu_info_);                           \
+    EXPECT_LE(diff, max_diff);                                                \
+  }                                                                           \
+  TEST_F(LibYUVScaleTest, I444##name##From##width##x##height##_##filter) {    \
+    int diff = I444TestFilter(width, height, Abs(benchmark_width_),           \
+                              Abs(benchmark_height_), kFilter##filter,        \
+                              benchmark_iterations_, disable_cpu_flags_,      \
+                              benchmark_cpu_info_);                           \
+    EXPECT_LE(diff, max_diff);                                                \
+  }                                                                           \
+  TEST_F(LibYUVScaleTest,                                                     \
+         DISABLED_##I420##name##From##width##x##height##_##filter##_12) {     \
+    int diff = I420TestFilter_12(width, height, Abs(benchmark_width_),        \
+                                 Abs(benchmark_height_), kFilter##filter,     \
+                                 benchmark_iterations_, disable_cpu_flags_,   \
+                                 benchmark_cpu_info_);                        \
+    EXPECT_LE(diff, max_diff);                                                \
+  }                                                                           \
+  TEST_F(LibYUVScaleTest,                                                     \
+         DISABLED_##I444##name##From##width##x##height##_##filter##_12) {     \
+    int diff = I444TestFilter_12(width, height, Abs(benchmark_width_),        \
+                                 Abs(benchmark_height_), kFilter##filter,     \
+                                 benchmark_iterations_, disable_cpu_flags_,   \
+                                 benchmark_cpu_info_);                        \
+    EXPECT_LE(diff, max_diff);                                                \
+  }                                                                           \
+  TEST_F(LibYUVScaleTest,                                                     \
+         DISABLED_##I420##name##From##width##x##height##_##filter##_16) {     \
+    int diff = I420TestFilter_16(width, height, Abs(benchmark_width_),        \
+                                 Abs(benchmark_height_), kFilter##filter,     \
+                                 benchmark_iterations_, disable_cpu_flags_,   \
+                                 benchmark_cpu_info_);                        \
+    EXPECT_LE(diff, max_diff);                                                \
+  }                                                                           \
+  TEST_F(LibYUVScaleTest,                                                     \
+         DISABLED_##I444##name##From##width##x##height##_##filter##_16) {     \
+    int diff = I444TestFilter_16(width, height, Abs(benchmark_width_),        \
+                                 Abs(benchmark_height_), kFilter##filter,     \
+                                 benchmark_iterations_, disable_cpu_flags_,   \
+                                 benchmark_cpu_info_);                        \
+    EXPECT_LE(diff, max_diff);                                                \
+  }                                                                           \
+  TEST_F(LibYUVScaleTest, NV12##name##From##width##x##height##_##filter) {    \
+    int diff = NV12TestFilter(width, height, Abs(benchmark_width_),           \
+                              Abs(benchmark_height_), kFilter##filter,        \
+                              benchmark_iterations_, disable_cpu_flags_,      \
+                              benchmark_cpu_info_);                           \
+    EXPECT_LE(diff, max_diff);                                                \
+  }
+
+#ifndef DISABLE_SLOW_TESTS
+// Test scale to a specified size with all 4 filters.
+#define TEST_SCALETO(name, width, height)           \
+  TEST_SCALETO1(, name, width, height, None, 0)     \
+  TEST_SCALETO1(, name, width, height, Linear, 3)   \
+  TEST_SCALETO1(, name, width, height, Bilinear, 3) \
+  TEST_SCALETO1(, name, width, height, Box, 3)
+#else
+#if defined(ENABLE_FULL_TESTS)
+#define TEST_SCALETO(name, width, height)                    \
+  TEST_SCALETO1(DISABLED_, name, width, height, None, 0)     \
+  TEST_SCALETO1(DISABLED_, name, width, height, Linear, 3)   \
+  TEST_SCALETO1(DISABLED_, name, width, height, Bilinear, 3) \
+  TEST_SCALETO1(DISABLED_, name, width, height, Box, 3)
+#else
+#define TEST_SCALETO(name, width, height)                    \
+  TEST_SCALETO1(DISABLED_, name, width, height, Bilinear, 3) \
+  TEST_SCALETO1(DISABLED_, name, width, height, Box, 3)
+#endif
+#endif
+
+TEST_SCALETO(Scale, 1, 1)
+// TEST_SCALETO(Scale, 256, 144) /* 128x72 * 2 */
+TEST_SCALETO(Scale, 320, 240)
+TEST_SCALETO(Scale, 569, 480)
+TEST_SCALETO(Scale, 640, 360)
+#ifndef DISABLE_SLOW_TESTS
+TEST_SCALETO(Scale, 1280, 720)
+TEST_SCALETO(Scale, 1920, 1080)
+#endif  // DISABLE_SLOW_TESTS
+#undef TEST_SCALETO1
+#undef TEST_SCALETO
+
+#define TEST_SCALESWAPXY1(DISABLED_, name, filter, max_diff)               \
+  TEST_F(LibYUVScaleTest, I420##name##SwapXY_##filter) {                   \
+    int diff = I420TestFilter(benchmark_width_, benchmark_height_,         \
+                              benchmark_height_, benchmark_width_,         \
+                              kFilter##filter, benchmark_iterations_,      \
+                              disable_cpu_flags_, benchmark_cpu_info_);    \
+    EXPECT_LE(diff, max_diff);                                             \
+  }                                                                        \
+  TEST_F(LibYUVScaleTest, I444##name##SwapXY_##filter) {                   \
+    int diff = I444TestFilter(benchmark_width_, benchmark_height_,         \
+                              benchmark_height_, benchmark_width_,         \
+                              kFilter##filter, benchmark_iterations_,      \
+                              disable_cpu_flags_, benchmark_cpu_info_);    \
+    EXPECT_LE(diff, max_diff);                                             \
+  }                                                                        \
+  TEST_F(LibYUVScaleTest, DISABLED_##I420##name##SwapXY_##filter##_12) {   \
+    int diff = I420TestFilter_12(benchmark_width_, benchmark_height_,      \
+                                 benchmark_height_, benchmark_width_,      \
+                                 kFilter##filter, benchmark_iterations_,   \
+                                 disable_cpu_flags_, benchmark_cpu_info_); \
+    EXPECT_LE(diff, max_diff);                                             \
+  }                                                                        \
+  TEST_F(LibYUVScaleTest, DISABLED_##I444##name##SwapXY_##filter##_12) {   \
+    int diff = I444TestFilter_12(benchmark_width_, benchmark_height_,      \
+                                 benchmark_height_, benchmark_width_,      \
+                                 kFilter##filter, benchmark_iterations_,   \
+                                 disable_cpu_flags_, benchmark_cpu_info_); \
+    EXPECT_LE(diff, max_diff);                                             \
+  }                                                                        \
+  TEST_F(LibYUVScaleTest, DISABLED_##I420##name##SwapXY_##filter##_16) {   \
+    int diff = I420TestFilter_16(benchmark_width_, benchmark_height_,      \
+                                 benchmark_height_, benchmark_width_,      \
+                                 kFilter##filter, benchmark_iterations_,   \
+                                 disable_cpu_flags_, benchmark_cpu_info_); \
+    EXPECT_LE(diff, max_diff);                                             \
+  }                                                                        \
+  TEST_F(LibYUVScaleTest, DISABLED_##I444##name##SwapXY_##filter##_16) {   \
+    int diff = I444TestFilter_16(benchmark_width_, benchmark_height_,      \
+                                 benchmark_height_, benchmark_width_,      \
+                                 kFilter##filter, benchmark_iterations_,   \
+                                 disable_cpu_flags_, benchmark_cpu_info_); \
+    EXPECT_LE(diff, max_diff);                                             \
+  }                                                                        \
+  TEST_F(LibYUVScaleTest, NV12##name##SwapXY_##filter) {                   \
+    int diff = NV12TestFilter(benchmark_width_, benchmark_height_,         \
+                              benchmark_height_, benchmark_width_,         \
+                              kFilter##filter, benchmark_iterations_,      \
+                              disable_cpu_flags_, benchmark_cpu_info_);    \
+    EXPECT_LE(diff, max_diff);                                             \
+  }
+
+// Test scale to a specified size with all 4 filters.
+#ifndef DISABLE_SLOW_TESTS
+TEST_SCALESWAPXY1(, Scale, None, 0)
+TEST_SCALESWAPXY1(, Scale, Linear, 3)
+TEST_SCALESWAPXY1(, Scale, Bilinear, 3)
+TEST_SCALESWAPXY1(, Scale, Box, 3)
+#else
+#if defined(ENABLE_FULL_TESTS)
+TEST_SCALESWAPXY1(DISABLED_, Scale, None, 0)
+TEST_SCALESWAPXY1(DISABLED_, Scale, Linear, 3)
+TEST_SCALESWAPXY1(DISABLED_, Scale, Bilinear, 3)
+TEST_SCALESWAPXY1(DISABLED_, Scale, Box, 3)
+#else
+TEST_SCALESWAPXY1(DISABLED_, Scale, Bilinear, 3)
+TEST_SCALESWAPXY1(DISABLED_, Scale, Box, 3)
+#endif
+#endif
+
+#undef TEST_SCALESWAPXY1
+
+#ifdef ENABLE_ROW_TESTS
+#ifdef HAS_SCALEROWDOWN2_SSSE3
+TEST_F(LibYUVScaleTest, TestScaleRowDown2Box_Odd_SSSE3) {
+  SIMD_ALIGNED(uint8_t orig_pixels[128 * 2]);
+  SIMD_ALIGNED(uint8_t dst_pixels_opt[64]);
+  SIMD_ALIGNED(uint8_t dst_pixels_c[64]);
+  memset(orig_pixels, 0, sizeof(orig_pixels));
+  memset(dst_pixels_opt, 0, sizeof(dst_pixels_opt));
+  memset(dst_pixels_c, 0, sizeof(dst_pixels_c));
+
+  int has_ssse3 = TestCpuFlag(kCpuHasSSSE3);
+  if (!has_ssse3) {
+    printf("Warning SSSE3 not detected; Skipping test.\n");
+  } else {
+    // TL.
+    orig_pixels[0] = 255u;
+    orig_pixels[1] = 0u;
+    orig_pixels[128 + 0] = 0u;
+    orig_pixels[128 + 1] = 0u;
+    // TR.
+    orig_pixels[2] = 0u;
+    orig_pixels[3] = 100u;
+    orig_pixels[128 + 2] = 0u;
+    orig_pixels[128 + 3] = 0u;
+    // BL.
+    orig_pixels[4] = 0u;
+    orig_pixels[5] = 0u;
+    orig_pixels[128 + 4] = 50u;
+    orig_pixels[128 + 5] = 0u;
+    // BR.
+    orig_pixels[6] = 0u;
+    orig_pixels[7] = 0u;
+    orig_pixels[128 + 6] = 0u;
+    orig_pixels[128 + 7] = 20u;
+    // Odd.
+    orig_pixels[126] = 4u;
+    orig_pixels[127] = 255u;
+    orig_pixels[128 + 126] = 16u;
+    orig_pixels[128 + 127] = 255u;
+
+    // Test regular half size.
+    ScaleRowDown2Box_C(orig_pixels, 128, dst_pixels_c, 64);
+
+    EXPECT_EQ(64u, dst_pixels_c[0]);
+    EXPECT_EQ(25u, dst_pixels_c[1]);
+    EXPECT_EQ(13u, dst_pixels_c[2]);
+    EXPECT_EQ(5u, dst_pixels_c[3]);
+    EXPECT_EQ(0u, dst_pixels_c[4]);
+    EXPECT_EQ(133u, dst_pixels_c[63]);
+
+    // Test Odd width version - Last pixel is just 1 horizontal pixel.
+    ScaleRowDown2Box_Odd_C(orig_pixels, 128, dst_pixels_c, 64);
+
+    EXPECT_EQ(64u, dst_pixels_c[0]);
+    EXPECT_EQ(25u, dst_pixels_c[1]);
+    EXPECT_EQ(13u, dst_pixels_c[2]);
+    EXPECT_EQ(5u, dst_pixels_c[3]);
+    EXPECT_EQ(0u, dst_pixels_c[4]);
+    EXPECT_EQ(10u, dst_pixels_c[63]);
+
+    // Test one pixel less, should skip the last pixel.
+    memset(dst_pixels_c, 0, sizeof(dst_pixels_c));
+    ScaleRowDown2Box_Odd_C(orig_pixels, 128, dst_pixels_c, 63);
+
+    EXPECT_EQ(64u, dst_pixels_c[0]);
+    EXPECT_EQ(25u, dst_pixels_c[1]);
+    EXPECT_EQ(13u, dst_pixels_c[2]);
+    EXPECT_EQ(5u, dst_pixels_c[3]);
+    EXPECT_EQ(0u, dst_pixels_c[4]);
+    EXPECT_EQ(0u, dst_pixels_c[63]);
+
+    // Test regular half size SSSE3.
+    ScaleRowDown2Box_SSSE3(orig_pixels, 128, dst_pixels_opt, 64);
+
+    EXPECT_EQ(64u, dst_pixels_opt[0]);
+    EXPECT_EQ(25u, dst_pixels_opt[1]);
+    EXPECT_EQ(13u, dst_pixels_opt[2]);
+    EXPECT_EQ(5u, dst_pixels_opt[3]);
+    EXPECT_EQ(0u, dst_pixels_opt[4]);
+    EXPECT_EQ(133u, dst_pixels_opt[63]);
+
+    // Compare C and SSSE3 match.
+    ScaleRowDown2Box_Odd_C(orig_pixels, 128, dst_pixels_c, 64);
+    ScaleRowDown2Box_Odd_SSSE3(orig_pixels, 128, dst_pixels_opt, 64);
+    for (int i = 0; i < 64; ++i) {
+      EXPECT_EQ(dst_pixels_c[i], dst_pixels_opt[i]);
+    }
+  }
+}
+#endif  // HAS_SCALEROWDOWN2_SSSE3
+
+extern "C" void ScaleRowUp2_16_NEON(const uint16_t* src_ptr,
+                                    ptrdiff_t src_stride,
+                                    uint16_t* dst,
+                                    int dst_width);
+extern "C" void ScaleRowUp2_16_C(const uint16_t* src_ptr,
+                                 ptrdiff_t src_stride,
+                                 uint16_t* dst,
+                                 int dst_width);
+
+TEST_F(LibYUVScaleTest, TestScaleRowUp2_16) {
+  SIMD_ALIGNED(uint16_t orig_pixels[640 * 2 + 1]);  // 2 rows + 1 pixel overrun.
+  SIMD_ALIGNED(uint16_t dst_pixels_opt[1280]);
+  SIMD_ALIGNED(uint16_t dst_pixels_c[1280]);
+
+  memset(orig_pixels, 0, sizeof(orig_pixels));
+  memset(dst_pixels_opt, 1, sizeof(dst_pixels_opt));
+  memset(dst_pixels_c, 2, sizeof(dst_pixels_c));
+
+  for (int i = 0; i < 640 * 2 + 1; ++i) {
+    orig_pixels[i] = i;
+  }
+  ScaleRowUp2_16_C(&orig_pixels[0], 640, &dst_pixels_c[0], 1280);
+  for (int i = 0; i < benchmark_pixels_div1280_; ++i) {
+#if !defined(LIBYUV_DISABLE_NEON) && defined(__aarch64__)
+    int has_neon = TestCpuFlag(kCpuHasNEON);
+    if (has_neon) {
+      ScaleRowUp2_16_NEON(&orig_pixels[0], 640, &dst_pixels_opt[0], 1280);
+    } else {
+      ScaleRowUp2_16_C(&orig_pixels[0], 640, &dst_pixels_opt[0], 1280);
+    }
+#else
+    ScaleRowUp2_16_C(&orig_pixels[0], 640, &dst_pixels_opt[0], 1280);
+#endif
+  }
+
+  for (int i = 0; i < 1280; ++i) {
+    EXPECT_EQ(dst_pixels_c[i], dst_pixels_opt[i]);
+  }
+  EXPECT_EQ(dst_pixels_c[0], (0 * 9 + 1 * 3 + 640 * 3 + 641 * 1 + 8) / 16);
+  EXPECT_EQ(dst_pixels_c[1279], 800);
+}
+
+extern "C" void ScaleRowDown2Box_16_NEON(const uint16_t* src_ptr,
+                                         ptrdiff_t src_stride,
+                                         uint16_t* dst,
+                                         int dst_width);
+
+TEST_F(LibYUVScaleTest, TestScaleRowDown2Box_16) {
+  SIMD_ALIGNED(uint16_t orig_pixels[2560 * 2]);
+  SIMD_ALIGNED(uint16_t dst_pixels_c[1280]);
+  SIMD_ALIGNED(uint16_t dst_pixels_opt[1280]);
+
+  memset(orig_pixels, 0, sizeof(orig_pixels));
+  memset(dst_pixels_c, 1, sizeof(dst_pixels_c));
+  memset(dst_pixels_opt, 2, sizeof(dst_pixels_opt));
+
+  for (int i = 0; i < 2560 * 2; ++i) {
+    orig_pixels[i] = i;
+  }
+  ScaleRowDown2Box_16_C(&orig_pixels[0], 2560, &dst_pixels_c[0], 1280);
+  for (int i = 0; i < benchmark_pixels_div1280_; ++i) {
+#if !defined(LIBYUV_DISABLE_NEON) && defined(__aarch64__)
+    int has_neon = TestCpuFlag(kCpuHasNEON);
+    if (has_neon) {
+      ScaleRowDown2Box_16_NEON(&orig_pixels[0], 2560, &dst_pixels_opt[0], 1280);
+    } else {
+      ScaleRowDown2Box_16_C(&orig_pixels[0], 2560, &dst_pixels_opt[0], 1280);
+    }
+#else
+    ScaleRowDown2Box_16_C(&orig_pixels[0], 2560, &dst_pixels_opt[0], 1280);
+#endif
+  }
+
+  for (int i = 0; i < 1280; ++i) {
+    EXPECT_EQ(dst_pixels_c[i], dst_pixels_opt[i]);
+  }
+
+  EXPECT_EQ(dst_pixels_c[0], (0 + 1 + 2560 + 2561 + 2) / 4);
+  EXPECT_EQ(dst_pixels_c[1279], 3839);
+}
+#endif  // ENABLE_ROW_TESTS
+
+// Test scaling plane with 8 bit C vs 12 bit C and return maximum pixel
+// difference.
+// 0 = exact.
+static int TestPlaneFilter_16(int src_width,
+                              int src_height,
+                              int dst_width,
+                              int dst_height,
+                              FilterMode f,
+                              int benchmark_iterations,
+                              int disable_cpu_flags,
+                              int benchmark_cpu_info) {
+  if (!SizeValid(src_width, src_height, dst_width, dst_height)) {
+    return 0;
+  }
+
+  int i;
+  int64_t src_y_plane_size = (Abs(src_width)) * (Abs(src_height));
+  int src_stride_y = Abs(src_width);
+  int dst_y_plane_size = dst_width * dst_height;
+  int dst_stride_y = dst_width;
+
+  align_buffer_page_end(src_y, src_y_plane_size);
+  align_buffer_page_end(src_y_16, src_y_plane_size * 2);
+  align_buffer_page_end(dst_y_8, dst_y_plane_size);
+  align_buffer_page_end(dst_y_16, dst_y_plane_size * 2);
+  uint16_t* p_src_y_16 = reinterpret_cast<uint16_t*>(src_y_16);
+  uint16_t* p_dst_y_16 = reinterpret_cast<uint16_t*>(dst_y_16);
+
+  MemRandomize(src_y, src_y_plane_size);
+  memset(dst_y_8, 0, dst_y_plane_size);
+  memset(dst_y_16, 1, dst_y_plane_size * 2);
+
+  for (i = 0; i < src_y_plane_size; ++i) {
+    p_src_y_16[i] = src_y[i] & 255;
+  }
+
+  MaskCpuFlags(disable_cpu_flags);  // Disable all CPU optimization.
+  ScalePlane(src_y, src_stride_y, src_width, src_height, dst_y_8, dst_stride_y,
+             dst_width, dst_height, f);
+  MaskCpuFlags(benchmark_cpu_info);  // Enable all CPU optimization.
+
+  for (i = 0; i < benchmark_iterations; ++i) {
+    ScalePlane_16(p_src_y_16, src_stride_y, src_width, src_height, p_dst_y_16,
+                  dst_stride_y, dst_width, dst_height, f);
+  }
+
+  // Expect an exact match.
+  int max_diff = 0;
+  for (i = 0; i < dst_y_plane_size; ++i) {
+    int abs_diff = Abs(dst_y_8[i] - p_dst_y_16[i]);
+    if (abs_diff > max_diff) {
+      max_diff = abs_diff;
+    }
+  }
+
+  free_aligned_buffer_page_end(dst_y_8);
+  free_aligned_buffer_page_end(dst_y_16);
+  free_aligned_buffer_page_end(src_y);
+  free_aligned_buffer_page_end(src_y_16);
+
+  return max_diff;
+}
+
+// The following adjustments in dimensions ensure the scale factor will be
+// exactly achieved.
+// 2 is chroma subsample.
+#define DX(x, nom, denom) static_cast<int>(((Abs(x) / nom + 1) / 2) * nom * 2)
+#define SX(x, nom, denom) static_cast<int>(((x / nom + 1) / 2) * denom * 2)
+
+#define TEST_FACTOR1(name, filter, nom, denom, max_diff)                       \
+  TEST_F(LibYUVScaleTest, DISABLED_##ScalePlaneDownBy##name##_##filter##_16) { \
+    int diff = TestPlaneFilter_16(                                             \
+        SX(benchmark_width_, nom, denom), SX(benchmark_height_, nom, denom),   \
+        DX(benchmark_width_, nom, denom), DX(benchmark_height_, nom, denom),   \
+        kFilter##filter, benchmark_iterations_, disable_cpu_flags_,            \
+        benchmark_cpu_info_);                                                  \
+    EXPECT_LE(diff, max_diff);                                                 \
+  }
+
+// Test a scale factor with all 4 filters.  Expect unfiltered to be exact, but
+// filtering is different fixed point implementations for SSSE3, Neon and C.
+#define TEST_FACTOR(name, nom, denom, boxdiff)      \
+  TEST_FACTOR1(name, None, nom, denom, 0)           \
+  TEST_FACTOR1(name, Linear, nom, denom, boxdiff)   \
+  TEST_FACTOR1(name, Bilinear, nom, denom, boxdiff) \
+  TEST_FACTOR1(name, Box, nom, denom, boxdiff)
+
+TEST_FACTOR(2, 1, 2, 0)
+TEST_FACTOR(4, 1, 4, 0)
+// TEST_FACTOR(8, 1, 8, 0) Disable for benchmark performance.  Takes 90 seconds.
+TEST_FACTOR(3by4, 3, 4, 1)
+TEST_FACTOR(3by8, 3, 8, 1)
+TEST_FACTOR(3, 1, 3, 0)
+#undef TEST_FACTOR1
+#undef TEST_FACTOR
+#undef SX
+#undef DX
+
+TEST_F(LibYUVScaleTest, PlaneTest3x) {
+  const int kSrcStride = 480;
+  const int kDstStride = 160;
+  const int kSize = kSrcStride * 3;
+  align_buffer_page_end(orig_pixels, kSize);
+  for (int i = 0; i < 480 * 3; ++i) {
+    orig_pixels[i] = i;
+  }
+  align_buffer_page_end(dest_pixels, kDstStride);
+
+  int iterations160 = (benchmark_width_ * benchmark_height_ + (160 - 1)) / 160 *
+                      benchmark_iterations_;
+  for (int i = 0; i < iterations160; ++i) {
+    ScalePlane(orig_pixels, kSrcStride, 480, 3, dest_pixels, kDstStride, 160, 1,
+               kFilterBilinear);
+  }
+
+  EXPECT_EQ(225, dest_pixels[0]);
+
+  ScalePlane(orig_pixels, kSrcStride, 480, 3, dest_pixels, kDstStride, 160, 1,
+             kFilterNone);
+
+  EXPECT_EQ(225, dest_pixels[0]);
+
+  free_aligned_buffer_page_end(dest_pixels);
+  free_aligned_buffer_page_end(orig_pixels);
+}
+
+TEST_F(LibYUVScaleTest, PlaneTest4x) {
+  const int kSrcStride = 640;
+  const int kDstStride = 160;
+  const int kSize = kSrcStride * 4;
+  align_buffer_page_end(orig_pixels, kSize);
+  for (int i = 0; i < 640 * 4; ++i) {
+    orig_pixels[i] = i;
+  }
+  align_buffer_page_end(dest_pixels, kDstStride);
+
+  int iterations160 = (benchmark_width_ * benchmark_height_ + (160 - 1)) / 160 *
+                      benchmark_iterations_;
+  for (int i = 0; i < iterations160; ++i) {
+    ScalePlane(orig_pixels, kSrcStride, 640, 4, dest_pixels, kDstStride, 160, 1,
+               kFilterBilinear);
+  }
+
+  EXPECT_EQ(66, dest_pixels[0]);
+
+  ScalePlane(orig_pixels, kSrcStride, 640, 4, dest_pixels, kDstStride, 160, 1,
+             kFilterNone);
+
+  EXPECT_EQ(2, dest_pixels[0]);  // expect the 3rd pixel of the 3rd row
+
+  free_aligned_buffer_page_end(dest_pixels);
+  free_aligned_buffer_page_end(orig_pixels);
+}
+
+// Intent is to test 200x50 to 50x200 but width and height can be parameters.
+TEST_F(LibYUVScaleTest, PlaneTestRotate_None) {
+  const int kSize = benchmark_width_ * benchmark_height_;
+  align_buffer_page_end(orig_pixels, kSize);
+  for (int i = 0; i < kSize; ++i) {
+    orig_pixels[i] = i;
+  }
+  align_buffer_page_end(dest_opt_pixels, kSize);
+  align_buffer_page_end(dest_c_pixels, kSize);
+
+  MaskCpuFlags(disable_cpu_flags_);  // Disable all CPU optimization.
+  ScalePlane(orig_pixels, benchmark_width_, benchmark_width_, benchmark_height_,
+             dest_c_pixels, benchmark_height_, benchmark_height_,
+             benchmark_width_, kFilterNone);
+  MaskCpuFlags(benchmark_cpu_info_);  // Enable all CPU optimization.
+
+  for (int i = 0; i < benchmark_iterations_; ++i) {
+    ScalePlane(orig_pixels, benchmark_width_, benchmark_width_,
+               benchmark_height_, dest_opt_pixels, benchmark_height_,
+               benchmark_height_, benchmark_width_, kFilterNone);
+  }
+
+  for (int i = 0; i < kSize; ++i) {
+    EXPECT_EQ(dest_c_pixels[i], dest_opt_pixels[i]);
+  }
+
+  free_aligned_buffer_page_end(dest_c_pixels);
+  free_aligned_buffer_page_end(dest_opt_pixels);
+  free_aligned_buffer_page_end(orig_pixels);
+}
+
+TEST_F(LibYUVScaleTest, PlaneTestRotate_Bilinear) {
+  const int kSize = benchmark_width_ * benchmark_height_;
+  align_buffer_page_end(orig_pixels, kSize);
+  for (int i = 0; i < kSize; ++i) {
+    orig_pixels[i] = i;
+  }
+  align_buffer_page_end(dest_opt_pixels, kSize);
+  align_buffer_page_end(dest_c_pixels, kSize);
+
+  MaskCpuFlags(disable_cpu_flags_);  // Disable all CPU optimization.
+  ScalePlane(orig_pixels, benchmark_width_, benchmark_width_, benchmark_height_,
+             dest_c_pixels, benchmark_height_, benchmark_height_,
+             benchmark_width_, kFilterBilinear);
+  MaskCpuFlags(benchmark_cpu_info_);  // Enable all CPU optimization.
+
+  for (int i = 0; i < benchmark_iterations_; ++i) {
+    ScalePlane(orig_pixels, benchmark_width_, benchmark_width_,
+               benchmark_height_, dest_opt_pixels, benchmark_height_,
+               benchmark_height_, benchmark_width_, kFilterBilinear);
+  }
+
+  for (int i = 0; i < kSize; ++i) {
+    EXPECT_EQ(dest_c_pixels[i], dest_opt_pixels[i]);
+  }
+
+  free_aligned_buffer_page_end(dest_c_pixels);
+  free_aligned_buffer_page_end(dest_opt_pixels);
+  free_aligned_buffer_page_end(orig_pixels);
+}
+
+// Intent is to test 200x50 to 50x200 but width and height can be parameters.
+TEST_F(LibYUVScaleTest, PlaneTestRotate_Box) {
+  const int kSize = benchmark_width_ * benchmark_height_;
+  align_buffer_page_end(orig_pixels, kSize);
+  for (int i = 0; i < kSize; ++i) {
+    orig_pixels[i] = i;
+  }
+  align_buffer_page_end(dest_opt_pixels, kSize);
+  align_buffer_page_end(dest_c_pixels, kSize);
+
+  MaskCpuFlags(disable_cpu_flags_);  // Disable all CPU optimization.
+  ScalePlane(orig_pixels, benchmark_width_, benchmark_width_, benchmark_height_,
+             dest_c_pixels, benchmark_height_, benchmark_height_,
+             benchmark_width_, kFilterBox);
+  MaskCpuFlags(benchmark_cpu_info_);  // Enable all CPU optimization.
+
+  for (int i = 0; i < benchmark_iterations_; ++i) {
+    ScalePlane(orig_pixels, benchmark_width_, benchmark_width_,
+               benchmark_height_, dest_opt_pixels, benchmark_height_,
+               benchmark_height_, benchmark_width_, kFilterBox);
+  }
+
+  for (int i = 0; i < kSize; ++i) {
+    EXPECT_EQ(dest_c_pixels[i], dest_opt_pixels[i]);
+  }
+
+  free_aligned_buffer_page_end(dest_c_pixels);
+  free_aligned_buffer_page_end(dest_opt_pixels);
+  free_aligned_buffer_page_end(orig_pixels);
+}
+
+TEST_F(LibYUVScaleTest, PlaneTest1_Box) {
+  align_buffer_page_end(orig_pixels, 3);
+  align_buffer_page_end(dst_pixels, 3);
+
+  // Pad the 1x1 byte image with invalid values before and after in case libyuv
+  // reads outside the memory boundaries.
+  orig_pixels[0] = 0;
+  orig_pixels[1] = 1;  // scale this pixel
+  orig_pixels[2] = 2;
+  dst_pixels[0] = 3;
+  dst_pixels[1] = 3;
+  dst_pixels[2] = 3;
+
+  libyuv::ScalePlane(orig_pixels + 1, /* src_stride= */ 1, /* src_width= */ 1,
+                     /* src_height= */ 1, dst_pixels, /* dst_stride= */ 1,
+                     /* dst_width= */ 1, /* dst_height= */ 2,
+                     libyuv::kFilterBox);
+
+  EXPECT_EQ(dst_pixels[0], 1);
+  EXPECT_EQ(dst_pixels[1], 1);
+  EXPECT_EQ(dst_pixels[2], 3);
+
+  free_aligned_buffer_page_end(dst_pixels);
+  free_aligned_buffer_page_end(orig_pixels);
+}
+
+TEST_F(LibYUVScaleTest, PlaneTest1_16_Box) {
+  align_buffer_page_end(orig_pixels_alloc, 3 * 2);
+  align_buffer_page_end(dst_pixels_alloc, 3 * 2);
+  uint16_t* orig_pixels = (uint16_t*)orig_pixels_alloc;
+  uint16_t* dst_pixels = (uint16_t*)dst_pixels_alloc;
+
+  // Pad the 1x1 byte image with invalid values before and after in case libyuv
+  // reads outside the memory boundaries.
+  orig_pixels[0] = 0;
+  orig_pixels[1] = 1;  // scale this pixel
+  orig_pixels[2] = 2;
+  dst_pixels[0] = 3;
+  dst_pixels[1] = 3;
+  dst_pixels[2] = 3;
+
+  libyuv::ScalePlane_16(
+      orig_pixels + 1, /* src_stride= */ 1, /* src_width= */ 1,
+      /* src_height= */ 1, dst_pixels, /* dst_stride= */ 1,
+      /* dst_width= */ 1, /* dst_height= */ 2, libyuv::kFilterNone);
+
+  EXPECT_EQ(dst_pixels[0], 1);
+  EXPECT_EQ(dst_pixels[1], 1);
+  EXPECT_EQ(dst_pixels[2], 3);
+
+  free_aligned_buffer_page_end(dst_pixels_alloc);
+  free_aligned_buffer_page_end(orig_pixels_alloc);
+}
+}  // namespace libyuv
diff --git a/3rdparty/libyuv/src/unit_test/scale_uv_test.cc b/3rdparty/libyuv/src/unit_test/scale_uv_test.cc
new file mode 100644
index 00000000..a185fb63
--- /dev/null
+++ b/3rdparty/libyuv/src/unit_test/scale_uv_test.cc
@@ -0,0 +1,278 @@
+/*
+ *  Copyright 2011 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include <stdlib.h>
+#include <time.h>
+
+#include "../unit_test/unit_test.h"
+#include "libyuv/cpu_id.h"
+#include "libyuv/scale_uv.h"
+
+namespace libyuv {
+
+#define STRINGIZE(line) #line
+#define FILELINESTR(file, line) file ":" STRINGIZE(line)
+
+#if !defined(DISABLE_SLOW_TESTS) || defined(__x86_64__) || defined(__i386__)
+// SLOW TESTS are those that are unoptimized C code.
+// FULL TESTS are optimized but test many variations of the same code.
+#define ENABLE_FULL_TESTS
+#endif
+
+// Test scaling with C vs Opt and return maximum pixel difference. 0 = exact.
+static int UVTestFilter(int src_width,
+                        int src_height,
+                        int dst_width,
+                        int dst_height,
+                        FilterMode f,
+                        int benchmark_iterations,
+                        int disable_cpu_flags,
+                        int benchmark_cpu_info) {
+  if (!SizeValid(src_width, src_height, dst_width, dst_height)) {
+    return 0;
+  }
+
+  int i, j;
+  const int b = 0;  // 128 to test for padding/stride.
+  int64_t src_uv_plane_size =
+      (Abs(src_width) + b * 2) * (Abs(src_height) + b * 2) * 2LL;
+  int src_stride_uv = (b * 2 + Abs(src_width)) * 2;
+
+  align_buffer_page_end(src_uv, src_uv_plane_size);
+  if (!src_uv) {
+    printf("Skipped.  Alloc failed " FILELINESTR(__FILE__, __LINE__) "\n");
+    return 0;
+  }
+  MemRandomize(src_uv, src_uv_plane_size);
+
+  int64_t dst_uv_plane_size = (dst_width + b * 2) * (dst_height + b * 2) * 2LL;
+  int dst_stride_uv = (b * 2 + dst_width) * 2;
+
+  align_buffer_page_end(dst_uv_c, dst_uv_plane_size);
+  align_buffer_page_end(dst_uv_opt, dst_uv_plane_size);
+  if (!dst_uv_c || !dst_uv_opt) {
+    printf("Skipped.  Alloc failed " FILELINESTR(__FILE__, __LINE__) "\n");
+    return 0;
+  }
+  memset(dst_uv_c, 2, dst_uv_plane_size);
+  memset(dst_uv_opt, 3, dst_uv_plane_size);
+
+  // Warm up both versions for consistent benchmarks.
+  MaskCpuFlags(disable_cpu_flags);  // Disable all CPU optimization.
+  UVScale(src_uv + (src_stride_uv * b) + b * 2, src_stride_uv, src_width,
+          src_height, dst_uv_c + (dst_stride_uv * b) + b * 2, dst_stride_uv,
+          dst_width, dst_height, f);
+  MaskCpuFlags(benchmark_cpu_info);  // Enable all CPU optimization.
+  UVScale(src_uv + (src_stride_uv * b) + b * 2, src_stride_uv, src_width,
+          src_height, dst_uv_opt + (dst_stride_uv * b) + b * 2, dst_stride_uv,
+          dst_width, dst_height, f);
+
+  MaskCpuFlags(disable_cpu_flags);  // Disable all CPU optimization.
+  double c_time = get_time();
+  UVScale(src_uv + (src_stride_uv * b) + b * 2, src_stride_uv, src_width,
+          src_height, dst_uv_c + (dst_stride_uv * b) + b * 2, dst_stride_uv,
+          dst_width, dst_height, f);
+
+  c_time = (get_time() - c_time);
+
+  MaskCpuFlags(benchmark_cpu_info);  // Enable all CPU optimization.
+  double opt_time = get_time();
+  for (i = 0; i < benchmark_iterations; ++i) {
+    UVScale(src_uv + (src_stride_uv * b) + b * 2, src_stride_uv, src_width,
+            src_height, dst_uv_opt + (dst_stride_uv * b) + b * 2, dst_stride_uv,
+            dst_width, dst_height, f);
+  }
+  opt_time = (get_time() - opt_time) / benchmark_iterations;
+
+  // Report performance of C vs OPT
+  printf("filter %d - %8d us C - %8d us OPT\n", f,
+         static_cast<int>(c_time * 1e6), static_cast<int>(opt_time * 1e6));
+
+  // C version may be a little off from the optimized. Order of
+  //  operations may introduce rounding somewhere. So do a difference
+  //  of the buffers and look to see that the max difference isn't
+  //  over 2.
+  int max_diff = 0;
+  for (i = b; i < (dst_height + b); ++i) {
+    for (j = b * 2; j < (dst_width + b) * 2; ++j) {
+      int abs_diff = Abs(dst_uv_c[(i * dst_stride_uv) + j] -
+                         dst_uv_opt[(i * dst_stride_uv) + j]);
+      if (abs_diff > max_diff) {
+        max_diff = abs_diff;
+      }
+    }
+  }
+
+  free_aligned_buffer_page_end(dst_uv_c);
+  free_aligned_buffer_page_end(dst_uv_opt);
+  free_aligned_buffer_page_end(src_uv);
+  return max_diff;
+}
+
+// The following adjustments in dimensions ensure the scale factor will be
+// exactly achieved.
+#define DX(x, nom, denom) static_cast<int>((Abs(x) / nom) * nom)
+#define SX(x, nom, denom) static_cast<int>((x / nom) * denom)
+
+#define TEST_FACTOR1(name, filter, nom, denom, max_diff)                     \
+  TEST_F(LibYUVScaleTest, UVScaleDownBy##name##_##filter) {                  \
+    int diff = UVTestFilter(                                                 \
+        SX(benchmark_width_, nom, denom), SX(benchmark_height_, nom, denom), \
+        DX(benchmark_width_, nom, denom), DX(benchmark_height_, nom, denom), \
+        kFilter##filter, benchmark_iterations_, disable_cpu_flags_,          \
+        benchmark_cpu_info_);                                                \
+    EXPECT_LE(diff, max_diff);                                               \
+  }
+
+#if defined(ENABLE_FULL_TESTS)
+// Test a scale factor with all 4 filters.  Expect unfiltered to be exact, but
+// filtering is different fixed point implementations for SSSE3, Neon and C.
+#define TEST_FACTOR(name, nom, denom)         \
+  TEST_FACTOR1(name, None, nom, denom, 0)     \
+  TEST_FACTOR1(name, Linear, nom, denom, 3)   \
+  TEST_FACTOR1(name, Bilinear, nom, denom, 3) \
+  TEST_FACTOR1(name, Box, nom, denom, 3)
+#else
+// Test a scale factor with Bilinear.
+#define TEST_FACTOR(name, nom, denom) \
+  TEST_FACTOR1(name, Bilinear, nom, denom, 3)
+#endif
+
+TEST_FACTOR(2, 1, 2)
+TEST_FACTOR(4, 1, 4)
+// TEST_FACTOR(8, 1, 8)  Disable for benchmark performance.
+TEST_FACTOR(3by4, 3, 4)
+TEST_FACTOR(3by8, 3, 8)
+TEST_FACTOR(3, 1, 3)
+#undef TEST_FACTOR1
+#undef TEST_FACTOR
+#undef SX
+#undef DX
+
+#define TEST_SCALETO1(name, width, height, filter, max_diff)                \
+  TEST_F(LibYUVScaleTest, name##To##width##x##height##_##filter) {          \
+    int diff = UVTestFilter(benchmark_width_, benchmark_height_, width,     \
+                            height, kFilter##filter, benchmark_iterations_, \
+                            disable_cpu_flags_, benchmark_cpu_info_);       \
+    EXPECT_LE(diff, max_diff);                                              \
+  }                                                                         \
+  TEST_F(LibYUVScaleTest, name##From##width##x##height##_##filter) {        \
+    int diff = UVTestFilter(width, height, Abs(benchmark_width_),           \
+                            Abs(benchmark_height_), kFilter##filter,        \
+                            benchmark_iterations_, disable_cpu_flags_,      \
+                            benchmark_cpu_info_);                           \
+    EXPECT_LE(diff, max_diff);                                              \
+  }
+
+#if defined(ENABLE_FULL_TESTS)
+/// Test scale to a specified size with all 4 filters.
+#define TEST_SCALETO(name, width, height)       \
+  TEST_SCALETO1(name, width, height, None, 0)   \
+  TEST_SCALETO1(name, width, height, Linear, 3) \
+  TEST_SCALETO1(name, width, height, Bilinear, 3)
+#else
+#define TEST_SCALETO(name, width, height) \
+  TEST_SCALETO1(name, width, height, Bilinear, 3)
+#endif
+
+TEST_SCALETO(UVScale, 1, 1)
+// TEST_SCALETO(UVScale, 256, 144) /* 128x72 * 2 */
+TEST_SCALETO(UVScale, 320, 240)
+TEST_SCALETO(UVScale, 569, 480)
+TEST_SCALETO(UVScale, 640, 360)
+#ifndef DISABLE_SLOW_TESTS
+TEST_SCALETO(UVScale, 1280, 720)
+TEST_SCALETO(UVScale, 1920, 1080)
+#endif  // DISABLE_SLOW_TESTS
+#undef TEST_SCALETO1
+#undef TEST_SCALETO
+
+#define TEST_SCALESWAPXY1(name, filter, max_diff)                              \
+  TEST_F(LibYUVScaleTest, name##SwapXY_##filter) {                             \
+    int diff =                                                                 \
+        UVTestFilter(benchmark_width_, benchmark_height_, benchmark_height_,   \
+                     benchmark_width_, kFilter##filter, benchmark_iterations_, \
+                     disable_cpu_flags_, benchmark_cpu_info_);                 \
+    EXPECT_LE(diff, max_diff);                                                 \
+  }
+
+#if defined(ENABLE_FULL_TESTS)
+// Test scale with swapped width and height with all 3 filters.
+TEST_SCALESWAPXY1(UVScale, None, 0)
+TEST_SCALESWAPXY1(UVScale, Linear, 0)
+TEST_SCALESWAPXY1(UVScale, Bilinear, 0)
+#else
+TEST_SCALESWAPXY1(UVScale, Bilinear, 0)
+#endif
+#undef TEST_SCALESWAPXY1
+
+TEST_F(LibYUVScaleTest, UVTest3x) {
+  const int kSrcStride = 480 * 2;
+  const int kDstStride = 160 * 2;
+  const int kSize = kSrcStride * 3;
+  align_buffer_page_end(orig_pixels, kSize);
+  for (int i = 0; i < 480 * 3; ++i) {
+    orig_pixels[i * 2 + 0] = i;
+    orig_pixels[i * 2 + 1] = 255 - i;
+  }
+  align_buffer_page_end(dest_pixels, kDstStride);
+
+  int iterations160 = (benchmark_width_ * benchmark_height_ + (160 - 1)) / 160 *
+                      benchmark_iterations_;
+  for (int i = 0; i < iterations160; ++i) {
+    UVScale(orig_pixels, kSrcStride, 480, 3, dest_pixels, kDstStride, 160, 1,
+            kFilterBilinear);
+  }
+
+  EXPECT_EQ(225, dest_pixels[0]);
+  EXPECT_EQ(255 - 225, dest_pixels[1]);
+
+  UVScale(orig_pixels, kSrcStride, 480, 3, dest_pixels, kDstStride, 160, 1,
+          kFilterNone);
+
+  EXPECT_EQ(225, dest_pixels[0]);
+  EXPECT_EQ(255 - 225, dest_pixels[1]);
+
+  free_aligned_buffer_page_end(dest_pixels);
+  free_aligned_buffer_page_end(orig_pixels);
+}
+
+TEST_F(LibYUVScaleTest, UVTest4x) {
+  const int kSrcStride = 640 * 2;
+  const int kDstStride = 160 * 2;
+  const int kSize = kSrcStride * 4;
+  align_buffer_page_end(orig_pixels, kSize);
+  for (int i = 0; i < 640 * 4; ++i) {
+    orig_pixels[i * 2 + 0] = i;
+    orig_pixels[i * 2 + 1] = 255 - i;
+  }
+  align_buffer_page_end(dest_pixels, kDstStride);
+
+  int iterations160 = (benchmark_width_ * benchmark_height_ + (160 - 1)) / 160 *
+                      benchmark_iterations_;
+  for (int i = 0; i < iterations160; ++i) {
+    UVScale(orig_pixels, kSrcStride, 640, 4, dest_pixels, kDstStride, 160, 1,
+            kFilterBilinear);
+  }
+
+  EXPECT_EQ(66, dest_pixels[0]);
+  EXPECT_EQ(190, dest_pixels[1]);
+
+  UVScale(orig_pixels, kSrcStride, 64, 4, dest_pixels, kDstStride, 16, 1,
+          kFilterNone);
+
+  EXPECT_EQ(2, dest_pixels[0]);  // expect the 3rd pixel of the 3rd row
+  EXPECT_EQ(255 - 2, dest_pixels[1]);
+
+  free_aligned_buffer_page_end(dest_pixels);
+  free_aligned_buffer_page_end(orig_pixels);
+}
+
+}  // namespace libyuv
diff --git a/3rdparty/libyuv/src/unit_test/testdata/arm_v7.txt b/3rdparty/libyuv/src/unit_test/testdata/arm_v7.txt
new file mode 100644
index 00000000..5d7dbd04
--- /dev/null
+++ b/3rdparty/libyuv/src/unit_test/testdata/arm_v7.txt
@@ -0,0 +1,12 @@
+Processor	: ARMv7 Processor rev 5 (v7l)
+BogoMIPS	: 795.44
+Features	: swp half thumb fastmult vfp edsp iwmmxt thumbee vfpv3 vfpv3d16 
+CPU implementer	: 0x56
+CPU architecture: 7
+CPU variant	: 0x0
+CPU part	: 0x581
+CPU revision	: 5
+
+Hardware	: OLPC XO-1.75
+Revision	: 0000
+Serial		: 0000000000000000
diff --git a/3rdparty/libyuv/src/unit_test/testdata/juno.txt b/3rdparty/libyuv/src/unit_test/testdata/juno.txt
new file mode 100644
index 00000000..dd465272
--- /dev/null
+++ b/3rdparty/libyuv/src/unit_test/testdata/juno.txt
@@ -0,0 +1,15 @@
+Processor       : AArch64 Processor rev 0 (aarch64)
+processor       : 0
+processor       : 1
+processor       : 2
+processor       : 3
+processor       : 4
+processor       : 5
+Features        : fp asimd evtstrm aes pmull sha1 sha2 crc32
+CPU implementer : 0x41
+CPU architecture: AArch64
+CPU variant     : 0x0
+CPU part        : 0xd07
+CPU revision    : 0
+
+Hardware        : Juno
diff --git a/3rdparty/libyuv/src/unit_test/testdata/mips.txt b/3rdparty/libyuv/src/unit_test/testdata/mips.txt
new file mode 100644
index 00000000..d9f28cbf
--- /dev/null
+++ b/3rdparty/libyuv/src/unit_test/testdata/mips.txt
@@ -0,0 +1,7 @@
+system type             : generic-loongson-machine
+machine                 : loongson,generic
+processor               : 0
+
+isa                     : mips1 mips2 mips3 mips4 mips5 mips32r1 mips32r2 mips64r1 mips64r2
+ASEs implemented        : vz
+shadow register sets    : 1
diff --git a/3rdparty/libyuv/src/unit_test/testdata/mips_loongson2k.txt b/3rdparty/libyuv/src/unit_test/testdata/mips_loongson2k.txt
new file mode 100644
index 00000000..8a88d38f
--- /dev/null
+++ b/3rdparty/libyuv/src/unit_test/testdata/mips_loongson2k.txt
@@ -0,0 +1,5 @@
+system type		: Loongson2K-SBC
+machine			: loongson,LS2k1000-EVP
+processor		: 0
+cpu model		: Loongson-2K V0.3  FPU V0.1
+BogoMIPS		: 1980.41
diff --git a/3rdparty/libyuv/src/unit_test/testdata/mips_loongson3.txt b/3rdparty/libyuv/src/unit_test/testdata/mips_loongson3.txt
new file mode 100644
index 00000000..1f540b12
--- /dev/null
+++ b/3rdparty/libyuv/src/unit_test/testdata/mips_loongson3.txt
@@ -0,0 +1,10 @@
+system type		: generic-loongson-machine
+machine			: Unknown
+processor		: 0
+cpu model		: ICT Loongson-3 V0.9  FPU V0.1
+model name		: ICT Loongson-3A R3 (Loongson-3A3000) @ 1500MHz
+BogoMIPS		: 2990.15
+
+isa			: mips1 mips2 mips3 mips4 mips5 mips32r1 mips32r2 mips64r1 mips64r2
+ASEs implemented	: dsp dsp2 vz
+shadow register sets	: 1
diff --git a/3rdparty/libyuv/src/unit_test/testdata/mips_loongson_mmi.txt b/3rdparty/libyuv/src/unit_test/testdata/mips_loongson_mmi.txt
new file mode 100644
index 00000000..0f10b8bb
--- /dev/null
+++ b/3rdparty/libyuv/src/unit_test/testdata/mips_loongson_mmi.txt
@@ -0,0 +1,7 @@
+system type             : generic-loongson-machine
+machine                 : loongson,generic
+processor               : 0
+
+isa                     : mips1 mips2 mips3 mips4 mips5 mips32r1 mips32r2 mips64r1 mips64r2
+ASEs implemented        : vz loongson-mmi loongson-ext
+shadow register sets    : 1
diff --git a/3rdparty/libyuv/src/unit_test/testdata/mips_msa.txt b/3rdparty/libyuv/src/unit_test/testdata/mips_msa.txt
new file mode 100644
index 00000000..ac930615
--- /dev/null
+++ b/3rdparty/libyuv/src/unit_test/testdata/mips_msa.txt
@@ -0,0 +1,7 @@
+system type             : generic-loongson-machine
+machine                 : loongson,generic
+processor               : 0
+
+isa                     : mips1 mips2 mips3 mips4 mips5 mips32r1 mips32r2 mips64r1 mips64r2
+ASEs implemented        : vz msa
+shadow register sets    : 1
diff --git a/3rdparty/libyuv/src/unit_test/testdata/tegra3.txt b/3rdparty/libyuv/src/unit_test/testdata/tegra3.txt
new file mode 100644
index 00000000..d1b09f6b
--- /dev/null
+++ b/3rdparty/libyuv/src/unit_test/testdata/tegra3.txt
@@ -0,0 +1,23 @@
+Processor       : ARMv7 Processor rev 9 (v7l)
+processor       : 0
+BogoMIPS        : 1992.29
+
+processor       : 1
+BogoMIPS        : 1992.29
+
+processor       : 2
+BogoMIPS        : 1992.29
+
+processor       : 3
+BogoMIPS        : 1992.29
+
+Features        : swp half thumb fastmult vfp edsp neon vfpv3
+CPU implementer : 0�41
+CPU architecture: 7
+CPU variant     : 0�2
+CPU part        : 0xc09
+CPU revision    : 9
+
+Hardware        : cardhu
+Revision        : 0000
+
diff --git a/3rdparty/libyuv/src/unit_test/testdata/test0.jpg b/3rdparty/libyuv/src/unit_test/testdata/test0.jpg
new file mode 100644
index 00000000..f4461a81
Binary files /dev/null and b/3rdparty/libyuv/src/unit_test/testdata/test0.jpg differ
diff --git a/3rdparty/libyuv/src/unit_test/testdata/test1.jpg b/3rdparty/libyuv/src/unit_test/testdata/test1.jpg
new file mode 100644
index 00000000..a0210e9d
Binary files /dev/null and b/3rdparty/libyuv/src/unit_test/testdata/test1.jpg differ
diff --git a/3rdparty/libyuv/src/unit_test/testdata/test2.jpg b/3rdparty/libyuv/src/unit_test/testdata/test2.jpg
new file mode 100644
index 00000000..816ca767
Binary files /dev/null and b/3rdparty/libyuv/src/unit_test/testdata/test2.jpg differ
diff --git a/3rdparty/libyuv/src/unit_test/testdata/test3.jpg b/3rdparty/libyuv/src/unit_test/testdata/test3.jpg
new file mode 100644
index 00000000..792d91dc
Binary files /dev/null and b/3rdparty/libyuv/src/unit_test/testdata/test3.jpg differ
diff --git a/3rdparty/libyuv/src/unit_test/testdata/test4.jpg b/3rdparty/libyuv/src/unit_test/testdata/test4.jpg
new file mode 100644
index 00000000..1ef41668
Binary files /dev/null and b/3rdparty/libyuv/src/unit_test/testdata/test4.jpg differ
diff --git a/3rdparty/libyuv/src/unit_test/unit_test.cc b/3rdparty/libyuv/src/unit_test/unit_test.cc
new file mode 100644
index 00000000..61145a46
--- /dev/null
+++ b/3rdparty/libyuv/src/unit_test/unit_test.cc
@@ -0,0 +1,557 @@
+/*
+ *  Copyright 2011 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include "../unit_test/unit_test.h"
+
+#include <stdlib.h>  // For getenv()
+
+#include <cstring>
+
+#ifdef LIBYUV_USE_ABSL_FLAGS
+#include "absl/flags/flag.h"
+#include "absl/flags/parse.h"
+#endif
+#include "libyuv/cpu_id.h"
+
+unsigned int fastrand_seed = 0xfb;
+
+#ifdef LIBYUV_USE_ABSL_FLAGS
+ABSL_FLAG(int32_t, libyuv_width, 0, "width of test image.");
+ABSL_FLAG(int32_t, libyuv_height, 0, "height of test image.");
+ABSL_FLAG(int32_t, libyuv_repeat, 0, "number of times to repeat test.");
+ABSL_FLAG(int32_t,
+          libyuv_flags,
+          0,
+          "cpu flags for reference code. 1 = C, -1 = SIMD");
+ABSL_FLAG(int32_t,
+          libyuv_cpu_info,
+          0,
+          "cpu flags for benchmark code. 1 = C, -1 = SIMD");
+#else
+// Disable command line parameters if absl/flags disabled.
+static const int32_t FLAGS_libyuv_width = 0;
+static const int32_t FLAGS_libyuv_height = 0;
+static const int32_t FLAGS_libyuv_repeat = 0;
+static const int32_t FLAGS_libyuv_flags = 0;
+static const int32_t FLAGS_libyuv_cpu_info = 0;
+#endif
+
+#ifdef LIBYUV_USE_ABSL_FLAGS
+#define LIBYUV_GET_FLAG(f) absl::GetFlag(f)
+#else
+#define LIBYUV_GET_FLAG(f) f
+#endif
+
+// Test environment variable for disabling CPU features. Any non-zero value
+// to disable. Zero ignored to make it easy to set the variable on/off.
+#if !defined(__native_client__) && !defined(_M_ARM)
+static LIBYUV_BOOL TestEnv(const char* name) {
+  const char* var = getenv(name);
+  if (var) {
+    if (var[0] != '0') {
+      return LIBYUV_TRUE;
+    }
+  }
+  return LIBYUV_FALSE;
+}
+#else  // nacl does not support getenv().
+static LIBYUV_BOOL TestEnv(const char*) {
+  return LIBYUV_FALSE;
+}
+#endif
+
+int TestCpuEnv(int cpu_info) {
+#if defined(__arm__) || defined(__aarch64__)
+  if (TestEnv("LIBYUV_DISABLE_NEON")) {
+    cpu_info &= ~libyuv::kCpuHasNEON;
+  }
+#endif
+#if defined(__mips__) && defined(__linux__)
+  if (TestEnv("LIBYUV_DISABLE_MSA")) {
+    cpu_info &= ~libyuv::kCpuHasMSA;
+  }
+#endif
+#if defined(__longarch__) && defined(__linux__)
+  if (TestEnv("LIBYUV_DISABLE_LSX")) {
+    cpu_info &= ~libyuv::kCpuHasLSX;
+  }
+#endif
+#if defined(__longarch__) && defined(__linux__)
+  if (TestEnv("LIBYUV_DISABLE_LASX")) {
+    cpu_info &= ~libyuv::kCpuHasLASX;
+  }
+#endif
+#if !defined(__pnacl__) && !defined(__CLR_VER) &&                   \
+    (defined(__x86_64__) || defined(_M_X64) || defined(__i386__) || \
+     defined(_M_IX86))
+  if (TestEnv("LIBYUV_DISABLE_X86")) {
+    cpu_info &= ~libyuv::kCpuHasX86;
+  }
+  if (TestEnv("LIBYUV_DISABLE_SSE2")) {
+    cpu_info &= ~libyuv::kCpuHasSSE2;
+  }
+  if (TestEnv("LIBYUV_DISABLE_SSSE3")) {
+    cpu_info &= ~libyuv::kCpuHasSSSE3;
+  }
+  if (TestEnv("LIBYUV_DISABLE_SSE41")) {
+    cpu_info &= ~libyuv::kCpuHasSSE41;
+  }
+  if (TestEnv("LIBYUV_DISABLE_SSE42")) {
+    cpu_info &= ~libyuv::kCpuHasSSE42;
+  }
+  if (TestEnv("LIBYUV_DISABLE_AVX")) {
+    cpu_info &= ~libyuv::kCpuHasAVX;
+  }
+  if (TestEnv("LIBYUV_DISABLE_AVX2")) {
+    cpu_info &= ~libyuv::kCpuHasAVX2;
+  }
+  if (TestEnv("LIBYUV_DISABLE_ERMS")) {
+    cpu_info &= ~libyuv::kCpuHasERMS;
+  }
+  if (TestEnv("LIBYUV_DISABLE_FMA3")) {
+    cpu_info &= ~libyuv::kCpuHasFMA3;
+  }
+  if (TestEnv("LIBYUV_DISABLE_F16C")) {
+    cpu_info &= ~libyuv::kCpuHasF16C;
+  }
+  if (TestEnv("LIBYUV_DISABLE_AVX512BW")) {
+    cpu_info &= ~libyuv::kCpuHasAVX512BW;
+  }
+  if (TestEnv("LIBYUV_DISABLE_AVX512VL")) {
+    cpu_info &= ~libyuv::kCpuHasAVX512VL;
+  }
+  if (TestEnv("LIBYUV_DISABLE_AVX512VNNI")) {
+    cpu_info &= ~libyuv::kCpuHasAVX512VNNI;
+  }
+  if (TestEnv("LIBYUV_DISABLE_AVX512VBMI")) {
+    cpu_info &= ~libyuv::kCpuHasAVX512VBMI;
+  }
+  if (TestEnv("LIBYUV_DISABLE_AVX512VBMI2")) {
+    cpu_info &= ~libyuv::kCpuHasAVX512VBMI2;
+  }
+  if (TestEnv("LIBYUV_DISABLE_AVX512VBITALG")) {
+    cpu_info &= ~libyuv::kCpuHasAVX512VBITALG;
+  }
+  if (TestEnv("LIBYUV_DISABLE_AVX512VPOPCNTDQ")) {
+    cpu_info &= ~libyuv::kCpuHasAVX512VPOPCNTDQ;
+  }
+  if (TestEnv("LIBYUV_DISABLE_GFNI")) {
+    cpu_info &= ~libyuv::kCpuHasGFNI;
+  }
+#endif
+  if (TestEnv("LIBYUV_DISABLE_ASM")) {
+    cpu_info = libyuv::kCpuInitialized;
+  }
+  return cpu_info;
+}
+
+// For quicker unittests, default is 128 x 72.  But when benchmarking,
+// default to 720p.  Allow size to specify.
+// Set flags to -1 for benchmarking to avoid slower C code.
+
+LibYUVConvertTest::LibYUVConvertTest()
+    : benchmark_iterations_(1),
+      benchmark_width_(128),
+      benchmark_height_(72),
+      disable_cpu_flags_(1),
+      benchmark_cpu_info_(-1) {
+  const char* repeat = getenv("LIBYUV_REPEAT");
+  if (repeat) {
+    benchmark_iterations_ = atoi(repeat);  // NOLINT
+  }
+  if (LIBYUV_GET_FLAG(FLAGS_libyuv_repeat)) {
+    benchmark_iterations_ = LIBYUV_GET_FLAG(FLAGS_libyuv_repeat);
+  }
+  if (benchmark_iterations_ > 1) {
+    benchmark_width_ = 1280;
+    benchmark_height_ = 720;
+  }
+  const char* width = getenv("LIBYUV_WIDTH");
+  if (width) {
+    benchmark_width_ = atoi(width);  // NOLINT
+  }
+  if (LIBYUV_GET_FLAG(FLAGS_libyuv_width)) {
+    benchmark_width_ = LIBYUV_GET_FLAG(FLAGS_libyuv_width);
+  }
+  const char* height = getenv("LIBYUV_HEIGHT");
+  if (height) {
+    benchmark_height_ = atoi(height);  // NOLINT
+  }
+  if (LIBYUV_GET_FLAG(FLAGS_libyuv_height)) {
+    benchmark_height_ = LIBYUV_GET_FLAG(FLAGS_libyuv_height);
+  }
+  const char* cpu_flags = getenv("LIBYUV_FLAGS");
+  if (cpu_flags) {
+    disable_cpu_flags_ = atoi(cpu_flags);  // NOLINT
+  }
+  if (LIBYUV_GET_FLAG(FLAGS_libyuv_flags)) {
+    disable_cpu_flags_ = LIBYUV_GET_FLAG(FLAGS_libyuv_flags);
+  }
+  const char* cpu_info = getenv("LIBYUV_CPU_INFO");
+  if (cpu_info) {
+    benchmark_cpu_info_ = atoi(cpu_flags);  // NOLINT
+  }
+  if (LIBYUV_GET_FLAG(FLAGS_libyuv_cpu_info)) {
+    benchmark_cpu_info_ = LIBYUV_GET_FLAG(FLAGS_libyuv_cpu_info);
+  }
+  disable_cpu_flags_ = TestCpuEnv(disable_cpu_flags_);
+  benchmark_cpu_info_ = TestCpuEnv(benchmark_cpu_info_);
+  libyuv::MaskCpuFlags(benchmark_cpu_info_);
+  benchmark_pixels_div1280_ =
+      static_cast<int>((static_cast<double>(Abs(benchmark_width_)) *
+                            static_cast<double>(Abs(benchmark_height_)) *
+                            static_cast<double>(benchmark_iterations_) +
+                        1279.0) /
+                       1280.0);
+}
+
+LibYUVColorTest::LibYUVColorTest()
+    : benchmark_iterations_(1),
+      benchmark_width_(128),
+      benchmark_height_(72),
+      disable_cpu_flags_(1),
+      benchmark_cpu_info_(-1) {
+  const char* repeat = getenv("LIBYUV_REPEAT");
+  if (repeat) {
+    benchmark_iterations_ = atoi(repeat);  // NOLINT
+  }
+  if (LIBYUV_GET_FLAG(FLAGS_libyuv_repeat)) {
+    benchmark_iterations_ = LIBYUV_GET_FLAG(FLAGS_libyuv_repeat);
+  }
+  if (benchmark_iterations_ > 1) {
+    benchmark_width_ = 1280;
+    benchmark_height_ = 720;
+  }
+  const char* width = getenv("LIBYUV_WIDTH");
+  if (width) {
+    benchmark_width_ = atoi(width);  // NOLINT
+  }
+  if (LIBYUV_GET_FLAG(FLAGS_libyuv_width)) {
+    benchmark_width_ = LIBYUV_GET_FLAG(FLAGS_libyuv_width);
+  }
+  const char* height = getenv("LIBYUV_HEIGHT");
+  if (height) {
+    benchmark_height_ = atoi(height);  // NOLINT
+  }
+  if (LIBYUV_GET_FLAG(FLAGS_libyuv_height)) {
+    benchmark_height_ = LIBYUV_GET_FLAG(FLAGS_libyuv_height);
+  }
+  const char* cpu_flags = getenv("LIBYUV_FLAGS");
+  if (cpu_flags) {
+    disable_cpu_flags_ = atoi(cpu_flags);  // NOLINT
+  }
+  if (LIBYUV_GET_FLAG(FLAGS_libyuv_flags)) {
+    disable_cpu_flags_ = LIBYUV_GET_FLAG(FLAGS_libyuv_flags);
+  }
+  const char* cpu_info = getenv("LIBYUV_CPU_INFO");
+  if (cpu_info) {
+    benchmark_cpu_info_ = atoi(cpu_flags);  // NOLINT
+  }
+  if (LIBYUV_GET_FLAG(FLAGS_libyuv_cpu_info)) {
+    benchmark_cpu_info_ = LIBYUV_GET_FLAG(FLAGS_libyuv_cpu_info);
+  }
+  disable_cpu_flags_ = TestCpuEnv(disable_cpu_flags_);
+  benchmark_cpu_info_ = TestCpuEnv(benchmark_cpu_info_);
+  libyuv::MaskCpuFlags(benchmark_cpu_info_);
+  benchmark_pixels_div1280_ =
+      static_cast<int>((static_cast<double>(Abs(benchmark_width_)) *
+                            static_cast<double>(Abs(benchmark_height_)) *
+                            static_cast<double>(benchmark_iterations_) +
+                        1279.0) /
+                       1280.0);
+}
+
+LibYUVScaleTest::LibYUVScaleTest()
+    : benchmark_iterations_(1),
+      benchmark_width_(128),
+      benchmark_height_(72),
+      disable_cpu_flags_(1),
+      benchmark_cpu_info_(-1) {
+  const char* repeat = getenv("LIBYUV_REPEAT");
+  if (repeat) {
+    benchmark_iterations_ = atoi(repeat);  // NOLINT
+  }
+  if (LIBYUV_GET_FLAG(FLAGS_libyuv_repeat)) {
+    benchmark_iterations_ = LIBYUV_GET_FLAG(FLAGS_libyuv_repeat);
+  }
+  if (benchmark_iterations_ > 1) {
+    benchmark_width_ = 1280;
+    benchmark_height_ = 720;
+  }
+  const char* width = getenv("LIBYUV_WIDTH");
+  if (width) {
+    benchmark_width_ = atoi(width);  // NOLINT
+  }
+  if (LIBYUV_GET_FLAG(FLAGS_libyuv_width)) {
+    benchmark_width_ = LIBYUV_GET_FLAG(FLAGS_libyuv_width);
+  }
+  const char* height = getenv("LIBYUV_HEIGHT");
+  if (height) {
+    benchmark_height_ = atoi(height);  // NOLINT
+  }
+  if (LIBYUV_GET_FLAG(FLAGS_libyuv_height)) {
+    benchmark_height_ = LIBYUV_GET_FLAG(FLAGS_libyuv_height);
+  }
+  const char* cpu_flags = getenv("LIBYUV_FLAGS");
+  if (cpu_flags) {
+    disable_cpu_flags_ = atoi(cpu_flags);  // NOLINT
+  }
+  if (LIBYUV_GET_FLAG(FLAGS_libyuv_flags)) {
+    disable_cpu_flags_ = LIBYUV_GET_FLAG(FLAGS_libyuv_flags);
+  }
+  const char* cpu_info = getenv("LIBYUV_CPU_INFO");
+  if (cpu_info) {
+    benchmark_cpu_info_ = atoi(cpu_flags);  // NOLINT
+  }
+  if (LIBYUV_GET_FLAG(FLAGS_libyuv_cpu_info)) {
+    benchmark_cpu_info_ = LIBYUV_GET_FLAG(FLAGS_libyuv_cpu_info);
+  }
+  disable_cpu_flags_ = TestCpuEnv(disable_cpu_flags_);
+  benchmark_cpu_info_ = TestCpuEnv(benchmark_cpu_info_);
+  libyuv::MaskCpuFlags(benchmark_cpu_info_);
+  benchmark_pixels_div1280_ =
+      static_cast<int>((static_cast<double>(Abs(benchmark_width_)) *
+                            static_cast<double>(Abs(benchmark_height_)) *
+                            static_cast<double>(benchmark_iterations_) +
+                        1279.0) /
+                       1280.0);
+}
+
+LibYUVRotateTest::LibYUVRotateTest()
+    : benchmark_iterations_(1),
+      benchmark_width_(128),
+      benchmark_height_(72),
+      disable_cpu_flags_(1),
+      benchmark_cpu_info_(-1) {
+  const char* repeat = getenv("LIBYUV_REPEAT");
+  if (repeat) {
+    benchmark_iterations_ = atoi(repeat);  // NOLINT
+  }
+  if (LIBYUV_GET_FLAG(FLAGS_libyuv_repeat)) {
+    benchmark_iterations_ = LIBYUV_GET_FLAG(FLAGS_libyuv_repeat);
+  }
+  if (benchmark_iterations_ > 1) {
+    benchmark_width_ = 1280;
+    benchmark_height_ = 720;
+  }
+  const char* width = getenv("LIBYUV_WIDTH");
+  if (width) {
+    benchmark_width_ = atoi(width);  // NOLINT
+  }
+  if (LIBYUV_GET_FLAG(FLAGS_libyuv_width)) {
+    benchmark_width_ = LIBYUV_GET_FLAG(FLAGS_libyuv_width);
+  }
+  const char* height = getenv("LIBYUV_HEIGHT");
+  if (height) {
+    benchmark_height_ = atoi(height);  // NOLINT
+  }
+  if (LIBYUV_GET_FLAG(FLAGS_libyuv_height)) {
+    benchmark_height_ = LIBYUV_GET_FLAG(FLAGS_libyuv_height);
+  }
+  const char* cpu_flags = getenv("LIBYUV_FLAGS");
+  if (cpu_flags) {
+    disable_cpu_flags_ = atoi(cpu_flags);  // NOLINT
+  }
+  if (LIBYUV_GET_FLAG(FLAGS_libyuv_flags)) {
+    disable_cpu_flags_ = LIBYUV_GET_FLAG(FLAGS_libyuv_flags);
+  }
+  const char* cpu_info = getenv("LIBYUV_CPU_INFO");
+  if (cpu_info) {
+    benchmark_cpu_info_ = atoi(cpu_flags);  // NOLINT
+  }
+  if (LIBYUV_GET_FLAG(FLAGS_libyuv_cpu_info)) {
+    benchmark_cpu_info_ = LIBYUV_GET_FLAG(FLAGS_libyuv_cpu_info);
+  }
+  disable_cpu_flags_ = TestCpuEnv(disable_cpu_flags_);
+  benchmark_cpu_info_ = TestCpuEnv(benchmark_cpu_info_);
+  libyuv::MaskCpuFlags(benchmark_cpu_info_);
+  benchmark_pixels_div1280_ =
+      static_cast<int>((static_cast<double>(Abs(benchmark_width_)) *
+                            static_cast<double>(Abs(benchmark_height_)) *
+                            static_cast<double>(benchmark_iterations_) +
+                        1279.0) /
+                       1280.0);
+}
+
+LibYUVPlanarTest::LibYUVPlanarTest()
+    : benchmark_iterations_(1),
+      benchmark_width_(128),
+      benchmark_height_(72),
+      disable_cpu_flags_(1),
+      benchmark_cpu_info_(-1) {
+  const char* repeat = getenv("LIBYUV_REPEAT");
+  if (repeat) {
+    benchmark_iterations_ = atoi(repeat);  // NOLINT
+  }
+  if (LIBYUV_GET_FLAG(FLAGS_libyuv_repeat)) {
+    benchmark_iterations_ = LIBYUV_GET_FLAG(FLAGS_libyuv_repeat);
+  }
+  if (benchmark_iterations_ > 1) {
+    benchmark_width_ = 1280;
+    benchmark_height_ = 720;
+  }
+  const char* width = getenv("LIBYUV_WIDTH");
+  if (width) {
+    benchmark_width_ = atoi(width);  // NOLINT
+  }
+  if (LIBYUV_GET_FLAG(FLAGS_libyuv_width)) {
+    benchmark_width_ = LIBYUV_GET_FLAG(FLAGS_libyuv_width);
+  }
+  const char* height = getenv("LIBYUV_HEIGHT");
+  if (height) {
+    benchmark_height_ = atoi(height);  // NOLINT
+  }
+  if (LIBYUV_GET_FLAG(FLAGS_libyuv_height)) {
+    benchmark_height_ = LIBYUV_GET_FLAG(FLAGS_libyuv_height);
+  }
+  const char* cpu_flags = getenv("LIBYUV_FLAGS");
+  if (cpu_flags) {
+    disable_cpu_flags_ = atoi(cpu_flags);  // NOLINT
+  }
+  if (LIBYUV_GET_FLAG(FLAGS_libyuv_flags)) {
+    disable_cpu_flags_ = LIBYUV_GET_FLAG(FLAGS_libyuv_flags);
+  }
+  const char* cpu_info = getenv("LIBYUV_CPU_INFO");
+  if (cpu_info) {
+    benchmark_cpu_info_ = atoi(cpu_flags);  // NOLINT
+  }
+  if (LIBYUV_GET_FLAG(FLAGS_libyuv_cpu_info)) {
+    benchmark_cpu_info_ = LIBYUV_GET_FLAG(FLAGS_libyuv_cpu_info);
+  }
+  disable_cpu_flags_ = TestCpuEnv(disable_cpu_flags_);
+  benchmark_cpu_info_ = TestCpuEnv(benchmark_cpu_info_);
+  libyuv::MaskCpuFlags(benchmark_cpu_info_);
+  benchmark_pixels_div1280_ =
+      static_cast<int>((static_cast<double>(Abs(benchmark_width_)) *
+                            static_cast<double>(Abs(benchmark_height_)) *
+                            static_cast<double>(benchmark_iterations_) +
+                        1279.0) /
+                       1280.0);
+}
+
+LibYUVBaseTest::LibYUVBaseTest()
+    : benchmark_iterations_(1),
+      benchmark_width_(128),
+      benchmark_height_(72),
+      disable_cpu_flags_(1),
+      benchmark_cpu_info_(-1) {
+  const char* repeat = getenv("LIBYUV_REPEAT");
+  if (repeat) {
+    benchmark_iterations_ = atoi(repeat);  // NOLINT
+  }
+  if (LIBYUV_GET_FLAG(FLAGS_libyuv_repeat)) {
+    benchmark_iterations_ = LIBYUV_GET_FLAG(FLAGS_libyuv_repeat);
+  }
+  if (benchmark_iterations_ > 1) {
+    benchmark_width_ = 1280;
+    benchmark_height_ = 720;
+  }
+  const char* width = getenv("LIBYUV_WIDTH");
+  if (width) {
+    benchmark_width_ = atoi(width);  // NOLINT
+  }
+  if (LIBYUV_GET_FLAG(FLAGS_libyuv_width)) {
+    benchmark_width_ = LIBYUV_GET_FLAG(FLAGS_libyuv_width);
+  }
+  const char* height = getenv("LIBYUV_HEIGHT");
+  if (height) {
+    benchmark_height_ = atoi(height);  // NOLINT
+  }
+  if (LIBYUV_GET_FLAG(FLAGS_libyuv_height)) {
+    benchmark_height_ = LIBYUV_GET_FLAG(FLAGS_libyuv_height);
+  }
+  const char* cpu_flags = getenv("LIBYUV_FLAGS");
+  if (cpu_flags) {
+    disable_cpu_flags_ = atoi(cpu_flags);  // NOLINT
+  }
+  if (LIBYUV_GET_FLAG(FLAGS_libyuv_flags)) {
+    disable_cpu_flags_ = LIBYUV_GET_FLAG(FLAGS_libyuv_flags);
+  }
+  const char* cpu_info = getenv("LIBYUV_CPU_INFO");
+  if (cpu_info) {
+    benchmark_cpu_info_ = atoi(cpu_flags);  // NOLINT
+  }
+  if (LIBYUV_GET_FLAG(FLAGS_libyuv_cpu_info)) {
+    benchmark_cpu_info_ = LIBYUV_GET_FLAG(FLAGS_libyuv_cpu_info);
+  }
+  disable_cpu_flags_ = TestCpuEnv(disable_cpu_flags_);
+  benchmark_cpu_info_ = TestCpuEnv(benchmark_cpu_info_);
+  libyuv::MaskCpuFlags(benchmark_cpu_info_);
+  benchmark_pixels_div1280_ =
+      static_cast<int>((static_cast<double>(Abs(benchmark_width_)) *
+                            static_cast<double>(Abs(benchmark_height_)) *
+                            static_cast<double>(benchmark_iterations_) +
+                        1279.0) /
+                       1280.0);
+}
+
+LibYUVCompareTest::LibYUVCompareTest()
+    : benchmark_iterations_(1),
+      benchmark_width_(128),
+      benchmark_height_(72),
+      disable_cpu_flags_(1),
+      benchmark_cpu_info_(-1) {
+  const char* repeat = getenv("LIBYUV_REPEAT");
+  if (repeat) {
+    benchmark_iterations_ = atoi(repeat);  // NOLINT
+  }
+  if (LIBYUV_GET_FLAG(FLAGS_libyuv_repeat)) {
+    benchmark_iterations_ = LIBYUV_GET_FLAG(FLAGS_libyuv_repeat);
+  }
+  if (benchmark_iterations_ > 1) {
+    benchmark_width_ = 1280;
+    benchmark_height_ = 720;
+  }
+  const char* width = getenv("LIBYUV_WIDTH");
+  if (width) {
+    benchmark_width_ = atoi(width);  // NOLINT
+  }
+  if (LIBYUV_GET_FLAG(FLAGS_libyuv_width)) {
+    benchmark_width_ = LIBYUV_GET_FLAG(FLAGS_libyuv_width);
+  }
+  const char* height = getenv("LIBYUV_HEIGHT");
+  if (height) {
+    benchmark_height_ = atoi(height);  // NOLINT
+  }
+  if (LIBYUV_GET_FLAG(FLAGS_libyuv_height)) {
+    benchmark_height_ = LIBYUV_GET_FLAG(FLAGS_libyuv_height);
+  }
+  const char* cpu_flags = getenv("LIBYUV_FLAGS");
+  if (cpu_flags) {
+    disable_cpu_flags_ = atoi(cpu_flags);  // NOLINT
+  }
+  if (LIBYUV_GET_FLAG(FLAGS_libyuv_flags)) {
+    disable_cpu_flags_ = LIBYUV_GET_FLAG(FLAGS_libyuv_flags);
+  }
+  const char* cpu_info = getenv("LIBYUV_CPU_INFO");
+  if (cpu_info) {
+    benchmark_cpu_info_ = atoi(cpu_flags);  // NOLINT
+  }
+  if (LIBYUV_GET_FLAG(FLAGS_libyuv_cpu_info)) {
+    benchmark_cpu_info_ = LIBYUV_GET_FLAG(FLAGS_libyuv_cpu_info);
+  }
+  disable_cpu_flags_ = TestCpuEnv(disable_cpu_flags_);
+  benchmark_cpu_info_ = TestCpuEnv(benchmark_cpu_info_);
+  libyuv::MaskCpuFlags(benchmark_cpu_info_);
+  benchmark_pixels_div1280_ =
+      static_cast<int>((static_cast<double>(Abs(benchmark_width_)) *
+                            static_cast<double>(Abs(benchmark_height_)) *
+                            static_cast<double>(benchmark_iterations_) +
+                        1279.0) /
+                       1280.0);
+}
+
+int main(int argc, char** argv) {
+  ::testing::InitGoogleTest(&argc, argv);
+#ifdef LIBYUV_USE_ABSL_FLAGS
+  absl::ParseCommandLine(argc, argv);
+#endif
+  return RUN_ALL_TESTS();
+}
diff --git a/3rdparty/libyuv/src/unit_test/unit_test.h b/3rdparty/libyuv/src/unit_test/unit_test.h
new file mode 100644
index 00000000..0a8df4d2
--- /dev/null
+++ b/3rdparty/libyuv/src/unit_test/unit_test.h
@@ -0,0 +1,212 @@
+/*
+ *  Copyright 2011 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#ifndef UNIT_TEST_UNIT_TEST_H_  // NOLINT
+#define UNIT_TEST_UNIT_TEST_H_
+
+#ifdef _WIN32
+#include <windows.h>
+#else
+#include <sys/resource.h>
+#include <sys/time.h>
+#endif
+
+#include <gtest/gtest.h>
+
+#include "libyuv/basic_types.h"
+
+#ifndef SIMD_ALIGNED
+#if defined(_MSC_VER) && !defined(__CLR_VER)
+#define SIMD_ALIGNED(var) __declspec(align(16)) var
+#elif defined(__GNUC__) && !defined(__pnacl__)
+#define SIMD_ALIGNED(var) var __attribute__((aligned(16)))
+#else
+#define SIMD_ALIGNED(var) var
+#endif
+#endif
+
+static __inline int Abs(int v) {
+  return v >= 0 ? v : -v;
+}
+
+static __inline float FAbs(float v) {
+  return v >= 0 ? v : -v;
+}
+#define OFFBY 0
+
+// Scaling uses 16.16 fixed point to step thru the source image, so a
+// maximum size of 32767.999 can be expressed.  32768 is valid because
+// the step is 1 beyond the image but not used.
+// Destination size is mainly constrained by valid scale step not the
+// absolute size, so it may be possible to relax the destination size
+// constraint.
+// Source size is unconstrained for most specialized scalers.  e.g.
+// An image of 65536 scaled to half size would be valid.  The test
+// could be relaxed for special scale factors.
+// If this test is removed, the scaling function should gracefully
+// fail with a return code.  The test could be changed to know that
+// libyuv failed in a controlled way.
+
+static const int kMaxWidth = 32768;
+static const int kMaxHeight = 32768;
+
+static inline bool SizeValid(int src_width,
+                             int src_height,
+                             int dst_width,
+                             int dst_height) {
+  if (src_width > kMaxWidth || src_height > kMaxHeight ||
+      dst_width > kMaxWidth || dst_height > kMaxHeight) {
+    printf("Warning - size too large to test.  Skipping\n");
+    return false;
+  }
+  return true;
+}
+
+#define align_buffer_page_end(var, size)                                \
+  uint8_t* var##_mem =                                                  \
+      reinterpret_cast<uint8_t*>(malloc(((size) + 4095 + 63) & ~4095)); \
+  uint8_t* var = reinterpret_cast<uint8_t*>(                            \
+      (intptr_t)(var##_mem + (((size) + 4095 + 63) & ~4095) - (size)) & ~63)
+
+#define free_aligned_buffer_page_end(var) \
+  free(var##_mem);                        \
+  var = 0
+
+#ifdef WIN32
+static inline double get_time() {
+  LARGE_INTEGER t, f;
+  QueryPerformanceCounter(&t);
+  QueryPerformanceFrequency(&f);
+  return static_cast<double>(t.QuadPart) / static_cast<double>(f.QuadPart);
+}
+#else
+static inline double get_time() {
+  struct timeval t;
+  struct timezone tzp;
+  gettimeofday(&t, &tzp);
+  return t.tv_sec + t.tv_usec * 1e-6;
+}
+#endif
+
+#ifndef SIMD_ALIGNED
+#if defined(_MSC_VER) && !defined(__CLR_VER)
+#define SIMD_ALIGNED(var) __declspec(align(16)) var
+#elif defined(__GNUC__) && !defined(__pnacl__)
+#define SIMD_ALIGNED(var) var __attribute__((aligned(16)))
+#else
+#define SIMD_ALIGNED(var) var
+#endif
+#endif
+
+extern unsigned int fastrand_seed;
+inline int fastrand() {
+  fastrand_seed = fastrand_seed * 214013u + 2531011u;
+  return static_cast<int>((fastrand_seed >> 16) & 0xffff);
+}
+
+// ubsan fails if dst is unaligned unless we use uint8
+static inline void MemRandomize(uint8_t* dst, int64_t len) {
+  int64_t i;
+  for (i = 0; i < len - 1; i += 2) {
+    int r = fastrand();
+    dst[0] = static_cast<uint8_t>(r);
+    dst[1] = static_cast<uint8_t>(r >> 8);
+    dst += 2;
+  }
+  for (; i < len; ++i) {
+    *dst++ = fastrand();
+  }
+}
+
+class LibYUVColorTest : public ::testing::Test {
+ protected:
+  LibYUVColorTest();
+
+  int benchmark_iterations_;  // Default 1. Use 1000 for benchmarking.
+  int benchmark_width_;       // Default 1280.  Use 640 for benchmarking VGA.
+  int benchmark_height_;      // Default 720.  Use 360 for benchmarking VGA.
+  int benchmark_pixels_div1280_;  // Total pixels to benchmark / 1280.
+  int disable_cpu_flags_;         // Default 1.  Use -1 for benchmarking.
+  int benchmark_cpu_info_;        // Default -1.  Use 1 to disable SIMD.
+};
+
+class LibYUVConvertTest : public ::testing::Test {
+ protected:
+  LibYUVConvertTest();
+
+  int benchmark_iterations_;  // Default 1. Use 1000 for benchmarking.
+  int benchmark_width_;       // Default 1280.  Use 640 for benchmarking VGA.
+  int benchmark_height_;      // Default 720.  Use 360 for benchmarking VGA.
+  int benchmark_pixels_div1280_;  // Total pixels to benchmark / 1280.
+  int disable_cpu_flags_;         // Default 1.  Use -1 for benchmarking.
+  int benchmark_cpu_info_;        // Default -1.  Use 1 to disable SIMD.
+};
+
+class LibYUVScaleTest : public ::testing::Test {
+ protected:
+  LibYUVScaleTest();
+
+  int benchmark_iterations_;  // Default 1. Use 1000 for benchmarking.
+  int benchmark_width_;       // Default 1280.  Use 640 for benchmarking VGA.
+  int benchmark_height_;      // Default 720.  Use 360 for benchmarking VGA.
+  int benchmark_pixels_div1280_;  // Total pixels to benchmark / 1280.
+  int disable_cpu_flags_;         // Default 1.  Use -1 for benchmarking.
+  int benchmark_cpu_info_;        // Default -1.  Use 1 to disable SIMD.
+};
+
+class LibYUVRotateTest : public ::testing::Test {
+ protected:
+  LibYUVRotateTest();
+
+  int benchmark_iterations_;  // Default 1. Use 1000 for benchmarking.
+  int benchmark_width_;       // Default 1280.  Use 640 for benchmarking VGA.
+  int benchmark_height_;      // Default 720.  Use 360 for benchmarking VGA.
+  int benchmark_pixels_div1280_;  // Total pixels to benchmark / 1280.
+  int disable_cpu_flags_;         // Default 1.  Use -1 for benchmarking.
+  int benchmark_cpu_info_;        // Default -1.  Use 1 to disable SIMD.
+};
+
+class LibYUVPlanarTest : public ::testing::Test {
+ protected:
+  LibYUVPlanarTest();
+
+  int benchmark_iterations_;  // Default 1. Use 1000 for benchmarking.
+  int benchmark_width_;       // Default 1280.  Use 640 for benchmarking VGA.
+  int benchmark_height_;      // Default 720.  Use 360 for benchmarking VGA.
+  int benchmark_pixels_div1280_;  // Total pixels to benchmark / 1280.
+  int disable_cpu_flags_;         // Default 1.  Use -1 for benchmarking.
+  int benchmark_cpu_info_;        // Default -1.  Use 1 to disable SIMD.
+};
+
+class LibYUVBaseTest : public ::testing::Test {
+ protected:
+  LibYUVBaseTest();
+
+  int benchmark_iterations_;  // Default 1. Use 1000 for benchmarking.
+  int benchmark_width_;       // Default 1280.  Use 640 for benchmarking VGA.
+  int benchmark_height_;      // Default 720.  Use 360 for benchmarking VGA.
+  int benchmark_pixels_div1280_;  // Total pixels to benchmark / 1280.
+  int disable_cpu_flags_;         // Default 1.  Use -1 for benchmarking.
+  int benchmark_cpu_info_;        // Default -1.  Use 1 to disable SIMD.
+};
+
+class LibYUVCompareTest : public ::testing::Test {
+ protected:
+  LibYUVCompareTest();
+
+  int benchmark_iterations_;  // Default 1. Use 1000 for benchmarking.
+  int benchmark_width_;       // Default 1280.  Use 640 for benchmarking VGA.
+  int benchmark_height_;      // Default 720.  Use 360 for benchmarking VGA.
+  int benchmark_pixels_div1280_;  // Total pixels to benchmark / 1280.
+  int disable_cpu_flags_;         // Default 1.  Use -1 for benchmarking.
+  int benchmark_cpu_info_;        // Default -1.  Use 1 to disable SIMD.
+};
+
+#endif  // UNIT_TEST_UNIT_TEST_H_  NOLINT
diff --git a/3rdparty/libyuv/src/unit_test/video_common_test.cc b/3rdparty/libyuv/src/unit_test/video_common_test.cc
new file mode 100644
index 00000000..36728ea9
--- /dev/null
+++ b/3rdparty/libyuv/src/unit_test/video_common_test.cc
@@ -0,0 +1,112 @@
+/*
+ *  Copyright 2012 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "../unit_test/unit_test.h"
+#include "libyuv/video_common.h"
+
+namespace libyuv {
+
+// Tests FourCC codes in video common, which are used for ConvertToI420().
+
+static bool TestValidChar(uint32_t onecc) {
+  return (onecc >= '0' && onecc <= '9') || (onecc >= 'A' && onecc <= 'Z') ||
+         (onecc >= 'a' && onecc <= 'z') || (onecc == ' ') || (onecc == 0xff);
+}
+
+static bool TestValidFourCC(uint32_t fourcc, int bpp) {
+  if (!TestValidChar(fourcc & 0xff) || !TestValidChar((fourcc >> 8) & 0xff) ||
+      !TestValidChar((fourcc >> 16) & 0xff) ||
+      !TestValidChar((fourcc >> 24) & 0xff)) {
+    return false;
+  }
+  if (bpp < 0 || bpp > 64) {
+    return false;
+  }
+  return true;
+}
+
+TEST_F(LibYUVBaseTest, TestCanonicalFourCC) {
+  EXPECT_EQ(static_cast<uint32_t>(FOURCC_I420), CanonicalFourCC(FOURCC_IYUV));
+  EXPECT_EQ(static_cast<uint32_t>(FOURCC_I420), CanonicalFourCC(FOURCC_YU12));
+  EXPECT_EQ(static_cast<uint32_t>(FOURCC_I422), CanonicalFourCC(FOURCC_YU16));
+  EXPECT_EQ(static_cast<uint32_t>(FOURCC_I444), CanonicalFourCC(FOURCC_YU24));
+  EXPECT_EQ(static_cast<uint32_t>(FOURCC_YUY2), CanonicalFourCC(FOURCC_YUYV));
+  EXPECT_EQ(static_cast<uint32_t>(FOURCC_YUY2), CanonicalFourCC(FOURCC_YUVS));
+  EXPECT_EQ(static_cast<uint32_t>(FOURCC_UYVY), CanonicalFourCC(FOURCC_HDYC));
+  EXPECT_EQ(static_cast<uint32_t>(FOURCC_UYVY), CanonicalFourCC(FOURCC_2VUY));
+  EXPECT_EQ(static_cast<uint32_t>(FOURCC_MJPG), CanonicalFourCC(FOURCC_JPEG));
+  EXPECT_EQ(static_cast<uint32_t>(FOURCC_MJPG), CanonicalFourCC(FOURCC_DMB1));
+  EXPECT_EQ(static_cast<uint32_t>(FOURCC_RAW), CanonicalFourCC(FOURCC_RGB3));
+  EXPECT_EQ(static_cast<uint32_t>(FOURCC_24BG), CanonicalFourCC(FOURCC_BGR3));
+  EXPECT_EQ(static_cast<uint32_t>(FOURCC_BGRA), CanonicalFourCC(FOURCC_CM32));
+  EXPECT_EQ(static_cast<uint32_t>(FOURCC_RAW), CanonicalFourCC(FOURCC_CM24));
+  EXPECT_EQ(static_cast<uint32_t>(FOURCC_RGBO), CanonicalFourCC(FOURCC_L555));
+  EXPECT_EQ(static_cast<uint32_t>(FOURCC_RGBP), CanonicalFourCC(FOURCC_L565));
+  EXPECT_EQ(static_cast<uint32_t>(FOURCC_RGBO), CanonicalFourCC(FOURCC_5551));
+}
+
+TEST_F(LibYUVBaseTest, TestFourCC) {
+  EXPECT_TRUE(TestValidFourCC(FOURCC_I420, FOURCC_BPP_I420));
+  EXPECT_TRUE(TestValidFourCC(FOURCC_I420, FOURCC_BPP_I420));
+  EXPECT_TRUE(TestValidFourCC(FOURCC_I422, FOURCC_BPP_I422));
+  EXPECT_TRUE(TestValidFourCC(FOURCC_I444, FOURCC_BPP_I444));
+  EXPECT_TRUE(TestValidFourCC(FOURCC_I400, FOURCC_BPP_I400));
+  EXPECT_TRUE(TestValidFourCC(FOURCC_NV21, FOURCC_BPP_NV21));
+  EXPECT_TRUE(TestValidFourCC(FOURCC_NV12, FOURCC_BPP_NV12));
+  EXPECT_TRUE(TestValidFourCC(FOURCC_YUY2, FOURCC_BPP_YUY2));
+  EXPECT_TRUE(TestValidFourCC(FOURCC_UYVY, FOURCC_BPP_UYVY));
+  EXPECT_TRUE(TestValidFourCC(FOURCC_M420, FOURCC_BPP_M420));  // deprecated.
+  EXPECT_TRUE(TestValidFourCC(FOURCC_Q420, FOURCC_BPP_Q420));  // deprecated.
+  EXPECT_TRUE(TestValidFourCC(FOURCC_ARGB, FOURCC_BPP_ARGB));
+  EXPECT_TRUE(TestValidFourCC(FOURCC_BGRA, FOURCC_BPP_BGRA));
+  EXPECT_TRUE(TestValidFourCC(FOURCC_ABGR, FOURCC_BPP_ABGR));
+  EXPECT_TRUE(TestValidFourCC(FOURCC_AR30, FOURCC_BPP_AR30));
+  EXPECT_TRUE(TestValidFourCC(FOURCC_AB30, FOURCC_BPP_AB30));
+  EXPECT_TRUE(TestValidFourCC(FOURCC_AR64, FOURCC_BPP_AR64));
+  EXPECT_TRUE(TestValidFourCC(FOURCC_AB64, FOURCC_BPP_AB64));
+  EXPECT_TRUE(TestValidFourCC(FOURCC_24BG, FOURCC_BPP_24BG));
+  EXPECT_TRUE(TestValidFourCC(FOURCC_RAW, FOURCC_BPP_RAW));
+  EXPECT_TRUE(TestValidFourCC(FOURCC_RGBA, FOURCC_BPP_RGBA));
+  EXPECT_TRUE(TestValidFourCC(FOURCC_RGBP, FOURCC_BPP_RGBP));
+  EXPECT_TRUE(TestValidFourCC(FOURCC_RGBO, FOURCC_BPP_RGBO));
+  EXPECT_TRUE(TestValidFourCC(FOURCC_R444, FOURCC_BPP_R444));
+  EXPECT_TRUE(TestValidFourCC(FOURCC_H420, FOURCC_BPP_H420));
+  EXPECT_TRUE(TestValidFourCC(FOURCC_H422, FOURCC_BPP_H422));
+  EXPECT_TRUE(TestValidFourCC(FOURCC_H010, FOURCC_BPP_H010));
+  EXPECT_TRUE(TestValidFourCC(FOURCC_H210, FOURCC_BPP_H210));
+  EXPECT_TRUE(TestValidFourCC(FOURCC_I010, FOURCC_BPP_I010));
+  EXPECT_TRUE(TestValidFourCC(FOURCC_I210, FOURCC_BPP_I210));
+  EXPECT_TRUE(TestValidFourCC(FOURCC_P010, FOURCC_BPP_P010));
+  EXPECT_TRUE(TestValidFourCC(FOURCC_P210, FOURCC_BPP_P210));
+  EXPECT_TRUE(TestValidFourCC(FOURCC_MJPG, FOURCC_BPP_MJPG));
+  EXPECT_TRUE(TestValidFourCC(FOURCC_YV12, FOURCC_BPP_YV12));
+  EXPECT_TRUE(TestValidFourCC(FOURCC_YV16, FOURCC_BPP_YV16));
+  EXPECT_TRUE(TestValidFourCC(FOURCC_YV24, FOURCC_BPP_YV24));
+  EXPECT_TRUE(TestValidFourCC(FOURCC_YU12, FOURCC_BPP_YU12));
+  EXPECT_TRUE(TestValidFourCC(FOURCC_IYUV, FOURCC_BPP_IYUV));
+  EXPECT_TRUE(TestValidFourCC(FOURCC_YU16, FOURCC_BPP_YU16));
+  EXPECT_TRUE(TestValidFourCC(FOURCC_YU24, FOURCC_BPP_YU24));
+  EXPECT_TRUE(TestValidFourCC(FOURCC_YUYV, FOURCC_BPP_YUYV));
+  EXPECT_TRUE(TestValidFourCC(FOURCC_YUVS, FOURCC_BPP_YUVS));
+  EXPECT_TRUE(TestValidFourCC(FOURCC_HDYC, FOURCC_BPP_HDYC));
+  EXPECT_TRUE(TestValidFourCC(FOURCC_2VUY, FOURCC_BPP_2VUY));
+  EXPECT_TRUE(TestValidFourCC(FOURCC_JPEG, FOURCC_BPP_JPEG));
+  EXPECT_TRUE(TestValidFourCC(FOURCC_DMB1, FOURCC_BPP_DMB1));
+  EXPECT_TRUE(TestValidFourCC(FOURCC_BA81, FOURCC_BPP_BA81));
+  EXPECT_TRUE(TestValidFourCC(FOURCC_RGB3, FOURCC_BPP_RGB3));
+  EXPECT_TRUE(TestValidFourCC(FOURCC_BGR3, FOURCC_BPP_BGR3));
+  EXPECT_TRUE(TestValidFourCC(FOURCC_H264, FOURCC_BPP_H264));
+  EXPECT_TRUE(TestValidFourCC(FOURCC_ANY, FOURCC_BPP_ANY));
+}
+
+}  // namespace libyuv
diff --git a/3rdparty/libyuv/src/util/Makefile b/3rdparty/libyuv/src/util/Makefile
new file mode 100644
index 00000000..40e74b65
--- /dev/null
+++ b/3rdparty/libyuv/src/util/Makefile
@@ -0,0 +1,9 @@
+psnr: psnr.cc ssim.cc psnr_main.cc
+ifeq ($(CXX),icl)
+	$(CXX) /arch:SSE2 /Ox /openmp psnr.cc ssim.cc psnr_main.cc
+else
+	$(CXX) -msse2 -O3 -fopenmp -static -o psnr psnr.cc ssim.cc psnr_main.cc -Wl,--strip-all
+endif
+
+# for MacOS
+# /usr/local/bin/g++-7 -msse2 -O3 -fopenmp -Bstatic -o psnr psnr.cc ssim.cc psnr_main.cc
diff --git a/3rdparty/libyuv/src/util/color.cc b/3rdparty/libyuv/src/util/color.cc
new file mode 100644
index 00000000..8c3bbefd
--- /dev/null
+++ b/3rdparty/libyuv/src/util/color.cc
@@ -0,0 +1,120 @@
+/*
+ *  Copyright 2021 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+// This utility computes values needed to generate yuvconstants based on
+// white point values.
+// The yuv formulas are tuned for 8 bit YUV channels.
+
+// For those MCs that can be represented as kr and kb:
+// Full range
+// float M[3][3]
+// {{1,0,2*(1-kr)},{1,-((2*kb)/((2-kb)*(1-kb-kr))),-((2*kr)/((2-kr)*(1-kb-kr)))},{1,2*(1-kb),0}};
+// float B[3]
+// {1+(256*(1-kr))/255,1-(256*kb)/(255*(2-kb)*(1-kb-kr))-(256*kr)/(255*(2-kr)*(1-kb-kr)),1+(256*(1-kb))/255};
+// Limited range
+// float M[3][3]
+// {{85/73,0,255/112-(255*kr)/112},{85/73,-((255*kb)/(112*(2-kb)*(1-kb-kr))),-((255*kr)/(112*(2-kr)*(1-kb-kr)))},{85/73,255/112-(255*kb)/112,0}};
+// float B[3]
+// {77662/43435-(1537*kr)/1785,203/219-(1537*kb)/(1785*(2-kb)*(1-kb-kr))-(1537*kr)/(1785*(2-kr)*(1-kb-kr)),77662/43435-(1537*kb)/1785};
+
+// mc bt
+// 1 bt.709      KR = 0.2126; KB = 0.0722
+// 4 fcc         KR = 0.30;   KB = 0.11
+// 6 bt.601      KR = 0.299;  KB = 0.114
+// 7 SMPTE 240M  KR = 0.212;  KB = 0.087
+// 10 bt2020     KR = 0.2627; KB = 0.0593
+
+// BT.709 full range YUV to RGB reference
+//  R = Y               + V * 1.5748
+//  G = Y - U * 0.18732 - V * 0.46812
+//  B = Y + U * 1.8556
+//  KR = 0.2126
+//  KB = 0.0722
+
+// https://mymusing.co/bt601-yuv-to-rgb-conversion-color/
+
+// // Y contribution to R,G,B.  Scale and bias.
+// #define YG 16320 /* round(1.000 * 64 * 256 * 256 / 257) */
+// #define YB 32    /* 64 / 2 */
+//
+// // U and V contributions to R,G,B.
+// #define UB 113 /* round(1.77200 * 64) */
+// #define UG 22  /* round(0.34414 * 64) */
+// #define VG 46  /* round(0.71414 * 64) */
+// #define VR 90  /* round(1.40200 * 64) */
+//
+// // Bias values to round, and subtract 128 from U and V.
+// #define BB (-UB * 128 + YB)
+// #define BG (UG * 128 + VG * 128 + YB)
+// #define BR (-VR * 128 + YB)
+
+int round(float v) {
+  return (int)(v + 0.5);
+}
+
+int main(int argc, const char* argv[]) {
+  if (argc < 2) {
+    printf("color kr kb\n");
+    return -1;
+  }
+  float kr = atof(argv[1]);
+  float kb = atof(argv[2]);
+  float kg = 1 - kr - kb;
+
+  float vr = 2 * (1 - kr);
+  float ug = 2 * ((1 - kb) * kb / kg);
+  float vg = 2 * ((1 - kr) * kr / kg);
+  float ub = 2 * (1 - kb);
+
+  printf("Full range\n");
+  printf("R = Y                + V * %5f\n", vr);
+  printf("G = Y - U * %6f - V * %6f\n", ug, vg);
+  printf("B = Y + U * %5f\n", ub);
+
+  printf("KR = %4f; ", kr);
+  printf("KB = %4f\n", kb);
+  //  printf("KG = %4f\n", kg);
+  // #define YG 16320 /* round(1.000 * 64 * 256 * 256 / 257) */
+  // #define YB 32    /* 64 / 2 */
+  //
+  // // U and V contributions to R,G,B.
+
+  printf("UB %-3d /* round(%f * 64) */\n", round(ub * 64), ub);
+  printf("UG %-3d /* round(%f * 64) */\n", round(ug * 64), ug);
+  printf("VG %-3d /* round(%f * 64) */\n", round(vg * 64), vg);
+  printf("VR %-3d /* round(%f * 64) */\n", round(vr * 64), vr);
+
+  vr = 255.f / 224.f * 2 * (1 - kr);
+  ug = 255.f / 224.f * 2 * ((1 - kb) * kb / kg);
+  vg = 255.f / 224.f * 2 * ((1 - kr) * kr / kg);
+  ub = 255.f / 224.f * 2 * (1 - kb);
+
+  printf("Limited range\n");
+  printf("R = (Y - 16) * 1.164                + V * %5f\n", vr);
+  printf("G = (Y - 16) * 1.164 - U * %6f - V * %6f\n", ug, vg);
+  printf("B = (Y - 16) * 1.164 + U * %5f\n", ub);
+
+  //  printf("KG = %4f\n", kg);
+  // #define YG 16320 /* round(1.000 * 64 * 256 * 256 / 257) */
+  // #define YB 32    /* 64 / 2 */
+  //
+  // // U and V contributions to R,G,B.
+
+  printf("UB %-3d /* round(%f * 64) */\n", round(ub * 64), ub);
+  printf("UG %-3d /* round(%f * 64) */\n", round(ug * 64), ug);
+  printf("VG %-3d /* round(%f * 64) */\n", round(vg * 64), vg);
+  printf("VR %-3d /* round(%f * 64) */\n", round(vr * 64), vr);
+
+  return 0;
+}
diff --git a/3rdparty/libyuv/src/util/compare.cc b/3rdparty/libyuv/src/util/compare.cc
new file mode 100644
index 00000000..a16613ee
--- /dev/null
+++ b/3rdparty/libyuv/src/util/compare.cc
@@ -0,0 +1,67 @@
+/*
+ *  Copyright 2012 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+
+#include "libyuv/basic_types.h"
+#include "libyuv/compare.h"
+#include "libyuv/version.h"
+
+int main(int argc, char** argv) {
+  if (argc < 1) {
+    printf("libyuv compare v%d\n", LIBYUV_VERSION);
+    printf("compare file1.yuv file2.yuv\n");
+    return -1;
+  }
+  char* name1 = argv[1];
+  char* name2 = (argc > 2) ? argv[2] : NULL;
+  FILE* fin1 = fopen(name1, "rb");
+  FILE* fin2 = name2 ? fopen(name2, "rb") : NULL;
+
+  const int kBlockSize = 32768;
+  uint8_t buf1[kBlockSize];
+  uint8_t buf2[kBlockSize];
+  uint32_t hash1 = 5381;
+  uint32_t hash2 = 5381;
+  uint64_t sum_square_err = 0;
+  uint64_t size_min = 0;
+  int amt1 = 0;
+  int amt2 = 0;
+  do {
+    amt1 = static_cast<int>(fread(buf1, 1, kBlockSize, fin1));
+    if (amt1 > 0) {
+      hash1 = libyuv::HashDjb2(buf1, amt1, hash1);
+    }
+    if (fin2) {
+      amt2 = static_cast<int>(fread(buf2, 1, kBlockSize, fin2));
+      if (amt2 > 0) {
+        hash2 = libyuv::HashDjb2(buf2, amt2, hash2);
+      }
+      int amt_min = (amt1 < amt2) ? amt1 : amt2;
+      size_min += amt_min;
+      sum_square_err += libyuv::ComputeSumSquareError(buf1, buf2, amt_min);
+    }
+  } while (amt1 > 0 || amt2 > 0);
+
+  printf("hash1 %x", hash1);
+  if (fin2) {
+    printf(", hash2 %x", hash2);
+    double mse =
+        static_cast<double>(sum_square_err) / static_cast<double>(size_min);
+    printf(", mse %.2f", mse);
+    double psnr = libyuv::SumSquareErrorToPsnr(sum_square_err, size_min);
+    printf(", psnr %.2f\n", psnr);
+    fclose(fin2);
+  }
+  fclose(fin1);
+}
diff --git a/3rdparty/libyuv/src/util/cpuid.c b/3rdparty/libyuv/src/util/cpuid.c
new file mode 100644
index 00000000..fbccf20e
--- /dev/null
+++ b/3rdparty/libyuv/src/util/cpuid.c
@@ -0,0 +1,121 @@
+/*
+ *  Copyright 2012 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "libyuv/cpu_id.h"
+
+#ifdef __cplusplus
+using namespace libyuv;
+#endif
+
+int main(int argc, const char* argv[]) {
+  int cpu_flags = TestCpuFlag(-1);
+  int has_arm = TestCpuFlag(kCpuHasARM);
+  int has_mips = TestCpuFlag(kCpuHasMIPS);
+  int has_x86 = TestCpuFlag(kCpuHasX86);
+  int has_loongarch = TestCpuFlag(kCpuHasLOONGARCH);
+  (void)argc;
+  (void)argv;
+
+#if defined(__i386__) || defined(__x86_64__) || defined(_M_IX86) || \
+    defined(_M_X64)
+  if (has_x86) {
+    int family, model, cpu_info[4];
+    // Vendor ID:
+    // AuthenticAMD AMD processor
+    // CentaurHauls Centaur processor
+    // CyrixInstead Cyrix processor
+    // GenuineIntel Intel processor
+    // GenuineTMx86 Transmeta processor
+    // Geode by NSC National Semiconductor processor
+    // NexGenDriven NexGen processor
+    // RiseRiseRise Rise Technology processor
+    // SiS SiS SiS  SiS processor
+    // UMC UMC UMC  UMC processor
+    CpuId(0, 0, &cpu_info[0]);
+    cpu_info[0] = cpu_info[1];  // Reorder output
+    cpu_info[1] = cpu_info[3];
+    cpu_info[3] = 0;
+    printf("Cpu Vendor: %s\n", (char*)(&cpu_info[0]));
+
+    // CPU Family and Model
+    // 3:0 - Stepping
+    // 7:4 - Model
+    // 11:8 - Family
+    // 13:12 - Processor Type
+    // 19:16 - Extended Model
+    // 27:20 - Extended Family
+    CpuId(1, 0, &cpu_info[0]);
+    family = ((cpu_info[0] >> 8) & 0x0f) | ((cpu_info[0] >> 16) & 0xff0);
+    model = ((cpu_info[0] >> 4) & 0x0f) | ((cpu_info[0] >> 12) & 0xf0);
+    printf("Cpu Family %d (0x%x), Model %d (0x%x)\n", family, family, model,
+           model);
+  }
+#endif
+  printf("Cpu Flags %x\n", cpu_flags);
+  printf("Has ARM %x\n", has_arm);
+  printf("Has MIPS %x\n", has_mips);
+  printf("Has X86 %x\n", has_x86);
+  printf("Has LOONGARCH %x\n", has_loongarch);
+  if (has_arm) {
+    int has_neon = TestCpuFlag(kCpuHasNEON);
+    printf("Has NEON %x\n", has_neon);
+  }
+  if (has_mips) {
+    int has_msa = TestCpuFlag(kCpuHasMSA);
+    printf("Has MSA %x\n", has_msa);
+  }
+  if (has_loongarch) {
+    int has_lsx = TestCpuFlag(kCpuHasLSX);
+    printf("Has LSX %x\n", has_lsx);
+    int has_lasx = TestCpuFlag(kCpuHasLASX);
+    printf("Has LASX %x\n", has_lasx);
+  }
+  if (has_x86) {
+    int has_sse2 = TestCpuFlag(kCpuHasSSE2);
+    int has_ssse3 = TestCpuFlag(kCpuHasSSSE3);
+    int has_sse41 = TestCpuFlag(kCpuHasSSE41);
+    int has_sse42 = TestCpuFlag(kCpuHasSSE42);
+    int has_avx = TestCpuFlag(kCpuHasAVX);
+    int has_avx2 = TestCpuFlag(kCpuHasAVX2);
+    int has_erms = TestCpuFlag(kCpuHasERMS);
+    int has_fma3 = TestCpuFlag(kCpuHasFMA3);
+    int has_f16c = TestCpuFlag(kCpuHasF16C);
+    int has_gfni = TestCpuFlag(kCpuHasGFNI);
+    int has_avx512bw = TestCpuFlag(kCpuHasAVX512BW);
+    int has_avx512vl = TestCpuFlag(kCpuHasAVX512VL);
+    int has_avx512vnni = TestCpuFlag(kCpuHasAVX512VNNI);
+    int has_avx512vbmi = TestCpuFlag(kCpuHasAVX512VBMI);
+    int has_avx512vbmi2 = TestCpuFlag(kCpuHasAVX512VBMI2);
+    int has_avx512vbitalg = TestCpuFlag(kCpuHasAVX512VBITALG);
+    int has_avx512vpopcntdq = TestCpuFlag(kCpuHasAVX512VPOPCNTDQ);
+    printf("Has SSE2 %x\n", has_sse2);
+    printf("Has SSSE3 %x\n", has_ssse3);
+    printf("Has SSE4.1 %x\n", has_sse41);
+    printf("Has SSE4.2 %x\n", has_sse42);
+    printf("Has AVX %x\n", has_avx);
+    printf("Has AVX2 %x\n", has_avx2);
+    printf("Has ERMS %x\n", has_erms);
+    printf("Has FMA3 %x\n", has_fma3);
+    printf("Has F16C %x\n", has_f16c);
+    printf("Has GFNI %x\n", has_gfni);
+    printf("Has AVX512BW %x\n", has_avx512bw);
+    printf("Has AVX512VL %x\n", has_avx512vl);
+    printf("Has AVX512VNNI %x\n", has_avx512vnni);
+    printf("Has AVX512VBMI %x\n", has_avx512vbmi);
+    printf("Has AVX512VBMI2 %x\n", has_avx512vbmi2);
+    printf("Has AVX512VBITALG %x\n", has_avx512vbitalg);
+    printf("Has AVX512VPOPCNTDQ %x\n", has_avx512vpopcntdq);
+  }
+  return 0;
+}
diff --git a/3rdparty/libyuv/src/util/i444tonv12_eg.cc b/3rdparty/libyuv/src/util/i444tonv12_eg.cc
new file mode 100644
index 00000000..0fcb4095
--- /dev/null
+++ b/3rdparty/libyuv/src/util/i444tonv12_eg.cc
@@ -0,0 +1,28 @@
+
+#include "libyuv/convert.h"
+
+#include <stdio.h>   // for printf
+#include <string.h>  // for memset
+
+int main(int, char**) {
+  unsigned char src_i444[640 * 400 * 3];
+  unsigned char dst_nv12[640 * 400 * 3 / 2];
+
+  for (size_t i = 0; i < sizeof(src_i444); ++i) {
+    src_i444[i] = i & 255;
+  }
+  memset(dst_nv12, 0, sizeof(dst_nv12));
+  libyuv::I444ToNV12(&src_i444[0], 640,              // source Y
+                     &src_i444[640 * 400], 640,      // source U
+                     &src_i444[640 * 400 * 2], 640,  // source V
+                     &dst_nv12[0], 640,              // dest Y
+                     &dst_nv12[640 * 400], 640,      // dest UV
+                     640, 400);                      // width and height
+
+  int checksum = 0;
+  for (size_t i = 0; i < sizeof(dst_nv12); ++i) {
+    checksum += dst_nv12[i];
+  }
+  printf("checksum %x %s\n", checksum, checksum == 0x2ec0c00 ? "PASS" : "FAIL");
+  return 0;
+}
\ No newline at end of file
diff --git a/3rdparty/libyuv/src/util/psnr.cc b/3rdparty/libyuv/src/util/psnr.cc
new file mode 100644
index 00000000..c7bee7f9
--- /dev/null
+++ b/3rdparty/libyuv/src/util/psnr.cc
@@ -0,0 +1,291 @@
+/*
+ *  Copyright 2013 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include "./psnr.h"  // NOLINT
+
+#ifdef _OPENMP
+#include <omp.h>
+#endif
+#ifdef _MSC_VER
+#include <intrin.h>  // For __cpuid()
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef unsigned int uint32_t;  // NOLINT
+#ifdef _MSC_VER
+typedef unsigned __int64 uint64_t;
+#else  // COMPILER_MSVC
+#if defined(__LP64__) && !defined(__OpenBSD__) && !defined(__APPLE__)
+typedef unsigned long uint64_t;  // NOLINT
+#else   // defined(__LP64__) && !defined(__OpenBSD__) && !defined(__APPLE__)
+typedef unsigned long long uint64_t;  // NOLINT
+#endif  // __LP64__
+#endif  // _MSC_VER
+
+// libyuv provides this function when linking library for jpeg support.
+#if !defined(HAVE_JPEG)
+
+#if !defined(LIBYUV_DISABLE_NEON) && defined(__ARM_NEON__) && \
+    !defined(__aarch64__)
+#define HAS_SUMSQUAREERROR_NEON
+static uint32_t SumSquareError_NEON(const uint8_t* src_a,
+                                    const uint8_t* src_b,
+                                    int count) {
+  volatile uint32_t sse;
+  asm volatile(
+      "vmov.u8    q7, #0                         \n"
+      "vmov.u8    q9, #0                         \n"
+      "vmov.u8    q8, #0                         \n"
+      "vmov.u8    q10, #0                        \n"
+
+      "1:                                        \n"
+      "vld1.u8    {q0}, [%0]!                    \n"
+      "vld1.u8    {q1}, [%1]!                    \n"
+      "vsubl.u8   q2, d0, d2                     \n"
+      "vsubl.u8   q3, d1, d3                     \n"
+      "vmlal.s16  q7, d4, d4                     \n"
+      "vmlal.s16  q8, d6, d6                     \n"
+      "vmlal.s16  q8, d5, d5                     \n"
+      "vmlal.s16  q10, d7, d7                    \n"
+      "subs       %2, %2, #16                    \n"
+      "bhi        1b                             \n"
+
+      "vadd.u32   q7, q7, q8                     \n"
+      "vadd.u32   q9, q9, q10                    \n"
+      "vadd.u32   q10, q7, q9                    \n"
+      "vpaddl.u32 q1, q10                        \n"
+      "vadd.u64   d0, d2, d3                     \n"
+      "vmov.32    %3, d0[0]                      \n"
+      : "+r"(src_a), "+r"(src_b), "+r"(count), "=r"(sse)
+      :
+      : "memory", "cc", "q0", "q1", "q2", "q3", "q7", "q8", "q9", "q10");
+  return sse;
+}
+#elif !defined(LIBYUV_DISABLE_NEON) && defined(__aarch64__)
+#define HAS_SUMSQUAREERROR_NEON
+static uint32_t SumSquareError_NEON(const uint8_t* src_a,
+                                    const uint8_t* src_b,
+                                    int count) {
+  volatile uint32_t sse;
+  asm volatile(
+      "eor        v16.16b, v16.16b, v16.16b      \n"
+      "eor        v18.16b, v18.16b, v18.16b      \n"
+      "eor        v17.16b, v17.16b, v17.16b      \n"
+      "eor        v19.16b, v19.16b, v19.16b      \n"
+
+      "1:                                        \n"
+      "ld1        {v0.16b}, [%0], #16            \n"
+      "ld1        {v1.16b}, [%1], #16            \n"
+      "subs       %w2, %w2, #16                  \n"
+      "usubl      v2.8h, v0.8b, v1.8b            \n"
+      "usubl2     v3.8h, v0.16b, v1.16b          \n"
+      "smlal      v16.4s, v2.4h, v2.4h           \n"
+      "smlal      v17.4s, v3.4h, v3.4h           \n"
+      "smlal2     v18.4s, v2.8h, v2.8h           \n"
+      "smlal2     v19.4s, v3.8h, v3.8h           \n"
+      "b.gt       1b                             \n"
+
+      "add        v16.4s, v16.4s, v17.4s         \n"
+      "add        v18.4s, v18.4s, v19.4s         \n"
+      "add        v19.4s, v16.4s, v18.4s         \n"
+      "addv       s0, v19.4s                     \n"
+      "fmov       %w3, s0                        \n"
+      : "+r"(src_a), "+r"(src_b), "+r"(count), "=r"(sse)
+      :
+      : "cc", "v0", "v1", "v2", "v3", "v16", "v17", "v18", "v19");
+  return sse;
+}
+#elif !defined(LIBYUV_DISABLE_X86) && defined(_M_IX86) && defined(_MSC_VER)
+#define HAS_SUMSQUAREERROR_SSE2
+__declspec(naked) static uint32_t SumSquareError_SSE2(const uint8_t* /*src_a*/,
+                                                      const uint8_t* /*src_b*/,
+                                                      int /*count*/) {
+  __asm {
+    mov        eax, [esp + 4]  // src_a
+    mov        edx, [esp + 8]  // src_b
+    mov        ecx, [esp + 12]  // count
+    pxor       xmm0, xmm0
+    pxor       xmm5, xmm5
+    sub        edx, eax
+
+  wloop:
+    movdqu     xmm1, [eax]
+    movdqu     xmm2, [eax + edx]
+    lea        eax,  [eax + 16]
+    movdqu     xmm3, xmm1
+    psubusb    xmm1, xmm2
+    psubusb    xmm2, xmm3
+    por        xmm1, xmm2
+    movdqu     xmm2, xmm1
+    punpcklbw  xmm1, xmm5
+    punpckhbw  xmm2, xmm5
+    pmaddwd    xmm1, xmm1
+    pmaddwd    xmm2, xmm2
+    paddd      xmm0, xmm1
+    paddd      xmm0, xmm2
+    sub        ecx, 16
+    ja         wloop
+
+    pshufd     xmm1, xmm0, 0EEh
+    paddd      xmm0, xmm1
+    pshufd     xmm1, xmm0, 01h
+    paddd      xmm0, xmm1
+    movd       eax, xmm0
+    ret
+  }
+}
+#elif !defined(LIBYUV_DISABLE_X86) && (defined(__x86_64__) || defined(__i386__))
+#define HAS_SUMSQUAREERROR_SSE2
+static uint32_t SumSquareError_SSE2(const uint8_t* src_a,
+                                    const uint8_t* src_b,
+                                    int count) {
+  uint32_t sse;
+  asm volatile(  // NOLINT
+      "pxor      %%xmm0,%%xmm0                   \n"
+      "pxor      %%xmm5,%%xmm5                   \n"
+      "sub       %0,%1                           \n"
+
+      "1:                                        \n"
+      "movdqu    (%0),%%xmm1                     \n"
+      "movdqu    (%0,%1,1),%%xmm2                \n"
+      "lea       0x10(%0),%0                     \n"
+      "movdqu    %%xmm1,%%xmm3                   \n"
+      "psubusb   %%xmm2,%%xmm1                   \n"
+      "psubusb   %%xmm3,%%xmm2                   \n"
+      "por       %%xmm2,%%xmm1                   \n"
+      "movdqu    %%xmm1,%%xmm2                   \n"
+      "punpcklbw %%xmm5,%%xmm1                   \n"
+      "punpckhbw %%xmm5,%%xmm2                   \n"
+      "pmaddwd   %%xmm1,%%xmm1                   \n"
+      "pmaddwd   %%xmm2,%%xmm2                   \n"
+      "paddd     %%xmm1,%%xmm0                   \n"
+      "paddd     %%xmm2,%%xmm0                   \n"
+      "sub       $0x10,%2                        \n"
+      "ja        1b                              \n"
+
+      "pshufd    $0xee,%%xmm0,%%xmm1             \n"
+      "paddd     %%xmm1,%%xmm0                   \n"
+      "pshufd    $0x1,%%xmm0,%%xmm1              \n"
+      "paddd     %%xmm1,%%xmm0                   \n"
+      "movd      %%xmm0,%3                       \n"
+
+      : "+r"(src_a),  // %0
+        "+r"(src_b),  // %1
+        "+r"(count),  // %2
+        "=g"(sse)     // %3
+      :
+      : "memory", "cc"
+#if defined(__SSE2__)
+        ,
+        "xmm0", "xmm1", "xmm2", "xmm3", "xmm5"
+#endif
+  );  // NOLINT
+  return sse;
+}
+#endif  // LIBYUV_DISABLE_X86 etc
+
+#if defined(HAS_SUMSQUAREERROR_SSE2)
+#if (defined(__pic__) || defined(__APPLE__)) && defined(__i386__)
+static __inline void __cpuid(int cpu_info[4], int info_type) {
+  asm volatile(  // NOLINT
+      "mov %%ebx, %%edi                          \n"
+      "cpuid                                     \n"
+      "xchg %%edi, %%ebx                         \n"
+      : "=a"(cpu_info[0]), "=D"(cpu_info[1]), "=c"(cpu_info[2]),
+        "=d"(cpu_info[3])
+      : "a"(info_type));
+}
+// For gcc/clang but not clangcl.
+#elif !defined(_MSC_VER) && (defined(__i386__) || defined(__x86_64__))
+static __inline void __cpuid(int cpu_info[4], int info_type) {
+  asm volatile(  // NOLINT
+      "cpuid                                     \n"
+      : "=a"(cpu_info[0]), "=b"(cpu_info[1]), "=c"(cpu_info[2]),
+        "=d"(cpu_info[3])
+      : "a"(info_type));
+}
+#endif
+
+static int CpuHasSSE2() {
+#if defined(__i386__) || defined(__x86_64__) || defined(_M_IX86)
+  int cpu_info[4];
+  __cpuid(cpu_info, 1);
+  if (cpu_info[3] & 0x04000000) {
+    return 1;
+  }
+#endif
+  return 0;
+}
+#endif  // HAS_SUMSQUAREERROR_SSE2
+
+static uint32_t SumSquareError_C(const uint8_t* src_a,
+                                 const uint8_t* src_b,
+                                 int count) {
+  uint32_t sse = 0u;
+  for (int x = 0; x < count; ++x) {
+    int diff = src_a[x] - src_b[x];
+    sse += static_cast<uint32_t>(diff * diff);
+  }
+  return sse;
+}
+
+double ComputeSumSquareError(const uint8_t* src_a,
+                             const uint8_t* src_b,
+                             int count) {
+  uint32_t (*SumSquareError)(const uint8_t* src_a, const uint8_t* src_b,
+                             int count) = SumSquareError_C;
+#if defined(HAS_SUMSQUAREERROR_NEON)
+  SumSquareError = SumSquareError_NEON;
+#endif
+#if defined(HAS_SUMSQUAREERROR_SSE2)
+  if (CpuHasSSE2()) {
+    SumSquareError = SumSquareError_SSE2;
+  }
+#endif
+  const int kBlockSize = 1 << 15;
+  uint64_t sse = 0;
+#ifdef _OPENMP
+#pragma omp parallel for reduction(+ : sse)
+#endif
+  for (int i = 0; i < (count - (kBlockSize - 1)); i += kBlockSize) {
+    sse += SumSquareError(src_a + i, src_b + i, kBlockSize);
+  }
+  src_a += count & ~(kBlockSize - 1);
+  src_b += count & ~(kBlockSize - 1);
+  int remainder = count & (kBlockSize - 1) & ~15;
+  if (remainder) {
+    sse += SumSquareError(src_a, src_b, remainder);
+    src_a += remainder;
+    src_b += remainder;
+  }
+  remainder = count & 15;
+  if (remainder) {
+    sse += SumSquareError_C(src_a, src_b, remainder);
+  }
+  return static_cast<double>(sse);
+}
+#endif
+
+// PSNR formula: psnr = 10 * log10 (Peak Signal^2 * size / sse)
+// Returns 128.0 (kMaxPSNR) if sse is 0 (perfect match).
+double ComputePSNR(double sse, double size) {
+  const double kMINSSE = 255.0 * 255.0 * size / pow(10.0, kMaxPSNR / 10.0);
+  if (sse <= kMINSSE) {
+    sse = kMINSSE;  // Produces max PSNR of 128
+  }
+  return 10.0 * log10(255.0 * 255.0 * size / sse);
+}
+
+#ifdef __cplusplus
+}  // extern "C"
+#endif
diff --git a/3rdparty/libyuv/src/util/psnr.h b/3rdparty/libyuv/src/util/psnr.h
new file mode 100644
index 00000000..aac128cb
--- /dev/null
+++ b/3rdparty/libyuv/src/util/psnr.h
@@ -0,0 +1,47 @@
+/*
+ *  Copyright 2013 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+// Get PSNR for video sequence. Assuming RAW 4:2:0 Y:Cb:Cr format
+
+#ifndef UTIL_PSNR_H_  // NOLINT
+#define UTIL_PSNR_H_
+
+#include <math.h>  // For log10()
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if !defined(INT_TYPES_DEFINED) && !defined(UINT8_TYPE_DEFINED)
+typedef unsigned char uint8_t;
+#define UINT8_TYPE_DEFINED
+#endif
+
+static const double kMaxPSNR = 128.0;
+
+// libyuv provides this function when linking library for jpeg support.
+// TODO(fbarchard): make psnr lib compatible subset of libyuv.
+#if !defined(HAVE_JPEG)
+// Computer Sum of Squared Error (SSE).
+// Pass this to ComputePSNR for final result.
+double ComputeSumSquareError(const uint8_t* src_a,
+                             const uint8_t* src_b,
+                             int count);
+#endif
+
+// PSNR formula: psnr = 10 * log10 (Peak Signal^2 * size / sse)
+// Returns 128.0 (kMaxPSNR) if sse is 0 (perfect match).
+double ComputePSNR(double sse, double size);
+
+#ifdef __cplusplus
+}  // extern "C"
+#endif
+
+#endif  // UTIL_PSNR_H_  // NOLINT
diff --git a/3rdparty/libyuv/src/util/psnr_main.cc b/3rdparty/libyuv/src/util/psnr_main.cc
new file mode 100644
index 00000000..8b9fd972
--- /dev/null
+++ b/3rdparty/libyuv/src/util/psnr_main.cc
@@ -0,0 +1,633 @@
+/*
+ *  Copyright 2013 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+// Get PSNR or SSIM for video sequence. Assuming RAW 4:2:0 Y:Cb:Cr format
+// To build: g++ -O3 -o psnr psnr.cc ssim.cc psnr_main.cc
+// or VisualC: cl /Ox psnr.cc ssim.cc psnr_main.cc
+//
+// To enable OpenMP and SSE2
+// gcc: g++ -msse2 -O3 -fopenmp -o psnr psnr.cc ssim.cc psnr_main.cc
+// vc:  cl /arch:SSE2 /Ox /openmp psnr.cc ssim.cc psnr_main.cc
+//
+// Usage: psnr org_seq rec_seq -s width height [-skip skip_org skip_rec]
+
+#ifndef _CRT_SECURE_NO_WARNINGS
+#define _CRT_SECURE_NO_WARNINGS
+#endif
+
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#ifdef _OPENMP
+#include <omp.h>
+#endif
+
+#include "./psnr.h"
+#include "./ssim.h"
+#ifdef HAVE_JPEG
+#include "libyuv/compare.h"
+#include "libyuv/convert.h"
+#endif
+
+struct metric {
+  double y, u, v, all;
+  double min_y, min_u, min_v, min_all;
+  double global_y, global_u, global_v, global_all;
+  int min_frame;
+};
+
+// options
+bool verbose = false;
+bool quiet = false;
+bool show_name = false;
+bool do_swap_uv = false;
+bool do_psnr = false;
+bool do_ssim = false;
+bool do_mse = false;
+bool do_lssim = false;
+int image_width = 0, image_height = 0;
+int fileindex_org = 0;  // argv argument contains the source file name.
+int fileindex_rec = 0;  // argv argument contains the destination file name.
+int num_rec = 0;
+int num_skip_org = 0;
+int num_skip_rec = 0;
+int num_frames = 0;
+#ifdef _OPENMP
+int num_threads = 0;
+#endif
+
+// Parse PYUV format. ie name.1920x800_24Hz_P420.yuv
+bool ExtractResolutionFromFilename(const char* name,
+                                   int* width_ptr,
+                                   int* height_ptr) {
+  // Isolate the .width_height. section of the filename by searching for a
+  // dot or underscore followed by a digit.
+  for (int i = 0; name[i]; ++i) {
+    if ((name[i] == '.' || name[i] == '_') && name[i + 1] >= '0' &&
+        name[i + 1] <= '9') {
+      int n = sscanf(name + i + 1, "%dx%d", width_ptr, height_ptr);  // NOLINT
+      if (2 == n) {
+        return true;
+      }
+    }
+  }
+
+#ifdef HAVE_JPEG
+  // Try parsing file as a jpeg.
+  FILE* const file_org = fopen(name, "rb");
+  if (file_org == NULL) {
+    fprintf(stderr, "Cannot open %s\n", name);
+    return false;
+  }
+  fseek(file_org, 0, SEEK_END);
+  size_t total_size = ftell(file_org);
+  fseek(file_org, 0, SEEK_SET);
+  uint8_t* const ch_org = new uint8_t[total_size];
+  memset(ch_org, 0, total_size);
+  size_t bytes_org = fread(ch_org, sizeof(uint8_t), total_size, file_org);
+  fclose(file_org);
+  if (bytes_org == total_size) {
+    if (0 == libyuv::MJPGSize(ch_org, total_size, width_ptr, height_ptr)) {
+      delete[] ch_org;
+      return true;
+    }
+  }
+  delete[] ch_org;
+#endif  // HAVE_JPEG
+  return false;
+}
+
+// Scale Y channel from 16..240 to 0..255.
+// This can be useful when comparing codecs that are inconsistant about Y
+uint8_t ScaleY(uint8_t y) {
+  int ny = (y - 16) * 256 / 224;
+  if (ny < 0) {
+    ny = 0;
+  }
+  if (ny > 255) {
+    ny = 255;
+  }
+  return static_cast<uint8_t>(ny);
+}
+
+// MSE = Mean Square Error
+double GetMSE(double sse, double size) {
+  return sse / size;
+}
+
+void PrintHelp(const char* program) {
+  printf("%s [-options] org_seq rec_seq [rec_seq2.. etc]\n", program);
+#ifdef HAVE_JPEG
+  printf("jpeg or raw YUV 420 supported.\n");
+#endif
+  printf("options:\n");
+  printf(
+      " -s <width> <height> .... specify YUV size, mandatory if none of the "
+      "sequences have the\n");
+  printf(
+      "                          resolution embedded in their filename (ie. "
+      "name.1920x800_24Hz_P420.yuv)\n");
+  printf(" -psnr .................. compute PSNR (default)\n");
+  printf(" -ssim .................. compute SSIM\n");
+  printf(" -mse ................... compute MSE\n");
+  printf(" -swap .................. Swap U and V plane\n");
+  printf(" -skip <org> <rec> ...... Number of frame to skip of org and rec\n");
+  printf(" -frames <num> .......... Number of frames to compare\n");
+#ifdef _OPENMP
+  printf(" -t <num> ............... Number of threads\n");
+#endif
+  printf(" -n ..................... Show file name\n");
+  printf(" -v ..................... verbose++\n");
+  printf(" -q ..................... quiet\n");
+  printf(" -h ..................... this help\n");
+  exit(0);
+}
+
+void ParseOptions(int argc, const char* argv[]) {
+  if (argc <= 1) {
+    PrintHelp(argv[0]);
+  }
+  for (int c = 1; c < argc; ++c) {
+    if (!strcmp(argv[c], "-v")) {
+      verbose = true;
+    } else if (!strcmp(argv[c], "-q")) {
+      quiet = true;
+    } else if (!strcmp(argv[c], "-n")) {
+      show_name = true;
+    } else if (!strcmp(argv[c], "-psnr")) {
+      do_psnr = true;
+    } else if (!strcmp(argv[c], "-mse")) {
+      do_mse = true;
+    } else if (!strcmp(argv[c], "-ssim")) {
+      do_ssim = true;
+    } else if (!strcmp(argv[c], "-lssim")) {
+      do_ssim = true;
+      do_lssim = true;
+    } else if (!strcmp(argv[c], "-swap")) {
+      do_swap_uv = true;
+    } else if (!strcmp(argv[c], "-h") || !strcmp(argv[c], "-help")) {
+      PrintHelp(argv[0]);
+    } else if (!strcmp(argv[c], "-s") && c + 2 < argc) {
+      image_width = atoi(argv[++c]);   // NOLINT
+      image_height = atoi(argv[++c]);  // NOLINT
+    } else if (!strcmp(argv[c], "-skip") && c + 2 < argc) {
+      num_skip_org = atoi(argv[++c]);  // NOLINT
+      num_skip_rec = atoi(argv[++c]);  // NOLINT
+    } else if (!strcmp(argv[c], "-frames") && c + 1 < argc) {
+      num_frames = atoi(argv[++c]);  // NOLINT
+#ifdef _OPENMP
+    } else if (!strcmp(argv[c], "-t") && c + 1 < argc) {
+      num_threads = atoi(argv[++c]);  // NOLINT
+#endif
+    } else if (argv[c][0] == '-') {
+      fprintf(stderr, "Unknown option. %s\n", argv[c]);
+    } else if (fileindex_org == 0) {
+      fileindex_org = c;
+    } else if (fileindex_rec == 0) {
+      fileindex_rec = c;
+      num_rec = 1;
+    } else {
+      ++num_rec;
+    }
+  }
+  if (fileindex_org == 0 || fileindex_rec == 0) {
+    fprintf(stderr, "Missing filenames\n");
+    PrintHelp(argv[0]);
+  }
+  if (num_skip_org < 0 || num_skip_rec < 0) {
+    fprintf(stderr, "Skipped frames incorrect\n");
+    PrintHelp(argv[0]);
+  }
+  if (num_frames < 0) {
+    fprintf(stderr, "Number of frames incorrect\n");
+    PrintHelp(argv[0]);
+  }
+  if (image_width == 0 || image_height == 0) {
+    int org_width, org_height;
+    int rec_width, rec_height;
+    bool org_res_avail = ExtractResolutionFromFilename(argv[fileindex_org],
+                                                       &org_width, &org_height);
+    bool rec_res_avail = ExtractResolutionFromFilename(argv[fileindex_rec],
+                                                       &rec_width, &rec_height);
+    if (org_res_avail) {
+      if (rec_res_avail) {
+        if ((org_width == rec_width) && (org_height == rec_height)) {
+          image_width = org_width;
+          image_height = org_height;
+        } else {
+          fprintf(stderr, "Sequences have different resolutions.\n");
+          PrintHelp(argv[0]);
+        }
+      } else {
+        image_width = org_width;
+        image_height = org_height;
+      }
+    } else if (rec_res_avail) {
+      image_width = rec_width;
+      image_height = rec_height;
+    } else {
+      fprintf(stderr, "Missing dimensions.\n");
+      PrintHelp(argv[0]);
+    }
+  }
+}
+
+bool UpdateMetrics(uint8_t* ch_org,
+                   uint8_t* ch_rec,
+                   const int y_size,
+                   const int uv_size,
+                   const size_t total_size,
+                   int number_of_frames,
+                   metric* cur_distortion_psnr,
+                   metric* distorted_frame,
+                   bool compute_psnr) {
+  const int uv_offset = (do_swap_uv ? uv_size : 0);
+  const uint8_t* const u_org = ch_org + y_size + uv_offset;
+  const uint8_t* const u_rec = ch_rec + y_size;
+  const uint8_t* const v_org = ch_org + y_size + (uv_size - uv_offset);
+  const uint8_t* const v_rec = ch_rec + y_size + uv_size;
+  if (compute_psnr) {
+#ifdef HAVE_JPEG
+    double y_err = static_cast<double>(
+        libyuv::ComputeSumSquareError(ch_org, ch_rec, y_size));
+    double u_err = static_cast<double>(
+        libyuv::ComputeSumSquareError(u_org, u_rec, uv_size));
+    double v_err = static_cast<double>(
+        libyuv::ComputeSumSquareError(v_org, v_rec, uv_size));
+#else
+    double y_err = ComputeSumSquareError(ch_org, ch_rec, y_size);
+    double u_err = ComputeSumSquareError(u_org, u_rec, uv_size);
+    double v_err = ComputeSumSquareError(v_org, v_rec, uv_size);
+#endif
+    const double total_err = y_err + u_err + v_err;
+    cur_distortion_psnr->global_y += y_err;
+    cur_distortion_psnr->global_u += u_err;
+    cur_distortion_psnr->global_v += v_err;
+    cur_distortion_psnr->global_all += total_err;
+    distorted_frame->y = ComputePSNR(y_err, static_cast<double>(y_size));
+    distorted_frame->u = ComputePSNR(u_err, static_cast<double>(uv_size));
+    distorted_frame->v = ComputePSNR(v_err, static_cast<double>(uv_size));
+    distorted_frame->all =
+        ComputePSNR(total_err, static_cast<double>(total_size));
+  } else {
+    distorted_frame->y = CalcSSIM(ch_org, ch_rec, image_width, image_height);
+    distorted_frame->u =
+        CalcSSIM(u_org, u_rec, (image_width + 1) / 2, (image_height + 1) / 2);
+    distorted_frame->v =
+        CalcSSIM(v_org, v_rec, (image_width + 1) / 2, (image_height + 1) / 2);
+    distorted_frame->all =
+        (distorted_frame->y + distorted_frame->u + distorted_frame->v) /
+        total_size;
+    distorted_frame->y /= y_size;
+    distorted_frame->u /= uv_size;
+    distorted_frame->v /= uv_size;
+
+    if (do_lssim) {
+      distorted_frame->all = CalcLSSIM(distorted_frame->all);
+      distorted_frame->y = CalcLSSIM(distorted_frame->y);
+      distorted_frame->u = CalcLSSIM(distorted_frame->u);
+      distorted_frame->v = CalcLSSIM(distorted_frame->v);
+    }
+  }
+
+  cur_distortion_psnr->y += distorted_frame->y;
+  cur_distortion_psnr->u += distorted_frame->u;
+  cur_distortion_psnr->v += distorted_frame->v;
+  cur_distortion_psnr->all += distorted_frame->all;
+
+  bool ismin = false;
+  if (distorted_frame->y < cur_distortion_psnr->min_y) {
+    cur_distortion_psnr->min_y = distorted_frame->y;
+  }
+  if (distorted_frame->u < cur_distortion_psnr->min_u) {
+    cur_distortion_psnr->min_u = distorted_frame->u;
+  }
+  if (distorted_frame->v < cur_distortion_psnr->min_v) {
+    cur_distortion_psnr->min_v = distorted_frame->v;
+  }
+  if (distorted_frame->all < cur_distortion_psnr->min_all) {
+    cur_distortion_psnr->min_all = distorted_frame->all;
+    cur_distortion_psnr->min_frame = number_of_frames;
+    ismin = true;
+  }
+  return ismin;
+}
+
+int main(int argc, const char* argv[]) {
+  ParseOptions(argc, argv);
+  if (!do_psnr && !do_ssim) {
+    do_psnr = true;
+  }
+
+#ifdef _OPENMP
+  if (num_threads) {
+    omp_set_num_threads(num_threads);
+  }
+  if (verbose) {
+    printf("OpenMP %d procs\n", omp_get_num_procs());
+  }
+#endif
+  // Open original file (first file argument)
+  FILE* const file_org = fopen(argv[fileindex_org], "rb");
+  if (file_org == NULL) {
+    fprintf(stderr, "Cannot open %s\n", argv[fileindex_org]);
+    exit(1);
+  }
+
+  // Open all files to compare to
+  FILE** file_rec = new FILE*[num_rec];
+  memset(file_rec, 0, num_rec * sizeof(FILE*));  // NOLINT
+  for (int cur_rec = 0; cur_rec < num_rec; ++cur_rec) {
+    file_rec[cur_rec] = fopen(argv[fileindex_rec + cur_rec], "rb");
+    if (file_rec[cur_rec] == NULL) {
+      fprintf(stderr, "Cannot open %s\n", argv[fileindex_rec + cur_rec]);
+      fclose(file_org);
+      for (int i = 0; i < cur_rec; ++i) {
+        fclose(file_rec[i]);
+      }
+      delete[] file_rec;
+      exit(1);
+    }
+  }
+
+  const int y_size = image_width * image_height;
+  const int uv_size = ((image_width + 1) / 2) * ((image_height + 1) / 2);
+  const size_t total_size = y_size + 2 * uv_size;  // NOLINT
+#if defined(_MSC_VER)
+  _fseeki64(
+      file_org,
+      static_cast<__int64>(num_skip_org) * static_cast<__int64>(total_size),
+      SEEK_SET);
+#else
+  fseek(file_org, num_skip_org * total_size, SEEK_SET);
+#endif
+  for (int cur_rec = 0; cur_rec < num_rec; ++cur_rec) {
+#if defined(_MSC_VER)
+    _fseeki64(
+        file_rec[cur_rec],
+        static_cast<__int64>(num_skip_rec) * static_cast<__int64>(total_size),
+        SEEK_SET);
+#else
+    fseek(file_rec[cur_rec], num_skip_rec * total_size, SEEK_SET);
+#endif
+  }
+
+  uint8_t* const ch_org = new uint8_t[total_size];
+  uint8_t* const ch_rec = new uint8_t[total_size];
+  if (ch_org == NULL || ch_rec == NULL) {
+    fprintf(stderr, "No memory available\n");
+    fclose(file_org);
+    for (int i = 0; i < num_rec; ++i) {
+      fclose(file_rec[i]);
+    }
+    delete[] ch_org;
+    delete[] ch_rec;
+    delete[] file_rec;
+    exit(1);
+  }
+
+  metric* const distortion_psnr = new metric[num_rec];
+  metric* const distortion_ssim = new metric[num_rec];
+  for (int cur_rec = 0; cur_rec < num_rec; ++cur_rec) {
+    metric* cur_distortion_psnr = &distortion_psnr[cur_rec];
+    cur_distortion_psnr->y = 0.0;
+    cur_distortion_psnr->u = 0.0;
+    cur_distortion_psnr->v = 0.0;
+    cur_distortion_psnr->all = 0.0;
+    cur_distortion_psnr->min_y = kMaxPSNR;
+    cur_distortion_psnr->min_u = kMaxPSNR;
+    cur_distortion_psnr->min_v = kMaxPSNR;
+    cur_distortion_psnr->min_all = kMaxPSNR;
+    cur_distortion_psnr->min_frame = 0;
+    cur_distortion_psnr->global_y = 0.0;
+    cur_distortion_psnr->global_u = 0.0;
+    cur_distortion_psnr->global_v = 0.0;
+    cur_distortion_psnr->global_all = 0.0;
+    distortion_ssim[cur_rec] = cur_distortion_psnr[cur_rec];
+  }
+
+  if (verbose) {
+    printf("Size: %dx%d\n", image_width, image_height);
+  }
+
+  if (!quiet) {
+    printf("Frame");
+    if (do_psnr) {
+      printf("\t PSNR-Y \t PSNR-U \t PSNR-V \t PSNR-All \t Frame");
+    }
+    if (do_ssim) {
+      printf("\t  SSIM-Y\t  SSIM-U\t  SSIM-V\t  SSIM-All\t Frame");
+    }
+    if (show_name) {
+      printf("\tName\n");
+    } else {
+      printf("\n");
+    }
+  }
+
+  int number_of_frames;
+  for (number_of_frames = 0;; ++number_of_frames) {
+    if (num_frames && number_of_frames >= num_frames) {
+      break;
+    }
+
+    size_t bytes_org = fread(ch_org, sizeof(uint8_t), total_size, file_org);
+    if (bytes_org < total_size) {
+#ifdef HAVE_JPEG
+      // Try parsing file as a jpeg.
+      uint8_t* const ch_jpeg = new uint8_t[bytes_org];
+      memcpy(ch_jpeg, ch_org, bytes_org);
+      memset(ch_org, 0, total_size);
+
+      if (0 != libyuv::MJPGToI420(ch_jpeg, bytes_org, ch_org, image_width,
+                                  ch_org + y_size, (image_width + 1) / 2,
+                                  ch_org + y_size + uv_size,
+                                  (image_width + 1) / 2, image_width,
+                                  image_height, image_width, image_height)) {
+        delete[] ch_jpeg;
+        break;
+      }
+      delete[] ch_jpeg;
+#else
+      break;
+#endif  // HAVE_JPEG
+    }
+
+    for (int cur_rec = 0; cur_rec < num_rec; ++cur_rec) {
+      size_t bytes_rec =
+          fread(ch_rec, sizeof(uint8_t), total_size, file_rec[cur_rec]);
+      if (bytes_rec < total_size) {
+#ifdef HAVE_JPEG
+        // Try parsing file as a jpeg.
+        uint8_t* const ch_jpeg = new uint8_t[bytes_rec];
+        memcpy(ch_jpeg, ch_rec, bytes_rec);
+        memset(ch_rec, 0, total_size);
+
+        if (0 != libyuv::MJPGToI420(ch_jpeg, bytes_rec, ch_rec, image_width,
+                                    ch_rec + y_size, (image_width + 1) / 2,
+                                    ch_rec + y_size + uv_size,
+                                    (image_width + 1) / 2, image_width,
+                                    image_height, image_width, image_height)) {
+          delete[] ch_jpeg;
+          break;
+        }
+        delete[] ch_jpeg;
+#else
+        break;
+#endif  // HAVE_JPEG
+      }
+
+      if (verbose) {
+        printf("%5d", number_of_frames);
+      }
+      if (do_psnr) {
+        metric distorted_frame = {};
+        metric* cur_distortion_psnr = &distortion_psnr[cur_rec];
+        bool ismin = UpdateMetrics(ch_org, ch_rec, y_size, uv_size, total_size,
+                                   number_of_frames, cur_distortion_psnr,
+                                   &distorted_frame, true);
+        if (verbose) {
+          printf("\t%10.6f", distorted_frame.y);
+          printf("\t%10.6f", distorted_frame.u);
+          printf("\t%10.6f", distorted_frame.v);
+          printf("\t%10.6f", distorted_frame.all);
+          printf("\t%5s", ismin ? "min" : "");
+        }
+      }
+      if (do_ssim) {
+        metric distorted_frame = {};
+        metric* cur_distortion_ssim = &distortion_ssim[cur_rec];
+        bool ismin = UpdateMetrics(ch_org, ch_rec, y_size, uv_size, total_size,
+                                   number_of_frames, cur_distortion_ssim,
+                                   &distorted_frame, false);
+        if (verbose) {
+          printf("\t%10.6f", distorted_frame.y);
+          printf("\t%10.6f", distorted_frame.u);
+          printf("\t%10.6f", distorted_frame.v);
+          printf("\t%10.6f", distorted_frame.all);
+          printf("\t%5s", ismin ? "min" : "");
+        }
+      }
+      if (verbose) {
+        if (show_name) {
+          printf("\t%s", argv[fileindex_rec + cur_rec]);
+        }
+        printf("\n");
+      }
+    }
+  }
+
+  // Final PSNR computation.
+  for (int cur_rec = 0; cur_rec < num_rec; ++cur_rec) {
+    metric* cur_distortion_psnr = &distortion_psnr[cur_rec];
+    metric* cur_distortion_ssim = &distortion_ssim[cur_rec];
+    if (number_of_frames > 0) {
+      const double norm = 1. / static_cast<double>(number_of_frames);
+      cur_distortion_psnr->y *= norm;
+      cur_distortion_psnr->u *= norm;
+      cur_distortion_psnr->v *= norm;
+      cur_distortion_psnr->all *= norm;
+      cur_distortion_ssim->y *= norm;
+      cur_distortion_ssim->u *= norm;
+      cur_distortion_ssim->v *= norm;
+      cur_distortion_ssim->all *= norm;
+    }
+
+    if (do_psnr) {
+      const double global_psnr_y =
+          ComputePSNR(cur_distortion_psnr->global_y,
+                      static_cast<double>(y_size) * number_of_frames);
+      const double global_psnr_u =
+          ComputePSNR(cur_distortion_psnr->global_u,
+                      static_cast<double>(uv_size) * number_of_frames);
+      const double global_psnr_v =
+          ComputePSNR(cur_distortion_psnr->global_v,
+                      static_cast<double>(uv_size) * number_of_frames);
+      const double global_psnr_all =
+          ComputePSNR(cur_distortion_psnr->global_all,
+                      static_cast<double>(total_size) * number_of_frames);
+      printf("Global:\t%10.6f\t%10.6f\t%10.6f\t%10.6f\t%5d", global_psnr_y,
+             global_psnr_u, global_psnr_v, global_psnr_all, number_of_frames);
+      if (show_name) {
+        printf("\t%s", argv[fileindex_rec + cur_rec]);
+      }
+      printf("\n");
+    }
+
+    if (!quiet) {
+      printf("Avg:");
+      if (do_psnr) {
+        printf("\t%10.6f\t%10.6f\t%10.6f\t%10.6f\t%5d", cur_distortion_psnr->y,
+               cur_distortion_psnr->u, cur_distortion_psnr->v,
+               cur_distortion_psnr->all, number_of_frames);
+      }
+      if (do_ssim) {
+        printf("\t%10.6f\t%10.6f\t%10.6f\t%10.6f\t%5d", cur_distortion_ssim->y,
+               cur_distortion_ssim->u, cur_distortion_ssim->v,
+               cur_distortion_ssim->all, number_of_frames);
+      }
+      if (show_name) {
+        printf("\t%s", argv[fileindex_rec + cur_rec]);
+      }
+      printf("\n");
+    }
+    if (!quiet) {
+      printf("Min:");
+      if (do_psnr) {
+        printf("\t%10.6f\t%10.6f\t%10.6f\t%10.6f\t%5d",
+               cur_distortion_psnr->min_y, cur_distortion_psnr->min_u,
+               cur_distortion_psnr->min_v, cur_distortion_psnr->min_all,
+               cur_distortion_psnr->min_frame);
+      }
+      if (do_ssim) {
+        printf("\t%10.6f\t%10.6f\t%10.6f\t%10.6f\t%5d",
+               cur_distortion_ssim->min_y, cur_distortion_ssim->min_u,
+               cur_distortion_ssim->min_v, cur_distortion_ssim->min_all,
+               cur_distortion_ssim->min_frame);
+      }
+      if (show_name) {
+        printf("\t%s", argv[fileindex_rec + cur_rec]);
+      }
+      printf("\n");
+    }
+
+    if (do_mse) {
+      double global_mse_y =
+          GetMSE(cur_distortion_psnr->global_y,
+                 static_cast<double>(y_size) * number_of_frames);
+      double global_mse_u =
+          GetMSE(cur_distortion_psnr->global_u,
+                 static_cast<double>(uv_size) * number_of_frames);
+      double global_mse_v =
+          GetMSE(cur_distortion_psnr->global_v,
+                 static_cast<double>(uv_size) * number_of_frames);
+      double global_mse_all =
+          GetMSE(cur_distortion_psnr->global_all,
+                 static_cast<double>(total_size) * number_of_frames);
+      printf("MSE:\t%10.6f\t%10.6f\t%10.6f\t%10.6f\t%5d", global_mse_y,
+             global_mse_u, global_mse_v, global_mse_all, number_of_frames);
+      if (show_name) {
+        printf("\t%s", argv[fileindex_rec + cur_rec]);
+      }
+      printf("\n");
+    }
+  }
+  fclose(file_org);
+  for (int cur_rec = 0; cur_rec < num_rec; ++cur_rec) {
+    fclose(file_rec[cur_rec]);
+  }
+  delete[] distortion_psnr;
+  delete[] distortion_ssim;
+  delete[] ch_org;
+  delete[] ch_rec;
+  delete[] file_rec;
+  return 0;
+}
diff --git a/3rdparty/libyuv/src/util/ssim.cc b/3rdparty/libyuv/src/util/ssim.cc
new file mode 100644
index 00000000..096fbcf0
--- /dev/null
+++ b/3rdparty/libyuv/src/util/ssim.cc
@@ -0,0 +1,364 @@
+/*
+ *  Copyright 2013 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include "../util/ssim.h"  // NOLINT
+
+#include <string.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef unsigned int uint32_t;    // NOLINT
+typedef unsigned short uint16_t;  // NOLINT
+
+#if !defined(LIBYUV_DISABLE_X86) && !defined(__SSE2__) && \
+    (defined(_M_X64) || (defined(_M_IX86_FP) && (_M_IX86_FP >= 2)))
+#define __SSE2__
+#endif
+#if !defined(LIBYUV_DISABLE_X86) && defined(__SSE2__)
+#include <emmintrin.h>
+#endif
+
+#ifdef _OPENMP
+#include <omp.h>
+#endif
+
+// SSIM
+enum { KERNEL = 3, KERNEL_SIZE = 2 * KERNEL + 1 };
+
+// Symmetric Gaussian kernel:  K[i] = ~11 * exp(-0.3 * i * i)
+// The maximum value (11 x 11) must be less than 128 to avoid sign
+// problems during the calls to _mm_mullo_epi16().
+static const int K[KERNEL_SIZE] = {
+    1, 3, 7, 11, 7, 3, 1  // ~11 * exp(-0.3 * i * i)
+};
+static const double kiW[KERNEL + 1 + 1] = {
+    1. / 1089.,  // 1 / sum(i:0..6, j..6) K[i]*K[j]
+    1. / 1089.,  // 1 / sum(i:0..6, j..6) K[i]*K[j]
+    1. / 1056.,  // 1 / sum(i:0..5, j..6) K[i]*K[j]
+    1. / 957.,   // 1 / sum(i:0..4, j..6) K[i]*K[j]
+    1. / 726.,   // 1 / sum(i:0..3, j..6) K[i]*K[j]
+};
+
+#if !defined(LIBYUV_DISABLE_X86) && defined(__SSE2__)
+
+#define PWEIGHT(A, B) static_cast<uint16_t>(K[(A)] * K[(B)])  // weight product
+#define MAKE_WEIGHT(L)                                                \
+  {                                                                   \
+    {                                                                 \
+      {                                                               \
+        PWEIGHT(L, 0)                                                 \
+        , PWEIGHT(L, 1), PWEIGHT(L, 2), PWEIGHT(L, 3), PWEIGHT(L, 4), \
+            PWEIGHT(L, 5), PWEIGHT(L, 6), 0                           \
+      }                                                               \
+    }                                                                 \
+  }
+
+// We need this union trick to be able to initialize constant static __m128i
+// values. We can't call _mm_set_epi16() for static compile-time initialization.
+static const struct {
+  union {
+    uint16_t i16_[8];
+    __m128i m_;
+  } values_;
+} W0 = MAKE_WEIGHT(0), W1 = MAKE_WEIGHT(1), W2 = MAKE_WEIGHT(2),
+  W3 = MAKE_WEIGHT(3);
+// ... the rest is symmetric.
+#undef MAKE_WEIGHT
+#undef PWEIGHT
+#endif
+
+// Common final expression for SSIM, once the weighted sums are known.
+static double FinalizeSSIM(double iw,
+                           double xm,
+                           double ym,
+                           double xxm,
+                           double xym,
+                           double yym) {
+  const double iwx = xm * iw;
+  const double iwy = ym * iw;
+  double sxx = xxm * iw - iwx * iwx;
+  double syy = yym * iw - iwy * iwy;
+  // small errors are possible, due to rounding. Clamp to zero.
+  if (sxx < 0.) {
+    sxx = 0.;
+  }
+  if (syy < 0.) {
+    syy = 0.;
+  }
+  const double sxsy = sqrt(sxx * syy);
+  const double sxy = xym * iw - iwx * iwy;
+  static const double C11 = (0.01 * 0.01) * (255 * 255);
+  static const double C22 = (0.03 * 0.03) * (255 * 255);
+  static const double C33 = (0.015 * 0.015) * (255 * 255);
+  const double l = (2. * iwx * iwy + C11) / (iwx * iwx + iwy * iwy + C11);
+  const double c = (2. * sxsy + C22) / (sxx + syy + C22);
+  const double s = (sxy + C33) / (sxsy + C33);
+  return l * c * s;
+}
+
+// GetSSIM() does clipping.  GetSSIMFullKernel() does not
+
+// TODO(skal): use summed tables?
+// Note: worst case of accumulation is a weight of 33 = 11 + 2 * (7 + 3 + 1)
+// with a diff of 255, squared. The maximum error is thus 0x4388241,
+// which fits into 32 bits integers.
+double GetSSIM(const uint8_t* org,
+               const uint8_t* rec,
+               int xo,
+               int yo,
+               int W,
+               int H,
+               int stride) {
+  uint32_t ws = 0, xm = 0, ym = 0, xxm = 0, xym = 0, yym = 0;
+  org += (yo - KERNEL) * stride;
+  org += (xo - KERNEL);
+  rec += (yo - KERNEL) * stride;
+  rec += (xo - KERNEL);
+  for (int y_ = 0; y_ < KERNEL_SIZE; ++y_, org += stride, rec += stride) {
+    if (((yo - KERNEL + y_) < 0) || ((yo - KERNEL + y_) >= H)) {
+      continue;
+    }
+    const int Wy = K[y_];
+    for (int x_ = 0; x_ < KERNEL_SIZE; ++x_) {
+      const int Wxy = Wy * K[x_];
+      if (((xo - KERNEL + x_) >= 0) && ((xo - KERNEL + x_) < W)) {
+        const int org_x = org[x_];
+        const int rec_x = rec[x_];
+        ws += Wxy;
+        xm += Wxy * org_x;
+        ym += Wxy * rec_x;
+        xxm += Wxy * org_x * org_x;
+        xym += Wxy * org_x * rec_x;
+        yym += Wxy * rec_x * rec_x;
+      }
+    }
+  }
+  return FinalizeSSIM(1. / ws, xm, ym, xxm, xym, yym);
+}
+
+double GetSSIMFullKernel(const uint8_t* org,
+                         const uint8_t* rec,
+                         int xo,
+                         int yo,
+                         int stride,
+                         double area_weight) {
+  uint32_t xm = 0, ym = 0, xxm = 0, xym = 0, yym = 0;
+
+#if defined(LIBYUV_DISABLE_X86) || !defined(__SSE2__)
+
+  org += yo * stride + xo;
+  rec += yo * stride + xo;
+  for (int y = 1; y <= KERNEL; y++) {
+    const int dy1 = y * stride;
+    const int dy2 = y * stride;
+    const int Wy = K[KERNEL + y];
+
+    for (int x = 1; x <= KERNEL; x++) {
+      // Compute the contributions of upper-left (ul), upper-right (ur)
+      // lower-left (ll) and lower-right (lr) points (see the diagram below).
+      // Symmetric Kernel will have same weight on those points.
+      //       -  -  -  -  -  -  -
+      //       -  ul -  -  -  ur -
+      //       -  -  -  -  -  -  -
+      //       -  -  -  0  -  -  -
+      //       -  -  -  -  -  -  -
+      //       -  ll -  -  -  lr -
+      //       -  -  -  -  -  -  -
+      const int Wxy = Wy * K[KERNEL + x];
+      const int ul1 = org[-dy1 - x];
+      const int ur1 = org[-dy1 + x];
+      const int ll1 = org[dy1 - x];
+      const int lr1 = org[dy1 + x];
+
+      const int ul2 = rec[-dy2 - x];
+      const int ur2 = rec[-dy2 + x];
+      const int ll2 = rec[dy2 - x];
+      const int lr2 = rec[dy2 + x];
+
+      xm += Wxy * (ul1 + ur1 + ll1 + lr1);
+      ym += Wxy * (ul2 + ur2 + ll2 + lr2);
+      xxm += Wxy * (ul1 * ul1 + ur1 * ur1 + ll1 * ll1 + lr1 * lr1);
+      xym += Wxy * (ul1 * ul2 + ur1 * ur2 + ll1 * ll2 + lr1 * lr2);
+      yym += Wxy * (ul2 * ul2 + ur2 * ur2 + ll2 * ll2 + lr2 * lr2);
+    }
+
+    // Compute the contributions of up (u), down (d), left (l) and right (r)
+    // points across the main axes (see the diagram below).
+    // Symmetric Kernel will have same weight on those points.
+    //       -  -  -  -  -  -  -
+    //       -  -  -  u  -  -  -
+    //       -  -  -  -  -  -  -
+    //       -  l  -  0  -  r  -
+    //       -  -  -  -  -  -  -
+    //       -  -  -  d  -  -  -
+    //       -  -  -  -  -  -  -
+    const int Wxy = Wy * K[KERNEL];
+    const int u1 = org[-dy1];
+    const int d1 = org[dy1];
+    const int l1 = org[-y];
+    const int r1 = org[y];
+
+    const int u2 = rec[-dy2];
+    const int d2 = rec[dy2];
+    const int l2 = rec[-y];
+    const int r2 = rec[y];
+
+    xm += Wxy * (u1 + d1 + l1 + r1);
+    ym += Wxy * (u2 + d2 + l2 + r2);
+    xxm += Wxy * (u1 * u1 + d1 * d1 + l1 * l1 + r1 * r1);
+    xym += Wxy * (u1 * u2 + d1 * d2 + l1 * l2 + r1 * r2);
+    yym += Wxy * (u2 * u2 + d2 * d2 + l2 * l2 + r2 * r2);
+  }
+
+  // Lastly the contribution of (x0, y0) point.
+  const int Wxy = K[KERNEL] * K[KERNEL];
+  const int s1 = org[0];
+  const int s2 = rec[0];
+
+  xm += Wxy * s1;
+  ym += Wxy * s2;
+  xxm += Wxy * s1 * s1;
+  xym += Wxy * s1 * s2;
+  yym += Wxy * s2 * s2;
+
+#else  // __SSE2__
+
+  org += (yo - KERNEL) * stride + (xo - KERNEL);
+  rec += (yo - KERNEL) * stride + (xo - KERNEL);
+
+  const __m128i zero = _mm_setzero_si128();
+  __m128i x = zero;
+  __m128i y = zero;
+  __m128i xx = zero;
+  __m128i xy = zero;
+  __m128i yy = zero;
+
+// Read 8 pixels at line #L, and convert to 16bit, perform weighting
+// and acccumulate.
+#define LOAD_LINE_PAIR(L, WEIGHT)                                            \
+  do {                                                                       \
+    const __m128i v0 =                                                       \
+        _mm_loadl_epi64(reinterpret_cast<const __m128i*>(org + (L)*stride)); \
+    const __m128i v1 =                                                       \
+        _mm_loadl_epi64(reinterpret_cast<const __m128i*>(rec + (L)*stride)); \
+    const __m128i w0 = _mm_unpacklo_epi8(v0, zero);                          \
+    const __m128i w1 = _mm_unpacklo_epi8(v1, zero);                          \
+    const __m128i ww0 = _mm_mullo_epi16(w0, (WEIGHT).values_.m_);            \
+    const __m128i ww1 = _mm_mullo_epi16(w1, (WEIGHT).values_.m_);            \
+    x = _mm_add_epi32(x, _mm_unpacklo_epi16(ww0, zero));                     \
+    y = _mm_add_epi32(y, _mm_unpacklo_epi16(ww1, zero));                     \
+    x = _mm_add_epi32(x, _mm_unpackhi_epi16(ww0, zero));                     \
+    y = _mm_add_epi32(y, _mm_unpackhi_epi16(ww1, zero));                     \
+    xx = _mm_add_epi32(xx, _mm_madd_epi16(ww0, w0));                         \
+    xy = _mm_add_epi32(xy, _mm_madd_epi16(ww0, w1));                         \
+    yy = _mm_add_epi32(yy, _mm_madd_epi16(ww1, w1));                         \
+  } while (0)
+
+#define ADD_AND_STORE_FOUR_EPI32(M, OUT)                    \
+  do {                                                      \
+    uint32_t tmp[4];                                        \
+    _mm_storeu_si128(reinterpret_cast<__m128i*>(tmp), (M)); \
+    (OUT) = tmp[3] + tmp[2] + tmp[1] + tmp[0];              \
+  } while (0)
+
+  LOAD_LINE_PAIR(0, W0);
+  LOAD_LINE_PAIR(1, W1);
+  LOAD_LINE_PAIR(2, W2);
+  LOAD_LINE_PAIR(3, W3);
+  LOAD_LINE_PAIR(4, W2);
+  LOAD_LINE_PAIR(5, W1);
+  LOAD_LINE_PAIR(6, W0);
+
+  ADD_AND_STORE_FOUR_EPI32(x, xm);
+  ADD_AND_STORE_FOUR_EPI32(y, ym);
+  ADD_AND_STORE_FOUR_EPI32(xx, xxm);
+  ADD_AND_STORE_FOUR_EPI32(xy, xym);
+  ADD_AND_STORE_FOUR_EPI32(yy, yym);
+
+#undef LOAD_LINE_PAIR
+#undef ADD_AND_STORE_FOUR_EPI32
+#endif
+
+  return FinalizeSSIM(area_weight, xm, ym, xxm, xym, yym);
+}
+
+static int start_max(int x, int y) {
+  return (x > y) ? x : y;
+}
+
+double CalcSSIM(const uint8_t* org,
+                const uint8_t* rec,
+                const int image_width,
+                const int image_height) {
+  double SSIM = 0.;
+  const int KERNEL_Y = (image_height < KERNEL) ? image_height : KERNEL;
+  const int KERNEL_X = (image_width < KERNEL) ? image_width : KERNEL;
+  const int start_x = start_max(image_width - 8 + KERNEL_X, KERNEL_X);
+  const int start_y = start_max(image_height - KERNEL_Y, KERNEL_Y);
+  const int stride = image_width;
+
+  for (int j = 0; j < KERNEL_Y; ++j) {
+    for (int i = 0; i < image_width; ++i) {
+      SSIM += GetSSIM(org, rec, i, j, image_width, image_height, stride);
+    }
+  }
+
+#ifdef _OPENMP
+#pragma omp parallel for reduction(+ : SSIM)
+#endif
+  for (int j = KERNEL_Y; j < image_height - KERNEL_Y; ++j) {
+    for (int i = 0; i < KERNEL_X; ++i) {
+      SSIM += GetSSIM(org, rec, i, j, image_width, image_height, stride);
+    }
+    for (int i = KERNEL_X; i < start_x; ++i) {
+      SSIM += GetSSIMFullKernel(org, rec, i, j, stride, kiW[0]);
+    }
+    if (start_x < image_width) {
+      // GetSSIMFullKernel() needs to be able to read 8 pixels (in SSE2). So we
+      // copy the 8 rightmost pixels on a cache area, and pad this area with
+      // zeros which won't contribute to the overall SSIM value (but we need
+      // to pass the correct normalizing constant!). By using this cache, we can
+      // still call GetSSIMFullKernel() instead of the slower GetSSIM().
+      // NOTE: we could use similar method for the left-most pixels too.
+      const int kScratchWidth = 8;
+      const int kScratchStride = kScratchWidth + KERNEL + 1;
+      uint8_t scratch_org[KERNEL_SIZE * kScratchStride] = {0};
+      uint8_t scratch_rec[KERNEL_SIZE * kScratchStride] = {0};
+
+      for (int k = 0; k < KERNEL_SIZE; ++k) {
+        const int offset =
+            (j - KERNEL + k) * stride + image_width - kScratchWidth;
+        memcpy(scratch_org + k * kScratchStride, org + offset, kScratchWidth);
+        memcpy(scratch_rec + k * kScratchStride, rec + offset, kScratchWidth);
+      }
+      for (int k = 0; k <= KERNEL_X + 1; ++k) {
+        SSIM += GetSSIMFullKernel(scratch_org, scratch_rec, KERNEL + k, KERNEL,
+                                  kScratchStride, kiW[k]);
+      }
+    }
+  }
+
+  for (int j = start_y; j < image_height; ++j) {
+    for (int i = 0; i < image_width; ++i) {
+      SSIM += GetSSIM(org, rec, i, j, image_width, image_height, stride);
+    }
+  }
+  return SSIM;
+}
+
+double CalcLSSIM(double ssim) {
+  return -10.0 * log10(1.0 - ssim);
+}
+
+#ifdef __cplusplus
+}  // extern "C"
+#endif
diff --git a/3rdparty/libyuv/src/util/ssim.h b/3rdparty/libyuv/src/util/ssim.h
new file mode 100644
index 00000000..a855f1d1
--- /dev/null
+++ b/3rdparty/libyuv/src/util/ssim.h
@@ -0,0 +1,38 @@
+/*
+ *  Copyright 2013 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+// Get SSIM for video sequence. Assuming RAW 4:2:0 Y:Cb:Cr format
+
+#ifndef UTIL_SSIM_H_
+#define UTIL_SSIM_H_
+
+#include <math.h>  // For log10()
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if !defined(INT_TYPES_DEFINED) && !defined(UINT8_TYPE_DEFINED)
+typedef unsigned char uint8_t;
+#define UINT8_TYPE_DEFINED
+#endif
+
+double CalcSSIM(const uint8_t* org,
+                const uint8_t* rec,
+                const int image_width,
+                const int image_height);
+
+double CalcLSSIM(double ssim);
+
+#ifdef __cplusplus
+}  // extern "C"
+#endif
+
+#endif  // UTIL_SSIM_H_
diff --git a/3rdparty/libyuv/src/util/yuvconstants.c b/3rdparty/libyuv/src/util/yuvconstants.c
new file mode 100644
index 00000000..7b6c9648
--- /dev/null
+++ b/3rdparty/libyuv/src/util/yuvconstants.c
@@ -0,0 +1,113 @@
+/*
+ *  Copyright 2021 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+// This utility computes values needed to generate yuvconstants based on
+// white point values.
+// The yuv formulas are tuned for 8 bit YUV channels.
+
+// See Also
+// https://mymusing.co/bt601-yuv-to-rgb-conversion-color/
+
+// BT.709 full range YUV to RGB reference
+//  R = Y               + V * 1.5748
+//  G = Y - U * 0.18732 - V * 0.46812
+//  B = Y + U * 1.8556
+//  KR = 0.2126
+//  KB = 0.0722
+
+// // Y contribution to R,G,B.  Scale and bias.
+// #define YG 16320 /* round(1.000 * 64 * 256 * 256 / 257) */
+// #define YB 32    /* 64 / 2 */
+//
+// // U and V contributions to R,G,B.
+// #define UB 113 /* round(1.77200 * 64) */
+// #define UG 22  /* round(0.34414 * 64) */
+// #define VG 46  /* round(0.71414 * 64) */
+// #define VR 90  /* round(1.40200 * 64) */
+//
+// // Bias values to round, and subtract 128 from U and V.
+// #define BB (-UB * 128 + YB)
+// #define BG (UG * 128 + VG * 128 + YB)
+// #define BR (-VR * 128 + YB)
+
+int main(int argc, const char* argv[]) {
+  if (argc < 2) {
+    printf("yuvconstants Kr Kb\n");
+    printf("  MC BT          KR = 0.2126; KB = 0.0722\n");
+    printf("  1  BT.709      KR = 0.2126; KB = 0.0722\n");
+    printf("  4  FCC         KR = 0.30;   KB = 0.11\n");
+    printf("  6  BT.601      KR = 0.299;  KB = 0.114\n");
+    printf("  7  SMPTE 240M  KR = 0.212;  KB = 0.087\n");
+    printf("  9  BT.2020     KR = 0.2627; KB = 0.0593\n");
+    return -1;
+  }
+  float kr = atof(argv[1]);
+  float kb = atof(argv[2]);
+  float kg = 1 - kr - kb;
+
+  float vr = 2 * (1 - kr);
+  float ug = 2 * ((1 - kb) * kb / kg);
+  float vg = 2 * ((1 - kr) * kr / kg);
+  float ub = 2 * (1 - kb);
+
+  printf("Full range\n");
+  printf("R = Y                + V * %5f\n", vr);
+  printf("G = Y - U * %6f - V * %6f\n", ug, vg);
+  printf("B = Y + U * %5f\n", ub);
+
+  printf("KR = %4f; ", kr);
+  printf("KB = %4f\n", kb);
+  // printf("KG = %4f\n", kg);
+  // #define YG 16320 /* round(1.000 * 64 * 256 * 256 / 257) */
+  // #define YB 32    /* 64 / 2 */
+  //
+  // // U and V contributions to R,G,B.
+
+  printf("UB %-3.0f /* round(%f * 64 = %8.4f) */\n", round(ub * 64), ub,
+         ub * 64);
+  printf("UG %-3.0f /* round(%f * 64 = %8.4f) */\n", round(ug * 64), ug,
+         ug * 64);
+  printf("VG %-3.0f /* round(%f * 64 = %8.4f) */\n", round(vg * 64), vg,
+         vg * 64);
+  printf("VR %-3.0f /* round(%f * 64 = %8.4f) */\n", round(vr * 64), vr,
+         vr * 64);
+
+  vr = 255.f / 224.f * 2 * (1 - kr);
+  ug = 255.f / 224.f * 2 * ((1 - kb) * kb / kg);
+  vg = 255.f / 224.f * 2 * ((1 - kr) * kr / kg);
+  ub = 255.f / 224.f * 2 * (1 - kb);
+
+  printf("\nLimited range\n");
+  printf("R = (Y - 16) * 1.164                + V * %5f\n", vr);
+  printf("G = (Y - 16) * 1.164 - U * %6f - V * %6f\n", ug, vg);
+  printf("B = (Y - 16) * 1.164 + U * %5f\n", ub);
+
+  // printf("KG = %4f\n", kg);
+  // #define YG 16320 /* round(1.000 * 64 * 256 * 256 / 257) */
+  // #define YB 32    /* 64 / 2 */
+  //
+  // // U and V contributions to R,G,B.
+
+  printf("UB %-3.0f /* round(%f * 64 = %8.4f) */\n", round(ub * 64), ub,
+         ub * 64);
+  printf("UG %-3.0f /* round(%f * 64 = %8.4f) */\n", round(ug * 64), ug,
+         ug * 64);
+  printf("VG %-3.0f /* round(%f * 64 = %8.4f) */\n", round(vg * 64), vg,
+         vg * 64);
+  printf("VR %-3.0f /* round(%f * 64 = %8.4f) */\n", round(vr * 64), vr,
+         vr * 64);
+
+  return 0;
+}
diff --git a/3rdparty/libyuv/src/util/yuvconvert.cc b/3rdparty/libyuv/src/util/yuvconvert.cc
new file mode 100644
index 00000000..332699e3
--- /dev/null
+++ b/3rdparty/libyuv/src/util/yuvconvert.cc
@@ -0,0 +1,367 @@
+/*
+ *  Copyright 2013 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+// Convert an ARGB image to YUV.
+// Usage: yuvconvert src_argb.raw dst_yuv.raw
+
+#ifndef _CRT_SECURE_NO_WARNINGS
+#define _CRT_SECURE_NO_WARNINGS
+#endif
+
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "libyuv/convert.h"
+#include "libyuv/planar_functions.h"
+#include "libyuv/scale_argb.h"
+
+// options
+bool verbose = false;
+bool attenuate = false;
+bool unattenuate = false;
+int image_width = 0, image_height = 0;  // original width and height
+int dst_width = 0, dst_height = 0;      // new width and height
+int fileindex_org = 0;  // argv argument contains the original file name.
+int fileindex_rec = 0;  // argv argument contains the reconstructed file name.
+int num_rec = 0;        // Number of reconstructed images.
+int num_skip_org = 0;   // Number of frames to skip in original.
+int num_frames = 0;     // Number of frames to convert.
+int filter = 1;         // Bilinear filter for scaling.
+
+static __inline uint32_t Abs(int32_t v) {
+  return v >= 0 ? v : -v;
+}
+
+// Parse PYUV format. ie name.1920x800_24Hz_P420.yuv
+bool ExtractResolutionFromFilename(const char* name,
+                                   int* width_ptr,
+                                   int* height_ptr) {
+  // Isolate the .width_height. section of the filename by searching for a
+  // dot or underscore followed by a digit.
+  for (int i = 0; name[i]; ++i) {
+    if ((name[i] == '.' || name[i] == '_') && name[i + 1] >= '0' &&
+        name[i + 1] <= '9') {
+      int n = sscanf(name + i + 1, "%dx%d", width_ptr, height_ptr);  // NOLINT
+      if (2 == n) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+void PrintHelp(const char* program) {
+  printf("%s [-options] src_argb.raw dst_yuv.raw\n", program);
+  printf(
+      " -s <width> <height> .... specify source resolution.  "
+      "Optional if name contains\n"
+      "                          resolution (ie. "
+      "name.1920x800_24Hz_P420.yuv)\n"
+      "                          Negative value mirrors.\n");
+  printf(" -d <width> <height> .... specify destination resolution.\n");
+  printf(" -f <filter> ............ 0 = point, 1 = bilinear (default).\n");
+  printf(" -skip <src_argb> ....... Number of frame to skip of src_argb\n");
+  printf(" -frames <num> .......... Number of frames to convert\n");
+  printf(" -attenuate ............. Attenuate the ARGB image\n");
+  printf(" -unattenuate ........... Unattenuate the ARGB image\n");
+  printf(" -v ..................... verbose\n");
+  printf(" -h ..................... this help\n");
+  exit(0);
+}
+
+void ParseOptions(int argc, const char* argv[]) {
+  if (argc <= 1) {
+    PrintHelp(argv[0]);
+  }
+  for (int c = 1; c < argc; ++c) {
+    if (!strcmp(argv[c], "-v")) {
+      verbose = true;
+    } else if (!strcmp(argv[c], "-attenuate")) {
+      attenuate = true;
+    } else if (!strcmp(argv[c], "-unattenuate")) {
+      unattenuate = true;
+    } else if (!strcmp(argv[c], "-h") || !strcmp(argv[c], "-help")) {
+      PrintHelp(argv[0]);
+    } else if (!strcmp(argv[c], "-s") && c + 2 < argc) {
+      image_width = atoi(argv[++c]);   // NOLINT
+      image_height = atoi(argv[++c]);  // NOLINT
+    } else if (!strcmp(argv[c], "-d") && c + 2 < argc) {
+      dst_width = atoi(argv[++c]);   // NOLINT
+      dst_height = atoi(argv[++c]);  // NOLINT
+    } else if (!strcmp(argv[c], "-skip") && c + 1 < argc) {
+      num_skip_org = atoi(argv[++c]);  // NOLINT
+    } else if (!strcmp(argv[c], "-frames") && c + 1 < argc) {
+      num_frames = atoi(argv[++c]);  // NOLINT
+    } else if (!strcmp(argv[c], "-f") && c + 1 < argc) {
+      filter = atoi(argv[++c]);  // NOLINT
+    } else if (argv[c][0] == '-') {
+      fprintf(stderr, "Unknown option. %s\n", argv[c]);
+    } else if (fileindex_org == 0) {
+      fileindex_org = c;
+    } else if (fileindex_rec == 0) {
+      fileindex_rec = c;
+      num_rec = 1;
+    } else {
+      ++num_rec;
+    }
+  }
+  if (fileindex_org == 0 || fileindex_rec == 0) {
+    fprintf(stderr, "Missing filenames\n");
+    PrintHelp(argv[0]);
+  }
+  if (num_skip_org < 0) {
+    fprintf(stderr, "Skipped frames incorrect\n");
+    PrintHelp(argv[0]);
+  }
+  if (num_frames < 0) {
+    fprintf(stderr, "Number of frames incorrect\n");
+    PrintHelp(argv[0]);
+  }
+
+  int org_width, org_height;
+  int rec_width, rec_height;
+  bool org_res_avail = ExtractResolutionFromFilename(argv[fileindex_org],
+                                                     &org_width, &org_height);
+  bool rec_res_avail = ExtractResolutionFromFilename(argv[fileindex_rec],
+                                                     &rec_width, &rec_height);
+  if (image_width == 0 || image_height == 0) {
+    if (org_res_avail) {
+      image_width = org_width;
+      image_height = org_height;
+    } else if (rec_res_avail) {
+      image_width = rec_width;
+      image_height = rec_height;
+    } else {
+      fprintf(stderr, "Missing dimensions.\n");
+      PrintHelp(argv[0]);
+    }
+  }
+  if (dst_width == 0 || dst_height == 0) {
+    if (rec_res_avail) {
+      dst_width = rec_width;
+      dst_height = rec_height;
+    } else {
+      dst_width = Abs(image_width);
+      dst_height = Abs(image_height);
+    }
+  }
+}
+
+static const int kTileX = 32;
+static const int kTileY = 32;
+
+static int TileARGBScale(const uint8_t* src_argb,
+                         int src_stride_argb,
+                         int src_width,
+                         int src_height,
+                         uint8_t* dst_argb,
+                         int dst_stride_argb,
+                         int destination_width,
+                         int destination_height,
+                         libyuv::FilterMode filtering) {
+  for (int y = 0; y < destination_height; y += kTileY) {
+    for (int x = 0; x < destination_width; x += kTileX) {
+      int clip_width = kTileX;
+      if (x + clip_width > destination_width) {
+        clip_width = destination_width - x;
+      }
+      int clip_height = kTileY;
+      if (y + clip_height > destination_height) {
+        clip_height = destination_height - y;
+      }
+      int r = libyuv::ARGBScaleClip(src_argb, src_stride_argb, src_width,
+                                    src_height, dst_argb, dst_stride_argb,
+                                    destination_width, destination_height, x, y,
+                                    clip_width, clip_height, filtering);
+      if (r) {
+        return r;
+      }
+    }
+  }
+  return 0;
+}
+
+int main(int argc, const char* argv[]) {
+  ParseOptions(argc, argv);
+
+  // Open original file (first file argument)
+  FILE* const file_org = fopen(argv[fileindex_org], "rb");
+  if (file_org == NULL) {
+    fprintf(stderr, "Cannot open %s\n", argv[fileindex_org]);
+    exit(1);
+  }
+
+  // Open all files to convert to
+  FILE** file_rec = new FILE*[num_rec];
+  memset(file_rec, 0, num_rec * sizeof(FILE*));  // NOLINT
+  for (int cur_rec = 0; cur_rec < num_rec; ++cur_rec) {
+    file_rec[cur_rec] = fopen(argv[fileindex_rec + cur_rec], "wb");
+    if (file_rec[cur_rec] == NULL) {
+      fprintf(stderr, "Cannot open %s\n", argv[fileindex_rec + cur_rec]);
+      fclose(file_org);
+      for (int i = 0; i < cur_rec; ++i) {
+        fclose(file_rec[i]);
+      }
+      delete[] file_rec;
+      exit(1);
+    }
+  }
+
+  bool org_is_yuv = strstr(argv[fileindex_org], "_P420.") != NULL;
+  bool org_is_argb = strstr(argv[fileindex_org], "_ARGB.") != NULL;
+  if (!org_is_yuv && !org_is_argb) {
+    fprintf(stderr, "Original format unknown %s\n", argv[fileindex_org]);
+    exit(1);
+  }
+  int org_size = Abs(image_width) * Abs(image_height) * 4;  // ARGB
+  // Input is YUV
+  if (org_is_yuv) {
+    const int y_size = Abs(image_width) * Abs(image_height);
+    const int uv_size =
+        ((Abs(image_width) + 1) / 2) * ((Abs(image_height) + 1) / 2);
+    org_size = y_size + 2 * uv_size;  // YUV original.
+  }
+
+  const int dst_size = dst_width * dst_height * 4;  // ARGB scaled
+  const int y_size = dst_width * dst_height;
+  const int uv_size = ((dst_width + 1) / 2) * ((dst_height + 1) / 2);
+  const size_t total_size = y_size + 2 * uv_size;
+#if defined(_MSC_VER)
+  _fseeki64(file_org,
+            static_cast<__int64>(num_skip_org) * static_cast<__int64>(org_size),
+            SEEK_SET);
+#else
+  fseek(file_org, num_skip_org * total_size, SEEK_SET);
+#endif
+
+  uint8_t* const ch_org = new uint8_t[org_size];
+  uint8_t* const ch_dst = new uint8_t[dst_size];
+  uint8_t* const ch_rec = new uint8_t[total_size];
+  if (ch_org == NULL || ch_rec == NULL) {
+    fprintf(stderr, "No memory available\n");
+    fclose(file_org);
+    for (int i = 0; i < num_rec; ++i) {
+      fclose(file_rec[i]);
+    }
+    delete[] ch_org;
+    delete[] ch_dst;
+    delete[] ch_rec;
+    delete[] file_rec;
+    exit(1);
+  }
+
+  if (verbose) {
+    printf("Size: %dx%d to %dx%d\n", image_width, image_height, dst_width,
+           dst_height);
+  }
+
+  int number_of_frames;
+  for (number_of_frames = 0;; ++number_of_frames) {
+    if (num_frames && number_of_frames >= num_frames) {
+      break;
+    }
+
+    // Load original YUV or ARGB frame.
+    size_t bytes_org =
+        fread(ch_org, sizeof(uint8_t), static_cast<size_t>(org_size), file_org);
+    if (bytes_org < static_cast<size_t>(org_size)) {
+      break;
+    }
+
+    // TODO(fbarchard): Attenuate doesnt need to know dimensions.
+    // ARGB attenuate frame
+    if (org_is_argb && attenuate) {
+      libyuv::ARGBAttenuate(ch_org, 0, ch_org, 0, org_size / 4, 1);
+    }
+    // ARGB unattenuate frame
+    if (org_is_argb && unattenuate) {
+      libyuv::ARGBUnattenuate(ch_org, 0, ch_org, 0, org_size / 4, 1);
+    }
+
+    for (int cur_rec = 0; cur_rec < num_rec; ++cur_rec) {
+      // Scale YUV or ARGB frame.
+      if (org_is_yuv) {
+        int src_width = Abs(image_width);
+        int src_height = Abs(image_height);
+        int half_src_width = (src_width + 1) / 2;
+        int half_src_height = (src_height + 1) / 2;
+        int half_dst_width = (dst_width + 1) / 2;
+        int half_dst_height = (dst_height + 1) / 2;
+        I420Scale(
+            ch_org, src_width, ch_org + src_width * src_height, half_src_width,
+            ch_org + src_width * src_height + half_src_width * half_src_height,
+            half_src_width, image_width, image_height, ch_rec, dst_width,
+            ch_rec + dst_width * dst_height, half_dst_width,
+            ch_rec + dst_width * dst_height + half_dst_width * half_dst_height,
+            half_dst_width, dst_width, dst_height,
+            static_cast<libyuv::FilterMode>(filter));
+      } else {
+        TileARGBScale(ch_org, Abs(image_width) * 4, image_width, image_height,
+                      ch_dst, dst_width * 4, dst_width, dst_height,
+                      static_cast<libyuv::FilterMode>(filter));
+      }
+      bool rec_is_yuv = strstr(argv[fileindex_rec + cur_rec], "_P420.") != NULL;
+      bool rec_is_argb =
+          strstr(argv[fileindex_rec + cur_rec], "_ARGB.") != NULL;
+      if (!rec_is_yuv && !rec_is_argb) {
+        fprintf(stderr, "Output format unknown %s\n",
+                argv[fileindex_rec + cur_rec]);
+        continue;  // Advance to next file.
+      }
+
+      // Convert ARGB to YUV.
+      if (!org_is_yuv && rec_is_yuv) {
+        int half_width = (dst_width + 1) / 2;
+        int half_height = (dst_height + 1) / 2;
+        libyuv::ARGBToI420(
+            ch_dst, dst_width * 4, ch_rec, dst_width,
+            ch_rec + dst_width * dst_height, half_width,
+            ch_rec + dst_width * dst_height + half_width * half_height,
+            half_width, dst_width, dst_height);
+      }
+
+      // Output YUV or ARGB frame.
+      if (rec_is_yuv) {
+        size_t bytes_rec =
+            fwrite(ch_rec, sizeof(uint8_t), static_cast<size_t>(total_size),
+                   file_rec[cur_rec]);
+        if (bytes_rec < static_cast<size_t>(total_size)) {
+          break;
+        }
+      } else {
+        size_t bytes_rec =
+            fwrite(ch_dst, sizeof(uint8_t), static_cast<size_t>(dst_size),
+                   file_rec[cur_rec]);
+        if (bytes_rec < static_cast<size_t>(dst_size)) {
+          break;
+        }
+      }
+      if (verbose) {
+        printf("%5d", number_of_frames);
+      }
+      if (verbose) {
+        printf("\t%s", argv[fileindex_rec + cur_rec]);
+        printf("\n");
+      }
+    }
+  }
+
+  fclose(file_org);
+  for (int cur_rec = 0; cur_rec < num_rec; ++cur_rec) {
+    fclose(file_rec[cur_rec]);
+  }
+  delete[] ch_org;
+  delete[] ch_dst;
+  delete[] ch_rec;
+  delete[] file_rec;
+  return 0;
+}
diff --git a/3rdparty/libyuv/src/winarm.mk b/3rdparty/libyuv/src/winarm.mk
new file mode 100644
index 00000000..b0a344ae
--- /dev/null
+++ b/3rdparty/libyuv/src/winarm.mk
@@ -0,0 +1,47 @@
+# This is a generic makefile for libyuv for Windows Arm.
+# call "c:\Program Files (x86)\Microsoft Visual Studio 11.0\VC\bin\x86_arm\vcvarsx86_arm.bat"
+# nmake /f winarm.mk
+# make -f winarm.mk
+# nmake /f winarm.mk clean
+# consider /arch:ARMv7VE
+CC=cl
+CCFLAGS=/Ox /nologo /Iinclude /DWINAPI_FAMILY=WINAPI_FAMILY_PHONE_APP
+AR=lib
+ARFLAGS=/MACHINE:ARM /NOLOGO /SUBSYSTEM:NATIVE
+RM=cmd /c del
+
+LOCAL_OBJ_FILES = \
+	source/compare.o\
+	source/compare_common.o\
+	source/convert.o\
+	source/convert_argb.o\
+	source/convert_from.o\
+	source/convert_from_argb.o\
+	source/convert_to_argb.o\
+	source/convert_to_i420.o\
+	source/cpu_id.o\
+	source/planar_functions.o\
+	source/rotate.o\
+	source/rotate_any.o\
+	source/rotate_argb.o\
+	source/rotate_common.o\
+	source/row_any.o\
+	source/row_common.o\
+	source/scale.o\
+	source/scale_any.o\
+	source/scale_argb.o\
+	source/scale_common.o\
+	source/scale_uv.o\
+	source/video_common.o
+
+.cc.o:
+	$(CC) /c $(CCFLAGS) $*.cc /Fo$@
+
+all: libyuv_arm.lib winarm.mk
+
+libyuv_arm.lib: $(LOCAL_OBJ_FILES) winarm.mk
+	$(AR) $(ARFLAGS) /OUT:$@ $(LOCAL_OBJ_FILES)
+
+clean:
+	$(RM) "source\*.o" libyuv_arm.lib
+
diff --git a/3rdparty/live555/CMakeLists.txt b/3rdparty/live555/CMakeLists.txt
new file mode 100644
index 00000000..f0d4530e
--- /dev/null
+++ b/3rdparty/live555/CMakeLists.txt
@@ -0,0 +1,12 @@
+cmake_minimum_required(VERSION 3.5)
+
+add_subdirectory(src)
+
+# Remove warning as error for live555
+get_target_property(compile_options live555 COMPILE_OPTIONS)
+list(REMOVE_ITEM compile_options "-Werror" "/WX")
+set_target_properties(live555 PROPERTIES COMPILE_OPTIONS "${compile_options}")
+
+add_library(live555::live555 ALIAS live555)
+ob_source_group(live555::live555)
+set_target_properties(live555 PROPERTIES FOLDER "dependencies")
diff --git a/3rdparty/live555/src/BasicUsageEnvironment/BasicHashTable.cpp b/3rdparty/live555/src/BasicUsageEnvironment/BasicHashTable.cpp
new file mode 100644
index 00000000..19ba7507
--- /dev/null
+++ b/3rdparty/live555/src/BasicUsageEnvironment/BasicHashTable.cpp
@@ -0,0 +1,293 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// Basic Hash Table implementation
+// Implementation
+
+#include "BasicHashTable.hh"
+#include "strDup.hh"
+
+#if defined(__WIN32__) || defined(_WIN32)
+#else
+#include <stddef.h>
+#endif
+#include <string.h>
+#include <stdio.h>
+
+// When there are this many entries per bucket, on average, rebuild
+// the table to increase the number of buckets
+#define REBUILD_MULTIPLIER 3
+
+BasicHashTable::BasicHashTable(int keyType)
+    : fBuckets(fStaticBuckets),
+      fNumBuckets(SMALL_HASH_TABLE_SIZE),
+      fNumEntries(0),
+      fRebuildSize(SMALL_HASH_TABLE_SIZE * REBUILD_MULTIPLIER),
+      fDownShift(28),
+      fMask(0x3),
+      fKeyType(keyType) {
+    for(unsigned i = 0; i < SMALL_HASH_TABLE_SIZE; ++i) {
+        fStaticBuckets[i] = NULL;
+    }
+}
+
+BasicHashTable::~BasicHashTable() {
+    // Free all the entries in the table:
+    for(unsigned i = 0; i < fNumBuckets; ++i) {
+        TableEntry *entry;
+        while((entry = fBuckets[i]) != NULL) {
+            deleteEntry(i, entry);
+        }
+    }
+
+    // Also free the bucket array, if it was dynamically allocated:
+    if(fBuckets != fStaticBuckets)
+        delete[] fBuckets;
+}
+
+void *BasicHashTable::Add(char const *key, void *value) {
+    void *      oldValue;
+    unsigned    index;
+    TableEntry *entry = lookupKey(key, index);
+    if(entry != NULL) {
+        // There's already an item with this key
+        oldValue = entry->value;
+    }
+    else {
+        // There's no existing entry; create a new one:
+        entry    = insertNewEntry(index, key);
+        oldValue = NULL;
+    }
+    entry->value = value;
+
+    // If the table has become too large, rebuild it with more buckets:
+    if(fNumEntries >= fRebuildSize)
+        rebuild();
+
+    return oldValue;
+}
+
+Boolean BasicHashTable::Remove(char const *key) {
+    unsigned    index;
+    TableEntry *entry = lookupKey(key, index);
+    if(entry == NULL)
+        return False;  // no such entry
+
+    deleteEntry(index, entry);
+
+    return True;
+}
+
+void *BasicHashTable::Lookup(char const *key) const {
+    unsigned    index;
+    TableEntry *entry = lookupKey(key, index);
+    if(entry == NULL)
+        return NULL;  // no such entry
+
+    return entry->value;
+}
+
+unsigned BasicHashTable::numEntries() const {
+    return fNumEntries;
+}
+
+BasicHashTable::Iterator::Iterator(BasicHashTable const &table) : fTable(table), fNextIndex(0), fNextEntry(NULL) {}
+
+void *BasicHashTable::Iterator::next(char const *&key) {
+    while(fNextEntry == NULL) {
+        if(fNextIndex >= fTable.fNumBuckets)
+            return NULL;
+
+        fNextEntry = fTable.fBuckets[fNextIndex++];
+    }
+
+    BasicHashTable::TableEntry *entry = fNextEntry;
+    fNextEntry                        = entry->fNext;
+
+    key = entry->key;
+    return entry->value;
+}
+
+////////// Implementation of HashTable creation functions //////////
+
+HashTable *HashTable::create(int keyType) {
+    return new BasicHashTable(keyType);
+}
+
+HashTable::Iterator *HashTable::Iterator::create(HashTable const &hashTable) {
+    // "hashTable" is assumed to be a BasicHashTable
+    return new BasicHashTable::Iterator((BasicHashTable const &)hashTable);
+}
+
+////////// Implementation of internal member functions //////////
+
+BasicHashTable::TableEntry *BasicHashTable ::lookupKey(char const *key, unsigned &index) const {
+    TableEntry *entry;
+    index = hashIndexFromKey(key);
+
+    for(entry = fBuckets[index]; entry != NULL; entry = entry->fNext) {
+        if(keyMatches(key, entry->key))
+            break;
+    }
+
+    return entry;
+}
+
+Boolean BasicHashTable ::keyMatches(char const *key1, char const *key2) const {
+    // The way we check the keys for a match depends upon their type:
+    if(fKeyType == STRING_HASH_KEYS) {
+        return (strcmp(key1, key2) == 0);
+    }
+    else if(fKeyType == ONE_WORD_HASH_KEYS) {
+        return (key1 == key2);
+    }
+    else {
+        unsigned *k1 = (unsigned *)key1;
+        unsigned *k2 = (unsigned *)key2;
+
+        for(int i = 0; i < fKeyType; ++i) {
+            if(k1[i] != k2[i])
+                return False;  // keys differ
+        }
+        return True;
+    }
+}
+
+BasicHashTable::TableEntry *BasicHashTable ::insertNewEntry(unsigned index, char const *key) {
+    TableEntry *entry = new TableEntry();
+    entry->fNext      = fBuckets[index];
+    fBuckets[index]   = entry;
+
+    ++fNumEntries;
+    assignKey(entry, key);
+
+    return entry;
+}
+
+void BasicHashTable::assignKey(TableEntry *entry, char const *key) {
+    // The way we assign the key depends upon its type:
+    if(fKeyType == STRING_HASH_KEYS) {
+        entry->key = strDup(key);
+    }
+    else if(fKeyType == ONE_WORD_HASH_KEYS) {
+        entry->key = key;
+    }
+    else if(fKeyType > 0) {
+        unsigned *keyFrom = (unsigned *)key;
+        unsigned *keyTo   = new unsigned[fKeyType];
+        for(int i = 0; i < fKeyType; ++i)
+            keyTo[i] = keyFrom[i];
+
+        entry->key = (char const *)keyTo;
+    }
+}
+
+void BasicHashTable::deleteEntry(unsigned index, TableEntry *entry) {
+    TableEntry **ep = &fBuckets[index];
+
+    Boolean foundIt = False;
+    while(*ep != NULL) {
+        if(*ep == entry) {
+            foundIt = True;
+            *ep     = entry->fNext;
+            break;
+        }
+        ep = &((*ep)->fNext);
+    }
+
+    if(!foundIt) {  // shouldn't happen
+#ifdef DEBUG
+        fprintf(stderr, "BasicHashTable[%p]::deleteEntry(%d,%p): internal error - not found (first entry %p", this, index, entry, fBuckets[index]);
+        if(fBuckets[index] != NULL)
+            fprintf(stderr, ", next entry %p", fBuckets[index]->fNext);
+        fprintf(stderr, ")\n");
+#endif
+    }
+
+    --fNumEntries;
+    deleteKey(entry);
+    delete entry;
+}
+
+void BasicHashTable::deleteKey(TableEntry *entry) {
+    // The way we delete the key depends upon its type:
+    if(fKeyType == ONE_WORD_HASH_KEYS) {
+        entry->key = NULL;
+    }
+    else {
+        delete[](char *) entry->key;
+        entry->key = NULL;
+    }
+}
+
+void BasicHashTable::rebuild() {
+    // Remember the existing table size:
+    unsigned     oldSize    = fNumBuckets;
+    TableEntry **oldBuckets = fBuckets;
+
+    // Create the new sized table:
+    fNumBuckets *= 4;
+    fBuckets = new TableEntry *[fNumBuckets];
+    for(unsigned i = 0; i < fNumBuckets; ++i) {
+        fBuckets[i] = NULL;
+    }
+    fRebuildSize *= 4;
+    fDownShift -= 2;
+    fMask = (fMask << 2) | 0x3;
+
+    // Rehash the existing entries into the new table:
+    for(TableEntry **oldChainPtr = oldBuckets; oldSize > 0; --oldSize, ++oldChainPtr) {
+        for(TableEntry *hPtr = *oldChainPtr; hPtr != NULL; hPtr = *oldChainPtr) {
+            *oldChainPtr = hPtr->fNext;
+
+            unsigned index = hashIndexFromKey(hPtr->key);
+
+            hPtr->fNext     = fBuckets[index];
+            fBuckets[index] = hPtr;
+        }
+    }
+
+    // Free the old bucket array, if it was dynamically allocated:
+    if(oldBuckets != fStaticBuckets)
+        delete[] oldBuckets;
+}
+
+unsigned BasicHashTable::hashIndexFromKey(char const *key) const {
+    unsigned result = 0;
+
+    if(fKeyType == STRING_HASH_KEYS) {
+        while(1) {
+            char c = *key++;
+            if(c == 0)
+                break;
+            result += (result << 3) + (unsigned)c;
+        }
+        result &= fMask;
+    }
+    else if(fKeyType == ONE_WORD_HASH_KEYS) {
+        result = randomIndex((uintptr_t)key);
+    }
+    else {
+        unsigned *k   = (unsigned *)key;
+        uintptr_t sum = 0;
+        for(int i = 0; i < fKeyType; ++i) {
+            sum += k[i];
+        }
+        result = randomIndex(sum);
+    }
+
+    return result;
+}
diff --git a/3rdparty/live555/src/BasicUsageEnvironment/BasicTaskScheduler.cpp b/3rdparty/live555/src/BasicUsageEnvironment/BasicTaskScheduler.cpp
new file mode 100644
index 00000000..76a21d26
--- /dev/null
+++ b/3rdparty/live555/src/BasicUsageEnvironment/BasicTaskScheduler.cpp
@@ -0,0 +1,288 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// Basic Usage Environment: for a simple, non-scripted, console application
+// Implementation
+
+#include "BasicUsageEnvironment.hh"
+#include "HandlerSet.hh"
+#include <stdio.h>
+#if defined(_QNX4)
+#include <sys/select.h>
+#include <unix.h>
+#endif
+
+////////// BasicTaskScheduler //////////
+
+BasicTaskScheduler *BasicTaskScheduler::createNew(unsigned maxSchedulerGranularity) {
+    return new BasicTaskScheduler(maxSchedulerGranularity);
+}
+
+BasicTaskScheduler::BasicTaskScheduler(unsigned maxSchedulerGranularity)
+    : fMaxSchedulerGranularity(maxSchedulerGranularity),
+      fMaxNumSockets(0)
+#if defined(__WIN32__) || defined(_WIN32)
+      ,
+      fDummySocketNum(-1)
+#endif
+{
+    FD_ZERO(&fReadSet);
+    FD_ZERO(&fWriteSet);
+    FD_ZERO(&fExceptionSet);
+
+    if(maxSchedulerGranularity > 0)
+        schedulerTickTask();  // ensures that we handle events frequently
+}
+
+BasicTaskScheduler::~BasicTaskScheduler() {
+#if defined(__WIN32__) || defined(_WIN32)
+    if(fDummySocketNum >= 0)
+        closeSocket(fDummySocketNum);
+#endif
+}
+
+void BasicTaskScheduler::schedulerTickTask(void *clientData) {
+    ((BasicTaskScheduler *)clientData)->schedulerTickTask();
+}
+
+void BasicTaskScheduler::schedulerTickTask() {
+    scheduleDelayedTask(fMaxSchedulerGranularity, schedulerTickTask, this);
+}
+
+#ifndef MILLION
+#define MILLION 1000000
+#endif
+
+void BasicTaskScheduler::SingleStep(unsigned maxDelayTime) {
+    fd_set readSet      = fReadSet;       // make a copy for this select() call
+    fd_set writeSet     = fWriteSet;      // ditto
+    fd_set exceptionSet = fExceptionSet;  // ditto
+
+    DelayInterval const &timeToDelay = fDelayQueue.timeToNextAlarm();
+    struct timeval       tv_timeToDelay;
+    tv_timeToDelay.tv_sec  = timeToDelay.seconds();
+    tv_timeToDelay.tv_usec = timeToDelay.useconds();
+    // Very large "tv_sec" values cause select() to fail.
+    // Don't make it any larger than 1 million seconds (11.5 days)
+    const long MAX_TV_SEC = MILLION;
+    if(tv_timeToDelay.tv_sec > MAX_TV_SEC) {
+        tv_timeToDelay.tv_sec = MAX_TV_SEC;
+    }
+    // Also check our "maxDelayTime" parameter (if it's > 0):
+    if(maxDelayTime > 0
+       && (tv_timeToDelay.tv_sec > (long)maxDelayTime / MILLION
+           || (tv_timeToDelay.tv_sec == (long)maxDelayTime / MILLION && tv_timeToDelay.tv_usec > (long)maxDelayTime % MILLION))) {
+        tv_timeToDelay.tv_sec  = maxDelayTime / MILLION;
+        tv_timeToDelay.tv_usec = maxDelayTime % MILLION;
+    }
+
+    int selectResult = select(fMaxNumSockets, &readSet, &writeSet, &exceptionSet, &tv_timeToDelay);
+    if(selectResult < 0) {
+#if defined(__WIN32__) || defined(_WIN32)
+        int err = WSAGetLastError();
+        // For some unknown reason, select() in Windoze sometimes fails with WSAEINVAL if
+        // it was called with no entries set in "readSet".  If this happens, ignore it:
+        if(err == WSAEINVAL && readSet.fd_count == 0) {
+            err = EINTR;
+            // To stop this from happening again, create a dummy socket:
+            if(fDummySocketNum >= 0)
+                closeSocket(fDummySocketNum);
+            fDummySocketNum = socket(AF_INET, SOCK_DGRAM, 0);
+            FD_SET((unsigned)fDummySocketNum, &fReadSet);
+        }
+        if(err != EINTR) {
+#else
+        if(errno != EINTR && errno != EAGAIN) {
+#endif
+            // Unexpected error - treat this as fatal:
+#if !defined(_WIN32_WCE)
+            perror("BasicTaskScheduler::SingleStep(): select() fails");
+            // Because this failure is often "Bad file descriptor" - which is caused by an invalid socket number (i.e., a socket number
+            // that had already been closed) being used in "select()" - we print out the sockets that were being used in "select()",
+            // to assist in debugging:
+            fprintf(stderr, "socket numbers used in the select() call:");
+            for(int i = 0; i < 10000; ++i) {
+                if(FD_ISSET(i, &fReadSet) || FD_ISSET(i, &fWriteSet) || FD_ISSET(i, &fExceptionSet)) {
+                    fprintf(stderr, " %d(", i);
+                    if(FD_ISSET(i, &fReadSet))
+                        fprintf(stderr, "r");
+                    if(FD_ISSET(i, &fWriteSet))
+                        fprintf(stderr, "w");
+                    if(FD_ISSET(i, &fExceptionSet))
+                        fprintf(stderr, "e");
+                    fprintf(stderr, ")");
+                }
+            }
+            fprintf(stderr, "\n");
+#endif
+            internalError();
+        }
+    }
+
+    // Call the handler function for one readable socket:
+    HandlerIterator    iter(*fHandlers);
+    HandlerDescriptor *handler;
+    // To ensure forward progress through the handlers, begin past the last
+    // socket number that we handled:
+    if(fLastHandledSocketNum >= 0) {
+        while((handler = iter.next()) != NULL) {
+            if(handler->socketNum == fLastHandledSocketNum)
+                break;
+        }
+        if(handler == NULL) {
+            fLastHandledSocketNum = -1;
+            iter.reset();  // start from the beginning instead
+        }
+    }
+    while((handler = iter.next()) != NULL) {
+        int sock               = handler->socketNum;  // alias
+        int resultConditionSet = 0;
+        if(FD_ISSET(sock, &readSet) && FD_ISSET(sock, &fReadSet) /*sanity check*/)
+            resultConditionSet |= SOCKET_READABLE;
+        if(FD_ISSET(sock, &writeSet) && FD_ISSET(sock, &fWriteSet) /*sanity check*/)
+            resultConditionSet |= SOCKET_WRITABLE;
+        if(FD_ISSET(sock, &exceptionSet) && FD_ISSET(sock, &fExceptionSet) /*sanity check*/)
+            resultConditionSet |= SOCKET_EXCEPTION;
+        if((resultConditionSet & handler->conditionSet) != 0 && handler->handlerProc != NULL) {
+            fLastHandledSocketNum = sock;
+            // Note: we set "fLastHandledSocketNum" before calling the handler,
+            // in case the handler calls "doEventLoop()" reentrantly.
+            (*handler->handlerProc)(handler->clientData, resultConditionSet);
+            break;
+        }
+    }
+    if(handler == NULL && fLastHandledSocketNum >= 0) {
+        // We didn't call a handler, but we didn't get to check all of them,
+        // so try again from the beginning:
+        iter.reset();
+        while((handler = iter.next()) != NULL) {
+            int sock               = handler->socketNum;  // alias
+            int resultConditionSet = 0;
+            if(FD_ISSET(sock, &readSet) && FD_ISSET(sock, &fReadSet) /*sanity check*/)
+                resultConditionSet |= SOCKET_READABLE;
+            if(FD_ISSET(sock, &writeSet) && FD_ISSET(sock, &fWriteSet) /*sanity check*/)
+                resultConditionSet |= SOCKET_WRITABLE;
+            if(FD_ISSET(sock, &exceptionSet) && FD_ISSET(sock, &fExceptionSet) /*sanity check*/)
+                resultConditionSet |= SOCKET_EXCEPTION;
+            if((resultConditionSet & handler->conditionSet) != 0 && handler->handlerProc != NULL) {
+                fLastHandledSocketNum = sock;
+                // Note: we set "fLastHandledSocketNum" before calling the handler,
+                // in case the handler calls "doEventLoop()" reentrantly.
+                (*handler->handlerProc)(handler->clientData, resultConditionSet);
+                break;
+            }
+        }
+        if(handler == NULL)
+            fLastHandledSocketNum = -1;  // because we didn't call a handler
+    }
+
+    // Also handle any newly-triggered event (Note that we do this *after* calling a socket handler,
+    // in case the triggered event handler modifies The set of readable sockets.)
+    if(fTriggersAwaitingHandling != 0) {
+        if(fTriggersAwaitingHandling == fLastUsedTriggerMask) {
+            // Common-case optimization for a single event trigger:
+            fTriggersAwaitingHandling &= ~fLastUsedTriggerMask;
+            if(fTriggeredEventHandlers[fLastUsedTriggerNum] != NULL) {
+                (*fTriggeredEventHandlers[fLastUsedTriggerNum])(fTriggeredEventClientDatas[fLastUsedTriggerNum]);
+            }
+        }
+        else {
+            // Look for an event trigger that needs handling (making sure that we make forward progress through all possible triggers):
+            unsigned       i    = fLastUsedTriggerNum;
+            EventTriggerId mask = fLastUsedTriggerMask;
+
+            do {
+                i = (i + 1) % MAX_NUM_EVENT_TRIGGERS;
+                mask >>= 1;
+                if(mask == 0)
+                    mask = 0x80000000;
+
+                if((fTriggersAwaitingHandling & mask) != 0) {
+                    fTriggersAwaitingHandling &= ~mask;
+                    if(fTriggeredEventHandlers[i] != NULL) {
+                        (*fTriggeredEventHandlers[i])(fTriggeredEventClientDatas[i]);
+                    }
+
+                    fLastUsedTriggerMask = mask;
+                    fLastUsedTriggerNum  = i;
+                    break;
+                }
+            } while(i != fLastUsedTriggerNum);
+        }
+    }
+
+    // Also handle any delayed event that may have come due.
+    fDelayQueue.handleAlarm();
+}
+
+void BasicTaskScheduler ::setBackgroundHandling(int socketNum, int conditionSet, BackgroundHandlerProc *handlerProc, void *clientData) {
+    if(socketNum < 0)
+        return;
+#if !defined(__WIN32__) && !defined(_WIN32) && defined(FD_SETSIZE)
+    if(socketNum >= (int)(FD_SETSIZE))
+        return;
+#endif
+    FD_CLR((unsigned)socketNum, &fReadSet);
+    FD_CLR((unsigned)socketNum, &fWriteSet);
+    FD_CLR((unsigned)socketNum, &fExceptionSet);
+    if(conditionSet == 0) {
+        fHandlers->clearHandler(socketNum);
+        if(socketNum + 1 == fMaxNumSockets) {
+            --fMaxNumSockets;
+        }
+    }
+    else {
+        fHandlers->assignHandler(socketNum, conditionSet, handlerProc, clientData);
+        if(socketNum + 1 > fMaxNumSockets) {
+            fMaxNumSockets = socketNum + 1;
+        }
+        if(conditionSet & SOCKET_READABLE)
+            FD_SET((unsigned)socketNum, &fReadSet);
+        if(conditionSet & SOCKET_WRITABLE)
+            FD_SET((unsigned)socketNum, &fWriteSet);
+        if(conditionSet & SOCKET_EXCEPTION)
+            FD_SET((unsigned)socketNum, &fExceptionSet);
+    }
+}
+
+void BasicTaskScheduler::moveSocketHandling(int oldSocketNum, int newSocketNum) {
+    if(oldSocketNum < 0 || newSocketNum < 0)
+        return;  // sanity check
+#if !defined(__WIN32__) && !defined(_WIN32) && defined(FD_SETSIZE)
+    if(oldSocketNum >= (int)(FD_SETSIZE) || newSocketNum >= (int)(FD_SETSIZE))
+        return;  // sanity check
+#endif
+    if(FD_ISSET(oldSocketNum, &fReadSet)) {
+        FD_CLR((unsigned)oldSocketNum, &fReadSet);
+        FD_SET((unsigned)newSocketNum, &fReadSet);
+    }
+    if(FD_ISSET(oldSocketNum, &fWriteSet)) {
+        FD_CLR((unsigned)oldSocketNum, &fWriteSet);
+        FD_SET((unsigned)newSocketNum, &fWriteSet);
+    }
+    if(FD_ISSET(oldSocketNum, &fExceptionSet)) {
+        FD_CLR((unsigned)oldSocketNum, &fExceptionSet);
+        FD_SET((unsigned)newSocketNum, &fExceptionSet);
+    }
+    fHandlers->moveHandler(oldSocketNum, newSocketNum);
+
+    if(oldSocketNum + 1 == fMaxNumSockets) {
+        --fMaxNumSockets;
+    }
+    if(newSocketNum + 1 > fMaxNumSockets) {
+        fMaxNumSockets = newSocketNum + 1;
+    }
+}
diff --git a/3rdparty/live555/src/BasicUsageEnvironment/BasicTaskScheduler0.cpp b/3rdparty/live555/src/BasicUsageEnvironment/BasicTaskScheduler0.cpp
new file mode 100644
index 00000000..a14b1a8d
--- /dev/null
+++ b/3rdparty/live555/src/BasicUsageEnvironment/BasicTaskScheduler0.cpp
@@ -0,0 +1,231 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// Basic Usage Environment: for a simple, non-scripted, console application
+// Implementation
+
+#include "BasicUsageEnvironment0.hh"
+#include "HandlerSet.hh"
+
+////////// A subclass of DelayQueueEntry,
+//////////     used to implement BasicTaskScheduler0::scheduleDelayedTask()
+
+class AlarmHandler : public DelayQueueEntry {
+public:
+    AlarmHandler(TaskFunc *proc, void *clientData, DelayInterval timeToDelay) : DelayQueueEntry(timeToDelay), fProc(proc), fClientData(clientData) {}
+
+private:  // redefined virtual functions
+    virtual void handleTimeout() {
+        (*fProc)(fClientData);
+        DelayQueueEntry::handleTimeout();
+    }
+
+private:
+    TaskFunc *fProc;
+    void *    fClientData;
+};
+
+////////// BasicTaskScheduler0 //////////
+
+BasicTaskScheduler0::BasicTaskScheduler0()
+    : fLastHandledSocketNum(-1), fTriggersAwaitingHandling(0), fLastUsedTriggerMask(1), fLastUsedTriggerNum(MAX_NUM_EVENT_TRIGGERS - 1) {
+    fHandlers = new HandlerSet;
+    for(unsigned i = 0; i < MAX_NUM_EVENT_TRIGGERS; ++i) {
+        fTriggeredEventHandlers[i]    = NULL;
+        fTriggeredEventClientDatas[i] = NULL;
+    }
+}
+
+BasicTaskScheduler0::~BasicTaskScheduler0() {
+    delete fHandlers;
+}
+
+TaskToken BasicTaskScheduler0::scheduleDelayedTask(int64_t microseconds, TaskFunc *proc, void *clientData) {
+    if(microseconds < 0)
+        microseconds = 0;
+    DelayInterval timeToDelay((long)(microseconds / 1000000), (long)(microseconds % 1000000));
+    AlarmHandler *alarmHandler = new AlarmHandler(proc, clientData, timeToDelay);
+    fDelayQueue.addEntry(alarmHandler);
+
+    return (void *)(alarmHandler->token());
+}
+
+void BasicTaskScheduler0::unscheduleDelayedTask(TaskToken &prevTask) {
+    DelayQueueEntry *alarmHandler = fDelayQueue.removeEntry((intptr_t)prevTask);
+    prevTask                      = NULL;
+    delete alarmHandler;
+}
+
+void BasicTaskScheduler0::doEventLoop(char volatile *watchVariable) {
+    // Repeatedly loop, handling readble sockets and timed events:
+    while(1) {
+        if(watchVariable != NULL && *watchVariable != 0)
+            break;
+        SingleStep();
+    }
+}
+
+EventTriggerId BasicTaskScheduler0::createEventTrigger(TaskFunc *eventHandlerProc) {
+    unsigned       i    = fLastUsedTriggerNum;
+    EventTriggerId mask = fLastUsedTriggerMask;
+
+    do {
+        i = (i + 1) % MAX_NUM_EVENT_TRIGGERS;
+        mask >>= 1;
+        if(mask == 0)
+            mask = 0x80000000;
+
+        if(fTriggeredEventHandlers[i] == NULL) {
+            // This trigger number is free; use it:
+            fTriggeredEventHandlers[i]    = eventHandlerProc;
+            fTriggeredEventClientDatas[i] = NULL;  // sanity
+
+            fLastUsedTriggerMask = mask;
+            fLastUsedTriggerNum  = i;
+
+            return mask;
+        }
+    } while(i != fLastUsedTriggerNum);
+
+    // All available event triggers are allocated; return 0 instead:
+    return 0;
+}
+
+void BasicTaskScheduler0::deleteEventTrigger(EventTriggerId eventTriggerId) {
+    fTriggersAwaitingHandling &= ~eventTriggerId;
+
+    if(eventTriggerId == fLastUsedTriggerMask) {  // common-case optimization:
+        fTriggeredEventHandlers[fLastUsedTriggerNum]    = NULL;
+        fTriggeredEventClientDatas[fLastUsedTriggerNum] = NULL;
+    }
+    else {
+        // "eventTriggerId" should have just one bit set.
+        // However, we do the reasonable thing if the user happened to 'or' together two or more "EventTriggerId"s:
+        EventTriggerId mask = 0x80000000;
+        for(unsigned i = 0; i < MAX_NUM_EVENT_TRIGGERS; ++i) {
+            if((eventTriggerId & mask) != 0) {
+                fTriggeredEventHandlers[i]    = NULL;
+                fTriggeredEventClientDatas[i] = NULL;
+            }
+            mask >>= 1;
+        }
+    }
+}
+
+void BasicTaskScheduler0::triggerEvent(EventTriggerId eventTriggerId, void *clientData) {
+    // First, record the "clientData".  (Note that we allow "eventTriggerId" to be a combination of bits for multiple events.)
+    EventTriggerId mask = 0x80000000;
+    for(unsigned i = 0; i < MAX_NUM_EVENT_TRIGGERS; ++i) {
+        if((eventTriggerId & mask) != 0) {
+            fTriggeredEventClientDatas[i] = clientData;
+        }
+        mask >>= 1;
+    }
+
+    // Then, note this event as being ready to be handled.
+    // (Note that because this function (unlike others in the library) can be called from an external thread, we do this last, to
+    //  reduce the risk of a race condition.)
+    fTriggersAwaitingHandling |= eventTriggerId;
+}
+
+////////// HandlerSet (etc.) implementation //////////
+
+HandlerDescriptor::HandlerDescriptor(HandlerDescriptor *nextHandler) : conditionSet(0), handlerProc(NULL) {
+    // Link this descriptor into a doubly-linked list:
+    if(nextHandler == this) {  // initialization
+        fNextHandler = fPrevHandler = this;
+    }
+    else {
+        fNextHandler               = nextHandler;
+        fPrevHandler               = nextHandler->fPrevHandler;
+        nextHandler->fPrevHandler  = this;
+        fPrevHandler->fNextHandler = this;
+    }
+}
+
+HandlerDescriptor::~HandlerDescriptor() {
+    // Unlink this descriptor from a doubly-linked list:
+    fNextHandler->fPrevHandler = fPrevHandler;
+    fPrevHandler->fNextHandler = fNextHandler;
+}
+
+HandlerSet::HandlerSet() : fHandlers(&fHandlers) {
+    fHandlers.socketNum = -1;  // shouldn't ever get looked at, but in case...
+}
+
+HandlerSet::~HandlerSet() {
+    // Delete each handler descriptor:
+    while(fHandlers.fNextHandler != &fHandlers) {
+        delete fHandlers.fNextHandler;  // changes fHandlers->fNextHandler
+    }
+}
+
+void HandlerSet ::assignHandler(int socketNum, int conditionSet, TaskScheduler::BackgroundHandlerProc *handlerProc, void *clientData) {
+    // First, see if there's already a handler for this socket:
+    HandlerDescriptor *handler = lookupHandler(socketNum);
+    if(handler == NULL) {  // No existing handler, so create a new descr:
+        handler            = new HandlerDescriptor(fHandlers.fNextHandler);
+        handler->socketNum = socketNum;
+    }
+
+    handler->conditionSet = conditionSet;
+    handler->handlerProc  = handlerProc;
+    handler->clientData   = clientData;
+}
+
+void HandlerSet::clearHandler(int socketNum) {
+    HandlerDescriptor *handler = lookupHandler(socketNum);
+    delete handler;
+}
+
+void HandlerSet::moveHandler(int oldSocketNum, int newSocketNum) {
+    HandlerDescriptor *handler = lookupHandler(oldSocketNum);
+    if(handler != NULL) {
+        handler->socketNum = newSocketNum;
+    }
+}
+
+HandlerDescriptor *HandlerSet::lookupHandler(int socketNum) {
+    HandlerDescriptor *handler;
+    HandlerIterator    iter(*this);
+    while((handler = iter.next()) != NULL) {
+        if(handler->socketNum == socketNum)
+            break;
+    }
+    return handler;
+}
+
+HandlerIterator::HandlerIterator(HandlerSet &handlerSet) : fOurSet(handlerSet) {
+    reset();
+}
+
+HandlerIterator::~HandlerIterator() {}
+
+void HandlerIterator::reset() {
+    fNextPtr = fOurSet.fHandlers.fNextHandler;
+}
+
+HandlerDescriptor *HandlerIterator::next() {
+    HandlerDescriptor *result = fNextPtr;
+    if(result == &fOurSet.fHandlers) {  // no more
+        result = NULL;
+    }
+    else {
+        fNextPtr = fNextPtr->fNextHandler;
+    }
+
+    return result;
+}
diff --git a/3rdparty/live555/src/BasicUsageEnvironment/BasicUsageEnvironment.cpp b/3rdparty/live555/src/BasicUsageEnvironment/BasicUsageEnvironment.cpp
new file mode 100644
index 00000000..814d787e
--- /dev/null
+++ b/3rdparty/live555/src/BasicUsageEnvironment/BasicUsageEnvironment.cpp
@@ -0,0 +1,78 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// Basic Usage Environment: for a simple, non-scripted, console application
+// Implementation
+
+#include "BasicUsageEnvironment.hh"
+#include <stdio.h>
+
+////////// BasicUsageEnvironment //////////
+
+#if defined(__WIN32__) || defined(_WIN32)
+extern "C" int initializeWinsockIfNecessary();
+#endif
+
+BasicUsageEnvironment::BasicUsageEnvironment(TaskScheduler &taskScheduler) : BasicUsageEnvironment0(taskScheduler) {
+#if defined(__WIN32__) || defined(_WIN32)
+    if(!initializeWinsockIfNecessary()) {
+        setResultErrMsg("Failed to initialize 'winsock': ");
+        reportBackgroundError();
+        internalError();
+    }
+#endif
+}
+
+BasicUsageEnvironment::~BasicUsageEnvironment() {}
+
+BasicUsageEnvironment *BasicUsageEnvironment::createNew(TaskScheduler &taskScheduler) {
+    return new BasicUsageEnvironment(taskScheduler);
+}
+
+int BasicUsageEnvironment::getErrno() const {
+#if defined(__WIN32__) || defined(_WIN32) || defined(_WIN32_WCE)
+    return WSAGetLastError();
+#else
+    return errno;
+#endif
+}
+
+UsageEnvironment &BasicUsageEnvironment::operator<<(char const *str) {
+    if(str == NULL)
+        str = "(NULL)";  // sanity check
+    fprintf(stderr, "%s", str);
+    return *this;
+}
+
+UsageEnvironment &BasicUsageEnvironment::operator<<(int i) {
+    fprintf(stderr, "%d", i);
+    return *this;
+}
+
+UsageEnvironment &BasicUsageEnvironment::operator<<(unsigned u) {
+    fprintf(stderr, "%u", u);
+    return *this;
+}
+
+UsageEnvironment &BasicUsageEnvironment::operator<<(double d) {
+    fprintf(stderr, "%f", d);
+    return *this;
+}
+
+UsageEnvironment &BasicUsageEnvironment::operator<<(void *p) {
+    fprintf(stderr, "%p", p);
+    return *this;
+}
diff --git a/3rdparty/live555/src/BasicUsageEnvironment/BasicUsageEnvironment0.cpp b/3rdparty/live555/src/BasicUsageEnvironment/BasicUsageEnvironment0.cpp
new file mode 100644
index 00000000..feac3c0b
--- /dev/null
+++ b/3rdparty/live555/src/BasicUsageEnvironment/BasicUsageEnvironment0.cpp
@@ -0,0 +1,100 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// Basic Usage Environment: for a simple, non-scripted, console application
+// Implementation
+
+#include "BasicUsageEnvironment0.hh"
+#include <stdio.h>
+#if defined(__WIN32__) || defined(_WIN32) || defined(_WIN32_WCE)
+#define snprintf _snprintf
+#endif
+
+////////// BasicUsageEnvironment //////////
+
+BasicUsageEnvironment0::BasicUsageEnvironment0(TaskScheduler &taskScheduler) : UsageEnvironment(taskScheduler), fBufferMaxSize(RESULT_MSG_BUFFER_MAX) {
+    reset();
+}
+
+BasicUsageEnvironment0::~BasicUsageEnvironment0() {}
+
+void BasicUsageEnvironment0::reset() {
+    fCurBufferSize                   = 0;
+    fResultMsgBuffer[fCurBufferSize] = '\0';
+}
+
+// Implementation of virtual functions:
+
+char const *BasicUsageEnvironment0::getResultMsg() const {
+    return fResultMsgBuffer;
+}
+
+void BasicUsageEnvironment0::setResultMsg(MsgString msg) {
+    reset();
+    appendToResultMsg(msg);
+}
+
+void BasicUsageEnvironment0::setResultMsg(MsgString msg1, MsgString msg2) {
+    setResultMsg(msg1);
+    appendToResultMsg(msg2);
+}
+
+void BasicUsageEnvironment0::setResultMsg(MsgString msg1, MsgString msg2, MsgString msg3) {
+    setResultMsg(msg1, msg2);
+    appendToResultMsg(msg3);
+}
+
+void BasicUsageEnvironment0::setResultErrMsg(MsgString msg, int err) {
+    setResultMsg(msg);
+
+    if(err == 0)
+        err = getErrno();
+#if defined(__WIN32__) || defined(_WIN32) || defined(_WIN32_WCE)
+#ifndef _UNICODE
+    char errMsg[RESULT_MSG_BUFFER_MAX] = "\0";
+    if(0 != FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM, NULL, err, 0, errMsg, sizeof(errMsg) / sizeof(errMsg[0]), NULL)) {
+        // Remove all trailing '\r', '\n' and '.'
+        for(char *p = errMsg + strlen(errMsg); p != errMsg && (*p == '\r' || *p == '\n' || *p == '.' || *p == '\0'); --p) {
+            *p = '\0';
+        }
+    }
+    else
+        snprintf(errMsg, sizeof(errMsg) / sizeof(errMsg[0]), "error %d", err);
+    appendToResultMsg(errMsg);
+#endif
+#else
+    appendToResultMsg(strerror(err));
+#endif
+}
+
+void BasicUsageEnvironment0::appendToResultMsg(MsgString msg) {
+    char *   curPtr         = &fResultMsgBuffer[fCurBufferSize];
+    unsigned spaceAvailable = fBufferMaxSize - fCurBufferSize;
+    unsigned msgLength      = strlen(msg);
+
+    // Copy only enough of "msg" as will fit:
+    if(msgLength > spaceAvailable - 1) {
+        msgLength = spaceAvailable - 1;
+    }
+
+    memmove(curPtr, (char *)msg, msgLength);
+    fCurBufferSize += msgLength;
+    fResultMsgBuffer[fCurBufferSize] = '\0';
+}
+
+void BasicUsageEnvironment0::reportBackgroundError() {
+    fputs(getResultMsg(), stderr);
+}
diff --git a/3rdparty/live555/src/BasicUsageEnvironment/DelayQueue.cpp b/3rdparty/live555/src/BasicUsageEnvironment/DelayQueue.cpp
new file mode 100644
index 00000000..c24f502d
--- /dev/null
+++ b/3rdparty/live555/src/BasicUsageEnvironment/DelayQueue.cpp
@@ -0,0 +1,230 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// Copyright (c) 1996-2022, Live Networks, Inc.  All rights reserved
+//	Help by Carlo Bonamico to get working for Windows
+// Delay queue
+// Implementation
+
+#include "DelayQueue.hh"
+#include "GroupsockHelper.hh"
+
+static const int MILLION = 1000000;
+
+///// Timeval /////
+
+int Timeval::operator>=(const Timeval &arg2) const {
+    return seconds() > arg2.seconds() || (seconds() == arg2.seconds() && useconds() >= arg2.useconds());
+}
+
+void Timeval::operator+=(const DelayInterval &arg2) {
+    secs() += arg2.seconds();
+    usecs() += arg2.useconds();
+    if(useconds() >= MILLION) {
+        usecs() -= MILLION;
+        ++secs();
+    }
+}
+
+void Timeval::operator-=(const DelayInterval &arg2) {
+    secs() -= arg2.seconds();
+    usecs() -= arg2.useconds();
+    if((int)useconds() < 0) {
+        usecs() += MILLION;
+        --secs();
+    }
+    if((int)seconds() < 0)
+        secs() = usecs() = 0;
+}
+
+DelayInterval operator-(const Timeval &arg1, const Timeval &arg2) {
+    time_base_seconds secs  = arg1.seconds() - arg2.seconds();
+    time_base_seconds usecs = arg1.useconds() - arg2.useconds();
+
+    if((int)usecs < 0) {
+        usecs += MILLION;
+        --secs;
+    }
+    if((int)secs < 0)
+        return DELAY_ZERO;
+    else
+        return DelayInterval(secs, usecs);
+}
+
+///// DelayInterval /////
+
+DelayInterval operator*(short arg1, const DelayInterval &arg2) {
+    time_base_seconds result_seconds  = arg1 * arg2.seconds();
+    time_base_seconds result_useconds = arg1 * arg2.useconds();
+
+    time_base_seconds carry = result_useconds / MILLION;
+    result_useconds -= carry * MILLION;
+    result_seconds += carry;
+
+    return DelayInterval(result_seconds, result_useconds);
+}
+
+#ifndef INT_MAX
+#define INT_MAX 0x7FFFFFFF
+#endif
+const DelayInterval DELAY_ZERO(0, 0);
+const DelayInterval DELAY_SECOND(1, 0);
+const DelayInterval DELAY_MINUTE = 60 * DELAY_SECOND;
+const DelayInterval DELAY_HOUR   = 60 * DELAY_MINUTE;
+const DelayInterval DELAY_DAY    = 24 * DELAY_HOUR;
+const DelayInterval ETERNITY(INT_MAX, MILLION - 1);
+// used internally to make the implementation work
+
+///// DelayQueueEntry /////
+
+intptr_t DelayQueueEntry::tokenCounter = 0;
+
+DelayQueueEntry::DelayQueueEntry(DelayInterval delay) : fDeltaTimeRemaining(delay) {
+    fNext = fPrev = this;
+    fToken        = ++tokenCounter;
+}
+
+DelayQueueEntry::~DelayQueueEntry() {}
+
+void DelayQueueEntry::handleTimeout() {
+    delete this;
+}
+
+///// DelayQueue /////
+
+DelayQueue::DelayQueue() : DelayQueueEntry(ETERNITY) {
+    fLastSyncTime = TimeNow();
+}
+
+DelayQueue::~DelayQueue() {
+    while(fNext != this) {
+        DelayQueueEntry *entryToRemove = fNext;
+        removeEntry(entryToRemove);
+        delete entryToRemove;
+    }
+}
+
+void DelayQueue::addEntry(DelayQueueEntry *newEntry) {
+    synchronize();
+
+    DelayQueueEntry *cur = head();
+    while(newEntry->fDeltaTimeRemaining >= cur->fDeltaTimeRemaining) {
+        newEntry->fDeltaTimeRemaining -= cur->fDeltaTimeRemaining;
+        cur = cur->fNext;
+    }
+
+    cur->fDeltaTimeRemaining -= newEntry->fDeltaTimeRemaining;
+
+    // Add "newEntry" to the queue, just before "cur":
+    newEntry->fNext = cur;
+    newEntry->fPrev = cur->fPrev;
+    cur->fPrev = newEntry->fPrev->fNext = newEntry;
+}
+
+void DelayQueue::updateEntry(DelayQueueEntry *entry, DelayInterval newDelay) {
+    if(entry == NULL)
+        return;
+
+    removeEntry(entry);
+    entry->fDeltaTimeRemaining = newDelay;
+    addEntry(entry);
+}
+
+void DelayQueue::updateEntry(intptr_t tokenToFind, DelayInterval newDelay) {
+    DelayQueueEntry *entry = findEntryByToken(tokenToFind);
+    updateEntry(entry, newDelay);
+}
+
+void DelayQueue::removeEntry(DelayQueueEntry *entry) {
+    if(entry == NULL || entry->fNext == NULL)
+        return;
+
+    entry->fNext->fDeltaTimeRemaining += entry->fDeltaTimeRemaining;
+    entry->fPrev->fNext = entry->fNext;
+    entry->fNext->fPrev = entry->fPrev;
+    entry->fNext = entry->fPrev = NULL;
+    // in case we should try to remove it again
+}
+
+DelayQueueEntry *DelayQueue::removeEntry(intptr_t tokenToFind) {
+    DelayQueueEntry *entry = findEntryByToken(tokenToFind);
+    removeEntry(entry);
+    return entry;
+}
+
+DelayInterval const &DelayQueue::timeToNextAlarm() {
+    if(head()->fDeltaTimeRemaining == DELAY_ZERO)
+        return DELAY_ZERO;  // a common case
+
+    synchronize();
+    return head()->fDeltaTimeRemaining;
+}
+
+void DelayQueue::handleAlarm() {
+    if(head()->fDeltaTimeRemaining != DELAY_ZERO)
+        synchronize();
+
+    if(head()->fDeltaTimeRemaining == DELAY_ZERO) {
+        // This event is due to be handled:
+        DelayQueueEntry *toRemove = head();
+        removeEntry(toRemove);  // do this first, in case handler accesses queue
+
+        toRemove->handleTimeout();
+    }
+}
+
+DelayQueueEntry *DelayQueue::findEntryByToken(intptr_t tokenToFind) {
+    DelayQueueEntry *cur = head();
+    while(cur != this) {
+        if(cur->token() == tokenToFind)
+            return cur;
+        cur = cur->fNext;
+    }
+
+    return NULL;
+}
+
+void DelayQueue::synchronize() {
+    // First, figure out how much time has elapsed since the last sync:
+    _EventTime timeNow = TimeNow();
+    if(timeNow < fLastSyncTime) {
+        // The system clock has apparently gone back in time; reset our sync time and return:
+        fLastSyncTime = timeNow;
+        return;
+    }
+    DelayInterval timeSinceLastSync = timeNow - fLastSyncTime;
+    fLastSyncTime                   = timeNow;
+
+    // Then, adjust the delay queue for any entries whose time is up:
+    DelayQueueEntry *curEntry = head();
+    while(timeSinceLastSync >= curEntry->fDeltaTimeRemaining) {
+        timeSinceLastSync -= curEntry->fDeltaTimeRemaining;
+        curEntry->fDeltaTimeRemaining = DELAY_ZERO;
+        curEntry                      = curEntry->fNext;
+    }
+    curEntry->fDeltaTimeRemaining -= timeSinceLastSync;
+}
+
+///// _EventTime /////
+
+_EventTime TimeNow() {
+    struct timeval tvNow;
+
+    gettimeofday(&tvNow, NULL);
+
+    return _EventTime(tvNow.tv_sec, tvNow.tv_usec);
+}
+
+const _EventTime THE_END_OF_TIME(INT_MAX);
diff --git a/3rdparty/live555/src/BasicUsageEnvironment/Makefile.head b/3rdparty/live555/src/BasicUsageEnvironment/Makefile.head
new file mode 100644
index 00000000..f4e4414c
--- /dev/null
+++ b/3rdparty/live555/src/BasicUsageEnvironment/Makefile.head
@@ -0,0 +1,4 @@
+INCLUDES = -Iinclude -I../UsageEnvironment/include -I../groupsock/include
+PREFIX = /usr/local
+LIBDIR = $(PREFIX)/lib
+##### Change the following for your environment:
diff --git a/3rdparty/live555/src/BasicUsageEnvironment/Makefile.tail b/3rdparty/live555/src/BasicUsageEnvironment/Makefile.tail
new file mode 100644
index 00000000..5d041791
--- /dev/null
+++ b/3rdparty/live555/src/BasicUsageEnvironment/Makefile.tail
@@ -0,0 +1,43 @@
+##### End of variables to change
+
+NAME = libBasicUsageEnvironment
+LIB_FILE = $(NAME).$(LIB_SUFFIX)
+ALL = $(LIB_FILE)
+all:	$(ALL)
+
+OBJS = BasicUsageEnvironment0.$(OBJ) BasicUsageEnvironment.$(OBJ) \
+	BasicTaskScheduler0.$(OBJ) BasicTaskScheduler.$(OBJ) \
+	DelayQueue.$(OBJ) BasicHashTable.$(OBJ)
+
+libBasicUsageEnvironment.$(LIB_SUFFIX): $(OBJS)
+	$(LIBRARY_LINK)$@ $(LIBRARY_LINK_OPTS) \
+		$(OBJS)
+
+.$(C).$(OBJ):
+	$(C_COMPILER) -c $(C_FLAGS) $<       
+
+.$(CPP).$(OBJ):
+	$(CPLUSPLUS_COMPILER) -c $(CPLUSPLUS_FLAGS) $<
+
+BasicUsageEnvironment0.$(CPP):	include/BasicUsageEnvironment0.hh
+include/BasicUsageEnvironment0.hh:	include/BasicUsageEnvironment_version.hh include/DelayQueue.hh
+BasicUsageEnvironment.$(CPP):	include/BasicUsageEnvironment.hh
+include/BasicUsageEnvironment.hh:	include/BasicUsageEnvironment0.hh
+BasicTaskScheduler0.$(CPP):	include/BasicUsageEnvironment0.hh include/HandlerSet.hh
+BasicTaskScheduler.$(CPP):	include/BasicUsageEnvironment.hh include/HandlerSet.hh
+DelayQueue.$(CPP):		include/DelayQueue.hh
+BasicHashTable.$(CPP):		include/BasicHashTable.hh
+
+clean:
+	-rm -rf *.$(OBJ) $(ALL) core *.core *~ include/*~
+
+install: install1 $(INSTALL2)
+install1: libBasicUsageEnvironment.$(LIB_SUFFIX)
+	  install -d $(DESTDIR)$(PREFIX)/include/BasicUsageEnvironment $(DESTDIR)$(LIBDIR)
+	  install -m 644 include/*.hh $(DESTDIR)$(PREFIX)/include/BasicUsageEnvironment
+	  install -m 644 libBasicUsageEnvironment.$(LIB_SUFFIX) $(DESTDIR)$(LIBDIR)
+install_shared_libraries: libBasicUsageEnvironment.$(LIB_SUFFIX)
+	  ln -fs $(NAME).$(LIB_SUFFIX) $(DESTDIR)$(LIBDIR)/$(NAME).$(SHORT_LIB_SUFFIX)
+	  ln -fs $(NAME).$(LIB_SUFFIX) $(DESTDIR)$(LIBDIR)/$(NAME).so
+
+##### Any additional, platform-specific rules come here:
diff --git a/3rdparty/live555/src/BasicUsageEnvironment/include/BasicHashTable.hh b/3rdparty/live555/src/BasicUsageEnvironment/include/BasicHashTable.hh
new file mode 100644
index 00000000..5b4d3eb7
--- /dev/null
+++ b/3rdparty/live555/src/BasicUsageEnvironment/include/BasicHashTable.hh
@@ -0,0 +1,104 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// Basic Hash Table implementation
+// C++ header
+
+#ifndef _BASIC_HASH_TABLE_HH
+#define _BASIC_HASH_TABLE_HH
+
+#ifndef _HASH_TABLE_HH
+#include "HashTable.hh"
+#endif
+#ifndef _NET_COMMON_H
+#include <NetCommon.h> // to ensure that "uintptr_t" is defined
+#endif
+
+// A simple hash table implementation, inspired by the hash table
+// implementation used in Tcl 7.6: <http://www.tcl.tk/>
+
+#define SMALL_HASH_TABLE_SIZE 4
+
+class BasicHashTable: public HashTable {
+private:
+	class TableEntry; // forward
+
+public:
+  BasicHashTable(int keyType);
+  virtual ~BasicHashTable();
+
+  // Used to iterate through the members of the table:
+  class Iterator; friend class Iterator; // to make Sun's C++ compiler happy
+  class Iterator: public HashTable::Iterator {
+  public:
+    Iterator(BasicHashTable const& table);
+
+  private: // implementation of inherited pure virtual functions
+    void* next(char const*& key); // returns 0 if none
+
+  private:
+    BasicHashTable const& fTable;
+    unsigned fNextIndex; // index of next bucket to be enumerated after this
+    TableEntry* fNextEntry; // next entry in the current bucket
+  };
+
+private: // implementation of inherited pure virtual functions
+  virtual void* Add(char const* key, void* value);
+  // Returns the old value if different, otherwise 0
+  virtual Boolean Remove(char const* key);
+  virtual void* Lookup(char const* key) const;
+  // Returns 0 if not found
+  virtual unsigned numEntries() const;
+
+private:
+  class TableEntry {
+  public:
+    TableEntry* fNext;
+    char const* key;
+    void* value;
+  };
+
+  TableEntry* lookupKey(char const* key, unsigned& index) const;
+    // returns entry matching "key", or NULL if none
+  Boolean keyMatches(char const* key1, char const* key2) const;
+    // used to implement "lookupKey()"
+
+  TableEntry* insertNewEntry(unsigned index, char const* key);
+    // creates a new entry, and inserts it in the table
+  void assignKey(TableEntry* entry, char const* key);
+    // used to implement "insertNewEntry()"
+
+  void deleteEntry(unsigned index, TableEntry* entry);
+  void deleteKey(TableEntry* entry);
+    // used to implement "deleteEntry()"
+
+  void rebuild(); // rebuilds the table as its size increases
+
+  unsigned hashIndexFromKey(char const* key) const;
+    // used to implement many of the routines above
+
+  unsigned randomIndex(uintptr_t i) const {
+    return (unsigned)(((i*1103515245) >> fDownShift) & fMask);
+  }
+
+private:
+  TableEntry** fBuckets; // pointer to bucket array
+  TableEntry* fStaticBuckets[SMALL_HASH_TABLE_SIZE];// used for small tables
+  unsigned fNumBuckets, fNumEntries, fRebuildSize, fDownShift, fMask;
+  int fKeyType;
+};
+
+#endif
diff --git a/3rdparty/live555/src/BasicUsageEnvironment/include/BasicUsageEnvironment.hh b/3rdparty/live555/src/BasicUsageEnvironment/include/BasicUsageEnvironment.hh
new file mode 100644
index 00000000..7d5133fa
--- /dev/null
+++ b/3rdparty/live555/src/BasicUsageEnvironment/include/BasicUsageEnvironment.hh
@@ -0,0 +1,86 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// Basic Usage Environment: for a simple, non-scripted, console application
+// C++ header
+
+#ifndef _BASIC_USAGE_ENVIRONMENT_HH
+#define _BASIC_USAGE_ENVIRONMENT_HH
+
+#ifndef _BASIC_USAGE_ENVIRONMENT0_HH
+#include "BasicUsageEnvironment0.hh"
+#endif
+
+class BasicUsageEnvironment: public BasicUsageEnvironment0 {
+public:
+  static BasicUsageEnvironment* createNew(TaskScheduler& taskScheduler);
+
+  // redefined virtual functions:
+  virtual int getErrno() const;
+
+  virtual UsageEnvironment& operator<<(char const* str);
+  virtual UsageEnvironment& operator<<(int i);
+  virtual UsageEnvironment& operator<<(unsigned u);
+  virtual UsageEnvironment& operator<<(double d);
+  virtual UsageEnvironment& operator<<(void* p);
+
+protected:
+  BasicUsageEnvironment(TaskScheduler& taskScheduler);
+      // called only by "createNew()" (or subclass constructors)
+  virtual ~BasicUsageEnvironment();
+};
+
+
+class BasicTaskScheduler: public BasicTaskScheduler0 {
+public:
+  static BasicTaskScheduler* createNew(unsigned maxSchedulerGranularity = 10000/*microseconds*/);
+    // "maxSchedulerGranularity" (default value: 10 ms) specifies the maximum time that we wait (in "select()") before
+    // returning to the event loop to handle non-socket or non-timer-based events, such as 'triggered events'.
+    // You can change this is you wish (but only if you know what you're doing!), or set it to 0, to specify no such maximum time.
+    // (You should set it to 0 only if you know that you will not be using 'event triggers'.)
+  virtual ~BasicTaskScheduler();
+
+protected:
+  BasicTaskScheduler(unsigned maxSchedulerGranularity);
+      // called only by "createNew()"
+
+  static void schedulerTickTask(void* clientData);
+  void schedulerTickTask();
+
+protected:
+  // Redefined virtual functions:
+  virtual void SingleStep(unsigned maxDelayTime);
+
+  virtual void setBackgroundHandling(int socketNum, int conditionSet, BackgroundHandlerProc* handlerProc, void* clientData);
+  virtual void moveSocketHandling(int oldSocketNum, int newSocketNum);
+
+protected:
+  unsigned fMaxSchedulerGranularity;
+
+  // To implement background operations:
+  int fMaxNumSockets;
+  fd_set fReadSet;
+  fd_set fWriteSet;
+  fd_set fExceptionSet;
+
+private:
+#if defined(__WIN32__) || defined(_WIN32)
+  // Hack to work around a bug in Windows' "select()" implementation:
+  int fDummySocketNum;
+#endif
+};
+
+#endif
diff --git a/3rdparty/live555/src/BasicUsageEnvironment/include/BasicUsageEnvironment0.hh b/3rdparty/live555/src/BasicUsageEnvironment/include/BasicUsageEnvironment0.hh
new file mode 100644
index 00000000..d91b441c
--- /dev/null
+++ b/3rdparty/live555/src/BasicUsageEnvironment/include/BasicUsageEnvironment0.hh
@@ -0,0 +1,114 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// Basic Usage Environment: for a simple, non-scripted, console application
+// C++ header
+
+#ifndef _BASIC_USAGE_ENVIRONMENT0_HH
+#define _BASIC_USAGE_ENVIRONMENT0_HH
+
+#ifndef _BASICUSAGEENVIRONMENT_VERSION_HH
+#include "BasicUsageEnvironment_version.hh"
+#endif
+
+#ifndef _USAGE_ENVIRONMENT_HH
+#include "UsageEnvironment.hh"
+#endif
+
+#ifndef _DELAY_QUEUE_HH
+#include "DelayQueue.hh"
+#endif
+
+#define RESULT_MSG_BUFFER_MAX 1000
+
+// An abstract base class, useful for subclassing
+// (e.g., to redefine the implementation of "operator<<")
+class BasicUsageEnvironment0: public UsageEnvironment {
+public:
+  // redefined virtual functions:
+  virtual MsgString getResultMsg() const;
+
+  virtual void setResultMsg(MsgString msg);
+  virtual void setResultMsg(MsgString msg1,
+		    MsgString msg2);
+  virtual void setResultMsg(MsgString msg1,
+		    MsgString msg2,
+		    MsgString msg3);
+  virtual void setResultErrMsg(MsgString msg, int err = 0);
+
+  virtual void appendToResultMsg(MsgString msg);
+
+  virtual void reportBackgroundError();
+
+protected:
+  BasicUsageEnvironment0(TaskScheduler& taskScheduler);
+  virtual ~BasicUsageEnvironment0();
+
+private:
+  void reset();
+
+  char fResultMsgBuffer[RESULT_MSG_BUFFER_MAX];
+  unsigned fCurBufferSize;
+  unsigned fBufferMaxSize;
+};
+
+class HandlerSet; // forward
+
+#define MAX_NUM_EVENT_TRIGGERS 32
+
+// An abstract base class, useful for subclassing
+// (e.g., to redefine the implementation of socket event handling)
+class BasicTaskScheduler0: public TaskScheduler {
+public:
+  virtual ~BasicTaskScheduler0();
+
+  virtual void SingleStep(unsigned maxDelayTime = 0) = 0;
+      // "maxDelayTime" is in microseconds.  It allows a subclass to impose a limit
+      // on how long "select()" can delay, in case it wants to also do polling.
+      // 0 (the default value) means: There's no maximum; just look at the delay queue
+
+public:
+  // Redefined virtual functions:
+  virtual TaskToken scheduleDelayedTask(int64_t microseconds, TaskFunc* proc,
+				void* clientData);
+  virtual void unscheduleDelayedTask(TaskToken& prevTask);
+
+  virtual void doEventLoop(char volatile* watchVariable);
+
+  virtual EventTriggerId createEventTrigger(TaskFunc* eventHandlerProc);
+  virtual void deleteEventTrigger(EventTriggerId eventTriggerId);
+  virtual void triggerEvent(EventTriggerId eventTriggerId, void* clientData = NULL);
+
+protected:
+  BasicTaskScheduler0();
+
+protected:
+  // To implement delayed operations:
+  DelayQueue fDelayQueue;
+
+  // To implement background reads:
+  HandlerSet* fHandlers;
+  int fLastHandledSocketNum;
+
+  // To implement event triggers:
+  EventTriggerId volatile fTriggersAwaitingHandling; // implemented as a 32-bit bitmap
+  EventTriggerId fLastUsedTriggerMask; // implemented as a 32-bit bitmap
+  TaskFunc* fTriggeredEventHandlers[MAX_NUM_EVENT_TRIGGERS];
+  void* fTriggeredEventClientDatas[MAX_NUM_EVENT_TRIGGERS];
+  unsigned fLastUsedTriggerNum; // in the range [0,MAX_NUM_EVENT_TRIGGERS)
+};
+
+#endif
diff --git a/3rdparty/live555/src/BasicUsageEnvironment/include/BasicUsageEnvironment_version.hh b/3rdparty/live555/src/BasicUsageEnvironment/include/BasicUsageEnvironment_version.hh
new file mode 100644
index 00000000..c010978e
--- /dev/null
+++ b/3rdparty/live555/src/BasicUsageEnvironment/include/BasicUsageEnvironment_version.hh
@@ -0,0 +1,25 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// Version information for the "BasicUsageEnvironment" library
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+
+#ifndef _BASICUSAGEENVIRONMENT_VERSION_HH
+#define _BASICUSAGEENVIRONMENT_VERSION_HH
+
+#define BASICUSAGEENVIRONMENT_LIBRARY_VERSION_STRING	"2022.04.26"
+#define BASICUSAGEENVIRONMENT_LIBRARY_VERSION_INT		1650931200
+
+#endif
diff --git a/3rdparty/live555/src/BasicUsageEnvironment/include/DelayQueue.hh b/3rdparty/live555/src/BasicUsageEnvironment/include/DelayQueue.hh
new file mode 100644
index 00000000..27cdab12
--- /dev/null
+++ b/3rdparty/live555/src/BasicUsageEnvironment/include/DelayQueue.hh
@@ -0,0 +1,182 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+ // Copyright (c) 1996-2022, Live Networks, Inc.  All rights reserved
+// Delay queue
+// C++ header
+
+#ifndef _DELAY_QUEUE_HH
+#define _DELAY_QUEUE_HH
+
+#ifndef _NET_COMMON_H
+#include "NetCommon.h"
+#endif
+
+#ifdef TIME_BASE
+typedef TIME_BASE time_base_seconds;
+#else
+typedef long time_base_seconds;
+#endif
+
+///// A "Timeval" can be either an absolute time, or a time interval /////
+
+class Timeval {
+public:
+  time_base_seconds seconds() const {
+    return fTv.tv_sec;
+  }
+  time_base_seconds seconds() {
+    return fTv.tv_sec;
+  }
+  time_base_seconds useconds() const {
+    return fTv.tv_usec;
+  }
+  time_base_seconds useconds() {
+    return fTv.tv_usec;
+  }
+
+  int operator>=(Timeval const& arg2) const;
+  int operator<=(Timeval const& arg2) const {
+    return arg2 >= *this;
+  }
+  int operator<(Timeval const& arg2) const {
+    return !(*this >= arg2);
+  }
+  int operator>(Timeval const& arg2) const {
+    return arg2 < *this;
+  }
+  int operator==(Timeval const& arg2) const {
+    return *this >= arg2 && arg2 >= *this;
+  }
+  int operator!=(Timeval const& arg2) const {
+    return !(*this == arg2);
+  }
+
+  void operator+=(class DelayInterval const& arg2);
+  void operator-=(class DelayInterval const& arg2);
+  // returns ZERO iff arg2 >= arg1
+
+protected:
+  Timeval(time_base_seconds seconds, time_base_seconds useconds) {
+    fTv.tv_sec = seconds; fTv.tv_usec = useconds;
+  }
+
+private:
+  time_base_seconds& secs() {
+    return (time_base_seconds&)fTv.tv_sec;
+  }
+  time_base_seconds& usecs() {
+    return (time_base_seconds&)fTv.tv_usec;
+  }
+
+  struct timeval fTv;
+};
+
+#ifndef max
+inline Timeval max(Timeval const& arg1, Timeval const& arg2) {
+  return arg1 >= arg2 ? arg1 : arg2;
+}
+#endif
+#ifndef min
+inline Timeval min(Timeval const& arg1, Timeval const& arg2) {
+  return arg1 <= arg2 ? arg1 : arg2;
+}
+#endif
+
+class DelayInterval operator-(Timeval const& arg1, Timeval const& arg2);
+// returns ZERO iff arg2 >= arg1
+
+
+///// DelayInterval /////
+
+class DelayInterval: public Timeval {
+public:
+  DelayInterval(time_base_seconds seconds, time_base_seconds useconds)
+    : Timeval(seconds, useconds) {}
+};
+
+DelayInterval operator*(short arg1, DelayInterval const& arg2);
+
+extern DelayInterval const DELAY_ZERO;
+extern DelayInterval const DELAY_SECOND;
+extern DelayInterval const DELAY_MINUTE;
+extern DelayInterval const DELAY_HOUR;
+extern DelayInterval const DELAY_DAY;
+
+///// _EventTime /////
+
+class _EventTime: public Timeval {
+public:
+  _EventTime(unsigned secondsSinceEpoch = 0,
+	    unsigned usecondsSinceEpoch = 0)
+    // We use the Unix standard epoch: January 1, 1970
+    : Timeval(secondsSinceEpoch, usecondsSinceEpoch) {}
+};
+
+_EventTime TimeNow();
+
+extern _EventTime const THE_END_OF_TIME;
+
+
+///// DelayQueueEntry /////
+
+class DelayQueueEntry {
+public:
+  virtual ~DelayQueueEntry();
+
+  intptr_t token() {
+    return fToken;
+  }
+
+protected: // abstract base class
+  DelayQueueEntry(DelayInterval delay);
+
+  virtual void handleTimeout();
+
+private:
+  friend class DelayQueue;
+  DelayQueueEntry* fNext;
+  DelayQueueEntry* fPrev;
+  DelayInterval fDeltaTimeRemaining;
+
+  intptr_t fToken;
+  static intptr_t tokenCounter;
+};
+
+///// DelayQueue /////
+
+class DelayQueue: public DelayQueueEntry {
+public:
+  DelayQueue();
+  virtual ~DelayQueue();
+
+  void addEntry(DelayQueueEntry* newEntry); // returns a token for the entry
+  void updateEntry(DelayQueueEntry* entry, DelayInterval newDelay);
+  void updateEntry(intptr_t tokenToFind, DelayInterval newDelay);
+  void removeEntry(DelayQueueEntry* entry); // but doesn't delete it
+  DelayQueueEntry* removeEntry(intptr_t tokenToFind); // but doesn't delete it
+
+  DelayInterval const& timeToNextAlarm();
+  void handleAlarm();
+
+private:
+  DelayQueueEntry* head() { return fNext; }
+  DelayQueueEntry* findEntryByToken(intptr_t token);
+  void synchronize(); // bring the 'time remaining' fields up-to-date
+
+  _EventTime fLastSyncTime;
+};
+
+#endif
diff --git a/3rdparty/live555/src/BasicUsageEnvironment/include/HandlerSet.hh b/3rdparty/live555/src/BasicUsageEnvironment/include/HandlerSet.hh
new file mode 100644
index 00000000..6af6e721
--- /dev/null
+++ b/3rdparty/live555/src/BasicUsageEnvironment/include/HandlerSet.hh
@@ -0,0 +1,77 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// Basic Usage Environment: for a simple, non-scripted, console application
+// C++ header
+
+#ifndef _HANDLER_SET_HH
+#define _HANDLER_SET_HH
+
+#ifndef _BOOLEAN_HH
+#include "Boolean.hh"
+#endif
+
+////////// HandlerSet (etc.) definition //////////
+
+class HandlerDescriptor {
+  HandlerDescriptor(HandlerDescriptor* nextHandler);
+  virtual ~HandlerDescriptor();
+
+public:
+  int socketNum;
+  int conditionSet;
+  TaskScheduler::BackgroundHandlerProc* handlerProc;
+  void* clientData;
+
+private:
+  // Descriptors are linked together in a doubly-linked list:
+  friend class HandlerSet;
+  friend class HandlerIterator;
+  HandlerDescriptor* fNextHandler;
+  HandlerDescriptor* fPrevHandler;
+};
+
+class HandlerSet {
+public:
+  HandlerSet();
+  virtual ~HandlerSet();
+
+  void assignHandler(int socketNum, int conditionSet, TaskScheduler::BackgroundHandlerProc* handlerProc, void* clientData);
+  void clearHandler(int socketNum);
+  void moveHandler(int oldSocketNum, int newSocketNum);
+
+private:
+  HandlerDescriptor* lookupHandler(int socketNum);
+
+private:
+  friend class HandlerIterator;
+  HandlerDescriptor fHandlers;
+};
+
+class HandlerIterator {
+public:
+  HandlerIterator(HandlerSet& handlerSet);
+  virtual ~HandlerIterator();
+
+  HandlerDescriptor* next(); // returns NULL if none
+  void reset();
+
+private:
+  HandlerSet& fOurSet;
+  HandlerDescriptor* fNextPtr;
+};
+
+#endif
diff --git a/3rdparty/live555/src/CMakeLists.txt b/3rdparty/live555/src/CMakeLists.txt
new file mode 100644
index 00000000..c67a88af
--- /dev/null
+++ b/3rdparty/live555/src/CMakeLists.txt
@@ -0,0 +1,51 @@
+cmake_minimum_required(VERSION 3.5)
+project(Live555 LANGUAGES CXX C)
+
+add_definitions(-DNO_OPENSSL)
+if (WIN32)
+    add_definitions(-DNO_GETIFADDRS)
+endif()
+
+aux_source_directory(groupsock GROUPSOCK_SRCS)
+aux_source_directory(liveMedia LIVEMEDIA_SRCS)
+aux_source_directory(UsageEnvironment USAGE_ENVIRONMENT_SRCS)
+aux_source_directory(BasicUsageEnvironment BASIC_USAGE_ENVIRONMENT_SRCS)
+
+set(LIVE555_INCLUDE_DIRS
+    ${CMAKE_CURRENT_SOURCE_DIR}/groupsock/include
+    ${CMAKE_CURRENT_SOURCE_DIR}/liveMedia/include
+    ${CMAKE_CURRENT_SOURCE_DIR}/UsageEnvironment/include
+    ${CMAKE_CURRENT_SOURCE_DIR}/BasicUsageEnvironment/include
+)
+
+# message("LIVE555_INCLUDE_DIRS=${LIVE555_INCLUDE_DIRS}")
+
+add_library(live555 STATIC
+    ${GROUPSOCK_SRCS}
+    ${LIVEMEDIA_SRCS}
+    ${USAGE_ENVIRONMENT_SRCS}
+    ${BASIC_USAGE_ENVIRONMENT_SRCS}
+    ${ANDROID_ADDITION_SRCS}
+)
+
+if(ANDROID_NDK_TOOLCHAIN_INCLUDED AND CMAKE_ANDROID_NDK_VERSION VERSION_LESS 24)
+    aux_source_directory(android_ifaddrs_addition ANDROID_ADDITION_SRCS)
+    target_sources(live555 PRIVATE "${ANDROID_ADDITION_SRCS}")
+    set(LIVE555_INCLUDE_DIRS
+        ${LIVE555_INCLUDE_DIRS}
+        ${CMAKE_CURRENT_SOURCE_DIR}/android_ifaddrs_addition
+    )
+endif()
+
+target_include_directories(live555
+    PUBLIC
+    ${LIVE555_INCLUDE_DIRS}
+)
+
+if (WIN32)
+    target_link_libraries(live555 PRIVATE Ws2_32)
+endif ()
+
+# for test:
+# add_subdirectory(mediaServer)
+# add_subdirectory(testProgs)
\ No newline at end of file
diff --git a/3rdparty/live555/src/COPYING b/3rdparty/live555/src/COPYING
new file mode 100644
index 00000000..94a9ed02
--- /dev/null
+++ b/3rdparty/live555/src/COPYING
@@ -0,0 +1,674 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program 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.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<http://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<http://www.gnu.org/philosophy/why-not-lgpl.html>.
diff --git a/3rdparty/live555/src/COPYING.LESSER b/3rdparty/live555/src/COPYING.LESSER
new file mode 100644
index 00000000..65c5ca88
--- /dev/null
+++ b/3rdparty/live555/src/COPYING.LESSER
@@ -0,0 +1,165 @@
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.
diff --git a/3rdparty/live555/src/Makefile.head b/3rdparty/live555/src/Makefile.head
new file mode 100644
index 00000000..458c54cb
--- /dev/null
+++ b/3rdparty/live555/src/Makefile.head
@@ -0,0 +1 @@
+##### Change the following for your environment:
diff --git a/3rdparty/live555/src/Makefile.tail b/3rdparty/live555/src/Makefile.tail
new file mode 100644
index 00000000..6c49b830
--- /dev/null
+++ b/3rdparty/live555/src/Makefile.tail
@@ -0,0 +1,54 @@
+##### End of variables to change
+
+LIVEMEDIA_DIR = liveMedia
+GROUPSOCK_DIR = groupsock
+USAGE_ENVIRONMENT_DIR = UsageEnvironment
+BASIC_USAGE_ENVIRONMENT_DIR = BasicUsageEnvironment
+
+TESTPROGS_DIR = testProgs
+
+MEDIA_SERVER_DIR = mediaServer
+
+PROXY_SERVER_DIR = proxyServer
+
+HLS_PROXY_DIR = hlsProxy
+
+all:
+	cd $(LIVEMEDIA_DIR) ; $(MAKE)
+	cd $(GROUPSOCK_DIR) ; $(MAKE)
+	cd $(USAGE_ENVIRONMENT_DIR) ; $(MAKE)
+	cd $(BASIC_USAGE_ENVIRONMENT_DIR) ; $(MAKE)
+	cd $(TESTPROGS_DIR) ; $(MAKE)
+	cd $(MEDIA_SERVER_DIR) ; $(MAKE)
+	cd $(PROXY_SERVER_DIR) ; $(MAKE)
+	cd $(HLS_PROXY_DIR) ; $(MAKE)
+	@echo
+	@echo "For more information about this source code (including your obligations under the LGPL), please see our FAQ at http://live555.com/liveMedia/faq.html"
+
+install:
+	cd $(LIVEMEDIA_DIR) ; $(MAKE) install
+	cd $(GROUPSOCK_DIR) ; $(MAKE) install
+	cd $(USAGE_ENVIRONMENT_DIR) ; $(MAKE) install
+	cd $(BASIC_USAGE_ENVIRONMENT_DIR) ; $(MAKE) install
+	cd $(TESTPROGS_DIR) ; $(MAKE) install
+	cd $(MEDIA_SERVER_DIR) ; $(MAKE) install
+	cd $(PROXY_SERVER_DIR) ; $(MAKE) install
+	cd $(HLS_PROXY_DIR) ; $(MAKE) install
+
+clean:
+	cd $(LIVEMEDIA_DIR) ; $(MAKE) clean
+	cd $(GROUPSOCK_DIR) ; $(MAKE) clean
+	cd $(USAGE_ENVIRONMENT_DIR) ; $(MAKE) clean
+	cd $(BASIC_USAGE_ENVIRONMENT_DIR) ; $(MAKE) clean
+	cd $(TESTPROGS_DIR) ; $(MAKE) clean
+	cd $(MEDIA_SERVER_DIR) ; $(MAKE) clean
+	cd $(PROXY_SERVER_DIR) ; $(MAKE) clean
+	cd $(HLS_PROXY_DIR) ; $(MAKE) clean
+
+distclean: clean
+	-rm -f $(LIVEMEDIA_DIR)/Makefile $(GROUPSOCK_DIR)/Makefile \
+	  $(USAGE_ENVIRONMENT_DIR)/Makefile $(BASIC_USAGE_ENVIRONMENT_DIR)/Makefile \
+	  $(TESTPROGS_DIR)/Makefile $(MEDIA_SERVER_DIR)/Makefile \
+	  $(PROXY_SERVER_DIR)/Makefile \
+	  $(HLS_PROXY_DIR)/Makefile \
+	  Makefile
diff --git a/3rdparty/live555/src/README b/3rdparty/live555/src/README
new file mode 100644
index 00000000..73874c28
--- /dev/null
+++ b/3rdparty/live555/src/README
@@ -0,0 +1,2 @@
+For documentation and instructions for building this software,
+see <http://www.live555.com/liveMedia/>
diff --git a/3rdparty/live555/src/UsageEnvironment/HashTable.cpp b/3rdparty/live555/src/UsageEnvironment/HashTable.cpp
new file mode 100644
index 00000000..fb384d8b
--- /dev/null
+++ b/3rdparty/live555/src/UsageEnvironment/HashTable.cpp
@@ -0,0 +1,48 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// Generic Hash Table
+// Implementation
+
+#include "HashTable.hh"
+
+HashTable::HashTable() {}
+
+HashTable::~HashTable() {}
+
+HashTable::Iterator::Iterator() {}
+
+HashTable::Iterator::~Iterator() {}
+
+void *HashTable::RemoveNext() {
+    Iterator *  iter = Iterator::create(*this);
+    char const *key;
+    void *      removedValue = iter->next(key);
+    if(removedValue != 0)
+        Remove(key);
+
+    delete iter;
+    return removedValue;
+}
+
+void *HashTable::getFirst() {
+    Iterator *  iter = Iterator::create(*this);
+    char const *key;
+    void *      firstValue = iter->next(key);
+
+    delete iter;
+    return firstValue;
+}
diff --git a/3rdparty/live555/src/UsageEnvironment/Makefile.head b/3rdparty/live555/src/UsageEnvironment/Makefile.head
new file mode 100644
index 00000000..48b02686
--- /dev/null
+++ b/3rdparty/live555/src/UsageEnvironment/Makefile.head
@@ -0,0 +1,4 @@
+INCLUDES = -Iinclude -I../groupsock/include
+PREFIX = /usr/local
+LIBDIR = $(PREFIX)/lib
+##### Change the following for your environment:
diff --git a/3rdparty/live555/src/UsageEnvironment/Makefile.tail b/3rdparty/live555/src/UsageEnvironment/Makefile.tail
new file mode 100644
index 00000000..a7c23dfe
--- /dev/null
+++ b/3rdparty/live555/src/UsageEnvironment/Makefile.tail
@@ -0,0 +1,37 @@
+##### End of variables to change
+
+NAME = libUsageEnvironment
+USAGE_ENVIRONMENT_LIB = $(NAME).$(LIB_SUFFIX)
+ALL = $(USAGE_ENVIRONMENT_LIB)
+all:	$(ALL)
+
+OBJS = UsageEnvironment.$(OBJ) HashTable.$(OBJ) strDup.$(OBJ)
+
+$(USAGE_ENVIRONMENT_LIB): $(OBJS)
+	$(LIBRARY_LINK)$@ $(LIBRARY_LINK_OPTS) $(OBJS)
+
+.$(C).$(OBJ):
+	$(C_COMPILER) -c $(C_FLAGS) $<       
+
+.$(CPP).$(OBJ):
+	$(CPLUSPLUS_COMPILER) -c $(CPLUSPLUS_FLAGS) $<
+
+UsageEnvironment.$(CPP):	include/UsageEnvironment.hh
+include/UsageEnvironment.hh:	include/UsageEnvironment_version.hh include/Boolean.hh include/strDup.hh
+HashTable.$(CPP):		include/HashTable.hh
+include/HashTable.hh:		include/Boolean.hh
+strDup.$(CPP):			include/strDup.hh
+
+clean:
+	-rm -rf *.$(OBJ) $(ALL) core *.core *~ include/*~
+
+install: install1 $(INSTALL2)
+install1: $(USAGE_ENVIRONMENT_LIB)
+	  install -d $(DESTDIR)$(PREFIX)/include/UsageEnvironment $(DESTDIR)$(LIBDIR)
+	  install -m 644 include/*.hh $(DESTDIR)$(PREFIX)/include/UsageEnvironment
+	  install -m 644 $(USAGE_ENVIRONMENT_LIB) $(DESTDIR)$(LIBDIR)
+install_shared_libraries: $(USAGE_ENVIRONMENT_LIB)
+	  ln -fs $(NAME).$(LIB_SUFFIX) $(DESTDIR)$(LIBDIR)/$(NAME).$(SHORT_LIB_SUFFIX)
+	  ln -fs $(NAME).$(LIB_SUFFIX) $(DESTDIR)$(LIBDIR)/$(NAME).so
+
+##### Any additional, platform-specific rules come here:
diff --git a/3rdparty/live555/src/UsageEnvironment/UsageEnvironment.cpp b/3rdparty/live555/src/UsageEnvironment/UsageEnvironment.cpp
new file mode 100644
index 00000000..205cd0f5
--- /dev/null
+++ b/3rdparty/live555/src/UsageEnvironment/UsageEnvironment.cpp
@@ -0,0 +1,54 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// Usage Environment
+// Implementation
+
+#include "UsageEnvironment.hh"
+
+Boolean UsageEnvironment::reclaim() {
+    // We delete ourselves only if we have no remainining state:
+    if(liveMediaPriv == NULL && groupsockPriv == NULL) {
+        delete this;
+        return True;
+    }
+
+    return False;
+}
+
+UsageEnvironment::UsageEnvironment(TaskScheduler &scheduler) : liveMediaPriv(NULL), groupsockPriv(NULL), fScheduler(scheduler) {}
+
+UsageEnvironment::~UsageEnvironment() {}
+
+// By default, we handle 'should not occur'-type library errors by calling abort().  Subclasses can redefine this, if desired.
+// (If your runtime library doesn't define the "abort()" function, then define your own (e.g., that does nothing).)
+void UsageEnvironment::internalError() {
+    abort();
+}
+
+TaskScheduler::TaskScheduler() {}
+
+TaskScheduler::~TaskScheduler() {}
+
+void TaskScheduler::rescheduleDelayedTask(TaskToken &task, int64_t microseconds, TaskFunc *proc, void *clientData) {
+    unscheduleDelayedTask(task);
+    task = scheduleDelayedTask(microseconds, proc, clientData);
+}
+
+// By default, we handle 'should not occur'-type library errors by calling abort().  Subclasses can redefine this, if desired.
+void TaskScheduler::internalError() {
+    abort();
+}
diff --git a/3rdparty/live555/src/UsageEnvironment/include/Boolean.hh b/3rdparty/live555/src/UsageEnvironment/include/Boolean.hh
new file mode 100644
index 00000000..3d8401eb
--- /dev/null
+++ b/3rdparty/live555/src/UsageEnvironment/include/Boolean.hh
@@ -0,0 +1,37 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+#ifndef _BOOLEAN_HH
+#define _BOOLEAN_HH
+
+#if defined(__BORLANDC__) || (!defined(USE_LIVE555_BOOLEAN) && defined(_MSC_VER) &&  _MSC_VER >= 1400)
+// Use the "bool" type defined by the Borland compiler, and MSVC++ 8.0, Visual Studio 2005 and higher
+typedef bool Boolean;
+#define False false
+#define True true
+#else
+typedef unsigned char Boolean;
+#ifndef __MSHTML_LIBRARY_DEFINED__
+#ifndef False
+const Boolean False = 0;
+#endif
+#ifndef True
+const Boolean True = 1;
+#endif
+
+#endif
+#endif
+
+#endif
diff --git a/3rdparty/live555/src/UsageEnvironment/include/HashTable.hh b/3rdparty/live555/src/UsageEnvironment/include/HashTable.hh
new file mode 100644
index 00000000..2a824311
--- /dev/null
+++ b/3rdparty/live555/src/UsageEnvironment/include/HashTable.hh
@@ -0,0 +1,76 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// Generic Hash Table
+// C++ header
+
+#ifndef _HASH_TABLE_HH
+#define _HASH_TABLE_HH
+
+#ifndef _BOOLEAN_HH
+#include "Boolean.hh"
+#endif
+
+class HashTable {
+public:
+  virtual ~HashTable();
+  
+  // The following must be implemented by a particular
+  // implementation (subclass):
+  static HashTable* create(int keyType);
+  
+  virtual void* Add(char const* key, void* value) = 0;
+  // Returns the old value if different, otherwise 0
+  virtual Boolean Remove(char const* key) = 0;
+  virtual void* Lookup(char const* key) const = 0;
+  // Returns 0 if not found
+  virtual unsigned numEntries() const = 0;
+  Boolean IsEmpty() const { return numEntries() == 0; }
+  
+  // Used to iterate through the members of the table:
+  class Iterator {
+  public:
+    // The following must be implemented by a particular
+    // implementation (subclass):
+    static Iterator* create(HashTable const& hashTable);
+    
+    virtual ~Iterator();
+    
+    virtual void* next(char const*& key) = 0; // returns 0 if none
+    
+  protected:
+    Iterator(); // abstract base class
+  };
+  
+  // A shortcut that can be used to successively remove each of
+  // the entries in the table (e.g., so that their values can be
+  // deleted, if they happen to be pointers to allocated memory).
+  void* RemoveNext();
+  
+  // Returns the first entry in the table.
+  // (This is useful for deleting each entry in the table, if the entry's destructor also removes itself from the table.)
+  void* getFirst(); 
+  
+protected:
+  HashTable(); // abstract base class
+};
+
+// Warning: The following are deliberately the same as in
+// Tcl's hash table implementation
+int const STRING_HASH_KEYS = 0;
+int const ONE_WORD_HASH_KEYS = 1;
+
+#endif
diff --git a/3rdparty/live555/src/UsageEnvironment/include/UsageEnvironment.hh b/3rdparty/live555/src/UsageEnvironment/include/UsageEnvironment.hh
new file mode 100644
index 00000000..2527c2cb
--- /dev/null
+++ b/3rdparty/live555/src/UsageEnvironment/include/UsageEnvironment.hh
@@ -0,0 +1,172 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// Usage Environment
+// C++ header
+
+#ifndef _USAGE_ENVIRONMENT_HH
+#define _USAGE_ENVIRONMENT_HH
+
+#ifndef _USAGEENVIRONMENT_VERSION_HH
+#include "UsageEnvironment_version.hh"
+#endif
+
+#ifndef _NETCOMMON_H
+#include "NetCommon.h"
+#endif
+
+#ifndef _BOOLEAN_HH
+#include "Boolean.hh"
+#endif
+
+#ifndef _STRDUP_HH
+// "strDup()" is used often, so include this here, so everyone gets it:
+#include "strDup.hh"
+#endif
+
+#ifndef NULL
+#define NULL 0
+#endif
+
+#ifdef __BORLANDC__
+#define _setmode setmode
+#define _O_BINARY O_BINARY
+#endif
+
+class TaskScheduler; // forward
+
+// An abstract base class, subclassed for each use of the library
+
+class UsageEnvironment {
+public:
+  Boolean reclaim();
+      // returns True iff we were actually able to delete our object
+
+  // task scheduler:
+  TaskScheduler& taskScheduler() const {return fScheduler;}
+
+  // result message handling:
+  typedef char const* MsgString;
+  virtual MsgString getResultMsg() const = 0;
+
+  virtual void setResultMsg(MsgString msg) = 0;
+  virtual void setResultMsg(MsgString msg1, MsgString msg2) = 0;
+  virtual void setResultMsg(MsgString msg1, MsgString msg2, MsgString msg3) = 0;
+  virtual void setResultErrMsg(MsgString msg, int err = 0) = 0;
+	// like setResultMsg(), except that an 'errno' message is appended.  (If "err == 0", the "getErrno()" code is used instead.)
+
+  virtual void appendToResultMsg(MsgString msg) = 0;
+
+  virtual void reportBackgroundError() = 0;
+	// used to report a (previously set) error message within
+	// a background event
+
+  virtual void internalError(); // used to 'handle' a 'should not occur'-type error condition within the library.
+
+  // 'errno'
+  virtual int getErrno() const = 0;
+
+  // 'console' output:
+  virtual UsageEnvironment& operator<<(char const* str) = 0;
+  virtual UsageEnvironment& operator<<(int i) = 0;
+  virtual UsageEnvironment& operator<<(unsigned u) = 0;
+  virtual UsageEnvironment& operator<<(double d) = 0;
+  virtual UsageEnvironment& operator<<(void* p) = 0;
+
+  // a pointer to additional, optional, client-specific state
+  void* liveMediaPriv;
+  void* groupsockPriv;
+
+protected:
+  UsageEnvironment(TaskScheduler& scheduler); // abstract base class
+  virtual ~UsageEnvironment(); // we are deleted only by reclaim()
+
+private:
+  TaskScheduler& fScheduler;
+};
+
+
+typedef void TaskFunc(void* clientData);
+typedef void* TaskToken;
+typedef u_int32_t EventTriggerId;
+
+class TaskScheduler {
+public:
+  virtual ~TaskScheduler();
+
+  virtual TaskToken scheduleDelayedTask(int64_t microseconds, TaskFunc* proc,
+					void* clientData) = 0;
+	// Schedules a task to occur (after a delay) when we next
+	// reach a scheduling point.
+	// (Does not delay if "microseconds" <= 0)
+	// Returns a token that can be used in a subsequent call to
+	// unscheduleDelayedTask() or rescheduleDelayedTask()
+        // (but only if the task has not yet occurred).
+
+  virtual void unscheduleDelayedTask(TaskToken& prevTask) = 0;
+	// (Has no effect if "prevTask" == NULL)
+        // Sets "prevTask" to NULL afterwards.
+        // Note: This MUST NOT be called if the scheduled task has already occurred.
+
+  virtual void rescheduleDelayedTask(TaskToken& task,
+				     int64_t microseconds, TaskFunc* proc,
+				     void* clientData);
+        // Combines "unscheduleDelayedTask()" with "scheduleDelayedTask()"
+        // (setting "task" to the new task token).
+        // Note: This MUST NOT be called if the scheduled task has already occurred.
+
+  // For handling socket operations in the background (from the event loop):
+  typedef void BackgroundHandlerProc(void* clientData, int mask);
+    // Possible bits to set in "mask".  (These are deliberately defined
+    // the same as those in Tcl, to make a Tcl-based subclass easy.)
+    #define SOCKET_READABLE    (1<<1)
+    #define SOCKET_WRITABLE    (1<<2)
+    #define SOCKET_EXCEPTION   (1<<3)
+  virtual void setBackgroundHandling(int socketNum, int conditionSet, BackgroundHandlerProc* handlerProc, void* clientData) = 0;
+  void disableBackgroundHandling(int socketNum) { setBackgroundHandling(socketNum, 0, NULL, NULL); }
+  virtual void moveSocketHandling(int oldSocketNum, int newSocketNum) = 0;
+        // Changes any socket handling for "oldSocketNum" so that occurs with "newSocketNum" instead.
+
+  virtual void doEventLoop(char volatile* watchVariable = NULL) = 0;
+      // Causes further execution to take place within the event loop.
+      // Delayed tasks, background I/O handling, and other events are handled, sequentially (as a single thread of control).
+      // (If "watchVariable" is not NULL, then we return from this routine when *watchVariable != 0)
+
+  virtual EventTriggerId createEventTrigger(TaskFunc* eventHandlerProc) = 0;
+      // Creates a 'trigger' for an event, which - if it occurs - will be handled (from the event loop) using "eventHandlerProc".
+      // (Returns 0 iff no such trigger can be created (e.g., because of implementation limits on the number of triggers).)
+  virtual void deleteEventTrigger(EventTriggerId eventTriggerId) = 0;
+
+  virtual void triggerEvent(EventTriggerId eventTriggerId, void* clientData = NULL) = 0;
+      // Causes the (previously-registered) handler function for the specified event to be handled (from the event loop).
+      // The handler function is called with "clientData" as parameter.
+      // Note: This function (unlike other library functions) may be called from an external thread
+      // - to signal an external event.  (However, "triggerEvent()" should not be called with the
+      // same 'event trigger id' from different threads.)
+
+  // The following two functions are deprecated, and are provided for backwards-compatibility only:
+  void turnOnBackgroundReadHandling(int socketNum, BackgroundHandlerProc* handlerProc, void* clientData) {
+    setBackgroundHandling(socketNum, SOCKET_READABLE, handlerProc, clientData);
+  }
+  void turnOffBackgroundReadHandling(int socketNum) { disableBackgroundHandling(socketNum); }
+
+  virtual void internalError(); // used to 'handle' a 'should not occur'-type error condition within the library.
+
+protected:
+  TaskScheduler(); // abstract base class
+};
+
+#endif
diff --git a/3rdparty/live555/src/UsageEnvironment/include/UsageEnvironment_version.hh b/3rdparty/live555/src/UsageEnvironment/include/UsageEnvironment_version.hh
new file mode 100644
index 00000000..ced5e9c6
--- /dev/null
+++ b/3rdparty/live555/src/UsageEnvironment/include/UsageEnvironment_version.hh
@@ -0,0 +1,25 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// Version information for the "UsageEnvironment" library
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+
+#ifndef _USAGEENVIRONMENT_VERSION_HH
+#define _USAGEENVIRONMENT_VERSION_HH
+
+#define USAGEENVIRONMENT_LIBRARY_VERSION_STRING	"2022.04.26"
+#define USAGEENVIRONMENT_LIBRARY_VERSION_INT		1650931200
+
+#endif
diff --git a/3rdparty/live555/src/UsageEnvironment/include/strDup.hh b/3rdparty/live555/src/UsageEnvironment/include/strDup.hh
new file mode 100644
index 00000000..d59723d2
--- /dev/null
+++ b/3rdparty/live555/src/UsageEnvironment/include/strDup.hh
@@ -0,0 +1,37 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+
+#ifndef _STRDUP_HH
+#define _STRDUP_HH
+
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A C++ equivalent to the standard C routine "strdup()".
+// This generates a char* that can be deleted using "delete[]"
+// Header
+
+#include <string.h>
+
+char* strDup(char const* str);
+// Note: strDup(NULL) returns NULL
+
+char* strDupSize(char const* str);
+// Like "strDup()", except that it *doesn't* copy the original.
+// (Instead, it just allocates a string of the same size as the original.)
+
+char* strDupSize(char const* str, size_t& resultBufSize);
+// An alternative form of "strDupSize()" that also returns the size of the allocated buffer.
+
+#endif
diff --git a/3rdparty/live555/src/UsageEnvironment/strDup.cpp b/3rdparty/live555/src/UsageEnvironment/strDup.cpp
new file mode 100644
index 00000000..8ba1c620
--- /dev/null
+++ b/3rdparty/live555/src/UsageEnvironment/strDup.cpp
@@ -0,0 +1,51 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A C++ equivalent to the standard C routine "strdup()".
+// This generates a char* that can be deleted using "delete[]"
+// Implementation
+
+#include "strDup.hh"
+
+char *strDup(char const *str) {
+    if(str == NULL)
+        return NULL;
+    size_t len  = strlen(str) + 1;
+    char * copy = new char[len];
+
+    if(copy != NULL) {
+        memcpy(copy, str, len);
+    }
+    return copy;
+}
+
+char *strDupSize(char const *str) {
+    size_t dummy;
+
+    return strDupSize(str, dummy);
+}
+
+char *strDupSize(char const *str, size_t &resultBufSize) {
+    if(str == NULL) {
+        resultBufSize = 0;
+        return NULL;
+    }
+
+    resultBufSize = strlen(str) + 1;
+    char *copy    = new char[resultBufSize];
+
+    return copy;
+}
diff --git a/3rdparty/live555/src/WindowsAudioInputDevice/WindowsAudioInputDevice.mak b/3rdparty/live555/src/WindowsAudioInputDevice/WindowsAudioInputDevice.mak
new file mode 100644
index 00000000..50230e58
--- /dev/null
+++ b/3rdparty/live555/src/WindowsAudioInputDevice/WindowsAudioInputDevice.mak
@@ -0,0 +1,108 @@
+INCLUDES = -I../UsageEnvironment/include -I../groupsock/include -I../liveMedia/include
+##### Change the following for your environment: 
+# Comment out the following line to produce Makefiles that generate debuggable code:
+NODEBUG=1
+
+# The following definition ensures that we are properly matching
+# the WinSock2 library file with the correct header files.
+# (will link with "ws2_32.lib" and include "winsock2.h" & "Ws2tcpip.h")
+TARGETOS = WINNT
+
+# If for some reason you wish to use WinSock1 instead, uncomment the
+# following two definitions.
+# (will link with "wsock32.lib" and include "winsock.h")
+#TARGETOS = WIN95
+#APPVER = 4.0
+
+!include    <ntwin32.mak>
+
+UI_OPTS =		$(guilflags) $(guilibsdll)
+# Use the following to get a console (e.g., for debugging):
+CONSOLE_UI_OPTS =		$(conlflags) $(conlibsdll)
+CPU=i386
+
+TOOLS32	=		c:\Program Files\DevStudio\Vc
+COMPILE_OPTS =		$(INCLUDES) $(cdebug) $(cflags) $(cvarsdll) -I. -I"$(TOOLS32)\include"
+C =			c
+C_COMPILER =		"$(TOOLS32)\bin\cl"
+C_FLAGS =		$(COMPILE_OPTS)
+CPP =			cpp
+CPLUSPLUS_COMPILER =	$(C_COMPILER)
+CPLUSPLUS_FLAGS =	$(COMPILE_OPTS)
+OBJ =			obj
+LINK =			$(link) -out:
+LIBRARY_LINK =		lib -out:
+LINK_OPTS_0 =		$(linkdebug) msvcirt.lib
+LIBRARY_LINK_OPTS =	
+LINK_OPTS =		$(LINK_OPTS_0) $(UI_OPTS)
+CONSOLE_LINK_OPTS =	$(LINK_OPTS_0) $(CONSOLE_UI_OPTS)
+SERVICE_LINK_OPTS =     kernel32.lib advapi32.lib shell32.lib -subsystem:console,$(APPVER)
+LIB_SUFFIX =		lib
+LIBS_FOR_CONSOLE_APPLICATION =
+LIBS_FOR_GUI_APPLICATION =
+MULTIMEDIA_LIBS =	winmm.lib
+EXE =			.exe
+
+rc32 = "$(TOOLS32)\bin\rc"
+.rc.res:
+	$(rc32) $<
+##### End of variables to change
+
+WINDOWSAUDIOINPUTDEVICE_NOMIXER_LIB = libWindowsAudioInputDevice_noMixer.$(LIB_SUFFIX)
+WINDOWSAUDIOINPUTDEVICE_MIXER_LIB = libWindowsAudioInputDevice_mixer.$(LIB_SUFFIX)
+ALL = $(WINDOWSAUDIOINPUTDEVICE_NOMIXER_LIB) $(WINDOWSAUDIOINPUTDEVICE_MIXER_LIB) \
+	showAudioInputPorts_noMixer$(EXE) showAudioInputPorts_mixer$(EXE)
+all::	$(ALL)
+
+.$(C).$(OBJ):
+	$(C_COMPILER) -c $(C_FLAGS) $<       
+
+.$(CPP).$(OBJ):
+	$(CPLUSPLUS_COMPILER) -c $(CPLUSPLUS_FLAGS) $<
+
+WINDOWSAUDIOINPUTDEVICE_NOMIXER_LIB_OBJS = WindowsAudioInputDevice_common.$(OBJ) WindowsAudioInputDevice_noMixer.$(OBJ)
+WINDOWSAUDIOINPUTDEVICE_MIXER_LIB_OBJS = WindowsAudioInputDevice_common.$(OBJ) WindowsAudioInputDevice_mixer.$(OBJ)
+
+WindowsAudioInputDevice_common.$(CPP):	WindowsAudioInputDevice_common.hh
+WindowsAudioInputDevice_noMixer.$(CPP):	WindowsAudioInputDevice_noMixer.hh
+WindowsAudioInputDevice_noMixer.hh:		WindowsAudioInputDevice_common.hh
+WindowsAudioInputDevice_mixer.$(CPP):	WindowsAudioInputDevice_mixer.hh
+WindowsAudioInputDevice_mixer.hh:		WindowsAudioInputDevice_common.hh
+
+$(WINDOWSAUDIOINPUTDEVICE_NOMIXER_LIB): $(WINDOWSAUDIOINPUTDEVICE_NOMIXER_LIB_OBJS) \
+	$(PLATFORM_SPECIFIC_LIB_OBJS)
+	$(LIBRARY_LINK)$@ $(LIBRARY_LINK_OPTS) \
+	$(WINDOWSAUDIOINPUTDEVICE_NOMIXER_LIB_OBJS)
+$(WINDOWSAUDIOINPUTDEVICE_MIXER_LIB): $(WINDOWSAUDIOINPUTDEVICE_MIXER_LIB_OBJS) \
+	$(PLATFORM_SPECIFIC_LIB_OBJS)
+	$(LIBRARY_LINK)$@ $(LIBRARY_LINK_OPTS) \
+	$(WINDOWSAUDIOINPUTDEVICE_MIXER_LIB_OBJS)
+
+USAGE_ENVIRONMENT_DIR = ../UsageEnvironment
+USAGE_ENVIRONMENT_LIB = $(USAGE_ENVIRONMENT_DIR)/libUsageEnvironment.$(LIB_SUFFIX)
+BASIC_USAGE_ENVIRONMENT_DIR = ../BasicUsageEnvironment
+BASIC_USAGE_ENVIRONMENT_LIB = $(BASIC_USAGE_ENVIRONMENT_DIR)/libBasicUsageEnvironment.$(LIB_SUFFIX)
+LIVEMEDIA_DIR = ../liveMedia
+LIVEMEDIA_LIB = $(LIVEMEDIA_DIR)/libliveMedia.$(LIB_SUFFIX)
+GROUPSOCK_DIR = ../groupsock
+GROUPSOCK_LIB = $(GROUPSOCK_DIR)/libgroupsock.$(LIB_SUFFIX)
+LOCAL_LIBS =    $(LIVEMEDIA_LIB) $(GROUPSOCK_LIB) \
+                $(USAGE_ENVIRONMENT_LIB) $(BASIC_USAGE_ENVIRONMENT_LIB)
+LOCAL_LIBS_NOMIXER =    $(WINDOWSAUDIOINPUTDEVICE_NOMIXER_LIB) $(LOCAL_LIBS)
+LOCAL_LIBS_MIXER =    $(WINDOWSAUDIOINPUTDEVICE_MIXER_LIB) $(LOCAL_LIBS)
+MULTIMEDIA_LIBS =       winmm.lib
+LIBS_NOMIXER = $(LOCAL_LIBS_NOMIXER) $(LIBS_FOR_CONSOLE_APPLICATION) $(MULTIMEDIA_LIBS)
+LIBS_MIXER = $(LOCAL_LIBS_MIXER) $(LIBS_FOR_CONSOLE_APPLICATION) $(MULTIMEDIA_LIBS)
+
+SHOW_AUDIO_INPUT_PORTS_OBJS = showAudioInputPorts.$(OBJ)
+
+showAudioInputPorts_noMixer$(EXE):	$(SHOW_AUDIO_INPUT_PORTS_OBJS) $(LOCAL_LIBS_NOMIXER)
+	$(LINK)$@ $(CONSOLE_LINK_OPTS) $(SHOW_AUDIO_INPUT_PORTS_OBJS) $(LIBS_NOMIXER)
+showAudioInputPorts_mixer$(EXE):	$(SHOW_AUDIO_INPUT_PORTS_OBJS) $(LOCAL_LIBS_MIXER)
+	$(LINK)$@ $(CONSOLE_LINK_OPTS) $(SHOW_AUDIO_INPUT_PORTS_OBJS) $(LIBS_MIXER)
+
+clean:
+	-rm -rf *.$(OBJ) $(ALL) tcl2array$(EXE) core *.core *~
+	-rm -rf $(TCL_EMBEDDED_CPLUSPLUS_FILES) $(TK_EMBEDDED_CPLUSPLUS_FILES) $(MISC_EMBEDDED_CPLUSPLUS_FILES)
+
+##### Any additional, platform-specific rules come here:
diff --git a/3rdparty/live555/src/WindowsAudioInputDevice/WindowsAudioInputDevice_common.cpp b/3rdparty/live555/src/WindowsAudioInputDevice/WindowsAudioInputDevice_common.cpp
new file mode 100644
index 00000000..c0e7327e
--- /dev/null
+++ b/3rdparty/live555/src/WindowsAudioInputDevice/WindowsAudioInputDevice_common.cpp
@@ -0,0 +1,337 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// Copyright (c) 2001-2004 Live Networks, Inc.  All rights reserved.
+// Windows implementation of a generic audio input device
+// Base class for both library versions:
+//     One that uses Windows' built-in software mixer; another that doesn't.
+// Implementation
+
+#include "WindowsAudioInputDevice_common.hh"
+#include <GroupsockHelper.hh>
+
+////////// WindowsAudioInputDevice_common implementation //////////
+
+unsigned WindowsAudioInputDevice_common::_bitsPerSample = 16;
+
+WindowsAudioInputDevice_common ::WindowsAudioInputDevice_common(UsageEnvironment &env, int inputPortNumber, unsigned char bitsPerSample,
+                                                                unsigned char numChannels, unsigned samplingFrequency, unsigned granularityInMS)
+    : AudioInputDevice(env, bitsPerSample, numChannels, samplingFrequency, granularityInMS), fCurPortIndex(-1), fHaveStarted(False) {
+    _bitsPerSample = bitsPerSample;
+}
+
+WindowsAudioInputDevice_common::~WindowsAudioInputDevice_common() {}
+
+Boolean WindowsAudioInputDevice_common::initialSetInputPort(int portIndex) {
+    if(!setInputPort(portIndex)) {
+        char errMsgPrefix[100];
+        sprintf(errMsgPrefix, "Failed to set audio input port number to %d: ", portIndex);
+        char *errMsgSuffix = strDup(envir().getResultMsg());
+        envir().setResultMsg(errMsgPrefix, errMsgSuffix);
+        delete[] errMsgSuffix;
+        return False;
+    }
+    else {
+        return True;
+    }
+}
+
+void WindowsAudioInputDevice_common::doGetNextFrame() {
+    if(!fHaveStarted) {
+        // Before reading the first audio data, flush any existing data:
+        while(readHead != NULL)
+            releaseHeadBuffer();
+        fHaveStarted = True;
+    }
+    fTotalPollingDelay = 0;
+    audioReadyPoller1();
+}
+
+void WindowsAudioInputDevice_common::doStopGettingFrames() {
+    // Turn off the audio poller:
+    envir().taskScheduler().unscheduleDelayedTask(nextTask());
+}
+
+double WindowsAudioInputDevice_common::getAverageLevel() const {
+    // If the input audio queue is empty, return the previous level,
+    // otherwise use the input queue to recompute "averageLevel":
+    if(readHead != NULL) {
+        double   levelTotal    = 0.0;
+        unsigned totNumSamples = 0;
+        WAVEHDR *curHdr        = readHead;
+        while(1) {
+            short *  samplePtr  = (short *)(curHdr->lpData);
+            unsigned numSamples = blockSize / 2;
+            totNumSamples += numSamples;
+
+            while(numSamples-- > 0) {
+                short sample = *samplePtr++;
+                if(sample < 0)
+                    sample = -sample;
+                levelTotal += (unsigned short)sample;
+            }
+
+            if(curHdr == readTail)
+                break;
+            curHdr = curHdr->lpNext;
+        }
+        averageLevel = levelTotal / (totNumSamples * (double)0x8000);
+    }
+    return averageLevel;
+}
+
+void WindowsAudioInputDevice_common::audioReadyPoller(void *clientData) {
+    WindowsAudioInputDevice_common *inputDevice = (WindowsAudioInputDevice_common *)clientData;
+    inputDevice->audioReadyPoller1();
+}
+
+void WindowsAudioInputDevice_common::audioReadyPoller1() {
+    nextTask() = NULL;
+    if(readHead != NULL) {
+        onceAudioIsReady();
+    }
+    else {
+        unsigned const maxPollingDelay = (100 + fGranularityInMS) * 1000;
+        if(fTotalPollingDelay > maxPollingDelay) {
+            // We've waited too long for the audio device - assume it's down:
+            handleClosure(this);
+            return;
+        }
+
+        // Try again after a short delay:
+        unsigned const uSecondsToDelay = fGranularityInMS * 1000;
+        fTotalPollingDelay += uSecondsToDelay;
+        nextTask() = envir().taskScheduler().scheduleDelayedTask(uSecondsToDelay, (TaskFunc *)audioReadyPoller, this);
+    }
+}
+
+void WindowsAudioInputDevice_common::onceAudioIsReady() {
+    fFrameSize = readFromBuffers(fTo, fMaxSize, fPresentationTime);
+    if(fFrameSize == 0) {
+        // The source is no longer readable
+        handleClosure(this);
+        return;
+    }
+    fDurationInMicroseconds = 1000000 / fSamplingFrequency;
+
+    // Call our own 'after getting' function.  Because we sometimes get here
+    // after returning from a delay, we can call this directly, without risking
+    // infinite recursion
+    afterGetting(this);
+}
+
+static void CALLBACK waveInCallback(HWAVEIN /*hwi*/, UINT uMsg, DWORD /*dwInstance*/, DWORD dwParam1, DWORD /*dwParam2*/) {
+    switch(uMsg) {
+    case WIM_DATA:
+        WAVEHDR *hdr = (WAVEHDR *)dwParam1;
+        WindowsAudioInputDevice_common::waveInProc(hdr);
+        break;
+    }
+}
+
+Boolean WindowsAudioInputDevice_common::openWavInPort(int index, unsigned numChannels, unsigned samplingFrequency, unsigned granularityInMS) {
+    uSecsPerByte = (8 * 1e6) / (_bitsPerSample * numChannels * samplingFrequency);
+
+    // Configure the port, based on the specified parameters:
+    WAVEFORMATEX wfx;
+    wfx.wFormatTag      = WAVE_FORMAT_PCM;
+    wfx.nChannels       = numChannels;
+    wfx.nSamplesPerSec  = samplingFrequency;
+    wfx.wBitsPerSample  = _bitsPerSample;
+    wfx.nBlockAlign     = (numChannels * _bitsPerSample) / 8;
+    wfx.nAvgBytesPerSec = samplingFrequency * wfx.nBlockAlign;
+    wfx.cbSize          = 0;
+
+    blockSize = (wfx.nAvgBytesPerSec * granularityInMS) / 1000;
+
+    // Use a 10-second input buffer, to allow for CPU competition from video, etc.,
+    // and also for some audio cards that buffer as much as 5 seconds of audio.
+    unsigned const bufferSeconds = 10;
+    numBlocks                    = (bufferSeconds * 1000) / granularityInMS;
+
+    if(!waveIn_open(index, wfx))
+        return False;
+
+    // Set this process's priority high. I'm not sure how much this is really needed,
+    // but the "rat" code does this:
+    SetPriorityClass(GetCurrentProcess(), HIGH_PRIORITY_CLASS);
+    return True;
+}
+
+Boolean WindowsAudioInputDevice_common::waveIn_open(unsigned uid, WAVEFORMATEX &wfx) {
+    if(shWaveIn != NULL)
+        return True;  // already open
+
+    do {
+        waveIn_reset();
+        if(waveInOpen(&shWaveIn, uid, &wfx, (DWORD)waveInCallback, 0, CALLBACK_FUNCTION) != MMSYSERR_NOERROR)
+            break;
+
+        // Allocate read buffers, and headers:
+        readData = new unsigned char[numBlocks * blockSize];
+        if(readData == NULL)
+            break;
+
+        readHdrs = new WAVEHDR[numBlocks];
+        if(readHdrs == NULL)
+            break;
+        readHead = readTail = NULL;
+
+        readTimes = new struct timeval[numBlocks];
+        if(readTimes == NULL)
+            break;
+
+        // Initialize headers:
+        for(unsigned i = 0; i < numBlocks; ++i) {
+            readHdrs[i].lpData         = (char *)&readData[i * blockSize];
+            readHdrs[i].dwBufferLength = blockSize;
+            readHdrs[i].dwFlags        = 0;
+            if(waveInPrepareHeader(shWaveIn, &readHdrs[i], sizeof(WAVEHDR)) != MMSYSERR_NOERROR)
+                break;
+            if(waveInAddBuffer(shWaveIn, &readHdrs[i], sizeof(WAVEHDR)) != MMSYSERR_NOERROR)
+                break;
+        }
+
+        if(waveInStart(shWaveIn) != MMSYSERR_NOERROR)
+            break;
+
+#ifdef UNICODE
+        hAudioReady = CreateEvent(NULL, TRUE, FALSE, L"waveIn Audio Ready");
+#else
+        hAudioReady = CreateEvent(NULL, TRUE, FALSE, "waveIn Audio Ready");
+#endif
+        return True;
+    } while(0);
+
+    waveIn_reset();
+    return False;
+}
+
+void WindowsAudioInputDevice_common::waveIn_close() {
+    if(shWaveIn == NULL)
+        return;  // already closed
+
+    waveInStop(shWaveIn);
+    waveInReset(shWaveIn);
+
+    for(unsigned i = 0; i < numBlocks; ++i) {
+        if(readHdrs[i].dwFlags & WHDR_PREPARED) {
+            waveInUnprepareHeader(shWaveIn, &readHdrs[i], sizeof(WAVEHDR));
+        }
+    }
+
+    waveInClose(shWaveIn);
+    waveIn_reset();
+}
+
+void WindowsAudioInputDevice_common::waveIn_reset() {
+    shWaveIn = NULL;
+
+    delete[] readData;
+    readData            = NULL;
+    bytesUsedAtReadHead = 0;
+
+    delete[] readHdrs;
+    readHdrs = NULL;
+    readHead = readTail = NULL;
+
+    delete[] readTimes;
+    readTimes = NULL;
+
+    hAudioReady = NULL;
+}
+
+unsigned WindowsAudioInputDevice_common::readFromBuffers(unsigned char *to, unsigned numBytesWanted, struct timeval &creationTime) {
+    // Begin by computing the creation time of (the first bytes of) this returned audio data:
+    if(readHead != NULL) {
+        int hdrIndex = readHead - readHdrs;
+        creationTime = readTimes[hdrIndex];
+
+        // Adjust this time to allow for any data that's already been read from this buffer:
+        if(bytesUsedAtReadHead > 0) {
+            creationTime.tv_usec += (unsigned)(uSecsPerByte * bytesUsedAtReadHead);
+            creationTime.tv_sec += creationTime.tv_usec / 1000000;
+            creationTime.tv_usec %= 1000000;
+        }
+    }
+
+    // Then, read from each available buffer, until we have the data that we want:
+    unsigned numBytesRead = 0;
+    while(readHead != NULL && numBytesRead < numBytesWanted) {
+        unsigned thisRead = min(readHead->dwBytesRecorded - bytesUsedAtReadHead, numBytesWanted - numBytesRead);
+        memmove(&to[numBytesRead], &readHead->lpData[bytesUsedAtReadHead], thisRead);
+        numBytesRead += thisRead;
+        bytesUsedAtReadHead += thisRead;
+        if(bytesUsedAtReadHead == readHead->dwBytesRecorded) {
+            // We're finished with the block; give it back to the device:
+            releaseHeadBuffer();
+        }
+    }
+
+    return numBytesRead;
+}
+
+void WindowsAudioInputDevice_common::releaseHeadBuffer() {
+    WAVEHDR *toRelease = readHead;
+    if(readHead == NULL)
+        return;
+
+    readHead = readHead->lpNext;
+    if(readHead == NULL)
+        readTail = NULL;
+
+    toRelease->lpNext          = NULL;
+    toRelease->dwBytesRecorded = 0;
+    toRelease->dwFlags &= ~WHDR_DONE;
+    waveInAddBuffer(shWaveIn, toRelease, sizeof(WAVEHDR));
+    bytesUsedAtReadHead = 0;
+}
+
+void WindowsAudioInputDevice_common::waveInProc(WAVEHDR *hdr) {
+    unsigned hdrIndex = hdr - readHdrs;
+
+    // Record the time that the data arrived:
+    int dontCare;
+    gettimeofday(&readTimes[hdrIndex], &dontCare);
+
+    // Add the block to the tail of the queue:
+    hdr->lpNext = NULL;
+    if(readTail != NULL) {
+        readTail->lpNext = hdr;
+        readTail         = hdr;
+    }
+    else {
+        readHead = readTail = hdr;
+    }
+    SetEvent(hAudioReady);
+}
+
+HWAVEIN WindowsAudioInputDevice_common::shWaveIn = NULL;
+
+unsigned WindowsAudioInputDevice_common::blockSize = 0;
+unsigned WindowsAudioInputDevice_common::numBlocks = 0;
+
+unsigned char *WindowsAudioInputDevice_common::readData            = NULL;
+DWORD          WindowsAudioInputDevice_common::bytesUsedAtReadHead = 0;
+double         WindowsAudioInputDevice_common::uSecsPerByte        = 0.0;
+double         WindowsAudioInputDevice_common::averageLevel        = 0.0;
+
+WAVEHDR *WindowsAudioInputDevice_common::readHdrs = NULL;
+WAVEHDR *WindowsAudioInputDevice_common::readHead = NULL;
+WAVEHDR *WindowsAudioInputDevice_common::readTail = NULL;
+
+struct timeval *WindowsAudioInputDevice_common::readTimes = NULL;
+
+HANDLE WindowsAudioInputDevice_common::hAudioReady = NULL;
diff --git a/3rdparty/live555/src/WindowsAudioInputDevice/WindowsAudioInputDevice_common.hh b/3rdparty/live555/src/WindowsAudioInputDevice/WindowsAudioInputDevice_common.hh
new file mode 100644
index 00000000..936a494f
--- /dev/null
+++ b/3rdparty/live555/src/WindowsAudioInputDevice/WindowsAudioInputDevice_common.hh
@@ -0,0 +1,82 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// Windows implementation of a generic audio input device
+// Base class for both library versions:
+//     One that uses Windows' built-in software mixer; another that doesn't.
+// C++ header
+
+#ifndef _WINDOWS_AUDIO_INPUT_DEVICE_COMMON_HH
+#define _WINDOWS_AUDIO_INPUT_DEVICE_COMMON_HH
+
+#ifndef _AUDIO_INPUT_DEVICE_HH
+#include "AudioInputDevice.hh"
+#endif
+
+class WindowsAudioInputDevice_common: public AudioInputDevice {
+public:
+  static Boolean openWavInPort(int index, unsigned numChannels, unsigned samplingFrequency, unsigned granularityInMS);
+  static void waveIn_close();
+  static void waveInProc(WAVEHDR* hdr); // Windows audio callback function
+
+protected:
+  WindowsAudioInputDevice_common(UsageEnvironment& env, int inputPortNumber,
+	unsigned char bitsPerSample, unsigned char numChannels,
+	unsigned samplingFrequency, unsigned granularityInMS);
+	// virtual base class
+
+  virtual ~WindowsAudioInputDevice_common();
+
+  Boolean initialSetInputPort(int portIndex);
+
+protected:
+  int fCurPortIndex;
+
+private:
+  // redefined virtual functions:
+  virtual void doGetNextFrame();
+  virtual void doStopGettingFrames();
+  virtual double getAverageLevel() const;
+
+private:
+  static void audioReadyPoller(void* clientData);
+
+  void audioReadyPoller1();
+  void onceAudioIsReady();
+
+  // Audio input buffering:
+  static Boolean waveIn_open(unsigned uid, WAVEFORMATEX& wfx);
+  static void waveIn_reset(); // used to implement both of the above
+  static unsigned readFromBuffers(unsigned char* to, unsigned numBytesWanted, struct timeval& creationTime);
+  static void releaseHeadBuffer(); // from the input header queue
+
+private:
+  static unsigned _bitsPerSample;
+  static HWAVEIN shWaveIn;
+  static unsigned blockSize, numBlocks;
+  static unsigned char* readData; // buffer for incoming audio data
+  static DWORD bytesUsedAtReadHead; // number of bytes that have already been read at head
+  static double uSecsPerByte; // used to adjust the time for # bytes consumed since arrival
+  static double averageLevel;
+  static WAVEHDR *readHdrs, *readHead, *readTail; // input header queue
+  static struct timeval* readTimes;
+  static HANDLE hAudioReady; // audio ready event
+
+  Boolean fHaveStarted;
+  unsigned fTotalPollingDelay; // uSeconds
+};
+
+#endif
diff --git a/3rdparty/live555/src/WindowsAudioInputDevice/WindowsAudioInputDevice_mixer.cpp b/3rdparty/live555/src/WindowsAudioInputDevice/WindowsAudioInputDevice_mixer.cpp
new file mode 100644
index 00000000..897ec3af
--- /dev/null
+++ b/3rdparty/live555/src/WindowsAudioInputDevice/WindowsAudioInputDevice_mixer.cpp
@@ -0,0 +1,497 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// Copyright (c) 2001-2004 Live Networks, Inc.  All rights reserved.
+// Windows implementation of a generic audio input device
+// This version uses Windows' built-in software mixer.
+// Implementation
+
+#include <WindowsAudioInputDevice_mixer.hh>
+
+////////// Mixer and AudioInputPort definition //////////
+
+class AudioInputPort {
+public:
+    int   tag;
+    DWORD dwComponentType;
+    char  name[MIXER_LONG_NAME_CHARS];
+};
+
+class Mixer {
+public:
+    Mixer();
+    virtual ~Mixer();
+
+    void    open(unsigned numChannels, unsigned samplingFrequency, unsigned granularityInMS);
+    void    open();  // open with default parameters
+    void    getPortsInfo();
+    Boolean enableInputPort(unsigned portIndex, char const *&errReason, MMRESULT &errCode);
+    void    close();
+
+    unsigned        index;
+    HMIXER          hMixer;       // valid when open
+    DWORD           dwRecLineID;  // valid when open
+    unsigned        numPorts;
+    AudioInputPort *ports;
+    char            name[MAXPNAMELEN];
+};
+
+////////// AudioInputDevice (remaining) implementation //////////
+
+AudioInputDevice *AudioInputDevice::createNew(UsageEnvironment &env, int inputPortNumber, unsigned char bitsPerSample, unsigned char numChannels,
+                                              unsigned samplingFrequency, unsigned granularityInMS) {
+    Boolean                  success;
+    WindowsAudioInputDevice *newSource =
+        new WindowsAudioInputDevice(env, inputPortNumber, bitsPerSample, numChannels, samplingFrequency, granularityInMS, success);
+    if(!success) {
+        delete newSource;
+        newSource = NULL;
+    }
+
+    return newSource;
+}
+
+AudioPortNames *AudioInputDevice::getPortNames() {
+    WindowsAudioInputDevice::initializeIfNecessary();
+
+    AudioPortNames *portNames = new AudioPortNames;
+    portNames->numPorts       = WindowsAudioInputDevice::numInputPortsTotal;
+    portNames->portName       = new char *[WindowsAudioInputDevice::numInputPortsTotal];
+
+    // If there's more than one mixer, print only the port name.
+    // If there's two or more mixers, also include the mixer name
+    // (to disambiguate port names that may be the same name in different mixers)
+    char        portNameBuffer[2 * MAXPNAMELEN + 10 /*slop*/];
+    char        mixerNameBuffer[MAXPNAMELEN];
+    char const *portNameFmt;
+    if(WindowsAudioInputDevice::numMixers <= 1) {
+        portNameFmt = "%s";
+    }
+    else {
+        portNameFmt = "%s (%s)";
+    }
+
+    unsigned curPortNum = 0;
+    for(unsigned i = 0; i < WindowsAudioInputDevice::numMixers; ++i) {
+        Mixer &mixer = WindowsAudioInputDevice::ourMixers[i];
+
+        if(WindowsAudioInputDevice::numMixers <= 1) {
+            mixerNameBuffer[0] = '\0';
+        }
+        else {
+            strncpy(mixerNameBuffer, mixer.name, sizeof mixerNameBuffer);
+#if 0
+      // Hack: Simplify the mixer name, by truncating after the first space character:
+      for (int k = 0; k < sizeof mixerNameBuffer && mixerNameBuffer[k] != '\0'; ++k) {
+	if (mixerNameBuffer[k] == ' ') {
+	  mixerNameBuffer[k] = '\0';
+	  break;
+	}
+      }
+#endif
+        }
+
+        for(unsigned j = 0; j < mixer.numPorts; ++j) {
+            sprintf(portNameBuffer, portNameFmt, mixer.ports[j].name, mixerNameBuffer);
+            portNames->portName[curPortNum++] = strDup(portNameBuffer);
+        }
+    }
+
+    return portNames;
+}
+
+////////// WindowsAudioInputDevice implementation //////////
+
+WindowsAudioInputDevice ::WindowsAudioInputDevice(UsageEnvironment &env, int inputPortNumber, unsigned char bitsPerSample, unsigned char numChannels,
+                                                  unsigned samplingFrequency, unsigned granularityInMS, Boolean &success)
+    : WindowsAudioInputDevice_common(env, inputPortNumber, bitsPerSample, numChannels, samplingFrequency, granularityInMS), fCurMixerId(-1) {
+    success = initialSetInputPort(inputPortNumber);
+}
+
+WindowsAudioInputDevice::~WindowsAudioInputDevice() {
+    if(fCurMixerId >= 0)
+        ourMixers[fCurMixerId].close();
+
+    delete[] ourMixers;
+    ourMixers = NULL;
+    numMixers = numInputPortsTotal = 0;
+}
+
+void WindowsAudioInputDevice::initializeIfNecessary() {
+    if(ourMixers != NULL)
+        return;  // we've already been initialized
+    numMixers = mixerGetNumDevs();
+    ourMixers = new Mixer[numMixers];
+
+    // Initialize each mixer:
+    numInputPortsTotal = 0;
+    for(unsigned i = 0; i < numMixers; ++i) {
+        Mixer &mixer = ourMixers[i];
+        mixer.index  = i;
+        mixer.open();
+        if(mixer.hMixer != NULL) {
+            // This device has a valid mixer.  Get information about its ports:
+            mixer.getPortsInfo();
+            mixer.close();
+
+            if(mixer.numPorts == 0)
+                continue;
+
+            numInputPortsTotal += mixer.numPorts;
+        }
+        else {
+            mixer.ports    = NULL;
+            mixer.numPorts = 0;
+        }
+    }
+}
+
+Boolean WindowsAudioInputDevice::setInputPort(int portIndex) {
+    initializeIfNecessary();
+
+    if(portIndex < 0 || portIndex >= (int)numInputPortsTotal) {  // bad index
+        envir().setResultMsg("Bad input port index\n");
+        return False;
+    }
+
+    // Find the mixer and port that corresponds to "portIndex":
+    int newMixerId, portWithinMixer, portIndexCount = 0;
+    for(newMixerId = 0; newMixerId < (int)numMixers; ++newMixerId) {
+        int prevPortIndexCount = portIndexCount;
+        portIndexCount += ourMixers[newMixerId].numPorts;
+        if(portIndexCount > portIndex) {  // it's with this mixer
+            portWithinMixer = portIndex - prevPortIndexCount;
+            break;
+        }
+    }
+
+    // Check that this mixer is allowed:
+    if(allowedDeviceNames != NULL) {
+        int i;
+        for(i = 0; allowedDeviceNames[i] != NULL; ++i) {
+            if(strncmp(ourMixers[newMixerId].name, allowedDeviceNames[i], strlen(allowedDeviceNames[i])) == 0) {
+                // The allowed device name is a prefix of this mixer's name
+                break;  // this mixer is allowed
+            }
+        }
+        if(allowedDeviceNames[i] == NULL) {  // this mixer is not on the allowed list
+            envir().setResultMsg("Access to this audio device is not allowed\n");
+            return False;
+        }
+    }
+
+    if(newMixerId != fCurMixerId) {
+        // The mixer has changed, so close the old one and open the new one:
+        if(fCurMixerId >= 0)
+            ourMixers[fCurMixerId].close();
+        fCurMixerId = newMixerId;
+        ourMixers[fCurMixerId].open(fNumChannels, fSamplingFrequency, fGranularityInMS);
+    }
+    if(portIndex != fCurPortIndex) {
+        // Change the input port:
+        fCurPortIndex = portIndex;
+        char const *errReason;
+        MMRESULT    errCode;
+        if(!ourMixers[newMixerId].enableInputPort(portWithinMixer, errReason, errCode)) {
+            char resultMsg[100];
+            sprintf(resultMsg, "Failed to enable input port: %s failed (0x%08x)\n", errReason, errCode);
+            envir().setResultMsg(resultMsg);
+            return False;
+        }
+        // Later, may also need to transfer 'gain' to new port #####
+    }
+    return True;
+}
+
+unsigned WindowsAudioInputDevice::numMixers = 0;
+
+Mixer *WindowsAudioInputDevice::ourMixers = NULL;
+
+unsigned WindowsAudioInputDevice::numInputPortsTotal = 0;
+
+////////// Mixer and AudioInputPort implementation //////////
+
+Mixer::Mixer() : hMixer(NULL), dwRecLineID(0), numPorts(0), ports(NULL) {}
+
+Mixer::~Mixer() {
+    delete[] ports;
+}
+
+void Mixer::open(unsigned numChannels, unsigned samplingFrequency, unsigned granularityInMS) {
+    HMIXER newHMixer = NULL;
+    do {
+        MIXERCAPS mc;
+        if(mixerGetDevCaps(index, &mc, sizeof mc) != MMSYSERR_NOERROR)
+            break;
+
+#ifdef UNICODE
+        // Copy the mixer name:
+        wcstombs(name, mc.szPname, MAXPNAMELEN);
+#else
+        strncpy(name, mc.szPname, MAXPNAMELEN);
+#endif
+
+        // Find the correct line for this mixer:
+        unsigned i, uWavIn;
+        unsigned nWavIn = waveInGetNumDevs();
+        for(i = 0; i < nWavIn; ++i) {
+            WAVEINCAPS wic;
+            if(waveInGetDevCaps(i, &wic, sizeof wic) != MMSYSERR_NOERROR)
+                continue;
+
+            MIXERLINE ml;
+            ml.cbStruct      = sizeof ml;
+            ml.Target.dwType = MIXERLINE_TARGETTYPE_WAVEIN;
+
+#ifdef UNICODE
+            wcsncpy(ml.Target.szPname, wic.szPname, MAXPNAMELEN);
+#else
+            strncpy(ml.Target.szPname, wic.szPname, MAXPNAMELEN);
+#endif
+
+            ml.Target.vDriverVersion = wic.vDriverVersion;
+            ml.Target.wMid           = wic.wMid;
+            ml.Target.wPid           = wic.wPid;
+
+            if(mixerGetLineInfo((HMIXEROBJ)index, &ml, MIXER_GETLINEINFOF_TARGETTYPE /*|MIXER_OBJECTF_MIXER*/) == MMSYSERR_NOERROR) {
+                // this is the right line
+                uWavIn      = i;
+                dwRecLineID = ml.dwLineID;
+                break;
+            }
+        }
+        if(i >= nWavIn)
+            break;  // error: we couldn't find the right line
+
+        if(mixerOpen(&newHMixer, index, (unsigned long)NULL, (unsigned long)NULL, MIXER_OBJECTF_MIXER) != MMSYSERR_NOERROR)
+            break;
+        if(newHMixer == NULL)
+            break;
+
+        // Sanity check: re-call "mixerGetDevCaps()" using the mixer device handle:
+        if(mixerGetDevCaps((UINT)newHMixer, &mc, sizeof mc) != MMSYSERR_NOERROR)
+            break;
+        if(mc.cDestinations < 1)
+            break;  // error: this mixer has no destinations
+
+        if(!WindowsAudioInputDevice_common::openWavInPort(uWavIn, numChannels, samplingFrequency, granularityInMS))
+            break;
+
+        hMixer = newHMixer;
+        return;
+    } while(0);
+
+    // An error occurred:
+    close();
+}
+
+void Mixer::open() {
+    open(1, 8000, 20);
+}
+
+void Mixer::getPortsInfo() {
+    MIXERCAPS mc;
+    mixerGetDevCaps((UINT)hMixer, &mc, sizeof mc);
+
+    MIXERLINE mlt;
+    unsigned  i;
+    for(i = 0; i < mc.cDestinations; ++i) {
+        memset(&mlt, 0, sizeof mlt);
+        mlt.cbStruct      = sizeof mlt;
+        mlt.dwDestination = i;
+        if(mixerGetLineInfo((HMIXEROBJ)hMixer, &mlt, MIXER_GETLINEINFOF_DESTINATION) != MMSYSERR_NOERROR)
+            continue;
+        if(mlt.dwLineID == dwRecLineID)
+            break;  // this is the destination we're interested in
+    }
+    ports = new AudioInputPort[mlt.cConnections];
+
+    numPorts = mlt.cConnections;
+    for(i = 0; i < numPorts; ++i) {
+        MIXERLINE mlc;
+        memcpy(&mlc, &mlt, sizeof mlc);
+        mlc.dwSource = i;
+        mixerGetLineInfo((HMIXEROBJ)hMixer, &mlc, MIXER_GETLINEINFOF_SOURCE /*|MIXER_OBJECTF_HMIXER*/);
+        ports[i].tag             = mlc.dwLineID;
+        ports[i].dwComponentType = mlc.dwComponentType;
+#ifdef UNICODE
+        wcstombs(ports[i].name, mlc.szName, MIXER_LONG_NAME_CHARS);
+#else
+        strncpy(ports[i].name, mlc.szName, MIXER_LONG_NAME_CHARS);
+#endif
+    }
+
+    // Make the microphone the first port in the list:
+    for(i = 1; i < numPorts; ++i) {
+#ifdef OLD_MICROPHONE_TESTING_CODE
+        if(_strnicmp("mic", ports[i].name, 3) == 0 || _strnicmp("mik", ports[i].name, 3) == 0) {
+#else
+        if(ports[i].dwComponentType == MIXERLINE_COMPONENTTYPE_SRC_MICROPHONE) {
+#endif
+            AudioInputPort tmp = ports[0];
+            ports[0]           = ports[i];
+            ports[i]           = tmp;
+        }
+    }
+}
+
+Boolean Mixer::enableInputPort(unsigned portIndex, char const *&errReason, MMRESULT &errCode) {
+    errReason            = NULL;  // unless there's an error
+    AudioInputPort &port = ports[portIndex];
+
+    MIXERCONTROL mc;
+    mc.cMultipleItems = 1;  // in case it doesn't get set below
+    MIXERLINECONTROLS mlc;
+#if 0  // the following doesn't seem to be needed, and can fail:
+  mlc.cbStruct = sizeof mlc;
+  mlc.pamxctrl = &mc;
+  mlc.cbmxctrl = sizeof (MIXERCONTROL);
+  mlc.dwLineID = port.tag;
+  mlc.dwControlType = MIXERCONTROL_CONTROLTYPE_VOLUME;
+  if ((errCode = mixerGetLineControls((HMIXEROBJ)hMixer, &mlc, MIXER_GETLINECONTROLSF_ONEBYTYPE/*|MIXER_OBJECTF_HMIXER*/)) != MMSYSERR_NOERROR) {
+    errReason = "mixerGetLineControls()";
+    return False;
+  }
+#endif
+
+    MIXERLINE ml;
+    memset(&ml, 0, sizeof(MIXERLINE));
+    ml.cbStruct = sizeof(MIXERLINE);
+    ml.dwLineID = port.tag;
+    if((errCode = mixerGetLineInfo((HMIXEROBJ)hMixer, &ml, MIXER_GETLINEINFOF_LINEID)) != MMSYSERR_NOERROR) {
+        errReason = "mixerGetLineInfo()1";
+        return False;
+    }
+
+#ifdef UNICODE
+    wchar_t portname[MIXER_LONG_NAME_CHARS + 1];
+    wcsncpy(portname, ml.szName, MIXER_LONG_NAME_CHARS);
+#else
+    char portname[MIXER_LONG_NAME_CHARS + 1];
+    strncpy(portname, ml.szName, MIXER_LONG_NAME_CHARS);
+#endif
+
+    memset(&ml, 0, sizeof(MIXERLINE));
+    ml.cbStruct = sizeof(MIXERLINE);
+    ml.dwLineID = dwRecLineID;
+    if((errCode = mixerGetLineInfo((HMIXEROBJ)hMixer, &ml, MIXER_GETLINEINFOF_LINEID /*|MIXER_OBJECTF_HMIXER*/)) != MMSYSERR_NOERROR) {
+        errReason = "mixerGetLineInfo()2";
+        return False;
+    }
+
+    // Get Mixer/MUX control information (need control id to set and get control details)
+    mlc.cbStruct      = sizeof mlc;
+    mlc.dwLineID      = ml.dwLineID;
+    mlc.cControls     = 1;
+    mc.cbStruct       = sizeof mc;   // Needed???#####
+    mc.dwControlID    = 0xDEADBEEF;  // For testing #####
+    mlc.pamxctrl      = &mc;
+    mlc.cbmxctrl      = sizeof mc;
+    mlc.dwControlType = MIXERCONTROL_CONTROLTYPE_MUX;  // Single Select
+    if((errCode = mixerGetLineControls((HMIXEROBJ)hMixer, &mlc, MIXER_GETLINECONTROLSF_ONEBYTYPE /*|MIXER_OBJECTF_HMIXER*/)) != MMSYSERR_NOERROR) {
+        mlc.dwControlType = MIXERCONTROL_CONTROLTYPE_MIXER;  // Multiple Select
+        mixerGetLineControls((HMIXEROBJ)hMixer, &mlc, MIXER_GETLINECONTROLSF_ONEBYTYPE /*|MIXER_OBJECTF_HMIXER*/);
+    }
+
+    unsigned matchLine = 0;
+    if(mc.cMultipleItems > 1) {
+        // Before getting control, we need to know which line to grab.
+        // We figure this out by listing the lines, and comparing names:
+        MIXERCONTROLDETAILS mcd;
+        mcd.cbStruct                           = sizeof mcd;
+        mcd.cChannels                          = ml.cChannels;
+        mcd.cMultipleItems                     = mc.cMultipleItems;
+        MIXERCONTROLDETAILS_LISTTEXT *mcdlText = new MIXERCONTROLDETAILS_LISTTEXT[mc.cMultipleItems];
+        mcd.cbDetails                          = sizeof(MIXERCONTROLDETAILS_LISTTEXT);
+        mcd.paDetails                          = mcdlText;
+
+        if(mc.dwControlID != 0xDEADBEEF) {  // we know the control id for real
+            mcd.dwControlID = mc.dwControlID;
+            if((errCode = mixerGetControlDetails((HMIXEROBJ)hMixer, &mcd, MIXER_GETCONTROLDETAILSF_LISTTEXT /*|MIXER_OBJECTF_HMIXER*/)) != MMSYSERR_NOERROR) {
+                delete[] mcdlText;
+                errReason = "mixerGetControlDetails()1";
+                return False;
+            }
+        }
+        else {
+            // Hack: We couldn't find a MUX or MIXER control, so try to guess the control id:
+            for(mc.dwControlID = 0; mc.dwControlID < 32; ++mc.dwControlID) {
+                mcd.dwControlID = mc.dwControlID;
+                if((errCode = mixerGetControlDetails((HMIXEROBJ)hMixer, &mcd, MIXER_GETCONTROLDETAILSF_LISTTEXT /*|MIXER_OBJECTF_HMIXER*/)) == MMSYSERR_NOERROR)
+                    break;
+            }
+            if(mc.dwControlID == 32) {  // unable to guess mux/mixer control id
+                delete[] mcdlText;
+                errReason = "mixerGetControlDetails()2";
+                return False;
+            }
+        }
+
+#ifdef UNICODE
+        for(unsigned i = 0; i < mcd.cMultipleItems; ++i) {
+            if(wcscmp(mcdlText[i].szName, portname) == 0) {
+                matchLine = i;
+                break;
+            }
+        }
+#else
+        for(unsigned i = 0; i < mcd.cMultipleItems; ++i) {
+            if(strcmp(mcdlText[i].szName, portname) == 0) {
+                matchLine = i;
+                break;
+            }
+        }
+#endif
+
+        delete[] mcdlText;
+    }
+
+    // Now get control itself:
+    MIXERCONTROLDETAILS mcd;
+    mcd.cbStruct                           = sizeof mcd;
+    mcd.dwControlID                        = mc.dwControlID;
+    mcd.cChannels                          = ml.cChannels;
+    mcd.cMultipleItems                     = mc.cMultipleItems;
+    MIXERCONTROLDETAILS_BOOLEAN *mcdbState = new MIXERCONTROLDETAILS_BOOLEAN[mc.cMultipleItems];
+    mcd.paDetails                          = mcdbState;
+    mcd.cbDetails                          = sizeof(MIXERCONTROLDETAILS_BOOLEAN);
+
+    if((errCode = mixerGetControlDetails((HMIXEROBJ)hMixer, &mcd, MIXER_GETCONTROLDETAILSF_VALUE /*|MIXER_OBJECTF_HMIXER*/)) != MMSYSERR_NOERROR) {
+        delete[] mcdbState;
+        errReason = "mixerGetControlDetails()3";
+        return False;
+    }
+
+    for(unsigned j = 0; j < mcd.cMultipleItems; ++j) {
+        mcdbState[j].fValue = (j == matchLine);
+    }
+
+    if((errCode = mixerSetControlDetails((HMIXEROBJ)hMixer, &mcd, MIXER_OBJECTF_HMIXER)) != MMSYSERR_NOERROR) {
+        delete[] mcdbState;
+        errReason = "mixerSetControlDetails()";
+        return False;
+    }
+    delete[] mcdbState;
+
+    return True;
+}
+
+void Mixer::close() {
+    WindowsAudioInputDevice_common::waveIn_close();
+    if(hMixer != NULL)
+        mixerClose(hMixer);
+    hMixer      = NULL;
+    dwRecLineID = 0;
+}
diff --git a/3rdparty/live555/src/WindowsAudioInputDevice/WindowsAudioInputDevice_mixer.hh b/3rdparty/live555/src/WindowsAudioInputDevice/WindowsAudioInputDevice_mixer.hh
new file mode 100644
index 00000000..bed736ab
--- /dev/null
+++ b/3rdparty/live555/src/WindowsAudioInputDevice/WindowsAudioInputDevice_mixer.hh
@@ -0,0 +1,57 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// Windows implementation of a generic audio input device
+// This version uses Windows' built-in software mixer.
+// C++ header
+//
+// To use this, call "AudioInputDevice::createNew()".
+// You can also call "AudioInputDevice::getPortNames()" to get a list
+// of port names.
+
+#ifndef _WINDOWS_AUDIO_INPUT_DEVICE_MIXER_HH
+#define _WINDOWS_AUDIO_INPUT_DEVICE_MIXER_HH
+
+#ifndef _WINDOWS_AUDIO_INPUT_DEVICE_COMMON_HH
+#include "WindowsAudioInputDevice_common.hh"
+#endif
+
+class WindowsAudioInputDevice: public WindowsAudioInputDevice_common {
+private:
+  friend class AudioInputDevice;
+  WindowsAudioInputDevice(UsageEnvironment& env, int inputPortNumber,
+	unsigned char bitsPerSample, unsigned char numChannels,
+	unsigned samplingFrequency, unsigned granularityInMS,
+	Boolean& success);
+	// called only by createNew()
+
+  virtual ~WindowsAudioInputDevice();
+
+  static void initializeIfNecessary();
+
+private:
+  // redefined virtual functions:
+  virtual Boolean setInputPort(int portIndex);
+
+private:
+  static unsigned numMixers;
+  static class Mixer* ourMixers;
+  static unsigned numInputPortsTotal;
+
+  int fCurMixerId;
+};
+
+#endif
diff --git a/3rdparty/live555/src/WindowsAudioInputDevice/WindowsAudioInputDevice_noMixer.cpp b/3rdparty/live555/src/WindowsAudioInputDevice/WindowsAudioInputDevice_noMixer.cpp
new file mode 100644
index 00000000..d77d11cd
--- /dev/null
+++ b/3rdparty/live555/src/WindowsAudioInputDevice/WindowsAudioInputDevice_noMixer.cpp
@@ -0,0 +1,172 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// Copyright (c) 2001-2004 Live Networks, Inc.  All rights reserved.
+// Windows implementation of a generic audio input device
+// This version does not use Windows' built-in software mixer.
+// Implementation
+
+#include <WindowsAudioInputDevice_noMixer.hh>
+
+////////// AudioInputPort definition //////////
+
+class AudioInputPort {
+public:
+    void open(unsigned numChannels, unsigned samplingFrequency, unsigned granularityInMS);
+    void open();  // open with default parameters
+    void close();
+
+public:
+    int  index;
+    char name[MAXPNAMELEN];
+};
+
+////////// AudioInputDevice (remaining) implementation //////////
+
+AudioInputDevice *AudioInputDevice::createNew(UsageEnvironment &env, int inputPortNumber, unsigned char bitsPerSample, unsigned char numChannels,
+                                              unsigned samplingFrequency, unsigned granularityInMS) {
+    Boolean                  success;
+    WindowsAudioInputDevice *newSource =
+        new WindowsAudioInputDevice(env, inputPortNumber, bitsPerSample, numChannels, samplingFrequency, granularityInMS, success);
+    if(!success) {
+        delete newSource;
+        newSource = NULL;
+    }
+
+    return newSource;
+}
+
+AudioPortNames *AudioInputDevice::getPortNames() {
+    WindowsAudioInputDevice::initializeIfNecessary();
+
+    AudioPortNames *portNames = new AudioPortNames;
+    portNames->numPorts       = WindowsAudioInputDevice::numAudioInputPorts;
+    portNames->portName       = new char *[WindowsAudioInputDevice::numAudioInputPorts];
+
+    for(unsigned i = 0; i < WindowsAudioInputDevice::numAudioInputPorts; ++i) {
+        AudioInputPort &audioInputPort = WindowsAudioInputDevice::ourAudioInputPorts[i];
+
+        portNames->portName[i] = strDup(audioInputPort.name);
+    }
+
+    return portNames;
+}
+
+////////// WindowsAudioInputDevice implementation //////////
+
+WindowsAudioInputDevice ::WindowsAudioInputDevice(UsageEnvironment &env, int inputPortNumber, unsigned char bitsPerSample, unsigned char numChannels,
+                                                  unsigned samplingFrequency, unsigned granularityInMS, Boolean &success)
+    : WindowsAudioInputDevice_common(env, inputPortNumber, bitsPerSample, numChannels, samplingFrequency, granularityInMS) {
+    success = initialSetInputPort(inputPortNumber);
+}
+
+WindowsAudioInputDevice::~WindowsAudioInputDevice() {
+    if(fCurPortIndex >= 0)
+        ourAudioInputPorts[fCurPortIndex].close();
+
+    delete[] ourAudioInputPorts;
+    ourAudioInputPorts = NULL;
+    numAudioInputPorts = 0;
+}
+
+void WindowsAudioInputDevice::initializeIfNecessary() {
+    if(ourAudioInputPorts != NULL)
+        return;  // we've already been initialized
+    numAudioInputPorts = waveInGetNumDevs();
+    ourAudioInputPorts = new AudioInputPort[numAudioInputPorts];
+
+    // Initialize each audio input port
+    for(unsigned i = 0; i < numAudioInputPorts; ++i) {
+        AudioInputPort &port = ourAudioInputPorts[i];
+        port.index           = i;
+        port.open();  // to set the port name
+        port.close();
+    }
+}
+
+Boolean WindowsAudioInputDevice::setInputPort(int portIndex) {
+    initializeIfNecessary();
+
+    if(portIndex < 0 || portIndex >= (int)numAudioInputPorts) {  // bad index
+        envir().setResultMsg("Bad input port index\n");
+        return False;
+    }
+
+    // Check that this port is allowed:
+    if(allowedDeviceNames != NULL) {
+        int i;
+        for(i = 0; allowedDeviceNames[i] != NULL; ++i) {
+            if(strncmp(ourAudioInputPorts[portIndex].name, allowedDeviceNames[i], strlen(allowedDeviceNames[i])) == 0) {
+                // The allowed device name is a prefix of this port's name
+                break;  // this port is allowed
+            }
+        }
+        if(allowedDeviceNames[i] == NULL) {  // this port is not on the allowed list
+            envir().setResultMsg("Access to this audio device is not allowed\n");
+            return False;
+        }
+    }
+
+    if(portIndex != fCurPortIndex) {
+        // The port has changed, so close the old one and open the new one:
+        if(fCurPortIndex >= 0)
+            ourAudioInputPorts[fCurPortIndex].close();
+        ;
+        fCurPortIndex = portIndex;
+        ourAudioInputPorts[fCurPortIndex].open(fNumChannels, fSamplingFrequency, fGranularityInMS);
+    }
+    fCurPortIndex = portIndex;
+    return True;
+}
+
+unsigned WindowsAudioInputDevice::numAudioInputPorts = 0;
+
+AudioInputPort *WindowsAudioInputDevice::ourAudioInputPorts = NULL;
+
+////////// AudioInputPort implementation //////////
+
+void AudioInputPort::open(unsigned numChannels, unsigned samplingFrequency, unsigned granularityInMS) {
+    do {
+        // Get the port name:
+        WAVEINCAPS wic;
+        if(waveInGetDevCaps(index, &wic, sizeof wic) != MMSYSERR_NOERROR) {
+            name[0] = '\0';
+            break;
+        }
+
+#ifdef UNICODE
+        // Copy the mixer name:
+        wcstombs(name, wic.szPname, MAXPNAMELEN);
+#else
+        strncpy(name, wic.szPname, MAXPNAMELEN);
+#endif
+
+        if(!WindowsAudioInputDevice_common::openWavInPort(index, numChannels, samplingFrequency, granularityInMS))
+            break;
+
+        return;
+    } while(0);
+
+    // An error occurred:
+    close();
+}
+
+void AudioInputPort::open() {
+    open(1, 8000, 20);
+}
+
+void AudioInputPort::close() {
+    WindowsAudioInputDevice_common::waveIn_close();
+}
diff --git a/3rdparty/live555/src/WindowsAudioInputDevice/WindowsAudioInputDevice_noMixer.hh b/3rdparty/live555/src/WindowsAudioInputDevice/WindowsAudioInputDevice_noMixer.hh
new file mode 100644
index 00000000..62847416
--- /dev/null
+++ b/3rdparty/live555/src/WindowsAudioInputDevice/WindowsAudioInputDevice_noMixer.hh
@@ -0,0 +1,54 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// Windows implementation of a generic audio input device
+// This version does not use Windows' built-in software mixer.
+// C++ header
+//
+// To use this, call "AudioInputDevice::createNew()".
+// You can also call "AudioInputDevice::getPortNames()" to get a list
+// of port names.
+
+#ifndef _WINDOWS_AUDIO_INPUT_DEVICE_NOMIXER_HH
+#define _WINDOWS_AUDIO_INPUT_DEVICE_NOMIXER_HH
+
+#ifndef _WINDOWS_AUDIO_INPUT_DEVICE_COMMON_HH
+#include "WindowsAudioInputDevice_common.hh"
+#endif
+
+class WindowsAudioInputDevice: public WindowsAudioInputDevice_common {
+private:
+  friend class AudioInputDevice;
+  WindowsAudioInputDevice(UsageEnvironment& env, int inputPortNumber,
+	unsigned char bitsPerSample, unsigned char numChannels,
+	unsigned samplingFrequency, unsigned granularityInMS,
+	Boolean& success);
+	// called only by createNew()
+
+  virtual ~WindowsAudioInputDevice();
+
+  static void initializeIfNecessary();
+
+private:
+  // redefined virtual functions:
+  virtual Boolean setInputPort(int portIndex);
+
+private:
+  static unsigned numAudioInputPorts;
+  static class AudioInputPort* ourAudioInputPorts;
+};
+
+#endif
diff --git a/3rdparty/live555/src/WindowsAudioInputDevice/showAudioInputPorts.cpp b/3rdparty/live555/src/WindowsAudioInputDevice/showAudioInputPorts.cpp
new file mode 100644
index 00000000..8744d86a
--- /dev/null
+++ b/3rdparty/live555/src/WindowsAudioInputDevice/showAudioInputPorts.cpp
@@ -0,0 +1,35 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// Copyright (c) 1996-2022, Live Networks, Inc.  All rights reserved
+// A program that prints out this computer's audio input ports
+
+#include "AudioInputDevice.hh"
+#include <stdio.h>
+
+int main(int argc, char **argv) {
+    AudioPortNames *portNames = AudioInputDevice::getPortNames();
+    if(portNames == NULL) {
+        fprintf(stderr, "AudioInputDevice::getPortNames() failed!\n");
+        exit(1);
+    }
+
+    printf("%d available audio input ports:\n", portNames->numPorts);
+    for(unsigned i = 0; i < portNames->numPorts; ++i) {
+        printf("%d\t%s\n", i, portNames->portName[i]);
+    }
+
+    return 0;
+}
diff --git a/3rdparty/live555/src/android_ifaddrs_addition/README.md b/3rdparty/live555/src/android_ifaddrs_addition/README.md
new file mode 100644
index 00000000..dc05bdfd
--- /dev/null
+++ b/3rdparty/live555/src/android_ifaddrs_addition/README.md
@@ -0,0 +1,6 @@
+android-ifaddrs
+===============
+
+An implementation of getifaddrs() for Android, since the NDK does not natively support it.
+
+Works just like you would expect on regular Linux. License information is present in each file (BSD license).
diff --git a/3rdparty/live555/src/android_ifaddrs_addition/ifaddrs_add.c b/3rdparty/live555/src/android_ifaddrs_addition/ifaddrs_add.c
new file mode 100644
index 00000000..825c7c41
--- /dev/null
+++ b/3rdparty/live555/src/android_ifaddrs_addition/ifaddrs_add.c
@@ -0,0 +1,521 @@
+/*
+Copyright (c) 2013, Kenneth MacKay
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+ * Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+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 "ifaddrs_add.h"
+
+#if __ANDROID_API__ < 24
+#include <string.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <unistd.h>
+#include <sys/socket.h>
+#include <net/if_arp.h>
+#include <netinet/in.h>
+#include <linux/netlink.h>
+#include <linux/rtnetlink.h>
+
+typedef struct NetlinkList {
+    struct NetlinkList *m_next;
+    struct nlmsghdr *   m_data;
+    unsigned int        m_size;
+} NetlinkList;
+
+static int netlink_socket(void) {
+    int l_socket = socket(PF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
+    if(l_socket < 0) {
+        return -1;
+    }
+
+    struct sockaddr_nl l_addr;
+    memset(&l_addr, 0, sizeof(l_addr));
+    l_addr.nl_family = AF_NETLINK;
+    if(bind(l_socket, (struct sockaddr *)&l_addr, sizeof(l_addr)) < 0) {
+        close(l_socket);
+        return -1;
+    }
+
+    return l_socket;
+}
+
+static int netlink_send(int p_socket, int p_request) {
+    char l_buffer[NLMSG_ALIGN(sizeof(struct nlmsghdr)) + NLMSG_ALIGN(sizeof(struct rtgenmsg))];
+    memset(l_buffer, 0, sizeof(l_buffer));
+    struct nlmsghdr *l_hdr = (struct nlmsghdr *)l_buffer;
+    struct rtgenmsg *l_msg = (struct rtgenmsg *)NLMSG_DATA(l_hdr);
+
+    l_hdr->nlmsg_len    = NLMSG_LENGTH(sizeof(*l_msg));
+    l_hdr->nlmsg_type   = p_request;
+    l_hdr->nlmsg_flags  = NLM_F_ROOT | NLM_F_MATCH | NLM_F_REQUEST;
+    l_hdr->nlmsg_pid    = 0;
+    l_hdr->nlmsg_seq    = p_socket;
+    l_msg->rtgen_family = AF_UNSPEC;
+
+    struct sockaddr_nl l_addr;
+    memset(&l_addr, 0, sizeof(l_addr));
+    l_addr.nl_family = AF_NETLINK;
+    return (sendto(p_socket, l_hdr, l_hdr->nlmsg_len, 0, (struct sockaddr *)&l_addr, sizeof(l_addr)));
+}
+
+static int netlink_recv(int p_socket, void *p_buffer, size_t p_len) {
+    struct msghdr      l_msg;
+    struct iovec       l_iov = { p_buffer, p_len };
+    struct sockaddr_nl l_addr;
+    int                l_result;
+
+    for(;;) {
+        l_msg.msg_name       = (void *)&l_addr;
+        l_msg.msg_namelen    = sizeof(l_addr);
+        l_msg.msg_iov        = &l_iov;
+        l_msg.msg_iovlen     = 1;
+        l_msg.msg_control    = NULL;
+        l_msg.msg_controllen = 0;
+        l_msg.msg_flags      = 0;
+        int l_result         = recvmsg(p_socket, &l_msg, 0);
+
+        if(l_result < 0) {
+            if(errno == EINTR) {
+                continue;
+            }
+            return -2;
+        }
+
+        if(l_msg.msg_flags & MSG_TRUNC) {  // buffer was too small
+            return -1;
+        }
+        return l_result;
+    }
+}
+
+static struct nlmsghdr *getNetlinkResponse(int p_socket, int *p_size, int *p_done) {
+    size_t l_size   = 4096;
+    void * l_buffer = NULL;
+
+    for(;;) {
+        free(l_buffer);
+        l_buffer = malloc(l_size);
+
+        int l_read = netlink_recv(p_socket, l_buffer, l_size);
+        *p_size    = l_read;
+        if(l_read == -2) {
+            free(l_buffer);
+            return NULL;
+        }
+        if(l_read >= 0) {
+            pid_t            l_pid = getpid();
+            struct nlmsghdr *l_hdr;
+            for(l_hdr = (struct nlmsghdr *)l_buffer; NLMSG_OK(l_hdr, (unsigned int)l_read); l_hdr = (struct nlmsghdr *)NLMSG_NEXT(l_hdr, l_read)) {
+                if((pid_t)l_hdr->nlmsg_pid != l_pid || (int)l_hdr->nlmsg_seq != p_socket) {
+                    continue;
+                }
+
+                if(l_hdr->nlmsg_type == NLMSG_DONE) {
+                    *p_done = 1;
+                    break;
+                }
+
+                if(l_hdr->nlmsg_type == NLMSG_ERROR) {
+                    free(l_buffer);
+                    return NULL;
+                }
+            }
+            return l_buffer;
+        }
+
+        l_size *= 2;
+    }
+}
+
+static NetlinkList *newListItem(struct nlmsghdr *p_data, unsigned int p_size) {
+    NetlinkList *l_item = malloc(sizeof(NetlinkList));
+    l_item->m_next      = NULL;
+    l_item->m_data      = p_data;
+    l_item->m_size      = p_size;
+    return l_item;
+}
+
+static void freeResultList(NetlinkList *p_list) {
+    NetlinkList *l_cur;
+    while(p_list) {
+        l_cur  = p_list;
+        p_list = p_list->m_next;
+        free(l_cur->m_data);
+        free(l_cur);
+    }
+}
+
+static NetlinkList *getResultList(int p_socket, int p_request) {
+    if(netlink_send(p_socket, p_request) < 0) {
+        return NULL;
+    }
+
+    NetlinkList *l_list = NULL;
+    NetlinkList *l_end  = NULL;
+    int          l_size;
+    int          l_done = 0;
+    while(!l_done) {
+        struct nlmsghdr *l_hdr = getNetlinkResponse(p_socket, &l_size, &l_done);
+        if(!l_hdr) {  // error
+            freeResultList(l_list);
+            return NULL;
+        }
+
+        NetlinkList *l_item = newListItem(l_hdr, l_size);
+        if(!l_list) {
+            l_list = l_item;
+        }
+        else {
+            l_end->m_next = l_item;
+        }
+        l_end = l_item;
+    }
+    return l_list;
+}
+
+static size_t maxSize(size_t a, size_t b) {
+    return (a > b ? a : b);
+}
+
+static size_t calcAddrLen(sa_family_t p_family, int p_dataSize) {
+    switch(p_family) {
+    case AF_INET:
+        return sizeof(struct sockaddr_in);
+    case AF_INET6:
+        return sizeof(struct sockaddr_in6);
+    case AF_PACKET:
+        return maxSize(sizeof(struct sockaddr_ll), offsetof(struct sockaddr_ll, sll_addr) + p_dataSize);
+    default:
+        return maxSize(sizeof(struct sockaddr), offsetof(struct sockaddr, sa_data) + p_dataSize);
+    }
+}
+
+static void makeSockaddr(sa_family_t p_family, struct sockaddr *p_dest, void *p_data, size_t p_size) {
+    switch(p_family) {
+    case AF_INET:
+        memcpy(&((struct sockaddr_in *)p_dest)->sin_addr, p_data, p_size);
+        break;
+    case AF_INET6:
+        memcpy(&((struct sockaddr_in6 *)p_dest)->sin6_addr, p_data, p_size);
+        break;
+    case AF_PACKET:
+        memcpy(((struct sockaddr_ll *)p_dest)->sll_addr, p_data, p_size);
+        ((struct sockaddr_ll *)p_dest)->sll_halen = p_size;
+        break;
+    default:
+        memcpy(p_dest->sa_data, p_data, p_size);
+        break;
+    }
+    p_dest->sa_family = p_family;
+}
+
+static void addToEnd(struct ifaddrs **p_resultList, struct ifaddrs *p_entry) {
+    if(!*p_resultList) {
+        *p_resultList = p_entry;
+    }
+    else {
+        struct ifaddrs *l_cur = *p_resultList;
+        while(l_cur->ifa_next) {
+            l_cur = l_cur->ifa_next;
+        }
+        l_cur->ifa_next = p_entry;
+    }
+}
+
+static void interpretLink(struct nlmsghdr *p_hdr, struct ifaddrs **p_links, struct ifaddrs **p_resultList) {
+    struct ifinfomsg *l_info = (struct ifinfomsg *)NLMSG_DATA(p_hdr);
+
+    size_t l_nameSize = 0;
+    size_t l_addrSize = 0;
+    size_t l_dataSize = 0;
+
+    size_t         l_rtaSize = NLMSG_PAYLOAD(p_hdr, sizeof(struct ifinfomsg));
+    struct rtattr *l_rta;
+    for(l_rta = (struct rtattr *)(((char *)l_info) + NLMSG_ALIGN(sizeof(struct ifinfomsg))); RTA_OK(l_rta, l_rtaSize); l_rta = RTA_NEXT(l_rta, l_rtaSize)) {
+        void * l_rtaData     = RTA_DATA(l_rta);
+        size_t l_rtaDataSize = RTA_PAYLOAD(l_rta);
+        switch(l_rta->rta_type) {
+        case IFLA_ADDRESS:
+        case IFLA_BROADCAST:
+            l_addrSize += NLMSG_ALIGN(calcAddrLen(AF_PACKET, l_rtaDataSize));
+            break;
+        case IFLA_IFNAME:
+            l_nameSize += NLMSG_ALIGN(l_rtaSize + 1);
+            break;
+        case IFLA_STATS:
+            l_dataSize += NLMSG_ALIGN(l_rtaSize);
+            break;
+        default:
+            break;
+        }
+    }
+
+    struct ifaddrs *l_entry = malloc(sizeof(struct ifaddrs) + l_nameSize + l_addrSize + l_dataSize);
+    memset(l_entry, 0, sizeof(struct ifaddrs));
+    l_entry->ifa_name = "";
+
+    char *l_name = ((char *)l_entry) + sizeof(struct ifaddrs);
+    char *l_addr = l_name + l_nameSize;
+    char *l_data = l_addr + l_addrSize;
+
+    l_entry->ifa_flags = l_info->ifi_flags;
+
+    l_rtaSize = NLMSG_PAYLOAD(p_hdr, sizeof(struct ifinfomsg));
+    for(l_rta = (struct rtattr *)(((char *)l_info) + NLMSG_ALIGN(sizeof(struct ifinfomsg))); RTA_OK(l_rta, l_rtaSize); l_rta = RTA_NEXT(l_rta, l_rtaSize)) {
+        void * l_rtaData     = RTA_DATA(l_rta);
+        size_t l_rtaDataSize = RTA_PAYLOAD(l_rta);
+        switch(l_rta->rta_type) {
+        case IFLA_ADDRESS:
+        case IFLA_BROADCAST: {
+            size_t l_addrLen = calcAddrLen(AF_PACKET, l_rtaDataSize);
+            makeSockaddr(AF_PACKET, (struct sockaddr *)l_addr, l_rtaData, l_rtaDataSize);
+            ((struct sockaddr_ll *)l_addr)->sll_ifindex = l_info->ifi_index;
+            ((struct sockaddr_ll *)l_addr)->sll_hatype  = l_info->ifi_type;
+            if(l_rta->rta_type == IFLA_ADDRESS) {
+                l_entry->ifa_addr = (struct sockaddr *)l_addr;
+            }
+            else {
+                l_entry->ifa_broadaddr = (struct sockaddr *)l_addr;
+            }
+            l_addr += NLMSG_ALIGN(l_addrLen);
+            break;
+        }
+        case IFLA_IFNAME:
+            strncpy(l_name, l_rtaData, l_rtaDataSize);
+            l_name[l_rtaDataSize] = '\0';
+            l_entry->ifa_name     = l_name;
+            break;
+        case IFLA_STATS:
+            memcpy(l_data, l_rtaData, l_rtaDataSize);
+            l_entry->ifa_data = l_data;
+            break;
+        default:
+            break;
+        }
+    }
+
+    addToEnd(p_resultList, l_entry);
+    p_links[l_info->ifi_index - 1] = l_entry;
+}
+
+static void interpretAddr(struct nlmsghdr *p_hdr, struct ifaddrs **p_links, struct ifaddrs **p_resultList) {
+    struct ifaddrmsg *l_info = (struct ifaddrmsg *)NLMSG_DATA(p_hdr);
+
+    size_t l_nameSize = 0;
+    size_t l_addrSize = 0;
+
+    int l_addedNetmask = 0;
+
+    size_t         l_rtaSize = NLMSG_PAYLOAD(p_hdr, sizeof(struct ifaddrmsg));
+    struct rtattr *l_rta;
+    for(l_rta = (struct rtattr *)(((char *)l_info) + NLMSG_ALIGN(sizeof(struct ifaddrmsg))); RTA_OK(l_rta, l_rtaSize); l_rta = RTA_NEXT(l_rta, l_rtaSize)) {
+        void * l_rtaData     = RTA_DATA(l_rta);
+        size_t l_rtaDataSize = RTA_PAYLOAD(l_rta);
+        if(l_info->ifa_family == AF_PACKET) {
+            continue;
+        }
+
+        switch(l_rta->rta_type) {
+        case IFA_ADDRESS:
+        case IFA_LOCAL:
+            if((l_info->ifa_family == AF_INET || l_info->ifa_family == AF_INET6) && !l_addedNetmask) {  // make room for netmask
+                l_addrSize += NLMSG_ALIGN(calcAddrLen(l_info->ifa_family, l_rtaDataSize));
+                l_addedNetmask = 1;
+            }
+        case IFA_BROADCAST:
+            l_addrSize += NLMSG_ALIGN(calcAddrLen(l_info->ifa_family, l_rtaDataSize));
+            break;
+        case IFA_LABEL:
+            l_nameSize += NLMSG_ALIGN(l_rtaSize + 1);
+            break;
+        default:
+            break;
+        }
+    }
+
+    struct ifaddrs *l_entry = malloc(sizeof(struct ifaddrs) + l_nameSize + l_addrSize);
+    memset(l_entry, 0, sizeof(struct ifaddrs));
+    l_entry->ifa_name = p_links[l_info->ifa_index - 1]->ifa_name;
+
+    char *l_name = ((char *)l_entry) + sizeof(struct ifaddrs);
+    char *l_addr = l_name + l_nameSize;
+
+    l_entry->ifa_flags = l_info->ifa_flags | p_links[l_info->ifa_index - 1]->ifa_flags;
+
+    l_rtaSize = NLMSG_PAYLOAD(p_hdr, sizeof(struct ifaddrmsg));
+    for(l_rta = (struct rtattr *)(((char *)l_info) + NLMSG_ALIGN(sizeof(struct ifaddrmsg))); RTA_OK(l_rta, l_rtaSize); l_rta = RTA_NEXT(l_rta, l_rtaSize)) {
+        void * l_rtaData     = RTA_DATA(l_rta);
+        size_t l_rtaDataSize = RTA_PAYLOAD(l_rta);
+        switch(l_rta->rta_type) {
+        case IFA_ADDRESS:
+        case IFA_BROADCAST:
+        case IFA_LOCAL: {
+            size_t l_addrLen = calcAddrLen(l_info->ifa_family, l_rtaDataSize);
+            makeSockaddr(l_info->ifa_family, (struct sockaddr *)l_addr, l_rtaData, l_rtaDataSize);
+            if(l_info->ifa_family == AF_INET6) {
+                if(IN6_IS_ADDR_LINKLOCAL((struct in6_addr *)l_rtaData) || IN6_IS_ADDR_MC_LINKLOCAL((struct in6_addr *)l_rtaData)) {
+                    ((struct sockaddr_in6 *)l_addr)->sin6_scope_id = l_info->ifa_index;
+                }
+            }
+
+            if(l_rta->rta_type
+               == IFA_ADDRESS) {  // apparently in a point-to-point network IFA_ADDRESS contains the dest address and IFA_LOCAL contains the local address
+                if(l_entry->ifa_addr) {
+                    l_entry->ifa_dstaddr = (struct sockaddr *)l_addr;
+                }
+                else {
+                    l_entry->ifa_addr = (struct sockaddr *)l_addr;
+                }
+            }
+            else if(l_rta->rta_type == IFA_LOCAL) {
+                if(l_entry->ifa_addr) {
+                    l_entry->ifa_dstaddr = l_entry->ifa_addr;
+                }
+                l_entry->ifa_addr = (struct sockaddr *)l_addr;
+            }
+            else {
+                l_entry->ifa_broadaddr = (struct sockaddr *)l_addr;
+            }
+            l_addr += NLMSG_ALIGN(l_addrLen);
+            break;
+        }
+        case IFA_LABEL:
+            strncpy(l_name, l_rtaData, l_rtaDataSize);
+            l_name[l_rtaDataSize] = '\0';
+            l_entry->ifa_name     = l_name;
+            break;
+        default:
+            break;
+        }
+    }
+
+    if(l_entry->ifa_addr && (l_entry->ifa_addr->sa_family == AF_INET || l_entry->ifa_addr->sa_family == AF_INET6)) {
+        unsigned l_maxPrefix = (l_entry->ifa_addr->sa_family == AF_INET ? 32 : 128);
+        unsigned l_prefix    = (l_info->ifa_prefixlen > l_maxPrefix ? l_maxPrefix : l_info->ifa_prefixlen);
+        char     l_mask[16]  = { 0 };
+        unsigned i;
+        for(i = 0; i < (l_prefix / 8); ++i) {
+            l_mask[i] = 0xff;
+        }
+        l_mask[i] = 0xff << (8 - (l_prefix % 8));
+
+        makeSockaddr(l_entry->ifa_addr->sa_family, (struct sockaddr *)l_addr, l_mask, l_maxPrefix / 8);
+        l_entry->ifa_netmask = (struct sockaddr *)l_addr;
+    }
+
+    addToEnd(p_resultList, l_entry);
+}
+
+static void interpret(int p_socket, NetlinkList *p_netlinkList, struct ifaddrs **p_links, struct ifaddrs **p_resultList) {
+    pid_t l_pid = getpid();
+    for(; p_netlinkList; p_netlinkList = p_netlinkList->m_next) {
+        unsigned int     l_nlsize = p_netlinkList->m_size;
+        struct nlmsghdr *l_hdr;
+        for(l_hdr = p_netlinkList->m_data; NLMSG_OK(l_hdr, l_nlsize); l_hdr = NLMSG_NEXT(l_hdr, l_nlsize)) {
+            if((pid_t)l_hdr->nlmsg_pid != l_pid || (int)l_hdr->nlmsg_seq != p_socket) {
+                continue;
+            }
+
+            if(l_hdr->nlmsg_type == NLMSG_DONE) {
+                break;
+            }
+
+            if(l_hdr->nlmsg_type == RTM_NEWLINK) {
+                interpretLink(l_hdr, p_links, p_resultList);
+            }
+            else if(l_hdr->nlmsg_type == RTM_NEWADDR) {
+                interpretAddr(l_hdr, p_links, p_resultList);
+            }
+        }
+    }
+}
+
+static unsigned countLinks(int p_socket, NetlinkList *p_netlinkList) {
+    unsigned l_links = 0;
+    pid_t    l_pid   = getpid();
+    for(; p_netlinkList; p_netlinkList = p_netlinkList->m_next) {
+        unsigned int     l_nlsize = p_netlinkList->m_size;
+        struct nlmsghdr *l_hdr;
+        for(l_hdr = p_netlinkList->m_data; NLMSG_OK(l_hdr, l_nlsize); l_hdr = NLMSG_NEXT(l_hdr, l_nlsize)) {
+            if((pid_t)l_hdr->nlmsg_pid != l_pid || (int)l_hdr->nlmsg_seq != p_socket) {
+                continue;
+            }
+
+            if(l_hdr->nlmsg_type == NLMSG_DONE) {
+                break;
+            }
+
+            if(l_hdr->nlmsg_type == RTM_NEWLINK) {
+                ++l_links;
+            }
+        }
+    }
+
+    return l_links;
+}
+
+int getifaddrs(struct ifaddrs **ifap) {
+    if(!ifap) {
+        return -1;
+    }
+    *ifap = NULL;
+
+    int l_socket = netlink_socket();
+    if(l_socket < 0) {
+        return -1;
+    }
+
+    NetlinkList *l_linkResults = getResultList(l_socket, RTM_GETLINK);
+    if(!l_linkResults) {
+        close(l_socket);
+        return -1;
+    }
+
+    NetlinkList *l_addrResults = getResultList(l_socket, RTM_GETADDR);
+    if(!l_addrResults) {
+        close(l_socket);
+        freeResultList(l_linkResults);
+        return -1;
+    }
+
+    unsigned        l_numLinks = countLinks(l_socket, l_linkResults) + countLinks(l_socket, l_addrResults);
+    struct ifaddrs *l_links[l_numLinks];
+    memset(l_links, 0, l_numLinks * sizeof(struct ifaddrs *));
+
+    interpret(l_socket, l_linkResults, l_links, ifap);
+    interpret(l_socket, l_addrResults, l_links, ifap);
+
+    freeResultList(l_linkResults);
+    freeResultList(l_addrResults);
+    close(l_socket);
+    return 0;
+}
+
+void freeifaddrs(struct ifaddrs *ifa) {
+    struct ifaddrs *l_cur;
+    while(ifa) {
+        l_cur = ifa;
+        ifa   = ifa->ifa_next;
+        free(l_cur);
+    }
+}
+#endif
\ No newline at end of file
diff --git a/3rdparty/live555/src/android_ifaddrs_addition/ifaddrs_add.h b/3rdparty/live555/src/android_ifaddrs_addition/ifaddrs_add.h
new file mode 100644
index 00000000..e0877a82
--- /dev/null
+++ b/3rdparty/live555/src/android_ifaddrs_addition/ifaddrs_add.h
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 1995, 1999
+ *	Berkeley Software Design, Inc.  All rights reserved.
+ *
+ * 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY Berkeley Software Design, Inc. ``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 Berkeley Software Design, Inc. 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.
+ *
+ *	BSDI ifaddrs.h,v 2.5 2000/02/23 14:51:59 dab Exp
+ */
+
+#ifndef _IFADDRS_ADD_H_
+#define _IFADDRS_ADD_H_
+
+#include <ifaddrs.h>
+#include <net/if.h>
+
+#if __ANDROID_API__ < 24
+int  getifaddrs(struct ifaddrs **ifap);
+void freeifaddrs(struct ifaddrs *ifa);
+#endif
+
+#endif
diff --git a/3rdparty/live555/src/config.armeb-uclibc b/3rdparty/live555/src/config.armeb-uclibc
new file mode 100644
index 00000000..a88289f9
--- /dev/null
+++ b/3rdparty/live555/src/config.armeb-uclibc
@@ -0,0 +1,19 @@
+CROSS_COMPILE=         armeb-linux-uclibc-
+COMPILE_OPTS =          $(INCLUDES) -I/usr/local/include -I. -Os -DSOCKLEN_T=socklen_t -DNO_SSTREAM=1 -D
+LARGEFILE_SOURCE=1 -D_FILE_OFFSET_BITS=64
+C =                    c
+C_COMPILER =           $(CROSS_COMPILE)gcc
+C_FLAGS =              $(COMPILE_OPTS)
+CPP =                  cpp
+CPLUSPLUS_COMPILER =   $(CROSS_COMPILE)g++
+CPLUSPLUS_FLAGS =      $(COMPILE_OPTS) -Wall -DBSD=1
+OBJ =                  o
+LINK =                 $(CROSS_COMPILE)gcc -o
+LINK_OPTS =            -L.
+CONSOLE_LINK_OPTS =    $(LINK_OPTS)
+LIBRARY_LINK =         $(CROSS_COMPILE)ar cr 
+LIBRARY_LINK_OPTS =    
+LIB_SUFFIX =                   a
+LIBS_FOR_CONSOLE_APPLICATION = -lssl -lcrypto
+LIBS_FOR_GUI_APPLICATION =
+EXE =
diff --git a/3rdparty/live555/src/config.armlinux b/3rdparty/live555/src/config.armlinux
new file mode 100644
index 00000000..5a7f8a8e
--- /dev/null
+++ b/3rdparty/live555/src/config.armlinux
@@ -0,0 +1,18 @@
+CROSS_COMPILE?=		arm-elf-
+COMPILE_OPTS =		$(INCLUDES) -I/usr/local/include -I. -O2 -DSOCKLEN_T=socklen_t -DNO_SSTREAM=1 -D_LARGEFILE_SOURCE=1 -D_FILE_OFFSET_BITS=64
+C =			c
+C_COMPILER =		$(CROSS_COMPILE)gcc
+C_FLAGS =		$(COMPILE_OPTS)
+CPP =			cpp
+CPLUSPLUS_COMPILER =	$(CROSS_COMPILE)g++
+CPLUSPLUS_FLAGS =	$(COMPILE_OPTS) -Wall -DBSD=1
+OBJ =			o
+LINK =			$(CROSS_COMPILE)g++ -o
+LINK_OPTS =		
+CONSOLE_LINK_OPTS =	$(LINK_OPTS)
+LIBRARY_LINK =		$(CROSS_COMPILE)ar cr 
+LIBRARY_LINK_OPTS =	$(LINK_OPTS)
+LIB_SUFFIX =			a
+LIBS_FOR_CONSOLE_APPLICATION = -lssl -lcrypto
+LIBS_FOR_GUI_APPLICATION =
+EXE =
diff --git a/3rdparty/live555/src/config.avr32-linux b/3rdparty/live555/src/config.avr32-linux
new file mode 100644
index 00000000..db89d9b1
--- /dev/null
+++ b/3rdparty/live555/src/config.avr32-linux
@@ -0,0 +1,15 @@
+CROSS_COMPILE=        avr32-linux-uclibc-
+COMPILE_OPTS =        -I/usr/local/include -Os  $(INCLUDES) -msoft-float -D_LARGEFILE_SOURCE -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 -DSOCKLEN_T=socklen_t -DNO_SSTREAM=1 C =            c
+C_COMPILER =        $(CROSS_COMPILE)gcc
+C_FLAGS =        $(COMPILE_OPTS)
+CPP =            cpp
+CPLUSPLUS_COMPILER =    $(CROSS_COMPILE)c++
+CPLUSPLUS_FLAGS =    $(COMPILE_OPTS) -Wall -fuse-cxa-atexit -DBSD=1 OBJ =            o
+LINK =            $(CROSS_COMPILE)c++ -o
+LINK_OPTS =         
+CONSOLE_LINK_OPTS =    $(LINK_OPTS)
+LIBRARY_LINK =        $(CROSS_COMPILE)ar cr LIBRARY_LINK_OPTS =     
+LIB_SUFFIX =        a
+LIBS_FOR_CONSOLE_APPLICATION = -lssl -lcrypto
+LIBS_FOR_GUI_APPLICATION =
+EXE =
diff --git a/3rdparty/live555/src/config.bfin-linux-uclibc b/3rdparty/live555/src/config.bfin-linux-uclibc
new file mode 100644
index 00000000..a316d4c3
--- /dev/null
+++ b/3rdparty/live555/src/config.bfin-linux-uclibc
@@ -0,0 +1,18 @@
+CROSS_COMPILER     = bfin-linux-uclibc-
+COMPILE_OPTS       = $(INCLUDES) -I/usr/local/include -I. -DSOCKLEN_T=socklen_t -D_LARGEFILE_SOURCE=1 -DUCLINUX -D_FILE_OFFSET_BITS=64
+C                  = c
+C_COMPILER         = $(CROSS_COMPILER)gcc
+C_FLAGS            = $(COMPILE_OPTS) -Wall
+CPP                = cpp
+CPLUSPLUS_COMPILER = $(CROSS_COMPILER)g++
+CPLUSPLUS_FLAGS    = $(COMPILE_OPTS) -Wall
+OBJ                = o
+LINK               = $(CROSS_COMPILER)g++ -o
+LINK_OPTS          = -L.
+CONSOLE_LINK_OPTS  = $(LINK_OPTS)
+LIBRARY_LINK       = $(CROSS_COMPILER)ar cr 
+LIBRARY_LINK_OPTS  = 
+LIB_SUFFIX         = a
+LIBS_FOR_CONSOLE_APPLICATION = -lssl -lcrypto
+LIBS_FOR_GUI_APPLICATION =
+EXE =
diff --git a/3rdparty/live555/src/config.bfin-uclinux b/3rdparty/live555/src/config.bfin-uclinux
new file mode 100644
index 00000000..9424110d
--- /dev/null
+++ b/3rdparty/live555/src/config.bfin-uclinux
@@ -0,0 +1,18 @@
+CROSS_COMPILER=        bfin-uclinux-
+COMPILE_OPTS =        $(INCLUDES) -I/usr/local/include -I. -DSOCKLEN_T=socklen_t -D_LARGEFILE_SOURCE=1 -DUCLINUX -D_FILE_OFFSET_BITS=64
+C =            c
+C_COMPILER =        $(CROSS_COMPILER)gcc
+C_FLAGS =        $(COMPILE_OPTS) -Wall
+CPP =            cpp
+CPLUSPLUS_COMPILER =    $(CROSS_COMPILER)g++
+CPLUSPLUS_FLAGS =    $(COMPILE_OPTS) -Wall
+OBJ =            o
+LINK =            $(CROSS_COMPILER)g++ -Wl,-elf2flt -o
+LINK_OPTS =        -L.
+CONSOLE_LINK_OPTS =    $(LINK_OPTS)
+LIBRARY_LINK =        $(CROSS_COMPILER)ar cr 
+LIBRARY_LINK_OPTS =    
+LIB_SUFFIX =            a
+LIBS_FOR_CONSOLE_APPLICATION = -lssl -lcrypto
+LIBS_FOR_GUI_APPLICATION =
+EXE =
diff --git a/3rdparty/live555/src/config.bsplinux b/3rdparty/live555/src/config.bsplinux
new file mode 100644
index 00000000..8290ce54
--- /dev/null
+++ b/3rdparty/live555/src/config.bsplinux
@@ -0,0 +1,18 @@
+CROSS_COMPILE=
+COMPILE_OPTS =          $(INCLUDES) -I. -I/usr/local/include -O2 -DSOCKLEN_T=socklen_t -DNO_SSTREAM=1 -D_LARGEFILE_SOURCE=1 -D_FILE_OFFSET_BITS=64
+C =                     c
+C_COMPILER =            $(CROSS_COMPILE)ecc
+C_FLAGS =               $(COMPILE_OPTS)
+CPP =                   cpp
+CPLUSPLUS_COMPILER =    $(CROSS_COMPILE)e++
+CPLUSPLUS_FLAGS =       $(COMPILE_OPTS) -Wall -DBSD=1
+OBJ =                   o
+LINK =                  $(CROSS_COMPILE)e++ -o
+LINK_OPTS =             -L.
+CONSOLE_LINK_OPTS =     $(LINK_OPTS)
+LIBRARY_LINK =          $(CROSS_COMPILE)eld -o
+LIBRARY_LINK_OPTS =     $(LINK_OPTS) -r -Bstatic
+LIB_SUFFIX =                    a
+LIBS_FOR_CONSOLE_APPLICATION = -lm -lssl -lcrypto
+LIBS_FOR_GUI_APPLICATION =
+EXE =
diff --git a/3rdparty/live555/src/config.cris-axis-linux-gnu b/3rdparty/live555/src/config.cris-axis-linux-gnu
new file mode 100644
index 00000000..ce1195f3
--- /dev/null
+++ b/3rdparty/live555/src/config.cris-axis-linux-gnu
@@ -0,0 +1,23 @@
+# Note: AXIS_TOP_DIR is assumed to already be set in your environment.
+# You can set this using the "init_env" script.
+# See http://developer.axis.com/doc/software/apps/apps-howto.html
+# for more information.
+AXIS_DIR = $(AXIS_TOP_DIR)/target/cris-axis-linux-gnu
+COMPILE_OPTS = $(INCLUDES) -I. -mlinux -isystem $(AXIS_DIR)/include -I/usr/local/include -Wall -O2 -DSOCKLEN_T=socklen_t -DCRIS -D_LARGEFILE_SOURCE=1 -D_FILE_OFFSET_BITS=64
+C =			c
+C_COMPILER =		gcc-cris
+C_FLAGS =		$(COMPILE_OPTS)
+CPP =			cpp
+CPLUSPLUS_COMPILER =	c++-cris
+CPLUSPLUS_FLAGS =	$(COMPILE_OPTS) -Wno-ctor-dtor-privacy -ansi -pipe
+OBJ =			o
+LINK =			c++-cris -static -o
+AXIS_LINK_OPTS =	-L$(AXIS_DIR)/lib
+LINK_OPTS =		-L.
+CONSOLE_LINK_OPTS =	$(LINK_OPTS) -L$(AXIS_DIR)/lib -mlinux
+LIBRARY_LINK =		ld-cris -mcrislinux -o
+LIBRARY_LINK_OPTS =	$(LINK_OPTS) -r -Bstatic
+LIB_SUFFIX =			a
+LIBS_FOR_CONSOLE_APPLICATION = -lssl -lcrypto
+LIBS_FOR_GUI_APPLICATION =
+EXE =
diff --git a/3rdparty/live555/src/config.cygwin b/3rdparty/live555/src/config.cygwin
new file mode 100644
index 00000000..2e7a9c07
--- /dev/null
+++ b/3rdparty/live555/src/config.cygwin
@@ -0,0 +1,17 @@
+COMPILE_OPTS =		$(INCLUDES) -I/usr/local/include -I. -O -DSOCKLEN_T=socklen_t -DNEWLOCALE_NOT_USED=1
+C =			c
+C_COMPILER =		gcc
+C_FLAGS =		$(COMPILE_OPTS) -DUSE_OUR_BZERO=1 -D__CYGWIN__
+CPP =			cpp
+CPLUSPLUS_COMPILER =	c++
+CPLUSPLUS_FLAGS =	$(COMPILE_OPTS) -Wall -DBSD=1
+OBJ =			o
+LINK =			c++ -o 
+LINK_OPTS =		-L.
+CONSOLE_LINK_OPTS =	$(LINK_OPTS)
+LIBRARY_LINK =		ld -o 
+LIBRARY_LINK_OPTS =	$(LINK_OPTS) -r -Bstatic
+LIB_SUFFIX =			a
+LIBS_FOR_CONSOLE_APPLICATION = -lssl -lcrypto
+LIBS_FOR_GUI_APPLICATION =
+EXE =
diff --git a/3rdparty/live555/src/config.cygwin-for-vlc b/3rdparty/live555/src/config.cygwin-for-vlc
new file mode 100644
index 00000000..b1e19e88
--- /dev/null
+++ b/3rdparty/live555/src/config.cygwin-for-vlc
@@ -0,0 +1,17 @@
+COMPILE_OPTS =		$(INCLUDES) -I/usr/local/include -I. -O -DSOCKLEN_T=socklen_t -DNEWLOCALE_NOT_USED=1
+C =			c
+C_COMPILER =		gcc
+C_FLAGS =		$(COMPILE_OPTS) -DUSE_OUR_BZERO=1 -D_WIN32 -mno-cygwin
+CPP =			cpp
+CPLUSPLUS_COMPILER =	c++
+CPLUSPLUS_FLAGS =	$(COMPILE_OPTS) -Wall -DBSD=1 -D_WIN32 -Wno-deprecated -mno-cygwin
+OBJ =			o
+LINK =			c++ -o
+LINK_OPTS =		-L.
+CONSOLE_LINK_OPTS =	$(LINK_OPTS)
+LIBRARY_LINK =		ld -o
+LIBRARY_LINK_OPTS =	$(LINK_OPTS) -r -Bstatic
+LIB_SUFFIX =		a
+LIBS_FOR_CONSOLE_APPLICATION = -lssl -lcrypto
+LIBS_FOR_GUI_APPLICATION =
+EXE =
diff --git a/3rdparty/live555/src/config.freebsd b/3rdparty/live555/src/config.freebsd
new file mode 100644
index 00000000..00cfe211
--- /dev/null
+++ b/3rdparty/live555/src/config.freebsd
@@ -0,0 +1,17 @@
+COMPILE_OPTS =		$(INCLUDES) -I/usr/local/include -I. -O -DBSD=1 -DNEWLOCALE_NOT_USED=1 -DSOCKLEN_T=socklen_t -DHAVE_SOCKADDR_LEN=1
+C =			c
+C_COMPILER =		cc
+C_FLAGS =		$(COMPILE_OPTS)
+CPP =			cpp
+CPLUSPLUS_COMPILER =	c++
+CPLUSPLUS_FLAGS =	$(COMPILE_OPTS) -Wall
+OBJ =			o
+LINK =			c++ -o
+LINK_OPTS =		-L.
+CONSOLE_LINK_OPTS =	$(LINK_OPTS)
+LIBRARY_LINK =		ar cr 
+LIBRARY_LINK_OPTS =	
+LIB_SUFFIX =			a
+LIBS_FOR_CONSOLE_APPLICATION = -lssl -lcrypto
+LIBS_FOR_GUI_APPLICATION =
+EXE =
diff --git a/3rdparty/live555/src/config.freebsd-no-openssl b/3rdparty/live555/src/config.freebsd-no-openssl
new file mode 100644
index 00000000..2170518e
--- /dev/null
+++ b/3rdparty/live555/src/config.freebsd-no-openssl
@@ -0,0 +1,17 @@
+COMPILE_OPTS =		$(INCLUDES) -I. -O -DBSD=1 -DNEWLOCALE_NOT_USED=1 -DSOCKLEN_T=socklen_t -DHAVE_SOCKADDR_LEN=1 -DNO_OPENSSL=1
+C =			c
+C_COMPILER =		cc
+C_FLAGS =		$(COMPILE_OPTS)
+CPP =			cpp
+CPLUSPLUS_COMPILER =	c++
+CPLUSPLUS_FLAGS =	$(COMPILE_OPTS) -Wall
+OBJ =			o
+LINK =			c++ -o
+LINK_OPTS =		-L.
+CONSOLE_LINK_OPTS =	$(LINK_OPTS)
+LIBRARY_LINK =		ar cr 
+LIBRARY_LINK_OPTS =	
+LIB_SUFFIX =			a
+LIBS_FOR_CONSOLE_APPLICATION =
+LIBS_FOR_GUI_APPLICATION =
+EXE =
diff --git a/3rdparty/live555/src/config.iphone-simulator b/3rdparty/live555/src/config.iphone-simulator
new file mode 100644
index 00000000..d4e300c8
--- /dev/null
+++ b/3rdparty/live555/src/config.iphone-simulator
@@ -0,0 +1,28 @@
+# **Note: You must install the relevant "Command line tools (OSX *.*) for Xcode - Xcode *.*"
+# for this configuration file to work.
+
+# Change the following version number, if necessary, before running "genMakefiles iphone-simulator"
+IOS_VERSION = 8.3
+MIN_IOS_VERSION =  7.0
+
+DEVELOPER_PATH = /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer
+TOOL_PATH = $(DEVELOPER_PATH)/usr/bin
+SDK_PATH = $(DEVELOPER_PATH)/SDKs
+SDK = $(SDK_PATH)/iPhoneSimulator$(IOS_VERSION).sdk
+COMPILE_OPTS =          $(INCLUDES) -I/usr/local/include -I. $(EXTRA_LDFLAGS) -DBSD=1 -O2 -DSOCKLEN_T=socklen_t -DHAVE_SOCKADDR_LEN=1 -miphoneos-version-min=$(MIN_IOS_VERSION) -D_LARGEFILE_SOURCE=1 -D_FILE_OFFSET_BITS=64 -fPIC -arch i386 --sysroot=$(SDK) -isysroot $(SDK)
+C =                     c
+C_COMPILER =            /usr/bin/xcrun clang
+C_FLAGS =               $(COMPILE_OPTS)
+CPP =                   cpp
+CPLUSPLUS_COMPILER =    /usr/bin/xcrun clang
+CPLUSPLUS_FLAGS =       $(COMPILE_OPTS) -Wall
+OBJ =                   o
+LINK =                  /usr/bin/xcrun clang -o
+LINK_OPTS =             -L. -arch i386 -miphoneos-version-min=$(MIN_IOS_VERSION) --sysroot=$(SDK) -isysroot -L$(SDK)/usr/lib/system -I$(SDK)/usr/lib /usr/lib/libc++.Dylib
+CONSOLE_LINK_OPTS =     $(LINK_OPTS)
+LIBRARY_LINK =          /usr/bin/xcrun libtool -static -o 
+LIBRARY_LINK_OPTS =
+LIB_SUFFIX =            a
+LIBS_FOR_CONSOLE_APPLICATION = -lssl -lcrypto
+LIBS_FOR_GUI_APPLICATION =
+EXE =
diff --git a/3rdparty/live555/src/config.iphoneos b/3rdparty/live555/src/config.iphoneos
new file mode 100644
index 00000000..0eb8bcab
--- /dev/null
+++ b/3rdparty/live555/src/config.iphoneos
@@ -0,0 +1,27 @@
+# **Note: You must install the relevant "Command line tools (OSX *.*) for Xcode - Xcode *.*"
+# for this configuration file to work.
+#
+# Change the following version number, if necessary, before running "genMakefiles iphoneos"
+IOS_VERSION = 8.3
+
+DEVELOPER_PATH =  /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer
+TOOL_PATH = $(DEVELOPER_PATH)/usr/bin
+SDK_PATH = $(DEVELOPER_PATH)/SDKs
+SDK = $(SDK_PATH)/iPhoneOS$(IOS_VERSION).sdk
+COMPILE_OPTS =          $(INCLUDES) -I/usr/local/include -I. $(EXTRA_LDFLAGS) -DBSD=1 -O2 -DSOCKLEN_T=socklen_t -DHAVE_SOCKADDR_LEN=1 -D_LARGEFILE_SOURCE=1 -D_FILE_OFFSET_BITS=64 -fPIC -arch armv7 --sysroot=$(SDK)
+C =                     c
+C_COMPILER =            /usr/bin/xcrun clang
+C_FLAGS =               $(COMPILE_OPTS)
+CPP =                   cpp
+CPLUSPLUS_COMPILER =    /usr/bin/xcrun clang
+CPLUSPLUS_FLAGS =       $(COMPILE_OPTS) -Wall
+OBJ =                   o
+LINK =                  /usr/bin/xcrun clang -o 
+LINK_OPTS =             -v -L. -arch armv7 --sysroot=$(SDK) -L$(SDK)/usr/lib/system /usr/lib/libc++.Dylib
+CONSOLE_LINK_OPTS =     $(LINK_OPTS)
+LIBRARY_LINK =          /usr/bin/xcrun libtool -static -o 
+LIBRARY_LINK_OPTS =
+LIB_SUFFIX =            a
+LIBS_FOR_CONSOLE_APPLICATION = -lssl -lcrypto
+LIBS_FOR_GUI_APPLICATION =
+EXE = 
diff --git a/3rdparty/live555/src/config.linux b/3rdparty/live555/src/config.linux
new file mode 100644
index 00000000..b4021ef6
--- /dev/null
+++ b/3rdparty/live555/src/config.linux
@@ -0,0 +1,17 @@
+COMPILE_OPTS =		$(INCLUDES) -I/usr/local/include -I. -O2 -DSOCKLEN_T=socklen_t -D_LARGEFILE_SOURCE=1 -D_FILE_OFFSET_BITS=64
+C =			c
+C_COMPILER =		cc
+C_FLAGS =		$(COMPILE_OPTS) $(CPPFLAGS) $(CFLAGS)
+CPP =			cpp
+CPLUSPLUS_COMPILER =	c++
+CPLUSPLUS_FLAGS =	$(COMPILE_OPTS) -Wall -DBSD=1 $(CPPFLAGS) $(CXXFLAGS)
+OBJ =			o
+LINK =			c++ -o
+LINK_OPTS =		-L. $(LDFLAGS)
+CONSOLE_LINK_OPTS =	$(LINK_OPTS)
+LIBRARY_LINK =		ar cr 
+LIBRARY_LINK_OPTS =	
+LIB_SUFFIX =			a
+LIBS_FOR_CONSOLE_APPLICATION = -lssl -lcrypto
+LIBS_FOR_GUI_APPLICATION =
+EXE =
diff --git a/3rdparty/live555/src/config.linux-64bit b/3rdparty/live555/src/config.linux-64bit
new file mode 100644
index 00000000..84b9623f
--- /dev/null
+++ b/3rdparty/live555/src/config.linux-64bit
@@ -0,0 +1,17 @@
+COMPILE_OPTS =		$(INCLUDES) -m64  -fPIC -I/usr/local/include -I. -O2 -DSOCKLEN_T=socklen_t -D_LARGEFILE_SOURCE=1 -D_FILE_OFFSET_BITS=64
+C =			c
+C_COMPILER =		cc
+C_FLAGS =		$(COMPILE_OPTS)
+CPP =			cpp
+CPLUSPLUS_COMPILER =	c++
+CPLUSPLUS_FLAGS =	$(COMPILE_OPTS) -Wall -DBSD=1
+OBJ =			o
+LINK =			c++ -o
+LINK_OPTS =		-L.
+CONSOLE_LINK_OPTS =	$(LINK_OPTS)
+LIBRARY_LINK =		ar cr 
+LIBRARY_LINK_OPTS =	
+LIB_SUFFIX =			a
+LIBS_FOR_CONSOLE_APPLICATION = -lssl -lcrypto
+LIBS_FOR_GUI_APPLICATION =
+EXE =
diff --git a/3rdparty/live555/src/config.linux-gdb b/3rdparty/live555/src/config.linux-gdb
new file mode 100644
index 00000000..800e0d37
--- /dev/null
+++ b/3rdparty/live555/src/config.linux-gdb
@@ -0,0 +1,17 @@
+COMPILE_OPTS =		$(INCLUDES) -I/usr/local/include -I. -O -DSOCKLEN_T=socklen_t -g -D_LARGEFILE_SOURCE=1 -D_FILE_OFFSET_BITS=64
+C =			c
+C_COMPILER =		cc
+C_FLAGS =		$(COMPILE_OPTS)
+CPP =			cpp
+CPLUSPLUS_COMPILER =	c++
+CPLUSPLUS_FLAGS =	$(COMPILE_OPTS) -Wall -DBSD=1
+OBJ =			o
+LINK =			c++ -o
+LINK_OPTS =		-L.
+CONSOLE_LINK_OPTS =	$(LINK_OPTS)
+LIBRARY_LINK =		ar cr 
+LIBRARY_LINK_OPTS =	
+LIB_SUFFIX =			a
+LIBS_FOR_CONSOLE_APPLICATION = -lssl -lcrypto
+LIBS_FOR_GUI_APPLICATION =
+EXE =
diff --git a/3rdparty/live555/src/config.linux-no-openssl b/3rdparty/live555/src/config.linux-no-openssl
new file mode 100644
index 00000000..0de38c4e
--- /dev/null
+++ b/3rdparty/live555/src/config.linux-no-openssl
@@ -0,0 +1,17 @@
+COMPILE_OPTS =		$(INCLUDES) -I. -O2 -DSOCKLEN_T=socklen_t -D_LARGEFILE_SOURCE=1 -D_FILE_OFFSET_BITS=64 -DNO_OPENSSL=1
+C =			c
+C_COMPILER =		cc
+C_FLAGS =		$(COMPILE_OPTS) $(CPPFLAGS) $(CFLAGS)
+CPP =			cpp
+CPLUSPLUS_COMPILER =	c++
+CPLUSPLUS_FLAGS =	$(COMPILE_OPTS) -Wall -DBSD=1 $(CPPFLAGS) $(CXXFLAGS)
+OBJ =			o
+LINK =			c++ -o
+LINK_OPTS =		-L. $(LDFLAGS)
+CONSOLE_LINK_OPTS =	$(LINK_OPTS)
+LIBRARY_LINK =		ar cr 
+LIBRARY_LINK_OPTS =	
+LIB_SUFFIX =			a
+LIBS_FOR_CONSOLE_APPLICATION =
+LIBS_FOR_GUI_APPLICATION =
+EXE =
diff --git a/3rdparty/live555/src/config.linux-with-shared-libraries b/3rdparty/live555/src/config.linux-with-shared-libraries
new file mode 100644
index 00000000..2404cb96
--- /dev/null
+++ b/3rdparty/live555/src/config.linux-with-shared-libraries
@@ -0,0 +1,46 @@
+# 'CURRENT':'REVISION':'AGE' are updated - whenever a library changes - as follows:
+# The library code changes, but without any changes to the API (i.e., interfaces) => increment REVISION
+# At least one interface changes, or is removed => CURRENT += 1; REVISION = 0; AGE = 0
+# One or more interfaces were added, but no existing interfaces were changed or removed => CURRENT += 1; REVISION = 0; AGE += 1
+
+libliveMedia_VERSION_CURRENT=107
+libliveMedia_VERSION_REVISION=1
+libliveMedia_VERSION_AGE=1
+libliveMedia_LIB_SUFFIX=so.$(shell expr $(libliveMedia_VERSION_CURRENT) - $(libliveMedia_VERSION_AGE)).$(libliveMedia_VERSION_AGE).$(libliveMedia_VERSION_REVISION)
+
+libBasicUsageEnvironment_VERSION_CURRENT=1
+libBasicUsageEnvironment_VERSION_REVISION=1
+libBasicUsageEnvironment_VERSION_AGE=0
+libBasicUsageEnvironment_LIB_SUFFIX=so.$(shell expr $(libBasicUsageEnvironment_VERSION_CURRENT) - $(libBasicUsageEnvironment_VERSION_AGE)).$(libBasicUsageEnvironment_VERSION_AGE).$(libBasicUsageEnvironment_VERSION_REVISION)
+
+libUsageEnvironment_VERSION_CURRENT=4
+libUsageEnvironment_VERSION_REVISION=0
+libUsageEnvironment_VERSION_AGE=1
+libUsageEnvironment_LIB_SUFFIX=so.$(shell expr $(libUsageEnvironment_VERSION_CURRENT) - $(libUsageEnvironment_VERSION_AGE)).$(libUsageEnvironment_VERSION_AGE).$(libUsageEnvironment_VERSION_REVISION)
+
+libgroupsock_VERSION_CURRENT=30
+libgroupsock_VERSION_REVISION=10
+libgroupsock_VERSION_AGE=0
+libgroupsock_LIB_SUFFIX=so.$(shell expr $(libgroupsock_VERSION_CURRENT) - $(libgroupsock_VERSION_AGE)).$(libgroupsock_VERSION_AGE).$(libgroupsock_VERSION_REVISION)
+#####
+
+COMPILE_OPTS =		$(INCLUDES) -I/usr/local/include -I. -O2 -DSOCKLEN_T=socklen_t -D_LARGEFILE_SOURCE=1 -D_FILE_OFFSET_BITS=64 -fPIC
+C =			c
+C_COMPILER =		$(CC)
+C_FLAGS =		$(COMPILE_OPTS) $(CPPFLAGS) $(CFLAGS)
+CPP =			cpp
+CPLUSPLUS_COMPILER =	$(CXX)
+CPLUSPLUS_FLAGS =	$(COMPILE_OPTS) -Wall -DBSD=1 $(CPPFLAGS) $(CXXFLAGS)
+OBJ =			o
+LINK =			$(CXX) -o
+LINK_OPTS =		-L. $(LDFLAGS)
+CONSOLE_LINK_OPTS =	$(LINK_OPTS)
+LIBRARY_LINK =		$(CC) -o 
+SHORT_LIB_SUFFIX =	so.$(shell expr $($(NAME)_VERSION_CURRENT) - $($(NAME)_VERSION_AGE))
+LIB_SUFFIX =	 	$(SHORT_LIB_SUFFIX).$($(NAME)_VERSION_AGE).$($(NAME)_VERSION_REVISION)
+LIBRARY_LINK_OPTS =	-shared -Wl,-soname,$(NAME).$(SHORT_LIB_SUFFIX) $(LDFLAGS)
+LIBS_FOR_CONSOLE_APPLICATION = -lssl -lcrypto
+LIBS_FOR_GUI_APPLICATION =
+LIBS_FOR_LIVEMEDIA_LIB = -lssl -lcrypto
+EXE =
+INSTALL2 =		install_shared_libraries
diff --git a/3rdparty/live555/src/config.macosx-bigsur b/3rdparty/live555/src/config.macosx-bigsur
new file mode 100644
index 00000000..236f58e5
--- /dev/null
+++ b/3rdparty/live555/src/config.macosx-bigsur
@@ -0,0 +1,17 @@
+COMPILE_OPTS =		$(INCLUDES) -I. -I/usr/local/include $(EXTRA_LDFLAGS) -DBSD=1 -O -DSOCKLEN_T=socklen_t -DHAVE_SOCKADDR_LEN=1 -DTIME_BASE=int -DNEED_XLOCALE_H=1
+C =			c
+C_COMPILER =		cc
+C_FLAGS =		$(COMPILE_OPTS)
+CPP =			cpp
+CPLUSPLUS_COMPILER =	c++
+CPLUSPLUS_FLAGS =	$(COMPILE_OPTS) -Wall
+OBJ =			o
+LINK =			c++ -o 
+LINK_OPTS =		-L. -L/usr/local/ssl/lib
+CONSOLE_LINK_OPTS =	$(LINK_OPTS)
+LIBRARY_LINK =		libtool -s -o 
+LIBRARY_LINK_OPTS =	
+LIB_SUFFIX =			a
+LIBS_FOR_CONSOLE_APPLICATION = -lssl -lcrypto
+LIBS_FOR_GUI_APPLICATION =
+EXE =
diff --git a/3rdparty/live555/src/config.macosx-catalina b/3rdparty/live555/src/config.macosx-catalina
new file mode 100644
index 00000000..58e54026
--- /dev/null
+++ b/3rdparty/live555/src/config.macosx-catalina
@@ -0,0 +1,17 @@
+COMPILE_OPTS =		$(INCLUDES) -I. -I/usr/local/include $(EXTRA_LDFLAGS) -DBSD=1 -O -DSOCKLEN_T=socklen_t -DHAVE_SOCKADDR_LEN=1 -DTIME_BASE=int -DNEED_XLOCALE_H=1
+C =			c
+C_COMPILER =		cc
+C_FLAGS =		$(COMPILE_OPTS)
+CPP =			cpp
+CPLUSPLUS_COMPILER =	c++
+CPLUSPLUS_FLAGS =	$(COMPILE_OPTS) -Wall
+OBJ =			o
+LINK =			c++ -o 
+LINK_OPTS =		-L.
+CONSOLE_LINK_OPTS =	$(LINK_OPTS)
+LIBRARY_LINK =		libtool -s -o 
+LIBRARY_LINK_OPTS =	
+LIB_SUFFIX =			a
+LIBS_FOR_CONSOLE_APPLICATION = /usr/lib/libssl.46.Dylib /usr/lib/libcrypto.44.Dylib
+LIBS_FOR_GUI_APPLICATION =
+EXE =
diff --git a/3rdparty/live555/src/config.macosx-no-openssl b/3rdparty/live555/src/config.macosx-no-openssl
new file mode 100644
index 00000000..3b5485fd
--- /dev/null
+++ b/3rdparty/live555/src/config.macosx-no-openssl
@@ -0,0 +1,17 @@
+COMPILE_OPTS =		$(INCLUDES) -I. -I/usr/local/include $(EXTRA_LDFLAGS) -DBSD=1 -O -DSOCKLEN_T=socklen_t -DHAVE_SOCKADDR_LEN=1 -DTIME_BASE=int -DNEED_XLOCALE_H=1 -DNO_OPENSSL=1
+C =			c
+C_COMPILER =		cc
+C_FLAGS =		$(COMPILE_OPTS)
+CPP =			cpp
+CPLUSPLUS_COMPILER =	c++
+CPLUSPLUS_FLAGS =	$(COMPILE_OPTS) -Wall
+OBJ =			o
+LINK =			c++ -o 
+LINK_OPTS =		-L.
+CONSOLE_LINK_OPTS =	$(LINK_OPTS)
+LIBRARY_LINK =		libtool -s -o 
+LIBRARY_LINK_OPTS =	
+LIB_SUFFIX =			a
+LIBS_FOR_CONSOLE_APPLICATION = 
+LIBS_FOR_GUI_APPLICATION =
+EXE =
diff --git a/3rdparty/live555/src/config.mingw b/3rdparty/live555/src/config.mingw
new file mode 100644
index 00000000..29a03c57
--- /dev/null
+++ b/3rdparty/live555/src/config.mingw
@@ -0,0 +1,17 @@
+COMPILE_OPTS =         $(INCLUDES) -I/usr/local/include -I. -O -DSOCKLEN_T=int -DLOCALE_NOT_USED
+C =                    c
+C_COMPILER =           $(CC)
+C_FLAGS =              $(COMPILE_OPTS) -DUSE_OUR_BZERO=1 -D__MINGW32__
+CPP =                  cpp
+CPLUSPLUS_COMPILER =   $(CXX)
+CPLUSPLUS_FLAGS =      $(COMPILE_OPTS) -D__MINGW32__ -Wall -Wno-deprecated
+OBJ =                  o
+LINK =                 $(CXX) -o 
+LINK_OPTS =            -L.
+CONSOLE_LINK_OPTS =    $(LINK_OPTS)
+LIBRARY_LINK =         $(LD) -o 
+LIBRARY_LINK_OPTS =    $(LINK_OPTS) -r -Bstatic
+LIB_SUFFIX =                   a
+LIBS_FOR_CONSOLE_APPLICATION = -lws2_32 -lssl -lcrypto
+LIBS_FOR_GUI_APPLICATION = -lws2_32
+EXE = .exe
diff --git a/3rdparty/live555/src/config.openbsd b/3rdparty/live555/src/config.openbsd
new file mode 100644
index 00000000..7fa50a35
--- /dev/null
+++ b/3rdparty/live555/src/config.openbsd
@@ -0,0 +1,18 @@
+.SUFFIXES: .cpp
+COMPILE_OPTS =		$(INCLUDES) -I/usr/local/include -I. -DBSD=1 -O -DSOCKLEN_T=socklen_t
+C =			c
+C_COMPILER =		cc
+C_FLAGS =		$(COMPILE_OPTS)
+CPP =			cpp
+CPLUSPLUS_COMPILER =	c++
+CPLUSPLUS_FLAGS =	$(COMPILE_OPTS) -Wall -DAIX=1
+OBJ =			o
+LINK =			c++ -o
+LINK_OPTS =		-L.
+CONSOLE_LINK_OPTS =	$(LINK_OPTS)
+LIBRARY_LINK =		ld -o
+LIBRARY_LINK_OPTS =	$(LINK_OPTS) -r
+LIB_SUFFIX =			a
+LIBS_FOR_CONSOLE_APPLICATION = -lssl -lcrypto
+LIBS_FOR_GUI_APPLICATION =
+EXE =
diff --git a/3rdparty/live555/src/config.qnx4 b/3rdparty/live555/src/config.qnx4
new file mode 100644
index 00000000..52cccdb3
--- /dev/null
+++ b/3rdparty/live555/src/config.qnx4
@@ -0,0 +1,23 @@
+#
+# Requires:
+#  QNX 4.25
+#  Watcom 10.6
+#  TCP/IP 5.0
+#
+COMPILE_OPTS =		$(INCLUDES) -I/usr/local/include -I. -D_QNX4 -DBSD -DSOCKLEN_T=uint32_t -I/usr/watcom/10.6/usr/include
+C =				c
+C_COMPILER =		cc32
+C_FLAGS =		$(COMPILE_OPTS)
+CPP =			cpp
+CPLUSPLUS_COMPILER =	cc32
+CPLUSPLUS_FLAGS =	$(COMPILE_OPTS) -WC,-xs
+OBJ =			o
+LINK =			cc32 -b -M -N30000 -o
+LINK_OPTS =		-l.
+CONSOLE_LINK_OPTS =	$(LINK_OPTS)
+LIBRARY_LINK =		wlib -n -b -c
+LIBRARY_LINK_OPTS =	$(LINK_OPTS)
+LIB_SUFFIX =			lib
+LIBS_FOR_CONSOLE_APPLICATION = -lsocket -lssl -lcrypto
+LIBS_FOR_GUI_APPLICATION = $(LIBS_FOR_CONSOLE_APPLICATION)
+EXE =
diff --git a/3rdparty/live555/src/config.solaris-32bit b/3rdparty/live555/src/config.solaris-32bit
new file mode 100644
index 00000000..9956849c
--- /dev/null
+++ b/3rdparty/live555/src/config.solaris-32bit
@@ -0,0 +1,17 @@
+COMPILE_OPTS =		$(INCLUDES) -I/usr/local/include -I. -O -DSOLARIS -DNEWLOCALE_NOT_USED -DSOCKLEN_T=socklen_t
+C =			c
+C_COMPILER =		cc
+C_FLAGS =		$(COMPILE_OPTS)
+CPP =			cpp
+CPLUSPLUS_COMPILER =	c++
+CPLUSPLUS_FLAGS =	$(COMPILE_OPTS) -Wall
+OBJ =			o
+LINK =			c++ -o
+LINK_OPTS =		-L.
+CONSOLE_LINK_OPTS =	$(LINK_OPTS)
+LIBRARY_LINK =		ld -o
+LIBRARY_LINK_OPTS =	$(LINK_OPTS) -r -dn
+LIB_SUFFIX =			a
+LIBS_FOR_CONSOLE_APPLICATION = -lsocket -lnsl -lssl -lcrypto
+LIBS_FOR_GUI_APPLICATION = $(LIBS_FOR_CONSOLE_APPLICATION)
+EXE =
diff --git a/3rdparty/live555/src/config.solaris-64bit b/3rdparty/live555/src/config.solaris-64bit
new file mode 100644
index 00000000..97f934e8
--- /dev/null
+++ b/3rdparty/live555/src/config.solaris-64bit
@@ -0,0 +1,17 @@
+COMPILE_OPTS =          $(INCLUDES) -m64 -I/usr/local/include -I. -O -DSOLARIS -DNEWLOCALE_NOT_USED -DSOCKLEN_T=socklen_t
+C =                     c
+C_COMPILER =            cc
+C_FLAGS =               $(COMPILE_OPTS)
+CPP =                   cpp
+CPLUSPLUS_COMPILER =    c++
+CPLUSPLUS_FLAGS =       $(COMPILE_OPTS) -Wall
+OBJ =                   o
+LINK =                  c++ -m64 -o 
+LINK_OPTS =             -L.
+CONSOLE_LINK_OPTS =     $(LINK_OPTS)
+LIBRARY_LINK =          ld -o
+LIBRARY_LINK_OPTS =     $(LINK_OPTS) -64 -r -dn
+LIB_SUFFIX =                    a
+LIBS_FOR_CONSOLE_APPLICATION = -lsocket -lnsl -lssl -lcrypto
+LIBS_FOR_GUI_APPLICATION = $(LIBS_FOR_CONSOLE_APPLICATION)
+EXE =
diff --git a/3rdparty/live555/src/config.uClinux b/3rdparty/live555/src/config.uClinux
new file mode 100644
index 00000000..289fcfc2
--- /dev/null
+++ b/3rdparty/live555/src/config.uClinux
@@ -0,0 +1,20 @@
+CROSS_COMPILE=        arc-linux-uclibc-
+COMPILE_OPTS =        $(INCLUDES) -I/usr/local/include -I. -O2 -DSOCKLEN_T=socklen_t -D_LARGEFILE_SOURCE=1 -D_FILE_OFFSET_BITS=64
+C =            c
+C_COMPILER =        $(CROSS_COMPILE)gcc
+CFLAGS +=        $(COMPILE_OPTS)
+C_FLAGS = $(CFLAGS)
+CPP =            cpp
+CPLUSPLUS_COMPILER =    $(CROSS_COMPILE)g++
+CPLUSPLUS_FLAGS =    $(COMPILE_OPTS) -Wall -DBSD=1
+CPLUSPLUS_FLAGS += $(CPPFLAGS) -fexceptions
+OBJ =            o
+LINK =            $(CROSS_COMPILE)g++ -o
+LINK_OPTS =        -L. $(LDFLAGS)
+CONSOLE_LINK_OPTS =    $(LINK_OPTS)
+LIBRARY_LINK =        $(CROSS_COMPILE)ar cr 
+LIBRARY_LINK_OPTS =    
+LIB_SUFFIX =            a
+LIBS_FOR_CONSOLE_APPLICATION = $(CXXLIBS) -lssl -lcrypto
+LIBS_FOR_GUI_APPLICATION = $(LIBS_FOR_CONSOLE_APPLICATION)
+EXE =
diff --git a/3rdparty/live555/src/configure b/3rdparty/live555/src/configure
new file mode 100644
index 00000000..c5f48b74
--- /dev/null
+++ b/3rdparty/live555/src/configure
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+echo "Whoa! This software distribution does NOT use the normal Unix \"configure\" mechanism for generating a Makefile.  For instructions on how to build this software, see <http://www.live555.com/liveMedia/>."
+echo "Also, please make sure that you're using the most up-to-date version of the source code - available from <http://www.live555.com/liveMedia/public/>."
diff --git a/3rdparty/live555/src/fix-makefile b/3rdparty/live555/src/fix-makefile
new file mode 100644
index 00000000..1b4aeca5
--- /dev/null
+++ b/3rdparty/live555/src/fix-makefile
@@ -0,0 +1,26 @@
+#!/bin/sh
+# the next line restarts using tclsh \
+exec tclsh "$0" "$@"
+
+set makefileName [lindex $argv 0]
+set tmpfileName /tmp/rsftmp
+
+set inFid [open $makefileName r]
+set outFid [open $tmpfileName w]
+
+while {![eof $inFid]} {
+	set line [gets $inFid]
+	if {[string match *\)\$* $line]} {
+		set pos [string first \)\$ $line]
+		set prefix [string range $line 0 $pos]
+		incr pos
+		set suffix [string range $line $pos end]
+		set line $prefix\ $suffix
+	}
+
+	puts $outFid $line
+}
+
+close $inFid
+close $outFid
+file rename -force $tmpfileName $makefileName
diff --git a/3rdparty/live555/src/genMakefiles b/3rdparty/live555/src/genMakefiles
new file mode 100644
index 00000000..a139f544
--- /dev/null
+++ b/3rdparty/live555/src/genMakefiles
@@ -0,0 +1,25 @@
+#!/bin/sh
+
+usage() {
+    echo "Usage: $0 <os-platform>"
+    exit 1
+}
+
+if [ $# -ne 1 ]
+then
+    usage $*
+fi
+
+platform=$1
+subdirs="liveMedia groupsock UsageEnvironment BasicUsageEnvironment testProgs mediaServer proxyServer hlsProxy"
+    
+for subdir in $subdirs
+do
+    /bin/rm -f $subdir/Makefile
+    cat $subdir/Makefile.head config.$platform $subdir/Makefile.tail > $subdir/Makefile
+    chmod a-w $subdir/Makefile
+done
+
+/bin/rm -f Makefile
+cat Makefile.head config.$1 Makefile.tail > Makefile
+chmod a-w Makefile
diff --git a/3rdparty/live555/src/genWindowsMakefiles b/3rdparty/live555/src/genWindowsMakefiles
new file mode 100644
index 00000000..5deee122
--- /dev/null
+++ b/3rdparty/live555/src/genWindowsMakefiles
@@ -0,0 +1,41 @@
+#!/bin/sh
+
+cd liveMedia
+/bin/rm -f liveMedia.mak
+/bin/rm -f Makefile
+cat Makefile.head ../win32config Makefile.tail > liveMedia.mak
+
+cd ../groupsock
+/bin/rm -f groupsock.mak
+/bin/rm -f Makefile
+cat Makefile.head ../win32config Makefile.tail > groupsock.mak
+
+cd ../UsageEnvironment
+/bin/rm -f UsageEnvironment.mak
+/bin/rm -f Makefile
+cat Makefile.head ../win32config Makefile.tail > UsageEnvironment.mak
+
+cd ../BasicUsageEnvironment
+/bin/rm -f BasicUsageEnvironment.mak
+/bin/rm -f Makefile
+cat Makefile.head ../win32config Makefile.tail > BasicUsageEnvironment.mak
+
+cd ../testProgs
+/bin/rm -f testProgs.mak
+/bin/rm -f Makefile
+cat Makefile.head ../win32config Makefile.tail > testProgs.mak
+
+cd ../mediaServer
+/bin/rm -f mediaServer.mak
+/bin/rm -f Makefile
+cat Makefile.head ../win32config Makefile.tail > mediaServer.mak
+
+cd ../proxyServer
+/bin/rm -f proxyServer.mak
+/bin/rm -f Makefile
+cat Makefile.head ../win32config Makefile.tail > proxyServer.mak
+
+cd ../hlsProxy
+/bin/rm -f hlsProxy.mak
+/bin/rm -f Makefile
+cat Makefile.head ../win32config Makefile.tail > hlsProxy.mak
diff --git a/3rdparty/live555/src/genWindowsMakefiles.cmd b/3rdparty/live555/src/genWindowsMakefiles.cmd
new file mode 100644
index 00000000..3d1c27c7
--- /dev/null
+++ b/3rdparty/live555/src/genWindowsMakefiles.cmd
@@ -0,0 +1,30 @@
+@Echo OFF
+SETLOCAL
+for %%I in (%0) do %%~dI
+for %%I in (%0) do cd "%%~pI"
+cd liveMedia
+del /Q liveMedia.mak
+type Makefile.head ..\win32config Makefile.tail > liveMedia.mak
+cd ../groupsock
+del /Q groupsock.mak
+type Makefile.head ..\win32config Makefile.tail > groupsock.mak
+cd ../UsageEnvironment
+del /Q UsageEnvironment.mak
+type Makefile.head ..\win32config Makefile.tail > UsageEnvironment.mak
+cd ../BasicUsageEnvironment
+del /Q BasicUsageEnvironment.mak
+type Makefile.head ..\win32config Makefile.tail > BasicUsageEnvironment.mak
+cd ../testProgs
+del /Q testProgs.mak
+type Makefile.head ..\win32config Makefile.tail > testProgs.mak
+cd ../mediaServer
+del /Q mediaServer.mak
+type Makefile.head ..\win32config Makefile.tail > mediaServer.mak
+cd ../proxyServer
+del /Q proxyServer.mak
+type Makefile.head ..\win32config Makefile.tail > proxyServer.mak
+cd ../hlsProxy
+del /Q hlsProxy.mak
+type Makefile.head ..\win32config Makefile.tail > hlsProxy.mak
+
+ENDLOCAL
diff --git a/3rdparty/live555/src/groupsock/GroupEId.cpp b/3rdparty/live555/src/groupsock/GroupEId.cpp
new file mode 100644
index 00000000..bfd7f793
--- /dev/null
+++ b/3rdparty/live555/src/groupsock/GroupEId.cpp
@@ -0,0 +1,49 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// Copyright (c) 1996-2022, Live Networks, Inc.  All rights reserved
+// "Group Endpoint Id"
+// Implementation
+
+#include "GroupEId.hh"
+
+GroupEId::GroupEId(struct sockaddr_storage const &groupAddr, portNumBits portNum, u_int8_t ttl) {
+    init(groupAddr, nullAddress(), portNum, ttl);
+}
+
+GroupEId::GroupEId(struct sockaddr_storage const &groupAddr, struct sockaddr_storage const &sourceFilterAddr, portNumBits portNum) {
+    init(groupAddr, sourceFilterAddr, portNum, 255);
+}
+
+GroupEId::GroupEId() {
+    init(nullAddress(), nullAddress(), 0, 255);
+}
+
+Boolean GroupEId::isSSM() const {
+    // We're a SSM group if "fSourceFilterAddress" is not a 'null' address:
+    return !addressIsNull(fSourceFilterAddress);
+}
+
+portNumBits GroupEId::portNum() const {
+    return ::portNum(fGroupAddress);
+}
+
+void GroupEId::init(struct sockaddr_storage const &groupAddr, struct sockaddr_storage const &sourceFilterAddr, portNumBits portNum, u_int8_t ttl) {
+    fGroupAddress = groupAddr;
+    setPortNum(fGroupAddress, portNum);
+    fSourceFilterAddress = sourceFilterAddr;
+
+    fTTL = ttl;
+}
diff --git a/3rdparty/live555/src/groupsock/Groupsock.cpp b/3rdparty/live555/src/groupsock/Groupsock.cpp
new file mode 100644
index 00000000..9049a58b
--- /dev/null
+++ b/3rdparty/live555/src/groupsock/Groupsock.cpp
@@ -0,0 +1,515 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// 'Group sockets'
+// Implementation
+
+#include "Groupsock.hh"
+#include "GroupsockHelper.hh"
+
+#ifndef NO_SSTREAM
+#include <sstream>
+#endif
+#include <stdio.h>
+
+///////// OutputSocket //////////
+
+OutputSocket::OutputSocket(UsageEnvironment &env, int family)
+    : Socket(env, 0 /* let kernel choose port */, family), fSourcePort(0), fLastSentTTL(256 /*hack: a deliberately invalid value*/) {}
+
+OutputSocket::OutputSocket(UsageEnvironment &env, Port port, int family)
+    : Socket(env, port, family), fSourcePort(0), fLastSentTTL(256 /*hack: a deliberately invalid value*/) {}
+
+OutputSocket::~OutputSocket() {}
+
+Boolean OutputSocket::write(struct sockaddr_storage const &addressAndPort, u_int8_t ttl, unsigned char *buffer, unsigned bufferSize) {
+    if((unsigned)ttl == fLastSentTTL) {
+        // Optimization: Don't do a 'set TTL' system call again
+        if(!writeSocket(env(), socketNum(), addressAndPort, buffer, bufferSize))
+            return False;
+    }
+    else {
+        if(!writeSocket(env(), socketNum(), addressAndPort, ttl, buffer, bufferSize))
+            return False;
+        fLastSentTTL = (unsigned)ttl;
+    }
+
+    if(sourcePortNum() == 0) {
+        // Now that we've sent a packet, we can find out what the
+        // kernel chose as our ephemeral source port number:
+        if(!getSourcePort(env(), socketNum(), addressAndPort.ss_family, fSourcePort)) {
+            if(DebugLevel >= 1)
+                env() << *this << ": failed to get source port: " << env().getResultMsg() << "\n";
+            return False;
+        }
+    }
+
+    return True;
+}
+
+// By default, we don't do reads:
+Boolean OutputSocket ::handleRead(unsigned char * /*buffer*/, unsigned /*bufferMaxSize*/, unsigned & /*bytesRead*/,
+                                  struct sockaddr_storage & /*fromAddressAndPort*/) {
+    return True;
+}
+
+///////// destRecord //////////
+
+destRecord ::destRecord(struct sockaddr_storage const &addr, Port const &port, u_int8_t ttl, unsigned sessionId, destRecord *next)
+    : fNext(next), fGroupEId(addr, port.num(), ttl), fSessionId(sessionId) {}
+
+destRecord::~destRecord() {
+    delete fNext;
+}
+
+///////// Groupsock //////////
+
+NetInterfaceTrafficStats Groupsock::statsIncoming;
+NetInterfaceTrafficStats Groupsock::statsOutgoing;
+
+// Constructor for a source-independent multicast group
+Groupsock::Groupsock(UsageEnvironment &env, struct sockaddr_storage const &groupAddr, Port port, u_int8_t ttl)
+    : OutputSocket(env, port, groupAddr.ss_family), fDests(new destRecord(groupAddr, port, ttl, 0, NULL)), fIncomingGroupEId(groupAddr, port.num(), ttl) {
+    if(!socketJoinGroup(env, socketNum(), groupAddr)) {
+        if(DebugLevel >= 1) {
+            env << *this << ": failed to join group: " << env.getResultMsg() << "\n";
+        }
+    }
+
+    // Make sure we can get our source address:
+    if(!weHaveAnIPAddress(env)) {
+        if(DebugLevel >= 0) {  // this is a fatal error
+            env << "Unable to determine our source address: " << env.getResultMsg() << "\n";
+        }
+    }
+
+    if(DebugLevel >= 2)
+        env << *this << ": created\n";
+}
+
+// Constructor for a source-specific multicast group
+Groupsock::Groupsock(UsageEnvironment &env, struct sockaddr_storage const &groupAddr, struct sockaddr_storage const &sourceFilterAddr, Port port)
+    : OutputSocket(env, port, groupAddr.ss_family),
+      fDests(new destRecord(groupAddr, port, 255, 0, NULL)),
+      fIncomingGroupEId(groupAddr, sourceFilterAddr, port.num()) {
+    // First try a SSM join.  If that fails, try a regular join:
+    if(!socketJoinGroupSSM(env, socketNum(), groupAddr, sourceFilterAddr)) {
+        if(DebugLevel >= 3) {
+            env << *this << ": SSM join failed: " << env.getResultMsg();
+            env << " - trying regular join instead\n";
+        }
+        if(!socketJoinGroup(env, socketNum(), groupAddr)) {
+            if(DebugLevel >= 1) {
+                env << *this << ": failed to join group: " << env.getResultMsg() << "\n";
+            }
+        }
+    }
+
+    if(DebugLevel >= 2)
+        env << *this << ": created\n";
+}
+
+Groupsock::~Groupsock() {
+    if(isSSM()) {
+        if(!socketLeaveGroupSSM(env(), socketNum(), groupAddress(), sourceFilterAddress())) {
+            socketLeaveGroup(env(), socketNum(), groupAddress());
+        }
+    }
+    else {
+        socketLeaveGroup(env(), socketNum(), groupAddress());
+    }
+
+    delete fDests;
+
+    if(DebugLevel >= 2)
+        env() << *this << ": deleting\n";
+}
+
+destRecord *Groupsock ::createNewDestRecord(struct sockaddr_storage const &addr, Port const &port, u_int8_t ttl, unsigned sessionId, destRecord *next) {
+    // Default implementation:
+    return new destRecord(addr, port, ttl, sessionId, next);
+}
+
+void Groupsock::changeDestinationParameters(struct sockaddr_storage const &newDestAddr, Port newDestPort, int newDestTTL, unsigned sessionId) {
+    destRecord *dest;
+    for(dest = fDests; dest != NULL && dest->fSessionId != sessionId; dest = dest->fNext) {
+    }
+
+    if(dest == NULL) {  // There's no existing 'destRecord' for this "sessionId"; add a new one:
+        fDests = createNewDestRecord(newDestAddr, newDestPort, newDestTTL, sessionId, fDests);
+        return;
+    }
+
+    // "dest" is an existing 'destRecord' for this "sessionId"; change its values to the new ones:
+    struct sockaddr_storage destAddr = dest->fGroupEId.groupAddress();
+    if(!addressIsNull(newDestAddr)) {
+        // Replace "destAddr" with "newDestAddr"
+        if(!(newDestAddr == destAddr) && IsMulticastAddress(newDestAddr)) {
+            // If the new destination is a multicast address, then we assume that
+            // we want to join it also.  (If this is not in fact the case, then
+            // call "multicastSendOnly()" afterwards.)
+            socketLeaveGroup(env(), socketNum(), destAddr);
+            socketJoinGroup(env(), socketNum(), newDestAddr);
+        }
+        destAddr = newDestAddr;
+    }
+
+    portNumBits destPortNum = dest->fGroupEId.portNum();
+    if(newDestPort.num() != 0) {
+        // Replace "destPort" with "newDestPort"
+        if(newDestPort.num() != destPortNum && IsMulticastAddress(destAddr)) {
+            // Also bind to the new port number:
+            changePort(newDestPort);
+            // And rejoin the multicast group:
+            socketJoinGroup(env(), socketNum(), destAddr);
+        }
+        destPortNum = newDestPort.num();
+    }
+
+    u_int8_t destTTL = ttl();
+    if(newDestTTL != ~0) {
+        // Replace "destTTL" with "newDestTTL"
+        destTTL = (u_int8_t)newDestTTL;
+    }
+
+    dest->fGroupEId = GroupEId(destAddr, destPortNum, destTTL);
+
+    // Finally, remove any other 'destRecord's that might also have this "sessionId":
+    removeDestinationFrom(dest->fNext, sessionId);
+}
+
+unsigned Groupsock ::lookupSessionIdFromDestination(struct sockaddr_storage const &destAddrAndPort) const {
+    destRecord *dest = lookupDestRecordFromDestination(destAddrAndPort);
+    if(dest == NULL)
+        return 0;
+
+    return dest->fSessionId;
+}
+
+void Groupsock::addDestination(struct sockaddr_storage const &addr, Port const &port, unsigned sessionId) {
+    // Default implementation:
+    // If there's no existing 'destRecord' with the same "addr", "port", and "sessionId", add a new one:
+    for(destRecord *dest = fDests; dest != NULL; dest = dest->fNext) {
+        if(dest->fSessionId == sessionId && dest->fGroupEId.groupAddress() == addr && dest->fGroupEId.portNum() == port.num()) {
+            return;
+        }
+    }
+
+    fDests = createNewDestRecord(addr, port, 255, sessionId, fDests);
+}
+
+void Groupsock::removeDestination(unsigned sessionId) {
+    // Default implementation:
+    removeDestinationFrom(fDests, sessionId);
+}
+
+void Groupsock::removeAllDestinations() {
+    delete fDests;
+    fDests = NULL;
+}
+
+void Groupsock::multicastSendOnly() {
+    // We disable this code for now, because - on some systems - leaving the multicast group seems to cause sent packets
+    // to not be received by other applications (at least, on the same host).
+#if 0
+  socketLeaveGroup(env(), socketNum(), groupAddress(r);
+  for (destRecord* dests = fDests; dests != NULL; dests = dests->fNext) {
+    socketLeaveGroup(env(), socketNum(), dests->fGroupEId.groupAddress(r);
+  }
+#endif
+}
+
+Boolean Groupsock::output(UsageEnvironment &env, unsigned char *buffer, unsigned bufferSize) {
+    do {
+        // First, do the datagram send, to each destination:
+        Boolean writeSuccess = True;
+        for(destRecord *dests = fDests; dests != NULL; dests = dests->fNext) {
+            if(!write(dests->fGroupEId.groupAddress(), dests->fGroupEId.ttl(), buffer, bufferSize)) {
+                writeSuccess = False;
+                break;
+            }
+        }
+        if(!writeSuccess)
+            break;
+        statsOutgoing.countPacket(bufferSize);
+        statsGroupOutgoing.countPacket(bufferSize);
+
+        if(DebugLevel >= 3) {
+            env << *this << ": wrote " << bufferSize << " bytes, ttl " << (unsigned)ttl() << "\n";
+        }
+        return True;
+    } while(0);
+
+    if(DebugLevel >= 0) {  // this is a fatal error
+        UsageEnvironment::MsgString msg = strDup(env.getResultMsg());
+        env.setResultMsg("Groupsock write failed: ", msg);
+        delete[](char *) msg;
+    }
+    return False;
+}
+
+Boolean Groupsock::handleRead(unsigned char *buffer, unsigned bufferMaxSize, unsigned &bytesRead, struct sockaddr_storage &fromAddressAndPort) {
+    bytesRead = 0;  // initially
+
+    int numBytes = readSocket(env(), socketNum(), buffer, bufferMaxSize, fromAddressAndPort);
+    if(numBytes < 0) {
+        if(DebugLevel >= 0) {  // this is a fatal error
+            UsageEnvironment::MsgString msg = strDup(env().getResultMsg());
+            env().setResultMsg("Groupsock read failed: ", msg);
+            delete[](char *) msg;
+        }
+        return False;
+    }
+
+    // If we're a SSM group, make sure the source address matches:
+    if(isSSM() && !(fromAddressAndPort == sourceFilterAddress()))
+        return True;
+
+    // We'll handle this data.
+    bytesRead = numBytes;
+
+    if(!wasLoopedBackFromUs(env(), fromAddressAndPort)) {
+        statsIncoming.countPacket(bytesRead);
+        statsGroupIncoming.countPacket(bytesRead);
+    }
+    if(DebugLevel >= 3) {
+        env() << *this << ": read " << bytesRead << " bytes from " << AddressString(fromAddressAndPort).val() << ", port " << ntohs(portNum(fromAddressAndPort))
+              << "\n";
+    }
+
+    return True;
+}
+
+Boolean Groupsock::wasLoopedBackFromUs(UsageEnvironment &env, struct sockaddr_storage const &fromAddressAndPort) {
+    if(fromAddressAndPort.ss_family != AF_INET)
+        return False;  // later update for IPv6
+
+    struct sockaddr_in const &fromAddressAndPort4 = (struct sockaddr_in const &)fromAddressAndPort;
+    if(fromAddressAndPort4.sin_addr.s_addr == ourIPv4Address(env) || fromAddressAndPort4.sin_addr.s_addr == 0x7F000001 /*127.0.0.1*/) {
+        if(portNum(fromAddressAndPort) == sourcePortNum()) {
+#ifdef DEBUG_LOOPBACK_CHECKING
+            if(DebugLevel >= 3) {
+                env() << *this << ": got looped-back packet\n";
+            }
+#endif
+            return True;
+        }
+    }
+
+    return False;
+}
+
+destRecord *Groupsock ::lookupDestRecordFromDestination(struct sockaddr_storage const &targetAddrAndPort) const {
+    for(destRecord *dest = fDests; dest != NULL; dest = dest->fNext) {
+        if(dest->fGroupEId.groupAddress() == targetAddrAndPort && dest->fGroupEId.portNum() == portNum(targetAddrAndPort)) {
+            return dest;
+        }
+    }
+
+    return NULL;
+}
+
+void Groupsock::removeDestinationFrom(destRecord *&dests, unsigned sessionId) {
+    destRecord **destsPtr = &dests;
+    while(*destsPtr != NULL) {
+        if(sessionId == (*destsPtr)->fSessionId) {
+            // Remove the record pointed to by *destsPtr :
+            destRecord *next   = (*destsPtr)->fNext;
+            (*destsPtr)->fNext = NULL;
+            delete(*destsPtr);
+            *destsPtr = next;
+        }
+        else {
+            destsPtr = &((*destsPtr)->fNext);
+        }
+    }
+}
+
+UsageEnvironment &operator<<(UsageEnvironment &s, const Groupsock &g) {
+    UsageEnvironment &s1 = s << timestampString() << " Groupsock(" << g.socketNum() << ": " << AddressString(g.groupAddress()).val() << ", " << g.port()
+                             << ", ";
+    if(g.isSSM()) {
+        return s1 << "SSM source: " << AddressString(g.sourceFilterAddress()).val() << ")";
+    }
+    else {
+        return s1 << (unsigned)(g.ttl()) << ")";
+    }
+}
+
+////////// GroupsockLookupTable //////////
+
+// A hash table used to index Groupsocks by socket number.
+
+static HashTable *&getSocketTable(UsageEnvironment &env) {
+    _groupsockPriv *priv = groupsockPriv(env);
+    if(priv->socketTable == NULL) {  // We need to create it
+        priv->socketTable = HashTable::create(ONE_WORD_HASH_KEYS);
+    }
+    return priv->socketTable;
+}
+
+static Boolean unsetGroupsockBySocket(Groupsock const *groupsock) {
+    do {
+        if(groupsock == NULL)
+            break;
+
+        int sock = groupsock->socketNum();
+        // Make sure "sock" is in bounds:
+        if(sock < 0)
+            break;
+
+        HashTable *&sockets = getSocketTable(groupsock->env());
+
+        Groupsock *gs = (Groupsock *)sockets->Lookup((char *)(long)sock);
+        if(gs == NULL || gs != groupsock)
+            break;
+        sockets->Remove((char *)(long)sock);
+
+        if(sockets->IsEmpty()) {
+            // We can also delete the table (to reclaim space):
+            delete sockets;
+            sockets = NULL;
+            reclaimGroupsockPriv(gs->env());
+        }
+
+        return True;
+    } while(0);
+
+    return False;
+}
+
+static Boolean setGroupsockBySocket(UsageEnvironment &env, int sock, Groupsock *groupsock) {
+    do {
+        // Make sure the "sock" parameter is in bounds:
+        if(sock < 0) {
+            char buf[100];
+            sprintf(buf, "trying to use bad socket (%d)", sock);
+            env.setResultMsg(buf);
+            break;
+        }
+
+        HashTable *sockets = getSocketTable(env);
+
+        // Make sure we're not replacing an existing Groupsock (although that shouldn't happen)
+        Boolean alreadyExists = (sockets->Lookup((char *)(long)sock) != 0);
+        if(alreadyExists) {
+            char buf[100];
+            sprintf(buf, "Attempting to replace an existing socket (%d)", sock);
+            env.setResultMsg(buf);
+            break;
+        }
+
+        sockets->Add((char *)(long)sock, groupsock);
+        return True;
+    } while(0);
+
+    return False;
+}
+
+static Groupsock *getGroupsockBySocket(UsageEnvironment &env, int sock) {
+    do {
+        // Make sure the "sock" parameter is in bounds:
+        if(sock < 0)
+            break;
+
+        HashTable *sockets = getSocketTable(env);
+        return (Groupsock *)sockets->Lookup((char *)(long)sock);
+    } while(0);
+
+    return NULL;
+}
+
+Groupsock *GroupsockLookupTable::Fetch(UsageEnvironment &env, struct sockaddr_storage const &groupAddress, Port port, u_int8_t ttl, Boolean &isNew) {
+    isNew = False;
+    Groupsock *groupsock;
+    do {
+        groupsock = (Groupsock *)fTable.Lookup(groupAddress, port);
+        if(groupsock == NULL) {  // we need to create one:
+            groupsock = AddNew(env, groupAddress, nullAddress(), port, ttl);
+            if(groupsock == NULL)
+                break;
+            isNew = True;
+        }
+    } while(0);
+
+    return groupsock;
+}
+
+Groupsock *GroupsockLookupTable::Fetch(UsageEnvironment &env, struct sockaddr_storage const &groupAddress, struct sockaddr_storage const &sourceFilterAddr,
+                                       Port port, Boolean &isNew) {
+    isNew = False;
+    Groupsock *groupsock;
+    do {
+        groupsock = (Groupsock *)fTable.Lookup(groupAddress, sourceFilterAddr, port);
+        if(groupsock == NULL) {  // we need to create one:
+            groupsock = AddNew(env, groupAddress, sourceFilterAddr, port, 0);
+            if(groupsock == NULL)
+                break;
+            isNew = True;
+        }
+    } while(0);
+
+    return groupsock;
+}
+
+Groupsock *GroupsockLookupTable::Lookup(struct sockaddr_storage const &groupAddress, Port port) {
+    return (Groupsock *)fTable.Lookup(groupAddress, port);
+}
+
+Groupsock *GroupsockLookupTable::Lookup(struct sockaddr_storage const &groupAddress, struct sockaddr_storage const &sourceFilterAddr, Port port) {
+    return (Groupsock *)fTable.Lookup(groupAddress, sourceFilterAddr, port);
+}
+
+Groupsock *GroupsockLookupTable::Lookup(UsageEnvironment &env, int sock) {
+    return getGroupsockBySocket(env, sock);
+}
+
+Boolean GroupsockLookupTable::Remove(Groupsock const *groupsock) {
+    unsetGroupsockBySocket(groupsock);
+
+    return fTable.Remove(groupsock->groupAddress(), groupsock->sourceFilterAddress(), groupsock->port());
+}
+
+Groupsock *GroupsockLookupTable::AddNew(UsageEnvironment &env, struct sockaddr_storage const &groupAddress, struct sockaddr_storage const &sourceFilterAddress,
+                                        Port port, u_int8_t ttl) {
+    Groupsock *groupsock;
+    do {
+        if(addressIsNull(sourceFilterAddress)) {
+            // regular, ISM groupsock
+            groupsock = new Groupsock(env, groupAddress, port, ttl);
+        }
+        else {
+            // SSM groupsock
+            groupsock = new Groupsock(env, groupAddress, sourceFilterAddress, port);
+        }
+
+        if(groupsock == NULL || groupsock->socketNum() < 0)
+            break;
+
+        if(!setGroupsockBySocket(env, groupsock->socketNum(), groupsock))
+            break;
+
+        fTable.Add(groupAddress, sourceFilterAddress, port, (void *)groupsock);
+    } while(0);
+
+    return groupsock;
+}
+
+GroupsockLookupTable::Iterator::Iterator(GroupsockLookupTable &groupsocks) : fIter(AddressPortLookupTable::Iterator(groupsocks.fTable)) {}
+
+Groupsock *GroupsockLookupTable::Iterator::next() {
+    return (Groupsock *)fIter.next();
+};
diff --git a/3rdparty/live555/src/groupsock/GroupsockHelper.cpp b/3rdparty/live555/src/groupsock/GroupsockHelper.cpp
new file mode 100644
index 00000000..6fdfe1c5
--- /dev/null
+++ b/3rdparty/live555/src/groupsock/GroupsockHelper.cpp
@@ -0,0 +1,1102 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "groupsock"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// Helper routines to implement 'group sockets'
+// Implementation
+
+#include "GroupsockHelper.hh"
+
+#if(defined(__WIN32__) || defined(_WIN32)) && !defined(__MINGW32__)
+#include <time.h>
+extern "C" int initializeWinsockIfNecessary();
+#else
+#include <cstdarg>
+#include <ctime>
+#include <sys/time.h>
+#include <sys/socket.h>
+#if !defined(_WIN32)
+#include <netinet/tcp.h>
+#ifdef __ANDROID_NDK__
+#include <android/ndk-version.h>
+#define ANDROID_OLD_NDK __NDK_MAJOR__ < 17
+#endif
+#endif
+#include <fcntl.h>
+#define initializeWinsockIfNecessary() 1
+#endif
+#if defined(__WIN32__) || defined(_WIN32) || defined(_QNX4)
+#else
+#include <csignal>
+#define USE_SIGNALS 1
+#endif
+#ifndef NO_GETIFADDRS
+#include <ifaddrs.h>
+#include <net/if.h>
+
+#if defined(ANDROID) && __ANDROID_API__ < 24
+#ifdef __cplusplus
+extern "C" {
+#endif
+#include "ifaddrs_add.h"
+#ifdef __cplusplus
+}
+#endif
+#endif
+
+#endif
+#include <cstdio>
+
+// By default, use INADDR_ANY for the sending and receiving interfaces (IPv4 only):
+ipv4AddressBits SendingInterfaceAddr   = INADDR_ANY;
+ipv4AddressBits ReceivingInterfaceAddr = INADDR_ANY;
+
+static void socketErr(UsageEnvironment &env, char const *errorMsg) {
+    env.setResultErrMsg(errorMsg);
+}
+
+NoReuse::NoReuse(UsageEnvironment &env) : fEnv(env) {
+    groupsockPriv(fEnv)->reuseFlag = 0;
+}
+
+NoReuse::~NoReuse() {
+    groupsockPriv(fEnv)->reuseFlag = 1;
+    reclaimGroupsockPriv(fEnv);
+}
+
+_groupsockPriv *groupsockPriv(UsageEnvironment &env) {
+    if(env.groupsockPriv == NULL) {  // We need to create it
+        _groupsockPriv *result = new _groupsockPriv;
+        result->socketTable    = NULL;
+        result->reuseFlag      = 1;  // default value => allow reuse of socket numbers
+        env.groupsockPriv      = result;
+    }
+    return (_groupsockPriv *)(env.groupsockPriv);
+}
+
+void reclaimGroupsockPriv(UsageEnvironment &env) {
+    _groupsockPriv *priv = (_groupsockPriv *)(env.groupsockPriv);
+    if(priv->socketTable == NULL && priv->reuseFlag == 1 /*default value*/) {
+        // We can delete the structure (to save space); it will get created again, if needed:
+        delete priv;
+        env.groupsockPriv = NULL;
+    }
+}
+
+static int createSocket(int domain, int type) {
+    // Call "socket()" to create a socket of the specified type.
+    // But also set it to have the 'close on exec' property (if we can)
+    int sock;
+
+    // In case PF_INET(6) is not defined to be AF_INET(6):
+    int const domain2 = domain == AF_INET ? PF_INET : domain == AF_INET6 ? PF_INET6 : domain;
+
+#ifdef SOCK_CLOEXEC
+    sock = socket(domain2, type | SOCK_CLOEXEC, 0);
+    if(sock != -1 || errno != EINVAL)
+        return sock;
+        // An "errno" of EINVAL likely means that the system wasn't happy with the SOCK_CLOEXEC; fall through and try again without it:
+#endif
+
+    sock = socket(domain2, type, 0);
+#ifdef FD_CLOEXEC
+    if(sock != -1)
+        fcntl(sock, F_SETFD, FD_CLOEXEC);
+#endif
+    return sock;
+}
+
+int setupDatagramSocket(UsageEnvironment &env, Port port, int domain) {
+    if(!initializeWinsockIfNecessary()) {
+        socketErr(env, "Failed to initialize 'winsock': ");
+        return -1;
+    }
+
+    int newSocket = createSocket(domain, SOCK_DGRAM);
+    if(newSocket < 0) {
+        socketErr(env, "unable to create datagram socket: ");
+        return newSocket;
+    }
+
+    int reuseFlag = groupsockPriv(env)->reuseFlag;
+    reclaimGroupsockPriv(env);
+    if(setsockopt(newSocket, SOL_SOCKET, SO_REUSEADDR, (const char *)&reuseFlag, sizeof reuseFlag) < 0) {
+        socketErr(env, "setsockopt(SO_REUSEADDR) error: ");
+        closeSocket(newSocket);
+        return -1;
+    }
+
+#if defined(__WIN32__) || defined(_WIN32)
+    // Windoze doesn't properly handle SO_REUSEPORT or IP_MULTICAST_LOOP
+#else
+#ifdef SO_REUSEPORT
+    if(setsockopt(newSocket, SOL_SOCKET, SO_REUSEPORT, (const char *)&reuseFlag, sizeof reuseFlag) < 0) {
+        socketErr(env, "setsockopt(SO_REUSEPORT) error: ");
+        closeSocket(newSocket);
+        return -1;
+    }
+#endif
+
+#ifdef IP_MULTICAST_LOOP
+    const u_int8_t loop = 1;
+    if(setsockopt(newSocket, domain == AF_INET ? IPPROTO_IP : IPPROTO_IPV6, domain == AF_INET ? IP_MULTICAST_LOOP : IPV6_MULTICAST_LOOP, (const char *)&loop,
+                  sizeof loop)
+       < 0) {
+        if(domain == AF_INET) {  // For some unknown reason, this might not work for IPv6
+            socketErr(env, "setsockopt(IP_MULTICAST_LOOP) error: ");
+            closeSocket(newSocket);
+            return -1;
+        }
+    }
+#endif
+#endif
+
+    if(domain == AF_INET) {
+        // Note: Windoze requires binding, even if the port number is 0
+        ipv4AddressBits addr = INADDR_ANY;
+#if defined(__WIN32__) || defined(_WIN32)
+#else
+        if(port.num() != 0 || ReceivingInterfaceAddr != INADDR_ANY) {
+#endif
+        if(port.num() == 0)
+            addr = ReceivingInterfaceAddr;
+        MAKE_SOCKADDR_IN(name, addr, port.num());
+        if(bind(newSocket, (struct sockaddr *)&name, sizeof name) != 0) {
+            char tmpBuffer[100];
+            sprintf(tmpBuffer, "IPv4 bind() error (port number: %d): ", ntohs(port.num()));
+            socketErr(env, tmpBuffer);
+            closeSocket(newSocket);
+            return -1;
+        }
+#if defined(__WIN32__) || defined(_WIN32)
+#else
+        }
+#endif
+    }
+    else {  // IPv6
+        if(port.num() != 0) {
+            // For IPv6 sockets, we need the IPV6_V6ONLY flag set to 1, otherwise we would not
+            // be able to have an IPv4 socket and an IPv6 socket bound to the same port:
+            int const one = 1;
+            (void)setsockopt(newSocket, IPPROTO_IPV6, IPV6_V6ONLY, (const char *)&one, sizeof one);
+
+            MAKE_SOCKADDR_IN6(name, port.num());
+            if(bind(newSocket, (struct sockaddr *)&name, sizeof name) != 0) {
+                char tmpBuffer[100];
+                sprintf(tmpBuffer, "IPv6 bind() error (port number: %d): ", ntohs(port.num()));
+                socketErr(env, tmpBuffer);
+                closeSocket(newSocket);
+                return -1;
+            }
+        }
+    }
+
+    // Set the sending interface for multicasts, if it's not the default:
+    if(SendingInterfaceAddr != INADDR_ANY) {  // later, fix for IPv6
+        struct in_addr addr;
+        addr.s_addr = SendingInterfaceAddr;
+
+        if(setsockopt(newSocket, domain == AF_INET ? IPPROTO_IP : IPPROTO_IPV6, domain == AF_INET ? IP_MULTICAST_IF : IPV6_MULTICAST_IF, (const char *)&addr,
+                      sizeof addr)
+           < 0) {
+            socketErr(env, "error setting outgoing multicast interface: ");
+            closeSocket(newSocket);
+            return -1;
+        }
+    }
+
+    return newSocket;
+}
+
+Boolean makeSocketNonBlocking(int sock) {
+#if defined(__WIN32__) || defined(_WIN32)
+    unsigned long arg = 1;
+    return ioctlsocket(sock, FIONBIO, &arg) == 0;
+#elif defined(VXWORKS)
+    int arg = 1;
+    return ioctl(sock, FIONBIO, (int)&arg) == 0;
+#else
+    int curFlags = fcntl(sock, F_GETFL, 0);
+    return fcntl(sock, F_SETFL, curFlags | O_NONBLOCK) >= 0;
+#endif
+}
+
+Boolean makeSocketBlocking(int sock, unsigned writeTimeoutInMilliseconds) {
+    Boolean result;
+#if defined(__WIN32__) || defined(_WIN32)
+    unsigned long arg = 0;
+    result            = ioctlsocket(sock, FIONBIO, &arg) == 0;
+#elif defined(VXWORKS)
+    int arg = 0;
+    result  = ioctl(sock, FIONBIO, (int)&arg) == 0;
+#else
+    int curFlags = fcntl(sock, F_GETFL, 0);
+    result       = fcntl(sock, F_SETFL, curFlags & (~O_NONBLOCK)) >= 0;
+#endif
+
+    if(writeTimeoutInMilliseconds > 0) {
+#ifdef SO_SNDTIMEO
+#if defined(__WIN32__) || defined(_WIN32)
+        DWORD msto = (DWORD)writeTimeoutInMilliseconds;
+        setsockopt(sock, SOL_SOCKET, SO_SNDTIMEO, (char *)&msto, sizeof(msto));
+#else
+        struct timeval tv;
+        tv.tv_sec  = writeTimeoutInMilliseconds / 1000;
+        tv.tv_usec = (writeTimeoutInMilliseconds % 1000) * 1000;
+        setsockopt(sock, SOL_SOCKET, SO_SNDTIMEO, (char *)&tv, sizeof tv);
+#endif
+#endif
+    }
+
+    return result;
+}
+
+Boolean setSocketKeepAlive(int sock) {
+#if defined(__WIN32__) || defined(_WIN32)
+    // How do we do this in Windows?  For now, just make this a no-op in Windows:
+#else
+    int const keepalive_enabled = 1;
+    if(setsockopt(sock, SOL_SOCKET, SO_KEEPALIVE, (void *)&keepalive_enabled, sizeof keepalive_enabled) < 0) {
+        return False;
+    }
+
+#ifdef TCP_KEEPIDLE
+    int const keepalive_time = 180;
+    if(setsockopt(sock, IPPROTO_TCP, TCP_KEEPIDLE, (void *)&keepalive_time, sizeof keepalive_time) < 0) {
+        return False;
+    }
+#endif
+
+#ifdef TCP_KEEPCNT
+    int const keepalive_count = 5;
+    if(setsockopt(sock, IPPROTO_TCP, TCP_KEEPCNT, (void *)&keepalive_count, sizeof keepalive_count) < 0) {
+        return False;
+    }
+#endif
+
+#ifdef TCP_KEEPINTVL
+    int const keepalive_interval = 20;
+    if(setsockopt(sock, IPPROTO_TCP, TCP_KEEPINTVL, (void *)&keepalive_interval, sizeof keepalive_interval) < 0) {
+        return False;
+    }
+#endif
+#endif
+
+    return True;
+}
+
+int setupStreamSocket(UsageEnvironment &env, Port port, int domain, Boolean makeNonBlocking, Boolean setKeepAlive) {
+    if(!initializeWinsockIfNecessary()) {
+        socketErr(env, "Failed to initialize 'winsock': ");
+        return -1;
+    }
+
+    int newSocket = createSocket(domain, SOCK_STREAM);
+    if(newSocket < 0) {
+        socketErr(env, "unable to create stream socket: ");
+        return newSocket;
+    }
+
+    int reuseFlag = groupsockPriv(env)->reuseFlag;
+    reclaimGroupsockPriv(env);
+    if(setsockopt(newSocket, SOL_SOCKET, SO_REUSEADDR, (const char *)&reuseFlag, sizeof reuseFlag) < 0) {
+        socketErr(env, "setsockopt(SO_REUSEADDR) error: ");
+        closeSocket(newSocket);
+        return -1;
+    }
+
+    // SO_REUSEPORT doesn't really make sense for TCP sockets, so we
+    // normally don't set them.  However, if you really want to do this
+    // #define REUSE_FOR_TCP
+#ifdef REUSE_FOR_TCP
+#if defined(__WIN32__) || defined(_WIN32)
+    // Windoze doesn't properly handle SO_REUSEPORT
+#else
+#ifdef SO_REUSEPORT
+    if(setsockopt(newSocket, SOL_SOCKET, SO_REUSEPORT, (const char *)&reuseFlag, sizeof reuseFlag) < 0) {
+        socketErr(env, "setsockopt(SO_REUSEPORT) error: ");
+        closeSocket(newSocket);
+        return -1;
+    }
+#endif
+#endif
+#endif
+
+    if(domain == AF_INET) {
+        // Note: Windoze requires binding, even if the port number is 0
+#if defined(__WIN32__) || defined(_WIN32)
+#else
+        if(port.num() != 0 || ReceivingInterfaceAddr != INADDR_ANY) {
+#endif
+        MAKE_SOCKADDR_IN(name, ReceivingInterfaceAddr, port.num());
+        if(bind(newSocket, (struct sockaddr *)&name, sizeof name) != 0) {
+            char tmpBuffer[100];
+            sprintf(tmpBuffer, "IPv4 bind() error (port number: %d): ", ntohs(port.num()));
+            socketErr(env, tmpBuffer);
+            closeSocket(newSocket);
+            return -1;
+        }
+#if defined(__WIN32__) || defined(_WIN32)
+#else
+        }
+#endif
+    }
+    else {  // IPv6
+        if(port.num() != 0) {
+            // For IPv6 sockets, we need the IPV6_V6ONLY flag set to 1, otherwise we would not
+            // be able to have an IPv4 socket and an IPv6 socket bound to the same port:
+            int const one = 1;
+            (void)setsockopt(newSocket, IPPROTO_IPV6, IPV6_V6ONLY, (const char *)&one, sizeof one);
+
+            MAKE_SOCKADDR_IN6(name, port.num());
+            if(bind(newSocket, (struct sockaddr *)&name, sizeof name) != 0) {
+                char tmpBuffer[100];
+                sprintf(tmpBuffer, "IPv6 bind() error (port number: %d): ", ntohs(port.num()));
+                socketErr(env, tmpBuffer);
+                closeSocket(newSocket);
+                return -1;
+            }
+        }
+    }
+
+    if(makeNonBlocking) {
+        if(!makeSocketNonBlocking(newSocket)) {
+            socketErr(env, "failed to make non-blocking: ");
+            closeSocket(newSocket);
+            return -1;
+        }
+    }
+
+    // Set the keep alive mechanism for the TCP socket, to avoid "ghost sockets"
+    //    that remain after an interrupted communication.
+    if(setKeepAlive) {
+        if(!setSocketKeepAlive(newSocket)) {
+            socketErr(env, "failed to set keep alive: ");
+            closeSocket(newSocket);
+            return -1;
+        }
+    }
+
+    return newSocket;
+}
+
+int readSocket(UsageEnvironment &env, int socket, unsigned char *buffer, unsigned bufferSize, struct sockaddr_storage &fromAddress) {
+    SOCKLEN_T addressSize = sizeof fromAddress;
+    int       bytesRead   = recvfrom(socket, (char *)buffer, bufferSize, 0, (struct sockaddr *)&fromAddress,
+                                     reinterpret_cast<socklen_t *>(&addressSize));
+    if(bytesRead < 0) {
+        //##### HACK to work around bugs in Linux and Windows:
+        int err = env.getErrno();
+        if(err == 111 /*ECONNREFUSED (Linux)*/
+#if defined(__WIN32__) || defined(_WIN32)
+           // What a piece of crap Windows is.  Sometimes
+           // recvfrom() returns -1, but with an 'errno' of 0.
+           // This appears not to be a real error; just treat
+           // it as if it were a read of zero bytes, and hope
+           // we don't have to do anything else to 'reset'
+           // this alleged error:
+           || err == 0 || err == EWOULDBLOCK
+#else
+           || err == EAGAIN
+#endif
+           || err == 113 /*EHOSTUNREACH (Linux)*/) {  // Why does Linux return this for datagram sock?
+            return 0;
+        }
+        //##### END HACK
+        socketErr(env, "recvfrom() error: ");
+    }
+    else if(bytesRead == 0) {
+        // "recvfrom()" on a stream socket can return 0 if the remote end has closed the connection.  Treat this as an error:
+        return -1;
+    }
+
+    return bytesRead;
+}
+
+Boolean writeSocket(UsageEnvironment &env, int socket, struct sockaddr_storage const &addressAndPort, u_int8_t ttlArg, unsigned char *buffer,
+                    unsigned bufferSize) {
+    // Before sending, set the socket's TTL (IPv4 only):
+    if(addressAndPort.ss_family == AF_INET) {
+#if defined(__WIN32__) || defined(_WIN32)
+#define TTL_TYPE int
+#else
+#define TTL_TYPE u_int8_t
+#endif
+        TTL_TYPE ttl = (TTL_TYPE)ttlArg;
+        if(setsockopt(socket, IPPROTO_IP, IP_MULTICAST_TTL, (const char *)&ttl, sizeof ttl) < 0) {
+            socketErr(env, "setsockopt(IP_MULTICAST_TTL) error: ");
+            return False;
+        }
+    }
+
+    return writeSocket(env, socket, addressAndPort, buffer, bufferSize);
+}
+
+Boolean writeSocket(UsageEnvironment &env, int socket, struct sockaddr_storage const &addressAndPort, unsigned char *buffer, unsigned bufferSize) {
+    do {
+        SOCKLEN_T dest_len  = addressSize(addressAndPort);
+        int       bytesSent = sendto(socket, (char *)buffer, bufferSize, 0, (struct sockaddr const *)&addressAndPort, dest_len);
+        if(bytesSent != (int)bufferSize) {
+            char tmpBuf[100];
+            sprintf(tmpBuf, "writeSocket(%d), sendTo() error: wrote %d bytes instead of %u: ", socket, bytesSent, bufferSize);
+            socketErr(env, tmpBuf);
+            break;
+        }
+
+        return True;
+    } while(0);
+
+    return False;
+}
+
+void ignoreSigPipeOnSocket(int socketNum) {
+#ifdef USE_SIGNALS
+#ifdef SO_NOSIGPIPE
+    int set_option = 1;
+    setsockopt(socketNum, SOL_SOCKET, SO_NOSIGPIPE, &set_option, sizeof set_option);
+#else
+    signal(SIGPIPE, SIG_IGN);
+#endif
+#endif
+}
+
+static unsigned getBufferSize(UsageEnvironment &env, int bufOptName, int socket) {
+    unsigned  curSize;
+    SOCKLEN_T sizeSize = sizeof curSize;
+    if(getsockopt(socket, SOL_SOCKET, bufOptName, (char *)&curSize, reinterpret_cast<socklen_t *>(&sizeSize)) < 0) {
+        socketErr(env, "getBufferSize() error: ");
+        return 0;
+    }
+
+    return curSize;
+}
+unsigned getSendBufferSize(UsageEnvironment &env, int socket) {
+    return getBufferSize(env, SO_SNDBUF, socket);
+}
+unsigned getReceiveBufferSize(UsageEnvironment &env, int socket) {
+    return getBufferSize(env, SO_RCVBUF, socket);
+}
+
+static unsigned setBufferTo(UsageEnvironment &env, int bufOptName, int socket, unsigned requestedSize) {
+    SOCKLEN_T sizeSize = sizeof requestedSize;
+    setsockopt(socket, SOL_SOCKET, bufOptName, (char *)&requestedSize, sizeSize);
+
+    // Get and return the actual, resulting buffer size:
+    return getBufferSize(env, bufOptName, socket);
+}
+unsigned setSendBufferTo(UsageEnvironment &env, int socket, unsigned requestedSize) {
+    return setBufferTo(env, SO_SNDBUF, socket, requestedSize);
+}
+unsigned setReceiveBufferTo(UsageEnvironment &env, int socket, unsigned requestedSize) {
+    return setBufferTo(env, SO_RCVBUF, socket, requestedSize);
+}
+
+static unsigned increaseBufferTo(UsageEnvironment &env, int bufOptName, int socket, unsigned requestedSize) {
+    // First, get the current buffer size.  If it's already at least
+    // as big as what we're requesting, do nothing.
+    unsigned curSize = getBufferSize(env, bufOptName, socket);
+
+    // Next, try to increase the buffer to the requested size,
+    // or to some smaller size, if that's not possible:
+    while(requestedSize > curSize) {
+        SOCKLEN_T sizeSize = sizeof requestedSize;
+        if(setsockopt(socket, SOL_SOCKET, bufOptName, (char *)&requestedSize, sizeSize) >= 0) {
+            // success
+            return requestedSize;
+        }
+        requestedSize = (requestedSize + curSize) / 2;
+    }
+
+    return getBufferSize(env, bufOptName, socket);
+}
+unsigned increaseSendBufferTo(UsageEnvironment &env, int socket, unsigned requestedSize) {
+    return increaseBufferTo(env, SO_SNDBUF, socket, requestedSize);
+}
+unsigned increaseReceiveBufferTo(UsageEnvironment &env, int socket, unsigned requestedSize) {
+    return increaseBufferTo(env, SO_RCVBUF, socket, requestedSize);
+}
+
+static void clearMulticastAllSocketOption(int socket, int domain) {
+#ifdef IP_MULTICAST_ALL
+    // This option is defined in modern versions of Linux to overcome a bug in the Linux kernel's default behavior.
+    // When set to 0, it ensures that we receive only packets that were sent to the specified IP multicast address,
+    // even if some other process on the same system has joined a different multicast group with the same port number.
+    int multicastAll = 0;
+    (void)setsockopt(socket, domain == AF_INET ? IPPROTO_IP : IPPROTO_IPV6,
+                     IP_MULTICAST_ALL,  // is this the same for IPv6?
+                     (void *)&multicastAll, sizeof multicastAll);
+    // Ignore the call's result.  Should it fail, we'll still receive packets (just perhaps more than intended)
+#endif
+}
+
+Boolean socketJoinGroup(UsageEnvironment &env, int socket, struct sockaddr_storage const &groupAddress) {
+    if(!IsMulticastAddress(groupAddress))
+        return True;  // ignore this case
+
+    int              level, option_name;
+    void const *     option_value;
+    SOCKLEN_T        option_len;
+    struct ip_mreq   imr4;
+    struct ipv6_mreq imr6;
+
+    switch(groupAddress.ss_family) {
+    case AF_INET: {
+        imr4.imr_multiaddr.s_addr = ((struct sockaddr_in &)groupAddress).sin_addr.s_addr;
+        imr4.imr_interface.s_addr = ReceivingInterfaceAddr;
+
+        level        = IPPROTO_IP;
+        option_name  = IP_ADD_MEMBERSHIP;
+        option_value = &imr4;
+        option_len   = sizeof imr4;
+        break;
+    }
+    case AF_INET6: {
+        imr6.ipv6mr_multiaddr = ((struct sockaddr_in6 &)groupAddress).sin6_addr;
+        imr6.ipv6mr_interface = 0;  // ???
+
+        level        = IPPROTO_IPV6;
+        option_name  = IPV6_JOIN_GROUP;
+        option_value = &imr6;
+        option_len   = sizeof imr6;
+        break;
+    }
+    default: {
+        return False;
+    }
+    }
+    if(setsockopt(socket, level, option_name, (const char *)option_value, option_len) < 0) {
+#if defined(__WIN32__) || defined(_WIN32)
+        if(env.getErrno() != 0) {
+            // That piece-of-shit toy operating system (Windows) sometimes lies
+            // about setsockopt() failing!
+#endif
+            socketErr(env, "setsockopt(IP_ADD_MEMBERSHIP) error: ");
+            return False;
+#if defined(__WIN32__) || defined(_WIN32)
+        }
+#endif
+    }
+
+    clearMulticastAllSocketOption(socket, groupAddress.ss_family);
+
+    return True;
+}
+
+Boolean socketLeaveGroup(UsageEnvironment &, int socket, struct sockaddr_storage const &groupAddress) {
+    if(!IsMulticastAddress(groupAddress))
+        return True;  // ignore this case
+
+    int              level, option_name;
+    void const *     option_value;
+    SOCKLEN_T        option_len;
+    struct ip_mreq   imr4;
+    struct ipv6_mreq imr6;
+
+    switch(groupAddress.ss_family) {
+    case AF_INET: {
+        imr4.imr_multiaddr.s_addr = ((struct sockaddr_in &)groupAddress).sin_addr.s_addr;
+        imr4.imr_interface.s_addr = ReceivingInterfaceAddr;
+
+        level        = IPPROTO_IP;
+        option_name  = IP_DROP_MEMBERSHIP;
+        option_value = &imr4;
+        option_len   = sizeof imr4;
+        break;
+    }
+    case AF_INET6: {
+        imr6.ipv6mr_multiaddr = ((struct sockaddr_in6 &)groupAddress).sin6_addr;
+        imr6.ipv6mr_interface = 0;  // ???
+
+        level        = IPPROTO_IPV6;
+        option_name  = IPV6_LEAVE_GROUP;
+        option_value = &imr6;
+        option_len   = sizeof imr6;
+        break;
+    }
+    default: {
+        return False;
+    }
+    }
+    if(setsockopt(socket, level, option_name, (const char *)option_value, option_len) < 0) {
+        return False;
+    }
+
+    return True;
+}
+
+// The source-specific join/leave operations require special setsockopt()
+// commands, and a special structure (ip_mreq_source).  If the include files
+// didn't define these, we do so here:
+#if !defined(IP_ADD_SOURCE_MEMBERSHIP)
+struct ip_mreq_source {
+    struct in_addr imr_multiaddr;  /* IP multicast address of group */
+    struct in_addr imr_sourceaddr; /* IP address of source */
+    struct in_addr imr_interface;  /* local IP address of interface */
+};
+#endif
+
+#ifndef IP_ADD_SOURCE_MEMBERSHIP
+
+#ifdef LINUX
+#define IP_ADD_SOURCE_MEMBERSHIP 39
+#define IP_DROP_SOURCE_MEMBERSHIP 40
+#else
+#define IP_ADD_SOURCE_MEMBERSHIP 25
+#define IP_DROP_SOURCE_MEMBERSHIP 26
+#endif
+
+#endif
+
+Boolean socketJoinGroupSSM(UsageEnvironment &env, int socket, struct sockaddr_storage const &groupAddress, struct sockaddr_storage const &sourceFilterAddr) {
+    if(!IsMulticastAddress(groupAddress))
+        return True;  // ignore this case
+    if(groupAddress.ss_family != AF_INET)
+        return False;  // later, support IPv6
+
+    struct ip_mreq_source imr;
+#if ANDROID_OLD_NDK
+    imr.imr_multiaddr  = ((struct sockaddr_in &)groupAddress).sin_addr.s_addr;
+    imr.imr_sourceaddr = ((struct sockaddr_in &)sourceFilterAddr).sin_addr.s_addr;
+    imr.imr_interface  = ReceivingInterfaceAddr;
+#else
+    imr.imr_multiaddr.s_addr  = ((struct sockaddr_in &)groupAddress).sin_addr.s_addr;
+    imr.imr_sourceaddr.s_addr = ((struct sockaddr_in &)sourceFilterAddr).sin_addr.s_addr;
+    imr.imr_interface.s_addr  = ReceivingInterfaceAddr;
+#endif
+    if(setsockopt(socket, IPPROTO_IP, IP_ADD_SOURCE_MEMBERSHIP, (const char *)&imr, sizeof(struct ip_mreq_source)) < 0) {
+        socketErr(env, "setsockopt(IP_ADD_SOURCE_MEMBERSHIP) error: ");
+        return False;
+    }
+
+    clearMulticastAllSocketOption(socket, groupAddress.ss_family);
+
+    return True;
+}
+
+Boolean socketLeaveGroupSSM(UsageEnvironment & /*env*/, int socket, struct sockaddr_storage const &groupAddress,
+                            struct sockaddr_storage const &sourceFilterAddr) {
+    if(!IsMulticastAddress(groupAddress))
+        return True;  // ignore this case
+    if(groupAddress.ss_family != AF_INET)
+        return False;  // later, support IPv6
+
+    struct ip_mreq_source imr;
+#if ANDROID_OLD_NDK
+    imr.imr_multiaddr  = ((struct sockaddr_in &)groupAddress).sin_addr.s_addr;
+    imr.imr_sourceaddr = ((struct sockaddr_in &)sourceFilterAddr).sin_addr.s_addr;
+    imr.imr_interface  = ReceivingInterfaceAddr;
+#else
+    imr.imr_multiaddr.s_addr  = ((struct sockaddr_in &)groupAddress).sin_addr.s_addr;
+    imr.imr_sourceaddr.s_addr = ((struct sockaddr_in &)sourceFilterAddr).sin_addr.s_addr;
+    imr.imr_interface.s_addr  = ReceivingInterfaceAddr;
+#endif
+    if(setsockopt(socket, IPPROTO_IP, IP_DROP_SOURCE_MEMBERSHIP, (const char *)&imr, sizeof(struct ip_mreq_source)) < 0) {
+        return False;
+    }
+
+    return True;
+}
+
+static Boolean getSourcePort0(int socket, portNumBits &resultPortNum /*host order*/) {
+    sockaddr_storage testAddr;
+    setPortNum(testAddr, 0);
+
+    SOCKLEN_T len = sizeof testAddr;
+    if(getsockname(socket, (struct sockaddr *)&testAddr, reinterpret_cast<socklen_t *>(&len)) < 0)
+        return False;
+
+    resultPortNum = ntohs(portNum(testAddr));
+    return True;
+}
+
+Boolean getSourcePort(UsageEnvironment &env, int socket, int domain, Port &port) {
+    portNumBits portNum = 0;
+    if(!getSourcePort0(socket, portNum) || portNum == 0) {
+        // Hack - call bind(), then try again:
+        if(domain == AF_INET) {  // IPv4
+            MAKE_SOCKADDR_IN(name, INADDR_ANY, 0);
+            bind(socket, (struct sockaddr *)&name, sizeof name);
+        }
+        else {  // IPv6
+            MAKE_SOCKADDR_IN6(name, 0);
+            bind(socket, (struct sockaddr *)&name, sizeof name);
+        }
+
+        if(!getSourcePort0(socket, portNum) || portNum == 0) {
+            socketErr(env, "getsockname() error: ");
+            return False;
+        }
+    }
+
+    port = Port(portNum);
+    return True;
+}
+
+static Boolean isBadIPv4AddressForUs(ipv4AddressBits addr) {
+    // Check for some possible erroneous addresses:
+    ipv4AddressBits nAddr = htonl(addr);
+    return (nAddr == 0x7F000001 /* 127.0.0.1 */
+            || nAddr == 0 || nAddr == (ipv4AddressBits)(~0));
+}
+
+static Boolean isBadIPv6AddressForUs(ipv6AddressBits addr) {
+    // We consider an IPv6 address bad if:
+    //   - the first 10 bits are 0xFE8, indicating a link-local or site-local address, or
+    //   - the first 15 bytes are 0, and the 16th byte is 0 (unspecified) or 1 (loopback)
+    if(addr[0] == 0xFE)
+        return (addr[1] & 0x80) != 0;
+
+    for(unsigned i = 0; i < 15; ++i) {
+        if(addr[i] != 0)
+            return False;
+    }
+
+    return addr[15] == 0 || addr[15] == 1;
+}
+
+static Boolean isBadAddressForUs(struct sockaddr const &addr) {
+    switch(addr.sa_family) {
+    case AF_INET: {
+        return isBadIPv4AddressForUs(((sockaddr_in &)addr).sin_addr.s_addr);
+    }
+    case AF_INET6: {
+        return isBadIPv6AddressForUs(((sockaddr_in6 &)addr).sin6_addr.s6_addr);
+    }
+    default: {
+        return True;
+    }
+    }
+}
+
+static Boolean isBadAddressForUs(NetAddress const &addr) {
+    if(addr.length() == sizeof(ipv4AddressBits)) {
+        return isBadIPv4AddressForUs(*(ipv4AddressBits *)(addr.data()));
+    }
+    else if(addr.length() == sizeof(ipv6AddressBits)) {
+        return isBadIPv6AddressForUs(*(ipv6AddressBits *)(addr.data()));
+    }
+    else {
+        return True;
+    }
+}
+
+static void getOurIPAddresses(UsageEnvironment &env);  // forward
+
+static ipv4AddressBits _ourIPv4Address = 0;
+#define _weHaveAnIPv4Address (_ourIPv4Address != 0)
+
+ipv4AddressBits ourIPv4Address(UsageEnvironment &env) {
+    if(ReceivingInterfaceAddr != INADDR_ANY) {
+        // Hack: If we were told to receive on a specific interface address, then
+        // define this to be our ip address:
+        _ourIPv4Address = ReceivingInterfaceAddr;
+    }
+
+    if(!_weHaveAnIPv4Address) {
+        getOurIPAddresses(env);
+    }
+
+    return _ourIPv4Address;
+}
+
+static ipv6AddressBits _ourIPv6Address;
+static Boolean         _weHaveAnIPv6Address = False;
+
+ipv6AddressBits const &ourIPv6Address(UsageEnvironment &env) {
+    if(!_weHaveAnIPv6Address) {
+        getOurIPAddresses(env);
+    }
+
+    return _ourIPv6Address;
+}
+
+Boolean weHaveAnIPv4Address(UsageEnvironment &env) {
+    if(_weHaveAnIPv4Address || _weHaveAnIPv6Address)
+        return _weHaveAnIPv4Address;
+
+    getOurIPAddresses(env);
+    return _weHaveAnIPv4Address;
+}
+
+Boolean weHaveAnIPv6Address(UsageEnvironment &env) {
+    if(_weHaveAnIPv4Address || _weHaveAnIPv6Address)
+        return _weHaveAnIPv6Address;
+
+    getOurIPAddresses(env);
+    return _weHaveAnIPv6Address;
+}
+
+Boolean weHaveAnIPAddress(UsageEnvironment &env) {
+    if(_weHaveAnIPv4Address || _weHaveAnIPv6Address)
+        return True;
+
+    getOurIPAddresses(env);
+    return _weHaveAnIPv4Address || _weHaveAnIPv6Address;
+}
+
+static void copyAddress(struct sockaddr_storage &to, struct sockaddr const *from) {
+    // Copy a "struct sockaddr" to a "struct sockaddr_storage" (assumed to be large enough)
+    if(from == NULL)
+        return;
+
+    switch(from->sa_family) {
+    case AF_INET: {
+#ifdef HAVE_SOCKADDR_LEN
+        if(from->sa_len < sizeof(struct sockaddr_in))
+            return;  // sanity check
+        to.ss_len = sizeof(struct sockaddr_in);
+#endif
+        to.ss_family                        = AF_INET;
+        ((sockaddr_in &)to).sin_addr.s_addr = ((sockaddr_in const *)from)->sin_addr.s_addr;
+        break;
+    }
+    case AF_INET6: {
+#ifdef HAVE_SOCKADDR_LEN
+        if(from->sa_len < sizeof(struct sockaddr_in6))
+            return;  // sanity check
+        to.ss_len = sizeof(struct sockaddr_in6);
+#endif
+        to.ss_family = AF_INET6;
+        for(unsigned i = 0; i < 16; ++i) {
+            ((sockaddr_in6 &)to).sin6_addr.s6_addr[i] = ((sockaddr_in6 const *)from)->sin6_addr.s6_addr[i];
+        }
+        break;
+    }
+    }
+}
+
+void getOurIPAddresses(UsageEnvironment &env) {
+    // We use two methods to (try to) get our IP addresses.
+    // First, we use "getifaddrs()".  But if that doesn't work
+    // (or if "getifaddrs()" is not defined), then we use an alternative (more old-fashioned)
+    // mechanism: First get our host name, then try resolving this host name.
+    struct sockaddr_storage foundIPv4Address = nullAddress(AF_INET);
+    struct sockaddr_storage foundIPv6Address = nullAddress(AF_INET6);
+
+    Boolean getifaddrsWorks = False;  // until we learn otherwise
+#ifndef NO_GETIFADDRS
+    struct ifaddrs *ifap;
+
+    if(getifaddrs(&ifap) == 0) {
+        // Look through all interfaces:
+        for(struct ifaddrs *p = ifap; p != NULL; p = p->ifa_next) {
+            // Ignore an interface if it's not up, or is a loopback interface:
+            if((p->ifa_flags & IFF_UP) == 0 || (p->ifa_flags & IFF_LOOPBACK) != 0)
+                continue;
+
+            // Also ignore the interface if the address is considered 'bad' for us:
+            if(p->ifa_addr == NULL || isBadAddressForUs(*p->ifa_addr))
+                continue;
+
+            // We take the first IPv4 and first IPv6 addresses:
+            if(p->ifa_addr->sa_family == AF_INET && addressIsNull(foundIPv4Address)) {
+                copyAddress(foundIPv4Address, p->ifa_addr);
+                getifaddrsWorks = True;
+            }
+            else if(p->ifa_addr->sa_family == AF_INET6 && addressIsNull(foundIPv6Address)) {
+                copyAddress(foundIPv6Address, p->ifa_addr);
+                getifaddrsWorks = True;
+            }
+        }
+        freeifaddrs(ifap);
+    }
+#endif
+
+    if(!getifaddrsWorks)
+        do {
+            // We couldn't find our address using "getifaddrs()",
+            // so try instead to look it up directly - by first getting our host name,
+            // and then resolving this host name
+            char hostname[100];
+            hostname[0] = '\0';
+            int result  = gethostname(hostname, sizeof hostname);
+            if(result != 0 || hostname[0] == '\0') {
+                env.setResultErrMsg("initial gethostname() failed");
+                break;
+            }
+
+            // Try to resolve "hostname" to one or more IP addresses:
+            NetAddressList           addresses(hostname);
+            NetAddressList::Iterator iter(addresses);
+
+            // Look at each address, rejecting any that are bad.
+            // We take the first IPv4 and first IPv6 addresses, if any.
+            NetAddress const *address;
+            while((address = iter.nextAddress()) != NULL) {
+                if(isBadAddressForUs(*address))
+                    continue;
+
+                if(address->length() == sizeof(ipv4AddressBits) && addressIsNull(foundIPv4Address)) {
+                    copyAddress(foundIPv4Address, address);
+                }
+                else if(address->length() == sizeof(ipv6AddressBits) && addressIsNull(foundIPv6Address)) {
+                    copyAddress(foundIPv6Address, address);
+                }
+            }
+        } while(0);
+
+    // Note the IPv4 and IPv6 addresses that we found:
+    _ourIPv4Address = ((sockaddr_in &)foundIPv4Address).sin_addr.s_addr;
+
+    for(unsigned i = 0; i < 16; ++i) {
+        _ourIPv6Address[i] = ((sockaddr_in6 &)foundIPv6Address).sin6_addr.s6_addr[i];
+        if(_ourIPv6Address[i] != 0)
+            _weHaveAnIPv6Address = True;
+    }
+
+    if(!_weHaveAnIPv4Address && !_weHaveAnIPv6Address) {
+        env.setResultMsg("This computer does not have a valid IP (v4 or v6) address!");
+    }
+
+    // Use our newly-discovered IP addresses, and the current time,
+    // to initialize the random number generator's seed:
+    struct timeval timeNow;
+    gettimeofday(&timeNow, NULL);
+    unsigned seed = _ourIPv4Address ^ timeNow.tv_sec ^ timeNow.tv_usec;
+    for(unsigned i = 0; i < 16; i += 4) {
+        seed ^= (_ourIPv6Address[i] << 24) | (_ourIPv6Address[i + 1] << 16) | (_ourIPv6Address[i + 2] << 8) | _ourIPv6Address[i + 3];
+    }
+    our_srandom(seed);
+}
+
+ipv4AddressBits chooseRandomIPv4SSMAddress(UsageEnvironment &env) {
+    // First, a hack to ensure that our random number generator is seeded:
+    (void)ourIPv4Address(env);
+
+    // Choose a random address in the range [232.0.1.0, 232.255.255.255)
+    // i.e., [0xE8000100, 0xE8FFFFFF)
+    ipv4AddressBits const first = 0xE8000100, lastPlus1 = 0xE8FFFFFF;
+    ipv4AddressBits const range = lastPlus1 - first;
+
+    return ntohl(first + ((ipv4AddressBits)our_random()) % range);
+}
+
+char const *timestampString() {
+    struct timeval tvNow;
+    gettimeofday(&tvNow, NULL);
+
+#if !defined(_WIN32_WCE)
+    static char timeString[9];  // holds hh:mm:ss plus trailing '\0'
+
+    time_t      tvNow_t     = tvNow.tv_sec;
+    char const *ctimeResult = ctime(&tvNow_t);
+    if(ctimeResult == NULL) {
+        sprintf(timeString, "??:??:??");
+    }
+    else {
+        char const *from = &ctimeResult[11];
+        int         i;
+        for(i = 0; i < 8; ++i) {
+            timeString[i] = from[i];
+        }
+        timeString[i] = '\0';
+    }
+#else
+    // WinCE apparently doesn't have "ctime()", so instead, construct
+    // a timestamp string just using the integer and fractional parts
+    // of "tvNow":
+    static char timeString[50];
+    sprintf(timeString, "%lu.%06ld", tvNow.tv_sec, tvNow.tv_usec);
+#endif
+
+    return (char const *)&timeString;
+}
+
+#if(defined(__WIN32__) || defined(_WIN32)) && !defined(__MINGW32__)
+// For Windoze, we need to implement our own gettimeofday()
+
+// used to make sure that static variables in gettimeofday() aren't initialized simultaneously by multiple threads
+static LONG initializeLock_gettimeofday = 0;
+
+#if !defined(_WIN32_WCE)
+#include <sys/timeb.h>
+#endif
+
+int gettimeofday(struct timeval *tp, int * /*tz*/) {
+    static LARGE_INTEGER tickFrequency, epochOffset;
+
+    static Boolean isInitialized = False;
+
+    LARGE_INTEGER tickNow;
+
+#if !defined(_WIN32_WCE)
+    QueryPerformanceCounter(&tickNow);
+#else
+    tickNow.QuadPart = GetTickCount();
+#endif
+
+    if(!isInitialized) {
+        if(1 == InterlockedIncrement(&initializeLock_gettimeofday)) {
+#if !defined(_WIN32_WCE)
+            // For our first call, use "ftime()", so that we get a time with a proper epoch.
+            // For subsequent calls, use "QueryPerformanceCount()", because it's more fine-grain.
+            struct timeb tb;
+            ftime(&tb);
+            tp->tv_sec  = tb.time;
+            tp->tv_usec = 1000 * tb.millitm;
+
+            // Also get our counter frequency:
+            QueryPerformanceFrequency(&tickFrequency);
+#else
+            /* FILETIME of Jan 1 1970 00:00:00. */
+            const LONGLONG epoch = 116444736000000000LL;
+            FILETIME fileTime;
+            LARGE_INTEGER time;
+            GetSystemTimeAsFileTime(&fileTime);
+
+            time.HighPart = fileTime.dwHighDateTime;
+            time.LowPart = fileTime.dwLowDateTime;
+
+            // convert to from 100ns time to unix timestamp in seconds, 1000*1000*10
+            tp->tv_sec = (long)((time.QuadPart - epoch) / 10000000L);
+
+            /*
+              GetSystemTimeAsFileTime has just a seconds resolution,
+              thats why wince-version of gettimeofday is not 100% accurate, usec accuracy would be calculated like this:
+              // convert 100 nanoseconds to usec
+              tp->tv_usec= (long)((time.QuadPart - epoch)%10000000L) / 10L;
+            */
+            tp->tv_usec = 0;
+
+            // resolution of GetTickCounter() is always milliseconds
+            tickFrequency.QuadPart = 1000;
+#endif
+            // compute an offset to add to subsequent counter times, so we get a proper epoch:
+            epochOffset.QuadPart = tp->tv_sec * tickFrequency.QuadPart + (tp->tv_usec * tickFrequency.QuadPart) / 1000000L - tickNow.QuadPart;
+
+            // next caller can use ticks for time calculation
+            isInitialized = True;
+            return 0;
+        }
+        else {
+            InterlockedDecrement(&initializeLock_gettimeofday);
+            // wait until first caller has initialized static values
+            while(!isInitialized) {
+                Sleep(1);
+            }
+        }
+    }
+
+    // adjust our tick count so that we get a proper epoch:
+    tickNow.QuadPart += epochOffset.QuadPart;
+
+    tp->tv_sec  = (long)(tickNow.QuadPart / tickFrequency.QuadPart);
+    tp->tv_usec = (long)(((tickNow.QuadPart % tickFrequency.QuadPart) * 1000000L) / tickFrequency.QuadPart);
+
+    return 0;
+}
+#endif
+#undef ANDROID_OLD_NDK
diff --git a/3rdparty/live555/src/groupsock/IOHandlers.cpp b/3rdparty/live555/src/groupsock/IOHandlers.cpp
new file mode 100644
index 00000000..861f32b7
--- /dev/null
+++ b/3rdparty/live555/src/groupsock/IOHandlers.cpp
@@ -0,0 +1,44 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "groupsock"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// IO event handlers
+// Implementation
+
+#include "IOHandlers.hh"
+
+//##### TEMP: Use a single buffer.
+//##### This assumes that the I/O handlers are non-reentrant
+static unsigned const maxPacketLength = 0x10000;  // bytes
+                                                  // This is usually overkill, because UDP packets are usually no larger
+                                                  // than the typical Ethernet MTU (1500 bytes).  However, I've seen
+                                                  // reports of Windows Media Servers sending UDP packets as large as
+                                                  // 27 kBytes.  These will probably undergo lots of IP-level
+                                                  // fragmentation, but that occurs below us.  We just have to hope that
+                                                  // fragments don't get lost.
+static unsigned const ioBufferSize = maxPacketLength;
+static unsigned char  ioBuffer[ioBufferSize];
+
+void socketReadHandler(Socket *sock, int /*mask*/) {
+    unsigned                bytesRead;
+    struct sockaddr_storage dummy;  // not used
+    UsageEnvironment &      saveEnv = sock->env();
+    // because handleRead(), if it fails, may delete "sock"
+
+    if(!sock->handleRead(ioBuffer, ioBufferSize, bytesRead, dummy)) {
+        saveEnv.reportBackgroundError();
+    }
+}
diff --git a/3rdparty/live555/src/groupsock/Makefile.head b/3rdparty/live555/src/groupsock/Makefile.head
new file mode 100644
index 00000000..219f685c
--- /dev/null
+++ b/3rdparty/live555/src/groupsock/Makefile.head
@@ -0,0 +1,4 @@
+INCLUDES = -Iinclude -I../UsageEnvironment/include
+PREFIX = /usr/local
+LIBDIR = $(PREFIX)/lib
+##### Change the following for your environment:
diff --git a/3rdparty/live555/src/groupsock/Makefile.tail b/3rdparty/live555/src/groupsock/Makefile.tail
new file mode 100644
index 00000000..ab8266ec
--- /dev/null
+++ b/3rdparty/live555/src/groupsock/Makefile.tail
@@ -0,0 +1,44 @@
+##### End of variables to change
+
+NAME = libgroupsock
+ALL = $(NAME).$(LIB_SUFFIX)
+all:	$(ALL)
+
+.$(C).$(OBJ):
+	$(C_COMPILER) -c $(C_FLAGS) $<
+.$(CPP).$(OBJ):
+	$(CPLUSPLUS_COMPILER) -c $(CPLUSPLUS_FLAGS) $<
+
+GROUPSOCK_LIB_OBJS = GroupsockHelper.$(OBJ) GroupEId.$(OBJ) inet.$(OBJ) Groupsock.$(OBJ) NetInterface.$(OBJ) NetAddress.$(OBJ) IOHandlers.$(OBJ)
+
+GroupsockHelper.$(CPP):	include/GroupsockHelper.hh
+include/GroupsockHelper.hh:	include/NetAddress.hh
+include/NetAddress.hh:	include/NetCommon.h
+GroupEId.$(CPP):	include/GroupEId.hh
+include/GroupEId.hh:	include/NetAddress.hh
+inet.$(C):		include/NetCommon.h
+Groupsock.$(CPP):	include/Groupsock.hh include/GroupsockHelper.hh
+include/Groupsock.hh:	include/groupsock_version.hh include/NetInterface.hh include/GroupEId.hh
+include/NetInterface.hh:	include/NetAddress.hh
+NetInterface.$(CPP):	include/NetInterface.hh include/GroupsockHelper.hh
+NetAddress.$(CPP):	include/NetAddress.hh include/GroupsockHelper.hh
+IOHandlers.$(CPP):	include/IOHandlers.hh
+
+libgroupsock.$(LIB_SUFFIX): $(GROUPSOCK_LIB_OBJS) \
+    $(PLATFORM_SPECIFIC_LIB_OBJS)
+	$(LIBRARY_LINK)$@ $(LIBRARY_LINK_OPTS) \
+		$(GROUPSOCK_LIB_OBJS)
+
+clean:
+	-rm -rf *.$(OBJ) $(ALL) core *.core *~ include/*~
+
+install: install1 $(INSTALL2)
+install1: libgroupsock.$(LIB_SUFFIX)
+	  install -d $(DESTDIR)$(PREFIX)/include/groupsock $(DESTDIR)$(LIBDIR)
+	  install -m 644 include/*.hh include/*.h $(DESTDIR)$(PREFIX)/include/groupsock
+	  install -m 644 libgroupsock.$(LIB_SUFFIX) $(DESTDIR)$(LIBDIR)
+install_shared_libraries: libgroupsock.$(LIB_SUFFIX)
+	  ln -fs libgroupsock.$(LIB_SUFFIX) $(DESTDIR)$(LIBDIR)/libgroupsock.$(SHORT_LIB_SUFFIX)
+	  ln -fs libgroupsock.$(LIB_SUFFIX) $(DESTDIR)$(LIBDIR)/libgroupsock.so
+
+##### Any additional, platform-specific rules come here:
diff --git a/3rdparty/live555/src/groupsock/NetAddress.cpp b/3rdparty/live555/src/groupsock/NetAddress.cpp
new file mode 100644
index 00000000..57ca8427
--- /dev/null
+++ b/3rdparty/live555/src/groupsock/NetAddress.cpp
@@ -0,0 +1,523 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "groupsock"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// Network Addresses
+// Implementation
+
+#include "NetAddress.hh"
+#include "GroupsockHelper.hh"
+
+#include <stddef.h>
+#include <stdio.h>
+#if defined(__WIN32__) || defined(_WIN32)
+#define USE_GETHOSTBYNAME 1 /*because at least some Windows don't have getaddrinfo()*/
+#else
+#ifndef INADDR_NONE
+#define INADDR_NONE 0xFFFFFFFF
+#endif
+#endif
+
+////////// NetAddress //////////
+
+NetAddress::NetAddress(u_int8_t const *data, unsigned length) {
+    assign(data, length);
+}
+
+NetAddress::NetAddress(unsigned length) {
+    fData = new u_int8_t[length];
+    if(fData == NULL) {
+        fLength = 0;
+        return;
+    }
+
+    for(unsigned i = 0; i < length; ++i)
+        fData[i] = 0;
+    fLength = length;
+}
+
+NetAddress::NetAddress(NetAddress const &orig) {
+    assign(orig.data(), orig.length());
+}
+
+NetAddress &NetAddress::operator=(NetAddress const &rightSide) {
+    if(&rightSide != this) {
+        clean();
+        assign(rightSide.data(), rightSide.length());
+    }
+    return *this;
+}
+
+NetAddress::~NetAddress() {
+    clean();
+}
+
+void NetAddress::assign(u_int8_t const *data, unsigned length) {
+    fData = new u_int8_t[length];
+    if(fData == NULL) {
+        fLength = 0;
+        return;
+    }
+
+    for(unsigned i = 0; i < length; ++i)
+        fData[i] = data[i];
+    fLength = length;
+}
+
+void NetAddress::clean() {
+    delete[] fData;
+    fData   = NULL;
+    fLength = 0;
+}
+
+static struct sockaddr_storage _nullIPv4Address, _nullIPv6Address;
+struct sockaddr_storage const &nullAddress(int addressFamily) {
+    switch(addressFamily) {
+    case AF_INET: {
+        _nullIPv4Address.ss_family                        = AF_INET;
+        ((sockaddr_in &)_nullIPv4Address).sin_addr.s_addr = 0;
+
+        return _nullIPv4Address;
+    }
+    default: {  // assume AF_INET6
+        _nullIPv6Address.ss_family = AF_INET6;
+        for(unsigned i = 0; i < 16; ++i) {
+            ((sockaddr_in6 &)_nullIPv6Address).sin6_addr.s6_addr[i] = 0;
+        }
+
+        return _nullIPv6Address;
+    }
+    }
+}
+
+Boolean addressIsNull(sockaddr_storage const &address) {
+    switch(address.ss_family) {
+    case AF_INET: {
+        return ((sockaddr_in const &)address).sin_addr.s_addr == 0;
+    }
+    case AF_INET6: {
+        for(unsigned i = 0; i < 16; ++i) {
+            if(((sockaddr_in6 const &)address).sin6_addr.s6_addr[i] != 0)
+                return False;
+        }
+        return True;
+    }
+    default: {
+        return False;
+    }
+    }
+}
+
+SOCKLEN_T addressSize(sockaddr_storage const &address) {
+    switch(address.ss_family) {
+    case AF_INET: {
+        return sizeof(struct sockaddr_in);
+    }
+    case AF_INET6: {
+        return sizeof(struct sockaddr_in6);
+    }
+    default: {
+        return 0;
+    }
+    }
+}
+
+void copyAddress(struct sockaddr_storage &to, NetAddress const *from) {
+    if(from == NULL)
+        return;
+
+    if(from->length() == sizeof(ipv4AddressBits)) {
+#ifdef HAVE_SOCKADDR_LEN
+        to.ss_len = sizeof(struct sockaddr_in);
+#endif
+        to.ss_family                        = AF_INET;
+        ((sockaddr_in &)to).sin_addr.s_addr = *(ipv4AddressBits *)(from->data());
+    }
+    else {  // IPv6
+#ifdef HAVE_SOCKADDR_LEN
+        to.ss_len = sizeof(struct sockaddr_in6);
+#endif
+        to.ss_family = AF_INET6;
+        for(unsigned i = 0; i < 16; ++i) {
+            ((sockaddr_in6 &)to).sin6_addr.s6_addr[i] = (from->data())[i];
+        }
+        ((sockaddr_in6 &)to).sin6_scope_id = 0;  // instead, somehow look this up from the address?
+    }
+}
+
+Boolean operator==(struct sockaddr_storage const &left, struct sockaddr_storage const &right) {
+    if(left.ss_family != right.ss_family)
+        return False;
+
+    switch(left.ss_family) {
+    case AF_INET: {
+        return ((struct sockaddr_in const &)left).sin_addr.s_addr == ((struct sockaddr_in const &)right).sin_addr.s_addr;
+    }
+    case AF_INET6: {
+        return ((struct sockaddr_in6 const &)left).sin6_addr.s6_addr == ((struct sockaddr_in6 const &)right).sin6_addr.s6_addr;
+    }
+    default: {
+        return False;
+    }
+    }
+}
+
+////////// NetAddressList //////////
+
+NetAddressList::NetAddressList(char const *hostname, int addressFamily) : fNumAddresses(0), fAddressArray(NULL) {
+    if(hostname == NULL)
+        return;
+
+    // First, check whether "hostname" is an IP address literal (check IPv4, then IPv6).
+    // If so, return a 1-element list with this address:
+    ipv4AddressBits addr4;
+    if(addressFamily != AF_INET6 && inet_pton(AF_INET, hostname, (u_int8_t *)&addr4) == 1) {
+        fNumAddresses = 1;
+        fAddressArray = new NetAddress *[fNumAddresses];
+        if(fAddressArray == NULL)
+            return;
+
+        fAddressArray[0] = new NetAddress((u_int8_t *)&addr4, sizeof addr4);
+        return;
+    }
+
+    ipv6AddressBits addr6;
+    if(addressFamily != AF_INET && inet_pton(AF_INET6, hostname, (u_int8_t *)&addr6) == 1) {
+        fNumAddresses = 1;
+        fAddressArray = new NetAddress *[fNumAddresses];
+        if(fAddressArray == NULL)
+            return;
+
+        fAddressArray[0] = new NetAddress((u_int8_t *)&addr6, sizeof addr6);
+        return;
+    }
+
+    // "hostname" is not an IP address string; try resolving it as a real host name instead:
+#if defined(USE_GETHOSTBYNAME) || defined(VXWORKS)
+    struct hostent *host;
+#if defined(VXWORKS)
+    char hostentBuf[512];
+
+    host = (struct hostent *)resolvGetHostByName((char *)hostname, (char *)&hostentBuf, sizeof hostentBuf);
+#else
+    host = gethostbyname((char *)hostname);
+#endif
+    if(host == NULL || host->h_length != 4 || host->h_addr_list == NULL)
+        return;  // no luck
+
+    u_int8_t const **const hAddrPtr = (u_int8_t const **)host->h_addr_list;
+    // First, count the number of addresses:
+    u_int8_t const **hAddrPtr1 = hAddrPtr;
+    while(*hAddrPtr1 != NULL) {
+        ++fNumAddresses;
+        ++hAddrPtr1;
+    }
+
+    // Next, set up the list:
+    fAddressArray = new NetAddress *[fNumAddresses];
+    if(fAddressArray == NULL)
+        return;
+
+    for(unsigned i = 0; i < fNumAddresses; ++i) {
+        fAddressArray[i] = new NetAddress(hAddrPtr[i], host->h_length);
+    }
+#else
+    // Use "getaddrinfo()" (rather than the older, deprecated "gethostbyname()"):
+    struct addrinfo addrinfoHints;
+    memset(&addrinfoHints, 0, sizeof addrinfoHints);
+    addrinfoHints.ai_flags             = AI_ADDRCONFIG;  // We only care about addresses that we can handle
+    struct addrinfo *addrinfoResultPtr = NULL;
+    int              result            = -1;
+    if(addressFamily != AF_INET6) {
+        // First, look up an IPv4 address for the name
+        addrinfoHints.ai_family = AF_INET;  // First, look up an IPv4 address for the name
+        result                  = getaddrinfo(hostname, NULL, &addrinfoHints, &addrinfoResultPtr);
+    }
+    if(addressFamily != AF_INET && (result != 0 || addrinfoResultPtr == NULL)) {
+        // Try again, looking up an IPv6 address for the name instead:
+        addrinfoHints.ai_family = AF_INET6;
+        result                  = getaddrinfo(hostname, NULL, &addrinfoHints, &addrinfoResultPtr);
+    }
+    if(result != 0 || addrinfoResultPtr == NULL)
+        return;  // no luck
+
+    // First, count the number of addresses:
+    const struct addrinfo *p = addrinfoResultPtr;
+    while(p != NULL) {
+        if(p->ai_family != AF_INET && p->ai_family != AF_INET6)
+            continue;  // unsupported address
+        if(addressFamily != AF_UNSPEC && p->ai_family != addressFamily)
+            continue;  // unwanted
+        // Sanity check: Also check the address length:
+        if(p->ai_family == AF_INET && p->ai_addrlen < sizeof(struct sockaddr_in))
+            continue;
+        if(p->ai_family == AF_INET6 && p->ai_addrlen < sizeof(struct sockaddr_in6))
+            continue;
+        ++fNumAddresses;
+        p = p->ai_next;
+    }
+
+    // Next, set up the list:
+    fAddressArray = new NetAddress *[fNumAddresses];
+    if(fAddressArray == NULL)
+        return;
+
+    unsigned i = 0;
+    p          = addrinfoResultPtr;
+    while(p != NULL) {
+        // Same sanity checks as before:
+        if(p->ai_family != AF_INET && p->ai_family != AF_INET6)
+            continue;  // unsupported address
+        if(addressFamily != AF_UNSPEC && p->ai_family != addressFamily)
+            continue;  // unwanted
+        if(p->ai_family == AF_INET && p->ai_addrlen < sizeof(struct sockaddr_in))
+            continue;
+        if(p->ai_family == AF_INET6 && p->ai_addrlen < sizeof(struct sockaddr_in6))
+            continue;
+
+        if(p->ai_family == AF_INET) {  // IPv4
+            fAddressArray[i++] = new NetAddress((u_int8_t const *)&(((struct sockaddr_in *)p->ai_addr)->sin_addr.s_addr), sizeof(ipv4AddressBits));
+        }
+        else {  // IPv6
+            fAddressArray[i++] = new NetAddress((u_int8_t const *)&(((struct sockaddr_in6 *)p->ai_addr)->sin6_addr.s6_addr), sizeof(ipv6AddressBits));
+        }
+        p = p->ai_next;
+    }
+
+    // Finally, free the data that we had allocated by calling "getaddrinfo()":
+    freeaddrinfo(addrinfoResultPtr);
+#endif
+}
+
+NetAddressList::NetAddressList(NetAddressList const &orig) {
+    assign(orig.numAddresses(), orig.fAddressArray);
+}
+
+NetAddressList &NetAddressList::operator=(NetAddressList const &rightSide) {
+    if(&rightSide != this) {
+        clean();
+        assign(rightSide.numAddresses(), rightSide.fAddressArray);
+    }
+    return *this;
+}
+
+NetAddressList::~NetAddressList() {
+    clean();
+}
+
+void NetAddressList::assign(unsigned numAddresses, NetAddress **addressArray) {
+    fAddressArray = new NetAddress *[numAddresses];
+    if(fAddressArray == NULL) {
+        fNumAddresses = 0;
+        return;
+    }
+
+    for(unsigned i = 0; i < numAddresses; ++i) {
+        fAddressArray[i] = new NetAddress(*addressArray[i]);
+    }
+    fNumAddresses = numAddresses;
+}
+
+void NetAddressList::clean() {
+    while(fNumAddresses-- > 0) {
+        delete fAddressArray[fNumAddresses];
+    }
+    delete[] fAddressArray;
+    fAddressArray = NULL;
+}
+
+NetAddress const *NetAddressList::firstAddress() const {
+    if(fNumAddresses == 0)
+        return NULL;
+
+    return fAddressArray[0];
+}
+
+////////// NetAddressList::Iterator //////////
+NetAddressList::Iterator::Iterator(NetAddressList const &addressList) : fAddressList(addressList), fNextIndex(0) {}
+
+NetAddress const *NetAddressList::Iterator::nextAddress() {
+    if(fNextIndex >= fAddressList.numAddresses())
+        return NULL;  // no more
+    return fAddressList.fAddressArray[fNextIndex++];
+}
+
+////////// Port //////////
+
+Port::Port(portNumBits num /* in host byte order */) {
+    fPortNum = htons(num);
+}
+
+UsageEnvironment &operator<<(UsageEnvironment &s, const Port &p) {
+    return s << ntohs(p.num());
+}
+
+////////// AddressPortLookupTable //////////
+
+#define NUM_RECORDS_IN_KEY_FOR_EACH_ADDRESS (sizeof(struct in6_addr) / sizeof(int))
+#define NUM_RECORDS_IN_KEY_TOTAL (2 * NUM_RECORDS_IN_KEY_FOR_EACH_ADDRESS + 1)
+
+AddressPortLookupTable::AddressPortLookupTable() : fTable(HashTable::create(NUM_RECORDS_IN_KEY_TOTAL)) {}
+
+AddressPortLookupTable::~AddressPortLookupTable() {
+    delete fTable;
+}
+
+static void setKeyFromAddress(int *&key, struct sockaddr_storage const &address) {
+    if(address.ss_family == AF_INET) {
+        // For an IPv4 address, set the upper 3 words of the key to zero, with the address last:
+        *key++ = 0;
+        *key++ = 0;
+        *key++ = 0;
+        *key++ = ((sockaddr_in const &)address).sin_addr.s_addr;
+    }
+    else {
+        // Assume that the address is IPv6; use all 128 bits (4 words) for the key:
+        struct sockaddr_in6 const &address6 = (struct sockaddr_in6 &)address;
+        u_int8_t const *           s6a      = address6.sin6_addr.s6_addr;  // alias
+        *key++                              = (s6a[0] << 24) | (s6a[1] << 16) | (s6a[2] << 8) | s6a[3];
+        *key++                              = (s6a[4] << 24) | (s6a[5] << 16) | (s6a[6] << 8) | s6a[7];
+        *key++                              = (s6a[8] << 24) | (s6a[9] << 16) | (s6a[10] << 8) | s6a[11];
+        *key++                              = (s6a[12] << 24) | (s6a[13] << 16) | (s6a[14] << 8) | s6a[15];
+    }
+}
+
+static void setKey(int *key, struct sockaddr_storage const &address1, struct sockaddr_storage const &address2, Port port) {
+    setKeyFromAddress(key, address1);
+    setKeyFromAddress(key, address2);
+    *key = (int)port.num();
+}
+
+void *AddressPortLookupTable::Add(struct sockaddr_storage const &address1, struct sockaddr_storage const &address2, Port port, void *value) {
+    int key[NUM_RECORDS_IN_KEY_TOTAL];
+    setKey(key, address1, address2, port);
+    return fTable->Add((char *)key, value);
+}
+
+void *AddressPortLookupTable::Lookup(struct sockaddr_storage const &address1, struct sockaddr_storage const &address2, Port port) {
+    int key[NUM_RECORDS_IN_KEY_TOTAL];
+    setKey(key, address1, address2, port);
+    return fTable->Lookup((char *)key);
+}
+
+Boolean AddressPortLookupTable::Remove(struct sockaddr_storage const &address1, struct sockaddr_storage const &address2, Port port) {
+    int key[NUM_RECORDS_IN_KEY_TOTAL];
+    setKey(key, address1, address2, port);
+    return fTable->Remove((char *)key);
+}
+
+AddressPortLookupTable::Iterator::Iterator(AddressPortLookupTable &table) : fIter(HashTable::Iterator::create(*(table.fTable))) {}
+
+AddressPortLookupTable::Iterator::~Iterator() {
+    delete fIter;
+}
+
+void *AddressPortLookupTable::Iterator::next() {
+    char const *key;  // dummy
+    return fIter->next(key);
+}
+
+////////// IsMulticastAddress() implementation //////////
+
+Boolean IsMulticastAddress(struct sockaddr_storage const &address) {
+    switch(address.ss_family) {
+    case AF_INET: {
+        ipv4AddressBits addressInNetworkOrder = htonl(((sockaddr_in const &)address).sin_addr.s_addr);
+        // Note: We return False for addresses in the range 224.0.0.0
+        // through 224.0.0.255, because these are non-routable
+        return addressInNetworkOrder > 0xE00000FF && addressInNetworkOrder <= 0xEFFFFFFF;
+    }
+    case AF_INET6: {
+        // An IPv6 address is multicast if the first byte is 0xFF:
+        return ((sockaddr_in6 const &)address).sin6_addr.s6_addr[0] == 0xFF;
+    }
+    default: {
+        return False;
+    }
+    }
+}
+
+////////// AddressString implementation //////////
+
+AddressString::AddressString(struct sockaddr_in const &addr) {
+    init(addr.sin_addr.s_addr);
+}
+AddressString::AddressString(struct in_addr const &addr) {
+    init(addr.s_addr);
+}
+AddressString::AddressString(ipv4AddressBits const &addr) {
+    init(addr);
+}
+
+AddressString::AddressString(struct sockaddr_in6 const &addr) {
+    init(addr.sin6_addr.s6_addr);
+}
+AddressString::AddressString(struct in6_addr const &addr) {
+    init(addr.s6_addr);
+}
+AddressString::AddressString(ipv6AddressBits const &addr) {
+    init(addr);
+}
+
+AddressString::AddressString(struct sockaddr_storage const &addr) {
+    switch(addr.ss_family) {
+    case AF_INET: {
+        init(((sockaddr_in &)addr).sin_addr.s_addr);
+        break;
+    }
+    case AF_INET6: {
+        init(((sockaddr_in6 &)addr).sin6_addr.s6_addr);
+        break;
+    }
+    default: {
+        fVal = new char[200];  // more than enough for this error message
+        sprintf(fVal, "(unknown address family %d)", addr.ss_family);
+        break;
+    }
+    }
+}
+
+void AddressString::init(ipv4AddressBits const &addr) {
+    fVal = new char[INET_ADDRSTRLEN];
+    inet_ntop(AF_INET, &addr, fVal, INET_ADDRSTRLEN);
+}
+
+void AddressString::init(ipv6AddressBits const &addr) {
+    fVal = new char[INET6_ADDRSTRLEN];
+    inet_ntop(AF_INET6, &addr, fVal, INET6_ADDRSTRLEN);
+}
+
+AddressString::~AddressString() {
+    delete[] fVal;
+}
+
+portNumBits portNum(struct sockaddr_storage const &address) {
+    switch(address.ss_family) {
+    case AF_INET: {
+        return ((sockaddr_in &)address).sin_port;
+    }
+    case AF_INET6: {
+        return ((sockaddr_in6 &)address).sin6_port;
+    }
+    default: {
+        return 0;
+    }
+    }
+}
+
+void setPortNum(struct sockaddr_storage &address, portNumBits portNum /*in network order*/) {
+    ((sockaddr_in &)address).sin_port = portNum;  // position will be the same for "sockaddr_in6"
+}
diff --git a/3rdparty/live555/src/groupsock/NetInterface.cpp b/3rdparty/live555/src/groupsock/NetInterface.cpp
new file mode 100644
index 00000000..fbd7cbdb
--- /dev/null
+++ b/3rdparty/live555/src/groupsock/NetInterface.cpp
@@ -0,0 +1,126 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "groupsock"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// Network Interfaces
+// Implementation
+
+#include "NetInterface.hh"
+#include "GroupsockHelper.hh"
+
+#ifndef NO_SSTREAM
+#include <sstream>
+#endif
+#include <stdio.h>
+
+////////// NetInterface //////////
+
+UsageEnvironment *NetInterface::DefaultUsageEnvironment = NULL;
+
+NetInterface::NetInterface() {}
+
+NetInterface::~NetInterface() {}
+
+////////// Socket //////////
+
+int Socket::DebugLevel = 1;  // default value
+
+Socket::Socket(UsageEnvironment &env, Port port, int family)
+    : fEnv(DefaultUsageEnvironment != NULL ? *DefaultUsageEnvironment : env), fPort(port), fFamily(family) {
+    fSocketNum = setupDatagramSocket(fEnv, port, family);
+}
+
+void Socket::reset() {
+    if(fSocketNum >= 0)
+        closeSocket(fSocketNum);
+    fSocketNum = -1;
+}
+
+Socket::~Socket() {
+    reset();
+}
+
+Boolean Socket::changePort(Port newPort) {
+    int      oldSocketNum         = fSocketNum;
+    unsigned oldReceiveBufferSize = getReceiveBufferSize(fEnv, fSocketNum);
+    unsigned oldSendBufferSize    = getSendBufferSize(fEnv, fSocketNum);
+    closeSocket(fSocketNum);
+
+    fSocketNum = setupDatagramSocket(fEnv, newPort, fFamily);
+    if(fSocketNum < 0) {
+        fEnv.taskScheduler().turnOffBackgroundReadHandling(oldSocketNum);
+        return False;
+    }
+
+    setReceiveBufferTo(fEnv, fSocketNum, oldReceiveBufferSize);
+    setSendBufferTo(fEnv, fSocketNum, oldSendBufferSize);
+    if(fSocketNum != oldSocketNum) {  // the socket number has changed, so move any event handling for it:
+        fEnv.taskScheduler().moveSocketHandling(oldSocketNum, fSocketNum);
+    }
+    return True;
+}
+
+UsageEnvironment &operator<<(UsageEnvironment &s, const Socket &sock) {
+    return s << timestampString() << " Socket(" << sock.socketNum() << ")";
+}
+
+////////// SocketLookupTable //////////
+
+SocketLookupTable::SocketLookupTable() : fTable(HashTable::create(ONE_WORD_HASH_KEYS)) {}
+
+SocketLookupTable::~SocketLookupTable() {
+    delete fTable;
+}
+
+Socket *SocketLookupTable::Fetch(UsageEnvironment &env, Port port, Boolean &isNew) {
+    isNew = False;
+    Socket *sock;
+    do {
+        sock = (Socket *)fTable->Lookup((char *)(long)(port.num()));
+        if(sock == NULL) {  // we need to create one:
+            sock = CreateNew(env, port);
+            if(sock == NULL || sock->socketNum() < 0)
+                break;
+
+            fTable->Add((char *)(long)(port.num()), (void *)sock);
+            isNew = True;
+        }
+
+        return sock;
+    } while(0);
+
+    delete sock;
+    return NULL;
+}
+
+Boolean SocketLookupTable::Remove(Socket const *sock) {
+    return fTable->Remove((char *)(long)(sock->port().num()));
+}
+
+////////// NetInterfaceTrafficStats //////////
+
+NetInterfaceTrafficStats::NetInterfaceTrafficStats() {
+    fTotNumPackets = fTotNumBytes = 0.0;
+}
+
+void NetInterfaceTrafficStats::countPacket(unsigned packetSize) {
+    fTotNumPackets += 1.0;
+    fTotNumBytes += packetSize;
+}
+
+Boolean NetInterfaceTrafficStats::haveSeenTraffic() const {
+    return fTotNumPackets != 0.0;
+}
diff --git a/3rdparty/live555/src/groupsock/include/GroupEId.hh b/3rdparty/live555/src/groupsock/include/GroupEId.hh
new file mode 100644
index 00000000..f65eae60
--- /dev/null
+++ b/3rdparty/live555/src/groupsock/include/GroupEId.hh
@@ -0,0 +1,64 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "multikit" Multicast Application Shell
+// Copyright (c) 1996-2022, Live Networks, Inc.  All rights reserved
+// "Group Endpoint Id"
+// C++ header
+
+#ifndef _GROUPEID_HH
+#define _GROUPEID_HH
+
+#ifndef _BOOLEAN_HH
+#include "Boolean.hh"
+#endif
+
+#ifndef _NET_ADDRESS_HH
+#include "NetAddress.hh"
+#endif
+
+class GroupEId {
+public:
+  GroupEId(struct sockaddr_storage const& groupAddr,
+	   portNumBits portNum, u_int8_t ttl);
+      // used for a 'source-independent multicast' group
+  GroupEId(struct sockaddr_storage const& groupAddr,
+	   struct sockaddr_storage const& sourceFilterAddr,
+	   portNumBits portNum);
+      // used for a 'source-specific multicast' group
+  GroupEId(); // tmp default constructor, until "Groupsock" interface uses "sockaddr_storage"
+
+  struct sockaddr_storage const& groupAddress() const { return fGroupAddress; }
+  struct sockaddr_storage const& sourceFilterAddress() const { return fSourceFilterAddress; }
+
+  Boolean isSSM() const;
+
+  portNumBits portNum() const;
+
+  u_int8_t ttl() const { return fTTL; }
+
+private:
+  void init(struct sockaddr_storage const& groupAddr,
+	    struct sockaddr_storage const& sourceFilterAddr,
+	    portNumBits portNum,
+	    u_int8_t ttl);
+
+private:
+  struct sockaddr_storage fGroupAddress; // also includes port number (in network byte order)
+  struct sockaddr_storage fSourceFilterAddress;
+  u_int8_t fTTL;
+};
+
+#endif
diff --git a/3rdparty/live555/src/groupsock/include/Groupsock.hh b/3rdparty/live555/src/groupsock/include/Groupsock.hh
new file mode 100644
index 00000000..af1d1203
--- /dev/null
+++ b/3rdparty/live555/src/groupsock/include/Groupsock.hh
@@ -0,0 +1,201 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "groupsock"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// 'Group sockets'
+// C++ header
+
+#ifndef _GROUPSOCK_HH
+#define _GROUPSOCK_HH
+
+#ifndef _GROUPSOCK_VERSION_HH
+#include "groupsock_version.hh"
+#endif
+
+#ifndef _NET_INTERFACE_HH
+#include "NetInterface.hh"
+#endif
+
+#ifndef _GROUPEID_HH
+#include "GroupEId.hh"
+#endif
+
+// An "OutputSocket" is (by default) used only to send packets.
+// No packets are received on it (unless a subclass arranges this)
+
+class OutputSocket: public Socket {
+public:
+  OutputSocket(UsageEnvironment& env, int family);
+  virtual ~OutputSocket();
+
+  virtual Boolean write(struct sockaddr_storage const& addressAndPort, u_int8_t ttl,
+			unsigned char* buffer, unsigned bufferSize);
+
+protected:
+  OutputSocket(UsageEnvironment& env, Port port, int family);
+
+  portNumBits sourcePortNum() const {return fSourcePort.num();}
+
+private: // redefined virtual function
+  virtual Boolean handleRead(unsigned char* buffer, unsigned bufferMaxSize,
+			     unsigned& bytesRead,
+			     struct sockaddr_storage& fromAddressAndPort);
+
+private:
+  Port fSourcePort;
+  unsigned fLastSentTTL;
+};
+
+class destRecord {
+public:
+  destRecord(struct sockaddr_storage const& addr, Port const& port, u_int8_t ttl, unsigned sessionId,
+	     destRecord* next);
+  virtual ~destRecord();
+
+public:
+  destRecord* fNext;
+  GroupEId fGroupEId;
+  unsigned fSessionId;
+};
+
+// A "Groupsock" is used to both send and receive packets.
+// As the name suggests, it was originally designed to send/receive
+// multicast, but it can send/receive unicast as well.
+
+class Groupsock: public OutputSocket {
+public:
+  Groupsock(UsageEnvironment& env, struct sockaddr_storage const& groupAddr,
+	    Port port, u_int8_t ttl);
+      // used for a 'source-independent multicast' group
+  Groupsock(UsageEnvironment& env, struct sockaddr_storage const& groupAddr,
+	    struct sockaddr_storage const& sourceFilterAddr,
+	    Port port);
+      // used for a 'source-specific multicast' group
+
+  virtual ~Groupsock();
+
+  virtual destRecord* createNewDestRecord(struct sockaddr_storage const& addr, Port const& port, u_int8_t ttl, unsigned sessionId, destRecord* next);
+      // Can be redefined by subclasses that also subclass "destRecord"
+
+  void changeDestinationParameters(struct sockaddr_storage const& newDestAddr,
+				   Port newDestPort, int newDestTTL,
+				   unsigned sessionId = 0);
+      // By default, the destination address, port and ttl for
+      // outgoing packets are those that were specified in
+      // the constructor.  This works OK for multicast sockets,
+      // but for unicast we usually want the destination port
+      // number, at least, to be different from the source port.
+      // (If a parameter is 0 (or ~0 for ttl), then no change is made to that parameter.)
+      // (If no existing "destRecord" exists with this "sessionId", then we add a new "destRecord".)
+  unsigned lookupSessionIdFromDestination(struct sockaddr_storage const& destAddrAndPort) const;
+      // returns 0 if not found
+
+  // As a special case, we also allow multiple destinations (addresses & ports)
+  // (This can be used to implement multi-unicast.)
+  virtual void addDestination(struct sockaddr_storage const& addr, Port const& port,
+			      unsigned sessionId);
+  virtual void removeDestination(unsigned sessionId);
+  void removeAllDestinations();
+  Boolean hasMultipleDestinations() const { return fDests != NULL && fDests->fNext != NULL; }
+
+  struct sockaddr_storage const& groupAddress() const {
+    return fIncomingGroupEId.groupAddress();
+  }
+  struct sockaddr_storage const& sourceFilterAddress() const {
+    return fIncomingGroupEId.sourceFilterAddress();
+  }
+
+  Boolean isSSM() const {
+    return fIncomingGroupEId.isSSM();
+  }
+
+  u_int8_t ttl() const { return fIncomingGroupEId.ttl(); }
+
+  void multicastSendOnly(); // send, but don't receive any multicast packets
+
+  virtual Boolean output(UsageEnvironment& env, unsigned char* buffer, unsigned bufferSize);
+
+  static NetInterfaceTrafficStats statsIncoming;
+  static NetInterfaceTrafficStats statsOutgoing;
+  NetInterfaceTrafficStats statsGroupIncoming; // *not* static
+  NetInterfaceTrafficStats statsGroupOutgoing; // *not* static
+
+  Boolean wasLoopedBackFromUs(UsageEnvironment& env,
+			      struct sockaddr_storage const& fromAddressAndPort);
+
+public: // redefined virtual functions
+  virtual Boolean handleRead(unsigned char* buffer, unsigned bufferMaxSize,
+			     unsigned& bytesRead,
+			     struct sockaddr_storage& fromAddressAndPort);
+
+protected:
+  destRecord* lookupDestRecordFromDestination(struct sockaddr_storage const& targetAddrAndPort) const;
+
+private:
+  void removeDestinationFrom(destRecord*& dests, unsigned sessionId);
+    // used to implement (the public) "removeDestination()", and "changeDestinationParameters()"
+protected:
+  destRecord* fDests;
+private:
+  GroupEId fIncomingGroupEId;
+};
+
+UsageEnvironment& operator<<(UsageEnvironment& s, const Groupsock& g);
+
+// A data structure for looking up a 'groupsock'
+// by (multicast address, port), or by socket number
+class GroupsockLookupTable {
+public:
+  Groupsock* Fetch(UsageEnvironment& env, struct sockaddr_storage const& groupAddress,
+		   Port port, u_int8_t ttl, Boolean& isNew);
+      // Creates a new Groupsock if none already exists
+  Groupsock* Fetch(UsageEnvironment& env, struct sockaddr_storage const& groupAddress,
+		   struct sockaddr_storage const& sourceFilterAddr,
+		   Port port, Boolean& isNew);
+      // Creates a new Groupsock if none already exists
+  Groupsock* Lookup(struct sockaddr_storage const& groupAddress, Port port);
+      // Returns NULL if none already exists
+  Groupsock* Lookup(struct sockaddr_storage const& groupAddress,
+		    struct sockaddr_storage const& sourceFilterAddr,
+		    Port port);
+      // Returns NULL if none already exists
+  Groupsock* Lookup(UsageEnvironment& env, int sock);
+      // Returns NULL if none already exists
+  Boolean Remove(Groupsock const* groupsock);
+
+  // Used to iterate through the groupsocks in the table
+  class Iterator {
+  public:
+    Iterator(GroupsockLookupTable& groupsocks);
+
+    Groupsock* next(); // NULL iff none
+
+  private:
+    AddressPortLookupTable::Iterator fIter;
+  };
+
+private:
+  Groupsock* AddNew(UsageEnvironment& env,
+		    struct sockaddr_storage const& groupAddress,
+		    struct sockaddr_storage const& sourceFilterAddress,
+		    Port port, u_int8_t ttl);
+
+private:
+  friend class Iterator;
+  AddressPortLookupTable fTable;
+};
+
+#endif
diff --git a/3rdparty/live555/src/groupsock/include/GroupsockHelper.hh b/3rdparty/live555/src/groupsock/include/GroupsockHelper.hh
new file mode 100644
index 00000000..960b56d0
--- /dev/null
+++ b/3rdparty/live555/src/groupsock/include/GroupsockHelper.hh
@@ -0,0 +1,160 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "groupsock"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// Helper routines to implement 'group sockets'
+// C++ header
+
+#ifndef _GROUPSOCK_HELPER_HH
+#define _GROUPSOCK_HELPER_HH
+
+#ifndef _NET_ADDRESS_HH
+#include "NetAddress.hh"
+#endif
+
+int setupDatagramSocket(UsageEnvironment& env, Port port, int domain);
+int setupStreamSocket(UsageEnvironment& env, Port port, int domain,
+		      Boolean makeNonBlocking = True, Boolean setKeepAlive = False);
+
+int readSocket(UsageEnvironment& env,
+	       int socket, unsigned char* buffer, unsigned bufferSize,
+	       struct sockaddr_storage& fromAddress /*set only if we're a datagram socket*/);
+
+Boolean writeSocket(UsageEnvironment& env,
+		    int socket, struct sockaddr_storage const& addressAndPort,
+		    u_int8_t ttlArg,
+		    unsigned char* buffer, unsigned bufferSize);
+
+Boolean writeSocket(UsageEnvironment& env,
+		    int socket, struct sockaddr_storage const& addressAndPort,
+		    unsigned char* buffer, unsigned bufferSize);
+    // An optimized version of "writeSocket" that omits the "setsockopt()" call to set the TTL.
+
+void ignoreSigPipeOnSocket(int socketNum);
+
+unsigned getSendBufferSize(UsageEnvironment& env, int socket);
+unsigned getReceiveBufferSize(UsageEnvironment& env, int socket);
+unsigned setSendBufferTo(UsageEnvironment& env,
+			 int socket, unsigned requestedSize);
+unsigned setReceiveBufferTo(UsageEnvironment& env,
+			    int socket, unsigned requestedSize);
+unsigned increaseSendBufferTo(UsageEnvironment& env,
+			      int socket, unsigned requestedSize);
+unsigned increaseReceiveBufferTo(UsageEnvironment& env,
+				 int socket, unsigned requestedSize);
+
+Boolean makeSocketNonBlocking(int sock);
+Boolean makeSocketBlocking(int sock, unsigned writeTimeoutInMilliseconds = 0);
+  // A "writeTimeoutInMilliseconds" value of 0 means: Don't timeout
+Boolean setSocketKeepAlive(int sock);
+
+Boolean socketJoinGroup(UsageEnvironment& env, int socket,
+			struct sockaddr_storage const& groupAddress);
+Boolean socketLeaveGroup(UsageEnvironment&, int socket,
+			 struct sockaddr_storage const& groupAddress);
+
+// source-specific multicast join/leave
+Boolean socketJoinGroupSSM(UsageEnvironment& env, int socket,
+			   struct sockaddr_storage const& groupAddress,
+			   struct sockaddr_storage const& sourceFilterAddr);
+Boolean socketLeaveGroupSSM(UsageEnvironment&, int socket,
+			    struct sockaddr_storage const& groupAddress,
+			    struct sockaddr_storage const& sourceFilterAddr);
+
+Boolean getSourcePort(UsageEnvironment& env, int socket, int domain, Port& port);
+
+ipv4AddressBits ourIPv4Address(UsageEnvironment& env); // in network order
+ipv6AddressBits const& ourIPv6Address(UsageEnvironment& env);
+
+Boolean weHaveAnIPv4Address(UsageEnvironment& env);
+Boolean weHaveAnIPv6Address(UsageEnvironment& env);
+Boolean weHaveAnIPAddress(UsageEnvironment& env);
+  // returns True if we have either an IPv4 or an IPv6 address
+
+// IPv4 addresses of our sending and receiving interfaces.  (By default, these
+// are INADDR_ANY (i.e., 0), specifying the default interface.)
+extern ipv4AddressBits SendingInterfaceAddr;
+extern ipv4AddressBits ReceivingInterfaceAddr;
+
+// Allocates a randomly-chosen IPv4 SSM (multicast) address:
+ipv4AddressBits chooseRandomIPv4SSMAddress(UsageEnvironment& env);
+
+// Returns a simple "hh:mm:ss" string, for use in debugging output (e.g.)
+char const* timestampString();
+
+
+#ifdef HAVE_SOCKADDR_LEN
+#define SET_SOCKADDR_SIN_LEN(var) var.sin_len = sizeof var
+#define SET_SOCKADDR_SIN6_LEN(var) var.sin6_len = sizeof var
+#else
+#define SET_SOCKADDR_SIN_LEN(var)
+#define SET_SOCKADDR_SIN6_LEN(var)
+#endif
+
+#define MAKE_SOCKADDR_IN(var,adr,prt) /*adr,prt must be in network order*/\
+    struct sockaddr_in var;\
+    var.sin_family = AF_INET;\
+    var.sin_addr.s_addr = (adr);\
+    var.sin_port = (prt);\
+    SET_SOCKADDR_SIN_LEN(var);
+#define MAKE_SOCKADDR_IN6(var,prt) /*adr,prt must be in network order*/\
+    struct sockaddr_in6 var;\
+    memset(&var, 0, sizeof var);\
+    var.sin6_family = AF_INET6;\
+    var.sin6_port = (prt);\
+    SET_SOCKADDR_SIN6_LEN(var);
+
+
+// By default, we create sockets with the SO_REUSE_* flag set.
+// If, instead, you want to create sockets without the SO_REUSE_* flags,
+// Then enclose the creation code with:
+//          {
+//            NoReuse dummy;
+//            ...
+//          }
+class NoReuse {
+public:
+  NoReuse(UsageEnvironment& env);
+  ~NoReuse();
+
+private:
+  UsageEnvironment& fEnv;
+};
+
+
+// Define the "UsageEnvironment"-specific "groupsockPriv" structure:
+
+struct _groupsockPriv { // There should be only one of these allocated
+  HashTable* socketTable;
+  int reuseFlag;
+};
+_groupsockPriv* groupsockPriv(UsageEnvironment& env); // allocates it if necessary
+void reclaimGroupsockPriv(UsageEnvironment& env);
+
+
+#if (defined(__WIN32__) || defined(_WIN32)) && !defined(__MINGW32__)
+// For Windoze, we need to implement our own gettimeofday()
+extern int gettimeofday(struct timeval*, int*);
+#else
+#include <sys/time.h>
+#endif
+
+// The following are implemented in inet.c:
+extern "C" void our_srandom(int x);
+extern "C" long our_random();
+extern "C" u_int32_t our_random32(); // because "our_random()" returns a 31-bit number
+
+#endif
diff --git a/3rdparty/live555/src/groupsock/include/IOHandlers.hh b/3rdparty/live555/src/groupsock/include/IOHandlers.hh
new file mode 100644
index 00000000..b4be08d9
--- /dev/null
+++ b/3rdparty/live555/src/groupsock/include/IOHandlers.hh
@@ -0,0 +1,31 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "groupsock"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// IO event handlers
+// C++ header
+
+#ifndef _IO_HANDLERS_HH
+#define _IO_HANDLERS_HH
+
+#ifndef _NET_INTERFACE_HH
+#include "NetInterface.hh"
+#endif
+
+// Handles incoming data on sockets:
+void socketReadHandler(Socket* sock, int mask);
+
+#endif
diff --git a/3rdparty/live555/src/groupsock/include/NetAddress.hh b/3rdparty/live555/src/groupsock/include/NetAddress.hh
new file mode 100644
index 00000000..22d726ce
--- /dev/null
+++ b/3rdparty/live555/src/groupsock/include/NetAddress.hh
@@ -0,0 +1,209 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "groupsock"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// Network Addresses
+// C++ header
+
+#ifndef _NET_ADDRESS_HH
+#define _NET_ADDRESS_HH
+
+#ifndef _HASH_TABLE_HH
+#include "HashTable.hh"
+#endif
+
+#ifndef _NET_COMMON_H
+#include "NetCommon.h"
+#endif
+
+#ifndef _USAGE_ENVIRONMENT_HH
+#include "UsageEnvironment.hh"
+#endif
+
+// Definition of a type representing a low-level network address.
+    // Note that the type "netAddressBits" is no longer defined; use "ipv4AddressBits" instead.
+typedef u_int32_t ipv4AddressBits;
+typedef u_int8_t ipv6AddressBits[16]; // 128 bits
+
+class NetAddress {
+public:
+  NetAddress(u_int8_t const* data,
+	     unsigned length = 4 /* default: 32 bits (for IPv4); use 16 (128 bits) for IPv6 */);
+  NetAddress(unsigned length = 4); // sets address data to all-zeros
+  NetAddress(NetAddress const& orig);
+  NetAddress& operator=(NetAddress const& rightSide);
+  virtual ~NetAddress();
+  
+  unsigned length() const { return fLength; }
+  u_int8_t const* data() const // always in network byte order
+  { return fData; }
+  
+private:
+  void assign(u_int8_t const* data, unsigned length);
+  void clean();
+  
+  unsigned fLength;
+  u_int8_t* fData;
+};
+
+struct sockaddr_storage const& nullAddress(int addressFamily = AF_INET);
+Boolean addressIsNull(sockaddr_storage const& address);
+
+SOCKLEN_T addressSize(sockaddr_storage const& address);
+
+void copyAddress(struct sockaddr_storage& to, NetAddress const* from);
+
+Boolean operator==(struct sockaddr_storage const& left, struct sockaddr_storage const& right);
+    // compares the family and address parts only; not the port number or anything else
+
+class NetAddressList {
+public:
+  NetAddressList(char const* hostname, int addressFamily = AF_UNSPEC);
+  NetAddressList(NetAddressList const& orig);
+  NetAddressList& operator=(NetAddressList const& rightSide);
+  virtual ~NetAddressList();
+  
+  unsigned numAddresses() const { return fNumAddresses; }
+  
+  NetAddress const* firstAddress() const;
+  
+  // Used to iterate through the addresses in a list:
+  class Iterator {
+  public:
+    Iterator(NetAddressList const& addressList);
+    NetAddress const* nextAddress(); // NULL iff none
+  private:
+    NetAddressList const& fAddressList;
+    unsigned fNextIndex;
+  };
+  
+private:
+  void assign(unsigned numAddresses, NetAddress** addressArray);
+  void clean();
+  
+  friend class Iterator;
+  unsigned fNumAddresses;
+  NetAddress** fAddressArray;
+};
+
+typedef u_int16_t portNumBits;
+
+class Port {
+public:
+  Port(portNumBits num /* in host byte order */);
+  
+  portNumBits num() const { return fPortNum; } // in network byte order
+  
+private:
+  portNumBits fPortNum; // stored in network byte order
+#ifdef IRIX
+  portNumBits filler; // hack to overcome a bug in IRIX C++ compiler
+#endif
+};
+
+UsageEnvironment& operator<<(UsageEnvironment& s, const Port& p);
+
+
+// A generic table for looking up objects by (address1, address2, port)
+class AddressPortLookupTable {
+public:
+  AddressPortLookupTable();
+  virtual ~AddressPortLookupTable();
+  
+  void* Add(struct sockaddr_storage const& address1,
+	    struct sockaddr_storage const& address2,
+	    Port port,
+	    void* value);
+      // Returns the old value if different, otherwise 0
+  void* Add(struct sockaddr_storage const& address1,
+	    Port port,
+	    void* value) {
+    return Add(address1, nullAddress(), port, value);
+  }
+
+  Boolean Remove(struct sockaddr_storage const& address1,
+		 struct sockaddr_storage const& address2,
+		 Port port);
+  Boolean Remove(struct sockaddr_storage const& address1,
+		 Port port) {
+    return Remove(address1, nullAddress(), port);
+  }
+
+  void* Lookup(struct sockaddr_storage const& address1,
+	       struct sockaddr_storage const& address2,
+	       Port port);
+      // Returns 0 if not found
+  void* Lookup(struct sockaddr_storage const& address1,
+	       Port port) {
+    return Lookup(address1, nullAddress(), port);
+  }
+
+  void* RemoveNext() { return fTable->RemoveNext(); }
+
+  // Used to iterate through the entries in the table
+  class Iterator {
+  public:
+    Iterator(AddressPortLookupTable& table);
+    virtual ~Iterator();
+    
+    void* next(); // NULL iff none
+    
+  private:
+    HashTable::Iterator* fIter;
+  };
+  
+private:
+  friend class Iterator;
+  HashTable* fTable;
+};
+
+
+Boolean IsMulticastAddress(struct sockaddr_storage const& address);
+
+
+// A mechanism for displaying an IP (v4 or v6) address in ASCII.
+// (This encapsulates the "inet_ntop()" function.)
+class AddressString {
+public:
+  // IPv4 input:
+  AddressString(struct sockaddr_in const& addr);
+  AddressString(struct in_addr const& addr);
+  AddressString(ipv4AddressBits const& addr); // "addr" is assumed to be in network byte order
+
+  // IPv6 input:
+  AddressString(struct sockaddr_in6 const& addr);
+  AddressString(struct in6_addr const& addr);
+  AddressString(ipv6AddressBits const& addr);
+
+  // IPv4 or IPv6 input:
+  AddressString(struct sockaddr_storage const& addr);
+
+  virtual ~AddressString();
+
+  char const* val() const { return fVal; }
+
+private:
+  void init(ipv4AddressBits const& addr); // used to implement the IPv4 constructors
+  void init(ipv6AddressBits const& addr); // used to implement the IPv6 constructors
+
+private:
+  char* fVal; // The result ASCII string: allocated by the constructor; deleted by the destructor
+};
+
+portNumBits portNum(struct sockaddr_storage const& address);
+void setPortNum(struct sockaddr_storage& address, portNumBits portNum/*in network order*/);
+
+#endif
diff --git a/3rdparty/live555/src/groupsock/include/NetCommon.h b/3rdparty/live555/src/groupsock/include/NetCommon.h
new file mode 100644
index 00000000..db69192c
--- /dev/null
+++ b/3rdparty/live555/src/groupsock/include/NetCommon.h
@@ -0,0 +1,130 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+/* "groupsock" interface
+ * Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+ * Common include files, typically used for networking
+ */
+
+#ifndef _NET_COMMON_H
+#define _NET_COMMON_H
+
+#if defined(__WIN32__) || defined(_WIN32) || defined(_WIN32_WCE)
+/* Windows */
+#if defined(WINNT) || defined(_WINNT) || defined(__BORLANDC__) || defined(__MINGW32__) || defined(_WIN32_WCE) || defined(_MSC_VER)
+#define _MSWSOCK_
+#include <winsock2.h>
+#include <ws2tcpip.h>
+#endif
+#include <windows.h>
+#include <errno.h>
+#include <string.h>
+
+#define closeSocket closesocket
+#ifdef EWOULDBLOCK
+#undef EWOULDBLOCK
+#endif
+#ifdef EINPROGRESS
+#undef EINPROGRESS
+#endif
+#ifdef EAGAIN
+#undef EAGAIN
+#endif
+#ifdef EINTR
+#undef EINTR
+#endif
+#define EWOULDBLOCK WSAEWOULDBLOCK
+#define EINPROGRESS WSAEWOULDBLOCK
+#define EAGAIN WSAEWOULDBLOCK
+#define EINTR WSAEINTR
+
+#if defined(_WIN32_WCE)
+#define NO_STRSTREAM 1
+#endif
+
+/* Definitions of size-specific types: */
+typedef __int64          int64_t;
+typedef unsigned __int64 u_int64_t;
+
+typedef int      int32_t;
+typedef unsigned u_int32_t;
+
+typedef short          int16_t;
+typedef unsigned short u_int16_t;
+
+typedef unsigned char u_int8_t;
+
+// For "uintptr_t" and "intptr_t", we assume that if they're not already defined, then this must be
+// an old, 32-bit version of Windows:
+#if !defined(_MSC_STDINT_H_) && !defined(_UINTPTR_T_DEFINED) && !defined(_UINTPTR_T_DECLARED) && !defined(_UINTPTR_T)
+typedef unsigned uintptr_t;
+#endif
+#if !defined(_MSC_STDINT_H_) && !defined(_INTPTR_T_DEFINED) && !defined(_INTPTR_T_DECLARED) && !defined(_INTPTR_T)
+typedef int intptr_t;
+#endif
+
+#elif defined(VXWORKS)
+/* VxWorks */
+#include <time.h>
+#include <timers.h>
+#include <sys/times.h>
+#include <sockLib.h>
+#include <hostLib.h>
+#include <resolvLib.h>
+#include <ioLib.h>
+
+typedef unsigned int   u_int32_t;
+typedef unsigned short u_int16_t;
+typedef unsigned char  u_int8_t;
+
+#else
+/* Unix */
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/time.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <netdb.h>
+#include <unistd.h>
+#include <string.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <strings.h>
+#include <ctype.h>
+#include <stdint.h>
+#if defined(_QNX4)
+#include <sys/select.h>
+#include <unix.h>
+#endif
+
+#define closeSocket close
+
+#ifdef SOLARIS
+#define u_int64_t uint64_t
+#define u_int32_t uint32_t
+#define u_int16_t uint16_t
+#define u_int8_t uint8_t
+#endif
+#endif
+
+#ifndef SOCKLEN_T
+#if defined(ANDROID) || defined(OS_MACOS)
+#define SOCKLEN_T socklen_t
+#else
+#define SOCKLEN_T int
+#endif
+#endif
+
+#endif
diff --git a/3rdparty/live555/src/groupsock/include/NetInterface.hh b/3rdparty/live555/src/groupsock/include/NetInterface.hh
new file mode 100644
index 00000000..ea61828e
--- /dev/null
+++ b/3rdparty/live555/src/groupsock/include/NetInterface.hh
@@ -0,0 +1,109 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "groupsock"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// Network Interfaces
+// C++ header
+
+#ifndef _NET_INTERFACE_HH
+#define _NET_INTERFACE_HH
+
+#ifndef _NET_ADDRESS_HH
+#include "NetAddress.hh"
+#endif
+
+class NetInterface {
+public:
+  virtual ~NetInterface();
+
+  static UsageEnvironment* DefaultUsageEnvironment;
+      // if non-NULL, used for each new interface
+
+protected:
+  NetInterface(); // virtual base class
+};
+
+class Socket: public NetInterface {
+public:
+  virtual ~Socket();
+  void reset(); // closes the socket, and sets "fSocketNum" to -1
+
+  virtual Boolean handleRead(unsigned char* buffer, unsigned bufferMaxSize,
+			     unsigned& bytesRead,
+			     struct sockaddr_storage& fromAddress) = 0;
+      // Returns False on error; resultData == NULL if data ignored
+
+  int socketNum() const { return fSocketNum; }
+
+  Port port() const {
+    return fPort;
+  }
+
+  UsageEnvironment& env() const { return fEnv; }
+
+  static int DebugLevel;
+
+protected:
+  Socket(UsageEnvironment& env, Port port, int family); // virtual base class
+
+  Boolean changePort(Port newPort); // will also cause socketNum() to change
+
+private:
+  int fSocketNum;
+  UsageEnvironment& fEnv;
+  Port fPort;
+  int fFamily;
+};
+
+UsageEnvironment& operator<<(UsageEnvironment& s, const Socket& sock);
+
+// A data structure for looking up a Socket by port:
+
+class SocketLookupTable {
+public:
+  virtual ~SocketLookupTable();
+
+  Socket* Fetch(UsageEnvironment& env, Port port, Boolean& isNew);
+  // Creates a new Socket if none already exists
+  Boolean Remove(Socket const* sock);
+
+protected:
+  SocketLookupTable(); // abstract base class
+  virtual Socket* CreateNew(UsageEnvironment& env, Port port) = 0;
+
+private:
+  HashTable* fTable;
+};
+
+// A data structure for counting traffic:
+
+class NetInterfaceTrafficStats {
+public:
+  NetInterfaceTrafficStats();
+
+  void countPacket(unsigned packetSize);
+
+  float totNumPackets() const {return fTotNumPackets;}
+  float totNumBytes() const {return fTotNumBytes;}
+
+  Boolean haveSeenTraffic() const;
+
+private:
+  float fTotNumPackets;
+  float fTotNumBytes;
+};
+
+#endif
diff --git a/3rdparty/live555/src/groupsock/include/groupsock_version.hh b/3rdparty/live555/src/groupsock/include/groupsock_version.hh
new file mode 100644
index 00000000..175f0d3b
--- /dev/null
+++ b/3rdparty/live555/src/groupsock/include/groupsock_version.hh
@@ -0,0 +1,25 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// Version information for the "groupsock" library
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+
+#ifndef _GROUPSOCK_VERSION_HH
+#define _GROUPSOCK_VERSION_HH
+
+#define GROUPSOCK_LIBRARY_VERSION_STRING	"2022.04.26"
+#define GROUPSOCK_LIBRARY_VERSION_INT		1650931200
+
+#endif
diff --git a/3rdparty/live555/src/groupsock/inet.c b/3rdparty/live555/src/groupsock/inet.c
new file mode 100644
index 00000000..9946dcd2
--- /dev/null
+++ b/3rdparty/live555/src/groupsock/inet.c
@@ -0,0 +1,435 @@
+#ifndef _NET_COMMON_H
+#include "NetCommon.h"
+#endif
+
+#include <stdio.h>
+
+#ifdef VXWORKS
+#include <inetLib.h>
+#endif
+
+#if defined(__WIN32__) || defined(_WIN32)
+#ifndef IMN_PIM
+#define WS_VERSION_CHOICE1 0x202 /*MAKEWORD(2,2)*/
+#define WS_VERSION_CHOICE2 0x101 /*MAKEWORD(1,1)*/
+int initializeWinsockIfNecessary(void) {
+    /* We need to call an initialization routine before
+     * we can do anything with winsock.  (How fucking lame!):
+     */
+    static int _haveInitializedWinsock = 0;
+    WSADATA    wsadata;
+
+    if(!_haveInitializedWinsock) {
+        if((WSAStartup(WS_VERSION_CHOICE1, &wsadata) != 0) && ((WSAStartup(WS_VERSION_CHOICE2, &wsadata)) != 0)) {
+            return 0; /* error in initialization */
+        }
+        if((wsadata.wVersion != WS_VERSION_CHOICE1) && (wsadata.wVersion != WS_VERSION_CHOICE2)) {
+            WSACleanup();
+            return 0; /* desired Winsock version was not available */
+        }
+        _haveInitializedWinsock = 1;
+    }
+
+    return 1;
+}
+#else
+int initializeWinsockIfNecessary(void) {
+    return 1;
+}
+#endif
+#else
+#define initializeWinsockIfNecessary() 1
+#endif
+
+#ifndef NULL
+#define NULL 0
+#endif
+
+#ifdef USE_SYSTEM_RANDOM
+/* Use the system-supplied "random()" and "srandom()" functions */
+#include <stdlib.h>
+long our_random() {
+#if defined(__WIN32__) || defined(_WIN32)
+    return rand();
+#else
+    return random();
+#endif
+}
+void our_srandom(unsigned int x) {
+#if defined(__WIN32__) || defined(_WIN32)
+    srand(x);
+#else
+    srandom(x);
+#endif
+}
+
+#else
+
+/* Use our own implementation of the "random()" and "srandom()" functions */
+/*
+ * random.c:
+ *
+ * An improved random number generation package.  In addition to the standard
+ * rand()/srand() like interface, this package also has a special state info
+ * interface.  The our_initstate() routine is called with a seed, an array of
+ * bytes, and a count of how many bytes are being passed in; this array is
+ * then initialized to contain information for random number generation with
+ * that much state information.  Good sizes for the amount of state
+ * information are 32, 64, 128, and 256 bytes.  The state can be switched by
+ * calling the our_setstate() routine with the same array as was initiallized
+ * with our_initstate().  By default, the package runs with 128 bytes of state
+ * information and generates far better random numbers than a linear
+ * congruential generator.  If the amount of state information is less than
+ * 32 bytes, a simple linear congruential R.N.G. is used.
+ *
+ * Internally, the state information is treated as an array of longs; the
+ * zeroeth element of the array is the type of R.N.G. being used (small
+ * integer); the remainder of the array is the state information for the
+ * R.N.G.  Thus, 32 bytes of state information will give 7 longs worth of
+ * state information, which will allow a degree seven polynomial.  (Note:
+ * the zeroeth word of state information also has some other information
+ * stored in it -- see our_setstate() for details).
+ *
+ * The random number generation technique is a linear feedback shift register
+ * approach, employing trinomials (since there are fewer terms to sum up that
+ * way).  In this approach, the least significant bit of all the numbers in
+ * the state table will act as a linear feedback shift register, and will
+ * have period 2^deg - 1 (where deg is the degree of the polynomial being
+ * used, assuming that the polynomial is irreducible and primitive).  The
+ * higher order bits will have longer periods, since their values are also
+ * influenced by pseudo-random carries out of the lower bits.  The total
+ * period of the generator is approximately deg*(2**deg - 1); thus doubling
+ * the amount of state information has a vast influence on the period of the
+ * generator.  Note: the deg*(2**deg - 1) is an approximation only good for
+ * large deg, when the period of the shift register is the dominant factor.
+ * With deg equal to seven, the period is actually much longer than the
+ * 7*(2**7 - 1) predicted by this formula.
+ */
+
+/*
+ * For each of the currently supported random number generators, we have a
+ * break value on the amount of state information (you need at least this
+ * many bytes of state info to support this random number generator), a degree
+ * for the polynomial (actually a trinomial) that the R.N.G. is based on, and
+ * the separation between the two lower order coefficients of the trinomial.
+ */
+#define TYPE_0 0 /* linear congruential */
+#define BREAK_0 8
+#define DEG_0 0
+#define SEP_0 0
+
+#define TYPE_1 1 /* x**7 + x**3 + 1 */
+#define BREAK_1 32
+#define DEG_1 7
+#define SEP_1 3
+
+#define TYPE_2 2 /* x**15 + x + 1 */
+#define BREAK_2 64
+#define DEG_2 15
+#define SEP_2 1
+
+#define TYPE_3 3 /* x**31 + x**3 + 1 */
+#define BREAK_3 128
+#define DEG_3 31
+#define SEP_3 3
+
+#define TYPE_4 4 /* x**63 + x + 1 */
+#define BREAK_4 256
+#define DEG_4 63
+#define SEP_4 1
+
+/*
+ * Array versions of the above information to make code run faster --
+ * relies on fact that TYPE_i == i.
+ */
+#define MAX_TYPES 5 /* max number of types above */
+
+static int const degrees[MAX_TYPES] = { DEG_0, DEG_1, DEG_2, DEG_3, DEG_4 };
+static int const seps[MAX_TYPES]    = { SEP_0, SEP_1, SEP_2, SEP_3, SEP_4 };
+
+/*
+ * Initially, everything is set up as if from:
+ *
+ *	our_initstate(1, &randtbl, 128);
+ *
+ * Note that this initialization takes advantage of the fact that srandom()
+ * advances the front and rear pointers 10*rand_deg times, and hence the
+ * rear pointer which starts at 0 will also end up at zero; thus the zeroeth
+ * element of the state information, which contains info about the current
+ * position of the rear pointer is just
+ *
+ *	MAX_TYPES * (rptr - state) + TYPE_3 == TYPE_3.
+ */
+
+static long randtbl[DEG_3 + 1] = {
+    TYPE_3,     0x9a319039, 0x32d9c024, 0x9b663182, 0x5da1f342, 0xde3b81e0, 0xdf0a6fb5, 0xf103bc02, 0x48f340fb, 0x7449e56b, 0xbeb1dbb0,
+    0xab5c5918, 0x946554fd, 0x8c2e680f, 0xeb3d799f, 0xb11ee0b7, 0x2d436b86, 0xda672e2a, 0x1588ca88, 0xe369735d, 0x904f35f7, 0xd7158fd6,
+    0x6fa6f051, 0x616e6b96, 0xac94efdc, 0x36413f93, 0xc622c298, 0xf5a42ab8, 0x8a88d77b, 0xf5ad9d0e, 0x8999220b, 0x27fb47b9,
+};
+
+/*
+ * fptr and rptr are two pointers into the state info, a front and a rear
+ * pointer.  These two pointers are always rand_sep places aparts, as they
+ * cycle cyclically through the state information.  (Yes, this does mean we
+ * could get away with just one pointer, but the code for random() is more
+ * efficient this way).  The pointers are left positioned as they would be
+ * from the call
+ *
+ *	our_initstate(1, randtbl, 128);
+ *
+ * (The position of the rear pointer, rptr, is really 0 (as explained above
+ * in the initialization of randtbl) because the state table pointer is set
+ * to point to randtbl[1] (as explained below).
+ */
+static long *fptr = &randtbl[SEP_3 + 1];
+static long *rptr = &randtbl[1];
+
+/*
+ * The following things are the pointer to the state information table, the
+ * type of the current generator, the degree of the current polynomial being
+ * used, and the separation between the two pointers.  Note that for efficiency
+ * of random(), we remember the first location of the state information, not
+ * the zeroeth.  Hence it is valid to access state[-1], which is used to
+ * store the type of the R.N.G.  Also, we remember the last location, since
+ * this is more efficient than indexing every time to find the address of
+ * the last element to see if the front and rear pointers have wrapped.
+ */
+static long *state     = &randtbl[1];
+static int   rand_type = TYPE_3;
+static int   rand_deg  = DEG_3;
+static int   rand_sep  = SEP_3;
+static long *end_ptr   = &randtbl[DEG_3 + 1];
+
+/*
+ * srandom:
+ *
+ * Initialize the random number generator based on the given seed.  If the
+ * type is the trivial no-state-information type, just remember the seed.
+ * Otherwise, initializes state[] based on the given "seed" via a linear
+ * congruential generator.  Then, the pointers are set to known locations
+ * that are exactly rand_sep places apart.  Lastly, it cycles the state
+ * information a given number of times to get rid of any initial dependencies
+ * introduced by the L.C.R.N.G.  Note that the initialization of randtbl[]
+ * for default usage relies on values produced by this routine.
+ */
+long our_random(void); /*forward*/
+void our_srandom(unsigned int x) {
+    register int i;
+
+    if(rand_type == TYPE_0)
+        state[0] = x;
+    else {
+        state[0] = x;
+        for(i = 1; i < rand_deg; i++)
+            state[i] = 1103515245 * state[i - 1] + 12345;
+        fptr = &state[rand_sep];
+        rptr = &state[0];
+        for(i = 0; i < 10 * rand_deg; i++)
+            (void)our_random();
+    }
+}
+
+/*
+ * our_initstate:
+ *
+ * Initialize the state information in the given array of n bytes for future
+ * random number generation.  Based on the number of bytes we are given, and
+ * the break values for the different R.N.G.'s, we choose the best (largest)
+ * one we can and set things up for it.  srandom() is then called to
+ * initialize the state information.
+ *
+ * Note that on return from srandom(), we set state[-1] to be the type
+ * multiplexed with the current value of the rear pointer; this is so
+ * successive calls to our_initstate() won't lose this information and will be
+ * able to restart with our_setstate().
+ *
+ * Note: the first thing we do is save the current state, if any, just like
+ * our_setstate() so that it doesn't matter when our_initstate is called.
+ *
+ * Returns a pointer to the old state.
+ */
+char *our_initstate(seed, arg_state, n) unsigned int seed; /* seed for R.N.G. */
+char *arg_state;                                           /* pointer to state array */
+int   n;                                                   /* # bytes of state info */
+{
+    register char *ostate = (char *)(&state[-1]);
+
+    if(rand_type == TYPE_0)
+        state[-1] = rand_type;
+    else
+        state[-1] = MAX_TYPES * (rptr - state) + rand_type;
+    if(n < BREAK_0) {
+#ifdef DEBUG
+        (void)fprintf(stderr, "random: not enough state (%d bytes); ignored.\n", n);
+#endif
+        return (0);
+    }
+    if(n < BREAK_1) {
+        rand_type = TYPE_0;
+        rand_deg  = DEG_0;
+        rand_sep  = SEP_0;
+    }
+    else if(n < BREAK_2) {
+        rand_type = TYPE_1;
+        rand_deg  = DEG_1;
+        rand_sep  = SEP_1;
+    }
+    else if(n < BREAK_3) {
+        rand_type = TYPE_2;
+        rand_deg  = DEG_2;
+        rand_sep  = SEP_2;
+    }
+    else if(n < BREAK_4) {
+        rand_type = TYPE_3;
+        rand_deg  = DEG_3;
+        rand_sep  = SEP_3;
+    }
+    else {
+        rand_type = TYPE_4;
+        rand_deg  = DEG_4;
+        rand_sep  = SEP_4;
+    }
+    state   = &(((long *)arg_state)[1]); /* first location */
+    end_ptr = &state[rand_deg];          /* must set end_ptr before srandom */
+    our_srandom(seed);
+    if(rand_type == TYPE_0)
+        state[-1] = rand_type;
+    else
+        state[-1] = MAX_TYPES * (rptr - state) + rand_type;
+    return (ostate);
+}
+
+/*
+ * our_setstate:
+ *
+ * Restore the state from the given state array.
+ *
+ * Note: it is important that we also remember the locations of the pointers
+ * in the current state information, and restore the locations of the pointers
+ * from the old state information.  This is done by multiplexing the pointer
+ * location into the zeroeth word of the state information.
+ *
+ * Note that due to the order in which things are done, it is OK to call
+ * our_setstate() with the same state as the current state.
+ *
+ * Returns a pointer to the old state information.
+ */
+char *our_setstate(arg_state) char *arg_state;
+{
+    register long *new_state = (long *)arg_state;
+    register int   type      = new_state[0] % MAX_TYPES;
+    register int   rear      = new_state[0] / MAX_TYPES;
+    char *         ostate    = (char *)(&state[-1]);
+
+    if(rand_type == TYPE_0)
+        state[-1] = rand_type;
+    else
+        state[-1] = MAX_TYPES * (rptr - state) + rand_type;
+    switch(type) {
+    case TYPE_0:
+    case TYPE_1:
+    case TYPE_2:
+    case TYPE_3:
+    case TYPE_4:
+        rand_type = type;
+        rand_deg  = degrees[type];
+        rand_sep  = seps[type];
+        break;
+    default:
+#ifdef DEBUG
+        (void)fprintf(stderr, "random: state info corrupted; not changed.\n");
+#endif
+        break;
+    }
+    state = &new_state[1];
+    if(rand_type != TYPE_0) {
+        rptr = &state[rear];
+        fptr = &state[(rear + rand_sep) % rand_deg];
+    }
+    end_ptr = &state[rand_deg]; /* set end_ptr too */
+    return (ostate);
+}
+
+/*
+ * random:
+ *
+ * If we are using the trivial TYPE_0 R.N.G., just do the old linear
+ * congruential bit.  Otherwise, we do our fancy trinomial stuff, which is
+ * the same in all the other cases due to all the global variables that have
+ * been set up.  The basic operation is to add the number at the rear pointer
+ * into the one at the front pointer.  Then both pointers are advanced to
+ * the next location cyclically in the table.  The value returned is the sum
+ * generated, reduced to 31 bits by throwing away the "least random" low bit.
+ *
+ * Note: the code takes advantage of the fact that both the front and
+ * rear pointers can't wrap on the same call by not testing the rear
+ * pointer if the front one has wrapped.
+ *
+ * Returns a 31-bit random number.
+ */
+long our_random() {
+    long i;
+
+    if(rand_type == TYPE_0) {
+        i = state[0] = (state[0] * 1103515245 + 12345) & 0x7fffffff;
+    }
+    else {
+        /* Make copies of "rptr" and "fptr" before working with them, in case we're being called concurrently by multiple threads: */
+        long *rp = rptr;
+        long *fp = fptr;
+
+        /* Make sure "rp" and "fp" are separated by the correct distance (again, allowing for concurrent access): */
+        if(!(fp == rp + SEP_3 || fp + DEG_3 == rp + SEP_3)) {
+            /* A rare case that should occur only if we're being called concurrently by multiple threads. */
+            /* Restore the proper separation between the pointers: */
+            if(rp <= fp)
+                rp = fp - SEP_3;
+            else
+                rp = fp + DEG_3 - SEP_3;
+        }
+
+        *fp += *rp;
+        i = (*fp >> 1) & 0x7fffffff; /* chucking least random bit */
+        if(++fp >= end_ptr) {
+            fp = state;
+            ++rp;
+        }
+        else if(++rp >= end_ptr) {
+            rp = state;
+        }
+
+        /* Restore "rptr" and "fptr" from our working copies: */
+        rptr = rp;
+        fptr = fp;
+    }
+
+    return i;
+}
+#endif
+
+u_int32_t our_random32() {
+    /* Return a 32-bit random number.
+       Because "our_random()" returns a 31-bit random number, we call it a second
+       time, to generate the high bit.
+       (Actually, to increase the likelihood of randomness, we take the middle 16 bits of two successive calls to "our_random()")
+    */
+    long      random_1   = our_random();
+    u_int32_t random16_1 = (u_int32_t)(random_1 & 0x00FFFF00);
+
+    long      random_2   = our_random();
+    u_int32_t random16_2 = (u_int32_t)(random_2 & 0x00FFFF00);
+
+    return (random16_1 << 8) | (random16_2 >> 8);
+}
+
+#ifdef USE_OUR_BZERO
+#ifndef __bzero
+void __bzero(to, count) char *to;
+int  count;
+{
+    while(count-- > 0) {
+        *to++ = 0;
+    }
+}
+#endif
+#endif
diff --git a/3rdparty/live555/src/hlsProxy/Makefile.head b/3rdparty/live555/src/hlsProxy/Makefile.head
new file mode 100644
index 00000000..327a98ea
--- /dev/null
+++ b/3rdparty/live555/src/hlsProxy/Makefile.head
@@ -0,0 +1,8 @@
+PREFIX = /usr/local
+INCLUDES = -I../UsageEnvironment/include -I../groupsock/include -I../liveMedia/include -I../BasicUsageEnvironment/include
+# Default library filename suffixes for each library that we link with.  The "config.*" file might redefine these later.
+libliveMedia_LIB_SUFFIX = $(LIB_SUFFIX)
+libBasicUsageEnvironment_LIB_SUFFIX = $(LIB_SUFFIX)
+libUsageEnvironment_LIB_SUFFIX = $(LIB_SUFFIX)
+libgroupsock_LIB_SUFFIX = $(LIB_SUFFIX)
+##### Change the following for your environment:
diff --git a/3rdparty/live555/src/hlsProxy/Makefile.tail b/3rdparty/live555/src/hlsProxy/Makefile.tail
new file mode 100644
index 00000000..c34bea92
--- /dev/null
+++ b/3rdparty/live555/src/hlsProxy/Makefile.tail
@@ -0,0 +1,37 @@
+##### End of variables to change
+
+HLS_PROXY = live555HLSProxy$(EXE)
+
+ALL = $(HLS_PROXY)
+all: $(ALL)
+
+.$(C).$(OBJ):
+	$(C_COMPILER) -c $(C_FLAGS) $<
+.$(CPP).$(OBJ):
+	$(CPLUSPLUS_COMPILER) -c $(CPLUSPLUS_FLAGS) $<
+
+HLS_PROXY_OBJS = live555HLSProxy.$(OBJ)
+
+USAGE_ENVIRONMENT_DIR = ../UsageEnvironment
+USAGE_ENVIRONMENT_LIB = $(USAGE_ENVIRONMENT_DIR)/libUsageEnvironment.$(libUsageEnvironment_LIB_SUFFIX)
+BASIC_USAGE_ENVIRONMENT_DIR = ../BasicUsageEnvironment
+BASIC_USAGE_ENVIRONMENT_LIB = $(BASIC_USAGE_ENVIRONMENT_DIR)/libBasicUsageEnvironment.$(libBasicUsageEnvironment_LIB_SUFFIX)
+LIVEMEDIA_DIR = ../liveMedia
+LIVEMEDIA_LIB = $(LIVEMEDIA_DIR)/libliveMedia.$(libliveMedia_LIB_SUFFIX)
+GROUPSOCK_DIR = ../groupsock
+GROUPSOCK_LIB = $(GROUPSOCK_DIR)/libgroupsock.$(libgroupsock_LIB_SUFFIX)
+LOCAL_LIBS =	$(LIVEMEDIA_LIB) $(GROUPSOCK_LIB) \
+		$(BASIC_USAGE_ENVIRONMENT_LIB) $(USAGE_ENVIRONMENT_LIB)
+LIBS =			$(LOCAL_LIBS) $(LIBS_FOR_CONSOLE_APPLICATION)
+
+live555HLSProxy$(EXE):	$(HLS_PROXY_OBJS) $(LOCAL_LIBS)
+	$(LINK)$@ $(CONSOLE_LINK_OPTS) $(HLS_PROXY_OBJS) $(LIBS)
+
+clean:
+	-rm -rf *.$(OBJ) $(ALL) core *.core *~ include/*~
+
+install: $(HLS_PROXY)
+	  install -d $(DESTDIR)$(PREFIX)/bin
+	  install -m 755 $(HLS_PROXY) $(DESTDIR)$(PREFIX)/bin
+
+##### Any additional, platform-specific rules come here:
diff --git a/3rdparty/live555/src/hlsProxy/live555HLSProxy.cpp b/3rdparty/live555/src/hlsProxy/live555HLSProxy.cpp
new file mode 100644
index 00000000..a111b44b
--- /dev/null
+++ b/3rdparty/live555/src/hlsProxy/live555HLSProxy.cpp
@@ -0,0 +1,548 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// Copyright (c) 1996-2022, Live Networks, Inc.  All rights reserved
+// A program that acts as a proxy for a RTSP stream, converting it into a sequence of
+// HLS (HTTP Live Streaming) segments, plus a ".m3u8" file that can be accessed via a web browser.
+// main program
+
+#include "liveMedia.hh"
+#include "BasicUsageEnvironment.hh"
+
+#define RTSP_CLIENT_VERBOSITY_LEVEL 0   // set to 1 for more verbose output from the "RTSPClient"
+#define OUR_HLS_SEGMENTATION_DURATION 6 /*seconds*/
+#define OUR_HLS_REWIND_DURATION 60      /*seconds: How far back in time a browser can seek*/
+
+UsageEnvironment *                env;
+char const *                      programName;
+char *                            username              = NULL;
+char *                            password              = NULL;
+Authenticator *                   ourAuthenticator      = NULL;
+Boolean                           streamUsingTCP        = False;
+portNumBits                       tunnelOverHTTPPortNum = 0;
+char const *                      hlsPrefix;
+MediaSession *                    session;
+MPEG2TransportStreamFromESSource *transportStream;
+MediaSubsessionIterator *         iter;
+MediaSubsession *                 subsession;
+unsigned                          numUsableSubsessions                   = 0;
+double                            duration                               = 0.0;
+Boolean                           createHandlerServerForREGISTERCommand  = False;
+portNumBits                       handlerServerForREGISTERCommandPortNum = 0;
+HandlerServerForREGISTERCommand * handlerServerForREGISTERCommand;
+char *                            usernameForREGISTER = NULL;
+char *                            passwordForREGISTER = NULL;
+UserAuthenticationDatabase *      authDBForREGISTER   = NULL;
+
+void usage() {
+    *env << "usage:\t" << programName << " [-u <username> <password>] [-t|-T <http-port>] <input-RTSP-url> <HLS-prefix>\n";
+    *env << "   or:\t" << programName << " -R [<port-num>] [-U <username-for-REGISTER> <password-for-REGISTER>] <HLS-prefix>\n";
+    exit(1);
+}
+
+// Forward function definitions:
+void continueAfterClientCreation0(RTSPClient *rtspClient, Boolean requestStreamingOverTCP);
+void continueAfterClientCreation1(RTSPClient *rtspClient);
+void continueAfterDESCRIBE(RTSPClient *rtspClient, int resultCode, char *resultString);
+
+int main(int argc, char **argv) {
+    // Begin by setting up our usage environment:
+    TaskScheduler *scheduler = BasicTaskScheduler::createNew();
+    env                      = BasicUsageEnvironment::createNew(*scheduler);
+
+    // Output information about the program (and LIVE555 version):
+    *env << "LIVE555 HLS Proxy, documented at http://www.live555.com/hlsProxy/\n";
+    *env << "\t(LIVE555 Streaming Media version " << LIVEMEDIA_LIBRARY_VERSION_STRING << ")\n";
+
+    // Parse the command line:
+    programName = argv[0];
+    while(argc > 1) {
+        char *const opt = argv[1];
+        if(opt[0] != '-') {
+            if(argc <= 3)
+                break;  // only the URL + prefix is left
+            usage();
+        }
+
+        switch(opt[1]) {
+        case 'u': {  // specify a username and password
+            if(argc < 4)
+                usage();  // there's no argv[3] (for the "password")
+            username = argv[2];
+            password = argv[3];
+            argv += 2;
+            argc -= 2;
+            ourAuthenticator = new Authenticator(username, password);
+            break;
+        }
+
+        case 't': {  // stream RTP and RTCP over the TCP 'control' connection
+            streamUsingTCP = True;
+            break;
+        }
+
+        case 'T': {
+            if(argc > 3 && argv[2][0] != '-') {
+                // The next argument is the HTTP server port number:
+                if(sscanf(argv[2], "%hu", &tunnelOverHTTPPortNum) == 1 && tunnelOverHTTPPortNum > 0) {
+                    ++argv;
+                    --argc;
+                    break;
+                }
+            }
+
+            // If we get here, the option was specified incorrectly:
+            usage();
+            break;
+        }
+
+        case 'R': {
+            // set up a handler server for incoming "REGISTER" commands
+            createHandlerServerForREGISTERCommand = True;
+            if(argc > 2 && argv[2][0] != '-') {
+                // The next argument is the REGISTER handler server port number:
+                if(sscanf(argv[2], "%hu", &handlerServerForREGISTERCommandPortNum) == 1 && handlerServerForREGISTERCommandPortNum > 0) {
+                    ++argv;
+                    --argc;
+                    break;
+                }
+            }
+            break;
+        }
+
+        case 'U': {  // specify a username and password to be used to authentication an incoming "REGISTER" command (for use with -R)
+            if(argc < 4)
+                usage();  // there's no argv[3] (for the "password")
+            usernameForREGISTER = argv[2];
+            passwordForREGISTER = argv[3];
+            argv += 2;
+            argc -= 2;
+
+            if(authDBForREGISTER == NULL)
+                authDBForREGISTER = new UserAuthenticationDatabase;
+            authDBForREGISTER->addUserRecord(usernameForREGISTER, passwordForREGISTER);
+            break;
+        }
+
+        default: {
+            *env << "Invalid option: " << opt << "\n";
+            usage();
+            break;
+        }
+        }
+
+        ++argv;
+        --argc;
+    }
+
+    // Create (or arrange to create) our RTSP client object:
+    if(createHandlerServerForREGISTERCommand) {
+        if(argc != 2)
+            usage();
+        hlsPrefix = argv[1];
+
+        handlerServerForREGISTERCommand = HandlerServerForREGISTERCommand::createNew(*env, continueAfterClientCreation0, handlerServerForREGISTERCommandPortNum,
+                                                                                     authDBForREGISTER, RTSP_CLIENT_VERBOSITY_LEVEL, programName);
+        if(handlerServerForREGISTERCommand == NULL) {
+            *env << "Failed to create a server for handling incoming \"REGISTER\" commands: " << env->getResultMsg() << "\n";
+            exit(1);
+        }
+        else {
+            *env << "Awaiting an incoming \"REGISTER\" command on port " << handlerServerForREGISTERCommand->serverPortNum() << "\n";
+        }
+    }
+    else {  // Normal case
+        if(argc != 3)
+            usage();
+        if(usernameForREGISTER != NULL) {
+            *env << "The '-U <username-for-REGISTER> <password-for-REGISTER>' option can be used only with -R\n";
+            usage();
+        }
+        char const *rtspURL = argv[1];
+        hlsPrefix           = argv[2];
+
+        RTSPClient *rtspClient = RTSPClient::createNew(*env, rtspURL, RTSP_CLIENT_VERBOSITY_LEVEL, programName, tunnelOverHTTPPortNum);
+        if(rtspClient == NULL) {
+            *env << "Failed to create a RTSP client for URL \"" << rtspURL << "\": " << env->getResultMsg() << "\n";
+            exit(1);
+        }
+
+        continueAfterClientCreation1(rtspClient);
+    }
+
+    // All further processing will be done from within the event loop:
+    env->taskScheduler().doEventLoop();  // does not return
+
+    return 0;  // only to prevent compiler warning
+}
+
+void continueAfterClientCreation0(RTSPClient *newRTSPClient, Boolean requestStreamingOverTCP) {
+    if(newRTSPClient == NULL)
+        return;
+
+    streamUsingTCP = requestStreamingOverTCP;
+
+    // Having handled one "REGISTER" command (giving us a "rtsp://" URL to stream from), we don't handle any more:
+    Medium::close(handlerServerForREGISTERCommand);
+    handlerServerForREGISTERCommand = NULL;
+
+    continueAfterClientCreation1(newRTSPClient);
+}
+
+void continueAfterClientCreation1(RTSPClient *rtspClient) {
+    // Having created a "RTSPClient" object, send a RTSP "DESCRIBE" command for the URL:
+    rtspClient->sendDescribeCommand(continueAfterDESCRIBE, ourAuthenticator);
+}
+
+// A function that outputs a string that identifies each stream (for debugging output).
+UsageEnvironment &operator<<(UsageEnvironment &env, const RTSPClient &rtspClient) {
+    return env << "[URL:\"" << rtspClient.url() << "\"]: ";
+}
+
+// A function that outputs a string that identifies each subsession (for debugging output).
+UsageEnvironment &operator<<(UsageEnvironment &env, const MediaSubsession &subsession) {
+    return env << subsession.mediumName() << "/" << subsession.codecName();
+}
+
+void setupNextSubsession(RTSPClient *rtspClient);  // forward
+
+void continueAfterDESCRIBE(RTSPClient *rtspClient, int resultCode, char *resultString) {
+    do {
+        if(resultCode != 0) {
+            *env << *rtspClient << "Failed to get a SDP description: " << resultString << "\n";
+            delete[] resultString;
+            break;
+        }
+
+        // Create a Transport Stream to multiplex the Elementary Stream data from each subsession:
+        transportStream = MPEG2TransportStreamFromESSource::createNew(*env);
+
+        // Create a media session object from the SDP description.
+        // Then iterate over it, to look for subsession(s) that we can handle:
+        session = MediaSession::createNew(*env, resultString);
+        delete[] resultString;
+        if(session == NULL) {
+            *env << *rtspClient << "Failed to create a MediaSession object from the SDP description: " << env->getResultMsg() << "\n";
+            break;
+        }
+        else if(!session->hasSubsessions()) {
+            *env << *rtspClient << "This session has no media subsessions (i.e., no \"m=\" lines)\n";
+            break;
+        }
+
+        iter = new MediaSubsessionIterator(*session);
+        setupNextSubsession(rtspClient);
+        return;
+    } while(0);
+
+    // An error occurred:
+    exit(1);
+}
+
+void continueAfterSETUP(RTSPClient *rtspClient, int resultCode, char *resultString);  // forward
+void startPlayingSession(RTSPClient *rtspClient);                                     // forward
+
+void setupNextSubsession(RTSPClient *rtspClient) {
+    subsession = iter->next();
+    if(subsession != NULL) {
+        // Check whether this subsession is a codec that we support.
+        // We support H.264 or H.265 video, and AAC audio.
+        if((strcmp(subsession->mediumName(), "video") == 0 && (strcmp(subsession->codecName(), "H264") == 0 || strcmp(subsession->codecName(), "H265") == 0))
+           || (strcmp(subsession->mediumName(), "audio") == 0 && strcmp(subsession->codecName(), "MPEG4-GENERIC" /*aka. AAC*/) == 0)) {
+            // Use this subsession.
+            ++numUsableSubsessions;
+            if(!subsession->initiate()) {
+                *env << *rtspClient << "Failed to initiate the \"" << *subsession << "\" subsession: " << env->getResultMsg() << "\n";
+            }
+            else {
+                *env << *rtspClient << "Initiated the \"" << *subsession << "\" subsession\n";
+
+                // Continue setting up this subsession, by sending a RTSP "SETUP" command:
+                rtspClient->sendSetupCommand(*subsession, continueAfterSETUP, False, streamUsingTCP, False, ourAuthenticator);
+                return;
+            }
+        }
+        setupNextSubsession(rtspClient);  // give up on this subsession; go to the next one
+        return;
+    }
+
+    // We've gone through all of the subsessions.
+    if(numUsableSubsessions == 0) {
+        *env << *rtspClient << "This stream has no usable subsessions\n";
+        exit(0);
+    }
+
+    startPlayingSession(rtspClient);
+}
+
+void continueAfterSETUP(RTSPClient *rtspClient, int resultCode, char *resultString) {
+    do {
+        if(resultCode != 0) {
+            *env << *rtspClient << "Failed to set up the \"" << *subsession << "\" subsession: " << resultString << "\n";
+            break;
+        }
+        delete[] resultString;
+
+        *env << *rtspClient << "Set up the \"" << *subsession << "\" subsession\n";
+
+        // Feed this subsession's input source into the Transport Stream:
+        if(strcmp(subsession->mediumName(), "video") == 0) {
+            // Create a 'framer' filter for the input source, to put the stream of NAL units into a
+            // form that's usable to output to the Transport Stream.
+            // (Note that we use a *DiscreteFramer*, because the input source is a stream of discrete
+            //  NAL units - i.e., one at a time.)
+            H264or5VideoStreamDiscreteFramer *framer;
+            int                               mpegVersion;
+
+            if(strcmp(subsession->codecName(), "H264") == 0) {
+                mpegVersion = 5;  // for H.264
+                framer      = H264VideoStreamDiscreteFramer::createNew(*env, subsession->readSource(), True /*includeStartCodeInOutput*/,
+                                                                  True /*insertAccessUnitDelimiters*/);
+
+                // Add any known SPS and PPS NAL units to the framer, so they'll get output ASAP:
+                u_int8_t *   sps     = NULL;
+                unsigned     spsSize = 0;
+                u_int8_t *   pps     = NULL;
+                unsigned     ppsSize = 0;
+                unsigned     numSPropRecords;
+                SPropRecord *sPropRecords = parseSPropParameterSets(subsession->fmtp_spropparametersets(), numSPropRecords);
+                if(numSPropRecords > 0) {
+                    sps     = sPropRecords[0].sPropBytes;
+                    spsSize = sPropRecords[0].sPropLength;
+                }
+                if(numSPropRecords > 1) {
+                    pps     = sPropRecords[1].sPropBytes;
+                    ppsSize = sPropRecords[1].sPropLength;
+                }
+                framer->setVPSandSPSandPPS(NULL, 0, sps, spsSize, pps, ppsSize);
+                delete[] sPropRecords;
+            }
+            else {                // H.265
+                mpegVersion = 6;  // for H.265
+                framer      = H265VideoStreamDiscreteFramer::createNew(*env, subsession->readSource(), True /*includeStartCodeInOutput*/,
+                                                                  True /*insertAccessUnitDelimiters*/);
+
+                // Add any known VPS, SPS and PPS NAL units to the framer, so they'll get output ASAP:
+                u_int8_t *   vps     = NULL;
+                unsigned     vpsSize = 0;
+                u_int8_t *   sps     = NULL;
+                unsigned     spsSize = 0;
+                u_int8_t *   pps     = NULL;
+                unsigned     ppsSize = 0;
+                unsigned     numSPropRecords;
+                SPropRecord *sPropRecordsVPS, *sPropRecordsSPS, *sPropRecordsPPS;
+
+                sPropRecordsVPS = parseSPropParameterSets(subsession->fmtp_spropvps(), numSPropRecords);
+                if(numSPropRecords > 0) {
+                    vps     = sPropRecordsVPS[0].sPropBytes;
+                    vpsSize = sPropRecordsVPS[0].sPropLength;
+                }
+
+                sPropRecordsSPS = parseSPropParameterSets(subsession->fmtp_spropsps(), numSPropRecords);
+                if(numSPropRecords > 0) {
+                    sps     = sPropRecordsSPS[0].sPropBytes;
+                    spsSize = sPropRecordsSPS[0].sPropLength;
+                }
+
+                sPropRecordsPPS = parseSPropParameterSets(subsession->fmtp_sproppps(), numSPropRecords);
+                if(numSPropRecords > 0) {
+                    pps     = sPropRecordsPPS[0].sPropBytes;
+                    ppsSize = sPropRecordsPPS[0].sPropLength;
+                }
+
+                framer->setVPSandSPSandPPS(vps, vpsSize, sps, spsSize, pps, ppsSize);
+                delete[] sPropRecordsVPS;
+                delete[] sPropRecordsSPS;
+                delete[] sPropRecordsPPS;
+            }
+
+            transportStream->addNewVideoSource(framer, mpegVersion);
+        }
+        else {  // audio (AAC)
+            // Create a 'framer' filter for the input source, to add a ADTS header to each AAC frame,
+            // to make the audio playable.
+            ADTSAudioStreamDiscreteFramer *framer = ADTSAudioStreamDiscreteFramer::createNew(*env, subsession->readSource(), subsession->fmtp_config());
+            transportStream->addNewAudioSource(framer, 4 /*mpegVersion: AAC*/);
+        }
+
+        // Also set up BYE handler//#####@@@@@
+    } while(0);
+
+    // Set up the next subsession, if any:
+    setupNextSubsession(rtspClient);
+}
+
+void continueAfterPLAY(RTSPClient *rtspClient, int resultCode, char *resultString);                // forward
+void segmentationCallback(void *clientData, char const *segmentFileName, double segmentDuration);  // forward
+void afterPlaying(void *clientData);                                                               // forward
+
+void startPlayingSession(RTSPClient *rtspClient) {
+    // Having successfully setup the session, create a data sink for it, and call "startPlaying()" on it.
+    // (This will prepare the data sink to receive data; the actual flow of data from the client won't start happening until later,
+    // after we've sent a RTSP "PLAY" command.)
+
+    MediaSink *sink = HLSSegmenter::createNew(*env, OUR_HLS_SEGMENTATION_DURATION, hlsPrefix, segmentationCallback);
+
+    // Start playing the sink object:
+    *env << "Beginning to read...\n";
+    sink->startPlaying(*transportStream, afterPlaying, NULL);
+
+    // Now, send a RTSP "PLAY" command to start the streaming:
+    if(session->absStartTime() != NULL) {
+        // Special case: The stream is indexed by 'absolute' time, so send an appropriate "PLAY" command:
+        rtspClient->sendPlayCommand(*session, continueAfterPLAY, session->absStartTime(), session->absEndTime(), 1.0f, ourAuthenticator);
+    }
+    else {
+        duration = session->playEndTime() - session->playStartTime();
+        rtspClient->sendPlayCommand(*session, continueAfterPLAY, 0.0f, -1.0f, 1.0f, ourAuthenticator);
+    }
+}
+
+// A record that defines a segment that has been written.  These records are kept in a list:
+class SegmentRecord {
+public:
+    SegmentRecord(char const *segmentFileName, double segmentDuration)
+        : fNext(NULL), fSegmentFileName(strDup(segmentFileName)), fSegmentDuration(segmentDuration) {}
+    virtual ~SegmentRecord() {
+        delete[] fSegmentFileName;
+        delete fNext;
+    }
+
+    SegmentRecord *&next() {
+        return fNext;
+    }
+    char const *fileName() const {
+        return fSegmentFileName;
+    }
+    double duration() const {
+        return fSegmentDuration;
+    }
+
+private:
+    SegmentRecord *fNext;
+    char *         fSegmentFileName;
+    double         fSegmentDuration;
+};
+
+SegmentRecord *head            = NULL;
+SegmentRecord *tail            = NULL;
+double         totalDuration   = 0.0;
+char *         ourM3U8FileName = NULL;
+
+void segmentationCallback(void * /*clientData*/, char const *segmentFileName, double segmentDuration) {
+    // Begin by updating our list of segments:
+    SegmentRecord *newSegment = new SegmentRecord(segmentFileName, segmentDuration);
+    if(tail != NULL) {
+        tail->next() = newSegment;
+    }
+    else {
+        head = newSegment;
+    }
+    tail = newSegment;
+    totalDuration += segmentDuration;
+
+    fprintf(stderr, "Wrote segment \"%s\" (duration: %f seconds) -> %f seconds of data stored\n", segmentFileName, segmentDuration, totalDuration);
+
+    static unsigned firstSegmentCounter = 1;
+    while(totalDuration > OUR_HLS_REWIND_DURATION) {
+        // Remove segments from the head of the list:
+        SegmentRecord *segmentToRemove = head;
+        if(segmentToRemove == NULL)
+            exit(1);  // should not happen
+
+        head = segmentToRemove->next();
+        if(tail == segmentToRemove) {  // should not happen
+            tail = NULL;
+        }
+        segmentToRemove->next() = NULL;
+
+        totalDuration -= segmentToRemove->duration();
+        fprintf(stderr, "\tDeleting segment \"%s\" (duration: %f seconds) -> %f seconds of data stored\n", segmentToRemove->fileName(),
+                segmentToRemove->duration(), totalDuration);
+        if(unlink(segmentToRemove->fileName()) != 0) {
+            *env << "\t\tunlink(\"" << segmentToRemove->fileName() << "\") failed: " << env->getResultMsg() << "\n";
+        }
+        delete segmentToRemove;
+        ++firstSegmentCounter;
+    }
+
+    // Then, rewrite our ".m3u8" file with the new list of segments:
+    if(ourM3U8FileName == NULL) {
+        ourM3U8FileName = new char[strlen(hlsPrefix) + 5 /*strlen(".m3u8")*/ + 1];
+        if(ourM3U8FileName == NULL)
+            exit(1);
+        sprintf(ourM3U8FileName, "%s.m3u8", hlsPrefix);
+    }
+
+    // Open our ".m3u8" file for output, and write the prefix:
+    FILE *ourM3U8Fid = fopen(ourM3U8FileName, "wb");
+    if(ourM3U8Fid == NULL) {
+        *env << "Failed to open file \"" << ourM3U8FileName << "\": " << env->getResultMsg();
+        exit(1);
+    }
+
+    fprintf(ourM3U8Fid,
+            "#EXTM3U\n"
+            "#EXT-X-VERSION:3\n"
+            "#EXT-X-INDEPENDENT-SEGMENTS\n"
+            "#EXT-X-TARGETDURATION:%u\n"
+            "#EXT-X-MEDIA-SEQUENCE:%u\n",
+            OUR_HLS_SEGMENTATION_DURATION, firstSegmentCounter);
+
+    // Write the list of segments:
+    for(SegmentRecord *segment = head; segment != NULL; segment = segment->next()) {
+        fprintf(ourM3U8Fid,
+                "#EXTINF:%f,\n"
+                "%s\n",
+                segment->duration(), segment->fileName());
+    }
+
+    // Close our ".m3u8" file:
+    fclose(ourM3U8Fid);
+
+    static Boolean isFirstTime = True;
+    if(isFirstTime) {
+        fprintf(stderr, "Wrote index file \"%s\"; the stream can now be played from a URL pointing to this file.\007\n", ourM3U8FileName);
+        isFirstTime = False;
+    }
+}
+
+void afterPlaying(void * /*clientData*/) {
+    *env << "...Done reading\n";
+    exit(0);
+}
+
+void continueAfterPLAY(RTSPClient *rtspClient, int resultCode, char *resultString) {
+    do {
+        if(resultCode != 0) {
+            *env << *rtspClient << "Failed to start playing session: " << resultString << "\n";
+            break;
+        }
+        delete[] resultString;
+
+        // Set timer based on duration #####@@@@@
+
+        *env << *rtspClient << "Started playing session";
+        if(duration > 0) {
+            *env << " (for up to " << duration << " seconds)";
+        }
+        *env << "...\n";
+
+        return;
+    } while(0);
+
+    // An error occurred:
+    exit(1);
+}
diff --git a/3rdparty/live555/src/liveMedia/AC3AudioFileServerMediaSubsession.cpp b/3rdparty/live555/src/liveMedia/AC3AudioFileServerMediaSubsession.cpp
new file mode 100644
index 00000000..6fe9f507
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/AC3AudioFileServerMediaSubsession.cpp
@@ -0,0 +1,49 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A 'ServerMediaSubsession' object that creates new, unicast, "RTPSink"s
+// on demand, from an AC3 audio file.
+// Implementation
+
+#include "AC3AudioFileServerMediaSubsession.hh"
+#include "ByteStreamFileSource.hh"
+#include "AC3AudioStreamFramer.hh"
+#include "AC3AudioRTPSink.hh"
+
+AC3AudioFileServerMediaSubsession *AC3AudioFileServerMediaSubsession::createNew(UsageEnvironment &env, char const *fileName, Boolean reuseFirstSource) {
+    return new AC3AudioFileServerMediaSubsession(env, fileName, reuseFirstSource);
+}
+
+AC3AudioFileServerMediaSubsession ::AC3AudioFileServerMediaSubsession(UsageEnvironment &env, char const *fileName, Boolean reuseFirstSource)
+    : FileServerMediaSubsession(env, fileName, reuseFirstSource) {}
+
+AC3AudioFileServerMediaSubsession::~AC3AudioFileServerMediaSubsession() {}
+
+FramedSource *AC3AudioFileServerMediaSubsession ::createNewStreamSource(unsigned /*clientSessionId*/, unsigned &estBitrate) {
+    estBitrate = 48;  // kbps, estimate
+
+    ByteStreamFileSource *fileSource = ByteStreamFileSource::createNew(envir(), fFileName);
+    if(fileSource == NULL)
+        return NULL;
+
+    return AC3AudioStreamFramer::createNew(envir(), fileSource);
+}
+
+RTPSink *AC3AudioFileServerMediaSubsession ::createNewRTPSink(Groupsock *rtpGroupsock, unsigned char rtpPayloadTypeIfDynamic, FramedSource *inputSource) {
+    AC3AudioStreamFramer *audioSource = (AC3AudioStreamFramer *)inputSource;
+    return AC3AudioRTPSink::createNew(envir(), rtpGroupsock, rtpPayloadTypeIfDynamic, audioSource->samplingRate());
+}
diff --git a/3rdparty/live555/src/liveMedia/AC3AudioRTPSink.cpp b/3rdparty/live555/src/liveMedia/AC3AudioRTPSink.cpp
new file mode 100644
index 00000000..f1e1b595
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/AC3AudioRTPSink.cpp
@@ -0,0 +1,80 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// RTP sink for AC3 audio
+// Implementation
+
+#include "AC3AudioRTPSink.hh"
+
+AC3AudioRTPSink::AC3AudioRTPSink(UsageEnvironment &env, Groupsock *RTPgs, u_int8_t rtpPayloadFormat, u_int32_t rtpTimestampFrequency)
+    : AudioRTPSink(env, RTPgs, rtpPayloadFormat, rtpTimestampFrequency, "AC3"), fTotNumFragmentsUsed(0) {}
+
+AC3AudioRTPSink::~AC3AudioRTPSink() {}
+
+AC3AudioRTPSink *AC3AudioRTPSink::createNew(UsageEnvironment &env, Groupsock *RTPgs, u_int8_t rtpPayloadFormat, u_int32_t rtpTimestampFrequency) {
+    return new AC3AudioRTPSink(env, RTPgs, rtpPayloadFormat, rtpTimestampFrequency);
+}
+
+Boolean AC3AudioRTPSink ::frameCanAppearAfterPacketStart(unsigned char const * /*frameStart*/, unsigned /*numBytesInFrame*/) const {
+    // (For now) allow at most 1 frame in a single packet:
+    return False;
+}
+
+void AC3AudioRTPSink ::doSpecialFrameHandling(unsigned fragmentationOffset, unsigned char *frameStart, unsigned numBytesInFrame,
+                                              struct timeval framePresentationTime, unsigned numRemainingBytes) {
+    // Set the 2-byte "payload header", as defined in RFC 4184.
+    unsigned char headers[2];
+
+    Boolean isFragment = numRemainingBytes > 0 || fragmentationOffset > 0;
+    if(!isFragment) {
+        headers[0] = 0;  // One or more complete frames
+        headers[1] = 1;  // because we (for now) allow at most 1 frame per packet
+    }
+    else {
+        if(fragmentationOffset > 0) {
+            headers[0] = 3;  // Fragment of frame other than initial fragment
+        }
+        else {
+            // An initial fragment of the frame
+            unsigned const totalFrameSize   = fragmentationOffset + numBytesInFrame + numRemainingBytes;
+            unsigned const fiveEighthsPoint = totalFrameSize / 2 + totalFrameSize / 8;
+            headers[0]                      = numBytesInFrame >= fiveEighthsPoint ? 1 : 2;
+
+            // Because this outgoing packet will be full (because it's an initial fragment), we can compute how many total
+            // fragments (and thus packets) will make up the complete AC-3 frame:
+            fTotNumFragmentsUsed = (totalFrameSize + (numBytesInFrame - 1)) / numBytesInFrame;
+        }
+
+        headers[1] = fTotNumFragmentsUsed;
+    }
+
+    setSpecialHeaderBytes(headers, sizeof headers);
+
+    if(numRemainingBytes == 0) {
+        // This packet contains the last (or only) fragment of the frame.
+        // Set the RTP 'M' ('marker') bit:
+        setMarkerBit();
+    }
+
+    // Important: Also call our base class's doSpecialFrameHandling(),
+    // to set the packet's timestamp:
+    MultiFramedRTPSink::doSpecialFrameHandling(fragmentationOffset, frameStart, numBytesInFrame, framePresentationTime, numRemainingBytes);
+}
+
+unsigned AC3AudioRTPSink::specialHeaderSize() const {
+    return 2;
+}
diff --git a/3rdparty/live555/src/liveMedia/AC3AudioRTPSource.cpp b/3rdparty/live555/src/liveMedia/AC3AudioRTPSource.cpp
new file mode 100644
index 00000000..ebd31841
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/AC3AudioRTPSource.cpp
@@ -0,0 +1,53 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// AC3 Audio RTP Sources
+// Implementation
+
+#include "AC3AudioRTPSource.hh"
+
+AC3AudioRTPSource *AC3AudioRTPSource::createNew(UsageEnvironment &env, Groupsock *RTPgs, unsigned char rtpPayloadFormat, unsigned rtpTimestampFrequency) {
+    return new AC3AudioRTPSource(env, RTPgs, rtpPayloadFormat, rtpTimestampFrequency);
+}
+
+AC3AudioRTPSource::AC3AudioRTPSource(UsageEnvironment &env, Groupsock *rtpGS, unsigned char rtpPayloadFormat, unsigned rtpTimestampFrequency)
+    : MultiFramedRTPSource(env, rtpGS, rtpPayloadFormat, rtpTimestampFrequency) {}
+
+AC3AudioRTPSource::~AC3AudioRTPSource() {}
+
+Boolean AC3AudioRTPSource ::processSpecialHeader(BufferedPacket *packet, unsigned &resultSpecialHeaderSize) {
+    unsigned char *headerStart = packet->data();
+    unsigned       packetSize  = packet->dataSize();
+
+    // There's a 2-byte payload header at the beginning:
+    if(packetSize < 2)
+        return False;
+    resultSpecialHeaderSize = 2;
+
+    unsigned char FT          = headerStart[0] & 0x03;
+    fCurrentPacketBeginsFrame = FT != 3;
+
+    // The RTP "M" (marker) bit indicates the last fragment of a frame.
+    // In case the sender did not set the "M" bit correctly, we also test for FT == 0:
+    fCurrentPacketCompletesFrame = packet->rtpMarkerBit() || FT == 0;
+
+    return True;
+}
+
+char const *AC3AudioRTPSource::MIMEtype() const {
+    return "audio/AC3";
+}
diff --git a/3rdparty/live555/src/liveMedia/AC3AudioStreamFramer.cpp b/3rdparty/live555/src/liveMedia/AC3AudioStreamFramer.cpp
new file mode 100644
index 00000000..aae3bd11
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/AC3AudioStreamFramer.cpp
@@ -0,0 +1,327 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A filter that breaks up an AC3 audio elementary stream into frames
+// Implementation
+
+#include "AC3AudioStreamFramer.hh"
+#include "StreamParser.hh"
+#include <GroupsockHelper.hh>
+
+////////// AC3AudioStreamParser definition //////////
+
+class AC3FrameParams {
+public:
+    AC3FrameParams() : samplingFreq(0) {}
+    // 8-byte header at the start of each frame:
+    //  u_int32_t hdr0, hdr1;
+    unsigned hdr0, hdr1;
+
+    // parameters derived from the headers
+    unsigned kbps, samplingFreq, frameSize;
+
+    void setParamsFromHeader();
+};
+
+class AC3AudioStreamParser : public StreamParser {
+public:
+    AC3AudioStreamParser(AC3AudioStreamFramer *usingSource, FramedSource *inputSource);
+    virtual ~AC3AudioStreamParser();
+
+public:
+    void     testStreamCode(unsigned char ourStreamCode, unsigned char *ptr, unsigned size);
+    unsigned parseFrame(unsigned &numTruncatedBytes);
+    // returns the size of the frame that was acquired, or 0 if none was
+
+    void registerReadInterest(unsigned char *to, unsigned maxSize);
+
+    AC3FrameParams const &currentFrame() const {
+        return fCurrentFrame;
+    }
+
+    Boolean haveParsedAFrame() const {
+        return fHaveParsedAFrame;
+    }
+    void readAndSaveAFrame();
+
+private:
+    static void afterGettingSavedFrame(void *clientData, unsigned frameSize, unsigned numTruncatedBytes, struct timeval presentationTime,
+                                       unsigned durationInMicroseconds);
+    void        afterGettingSavedFrame1(unsigned frameSize);
+    static void onSavedFrameClosure(void *clientData);
+    void        onSavedFrameClosure1();
+
+private:
+    AC3AudioStreamFramer *fUsingSource;
+    unsigned char *       fTo;
+    unsigned              fMaxSize;
+
+    Boolean        fHaveParsedAFrame;
+    unsigned char *fSavedFrame;
+    unsigned       fSavedFrameSize;
+    char           fSavedFrameFlag;
+
+    // Parameters of the most recently read frame:
+    AC3FrameParams fCurrentFrame;
+};
+
+////////// AC3AudioStreamFramer implementation //////////
+
+AC3AudioStreamFramer::AC3AudioStreamFramer(UsageEnvironment &env, FramedSource *inputSource, unsigned char streamCode)
+    : FramedFilter(env, inputSource), fOurStreamCode(streamCode) {
+    // Use the current wallclock time as the initial 'presentation time':
+    gettimeofday(&fNextFramePresentationTime, NULL);
+
+    fParser = new AC3AudioStreamParser(this, inputSource);
+}
+
+AC3AudioStreamFramer::~AC3AudioStreamFramer() {
+    delete fParser;
+}
+
+AC3AudioStreamFramer *AC3AudioStreamFramer::createNew(UsageEnvironment &env, FramedSource *inputSource, unsigned char streamCode) {
+    // Need to add source type checking here???  #####
+    return new AC3AudioStreamFramer(env, inputSource, streamCode);
+}
+
+unsigned AC3AudioStreamFramer::samplingRate() {
+    if(!fParser->haveParsedAFrame()) {
+        // Because we haven't yet parsed a frame, we don't yet know the input
+        // stream's sampling rate.  So, we first need to read a frame
+        // (into a special buffer that we keep around for later use).
+        fParser->readAndSaveAFrame();
+    }
+
+    return fParser->currentFrame().samplingFreq;
+}
+
+void AC3AudioStreamFramer::flushInput() {
+    fParser->flushInput();
+}
+
+void AC3AudioStreamFramer::doGetNextFrame() {
+    fParser->registerReadInterest(fTo, fMaxSize);
+    parseNextFrame();
+}
+
+#define MILLION 1000000
+
+struct timeval AC3AudioStreamFramer::currentFramePlayTime() const {
+    AC3FrameParams const &fr         = fParser->currentFrame();
+    unsigned const        numSamples = 1536;
+    unsigned const        freq       = fr.samplingFreq;
+
+    // result is numSamples/freq
+    unsigned const uSeconds = (freq == 0) ? 0 : ((numSamples * 2 * MILLION) / freq + 1) / 2;  // rounds to nearest integer
+
+    struct timeval result;
+    result.tv_sec  = uSeconds / MILLION;
+    result.tv_usec = uSeconds % MILLION;
+    return result;
+}
+
+void AC3AudioStreamFramer ::handleNewData(void *clientData, unsigned char *ptr, unsigned size, struct timeval /*presentationTime*/) {
+    AC3AudioStreamFramer *framer = (AC3AudioStreamFramer *)clientData;
+    framer->handleNewData(ptr, size);
+}
+
+void AC3AudioStreamFramer ::handleNewData(unsigned char *ptr, unsigned size) {
+    fParser->testStreamCode(fOurStreamCode, ptr, size);
+
+    parseNextFrame();
+}
+
+void AC3AudioStreamFramer::parseNextFrame() {
+    unsigned acquiredFrameSize = fParser->parseFrame(fNumTruncatedBytes);
+    if(acquiredFrameSize > 0) {
+        // We were able to acquire a frame from the input.
+        // It has already been copied to the reader's space.
+        fFrameSize = acquiredFrameSize;
+
+        // Also set the presentation time, and increment it for next time,
+        // based on the length of this frame:
+        fPresentationTime = fNextFramePresentationTime;
+
+        struct timeval framePlayTime = currentFramePlayTime();
+        fDurationInMicroseconds      = framePlayTime.tv_sec * MILLION + framePlayTime.tv_usec;
+        fNextFramePresentationTime.tv_usec += framePlayTime.tv_usec;
+        fNextFramePresentationTime.tv_sec += framePlayTime.tv_sec + fNextFramePresentationTime.tv_usec / MILLION;
+        fNextFramePresentationTime.tv_usec %= MILLION;
+
+        // Call our own 'after getting' function.  Because we're not a 'leaf'
+        // source, we can call this directly, without risking infinite recursion.
+        afterGetting(this);
+    }
+    else {
+        // We were unable to parse a complete frame from the input, because:
+        // - we had to read more data from the source stream, or
+        // - the source stream has ended.
+    }
+}
+
+////////// AC3AudioStreamParser implementation //////////
+
+static int const kbpsTable[] = { 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384, 448, 512, 576, 640 };
+
+void AC3FrameParams::setParamsFromHeader() {
+    unsigned char byte4 = hdr1 >> 24;
+
+    unsigned char kbpsIndex = (byte4 & 0x3E) >> 1;
+    if(kbpsIndex > 18)
+        kbpsIndex = 18;
+    kbps = kbpsTable[kbpsIndex];
+
+    unsigned char samplingFreqIndex = (byte4 & 0xC0) >> 6;
+    switch(samplingFreqIndex) {
+    case 0:
+        samplingFreq = 48000;
+        frameSize    = 4 * kbps;
+        break;
+    case 1:
+        samplingFreq = 44100;
+        frameSize    = 2 * (320 * kbps / 147 + (byte4 & 1));
+        break;
+    case 2:
+    case 3:  // not legal?
+        samplingFreq = 32000;
+        frameSize    = 6 * kbps;
+    }
+}
+
+AC3AudioStreamParser ::AC3AudioStreamParser(AC3AudioStreamFramer *usingSource, FramedSource *inputSource)
+    : StreamParser(inputSource, FramedSource::handleClosure, usingSource, &AC3AudioStreamFramer::handleNewData, usingSource),
+      fUsingSource(usingSource),
+      fHaveParsedAFrame(False),
+      fSavedFrame(NULL),
+      fSavedFrameSize(0) {}
+
+AC3AudioStreamParser::~AC3AudioStreamParser() {
+    delete[] fSavedFrame;
+}
+
+void AC3AudioStreamParser::registerReadInterest(unsigned char *to, unsigned maxSize) {
+    fTo      = to;
+    fMaxSize = maxSize;
+}
+
+void AC3AudioStreamParser ::testStreamCode(unsigned char ourStreamCode, unsigned char *ptr, unsigned size) {
+    if(ourStreamCode == 0)
+        return;  // we assume that there's no stream code at the beginning of the data
+
+    if(size < 4)
+        return;
+    unsigned char streamCode = *ptr;
+
+    if(streamCode == ourStreamCode) {
+        // Remove the first 4 bytes from the stream:
+        memmove(ptr, ptr + 4, size - 4);
+        totNumValidBytes() = totNumValidBytes() - 4;
+    }
+    else {
+        // Discard all of the data that was just read:
+        totNumValidBytes() = totNumValidBytes() - size;
+    }
+}
+
+unsigned AC3AudioStreamParser::parseFrame(unsigned &numTruncatedBytes) {
+    if(fSavedFrameSize > 0) {
+        // We've already read and parsed a frame.  Use it instead:
+        memmove(fTo, fSavedFrame, fSavedFrameSize);
+        delete[] fSavedFrame;
+        fSavedFrame        = NULL;
+        unsigned frameSize = fSavedFrameSize;
+        fSavedFrameSize    = 0;
+        return frameSize;
+    }
+
+    try {
+        saveParserState();
+
+        // We expect an AC3 audio header (first 2 bytes == 0x0B77) at the start:
+        while(1) {
+            unsigned next4Bytes = test4Bytes();
+            if(next4Bytes >> 16 == 0x0B77)
+                break;
+            skipBytes(1);
+            saveParserState();
+        }
+        fCurrentFrame.hdr0 = get4Bytes();
+        fCurrentFrame.hdr1 = test4Bytes();
+
+        fCurrentFrame.setParamsFromHeader();
+        fHaveParsedAFrame = True;
+
+        // Copy the frame to the requested destination:
+        unsigned frameSize = fCurrentFrame.frameSize;
+        if(frameSize > fMaxSize) {
+            numTruncatedBytes = frameSize - fMaxSize;
+            frameSize         = fMaxSize;
+        }
+        else {
+            numTruncatedBytes = 0;
+        }
+
+        fTo[0] = fCurrentFrame.hdr0 >> 24;
+        fTo[1] = fCurrentFrame.hdr0 >> 16;
+        fTo[2] = fCurrentFrame.hdr0 >> 8;
+        fTo[3] = fCurrentFrame.hdr0;
+        getBytes(&fTo[4], frameSize - 4);
+        skipBytes(numTruncatedBytes);
+
+        return frameSize;
+    }
+    catch(int /*e*/) {
+#ifdef DEBUG
+        fUsingSource->envir() << "AC3AudioStreamParser::parseFrame() EXCEPTION (This is normal behavior - *not* an error)\n";
+#endif
+        return 0;  // the parsing got interrupted
+    }
+}
+
+void AC3AudioStreamParser::readAndSaveAFrame() {
+    unsigned const maxAC3FrameSize = 4000;
+    delete[] fSavedFrame;
+    fSavedFrame     = new unsigned char[maxAC3FrameSize];
+    fSavedFrameSize = 0;
+
+    fSavedFrameFlag = 0;
+    fUsingSource->getNextFrame(fSavedFrame, maxAC3FrameSize, afterGettingSavedFrame, this, onSavedFrameClosure, this);
+    fUsingSource->envir().taskScheduler().doEventLoop(&fSavedFrameFlag);
+}
+
+void AC3AudioStreamParser ::afterGettingSavedFrame(void *clientData, unsigned frameSize, unsigned /*numTruncatedBytes*/, struct timeval /*presentationTime*/,
+                                                   unsigned /*durationInMicroseconds*/) {
+    AC3AudioStreamParser *parser = (AC3AudioStreamParser *)clientData;
+    parser->afterGettingSavedFrame1(frameSize);
+}
+
+void AC3AudioStreamParser ::afterGettingSavedFrame1(unsigned frameSize) {
+    fSavedFrameSize = frameSize;
+    fSavedFrameFlag = ~0;
+}
+
+void AC3AudioStreamParser::onSavedFrameClosure(void *clientData) {
+    AC3AudioStreamParser *parser = (AC3AudioStreamParser *)clientData;
+    parser->onSavedFrameClosure1();
+}
+
+void AC3AudioStreamParser::onSavedFrameClosure1() {
+    delete[] fSavedFrame;
+    fSavedFrame     = NULL;
+    fSavedFrameSize = 0;
+    fSavedFrameFlag = ~0;
+}
diff --git a/3rdparty/live555/src/liveMedia/ADTSAudioFileServerMediaSubsession.cpp b/3rdparty/live555/src/liveMedia/ADTSAudioFileServerMediaSubsession.cpp
new file mode 100644
index 00000000..330e2161
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/ADTSAudioFileServerMediaSubsession.cpp
@@ -0,0 +1,45 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A 'ServerMediaSubsession' object that creates new, unicast, "RTPSink"s
+// on demand, from an AAC audio file in ADTS format
+// Implementation
+
+#include "ADTSAudioFileServerMediaSubsession.hh"
+#include "ADTSAudioFileSource.hh"
+#include "MPEG4GenericRTPSink.hh"
+
+ADTSAudioFileServerMediaSubsession *ADTSAudioFileServerMediaSubsession::createNew(UsageEnvironment &env, char const *fileName, Boolean reuseFirstSource) {
+    return new ADTSAudioFileServerMediaSubsession(env, fileName, reuseFirstSource);
+}
+
+ADTSAudioFileServerMediaSubsession ::ADTSAudioFileServerMediaSubsession(UsageEnvironment &env, char const *fileName, Boolean reuseFirstSource)
+    : FileServerMediaSubsession(env, fileName, reuseFirstSource) {}
+
+ADTSAudioFileServerMediaSubsession ::~ADTSAudioFileServerMediaSubsession() {}
+
+FramedSource *ADTSAudioFileServerMediaSubsession ::createNewStreamSource(unsigned /*clientSessionId*/, unsigned &estBitrate) {
+    estBitrate = 96;  // kbps, estimate
+
+    return ADTSAudioFileSource::createNew(envir(), fFileName);
+}
+
+RTPSink *ADTSAudioFileServerMediaSubsession ::createNewRTPSink(Groupsock *rtpGroupsock, unsigned char rtpPayloadTypeIfDynamic, FramedSource *inputSource) {
+    ADTSAudioFileSource *adtsSource = (ADTSAudioFileSource *)inputSource;
+    return MPEG4GenericRTPSink::createNew(envir(), rtpGroupsock, rtpPayloadTypeIfDynamic, adtsSource->samplingFrequency(), "audio", "AAC-hbr",
+                                          adtsSource->configStr(), adtsSource->numChannels());
+}
diff --git a/3rdparty/live555/src/liveMedia/ADTSAudioFileSource.cpp b/3rdparty/live555/src/liveMedia/ADTSAudioFileSource.cpp
new file mode 100644
index 00000000..18a73e6f
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/ADTSAudioFileSource.cpp
@@ -0,0 +1,160 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A source object for AAC audio files in ADTS format
+// Implementation
+
+#include "ADTSAudioFileSource.hh"
+#include "InputFile.hh"
+#include <GroupsockHelper.hh>
+
+////////// ADTSAudioFileSource //////////
+
+static unsigned const samplingFrequencyTable[16] = { 96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050, 16000, 12000, 11025, 8000, 7350, 0, 0, 0 };
+
+ADTSAudioFileSource *ADTSAudioFileSource::createNew(UsageEnvironment &env, char const *fileName) {
+    FILE *fid = NULL;
+    do {
+        fid = OpenInputFile(env, fileName);
+        if(fid == NULL)
+            break;
+
+        // Now, having opened the input file, read the fixed header of the first frame,
+        // to get the audio stream's parameters:
+        unsigned char fixedHeader[4];  // it's actually 3.5 bytes long
+        if(fread(fixedHeader, 1, sizeof fixedHeader, fid) < sizeof fixedHeader)
+            break;
+
+        // Check the 'syncword':
+        if(!(fixedHeader[0] == 0xFF && (fixedHeader[1] & 0xF0) == 0xF0)) {
+            env.setResultMsg("Bad 'syncword' at start of ADTS file");
+            break;
+        }
+
+        // Get and check the 'profile':
+        u_int8_t profile = (fixedHeader[2] & 0xC0) >> 6;  // 2 bits
+        if(profile == 3) {
+            env.setResultMsg("Bad (reserved) 'profile': 3 in first frame of ADTS file");
+            break;
+        }
+
+        // Get and check the 'sampling_frequency_index':
+        u_int8_t sampling_frequency_index = (fixedHeader[2] & 0x3C) >> 2;  // 4 bits
+        if(samplingFrequencyTable[sampling_frequency_index] == 0) {
+            env.setResultMsg("Bad 'sampling_frequency_index' in first frame of ADTS file");
+            break;
+        }
+
+        // Get and check the 'channel_configuration':
+        u_int8_t channel_configuration = ((fixedHeader[2] & 0x01) << 2) | ((fixedHeader[3] & 0xC0) >> 6);  // 3 bits
+
+        // If we get here, the frame header was OK.
+        // Reset the fid to the beginning of the file:
+#ifndef _WIN32_WCE
+        rewind(fid);
+#else
+        SeekFile64(fid, SEEK_SET, 0);
+#endif
+#ifdef DEBUG
+        fprintf(stderr,
+                "Read first frame: profile %d, "
+                "sampling_frequency_index %d => samplingFrequency %d, "
+                "channel_configuration %d\n",
+                profile, sampling_frequency_index, samplingFrequencyTable[sampling_frequency_index], channel_configuration);
+#endif
+        return new ADTSAudioFileSource(env, fid, profile, sampling_frequency_index, channel_configuration);
+    } while(0);
+
+    // An error occurred:
+    CloseInputFile(fid);
+    return NULL;
+}
+
+ADTSAudioFileSource ::ADTSAudioFileSource(UsageEnvironment &env, FILE *fid, u_int8_t profile, u_int8_t samplingFrequencyIndex, u_int8_t channelConfiguration)
+    : FramedFileSource(env, fid) {
+    fSamplingFrequency = samplingFrequencyTable[samplingFrequencyIndex];
+    fNumChannels       = channelConfiguration == 0 ? 2 : channelConfiguration;
+    fuSecsPerFrame     = (1024 /*samples-per-frame*/ * 1000000) / fSamplingFrequency /*samples-per-second*/;
+
+    // Construct the 'AudioSpecificConfig', and from it, the corresponding ASCII string:
+    unsigned char  audioSpecificConfig[2];
+    u_int8_t const audioObjectType = profile + 1;
+    audioSpecificConfig[0]         = (audioObjectType << 3) | (samplingFrequencyIndex >> 1);
+    audioSpecificConfig[1]         = (samplingFrequencyIndex << 7) | (channelConfiguration << 3);
+    sprintf(fConfigStr, "%02X%02X", audioSpecificConfig[0], audioSpecificConfig[1]);
+}
+
+ADTSAudioFileSource::~ADTSAudioFileSource() {
+    CloseInputFile(fFid);
+}
+
+// Note: We should change the following to use asynchronous file reading, #####
+// as we now do with ByteStreamFileSource. #####
+void ADTSAudioFileSource::doGetNextFrame() {
+    // Begin by reading the 7-byte fixed_variable headers:
+    unsigned char headers[7];
+    if(fread(headers, 1, sizeof headers, fFid) < sizeof headers || feof(fFid) || ferror(fFid)) {
+        // The input source has ended:
+        handleClosure();
+        return;
+    }
+
+    // Extract important fields from the headers:
+    Boolean   protection_absent = headers[1] & 0x01;
+    u_int16_t frame_length      = ((headers[3] & 0x03) << 11) | (headers[4] << 3) | ((headers[5] & 0xE0) >> 5);
+#ifdef DEBUG
+    u_int16_t syncword = (headers[0] << 4) | (headers[1] >> 4);
+    fprintf(stderr, "Read frame: syncword 0x%x, protection_absent %d, frame_length %d\n", syncword, protection_absent, frame_length);
+    if(syncword != 0xFFF)
+        fprintf(stderr, "WARNING: Bad syncword!\n");
+#endif
+    unsigned numBytesToRead = frame_length > sizeof headers ? frame_length - sizeof headers : 0;
+
+    // If there's a 'crc_check' field, skip it:
+    if(!protection_absent) {
+        SeekFile64(fFid, 2, SEEK_CUR);
+        numBytesToRead = numBytesToRead > 2 ? numBytesToRead - 2 : 0;
+    }
+
+    // Next, read the raw frame data into the buffer provided:
+    if(numBytesToRead > fMaxSize) {
+        fNumTruncatedBytes = numBytesToRead - fMaxSize;
+        numBytesToRead     = fMaxSize;
+    }
+    int numBytesRead = fread(fTo, 1, numBytesToRead, fFid);
+    if(numBytesRead < 0)
+        numBytesRead = 0;
+    fFrameSize = numBytesRead;
+    fNumTruncatedBytes += numBytesToRead - numBytesRead;
+
+    // Set the 'presentation time':
+    if(fPresentationTime.tv_sec == 0 && fPresentationTime.tv_usec == 0) {
+        // This is the first frame, so use the current time:
+        gettimeofday(&fPresentationTime, NULL);
+    }
+    else {
+        // Increment by the play time of the previous frame:
+        unsigned uSeconds = fPresentationTime.tv_usec + fuSecsPerFrame;
+        fPresentationTime.tv_sec += uSeconds / 1000000;
+        fPresentationTime.tv_usec = uSeconds % 1000000;
+    }
+
+    fDurationInMicroseconds = fuSecsPerFrame;
+
+    // Switch to another task, and inform the reader that he has data:
+    nextTask() = envir().taskScheduler().scheduleDelayedTask(0, (TaskFunc *)FramedSource::afterGetting, this);
+}
diff --git a/3rdparty/live555/src/liveMedia/ADTSAudioStreamDiscreteFramer.cpp b/3rdparty/live555/src/liveMedia/ADTSAudioStreamDiscreteFramer.cpp
new file mode 100644
index 00000000..8f909312
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/ADTSAudioStreamDiscreteFramer.cpp
@@ -0,0 +1,116 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A filter that reads (discrete) AAC audio frames, and outputs each frame with
+// a preceding ADTS header.
+// Implementation
+
+#include "ADTSAudioStreamDiscreteFramer.hh"
+
+static u_int8_t hexToBinary(char c) {
+    if(c >= '0' && c <= '9')
+        return c - '0';
+    if(c >= 'a' && c <= 'f')
+        return 10 + (c - 'a');
+    if(c >= 'A' && c <= 'F')
+        return 10 + (c - 'A');
+
+    return 0;  // default if 'c' is not hex
+}
+
+ADTSAudioStreamDiscreteFramer *ADTSAudioStreamDiscreteFramer ::createNew(UsageEnvironment &env, FramedSource *inputSource, char const *configStr) {
+    u_int16_t configValue = 0;
+
+    if(configStr != NULL && strlen(configStr) >= 4) {
+        configValue = (hexToBinary(configStr[0]) << 12) | (hexToBinary(configStr[1]) << 8) | (hexToBinary(configStr[2]) << 4) | hexToBinary(configStr[3]);
+    }
+
+    // Unpack the 2-byte 'config' value to get "profile", "samplingFrequencyIndex",
+    // and "channelConfiguration":
+    u_int8_t audioObjectType        = configValue >> 11;
+    u_int8_t profile                = audioObjectType == 0 ? 0 : audioObjectType - 1;
+    u_int8_t samplingFrequencyIndex = (configValue & 0x0780) >> 7;
+    u_int8_t channelConfiguration   = (configValue & 0x0078) >> 3;
+
+    return new ADTSAudioStreamDiscreteFramer(env, inputSource, profile, samplingFrequencyIndex, channelConfiguration);
+}
+
+ADTSAudioStreamDiscreteFramer ::ADTSAudioStreamDiscreteFramer(UsageEnvironment &env, FramedSource *inputSource, u_int8_t profile,
+                                                              u_int8_t samplingFrequencyIndex, u_int8_t channelConfiguration)
+    : FramedFilter(env, inputSource) {
+    // Set up the ADTS header that we'll be prepending to each audio frame.
+    // This will be fixed, except for the frame size.
+    profile &= 0x03;                 // use 2 bits only
+    samplingFrequencyIndex &= 0x0F;  // use 4 bits only
+    channelConfiguration &= 0x07;    // use 3 bits only
+
+    fADTSHeader[0] = 0xFF;  // first 8 bits of syncword
+    fADTSHeader[1] = 0xF1;  // last 4 bits of syncword; version 0; layer 0; protection absent
+    fADTSHeader[2] = (profile << 6) | (samplingFrequencyIndex << 2) | (channelConfiguration >> 2);
+    fADTSHeader[3] = channelConfiguration << 6;
+    fADTSHeader[4] = 0;
+    fADTSHeader[5] = 0x1F;  // set 'buffer fullness' to all-1s
+    fADTSHeader[6] = 0xFC;  // set 'buffer fullness' to all-1s
+}
+
+ADTSAudioStreamDiscreteFramer::~ADTSAudioStreamDiscreteFramer() {}
+
+void ADTSAudioStreamDiscreteFramer::doGetNextFrame() {
+    // Arrange to read data (an AAC audio frame) from our data source, directly into the
+    // downstream object's buffer, allowing for the ATDS header in front.
+    // Make sure there's enoughn space:
+    if(fMaxSize <= ADTS_HEADER_SIZE) {
+        fNumTruncatedBytes = ADTS_HEADER_SIZE - fMaxSize;
+        handleClosure();
+        return;
+    }
+
+    fInputSource->getNextFrame(fTo + ADTS_HEADER_SIZE, fMaxSize - ADTS_HEADER_SIZE, afterGettingFrame, this, FramedSource::handleClosure, this);
+}
+
+void ADTSAudioStreamDiscreteFramer ::afterGettingFrame(void *clientData, unsigned frameSize, unsigned numTruncatedBytes, struct timeval presentationTime,
+                                                       unsigned durationInMicroseconds) {
+    ADTSAudioStreamDiscreteFramer *source = (ADTSAudioStreamDiscreteFramer *)clientData;
+    source->afterGettingFrame1(frameSize, numTruncatedBytes, presentationTime, durationInMicroseconds);
+}
+
+void ADTSAudioStreamDiscreteFramer ::afterGettingFrame1(unsigned frameSize, unsigned numTruncatedBytes, struct timeval presentationTime,
+                                                        unsigned durationInMicroseconds) {
+    frameSize += ADTS_HEADER_SIZE;
+
+    // Fill in the ADTS header with the (updated) frame size:
+    fFrameSize = frameSize;
+    frameSize &= 0x1FFF;  // use only 13 bits in the ADTS header
+    fADTSHeader[3] = (fADTSHeader[3] & 0xFC) | (frameSize >> 11);
+    fADTSHeader[4] = frameSize >> 3;
+    fADTSHeader[5] = (fADTSHeader[5] & 0x1F) | (frameSize << 5);
+
+    // And copy the ADTS header to the destination:
+    fTo[0] = fADTSHeader[0];
+    fTo[1] = fADTSHeader[1];
+    fTo[2] = fADTSHeader[2];
+    fTo[3] = fADTSHeader[3];
+    fTo[4] = fADTSHeader[4];
+    fTo[5] = fADTSHeader[5];
+    fTo[6] = fADTSHeader[6];
+
+    // Complete delivery to the downstream object:
+    fNumTruncatedBytes      = numTruncatedBytes;
+    fPresentationTime       = presentationTime;
+    fDurationInMicroseconds = durationInMicroseconds;
+    afterGetting(this);
+}
diff --git a/3rdparty/live555/src/liveMedia/AMRAudioFileServerMediaSubsession.cpp b/3rdparty/live555/src/liveMedia/AMRAudioFileServerMediaSubsession.cpp
new file mode 100644
index 00000000..37a22d05
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/AMRAudioFileServerMediaSubsession.cpp
@@ -0,0 +1,44 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A 'ServerMediaSubsession' object that creates new, unicast, "RTPSink"s
+// on demand, from an AMR audio file.
+// Implementation
+
+#include "AMRAudioFileServerMediaSubsession.hh"
+#include "AMRAudioRTPSink.hh"
+#include "AMRAudioFileSource.hh"
+
+AMRAudioFileServerMediaSubsession *AMRAudioFileServerMediaSubsession::createNew(UsageEnvironment &env, char const *fileName, Boolean reuseFirstSource) {
+    return new AMRAudioFileServerMediaSubsession(env, fileName, reuseFirstSource);
+}
+
+AMRAudioFileServerMediaSubsession ::AMRAudioFileServerMediaSubsession(UsageEnvironment &env, char const *fileName, Boolean reuseFirstSource)
+    : FileServerMediaSubsession(env, fileName, reuseFirstSource) {}
+
+AMRAudioFileServerMediaSubsession ::~AMRAudioFileServerMediaSubsession() {}
+
+FramedSource *AMRAudioFileServerMediaSubsession ::createNewStreamSource(unsigned /*clientSessionId*/, unsigned &estBitrate) {
+    estBitrate = 10;  // kbps, estimate
+
+    return AMRAudioFileSource::createNew(envir(), fFileName);
+}
+
+RTPSink *AMRAudioFileServerMediaSubsession ::createNewRTPSink(Groupsock *rtpGroupsock, unsigned char rtpPayloadTypeIfDynamic, FramedSource *inputSource) {
+    AMRAudioFileSource *amrSource = (AMRAudioFileSource *)inputSource;
+    return AMRAudioRTPSink::createNew(envir(), rtpGroupsock, rtpPayloadTypeIfDynamic, amrSource->isWideband(), amrSource->numChannels());
+}
diff --git a/3rdparty/live555/src/liveMedia/AMRAudioFileSink.cpp b/3rdparty/live555/src/liveMedia/AMRAudioFileSink.cpp
new file mode 100644
index 00000000..cfd234eb
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/AMRAudioFileSink.cpp
@@ -0,0 +1,93 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// AMR Audio File sinks
+// Implementation
+
+#include "AMRAudioFileSink.hh"
+#include "AMRAudioSource.hh"
+#include "OutputFile.hh"
+
+////////// AMRAudioFileSink //////////
+
+AMRAudioFileSink ::AMRAudioFileSink(UsageEnvironment &env, FILE *fid, unsigned bufferSize, char const *perFrameFileNamePrefix)
+    : FileSink(env, fid, bufferSize, perFrameFileNamePrefix), fHaveWrittenHeader(False) {}
+
+AMRAudioFileSink::~AMRAudioFileSink() {}
+
+AMRAudioFileSink *AMRAudioFileSink::createNew(UsageEnvironment &env, char const *fileName, unsigned bufferSize, Boolean oneFilePerFrame) {
+    do {
+        FILE *      fid;
+        char const *perFrameFileNamePrefix;
+        if(oneFilePerFrame) {
+            // Create the fid for each frame
+            fid                    = NULL;
+            perFrameFileNamePrefix = fileName;
+        }
+        else {
+            // Normal case: create the fid once
+            fid = OpenOutputFile(env, fileName);
+            if(fid == NULL)
+                break;
+            perFrameFileNamePrefix = NULL;
+        }
+
+        return new AMRAudioFileSink(env, fid, bufferSize, perFrameFileNamePrefix);
+    } while(0);
+
+    return NULL;
+}
+
+Boolean AMRAudioFileSink::sourceIsCompatibleWithUs(MediaSource &source) {
+    // The input source must be a AMR Audio source:
+    return source.isAMRAudioSource();
+}
+
+void AMRAudioFileSink::afterGettingFrame(unsigned frameSize, unsigned numTruncatedBytes, struct timeval presentationTime) {
+    AMRAudioSource *source = (AMRAudioSource *)fSource;
+    if(source == NULL)
+        return;  // sanity check
+
+    if(!fHaveWrittenHeader && fPerFrameFileNameBuffer == NULL) {
+        // Output the appropriate AMR header to the start of the file.
+        // This header is defined in RFC 4867, section 5.
+        // (However, we don't do this if we're creating one file per frame.)
+        char headerBuffer[100];
+        sprintf(headerBuffer, "#!AMR%s%s\n", source->isWideband() ? "-WB" : "", source->numChannels() > 1 ? "_MC1.0" : "");
+        unsigned headerLength = strlen(headerBuffer);
+        if(source->numChannels() > 1) {
+            // Also add a 32-bit channel description field:
+            headerBuffer[headerLength++] = 0;
+            headerBuffer[headerLength++] = 0;
+            headerBuffer[headerLength++] = 0;
+            headerBuffer[headerLength++] = source->numChannels();
+        }
+
+        addData((unsigned char *)headerBuffer, headerLength, presentationTime);
+    }
+    fHaveWrittenHeader = True;
+
+    // Add the 1-byte header, before writing the file data proper:
+    // (Again, we don't do this if we're creating one file per frame.)
+    if(fPerFrameFileNameBuffer == NULL) {
+        u_int8_t frameHeader = source->lastFrameHeader();
+        addData(&frameHeader, 1, presentationTime);
+    }
+
+    // Call the parent class to complete the normal file write with the input data:
+    FileSink::afterGettingFrame(frameSize, numTruncatedBytes, presentationTime);
+}
diff --git a/3rdparty/live555/src/liveMedia/AMRAudioFileSource.cpp b/3rdparty/live555/src/liveMedia/AMRAudioFileSource.cpp
new file mode 100644
index 00000000..8c876f1e
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/AMRAudioFileSource.cpp
@@ -0,0 +1,168 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A source object for AMR audio files (as defined in RFC 4867, section 5)
+// Implementation
+
+#include "AMRAudioFileSource.hh"
+#include "InputFile.hh"
+#include "GroupsockHelper.hh"
+
+////////// AMRAudioFileSource //////////
+
+AMRAudioFileSource *AMRAudioFileSource::createNew(UsageEnvironment &env, char const *fileName) {
+    FILE *  fid           = NULL;
+    Boolean magicNumberOK = True;
+    do {
+
+        fid = OpenInputFile(env, fileName);
+        if(fid == NULL)
+            break;
+
+        // Now, having opened the input file, read the first few bytes, to
+        // check the required 'magic number':
+        magicNumberOK        = False;  // until we learn otherwise
+        Boolean  isWideband  = False;  // by default
+        unsigned numChannels = 1;      // by default
+        char     buf[100];
+        // Start with the first 6 bytes (the first 5 of which must be "#!AMR"):
+        if(fread(buf, 1, 6, fid) < 6)
+            break;
+        if(strncmp(buf, "#!AMR", 5) != 0)
+            break;  // bad magic #
+        unsigned bytesRead = 6;
+
+        // The next bytes must be "\n", "-WB\n", "_MC1.0\n", or "-WB_MC1.0\n"
+        if(buf[5] == '-') {
+            // The next bytes must be "WB\n" or "WB_MC1.0\n"
+            if(fread(&buf[bytesRead], 1, 3, fid) < 3)
+                break;
+            if(strncmp(&buf[bytesRead], "WB", 2) != 0)
+                break;  // bad magic #
+            isWideband = True;
+            bytesRead += 3;
+        }
+        if(buf[bytesRead - 1] == '_') {
+            // The next bytes must be "MC1.0\n"
+            if(fread(&buf[bytesRead], 1, 6, fid) < 6)
+                break;
+            if(strncmp(&buf[bytesRead], "MC1.0\n", 6) != 0)
+                break;  // bad magic #
+            bytesRead += 6;
+
+            // The next 4 bytes contain the number of channels:
+            char channelDesc[4];
+            if(fread(channelDesc, 1, 4, fid) < 4)
+                break;
+            numChannels = channelDesc[3] & 0xF;
+        }
+        else if(buf[bytesRead - 1] != '\n') {
+            break;  // bad magic #
+        }
+
+        // If we get here, the magic number was OK:
+        magicNumberOK = True;
+
+#ifdef DEBUG
+        fprintf(stderr, "isWideband: %d, numChannels: %d\n", isWideband, numChannels);
+#endif
+        return new AMRAudioFileSource(env, fid, isWideband, numChannels);
+    } while(0);
+
+    // An error occurred:
+    CloseInputFile(fid);
+    if(!magicNumberOK) {
+        env.setResultMsg("Bad (or nonexistent) AMR file header");
+    }
+    return NULL;
+}
+
+AMRAudioFileSource ::AMRAudioFileSource(UsageEnvironment &env, FILE *fid, Boolean isWideband, unsigned numChannels)
+    : AMRAudioSource(env, isWideband, numChannels), fFid(fid) {}
+
+AMRAudioFileSource::~AMRAudioFileSource() {
+    CloseInputFile(fFid);
+}
+
+// The mapping from the "FT" field to frame size.
+// Values of 65535 are invalid.
+#define FT_INVALID 65535
+static unsigned short const frameSize[16] = { 12, 13, 15, 17, 19, 20, 26, 31, 5, FT_INVALID, FT_INVALID, FT_INVALID, FT_INVALID, FT_INVALID, FT_INVALID, 0 };
+static unsigned short const frameSizeWideband[16] = { 17, 23, 32, 36, 40, 46, 50, 58, 60, 5, FT_INVALID, FT_INVALID, FT_INVALID, FT_INVALID, 0, 0 };
+
+// Note: We should change the following to use asynchronous file reading, #####
+// as we now do with ByteStreamFileSource. #####
+void AMRAudioFileSource::doGetNextFrame() {
+    if(feof(fFid) || ferror(fFid)) {
+        handleClosure();
+        return;
+    }
+
+    // Begin by reading the 1-byte frame header (and checking it for validity)
+    while(1) {
+        if(fread(&fLastFrameHeader, 1, 1, fFid) < 1) {
+            handleClosure();
+            return;
+        }
+        if((fLastFrameHeader & 0x83) != 0) {
+#ifdef DEBUG
+            fprintf(stderr, "Invalid frame header 0x%02x (padding bits (0x83) are not zero)\n", fLastFrameHeader);
+#endif
+        }
+        else {
+            unsigned char ft = (fLastFrameHeader & 0x78) >> 3;
+            fFrameSize       = fIsWideband ? frameSizeWideband[ft] : frameSize[ft];
+            if(fFrameSize == FT_INVALID) {
+#ifdef DEBUG
+                fprintf(stderr, "Invalid FT field %d (from frame header 0x%02x)\n", ft, fLastFrameHeader);
+#endif
+            }
+            else {
+                // The frame header is OK
+#ifdef DEBUG
+                fprintf(stderr, "Valid frame header 0x%02x -> ft %d -> frame size %d\n", fLastFrameHeader, ft, fFrameSize);
+#endif
+                break;
+            }
+        }
+    }
+
+    // Next, read the frame-block into the buffer provided:
+    fFrameSize *= fNumChannels;  // because multiple channels make up a frame-block
+    if(fFrameSize > fMaxSize) {
+        fNumTruncatedBytes = fFrameSize - fMaxSize;
+        fFrameSize         = fMaxSize;
+    }
+    fFrameSize = fread(fTo, 1, fFrameSize, fFid);
+
+    // Set the 'presentation time':
+    if(fPresentationTime.tv_sec == 0 && fPresentationTime.tv_usec == 0) {
+        // This is the first frame, so use the current time:
+        gettimeofday(&fPresentationTime, NULL);
+    }
+    else {
+        // Increment by the play time of the previous frame (20 ms)
+        unsigned uSeconds = fPresentationTime.tv_usec + 20000;
+        fPresentationTime.tv_sec += uSeconds / 1000000;
+        fPresentationTime.tv_usec = uSeconds % 1000000;
+    }
+
+    fDurationInMicroseconds = 20000;  // each frame is 20 ms
+
+    // Switch to another task, and inform the reader that he has data:
+    nextTask() = envir().taskScheduler().scheduleDelayedTask(0, (TaskFunc *)FramedSource::afterGetting, this);
+}
diff --git a/3rdparty/live555/src/liveMedia/AMRAudioRTPSink.cpp b/3rdparty/live555/src/liveMedia/AMRAudioRTPSink.cpp
new file mode 100644
index 00000000..ded3a6e6
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/AMRAudioRTPSink.cpp
@@ -0,0 +1,122 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// RTP sink for AMR audio (RFC 4867)
+// Implementation
+
+// NOTE: At present, this is just a limited implementation, supporting:
+// octet-alignment only; no interleaving; no frame CRC; no robust-sorting.
+
+#include "AMRAudioRTPSink.hh"
+#include "AMRAudioSource.hh"
+
+AMRAudioRTPSink *AMRAudioRTPSink::createNew(UsageEnvironment &env, Groupsock *RTPgs, unsigned char rtpPayloadFormat, Boolean sourceIsWideband,
+                                            unsigned numChannelsInSource) {
+    return new AMRAudioRTPSink(env, RTPgs, rtpPayloadFormat, sourceIsWideband, numChannelsInSource);
+}
+
+AMRAudioRTPSink ::AMRAudioRTPSink(UsageEnvironment &env, Groupsock *RTPgs, unsigned char rtpPayloadFormat, Boolean sourceIsWideband,
+                                  unsigned numChannelsInSource)
+    : AudioRTPSink(env, RTPgs, rtpPayloadFormat, sourceIsWideband ? 16000 : 8000, sourceIsWideband ? "AMR-WB" : "AMR", numChannelsInSource),
+      fSourceIsWideband(sourceIsWideband),
+      fFmtpSDPLine(NULL) {}
+
+AMRAudioRTPSink::~AMRAudioRTPSink() {
+    delete[] fFmtpSDPLine;
+}
+
+Boolean AMRAudioRTPSink::sourceIsCompatibleWithUs(MediaSource &source) {
+    // Our source must be an AMR audio source:
+    if(!source.isAMRAudioSource())
+        return False;
+
+    // Also, the source must be wideband iff we asked for this:
+    AMRAudioSource &amrSource = (AMRAudioSource &)source;
+    if((amrSource.isWideband() ^ fSourceIsWideband) != 0)
+        return False;
+
+    // Also, the source must have the same number of channels that we
+    // specified.  (It could, in principle, have more, but we don't
+    // support that.)
+    if(amrSource.numChannels() != numChannels())
+        return False;
+
+    // Also, because in our current implementation we output only one
+    // frame in each RTP packet, this means that for multi-channel audio,
+    // each 'frame-block' will be split over multiple RTP packets, which
+    // may violate the spec.  Warn about this:
+    if(amrSource.numChannels() > 1) {
+        envir() << "AMRAudioRTPSink: Warning: Input source has " << amrSource.numChannels()
+                << " audio channels.  In the current implementation, the multi-frame frame-block will be split over multiple RTP packets\n";
+    }
+
+    return True;
+}
+
+void AMRAudioRTPSink::doSpecialFrameHandling(unsigned fragmentationOffset, unsigned char *frameStart, unsigned numBytesInFrame,
+                                             struct timeval framePresentationTime, unsigned numRemainingBytes) {
+    // If this is the 1st frame in the 1st packet, set the RTP 'M' (marker)
+    // bit (because this is considered the start of a talk spurt):
+    if(isFirstPacket() && isFirstFrameInPacket()) {
+        setMarkerBit();
+    }
+
+    // If this is the first frame in the packet, set the 1-byte payload
+    // header (using CMR 15)
+    if(isFirstFrameInPacket()) {
+        u_int8_t payloadHeader = 0xF0;
+        setSpecialHeaderBytes(&payloadHeader, 1, 0);
+    }
+
+    // Set the TOC field for the current frame, based on the "FT" and "Q"
+    // values from our source:
+    AMRAudioSource *amrSource = (AMRAudioSource *)fSource;
+    if(amrSource == NULL)
+        return;  // sanity check
+
+    u_int8_t toc = amrSource->lastFrameHeader();
+    // Clear the "F" bit, because we're the last frame in this packet: #####
+    toc &= ~0x80;
+    setSpecialHeaderBytes(&toc, 1, 1 + numFramesUsedSoFar());
+
+    // Important: Also call our base class's doSpecialFrameHandling(),
+    // to set the packet's timestamp:
+    MultiFramedRTPSink::doSpecialFrameHandling(fragmentationOffset, frameStart, numBytesInFrame, framePresentationTime, numRemainingBytes);
+}
+
+Boolean AMRAudioRTPSink ::frameCanAppearAfterPacketStart(unsigned char const * /*frameStart*/, unsigned /*numBytesInFrame*/) const {
+    // For now, pack only one AMR frame into each outgoing RTP packet: #####
+    return False;
+}
+
+unsigned AMRAudioRTPSink::specialHeaderSize() const {
+    // For now, because we're packing only one frame per packet,
+    // there's just a 1-byte payload header, plus a 1-byte TOC #####
+    return 2;
+}
+
+char const *AMRAudioRTPSink::auxSDPLine() {
+    if(fFmtpSDPLine == NULL) {
+        // Generate a "a=fmtp:" line with "octet-aligned=1"
+        // (That is the only non-default parameter.)
+        char buf[100];
+        sprintf(buf, "a=fmtp:%d octet-align=1\r\n", rtpPayloadType());
+        delete[] fFmtpSDPLine;
+        fFmtpSDPLine = strDup(buf);
+    }
+    return fFmtpSDPLine;
+}
diff --git a/3rdparty/live555/src/liveMedia/AMRAudioRTPSource.cpp b/3rdparty/live555/src/liveMedia/AMRAudioRTPSource.cpp
new file mode 100644
index 00000000..89de73af
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/AMRAudioRTPSource.cpp
@@ -0,0 +1,707 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// AMR Audio RTP Sources (RFC 4867)
+// Implementation
+
+#include "AMRAudioRTPSource.hh"
+#include "MultiFramedRTPSource.hh"
+#include "BitVector.hh"
+#include <string.h>
+#include <stdlib.h>
+
+// This source is implemented internally by two separate sources:
+// (i) a RTP source for the raw (and possibly interleaved) AMR frames, and
+// (ii) a deinterleaving filter that reads from this.
+// Define these two new classes here:
+
+class RawAMRRTPSource : public MultiFramedRTPSource {
+public:
+    static RawAMRRTPSource *createNew(UsageEnvironment &env, Groupsock *RTPgs, unsigned char rtpPayloadFormat, Boolean isWideband, Boolean isOctetAligned,
+                                      Boolean isInterleaved, Boolean CRCsArePresent);
+
+    Boolean isWideband() const {
+        return fIsWideband;
+    }
+    unsigned char ILL() const {
+        return fILL;
+    }
+    unsigned char ILP() const {
+        return fILP;
+    }
+    unsigned TOCSize() const {
+        return fTOCSize;
+    }  // total # of frames in the last pkt
+    unsigned char *TOC() const {
+        return fTOC;
+    }  // FT+Q value for each TOC entry
+    unsigned &frameIndex() {
+        return fFrameIndex;
+    }  // index of frame-block within pkt
+    Boolean &isSynchronized() {
+        return fIsSynchronized;
+    }
+
+private:
+    RawAMRRTPSource(UsageEnvironment &env, Groupsock *RTPgs, unsigned char rtpPayloadFormat, Boolean isWideband, Boolean isOctetAligned, Boolean isInterleaved,
+                    Boolean CRCsArePresent);
+    // called only by createNew()
+
+    virtual ~RawAMRRTPSource();
+
+private:
+    // redefined virtual functions:
+    virtual Boolean hasBeenSynchronizedUsingRTCP();
+
+    virtual Boolean     processSpecialHeader(BufferedPacket *packet, unsigned &resultSpecialHeaderSize);
+    virtual char const *MIMEtype() const;
+
+private:
+    Boolean        fIsWideband, fIsOctetAligned, fIsInterleaved, fCRCsArePresent;
+    unsigned char  fILL, fILP;
+    unsigned       fTOCSize;
+    unsigned char *fTOC;
+    unsigned       fFrameIndex;
+    Boolean        fIsSynchronized;
+};
+
+class AMRDeinterleaver : public AMRAudioSource {
+public:
+    static AMRDeinterleaver *createNew(UsageEnvironment &env, Boolean isWideband, unsigned numChannels, unsigned maxInterleaveGroupSize,
+                                       RawAMRRTPSource *inputSource);
+
+private:
+    AMRDeinterleaver(UsageEnvironment &env, Boolean isWideband, unsigned numChannels, unsigned maxInterleaveGroupSize, RawAMRRTPSource *inputSource);
+    // called only by "createNew()"
+
+    virtual ~AMRDeinterleaver();
+
+    static void afterGettingFrame(void *clientData, unsigned frameSize, unsigned numTruncatedBytes, struct timeval presentationTime,
+                                  unsigned durationInMicroseconds);
+    void        afterGettingFrame1(unsigned frameSize, struct timeval presentationTime);
+
+private:
+    // Redefined virtual functions:
+    void         doGetNextFrame();
+    virtual void doStopGettingFrames();
+
+private:
+    RawAMRRTPSource *              fInputSource;
+    class AMRDeinterleavingBuffer *fDeinterleavingBuffer;
+    Boolean                        fNeedAFrame;
+};
+
+////////// AMRAudioRTPSource implementation //////////
+
+#define MAX_NUM_CHANNELS 20  // far larger than ever expected...
+#define MAX_INTERLEAVING_GROUP_SIZE 1000  // far larger than ever expected...
+
+AMRAudioSource *AMRAudioRTPSource::createNew(UsageEnvironment &env, Groupsock *RTPgs, RTPSource *&resultRTPSource, unsigned char rtpPayloadFormat,
+                                             Boolean isWideband, unsigned numChannels, Boolean isOctetAligned, unsigned interleaving,
+                                             Boolean robustSortingOrder, Boolean CRCsArePresent) {
+    // Perform sanity checks on the input parameters:
+    if(robustSortingOrder) {
+        env << "AMRAudioRTPSource::createNew(): 'Robust sorting order' was specified, but we don't yet support this!\n";
+        return NULL;
+    }
+    else if(numChannels > MAX_NUM_CHANNELS) {
+        env << "AMRAudioRTPSource::createNew(): The \"number of channels\" parameter (" << numChannels << ") is much too large!\n";
+        return NULL;
+    }
+    else if(interleaving > MAX_INTERLEAVING_GROUP_SIZE) {
+        env << "AMRAudioRTPSource::createNew(): The \"interleaving\" parameter (" << interleaving << ") is much too large!\n";
+        return NULL;
+    }
+
+    // 'Bandwidth-efficient mode' precludes some other options:
+    if(!isOctetAligned) {
+        if(interleaving > 0 || robustSortingOrder || CRCsArePresent) {
+            env << "AMRAudioRTPSource::createNew(): 'Bandwidth-efficient mode' was specified, along with interleaving, 'robust sorting order', and/or CRCs, so "
+                   "we assume 'octet-aligned mode' instead.\n";
+            isOctetAligned = True;
+        }
+    }
+
+    Boolean  isInterleaved;
+    unsigned maxInterleaveGroupSize;  // in frames (not frame-blocks)
+    if(interleaving > 0) {
+        isInterleaved          = True;
+        maxInterleaveGroupSize = interleaving * numChannels;
+    }
+    else {
+        isInterleaved          = False;
+        maxInterleaveGroupSize = numChannels;
+    }
+
+    RawAMRRTPSource *rawRTPSource;
+    resultRTPSource = rawRTPSource = RawAMRRTPSource::createNew(env, RTPgs, rtpPayloadFormat, isWideband, isOctetAligned, isInterleaved, CRCsArePresent);
+    if(resultRTPSource == NULL)
+        return NULL;
+
+    AMRDeinterleaver *deinterleaver = AMRDeinterleaver::createNew(env, isWideband, numChannels, maxInterleaveGroupSize, rawRTPSource);
+    if(deinterleaver == NULL) {
+        Medium::close(resultRTPSource);
+        resultRTPSource = NULL;
+    }
+
+    return deinterleaver;
+}
+
+////////// AMRBufferedPacket and AMRBufferedPacketFactory //////////
+
+// A subclass of BufferedPacket, used to separate out AMR frames.
+
+class AMRBufferedPacket : public BufferedPacket {
+public:
+    AMRBufferedPacket(RawAMRRTPSource &ourSource);
+    virtual ~AMRBufferedPacket();
+
+private:  // redefined virtual functions
+    virtual unsigned nextEnclosedFrameSize(unsigned char *&framePtr, unsigned dataSize);
+
+private:
+    RawAMRRTPSource &fOurSource;
+};
+
+class AMRBufferedPacketFactory : public BufferedPacketFactory {
+private:  // redefined virtual functions
+    virtual BufferedPacket *createNewPacket(MultiFramedRTPSource *ourSource);
+};
+
+///////// RawAMRRTPSource implementation ////////
+
+RawAMRRTPSource *RawAMRRTPSource::createNew(UsageEnvironment &env, Groupsock *RTPgs, unsigned char rtpPayloadFormat, Boolean isWideband, Boolean isOctetAligned,
+                                            Boolean isInterleaved, Boolean CRCsArePresent) {
+    return new RawAMRRTPSource(env, RTPgs, rtpPayloadFormat, isWideband, isOctetAligned, isInterleaved, CRCsArePresent);
+}
+
+RawAMRRTPSource ::RawAMRRTPSource(UsageEnvironment &env, Groupsock *RTPgs, unsigned char rtpPayloadFormat, Boolean isWideband, Boolean isOctetAligned,
+                                  Boolean isInterleaved, Boolean CRCsArePresent)
+    : MultiFramedRTPSource(env, RTPgs, rtpPayloadFormat, isWideband ? 16000 : 8000, new AMRBufferedPacketFactory),
+      fIsWideband(isWideband),
+      fIsOctetAligned(isOctetAligned),
+      fIsInterleaved(isInterleaved),
+      fCRCsArePresent(CRCsArePresent),
+      fILL(0),
+      fILP(0),
+      fTOCSize(0),
+      fTOC(NULL),
+      fFrameIndex(0),
+      fIsSynchronized(False) {}
+
+RawAMRRTPSource::~RawAMRRTPSource() {
+    delete[] fTOC;
+}
+
+#define FT_SPEECH_LOST 14
+#define FT_NO_DATA 15
+
+static void unpackBandwidthEfficientData(BufferedPacket *packet,
+                                         Boolean         isWideband);  // forward
+
+Boolean RawAMRRTPSource ::processSpecialHeader(BufferedPacket *packet, unsigned &resultSpecialHeaderSize) {
+    // If the data is 'bandwidth-efficient', first unpack it so that it's
+    // 'octet-aligned':
+    if(!fIsOctetAligned)
+        unpackBandwidthEfficientData(packet, fIsWideband);
+
+    unsigned char *headerStart = packet->data();
+    unsigned       packetSize  = packet->dataSize();
+
+    // There's at least a 1-byte header, containing the CMR:
+    if(packetSize < 1)
+        return False;
+    resultSpecialHeaderSize = 1;
+
+    if(fIsInterleaved) {
+        // There's an extra byte, containing the interleave parameters:
+        if(packetSize < 2)
+            return False;
+
+        // Get the interleaving parameters, and check them for validity:
+        unsigned char const secondByte = headerStart[1];
+        fILL                           = (secondByte & 0xF0) >> 4;
+        fILP                           = secondByte & 0x0F;
+        if(fILP > fILL)
+            return False;  // invalid
+        ++resultSpecialHeaderSize;
+    }
+#ifdef DEBUG
+    fprintf(stderr, "packetSize: %d, ILL: %d, ILP: %d\n", packetSize, fILL, fILP);
+#endif
+    fFrameIndex = 0;  // initially
+
+    // Next, there's a "Payload Table of Contents" (one byte per entry):
+    unsigned numFramesPresent = 0, numNonEmptyFramesPresent = 0;
+    unsigned tocStartIndex = resultSpecialHeaderSize;
+    Boolean  F;
+    do {
+        if(resultSpecialHeaderSize >= packetSize)
+            return False;
+        unsigned char const tocByte = headerStart[resultSpecialHeaderSize++];
+        F                           = (tocByte & 0x80) != 0;
+        unsigned char const FT      = (tocByte & 0x78) >> 3;
+#ifdef DEBUG
+        unsigned char Q = (tocByte & 0x04) >> 2;
+        fprintf(stderr, "\tTOC entry: F %d, FT %d, Q %d\n", F, FT, Q);
+#endif
+        ++numFramesPresent;
+        if(FT != FT_SPEECH_LOST && FT != FT_NO_DATA)
+            ++numNonEmptyFramesPresent;
+    } while(F);
+#ifdef DEBUG
+    fprintf(stderr, "TOC contains %d entries (%d non-empty)\n", numFramesPresent, numNonEmptyFramesPresent);
+#endif
+
+    // Now that we know the size of the TOC, fill in our copy:
+    if(numFramesPresent > fTOCSize) {
+        delete[] fTOC;
+        fTOC = new unsigned char[numFramesPresent];
+    }
+    fTOCSize = numFramesPresent;
+    for(unsigned i = 0; i < fTOCSize; ++i) {
+        unsigned char const tocByte = headerStart[tocStartIndex + i];
+        fTOC[i]                     = tocByte & 0x7C;  // clear everything except the F and Q fields
+    }
+
+    if(fCRCsArePresent) {
+        // 'numNonEmptyFramesPresent' CRC bytes will follow.
+        // Note: we currently don't check the CRCs for validity #####
+        resultSpecialHeaderSize += numNonEmptyFramesPresent;
+#ifdef DEBUG
+        fprintf(stderr, "Ignoring %d following CRC bytes\n", numNonEmptyFramesPresent);
+#endif
+        if(resultSpecialHeaderSize > packetSize)
+            return False;
+    }
+#ifdef DEBUG
+    fprintf(stderr, "Total special header size: %d\n", resultSpecialHeaderSize);
+#endif
+
+    return True;
+}
+
+char const *RawAMRRTPSource::MIMEtype() const {
+    return fIsWideband ? "audio/AMR-WB" : "audio/AMR";
+}
+
+Boolean RawAMRRTPSource::hasBeenSynchronizedUsingRTCP() {
+    return fIsSynchronized;
+}
+
+///// AMRBufferedPacket and AMRBufferedPacketFactory implementation
+
+AMRBufferedPacket::AMRBufferedPacket(RawAMRRTPSource &ourSource) : fOurSource(ourSource) {}
+
+AMRBufferedPacket::~AMRBufferedPacket() {}
+
+// The mapping from the "FT" field to frame size.
+// Values of 65535 are invalid.
+#define FT_INVALID 65535
+static unsigned short const frameBytesFromFT[16]         = { 12, 13,         15,         17,         19,         20,         26,         31,
+                                                     5,  FT_INVALID, FT_INVALID, FT_INVALID, FT_INVALID, FT_INVALID, FT_INVALID, 0 };
+static unsigned short const frameBytesFromFTWideband[16] = { 17, 23, 32, 36, 40, 46, 50, 58, 60, 5, FT_INVALID, FT_INVALID, FT_INVALID, FT_INVALID, 0, 0 };
+
+unsigned AMRBufferedPacket::nextEnclosedFrameSize(unsigned char *&framePtr, unsigned dataSize) {
+    if(dataSize == 0)
+        return 0;  // sanity check
+
+    // The size of the AMR frame is determined by the corresponding 'FT' value
+    // in the packet's Table of Contents.
+    unsigned const tocIndex = fOurSource.frameIndex();
+    if(tocIndex >= fOurSource.TOCSize())
+        return 0;  // sanity check
+
+    unsigned char const tocByte = fOurSource.TOC()[tocIndex];
+    unsigned char const FT      = (tocByte & 0x78) >> 3;
+    // ASSERT: FT < 16
+    unsigned short frameSize = fOurSource.isWideband() ? frameBytesFromFTWideband[FT] : frameBytesFromFT[FT];
+    if(frameSize == FT_INVALID) {
+        // Strange TOC entry!
+        fOurSource.envir() << "AMRBufferedPacket::nextEnclosedFrameSize(): invalid FT: " << FT << "\n";
+        frameSize = 0;  // This probably messes up the rest of this packet, but...
+    }
+#ifdef DEBUG
+    fprintf(stderr, "AMRBufferedPacket::nextEnclosedFrameSize(): frame #: %d, FT: %d, isWideband: %d => frameSize: %d (dataSize: %d)\n", tocIndex, FT,
+            fOurSource.isWideband(), frameSize, dataSize);
+#endif
+    ++fOurSource.frameIndex();
+
+    if(dataSize < frameSize)
+        return 0;
+    return frameSize;
+}
+
+BufferedPacket *AMRBufferedPacketFactory ::createNewPacket(MultiFramedRTPSource *ourSource) {
+    return new AMRBufferedPacket((RawAMRRTPSource &)(*ourSource));
+}
+
+///////// AMRDeinterleavingBuffer /////////
+// (used to implement AMRDeinterleaver)
+
+#define AMR_MAX_FRAME_SIZE 60
+
+class AMRDeinterleavingBuffer {
+public:
+    AMRDeinterleavingBuffer(unsigned numChannels, unsigned maxInterleaveGroupSize);
+    virtual ~AMRDeinterleavingBuffer();
+
+    void    deliverIncomingFrame(unsigned frameSize, RawAMRRTPSource *source, struct timeval presentationTime);
+    Boolean retrieveFrame(unsigned char *to, unsigned maxSize, unsigned &resultFrameSize, unsigned &resultNumTruncatedBytes, u_int8_t &resultFrameHeader,
+                          struct timeval &resultPresentationTime, Boolean &resultIsSynchronized);
+
+    unsigned char *inputBuffer() {
+        return fInputBuffer;
+    }
+    unsigned inputBufferSize() const {
+        return AMR_MAX_FRAME_SIZE;
+    }
+
+private:
+    unsigned char *createNewBuffer();
+
+    class FrameDescriptor {
+    public:
+        FrameDescriptor();
+        virtual ~FrameDescriptor();
+
+        unsigned       frameSize;
+        unsigned char *frameData;
+        u_int8_t       frameHeader;
+        struct timeval presentationTime;
+        Boolean        fIsSynchronized;
+    };
+
+    unsigned         fNumChannels, fMaxInterleaveGroupSize;
+    FrameDescriptor *fFrames[2];
+    unsigned char    fIncomingBankId;  // toggles between 0 and 1
+    unsigned char    fIncomingBinMax;  // in the incoming bank
+    unsigned char    fOutgoingBinMax;  // in the outgoing bank
+    unsigned char    fNextOutgoingBin;
+    Boolean          fHaveSeenPackets;
+    u_int16_t        fLastPacketSeqNumForGroup;
+    unsigned char *  fInputBuffer;
+    struct timeval   fLastRetrievedPresentationTime;
+    unsigned         fNumSuccessiveSyncedFrames;
+    unsigned char    fILL;
+};
+
+////////// AMRDeinterleaver implementation /////////
+
+AMRDeinterleaver *AMRDeinterleaver ::createNew(UsageEnvironment &env, Boolean isWideband, unsigned numChannels, unsigned maxInterleaveGroupSize,
+                                               RawAMRRTPSource *inputSource) {
+    return new AMRDeinterleaver(env, isWideband, numChannels, maxInterleaveGroupSize, inputSource);
+}
+
+AMRDeinterleaver::AMRDeinterleaver(UsageEnvironment &env, Boolean isWideband, unsigned numChannels, unsigned maxInterleaveGroupSize,
+                                   RawAMRRTPSource *inputSource)
+    : AMRAudioSource(env, isWideband, numChannels), fInputSource(inputSource), fNeedAFrame(False) {
+    fDeinterleavingBuffer = new AMRDeinterleavingBuffer(numChannels, maxInterleaveGroupSize);
+}
+
+AMRDeinterleaver::~AMRDeinterleaver() {
+    delete fDeinterleavingBuffer;
+    Medium::close(fInputSource);
+}
+
+static unsigned const uSecsPerFrame = 20000;  // 20 ms
+
+void AMRDeinterleaver::doGetNextFrame() {
+    // First, try getting a frame from the deinterleaving buffer:
+    if(fDeinterleavingBuffer->retrieveFrame(fTo, fMaxSize, fFrameSize, fNumTruncatedBytes, fLastFrameHeader, fPresentationTime,
+                                            fInputSource->isSynchronized())) {
+
+        // Success!
+        fNeedAFrame = False;
+
+        fDurationInMicroseconds = uSecsPerFrame;
+
+        // Call our own 'after getting' function.  Because we're not a 'leaf'
+        // source, we can call this directly, without risking
+        // infinite recursion
+        afterGetting(this);
+        return;
+    }
+
+    // No luck, so ask our source for help:
+    fNeedAFrame = True;
+    if(!fInputSource->isCurrentlyAwaitingData()) {
+        fInputSource->getNextFrame(fDeinterleavingBuffer->inputBuffer(), fDeinterleavingBuffer->inputBufferSize(), afterGettingFrame, this,
+                                   FramedSource::handleClosure, this);
+    }
+}
+
+void AMRDeinterleaver::doStopGettingFrames() {
+    fNeedAFrame = False;
+    fInputSource->stopGettingFrames();
+}
+
+void AMRDeinterleaver ::afterGettingFrame(void *clientData, unsigned frameSize, unsigned /*numTruncatedBytes*/, struct timeval presentationTime,
+                                          unsigned /*durationInMicroseconds*/) {
+    AMRDeinterleaver *deinterleaver = (AMRDeinterleaver *)clientData;
+    deinterleaver->afterGettingFrame1(frameSize, presentationTime);
+}
+
+void AMRDeinterleaver ::afterGettingFrame1(unsigned frameSize, struct timeval presentationTime) {
+    RawAMRRTPSource *source = (RawAMRRTPSource *)fInputSource;
+
+    // First, put the frame into our deinterleaving buffer:
+    fDeinterleavingBuffer->deliverIncomingFrame(frameSize, source, presentationTime);
+
+    // Then, try delivering a frame to the client (if he wants one):
+    if(fNeedAFrame)
+        doGetNextFrame();
+}
+
+////////// AMRDeinterleavingBuffer implementation /////////
+
+AMRDeinterleavingBuffer ::AMRDeinterleavingBuffer(unsigned numChannels, unsigned maxInterleaveGroupSize)
+    : fNumChannels(numChannels),
+      fMaxInterleaveGroupSize(maxInterleaveGroupSize),
+      fIncomingBankId(0),
+      fIncomingBinMax(0),
+      fOutgoingBinMax(0),
+      fNextOutgoingBin(0),
+      fHaveSeenPackets(False),
+      fNumSuccessiveSyncedFrames(0),
+      fILL(0) {
+    // Use two banks of descriptors - one for incoming, one for outgoing
+    fFrames[0]   = new FrameDescriptor[fMaxInterleaveGroupSize];
+    fFrames[1]   = new FrameDescriptor[fMaxInterleaveGroupSize];
+    fInputBuffer = createNewBuffer();
+}
+
+AMRDeinterleavingBuffer::~AMRDeinterleavingBuffer() {
+    delete[] fInputBuffer;
+    delete[] fFrames[0];
+    delete[] fFrames[1];
+}
+
+void AMRDeinterleavingBuffer ::deliverIncomingFrame(unsigned frameSize, RawAMRRTPSource *source, struct timeval presentationTime) {
+    fILL                             = source->ILL();
+    unsigned char const ILP          = source->ILP();
+    unsigned            frameIndex   = source->frameIndex();
+    unsigned short      packetSeqNum = source->curPacketRTPSeqNum();
+
+    // First perform a sanity check on the parameters:
+    // (This is overkill, as the source should have already done this.)
+    if(ILP > fILL || frameIndex == 0) {
+#ifdef DEBUG
+        fprintf(stderr, "AMRDeinterleavingBuffer::deliverIncomingFrame() param sanity check failed (%d,%d,%d,%d)\n", frameSize, fILL, ILP, frameIndex);
+#endif
+        source->envir().internalError();
+    }
+
+    --frameIndex;  // because it was incremented by the source when this frame was read
+    u_int8_t frameHeader;
+    if(frameIndex >= source->TOCSize()) {  // sanity check
+        frameHeader = FT_NO_DATA << 3;
+    }
+    else {
+        frameHeader = source->TOC()[frameIndex];
+    }
+
+    unsigned frameBlockIndex       = frameIndex / fNumChannels;
+    unsigned frameWithinFrameBlock = frameIndex % fNumChannels;
+
+    // The input "presentationTime" was that of the first frame-block in this
+    // packet.  Update it for the current frame:
+    unsigned uSecIncrement = frameBlockIndex * (fILL + 1) * uSecsPerFrame;
+    presentationTime.tv_usec += uSecIncrement;
+    presentationTime.tv_sec += presentationTime.tv_usec / 1000000;
+    presentationTime.tv_usec = presentationTime.tv_usec % 1000000;
+
+    // Next, check whether this packet is part of a new interleave group
+    if(!fHaveSeenPackets || seqNumLT(fLastPacketSeqNumForGroup, packetSeqNum + frameBlockIndex)) {
+        // We've moved to a new interleave group
+#ifdef DEBUG
+        fprintf(stderr, "AMRDeinterleavingBuffer::deliverIncomingFrame(): new interleave group\n");
+#endif
+        fHaveSeenPackets          = True;
+        fLastPacketSeqNumForGroup = packetSeqNum + fILL - ILP;
+
+        // Switch the incoming and outgoing banks:
+        fIncomingBankId ^= 1;
+        unsigned char tmp = fIncomingBinMax;
+        fIncomingBinMax   = fOutgoingBinMax;
+        fOutgoingBinMax   = tmp;
+        fNextOutgoingBin  = 0;
+    }
+
+    // Now move the incoming frame into the appropriate bin:
+    unsigned const binNumber = ((ILP + frameBlockIndex * (fILL + 1)) * fNumChannels + frameWithinFrameBlock) % fMaxInterleaveGroupSize;  // the % is for sanity
+#ifdef DEBUG
+    fprintf(stderr,
+            "AMRDeinterleavingBuffer::deliverIncomingFrame(): frameIndex %d (%d,%d) put in bank %d, bin %d (%d): size %d, header 0x%02x, presentationTime "
+            "%lu.%06ld\n",
+            frameIndex, frameBlockIndex, frameWithinFrameBlock, fIncomingBankId, binNumber, fMaxInterleaveGroupSize, frameSize, frameHeader,
+            presentationTime.tv_sec, presentationTime.tv_usec);
+#endif
+    FrameDescriptor &inBin     = fFrames[fIncomingBankId][binNumber];
+    unsigned char *  curBuffer = inBin.frameData;
+    inBin.frameData            = fInputBuffer;
+    inBin.frameSize            = frameSize;
+    inBin.frameHeader          = frameHeader;
+    inBin.presentationTime     = presentationTime;
+    inBin.fIsSynchronized      = ((RTPSource *)source)->RTPSource::hasBeenSynchronizedUsingRTCP();
+
+    if(curBuffer == NULL)
+        curBuffer = createNewBuffer();
+    fInputBuffer = curBuffer;
+
+    if(binNumber >= fIncomingBinMax) {
+        fIncomingBinMax = binNumber + 1;
+    }
+}
+
+Boolean AMRDeinterleavingBuffer ::retrieveFrame(unsigned char *to, unsigned maxSize, unsigned &resultFrameSize, unsigned &resultNumTruncatedBytes,
+                                                u_int8_t &resultFrameHeader, struct timeval &resultPresentationTime, Boolean &resultIsSynchronized) {
+
+    if(fNextOutgoingBin >= fOutgoingBinMax)
+        return False;  // none left
+
+    FrameDescriptor &outBin   = fFrames[fIncomingBankId ^ 1][fNextOutgoingBin];
+    unsigned char *  fromPtr  = outBin.frameData;
+    unsigned char    fromSize = outBin.frameSize;
+    outBin.frameSize          = 0;      // for the next time this bin is used
+    resultIsSynchronized      = False;  // by default; can be changed by:
+    if(outBin.fIsSynchronized) {
+        // Don't consider the outgoing frame to be synchronized until we've received at least a complete interleave cycle of
+        // synchronized frames.  This ensures that the receiver will be getting all synchronized frames from now on.
+        if(++fNumSuccessiveSyncedFrames > fILL) {
+            resultIsSynchronized       = True;
+            fNumSuccessiveSyncedFrames = fILL + 1;  // prevents overflow
+        }
+    }
+    else {
+        fNumSuccessiveSyncedFrames = 0;
+    }
+
+    // Check whether this frame is missing; if so, return a FT_NO_DATA frame:
+    if(fromSize == 0) {
+        resultFrameHeader = FT_NO_DATA << 3;
+
+        // Compute this erasure frame's presentation time via extrapolation:
+        resultPresentationTime = fLastRetrievedPresentationTime;
+        resultPresentationTime.tv_usec += uSecsPerFrame;
+        if(resultPresentationTime.tv_usec >= 1000000) {
+            ++resultPresentationTime.tv_sec;
+            resultPresentationTime.tv_usec -= 1000000;
+        }
+    }
+    else {
+        // Normal case - a frame exists:
+        resultFrameHeader      = outBin.frameHeader;
+        resultPresentationTime = outBin.presentationTime;
+    }
+
+    fLastRetrievedPresentationTime = resultPresentationTime;
+
+    if(fromSize > maxSize) {
+        resultNumTruncatedBytes = fromSize - maxSize;
+        resultFrameSize         = maxSize;
+    }
+    else {
+        resultNumTruncatedBytes = 0;
+        resultFrameSize         = fromSize;
+    }
+    memmove(to, fromPtr, resultFrameSize);
+#ifdef DEBUG
+    fprintf(stderr, "AMRDeinterleavingBuffer::retrieveFrame(): from bank %d, bin %d: size %d, header 0x%02x, presentationTime %lu.%06ld\n", fIncomingBankId ^ 1,
+            fNextOutgoingBin, resultFrameSize, resultFrameHeader, resultPresentationTime.tv_sec, resultPresentationTime.tv_usec);
+#endif
+
+    ++fNextOutgoingBin;
+    return True;
+}
+
+unsigned char *AMRDeinterleavingBuffer::createNewBuffer() {
+    return new unsigned char[inputBufferSize()];
+}
+
+AMRDeinterleavingBuffer::FrameDescriptor::FrameDescriptor() : frameSize(0), frameData(NULL) {}
+
+AMRDeinterleavingBuffer::FrameDescriptor::~FrameDescriptor() {
+    delete[] frameData;
+}
+
+// Unpack bandwidth-aligned data to octet-aligned:
+static unsigned short const frameBitsFromFT[16]         = { 95, 103, 118, 134, 148, 159, 204, 244, 39, 0, 0, 0, 0, 0, 0, 0 };
+static unsigned short const frameBitsFromFTWideband[16] = { 132, 177, 253, 285, 317, 365, 397, 461, 477, 40, 0, 0, 0, 0, 0, 0 };
+
+static void unpackBandwidthEfficientData(BufferedPacket *packet, Boolean isWideband) {
+#ifdef DEBUG
+    fprintf(stderr, "Unpacking 'bandwidth-efficient' payload (%d bytes):\n", packet->dataSize());
+    for(unsigned j = 0; j < packet->dataSize(); ++j) {
+        fprintf(stderr, "%02x:", (packet->data())[j]);
+    }
+    fprintf(stderr, "\n");
+#endif
+    BitVector fromBV(packet->data(), 0, 8 * packet->dataSize());
+
+    unsigned const toBufferSize = 2 * packet->dataSize();  // conservatively large
+    unsigned char *toBuffer     = new unsigned char[toBufferSize];
+    unsigned       toCount      = 0;
+
+    // Begin with the payload header:
+    unsigned CMR        = fromBV.getBits(4);
+    toBuffer[toCount++] = CMR << 4;
+
+    // Then, run through and unpack the TOC entries:
+    while(1) {
+        unsigned toc        = fromBV.getBits(6);
+        toBuffer[toCount++] = toc << 2;
+
+        if((toc & 0x20) == 0)
+            break;  // the F bit is 0
+    }
+
+    // Then, using the TOC data, unpack each frame payload:
+    unsigned const tocSize = toCount - 1;
+    for(unsigned i = 1; i <= tocSize; ++i) {
+        unsigned char       tocByte        = toBuffer[i];
+        unsigned char const FT             = (tocByte & 0x78) >> 3;
+        unsigned short      frameSizeBits  = isWideband ? frameBitsFromFTWideband[FT] : frameBitsFromFT[FT];
+        unsigned short      frameSizeBytes = (frameSizeBits + 7) / 8;
+
+        if(frameSizeBits > fromBV.numBitsRemaining()) {
+#ifdef DEBUG
+            fprintf(stderr, "\tWarning: Unpacking frame %d of %d: want %d bits, but only %d are available!\n", i, tocSize, frameSizeBits,
+                    fromBV.numBitsRemaining());
+#endif
+            break;
+        }
+
+        shiftBits(&toBuffer[toCount], 0,                 // to
+                  packet->data(), fromBV.curBitIndex(),  // from
+                  frameSizeBits                          // num bits
+        );
+        fromBV.skipBits(frameSizeBits);
+        toCount += frameSizeBytes;
+    }
+
+#ifdef DEBUG
+    if(fromBV.numBitsRemaining() > 7) {
+        fprintf(stderr, "\tWarning: %d bits remain unused!\n", fromBV.numBitsRemaining());
+    }
+#endif
+
+    // Finally, replace the current packet data with the unpacked data:
+    packet->removePadding(packet->dataSize());  // throws away current packet data
+    packet->appendData(toBuffer, toCount);
+    delete[] toBuffer;
+}
diff --git a/3rdparty/live555/src/liveMedia/AMRAudioSource.cpp b/3rdparty/live555/src/liveMedia/AMRAudioSource.cpp
new file mode 100644
index 00000000..e5d83424
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/AMRAudioSource.cpp
@@ -0,0 +1,34 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A source object for AMR audio sources
+// Implementation
+
+#include "AMRAudioSource.hh"
+
+AMRAudioSource::AMRAudioSource(UsageEnvironment &env, Boolean isWideband, unsigned numChannels)
+    : FramedSource(env), fIsWideband(isWideband), fNumChannels(numChannels), fLastFrameHeader(0) {}
+
+AMRAudioSource::~AMRAudioSource() {}
+
+char const *AMRAudioSource::MIMEtype() const {
+    return "audio/AMR";
+}
+
+Boolean AMRAudioSource::isAMRAudioSource() const {
+    return True;
+}
diff --git a/3rdparty/live555/src/liveMedia/AVIFileSink.cpp b/3rdparty/live555/src/liveMedia/AVIFileSink.cpp
new file mode 100644
index 00000000..ab9cf619
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/AVIFileSink.cpp
@@ -0,0 +1,821 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A sink that generates an AVI file from a composite media session
+// Implementation
+
+#include "AVIFileSink.hh"
+#include "InputFile.hh"
+#include "OutputFile.hh"
+#include "GroupsockHelper.hh"
+
+#define fourChar(x, y, z, w) (((w) << 24) | ((z) << 16) | ((y) << 8) | (x)) /*little-endian*/
+
+#define AVIIF_LIST 0x00000001
+#define AVIIF_KEYFRAME 0x00000010
+#define AVIIF_NO_TIME 0x00000100
+#define AVIIF_COMPRESSOR 0x0FFF0000
+
+////////// AVISubsessionIOState ///////////
+// A structure used to represent the I/O state of each input 'subsession':
+
+class SubsessionBuffer {
+public:
+    SubsessionBuffer(unsigned bufferSize) : fBufferSize(bufferSize) {
+        reset();
+        fData = new unsigned char[bufferSize];
+    }
+    virtual ~SubsessionBuffer() {
+        delete[] fData;
+    }
+    void reset() {
+        fBytesInUse = 0;
+    }
+    void addBytes(unsigned numBytes) {
+        fBytesInUse += numBytes;
+    }
+
+    unsigned char *dataStart() {
+        return &fData[0];
+    }
+    unsigned char *dataEnd() {
+        return &fData[fBytesInUse];
+    }
+    unsigned bytesInUse() const {
+        return fBytesInUse;
+    }
+    unsigned bytesAvailable() const {
+        return fBufferSize - fBytesInUse;
+    }
+
+    void setPresentationTime(struct timeval const &presentationTime) {
+        fPresentationTime = presentationTime;
+    }
+    struct timeval const &presentationTime() const {
+        return fPresentationTime;
+    }
+
+private:
+    unsigned       fBufferSize;
+    struct timeval fPresentationTime;
+    unsigned char *fData;
+    unsigned       fBytesInUse;
+};
+
+class AVISubsessionIOState {
+public:
+    AVISubsessionIOState(AVIFileSink &sink, MediaSubsession &subsession);
+    virtual ~AVISubsessionIOState();
+
+    void setAVIstate(unsigned subsessionIndex);
+    void setFinalAVIstate();
+
+    void afterGettingFrame(unsigned packetDataSize, struct timeval presentationTime);
+    void onSourceClosure();
+
+    UsageEnvironment &envir() const {
+        return fOurSink.envir();
+    }
+
+public:
+    SubsessionBuffer *fBuffer, *fPrevBuffer;
+    AVIFileSink &     fOurSink;
+    MediaSubsession & fOurSubsession;
+
+    unsigned short fLastPacketRTPSeqNum;
+    Boolean        fOurSourceIsActive;
+    struct timeval fPrevPresentationTime;
+    unsigned       fMaxBytesPerSecond;
+    Boolean        fIsVideo, fIsAudio, fIsByteSwappedAudio;
+    unsigned       fAVISubsessionTag;
+    unsigned       fAVICodecHandlerType;
+    unsigned       fAVISamplingFrequency;  // for audio
+    u_int16_t      fWAVCodecTag;           // for audio
+    unsigned       fAVIScale;
+    unsigned       fAVIRate;
+    unsigned       fAVISize;
+    unsigned       fNumFrames;
+    unsigned       fSTRHFrameCountPosition;
+
+private:
+    void useFrame(SubsessionBuffer &buffer);
+};
+
+///////// AVIIndexRecord definition & implementation //////////
+
+class AVIIndexRecord {
+public:
+    AVIIndexRecord(unsigned chunkId, unsigned flags, unsigned offset, unsigned size)
+        : fNext(NULL), fChunkId(chunkId), fFlags(flags), fOffset(offset), fSize(size) {}
+
+    AVIIndexRecord *&next() {
+        return fNext;
+    }
+    unsigned chunkId() const {
+        return fChunkId;
+    }
+    unsigned flags() const {
+        return fFlags;
+    }
+    unsigned offset() const {
+        return fOffset;
+    }
+    unsigned size() const {
+        return fSize;
+    }
+
+private:
+    AVIIndexRecord *fNext;
+    unsigned        fChunkId;
+    unsigned        fFlags;
+    unsigned        fOffset;
+    unsigned        fSize;
+};
+
+////////// AVIFileSink implementation //////////
+
+AVIFileSink::AVIFileSink(UsageEnvironment &env, MediaSession &inputSession, char const *outputFileName, unsigned bufferSize, unsigned short movieWidth,
+                         unsigned short movieHeight, unsigned movieFPS, Boolean packetLossCompensate)
+    : Medium(env),
+      fInputSession(inputSession),
+      fIndexRecordsHead(NULL),
+      fIndexRecordsTail(NULL),
+      fNumIndexRecords(0),
+      fBufferSize(bufferSize),
+      fPacketLossCompensate(packetLossCompensate),
+      fAreCurrentlyBeingPlayed(False),
+      fNumSubsessions(0),
+      fNumBytesWritten(0),
+      fHaveCompletedOutputFile(False),
+      fMovieWidth(movieWidth),
+      fMovieHeight(movieHeight),
+      fMovieFPS(movieFPS) {
+    fOutFid = OpenOutputFile(env, outputFileName);
+    if(fOutFid == NULL)
+        return;
+
+    // Set up I/O state for each input subsession:
+    MediaSubsessionIterator iter(fInputSession);
+    MediaSubsession *       subsession;
+    while((subsession = iter.next()) != NULL) {
+        // Ignore subsessions without a data source:
+        FramedSource *subsessionSource = subsession->readSource();
+        if(subsessionSource == NULL)
+            continue;
+
+        // If "subsession's" SDP description specified screen dimension
+        // or frame rate parameters, then use these.
+        if(subsession->videoWidth() != 0) {
+            fMovieWidth = subsession->videoWidth();
+        }
+        if(subsession->videoHeight() != 0) {
+            fMovieHeight = subsession->videoHeight();
+        }
+        if(subsession->videoFPS() != 0) {
+            fMovieFPS = subsession->videoFPS();
+        }
+
+        AVISubsessionIOState *ioState = new AVISubsessionIOState(*this, *subsession);
+        subsession->miscPtr           = (void *)ioState;
+
+        // Also set a 'BYE' handler for this subsession's RTCP instance:
+        if(subsession->rtcpInstance() != NULL) {
+            subsession->rtcpInstance()->setByeHandler(onRTCPBye, ioState);
+        }
+
+        ++fNumSubsessions;
+    }
+
+    // Begin by writing an AVI header:
+    addFileHeader_AVI();
+}
+
+AVIFileSink::~AVIFileSink() {
+    completeOutputFile();
+
+    // Then, stop streaming and delete each active "AVISubsessionIOState":
+    MediaSubsessionIterator iter(fInputSession);
+    MediaSubsession *       subsession;
+    while((subsession = iter.next()) != NULL) {
+        if(subsession->readSource() != NULL)
+            subsession->readSource()->stopGettingFrames();
+
+        AVISubsessionIOState *ioState = (AVISubsessionIOState *)(subsession->miscPtr);
+        if(ioState == NULL)
+            continue;
+
+        delete ioState;
+    }
+
+    // Then, delete the index records:
+    AVIIndexRecord *cur = fIndexRecordsHead;
+    while(cur != NULL) {
+        AVIIndexRecord *next = cur->next();
+        delete cur;
+        cur = next;
+    }
+
+    // Finally, close our output file:
+    CloseOutputFile(fOutFid);
+}
+
+AVIFileSink *AVIFileSink ::createNew(UsageEnvironment &env, MediaSession &inputSession, char const *outputFileName, unsigned bufferSize,
+                                     unsigned short movieWidth, unsigned short movieHeight, unsigned movieFPS, Boolean packetLossCompensate) {
+    AVIFileSink *newSink = new AVIFileSink(env, inputSession, outputFileName, bufferSize, movieWidth, movieHeight, movieFPS, packetLossCompensate);
+    if(newSink == NULL || newSink->fOutFid == NULL) {
+        Medium::close(newSink);
+        return NULL;
+    }
+
+    return newSink;
+}
+
+Boolean AVIFileSink::startPlaying(afterPlayingFunc *afterFunc, void *afterClientData) {
+    // Make sure we're not already being played:
+    if(fAreCurrentlyBeingPlayed) {
+        envir().setResultMsg("This sink has already been played");
+        return False;
+    }
+
+    fAreCurrentlyBeingPlayed = True;
+    fAfterFunc               = afterFunc;
+    fAfterClientData         = afterClientData;
+
+    return continuePlaying();
+}
+
+Boolean AVIFileSink::continuePlaying() {
+    // Run through each of our input session's 'subsessions',
+    // asking for a frame from each one:
+    Boolean                 haveActiveSubsessions = False;
+    MediaSubsessionIterator iter(fInputSession);
+    MediaSubsession *       subsession;
+    while((subsession = iter.next()) != NULL) {
+        FramedSource *subsessionSource = subsession->readSource();
+        if(subsessionSource == NULL)
+            continue;
+
+        if(subsessionSource->isCurrentlyAwaitingData())
+            continue;
+
+        AVISubsessionIOState *ioState = (AVISubsessionIOState *)(subsession->miscPtr);
+        if(ioState == NULL)
+            continue;
+
+        haveActiveSubsessions = True;
+        unsigned char *toPtr  = ioState->fBuffer->dataEnd();
+        unsigned       toSize = ioState->fBuffer->bytesAvailable();
+        subsessionSource->getNextFrame(toPtr, toSize, afterGettingFrame, ioState, onSourceClosure, ioState);
+    }
+    if(!haveActiveSubsessions) {
+        envir().setResultMsg("No subsessions are currently active");
+        return False;
+    }
+
+    return True;
+}
+
+void AVIFileSink ::afterGettingFrame(void *clientData, unsigned packetDataSize, unsigned numTruncatedBytes, struct timeval presentationTime,
+                                     unsigned /*durationInMicroseconds*/) {
+    AVISubsessionIOState *ioState = (AVISubsessionIOState *)clientData;
+    if(numTruncatedBytes > 0) {
+        ioState->envir() << "AVIFileSink::afterGettingFrame(): The input frame data was too large for our buffer.  " << numTruncatedBytes
+                         << " bytes of trailing data was dropped!  Correct this by increasing the \"bufferSize\" parameter in the \"createNew()\" call.\n";
+    }
+    ioState->afterGettingFrame(packetDataSize, presentationTime);
+}
+
+void AVIFileSink::onSourceClosure(void *clientData) {
+    AVISubsessionIOState *ioState = (AVISubsessionIOState *)clientData;
+    ioState->onSourceClosure();
+}
+
+void AVIFileSink::onSourceClosure1() {
+    // Check whether *all* of the subsession sources have closed.
+    // If not, do nothing for now:
+    MediaSubsessionIterator iter(fInputSession);
+    MediaSubsession *       subsession;
+    while((subsession = iter.next()) != NULL) {
+        AVISubsessionIOState *ioState = (AVISubsessionIOState *)(subsession->miscPtr);
+        if(ioState == NULL)
+            continue;
+
+        if(ioState->fOurSourceIsActive)
+            return;  // this source hasn't closed
+    }
+
+    completeOutputFile();
+
+    // Call our specified 'after' function:
+    if(fAfterFunc != NULL) {
+        (*fAfterFunc)(fAfterClientData);
+    }
+}
+
+void AVIFileSink::onRTCPBye(void *clientData) {
+    AVISubsessionIOState *ioState = (AVISubsessionIOState *)clientData;
+
+    struct timeval timeNow;
+    gettimeofday(&timeNow, NULL);
+    unsigned secsDiff = timeNow.tv_sec - ioState->fOurSink.fStartTime.tv_sec;
+
+    MediaSubsession &subsession = ioState->fOurSubsession;
+    ioState->envir() << "Received RTCP \"BYE\" on \"" << subsession.mediumName() << "/" << subsession.codecName() << "\" subsession (after " << secsDiff
+                     << " seconds)\n";
+
+    // Handle the reception of a RTCP "BYE" as if the source had closed:
+    ioState->onSourceClosure();
+}
+
+void AVIFileSink::addIndexRecord(AVIIndexRecord *newIndexRecord) {
+    if(fIndexRecordsHead == NULL) {
+        fIndexRecordsHead = newIndexRecord;
+    }
+    else {
+        fIndexRecordsTail->next() = newIndexRecord;
+    }
+    fIndexRecordsTail = newIndexRecord;
+    ++fNumIndexRecords;
+}
+
+void AVIFileSink::completeOutputFile() {
+    if(fHaveCompletedOutputFile || fOutFid == NULL)
+        return;
+
+    // Update various AVI 'size' fields to take account of the codec data that
+    // we've now written to the file:
+    unsigned maxBytesPerSecond = 0;
+    unsigned numVideoFrames    = 0;
+    unsigned numAudioFrames    = 0;
+
+    //// Subsession-specific fields:
+    MediaSubsessionIterator iter(fInputSession);
+    MediaSubsession *       subsession;
+    while((subsession = iter.next()) != NULL) {
+        AVISubsessionIOState *ioState = (AVISubsessionIOState *)(subsession->miscPtr);
+        if(ioState == NULL)
+            continue;
+
+        maxBytesPerSecond += ioState->fMaxBytesPerSecond;
+
+        setWord(ioState->fSTRHFrameCountPosition, ioState->fNumFrames);
+        if(ioState->fIsVideo)
+            numVideoFrames = ioState->fNumFrames;
+        else if(ioState->fIsAudio)
+            numAudioFrames = ioState->fNumFrames;
+    }
+
+    //// Global fields:
+    add4ByteString("idx1");
+    addWord(fNumIndexRecords * 4 * 4);  // the size of all of the index records, which come next:
+    for(AVIIndexRecord *indexRecord = fIndexRecordsHead; indexRecord != NULL; indexRecord = indexRecord->next()) {
+        addWord(indexRecord->chunkId());
+        addWord(indexRecord->flags());
+        addWord(indexRecord->offset());
+        addWord(indexRecord->size());
+    }
+
+    fRIFFSizeValue += fNumBytesWritten + fNumIndexRecords * 4 * 4 - 4;
+    setWord(fRIFFSizePosition, fRIFFSizeValue);
+
+    setWord(fAVIHMaxBytesPerSecondPosition, maxBytesPerSecond);
+    setWord(fAVIHFrameCountPosition, numVideoFrames > 0 ? numVideoFrames : numAudioFrames);
+
+    fMoviSizeValue += fNumBytesWritten;
+    setWord(fMoviSizePosition, fMoviSizeValue);
+
+    // We're done:
+    fHaveCompletedOutputFile = True;
+}
+
+////////// AVISubsessionIOState implementation ///////////
+
+AVISubsessionIOState::AVISubsessionIOState(AVIFileSink &sink, MediaSubsession &subsession)
+    : fOurSink(sink), fOurSubsession(subsession), fMaxBytesPerSecond(0), fIsVideo(False), fIsAudio(False), fIsByteSwappedAudio(False), fNumFrames(0) {
+    fBuffer     = new SubsessionBuffer(fOurSink.fBufferSize);
+    fPrevBuffer = sink.fPacketLossCompensate ? new SubsessionBuffer(fOurSink.fBufferSize) : NULL;
+
+    FramedSource *subsessionSource = subsession.readSource();
+    fOurSourceIsActive             = subsessionSource != NULL;
+
+    fPrevPresentationTime.tv_sec  = 0;
+    fPrevPresentationTime.tv_usec = 0;
+}
+
+AVISubsessionIOState::~AVISubsessionIOState() {
+    delete fBuffer;
+    delete fPrevBuffer;
+}
+
+void AVISubsessionIOState::setAVIstate(unsigned subsessionIndex) {
+    fIsVideo = strcmp(fOurSubsession.mediumName(), "video") == 0;
+    fIsAudio = strcmp(fOurSubsession.mediumName(), "audio") == 0;
+
+    if(fIsVideo) {
+        fAVISubsessionTag = fourChar('0' + subsessionIndex / 10, '0' + subsessionIndex % 10, 'd', 'c');
+        if(strcmp(fOurSubsession.codecName(), "JPEG") == 0) {
+            fAVICodecHandlerType = fourChar('m', 'j', 'p', 'g');
+        }
+        else if(strcmp(fOurSubsession.codecName(), "MP4V-ES") == 0) {
+            fAVICodecHandlerType = fourChar('D', 'I', 'V', 'X');
+        }
+        else if(strcmp(fOurSubsession.codecName(), "MPV") == 0) {
+            fAVICodecHandlerType = fourChar('m', 'p', 'g', '1');  // what about MPEG-2?
+        }
+        else if(strcmp(fOurSubsession.codecName(), "H263-1998") == 0 || strcmp(fOurSubsession.codecName(), "H263-2000") == 0) {
+            fAVICodecHandlerType = fourChar('H', '2', '6', '3');
+        }
+        else if(strcmp(fOurSubsession.codecName(), "H264") == 0) {
+            fAVICodecHandlerType = fourChar('H', '2', '6', '4');
+        }
+        else {
+            fAVICodecHandlerType = fourChar('?', '?', '?', '?');
+        }
+        fAVIScale = 1;                                                 // ??? #####
+        fAVIRate  = fOurSink.fMovieFPS;                                // ??? #####
+        fAVISize  = fOurSink.fMovieWidth * fOurSink.fMovieHeight * 3;  // ??? #####
+    }
+    else if(fIsAudio) {
+        fIsByteSwappedAudio   = False;  // by default
+        fAVISubsessionTag     = fourChar('0' + subsessionIndex / 10, '0' + subsessionIndex % 10, 'w', 'b');
+        fAVICodecHandlerType  = 1;  // ??? ####
+        unsigned numChannels  = fOurSubsession.numChannels();
+        fAVISamplingFrequency = fOurSubsession.rtpTimestampFrequency();  // default
+        if(strcmp(fOurSubsession.codecName(), "L16") == 0) {
+            fIsByteSwappedAudio = True;  // need to byte-swap data before writing it
+            fWAVCodecTag        = 0x0001;
+            fAVIScale = fAVISize = 2 * numChannels;  // 2 bytes/sample
+            fAVIRate             = fAVISize * fAVISamplingFrequency;
+        }
+        else if(strcmp(fOurSubsession.codecName(), "L8") == 0) {
+            fWAVCodecTag = 0x0001;
+            fAVIScale = fAVISize = numChannels;  // 1 byte/sample
+            fAVIRate             = fAVISize * fAVISamplingFrequency;
+        }
+        else if(strcmp(fOurSubsession.codecName(), "PCMA") == 0) {
+            fWAVCodecTag = 0x0006;
+            fAVIScale = fAVISize = numChannels;  // 1 byte/sample
+            fAVIRate             = fAVISize * fAVISamplingFrequency;
+        }
+        else if(strcmp(fOurSubsession.codecName(), "PCMU") == 0) {
+            fWAVCodecTag = 0x0007;
+            fAVIScale = fAVISize = numChannels;  // 1 byte/sample
+            fAVIRate             = fAVISize * fAVISamplingFrequency;
+        }
+        else if(strcmp(fOurSubsession.codecName(), "MPA") == 0) {
+            fWAVCodecTag = 0x0050;
+            fAVIScale = fAVISize = 1;
+            fAVIRate             = 0;  // ??? #####
+        }
+        else {
+            fWAVCodecTag = 0x0001;  // ??? #####
+            fAVIScale = fAVISize = 1;
+            fAVIRate             = 0;  // ??? #####
+        }
+    }
+    else {  // unknown medium
+        fAVISubsessionTag    = fourChar('0' + subsessionIndex / 10, '0' + subsessionIndex % 10, '?', '?');
+        fAVICodecHandlerType = 0;
+        fAVIScale = fAVISize = 1;
+        fAVIRate             = 0;  // ??? #####
+    }
+}
+
+void AVISubsessionIOState::afterGettingFrame(unsigned packetDataSize, struct timeval presentationTime) {
+    // Begin by checking whether there was a gap in the RTP stream.
+    // If so, try to compensate for this (if desired):
+    unsigned short rtpSeqNum = fOurSubsession.rtpSource()->curPacketRTPSeqNum();
+    if(fOurSink.fPacketLossCompensate && fPrevBuffer->bytesInUse() > 0) {
+        short seqNumGap = rtpSeqNum - fLastPacketRTPSeqNum;
+        for(short i = 1; i < seqNumGap; ++i) {
+            // Insert a copy of the previous frame, to compensate for the loss:
+            useFrame(*fPrevBuffer);
+        }
+    }
+    fLastPacketRTPSeqNum = rtpSeqNum;
+
+    // Now, continue working with the frame that we just got
+    if(fBuffer->bytesInUse() == 0) {
+        fBuffer->setPresentationTime(presentationTime);
+    }
+    fBuffer->addBytes(packetDataSize);
+
+    useFrame(*fBuffer);
+    if(fOurSink.fPacketLossCompensate) {
+        // Save this frame, in case we need it for recovery:
+        SubsessionBuffer *tmp = fPrevBuffer;  // assert: != NULL
+        fPrevBuffer           = fBuffer;
+        fBuffer               = tmp;
+    }
+    fBuffer->reset();  // for the next input
+
+    // Now, try getting more frames:
+    fOurSink.continuePlaying();
+}
+
+void AVISubsessionIOState::useFrame(SubsessionBuffer &buffer) {
+    unsigned char *const  frameSource      = buffer.dataStart();
+    unsigned const        frameSize        = buffer.bytesInUse();
+    struct timeval const &presentationTime = buffer.presentationTime();
+    if(fPrevPresentationTime.tv_usec != 0 || fPrevPresentationTime.tv_sec != 0) {
+        int uSecondsDiff = (presentationTime.tv_sec - fPrevPresentationTime.tv_sec) * 1000000 + (presentationTime.tv_usec - fPrevPresentationTime.tv_usec);
+        if(uSecondsDiff > 0) {
+            unsigned bytesPerSecond = (unsigned)((frameSize * 1000000.0) / uSecondsDiff);
+            if(bytesPerSecond > fMaxBytesPerSecond) {
+                fMaxBytesPerSecond = bytesPerSecond;
+            }
+        }
+    }
+    fPrevPresentationTime = presentationTime;
+
+    if(fIsByteSwappedAudio) {
+        // We need to swap the 16-bit audio samples from big-endian
+        // to little-endian order, before writing them to a file:
+        for(unsigned i = 0; i < frameSize; i += 2) {
+            unsigned char tmp  = frameSource[i];
+            frameSource[i]     = frameSource[i + 1];
+            frameSource[i + 1] = tmp;
+        }
+    }
+
+    // Add an index record for this frame:
+    AVIIndexRecord *newIndexRecord = new AVIIndexRecord(fAVISubsessionTag,              // chunk id
+                                                        AVIIF_KEYFRAME,                 // flags
+                                                        4 + fOurSink.fNumBytesWritten,  // offset (note: 4 == 'movi')
+                                                        frameSize);                     // size
+    fOurSink.addIndexRecord(newIndexRecord);
+
+    // Write the data into the file:
+    fOurSink.fNumBytesWritten += fOurSink.addWord(fAVISubsessionTag);
+    if(strcmp(fOurSubsession.codecName(), "H264") == 0) {
+        // Insert a 'start code' (0x00 0x00 0x00 0x01) in front of the frame:
+        fOurSink.fNumBytesWritten += fOurSink.addWord(4 + frameSize);
+        fOurSink.fNumBytesWritten += fOurSink.addWord(fourChar(0x00, 0x00, 0x00, 0x01));  // add start code
+    }
+    else {
+        fOurSink.fNumBytesWritten += fOurSink.addWord(frameSize);
+    }
+    fwrite(frameSource, 1, frameSize, fOurSink.fOutFid);
+    fOurSink.fNumBytesWritten += frameSize;
+    // Pad to an even length:
+    if(frameSize % 2 != 0)
+        fOurSink.fNumBytesWritten += fOurSink.addByte(0);
+
+    ++fNumFrames;
+}
+
+void AVISubsessionIOState::onSourceClosure() {
+    fOurSourceIsActive = False;
+    fOurSink.onSourceClosure1();
+}
+
+////////// AVI-specific implementation //////////
+
+unsigned AVIFileSink::addWord(unsigned word) {
+    // Add "word" to the file in little-endian order:
+    addByte(word);
+    addByte(word >> 8);
+    addByte(word >> 16);
+    addByte(word >> 24);
+
+    return 4;
+}
+
+unsigned AVIFileSink::addHalfWord(unsigned short halfWord) {
+    // Add "halfWord" to the file in little-endian order:
+    addByte((unsigned char)halfWord);
+    addByte((unsigned char)(halfWord >> 8));
+
+    return 2;
+}
+
+unsigned AVIFileSink::addZeroWords(unsigned numWords) {
+    for(unsigned i = 0; i < numWords; ++i) {
+        addWord(0);
+    }
+
+    return numWords * 4;
+}
+
+unsigned AVIFileSink::add4ByteString(char const *str) {
+    addByte(str[0]);
+    addByte(str[1]);
+    addByte(str[2]);
+    addByte(str[3] == '\0' ? ' ' : str[3]);  // e.g., for "AVI "
+
+    return 4;
+}
+
+void AVIFileSink::setWord(unsigned filePosn, unsigned size) {
+    do {
+        if(SeekFile64(fOutFid, filePosn, SEEK_SET) < 0)
+            break;
+        addWord(size);
+        if(SeekFile64(fOutFid, 0, SEEK_END) < 0)
+            break;  // go back to where we were
+
+        return;
+    } while(0);
+
+    // One of the SeekFile64()s failed, probable because we're not a seekable file
+    envir() << "AVIFileSink::setWord(): SeekFile64 failed (err " << envir().getErrno() << ")\n";
+}
+
+// Methods for writing particular file headers.  Note the following macros:
+
+#define addFileHeader(tag, name)                                               \
+    unsigned AVIFileSink::addFileHeader_##name() {                             \
+        add4ByteString("" #tag "");                                            \
+        unsigned headerSizePosn = (unsigned)TellFile64(fOutFid);               \
+        addWord(0);                                                            \
+        add4ByteString("" #name "");                                           \
+        unsigned ignoredSize = 8; /*don't include size of tag or size fields*/ \
+        unsigned size        = 12
+
+#define addFileHeader1(name)                                                    \
+    unsigned AVIFileSink::addFileHeader_##name() {                              \
+        add4ByteString("" #name "");                                            \
+        unsigned headerSizePosn = (unsigned)TellFile64(fOutFid);                \
+        addWord(0);                                                             \
+        unsigned ignoredSize = 8; /*don't include size of name or size fields*/ \
+        unsigned size        = 8
+
+#define addFileHeaderEnd                         \
+    setWord(headerSizePosn, size - ignoredSize); \
+    return size;                                 \
+    }
+
+addFileHeader(RIFF, AVI);
+size += addFileHeader_hdrl();
+size += addFileHeader_movi();
+fRIFFSizePosition = headerSizePosn;
+fRIFFSizeValue    = size - ignoredSize;
+addFileHeaderEnd;
+
+addFileHeader(LIST, hdrl);
+size += addFileHeader_avih();
+
+// Then, add a "strl" header for each subsession (stream):
+// (Make the video subsession (if any) come before the audio subsession.)
+unsigned                subsessionCount = 0;
+MediaSubsessionIterator iter(fInputSession);
+MediaSubsession *       subsession;
+while((subsession = iter.next()) != NULL) {
+    fCurrentIOState = (AVISubsessionIOState *)(subsession->miscPtr);
+    if(fCurrentIOState == NULL)
+        continue;
+    if(strcmp(subsession->mediumName(), "video") != 0)
+        continue;
+
+    fCurrentIOState->setAVIstate(subsessionCount++);
+    size += addFileHeader_strl();
+}
+iter.reset();
+while((subsession = iter.next()) != NULL) {
+    fCurrentIOState = (AVISubsessionIOState *)(subsession->miscPtr);
+    if(fCurrentIOState == NULL)
+        continue;
+    if(strcmp(subsession->mediumName(), "video") == 0)
+        continue;
+
+    fCurrentIOState->setAVIstate(subsessionCount++);
+    size += addFileHeader_strl();
+}
+
+// Then add another JUNK entry
+++fJunkNumber;
+size += addFileHeader_JUNK();
+addFileHeaderEnd;
+
+#define AVIF_HASINDEX 0x00000010  // Index at end of file?
+#define AVIF_MUSTUSEINDEX 0x00000020
+#define AVIF_ISINTERLEAVED 0x00000100
+#define AVIF_TRUSTCKTYPE 0x00000800  // Use CKType to find key frames?
+#define AVIF_WASCAPTUREFILE 0x00010000
+#define AVIF_COPYRIGHTED 0x00020000
+
+addFileHeader1(avih);
+unsigned usecPerFrame = fMovieFPS == 0 ? 0 : 1000000 / fMovieFPS;
+size += addWord(usecPerFrame);  // dwMicroSecPerFrame
+fAVIHMaxBytesPerSecondPosition = (unsigned)TellFile64(fOutFid);
+size += addWord(0);                                                      // dwMaxBytesPerSec (fill in later)
+size += addWord(0);                                                      // dwPaddingGranularity
+size += addWord(AVIF_TRUSTCKTYPE | AVIF_HASINDEX | AVIF_ISINTERLEAVED);  // dwFlags
+fAVIHFrameCountPosition = (unsigned)TellFile64(fOutFid);
+size += addWord(0);                // dwTotalFrames (fill in later)
+size += addWord(0);                // dwInitialFrame
+size += addWord(fNumSubsessions);  // dwStreams
+size += addWord(fBufferSize);      // dwSuggestedBufferSize
+size += addWord(fMovieWidth);      // dwWidth
+size += addWord(fMovieHeight);     // dwHeight
+size += addZeroWords(4);           // dwReserved
+addFileHeaderEnd;
+
+addFileHeader(LIST, strl);
+size += addFileHeader_strh();
+size += addFileHeader_strf();
+fJunkNumber = 0;
+size += addFileHeader_JUNK();
+addFileHeaderEnd;
+
+addFileHeader1(strh);
+size += add4ByteString(fCurrentIOState->fIsVideo ? "vids" : fCurrentIOState->fIsAudio ? "auds" : "????");  // fccType
+size += addWord(fCurrentIOState->fAVICodecHandlerType);                                                    // fccHandler
+size += addWord(0);                                                                                        // dwFlags
+size += addWord(0);                                                                                        // wPriority + wLanguage
+size += addWord(0);                                                                                        // dwInitialFrames
+size += addWord(fCurrentIOState->fAVIScale);                                                               // dwScale
+size += addWord(fCurrentIOState->fAVIRate);                                                                // dwRate
+size += addWord(0);                                                                                        // dwStart
+fCurrentIOState->fSTRHFrameCountPosition = (unsigned)TellFile64(fOutFid);
+size += addWord(0);                          // dwLength (fill in later)
+size += addWord(fBufferSize);                // dwSuggestedBufferSize
+size += addWord((unsigned)-1);               // dwQuality
+size += addWord(fCurrentIOState->fAVISize);  // dwSampleSize
+size += addWord(0);                          // rcFrame (start)
+if(fCurrentIOState->fIsVideo) {
+    size += addHalfWord(fMovieWidth);
+    size += addHalfWord(fMovieHeight);
+}
+else {
+    size += addWord(0);
+}
+addFileHeaderEnd;
+
+addFileHeader1(strf);
+if(fCurrentIOState->fIsVideo) {
+    // Add a BITMAPINFO header:
+    unsigned extraDataSize = 0;
+    size += addWord(10 * 4 + extraDataSize);  // size
+    size += addWord(fMovieWidth);
+    size += addWord(fMovieHeight);
+    size += addHalfWord(1);                                  // planes
+    size += addHalfWord(24);                                 // bits-per-sample #####
+    size += addWord(fCurrentIOState->fAVICodecHandlerType);  // compr. type
+    size += addWord(fCurrentIOState->fAVISize);
+    size += addZeroWords(4);  // ??? #####
+                              // Later, add extra data here (if any) #####
+}
+else if(fCurrentIOState->fIsAudio) {
+    // Add a WAVFORMATEX header:
+    size += addHalfWord(fCurrentIOState->fWAVCodecTag);
+    unsigned numChannels = fCurrentIOState->fOurSubsession.numChannels();
+    size += addHalfWord(numChannels);
+    size += addWord(fCurrentIOState->fAVISamplingFrequency);
+    size += addWord(fCurrentIOState->fAVIRate);      // bytes per second
+    size += addHalfWord(fCurrentIOState->fAVISize);  // block alignment
+    unsigned bitsPerSample = (fCurrentIOState->fAVISize * 8) / numChannels;
+    size += addHalfWord(bitsPerSample);
+    if(strcmp(fCurrentIOState->fOurSubsession.codecName(), "MPA") == 0) {
+        // Assume MPEG layer II audio (not MP3): #####
+        size += addHalfWord(22);                         // wav_extra_size
+        size += addHalfWord(2);                          // fwHeadLayer
+        size += addWord(8 * fCurrentIOState->fAVIRate);  // dwHeadBitrate #####
+        size += addHalfWord(numChannels == 2 ? 1 : 8);   // fwHeadMode
+        size += addHalfWord(0);                          // fwHeadModeExt
+        size += addHalfWord(1);                          // wHeadEmphasis
+        size += addHalfWord(16);                         // fwHeadFlags
+        size += addWord(0);                              // dwPTSLow
+        size += addWord(0);                              // dwPTSHigh
+    }
+}
+addFileHeaderEnd;
+
+#define AVI_MASTER_INDEX_SIZE 256
+
+addFileHeader1(JUNK);
+if(fJunkNumber == 0) {
+    size += addHalfWord(4);                               // wLongsPerEntry
+    size += addHalfWord(0);                               // bIndexSubType + bIndexType
+    size += addWord(0);                                   // nEntriesInUse #####
+    size += addWord(fCurrentIOState->fAVISubsessionTag);  // dwChunkId
+    size += addZeroWords(2);                              // dwReserved
+    size += addZeroWords(AVI_MASTER_INDEX_SIZE * 4);
+}
+else {
+    size += add4ByteString("odml");
+    size += add4ByteString("dmlh");
+    unsigned wtfCount = 248;
+    size += addWord(wtfCount);  // ??? #####
+    size += addZeroWords(wtfCount / 4);
+}
+addFileHeaderEnd;
+
+addFileHeader(LIST, movi);
+fMoviSizePosition = headerSizePosn;
+fMoviSizeValue    = size - ignoredSize;
+addFileHeaderEnd;
diff --git a/3rdparty/live555/src/liveMedia/AudioInputDevice.cpp b/3rdparty/live555/src/liveMedia/AudioInputDevice.cpp
new file mode 100644
index 00000000..62e050fd
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/AudioInputDevice.cpp
@@ -0,0 +1,38 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// Copyright (c) 2001-2003 Live Networks, Inc.  All rights reserved.
+// Generic audio input device (such as a microphone, or an input sound card)
+// Implementation
+
+#include <AudioInputDevice.hh>
+
+AudioInputDevice ::AudioInputDevice(UsageEnvironment &env, unsigned char bitsPerSample, unsigned char numChannels, unsigned samplingFrequency,
+                                    unsigned granularityInMS)
+    : FramedSource(env), fBitsPerSample(bitsPerSample), fNumChannels(numChannels), fSamplingFrequency(samplingFrequency), fGranularityInMS(granularityInMS) {}
+
+AudioInputDevice::~AudioInputDevice() {}
+
+char **AudioInputDevice::allowedDeviceNames = NULL;
+
+////////// AudioPortNames implementation //////////
+
+AudioPortNames::AudioPortNames() : numPorts(0), portName(NULL) {}
+
+AudioPortNames::~AudioPortNames() {
+    for(unsigned i = 0; i < numPorts; ++i)
+        delete portName[i];
+    delete portName;
+}
diff --git a/3rdparty/live555/src/liveMedia/AudioRTPSink.cpp b/3rdparty/live555/src/liveMedia/AudioRTPSink.cpp
new file mode 100644
index 00000000..73fa7b03
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/AudioRTPSink.cpp
@@ -0,0 +1,31 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A generic RTP sink for audio codecs (abstract base class)
+// Implementation
+
+#include "AudioRTPSink.hh"
+
+AudioRTPSink::AudioRTPSink(UsageEnvironment &env, Groupsock *rtpgs, unsigned char rtpPayloadType, unsigned rtpTimestampFrequency,
+                           char const *rtpPayloadFormatName, unsigned numChannels)
+    : MultiFramedRTPSink(env, rtpgs, rtpPayloadType, rtpTimestampFrequency, rtpPayloadFormatName, numChannels) {}
+
+AudioRTPSink::~AudioRTPSink() {}
+
+char const *AudioRTPSink::sdpMediaType() const {
+    return "audio";
+}
diff --git a/3rdparty/live555/src/liveMedia/Base64.cpp b/3rdparty/live555/src/liveMedia/Base64.cpp
new file mode 100644
index 00000000..6e434a0b
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/Base64.cpp
@@ -0,0 +1,130 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// Base64 encoding and decoding
+// implementation
+
+#include "Base64.hh"
+#include <strDup.hh>
+#include <string.h>
+
+static char base64DecodeTable[256];
+
+static void initBase64DecodeTable() {
+    int i;
+    for(i = 0; i < 256; ++i)
+        base64DecodeTable[i] = (char)0x80;
+    // default value: invalid
+
+    for(i = 'A'; i <= 'Z'; ++i)
+        base64DecodeTable[i] = 0 + (i - 'A');
+    for(i = 'a'; i <= 'z'; ++i)
+        base64DecodeTable[i] = 26 + (i - 'a');
+    for(i = '0'; i <= '9'; ++i)
+        base64DecodeTable[i] = 52 + (i - '0');
+    base64DecodeTable[(unsigned char)'+'] = 62;
+    base64DecodeTable[(unsigned char)'/'] = 63;
+    base64DecodeTable[(unsigned char)'='] = 0;
+}
+
+unsigned char *base64Decode(char const *in, unsigned &resultSize, Boolean trimTrailingZeros) {
+    if(in == NULL)
+        return NULL;  // sanity check
+    return base64Decode(in, strlen(in), resultSize, trimTrailingZeros);
+}
+
+unsigned char *base64Decode(char const *in, unsigned inSize, unsigned &resultSize, Boolean trimTrailingZeros) {
+    static Boolean haveInitializedBase64DecodeTable = False;
+    if(!haveInitializedBase64DecodeTable) {
+        initBase64DecodeTable();
+        haveInitializedBase64DecodeTable = True;
+    }
+
+    unsigned char *out          = new unsigned char[inSize + 1];  // ensures we have enough space
+    int            k            = 0;
+    int            paddingCount = 0;
+    int const      jMax         = inSize - 3;
+    // in case "inSize" is not a multiple of 4 (although it should be)
+    for(int j = 0; j < jMax; j += 4) {
+        char inTmp[4], outTmp[4];
+        for(int i = 0; i < 4; ++i) {
+            inTmp[i] = in[i + j];
+            if(inTmp[i] == '=')
+                ++paddingCount;
+            outTmp[i] = base64DecodeTable[(unsigned char)inTmp[i]];
+            if((outTmp[i] & 0x80) != 0)
+                outTmp[i] = 0;  // this happens only if there was an invalid character; pretend that it was 'A'
+        }
+
+        out[k++] = (outTmp[0] << 2) | (outTmp[1] >> 4);
+        out[k++] = (outTmp[1] << 4) | (outTmp[2] >> 2);
+        out[k++] = (outTmp[2] << 6) | outTmp[3];
+    }
+
+    if(trimTrailingZeros) {
+        while(paddingCount > 0 && k > 0 && out[k - 1] == '\0') {
+            --k;
+            --paddingCount;
+        }
+    }
+    resultSize            = k;
+    unsigned char *result = new unsigned char[resultSize];
+    memmove(result, out, resultSize);
+    delete[] out;
+
+    return result;
+}
+
+static const char base64Char[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+char *base64Encode(char const *origSigned, unsigned origLength) {
+    unsigned char const *orig = (unsigned char const *)origSigned;  // in case any input bytes have the MSB set
+    if(orig == NULL)
+        return NULL;
+
+    unsigned const numOrig24BitValues = origLength / 3;
+    Boolean        havePadding        = origLength > numOrig24BitValues * 3;
+    Boolean        havePadding2       = origLength == numOrig24BitValues * 3 + 2;
+    unsigned const numResultBytes     = 4 * (numOrig24BitValues + havePadding);
+    char *         result             = new char[numResultBytes + 1];  // allow for trailing '\0'
+
+    // Map each full group of 3 input bytes into 4 output base-64 characters:
+    unsigned i;
+    for(i = 0; i < numOrig24BitValues; ++i) {
+        result[4 * i + 0] = base64Char[(orig[3 * i] >> 2) & 0x3F];
+        result[4 * i + 1] = base64Char[(((orig[3 * i] & 0x3) << 4) | (orig[3 * i + 1] >> 4)) & 0x3F];
+        result[4 * i + 2] = base64Char[((orig[3 * i + 1] << 2) | (orig[3 * i + 2] >> 6)) & 0x3F];
+        result[4 * i + 3] = base64Char[orig[3 * i + 2] & 0x3F];
+    }
+
+    // Now, take padding into account.  (Note: i == numOrig24BitValues)
+    if(havePadding) {
+        result[4 * i + 0] = base64Char[(orig[3 * i] >> 2) & 0x3F];
+        if(havePadding2) {
+            result[4 * i + 1] = base64Char[(((orig[3 * i] & 0x3) << 4) | (orig[3 * i + 1] >> 4)) & 0x3F];
+            result[4 * i + 2] = base64Char[(orig[3 * i + 1] << 2) & 0x3F];
+        }
+        else {
+            result[4 * i + 1] = base64Char[((orig[3 * i] & 0x3) << 4) & 0x3F];
+            result[4 * i + 2] = '=';
+        }
+        result[4 * i + 3] = '=';
+    }
+
+    result[numResultBytes] = '\0';
+    return result;
+}
diff --git a/3rdparty/live555/src/liveMedia/BasicUDPSink.cpp b/3rdparty/live555/src/liveMedia/BasicUDPSink.cpp
new file mode 100644
index 00000000..53dc4bbc
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/BasicUDPSink.cpp
@@ -0,0 +1,90 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A simple UDP sink (i.e., without RTP or other headers added); one frame per packet
+// Implementation
+
+#include "BasicUDPSink.hh"
+#include <GroupsockHelper.hh>
+
+BasicUDPSink *BasicUDPSink::createNew(UsageEnvironment &env, Groupsock *gs, unsigned maxPayloadSize) {
+    return new BasicUDPSink(env, gs, maxPayloadSize);
+}
+
+BasicUDPSink::BasicUDPSink(UsageEnvironment &env, Groupsock *gs, unsigned maxPayloadSize) : MediaSink(env), fGS(gs), fMaxPayloadSize(maxPayloadSize) {
+    fOutputBuffer = new unsigned char[fMaxPayloadSize];
+}
+
+BasicUDPSink::~BasicUDPSink() {
+    delete[] fOutputBuffer;
+}
+
+Boolean BasicUDPSink::continuePlaying() {
+    // Record the fact that we're starting to play now:
+    gettimeofday(&fNextSendTime, NULL);
+
+    // Arrange to get and send the first payload.
+    // (This will also schedule any future sends.)
+    continuePlaying1();
+    return True;
+}
+
+void BasicUDPSink::continuePlaying1() {
+    nextTask() = NULL;
+    if(fSource != NULL) {
+        fSource->getNextFrame(fOutputBuffer, fMaxPayloadSize, afterGettingFrame, this, onSourceClosure, this);
+    }
+}
+
+void BasicUDPSink::afterGettingFrame(void *clientData, unsigned frameSize, unsigned numTruncatedBytes, struct timeval /*presentationTime*/,
+                                     unsigned durationInMicroseconds) {
+    BasicUDPSink *sink = (BasicUDPSink *)clientData;
+    sink->afterGettingFrame1(frameSize, numTruncatedBytes, durationInMicroseconds);
+}
+
+void BasicUDPSink::afterGettingFrame1(unsigned frameSize, unsigned numTruncatedBytes, unsigned durationInMicroseconds) {
+    if(numTruncatedBytes > 0) {
+        envir() << "BasicUDPSink::afterGettingFrame1(): The input frame data was too large for our spcified maximum payload size (" << fMaxPayloadSize << ").  "
+                << numTruncatedBytes << " bytes of trailing data was dropped!\n";
+    }
+
+    // Send the packet:
+    fGS->output(envir(), fOutputBuffer, frameSize);
+
+    // Figure out the time at which the next packet should be sent, based
+    // on the duration of the payload that we just read:
+    fNextSendTime.tv_usec += durationInMicroseconds;
+    fNextSendTime.tv_sec += fNextSendTime.tv_usec / 1000000;
+    fNextSendTime.tv_usec %= 1000000;
+
+    struct timeval timeNow;
+    gettimeofday(&timeNow, NULL);
+    int     secsDiff     = fNextSendTime.tv_sec - timeNow.tv_sec;
+    int64_t uSecondsToGo = secsDiff * 1000000 + (fNextSendTime.tv_usec - timeNow.tv_usec);
+    if(uSecondsToGo < 0 || secsDiff < 0) {  // sanity check: Make sure that the time-to-delay is non-negative:
+        uSecondsToGo = 0;
+    }
+
+    // Delay this amount of time:
+    nextTask() = envir().taskScheduler().scheduleDelayedTask(uSecondsToGo, (TaskFunc *)sendNext, this);
+}
+
+// The following is called after each delay between packet sends:
+void BasicUDPSink::sendNext(void *firstArg) {
+    BasicUDPSink *sink = (BasicUDPSink *)firstArg;
+    sink->continuePlaying1();
+}
diff --git a/3rdparty/live555/src/liveMedia/BasicUDPSource.cpp b/3rdparty/live555/src/liveMedia/BasicUDPSource.cpp
new file mode 100644
index 00000000..dd058da1
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/BasicUDPSource.cpp
@@ -0,0 +1,75 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A simple UDP source, where every UDP payload is a complete frame
+// Implementation
+
+#include "BasicUDPSource.hh"
+#include <GroupsockHelper.hh>
+
+BasicUDPSource *BasicUDPSource::createNew(UsageEnvironment &env, Groupsock *inputGS) {
+    return new BasicUDPSource(env, inputGS);
+}
+
+BasicUDPSource::BasicUDPSource(UsageEnvironment &env, Groupsock *inputGS) : FramedSource(env), fInputGS(inputGS), fHaveStartedReading(False) {
+    // Try to use a large receive buffer (in the OS):
+    increaseReceiveBufferTo(env, inputGS->socketNum(), 50 * 1024);
+
+    // Make the socket non-blocking, even though it will be read from only asynchronously, when packets arrive.
+    // The reason for this is that, in some OSs, reads on a blocking socket can (allegedly) sometimes block,
+    // even if the socket was previously reported (e.g., by "select()") as having data available.
+    // (This can supposedly happen if the UDP checksum fails, for example.)
+    makeSocketNonBlocking(fInputGS->socketNum());
+}
+
+BasicUDPSource::~BasicUDPSource() {
+    envir().taskScheduler().turnOffBackgroundReadHandling(fInputGS->socketNum());
+}
+
+unsigned BasicUDPSource::maxFrameSize() const {
+    return 0xFFFF;  // maximum size of a UDP payload
+}
+
+void BasicUDPSource::doGetNextFrame() {
+    if(!fHaveStartedReading) {
+        // Await incoming packets:
+        envir().taskScheduler().turnOnBackgroundReadHandling(fInputGS->socketNum(), (TaskScheduler::BackgroundHandlerProc *)&incomingPacketHandler, this);
+        fHaveStartedReading = True;
+    }
+}
+
+void BasicUDPSource::doStopGettingFrames() {
+    envir().taskScheduler().turnOffBackgroundReadHandling(fInputGS->socketNum());
+    fHaveStartedReading = False;
+}
+
+void BasicUDPSource::incomingPacketHandler(BasicUDPSource *source, int /*mask*/) {
+    source->incomingPacketHandler1();
+}
+
+void BasicUDPSource::incomingPacketHandler1() {
+    if(!isCurrentlyAwaitingData())
+        return;  // we're not ready for the data yet
+
+    // Read the packet into our desired destination:
+    struct sockaddr_storage fromAddress;
+    if(!fInputGS->handleRead(fTo, fMaxSize, fFrameSize, fromAddress))
+        return;
+
+    // Tell our client that we have new data:
+    afterGetting(this);  // we're preceded by a net read; no infinite recursion
+}
diff --git a/3rdparty/live555/src/liveMedia/BitVector.cpp b/3rdparty/live555/src/liveMedia/BitVector.cpp
new file mode 100644
index 00000000..b18adac3
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/BitVector.cpp
@@ -0,0 +1,184 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// Bit Vector data structure
+// Implementation
+
+#include "BitVector.hh"
+
+BitVector::BitVector(unsigned char *baseBytePtr, unsigned baseBitOffset, unsigned totNumBits) {
+    setup(baseBytePtr, baseBitOffset, totNumBits);
+}
+
+void BitVector::setup(unsigned char *baseBytePtr, unsigned baseBitOffset, unsigned totNumBits) {
+    fBaseBytePtr   = baseBytePtr;
+    fBaseBitOffset = baseBitOffset;
+    fTotNumBits    = totNumBits;
+    fCurBitIndex   = 0;
+}
+
+static unsigned char const singleBitMask[8] = { 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01 };
+
+#define MAX_LENGTH 32
+
+void BitVector::putBits(unsigned from, unsigned numBits) {
+    if(numBits == 0)
+        return;
+
+    unsigned char tmpBuf[4];
+    unsigned      overflowingBits = 0;
+
+    if(numBits > MAX_LENGTH) {
+        numBits = MAX_LENGTH;
+    }
+
+    if(numBits > fTotNumBits - fCurBitIndex) {
+        overflowingBits = numBits - (fTotNumBits - fCurBitIndex);
+    }
+
+    tmpBuf[0] = (unsigned char)(from >> 24);
+    tmpBuf[1] = (unsigned char)(from >> 16);
+    tmpBuf[2] = (unsigned char)(from >> 8);
+    tmpBuf[3] = (unsigned char)from;
+
+    shiftBits(fBaseBytePtr, fBaseBitOffset + fCurBitIndex, /* to */
+              tmpBuf, MAX_LENGTH - numBits,                /* from */
+              numBits - overflowingBits /* num bits */);
+    fCurBitIndex += numBits - overflowingBits;
+}
+
+void BitVector::put1Bit(unsigned bit) {
+    // The following is equivalent to "putBits(..., 1)", except faster:
+    if(fCurBitIndex >= fTotNumBits) { /* overflow */
+        return;
+    }
+    else {
+        unsigned      totBitOffset = fBaseBitOffset + fCurBitIndex++;
+        unsigned char mask         = singleBitMask[totBitOffset % 8];
+        if(bit) {
+            fBaseBytePtr[totBitOffset / 8] |= mask;
+        }
+        else {
+            fBaseBytePtr[totBitOffset / 8] &= ~mask;
+        }
+    }
+}
+
+unsigned BitVector::getBits(unsigned numBits) {
+    if(numBits == 0)
+        return 0;
+
+    unsigned char tmpBuf[4];
+    unsigned      overflowingBits = 0;
+
+    if(numBits > MAX_LENGTH) {
+        numBits = MAX_LENGTH;
+    }
+
+    if(numBits > fTotNumBits - fCurBitIndex) {
+        overflowingBits = numBits - (fTotNumBits - fCurBitIndex);
+    }
+
+    shiftBits(tmpBuf, 0,                                   /* to */
+              fBaseBytePtr, fBaseBitOffset + fCurBitIndex, /* from */
+              numBits - overflowingBits /* num bits */);
+    fCurBitIndex += numBits - overflowingBits;
+
+    unsigned result = (tmpBuf[0] << 24) | (tmpBuf[1] << 16) | (tmpBuf[2] << 8) | tmpBuf[3];
+    result >>= (MAX_LENGTH - numBits);          // move into low-order part of word
+    result &= (0xFFFFFFFF << overflowingBits);  // so any overflow bits are 0
+    return result;
+}
+
+unsigned BitVector::get1Bit() {
+    // The following is equivalent to "getBits(1)", except faster:
+
+    if(fCurBitIndex >= fTotNumBits) { /* overflow */
+        return 0;
+    }
+    else {
+        unsigned      totBitOffset = fBaseBitOffset + fCurBitIndex++;
+        unsigned char curFromByte  = fBaseBytePtr[totBitOffset / 8];
+        unsigned      result       = (curFromByte >> (7 - (totBitOffset % 8))) & 0x01;
+        return result;
+    }
+}
+
+void BitVector::skipBits(unsigned numBits) {
+    if(numBits > fTotNumBits - fCurBitIndex) { /* overflow */
+        fCurBitIndex = fTotNumBits;
+    }
+    else {
+        fCurBitIndex += numBits;
+    }
+}
+
+unsigned BitVector::get_expGolomb() {
+    unsigned numLeadingZeroBits = 0;
+    unsigned codeStart          = 1;
+
+    while(get1Bit() == 0 && fCurBitIndex < fTotNumBits) {
+        ++numLeadingZeroBits;
+        codeStart *= 2;
+    }
+
+    return codeStart - 1 + getBits(numLeadingZeroBits);
+}
+
+int BitVector::get_expGolombSigned() {
+    unsigned codeNum = get_expGolomb();
+
+    if((codeNum & 1) == 0) {  // even
+        return -(int)(codeNum / 2);
+    }
+    else {  // odd
+        return (codeNum + 1) / 2;
+    }
+}
+
+void shiftBits(unsigned char *toBasePtr, unsigned toBitOffset, unsigned char const *fromBasePtr, unsigned fromBitOffset, unsigned numBits) {
+    if(numBits == 0)
+        return;
+
+    /* Note that from and to may overlap, if from>to */
+    unsigned char const *fromBytePtr = fromBasePtr + fromBitOffset / 8;
+    unsigned             fromBitRem  = fromBitOffset % 8;
+    unsigned char *      toBytePtr   = toBasePtr + toBitOffset / 8;
+    unsigned             toBitRem    = toBitOffset % 8;
+
+    while(numBits-- > 0) {
+        unsigned char fromBitMask = singleBitMask[fromBitRem];
+        unsigned char fromBit     = (*fromBytePtr) & fromBitMask;
+        unsigned char toBitMask   = singleBitMask[toBitRem];
+
+        if(fromBit != 0) {
+            *toBytePtr |= toBitMask;
+        }
+        else {
+            *toBytePtr &= ~toBitMask;
+        }
+
+        if(++fromBitRem == 8) {
+            ++fromBytePtr;
+            fromBitRem = 0;
+        }
+        if(++toBitRem == 8) {
+            ++toBytePtr;
+            toBitRem = 0;
+        }
+    }
+}
diff --git a/3rdparty/live555/src/liveMedia/ByteStreamFileSource.cpp b/3rdparty/live555/src/liveMedia/ByteStreamFileSource.cpp
new file mode 100644
index 00000000..5dd60ca4
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/ByteStreamFileSource.cpp
@@ -0,0 +1,184 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A file source that is a plain byte stream (rather than frames)
+// Implementation
+
+#include "ByteStreamFileSource.hh"
+#include "InputFile.hh"
+#include "GroupsockHelper.hh"
+
+////////// ByteStreamFileSource //////////
+
+ByteStreamFileSource *ByteStreamFileSource::createNew(UsageEnvironment &env, char const *fileName, unsigned preferredFrameSize, unsigned playTimePerFrame) {
+    FILE *fid = OpenInputFile(env, fileName);
+    if(fid == NULL)
+        return NULL;
+
+    ByteStreamFileSource *newSource = new ByteStreamFileSource(env, fid, preferredFrameSize, playTimePerFrame);
+    newSource->fFileSize            = GetFileSize(fileName, fid);
+
+    return newSource;
+}
+
+ByteStreamFileSource *ByteStreamFileSource::createNew(UsageEnvironment &env, FILE *fid, unsigned preferredFrameSize, unsigned playTimePerFrame) {
+    if(fid == NULL)
+        return NULL;
+
+    ByteStreamFileSource *newSource = new ByteStreamFileSource(env, fid, preferredFrameSize, playTimePerFrame);
+    newSource->fFileSize            = GetFileSize(NULL, fid);
+
+    return newSource;
+}
+
+void ByteStreamFileSource::seekToByteAbsolute(u_int64_t byteNumber, u_int64_t numBytesToStream) {
+    SeekFile64(fFid, (int64_t)byteNumber, SEEK_SET);
+
+    fNumBytesToStream      = numBytesToStream;
+    fLimitNumBytesToStream = fNumBytesToStream > 0;
+}
+
+void ByteStreamFileSource::seekToByteRelative(int64_t offset, u_int64_t numBytesToStream) {
+    SeekFile64(fFid, offset, SEEK_CUR);
+
+    fNumBytesToStream      = numBytesToStream;
+    fLimitNumBytesToStream = fNumBytesToStream > 0;
+}
+
+void ByteStreamFileSource::seekToEnd() {
+    SeekFile64(fFid, 0, SEEK_END);
+}
+
+ByteStreamFileSource::ByteStreamFileSource(UsageEnvironment &env, FILE *fid, unsigned preferredFrameSize, unsigned playTimePerFrame)
+    : FramedFileSource(env, fid),
+      fFileSize(0),
+      fPreferredFrameSize(preferredFrameSize),
+      fPlayTimePerFrame(playTimePerFrame),
+      fLastPlayTime(0),
+      fHaveStartedReading(False),
+      fLimitNumBytesToStream(False),
+      fNumBytesToStream(0) {
+#ifndef READ_FROM_FILES_SYNCHRONOUSLY
+    makeSocketNonBlocking(fileno(fFid));
+#endif
+
+    // Test whether the file is seekable
+    fFidIsSeekable = FileIsSeekable(fFid);
+}
+
+ByteStreamFileSource::~ByteStreamFileSource() {
+    if(fFid == NULL)
+        return;
+
+#ifndef READ_FROM_FILES_SYNCHRONOUSLY
+    envir().taskScheduler().turnOffBackgroundReadHandling(fileno(fFid));
+#endif
+
+    CloseInputFile(fFid);
+}
+
+void ByteStreamFileSource::doGetNextFrame() {
+    if(feof(fFid) || ferror(fFid) || (fLimitNumBytesToStream && fNumBytesToStream == 0)) {
+        handleClosure();
+        return;
+    }
+
+#ifdef READ_FROM_FILES_SYNCHRONOUSLY
+    doReadFromFile();
+#else
+    if(!fHaveStartedReading) {
+        // Await readable data from the file:
+        envir().taskScheduler().turnOnBackgroundReadHandling(fileno(fFid), (TaskScheduler::BackgroundHandlerProc *)&fileReadableHandler, this);
+        fHaveStartedReading = True;
+    }
+#endif
+}
+
+void ByteStreamFileSource::doStopGettingFrames() {
+    envir().taskScheduler().unscheduleDelayedTask(nextTask());
+#ifndef READ_FROM_FILES_SYNCHRONOUSLY
+    envir().taskScheduler().turnOffBackgroundReadHandling(fileno(fFid));
+    fHaveStartedReading = False;
+#endif
+}
+
+void ByteStreamFileSource::fileReadableHandler(ByteStreamFileSource *source, int /*mask*/) {
+    if(!source->isCurrentlyAwaitingData()) {
+        source->doStopGettingFrames();  // we're not ready for the data yet
+        return;
+    }
+    source->doReadFromFile();
+}
+
+void ByteStreamFileSource::doReadFromFile() {
+    // Try to read as many bytes as will fit in the buffer provided (or "fPreferredFrameSize" if less)
+    if(fLimitNumBytesToStream && fNumBytesToStream < (u_int64_t)fMaxSize) {
+        fMaxSize = (unsigned)fNumBytesToStream;
+    }
+    if(fPreferredFrameSize > 0 && fPreferredFrameSize < fMaxSize) {
+        fMaxSize = fPreferredFrameSize;
+    }
+#ifdef READ_FROM_FILES_SYNCHRONOUSLY
+    fFrameSize = fread(fTo, 1, fMaxSize, fFid);
+#else
+    if(fFidIsSeekable) {
+        fFrameSize = fread(fTo, 1, fMaxSize, fFid);
+    }
+    else {
+        // For non-seekable files (e.g., pipes), call "read()" rather than "fread()", to ensure that the read doesn't block:
+        fFrameSize = read(fileno(fFid), fTo, fMaxSize);
+    }
+#endif
+    if(fFrameSize == 0) {
+        handleClosure();
+        return;
+    }
+    fNumBytesToStream -= fFrameSize;
+
+    // Set the 'presentation time':
+    if(fPlayTimePerFrame > 0 && fPreferredFrameSize > 0) {
+        if(fPresentationTime.tv_sec == 0 && fPresentationTime.tv_usec == 0) {
+            // This is the first frame, so use the current time:
+            gettimeofday(&fPresentationTime, NULL);
+        }
+        else {
+            // Increment by the play time of the previous data:
+            unsigned uSeconds = fPresentationTime.tv_usec + fLastPlayTime;
+            fPresentationTime.tv_sec += uSeconds / 1000000;
+            fPresentationTime.tv_usec = uSeconds % 1000000;
+        }
+
+        // Remember the play time of this data:
+        fLastPlayTime           = (fPlayTimePerFrame * fFrameSize) / fPreferredFrameSize;
+        fDurationInMicroseconds = fLastPlayTime;
+    }
+    else {
+        // We don't know a specific play time duration for this data,
+        // so just record the current time as being the 'presentation time':
+        gettimeofday(&fPresentationTime, NULL);
+    }
+
+    // Inform the reader that he has data:
+#ifdef READ_FROM_FILES_SYNCHRONOUSLY
+    // To avoid possible infinite recursion, we need to return to the event loop to do this:
+    nextTask() = envir().taskScheduler().scheduleDelayedTask(0, (TaskFunc *)FramedSource::afterGetting, this);
+#else
+    // Because the file read was done from the event loop, we can call the
+    // 'after getting' function directly, without risk of infinite recursion:
+    FramedSource::afterGetting(this);
+#endif
+}
diff --git a/3rdparty/live555/src/liveMedia/ByteStreamMemoryBufferSource.cpp b/3rdparty/live555/src/liveMedia/ByteStreamMemoryBufferSource.cpp
new file mode 100644
index 00000000..a2a9330b
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/ByteStreamMemoryBufferSource.cpp
@@ -0,0 +1,124 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A class for streaming data from a (static) memory buffer, as if it were a file.
+// Implementation
+
+#include "ByteStreamMemoryBufferSource.hh"
+#include "GroupsockHelper.hh"
+
+////////// ByteStreamMemoryBufferSource //////////
+
+ByteStreamMemoryBufferSource *ByteStreamMemoryBufferSource::createNew(UsageEnvironment &env, u_int8_t *buffer, u_int64_t bufferSize,
+                                                                      Boolean deleteBufferOnClose, unsigned preferredFrameSize, unsigned playTimePerFrame) {
+    if(buffer == NULL)
+        return NULL;
+
+    return new ByteStreamMemoryBufferSource(env, buffer, bufferSize, deleteBufferOnClose, preferredFrameSize, playTimePerFrame);
+}
+
+ByteStreamMemoryBufferSource::ByteStreamMemoryBufferSource(UsageEnvironment &env, u_int8_t *buffer, u_int64_t bufferSize, Boolean deleteBufferOnClose,
+                                                           unsigned preferredFrameSize, unsigned playTimePerFrame)
+    : FramedSource(env),
+      fBuffer(buffer),
+      fBufferSize(bufferSize),
+      fCurIndex(0),
+      fDeleteBufferOnClose(deleteBufferOnClose),
+      fPreferredFrameSize(preferredFrameSize),
+      fPlayTimePerFrame(playTimePerFrame),
+      fLastPlayTime(0),
+      fLimitNumBytesToStream(False),
+      fNumBytesToStream(0) {}
+
+ByteStreamMemoryBufferSource::~ByteStreamMemoryBufferSource() {
+    if(fDeleteBufferOnClose)
+        delete[] fBuffer;
+}
+
+void ByteStreamMemoryBufferSource::seekToByteAbsolute(u_int64_t byteNumber, u_int64_t numBytesToStream) {
+    fCurIndex = byteNumber;
+    if(fCurIndex > fBufferSize)
+        fCurIndex = fBufferSize;
+
+    fNumBytesToStream      = numBytesToStream;
+    fLimitNumBytesToStream = fNumBytesToStream > 0;
+}
+
+void ByteStreamMemoryBufferSource::seekToByteRelative(int64_t offset, u_int64_t numBytesToStream) {
+    int64_t newIndex = fCurIndex + offset;
+    if(newIndex < 0) {
+        fCurIndex = 0;
+    }
+    else {
+        fCurIndex = (u_int64_t)offset;
+        if(fCurIndex > fBufferSize)
+            fCurIndex = fBufferSize;
+    }
+
+    fNumBytesToStream      = numBytesToStream;
+    fLimitNumBytesToStream = fNumBytesToStream > 0;
+}
+
+void ByteStreamMemoryBufferSource::doGetNextFrame() {
+    if(fCurIndex >= fBufferSize || (fLimitNumBytesToStream && fNumBytesToStream == 0)) {
+        handleClosure();
+        return;
+    }
+
+    // Try to read as many bytes as will fit in the buffer provided (or "fPreferredFrameSize" if less)
+    fFrameSize = fMaxSize;
+    if(fLimitNumBytesToStream && fNumBytesToStream < (u_int64_t)fFrameSize) {
+        fFrameSize = (unsigned)fNumBytesToStream;
+    }
+    if(fPreferredFrameSize > 0 && fPreferredFrameSize < fFrameSize) {
+        fFrameSize = fPreferredFrameSize;
+    }
+
+    if(fCurIndex + fFrameSize > fBufferSize) {
+        fFrameSize = (unsigned)(fBufferSize - fCurIndex);
+    }
+
+    memmove(fTo, &fBuffer[fCurIndex], fFrameSize);
+    fCurIndex += fFrameSize;
+    fNumBytesToStream -= fFrameSize;
+
+    // Set the 'presentation time':
+    if(fPlayTimePerFrame > 0 && fPreferredFrameSize > 0) {
+        if(fPresentationTime.tv_sec == 0 && fPresentationTime.tv_usec == 0) {
+            // This is the first frame, so use the current time:
+            gettimeofday(&fPresentationTime, NULL);
+        }
+        else {
+            // Increment by the play time of the previous data:
+            unsigned uSeconds = fPresentationTime.tv_usec + fLastPlayTime;
+            fPresentationTime.tv_sec += uSeconds / 1000000;
+            fPresentationTime.tv_usec = uSeconds % 1000000;
+        }
+
+        // Remember the play time of this data:
+        fLastPlayTime           = (fPlayTimePerFrame * fFrameSize) / fPreferredFrameSize;
+        fDurationInMicroseconds = fLastPlayTime;
+    }
+    else {
+        // We don't know a specific play time duration for this data,
+        // so just record the current time as being the 'presentation time':
+        gettimeofday(&fPresentationTime, NULL);
+    }
+
+    // Inform the downstream object that it has data:
+    FramedSource::afterGetting(this);
+}
diff --git a/3rdparty/live555/src/liveMedia/ByteStreamMultiFileSource.cpp b/3rdparty/live555/src/liveMedia/ByteStreamMultiFileSource.cpp
new file mode 100644
index 00000000..9d99dcbd
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/ByteStreamMultiFileSource.cpp
@@ -0,0 +1,125 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A source that consists of multiple byte-stream files, read sequentially.
+// (The input is an array of file names, with a terminating 'file name' of NULL.)
+// Implementation
+
+#include "ByteStreamMultiFileSource.hh"
+
+ByteStreamMultiFileSource ::ByteStreamMultiFileSource(UsageEnvironment &env, char const **fileNameArray, unsigned preferredFrameSize, unsigned playTimePerFrame)
+    : FramedSource(env),
+      fPreferredFrameSize(preferredFrameSize),
+      fPlayTimePerFrame(playTimePerFrame),
+      fCurrentlyReadSourceNumber(0),
+      fHaveStartedNewFile(False) {
+    // Begin by counting the number of sources (by looking for a terminating 'file name' of NULL):
+    for(fNumSources = 0;; ++fNumSources) {
+        if(fileNameArray[fNumSources] == NULL)
+            break;
+    }
+
+    // Next, copy the source file names into our own array:
+    fFileNameArray = new char const *[fNumSources];
+    if(fFileNameArray == NULL)
+        return;
+    unsigned i;
+    for(i = 0; i < fNumSources; ++i) {
+        fFileNameArray[i] = strDup(fileNameArray[i]);
+    }
+
+    // Next, set up our array of component ByteStreamFileSources
+    // Don't actually create these yet; instead, do this on demand
+    fSourceArray = new ByteStreamFileSource *[fNumSources];
+    if(fSourceArray == NULL)
+        return;
+    for(i = 0; i < fNumSources; ++i) {
+        fSourceArray[i] = NULL;
+    }
+}
+
+ByteStreamMultiFileSource::~ByteStreamMultiFileSource() {
+    unsigned i;
+    for(i = 0; i < fNumSources; ++i) {
+        Medium::close(fSourceArray[i]);
+    }
+    delete[] fSourceArray;
+
+    for(i = 0; i < fNumSources; ++i) {
+        delete[](char *)(fFileNameArray[i]);
+    }
+    delete[] fFileNameArray;
+}
+
+ByteStreamMultiFileSource *ByteStreamMultiFileSource ::createNew(UsageEnvironment &env, char const **fileNameArray, unsigned preferredFrameSize,
+                                                                 unsigned playTimePerFrame) {
+    ByteStreamMultiFileSource *newSource = new ByteStreamMultiFileSource(env, fileNameArray, preferredFrameSize, playTimePerFrame);
+
+    return newSource;
+}
+
+void ByteStreamMultiFileSource::doGetNextFrame() {
+    do {
+        // First, check whether we've run out of sources:
+        if(fCurrentlyReadSourceNumber >= fNumSources)
+            break;
+
+        fHaveStartedNewFile           = False;
+        ByteStreamFileSource *&source = fSourceArray[fCurrentlyReadSourceNumber];
+        if(source == NULL) {
+            // The current source hasn't been created yet.  Do this now:
+            source = ByteStreamFileSource::createNew(envir(), fFileNameArray[fCurrentlyReadSourceNumber], fPreferredFrameSize, fPlayTimePerFrame);
+            if(source == NULL)
+                break;
+            fHaveStartedNewFile = True;
+        }
+
+        // (Attempt to) read from the current source.
+        source->getNextFrame(fTo, fMaxSize, afterGettingFrame, this, onSourceClosure, this);
+        return;
+    } while(0);
+
+    // An error occurred; consider ourselves closed:
+    handleClosure();
+}
+
+void ByteStreamMultiFileSource ::afterGettingFrame(void *clientData, unsigned frameSize, unsigned numTruncatedBytes, struct timeval presentationTime,
+                                                   unsigned durationInMicroseconds) {
+    ByteStreamMultiFileSource *source = (ByteStreamMultiFileSource *)clientData;
+    source->fFrameSize                = frameSize;
+    source->fNumTruncatedBytes        = numTruncatedBytes;
+    source->fPresentationTime         = presentationTime;
+    source->fDurationInMicroseconds   = durationInMicroseconds;
+    FramedSource::afterGetting(source);
+}
+
+void ByteStreamMultiFileSource::onSourceClosure(void *clientData) {
+    ByteStreamMultiFileSource *source = (ByteStreamMultiFileSource *)clientData;
+    source->onSourceClosure1();
+}
+
+void ByteStreamMultiFileSource::onSourceClosure1() {
+    // This routine was called because the currently-read source was closed
+    // (probably due to EOF).  Close this source down, and move to the
+    // next one:
+    ByteStreamFileSource *&source = fSourceArray[fCurrentlyReadSourceNumber++];
+    Medium::close(source);
+    source = NULL;
+
+    // Try reading again:
+    doGetNextFrame();
+}
diff --git a/3rdparty/live555/src/liveMedia/DVVideoFileServerMediaSubsession.cpp b/3rdparty/live555/src/liveMedia/DVVideoFileServerMediaSubsession.cpp
new file mode 100644
index 00000000..3da755ed
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/DVVideoFileServerMediaSubsession.cpp
@@ -0,0 +1,95 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A 'ServerMediaSubsession' object that creates new, unicast, "RTPSink"s
+// on demand, from a DV video file.
+// Implementation
+
+#include "DVVideoFileServerMediaSubsession.hh"
+#include "DVVideoRTPSink.hh"
+#include "ByteStreamFileSource.hh"
+#include "DVVideoStreamFramer.hh"
+
+DVVideoFileServerMediaSubsession *DVVideoFileServerMediaSubsession::createNew(UsageEnvironment &env, char const *fileName, Boolean reuseFirstSource) {
+    return new DVVideoFileServerMediaSubsession(env, fileName, reuseFirstSource);
+}
+
+DVVideoFileServerMediaSubsession ::DVVideoFileServerMediaSubsession(UsageEnvironment &env, char const *fileName, Boolean reuseFirstSource)
+    : FileServerMediaSubsession(env, fileName, reuseFirstSource), fFileDuration(0.0) {}
+
+DVVideoFileServerMediaSubsession::~DVVideoFileServerMediaSubsession() {}
+
+FramedSource *DVVideoFileServerMediaSubsession ::createNewStreamSource(unsigned /*clientSessionId*/, unsigned &estBitrate) {
+    // Create the video source:
+    ByteStreamFileSource *fileSource = ByteStreamFileSource::createNew(envir(), fFileName);
+    if(fileSource == NULL)
+        return NULL;
+    fFileSize = fileSource->fileSize();
+
+    // Create a framer for the Video Elementary Stream:
+    DVVideoStreamFramer *framer = DVVideoStreamFramer::createNew(envir(), fileSource, True /*the file source is seekable*/);
+
+    // Use the framer to figure out the file's duration:
+    unsigned frameSize;
+    double   frameDuration;
+    if(framer->getFrameParameters(frameSize, frameDuration)) {
+        fFileDuration = (float)(((int64_t)fFileSize * frameDuration) / (frameSize * 1000000.0));
+        estBitrate    = (unsigned)((8000.0 * frameSize) / frameDuration);  // in kbps
+    }
+    else {
+        estBitrate = 50000;  // kbps, estimate
+    }
+
+    return framer;
+}
+
+RTPSink *DVVideoFileServerMediaSubsession::createNewRTPSink(Groupsock *rtpGroupsock, unsigned char rtpPayloadTypeIfDynamic, FramedSource * /*inputSource*/) {
+    return DVVideoRTPSink::createNew(envir(), rtpGroupsock, rtpPayloadTypeIfDynamic);
+}
+
+char const *DVVideoFileServerMediaSubsession::getAuxSDPLine(RTPSink *rtpSink, FramedSource *inputSource) {
+    return ((DVVideoRTPSink *)rtpSink)->auxSDPLineFromFramer((DVVideoStreamFramer *)inputSource);
+}
+
+float DVVideoFileServerMediaSubsession::duration() const {
+    return fFileDuration;
+}
+
+void DVVideoFileServerMediaSubsession ::seekStreamSource(FramedSource *inputSource, double &seekNPT, double streamDuration, u_int64_t &numBytes) {
+    // First, get the file source from "inputSource" (a framer):
+    DVVideoStreamFramer * framer     = (DVVideoStreamFramer *)inputSource;
+    ByteStreamFileSource *fileSource = (ByteStreamFileSource *)(framer->inputSource());
+
+    // Then figure out where to seek to within the file:
+    if(fFileDuration > 0.0) {
+        u_int64_t seekByteNumber = (u_int64_t)(((int64_t)fFileSize * seekNPT) / fFileDuration);
+        numBytes                 = (u_int64_t)(((int64_t)fFileSize * streamDuration) / fFileDuration);
+        fileSource->seekToByteAbsolute(seekByteNumber, numBytes);
+    }
+}
+
+void DVVideoFileServerMediaSubsession ::setStreamSourceDuration(FramedSource *inputSource, double streamDuration, u_int64_t &numBytes) {
+    // First, get the file source from "inputSource" (a framer):
+    DVVideoStreamFramer * framer     = (DVVideoStreamFramer *)inputSource;
+    ByteStreamFileSource *fileSource = (ByteStreamFileSource *)(framer->inputSource());
+
+    // Then figure out how many bytes to limit the streaming to:
+    if(fFileDuration > 0.0) {
+        numBytes = (u_int64_t)(((int64_t)fFileSize * streamDuration) / fFileDuration);
+        fileSource->seekToByteRelative(0, numBytes);
+    }
+}
diff --git a/3rdparty/live555/src/liveMedia/DVVideoRTPSink.cpp b/3rdparty/live555/src/liveMedia/DVVideoRTPSink.cpp
new file mode 100644
index 00000000..322f23ab
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/DVVideoRTPSink.cpp
@@ -0,0 +1,89 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// RTP sink for DV video (RFC 3189)
+// (Thanks to Ben Hutchings for prototyping this.)
+// Implementation
+
+#include "DVVideoRTPSink.hh"
+
+////////// DVVideoRTPSink implementation //////////
+
+DVVideoRTPSink ::DVVideoRTPSink(UsageEnvironment &env, Groupsock *RTPgs, unsigned char rtpPayloadFormat)
+    : VideoRTPSink(env, RTPgs, rtpPayloadFormat, 90000, "DV"), fFmtpSDPLine(NULL) {}
+
+DVVideoRTPSink::~DVVideoRTPSink() {
+    delete[] fFmtpSDPLine;
+}
+
+DVVideoRTPSink *DVVideoRTPSink::createNew(UsageEnvironment &env, Groupsock *RTPgs, unsigned char rtpPayloadFormat) {
+    return new DVVideoRTPSink(env, RTPgs, rtpPayloadFormat);
+}
+
+Boolean DVVideoRTPSink::sourceIsCompatibleWithUs(MediaSource &source) {
+    // Our source must be an appropriate framer:
+    return source.isDVVideoStreamFramer();
+}
+
+void DVVideoRTPSink::doSpecialFrameHandling(unsigned       fragmentationOffset, unsigned char * /*frameStart*/, unsigned /*numBytesInFrame*/,
+                                            struct timeval framePresentationTime, unsigned numRemainingBytes) {
+    if(numRemainingBytes == 0) {
+        // This packet contains the last (or only) fragment of the frame.
+        // Set the RTP 'M' ('marker') bit:
+        setMarkerBit();
+    }
+
+    // Also set the RTP timestamp:
+    setTimestamp(framePresentationTime);
+}
+
+unsigned DVVideoRTPSink::computeOverflowForNewFrame(unsigned newFrameSize) const {
+    unsigned initialOverflow = MultiFramedRTPSink::computeOverflowForNewFrame(newFrameSize);
+
+    // Adjust (increase) this overflow, if necessary, so that the amount of frame data that we use is an integral number
+    // of DIF blocks:
+    unsigned numFrameBytesUsed = newFrameSize - initialOverflow;
+    initialOverflow += numFrameBytesUsed % DV_DIF_BLOCK_SIZE;
+
+    return initialOverflow;
+}
+
+char const *DVVideoRTPSink::auxSDPLine() {
+    // Generate a new "a=fmtp:" line each time, using parameters from
+    // our framer source (in case they've changed since the last time that
+    // we were called):
+    DVVideoStreamFramer *framerSource = (DVVideoStreamFramer *)fSource;
+    if(framerSource == NULL)
+        return NULL;  // we don't yet have a source
+
+    return auxSDPLineFromFramer(framerSource);
+}
+
+char const *DVVideoRTPSink::auxSDPLineFromFramer(DVVideoStreamFramer *framerSource) {
+    char const *const profileName = framerSource->profileName();
+    if(profileName == NULL)
+        return NULL;
+
+    char const *const fmtpSDPFmt     = "a=fmtp:%d encode=%s;audio=bundled\r\n";
+    unsigned          fmtpSDPFmtSize = strlen(fmtpSDPFmt) + 3  // max payload format code length
+                              + strlen(profileName);
+    delete[] fFmtpSDPLine;  // if it already exists
+    fFmtpSDPLine = new char[fmtpSDPFmtSize];
+    sprintf(fFmtpSDPLine, fmtpSDPFmt, rtpPayloadType(), profileName);
+
+    return fFmtpSDPLine;
+}
diff --git a/3rdparty/live555/src/liveMedia/DVVideoRTPSource.cpp b/3rdparty/live555/src/liveMedia/DVVideoRTPSource.cpp
new file mode 100644
index 00000000..d2f90d73
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/DVVideoRTPSource.cpp
@@ -0,0 +1,53 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// DV Video RTP Sources
+// Implementation
+
+#include "DVVideoRTPSource.hh"
+
+DVVideoRTPSource *DVVideoRTPSource::createNew(UsageEnvironment &env, Groupsock *RTPgs, unsigned char rtpPayloadFormat, unsigned rtpTimestampFrequency) {
+    return new DVVideoRTPSource(env, RTPgs, rtpPayloadFormat, rtpTimestampFrequency);
+}
+
+DVVideoRTPSource::DVVideoRTPSource(UsageEnvironment &env, Groupsock *rtpGS, unsigned char rtpPayloadFormat, unsigned rtpTimestampFrequency)
+    : MultiFramedRTPSource(env, rtpGS, rtpPayloadFormat, rtpTimestampFrequency) {}
+
+DVVideoRTPSource::~DVVideoRTPSource() {}
+
+#define DV_DIF_BLOCK_SIZE 80
+#define DV_SECTION_HEADER 0x1F
+
+Boolean DVVideoRTPSource ::processSpecialHeader(BufferedPacket *packet, unsigned &resultSpecialHeaderSize) {
+    unsigned const packetSize = packet->dataSize();
+    if(packetSize < DV_DIF_BLOCK_SIZE)
+        return False;  // TARFU!
+
+    u_int8_t const *data      = packet->data();
+    fCurrentPacketBeginsFrame = data[0] == DV_SECTION_HEADER && (data[1] & 0xf8) == 0 && data[2] == 0;  // thanks to Ben Hutchings
+
+    // The RTP "M" (marker) bit indicates the last fragment of a frame:
+    fCurrentPacketCompletesFrame = packet->rtpMarkerBit();
+
+    // There is no special header
+    resultSpecialHeaderSize = 0;
+    return True;
+}
+
+char const *DVVideoRTPSource::MIMEtype() const {
+    return "video/DV";
+}
diff --git a/3rdparty/live555/src/liveMedia/DVVideoStreamFramer.cpp b/3rdparty/live555/src/liveMedia/DVVideoStreamFramer.cpp
new file mode 100644
index 00000000..f9d827cf
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/DVVideoStreamFramer.cpp
@@ -0,0 +1,217 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A filter that parses a DV input stream into DV frames to deliver to the downstream object
+// Implementation
+// (Thanks to Ben Hutchings for his help, including a prototype implementation.)
+
+#include "DVVideoStreamFramer.hh"
+#include "GroupsockHelper.hh"
+
+////////// DVVideoStreamFramer implementation //////////
+
+DVVideoStreamFramer::DVVideoStreamFramer(UsageEnvironment &env, FramedSource *inputSource, Boolean sourceIsSeekable, Boolean leavePresentationTimesUnmodified)
+    : FramedFilter(env, inputSource),
+      fLeavePresentationTimesUnmodified(leavePresentationTimesUnmodified),
+      fOurProfile(NULL),
+      fInitialBlocksPresent(False),
+      fSourceIsSeekable(sourceIsSeekable) {
+    fTo = NULL;  // hack used when reading "fSavedInitialBlocks"
+    // Use the current wallclock time as the initial 'presentation time':
+    gettimeofday(&fNextFramePresentationTime, NULL);
+}
+
+DVVideoStreamFramer::~DVVideoStreamFramer() {}
+
+DVVideoStreamFramer *DVVideoStreamFramer::createNew(UsageEnvironment &env, FramedSource *inputSource, Boolean sourceIsSeekable,
+                                                    Boolean leavePresentationTimesUnmodified) {
+    return new DVVideoStreamFramer(env, inputSource, sourceIsSeekable, leavePresentationTimesUnmodified);
+}
+
+// Define the parameters for the profiles that we understand:
+struct DVVideoProfile {
+    char const *name;
+    unsigned    apt;
+    unsigned    sType;
+    unsigned    sequenceCount;
+    unsigned    channelCount;
+    unsigned    dvFrameSize;    // in bytes (== sequenceCount*channelCount*(DV_NUM_BLOCKS_PER_SEQUENCE*DV_DIF_BLOCK_SIZE i.e. 12000))
+    double      frameDuration;  // duration of the above, in microseconds.  (1000000/this == frame rate)
+};
+
+static DVVideoProfile const profiles[] = { { "SD-VCR/525-60", 0, 0x00, 10, 1, 120000, (1000000 * 1001) / 30000.0 },
+                                           { "SD-VCR/625-50", 0, 0x00, 12, 1, 144000, 1000000 / 25.0 },
+                                           { "314M-25/525-60", 1, 0x00, 10, 1, 120000, (1000000 * 1001) / 30000.0 },
+                                           { "314M-25/625-50", 1, 0x00, 12, 1, 144000, 1000000 / 25.0 },
+                                           { "314M-50/525-60", 1, 0x04, 10, 2, 240000, (1000000 * 1001) / 30000.0 },
+                                           { "314M-50/625-50", 1, 0x04, 12, 2, 288000, 1000000 / 25.0 },
+                                           { "370M/1080-60i", 1, 0x14, 10, 4, 480000, (1000000 * 1001) / 30000.0 },
+                                           { "370M/1080-50i", 1, 0x14, 12, 4, 576000, 1000000 / 25.0 },
+                                           { "370M/720-60p", 1, 0x18, 10, 2, 240000, (1000000 * 1001) / 60000.0 },
+                                           { "370M/720-50p", 1, 0x18, 12, 2, 288000, 1000000 / 50.0 },
+                                           { NULL, 0, 0, 0, 0, 0, 0.0 } };
+
+char const *DVVideoStreamFramer::profileName() {
+    if(fOurProfile == NULL)
+        getProfile();
+
+    return fOurProfile != NULL ? ((DVVideoProfile const *)fOurProfile)->name : NULL;
+}
+
+Boolean DVVideoStreamFramer::getFrameParameters(unsigned &frameSize, double &frameDuration) {
+    if(fOurProfile == NULL)
+        getProfile();
+    if(fOurProfile == NULL)
+        return False;
+
+    frameSize     = ((DVVideoProfile const *)fOurProfile)->dvFrameSize;
+    frameDuration = ((DVVideoProfile const *)fOurProfile)->frameDuration;
+    return True;
+}
+
+void DVVideoStreamFramer::getProfile() {
+    // To determine the stream's profile, we need to first read a chunk of data that we can parse:
+    fInputSource->getNextFrame(fSavedInitialBlocks, DV_SAVED_INITIAL_BLOCKS_SIZE, afterGettingFrame, this, FramedSource::handleClosure, this);
+
+    // Handle events until the requested data arrives:
+    envir().taskScheduler().doEventLoop(&fInitialBlocksPresent);
+}
+
+Boolean DVVideoStreamFramer::isDVVideoStreamFramer() const {
+    return True;
+}
+
+void DVVideoStreamFramer::doGetNextFrame() {
+    fFrameSize = 0;  // initially, until we deliver data
+
+    // If we have saved initial blocks (and won't be seeking back to re-read this data), so use this data first.
+    if(fInitialBlocksPresent && !fSourceIsSeekable) {
+        // For simplicity, we require the downstream object's buffer to be >= this data's size:
+        if(fMaxSize < DV_SAVED_INITIAL_BLOCKS_SIZE) {
+            fNumTruncatedBytes = fMaxSize;
+            afterGetting(this);
+            return;
+        }
+
+        memmove(fTo, fSavedInitialBlocks, DV_SAVED_INITIAL_BLOCKS_SIZE);
+        fFrameSize = DV_SAVED_INITIAL_BLOCKS_SIZE;
+        fTo += DV_SAVED_INITIAL_BLOCKS_SIZE;
+        fInitialBlocksPresent = False;  // for the future
+    }
+
+    // Arrange to read the (rest of the) requested data.
+    // (But first, make sure that we read an integral multiple of the DV block size.)
+    fMaxSize -= fMaxSize % DV_DIF_BLOCK_SIZE;
+    getAndDeliverData();
+}
+
+#define DV_SMALLEST_POSSIBLE_FRAME_SIZE 120000
+
+void DVVideoStreamFramer::getAndDeliverData() {
+    unsigned const totFrameSize      = fOurProfile != NULL ? ((DVVideoProfile const *)fOurProfile)->dvFrameSize : DV_SMALLEST_POSSIBLE_FRAME_SIZE;
+    unsigned       totBytesToDeliver = totFrameSize < fMaxSize ? totFrameSize : fMaxSize;
+    unsigned       numBytesToRead    = totBytesToDeliver - fFrameSize;
+
+    fInputSource->getNextFrame(fTo, numBytesToRead, afterGettingFrame, this, FramedSource::handleClosure, this);
+}
+
+void DVVideoStreamFramer::afterGettingFrame(void *clientData, unsigned frameSize, unsigned numTruncatedBytes, struct timeval presentationTime,
+                                            unsigned /*durationInMicroseconds*/) {
+    DVVideoStreamFramer *source = (DVVideoStreamFramer *)clientData;
+    source->afterGettingFrame(frameSize, numTruncatedBytes, presentationTime);
+}
+
+#define DVSectionId(n) ptr[(n)*DV_DIF_BLOCK_SIZE + 0]
+#define DVData(n, i) ptr[(n)*DV_DIF_BLOCK_SIZE + 3 + (i)]
+
+#define DV_SECTION_HEADER 0x1F
+#define DV_PACK_HEADER_10 0x3F
+#define DV_PACK_HEADER_12 0xBF
+#define DV_SECTION_VAUX_MIN 0x50
+#define DV_SECTION_VAUX_MAX 0x5F
+#define DV_PACK_VIDEO_SOURCE 60
+#ifndef MILLION
+#define MILLION 1000000
+#endif
+
+void DVVideoStreamFramer::afterGettingFrame(unsigned frameSize, unsigned numTruncatedBytes, struct timeval presentationTime) {
+    if(fOurProfile == NULL && frameSize >= DV_SAVED_INITIAL_BLOCKS_SIZE) {
+        // (Try to) parse this data enough to figure out its profile.
+        // We assume that the data begins on a (80-byte) block boundary, but not necessarily on a (150-block) sequence boundary.
+        // We therefore scan each 80-byte block, until we find the 6-block header that begins a sequence:
+        u_int8_t const *data = (fTo == NULL) ? fSavedInitialBlocks : fTo;
+        for(u_int8_t const *ptr = data; ptr + 6 * DV_DIF_BLOCK_SIZE <= &data[DV_SAVED_INITIAL_BLOCKS_SIZE]; ptr += DV_DIF_BLOCK_SIZE) {
+            // Check whether "ptr" points to an appropriate header:
+            u_int8_t const sectionHeader = DVSectionId(0);
+            u_int8_t const sectionVAUX   = DVSectionId(5);
+            u_int8_t const packHeaderNum = DVData(0, 0);
+
+            if(sectionHeader == DV_SECTION_HEADER && (packHeaderNum == DV_PACK_HEADER_10 || packHeaderNum == DV_PACK_HEADER_12)
+               && (sectionVAUX >= DV_SECTION_VAUX_MIN && sectionVAUX <= DV_SECTION_VAUX_MAX)) {
+                // This data begins a sequence; look up the DV profile from this:
+                u_int8_t const apt           = DVData(0, 1) & 0x07;
+                u_int8_t const sType         = DVData(5, 48) & 0x1F;
+                u_int8_t const sequenceCount = (packHeaderNum == DV_PACK_HEADER_10) ? 10 : 12;
+
+                // Use these three parameters (apt, sType, sequenceCount) to look up the DV profile:
+                for(DVVideoProfile const *profile = profiles; profile->name != NULL; ++profile) {
+                    if(profile->apt == apt && profile->sType == sType && profile->sequenceCount == sequenceCount) {
+                        fOurProfile = profile;
+                        break;
+                    }
+                }
+                break;  // because we found a correct sequence header (even if we don't happen to define a profile for it)
+            }
+        }
+    }
+
+    if(fTo != NULL) {  // There is a downstream object; complete delivery to it (or read more data, if necessary)
+        unsigned const totFrameSize = fOurProfile != NULL ? ((DVVideoProfile const *)fOurProfile)->dvFrameSize : DV_SMALLEST_POSSIBLE_FRAME_SIZE;
+        fFrameSize += frameSize;
+        fTo += frameSize;
+        fPresentationTime = presentationTime;  // by default; may get changed below
+
+        if(fFrameSize < totFrameSize && fFrameSize < fMaxSize && numTruncatedBytes == 0) {
+            // We have more data to deliver; get it now:
+            getAndDeliverData();
+        }
+        else {
+            // We're done delivering this DV frame (but check for truncation):
+            fNumTruncatedBytes = totFrameSize - fFrameSize;
+
+            if(fOurProfile != NULL) {
+                // Also set the presentation time, and increment it for next time,
+                // based on the length of this frame:
+                if(!fLeavePresentationTimesUnmodified)
+                    fPresentationTime = fNextFramePresentationTime;
+
+                DVVideoProfile const *ourProfile             = (DVVideoProfile const *)fOurProfile;
+                double                durationInMicroseconds = (fFrameSize * ourProfile->frameDuration) / ourProfile->dvFrameSize;
+                fDurationInMicroseconds                      = (unsigned)durationInMicroseconds;
+                fNextFramePresentationTime.tv_usec += fDurationInMicroseconds;
+                fNextFramePresentationTime.tv_sec += fNextFramePresentationTime.tv_usec / MILLION;
+                fNextFramePresentationTime.tv_usec %= MILLION;
+            }
+
+            afterGetting(this);
+        }
+    }
+    else {
+        // We read data into our special buffer; signal that it has arrived:
+        fInitialBlocksPresent = True;
+    }
+}
diff --git a/3rdparty/live555/src/liveMedia/DeviceSource.cpp b/3rdparty/live555/src/liveMedia/DeviceSource.cpp
new file mode 100644
index 00000000..8af63581
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/DeviceSource.cpp
@@ -0,0 +1,153 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A template for a MediaSource encapsulating an audio/video input device
+//
+// NOTE: Sections of this code labeled "%%% TO BE WRITTEN %%%" are incomplete, and need to be written by the programmer
+// (depending on the features of the particular device).
+// Implementation
+
+#include "DeviceSource.hh"
+#include <GroupsockHelper.hh>  // for "gettimeofday()"
+
+DeviceSource *DeviceSource::createNew(UsageEnvironment &env, DeviceParameters params) {
+    return new DeviceSource(env, params);
+}
+
+EventTriggerId DeviceSource::eventTriggerId = 0;
+
+unsigned DeviceSource::referenceCount = 0;
+
+DeviceSource::DeviceSource(UsageEnvironment &env, DeviceParameters params) : FramedSource(env), fParams(params) {
+    if(referenceCount == 0) {
+        // Any global initialization of the device would be done here:
+        //%%% TO BE WRITTEN %%%
+    }
+    ++referenceCount;
+
+    // Any instance-specific initialization of the device would be done here:
+    //%%% TO BE WRITTEN %%%
+
+    // We arrange here for our "deliverFrame" member function to be called
+    // whenever the next frame of data becomes available from the device.
+    //
+    // If the device can be accessed as a readable socket, then one easy way to do this is using a call to
+    //     envir().taskScheduler().turnOnBackgroundReadHandling( ... )
+    // (See examples of this call in the "liveMedia" directory.)
+    //
+    // If, however, the device *cannot* be accessed as a readable socket, then instead we can implement it using 'event triggers':
+    // Create an 'event trigger' for this device (if it hasn't already been done):
+    if(eventTriggerId == 0) {
+        eventTriggerId = envir().taskScheduler().createEventTrigger(deliverFrame0);
+    }
+}
+
+DeviceSource::~DeviceSource() {
+    // Any instance-specific 'destruction' (i.e., resetting) of the device would be done here:
+    //%%% TO BE WRITTEN %%%
+
+    --referenceCount;
+    if(referenceCount == 0) {
+        // Any global 'destruction' (i.e., resetting) of the device would be done here:
+        //%%% TO BE WRITTEN %%%
+
+        // Reclaim our 'event trigger'
+        envir().taskScheduler().deleteEventTrigger(eventTriggerId);
+        eventTriggerId = 0;
+    }
+}
+
+void DeviceSource::doGetNextFrame() {
+    // This function is called (by our 'downstream' object) when it asks for new data.
+
+    // Note: If, for some reason, the source device stops being readable (e.g., it gets closed), then you do the following:
+    if(0 /* the source stops being readable */ /*%%% TO BE WRITTEN %%%*/) {
+        handleClosure();
+        return;
+    }
+
+    // If a new frame of data is immediately available to be delivered, then do this now:
+    if(0 /* a new frame of data is immediately available to be delivered*/ /*%%% TO BE WRITTEN %%%*/) {
+        deliverFrame();
+    }
+
+    // No new data is immediately available to be delivered.  We don't do anything more here.
+    // Instead, our event trigger must be called (e.g., from a separate thread) when new data becomes available.
+}
+
+void DeviceSource::deliverFrame0(void *clientData) {
+    ((DeviceSource *)clientData)->deliverFrame();
+}
+
+void DeviceSource::deliverFrame() {
+    // This function is called when new frame data is available from the device.
+    // We deliver this data by copying it to the 'downstream' object, using the following parameters (class members):
+    // 'in' parameters (these should *not* be modified by this function):
+    //     fTo: The frame data is copied to this address.
+    //         (Note that the variable "fTo" is *not* modified.  Instead,
+    //          the frame data is copied to the address pointed to by "fTo".)
+    //     fMaxSize: This is the maximum number of bytes that can be copied
+    //         (If the actual frame is larger than this, then it should
+    //          be truncated, and "fNumTruncatedBytes" set accordingly.)
+    // 'out' parameters (these are modified by this function):
+    //     fFrameSize: Should be set to the delivered frame size (<= fMaxSize).
+    //     fNumTruncatedBytes: Should be set iff the delivered frame would have been
+    //         bigger than "fMaxSize", in which case it's set to the number of bytes
+    //         that have been omitted.
+    //     fPresentationTime: Should be set to the frame's presentation time
+    //         (seconds, microseconds).  This time must be aligned with 'wall-clock time' - i.e., the time that you would get
+    //         by calling "gettimeofday()".
+    //     fDurationInMicroseconds: Should be set to the frame's duration, if known.
+    //         If, however, the device is a 'live source' (e.g., encoded from a camera or microphone), then we probably don't need
+    //         to set this variable, because - in this case - data will never arrive 'early'.
+    // Note the code below.
+
+    if(!isCurrentlyAwaitingData())
+        return;  // we're not ready for the data yet
+
+    u_int8_t *newFrameDataStart = (u_int8_t *)0xDEADBEEF;  //%%% TO BE WRITTEN %%%
+    unsigned  newFrameSize      = 0;                       //%%% TO BE WRITTEN %%%
+
+    // Deliver the data here:
+    if(newFrameSize > fMaxSize) {
+        fFrameSize         = fMaxSize;
+        fNumTruncatedBytes = newFrameSize - fMaxSize;
+    }
+    else {
+        fFrameSize = newFrameSize;
+    }
+    gettimeofday(&fPresentationTime, NULL);  // If you have a more accurate time - e.g., from an encoder - then use that instead.
+    // If the device is *not* a 'live source' (e.g., it comes instead from a file or buffer), then set "fDurationInMicroseconds" here.
+    memmove(fTo, newFrameDataStart, fFrameSize);
+
+    // After delivering the data, inform the reader that it is now available:
+    FramedSource::afterGetting(this);
+}
+
+// The following code would be called to signal that a new frame of data has become available.
+// This (unlike other "LIVE555 Streaming Media" library code) may be called from a separate thread.
+// (Note, however, that "triggerEvent()" cannot be called with the same 'event trigger id' from different threads.
+// Also, if you want to have multiple device threads, each one using a different 'event trigger id', then you will need
+// to make "eventTriggerId" a non-static member variable of "DeviceSource".)
+void signalNewFrameData() {
+    TaskScheduler *ourScheduler = NULL;  //%%% TO BE WRITTEN %%%
+    DeviceSource * ourDevice    = NULL;  //%%% TO BE WRITTEN %%%
+
+    if(ourScheduler != NULL) {  // sanity check
+        ourScheduler->triggerEvent(DeviceSource::eventTriggerId, ourDevice);
+    }
+}
diff --git a/3rdparty/live555/src/liveMedia/DigestAuthentication.cpp b/3rdparty/live555/src/liveMedia/DigestAuthentication.cpp
new file mode 100644
index 00000000..8ab607a6
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/DigestAuthentication.cpp
@@ -0,0 +1,170 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A class used for digest authentication.
+// Implementation
+
+#include "DigestAuthentication.hh"
+#include "ourMD5.hh"
+#include <strDup.hh>
+#include <GroupsockHelper.hh>  // for gettimeofday()
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+Authenticator::Authenticator() {
+    assign(NULL, NULL, NULL, NULL, False);
+}
+
+Authenticator::Authenticator(char const *username, char const *password, Boolean passwordIsMD5) {
+    assign(NULL, NULL, username, password, passwordIsMD5);
+}
+
+Authenticator::Authenticator(const Authenticator &orig) {
+    assign(orig.realm(), orig.nonce(), orig.username(), orig.password(), orig.fPasswordIsMD5);
+}
+
+Authenticator &Authenticator::operator=(const Authenticator &rightSide) {
+    if(&rightSide != this) {
+        reset();
+        assign(rightSide.realm(), rightSide.nonce(), rightSide.username(), rightSide.password(), rightSide.fPasswordIsMD5);
+    }
+
+    return *this;
+}
+
+Boolean Authenticator::operator<(const Authenticator *rightSide) {
+    // Returns True if "rightSide" is 'newer' than us:
+    if(rightSide != NULL && rightSide != this
+       && (rightSide->realm() != NULL || rightSide->nonce() != NULL || username() == NULL || password() == NULL
+           || strcmp(rightSide->username(), username()) != 0 || strcmp(rightSide->password(), password()) != 0)) {
+        return True;
+    }
+
+    return False;
+}
+
+Authenticator::~Authenticator() {
+    reset();
+}
+
+void Authenticator::reset() {
+    resetRealmAndNonce();
+    resetUsernameAndPassword();
+}
+
+void Authenticator::setRealmAndNonce(char const *realm, char const *nonce) {
+    resetRealmAndNonce();
+    assignRealmAndNonce(realm, nonce);
+}
+
+void Authenticator::setRealmAndRandomNonce(char const *realm) {
+    resetRealmAndNonce();
+
+    // Construct data to seed the random nonce:
+    struct {
+        struct timeval timestamp;
+        unsigned       counter;
+    } seedData;
+    gettimeofday(&seedData.timestamp, NULL);
+    static unsigned counter = 0;
+    seedData.counter        = ++counter;
+
+    // Use MD5 to compute a 'random' nonce from this seed data:
+    char nonceBuf[33];
+    our_MD5Data((unsigned char *)(&seedData), sizeof seedData, nonceBuf);
+
+    assignRealmAndNonce(realm, nonceBuf);
+}
+
+void Authenticator::setUsernameAndPassword(char const *username, char const *password, Boolean passwordIsMD5) {
+    resetUsernameAndPassword();
+    assignUsernameAndPassword(username, password, passwordIsMD5);
+}
+
+char const *Authenticator::computeDigestResponse(char const *cmd, char const *url) const {
+    // The "response" field is computed as:
+    //    md5(md5(<username>:<realm>:<password>):<nonce>:md5(<cmd>:<url>))
+    // or, if "fPasswordIsMD5" is True:
+    //    md5(<password>:<nonce>:md5(<cmd>:<url>))
+    char ha1Buf[33];
+    if(fPasswordIsMD5) {
+        strncpy(ha1Buf, password(), 32);
+        ha1Buf[32] = '\0';  // just in case
+    }
+    else {
+        unsigned const ha1DataLen = strlen(username()) + 1 + strlen(realm()) + 1 + strlen(password());
+        unsigned char *ha1Data    = new unsigned char[ha1DataLen + 1];
+        sprintf((char *)ha1Data, "%s:%s:%s", username(), realm(), password());
+        our_MD5Data(ha1Data, ha1DataLen, ha1Buf);
+        delete[] ha1Data;
+    }
+
+    unsigned const ha2DataLen = strlen(cmd) + 1 + strlen(url);
+    unsigned char *ha2Data    = new unsigned char[ha2DataLen + 1];
+    sprintf((char *)ha2Data, "%s:%s", cmd, url);
+    char ha2Buf[33];
+    our_MD5Data(ha2Data, ha2DataLen, ha2Buf);
+    delete[] ha2Data;
+
+    unsigned const digestDataLen = 32 + 1 + strlen(nonce()) + 1 + 32;
+    unsigned char *digestData    = new unsigned char[digestDataLen + 1];
+    sprintf((char *)digestData, "%s:%s:%s", ha1Buf, nonce(), ha2Buf);
+    char const *result = our_MD5Data(digestData, digestDataLen, NULL);
+    delete[] digestData;
+    return result;
+}
+
+void Authenticator::reclaimDigestResponse(char const *responseStr) const {
+    delete[](char *) responseStr;
+}
+
+void Authenticator::resetRealmAndNonce() {
+    delete[] fRealm;
+    fRealm = NULL;
+    delete[] fNonce;
+    fNonce = NULL;
+}
+
+void Authenticator::resetUsernameAndPassword() {
+    delete[] fUsername;
+    fUsername = NULL;
+    delete[] fPassword;
+    fPassword      = NULL;
+    fPasswordIsMD5 = False;
+}
+
+void Authenticator::assignRealmAndNonce(char const *realm, char const *nonce) {
+    fRealm = strDup(realm);
+    fNonce = strDup(nonce);
+}
+
+void Authenticator::assignUsernameAndPassword(char const *username, char const *password, Boolean passwordIsMD5) {
+    if(username == NULL)
+        username = "";
+    if(password == NULL)
+        password = "";
+
+    fUsername      = strDup(username);
+    fPassword      = strDup(password);
+    fPasswordIsMD5 = passwordIsMD5;
+}
+
+void Authenticator::assign(char const *realm, char const *nonce, char const *username, char const *password, Boolean passwordIsMD5) {
+    assignRealmAndNonce(realm, nonce);
+    assignUsernameAndPassword(username, password, passwordIsMD5);
+}
diff --git a/3rdparty/live555/src/liveMedia/EBMLNumber.cpp b/3rdparty/live555/src/liveMedia/EBMLNumber.cpp
new file mode 100644
index 00000000..26eec444
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/EBMLNumber.cpp
@@ -0,0 +1,303 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// EBML numbers (ids and sizes)
+// Implementation
+
+#include "EBMLNumber.hh"
+
+EBMLNumber::EBMLNumber(Boolean stripLeading1) : stripLeading1(stripLeading1), len(0) {}
+
+EBMLNumber::~EBMLNumber() {}
+
+char *EBMLNumber::hexString() const {
+    static char printBuf[2 * EBML_NUMBER_MAX_LEN + 1];
+
+    char *to = printBuf;
+    for(unsigned i = 0; i < len; ++i) {
+        sprintf(to, "%02X", data[i]);
+        to += 2;
+    }
+
+    return printBuf;
+}
+
+u_int64_t EBMLNumber::val() const {
+    u_int64_t result = 0;
+
+    for(unsigned i = 0; i < len; ++i) {
+        result = result * 256 + data[i];
+    }
+
+    return result;
+}
+
+EBMLId::EBMLId() : EBMLNumber(False) {}
+
+EBMLId::~EBMLId() {}
+
+char const *EBMLId::stringName() const {
+    switch(val()) {
+    case MATROSKA_ID_EBML: {
+        return "EBML";
+    }
+    case MATROSKA_ID_VOID: {
+        return "Void";
+    }
+    case MATROSKA_ID_CRC_32: {
+        return "CRC-32";
+    }
+    case MATROSKA_ID_SEGMENT: {
+        return "Segment";
+    }
+    case MATROSKA_ID_SEEK_HEAD: {
+        return "Seek Head";
+    }
+    case MATROSKA_ID_SEEK: {
+        return "Seek";
+    }
+    case MATROSKA_ID_SEEK_ID: {
+        return "Seek ID";
+    }
+    case MATROSKA_ID_SEEK_POSITION: {
+        return "Seek Position";
+    }
+    case MATROSKA_ID_INFO: {
+        return "Segment Info";
+    }
+    case MATROSKA_ID_SEGMENT_UID: {
+        return "Segment UID";
+    }
+    case MATROSKA_ID_DURATION: {
+        return "Segment Duration";
+    }
+    case MATROSKA_ID_TIMECODE_SCALE: {
+        return "Timecode Scale";
+    }
+    case MATROSKA_ID_DATE_UTC: {
+        return "Date (UTC)";
+    }
+    case MATROSKA_ID_TITLE: {
+        return "Title";
+    }
+    case MATROSKA_ID_MUXING_APP: {
+        return "Muxing App";
+    }
+    case MATROSKA_ID_WRITING_APP: {
+        return "Writing App";
+    }
+    case MATROSKA_ID_CLUSTER: {
+        return "Cluster";
+    }
+    case MATROSKA_ID_TIMECODE: {
+        return "TimeCode";
+    }
+    case MATROSKA_ID_POSITION: {
+        return "Position";
+    }
+    case MATROSKA_ID_PREV_SIZE: {
+        return "Prev. Size";
+    }
+    case MATROSKA_ID_SIMPLEBLOCK: {
+        return "SimpleBlock";
+    }
+    case MATROSKA_ID_BLOCK_GROUP: {
+        return "Block Group";
+    }
+    case MATROSKA_ID_BLOCK: {
+        return "Block";
+    }
+    case MATROSKA_ID_BLOCK_DURATION: {
+        return "Block Duration";
+    }
+    case MATROSKA_ID_REFERENCE_BLOCK: {
+        return "Reference Block";
+    }
+    case MATROSKA_ID_TRACKS: {
+        return "Tracks";
+    }
+    case MATROSKA_ID_TRACK_ENTRY: {
+        return "Track Entry";
+    }
+    case MATROSKA_ID_TRACK_NUMBER: {
+        return "Track Number";
+    }
+    case MATROSKA_ID_TRACK_UID: {
+        return "Track UID";
+    }
+    case MATROSKA_ID_TRACK_TYPE: {
+        return "Track Type";
+    }
+    case MATROSKA_ID_FLAG_ENABLED: {
+        return "Flag Enabled";
+    }
+    case MATROSKA_ID_FLAG_DEFAULT: {
+        return "Flag Default";
+    }
+    case MATROSKA_ID_FLAG_FORCED: {
+        return "Flag Forced";
+    }
+    case MATROSKA_ID_FLAG_LACING: {
+        return "Flag Lacing";
+    }
+    case MATROSKA_ID_MIN_CACHE: {
+        return "Min Cache";
+    }
+    case MATROSKA_ID_DEFAULT_DURATION: {
+        return "Default Duration";
+    }
+    case MATROSKA_ID_TRACK_TIMECODE_SCALE: {
+        return "Track Timecode Scale";
+    }
+    case MATROSKA_ID_MAX_BLOCK_ADDITION_ID: {
+        return "Max Block Addition ID";
+    }
+    case MATROSKA_ID_NAME: {
+        return "Name";
+    }
+    case MATROSKA_ID_LANGUAGE: {
+        return "Language";
+    }
+    case MATROSKA_ID_CODEC: {
+        return "Codec ID";
+    }
+    case MATROSKA_ID_CODEC_PRIVATE: {
+        return "Codec Private";
+    }
+    case MATROSKA_ID_CODEC_NAME: {
+        return "Codec Name";
+    }
+    case MATROSKA_ID_CODEC_DECODE_ALL: {
+        return "Codec Decode All";
+    }
+    case MATROSKA_ID_VIDEO: {
+        return "Video Settings";
+    }
+    case MATROSKA_ID_FLAG_INTERLACED: {
+        return "Flag Interlaced";
+    }
+    case MATROSKA_ID_PIXEL_WIDTH: {
+        return "Pixel Width";
+    }
+    case MATROSKA_ID_PIXEL_HEIGHT: {
+        return "Pixel Height";
+    }
+    case MATROSKA_ID_DISPLAY_WIDTH: {
+        return "Display Width";
+    }
+    case MATROSKA_ID_DISPLAY_HEIGHT: {
+        return "Display Height";
+    }
+    case MATROSKA_ID_DISPLAY_UNIT: {
+        return "Display Unit";
+    }
+    case MATROSKA_ID_AUDIO: {
+        return "Audio Settings";
+    }
+    case MATROSKA_ID_SAMPLING_FREQUENCY: {
+        return "Sampling Frequency";
+    }
+    case MATROSKA_ID_OUTPUT_SAMPLING_FREQUENCY: {
+        return "Output Sampling Frequency";
+    }
+    case MATROSKA_ID_CHANNELS: {
+        return "Channels";
+    }
+    case MATROSKA_ID_BIT_DEPTH: {
+        return "Bit Depth";
+    }
+    case MATROSKA_ID_CONTENT_ENCODINGS: {
+        return "Content Encodings";
+    }
+    case MATROSKA_ID_CONTENT_ENCODING: {
+        return "Content Encoding";
+    }
+    case MATROSKA_ID_CONTENT_COMPRESSION: {
+        return "Content Compression";
+    }
+    case MATROSKA_ID_CONTENT_COMP_ALGO: {
+        return "Content Compression Algorithm";
+    }
+    case MATROSKA_ID_CONTENT_COMP_SETTINGS: {
+        return "Content Compression Settings";
+    }
+    case MATROSKA_ID_CONTENT_ENCRYPTION: {
+        return "Content Encryption";
+    }
+    case MATROSKA_ID_ATTACHMENTS: {
+        return "Attachments";
+    }
+    case MATROSKA_ID_ATTACHED_FILE: {
+        return "Attached File";
+    }
+    case MATROSKA_ID_FILE_DESCRIPTION: {
+        return "File Description";
+    }
+    case MATROSKA_ID_FILE_NAME: {
+        return "File Name";
+    }
+    case MATROSKA_ID_FILE_MIME_TYPE: {
+        return "File MIME Type";
+    }
+    case MATROSKA_ID_FILE_DATA: {
+        return "File Data";
+    }
+    case MATROSKA_ID_FILE_UID: {
+        return "File UID";
+    }
+    case MATROSKA_ID_CUES: {
+        return "Cues";
+    }
+    case MATROSKA_ID_CUE_POINT: {
+        return "Cue Point";
+    }
+    case MATROSKA_ID_CUE_TIME: {
+        return "Cue Time";
+    }
+    case MATROSKA_ID_CUE_TRACK_POSITIONS: {
+        return "Cue Track Positions";
+    }
+    case MATROSKA_ID_CUE_TRACK: {
+        return "Cue Track";
+    }
+    case MATROSKA_ID_CUE_CLUSTER_POSITION: {
+        return "Cue Cluster Position";
+    }
+    case MATROSKA_ID_CUE_BLOCK_NUMBER: {
+        return "Cue Block Number";
+    }
+    case MATROSKA_ID_TAGS: {
+        return "Tags";
+    }
+    case MATROSKA_ID_SEEK_PRE_ROLL: {
+        return "SeekPreRoll";
+    }
+    case MATROSKA_ID_CODEC_DELAY: {
+        return "CodecDelay";
+    }
+    case MATROSKA_ID_DISCARD_PADDING: {
+        return "DiscardPadding";
+    }
+    default: {
+        return "*****unknown*****";
+    }
+    }
+}
+
+EBMLDataSize::EBMLDataSize() : EBMLNumber(True) {}
+
+EBMLDataSize::~EBMLDataSize() {}
diff --git a/3rdparty/live555/src/liveMedia/EBMLNumber.hh b/3rdparty/live555/src/liveMedia/EBMLNumber.hh
new file mode 100644
index 00000000..78c956cb
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/EBMLNumber.hh
@@ -0,0 +1,144 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// EBML numbers (ids and sizes)
+// C++ header
+
+#ifndef _EBML_NUMBER_HH
+#define _EBML_NUMBER_HH
+
+#include "NetCommon.h"
+#include "Boolean.hh"
+#include <stdio.h>
+
+#define EBML_NUMBER_MAX_LEN 8
+
+class EBMLNumber {
+public:
+  EBMLNumber(Boolean stripLeading1 = True);
+  virtual ~EBMLNumber();
+
+  u_int64_t val() const;  
+  char* hexString() const; // used for debugging
+  Boolean operator==(u_int64_t arg2) const { return val() == arg2; }
+  Boolean operator!=(u_int64_t arg2) const { return !(*this == arg2); }
+
+public:
+  Boolean stripLeading1;
+  unsigned len;
+  u_int8_t data[EBML_NUMBER_MAX_LEN];
+};
+
+// Definitions of some Matroska/EBML IDs (including the ones that we check for):
+#define MATROSKA_ID_EBML 0x1A45DFA3
+#define MATROSKA_ID_VOID 0xEC
+#define MATROSKA_ID_CRC_32 0xBF
+#define MATROSKA_ID_SEGMENT 0x18538067
+#define MATROSKA_ID_SEEK_HEAD 0x114D9B74
+#define MATROSKA_ID_SEEK 0x4DBB
+#define MATROSKA_ID_SEEK_ID 0x53AB
+#define MATROSKA_ID_SEEK_POSITION 0x53AC
+#define MATROSKA_ID_INFO 0x1549A966
+#define MATROSKA_ID_SEGMENT_UID 0x73A4
+#define MATROSKA_ID_TIMECODE_SCALE 0x2AD7B1
+#define MATROSKA_ID_DURATION 0x4489
+#define MATROSKA_ID_DATE_UTC 0x4461
+#define MATROSKA_ID_TITLE 0x7BA9
+#define MATROSKA_ID_MUXING_APP 0x4D80
+#define MATROSKA_ID_WRITING_APP 0x5741
+#define MATROSKA_ID_CLUSTER 0x1F43B675
+#define MATROSKA_ID_TIMECODE 0xE7
+#define MATROSKA_ID_POSITION 0xA7
+#define MATROSKA_ID_PREV_SIZE 0xAB
+#define MATROSKA_ID_SIMPLEBLOCK 0xA3
+#define MATROSKA_ID_BLOCK_GROUP 0xA0
+#define MATROSKA_ID_BLOCK 0xA1
+#define MATROSKA_ID_BLOCK_DURATION 0x9B
+#define MATROSKA_ID_REFERENCE_BLOCK 0xFB
+#define MATROSKA_ID_TRACKS 0x1654AE6B
+#define MATROSKA_ID_TRACK_ENTRY 0xAE
+#define MATROSKA_ID_TRACK_NUMBER 0xD7
+#define MATROSKA_ID_TRACK_UID 0x73C5
+#define MATROSKA_ID_TRACK_TYPE 0x83
+#define MATROSKA_ID_FLAG_ENABLED 0xB9
+#define MATROSKA_ID_FLAG_DEFAULT 0x88
+#define MATROSKA_ID_FLAG_FORCED 0x55AA
+#define MATROSKA_ID_FLAG_LACING 0x9C
+#define MATROSKA_ID_MIN_CACHE 0x6DE7
+#define MATROSKA_ID_DEFAULT_DURATION 0x23E383
+#define MATROSKA_ID_TRACK_TIMECODE_SCALE 0x23314F
+#define MATROSKA_ID_MAX_BLOCK_ADDITION_ID 0x55EE
+#define MATROSKA_ID_NAME 0x536E
+#define MATROSKA_ID_LANGUAGE 0x22B59C
+#define MATROSKA_ID_CODEC 0x86
+#define MATROSKA_ID_CODEC_PRIVATE 0x63A2
+#define MATROSKA_ID_CODEC_NAME 0x258688
+#define MATROSKA_ID_CODEC_DECODE_ALL 0xAA
+#define MATROSKA_ID_VIDEO 0xE0
+#define MATROSKA_ID_FLAG_INTERLACED 0x9A
+#define MATROSKA_ID_PIXEL_WIDTH 0xB0
+#define MATROSKA_ID_PIXEL_HEIGHT 0xBA
+#define MATROSKA_ID_DISPLAY_WIDTH 0x54B0
+#define MATROSKA_ID_DISPLAY_HEIGHT 0x54BA
+#define MATROSKA_ID_DISPLAY_UNIT 0x54B2
+#define MATROSKA_ID_AUDIO 0xE1
+#define MATROSKA_ID_SAMPLING_FREQUENCY 0xB5
+#define MATROSKA_ID_OUTPUT_SAMPLING_FREQUENCY 0x78B5
+#define MATROSKA_ID_CHANNELS 0x9F
+#define MATROSKA_ID_BIT_DEPTH 0x6264
+#define MATROSKA_ID_CONTENT_ENCODINGS 0x6D80
+#define MATROSKA_ID_CONTENT_ENCODING 0x6240
+#define MATROSKA_ID_CONTENT_COMPRESSION 0x5034
+#define MATROSKA_ID_CONTENT_COMP_ALGO 0x4254
+#define MATROSKA_ID_CONTENT_COMP_SETTINGS 0x4255
+#define MATROSKA_ID_CONTENT_ENCRYPTION 0x5035
+#define MATROSKA_ID_ATTACHMENTS 0x1941A469
+#define MATROSKA_ID_ATTACHED_FILE 0x61A7
+#define MATROSKA_ID_FILE_DESCRIPTION 0x467E
+#define MATROSKA_ID_FILE_NAME 0x466E
+#define MATROSKA_ID_FILE_MIME_TYPE 0x4660
+#define MATROSKA_ID_FILE_DATA 0x465C
+#define MATROSKA_ID_FILE_UID 0x46AE
+#define MATROSKA_ID_CUES 0x1C53BB6B
+#define MATROSKA_ID_CUE_POINT 0xBB
+#define MATROSKA_ID_CUE_TIME 0xB3
+#define MATROSKA_ID_CUE_TRACK_POSITIONS 0xB7
+#define MATROSKA_ID_CUE_TRACK 0xF7
+#define MATROSKA_ID_CUE_CLUSTER_POSITION 0xF1
+#define MATROSKA_ID_CUE_BLOCK_NUMBER 0x5378
+#define MATROSKA_ID_TAGS 0x1254C367
+#define MATROSKA_ID_SEEK_PRE_ROLL 0x56BB
+#define MATROSKA_ID_CODEC_DELAY 0x56AA
+#define MATROSKA_ID_DISCARD_PADDING 0x75A2
+#define MATROSKA_ID_COLOR_SPACE 0x2EB524
+#define MATROSKA_ID_PRIMARIES 0x55BB
+
+class EBMLId: public EBMLNumber {
+public:
+  EBMLId();
+  virtual ~EBMLId();
+
+  char const* stringName() const; // used for debugging
+};
+
+class EBMLDataSize: public EBMLNumber {
+public:
+  EBMLDataSize();
+  virtual ~EBMLDataSize();
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/FileServerMediaSubsession.cpp b/3rdparty/live555/src/liveMedia/FileServerMediaSubsession.cpp
new file mode 100644
index 00000000..0cbd509b
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/FileServerMediaSubsession.cpp
@@ -0,0 +1,31 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A 'ServerMediaSubsession' object that creates new, unicast, "RTPSink"s
+// on demand, from a file.
+// Implementation
+
+#include "FileServerMediaSubsession.hh"
+
+FileServerMediaSubsession ::FileServerMediaSubsession(UsageEnvironment &env, char const *fileName, Boolean reuseFirstSource)
+    : OnDemandServerMediaSubsession(env, reuseFirstSource), fFileSize(0) {
+    fFileName = strDup(fileName);
+}
+
+FileServerMediaSubsession::~FileServerMediaSubsession() {
+    delete[](char *) fFileName;
+}
diff --git a/3rdparty/live555/src/liveMedia/FileSink.cpp b/3rdparty/live555/src/liveMedia/FileSink.cpp
new file mode 100644
index 00000000..0fa846fa
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/FileSink.cpp
@@ -0,0 +1,150 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// File sinks
+// Implementation
+
+#if(defined(__WIN32__) || defined(_WIN32)) && !defined(_WIN32_WCE)
+#include <io.h>
+#include <fcntl.h>
+#endif
+#include "FileSink.hh"
+#include "GroupsockHelper.hh"
+#include "OutputFile.hh"
+
+////////// FileSink //////////
+
+FileSink::FileSink(UsageEnvironment &env, FILE *fid, unsigned bufferSize, char const *perFrameFileNamePrefix)
+    : MediaSink(env), fOutFid(fid), fBufferSize(bufferSize), fSamePresentationTimeCounter(0) {
+    fBuffer = new unsigned char[bufferSize];
+    if(perFrameFileNamePrefix != NULL) {
+        fPerFrameFileNamePrefix = strDup(perFrameFileNamePrefix);
+        fPerFrameFileNameBuffer = new char[strlen(perFrameFileNamePrefix) + 100];
+    }
+    else {
+        fPerFrameFileNamePrefix = NULL;
+        fPerFrameFileNameBuffer = NULL;
+    }
+    fPrevPresentationTime.tv_sec  = ~0;
+    fPrevPresentationTime.tv_usec = 0;
+}
+
+FileSink::~FileSink() {
+    delete[] fPerFrameFileNameBuffer;
+    delete[] fPerFrameFileNamePrefix;
+    delete[] fBuffer;
+    if(fOutFid != NULL)
+        fclose(fOutFid);
+}
+
+FileSink *FileSink::createNew(UsageEnvironment &env, char const *fileName, unsigned bufferSize, Boolean oneFilePerFrame) {
+    do {
+        FILE *      fid;
+        char const *perFrameFileNamePrefix;
+        if(oneFilePerFrame) {
+            // Create the fid for each frame
+            fid                    = NULL;
+            perFrameFileNamePrefix = fileName;
+        }
+        else {
+            // Normal case: create the fid once
+            fid = OpenOutputFile(env, fileName);
+            if(fid == NULL)
+                break;
+            perFrameFileNamePrefix = NULL;
+        }
+
+        return new FileSink(env, fid, bufferSize, perFrameFileNamePrefix);
+    } while(0);
+
+    return NULL;
+}
+
+Boolean FileSink::continuePlaying() {
+    if(fSource == NULL)
+        return False;
+
+    fSource->getNextFrame(fBuffer, fBufferSize, afterGettingFrame, this, onSourceClosure, this);
+
+    return True;
+}
+
+void FileSink::afterGettingFrame(void *clientData, unsigned frameSize, unsigned numTruncatedBytes, struct timeval presentationTime,
+                                 unsigned /*durationInMicroseconds*/) {
+    FileSink *sink = (FileSink *)clientData;
+    sink->afterGettingFrame(frameSize, numTruncatedBytes, presentationTime);
+}
+
+void FileSink::addData(unsigned char const *data, unsigned dataSize, struct timeval presentationTime) {
+    if(fPerFrameFileNameBuffer != NULL && fOutFid == NULL) {
+        // Special case: Open a new file on-the-fly for this frame
+        if(presentationTime.tv_usec == fPrevPresentationTime.tv_usec && presentationTime.tv_sec == fPrevPresentationTime.tv_sec) {
+            // The presentation time is unchanged from the previous frame, so we add a 'counter'
+            // suffix to the file name, to distinguish them:
+            sprintf(fPerFrameFileNameBuffer, "%s-%lu.%06lu-%u", fPerFrameFileNamePrefix, presentationTime.tv_sec, presentationTime.tv_usec,
+                    ++fSamePresentationTimeCounter);
+        }
+        else {
+            sprintf(fPerFrameFileNameBuffer, "%s-%lu.%06lu", fPerFrameFileNamePrefix, presentationTime.tv_sec, presentationTime.tv_usec);
+            fPrevPresentationTime        = presentationTime;  // for next time
+            fSamePresentationTimeCounter = 0;                 // for next time
+        }
+        fOutFid = OpenOutputFile(envir(), fPerFrameFileNameBuffer);
+    }
+
+    // Write to our file:
+#ifdef TEST_LOSS
+    static unsigned const framesPerPacket = 10;
+    static unsigned const frameCount      = 0;
+    static Boolean const  packetIsLost;
+    if((frameCount++) % framesPerPacket == 0) {
+        packetIsLost = (our_random() % 10 == 0);  // simulate 10% packet loss #####
+    }
+
+    if(!packetIsLost)
+#endif
+        if(fOutFid != NULL && data != NULL) {
+            fwrite(data, 1, dataSize, fOutFid);
+        }
+}
+
+void FileSink::afterGettingFrame(unsigned frameSize, unsigned numTruncatedBytes, struct timeval presentationTime) {
+    if(numTruncatedBytes > 0) {
+        envir() << "FileSink::afterGettingFrame(): The input frame data was too large for our buffer size (" << fBufferSize << ").  " << numTruncatedBytes
+                << " bytes of trailing data was dropped!  Correct this by increasing the \"bufferSize\" parameter in the \"createNew()\" call to at least "
+                << fBufferSize + numTruncatedBytes << "\n";
+    }
+    addData(fBuffer, frameSize, presentationTime);
+
+    if(fOutFid == NULL || fflush(fOutFid) == EOF) {
+        // The output file has closed.  Handle this the same way as if the input source had closed:
+        if(fSource != NULL)
+            fSource->stopGettingFrames();
+        onSourceClosure();
+        return;
+    }
+
+    if(fPerFrameFileNameBuffer != NULL) {
+        if(fOutFid != NULL) {
+            fclose(fOutFid);
+            fOutFid = NULL;
+        }
+    }
+
+    // Then try getting the next frame:
+    continuePlaying();
+}
diff --git a/3rdparty/live555/src/liveMedia/FramedFileSource.cpp b/3rdparty/live555/src/liveMedia/FramedFileSource.cpp
new file mode 100644
index 00000000..6f954009
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/FramedFileSource.cpp
@@ -0,0 +1,27 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// Framed File Sources
+// Implementation
+
+#include "FramedFileSource.hh"
+
+////////// FramedFileSource //////////
+
+FramedFileSource::FramedFileSource(UsageEnvironment &env, FILE *fid) : FramedSource(env), fFid(fid) {}
+
+FramedFileSource::~FramedFileSource() {}
diff --git a/3rdparty/live555/src/liveMedia/FramedFilter.cpp b/3rdparty/live555/src/liveMedia/FramedFilter.cpp
new file mode 100644
index 00000000..385970ed
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/FramedFilter.cpp
@@ -0,0 +1,58 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// Framed Filters
+// Implementation
+
+#include "FramedFilter.hh"
+
+////////// FramedFilter //////////
+#include <string.h>
+
+void FramedFilter::detachInputSource() {
+    if(fInputSource != NULL) {
+        fInputSource->stopGettingFrames();
+        reassignInputSource(NULL);
+    }
+}
+
+FramedFilter::FramedFilter(UsageEnvironment &env, FramedSource *inputSource) : FramedSource(env), fInputSource(inputSource) {}
+
+FramedFilter::~FramedFilter() {
+    Medium::close(fInputSource);
+}
+
+// Default implementations of needed virtual functions.  These merely
+// call the same function in the input source - i.e., act like a 'null filter
+
+char const *FramedFilter::MIMEtype() const {
+    if(fInputSource == NULL)
+        return "";
+
+    return fInputSource->MIMEtype();
+}
+
+void FramedFilter::getAttributes() const {
+    if(fInputSource != NULL)
+        fInputSource->getAttributes();
+}
+
+void FramedFilter::doStopGettingFrames() {
+    FramedSource::doStopGettingFrames();
+    if(fInputSource != NULL)
+        fInputSource->stopGettingFrames();
+}
diff --git a/3rdparty/live555/src/liveMedia/FramedSource.cpp b/3rdparty/live555/src/liveMedia/FramedSource.cpp
new file mode 100644
index 00000000..cba6a314
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/FramedSource.cpp
@@ -0,0 +1,117 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// Framed Sources
+// Implementation
+
+#include "FramedSource.hh"
+#include <stdlib.h>
+
+////////// FramedSource //////////
+
+FramedSource::FramedSource(UsageEnvironment &env)
+    : MediaSource(env), fAfterGettingFunc(NULL), fAfterGettingClientData(NULL), fOnCloseFunc(NULL), fOnCloseClientData(NULL), fIsCurrentlyAwaitingData(False) {
+    fPresentationTime.tv_sec = fPresentationTime.tv_usec = 0;  // initially
+}
+
+FramedSource::~FramedSource() {}
+
+Boolean FramedSource::isFramedSource() const {
+    return True;
+}
+
+Boolean FramedSource::lookupByName(UsageEnvironment &env, char const *sourceName, FramedSource *&resultSource) {
+    resultSource = NULL;  // unless we succeed
+
+    MediaSource *source;
+    if(!MediaSource::lookupByName(env, sourceName, source))
+        return False;
+
+    if(!source->isFramedSource()) {
+        env.setResultMsg(sourceName, " is not a framed source");
+        return False;
+    }
+
+    resultSource = (FramedSource *)source;
+    return True;
+}
+
+void FramedSource::getNextFrame(unsigned char *to, unsigned maxSize, afterGettingFunc *afterGettingFunc, void *afterGettingClientData, onCloseFunc *onCloseFunc,
+                                void *onCloseClientData) {
+    // Make sure we're not already being read:
+    if(fIsCurrentlyAwaitingData) {
+        envir() << "FramedSource[" << this << "]::getNextFrame(): attempting to read more than once at the same time!\n";
+        envir().internalError();
+    }
+
+    fTo                      = to;
+    fMaxSize                 = maxSize;
+    fNumTruncatedBytes       = 0;  // by default; could be changed by doGetNextFrame()
+    fDurationInMicroseconds  = 0;  // by default; could be changed by doGetNextFrame()
+    fAfterGettingFunc        = afterGettingFunc;
+    fAfterGettingClientData  = afterGettingClientData;
+    fOnCloseFunc             = onCloseFunc;
+    fOnCloseClientData       = onCloseClientData;
+    fIsCurrentlyAwaitingData = True;
+
+    doGetNextFrame();
+}
+
+void FramedSource::afterGetting(FramedSource *source) {
+    source->nextTask()               = NULL;
+    source->fIsCurrentlyAwaitingData = False;
+    // indicates that we can be read again
+    // Note that this needs to be done here, in case the "fAfterFunc"
+    // called below tries to read another frame (which it usually will)
+
+    if(source->fAfterGettingFunc != NULL) {
+        (*(source->fAfterGettingFunc))(source->fAfterGettingClientData, source->fFrameSize, source->fNumTruncatedBytes, source->fPresentationTime,
+                                       source->fDurationInMicroseconds);
+    }
+}
+
+void FramedSource::handleClosure(void *clientData) {
+    FramedSource *source = (FramedSource *)clientData;
+    source->handleClosure();
+}
+
+void FramedSource::handleClosure() {
+    fIsCurrentlyAwaitingData = False;  // because we got a close instead
+    if(fOnCloseFunc != NULL) {
+        (*fOnCloseFunc)(fOnCloseClientData);
+    }
+}
+
+void FramedSource::stopGettingFrames() {
+    fIsCurrentlyAwaitingData = False;  // indicates that we can be read again
+    fAfterGettingFunc        = NULL;
+    fOnCloseFunc             = NULL;
+
+    // Perform any specialized action now:
+    doStopGettingFrames();
+}
+
+void FramedSource::doStopGettingFrames() {
+    // Default implementation: Do nothing except cancel any pending 'delivery' task:
+    envir().taskScheduler().unscheduleDelayedTask(nextTask());
+    // Subclasses may wish to redefine this function.
+}
+
+unsigned FramedSource::maxFrameSize() const {
+    // By default, this source has no maximum frame size.
+    return 0;
+}
diff --git a/3rdparty/live555/src/liveMedia/GSMAudioRTPSink.cpp b/3rdparty/live555/src/liveMedia/GSMAudioRTPSink.cpp
new file mode 100644
index 00000000..68919078
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/GSMAudioRTPSink.cpp
@@ -0,0 +1,34 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// RTP sink for GSM audio
+// Implementation
+
+#include "GSMAudioRTPSink.hh"
+
+GSMAudioRTPSink::GSMAudioRTPSink(UsageEnvironment &env, Groupsock *RTPgs) : AudioRTPSink(env, RTPgs, 3, 8000, "GSM") {}
+
+GSMAudioRTPSink::~GSMAudioRTPSink() {}
+
+GSMAudioRTPSink *GSMAudioRTPSink::createNew(UsageEnvironment &env, Groupsock *RTPgs) {
+    return new GSMAudioRTPSink(env, RTPgs);
+}
+
+Boolean GSMAudioRTPSink ::frameCanAppearAfterPacketStart(unsigned char const * /*frameStart*/, unsigned /*numBytesInFrame*/) const {
+    // Allow at most 5 frames in a single packet:
+    return numFramesUsedSoFar() < 5;
+}
diff --git a/3rdparty/live555/src/liveMedia/GenericMediaServer.cpp b/3rdparty/live555/src/liveMedia/GenericMediaServer.cpp
new file mode 100644
index 00000000..e4f79f69
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/GenericMediaServer.cpp
@@ -0,0 +1,467 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A generic media server class, used to implement a RTSP server, and any other server that uses
+//  "ServerMediaSession" objects to describe media to be served.
+// Implementation
+
+#include "GenericMediaServer.hh"
+#include <GroupsockHelper.hh>
+#if defined(__WIN32__) || defined(_WIN32) || defined(_QNX4)
+#define snprintf _snprintf
+#endif
+
+////////// GenericMediaServer implementation //////////
+
+void GenericMediaServer::addServerMediaSession(ServerMediaSession *serverMediaSession) {
+    if(serverMediaSession == NULL)
+        return;
+
+    char const *sessionName = serverMediaSession->streamName();
+    if(sessionName == NULL)
+        sessionName = "";
+    removeServerMediaSession(sessionName);
+    // in case an existing "ServerMediaSession" with this name already exists
+
+    fServerMediaSessions->Add(sessionName, (void *)serverMediaSession);
+}
+
+void GenericMediaServer ::lookupServerMediaSession(char const *streamName, lookupServerMediaSessionCompletionFunc *completionFunc, void *completionClientData,
+                                                   Boolean /*isFirstLookupInSession*/) {
+    // Default implementation: Do a synchronous lookup, and call the completion function:
+    if(completionFunc != NULL) {
+        (*completionFunc)(completionClientData, getServerMediaSession(streamName));
+    }
+}
+
+struct lsmsMemberFunctionRecord {
+    GenericMediaServer *fServer;
+    void (GenericMediaServer::*fMemberFunc)(ServerMediaSession *);
+};
+
+static void lsmsMemberFunctionCompletionFunc(void *clientData, ServerMediaSession *sessionLookedUp) {
+    lsmsMemberFunctionRecord *memberFunctionRecord = (lsmsMemberFunctionRecord *)clientData;
+    (memberFunctionRecord->fServer->*(memberFunctionRecord->fMemberFunc))(sessionLookedUp);
+    delete memberFunctionRecord;
+}
+
+void GenericMediaServer ::lookupServerMediaSession(char const *streamName, void (GenericMediaServer::*memberFunc)(ServerMediaSession *)) {
+    struct lsmsMemberFunctionRecord *memberFunctionRecord = new struct lsmsMemberFunctionRecord;
+    memberFunctionRecord->fServer                         = this;
+    memberFunctionRecord->fMemberFunc                     = memberFunc;
+
+    GenericMediaServer ::lookupServerMediaSession(streamName, lsmsMemberFunctionCompletionFunc, memberFunctionRecord);
+}
+
+void GenericMediaServer::removeServerMediaSession(ServerMediaSession *serverMediaSession) {
+    if(serverMediaSession == NULL)
+        return;
+
+    fServerMediaSessions->Remove(serverMediaSession->streamName());
+    if(serverMediaSession->referenceCount() == 0) {
+        Medium::close(serverMediaSession);
+    }
+    else {
+        serverMediaSession->deleteWhenUnreferenced() = True;
+    }
+}
+
+void GenericMediaServer::removeServerMediaSession(char const *streamName) {
+    lookupServerMediaSession(streamName, &GenericMediaServer::removeServerMediaSession);
+}
+
+void GenericMediaServer::closeAllClientSessionsForServerMediaSession(ServerMediaSession *serverMediaSession) {
+    if(serverMediaSession == NULL)
+        return;
+
+    HashTable::Iterator *              iter = HashTable::Iterator::create(*fClientSessions);
+    GenericMediaServer::ClientSession *clientSession;
+    char const *                       key;  // dummy
+    while((clientSession = (GenericMediaServer::ClientSession *)(iter->next(key))) != NULL) {
+        if(clientSession->fOurServerMediaSession == serverMediaSession) {
+            delete clientSession;
+        }
+    }
+    delete iter;
+}
+
+void GenericMediaServer::closeAllClientSessionsForServerMediaSession(char const *streamName) {
+    lookupServerMediaSession(streamName, &GenericMediaServer::closeAllClientSessionsForServerMediaSession);
+}
+
+void GenericMediaServer::deleteServerMediaSession(ServerMediaSession *serverMediaSession) {
+    if(serverMediaSession == NULL)
+        return;
+
+    closeAllClientSessionsForServerMediaSession(serverMediaSession);
+    removeServerMediaSession(serverMediaSession);
+}
+
+void GenericMediaServer::deleteServerMediaSession(char const *streamName) {
+    lookupServerMediaSession(streamName, &GenericMediaServer::deleteServerMediaSession);
+}
+
+GenericMediaServer ::GenericMediaServer(UsageEnvironment &env, int ourSocketIPv4, int ourSocketIPv6, Port ourPort, unsigned reclamationSeconds)
+    : Medium(env),
+      fServerSocketIPv4(ourSocketIPv4),
+      fServerSocketIPv6(ourSocketIPv6),
+      fServerPort(ourPort),
+      fReclamationSeconds(reclamationSeconds),
+      fServerMediaSessions(HashTable::create(STRING_HASH_KEYS)),
+      fClientConnections(HashTable::create(ONE_WORD_HASH_KEYS)),
+      fClientSessions(HashTable::create(STRING_HASH_KEYS)),
+      fPreviousClientSessionId(0),
+      fTLSCertificateFileName(NULL),
+      fTLSPrivateKeyFileName(NULL) {
+    ignoreSigPipeOnSocket(fServerSocketIPv4);  // so that clients on the same host that are killed don't also kill us
+    ignoreSigPipeOnSocket(fServerSocketIPv6);  // ditto
+
+    // Arrange to handle connections from others:
+    env.taskScheduler().turnOnBackgroundReadHandling(fServerSocketIPv4, incomingConnectionHandlerIPv4, this);
+    env.taskScheduler().turnOnBackgroundReadHandling(fServerSocketIPv6, incomingConnectionHandlerIPv6, this);
+}
+
+GenericMediaServer::~GenericMediaServer() {
+    // Turn off background read handling:
+    envir().taskScheduler().turnOffBackgroundReadHandling(fServerSocketIPv4);
+    ::closeSocket(fServerSocketIPv4);
+    envir().taskScheduler().turnOffBackgroundReadHandling(fServerSocketIPv6);
+    ::closeSocket(fServerSocketIPv6);
+
+    delete[] fTLSCertificateFileName;
+    delete[] fTLSPrivateKeyFileName;
+}
+
+void GenericMediaServer::cleanup() {
+    // This member function must be called in the destructor of any subclass of
+    // "GenericMediaServer".  (We don't call this in the destructor of "GenericMediaServer" itself,
+    // because by that time, the subclass destructor will already have been called, and this may
+    // affect (break) the destruction of the "ClientSession" and "ClientConnection" objects, which
+    // themselves will have been subclassed.)
+
+    // Close all client session objects:
+    GenericMediaServer::ClientSession *clientSession;
+    while((clientSession = (GenericMediaServer::ClientSession *)fClientSessions->getFirst()) != NULL) {
+        delete clientSession;
+    }
+    delete fClientSessions;
+
+    // Close all client connection objects:
+    GenericMediaServer::ClientConnection *connection;
+    while((connection = (GenericMediaServer::ClientConnection *)fClientConnections->getFirst()) != NULL) {
+        delete connection;
+    }
+    delete fClientConnections;
+
+    // Delete all server media sessions
+    ServerMediaSession *serverMediaSession;
+    while((serverMediaSession = (ServerMediaSession *)fServerMediaSessions->getFirst()) != NULL) {
+        removeServerMediaSession(serverMediaSession);  // will delete it, because it no longer has any 'client session' objects using it
+    }
+    delete fServerMediaSessions;
+}
+
+#define LISTEN_BACKLOG_SIZE 20
+
+int GenericMediaServer::setUpOurSocket(UsageEnvironment &env, Port &ourPort, int domain) {
+    int ourSocket = -1;
+
+    do {
+        // The following statement is enabled by default.
+        // Don't disable it (by defining ALLOW_SERVER_PORT_REUSE) unless you know what you're doing.
+#if !defined(ALLOW_SERVER_PORT_REUSE) && !defined(ALLOW_RTSP_SERVER_PORT_REUSE)
+        // ALLOW_RTSP_SERVER_PORT_REUSE is for backwards-compatibility #####
+        NoReuse dummy(env);  // Don't use this socket if there's already a local server using it
+#endif
+
+        ourSocket = setupStreamSocket(env, ourPort, domain, True, True);
+        // later fix to support IPv6
+        if(ourSocket < 0)
+            break;
+
+        // Make sure we have a big send buffer:
+        if(!increaseSendBufferTo(env, ourSocket, 50 * 1024))
+            break;
+
+        // Allow multiple simultaneous connections:
+        if(listen(ourSocket, LISTEN_BACKLOG_SIZE) < 0) {
+            env.setResultErrMsg("listen() failed: ");
+            break;
+        }
+
+        if(ourPort.num() == 0) {
+            // bind() will have chosen a port for us; return it also:
+            if(!getSourcePort(env, ourSocket, domain, ourPort))
+                break;
+        }
+
+        return ourSocket;
+    } while(0);
+
+    if(ourSocket != -1)
+        ::closeSocket(ourSocket);
+    return -1;
+}
+
+void GenericMediaServer::incomingConnectionHandlerIPv4(void *instance, int /*mask*/) {
+    GenericMediaServer *server = (GenericMediaServer *)instance;
+    server->incomingConnectionHandlerIPv4();
+}
+void GenericMediaServer::incomingConnectionHandlerIPv6(void *instance, int /*mask*/) {
+    GenericMediaServer *server = (GenericMediaServer *)instance;
+    server->incomingConnectionHandlerIPv6();
+}
+void GenericMediaServer::incomingConnectionHandlerIPv4() {
+    incomingConnectionHandlerOnSocket(fServerSocketIPv4);
+}
+void GenericMediaServer::incomingConnectionHandlerIPv6() {
+    incomingConnectionHandlerOnSocket(fServerSocketIPv6);
+}
+
+void GenericMediaServer::incomingConnectionHandlerOnSocket(int serverSocket) {
+    struct sockaddr_storage clientAddr;
+    SOCKLEN_T               clientAddrLen = sizeof clientAddr;
+    int                     clientSocket  = accept(serverSocket, (struct sockaddr *)&clientAddr,
+                                                   reinterpret_cast<socklen_t *>(&clientAddrLen));
+    if(clientSocket < 0) {
+        int err = envir().getErrno();
+        if(err != EWOULDBLOCK) {
+            envir().setResultErrMsg("accept() failed: ");
+        }
+        return;
+    }
+    ignoreSigPipeOnSocket(clientSocket);  // so that clients on the same host that are killed don't also kill us
+    makeSocketNonBlocking(clientSocket);
+    increaseSendBufferTo(envir(), clientSocket, 50 * 1024);
+
+#ifdef DEBUG
+    envir() << "accept()ed connection from " << AddressString(clientAddr).val() << "\n";
+#endif
+
+    // Create a new object for handling this connection:
+    (void)createNewClientConnection(clientSocket, clientAddr);
+}
+
+void GenericMediaServer ::setTLSFileNames(char const *certFileName, char const *privKeyFileName) {
+    delete[] fTLSCertificateFileName;
+    fTLSCertificateFileName = strDup(certFileName);
+    delete[] fTLSPrivateKeyFileName;
+    fTLSPrivateKeyFileName = strDup(privKeyFileName);
+}
+
+////////// GenericMediaServer::ClientConnection implementation //////////
+
+GenericMediaServer::ClientConnection ::ClientConnection(GenericMediaServer &ourServer, int clientSocket, struct sockaddr_storage const &clientAddr,
+                                                        Boolean useTLS)
+    : fOurServer(ourServer), fOurSocket(clientSocket), fClientAddr(clientAddr), fTLS(envir()) {
+    // Add ourself to our 'client connections' table:
+    fOurServer.fClientConnections->Add((char const *)this, this);
+
+    if(useTLS) {
+        // Perform extra processing to handle a TLS connection:
+        fTLS.setCertificateAndPrivateKeyFileNames(ourServer.fTLSCertificateFileName, ourServer.fTLSPrivateKeyFileName);
+        fTLS.isNeeded = True;
+
+        fTLS.tlsAcceptIsNeeded = True;  // call fTLS.accept() the next time the socket is readable
+    }
+
+    // Arrange to handle incoming requests:
+    resetRequestBuffer();
+    envir().taskScheduler().setBackgroundHandling(fOurSocket, SOCKET_READABLE | SOCKET_EXCEPTION, incomingRequestHandler, this);
+}
+
+GenericMediaServer::ClientConnection::~ClientConnection() {
+    // Remove ourself from the server's 'client connections' hash table before we go:
+    fOurServer.fClientConnections->Remove((char const *)this);
+
+    closeSockets();
+}
+
+void GenericMediaServer::ClientConnection::closeSockets() {
+    // Turn off background handling on our socket:
+    envir().taskScheduler().disableBackgroundHandling(fOurSocket);
+    if(fOurSocket >= 0)
+        ::closeSocket(fOurSocket);
+
+    fOurSocket = -1;
+}
+
+void GenericMediaServer::ClientConnection::incomingRequestHandler(void *instance, int /*mask*/) {
+    ClientConnection *connection = (ClientConnection *)instance;
+    connection->incomingRequestHandler();
+}
+
+void GenericMediaServer::ClientConnection::incomingRequestHandler() {
+    if(fTLS.tlsAcceptIsNeeded) {  // we need to successfully call fTLS.accept() first:
+        if(fTLS.accept(fOurSocket) <= 0)
+            return;  // either an error, or we need to try again later
+
+        fTLS.tlsAcceptIsNeeded = False;
+        // We can now read data, as usual:
+    }
+
+    int bytesRead;
+    if(fTLS.isNeeded) {
+        bytesRead = fTLS.read(&fRequestBuffer[fRequestBytesAlreadySeen], fRequestBufferBytesLeft);
+    }
+    else {
+        struct sockaddr_storage dummy;  // 'from' address, meaningless in this case
+
+        bytesRead = readSocket(envir(), fOurSocket, &fRequestBuffer[fRequestBytesAlreadySeen], fRequestBufferBytesLeft, dummy);
+    }
+    handleRequestBytes(bytesRead);
+}
+
+void GenericMediaServer::ClientConnection::resetRequestBuffer() {
+    fRequestBytesAlreadySeen = 0;
+    fRequestBufferBytesLeft  = sizeof fRequestBuffer;
+}
+
+////////// GenericMediaServer::ClientSession implementation //////////
+
+GenericMediaServer::ClientSession ::ClientSession(GenericMediaServer &ourServer, u_int32_t sessionId)
+    : fOurServer(ourServer), fOurSessionId(sessionId), fOurServerMediaSession(NULL), fLivenessCheckTask(NULL) {
+    noteLiveness();
+}
+
+GenericMediaServer::ClientSession::~ClientSession() {
+    // Turn off any liveness checking:
+    envir().taskScheduler().unscheduleDelayedTask(fLivenessCheckTask);
+
+    // Remove ourself from the server's 'client sessions' hash table before we go:
+    char sessionIdStr[8 + 1];
+    sprintf(sessionIdStr, "%08X", fOurSessionId);
+    fOurServer.fClientSessions->Remove(sessionIdStr);
+
+    if(fOurServerMediaSession != NULL) {
+        fOurServerMediaSession->decrementReferenceCount();
+        if(fOurServerMediaSession->referenceCount() == 0 && fOurServerMediaSession->deleteWhenUnreferenced()) {
+            fOurServer.removeServerMediaSession(fOurServerMediaSession);
+            fOurServerMediaSession = NULL;
+        }
+    }
+}
+
+void GenericMediaServer::ClientSession::noteLiveness() {
+#ifdef DEBUG
+    char const *streamName = (fOurServerMediaSession == NULL) ? "???" : fOurServerMediaSession->streamName();
+    fprintf(stderr, "Client session (id \"%08X\", stream name \"%s\"): Liveness indication\n", fOurSessionId, streamName);
+#endif
+    if(fOurServerMediaSession != NULL)
+        fOurServerMediaSession->noteLiveness();
+
+    if(fOurServer.fReclamationSeconds > 0) {
+        envir().taskScheduler().rescheduleDelayedTask(fLivenessCheckTask, fOurServer.fReclamationSeconds * 1000000, (TaskFunc *)livenessTimeoutTask, this);
+    }
+}
+
+void GenericMediaServer::ClientSession::noteClientLiveness(ClientSession *clientSession) {
+    clientSession->noteLiveness();
+}
+
+void GenericMediaServer::ClientSession::livenessTimeoutTask(ClientSession *clientSession) {
+    // If this gets called, the client session is assumed to have timed out, so delete it:
+#ifdef DEBUG
+    char const *streamName = (clientSession->fOurServerMediaSession == NULL) ? "???" : clientSession->fOurServerMediaSession->streamName();
+    fprintf(stderr, "Client session (id \"%08X\", stream name \"%s\") has timed out (due to inactivity)\n", clientSession->fOurSessionId, streamName);
+#endif
+    clientSession->fLivenessCheckTask = NULL;
+    delete clientSession;
+}
+
+GenericMediaServer::ClientSession *GenericMediaServer::createNewClientSessionWithId() {
+    u_int32_t sessionId;
+    char      sessionIdStr[8 + 1];
+
+    // Choose a random (unused) 32-bit integer for the session id
+    // (it will be encoded as a 8-digit hex number).  (We avoid choosing session id 0,
+    // because that has a special use by some servers.  Similarly, we avoid choosing the same
+    // session id twice in a row.)
+    do {
+        sessionId = (u_int32_t)our_random32();
+        snprintf(sessionIdStr, sizeof sessionIdStr, "%08X", sessionId);
+    } while(sessionId == 0 || sessionId == fPreviousClientSessionId || lookupClientSession(sessionIdStr) != NULL);
+    fPreviousClientSessionId = sessionId;
+
+    ClientSession *clientSession = createNewClientSession(sessionId);
+    if(clientSession != NULL)
+        fClientSessions->Add(sessionIdStr, clientSession);
+
+    return clientSession;
+}
+
+GenericMediaServer::ClientSession *GenericMediaServer::lookupClientSession(u_int32_t sessionId) {
+    char sessionIdStr[8 + 1];
+    snprintf(sessionIdStr, sizeof sessionIdStr, "%08X", sessionId);
+    return lookupClientSession(sessionIdStr);
+}
+
+GenericMediaServer::ClientSession *GenericMediaServer::lookupClientSession(char const *sessionIdStr) {
+    return (GenericMediaServer::ClientSession *)fClientSessions->Lookup(sessionIdStr);
+}
+
+ServerMediaSession *GenericMediaServer::getServerMediaSession(char const *streamName) {
+    return (ServerMediaSession *)(fServerMediaSessions->Lookup(streamName));
+}
+
+////////// ServerMediaSessionIterator implementation //////////
+
+GenericMediaServer::ServerMediaSessionIterator ::ServerMediaSessionIterator(GenericMediaServer &server)
+    : fOurIterator((server.fServerMediaSessions == NULL) ? NULL : HashTable::Iterator::create(*server.fServerMediaSessions)) {}
+
+GenericMediaServer::ServerMediaSessionIterator::~ServerMediaSessionIterator() {
+    delete fOurIterator;
+}
+
+ServerMediaSession *GenericMediaServer::ServerMediaSessionIterator::next() {
+    if(fOurIterator == NULL)
+        return NULL;
+
+    char const *key;  // dummy
+    return (ServerMediaSession *)(fOurIterator->next(key));
+}
+
+////////// UserAuthenticationDatabase implementation //////////
+
+UserAuthenticationDatabase::UserAuthenticationDatabase(char const *realm, Boolean passwordsAreMD5)
+    : fTable(HashTable::create(STRING_HASH_KEYS)), fRealm(strDup(realm == NULL ? "LIVE555 Streaming Media" : realm)), fPasswordsAreMD5(passwordsAreMD5) {}
+
+UserAuthenticationDatabase::~UserAuthenticationDatabase() {
+    delete[] fRealm;
+
+    // Delete the allocated 'password' strings that we stored in the table, and then the table itself:
+    char *password;
+    while((password = (char *)fTable->RemoveNext()) != NULL) {
+        delete[] password;
+    }
+    delete fTable;
+}
+
+void UserAuthenticationDatabase::addUserRecord(char const *username, char const *password) {
+    char *oldPassword = (char *)fTable->Add(username, (void *)(strDup(password)));
+    delete[] oldPassword;  // if any
+}
+
+void UserAuthenticationDatabase::removeUserRecord(char const *username) {
+    char *password = (char *)(fTable->Lookup(username));
+    fTable->Remove(username);
+    delete[] password;
+}
+
+char const *UserAuthenticationDatabase::lookupPassword(char const *username) {
+    return (char const *)(fTable->Lookup(username));
+}
diff --git a/3rdparty/live555/src/liveMedia/H261VideoRTPSource.cpp b/3rdparty/live555/src/liveMedia/H261VideoRTPSource.cpp
new file mode 100644
index 00000000..48cd6043
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/H261VideoRTPSource.cpp
@@ -0,0 +1,54 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// H.261 Video RTP Sources
+// Implementation
+
+#include "H261VideoRTPSource.hh"
+
+H261VideoRTPSource *H261VideoRTPSource::createNew(UsageEnvironment &env, Groupsock *RTPgs, unsigned char rtpPayloadFormat, unsigned rtpTimestampFrequency) {
+    return new H261VideoRTPSource(env, RTPgs, rtpPayloadFormat, rtpTimestampFrequency);
+}
+
+H261VideoRTPSource ::H261VideoRTPSource(UsageEnvironment &env, Groupsock *RTPgs, unsigned char rtpPayloadFormat, unsigned rtpTimestampFrequency)
+    : MultiFramedRTPSource(env, RTPgs, rtpPayloadFormat, rtpTimestampFrequency), fLastSpecialHeader(0) {}
+
+H261VideoRTPSource::~H261VideoRTPSource() {}
+
+Boolean H261VideoRTPSource ::processSpecialHeader(BufferedPacket *packet, unsigned &resultSpecialHeaderSize) {
+    // There's a 4-byte video-specific header
+    if(packet->dataSize() < 4)
+        return False;
+
+    unsigned char *headerStart = packet->data();
+    fLastSpecialHeader         = (headerStart[0] << 24) | (headerStart[1] << 16) | (headerStart[2] << 8) | headerStart[3];
+
+#ifdef DELIVER_COMPLETE_FRAMES
+    fCurrentPacketBeginsFrame = fCurrentPacketCompletesFrame;
+    // whether the *previous* packet ended a frame
+
+    // The RTP "M" (marker) bit indicates the last fragment of a frame:
+    fCurrentPacketCompletesFrame = packet->rtpMarkerBit();
+#endif
+
+    resultSpecialHeaderSize = 4;
+    return True;
+}
+
+char const *H261VideoRTPSource::MIMEtype() const {
+    return "video/H261";
+}
diff --git a/3rdparty/live555/src/liveMedia/H263plusVideoFileServerMediaSubsession.cpp b/3rdparty/live555/src/liveMedia/H263plusVideoFileServerMediaSubsession.cpp
new file mode 100644
index 00000000..36c86772
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/H263plusVideoFileServerMediaSubsession.cpp
@@ -0,0 +1,56 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A 'ServerMediaSubsession' object that creates new, unicast, "RTPSink"s
+// on demand, from a H263 video file.
+// Implementation
+
+// Author: Bernhard Feiten. // Based on MPEG4VideoFileServerMediaSubsession
+// Updated by Ross FInlayson (December 2007)
+
+#include "H263plusVideoFileServerMediaSubsession.hh"
+#include "H263plusVideoRTPSink.hh"
+#include "ByteStreamFileSource.hh"
+#include "H263plusVideoStreamFramer.hh"
+
+H263plusVideoFileServerMediaSubsession *H263plusVideoFileServerMediaSubsession::createNew(UsageEnvironment &env, char const *fileName,
+                                                                                          Boolean reuseFirstSource) {
+    return new H263plusVideoFileServerMediaSubsession(env, fileName, reuseFirstSource);
+}
+
+H263plusVideoFileServerMediaSubsession ::H263plusVideoFileServerMediaSubsession(UsageEnvironment &env, char const *fileName, Boolean reuseFirstSource)
+    : FileServerMediaSubsession(env, fileName, reuseFirstSource) {}
+
+H263plusVideoFileServerMediaSubsession::~H263plusVideoFileServerMediaSubsession() {}
+
+FramedSource *H263plusVideoFileServerMediaSubsession ::createNewStreamSource(unsigned /*clientSessionId*/, unsigned &estBitrate) {
+    estBitrate = 500;  // kbps, estimate ??
+
+    // Create the video source:
+    ByteStreamFileSource *fileSource = ByteStreamFileSource::createNew(envir(), fFileName);
+    if(fileSource == NULL)
+        return NULL;
+    fFileSize = fileSource->fileSize();
+
+    // Create a framer for the Video Elementary Stream:
+    return H263plusVideoStreamFramer::createNew(envir(), fileSource);
+}
+
+RTPSink *H263plusVideoFileServerMediaSubsession::createNewRTPSink(Groupsock *rtpGroupsock, unsigned char rtpPayloadTypeIfDynamic,
+                                                                  FramedSource * /*inputSource*/) {
+    return H263plusVideoRTPSink::createNew(envir(), rtpGroupsock, rtpPayloadTypeIfDynamic);
+}
diff --git a/3rdparty/live555/src/liveMedia/H263plusVideoRTPSink.cpp b/3rdparty/live555/src/liveMedia/H263plusVideoRTPSink.cpp
new file mode 100644
index 00000000..db5e0579
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/H263plusVideoRTPSink.cpp
@@ -0,0 +1,77 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// RTP sink for H.263+ video (RFC 4629)
+// Implementation
+
+#include "H263plusVideoRTPSink.hh"
+
+H263plusVideoRTPSink ::H263plusVideoRTPSink(UsageEnvironment &env, Groupsock *RTPgs, unsigned char rtpPayloadFormat, u_int32_t rtpTimestampFrequency)
+    : VideoRTPSink(env, RTPgs, rtpPayloadFormat, rtpTimestampFrequency, "H263-1998") {}
+
+H263plusVideoRTPSink::~H263plusVideoRTPSink() {}
+
+H263plusVideoRTPSink *H263plusVideoRTPSink::createNew(UsageEnvironment &env, Groupsock *RTPgs, unsigned char rtpPayloadFormat,
+                                                      u_int32_t rtpTimestampFrequency) {
+    return new H263plusVideoRTPSink(env, RTPgs, rtpPayloadFormat, rtpTimestampFrequency);
+}
+
+Boolean H263plusVideoRTPSink ::frameCanAppearAfterPacketStart(unsigned char const * /*frameStart*/, unsigned /*numBytesInFrame*/) const {
+    // A packet can contain only one frame
+    return False;
+}
+
+void H263plusVideoRTPSink ::doSpecialFrameHandling(unsigned fragmentationOffset, unsigned char *frameStart, unsigned numBytesInFrame,
+                                                   struct timeval framePresentationTime, unsigned numRemainingBytes) {
+    if(fragmentationOffset == 0) {
+        // This packet contains the first (or only) fragment of the frame.
+        // Set the 'P' bit in the special header:
+        unsigned short specialHeader = 0x0400;
+
+        // Also, reuse the first two bytes of the payload for this special
+        // header.  (They should both have been zero.)
+        if(numBytesInFrame < 2) {
+            envir() << "H263plusVideoRTPSink::doSpecialFrameHandling(): bad frame size " << numBytesInFrame << "\n";
+            return;
+        }
+        if(frameStart[0] != 0 || frameStart[1] != 0) {
+            envir() << "H263plusVideoRTPSink::doSpecialFrameHandling(): unexpected non-zero first two bytes!\n";
+        }
+        frameStart[0] = specialHeader >> 8;
+        frameStart[1] = (unsigned char)specialHeader;
+    }
+    else {
+        unsigned short specialHeader = 0;
+        setSpecialHeaderBytes((unsigned char *)&specialHeader, 2);
+    }
+
+    if(numRemainingBytes == 0) {
+        // This packet contains the last (or only) fragment of the frame.
+        // Set the RTP 'M' ('marker') bit:
+        setMarkerBit();
+    }
+
+    // Also set the RTP timestamp:
+    setTimestamp(framePresentationTime);
+}
+
+unsigned H263plusVideoRTPSink::specialHeaderSize() const {
+    // There's a 2-byte special video header.  However, if we're the first
+    // (or only) fragment of a frame, then we reuse the first 2 bytes of
+    // the payload instead.
+    return (curFragmentationOffset() == 0) ? 0 : 2;
+}
diff --git a/3rdparty/live555/src/liveMedia/H263plusVideoRTPSource.cpp b/3rdparty/live555/src/liveMedia/H263plusVideoRTPSource.cpp
new file mode 100644
index 00000000..367fb995
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/H263plusVideoRTPSource.cpp
@@ -0,0 +1,96 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// H.263+ Video RTP Sources
+// Implementation
+
+#include "H263plusVideoRTPSource.hh"
+
+H263plusVideoRTPSource *H263plusVideoRTPSource::createNew(UsageEnvironment &env, Groupsock *RTPgs, unsigned char rtpPayloadFormat,
+                                                          unsigned rtpTimestampFrequency) {
+    return new H263plusVideoRTPSource(env, RTPgs, rtpPayloadFormat, rtpTimestampFrequency);
+}
+
+H263plusVideoRTPSource ::H263plusVideoRTPSource(UsageEnvironment &env, Groupsock *RTPgs, unsigned char rtpPayloadFormat, unsigned rtpTimestampFrequency)
+    : MultiFramedRTPSource(env, RTPgs, rtpPayloadFormat, rtpTimestampFrequency), fNumSpecialHeaders(0), fSpecialHeaderBytesLength(0) {}
+
+H263plusVideoRTPSource::~H263plusVideoRTPSource() {}
+
+Boolean H263plusVideoRTPSource ::processSpecialHeader(BufferedPacket *packet, unsigned &resultSpecialHeaderSize) {
+    unsigned char *headerStart = packet->data();
+    unsigned       packetSize  = packet->dataSize();
+
+    // The H.263+ payload header is at least 2 bytes in size.
+    // Extract the known fields from the first 2 bytes:
+    unsigned expectedHeaderSize = 2;
+    if(packetSize < expectedHeaderSize)
+        return False;
+
+    // unsigned char RR = headerStart[0]>>3;
+    Boolean       P    = (headerStart[0] & 0x4) != 0;
+    Boolean       V    = (headerStart[0] & 0x2) != 0;
+    unsigned char PLEN = ((headerStart[0] & 0x1) << 5) | (headerStart[1] >> 3);
+    // unsigned char PEBIT = headerStart[1]&0x7;
+
+    if(V) {
+        // There's an extra VRC byte at the end of the header:
+        ++expectedHeaderSize;
+        if(packetSize < expectedHeaderSize)
+            return False;
+    }
+
+    if(PLEN > 0) {
+        // There's an extra picture header at the end:
+        expectedHeaderSize += PLEN;
+        if(packetSize < expectedHeaderSize)
+            return False;
+    }
+
+    fCurrentPacketBeginsFrame = P;
+    if(fCurrentPacketBeginsFrame) {
+        fNumSpecialHeaders = fSpecialHeaderBytesLength = 0;
+    }
+
+    // Make a copy of the special header bytes, in case a reader
+    // can use them:
+    unsigned bytesAvailable = SPECIAL_HEADER_BUFFER_SIZE - fSpecialHeaderBytesLength - 1;
+    if(expectedHeaderSize <= bytesAvailable) {
+        fSpecialHeaderBytes[fSpecialHeaderBytesLength++] = expectedHeaderSize;
+        for(unsigned i = 0; i < expectedHeaderSize; ++i) {
+            fSpecialHeaderBytes[fSpecialHeaderBytesLength++] = headerStart[i];
+        }
+        fPacketSizes[fNumSpecialHeaders++] = packetSize;
+    }
+
+    if(P) {
+        // Prepend two zero bytes to the start of the payload proper.
+        // Hack: Do this by shrinking this special header by 2 bytes:
+        expectedHeaderSize -= 2;
+        headerStart[expectedHeaderSize]     = 0;
+        headerStart[expectedHeaderSize + 1] = 0;
+    }
+
+    // The RTP "M" (marker) bit indicates the last fragment of a frame:
+    fCurrentPacketCompletesFrame = packet->rtpMarkerBit();
+
+    resultSpecialHeaderSize = expectedHeaderSize;
+    return True;
+}
+
+char const *H263plusVideoRTPSource::MIMEtype() const {
+    return "video/H263-1998";
+}
diff --git a/3rdparty/live555/src/liveMedia/H263plusVideoStreamFramer.cpp b/3rdparty/live555/src/liveMedia/H263plusVideoStreamFramer.cpp
new file mode 100644
index 00000000..0fdc85e5
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/H263plusVideoStreamFramer.cpp
@@ -0,0 +1,112 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// Author Bernhard Feiten
+// A filter that breaks up an H.263plus video stream into frames.
+//
+
+#include "H263plusVideoStreamFramer.hh"
+#include "H263plusVideoStreamParser.hh"
+
+#include <string.h>
+#include <GroupsockHelper.hh>
+
+///////////////////////////////////////////////////////////////////////////////
+////////// H263plusVideoStreamFramer implementation //////////
+// public///////////////////////////////////////////////////////////////////////
+H263plusVideoStreamFramer *H263plusVideoStreamFramer::createNew(UsageEnvironment &env, FramedSource *inputSource) {
+    // Need to add source type checking here???  #####
+    H263plusVideoStreamFramer *fr;
+    fr = new H263plusVideoStreamFramer(env, inputSource);
+    return fr;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+H263plusVideoStreamFramer::H263plusVideoStreamFramer(UsageEnvironment &env, FramedSource *inputSource, Boolean createParser)
+    : FramedFilter(env, inputSource),
+      fFrameRate(0.0),  // until we learn otherwise
+      fPictureEndMarker(False) {
+    // Use the current wallclock time as the base 'presentation time':
+    gettimeofday(&fPresentationTimeBase, NULL);
+    fParser = createParser ? new H263plusVideoStreamParser(this, inputSource) : NULL;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+H263plusVideoStreamFramer::~H263plusVideoStreamFramer() {
+    delete fParser;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+void H263plusVideoStreamFramer::doGetNextFrame() {
+    fParser->registerReadInterest(fTo, fMaxSize);
+    continueReadProcessing();
+}
+
+///////////////////////////////////////////////////////////////////////////////
+Boolean H263plusVideoStreamFramer::isH263plusVideoStreamFramer() const {
+    return True;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+void H263plusVideoStreamFramer::continueReadProcessing(void *clientData, unsigned char * /*ptr*/, unsigned /*size*/, struct timeval /*presentationTime*/) {
+    H263plusVideoStreamFramer *framer = (H263plusVideoStreamFramer *)clientData;
+    framer->continueReadProcessing();
+}
+
+///////////////////////////////////////////////////////////////////////////////
+void H263plusVideoStreamFramer::continueReadProcessing() {
+    unsigned acquiredFrameSize;
+
+    u_int64_t frameDuration;  // in ms
+
+    acquiredFrameSize = fParser->parse(frameDuration);
+    // Calculate some average bitrate information (to be adapted)
+    //	avgBitrate = (totalBytes * 8 * H263_TIMESCALE) / totalDuration;
+
+    if(acquiredFrameSize > 0) {
+        // We were able to acquire a frame from the input.
+        // It has already been copied to the reader's space.
+        fFrameSize = acquiredFrameSize;
+        //    fNumTruncatedBytes = fParser->numTruncatedBytes(); // not needed so far
+
+        fFrameRate = frameDuration == 0 ? 0.0 : 1000. / (long)frameDuration;
+
+        // Compute "fPresentationTime"
+        if(acquiredFrameSize == 5)  // first frame
+            fPresentationTime = fPresentationTimeBase;
+        else
+            fPresentationTime.tv_usec += (long)frameDuration * 1000;
+
+        while(fPresentationTime.tv_usec >= 1000000) {
+            fPresentationTime.tv_usec -= 1000000;
+            ++fPresentationTime.tv_sec;
+        }
+
+        // Compute "fDurationInMicroseconds"
+        fDurationInMicroseconds = (unsigned int)frameDuration * 1000;
+        ;
+
+        // Call our own 'after getting' function.  Because we're not a 'leaf'
+        // source, we can call this directly, without risking infinite recursion.
+        afterGetting(this);
+    }
+    else {
+        // We were unable to parse a complete frame from the input, because:
+        // - we had to read more data from the source stream, or
+        // - the source stream has ended.
+    }
+}
diff --git a/3rdparty/live555/src/liveMedia/H263plusVideoStreamParser.cpp b/3rdparty/live555/src/liveMedia/H263plusVideoStreamParser.cpp
new file mode 100644
index 00000000..22d3955b
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/H263plusVideoStreamParser.cpp
@@ -0,0 +1,816 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// Author Bernhard Feiten
+// A filter that breaks up an H.263plus video stream into frames.
+// Based on MPEG4IP/mp4creator/h263.c
+
+#include "H263plusVideoStreamParser.hh"
+#include "H263plusVideoStreamFramer.hh"
+// #include <string.h>
+// #include "GroupsockHelper.hh"
+
+H263plusVideoStreamParser::H263plusVideoStreamParser(H263plusVideoStreamFramer *usingSource, FramedSource *inputSource)
+    : StreamParser(inputSource, FramedSource::handleClosure, usingSource, &H263plusVideoStreamFramer::continueReadProcessing, usingSource),
+      fUsingSource(usingSource),
+      fnextTR(0),
+      fcurrentPT(0) {
+    memset(fStates, 0, sizeof(fStates));
+    memset(&fNextInfo, 0, sizeof(fNextInfo));
+    memset(&fCurrentInfo, 0, sizeof(fCurrentInfo));
+    memset(&fMaxBitrateCtx, 0, sizeof(fMaxBitrateCtx));
+    memset(fNextHeader, 0, H263_REQUIRE_HEADER_SIZE_BYTES);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+H263plusVideoStreamParser::~H263plusVideoStreamParser() {}
+
+///////////////////////////////////////////////////////////////////////////////
+void H263plusVideoStreamParser::restoreSavedParserState() {
+    StreamParser::restoreSavedParserState();
+    fTo                = fSavedTo;
+    fNumTruncatedBytes = fSavedNumTruncatedBytes;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+void H263plusVideoStreamParser::setParseState() {
+    fSavedTo                = fTo;
+    fSavedNumTruncatedBytes = fNumTruncatedBytes;
+    saveParserState();  // Needed for the parsing process in StreamParser
+}
+
+///////////////////////////////////////////////////////////////////////////////
+void H263plusVideoStreamParser::registerReadInterest(unsigned char *to, unsigned maxSize) {
+    fStartOfFrame = fTo = fSavedTo = to;
+    fLimit                         = to + maxSize;
+    fMaxSize                       = maxSize;
+    fNumTruncatedBytes = fSavedNumTruncatedBytes = 0;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// parse() ,  derived from H263Creator of MPEG4IP, h263.c
+unsigned H263plusVideoStreamParser::parse(u_int64_t &currentDuration) {
+
+    //   u_int8_t       frameBuffer[H263_BUFFER_SIZE]; // The input buffer
+    // Pointer which tells LoadNextH263Object where to read data to
+    //   u_int8_t*      pFrameBuffer = fTo + H263_REQUIRE_HEADER_SIZE_BYTES;
+    u_int32_t frameSize;    // The current frame size
+                            // Pointer to receive address of the header data
+                            //   u_int8_t*      pCurrentHeader;// = pFrameBuffer;
+                            //   u_int64_t      currentDuration;  // The current frame's duration
+    u_int8_t trDifference;  // The current TR difference
+                            // The previous TR difference
+                            //   u_int8_t       prevTrDifference = H263_BASIC_FRAME_RATE;
+                            //   u_int64_t      totalDuration = 0;// Duration accumulator
+                            //   u_int64_t      avgBitrate;       // Average bitrate
+                            //   u_int64_t      totalBytes = 0;   // Size accumulator
+
+    try  // The get data routines of the class FramedFilter returns an error when
+    {    // the buffer is empty. This occurs at the beginning and at the end of the file.
+        fCurrentInfo = fNextInfo;
+
+        // Parse 1 frame
+        // For the first time, only the first frame's header is returned.
+        // The second time the full first frame is returned
+        frameSize = parseH263Frame();
+
+        currentDuration = 0;
+        if((frameSize > 0)) {
+            // We were able to acquire a frame from the input.
+
+            // Parse the returned frame header (if any)
+            if(!ParseShortHeader(fTo, &fNextInfo)) {
+#ifdef DEBUG
+                fprintf(stderr, "H263plusVideoStreamParser: Fatal error\n");
+#endif
+            }
+
+            trDifference = GetTRDifference(fNextInfo.tr, fCurrentInfo.tr);
+
+            // calculate the current frame duration
+            currentDuration = CalculateDuration(trDifference);
+
+            // Accumulate the frame's size and duration for avgBitrate calculation
+            // totalDuration += currentDuration;
+            // totalBytes += frameSize;
+            //  If needed, recalculate bitrate information
+            //    if (h263Bitrates)
+            // GetMaxBitrate(&fMaxBitrateCtx, frameSize, prevTrDifference);
+            // prevTrDifference = trDifference;
+
+            setParseState();  // Needed for the parsing process in StreamParser
+        }
+    }
+    catch(int /*e*/) {
+#ifdef DEBUG
+        fprintf(stderr, "H263plusVideoStreamParser::parse() EXCEPTION (This is normal behavior - *not* an error)\n");
+#endif
+        frameSize = 0;
+    }
+
+    return frameSize;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// parseH263Frame derived from LoadNextH263Object of MPEG4IP
+// - service routine that reads a single frame from the input file.
+// It shall fill the input buffer with data up until - and including - the
+// next start code and shall report back both the number of bytes read and a
+// pointer to the next start code. The first call to this function shall only
+// yield a pointer with 0 data bytes and the last call to this function shall
+// only yield data bytes with a NULL pointer as the next header.
+//
+// TODO: This function only supports valid bit streams. Upon error, it fails
+// without the possibility to recover. A Better idea would be to skip frames
+// until a parsable frame is read from the file.
+//
+// Parameters:
+//      ppNextHeader - output parameter that upon return points to the location
+//                     of the next frame's head in the buffer.
+//                     This pointer shall be NULL for the last frame read.
+// Returns the total number of bytes read.
+// Uses FrameFileSource intantiated by constructor.
+///////////////////////////////////////////////////////////////////////////////
+int H263plusVideoStreamParser::parseH263Frame() {
+    char      row         = 0;
+    u_int8_t *bufferIndex = fTo;
+    // The buffer end which will allow the loop to leave place for
+    // the additionalBytesNeeded
+    u_int8_t *bufferEnd = fTo + fMaxSize - ADDITIONAL_BYTES_NEEDED - 1;
+
+    memcpy(fTo, fNextHeader, H263_REQUIRE_HEADER_SIZE_BYTES);
+    bufferIndex += H263_REQUIRE_HEADER_SIZE_BYTES;
+
+    // The state table and the following loop implements a state machine enabling
+    // us to read bytes from the file until (and inclusing) the requested
+    // start code (00 00 8X) is found
+
+    // Initialize the states array, if it hasn't been initialized yet...
+    if(!fStates[0][0]) {
+        // One 00 was read
+        fStates[0][0] = 1;
+        // Two sequential 0x00 ware read
+        fStates[1][0] = fStates[2][0] = 2;
+        // A full start code was read
+        fStates[2][128] = fStates[2][129] = fStates[2][130] = fStates[2][131] = -1;
+    }
+
+    // Read data from file into the output buffer until either a start code
+    // is found, or the end of file has been reached.
+    do {
+        *bufferIndex = get1Byte();
+    } while((bufferIndex < bufferEnd) &&                                          // We have place in the buffer
+            ((int)(row = fStates[(unsigned char)row][*(bufferIndex++)]) != -1));  // Start code was not found
+
+    if((int)row != -1) {
+        fprintf(stderr, "%s: Buffer too small (%u)\n", "h263reader:", bufferEnd - fTo + ADDITIONAL_BYTES_NEEDED);
+        return 0;
+    }
+
+    // Cool ... now we have a start code
+    // Now we just have to read the additionalBytesNeeded
+    getBytes(bufferIndex, ADDITIONAL_BYTES_NEEDED);
+    memcpy(fNextHeader, bufferIndex - H263_STARTCODE_SIZE_BYTES, H263_REQUIRE_HEADER_SIZE_BYTES);
+
+    int sz = bufferIndex - fTo - H263_STARTCODE_SIZE_BYTES;
+
+    if(sz == 5)  // first frame
+        memcpy(fTo, fTo + H263_REQUIRE_HEADER_SIZE_BYTES, H263_REQUIRE_HEADER_SIZE_BYTES);
+
+    return sz;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// ParseShortHeader - service routine that accepts a buffer containing a frame
+// header and extracts relevant codec information from it.
+//
+// NOTE: the first bit in the following commnets is 0 (zero).
+//
+//       0                   1                   2                   3
+//       0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+//      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//      |      PSC (Picture Start Code=22 bits)     |  (TR=8 bits)  |   >
+//      |0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0|               |1 0>
+//      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//      <   (PTYPE=13 bits)   |
+//      <. . .|(FMT)|Z|. . . .|
+//      +-+-+-+-+-+-+-+-+-+-+-+
+//      -> PTYPE.FMT contains a width/height identification
+//      -> PTYPE.Z   is 1 for P-Frames, 0 for I-Frames
+//      Note: When FMT is 111, there is an extended PTYPE...
+//
+// Inputs:
+//      headerBuffer - pointer to the current header buffer
+//      outputInfoStruct - pointer to the structure receiving the data
+// Outputs:
+//      This function returns a structure of important codec-specific
+//      information (The Temporal Reference bits, width & height of the current
+//      frame and the sync - or "frame type" - bit. It reports success or
+//      failure to the calling function.
+////////////////////////////////////////////////////////////////////////////////
+bool H263plusVideoStreamParser::ParseShortHeader(u_int8_t *headerBuffer, H263INFO *outputInfoStruct) {
+    u_int8_t fmt = 0;
+    // Extract temporal reference (TR) from the buffer (bits 22-29 inclusive)
+    outputInfoStruct->tr = (headerBuffer[2] << 6) & 0xC0;   // 2 LS bits out of the 3rd byte
+    outputInfoStruct->tr |= (headerBuffer[3] >> 2) & 0x3F;  // 6 MS bits out of the 4th byte
+    // Extract the FMT part of PTYPE from the buffer (bits 35-37 inclusive)
+    fmt = (headerBuffer[4] >> 2) & 0x07;  // bits 3-5 ouf of the 5th byte
+    // If PTYPE is not supported, return a failure notice to the calling function
+    // FIXME: PLUSPTYPE is not supported
+    if(fmt == 0x07) {
+        return false;
+    }
+    // If PTYPE is supported, calculate the current width and height according to
+    // a predefined table
+    if(!GetWidthAndHeight(fmt, &(outputInfoStruct->width), &(outputInfoStruct->height))) {
+        return false;
+    }
+    // Extract the frame-type bit, which is the 9th bit of PTYPE (bit 38)
+    outputInfoStruct->isSyncFrame = !(headerBuffer[4] & 0x02);
+
+    return true;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// GetMaxBitrate- service routine that accepts frame information and
+// derives bitrate information from it. This function uses a sliding window
+// technique to calculate the maximum bitrates in any window of 1 second
+// inside the file.
+// The sliding window is implemented with a table of bitrates for the last
+// second (30 entries - one entry per TR unit).
+//
+// Inputs:
+//      ctx - context for this function
+//      frameSize - the size of the current frame in bytes
+//      frameTRDiff - the "duration" of the frame in TR units
+// Outputs:
+//      This function returns the up-to-date maximum bitrate
+////////////////////////////////////////////////////////////////////////////////
+void H263plusVideoStreamParser::GetMaxBitrate(MaxBitrate_CTX *ctx, u_int32_t frameSize, u_int8_t frameTRDiff) {
+    if(frameTRDiff == 0)
+        return;
+
+    // Calculate the current frame's bitrate as bits per TR unit (round the result
+    // upwards)
+    u_int32_t frameBitrate = frameSize * 8 / frameTRDiff + 1;
+
+    // for each TRdiff received,
+    while(frameTRDiff--) {
+        // Subtract the oldest bitrate entry from the current bitrate
+        ctx->windowBitrate -= ctx->bitrateTable[ctx->tableIndex];
+        // Update the oldest bitrate entry with the current frame's bitrate
+        ctx->bitrateTable[ctx->tableIndex] = frameBitrate;
+        // Add the current frame's bitrate to the current bitrate
+        ctx->windowBitrate += frameBitrate;
+        // Check if we have a new maximum bitrate
+        if(ctx->windowBitrate > ctx->maxBitrate) {
+            ctx->maxBitrate = ctx->windowBitrate;
+        }
+        // Advance the table index
+        // Wrapping around the bitrateTable size
+        ctx->tableIndex = (ctx->tableIndex + 1) % (sizeof(ctx->bitrateTable) / sizeof(ctx->bitrateTable[0]));
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// CalculateDuration - service routine that calculates the current frame's
+// duration in milli-seconds using it's duration in TR units.
+//  - In order not to accumulate the calculation error, we are using the TR
+// duration to calculate the current and the next frame's presentation time in
+// milli-seconds.
+//
+// Inputs: trDiff - The current frame's duration in TR units
+// Return: The current frame's duration in milli-seconds
+////////////////////////////////////////////////////////////////////////////////
+u_int64_t H263plusVideoStreamParser::CalculateDuration(u_int8_t trDiff) {
+    u_int64_t nextPT;    // The next frame's presentation time in milli-seconds
+    u_int64_t duration;  // The current frame's duration in milli-seconds
+
+    fnextTR += trDiff;
+    // Calculate the next frame's presentation time, in milli-seconds
+    nextPT = (fnextTR * 1001) / H263_BASIC_FRAME_RATE;
+    // The frame's duration is the difference between the next presentation
+    // time and the current presentation time.
+    duration = nextPT - fcurrentPT;
+    // "Remember" the next presentation time for the next time this function is called
+    fcurrentPT = nextPT;
+
+    return duration;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+bool H263plusVideoStreamParser::GetWidthAndHeight(u_int8_t fmt, u_int16_t *width, u_int16_t *height) {
+    // The 'fmt' corresponds to bits 5-7 of the PTYPE
+    static struct {
+        u_int16_t width;
+        u_int16_t height;
+    } const dimensionsTable[8] = {
+        { 0, 0 },        // 000 - 0 - forbidden, generates an error
+        { 128, 96 },     // 001 - 1 - Sub QCIF
+        { 176, 144 },    // 010 - 2 - QCIF
+        { 352, 288 },    // 011 - 3 - CIF
+        { 704, 576 },    // 100 - 4 - 4CIF
+        { 1409, 1152 },  // 101 - 5 - 16CIF
+        { 0, 0 },        // 110 - 6 - reserved, generates an error
+        { 0, 0 }         // 111 - 7 - extended, not supported by profile 0
+    };
+
+    if(fmt > 7)
+        return false;
+
+    *width  = dimensionsTable[fmt].width;
+    *height = dimensionsTable[fmt].height;
+
+    if(*width == 0)
+        return false;
+
+    return true;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+u_int8_t H263plusVideoStreamParser::GetTRDifference(u_int8_t nextTR, u_int8_t currentTR) {
+    if(currentTR > nextTR) {
+        // Wrap around 255...
+        return nextTR + (256 - currentTR);
+    }
+    else {
+        return nextTR - currentTR;
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+// this is the h263.c file of MPEG4IP mp4creator
+/*
+#include "mp4creator.h"
+
+// Default timescale for H.263 (1000ms)
+#define H263_TIMESCALE 1000
+// Default H263 frame rate (30fps)
+#define H263_BASIC_FRAME_RATE 30
+
+// Minimum number of bytes needed to parse an H263 header
+#define H263_REQUIRE_HEADER_SIZE_BYTES 5
+// Number of bytes the start code requries
+#define H263_STARTCODE_SIZE_BYTES 3
+// This is the input buffer's size. It should contain
+// 1 frame with the following start code
+#define H263_BUFFER_SIZE 256 * 1024
+// The default max different (in %) betwqeen max and average bitrates
+#define H263_DEFAULT_CBR_TOLERANCE  10
+
+// The following structure holds information extracted from each frame's header:
+typedef struct _H263INFO {
+  u_int8_t  tr;                 // Temporal Reference, used in duration calculation
+  u_int16_t width;              // Width of the picture
+  u_int16_t height;             // Height of the picture
+  bool      isSyncFrame;        // Frame type (true = I frame = "sync" frame)
+} H263INFO;
+
+// Context for the GetMaxBitrate function
+typedef struct _MaxBitrate_CTX {
+  u_int32_t  bitrateTable[H263_BASIC_FRAME_RATE];// Window of 1 second
+  u_int32_t  windowBitrate;              // The bitrate of the current window
+  u_int32_t  maxBitrate;                 // The up-to-date maximum bitrate
+  u_int32_t  tableIndex;                 // The next TR unit to update
+} MaxBitrate_CTX;
+
+// Forward declarations:
+static int LoadNextH263Object(  FILE           *inputFileHandle,
+                                u_int8_t       *frameBuffer,
+                                u_int32_t      *frameBufferSize,
+                                u_int32_t       additionalBytesNeeded,
+                                u_int8_t      **ppNextHeader);
+
+static bool ParseShortHeader(   u_int8_t       *headerBuffer,
+                                H263INFO       *outputInfoStruct);
+
+static u_int8_t GetTRDifference(u_int8_t        nextTR,
+                                u_int8_t        currentTR);
+
+static void GetMaxBitrate(      MaxBitrate_CTX *ctx,
+                                u_int32_t       frameSize,
+                                u_int8_t        frameTRDiff);
+
+static MP4Duration CalculateDuration(u_int8_t   trDiff);
+
+static bool GetWidthAndHeight(  u_int8_t        fmt,
+                                u_int16_t      *width,
+                                u_int16_t      *height);
+
+static char   states[3][256];
+/ *
+ * H263Creator - Main function
+ * Inputs:
+ *      outputFileHandle - The handle of the output file
+ *      inputFileHandle - The handle of the input file
+ *      Codec-specific parameters:
+ *              H263Level - H.263 Level used for this track
+ *              H263Profile - H.263 Profile used for this track
+ *              H263Bitrates - A Parameter indicating whether the function
+ *                             should calculate H263 bitrates or not.
+ *              cbrTolerance - CBR tolerance indicates when to set the
+ *                             average bitrate.
+ * Outputs:
+ *      This function returns either the track ID of the newly added track upon
+ *      success or a predefined value representing an erroneous state.
+ * /
+MP4TrackId H263Creator(MP4FileHandle outputFileHandle,
+                       FILE*         inputFileHandle,
+                       u_int8_t      h263Profile,
+                       u_int8_t      h263Level,
+                       bool          h263Bitrates,
+                       u_int8_t      cbrTolerance)
+{
+  H263INFO       nextInfo;   // Holds information about the next frame
+  H263INFO       currentInfo;// Holds information about the current frame
+  MaxBitrate_CTX maxBitrateCtx;// Context for the GetMaxBitrate function
+  memset(&nextInfo, 0, sizeof(nextInfo));
+  memset(&currentInfo, 0, sizeof(currentInfo));
+  memset(&maxBitrateCtx, 0, sizeof(maxBitrateCtx));
+  memset(states, 0, sizeof(states));
+  u_int8_t       frameBuffer[H263_BUFFER_SIZE]; // The input buffer
+                 // Pointer which tells LoadNextH263Object where to read data to
+  u_int8_t*      pFrameBuffer = frameBuffer + H263_REQUIRE_HEADER_SIZE_BYTES;
+  u_int32_t      frameSize;        // The current frame size
+                                // Pointer to receive address of the header data
+  u_int8_t*      pCurrentHeader = pFrameBuffer;
+  MP4Duration    currentDuration;  // The current frame's duration
+  u_int8_t       trDifference;     // The current TR difference
+                                   // The previous TR difference
+  u_int8_t       prevTrDifference = H263_BASIC_FRAME_RATE;
+  MP4Duration    totalDuration = 0;// Duration accumulator
+  MP4Duration    avgBitrate;       // Average bitrate
+  u_int64_t      totalBytes = 0;   // Size accumulator
+  MP4TrackId     trackId = MP4_INVALID_TRACK_ID; // Our MP4 track
+  bool           stay = true;      // loop flag
+
+  while (stay) {
+    currentInfo = nextInfo;
+    memmove(frameBuffer, pCurrentHeader, H263_REQUIRE_HEADER_SIZE_BYTES);
+    frameSize = H263_BUFFER_SIZE - H263_REQUIRE_HEADER_SIZE_BYTES;
+    // Read 1 frame and the next frame's header from the file.
+    // For the first frame, only the first frame's header is returned.
+    // For the last frame, only the last frame's data is returned.
+    if (! LoadNextH263Object(inputFileHandle, pFrameBuffer, &frameSize,
+          H263_REQUIRE_HEADER_SIZE_BYTES - H263_STARTCODE_SIZE_BYTES,
+          &pCurrentHeader))
+      break; // Fatal error ...
+
+    if (pCurrentHeader) {
+      // Parse the returned frame header (if any)
+      if (!ParseShortHeader(pCurrentHeader, &nextInfo))
+        break; // Fatal error
+      trDifference = GetTRDifference(nextInfo.tr, currentInfo.tr);
+    } else {
+      // This is the last frame ... we have to fake the trDifference ...
+      trDifference = 1;
+      // No header data has been read at this iteration, so we have to manually
+      // add the frame's header we read at the previous iteration.
+      // Note that LoadNextH263Object returns the number of bytes read, which
+      // are the current frame's data and the next frame's header
+      frameSize += H263_REQUIRE_HEADER_SIZE_BYTES;
+      // There is no need for the next iteration ...
+      stay = false;
+    }
+
+    // If this is the first iteration ...
+    if (currentInfo.width == 0) {
+      // If we have more data than just the header
+      if ((frameSize > H263_REQUIRE_HEADER_SIZE_BYTES) ||
+          !pCurrentHeader)  // Or no header at all
+        break;     // Fatal error
+      else
+        continue;  // We have only the first frame's header ...
+    }
+
+    if (trackId == MP4_INVALID_TRACK_ID) {
+      //  If a track has not been added yet, add the track to the file.
+      trackId = MP4AddH263VideoTrack(outputFileHandle, H263_TIMESCALE,
+          0, currentInfo.width, currentInfo.height,
+          h263Level, h263Profile, 0, 0);
+      if (trackId == MP4_INVALID_TRACK_ID)
+        break; // Fatal error
+    }
+
+    // calculate the current frame duration
+    currentDuration = CalculateDuration(trDifference);
+    // Write the current frame to the file.
+    if (!MP4WriteSample(outputFileHandle, trackId, frameBuffer, frameSize,
+          currentDuration, 0, currentInfo.isSyncFrame))
+      break; // Fatal error
+
+    // Accumulate the frame's size and duration for avgBitrate calculation
+    totalDuration += currentDuration;
+    totalBytes += frameSize;
+    //  If needed, recalculate bitrate information
+    if (h263Bitrates)
+      GetMaxBitrate(&maxBitrateCtx, frameSize, prevTrDifference);
+    prevTrDifference = trDifference;
+  } // while (stay)
+
+  // If this is the last frame,
+  if (!stay) {
+    // If needed and possible, update bitrate information in the file
+    if (h263Bitrates && totalDuration) {
+      avgBitrate = (totalBytes * 8 * H263_TIMESCALE) / totalDuration;
+      if (cbrTolerance == 0)
+        cbrTolerance = H263_DEFAULT_CBR_TOLERANCE;
+      // Same as: if (maxBitrate / avgBitrate > (cbrTolerance + 100) / 100.0)
+      if (maxBitrateCtx.maxBitrate * 100 > (cbrTolerance + 100) * avgBitrate)
+        avgBitrate = 0;
+      MP4SetH263Bitrates(outputFileHandle, trackId,
+          avgBitrate, maxBitrateCtx.maxBitrate);
+    }
+    // Return the newly added track ID
+    return trackId;
+  }
+
+  // If we got to here... something went wrong ...
+  fprintf(stderr,
+    "%s: Could not parse input file, invalid video stream?\n", ProgName);
+  // Upon failure, delete the newly added track if it has been added
+  if (trackId != MP4_INVALID_TRACK_ID) {
+    MP4DeleteTrack(outputFileHandle, trackId);
+  }
+  return MP4_INVALID_TRACK_ID;
+}
+
+/ *
+ * LoadNextH263Object - service routine that reads a single frame from the input
+ * file. It shall fill the input buffer with data up until - and including - the
+ * next start code and shall report back both the number of bytes read and a
+ * pointer to the next start code. The first call to this function shall only
+ * yield a pointer with 0 data bytes and the last call to this function shall
+ * only yield data bytes with a NULL pointer as the next header.
+ *
+ * TODO: This function only supports valid bit streams. Upon error, it fails
+ * without the possibility to recover. A Better idea would be to skip frames
+ * until a parsable frame is read from the file.
+ *
+ * Parameters:
+ *      inputFileHandle - The handle of the input file
+ *      frameBuffer - buffer where to place read data
+ *      frameBufferSize - in/out parameter indicating the size of the buffer on
+ *                          entry and the number of bytes copied to the buffer upon
+ *                          return
+ *      additionalBytesNeeded - indicates how many additional bytes are to be read
+ *                          from the next frame's header (over the 3 bytes that
+ *                          are already read).
+ *                          NOTE: This number MUST be > 0
+ *      ppNextHeader - output parameter that upon return points to the location
+ *                     of the next frame's head in the buffer
+ * Outputs:
+ *      This function returns two pieces of information:
+ *      1. The total number of bytes read.
+ *      2. A Pointer to the header of the next frame. This pointer shall be NULL
+ *      for the last frame read.
+ * /
+static int LoadNextH263Object(  FILE           *inputFileHandle,
+                                u_int8_t       *frameBuffer,
+                                u_int32_t      *frameBufferSize,
+                                u_int32_t       additionalBytesNeeded,
+                                u_int8_t      **ppNextHeader)
+{
+  // This table and the following loop implements a state machine enabling
+  // us to read bytes from the file untill (and inclusing) the requested
+  // start code (00 00 8X) is found
+  char        row = 0;
+  u_int8_t     *bufferStart = frameBuffer;
+  // The buffer end which will allow the loop to leave place for
+  // the additionalBytesNeeded
+  u_int8_t     *bufferEnd = frameBuffer + *frameBufferSize -
+                                              additionalBytesNeeded - 1;
+
+  // Initialize the states array, if it hasn't been initialized yet...
+  if (!states[0][0]) {
+    // One 00 was read
+    states[0][0] = 1;
+    // Two sequential 0x00 ware read
+    states[1][0] = states[2][0] = 2;
+    // A full start code was read
+    states[2][128] = states[2][129] = states[2][130] = states[2][131] = -1;
+  }
+
+  // Read data from file into the output buffer until either a start code
+  // is found, or the end of file has been reached.
+  do {
+    if (fread(frameBuffer, 1, 1, inputFileHandle) != 1){
+      // EOF or other error before we got a start code
+      *ppNextHeader = NULL;
+      *frameBufferSize = frameBuffer - bufferStart;
+      return 1;
+    }
+  } while ((frameBuffer < bufferEnd) &&                    // We have place in the buffer
+           ((row = states[row][*(frameBuffer++)]) != -1)); // Start code was not found
+  if (row != -1) {
+    fprintf(stderr, "%s: Buffer too small (%u)\n",
+            ProgName, bufferEnd - bufferStart + additionalBytesNeeded);
+    return 0;
+  }
+
+  // Cool ... now we have a start code
+  *ppNextHeader = frameBuffer - H263_STARTCODE_SIZE_BYTES;
+  *frameBufferSize = frameBuffer - bufferStart + additionalBytesNeeded;
+
+  // Now we just have to read the additionalBytesNeeded
+  if(fread(frameBuffer, additionalBytesNeeded, 1, inputFileHandle) != 1) {
+    /// We got a start code but can't read additionalBytesNeeded ... that's a fatal error
+    fprintf(stderr, "%s: Invalid H263 bitstream\n", ProgName);
+    return 0;
+  }
+
+  return 1;
+}
+
+
+/ *
+ * ParseShortHeader - service routine that accepts a buffer containing a frame
+ * header and extracts relevant codec information from it.
+ *
+ * NOTE: the first bit in the following commnets is 0 (zero).
+ *
+ *
+ *       0                   1                   2                   3
+ *       0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+ *      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ *      |      PSC (Picture Start Code=22 bits)     |  (TR=8 bits)  |   >
+ *      |0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0|               |1 0>
+ *      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ *      <   (PTYPE=13 bits)   |
+ *      <. . .|(FMT)|Z|. . . .|
+ *      +-+-+-+-+-+-+-+-+-+-+-+
+ *      -> PTYPE.FMT contains a width/height identification
+ *      -> PTYPE.Z   is 1 for P-Frames, 0 for I-Frames
+ *      Note: When FMT is 111, there is an extended PTYPE...
+ *
+ * Inputs:
+ *      headerBuffer - pointer to the current header buffer
+ *      outputInfoStruct - pointer to the structure receiving the data
+ * Outputs:
+ *      This function returns a structure of important codec-specific
+ *      information (The Temporal Reference bits, width & height of the current
+ *      frame and the sync - or "frame type" - bit. It reports success or
+ *      failure to the calling function.
+ * /
+static bool ParseShortHeader(   u_int8_t       *headerBuffer,
+                                H263INFO       *outputInfoStruct)
+{
+  u_int8_t fmt = 0;
+  // Extract temporal reference (TR) from the buffer (bits 22-29 inclusive)
+  outputInfoStruct->tr  = (headerBuffer[2] << 6) & 0xC0; // 2 LS bits out of the 3rd byte
+  outputInfoStruct->tr |= (headerBuffer[3] >> 2) & 0x3F; // 6 MS bits out of the 4th byte
+  // Extract the FMT part of PTYPE from the buffer (bits 35-37 inclusive)
+  fmt = (headerBuffer[4] >> 2) & 0x07; // bits 3-5 ouf of the 5th byte
+  // If PTYPE is not supported, return a failure notice to the calling function
+  // FIXME: PLUSPTYPE is not supported
+   if (fmt == 0x07) {
+    return false;
+  }
+  // If PTYPE is supported, calculate the current width and height according to
+  // a predefined table
+  if (!GetWidthAndHeight(fmt, &(outputInfoStruct->width),
+                              &(outputInfoStruct->height))) {
+    return false;
+  }
+  // Extract the frame-type bit, which is the 9th bit of PTYPE (bit 38)
+  outputInfoStruct->isSyncFrame = !(headerBuffer[4] & 0x02);
+
+  return true;
+}
+
+/ *
+ * GetMaxBitrate- service routine that accepts frame information and
+ * derives bitrate information from it. This function uses a sliding window
+ * technique to calculate the maximum bitrates in any window of 1 second
+ * inside the file.
+ * The sliding window is implemented with a table of bitrates for the last
+ * second (30 entries - one entry per TR unit).
+ *
+ * Inputs:
+ *      ctx - context for this function
+ *      frameSize - the size of the current frame in bytes
+ *      frameTRDiff - the "duration" of the frame in TR units
+ * Outputs:
+ *      This function returns the up-to-date maximum bitrate
+ * /
+static void GetMaxBitrate(      MaxBitrate_CTX *ctx,
+                                u_int32_t       frameSize,
+                                u_int8_t        frameTRDiff)
+{
+  if (frameTRDiff == 0)
+    return;
+
+  // Calculate the current frame's bitrate as bits per TR unit (round the result
+  // upwards)
+  u_int32_t frameBitrate = frameSize * 8 / frameTRDiff + 1;
+
+  // for each TRdiff received,
+  while (frameTRDiff--) {
+    // Subtract the oldest bitrate entry from the current bitrate
+    ctx->windowBitrate -= ctx->bitrateTable[ctx->tableIndex];
+     // Update the oldest bitrate entry with the current frame's bitrate
+    ctx->bitrateTable[ctx->tableIndex] = frameBitrate;
+    // Add the current frame's bitrate to the current bitrate
+    ctx->windowBitrate += frameBitrate;
+    // Check if we have a new maximum bitrate
+    if (ctx->windowBitrate > ctx->maxBitrate) {
+      ctx->maxBitrate = ctx->windowBitrate;
+    }
+    // Advance the table index
+    ctx->tableIndex = (ctx->tableIndex + 1) %
+        // Wrapping around the bitrateTable size
+        ( sizeof(ctx->bitrateTable) / sizeof(ctx->bitrateTable[0]) );
+  }
+}
+
+/ *
+ * CalculateDuration - service routine that calculates the current frame's
+ * duration in milli-seconds using it's duration in TR units.
+ *  - In order not to accumulate the calculation error, we are using the TR
+ * duration to calculate the current and the next frame's presentation time in
+ * milli-seconds.
+ *
+ * Inputs:
+ *      trDiff - The current frame's duration in TR units
+ * Outputs:
+ *      The current frame's duration in milli-seconds
+ * /
+static MP4Duration CalculateDuration(u_int8_t   trDiff)
+{
+  static u_int32_t const    nextTR    = 0;   // The next frame's presentation time in TR units
+  static MP4Duration const  currentPT = 0;   // The current frame's presentation time in milli-seconds
+  MP4Duration         nextPT;          // The next frame's presentation time in milli-seconds
+  MP4Duration         duration;        // The current frame's duration in milli-seconds
+
+  nextTR += trDiff;
+  // Calculate the next frame's presentation time, in milli-seconds
+  nextPT = (nextTR * 1001) / H263_BASIC_FRAME_RATE;
+  // The frame's duration is the difference between the next presentation
+  // time and the current presentation time.
+  duration = nextPT - currentPT;
+  // "Remember" the next presentation time for the next time this function is
+  // called
+  currentPT = nextPT;
+
+  return duration;
+}
+
+static bool GetWidthAndHeight(  u_int8_t        fmt,
+                                u_int16_t      *width,
+                                u_int16_t      *height)
+{
+  // The 'fmt' corresponds to bits 5-7 of the PTYPE
+  static struct {
+    u_int16_t width;
+    u_int16_t height;
+  } const dimensionsTable[8] = {
+    { 0,    0 },      // 000 - 0 - forbidden, generates an error
+    { 128,  96 },     // 001 - 1 - Sub QCIF
+    { 176,  144 },    // 010 - 2 - QCIF
+    { 352,  288 },    // 011 - 3 - CIF
+    { 704,  576 },    // 100 - 4 - 4CIF
+    { 1409, 1152 },   // 101 - 5 - 16CIF
+    { 0,    0 },      // 110 - 6 - reserved, generates an error
+    { 0,    0 }       // 111 - 7 - extended, not supported by profile 0
+  };
+
+  if (fmt > 7)
+    return false;
+
+  *width  = dimensionsTable[fmt].width;
+  *height = dimensionsTable[fmt].height;
+
+  if (*width  == 0)
+    return false;
+
+  return true;
+}
+
+static u_int8_t GetTRDifference(u_int8_t        nextTR,
+                                u_int8_t        currentTR)
+{
+  if (currentTR > nextTR) {
+    // Wrap around 255...
+    return nextTR + (256 - currentTR);
+  } else {
+    return nextTR - currentTR;
+  }
+}
+
+*/
diff --git a/3rdparty/live555/src/liveMedia/H263plusVideoStreamParser.hh b/3rdparty/live555/src/liveMedia/H263plusVideoStreamParser.hh
new file mode 100644
index 00000000..471ae645
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/H263plusVideoStreamParser.hh
@@ -0,0 +1,127 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A filter that breaks up an H263 video stream into frames.
+// derived from MPEG4IP h263.c
+// Author Benhard Feiten
+
+#ifndef _H263PLUS_VIDEO_STREAM_PARSER_HH
+#define _H263PLUS_VIDEO_STREAM_PARSER_HH
+
+#ifndef _STREAM_PARSER_HH
+#include "StreamParser.hh"
+#endif
+
+
+// Default timescale for H.263 (1000ms)
+#define H263_TIMESCALE 1000
+
+// Default H263 frame rate (30fps)
+#define H263_BASIC_FRAME_RATE 30
+
+// Minimum number of bytes needed to parse an H263 header
+#define H263_REQUIRE_HEADER_SIZE_BYTES 5
+
+// Number of bytes the start code requries
+#define H263_STARTCODE_SIZE_BYTES 3
+
+// This is the input buffer's size. It should contain
+// 1 frame with the following start code
+#define H263_BUFFER_SIZE 256 * 1024
+
+//  additionalBytesNeeded - indicates how many additional bytes are to be read
+//  from the next frame's header (over the 3 bytes that are already read).
+#define ADDITIONAL_BYTES_NEEDED H263_REQUIRE_HEADER_SIZE_BYTES - H263_STARTCODE_SIZE_BYTES
+
+// The default max different (in %) betwqeen max and average bitrates
+#define H263_DEFAULT_CBR_TOLERANCE  10
+
+
+
+// The following structure holds information extracted from each frame's header:
+typedef struct _H263INFO {
+  u_int8_t  tr;                 // Temporal Reference, used in duration calculation
+  u_int16_t width;              // Width of the picture
+  u_int16_t height;             // Height of the picture
+  bool      isSyncFrame;        // Frame type (true = I frame = "sync" frame)
+} H263INFO;
+
+typedef struct _MaxBitrate_CTX {
+  u_int32_t  bitrateTable[H263_BASIC_FRAME_RATE];// Window of 1 second
+  u_int32_t  windowBitrate;              // The bitrate of the current window
+  u_int32_t  maxBitrate;                 // The up-to-date maximum bitrate
+  u_int32_t  tableIndex;                 // The next TR unit to update
+} MaxBitrate_CTX;
+
+
+class H263plusVideoStreamParser : public StreamParser {
+
+public:
+   H263plusVideoStreamParser( class H263plusVideoStreamFramer* usingSource,
+			                  FramedSource* inputSource);
+
+   virtual ~H263plusVideoStreamParser();
+
+   void registerReadInterest(unsigned char* to, unsigned maxSize);
+
+   unsigned parse(u_int64_t & currentDuration);    // returns the size of the frame  that was acquired, or 0 if none
+   unsigned numTruncatedBytes() const { return fNumTruncatedBytes; }  // The number of truncated bytes (if any)
+
+
+protected:
+//  H263plusVideoStreamFramer* usingSource() {
+//    return (H263plusVideoStreamFramer*)fUsingSource;
+//  }
+  void setParseState();
+
+//   void setParseState(H263plusParseState parseState);
+
+
+private:
+   int       parseH263Frame( );
+   bool      ParseShortHeader(u_int8_t *headerBuffer, H263INFO *outputInfoStruct);
+   void      GetMaxBitrate( MaxBitrate_CTX *ctx, u_int32_t frameSize, u_int8_t frameTRDiff);
+   u_int64_t CalculateDuration(u_int8_t trDiff);
+   bool      GetWidthAndHeight( u_int8_t  fmt, u_int16_t *width, u_int16_t *height);
+   u_int8_t  GetTRDifference( u_int8_t nextTR, u_int8_t currentTR);
+
+  virtual void restoreSavedParserState();
+
+protected:
+   class H263plusVideoStreamFramer* fUsingSource;
+
+   unsigned char* fTo;
+   unsigned       fMaxSize;
+   unsigned char* fStartOfFrame;
+   unsigned char* fSavedTo;
+   unsigned char* fLimit;
+   unsigned       fNumTruncatedBytes;
+   unsigned       fSavedNumTruncatedBytes;
+
+private:
+   H263INFO       fNextInfo;       // Holds information about the next frame
+   H263INFO       fCurrentInfo;    // Holds information about the current frame
+   MaxBitrate_CTX fMaxBitrateCtx;  // Context for the GetMaxBitrate function
+   char           fStates[3][256];
+   u_int8_t       fNextHeader[H263_REQUIRE_HEADER_SIZE_BYTES];
+
+  u_int32_t fnextTR;   // The next frame's presentation time in TR units
+  u_int64_t fcurrentPT;   // The current frame's presentation time in milli-seconds
+
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/H264VideoFileServerMediaSubsession.cpp b/3rdparty/live555/src/liveMedia/H264VideoFileServerMediaSubsession.cpp
new file mode 100644
index 00000000..5a0f4d78
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/H264VideoFileServerMediaSubsession.cpp
@@ -0,0 +1,114 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A 'ServerMediaSubsession' object that creates new, unicast, "RTPSink"s
+// on demand, from a H264 video file.
+// Implementation
+
+#include "H264VideoFileServerMediaSubsession.hh"
+#include "H264VideoRTPSink.hh"
+#include "ByteStreamFileSource.hh"
+#include "H264VideoStreamFramer.hh"
+
+H264VideoFileServerMediaSubsession *H264VideoFileServerMediaSubsession::createNew(UsageEnvironment &env, char const *fileName, Boolean reuseFirstSource) {
+    return new H264VideoFileServerMediaSubsession(env, fileName, reuseFirstSource);
+}
+
+H264VideoFileServerMediaSubsession::H264VideoFileServerMediaSubsession(UsageEnvironment &env, char const *fileName, Boolean reuseFirstSource)
+    : FileServerMediaSubsession(env, fileName, reuseFirstSource), fAuxSDPLine(NULL), fDoneFlag(0), fDummyRTPSink(NULL) {}
+
+H264VideoFileServerMediaSubsession::~H264VideoFileServerMediaSubsession() {
+    delete[] fAuxSDPLine;
+}
+
+static void afterPlayingDummy(void *clientData) {
+    H264VideoFileServerMediaSubsession *subsess = (H264VideoFileServerMediaSubsession *)clientData;
+    subsess->afterPlayingDummy1();
+}
+
+void H264VideoFileServerMediaSubsession::afterPlayingDummy1() {
+    // Unschedule any pending 'checking' task:
+    envir().taskScheduler().unscheduleDelayedTask(nextTask());
+    // Signal the event loop that we're done:
+    setDoneFlag();
+}
+
+static void checkForAuxSDPLine(void *clientData) {
+    H264VideoFileServerMediaSubsession *subsess = (H264VideoFileServerMediaSubsession *)clientData;
+    subsess->checkForAuxSDPLine1();
+}
+
+void H264VideoFileServerMediaSubsession::checkForAuxSDPLine1() {
+    nextTask() = NULL;
+
+    char const *dasl;
+    if(fAuxSDPLine != NULL) {
+        // Signal the event loop that we're done:
+        setDoneFlag();
+    }
+    else if(fDummyRTPSink != NULL && (dasl = fDummyRTPSink->auxSDPLine()) != NULL) {
+        fAuxSDPLine   = strDup(dasl);
+        fDummyRTPSink = NULL;
+
+        // Signal the event loop that we're done:
+        setDoneFlag();
+    }
+    else if(!fDoneFlag) {
+        // try again after a brief delay:
+        int uSecsToDelay = 100000;  // 100 ms
+        nextTask()       = envir().taskScheduler().scheduleDelayedTask(uSecsToDelay, (TaskFunc *)checkForAuxSDPLine, this);
+    }
+}
+
+char const *H264VideoFileServerMediaSubsession::getAuxSDPLine(RTPSink *rtpSink, FramedSource *inputSource) {
+    if(fAuxSDPLine != NULL)
+        return fAuxSDPLine;  // it's already been set up (for a previous client)
+
+    if(fDummyRTPSink == NULL) {  // we're not already setting it up for another, concurrent stream
+        // Note: For H264 video files, the 'config' information ("profile-level-id" and "sprop-parameter-sets") isn't known
+        // until we start reading the file.  This means that "rtpSink"s "auxSDPLine()" will be NULL initially,
+        // and we need to start reading data from our file until this changes.
+        fDummyRTPSink = rtpSink;
+
+        // Start reading the file:
+        fDummyRTPSink->startPlaying(*inputSource, afterPlayingDummy, this);
+
+        // Check whether the sink's 'auxSDPLine()' is ready:
+        checkForAuxSDPLine(this);
+    }
+
+    envir().taskScheduler().doEventLoop(&fDoneFlag);
+
+    return fAuxSDPLine;
+}
+
+FramedSource *H264VideoFileServerMediaSubsession::createNewStreamSource(unsigned /*clientSessionId*/, unsigned &estBitrate) {
+    estBitrate = 500;  // kbps, estimate
+
+    // Create the video source:
+    ByteStreamFileSource *fileSource = ByteStreamFileSource::createNew(envir(), fFileName);
+    if(fileSource == NULL)
+        return NULL;
+    fFileSize = fileSource->fileSize();
+
+    // Create a framer for the Video Elementary Stream:
+    return H264VideoStreamFramer::createNew(envir(), fileSource);
+}
+
+RTPSink *H264VideoFileServerMediaSubsession ::createNewRTPSink(Groupsock *rtpGroupsock, unsigned char rtpPayloadTypeIfDynamic, FramedSource * /*inputSource*/) {
+    return H264VideoRTPSink::createNew(envir(), rtpGroupsock, rtpPayloadTypeIfDynamic);
+}
diff --git a/3rdparty/live555/src/liveMedia/H264VideoFileSink.cpp b/3rdparty/live555/src/liveMedia/H264VideoFileSink.cpp
new file mode 100644
index 00000000..bbc509ee
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/H264VideoFileSink.cpp
@@ -0,0 +1,54 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// H.264 Video File sinks
+// Implementation
+
+#include "H264VideoFileSink.hh"
+#include "OutputFile.hh"
+
+////////// H264VideoFileSink //////////
+
+H264VideoFileSink ::H264VideoFileSink(UsageEnvironment &env, FILE *fid, char const *sPropParameterSetsStr, unsigned bufferSize,
+                                      char const *perFrameFileNamePrefix)
+    : H264or5VideoFileSink(env, fid, bufferSize, perFrameFileNamePrefix, sPropParameterSetsStr, NULL, NULL) {}
+
+H264VideoFileSink::~H264VideoFileSink() {}
+
+H264VideoFileSink *H264VideoFileSink::createNew(UsageEnvironment &env, char const *fileName, char const *sPropParameterSetsStr, unsigned bufferSize,
+                                                Boolean oneFilePerFrame) {
+    do {
+        FILE *      fid;
+        char const *perFrameFileNamePrefix;
+        if(oneFilePerFrame) {
+            // Create the fid for each frame
+            fid                    = NULL;
+            perFrameFileNamePrefix = fileName;
+        }
+        else {
+            // Normal case: create the fid once
+            fid = OpenOutputFile(env, fileName);
+            if(fid == NULL)
+                break;
+            perFrameFileNamePrefix = NULL;
+        }
+
+        return new H264VideoFileSink(env, fid, sPropParameterSetsStr, bufferSize, perFrameFileNamePrefix);
+    } while(0);
+
+    return NULL;
+}
diff --git a/3rdparty/live555/src/liveMedia/H264VideoRTPSink.cpp b/3rdparty/live555/src/liveMedia/H264VideoRTPSink.cpp
new file mode 100644
index 00000000..91ddc667
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/H264VideoRTPSink.cpp
@@ -0,0 +1,128 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// RTP sink for H.264 video (RFC 3984)
+// Implementation
+
+#include "H264VideoRTPSink.hh"
+#include "H264VideoStreamFramer.hh"
+#include "Base64.hh"
+#include "H264VideoRTPSource.hh"  // for "parseSPropParameterSets()"
+
+////////// H264VideoRTPSink implementation //////////
+
+H264VideoRTPSink ::H264VideoRTPSink(UsageEnvironment &env, Groupsock *RTPgs, unsigned char rtpPayloadFormat, u_int8_t const *sps, unsigned spsSize,
+                                    u_int8_t const *pps, unsigned ppsSize)
+    : H264or5VideoRTPSink(264, env, RTPgs, rtpPayloadFormat, NULL, 0, sps, spsSize, pps, ppsSize) {}
+
+H264VideoRTPSink::~H264VideoRTPSink() {}
+
+H264VideoRTPSink *H264VideoRTPSink ::createNew(UsageEnvironment &env, Groupsock *RTPgs, unsigned char rtpPayloadFormat) {
+    return new H264VideoRTPSink(env, RTPgs, rtpPayloadFormat);
+}
+
+H264VideoRTPSink *H264VideoRTPSink ::createNew(UsageEnvironment &env, Groupsock *RTPgs, unsigned char rtpPayloadFormat, u_int8_t const *sps, unsigned spsSize,
+                                               u_int8_t const *pps, unsigned ppsSize) {
+    return new H264VideoRTPSink(env, RTPgs, rtpPayloadFormat, sps, spsSize, pps, ppsSize);
+}
+
+H264VideoRTPSink *H264VideoRTPSink ::createNew(UsageEnvironment &env, Groupsock *RTPgs, unsigned char rtpPayloadFormat, char const *sPropParameterSetsStr) {
+    u_int8_t *sps     = NULL;
+    unsigned  spsSize = 0;
+    u_int8_t *pps     = NULL;
+    unsigned  ppsSize = 0;
+
+    unsigned     numSPropRecords;
+    SPropRecord *sPropRecords = parseSPropParameterSets(sPropParameterSetsStr, numSPropRecords);
+    for(unsigned i = 0; i < numSPropRecords; ++i) {
+        if(sPropRecords[i].sPropLength == 0)
+            continue;  // bad data
+        u_int8_t nal_unit_type = (sPropRecords[i].sPropBytes[0]) & 0x1F;
+        if(nal_unit_type == 7 /*SPS*/) {
+            sps     = sPropRecords[i].sPropBytes;
+            spsSize = sPropRecords[i].sPropLength;
+        }
+        else if(nal_unit_type == 8 /*PPS*/) {
+            pps     = sPropRecords[i].sPropBytes;
+            ppsSize = sPropRecords[i].sPropLength;
+        }
+    }
+
+    H264VideoRTPSink *result = new H264VideoRTPSink(env, RTPgs, rtpPayloadFormat, sps, spsSize, pps, ppsSize);
+    delete[] sPropRecords;
+
+    return result;
+}
+
+Boolean H264VideoRTPSink::sourceIsCompatibleWithUs(MediaSource &source) {
+    // Our source must be an appropriate framer:
+    return source.isH264VideoStreamFramer();
+}
+
+char const *H264VideoRTPSink::auxSDPLine() {
+    // Generate a new "a=fmtp:" line each time, using our SPS and PPS (if we have them),
+    // otherwise parameters from our framer source (in case they've changed since the last time that
+    // we were called):
+    H264or5VideoStreamFramer *framerSource = NULL;
+    u_int8_t *                vpsDummy     = NULL;
+    unsigned                  vpsDummySize = 0;
+    u_int8_t *                sps          = fSPS;
+    unsigned                  spsSize      = fSPSSize;
+    u_int8_t *                pps          = fPPS;
+    unsigned                  ppsSize      = fPPSSize;
+    if(sps == NULL || pps == NULL) {
+        // We need to get SPS and PPS from our framer source:
+        if(fOurFragmenter == NULL)
+            return NULL;  // we don't yet have a fragmenter (and therefore not a source)
+        framerSource = (H264or5VideoStreamFramer *)(fOurFragmenter->inputSource());
+        if(framerSource == NULL)
+            return NULL;  // we don't yet have a source
+
+        framerSource->getVPSandSPSandPPS(vpsDummy, vpsDummySize, sps, spsSize, pps, ppsSize);
+        if(sps == NULL || pps == NULL)
+            return NULL;  // our source isn't ready
+    }
+
+    // Set up the "a=fmtp:" SDP line for this stream:
+    u_int8_t *spsWEB     = new u_int8_t[spsSize];  // "WEB" means "Without Emulation Bytes"
+    unsigned  spsWEBSize = removeH264or5EmulationBytes(spsWEB, spsSize, sps, spsSize);
+    if(spsWEBSize < 4) {  // Bad SPS size => assume our source isn't ready
+        delete[] spsWEB;
+        return NULL;
+    }
+    u_int32_t profileLevelId = (spsWEB[1] << 16) | (spsWEB[2] << 8) | spsWEB[3];
+    delete[] spsWEB;
+
+    char *sps_base64 = base64Encode((char *)sps, spsSize);
+    char *pps_base64 = base64Encode((char *)pps, ppsSize);
+
+    char const *fmtpFmt = "a=fmtp:%d packetization-mode=1"
+                          ";profile-level-id=%06X"
+                          ";sprop-parameter-sets=%s,%s\r\n";
+    unsigned fmtpFmtSize = strlen(fmtpFmt) + 3 /* max char len */
+                           + 6                 /* 3 bytes in hex */
+                           + strlen(sps_base64) + strlen(pps_base64);
+    char *fmtp = new char[fmtpFmtSize];
+    sprintf(fmtp, fmtpFmt, rtpPayloadType(), profileLevelId, sps_base64, pps_base64);
+
+    delete[] sps_base64;
+    delete[] pps_base64;
+
+    delete[] fFmtpSDPLine;
+    fFmtpSDPLine = fmtp;
+    return fFmtpSDPLine;
+}
diff --git a/3rdparty/live555/src/liveMedia/H264VideoRTPSource.cpp b/3rdparty/live555/src/liveMedia/H264VideoRTPSource.cpp
new file mode 100644
index 00000000..da3388ad
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/H264VideoRTPSource.cpp
@@ -0,0 +1,190 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// H.264 Video RTP Sources
+// Implementation
+
+#include "H264VideoRTPSource.hh"
+#include "Base64.hh"
+
+////////// H264BufferedPacket and H264BufferedPacketFactory //////////
+
+class H264BufferedPacket : public BufferedPacket {
+public:
+    H264BufferedPacket(H264VideoRTPSource &ourSource);
+    virtual ~H264BufferedPacket();
+
+private:  // redefined virtual functions
+    virtual unsigned nextEnclosedFrameSize(unsigned char *&framePtr, unsigned dataSize);
+
+private:
+    H264VideoRTPSource &fOurSource;
+};
+
+class H264BufferedPacketFactory : public BufferedPacketFactory {
+private:  // redefined virtual functions
+    virtual BufferedPacket *createNewPacket(MultiFramedRTPSource *ourSource);
+};
+
+///////// H264VideoRTPSource implementation ////////
+
+H264VideoRTPSource *H264VideoRTPSource::createNew(UsageEnvironment &env, Groupsock *RTPgs, unsigned char rtpPayloadFormat, unsigned rtpTimestampFrequency) {
+    return new H264VideoRTPSource(env, RTPgs, rtpPayloadFormat, rtpTimestampFrequency);
+}
+
+H264VideoRTPSource ::H264VideoRTPSource(UsageEnvironment &env, Groupsock *RTPgs, unsigned char rtpPayloadFormat, unsigned rtpTimestampFrequency)
+    : MultiFramedRTPSource(env, RTPgs, rtpPayloadFormat, rtpTimestampFrequency, new H264BufferedPacketFactory) {}
+
+H264VideoRTPSource::~H264VideoRTPSource() {}
+
+Boolean H264VideoRTPSource ::processSpecialHeader(BufferedPacket *packet, unsigned &resultSpecialHeaderSize) {
+    unsigned char *headerStart = packet->data();
+    unsigned       packetSize  = packet->dataSize();
+    unsigned       numBytesToSkip;
+
+    // Check the 'nal_unit_type' for special 'aggregation' or 'fragmentation' packets:
+    if(packetSize < 1)
+        return False;
+    fCurPacketNALUnitType = (headerStart[0] & 0x1F);
+    switch(fCurPacketNALUnitType) {
+    case 24: {               // STAP-A
+        numBytesToSkip = 1;  // discard the type byte
+        break;
+    }
+    case 25:
+    case 26:
+    case 27: {               // STAP-B, MTAP16, or MTAP24
+        numBytesToSkip = 3;  // discard the type byte, and the initial DON
+        break;
+    }
+    case 28:
+    case 29: {  // // FU-A or FU-B
+        // For these NALUs, the first two bytes are the FU indicator and the FU header.
+        // If the start bit is set, we reconstruct the original NAL header into byte 1:
+        if(packetSize < 2)
+            return False;
+        unsigned char startBit = headerStart[1] & 0x80;
+        unsigned char endBit   = headerStart[1] & 0x40;
+        if(startBit) {
+            fCurrentPacketBeginsFrame = True;
+
+            headerStart[1] = (headerStart[0] & 0xE0) | (headerStart[1] & 0x1F);
+            numBytesToSkip = 1;
+        }
+        else {
+            // The start bit is not set, so we skip both the FU indicator and header:
+            fCurrentPacketBeginsFrame = False;
+            numBytesToSkip            = 2;
+        }
+        fCurrentPacketCompletesFrame = (endBit != 0);
+        break;
+    }
+    default: {
+        // This packet contains one complete NAL unit:
+        fCurrentPacketBeginsFrame = fCurrentPacketCompletesFrame = True;
+        numBytesToSkip                                           = 0;
+        break;
+    }
+    }
+
+    resultSpecialHeaderSize = numBytesToSkip;
+    return True;
+}
+
+char const *H264VideoRTPSource::MIMEtype() const {
+    return "video/H264";
+}
+
+SPropRecord *parseSPropParameterSets(char const *sPropParameterSetsStr,
+                                     // result parameter:
+                                     unsigned &numSPropRecords) {
+    // Make a copy of the input string, so we can replace the commas with '\0's:
+    char *inStr = strDup(sPropParameterSetsStr);
+    if(inStr == NULL) {
+        numSPropRecords = 0;
+        return NULL;
+    }
+
+    // Count the number of commas (and thus the number of parameter sets):
+    numSPropRecords = 1;
+    char *s;
+    for(s = inStr; *s != '\0'; ++s) {
+        if(*s == ',') {
+            ++numSPropRecords;
+            *s = '\0';
+        }
+    }
+
+    // Allocate and fill in the result array:
+    SPropRecord *resultArray = new SPropRecord[numSPropRecords];
+    s                        = inStr;
+    for(unsigned i = 0; i < numSPropRecords; ++i) {
+        resultArray[i].sPropBytes = base64Decode(s, resultArray[i].sPropLength);
+        s += strlen(s) + 1;
+    }
+
+    delete[] inStr;
+    return resultArray;
+}
+
+////////// H264BufferedPacket and H264BufferedPacketFactory implementation //////////
+
+H264BufferedPacket::H264BufferedPacket(H264VideoRTPSource &ourSource) : fOurSource(ourSource) {}
+
+H264BufferedPacket::~H264BufferedPacket() {}
+
+unsigned H264BufferedPacket ::nextEnclosedFrameSize(unsigned char *&framePtr, unsigned dataSize) {
+    unsigned resultNALUSize = 0;  // if an error occurs
+
+    switch(fOurSource.fCurPacketNALUnitType) {
+    case 24:
+    case 25: {  // STAP-A or STAP-B
+        // The first two bytes are NALU size:
+        if(dataSize < 2)
+            break;
+        resultNALUSize = (framePtr[0] << 8) | framePtr[1];
+        framePtr += 2;
+        break;
+    }
+    case 26: {  // MTAP16
+        // The first two bytes are NALU size.  The next three are the DOND and TS offset:
+        if(dataSize < 5)
+            break;
+        resultNALUSize = (framePtr[0] << 8) | framePtr[1];
+        framePtr += 5;
+        break;
+    }
+    case 27: {  // MTAP24
+        // The first two bytes are NALU size.  The next four are the DOND and TS offset:
+        if(dataSize < 6)
+            break;
+        resultNALUSize = (framePtr[0] << 8) | framePtr[1];
+        framePtr += 6;
+        break;
+    }
+    default: {
+        // Common case: We use the entire packet data:
+        return dataSize;
+    }
+    }
+
+    return (resultNALUSize <= dataSize) ? resultNALUSize : dataSize;
+}
+
+BufferedPacket *H264BufferedPacketFactory ::createNewPacket(MultiFramedRTPSource *ourSource) {
+    return new H264BufferedPacket((H264VideoRTPSource &)(*ourSource));
+}
diff --git a/3rdparty/live555/src/liveMedia/H264VideoStreamDiscreteFramer.cpp b/3rdparty/live555/src/liveMedia/H264VideoStreamDiscreteFramer.cpp
new file mode 100644
index 00000000..7ce5ed8b
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/H264VideoStreamDiscreteFramer.cpp
@@ -0,0 +1,39 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A simplified version of "H264VideoStreamFramer" that takes only complete,
+// discrete frames (rather than an arbitrary byte stream) as input.
+// This avoids the parsing and data copying overhead of the full
+// "H264VideoStreamFramer".
+// Implementation
+
+#include "H264VideoStreamDiscreteFramer.hh"
+
+H264VideoStreamDiscreteFramer *H264VideoStreamDiscreteFramer ::createNew(UsageEnvironment &env, FramedSource *inputSource, Boolean includeStartCodeInOutput,
+                                                                         Boolean insertAccessUnitDelimiters) {
+    return new H264VideoStreamDiscreteFramer(env, inputSource, includeStartCodeInOutput, insertAccessUnitDelimiters);
+}
+
+H264VideoStreamDiscreteFramer ::H264VideoStreamDiscreteFramer(UsageEnvironment &env, FramedSource *inputSource, Boolean includeStartCodeInOutput,
+                                                              Boolean insertAccessUnitDelimiters)
+    : H264or5VideoStreamDiscreteFramer(264, env, inputSource, includeStartCodeInOutput, insertAccessUnitDelimiters) {}
+
+H264VideoStreamDiscreteFramer::~H264VideoStreamDiscreteFramer() {}
+
+Boolean H264VideoStreamDiscreteFramer::isH264VideoStreamFramer() const {
+    return True;
+}
diff --git a/3rdparty/live555/src/liveMedia/H264VideoStreamFramer.cpp b/3rdparty/live555/src/liveMedia/H264VideoStreamFramer.cpp
new file mode 100644
index 00000000..ed3f3011
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/H264VideoStreamFramer.cpp
@@ -0,0 +1,36 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A filter that breaks up a H.264 Video Elementary Stream into NAL units.
+// Implementation
+
+#include "H264VideoStreamFramer.hh"
+
+H264VideoStreamFramer *H264VideoStreamFramer ::createNew(UsageEnvironment &env, FramedSource *inputSource, Boolean includeStartCodeInOutput,
+                                                         Boolean insertAccessUnitDelimiters) {
+    return new H264VideoStreamFramer(env, inputSource, True, includeStartCodeInOutput, insertAccessUnitDelimiters);
+}
+
+H264VideoStreamFramer ::H264VideoStreamFramer(UsageEnvironment &env, FramedSource *inputSource, Boolean createParser, Boolean includeStartCodeInOutput,
+                                              Boolean insertAccessUnitDelimiters)
+    : H264or5VideoStreamFramer(264, env, inputSource, createParser, includeStartCodeInOutput, insertAccessUnitDelimiters) {}
+
+H264VideoStreamFramer::~H264VideoStreamFramer() {}
+
+Boolean H264VideoStreamFramer::isH264VideoStreamFramer() const {
+    return True;
+}
diff --git a/3rdparty/live555/src/liveMedia/H264or5VideoFileSink.cpp b/3rdparty/live555/src/liveMedia/H264or5VideoFileSink.cpp
new file mode 100644
index 00000000..a1c27df0
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/H264or5VideoFileSink.cpp
@@ -0,0 +1,62 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// H.264 or H.265 Video File sinks
+// Implementation
+
+#include "H264or5VideoFileSink.hh"
+#include "H264VideoRTPSource.hh"  // for "parseSPropParameterSets()"
+
+////////// H264or5VideoFileSink //////////
+
+H264or5VideoFileSink ::H264or5VideoFileSink(UsageEnvironment &env, FILE *fid, unsigned bufferSize, char const *perFrameFileNamePrefix,
+                                            char const *sPropParameterSetsStr1, char const *sPropParameterSetsStr2, char const *sPropParameterSetsStr3)
+    : FileSink(env, fid, bufferSize, perFrameFileNamePrefix), fHaveWrittenFirstFrame(False) {
+    fSPropParameterSetsStr[0] = strDup(sPropParameterSetsStr1);
+    fSPropParameterSetsStr[1] = strDup(sPropParameterSetsStr2);
+    fSPropParameterSetsStr[2] = strDup(sPropParameterSetsStr3);
+}
+
+H264or5VideoFileSink::~H264or5VideoFileSink() {
+    for(unsigned j = 0; j < 3; ++j)
+        delete[](char *) fSPropParameterSetsStr[j];
+}
+
+void H264or5VideoFileSink::afterGettingFrame(unsigned frameSize, unsigned numTruncatedBytes, struct timeval presentationTime) {
+    unsigned char const start_code[4] = { 0x00, 0x00, 0x00, 0x01 };
+
+    if(!fHaveWrittenFirstFrame) {
+        // If we have NAL units encoded in "sprop parameter strings", prepend these to the file:
+        for(unsigned j = 0; j < 3; ++j) {
+            unsigned     numSPropRecords;
+            SPropRecord *sPropRecords = parseSPropParameterSets(fSPropParameterSetsStr[j], numSPropRecords);
+            for(unsigned i = 0; i < numSPropRecords; ++i) {
+                if(sPropRecords[i].sPropLength > 0)
+                    addData(start_code, 4, presentationTime);
+                addData(sPropRecords[i].sPropBytes, sPropRecords[i].sPropLength, presentationTime);
+            }
+            delete[] sPropRecords;
+        }
+        fHaveWrittenFirstFrame = True;  // for next time
+    }
+
+    // Write the input data to the file, with the start code in front:
+    addData(start_code, 4, presentationTime);
+
+    // Call the parent class to complete the normal file write with the input data:
+    FileSink::afterGettingFrame(frameSize, numTruncatedBytes, presentationTime);
+}
diff --git a/3rdparty/live555/src/liveMedia/H264or5VideoRTPSink.cpp b/3rdparty/live555/src/liveMedia/H264or5VideoRTPSink.cpp
new file mode 100644
index 00000000..ad052f71
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/H264or5VideoRTPSink.cpp
@@ -0,0 +1,280 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// RTP sink for H.264 or H.265 video
+// Implementation
+
+#include "H264or5VideoRTPSink.hh"
+#include "H264or5VideoStreamFramer.hh"
+
+////////// H264or5Fragmenter definition //////////
+
+// Because of the ideosyncracies of the H.264 RTP payload format, we implement
+// "H264or5VideoRTPSink" using a separate "H264or5Fragmenter" class that delivers,
+// to the "H264or5VideoRTPSink", only fragments that will fit within an outgoing
+// RTP packet.  I.e., we implement fragmentation in this separate "H264or5Fragmenter"
+// class, rather than in "H264or5VideoRTPSink".
+// (Note: This class should be used only by "H264or5VideoRTPSink", or a subclass.)
+
+class H264or5Fragmenter : public FramedFilter {
+public:
+    H264or5Fragmenter(int hNumber, UsageEnvironment &env, FramedSource *inputSource, unsigned inputBufferMax, unsigned maxOutputPacketSize);
+    virtual ~H264or5Fragmenter();
+
+    Boolean lastFragmentCompletedNALUnit() const {
+        return fLastFragmentCompletedNALUnit;
+    }
+
+private:  // redefined virtual functions:
+    virtual void doGetNextFrame();
+    virtual void doStopGettingFrames();
+
+private:
+    static void afterGettingFrame(void *clientData, unsigned frameSize, unsigned numTruncatedBytes, struct timeval presentationTime,
+                                  unsigned durationInMicroseconds);
+    void        afterGettingFrame1(unsigned frameSize, unsigned numTruncatedBytes, struct timeval presentationTime, unsigned durationInMicroseconds);
+    void        reset();
+
+private:
+    int            fHNumber;
+    unsigned       fInputBufferSize;
+    unsigned       fMaxOutputPacketSize;
+    unsigned char *fInputBuffer;
+    unsigned       fNumValidDataBytes;
+    unsigned       fCurDataOffset;
+    unsigned       fSaveNumTruncatedBytes;
+    Boolean        fLastFragmentCompletedNALUnit;
+};
+
+////////// H264or5VideoRTPSink implementation //////////
+
+H264or5VideoRTPSink ::H264or5VideoRTPSink(int hNumber, UsageEnvironment &env, Groupsock *RTPgs, unsigned char rtpPayloadFormat, u_int8_t const *vps,
+                                          unsigned vpsSize, u_int8_t const *sps, unsigned spsSize, u_int8_t const *pps, unsigned ppsSize)
+    : VideoRTPSink(env, RTPgs, rtpPayloadFormat, 90000, hNumber == 264 ? "H264" : "H265"), fHNumber(hNumber), fOurFragmenter(NULL), fFmtpSDPLine(NULL) {
+    if(vps != NULL) {
+        fVPSSize = vpsSize;
+        fVPS     = new u_int8_t[fVPSSize];
+        memmove(fVPS, vps, fVPSSize);
+    }
+    else {
+        fVPSSize = 0;
+        fVPS     = NULL;
+    }
+    if(sps != NULL) {
+        fSPSSize = spsSize;
+        fSPS     = new u_int8_t[fSPSSize];
+        memmove(fSPS, sps, fSPSSize);
+    }
+    else {
+        fSPSSize = 0;
+        fSPS     = NULL;
+    }
+    if(pps != NULL) {
+        fPPSSize = ppsSize;
+        fPPS     = new u_int8_t[fPPSSize];
+        memmove(fPPS, pps, fPPSSize);
+    }
+    else {
+        fPPSSize = 0;
+        fPPS     = NULL;
+    }
+}
+
+H264or5VideoRTPSink::~H264or5VideoRTPSink() {
+    fSource = fOurFragmenter;  // hack: in case "fSource" had gotten set to NULL before we were called
+    delete[] fFmtpSDPLine;
+    delete[] fVPS;
+    delete[] fSPS;
+    delete[] fPPS;
+    stopPlaying();  // call this now, because we won't have our 'fragmenter' when the base class destructor calls it later.
+
+    // Close our 'fragmenter' as well:
+    Medium::close(fOurFragmenter);
+    fSource = NULL;  // for the base class destructor, which gets called next
+}
+
+Boolean H264or5VideoRTPSink::continuePlaying() {
+    // First, check whether we have a 'fragmenter' class set up yet.
+    // If not, create it now:
+    if(fOurFragmenter == NULL) {
+        fOurFragmenter = new H264or5Fragmenter(fHNumber, envir(), fSource, OutPacketBuffer::maxSize, ourMaxPacketSize() - 12 /*RTP hdr size*/);
+    }
+    else {
+        fOurFragmenter->reassignInputSource(fSource);
+    }
+    fSource = fOurFragmenter;
+
+    // Then call the parent class's implementation:
+    return MultiFramedRTPSink::continuePlaying();
+}
+
+void H264or5VideoRTPSink::doSpecialFrameHandling(unsigned /*fragmentationOffset*/, unsigned char * /*frameStart*/, unsigned /*numBytesInFrame*/,
+                                                 struct timeval framePresentationTime, unsigned /*numRemainingBytes*/) {
+    // Set the RTP 'M' (marker) bit iff
+    // 1/ The most recently delivered fragment was the end of (or the only fragment of) an NAL unit, and
+    // 2/ This NAL unit was the last NAL unit of an 'access unit' (i.e. video frame).
+    if(fOurFragmenter != NULL) {
+        H264or5VideoStreamFramer *framerSource = (H264or5VideoStreamFramer *)(fOurFragmenter->inputSource());
+        // This relies on our fragmenter's source being a "H264or5VideoStreamFramer".
+        if(((H264or5Fragmenter *)fOurFragmenter)->lastFragmentCompletedNALUnit() && framerSource != NULL && framerSource->pictureEndMarker()) {
+            setMarkerBit();
+            framerSource->pictureEndMarker() = False;
+        }
+    }
+
+    setTimestamp(framePresentationTime);
+}
+
+Boolean H264or5VideoRTPSink ::frameCanAppearAfterPacketStart(unsigned char const * /*frameStart*/, unsigned /*numBytesInFrame*/) const {
+    return False;
+}
+
+////////// H264or5Fragmenter implementation //////////
+
+H264or5Fragmenter::H264or5Fragmenter(int hNumber, UsageEnvironment &env, FramedSource *inputSource, unsigned inputBufferMax, unsigned maxOutputPacketSize)
+    : FramedFilter(env, inputSource), fHNumber(hNumber), fInputBufferSize(inputBufferMax + 1), fMaxOutputPacketSize(maxOutputPacketSize) {
+    fInputBuffer = new unsigned char[fInputBufferSize];
+    reset();
+}
+
+H264or5Fragmenter::~H264or5Fragmenter() {
+    delete[] fInputBuffer;
+    detachInputSource();  // so that the subsequent ~FramedFilter() doesn't delete it
+}
+
+void H264or5Fragmenter::doGetNextFrame() {
+    if(fNumValidDataBytes == 1) {
+        // We have no NAL unit data currently in the buffer.  Read a new one:
+        fInputSource->getNextFrame(&fInputBuffer[1], fInputBufferSize - 1, afterGettingFrame, this, FramedSource::handleClosure, this);
+    }
+    else {
+        // We have NAL unit data in the buffer.  There are three cases to consider:
+        // 1. There is a new NAL unit in the buffer, and it's small enough to deliver
+        //    to the RTP sink (as is).
+        // 2. There is a new NAL unit in the buffer, but it's too large to deliver to
+        //    the RTP sink in its entirety.  Deliver the first fragment of this data,
+        //    as a FU packet, with one extra preceding header byte (for the "FU header").
+        // 3. There is a NAL unit in the buffer, and we've already delivered some
+        //    fragment(s) of this.  Deliver the next fragment of this data,
+        //    as a FU packet, with two (H.264) or three (H.265) extra preceding header bytes
+        //    (for the "NAL header" and the "FU header").
+
+        if(fMaxSize < fMaxOutputPacketSize) {  // shouldn't happen
+            envir() << "H264or5Fragmenter::doGetNextFrame(): fMaxSize (" << fMaxSize << ") is smaller than expected\n";
+        }
+        else {
+            fMaxSize = fMaxOutputPacketSize;
+        }
+
+        fLastFragmentCompletedNALUnit = True;         // by default
+        if(fCurDataOffset == 1) {                     // case 1 or 2
+            if(fNumValidDataBytes - 1 <= fMaxSize) {  // case 1
+                memmove(fTo, &fInputBuffer[1], fNumValidDataBytes - 1);
+                fFrameSize     = fNumValidDataBytes - 1;
+                fCurDataOffset = fNumValidDataBytes;
+            }
+            else {  // case 2
+                // We need to send the NAL unit data as FU packets.  Deliver the first
+                // packet now.  Note that we add "NAL header" and "FU header" bytes to the front
+                // of the packet (overwriting the existing "NAL header").
+                if(fHNumber == 264) {
+                    fInputBuffer[0] = (fInputBuffer[1] & 0xE0) | 28;    // FU indicator
+                    fInputBuffer[1] = 0x80 | (fInputBuffer[1] & 0x1F);  // FU header (with S bit)
+                }
+                else {  // 265
+                    u_int8_t nal_unit_type = (fInputBuffer[1] & 0x7E) >> 1;
+                    fInputBuffer[0]        = (fInputBuffer[1] & 0x81) | (49 << 1);  // Payload header (1st byte)
+                    fInputBuffer[1]        = fInputBuffer[2];                       // Payload header (2nd byte)
+                    fInputBuffer[2]        = 0x80 | nal_unit_type;                  // FU header (with S bit)
+                }
+                memmove(fTo, fInputBuffer, fMaxSize);
+                fFrameSize = fMaxSize;
+                fCurDataOffset += fMaxSize - 1;
+                fLastFragmentCompletedNALUnit = False;
+            }
+        }
+        else {  // case 3
+            // We are sending this NAL unit data as FU packets.  We've already sent the
+            // first packet (fragment).  Now, send the next fragment.  Note that we add
+            // "NAL header" and "FU header" bytes to the front.  (We reuse these bytes that
+            // we already sent for the first fragment, but clear the S bit, and add the E
+            // bit if this is the last fragment.)
+            unsigned numExtraHeaderBytes;
+            if(fHNumber == 264) {
+                fInputBuffer[fCurDataOffset - 2] = fInputBuffer[0];          // FU indicator
+                fInputBuffer[fCurDataOffset - 1] = fInputBuffer[1] & ~0x80;  // FU header (no S bit)
+                numExtraHeaderBytes              = 2;
+            }
+            else {                                                           // 265
+                fInputBuffer[fCurDataOffset - 3] = fInputBuffer[0];          // Payload header (1st byte)
+                fInputBuffer[fCurDataOffset - 2] = fInputBuffer[1];          // Payload header (2nd byte)
+                fInputBuffer[fCurDataOffset - 1] = fInputBuffer[2] & ~0x80;  // FU header (no S bit)
+                numExtraHeaderBytes              = 3;
+            }
+            unsigned numBytesToSend = numExtraHeaderBytes + (fNumValidDataBytes - fCurDataOffset);
+            if(numBytesToSend > fMaxSize) {
+                // We can't send all of the remaining data this time:
+                numBytesToSend                = fMaxSize;
+                fLastFragmentCompletedNALUnit = False;
+            }
+            else {
+                // This is the last fragment:
+                fInputBuffer[fCurDataOffset - 1] |= 0x40;  // set the E bit in the FU header
+                fNumTruncatedBytes = fSaveNumTruncatedBytes;
+            }
+            memmove(fTo, &fInputBuffer[fCurDataOffset - numExtraHeaderBytes], numBytesToSend);
+            fFrameSize = numBytesToSend;
+            fCurDataOffset += numBytesToSend - numExtraHeaderBytes;
+        }
+
+        if(fCurDataOffset >= fNumValidDataBytes) {
+            // We're done with this data.  Reset the pointers for receiving new data:
+            fNumValidDataBytes = fCurDataOffset = 1;
+        }
+
+        // Complete delivery to the client:
+        FramedSource::afterGetting(this);
+    }
+}
+
+void H264or5Fragmenter::doStopGettingFrames() {
+    // Make sure that we don't have any stale data fragments lying around, should we later resume:
+    reset();
+    FramedFilter::doStopGettingFrames();
+}
+
+void H264or5Fragmenter::afterGettingFrame(void *clientData, unsigned frameSize, unsigned numTruncatedBytes, struct timeval presentationTime,
+                                          unsigned durationInMicroseconds) {
+    H264or5Fragmenter *fragmenter = (H264or5Fragmenter *)clientData;
+    fragmenter->afterGettingFrame1(frameSize, numTruncatedBytes, presentationTime, durationInMicroseconds);
+}
+
+void H264or5Fragmenter::afterGettingFrame1(unsigned frameSize, unsigned numTruncatedBytes, struct timeval presentationTime, unsigned durationInMicroseconds) {
+    fNumValidDataBytes += frameSize;
+    fSaveNumTruncatedBytes  = numTruncatedBytes;
+    fPresentationTime       = presentationTime;
+    fDurationInMicroseconds = durationInMicroseconds;
+
+    // Deliver data to the client:
+    doGetNextFrame();
+}
+
+void H264or5Fragmenter::reset() {
+    fNumValidDataBytes = fCurDataOffset = 1;
+    fSaveNumTruncatedBytes              = 0;
+    fLastFragmentCompletedNALUnit       = True;
+}
diff --git a/3rdparty/live555/src/liveMedia/H264or5VideoStreamDiscreteFramer.cpp b/3rdparty/live555/src/liveMedia/H264or5VideoStreamDiscreteFramer.cpp
new file mode 100644
index 00000000..29afb0f0
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/H264or5VideoStreamDiscreteFramer.cpp
@@ -0,0 +1,183 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A simplified version of "H264or5VideoStreamFramer" that takes only complete,
+// discrete frames (rather than an arbitrary byte stream) as input.
+// This avoids the parsing and data copying overhead of the full
+// "H264or5VideoStreamFramer".
+// Implementation
+
+#include "H264or5VideoStreamDiscreteFramer.hh"
+
+H264or5VideoStreamDiscreteFramer ::H264or5VideoStreamDiscreteFramer(int hNumber, UsageEnvironment &env, FramedSource *inputSource,
+                                                                    Boolean includeStartCodeInOutput, Boolean insertAccessUnitDelimiters)
+    : H264or5VideoStreamFramer(hNumber, env, inputSource, False /*don't create a parser*/, includeStartCodeInOutput, insertAccessUnitDelimiters) {}
+
+H264or5VideoStreamDiscreteFramer::~H264or5VideoStreamDiscreteFramer() {}
+
+void H264or5VideoStreamDiscreteFramer::doGetNextFrame() {
+    if(fIncludeStartCodeInOutput) {
+        // Prepend a 4-byte 'start code' (0x00000001) to the output:
+        if(fMaxSize < 4) {  // there's no space
+            fNumTruncatedBytes = 4 - fMaxSize;
+            handleClosure();
+            return;
+        }
+        *fTo++ = 0x00;
+        *fTo++ = 0x00;
+        *fTo++ = 0x00;
+        *fTo++ = 0x01;
+        fMaxSize -= 4;
+    }
+
+    if(fInsertAccessUnitDelimiters && pictureEndMarker()) {
+        // Deliver an "access_unit_delimiter" NAL unit instead:
+        unsigned const audNALSize = fHNumber == 264 ? 2 : 3;
+
+        // If we have VPS,SPS,PPS NAL units, then append those as well:
+        unsigned nalDataSize = audNALSize + fLastSeenVPSSize + fLastSeenSPSSize + fLastSeenPPSSize;
+        if(fIncludeStartCodeInOutput) {
+            // Add the size of the 4-byte start codes:
+            if(fLastSeenVPSSize > 0)
+                nalDataSize += 4;
+            if(fLastSeenSPSSize > 0)
+                nalDataSize += 4;
+            if(fLastSeenPPSSize > 0)
+                nalDataSize += 4;
+        }
+
+        if(nalDataSize > fMaxSize) {  // there's no space
+            fNumTruncatedBytes = nalDataSize - fMaxSize;
+            handleClosure();
+            return;
+        }
+
+        if(fHNumber == 264) {
+            *fTo++ = 9;     // "Access unit delimiter" nal_unit_type
+            *fTo++ = 0xF0;  // "primary_pic_type" (7); "rbsp_trailing_bits()"
+        }
+        else {                 // H.265
+            *fTo++ = 35 << 1;  // "Access unit delimiter" nal_unit_type
+            *fTo++ = 0;        // "nuh_layer_id" (0); "nuh_temporal_id_plus1" (0) (Is this correct??)
+            *fTo++ = 0x50;     // "pic_type" (2); "rbsp_trailing_bits()" (Is this correct??)
+        }
+
+        if(fLastSeenVPSSize > 0) {
+            if(fIncludeStartCodeInOutput) {
+                *fTo++ = 0x00;
+                *fTo++ = 0x00;
+                *fTo++ = 0x00;
+                *fTo++ = 0x01;
+            }
+            memmove(fTo, fLastSeenVPS, fLastSeenVPSSize);
+            fTo += fLastSeenVPSSize;
+        }
+        if(fLastSeenSPSSize > 0) {
+            if(fIncludeStartCodeInOutput) {
+                *fTo++ = 0x00;
+                *fTo++ = 0x00;
+                *fTo++ = 0x00;
+                *fTo++ = 0x01;
+            }
+            memmove(fTo, fLastSeenSPS, fLastSeenSPSSize);
+            fTo += fLastSeenSPSSize;
+        }
+        if(fLastSeenPPSSize > 0) {
+            if(fIncludeStartCodeInOutput) {
+                *fTo++ = 0x00;
+                *fTo++ = 0x00;
+                *fTo++ = 0x00;
+                *fTo++ = 0x01;
+            }
+            memmove(fTo, fLastSeenPPS, fLastSeenPPSSize);
+            fTo += fLastSeenPPSSize;
+        }
+
+        fFrameSize = (fIncludeStartCodeInOutput ? 4 : 0) + nalDataSize;
+
+        pictureEndMarker() = False;  // for next time
+        afterGetting(this);          // complete delivery to the downstream object
+    }
+    else {
+        // Normal case:
+        // Arrange to read data (which should be a complete H.264 or H.265 NAL unit)
+        // from our data source, directly into the client's input buffer.
+        // After reading this, we'll do some parsing on the frame.
+        fInputSource->getNextFrame(fTo, fMaxSize, afterGettingFrame, this, FramedSource::handleClosure, this);
+    }
+}
+
+void H264or5VideoStreamDiscreteFramer ::afterGettingFrame(void *clientData, unsigned frameSize, unsigned numTruncatedBytes, struct timeval presentationTime,
+                                                          unsigned durationInMicroseconds) {
+    H264or5VideoStreamDiscreteFramer *source = (H264or5VideoStreamDiscreteFramer *)clientData;
+    source->afterGettingFrame1(frameSize, numTruncatedBytes, presentationTime, durationInMicroseconds);
+}
+
+void H264or5VideoStreamDiscreteFramer ::afterGettingFrame1(unsigned frameSize, unsigned numTruncatedBytes, struct timeval presentationTime,
+                                                           unsigned durationInMicroseconds) {
+    // Get the "nal_unit_type", to see if this NAL unit is one that we want to save a copy of:
+    u_int8_t nal_unit_type;
+    if(fHNumber == 264 && frameSize >= 1) {
+        nal_unit_type = fTo[0] & 0x1F;
+    }
+    else if(fHNumber == 265 && frameSize >= 2) {
+        nal_unit_type = (fTo[0] & 0x7E) >> 1;
+    }
+    else {
+        // This is too short to be a valid NAL unit, so just assume a bogus nal_unit_type
+        nal_unit_type = 0xFF;
+    }
+
+    // Begin by checking for a (likely) common error: NAL units that (erroneously) begin with a
+    // 0x00000001 or 0x000001 'start code'.  (Those start codes should only be in byte-stream data;
+    // *not* data that consists of discrete NAL units.)
+    // Once again, to be clear: The NAL units that you feed to a "H264or5VideoStreamDiscreteFramer"
+    // MUST NOT include start codes.
+    if(frameSize >= 4 && fTo[0] == 0 && fTo[1] == 0 && ((fTo[2] == 0 && fTo[3] == 1) || fTo[2] == 1)) {
+        envir() << "H264or5VideoStreamDiscreteFramer error: MPEG 'start code' seen in the input\n";
+    }
+    else if(isVPS(nal_unit_type)) {  // Video parameter set (VPS)
+        saveCopyOfVPS(fTo, frameSize);
+    }
+    else if(isSPS(nal_unit_type)) {  // Sequence parameter set (SPS)
+        saveCopyOfSPS(fTo, frameSize);
+    }
+    else if(isPPS(nal_unit_type)) {  // Picture parameter set (PPS)
+        saveCopyOfPPS(fTo, frameSize);
+    }
+
+    fPictureEndMarker = nalUnitEndsAccessUnit(nal_unit_type);
+
+    // Finally, complete delivery to the client:
+    fFrameSize              = fIncludeStartCodeInOutput ? (4 + frameSize) : frameSize;
+    fNumTruncatedBytes      = numTruncatedBytes;
+    fPresentationTime       = presentationTime;
+    fDurationInMicroseconds = durationInMicroseconds;
+    afterGetting(this);
+}
+
+Boolean H264or5VideoStreamDiscreteFramer::nalUnitEndsAccessUnit(u_int8_t nal_unit_type) {
+    // Check whether this NAL unit ends the current 'access unit' (basically, a video frame).
+    //  Unfortunately, we can't do this reliably, because we don't yet know anything about the
+    // *next* NAL unit that we'll see.  So, we guess this as best as we can, by assuming that
+    // if this NAL unit is a VCL NAL unit, then it ends the current 'access unit'.
+    //
+    // This will be wrong if you are streaming multiple 'slices' per picture.  In that case,
+    // you can define a subclass that reimplements this virtual function to do the right thing.
+
+    return isVCL(nal_unit_type);
+}
diff --git a/3rdparty/live555/src/liveMedia/H264or5VideoStreamFramer.cpp b/3rdparty/live555/src/liveMedia/H264or5VideoStreamFramer.cpp
new file mode 100644
index 00000000..bea61bf4
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/H264or5VideoStreamFramer.cpp
@@ -0,0 +1,1276 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A filter that breaks up a H.264 or H.265 Video Elementary Stream into NAL units.
+// Implementation
+
+#include "H264or5VideoStreamFramer.hh"
+#include "MPEGVideoStreamParser.hh"
+#include "BitVector.hh"
+#include <GroupsockHelper.hh>  // for "gettimeofday()"
+
+////////// H264or5VideoStreamParser definition //////////
+
+class H264or5VideoStreamParser : public MPEGVideoStreamParser {
+public:
+    H264or5VideoStreamParser(int hNumber, H264or5VideoStreamFramer *usingSource, FramedSource *inputSource, Boolean includeStartCodeInOutput);
+    virtual ~H264or5VideoStreamParser();
+
+private:  // redefined virtual functions:
+    virtual void     flushInput();
+    virtual unsigned parse();
+
+private:
+    H264or5VideoStreamFramer *usingSource() {
+        return (H264or5VideoStreamFramer *)fUsingSource;
+    }
+
+    Boolean isVPS(u_int8_t nal_unit_type) {
+        return usingSource()->isVPS(nal_unit_type);
+    }
+    Boolean isSPS(u_int8_t nal_unit_type) {
+        return usingSource()->isSPS(nal_unit_type);
+    }
+    Boolean isPPS(u_int8_t nal_unit_type) {
+        return usingSource()->isPPS(nal_unit_type);
+    }
+    Boolean isVCL(u_int8_t nal_unit_type) {
+        return usingSource()->isVCL(nal_unit_type);
+    }
+    Boolean isSEI(u_int8_t nal_unit_type);
+    Boolean isEOF(u_int8_t nal_unit_type);
+    Boolean usuallyBeginsAccessUnit(u_int8_t nal_unit_type);
+
+    void removeEmulationBytes(u_int8_t *nalUnitCopy, unsigned maxSize, unsigned &nalUnitCopySize);
+
+    void analyze_video_parameter_set_data(unsigned &num_units_in_tick, unsigned &time_scale);
+    void analyze_seq_parameter_set_data(unsigned &num_units_in_tick, unsigned &time_scale);
+    void profile_tier_level(BitVector &bv, unsigned max_sub_layers_minus1);
+    void analyze_vui_parameters(BitVector &bv, unsigned &num_units_in_tick, unsigned &time_scale);
+    void analyze_hrd_parameters(BitVector &bv);
+    void analyze_sei_data(u_int8_t nal_unit_type);
+    void analyze_sei_payload(unsigned payloadType, unsigned payloadSize, u_int8_t *payload);
+
+private:
+    int      fHNumber;  // 264 or 265
+    unsigned fOutputStartCodeSize;
+    Boolean  fHaveSeenFirstStartCode, fHaveSeenFirstByteOfNALUnit;
+    u_int8_t fFirstByteOfNALUnit;
+    double   fParsedFrameRate;
+    // variables set & used in the specification:
+    unsigned cpb_removal_delay_length_minus1, dpb_output_delay_length_minus1;
+    Boolean  CpbDpbDelaysPresentFlag, pic_struct_present_flag;
+    double   DeltaTfiDivisor;
+};
+
+////////// H264or5VideoStreamFramer implementation //////////
+
+H264or5VideoStreamFramer ::H264or5VideoStreamFramer(int hNumber, UsageEnvironment &env, FramedSource *inputSource, Boolean createParser,
+                                                    Boolean includeStartCodeInOutput, Boolean insertAccessUnitDelimiters)
+    : MPEGVideoStreamFramer(env, inputSource),
+      fHNumber(hNumber),
+      fIncludeStartCodeInOutput(includeStartCodeInOutput),
+      fInsertAccessUnitDelimiters(insertAccessUnitDelimiters),
+      fLastSeenVPS(NULL),
+      fLastSeenVPSSize(0),
+      fLastSeenSPS(NULL),
+      fLastSeenSPSSize(0),
+      fLastSeenPPS(NULL),
+      fLastSeenPPSSize(0) {
+    fParser    = createParser ? new H264or5VideoStreamParser(hNumber, this, inputSource, includeStartCodeInOutput) : NULL;
+    fFrameRate = 30.0;  // We assume a frame rate of 30 fps, unless we learn otherwise (from parsing a VPS or SPS NAL unit)
+}
+
+H264or5VideoStreamFramer::~H264or5VideoStreamFramer() {
+    delete[] fLastSeenPPS;
+    delete[] fLastSeenSPS;
+    delete[] fLastSeenVPS;
+}
+
+#define VPS_MAX_SIZE 1000  // larger than the largest possible VPS (Video Parameter Set) NAL unit
+
+void H264or5VideoStreamFramer::saveCopyOfVPS(u_int8_t *from, unsigned size) {
+    if(from == NULL)
+        return;
+    delete[] fLastSeenVPS;
+    fLastSeenVPS = new u_int8_t[size];
+    memmove(fLastSeenVPS, from, size);
+
+    fLastSeenVPSSize = size;
+}
+
+#define SPS_MAX_SIZE 1000  // larger than the largest possible SPS (Sequence Parameter Set) NAL unit
+
+void H264or5VideoStreamFramer::saveCopyOfSPS(u_int8_t *from, unsigned size) {
+    if(from == NULL)
+        return;
+    delete[] fLastSeenSPS;
+    fLastSeenSPS = new u_int8_t[size];
+    memmove(fLastSeenSPS, from, size);
+
+    fLastSeenSPSSize = size;
+}
+
+void H264or5VideoStreamFramer::saveCopyOfPPS(u_int8_t *from, unsigned size) {
+    if(from == NULL)
+        return;
+    delete[] fLastSeenPPS;
+    fLastSeenPPS = new u_int8_t[size];
+    memmove(fLastSeenPPS, from, size);
+
+    fLastSeenPPSSize = size;
+}
+
+void H264or5VideoStreamFramer::setPresentationTime() {
+    if(fPresentationTimeBase.tv_sec == 0 && fPresentationTimeBase.tv_usec == 0) {
+        // Set to the current time:
+        gettimeofday(&fPresentationTimeBase, NULL);
+        fNextPresentationTime = fPresentationTimeBase;
+    }
+    fPresentationTime = fNextPresentationTime;
+}
+
+Boolean H264or5VideoStreamFramer::isVPS(u_int8_t nal_unit_type) {
+    // VPS NAL units occur in H.265 only:
+    return fHNumber == 265 && nal_unit_type == 32;
+}
+
+Boolean H264or5VideoStreamFramer::isSPS(u_int8_t nal_unit_type) {
+    return fHNumber == 264 ? nal_unit_type == 7 : nal_unit_type == 33;
+}
+
+Boolean H264or5VideoStreamFramer::isPPS(u_int8_t nal_unit_type) {
+    return fHNumber == 264 ? nal_unit_type == 8 : nal_unit_type == 34;
+}
+
+Boolean H264or5VideoStreamFramer::isVCL(u_int8_t nal_unit_type) {
+    return fHNumber == 264 ? (nal_unit_type <= 5 && nal_unit_type > 0) : (nal_unit_type <= 31);
+}
+
+void H264or5VideoStreamFramer::doGetNextFrame() {
+    if(fInsertAccessUnitDelimiters && pictureEndMarker()) {
+        // Deliver an "access_unit_delimiter" NAL unit instead:
+        unsigned const startCodeSize = fIncludeStartCodeInOutput ? 4 : 0;
+        unsigned const audNALSize    = fHNumber == 264 ? 2 : 3;
+
+        fFrameSize = startCodeSize + audNALSize;
+        if(fFrameSize > fMaxSize) {  // there's no space
+            fNumTruncatedBytes = fFrameSize - fMaxSize;
+            fFrameSize         = fMaxSize;
+            handleClosure();
+            return;
+        }
+
+        if(fIncludeStartCodeInOutput) {
+            *fTo++ = 0x00;
+            *fTo++ = 0x00;
+            *fTo++ = 0x00;
+            *fTo++ = 0x01;
+        }
+        if(fHNumber == 264) {
+            *fTo++ = 9;     // "Access unit delimiter" nal_unit_type
+            *fTo++ = 0xF0;  // "primary_pic_type" (7); "rbsp_trailing_bits()"
+        }
+        else {                 // H.265
+            *fTo++ = 35 << 1;  // "Access unit delimiter" nal_unit_type
+            *fTo++ = 0;        // "nuh_layer_id" (0); "nuh_temporal_id_plus1" (0) (Is this correct??)
+            *fTo++ = 0x50;     // "pic_type" (2); "rbsp_trailing_bits()" (Is this correct??)
+        }
+
+        pictureEndMarker() = False;  // for next time
+        afterGetting(this);
+    }
+    else {
+        // Do the normal delivery of a NAL unit from the parser:
+        MPEGVideoStreamFramer::doGetNextFrame();
+    }
+}
+
+////////// H264or5VideoStreamParser implementation //////////
+
+H264or5VideoStreamParser ::H264or5VideoStreamParser(int hNumber, H264or5VideoStreamFramer *usingSource, FramedSource *inputSource,
+                                                    Boolean includeStartCodeInOutput)
+    : MPEGVideoStreamParser(usingSource, inputSource),
+      fHNumber(hNumber),
+      fOutputStartCodeSize(includeStartCodeInOutput ? 4 : 0),
+      fHaveSeenFirstStartCode(False),
+      fHaveSeenFirstByteOfNALUnit(False),
+      fParsedFrameRate(0.0),
+      cpb_removal_delay_length_minus1(23),
+      dpb_output_delay_length_minus1(23),
+      CpbDpbDelaysPresentFlag(0),
+      pic_struct_present_flag(0),
+      DeltaTfiDivisor(hNumber == 264 ? 2.0 : 1.0) {}
+
+H264or5VideoStreamParser::~H264or5VideoStreamParser() {}
+
+#define PREFIX_SEI_NUT 39  // for H.265
+#define SUFFIX_SEI_NUT 40  // for H.265
+Boolean H264or5VideoStreamParser::isSEI(u_int8_t nal_unit_type) {
+    return fHNumber == 264 ? nal_unit_type == 6 : (nal_unit_type == PREFIX_SEI_NUT || nal_unit_type == SUFFIX_SEI_NUT);
+}
+
+Boolean H264or5VideoStreamParser::isEOF(u_int8_t nal_unit_type) {
+    // "end of sequence" or "end of (bit)stream"
+    return fHNumber == 264 ? (nal_unit_type == 10 || nal_unit_type == 11) : (nal_unit_type == 36 || nal_unit_type == 37);
+}
+
+Boolean H264or5VideoStreamParser::usuallyBeginsAccessUnit(u_int8_t nal_unit_type) {
+    return fHNumber == 264 ? (nal_unit_type >= 6 && nal_unit_type <= 9) || (nal_unit_type >= 14 && nal_unit_type <= 18)
+                           : (nal_unit_type >= 32 && nal_unit_type <= 35) || (nal_unit_type == 39) || (nal_unit_type >= 41 && nal_unit_type <= 44)
+                                 || (nal_unit_type >= 48 && nal_unit_type <= 55);
+}
+
+void H264or5VideoStreamParser ::removeEmulationBytes(u_int8_t *nalUnitCopy, unsigned maxSize, unsigned &nalUnitCopySize) {
+    u_int8_t const *nalUnitOrig       = fStartOfFrame + fOutputStartCodeSize;
+    unsigned const  numBytesInNALunit = fTo - nalUnitOrig;
+    nalUnitCopySize                   = removeH264or5EmulationBytes(nalUnitCopy, maxSize, nalUnitOrig, numBytesInNALunit);
+}
+
+#ifdef DEBUG
+char const *nal_unit_type_description_h264[32] = {
+    "Unspecified",                                                     // 0
+    "Coded slice of a non-IDR picture",                                // 1
+    "Coded slice data partition A",                                    // 2
+    "Coded slice data partition B",                                    // 3
+    "Coded slice data partition C",                                    // 4
+    "Coded slice of an IDR picture",                                   // 5
+    "Supplemental enhancement information (SEI)",                      // 6
+    "Sequence parameter set",                                          // 7
+    "Picture parameter set",                                           // 8
+    "Access unit delimiter",                                           // 9
+    "End of sequence",                                                 // 10
+    "End of stream",                                                   // 11
+    "Filler data",                                                     // 12
+    "Sequence parameter set extension",                                // 13
+    "Prefix NAL unit",                                                 // 14
+    "Subset sequence parameter set",                                   // 15
+    "Reserved",                                                        // 16
+    "Reserved",                                                        // 17
+    "Reserved",                                                        // 18
+    "Coded slice of an auxiliary coded picture without partitioning",  // 19
+    "Coded slice extension",                                           // 20
+    "Reserved",                                                        // 21
+    "Reserved",                                                        // 22
+    "Reserved",                                                        // 23
+    "Unspecified",                                                     // 24
+    "Unspecified",                                                     // 25
+    "Unspecified",                                                     // 26
+    "Unspecified",                                                     // 27
+    "Unspecified",                                                     // 28
+    "Unspecified",                                                     // 29
+    "Unspecified",                                                     // 30
+    "Unspecified"                                                      // 31
+};
+char const *nal_unit_type_description_h265[64] = {
+    "Coded slice segment of a non-TSA, non-STSA trailing picture",  // 0
+    "Coded slice segment of a non-TSA, non-STSA trailing picture",  // 1
+    "Coded slice segment of a TSA picture",                         // 2
+    "Coded slice segment of a TSA picture",                         // 3
+    "Coded slice segment of a STSA picture",                        // 4
+    "Coded slice segment of a STSA picture",                        // 5
+    "Coded slice segment of a RADL picture",                        // 6
+    "Coded slice segment of a RADL picture",                        // 7
+    "Coded slice segment of a RASL picture",                        // 8
+    "Coded slice segment of a RASL picture",                        // 9
+    "Reserved",                                                     // 10
+    "Reserved",                                                     // 11
+    "Reserved",                                                     // 12
+    "Reserved",                                                     // 13
+    "Reserved",                                                     // 14
+    "Reserved",                                                     // 15
+    "Coded slice segment of a BLA picture",                         // 16
+    "Coded slice segment of a BLA picture",                         // 17
+    "Coded slice segment of a BLA picture",                         // 18
+    "Coded slice segment of an IDR picture",                        // 19
+    "Coded slice segment of an IDR picture",                        // 20
+    "Coded slice segment of a CRA picture",                         // 21
+    "Reserved",                                                     // 22
+    "Reserved",                                                     // 23
+    "Reserved",                                                     // 24
+    "Reserved",                                                     // 25
+    "Reserved",                                                     // 26
+    "Reserved",                                                     // 27
+    "Reserved",                                                     // 28
+    "Reserved",                                                     // 29
+    "Reserved",                                                     // 30
+    "Reserved",                                                     // 31
+    "Video parameter set",                                          // 32
+    "Sequence parameter set",                                       // 33
+    "Picture parameter set",                                        // 34
+    "Access unit delimiter",                                        // 35
+    "End of sequence",                                              // 36
+    "End of bitstream",                                             // 37
+    "Filler data",                                                  // 38
+    "Supplemental enhancement information (SEI)",                   // 39
+    "Supplemental enhancement information (SEI)",                   // 40
+    "Reserved",                                                     // 41
+    "Reserved",                                                     // 42
+    "Reserved",                                                     // 43
+    "Reserved",                                                     // 44
+    "Reserved",                                                     // 45
+    "Reserved",                                                     // 46
+    "Reserved",                                                     // 47
+    "Unspecified",                                                  // 48
+    "Unspecified",                                                  // 49
+    "Unspecified",                                                  // 50
+    "Unspecified",                                                  // 51
+    "Unspecified",                                                  // 52
+    "Unspecified",                                                  // 53
+    "Unspecified",                                                  // 54
+    "Unspecified",                                                  // 55
+    "Unspecified",                                                  // 56
+    "Unspecified",                                                  // 57
+    "Unspecified",                                                  // 58
+    "Unspecified",                                                  // 59
+    "Unspecified",                                                  // 60
+    "Unspecified",                                                  // 61
+    "Unspecified",                                                  // 62
+    "Unspecified",                                                  // 63
+};
+#endif
+
+#ifdef DEBUG
+static unsigned numDebugTabs = 1;
+#define DEBUG_PRINT_TABS                          \
+    for(unsigned _i = 0; _i < numDebugTabs; ++_i) \
+    fprintf(stderr, "\t")
+#define DEBUG_PRINT(x)                      \
+    do {                                    \
+        DEBUG_PRINT_TABS;                   \
+        fprintf(stderr, "%s: %d\n", #x, x); \
+    } while(0)
+#define DEBUG_STR(x)                \
+    do {                            \
+        DEBUG_PRINT_TABS;           \
+        fprintf(stderr, "%s\n", x); \
+    } while(0)
+class DebugTab {
+public:
+    DebugTab() {
+        ++numDebugTabs;
+    }
+    ~DebugTab() {
+        --numDebugTabs;
+    }
+};
+#define DEBUG_TAB DebugTab dummy
+#else
+#define DEBUG_PRINT(x) \
+    do {               \
+        x = x;         \
+    } while(0)
+// Note: the "x=x;" statement is intended to eliminate "unused variable" compiler warning messages
+#define DEBUG_STR(x) \
+    do {             \
+    } while(0)
+#define DEBUG_TAB \
+    do {          \
+    } while(0)
+#endif
+
+void H264or5VideoStreamParser::profile_tier_level(BitVector &bv, unsigned max_sub_layers_minus1) {
+    bv.skipBits(96);
+
+    unsigned i;
+    Boolean  sub_layer_profile_present_flag[7], sub_layer_level_present_flag[7];
+    for(i = 0; i < max_sub_layers_minus1; ++i) {
+        sub_layer_profile_present_flag[i] = bv.get1BitBoolean();
+        sub_layer_level_present_flag[i]   = bv.get1BitBoolean();
+    }
+    if(max_sub_layers_minus1 > 0) {
+        bv.skipBits(2 * (8 - max_sub_layers_minus1));  // reserved_zero_2bits
+    }
+    for(i = 0; i < max_sub_layers_minus1; ++i) {
+        if(sub_layer_profile_present_flag[i]) {
+            bv.skipBits(88);
+        }
+        if(sub_layer_level_present_flag[i]) {
+            bv.skipBits(8);  // sub_layer_level_idc[i]
+        }
+    }
+}
+
+void H264or5VideoStreamParser ::analyze_vui_parameters(BitVector &bv, unsigned &num_units_in_tick, unsigned &time_scale) {
+    Boolean aspect_ratio_info_present_flag = bv.get1BitBoolean();
+    DEBUG_PRINT(aspect_ratio_info_present_flag);
+    if(aspect_ratio_info_present_flag) {
+        DEBUG_TAB;
+        unsigned aspect_ratio_idc = bv.getBits(8);
+        DEBUG_PRINT(aspect_ratio_idc);
+        if(aspect_ratio_idc == 255 /*Extended_SAR*/) {
+            bv.skipBits(32);  // sar_width; sar_height
+        }
+    }
+    Boolean overscan_info_present_flag = bv.get1BitBoolean();
+    DEBUG_PRINT(overscan_info_present_flag);
+    if(overscan_info_present_flag) {
+        bv.skipBits(1);  // overscan_appropriate_flag
+    }
+    Boolean video_signal_type_present_flag = bv.get1BitBoolean();
+    DEBUG_PRINT(video_signal_type_present_flag);
+    if(video_signal_type_present_flag) {
+        DEBUG_TAB;
+        bv.skipBits(4);  // video_format; video_full_range_flag
+        Boolean colour_description_present_flag = bv.get1BitBoolean();
+        DEBUG_PRINT(colour_description_present_flag);
+        if(colour_description_present_flag) {
+            bv.skipBits(24);  // colour_primaries; transfer_characteristics; matrix_coefficients
+        }
+    }
+    Boolean chroma_loc_info_present_flag = bv.get1BitBoolean();
+    DEBUG_PRINT(chroma_loc_info_present_flag);
+    if(chroma_loc_info_present_flag) {
+        (void)bv.get_expGolomb();  // chroma_sample_loc_type_top_field
+        (void)bv.get_expGolomb();  // chroma_sample_loc_type_bottom_field
+    }
+    if(fHNumber == 265) {
+        bv.skipBits(2);  // neutral_chroma_indication_flag, field_seq_flag
+        Boolean frame_field_info_present_flag = bv.get1BitBoolean();
+        DEBUG_PRINT(frame_field_info_present_flag);
+        pic_struct_present_flag             = frame_field_info_present_flag;  // hack to make H.265 like H.264
+        Boolean default_display_window_flag = bv.get1BitBoolean();
+        DEBUG_PRINT(default_display_window_flag);
+        if(default_display_window_flag) {
+            (void)bv.get_expGolomb();  // def_disp_win_left_offset
+            (void)bv.get_expGolomb();  // def_disp_win_right_offset
+            (void)bv.get_expGolomb();  // def_disp_win_top_offset
+            (void)bv.get_expGolomb();  // def_disp_win_bottom_offset
+        }
+    }
+    Boolean timing_info_present_flag = bv.get1BitBoolean();
+    DEBUG_PRINT(timing_info_present_flag);
+    if(timing_info_present_flag) {
+        DEBUG_TAB;
+        num_units_in_tick = bv.getBits(32);
+        DEBUG_PRINT(num_units_in_tick);
+        time_scale = bv.getBits(32);
+        DEBUG_PRINT(time_scale);
+        if(fHNumber == 264) {
+            Boolean fixed_frame_rate_flag = bv.get1BitBoolean();
+            DEBUG_PRINT(fixed_frame_rate_flag);
+        }
+        else {  // 265
+            Boolean vui_poc_proportional_to_timing_flag = bv.get1BitBoolean();
+            DEBUG_PRINT(vui_poc_proportional_to_timing_flag);
+            if(vui_poc_proportional_to_timing_flag) {
+                unsigned vui_num_ticks_poc_diff_one_minus1 = bv.get_expGolomb();
+                DEBUG_PRINT(vui_num_ticks_poc_diff_one_minus1);
+            }
+            return;  // For H.265, don't bother parsing any more of this #####
+        }
+    }
+    // The following is H.264 only: #####
+    Boolean nal_hrd_parameters_present_flag = bv.get1BitBoolean();
+    DEBUG_PRINT(nal_hrd_parameters_present_flag);
+    if(nal_hrd_parameters_present_flag)
+        analyze_hrd_parameters(bv);
+    Boolean vcl_hrd_parameters_present_flag = bv.get1BitBoolean();
+    DEBUG_PRINT(vcl_hrd_parameters_present_flag);
+    if(vcl_hrd_parameters_present_flag)
+        analyze_hrd_parameters(bv);
+    CpbDpbDelaysPresentFlag = nal_hrd_parameters_present_flag || vcl_hrd_parameters_present_flag;
+    if(CpbDpbDelaysPresentFlag) {
+        bv.skipBits(1);  // low_delay_hrd_flag
+    }
+    pic_struct_present_flag = bv.get1BitBoolean();
+    DEBUG_PRINT(pic_struct_present_flag);
+}
+
+void H264or5VideoStreamParser::analyze_hrd_parameters(BitVector &bv) {
+    DEBUG_TAB;
+    unsigned cpb_cnt_minus1 = bv.get_expGolomb();
+    DEBUG_PRINT(cpb_cnt_minus1);
+    unsigned bit_rate_scale = bv.getBits(4);
+    DEBUG_PRINT(bit_rate_scale);
+    unsigned cpb_size_scale = bv.getBits(4);
+    DEBUG_PRINT(cpb_size_scale);
+    for(unsigned SchedSelIdx = 0; SchedSelIdx <= cpb_cnt_minus1; ++SchedSelIdx) {
+        DEBUG_TAB;
+        DEBUG_PRINT(SchedSelIdx);
+        unsigned bit_rate_value_minus1 = bv.get_expGolomb();
+        DEBUG_PRINT(bit_rate_value_minus1);
+        unsigned cpb_size_value_minus1 = bv.get_expGolomb();
+        DEBUG_PRINT(cpb_size_value_minus1);
+        Boolean cbr_flag = bv.get1BitBoolean();
+        DEBUG_PRINT(cbr_flag);
+    }
+    unsigned initial_cpb_removal_delay_length_minus1 = bv.getBits(5);
+    DEBUG_PRINT(initial_cpb_removal_delay_length_minus1);
+    cpb_removal_delay_length_minus1 = bv.getBits(5);
+    DEBUG_PRINT(cpb_removal_delay_length_minus1);
+    dpb_output_delay_length_minus1 = bv.getBits(5);
+    DEBUG_PRINT(dpb_output_delay_length_minus1);
+    unsigned time_offset_length = bv.getBits(5);
+    DEBUG_PRINT(time_offset_length);
+}
+
+void H264or5VideoStreamParser ::analyze_video_parameter_set_data(unsigned &num_units_in_tick, unsigned &time_scale) {
+    num_units_in_tick = time_scale = 0;  // default values
+
+    // Begin by making a copy of the NAL unit data, removing any 'emulation prevention' bytes:
+    u_int8_t vps[VPS_MAX_SIZE];
+    unsigned vpsSize;
+    removeEmulationBytes(vps, sizeof vps, vpsSize);
+
+    BitVector bv(vps, 0, 8 * vpsSize);
+
+    // Assert: fHNumber == 265 (because this function is called only when parsing H.265)
+    unsigned i;
+
+    bv.skipBits(28);  // nal_unit_header, vps_video_parameter_set_id, vps_reserved_three_2bits, vps_max_layers_minus1
+    unsigned vps_max_sub_layers_minus1 = bv.getBits(3);
+    DEBUG_PRINT(vps_max_sub_layers_minus1);
+    bv.skipBits(17);  // vps_temporal_id_nesting_flag, vps_reserved_0xffff_16bits
+    profile_tier_level(bv, vps_max_sub_layers_minus1);
+    Boolean vps_sub_layer_ordering_info_present_flag = bv.get1BitBoolean();
+    DEBUG_PRINT(vps_sub_layer_ordering_info_present_flag);
+    for(i = vps_sub_layer_ordering_info_present_flag ? 0 : vps_max_sub_layers_minus1; i <= vps_max_sub_layers_minus1; ++i) {
+        (void)bv.get_expGolomb();  // vps_max_dec_pic_buffering_minus1[i]
+        (void)bv.get_expGolomb();  // vps_max_num_reorder_pics[i]
+        (void)bv.get_expGolomb();  // vps_max_latency_increase_plus1[i]
+    }
+    unsigned vps_max_layer_id = bv.getBits(6);
+    DEBUG_PRINT(vps_max_layer_id);
+    unsigned vps_num_layer_sets_minus1 = bv.get_expGolomb();
+    DEBUG_PRINT(vps_num_layer_sets_minus1);
+    for(i = 1; i <= vps_num_layer_sets_minus1; ++i) {
+        bv.skipBits(vps_max_layer_id + 1);  // layer_id_included_flag[i][0..vps_max_layer_id]
+    }
+    Boolean vps_timing_info_present_flag = bv.get1BitBoolean();
+    DEBUG_PRINT(vps_timing_info_present_flag);
+    if(vps_timing_info_present_flag) {
+        DEBUG_TAB;
+        num_units_in_tick = bv.getBits(32);
+        DEBUG_PRINT(num_units_in_tick);
+        time_scale = bv.getBits(32);
+        DEBUG_PRINT(time_scale);
+        Boolean vps_poc_proportional_to_timing_flag = bv.get1BitBoolean();
+        DEBUG_PRINT(vps_poc_proportional_to_timing_flag);
+        if(vps_poc_proportional_to_timing_flag) {
+            unsigned vps_num_ticks_poc_diff_one_minus1 = bv.get_expGolomb();
+            DEBUG_PRINT(vps_num_ticks_poc_diff_one_minus1);
+        }
+    }
+    Boolean vps_extension_flag = bv.get1BitBoolean();
+    DEBUG_PRINT(vps_extension_flag);
+}
+
+void H264or5VideoStreamParser ::analyze_seq_parameter_set_data(unsigned &num_units_in_tick, unsigned &time_scale) {
+    num_units_in_tick = time_scale = 0;  // default values
+
+    // Begin by making a copy of the NAL unit data, removing any 'emulation prevention' bytes:
+    u_int8_t sps[SPS_MAX_SIZE];
+    unsigned spsSize;
+    removeEmulationBytes(sps, sizeof sps, spsSize);
+
+    BitVector bv(sps, 0, 8 * spsSize);
+
+    if(fHNumber == 264) {
+        bv.skipBits(8);  // forbidden_zero_bit; nal_ref_idc; nal_unit_type
+        unsigned profile_idc = bv.getBits(8);
+        DEBUG_PRINT(profile_idc);
+        unsigned constraint_setN_flag = bv.getBits(8);  // also "reserved_zero_2bits" at end
+        DEBUG_PRINT(constraint_setN_flag);
+        unsigned level_idc = bv.getBits(8);
+        DEBUG_PRINT(level_idc);
+        unsigned seq_parameter_set_id = bv.get_expGolomb();
+        DEBUG_PRINT(seq_parameter_set_id);
+        if(profile_idc == 100 || profile_idc == 110 || profile_idc == 122 || profile_idc == 244 || profile_idc == 44 || profile_idc == 83 || profile_idc == 86
+           || profile_idc == 118 || profile_idc == 128) {
+            DEBUG_TAB;
+            unsigned chroma_format_idc = bv.get_expGolomb();
+            DEBUG_PRINT(chroma_format_idc);
+            if(chroma_format_idc == 3) {
+                DEBUG_TAB;
+                Boolean separate_colour_plane_flag = bv.get1BitBoolean();
+                DEBUG_PRINT(separate_colour_plane_flag);
+            }
+            (void)bv.get_expGolomb();  // bit_depth_luma_minus8
+            (void)bv.get_expGolomb();  // bit_depth_chroma_minus8
+            bv.skipBits(1);            // qpprime_y_zero_transform_bypass_flag
+            Boolean seq_scaling_matrix_present_flag = bv.get1BitBoolean();
+            DEBUG_PRINT(seq_scaling_matrix_present_flag);
+            if(seq_scaling_matrix_present_flag) {
+                for(int i = 0; i < ((chroma_format_idc != 3) ? 8 : 12); ++i) {
+                    DEBUG_TAB;
+                    DEBUG_PRINT(i);
+                    Boolean seq_scaling_list_present_flag = bv.get1BitBoolean();
+                    DEBUG_PRINT(seq_scaling_list_present_flag);
+                    if(seq_scaling_list_present_flag) {
+                        DEBUG_TAB;
+                        unsigned sizeOfScalingList = i < 6 ? 16 : 64;
+                        unsigned lastScale         = 8;
+                        unsigned nextScale         = 8;
+                        for(unsigned j = 0; j < sizeOfScalingList; ++j) {
+                            DEBUG_TAB;
+                            DEBUG_PRINT(j);
+                            DEBUG_PRINT(nextScale);
+                            if(nextScale != 0) {
+                                DEBUG_TAB;
+                                int delta_scale = bv.get_expGolombSigned();
+                                DEBUG_PRINT(delta_scale);
+                                nextScale = (lastScale + delta_scale + 256) % 256;
+                            }
+                            lastScale = (nextScale == 0) ? lastScale : nextScale;
+                            DEBUG_PRINT(lastScale);
+                        }
+                    }
+                }
+            }
+        }
+        unsigned log2_max_frame_num_minus4 = bv.get_expGolomb();
+        DEBUG_PRINT(log2_max_frame_num_minus4);
+        unsigned pic_order_cnt_type = bv.get_expGolomb();
+        DEBUG_PRINT(pic_order_cnt_type);
+        if(pic_order_cnt_type == 0) {
+            DEBUG_TAB;
+            unsigned log2_max_pic_order_cnt_lsb_minus4 = bv.get_expGolomb();
+            DEBUG_PRINT(log2_max_pic_order_cnt_lsb_minus4);
+        }
+        else if(pic_order_cnt_type == 1) {
+            DEBUG_TAB;
+            bv.skipBits(1);                  // delta_pic_order_always_zero_flag
+            (void)bv.get_expGolombSigned();  // offset_for_non_ref_pic
+            (void)bv.get_expGolombSigned();  // offset_for_top_to_bottom_field
+            unsigned num_ref_frames_in_pic_order_cnt_cycle = bv.get_expGolomb();
+            DEBUG_PRINT(num_ref_frames_in_pic_order_cnt_cycle);
+            for(unsigned i = 0; i < num_ref_frames_in_pic_order_cnt_cycle; ++i) {
+                (void)bv.get_expGolombSigned();  // offset_for_ref_frame[i]
+            }
+        }
+        unsigned max_num_ref_frames = bv.get_expGolomb();
+        DEBUG_PRINT(max_num_ref_frames);
+        Boolean gaps_in_frame_num_value_allowed_flag = bv.get1BitBoolean();
+        DEBUG_PRINT(gaps_in_frame_num_value_allowed_flag);
+        unsigned pic_width_in_mbs_minus1 = bv.get_expGolomb();
+        DEBUG_PRINT(pic_width_in_mbs_minus1);
+        unsigned pic_height_in_map_units_minus1 = bv.get_expGolomb();
+        DEBUG_PRINT(pic_height_in_map_units_minus1);
+        Boolean frame_mbs_only_flag = bv.get1BitBoolean();
+        DEBUG_PRINT(frame_mbs_only_flag);
+        if(!frame_mbs_only_flag) {
+            bv.skipBits(1);  // mb_adaptive_frame_field_flag
+        }
+        bv.skipBits(1);  // direct_8x8_inference_flag
+        Boolean frame_cropping_flag = bv.get1BitBoolean();
+        DEBUG_PRINT(frame_cropping_flag);
+        if(frame_cropping_flag) {
+            (void)bv.get_expGolomb();  // frame_crop_left_offset
+            (void)bv.get_expGolomb();  // frame_crop_right_offset
+            (void)bv.get_expGolomb();  // frame_crop_top_offset
+            (void)bv.get_expGolomb();  // frame_crop_bottom_offset
+        }
+        Boolean vui_parameters_present_flag = bv.get1BitBoolean();
+        DEBUG_PRINT(vui_parameters_present_flag);
+        if(vui_parameters_present_flag) {
+            DEBUG_TAB;
+            analyze_vui_parameters(bv, num_units_in_tick, time_scale);
+        }
+    }
+    else {  // 265
+        unsigned i;
+
+        bv.skipBits(16);  // nal_unit_header
+        bv.skipBits(4);   // sps_video_parameter_set_id
+        unsigned sps_max_sub_layers_minus1 = bv.getBits(3);
+        DEBUG_PRINT(sps_max_sub_layers_minus1);
+        bv.skipBits(1);  // sps_temporal_id_nesting_flag
+        profile_tier_level(bv, sps_max_sub_layers_minus1);
+        (void)bv.get_expGolomb();  // sps_seq_parameter_set_id
+        unsigned chroma_format_idc = bv.get_expGolomb();
+        DEBUG_PRINT(chroma_format_idc);
+        if(chroma_format_idc == 3)
+            bv.skipBits(1);  // separate_colour_plane_flag
+        unsigned pic_width_in_luma_samples = bv.get_expGolomb();
+        DEBUG_PRINT(pic_width_in_luma_samples);
+        unsigned pic_height_in_luma_samples = bv.get_expGolomb();
+        DEBUG_PRINT(pic_height_in_luma_samples);
+        Boolean conformance_window_flag = bv.get1BitBoolean();
+        DEBUG_PRINT(conformance_window_flag);
+        if(conformance_window_flag) {
+            DEBUG_TAB;
+            unsigned conf_win_left_offset = bv.get_expGolomb();
+            DEBUG_PRINT(conf_win_left_offset);
+            unsigned conf_win_right_offset = bv.get_expGolomb();
+            DEBUG_PRINT(conf_win_right_offset);
+            unsigned conf_win_top_offset = bv.get_expGolomb();
+            DEBUG_PRINT(conf_win_top_offset);
+            unsigned conf_win_bottom_offset = bv.get_expGolomb();
+            DEBUG_PRINT(conf_win_bottom_offset);
+        }
+        (void)bv.get_expGolomb();  // bit_depth_luma_minus8
+        (void)bv.get_expGolomb();  // bit_depth_chroma_minus8
+        unsigned log2_max_pic_order_cnt_lsb_minus4        = bv.get_expGolomb();
+        Boolean  sps_sub_layer_ordering_info_present_flag = bv.get1BitBoolean();
+        DEBUG_PRINT(sps_sub_layer_ordering_info_present_flag);
+        for(i = (sps_sub_layer_ordering_info_present_flag ? 0 : sps_max_sub_layers_minus1); i <= sps_max_sub_layers_minus1; ++i) {
+            (void)bv.get_expGolomb();  // sps_max_dec_pic_buffering_minus1[i]
+            (void)bv.get_expGolomb();  // sps_max_num_reorder_pics[i]
+            (void)bv.get_expGolomb();  // sps_max_latency_increase[i]
+        }
+        (void)bv.get_expGolomb();  // log2_min_luma_coding_block_size_minus3
+        (void)bv.get_expGolomb();  // log2_diff_max_min_luma_coding_block_size
+        (void)bv.get_expGolomb();  // log2_min_transform_block_size_minus2
+        (void)bv.get_expGolomb();  // log2_diff_max_min_transform_block_size
+        (void)bv.get_expGolomb();  // max_transform_hierarchy_depth_inter
+        (void)bv.get_expGolomb();  // max_transform_hierarchy_depth_intra
+        Boolean scaling_list_enabled_flag = bv.get1BitBoolean();
+        DEBUG_PRINT(scaling_list_enabled_flag);
+        if(scaling_list_enabled_flag) {
+            DEBUG_TAB;
+            Boolean sps_scaling_list_data_present_flag = bv.get1BitBoolean();
+            DEBUG_PRINT(sps_scaling_list_data_present_flag);
+            if(sps_scaling_list_data_present_flag) {
+                // scaling_list_data()
+                DEBUG_TAB;
+                for(unsigned sizeId = 0; sizeId < 4; ++sizeId) {
+                    DEBUG_PRINT(sizeId);
+                    for(unsigned matrixId = 0; matrixId < (sizeId == 3 ? 2 : 6); ++matrixId) {
+                        DEBUG_TAB;
+                        DEBUG_PRINT(matrixId);
+                        Boolean scaling_list_pred_mode_flag = bv.get1BitBoolean();
+                        DEBUG_PRINT(scaling_list_pred_mode_flag);
+                        if(!scaling_list_pred_mode_flag) {
+                            (void)bv.get_expGolomb();  // scaling_list_pred_matrix_id_delta[sizeId][matrixId]
+                        }
+                        else {
+                            unsigned const c       = 1 << (4 + (sizeId << 1));
+                            unsigned       coefNum = c < 64 ? c : 64;
+                            if(sizeId > 1) {
+                                (void)bv.get_expGolomb();  // scaling_list_dc_coef_minus8[sizeId][matrixId]
+                            }
+                            for(i = 0; i < coefNum; ++i) {
+                                (void)bv.get_expGolomb();  // scaling_list_delta_coef
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        bv.skipBits(2);  // amp_enabled_flag, sample_adaptive_offset_enabled_flag
+        Boolean pcm_enabled_flag = bv.get1BitBoolean();
+        DEBUG_PRINT(pcm_enabled_flag);
+        if(pcm_enabled_flag) {
+            bv.skipBits(8);            // pcm_sample_bit_depth_luma_minus1, pcm_sample_bit_depth_chroma_minus1
+            (void)bv.get_expGolomb();  // log2_min_pcm_luma_coding_block_size_minus3
+            (void)bv.get_expGolomb();  // log2_diff_max_min_pcm_luma_coding_block_size
+            bv.skipBits(1);            // pcm_loop_filter_disabled_flag
+        }
+        unsigned num_short_term_ref_pic_sets = bv.get_expGolomb();
+        DEBUG_PRINT(num_short_term_ref_pic_sets);
+        unsigned num_negative_pics = 0, prev_num_negative_pics = 0;
+        unsigned num_positive_pics = 0, prev_num_positive_pics = 0;
+        for(i = 0; i < num_short_term_ref_pic_sets; ++i) {
+            // short_term_ref_pic_set(i):
+            DEBUG_TAB;
+            DEBUG_PRINT(i);
+            Boolean inter_ref_pic_set_prediction_flag = False;
+            if(i != 0) {
+                inter_ref_pic_set_prediction_flag = bv.get1BitBoolean();
+            }
+            DEBUG_PRINT(inter_ref_pic_set_prediction_flag);
+            if(inter_ref_pic_set_prediction_flag) {
+                DEBUG_TAB;
+                if(i == num_short_term_ref_pic_sets) {
+                    // This can't happen here, but it's in the spec, so we include it for completeness
+                    (void)bv.get_expGolomb();  // delta_idx_minus1
+                }
+                bv.skipBits(1);                                                           // delta_rps_sign
+                (void)bv.get_expGolomb();                                                 // abs_delta_rps_minus1
+                unsigned NumDeltaPocs = prev_num_negative_pics + prev_num_positive_pics;  // correct???
+                for(unsigned j = 0; j < NumDeltaPocs; ++j) {
+                    DEBUG_PRINT(j);
+                    Boolean used_by_curr_pic_flag = bv.get1BitBoolean();
+                    DEBUG_PRINT(used_by_curr_pic_flag);
+                    if(!used_by_curr_pic_flag)
+                        bv.skipBits(1);  // use_delta_flag[j]
+                }
+            }
+            else {
+                prev_num_negative_pics = num_negative_pics;
+                num_negative_pics      = bv.get_expGolomb();
+                DEBUG_PRINT(num_negative_pics);
+                prev_num_positive_pics = num_positive_pics;
+                num_positive_pics      = bv.get_expGolomb();
+                DEBUG_PRINT(num_positive_pics);
+                unsigned k;
+                for(k = 0; k < num_negative_pics; ++k) {
+                    (void)bv.get_expGolomb();  // delta_poc_s0_minus1[k]
+                    bv.skipBits(1);            // used_by_curr_pic_s0_flag[k]
+                }
+                for(k = 0; k < num_positive_pics; ++k) {
+                    (void)bv.get_expGolomb();  // delta_poc_s1_minus1[k]
+                    bv.skipBits(1);            // used_by_curr_pic_s1_flag[k]
+                }
+            }
+        }
+        Boolean long_term_ref_pics_present_flag = bv.get1BitBoolean();
+        DEBUG_PRINT(long_term_ref_pics_present_flag);
+        if(long_term_ref_pics_present_flag) {
+            DEBUG_TAB;
+            unsigned num_long_term_ref_pics_sps = bv.get_expGolomb();
+            DEBUG_PRINT(num_long_term_ref_pics_sps);
+            for(i = 0; i < num_long_term_ref_pics_sps; ++i) {
+                bv.skipBits(log2_max_pic_order_cnt_lsb_minus4);  // lt_ref_pic_poc_lsb_sps[i]
+                bv.skipBits(1);                                  // used_by_curr_pic_lt_sps_flag[1]
+            }
+        }
+        bv.skipBits(2);  // sps_temporal_mvp_enabled_flag, strong_intra_smoothing_enabled_flag
+        Boolean vui_parameters_present_flag = bv.get1BitBoolean();
+        DEBUG_PRINT(vui_parameters_present_flag);
+        if(vui_parameters_present_flag) {
+            DEBUG_TAB;
+            analyze_vui_parameters(bv, num_units_in_tick, time_scale);
+        }
+        Boolean sps_extension_flag = bv.get1BitBoolean();
+        DEBUG_PRINT(sps_extension_flag);
+    }
+}
+
+#define SEI_MAX_SIZE 5000  // larger than the largest possible SEI NAL unit
+
+#ifdef DEBUG
+#define MAX_SEI_PAYLOAD_TYPE_DESCRIPTION_H264 46
+char const *sei_payloadType_description_h264[MAX_SEI_PAYLOAD_TYPE_DESCRIPTION_H264 + 1] = {
+    "buffering_period",                      // 0
+    "pic_timing",                            // 1
+    "pan_scan_rect",                         // 2
+    "filler_payload",                        // 3
+    "user_data_registered_itu_t_t35",        // 4
+    "user_data_unregistered",                // 5
+    "recovery_point",                        // 6
+    "dec_ref_pic_marking_repetition",        // 7
+    "spare_pic",                             // 8
+    "scene_info",                            // 9
+    "sub_seq_info",                          // 10
+    "sub_seq_layer_characteristics",         // 11
+    "sub_seq_characteristics",               // 12
+    "full_frame_freeze",                     // 13
+    "full_frame_freeze_release",             // 14
+    "full_frame_snapshot",                   // 15
+    "progressive_refinement_segment_start",  // 16
+    "progressive_refinement_segment_end",    // 17
+    "motion_constrained_slice_group_set",    // 18
+    "film_grain_characteristics",            // 19
+    "deblocking_filter_display_preference",  // 20
+    "stereo_video_info",                     // 21
+    "post_filter_hint",                      // 22
+    "tone_mapping_info",                     // 23
+    "scalability_info",                      // 24
+    "sub_pic_scalable_layer",                // 25
+    "non_required_layer_rep",                // 26
+    "priority_layer_info",                   // 27
+    "layers_not_present",                    // 28
+    "layer_dependency_change",               // 29
+    "scalable_nesting",                      // 30
+    "base_layer_temporal_hrd",               // 31
+    "quality_layer_integrity_check",         // 32
+    "redundant_pic_property",                // 33
+    "tl0_dep_rep_index",                     // 34
+    "tl_switching_point",                    // 35
+    "parallel_decoding_info",                // 36
+    "mvc_scalable_nesting",                  // 37
+    "view_scalability_info",                 // 38
+    "multiview_scene_info",                  // 39
+    "multiview_acquisition_info",            // 40
+    "non_required_view_component",           // 41
+    "view_dependency_change",                // 42
+    "operation_points_not_present",          // 43
+    "base_view_temporal_hrd",                // 44
+    "frame_packing_arrangement",             // 45
+    "reserved_sei_message"                   // 46 or higher
+};
+#endif
+
+void H264or5VideoStreamParser::analyze_sei_data(u_int8_t nal_unit_type) {
+    // Begin by making a copy of the NAL unit data, removing any 'emulation prevention' bytes:
+    u_int8_t sei[SEI_MAX_SIZE];
+    unsigned seiSize;
+    removeEmulationBytes(sei, sizeof sei, seiSize);
+
+    unsigned j = 1;  // skip the initial byte (forbidden_zero_bit; nal_ref_idc; nal_unit_type); we've already seen it
+    while(j < seiSize) {
+        unsigned payloadType = 0;
+        do {
+            payloadType += sei[j];
+        } while(sei[j++] == 255 && j < seiSize);
+        if(j >= seiSize)
+            break;
+
+        unsigned payloadSize = 0;
+        do {
+            payloadSize += sei[j];
+        } while(sei[j++] == 255 && j < seiSize);
+        if(j >= seiSize)
+            break;
+
+#ifdef DEBUG
+        char const *description;
+        if(fHNumber == 264) {
+            unsigned descriptionNum = payloadType <= MAX_SEI_PAYLOAD_TYPE_DESCRIPTION_H264 ? payloadType : MAX_SEI_PAYLOAD_TYPE_DESCRIPTION_H264;
+            description             = sei_payloadType_description_h264[descriptionNum];
+        }
+        else {  // 265
+            description = payloadType == 3                                          ? "filler_payload"
+                          : payloadType == 4                                        ? "user_data_registered_itu_t_t35"
+                          : payloadType == 5                                        ? "user_data_unregistered"
+                          : payloadType == 17                                       ? "progressive_refinement_segment_end"
+                          : payloadType == 22                                       ? "post_filter_hint"
+                          : (payloadType == 132 && nal_unit_type == SUFFIX_SEI_NUT) ? "decoded_picture_hash"
+                          : nal_unit_type == SUFFIX_SEI_NUT                         ? "reserved_sei_message"
+                          : payloadType == 0                                        ? "buffering_period"
+                          : payloadType == 1                                        ? "pic_timing"
+                          : payloadType == 2                                        ? "pan_scan_rect"
+                          : payloadType == 6                                        ? "recovery_point"
+                          : payloadType == 9                                        ? "scene_info"
+                          : payloadType == 15                                       ? "picture_snapshot"
+                          : payloadType == 16                                       ? "progressive_refinement_segment_start"
+                          : payloadType == 19                                       ? "film_grain_characteristics"
+                          : payloadType == 23                                       ? "tone_mapping_info"
+                          : payloadType == 45                                       ? "frame_packing_arrangement"
+                          : payloadType == 47                                       ? "display_orientation"
+                          : payloadType == 128                                      ? "structure_of_pictures_info"
+                          : payloadType == 129                                      ? "active_parameter_sets"
+                          : payloadType == 130                                      ? "decoding_unit_info"
+                          : payloadType == 131                                      ? "temporal_sub_layer_zero_index"
+                          : payloadType == 133                                      ? "scalable_nesting"
+                          : payloadType == 134                                      ? "region_refresh_info"
+                                                                                    : "reserved_sei_message";
+        }
+        fprintf(stderr, "\tpayloadType %d (\"%s\"); payloadSize %d\n", payloadType, description, payloadSize);
+#endif
+
+        analyze_sei_payload(payloadType, payloadSize, &sei[j]);
+        j += payloadSize;
+    }
+}
+
+void H264or5VideoStreamParser ::analyze_sei_payload(unsigned payloadType, unsigned payloadSize, u_int8_t *payload) {
+    if(payloadType == 1 /* pic_timing, for both H.264 and H.265 */) {
+        BitVector bv(payload, 0, 8 * payloadSize);
+
+        DEBUG_TAB;
+        if(CpbDpbDelaysPresentFlag) {
+            unsigned cpb_removal_delay = bv.getBits(cpb_removal_delay_length_minus1 + 1);
+            DEBUG_PRINT(cpb_removal_delay);
+            unsigned dpb_output_delay = bv.getBits(dpb_output_delay_length_minus1 + 1);
+            DEBUG_PRINT(dpb_output_delay);
+        }
+        double prevDeltaTfiDivisor = DeltaTfiDivisor;
+        if(pic_struct_present_flag) {
+            unsigned pic_struct = bv.getBits(4);
+            DEBUG_PRINT(pic_struct);
+            // Use this to set "DeltaTfiDivisor" (which is used to compute the frame rate):
+            if(fHNumber == 264) {
+                DeltaTfiDivisor = pic_struct == 0   ? 2.0
+                                  : pic_struct <= 2 ? 1.0
+                                  : pic_struct <= 4 ? 2.0
+                                  : pic_struct <= 6 ? 3.0
+                                  : pic_struct == 7 ? 4.0
+                                  : pic_struct == 8 ? 6.0
+                                                    : 2.0;
+            }
+            else {  // H.265
+                DeltaTfiDivisor = pic_struct == 0    ? 2.0
+                                  : pic_struct <= 2  ? 1.0
+                                  : pic_struct <= 4  ? 2.0
+                                  : pic_struct <= 6  ? 3.0
+                                  : pic_struct == 7  ? 2.0
+                                  : pic_struct == 8  ? 3.0
+                                  : pic_struct <= 12 ? 1.0
+                                                     : 2.0;
+            }
+        }
+        else {
+            if(fHNumber == 264) {
+                // Need to get field_pic_flag from slice_header to set this properly! #####
+            }
+            else {  // H.265
+                DeltaTfiDivisor = 1.0;
+            }
+        }
+        // If "DeltaTfiDivisor" has changed, and we've already computed the frame rate, then
+        // adjust it, based on the new value of "DeltaTfiDivisor":
+        if(DeltaTfiDivisor != prevDeltaTfiDivisor && fParsedFrameRate != 0.0) {
+            usingSource()->fFrameRate = fParsedFrameRate = fParsedFrameRate * (prevDeltaTfiDivisor / DeltaTfiDivisor);
+#ifdef DEBUG
+            fprintf(stderr, "Changed frame rate to %f fps\n", usingSource()->fFrameRate);
+#endif
+        }
+        // Ignore the rest of the payload (timestamps) for now... #####
+    }
+}
+
+void H264or5VideoStreamParser::flushInput() {
+    fHaveSeenFirstStartCode     = False;
+    fHaveSeenFirstByteOfNALUnit = False;
+
+    StreamParser::flushInput();
+}
+
+unsigned H264or5VideoStreamParser::parse() {
+    try {
+        // The stream must start with a 0x00000001:
+        if(!fHaveSeenFirstStartCode) {
+            // Skip over any input bytes that precede the first 0x00000001:
+            u_int32_t first4Bytes;
+            while((first4Bytes = test4Bytes()) != 0x00000001) {
+                get1Byte();
+                setParseState();  // ensures that we progress over bad data
+            }
+            skipBytes(4);  // skip this initial code
+
+            setParseState();
+            fHaveSeenFirstStartCode = True;  // from now on
+        }
+
+        if(fOutputStartCodeSize > 0 && curFrameSize() == 0 && !haveSeenEOF()) {
+            // Include a start code in the output:
+            save4Bytes(0x00000001);
+        }
+
+        // Then save everything up until the next 0x00000001 (4 bytes) or 0x000001 (3 bytes), or we hit EOF.
+        // Also make note of the first byte, because it contains the "nal_unit_type":
+        if(haveSeenEOF()) {
+            // We hit EOF the last time that we tried to parse this data, so we know that any remaining unparsed data
+            // forms a complete NAL unit, and that there's no 'start code' at the end:
+            unsigned remainingDataSize = totNumValidBytes() - curOffset();
+#ifdef DEBUG
+            unsigned const trailingNALUnitSize = remainingDataSize;
+#endif
+            while(remainingDataSize > 0) {
+                u_int8_t nextByte = get1Byte();
+                if(!fHaveSeenFirstByteOfNALUnit) {
+                    fFirstByteOfNALUnit         = nextByte;
+                    fHaveSeenFirstByteOfNALUnit = True;
+                }
+                saveByte(nextByte);
+                --remainingDataSize;
+            }
+
+#ifdef DEBUG
+            if(fHNumber == 264) {
+                u_int8_t nal_ref_idc   = (fFirstByteOfNALUnit & 0x60) >> 5;
+                u_int8_t nal_unit_type = fFirstByteOfNALUnit & 0x1F;
+                fprintf(stderr, "Parsed trailing %d-byte NAL-unit (nal_ref_idc: %d, nal_unit_type: %d (\"%s\"))\n", trailingNALUnitSize, nal_ref_idc,
+                        nal_unit_type, nal_unit_type_description_h264[nal_unit_type]);
+            }
+            else {  // 265
+                u_int8_t nal_unit_type = (fFirstByteOfNALUnit & 0x7E) >> 1;
+                fprintf(stderr, "Parsed trailing %d-byte NAL-unit (nal_unit_type: %d (\"%s\"))\n", trailingNALUnitSize, nal_unit_type,
+                        nal_unit_type_description_h265[nal_unit_type]);
+            }
+#endif
+
+            (void)get1Byte();  // forces another read, which will cause EOF to get handled for real this time
+            return 0;
+        }
+        else {
+            u_int32_t next4Bytes = test4Bytes();
+            if(!fHaveSeenFirstByteOfNALUnit) {
+                fFirstByteOfNALUnit         = next4Bytes >> 24;
+                fHaveSeenFirstByteOfNALUnit = True;
+            }
+            while(next4Bytes != 0x00000001 && (next4Bytes & 0xFFFFFF00) != 0x00000100) {
+                // We save at least some of "next4Bytes".
+                if((unsigned)(next4Bytes & 0xFF) > 1) {
+                    // Common case: 0x00000001 or 0x000001 definitely doesn't begin anywhere in "next4Bytes", so we save all of it:
+                    save4Bytes(next4Bytes);
+                    skipBytes(4);
+                }
+                else {
+                    // Save the first byte, and continue testing the rest:
+                    saveByte(next4Bytes >> 24);
+                    skipBytes(1);
+                }
+                setParseState();  // ensures forward progress
+                next4Bytes = test4Bytes();
+            }
+            // Assert: next4Bytes starts with 0x00000001 or 0x000001, and we've saved all previous bytes (forming a complete NAL unit).
+            // Skip over these remaining bytes, up until the start of the next NAL unit:
+            if(next4Bytes == 0x00000001) {
+                skipBytes(4);
+            }
+            else {
+                skipBytes(3);
+            }
+        }
+
+        fHaveSeenFirstByteOfNALUnit = False;  // for the next NAL unit that we'll parse
+        u_int8_t nal_unit_type;
+        if(fHNumber == 264) {
+            nal_unit_type = fFirstByteOfNALUnit & 0x1F;
+#ifdef DEBUG
+            u_int8_t nal_ref_idc = (fFirstByteOfNALUnit & 0x60) >> 5;
+            fprintf(stderr, "Parsed %d-byte NAL-unit (nal_ref_idc: %d, nal_unit_type: %d (\"%s\"))\n", curFrameSize() - fOutputStartCodeSize, nal_ref_idc,
+                    nal_unit_type, nal_unit_type_description_h264[nal_unit_type]);
+#endif
+        }
+        else {  // 265
+            nal_unit_type = (fFirstByteOfNALUnit & 0x7E) >> 1;
+#ifdef DEBUG
+            fprintf(stderr, "Parsed %d-byte NAL-unit (nal_unit_type: %d (\"%s\"))\n", curFrameSize() - fOutputStartCodeSize, nal_unit_type,
+                    nal_unit_type_description_h265[nal_unit_type]);
+#endif
+        }
+
+        // Now that we have found (& copied) a NAL unit, process it if it's of special interest to us:
+        if(isVPS(nal_unit_type)) {  // Video parameter set
+            // First, save a copy of this NAL unit, in case the downstream object wants to see it:
+            usingSource()->saveCopyOfVPS(fStartOfFrame + fOutputStartCodeSize, curFrameSize() - fOutputStartCodeSize);
+
+            if(fParsedFrameRate == 0.0) {
+                // We haven't yet parsed a frame rate from the stream.
+                // So parse this NAL unit to check whether frame rate information is present:
+                unsigned num_units_in_tick, time_scale;
+                analyze_video_parameter_set_data(num_units_in_tick, time_scale);
+                if(time_scale > 0 && num_units_in_tick > 0) {
+                    usingSource()->fFrameRate = fParsedFrameRate = time_scale / (DeltaTfiDivisor * num_units_in_tick);
+#ifdef DEBUG
+                    fprintf(stderr, "Set frame rate to %f fps\n", usingSource()->fFrameRate);
+#endif
+                }
+                else {
+#ifdef DEBUG
+                    fprintf(stderr, "\tThis \"Video Parameter Set\" NAL unit contained no frame rate information, so we use a default frame rate of %f fps\n",
+                            usingSource()->fFrameRate);
+#endif
+                }
+            }
+        }
+        else if(isSPS(nal_unit_type)) {  // Sequence parameter set
+            // First, save a copy of this NAL unit, in case the downstream object wants to see it:
+            usingSource()->saveCopyOfSPS(fStartOfFrame + fOutputStartCodeSize, curFrameSize() - fOutputStartCodeSize);
+
+            if(fParsedFrameRate == 0.0) {
+                // We haven't yet parsed a frame rate from the stream.
+                // So parse this NAL unit to check whether frame rate information is present:
+                unsigned num_units_in_tick, time_scale;
+                analyze_seq_parameter_set_data(num_units_in_tick, time_scale);
+                if(time_scale > 0 && num_units_in_tick > 0) {
+                    usingSource()->fFrameRate = fParsedFrameRate = time_scale / (DeltaTfiDivisor * num_units_in_tick);
+#ifdef DEBUG
+                    fprintf(stderr, "Set frame rate to %f fps\n", usingSource()->fFrameRate);
+#endif
+                }
+                else {
+#ifdef DEBUG
+                    fprintf(stderr,
+                            "\tThis \"Sequence Parameter Set\" NAL unit contained no frame rate information, so we use a default frame rate of %f fps\n",
+                            usingSource()->fFrameRate);
+#endif
+                }
+            }
+        }
+        else if(isPPS(nal_unit_type)) {  // Picture parameter set
+            // Save a copy of this NAL unit, in case the downstream object wants to see it:
+            usingSource()->saveCopyOfPPS(fStartOfFrame + fOutputStartCodeSize, curFrameSize() - fOutputStartCodeSize);
+        }
+        else if(isSEI(nal_unit_type)) {  // Supplemental enhancement information (SEI)
+            analyze_sei_data(nal_unit_type);
+            // Later, perhaps adjust "fPresentationTime" if we saw a "pic_timing" SEI payload??? #####
+        }
+
+        usingSource()->setPresentationTime();
+#ifdef DEBUG
+        unsigned long secs  = (unsigned long)usingSource()->fPresentationTime.tv_sec;
+        unsigned      uSecs = (unsigned)usingSource()->fPresentationTime.tv_usec;
+        fprintf(stderr, "\tPresentation time: %lu.%06u\n", secs, uSecs);
+#endif
+
+        // Now, check whether this NAL unit ends an 'access unit'.
+        // (RTP streamers need to know this in order to figure out whether or not to set the "M" bit.)
+        Boolean thisNALUnitEndsAccessUnit;
+        if(haveSeenEOF() || isEOF(nal_unit_type)) {
+            // There is no next NAL unit, so we assume that this one ends the current 'access unit':
+            thisNALUnitEndsAccessUnit = True;
+        }
+        else if(usuallyBeginsAccessUnit(nal_unit_type)) {
+            // These NAL units usually *begin* an access unit, so assume that they don't end one here:
+            thisNALUnitEndsAccessUnit = False;
+        }
+        else {
+            // We need to check the *next* NAL unit to figure out whether
+            // the current NAL unit ends an 'access unit':
+            u_int8_t firstBytesOfNextNALUnit[3];
+            testBytes(firstBytesOfNextNALUnit, 3);
+
+            u_int8_t const &next_nal_unit_type = fHNumber == 264 ? (firstBytesOfNextNALUnit[0] & 0x1F) : ((firstBytesOfNextNALUnit[0] & 0x7E) >> 1);
+            if(isVCL(next_nal_unit_type)) {
+                // The high-order bit of the byte after the "nal_unit_header" tells us whether it's
+                // the start of a new 'access unit' (and thus the current NAL unit ends an 'access unit'):
+                u_int8_t const byteAfter_nal_unit_header = fHNumber == 264 ? firstBytesOfNextNALUnit[1] : firstBytesOfNextNALUnit[2];
+                thisNALUnitEndsAccessUnit                = (byteAfter_nal_unit_header & 0x80) != 0;
+            }
+            else if(usuallyBeginsAccessUnit(next_nal_unit_type)) {
+                // The next NAL unit's type is one that usually appears at the start of an 'access unit',
+                // so we assume that the current NAL unit ends an 'access unit':
+                thisNALUnitEndsAccessUnit = True;
+            }
+            else {
+                // The next NAL unit definitely doesn't start a new 'access unit',
+                // which means that the current NAL unit doesn't end one:
+                thisNALUnitEndsAccessUnit = False;
+            }
+        }
+
+        if(thisNALUnitEndsAccessUnit) {
+#ifdef DEBUG
+            fprintf(stderr, "*****This NAL unit ends the current access unit*****\n");
+#endif
+            usingSource()->fPictureEndMarker = True;
+            ++usingSource()->fPictureCount;
+
+            // Note that the presentation time for the next NAL unit will be different:
+            struct timeval &nextPT     = usingSource()->fNextPresentationTime;  // alias
+            nextPT                     = usingSource()->fPresentationTime;
+            double   nextFraction      = nextPT.tv_usec / 1000000.0 + 1 / usingSource()->fFrameRate;
+            unsigned nextSecsIncrement = (long)nextFraction;
+            nextPT.tv_sec += (long)nextSecsIncrement;
+            nextPT.tv_usec = (long)((nextFraction - nextSecsIncrement) * 1000000);
+        }
+        setParseState();
+
+        return curFrameSize();
+    }
+    catch(int /*e*/) {
+#ifdef DEBUG
+        fprintf(stderr, "H264or5VideoStreamParser::parse() EXCEPTION (This is normal behavior - *not* an error)\n");
+#endif
+        return 0;  // the parsing got interrupted
+    }
+}
+
+unsigned removeH264or5EmulationBytes(u_int8_t *to, unsigned toMaxSize, u_int8_t const *from, unsigned fromSize) {
+    unsigned toSize = 0;
+    unsigned i      = 0;
+    while(i < fromSize && toSize + 1 < toMaxSize) {
+        if(i + 2 < fromSize && from[i] == 0 && from[i + 1] == 0 && from[i + 2] == 3) {
+            to[toSize] = to[toSize + 1] = 0;
+            toSize += 2;
+            i += 3;
+        }
+        else {
+            to[toSize] = from[i];
+            toSize += 1;
+            i += 1;
+        }
+    }
+
+    return toSize;
+}
diff --git a/3rdparty/live555/src/liveMedia/H265VideoFileServerMediaSubsession.cpp b/3rdparty/live555/src/liveMedia/H265VideoFileServerMediaSubsession.cpp
new file mode 100644
index 00000000..b3c11e65
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/H265VideoFileServerMediaSubsession.cpp
@@ -0,0 +1,115 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A 'ServerMediaSubsession' object that creates new, unicast, "RTPSink"s
+// on demand, from a H265 video file.
+// Implementation
+
+#include "H265VideoFileServerMediaSubsession.hh"
+#include "H265VideoRTPSink.hh"
+#include "ByteStreamFileSource.hh"
+#include "H265VideoStreamFramer.hh"
+
+H265VideoFileServerMediaSubsession *H265VideoFileServerMediaSubsession::createNew(UsageEnvironment &env, char const *fileName, Boolean reuseFirstSource) {
+    return new H265VideoFileServerMediaSubsession(env, fileName, reuseFirstSource);
+}
+
+H265VideoFileServerMediaSubsession::H265VideoFileServerMediaSubsession(UsageEnvironment &env, char const *fileName, Boolean reuseFirstSource)
+    : FileServerMediaSubsession(env, fileName, reuseFirstSource), fAuxSDPLine(NULL), fDoneFlag(0), fDummyRTPSink(NULL) {}
+
+H265VideoFileServerMediaSubsession::~H265VideoFileServerMediaSubsession() {
+    delete[] fAuxSDPLine;
+}
+
+static void afterPlayingDummy(void *clientData) {
+    H265VideoFileServerMediaSubsession *subsess = (H265VideoFileServerMediaSubsession *)clientData;
+    subsess->afterPlayingDummy1();
+}
+
+void H265VideoFileServerMediaSubsession::afterPlayingDummy1() {
+    // Unschedule any pending 'checking' task:
+    envir().taskScheduler().unscheduleDelayedTask(nextTask());
+    // Signal the event loop that we're done:
+    setDoneFlag();
+}
+
+static void checkForAuxSDPLine(void *clientData) {
+    H265VideoFileServerMediaSubsession *subsess = (H265VideoFileServerMediaSubsession *)clientData;
+    subsess->checkForAuxSDPLine1();
+}
+
+void H265VideoFileServerMediaSubsession::checkForAuxSDPLine1() {
+    nextTask() = NULL;
+
+    char const *dasl;
+    if(fAuxSDPLine != NULL) {
+        // Signal the event loop that we're done:
+        setDoneFlag();
+    }
+    else if(fDummyRTPSink != NULL && (dasl = fDummyRTPSink->auxSDPLine()) != NULL) {
+        fAuxSDPLine   = strDup(dasl);
+        fDummyRTPSink = NULL;
+
+        // Signal the event loop that we're done:
+        setDoneFlag();
+    }
+    else if(!fDoneFlag) {
+        // try again after a brief delay:
+        int uSecsToDelay = 100000;  // 100 ms
+        nextTask()       = envir().taskScheduler().scheduleDelayedTask(uSecsToDelay, (TaskFunc *)checkForAuxSDPLine, this);
+    }
+}
+
+char const *H265VideoFileServerMediaSubsession::getAuxSDPLine(RTPSink *rtpSink, FramedSource *inputSource) {
+    if(fAuxSDPLine != NULL)
+        return fAuxSDPLine;  // it's already been set up (for a previous client)
+
+    if(fDummyRTPSink == NULL) {  // we're not already setting it up for another, concurrent stream
+        // Note: For H265 video files, the 'config' information (used for several payload-format
+        // specific parameters in the SDP description) isn't known until we start reading the file.
+        // This means that "rtpSink"s "auxSDPLine()" will be NULL initially,
+        // and we need to start reading data from our file until this changes.
+        fDummyRTPSink = rtpSink;
+
+        // Start reading the file:
+        fDummyRTPSink->startPlaying(*inputSource, afterPlayingDummy, this);
+
+        // Check whether the sink's 'auxSDPLine()' is ready:
+        checkForAuxSDPLine(this);
+    }
+
+    envir().taskScheduler().doEventLoop(&fDoneFlag);
+
+    return fAuxSDPLine;
+}
+
+FramedSource *H265VideoFileServerMediaSubsession::createNewStreamSource(unsigned /*clientSessionId*/, unsigned &estBitrate) {
+    estBitrate = 500;  // kbps, estimate
+
+    // Create the video source:
+    ByteStreamFileSource *fileSource = ByteStreamFileSource::createNew(envir(), fFileName);
+    if(fileSource == NULL)
+        return NULL;
+    fFileSize = fileSource->fileSize();
+
+    // Create a framer for the Video Elementary Stream:
+    return H265VideoStreamFramer::createNew(envir(), fileSource);
+}
+
+RTPSink *H265VideoFileServerMediaSubsession ::createNewRTPSink(Groupsock *rtpGroupsock, unsigned char rtpPayloadTypeIfDynamic, FramedSource * /*inputSource*/) {
+    return H265VideoRTPSink::createNew(envir(), rtpGroupsock, rtpPayloadTypeIfDynamic);
+}
diff --git a/3rdparty/live555/src/liveMedia/H265VideoFileSink.cpp b/3rdparty/live555/src/liveMedia/H265VideoFileSink.cpp
new file mode 100644
index 00000000..fe065176
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/H265VideoFileSink.cpp
@@ -0,0 +1,54 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// H.265 Video File sinks
+// Implementation
+
+#include "H265VideoFileSink.hh"
+#include "OutputFile.hh"
+
+////////// H265VideoFileSink //////////
+
+H265VideoFileSink ::H265VideoFileSink(UsageEnvironment &env, FILE *fid, char const *sPropVPSStr, char const *sPropSPSStr, char const *sPropPPSStr,
+                                      unsigned bufferSize, char const *perFrameFileNamePrefix)
+    : H264or5VideoFileSink(env, fid, bufferSize, perFrameFileNamePrefix, sPropVPSStr, sPropSPSStr, sPropPPSStr) {}
+
+H265VideoFileSink::~H265VideoFileSink() {}
+
+H265VideoFileSink *H265VideoFileSink::createNew(UsageEnvironment &env, char const *fileName, char const *sPropVPSStr, char const *sPropSPSStr,
+                                                char const *sPropPPSStr, unsigned bufferSize, Boolean oneFilePerFrame) {
+    do {
+        FILE *      fid;
+        char const *perFrameFileNamePrefix;
+        if(oneFilePerFrame) {
+            // Create the fid for each frame
+            fid                    = NULL;
+            perFrameFileNamePrefix = fileName;
+        }
+        else {
+            // Normal case: create the fid once
+            fid = OpenOutputFile(env, fileName);
+            if(fid == NULL)
+                break;
+            perFrameFileNamePrefix = NULL;
+        }
+
+        return new H265VideoFileSink(env, fid, sPropVPSStr, sPropSPSStr, sPropPPSStr, bufferSize, perFrameFileNamePrefix);
+    } while(0);
+
+    return NULL;
+}
diff --git a/3rdparty/live555/src/liveMedia/H265VideoRTPSink.cpp b/3rdparty/live555/src/liveMedia/H265VideoRTPSink.cpp
new file mode 100644
index 00000000..7020841e
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/H265VideoRTPSink.cpp
@@ -0,0 +1,169 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// RTP sink for H.265 video
+// Implementation
+
+#include "H265VideoRTPSink.hh"
+#include "H265VideoStreamFramer.hh"
+#include "Base64.hh"
+#include "BitVector.hh"
+#include "H264VideoRTPSource.hh"  // for "parseSPropParameterSets()"
+
+////////// H265VideoRTPSink implementation //////////
+
+H265VideoRTPSink ::H265VideoRTPSink(UsageEnvironment &env, Groupsock *RTPgs, unsigned char rtpPayloadFormat, u_int8_t const *vps, unsigned vpsSize,
+                                    u_int8_t const *sps, unsigned spsSize, u_int8_t const *pps, unsigned ppsSize)
+    : H264or5VideoRTPSink(265, env, RTPgs, rtpPayloadFormat, vps, vpsSize, sps, spsSize, pps, ppsSize) {}
+
+H265VideoRTPSink::~H265VideoRTPSink() {}
+
+H265VideoRTPSink *H265VideoRTPSink ::createNew(UsageEnvironment &env, Groupsock *RTPgs, unsigned char rtpPayloadFormat) {
+    return new H265VideoRTPSink(env, RTPgs, rtpPayloadFormat);
+}
+
+H265VideoRTPSink *H265VideoRTPSink ::createNew(UsageEnvironment &env, Groupsock *RTPgs, unsigned char rtpPayloadFormat, u_int8_t const *vps, unsigned vpsSize,
+                                               u_int8_t const *sps, unsigned spsSize, u_int8_t const *pps, unsigned ppsSize) {
+    return new H265VideoRTPSink(env, RTPgs, rtpPayloadFormat, vps, vpsSize, sps, spsSize, pps, ppsSize);
+}
+
+H265VideoRTPSink *H265VideoRTPSink ::createNew(UsageEnvironment &env, Groupsock *RTPgs, unsigned char rtpPayloadFormat, char const *sPropVPSStr,
+                                               char const *sPropSPSStr, char const *sPropPPSStr) {
+    u_int8_t *vps     = NULL;
+    unsigned  vpsSize = 0;
+    u_int8_t *sps     = NULL;
+    unsigned  spsSize = 0;
+    u_int8_t *pps     = NULL;
+    unsigned  ppsSize = 0;
+
+    // Parse each 'sProp' string, extracting and then classifying the NAL unit(s) from each one.
+    // We're 'liberal in what we accept'; it's OK if the strings don't contain the NAL unit type
+    // implied by their names (or if one or more of the strings encode multiple NAL units).
+    SPropRecord *sPropRecords[3];
+    unsigned     numSPropRecords[3];
+    sPropRecords[0] = parseSPropParameterSets(sPropVPSStr, numSPropRecords[0]);
+    sPropRecords[1] = parseSPropParameterSets(sPropSPSStr, numSPropRecords[1]);
+    sPropRecords[2] = parseSPropParameterSets(sPropPPSStr, numSPropRecords[2]);
+
+    for(unsigned j = 0; j < 3; ++j) {
+        SPropRecord *records    = sPropRecords[j];
+        unsigned     numRecords = numSPropRecords[j];
+
+        for(unsigned i = 0; i < numRecords; ++i) {
+            if(records[i].sPropLength == 0)
+                continue;  // bad data
+            u_int8_t nal_unit_type = ((records[i].sPropBytes[0]) & 0x7E) >> 1;
+            if(nal_unit_type == 32 /*VPS*/) {
+                vps     = records[i].sPropBytes;
+                vpsSize = records[i].sPropLength;
+            }
+            else if(nal_unit_type == 33 /*SPS*/) {
+                sps     = records[i].sPropBytes;
+                spsSize = records[i].sPropLength;
+            }
+            else if(nal_unit_type == 34 /*PPS*/) {
+                pps     = records[i].sPropBytes;
+                ppsSize = records[i].sPropLength;
+            }
+        }
+    }
+
+    H265VideoRTPSink *result = new H265VideoRTPSink(env, RTPgs, rtpPayloadFormat, vps, vpsSize, sps, spsSize, pps, ppsSize);
+    delete[] sPropRecords[0];
+    delete[] sPropRecords[1];
+    delete[] sPropRecords[2];
+
+    return result;
+}
+
+Boolean H265VideoRTPSink::sourceIsCompatibleWithUs(MediaSource &source) {
+    // Our source must be an appropriate framer:
+    return source.isH265VideoStreamFramer();
+}
+
+char const *H265VideoRTPSink::auxSDPLine() {
+    // Generate a new "a=fmtp:" line each time, using our VPS, SPS and PPS (if we have them),
+    // otherwise parameters from our framer source (in case they've changed since the last time that
+    // we were called):
+    H264or5VideoStreamFramer *framerSource = NULL;
+    u_int8_t *                vps          = fVPS;
+    unsigned                  vpsSize      = fVPSSize;
+    u_int8_t *                sps          = fSPS;
+    unsigned                  spsSize      = fSPSSize;
+    u_int8_t *                pps          = fPPS;
+    unsigned                  ppsSize      = fPPSSize;
+    if(vps == NULL || sps == NULL || pps == NULL) {
+        // We need to get VPS, SPS and PPS from our framer source:
+        if(fOurFragmenter == NULL)
+            return NULL;  // we don't yet have a fragmenter (and therefore not a source)
+        framerSource = (H264or5VideoStreamFramer *)(fOurFragmenter->inputSource());
+        if(framerSource == NULL)
+            return NULL;  // we don't yet have a source
+
+        framerSource->getVPSandSPSandPPS(vps, vpsSize, sps, spsSize, pps, ppsSize);
+        if(vps == NULL || sps == NULL || pps == NULL) {
+            return NULL;  // our source isn't ready
+        }
+    }
+
+    // Set up the "a=fmtp:" SDP line for this stream.
+    u_int8_t *vpsWEB     = new u_int8_t[vpsSize];  // "WEB" means "Without Emulation Bytes"
+    unsigned  vpsWEBSize = removeH264or5EmulationBytes(vpsWEB, vpsSize, vps, vpsSize);
+    if(vpsWEBSize < 6 /*'profile_tier_level' offset*/ + 12 /*num 'profile_tier_level' bytes*/) {
+        // Bad VPS size => assume our source isn't ready
+        delete[] vpsWEB;
+        return NULL;
+    }
+    u_int8_t const *profileTierLevelHeaderBytes = &vpsWEB[6];
+    unsigned        profileSpace                = profileTierLevelHeaderBytes[0] >> 6;          // general_profile_space
+    unsigned        profileId                   = profileTierLevelHeaderBytes[0] & 0x1F;        // general_profile_idc
+    unsigned        tierFlag                    = (profileTierLevelHeaderBytes[0] >> 5) & 0x1;  // general_tier_flag
+    unsigned        levelId                     = profileTierLevelHeaderBytes[11];              // general_level_idc
+    u_int8_t const *interop_constraints         = &profileTierLevelHeaderBytes[5];
+    char            interopConstraintsStr[100];
+    sprintf(interopConstraintsStr, "%02X%02X%02X%02X%02X%02X", interop_constraints[0], interop_constraints[1], interop_constraints[2], interop_constraints[3],
+            interop_constraints[4], interop_constraints[5]);
+    delete[] vpsWEB;
+
+    char *sprop_vps = base64Encode((char *)vps, vpsSize);
+    char *sprop_sps = base64Encode((char *)sps, spsSize);
+    char *sprop_pps = base64Encode((char *)pps, ppsSize);
+
+    char const *fmtpFmt = "a=fmtp:%d profile-space=%u"
+                          ";profile-id=%u"
+                          ";tier-flag=%u"
+                          ";level-id=%u"
+                          ";interop-constraints=%s"
+                          ";sprop-vps=%s"
+                          ";sprop-sps=%s"
+                          ";sprop-pps=%s\r\n";
+    unsigned fmtpFmtSize = strlen(fmtpFmt) + 3 /* max num chars: rtpPayloadType */ + 20 /* max num chars: profile_space */
+                           + 20                                                         /* max num chars: profile_id */
+                           + 20                                                         /* max num chars: tier_flag */
+                           + 20                                                         /* max num chars: level_id */
+                           + strlen(interopConstraintsStr) + strlen(sprop_vps) + strlen(sprop_sps) + strlen(sprop_pps);
+    char *fmtp = new char[fmtpFmtSize];
+    sprintf(fmtp, fmtpFmt, rtpPayloadType(), profileSpace, profileId, tierFlag, levelId, interopConstraintsStr, sprop_vps, sprop_sps, sprop_pps);
+
+    delete[] sprop_vps;
+    delete[] sprop_sps;
+    delete[] sprop_pps;
+
+    delete[] fFmtpSDPLine;
+    fFmtpSDPLine = fmtp;
+    return fFmtpSDPLine;
+}
diff --git a/3rdparty/live555/src/liveMedia/H265VideoRTPSource.cpp b/3rdparty/live555/src/liveMedia/H265VideoRTPSource.cpp
new file mode 100644
index 00000000..25e173b9
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/H265VideoRTPSource.cpp
@@ -0,0 +1,213 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// H.265 Video RTP Sources
+// Implementation
+
+#include "H265VideoRTPSource.hh"
+
+////////// H265BufferedPacket and H265BufferedPacketFactory //////////
+
+class H265BufferedPacket : public BufferedPacket {
+public:
+    H265BufferedPacket(H265VideoRTPSource &ourSource);
+    virtual ~H265BufferedPacket();
+
+private:  // redefined virtual functions
+    virtual unsigned nextEnclosedFrameSize(unsigned char *&framePtr, unsigned dataSize);
+
+private:
+    H265VideoRTPSource &fOurSource;
+};
+
+class H265BufferedPacketFactory : public BufferedPacketFactory {
+private:  // redefined virtual functions
+    virtual BufferedPacket *createNewPacket(MultiFramedRTPSource *ourSource);
+};
+
+///////// H265VideoRTPSource implementation ////////
+
+H265VideoRTPSource *H265VideoRTPSource::createNew(UsageEnvironment &env, Groupsock *RTPgs, unsigned char rtpPayloadFormat, Boolean expectDONFields,
+                                                  unsigned rtpTimestampFrequency) {
+    return new H265VideoRTPSource(env, RTPgs, rtpPayloadFormat, expectDONFields, rtpTimestampFrequency);
+}
+
+H265VideoRTPSource ::H265VideoRTPSource(UsageEnvironment &env, Groupsock *RTPgs, unsigned char rtpPayloadFormat, Boolean expectDONFields,
+                                        unsigned rtpTimestampFrequency)
+    : MultiFramedRTPSource(env, RTPgs, rtpPayloadFormat, rtpTimestampFrequency, new H265BufferedPacketFactory),
+      fExpectDONFields(expectDONFields),
+      fPreviousNALUnitDON(0),
+      fCurrentNALUnitAbsDon((u_int64_t)(~0)) {}
+
+H265VideoRTPSource::~H265VideoRTPSource() {}
+
+Boolean H265VideoRTPSource ::processSpecialHeader(BufferedPacket *packet, unsigned &resultSpecialHeaderSize) {
+    unsigned char *headerStart = packet->data();
+    unsigned       packetSize  = packet->dataSize();
+    u_int16_t      DONL        = 0;
+    unsigned       numBytesToSkip;
+
+    // Check the Payload Header's 'nal_unit_type' for special aggregation or fragmentation packets:
+    if(packetSize < 2)
+        return False;
+    fCurPacketNALUnitType = (headerStart[0] & 0x7E) >> 1;
+    switch(fCurPacketNALUnitType) {
+    case 48: {  // Aggregation Packet (AP)
+        // We skip over the 2-byte Payload Header, and the DONL header (if any).
+        if(fExpectDONFields) {
+            if(packetSize < 4)
+                return False;
+            DONL           = (headerStart[2] << 8) | headerStart[3];
+            numBytesToSkip = 4;
+        }
+        else {
+            numBytesToSkip = 2;
+        }
+        break;
+    }
+    case 49: {  // Fragmentation Unit (FU)
+        // This NALU begins with the 2-byte Payload Header, the 1-byte FU header, and (optionally)
+        // the 2-byte DONL header.
+        // If the start bit is set, we reconstruct the original NAL header at the end of these
+        // 3 (or 5) bytes, and skip over the first 1 (or 3) bytes.
+        if(packetSize < 3)
+            return False;
+        u_int8_t startBit = headerStart[2] & 0x80;  // from the FU header
+        u_int8_t endBit   = headerStart[2] & 0x40;  // from the FU header
+        if(startBit) {
+            fCurrentPacketBeginsFrame = True;
+
+            u_int8_t nal_unit_type = headerStart[2] & 0x3F;  // the last 6 bits of the FU header
+            u_int8_t newNALHeader[2];
+            newNALHeader[0] = (headerStart[0] & 0x81) | (nal_unit_type << 1);
+            newNALHeader[1] = headerStart[1];
+
+            if(fExpectDONFields) {
+                if(packetSize < 5)
+                    return False;
+                DONL           = (headerStart[3] << 8) | headerStart[4];
+                headerStart[3] = newNALHeader[0];
+                headerStart[4] = newNALHeader[1];
+                numBytesToSkip = 3;
+            }
+            else {
+                headerStart[1] = newNALHeader[0];
+                headerStart[2] = newNALHeader[1];
+                numBytesToSkip = 1;
+            }
+        }
+        else {
+            // The start bit is not set, so we skip over all headers:
+            fCurrentPacketBeginsFrame = False;
+            if(fExpectDONFields) {
+                if(packetSize < 5)
+                    return False;
+                DONL           = (headerStart[3] << 8) | headerStart[4];
+                numBytesToSkip = 5;
+            }
+            else {
+                numBytesToSkip = 3;
+            }
+        }
+        fCurrentPacketCompletesFrame = (endBit != 0);
+        break;
+    }
+    default: {
+        // This packet contains one complete NAL unit:
+        fCurrentPacketBeginsFrame = fCurrentPacketCompletesFrame = True;
+        numBytesToSkip                                           = 0;
+        break;
+    }
+    }
+
+    computeAbsDonFromDON(DONL);
+    resultSpecialHeaderSize = numBytesToSkip;
+    return True;
+}
+
+char const *H265VideoRTPSource::MIMEtype() const {
+    return "video/H265";
+}
+
+void H265VideoRTPSource::computeAbsDonFromDON(u_int16_t DON) {
+    if(!fExpectDONFields) {
+        // Without DON fields in the input stream, we just increment our "AbsDon" count each time:
+        ++fCurrentNALUnitAbsDon;
+    }
+    else {
+        if(fCurrentNALUnitAbsDon == (u_int64_t)(~0)) {
+            // This is the very first NAL unit, so "AbsDon" is just "DON":
+            fCurrentNALUnitAbsDon = (u_int64_t)DON;
+        }
+        else {
+            // Use the previous NAL unit's DON and the current DON to compute "AbsDon":
+            //     AbsDon[n] = AbsDon[n-1] + (DON[n] - DON[n-1]) mod 2^16
+            short   signedDiff16 = (short)(DON - fPreviousNALUnitDON);
+            int64_t signedDiff64 = (int64_t)signedDiff16;
+            fCurrentNALUnitAbsDon += signedDiff64;
+        }
+
+        fPreviousNALUnitDON = DON;  // for next time
+    }
+}
+
+////////// H265BufferedPacket and H265BufferedPacketFactory implementation //////////
+
+H265BufferedPacket::H265BufferedPacket(H265VideoRTPSource &ourSource) : fOurSource(ourSource) {}
+
+H265BufferedPacket::~H265BufferedPacket() {}
+
+unsigned H265BufferedPacket ::nextEnclosedFrameSize(unsigned char *&framePtr, unsigned dataSize) {
+    unsigned resultNALUSize = 0;  // if an error occurs
+
+    switch(fOurSource.fCurPacketNALUnitType) {
+    case 48: {  // Aggregation Packet (AP)
+        if(useCount() > 0) {
+            // We're other than the first NAL unit inside this Aggregation Packet.
+            // Update our 'decoding order number':
+            u_int16_t DONL = 0;
+            if(fOurSource.fExpectDONFields) {
+                // There's a 1-byte DOND field next:
+                if(dataSize < 1)
+                    break;
+                u_int8_t DOND = framePtr[0];
+                DONL          = fOurSource.fPreviousNALUnitDON + (u_int16_t)(DOND + 1);
+                ++framePtr;
+                --dataSize;
+            }
+            fOurSource.computeAbsDonFromDON(DONL);
+        }
+
+        // The next 2 bytes are the NAL unit size:
+        if(dataSize < 2)
+            break;
+        resultNALUSize = (framePtr[0] << 8) | framePtr[1];
+        framePtr += 2;
+        break;
+    }
+    default: {
+        // Common case: We use the entire packet data:
+        return dataSize;
+    }
+    }
+
+    return (resultNALUSize <= dataSize) ? resultNALUSize : dataSize;
+}
+
+BufferedPacket *H265BufferedPacketFactory ::createNewPacket(MultiFramedRTPSource *ourSource) {
+    return new H265BufferedPacket((H265VideoRTPSource &)(*ourSource));
+}
diff --git a/3rdparty/live555/src/liveMedia/H265VideoStreamDiscreteFramer.cpp b/3rdparty/live555/src/liveMedia/H265VideoStreamDiscreteFramer.cpp
new file mode 100644
index 00000000..53bc76c2
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/H265VideoStreamDiscreteFramer.cpp
@@ -0,0 +1,39 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A simplified version of "H265VideoStreamFramer" that takes only complete,
+// discrete frames (rather than an arbitrary byte stream) as input.
+// This avoids the parsing and data copying overhead of the full
+// "H265VideoStreamFramer".
+// Implementation
+
+#include "H265VideoStreamDiscreteFramer.hh"
+
+H265VideoStreamDiscreteFramer *H265VideoStreamDiscreteFramer ::createNew(UsageEnvironment &env, FramedSource *inputSource, Boolean includeStartCodeInOutput,
+                                                                         Boolean insertAccessUnitDelimiters) {
+    return new H265VideoStreamDiscreteFramer(env, inputSource, includeStartCodeInOutput, insertAccessUnitDelimiters);
+}
+
+H265VideoStreamDiscreteFramer ::H265VideoStreamDiscreteFramer(UsageEnvironment &env, FramedSource *inputSource, Boolean includeStartCodeInOutput,
+                                                              Boolean insertAccessUnitDelimiters)
+    : H264or5VideoStreamDiscreteFramer(265, env, inputSource, includeStartCodeInOutput, insertAccessUnitDelimiters) {}
+
+H265VideoStreamDiscreteFramer::~H265VideoStreamDiscreteFramer() {}
+
+Boolean H265VideoStreamDiscreteFramer::isH265VideoStreamFramer() const {
+    return True;
+}
diff --git a/3rdparty/live555/src/liveMedia/H265VideoStreamFramer.cpp b/3rdparty/live555/src/liveMedia/H265VideoStreamFramer.cpp
new file mode 100644
index 00000000..9c1ec7e0
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/H265VideoStreamFramer.cpp
@@ -0,0 +1,36 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A filter that breaks up a H.265 Video Elementary Stream into NAL units.
+// Implementation
+
+#include "H265VideoStreamFramer.hh"
+
+H265VideoStreamFramer *H265VideoStreamFramer ::createNew(UsageEnvironment &env, FramedSource *inputSource, Boolean includeStartCodeInOutput,
+                                                         Boolean insertAccessUnitDelimiters) {
+    return new H265VideoStreamFramer(env, inputSource, True, includeStartCodeInOutput, insertAccessUnitDelimiters);
+}
+
+H265VideoStreamFramer ::H265VideoStreamFramer(UsageEnvironment &env, FramedSource *inputSource, Boolean createParser, Boolean includeStartCodeInOutput,
+                                              Boolean insertAccessUnitDelimiters)
+    : H264or5VideoStreamFramer(265, env, inputSource, createParser, includeStartCodeInOutput, insertAccessUnitDelimiters) {}
+
+H265VideoStreamFramer::~H265VideoStreamFramer() {}
+
+Boolean H265VideoStreamFramer::isH265VideoStreamFramer() const {
+    return True;
+}
diff --git a/3rdparty/live555/src/liveMedia/HLSSegmenter.cpp b/3rdparty/live555/src/liveMedia/HLSSegmenter.cpp
new file mode 100644
index 00000000..715a9c33
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/HLSSegmenter.cpp
@@ -0,0 +1,139 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A media sink that takes - as input - a MPEG Transport Stream, and outputs a series
+// of MPEG Transport Stream files, each representing a segment of the input stream,
+// suitable for HLS (Apple's "HTTP Live Streaming").
+// Implementation
+
+#include "HLSSegmenter.hh"
+#include "OutputFile.hh"
+#include "MPEG2TransportStreamMultiplexor.hh"
+
+#define TRANSPORT_PACKET_SIZE 188
+#define OUTPUT_FILE_BUFFER_SIZE (TRANSPORT_PACKET_SIZE * 100)
+
+HLSSegmenter *HLSSegmenter ::createNew(UsageEnvironment &env, unsigned segmentationDuration, char const *fileNamePrefix, onEndOfSegmentFunc *onEndOfSegmentFunc,
+                                       void *onEndOfSegmentClientData) {
+    return new HLSSegmenter(env, segmentationDuration, fileNamePrefix, onEndOfSegmentFunc, onEndOfSegmentClientData);
+}
+
+HLSSegmenter::HLSSegmenter(UsageEnvironment &env, unsigned segmentationDuration, char const *fileNamePrefix, onEndOfSegmentFunc *onEndOfSegmentFunc,
+                           void *onEndOfSegmentClientData)
+    : MediaSink(env),
+      fSegmentationDuration(segmentationDuration),
+      fFileNamePrefix(fileNamePrefix),
+      fOnEndOfSegmentFunc(onEndOfSegmentFunc),
+      fOnEndOfSegmentClientData(onEndOfSegmentClientData),
+      fHaveConfiguredUpstreamSource(False),
+      fCurrentSegmentCounter(1),
+      fOutFid(NULL) {
+    // Allocate enough space for the segment file name:
+    fOutputSegmentFileName = new char[strlen(fileNamePrefix) + 20 /*more than enough*/];
+
+    // Allocate the output file buffer size:
+    fOutputFileBuffer = new unsigned char[OUTPUT_FILE_BUFFER_SIZE];
+}
+HLSSegmenter::~HLSSegmenter() {
+    delete[] fOutputFileBuffer;
+    delete[] fOutputSegmentFileName;
+}
+
+void HLSSegmenter::ourEndOfSegmentHandler(void *clientData, double segmentDuration) {
+    ((HLSSegmenter *)clientData)->ourEndOfSegmentHandler(segmentDuration);
+}
+
+void HLSSegmenter::ourEndOfSegmentHandler(double segmentDuration) {
+    // Note the end of the current segment:
+    if(fOnEndOfSegmentFunc != NULL) {
+        (*fOnEndOfSegmentFunc)(fOnEndOfSegmentClientData, fOutputSegmentFileName, segmentDuration);
+    }
+
+    // Begin the next segment:
+    ++fCurrentSegmentCounter;
+    openNextOutputSegment();
+}
+
+Boolean HLSSegmenter::openNextOutputSegment() {
+    CloseOutputFile(fOutFid);
+
+    sprintf(fOutputSegmentFileName, "%s%03u.ts", fFileNamePrefix, fCurrentSegmentCounter);
+    fOutFid = OpenOutputFile(envir(), fOutputSegmentFileName);
+
+    return fOutFid != NULL;
+}
+
+void HLSSegmenter::afterGettingFrame(void *clientData, unsigned frameSize, unsigned numTruncatedBytes, struct timeval /*presentationTime*/,
+                                     unsigned /*durationInMicroseconds*/) {
+    ((HLSSegmenter *)clientData)->afterGettingFrame(frameSize, numTruncatedBytes);
+}
+
+void HLSSegmenter::afterGettingFrame(unsigned frameSize, unsigned numTruncatedBytes) {
+    if(numTruncatedBytes > 0) {  // Shouldn't happen
+        fprintf(stderr, "HLSSegmenter::afterGettingFrame(frameSize %d, numTruncatedBytes %d)\n", frameSize, numTruncatedBytes);
+    }
+
+    // Write the data to our output segment file:
+    fwrite(fOutputFileBuffer, 1, frameSize, fOutFid);
+
+    // Then try getting the next frame:
+    continuePlaying();
+}
+
+void HLSSegmenter::ourOnSourceClosure(void *clientData) {
+    ((HLSSegmenter *)clientData)->ourOnSourceClosure();
+}
+
+void HLSSegmenter::ourOnSourceClosure() {
+    // Note the end of the final segment (currently being written):
+    if(fOnEndOfSegmentFunc != NULL) {
+        // We know that the source is a "MPEG2TransportStreamMultiplexor":
+        MPEG2TransportStreamMultiplexor *multiplexorSource = (MPEG2TransportStreamMultiplexor *)fSource;
+        double                           segmentDuration   = multiplexorSource->currentSegmentDuration();
+
+        (*fOnEndOfSegmentFunc)(fOnEndOfSegmentClientData, fOutputSegmentFileName, segmentDuration);
+    }
+
+    // Handle the closure for real:
+    onSourceClosure();
+}
+
+Boolean HLSSegmenter::sourceIsCompatibleWithUs(MediaSource &source) {
+    // Our source must be a Transport Stream Multiplexor:
+    return source.isMPEG2TransportStreamMultiplexor();
+}
+
+Boolean HLSSegmenter::continuePlaying() {
+    if(fSource == NULL)
+        return False;
+    if(!fHaveConfiguredUpstreamSource) {
+        // We know that the source is a "MPEG2TransportStreamMultiplexor":
+        MPEG2TransportStreamMultiplexor *multiplexorSource = (MPEG2TransportStreamMultiplexor *)fSource;
+
+        // Tell our upstream multiplexor to call our 'end of segment handler' at the end of
+        // each timed segment:
+        multiplexorSource->setTimedSegmentation(fSegmentationDuration, ourEndOfSegmentHandler, this);
+
+        fHaveConfiguredUpstreamSource = True;  // from now on
+    }
+    if(fOutFid == NULL && !openNextOutputSegment())
+        return False;
+
+    fSource->getNextFrame(fOutputFileBuffer, OUTPUT_FILE_BUFFER_SIZE, afterGettingFrame, this, ourOnSourceClosure, this);
+
+    return True;
+}
diff --git a/3rdparty/live555/src/liveMedia/HMAC_SHA1.cpp b/3rdparty/live555/src/liveMedia/HMAC_SHA1.cpp
new file mode 100644
index 00000000..c38871eb
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/HMAC_SHA1.cpp
@@ -0,0 +1,79 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022, Live Networks, Inc.  All rights reserved
+//
+// A function for computing the HMAC_SHA1 digest
+// Implementation
+
+#include "HMAC_SHA1.hh"
+
+#ifndef NO_OPENSSL
+#if defined(__APPLE__)
+#define COMMON_DIGEST_FOR_OPENSSL
+#include <CommonCrypto/CommonDigest.h>
+#endif
+#include <openssl/evp.h>
+
+////////// HMAC_SHA1 implementation //////////
+
+static void sha1(u_int8_t *resultDigest /*must be SHA1_DIGEST_LEN bytes in size*/, u_int8_t const *data1, unsigned data1Length, u_int8_t const *data2 = NULL,
+                 unsigned data2Length = 0) {
+    EVP_MD_CTX *ctx = EVP_MD_CTX_create();
+    EVP_DigestInit(ctx, EVP_sha1());
+    EVP_DigestUpdate(ctx, data1, data1Length);
+    if(data2 != NULL) {
+        EVP_DigestUpdate(ctx, data2, data2Length);
+    }
+    EVP_DigestFinal(ctx, resultDigest, NULL);
+    EVP_MD_CTX_destroy(ctx);
+}
+
+void HMAC_SHA1(u_int8_t const *key, unsigned keyLength, u_int8_t const *text, unsigned textLength,
+               u_int8_t *resultDigest /*must be SHA1_DIGEST_LEN bytes in size*/) {
+    if(key == NULL || keyLength == 0 || text == NULL || textLength == 0 || resultDigest == NULL) {
+        return;  // sanity check
+    }
+
+    // If the key is longer than the block size, hash it to make it smaller:
+    u_int8_t tmpDigest[SHA1_DIGEST_LEN];
+    if(keyLength > HMAC_BLOCK_SIZE) {
+        sha1(tmpDigest, key, keyLength);
+        key       = tmpDigest;
+        keyLength = SHA1_DIGEST_LEN;
+    }
+    // Assert: keyLength <= HMAC_BLOCK_SIZE
+
+    // Initialize the inner and outer pads with the key:
+    u_int8_t ipad[HMAC_BLOCK_SIZE];
+    u_int8_t opad[HMAC_BLOCK_SIZE];
+    unsigned i;
+    for(i = 0; i < keyLength; ++i) {
+        ipad[i] = key[i] ^ 0x36;
+        opad[i] = key[i] ^ 0x5c;
+    }
+    for(; i < HMAC_BLOCK_SIZE; ++i) {
+        ipad[i] = 0x36;
+        opad[i] = 0x5c;
+    }
+
+    // Perform the inner hash:
+    sha1(tmpDigest, ipad, HMAC_BLOCK_SIZE, text, textLength);
+
+    // Perform the outer hash:
+    sha1(resultDigest, opad, HMAC_BLOCK_SIZE, tmpDigest, SHA1_DIGEST_LEN);
+}
+#endif
diff --git a/3rdparty/live555/src/liveMedia/InputFile.cpp b/3rdparty/live555/src/liveMedia/InputFile.cpp
new file mode 100644
index 00000000..05a46c54
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/InputFile.cpp
@@ -0,0 +1,118 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// Common routines for opening/closing named input files
+// Implementation
+
+#include "InputFile.hh"
+#include <string.h>
+
+FILE *OpenInputFile(UsageEnvironment &env, char const *fileName) {
+    FILE *fid;
+
+    // Check for a special case file name: "stdin"
+    if(strcmp(fileName, "stdin") == 0) {
+        fid = stdin;
+#if(defined(__WIN32__) || defined(_WIN32)) && !defined(_WIN32_WCE)
+        _setmode(_fileno(stdin), _O_BINARY);  // convert to binary mode
+#endif
+    }
+    else {
+        fid = fopen(fileName, "rb");
+        if(fid == NULL) {
+            env.setResultMsg("unable to open file \"", fileName, "\"");
+        }
+    }
+
+    return fid;
+}
+
+void CloseInputFile(FILE *fid) {
+    // Don't close 'stdin', in case we want to use it again later.
+    if(fid != NULL && fid != stdin)
+        fclose(fid);
+}
+
+u_int64_t GetFileSize(char const *fileName, FILE *fid) {
+    u_int64_t fileSize = 0;  // by default
+
+    if(fid != stdin) {
+#if !defined(_WIN32_WCE)
+        if(fileName == NULL) {
+#endif
+            if(fid != NULL && SeekFile64(fid, 0, SEEK_END) >= 0) {
+                fileSize = (u_int64_t)TellFile64(fid);
+                if(fileSize == (u_int64_t)-1)
+                    fileSize = 0;  // TellFile64() failed
+                SeekFile64(fid, 0, SEEK_SET);
+            }
+#if !defined(_WIN32_WCE)
+        }
+        else {
+            struct stat sb;
+            if(stat(fileName, &sb) == 0) {
+                fileSize = sb.st_size;
+            }
+        }
+#endif
+    }
+
+    return fileSize;
+}
+
+int64_t SeekFile64(FILE *fid, int64_t offset, int whence) {
+    if(fid == NULL)
+        return -1;
+
+    clearerr(fid);
+    fflush(fid);
+#if(defined(__WIN32__) || defined(_WIN32)) && !defined(_WIN32_WCE)
+    return _lseeki64(_fileno(fid), offset, whence) == (int64_t)-1 ? -1 : 0;
+#else
+#if defined(_WIN32_WCE)
+    return fseek(fid, (long)(offset), whence);
+#else
+    return fseeko(fid, (off_t)(offset), whence);
+#endif
+#endif
+}
+
+int64_t TellFile64(FILE *fid) {
+    if(fid == NULL)
+        return -1;
+
+    clearerr(fid);
+    fflush(fid);
+#if(defined(__WIN32__) || defined(_WIN32)) && !defined(_WIN32_WCE)
+    return _telli64(_fileno(fid));
+#else
+#if defined(_WIN32_WCE)
+    return ftell(fid);
+#else
+    return ftello(fid);
+#endif
+#endif
+}
+
+Boolean FileIsSeekable(FILE *fid) {
+    if(SeekFile64(fid, 1, SEEK_CUR) < 0) {
+        return False;
+    }
+
+    SeekFile64(fid, -1, SEEK_CUR);  // seek back to where we were
+    return True;
+}
diff --git a/3rdparty/live555/src/liveMedia/JPEG2000VideoRTPSink.cpp b/3rdparty/live555/src/liveMedia/JPEG2000VideoRTPSink.cpp
new file mode 100644
index 00000000..6131fbd9
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/JPEG2000VideoRTPSink.cpp
@@ -0,0 +1,72 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+
+#include "JPEG2000VideoRTPSink.hh"
+
+JPEG2000VideoRTPSink::JPEG2000VideoRTPSink(UsageEnvironment &env, Groupsock *RTPgs) : VideoRTPSink(env, RTPgs, 98, 90000, "jpeg2000") {}
+
+JPEG2000VideoRTPSink::~JPEG2000VideoRTPSink() {}
+
+JPEG2000VideoRTPSink *JPEG2000VideoRTPSink::createNew(UsageEnvironment &env, Groupsock *RTPgs) {
+    return new JPEG2000VideoRTPSink(env, RTPgs);
+}
+
+#define JPEG2000_PAYLOAD_HEADER_SIZE 8
+
+void JPEG2000VideoRTPSink ::doSpecialFrameHandling(unsigned fragmentationOffset, unsigned char *frameStart, unsigned numBytesInFrame,
+                                                   struct timeval framePresentationTime, unsigned numRemainingBytes) {
+    // Fill in the Payload Header:
+    u_int8_t payloadHeader[JPEG2000_PAYLOAD_HEADER_SIZE];
+
+    // For "tp", assume for now that the payload is progressively scanned (i.e., tp = 0)
+    // For "MHF", assume that a whole main header is present (i.e., MHF = 3), *unless* we're
+    //   the second or later packet of a fragment, in which case we assume that it's not (i.e. MHF = 0)
+    // For "mh_id", set this to 0 (as specified in RFC 5371).
+    // For "T" (Tile field invalidation flag), set this to 0 (we don't set the "tile number" field).
+    payloadHeader[0] = fragmentationOffset > 0 ? 0x00 : 0x30;
+
+    // Set the "priority" field to 255, as specified in RFC 5371:
+    payloadHeader[1] = 255;
+
+    // Set the "tile number" field to 0:
+    payloadHeader[2] = payloadHeader[3] = 0;
+
+    // Set the "reserved" field to 0, as specified in RFC 5371:
+    payloadHeader[4] = 0;
+
+    // Set the "fragmentation offset" field to the value of our "fragmentationOffset" parameter:
+    payloadHeader[5] = (u_int8_t)(fragmentationOffset >> 16);
+    payloadHeader[6] = (u_int8_t)(fragmentationOffset >> 8);
+    payloadHeader[7] = (u_int8_t)(fragmentationOffset);
+
+    // Write the payload header to the outgoing packet:
+    setSpecialHeaderBytes(payloadHeader, sizeof payloadHeader);
+
+    if(numRemainingBytes == 0) {
+        // This packet contains the last (or only) fragment of the frame.
+        // Set the RTP 'M' ('marker') bit
+        setMarkerBit();
+    }
+
+    // Also set the RTP timestamp:
+    setTimestamp(framePresentationTime);
+}
+
+unsigned JPEG2000VideoRTPSink::specialHeaderSize() const {
+    return JPEG2000_PAYLOAD_HEADER_SIZE;
+}
diff --git a/3rdparty/live555/src/liveMedia/JPEG2000VideoRTPSource.cpp b/3rdparty/live555/src/liveMedia/JPEG2000VideoRTPSource.cpp
new file mode 100644
index 00000000..a4ea57c6
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/JPEG2000VideoRTPSource.cpp
@@ -0,0 +1,56 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+
+#include "JPEG2000VideoRTPSource.hh"
+
+JPEG2000VideoRTPSource *JPEG2000VideoRTPSource::createNew(UsageEnvironment &env, Groupsock *RTPgs, unsigned char rtpPayloadFormat,
+                                                          unsigned rtpTimestampFrequency, char const *sampling) {
+    return new JPEG2000VideoRTPSource(env, RTPgs, rtpPayloadFormat, rtpTimestampFrequency, sampling);
+}
+
+JPEG2000VideoRTPSource ::JPEG2000VideoRTPSource(UsageEnvironment &env, Groupsock *RTPgs, unsigned char rtpPayloadFormat, unsigned rtpTimestampFrequency,
+                                                char const *sampling)
+    : MultiFramedRTPSource(env, RTPgs, rtpPayloadFormat, rtpTimestampFrequency) {
+    fSampling = strDup(sampling);
+}
+
+JPEG2000VideoRTPSource::~JPEG2000VideoRTPSource() {
+    delete[] fSampling;
+}
+
+#define JPEG2000_PAYLOAD_HEADER_SIZE 8
+
+Boolean JPEG2000VideoRTPSource ::processSpecialHeader(BufferedPacket *packet, unsigned &resultSpecialHeaderSize) {
+    unsigned char *headerStart = packet->data();
+    unsigned       packetSize  = packet->dataSize();
+
+    // There should be enough space for a payload header:
+    if(packetSize < JPEG2000_PAYLOAD_HEADER_SIZE)
+        return False;
+
+    u_int32_t fragmentOffset     = (headerStart[5] << 16) | (headerStart[6] << 8) | (headerStart[7]);
+    fCurrentPacketBeginsFrame    = fragmentOffset == 0;
+    fCurrentPacketCompletesFrame = packet->rtpMarkerBit();
+
+    resultSpecialHeaderSize = JPEG2000_PAYLOAD_HEADER_SIZE;
+    return True;
+}
+
+char const *JPEG2000VideoRTPSource::MIMEtype() const {
+    return "video/JPEG2000";
+}
diff --git a/3rdparty/live555/src/liveMedia/JPEGVideoRTPSink.cpp b/3rdparty/live555/src/liveMedia/JPEGVideoRTPSink.cpp
new file mode 100644
index 00000000..9fc627d8
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/JPEGVideoRTPSink.cpp
@@ -0,0 +1,132 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// RTP sink for JPEG video (RFC 2435)
+// Implementation
+
+#include "JPEGVideoRTPSink.hh"
+#include "JPEGVideoSource.hh"
+
+JPEGVideoRTPSink ::JPEGVideoRTPSink(UsageEnvironment &env, Groupsock *RTPgs) : VideoRTPSink(env, RTPgs, 26, 90000, "JPEG") {}
+
+JPEGVideoRTPSink::~JPEGVideoRTPSink() {}
+
+JPEGVideoRTPSink *JPEGVideoRTPSink::createNew(UsageEnvironment &env, Groupsock *RTPgs) {
+    return new JPEGVideoRTPSink(env, RTPgs);
+}
+
+Boolean JPEGVideoRTPSink::sourceIsCompatibleWithUs(MediaSource &source) {
+    return source.isJPEGVideoSource();
+}
+
+Boolean JPEGVideoRTPSink ::frameCanAppearAfterPacketStart(unsigned char const * /*frameStart*/, unsigned /*numBytesInFrame*/) const {
+    // A packet can contain only one frame
+    return False;
+}
+
+void JPEGVideoRTPSink ::doSpecialFrameHandling(unsigned       fragmentationOffset, unsigned char * /*frameStart*/, unsigned /*numBytesInFrame*/,
+                                               struct timeval framePresentationTime, unsigned numRemainingBytes) {
+    // Our source is known to be a JPEGVideoSource
+    JPEGVideoSource *source = (JPEGVideoSource *)fSource;
+    if(source == NULL)
+        return;  // sanity check
+
+    u_int8_t       mainJPEGHeader[8];  // the special header
+    u_int8_t const type = source->type();
+
+    mainJPEGHeader[0] = 0;  // Type-specific
+    mainJPEGHeader[1] = fragmentationOffset >> 16;
+    mainJPEGHeader[2] = fragmentationOffset >> 8;
+    mainJPEGHeader[3] = fragmentationOffset;
+    mainJPEGHeader[4] = type;
+    mainJPEGHeader[5] = source->qFactor();
+    mainJPEGHeader[6] = source->width();
+    mainJPEGHeader[7] = source->height();
+    setSpecialHeaderBytes(mainJPEGHeader, sizeof mainJPEGHeader);
+
+    unsigned restartMarkerHeaderSize = 0;  // by default
+    if(type >= 64 && type <= 127) {
+        // There is also a Restart Marker Header:
+        restartMarkerHeaderSize         = 4;
+        u_int16_t const restartInterval = source->restartInterval();  // should be non-zero
+
+        u_int8_t restartMarkerHeader[4];
+        restartMarkerHeader[0] = restartInterval >> 8;
+        restartMarkerHeader[1] = restartInterval & 0xFF;
+        restartMarkerHeader[2] = restartMarkerHeader[3] = 0xFF;  // F=L=1; Restart Count = 0x3FFF
+
+        setSpecialHeaderBytes(restartMarkerHeader, restartMarkerHeaderSize, sizeof mainJPEGHeader /* start position */);
+    }
+
+    if(fragmentationOffset == 0 && source->qFactor() >= 128) {
+        // There is also a Quantization Header:
+        u_int8_t        precision;
+        u_int16_t       length;
+        u_int8_t const *quantizationTables = source->quantizationTables(precision, length);
+
+        unsigned const quantizationHeaderSize = 4 + length;
+        u_int8_t *     quantizationHeader     = new u_int8_t[quantizationHeaderSize];
+
+        quantizationHeader[0] = 0;  // MBZ
+        quantizationHeader[1] = precision;
+        quantizationHeader[2] = length >> 8;
+        quantizationHeader[3] = length & 0xFF;
+        if(quantizationTables != NULL) {  // sanity check
+            for(u_int16_t i = 0; i < length; ++i) {
+                quantizationHeader[4 + i] = quantizationTables[i];
+            }
+        }
+
+        setSpecialHeaderBytes(quantizationHeader, quantizationHeaderSize, sizeof mainJPEGHeader + restartMarkerHeaderSize /* start position */);
+        delete[] quantizationHeader;
+    }
+
+    if(numRemainingBytes == 0) {
+        // This packet contains the last (or only) fragment of the frame.
+        // Set the RTP 'M' ('marker') bit:
+        setMarkerBit();
+    }
+
+    // Also set the RTP timestamp:
+    setTimestamp(framePresentationTime);
+}
+
+unsigned JPEGVideoRTPSink::specialHeaderSize() const {
+    // Our source is known to be a JPEGVideoSource
+    JPEGVideoSource *source = (JPEGVideoSource *)fSource;
+    if(source == NULL)
+        return 0;  // sanity check
+
+    unsigned headerSize = 8;  // by default
+
+    u_int8_t const type = source->type();
+    if(type >= 64 && type <= 127) {
+        // There is also a Restart Marker Header:
+        headerSize += 4;
+    }
+
+    if(curFragmentationOffset() == 0 && source->qFactor() >= 128) {
+        // There is also a Quantization Header:
+        u_int8_t  dummy;
+        u_int16_t quantizationTablesSize;
+        (void)(source->quantizationTables(dummy, quantizationTablesSize));
+
+        headerSize += 4 + quantizationTablesSize;
+    }
+
+    return headerSize;
+}
diff --git a/3rdparty/live555/src/liveMedia/JPEGVideoRTPSource.cpp b/3rdparty/live555/src/liveMedia/JPEGVideoRTPSource.cpp
new file mode 100644
index 00000000..8fa8b427
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/JPEGVideoRTPSource.cpp
@@ -0,0 +1,431 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// JPEG Video (RFC 2435) RTP Sources
+// Implementation
+
+#include "JPEGVideoRTPSource.hh"
+
+////////// JPEGBufferedPacket and JPEGBufferedPacketFactory //////////
+
+class JPEGBufferedPacket : public BufferedPacket {
+public:
+    Boolean completesFrame;
+
+private:
+    // Redefined virtual functions:
+    virtual void     reset();
+    virtual unsigned nextEnclosedFrameSize(unsigned char *&framePtr, unsigned dataSize);
+};
+
+class JPEGBufferedPacketFactory : public BufferedPacketFactory {
+private:  // redefined virtual functions
+    virtual BufferedPacket *createNewPacket(MultiFramedRTPSource *ourSource);
+};
+
+////////// JPEGVideoRTPSource implementation //////////
+
+#define BYTE unsigned char
+#define WORD unsigned
+#define DWORD unsigned long
+
+JPEGVideoRTPSource *JPEGVideoRTPSource::createNew(UsageEnvironment &env, Groupsock *RTPgs, unsigned char rtpPayloadFormat, unsigned rtpTimestampFrequency,
+                                                  unsigned defaultWidth, unsigned defaultHeight) {
+    return new JPEGVideoRTPSource(env, RTPgs, rtpPayloadFormat, rtpTimestampFrequency, defaultWidth, defaultHeight);
+}
+
+JPEGVideoRTPSource::JPEGVideoRTPSource(UsageEnvironment &env, Groupsock *RTPgs, unsigned char rtpPayloadFormat, unsigned rtpTimestampFrequency,
+                                       unsigned defaultWidth, unsigned defaultHeight)
+    : MultiFramedRTPSource(env, RTPgs, rtpPayloadFormat, rtpTimestampFrequency, new JPEGBufferedPacketFactory),
+      fDefaultWidth(defaultWidth),
+      fDefaultHeight(defaultHeight) {}
+
+JPEGVideoRTPSource::~JPEGVideoRTPSource() {}
+
+enum {
+    MARKER_SOF0      = 0xc0,  // start-of-frame, baseline scan
+    MARKER_SOI       = 0xd8,  // start of image
+    MARKER_EOI       = 0xd9,  // end of image
+    MARKER_SOS       = 0xda,  // start of scan
+    MARKER_DRI       = 0xdd,  // restart interval
+    MARKER_DQT       = 0xdb,  // define quantization tables
+    MARKER_DHT       = 0xc4,  // huffman tables
+    MARKER_APP_FIRST = 0xe0,
+    MARKER_APP_LAST  = 0xef,
+    MARKER_COMMENT   = 0xfe,
+};
+
+static unsigned char const lum_dc_codelens[] = {
+    0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0,
+};
+
+static unsigned char const lum_dc_symbols[] = {
+    0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
+};
+
+static unsigned char const lum_ac_codelens[] = {
+    0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d,
+};
+
+static unsigned char const lum_ac_symbols[] = {
+    0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12, 0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07, 0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08,
+    0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0, 0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28,
+    0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
+    0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
+    0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6,
+    0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,
+    0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa,
+};
+
+static unsigned char const chm_dc_codelens[] = {
+    0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0,
+};
+
+static unsigned char const chm_dc_symbols[] = {
+    0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
+};
+
+static unsigned char const chm_ac_codelens[] = {
+    0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77,
+};
+
+static unsigned char const chm_ac_symbols[] = {
+    0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21, 0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71, 0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,
+    0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0, 0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34, 0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26,
+    0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
+    0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
+    0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4,
+    0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda,
+    0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa,
+};
+
+static void createHuffmanHeader(unsigned char *&p, unsigned char const *codelens, int ncodes, unsigned char const *symbols, int nsymbols, int tableNo,
+                                int tableClass) {
+    *p++ = 0xff;
+    *p++ = MARKER_DHT;
+    *p++ = 0;                     /* length msb */
+    *p++ = 3 + ncodes + nsymbols; /* length lsb */
+    *p++ = (tableClass << 4) | tableNo;
+    memcpy(p, codelens, ncodes);
+    p += ncodes;
+    memcpy(p, symbols, nsymbols);
+    p += nsymbols;
+}
+
+static unsigned computeJPEGHeaderSize(unsigned qtlen, unsigned dri) {
+    unsigned qtlen_half = qtlen / 2;  // in case qtlen is odd; shouldn't happen
+    qtlen               = qtlen_half * 2;
+
+    unsigned numQtables = qtlen > 64 ? 2 : 1;
+    return 485 + numQtables * 5 + qtlen + (dri > 0 ? 6 : 0);
+}
+
+static void createJPEGHeader(unsigned char *buf, unsigned type, unsigned w, unsigned h, unsigned char const *qtables, unsigned qtlen, unsigned dri) {
+    unsigned char *ptr        = buf;
+    unsigned       numQtables = qtlen > 64 ? 2 : 1;
+
+    // MARKER_SOI:
+    *ptr++ = 0xFF;
+    *ptr++ = MARKER_SOI;
+
+    // MARKER_APP_FIRST:
+    *ptr++ = 0xFF;
+    *ptr++ = MARKER_APP_FIRST;
+    *ptr++ = 0x00;
+    *ptr++ = 0x10;  // size of chunk
+    *ptr++ = 'J';
+    *ptr++ = 'F';
+    *ptr++ = 'I';
+    *ptr++ = 'F';
+    *ptr++ = 0x00;
+    *ptr++ = 0x01;
+    *ptr++ = 0x01;  // JFIF format version (1.1)
+    *ptr++ = 0x00;  // no units
+    *ptr++ = 0x00;
+    *ptr++ = 0x01;  // Horizontal pixel aspect ratio
+    *ptr++ = 0x00;
+    *ptr++ = 0x01;  // Vertical pixel aspect ratio
+    *ptr++ = 0x00;
+    *ptr++ = 0x00;  // no thumbnail
+
+    // MARKER_DRI:
+    if(dri > 0) {
+        *ptr++ = 0xFF;
+        *ptr++ = MARKER_DRI;
+        *ptr++ = 0x00;
+        *ptr++ = 0x04;  // size of chunk
+        *ptr++ = (BYTE)(dri >> 8);
+        *ptr++ = (BYTE)(dri);  // restart interval
+    }
+
+    // MARKER_DQT (luma):
+    unsigned tableSize = numQtables == 1 ? qtlen : qtlen / 2;
+    *ptr++             = 0xFF;
+    *ptr++             = MARKER_DQT;
+    *ptr++             = 0x00;
+    *ptr++             = tableSize + 3;  // size of chunk
+    *ptr++             = 0x00;           // precision(0), table id(0)
+    memcpy(ptr, qtables, tableSize);
+    qtables += tableSize;
+    ptr += tableSize;
+
+    if(numQtables > 1) {
+        unsigned tableSize = qtlen - qtlen / 2;
+        // MARKER_DQT (chroma):
+        *ptr++ = 0xFF;
+        *ptr++ = MARKER_DQT;
+        *ptr++ = 0x00;
+        *ptr++ = tableSize + 3;  // size of chunk
+        *ptr++ = 0x01;           // precision(0), table id(1)
+        memcpy(ptr, qtables, tableSize);
+        qtables += tableSize;
+        ptr += tableSize;
+    }
+
+    // MARKER_SOF0:
+    *ptr++ = 0xFF;
+    *ptr++ = MARKER_SOF0;
+    *ptr++ = 0x00;
+    *ptr++ = 0x11;  // size of chunk
+    *ptr++ = 0x08;  // sample precision
+    *ptr++ = (BYTE)(h >> 8);
+    *ptr++ = (BYTE)(h);  // number of lines (must be a multiple of 8)
+    *ptr++ = (BYTE)(w >> 8);
+    *ptr++ = (BYTE)(w);                      // number of columns (must be a multiple of 8)
+    *ptr++ = 0x03;                           // number of components
+    *ptr++ = 0x01;                           // id of component
+    *ptr++ = type ? 0x22 : 0x21;             // sampling ratio (h,v)
+    *ptr++ = 0x00;                           // quant table id
+    *ptr++ = 0x02;                           // id of component
+    *ptr++ = 0x11;                           // sampling ratio (h,v)
+    *ptr++ = numQtables == 1 ? 0x00 : 0x01;  // quant table id
+    *ptr++ = 0x03;                           // id of component
+    *ptr++ = 0x11;                           // sampling ratio (h,v)
+    *ptr++ = numQtables == 1 ? 0x00 : 0x01;  // quant table id
+
+    createHuffmanHeader(ptr, lum_dc_codelens, sizeof lum_dc_codelens, lum_dc_symbols, sizeof lum_dc_symbols, 0, 0);
+    createHuffmanHeader(ptr, lum_ac_codelens, sizeof lum_ac_codelens, lum_ac_symbols, sizeof lum_ac_symbols, 0, 1);
+    createHuffmanHeader(ptr, chm_dc_codelens, sizeof chm_dc_codelens, chm_dc_symbols, sizeof chm_dc_symbols, 1, 0);
+    createHuffmanHeader(ptr, chm_ac_codelens, sizeof chm_ac_codelens, chm_ac_symbols, sizeof chm_ac_symbols, 1, 1);
+
+    // MARKER_SOS:
+    *ptr++ = 0xFF;
+    *ptr++ = MARKER_SOS;
+    *ptr++ = 0x00;
+    *ptr++ = 0x0C;  // size of chunk
+    *ptr++ = 0x03;  // number of components
+    *ptr++ = 0x01;  // id of component
+    *ptr++ = 0x00;  // huffman table id (DC, AC)
+    *ptr++ = 0x02;  // id of component
+    *ptr++ = 0x11;  // huffman table id (DC, AC)
+    *ptr++ = 0x03;  // id of component
+    *ptr++ = 0x11;  // huffman table id (DC, AC)
+    *ptr++ = 0x00;  // start of spectral
+    *ptr++ = 0x3F;  // end of spectral
+    *ptr++ = 0x00;  // successive approximation bit position (high, low)
+}
+
+// The default 'luma' and 'chroma' quantizer tables, in zigzag order:
+static unsigned char const defaultQuantizers[128] = {
+    // luma table:
+    16, 11, 12, 14, 12, 10, 16, 14, 13, 14, 18, 17, 16, 19, 24, 40, 26, 24, 22, 22, 24, 49, 35, 37, 29, 40, 58, 51, 61, 60, 57, 51, 56, 55, 64, 72, 92, 78, 64,
+    68, 87, 69, 55, 56, 80, 109, 81, 87, 95, 98, 103, 104, 103, 62, 77, 113, 121, 112, 100, 120, 92, 101, 103, 99,
+    // chroma table:
+    17, 18, 18, 24, 21, 24, 47, 26, 26, 47, 99, 66, 56, 66, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
+    99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99
+};
+
+static void makeDefaultQtables(unsigned char *resultTables, unsigned Q) {
+    int factor = Q;
+    int q;
+
+    if(Q < 1)
+        factor = 1;
+    else if(Q > 99)
+        factor = 99;
+
+    if(Q < 50) {
+        q = 5000 / factor;
+    }
+    else {
+        q = 200 - factor * 2;
+    }
+
+    for(int i = 0; i < 128; ++i) {
+        int newVal = (defaultQuantizers[i] * q + 50) / 100;
+        if(newVal < 1)
+            newVal = 1;
+        else if(newVal > 255)
+            newVal = 255;
+        resultTables[i] = newVal;
+    }
+}
+
+Boolean JPEGVideoRTPSource ::processSpecialHeader(BufferedPacket *packet, unsigned &resultSpecialHeaderSize) {
+    unsigned char *headerStart = packet->data();
+    unsigned       packetSize  = packet->dataSize();
+
+    unsigned char *qtables = NULL;
+    unsigned       qtlen   = 0;
+    unsigned       dri     = 0;
+
+    // There's at least 8-byte video-specific header
+    /*
+  0                   1                   2                   3
+  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+  | Type-specific |              Fragment Offset                  |
+  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+  |      Type     |       Q       |     Width     |     Height    |
+  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+    */
+    if(packetSize < 8)
+        return False;
+
+    resultSpecialHeaderSize = 8;
+
+    unsigned Offset = (unsigned)((DWORD)headerStart[1] << 16 | (DWORD)headerStart[2] << 8 | (DWORD)headerStart[3]);
+    unsigned Type   = (unsigned)headerStart[4];
+    unsigned type   = Type & 1;
+    unsigned Q      = (unsigned)headerStart[5];
+    unsigned width  = (unsigned)headerStart[6] * 8;
+    unsigned height = (unsigned)headerStart[7] * 8;
+    if((width == 0 || height == 0) && fDefaultWidth != 0 && fDefaultHeight != 0) {
+        // Use the default width and height parameters instead:
+        width  = fDefaultWidth;
+        height = fDefaultHeight;
+    }
+    if(width == 0)
+        width = 256 * 8;  // special case
+    if(height == 0)
+        height = 256 * 8;  // special case
+
+    if(Type > 63) {
+        // Restart Marker header present
+        /*
+    0                   1                   2                   3
+    0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+    |       Restart Interval        |F|L|       Restart Count       |
+    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+        */
+        if(packetSize < resultSpecialHeaderSize + 4)
+            return False;
+
+        unsigned RestartInterval = (unsigned)((WORD)headerStart[resultSpecialHeaderSize] << 8 | (WORD)headerStart[resultSpecialHeaderSize + 1]);
+        dri                      = RestartInterval;
+        resultSpecialHeaderSize += 4;
+    }
+
+    if(Offset == 0) {
+        if(Q > 127) {
+            // Quantization Table header present
+            /*
+            0                   1                   2                   3
+            0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+            +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+            |      MBZ      |   Precision   |             Length            |
+            +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+            |                    Quantization Table Data                    |
+            |                              ...                              |
+            +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+            */
+            if(packetSize < resultSpecialHeaderSize + 4)
+                return False;
+
+            unsigned MBZ = (unsigned)headerStart[resultSpecialHeaderSize];
+            if(MBZ == 0) {
+                // unsigned Precision = (unsigned)headerStart[resultSpecialHeaderSize + 1];
+                unsigned Length = (unsigned)((WORD)headerStart[resultSpecialHeaderSize + 2] << 8 | (WORD)headerStart[resultSpecialHeaderSize + 3]);
+
+                // ASSERT(Length == 128);
+
+                resultSpecialHeaderSize += 4;
+
+                if(packetSize < resultSpecialHeaderSize + Length)
+                    return False;
+
+                qtlen   = Length;
+                qtables = &headerStart[resultSpecialHeaderSize];
+
+                resultSpecialHeaderSize += Length;
+            }
+        }
+    }
+
+    // If this is the first (or only) fragment of a JPEG frame, then we need
+    // to synthesize a JPEG header, and prepend it to the incoming data.
+    // Hack: We can do this because we allowed space for it in
+    // our special "JPEGBufferedPacket" subclass.  We also adjust
+    // "resultSpecialHeaderSize" to compensate for this, by subtracting
+    // the size of the synthesized header.  Note that this will cause
+    // "resultSpecialHeaderSize" to become negative, but the code that called
+    // us (in "MultiFramedRTPSource") will handle this properly.
+    if(Offset == 0) {
+        unsigned char newQtables[128];
+        if(qtlen == 0) {
+            // A quantization table was not present in the RTP JPEG header,
+            // so use the default tables, scaled according to the "Q" factor:
+            makeDefaultQtables(newQtables, Q);
+            qtables = newQtables;
+            qtlen   = sizeof newQtables;
+        }
+
+        unsigned hdrlen = computeJPEGHeaderSize(qtlen, dri);
+        resultSpecialHeaderSize -= hdrlen;            // goes negative
+        headerStart += (int)resultSpecialHeaderSize;  // goes backward
+        createJPEGHeader(headerStart, type, width, height, qtables, qtlen, dri);
+    }
+
+    fCurrentPacketBeginsFrame = (Offset == 0);
+
+    // The RTP "M" (marker) bit indicates the last fragment of a frame:
+    ((JPEGBufferedPacket *)packet)->completesFrame = fCurrentPacketCompletesFrame = packet->rtpMarkerBit();
+
+    return True;
+}
+
+char const *JPEGVideoRTPSource::MIMEtype() const {
+    return "video/JPEG";
+}
+
+////////// JPEGBufferedPacket and JPEGBufferedPacketFactory implementation
+
+void JPEGBufferedPacket::reset() {
+    BufferedPacket::reset();
+
+    // Move our "fHead" and "fTail" forward, to allow space for a synthesized
+    // JPEG header to precede the RTP data that comes in over the network.
+    unsigned offset = MAX_JPEG_HEADER_SIZE;
+    if(offset > fPacketSize)
+        offset = fPacketSize;  // shouldn't happen
+    fHead = fTail = offset;
+}
+
+unsigned JPEGBufferedPacket ::nextEnclosedFrameSize(unsigned char *&framePtr, unsigned dataSize) {
+    // Normally, the enclosed frame size is just "dataSize".  If, however,
+    // the frame does not end with the "EOI" marker, then add this now:
+    if(completesFrame && dataSize >= 2 && !(framePtr[dataSize - 2] == 0xFF && framePtr[dataSize - 1] == MARKER_EOI)) {
+        framePtr[dataSize++] = 0xFF;
+        framePtr[dataSize++] = MARKER_EOI;
+    }
+    return dataSize;
+}
+
+BufferedPacket *JPEGBufferedPacketFactory ::createNewPacket(MultiFramedRTPSource * /*ourSource*/) {
+    return new JPEGBufferedPacket;
+}
diff --git a/3rdparty/live555/src/liveMedia/JPEGVideoSource.cpp b/3rdparty/live555/src/liveMedia/JPEGVideoSource.cpp
new file mode 100644
index 00000000..2486e0a0
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/JPEGVideoSource.cpp
@@ -0,0 +1,41 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// JPEG video sources
+// Implementation
+
+#include "JPEGVideoSource.hh"
+
+JPEGVideoSource::JPEGVideoSource(UsageEnvironment &env) : FramedSource(env) {}
+
+JPEGVideoSource::~JPEGVideoSource() {}
+
+u_int8_t const *JPEGVideoSource::quantizationTables(u_int8_t &precision, u_int16_t &length) {
+    // Default implementation
+    precision = 0;
+    length    = 0;
+    return NULL;
+}
+
+u_int16_t JPEGVideoSource::restartInterval() {
+    // Default implementation
+    return 0;
+}
+
+Boolean JPEGVideoSource::isJPEGVideoSource() const {
+    return True;
+}
diff --git a/3rdparty/live555/src/liveMedia/Locale.cpp b/3rdparty/live555/src/liveMedia/Locale.cpp
new file mode 100644
index 00000000..f002c450
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/Locale.cpp
@@ -0,0 +1,72 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// Support for temporarily setting the locale (e.g., to "C" or "POSIX") for (e.g.) parsing or printing
+// floating-point numbers in protocol headers, or calling toupper()/tolower() on human-input strings.
+// Implementation
+
+#include "Locale.hh"
+#include <strDup.hh>
+
+Locale::Locale(char const *newLocale, LocaleCategory category) {
+#ifndef LOCALE_NOT_USED
+#ifndef NEWLOCALE_NOT_USED
+    int categoryMask;
+    switch(category) {
+    case All: {
+        categoryMask = LC_ALL_MASK;
+        break;
+    }
+    case Numeric: {
+        categoryMask = LC_NUMERIC_MASK;
+        break;
+    }
+    }
+    fLocale     = newlocale(categoryMask, newLocale, NULL);
+    fPrevLocale = uselocale(fLocale);
+#else
+    switch(category) {
+    case All: {
+        fCategoryNum = LC_ALL;
+        break;
+    }
+    case Numeric: {
+        fCategoryNum = LC_NUMERIC;
+        break;
+    }
+    }
+    fPrevLocale = strDup(setlocale(fCategoryNum, NULL));
+    setlocale(fCategoryNum, newLocale);
+#endif
+#endif
+}
+
+Locale::~Locale() {
+#ifndef LOCALE_NOT_USED
+#ifndef NEWLOCALE_NOT_USED
+    if(fLocale != (locale_t)0) {
+        uselocale(fPrevLocale);
+        freelocale(fLocale);
+    }
+#else
+    if(fPrevLocale != NULL) {
+        setlocale(fCategoryNum, fPrevLocale);
+        delete[] fPrevLocale;
+    }
+#endif
+#endif
+}
diff --git a/3rdparty/live555/src/liveMedia/MIKEY.cpp b/3rdparty/live555/src/liveMedia/MIKEY.cpp
new file mode 100644
index 00000000..ff269147
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/MIKEY.cpp
@@ -0,0 +1,665 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A data structure that implements a MIKEY message (RFC 3830)
+// Implementation
+
+#include "MIKEY.hh"
+#include <GroupsockHelper.hh>  // for our_random32()
+
+////////// MIKEYPayload definition /////////
+
+class MIKEYPayload {
+public:
+    MIKEYPayload(MIKEYState &ourMIKEYState, u_int8_t payloadType);
+    // create with default values
+    MIKEYPayload(MIKEYState &ourMIKEYState, u_int8_t payloadType, u_int8_t const *data, unsigned dataSize);
+    // create as a copy of existing values
+
+    virtual ~MIKEYPayload();
+
+    u_int8_t const *data() const {
+        return fData;
+    }
+    unsigned dataSize() const {
+        return fDataSize;
+    }
+
+    MIKEYPayload *next() const {
+        return fNext;
+    }
+    void setNextPayload(MIKEYPayload *nextPayload);
+
+private:
+    MIKEYState &  fOurMIKEYState;
+    u_int8_t      fPayloadType;
+    u_int8_t *    fData;
+    unsigned      fDataSize;
+    MIKEYPayload *fNext;
+};
+
+////////// MIKEYState implementation //////////
+
+enum MIKEYPayloadType {
+    KEMAC    = 1,
+    PKE      = 2,
+    DH       = 3,
+    SIGN     = 4,
+    T        = 5,
+    ID       = 6,
+    CERT     = 7,
+    CHASH    = 8,
+    V        = 9,
+    SP       = 10,
+    RAND     = 11,
+    ERR      = 12,
+    KEY_DATA = 13,
+    HDR      = 255
+};
+
+MIKEYState::MIKEYState(Boolean useEncryption)
+    :  // Set default encryption/authentication parameters:
+      fEncryptSRTP(useEncryption),
+      fEncryptSRTCP(useEncryption),
+      fMKI(our_random32()),
+      fUseAuthentication(True),
+
+      fHeaderPayload(NULL),
+      fTailPayload(NULL),
+      fTotalPayloadByteCount(0) {
+    // Fill in our 'key data' (30 bytes) with (pseudo-)random bits:
+    u_int8_t *p = &fKeyData[0];
+    u_int32_t random32;
+    random32 = our_random32();
+    *p++     = (random32 >> 24);
+    *p++     = (random32 >> 16);
+    *p++     = (random32 >> 8);
+    *p++     = random32;  // 0-3
+    random32 = our_random32();
+    *p++     = (random32 >> 24);
+    *p++     = (random32 >> 16);
+    *p++     = (random32 >> 8);
+    *p++     = random32;  // 4-7
+    random32 = our_random32();
+    *p++     = (random32 >> 24);
+    *p++     = (random32 >> 16);
+    *p++     = (random32 >> 8);
+    *p++     = random32;  // 8-11
+    random32 = our_random32();
+    *p++     = (random32 >> 24);
+    *p++     = (random32 >> 16);
+    *p++     = (random32 >> 8);
+    *p++     = random32;  // 12-15
+    random32 = our_random32();
+    *p++     = (random32 >> 24);
+    *p++     = (random32 >> 16);
+    *p++     = (random32 >> 8);
+    *p++     = random32;  // 16-19
+    random32 = our_random32();
+    *p++     = (random32 >> 24);
+    *p++     = (random32 >> 16);
+    *p++     = (random32 >> 8);
+    *p++     = random32;  // 20-23
+    random32 = our_random32();
+    *p++     = (random32 >> 24);
+    *p++     = (random32 >> 16);
+    *p++     = (random32 >> 8);
+    *p++     = random32;  // 24-27
+    random32 = our_random32();
+    *p++     = (random32 >> 24);
+    *p++     = (random32 >> 16);  // 28-29
+
+    addNewPayload(new MIKEYPayload(*this, HDR));
+    addNewPayload(new MIKEYPayload(*this, T));
+    addNewPayload(new MIKEYPayload(*this, RAND));
+    addNewPayload(new MIKEYPayload(*this, SP));
+    addNewPayload(new MIKEYPayload(*this, KEMAC));
+}
+
+MIKEYState::~MIKEYState() {
+    delete fHeaderPayload;  // which will delete all the other payloads as well
+}
+
+MIKEYState *MIKEYState::createNew(u_int8_t const *messageToParse, unsigned messageSize) {
+    Boolean     parsedOK;
+    MIKEYState *newMIKEYState = new MIKEYState(messageToParse, messageSize, parsedOK);
+
+    if(!parsedOK) {
+        delete newMIKEYState;
+        newMIKEYState = NULL;
+    }
+
+    return newMIKEYState;
+}
+
+u_int8_t *MIKEYState::generateMessage(unsigned &messageSize) const {
+    if(fTotalPayloadByteCount == 0)
+        return NULL;
+
+    // ASSERT: fTotalPayloadByteCount == the sum of all of the payloads' "fDataSize"s
+    messageSize             = fTotalPayloadByteCount;
+    u_int8_t *resultMessage = new u_int8_t[messageSize];
+    u_int8_t *p             = resultMessage;
+
+    for(MIKEYPayload *payload = fHeaderPayload; payload != NULL; payload = payload->next()) {
+        if(payload->data() == NULL)
+            continue;
+
+        memcpy(p, payload->data(), payload->dataSize());
+        p += payload->dataSize();
+    }
+
+    return resultMessage;
+}
+
+MIKEYState::MIKEYState(u_int8_t const *messageToParse, unsigned messageSize, Boolean &parsedOK)
+    :  // Set encryption/authentication parameters to default values (that may be overwritten
+       // later as we parse the message):
+      fEncryptSRTP(False),
+      fEncryptSRTCP(False),
+      fUseAuthentication(False),
+
+      fHeaderPayload(NULL),
+      fTailPayload(NULL),
+      fTotalPayloadByteCount(0) {
+    parsedOK = False;  // unless we learn otherwise
+
+    // Begin by parsing a HDR payload:
+    u_int8_t const *      ptr    = messageToParse;
+    u_int8_t const *const endPtr = messageToParse + messageSize;
+    u_int8_t              nextPayloadType;
+
+    if(!parseHDRPayload(ptr, endPtr, nextPayloadType))
+        return;
+
+    // Then parse each subsequent payload that we see:
+    while(nextPayloadType != 0) {
+        if(!parseNonHDRPayload(ptr, endPtr, nextPayloadType))
+            return;
+    }
+
+    // We succeeded in parsing all the data:
+    parsedOK = True;
+}
+
+void MIKEYState::addNewPayload(MIKEYPayload *newPayload) {
+    if(fTailPayload == NULL) {
+        fHeaderPayload = newPayload;
+    }
+    else {
+        fTailPayload->setNextPayload(newPayload);
+    }
+    fTailPayload = newPayload;
+
+    fTotalPayloadByteCount += newPayload->dataSize();
+}
+
+#define testSize(n)        \
+    if(ptr + (n) > endPtr) \
+    break
+
+Boolean MIKEYState ::parseHDRPayload(u_int8_t const *&ptr, u_int8_t const *endPtr, u_int8_t &nextPayloadType) {
+    do {
+        testSize(10);
+        nextPayloadType            = ptr[2];
+        u_int8_t numCryptoSessions = ptr[8];
+
+        unsigned payloadSize = 10 + numCryptoSessions * (1 + 4 + 4);
+        testSize(payloadSize);
+
+        addNewPayload(new MIKEYPayload(*this, HDR, ptr, payloadSize));
+        ptr += payloadSize;
+
+        return True;
+    } while(0);
+
+    // An error occurred:
+    return False;
+}
+
+static u_int32_t get4Bytes(u_int8_t const *&ptr) {
+    u_int32_t result = (ptr[0] << 24) | (ptr[1] << 16) | (ptr[2] << 8) | ptr[3];
+    ptr += 4;
+    return result;
+}
+
+static u_int16_t get2Bytes(u_int8_t const *&ptr) {
+    u_int16_t result = (ptr[0] << 8) | ptr[1];
+    ptr += 2;
+    return result;
+}
+
+Boolean MIKEYState ::parseNonHDRPayload(u_int8_t const *&ptr, u_int8_t const *endPtr, u_int8_t &nextPayloadType) {
+    do {
+        Boolean         parseSucceeded = False;  // initially
+        u_int8_t const *payloadStart   = ptr;
+        unsigned        payloadSize    = 0;
+
+        testSize(1);
+        u_int8_t ourPayloadType = nextPayloadType;
+        nextPayloadType         = *ptr++;
+
+        // The parsing depends on "ourPayloadType":
+        switch(ourPayloadType) {
+        case T: {  // RFC 3830, section 6.6
+            testSize(1);
+            u_int8_t TS_type      = *ptr++;
+            unsigned TS_value_len = 0;
+            switch(TS_type) {
+            case 0:    // NTP-UTC
+            case 1: {  // NTP
+                TS_value_len = 8;
+                break;
+            }
+            case 2: {  // COUNTER
+                TS_value_len = 4;
+                break;
+            }
+            }
+            if(TS_value_len == 0)
+                break;  // unknown TS_type
+
+            testSize(TS_value_len);
+            payloadSize    = 2 + TS_value_len;
+            parseSucceeded = True;
+            break;
+        }
+        case RAND: {  // RFC 3830, section 6.11
+            testSize(1);
+            u_int8_t RAND_len = *ptr++;
+
+            testSize(RAND_len);
+            payloadSize    = 2 + RAND_len;
+            parseSucceeded = True;
+            break;
+        }
+        case SP: {  // RFC 3830, section 6.10
+            testSize(4);
+            ++ptr;  // skip over "Policy no"
+            u_int8_t protType = *ptr++;
+            if(protType != 0 /*SRTP*/)
+                break;  // unsupported protocol type
+
+            u_int16_t policyParam_len = get2Bytes(ptr);
+
+            testSize(policyParam_len);
+            payloadSize                   = 5 + policyParam_len;
+            u_int8_t const *payloadEndPtr = payloadStart + payloadSize;
+            // Look through the "Policy param" section, making sure that:
+            //   - each of the "length" fields make sense
+            //   - for "type"s that we understand, the values make sense
+            Boolean parsedPolicyParamSection = False;
+            while(1) {
+                testSize(2);
+                u_int8_t ppType   = *ptr++;
+                u_int8_t ppLength = *ptr++;
+
+                testSize(ppLength);
+                if(ptr + ppLength > payloadEndPtr)
+                    break;  // bad "length"s - too big for the payload
+
+                // Check types that we understand:
+                Boolean policyIsOK = False;  // until we learn otherwise
+                switch(ppType) {
+                case 0: {  // Encryption algorithm: we handle only NULL and AES-CM
+                    if(ppLength != 1)
+                        break;
+                    u_int8_t value = ptr[0];
+                    if(value > 1)
+                        break;  // unsupported algorithm
+                    if(value > 0)
+                        fEncryptSRTP = fEncryptSRTCP = True;
+                    // Note: these might get changed by a subsequent "off/on" entry
+                    policyIsOK = True;
+                    break;
+                }
+                case 1: {  // Session Encr. key length
+                    if(ppLength != 1)
+                        break;
+                    u_int8_t value = ptr[0];
+                    if(value != 16)
+                        break;  // bad/unsupported value
+                    policyIsOK = True;
+                    break;
+                }
+                case 2: {  // Authentication algorithm: we handle only NULL and HMAC-SHA-1
+                    if(ppLength != 1)
+                        break;
+                    u_int8_t value = ptr[0];
+                    if(value > 1)
+                        break;  // unsupported algorithm
+                    if(value > 0)
+                        fUseAuthentication = True;
+                    // Note: this might get changed by a subsequent "off/on" entry
+                    policyIsOK = True;
+                    break;
+                }
+                case 3: {  // Session Auth. key length
+                    if(ppLength != 1)
+                        break;
+                    u_int8_t value = ptr[0];
+                    if(value != 20)
+                        break;  // bad/unsupported value
+                    policyIsOK = True;
+                    break;
+                }
+                case 4: {  // Session Salt key length
+                    if(ppLength != 1)
+                        break;
+                    u_int8_t value = ptr[0];
+                    if(value != 14)
+                        break;  // bad/unsupported value
+                    policyIsOK = True;
+                    break;
+                }
+                case 7: {  // SRTP encryption off/on
+                    if(ppLength != 1)
+                        break;
+                    u_int8_t value = ptr[0];
+                    if(value > 1)
+                        break;  // bad/unsupported value
+                    fEncryptSRTP = value;
+                    policyIsOK   = True;
+                    break;
+                }
+                case 8: {  // SRTCP encryption off/on
+                    if(ppLength != 1)
+                        break;
+                    u_int8_t value = ptr[0];
+                    if(value > 1)
+                        break;  // bad/unsupported value
+                    fEncryptSRTCP = value;
+                    policyIsOK    = True;
+                    break;
+                }
+                case 10: {  // SRTP authentication off/on
+                    if(ppLength != 1)
+                        break;
+                    u_int8_t value = ptr[0];
+                    if(value > 1)
+                        break;  // bad/unsupported value
+                    fUseAuthentication = value;
+                    policyIsOK         = True;
+                    break;
+                }
+                case 11: {  // Authentication tag length
+                    if(ppLength != 1)
+                        break;
+                    u_int8_t value = ptr[0];
+                    if(value != 10)
+                        break;  // bad/unsupported value
+                    policyIsOK = True;
+                    break;
+                }
+                default: {  // a policy type that we don't handle; still OK
+                    policyIsOK = True;
+                    break;
+                }
+                }
+                if(!policyIsOK)
+                    break;
+
+                ptr += ppLength;
+                if(ptr == payloadEndPtr) {
+                    // We've successfully checked all of the "Policy param"s
+                    parsedPolicyParamSection = True;
+                    break;
+                }
+            }
+            if(!parsedPolicyParamSection)
+                break;
+            parseSucceeded = True;
+            break;
+        }
+        case KEMAC: {  // RFC 3830, section 6.2
+            testSize(3);
+            u_int8_t encrAlg = *ptr++;
+            // We currently support only 'NULL' encryption on the key data:
+            if(encrAlg != 0 /*NULL*/)
+                break;  // unknown or unsupported key encryption
+
+            u_int16_t encrDataLen = get2Bytes(ptr);
+
+            testSize(encrDataLen);
+            // Parse the 'key data sub-payload':
+            {
+                u_int8_t const *subPtr = ptr;
+                if(encrDataLen < 4)
+                    break;  // not enough space
+                ++subPtr;   // skip over the "Next payload" field
+
+                // Check the "Type" and "KV" fields; we support only TEK and SPI/MKI
+                // Note: This means that we'll reject the "a=key-mgmt" SDP MIKEY data from
+                //   an Axis camera, because that doesn't specify SPI/MKI.  But that's what
+                //   we want, because the Axis camera's "a=key-mgmt" SDP MIKEY data is meant
+                //   to be ignored by clients.
+                if(*subPtr++ != ((2 << 4) | 1))
+                    break;  // Type 2 (TEK) | KV 1 (SPI/MKI)
+                u_int16_t keyDataLen = get2Bytes(subPtr);
+                // The key data length must be 30 (encryption key length (16) + salt length (14)):
+                if(keyDataLen != 30)
+                    break;
+
+                // Make sure we have enough space for the key data and the "SPI Length" field:
+                if(4 + keyDataLen + 1 > encrDataLen)
+                    break;
+                // Record the key data:
+                memmove(fKeyData, subPtr, keyDataLen);
+                subPtr += keyDataLen;
+
+                // Check the "SPI Length"; we support only length 4:
+                u_int8_t SPILength = *subPtr++;
+                if(SPILength != 4)
+                    break;
+
+                // Make a note of the MKI (the next 4 bytes):
+                if(4 + keyDataLen + 1 + SPILength > encrDataLen)
+                    break;
+                fMKI = get4Bytes(subPtr);
+            }
+            ptr += encrDataLen;
+
+            testSize(1);
+            u_int8_t macAlg = *ptr++;
+            unsigned macLen;
+            // We currently support only a 'NULL' MAC on the key data:
+            if(macAlg == 0 /*NULL*/)
+                macLen = 0;
+            else
+                break;  // unknown or unsupported MAC algorithm => parse fails
+
+            testSize(macLen);
+            payloadSize    = 4 + encrDataLen + 1 + macLen;
+            parseSucceeded = True;
+            break;
+        }
+        default: {
+            // Unknown payload type.  The parsing fails.
+            break;
+        }
+        }
+        if(!parseSucceeded)
+            break;
+
+        addNewPayload(new MIKEYPayload(*this, ourPayloadType, payloadStart, payloadSize));
+        ptr = payloadStart + payloadSize;
+
+        return True;
+    } while(0);
+
+    // An error occurred:
+    return False;
+}
+
+////////// MIKEYPayload implementation //////////
+
+static void addWord(u_int8_t *&p, u_int32_t word) {
+    *p++ = word >> 24;
+    *p++ = word >> 16;
+    *p++ = word >> 8;
+    *p++ = word;
+}
+
+static void addHalfWord(u_int8_t *&p, u_int16_t halfWord) {
+    *p++ = halfWord >> 8;
+    *p++ = halfWord;
+}
+
+static void add1BytePolicyParam(u_int8_t *&p, u_int8_t type, u_int8_t value) {
+    *p++ = type;
+    *p++ = 1;  // length
+    *p++ = value;
+}
+
+MIKEYPayload::MIKEYPayload(MIKEYState &ourMIKEYState, u_int8_t payloadType) : fOurMIKEYState(ourMIKEYState), fPayloadType(payloadType), fNext(NULL) {
+    switch(payloadType) {
+    case HDR: {  // RFC 3830, section 6.1
+        fDataSize              = 19;
+        fData                  = new u_int8_t[fDataSize];
+        u_int8_t *p            = fData;
+        *p++                   = 1;  // version
+        *p++                   = 0;  // Initiator's pre-shared key message
+        *p++                   = 0;  // no next payload (initially)
+        *p++                   = 0;  // V=0; PRF func: MIKEY-1
+        u_int32_t const CSB_ID = our_random32();
+        addWord(p, CSB_ID);
+        *p++ = 1;                    // #CS: 1
+        *p++ = 0;                    // CS ID map type: SRTP-ID
+        *p++ = 0;                    // Policy_no_1
+        addWord(p, our_random32());  // SSRC_1
+        addWord(p, 0x00000000);      // ROC_1
+        break;
+    }
+    case T: {  // RFC 3830, section 6.6
+        fDataSize   = 10;
+        fData       = new u_int8_t[fDataSize];
+        u_int8_t *p = fData;
+        *p++        = 0;  // no next payload (initially)
+        *p++        = 0;  // TS type: NTP-UTC
+
+        // Get the current time, and convert it to a NTP-UTC time:
+        struct timeval timeNow;
+        gettimeofday(&timeNow, NULL);
+        u_int32_t ntpSeconds = timeNow.tv_sec + 0x83AA7E80;  // 1970 epoch -> 1900 epoch
+        addWord(p, ntpSeconds);
+        double    fractionalPart      = (timeNow.tv_usec / 15625.0) * 0x04000000;  // 2^32/10^6
+        u_int32_t ntpFractionOfSecond = (u_int32_t)(fractionalPart + 0.5);         // round
+        addWord(p, ntpFractionOfSecond);
+        break;
+    }
+    case RAND: {  // RFC 3830, section 6.11
+        fDataSize                     = 18;
+        fData                         = new u_int8_t[fDataSize];
+        u_int8_t *p                   = fData;
+        *p++                          = 0;                   // no next payload (initially)
+        unsigned const numRandomWords = 4;                   // number of 32-bit words making up the RAND value
+        *p++                          = 4 * numRandomWords;  // RAND len (in bytes)
+        for(unsigned i = 0; i < numRandomWords; ++i) {
+            u_int32_t randomNumber = our_random32();
+            addWord(p, randomNumber);
+        }
+        break;
+    }
+    case SP: {  // RFC 3830, section 6.10
+        fDataSize                = 32;
+        fData                    = new u_int8_t[fDataSize];
+        u_int8_t *p              = fData;
+        *p++                     = 0;  // no next payload (initially)
+        *p++                     = 0;  // Policy number
+        *p++                     = 0;  // Protocol type: SRTP
+        u_int16_t policyParamLen = 27;
+        addHalfWord(p, policyParamLen);
+        // Now add the SRTP policy parameters:
+        add1BytePolicyParam(p, 0 /*Encryption algorithm*/, (fOurMIKEYState.encryptSRTP() || fOurMIKEYState.encryptSRTCP()) ? 1 /*AES-CM*/ : 0 /*NULL*/);
+        add1BytePolicyParam(p, 1 /*Session Encryption key length*/, 16);
+        add1BytePolicyParam(p, 2 /*Authentication algorithm*/, fOurMIKEYState.useAuthentication() ? 1 /*HMAC-SHA-1*/ : 0 /*NULL*/);
+        add1BytePolicyParam(p, 3 /*Session Authentication key length*/, 20);
+        add1BytePolicyParam(p, 4 /*Session Salt key length*/, 14);
+        add1BytePolicyParam(p, 7 /*SRTP encryption off/on*/, fOurMIKEYState.encryptSRTP());
+        add1BytePolicyParam(p, 8 /*SRTCP encryption off/on*/, fOurMIKEYState.encryptSRTCP());
+        add1BytePolicyParam(p, 10 /*SRTP authentication off/on*/, fOurMIKEYState.useAuthentication());
+        add1BytePolicyParam(p, 11 /*Authentication tag length*/, 10);
+        break;
+    }
+    case KEMAC: {  // RFC 3830, section 6.2
+        fDataSize             = 44;
+        fData                 = new u_int8_t[fDataSize];
+        u_int8_t *p           = fData;
+        *p++                  = 0;  // no next payload
+        *p++                  = 0;  // Encr alg (NULL)
+        u_int16_t encrDataLen = 39;
+        addHalfWord(p, encrDataLen);
+        {                         // Key data sub-payload (RFC 3830, section 6.13):
+            *p++ = 0;             // no next payload
+            *p++ = (2 << 4) | 1;  // Type 2 (TEK) | KV 1 (SPI/MKI)
+
+            // Key data len:
+            u_int16_t const keyDataLen = 30;
+            addHalfWord(p, keyDataLen);
+
+            // Key data:
+            memcpy(p, fOurMIKEYState.keyData(), keyDataLen);
+            p += keyDataLen;
+
+            {              // KV data (for SPI/MKI) (RFC 3830, section 6.14):
+                *p++ = 4;  // SPI/MKI Length
+                addWord(p, fOurMIKEYState.MKI());
+            }
+        }
+        *p++ = 0;  // MAC alg (NULL)
+        break;
+    }
+    default: {
+        // Unused payload type.  Just in case, allocate 1 byte, for the
+        // presumed 'next payload type' field.
+        fDataSize = 1;
+        fData     = new u_int8_t[fDataSize];
+        fData[0]  = 0;
+        break;
+    }
+    }
+}
+
+MIKEYPayload::MIKEYPayload(MIKEYState &ourMIKEYState, u_int8_t payloadType, u_int8_t const *data, unsigned dataSize)
+    : fOurMIKEYState(ourMIKEYState), fPayloadType(payloadType), fDataSize(dataSize), fNext(NULL) {
+    fData = new u_int8_t[fDataSize];
+    memcpy(fData, data, fDataSize);
+}
+
+MIKEYPayload::~MIKEYPayload() {
+    delete[] fData;
+    delete fNext;
+}
+
+void MIKEYPayload::setNextPayload(MIKEYPayload *nextPayload) {
+    fNext = nextPayload;
+
+    // We also need to set the 'next payload type' field in our data:
+    u_int8_t nextPayloadType = nextPayload->fPayloadType;
+
+    switch(fPayloadType) {
+    case HDR: {
+        fData[2] = nextPayloadType;
+        break;
+    }
+    default: {
+        if(fData != NULL)
+            fData[0] = nextPayloadType;
+        break;
+    }
+    }
+}
diff --git a/3rdparty/live555/src/liveMedia/MP3ADU.cpp b/3rdparty/live555/src/liveMedia/MP3ADU.cpp
new file mode 100644
index 00000000..2ebf3ba2
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/MP3ADU.cpp
@@ -0,0 +1,642 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// 'ADU' MP3 streams (for improved loss-tolerance)
+// Implementation
+
+#include "MP3ADU.hh"
+#include "MP3ADUdescriptor.hh"
+#include "MP3Internals.hh"
+#include <string.h>
+
+#ifdef TEST_LOSS
+#include "GroupsockHelper.hh"
+#endif
+
+// Segment data structures, used in the implementation below:
+
+#define SegmentBufSize 2000 /* conservatively high */
+
+class Segment {
+public:
+    unsigned char  buf[SegmentBufSize];
+    unsigned char *dataStart() {
+        return &buf[descriptorSize];
+    }
+    unsigned frameSize;   // if it's a non-ADU frame
+    unsigned dataHere();  // if it's a non-ADU frame
+
+    unsigned              descriptorSize;
+    static unsigned const headerSize;
+    unsigned              sideInfoSize, aduSize;
+    unsigned              backpointer;
+
+    struct timeval presentationTime;
+    unsigned       durationInMicroseconds;
+};
+
+unsigned const Segment::headerSize = 4;
+
+#define SegmentQueueSize 20
+
+class SegmentQueue {
+public:
+    SegmentQueue(Boolean directionIsToADU, Boolean includeADUdescriptors) : fDirectionIsToADU(directionIsToADU), fIncludeADUdescriptors(includeADUdescriptors) {
+        reset();
+    }
+
+    Segment s[SegmentQueueSize];
+
+    unsigned headIndex() {
+        return fHeadIndex;
+    }
+    Segment &headSegment() {
+        return s[fHeadIndex];
+    }
+
+    unsigned nextFreeIndex() {
+        return fNextFreeIndex;
+    }
+    Segment &nextFreeSegment() {
+        return s[fNextFreeIndex];
+    }
+    Boolean isEmpty() {
+        return isEmptyOrFull() && totalDataSize() == 0;
+    }
+    Boolean isFull() {
+        return isEmptyOrFull() && totalDataSize() > 0;
+    }
+
+    static unsigned nextIndex(unsigned ix) {
+        return (ix + 1) % SegmentQueueSize;
+    }
+    static unsigned prevIndex(unsigned ix) {
+        return (ix + SegmentQueueSize - 1) % SegmentQueueSize;
+    }
+
+    unsigned totalDataSize() {
+        return fTotalDataSize;
+    }
+
+    void enqueueNewSegment(FramedSource *inputSource, FramedSource *usingSource);
+
+    Boolean dequeue();
+
+    Boolean insertDummyBeforeTail(unsigned backpointer);
+
+    void reset() {
+        fHeadIndex = fNextFreeIndex = fTotalDataSize = 0;
+    }
+
+private:
+    static void sqAfterGettingSegment(void *clientData, unsigned numBytesRead, unsigned numTruncatedBytes, struct timeval presentationTime,
+                                      unsigned durationInMicroseconds);
+
+    Boolean sqAfterGettingCommon(Segment &seg, unsigned numBytesRead);
+    Boolean isEmptyOrFull() {
+        return headIndex() == nextFreeIndex();
+    }
+
+    unsigned fHeadIndex, fNextFreeIndex, fTotalDataSize;
+
+    // The following is used for asynchronous reads:
+    FramedSource *fUsingSource;
+
+    // This tells us whether the direction in which we're being used
+    // is MP3->ADU, or vice-versa.  (This flag is used for debugging output.)
+    Boolean fDirectionIsToADU;
+
+    // The following is true iff we're used to enqueue incoming
+    // ADU frames, and these have an ADU descriptor in front
+    Boolean fIncludeADUdescriptors;
+};
+
+////////// ADUFromMP3Source //////////
+
+ADUFromMP3Source::ADUFromMP3Source(UsageEnvironment &env, FramedSource *inputSource, Boolean includeADUdescriptors)
+    : FramedFilter(env, inputSource),
+      fAreEnqueueingMP3Frame(False),
+      fSegments(new SegmentQueue(True /* because we're MP3->ADU */, False /*no descriptors in incoming frames*/)),
+      fIncludeADUdescriptors(includeADUdescriptors),
+      fTotalDataSizeBeforePreviousRead(0),
+      fScale(1),
+      fFrameCounter(0) {}
+
+ADUFromMP3Source::~ADUFromMP3Source() {
+    delete fSegments;
+}
+
+char const *ADUFromMP3Source::MIMEtype() const {
+    return "audio/MPA-ROBUST";
+}
+
+ADUFromMP3Source *ADUFromMP3Source::createNew(UsageEnvironment &env, FramedSource *inputSource, Boolean includeADUdescriptors) {
+    // The source must be a MPEG audio source:
+    if(strcmp(inputSource->MIMEtype(), "audio/MPEG") != 0) {
+        env.setResultMsg(inputSource->name(), " is not an MPEG audio source");
+        return NULL;
+    }
+
+    return new ADUFromMP3Source(env, inputSource, includeADUdescriptors);
+}
+
+void ADUFromMP3Source::resetInput() {
+    fSegments->reset();
+}
+
+Boolean ADUFromMP3Source::setScaleFactor(int scale) {
+    if(scale < 1)
+        return False;
+    fScale = scale;
+    return True;
+}
+
+void ADUFromMP3Source::doGetNextFrame() {
+    if(!fAreEnqueueingMP3Frame) {
+        // Arrange to enqueue a new MP3 frame:
+        fTotalDataSizeBeforePreviousRead = fSegments->totalDataSize();
+        fAreEnqueueingMP3Frame           = True;
+        fSegments->enqueueNewSegment(fInputSource, this);
+    }
+    else {
+        // Deliver an ADU from a previously-read MP3 frame:
+        fAreEnqueueingMP3Frame = False;
+
+        if(!doGetNextFrame1()) {
+            // An internal error occurred; act as if our source went away:
+            handleClosure();
+        }
+    }
+}
+
+Boolean ADUFromMP3Source::doGetNextFrame1() {
+    // First, check whether we have enough previously-read data to output an
+    // ADU for the last-read MP3 frame:
+    unsigned tailIndex;
+    Segment *tailSeg;
+    Boolean  needMoreData;
+
+    if(fSegments->isEmpty()) {
+        needMoreData = True;
+        tailSeg      = NULL;
+        tailIndex    = 0;  // unneeded, but stops compiler warnings
+    }
+    else {
+        tailIndex = SegmentQueue::prevIndex(fSegments->nextFreeIndex());
+        tailSeg   = &(fSegments->s[tailIndex]);
+
+        needMoreData = fTotalDataSizeBeforePreviousRead < tailSeg->backpointer            // bp points back too far
+                       || tailSeg->backpointer + tailSeg->dataHere() < tailSeg->aduSize;  // not enough data
+    }
+
+    if(needMoreData) {
+        // We don't have enough data to output an ADU from the last-read MP3
+        // frame, so need to read another one and try again:
+        doGetNextFrame();
+        return True;
+    }
+
+    // Output an ADU from the tail segment:
+    fFrameSize              = tailSeg->headerSize + tailSeg->sideInfoSize + tailSeg->aduSize;
+    fPresentationTime       = tailSeg->presentationTime;
+    fDurationInMicroseconds = tailSeg->durationInMicroseconds;
+    unsigned descriptorSize = fIncludeADUdescriptors ? ADUdescriptor::computeSize(fFrameSize) : 0;
+#ifdef DEBUG
+    fprintf(stderr, "m->a:outputting ADU %d<-%d, nbr:%d, sis:%d, dh:%d, (descriptor size: %d)\n", tailSeg->aduSize, tailSeg->backpointer, fFrameSize,
+            tailSeg->sideInfoSize, tailSeg->dataHere(), descriptorSize);
+#endif
+    if(descriptorSize + fFrameSize > fMaxSize) {
+        envir() << "ADUFromMP3Source::doGetNextFrame1(): not enough room (" << descriptorSize + fFrameSize << ">" << fMaxSize << ")\n";
+        fFrameSize = 0;
+        return False;
+    }
+
+    unsigned char *toPtr = fTo;
+    // output the ADU descriptor:
+    if(fIncludeADUdescriptors) {
+        fFrameSize += ADUdescriptor::generateDescriptor(toPtr, fFrameSize);
+    }
+
+    // output header and side info:
+    memmove(toPtr, tailSeg->dataStart(), tailSeg->headerSize + tailSeg->sideInfoSize);
+    toPtr += tailSeg->headerSize + tailSeg->sideInfoSize;
+
+    // go back to the frame that contains the start of our data:
+    unsigned offset    = 0;
+    unsigned i         = tailIndex;
+    unsigned prevBytes = tailSeg->backpointer;
+    while(prevBytes > 0) {
+        i                 = SegmentQueue::prevIndex(i);
+        unsigned dataHere = fSegments->s[i].dataHere();
+        if(dataHere < prevBytes) {
+            prevBytes -= dataHere;
+        }
+        else {
+            offset = dataHere - prevBytes;
+            break;
+        }
+    }
+
+    // dequeue any segments that we no longer need:
+    while(fSegments->headIndex() != i) {
+        fSegments->dequeue();  // we're done with it
+    }
+
+    unsigned bytesToUse = tailSeg->aduSize;
+    while(bytesToUse > 0) {
+        Segment &      seg           = fSegments->s[i];
+        unsigned char *fromPtr       = &seg.dataStart()[seg.headerSize + seg.sideInfoSize + offset];
+        unsigned       dataHere      = seg.dataHere() - offset;
+        unsigned       bytesUsedHere = dataHere < bytesToUse ? dataHere : bytesToUse;
+        memmove(toPtr, fromPtr, bytesUsedHere);
+        bytesToUse -= bytesUsedHere;
+        toPtr += bytesUsedHere;
+        offset = 0;
+        i      = SegmentQueue::nextIndex(i);
+    }
+
+    if(fFrameCounter++ % fScale == 0) {
+        // Call our own 'after getting' function.  Because we're not a 'leaf'
+        // source, we can call this directly, without risking infinite recursion.
+        afterGetting(this);
+    }
+    else {
+        // Don't use this frame; get another one:
+        doGetNextFrame();
+    }
+
+    return True;
+}
+
+////////// MP3FromADUSource //////////
+
+MP3FromADUSource::MP3FromADUSource(UsageEnvironment &env, FramedSource *inputSource, Boolean includeADUdescriptors)
+    : FramedFilter(env, inputSource), fAreEnqueueingADU(False), fSegments(new SegmentQueue(False /* because we're ADU->MP3 */, includeADUdescriptors)) {}
+
+MP3FromADUSource::~MP3FromADUSource() {
+    delete fSegments;
+}
+
+char const *MP3FromADUSource::MIMEtype() const {
+    return "audio/MPEG";
+}
+
+MP3FromADUSource *MP3FromADUSource::createNew(UsageEnvironment &env, FramedSource *inputSource, Boolean includeADUdescriptors) {
+    // The source must be an MP3 ADU source:
+    if(strcmp(inputSource->MIMEtype(), "audio/MPA-ROBUST") != 0) {
+        env.setResultMsg(inputSource->name(), " is not an MP3 ADU source");
+        return NULL;
+    }
+
+    return new MP3FromADUSource(env, inputSource, includeADUdescriptors);
+}
+
+void MP3FromADUSource::doGetNextFrame() {
+    if(fAreEnqueueingADU)
+        insertDummyADUsIfNecessary();
+    fAreEnqueueingADU = False;
+
+    if(needToGetAnADU()) {
+        // Before returning a frame, we must enqueue at least one ADU:
+#ifdef TEST_LOSS
+    NOTE:
+        This code no longer works, because it uses synchronous reads, which are no longer supported.static unsigned const framesPerPacket = 10;
+        static unsigned const frameCount = 0;
+        static Boolean        packetIsLost;
+        while(1) {
+            if((frameCount++) % framesPerPacket == 0) {
+                packetIsLost = (our_random() % 10 == 0);  // simulate 10% packet loss #####
+            }
+
+            if(packetIsLost) {
+                // Read and discard the next input frame (that would be part of
+                // a lost packet):
+                Segment        dummySegment;
+                unsigned       numBytesRead;
+                struct timeval presentationTime;
+                // (this works only if the source can be read synchronously)
+                fInputSource->syncGetNextFrame(dummySegment.buf, sizeof dummySegment.buf, numBytesRead, presentationTime);
+            }
+            else {
+                break;  // from while (1)
+            }
+        }
+#endif
+
+        fAreEnqueueingADU = True;
+        fSegments->enqueueNewSegment(fInputSource, this);
+    }
+    else {
+        // Return a frame now:
+        generateFrameFromHeadADU();
+        // sets fFrameSize, fPresentationTime, and fDurationInMicroseconds
+
+        // Call our own 'after getting' function.  Because we're not a 'leaf'
+        // source, we can call this directly, without risking infinite recursion.
+        afterGetting(this);
+    }
+}
+
+Boolean MP3FromADUSource::needToGetAnADU() {
+    // Check whether we need to first enqueue a new ADU before we
+    // can generate a frame for our head ADU.
+    Boolean needToEnqueue = True;
+
+    if(!fSegments->isEmpty()) {
+        unsigned  index          = fSegments->headIndex();
+        Segment * seg            = &(fSegments->headSegment());
+        int const endOfHeadFrame = (int)seg->dataHere();
+        unsigned  frameOffset    = 0;
+
+        while(1) {
+            int endOfData = frameOffset - seg->backpointer + seg->aduSize;
+            if(endOfData >= endOfHeadFrame) {
+                // We already have enough data to generate a frame
+                needToEnqueue = False;
+                break;
+            }
+
+            frameOffset += seg->dataHere();
+            index = SegmentQueue::nextIndex(index);
+            if(index == fSegments->nextFreeIndex())
+                break;
+            seg = &(fSegments->s[index]);
+        }
+    }
+
+    return needToEnqueue;
+}
+
+void MP3FromADUSource::insertDummyADUsIfNecessary() {
+    if(fSegments->isEmpty())
+        return;  // shouldn't happen
+
+    // The tail segment (ADU) is assumed to have been recently
+    // enqueued.  If its backpointer would overlap the data
+    // of the previous ADU, then we need to insert one or more
+    // empty, 'dummy' ADUs ahead of it.  (This situation should occur
+    // only if an intermediate ADU was lost.)
+
+    unsigned tailIndex = SegmentQueue::prevIndex(fSegments->nextFreeIndex());
+    Segment *tailSeg   = &(fSegments->s[tailIndex]);
+
+    while(1) {
+        unsigned prevADUend;  // relative to the start of the new ADU
+        if(fSegments->headIndex() != tailIndex) {
+            // there is a previous segment
+            unsigned prevIndex   = SegmentQueue::prevIndex(tailIndex);
+            Segment &prevSegment = fSegments->s[prevIndex];
+            prevADUend           = prevSegment.dataHere() + prevSegment.backpointer;
+            if(prevSegment.aduSize > prevADUend) {
+                // shouldn't happen if the previous ADU was well-formed
+                prevADUend = 0;
+            }
+            else {
+                prevADUend -= prevSegment.aduSize;
+            }
+        }
+        else {
+            prevADUend = 0;
+        }
+
+        if(tailSeg->backpointer > prevADUend) {
+            // We need to insert a dummy ADU in front of the tail
+#ifdef DEBUG
+            fprintf(stderr, "a->m:need to insert a dummy ADU (%d, %d, %d) [%d, %d]\n", tailSeg->backpointer, prevADUend, tailSeg->dataHere(),
+                    fSegments->headIndex(), fSegments->nextFreeIndex());
+#endif
+            tailIndex = fSegments->nextFreeIndex();
+            if(!fSegments->insertDummyBeforeTail(prevADUend))
+                return;
+            tailSeg = &(fSegments->s[tailIndex]);
+        }
+        else {
+            break;  // no more dummy ADUs need to be inserted
+        }
+    }
+}
+
+Boolean MP3FromADUSource::generateFrameFromHeadADU() {
+    // Output a frame for the head ADU:
+    if(fSegments->isEmpty())
+        return False;
+    unsigned index = fSegments->headIndex();
+    Segment *seg   = &(fSegments->headSegment());
+#ifdef DEBUG
+    fprintf(stderr, "a->m:outputting frame for %d<-%d (fs %d, dh %d), (descriptorSize: %d)\n", seg->aduSize, seg->backpointer, seg->frameSize, seg->dataHere(),
+            seg->descriptorSize);
+#endif
+    unsigned char *toPtr = fTo;
+
+    // output header and side info:
+    fFrameSize              = seg->frameSize;
+    fPresentationTime       = seg->presentationTime;
+    fDurationInMicroseconds = seg->durationInMicroseconds;
+    memmove(toPtr, seg->dataStart(), seg->headerSize + seg->sideInfoSize);
+    toPtr += seg->headerSize + seg->sideInfoSize;
+
+    // zero out the rest of the frame, in case ADU data doesn't fill it all in
+    unsigned bytesToZero = seg->dataHere();
+    for(unsigned i = 0; i < bytesToZero; ++i) {
+        toPtr[i] = '\0';
+    }
+
+    // Fill in the frame with appropriate ADU data from this and
+    // subsequent ADUs:
+    unsigned       frameOffset    = 0;
+    unsigned       toOffset       = 0;
+    unsigned const endOfHeadFrame = seg->dataHere();
+
+    while(toOffset < endOfHeadFrame) {
+        int startOfData = frameOffset - seg->backpointer;
+        if(startOfData > (int)endOfHeadFrame)
+            break;  // no more ADUs needed
+
+        int endOfData = startOfData + seg->aduSize;
+        if(endOfData > (int)endOfHeadFrame) {
+            endOfData = endOfHeadFrame;
+        }
+
+        unsigned fromOffset;
+        if(startOfData <= (int)toOffset) {
+            fromOffset  = toOffset - startOfData;
+            startOfData = toOffset;
+            if(endOfData < startOfData)
+                endOfData = startOfData;
+        }
+        else {
+            fromOffset = 0;
+
+            // we may need some padding bytes beforehand
+            unsigned bytesToZero = startOfData - toOffset;
+#ifdef DEBUG
+            if(bytesToZero > 0)
+                fprintf(stderr, "a->m:outputting %d zero bytes (%d, %d, %d, %d)\n", bytesToZero, startOfData, toOffset, frameOffset, seg->backpointer);
+#endif
+            toOffset += bytesToZero;
+        }
+
+        unsigned char *fromPtr       = &seg->dataStart()[seg->headerSize + seg->sideInfoSize + fromOffset];
+        unsigned       bytesUsedHere = endOfData - startOfData;
+#ifdef DEBUG
+        if(bytesUsedHere > 0)
+            fprintf(stderr, "a->m:outputting %d bytes from %d<-%d\n", bytesUsedHere, seg->aduSize, seg->backpointer);
+#endif
+        memmove(toPtr + toOffset, fromPtr, bytesUsedHere);
+        toOffset += bytesUsedHere;
+
+        frameOffset += seg->dataHere();
+        index = SegmentQueue::nextIndex(index);
+        if(index == fSegments->nextFreeIndex())
+            break;
+        seg = &(fSegments->s[index]);
+    }
+
+    fSegments->dequeue();
+
+    return True;
+}
+
+////////// Segment //////////
+
+unsigned Segment::dataHere() {
+    int result = frameSize - (headerSize + sideInfoSize);
+    if(result < 0) {
+        return 0;
+    }
+
+    return (unsigned)result;
+}
+
+////////// SegmentQueue //////////
+
+void SegmentQueue::enqueueNewSegment(FramedSource *inputSource, FramedSource *usingSource) {
+    if(isFull()) {
+        usingSource->envir() << "SegmentQueue::enqueueNewSegment() overflow\n";
+        usingSource->handleClosure();
+        return;
+    }
+
+    fUsingSource = usingSource;
+
+    Segment &seg = nextFreeSegment();
+    inputSource->getNextFrame(seg.buf, sizeof seg.buf, sqAfterGettingSegment, this, FramedSource::handleClosure, usingSource);
+}
+
+void SegmentQueue::sqAfterGettingSegment(void *clientData, unsigned numBytesRead, unsigned /*numTruncatedBytes*/, struct timeval presentationTime,
+                                         unsigned durationInMicroseconds) {
+    SegmentQueue *segQueue = (SegmentQueue *)clientData;
+    Segment &     seg      = segQueue->nextFreeSegment();
+
+    seg.presentationTime       = presentationTime;
+    seg.durationInMicroseconds = durationInMicroseconds;
+
+    if(segQueue->sqAfterGettingCommon(seg, numBytesRead)) {
+#ifdef DEBUG
+        char const *direction = segQueue->fDirectionIsToADU ? "m->a" : "a->m";
+        fprintf(stderr, "%s:read frame %d<-%d, fs:%d, sis:%d, dh:%d, (descriptor size: %d)\n", direction, seg.aduSize, seg.backpointer, seg.frameSize,
+                seg.sideInfoSize, seg.dataHere(), seg.descriptorSize);
+#endif
+    }
+
+    // Continue our original calling source where it left off:
+    segQueue->fUsingSource->doGetNextFrame();
+}
+
+// Common code called after a new segment is enqueued
+Boolean SegmentQueue::sqAfterGettingCommon(Segment &seg, unsigned numBytesRead) {
+    unsigned char *fromPtr = seg.buf;
+
+    if(fIncludeADUdescriptors) {
+        // The newly-read data is assumed to be an ADU with a descriptor
+        // in front
+        (void)ADUdescriptor::getRemainingFrameSize(fromPtr);
+        seg.descriptorSize = (unsigned)(fromPtr - seg.buf);
+    }
+    else {
+        seg.descriptorSize = 0;
+    }
+
+    // parse the MP3-specific info in the frame to get the ADU params
+    unsigned    hdr;
+    MP3SideInfo sideInfo;
+    if(!GetADUInfoFromMP3Frame(fromPtr, numBytesRead, hdr, seg.frameSize, sideInfo, seg.sideInfoSize, seg.backpointer, seg.aduSize)) {
+        return False;
+    }
+
+    // If we've just read an ADU (rather than a regular MP3 frame), then use the
+    // entire "numBytesRead" data for the 'aduSize', so that we include any
+    // 'ancillary data' that may be present at the end of the ADU:
+    if(!fDirectionIsToADU) {
+        unsigned newADUSize = numBytesRead - seg.descriptorSize - 4 /*header size*/ - seg.sideInfoSize;
+        if(newADUSize > seg.aduSize)
+            seg.aduSize = newADUSize;
+    }
+    fTotalDataSize += seg.dataHere();
+    fNextFreeIndex = nextIndex(fNextFreeIndex);
+
+    return True;
+}
+
+Boolean SegmentQueue::dequeue() {
+    if(isEmpty()) {
+        fUsingSource->envir() << "SegmentQueue::dequeue(): underflow!\n";
+        return False;
+    }
+
+    Segment &seg = s[headIndex()];
+    fTotalDataSize -= seg.dataHere();
+    fHeadIndex = nextIndex(fHeadIndex);
+    return True;
+}
+
+Boolean SegmentQueue::insertDummyBeforeTail(unsigned backpointer) {
+    if(isEmptyOrFull())
+        return False;
+
+    // Copy the current tail segment to its new position, then modify the
+    // old tail segment to be a 'dummy' ADU
+
+    unsigned newTailIndex = nextFreeIndex();
+    Segment &newTailSeg   = s[newTailIndex];
+
+    unsigned oldTailIndex = prevIndex(newTailIndex);
+    Segment &oldTailSeg   = s[oldTailIndex];
+
+    newTailSeg = oldTailSeg;  // structure copy
+
+    // Begin by setting (replacing) the ADU descriptor of the dummy ADU:
+    unsigned char *ptr = oldTailSeg.buf;
+    if(fIncludeADUdescriptors) {
+        unsigned remainingFrameSize    = oldTailSeg.headerSize + oldTailSeg.sideInfoSize + 0 /* 0-size ADU */;
+        unsigned currentDescriptorSize = oldTailSeg.descriptorSize;
+
+        if(currentDescriptorSize == 2) {
+            ADUdescriptor::generateTwoByteDescriptor(ptr, remainingFrameSize);
+        }
+        else {
+            (void)ADUdescriptor::generateDescriptor(ptr, remainingFrameSize);
+        }
+    }
+
+    // Then zero out the side info of the dummy frame:
+    if(!ZeroOutMP3SideInfo(ptr, oldTailSeg.frameSize, backpointer))
+        return False;
+
+    unsigned dummyNumBytesRead = oldTailSeg.descriptorSize + 4 /*header size*/ + oldTailSeg.sideInfoSize;
+    return sqAfterGettingCommon(oldTailSeg, dummyNumBytesRead);
+}
diff --git a/3rdparty/live555/src/liveMedia/MP3ADURTPSink.cpp b/3rdparty/live555/src/liveMedia/MP3ADURTPSink.cpp
new file mode 100644
index 00000000..5c29e7e3
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/MP3ADURTPSink.cpp
@@ -0,0 +1,104 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// RTP sink for 'ADUized' MP3 frames ("mpa-robust")
+// Implementation
+
+#include "MP3ADURTPSink.hh"
+
+MP3ADURTPSink::MP3ADURTPSink(UsageEnvironment &env, Groupsock *RTPgs, unsigned char RTPPayloadType)
+    : AudioRTPSink(env, RTPgs, RTPPayloadType, 90000, "MPA-ROBUST") {}
+
+MP3ADURTPSink::~MP3ADURTPSink() {}
+
+MP3ADURTPSink *MP3ADURTPSink::createNew(UsageEnvironment &env, Groupsock *RTPgs, unsigned char RTPPayloadType) {
+    return new MP3ADURTPSink(env, RTPgs, RTPPayloadType);
+}
+
+static void badDataSize(UsageEnvironment &env, unsigned numBytesInFrame) {
+    env << "MP3ADURTPSink::doSpecialFrameHandling(): invalid size (" << numBytesInFrame << ") of non-fragmented input ADU!\n";
+}
+
+void MP3ADURTPSink::doSpecialFrameHandling(unsigned fragmentationOffset, unsigned char *frameStart, unsigned numBytesInFrame,
+                                           struct timeval framePresentationTime, unsigned numRemainingBytes) {
+    // If this is the first (or only) fragment of an ADU, then
+    // check the "ADU descriptor" (that should be at the front) for validity:
+    if(fragmentationOffset == 0) {
+        unsigned aduDescriptorSize;
+
+        if(numBytesInFrame < 1) {
+            badDataSize(envir(), numBytesInFrame);
+            return;
+        }
+        if(frameStart[0] & 0x40) {
+            // We have a 2-byte ADU descriptor
+            aduDescriptorSize = 2;
+            if(numBytesInFrame < 2) {
+                badDataSize(envir(), numBytesInFrame);
+                return;
+            }
+            fCurADUSize = ((frameStart[0] & ~0xC0) << 8) | frameStart[1];
+        }
+        else {
+            // We have a 1-byte ADU descriptor
+            aduDescriptorSize = 1;
+            fCurADUSize       = frameStart[0] & ~0x80;
+        }
+
+        if(frameStart[0] & 0x80) {
+            envir() << "Unexpected \"C\" bit seen on non-fragment input ADU!\n";
+            return;
+        }
+
+        // Now, check whether the ADU size in the ADU descriptor is consistent
+        // with the total data size of (all fragments of) the input frame:
+        unsigned expectedADUSize = fragmentationOffset + numBytesInFrame + numRemainingBytes - aduDescriptorSize;
+        if(fCurADUSize != expectedADUSize) {
+            envir() << "MP3ADURTPSink::doSpecialFrameHandling(): Warning: Input ADU size " << expectedADUSize << " (=" << fragmentationOffset << "+"
+                    << numBytesInFrame << "+" << numRemainingBytes << "-" << aduDescriptorSize << ") did not match the value (" << fCurADUSize
+                    << ") in the ADU descriptor!\n";
+            fCurADUSize = expectedADUSize;
+        }
+    }
+    else {
+        // This is the second (or subsequent) fragment.
+        // Insert a new ADU descriptor:
+        unsigned char aduDescriptor[2];
+        aduDescriptor[0] = 0xC0 | (fCurADUSize >> 8);
+        aduDescriptor[1] = fCurADUSize & 0xFF;
+        setSpecialHeaderBytes(aduDescriptor, 2);
+    }
+
+    // Important: Also call our base class's doSpecialFrameHandling(),
+    // to set the packet's timestamp:
+    MultiFramedRTPSink::doSpecialFrameHandling(fragmentationOffset, frameStart, numBytesInFrame, framePresentationTime, numRemainingBytes);
+}
+
+unsigned MP3ADURTPSink::specialHeaderSize() const {
+    // Normally there's no special header.
+    // (The "ADU descriptor" is already present in the data.)
+    unsigned specialHeaderSize = 0;
+
+    // However, if we're about to output the second (or subsequent) fragment
+    // of a fragmented ADU, then we need to insert a new ADU descriptor at
+    // the front of the packet:
+    if(curFragmentationOffset() > 0) {
+        specialHeaderSize = 2;
+    }
+
+    return specialHeaderSize;
+}
diff --git a/3rdparty/live555/src/liveMedia/MP3ADURTPSource.cpp b/3rdparty/live555/src/liveMedia/MP3ADURTPSource.cpp
new file mode 100644
index 00000000..971f5a75
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/MP3ADURTPSource.cpp
@@ -0,0 +1,66 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// RTP source for 'ADUized' MP3 frames ("mpa-robust")
+// Implementation
+
+#include "MP3ADURTPSource.hh"
+#include "MP3ADUdescriptor.hh"
+
+////////// ADUBufferedPacket and ADUBufferedPacketFactory //////////
+
+class ADUBufferedPacket : public BufferedPacket {
+private:  // redefined virtual functions
+    virtual unsigned nextEnclosedFrameSize(unsigned char *&framePtr, unsigned dataSize);
+};
+
+class ADUBufferedPacketFactory : public BufferedPacketFactory {
+private:  // redefined virtual functions
+    virtual BufferedPacket *createNewPacket(MultiFramedRTPSource *ourSource);
+};
+
+///////// MP3ADURTPSource implementation ////////
+
+MP3ADURTPSource *MP3ADURTPSource::createNew(UsageEnvironment &env, Groupsock *RTPgs, unsigned char rtpPayloadFormat, unsigned rtpTimestampFrequency) {
+    return new MP3ADURTPSource(env, RTPgs, rtpPayloadFormat, rtpTimestampFrequency);
+}
+
+MP3ADURTPSource::MP3ADURTPSource(UsageEnvironment &env, Groupsock *RTPgs, unsigned char rtpPayloadFormat, unsigned rtpTimestampFrequency)
+    : MultiFramedRTPSource(env, RTPgs, rtpPayloadFormat, rtpTimestampFrequency, new ADUBufferedPacketFactory) {}
+
+MP3ADURTPSource::~MP3ADURTPSource() {}
+
+char const *MP3ADURTPSource::MIMEtype() const {
+    return "audio/MPA-ROBUST";
+}
+
+////////// ADUBufferedPacket and ADUBufferredPacketFactory implementation
+
+unsigned ADUBufferedPacket ::nextEnclosedFrameSize(unsigned char *&framePtr, unsigned dataSize) {
+    // Return the size of the next MP3 'ADU', on the assumption that
+    // the input data is ADU-encoded MP3 frames.
+    unsigned char *frameDataPtr       = framePtr;
+    unsigned       remainingFrameSize = ADUdescriptor::getRemainingFrameSize(frameDataPtr);
+    unsigned       descriptorSize     = (unsigned)(frameDataPtr - framePtr);
+    unsigned       fullADUSize        = descriptorSize + remainingFrameSize;
+
+    return (fullADUSize <= dataSize) ? fullADUSize : dataSize;
+}
+
+BufferedPacket *ADUBufferedPacketFactory ::createNewPacket(MultiFramedRTPSource * /*ourSource*/) {
+    return new ADUBufferedPacket;
+}
diff --git a/3rdparty/live555/src/liveMedia/MP3ADUTranscoder.cpp b/3rdparty/live555/src/liveMedia/MP3ADUTranscoder.cpp
new file mode 100644
index 00000000..0a2487bc
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/MP3ADUTranscoder.cpp
@@ -0,0 +1,75 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// Transcoder for ADUized MP3 frames
+// Implementation
+
+#include "MP3ADUTranscoder.hh"
+#include "MP3Internals.hh"
+#include <string.h>
+
+MP3ADUTranscoder::MP3ADUTranscoder(UsageEnvironment &env, unsigned outBitrate /* in kbps */, FramedSource *inputSource)
+    : FramedFilter(env, inputSource), fOutBitrate(outBitrate), fAvailableBytesForBackpointer(0), fOrigADU(new unsigned char[MAX_MP3_FRAME_SIZE]) {}
+
+MP3ADUTranscoder::~MP3ADUTranscoder() {
+    delete[] fOrigADU;
+}
+
+MP3ADUTranscoder *MP3ADUTranscoder::createNew(UsageEnvironment &env, unsigned outBitrate /* in kbps */, FramedSource *inputSource) {
+    // The source must be an MP3 ADU source:
+    if(strcmp(inputSource->MIMEtype(), "audio/MPA-ROBUST") != 0) {
+        env.setResultMsg(inputSource->name(), " is not an MP3 ADU source");
+        return NULL;
+    }
+
+    return new MP3ADUTranscoder(env, outBitrate, inputSource);
+}
+
+void MP3ADUTranscoder::getAttributes() const {
+    // Begin by getting the attributes from our input source:
+    fInputSource->getAttributes();
+
+    // Then modify them by appending the corrected bandwidth
+    char buffer[30];
+    sprintf(buffer, " bandwidth %d", outBitrate());
+    envir().appendToResultMsg(buffer);
+}
+
+void MP3ADUTranscoder::doGetNextFrame() {
+    fInputSource->getNextFrame(fOrigADU, MAX_MP3_FRAME_SIZE, afterGettingFrame, this, handleClosure, this);
+}
+
+void MP3ADUTranscoder::afterGettingFrame(void *clientData, unsigned numBytesRead, unsigned numTruncatedBytes, struct timeval presentationTime,
+                                         unsigned durationInMicroseconds) {
+    MP3ADUTranscoder *transcoder = (MP3ADUTranscoder *)clientData;
+    transcoder->afterGettingFrame1(numBytesRead, numTruncatedBytes, presentationTime, durationInMicroseconds);
+}
+
+void MP3ADUTranscoder::afterGettingFrame1(unsigned numBytesRead, unsigned numTruncatedBytes, struct timeval presentationTime, unsigned durationInMicroseconds) {
+    fNumTruncatedBytes      = numTruncatedBytes;  // but can we handle this being >0? #####
+    fPresentationTime       = presentationTime;
+    fDurationInMicroseconds = durationInMicroseconds;
+    fFrameSize              = TranscodeMP3ADU(fOrigADU, numBytesRead, fOutBitrate, fTo, fMaxSize, fAvailableBytesForBackpointer);
+    if(fFrameSize == 0) {  // internal error - bad ADU data?
+        handleClosure();
+        return;
+    }
+
+    // Call our own 'after getting' function.  Because we're not a 'leaf'
+    // source, we can call this directly, without risking infinite recursion.
+    afterGetting(this);
+}
diff --git a/3rdparty/live555/src/liveMedia/MP3ADUdescriptor.cpp b/3rdparty/live555/src/liveMedia/MP3ADUdescriptor.cpp
new file mode 100644
index 00000000..3ac1e63b
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/MP3ADUdescriptor.cpp
@@ -0,0 +1,63 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// Descriptor preceding frames of 'ADU' MP3 streams (for improved loss-tolerance)
+// Implementation
+
+#include "MP3ADUdescriptor.hh"
+
+////////// ADUdescriptor //////////
+
+//##### NOTE: For now, ignore fragmentation.  Fix this later! #####
+
+#define TWO_BYTE_DESCR_FLAG 0x40
+
+unsigned ADUdescriptor::generateDescriptor(unsigned char *&toPtr, unsigned remainingFrameSize) {
+    unsigned descriptorSize = ADUdescriptor::computeSize(remainingFrameSize);
+    switch(descriptorSize) {
+    case 1: {
+        *toPtr++ = (unsigned char)remainingFrameSize;
+        break;
+    }
+    case 2: {
+        generateTwoByteDescriptor(toPtr, remainingFrameSize);
+        break;
+    }
+    }
+
+    return descriptorSize;
+}
+
+void ADUdescriptor::generateTwoByteDescriptor(unsigned char *&toPtr, unsigned remainingFrameSize) {
+    *toPtr++ = (TWO_BYTE_DESCR_FLAG | (unsigned char)(remainingFrameSize >> 8));
+    *toPtr++ = (unsigned char)(remainingFrameSize & 0xFF);
+}
+
+unsigned ADUdescriptor::getRemainingFrameSize(unsigned char *&fromPtr) {
+    unsigned char firstByte = *fromPtr++;
+
+    if(firstByte & TWO_BYTE_DESCR_FLAG) {
+        // This is a 2-byte descriptor
+        unsigned char secondByte = *fromPtr++;
+
+        return ((firstByte & 0x3F) << 8) | secondByte;
+    }
+    else {
+        // This is a 1-byte descriptor
+        return (firstByte & 0x3F);
+    }
+}
diff --git a/3rdparty/live555/src/liveMedia/MP3ADUdescriptor.hh b/3rdparty/live555/src/liveMedia/MP3ADUdescriptor.hh
new file mode 100644
index 00000000..ce415b42
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/MP3ADUdescriptor.hh
@@ -0,0 +1,43 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// Descriptor preceding frames of 'ADU' MP3 streams (for improved loss-tolerance)
+// C++ header
+
+#ifndef _MP3_ADU_DESCRIPTOR_HH
+#define _MP3_ADU_DESCRIPTOR_HH
+
+// A class for handling the descriptor that begins each ADU frame:
+//   (Note: We don't yet implement fragmentation)
+class ADUdescriptor {
+public:
+  // Operations for generating a new descriptor
+  static unsigned computeSize(unsigned remainingFrameSize) {
+    return remainingFrameSize >= 64 ? 2 : 1;
+  }
+  static unsigned generateDescriptor(unsigned char*& toPtr, unsigned remainingFrameSize);
+   // returns descriptor size; increments "toPtr" afterwards
+  static void generateTwoByteDescriptor(unsigned char*& toPtr, unsigned remainingFrameSize);
+   // always generates a 2-byte descriptor, even if "remainingFrameSize" is
+   // small enough for a 1-byte descriptor
+
+  // Operations for reading a descriptor
+  static unsigned getRemainingFrameSize(unsigned char*& fromPtr);
+   // increments "fromPtr" afterwards
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/MP3ADUinterleaving.cpp b/3rdparty/live555/src/liveMedia/MP3ADUinterleaving.cpp
new file mode 100644
index 00000000..b4f70bc8
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/MP3ADUinterleaving.cpp
@@ -0,0 +1,459 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// Interleaving of MP3 ADUs
+// Implementation
+
+#include "MP3ADUinterleaving.hh"
+#include "MP3ADUdescriptor.hh"
+
+#include <string.h>
+
+#ifdef TEST_LOSS
+#include "GroupsockHelper.hh"
+#endif
+
+////////// Interleaving //////////
+
+Interleaving::Interleaving(unsigned cycleSize, unsigned char const *cycleArray) : fCycleSize(cycleSize) {
+    for(unsigned i = 0; i < fCycleSize; ++i) {
+        fInverseCycle[cycleArray[i]] = i;
+    }
+}
+
+Interleaving::~Interleaving() {}
+
+////////// MP3ADUinterleaverBase //////////
+
+MP3ADUinterleaverBase::MP3ADUinterleaverBase(UsageEnvironment &env, FramedSource *inputSource) : FramedFilter(env, inputSource) {}
+MP3ADUinterleaverBase::~MP3ADUinterleaverBase() {}
+
+FramedSource *MP3ADUinterleaverBase::getInputSource(UsageEnvironment &env, char const *inputSourceName) {
+    FramedSource *inputSource;
+    if(!FramedSource::lookupByName(env, inputSourceName, inputSource))
+        return NULL;
+
+    if(strcmp(inputSource->MIMEtype(), "audio/MPA-ROBUST") != 0) {
+        env.setResultMsg(inputSourceName, " is not an MP3 ADU source");
+        return NULL;
+    }
+
+    return inputSource;
+}
+
+void MP3ADUinterleaverBase::afterGettingFrame(void *clientData, unsigned numBytesRead, unsigned /*numTruncatedBytes*/, struct timeval presentationTime,
+                                              unsigned durationInMicroseconds) {
+    MP3ADUinterleaverBase *interleaverBase = (MP3ADUinterleaverBase *)clientData;
+    // Finish up after reading:
+    interleaverBase->afterGettingFrame(numBytesRead, presentationTime, durationInMicroseconds);
+
+    // Then, continue to deliver an outgoing frame:
+    interleaverBase->doGetNextFrame();
+}
+
+////////// InterleavingFrames (definition) //////////
+
+class InterleavingFrames {
+public:
+    InterleavingFrames(unsigned maxCycleSize);
+    virtual ~InterleavingFrames();
+
+    Boolean  haveReleaseableFrame();
+    void     getIncomingFrameParams(unsigned char index, unsigned char *&dataPtr, unsigned &bytesAvailable);
+    void     getReleasingFrameParams(unsigned char index, unsigned char *&dataPtr, unsigned &bytesInUse, struct timeval &presentationTime,
+                                     unsigned &durationInMicroseconds);
+    void     setFrameParams(unsigned char index, unsigned char icc, unsigned char ii, unsigned frameSize, struct timeval presentationTime,
+                            unsigned durationInMicroseconds);
+    unsigned nextIndexToRelease() {
+        return fNextIndexToRelease;
+    }
+    void releaseNext();
+
+private:
+    unsigned                           fMaxCycleSize;
+    unsigned                           fNextIndexToRelease;
+    class InterleavingFrameDescriptor *fDescriptors;
+};
+
+////////// MP3ADUinterleaver //////////
+
+MP3ADUinterleaver::MP3ADUinterleaver(UsageEnvironment &env, Interleaving const &interleaving, FramedSource *inputSource)
+    : MP3ADUinterleaverBase(env, inputSource), fInterleaving(interleaving), fFrames(new InterleavingFrames(interleaving.cycleSize())), fII(0), fICC(0) {}
+
+MP3ADUinterleaver::~MP3ADUinterleaver() {
+    delete fFrames;
+}
+
+MP3ADUinterleaver *MP3ADUinterleaver::createNew(UsageEnvironment &env, Interleaving const &interleaving, FramedSource *inputSource) {
+    return new MP3ADUinterleaver(env, interleaving, inputSource);
+}
+
+void MP3ADUinterleaver::doGetNextFrame() {
+    // If there's a frame immediately available, deliver it, otherwise get new
+    // frames from the source until one's available:
+    if(fFrames->haveReleaseableFrame()) {
+        releaseOutgoingFrame();
+
+        // Call our own 'after getting' function.  Because we're not a 'leaf'
+        // source, we can call this directly, without risking infinite recursion.
+        afterGetting(this);
+    }
+    else {
+        fPositionOfNextIncomingFrame = fInterleaving.lookupInverseCycle(fII);
+        unsigned char *dataPtr;
+        unsigned       bytesAvailable;
+        fFrames->getIncomingFrameParams(fPositionOfNextIncomingFrame, dataPtr, bytesAvailable);
+
+        // Read the next incoming frame (asynchronously)
+        fInputSource->getNextFrame(dataPtr, bytesAvailable, &MP3ADUinterleaverBase::afterGettingFrame, this, handleClosure, this);
+    }
+}
+
+void MP3ADUinterleaver::releaseOutgoingFrame() {
+    unsigned char *fromPtr;
+    fFrames->getReleasingFrameParams(fFrames->nextIndexToRelease(), fromPtr, fFrameSize, fPresentationTime, fDurationInMicroseconds);
+
+    if(fFrameSize > fMaxSize) {
+        fNumTruncatedBytes = fFrameSize - fMaxSize;
+        fFrameSize         = fMaxSize;
+    }
+    memmove(fTo, fromPtr, fFrameSize);
+
+    fFrames->releaseNext();
+}
+
+void MP3ADUinterleaver::afterGettingFrame(unsigned numBytesRead, struct timeval presentationTime, unsigned durationInMicroseconds) {
+    // Set the (icc,ii) and frame size of the newly-read frame:
+    fFrames->setFrameParams(fPositionOfNextIncomingFrame, fICC, fII, numBytesRead, presentationTime, durationInMicroseconds);
+
+    // Prepare our counters for the next frame:
+    if(++fII == fInterleaving.cycleSize()) {
+        fII  = 0;
+        fICC = (fICC + 1) % 8;
+    }
+}
+
+////////// DeinterleavingFrames (definition) //////////
+
+class DeinterleavingFrames {
+public:
+    DeinterleavingFrames();
+    virtual ~DeinterleavingFrames();
+
+    Boolean haveReleaseableFrame();
+    void    getIncomingFrameParams(unsigned char *&dataPtr, unsigned &bytesAvailable);
+    void    getIncomingFrameParamsAfter(unsigned frameSize, struct timeval presentationTime, unsigned durationInMicroseconds, unsigned char &icc,
+                                        unsigned char &ii);
+    void    getReleasingFrameParams(unsigned char *&dataPtr, unsigned &bytesInUse, struct timeval &presentationTime, unsigned &durationInMicroseconds);
+    void    moveIncomingFrameIntoPlace();
+    void    releaseNext();
+    void    startNewCycle();
+
+private:
+    unsigned                             fNextIndexToRelease;
+    Boolean                              fHaveEndedCycle;
+    unsigned                             fIIlastSeen;
+    unsigned                             fMinIndexSeen, fMaxIndexSeen;  // actually, max+1
+    class DeinterleavingFrameDescriptor *fDescriptors;
+};
+
+////////// MP3ADUdeinterleaver //////////
+
+MP3ADUdeinterleaver::MP3ADUdeinterleaver(UsageEnvironment &env, FramedSource *inputSource)
+    : MP3ADUinterleaverBase(env, inputSource), fFrames(new DeinterleavingFrames), fIIlastSeen(~0), fICClastSeen(~0) {}
+
+MP3ADUdeinterleaver::~MP3ADUdeinterleaver() {
+    delete fFrames;
+}
+
+MP3ADUdeinterleaver *MP3ADUdeinterleaver::createNew(UsageEnvironment &env, FramedSource *inputSource) {
+    return new MP3ADUdeinterleaver(env, inputSource);
+}
+
+void MP3ADUdeinterleaver::doGetNextFrame() {
+    // If there's a frame immediately available, deliver it, otherwise get new
+    // frames from the source until one's available:
+    if(fFrames->haveReleaseableFrame()) {
+        releaseOutgoingFrame();
+
+        // Call our own 'after getting' function.  Because we're not a 'leaf'
+        // source, we can call this directly, without risking infinite recursion.
+        afterGetting(this);
+    }
+    else {
+#ifdef TEST_LOSS
+    NOTE:
+        This code no longer works, because it uses synchronous reads, which are no longer supported.static unsigned const framesPerPacket = 3;
+        static unsigned const frameCount = 0;
+        static Boolean        packetIsLost;
+        while(1) {
+            unsigned packetCount = frameCount / framesPerPacket;
+            if((frameCount++) % framesPerPacket == 0) {
+                packetIsLost = (our_random() % 10 == 0);  // simulate 10% packet loss #####
+            }
+
+            if(packetIsLost) {
+                // Read and discard the next input frame (that would be part of
+                // a lost packet):
+                unsigned char  dummyBuf[2000];
+                unsigned       numBytesRead;
+                struct timeval presentationTime;
+                // (this works only if the source can be read synchronously)
+                fInputSource->syncGetNextFrame(dummyBuf, sizeof dummyBuf, numBytesRead, presentationTime);
+            }
+            else {
+                break;  // from while (1)
+            }
+        }
+#endif
+        unsigned char *dataPtr;
+        unsigned       bytesAvailable;
+        fFrames->getIncomingFrameParams(dataPtr, bytesAvailable);
+
+        // Read the next incoming frame (asynchronously)
+        fInputSource->getNextFrame(dataPtr, bytesAvailable, &MP3ADUinterleaverBase::afterGettingFrame, this, handleClosure, this);
+    }
+}
+
+void MP3ADUdeinterleaver::afterGettingFrame(unsigned numBytesRead, struct timeval presentationTime, unsigned durationInMicroseconds) {
+    // Get the (icc,ii) and set the frame size of the newly-read frame:
+    unsigned char icc, ii;
+    fFrames->getIncomingFrameParamsAfter(numBytesRead, presentationTime, durationInMicroseconds, icc, ii);
+
+    // Compare these to the values we saw last:
+    if(icc != fICClastSeen || ii == fIIlastSeen) {
+        // We've started a new interleave cycle
+        // (or interleaving was not used).  Release all
+        // pending ADU frames to the ADU->MP3 conversion step:
+        fFrames->startNewCycle();
+    }
+    else {
+        // We're still in the same cycle as before.
+        // Move the newly-read frame into place, so it can be used:
+        fFrames->moveIncomingFrameIntoPlace();
+    }
+
+    fICClastSeen = icc;
+    fIIlastSeen  = ii;
+}
+
+void MP3ADUdeinterleaver::releaseOutgoingFrame() {
+    unsigned char *fromPtr;
+    fFrames->getReleasingFrameParams(fromPtr, fFrameSize, fPresentationTime, fDurationInMicroseconds);
+
+    if(fFrameSize > fMaxSize) {
+        fNumTruncatedBytes = fFrameSize - fMaxSize;
+        fFrameSize         = fMaxSize;
+    }
+    memmove(fTo, fromPtr, fFrameSize);
+
+    fFrames->releaseNext();
+}
+
+////////// InterleavingFrames (implementation) //////////
+
+#define MAX_FRAME_SIZE 2000 /* conservatively high */
+
+class InterleavingFrameDescriptor {
+public:
+    InterleavingFrameDescriptor() {
+        frameDataSize = 0;
+    }
+
+    unsigned       frameDataSize;  // includes ADU descriptor and (modified) MPEG hdr
+    struct timeval presentationTime;
+    unsigned       durationInMicroseconds;
+    unsigned char  frameData[MAX_FRAME_SIZE];  // ditto
+};
+
+InterleavingFrames::InterleavingFrames(unsigned maxCycleSize)
+    : fMaxCycleSize(maxCycleSize), fNextIndexToRelease(0), fDescriptors(new InterleavingFrameDescriptor[maxCycleSize]) {}
+InterleavingFrames::~InterleavingFrames() {
+    delete[] fDescriptors;
+}
+
+Boolean InterleavingFrames::haveReleaseableFrame() {
+    return fDescriptors[fNextIndexToRelease].frameDataSize > 0;
+}
+
+void InterleavingFrames::getIncomingFrameParams(unsigned char index, unsigned char *&dataPtr, unsigned &bytesAvailable) {
+    InterleavingFrameDescriptor &desc = fDescriptors[index];
+    dataPtr                           = &desc.frameData[0];
+    bytesAvailable                    = MAX_FRAME_SIZE;
+}
+
+void InterleavingFrames::getReleasingFrameParams(unsigned char index, unsigned char *&dataPtr, unsigned &bytesInUse, struct timeval &presentationTime,
+                                                 unsigned &durationInMicroseconds) {
+    InterleavingFrameDescriptor &desc = fDescriptors[index];
+    dataPtr                           = &desc.frameData[0];
+    bytesInUse                        = desc.frameDataSize;
+    presentationTime                  = desc.presentationTime;
+    durationInMicroseconds            = desc.durationInMicroseconds;
+}
+
+void InterleavingFrames::setFrameParams(unsigned char index, unsigned char icc, unsigned char ii, unsigned frameSize, struct timeval presentationTime,
+                                        unsigned durationInMicroseconds) {
+    InterleavingFrameDescriptor &desc = fDescriptors[index];
+    desc.frameDataSize                = frameSize;
+    desc.presentationTime             = presentationTime;
+    desc.durationInMicroseconds       = durationInMicroseconds;
+
+    // Advance over the ADU descriptor, to get to the MPEG 'syncword':
+    unsigned char *ptr = &desc.frameData[0];
+    (void)ADUdescriptor::getRemainingFrameSize(ptr);
+
+    // Replace the next 11 bits with (ii,icc):
+    *ptr++ = ii;
+    *ptr &= ~0xE0;
+    *ptr |= (icc << 5);
+}
+
+void InterleavingFrames::releaseNext() {
+    fDescriptors[fNextIndexToRelease].frameDataSize = 0;
+    fNextIndexToRelease                             = (fNextIndexToRelease + 1) % fMaxCycleSize;
+}
+
+////////// DeinterleavingFrames (implementation) //////////
+
+class DeinterleavingFrameDescriptor {
+public:
+    DeinterleavingFrameDescriptor() {
+        frameDataSize = 0;
+        frameData     = NULL;
+    }
+    virtual ~DeinterleavingFrameDescriptor() {
+        delete[] frameData;
+    }
+
+    unsigned       frameDataSize;  // includes ADU descriptor and (modified) MPEG hdr
+    struct timeval presentationTime;
+    unsigned       durationInMicroseconds;
+    unsigned char *frameData;
+};
+
+DeinterleavingFrames::DeinterleavingFrames()
+    : fNextIndexToRelease(0),
+      fHaveEndedCycle(False),
+      fMinIndexSeen(MAX_CYCLE_SIZE),
+      fMaxIndexSeen(0),
+      fDescriptors(new DeinterleavingFrameDescriptor[MAX_CYCLE_SIZE + 1]) {}
+DeinterleavingFrames::~DeinterleavingFrames() {
+    delete[] fDescriptors;
+}
+
+Boolean DeinterleavingFrames::haveReleaseableFrame() {
+    if(!fHaveEndedCycle) {
+        // Check just the next frame in the sequence
+        return fDescriptors[fNextIndexToRelease].frameDataSize > 0;
+    }
+    else {
+        // We've just ended a cycle, so we can skip over frames that didn't
+        // get filled in (due to packet loss):
+        if(fNextIndexToRelease < fMinIndexSeen) {
+            fNextIndexToRelease = fMinIndexSeen;
+        }
+        while(fNextIndexToRelease < fMaxIndexSeen && fDescriptors[fNextIndexToRelease].frameDataSize == 0) {
+            ++fNextIndexToRelease;
+        }
+        if(fNextIndexToRelease >= fMaxIndexSeen) {
+            // No more frames are available from the cycle that we just ended, so
+            // clear out all previously stored frames, then make available
+            // the last-read frame, and return false for now:
+            for(unsigned i = fMinIndexSeen; i < fMaxIndexSeen; ++i) {
+                fDescriptors[i].frameDataSize = 0;
+            }
+
+            fMinIndexSeen = MAX_CYCLE_SIZE;
+            fMaxIndexSeen = 0;
+            moveIncomingFrameIntoPlace();
+
+            fHaveEndedCycle     = False;
+            fNextIndexToRelease = 0;
+            return False;
+        }
+
+        return True;
+    }
+}
+
+void DeinterleavingFrames::getIncomingFrameParams(unsigned char *&dataPtr, unsigned &bytesAvailable) {
+    // Use fDescriptors[MAX_CYCLE_SIZE] to store the incoming frame,
+    // prior to figuring out its real position:
+    DeinterleavingFrameDescriptor &desc = fDescriptors[MAX_CYCLE_SIZE];
+    if(desc.frameData == NULL) {
+        // There's no buffer yet, so allocate a new one:
+        desc.frameData = new unsigned char[MAX_FRAME_SIZE];
+    }
+    dataPtr        = desc.frameData;
+    bytesAvailable = MAX_FRAME_SIZE;
+}
+
+void DeinterleavingFrames ::getIncomingFrameParamsAfter(unsigned frameSize, struct timeval presentationTime, unsigned durationInMicroseconds,
+                                                        unsigned char &icc, unsigned char &ii) {
+    DeinterleavingFrameDescriptor &desc = fDescriptors[MAX_CYCLE_SIZE];
+    desc.frameDataSize                  = frameSize;
+    desc.presentationTime               = presentationTime;
+    desc.durationInMicroseconds         = durationInMicroseconds;
+
+    // Advance over the ADU descriptor, to get to the MPEG 'syncword':
+    unsigned char *ptr = desc.frameData;
+    (void)ADUdescriptor::getRemainingFrameSize(ptr);
+
+    // Read the next 11 bits into (ii,icc), and replace them with all-1s:
+    fIIlastSeen = ii = *ptr;
+    *ptr++           = 0xFF;
+    icc              = (*ptr & 0xE0) >> 5;
+    *ptr |= 0xE0;
+}
+
+void DeinterleavingFrames::getReleasingFrameParams(unsigned char *&dataPtr, unsigned &bytesInUse, struct timeval &presentationTime,
+                                                   unsigned &durationInMicroseconds) {
+    DeinterleavingFrameDescriptor &desc = fDescriptors[fNextIndexToRelease];
+    dataPtr                             = desc.frameData;
+    bytesInUse                          = desc.frameDataSize;
+    presentationTime                    = desc.presentationTime;
+    durationInMicroseconds              = desc.durationInMicroseconds;
+}
+
+void DeinterleavingFrames::moveIncomingFrameIntoPlace() {
+    DeinterleavingFrameDescriptor &fromDesc = fDescriptors[MAX_CYCLE_SIZE];
+    DeinterleavingFrameDescriptor &toDesc   = fDescriptors[fIIlastSeen];
+
+    toDesc.frameDataSize    = fromDesc.frameDataSize;
+    toDesc.presentationTime = fromDesc.presentationTime;
+
+    // Move the data pointer into place by swapping the data pointers:
+    unsigned char *tmp = toDesc.frameData;
+    toDesc.frameData   = fromDesc.frameData;
+    fromDesc.frameData = tmp;
+
+    if(fIIlastSeen < fMinIndexSeen) {
+        fMinIndexSeen = fIIlastSeen;
+    }
+    if(fIIlastSeen + 1 > fMaxIndexSeen) {
+        fMaxIndexSeen = fIIlastSeen + 1;
+    }
+}
+
+void DeinterleavingFrames::releaseNext() {
+    fDescriptors[fNextIndexToRelease].frameDataSize = 0;
+    fNextIndexToRelease                             = (fNextIndexToRelease + 1) % MAX_CYCLE_SIZE;
+}
+
+void DeinterleavingFrames::startNewCycle() {
+    fHaveEndedCycle = True;
+}
diff --git a/3rdparty/live555/src/liveMedia/MP3AudioFileServerMediaSubsession.cpp b/3rdparty/live555/src/liveMedia/MP3AudioFileServerMediaSubsession.cpp
new file mode 100644
index 00000000..3a8d566f
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/MP3AudioFileServerMediaSubsession.cpp
@@ -0,0 +1,178 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A 'ServerMediaSubsession' object that creates new, unicast, "RTPSink"s
+// on demand, from a MP3 audio file.
+// (Actually, any MPEG-1 or MPEG-2 audio file should work.)
+// Implementation
+
+#include "MP3AudioFileServerMediaSubsession.hh"
+#include "MPEG1or2AudioRTPSink.hh"
+#include "MP3ADURTPSink.hh"
+#include "MP3FileSource.hh"
+#include "MP3ADU.hh"
+
+MP3AudioFileServerMediaSubsession *MP3AudioFileServerMediaSubsession ::createNew(UsageEnvironment &env, char const *fileName, Boolean reuseFirstSource,
+                                                                                 Boolean generateADUs, Interleaving *interleaving) {
+    return new MP3AudioFileServerMediaSubsession(env, fileName, reuseFirstSource, generateADUs, interleaving);
+}
+
+MP3AudioFileServerMediaSubsession ::MP3AudioFileServerMediaSubsession(UsageEnvironment &env, char const *fileName, Boolean reuseFirstSource,
+                                                                      Boolean generateADUs, Interleaving *interleaving)
+    : FileServerMediaSubsession(env, fileName, reuseFirstSource), fGenerateADUs(generateADUs), fInterleaving(interleaving), fFileDuration(0.0) {}
+
+MP3AudioFileServerMediaSubsession ::~MP3AudioFileServerMediaSubsession() {
+    delete fInterleaving;
+}
+
+FramedSource *MP3AudioFileServerMediaSubsession ::createNewStreamSourceCommon(FramedSource *baseMP3Source, unsigned mp3NumBytes, unsigned &estBitrate) {
+    FramedSource *streamSource;
+    do {
+        streamSource = baseMP3Source;  // by default
+        if(streamSource == NULL)
+            break;
+
+        // Use the MP3 file size, plus the duration, to estimate the stream's bitrate:
+        if(mp3NumBytes > 0 && fFileDuration > 0.0) {
+            estBitrate = (unsigned)(mp3NumBytes / (125 * fFileDuration) + 0.5);  // kbps, rounded
+            if(estBitrate == 0)
+                estBitrate = 128;  // kbps, estimate
+        }
+        else {
+            estBitrate = 128;  // kbps, estimate
+        }
+
+        if(fGenerateADUs) {
+            // Add a filter that converts the source MP3s to ADUs:
+            streamSource = ADUFromMP3Source::createNew(envir(), streamSource);
+            if(streamSource == NULL)
+                break;
+
+            if(fInterleaving != NULL) {
+                // Add another filter that interleaves the ADUs before packetizing:
+                streamSource = MP3ADUinterleaver::createNew(envir(), *fInterleaving, streamSource);
+                if(streamSource == NULL)
+                    break;
+            }
+        }
+        else if(fFileDuration > 0.0) {
+            // Because this is a seekable file, insert a pair of filters: one that
+            // converts the input MP3 stream to ADUs; another that converts these
+            // ADUs back to MP3.  This allows us to seek within the input stream without
+            // tripping over the MP3 'bit reservoir':
+            streamSource = ADUFromMP3Source::createNew(envir(), streamSource);
+            if(streamSource == NULL)
+                break;
+
+            streamSource = MP3FromADUSource::createNew(envir(), streamSource);
+            if(streamSource == NULL)
+                break;
+        }
+    } while(0);
+
+    return streamSource;
+}
+
+void MP3AudioFileServerMediaSubsession::getBaseStreams(FramedSource *frontStream, FramedSource *&sourceMP3Stream, ADUFromMP3Source *&aduStream /*if any*/) {
+    if(fGenerateADUs) {
+        // There's an ADU stream.
+        if(fInterleaving != NULL) {
+            // There's an interleaving filter in front of the ADU stream.  So go back one, to reach the ADU stream:
+            aduStream = (ADUFromMP3Source *)(((FramedFilter *)frontStream)->inputSource());
+        }
+        else {
+            aduStream = (ADUFromMP3Source *)frontStream;
+        }
+
+        // Then, go back one more, to reach the MP3 source:
+        sourceMP3Stream = (MP3FileSource *)(aduStream->inputSource());
+    }
+    else if(fFileDuration > 0.0) {
+        // There are a pair of filters - MP3->ADU and ADU->MP3 - in front of the
+        // original MP3 source.  So, go back one, to reach the ADU source:
+        aduStream = (ADUFromMP3Source *)(((FramedFilter *)frontStream)->inputSource());
+
+        // Then, go back one more, to reach the MP3 source:
+        sourceMP3Stream = (MP3FileSource *)(aduStream->inputSource());
+    }
+    else {
+        // There's no filter in front of the source MP3 stream (and there's no ADU stream):
+        aduStream       = NULL;
+        sourceMP3Stream = frontStream;
+    }
+}
+
+void MP3AudioFileServerMediaSubsession ::seekStreamSource(FramedSource *inputSource, double &seekNPT, double streamDuration, u_int64_t & /*numBytes*/) {
+    FramedSource *    sourceMP3Stream;
+    ADUFromMP3Source *aduStream;
+    getBaseStreams(inputSource, sourceMP3Stream, aduStream);
+
+    if(aduStream != NULL)
+        aduStream->resetInput();  // because we're about to seek within its source
+    ((MP3FileSource *)sourceMP3Stream)->seekWithinFile(seekNPT, streamDuration);
+}
+
+void MP3AudioFileServerMediaSubsession ::setStreamSourceScale(FramedSource *inputSource, float scale) {
+
+    FramedSource *    sourceMP3Stream;
+    ADUFromMP3Source *aduStream;
+    getBaseStreams(inputSource, sourceMP3Stream, aduStream);
+
+    if(aduStream == NULL)
+        return;  // because, in this case, the stream's not scalable
+
+    int iScale = (int)scale;
+    aduStream->setScaleFactor(iScale);
+    ((MP3FileSource *)sourceMP3Stream)->setPresentationTimeScale(iScale);
+}
+
+FramedSource *MP3AudioFileServerMediaSubsession ::createNewStreamSource(unsigned /*clientSessionId*/, unsigned &estBitrate) {
+    MP3FileSource *mp3Source = MP3FileSource::createNew(envir(), fFileName);
+    if(mp3Source == NULL)
+        return NULL;
+    fFileDuration = mp3Source->filePlayTime();
+
+    return createNewStreamSourceCommon(mp3Source, mp3Source->fileSize(), estBitrate);
+}
+
+RTPSink *MP3AudioFileServerMediaSubsession ::createNewRTPSink(Groupsock *rtpGroupsock, unsigned char rtpPayloadTypeIfDynamic, FramedSource * /*inputSource*/) {
+    if(fGenerateADUs) {
+        return MP3ADURTPSink::createNew(envir(), rtpGroupsock, rtpPayloadTypeIfDynamic);
+    }
+    else {
+        return MPEG1or2AudioRTPSink::createNew(envir(), rtpGroupsock);
+    }
+}
+
+void MP3AudioFileServerMediaSubsession::testScaleFactor(float &scale) {
+    if(fFileDuration <= 0.0) {
+        // The file is non-seekable, so is probably a live input source.
+        // We don't support scale factors other than 1
+        scale = 1;
+    }
+    else {
+        // We support any integral scale >= 1
+        int iScale = (int)(scale + 0.5);  // round
+        if(iScale < 1)
+            iScale = 1;
+        scale = (float)iScale;
+    }
+}
+
+float MP3AudioFileServerMediaSubsession::duration() const {
+    return fFileDuration;
+}
diff --git a/3rdparty/live555/src/liveMedia/MP3AudioMatroskaFileServerMediaSubsession.cpp b/3rdparty/live555/src/liveMedia/MP3AudioMatroskaFileServerMediaSubsession.cpp
new file mode 100644
index 00000000..2e6a6f14
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/MP3AudioMatroskaFileServerMediaSubsession.cpp
@@ -0,0 +1,56 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A 'ServerMediaSubsession' object that creates new, unicast, "RTPSink"s
+// on demand, from an MP3 audio track within a Matroska file.
+// (Actually, MPEG-1 or MPEG-2 audio file should also work.)
+// Implementation
+
+#include "FileServerMediaSubsession.hh"
+#include "MP3AudioMatroskaFileServerMediaSubsession.hh"
+#include "MatroskaDemuxedTrack.hh"
+
+MP3AudioMatroskaFileServerMediaSubsession *MP3AudioMatroskaFileServerMediaSubsession ::createNew(MatroskaFileServerDemux &demux, MatroskaTrack *track,
+                                                                                                 Boolean generateADUs, Interleaving *interleaving) {
+    return new MP3AudioMatroskaFileServerMediaSubsession(demux, track, generateADUs, interleaving);
+}
+
+MP3AudioMatroskaFileServerMediaSubsession ::MP3AudioMatroskaFileServerMediaSubsession(MatroskaFileServerDemux &demux, MatroskaTrack *track,
+                                                                                      Boolean generateADUs, Interleaving *interleaving)
+    : MP3AudioFileServerMediaSubsession(demux.envir(), demux.fileName(), False, generateADUs, interleaving),
+      fOurDemux(demux),
+      fTrackNumber(track->trackNumber) {
+    fFileDuration = fOurDemux.fileDuration();
+}
+
+MP3AudioMatroskaFileServerMediaSubsession::~MP3AudioMatroskaFileServerMediaSubsession() {}
+
+void MP3AudioMatroskaFileServerMediaSubsession ::seekStreamSource(FramedSource *inputSource, double &seekNPT, double /*streamDuration*/,
+                                                                  u_int64_t & /*numBytes*/) {
+    FramedSource *    sourceMP3Stream;
+    ADUFromMP3Source *aduStream;
+    getBaseStreams(inputSource, sourceMP3Stream, aduStream);
+
+    if(aduStream != NULL)
+        aduStream->resetInput();  // because we're about to seek within its source
+    ((MatroskaDemuxedTrack *)sourceMP3Stream)->seekToTime(seekNPT);
+}
+
+FramedSource *MP3AudioMatroskaFileServerMediaSubsession ::createNewStreamSource(unsigned clientSessionId, unsigned &estBitrate) {
+    FramedSource *baseMP3Source = fOurDemux.newDemuxedTrack(clientSessionId, fTrackNumber);
+    return createNewStreamSourceCommon(baseMP3Source, 0, estBitrate);
+}
diff --git a/3rdparty/live555/src/liveMedia/MP3AudioMatroskaFileServerMediaSubsession.hh b/3rdparty/live555/src/liveMedia/MP3AudioMatroskaFileServerMediaSubsession.hh
new file mode 100644
index 00000000..f9f15bac
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/MP3AudioMatroskaFileServerMediaSubsession.hh
@@ -0,0 +1,57 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A 'ServerMediaSubsession' object that creates new, unicast, "RTPSink"s
+// on demand, from an MP3 audio track within a Matroska file.
+// (Actually, MPEG-1 or MPEG-2 audio should also work.)
+// C++ header
+
+#ifndef _MP3_AUDIO_MATROSKA_FILE_SERVER_MEDIA_SUBSESSION_HH
+#define _MP3_AUDIO_MATROSKA_FILE_SERVER_MEDIA_SUBSESSION_HH
+
+#ifndef _MP3_AUDIO_FILE_SERVER_MEDIA_SUBSESSION_HH
+#include "MP3AudioFileServerMediaSubsession.hh"
+#endif
+#ifndef _MATROSKA_FILE_SERVER_DEMUX_HH
+#include "MatroskaFileServerDemux.hh"
+#endif
+
+class MP3AudioMatroskaFileServerMediaSubsession: public MP3AudioFileServerMediaSubsession {
+public:
+  static MP3AudioMatroskaFileServerMediaSubsession*
+  createNew(MatroskaFileServerDemux& demux, MatroskaTrack* track,
+	    Boolean generateADUs = False, Interleaving* interleaving = NULL);
+      // Note: "interleaving" is used only if "generateADUs" is True,
+      // (and a value of NULL means 'no interleaving')
+
+private:
+  MP3AudioMatroskaFileServerMediaSubsession(MatroskaFileServerDemux& demux, MatroskaTrack* track,
+					    Boolean generateADUs, Interleaving* interleaving);
+      // called only by createNew();
+  virtual ~MP3AudioMatroskaFileServerMediaSubsession();
+
+private: // redefined virtual functions
+  virtual void seekStreamSource(FramedSource* inputSource, double& seekNPT, double streamDuration, u_int64_t& numBytes);
+  virtual FramedSource* createNewStreamSource(unsigned clientSessionId,
+                                              unsigned& estBitrate);
+
+private:
+  MatroskaFileServerDemux& fOurDemux;
+  unsigned fTrackNumber;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/MP3FileSource.cpp b/3rdparty/live555/src/liveMedia/MP3FileSource.cpp
new file mode 100644
index 00000000..eb4ab499
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/MP3FileSource.cpp
@@ -0,0 +1,203 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// MP3 File Sources
+// Implementation
+
+#include "MP3FileSource.hh"
+#include "MP3StreamState.hh"
+#include "InputFile.hh"
+
+////////// MP3FileSource //////////
+
+MP3FileSource *MP3FileSource::createNew(UsageEnvironment &env, char const *fileName) {
+    MP3FileSource *newSource = NULL;
+
+    do {
+        FILE *fid;
+
+        fid = OpenInputFile(env, fileName);
+        if(fid == NULL)
+            break;
+
+        newSource = new MP3FileSource(env, fid);
+        if(newSource == NULL)
+            break;
+
+        unsigned fileSize = (unsigned)GetFileSize(fileName, fid);
+        newSource->assignStream(fid, fileSize);
+
+        return newSource;
+    } while(0);
+
+    Medium::close(newSource);
+    return NULL;
+}
+
+MP3FileSource::MP3FileSource(UsageEnvironment &env, FILE *fid)
+    : FramedFileSource(env, fid),
+      fStreamState(new MP3StreamState),
+      fHaveStartedReading(False),
+      fHaveBeenInitialized(False),
+      fLimitNumBytesToStream(False),
+      fNumBytesToStream(0) {
+    //###### We can't make the socket non-blocking yet, because we still do synchronous reads
+    //###### on it (to find MP3 headers).  Later, fix this.
+    // makeSocketNonBlocking(fileno(fFid));
+
+    // Test whether the file is seekable
+    fFidIsSeekable = FileIsSeekable(fFid);
+}
+
+MP3FileSource::~MP3FileSource() {
+    if(fFid != NULL)
+        envir().taskScheduler().turnOffBackgroundReadHandling(fileno(fFid));
+
+    delete fStreamState;  // closes the input file
+}
+
+char const *MP3FileSource::MIMEtype() const {
+    return "audio/MPEG";
+}
+
+float MP3FileSource::filePlayTime() const {
+    return fStreamState->filePlayTime();
+}
+
+unsigned MP3FileSource::fileSize() const {
+    return fStreamState->fileSize();
+}
+
+void MP3FileSource::setPresentationTimeScale(unsigned scale) {
+    fStreamState->setPresentationTimeScale(scale);
+}
+
+void MP3FileSource::seekWithinFile(double seekNPT, double streamDuration) {
+    float fileDuration = filePlayTime();
+
+    // First, make sure that 0.0 <= seekNPT <= seekNPT + streamDuration <= fileDuration
+    if(seekNPT < 0.0) {
+        seekNPT = 0.0;
+    }
+    else if(seekNPT > fileDuration) {
+        seekNPT = fileDuration;
+    }
+    if(streamDuration < 0.0) {
+        streamDuration = 0.0;
+    }
+    else if(seekNPT + streamDuration > fileDuration) {
+        streamDuration = fileDuration - seekNPT;
+    }
+
+    float    seekFraction   = (float)seekNPT / fileDuration;
+    unsigned seekByteNumber = fStreamState->getByteNumberFromPositionFraction(seekFraction);
+    fStreamState->seekWithinFile(seekByteNumber);
+
+    fLimitNumBytesToStream = False;  // by default
+    if(streamDuration > 0.0) {
+        float    endFraction   = (float)(seekNPT + streamDuration) / fileDuration;
+        unsigned endByteNumber = fStreamState->getByteNumberFromPositionFraction(endFraction);
+        if(endByteNumber > seekByteNumber) {  // sanity check
+            fNumBytesToStream      = endByteNumber - seekByteNumber;
+            fLimitNumBytesToStream = True;
+        }
+    }
+}
+
+void MP3FileSource::getAttributes() const {
+    char buffer[200];
+    fStreamState->getAttributes(buffer, sizeof buffer);
+    envir().setResultMsg(buffer);
+}
+
+void MP3FileSource::doGetNextFrame() {
+    if(feof(fFid) || ferror(fFid) || (fLimitNumBytesToStream && fNumBytesToStream == 0)) {
+        handleClosure();
+        return;
+    }
+
+    if(!fHaveStartedReading) {
+        // Await readable data from the file:
+        envir().taskScheduler().turnOnBackgroundReadHandling(fileno(fFid), (TaskScheduler::BackgroundHandlerProc *)&fileReadableHandler, this);
+        fHaveStartedReading = True;
+        return;
+    }
+
+    if(!fHaveBeenInitialized) {
+        if(!initializeStream())
+            return;
+
+        fPresentationTime    = fFirstFramePresentationTime;
+        fHaveBeenInitialized = True;
+    }
+    else {
+        if(fStreamState->findNextHeader(fPresentationTime) == 0)
+            return;
+    }
+
+    if(fLimitNumBytesToStream && fNumBytesToStream < (u_int64_t)fMaxSize) {
+        fMaxSize = (unsigned)fNumBytesToStream;
+    }
+    if(!fStreamState->readFrame(fTo, fMaxSize, fFrameSize, fDurationInMicroseconds)) {
+        char tmp[200];
+        sprintf(tmp, "Insufficient buffer size %d for reading MPEG audio frame (needed %d)\n", fMaxSize, fFrameSize);
+        envir().setResultMsg(tmp);
+        handleClosure();
+        return;
+    }
+    fNumBytesToStream -= fFrameSize;
+
+    // Inform the reader that he has data:
+    // Because the file read was done from the event loop, we can call the
+    // 'after getting' function directly, without risk of infinite recursion:
+    FramedSource::afterGetting(this);
+}
+
+void MP3FileSource::fileReadableHandler(MP3FileSource *source, int /*mask*/) {
+    if(!source->isCurrentlyAwaitingData()) {
+        source->doStopGettingFrames();  // we're not ready for the data yet
+        return;
+    }
+    source->doGetNextFrame();
+}
+
+void MP3FileSource::assignStream(FILE *fid, unsigned fileSize) {
+    fStreamState->assignStream(fid, fileSize);
+
+    if(!fHaveBeenInitialized) {
+        if(!initializeStream())
+            return;
+
+        fPresentationTime    = fFirstFramePresentationTime;
+        fHaveBeenInitialized = True;
+    }
+}
+
+Boolean MP3FileSource::initializeStream() {
+    // Make sure the file has an appropriate header near the start:
+    if(fStreamState->findNextHeader(fFirstFramePresentationTime) == 0) {
+        envir().setResultMsg("not an MPEG audio file");
+        return False;
+    }
+
+    fStreamState->checkForXingHeader();  // in case this is a VBR file
+
+    // Hack: It's possible that our environment's 'result message' has been
+    // reset within this function, so set it again to our name now:
+    envir().setResultMsg(name());
+    return True;
+}
diff --git a/3rdparty/live555/src/liveMedia/MP3Internals.cpp b/3rdparty/live555/src/liveMedia/MP3Internals.cpp
new file mode 100644
index 00000000..5923b58b
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/MP3Internals.cpp
@@ -0,0 +1,776 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// MP3 internal implementation details
+// Implementation
+
+#include "MP3InternalsHuffman.hh"
+
+#include <stdlib.h>
+#include <math.h>
+#include <stdio.h>
+#include <string.h>
+
+// This is crufty old code that needs to be cleaned up #####
+
+static unsigned const live_tabsel[2][3][16] = { { { 32, 32, 64, 96, 128, 160, 192, 224, 256, 288, 320, 352, 384, 416, 448, 448 },
+                                                  { 32, 32, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384, 384 },
+                                                  { 32, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 320 } },
+
+                                                { { 32, 32, 48, 56, 64, 80, 96, 112, 128, 144, 160, 176, 192, 224, 256, 256 },
+                                                  { 8, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160, 160 },
+                                                  { 8, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160, 160 } } };
+/* Note: live_tabsel[*][*][0 or 15] shouldn't occur; use dummy values there */
+
+static long const live_freqs[] = { 44100, 48000, 32000, 22050, 24000, 16000, 11025, 12000, 8000, 0 };
+
+struct bandInfoStruct {
+    int longIdx[23];
+    int longDiff[22];
+    int shortIdx[14];
+    int shortDiff[13];
+};
+
+static struct bandInfoStruct const bandInfo[7] = {
+    /* MPEG 1.0 */
+    { { 0, 4, 8, 12, 16, 20, 24, 30, 36, 44, 52, 62, 74, 90, 110, 134, 162, 196, 238, 288, 342, 418, 576 },
+      { 4, 4, 4, 4, 4, 4, 6, 6, 8, 8, 10, 12, 16, 20, 24, 28, 34, 42, 50, 54, 76, 158 },
+      { 0, 4 * 3, 8 * 3, 12 * 3, 16 * 3, 22 * 3, 30 * 3, 40 * 3, 52 * 3, 66 * 3, 84 * 3, 106 * 3, 136 * 3, 192 * 3 },
+      { 4, 4, 4, 4, 6, 8, 10, 12, 14, 18, 22, 30, 56 } },
+
+    { { 0, 4, 8, 12, 16, 20, 24, 30, 36, 42, 50, 60, 72, 88, 106, 128, 156, 190, 230, 276, 330, 384, 576 },
+      { 4, 4, 4, 4, 4, 4, 6, 6, 6, 8, 10, 12, 16, 18, 22, 28, 34, 40, 46, 54, 54, 192 },
+      { 0, 4 * 3, 8 * 3, 12 * 3, 16 * 3, 22 * 3, 28 * 3, 38 * 3, 50 * 3, 64 * 3, 80 * 3, 100 * 3, 126 * 3, 192 * 3 },
+      { 4, 4, 4, 4, 6, 6, 10, 12, 14, 16, 20, 26, 66 } },
+
+    { { 0, 4, 8, 12, 16, 20, 24, 30, 36, 44, 54, 66, 82, 102, 126, 156, 194, 240, 296, 364, 448, 550, 576 },
+      { 4, 4, 4, 4, 4, 4, 6, 6, 8, 10, 12, 16, 20, 24, 30, 38, 46, 56, 68, 84, 102, 26 },
+      { 0, 4 * 3, 8 * 3, 12 * 3, 16 * 3, 22 * 3, 30 * 3, 42 * 3, 58 * 3, 78 * 3, 104 * 3, 138 * 3, 180 * 3, 192 * 3 },
+      { 4, 4, 4, 4, 6, 8, 12, 16, 20, 26, 34, 42, 12 } },
+
+    /* MPEG 2.0 */
+    { { 0, 6, 12, 18, 24, 30, 36, 44, 54, 66, 80, 96, 116, 140, 168, 200, 238, 284, 336, 396, 464, 522, 576 },
+      { 6, 6, 6, 6, 6, 6, 8, 10, 12, 14, 16, 20, 24, 28, 32, 38, 46, 52, 60, 68, 58, 54 },
+      { 0, 4 * 3, 8 * 3, 12 * 3, 18 * 3, 24 * 3, 32 * 3, 42 * 3, 56 * 3, 74 * 3, 100 * 3, 132 * 3, 174 * 3, 192 * 3 },
+      { 4, 4, 4, 6, 6, 8, 10, 14, 18, 26, 32, 42, 18 } },
+
+    { { 0, 6, 12, 18, 24, 30, 36, 44, 54, 66, 80, 96, 114, 136, 162, 194, 232, 278, 330, 394, 464, 540, 576 },
+      { 6, 6, 6, 6, 6, 6, 8, 10, 12, 14, 16, 18, 22, 26, 32, 38, 46, 52, 64, 70, 76, 36 },
+      { 0, 4 * 3, 8 * 3, 12 * 3, 18 * 3, 26 * 3, 36 * 3, 48 * 3, 62 * 3, 80 * 3, 104 * 3, 136 * 3, 180 * 3, 192 * 3 },
+      { 4, 4, 4, 6, 8, 10, 12, 14, 18, 24, 32, 44, 12 } },
+
+    { { 0, 6, 12, 18, 24, 30, 36, 44, 54, 66, 80, 96, 116, 140, 168, 200, 238, 284, 336, 396, 464, 522, 576 },
+      { 6, 6, 6, 6, 6, 6, 8, 10, 12, 14, 16, 20, 24, 28, 32, 38, 46, 52, 60, 68, 58, 54 },
+      { 0, 4 * 3, 8 * 3, 12 * 3, 18 * 3, 26 * 3, 36 * 3, 48 * 3, 62 * 3, 80 * 3, 104 * 3, 134 * 3, 174 * 3, 192 * 3 },
+      { 4, 4, 4, 6, 8, 10, 12, 14, 18, 24, 30, 40, 18 } },
+
+    /* MPEG 2.5, wrong! table (it's just a copy of MPEG 2.0/44.1kHz) */
+    { { 0, 6, 12, 18, 24, 30, 36, 44, 54, 66, 80, 96, 116, 140, 168, 200, 238, 284, 336, 396, 464, 522, 576 },
+      { 6, 6, 6, 6, 6, 6, 8, 10, 12, 14, 16, 20, 24, 28, 32, 38, 46, 52, 60, 68, 58, 54 },
+      { 0, 4 * 3, 8 * 3, 12 * 3, 18 * 3, 24 * 3, 32 * 3, 42 * 3, 56 * 3, 74 * 3, 100 * 3, 132 * 3, 174 * 3, 192 * 3 },
+      { 4, 4, 4, 6, 6, 8, 10, 14, 18, 26, 32, 42, 18 } },
+};
+
+unsigned int n_slen2[512]; /* MPEG 2.0 slen for 'normal' mode */
+unsigned int i_slen2[256]; /* MPEG 2.0 slen for intensity stereo */
+
+#define MPG_MD_MONO 3
+
+////////// MP3FrameParams //////////
+
+MP3FrameParams::MP3FrameParams()
+    : isMPEG2(0),
+      samplingFreq(44100),
+      frameSize(413),  // init params, in case we're used early
+      bv(frameBytes, 0, sizeof frameBytes) /* by default */ {
+    oldHdr = firstHdr = 0;
+
+    static Boolean doneInit = False;
+    if(doneInit)
+        return;
+
+    int i, j, k, l;
+
+    for(i = 0; i < 5; i++) {
+        for(j = 0; j < 6; j++) {
+            for(k = 0; k < 6; k++) {
+                int n      = k + j * 6 + i * 36;
+                i_slen2[n] = i | (j << 3) | (k << 6) | (3 << 12);
+            }
+        }
+    }
+    for(i = 0; i < 4; i++) {
+        for(j = 0; j < 4; j++) {
+            for(k = 0; k < 4; k++) {
+                int n            = k + j * 4 + i * 16;
+                i_slen2[n + 180] = i | (j << 3) | (k << 6) | (4 << 12);
+            }
+        }
+    }
+    for(i = 0; i < 4; i++) {
+        for(j = 0; j < 3; j++) {
+            int n            = j + i * 3;
+            i_slen2[n + 244] = i | (j << 3) | (5 << 12);
+            n_slen2[n + 500] = i | (j << 3) | (2 << 12) | (1 << 15);
+        }
+    }
+
+    for(i = 0; i < 5; i++) {
+        for(j = 0; j < 5; j++) {
+            for(k = 0; k < 4; k++) {
+                for(l = 0; l < 4; l++) {
+                    int n      = l + k * 4 + j * 16 + i * 80;
+                    n_slen2[n] = i | (j << 3) | (k << 6) | (l << 9) | (0 << 12);
+                }
+            }
+        }
+    }
+    for(i = 0; i < 5; i++) {
+        for(j = 0; j < 5; j++) {
+            for(k = 0; k < 4; k++) {
+                int n            = k + j * 4 + i * 20;
+                n_slen2[n + 400] = i | (j << 3) | (k << 6) | (1 << 12);
+            }
+        }
+    }
+    doneInit = True;
+}
+
+MP3FrameParams::~MP3FrameParams() {}
+
+void MP3FrameParams::setParamsFromHeader() {
+    if(hdr & (1 << 20)) {
+        isMPEG2   = (hdr & (1 << 19)) ? 0x0 : 0x1;
+        isMPEG2_5 = 0;
+    }
+    else {
+        isMPEG2   = 1;
+        isMPEG2_5 = 1;
+    }
+
+    layer = 4 - ((hdr >> 17) & 3);
+    if(layer == 4)
+        layer = 3;  // layer==4 is not allowed
+    bitrateIndex = ((hdr >> 12) & 0xf);
+
+    if(isMPEG2_5) {
+        samplingFreqIndex = ((hdr >> 10) & 0x3) + 6;
+    }
+    else {
+        samplingFreqIndex = ((hdr >> 10) & 0x3) + (isMPEG2 * 3);
+    }
+
+    hasCRC = (hdr & 0x10000) == 0;
+
+    padding   = ((hdr >> 9) & 0x1);
+    extension = ((hdr >> 8) & 0x1);
+    mode      = ((hdr >> 6) & 0x3);
+    mode_ext  = ((hdr >> 4) & 0x3);
+    copyright = ((hdr >> 3) & 0x1);
+    original  = ((hdr >> 2) & 0x1);
+    emphasis  = hdr & 0x3;
+
+    stereo = (mode == MPG_MD_MONO) ? 1 : 2;
+
+    if(((hdr >> 10) & 0x3) == 0x3) {
+#ifdef DEBUG_ERRORS
+        fprintf(stderr, "Stream error - hdr: 0x%08x\n", hdr);
+#endif
+    }
+
+    bitrate      = live_tabsel[isMPEG2][layer - 1][bitrateIndex];
+    samplingFreq = live_freqs[samplingFreqIndex];
+    isStereo     = (stereo > 1);
+    isFreeFormat = (bitrateIndex == 0);
+    frameSize    = ComputeFrameSize(bitrate, samplingFreq, padding, isMPEG2, layer);
+    sideInfoSize = computeSideInfoSize();
+}
+
+unsigned MP3FrameParams::computeSideInfoSize() {
+    unsigned size;
+
+    if(isMPEG2) {
+        size = isStereo ? 17 : 9;
+    }
+    else {
+        size = isStereo ? 32 : 17;
+    }
+
+    if(hasCRC) {
+        size += 2;
+    }
+
+    return size;
+}
+
+unsigned ComputeFrameSize(unsigned bitrate, unsigned samplingFreq, Boolean usePadding, Boolean isMPEG2, unsigned char layer) {
+    if(samplingFreq == 0)
+        return 0;
+    unsigned const bitrateMultiplier = (layer == 1) ? 12000 * 4 : 144000;
+    unsigned       framesize;
+
+    framesize = bitrate * bitrateMultiplier;
+    framesize /= samplingFreq << (isMPEG2 ? 1 : 0);
+    framesize = framesize + usePadding - 4;
+
+    return framesize;
+}
+
+#define TRUNC_FAIRLY
+static unsigned updateSideInfoSizes(MP3SideInfo &sideInfo, Boolean isMPEG2, unsigned char const *mainDataPtr, unsigned allowedNumBits, unsigned &part23Length0a,
+                                    unsigned &part23Length0aTruncation, unsigned &part23Length0b, unsigned &part23Length0bTruncation, unsigned &part23Length1a,
+                                    unsigned &part23Length1aTruncation, unsigned &part23Length1b, unsigned &part23Length1bTruncation) {
+    unsigned p23L0, p23L1 = 0, p23L0Trunc = 0, p23L1Trunc = 0;
+
+    p23L0 = sideInfo.ch[0].gr[0].part2_3_length;
+    p23L1 = isMPEG2 ? 0 : sideInfo.ch[0].gr[1].part2_3_length;
+#ifdef TRUNC_ONLY0
+    if(p23L0 < allowedNumBits)
+        allowedNumBits = p23L0;
+#endif
+#ifdef TRUNC_ONLY1
+    if(p23L1 < allowedNumBits)
+        allowedNumBits = p23L1;
+#endif
+    if(p23L0 + p23L1 > allowedNumBits) {
+        /* We need to shorten one or both fields */
+        unsigned truncation = p23L0 + p23L1 - allowedNumBits;
+#ifdef TRUNC_FAIRLY
+        p23L0Trunc = (truncation * p23L0) / (p23L0 + p23L1);
+        p23L1Trunc = truncation - p23L0Trunc;
+#endif
+#if defined(TRUNC_FAVOR0) || defined(TRUNC_ONLY0)
+        p23L1Trunc = (truncation > p23L1) ? p23L1 : truncation;
+        p23L0Trunc = truncation - p23L1Trunc;
+#endif
+#if defined(TRUNC_FAVOR1) || defined(TRUNC_ONLY1)
+        p23L0Trunc = (truncation > p23L0) ? p23L0 : truncation;
+        p23L1Trunc = truncation - p23L0Trunc;
+#endif
+    }
+
+    /* ASSERT: (p23L0Trunc <= p23L0) && (p23l1Trunc <= p23L1) */
+    p23L0 -= p23L0Trunc;
+    p23L1 -= p23L1Trunc;
+#ifdef DEBUG
+    fprintf(stderr, "updateSideInfoSizes (allowed: %d): %d->%d, %d->%d\n", allowedNumBits, p23L0 + p23L0Trunc, p23L0, p23L1 + p23L1Trunc, p23L1);
+#endif
+
+    // The truncations computed above are still estimates.  We need to
+    // adjust them so that the new fields will continue to end on
+    // Huffman-encoded sample boundaries:
+    updateSideInfoForHuffman(sideInfo, isMPEG2, mainDataPtr, p23L0, p23L1, part23Length0a, part23Length0aTruncation, part23Length0b, part23Length0bTruncation,
+                             part23Length1a, part23Length1aTruncation, part23Length1b, part23Length1bTruncation);
+    p23L0 = part23Length0a + part23Length0b;
+    p23L1 = part23Length1a + part23Length1b;
+
+    sideInfo.ch[0].gr[0].part2_3_length = p23L0;
+    sideInfo.ch[0].gr[1].part2_3_length = p23L1;
+    part23Length0bTruncation += sideInfo.ch[1].gr[0].part2_3_length; /* allow for stereo */
+    sideInfo.ch[1].gr[0].part2_3_length = 0;                         /* output mono */
+    sideInfo.ch[1].gr[1].part2_3_length = 0;                         /* output mono */
+
+    return p23L0 + p23L1;
+}
+
+Boolean GetADUInfoFromMP3Frame(unsigned char const *framePtr, unsigned totFrameSize, unsigned &hdr, unsigned &frameSize, MP3SideInfo &sideInfo,
+                               unsigned &sideInfoSize, unsigned &backpointer, unsigned &aduSize) {
+    if(totFrameSize < 4)
+        return False;  // there's not enough data
+
+    MP3FrameParams fr;
+    fr.hdr = ((unsigned)framePtr[0] << 24) | ((unsigned)framePtr[1] << 16) | ((unsigned)framePtr[2] << 8) | (unsigned)framePtr[3];
+    fr.setParamsFromHeader();
+    fr.setBytePointer(framePtr + 4, totFrameSize - 4);  // skip hdr
+
+    frameSize = 4 + fr.frameSize;
+
+    if(fr.layer != 3) {
+        // Special case for non-layer III frames
+        backpointer  = 0;
+        sideInfoSize = 0;
+        aduSize      = fr.frameSize;
+        return True;
+    }
+
+    sideInfoSize = fr.sideInfoSize;
+    if(totFrameSize < 4 + sideInfoSize)
+        return False;  // not enough data
+
+    fr.getSideInfo(sideInfo);
+
+    hdr              = fr.hdr;
+    backpointer      = sideInfo.main_data_begin;
+    unsigned numBits = sideInfo.ch[0].gr[0].part2_3_length;
+    numBits += sideInfo.ch[0].gr[1].part2_3_length;
+    numBits += sideInfo.ch[1].gr[0].part2_3_length;
+    numBits += sideInfo.ch[1].gr[1].part2_3_length;
+    aduSize = (numBits + 7) / 8;
+#ifdef DEBUG
+    fprintf(stderr, "mp3GetADUInfoFromFrame: hdr: %08x, frameSize: %d, part2_3_lengths: %d,%d,%d,%d, aduSize: %d, backpointer: %d\n", hdr, frameSize,
+            sideInfo.ch[0].gr[0].part2_3_length, sideInfo.ch[0].gr[1].part2_3_length, sideInfo.ch[1].gr[0].part2_3_length, sideInfo.ch[1].gr[1].part2_3_length,
+            aduSize, backpointer);
+#endif
+
+    return True;
+}
+
+static void getSideInfo1(MP3FrameParams &fr, MP3SideInfo &si, int stereo, int ms_stereo, long sfreq, int /*single*/) {
+    int ch, gr;
+#if 0
+   int powdiff = (single == 3) ? 4 : 0;
+#endif
+
+    /* initialize all four "part2_3_length" fields to zero: */
+    si.ch[0].gr[0].part2_3_length = 0;
+    si.ch[1].gr[0].part2_3_length = 0;
+    si.ch[0].gr[1].part2_3_length = 0;
+    si.ch[1].gr[1].part2_3_length = 0;
+
+    si.main_data_begin = fr.getBits(9);
+    if(stereo == 1)
+        si.private_bits = fr.getBits(5);
+    else
+        si.private_bits = fr.getBits(3);
+
+    for(ch = 0; ch < stereo; ch++) {
+        si.ch[ch].gr[0].scfsi = -1;
+        si.ch[ch].gr[1].scfsi = fr.getBits(4);
+    }
+
+    for(gr = 0; gr < 2; gr++) {
+        for(ch = 0; ch < stereo; ch++) {
+            MP3SideInfo::gr_info_s_t &gr_info = si.ch[ch].gr[gr];
+
+            gr_info.part2_3_length = fr.getBits(12);
+            gr_info.big_values     = fr.getBits(9);
+            gr_info.global_gain    = fr.getBits(8);
+#if 0
+       gr_info.pow2gain = gainpow2+256 - gr_info.global_gain + powdiff;
+       if (ms_stereo) gr_info.pow2gain += 2;
+#endif
+            gr_info.scalefac_compress = fr.getBits(4);
+            /* window-switching flag == 1 for block_Type != 0 .. and block-type == 0 -> win-sw-flag = 0 */
+            gr_info.window_switching_flag = fr.get1Bit();
+            if(gr_info.window_switching_flag) {
+                int i;
+                gr_info.block_type       = fr.getBits(2);
+                gr_info.mixed_block_flag = fr.get1Bit();
+                gr_info.table_select[0]  = fr.getBits(5);
+                gr_info.table_select[1]  = fr.getBits(5);
+                /*
+                 * table_select[2] not needed, because there is no region2,
+                 * but to satisfy some verifications tools we set it either.
+                 */
+                gr_info.table_select[2] = 0;
+                for(i = 0; i < 3; i++) {
+                    gr_info.subblock_gain[i] = fr.getBits(3);
+                    gr_info.full_gain[i]     = gr_info.pow2gain + ((gr_info.subblock_gain[i]) << 3);
+                }
+
+#ifdef DEBUG_ERRORS
+                if(gr_info.block_type == 0) {
+                    fprintf(stderr, "Blocktype == 0 and window-switching == 1 not allowed.\n");
+                }
+#endif
+                /* region_count/start parameters are implicit in this case. */
+                gr_info.region1start = 36 >> 1;
+                gr_info.region2start = 576 >> 1;
+            }
+            else {
+                int i, r0c, r1c;
+                for(i = 0; i < 3; i++) {
+                    gr_info.table_select[i] = fr.getBits(5);
+                }
+                r0c = gr_info.region0_count = fr.getBits(4);
+                r1c = gr_info.region1_count = fr.getBits(3);
+                gr_info.region1start        = bandInfo[sfreq].longIdx[r0c + 1] >> 1;
+                gr_info.region2start        = bandInfo[sfreq].longIdx[r0c + 1 + r1c + 1] >> 1;
+                gr_info.block_type          = 0;
+                gr_info.mixed_block_flag    = 0;
+            }
+            gr_info.preflag            = fr.get1Bit();
+            gr_info.scalefac_scale     = fr.get1Bit();
+            gr_info.count1table_select = fr.get1Bit();
+        }
+    }
+}
+
+static void getSideInfo2(MP3FrameParams &fr, MP3SideInfo &si, int stereo, int ms_stereo, long sfreq, int /*single*/) {
+    int ch;
+#if 0
+   int powdiff = (single == 3) ? 4 : 0;
+#endif
+
+    /* initialize all four "part2_3_length" fields to zero: */
+    si.ch[0].gr[0].part2_3_length = 0;
+    si.ch[1].gr[0].part2_3_length = 0;
+    si.ch[0].gr[1].part2_3_length = 0;
+    si.ch[1].gr[1].part2_3_length = 0;
+
+    si.main_data_begin = fr.getBits(8);
+    if(stereo == 1)
+        si.private_bits = fr.get1Bit();
+    else
+        si.private_bits = fr.getBits(2);
+
+    for(ch = 0; ch < stereo; ch++) {
+        MP3SideInfo::gr_info_s_t &gr_info = si.ch[ch].gr[0];
+
+        gr_info.part2_3_length         = fr.getBits(12);
+        si.ch[ch].gr[1].part2_3_length = 0; /* to ensure granule 1 unused */
+
+        gr_info.big_values  = fr.getBits(9);
+        gr_info.global_gain = fr.getBits(8);
+#if 0
+       gr_info.pow2gain = gainpow2+256 - gr_info.global_gain + powdiff;
+       if (ms_stereo) gr_info.pow2gain += 2;
+#endif
+        gr_info.scalefac_compress = fr.getBits(9);
+        /* window-switching flag == 1 for block_Type != 0 .. and block-type == 0 -> win-sw-flag = 0 */
+        gr_info.window_switching_flag = fr.get1Bit();
+        if(gr_info.window_switching_flag) {
+            int i;
+            gr_info.block_type       = fr.getBits(2);
+            gr_info.mixed_block_flag = fr.get1Bit();
+            gr_info.table_select[0]  = fr.getBits(5);
+            gr_info.table_select[1]  = fr.getBits(5);
+            /*
+             * table_select[2] not needed, because there is no region2,
+             * but to satisfy some verifications tools we set it either.
+             */
+            gr_info.table_select[2] = 0;
+            for(i = 0; i < 3; i++) {
+                gr_info.subblock_gain[i] = fr.getBits(3);
+                gr_info.full_gain[i]     = gr_info.pow2gain + ((gr_info.subblock_gain[i]) << 3);
+            }
+
+#ifdef DEBUG_ERRORS
+            if(gr_info.block_type == 0) {
+                fprintf(stderr, "Blocktype == 0 and window-switching == 1 not allowed.\n");
+            }
+#endif
+            /* region_count/start parameters are implicit in this case. */
+            /* check this again! */
+            if(gr_info.block_type == 2)
+                gr_info.region1start = 36 >> 1;
+            else {
+                gr_info.region1start = 54 >> 1;
+            }
+            gr_info.region2start = 576 >> 1;
+        }
+        else {
+            int i, r0c, r1c;
+            for(i = 0; i < 3; i++) {
+                gr_info.table_select[i] = fr.getBits(5);
+            }
+            r0c = gr_info.region0_count = fr.getBits(4);
+            r1c = gr_info.region1_count = fr.getBits(3);
+            gr_info.region1start        = bandInfo[sfreq].longIdx[r0c + 1] >> 1;
+            gr_info.region2start        = bandInfo[sfreq].longIdx[r0c + 1 + r1c + 1] >> 1;
+            gr_info.block_type          = 0;
+            gr_info.mixed_block_flag    = 0;
+        }
+        gr_info.scalefac_scale     = fr.get1Bit();
+        gr_info.count1table_select = fr.get1Bit();
+    }
+}
+
+#define MPG_MD_JOINT_STEREO 1
+
+void MP3FrameParams::getSideInfo(MP3SideInfo &si) {
+    // First skip over the CRC if present:
+    if(hasCRC)
+        getBits(16);
+
+    int single = -1;
+    int ms_stereo;
+    int sfreq = samplingFreqIndex;
+
+    if(stereo == 1) {
+        single = 0;
+    }
+
+    ms_stereo = (mode == MPG_MD_JOINT_STEREO) && (mode_ext & 0x2);
+
+    if(isMPEG2) {
+        getSideInfo2(*this, si, stereo, ms_stereo, sfreq, single);
+    }
+    else {
+        getSideInfo1(*this, si, stereo, ms_stereo, sfreq, single);
+    }
+}
+
+static void putSideInfo1(BitVector &bv, MP3SideInfo const &si, Boolean isStereo) {
+    int ch, gr, i;
+    int stereo = isStereo ? 2 : 1;
+
+    bv.putBits(si.main_data_begin, 9);
+    if(stereo == 1)
+        bv.putBits(si.private_bits, 5);
+    else
+        bv.putBits(si.private_bits, 3);
+
+    for(ch = 0; ch < stereo; ch++) {
+        bv.putBits(si.ch[ch].gr[1].scfsi, 4);
+    }
+
+    for(gr = 0; gr < 2; gr++) {
+        for(ch = 0; ch < stereo; ch++) {
+            MP3SideInfo::gr_info_s_t const &gr_info = si.ch[ch].gr[gr];
+
+            bv.putBits(gr_info.part2_3_length, 12);
+            bv.putBits(gr_info.big_values, 9);
+            bv.putBits(gr_info.global_gain, 8);
+            bv.putBits(gr_info.scalefac_compress, 4);
+            bv.put1Bit(gr_info.window_switching_flag);
+            if(gr_info.window_switching_flag) {
+                bv.putBits(gr_info.block_type, 2);
+                bv.put1Bit(gr_info.mixed_block_flag);
+                for(i = 0; i < 2; i++)
+                    bv.putBits(gr_info.table_select[i], 5);
+                for(i = 0; i < 3; i++)
+                    bv.putBits(gr_info.subblock_gain[i], 3);
+            }
+            else {
+                for(i = 0; i < 3; i++)
+                    bv.putBits(gr_info.table_select[i], 5);
+                bv.putBits(gr_info.region0_count, 4);
+                bv.putBits(gr_info.region1_count, 3);
+            }
+
+            bv.put1Bit(gr_info.preflag);
+            bv.put1Bit(gr_info.scalefac_scale);
+            bv.put1Bit(gr_info.count1table_select);
+        }
+    }
+}
+
+static void putSideInfo2(BitVector &bv, MP3SideInfo const &si, Boolean isStereo) {
+    int ch, i;
+    int stereo = isStereo ? 2 : 1;
+
+    bv.putBits(si.main_data_begin, 8);
+    if(stereo == 1)
+        bv.put1Bit(si.private_bits);
+    else
+        bv.putBits(si.private_bits, 2);
+
+    for(ch = 0; ch < stereo; ch++) {
+        MP3SideInfo::gr_info_s_t const &gr_info = si.ch[ch].gr[0];
+
+        bv.putBits(gr_info.part2_3_length, 12);
+        bv.putBits(gr_info.big_values, 9);
+        bv.putBits(gr_info.global_gain, 8);
+        bv.putBits(gr_info.scalefac_compress, 9);
+        bv.put1Bit(gr_info.window_switching_flag);
+        if(gr_info.window_switching_flag) {
+            bv.putBits(gr_info.block_type, 2);
+            bv.put1Bit(gr_info.mixed_block_flag);
+            for(i = 0; i < 2; i++)
+                bv.putBits(gr_info.table_select[i], 5);
+            for(i = 0; i < 3; i++)
+                bv.putBits(gr_info.subblock_gain[i], 3);
+        }
+        else {
+            for(i = 0; i < 3; i++)
+                bv.putBits(gr_info.table_select[i], 5);
+            bv.putBits(gr_info.region0_count, 4);
+            bv.putBits(gr_info.region1_count, 3);
+        }
+
+        bv.put1Bit(gr_info.scalefac_scale);
+        bv.put1Bit(gr_info.count1table_select);
+    }
+}
+
+static void PutMP3SideInfoIntoFrame(MP3SideInfo const &si, MP3FrameParams const &fr, unsigned char *framePtr) {
+    if(fr.hasCRC)
+        framePtr += 2;  // skip CRC
+
+    BitVector bv(framePtr, 0, 8 * fr.sideInfoSize);
+
+    if(fr.isMPEG2) {
+        putSideInfo2(bv, si, fr.isStereo);
+    }
+    else {
+        putSideInfo1(bv, si, fr.isStereo);
+    }
+}
+
+Boolean ZeroOutMP3SideInfo(unsigned char *framePtr, unsigned totFrameSize, unsigned newBackpointer) {
+    if(totFrameSize < 4)
+        return False;  // there's not enough data
+
+    MP3FrameParams fr;
+    fr.hdr = ((unsigned)framePtr[0] << 24) | ((unsigned)framePtr[1] << 16) | ((unsigned)framePtr[2] << 8) | (unsigned)framePtr[3];
+    fr.setParamsFromHeader();
+    fr.setBytePointer(framePtr + 4, totFrameSize - 4);  // skip hdr
+
+    if(totFrameSize < 4 + fr.sideInfoSize)
+        return False;  // not enough data
+
+    MP3SideInfo si;
+    fr.getSideInfo(si);
+
+    si.main_data_begin = newBackpointer; /* backpointer */
+    /* set all four "part2_3_length" and "big_values" fields to zero: */
+    si.ch[0].gr[0].part2_3_length = si.ch[0].gr[0].big_values = 0;
+    si.ch[1].gr[0].part2_3_length = si.ch[1].gr[0].big_values = 0;
+    si.ch[0].gr[1].part2_3_length = si.ch[0].gr[1].big_values = 0;
+    si.ch[1].gr[1].part2_3_length = si.ch[1].gr[1].big_values = 0;
+
+    PutMP3SideInfoIntoFrame(si, fr, framePtr + 4);
+
+    return True;
+}
+
+static unsigned MP3BitrateToBitrateIndex(unsigned bitrate /* in kbps */, Boolean isMPEG2) {
+    for(unsigned i = 1; i < 15; ++i) {
+        if(live_tabsel[isMPEG2][2][i] >= bitrate)
+            return i;
+    }
+
+    // "bitrate" was larger than any possible, so return the largest possible:
+    return 14;
+}
+
+static void outputHeader(unsigned char *toPtr, unsigned hdr) {
+    toPtr[0] = (unsigned char)(hdr >> 24);
+    toPtr[1] = (unsigned char)(hdr >> 16);
+    toPtr[2] = (unsigned char)(hdr >> 8);
+    toPtr[3] = (unsigned char)(hdr);
+}
+
+static void assignADUBackpointer(MP3FrameParams const &fr, unsigned aduSize, MP3SideInfo &sideInfo, unsigned &availableBytesForBackpointer) {
+    // Give the ADU as large a backpointer as possible:
+    unsigned maxBackpointerSize = fr.isMPEG2 ? 255 : 511;
+
+    unsigned backpointerSize = availableBytesForBackpointer;
+    if(backpointerSize > maxBackpointerSize) {
+        backpointerSize = maxBackpointerSize;
+    }
+
+    // Store the new backpointer now:
+    sideInfo.main_data_begin = backpointerSize;
+
+    // Figure out how many bytes are available for the *next* ADU's backpointer:
+    availableBytesForBackpointer = backpointerSize + fr.frameSize - fr.sideInfoSize;
+    if(availableBytesForBackpointer < aduSize) {
+        availableBytesForBackpointer = 0;
+    }
+    else {
+        availableBytesForBackpointer -= aduSize;
+    }
+}
+
+unsigned TranscodeMP3ADU(unsigned char const *fromPtr, unsigned fromSize, unsigned toBitrate, unsigned char *toPtr, unsigned toMaxSize,
+                         unsigned &availableBytesForBackpointer) {
+    // Begin by parsing the input ADU's parameters:
+    unsigned    hdr, inFrameSize, inSideInfoSize, backpointer, inAduSize;
+    MP3SideInfo sideInfo;
+    if(!GetADUInfoFromMP3Frame(fromPtr, fromSize, hdr, inFrameSize, sideInfo, inSideInfoSize, backpointer, inAduSize)) {
+        return 0;
+    }
+    fromPtr += (4 + inSideInfoSize);  // skip to 'main data'
+
+    // Alter the 4-byte MPEG header to reflect the output ADU:
+    // (different bitrate; mono; no CRC)
+    Boolean  isMPEG2        = ((hdr & 0x00080000) == 0);
+    unsigned toBitrateIndex = MP3BitrateToBitrateIndex(toBitrate, isMPEG2);
+    hdr &= ~0xF000;
+    hdr |= (toBitrateIndex << 12);  // set bitrate index
+    hdr |= 0x10200;                 // turn on !error-prot and padding bits
+    hdr &= ~0xC0;
+    hdr |= 0xC0;  // set mode to 3 (mono)
+
+    // Set up the rest of the parameters of the new ADU:
+    MP3FrameParams outFr;
+    outFr.hdr = hdr;
+    outFr.setParamsFromHeader();
+
+    // Figure out how big to make the output ADU:
+    unsigned inAveAduSize  = inFrameSize - inSideInfoSize;
+    unsigned outAveAduSize = outFr.frameSize - outFr.sideInfoSize;
+    unsigned desiredOutAduSize /*=inAduSize*outAveAduSize/inAveAduSize*/
+        = (2 * inAduSize * outAveAduSize + inAveAduSize) / (2 * inAveAduSize);
+    // this rounds to the nearest integer
+
+    if(toMaxSize < (4 + outFr.sideInfoSize))
+        return 0;
+    unsigned maxOutAduSize = toMaxSize - (4 + outFr.sideInfoSize);
+    if(desiredOutAduSize > maxOutAduSize) {
+        desiredOutAduSize = maxOutAduSize;
+    }
+
+    // Figure out the new sizes of the various 'part23 lengths',
+    // and how much they are truncated:
+    unsigned part23Length0a, part23Length0aTruncation;
+    unsigned part23Length0b, part23Length0bTruncation;
+    unsigned part23Length1a, part23Length1aTruncation;
+    unsigned part23Length1b, part23Length1bTruncation;
+    unsigned numAduBits = updateSideInfoSizes(sideInfo, outFr.isMPEG2, fromPtr, 8 * desiredOutAduSize, part23Length0a, part23Length0aTruncation, part23Length0b,
+                                              part23Length0bTruncation, part23Length1a, part23Length1aTruncation, part23Length1b, part23Length1bTruncation);
+#ifdef DEBUG
+    fprintf(stderr, "shrinkage %d->%d [(%d,%d),(%d,%d)] (trunc: [(%d,%d),(%d,%d)]) {%d}\n", inAduSize, (numAduBits + 7) / 8, part23Length0a, part23Length0b,
+            part23Length1a, part23Length1b, part23Length0aTruncation, part23Length0bTruncation, part23Length1aTruncation, part23Length1bTruncation,
+            maxOutAduSize);
+#endif
+    unsigned actualOutAduSize = (numAduBits + 7) / 8;
+
+    // Give the new ADU an appropriate 'backpointer':
+    assignADUBackpointer(outFr, actualOutAduSize, sideInfo, availableBytesForBackpointer);
+
+    ///// Now output the new ADU:
+
+    // 4-byte header
+    outputHeader(toPtr, hdr);
+    toPtr += 4;
+
+    // side info
+    PutMP3SideInfoIntoFrame(sideInfo, outFr, toPtr);
+    toPtr += outFr.sideInfoSize;
+
+    // 'main data', using the new lengths
+    unsigned toBitOffset   = 0;
+    unsigned fromBitOffset = 0;
+
+    /* rebuild portion 0a: */
+    memmove(toPtr, fromPtr, (part23Length0a + 7) / 8);
+    toBitOffset += part23Length0a;
+    fromBitOffset += part23Length0a + part23Length0aTruncation;
+
+    /* rebuild portion 0b: */
+    shiftBits(toPtr, toBitOffset, fromPtr, fromBitOffset, part23Length0b);
+    toBitOffset += part23Length0b;
+    fromBitOffset += part23Length0b + part23Length0bTruncation;
+
+    /* rebuild portion 1a: */
+    shiftBits(toPtr, toBitOffset, fromPtr, fromBitOffset, part23Length1a);
+    toBitOffset += part23Length1a;
+    fromBitOffset += part23Length1a + part23Length1aTruncation;
+
+    /* rebuild portion 1b: */
+    shiftBits(toPtr, toBitOffset, fromPtr, fromBitOffset, part23Length1b);
+    toBitOffset += part23Length1b;
+
+    /* zero out any remaining bits (probably unnecessary, but...) */
+    unsigned char const zero = '\0';
+    shiftBits(toPtr, toBitOffset, &zero, 0, actualOutAduSize * 8 - numAduBits);
+
+    return 4 + outFr.sideInfoSize + actualOutAduSize;
+}
diff --git a/3rdparty/live555/src/liveMedia/MP3Internals.hh b/3rdparty/live555/src/liveMedia/MP3Internals.hh
new file mode 100644
index 00000000..e7180014
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/MP3Internals.hh
@@ -0,0 +1,143 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// MP3 internal implementation details
+// C++ header
+
+#ifndef _MP3_INTERNALS_HH
+#define _MP3_INTERNALS_HH
+
+#ifndef _BOOLEAN_HH
+#include "Boolean.hh"
+#endif
+#ifndef _BIT_VECTOR_HH
+#include "BitVector.hh"
+#endif
+
+typedef struct MP3SideInfo {
+  unsigned main_data_begin;
+  unsigned private_bits;
+  typedef struct gr_info_s {
+    int scfsi;
+    unsigned part2_3_length;
+    unsigned big_values;
+    unsigned global_gain;
+    unsigned scalefac_compress;
+    unsigned window_switching_flag;
+    unsigned block_type;
+    unsigned mixed_block_flag;
+    unsigned table_select[3];
+    unsigned region0_count;
+    unsigned region1_count;
+    unsigned subblock_gain[3];
+    unsigned maxband[3];
+    unsigned maxbandl;
+    unsigned maxb;
+    unsigned region1start;
+    unsigned region2start;
+    unsigned preflag;
+    unsigned scalefac_scale;
+    unsigned count1table_select;
+    double *full_gain[3];
+    double *pow2gain;
+  } gr_info_s_t;
+  struct {
+    gr_info_s_t gr[2];
+  } ch[2];
+} MP3SideInfo_t;
+
+#define SBLIMIT 32
+#define MAX_MP3_FRAME_SIZE 2500 /* also big enough for an 'ADU'ized frame */
+
+class MP3FrameParams {
+public:
+  MP3FrameParams();
+  ~MP3FrameParams();
+
+  // 4-byte MPEG header:
+  unsigned hdr;
+
+  // a buffer that can be used to hold the rest of the frame:
+  unsigned char frameBytes[MAX_MP3_FRAME_SIZE];
+
+  // public parameters derived from the header
+  void setParamsFromHeader(); // this sets them
+  Boolean isMPEG2;
+  unsigned layer; // currently only 3 is supported
+  unsigned bitrate; // in kbps
+  unsigned samplingFreq;
+  Boolean isStereo;
+  Boolean isFreeFormat;
+  unsigned frameSize; // doesn't include the initial 4-byte header
+  unsigned sideInfoSize;
+  Boolean hasCRC;
+
+  void setBytePointer(unsigned char const* restOfFrame,
+		      unsigned totNumBytes) {// called during setup
+    bv.setup((unsigned char*)restOfFrame, 0, 8*totNumBytes);
+  }
+
+  // other, public parameters used when parsing input (perhaps get rid of)
+  unsigned oldHdr, firstHdr;
+
+  // Extract (unpack) the side info from the frame into a struct:
+  void getSideInfo(MP3SideInfo& si);
+
+  // The bit pointer used for reading data from frame data
+  unsigned getBits(unsigned numBits) { return bv.getBits(numBits); }
+  unsigned get1Bit() { return bv.get1Bit(); }
+
+private:
+  BitVector bv;
+
+  // other, private parameters derived from the header
+  unsigned bitrateIndex;
+  unsigned samplingFreqIndex;
+  Boolean isMPEG2_5;
+  Boolean padding;
+  Boolean extension;
+  unsigned mode;
+  unsigned mode_ext;
+  Boolean copyright;
+  Boolean original;
+  unsigned emphasis;
+  unsigned stereo;
+
+private:
+  unsigned computeSideInfoSize();
+};
+
+unsigned ComputeFrameSize(unsigned bitrate, unsigned samplingFreq,
+			  Boolean usePadding, Boolean isMPEG2,
+			  unsigned char layer);
+
+Boolean GetADUInfoFromMP3Frame(unsigned char const* framePtr,
+			       unsigned totFrameSize,
+			       unsigned& hdr, unsigned& frameSize,
+			       MP3SideInfo& sideInfo, unsigned& sideInfoSize,
+			       unsigned& backpointer, unsigned& aduSize);
+
+Boolean ZeroOutMP3SideInfo(unsigned char* framePtr, unsigned totFrameSize,
+			   unsigned newBackpointer);
+
+unsigned TranscodeMP3ADU(unsigned char const* fromPtr, unsigned fromSize,
+		      unsigned toBitrate,
+		      unsigned char* toPtr, unsigned toMaxSize,
+		      unsigned& availableBytesForBackpointer);
+  // returns the size of the resulting ADU (0 on failure)
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/MP3InternalsHuffman.cpp b/3rdparty/live555/src/liveMedia/MP3InternalsHuffman.cpp
new file mode 100644
index 00000000..1df47866
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/MP3InternalsHuffman.cpp
@@ -0,0 +1,1009 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// MP3 internal implementation details (Huffman encoding)
+// Implementation
+
+#include "MP3InternalsHuffman.hh"
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+MP3HuffmanEncodingInfo ::MP3HuffmanEncodingInfo(Boolean includeDecodedValues) {
+    if(includeDecodedValues) {
+        decodedValues = new unsigned[(SBLIMIT * SSLIMIT + 1) * 4];
+    }
+    else {
+        decodedValues = NULL;
+    }
+}
+
+MP3HuffmanEncodingInfo::~MP3HuffmanEncodingInfo() {
+    delete[] decodedValues;
+}
+
+// This is crufty old code that needs to be cleaned up #####
+
+static unsigned debugCount = 0; /* for debugging */
+
+#define TRUNC_FAVORa
+
+void updateSideInfoForHuffman(MP3SideInfo &sideInfo, Boolean isMPEG2, unsigned char const *mainDataPtr, unsigned p23L0, unsigned p23L1,
+                              unsigned &part23Length0a, unsigned &part23Length0aTruncation, unsigned &part23Length0b, unsigned &part23Length0bTruncation,
+                              unsigned &part23Length1a, unsigned &part23Length1aTruncation, unsigned &part23Length1b, unsigned &part23Length1bTruncation) {
+    int                       i, j;
+    unsigned                  sfLength, origTotABsize, adjustment;
+    MP3SideInfo::gr_info_s_t *gr;
+
+    /* First, Huffman-decode each part of the segment's main data,
+       to see at which bit-boundaries the samples appear:
+     */
+    MP3HuffmanEncodingInfo hei;
+
+    ++debugCount;
+#ifdef DEBUG
+    fprintf(stderr, "usifh-start: p23L0: %d, p23L1: %d\n", p23L0, p23L1);
+#endif
+
+    /* Process granule 0 */
+    {
+        gr            = &(sideInfo.ch[0].gr[0]);
+        origTotABsize = gr->part2_3_length;
+
+        MP3HuffmanDecode(gr, isMPEG2, mainDataPtr, 0, origTotABsize, sfLength, hei);
+
+        /* Begin by computing new sizes for parts a & b (& their truncations) */
+#ifdef DEBUG
+        fprintf(stderr, "usifh-0: %d, %d:%d, %d:%d, %d:%d, %d:%d, %d:%d\n", hei.numSamples, sfLength / 8, sfLength % 8, hei.reg1Start / 8, hei.reg1Start % 8,
+                hei.reg2Start / 8, hei.reg2Start % 8, hei.bigvalStart / 8, hei.bigvalStart % 8, origTotABsize / 8, origTotABsize % 8);
+#endif
+        if(p23L0 < sfLength) {
+            /* We can't use this, so give it all to the next granule: */
+            p23L1 += p23L0;
+            p23L0 = 0;
+        }
+
+        part23Length0a           = hei.bigvalStart;
+        part23Length0b           = origTotABsize - hei.bigvalStart;
+        part23Length0aTruncation = part23Length0bTruncation = 0;
+        if(origTotABsize > p23L0) {
+            /* We need to shorten one or both of fields a & b */
+            unsigned truncation = origTotABsize - p23L0;
+#ifdef TRUNC_FAIRLY
+            part23Length0aTruncation = (truncation * (part23Length0a - sfLength)) / (origTotABsize - sfLength);
+            part23Length0bTruncation = truncation - part23Length0aTruncation;
+#endif
+#ifdef TRUNC_FAVORa
+            part23Length0bTruncation = (truncation > part23Length0b) ? part23Length0b : truncation;
+            part23Length0aTruncation = truncation - part23Length0bTruncation;
+#endif
+#ifdef TRUNC_FAVORb
+            part23Length0aTruncation = (truncation > part23Length0a - sfLength) ? (part23Length0a - sfLength) : truncation;
+            part23Length0bTruncation = truncation - part23Length0aTruncation;
+#endif
+        }
+        /* ASSERT:  part23Length0xTruncation <= part23Length0x */
+        part23Length0a -= part23Length0aTruncation;
+        part23Length0b -= part23Length0bTruncation;
+#ifdef DEBUG
+        fprintf(stderr, "usifh-0: interim sizes: %d (%d), %d (%d)\n", part23Length0a, part23Length0aTruncation, part23Length0b, part23Length0bTruncation);
+#endif
+
+        /* Adjust these new lengths so they end on sample bit boundaries: */
+        for(i = 0; i < (int)hei.numSamples; ++i) {
+            if(hei.allBitOffsets[i] == part23Length0a)
+                break;
+            else if(hei.allBitOffsets[i] > part23Length0a) {
+                --i;
+                break;
+            }
+        }
+        if(i < 0) { /* should happen only if we couldn't fit sfLength */
+            i          = 0;
+            adjustment = 0;
+        }
+        else {
+            adjustment = part23Length0a - hei.allBitOffsets[i];
+        }
+#ifdef DEBUG
+        fprintf(stderr, "%d usifh-0: adjustment 1: %d\n", debugCount, adjustment);
+#endif
+        part23Length0a -= adjustment;
+        part23Length0aTruncation += adjustment;
+        /* Assign the bits we just shaved to field b and granule 1: */
+        if(part23Length0bTruncation < adjustment) {
+            p23L1 += (adjustment - part23Length0bTruncation);
+            adjustment = part23Length0bTruncation;
+        }
+        part23Length0b += adjustment;
+        part23Length0bTruncation -= adjustment;
+        for(j = i; j < (int)hei.numSamples; ++j) {
+            if(hei.allBitOffsets[j] == part23Length0a + part23Length0aTruncation + part23Length0b)
+                break;
+            else if(hei.allBitOffsets[j] > part23Length0a + part23Length0aTruncation + part23Length0b) {
+                --j;
+                break;
+            }
+        }
+        if(j < 0) { /* should happen only if we couldn't fit sfLength */
+            j          = 0;
+            adjustment = 0;
+        }
+        else {
+            adjustment = part23Length0a + part23Length0aTruncation + part23Length0b - hei.allBitOffsets[j];
+        }
+#ifdef DEBUG
+        fprintf(stderr, "%d usifh-0: adjustment 2: %d\n", debugCount, adjustment);
+#endif
+        if(adjustment > part23Length0b)
+            adjustment = part23Length0b; /*sanity*/
+        part23Length0b -= adjustment;
+        part23Length0bTruncation += adjustment;
+        /* Assign the bits we just shaved to granule 1 */
+        p23L1 += adjustment;
+
+        if(part23Length0aTruncation > 0) {
+            /* Change the granule's 'big_values' field to reflect the truncation */
+            gr->big_values = i;
+        }
+    }
+
+    /* Process granule 1 (MPEG-1 only) */
+
+    if(isMPEG2) {
+        part23Length1a = part23Length1b = 0;
+        part23Length1aTruncation = part23Length1bTruncation = 0;
+    }
+    else {
+        unsigned granule1Offset = origTotABsize + sideInfo.ch[1].gr[0].part2_3_length;
+
+        gr            = &(sideInfo.ch[0].gr[1]);
+        origTotABsize = gr->part2_3_length;
+
+        MP3HuffmanDecode(gr, isMPEG2, mainDataPtr, granule1Offset, origTotABsize, sfLength, hei);
+
+        /* Begin by computing new sizes for parts a & b (& their truncations) */
+#ifdef DEBUG
+        fprintf(stderr, "usifh-1: %d, %d:%d, %d:%d, %d:%d, %d:%d, %d:%d\n", hei.numSamples, sfLength / 8, sfLength % 8, hei.reg1Start / 8, hei.reg1Start % 8,
+                hei.reg2Start / 8, hei.reg2Start % 8, hei.bigvalStart / 8, hei.bigvalStart % 8, origTotABsize / 8, origTotABsize % 8);
+#endif
+        if(p23L1 < sfLength) {
+            /* We can't use this, so give up on this granule: */
+            p23L1 = 0;
+        }
+
+        part23Length1a           = hei.bigvalStart;
+        part23Length1b           = origTotABsize - hei.bigvalStart;
+        part23Length1aTruncation = part23Length1bTruncation = 0;
+        if(origTotABsize > p23L1) {
+            /* We need to shorten one or both of fields a & b */
+            unsigned truncation = origTotABsize - p23L1;
+#ifdef TRUNC_FAIRLY
+            part23Length1aTruncation = (truncation * (part23Length1a - sfLength)) / (origTotABsize - sfLength);
+            part23Length1bTruncation = truncation - part23Length1aTruncation;
+#endif
+#ifdef TRUNC_FAVORa
+            part23Length1bTruncation = (truncation > part23Length1b) ? part23Length1b : truncation;
+            part23Length1aTruncation = truncation - part23Length1bTruncation;
+#endif
+#ifdef TRUNC_FAVORb
+            part23Length1aTruncation = (truncation > part23Length1a - sfLength) ? (part23Length1a - sfLength) : truncation;
+            part23Length1bTruncation = truncation - part23Length1aTruncation;
+#endif
+        }
+        /* ASSERT:  part23Length1xTruncation <= part23Length1x */
+        part23Length1a -= part23Length1aTruncation;
+        part23Length1b -= part23Length1bTruncation;
+#ifdef DEBUG
+        fprintf(stderr, "usifh-1: interim sizes: %d (%d), %d (%d)\n", part23Length1a, part23Length1aTruncation, part23Length1b, part23Length1bTruncation);
+#endif
+
+        /* Adjust these new lengths so they end on sample bit boundaries: */
+        for(i = 0; i < (int)hei.numSamples; ++i) {
+            if(hei.allBitOffsets[i] == part23Length1a)
+                break;
+            else if(hei.allBitOffsets[i] > part23Length1a) {
+                --i;
+                break;
+            }
+        }
+        if(i < 0) { /* should happen only if we couldn't fit sfLength */
+            i          = 0;
+            adjustment = 0;
+        }
+        else {
+            adjustment = part23Length1a - hei.allBitOffsets[i];
+        }
+#ifdef DEBUG
+        fprintf(stderr, "%d usifh-1: adjustment 0: %d\n", debugCount, adjustment);
+#endif
+        part23Length1a -= adjustment;
+        part23Length1aTruncation += adjustment;
+        /* Assign the bits we just shaved to field b: */
+        if(part23Length1bTruncation < adjustment) {
+            adjustment = part23Length1bTruncation;
+        }
+        part23Length1b += adjustment;
+        part23Length1bTruncation -= adjustment;
+        for(j = i; j < (int)hei.numSamples; ++j) {
+            if(hei.allBitOffsets[j] == part23Length1a + part23Length1aTruncation + part23Length1b)
+                break;
+            else if(hei.allBitOffsets[j] > part23Length1a + part23Length1aTruncation + part23Length1b) {
+                --j;
+                break;
+            }
+        }
+        if(j < 0) { /* should happen only if we couldn't fit sfLength */
+            j          = 0;
+            adjustment = 0;
+        }
+        else {
+            adjustment = part23Length1a + part23Length1aTruncation + part23Length1b - hei.allBitOffsets[j];
+        }
+#ifdef DEBUG
+        fprintf(stderr, "%d usifh-1: adjustment 1: %d\n", debugCount, adjustment);
+#endif
+        if(adjustment > part23Length1b)
+            adjustment = part23Length1b; /*sanity*/
+        part23Length1b -= adjustment;
+        part23Length1bTruncation += adjustment;
+
+        if(part23Length1aTruncation > 0) {
+            /* Change the granule's 'big_values' field to reflect the truncation */
+            gr->big_values = i;
+        }
+    }
+#ifdef DEBUG
+    fprintf(stderr, "usifh-end, new vals: %d (%d), %d (%d), %d (%d), %d (%d)\n", part23Length0a, part23Length0aTruncation, part23Length0b,
+            part23Length0bTruncation, part23Length1a, part23Length1aTruncation, part23Length1b, part23Length1bTruncation);
+#endif
+}
+
+static void rsf_getline(char *line, unsigned max, unsigned char **fi) {
+    unsigned i;
+    for(i = 0; i < max; ++i) {
+        line[i] = *(*fi)++;
+        if(line[i] == '\n') {
+            line[i++] = '\0';
+            return;
+        }
+    }
+    line[i] = '\0';
+}
+
+static void rsfscanf(unsigned char **fi, unsigned int *v) {
+    while(sscanf((char *)*fi, "%x", v) == 0) {
+        /* skip past the next '\0' */
+        while(*(*fi)++ != '\0') {
+        }
+    }
+
+    /* skip past any white-space before the value: */
+    while(*(*fi) <= ' ')
+        ++(*fi);
+
+    /* skip past the value: */
+    while(*(*fi) > ' ')
+        ++(*fi);
+}
+
+#define HUFFBITS unsigned long int
+#define SIZEOF_HUFFBITS 4
+#define HTN 34
+#define MXOFF 250
+
+struct huffcodetab {
+    char           tablename[3]; /*string, containing table_description	*/
+    unsigned int   xlen;         /*max. x-index+			      	*/
+    unsigned int   ylen;         /*max. y-index+				*/
+    unsigned int   linbits;      /*number of linbits			*/
+    unsigned int   linmax;       /*max number to be stored in linbits	*/
+    int            ref;          /*a positive value indicates a reference*/
+    HUFFBITS *     table;        /*pointer to array[xlen][ylen]		*/
+    unsigned char *hlen;         /*pointer to array[xlen][ylen]		*/
+    unsigned char (*val)[2];     /*decoder tree				*/
+    unsigned int treelen;        /*length of decoder tree		*/
+};
+
+static struct huffcodetab rsf_ht[HTN];  // array of all huffcodetable headers
+/* 0..31 Huffman code table 0..31	*/
+/* 32,33 count1-tables			*/
+
+/* read the huffman decoder table */
+static int read_decoder_table(unsigned char *fi) {
+    int          n, i, nn, t;
+    unsigned int v0, v1;
+    char         command[100], line[100];
+    for(n = 0; n < HTN; n++) {
+        rsf_ht[n].table = NULL;
+        rsf_ht[n].hlen  = NULL;
+
+        /* .table number treelen xlen ylen linbits */
+        do {
+            rsf_getline(line, 99, &fi);
+        } while((line[0] == '#') || (line[0] < ' '));
+
+        sscanf(line, "%s %s %u %u %u %u", command, rsf_ht[n].tablename, &rsf_ht[n].treelen, &rsf_ht[n].xlen, &rsf_ht[n].ylen, &rsf_ht[n].linbits);
+        if(strcmp(command, ".end") == 0)
+            return n;
+        else if(strcmp(command, ".table") != 0) {
+#ifdef DEBUG
+            fprintf(stderr, "huffman table %u data corrupted\n", n);
+#endif
+            return -1;
+        }
+        rsf_ht[n].linmax = (1 << rsf_ht[n].linbits) - 1;
+
+        sscanf(rsf_ht[n].tablename, "%u", &nn);
+        if(nn != n) {
+#ifdef DEBUG
+            fprintf(stderr, "wrong table number %u\n", n);
+#endif
+            return (-2);
+        }
+        do {
+            rsf_getline(line, 99, &fi);
+        } while((line[0] == '#') || (line[0] < ' '));
+
+        sscanf(line, "%s %u", command, &t);
+        if(strcmp(command, ".reference") == 0) {
+            rsf_ht[n].ref     = t;
+            rsf_ht[n].val     = rsf_ht[t].val;
+            rsf_ht[n].treelen = rsf_ht[t].treelen;
+            if((rsf_ht[n].xlen != rsf_ht[t].xlen) || (rsf_ht[n].ylen != rsf_ht[t].ylen)) {
+#ifdef DEBUG
+                fprintf(stderr, "wrong table %u reference\n", n);
+#endif
+                return (-3);
+            };
+            while((line[0] == '#') || (line[0] < ' ')) {
+                rsf_getline(line, 99, &fi);
+            }
+        }
+        else if(strcmp(command, ".treedata") == 0) {
+            rsf_ht[n].ref = -1;
+            rsf_ht[n].val = (unsigned char(*)[2]) new unsigned char[2 * (rsf_ht[n].treelen)];
+            if((rsf_ht[n].val == NULL) && (rsf_ht[n].treelen != 0)) {
+#ifdef DEBUG
+                fprintf(stderr, "heaperror at table %d\n", n);
+#endif
+                return -1;
+            }
+            for(i = 0; (unsigned)i < rsf_ht[n].treelen; i++) {
+                rsfscanf(&fi, &v0);
+                rsfscanf(&fi, &v1);
+                /*replaces        fscanf(fi,"%x %x",&v0, &v1);*/
+                rsf_ht[n].val[i][0] = (unsigned char)v0;
+                rsf_ht[n].val[i][1] = (unsigned char)v1;
+            }
+            rsf_getline(line, 99, &fi); /* read the rest of the line */
+        }
+        else {
+#ifdef DEBUG
+            fprintf(stderr, "huffman decodertable error at table %d\n", n);
+#endif
+        }
+    }
+    return n;
+}
+
+static void initialize_huffman() {
+    static Boolean huffman_initialized = False;
+
+    if(huffman_initialized)
+        return;
+
+    if(read_decoder_table(huffdec) != HTN) {
+#ifdef DEBUG
+        fprintf(stderr, "decoder table read error\n");
+#endif
+        return;
+    }
+    huffman_initialized = True;
+}
+
+static unsigned char const slen[2][16] = { { 0, 0, 0, 0, 3, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4 }, { 0, 1, 2, 3, 0, 1, 2, 3, 1, 2, 3, 1, 2, 3, 2, 3 } };
+
+static unsigned char const stab[3][6][4] = { { { 6, 5, 5, 5 }, { 6, 5, 7, 3 }, { 11, 10, 0, 0 }, { 7, 7, 7, 0 }, { 6, 6, 6, 3 }, { 8, 8, 5, 0 } },
+                                             { { 9, 9, 9, 9 }, { 9, 9, 12, 6 }, { 18, 18, 0, 0 }, { 12, 12, 12, 0 }, { 12, 9, 9, 6 }, { 15, 12, 9, 0 } },
+                                             { { 6, 9, 9, 9 }, { 6, 9, 12, 6 }, { 15, 18, 0, 0 }, { 6, 15, 12, 0 }, { 6, 12, 9, 6 }, { 6, 18, 9, 0 } } };
+
+static unsigned rsf_get_scale_factors_1(MP3SideInfo::gr_info_s_t *gr_info) {
+    int numbits;
+    int num0 = slen[0][gr_info->scalefac_compress];
+    int num1 = slen[1][gr_info->scalefac_compress];
+
+    if(gr_info->block_type == 2) {
+        numbits = (num0 + num1) * 18;
+
+        if(gr_info->mixed_block_flag) {
+            numbits -= num0; /* num0 * 17 + num1 * 18 */
+        }
+    }
+    else {
+        int scfsi = gr_info->scfsi;
+
+        if(scfsi < 0) { /* scfsi < 0 => granule == 0 */
+            numbits = (num0 + num1) * 10 + num0;
+        }
+        else {
+            numbits = 0;
+            if(!(scfsi & 0x8)) {
+                numbits += num0 * 6;
+            }
+            else {
+            }
+
+            if(!(scfsi & 0x4)) {
+                numbits += num0 * 5;
+            }
+            else {
+            }
+
+            if(!(scfsi & 0x2)) {
+                numbits += num1 * 5;
+            }
+            else {
+            }
+
+            if(!(scfsi & 0x1)) {
+                numbits += num1 * 5;
+            }
+            else {
+            }
+        }
+    }
+
+    return numbits;
+}
+
+extern unsigned n_slen2[];
+extern unsigned i_slen2[];
+
+static unsigned rsf_get_scale_factors_2(MP3SideInfo::gr_info_s_t *gr_info) {
+    unsigned char const *pnt;
+    int                  i;
+    unsigned int         slen;
+    int                  n       = 0;
+    int                  numbits = 0;
+
+    slen = n_slen2[gr_info->scalefac_compress];
+
+    gr_info->preflag = (slen >> 15) & 0x1;
+
+    n = 0;
+    if(gr_info->block_type == 2) {
+        n++;
+        if(gr_info->mixed_block_flag)
+            n++;
+    }
+
+    pnt = stab[n][(slen >> 12) & 0x7];
+
+    for(i = 0; i < 4; i++) {
+        int num = slen & 0x7;
+        slen >>= 3;
+        numbits += pnt[i] * num;
+    }
+
+    return numbits;
+}
+
+static unsigned getScaleFactorsLength(MP3SideInfo::gr_info_s_t *gr, Boolean isMPEG2) {
+    return isMPEG2 ? rsf_get_scale_factors_2(gr) : rsf_get_scale_factors_1(gr);
+}
+
+static int rsf_huffman_decoder(BitVector &bv, struct huffcodetab const *h, int *x, int *y, int *v, int *w);  // forward
+
+void MP3HuffmanDecode(MP3SideInfo::gr_info_s_t *gr, Boolean isMPEG2, unsigned char const *fromBasePtr, unsigned fromBitOffset, unsigned fromLength,
+                      unsigned &scaleFactorsLength, MP3HuffmanEncodingInfo &hei) {
+    unsigned            i;
+    int                 x, y, v, w;
+    struct huffcodetab *h;
+    BitVector           bv((unsigned char *)fromBasePtr, fromBitOffset, fromLength);
+
+    /* Compute the size of the scale factors (& also advance bv): */
+    scaleFactorsLength = getScaleFactorsLength(gr, isMPEG2);
+    bv.skipBits(scaleFactorsLength);
+
+    initialize_huffman();
+
+    hei.reg1Start = hei.reg2Start = hei.numSamples = 0;
+
+    /* Read bigvalues area. */
+    if(gr->big_values < gr->region1start + gr->region2start) {
+        gr->big_values = gr->region1start + gr->region2start; /* sanity check */
+    }
+    for(i = 0; i < gr->big_values; ++i) {
+        if(i < gr->region1start) {
+            /* in region 0 */
+            h = &rsf_ht[gr->table_select[0]];
+        }
+        else if(i < gr->region2start) {
+            /* in region 1 */
+            h = &rsf_ht[gr->table_select[1]];
+            if(hei.reg1Start == 0) {
+                hei.reg1Start = bv.curBitIndex();
+            }
+        }
+        else {
+            /* in region 2 */
+            h = &rsf_ht[gr->table_select[2]];
+            if(hei.reg2Start == 0) {
+                hei.reg2Start = bv.curBitIndex();
+            }
+        }
+
+        hei.allBitOffsets[i] = bv.curBitIndex();
+        rsf_huffman_decoder(bv, h, &x, &y, &v, &w);
+        if(hei.decodedValues != NULL) {
+            // Record the decoded values:
+            unsigned *ptr = &hei.decodedValues[4 * i];
+            ptr[0]        = x;
+            ptr[1]        = y;
+            ptr[2]        = v;
+            ptr[3]        = w;
+        }
+    }
+    hei.bigvalStart = bv.curBitIndex();
+
+    /* Read count1 area. */
+    h = &rsf_ht[gr->count1table_select + 32];
+    while(bv.curBitIndex() < bv.totNumBits() && i < SSLIMIT * SBLIMIT) {
+        hei.allBitOffsets[i] = bv.curBitIndex();
+        rsf_huffman_decoder(bv, h, &x, &y, &v, &w);
+        if(hei.decodedValues != NULL) {
+            // Record the decoded values:
+            unsigned *ptr = &hei.decodedValues[4 * i];
+            ptr[0]        = x;
+            ptr[1]        = y;
+            ptr[2]        = v;
+            ptr[3]        = w;
+        }
+        ++i;
+    }
+
+    hei.allBitOffsets[i] = bv.curBitIndex();
+    hei.numSamples       = i;
+}
+
+HUFFBITS     dmask = 1 << (SIZEOF_HUFFBITS * 8 - 1);
+unsigned int hs    = SIZEOF_HUFFBITS * 8;
+
+/* do the huffman-decoding 						*/
+static int rsf_huffman_decoder(BitVector &               bv,
+                               struct huffcodetab const *h,  // ptr to huffman code record
+                               /* unsigned */ int *      x,  // returns decoded x value
+                               /* unsigned */ int *      y,  // returns decoded y value
+                               int *v, int *w) {
+    HUFFBITS level;
+    unsigned point = 0;
+    int      error = 1;
+    level          = dmask;
+    *x = *y = *v = *w = 0;
+    if(h->val == NULL)
+        return 2;
+
+    /* table 0 needs no bits */
+    if(h->treelen == 0)
+        return 0;
+
+    /* Lookup in Huffman table. */
+
+    do {
+        if(h->val[point][0] == 0) { /*end of tree*/
+            *x = h->val[point][1] >> 4;
+            *y = h->val[point][1] & 0xf;
+
+            error = 0;
+            break;
+        }
+        if(bv.get1Bit()) {
+            while(h->val[point][1] >= MXOFF)
+                point += h->val[point][1];
+            point += h->val[point][1];
+        }
+        else {
+            while(h->val[point][0] >= MXOFF)
+                point += h->val[point][0];
+            point += h->val[point][0];
+        }
+        level >>= 1;
+    } while(level || (point < h->treelen));
+    /////  } while (level  || (point < rsf_ht->treelen) );
+
+    /* Check for error. */
+
+    if(error) { /* set x and y to a medium value as a simple concealment */
+        printf("Illegal Huffman code in data.\n");
+        *x = ((h->xlen - 1) << 1);
+        *y = ((h->ylen - 1) << 1);
+    }
+
+    /* Process sign encodings for quadruples tables. */
+
+    if(h->tablename[0] == '3' && (h->tablename[1] == '2' || h->tablename[1] == '3')) {
+        *v = (*y >> 3) & 1;
+        *w = (*y >> 2) & 1;
+        *x = (*y >> 1) & 1;
+        *y = *y & 1;
+
+        if(*v)
+            if(bv.get1Bit() == 1)
+                *v = -*v;
+        if(*w)
+            if(bv.get1Bit() == 1)
+                *w = -*w;
+        if(*x)
+            if(bv.get1Bit() == 1)
+                *x = -*x;
+        if(*y)
+            if(bv.get1Bit() == 1)
+                *y = -*y;
+    }
+
+    /* Process sign and escape encodings for dual tables. */
+
+    else {
+        if(h->linbits)
+            if((h->xlen - 1) == (unsigned)*x)
+                *x += bv.getBits(h->linbits);
+        if(*x)
+            if(bv.get1Bit() == 1)
+                *x = -*x;
+        if(h->linbits)
+            if((h->ylen - 1) == (unsigned)*y)
+                *y += bv.getBits(h->linbits);
+        if(*y)
+            if(bv.get1Bit() == 1)
+                *y = -*y;
+    }
+
+    return error;
+}
+
+#ifdef DO_HUFFMAN_ENCODING
+inline int getNextSample(unsigned char const *&fromPtr) {
+    int sample
+#ifdef FOUR_BYTE_SAMPLES
+        = (fromPtr[0] << 24) | (fromPtr[1] << 16) | (fromPtr[2] << 8) | fromPtr[3];
+#else
+#ifdef TWO_BYTE_SAMPLES
+        = (fromPtr[0] << 8) | fromPtr[1];
+#else
+        // ONE_BYTE_SAMPLES
+        = fromPtr[0];
+#endif
+#endif
+    fromPtr += BYTES_PER_SAMPLE_VALUE;
+    return sample;
+}
+
+static void rsf_huffman_encoder(BitVector &bv, struct huffcodetab *h, int x, int y, int v, int w);  // forward
+
+unsigned MP3HuffmanEncode(MP3SideInfo::gr_info_s_t const *gr, unsigned char const *fromPtr, unsigned char *toPtr, unsigned toBitOffset, unsigned numHuffBits) {
+    unsigned            i;
+    struct huffcodetab *h;
+    int                 x, y, v, w;
+    BitVector           bv(toPtr, toBitOffset, numHuffBits);
+
+    initialize_huffman();
+
+    // Encode big_values area:
+    unsigned big_values = gr->big_values;
+    if(big_values < gr->region1start + gr->region2start) {
+        big_values = gr->region1start + gr->region2start; /* sanity check */
+    }
+    for(i = 0; i < big_values; ++i) {
+        if(i < gr->region1start) {
+            /* in region 0 */
+            h = &rsf_ht[gr->table_select[0]];
+        }
+        else if(i < gr->region2start) {
+            /* in region 1 */
+            h = &rsf_ht[gr->table_select[1]];
+        }
+        else {
+            /* in region 2 */
+            h = &rsf_ht[gr->table_select[2]];
+        }
+
+        x = getNextSample(fromPtr);
+        y = getNextSample(fromPtr);
+        v = getNextSample(fromPtr);
+        w = getNextSample(fromPtr);
+        rsf_huffman_encoder(bv, h, x, y, v, w);
+    }
+
+    // Encode count1 area:
+    h = &rsf_ht[gr->count1table_select + 32];
+    while(bv.curBitIndex() < bv.totNumBits() && i < SSLIMIT * SBLIMIT) {
+        x = getNextSample(fromPtr);
+        y = getNextSample(fromPtr);
+        v = getNextSample(fromPtr);
+        w = getNextSample(fromPtr);
+        rsf_huffman_encoder(bv, h, x, y, v, w);
+        ++i;
+    }
+
+    return i;
+}
+
+static Boolean lookupHuffmanTableEntry(struct huffcodetab const *h, HUFFBITS bits, unsigned bitsLength, unsigned char &xy) {
+    unsigned point              = 0;
+    unsigned mask               = 1;
+    unsigned numBitsTestedSoFar = 0;
+    do {
+        if(h->val[point][0] == 0) {  // end of tree
+            xy = h->val[point][1];
+            if(h->hlen[xy] == 0) {  // this entry hasn't already been used
+                h->table[xy] = bits;
+                h->hlen[xy]  = bitsLength;
+                return True;
+            }
+            else {  // this entry has already been seen
+                return False;
+            }
+        }
+
+        if(numBitsTestedSoFar++ == bitsLength) {
+            // We don't yet have enough bits for this prefix
+            return False;
+        }
+        if(bits & mask) {
+            while(h->val[point][1] >= MXOFF)
+                point += h->val[point][1];
+            point += h->val[point][1];
+        }
+        else {
+            while(h->val[point][0] >= MXOFF)
+                point += h->val[point][0];
+            point += h->val[point][0];
+        }
+        mask <<= 1;
+    } while(mask || (point < h->treelen));
+
+    return False;
+}
+
+static void buildHuffmanEncodingTable(struct huffcodetab *h) {
+    h->table = new unsigned long[256];
+    h->hlen  = new unsigned char[256];
+    if(h->table == NULL || h->hlen == NULL) {
+        h->table = NULL;
+        return;
+    }
+    for(unsigned i = 0; i < 256; ++i) {
+        h->table[i] = 0;
+        h->hlen[i]  = 0;
+    }
+
+    // Look up entries for each possible bit sequence length:
+    unsigned maxNumEntries = h->xlen * h->ylen;
+    unsigned numEntries    = 0;
+    unsigned powerOf2      = 1;
+    for(unsigned bitsLength = 1; bitsLength <= 8 * SIZEOF_HUFFBITS; ++bitsLength) {
+        powerOf2 *= 2;
+        for(HUFFBITS bits = 0; bits < powerOf2; ++bits) {
+            // Find the table value - if any - for 'bits' (length 'bitsLength'):
+            unsigned char xy;
+            if(lookupHuffmanTableEntry(h, bits, bitsLength, xy)) {
+                ++numEntries;
+                if(numEntries == maxNumEntries)
+                    return;  // we're done
+            }
+        }
+    }
+#ifdef DEBUG
+    fprintf(stderr, "Didn't find enough entries!\n");  // shouldn't happen
+#endif
+}
+
+static void lookupXYandPutBits(BitVector &bv, struct huffcodetab const *h, unsigned char xy) {
+    HUFFBITS bits       = h->table[xy];
+    unsigned bitsLength = h->hlen[xy];
+
+    // Note that "bits" is in reverse order, so read them from right-to-left:
+    while(bitsLength-- > 0) {
+        bv.put1Bit(bits & 0x00000001);
+        bits >>= 1;
+    }
+}
+
+static void putLinbits(BitVector &bv, struct huffcodetab const *h, HUFFBITS bits) {
+    bv.putBits(bits, h->linbits);
+}
+
+static void rsf_huffman_encoder(BitVector &bv, struct huffcodetab *h, int x, int y, int v, int w) {
+    if(h->val == NULL)
+        return;
+
+    /* table 0 produces no bits */
+    if(h->treelen == 0)
+        return;
+
+    if(h->table == NULL) {
+        // We haven't yet built the encoding array for this table; do it now:
+        buildHuffmanEncodingTable(h);
+        if(h->table == NULL)
+            return;
+    }
+
+    Boolean       xIsNeg = False, yIsNeg = False, vIsNeg = False, wIsNeg = False;
+    unsigned char xy;
+
+#ifdef FOUR_BYTE_SAMPLES
+#else
+#ifdef TWO_BYTE_SAMPLES
+    // Convert 2-byte negative numbers to their 4-byte equivalents:
+    if(x & 0x8000)
+        x |= 0xFFFF0000;
+    if(y & 0x8000)
+        y |= 0xFFFF0000;
+    if(v & 0x8000)
+        v |= 0xFFFF0000;
+    if(w & 0x8000)
+        w |= 0xFFFF0000;
+#else
+    // ONE_BYTE_SAMPLES
+    // Convert 1-byte negative numbers to their 4-byte equivalents:
+    if(x & 0x80)
+        x |= 0xFFFFFF00;
+    if(y & 0x80)
+        y |= 0xFFFFFF00;
+    if(v & 0x80)
+        v |= 0xFFFFFF00;
+    if(w & 0x80)
+        w |= 0xFFFFFF00;
+#endif
+#endif
+
+    if(h->tablename[0] == '3' && (h->tablename[1] == '2' || h->tablename[1] == '3')) {  // quad tables
+        if(x < 0) {
+            xIsNeg = True;
+            x      = -x;
+        }
+        if(y < 0) {
+            yIsNeg = True;
+            y      = -y;
+        }
+        if(v < 0) {
+            vIsNeg = True;
+            v      = -v;
+        }
+        if(w < 0) {
+            wIsNeg = True;
+            w      = -w;
+        }
+
+        // Sanity check: x,y,v,w must all be 0 or 1:
+        if(x > 1 || y > 1 || v > 1 || w > 1) {
+#ifdef DEBUG
+            fprintf(stderr, "rsf_huffman_encoder quad sanity check fails: %x,%x,%x,%x\n", x, y, v, w);
+#endif
+        }
+
+        xy = (v << 3) | (w << 2) | (x << 1) | y;
+        lookupXYandPutBits(bv, h, xy);
+
+        if(v)
+            bv.put1Bit(vIsNeg);
+        if(w)
+            bv.put1Bit(wIsNeg);
+        if(x)
+            bv.put1Bit(xIsNeg);
+        if(y)
+            bv.put1Bit(yIsNeg);
+    }
+    else {  // dual tables
+        // Sanity check: v and w must be 0:
+        if(v != 0 || w != 0) {
+#ifdef DEBUG
+            fprintf(stderr, "rsf_huffman_encoder dual sanity check 1 fails: %x,%x,%x,%x\n", x, y, v, w);
+#endif
+        }
+
+        if(x < 0) {
+            xIsNeg = True;
+            x      = -x;
+        }
+        if(y < 0) {
+            yIsNeg = True;
+            y      = -y;
+        }
+
+        // Sanity check: x and y must be <= 255:
+        if(x > 255 || y > 255) {
+#ifdef DEBUG
+            fprintf(stderr, "rsf_huffman_encoder dual sanity check 2 fails: %x,%x,%x,%x\n", x, y, v, w);
+#endif
+        }
+
+        int      xl1      = h->xlen - 1;
+        int      yl1      = h->ylen - 1;
+        unsigned linbitsX = 0;
+        unsigned linbitsY = 0;
+
+        if(((x < xl1) || (xl1 == 0)) && (y < yl1)) {
+            // normal case
+            xy = (x << 4) | y;
+            lookupXYandPutBits(bv, h, xy);
+            if(x)
+                bv.put1Bit(xIsNeg);
+            if(y)
+                bv.put1Bit(yIsNeg);
+        }
+        else if(x >= xl1) {
+            linbitsX = (unsigned)(x - xl1);
+            if(linbitsX > h->linmax) {
+#ifdef DEBUG
+                fprintf(stderr, "warning: Huffman X table overflow\n");
+#endif
+                linbitsX = h->linmax;
+            };
+
+            if(y >= yl1) {
+                xy = (xl1 << 4) | yl1;
+                lookupXYandPutBits(bv, h, xy);
+                linbitsY = (unsigned)(y - yl1);
+                if(linbitsY > h->linmax) {
+#ifdef DEBUG
+                    fprintf(stderr, "warning: Huffman Y table overflow\n");
+#endif
+                    linbitsY = h->linmax;
+                };
+
+                if(h->linbits)
+                    putLinbits(bv, h, linbitsX);
+                if(x)
+                    bv.put1Bit(xIsNeg);
+                if(h->linbits)
+                    putLinbits(bv, h, linbitsY);
+                if(y)
+                    bv.put1Bit(yIsNeg);
+            }
+            else { /* x >= h->xlen, y < h->ylen */
+                xy = (xl1 << 4) | y;
+                lookupXYandPutBits(bv, h, xy);
+                if(h->linbits)
+                    putLinbits(bv, h, linbitsX);
+                if(x)
+                    bv.put1Bit(xIsNeg);
+                if(y)
+                    bv.put1Bit(yIsNeg);
+            }
+        }
+        else { /* ((x < h->xlen) && (y >= h->ylen)) */
+            xy = (x << 4) | yl1;
+            lookupXYandPutBits(bv, h, xy);
+            linbitsY = y - yl1;
+            if(linbitsY > h->linmax) {
+#ifdef DEBUG
+                fprintf(stderr, "warning: Huffman Y table overflow\n");
+#endif
+                linbitsY = h->linmax;
+            };
+            if(x)
+                bv.put1Bit(xIsNeg);
+            if(h->linbits)
+                putLinbits(bv, h, linbitsY);
+            if(y)
+                bv.put1Bit(yIsNeg);
+        }
+    }
+}
+#endif
diff --git a/3rdparty/live555/src/liveMedia/MP3InternalsHuffman.hh b/3rdparty/live555/src/liveMedia/MP3InternalsHuffman.hh
new file mode 100644
index 00000000..46c9f7f1
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/MP3InternalsHuffman.hh
@@ -0,0 +1,82 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// MP3 internal implementation details (Huffman encoding)
+// C++ header
+
+#ifndef _MP3_INTERNALS_HUFFMAN_HH
+#define _MP3_INTERNALS_HUFFMAN_HH
+
+#ifndef _MP3_INTERNALS_HH
+#include "MP3Internals.hh"
+#endif
+
+void updateSideInfoForHuffman(MP3SideInfo& sideInfo, Boolean isMPEG2,
+			      unsigned char const* mainDataPtr,
+			      unsigned p23L0, unsigned p23L1,
+			      unsigned& part23Length0a,
+			      unsigned& part23Length0aTruncation,
+			      unsigned& part23Length0b,
+			      unsigned& part23Length0bTruncation,
+			      unsigned& part23Length1a,
+			      unsigned& part23Length1aTruncation,
+			      unsigned& part23Length1b,
+			      unsigned& part23Length1bTruncation);
+
+#define SSLIMIT 18
+
+class MP3HuffmanEncodingInfo {
+public:
+  MP3HuffmanEncodingInfo(Boolean includeDecodedValues = False);
+  ~MP3HuffmanEncodingInfo();
+
+public:
+  unsigned numSamples;
+  unsigned allBitOffsets[SBLIMIT*SSLIMIT + 1];
+  unsigned reg1Start, reg2Start, bigvalStart; /* special bit offsets */
+  unsigned* decodedValues;
+};
+
+/* forward */
+void MP3HuffmanDecode(MP3SideInfo::gr_info_s_t* gr, Boolean isMPEG2,
+		      unsigned char const* fromBasePtr,
+		      unsigned fromBitOffset, unsigned fromLength,
+		      unsigned& scaleFactorsLength,
+		      MP3HuffmanEncodingInfo& hei);
+
+extern unsigned char huffdec[]; // huffman table data
+
+// The following are used if we process Huffman-decoded values
+#ifdef FOUR_BYTE_SAMPLES
+#define BYTES_PER_SAMPLE_VALUE 4
+#else
+#ifdef TWO_BYTE_SAMPLES
+#define BYTES_PER_SAMPLE_VALUE 2
+#else
+// ONE_BYTE_SAMPLES
+#define BYTES_PER_SAMPLE_VALUE 1
+#endif
+#endif
+
+#ifdef DO_HUFFMAN_ENCODING
+unsigned MP3HuffmanEncode(MP3SideInfo::gr_info_s_t const* gr,
+			  unsigned char const* fromPtr,
+			  unsigned char* toPtr, unsigned toBitOffset,
+			  unsigned numHuffBits);
+#endif
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/MP3InternalsHuffmanTable.cpp b/3rdparty/live555/src/liveMedia/MP3InternalsHuffmanTable.cpp
new file mode 100644
index 00000000..0f1a63b5
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/MP3InternalsHuffmanTable.cpp
@@ -0,0 +1,728 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// MP3 internal implementation details (Huffman encoding)
+// Table
+
+#include "MP3InternalsHuffman.hh"
+
+unsigned char huffdec[] = {
+    0x0a, 0x2e, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x20, 0x30, 0x20, 0x20, 0x20, 0x30, 0x20, 0x20, 0x30, 0x20, 0x20, 0x30, 0x20, 0x20, 0x30, 0x0a, 0x2e, 0x74,
+    0x72, 0x65, 0x65, 0x64, 0x61, 0x74, 0x61, 0x0a, 0x0a, 0x2e, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x20, 0x31, 0x20, 0x20, 0x20, 0x37, 0x20, 0x20, 0x32, 0x20,
+    0x20, 0x32, 0x20, 0x20, 0x30, 0x0a, 0x2e, 0x74, 0x72, 0x65, 0x65, 0x64, 0x61, 0x74, 0x61, 0x0a, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x20,
+    0x30, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x31, 0x30, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x20, 0x31, 0x20,
+    0x20, 0x30, 0x20, 0x31, 0x31, 0x20, 0x0a, 0x0a, 0x2e, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x37, 0x20, 0x20, 0x33, 0x20, 0x20,
+    0x33, 0x20, 0x20, 0x30, 0x0a, 0x2e, 0x74, 0x72, 0x65, 0x65, 0x64, 0x61, 0x74, 0x61, 0x0a, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x20, 0x30,
+    0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x31, 0x30, 0x20, 0x20, 0x30, 0x20, 0x20, 0x31, 0x20, 0x20,
+    0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x31, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20,
+    0x32, 0x30, 0x20, 0x20, 0x30, 0x20, 0x32, 0x31, 0x20, 0x0a, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x31, 0x32, 0x20, 0x20, 0x32, 0x20, 0x20,
+    0x31, 0x20, 0x20, 0x30, 0x20, 0x20, 0x32, 0x20, 0x20, 0x30, 0x20, 0x32, 0x32, 0x20, 0x0a, 0x0a, 0x2e, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x20, 0x33, 0x20,
+    0x20, 0x31, 0x37, 0x20, 0x20, 0x33, 0x20, 0x20, 0x33, 0x20, 0x20, 0x30, 0x0a, 0x2e, 0x74, 0x72, 0x65, 0x65, 0x64, 0x61, 0x74, 0x61, 0x0a, 0x20, 0x34, 0x20,
+    0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x20, 0x30, 0x20, 0x20, 0x30, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31,
+    0x20, 0x20, 0x30, 0x20, 0x31, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x31, 0x30, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20,
+    0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x32, 0x30, 0x20, 0x20, 0x30, 0x20, 0x32, 0x31, 0x20, 0x0a, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30,
+    0x20, 0x31, 0x32, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x20, 0x32, 0x20, 0x20, 0x30, 0x20, 0x32, 0x32, 0x20, 0x0a, 0x0a, 0x2e, 0x74,
+    0x61, 0x62, 0x6c, 0x65, 0x20, 0x20, 0x34, 0x20, 0x20, 0x20, 0x30, 0x20, 0x20, 0x30, 0x20, 0x20, 0x30, 0x20, 0x20, 0x30, 0x0a, 0x2e, 0x74, 0x72, 0x65, 0x65,
+    0x64, 0x61, 0x74, 0x61, 0x0a, 0x0a, 0x2e, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x20, 0x35, 0x20, 0x20, 0x33, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x34, 0x20,
+    0x20, 0x30, 0x0a, 0x2e, 0x74, 0x72, 0x65, 0x65, 0x64, 0x61, 0x74, 0x61, 0x0a, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x20, 0x30, 0x20, 0x20,
+    0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x31, 0x30, 0x20, 0x20, 0x30, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20,
+    0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x31, 0x31, 0x20, 0x20, 0x38, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31,
+    0x20, 0x20, 0x30, 0x20, 0x32, 0x30, 0x20, 0x0a, 0x20, 0x30, 0x20, 0x20, 0x32, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x32, 0x31, 0x20,
+    0x20, 0x30, 0x20, 0x31, 0x32, 0x20, 0x20, 0x38, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30,
+    0x20, 0x32, 0x32, 0x20, 0x20, 0x30, 0x20, 0x33, 0x30, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x20, 0x33, 0x20, 0x20, 0x30, 0x20, 0x31,
+    0x33, 0x20, 0x0a, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x33, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x33, 0x32,
+    0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x32, 0x33, 0x20, 0x20, 0x30, 0x20, 0x33, 0x33, 0x20, 0x0a, 0x0a, 0x2e, 0x74, 0x61, 0x62, 0x6c,
+    0x65, 0x20, 0x20, 0x36, 0x20, 0x20, 0x33, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x34, 0x20, 0x20, 0x30, 0x0a, 0x2e, 0x74, 0x72, 0x65, 0x65, 0x64, 0x61, 0x74,
+    0x61, 0x0a, 0x20, 0x36, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x20, 0x30, 0x20,
+    0x20, 0x30, 0x20, 0x31, 0x30, 0x20, 0x20, 0x30, 0x20, 0x31, 0x31, 0x20, 0x20, 0x36, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30,
+    0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x32, 0x30, 0x20, 0x20, 0x30, 0x20, 0x32, 0x31, 0x20, 0x0a, 0x20, 0x36, 0x20,
+    0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x31, 0x32, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x20, 0x32,
+    0x20, 0x20, 0x30, 0x20, 0x32, 0x32, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x33, 0x31, 0x20, 0x20,
+    0x30, 0x20, 0x31, 0x33, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x0a, 0x20, 0x30, 0x20, 0x33, 0x30, 0x20, 0x20, 0x30,
+    0x20, 0x33, 0x32, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x32, 0x33, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x20,
+    0x33, 0x20, 0x20, 0x30, 0x20, 0x33, 0x33, 0x20, 0x0a, 0x0a, 0x2e, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x20, 0x37, 0x20, 0x20, 0x37, 0x31, 0x20, 0x20, 0x36,
+    0x20, 0x20, 0x36, 0x20, 0x20, 0x30, 0x0a, 0x2e, 0x74, 0x72, 0x65, 0x65, 0x64, 0x61, 0x74, 0x61, 0x0a, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20,
+    0x20, 0x30, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x31, 0x30, 0x20, 0x20, 0x30, 0x20, 0x20, 0x31,
+    0x20, 0x20, 0x38, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x31, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20,
+    0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x32, 0x30, 0x20, 0x0a, 0x20, 0x30, 0x20, 0x20, 0x32, 0x20, 0x20, 0x30, 0x20, 0x32, 0x31, 0x20, 0x31, 0x32,
+    0x20, 0x20, 0x31, 0x20, 0x20, 0x36, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x31, 0x32, 0x20, 0x20, 0x32, 0x20, 0x20,
+    0x31, 0x20, 0x20, 0x30, 0x20, 0x32, 0x32, 0x20, 0x20, 0x30, 0x20, 0x33, 0x30, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20,
+    0x20, 0x30, 0x20, 0x33, 0x31, 0x20, 0x0a, 0x20, 0x30, 0x20, 0x31, 0x33, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20,
+    0x30, 0x20, 0x20, 0x33, 0x20, 0x20, 0x30, 0x20, 0x33, 0x32, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x32, 0x33, 0x20, 0x20, 0x30, 0x20,
+    0x20, 0x34, 0x20, 0x20, 0x61, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x34, 0x30,
+    0x20, 0x0a, 0x20, 0x30, 0x20, 0x34, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x31, 0x34, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20,
+    0x20, 0x30, 0x20, 0x34, 0x32, 0x20, 0x20, 0x30, 0x20, 0x32, 0x34, 0x20, 0x20, 0x63, 0x20, 0x20, 0x31, 0x20, 0x20, 0x36, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34,
+    0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x33, 0x33, 0x20, 0x20, 0x30, 0x20, 0x34, 0x33, 0x20, 0x0a, 0x20, 0x30, 0x20,
+    0x35, 0x30, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x33, 0x34, 0x20, 0x20, 0x30, 0x20, 0x20, 0x35,
+    0x20, 0x20, 0x30, 0x20, 0x35, 0x31, 0x20, 0x20, 0x36, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x31, 0x35, 0x20, 0x20,
+    0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x35, 0x32, 0x20, 0x20, 0x30, 0x20, 0x32, 0x35, 0x20, 0x0a, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32,
+    0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x34, 0x34, 0x20, 0x20, 0x30, 0x20, 0x33, 0x35, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20,
+    0x31, 0x20, 0x20, 0x30, 0x20, 0x35, 0x33, 0x20, 0x20, 0x30, 0x20, 0x35, 0x34, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x34, 0x35, 0x20,
+    0x20, 0x30, 0x20, 0x35, 0x35, 0x20, 0x0a, 0x0a, 0x2e, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x20, 0x38, 0x20, 0x20, 0x37, 0x31, 0x20, 0x20, 0x36, 0x20, 0x20,
+    0x36, 0x20, 0x20, 0x30, 0x0a, 0x2e, 0x74, 0x72, 0x65, 0x65, 0x64, 0x61, 0x74, 0x61, 0x0a, 0x20, 0x36, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31,
+    0x20, 0x20, 0x30, 0x20, 0x20, 0x30, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x31, 0x30, 0x20, 0x20, 0x30, 0x20, 0x20, 0x31, 0x20, 0x20,
+    0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x31, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20,
+    0x32, 0x31, 0x20, 0x20, 0x30, 0x20, 0x31, 0x32, 0x20, 0x0a, 0x20, 0x65, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20,
+    0x31, 0x20, 0x20, 0x30, 0x20, 0x32, 0x30, 0x20, 0x20, 0x30, 0x20, 0x20, 0x32, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x32, 0x32, 0x20,
+    0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x33, 0x30, 0x20, 0x20, 0x30, 0x20, 0x20, 0x33, 0x20, 0x20, 0x32,
+    0x20, 0x20, 0x31, 0x20, 0x0a, 0x20, 0x30, 0x20, 0x33, 0x31, 0x20, 0x20, 0x30, 0x20, 0x31, 0x33, 0x20, 0x20, 0x65, 0x20, 0x20, 0x31, 0x20, 0x20, 0x38, 0x20,
+    0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x33, 0x32, 0x20, 0x20, 0x30, 0x20, 0x32, 0x33,
+    0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x34, 0x30, 0x20, 0x20, 0x30, 0x20, 0x20, 0x34, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x0a,
+    0x20, 0x30, 0x20, 0x34, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x31, 0x34, 0x20, 0x20, 0x30, 0x20, 0x34, 0x32, 0x20, 0x20, 0x63,
+    0x20, 0x20, 0x31, 0x20, 0x20, 0x36, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x32, 0x34, 0x20, 0x20, 0x32, 0x20, 0x20,
+    0x31, 0x20, 0x20, 0x30, 0x20, 0x33, 0x33, 0x20, 0x20, 0x30, 0x20, 0x35, 0x30, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x0a, 0x20, 0x32, 0x20, 0x20, 0x31,
+    0x20, 0x20, 0x30, 0x20, 0x34, 0x33, 0x20, 0x20, 0x30, 0x20, 0x33, 0x34, 0x20, 0x20, 0x30, 0x20, 0x35, 0x31, 0x20, 0x20, 0x36, 0x20, 0x20, 0x31, 0x20, 0x20,
+    0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x31, 0x35, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x20, 0x35, 0x20, 0x20, 0x30, 0x20,
+    0x35, 0x32, 0x20, 0x20, 0x36, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x0a, 0x20, 0x30, 0x20, 0x32, 0x35, 0x20, 0x20, 0x32, 0x20, 0x20,
+    0x31, 0x20, 0x20, 0x30, 0x20, 0x34, 0x34, 0x20, 0x20, 0x30, 0x20, 0x33, 0x35, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x35, 0x33, 0x20,
+    0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x34, 0x35, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x35, 0x34, 0x20, 0x20, 0x30,
+    0x20, 0x35, 0x35, 0x20, 0x0a, 0x0a, 0x2e, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x20, 0x39, 0x20, 0x20, 0x37, 0x31, 0x20, 0x20, 0x36, 0x20, 0x20, 0x36, 0x20,
+    0x20, 0x30, 0x0a, 0x2e, 0x74, 0x72, 0x65, 0x65, 0x64, 0x61, 0x74, 0x61, 0x0a, 0x20, 0x38, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20,
+    0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x20, 0x30, 0x20, 0x20, 0x30, 0x20, 0x31, 0x30, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20,
+    0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x31, 0x31, 0x20, 0x20, 0x61, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31,
+    0x20, 0x20, 0x30, 0x20, 0x32, 0x30, 0x20, 0x0a, 0x20, 0x30, 0x20, 0x32, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x31, 0x32, 0x20,
+    0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x20, 0x32, 0x20, 0x20, 0x30, 0x20, 0x32, 0x32, 0x20, 0x20, 0x63, 0x20, 0x20, 0x31, 0x20, 0x20, 0x36,
+    0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x33, 0x30, 0x20, 0x20, 0x30, 0x20, 0x20,
+    0x33, 0x20, 0x0a, 0x20, 0x30, 0x20, 0x33, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x31, 0x33, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31,
+    0x20, 0x20, 0x30, 0x20, 0x33, 0x32, 0x20, 0x20, 0x30, 0x20, 0x32, 0x33, 0x20, 0x20, 0x63, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20,
+    0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x34, 0x31, 0x20, 0x20, 0x30, 0x20, 0x31, 0x34, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x0a, 0x20, 0x32,
+    0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x34, 0x30, 0x20, 0x20, 0x30, 0x20, 0x33, 0x33, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x34,
+    0x32, 0x20, 0x20, 0x30, 0x20, 0x32, 0x34, 0x20, 0x20, 0x61, 0x20, 0x20, 0x31, 0x20, 0x20, 0x36, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20,
+    0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x20, 0x34, 0x20, 0x20, 0x30, 0x20, 0x35, 0x30, 0x20, 0x0a, 0x20, 0x30, 0x20, 0x34, 0x33, 0x20, 0x20,
+    0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x33, 0x34, 0x20, 0x20, 0x30, 0x20, 0x35, 0x31, 0x20, 0x20, 0x38, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20,
+    0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x31, 0x35, 0x20, 0x20, 0x30, 0x20, 0x35, 0x32, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31,
+    0x20, 0x20, 0x30, 0x20, 0x32, 0x35, 0x20, 0x20, 0x30, 0x20, 0x34, 0x34, 0x20, 0x0a, 0x20, 0x36, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20,
+    0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x20, 0x35, 0x20, 0x20, 0x30, 0x20, 0x35, 0x34, 0x20, 0x20, 0x30, 0x20, 0x35, 0x33, 0x20, 0x20, 0x32,
+    0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x33, 0x35, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x34, 0x35, 0x20, 0x20, 0x30, 0x20, 0x35,
+    0x35, 0x20, 0x0a, 0x0a, 0x2e, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x31, 0x30, 0x20, 0x31, 0x32, 0x37, 0x20, 0x20, 0x38, 0x20, 0x20, 0x38, 0x20, 0x20, 0x30,
+    0x0a, 0x2e, 0x74, 0x72, 0x65, 0x65, 0x64, 0x61, 0x74, 0x61, 0x0a, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x20, 0x30, 0x20, 0x20, 0x34, 0x20,
+    0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x31, 0x30, 0x20, 0x20, 0x30, 0x20, 0x20, 0x31, 0x20, 0x20, 0x61, 0x20, 0x20, 0x31,
+    0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x31, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20,
+    0x30, 0x20, 0x32, 0x30, 0x20, 0x0a, 0x20, 0x30, 0x20, 0x20, 0x32, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x32, 0x31, 0x20, 0x20, 0x30,
+    0x20, 0x31, 0x32, 0x20, 0x31, 0x63, 0x20, 0x20, 0x31, 0x20, 0x20, 0x38, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20,
+    0x31, 0x20, 0x20, 0x30, 0x20, 0x32, 0x32, 0x20, 0x20, 0x30, 0x20, 0x33, 0x30, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x33, 0x31, 0x20,
+    0x0a, 0x20, 0x30, 0x20, 0x31, 0x33, 0x20, 0x20, 0x38, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20,
+    0x30, 0x20, 0x20, 0x33, 0x20, 0x20, 0x30, 0x20, 0x33, 0x32, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x32, 0x33, 0x20, 0x20, 0x30, 0x20,
+    0x34, 0x30, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x34, 0x31, 0x20, 0x0a, 0x20, 0x30, 0x20, 0x31,
+    0x34, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x20, 0x34, 0x20, 0x20, 0x30, 0x20, 0x33, 0x33, 0x20,
+    0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x34, 0x32, 0x20, 0x20, 0x30, 0x20, 0x32, 0x34, 0x20, 0x31, 0x63, 0x20, 0x20, 0x31, 0x20, 0x20, 0x61,
+    0x20, 0x20, 0x31, 0x20, 0x20, 0x36, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x0a, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20,
+    0x35, 0x30, 0x20, 0x20, 0x30, 0x20, 0x20, 0x35, 0x20, 0x20, 0x30, 0x20, 0x36, 0x30, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x36, 0x31,
+    0x20, 0x20, 0x30, 0x20, 0x31, 0x36, 0x20, 0x20, 0x63, 0x20, 0x20, 0x31, 0x20, 0x20, 0x36, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20,
+    0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x34, 0x33, 0x20, 0x0a, 0x20, 0x30, 0x20, 0x33, 0x34, 0x20, 0x20, 0x30, 0x20, 0x35, 0x31, 0x20, 0x20, 0x32,
+    0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x31, 0x35, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x35, 0x32, 0x20, 0x20, 0x30, 0x20, 0x32,
+    0x35, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x32, 0x36, 0x20, 0x20, 0x30, 0x20, 0x33, 0x36, 0x20,
+    0x20, 0x30, 0x20, 0x37, 0x31, 0x20, 0x0a, 0x31, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x38, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20,
+    0x30, 0x20, 0x31, 0x37, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x34, 0x34, 0x20, 0x20, 0x30, 0x20,
+    0x35, 0x33, 0x20, 0x20, 0x30, 0x20, 0x20, 0x36, 0x20, 0x20, 0x36, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31,
+    0x20, 0x0a, 0x20, 0x30, 0x20, 0x33, 0x35, 0x20, 0x20, 0x30, 0x20, 0x34, 0x35, 0x20, 0x20, 0x30, 0x20, 0x36, 0x32, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20,
+    0x20, 0x30, 0x20, 0x37, 0x30, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x20, 0x37, 0x20, 0x20, 0x30, 0x20, 0x36, 0x34, 0x20, 0x20, 0x65,
+    0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x37, 0x32, 0x20, 0x0a, 0x20, 0x30, 0x20,
+    0x32, 0x37, 0x20, 0x20, 0x36, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x36, 0x33, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31,
+    0x20, 0x20, 0x30, 0x20, 0x35, 0x34, 0x20, 0x20, 0x30, 0x20, 0x35, 0x35, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x34, 0x36, 0x20, 0x20,
+    0x30, 0x20, 0x37, 0x33, 0x20, 0x20, 0x38, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x0a, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30,
+    0x20, 0x33, 0x37, 0x20, 0x20, 0x30, 0x20, 0x36, 0x35, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x35, 0x36, 0x20, 0x20, 0x30, 0x20, 0x37,
+    0x34, 0x20, 0x20, 0x36, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x34, 0x37, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20,
+    0x20, 0x30, 0x20, 0x36, 0x36, 0x20, 0x20, 0x30, 0x20, 0x37, 0x35, 0x20, 0x0a, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20,
+    0x30, 0x20, 0x35, 0x37, 0x20, 0x20, 0x30, 0x20, 0x37, 0x36, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x36, 0x37, 0x20, 0x20, 0x30, 0x20,
+    0x37, 0x37, 0x20, 0x0a, 0x0a, 0x2e, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x31, 0x31, 0x20, 0x31, 0x32, 0x37, 0x20, 0x20, 0x38, 0x20, 0x20, 0x38, 0x20, 0x20,
+    0x30, 0x0a, 0x2e, 0x74, 0x72, 0x65, 0x65, 0x64, 0x61, 0x74, 0x61, 0x0a, 0x20, 0x36, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30,
+    0x20, 0x20, 0x30, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x31, 0x30, 0x20, 0x20, 0x30, 0x20, 0x20, 0x31, 0x20, 0x20, 0x38, 0x20, 0x20,
+    0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x31, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20,
+    0x20, 0x30, 0x20, 0x32, 0x30, 0x20, 0x0a, 0x20, 0x30, 0x20, 0x20, 0x32, 0x20, 0x20, 0x30, 0x20, 0x31, 0x32, 0x20, 0x31, 0x38, 0x20, 0x20, 0x31, 0x20, 0x20,
+    0x38, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x32, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20,
+    0x32, 0x32, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x33, 0x30, 0x20, 0x20, 0x30, 0x20, 0x20, 0x33, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31,
+    0x20, 0x0a, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x33, 0x31, 0x20, 0x20, 0x30, 0x20, 0x31, 0x33, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20,
+    0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x33, 0x32, 0x20, 0x20, 0x30, 0x20, 0x32, 0x33, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32,
+    0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x34, 0x30, 0x20, 0x20, 0x30, 0x20, 0x20, 0x34, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x0a, 0x20, 0x30, 0x20,
+    0x34, 0x31, 0x20, 0x20, 0x30, 0x20, 0x31, 0x34, 0x20, 0x31, 0x65, 0x20, 0x20, 0x31, 0x20, 0x31, 0x30, 0x20, 0x20, 0x31, 0x20, 0x20, 0x61, 0x20, 0x20, 0x31,
+    0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x34, 0x32, 0x20, 0x20, 0x30, 0x20, 0x32, 0x34, 0x20, 0x20,
+    0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x33, 0x33, 0x20, 0x0a, 0x20, 0x30, 0x20, 0x34, 0x33, 0x20, 0x20, 0x30,
+    0x20, 0x35, 0x30, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x33, 0x34, 0x20, 0x20, 0x30, 0x20, 0x35,
+    0x31, 0x20, 0x20, 0x30, 0x20, 0x36, 0x31, 0x20, 0x20, 0x36, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x31, 0x36, 0x20,
+    0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x20, 0x36, 0x20, 0x0a, 0x20, 0x30, 0x20, 0x32, 0x36, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20,
+    0x30, 0x20, 0x36, 0x32, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x31, 0x35, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20,
+    0x20, 0x35, 0x20, 0x20, 0x30, 0x20, 0x35, 0x32, 0x20, 0x31, 0x30, 0x20, 0x20, 0x31, 0x20, 0x20, 0x61, 0x20, 0x20, 0x31, 0x20, 0x20, 0x36, 0x20, 0x20, 0x31,
+    0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x0a, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x32, 0x35, 0x20, 0x20, 0x30, 0x20, 0x34, 0x34, 0x20,
+    0x20, 0x30, 0x20, 0x36, 0x30, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x36, 0x33, 0x20, 0x20, 0x30, 0x20, 0x33, 0x36, 0x20, 0x20, 0x34,
+    0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x37, 0x30, 0x20, 0x20, 0x30, 0x20, 0x31, 0x37, 0x20, 0x20, 0x30, 0x20, 0x37,
+    0x31, 0x20, 0x0a, 0x31, 0x30, 0x20, 0x20, 0x31, 0x20, 0x20, 0x36, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31,
+    0x20, 0x20, 0x30, 0x20, 0x20, 0x37, 0x20, 0x20, 0x30, 0x20, 0x36, 0x34, 0x20, 0x20, 0x30, 0x20, 0x37, 0x32, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20,
+    0x30, 0x20, 0x32, 0x37, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x35, 0x33, 0x20, 0x0a, 0x20, 0x30,
+    0x20, 0x33, 0x35, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x35, 0x34, 0x20, 0x20, 0x30, 0x20, 0x34, 0x35, 0x20, 0x20, 0x61, 0x20, 0x20,
+    0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x34, 0x36, 0x20, 0x20, 0x30, 0x20, 0x37, 0x33, 0x20,
+    0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x33, 0x37, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x0a, 0x20, 0x30, 0x20, 0x36, 0x35, 0x20, 0x20,
+    0x30, 0x20, 0x35, 0x36, 0x20, 0x20, 0x61, 0x20, 0x20, 0x31, 0x20, 0x20, 0x36, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20,
+    0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x35, 0x35, 0x20, 0x20, 0x30, 0x20, 0x35, 0x37, 0x20, 0x20, 0x30, 0x20, 0x37, 0x34, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31,
+    0x20, 0x20, 0x30, 0x20, 0x34, 0x37, 0x20, 0x20, 0x30, 0x20, 0x36, 0x36, 0x20, 0x0a, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20,
+    0x20, 0x30, 0x20, 0x37, 0x35, 0x20, 0x20, 0x30, 0x20, 0x37, 0x36, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x36, 0x37, 0x20, 0x20, 0x30,
+    0x20, 0x37, 0x37, 0x20, 0x0a, 0x0a, 0x2e, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x31, 0x32, 0x20, 0x31, 0x32, 0x37, 0x20, 0x20, 0x38, 0x20, 0x20, 0x38, 0x20,
+    0x20, 0x30, 0x0a, 0x2e, 0x74, 0x72, 0x65, 0x65, 0x64, 0x61, 0x74, 0x61, 0x0a, 0x20, 0x63, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20,
+    0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x31, 0x30, 0x20, 0x20, 0x30, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20,
+    0x31, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x20, 0x30, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x32, 0x30,
+    0x20, 0x20, 0x30, 0x20, 0x20, 0x32, 0x20, 0x0a, 0x31, 0x30, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20,
+    0x20, 0x30, 0x20, 0x32, 0x31, 0x20, 0x20, 0x30, 0x20, 0x31, 0x32, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30,
+    0x20, 0x32, 0x32, 0x20, 0x20, 0x30, 0x20, 0x33, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x31, 0x33, 0x20, 0x20, 0x32, 0x20, 0x20,
+    0x31, 0x20, 0x0a, 0x20, 0x30, 0x20, 0x33, 0x30, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x20, 0x33, 0x20, 0x20, 0x30, 0x20, 0x34, 0x30,
+    0x20, 0x31, 0x61, 0x20, 0x20, 0x31, 0x20, 0x20, 0x38, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20,
+    0x30, 0x20, 0x33, 0x32, 0x20, 0x20, 0x30, 0x20, 0x32, 0x33, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x34, 0x31, 0x20, 0x0a, 0x20, 0x30,
+    0x20, 0x33, 0x33, 0x20, 0x20, 0x61, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x31,
+    0x34, 0x20, 0x20, 0x30, 0x20, 0x34, 0x32, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x32, 0x34, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20,
+    0x20, 0x30, 0x20, 0x20, 0x34, 0x20, 0x20, 0x30, 0x20, 0x35, 0x30, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x0a, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20,
+    0x30, 0x20, 0x34, 0x33, 0x20, 0x20, 0x30, 0x20, 0x33, 0x34, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x35, 0x31, 0x20, 0x20, 0x30, 0x20,
+    0x31, 0x35, 0x20, 0x31, 0x63, 0x20, 0x20, 0x31, 0x20, 0x20, 0x65, 0x20, 0x20, 0x31, 0x20, 0x20, 0x38, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31,
+    0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x35, 0x32, 0x20, 0x0a, 0x20, 0x30, 0x20, 0x32, 0x35, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20,
+    0x20, 0x30, 0x20, 0x35, 0x33, 0x20, 0x20, 0x30, 0x20, 0x33, 0x35, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30,
+    0x20, 0x36, 0x30, 0x20, 0x20, 0x30, 0x20, 0x31, 0x36, 0x20, 0x20, 0x30, 0x20, 0x36, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20,
+    0x31, 0x20, 0x20, 0x30, 0x20, 0x36, 0x32, 0x20, 0x0a, 0x20, 0x30, 0x20, 0x32, 0x36, 0x20, 0x20, 0x36, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31,
+    0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x20, 0x35, 0x20, 0x20, 0x30, 0x20, 0x20, 0x36, 0x20, 0x20, 0x30, 0x20, 0x34, 0x34, 0x20, 0x20,
+    0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x35, 0x34, 0x20, 0x20, 0x30, 0x20, 0x34, 0x35, 0x20, 0x31, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x61, 0x20,
+    0x20, 0x31, 0x20, 0x0a, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x36, 0x33, 0x20, 0x20, 0x30, 0x20, 0x33,
+    0x36, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x37, 0x30, 0x20, 0x20, 0x30, 0x20, 0x20, 0x37, 0x20,
+    0x20, 0x30, 0x20, 0x37, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x31, 0x37, 0x20, 0x0a, 0x20,
+    0x30, 0x20, 0x36, 0x34, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x34, 0x36, 0x20, 0x20, 0x30, 0x20, 0x37, 0x32, 0x20, 0x20, 0x61, 0x20,
+    0x20, 0x31, 0x20, 0x20, 0x36, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x32, 0x37, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31,
+    0x20, 0x20, 0x30, 0x20, 0x35, 0x35, 0x20, 0x20, 0x30, 0x20, 0x37, 0x33, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x0a, 0x20, 0x30, 0x20, 0x33, 0x37, 0x20,
+    0x20, 0x30, 0x20, 0x35, 0x36, 0x20, 0x20, 0x38, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30,
+    0x20, 0x36, 0x35, 0x20, 0x20, 0x30, 0x20, 0x37, 0x34, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x34, 0x37, 0x20, 0x20, 0x30, 0x20, 0x36,
+    0x36, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x0a, 0x20, 0x30, 0x20, 0x37, 0x35, 0x20, 0x20, 0x30, 0x20, 0x35, 0x37,
+    0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x37, 0x36, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x36, 0x37, 0x20, 0x20,
+    0x30, 0x20, 0x37, 0x37, 0x20, 0x0a, 0x0a, 0x2e, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x31, 0x33, 0x20, 0x35, 0x31, 0x31, 0x20, 0x31, 0x36, 0x20, 0x31, 0x36,
+    0x20, 0x20, 0x30, 0x0a, 0x2e, 0x74, 0x72, 0x65, 0x65, 0x64, 0x61, 0x74, 0x61, 0x0a, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x20, 0x30, 0x20,
+    0x20, 0x36, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x31, 0x30, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30,
+    0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x31, 0x31, 0x20, 0x31, 0x63, 0x20, 0x20, 0x31, 0x20, 0x20, 0x38, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20,
+    0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x0a, 0x20, 0x30, 0x20, 0x32, 0x30, 0x20, 0x20, 0x30, 0x20, 0x20, 0x32, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31,
+    0x20, 0x20, 0x30, 0x20, 0x32, 0x31, 0x20, 0x20, 0x30, 0x20, 0x31, 0x32, 0x20, 0x20, 0x38, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20,
+    0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x32, 0x32, 0x20, 0x20, 0x30, 0x20, 0x33, 0x30, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20,
+    0x20, 0x33, 0x20, 0x0a, 0x20, 0x30, 0x20, 0x33, 0x31, 0x20, 0x20, 0x36, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x31,
+    0x33, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x33, 0x32, 0x20, 0x20, 0x30, 0x20, 0x32, 0x33, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20,
+    0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x34, 0x30, 0x20, 0x20, 0x30, 0x20, 0x20, 0x34, 0x20, 0x20, 0x30, 0x20, 0x34, 0x31, 0x20, 0x0a, 0x34,
+    0x36, 0x20, 0x20, 0x31, 0x20, 0x31, 0x63, 0x20, 0x20, 0x31, 0x20, 0x20, 0x65, 0x20, 0x20, 0x31, 0x20, 0x20, 0x36, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20,
+    0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x31, 0x34, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x33, 0x33, 0x20, 0x20, 0x30, 0x20, 0x34, 0x32,
+    0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x32, 0x34, 0x20, 0x0a, 0x20, 0x30, 0x20, 0x35, 0x30, 0x20,
+    0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x34, 0x33, 0x20, 0x20, 0x30, 0x20, 0x33, 0x34, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32,
+    0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x35, 0x31, 0x20, 0x20, 0x30, 0x20, 0x31, 0x35, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20,
+    0x31, 0x20, 0x20, 0x30, 0x20, 0x20, 0x35, 0x20, 0x20, 0x30, 0x20, 0x35, 0x32, 0x20, 0x0a, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x32, 0x35,
+    0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x34, 0x34, 0x20, 0x20, 0x30, 0x20, 0x35, 0x33, 0x20, 0x20, 0x65, 0x20, 0x20, 0x31, 0x20, 0x20,
+    0x38, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x36, 0x30, 0x20, 0x20, 0x30, 0x20,
+    0x20, 0x36, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x0a, 0x20, 0x30, 0x20, 0x36, 0x31, 0x20, 0x20, 0x30, 0x20, 0x31, 0x36, 0x20, 0x20, 0x34, 0x20, 0x20,
+    0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x38, 0x30, 0x20, 0x20, 0x30, 0x20, 0x20, 0x38, 0x20, 0x20, 0x30, 0x20, 0x38, 0x31, 0x20,
+    0x31, 0x30, 0x20, 0x20, 0x31, 0x20, 0x20, 0x38, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30,
+    0x20, 0x33, 0x35, 0x20, 0x0a, 0x20, 0x30, 0x20, 0x36, 0x32, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x32, 0x36, 0x20, 0x20, 0x30, 0x20,
+    0x35, 0x34, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x34, 0x35, 0x20, 0x20, 0x30, 0x20, 0x36, 0x33,
+    0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x33, 0x36, 0x20, 0x20, 0x30, 0x20, 0x37, 0x30, 0x20, 0x20, 0x36, 0x20, 0x20, 0x31, 0x20, 0x0a,
+    0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x20, 0x37, 0x20, 0x20, 0x30, 0x20, 0x35, 0x35, 0x20, 0x20, 0x30,
+    0x20, 0x37, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x31, 0x37, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x32,
+    0x37, 0x20, 0x20, 0x30, 0x20, 0x33, 0x37, 0x20, 0x34, 0x38, 0x20, 0x20, 0x31, 0x20, 0x31, 0x38, 0x20, 0x20, 0x31, 0x20, 0x0a, 0x20, 0x63, 0x20, 0x20, 0x31,
+    0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x31, 0x38, 0x20, 0x20, 0x30, 0x20, 0x38, 0x32, 0x20, 0x20,
+    0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x32, 0x38, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20,
+    0x36, 0x34, 0x20, 0x20, 0x30, 0x20, 0x34, 0x36, 0x20, 0x20, 0x30, 0x20, 0x37, 0x32, 0x20, 0x0a, 0x20, 0x38, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20,
+    0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x38, 0x34, 0x20, 0x20, 0x30, 0x20, 0x34, 0x38, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20,
+    0x20, 0x30, 0x20, 0x39, 0x30, 0x20, 0x20, 0x30, 0x20, 0x20, 0x39, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x39, 0x31, 0x20, 0x20, 0x30,
+    0x20, 0x31, 0x39, 0x20, 0x31, 0x38, 0x20, 0x20, 0x31, 0x20, 0x0a, 0x20, 0x65, 0x20, 0x20, 0x31, 0x20, 0x20, 0x38, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20,
+    0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x37, 0x33, 0x20, 0x20, 0x30, 0x20, 0x36, 0x35, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31,
+    0x20, 0x20, 0x30, 0x20, 0x35, 0x36, 0x20, 0x20, 0x30, 0x20, 0x37, 0x34, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20,
+    0x30, 0x20, 0x34, 0x37, 0x20, 0x0a, 0x20, 0x30, 0x20, 0x36, 0x36, 0x20, 0x20, 0x30, 0x20, 0x38, 0x33, 0x20, 0x20, 0x36, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32,
+    0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x33, 0x38, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x37, 0x35, 0x20, 0x20, 0x30, 0x20, 0x35,
+    0x37, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x39, 0x32, 0x20, 0x20, 0x30, 0x20, 0x32, 0x39, 0x20, 0x20, 0x65, 0x20, 0x20, 0x31, 0x20,
+    0x0a, 0x20, 0x38, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x36, 0x37, 0x20, 0x20,
+    0x30, 0x20, 0x38, 0x35, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x35, 0x38, 0x20, 0x20, 0x30, 0x20, 0x33, 0x39, 0x20, 0x20, 0x32, 0x20,
+    0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x39, 0x33, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x34, 0x39, 0x20, 0x0a, 0x20, 0x30, 0x20, 0x38,
+    0x36, 0x20, 0x20, 0x36, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x61, 0x30, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20,
+    0x20, 0x30, 0x20, 0x36, 0x38, 0x20, 0x20, 0x30, 0x20, 0x20, 0x61, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x61, 0x31, 0x20, 0x20, 0x30,
+    0x20, 0x31, 0x61, 0x20, 0x34, 0x34, 0x20, 0x20, 0x31, 0x20, 0x31, 0x38, 0x20, 0x20, 0x31, 0x20, 0x0a, 0x20, 0x63, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20,
+    0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x61, 0x32, 0x20, 0x20, 0x30, 0x20, 0x32, 0x61, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31,
+    0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x39, 0x35, 0x20, 0x20, 0x30, 0x20, 0x35, 0x39, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20,
+    0x30, 0x20, 0x61, 0x33, 0x20, 0x20, 0x30, 0x20, 0x33, 0x61, 0x20, 0x0a, 0x20, 0x38, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32,
+    0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x34, 0x61, 0x20, 0x20, 0x30, 0x20, 0x39, 0x36, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x62,
+    0x30, 0x20, 0x20, 0x30, 0x20, 0x20, 0x62, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x62, 0x31, 0x20, 0x20, 0x30, 0x20, 0x31, 0x62, 0x20,
+    0x31, 0x34, 0x20, 0x20, 0x31, 0x20, 0x0a, 0x20, 0x38, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x62, 0x32, 0x20, 0x20,
+    0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x37, 0x36, 0x20, 0x20, 0x30, 0x20, 0x37, 0x37, 0x20, 0x20, 0x30, 0x20,
+    0x39, 0x34, 0x20, 0x20, 0x36, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x38, 0x37,
+    0x20, 0x0a, 0x20, 0x30, 0x20, 0x37, 0x38, 0x20, 0x20, 0x30, 0x20, 0x61, 0x34, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20,
+    0x20, 0x30, 0x20, 0x36, 0x39, 0x20, 0x20, 0x30, 0x20, 0x61, 0x35, 0x20, 0x20, 0x30, 0x20, 0x32, 0x62, 0x20, 0x20, 0x63, 0x20, 0x20, 0x31, 0x20, 0x20, 0x36,
+    0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x35, 0x61, 0x20, 0x0a, 0x20, 0x30, 0x20,
+    0x38, 0x38, 0x20, 0x20, 0x30, 0x20, 0x62, 0x33, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x33, 0x62, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31,
+    0x20, 0x20, 0x30, 0x20, 0x37, 0x39, 0x20, 0x20, 0x30, 0x20, 0x61, 0x36, 0x20, 0x20, 0x36, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20,
+    0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x36, 0x61, 0x20, 0x20, 0x30, 0x20, 0x62, 0x34, 0x20, 0x0a, 0x20, 0x30, 0x20, 0x63, 0x30, 0x20, 0x20, 0x34,
+    0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x20, 0x63, 0x20, 0x20, 0x30, 0x20, 0x39, 0x38, 0x20, 0x20, 0x30, 0x20, 0x63,
+    0x31, 0x20, 0x33, 0x63, 0x20, 0x20, 0x31, 0x20, 0x31, 0x36, 0x20, 0x20, 0x31, 0x20, 0x20, 0x61, 0x20, 0x20, 0x31, 0x20, 0x20, 0x36, 0x20, 0x20, 0x31, 0x20,
+    0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x31, 0x63, 0x20, 0x0a, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x38, 0x39, 0x20, 0x20,
+    0x30, 0x20, 0x62, 0x35, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x35, 0x62, 0x20, 0x20, 0x30, 0x20, 0x63, 0x32, 0x20, 0x20, 0x34, 0x20,
+    0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x32, 0x63, 0x20, 0x20, 0x30, 0x20, 0x33, 0x63, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31,
+    0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x0a, 0x20, 0x30, 0x20, 0x62, 0x36, 0x20, 0x20, 0x30, 0x20, 0x36, 0x62, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20,
+    0x20, 0x30, 0x20, 0x63, 0x34, 0x20, 0x20, 0x30, 0x20, 0x34, 0x63, 0x20, 0x31, 0x30, 0x20, 0x20, 0x31, 0x20, 0x20, 0x38, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34,
+    0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x61, 0x38, 0x20, 0x20, 0x30, 0x20, 0x38, 0x61, 0x20, 0x20, 0x32, 0x20, 0x20,
+    0x31, 0x20, 0x0a, 0x20, 0x30, 0x20, 0x64, 0x30, 0x20, 0x20, 0x30, 0x20, 0x20, 0x64, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x64, 0x31,
+    0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x34, 0x62, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x39, 0x37, 0x20, 0x20,
+    0x30, 0x20, 0x61, 0x37, 0x20, 0x20, 0x63, 0x20, 0x20, 0x31, 0x20, 0x20, 0x36, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x0a, 0x20, 0x30,
+    0x20, 0x63, 0x33, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x37, 0x61, 0x20, 0x20, 0x30, 0x20, 0x39, 0x39, 0x20, 0x20, 0x34, 0x20, 0x20,
+    0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x63, 0x35, 0x20, 0x20, 0x30, 0x20, 0x35, 0x63, 0x20, 0x20, 0x30, 0x20, 0x62, 0x37, 0x20,
+    0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x31, 0x64, 0x20, 0x0a, 0x20, 0x30, 0x20, 0x64, 0x32, 0x20, 0x20,
+    0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x32, 0x64, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x37, 0x62, 0x20, 0x20, 0x30, 0x20,
+    0x64, 0x33, 0x20, 0x33, 0x34, 0x20, 0x20, 0x31, 0x20, 0x31, 0x63, 0x20, 0x20, 0x31, 0x20, 0x20, 0x63, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31,
+    0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x33, 0x64, 0x20, 0x0a, 0x20, 0x30, 0x20, 0x63, 0x36, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20,
+    0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x36, 0x63, 0x20, 0x20, 0x30, 0x20, 0x61, 0x39, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30,
+    0x20, 0x39, 0x61, 0x20, 0x20, 0x30, 0x20, 0x64, 0x34, 0x20, 0x20, 0x38, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20,
+    0x31, 0x20, 0x20, 0x30, 0x20, 0x62, 0x38, 0x20, 0x0a, 0x20, 0x30, 0x20, 0x38, 0x62, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x34, 0x64,
+    0x20, 0x20, 0x30, 0x20, 0x63, 0x37, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x37, 0x63, 0x20, 0x20,
+    0x30, 0x20, 0x64, 0x35, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x35, 0x64, 0x20, 0x20, 0x30, 0x20, 0x65, 0x30, 0x20, 0x20, 0x61, 0x20,
+    0x20, 0x31, 0x20, 0x0a, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x65, 0x31, 0x20, 0x20, 0x30, 0x20, 0x31,
+    0x65, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x20, 0x65, 0x20, 0x20, 0x30, 0x20, 0x32, 0x65, 0x20,
+    0x20, 0x30, 0x20, 0x65, 0x32, 0x20, 0x20, 0x38, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x0a, 0x20,
+    0x30, 0x20, 0x65, 0x33, 0x20, 0x20, 0x30, 0x20, 0x36, 0x64, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x38, 0x63, 0x20, 0x20, 0x30, 0x20,
+    0x65, 0x34, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x65, 0x35, 0x20, 0x20, 0x30, 0x20, 0x62, 0x61,
+    0x20, 0x20, 0x30, 0x20, 0x66, 0x30, 0x20, 0x32, 0x36, 0x20, 0x20, 0x31, 0x20, 0x31, 0x30, 0x20, 0x20, 0x31, 0x20, 0x0a, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20,
+    0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x66, 0x31, 0x20, 0x20, 0x30, 0x20, 0x31, 0x66, 0x20, 0x20, 0x36, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34,
+    0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x61, 0x61, 0x20, 0x20, 0x30, 0x20, 0x39, 0x62, 0x20, 0x20, 0x30, 0x20, 0x62,
+    0x39, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x33, 0x65, 0x20, 0x0a, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x64, 0x36,
+    0x20, 0x20, 0x30, 0x20, 0x63, 0x38, 0x20, 0x20, 0x63, 0x20, 0x20, 0x31, 0x20, 0x20, 0x36, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20,
+    0x30, 0x20, 0x34, 0x65, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x64, 0x37, 0x20, 0x20, 0x30, 0x20, 0x37, 0x64, 0x20, 0x20, 0x32, 0x20,
+    0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x61, 0x62, 0x20, 0x0a, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x35, 0x65, 0x20, 0x20, 0x30, 0x20, 0x63,
+    0x39, 0x20, 0x20, 0x36, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x20, 0x66, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20,
+    0x20, 0x30, 0x20, 0x39, 0x63, 0x20, 0x20, 0x30, 0x20, 0x36, 0x65, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x66, 0x32, 0x20, 0x20, 0x30,
+    0x20, 0x32, 0x66, 0x20, 0x0a, 0x32, 0x30, 0x20, 0x20, 0x31, 0x20, 0x31, 0x30, 0x20, 0x20, 0x31, 0x20, 0x20, 0x36, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20,
+    0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x64, 0x38, 0x20, 0x20, 0x30, 0x20, 0x38, 0x64, 0x20, 0x20, 0x30, 0x20, 0x33, 0x66,
+    0x20, 0x20, 0x36, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x66, 0x33, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x0a,
+    0x20, 0x30, 0x20, 0x65, 0x36, 0x20, 0x20, 0x30, 0x20, 0x63, 0x61, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x66, 0x34, 0x20, 0x20, 0x30,
+    0x20, 0x34, 0x66, 0x20, 0x20, 0x38, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x62,
+    0x62, 0x20, 0x20, 0x30, 0x20, 0x61, 0x63, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x65, 0x37, 0x20, 0x0a, 0x20, 0x30, 0x20, 0x66, 0x35,
+    0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x64, 0x39, 0x20, 0x20, 0x30, 0x20, 0x39, 0x64, 0x20, 0x20,
+    0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x35, 0x66, 0x20, 0x20, 0x30, 0x20, 0x65, 0x38, 0x20, 0x31, 0x65, 0x20, 0x20, 0x31, 0x20, 0x20, 0x63, 0x20,
+    0x20, 0x31, 0x20, 0x20, 0x36, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x0a, 0x20, 0x30, 0x20, 0x36, 0x66, 0x20, 0x20, 0x32, 0x20, 0x20,
+    0x31, 0x20, 0x20, 0x30, 0x20, 0x66, 0x36, 0x20, 0x20, 0x30, 0x20, 0x63, 0x62, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20,
+    0x20, 0x30, 0x20, 0x62, 0x63, 0x20, 0x20, 0x30, 0x20, 0x61, 0x64, 0x20, 0x20, 0x30, 0x20, 0x64, 0x61, 0x20, 0x20, 0x38, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32,
+    0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x66, 0x37, 0x20, 0x0a, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20,
+    0x37, 0x65, 0x20, 0x20, 0x30, 0x20, 0x37, 0x66, 0x20, 0x20, 0x30, 0x20, 0x38, 0x65, 0x20, 0x20, 0x36, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31,
+    0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x39, 0x65, 0x20, 0x20, 0x30, 0x20, 0x61, 0x65, 0x20, 0x20, 0x30, 0x20, 0x63, 0x63, 0x20, 0x20,
+    0x32, 0x20, 0x20, 0x31, 0x20, 0x0a, 0x20, 0x30, 0x20, 0x66, 0x38, 0x20, 0x20, 0x30, 0x20, 0x38, 0x66, 0x20, 0x31, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x38,
+    0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x64, 0x62, 0x20, 0x20, 0x30, 0x20, 0x62,
+    0x64, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x65, 0x61, 0x20, 0x20, 0x30, 0x20, 0x66, 0x39, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20,
+    0x0a, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x39, 0x66, 0x20, 0x20, 0x30, 0x20, 0x65, 0x62, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20,
+    0x30, 0x20, 0x62, 0x65, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x63, 0x64, 0x20, 0x20, 0x30, 0x20, 0x66, 0x61, 0x20, 0x20, 0x65, 0x20,
+    0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x64, 0x64, 0x20, 0x0a, 0x20, 0x30, 0x20, 0x65,
+    0x63, 0x20, 0x20, 0x36, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x65, 0x39, 0x20,
+    0x20, 0x30, 0x20, 0x61, 0x66, 0x20, 0x20, 0x30, 0x20, 0x64, 0x63, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x63, 0x65, 0x20, 0x20, 0x30,
+    0x20, 0x66, 0x62, 0x20, 0x20, 0x38, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x0a, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20,
+    0x62, 0x66, 0x20, 0x20, 0x30, 0x20, 0x64, 0x65, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x63, 0x66, 0x20, 0x20, 0x30, 0x20, 0x65, 0x65,
+    0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x64, 0x66, 0x20, 0x20, 0x30, 0x20, 0x65, 0x66, 0x20, 0x20,
+    0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x66, 0x66, 0x20, 0x0a, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x65, 0x64, 0x20, 0x20, 0x32,
+    0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x66, 0x64, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x66, 0x63, 0x20, 0x20, 0x30, 0x20, 0x66,
+    0x65, 0x20, 0x0a, 0x0a, 0x2e, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x31, 0x34, 0x20, 0x20, 0x20, 0x30, 0x20, 0x20, 0x30, 0x20, 0x20, 0x30, 0x20, 0x20, 0x30,
+    0x0a, 0x2e, 0x74, 0x72, 0x65, 0x65, 0x64, 0x61, 0x74, 0x61, 0x0a, 0x0a, 0x2e, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x31, 0x35, 0x20, 0x35, 0x31, 0x31, 0x20,
+    0x31, 0x36, 0x20, 0x31, 0x36, 0x20, 0x20, 0x30, 0x0a, 0x2e, 0x74, 0x72, 0x65, 0x65, 0x64, 0x61, 0x74, 0x61, 0x0a, 0x31, 0x30, 0x20, 0x20, 0x31, 0x20, 0x20,
+    0x36, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x20, 0x30, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20,
+    0x31, 0x30, 0x20, 0x20, 0x30, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x31, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31,
+    0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x32, 0x30, 0x20, 0x0a, 0x20, 0x30, 0x20, 0x20, 0x32, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20,
+    0x20, 0x30, 0x20, 0x32, 0x31, 0x20, 0x20, 0x30, 0x20, 0x31, 0x32, 0x20, 0x33, 0x32, 0x20, 0x20, 0x31, 0x20, 0x31, 0x30, 0x20, 0x20, 0x31, 0x20, 0x20, 0x36,
+    0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x32, 0x32, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x33,
+    0x30, 0x20, 0x20, 0x30, 0x20, 0x33, 0x31, 0x20, 0x0a, 0x20, 0x36, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x31, 0x33,
+    0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x20, 0x33, 0x20, 0x20, 0x30, 0x20, 0x34, 0x30, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20,
+    0x30, 0x20, 0x33, 0x32, 0x20, 0x20, 0x30, 0x20, 0x32, 0x33, 0x20, 0x20, 0x65, 0x20, 0x20, 0x31, 0x20, 0x20, 0x36, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20,
+    0x20, 0x31, 0x20, 0x0a, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x20, 0x34, 0x20, 0x20, 0x30, 0x20, 0x31, 0x34, 0x20, 0x20, 0x30, 0x20, 0x34,
+    0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x33, 0x33, 0x20, 0x20, 0x30, 0x20, 0x34, 0x32, 0x20,
+    0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x32, 0x34, 0x20, 0x20, 0x30, 0x20, 0x34, 0x33, 0x20, 0x20, 0x61, 0x20, 0x20, 0x31, 0x20, 0x0a, 0x20,
+    0x36, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x33, 0x34, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20,
+    0x35, 0x30, 0x20, 0x20, 0x30, 0x20, 0x20, 0x35, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x35, 0x31, 0x20, 0x20, 0x30, 0x20, 0x31, 0x35,
+    0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x35, 0x32, 0x20, 0x0a, 0x20, 0x30, 0x20, 0x32, 0x35, 0x20,
+    0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x34, 0x34, 0x20, 0x20, 0x30, 0x20, 0x35, 0x33, 0x20, 0x20, 0x30,
+    0x20, 0x36, 0x31, 0x20, 0x35, 0x61, 0x20, 0x20, 0x31, 0x20, 0x32, 0x34, 0x20, 0x20, 0x31, 0x20, 0x31, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x61, 0x20, 0x20,
+    0x31, 0x20, 0x20, 0x36, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x0a, 0x20, 0x30, 0x20, 0x33, 0x35, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31,
+    0x20, 0x20, 0x30, 0x20, 0x36, 0x30, 0x20, 0x20, 0x30, 0x20, 0x20, 0x36, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x31, 0x36, 0x20, 0x20,
+    0x30, 0x20, 0x36, 0x32, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x32, 0x36, 0x20, 0x20, 0x30, 0x20,
+    0x35, 0x34, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x0a, 0x20, 0x30, 0x20, 0x34, 0x35, 0x20, 0x20, 0x30, 0x20, 0x36, 0x33, 0x20, 0x20, 0x61, 0x20, 0x20,
+    0x31, 0x20, 0x20, 0x36, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x33, 0x36, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20,
+    0x20, 0x30, 0x20, 0x37, 0x30, 0x20, 0x20, 0x30, 0x20, 0x20, 0x37, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x37, 0x31, 0x20, 0x20, 0x30,
+    0x20, 0x35, 0x35, 0x20, 0x0a, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x31, 0x37, 0x20, 0x20, 0x30, 0x20,
+    0x36, 0x34, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x37, 0x32, 0x20, 0x20, 0x30, 0x20, 0x32, 0x37, 0x20, 0x31, 0x38, 0x20, 0x20, 0x31,
+    0x20, 0x31, 0x30, 0x20, 0x20, 0x31, 0x20, 0x20, 0x38, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x0a,
+    0x20, 0x30, 0x20, 0x34, 0x36, 0x20, 0x20, 0x30, 0x20, 0x37, 0x33, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x33, 0x37, 0x20, 0x20, 0x30,
+    0x20, 0x36, 0x35, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x35, 0x36, 0x20, 0x20, 0x30, 0x20, 0x38,
+    0x30, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x20, 0x38, 0x20, 0x20, 0x30, 0x20, 0x37, 0x34, 0x20, 0x0a, 0x20, 0x34, 0x20, 0x20, 0x31,
+    0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x38, 0x31, 0x20, 0x20, 0x30, 0x20, 0x31, 0x38, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20,
+    0x30, 0x20, 0x38, 0x32, 0x20, 0x20, 0x30, 0x20, 0x32, 0x38, 0x20, 0x31, 0x30, 0x20, 0x20, 0x31, 0x20, 0x20, 0x38, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20,
+    0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x34, 0x37, 0x20, 0x0a, 0x20, 0x30, 0x20, 0x36, 0x36, 0x20, 0x20, 0x32, 0x20, 0x20,
+    0x31, 0x20, 0x20, 0x30, 0x20, 0x38, 0x33, 0x20, 0x20, 0x30, 0x20, 0x33, 0x38, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20,
+    0x20, 0x30, 0x20, 0x37, 0x35, 0x20, 0x20, 0x30, 0x20, 0x35, 0x37, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x38, 0x34, 0x20, 0x20, 0x30,
+    0x20, 0x34, 0x38, 0x20, 0x20, 0x36, 0x20, 0x20, 0x31, 0x20, 0x0a, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20,
+    0x39, 0x30, 0x20, 0x20, 0x30, 0x20, 0x31, 0x39, 0x20, 0x20, 0x30, 0x20, 0x39, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31,
+    0x20, 0x20, 0x30, 0x20, 0x39, 0x32, 0x20, 0x20, 0x30, 0x20, 0x37, 0x36, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x36, 0x37, 0x20, 0x20,
+    0x30, 0x20, 0x32, 0x39, 0x20, 0x0a, 0x35, 0x63, 0x20, 0x20, 0x31, 0x20, 0x32, 0x34, 0x20, 0x20, 0x31, 0x20, 0x31, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x61,
+    0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x38, 0x35, 0x20, 0x20, 0x30, 0x20, 0x35,
+    0x38, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x20, 0x39, 0x20, 0x20, 0x30, 0x20, 0x37, 0x37, 0x20,
+    0x0a, 0x20, 0x30, 0x20, 0x39, 0x33, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x33, 0x39, 0x20, 0x20,
+    0x30, 0x20, 0x39, 0x34, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x34, 0x39, 0x20, 0x20, 0x30, 0x20, 0x38, 0x36, 0x20, 0x20, 0x61, 0x20,
+    0x20, 0x31, 0x20, 0x20, 0x36, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x36, 0x38, 0x20, 0x0a, 0x20, 0x32, 0x20, 0x20,
+    0x31, 0x20, 0x20, 0x30, 0x20, 0x61, 0x30, 0x20, 0x20, 0x30, 0x20, 0x20, 0x61, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x61, 0x31, 0x20,
+    0x20, 0x30, 0x20, 0x31, 0x61, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x61, 0x32, 0x20, 0x20, 0x30,
+    0x20, 0x32, 0x61, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x39, 0x35, 0x20, 0x0a, 0x20, 0x30, 0x20, 0x35, 0x39, 0x20, 0x31, 0x61, 0x20,
+    0x20, 0x31, 0x20, 0x20, 0x65, 0x20, 0x20, 0x31, 0x20, 0x20, 0x36, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x61, 0x33,
+    0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x33, 0x61, 0x20, 0x20, 0x30, 0x20, 0x38, 0x37, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20,
+    0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x37, 0x38, 0x20, 0x0a, 0x20, 0x30, 0x20, 0x61, 0x34, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30,
+    0x20, 0x34, 0x61, 0x20, 0x20, 0x30, 0x20, 0x39, 0x36, 0x20, 0x20, 0x36, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20,
+    0x31, 0x20, 0x20, 0x30, 0x20, 0x36, 0x39, 0x20, 0x20, 0x30, 0x20, 0x62, 0x30, 0x20, 0x20, 0x30, 0x20, 0x62, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20,
+    0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x0a, 0x20, 0x30, 0x20, 0x31, 0x62, 0x20, 0x20, 0x30, 0x20, 0x61, 0x35, 0x20, 0x20, 0x30, 0x20, 0x62, 0x32, 0x20, 0x20,
+    0x65, 0x20, 0x20, 0x31, 0x20, 0x20, 0x38, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20,
+    0x35, 0x61, 0x20, 0x20, 0x30, 0x20, 0x32, 0x62, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x38, 0x38, 0x20, 0x20, 0x30, 0x20, 0x39, 0x37,
+    0x20, 0x0a, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x62, 0x33, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x37, 0x39, 0x20,
+    0x20, 0x30, 0x20, 0x33, 0x62, 0x20, 0x20, 0x38, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30,
+    0x20, 0x36, 0x61, 0x20, 0x20, 0x30, 0x20, 0x62, 0x34, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x34, 0x62, 0x20, 0x0a, 0x20, 0x30, 0x20,
+    0x63, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x39, 0x38, 0x20, 0x20, 0x30, 0x20, 0x38, 0x39,
+    0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x31, 0x63, 0x20, 0x20, 0x30, 0x20, 0x62, 0x35, 0x20, 0x35, 0x30, 0x20, 0x20, 0x31, 0x20, 0x32,
+    0x32, 0x20, 0x20, 0x31, 0x20, 0x31, 0x30, 0x20, 0x20, 0x31, 0x20, 0x20, 0x36, 0x20, 0x20, 0x31, 0x20, 0x0a, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32,
+    0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x35, 0x62, 0x20, 0x20, 0x30, 0x20, 0x32, 0x63, 0x20, 0x20, 0x30, 0x20, 0x63, 0x32, 0x20, 0x20, 0x36, 0x20, 0x20,
+    0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x20, 0x62, 0x20, 0x20, 0x30, 0x20, 0x63, 0x30, 0x20,
+    0x20, 0x30, 0x20, 0x61, 0x36, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x0a, 0x20, 0x30, 0x20, 0x61, 0x37, 0x20, 0x20, 0x30, 0x20, 0x37, 0x61, 0x20, 0x20,
+    0x61, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x63, 0x33, 0x20, 0x20, 0x30, 0x20,
+    0x33, 0x63, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x20, 0x63, 0x20, 0x20, 0x30, 0x20, 0x39, 0x39,
+    0x20, 0x20, 0x30, 0x20, 0x62, 0x36, 0x20, 0x0a, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x36, 0x62, 0x20,
+    0x20, 0x30, 0x20, 0x63, 0x34, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x34, 0x63, 0x20, 0x20, 0x30, 0x20, 0x61, 0x38, 0x20, 0x31, 0x34,
+    0x20, 0x20, 0x31, 0x20, 0x20, 0x61, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x38,
+    0x61, 0x20, 0x0a, 0x20, 0x30, 0x20, 0x63, 0x35, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x64, 0x30,
+    0x20, 0x20, 0x30, 0x20, 0x35, 0x63, 0x20, 0x20, 0x30, 0x20, 0x64, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20,
+    0x30, 0x20, 0x62, 0x37, 0x20, 0x20, 0x30, 0x20, 0x37, 0x62, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x31, 0x64, 0x20, 0x0a, 0x20, 0x32,
+    0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x20, 0x64, 0x20, 0x20, 0x30, 0x20, 0x32, 0x64, 0x20, 0x20, 0x63, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20,
+    0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x64, 0x32, 0x20, 0x20, 0x30, 0x20, 0x64, 0x33, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20,
+    0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x33, 0x64, 0x20, 0x20, 0x30, 0x20, 0x63, 0x36, 0x20, 0x0a, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20,
+    0x30, 0x20, 0x36, 0x63, 0x20, 0x20, 0x30, 0x20, 0x61, 0x39, 0x20, 0x20, 0x36, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20,
+    0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x39, 0x61, 0x20, 0x20, 0x30, 0x20, 0x62, 0x38, 0x20, 0x20, 0x30, 0x20, 0x64, 0x34, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31,
+    0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x38, 0x62, 0x20, 0x0a, 0x20, 0x30, 0x20, 0x34, 0x64, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20,
+    0x20, 0x30, 0x20, 0x63, 0x37, 0x20, 0x20, 0x30, 0x20, 0x37, 0x63, 0x20, 0x34, 0x34, 0x20, 0x20, 0x31, 0x20, 0x32, 0x32, 0x20, 0x20, 0x31, 0x20, 0x31, 0x32,
+    0x20, 0x20, 0x31, 0x20, 0x20, 0x61, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x64,
+    0x35, 0x20, 0x20, 0x30, 0x20, 0x35, 0x64, 0x20, 0x0a, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x65, 0x30,
+    0x20, 0x20, 0x30, 0x20, 0x20, 0x65, 0x20, 0x20, 0x30, 0x20, 0x65, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20,
+    0x30, 0x20, 0x31, 0x65, 0x20, 0x20, 0x30, 0x20, 0x65, 0x32, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x61, 0x61, 0x20, 0x20, 0x30, 0x20,
+    0x32, 0x65, 0x20, 0x0a, 0x20, 0x38, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x62,
+    0x39, 0x20, 0x20, 0x30, 0x20, 0x39, 0x62, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x65, 0x33, 0x20, 0x20, 0x30, 0x20, 0x64, 0x36, 0x20,
+    0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x36, 0x64, 0x20, 0x20, 0x30, 0x20, 0x33, 0x65, 0x20, 0x0a, 0x20,
+    0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x63, 0x38, 0x20, 0x20, 0x30, 0x20, 0x38, 0x63, 0x20, 0x31, 0x30, 0x20, 0x20, 0x31, 0x20, 0x20, 0x38, 0x20,
+    0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x65, 0x34, 0x20, 0x20, 0x30, 0x20, 0x34, 0x65,
+    0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x64, 0x37, 0x20, 0x20, 0x30, 0x20, 0x37, 0x64, 0x20, 0x0a, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20,
+    0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x65, 0x35, 0x20, 0x20, 0x30, 0x20, 0x62, 0x61, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30,
+    0x20, 0x61, 0x62, 0x20, 0x20, 0x30, 0x20, 0x35, 0x65, 0x20, 0x20, 0x38, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20,
+    0x31, 0x20, 0x20, 0x30, 0x20, 0x63, 0x39, 0x20, 0x20, 0x30, 0x20, 0x39, 0x63, 0x20, 0x0a, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x66, 0x31,
+    0x20, 0x20, 0x30, 0x20, 0x31, 0x66, 0x20, 0x20, 0x36, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20,
+    0x30, 0x20, 0x66, 0x30, 0x20, 0x20, 0x30, 0x20, 0x36, 0x65, 0x20, 0x20, 0x30, 0x20, 0x66, 0x32, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20,
+    0x32, 0x66, 0x20, 0x20, 0x30, 0x20, 0x65, 0x36, 0x20, 0x0a, 0x32, 0x36, 0x20, 0x20, 0x31, 0x20, 0x31, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x38, 0x20, 0x20,
+    0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x64, 0x38, 0x20, 0x20, 0x30, 0x20, 0x66, 0x33, 0x20,
+    0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x33, 0x66, 0x20, 0x20, 0x30, 0x20, 0x66, 0x34, 0x20, 0x20, 0x36, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32,
+    0x20, 0x20, 0x31, 0x20, 0x0a, 0x20, 0x30, 0x20, 0x34, 0x66, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x38, 0x64, 0x20, 0x20, 0x30, 0x20,
+    0x64, 0x39, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x62, 0x62, 0x20, 0x20, 0x30, 0x20, 0x63, 0x61, 0x20, 0x20, 0x38, 0x20, 0x20, 0x31,
+    0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x61, 0x63, 0x20, 0x20, 0x30, 0x20, 0x65, 0x37, 0x20, 0x0a,
+    0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x37, 0x65, 0x20, 0x20, 0x30, 0x20, 0x66, 0x35, 0x20, 0x20, 0x38, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34,
+    0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x39, 0x64, 0x20, 0x20, 0x30, 0x20, 0x35, 0x66, 0x20, 0x20, 0x32, 0x20, 0x20,
+    0x31, 0x20, 0x20, 0x30, 0x20, 0x65, 0x38, 0x20, 0x20, 0x30, 0x20, 0x38, 0x65, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x0a, 0x20, 0x30, 0x20, 0x66, 0x36,
+    0x20, 0x20, 0x30, 0x20, 0x63, 0x62, 0x20, 0x32, 0x32, 0x20, 0x20, 0x31, 0x20, 0x31, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x61, 0x20, 0x20, 0x31, 0x20, 0x20,
+    0x36, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x20, 0x66, 0x20, 0x20, 0x30, 0x20,
+    0x61, 0x65, 0x20, 0x20, 0x30, 0x20, 0x36, 0x66, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x0a, 0x20, 0x30, 0x20, 0x62, 0x63, 0x20, 0x20, 0x30, 0x20, 0x64,
+    0x61, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x61, 0x64, 0x20, 0x20, 0x30, 0x20, 0x66, 0x37, 0x20,
+    0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x37, 0x66, 0x20, 0x20, 0x30, 0x20, 0x65, 0x39, 0x20, 0x20, 0x38, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34,
+    0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x0a, 0x20, 0x30, 0x20, 0x39, 0x65, 0x20, 0x20, 0x30, 0x20, 0x63, 0x63, 0x20, 0x20, 0x32, 0x20,
+    0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x66, 0x38, 0x20, 0x20, 0x30, 0x20, 0x38, 0x66, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31,
+    0x20, 0x20, 0x30, 0x20, 0x64, 0x62, 0x20, 0x20, 0x30, 0x20, 0x62, 0x64, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x65, 0x61, 0x20, 0x20,
+    0x30, 0x20, 0x66, 0x39, 0x20, 0x0a, 0x31, 0x30, 0x20, 0x20, 0x31, 0x20, 0x20, 0x38, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32,
+    0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x39, 0x66, 0x20, 0x20, 0x30, 0x20, 0x64, 0x63, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x63,
+    0x64, 0x20, 0x20, 0x30, 0x20, 0x65, 0x62, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x62, 0x65, 0x20,
+    0x0a, 0x20, 0x30, 0x20, 0x66, 0x61, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x61, 0x66, 0x20, 0x20, 0x30, 0x20, 0x64, 0x64, 0x20, 0x20,
+    0x65, 0x20, 0x20, 0x31, 0x20, 0x20, 0x36, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20,
+    0x65, 0x63, 0x20, 0x20, 0x30, 0x20, 0x63, 0x65, 0x20, 0x20, 0x30, 0x20, 0x66, 0x62, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x0a, 0x20, 0x32, 0x20, 0x20,
+    0x31, 0x20, 0x20, 0x30, 0x20, 0x62, 0x66, 0x20, 0x20, 0x30, 0x20, 0x65, 0x64, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x64, 0x65, 0x20,
+    0x20, 0x30, 0x20, 0x66, 0x63, 0x20, 0x20, 0x36, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30,
+    0x20, 0x63, 0x66, 0x20, 0x20, 0x30, 0x20, 0x66, 0x64, 0x20, 0x20, 0x30, 0x20, 0x65, 0x65, 0x20, 0x0a, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20,
+    0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x64, 0x66, 0x20, 0x20, 0x30, 0x20, 0x66, 0x65, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x65, 0x66,
+    0x20, 0x20, 0x30, 0x20, 0x66, 0x66, 0x20, 0x0a, 0x0a, 0x2e, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x31, 0x36, 0x20, 0x35, 0x31, 0x31, 0x20, 0x31, 0x36, 0x20,
+    0x31, 0x36, 0x20, 0x20, 0x31, 0x0a, 0x2e, 0x74, 0x72, 0x65, 0x65, 0x64, 0x61, 0x74, 0x61, 0x0a, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x20,
+    0x30, 0x20, 0x20, 0x36, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x31, 0x30, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20,
+    0x20, 0x30, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x31, 0x31, 0x20, 0x32, 0x61, 0x20, 0x20, 0x31, 0x20, 0x20, 0x38, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34,
+    0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x0a, 0x20, 0x30, 0x20, 0x32, 0x30, 0x20, 0x20, 0x30, 0x20, 0x20, 0x32, 0x20, 0x20, 0x32, 0x20,
+    0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x32, 0x31, 0x20, 0x20, 0x30, 0x20, 0x31, 0x32, 0x20, 0x20, 0x61, 0x20, 0x20, 0x31, 0x20, 0x20, 0x36, 0x20, 0x20, 0x31,
+    0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x32, 0x32, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x33, 0x30, 0x20, 0x20,
+    0x30, 0x20, 0x20, 0x33, 0x20, 0x0a, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x33, 0x31, 0x20, 0x20, 0x30, 0x20, 0x31, 0x33, 0x20, 0x20, 0x61,
+    0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x33, 0x32, 0x20, 0x20, 0x30, 0x20, 0x32,
+    0x33, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x34, 0x30, 0x20, 0x20, 0x30, 0x20, 0x20, 0x34, 0x20,
+    0x0a, 0x20, 0x30, 0x20, 0x34, 0x31, 0x20, 0x20, 0x36, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x31, 0x34, 0x20, 0x20,
+    0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x33, 0x33, 0x20, 0x20, 0x30, 0x20, 0x34, 0x32, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20,
+    0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x32, 0x34, 0x20, 0x20, 0x30, 0x20, 0x35, 0x30, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x0a, 0x20, 0x30, 0x20, 0x34,
+    0x33, 0x20, 0x20, 0x30, 0x20, 0x33, 0x34, 0x20, 0x38, 0x61, 0x20, 0x20, 0x31, 0x20, 0x32, 0x38, 0x20, 0x20, 0x31, 0x20, 0x31, 0x30, 0x20, 0x20, 0x31, 0x20,
+    0x20, 0x36, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x20, 0x35, 0x20, 0x20, 0x30,
+    0x20, 0x31, 0x35, 0x20, 0x20, 0x30, 0x20, 0x35, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x0a, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20,
+    0x35, 0x32, 0x20, 0x20, 0x30, 0x20, 0x32, 0x35, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x34, 0x34,
+    0x20, 0x20, 0x30, 0x20, 0x33, 0x35, 0x20, 0x20, 0x30, 0x20, 0x35, 0x33, 0x20, 0x20, 0x61, 0x20, 0x20, 0x31, 0x20, 0x20, 0x36, 0x20, 0x20, 0x31, 0x20, 0x20,
+    0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x0a, 0x20, 0x30, 0x20, 0x36, 0x30, 0x20, 0x20, 0x30, 0x20, 0x20, 0x36, 0x20, 0x20, 0x30,
+    0x20, 0x36, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x31, 0x36, 0x20, 0x20, 0x30, 0x20, 0x36, 0x32, 0x20, 0x20, 0x38, 0x20, 0x20,
+    0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x32, 0x36, 0x20, 0x20, 0x30, 0x20, 0x35, 0x34, 0x20,
+    0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x0a, 0x20, 0x30, 0x20, 0x34, 0x35, 0x20, 0x20, 0x30, 0x20, 0x36, 0x33, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20,
+    0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x33, 0x36, 0x20, 0x20, 0x30, 0x20, 0x37, 0x30, 0x20, 0x20, 0x30, 0x20, 0x37, 0x31, 0x20, 0x32, 0x38, 0x20,
+    0x20, 0x31, 0x20, 0x31, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x38, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x31, 0x37,
+    0x20, 0x0a, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x20, 0x37, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x35, 0x35, 0x20,
+    0x20, 0x30, 0x20, 0x36, 0x34, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x37, 0x32, 0x20, 0x20, 0x30,
+    0x20, 0x32, 0x37, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x34, 0x36, 0x20, 0x0a, 0x20, 0x30, 0x20,
+    0x36, 0x35, 0x20, 0x20, 0x30, 0x20, 0x37, 0x33, 0x20, 0x20, 0x61, 0x20, 0x20, 0x31, 0x20, 0x20, 0x36, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31,
+    0x20, 0x20, 0x30, 0x20, 0x33, 0x37, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x35, 0x36, 0x20, 0x20, 0x30, 0x20, 0x20, 0x38, 0x20, 0x20,
+    0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x38, 0x30, 0x20, 0x20, 0x30, 0x20, 0x38, 0x31, 0x20, 0x0a, 0x20, 0x36, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32,
+    0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x31, 0x38, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x37, 0x34, 0x20, 0x20, 0x30, 0x20, 0x34,
+    0x37, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x38, 0x32, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x32, 0x38, 0x20,
+    0x20, 0x30, 0x20, 0x36, 0x36, 0x20, 0x31, 0x38, 0x20, 0x20, 0x31, 0x20, 0x0a, 0x20, 0x65, 0x20, 0x20, 0x31, 0x20, 0x20, 0x38, 0x20, 0x20, 0x31, 0x20, 0x20,
+    0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x38, 0x33, 0x20, 0x20, 0x30, 0x20, 0x33, 0x38, 0x20, 0x20, 0x32, 0x20,
+    0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x37, 0x35, 0x20, 0x20, 0x30, 0x20, 0x38, 0x34, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31,
+    0x20, 0x20, 0x30, 0x20, 0x34, 0x38, 0x20, 0x0a, 0x20, 0x30, 0x20, 0x39, 0x30, 0x20, 0x20, 0x30, 0x20, 0x39, 0x31, 0x20, 0x20, 0x36, 0x20, 0x20, 0x31, 0x20,
+    0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x31, 0x39, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x20, 0x39, 0x20, 0x20, 0x30,
+    0x20, 0x37, 0x36, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x39, 0x32, 0x20, 0x20, 0x30, 0x20, 0x32, 0x39, 0x20, 0x20, 0x65, 0x20, 0x20,
+    0x31, 0x20, 0x0a, 0x20, 0x38, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x38, 0x35,
+    0x20, 0x20, 0x30, 0x20, 0x35, 0x38, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x39, 0x33, 0x20, 0x20, 0x30, 0x20, 0x33, 0x39, 0x20, 0x20,
+    0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x61, 0x30, 0x20, 0x20, 0x30, 0x20, 0x20, 0x61, 0x20, 0x0a, 0x20, 0x30,
+    0x20, 0x31, 0x61, 0x20, 0x20, 0x38, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x61, 0x32, 0x20, 0x20, 0x32, 0x20, 0x20,
+    0x31, 0x20, 0x20, 0x30, 0x20, 0x36, 0x37, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x35, 0x37, 0x20, 0x20, 0x30, 0x20, 0x34, 0x39, 0x20,
+    0x20, 0x36, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x39, 0x34, 0x20, 0x0a, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20,
+    0x30, 0x20, 0x37, 0x37, 0x20, 0x20, 0x30, 0x20, 0x38, 0x36, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x61, 0x31, 0x20, 0x20, 0x32, 0x20,
+    0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x36, 0x38, 0x20, 0x20, 0x30, 0x20, 0x39, 0x35, 0x20, 0x64, 0x63, 0x20, 0x20, 0x31, 0x20, 0x37, 0x65, 0x20, 0x20, 0x31,
+    0x20, 0x33, 0x32, 0x20, 0x20, 0x31, 0x20, 0x31, 0x61, 0x20, 0x20, 0x31, 0x20, 0x0a, 0x20, 0x63, 0x20, 0x20, 0x31, 0x20, 0x20, 0x36, 0x20, 0x20, 0x31, 0x20,
+    0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x32, 0x61, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x35, 0x39, 0x20, 0x20, 0x30,
+    0x20, 0x33, 0x61, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x61, 0x33, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x38,
+    0x37, 0x20, 0x20, 0x30, 0x20, 0x37, 0x38, 0x20, 0x0a, 0x20, 0x38, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31,
+    0x20, 0x20, 0x30, 0x20, 0x61, 0x34, 0x20, 0x20, 0x30, 0x20, 0x34, 0x61, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x39, 0x36, 0x20, 0x20,
+    0x30, 0x20, 0x36, 0x39, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x62, 0x30, 0x20, 0x20, 0x30, 0x20,
+    0x20, 0x62, 0x20, 0x0a, 0x20, 0x30, 0x20, 0x62, 0x31, 0x20, 0x20, 0x61, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20,
+    0x31, 0x20, 0x20, 0x30, 0x20, 0x31, 0x62, 0x20, 0x20, 0x30, 0x20, 0x62, 0x32, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x32, 0x62, 0x20,
+    0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x61, 0x35, 0x20, 0x20, 0x30, 0x20, 0x35, 0x61, 0x20, 0x20, 0x36, 0x20, 0x20, 0x31, 0x20, 0x0a, 0x20,
+    0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x62, 0x33, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x61, 0x36, 0x20, 0x20, 0x30, 0x20,
+    0x36, 0x61, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x62, 0x34, 0x20, 0x20, 0x30, 0x20, 0x34, 0x62,
+    0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x20, 0x63, 0x20, 0x20, 0x30, 0x20, 0x63, 0x31, 0x20, 0x0a, 0x31, 0x65, 0x20, 0x20, 0x31, 0x20,
+    0x20, 0x65, 0x20, 0x20, 0x31, 0x20, 0x20, 0x36, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30,
+    0x20, 0x62, 0x35, 0x20, 0x20, 0x30, 0x20, 0x63, 0x32, 0x20, 0x20, 0x30, 0x20, 0x32, 0x63, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20,
+    0x31, 0x20, 0x20, 0x30, 0x20, 0x61, 0x37, 0x20, 0x20, 0x30, 0x20, 0x63, 0x33, 0x20, 0x0a, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x36, 0x62,
+    0x20, 0x20, 0x30, 0x20, 0x63, 0x34, 0x20, 0x20, 0x38, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x31, 0x64, 0x20, 0x20,
+    0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x38, 0x38, 0x20, 0x20, 0x30, 0x20, 0x39, 0x37, 0x20, 0x20, 0x30, 0x20,
+    0x33, 0x62, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x0a, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x64, 0x31, 0x20, 0x20, 0x30, 0x20, 0x64,
+    0x32, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x32, 0x64, 0x20, 0x20, 0x30, 0x20, 0x64, 0x33, 0x20, 0x31, 0x32, 0x20, 0x20, 0x31, 0x20,
+    0x20, 0x36, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x31, 0x65, 0x20, 0x20, 0x30,
+    0x20, 0x32, 0x65, 0x20, 0x0a, 0x20, 0x30, 0x20, 0x65, 0x32, 0x20, 0x20, 0x36, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20,
+    0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x37, 0x39, 0x20, 0x20, 0x30, 0x20, 0x39, 0x38, 0x20, 0x20, 0x30, 0x20, 0x63, 0x30, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31,
+    0x20, 0x20, 0x30, 0x20, 0x31, 0x63, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x38, 0x39, 0x20, 0x20, 0x30, 0x20, 0x35, 0x62, 0x20, 0x0a,
+    0x20, 0x65, 0x20, 0x20, 0x31, 0x20, 0x20, 0x36, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x33, 0x63, 0x20, 0x20, 0x32,
+    0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x37, 0x61, 0x20, 0x20, 0x30, 0x20, 0x62, 0x36, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20,
+    0x31, 0x20, 0x20, 0x30, 0x20, 0x34, 0x63, 0x20, 0x20, 0x30, 0x20, 0x39, 0x39, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x0a, 0x20, 0x30, 0x20, 0x61, 0x38,
+    0x20, 0x20, 0x30, 0x20, 0x38, 0x61, 0x20, 0x20, 0x36, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x20, 0x64, 0x20, 0x20,
+    0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x63, 0x35, 0x20, 0x20, 0x30, 0x20, 0x35, 0x63, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20,
+    0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x33, 0x64, 0x20, 0x20, 0x30, 0x20, 0x63, 0x36, 0x20, 0x0a, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x36,
+    0x63, 0x20, 0x20, 0x30, 0x20, 0x39, 0x61, 0x20, 0x35, 0x38, 0x20, 0x20, 0x31, 0x20, 0x35, 0x36, 0x20, 0x20, 0x31, 0x20, 0x32, 0x34, 0x20, 0x20, 0x31, 0x20,
+    0x31, 0x30, 0x20, 0x20, 0x31, 0x20, 0x20, 0x38, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30,
+    0x20, 0x38, 0x62, 0x20, 0x20, 0x30, 0x20, 0x34, 0x64, 0x20, 0x0a, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x63, 0x37, 0x20, 0x20, 0x30, 0x20,
+    0x37, 0x63, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x64, 0x35, 0x20, 0x20, 0x30, 0x20, 0x35, 0x64,
+    0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x65, 0x30, 0x20, 0x20, 0x30, 0x20, 0x20, 0x65, 0x20, 0x20, 0x38, 0x20, 0x20, 0x31, 0x20, 0x20,
+    0x32, 0x20, 0x20, 0x31, 0x20, 0x0a, 0x20, 0x30, 0x20, 0x65, 0x33, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30,
+    0x20, 0x64, 0x30, 0x20, 0x20, 0x30, 0x20, 0x62, 0x37, 0x20, 0x20, 0x30, 0x20, 0x37, 0x62, 0x20, 0x20, 0x36, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20,
+    0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x61, 0x39, 0x20, 0x20, 0x30, 0x20, 0x62, 0x38, 0x20, 0x20, 0x30, 0x20, 0x64, 0x34, 0x20,
+    0x0a, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x65, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x61, 0x61, 0x20, 0x20,
+    0x30, 0x20, 0x62, 0x39, 0x20, 0x31, 0x38, 0x20, 0x20, 0x31, 0x20, 0x20, 0x61, 0x20, 0x20, 0x31, 0x20, 0x20, 0x36, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20,
+    0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x39, 0x62, 0x20, 0x20, 0x30, 0x20, 0x64, 0x36, 0x20, 0x0a, 0x20, 0x30, 0x20, 0x36,
+    0x64, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x33, 0x65, 0x20, 0x20, 0x30, 0x20, 0x63, 0x38, 0x20, 0x20, 0x36, 0x20, 0x20, 0x31, 0x20,
+    0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x38, 0x63, 0x20, 0x20, 0x30, 0x20, 0x65, 0x34, 0x20, 0x20, 0x30,
+    0x20, 0x34, 0x65, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x0a, 0x20, 0x30, 0x20, 0x64, 0x37, 0x20, 0x20, 0x30, 0x20,
+    0x65, 0x35, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x62, 0x61, 0x20, 0x20, 0x30, 0x20, 0x61, 0x62, 0x20, 0x20, 0x63, 0x20, 0x20, 0x31,
+    0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x39, 0x63, 0x20, 0x20, 0x30, 0x20, 0x65, 0x36, 0x20, 0x20,
+    0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x0a, 0x20, 0x30, 0x20, 0x36, 0x65, 0x20, 0x20, 0x30, 0x20, 0x64, 0x38, 0x20, 0x20, 0x32,
+    0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x38, 0x64, 0x20, 0x20, 0x30, 0x20, 0x62, 0x62, 0x20, 0x20, 0x38, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20,
+    0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x65, 0x37, 0x20, 0x20, 0x30, 0x20, 0x39, 0x64, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20,
+    0x20, 0x30, 0x20, 0x65, 0x38, 0x20, 0x0a, 0x20, 0x30, 0x20, 0x38, 0x65, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20,
+    0x30, 0x20, 0x63, 0x62, 0x20, 0x20, 0x30, 0x20, 0x62, 0x63, 0x20, 0x20, 0x30, 0x20, 0x39, 0x65, 0x20, 0x20, 0x30, 0x20, 0x66, 0x31, 0x20, 0x20, 0x32, 0x20,
+    0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x31, 0x66, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x20, 0x66, 0x20, 0x20, 0x30, 0x20, 0x32, 0x66,
+    0x20, 0x0a, 0x34, 0x32, 0x20, 0x20, 0x31, 0x20, 0x33, 0x38, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x66, 0x32, 0x20,
+    0x33, 0x34, 0x20, 0x20, 0x31, 0x20, 0x33, 0x32, 0x20, 0x20, 0x31, 0x20, 0x31, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x38, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32,
+    0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x62, 0x64, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x35, 0x65, 0x20, 0x0a, 0x20, 0x32, 0x20,
+    0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x37, 0x64, 0x20, 0x20, 0x30, 0x20, 0x63, 0x39, 0x20, 0x20, 0x36, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31,
+    0x20, 0x20, 0x30, 0x20, 0x63, 0x61, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x61, 0x63, 0x20, 0x20, 0x30, 0x20, 0x37, 0x65, 0x20, 0x20,
+    0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x64, 0x61, 0x20, 0x0a, 0x20, 0x30, 0x20, 0x61, 0x64, 0x20, 0x20, 0x30,
+    0x20, 0x63, 0x63, 0x20, 0x20, 0x61, 0x20, 0x20, 0x31, 0x20, 0x20, 0x36, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x61,
+    0x65, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x64, 0x62, 0x20, 0x20, 0x30, 0x20, 0x64, 0x63, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20,
+    0x20, 0x30, 0x20, 0x63, 0x64, 0x20, 0x20, 0x30, 0x20, 0x62, 0x65, 0x20, 0x0a, 0x20, 0x36, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20,
+    0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x65, 0x62, 0x20, 0x20, 0x30, 0x20, 0x65, 0x64, 0x20, 0x20, 0x30, 0x20, 0x65, 0x65, 0x20, 0x20, 0x36, 0x20,
+    0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x64, 0x39, 0x20, 0x20, 0x30, 0x20, 0x65, 0x61,
+    0x20, 0x20, 0x30, 0x20, 0x65, 0x39, 0x20, 0x0a, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x64, 0x65, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20,
+    0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x64, 0x64, 0x20, 0x20, 0x30, 0x20, 0x65, 0x63, 0x20, 0x20, 0x30, 0x20, 0x63, 0x65, 0x20, 0x20, 0x30,
+    0x20, 0x33, 0x66, 0x20, 0x20, 0x30, 0x20, 0x66, 0x30, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x66,
+    0x33, 0x20, 0x0a, 0x20, 0x30, 0x20, 0x66, 0x34, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x34, 0x66, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31,
+    0x20, 0x20, 0x30, 0x20, 0x66, 0x35, 0x20, 0x20, 0x30, 0x20, 0x35, 0x66, 0x20, 0x20, 0x61, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20,
+    0x30, 0x20, 0x66, 0x66, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x66, 0x36, 0x20, 0x0a, 0x20, 0x30,
+    0x20, 0x36, 0x66, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x66, 0x37, 0x20, 0x20, 0x30, 0x20, 0x37, 0x66, 0x20, 0x20, 0x63, 0x20, 0x20,
+    0x31, 0x20, 0x20, 0x36, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x38, 0x66, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20,
+    0x20, 0x30, 0x20, 0x66, 0x38, 0x20, 0x20, 0x30, 0x20, 0x66, 0x39, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x0a, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20,
+    0x30, 0x20, 0x39, 0x66, 0x20, 0x20, 0x30, 0x20, 0x66, 0x61, 0x20, 0x20, 0x30, 0x20, 0x61, 0x66, 0x20, 0x20, 0x38, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20,
+    0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x66, 0x62, 0x20, 0x20, 0x30, 0x20, 0x62, 0x66, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31,
+    0x20, 0x20, 0x30, 0x20, 0x66, 0x63, 0x20, 0x20, 0x30, 0x20, 0x63, 0x66, 0x20, 0x0a, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20,
+    0x20, 0x30, 0x20, 0x66, 0x64, 0x20, 0x20, 0x30, 0x20, 0x64, 0x66, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x66, 0x65, 0x20, 0x20, 0x30,
+    0x20, 0x65, 0x66, 0x20, 0x0a, 0x0a, 0x2e, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x31, 0x37, 0x20, 0x35, 0x31, 0x31, 0x20, 0x31, 0x36, 0x20, 0x31, 0x36, 0x20,
+    0x20, 0x32, 0x0a, 0x2e, 0x72, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x20, 0x31, 0x36, 0x0a, 0x0a, 0x2e, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x31,
+    0x38, 0x20, 0x35, 0x31, 0x31, 0x20, 0x31, 0x36, 0x20, 0x31, 0x36, 0x20, 0x20, 0x33, 0x0a, 0x2e, 0x72, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x20,
+    0x31, 0x36, 0x0a, 0x0a, 0x2e, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x31, 0x39, 0x20, 0x35, 0x31, 0x31, 0x20, 0x31, 0x36, 0x20, 0x31, 0x36, 0x20, 0x20, 0x34,
+    0x0a, 0x2e, 0x72, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x20, 0x31, 0x36, 0x0a, 0x0a, 0x2e, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x32, 0x30, 0x20,
+    0x35, 0x31, 0x31, 0x20, 0x31, 0x36, 0x20, 0x31, 0x36, 0x20, 0x20, 0x36, 0x0a, 0x2e, 0x72, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x20, 0x31, 0x36,
+    0x0a, 0x0a, 0x2e, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x32, 0x31, 0x20, 0x35, 0x31, 0x31, 0x20, 0x31, 0x36, 0x20, 0x31, 0x36, 0x20, 0x20, 0x38, 0x0a, 0x2e,
+    0x72, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x20, 0x31, 0x36, 0x0a, 0x0a, 0x2e, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x32, 0x32, 0x20, 0x35, 0x31,
+    0x31, 0x20, 0x31, 0x36, 0x20, 0x31, 0x36, 0x20, 0x31, 0x30, 0x0a, 0x2e, 0x72, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x20, 0x31, 0x36, 0x0a, 0x0a,
+    0x2e, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x32, 0x33, 0x20, 0x35, 0x31, 0x31, 0x20, 0x31, 0x36, 0x20, 0x31, 0x36, 0x20, 0x31, 0x33, 0x0a, 0x2e, 0x72, 0x65,
+    0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x20, 0x31, 0x36, 0x0a, 0x0a, 0x2e, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x32, 0x34, 0x20, 0x35, 0x31, 0x32, 0x20,
+    0x31, 0x36, 0x20, 0x31, 0x36, 0x20, 0x20, 0x34, 0x0a, 0x2e, 0x74, 0x72, 0x65, 0x65, 0x64, 0x61, 0x74, 0x61, 0x0a, 0x33, 0x63, 0x20, 0x20, 0x31, 0x20, 0x20,
+    0x38, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x20, 0x30, 0x20, 0x20, 0x30, 0x20,
+    0x31, 0x30, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x31, 0x31, 0x20, 0x20, 0x65, 0x20, 0x20, 0x31,
+    0x20, 0x20, 0x36, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x0a, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x32, 0x30, 0x20,
+    0x20, 0x30, 0x20, 0x20, 0x32, 0x20, 0x20, 0x30, 0x20, 0x32, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x31, 0x32, 0x20, 0x20, 0x32,
+    0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x32, 0x32, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x33, 0x30, 0x20, 0x20, 0x30, 0x20, 0x20,
+    0x33, 0x20, 0x20, 0x65, 0x20, 0x20, 0x31, 0x20, 0x0a, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x33, 0x31,
+    0x20, 0x20, 0x30, 0x20, 0x31, 0x33, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x33, 0x32, 0x20, 0x20,
+    0x30, 0x20, 0x32, 0x33, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x34, 0x30, 0x20, 0x20, 0x30, 0x20,
+    0x20, 0x34, 0x20, 0x0a, 0x20, 0x30, 0x20, 0x34, 0x31, 0x20, 0x20, 0x38, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20,
+    0x31, 0x20, 0x20, 0x30, 0x20, 0x31, 0x34, 0x20, 0x20, 0x30, 0x20, 0x33, 0x33, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x34, 0x32, 0x20,
+    0x20, 0x30, 0x20, 0x32, 0x34, 0x20, 0x20, 0x36, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x0a, 0x20,
+    0x30, 0x20, 0x34, 0x33, 0x20, 0x20, 0x30, 0x20, 0x33, 0x34, 0x20, 0x20, 0x30, 0x20, 0x35, 0x31, 0x20, 0x20, 0x36, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20,
+    0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x35, 0x30, 0x20, 0x20, 0x30, 0x20, 0x20, 0x35, 0x20, 0x20, 0x30, 0x20, 0x31, 0x35,
+    0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x35, 0x32, 0x20, 0x20, 0x30, 0x20, 0x32, 0x35, 0x20, 0x0a, 0x66, 0x61, 0x20, 0x20, 0x31, 0x20,
+    0x36, 0x32, 0x20, 0x20, 0x31, 0x20, 0x32, 0x32, 0x20, 0x20, 0x31, 0x20, 0x31, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x61, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34,
+    0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x34, 0x34, 0x20, 0x20, 0x30, 0x20, 0x35, 0x33, 0x20, 0x20, 0x32, 0x20, 0x20,
+    0x31, 0x20, 0x20, 0x30, 0x20, 0x33, 0x35, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x0a, 0x20, 0x30, 0x20, 0x36, 0x30, 0x20, 0x20, 0x30, 0x20, 0x20, 0x36,
+    0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x36, 0x31, 0x20, 0x20, 0x30, 0x20, 0x31, 0x36, 0x20, 0x20,
+    0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x36, 0x32, 0x20, 0x20, 0x30, 0x20, 0x32, 0x36, 0x20, 0x20, 0x38, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20,
+    0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x0a, 0x20, 0x30, 0x20, 0x35, 0x34, 0x20, 0x20, 0x30, 0x20, 0x34, 0x35, 0x20, 0x20, 0x32, 0x20, 0x20,
+    0x31, 0x20, 0x20, 0x30, 0x20, 0x36, 0x33, 0x20, 0x20, 0x30, 0x20, 0x33, 0x36, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20,
+    0x20, 0x30, 0x20, 0x37, 0x31, 0x20, 0x20, 0x30, 0x20, 0x35, 0x35, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x36, 0x34, 0x20, 0x20, 0x30,
+    0x20, 0x34, 0x36, 0x20, 0x0a, 0x32, 0x30, 0x20, 0x20, 0x31, 0x20, 0x20, 0x65, 0x20, 0x20, 0x31, 0x20, 0x20, 0x36, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20,
+    0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x37, 0x32, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x32, 0x37, 0x20, 0x20, 0x30, 0x20, 0x33, 0x37,
+    0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x37, 0x33, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x0a,
+    0x20, 0x30, 0x20, 0x37, 0x30, 0x20, 0x20, 0x30, 0x20, 0x20, 0x37, 0x20, 0x20, 0x30, 0x20, 0x31, 0x37, 0x20, 0x20, 0x61, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34,
+    0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x36, 0x35, 0x20, 0x20, 0x30, 0x20, 0x35, 0x36, 0x20, 0x20, 0x34, 0x20, 0x20,
+    0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x38, 0x30, 0x20, 0x20, 0x30, 0x20, 0x20, 0x38, 0x20, 0x0a, 0x20, 0x30, 0x20, 0x38, 0x31,
+    0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x37, 0x34, 0x20, 0x20, 0x30, 0x20, 0x34, 0x37, 0x20, 0x20,
+    0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x31, 0x38, 0x20, 0x20, 0x30, 0x20, 0x38, 0x32, 0x20, 0x31, 0x30, 0x20, 0x20, 0x31, 0x20, 0x20, 0x38, 0x20,
+    0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x0a, 0x20, 0x30, 0x20, 0x32, 0x38, 0x20, 0x20, 0x30, 0x20, 0x36,
+    0x36, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x38, 0x33, 0x20, 0x20, 0x30, 0x20, 0x33, 0x38, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20,
+    0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x37, 0x35, 0x20, 0x20, 0x30, 0x20, 0x35, 0x37, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30,
+    0x20, 0x38, 0x34, 0x20, 0x20, 0x30, 0x20, 0x34, 0x38, 0x20, 0x0a, 0x20, 0x38, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20,
+    0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x39, 0x31, 0x20, 0x20, 0x30, 0x20, 0x31, 0x39, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x39, 0x32,
+    0x20, 0x20, 0x30, 0x20, 0x37, 0x36, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x36, 0x37, 0x20, 0x20,
+    0x30, 0x20, 0x32, 0x39, 0x20, 0x0a, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x38, 0x35, 0x20, 0x20, 0x30, 0x20, 0x35, 0x38, 0x20, 0x35, 0x63,
+    0x20, 0x20, 0x31, 0x20, 0x32, 0x32, 0x20, 0x20, 0x31, 0x20, 0x31, 0x30, 0x20, 0x20, 0x31, 0x20, 0x20, 0x38, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20,
+    0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x39, 0x33, 0x20, 0x20, 0x30, 0x20, 0x33, 0x39, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20,
+    0x0a, 0x20, 0x30, 0x20, 0x39, 0x34, 0x20, 0x20, 0x30, 0x20, 0x34, 0x39, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20,
+    0x30, 0x20, 0x37, 0x37, 0x20, 0x20, 0x30, 0x20, 0x38, 0x36, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x36, 0x38, 0x20, 0x20, 0x30, 0x20,
+    0x61, 0x31, 0x20, 0x20, 0x38, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x0a, 0x20, 0x30, 0x20, 0x61,
+    0x32, 0x20, 0x20, 0x30, 0x20, 0x32, 0x61, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x39, 0x35, 0x20, 0x20, 0x30, 0x20, 0x35, 0x39, 0x20,
+    0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x61, 0x33, 0x20, 0x20, 0x30, 0x20, 0x33, 0x61, 0x20, 0x20, 0x32,
+    0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x38, 0x37, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x0a, 0x20, 0x30, 0x20, 0x37, 0x38, 0x20, 0x20, 0x30, 0x20,
+    0x34, 0x61, 0x20, 0x31, 0x36, 0x20, 0x20, 0x31, 0x20, 0x20, 0x63, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31,
+    0x20, 0x20, 0x30, 0x20, 0x61, 0x34, 0x20, 0x20, 0x30, 0x20, 0x39, 0x36, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20,
+    0x30, 0x20, 0x36, 0x39, 0x20, 0x20, 0x30, 0x20, 0x62, 0x31, 0x20, 0x0a, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x31, 0x62, 0x20, 0x20, 0x30,
+    0x20, 0x61, 0x35, 0x20, 0x20, 0x36, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x62, 0x32, 0x20, 0x20, 0x32, 0x20, 0x20,
+    0x31, 0x20, 0x20, 0x30, 0x20, 0x35, 0x61, 0x20, 0x20, 0x30, 0x20, 0x32, 0x62, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x38, 0x38, 0x20,
+    0x20, 0x30, 0x20, 0x62, 0x33, 0x20, 0x0a, 0x31, 0x30, 0x20, 0x20, 0x31, 0x20, 0x20, 0x61, 0x20, 0x20, 0x31, 0x20, 0x20, 0x36, 0x20, 0x20, 0x31, 0x20, 0x20,
+    0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x39, 0x30, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x20, 0x39, 0x20, 0x20, 0x30, 0x20,
+    0x61, 0x30, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x39, 0x37, 0x20, 0x20, 0x30, 0x20, 0x37, 0x39, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31,
+    0x20, 0x0a, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x61, 0x36, 0x20, 0x20, 0x30, 0x20, 0x36, 0x61, 0x20, 0x20, 0x30, 0x20, 0x62, 0x34, 0x20,
+    0x20, 0x63, 0x20, 0x20, 0x31, 0x20, 0x20, 0x36, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x31, 0x61, 0x20, 0x20, 0x32,
+    0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x20, 0x61, 0x20, 0x20, 0x30, 0x20, 0x62, 0x30, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x0a, 0x20, 0x30, 0x20,
+    0x33, 0x62, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x20, 0x62, 0x20, 0x20, 0x30, 0x20, 0x63, 0x30, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31,
+    0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x34, 0x62, 0x20, 0x20, 0x30, 0x20, 0x63, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20,
+    0x30, 0x20, 0x39, 0x38, 0x20, 0x20, 0x30, 0x20, 0x38, 0x39, 0x20, 0x34, 0x33, 0x20, 0x20, 0x31, 0x20, 0x0a, 0x32, 0x32, 0x20, 0x20, 0x31, 0x20, 0x31, 0x30,
+    0x20, 0x20, 0x31, 0x20, 0x20, 0x38, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x31,
+    0x63, 0x20, 0x20, 0x30, 0x20, 0x62, 0x35, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x35, 0x62, 0x20, 0x20, 0x30, 0x20, 0x63, 0x32, 0x20,
+    0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x0a, 0x20, 0x30, 0x20, 0x32, 0x63, 0x20, 0x20, 0x30, 0x20, 0x61, 0x37, 0x20, 0x20,
+    0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x37, 0x61, 0x20, 0x20, 0x30, 0x20, 0x63, 0x33, 0x20, 0x20, 0x61, 0x20, 0x20, 0x31, 0x20, 0x20, 0x36, 0x20,
+    0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x33, 0x63, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x20, 0x63,
+    0x20, 0x20, 0x30, 0x20, 0x64, 0x30, 0x20, 0x0a, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x62, 0x36, 0x20, 0x20, 0x30, 0x20, 0x36, 0x62, 0x20,
+    0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x63, 0x34, 0x20, 0x20, 0x30, 0x20, 0x34, 0x63, 0x20, 0x20, 0x32,
+    0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x39, 0x39, 0x20, 0x20, 0x30, 0x20, 0x61, 0x38, 0x20, 0x31, 0x30, 0x20, 0x20, 0x31, 0x20, 0x20, 0x38, 0x20, 0x20,
+    0x31, 0x20, 0x0a, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x38, 0x61, 0x20, 0x20, 0x30, 0x20, 0x63, 0x35,
+    0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x35, 0x63, 0x20, 0x20, 0x30, 0x20, 0x64, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20,
+    0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x62, 0x37, 0x20, 0x20, 0x30, 0x20, 0x37, 0x62, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x0a, 0x20, 0x30,
+    0x20, 0x31, 0x64, 0x20, 0x20, 0x30, 0x20, 0x64, 0x32, 0x20, 0x20, 0x39, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20,
+    0x31, 0x20, 0x20, 0x30, 0x20, 0x32, 0x64, 0x20, 0x20, 0x30, 0x20, 0x64, 0x33, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x33, 0x64, 0x20,
+    0x20, 0x30, 0x20, 0x63, 0x36, 0x20, 0x35, 0x35, 0x20, 0x66, 0x61, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x0a, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20,
+    0x30, 0x20, 0x36, 0x63, 0x20, 0x20, 0x30, 0x20, 0x61, 0x39, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x39, 0x61, 0x20, 0x20, 0x30, 0x20,
+    0x64, 0x34, 0x20, 0x32, 0x30, 0x20, 0x20, 0x31, 0x20, 0x31, 0x30, 0x20, 0x20, 0x31, 0x20, 0x20, 0x38, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31,
+    0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x62, 0x38, 0x20, 0x0a, 0x20, 0x30, 0x20, 0x38, 0x62, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20,
+    0x20, 0x30, 0x20, 0x34, 0x64, 0x20, 0x20, 0x30, 0x20, 0x63, 0x37, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30,
+    0x20, 0x37, 0x63, 0x20, 0x20, 0x30, 0x20, 0x64, 0x35, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x35, 0x64, 0x20, 0x20, 0x30, 0x20, 0x65,
+    0x31, 0x20, 0x20, 0x38, 0x20, 0x20, 0x31, 0x20, 0x0a, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x31, 0x65,
+    0x20, 0x20, 0x30, 0x20, 0x65, 0x32, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x61, 0x61, 0x20, 0x20, 0x30, 0x20, 0x62, 0x39, 0x20, 0x20,
+    0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x39, 0x62, 0x20, 0x20, 0x30, 0x20, 0x65, 0x33, 0x20, 0x20, 0x32, 0x20,
+    0x20, 0x31, 0x20, 0x0a, 0x20, 0x30, 0x20, 0x64, 0x36, 0x20, 0x20, 0x30, 0x20, 0x36, 0x64, 0x20, 0x31, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x61, 0x20, 0x20,
+    0x31, 0x20, 0x20, 0x36, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x33, 0x65, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20,
+    0x20, 0x30, 0x20, 0x32, 0x65, 0x20, 0x20, 0x30, 0x20, 0x34, 0x65, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x63, 0x38, 0x20, 0x0a, 0x20,
+    0x30, 0x20, 0x38, 0x63, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x65, 0x34, 0x20, 0x20, 0x30, 0x20,
+    0x64, 0x37, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x37, 0x64, 0x20, 0x20, 0x30, 0x20, 0x61, 0x62,
+    0x20, 0x20, 0x30, 0x20, 0x65, 0x35, 0x20, 0x20, 0x61, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x0a, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20,
+    0x20, 0x30, 0x20, 0x62, 0x61, 0x20, 0x20, 0x30, 0x20, 0x35, 0x65, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x63, 0x39, 0x20, 0x20, 0x32,
+    0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x39, 0x63, 0x20, 0x20, 0x30, 0x20, 0x36, 0x65, 0x20, 0x20, 0x38, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20,
+    0x31, 0x20, 0x20, 0x30, 0x20, 0x65, 0x36, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x0a, 0x20, 0x30, 0x20, 0x20, 0x64, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31,
+    0x20, 0x20, 0x30, 0x20, 0x65, 0x30, 0x20, 0x20, 0x30, 0x20, 0x20, 0x65, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20,
+    0x30, 0x20, 0x64, 0x38, 0x20, 0x20, 0x30, 0x20, 0x38, 0x64, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x62, 0x62, 0x20, 0x20, 0x30, 0x20,
+    0x63, 0x61, 0x20, 0x34, 0x61, 0x20, 0x20, 0x31, 0x20, 0x0a, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x66, 0x66, 0x20, 0x34, 0x30, 0x20, 0x20,
+    0x31, 0x20, 0x33, 0x61, 0x20, 0x20, 0x31, 0x20, 0x32, 0x30, 0x20, 0x20, 0x31, 0x20, 0x31, 0x30, 0x20, 0x20, 0x31, 0x20, 0x20, 0x38, 0x20, 0x20, 0x31, 0x20,
+    0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x61, 0x63, 0x20, 0x20, 0x30, 0x20, 0x65, 0x37, 0x20, 0x20, 0x32,
+    0x20, 0x20, 0x31, 0x20, 0x0a, 0x20, 0x30, 0x20, 0x37, 0x65, 0x20, 0x20, 0x30, 0x20, 0x64, 0x39, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20,
+    0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x39, 0x64, 0x20, 0x20, 0x30, 0x20, 0x65, 0x38, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x38, 0x65,
+    0x20, 0x20, 0x30, 0x20, 0x63, 0x62, 0x20, 0x20, 0x38, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x0a,
+    0x20, 0x30, 0x20, 0x62, 0x63, 0x20, 0x20, 0x30, 0x20, 0x64, 0x61, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x61, 0x64, 0x20, 0x20, 0x30,
+    0x20, 0x65, 0x39, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x39, 0x65, 0x20, 0x20, 0x30, 0x20, 0x63,
+    0x63, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x64, 0x62, 0x20, 0x20, 0x30, 0x20, 0x62, 0x64, 0x20, 0x0a, 0x31, 0x30, 0x20, 0x20, 0x31,
+    0x20, 0x20, 0x38, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x65, 0x61, 0x20, 0x20,
+    0x30, 0x20, 0x61, 0x65, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x64, 0x63, 0x20, 0x20, 0x30, 0x20, 0x63, 0x64, 0x20, 0x20, 0x34, 0x20,
+    0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x65, 0x62, 0x20, 0x0a, 0x20, 0x30, 0x20, 0x62, 0x65, 0x20, 0x20, 0x32, 0x20, 0x20,
+    0x31, 0x20, 0x20, 0x30, 0x20, 0x64, 0x64, 0x20, 0x20, 0x30, 0x20, 0x65, 0x63, 0x20, 0x20, 0x38, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20,
+    0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x63, 0x65, 0x20, 0x20, 0x30, 0x20, 0x65, 0x64, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30,
+    0x20, 0x64, 0x65, 0x20, 0x20, 0x30, 0x20, 0x65, 0x65, 0x20, 0x0a, 0x20, 0x30, 0x20, 0x20, 0x66, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20,
+    0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x66, 0x30, 0x20, 0x20, 0x30, 0x20, 0x31, 0x66, 0x20, 0x20, 0x30, 0x20, 0x66, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31,
+    0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x66, 0x32, 0x20, 0x20, 0x30, 0x20, 0x32, 0x66, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20,
+    0x30, 0x20, 0x66, 0x33, 0x20, 0x0a, 0x20, 0x30, 0x20, 0x33, 0x66, 0x20, 0x31, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x38, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34,
+    0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x66, 0x34, 0x20, 0x20, 0x30, 0x20, 0x34, 0x66, 0x20, 0x20, 0x32, 0x20, 0x20,
+    0x31, 0x20, 0x20, 0x30, 0x20, 0x66, 0x35, 0x20, 0x20, 0x30, 0x20, 0x35, 0x66, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20,
+    0x0a, 0x20, 0x30, 0x20, 0x66, 0x36, 0x20, 0x20, 0x30, 0x20, 0x36, 0x66, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x66, 0x37, 0x20, 0x20,
+    0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x37, 0x66, 0x20, 0x20, 0x30, 0x20, 0x38, 0x66, 0x20, 0x20, 0x61, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20,
+    0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x66, 0x38, 0x20, 0x20, 0x30, 0x20, 0x66, 0x39, 0x20, 0x0a, 0x20, 0x34, 0x20, 0x20,
+    0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x39, 0x66, 0x20, 0x20, 0x30, 0x20, 0x61, 0x66, 0x20, 0x20, 0x30, 0x20, 0x66, 0x61, 0x20,
+    0x20, 0x38, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x66, 0x62, 0x20, 0x20, 0x30,
+    0x20, 0x62, 0x66, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x66, 0x63, 0x20, 0x0a, 0x20, 0x30, 0x20, 0x63, 0x66, 0x20, 0x20, 0x34, 0x20,
+    0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x66, 0x64, 0x20, 0x20, 0x30, 0x20, 0x64, 0x66, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31,
+    0x20, 0x20, 0x30, 0x20, 0x66, 0x65, 0x20, 0x20, 0x30, 0x20, 0x65, 0x66, 0x20, 0x0a, 0x0a, 0x2e, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x32, 0x35, 0x20, 0x35,
+    0x31, 0x32, 0x20, 0x31, 0x36, 0x20, 0x31, 0x36, 0x20, 0x20, 0x35, 0x0a, 0x2e, 0x72, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x20, 0x32, 0x34, 0x0a,
+    0x0a, 0x2e, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x32, 0x36, 0x20, 0x35, 0x31, 0x32, 0x20, 0x31, 0x36, 0x20, 0x31, 0x36, 0x20, 0x20, 0x36, 0x0a, 0x2e, 0x72,
+    0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x20, 0x32, 0x34, 0x0a, 0x0a, 0x2e, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x32, 0x37, 0x20, 0x35, 0x31, 0x32,
+    0x20, 0x31, 0x36, 0x20, 0x31, 0x36, 0x20, 0x20, 0x37, 0x0a, 0x2e, 0x72, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x20, 0x32, 0x34, 0x0a, 0x0a, 0x2e,
+    0x74, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x32, 0x38, 0x20, 0x35, 0x31, 0x32, 0x20, 0x31, 0x36, 0x20, 0x31, 0x36, 0x20, 0x20, 0x38, 0x0a, 0x2e, 0x72, 0x65, 0x66,
+    0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x20, 0x32, 0x34, 0x0a, 0x0a, 0x2e, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x32, 0x39, 0x20, 0x35, 0x31, 0x32, 0x20, 0x31,
+    0x36, 0x20, 0x31, 0x36, 0x20, 0x20, 0x39, 0x0a, 0x2e, 0x72, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x20, 0x32, 0x34, 0x0a, 0x0a, 0x2e, 0x74, 0x61,
+    0x62, 0x6c, 0x65, 0x20, 0x33, 0x30, 0x20, 0x35, 0x31, 0x32, 0x20, 0x31, 0x36, 0x20, 0x31, 0x36, 0x20, 0x31, 0x31, 0x0a, 0x2e, 0x72, 0x65, 0x66, 0x65, 0x72,
+    0x65, 0x6e, 0x63, 0x65, 0x20, 0x32, 0x34, 0x0a, 0x0a, 0x2e, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x33, 0x31, 0x20, 0x35, 0x31, 0x32, 0x20, 0x31, 0x36, 0x20,
+    0x31, 0x36, 0x20, 0x31, 0x33, 0x0a, 0x2e, 0x72, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x20, 0x32, 0x34, 0x0a, 0x0a, 0x2e, 0x74, 0x61, 0x62, 0x6c,
+    0x65, 0x20, 0x33, 0x32, 0x20, 0x20, 0x33, 0x31, 0x20, 0x20, 0x31, 0x20, 0x31, 0x36, 0x20, 0x20, 0x30, 0x0a, 0x2e, 0x74, 0x72, 0x65, 0x65, 0x64, 0x61, 0x74,
+    0x61, 0x0a, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x20, 0x30, 0x20, 0x20, 0x38, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20,
+    0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x20, 0x38, 0x20, 0x20, 0x30, 0x20, 0x20, 0x34, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30,
+    0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x20, 0x32, 0x20, 0x20, 0x38, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x0a, 0x20, 0x32, 0x20,
+    0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x20, 0x63, 0x20, 0x20, 0x30, 0x20, 0x20, 0x61, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x20, 0x33,
+    0x20, 0x20, 0x30, 0x20, 0x20, 0x36, 0x20, 0x20, 0x36, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x20, 0x39, 0x20, 0x20,
+    0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x20, 0x35, 0x20, 0x20, 0x30, 0x20, 0x20, 0x37, 0x20, 0x0a, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32,
+    0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x20, 0x65, 0x20, 0x20, 0x30, 0x20, 0x20, 0x64, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x20,
+    0x66, 0x20, 0x20, 0x30, 0x20, 0x20, 0x62, 0x20, 0x0a, 0x0a, 0x2e, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x33, 0x33, 0x20, 0x20, 0x33, 0x31, 0x20, 0x20, 0x31,
+    0x20, 0x31, 0x36, 0x20, 0x20, 0x30, 0x0a, 0x2e, 0x74, 0x72, 0x65, 0x65, 0x64, 0x61, 0x74, 0x61, 0x0a, 0x31, 0x30, 0x20, 0x20, 0x31, 0x20, 0x20, 0x38, 0x20,
+    0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x20, 0x30, 0x20, 0x20, 0x30, 0x20, 0x20, 0x31,
+    0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x20, 0x32, 0x20, 0x20, 0x30, 0x20, 0x20, 0x33, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20,
+    0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x20, 0x34, 0x20, 0x0a, 0x20, 0x30, 0x20, 0x20, 0x35, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30,
+    0x20, 0x20, 0x36, 0x20, 0x20, 0x30, 0x20, 0x20, 0x37, 0x20, 0x20, 0x38, 0x20, 0x20, 0x31, 0x20, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20,
+    0x31, 0x20, 0x20, 0x30, 0x20, 0x20, 0x38, 0x20, 0x20, 0x30, 0x20, 0x20, 0x39, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x20, 0x61, 0x20,
+    0x20, 0x30, 0x20, 0x20, 0x62, 0x20, 0x0a, 0x20, 0x34, 0x20, 0x20, 0x31, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x20, 0x63, 0x20, 0x20,
+    0x30, 0x20, 0x20, 0x64, 0x20, 0x20, 0x32, 0x20, 0x20, 0x31, 0x20, 0x20, 0x30, 0x20, 0x20, 0x65, 0x20, 0x20, 0x30, 0x20, 0x20, 0x66, 0x20, 0x0a, 0x0a, 0x2e,
+    0x65, 0x6e, 0x64, 0x0a
+};
diff --git a/3rdparty/live555/src/liveMedia/MP3StreamState.cpp b/3rdparty/live555/src/liveMedia/MP3StreamState.cpp
new file mode 100644
index 00000000..b4445923
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/MP3StreamState.cpp
@@ -0,0 +1,387 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A class encapsulating the state of a MP3 stream
+// Implementation
+
+#include "MP3StreamState.hh"
+#include "InputFile.hh"
+#include "GroupsockHelper.hh"
+
+#if defined(__WIN32__) || defined(_WIN32)
+#define snprintf _snprintf
+#if _MSC_VER >= 1400  // 1400 == vs2005
+#define fileno _fileno
+#endif
+#endif
+
+#define MILLION 1000000
+
+MP3StreamState::MP3StreamState() : fFid(NULL), fPresentationTimeScale(1) {}
+
+MP3StreamState::~MP3StreamState() {
+    // Close our open file or socket:
+    if(fFid != NULL && fFid != stdin) {
+        if(fFidIsReallyASocket) {
+            intptr_t fid_long = (intptr_t)fFid;
+            closeSocket((int)fid_long);
+        }
+        else {
+            CloseInputFile(fFid);
+        }
+    }
+}
+
+void MP3StreamState::assignStream(FILE *fid, unsigned fileSize) {
+    fFid = fid;
+
+    if(fileSize == (unsigned)(-1)) { /*HACK#####*/
+        fFidIsReallyASocket = 1;
+        fFileSize           = 0;
+    }
+    else {
+        fFidIsReallyASocket = 0;
+        fFileSize           = fileSize;
+    }
+    fNumFramesInFile = 0;          // until we know otherwise
+    fIsVBR = fHasXingTOC = False;  // ditto
+
+    // Set the first frame's 'presentation time' to the current wall time:
+    gettimeofday(&fNextFramePresentationTime, NULL);
+}
+
+struct timeval MP3StreamState::currentFramePlayTime() const {
+    unsigned const numSamples = 1152;
+    unsigned const freq       = fr().samplingFreq * (1 + fr().isMPEG2);
+
+    // result is numSamples/freq
+    unsigned const uSeconds = ((numSamples * 2 * MILLION) / freq + 1) / 2;  // rounds to nearest integer
+
+    struct timeval result;
+    result.tv_sec  = uSeconds / MILLION;
+    result.tv_usec = uSeconds % MILLION;
+    return result;
+}
+
+float MP3StreamState::filePlayTime() const {
+    unsigned numFramesInFile = fNumFramesInFile;
+    if(numFramesInFile == 0) {
+        // Estimate the number of frames from the file size, and the
+        // size of the current frame:
+        numFramesInFile = fFileSize / (4 + fCurrentFrame.frameSize);
+    }
+
+    struct timeval const pt = currentFramePlayTime();
+    return numFramesInFile * (pt.tv_sec + pt.tv_usec / (float)MILLION);
+}
+
+unsigned MP3StreamState::getByteNumberFromPositionFraction(float fraction) {
+    if(fHasXingTOC) {
+        // The file is VBR, with a Xing TOC; use it to determine which byte to seek to:
+        float    percent = fraction * 100.0f;
+        unsigned a       = (unsigned)percent;
+        if(a > 99)
+            a = 99;
+
+        unsigned fa = fXingTOC[a];
+        unsigned fb;
+        if(a < 99) {
+            fb = fXingTOC[a + 1];
+        }
+        else {
+            fb = 256;
+        }
+        fraction = (fa + (fb - fa) * (percent - a)) / 256.0f;
+    }
+
+    return (unsigned)(fraction * fFileSize);
+}
+
+void MP3StreamState::seekWithinFile(unsigned seekByteNumber) {
+    if(fFidIsReallyASocket)
+        return;  // it's not seekable
+
+    SeekFile64(fFid, seekByteNumber, SEEK_SET);
+}
+
+unsigned MP3StreamState::findNextHeader(struct timeval &presentationTime) {
+    presentationTime = fNextFramePresentationTime;
+
+    if(!findNextFrame())
+        return 0;
+
+    // From this frame, figure out the *next* frame's presentation time:
+    struct timeval framePlayTime = currentFramePlayTime();
+    if(fPresentationTimeScale > 1) {
+        // Scale this value
+        unsigned secondsRem = framePlayTime.tv_sec % fPresentationTimeScale;
+        framePlayTime.tv_sec -= secondsRem;
+        framePlayTime.tv_usec += secondsRem * MILLION;
+        framePlayTime.tv_sec /= fPresentationTimeScale;
+        framePlayTime.tv_usec /= fPresentationTimeScale;
+    }
+    fNextFramePresentationTime.tv_usec += framePlayTime.tv_usec;
+    fNextFramePresentationTime.tv_sec += framePlayTime.tv_sec + fNextFramePresentationTime.tv_usec / MILLION;
+    fNextFramePresentationTime.tv_usec %= MILLION;
+
+    return fr().hdr;
+}
+
+Boolean MP3StreamState::readFrame(unsigned char *outBuf, unsigned outBufSize, unsigned &resultFrameSize, unsigned &resultDurationInMicroseconds) {
+    /* We assume that "findNextHeader()" has already been called */
+
+    resultFrameSize = 4 + fr().frameSize;
+
+    if(outBufSize < resultFrameSize) {
+#ifdef DEBUG_ERRORS
+        fprintf(stderr, "Insufficient buffer size for reading input frame (%d, need %d)\n", outBufSize, resultFrameSize);
+#endif
+        if(outBufSize < 4)
+            outBufSize = 0;
+        resultFrameSize = outBufSize;
+
+        return False;
+    }
+
+    if(resultFrameSize >= 4) {
+        unsigned &hdr = fr().hdr;
+        *outBuf++     = (unsigned char)(hdr >> 24);
+        *outBuf++     = (unsigned char)(hdr >> 16);
+        *outBuf++     = (unsigned char)(hdr >> 8);
+        *outBuf++     = (unsigned char)(hdr);
+
+        memmove(outBuf, fr().frameBytes, resultFrameSize - 4);
+    }
+
+    struct timeval const pt      = currentFramePlayTime();
+    resultDurationInMicroseconds = pt.tv_sec * MILLION + pt.tv_usec;
+
+    return True;
+}
+
+void MP3StreamState::getAttributes(char *buffer, unsigned bufferSize) const {
+    char const *formatStr = "bandwidth %d MPEGnumber %d MPEGlayer %d samplingFrequency %d isStereo %d playTime %d isVBR %d";
+    unsigned    fpt       = (unsigned)(filePlayTime() + 0.5);  // rounds to nearest integer
+#if defined(IRIX) || defined(ALPHA) || defined(_QNX4) || defined(IMN_PIM) || defined(CRIS)
+    /* snprintf() isn't defined, so just use sprintf() - ugh! */
+    sprintf(buffer, formatStr, fr().bitrate, fr().isMPEG2 ? 2 : 1, fr().layer, fr().samplingFreq, fr().isStereo, fpt, fIsVBR);
+#else
+    snprintf(buffer, bufferSize, formatStr, fr().bitrate, fr().isMPEG2 ? 2 : 1, fr().layer, fr().samplingFreq, fr().isStereo, fpt, fIsVBR);
+#endif
+}
+
+// This is crufty old code that needs to be cleaned up #####
+#define HDRCMPMASK 0xfffffd00
+
+Boolean MP3StreamState::findNextFrame() {
+    unsigned char hbuf[8];
+    unsigned      l;
+    int           i;
+    int           attempt = 0;
+
+read_again:
+    if(readFromStream(hbuf, 4) != 4)
+        return False;
+
+    fr().hdr = ((unsigned long)hbuf[0] << 24) | ((unsigned long)hbuf[1] << 16) | ((unsigned long)hbuf[2] << 8) | (unsigned long)hbuf[3];
+
+#ifdef DEBUG_PARSE
+    fprintf(stderr, "fr().hdr: 0x%08x\n", fr().hdr);
+#endif
+    if(fr().oldHdr != fr().hdr || !fr().oldHdr) {
+        i = 0;
+    init_resync:
+#ifdef DEBUG_PARSE
+        fprintf(stderr, "init_resync: fr().hdr: 0x%08x\n", fr().hdr);
+#endif
+        if((fr().hdr & 0xffe00000) != 0xffe00000 || (fr().hdr & 0x00060000) == 0  // undefined 'layer' field
+           || (fr().hdr & 0x0000F000) == 0                                        // 'free format' bitrate index
+           || (fr().hdr & 0x0000F000) == 0x0000F000                               // undefined bitrate index
+           || (fr().hdr & 0x00000C00) == 0x00000C00                               // undefined frequency index
+           || (fr().hdr & 0x00000003) != 0x00000000                               // 'emphasis' field unexpectedly set
+        ) {
+            /* RSF: Do the following test even if we're not at the
+           start of the file, in case we have two or more
+           separate MP3 files cat'ed together:
+            */
+            /* Check for RIFF hdr */
+            if(fr().hdr == ('R' << 24) + ('I' << 16) + ('F' << 8) + 'F') {
+                unsigned char buf[70 /*was: 40*/];
+#ifdef DEBUG_ERRORS
+                fprintf(stderr, "Skipped RIFF header\n");
+#endif
+                readFromStream(buf, 66); /* already read 4 */
+                goto read_again;
+            }
+            /* Check for ID3 hdr */
+            if((fr().hdr & 0xFFFFFF00) == ('I' << 24) + ('D' << 16) + ('3' << 8)) {
+                unsigned      tagSize, bytesToSkip;
+                unsigned char buf[1000];
+                readFromStream(buf, 6); /* already read 4 */
+                tagSize     = ((buf[2] & 0x7F) << 21) + ((buf[3] & 0x7F) << 14) + ((buf[4] & 0x7F) << 7) + (buf[5] & 0x7F);
+                bytesToSkip = tagSize;
+                while(bytesToSkip > 0) {
+                    unsigned bytesToRead = sizeof buf;
+                    if(bytesToRead > bytesToSkip) {
+                        bytesToRead = bytesToSkip;
+                    }
+                    readFromStream(buf, bytesToRead);
+                    bytesToSkip -= bytesToRead;
+                }
+#ifdef DEBUG_ERRORS
+                fprintf(stderr, "Skipped %d-byte ID3 header\n", tagSize);
+#endif
+                goto read_again;
+            }
+            /* give up after 20,000 bytes */
+            if(i++ < 20000 /*4096*/ /*1024*/) {
+                memmove(&hbuf[0], &hbuf[1], 3);
+                if(readFromStream(hbuf + 3, 1) != 1) {
+                    return False;
+                }
+                fr().hdr <<= 8;
+                fr().hdr |= hbuf[3];
+                fr().hdr &= 0xffffffff;
+#ifdef DEBUG_PARSE
+                fprintf(stderr, "calling init_resync %d\n", i);
+#endif
+                goto init_resync;
+            }
+#ifdef DEBUG_ERRORS
+            fprintf(stderr, "Giving up searching valid MPEG header\n");
+#endif
+            return False;
+
+#ifdef DEBUG_ERRORS
+            fprintf(stderr, "Illegal Audio-MPEG-Header 0x%08lx at offset 0x%lx.\n", fr().hdr, tell_stream(str) - 4);
+#endif
+            /* Read more bytes until we find something that looks
+           reasonably like a valid header.  This is not a
+           perfect strategy, but it should get us back on the
+           track within a short time (and hopefully without
+           too much distortion in the audio output).  */
+            do {
+                attempt++;
+                memmove(&hbuf[0], &hbuf[1], 7);
+                if(readFromStream(&hbuf[3], 1) != 1) {
+                    return False;
+                }
+
+                /* This is faster than combining fr().hdr from scratch */
+                fr().hdr = ((fr().hdr << 8) | hbuf[3]) & 0xffffffff;
+
+                if(!fr().oldHdr)
+                    goto init_resync; /* "considered harmful", eh? */
+
+            } while((fr().hdr & HDRCMPMASK) != (fr().oldHdr & HDRCMPMASK) && (fr().hdr & HDRCMPMASK) != (fr().firstHdr & HDRCMPMASK));
+#ifdef DEBUG_ERRORS
+            fprintf(stderr, "Skipped %d bytes in input.\n", attempt);
+#endif
+        }
+        if(!fr().firstHdr) {
+            fr().firstHdr = fr().hdr;
+        }
+
+        fr().setParamsFromHeader();
+        fr().setBytePointer(fr().frameBytes, fr().frameSize);
+
+        fr().oldHdr = fr().hdr;
+
+        if(fr().isFreeFormat) {
+#ifdef DEBUG_ERRORS
+            fprintf(stderr, "Free format not supported.\n");
+#endif
+            return False;
+        }
+
+#ifdef MP3_ONLY
+        if(fr().layer != 3) {
+#ifdef DEBUG_ERRORS
+            fprintf(stderr, "MPEG layer %d is not supported!\n", fr().layer);
+#endif
+            return False;
+        }
+#endif
+    }
+
+    if((l = readFromStream(fr().frameBytes, fr().frameSize)) != fr().frameSize) {
+        if(l == 0)
+            return False;
+        memset(fr().frameBytes + 1, 0, fr().frameSize - 1);
+    }
+
+    return True;
+}
+
+unsigned MP3StreamState::readFromStream(unsigned char *buf, unsigned numChars) {
+    return fread(buf, 1, numChars, fFid);
+}
+
+#define XING_FRAMES_FLAG 0x0001
+#define XING_BYTES_FLAG 0x0002
+#define XING_TOC_FLAG 0x0004
+#define XING_VBR_SCALE_FLAG 0x0008
+
+void MP3StreamState::checkForXingHeader() {
+    // Look for 'Xing' in the first 4 bytes after the 'side info':
+    if(fr().frameSize < fr().sideInfoSize)
+        return;
+    unsigned       bytesAvailable = fr().frameSize - fr().sideInfoSize;
+    unsigned char *p              = &(fr().frameBytes[fr().sideInfoSize]);
+
+    if(bytesAvailable < 8)
+        return;
+    if(p[0] != 'X' || p[1] != 'i' || p[2] != 'n' || p[3] != 'g')
+        return;
+
+    // We found it.
+    fIsVBR = True;
+
+    u_int32_t flags = (p[4] << 24) | (p[5] << 16) | (p[6] << 8) | p[7];
+    unsigned  i     = 8;
+    bytesAvailable -= 8;
+
+    if(flags & XING_FRAMES_FLAG) {
+        // The next 4 bytes are the number of frames:
+        if(bytesAvailable < 4)
+            return;
+        fNumFramesInFile = (p[i] << 24) | (p[i + 1] << 16) | (p[i + 2] << 8) | (p[i + 3]);
+        i += 4;
+        bytesAvailable -= 4;
+    }
+
+    if(flags & XING_BYTES_FLAG) {
+        // The next 4 bytes is the file size:
+        if(bytesAvailable < 4)
+            return;
+        fFileSize = (p[i] << 24) | (p[i + 1] << 16) | (p[i + 2] << 8) | (p[i + 3]);
+        i += 4;
+        bytesAvailable -= 4;
+    }
+
+    if(flags & XING_TOC_FLAG) {
+        // Fill in the Xing 'table of contents':
+        if(bytesAvailable < XING_TOC_LENGTH)
+            return;
+        fHasXingTOC = True;
+        for(unsigned j = 0; j < XING_TOC_LENGTH; ++j) {
+            fXingTOC[j] = p[i + j];
+        }
+        i += XING_TOC_FLAG;
+        bytesAvailable -= XING_TOC_FLAG;
+    }
+}
diff --git a/3rdparty/live555/src/liveMedia/MP3StreamState.hh b/3rdparty/live555/src/liveMedia/MP3StreamState.hh
new file mode 100644
index 00000000..a94563e8
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/MP3StreamState.hh
@@ -0,0 +1,89 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A class encapsulating the state of a MP3 stream
+// C++ header
+
+#ifndef _MP3_STREAM_STATE_HH
+#define _MP3_STREAM_STATE_HH
+
+#ifndef _USAGE_ENVIRONMENT_HH
+#include "UsageEnvironment.hh"
+#endif
+#ifndef _BOOLEAN_HH
+#include "Boolean.hh"
+#endif
+#ifndef _MP3_INTERNALS_HH
+#include "MP3Internals.hh"
+#endif
+#ifndef _NET_COMMON_H
+#include "NetCommon.h"
+#endif
+
+#include <stdio.h>
+
+#define XING_TOC_LENGTH 100
+
+class MP3StreamState {
+public:
+  MP3StreamState();
+  virtual ~MP3StreamState();
+
+  void assignStream(FILE* fid, unsigned fileSize);
+
+  unsigned findNextHeader(struct timeval& presentationTime);
+  Boolean readFrame(unsigned char* outBuf, unsigned outBufSize,
+		    unsigned& resultFrameSize,
+		    unsigned& resultDurationInMicroseconds);
+      // called after findNextHeader()
+
+  void getAttributes(char* buffer, unsigned bufferSize) const;
+
+  float filePlayTime() const; // in seconds
+  unsigned fileSize() const { return fFileSize; }
+  void setPresentationTimeScale(unsigned scale) { fPresentationTimeScale = scale; }
+  unsigned getByteNumberFromPositionFraction(float fraction); // 0.0 <= fraction <= 1.0
+  void seekWithinFile(unsigned seekByteNumber);
+
+  void checkForXingHeader(); // hack for Xing VBR files
+
+protected: // private->protected requested by Pierre l'Hussiez
+  unsigned readFromStream(unsigned char* buf, unsigned numChars);
+
+private:
+  MP3FrameParams& fr() {return fCurrentFrame;}
+  MP3FrameParams const& fr() const {return fCurrentFrame;}
+
+  struct timeval currentFramePlayTime() const;
+
+  Boolean findNextFrame();
+
+private:
+  FILE* fFid;
+  Boolean fFidIsReallyASocket;
+  unsigned fFileSize;
+  unsigned fNumFramesInFile;
+  unsigned fPresentationTimeScale;
+    // used if we're streaming at other than the normal rate
+  Boolean fIsVBR, fHasXingTOC;
+  u_int8_t fXingTOC[XING_TOC_LENGTH]; // set iff "fHasXingTOC" is True
+
+  MP3FrameParams fCurrentFrame;
+  struct timeval fNextFramePresentationTime;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/MP3Transcoder.cpp b/3rdparty/live555/src/liveMedia/MP3Transcoder.cpp
new file mode 100644
index 00000000..b2e49b5f
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/MP3Transcoder.cpp
@@ -0,0 +1,46 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// MP3 Transcoder
+// Implementation
+
+#include "MP3Transcoder.hh"
+
+MP3Transcoder::MP3Transcoder(UsageEnvironment &env, MP3ADUTranscoder *aduTranscoder) : MP3FromADUSource(env, aduTranscoder, False) {}
+
+MP3Transcoder::~MP3Transcoder() {}
+
+MP3Transcoder *MP3Transcoder::createNew(UsageEnvironment &env, unsigned outBitrate /* in kbps */, FramedSource *inputSource) {
+    MP3Transcoder *newSource = NULL;
+
+    do {
+        // Create the intermediate filters that help implement the transcoder:
+        ADUFromMP3Source *aduFromMP3 = ADUFromMP3Source::createNew(env, inputSource, False);
+        // Note: This also checks that "inputSource" is an MP3 source
+        if(aduFromMP3 == NULL)
+            break;
+
+        MP3ADUTranscoder *aduTranscoder = MP3ADUTranscoder::createNew(env, outBitrate, aduFromMP3);
+        if(aduTranscoder == NULL)
+            break;
+
+        // Then create the transcoder itself:
+        newSource = new MP3Transcoder(env, aduTranscoder);
+    } while(0);
+
+    return newSource;
+}
diff --git a/3rdparty/live555/src/liveMedia/MPEG1or2AudioRTPSink.cpp b/3rdparty/live555/src/liveMedia/MPEG1or2AudioRTPSink.cpp
new file mode 100644
index 00000000..70efe61e
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/MPEG1or2AudioRTPSink.cpp
@@ -0,0 +1,53 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// RTP sink for MPEG audio (RFC 2250)
+// Implementation
+
+#include "MPEG1or2AudioRTPSink.hh"
+
+MPEG1or2AudioRTPSink::MPEG1or2AudioRTPSink(UsageEnvironment &env, Groupsock *RTPgs) : AudioRTPSink(env, RTPgs, 14, 90000, "MPA") {}
+
+MPEG1or2AudioRTPSink::~MPEG1or2AudioRTPSink() {}
+
+MPEG1or2AudioRTPSink *MPEG1or2AudioRTPSink::createNew(UsageEnvironment &env, Groupsock *RTPgs) {
+    return new MPEG1or2AudioRTPSink(env, RTPgs);
+}
+
+void MPEG1or2AudioRTPSink::doSpecialFrameHandling(unsigned fragmentationOffset, unsigned char *frameStart, unsigned numBytesInFrame,
+                                                  struct timeval framePresentationTime, unsigned numRemainingBytes) {
+    // If this is the 1st frame in the 1st packet, set the RTP 'M' (marker)
+    // bit (because this is considered the start of a talk spurt):
+    if(isFirstPacket() && isFirstFrameInPacket()) {
+        setMarkerBit();
+    }
+
+    // If this is the first frame in the packet, set the lower half of the
+    // audio-specific header (to the "fragmentationOffset"):
+    if(isFirstFrameInPacket()) {
+        setSpecialHeaderWord(fragmentationOffset & 0xFFFF);
+    }
+
+    // Important: Also call our base class's doSpecialFrameHandling(),
+    // to set the packet's timestamp:
+    MultiFramedRTPSink::doSpecialFrameHandling(fragmentationOffset, frameStart, numBytesInFrame, framePresentationTime, numRemainingBytes);
+}
+
+unsigned MPEG1or2AudioRTPSink::specialHeaderSize() const {
+    // There's a 4 byte special audio header:
+    return 4;
+}
diff --git a/3rdparty/live555/src/liveMedia/MPEG1or2AudioRTPSource.cpp b/3rdparty/live555/src/liveMedia/MPEG1or2AudioRTPSource.cpp
new file mode 100644
index 00000000..17b7457c
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/MPEG1or2AudioRTPSource.cpp
@@ -0,0 +1,50 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// MPEG-1 or MPEG-2 Audio RTP Sources
+// Implementation
+
+#include "MPEG1or2AudioRTPSource.hh"
+
+MPEG1or2AudioRTPSource *MPEG1or2AudioRTPSource::createNew(UsageEnvironment &env, Groupsock *RTPgs, unsigned char rtpPayloadFormat,
+                                                          unsigned rtpTimestampFrequency) {
+    return new MPEG1or2AudioRTPSource(env, RTPgs, rtpPayloadFormat, rtpTimestampFrequency);
+}
+
+MPEG1or2AudioRTPSource::MPEG1or2AudioRTPSource(UsageEnvironment &env, Groupsock *rtpGS, unsigned char rtpPayloadFormat, unsigned rtpTimestampFrequency)
+    : MultiFramedRTPSource(env, rtpGS, rtpPayloadFormat, rtpTimestampFrequency) {}
+
+MPEG1or2AudioRTPSource::~MPEG1or2AudioRTPSource() {}
+
+Boolean MPEG1or2AudioRTPSource ::processSpecialHeader(BufferedPacket *packet, unsigned &resultSpecialHeaderSize) {
+    // There's a 4-byte header indicating fragmentation.
+    if(packet->dataSize() < 4)
+        return False;
+
+    // Note: This fragmentation header is actually useless to us, because
+    // it doesn't tell us whether or not this RTP packet *ends* a
+    // fragmented frame.  Thus, we can't use it to properly set
+    // "fCurrentPacketCompletesFrame".  Instead, we assume that even
+    // a partial audio frame will be usable to clients.
+
+    resultSpecialHeaderSize = 4;
+    return True;
+}
+
+char const *MPEG1or2AudioRTPSource::MIMEtype() const {
+    return "audio/MPEG";
+}
diff --git a/3rdparty/live555/src/liveMedia/MPEG1or2AudioStreamFramer.cpp b/3rdparty/live555/src/liveMedia/MPEG1or2AudioStreamFramer.cpp
new file mode 100644
index 00000000..a07b4d11
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/MPEG1or2AudioStreamFramer.cpp
@@ -0,0 +1,194 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A filter that breaks up an MPEG (1,2) audio elementary stream into frames
+// Implementation
+
+#include "MPEG1or2AudioStreamFramer.hh"
+#include "StreamParser.hh"
+#include "MP3Internals.hh"
+#include <GroupsockHelper.hh>
+
+////////// MPEG1or2AudioStreamParser definition //////////
+
+class MPEG1or2AudioStreamParser : public StreamParser {
+public:
+    MPEG1or2AudioStreamParser(MPEG1or2AudioStreamFramer *usingSource, FramedSource *inputSource);
+    virtual ~MPEG1or2AudioStreamParser();
+
+public:
+    unsigned parse(unsigned &numTruncatedBytes);
+    // returns the size of the frame that was acquired, or 0 if none was
+
+    void registerReadInterest(unsigned char *to, unsigned maxSize);
+
+    MP3FrameParams const &currentFrame() const {
+        return fCurrentFrame;
+    }
+
+private:
+    unsigned char *fTo;
+    unsigned       fMaxSize;
+
+    // Parameters of the most recently read frame:
+    MP3FrameParams fCurrentFrame;  // also works for layer I or II
+};
+
+////////// MPEG1or2AudioStreamFramer implementation //////////
+
+MPEG1or2AudioStreamFramer ::MPEG1or2AudioStreamFramer(UsageEnvironment &env, FramedSource *inputSource, Boolean syncWithInputSource)
+    : FramedFilter(env, inputSource), fSyncWithInputSource(syncWithInputSource) {
+    reset();
+
+    fParser = new MPEG1or2AudioStreamParser(this, inputSource);
+}
+
+MPEG1or2AudioStreamFramer::~MPEG1or2AudioStreamFramer() {
+    delete fParser;
+}
+
+MPEG1or2AudioStreamFramer *MPEG1or2AudioStreamFramer::createNew(UsageEnvironment &env, FramedSource *inputSource, Boolean syncWithInputSource) {
+    // Need to add source type checking here???  #####
+    return new MPEG1or2AudioStreamFramer(env, inputSource, syncWithInputSource);
+}
+
+void MPEG1or2AudioStreamFramer::flushInput() {
+    reset();
+    fParser->flushInput();
+}
+
+void MPEG1or2AudioStreamFramer::reset() {
+    // Use the current wallclock time as the initial 'presentation time':
+    struct timeval timeNow;
+    gettimeofday(&timeNow, NULL);
+    resetPresentationTime(timeNow);
+}
+
+void MPEG1or2AudioStreamFramer ::resetPresentationTime(struct timeval newPresentationTime) {
+    fNextFramePresentationTime = newPresentationTime;
+}
+
+void MPEG1or2AudioStreamFramer::doGetNextFrame() {
+    fParser->registerReadInterest(fTo, fMaxSize);
+    continueReadProcessing();
+}
+
+#define MILLION 1000000
+
+static unsigned const numSamplesByLayer[4] = { 0, 384, 1152, 1152 };
+
+struct timeval MPEG1or2AudioStreamFramer::currentFramePlayTime() const {
+    MP3FrameParams const &fr         = fParser->currentFrame();
+    unsigned const        numSamples = numSamplesByLayer[fr.layer];
+
+    struct timeval result;
+    unsigned const freq = fr.samplingFreq * (1 + fr.isMPEG2);
+    if(freq == 0) {
+        result.tv_sec  = 0;
+        result.tv_usec = 0;
+        return result;
+    }
+
+    // result is numSamples/freq
+    unsigned const uSeconds = ((numSamples * 2 * MILLION) / freq + 1) / 2;  // rounds to nearest integer
+
+    result.tv_sec  = uSeconds / MILLION;
+    result.tv_usec = uSeconds % MILLION;
+    return result;
+}
+
+void MPEG1or2AudioStreamFramer ::continueReadProcessing(void *clientData, unsigned char * /*ptr*/, unsigned /*size*/, struct timeval presentationTime) {
+    MPEG1or2AudioStreamFramer *framer = (MPEG1or2AudioStreamFramer *)clientData;
+    if(framer->fSyncWithInputSource) {
+        framer->resetPresentationTime(presentationTime);
+    }
+    framer->continueReadProcessing();
+}
+
+void MPEG1or2AudioStreamFramer::continueReadProcessing() {
+    unsigned acquiredFrameSize = fParser->parse(fNumTruncatedBytes);
+    if(acquiredFrameSize > 0) {
+        // We were able to acquire a frame from the input.
+        // It has already been copied to the reader's space.
+        fFrameSize = acquiredFrameSize;
+
+        // Also set the presentation time, and increment it for next time,
+        // based on the length of this frame:
+        fPresentationTime            = fNextFramePresentationTime;
+        struct timeval framePlayTime = currentFramePlayTime();
+        fDurationInMicroseconds      = framePlayTime.tv_sec * MILLION + framePlayTime.tv_usec;
+        fNextFramePresentationTime.tv_usec += framePlayTime.tv_usec;
+        fNextFramePresentationTime.tv_sec += framePlayTime.tv_sec + fNextFramePresentationTime.tv_usec / MILLION;
+        fNextFramePresentationTime.tv_usec %= MILLION;
+
+        // Call our own 'after getting' function.  Because we're not a 'leaf'
+        // source, we can call this directly, without risking infinite recursion.
+        afterGetting(this);
+    }
+    else {
+        // We were unable to parse a complete frame from the input, because:
+        // - we had to read more data from the source stream, or
+        // - the source stream has ended.
+    }
+}
+
+////////// MPEG1or2AudioStreamParser implementation //////////
+
+MPEG1or2AudioStreamParser ::MPEG1or2AudioStreamParser(MPEG1or2AudioStreamFramer *usingSource, FramedSource *inputSource)
+    : StreamParser(inputSource, FramedSource::handleClosure, usingSource, &MPEG1or2AudioStreamFramer::continueReadProcessing, usingSource) {}
+
+MPEG1or2AudioStreamParser::~MPEG1or2AudioStreamParser() {}
+
+void MPEG1or2AudioStreamParser::registerReadInterest(unsigned char *to, unsigned maxSize) {
+    fTo      = to;
+    fMaxSize = maxSize;
+}
+
+unsigned MPEG1or2AudioStreamParser::parse(unsigned &numTruncatedBytes) {
+    try {
+        saveParserState();
+
+        // We expect a MPEG audio header (first 11 bits set to 1) at the start:
+        while(((fCurrentFrame.hdr = test4Bytes()) & 0xFFE00000) != 0xFFE00000) {
+            skipBytes(1);
+            saveParserState();
+        }
+
+        fCurrentFrame.setParamsFromHeader();
+
+        // Copy the frame to the requested destination:
+        unsigned frameSize = fCurrentFrame.frameSize + 4;  // include header
+        if(frameSize > fMaxSize) {
+            numTruncatedBytes = frameSize - fMaxSize;
+            frameSize         = fMaxSize;
+        }
+        else {
+            numTruncatedBytes = 0;
+        }
+
+        getBytes(fTo, frameSize);
+        skipBytes(numTruncatedBytes);
+
+        return frameSize;
+    }
+    catch(int /*e*/) {
+#ifdef DEBUG
+        fprintf(stderr, "MPEG1or2AudioStreamParser::parse() EXCEPTION (This is normal behavior - *not* an error)\n");
+#endif
+        return 0;  // the parsing got interrupted
+    }
+}
diff --git a/3rdparty/live555/src/liveMedia/MPEG1or2Demux.cpp b/3rdparty/live555/src/liveMedia/MPEG1or2Demux.cpp
new file mode 100644
index 00000000..981ea32e
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/MPEG1or2Demux.cpp
@@ -0,0 +1,761 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// Demultiplexer for a MPEG 1 or 2 Program Stream
+// Implementation
+
+#include "MPEG1or2Demux.hh"
+#include "MPEG1or2DemuxedElementaryStream.hh"
+#include "StreamParser.hh"
+#include <stdlib.h>
+
+////////// MPEGProgramStreamParser definition //////////
+
+// An enum representing the current state of the parser:
+enum MPEGParseState { PARSING_PACK_HEADER, PARSING_SYSTEM_HEADER, PARSING_PES_PACKET };
+
+class MPEGProgramStreamParser : public StreamParser {
+public:
+    MPEGProgramStreamParser(MPEG1or2Demux *usingDemux, FramedSource *inputSource);
+    virtual ~MPEGProgramStreamParser();
+
+public:
+    unsigned char parse();
+    // returns the stream id of a stream for which a frame was acquired,
+    // or 0 if no such frame was acquired.
+
+private:
+    void setParseState(MPEGParseState parseState);
+
+    void          parsePackHeader();
+    void          parseSystemHeader();
+    unsigned char parsePESPacket();  // returns as does parse()
+
+    Boolean isSpecialStreamId(unsigned char stream_id) const;
+    // for PES packet header parsing
+
+private:
+    MPEG1or2Demux *fUsingDemux;
+    MPEGParseState fCurrentParseState;
+};
+
+////////// MPEG1or2Demux::OutputDescriptor::SavedData definition/implementation //////////
+
+class MPEG1or2Demux::OutputDescriptor::SavedData {
+public:
+    SavedData(unsigned char *buf, unsigned size) : next(NULL), data(buf), dataSize(size), numBytesUsed(0) {}
+    virtual ~SavedData() {
+        delete[] data;
+        delete next;
+    }
+
+    SavedData *    next;
+    unsigned char *data;
+    unsigned       dataSize, numBytesUsed;
+};
+
+////////// MPEG1or2Demux implementation //////////
+
+MPEG1or2Demux ::MPEG1or2Demux(UsageEnvironment &env, FramedSource *inputSource, Boolean reclaimWhenLastESDies, MPEG1or2DemuxOnDeletionFunc *onDeletionFunc,
+                              void *objectToNotify)
+    : Medium(env),
+      fInputSource(inputSource),
+      fMPEGversion(0),
+      fNextAudioStreamNumber(0),
+      fNextVideoStreamNumber(0),
+      fReclaimWhenLastESDies(reclaimWhenLastESDies),
+      fNumOutstandingESs(0),
+      fNumPendingReads(0),
+      fHaveUndeliveredData(False),
+      fOnDeletionFunc(onDeletionFunc),
+      fOnDeletionObjectToNotify(objectToNotify) {
+    fParser = new MPEGProgramStreamParser(this, inputSource);
+    for(unsigned i = 0; i < 256; ++i) {
+        fOutput[i].savedDataHead = fOutput[i].savedDataTail = NULL;
+        fOutput[i].isPotentiallyReadable                    = False;
+        fOutput[i].isCurrentlyActive                        = False;
+        fOutput[i].isCurrentlyAwaitingData                  = False;
+    }
+}
+
+MPEG1or2Demux::~MPEG1or2Demux() {
+    if(fOnDeletionFunc != NULL) {
+        (*fOnDeletionFunc)(fOnDeletionObjectToNotify, this);
+    }
+
+    delete fParser;
+    for(unsigned i = 0; i < 256; ++i)
+        delete fOutput[i].savedDataHead;
+    Medium::close(fInputSource);
+}
+
+MPEG1or2Demux *MPEG1or2Demux ::createNew(UsageEnvironment &env, FramedSource *inputSource, Boolean reclaimWhenLastESDies,
+                                         MPEG1or2DemuxOnDeletionFunc *onDeletionFunc, void *objectToNotify) {
+    // Need to add source type checking here???  #####
+
+    return new MPEG1or2Demux(env, inputSource, reclaimWhenLastESDies, onDeletionFunc, objectToNotify);
+}
+
+MPEG1or2Demux::SCR::SCR() : highBit(0), remainingBits(0), extension(0), isValid(False) {}
+
+void MPEG1or2Demux ::noteElementaryStreamDeletion(MPEG1or2DemuxedElementaryStream * /*es*/) {
+    if(--fNumOutstandingESs == 0 && fReclaimWhenLastESDies) {
+        Medium::close(this);
+    }
+}
+
+void MPEG1or2Demux::flushInput() {
+    fParser->flushInput();
+}
+
+MPEG1or2DemuxedElementaryStream *MPEG1or2Demux::newElementaryStream(u_int8_t streamIdTag) {
+    ++fNumOutstandingESs;
+    fOutput[streamIdTag].isPotentiallyReadable = True;
+    return new MPEG1or2DemuxedElementaryStream(envir(), streamIdTag, *this);
+}
+
+MPEG1or2DemuxedElementaryStream *MPEG1or2Demux::newAudioStream() {
+    unsigned char newAudioStreamTag = 0xC0 | (fNextAudioStreamNumber++ & ~0xE0);
+    // MPEG audio stream tags are 110x xxxx (binary)
+    return newElementaryStream(newAudioStreamTag);
+}
+
+MPEG1or2DemuxedElementaryStream *MPEG1or2Demux::newVideoStream() {
+    unsigned char newVideoStreamTag = 0xE0 | (fNextVideoStreamNumber++ & ~0xF0);
+    // MPEG video stream tags are 1110 xxxx (binary)
+    return newElementaryStream(newVideoStreamTag);
+}
+
+// Appropriate one of the reserved stream id tags to mean: return raw PES packets:
+#define RAW_PES 0xFC
+
+MPEG1or2DemuxedElementaryStream *MPEG1or2Demux::newRawPESStream() {
+    return newElementaryStream(RAW_PES);
+}
+
+void MPEG1or2Demux::registerReadInterest(u_int8_t streamIdTag, unsigned char *to, unsigned maxSize, FramedSource::afterGettingFunc *afterGettingFunc,
+                                         void *afterGettingClientData, FramedSource::onCloseFunc *onCloseFunc, void *onCloseClientData) {
+    struct OutputDescriptor &out = fOutput[streamIdTag];
+
+    // Make sure this stream is not already being read:
+    if(out.isCurrentlyAwaitingData) {
+        envir() << "MPEG1or2Demux::registerReadInterest(): attempt to read stream more than once!\n";
+        envir().internalError();
+    }
+
+    out.to                      = to;
+    out.maxSize                 = maxSize;
+    out.fAfterGettingFunc       = afterGettingFunc;
+    out.afterGettingClientData  = afterGettingClientData;
+    out.fOnCloseFunc            = onCloseFunc;
+    out.onCloseClientData       = onCloseClientData;
+    out.isCurrentlyActive       = True;
+    out.isCurrentlyAwaitingData = True;
+    // out.frameSize and out.presentationTime will be set when a frame's read
+
+    ++fNumPendingReads;
+}
+
+Boolean MPEG1or2Demux::useSavedData(u_int8_t streamIdTag, unsigned char *to, unsigned maxSize, FramedSource::afterGettingFunc *afterGettingFunc,
+                                    void *afterGettingClientData) {
+    struct OutputDescriptor &out = fOutput[streamIdTag];
+    if(out.savedDataHead == NULL)
+        return False;  // common case
+
+    unsigned totNumBytesCopied = 0;
+    while(maxSize > 0 && out.savedDataHead != NULL) {
+        OutputDescriptor::SavedData &savedData      = *(out.savedDataHead);
+        unsigned char *              from           = &savedData.data[savedData.numBytesUsed];
+        unsigned                     numBytesToCopy = savedData.dataSize - savedData.numBytesUsed;
+        if(numBytesToCopy > maxSize)
+            numBytesToCopy = maxSize;
+        memmove(to, from, numBytesToCopy);
+        to += numBytesToCopy;
+        maxSize -= numBytesToCopy;
+        out.savedDataTotalSize -= numBytesToCopy;
+        totNumBytesCopied += numBytesToCopy;
+        savedData.numBytesUsed += numBytesToCopy;
+        if(savedData.numBytesUsed == savedData.dataSize) {
+            out.savedDataHead = savedData.next;
+            if(out.savedDataHead == NULL)
+                out.savedDataTail = NULL;
+            savedData.next = NULL;
+            delete &savedData;
+        }
+    }
+
+    out.isCurrentlyActive = True;
+    if(afterGettingFunc != NULL) {
+        struct timeval presentationTime;
+        presentationTime.tv_sec  = 0;
+        presentationTime.tv_usec = 0;  // should fix #####
+        (*afterGettingFunc)(afterGettingClientData, totNumBytesCopied, 0 /* numTruncatedBytes */, presentationTime, 0 /* durationInMicroseconds ?????#####*/);
+    }
+    return True;
+}
+
+void MPEG1or2Demux ::continueReadProcessing(void *clientData, unsigned char * /*ptr*/, unsigned /*size*/, struct timeval /*presentationTime*/) {
+    MPEG1or2Demux *demux = (MPEG1or2Demux *)clientData;
+    demux->continueReadProcessing();
+}
+
+void MPEG1or2Demux::continueReadProcessing() {
+    while(fNumPendingReads > 0) {
+        unsigned char acquiredStreamIdTag = fParser->parse();
+
+        if(acquiredStreamIdTag != 0) {
+            // We were able to acquire a frame from the input.
+            struct OutputDescriptor &newOut = fOutput[acquiredStreamIdTag];
+            newOut.isCurrentlyAwaitingData  = False;
+            // indicates that we can be read again
+            // (This needs to be set before the 'after getting' call below,
+            //  in case it tries to read another frame)
+
+            // Call our own 'after getting' function.  Because we're not a 'leaf'
+            // source, we can call this directly, without risking infinite recursion.
+            if(newOut.fAfterGettingFunc != NULL) {
+                (*newOut.fAfterGettingFunc)(newOut.afterGettingClientData, newOut.frameSize, 0 /* numTruncatedBytes */, newOut.presentationTime,
+                                            0 /* durationInMicroseconds ?????#####*/);
+                --fNumPendingReads;
+            }
+        }
+        else {
+            // We were unable to parse a complete frame from the input, because:
+            // - we had to read more data from the source stream, or
+            // - we found a frame for a stream that was being read, but whose
+            //   reader is not ready to get the frame right now, or
+            // - the source stream has ended.
+            break;
+        }
+    }
+}
+
+void MPEG1or2Demux::getNextFrame(u_int8_t streamIdTag, unsigned char *to, unsigned maxSize, FramedSource::afterGettingFunc *afterGettingFunc,
+                                 void *afterGettingClientData, FramedSource::onCloseFunc *onCloseFunc, void *onCloseClientData) {
+    // First, check whether we have saved data for this stream id:
+    if(useSavedData(streamIdTag, to, maxSize, afterGettingFunc, afterGettingClientData)) {
+        return;
+    }
+
+    // Then save the parameters of the specified stream id:
+    registerReadInterest(streamIdTag, to, maxSize, afterGettingFunc, afterGettingClientData, onCloseFunc, onCloseClientData);
+
+    // Next, if we're the only currently pending read, continue looking for data:
+    if(fNumPendingReads == 1 || fHaveUndeliveredData) {
+        fHaveUndeliveredData = 0;
+        continueReadProcessing();
+    }  // otherwise the continued read processing has already been taken care of
+}
+
+void MPEG1or2Demux::stopGettingFrames(u_int8_t streamIdTag) {
+    struct OutputDescriptor &out = fOutput[streamIdTag];
+
+    if(out.isCurrentlyAwaitingData && fNumPendingReads > 0) {
+        --fNumPendingReads;
+        if(fNumPendingReads == 0 && fInputSource != NULL)
+            fInputSource->stopGettingFrames();
+    }
+
+    out.isCurrentlyActive = out.isCurrentlyAwaitingData = False;
+}
+
+void MPEG1or2Demux::handleClosure(void *clientData) {
+    MPEG1or2Demux *demux = (MPEG1or2Demux *)clientData;
+
+    demux->fNumPendingReads = 0;
+
+    // Tell all pending readers that our source has closed.
+    // Note that we need to make a copy of our readers' close functions
+    // (etc.) before we start calling any of them, in case one of them
+    // ends up deleting this.
+    struct {
+        FramedSource::onCloseFunc *fOnCloseFunc;
+        void *                     onCloseClientData;
+    } savedPending[256];
+    unsigned i, numPending = 0;
+    for(i = 0; i < 256; ++i) {
+        struct OutputDescriptor &out = demux->fOutput[i];
+        if(out.isCurrentlyAwaitingData) {
+            if(out.fOnCloseFunc != NULL) {
+                savedPending[numPending].fOnCloseFunc      = out.fOnCloseFunc;
+                savedPending[numPending].onCloseClientData = out.onCloseClientData;
+                ++numPending;
+            }
+        }
+        delete out.savedDataHead;
+        out.savedDataHead = out.savedDataTail = NULL;
+        out.savedDataTotalSize                = 0;
+        out.isPotentiallyReadable = out.isCurrentlyActive = out.isCurrentlyAwaitingData = False;
+    }
+    for(i = 0; i < numPending; ++i) {
+        (*savedPending[i].fOnCloseFunc)(savedPending[i].onCloseClientData);
+    }
+}
+
+////////// MPEGProgramStreamParser implementation //////////
+
+#include <string.h>
+
+MPEGProgramStreamParser::MPEGProgramStreamParser(MPEG1or2Demux *usingDemux, FramedSource *inputSource)
+    : StreamParser(inputSource, MPEG1or2Demux::handleClosure, usingDemux, &MPEG1or2Demux::continueReadProcessing, usingDemux),
+      fUsingDemux(usingDemux),
+      fCurrentParseState(PARSING_PACK_HEADER) {}
+
+MPEGProgramStreamParser::~MPEGProgramStreamParser() {}
+
+void MPEGProgramStreamParser::setParseState(MPEGParseState parseState) {
+    fCurrentParseState = parseState;
+    saveParserState();
+}
+
+unsigned char MPEGProgramStreamParser::parse() {
+    unsigned char acquiredStreamTagId = 0;
+
+    try {
+        do {
+            switch(fCurrentParseState) {
+            case PARSING_PACK_HEADER: {
+                parsePackHeader();
+                break;
+            }
+            case PARSING_SYSTEM_HEADER: {
+                parseSystemHeader();
+                break;
+            }
+            case PARSING_PES_PACKET: {
+                acquiredStreamTagId = parsePESPacket();
+                break;
+            }
+            }
+        } while(acquiredStreamTagId == 0);
+
+        return acquiredStreamTagId;
+    }
+    catch(int /*e*/) {
+#ifdef DEBUG
+        fprintf(stderr, "MPEGProgramStreamParser::parse() EXCEPTION (This is normal behavior - *not* an error)\n");
+        fflush(stderr);
+#endif
+        return 0;  // the parsing got interrupted
+    }
+}
+
+#define PACK_START_CODE 0x000001BA
+#define SYSTEM_HEADER_START_CODE 0x000001BB
+#define PACKET_START_CODE_PREFIX 0x00000100
+
+static inline Boolean isPacketStartCode(unsigned code) {
+    return (code & 0xFFFFFF00) == PACKET_START_CODE_PREFIX && code > SYSTEM_HEADER_START_CODE;
+}
+
+void MPEGProgramStreamParser::parsePackHeader() {
+#ifdef DEBUG
+    fprintf(stderr, "parsing pack header\n");
+    fflush(stderr);
+#endif
+    unsigned first4Bytes;
+    while(1) {
+        first4Bytes = test4Bytes();
+
+        // We're supposed to have a pack header here, but check also for
+        // a system header or a PES packet, just in case:
+        if(first4Bytes == PACK_START_CODE) {
+            skipBytes(4);
+            break;
+        }
+        else if(first4Bytes == SYSTEM_HEADER_START_CODE) {
+#ifdef DEBUG
+            fprintf(stderr, "found system header instead of pack header\n");
+#endif
+            setParseState(PARSING_SYSTEM_HEADER);
+            return;
+        }
+        else if(isPacketStartCode(first4Bytes)) {
+#ifdef DEBUG
+            fprintf(stderr, "found packet start code 0x%02x instead of pack header\n", first4Bytes);
+#endif
+            setParseState(PARSING_PES_PACKET);
+            return;
+        }
+
+        setParseState(PARSING_PACK_HEADER);  // ensures we progress over bad data
+        if((first4Bytes & 0xFF) > 1) {       // a system code definitely doesn't start here
+            skipBytes(4);
+        }
+        else {
+            skipBytes(1);
+        }
+    }
+
+    // The size of the pack header differs depending on whether it's
+    // MPEG-1 or MPEG-2.  The next byte tells us this:
+    unsigned char       nextByte = get1Byte();
+    MPEG1or2Demux::SCR &scr      = fUsingDemux->fLastSeenSCR;  // alias
+    if((nextByte & 0xF0) == 0x20) {                            // MPEG-1
+        fUsingDemux->fMPEGversion = 1;
+        scr.highBit               = (nextByte & 0x08) >> 3;
+        scr.remainingBits         = (nextByte & 0x06) << 29;
+        unsigned next4Bytes       = get4Bytes();
+        scr.remainingBits |= (next4Bytes & 0xFFFE0000) >> 2;
+        scr.remainingBits |= (next4Bytes & 0x0000FFFE) >> 1;
+        scr.extension = 0;
+        scr.isValid   = True;
+        skipBits(24);
+
+#if defined(DEBUG_TIMESTAMPS) || defined(DEBUG_SCR_TIMESTAMPS)
+        fprintf(stderr, "pack hdr system_clock_reference_base: 0x%x", scr.highBit);
+        fprintf(stderr, "%08x\n", scr.remainingBits);
+#endif
+    }
+    else if((nextByte & 0xC0) == 0x40) {  // MPEG-2
+        fUsingDemux->fMPEGversion = 2;
+        scr.highBit               = (nextByte & 0x20) >> 5;
+        scr.remainingBits         = (nextByte & 0x18) << 27;
+        scr.remainingBits |= (nextByte & 0x03) << 28;
+        unsigned next4Bytes = get4Bytes();
+        scr.remainingBits |= (next4Bytes & 0xFFF80000) >> 4;
+        scr.remainingBits |= (next4Bytes & 0x0003FFF8) >> 3;
+        scr.extension = (next4Bytes & 0x00000003) << 7;
+        next4Bytes    = get4Bytes();
+        scr.extension |= (next4Bytes & 0xFE000000) >> 25;
+        scr.isValid = True;
+        skipBits(5);
+
+#if defined(DEBUG_TIMESTAMPS) || defined(DEBUG_SCR_TIMESTAMPS)
+        fprintf(stderr, "pack hdr system_clock_reference_base: 0x%x", scr.highBit);
+        fprintf(stderr, "%08x\n", scr.remainingBits);
+        fprintf(stderr, "pack hdr system_clock_reference_extension: 0x%03x\n", scr.extension);
+#endif
+        unsigned char pack_stuffing_length = getBits(3);
+        skipBytes(pack_stuffing_length);
+    }
+    else {  // unknown
+        fUsingDemux->envir() << "StreamParser::parsePack() saw strange byte following pack_start_code\n";
+    }
+
+    // Check for a System Header next:
+    setParseState(PARSING_SYSTEM_HEADER);
+}
+
+void MPEGProgramStreamParser::parseSystemHeader() {
+#ifdef DEBUG
+    fprintf(stderr, "parsing system header\n");
+    fflush(stderr);
+#endif
+    unsigned next4Bytes = test4Bytes();
+    if(next4Bytes != SYSTEM_HEADER_START_CODE) {
+        // The system header was optional.  Look for a PES Packet instead:
+        setParseState(PARSING_PES_PACKET);
+        return;
+    }
+
+#ifdef DEBUG
+    fprintf(stderr, "saw system_header_start_code\n");
+    fflush(stderr);
+#endif
+    skipBytes(4);  // we've already seen the system_header_start_code
+
+    unsigned short remaining_header_length = get2Bytes();
+
+    // According to the MPEG-1 and MPEG-2 specs, "remaining_header_length" should be
+    // at least 6 bytes.  Check this now:
+    if(remaining_header_length < 6) {
+        fUsingDemux->envir() << "StreamParser::parseSystemHeader(): saw strange header_length: " << remaining_header_length << " < 6\n";
+    }
+    skipBytes(remaining_header_length);
+
+    // Check for a PES Packet next:
+    setParseState(PARSING_PES_PACKET);
+}
+
+#define private_stream_1 0xBD
+#define private_stream_2 0xBF
+
+// A test for stream ids that are exempt from normal PES packet header parsing
+Boolean MPEGProgramStreamParser ::isSpecialStreamId(unsigned char stream_id) const {
+    if(stream_id == RAW_PES)
+        return True;  // hack
+
+    if(fUsingDemux->fMPEGversion == 1) {
+        return stream_id == private_stream_2;
+    }
+    else {  // assume MPEG-2
+        if(stream_id <= private_stream_2) {
+            return stream_id != private_stream_1;
+        }
+        else if((stream_id & 0xF0) == 0xF0) {
+            unsigned char lower4Bits = stream_id & 0x0F;
+            return lower4Bits <= 2 || lower4Bits == 0x8 || lower4Bits == 0xF;
+        }
+        else {
+            return False;
+        }
+    }
+}
+
+#define READER_NOT_READY 2
+
+unsigned char MPEGProgramStreamParser::parsePESPacket() {
+#ifdef DEBUG
+    fprintf(stderr, "parsing PES packet\n");
+    fflush(stderr);
+#endif
+    unsigned next4Bytes = test4Bytes();
+    if(!isPacketStartCode(next4Bytes)) {
+        // The PES Packet was optional.  Look for a Pack Header instead:
+        setParseState(PARSING_PACK_HEADER);
+        return 0;
+    }
+
+#ifdef DEBUG
+    fprintf(stderr, "saw packet_start_code_prefix\n");
+    fflush(stderr);
+#endif
+    skipBytes(3);  // we've already seen the packet_start_code_prefix
+
+    unsigned char stream_id = get1Byte();
+#if defined(DEBUG) || defined(DEBUG_TIMESTAMPS)
+    unsigned char streamNum = stream_id;
+    char const *  streamTypeStr;
+    if((stream_id & 0xE0) == 0xC0) {
+        streamTypeStr = "audio";
+        streamNum     = stream_id & ~0xE0;
+    }
+    else if((stream_id & 0xF0) == 0xE0) {
+        streamTypeStr = "video";
+        streamNum     = stream_id & ~0xF0;
+    }
+    else if(stream_id == 0xbc) {
+        streamTypeStr = "reserved";
+    }
+    else if(stream_id == 0xbd) {
+        streamTypeStr = "private_1";
+    }
+    else if(stream_id == 0xbe) {
+        streamTypeStr = "padding";
+    }
+    else if(stream_id == 0xbf) {
+        streamTypeStr = "private_2";
+    }
+    else {
+        streamTypeStr = "unknown";
+    }
+#endif
+#ifdef DEBUG
+    static unsigned frameCount = 1;
+    fprintf(stderr, "%d, saw %s stream: 0x%02x\n", frameCount, streamTypeStr, streamNum);
+    fflush(stderr);
+#endif
+
+    unsigned short PES_packet_length = get2Bytes();
+#ifdef DEBUG
+    fprintf(stderr, "PES_packet_length: %d\n", PES_packet_length);
+    fflush(stderr);
+#endif
+
+    // Parse over the rest of the header, until we get to the packet data itself.
+    // This varies depending upon the MPEG version:
+    if(fUsingDemux->fOutput[RAW_PES].isPotentiallyReadable) {
+        // Hack: We've been asked to return raw PES packets, for every stream:
+        stream_id = RAW_PES;
+    }
+    unsigned savedParserOffset = curOffset();
+#ifdef DEBUG_TIMESTAMPS
+    unsigned char pts_highBit       = 0;
+    unsigned      pts_remainingBits = 0;
+    unsigned char dts_highBit       = 0;
+    unsigned      dts_remainingBits = 0;
+#endif
+    if(fUsingDemux->fMPEGversion == 1) {
+        if(!isSpecialStreamId(stream_id)) {
+            unsigned char nextByte;
+            while((nextByte = get1Byte()) == 0xFF) {  // stuffing_byte
+            }
+            if((nextByte & 0xC0) == 0x40) {  // '01'
+                skipBytes(1);
+                nextByte = get1Byte();
+            }
+            if((nextByte & 0xF0) == 0x20) {  // '0010'
+#ifdef DEBUG_TIMESTAMPS
+                pts_highBit         = (nextByte & 0x08) >> 3;
+                pts_remainingBits   = (nextByte & 0x06) << 29;
+                unsigned next4Bytes = get4Bytes();
+                pts_remainingBits |= (next4Bytes & 0xFFFE0000) >> 2;
+                pts_remainingBits |= (next4Bytes & 0x0000FFFE) >> 1;
+#else
+                skipBytes(4);
+#endif
+            }
+            else if((nextByte & 0xF0) == 0x30) {  // '0011'
+#ifdef DEBUG_TIMESTAMPS
+                pts_highBit         = (nextByte & 0x08) >> 3;
+                pts_remainingBits   = (nextByte & 0x06) << 29;
+                unsigned next4Bytes = get4Bytes();
+                pts_remainingBits |= (next4Bytes & 0xFFFE0000) >> 2;
+                pts_remainingBits |= (next4Bytes & 0x0000FFFE) >> 1;
+
+                nextByte          = get1Byte();
+                dts_highBit       = (nextByte & 0x08) >> 3;
+                dts_remainingBits = (nextByte & 0x06) << 29;
+                next4Bytes        = get4Bytes();
+                dts_remainingBits |= (next4Bytes & 0xFFFE0000) >> 2;
+                dts_remainingBits |= (next4Bytes & 0x0000FFFE) >> 1;
+#else
+                skipBytes(9);
+#endif
+            }
+        }
+    }
+    else {  // assume MPEG-2
+        if(!isSpecialStreamId(stream_id)) {
+            // Fields in the next 3 bytes determine the size of the rest:
+            unsigned next3Bytes = getBits(24);
+#ifdef DEBUG_TIMESTAMPS
+            unsigned char PTS_DTS_flags = (next3Bytes & 0x00C000) >> 14;
+#endif
+#ifdef undef
+            unsigned char ESCR_flag           = (next3Bytes & 0x002000) >> 13;
+            unsigned char ES_rate_flag        = (next3Bytes & 0x001000) >> 12;
+            unsigned char DSM_trick_mode_flag = (next3Bytes & 0x000800) >> 11;
+#endif
+            unsigned char PES_header_data_length = (next3Bytes & 0x0000FF);
+#ifdef DEBUG
+            fprintf(stderr, "PES_header_data_length: 0x%02x\n", PES_header_data_length);
+            fflush(stderr);
+#endif
+#ifdef DEBUG_TIMESTAMPS
+            if(PTS_DTS_flags == 0x2 && PES_header_data_length >= 5) {
+                unsigned char nextByte = get1Byte();
+                pts_highBit            = (nextByte & 0x08) >> 3;
+                pts_remainingBits      = (nextByte & 0x06) << 29;
+                unsigned next4Bytes    = get4Bytes();
+                pts_remainingBits |= (next4Bytes & 0xFFFE0000) >> 2;
+                pts_remainingBits |= (next4Bytes & 0x0000FFFE) >> 1;
+
+                skipBytes(PES_header_data_length - 5);
+            }
+            else if(PTS_DTS_flags == 0x3 && PES_header_data_length >= 10) {
+                unsigned char nextByte = get1Byte();
+                pts_highBit            = (nextByte & 0x08) >> 3;
+                pts_remainingBits      = (nextByte & 0x06) << 29;
+                unsigned next4Bytes    = get4Bytes();
+                pts_remainingBits |= (next4Bytes & 0xFFFE0000) >> 2;
+                pts_remainingBits |= (next4Bytes & 0x0000FFFE) >> 1;
+
+                nextByte          = get1Byte();
+                dts_highBit       = (nextByte & 0x08) >> 3;
+                dts_remainingBits = (nextByte & 0x06) << 29;
+                next4Bytes        = get4Bytes();
+                dts_remainingBits |= (next4Bytes & 0xFFFE0000) >> 2;
+                dts_remainingBits |= (next4Bytes & 0x0000FFFE) >> 1;
+
+                skipBytes(PES_header_data_length - 10);
+            }
+#else
+            skipBytes(PES_header_data_length);
+#endif
+        }
+    }
+#ifdef DEBUG_TIMESTAMPS
+    fprintf(stderr, "%s stream, ", streamTypeStr);
+    fprintf(stderr, "packet presentation_time_stamp: 0x%x", pts_highBit);
+    fprintf(stderr, "%08x\n", pts_remainingBits);
+    fprintf(stderr, "\t\tpacket decoding_time_stamp: 0x%x", dts_highBit);
+    fprintf(stderr, "%08x\n", dts_remainingBits);
+#endif
+
+    // The rest of the packet will be the "PES_packet_data_byte"s
+    // Make sure that "PES_packet_length" was consistent with where we are now:
+    unsigned char acquiredStreamIdTag = 0;
+    unsigned      currentParserOffset = curOffset();
+    unsigned      bytesSkipped        = currentParserOffset - savedParserOffset;
+    if(stream_id == RAW_PES) {
+        restoreSavedParserState();  // so we deliver from the beginning of the PES packet
+        PES_packet_length += 6;     // to include the whole of the PES packet
+        bytesSkipped = 0;
+    }
+    if(PES_packet_length < bytesSkipped) {
+        fUsingDemux->envir() << "StreamParser::parsePESPacket(): saw inconsistent PES_packet_length " << PES_packet_length << " < " << bytesSkipped << "\n";
+    }
+    else {
+        PES_packet_length -= bytesSkipped;
+#ifdef DEBUG
+        unsigned next4Bytes = test4Bytes();
+#endif
+
+        // Check whether our using source is interested in this stream type.
+        // If so, deliver the frame to him:
+        MPEG1or2Demux::OutputDescriptor_t &out = fUsingDemux->fOutput[stream_id];
+        if(out.isCurrentlyAwaitingData) {
+            unsigned numBytesToCopy;
+            if(PES_packet_length > out.maxSize) {
+                fUsingDemux->envir() << "MPEGProgramStreamParser::parsePESPacket() error: PES_packet_length (" << PES_packet_length
+                                     << ") exceeds max frame size asked for (" << out.maxSize << ")\n";
+                numBytesToCopy = out.maxSize;
+            }
+            else {
+                numBytesToCopy = PES_packet_length;
+            }
+
+            getBytes(out.to, numBytesToCopy);
+            out.frameSize = numBytesToCopy;
+#ifdef DEBUG
+            fprintf(stderr, "%d, %d bytes of PES_packet_data (out.maxSize: %d); first 4 bytes: 0x%08x\n", frameCount, numBytesToCopy, out.maxSize, next4Bytes);
+            fflush(stderr);
+#endif
+            // set out.presentationTime later #####
+            acquiredStreamIdTag = stream_id;
+            PES_packet_length -= numBytesToCopy;
+        }
+        else if(out.isCurrentlyActive) {
+            // Someone has been reading this stream, but isn't right now.
+            // We can't deliver this frame until he asks for it, so punt for now.
+            // The next time he asks for a frame, he'll get it.
+#ifdef DEBUG
+            fprintf(stderr, "%d, currently undeliverable PES data; first 4 bytes: 0x%08x - currently undeliverable!\n", frameCount, next4Bytes);
+            fflush(stderr);
+#endif
+            restoreSavedParserState();  // so we read from the beginning next time
+            fUsingDemux->fHaveUndeliveredData = True;
+            throw READER_NOT_READY;
+        }
+        else if(out.isPotentiallyReadable && out.savedDataTotalSize + PES_packet_length < 1000000 /*limit*/) {
+            // Someone is interested in this stream, but hasn't begun reading it yet.
+            // Save this data, so that the reader will get it when he later asks for it.
+            unsigned char *buf = new unsigned char[PES_packet_length];
+            getBytes(buf, PES_packet_length);
+            MPEG1or2Demux::OutputDescriptor::SavedData *savedData = new MPEG1or2Demux::OutputDescriptor::SavedData(buf, PES_packet_length);
+            if(out.savedDataHead == NULL) {
+                out.savedDataHead = out.savedDataTail = savedData;
+            }
+            else {
+                out.savedDataTail->next = savedData;
+                out.savedDataTail       = savedData;
+            }
+            out.savedDataTotalSize += PES_packet_length;
+            PES_packet_length = 0;
+        }
+        skipBytes(PES_packet_length);
+    }
+
+    // Check for another PES Packet next:
+    setParseState(PARSING_PES_PACKET);
+#ifdef DEBUG
+    ++frameCount;
+#endif
+    return acquiredStreamIdTag;
+}
diff --git a/3rdparty/live555/src/liveMedia/MPEG1or2DemuxedElementaryStream.cpp b/3rdparty/live555/src/liveMedia/MPEG1or2DemuxedElementaryStream.cpp
new file mode 100644
index 00000000..d255dd00
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/MPEG1or2DemuxedElementaryStream.cpp
@@ -0,0 +1,78 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A MPEG 1 or 2 Elementary Stream, demultiplexed from a Program Stream
+// Implementation
+
+#include "MPEG1or2DemuxedElementaryStream.hh"
+
+////////// MPEG1or2DemuxedElementaryStream //////////
+
+MPEG1or2DemuxedElementaryStream::MPEG1or2DemuxedElementaryStream(UsageEnvironment &env, u_int8_t streamIdTag, MPEG1or2Demux &sourceDemux)
+    : FramedSource(env), fOurStreamIdTag(streamIdTag), fOurSourceDemux(sourceDemux), fMPEGversion(0) {
+    // Set our MIME type string for known media types:
+    if((streamIdTag & 0xE0) == 0xC0) {
+        fMIMEtype = "audio/MPEG";
+    }
+    else if((streamIdTag & 0xF0) == 0xE0) {
+        fMIMEtype = "video/MPEG";
+    }
+    else {
+        fMIMEtype = MediaSource::MIMEtype();
+    }
+}
+
+MPEG1or2DemuxedElementaryStream::~MPEG1or2DemuxedElementaryStream() {
+    fOurSourceDemux.noteElementaryStreamDeletion(this);
+}
+
+void MPEG1or2DemuxedElementaryStream::doGetNextFrame() {
+    fOurSourceDemux.getNextFrame(fOurStreamIdTag, fTo, fMaxSize, afterGettingFrame, this, handleClosure, this);
+}
+
+void MPEG1or2DemuxedElementaryStream::doStopGettingFrames() {
+    fOurSourceDemux.stopGettingFrames(fOurStreamIdTag);
+}
+
+char const *MPEG1or2DemuxedElementaryStream::MIMEtype() const {
+    return fMIMEtype;
+}
+
+unsigned MPEG1or2DemuxedElementaryStream::maxFrameSize() const {
+    return 6 + 65535;
+    // because the MPEG spec allows for PES packets as large as
+    // (6 + 65535) bytes (header + data)
+}
+
+void MPEG1or2DemuxedElementaryStream ::afterGettingFrame(void *clientData, unsigned frameSize, unsigned numTruncatedBytes, struct timeval presentationTime,
+                                                         unsigned durationInMicroseconds) {
+    MPEG1or2DemuxedElementaryStream *stream = (MPEG1or2DemuxedElementaryStream *)clientData;
+    stream->afterGettingFrame1(frameSize, numTruncatedBytes, presentationTime, durationInMicroseconds);
+}
+
+void MPEG1or2DemuxedElementaryStream ::afterGettingFrame1(unsigned frameSize, unsigned numTruncatedBytes, struct timeval presentationTime,
+                                                          unsigned durationInMicroseconds) {
+    fFrameSize              = frameSize;
+    fNumTruncatedBytes      = numTruncatedBytes;
+    fPresentationTime       = presentationTime;
+    fDurationInMicroseconds = durationInMicroseconds;
+
+    fLastSeenSCR = fOurSourceDemux.lastSeenSCR();
+    fMPEGversion = fOurSourceDemux.mpegVersion();
+
+    FramedSource::afterGetting(this);
+}
diff --git a/3rdparty/live555/src/liveMedia/MPEG1or2DemuxedServerMediaSubsession.cpp b/3rdparty/live555/src/liveMedia/MPEG1or2DemuxedServerMediaSubsession.cpp
new file mode 100644
index 00000000..af1d49dc
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/MPEG1or2DemuxedServerMediaSubsession.cpp
@@ -0,0 +1,128 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A 'ServerMediaSubsession' object that creates new, unicast, "RTPSink"s
+// on demand, from a MPEG-1 or 2 demuxer.
+// Implementation
+
+#include "MPEG1or2DemuxedServerMediaSubsession.hh"
+#include "MPEG1or2AudioStreamFramer.hh"
+#include "MPEG1or2AudioRTPSink.hh"
+#include "MPEG1or2VideoStreamFramer.hh"
+#include "MPEG1or2VideoRTPSink.hh"
+#include "AC3AudioStreamFramer.hh"
+#include "AC3AudioRTPSink.hh"
+#include "ByteStreamFileSource.hh"
+
+MPEG1or2DemuxedServerMediaSubsession *MPEG1or2DemuxedServerMediaSubsession ::createNew(MPEG1or2FileServerDemux &demux, u_int8_t streamIdTag,
+                                                                                       Boolean reuseFirstSource, Boolean iFramesOnly, double vshPeriod) {
+    return new MPEG1or2DemuxedServerMediaSubsession(demux, streamIdTag, reuseFirstSource, iFramesOnly, vshPeriod);
+}
+
+MPEG1or2DemuxedServerMediaSubsession ::MPEG1or2DemuxedServerMediaSubsession(MPEG1or2FileServerDemux &demux, u_int8_t streamIdTag, Boolean reuseFirstSource,
+                                                                            Boolean iFramesOnly, double vshPeriod)
+    : OnDemandServerMediaSubsession(demux.envir(), reuseFirstSource),
+      fOurDemux(demux),
+      fStreamIdTag(streamIdTag),
+      fIFramesOnly(iFramesOnly),
+      fVSHPeriod(vshPeriod) {}
+
+MPEG1or2DemuxedServerMediaSubsession::~MPEG1or2DemuxedServerMediaSubsession() {}
+
+FramedSource *MPEG1or2DemuxedServerMediaSubsession ::createNewStreamSource(unsigned clientSessionId, unsigned &estBitrate) {
+    FramedSource *es = NULL;
+    do {
+        es = fOurDemux.newElementaryStream(clientSessionId, fStreamIdTag);
+        if(es == NULL)
+            break;
+
+        if((fStreamIdTag & 0xF0) == 0xC0 /*MPEG audio*/) {
+            estBitrate = 128;  // kbps, estimate
+            return MPEG1or2AudioStreamFramer::createNew(envir(), es);
+        }
+        else if((fStreamIdTag & 0xF0) == 0xE0 /*video*/) {
+            estBitrate = 500;  // kbps, estimate
+            return MPEG1or2VideoStreamFramer::createNew(envir(), es, fIFramesOnly, fVSHPeriod);
+        }
+        else if(fStreamIdTag == 0xBD /*AC-3 audio*/) {
+            estBitrate = 192;  // kbps, estimate
+            return AC3AudioStreamFramer::createNew(envir(), es, 0x80);
+        }
+        else {  // unknown stream type
+            break;
+        }
+    } while(0);
+
+    // An error occurred:
+    Medium::close(es);
+    return NULL;
+}
+
+RTPSink *MPEG1or2DemuxedServerMediaSubsession ::createNewRTPSink(Groupsock *rtpGroupsock, unsigned char rtpPayloadTypeIfDynamic, FramedSource *inputSource) {
+    if((fStreamIdTag & 0xF0) == 0xC0 /*MPEG audio*/) {
+        return MPEG1or2AudioRTPSink::createNew(envir(), rtpGroupsock);
+    }
+    else if((fStreamIdTag & 0xF0) == 0xE0 /*video*/) {
+        return MPEG1or2VideoRTPSink::createNew(envir(), rtpGroupsock);
+    }
+    else if(fStreamIdTag == 0xBD /*AC-3 audio*/) {
+        // Get the sampling frequency from the audio source; use it for the RTP frequency:
+        AC3AudioStreamFramer *audioSource = (AC3AudioStreamFramer *)inputSource;
+        return AC3AudioRTPSink::createNew(envir(), rtpGroupsock, rtpPayloadTypeIfDynamic, audioSource->samplingRate());
+    }
+    else {
+        return NULL;
+    }
+}
+
+void MPEG1or2DemuxedServerMediaSubsession ::seekStreamSource(FramedSource *inputSource, double &seekNPT, double /*streamDuration*/, u_int64_t & /*numBytes*/) {
+    float const    dur             = duration();
+    unsigned const size            = fOurDemux.fileSize();
+    unsigned       absBytePosition = dur == 0.0 ? 0 : (unsigned)((seekNPT / dur) * size);
+
+    // "inputSource" is a 'framer'
+    // Flush its data, to account for the seek that we're about to do:
+    if((fStreamIdTag & 0xF0) == 0xC0 /*MPEG audio*/) {
+        MPEG1or2AudioStreamFramer *framer = (MPEG1or2AudioStreamFramer *)inputSource;
+        framer->flushInput();
+    }
+    else if((fStreamIdTag & 0xF0) == 0xE0 /*video*/) {
+        MPEG1or2VideoStreamFramer *framer = (MPEG1or2VideoStreamFramer *)inputSource;
+        framer->flushInput();
+    }
+
+    // "inputSource" is a filter; its input source is the original elem stream source:
+    MPEG1or2DemuxedElementaryStream *elemStreamSource = (MPEG1or2DemuxedElementaryStream *)(((FramedFilter *)inputSource)->inputSource());
+
+    // Next, get the original source demux:
+    MPEG1or2Demux &sourceDemux = elemStreamSource->sourceDemux();
+
+    // and flush its input buffers:
+    sourceDemux.flushInput();
+
+    // Then, get the original input file stream from the source demux:
+    ByteStreamFileSource *inputFileSource = (ByteStreamFileSource *)(sourceDemux.inputSource());
+    // Note: We can make that cast, because we know that the demux was originally
+    // created from a "ByteStreamFileSource".
+
+    // Do the appropriate seek within the input file stream:
+    inputFileSource->seekToByteAbsolute(absBytePosition);
+}
+
+float MPEG1or2DemuxedServerMediaSubsession::duration() const {
+    return fOurDemux.fileDuration();
+}
diff --git a/3rdparty/live555/src/liveMedia/MPEG1or2FileServerDemux.cpp b/3rdparty/live555/src/liveMedia/MPEG1or2FileServerDemux.cpp
new file mode 100644
index 00000000..50c15dd7
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/MPEG1or2FileServerDemux.cpp
@@ -0,0 +1,249 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A server demultiplexer for a MPEG 1 or 2 Program Stream
+// Implementation
+
+#include "MPEG1or2FileServerDemux.hh"
+#include "MPEG1or2DemuxedServerMediaSubsession.hh"
+#include "ByteStreamFileSource.hh"
+
+MPEG1or2FileServerDemux *MPEG1or2FileServerDemux::createNew(UsageEnvironment &env, char const *fileName, Boolean reuseFirstSource) {
+    return new MPEG1or2FileServerDemux(env, fileName, reuseFirstSource);
+}
+
+static float MPEG1or2ProgramStreamFileDuration(UsageEnvironment &env, char const *fileName,
+                                               unsigned &fileSize);  // forward
+MPEG1or2FileServerDemux ::MPEG1or2FileServerDemux(UsageEnvironment &env, char const *fileName, Boolean reuseFirstSource)
+    : Medium(env), fReuseFirstSource(reuseFirstSource), fSession0Demux(NULL), fLastCreatedDemux(NULL), fLastClientSessionId(~0) {
+    fFileName     = strDup(fileName);
+    fFileDuration = MPEG1or2ProgramStreamFileDuration(env, fileName, fFileSize);
+}
+
+MPEG1or2FileServerDemux::~MPEG1or2FileServerDemux() {
+    Medium::close(fSession0Demux);
+    delete[](char *) fFileName;
+}
+
+ServerMediaSubsession *MPEG1or2FileServerDemux::newAudioServerMediaSubsession() {
+    return MPEG1or2DemuxedServerMediaSubsession::createNew(*this, 0xC0, fReuseFirstSource);
+}
+
+ServerMediaSubsession *MPEG1or2FileServerDemux::newVideoServerMediaSubsession(Boolean iFramesOnly, double vshPeriod) {
+    return MPEG1or2DemuxedServerMediaSubsession::createNew(*this, 0xE0, fReuseFirstSource, iFramesOnly, vshPeriod);
+}
+
+ServerMediaSubsession *MPEG1or2FileServerDemux::newAC3AudioServerMediaSubsession() {
+    return MPEG1or2DemuxedServerMediaSubsession::createNew(*this, 0xBD, fReuseFirstSource);
+    // because, in a VOB file, the AC3 audio has stream id 0xBD
+}
+
+MPEG1or2DemuxedElementaryStream *MPEG1or2FileServerDemux::newElementaryStream(unsigned clientSessionId, u_int8_t streamIdTag) {
+    MPEG1or2Demux *demuxToUse = NULL;
+
+    if(clientSessionId == 0) {
+        // 'Session 0' is treated especially, because its audio & video streams
+        // are created and destroyed one-at-a-time, rather than both streams being
+        // created, and then (later) both streams being destroyed (as is the case
+        // for other ('real') session ids).  Because of this, a separate demux is
+        // used for session 0, and its deletion is managed by us, rather than
+        // happening automatically.
+        if(fSession0Demux == NULL) {
+            // Open our input file as a 'byte-stream file source':
+            ByteStreamFileSource *fileSource = ByteStreamFileSource::createNew(envir(), fFileName);
+            if(fileSource == NULL)
+                return NULL;
+            fSession0Demux = MPEG1or2Demux::createNew(envir(), fileSource, False /*note!*/);
+        }
+        demuxToUse = fSession0Demux;
+    }
+    else {
+        // First, check whether this is a new client session.  If so, create a new
+        // demux for it:
+        if(clientSessionId == fLastClientSessionId) {
+            demuxToUse = fLastCreatedDemux;  // use the same demultiplexor as before
+        }
+
+        if(demuxToUse == NULL) {
+            // Open our input file as a 'byte-stream file source':
+            ByteStreamFileSource *fileSource = ByteStreamFileSource::createNew(envir(), fFileName);
+            if(fileSource == NULL)
+                return NULL;
+
+            demuxToUse = MPEG1or2Demux::createNew(envir(), fileSource, True, onDemuxDeletion, this);
+            // Note: We tell the demux to delete itself when its last
+            // elementary stream is deleted.
+        }
+
+        fLastClientSessionId = clientSessionId;
+        fLastCreatedDemux    = demuxToUse;
+    }
+
+    return demuxToUse->newElementaryStream(streamIdTag);
+}
+
+void MPEG1or2FileServerDemux::onDemuxDeletion(void *clientData, MPEG1or2Demux *demuxBeingDeleted) {
+    ((MPEG1or2FileServerDemux *)clientData)->onDemuxDeletion(demuxBeingDeleted);
+}
+
+void MPEG1or2FileServerDemux::onDemuxDeletion(MPEG1or2Demux *demuxBeingDeleted) {
+    if(fLastCreatedDemux == demuxBeingDeleted)
+        fLastCreatedDemux = NULL;
+}
+
+static Boolean getMPEG1or2TimeCode(FramedSource *dataSource, MPEG1or2Demux &parentDemux, Boolean returnFirstSeenCode,
+                                   float &timeCode);  // forward
+
+static float MPEG1or2ProgramStreamFileDuration(UsageEnvironment &env, char const *fileName, unsigned &fileSize) {
+    FramedSource *dataSource = NULL;
+    float         duration   = 0.0;  // until we learn otherwise
+    fileSize                 = 0;    // ditto
+
+    do {
+        // Open the input file as a 'byte-stream file source':
+        ByteStreamFileSource *fileSource = ByteStreamFileSource::createNew(env, fileName);
+        if(fileSource == NULL)
+            break;
+        dataSource = fileSource;
+
+        fileSize = (unsigned)(fileSource->fileSize());
+        if(fileSize == 0)
+            break;
+
+        // Create a MPEG demultiplexor that reads from that source.
+        MPEG1or2Demux *baseDemux = MPEG1or2Demux::createNew(env, dataSource, True);
+        if(baseDemux == NULL)
+            break;
+
+        // Create, from this, a source that returns raw PES packets:
+        dataSource = baseDemux->newRawPESStream();
+
+        // Read the first time code from the file:
+        float firstTimeCode;
+        if(!getMPEG1or2TimeCode(dataSource, *baseDemux, True, firstTimeCode))
+            break;
+
+        // Then, read the last time code from the file.
+        // (Before doing this, flush the demux's input buffers,
+        //  and seek towards the end of the file, for efficiency.)
+        baseDemux->flushInput();
+        unsigned const startByteFromEnd = 100000;
+        unsigned       newFilePosition  = fileSize < startByteFromEnd ? 0 : fileSize - startByteFromEnd;
+        if(newFilePosition > 0)
+            fileSource->seekToByteAbsolute(newFilePosition);
+
+        float lastTimeCode;
+        if(!getMPEG1or2TimeCode(dataSource, *baseDemux, False, lastTimeCode))
+            break;
+
+        // Take the difference between these time codes as being the file duration:
+        float timeCodeDiff = lastTimeCode - firstTimeCode;
+        if(timeCodeDiff < 0)
+            break;
+        duration = timeCodeDiff;
+    } while(0);
+
+    Medium::close(dataSource);
+    return duration;
+}
+
+#define MFSD_DUMMY_SINK_BUFFER_SIZE (6 + 65535) /* large enough for a PES packet */
+
+class MFSD_DummySink : public MediaSink {
+public:
+    MFSD_DummySink(MPEG1or2Demux &demux, Boolean returnFirstSeenCode);
+    virtual ~MFSD_DummySink();
+
+    char watchVariable;
+
+private:
+    // redefined virtual function:
+    virtual Boolean continuePlaying();
+
+private:
+    static void afterGettingFrame(void *clientData, unsigned frameSize, unsigned numTruncatedBytes, struct timeval presentationTime,
+                                  unsigned durationInMicroseconds);
+    void        afterGettingFrame1();
+
+private:
+    MPEG1or2Demux &fOurDemux;
+    Boolean        fReturnFirstSeenCode;
+    unsigned char  fBuf[MFSD_DUMMY_SINK_BUFFER_SIZE];
+};
+
+static void  afterPlayingMFSD_DummySink(MFSD_DummySink *sink);   // forward
+static float computeSCRTimeCode(MPEG1or2Demux::SCR const &scr);  // forward
+
+static Boolean getMPEG1or2TimeCode(FramedSource *dataSource, MPEG1or2Demux &parentDemux, Boolean returnFirstSeenCode, float &timeCode) {
+    // Start reading through "dataSource", until we see a SCR time code:
+    parentDemux.lastSeenSCR().isValid = False;
+    UsageEnvironment &env             = dataSource->envir();  // alias
+    MFSD_DummySink    sink(parentDemux, returnFirstSeenCode);
+    sink.startPlaying(*dataSource, (MediaSink::afterPlayingFunc *)afterPlayingMFSD_DummySink, &sink);
+    env.taskScheduler().doEventLoop(&sink.watchVariable);
+
+    timeCode = computeSCRTimeCode(parentDemux.lastSeenSCR());
+    return parentDemux.lastSeenSCR().isValid;
+}
+
+////////// MFSD_DummySink implementation //////////
+
+MFSD_DummySink::MFSD_DummySink(MPEG1or2Demux &demux, Boolean returnFirstSeenCode)
+    : MediaSink(demux.envir()), watchVariable(0), fOurDemux(demux), fReturnFirstSeenCode(returnFirstSeenCode) {}
+
+MFSD_DummySink::~MFSD_DummySink() {}
+
+Boolean MFSD_DummySink::continuePlaying() {
+    if(fSource == NULL)
+        return False;  // sanity check
+
+    fSource->getNextFrame(fBuf, sizeof fBuf, afterGettingFrame, this, onSourceClosure, this);
+    return True;
+}
+
+void MFSD_DummySink::afterGettingFrame(void *clientData, unsigned /*frameSize*/, unsigned /*numTruncatedBytes*/, struct timeval /*presentationTime*/,
+                                       unsigned /*durationInMicroseconds*/) {
+    MFSD_DummySink *sink = (MFSD_DummySink *)clientData;
+    sink->afterGettingFrame1();
+}
+
+void MFSD_DummySink::afterGettingFrame1() {
+    if(fReturnFirstSeenCode && fOurDemux.lastSeenSCR().isValid) {
+        // We were asked to return the first SCR that we saw, and we've seen one,
+        // so we're done.  (Handle this as if the input source had closed.)
+        onSourceClosure();
+        return;
+    }
+
+    continuePlaying();
+}
+
+static void afterPlayingMFSD_DummySink(MFSD_DummySink *sink) {
+    // Return from the "doEventLoop()" call:
+    sink->watchVariable = ~0;
+}
+
+static float computeSCRTimeCode(MPEG1or2Demux::SCR const &scr) {
+    double result = scr.remainingBits / 90000.0 + scr.extension / 300.0;
+    if(scr.highBit) {
+        // Add (2^32)/90000 == (2^28)/5625
+        double const highBitValue = (256 * 1024 * 1024) / 5625.0;
+        result += highBitValue;
+    }
+
+    return (float)result;
+}
diff --git a/3rdparty/live555/src/liveMedia/MPEG1or2VideoFileServerMediaSubsession.cpp b/3rdparty/live555/src/liveMedia/MPEG1or2VideoFileServerMediaSubsession.cpp
new file mode 100644
index 00000000..3f8572f0
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/MPEG1or2VideoFileServerMediaSubsession.cpp
@@ -0,0 +1,52 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A 'ServerMediaSubsession' object that creates new, unicast, "RTPSink"s
+// on demand, from a MPEG-1 or 2 Elementary Stream video file.
+// Implementation
+
+#include "MPEG1or2VideoFileServerMediaSubsession.hh"
+#include "MPEG1or2VideoRTPSink.hh"
+#include "ByteStreamFileSource.hh"
+#include "MPEG1or2VideoStreamFramer.hh"
+
+MPEG1or2VideoFileServerMediaSubsession *MPEG1or2VideoFileServerMediaSubsession::createNew(UsageEnvironment &env, char const *fileName, Boolean reuseFirstSource,
+                                                                                          Boolean iFramesOnly, double vshPeriod) {
+    return new MPEG1or2VideoFileServerMediaSubsession(env, fileName, reuseFirstSource, iFramesOnly, vshPeriod);
+}
+
+MPEG1or2VideoFileServerMediaSubsession ::MPEG1or2VideoFileServerMediaSubsession(UsageEnvironment &env, char const *fileName, Boolean reuseFirstSource,
+                                                                                Boolean iFramesOnly, double vshPeriod)
+    : FileServerMediaSubsession(env, fileName, reuseFirstSource), fIFramesOnly(iFramesOnly), fVSHPeriod(vshPeriod) {}
+
+MPEG1or2VideoFileServerMediaSubsession ::~MPEG1or2VideoFileServerMediaSubsession() {}
+
+FramedSource *MPEG1or2VideoFileServerMediaSubsession ::createNewStreamSource(unsigned /*clientSessionId*/, unsigned &estBitrate) {
+    estBitrate = 500;  // kbps, estimate
+
+    ByteStreamFileSource *fileSource = ByteStreamFileSource::createNew(envir(), fFileName);
+    if(fileSource == NULL)
+        return NULL;
+    fFileSize = fileSource->fileSize();
+
+    return MPEG1or2VideoStreamFramer ::createNew(envir(), fileSource, fIFramesOnly, fVSHPeriod);
+}
+
+RTPSink *MPEG1or2VideoFileServerMediaSubsession ::createNewRTPSink(Groupsock *rtpGroupsock, unsigned char /*rtpPayloadTypeIfDynamic*/,
+                                                                   FramedSource * /*inputSource*/) {
+    return MPEG1or2VideoRTPSink::createNew(envir(), rtpGroupsock);
+}
diff --git a/3rdparty/live555/src/liveMedia/MPEG1or2VideoRTPSink.cpp b/3rdparty/live555/src/liveMedia/MPEG1or2VideoRTPSink.cpp
new file mode 100644
index 00000000..18b6ce68
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/MPEG1or2VideoRTPSink.cpp
@@ -0,0 +1,166 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// RTP sink for MPEG video (RFC 2250)
+// Implementation
+
+#include "MPEG1or2VideoRTPSink.hh"
+#include "MPEG1or2VideoStreamFramer.hh"
+
+MPEG1or2VideoRTPSink::MPEG1or2VideoRTPSink(UsageEnvironment &env, Groupsock *RTPgs) : VideoRTPSink(env, RTPgs, 32, 90000, "MPV") {
+    fPictureState.temporal_reference  = 0;
+    fPictureState.picture_coding_type = fPictureState.vector_code_bits = 0;
+}
+
+MPEG1or2VideoRTPSink::~MPEG1or2VideoRTPSink() {}
+
+MPEG1or2VideoRTPSink *MPEG1or2VideoRTPSink::createNew(UsageEnvironment &env, Groupsock *RTPgs) {
+    return new MPEG1or2VideoRTPSink(env, RTPgs);
+}
+
+Boolean MPEG1or2VideoRTPSink::sourceIsCompatibleWithUs(MediaSource &source) {
+    // Our source must be an appropriate framer:
+    return source.isMPEG1or2VideoStreamFramer();
+}
+
+Boolean MPEG1or2VideoRTPSink::allowFragmentationAfterStart() const {
+    return True;
+}
+
+Boolean MPEG1or2VideoRTPSink ::frameCanAppearAfterPacketStart(unsigned char const *frameStart, unsigned numBytesInFrame) const {
+    // A 'frame' (which in this context can mean a header or a slice as well as a
+    // complete picture) can appear at other than the first position in a packet
+    // in all situations, EXCEPT when it follows the end of (i.e., the last slice
+    // of) a picture.  I.e., the headers at the beginning of a picture must
+    // appear at the start of a RTP packet.
+    if(!fPreviousFrameWasSlice)
+        return True;
+
+    // A slice is already packed into this packet.  We allow this new 'frame'
+    // to be packed after it, provided that it is also a slice:
+    return numBytesInFrame >= 4 && frameStart[0] == 0 && frameStart[1] == 0 && frameStart[2] == 1 && frameStart[3] >= 1 && frameStart[3] <= 0xAF;
+}
+
+#define VIDEO_SEQUENCE_HEADER_START_CODE 0x000001B3
+#define PICTURE_START_CODE 0x00000100
+
+void MPEG1or2VideoRTPSink ::doSpecialFrameHandling(unsigned fragmentationOffset, unsigned char *frameStart, unsigned numBytesInFrame,
+                                                   struct timeval framePresentationTime, unsigned numRemainingBytes) {
+    Boolean thisFrameIsASlice = False;  // until we learn otherwise
+    if(isFirstFrameInPacket()) {
+        fSequenceHeaderPresent = fPacketBeginsSlice = fPacketEndsSlice = False;
+    }
+
+    if(fragmentationOffset == 0) {
+        // Begin by inspecting the 4-byte code at the start of the frame:
+        if(numBytesInFrame < 4)
+            return;  // shouldn't happen
+        unsigned startCode = (frameStart[0] << 24) | (frameStart[1] << 16) | (frameStart[2] << 8) | frameStart[3];
+
+        if(startCode == VIDEO_SEQUENCE_HEADER_START_CODE) {
+            // This is a video sequence header
+            fSequenceHeaderPresent = True;
+        }
+        else if(startCode == PICTURE_START_CODE) {
+            // This is a picture header
+
+            // Record the parameters of this picture:
+            if(numBytesInFrame < 8)
+                return;  // shouldn't happen
+            unsigned      next4Bytes = (frameStart[4] << 24) | (frameStart[5] << 16) | (frameStart[6] << 8) | frameStart[7];
+            unsigned char byte8      = numBytesInFrame == 8 ? 0 : frameStart[8];
+
+            fPictureState.temporal_reference  = (next4Bytes & 0xFFC00000) >> (32 - 10);
+            fPictureState.picture_coding_type = (next4Bytes & 0x00380000) >> (32 - (10 + 3));
+
+            unsigned char FBV, BFC, FFV, FFC;
+            FBV = BFC = FFV = FFC = 0;
+            switch(fPictureState.picture_coding_type) {
+            case 3:
+                FBV = (byte8 & 0x40) >> 6;
+                BFC = (byte8 & 0x38) >> 3;
+                // fall through to:
+            case 2:
+                FFV = (next4Bytes & 0x00000004) >> 2;
+                FFC = ((next4Bytes & 0x00000003) << 1) | ((byte8 & 0x80) >> 7);
+            }
+
+            fPictureState.vector_code_bits = (FBV << 7) | (BFC << 4) | (FFV << 3) | FFC;
+        }
+        else if((startCode & 0xFFFFFF00) == 0x00000100) {
+            unsigned char lastCodeByte = startCode & 0xFF;
+
+            if(lastCodeByte <= 0xAF) {
+                // This is (the start of) a slice
+                thisFrameIsASlice = True;
+            }
+            else {
+                // This is probably a GOP header; we don't do anything with this
+            }
+        }
+        else {
+            // The first 4 bytes aren't a code that we recognize.
+            envir() << "Warning: MPEG1or2VideoRTPSink::doSpecialFrameHandling saw strange first 4 bytes " << (void *)startCode
+                    << ", but we're not a fragment\n";
+        }
+    }
+    else {
+        // We're a fragment (other than the first) of a slice.
+        thisFrameIsASlice = True;
+    }
+
+    if(thisFrameIsASlice) {
+        // This packet begins a slice iff there's no fragmentation offset:
+        fPacketBeginsSlice = (fragmentationOffset == 0);
+
+        // This packet also ends a slice iff there are no fragments remaining:
+        fPacketEndsSlice = (numRemainingBytes == 0);
+    }
+
+    // Set the video-specific header based on the parameters that we've seen.
+    // Note that this may get done more than once, if several frames appear
+    // in the packet.  That's OK, because this situation happens infrequently,
+    // and we want the video-specific header to reflect the most up-to-date
+    // information (in particular, from a Picture Header) anyway.
+    unsigned videoSpecificHeader =
+        // T == 0
+        (fPictureState.temporal_reference << 16) |
+        // AN == N == 0
+        (fSequenceHeaderPresent << 13) | (fPacketBeginsSlice << 12) | (fPacketEndsSlice << 11) | (fPictureState.picture_coding_type << 8)
+        | fPictureState.vector_code_bits;
+    setSpecialHeaderWord(videoSpecificHeader);
+
+    // Also set the RTP timestamp.  (As above, we do this for each frame
+    // in the packet.)
+    setTimestamp(framePresentationTime);
+
+    // Set the RTP 'M' (marker) bit iff this frame ends (i.e., is the last
+    // slice of) a picture (and there are no fragments remaining).
+    // This relies on the source being a "MPEG1or2VideoStreamFramer".
+    MPEG1or2VideoStreamFramer *framerSource = (MPEG1or2VideoStreamFramer *)fSource;
+    if(framerSource != NULL && framerSource->pictureEndMarker() && numRemainingBytes == 0) {
+        setMarkerBit();
+        framerSource->pictureEndMarker() = False;
+    }
+
+    fPreviousFrameWasSlice = thisFrameIsASlice;
+}
+
+unsigned MPEG1or2VideoRTPSink::specialHeaderSize() const {
+    // There's a 4 byte special video header:
+    return 4;
+}
diff --git a/3rdparty/live555/src/liveMedia/MPEG1or2VideoRTPSource.cpp b/3rdparty/live555/src/liveMedia/MPEG1or2VideoRTPSource.cpp
new file mode 100644
index 00000000..f1adae12
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/MPEG1or2VideoRTPSource.cpp
@@ -0,0 +1,71 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// MPEG-1 or MPEG-2 Video RTP Sources
+// Implementation
+
+#include "MPEG1or2VideoRTPSource.hh"
+
+MPEG1or2VideoRTPSource *MPEG1or2VideoRTPSource::createNew(UsageEnvironment &env, Groupsock *RTPgs, unsigned char rtpPayloadFormat,
+                                                          unsigned rtpTimestampFrequency) {
+    return new MPEG1or2VideoRTPSource(env, RTPgs, rtpPayloadFormat, rtpTimestampFrequency);
+}
+
+MPEG1or2VideoRTPSource::MPEG1or2VideoRTPSource(UsageEnvironment &env, Groupsock *RTPgs, unsigned char rtpPayloadFormat, unsigned rtpTimestampFrequency)
+    : MultiFramedRTPSource(env, RTPgs, rtpPayloadFormat, rtpTimestampFrequency) {}
+
+MPEG1or2VideoRTPSource::~MPEG1or2VideoRTPSource() {}
+
+Boolean MPEG1or2VideoRTPSource ::processSpecialHeader(BufferedPacket *packet, unsigned &resultSpecialHeaderSize) {
+    // There's a 4-byte video-specific header
+    if(packet->dataSize() < 4)
+        return False;
+
+    u_int32_t header = ntohl(*(u_int32_t *)(packet->data()));
+
+    u_int32_t sBit = header & 0x00002000;  // sequence-header-present
+    u_int32_t bBit = header & 0x00001000;  // beginning-of-slice
+    u_int32_t eBit = header & 0x00000800;  // end-of-slice
+
+    fCurrentPacketBeginsFrame    = (sBit | bBit) != 0;
+    fCurrentPacketCompletesFrame = ((sBit != 0) && (bBit == 0)) || (eBit != 0);
+
+    resultSpecialHeaderSize = 4;
+    return True;
+}
+
+Boolean MPEG1or2VideoRTPSource ::packetIsUsableInJitterCalculation(unsigned char *packet, unsigned packetSize) {
+    // There's a 4-byte video-specific header
+    if(packetSize < 4)
+        return False;
+
+    // Extract the "Picture-Type" field from this, to determine whether
+    // this packet can be used in jitter calculations:
+    unsigned header = ntohl(*(u_int32_t *)packet);
+
+    unsigned short pictureType = (header >> 8) & 0x7;
+    if(pictureType == 1) {  // an I frame
+        return True;
+    }
+    else {  // a P, B, D, or other unknown frame type
+        return False;
+    }
+}
+
+char const *MPEG1or2VideoRTPSource::MIMEtype() const {
+    return "video/MPEG";
+}
diff --git a/3rdparty/live555/src/liveMedia/MPEG1or2VideoStreamDiscreteFramer.cpp b/3rdparty/live555/src/liveMedia/MPEG1or2VideoStreamDiscreteFramer.cpp
new file mode 100644
index 00000000..10a048f3
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/MPEG1or2VideoStreamDiscreteFramer.cpp
@@ -0,0 +1,187 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A simplified version of "MPEG1or2VideoStreamFramer" that takes only
+// complete, discrete frames (rather than an arbitrary byte stream) as input.
+// This avoids the parsing and data copying overhead of the full
+// "MPEG1or2VideoStreamFramer".
+// Implementation
+
+#include "MPEG1or2VideoStreamDiscreteFramer.hh"
+
+MPEG1or2VideoStreamDiscreteFramer *MPEG1or2VideoStreamDiscreteFramer::createNew(UsageEnvironment &env, FramedSource *inputSource, Boolean iFramesOnly,
+                                                                                double vshPeriod, Boolean leavePresentationTimesUnmodified) {
+    // Need to add source type checking here???  #####
+    return new MPEG1or2VideoStreamDiscreteFramer(env, inputSource, iFramesOnly, vshPeriod, leavePresentationTimesUnmodified);
+}
+
+MPEG1or2VideoStreamDiscreteFramer ::MPEG1or2VideoStreamDiscreteFramer(UsageEnvironment &env, FramedSource *inputSource, Boolean iFramesOnly, double vshPeriod,
+                                                                      Boolean leavePresentationTimesUnmodified)
+    : MPEG1or2VideoStreamFramer(env, inputSource, iFramesOnly, vshPeriod, False /*don't create a parser*/),
+      fLeavePresentationTimesUnmodified(leavePresentationTimesUnmodified),
+      fLastNonBFrameTemporal_reference(0),
+      fSavedVSHSize(0),
+      fSavedVSHTimestamp(0.0),
+      fIFramesOnly(iFramesOnly),
+      fVSHPeriod(vshPeriod) {
+    fLastNonBFramePresentationTime.tv_sec  = 0;
+    fLastNonBFramePresentationTime.tv_usec = 0;
+}
+
+MPEG1or2VideoStreamDiscreteFramer::~MPEG1or2VideoStreamDiscreteFramer() {}
+
+void MPEG1or2VideoStreamDiscreteFramer::doGetNextFrame() {
+    // Arrange to read data (which should be a complete MPEG-1 or 2 video frame)
+    // from our data source, directly into the client's input buffer.
+    // After reading this, we'll do some parsing on the frame.
+    fInputSource->getNextFrame(fTo, fMaxSize, afterGettingFrame, this, FramedSource::handleClosure, this);
+}
+
+void MPEG1or2VideoStreamDiscreteFramer ::afterGettingFrame(void *clientData, unsigned frameSize, unsigned numTruncatedBytes, struct timeval presentationTime,
+                                                           unsigned durationInMicroseconds) {
+    MPEG1or2VideoStreamDiscreteFramer *source = (MPEG1or2VideoStreamDiscreteFramer *)clientData;
+    source->afterGettingFrame1(frameSize, numTruncatedBytes, presentationTime, durationInMicroseconds);
+}
+
+static double const frameRateFromCode[] = {
+    0.0,             // forbidden
+    24000 / 1001.0,  // approx 23.976
+    24.0,
+    25.0,
+    30000 / 1001.0,  // approx 29.97
+    30.0,
+    50.0,
+    60000 / 1001.0,  // approx 59.94
+    60.0,
+    0.0,  // reserved
+    0.0,  // reserved
+    0.0,  // reserved
+    0.0,  // reserved
+    0.0,  // reserved
+    0.0,  // reserved
+    0.0   // reserved
+};
+
+#define MILLION 1000000
+
+void MPEG1or2VideoStreamDiscreteFramer ::afterGettingFrame1(unsigned frameSize, unsigned numTruncatedBytes, struct timeval presentationTime,
+                                                            unsigned durationInMicroseconds) {
+    // Check that the first 4 bytes are a system code:
+    if(frameSize >= 4 && fTo[0] == 0 && fTo[1] == 0 && fTo[2] == 1) {
+        fPictureEndMarker = True;  // Assume that we have a complete 'picture' here
+
+        u_int8_t nextCode = fTo[3];
+        if(nextCode == 0xB3) {  // VIDEO_SEQUENCE_HEADER_START_CODE
+            // Note the following 'frame rate' code:
+            if(frameSize >= 8) {
+                u_int8_t frame_rate_code = fTo[7] & 0x0F;
+                fFrameRate               = frameRateFromCode[frame_rate_code];
+            }
+
+            // Also, save away this Video Sequence Header, in case we need it later:
+            // First, figure out how big it is:
+            unsigned vshSize;
+            for(vshSize = 4; vshSize < frameSize - 3; ++vshSize) {
+                if(fTo[vshSize] == 0 && fTo[vshSize + 1] == 0 && fTo[vshSize + 2] == 1 && (fTo[vshSize + 3] == 0xB8 || fTo[vshSize + 3] == 0x00))
+                    break;
+            }
+            if(vshSize == frameSize - 3)
+                vshSize = frameSize;  // There was nothing else following it
+            if(vshSize <= sizeof fSavedVSHBuffer) {
+                memmove(fSavedVSHBuffer, fTo, vshSize);
+                fSavedVSHSize      = vshSize;
+                fSavedVSHTimestamp = presentationTime.tv_sec + presentationTime.tv_usec / (double)MILLION;
+            }
+        }
+        else if(nextCode == 0xB8) {  // GROUP_START_CODE
+            // If necessary, insert a saved Video Sequence Header in front of this:
+            double pts = presentationTime.tv_sec + presentationTime.tv_usec / (double)MILLION;
+            if(pts > fSavedVSHTimestamp + fVSHPeriod && fSavedVSHSize + frameSize <= fMaxSize) {
+                memmove(&fTo[fSavedVSHSize], &fTo[0], frameSize);  // make room for the header
+                memmove(&fTo[0], fSavedVSHBuffer, fSavedVSHSize);  // insert it
+                frameSize += fSavedVSHSize;
+                fSavedVSHTimestamp = pts;
+            }
+        }
+
+        unsigned i = 3;
+        if(nextCode == 0xB3 /*VIDEO_SEQUENCE_HEADER_START_CODE*/ || nextCode == 0xB8 /*GROUP_START_CODE*/) {
+            // Skip to the following PICTURE_START_CODE (if any):
+            for(i += 4; i < frameSize; ++i) {
+                if(fTo[i] == 0x00 /*PICTURE_START_CODE*/
+                   && fTo[i - 1] == 1 && fTo[i - 2] == 0 && fTo[i - 3] == 0) {
+                    nextCode = fTo[i];
+                    break;
+                }
+            }
+        }
+
+        if(nextCode == 0x00 /*PICTURE_START_CODE*/ && i + 2 < frameSize) {
+            // Get the 'temporal_reference' and 'picture_coding_type' from the
+            // following 2 bytes:
+            ++i;
+            unsigned short temporal_reference  = (fTo[i] << 2) | (fTo[i + 1] >> 6);
+            unsigned char  picture_coding_type = (fTo[i + 1] & 0x38) >> 3;
+
+            // If this is not an "I" frame, but we were asked for "I" frames only, then try again:
+            if(fIFramesOnly && picture_coding_type != 1) {
+                doGetNextFrame();
+                return;
+            }
+
+            // If this is a "B" frame, then we have to tweak "presentationTime":
+            if(!fLeavePresentationTimesUnmodified && picture_coding_type == 3 /*B*/
+               && (fLastNonBFramePresentationTime.tv_usec > 0 || fLastNonBFramePresentationTime.tv_sec > 0)) {
+                int trIncrement = fLastNonBFrameTemporal_reference - temporal_reference;
+                if(trIncrement < 0)
+                    trIncrement += 1024;  // field is 10 bits in size
+
+                unsigned usIncrement        = fFrameRate == 0.0 ? 0 : (unsigned)((trIncrement * MILLION) / fFrameRate);
+                unsigned secondsToSubtract  = usIncrement / MILLION;
+                unsigned uSecondsToSubtract = usIncrement % MILLION;
+
+                presentationTime = fLastNonBFramePresentationTime;
+                if((unsigned)presentationTime.tv_usec < uSecondsToSubtract) {
+                    presentationTime.tv_usec += MILLION;
+                    if(presentationTime.tv_sec > 0)
+                        --presentationTime.tv_sec;
+                }
+                presentationTime.tv_usec -= uSecondsToSubtract;
+                if((unsigned)presentationTime.tv_sec > secondsToSubtract) {
+                    presentationTime.tv_sec -= secondsToSubtract;
+                }
+                else {
+                    presentationTime.tv_sec = presentationTime.tv_usec = 0;
+                }
+            }
+            else {
+                fLastNonBFramePresentationTime   = presentationTime;
+                fLastNonBFrameTemporal_reference = temporal_reference;
+            }
+        }
+    }
+
+    // ##### Later:
+    // - do "iFramesOnly" if requested
+
+    // Complete delivery to the client:
+    fFrameSize              = frameSize;
+    fNumTruncatedBytes      = numTruncatedBytes;
+    fPresentationTime       = presentationTime;
+    fDurationInMicroseconds = durationInMicroseconds;
+    afterGetting(this);
+}
diff --git a/3rdparty/live555/src/liveMedia/MPEG1or2VideoStreamFramer.cpp b/3rdparty/live555/src/liveMedia/MPEG1or2VideoStreamFramer.cpp
new file mode 100644
index 00000000..c693b94e
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/MPEG1or2VideoStreamFramer.cpp
@@ -0,0 +1,471 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A filter that breaks up an MPEG 1 or 2 video elementary stream into
+//   frames for: Video_Sequence_Header, GOP_Header, Picture_Header
+// Implementation
+
+#include "MPEG1or2VideoStreamFramer.hh"
+#include "MPEGVideoStreamParser.hh"
+#include <string.h>
+
+////////// MPEG1or2VideoStreamParser definition //////////
+
+// An enum representing the current state of the parser:
+enum MPEGParseState {
+    PARSING_VIDEO_SEQUENCE_HEADER,
+    PARSING_VIDEO_SEQUENCE_HEADER_SEEN_CODE,
+    PARSING_GOP_HEADER,
+    PARSING_GOP_HEADER_SEEN_CODE,
+    PARSING_PICTURE_HEADER,
+    PARSING_SLICE
+};
+
+#define VSH_MAX_SIZE 1000
+
+class MPEG1or2VideoStreamParser : public MPEGVideoStreamParser {
+public:
+    MPEG1or2VideoStreamParser(MPEG1or2VideoStreamFramer *usingSource, FramedSource *inputSource, Boolean iFramesOnly, double vshPeriod);
+    virtual ~MPEG1or2VideoStreamParser();
+
+private:  // redefined virtual functions:
+    virtual void     flushInput();
+    virtual unsigned parse();
+
+private:
+    void reset();
+
+    MPEG1or2VideoStreamFramer *usingSource() {
+        return (MPEG1or2VideoStreamFramer *)fUsingSource;
+    }
+    void setParseState(MPEGParseState parseState);
+
+    unsigned parseVideoSequenceHeader(Boolean haveSeenStartCode);
+    unsigned parseGOPHeader(Boolean haveSeenStartCode);
+    unsigned parsePictureHeader();
+    unsigned parseSlice();
+
+private:
+    MPEGParseState fCurrentParseState;
+    unsigned       fPicturesSinceLastGOP;
+    // can be used to compute timestamp for a video_sequence_header
+    unsigned short fCurPicTemporalReference;
+    // used to compute slice timestamp
+    unsigned char fCurrentSliceNumber;  // set when parsing a slice
+
+    // A saved copy of the most recently seen 'video_sequence_header',
+    // in case we need to insert it into the stream periodically:
+    unsigned char fSavedVSHBuffer[VSH_MAX_SIZE];
+    unsigned      fSavedVSHSize;
+    double        fSavedVSHTimestamp;
+    double        fVSHPeriod;
+    Boolean       fIFramesOnly, fSkippingCurrentPicture;
+
+    void     saveCurrentVSH();
+    Boolean  needToUseSavedVSH();
+    unsigned useSavedVSH();  // returns the size of the saved VSH
+};
+
+////////// MPEG1or2VideoStreamFramer implementation //////////
+
+MPEG1or2VideoStreamFramer::MPEG1or2VideoStreamFramer(UsageEnvironment &env, FramedSource *inputSource, Boolean iFramesOnly, double vshPeriod,
+                                                     Boolean createParser)
+    : MPEGVideoStreamFramer(env, inputSource) {
+    fParser = createParser ? new MPEG1or2VideoStreamParser(this, inputSource, iFramesOnly, vshPeriod) : NULL;
+}
+
+MPEG1or2VideoStreamFramer::~MPEG1or2VideoStreamFramer() {}
+
+MPEG1or2VideoStreamFramer *MPEG1or2VideoStreamFramer::createNew(UsageEnvironment &env, FramedSource *inputSource, Boolean iFramesOnly, double vshPeriod) {
+    // Need to add source type checking here???  #####
+    return new MPEG1or2VideoStreamFramer(env, inputSource, iFramesOnly, vshPeriod);
+}
+
+double MPEG1or2VideoStreamFramer::getCurrentPTS() const {
+    return fPresentationTime.tv_sec + fPresentationTime.tv_usec / 1000000.0;
+}
+
+Boolean MPEG1or2VideoStreamFramer::isMPEG1or2VideoStreamFramer() const {
+    return True;
+}
+
+////////// MPEG1or2VideoStreamParser implementation //////////
+
+MPEG1or2VideoStreamParser ::MPEG1or2VideoStreamParser(MPEG1or2VideoStreamFramer *usingSource, FramedSource *inputSource, Boolean iFramesOnly, double vshPeriod)
+    : MPEGVideoStreamParser(usingSource, inputSource), fCurrentParseState(PARSING_VIDEO_SEQUENCE_HEADER), fVSHPeriod(vshPeriod), fIFramesOnly(iFramesOnly) {
+    reset();
+}
+
+MPEG1or2VideoStreamParser::~MPEG1or2VideoStreamParser() {}
+
+void MPEG1or2VideoStreamParser::setParseState(MPEGParseState parseState) {
+    fCurrentParseState = parseState;
+    MPEGVideoStreamParser::setParseState();
+}
+
+void MPEG1or2VideoStreamParser::reset() {
+    fPicturesSinceLastGOP    = 0;
+    fCurPicTemporalReference = 0;
+    fCurrentSliceNumber      = 0;
+    fSavedVSHSize            = 0;
+    fSkippingCurrentPicture  = False;
+}
+
+void MPEG1or2VideoStreamParser::flushInput() {
+    reset();
+    StreamParser::flushInput();
+    if(fCurrentParseState != PARSING_VIDEO_SEQUENCE_HEADER) {
+        setParseState(PARSING_GOP_HEADER);  // start from the next GOP
+    }
+}
+
+unsigned MPEG1or2VideoStreamParser::parse() {
+    try {
+        switch(fCurrentParseState) {
+        case PARSING_VIDEO_SEQUENCE_HEADER: {
+            return parseVideoSequenceHeader(False);
+        }
+        case PARSING_VIDEO_SEQUENCE_HEADER_SEEN_CODE: {
+            return parseVideoSequenceHeader(True);
+        }
+        case PARSING_GOP_HEADER: {
+            return parseGOPHeader(False);
+        }
+        case PARSING_GOP_HEADER_SEEN_CODE: {
+            return parseGOPHeader(True);
+        }
+        case PARSING_PICTURE_HEADER: {
+            return parsePictureHeader();
+        }
+        case PARSING_SLICE: {
+            return parseSlice();
+        }
+        default: {
+            return 0;  // shouldn't happen
+        }
+        }
+    }
+    catch(int /*e*/) {
+#ifdef DEBUG
+        fprintf(stderr, "MPEG1or2VideoStreamParser::parse() EXCEPTION (This is normal behavior - *not* an error)\n");
+#endif
+        return 0;  // the parsing got interrupted
+    }
+}
+
+void MPEG1or2VideoStreamParser::saveCurrentVSH() {
+    unsigned frameSize = curFrameSize();
+    if(frameSize > sizeof fSavedVSHBuffer)
+        return;  // too big to save
+
+    memmove(fSavedVSHBuffer, fStartOfFrame, frameSize);
+    fSavedVSHSize      = frameSize;
+    fSavedVSHTimestamp = usingSource()->getCurrentPTS();
+}
+
+Boolean MPEG1or2VideoStreamParser::needToUseSavedVSH() {
+    return usingSource()->getCurrentPTS() > fSavedVSHTimestamp + fVSHPeriod && fSavedVSHSize > 0;
+}
+
+unsigned MPEG1or2VideoStreamParser::useSavedVSH() {
+    unsigned bytesToUse    = fSavedVSHSize;
+    unsigned maxBytesToUse = fLimit - fStartOfFrame;
+    if(bytesToUse > maxBytesToUse)
+        bytesToUse = maxBytesToUse;
+
+    memmove(fStartOfFrame, fSavedVSHBuffer, bytesToUse);
+
+    // Also reset the saved timestamp:
+    fSavedVSHTimestamp = usingSource()->getCurrentPTS();
+
+#ifdef DEBUG
+    fprintf(stderr, "used saved video_sequence_header (%d bytes)\n", bytesToUse);
+#endif
+    return bytesToUse;
+}
+
+#define VIDEO_SEQUENCE_HEADER_START_CODE 0x000001B3
+#define GROUP_START_CODE 0x000001B8
+#define PICTURE_START_CODE 0x00000100
+#define SEQUENCE_END_CODE 0x000001B7
+
+static double const frameRateFromCode[] = {
+    0.0,             // forbidden
+    24000 / 1001.0,  // approx 23.976
+    24.0,
+    25.0,
+    30000 / 1001.0,  // approx 29.97
+    30.0,
+    50.0,
+    60000 / 1001.0,  // approx 59.94
+    60.0,
+    0.0,  // reserved
+    0.0,  // reserved
+    0.0,  // reserved
+    0.0,  // reserved
+    0.0,  // reserved
+    0.0,  // reserved
+    0.0   // reserved
+};
+
+unsigned MPEG1or2VideoStreamParser ::parseVideoSequenceHeader(Boolean haveSeenStartCode) {
+#ifdef DEBUG
+    fprintf(stderr, "parsing video sequence header\n");
+#endif
+    unsigned first4Bytes;
+    if(!haveSeenStartCode) {
+        while((first4Bytes = test4Bytes()) != VIDEO_SEQUENCE_HEADER_START_CODE) {
+#ifdef DEBUG
+            fprintf(stderr, "ignoring non video sequence header: 0x%08x\n", first4Bytes);
+#endif
+            get1Byte();
+            setParseState(PARSING_VIDEO_SEQUENCE_HEADER);
+            // ensures we progress over bad data
+        }
+        first4Bytes = get4Bytes();
+    }
+    else {
+        // We've already seen the start code
+        first4Bytes = VIDEO_SEQUENCE_HEADER_START_CODE;
+    }
+    save4Bytes(first4Bytes);
+
+    // Next, extract the size and rate parameters from the next 8 bytes
+    unsigned paramWord1 = get4Bytes();
+    save4Bytes(paramWord1);
+    unsigned next4Bytes = get4Bytes();
+#ifdef DEBUG
+    unsigned short horizontal_size_value    = (paramWord1 & 0xFFF00000) >> (32 - 12);
+    unsigned short vertical_size_value      = (paramWord1 & 0x000FFF00) >> 8;
+    unsigned char  aspect_ratio_information = (paramWord1 & 0x000000F0) >> 4;
+#endif
+    unsigned char frame_rate_code = (paramWord1 & 0x0000000F);
+    usingSource()->fFrameRate     = frameRateFromCode[frame_rate_code];
+#ifdef DEBUG
+    unsigned bit_rate_value        = (next4Bytes & 0xFFFFC000) >> (32 - 18);
+    unsigned vbv_buffer_size_value = (next4Bytes & 0x00001FF8) >> 3;
+    fprintf(stderr,
+            "horizontal_size_value: %d, vertical_size_value: %d, aspect_ratio_information: %d, frame_rate_code: %d (=>%f fps), bit_rate_value: %d (=>%d bps), "
+            "vbv_buffer_size_value: %d\n",
+            horizontal_size_value, vertical_size_value, aspect_ratio_information, frame_rate_code, usingSource()->fFrameRate, bit_rate_value,
+            bit_rate_value * 400, vbv_buffer_size_value);
+#endif
+
+    // Now, copy all bytes that we see, up until we reach a GROUP_START_CODE
+    // or a PICTURE_START_CODE:
+    do {
+        saveToNextCode(next4Bytes);
+    } while(next4Bytes != GROUP_START_CODE && next4Bytes != PICTURE_START_CODE);
+
+    setParseState((next4Bytes == GROUP_START_CODE) ? PARSING_GOP_HEADER_SEEN_CODE : PARSING_PICTURE_HEADER);
+
+    // Compute this frame's timestamp by noting how many pictures we've seen
+    // since the last GOP header:
+    usingSource()->computePresentationTime(fPicturesSinceLastGOP);
+
+    // Save this video_sequence_header, in case we need to insert a copy
+    // into the stream later:
+    saveCurrentVSH();
+
+    return curFrameSize();
+}
+
+unsigned MPEG1or2VideoStreamParser::parseGOPHeader(Boolean haveSeenStartCode) {
+    // First check whether we should insert a previously-saved
+    // 'video_sequence_header' here:
+    if(needToUseSavedVSH())
+        return useSavedVSH();
+
+#ifdef DEBUG
+    fprintf(stderr, "parsing GOP header\n");
+#endif
+    unsigned first4Bytes;
+    if(!haveSeenStartCode) {
+        while((first4Bytes = test4Bytes()) != GROUP_START_CODE) {
+#ifdef DEBUG
+            fprintf(stderr, "ignoring non GOP start code: 0x%08x\n", first4Bytes);
+#endif
+            get1Byte();
+            setParseState(PARSING_GOP_HEADER);
+            // ensures we progress over bad data
+        }
+        first4Bytes = get4Bytes();
+    }
+    else {
+        // We've already seen the GROUP_START_CODE
+        first4Bytes = GROUP_START_CODE;
+    }
+    save4Bytes(first4Bytes);
+
+    // Next, extract the (25-bit) time code from the next 4 bytes:
+    unsigned next4Bytes = get4Bytes();
+    unsigned time_code  = (next4Bytes & 0xFFFFFF80) >> (32 - 25);
+#if defined(DEBUG) || defined(DEBUG_TIMESTAMPS)
+    Boolean drop_frame_flag = (time_code & 0x01000000) != 0;
+#endif
+    unsigned time_code_hours    = (time_code & 0x00F80000) >> 19;
+    unsigned time_code_minutes  = (time_code & 0x0007E000) >> 13;
+    unsigned time_code_seconds  = (time_code & 0x00000FC0) >> 6;
+    unsigned time_code_pictures = (time_code & 0x0000003F);
+#if defined(DEBUG) || defined(DEBUG_TIMESTAMPS)
+    fprintf(stderr, "time_code: 0x%07x, drop_frame %d, hours %d, minutes %d, seconds %d, pictures %d\n", time_code, drop_frame_flag, time_code_hours,
+            time_code_minutes, time_code_seconds, time_code_pictures);
+#endif
+#ifdef DEBUG
+    Boolean closed_gop  = (next4Bytes & 0x00000040) != 0;
+    Boolean broken_link = (next4Bytes & 0x00000020) != 0;
+    fprintf(stderr, "closed_gop: %d, broken_link: %d\n", closed_gop, broken_link);
+#endif
+
+    // Now, copy all bytes that we see, up until we reach a PICTURE_START_CODE:
+    do {
+        saveToNextCode(next4Bytes);
+    } while(next4Bytes != PICTURE_START_CODE);
+
+    // Record the time code:
+    usingSource()->setTimeCode(time_code_hours, time_code_minutes, time_code_seconds, time_code_pictures, fPicturesSinceLastGOP);
+
+    fPicturesSinceLastGOP = 0;
+
+    // Compute this frame's timestamp:
+    usingSource()->computePresentationTime(0);
+
+    setParseState(PARSING_PICTURE_HEADER);
+
+    return curFrameSize();
+}
+
+inline Boolean isSliceStartCode(unsigned fourBytes) {
+    if((fourBytes & 0xFFFFFF00) != 0x00000100)
+        return False;
+
+    unsigned char lastByte = fourBytes & 0xFF;
+    return lastByte <= 0xAF && lastByte >= 1;
+}
+
+unsigned MPEG1or2VideoStreamParser::parsePictureHeader() {
+#ifdef DEBUG
+    fprintf(stderr, "parsing picture header\n");
+#endif
+    // Note that we've already read the PICTURE_START_CODE
+    // Next, extract the temporal reference from the next 4 bytes:
+    unsigned       next4Bytes          = get4Bytes();
+    unsigned short temporal_reference  = (next4Bytes & 0xFFC00000) >> (32 - 10);
+    unsigned char  picture_coding_type = (next4Bytes & 0x00380000) >> 19;
+#ifdef DEBUG
+    unsigned short vbv_delay = (next4Bytes & 0x0007FFF8) >> 3;
+    fprintf(stderr, "temporal_reference: %d, picture_coding_type: %d, vbv_delay: %d\n", temporal_reference, picture_coding_type, vbv_delay);
+#endif
+
+    fSkippingCurrentPicture = fIFramesOnly && picture_coding_type != 1;
+    if(fSkippingCurrentPicture) {
+        // Skip all bytes that we see, up until we reach a slice_start_code:
+        do {
+            skipToNextCode(next4Bytes);
+        } while(!isSliceStartCode(next4Bytes));
+    }
+    else {
+        // Save the PICTURE_START_CODE that we've already read:
+        save4Bytes(PICTURE_START_CODE);
+
+        // Copy all bytes that we see, up until we reach a slice_start_code:
+        do {
+            saveToNextCode(next4Bytes);
+        } while(!isSliceStartCode(next4Bytes));
+    }
+
+    setParseState(PARSING_SLICE);
+
+    fCurrentSliceNumber = next4Bytes & 0xFF;
+
+    // Record the temporal reference:
+    fCurPicTemporalReference = temporal_reference;
+
+    // Compute this frame's timestamp:
+    usingSource()->computePresentationTime(fCurPicTemporalReference);
+
+    if(fSkippingCurrentPicture) {
+        return parse();  // try again, until we get a non-skipped frame
+    }
+    else {
+        return curFrameSize();
+    }
+}
+
+unsigned MPEG1or2VideoStreamParser::parseSlice() {
+    // Note that we've already read the slice_start_code:
+    unsigned next4Bytes = PICTURE_START_CODE | fCurrentSliceNumber;
+#ifdef DEBUG_SLICE
+    fprintf(stderr, "parsing slice: 0x%08x\n", next4Bytes);
+#endif
+
+    if(fSkippingCurrentPicture) {
+        // Skip all bytes that we see, up until we reach a code of some sort:
+        skipToNextCode(next4Bytes);
+    }
+    else {
+        // Copy all bytes that we see, up until we reach a code of some sort:
+        saveToNextCode(next4Bytes);
+    }
+
+    // The next thing to parse depends on the code that we just saw:
+    if(isSliceStartCode(next4Bytes)) {  // common case
+        setParseState(PARSING_SLICE);
+        fCurrentSliceNumber = next4Bytes & 0xFF;
+    }
+    else {
+        // Because we don't see any more slices, we are assumed to have ended
+        // the current picture:
+        ++fPicturesSinceLastGOP;
+        ++usingSource()->fPictureCount;
+        usingSource()->fPictureEndMarker = True;  // HACK #####
+
+        switch(next4Bytes) {
+        case SEQUENCE_END_CODE: {
+            setParseState(PARSING_VIDEO_SEQUENCE_HEADER);
+            break;
+        }
+        case VIDEO_SEQUENCE_HEADER_START_CODE: {
+            setParseState(PARSING_VIDEO_SEQUENCE_HEADER_SEEN_CODE);
+            break;
+        }
+        case GROUP_START_CODE: {
+            setParseState(PARSING_GOP_HEADER_SEEN_CODE);
+            break;
+        }
+        case PICTURE_START_CODE: {
+            setParseState(PARSING_PICTURE_HEADER);
+            break;
+        }
+        default: {
+            usingSource()->envir() << "MPEG1or2VideoStreamParser::parseSlice(): Saw unexpected code " << (void *)next4Bytes << "\n";
+            setParseState(PARSING_SLICE);  // the safest way to recover...
+            break;
+        }
+        }
+    }
+
+    // Compute this frame's timestamp:
+    usingSource()->computePresentationTime(fCurPicTemporalReference);
+
+    if(fSkippingCurrentPicture) {
+        return parse();  // try again, until we get a non-skipped frame
+    }
+    else {
+        return curFrameSize();
+    }
+}
diff --git a/3rdparty/live555/src/liveMedia/MPEG2IndexFromTransportStream.cpp b/3rdparty/live555/src/liveMedia/MPEG2IndexFromTransportStream.cpp
new file mode 100644
index 00000000..eaa06930
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/MPEG2IndexFromTransportStream.cpp
@@ -0,0 +1,721 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A filter that produces a sequence of I-frame indices from a MPEG-2 Transport Stream
+// Implementation
+
+#include "MPEG2IndexFromTransportStream.hh"
+
+////////// IndexRecord definition //////////
+
+enum RecordType {
+    RECORD_UNPARSED            = 0,
+    RECORD_VSH                 = 1,  // a MPEG Video Sequence Header
+    RECORD_GOP                 = 2,
+    RECORD_PIC_NON_IFRAME      = 3,   // includes slices
+    RECORD_PIC_IFRAME          = 4,   // includes slices
+    RECORD_NAL_H264_SPS        = 5,   // H.264
+    RECORD_NAL_H264_PPS        = 6,   // H.264
+    RECORD_NAL_H264_SEI        = 7,   // H.264
+    RECORD_NAL_H264_NON_IFRAME = 8,   // H.264
+    RECORD_NAL_H264_IFRAME     = 9,   // H.264
+    RECORD_NAL_H264_OTHER      = 10,  // H.264
+    RECORD_NAL_H265_VPS        = 11,  // H.265
+    RECORD_NAL_H265_SPS        = 12,  // H.265
+    RECORD_NAL_H265_PPS        = 13,  // H.265
+    RECORD_NAL_H265_NON_IFRAME = 14,  // H.265
+    RECORD_NAL_H265_IFRAME     = 15,  // H.265
+    RECORD_NAL_H265_OTHER      = 16,  // H.265
+    RECORD_JUNK
+};
+
+class IndexRecord {
+public:
+    IndexRecord(u_int8_t startOffset, u_int8_t size, unsigned long transportPacketNumber, float pcr);
+    virtual ~IndexRecord();
+
+    RecordType &recordType() {
+        return fRecordType;
+    }
+    void setFirstFlag() {
+        fRecordType = (RecordType)(((u_int8_t)fRecordType) | 0x80);
+    }
+    u_int8_t startOffset() const {
+        return fStartOffset;
+    }
+    u_int8_t &size() {
+        return fSize;
+    }
+    float pcr() const {
+        return fPCR;
+    }
+    unsigned long transportPacketNumber() const {
+        return fTransportPacketNumber;
+    }
+
+    IndexRecord *next() const {
+        return fNext;
+    }
+    void addAfter(IndexRecord *prev);
+    void unlink();
+
+private:
+    // Index records are maintained in a doubly-linked list:
+    IndexRecord *fNext;
+    IndexRecord *fPrev;
+
+    RecordType fRecordType;
+    u_int8_t   fStartOffset;  // within the Transport Stream packet
+    u_int8_t   fSize;         // in bytes, following "fStartOffset".
+    // Note: fStartOffset + fSize <= TRANSPORT_PACKET_SIZE
+    float         fPCR;
+    unsigned long fTransportPacketNumber;
+};
+
+#ifdef DEBUG
+static char const *recordTypeStr[] = { "UNPARSED",
+                                       "VSH",
+                                       "GOP",
+                                       "PIC(non-I-frame)",
+                                       "PIC(I-frame)",
+                                       "SPS (H.264)",
+                                       "PPS (H.264)",
+                                       "SEI (H.264)",
+                                       "H.264 non-I-frame",
+                                       "H.264 I-frame",
+                                       "other NAL unit (H.264)",
+                                       "VPS (H.265)",
+                                       "SPS (H.265)",
+                                       "PPS (H.265)",
+                                       "H.265 non-I-frame",
+                                       "H.265 I-frame",
+                                       "other NAL unit (H.265)",
+                                       "JUNK" };
+
+UsageEnvironment &operator<<(UsageEnvironment &env, IndexRecord &r) {
+    return env << "[" << ((r.recordType() & 0x80) != 0 ? "1" : "") << recordTypeStr[r.recordType() & 0x7F] << ":" << (unsigned)r.transportPacketNumber() << ":"
+               << r.startOffset() << "(" << r.size() << ")@" << r.pcr() << "]";
+}
+#endif
+
+////////// MPEG2IFrameIndexFromTransportStream implementation //////////
+
+MPEG2IFrameIndexFromTransportStream *MPEG2IFrameIndexFromTransportStream::createNew(UsageEnvironment &env, FramedSource *inputSource) {
+    return new MPEG2IFrameIndexFromTransportStream(env, inputSource);
+}
+
+// The largest expected frame size (in bytes):
+#define MAX_FRAME_SIZE 400000
+
+// Make our parse buffer twice as large as this, to ensure that at least one
+// complete frame will fit inside it:
+#define PARSE_BUFFER_SIZE (2 * MAX_FRAME_SIZE)
+
+// The PID used for the PAT (as defined in the MPEG Transport Stream standard):
+#define PAT_PID 0
+
+MPEG2IFrameIndexFromTransportStream ::MPEG2IFrameIndexFromTransportStream(UsageEnvironment &env, FramedSource *inputSource)
+    : FramedFilter(env, inputSource),
+      fIsH264(False),
+      fIsH265(False),
+      fInputTransportPacketCounter((unsigned)-1),
+      fClosureNumber(0),
+      fLastContinuityCounter(~0),
+      fFirstPCR(0.0),
+      fLastPCR(0.0),
+      fHaveSeenFirstPCR(False),
+      fPMT_PID(0x10),
+      fVideo_PID(0xE0),  // default values
+      fParseBufferSize(PARSE_BUFFER_SIZE),
+      fParseBufferFrameStart(0),
+      fParseBufferParseEnd(4),
+      fParseBufferDataEnd(0),
+      fHeadIndexRecord(NULL),
+      fTailIndexRecord(NULL) {
+    fParseBuffer = new unsigned char[fParseBufferSize];
+}
+
+MPEG2IFrameIndexFromTransportStream::~MPEG2IFrameIndexFromTransportStream() {
+    delete fHeadIndexRecord;
+    delete[] fParseBuffer;
+}
+
+void MPEG2IFrameIndexFromTransportStream::doGetNextFrame() {
+    // Begin by trying to deliver an index record (for an already-parsed frame)
+    // to the client:
+    if(deliverIndexRecord())
+        return;
+
+    // No more index records are left to deliver, so try to parse a new frame:
+    if(parseFrame()) {  // success - try again
+        doGetNextFrame();
+        return;
+    }
+
+    // We need to read some more Transport Stream packets.  Check whether we have room:
+    if(fParseBufferSize - fParseBufferDataEnd < TRANSPORT_PACKET_SIZE) {
+        // There's no room left.  Compact the buffer, and check again:
+        compactParseBuffer();
+        if(fParseBufferSize - fParseBufferDataEnd < TRANSPORT_PACKET_SIZE) {
+            envir() << "ERROR: parse buffer full; increase MAX_FRAME_SIZE\n";
+            // Treat this as if the input source ended:
+            handleInputClosure1();
+            return;
+        }
+    }
+
+    // Arrange to read a new Transport Stream packet:
+    fInputSource->getNextFrame(fInputBuffer, sizeof fInputBuffer, afterGettingFrame, this, handleInputClosure, this);
+}
+
+void MPEG2IFrameIndexFromTransportStream ::afterGettingFrame(void *clientData, unsigned frameSize, unsigned numTruncatedBytes, struct timeval presentationTime,
+                                                             unsigned durationInMicroseconds) {
+    MPEG2IFrameIndexFromTransportStream *source = (MPEG2IFrameIndexFromTransportStream *)clientData;
+    source->afterGettingFrame1(frameSize, numTruncatedBytes, presentationTime, durationInMicroseconds);
+}
+
+#define TRANSPORT_SYNC_BYTE 0x47
+
+void MPEG2IFrameIndexFromTransportStream ::afterGettingFrame1(unsigned frameSize, unsigned numTruncatedBytes, struct timeval presentationTime,
+                                                              unsigned durationInMicroseconds) {
+    if(frameSize < TRANSPORT_PACKET_SIZE || fInputBuffer[0] != TRANSPORT_SYNC_BYTE) {
+        if(fInputBuffer[0] != TRANSPORT_SYNC_BYTE) {
+            envir() << "Bad TS sync byte: 0x" << fInputBuffer[0] << "\n";
+        }
+        // Handle this as if the source ended:
+        handleInputClosure1();
+        return;
+    }
+
+    ++fInputTransportPacketCounter;
+
+    // Figure out how much of this Transport Packet contains PES data:
+    u_int8_t adaptation_field_control = (fInputBuffer[3] & 0x30) >> 4;
+    u_int8_t totalHeaderSize          = adaptation_field_control <= 1 ? 4 : 5 + fInputBuffer[4];
+    if((adaptation_field_control == 2 && totalHeaderSize != TRANSPORT_PACKET_SIZE)
+       || (adaptation_field_control == 3 && totalHeaderSize >= TRANSPORT_PACKET_SIZE)) {
+        envir() << "Bad \"adaptation_field_length\": " << fInputBuffer[4] << "\n";
+        doGetNextFrame();
+        return;
+    }
+
+    // Check for a PCR:
+    if(totalHeaderSize > 5 && (fInputBuffer[5] & 0x10) != 0) {
+        // There's a PCR:
+        u_int32_t pcrBaseHigh = (fInputBuffer[6] << 24) | (fInputBuffer[7] << 16) | (fInputBuffer[8] << 8) | fInputBuffer[9];
+        float     pcr         = pcrBaseHigh / 45000.0f;
+        if((fInputBuffer[10] & 0x80) != 0)
+            pcr += 1 / 90000.0f;  // add in low-bit (if set)
+        unsigned short pcrExt = ((fInputBuffer[10] & 0x01) << 8) | fInputBuffer[11];
+        pcr += pcrExt / 27000000.0f;
+
+        if(!fHaveSeenFirstPCR) {
+            fFirstPCR         = pcr;
+            fHaveSeenFirstPCR = True;
+        }
+        else if(pcr < fLastPCR) {
+            // The PCR timestamp has gone backwards.  Display a warning about this
+            // (because it indicates buggy Transport Stream data), and compensate for it.
+            envir() << "\nWarning: At about " << fLastPCR - fFirstPCR << " seconds into the file, the PCR timestamp decreased - from " << fLastPCR << " to "
+                    << pcr << "\n";
+            fFirstPCR -= (fLastPCR - pcr);
+        }
+        fLastPCR = pcr;
+    }
+
+    // Get the PID from the packet, and check for special tables: the PAT and PMT:
+    u_int16_t PID = ((fInputBuffer[1] & 0x1F) << 8) | fInputBuffer[2];
+    if(PID == PAT_PID) {
+        analyzePAT(&fInputBuffer[totalHeaderSize], TRANSPORT_PACKET_SIZE - totalHeaderSize);
+    }
+    else if(PID == fPMT_PID) {
+        analyzePMT(&fInputBuffer[totalHeaderSize], TRANSPORT_PACKET_SIZE - totalHeaderSize);
+    }
+
+    // Ignore transport packets for non-video programs,
+    // or packets with no data, or packets that duplicate the previous packet:
+    u_int8_t continuity_counter = fInputBuffer[3] & 0x0F;
+    if((PID != fVideo_PID) || !(adaptation_field_control == 1 || adaptation_field_control == 3) || continuity_counter == fLastContinuityCounter) {
+        doGetNextFrame();
+        return;
+    }
+    fLastContinuityCounter = continuity_counter;
+
+    // Also, if this is the start of a PES packet, then skip over the PES header:
+    Boolean payload_unit_start_indicator = (fInputBuffer[1] & 0x40) != 0;
+    if(payload_unit_start_indicator && totalHeaderSize < TRANSPORT_PACKET_SIZE - 8 && fInputBuffer[totalHeaderSize] == 0x00
+       && fInputBuffer[totalHeaderSize + 1] == 0x00 && fInputBuffer[totalHeaderSize + 2] == 0x01) {
+        u_int8_t PES_header_data_length = fInputBuffer[totalHeaderSize + 8];
+        totalHeaderSize += 9 + PES_header_data_length;
+        if(totalHeaderSize >= TRANSPORT_PACKET_SIZE) {
+            envir() << "Unexpectedly large PES header size: " << PES_header_data_length << "\n";
+            // Handle this as if the source ended:
+            handleInputClosure1();
+            return;
+        }
+    }
+
+    // The remaining data is Video Elementary Stream data.  Add it to our parse buffer:
+    unsigned vesSize = TRANSPORT_PACKET_SIZE - totalHeaderSize;
+    memmove(&fParseBuffer[fParseBufferDataEnd], &fInputBuffer[totalHeaderSize], vesSize);
+    fParseBufferDataEnd += vesSize;
+
+    // And add a new index record noting where it came from:
+    addToTail(new IndexRecord(totalHeaderSize, vesSize, fInputTransportPacketCounter, fLastPCR - fFirstPCR));
+
+    // Try again:
+    doGetNextFrame();
+}
+
+void MPEG2IFrameIndexFromTransportStream::handleInputClosure(void *clientData) {
+    MPEG2IFrameIndexFromTransportStream *source = (MPEG2IFrameIndexFromTransportStream *)clientData;
+    source->handleInputClosure1();
+}
+
+#define VIDEO_SEQUENCE_START_CODE 0xB3  // MPEG-1 or 2
+#define VISUAL_OBJECT_SEQUENCE_START_CODE 0xB0  // MPEG-4
+#define GROUP_START_CODE 0xB8  // MPEG-1 or 2
+#define GROUP_VOP_START_CODE 0xB3  // MPEG-4
+#define PICTURE_START_CODE 0x00  // MPEG-1 or 2
+#define VOP_START_CODE 0xB6  // MPEG-4
+
+void MPEG2IFrameIndexFromTransportStream::handleInputClosure1() {
+    if(++fClosureNumber == 1 && fParseBufferDataEnd > fParseBufferFrameStart && fParseBufferDataEnd <= fParseBufferSize - 4) {
+        // This is the first time we saw EOF, and there's still data remaining to be
+        // parsed.  Hack: Append a Picture Header code to the end of the unparsed
+        // data, and try again.  This should use up all of the unparsed data.
+        fParseBuffer[fParseBufferDataEnd++] = 0;
+        fParseBuffer[fParseBufferDataEnd++] = 0;
+        fParseBuffer[fParseBufferDataEnd++] = 1;
+        fParseBuffer[fParseBufferDataEnd++] = PICTURE_START_CODE;
+
+        // Try again:
+        doGetNextFrame();
+    }
+    else {
+        // Handle closure in the regular way:
+        handleClosure();
+    }
+}
+
+void MPEG2IFrameIndexFromTransportStream ::analyzePAT(unsigned char *pkt, unsigned size) {
+    // Get the PMT_PID:
+    while(size >= 17) {  // The table is large enough
+        u_int16_t program_number = (pkt[9] << 8) | pkt[10];
+        if(program_number != 0) {
+            fPMT_PID = ((pkt[11] & 0x1F) << 8) | pkt[12];
+            return;
+        }
+
+        pkt += 4;
+        size -= 4;
+    }
+}
+
+void MPEG2IFrameIndexFromTransportStream ::analyzePMT(unsigned char *pkt, unsigned size) {
+    // Scan the "elementary_PID"s in the map, until we see the first video stream.
+
+    // First, get the "section_length", to get the table's size:
+    u_int16_t section_length = ((pkt[2] & 0x0F) << 8) | pkt[3];
+    if((unsigned)(4 + section_length) < size)
+        size = (4 + section_length);
+
+    // Then, skip any descriptors following the "program_info_length":
+    if(size < 22)
+        return;  // not enough data
+    unsigned program_info_length = ((pkt[11] & 0x0F) << 8) | pkt[12];
+    pkt += 13;
+    size -= 13;
+    if(size < program_info_length)
+        return;  // not enough data
+    pkt += program_info_length;
+    size -= program_info_length;
+
+    // Look at each ("stream_type","elementary_PID") pair, looking for a video stream:
+    while(size >= 9) {
+        u_int8_t  stream_type    = pkt[0];
+        u_int16_t elementary_PID = ((pkt[1] & 0x1F) << 8) | pkt[2];
+        if(stream_type == 1 || stream_type == 2 || stream_type == 0x1B /*H.264 video*/ || stream_type == 0x24 /*H.265 video*/) {
+            if(stream_type == 0x1B)
+                fIsH264 = True;
+            else if(stream_type == 0x24)
+                fIsH265 = True;
+            fVideo_PID = elementary_PID;
+            return;
+        }
+
+        u_int16_t ES_info_length = ((pkt[3] & 0x0F) << 8) | pkt[4];
+        pkt += 5;
+        size -= 5;
+        if(size < ES_info_length)
+            return;  // not enough data
+        pkt += ES_info_length;
+        size -= ES_info_length;
+    }
+}
+
+Boolean MPEG2IFrameIndexFromTransportStream::deliverIndexRecord() {
+    IndexRecord *head = fHeadIndexRecord;
+    if(head == NULL)
+        return False;
+
+    // Check whether the head record has been parsed yet:
+    if(head->recordType() == RECORD_UNPARSED)
+        return False;
+
+    // Remove the head record (the one whose data we'll be delivering):
+    IndexRecord *next = head->next();
+    head->unlink();
+    if(next == head) {
+        fHeadIndexRecord = fTailIndexRecord = NULL;
+    }
+    else {
+        fHeadIndexRecord = next;
+    }
+
+    if(head->recordType() == RECORD_JUNK) {
+        // Don't actually deliver the data to the client:
+        delete head;
+        // Try to deliver the next record instead:
+        return deliverIndexRecord();
+    }
+
+    // Deliver data from the head record:
+#ifdef DEBUG
+    envir() << "delivering: " << *head << "\n";
+#endif
+    if(fMaxSize < 11) {
+        fFrameSize = 0;
+    }
+    else {
+        fTo[0] = (u_int8_t)(head->recordType());
+        fTo[1] = head->startOffset();
+        fTo[2] = head->size();
+        // Deliver the PCR, as 24 bits (integer part; little endian) + 8 bits (fractional part)
+        float    pcr      = head->pcr();
+        unsigned pcr_int  = (unsigned)pcr;
+        u_int8_t pcr_frac = (u_int8_t)(256 * (pcr - pcr_int));
+        fTo[3]            = (unsigned char)(pcr_int);
+        fTo[4]            = (unsigned char)(pcr_int >> 8);
+        fTo[5]            = (unsigned char)(pcr_int >> 16);
+        fTo[6]            = (unsigned char)(pcr_frac);
+        // Deliver the transport packet number (in little-endian order):
+        unsigned long tpn = head->transportPacketNumber();
+        fTo[7]            = (unsigned char)(tpn);
+        fTo[8]            = (unsigned char)(tpn >> 8);
+        fTo[9]            = (unsigned char)(tpn >> 16);
+        fTo[10]           = (unsigned char)(tpn >> 24);
+        fFrameSize        = 11;
+    }
+
+    // Free the (former) head record (as we're now done with it):
+    delete head;
+
+    // Complete delivery to the client:
+    afterGetting(this);
+    return True;
+}
+
+Boolean MPEG2IFrameIndexFromTransportStream::parseFrame() {
+    // At this point, we have a queue of >=0 (unparsed) index records, representing
+    // the data in the parse buffer from "fParseBufferFrameStart"
+    // to "fParseBufferDataEnd".  We now parse through this data, looking for
+    // a complete 'frame', where a 'frame', in this case, means:
+    // 	for MPEG video: a Video Sequence Header, GOP Header, Picture Header, or Slice
+    // 	for H.264 or H.265 video: a NAL unit
+
+    // Inspect the frame's initial 4-byte code, to make sure it starts with a system code:
+    if(fParseBufferDataEnd - fParseBufferFrameStart < 4)
+        return False;  // not enough data
+    unsigned             numInitialBadBytes = 0;
+    unsigned char const *p                  = &fParseBuffer[fParseBufferFrameStart];
+    if(!(p[0] == 0 && p[1] == 0 && p[2] == 1)) {
+        // There's no system code at the beginning.  Parse until we find one:
+        if(fParseBufferParseEnd == fParseBufferFrameStart + 4) {
+            // Start parsing from the beginning of the frame data:
+            fParseBufferParseEnd = fParseBufferFrameStart;
+        }
+        unsigned char nextCode;
+        if(!parseToNextCode(nextCode))
+            return False;
+
+        numInitialBadBytes     = fParseBufferParseEnd - fParseBufferFrameStart;
+        fParseBufferFrameStart = fParseBufferParseEnd;
+        fParseBufferParseEnd += 4;  // skip over the code that we just saw
+        p = &fParseBuffer[fParseBufferFrameStart];
+    }
+
+    unsigned char curCode = p[3];
+    if(fIsH264)
+        curCode &= 0x1F;  // nal_unit_type
+    else if(fIsH265)
+        curCode = (curCode & 0x7E) >> 1;
+
+    RecordType    curRecordType;
+    unsigned char nextCode;
+    if(fIsH264) {
+        switch(curCode) {
+        case 1:  // Coded slice of a non-IDR picture
+            curRecordType = RECORD_NAL_H264_NON_IFRAME;
+            if(!parseToNextCode(nextCode))
+                return False;
+            break;
+        case 5:  // Coded slice of an IDR picture
+            curRecordType = RECORD_NAL_H264_IFRAME;
+            if(!parseToNextCode(nextCode))
+                return False;
+            break;
+        case 6:  // Supplemental enhancement information (SEI)
+            curRecordType = RECORD_NAL_H264_SEI;
+            if(!parseToNextCode(nextCode))
+                return False;
+            break;
+        case 7:  // Sequence parameter set (SPS)
+            curRecordType = RECORD_NAL_H264_SPS;
+            if(!parseToNextCode(nextCode))
+                return False;
+            break;
+        case 8:  // Picture parameter set (PPS)
+            curRecordType = RECORD_NAL_H264_PPS;
+            if(!parseToNextCode(nextCode))
+                return False;
+            break;
+        default:
+            curRecordType = RECORD_NAL_H264_OTHER;
+            if(!parseToNextCode(nextCode))
+                return False;
+            break;
+        }
+    }
+    else if(fIsH265) {
+        switch(curCode) {
+        case 19:  // Coded slice segment of an IDR picture
+        case 20:  // Coded slice segment of an IDR picture
+            curRecordType = RECORD_NAL_H265_IFRAME;
+            if(!parseToNextCode(nextCode))
+                return False;
+            break;
+        case 32:  // Video parameter set (VPS)
+            curRecordType = RECORD_NAL_H265_VPS;
+            if(!parseToNextCode(nextCode))
+                return False;
+            break;
+        case 33:  // Sequence parameter set (SPS)
+            curRecordType = RECORD_NAL_H265_SPS;
+            if(!parseToNextCode(nextCode))
+                return False;
+            break;
+        case 34:  // Picture parameter set (PPS)
+            curRecordType = RECORD_NAL_H265_PPS;
+            if(!parseToNextCode(nextCode))
+                return False;
+            break;
+        default:
+            curRecordType = (curCode <= 31) ? RECORD_NAL_H265_NON_IFRAME : RECORD_NAL_H265_OTHER;
+            if(!parseToNextCode(nextCode))
+                return False;
+            break;
+        }
+    }
+    else {  // MPEG-1, 2, or 4
+        switch(curCode) {
+        case VIDEO_SEQUENCE_START_CODE:
+        case VISUAL_OBJECT_SEQUENCE_START_CODE:
+            curRecordType = RECORD_VSH;
+            while(1) {
+                if(!parseToNextCode(nextCode))
+                    return False;
+                if(nextCode == GROUP_START_CODE || nextCode == PICTURE_START_CODE || nextCode == VOP_START_CODE)
+                    break;
+                fParseBufferParseEnd += 4;  // skip over the code that we just saw
+            }
+            break;
+        case GROUP_START_CODE:
+            curRecordType = RECORD_GOP;
+            while(1) {
+                if(!parseToNextCode(nextCode))
+                    return False;
+                if(nextCode == PICTURE_START_CODE || nextCode == VOP_START_CODE)
+                    break;
+                fParseBufferParseEnd += 4;  // skip over the code that we just saw
+            }
+            break;
+        default:                                    // picture
+            curRecordType = RECORD_PIC_NON_IFRAME;  // may get changed to IFRAME later
+            while(1) {
+                if(!parseToNextCode(nextCode))
+                    return False;
+                if(nextCode == VIDEO_SEQUENCE_START_CODE || nextCode == VISUAL_OBJECT_SEQUENCE_START_CODE || nextCode == GROUP_START_CODE
+                   || nextCode == GROUP_VOP_START_CODE || nextCode == PICTURE_START_CODE || nextCode == VOP_START_CODE)
+                    break;
+                fParseBufferParseEnd += 4;  // skip over the code that we just saw
+            }
+            break;
+        }
+    }
+
+    if(curRecordType == RECORD_PIC_NON_IFRAME) {
+        if(curCode == VOP_START_CODE) {  // MPEG-4
+            if((fParseBuffer[fParseBufferFrameStart + 4] & 0xC0) == 0) {
+                // This is actually an I-frame.  Note it as such:
+                curRecordType = RECORD_PIC_IFRAME;
+            }
+        }
+        else {  // MPEG-1 or 2
+            if((fParseBuffer[fParseBufferFrameStart + 5] & 0x38) == 0x08) {
+                // This is actually an I-frame.  Note it as such:
+                curRecordType = RECORD_PIC_IFRAME;
+            }
+        }
+    }
+
+    // There is now a parsed 'frame', from "fParseBufferFrameStart"
+    // to "fParseBufferParseEnd". Tag the corresponding index records to note this:
+    unsigned frameSize = fParseBufferParseEnd - fParseBufferFrameStart + numInitialBadBytes;
+#ifdef DEBUG
+    envir() << "parsed " << recordTypeStr[curRecordType] << "; length " << frameSize << "\n";
+#endif
+    for(IndexRecord *r = fHeadIndexRecord;; r = r->next()) {
+        if(numInitialBadBytes >= r->size()) {
+            r->recordType() = RECORD_JUNK;
+            numInitialBadBytes -= r->size();
+        }
+        else {
+            r->recordType() = curRecordType;
+        }
+        if(r == fHeadIndexRecord)
+            r->setFirstFlag();
+        // indicates that this is the first record for this frame
+
+        if(r->size() > frameSize) {
+            // This record contains extra data that's not part of the frame.
+            // Shorten this record, and move the extra data to a new record
+            // that comes afterwards:
+            u_int8_t newOffset = r->startOffset() + frameSize;
+            u_int8_t newSize   = r->size() - frameSize;
+            r->size()          = frameSize;
+#ifdef DEBUG
+            envir() << "tagged record (modified): " << *r << "\n";
+#endif
+
+            IndexRecord *newRecord = new IndexRecord(newOffset, newSize, r->transportPacketNumber(), r->pcr());
+            newRecord->addAfter(r);
+            if(fTailIndexRecord == r)
+                fTailIndexRecord = newRecord;
+#ifdef DEBUG
+            envir() << "added extra record: " << *newRecord << "\n";
+#endif
+        }
+        else {
+#ifdef DEBUG
+            envir() << "tagged record: " << *r << "\n";
+#endif
+        }
+        frameSize -= r->size();
+        if(frameSize == 0)
+            break;
+        if(r == fTailIndexRecord) {  // this shouldn't happen
+            envir() << "!!!!!Internal consistency error!!!!!\n";
+            return False;
+        }
+    }
+
+    // Finally, update our parse state (to skip over the now-parsed data):
+    fParseBufferFrameStart = fParseBufferParseEnd;
+    fParseBufferParseEnd += 4;  // to skip over the next code (that we found)
+
+    return True;
+}
+
+Boolean MPEG2IFrameIndexFromTransportStream ::parseToNextCode(unsigned char &nextCode) {
+    unsigned char const *p   = &fParseBuffer[fParseBufferParseEnd];
+    unsigned char const *end = &fParseBuffer[fParseBufferDataEnd];
+    while(p <= end - 4) {
+        if(p[2] > 1)
+            p += 3;  // common case (optimized)
+        else if(p[2] == 0)
+            ++p;
+        else if(p[0] == 0 && p[1] == 0) {  // && p[2] == 1
+            // We found a code here:
+            nextCode             = p[3];
+            fParseBufferParseEnd = p - &fParseBuffer[0];  // where we've gotten to
+            return True;
+        }
+        else
+            p += 3;
+    }
+
+    fParseBufferParseEnd = p - &fParseBuffer[0];  // where we've gotten to
+    return False;                                 // no luck this time
+}
+
+void MPEG2IFrameIndexFromTransportStream::compactParseBuffer() {
+#ifdef DEBUG
+    envir() << "Compacting parse buffer: [" << fParseBufferFrameStart << "," << fParseBufferParseEnd << "," << fParseBufferDataEnd << "]";
+#endif
+    memmove(&fParseBuffer[0], &fParseBuffer[fParseBufferFrameStart], fParseBufferDataEnd - fParseBufferFrameStart);
+    fParseBufferDataEnd -= fParseBufferFrameStart;
+    fParseBufferParseEnd -= fParseBufferFrameStart;
+    fParseBufferFrameStart = 0;
+#ifdef DEBUG
+    envir() << "-> [" << fParseBufferFrameStart << "," << fParseBufferParseEnd << "," << fParseBufferDataEnd << "]\n";
+#endif
+}
+
+void MPEG2IFrameIndexFromTransportStream::addToTail(IndexRecord *newIndexRecord) {
+#ifdef DEBUG
+    envir() << "adding new: " << *newIndexRecord << "\n";
+#endif
+    if(fTailIndexRecord == NULL) {
+        fHeadIndexRecord = fTailIndexRecord = newIndexRecord;
+    }
+    else {
+        newIndexRecord->addAfter(fTailIndexRecord);
+        fTailIndexRecord = newIndexRecord;
+    }
+}
+
+////////// IndexRecord implementation //////////
+
+IndexRecord::IndexRecord(u_int8_t startOffset, u_int8_t size, unsigned long transportPacketNumber, float pcr)
+    : fNext(this),
+      fPrev(this),
+      fRecordType(RECORD_UNPARSED),
+      fStartOffset(startOffset),
+      fSize(size),
+      fPCR(pcr),
+      fTransportPacketNumber(transportPacketNumber) {}
+
+IndexRecord::~IndexRecord() {
+    IndexRecord *nextRecord = next();
+    unlink();
+    if(nextRecord != this)
+        delete nextRecord;
+}
+
+void IndexRecord::addAfter(IndexRecord *prev) {
+    fNext              = prev->fNext;
+    fPrev              = prev;
+    prev->fNext->fPrev = this;
+    prev->fNext        = this;
+}
+
+void IndexRecord::unlink() {
+    fNext->fPrev = fPrev;
+    fPrev->fNext = fNext;
+    fNext = fPrev = this;
+}
diff --git a/3rdparty/live555/src/liveMedia/MPEG2TransportFileServerMediaSubsession.cpp b/3rdparty/live555/src/liveMedia/MPEG2TransportFileServerMediaSubsession.cpp
new file mode 100644
index 00000000..3c64d5b7
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/MPEG2TransportFileServerMediaSubsession.cpp
@@ -0,0 +1,336 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A 'ServerMediaSubsession' object that creates new, unicast, "RTPSink"s
+// on demand, from a MPEG-2 Transport Stream file.
+// Implementation
+
+#include "MPEG2TransportFileServerMediaSubsession.hh"
+#include "SimpleRTPSink.hh"
+
+MPEG2TransportFileServerMediaSubsession *MPEG2TransportFileServerMediaSubsession::createNew(UsageEnvironment &env, char const *fileName,
+                                                                                            char const *indexFileName, Boolean reuseFirstSource) {
+    MPEG2TransportStreamIndexFile *indexFile;
+    if(indexFileName != NULL && reuseFirstSource) {
+        // It makes no sense to support trick play if all clients use the same source.  Fix this:
+        env << "MPEG2TransportFileServerMediaSubsession::createNew(): ignoring the index file name, because \"reuseFirstSource\" is set\n";
+        indexFile = NULL;
+    }
+    else {
+        indexFile = MPEG2TransportStreamIndexFile::createNew(env, indexFileName);
+    }
+    return new MPEG2TransportFileServerMediaSubsession(env, fileName, indexFile, reuseFirstSource);
+}
+
+MPEG2TransportFileServerMediaSubsession ::MPEG2TransportFileServerMediaSubsession(UsageEnvironment &env, char const *fileName,
+                                                                                  MPEG2TransportStreamIndexFile *indexFile, Boolean reuseFirstSource)
+    : FileServerMediaSubsession(env, fileName, reuseFirstSource), fIndexFile(indexFile), fDuration(0.0), fClientSessionHashTable(NULL) {
+    if(fIndexFile != NULL) {  // we support 'trick play'
+        fDuration               = fIndexFile->getPlayingDuration();
+        fClientSessionHashTable = HashTable::create(ONE_WORD_HASH_KEYS);
+    }
+}
+
+MPEG2TransportFileServerMediaSubsession ::~MPEG2TransportFileServerMediaSubsession() {
+    if(fIndexFile != NULL) {  // we support 'trick play'
+        Medium::close(fIndexFile);
+
+        // Clean out the client session hash table:
+        while(1) {
+            ClientTrickPlayState *client = (ClientTrickPlayState *)(fClientSessionHashTable->RemoveNext());
+            if(client == NULL)
+                break;
+            delete client;
+        }
+        delete fClientSessionHashTable;
+    }
+}
+
+#define TRANSPORT_PACKET_SIZE 188
+#define TRANSPORT_PACKETS_PER_NETWORK_PACKET 7
+// The product of these two numbers must be enough to fit within a network packet
+
+void MPEG2TransportFileServerMediaSubsession ::startStream(unsigned clientSessionId, void *streamToken, TaskFunc *rtcpRRHandler, void *rtcpRRHandlerClientData,
+                                                           unsigned short &rtpSeqNum, unsigned &rtpTimestamp,
+                                                           ServerRequestAlternativeByteHandler *serverRequestAlternativeByteHandler,
+                                                           void *                               serverRequestAlternativeByteHandlerClientData) {
+    if(fIndexFile != NULL) {  // we support 'trick play'
+        ClientTrickPlayState *client = lookupClient(clientSessionId);
+        if(client != NULL && client->areChangingScale()) {
+            // First, handle this like a "PAUSE", except that we back up to the previous VSH
+            client->updateStateOnPlayChange(True);
+            OnDemandServerMediaSubsession::pauseStream(clientSessionId, streamToken);
+
+            // Then, adjust for the change of scale:
+            client->updateStateOnScaleChange();
+        }
+    }
+
+    // Call the original, default version of this routine:
+    OnDemandServerMediaSubsession::startStream(clientSessionId, streamToken, rtcpRRHandler, rtcpRRHandlerClientData, rtpSeqNum, rtpTimestamp,
+                                               serverRequestAlternativeByteHandler, serverRequestAlternativeByteHandlerClientData);
+}
+
+void MPEG2TransportFileServerMediaSubsession ::pauseStream(unsigned clientSessionId, void *streamToken) {
+    if(fIndexFile != NULL) {  // we support 'trick play'
+        ClientTrickPlayState *client = lookupClient(clientSessionId);
+        if(client != NULL) {
+            client->updateStateOnPlayChange(False);
+        }
+    }
+
+    // Call the original, default version of this routine:
+    OnDemandServerMediaSubsession::pauseStream(clientSessionId, streamToken);
+}
+
+void MPEG2TransportFileServerMediaSubsession ::seekStream(unsigned clientSessionId, void *streamToken, double &seekNPT, double streamDuration,
+                                                          u_int64_t &numBytes) {
+    // Begin by calling the original, default version of this routine:
+    OnDemandServerMediaSubsession::seekStream(clientSessionId, streamToken, seekNPT, streamDuration, numBytes);
+
+    // Then, special handling specific to indexed Transport Stream files:
+    if(fIndexFile != NULL) {  // we support 'trick play'
+        ClientTrickPlayState *client = lookupClient(clientSessionId);
+        if(client != NULL) {
+            unsigned long numTSPacketsToStream = client->updateStateFromNPT(seekNPT, streamDuration);
+            numBytes                           = numTSPacketsToStream * TRANSPORT_PACKET_SIZE;
+        }
+    }
+}
+
+void MPEG2TransportFileServerMediaSubsession ::setStreamScale(unsigned clientSessionId, void *streamToken, float scale) {
+    if(fIndexFile != NULL) {  // we support 'trick play'
+        ClientTrickPlayState *client = lookupClient(clientSessionId);
+        if(client != NULL) {
+            client->setNextScale(scale);  // scale won't take effect until the next "PLAY"
+        }
+    }
+
+    // Call the original, default version of this routine:
+    OnDemandServerMediaSubsession::setStreamScale(clientSessionId, streamToken, scale);
+}
+
+void MPEG2TransportFileServerMediaSubsession ::deleteStream(unsigned clientSessionId, void *&streamToken) {
+    if(fIndexFile != NULL) {  // we support 'trick play'
+        ClientTrickPlayState *client = lookupClient(clientSessionId);
+        if(client != NULL) {
+            client->updateStateOnPlayChange(False);
+        }
+    }
+
+    // Call the original, default version of this routine:
+    OnDemandServerMediaSubsession::deleteStream(clientSessionId, streamToken);
+}
+
+ClientTrickPlayState *MPEG2TransportFileServerMediaSubsession::newClientTrickPlayState() {
+    return new ClientTrickPlayState(fIndexFile);
+}
+
+FramedSource *MPEG2TransportFileServerMediaSubsession ::createNewStreamSource(unsigned clientSessionId, unsigned &estBitrate) {
+    // Create the video source:
+    unsigned const        inputDataChunkSize = TRANSPORT_PACKETS_PER_NETWORK_PACKET * TRANSPORT_PACKET_SIZE;
+    ByteStreamFileSource *fileSource         = ByteStreamFileSource::createNew(envir(), fFileName, inputDataChunkSize);
+    if(fileSource == NULL)
+        return NULL;
+    fFileSize = fileSource->fileSize();
+
+    // Use the file size and the duration to estimate the stream's bitrate:
+    if(fFileSize > 0 && fDuration > 0.0) {
+        estBitrate = (unsigned)((int64_t)fFileSize / (125 * fDuration) + 0.5);  // kbps, rounded
+    }
+    else {
+        estBitrate = 5000;  // kbps, estimate
+    }
+
+    // Create a framer for the Transport Stream:
+    MPEG2TransportStreamFramer *framer = MPEG2TransportStreamFramer::createNew(envir(), fileSource);
+
+    if(fIndexFile != NULL) {  // we support 'trick play'
+        // Keep state for this client (if we don't already have it):
+        ClientTrickPlayState *client = lookupClient(clientSessionId);
+        if(client == NULL) {
+            client = newClientTrickPlayState();
+            fClientSessionHashTable->Add((char const *)clientSessionId, client);
+        }
+        client->setSource(framer);
+    }
+
+    return framer;
+}
+
+RTPSink *MPEG2TransportFileServerMediaSubsession ::createNewRTPSink(Groupsock *rtpGroupsock, unsigned char /*rtpPayloadTypeIfDynamic*/,
+                                                                    FramedSource * /*inputSource*/) {
+    return SimpleRTPSink::createNew(envir(), rtpGroupsock, 33, 90000, "video", "MP2T", 1, True, False /*no 'M' bit*/);
+}
+
+void MPEG2TransportFileServerMediaSubsession::testScaleFactor(float &scale) {
+    if(fIndexFile != NULL && fDuration > 0.0) {
+        // We support any integral scale, other than 0
+        int iScale = scale < 0.0 ? (int)(scale - 0.5f) : (int)(scale + 0.5f);  // round
+        if(iScale == 0)
+            iScale = 1;
+        scale = (float)iScale;
+    }
+    else {
+        scale = 1.0f;
+    }
+}
+
+float MPEG2TransportFileServerMediaSubsession::duration() const {
+    return fDuration;
+}
+
+ClientTrickPlayState *MPEG2TransportFileServerMediaSubsession ::lookupClient(unsigned clientSessionId) {
+    return (ClientTrickPlayState *)(fClientSessionHashTable->Lookup((char const *)clientSessionId));
+}
+
+////////// ClientTrickPlayState implementation //////////
+
+ClientTrickPlayState::ClientTrickPlayState(MPEG2TransportStreamIndexFile *indexFile)
+    : fIndexFile(indexFile),
+      fOriginalTransportStreamSource(NULL),
+      fTrickModeFilter(NULL),
+      fTrickPlaySource(NULL),
+      fFramer(NULL),
+      fScale(1.0f),
+      fNextScale(1.0f),
+      fNPT(0.0f),
+      fTSRecordNum(0),
+      fIxRecordNum(0) {}
+
+unsigned long ClientTrickPlayState::updateStateFromNPT(double npt, double streamDuration) {
+    fNPT = (float)npt;
+    // Map "fNPT" to the corresponding Transport Stream and Index record numbers:
+    unsigned long tsRecordNum, ixRecordNum;
+    fIndexFile->lookupTSPacketNumFromNPT(fNPT, tsRecordNum, ixRecordNum);
+
+    updateTSRecordNum();
+    if(tsRecordNum != fTSRecordNum) {
+        fTSRecordNum = tsRecordNum;
+        fIxRecordNum = ixRecordNum;
+
+        // Seek the source to the new record number:
+        reseekOriginalTransportStreamSource();
+        // Note: We assume that we're asked to seek only in normal
+        // (i.e., non trick play) mode, so we don't seek within the trick
+        // play source (if any).
+
+        fFramer->clearPIDStatusTable();
+    }
+
+    unsigned long numTSRecordsToStream = 0;
+    float         pcrLimit             = 0.0;
+    if(streamDuration > 0.0) {
+        // fNPT might have changed when we looked it up in the index file.  Adjust "streamDuration" accordingly:
+        streamDuration += npt - (double)fNPT;
+
+        if(streamDuration > 0.0) {
+            // Specify that we want to stream no more data than this.
+
+            if(fNextScale == 1.0f) {
+                // We'll be streaming from the original file.
+                // Use the index file to figure out how many Transport Packets we get to stream:
+                unsigned long toTSRecordNum, toIxRecordNum;
+                float         toNPT = (float)(fNPT + streamDuration);
+                fIndexFile->lookupTSPacketNumFromNPT(toNPT, toTSRecordNum, toIxRecordNum);
+                if(toTSRecordNum > tsRecordNum) {  // sanity check
+                    numTSRecordsToStream = toTSRecordNum - tsRecordNum;
+                }
+            }
+            else {
+                // We'll be streaming from the trick play stream.
+                // It'd be difficult to figure out how many Transport Packets we need to stream, so instead set a PCR
+                // limit in the trick play stream.  (We rely upon the fact that PCRs in the trick play stream start at 0.0)
+                int direction = fNextScale < 0.0 ? -1 : 1;
+                pcrLimit      = (float)(streamDuration / (fNextScale * direction));
+            }
+        }
+    }
+    fFramer->setNumTSPacketsToStream(numTSRecordsToStream);
+    fFramer->setPCRLimit(pcrLimit);
+
+    return numTSRecordsToStream;
+}
+
+void ClientTrickPlayState::updateStateOnScaleChange() {
+    fScale = fNextScale;
+
+    // Change our source objects to reflect the change in scale:
+    // First, close the existing trick play source (if any):
+    if(fTrickPlaySource != NULL) {
+        fTrickModeFilter->forgetInputSource();
+        // so that the underlying Transport Stream source doesn't get deleted by:
+        Medium::close(fTrickPlaySource);
+        fTrickPlaySource = NULL;
+        fTrickModeFilter = NULL;
+    }
+    if(fNextScale != 1.0f) {
+        // Create a new trick play filter from the original Transport Stream source:
+        UsageEnvironment &env = fIndexFile->envir();  // alias
+        fTrickModeFilter      = MPEG2TransportStreamTrickModeFilter ::createNew(env, fOriginalTransportStreamSource, fIndexFile, int(fNextScale));
+        fTrickModeFilter->seekTo(fTSRecordNum, fIxRecordNum);
+
+        // And generate a Transport Stream from this:
+        fTrickPlaySource = MPEG2TransportStreamFromESSource::createNew(env);
+        fTrickPlaySource->addNewVideoSource(fTrickModeFilter, fIndexFile->mpegVersion());
+
+        fFramer->changeInputSource(fTrickPlaySource);
+    }
+    else {
+        // Switch back to the original Transport Stream source:
+        reseekOriginalTransportStreamSource();
+        fFramer->changeInputSource(fOriginalTransportStreamSource);
+    }
+}
+
+void ClientTrickPlayState::updateStateOnPlayChange(Boolean reverseToPreviousVSH) {
+    updateTSRecordNum();
+    if(fTrickPlaySource == NULL) {
+        // We were in regular (1x) play. Use the index file to look up the
+        // index record number and npt from the current transport number:
+        fIndexFile->lookupPCRFromTSPacketNum(fTSRecordNum, reverseToPreviousVSH, fNPT, fIxRecordNum);
+    }
+    else {
+        // We were in trick mode, and so already have the index record number.
+        // Get the transport record number and npt from this:
+        fIxRecordNum = fTrickModeFilter->nextIndexRecordNum();
+        if((long)fIxRecordNum < 0)
+            fIxRecordNum = 0;  // we were at the start of the file
+        unsigned long transportRecordNum;
+        float         pcr;
+        u_int8_t      offset, size, recordType;  // all dummy
+        if(fIndexFile->readIndexRecordValues(fIxRecordNum, transportRecordNum, offset, size, pcr, recordType)) {
+            fTSRecordNum = transportRecordNum;
+            fNPT         = pcr;
+        }
+    }
+}
+
+void ClientTrickPlayState::setSource(MPEG2TransportStreamFramer *framer) {
+    fFramer                        = framer;
+    fOriginalTransportStreamSource = (ByteStreamFileSource *)(framer->inputSource());
+}
+
+void ClientTrickPlayState::updateTSRecordNum() {
+    if(fFramer != NULL)
+        fTSRecordNum += (unsigned long)(fFramer->tsPacketCount());
+}
+
+void ClientTrickPlayState::reseekOriginalTransportStreamSource() {
+    u_int64_t tsRecordNum64 = (u_int64_t)fTSRecordNum;
+    fOriginalTransportStreamSource->seekToByteAbsolute(tsRecordNum64 * TRANSPORT_PACKET_SIZE);
+}
diff --git a/3rdparty/live555/src/liveMedia/MPEG2TransportStreamAccumulator.cpp b/3rdparty/live555/src/liveMedia/MPEG2TransportStreamAccumulator.cpp
new file mode 100644
index 00000000..c3809e58
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/MPEG2TransportStreamAccumulator.cpp
@@ -0,0 +1,71 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// Collects a stream of incoming MPEG Transport Stream packets into
+//  a chunk sufficiently large to send in a single outgoing (RTP or UDP) packet.
+// Implementation
+
+#include "MPEG2TransportStreamAccumulator.hh"
+
+MPEG2TransportStreamAccumulator *MPEG2TransportStreamAccumulator::createNew(UsageEnvironment &env, FramedSource *inputSource, unsigned maxPacketSize) {
+    return new MPEG2TransportStreamAccumulator(env, inputSource, maxPacketSize);
+}
+
+#ifndef TRANSPORT_PACKET_SIZE
+#define TRANSPORT_PACKET_SIZE 188
+#endif
+
+MPEG2TransportStreamAccumulator ::MPEG2TransportStreamAccumulator(UsageEnvironment &env, FramedSource *inputSource, unsigned maxPacketSize)
+    : FramedFilter(env, inputSource),
+      fDesiredPacketSize(maxPacketSize < TRANSPORT_PACKET_SIZE ? TRANSPORT_PACKET_SIZE : (maxPacketSize / TRANSPORT_PACKET_SIZE)),
+      fNumBytesGathered(0) {}
+
+MPEG2TransportStreamAccumulator::~MPEG2TransportStreamAccumulator() {}
+
+void MPEG2TransportStreamAccumulator::doGetNextFrame() {
+    if(fNumBytesGathered >= fDesiredPacketSize) {
+        // Complete the delivery to the client:
+        fFrameSize        = fNumBytesGathered;
+        fNumBytesGathered = 0;
+        afterGetting(this);
+    }
+    else {
+        // Ask for more data (delivered directly to the client's buffer);
+        fInputSource->getNextFrame(fTo, fMaxSize, afterGettingFrame, this, FramedSource::handleClosure, this);
+    }
+}
+
+void MPEG2TransportStreamAccumulator ::afterGettingFrame(void *clientData, unsigned frameSize, unsigned numTruncatedBytes, struct timeval presentationTime,
+                                                         unsigned durationInMicroseconds) {
+    MPEG2TransportStreamAccumulator *accumulator = (MPEG2TransportStreamAccumulator *)clientData;
+    accumulator->afterGettingFrame1(frameSize, numTruncatedBytes, presentationTime, durationInMicroseconds);
+}
+
+void MPEG2TransportStreamAccumulator ::afterGettingFrame1(unsigned frameSize, unsigned numTruncatedBytes, struct timeval presentationTime,
+                                                          unsigned durationInMicroseconds) {
+    if(fNumBytesGathered == 0) {  // this is the first frame of the new chunk
+        fPresentationTime       = presentationTime;
+        fDurationInMicroseconds = 0;
+    }
+    fNumBytesGathered += frameSize;
+    fTo += frameSize;
+    fMaxSize -= frameSize;
+    fDurationInMicroseconds += durationInMicroseconds;
+
+    // Try again to complete delivery:
+    doGetNextFrame();
+}
diff --git a/3rdparty/live555/src/liveMedia/MPEG2TransportStreamDemux.cpp b/3rdparty/live555/src/liveMedia/MPEG2TransportStreamDemux.cpp
new file mode 100644
index 00000000..f159a5b3
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/MPEG2TransportStreamDemux.cpp
@@ -0,0 +1,47 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// Demultiplexer for a MPEG Transport Stream
+// Implementation
+
+#include "MPEG2TransportStreamDemux.hh"
+#include "MPEG2TransportStreamParser.hh"
+
+MPEG2TransportStreamDemux *MPEG2TransportStreamDemux ::createNew(UsageEnvironment &env, FramedSource *inputSource, FramedSource::onCloseFunc *onCloseFunc,
+                                                                 void *onCloseClientData) {
+    return new MPEG2TransportStreamDemux(env, inputSource, onCloseFunc, onCloseClientData);
+}
+
+MPEG2TransportStreamDemux ::MPEG2TransportStreamDemux(UsageEnvironment &env, FramedSource *inputSource, FramedSource::onCloseFunc *onCloseFunc,
+                                                      void *onCloseClientData)
+    : Medium(env), fOnCloseFunc(onCloseFunc), fOnCloseClientData(onCloseClientData) {
+    fParser = new MPEG2TransportStreamParser(inputSource, handleEndOfFile, this);
+}
+
+MPEG2TransportStreamDemux::~MPEG2TransportStreamDemux() {
+    delete fParser;
+}
+
+void MPEG2TransportStreamDemux::handleEndOfFile(void *clientData) {
+    ((MPEG2TransportStreamDemux *)clientData)->handleEndOfFile();
+}
+
+void MPEG2TransportStreamDemux::handleEndOfFile() {
+    if(fOnCloseFunc != NULL)
+        (*fOnCloseFunc)(fOnCloseClientData);
+    delete this;
+}
diff --git a/3rdparty/live555/src/liveMedia/MPEG2TransportStreamDemuxedTrack.cpp b/3rdparty/live555/src/liveMedia/MPEG2TransportStreamDemuxedTrack.cpp
new file mode 100644
index 00000000..04d33a48
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/MPEG2TransportStreamDemuxedTrack.cpp
@@ -0,0 +1,30 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A media track, demultiplexed from a MPEG Transport Stream file
+// Implementation
+
+#include "MPEG2TransportStreamParser.hh"
+
+MPEG2TransportStreamDemuxedTrack ::MPEG2TransportStreamDemuxedTrack(MPEG2TransportStreamParser &ourParser, u_int16_t pid)
+    : FramedSource(ourParser.envir()), fOurParser(ourParser), fPID(pid) {}
+
+MPEG2TransportStreamDemuxedTrack::~MPEG2TransportStreamDemuxedTrack() {}
+
+void MPEG2TransportStreamDemuxedTrack::doGetNextFrame() {
+    fOurParser.continueParsing();
+}
diff --git a/3rdparty/live555/src/liveMedia/MPEG2TransportStreamDemuxedTrack.hh b/3rdparty/live555/src/liveMedia/MPEG2TransportStreamDemuxedTrack.hh
new file mode 100644
index 00000000..019ed938
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/MPEG2TransportStreamDemuxedTrack.hh
@@ -0,0 +1,50 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A media track, demultiplexed from a MPEG Transport Stream file
+// C++ header
+
+#ifndef _MPEG2_TRANSPORT_STREAM_DEMUXED_TRACK_HH
+#define _MPEG2_TRANSPORT_STREAM_DEMUXED_TRACK_HH
+
+#ifndef _MPEG2_TRANSPORT_STREAM_DEMUX_HH
+#include "MPEG2TransportStreamDemux.hh"
+#endif
+
+class MPEG2TransportStreamDemuxedTrack: public FramedSource {
+public:
+  MPEG2TransportStreamDemuxedTrack(class MPEG2TransportStreamParser& ourParser, u_int16_t pid);
+  virtual ~MPEG2TransportStreamDemuxedTrack();
+
+private:
+  // redefined virtual functions:
+  virtual void doGetNextFrame();
+
+private: // We are accessed only by "MPEG2TransportStreamParser" (a friend)
+  friend class MPEG2TransportStreamParser;
+  unsigned char* to() { return fTo; }
+  unsigned maxSize() { return fMaxSize; }
+  unsigned& frameSize() { return fFrameSize; }
+  unsigned& numTruncatedBytes() { return fNumTruncatedBytes; }
+  struct timeval& presentationTime() { return fPresentationTime; }
+
+private:
+  class MPEG2TransportStreamParser& fOurParser;
+  u_int16_t fPID;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/MPEG2TransportStreamFramer.cpp b/3rdparty/live555/src/liveMedia/MPEG2TransportStreamFramer.cpp
new file mode 100644
index 00000000..8ca3b9c5
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/MPEG2TransportStreamFramer.cpp
@@ -0,0 +1,291 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A filter that passes through (unchanged) chunks that contain an integral number
+// of MPEG-2 Transport Stream packets, but returning (in "fDurationInMicroseconds")
+// an updated estimate of the time gap between chunks.
+// Implementation
+
+#include "MPEG2TransportStreamFramer.hh"
+#include <GroupsockHelper.hh>  // for "gettimeofday()"
+
+#define TRANSPORT_PACKET_SIZE 188
+
+////////// Definitions of constants that control the behavior of this code /////////
+
+#if !defined(NEW_DURATION_WEIGHT)
+#define NEW_DURATION_WEIGHT 0.5
+// How much weight to give to the latest duration measurement (must be <= 1)
+#endif
+
+#if !defined(TIME_ADJUSTMENT_FACTOR)
+#define TIME_ADJUSTMENT_FACTOR 0.8
+// A factor by which to adjust the duration estimate to ensure that the overall
+// packet transmission times remains matched with the PCR times (which will be the
+// times that we expect receivers to play the incoming packets).
+// (must be <= 1)
+#endif
+
+#if !defined(MAX_PLAYOUT_BUFFER_DURATION)
+#define MAX_PLAYOUT_BUFFER_DURATION 0.1  // (seconds)
+#endif
+
+#if !defined(PCR_PERIOD_VARIATION_RATIO)
+#define PCR_PERIOD_VARIATION_RATIO 0.5
+#endif
+
+////////// PIDStatus //////////
+
+class PIDStatus {
+public:
+    PIDStatus(double _firstClock, double _firstRealTime)
+        : firstClock(_firstClock), lastClock(_firstClock), firstRealTime(_firstRealTime), lastRealTime(_firstRealTime), lastPacketNum(0) {}
+
+    double    firstClock, lastClock, firstRealTime, lastRealTime;
+    u_int64_t lastPacketNum;
+};
+
+////////// MPEG2TransportStreamFramer //////////
+
+MPEG2TransportStreamFramer *MPEG2TransportStreamFramer ::createNew(UsageEnvironment &env, FramedSource *inputSource) {
+    return new MPEG2TransportStreamFramer(env, inputSource);
+}
+
+MPEG2TransportStreamFramer ::MPEG2TransportStreamFramer(UsageEnvironment &env, FramedSource *inputSource)
+    : FramedFilter(env, inputSource),
+      fTSPacketCount(0),
+      fTSPacketDurationEstimate(0.0),
+      fTSPCRCount(0),
+      fLimitNumTSPacketsToStream(False),
+      fNumTSPacketsToStream(0),
+      fLimitTSPacketsToStreamByPCR(False),
+      fPCRLimit(0.0) {
+    fPIDStatusTable = HashTable::create(ONE_WORD_HASH_KEYS);
+}
+
+MPEG2TransportStreamFramer::~MPEG2TransportStreamFramer() {
+    clearPIDStatusTable();
+    delete fPIDStatusTable;
+}
+
+void MPEG2TransportStreamFramer::clearPIDStatusTable() {
+    PIDStatus *pidStatus;
+    while((pidStatus = (PIDStatus *)fPIDStatusTable->RemoveNext()) != NULL) {
+        delete pidStatus;
+    }
+}
+
+void MPEG2TransportStreamFramer::setNumTSPacketsToStream(unsigned long numTSRecordsToStream) {
+    fNumTSPacketsToStream      = numTSRecordsToStream;
+    fLimitNumTSPacketsToStream = numTSRecordsToStream > 0;
+}
+
+void MPEG2TransportStreamFramer::setPCRLimit(float pcrLimit) {
+    fPCRLimit                    = pcrLimit;
+    fLimitTSPacketsToStreamByPCR = pcrLimit != 0.0;
+}
+
+void MPEG2TransportStreamFramer::doGetNextFrame() {
+    if(fLimitNumTSPacketsToStream) {
+        if(fNumTSPacketsToStream == 0) {
+            handleClosure();
+            return;
+        }
+        if(fNumTSPacketsToStream * TRANSPORT_PACKET_SIZE < fMaxSize) {
+            fMaxSize = fNumTSPacketsToStream * TRANSPORT_PACKET_SIZE;
+        }
+    }
+
+    // Read directly from our input source into our client's buffer:
+    fFrameSize = 0;
+    fInputSource->getNextFrame(fTo, fMaxSize, afterGettingFrame, this, FramedSource::handleClosure, this);
+}
+
+void MPEG2TransportStreamFramer::doStopGettingFrames() {
+    FramedFilter::doStopGettingFrames();
+    fTSPacketCount = 0;
+    fTSPCRCount    = 0;
+
+    clearPIDStatusTable();
+}
+
+void MPEG2TransportStreamFramer ::afterGettingFrame(void *clientData, unsigned frameSize, unsigned /*numTruncatedBytes*/, struct timeval presentationTime,
+                                                    unsigned /*durationInMicroseconds*/) {
+    MPEG2TransportStreamFramer *framer = (MPEG2TransportStreamFramer *)clientData;
+    framer->afterGettingFrame1(frameSize, presentationTime);
+}
+
+#define TRANSPORT_SYNC_BYTE 0x47
+
+void MPEG2TransportStreamFramer::afterGettingFrame1(unsigned frameSize, struct timeval presentationTime) {
+    fFrameSize += frameSize;
+    unsigned const numTSPackets = fFrameSize / TRANSPORT_PACKET_SIZE;
+    fNumTSPacketsToStream -= numTSPackets;
+    fFrameSize = numTSPackets * TRANSPORT_PACKET_SIZE;  // an integral # of TS packets
+    if(fFrameSize == 0) {
+        // We didn't read a complete TS packet; assume that the input source has closed.
+        handleClosure();
+        return;
+    }
+
+    // Make sure the data begins with a sync byte:
+    unsigned syncBytePosition;
+    for(syncBytePosition = 0; syncBytePosition < fFrameSize; ++syncBytePosition) {
+        if(fTo[syncBytePosition] == TRANSPORT_SYNC_BYTE)
+            break;
+    }
+    if(syncBytePosition == fFrameSize) {
+        envir() << "No Transport Stream sync byte in data.";
+        handleClosure();
+        return;
+    }
+    else if(syncBytePosition > 0) {
+        // There's a sync byte, but not at the start of the data.  Move the good data
+        // to the start of the buffer, then read more to fill it up again:
+        memmove(fTo, &fTo[syncBytePosition], fFrameSize - syncBytePosition);
+        fFrameSize -= syncBytePosition;
+        fInputSource->getNextFrame(&fTo[fFrameSize], syncBytePosition, afterGettingFrame, this, FramedSource::handleClosure, this);
+        return;
+    }  // else normal case: the data begins with a sync byte
+
+    fPresentationTime = presentationTime;
+
+    // Scan through the TS packets that we read, and update our estimate of
+    // the duration of each packet:
+    struct timeval tvNow;
+    gettimeofday(&tvNow, NULL);
+    double timeNow = tvNow.tv_sec + tvNow.tv_usec / 1000000.0;
+    for(unsigned i = 0; i < numTSPackets; ++i) {
+        if(!updateTSPacketDurationEstimate(&fTo[i * TRANSPORT_PACKET_SIZE], timeNow)) {
+            // We hit a preset limit (based on PCR) within the stream.  Handle this as if the input source has closed:
+            handleClosure();
+            return;
+        }
+    }
+
+    fDurationInMicroseconds = numTSPackets * (unsigned)(fTSPacketDurationEstimate * 1000000);
+
+    // Complete the delivery to our client:
+    afterGetting(this);
+}
+
+Boolean MPEG2TransportStreamFramer::updateTSPacketDurationEstimate(unsigned char *pkt, double timeNow) {
+    // Sanity check: Make sure we start with the sync byte:
+    if(pkt[0] != TRANSPORT_SYNC_BYTE) {
+        envir() << "Missing sync byte!\n";
+        return True;
+    }
+
+    ++fTSPacketCount;
+
+    // If this packet doesn't contain a PCR, then we're not interested in it:
+    u_int8_t const adaptation_field_control = (pkt[3] & 0x30) >> 4;
+    if(adaptation_field_control != 2 && adaptation_field_control != 3)
+        return True;
+    // there's no adaptation_field
+
+    u_int8_t const adaptation_field_length = pkt[4];
+    if(adaptation_field_length == 0)
+        return True;
+
+    u_int8_t const discontinuity_indicator = pkt[5] & 0x80;
+    u_int8_t const pcrFlag                 = pkt[5] & 0x10;
+    if(pcrFlag == 0)
+        return True;  // no PCR
+
+    // There's a PCR.  Get it, and the PID:
+    ++fTSPCRCount;
+    u_int32_t pcrBaseHigh = (pkt[6] << 24) | (pkt[7] << 16) | (pkt[8] << 8) | pkt[9];
+    double    clock       = pcrBaseHigh / 45000.0;
+    if((pkt[10] & 0x80) != 0)
+        clock += 1 / 90000.0;  // add in low-bit (if set)
+    unsigned short pcrExt = ((pkt[10] & 0x01) << 8) | pkt[11];
+    clock += pcrExt / 27000000.0;
+    if(fLimitTSPacketsToStreamByPCR) {
+        if(clock > fPCRLimit) {
+            // We've hit a preset limit within the stream:
+            return False;
+        }
+    }
+
+    unsigned pid = ((pkt[1] & 0x1F) << 8) | pkt[2];
+
+    // Check whether we already have a record of a PCR for this PID:
+    PIDStatus *pidStatus = (PIDStatus *)(fPIDStatusTable->Lookup((char *)pid));
+
+    if(pidStatus == NULL) {
+        // We're seeing this PID's PCR for the first time:
+        pidStatus = new PIDStatus(clock, timeNow);
+        fPIDStatusTable->Add((char *)pid, pidStatus);
+#ifdef DEBUG_PCR
+        fprintf(stderr, "PID 0x%x, FIRST PCR 0x%08x+%d:%03x == %f @ %f, pkt #%lu\n", pid, pcrBaseHigh, pkt[10] >> 7, pcrExt, clock, timeNow, fTSPacketCount);
+#endif
+    }
+    else {
+        // We've seen this PID's PCR before; update our per-packet duration estimate:
+        int64_t packetsSinceLast = (int64_t)(fTSPacketCount - pidStatus->lastPacketNum);
+        // it's "int64_t" because some compilers can't convert "u_int64_t" -> "double"
+        double durationPerPacket = (clock - pidStatus->lastClock) / packetsSinceLast;
+
+        // Hack (suggested by "Romain"): Don't update our estimate if this PCR appeared unusually quickly.
+        // (This can produce more accurate estimates for wildly VBR streams.)
+        double meanPCRPeriod = 0.0;
+        if(fTSPCRCount > 0) {
+            double tsPacketCount = (double)(int64_t)fTSPacketCount;
+            double tsPCRCount    = (double)(int64_t)fTSPCRCount;
+            meanPCRPeriod        = tsPacketCount / tsPCRCount;
+            if(packetsSinceLast < meanPCRPeriod * PCR_PERIOD_VARIATION_RATIO)
+                return True;
+        }
+
+        if(fTSPacketDurationEstimate == 0.0) {  // we've just started
+            fTSPacketDurationEstimate = durationPerPacket;
+        }
+        else if(discontinuity_indicator == 0 && durationPerPacket >= 0.0) {
+            fTSPacketDurationEstimate = durationPerPacket * NEW_DURATION_WEIGHT + fTSPacketDurationEstimate * (1 - NEW_DURATION_WEIGHT);
+
+            // Also adjust the duration estimate to try to ensure that the transmission
+            // rate matches the playout rate:
+            double transmitDuration = timeNow - pidStatus->firstRealTime;
+            double playoutDuration  = clock - pidStatus->firstClock;
+            if(transmitDuration > playoutDuration) {
+                fTSPacketDurationEstimate *= TIME_ADJUSTMENT_FACTOR;  // reduce estimate
+            }
+            else if(transmitDuration + MAX_PLAYOUT_BUFFER_DURATION < playoutDuration) {
+                fTSPacketDurationEstimate /= TIME_ADJUSTMENT_FACTOR;  // increase estimate
+            }
+        }
+        else {
+            // the PCR has a discontinuity from its previous value; don't use it now,
+            // but reset our PCR and real-time values to compensate:
+            pidStatus->firstClock    = clock;
+            pidStatus->firstRealTime = timeNow;
+        }
+#ifdef DEBUG_PCR
+        fprintf(stderr,
+                "PID 0x%x, PCR 0x%08x+%d:%03x == %f @ %f (diffs %f @ %f), pkt #%lu, discon %d => this duration %f, new estimate %f, mean PCR period=%f\n", pid,
+                pcrBaseHigh, pkt[10] >> 7, pcrExt, clock, timeNow, clock - pidStatus->firstClock, timeNow - pidStatus->firstRealTime, fTSPacketCount,
+                discontinuity_indicator != 0, durationPerPacket, fTSPacketDurationEstimate, meanPCRPeriod);
+#endif
+    }
+
+    pidStatus->lastClock     = clock;
+    pidStatus->lastRealTime  = timeNow;
+    pidStatus->lastPacketNum = fTSPacketCount;
+
+    return True;
+}
diff --git a/3rdparty/live555/src/liveMedia/MPEG2TransportStreamFromESSource.cpp b/3rdparty/live555/src/liveMedia/MPEG2TransportStreamFromESSource.cpp
new file mode 100644
index 00000000..74afe457
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/MPEG2TransportStreamFromESSource.cpp
@@ -0,0 +1,245 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A filter for converting one or more MPEG Elementary Streams
+// to a MPEG-2 Transport Stream
+// Implementation
+
+#include "MPEG2TransportStreamFromESSource.hh"
+
+#define SIMPLE_PES_HEADER_SIZE 14
+#define INPUT_BUFFER_SIZE (SIMPLE_PES_HEADER_SIZE + 2 * MPEG2TransportStreamFromESSource::maxInputESFrameSize)
+#ifndef TS_FROM_ES_LOW_WATER_MARK
+#define TS_FROM_ES_LOW_WATER_MARK 1000  // <= MPEG2TransportStreamFromESSource::maxInputESFrameSize
+#endif
+
+////////// InputESSourceRecord definition //////////
+
+class InputESSourceRecord {
+public:
+    InputESSourceRecord(MPEG2TransportStreamFromESSource &parent, FramedSource *inputSource, u_int8_t streamId, int mpegVersion, InputESSourceRecord *next,
+                        int16_t PID = -1);
+    virtual ~InputESSourceRecord();
+
+    InputESSourceRecord *next() const {
+        return fNext;
+    }
+    FramedSource *inputSource() const {
+        return fInputSource;
+    }
+
+    void    askForNewData();
+    Boolean deliverBufferToClient();
+
+    unsigned char *buffer() const {
+        return fInputBuffer;
+    }
+    void reset() {
+        // Reset the buffer for future use:
+        fInputBufferBytesAvailable = 0;
+        fInputBufferInUse          = False;
+    }
+
+private:
+    static void afterGettingFrame(void *clientData, unsigned frameSize, unsigned numTruncatedBytes, struct timeval presentationTime,
+                                  unsigned durationInMicroseconds);
+    void        afterGettingFrame1(unsigned frameSize, unsigned numTruncatedBytes, struct timeval presentationTime);
+
+private:
+    InputESSourceRecord *             fNext;
+    MPEG2TransportStreamFromESSource &fParent;
+    FramedSource *                    fInputSource;
+    u_int8_t                          fStreamId;
+    int                               fMPEGVersion;
+    unsigned char *                   fInputBuffer;
+    unsigned                          fInputBufferBytesAvailable;
+    Boolean                           fInputBufferInUse;
+    MPEG1or2Demux::SCR                fSCR;
+    int16_t                           fPID;
+};
+
+////////// MPEG2TransportStreamFromESSource implementation //////////
+
+unsigned MPEG2TransportStreamFromESSource::maxInputESFrameSize = 100000;  // bytes
+
+MPEG2TransportStreamFromESSource *MPEG2TransportStreamFromESSource ::createNew(UsageEnvironment &env) {
+    return new MPEG2TransportStreamFromESSource(env);
+}
+
+void MPEG2TransportStreamFromESSource ::addNewVideoSource(FramedSource *inputSource, int mpegVersion, int16_t PID) {
+    u_int8_t streamId = 0xE0 | (fVideoSourceCounter++ & 0x0F);
+    addNewInputSource(inputSource, streamId, mpegVersion, PID);
+    fHaveVideoStreams = True;
+}
+
+void MPEG2TransportStreamFromESSource ::addNewAudioSource(FramedSource *inputSource, int mpegVersion, int16_t PID) {
+    u_int8_t streamId = 0xC0 | (fAudioSourceCounter++ & 0x0F);
+    addNewInputSource(inputSource, streamId, mpegVersion, PID);
+}
+
+MPEG2TransportStreamFromESSource ::MPEG2TransportStreamFromESSource(UsageEnvironment &env)
+    : MPEG2TransportStreamMultiplexor(env), fInputSources(NULL), fVideoSourceCounter(0), fAudioSourceCounter(0), fAwaitingBackgroundDelivery(False) {
+    fHaveVideoStreams = False;  // unless we add a video source
+}
+
+MPEG2TransportStreamFromESSource::~MPEG2TransportStreamFromESSource() {
+    doStopGettingFrames();
+    delete fInputSources;
+}
+
+void MPEG2TransportStreamFromESSource::doStopGettingFrames() {
+    // Stop each input source:
+    for(InputESSourceRecord *sourceRec = fInputSources; sourceRec != NULL; sourceRec = sourceRec->next()) {
+        sourceRec->inputSource()->stopGettingFrames();
+    }
+}
+
+void MPEG2TransportStreamFromESSource ::awaitNewBuffer(unsigned char *oldBuffer) {
+    InputESSourceRecord *sourceRec;
+    // Begin by resetting the old buffer:
+    if(oldBuffer != NULL) {
+        for(sourceRec = fInputSources; sourceRec != NULL; sourceRec = sourceRec->next()) {
+            if(sourceRec->buffer() == oldBuffer) {
+                sourceRec->reset();
+                break;
+            }
+        }
+        fAwaitingBackgroundDelivery = False;
+    }
+
+    if(isCurrentlyAwaitingData()) {
+        // Try to deliver one filled-in buffer to the client:
+        for(sourceRec = fInputSources; sourceRec != NULL; sourceRec = sourceRec->next()) {
+            if(sourceRec->deliverBufferToClient())
+                return;
+        }
+        fAwaitingBackgroundDelivery = True;
+    }
+
+    // No filled-in buffers are available. Ask each of our inputs for data:
+    for(sourceRec = fInputSources; sourceRec != NULL; sourceRec = sourceRec->next()) {
+        sourceRec->askForNewData();
+    }
+}
+
+void MPEG2TransportStreamFromESSource ::addNewInputSource(FramedSource *inputSource, u_int8_t streamId, int mpegVersion, int16_t PID) {
+    if(inputSource == NULL)
+        return;
+    fInputSources = new InputESSourceRecord(*this, inputSource, streamId, mpegVersion, fInputSources, PID);
+}
+
+////////// InputESSourceRecord implementation //////////
+
+InputESSourceRecord ::InputESSourceRecord(MPEG2TransportStreamFromESSource &parent, FramedSource *inputSource, u_int8_t streamId, int mpegVersion,
+                                          InputESSourceRecord *next, int16_t PID)
+    : fNext(next), fParent(parent), fInputSource(inputSource), fStreamId(streamId), fMPEGVersion(mpegVersion), fPID(PID) {
+    fInputBuffer = new unsigned char[INPUT_BUFFER_SIZE];
+    reset();
+}
+
+InputESSourceRecord::~InputESSourceRecord() {
+    Medium::close(fInputSource);
+    delete[] fInputBuffer;
+    delete fNext;
+}
+
+void InputESSourceRecord::askForNewData() {
+    if(fInputBufferInUse)
+        return;
+
+    if(fInputBufferBytesAvailable == 0) {
+        // Reset our buffer, by adding a simple PES header at the start:
+        fInputBuffer[0] = 0;
+        fInputBuffer[1] = 0;
+        fInputBuffer[2] = 1;
+        fInputBuffer[3] = fStreamId;
+        fInputBuffer[4] = 0;
+        fInputBuffer[5] = 0;  // fill in later with the length
+        fInputBuffer[6] = 0x80;
+        fInputBuffer[7] = 0x80;  // include a PTS
+        fInputBuffer[8] = 5;     // PES_header_data_length (enough for a PTS)
+        // fInputBuffer[9..13] will be the PTS; fill this in later
+        fInputBufferBytesAvailable = SIMPLE_PES_HEADER_SIZE;
+    }
+    if(fInputBufferBytesAvailable < TS_FROM_ES_LOW_WATER_MARK && !fInputSource->isCurrentlyAwaitingData()) {
+        // We don't yet have enough data in our buffer.  Arrange to read more:
+        fInputSource->getNextFrame(&fInputBuffer[fInputBufferBytesAvailable], INPUT_BUFFER_SIZE - fInputBufferBytesAvailable, afterGettingFrame, this,
+                                   FramedSource::handleClosure, &fParent);
+    }
+}
+
+Boolean InputESSourceRecord::deliverBufferToClient() {
+    if(fInputBufferInUse || fInputBufferBytesAvailable < TS_FROM_ES_LOW_WATER_MARK)
+        return False;
+
+    // Fill in the PES_packet_length field that we left unset before:
+    unsigned PES_packet_length = fInputBufferBytesAvailable - 6;
+    if(PES_packet_length > 0xFFFF) {
+        // Set the PES_packet_length field to 0.  This indicates an unbounded length (see ISO 13818-1, 2.4.3.7)
+        PES_packet_length = 0;
+    }
+    fInputBuffer[4] = PES_packet_length >> 8;
+    fInputBuffer[5] = PES_packet_length;
+
+    // Fill in the PES PTS (from our SCR):
+    fInputBuffer[9]  = 0x20 | (fSCR.highBit << 3) | (fSCR.remainingBits >> 29) | 0x01;
+    fInputBuffer[10] = fSCR.remainingBits >> 22;
+    fInputBuffer[11] = (fSCR.remainingBits >> 14) | 0x01;
+    fInputBuffer[12] = fSCR.remainingBits >> 7;
+    fInputBuffer[13] = (fSCR.remainingBits << 1) | 0x01;
+
+    fInputBufferInUse = True;
+
+    // Do the delivery:
+    fParent.handleNewBuffer(fInputBuffer, fInputBufferBytesAvailable, fMPEGVersion, fSCR, fPID);
+
+    return True;
+}
+
+void InputESSourceRecord ::afterGettingFrame(void *clientData, unsigned frameSize, unsigned numTruncatedBytes, struct timeval presentationTime,
+                                             unsigned /*durationInMicroseconds*/) {
+    InputESSourceRecord *source = (InputESSourceRecord *)clientData;
+    source->afterGettingFrame1(frameSize, numTruncatedBytes, presentationTime);
+}
+void InputESSourceRecord ::afterGettingFrame1(unsigned frameSize, unsigned numTruncatedBytes, struct timeval presentationTime) {
+    if(numTruncatedBytes > 0) {
+        fParent.envir()
+            << "MPEG2TransportStreamFromESSource: input buffer too small; increase \"MPEG2TransportStreamFromESSource::maxInputESFrameSize\" by at least "
+            << numTruncatedBytes << " bytes!\n";
+    }
+
+    if(fInputBufferBytesAvailable == SIMPLE_PES_HEADER_SIZE) {
+        // Use this presentationTime for our SCR:
+        fSCR.highBit       = ((presentationTime.tv_sec * 45000 + (presentationTime.tv_usec * 9) / 200) & 0x80000000) != 0;
+        fSCR.remainingBits = presentationTime.tv_sec * 90000 + (presentationTime.tv_usec * 9) / 100;
+        fSCR.extension     = (presentationTime.tv_usec * 9) % 100;
+#ifdef DEBUG_SCR
+        fprintf(stderr, "PES header: stream_id 0x%02x, pts: %u.%06u => SCR 0x%x%08x:%03x\n", fStreamId, (unsigned)presentationTime.tv_sec,
+                (unsigned)presentationTime.tv_usec, fSCR.highBit, fSCR.remainingBits, fSCR.extension);
+#endif
+    }
+
+    fInputBufferBytesAvailable += frameSize;
+
+    fParent.fPresentationTime = presentationTime;
+
+    // Now that we have new input data, check if we can deliver to the client:
+    if(fParent.fAwaitingBackgroundDelivery) {
+        fParent.fAwaitingBackgroundDelivery = False;
+        fParent.awaitNewBuffer(NULL);
+    }
+}
diff --git a/3rdparty/live555/src/liveMedia/MPEG2TransportStreamFromPESSource.cpp b/3rdparty/live555/src/liveMedia/MPEG2TransportStreamFromPESSource.cpp
new file mode 100644
index 00000000..b6671381
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/MPEG2TransportStreamFromPESSource.cpp
@@ -0,0 +1,59 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A filter for converting a stream of MPEG PES packets to a MPEG-2 Transport Stream
+// Implementation
+
+#include "MPEG2TransportStreamFromPESSource.hh"
+
+#define MAX_PES_PACKET_SIZE (6 + 65535)
+
+MPEG2TransportStreamFromPESSource *MPEG2TransportStreamFromPESSource ::createNew(UsageEnvironment &env, MPEG1or2DemuxedElementaryStream *inputSource) {
+    return new MPEG2TransportStreamFromPESSource(env, inputSource);
+}
+
+MPEG2TransportStreamFromPESSource ::MPEG2TransportStreamFromPESSource(UsageEnvironment &env, MPEG1or2DemuxedElementaryStream *inputSource)
+    : MPEG2TransportStreamMultiplexor(env), fInputSource(inputSource) {
+    fInputBuffer = new unsigned char[MAX_PES_PACKET_SIZE];
+}
+
+MPEG2TransportStreamFromPESSource::~MPEG2TransportStreamFromPESSource() {
+    Medium::close(fInputSource);
+    delete[] fInputBuffer;
+}
+
+void MPEG2TransportStreamFromPESSource::doStopGettingFrames() {
+    fInputSource->stopGettingFrames();
+}
+
+void MPEG2TransportStreamFromPESSource ::awaitNewBuffer(unsigned char * /*oldBuffer*/) {
+    fInputSource->getNextFrame(fInputBuffer, MAX_PES_PACKET_SIZE, afterGettingFrame, this, FramedSource::handleClosure, this);
+}
+
+void MPEG2TransportStreamFromPESSource ::afterGettingFrame(void *clientData, unsigned frameSize, unsigned numTruncatedBytes, struct timeval presentationTime,
+                                                           unsigned durationInMicroseconds) {
+    MPEG2TransportStreamFromPESSource *source = (MPEG2TransportStreamFromPESSource *)clientData;
+    source->afterGettingFrame1(frameSize, numTruncatedBytes, presentationTime, durationInMicroseconds);
+}
+
+void MPEG2TransportStreamFromPESSource ::afterGettingFrame1(unsigned frameSize, unsigned /*numTruncatedBytes*/, struct timeval /*presentationTime*/,
+                                                            unsigned /*durationInMicroseconds*/) {
+    if(frameSize < 4)
+        return;
+
+    handleNewBuffer(fInputBuffer, frameSize, fInputSource->mpegVersion(), fInputSource->lastSeenSCR());
+}
diff --git a/3rdparty/live555/src/liveMedia/MPEG2TransportStreamIndexFile.cpp b/3rdparty/live555/src/liveMedia/MPEG2TransportStreamIndexFile.cpp
new file mode 100644
index 00000000..96f8dba5
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/MPEG2TransportStreamIndexFile.cpp
@@ -0,0 +1,377 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A class that encapsulates MPEG-2 Transport Stream 'index files'/
+// These index files are used to implement 'trick play' operations
+// (seek-by-time, fast forward, reverse play) on Transport Stream files.
+//
+// Implementation
+
+#include "MPEG2TransportStreamIndexFile.hh"
+#include "InputFile.hh"
+
+MPEG2TransportStreamIndexFile ::MPEG2TransportStreamIndexFile(UsageEnvironment &env, char const *indexFileName)
+    : Medium(env),
+      fFileName(strDup(indexFileName)),
+      fFid(NULL),
+      fMPEGVersion(0),
+      fCurrentIndexRecordNum(0),
+      fCachedPCR(0.0f),
+      fCachedTSPacketNumber(0),
+      fNumIndexRecords(0) {
+    // Get the file size, to determine how many index records it contains:
+    u_int64_t indexFileSize = GetFileSize(indexFileName, NULL);
+    if(indexFileSize % INDEX_RECORD_SIZE != 0) {
+        env << "Warning: Size of the index file \"" << indexFileName << "\" (" << (unsigned)indexFileSize << ") is not a multiple of the index record size ("
+            << INDEX_RECORD_SIZE << ")\n";
+    }
+    fNumIndexRecords = (unsigned long)(indexFileSize / INDEX_RECORD_SIZE);
+}
+
+MPEG2TransportStreamIndexFile *MPEG2TransportStreamIndexFile ::createNew(UsageEnvironment &env, char const *indexFileName) {
+    if(indexFileName == NULL)
+        return NULL;
+    MPEG2TransportStreamIndexFile *indexFile = new MPEG2TransportStreamIndexFile(env, indexFileName);
+
+    // Reject empty or non-existent index files:
+    if(indexFile->getPlayingDuration() == 0.0f) {
+        delete indexFile;
+        indexFile = NULL;
+    }
+
+    return indexFile;
+}
+
+MPEG2TransportStreamIndexFile::~MPEG2TransportStreamIndexFile() {
+    closeFid();
+    delete[] fFileName;
+}
+
+void MPEG2TransportStreamIndexFile ::lookupTSPacketNumFromNPT(float &npt, unsigned long &tsPacketNumber, unsigned long &indexRecordNumber) {
+    if(npt <= 0.0 || fNumIndexRecords == 0) {  // Fast-track a common case:
+        npt            = 0.0f;
+        tsPacketNumber = indexRecordNumber = 0;
+        return;
+    }
+
+    // If "npt" is the same as the one that we last looked up, return its cached result:
+    if(npt == fCachedPCR) {
+        tsPacketNumber    = fCachedTSPacketNumber;
+        indexRecordNumber = fCachedIndexRecordNumber;
+        return;
+    }
+
+    // Search for the pair of neighboring index records whose PCR values span "npt".
+    // Use the 'regula-falsi' method.
+    Boolean       success = False;
+    unsigned long ixFound = 0;
+    do {
+        unsigned long ixLeft = 0, ixRight = fNumIndexRecords - 1;
+        float         pcrLeft = 0.0f, pcrRight;
+        if(!readIndexRecord(ixRight))
+            break;
+        pcrRight = pcrFromBuf();
+        if(npt > pcrRight)
+            npt = pcrRight;
+        // handle "npt" too large by seeking to the last frame of the file
+
+        while(ixRight - ixLeft > 1 && pcrLeft < npt && npt <= pcrRight) {
+            unsigned long ixNew = ixLeft + (unsigned long)(((npt - pcrLeft) / (pcrRight - pcrLeft)) * (ixRight - ixLeft));
+            if(ixNew == ixLeft || ixNew == ixRight) {
+                // use bisection instead:
+                ixNew = (ixLeft + ixRight) / 2;
+            }
+            if(!readIndexRecord(ixNew))
+                break;
+            float pcrNew = pcrFromBuf();
+            if(pcrNew < npt) {
+                pcrLeft = pcrNew;
+                ixLeft  = ixNew;
+            }
+            else {
+                pcrRight = pcrNew;
+                ixRight  = ixNew;
+            }
+        }
+        if(ixRight - ixLeft > 1 || npt <= pcrLeft || npt > pcrRight)
+            break;  // bad PCR values in index file?
+
+        ixFound = ixRight;
+        // "Rewind' until we reach the start of a Video Sequence or GOP header:
+        success = rewindToCleanPoint(ixFound);
+    } while(0);
+
+    if(success && readIndexRecord(ixFound)) {
+        // Return (and cache) information from record "ixFound":
+        npt = fCachedPCR = pcrFromBuf();
+        tsPacketNumber = fCachedTSPacketNumber = tsPacketNumFromBuf();
+        indexRecordNumber = fCachedIndexRecordNumber = ixFound;
+    }
+    else {
+        // An error occurred: Return the default values, for npt == 0:
+        npt            = 0.0f;
+        tsPacketNumber = indexRecordNumber = 0;
+    }
+    closeFid();
+}
+
+void MPEG2TransportStreamIndexFile ::lookupPCRFromTSPacketNum(unsigned long &tsPacketNumber, Boolean reverseToPreviousCleanPoint, float &pcr,
+                                                              unsigned long &indexRecordNumber) {
+    if(tsPacketNumber == 0 || fNumIndexRecords == 0) {  // Fast-track a common case:
+        pcr               = 0.0f;
+        indexRecordNumber = 0;
+        return;
+    }
+
+    // If "tsPacketNumber" is the same as the one that we last looked up, return its cached result:
+    if(tsPacketNumber == fCachedTSPacketNumber) {
+        pcr               = fCachedPCR;
+        indexRecordNumber = fCachedIndexRecordNumber;
+        return;
+    }
+
+    // Search for the pair of neighboring index records whose TS packet #s span "tsPacketNumber".
+    // Use the 'regula-falsi' method.
+    Boolean       success = False;
+    unsigned long ixFound = 0;
+    do {
+        unsigned long ixLeft = 0, ixRight = fNumIndexRecords - 1;
+        unsigned long tsLeft = 0, tsRight;
+        if(!readIndexRecord(ixRight))
+            break;
+        tsRight = tsPacketNumFromBuf();
+        if(tsPacketNumber > tsRight)
+            tsPacketNumber = tsRight;
+        // handle "tsPacketNumber" too large by seeking to the last frame of the file
+
+        while(ixRight - ixLeft > 1 && tsLeft < tsPacketNumber && tsPacketNumber <= tsRight) {
+            unsigned long ixNew = ixLeft + (unsigned long)(((tsPacketNumber - tsLeft) / (tsRight - tsLeft)) * (ixRight - ixLeft));
+            if(ixNew == ixLeft || ixNew == ixRight) {
+                // Use bisection instead:
+                ixNew = (ixLeft + ixRight) / 2;
+            }
+            if(!readIndexRecord(ixNew))
+                break;
+            unsigned long tsNew = tsPacketNumFromBuf();
+            if(tsNew < tsPacketNumber) {
+                tsLeft = tsNew;
+                ixLeft = ixNew;
+            }
+            else {
+                tsRight = tsNew;
+                ixRight = ixNew;
+            }
+        }
+        if(ixRight - ixLeft > 1 || tsPacketNumber <= tsLeft || tsPacketNumber > tsRight)
+            break;  // bad PCR values in index file?
+
+        ixFound = ixRight;
+        if(reverseToPreviousCleanPoint) {
+            // "Rewind' until we reach the start of a Video Sequence or GOP header:
+            success = rewindToCleanPoint(ixFound);
+        }
+        else {
+            success = True;
+        }
+    } while(0);
+
+    if(success && readIndexRecord(ixFound)) {
+        // Return (and cache) information from record "ixFound":
+        pcr = fCachedPCR      = pcrFromBuf();
+        fCachedTSPacketNumber = tsPacketNumFromBuf();
+        if(reverseToPreviousCleanPoint)
+            tsPacketNumber = fCachedTSPacketNumber;
+        indexRecordNumber = fCachedIndexRecordNumber = ixFound;
+    }
+    else {
+        // An error occurred: Return the default values, for tsPacketNumber == 0:
+        pcr               = 0.0f;
+        indexRecordNumber = 0;
+    }
+    closeFid();
+}
+
+Boolean MPEG2TransportStreamIndexFile ::readIndexRecordValues(unsigned long indexRecordNum, unsigned long &transportPacketNum, u_int8_t &offset, u_int8_t &size,
+                                                              float &pcr, u_int8_t &recordType) {
+    if(!readIndexRecord(indexRecordNum))
+        return False;
+
+    transportPacketNum = tsPacketNumFromBuf();
+    offset             = offsetFromBuf();
+    size               = sizeFromBuf();
+    pcr                = pcrFromBuf();
+    recordType         = recordTypeFromBuf();
+    return True;
+}
+
+float MPEG2TransportStreamIndexFile::getPlayingDuration() {
+    if(fNumIndexRecords == 0 || !readOneIndexRecord(fNumIndexRecords - 1))
+        return 0.0f;
+
+    return pcrFromBuf();
+}
+
+int MPEG2TransportStreamIndexFile::mpegVersion() {
+    if(fMPEGVersion != 0)
+        return fMPEGVersion;  // we already know it
+
+    // Read the first index record, and figure out the MPEG version from its type:
+    if(!readOneIndexRecord(0))
+        return 0;  // unknown; perhaps the indecx file is empty?
+
+    setMPEGVersionFromRecordType(recordTypeFromBuf());
+    return fMPEGVersion;
+}
+
+Boolean MPEG2TransportStreamIndexFile::openFid() {
+    if(fFid == NULL && fFileName != NULL) {
+        if((fFid = OpenInputFile(envir(), fFileName)) != NULL) {
+            fCurrentIndexRecordNum = 0;
+        }
+    }
+
+    return fFid != NULL;
+}
+
+Boolean MPEG2TransportStreamIndexFile::seekToIndexRecord(unsigned long indexRecordNumber) {
+    if(!openFid())
+        return False;
+
+    if(indexRecordNumber == fCurrentIndexRecordNum)
+        return True;  // we're already there
+
+    if(SeekFile64(fFid, (int64_t)(indexRecordNumber * INDEX_RECORD_SIZE), SEEK_SET) != 0)
+        return False;
+    fCurrentIndexRecordNum = indexRecordNumber;
+    return True;
+}
+
+Boolean MPEG2TransportStreamIndexFile::readIndexRecord(unsigned long indexRecordNum) {
+    do {
+        if(!seekToIndexRecord(indexRecordNum))
+            break;
+        if(fread(fBuf, INDEX_RECORD_SIZE, 1, fFid) != 1)
+            break;
+        ++fCurrentIndexRecordNum;
+
+        return True;
+    } while(0);
+
+    return False;  // an error occurred
+}
+
+Boolean MPEG2TransportStreamIndexFile::readOneIndexRecord(unsigned long indexRecordNum) {
+    Boolean result = readIndexRecord(indexRecordNum);
+    closeFid();
+
+    return result;
+}
+
+void MPEG2TransportStreamIndexFile::closeFid() {
+    if(fFid != NULL) {
+        CloseInputFile(fFid);
+        fFid = NULL;
+    }
+}
+
+float MPEG2TransportStreamIndexFile::pcrFromBuf() {
+    unsigned pcr_int  = (fBuf[5] << 16) | (fBuf[4] << 8) | fBuf[3];
+    u_int8_t pcr_frac = fBuf[6];
+    return pcr_int + pcr_frac / 256.0f;
+}
+
+unsigned long MPEG2TransportStreamIndexFile::tsPacketNumFromBuf() {
+    return (fBuf[10] << 24) | (fBuf[9] << 16) | (fBuf[8] << 8) | fBuf[7];
+}
+
+void MPEG2TransportStreamIndexFile::setMPEGVersionFromRecordType(u_int8_t recordType) {
+    if(fMPEGVersion != 0)
+        return;  // we already know it
+
+    u_int8_t const recordTypeWithoutStartBit = recordType & ~0x80;
+    if(recordTypeWithoutStartBit >= 1 && recordTypeWithoutStartBit <= 4)
+        fMPEGVersion = 2;
+    else if(recordTypeWithoutStartBit >= 5 && recordTypeWithoutStartBit <= 10)
+        fMPEGVersion = 5;
+    // represents H.264
+    else if(recordTypeWithoutStartBit >= 11 && recordTypeWithoutStartBit <= 16)
+        fMPEGVersion = 6;
+    // represents H.265
+}
+
+Boolean MPEG2TransportStreamIndexFile::rewindToCleanPoint(unsigned long &ixFound) {
+    Boolean success = False;  // until we learn otherwise
+
+    while(ixFound > 0) {
+        if(!readIndexRecord(ixFound))
+            break;
+
+        u_int8_t recordType = recordTypeFromBuf();
+        setMPEGVersionFromRecordType(recordType);
+
+        // A 'clean point' is the start of a 'frame' from which a decoder can cleanly resume
+        // handling the stream.  For H.264, this is a SPS.  For H.265, this is a VPS.
+        // For MPEG-2, this is a Video Sequence Header, or a GOP.
+
+        if((recordType & 0x80) != 0) {  // This is the start of a 'frame'
+            recordType &= ~0x80;        // remove the 'start of frame' bit
+            if(fMPEGVersion == 5) {     // H.264
+                if(recordType == 5 /*SPS*/) {
+                    success = True;
+                    break;
+                }
+            }
+            else if(fMPEGVersion == 6) {  // H.265
+                if(recordType == 11 /*VPS*/) {
+                    success = True;
+                    break;
+                }
+            }
+            else {  // MPEG-1, 2, or 4
+                if(recordType == 1 /*VSH*/) {
+                    success = True;
+                    break;
+                }
+                else if(recordType == 2 /*GOP*/) {
+                    // Hack: If the preceding record is for a Video Sequence Header, then use it instead:
+                    unsigned long newIxFound = ixFound;
+
+                    while(--newIxFound > 0) {
+                        if(!readIndexRecord(newIxFound))
+                            break;
+                        recordType = recordTypeFromBuf();
+                        if((recordType & 0x7F) != 1)
+                            break;                      // not a Video Sequence Header
+                        if((recordType & 0x80) != 0) {  // this is the start of the VSH; use it
+                            ixFound = newIxFound;
+                            break;
+                        }
+                    }
+                }
+                success = True;
+                break;
+            }
+        }
+
+        // Keep checking, from the previous record:
+        --ixFound;
+    }
+    if(ixFound == 0)
+        success = True;  // use record 0 anyway
+
+    return success;
+}
diff --git a/3rdparty/live555/src/liveMedia/MPEG2TransportStreamMultiplexor.cpp b/3rdparty/live555/src/liveMedia/MPEG2TransportStreamMultiplexor.cpp
new file mode 100644
index 00000000..d7983238
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/MPEG2TransportStreamMultiplexor.cpp
@@ -0,0 +1,459 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A class for generating MPEG-2 Transport Stream from one or more input
+// Elementary Stream data sources
+// Implementation
+
+#include "MPEG2TransportStreamMultiplexor.hh"
+
+#define TRANSPORT_PACKET_SIZE 188
+
+#define PAT_PERIOD_IF_UNTIMED 100  // # of packets between Program Association Tables (if not timed)
+#define PMT_PERIOD_IF_UNTIMED 500  // # of packets between Program Map Tables (if not timed)
+
+void MPEG2TransportStreamMultiplexor ::setTimedSegmentation(unsigned segmentationDuration, onEndOfSegmentFunc *onEndOfSegmentFunc,
+                                                            void *onEndOfSegmentClientData) {
+    fSegmentationDuration     = segmentationDuration;
+    fOnEndOfSegmentFunc       = onEndOfSegmentFunc;
+    fOnEndOfSegmentClientData = onEndOfSegmentClientData;
+}
+
+MPEG2TransportStreamMultiplexor ::MPEG2TransportStreamMultiplexor(UsageEnvironment &env)
+    : FramedSource(env),
+      fHaveVideoStreams(True /*by default*/),
+      fOutgoingPacketCounter(0),
+      fProgramMapVersion(0xFF),
+      fPreviousInputProgramMapVersion(0xFF),
+      fCurrentInputProgramMapVersion(0),
+      fPCR_PID(0),
+      fCurrentPID(0),
+      fInputBuffer(NULL),
+      fInputBufferSize(0),
+      fInputBufferBytesUsed(0),
+      fIsFirstAdaptationField(True),
+      fSegmentationDuration(0),
+      fSegmentationIndication(1),
+      fCurrentSegmentDuration(0.0),
+      fPreviousPTS(0.0),
+      fOnEndOfSegmentFunc(NULL),
+      fOnEndOfSegmentClientData(NULL) {
+    for(unsigned i = 0; i < PID_TABLE_SIZE; ++i) {
+        fPIDState[i].counter    = 0;
+        fPIDState[i].streamType = 0;
+    }
+}
+
+MPEG2TransportStreamMultiplexor::~MPEG2TransportStreamMultiplexor() {}
+
+Boolean MPEG2TransportStreamMultiplexor::isMPEG2TransportStreamMultiplexor() const {
+    return True;
+}
+
+void MPEG2TransportStreamMultiplexor::doGetNextFrame() {
+    if(fInputBufferBytesUsed >= fInputBufferSize) {
+        // No more bytes are available from the current buffer.
+        // Arrange to read a new one.
+        awaitNewBuffer(fInputBuffer);
+        return;
+    }
+
+    do {
+        // Periodically return a Program Association Table packet instead:
+        if((segmentationIsTimed() && fSegmentationIndication == 1) || (!segmentationIsTimed() && fOutgoingPacketCounter % PAT_PERIOD_IF_UNTIMED == 0)) {
+            ++fOutgoingPacketCounter;
+            deliverPATPacket();
+            fSegmentationIndication = 2;  // for next time
+            break;
+        }
+        ++fOutgoingPacketCounter;
+
+        // Periodically (or when we see a new PID) return a Program Map Table instead:
+        Boolean programMapHasChanged = fCurrentInputProgramMapVersion != fPreviousInputProgramMapVersion;
+        if(programMapHasChanged || (segmentationIsTimed() && fSegmentationIndication == 2)
+           || (!segmentationIsTimed() && fOutgoingPacketCounter % PMT_PERIOD_IF_UNTIMED == 0)) {
+            if(programMapHasChanged) {  // reset values for next time:
+                fPreviousInputProgramMapVersion = fCurrentInputProgramMapVersion;
+            }
+            deliverPMTPacket(programMapHasChanged);
+            fSegmentationIndication = 0;  // for next time
+            break;
+        }
+
+        // Normal case: Deliver (or continue delivering) the recently-read data:
+        deliverDataToClient(fCurrentPID, fInputBuffer, fInputBufferSize, fInputBufferBytesUsed);
+    } while(0);
+
+    // NEED TO SET fPresentationTime, durationInMicroseconds #####
+    // Complete the delivery to the client:
+    if((fOutgoingPacketCounter % 10) == 0) {
+        // To avoid excessive recursion (and stack overflow) caused by excessively large input frames,
+        // occasionally return to the event loop to do this:
+        nextTask() = envir().taskScheduler().scheduleDelayedTask(0, (TaskFunc *)FramedSource::afterGetting, this);
+    }
+    else {
+        afterGetting(this);
+    }
+}
+
+void MPEG2TransportStreamMultiplexor ::handleNewBuffer(unsigned char *buffer, unsigned bufferSize, int mpegVersion, MPEG1or2Demux::SCR scr, int16_t PID) {
+    if(bufferSize < 4)
+        return;
+    fInputBuffer          = buffer;
+    fInputBufferSize      = bufferSize;
+    fInputBufferBytesUsed = 0;
+
+    u_int8_t stream_id = fInputBuffer[3];
+    // Use "stream_id" directly as our PID.
+    // Also, figure out the Program Map 'stream type' from this.
+    if(stream_id == 0xBE) {  // padding_stream; ignore
+        fInputBufferSize = 0;
+    }
+    else if(stream_id == 0xBC) {  // program_stream_map
+        setProgramStreamMap(fInputBufferSize);
+        fInputBufferSize = 0;  // then, ignore the buffer
+    }
+    else {
+        if(PID == -1)
+            fCurrentPID = stream_id;
+        else
+            fCurrentPID = PID;
+
+        // Set the stream's type:
+        u_int8_t &streamType = fPIDState[fCurrentPID].streamType;  // alias
+
+        if(streamType == 0) {
+            // Instead, set the stream's type to default values, based on whether
+            // the stream is audio or video, and whether it's MPEG-1 or MPEG-2:
+            if((stream_id & 0xF0) == 0xE0) {  // video
+                streamType = mpegVersion == 1 ? 1 : mpegVersion == 2 ? 2 : mpegVersion == 4 ? 0x10 : mpegVersion == 5 /*H.264*/ ? 0x1B : 0x24 /*assume H.265*/;
+            }
+            else if((stream_id & 0xE0) == 0xC0) {  // audio
+                streamType = mpegVersion == 1 ? 3 : mpegVersion == 2 ? 4 : mpegVersion == 3 ? 6 : 0xF;
+            }
+            else if(stream_id == 0xBD) {  // private_stream1 (usually AC-3 or Opus)
+                streamType = 0x06;        // for DVB or Opus; for ATSC, use 0x81
+            }
+            else {                  // something else
+                streamType = 0x81;  // private
+            }
+        }
+
+        if(fPCR_PID == 0) {  // set it to this stream, if it's appropriate:
+            if((!fHaveVideoStreams && (streamType == 3 || streamType == 4 || streamType == 6 || streamType == 0xF)) /* audio stream */
+               || (streamType == 1 || streamType == 2 || streamType == 0x10 || streamType == 0x1B || streamType == 0x24) /* video stream */) {
+                fPCR_PID = fCurrentPID;  // use this stream's SCR for PCR
+            }
+        }
+        if(fCurrentPID == fPCR_PID) {
+            // Record the input's current SCR timestamp, for use as our PCR:
+            fPCR = scr;
+        }
+    }
+
+    // Now that we have new input data, retry the last delivery to the client:
+    doGetNextFrame();
+}
+
+void MPEG2TransportStreamMultiplexor ::deliverDataToClient(u_int16_t pid, unsigned char *buffer, unsigned bufferSize, unsigned &startPositionInBuffer) {
+    // Construct a new Transport packet, and deliver it to the client:
+    if(fMaxSize < TRANSPORT_PACKET_SIZE) {
+        fFrameSize         = 0;  // the client hasn't given us enough space; deliver nothing
+        fNumTruncatedBytes = TRANSPORT_PACKET_SIZE;
+    }
+    else {
+        fFrameSize                = TRANSPORT_PACKET_SIZE;
+        Boolean        willAddPCR = pid == fPCR_PID && startPositionInBuffer == 0 && !(fPCR.highBit == 0 && fPCR.remainingBits == 0 && fPCR.extension == 0);
+        unsigned const numBytesAvailable = bufferSize - startPositionInBuffer;
+        unsigned       numHeaderBytes    = 4;  // by default
+        unsigned       numPCRBytes       = 0;  // by default
+        unsigned       numPaddingBytes   = 0;  // by default
+        unsigned       numDataBytes;
+        u_int8_t       adaptation_field_control;
+        if(willAddPCR) {
+            adaptation_field_control = 0x30;
+            numHeaderBytes += 2;  // for the "adaptation_field_length" and flags
+            numPCRBytes = 6;
+            if(numBytesAvailable >= TRANSPORT_PACKET_SIZE - numHeaderBytes - numPCRBytes) {
+                numDataBytes = TRANSPORT_PACKET_SIZE - numHeaderBytes - numPCRBytes;
+            }
+            else {
+                numDataBytes    = numBytesAvailable;
+                numPaddingBytes = TRANSPORT_PACKET_SIZE - numHeaderBytes - numPCRBytes - numDataBytes;
+            }
+        }
+        else if(numBytesAvailable >= TRANSPORT_PACKET_SIZE - numHeaderBytes) {
+            // This is the common case
+            adaptation_field_control = 0x10;
+            numDataBytes             = TRANSPORT_PACKET_SIZE - numHeaderBytes;
+        }
+        else {
+            adaptation_field_control = 0x30;
+            ++numHeaderBytes;  // for the "adaptation_field_length"
+            // ASSERT: numBytesAvailable <= TRANSPORT_PACKET_SIZE - numHeaderBytes
+            numDataBytes = numBytesAvailable;
+            if(numDataBytes < TRANSPORT_PACKET_SIZE - numHeaderBytes) {
+                ++numHeaderBytes;  // for the adaptation field flags
+                numPaddingBytes = TRANSPORT_PACKET_SIZE - numHeaderBytes - numDataBytes;
+            }
+        }
+        // ASSERT: numHeaderBytes+numPCRBytes+numPaddingBytes+numDataBytes
+        //         == TRANSPORT_PACKET_SIZE
+
+        // Fill in the header of the Transport Stream packet:
+        unsigned char *header = fTo;
+        *header++             = 0x47;  // sync_byte
+        *header++             = ((startPositionInBuffer == 0) ? 0x40 : 0x00) | (pid >> 8);
+        // transport_error_indicator, payload_unit_start_indicator, transport_priority,
+        // first 5 bits of PID
+        *header++ = pid;
+        // last 8 bits of PID
+        unsigned &continuity_counter = fPIDState[pid].counter;  // alias
+        *header++                    = adaptation_field_control | (continuity_counter & 0x0F);
+        // transport_scrambling_control, adaptation_field_control, continuity_counter
+        ++continuity_counter;
+        if(adaptation_field_control == 0x30) {
+            // Add an adaptation field:
+            u_int8_t adaptation_field_length = (numHeaderBytes == 5) ? 0 : 1 + numPCRBytes + numPaddingBytes;
+            *header++                        = adaptation_field_length;
+            if(numHeaderBytes > 5) {
+                u_int8_t flags = willAddPCR ? 0x10 : 0x00;
+                if(fIsFirstAdaptationField) {
+                    flags |= 0x80;  // discontinuity_indicator
+                    fIsFirstAdaptationField = False;
+                }
+                *header++ = flags;
+                if(willAddPCR) {
+                    u_int32_t pcrHigh32Bits = (fPCR.highBit << 31) | (fPCR.remainingBits >> 1);
+                    u_int8_t  pcrLowBit     = fPCR.remainingBits & 1;
+                    u_int8_t  extHighBit    = (fPCR.extension & 0x100) >> 8;
+                    *header++               = pcrHigh32Bits >> 24;
+                    *header++               = pcrHigh32Bits >> 16;
+                    *header++               = pcrHigh32Bits >> 8;
+                    *header++               = pcrHigh32Bits;
+                    *header++               = (pcrLowBit << 7) | 0x7E | extHighBit;
+                    *header++               = (u_int8_t)fPCR.extension;  // low 8 bits of extension
+
+                    if(fSegmentationDuration > 0) {
+                        // Use the PCR to compute the duration of the segment so far, to check whether
+                        // segmentation needs to occur now:
+                        double pts = fPCR.highBit ? 0x80000000 / 45000.0 : 0.0;
+                        pts += fPCR.remainingBits / 90000.0;
+                        pts += fPCR.extension / 27000000.0;
+
+                        double lastSubSegmentDuration = (fPreviousPTS == 0.0) || (pts < fPreviousPTS) ? 0.0 : pts - fPreviousPTS;
+                        fCurrentSegmentDuration += lastSubSegmentDuration;
+
+                        // Check whether we need to segment the stream now:
+                        if(fCurrentSegmentDuration > (double)fSegmentationDuration
+                           || fCurrentSegmentDuration + lastSubSegmentDuration > (double)fSegmentationDuration) {
+                            // It's time to segment the stream.
+                            if(fOnEndOfSegmentFunc != NULL) {
+                                (*fOnEndOfSegmentFunc)(fOnEndOfSegmentClientData, fCurrentSegmentDuration);
+                            }
+
+                            fCurrentSegmentDuration = 0.0;  // for next time
+                            fSegmentationIndication = 1;    // output a PAT next
+                        }
+
+                        fPreviousPTS = pts;  // for next time
+                    }
+                }
+            }
+        }
+
+        // Add any padding bytes:
+        for(unsigned i = 0; i < numPaddingBytes; ++i)
+            *header++ = 0xFF;
+
+        // Finally, add the data bytes:
+        memmove(header, &buffer[startPositionInBuffer], numDataBytes);
+        startPositionInBuffer += numDataBytes;
+    }
+}
+
+#define PAT_PID 0
+#ifndef OUR_PROGRAM_NUMBER
+#define OUR_PROGRAM_NUMBER 1
+#endif
+#define OUR_PROGRAM_MAP_PID 0x1000
+
+void MPEG2TransportStreamMultiplexor::deliverPATPacket() {
+    // First, create a new buffer for the PAT packet:
+    unsigned const patSize   = TRANSPORT_PACKET_SIZE - 4;  // allow for the 4-byte header
+    unsigned char *patBuffer = new unsigned char[patSize];
+
+    // and fill it in:
+    unsigned char *pat = patBuffer;
+    *pat++             = 0;     // pointer_field
+    *pat++             = 0;     // table_id
+    *pat++             = 0xB0;  // section_syntax_indicator; 0; reserved, section_length (high)
+    *pat++             = 13;    // section_length (low)
+    *pat++             = 0;
+    *pat++             = 1;     // transport_stream_id
+    *pat++             = 0xC1;  // reserved; version_number; current_next_indicator
+    *pat++             = 0;     // section_number
+    *pat++             = 0;     // last_section_number
+    *pat++             = OUR_PROGRAM_NUMBER >> 8;
+    *pat++             = OUR_PROGRAM_NUMBER;                 // program_number
+    *pat++             = 0xE0 | (OUR_PROGRAM_MAP_PID >> 8);  // reserved; program_map_PID (high)
+    *pat++             = OUR_PROGRAM_MAP_PID & 0xFF;         // program_map_PID (low)
+
+    // Compute the CRC from the bytes we currently have (not including "pointer_field"):
+    u_int32_t crc = calculateCRC(patBuffer + 1, pat - (patBuffer + 1));
+    *pat++        = crc >> 24;
+    *pat++        = crc >> 16;
+    *pat++        = crc >> 8;
+    *pat++        = crc;
+
+    // Fill in the rest of the packet with padding bytes:
+    while(pat < &patBuffer[patSize])
+        *pat++ = 0xFF;
+
+    // Deliver the packet:
+    unsigned startPosition = 0;
+    deliverDataToClient(PAT_PID, patBuffer, patSize, startPosition);
+
+    // Finally, remove the new buffer:
+    delete[] patBuffer;
+}
+
+void MPEG2TransportStreamMultiplexor::deliverPMTPacket(Boolean hasChanged) {
+    if(hasChanged)
+        ++fProgramMapVersion;
+
+    // First, create a new buffer for the PMT packet:
+    unsigned const pmtSize   = TRANSPORT_PACKET_SIZE - 4;  // allow for the 4-byte header
+    unsigned char *pmtBuffer = new unsigned char[pmtSize];
+
+    // and fill it in:
+    unsigned char *pmt               = pmtBuffer;
+    *pmt++                           = 0;     // pointer_field
+    *pmt++                           = 2;     // table_id
+    *pmt++                           = 0xB0;  // section_syntax_indicator; 0; reserved, section_length (high)
+    unsigned char *section_lengthPtr = pmt;   // save for later
+    *pmt++                           = 0;     // section_length (low) (fill in later)
+    *pmt++                           = OUR_PROGRAM_NUMBER >> 8;
+    *pmt++                           = OUR_PROGRAM_NUMBER;                         // program_number
+    *pmt++                           = 0xC1 | ((fProgramMapVersion & 0x1F) << 1);  // reserved; version_number; current_next_indicator
+    *pmt++                           = 0;                                          // section_number
+    *pmt++                           = 0;                                          // last_section_number
+    *pmt++                           = 0xE0 | (fPCR_PID >> 8);                     // reserved; PCR_PID (high)
+    *pmt++                           = fPCR_PID;                                   // PCR_PID (low)
+    *pmt++                           = 0xF0;                                       // reserved; program_info_length (high)
+    *pmt++                           = 0;                                          // program_info_length (low)
+    for(int pid = 0; pid < PID_TABLE_SIZE; ++pid) {
+        if(fPIDState[pid].streamType != 0) {
+            // This PID gets recorded in the table
+            *pmt++ = fPIDState[pid].streamType;
+            *pmt++ = 0xE0 | (pid >> 8);  // reserved; elementary_pid (high)
+            *pmt++ = pid;                // elementary_pid (low)
+            *pmt++ = 0xF0;               // reserved; ES_info_length (high)
+            *pmt++ = 0;                  // ES_info_length (low)
+        }
+    }
+    unsigned section_length = pmt - (section_lengthPtr + 1) + 4 /*for CRC*/;
+    *section_lengthPtr      = section_length;
+
+    // Compute the CRC from the bytes we currently have (not including "pointer_field"):
+    u_int32_t crc = calculateCRC(pmtBuffer + 1, pmt - (pmtBuffer + 1));
+    *pmt++        = crc >> 24;
+    *pmt++        = crc >> 16;
+    *pmt++        = crc >> 8;
+    *pmt++        = crc;
+
+    // Fill in the rest of the packet with padding bytes:
+    while(pmt < &pmtBuffer[pmtSize])
+        *pmt++ = 0xFF;
+
+    // Deliver the packet:
+    unsigned startPosition = 0;
+    deliverDataToClient(OUR_PROGRAM_MAP_PID, pmtBuffer, pmtSize, startPosition);
+
+    // Finally, remove the new buffer:
+    delete[] pmtBuffer;
+}
+
+void MPEG2TransportStreamMultiplexor::setProgramStreamMap(unsigned frameSize) {
+    if(frameSize <= 16)
+        return;  // program_stream_map is too small to be useful
+    if(frameSize > 0xFF)
+        return;  // program_stream_map is too large
+
+    u_int16_t program_stream_map_length = (fInputBuffer[4] << 8) | fInputBuffer[5];
+    if((u_int16_t)frameSize > 6 + program_stream_map_length) {
+        frameSize = 6 + program_stream_map_length;
+    }
+
+    u_int8_t versionByte = fInputBuffer[6];
+    if((versionByte & 0x80) == 0)
+        return;  // "current_next_indicator" is not set
+    fCurrentInputProgramMapVersion = versionByte & 0x1F;
+
+    u_int16_t program_stream_info_length = (fInputBuffer[8] << 8) | fInputBuffer[9];
+    unsigned  offset                     = 10 + program_stream_info_length;  // skip over 'descriptors'
+
+    u_int16_t elementary_stream_map_length = (fInputBuffer[offset] << 8) | fInputBuffer[offset + 1];
+    offset += 2;
+    frameSize -= 4;  // sizeof CRC_32
+    if(frameSize > offset + elementary_stream_map_length) {
+        frameSize = offset + elementary_stream_map_length;
+    }
+
+    while(offset + 4 <= frameSize) {
+        u_int8_t stream_type          = fInputBuffer[offset];
+        u_int8_t elementary_stream_id = fInputBuffer[offset + 1];
+
+        fPIDState[elementary_stream_id].streamType = stream_type;
+
+        u_int16_t elementary_stream_info_length = (fInputBuffer[offset + 2] << 8) | fInputBuffer[offset + 3];
+        offset += 4 + elementary_stream_info_length;
+    }
+}
+
+static u_int32_t const CRC32[256] = {
+    0x00000000, 0x04c11db7, 0x09823b6e, 0x0d4326d9, 0x130476dc, 0x17c56b6b, 0x1a864db2, 0x1e475005, 0x2608edb8, 0x22c9f00f, 0x2f8ad6d6, 0x2b4bcb61, 0x350c9b64,
+    0x31cd86d3, 0x3c8ea00a, 0x384fbdbd, 0x4c11db70, 0x48d0c6c7, 0x4593e01e, 0x4152fda9, 0x5f15adac, 0x5bd4b01b, 0x569796c2, 0x52568b75, 0x6a1936c8, 0x6ed82b7f,
+    0x639b0da6, 0x675a1011, 0x791d4014, 0x7ddc5da3, 0x709f7b7a, 0x745e66cd, 0x9823b6e0, 0x9ce2ab57, 0x91a18d8e, 0x95609039, 0x8b27c03c, 0x8fe6dd8b, 0x82a5fb52,
+    0x8664e6e5, 0xbe2b5b58, 0xbaea46ef, 0xb7a96036, 0xb3687d81, 0xad2f2d84, 0xa9ee3033, 0xa4ad16ea, 0xa06c0b5d, 0xd4326d90, 0xd0f37027, 0xddb056fe, 0xd9714b49,
+    0xc7361b4c, 0xc3f706fb, 0xceb42022, 0xca753d95, 0xf23a8028, 0xf6fb9d9f, 0xfbb8bb46, 0xff79a6f1, 0xe13ef6f4, 0xe5ffeb43, 0xe8bccd9a, 0xec7dd02d, 0x34867077,
+    0x30476dc0, 0x3d044b19, 0x39c556ae, 0x278206ab, 0x23431b1c, 0x2e003dc5, 0x2ac12072, 0x128e9dcf, 0x164f8078, 0x1b0ca6a1, 0x1fcdbb16, 0x018aeb13, 0x054bf6a4,
+    0x0808d07d, 0x0cc9cdca, 0x7897ab07, 0x7c56b6b0, 0x71159069, 0x75d48dde, 0x6b93dddb, 0x6f52c06c, 0x6211e6b5, 0x66d0fb02, 0x5e9f46bf, 0x5a5e5b08, 0x571d7dd1,
+    0x53dc6066, 0x4d9b3063, 0x495a2dd4, 0x44190b0d, 0x40d816ba, 0xaca5c697, 0xa864db20, 0xa527fdf9, 0xa1e6e04e, 0xbfa1b04b, 0xbb60adfc, 0xb6238b25, 0xb2e29692,
+    0x8aad2b2f, 0x8e6c3698, 0x832f1041, 0x87ee0df6, 0x99a95df3, 0x9d684044, 0x902b669d, 0x94ea7b2a, 0xe0b41de7, 0xe4750050, 0xe9362689, 0xedf73b3e, 0xf3b06b3b,
+    0xf771768c, 0xfa325055, 0xfef34de2, 0xc6bcf05f, 0xc27dede8, 0xcf3ecb31, 0xcbffd686, 0xd5b88683, 0xd1799b34, 0xdc3abded, 0xd8fba05a, 0x690ce0ee, 0x6dcdfd59,
+    0x608edb80, 0x644fc637, 0x7a089632, 0x7ec98b85, 0x738aad5c, 0x774bb0eb, 0x4f040d56, 0x4bc510e1, 0x46863638, 0x42472b8f, 0x5c007b8a, 0x58c1663d, 0x558240e4,
+    0x51435d53, 0x251d3b9e, 0x21dc2629, 0x2c9f00f0, 0x285e1d47, 0x36194d42, 0x32d850f5, 0x3f9b762c, 0x3b5a6b9b, 0x0315d626, 0x07d4cb91, 0x0a97ed48, 0x0e56f0ff,
+    0x1011a0fa, 0x14d0bd4d, 0x19939b94, 0x1d528623, 0xf12f560e, 0xf5ee4bb9, 0xf8ad6d60, 0xfc6c70d7, 0xe22b20d2, 0xe6ea3d65, 0xeba91bbc, 0xef68060b, 0xd727bbb6,
+    0xd3e6a601, 0xdea580d8, 0xda649d6f, 0xc423cd6a, 0xc0e2d0dd, 0xcda1f604, 0xc960ebb3, 0xbd3e8d7e, 0xb9ff90c9, 0xb4bcb610, 0xb07daba7, 0xae3afba2, 0xaafbe615,
+    0xa7b8c0cc, 0xa379dd7b, 0x9b3660c6, 0x9ff77d71, 0x92b45ba8, 0x9675461f, 0x8832161a, 0x8cf30bad, 0x81b02d74, 0x857130c3, 0x5d8a9099, 0x594b8d2e, 0x5408abf7,
+    0x50c9b640, 0x4e8ee645, 0x4a4ffbf2, 0x470cdd2b, 0x43cdc09c, 0x7b827d21, 0x7f436096, 0x7200464f, 0x76c15bf8, 0x68860bfd, 0x6c47164a, 0x61043093, 0x65c52d24,
+    0x119b4be9, 0x155a565e, 0x18197087, 0x1cd86d30, 0x029f3d35, 0x065e2082, 0x0b1d065b, 0x0fdc1bec, 0x3793a651, 0x3352bbe6, 0x3e119d3f, 0x3ad08088, 0x2497d08d,
+    0x2056cd3a, 0x2d15ebe3, 0x29d4f654, 0xc5a92679, 0xc1683bce, 0xcc2b1d17, 0xc8ea00a0, 0xd6ad50a5, 0xd26c4d12, 0xdf2f6bcb, 0xdbee767c, 0xe3a1cbc1, 0xe760d676,
+    0xea23f0af, 0xeee2ed18, 0xf0a5bd1d, 0xf464a0aa, 0xf9278673, 0xfde69bc4, 0x89b8fd09, 0x8d79e0be, 0x803ac667, 0x84fbdbd0, 0x9abc8bd5, 0x9e7d9662, 0x933eb0bb,
+    0x97ffad0c, 0xafb010b1, 0xab710d06, 0xa6322bdf, 0xa2f33668, 0xbcb4666d, 0xb8757bda, 0xb5365d03, 0xb1f740b4
+};
+
+u_int32_t calculateCRC(u_int8_t const *data, unsigned dataLength, u_int32_t initialValue) {
+    u_int32_t crc = initialValue;
+
+    while(dataLength-- > 0) {
+        crc = (crc << 8) ^ CRC32[(crc >> 24) ^ (u_int32_t)(*data++)];
+    }
+
+    return crc;
+}
diff --git a/3rdparty/live555/src/liveMedia/MPEG2TransportStreamParser.cpp b/3rdparty/live555/src/liveMedia/MPEG2TransportStreamParser.cpp
new file mode 100644
index 00000000..3bb100e6
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/MPEG2TransportStreamParser.cpp
@@ -0,0 +1,330 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A parser for a MPEG Transport Stream
+// Implementation
+
+#include "MPEG2TransportStreamParser.hh"
+
+#define NUM_PIDS 0x10000
+
+StreamType StreamTypes[0x100];
+
+MPEG2TransportStreamParser ::MPEG2TransportStreamParser(FramedSource *inputSource, FramedSource::onCloseFunc *onEndFunc, void *onEndClientData)
+    : StreamParser(inputSource, onEndFunc, onEndClientData, continueParsing, this),
+      fInputSource(inputSource),
+      fAmCurrentlyParsing(False),
+      fOnEndFunc(onEndFunc),
+      fOnEndClientData(onEndClientData),
+      fLastSeenPCR(0.0) {
+    if(StreamTypes[0x01].dataType == StreamType::UNKNOWN) {  // initialize array with known values
+        StreamTypes[0x01] = StreamType("MPEG-1 video", StreamType::VIDEO, ".mpv");
+        StreamTypes[0x02] = StreamType("MPEG-2 video", StreamType::VIDEO, ".mpv");
+        StreamTypes[0x03] = StreamType("MPEG-1 audio", StreamType::AUDIO, ".mpa");
+        StreamTypes[0x04] = StreamType("MPEG-2 audio", StreamType::AUDIO, ".mpa");
+        StreamTypes[0x05] = StreamType("privately-defined data", StreamType::DATA);
+        StreamTypes[0x06] = StreamType("privately-defined data", StreamType::DATA);
+        StreamTypes[0x0F] = StreamType("AAC audio", StreamType::AUDIO, ".aac");
+        StreamTypes[0x10] = StreamType("MPEG-4 H.263 based video", StreamType::VIDEO, ".mpv");
+        StreamTypes[0x1B] = StreamType("H.264 video", StreamType::VIDEO, ".h264");
+        StreamTypes[0x1C] = StreamType("MPEG-4 raw audio", StreamType::AUDIO, ".mpa");
+        StreamTypes[0x1D] = StreamType("MPEG-4 text", StreamType::TEXT, ".txt");
+        StreamTypes[0x21] = StreamType("JPEG 2000 video", StreamType::VIDEO, ".mjpg");
+        StreamTypes[0x24] = StreamType("H.265 video", StreamType::VIDEO, ".h265");
+        StreamTypes[0x81] = StreamType("AC-3 audio", StreamType::AUDIO, ".ac3");
+    }
+
+    // Create our 'PID state' array:
+    fPIDState = new PIDState *[NUM_PIDS];
+    for(unsigned i = 0; i < NUM_PIDS; ++i)
+        fPIDState[i] = NULL;
+
+    // Initially, the only PID we know is 0x0000: a Program Association Table:
+    fPIDState[0x0000] = new PIDState_PAT(*this, 0x0000);
+
+    // Begin parsing:
+    continueParsing();
+}
+
+MPEG2TransportStreamParser::~MPEG2TransportStreamParser() {
+    for(unsigned i = 0; i < NUM_PIDS; ++i)
+        delete fPIDState[i];
+    delete[] fPIDState;
+}
+
+UsageEnvironment &MPEG2TransportStreamParser::envir() {
+    return fInputSource->envir();
+}
+
+void MPEG2TransportStreamParser ::continueParsing(void *clientData, unsigned char *ptr, unsigned size, struct timeval presentationTime) {
+    ((MPEG2TransportStreamParser *)clientData)->continueParsing();
+}
+
+void MPEG2TransportStreamParser::continueParsing() {
+    if(fAmCurrentlyParsing)
+        return;  // don't allow recursive calls to parse()
+
+    if(fInputSource != NULL) {
+        fAmCurrentlyParsing    = True;
+        Boolean parseSucceeded = parse();
+        fAmCurrentlyParsing    = False;
+
+        if(!parseSucceeded) {
+            // We didn't complete the parsing, because we had to read more data from the source,
+            // or because we're waiting for another read from downstream.
+            // Once that happens, we'll get called again.
+            return;
+        }
+    }
+
+    // We successfully parsed the file.  Call our 'done' function now:
+    if(fOnEndFunc != NULL)
+        (*fOnEndFunc)(fOnEndClientData);
+}
+
+#define TRANSPORT_SYNC_BYTE 0x47
+#define TRANSPORT_PACKET_SIZE 188
+
+Boolean MPEG2TransportStreamParser::parse() {
+    if(fInputSource->isCurrentlyAwaitingData())
+        return False;
+    // Our input source is currently being read. Wait until that read completes
+
+    try {
+        while(1) {
+            // Make sure we start with a 'sync byte':
+            do {
+                saveParserState();
+            } while(get1Byte() != TRANSPORT_SYNC_BYTE);
+
+            // Parse and process each (remaining 187 bytes of a) 'Transport Stream Packet' at a time.
+            // (Because these are a lot smaller than the "StreamParser" BANK_SIZE, we don't save
+            //  parser state in the middle of processing each such 'Transport Stream Packet'.
+            //  Therefore, processing of each 'Transport Stream Packet' needs to be idempotent.)
+
+            u_int16_t flagsPlusPID = get2Bytes();
+            // Check the "transport_error_indicator" flag; reject the packet if it's set:
+            if((flagsPlusPID & 0x8000) != 0) {
+#ifdef DEBUG_ERRORS
+                fprintf(stderr, "MPEG2TransportStreamParser::parse() Rejected packet with \"transport_error_indicator\" flag set!\n");
+#endif
+                continue;
+            }
+            Boolean pusi = (flagsPlusPID & 0x4000) != 0;  // payload_unit_start_indicator
+            // Ignore "transport_priority"
+            u_int16_t PID = flagsPlusPID & 0x1FFF;
+#ifdef DEBUG_CONTENTS
+            fprintf(stderr, "\nTransport Packet: payload_unit_start_indicator: %d; PID: 0x%04x\n", pusi, PID);
+#endif
+
+            u_int8_t controlPlusContinuity_counter = get1Byte();
+            // Reject any packets where the "transport_scrambling_control" field is not zero:
+            if((controlPlusContinuity_counter & 0xC0) != 0) {
+#ifdef DEBUG_ERRORS
+                fprintf(stderr, "MPEG2TransportStreamParser::parse() Rejected packet with \"transport_scrambling_control\" set to non-zero value %d!\n",
+                        (controlPlusContinuity_counter & 0xC0) >> 6);
+#endif
+                continue;
+            }
+            u_int8_t adaptation_field_control = (controlPlusContinuity_counter & 0x30) >> 4;  // 2 bits
+#ifdef DEBUG_CONTENTS
+            u_int8_t continuity_counter = (controlPlusContinuity_counter & 0x0F);  // 4 bits
+            fprintf(stderr, "adaptation_field_control: %d; continuity_counter: 0x%X\n", adaptation_field_control, continuity_counter);
+#endif
+
+            u_int8_t totalAdaptationFieldSize = adaptation_field_control < 2 ? 0 : parseAdaptationField();
+#ifdef DEBUG_ERRORS
+            if(adaptation_field_control == 2 && totalAdaptationFieldSize != 1 + 183) {
+                fprintf(stderr,
+                        "MPEG2TransportStreamParser::parse() Warning: Got an inconsistent \"totalAdaptationFieldSize\" %d for adaptation_field_control == 2\n",
+                        totalAdaptationFieldSize);
+            }
+#endif
+
+            int numDataBytes = TRANSPORT_PACKET_SIZE - 4 - totalAdaptationFieldSize;
+            if(numDataBytes > 0) {
+#ifdef DEBUG_CONTENTS
+                fprintf(stderr, "+%d data bytes:\n", numDataBytes);
+#endif
+                if(!processDataBytes(PID, pusi, numDataBytes)) {
+                    // The parsing got deferred (to be resumed later when a pending read happens)
+                    restoreSavedParserState();  // so that we later resume parsing at the start of the packet
+                    return False;
+                }
+            }
+        }
+    }
+    catch(int /*e*/) {
+#ifdef DEBUG_CONTENTS
+        fprintf(stderr, "MPEG2TransportStreamParser::parse() EXCEPTION (This is normal behavior - *not* an error)\n");
+#endif
+        return False;  // the parsing got interrupted
+    }
+}
+
+u_int8_t MPEG2TransportStreamParser::parseAdaptationField() {
+    unsigned startPos = curOffset();
+#ifdef DEBUG_CONTENTS
+    fprintf(stderr, "\tAdaptation Field:\n");
+#endif
+    u_int8_t adaptation_field_length = get1Byte();
+#ifdef DEBUG_CONTENTS
+    fprintf(stderr, "\t\tadaptation_field_length: %d\n", adaptation_field_length);
+#endif
+    if(adaptation_field_length > 0) {
+        u_int8_t flags = get1Byte();
+#ifdef DEBUG_CONTENTS
+        fprintf(stderr, "\t\tadaptation field flags: 0x%02x\n", flags);
+#endif
+        if((flags & 0x10) != 0) {  // PCR_flag
+            u_int32_t first32PCRBits = get4Bytes();
+            u_int16_t last16PCRBits  = get2Bytes();
+            // program_clock_reference_base = "first32PCRBits" and high bit of "last16PCRBits" (33 bits)
+            // program_clock_reference_extension = last 9 bits of "last16PCRBits" (9 bits)
+            double PCR = first32PCRBits / 45000.0;
+            if((last16PCRBits & 0x8000) != 0)
+                PCR += 1 / 90000.0;                        // add in low-bit (if set)
+            PCR += (last16PCRBits & 0x01FF) / 27000000.0;  // add in extension
+#ifdef DEBUG_CONTENTS
+            fprintf(stderr, "\t\tPCR: %.10f\n", PCR);
+#endif
+        }
+        if((flags & 0x08) != 0) {  // OPCR_flag
+            u_int32_t first32OPCRBits = get4Bytes();
+            u_int16_t last16OPCRBits  = get2Bytes();
+            // original_program_clock_reference_base = "first32OPCRBits" and high bit of "last16OPCRBits" (33 bits)
+            // original_program_clock_reference_extension = last 9 bits of "last16OPCRBits" (9 bits)
+            double OPCR = first32OPCRBits / 45000.0;
+            if((last16OPCRBits & 0x8000) != 0)
+                OPCR += 1 / 90000.0;                         // add in low-bit (if set)
+            OPCR += (last16OPCRBits & 0x01FF) / 27000000.0;  // add in extension
+#ifdef DEBUG_CONTENTS
+            fprintf(stderr, "\t\tOPCR: %.10f\n", OPCR);
+#endif
+        }
+        if((flags & 0x04) != 0) {  // splicing_point_flag
+            skipBytes(1);          // splice_countdown
+        }
+        if((flags & 0x02) != 0) {  // transport_private_data_flag
+            u_int8_t transport_private_data_length = get1Byte();
+#ifdef DEBUG_CONTENTS
+            fprintf(stderr, "\t\ttransport_private_data_length: %d\n", transport_private_data_length);
+#endif
+            skipBytes(transport_private_data_length);  // "private_data_byte"s
+        }
+        if((flags & 0x01) != 0) {  // adaptation_field_extension_flag
+#ifdef DEBUG_CONTENTS
+            u_int8_t adaptation_field_extension_length = get1Byte();
+            fprintf(stderr, "\t\tadaptation_field_extension_length: %d\n", adaptation_field_extension_length);
+#else
+            skipBytes(1);  // adaptation_field_extension_length
+#endif
+            u_int8_t flagsPlusReserved = get1Byte();
+#ifdef DEBUG_CONTENTS
+            fprintf(stderr, "\t\t\tflagsPlusReserved: 0x%02x\n", flagsPlusReserved);
+#endif
+            if((flagsPlusReserved & 0x80) != 0) {  // ltw_flag
+                skipBytes(2);                      // "ltw_valid_flag" + "ltw_offset"
+            }
+            if((flagsPlusReserved & 0x40) != 0) {  // piecewise_rate_flag
+                skipBytes(3);                      // reserved + "piecewise_rate"
+            }
+            if((flagsPlusReserved & 0x20) != 0) {  // seamless_splice_flag
+                skipBytes(5);                      // DTS_next_...
+            }
+            // Skip reserved bytes to the end of the adaptation_field:
+            int numBytesLeft = (1 + adaptation_field_length) - (curOffset() - startPos);
+            if(numBytesLeft > 0) {
+#ifdef DEBUG_CONTENTS
+                fprintf(stderr, "\t\t+%d reserved bytes\n", numBytesLeft);
+#endif
+                skipBytes(numBytesLeft);
+            }
+        }
+        // Skip "stuffing_byte"s to the end of the adaptation_field:
+        int numBytesLeft = (1 + adaptation_field_length) - (curOffset() - startPos);
+        if(numBytesLeft > 0) {
+#ifdef DEBUG_CONTENTS
+            fprintf(stderr, "\t\t+%d stuffing bytes\n", numBytesLeft);
+#endif
+#ifdef DEBUG_ERRORS
+            for(int i = 0; i < numBytesLeft; ++i) {
+                if(get1Byte() != 0xFF) {
+                    fprintf(stderr, "WARNING: non-stuffing byte in adaptation_field\n");
+                }
+            }
+#else
+            skipBytes(numBytesLeft);
+#endif
+        }
+    }
+
+    // Finally, figure out how many bytes we parsed, and compare it to what we expected:
+    unsigned totalAdaptationFieldSize = curOffset() - startPos;
+#ifdef DEBUG_ERRORS
+    if(totalAdaptationFieldSize != 1 + adaptation_field_length) {
+        fprintf(stderr, "MPEG2TransportStreamParser::parseAdaptationField() Warning: Got an inconsistent \"totalAdaptationFieldSize\" %d; expected %d\n",
+                totalAdaptationFieldSize, 1 + adaptation_field_length);
+    }
+#endif
+    return totalAdaptationFieldSize;
+}
+
+Boolean MPEG2TransportStreamParser ::processDataBytes(u_int16_t PID, Boolean pusi, unsigned numDataBytes) {
+    PIDState *pidState = fPIDState[PID];
+
+    if(pidState == NULL) {  // unknown PID
+#ifdef DEBUG_CONTENTS
+        fprintf(stderr, "\tUnknown PID\n");
+#endif
+        skipBytes(numDataBytes);
+        return True;
+    }
+
+    switch(pidState->type) {
+    case PAT: {
+        parsePAT(pusi, numDataBytes);
+        return True;
+    }
+    case PMT: {
+        parsePMT((PIDState_PMT *)pidState, pusi, numDataBytes);
+        return True;
+    }
+    case STREAM: {
+        return processStreamPacket((PIDState_STREAM *)pidState, pusi, numDataBytes);
+    }
+    default: {  // Never reached, but eliminates a possible error with dumb compilers
+        return False;
+    }
+    }
+}
+
+void MPEG2TransportStreamParser::restoreSavedParserState() {
+    StreamParser::restoreSavedParserState();
+    fAmCurrentlyParsing = False;
+}
+
+//########## PIDState implementation ##########
+
+PIDState::PIDState(MPEG2TransportStreamParser &parser, u_int16_t pid, PIDType pidType) : ourParser(parser), PID(pid), type(pidType) {}
+
+PIDState::~PIDState() {}
+
+//######### StreamType implementation ########
+
+StreamType ::StreamType(char const *description, enum dataType dataType, char const *filenameSuffix)
+    : description(description), dataType(dataType), filenameSuffix(filenameSuffix) {}
diff --git a/3rdparty/live555/src/liveMedia/MPEG2TransportStreamParser.hh b/3rdparty/live555/src/liveMedia/MPEG2TransportStreamParser.hh
new file mode 100644
index 00000000..d663120c
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/MPEG2TransportStreamParser.hh
@@ -0,0 +1,132 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A parser for a MPEG Transport Stream
+// C++ header
+
+#ifndef _MPEG2_TRANSPORT_STREAM_PARSER_HH
+
+#ifndef _STREAM_PARSER_HH
+#include "StreamParser.hh"
+#endif
+#ifndef _MPEG2_TRANSPORT_STREAM_DEMUXED_TRACK_HH
+#include "MPEG2TransportStreamDemuxedTrack.hh"
+#endif
+#ifndef _MEDIA_SINK_HH
+#include "MediaSink.hh"
+#endif
+
+// A descriptor that describes the state of each known PID:
+enum PIDType { PAT, PMT, STREAM };
+
+class PIDState {
+protected: // we're a virtual base class
+  PIDState(MPEG2TransportStreamParser& parser, u_int16_t pid, PIDType pidType);
+public:
+  virtual ~PIDState();
+
+public:
+  MPEG2TransportStreamParser& ourParser;
+  u_int16_t PID;
+  PIDType type;
+};
+
+class PIDState_PAT : public PIDState {
+public:
+  PIDState_PAT(MPEG2TransportStreamParser& parser, u_int16_t pid);
+protected:
+  virtual ~PIDState_PAT();
+};
+
+class PIDState_PMT : public PIDState {
+public:
+  PIDState_PMT(MPEG2TransportStreamParser& parser, u_int16_t pid, u_int16_t programNumber);
+protected:
+  virtual ~PIDState_PMT();
+
+public:
+  u_int16_t program_number;
+};
+
+class PIDState_STREAM : public PIDState {
+public:
+  PIDState_STREAM(MPEG2TransportStreamParser& parser, u_int16_t pid, u_int16_t programNumber, u_int8_t streamType);
+protected:
+  virtual ~PIDState_STREAM();
+
+public:
+  u_int16_t program_number;
+  u_int8_t stream_type;
+  double lastSeenPTS;
+  MPEG2TransportStreamDemuxedTrack* streamSource;
+  MediaSink* streamSink;
+};
+
+
+// Descriptions of known "stream_type"s:
+class StreamType {
+public:
+  char const* description;
+  enum dataType { AUDIO, VIDEO, DATA, TEXT, UNKNOWN } dataType;
+  char const* filenameSuffix;
+
+public:
+  StreamType(char const* description = "unknown", enum dataType dataType = UNKNOWN,
+	     char const* filenameSuffix = "");
+};
+
+
+class MPEG2TransportStreamParser: public StreamParser {
+public:
+  MPEG2TransportStreamParser(FramedSource* inputSource,
+			     FramedSource::onCloseFunc* onEndFunc, void* onEndClientData);
+  virtual ~MPEG2TransportStreamParser();
+
+  UsageEnvironment& envir();
+
+  // StreamParser 'client continue' function:
+  static void continueParsing(void* clientData, unsigned char* ptr, unsigned size, struct timeval presentationTime);
+  void continueParsing();
+
+private:
+  // Parsing functions:
+  friend class MPEG2TransportStreamDemuxedTrack;
+  Boolean parse(); // returns True iff we have finished parsing all BOS pages (on initialization)
+
+  u_int8_t parseAdaptationField();
+  Boolean processDataBytes(u_int16_t PID, Boolean pusi, unsigned numDataBytes);
+
+  void parsePAT(Boolean pusi, unsigned numDataBytes);
+  void parsePMT(PIDState_PMT* pidState, Boolean pusi, unsigned numDataBytes);
+  void parseStreamDescriptors(unsigned numDescriptorBytes);
+  Boolean processStreamPacket(PIDState_STREAM* pidState, Boolean pusi, unsigned numDataBytes);
+  unsigned parsePESHeader(PIDState_STREAM* pidState, unsigned numDataBytes);
+
+private: // redefined virtual functions
+  virtual void restoreSavedParserState();
+
+private:
+  // General state for parsing:
+  FramedSource* fInputSource;
+  Boolean fAmCurrentlyParsing;
+  FramedSource::onCloseFunc* fOnEndFunc;
+  void* fOnEndClientData;
+  PIDState** fPIDState;
+  double fLastSeenPCR;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/MPEG2TransportStreamParser_PAT.cpp b/3rdparty/live555/src/liveMedia/MPEG2TransportStreamParser_PAT.cpp
new file mode 100644
index 00000000..5461a103
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/MPEG2TransportStreamParser_PAT.cpp
@@ -0,0 +1,104 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A parser for a MPEG Transport Stream
+// Implementation
+
+#include "MPEG2TransportStreamParser.hh"
+
+void MPEG2TransportStreamParser::parsePAT(Boolean pusi, unsigned numDataBytes) {
+#ifdef DEBUG_CONTENTS
+    fprintf(stderr, "\tProgram Association Table\n");
+#endif
+    unsigned startPos = curOffset();
+
+    do {
+        if(pusi) {
+            u_int8_t pointer_field = get1Byte();
+            skipBytes(pointer_field);  // usually 0
+        }
+
+        u_int8_t table_id = get1Byte();
+        if(table_id != 0x00) {
+#ifdef DEBUG_ERRORS
+            fprintf(stderr, "MPEG2TransportStreamParser::parsePAT(%d, %d): bad table_id: 0x%02x\n", pusi, numDataBytes, table_id);
+#endif
+            break;
+        }
+
+        u_int16_t flagsPlusSection_length = get2Bytes();
+        u_int16_t section_length          = flagsPlusSection_length & 0x0FFF;
+#ifdef DEBUG_CONTENTS
+        fprintf(stderr, "\t\tsection_length: %d\n", section_length);
+#endif
+        if(section_length < 9 /*too small for remaining fields + CRC*/ || section_length > 1021 /*as per specification*/) {
+#ifdef DEBUG_ERRORS
+            fprintf(stderr, "MPEG2TransportStreamParser::parsePAT(%d, %d): Bad section_length: %d\n", pusi, numDataBytes, section_length);
+#endif
+            break;
+        }
+
+        unsigned endPos = curOffset() + section_length;
+        if(endPos - startPos > numDataBytes) {
+#ifdef DEBUG_ERRORS
+            fprintf(stderr, "MPEG2TransportStreamParser::parsePAT(%d, %d): section_length %d gives us a total size %d that's too large!\n", pusi, numDataBytes,
+                    section_length, endPos - startPos);
+#endif
+            break;
+        }
+
+#ifdef DEBUG_CONTENTS
+        u_int16_t transport_stream_id = get2Bytes();
+        fprintf(stderr, "\t\ttransport_stream_id: 0x%04x\n", transport_stream_id);
+        u_int8_t version_number_byte = get1Byte();
+        u_int8_t version_number      = (version_number_byte & 0x1E) >> 1;
+        u_int8_t section_number      = get1Byte();
+        u_int8_t last_section_number = get1Byte();
+        fprintf(stderr, "\t\tversion_number: %d; section_number: %d; last_section_number: %d\n", version_number, section_number, last_section_number);
+#else
+        skipBytes(5);
+#endif
+
+        while(curOffset() <= endPos - 4 /*for CRC*/ - 4 /*for a program_number+PID*/) {
+            u_int16_t program_number = get2Bytes();
+            u_int16_t pid            = get2Bytes() & 0x1FFF;
+
+#ifdef DEBUG_CONTENTS
+            fprintf(stderr, "\t\tprogram_number: %d; PID: 0x%04x\n", program_number, pid);
+#endif
+            if(program_number != 0x0000) {
+                if(fPIDState[pid] == NULL)
+                    fPIDState[pid] = new PIDState_PMT(*this, pid, program_number);
+            }
+        }
+    } while(0);
+
+    // Skip (ignore) all remaining bytes in this packet (including the CRC):
+    int numBytesLeft = numDataBytes - (curOffset() - startPos);
+    if(numBytesLeft > 0) {
+#ifdef DEBUG_CONTENTS
+        fprintf(stderr, "\t\t+%d CRC and stuffing bytes\n", numBytesLeft);
+#endif
+        skipBytes(numBytesLeft);
+    }
+}
+
+//########## PIDState_PAT implementation ##########
+
+PIDState_PAT::PIDState_PAT(MPEG2TransportStreamParser &parser, u_int16_t pid) : PIDState(parser, pid, PAT) {}
+
+PIDState_PAT::~PIDState_PAT() {}
diff --git a/3rdparty/live555/src/liveMedia/MPEG2TransportStreamParser_PMT.cpp b/3rdparty/live555/src/liveMedia/MPEG2TransportStreamParser_PMT.cpp
new file mode 100644
index 00000000..6cca57f4
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/MPEG2TransportStreamParser_PMT.cpp
@@ -0,0 +1,493 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A parser for a MPEG Transport Stream
+// Implementation
+
+#include "MPEG2TransportStreamParser.hh"
+
+void MPEG2TransportStreamParser ::parsePMT(PIDState_PMT *pidState, Boolean pusi, unsigned numDataBytes) {
+#ifdef DEBUG_CONTENTS
+    fprintf(stderr, "\tProgram Map Table\n");
+#endif
+    unsigned startPos = curOffset();
+
+    do {
+        if(pusi) {
+            u_int8_t pointer_field = get1Byte();
+            skipBytes(pointer_field);  // usually 0
+        }
+
+        u_int8_t table_id = get1Byte();
+        if(table_id != 0x02) {
+#ifdef DEBUG_ERRORS
+            fprintf(stderr, "MPEG2TransportStreamParser::parsePMT(0x%04x, %d, %d): bad table_id: 0x%02x\n", pidState->PID, pusi, numDataBytes, table_id);
+#endif
+            break;
+        }
+
+        u_int16_t flagsPlusSection_length = get2Bytes();
+        u_int16_t section_length          = flagsPlusSection_length & 0x0FFF;
+#ifdef DEBUG_CONTENTS
+        fprintf(stderr, "\t\tsection_length: %d\n", section_length);
+#endif
+        if(section_length < 13 /*too small for remaining fields + CRC*/ || section_length > 1021 /*as per specification*/) {
+#ifdef DEBUG_ERRORS
+            fprintf(stderr, "MPEG2TransportStreamParser::parsePMT(0x%04x, %d, %d): Bad section_length: %d\n", pidState->PID, pusi, numDataBytes,
+                    section_length);
+#endif
+            break;
+        }
+        unsigned endPos = curOffset() + section_length;
+        if(endPos - startPos > numDataBytes) {
+#ifdef DEBUG_ERRORS
+            fprintf(stderr, "MPEG2TransportStreamParser::parsePMT(0x%04x, %d, %d): section_length %d gives us a total size %d that's too large!\n",
+                    pidState->PID, pusi, numDataBytes, section_length, endPos - startPos);
+#endif
+            break;
+        }
+
+        u_int16_t program_number = get2Bytes();
+        if(program_number != pidState->program_number) {
+#ifdef DEBUG_ERRORS
+            fprintf(stderr,
+                    "MPEG2TransportStreamParser::parsePMT(0x%04x, %d, %d): program_number %d does not match the value %d that was given to us in the PAT!\n",
+                    pidState->PID, pusi, numDataBytes, program_number, pidState->program_number);
+#endif
+            break;
+        }
+#ifdef DEBUG_CONTENTS
+        fprintf(stderr, "\t\tprogram_number: %d\n", program_number);
+
+        u_int8_t version_number_byte = get1Byte();
+        u_int8_t version_number      = (version_number_byte & 0x1E) >> 1;
+        u_int8_t section_number      = get1Byte();
+        u_int8_t last_section_number = get1Byte();
+        fprintf(stderr, "\t\tversion_number: %d; section_number: %d; last_section_number: %d\n", version_number, section_number, last_section_number);
+        u_int16_t PCR_PID = get2Bytes();
+        PCR_PID &= 0x1FFF;
+        fprintf(stderr, "\t\tPCR_PID: 0x%04x\n", PCR_PID);
+#else
+        skipBytes(5);
+#endif
+
+        u_int16_t program_info_length = get2Bytes();
+        program_info_length &= 0x0FFF;
+#ifdef DEBUG_CONTENTS
+        fprintf(stderr, "\t\tprogram_info_length: %d\n", program_info_length);
+#endif
+        unsigned endOfDescriptors = curOffset() + program_info_length;
+        if(endOfDescriptors + 4 /*CRC*/ - startPos > numDataBytes) {
+#ifdef DEBUG_ERRORS
+            fprintf(stderr, "MPEG2TransportStreamParser::parsePMT(0x%04x, %d, %d): program_info_length %d gives us a total size %d that's too large!\n",
+                    pidState->PID, pusi, numDataBytes, program_info_length, endOfDescriptors + 4 - startPos);
+#endif
+            break;
+        }
+        parseStreamDescriptors(program_info_length);
+
+        while(curOffset() <= endPos - 4 /*for CRC*/ - 5 /*for mapping fields*/) {
+            u_int8_t  stream_type    = get1Byte();
+            u_int16_t elementary_PID = get2Bytes();
+            elementary_PID &= 0x1FFF;
+            u_int16_t ES_info_length = get2Bytes();
+            ES_info_length &= 0x0FFF;
+#ifdef DEBUG_CONTENTS
+            extern StreamType StreamTypes[];
+            char const *const streamTypeDesc = StreamTypes[stream_type].description;
+            fprintf(stderr, "\t\tstream_type: 0x%02x (%s); elementary_PID: 0x%04x; ES_info_length: %d\n", stream_type,
+                    streamTypeDesc == NULL ? "???" : streamTypeDesc, elementary_PID, ES_info_length);
+#endif
+            endOfDescriptors = curOffset() + ES_info_length;
+            if(endOfDescriptors + 4 /*CRC*/ - startPos > numDataBytes) {
+#ifdef DEBUG_ERRORS
+                fprintf(stderr, "MPEG2TransportStreamParser::parsePMT(0x%04x, %d, %d): ES_info_length %d gives us a total size %d that's too large!\n",
+                        pidState->PID, pusi, numDataBytes, ES_info_length, endOfDescriptors + 4 - startPos);
+#endif
+                break;
+            }
+            parseStreamDescriptors(ES_info_length);
+
+            if(fPIDState[elementary_PID] == NULL) {
+                fPIDState[elementary_PID] = new PIDState_STREAM(*this, elementary_PID, program_number, stream_type);
+            }
+        }
+    } while(0);
+
+    // Skip (ignore) all remaining bytes in this packet (including the CRC):
+    int numBytesLeft = numDataBytes - (curOffset() - startPos);
+    if(numBytesLeft > 0) {
+#ifdef DEBUG_CONTENTS
+        fprintf(stderr, "\t\t+%d CRC and stuffing bytes\n", numBytesLeft);
+#endif
+        skipBytes(numBytesLeft);
+    }
+}
+
+#ifdef DEBUG_CONTENTS
+#define pDesc(str)                                                                                                               \
+    do {                                                                                                                         \
+        fprintf(stderr, "\t\t\tdescriptor_tag: 0x%02x (%s); descriptor_length: %d\n", descriptor_tag, (str), descriptor_length); \
+    } while(0)
+#else
+#define pDesc(str)
+#endif
+
+void MPEG2TransportStreamParser::parseStreamDescriptors(unsigned numDescriptorBytes) {
+    while(numDescriptorBytes >= 2 /* enough for "descriptor_tag" and "descriptor_length" */) {
+        u_int8_t descriptor_tag    = get1Byte();
+        u_int8_t descriptor_length = get1Byte();
+        numDescriptorBytes -= 2;
+
+        if(descriptor_length > numDescriptorBytes) {
+#ifdef DEBUG_ERRORS
+            fprintf(stderr, "MPEG2TransportStreamParser::parseStreamDescriptors() error: Saw descriptor_length %d > remaining bytes %d\n", descriptor_length,
+                    numDescriptorBytes);
+#endif
+            skipBytes(numDescriptorBytes);
+            numDescriptorBytes = 0;
+            break;
+        }
+
+        Boolean parsedDescriptor = False;
+        switch(descriptor_tag) {
+            // Note: These are the tags that we've seen to date.  Add more when we see more.
+        case 0x02: {
+            pDesc("video");
+            if(descriptor_length < 1)
+                break;
+            u_int8_t flags            = get1Byte();
+            Boolean  MPEG_1_only_flag = (flags & 0x04) != 0;
+#ifdef DEBUG_CONTENTS
+            fprintf(stderr, "\t\t\t\tflags: 0x%02x (frame_rate_code 0x%1x; MPEG_1_only_flag %d)\n", flags, (flags & 0x78) >> 3, MPEG_1_only_flag);
+#endif
+            if(MPEG_1_only_flag == 0) {
+                if(descriptor_length < 3)
+                    break;
+#ifdef DEBUG_CONTENTS
+                u_int8_t profile_and_level_indication = get1Byte();
+                flags                                 = get1Byte();
+                fprintf(stderr, "\t\t\t\tprofile_and_level_indication 0x%02x; flags 0x%02x (chroma_format 0x%1x)\n", profile_and_level_indication, flags,
+                        (flags & 0xC0) >> 6);
+#else
+                skipBytes(2);
+#endif
+            }
+            numDescriptorBytes -= descriptor_length;
+            parsedDescriptor = True;
+            break;
+        }
+        case 0x03: {
+            pDesc("audio");
+            if(descriptor_length < 1)
+                break;
+#ifdef DEBUG_CONTENTS
+            u_int8_t flags = get1Byte();
+            fprintf(stderr, "\t\t\t\tflags: 0x%02x (layer %d)\n", flags, (flags & 0x30) >> 4);
+#else
+            skipBytes(1);
+#endif
+            numDescriptorBytes -= descriptor_length;
+            parsedDescriptor = True;
+            break;
+        }
+        case 0x05: {
+            pDesc("registration");
+            if(descriptor_length < 4)
+                break;
+#ifdef DEBUG_CONTENTS
+            u_int32_t format_identifier = get4Bytes();
+            fprintf(stderr, "\t\t\t\tformat_identifier: 0x%08x (%c%c%c%c)\n", format_identifier, format_identifier >> 24, format_identifier >> 16,
+                    format_identifier >> 8, format_identifier);
+            if(descriptor_length > 4) {
+                fprintf(stderr, "\t\t\t\tadditional_identification_info: ");
+                for(unsigned i = 4; i < descriptor_length; ++i)
+                    fprintf(stderr, "%02x:", get1Byte());
+                fprintf(stderr, "\n");
+            }
+#else
+            skipBytes(descriptor_length);
+#endif
+            numDescriptorBytes -= descriptor_length;
+            parsedDescriptor = True;
+            break;
+        }
+        case 0x06: {
+            pDesc("data stream alignment");
+            if(descriptor_length < 1)
+                break;
+#ifdef DEBUG_CONTENTS
+            u_int8_t alignment_type = get1Byte();
+            fprintf(stderr, "\t\t\t\talignment_type: 0x%02x\n", alignment_type);
+#else
+            skipBytes(1);
+#endif
+            numDescriptorBytes -= descriptor_length;
+            parsedDescriptor = True;
+            break;
+        }
+        case 0x0a: {
+            pDesc("ISO 639 language descriptor");
+            for(unsigned i = 0; i < descriptor_length / 4; ++i) {
+#ifdef DEBUG_CONTENTS
+                fprintf(stderr, "\t\t\t\tISO_639_language_code: %c%c%c; audio_type: 0x%02x\n", get1Byte(), get1Byte(), get1Byte(), get1Byte());
+#else
+                skipBytes(4);
+#endif
+            }
+            numDescriptorBytes -= descriptor_length;
+            parsedDescriptor = True;
+            break;
+        }
+        case 0x0b: {
+            pDesc("system clock");
+            if(descriptor_length < 2)
+                break;
+#ifdef DEBUG_CONTENTS
+            u_int8_t flags                  = get1Byte();
+            Boolean  external_clock_ref     = (flags & 0x80) != 0;
+            u_int8_t clock_accuracy_integer = flags & 0x3F;
+
+            u_int8_t clock_accuracy_exponent = get1Byte();
+            clock_accuracy_exponent >>= 5;
+            float ppm = clock_accuracy_integer * 1.0;
+            for(unsigned i = 0; i < clock_accuracy_exponent; ++i)
+                ppm /= 10.0;
+            fprintf(stderr, "\t\t\t\texternal_clock: %d; clock_accuracy int: %d, exp: %d -> %f ppm\n", external_clock_ref, clock_accuracy_integer,
+                    clock_accuracy_exponent, ppm);
+#else
+            skipBytes(2);
+#endif
+            numDescriptorBytes -= descriptor_length;
+            parsedDescriptor = True;
+            break;
+        }
+        case 0x0e: {
+            pDesc("maximum bitrate");
+            if(descriptor_length < 3)
+                break;
+#ifdef DEBUG_CONTENTS
+            u_int32_t maximum_bitrate = ((get1Byte() & 0x3F) << 16) | get2Bytes();  // 22 bits
+            fprintf(stderr, "\t\t\t\tmaximum_bitrate: %d => %f Mbps\n", maximum_bitrate, (maximum_bitrate * 50 * 8) / 1000000.0);
+#else
+            skipBytes(3);
+#endif
+            numDescriptorBytes -= descriptor_length;
+            parsedDescriptor = True;
+            break;
+        }
+        case 0x10: {
+            pDesc("smoothing buffer");
+            if(descriptor_length < 6)
+                break;
+#ifdef DEBUG_CONTENTS
+            u_int32_t sb_leak_rate = ((get1Byte() & 0x3F) << 16) | get2Bytes();  // 22 bits
+            u_int32_t sb_size      = ((get1Byte() & 0x3F) << 16) | get2Bytes();  // 22 bits
+            fprintf(stderr, "\t\t\t\tsb_leak_rate: %d => %f Mbps; sb_size: %d bytes\n", sb_leak_rate, (sb_leak_rate * 400) / 1000000.0, sb_size);
+#else
+            skipBytes(6);
+#endif
+            numDescriptorBytes -= descriptor_length;
+            parsedDescriptor = True;
+            break;
+        }
+        case 0x1d: {
+            pDesc("IOD parameters for ISO/IEC 14496-1");
+            // Note: We don't know how to parse this.  (Where's a document that describes this?)
+            skipBytes(descriptor_length);
+            numDescriptorBytes -= descriptor_length;
+            parsedDescriptor = True;
+            break;
+        }
+        case 0x28: {
+            pDesc("H.264 video parameters");
+            if(descriptor_length < 4)
+                break;
+#ifdef DEBUG_CONTENTS
+            u_int8_t profile_idc = get1Byte();
+            u_int8_t flags1      = get1Byte();
+            u_int8_t level_idc   = get1Byte();
+            u_int8_t flags2      = get1Byte();
+            fprintf(stderr, "\t\t\t\tprofile_idc: 0x%02x, flags1: 0x%02x, level_idc: 0x%02x, flags2: 0x%02x\n", profile_idc, flags1, level_idc, flags2);
+#else
+            skipBytes(4);
+#endif
+            numDescriptorBytes -= descriptor_length;
+            parsedDescriptor = True;
+            break;
+        }
+        case 0x52: {
+            pDesc("stream identifier");
+            if(descriptor_length < 1)
+                break;
+#ifdef DEBUG_CONTENTS
+            u_int8_t component_tag = get1Byte();
+            fprintf(stderr, "\t\t\t\tcomponent_tag: %d\n", component_tag);
+#else
+            skipBytes(1);
+#endif
+            numDescriptorBytes -= descriptor_length;
+            parsedDescriptor = True;
+            break;
+        }
+        case 0x56: {
+            pDesc("teletext");
+            for(unsigned i = 0; i < descriptor_length / 5; ++i) {
+#ifdef DEBUG_CONTENTS
+                fprintf(stderr, "\t\t\t\tISO_639_language_code: %c%c%c", get1Byte(), get1Byte(), get1Byte());
+                u_int8_t typePlusMagazine = get1Byte();
+                fprintf(stderr, "; type: 0x%02x; magazine: %d; page: %d\n", typePlusMagazine >> 3, typePlusMagazine & 0x07, get1Byte());
+#else
+                skipBytes(5);
+#endif
+            }
+            numDescriptorBytes -= descriptor_length;
+            parsedDescriptor = True;
+            break;
+        }
+        case 0x59: {
+            pDesc("subtitling");
+            for(unsigned i = 0; i < descriptor_length / 8; ++i) {
+#ifdef DEBUG_CONTENTS
+                fprintf(stderr, "\t\t\t\tISO_639_language_code: %c%c%c", get1Byte(), get1Byte(), get1Byte());
+                fprintf(stderr, "; subtitling_type: 0x%02x; composition_page_id: 0x%04x; ancillary_page_id: 0x%04x\n", get1Byte(), get2Bytes(), get2Bytes());
+#else
+                skipBytes(8);
+#endif
+            }
+            numDescriptorBytes -= descriptor_length;
+            parsedDescriptor = True;
+            break;
+        }
+        case 0x6f: {
+            pDesc("application signalling");
+            for(unsigned i = 0; i < descriptor_length / 3; ++i) {
+#ifdef DEBUG_CONTENTS
+                fprintf(stderr, "\t\t\t\tapplication_type: 0x%04x; AIT_version_number: %d\n", get2Bytes() & 0x7FFF, get1Byte() & 0x1F);
+#else
+                skipBytes(3);
+#endif
+            }
+            numDescriptorBytes -= descriptor_length;
+            parsedDescriptor = True;
+            break;
+        }
+        case 0x7a: {
+            pDesc("enhanced AC-3");
+            if(descriptor_length < 1)
+                break;
+#ifdef DEBUG_CONTENTS
+            u_int8_t flags = get1Byte();
+            fprintf(stderr, "\t\t\t\tflags: 0x%02x", flags);
+            if(descriptor_length > 1) {
+                fprintf(stderr, "; extra bytes: ");
+                for(unsigned i = 1; i < descriptor_length; ++i)
+                    fprintf(stderr, "0x%02x ", get1Byte());
+            }
+            fprintf(stderr, "\n");
+#else
+            skipBytes(descriptor_length);
+#endif
+            numDescriptorBytes -= descriptor_length;
+            parsedDescriptor = True;
+            break;
+        }
+        case 0x81: {
+            pDesc("AC-3 audio");
+            if(descriptor_length < 3)
+                break;
+#ifdef DEBUG_CONTENTS
+            u_int8_t flags = get1Byte();
+            fprintf(stderr, "\t\t\t\tsample_rate_code: %d; bsid: 0x%02x", flags >> 5, flags & 0x1F);
+            flags = get1Byte();
+            fprintf(stderr, "; bit_rate_code: %d; surround_mode: %d", flags >> 2, flags & 0x03);
+            flags = get1Byte();
+            fprintf(stderr, "; bsmod: %d; num_channels: %d; full_svc: %d", flags >> 5, (flags & 0x1E) >> 1, (flags & 0x01));
+            if(descriptor_length > 3) {
+                fprintf(stderr, "; extra bytes: ");
+                for(unsigned i = 3; i < descriptor_length; ++i)
+                    fprintf(stderr, "0x%02x ", get1Byte());
+            }
+            fprintf(stderr, "\n");
+#else
+            skipBytes(descriptor_length);
+#endif
+            numDescriptorBytes -= descriptor_length;
+            parsedDescriptor = True;
+            break;
+        }
+        case 0x86: {
+            pDesc("caption service");
+            if(descriptor_length < 1)
+                break;
+            u_int8_t number_of_services = get1Byte() & 0x1F;
+#ifdef DEBUG_CONTENTS
+            fprintf(stderr, "\t\t\t\tnumber_of_services: %d\n", number_of_services);
+#endif
+            if(descriptor_length < number_of_services * 6)
+                break;
+#ifdef DEBUG_CONTENTS
+            for(unsigned i = 0; i < number_of_services; ++i) {
+                fprintf(stderr, "\t\t\t\t\tlanguage: %c%c%c", get1Byte(), get1Byte(), get1Byte());
+
+                u_int8_t flags      = get1Byte();
+                Boolean  digital_cc = (flags & 0x80) != 0;
+                fprintf(stderr, "; digital_cc %d", digital_cc);
+                if(digital_cc == 0) {
+                    fprintf(stderr, "; line21_field: %d", flags & 0x01);
+                }
+                else {
+                    fprintf(stderr, "; caption_service_number: %d", flags & 0x3F);
+                }
+
+                u_int16_t flags2 = get2Bytes();
+                fprintf(stderr, "; easy_reader: %d; wide_aspect_ratio: %d\n", (flags2 & 0x8000) != 0, (flags2 & 0x4000) != 0);
+            }
+#else
+            skipBytes(number_of_services * 6);
+#endif
+            numDescriptorBytes -= descriptor_length;
+            parsedDescriptor = True;
+            break;
+        }
+        default: {
+            pDesc("???");
+            skipBytes(descriptor_length);
+            numDescriptorBytes -= descriptor_length;
+            parsedDescriptor = True;
+            break;
+        }
+        }
+        if(!parsedDescriptor)
+            break;  // an error occurred
+    }
+
+    // Skip over any remaining descriptor bytes (as a result of a parsing error):
+    if(numDescriptorBytes > 0) {
+#ifdef DEBUG_ERRORS
+        fprintf(stderr, "MPEG2TransportStreamParser::parseStreamDescriptors() Parsing error left %d bytes unparsed\n", numDescriptorBytes);
+#endif
+        skipBytes(numDescriptorBytes);
+    }
+}
+
+//########## PIDState_PMT implementation ##########
+
+PIDState_PMT ::PIDState_PMT(MPEG2TransportStreamParser &parser, u_int16_t pid, u_int16_t programNumber)
+    : PIDState(parser, pid, PMT), program_number(programNumber) {}
+
+PIDState_PMT::~PIDState_PMT() {}
diff --git a/3rdparty/live555/src/liveMedia/MPEG2TransportStreamParser_STREAM.cpp b/3rdparty/live555/src/liveMedia/MPEG2TransportStreamParser_STREAM.cpp
new file mode 100644
index 00000000..5edee135
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/MPEG2TransportStreamParser_STREAM.cpp
@@ -0,0 +1,308 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A parser for a MPEG Transport Stream
+// Implementation
+
+#include "MPEG2TransportStreamParser.hh"
+#include "FileSink.hh"
+#include <time.h>  // for time_t
+
+Boolean MPEG2TransportStreamParser ::processStreamPacket(PIDState_STREAM *pidState, Boolean pusi, unsigned numDataBytes) {
+#ifdef DEBUG_CONTENTS
+    extern StreamType StreamTypes[];
+    fprintf(stderr, "\t%s stream (stream_type 0x%02x)\n", StreamTypes[pidState->stream_type].description, pidState->stream_type);
+#endif
+    do {
+        MPEG2TransportStreamDemuxedTrack *streamSource = pidState->streamSource;
+        if(streamSource == NULL) {
+            // There's no source for this track; just skip the data:
+            skipBytes(numDataBytes);
+            break;
+        }
+
+        if(!streamSource->isCurrentlyAwaitingData()) {
+            // Wait until the source next gets read from.  (The parsing will continue then.)
+            return False;
+        }
+
+        // If the data begins with a PES header, parse it first
+        unsigned pesHeaderSize = 0;
+        if(pusi && pidState->stream_type != 0x05 /*these special private streams don't have PES hdrs*/) {
+            pesHeaderSize = parsePESHeader(pidState, numDataBytes);
+            if(pesHeaderSize == 0)
+                break;  // PES header parsing failed
+        }
+
+        // Deliver the data:
+        unsigned numBytesToDeliver = numDataBytes - pesHeaderSize;
+        if(numBytesToDeliver > streamSource->maxSize()) {
+            streamSource->frameSize()         = streamSource->maxSize();
+            streamSource->numTruncatedBytes() = numBytesToDeliver - streamSource->maxSize();
+        }
+        else {
+            streamSource->frameSize()         = numBytesToDeliver;
+            streamSource->numTruncatedBytes() = 0;
+        }
+        getBytes(streamSource->to(), streamSource->frameSize());
+        skipBytes(streamSource->numTruncatedBytes());
+
+        double pts                               = pidState->lastSeenPTS == 0.0 ? fLastSeenPCR : pidState->lastSeenPTS;
+        streamSource->presentationTime().tv_sec  = (time_t)pts;
+        streamSource->presentationTime().tv_usec = int(pts * 1000000.0) % 1000000;
+
+        FramedSource::afterGetting(streamSource);  // completes delivery
+    } while(0);
+
+    return True;
+}
+
+static Boolean isSpecialStreamId[0x100];
+
+unsigned MPEG2TransportStreamParser ::parsePESHeader(PIDState_STREAM *pidState, unsigned numDataBytes) {
+    static Boolean haveInitializedIsSpecialStreamId = False;
+    if(!haveInitializedIsSpecialStreamId) {
+        for(unsigned i = 0; i < 0x100; ++i)
+            isSpecialStreamId[i] = False;
+        isSpecialStreamId[0xBC] = True;  // program_stream_map
+        isSpecialStreamId[0xBE] = True;  // padding_stream
+        isSpecialStreamId[0xBF] = True;  // private_stream_2
+        isSpecialStreamId[0xF0] = True;  // ECM_stream
+        isSpecialStreamId[0xF1] = True;  // EMM_stream
+        isSpecialStreamId[0xF2] = True;  // DSMCC_stream
+        isSpecialStreamId[0xF8] = True;  // ITU-T Rec. H.222.1 type E
+        isSpecialStreamId[0xFF] = True;  // program_stream_directory
+
+        haveInitializedIsSpecialStreamId = True;  // from now on
+    }
+
+#ifdef DEBUG_CONTENTS
+    fprintf(stderr, "\t\tPES Header:\n");
+#endif
+    unsigned startPos = curOffset();
+
+    do {
+        u_int32_t startCodePlusStreamId = get4Bytes();
+        if((startCodePlusStreamId & 0xFFFFFF00) != 0x00000100) {
+#ifdef DEBUG_ERRORS
+            fprintf(stderr, "MPEG2TransportStreamParser::parsePESHeader(0x%02x, %d): Bad start code: 0x%06x\n", pidState->PID, numDataBytes,
+                    startCodePlusStreamId >> 8);
+#endif
+            break;
+        }
+        u_int8_t stream_id = startCodePlusStreamId & 0xFF;
+
+#ifdef DEBUG_CONTENTS
+        fprintf(stderr, "\t\t\tstream_id: 0x%02x; PES_packet_length: %d\n", stream_id, get2Bytes());
+#else
+        skipBytes(2);
+#endif
+
+        if(!isSpecialStreamId[stream_id]) {
+            u_int16_t flags = get2Bytes();
+            if((flags & 0xC000) != 0x8000) {
+#ifdef DEBUG_ERRORS
+                fprintf(stderr, "MPEG2TransportStreamParser::parsePESHeader(0x%02x, %d): Bad flags: 0x%04x\n", pidState->PID, numDataBytes, flags);
+#endif
+                break;
+            }
+            u_int8_t PTS_DTS_flags             = (flags & 0x00C0) >> 6;
+            Boolean  ESCR_flag                 = (flags & 0x0020) != 0;
+            Boolean  ES_rate_flag              = (flags & 0x0010) != 0;
+            Boolean  DSM_trick_mode_flag       = (flags & 0x0008) != 0;
+            Boolean  additional_copy_info_flag = (flags & 0x0004) != 0;
+            Boolean  PES_CRC_flag              = (flags & 0x0002) != 0;
+            Boolean  PES_extension_flag        = (flags & 0x0001) != 0;
+#ifdef DEBUG_CONTENTS
+            fprintf(stderr, "\t\t\tflags: 0x%04x (PTS_DTS:%d; ESCR:%d; ES_rate:%d; DSM_trick_mode:%d; additional_copy_info:%d; PES_CRC:%d; PES_extension:%d)\n",
+                    flags, PTS_DTS_flags, ESCR_flag, ES_rate_flag, DSM_trick_mode_flag, additional_copy_info_flag, PES_CRC_flag, PES_extension_flag);
+#endif
+
+            u_int8_t PES_header_data_length = get1Byte();
+#ifdef DEBUG_CONTENTS
+            fprintf(stderr, "\t\t\tPES_header_data_length: %d\n", PES_header_data_length);
+#endif
+
+            if(PTS_DTS_flags == 2 || PTS_DTS_flags == 3) {
+                // Begin with a PTS:
+                u_int8_t  first8PTSBits = get1Byte();
+                u_int32_t last32PTSBits = get4Bytes();
+                if((first8PTSBits & 0xF1) != ((PTS_DTS_flags << 4) | 0x01) || (last32PTSBits & 0x00010001) != 0x00010001) {
+#ifdef DEBUG_ERRORS
+                    fprintf(stderr, "MPEG2TransportStreamParser::parsePESHeader(0x%02x, %d): Bad PTS bits: 0x%02x,0x%08x\n", pidState->PID, numDataBytes,
+                            first8PTSBits, last32PTSBits);
+#endif
+                    break;
+                }
+                u_int32_t ptsUpper32 = ((first8PTSBits & 0x0E) << 28) | ((last32PTSBits & 0xFFFE0000) >> 3) | ((last32PTSBits & 0x0000FFFC) >> 2);
+                u_int8_t  ptsLowBit  = (last32PTSBits & 0x00000002) >> 1;
+                double    PTS        = ptsUpper32 / 45000.0;
+                if(ptsLowBit)
+                    PTS += 1 / 90000.0;
+#ifdef DEBUG_CONTENTS
+                fprintf(stderr, "\t\t\tPTS: 0x%02x%08x => 0x%08x+%d => %.10f\n", first8PTSBits, last32PTSBits, ptsUpper32, ptsLowBit, PTS);
+#endif
+                // Record this PTS:
+                pidState->lastSeenPTS = PTS;
+            }
+
+            if(PTS_DTS_flags == 3) {
+                // Continue with a DTS:
+                u_int8_t  first8DTSBits = get1Byte();
+                u_int32_t last32DTSBits = get4Bytes();
+                if((first8DTSBits & 0x11) != 0x11 || (last32DTSBits & 0x00010001) != 0x00010001) {
+#ifdef DEBUG_ERRORS
+                    fprintf(stderr, "MPEG2TransportStreamParser::parsePESHeader(0x%02x, %d): Bad DTS bits: 0x%02x,0x%08x\n", pidState->PID, numDataBytes,
+                            first8DTSBits, last32DTSBits);
+#endif
+                    break;
+                }
+                u_int32_t dtsUpper32 = ((first8DTSBits & 0x0E) << 28) | ((last32DTSBits & 0xFFFE0000) >> 3) | ((last32DTSBits & 0x0000FFFC) >> 2);
+                u_int8_t  dtsLowBit  = (last32DTSBits & 0x00000002) >> 1;
+                double    DTS        = dtsUpper32 / 45000.0;
+                if(dtsLowBit)
+                    DTS += 1 / 90000.0;
+#ifdef DEBUG_CONTENTS
+                fprintf(stderr, "\t\t\tDTS: 0x%02x%08x => 0x%08x+%d => %.10f\n", first8DTSBits, last32DTSBits, dtsUpper32, dtsLowBit, DTS);
+#endif
+            }
+
+            if(ESCR_flag) {
+                // Skip over the ESCR
+                skipBytes(6);
+            }
+
+            if(ES_rate_flag) {
+                // Skip over the ES_rate
+                skipBytes(6);
+            }
+
+            if(DSM_trick_mode_flag) {
+                // Skip over this
+                skipBytes(1);
+            }
+
+            if(additional_copy_info_flag) {
+                // Skip over this
+                skipBytes(1);
+            }
+
+            if(PES_CRC_flag) {
+                // Skip over this
+                skipBytes(2);
+            }
+
+            if(PES_extension_flag) {
+                u_int8_t flags                                = get1Byte();
+                Boolean  PES_private_data_flag                = (flags & 0x80) != 0;
+                Boolean  pack_header_field_flag               = (flags & 0x40) != 0;
+                Boolean  program_packet_sequence_counter_flag = (flags & 0x20) != 0;
+                Boolean  P_STD_buffer_flag                    = (flags & 0x10) != 0;
+                Boolean  PES_extension_flag_2                 = (flags & 0x01) != 0;
+#ifdef DEBUG_CONTENTS
+                fprintf(stderr,
+                        "\t\t\tPES_extension: flags: 0x%02x (PES_private_data:%d; pack_header_field:%d; program_packet_sequence_counter:%d; P_STD_buffer:%d; "
+                        "PES_extension_2:%d\n",
+                        flags, PES_private_data_flag, pack_header_field_flag, program_packet_sequence_counter_flag, P_STD_buffer_flag, PES_extension_flag_2);
+#endif
+                if(PES_private_data_flag) {
+                    // Skip over this
+                    skipBytes(16);
+                }
+                if(pack_header_field_flag) {
+                    // Skip over this
+                    skipBytes(1 + 12);  // "pack_header()" is 12 bytes in size
+                }
+                if(program_packet_sequence_counter_flag) {
+                    // Skip over this
+                    skipBytes(2);
+                }
+                if(P_STD_buffer_flag) {
+                    // Skip over this
+                    skipBytes(2);
+                }
+                if(PES_extension_flag_2) {
+                    u_int8_t PES_extension_field_length = get1Byte() & 0x7F;
+#ifdef DEBUG_CONTENTS
+                    fprintf(stderr, "\t\t\t\tPES_extension_field_length: %d\n", PES_extension_field_length);
+#endif
+                    skipBytes(PES_extension_field_length);
+                }
+            }
+
+            // Make sure that the number of header bytes parsed is consistent with "PES_header_data_length"
+            // (and skip over any remasining 'stuffing' bytes):
+            if(curOffset() - startPos > 9 + PES_header_data_length) {
+#ifdef DEBUG_ERRORS
+                fprintf(stderr,
+                        "MPEG2TransportStreamParser::parsePESHeader(0x%02x, %d): Error: Parsed %d PES header bytes; expected %d (based on "
+                        "\"PES_header_data_length\": %d)\n",
+                        pidState->PID, numDataBytes, curOffset() - startPos, 9 + PES_header_data_length, PES_header_data_length);
+#endif
+                break;
+            }
+            skipBytes(9 + PES_header_data_length - (curOffset() - startPos));  // >= 0
+        }
+
+        unsigned PESHeaderSize = curOffset() - startPos;
+#ifdef DEBUG_CONTENTS
+        fprintf(stderr, "\t\t\t=> PES header size: %d\n", PESHeaderSize);
+#endif
+        if(PESHeaderSize > numDataBytes) {
+#ifdef DEBUG_ERRORS
+            fprintf(stderr,
+                    "MPEG2TransportStreamParser::parsePESHeader(0x%02x, %d): Error: PES header size %d is larger than the number of bytes available (%d)\n",
+                    pidState->PID, numDataBytes, PESHeaderSize, numDataBytes);
+#endif
+            break;
+        }
+        return PESHeaderSize;
+    } while(0);
+
+    // An error occurred.  Skip over any remaining bytes in the packet:
+    int numBytesLeft = numDataBytes - (curOffset() - startPos);
+    if(numBytesLeft > 0)
+        skipBytes((unsigned)numBytesLeft);
+    return 0;
+}
+
+//########## PIDState_STREAM implementation ##########
+
+PIDState_STREAM::PIDState_STREAM(MPEG2TransportStreamParser &parser, u_int16_t pid, u_int16_t programNumber, u_int8_t streamType)
+    : PIDState(parser, pid, STREAM), program_number(programNumber), stream_type(streamType), lastSeenPTS(0.0) {
+    // Create the 'source' and 'sink' objects for this track, and 'start playing' them:
+    streamSource = new MPEG2TransportStreamDemuxedTrack(parser, pid);
+
+    char              fileName[100];
+    extern StreamType StreamTypes[];
+    StreamType &      st = StreamTypes[streamType];  // alias
+    sprintf(fileName, "%s-0x%04x-0x%04x%s",
+            st.dataType == StreamType::AUDIO   ? "AUDIO"
+            : st.dataType == StreamType::VIDEO ? "VIDEO"
+            : st.dataType == StreamType::DATA  ? "DATA"
+            : st.dataType == StreamType::TEXT  ? "TEXT"
+                                               : "UNKNOWN",
+            program_number, pid, st.filenameSuffix);
+    fprintf(stderr, "Creating new output file \"%s\"\n", fileName);
+    streamSink = FileSink::createNew(parser.envir(), fileName);
+    streamSink->startPlaying(*streamSource, NULL, NULL);
+}
+
+PIDState_STREAM::~PIDState_STREAM() {
+    Medium::close(streamSink);
+    Medium::close(streamSource);
+}
diff --git a/3rdparty/live555/src/liveMedia/MPEG2TransportStreamTrickModeFilter.cpp b/3rdparty/live555/src/liveMedia/MPEG2TransportStreamTrickModeFilter.cpp
new file mode 100644
index 00000000..4b2292d5
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/MPEG2TransportStreamTrickModeFilter.cpp
@@ -0,0 +1,267 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A filter that converts a MPEG Transport Stream file - with corresponding index file
+// - to a corresponding Video Elementary Stream.  It also uses a "scale" parameter
+// to implement 'trick mode' (fast forward or reverse play, using I-frames) on
+// the video stream.
+// Implementation
+
+#include "MPEG2TransportStreamTrickModeFilter.hh"
+#include <ByteStreamFileSource.hh>
+
+// Define the following to be True if we want the output file to have the same frame rate as the original file.
+//    (Because the output file contains I-frames only, this means that each I-frame will appear in the output file
+//     several times, and therefore the output file's bitrate will be significantly higher than that of the original.)
+// Define the following to be False if we want the output file to include each I-frame no more than once.
+//    (This means that - except for high 'scale' values - both the output frame rate and the output bit rate
+//     will be less than that of the original.)
+#define KEEP_ORIGINAL_FRAME_RATE False
+
+MPEG2TransportStreamTrickModeFilter *MPEG2TransportStreamTrickModeFilter ::createNew(UsageEnvironment &env, FramedSource *inputSource,
+                                                                                     MPEG2TransportStreamIndexFile *indexFile, int scale) {
+    return new MPEG2TransportStreamTrickModeFilter(env, inputSource, indexFile, scale);
+}
+
+MPEG2TransportStreamTrickModeFilter ::MPEG2TransportStreamTrickModeFilter(UsageEnvironment &env, FramedSource *inputSource,
+                                                                          MPEG2TransportStreamIndexFile *indexFile, int scale)
+    : FramedFilter(env, inputSource),
+      fHaveStarted(False),
+      fIndexFile(indexFile),
+      fScale(scale),
+      fDirection(1),
+      fState(SKIPPING_FRAME),
+      fFrameCount(0),
+      fNextIndexRecordNum(0),
+      fNextTSPacketNum(0),
+      fCurrentTSPacketNum((unsigned long)(-1)),
+      fUseSavedFrameNextTime(False) {
+    if(fScale < 0) {  // reverse play
+        fScale     = -fScale;
+        fDirection = -1;
+    }
+}
+
+MPEG2TransportStreamTrickModeFilter::~MPEG2TransportStreamTrickModeFilter() {}
+
+Boolean MPEG2TransportStreamTrickModeFilter::seekTo(unsigned long tsPacketNumber, unsigned long indexRecordNumber) {
+    seekToTransportPacket(tsPacketNumber);
+    fNextIndexRecordNum = indexRecordNumber;
+    return True;
+}
+
+#define isIFrameStart(type) \
+    ((type) == 0x81 /*actually, a VSH*/ || (type) == 0x85 /*actually, a SPS, for H.264*/ || (type) == 0x8B /*actually, a VPS, for H.265*/)
+// This relies upon I-frames always being preceded by a VSH+GOP (for MPEG-2 data),
+// by a SPS (for H.264 data), or by a VPS (for H.265 data)
+#define isNonIFrameStart(type) ((type) == 0x83 || (type) == 0x88 /*for H.264*/ || (type) == 0x8E /*for H.265*/)
+
+void MPEG2TransportStreamTrickModeFilter::doGetNextFrame() {
+    //  fprintf(stderr, "#####DGNF1\n");
+    // If our client's buffer size is too small, then deliver
+    // a 0-byte 'frame', to tell it to process all of the data that it has
+    // already read, before asking for more data from us:
+    if(fMaxSize < TRANSPORT_PACKET_SIZE) {
+        fFrameSize = 0;
+        afterGetting(this);
+        return;
+    }
+
+    while(1) {
+        // Get the next record from our index file.
+        // This tells us the type of frame this data is, which Transport Stream packet
+        // (from the input source) the data comes from, and where in the Transport Stream
+        // packet it comes from:
+        u_int8_t recordType;
+        float    recordPCR;
+        Boolean  endOfIndexFile = False;
+        if(!fIndexFile->readIndexRecordValues(fNextIndexRecordNum, fDesiredTSPacketNum, fDesiredDataOffset, fDesiredDataSize, recordPCR, recordType)) {
+            // We ran off the end of the index file.  If we're not delivering a
+            // pre-saved frame, then handle this the same way as if the
+            // input Transport Stream source ended.
+            if(fState != DELIVERING_SAVED_FRAME) {
+                onSourceClosure1();
+                return;
+            }
+            endOfIndexFile = True;
+        }
+        else if(!fHaveStarted) {
+            fFirstPCR    = recordPCR;
+            fHaveStarted = True;
+        }
+        //    fprintf(stderr, "#####read index record %ld: ts %ld: %c, PCR %f\n", fNextIndexRecordNum, fDesiredTSPacketNum, isIFrameStart(recordType) ? 'I' :
+        //    isNonIFrameStart(recordType) ? 'j' : 'x', recordPCR);
+        fNextIndexRecordNum += (fState == DELIVERING_SAVED_FRAME) ? 1 : fDirection;
+
+        // Handle this index record, depending on the record type and our current state:
+        switch(fState) {
+        case SKIPPING_FRAME:
+        case SAVING_AND_DELIVERING_FRAME: {
+            //      if (fState == SKIPPING_FRAME) fprintf(stderr, "\tSKIPPING_FRAME\n"); else fprintf(stderr, "\tSAVING_AND_DELIVERING_FRAME\n");//#####
+            if(isIFrameStart(recordType)) {
+                // Save a record of this frame:
+                fSavedFrameIndexRecordStart = fNextIndexRecordNum - fDirection;
+                fUseSavedFrameNextTime      = True;
+                //	fprintf(stderr, "\trecording\n");//#####
+                if((fFrameCount++) % fScale == 0 && fUseSavedFrameNextTime) {
+                    // A frame is due now.
+                    fFrameCount = 1;  // reset to avoid overflow
+                    if(fDirection > 0) {
+                        // Begin delivering this frame, as we're scanning it:
+                        fState = SAVING_AND_DELIVERING_FRAME;
+                        //	    fprintf(stderr, "\tdelivering\n");//#####
+                        fDesiredDataPCR = recordPCR;  // use this frame's PCR
+                        attemptDeliveryToClient();
+                        return;
+                    }
+                    else {
+                        // Deliver this frame, then resume normal scanning:
+                        // (This relies on the index records having begun with an I-frame.)
+                        fState                         = DELIVERING_SAVED_FRAME;
+                        fSavedSequentialIndexRecordNum = fNextIndexRecordNum;
+                        fDesiredDataPCR                = recordPCR;
+                        // use this frame's (not the saved frame's) PCR
+                        fNextIndexRecordNum = fSavedFrameIndexRecordStart;
+                        //	    fprintf(stderr, "\tbeginning delivery of saved frame\n");//#####
+                    }
+                }
+                else {
+                    // No frame is needed now:
+                    fState = SKIPPING_FRAME;
+                }
+            }
+            else if(isNonIFrameStart(recordType)) {
+                if((fFrameCount++) % fScale == 0 && fUseSavedFrameNextTime) {
+                    // A frame is due now, so begin delivering the one that we had saved:
+                    // (This relies on the index records having begun with an I-frame.)
+                    fFrameCount                    = 1;  // reset to avoid overflow
+                    fState                         = DELIVERING_SAVED_FRAME;
+                    fSavedSequentialIndexRecordNum = fNextIndexRecordNum;
+                    fDesiredDataPCR                = recordPCR;
+                    // use this frame's (not the saved frame's) PCR
+                    fNextIndexRecordNum = fSavedFrameIndexRecordStart;
+                    //	  fprintf(stderr, "\tbeginning delivery of saved frame\n");//#####
+                }
+                else {
+                    // No frame is needed now:
+                    fState = SKIPPING_FRAME;
+                }
+            }
+            else {
+                // Not the start of a frame, but deliver it, if it's needed:
+                if(fState == SAVING_AND_DELIVERING_FRAME) {
+                    //	  fprintf(stderr, "\tdelivering\n");//#####
+                    fDesiredDataPCR = recordPCR;  // use this frame's PCR
+                    attemptDeliveryToClient();
+                    return;
+                }
+            }
+            break;
+        }
+        case DELIVERING_SAVED_FRAME: {
+            //      fprintf(stderr, "\tDELIVERING_SAVED_FRAME\n");//#####
+            if(endOfIndexFile || (isIFrameStart(recordType) && fNextIndexRecordNum - 1 != fSavedFrameIndexRecordStart) || isNonIFrameStart(recordType)) {
+                //	fprintf(stderr, "\tended delivery of saved frame\n");//#####
+                // We've reached the end of the saved frame, so revert to the
+                // original sequence of index records:
+                fNextIndexRecordNum    = fSavedSequentialIndexRecordNum;
+                fUseSavedFrameNextTime = KEEP_ORIGINAL_FRAME_RATE;
+                fState                 = SKIPPING_FRAME;
+            }
+            else {
+                // Continue delivering:
+                //	fprintf(stderr, "\tdelivering\n");//#####
+                attemptDeliveryToClient();
+                return;
+            }
+            break;
+        }
+        }
+    }
+}
+
+void MPEG2TransportStreamTrickModeFilter::doStopGettingFrames() {
+    FramedFilter::doStopGettingFrames();
+    fIndexFile->stopReading();
+}
+
+void MPEG2TransportStreamTrickModeFilter::attemptDeliveryToClient() {
+    if(fCurrentTSPacketNum == fDesiredTSPacketNum) {
+        //    fprintf(stderr, "\t\tdelivering ts %d:%d, %d bytes, PCR %f\n", fCurrentTSPacketNum, fDesiredDataOffset, fDesiredDataSize, fDesiredDataPCR);//#####
+        // We already have the Transport Packet that we want.  Deliver its data:
+        memmove(fTo, &fInputBuffer[fDesiredDataOffset], fDesiredDataSize);
+        fFrameSize        = fDesiredDataSize;
+        float deliveryPCR = fDirection * (fDesiredDataPCR - fFirstPCR) / fScale;
+        if(deliveryPCR < 0.0)
+            deliveryPCR = 0.0;
+        fPresentationTime.tv_sec  = (unsigned long)deliveryPCR;
+        fPresentationTime.tv_usec = (unsigned long)((deliveryPCR - fPresentationTime.tv_sec) * 1000000.0f);
+        //    fprintf(stderr, "#####DGNF9\n");
+
+        afterGetting(this);
+    }
+    else {
+        // Arrange to read the Transport Packet that we want:
+        readTransportPacket(fDesiredTSPacketNum);
+    }
+}
+
+void MPEG2TransportStreamTrickModeFilter::seekToTransportPacket(unsigned long tsPacketNum) {
+    if(tsPacketNum == fNextTSPacketNum)
+        return;  // we're already there
+
+    ByteStreamFileSource *tsFile        = (ByteStreamFileSource *)fInputSource;
+    u_int64_t             tsPacketNum64 = (u_int64_t)tsPacketNum;
+    tsFile->seekToByteAbsolute(tsPacketNum64 * TRANSPORT_PACKET_SIZE);
+
+    fNextTSPacketNum = tsPacketNum;
+}
+
+void MPEG2TransportStreamTrickModeFilter::readTransportPacket(unsigned long tsPacketNum) {
+    seekToTransportPacket(tsPacketNum);
+    fInputSource->getNextFrame(fInputBuffer, TRANSPORT_PACKET_SIZE, afterGettingFrame, this, onSourceClosure, this);
+}
+
+void MPEG2TransportStreamTrickModeFilter ::afterGettingFrame(void *clientData, unsigned frameSize, unsigned /*numTruncatedBytes*/,
+                                                             struct timeval presentationTime, unsigned /*durationInMicroseconds*/) {
+    MPEG2TransportStreamTrickModeFilter *filter = (MPEG2TransportStreamTrickModeFilter *)clientData;
+    filter->afterGettingFrame1(frameSize);
+}
+
+void MPEG2TransportStreamTrickModeFilter::afterGettingFrame1(unsigned frameSize) {
+    if(frameSize != TRANSPORT_PACKET_SIZE) {
+        // Treat this as if the input source ended:
+        onSourceClosure1();
+        return;
+    }
+
+    fCurrentTSPacketNum = fNextTSPacketNum;  // i.e., the one that we just read
+    ++fNextTSPacketNum;
+
+    // Attempt deliver again:
+    attemptDeliveryToClient();
+}
+
+void MPEG2TransportStreamTrickModeFilter::onSourceClosure(void *clientData) {
+    MPEG2TransportStreamTrickModeFilter *filter = (MPEG2TransportStreamTrickModeFilter *)clientData;
+    filter->onSourceClosure1();
+}
+
+void MPEG2TransportStreamTrickModeFilter::onSourceClosure1() {
+    fIndexFile->stopReading();
+    handleClosure();
+}
diff --git a/3rdparty/live555/src/liveMedia/MPEG2TransportUDPServerMediaSubsession.cpp b/3rdparty/live555/src/liveMedia/MPEG2TransportUDPServerMediaSubsession.cpp
new file mode 100644
index 00000000..1666488f
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/MPEG2TransportUDPServerMediaSubsession.cpp
@@ -0,0 +1,76 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A 'ServerMediaSubsession' object that creates new, unicast, "RTPSink"s
+// on demand, from an incoming UDP (or RTP/UDP) MPEG-2 Transport Stream
+// Implementation
+
+#include "MPEG2TransportUDPServerMediaSubsession.hh"
+#include "BasicUDPSource.hh"
+#include "SimpleRTPSource.hh"
+#include "MPEG2TransportStreamFramer.hh"
+#include "SimpleRTPSink.hh"
+#include "GroupsockHelper.hh"
+
+MPEG2TransportUDPServerMediaSubsession *MPEG2TransportUDPServerMediaSubsession::createNew(UsageEnvironment &env, char const *inputAddressStr,
+                                                                                          Port const &inputPort, Boolean inputStreamIsRawUDP) {
+    return new MPEG2TransportUDPServerMediaSubsession(env, inputAddressStr, inputPort, inputStreamIsRawUDP);
+}
+
+MPEG2TransportUDPServerMediaSubsession ::MPEG2TransportUDPServerMediaSubsession(UsageEnvironment &env, char const *inputAddressStr, Port const &inputPort,
+                                                                                Boolean inputStreamIsRawUDP)
+    : OnDemandServerMediaSubsession(env, True /*reuseFirstSource*/), fInputPort(inputPort), fInputGroupsock(NULL), fInputStreamIsRawUDP(inputStreamIsRawUDP) {
+    fInputAddressStr = strDup(inputAddressStr);
+}
+
+MPEG2TransportUDPServerMediaSubsession::~MPEG2TransportUDPServerMediaSubsession() {
+    delete fInputGroupsock;
+    delete[](char *) fInputAddressStr;
+}
+
+FramedSource *MPEG2TransportUDPServerMediaSubsession ::createNewStreamSource(unsigned /* clientSessionId*/, unsigned &estBitrate) {
+    estBitrate = 5000;  // kbps, estimate
+
+    if(fInputGroupsock == NULL) {
+        // Create a 'groupsock' object for receiving the input stream:
+        struct sockaddr_storage inputAddress;
+        if(fInputAddressStr == NULL) {
+            inputAddress = nullAddress();
+        }
+        else {
+            NetAddressList inputAddresses(fInputAddressStr);
+            if(inputAddresses.numAddresses() == 0)
+                return NULL;
+            copyAddress(inputAddress, inputAddresses.firstAddress());
+        }
+        fInputGroupsock = new Groupsock(envir(), inputAddress, fInputPort, 255);
+    }
+
+    FramedSource *transportStreamSource;
+    if(fInputStreamIsRawUDP) {
+        transportStreamSource = BasicUDPSource::createNew(envir(), fInputGroupsock);
+    }
+    else {
+        transportStreamSource = SimpleRTPSource::createNew(envir(), fInputGroupsock, 33, 90000, "video/MP2T", 0, False /*no 'M' bit*/);
+    }
+    return MPEG2TransportStreamFramer::createNew(envir(), transportStreamSource);
+}
+
+RTPSink *MPEG2TransportUDPServerMediaSubsession ::createNewRTPSink(Groupsock *rtpGroupsock, unsigned char /*rtpPayloadTypeIfDynamic*/,
+                                                                   FramedSource * /*inputSource*/) {
+    return SimpleRTPSink::createNew(envir(), rtpGroupsock, 33, 90000, "video", "MP2T", 1, True, False /*no 'M' bit*/);
+}
diff --git a/3rdparty/live555/src/liveMedia/MPEG4ESVideoRTPSink.cpp b/3rdparty/live555/src/liveMedia/MPEG4ESVideoRTPSink.cpp
new file mode 100644
index 00000000..6e3c8180
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/MPEG4ESVideoRTPSink.cpp
@@ -0,0 +1,132 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// RTP sink for MPEG-4 Elementary Stream video (RFC 3016)
+// Implementation
+
+#include "MPEG4ESVideoRTPSink.hh"
+#include "MPEG4VideoStreamFramer.hh"
+#include "MPEG4LATMAudioRTPSource.hh"  // for "parseGeneralConfigStr()"
+
+MPEG4ESVideoRTPSink ::MPEG4ESVideoRTPSink(UsageEnvironment &env, Groupsock *RTPgs, unsigned char rtpPayloadFormat, u_int32_t rtpTimestampFrequency,
+                                          u_int8_t profileAndLevelIndication, char const *configStr)
+    : VideoRTPSink(env, RTPgs, rtpPayloadFormat, rtpTimestampFrequency, "MP4V-ES"),
+      fVOPIsPresent(False),
+      fProfileAndLevelIndication(profileAndLevelIndication),
+      fFmtpSDPLine(NULL) {
+    fConfigBytes = parseGeneralConfigStr(configStr, fNumConfigBytes);
+}
+
+MPEG4ESVideoRTPSink::~MPEG4ESVideoRTPSink() {
+    delete[] fFmtpSDPLine;
+    delete[] fConfigBytes;
+}
+
+MPEG4ESVideoRTPSink *MPEG4ESVideoRTPSink::createNew(UsageEnvironment &env, Groupsock *RTPgs, unsigned char rtpPayloadFormat, u_int32_t rtpTimestampFrequency) {
+    return new MPEG4ESVideoRTPSink(env, RTPgs, rtpPayloadFormat, rtpTimestampFrequency);
+}
+
+MPEG4ESVideoRTPSink *MPEG4ESVideoRTPSink::createNew(UsageEnvironment &env, Groupsock *RTPgs, unsigned char rtpPayloadFormat, u_int32_t rtpTimestampFrequency,
+                                                    u_int8_t profileAndLevelIndication, char const *configStr) {
+    return new MPEG4ESVideoRTPSink(env, RTPgs, rtpPayloadFormat, rtpTimestampFrequency, profileAndLevelIndication, configStr);
+}
+
+Boolean MPEG4ESVideoRTPSink::sourceIsCompatibleWithUs(MediaSource &source) {
+    // Our source must be an appropriate framer:
+    return source.isMPEG4VideoStreamFramer();
+}
+
+#define VOP_START_CODE 0x000001B6
+
+void MPEG4ESVideoRTPSink ::doSpecialFrameHandling(unsigned fragmentationOffset, unsigned char *frameStart, unsigned numBytesInFrame,
+                                                  struct timeval framePresentationTime, unsigned numRemainingBytes) {
+    if(fragmentationOffset == 0) {
+        // Begin by inspecting the 4-byte code at the start of the frame:
+        if(numBytesInFrame < 4)
+            return;  // shouldn't happen
+        u_int32_t startCode = (frameStart[0] << 24) | (frameStart[1] << 16) | (frameStart[2] << 8) | frameStart[3];
+
+        fVOPIsPresent = startCode == VOP_START_CODE;
+    }
+
+    // Set the RTP 'M' (marker) bit iff this frame ends a VOP
+    // (and there are no fragments remaining).
+    // This relies on the source being a "MPEG4VideoStreamFramer".
+    MPEG4VideoStreamFramer *framerSource = (MPEG4VideoStreamFramer *)fSource;
+    if(framerSource != NULL && framerSource->pictureEndMarker() && numRemainingBytes == 0) {
+        setMarkerBit();
+        framerSource->pictureEndMarker() = False;
+    }
+
+    // Also set the RTP timestamp.  (We do this for each frame
+    // in the packet, to ensure that the timestamp of the VOP (if present)
+    // gets used.)
+    setTimestamp(framePresentationTime);
+}
+
+Boolean MPEG4ESVideoRTPSink::allowFragmentationAfterStart() const {
+    return True;
+}
+
+Boolean MPEG4ESVideoRTPSink ::frameCanAppearAfterPacketStart(unsigned char const * /*frameStart*/, unsigned /*numBytesInFrame*/) const {
+    // Once we've packed a VOP into the packet, then no other
+    // frame can be packed into it:
+    return !fVOPIsPresent;
+}
+
+char const *MPEG4ESVideoRTPSink::auxSDPLine() {
+    // Generate a new "a=fmtp:" line each time, using our own 'configuration' information (if we have it),
+    // otherwise parameters from our framer source (in case they've changed since the last time that
+    // we were called):
+    unsigned       configLength = fNumConfigBytes;
+    unsigned char *config       = fConfigBytes;
+    if(fProfileAndLevelIndication == 0 || config == NULL) {
+        // We need to get this information from our framer source:
+        MPEG4VideoStreamFramer *framerSource = (MPEG4VideoStreamFramer *)fSource;
+        if(framerSource == NULL)
+            return NULL;  // we don't yet have a source
+
+        fProfileAndLevelIndication = framerSource->profile_and_level_indication();
+        if(fProfileAndLevelIndication == 0)
+            return NULL;  // our source isn't ready
+
+        config = framerSource->getConfigBytes(configLength);
+        if(config == NULL)
+            return NULL;  // our source isn't ready
+    }
+
+    char const *fmtpFmt = "a=fmtp:%d "
+                          "profile-level-id=%d;"
+                          "config=";
+    unsigned fmtpFmtSize = strlen(fmtpFmt) + 3 /* max char len */
+                           + 3                 /* max char len */
+                           + 2 * configLength  /* 2*, because each byte prints as 2 chars */
+                           + 2 /* trailing \r\n */;
+    char *fmtp = new char[fmtpFmtSize];
+    sprintf(fmtp, fmtpFmt, rtpPayloadType(), fProfileAndLevelIndication);
+    char *endPtr = &fmtp[strlen(fmtp)];
+    for(unsigned i = 0; i < configLength; ++i) {
+        sprintf(endPtr, "%02X", config[i]);
+        endPtr += 2;
+    }
+    sprintf(endPtr, "\r\n");
+
+    delete[] fFmtpSDPLine;
+    fFmtpSDPLine = strDup(fmtp);
+    delete[] fmtp;
+    return fFmtpSDPLine;
+}
diff --git a/3rdparty/live555/src/liveMedia/MPEG4ESVideoRTPSource.cpp b/3rdparty/live555/src/liveMedia/MPEG4ESVideoRTPSource.cpp
new file mode 100644
index 00000000..674db5dd
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/MPEG4ESVideoRTPSource.cpp
@@ -0,0 +1,52 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// MP4V-ES video RTP stream sources
+// Implementation
+
+#include "MPEG4ESVideoRTPSource.hh"
+
+///////// MPEG4ESVideoRTPSource implementation ////////
+
+//##### NOTE: INCOMPLETE!!! #####
+
+MPEG4ESVideoRTPSource *MPEG4ESVideoRTPSource::createNew(UsageEnvironment &env, Groupsock *RTPgs, unsigned char rtpPayloadFormat,
+                                                        unsigned rtpTimestampFrequency) {
+    return new MPEG4ESVideoRTPSource(env, RTPgs, rtpPayloadFormat, rtpTimestampFrequency);
+}
+
+MPEG4ESVideoRTPSource ::MPEG4ESVideoRTPSource(UsageEnvironment &env, Groupsock *RTPgs, unsigned char rtpPayloadFormat, unsigned rtpTimestampFrequency)
+    : MultiFramedRTPSource(env, RTPgs, rtpPayloadFormat, rtpTimestampFrequency) {}
+
+MPEG4ESVideoRTPSource::~MPEG4ESVideoRTPSource() {}
+
+Boolean MPEG4ESVideoRTPSource ::processSpecialHeader(BufferedPacket *packet, unsigned &resultSpecialHeaderSize) {
+    // The packet begins a frame iff its data begins with a system code
+    // (i.e., 0x000001??)
+    fCurrentPacketBeginsFrame = packet->dataSize() >= 4 && (packet->data())[0] == 0 && (packet->data())[1] == 0 && (packet->data())[2] == 1;
+
+    // The RTP "M" (marker) bit indicates the last fragment of a frame:
+    fCurrentPacketCompletesFrame = packet->rtpMarkerBit();
+
+    // There is no special header
+    resultSpecialHeaderSize = 0;
+    return True;
+}
+
+char const *MPEG4ESVideoRTPSource::MIMEtype() const {
+    return "video/MP4V-ES";
+}
diff --git a/3rdparty/live555/src/liveMedia/MPEG4GenericRTPSink.cpp b/3rdparty/live555/src/liveMedia/MPEG4GenericRTPSink.cpp
new file mode 100644
index 00000000..69961845
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/MPEG4GenericRTPSink.cpp
@@ -0,0 +1,116 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// MPEG4-GENERIC ("audio", "video", or "application") RTP stream sinks
+// Implementation
+
+#include "MPEG4GenericRTPSink.hh"
+#include "Locale.hh"
+#include <ctype.h>  // needed on some systems to define "tolower()"
+
+MPEG4GenericRTPSink ::MPEG4GenericRTPSink(UsageEnvironment &env, Groupsock *RTPgs, u_int8_t rtpPayloadFormat, u_int32_t rtpTimestampFrequency,
+                                          char const *sdpMediaTypeString, char const *mpeg4Mode, char const *configString, unsigned numChannels)
+    : MultiFramedRTPSink(env, RTPgs, rtpPayloadFormat, rtpTimestampFrequency, "MPEG4-GENERIC", numChannels),
+      fSDPMediaTypeString(strDup(sdpMediaTypeString)),
+      fMPEG4Mode(strDup(mpeg4Mode)),
+      fConfigString(strDup(configString)) {
+    // Check whether "mpeg4Mode" is one that we handle:
+    if(mpeg4Mode == NULL) {
+        env << "MPEG4GenericRTPSink error: NULL \"mpeg4Mode\" parameter\n";
+    }
+    else {
+        // To ease comparison, convert "mpeg4Mode" to lower case:
+        size_t const len = strlen(mpeg4Mode) + 1;
+        char *       m   = new char[len];
+
+        Locale l("POSIX");
+        for(size_t i = 0; i < len; ++i)
+            m[i] = tolower(mpeg4Mode[i]);
+
+        if(strcmp(m, "aac-hbr") != 0) {
+            env << "MPEG4GenericRTPSink error: Unknown \"mpeg4Mode\" parameter: \"" << mpeg4Mode << "\"\n";
+        }
+        delete[] m;
+    }
+
+    // Set up the "a=fmtp:" SDP line for this stream:
+    char const *fmtpFmt = "a=fmtp:%d "
+                          "streamtype=%d;profile-level-id=1;"
+                          "mode=%s;sizelength=13;indexlength=3;indexdeltalength=3;"
+                          "config=%s\r\n";
+    unsigned fmtpFmtSize = strlen(fmtpFmt) + 3 /* max char len */
+                           + 3                 /* max char len */
+                           + strlen(fMPEG4Mode) + strlen(fConfigString);
+    char *fmtp = new char[fmtpFmtSize];
+    sprintf(fmtp, fmtpFmt, rtpPayloadType(), strcmp(fSDPMediaTypeString, "video") == 0 ? 4 : 5, fMPEG4Mode, fConfigString);
+    fFmtpSDPLine = strDup(fmtp);
+    delete[] fmtp;
+}
+
+MPEG4GenericRTPSink::~MPEG4GenericRTPSink() {
+    delete[] fFmtpSDPLine;
+    delete[](char *) fConfigString;
+    delete[](char *) fMPEG4Mode;
+    delete[](char *) fSDPMediaTypeString;
+}
+
+MPEG4GenericRTPSink *MPEG4GenericRTPSink::createNew(UsageEnvironment &env, Groupsock *RTPgs, u_int8_t rtpPayloadFormat, u_int32_t rtpTimestampFrequency,
+                                                    char const *sdpMediaTypeString, char const *mpeg4Mode, char const *configString, unsigned numChannels) {
+    return new MPEG4GenericRTPSink(env, RTPgs, rtpPayloadFormat, rtpTimestampFrequency, sdpMediaTypeString, mpeg4Mode, configString, numChannels);
+}
+
+Boolean MPEG4GenericRTPSink ::frameCanAppearAfterPacketStart(unsigned char const * /*frameStart*/, unsigned /*numBytesInFrame*/) const {
+    // (For now) allow at most 1 frame in a single packet:
+    return False;
+}
+
+void MPEG4GenericRTPSink ::doSpecialFrameHandling(unsigned fragmentationOffset, unsigned char *frameStart, unsigned numBytesInFrame,
+                                                  struct timeval framePresentationTime, unsigned numRemainingBytes) {
+    // Set the "AU Header Section".  This is 4 bytes: 2 bytes for the
+    // initial "AU-headers-length" field, and 2 bytes for the first
+    // (and only) "AU Header":
+    unsigned      fullFrameSize = fragmentationOffset + numBytesInFrame + numRemainingBytes;
+    unsigned char headers[4];
+    headers[0] = 0;
+    headers[1] = 16 /* bits */;  // AU-headers-length
+    headers[2] = fullFrameSize >> 5;
+    headers[3] = (fullFrameSize & 0x1F) << 3;
+
+    setSpecialHeaderBytes(headers, sizeof headers);
+
+    if(numRemainingBytes == 0) {
+        // This packet contains the last (or only) fragment of the frame.
+        // Set the RTP 'M' ('marker') bit:
+        setMarkerBit();
+    }
+
+    // Important: Also call our base class's doSpecialFrameHandling(),
+    // to set the packet's timestamp:
+    MultiFramedRTPSink::doSpecialFrameHandling(fragmentationOffset, frameStart, numBytesInFrame, framePresentationTime, numRemainingBytes);
+}
+
+unsigned MPEG4GenericRTPSink::specialHeaderSize() const {
+    return 2 + 2;
+}
+
+char const *MPEG4GenericRTPSink::sdpMediaType() const {
+    return fSDPMediaTypeString;
+}
+
+char const *MPEG4GenericRTPSink::auxSDPLine() {
+    return fFmtpSDPLine;
+}
diff --git a/3rdparty/live555/src/liveMedia/MPEG4GenericRTPSource.cpp b/3rdparty/live555/src/liveMedia/MPEG4GenericRTPSource.cpp
new file mode 100644
index 00000000..aaa963b7
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/MPEG4GenericRTPSource.cpp
@@ -0,0 +1,203 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// MPEG4-GENERIC ("audio", "video", or "application") RTP stream sources
+// Implementation
+
+#include "MPEG4GenericRTPSource.hh"
+#include "BitVector.hh"
+#include "MPEG4LATMAudioRTPSource.hh"  // for parseGeneralConfigStr()
+
+////////// MPEG4GenericBufferedPacket and MPEG4GenericBufferedPacketFactory
+
+class MPEG4GenericBufferedPacket : public BufferedPacket {
+public:
+    MPEG4GenericBufferedPacket(MPEG4GenericRTPSource *ourSource);
+    virtual ~MPEG4GenericBufferedPacket();
+
+private:  // redefined virtual functions
+    virtual unsigned nextEnclosedFrameSize(unsigned char *&framePtr, unsigned dataSize);
+
+private:
+    MPEG4GenericRTPSource *fOurSource;
+};
+
+class MPEG4GenericBufferedPacketFactory : public BufferedPacketFactory {
+private:  // redefined virtual functions
+    virtual BufferedPacket *createNewPacket(MultiFramedRTPSource *ourSource);
+};
+
+////////// AUHeader //////////
+struct AUHeader {
+    unsigned size;
+    unsigned index;  // indexDelta for the 2nd & subsequent headers
+};
+
+///////// MPEG4GenericRTPSource implementation ////////
+
+//##### NOTE: INCOMPLETE!!! Support more modes, and interleaving #####
+
+MPEG4GenericRTPSource *MPEG4GenericRTPSource::createNew(UsageEnvironment &env, Groupsock *RTPgs, unsigned char rtpPayloadFormat, unsigned rtpTimestampFrequency,
+                                                        char const *mediumName, char const *mode, unsigned sizeLength, unsigned indexLength,
+                                                        unsigned indexDeltaLength) {
+    return new MPEG4GenericRTPSource(env, RTPgs, rtpPayloadFormat, rtpTimestampFrequency, mediumName, mode, sizeLength, indexLength, indexDeltaLength);
+}
+
+MPEG4GenericRTPSource ::MPEG4GenericRTPSource(UsageEnvironment &env, Groupsock *RTPgs, unsigned char rtpPayloadFormat, unsigned rtpTimestampFrequency,
+                                              char const *mediumName, char const *mode, unsigned sizeLength, unsigned indexLength, unsigned indexDeltaLength)
+    : MultiFramedRTPSource(env, RTPgs, rtpPayloadFormat, rtpTimestampFrequency, new MPEG4GenericBufferedPacketFactory),
+      fSizeLength(sizeLength),
+      fIndexLength(indexLength),
+      fIndexDeltaLength(indexDeltaLength),
+      fNumAUHeaders(0),
+      fNextAUHeader(0),
+      fAUHeaders(NULL) {
+    unsigned mimeTypeLength = strlen(mediumName) + 14 /* strlen("/MPEG4-GENERIC") */ + 1;
+    fMIMEType               = new char[mimeTypeLength];
+    if(fMIMEType != NULL) {
+        sprintf(fMIMEType, "%s/MPEG4-GENERIC", mediumName);
+    }
+
+    fMode = strDup(mode);
+    // Check for a "mode" that we don't yet support: //#####
+    if(mode == NULL || (strcmp(mode, "aac-hbr") != 0 && strcmp(mode, "generic") != 0)) {
+        envir() << "MPEG4GenericRTPSource Warning: Unknown or unsupported \"mode\": " << mode << "\n";
+    }
+}
+
+MPEG4GenericRTPSource::~MPEG4GenericRTPSource() {
+    delete[] fAUHeaders;
+    delete[] fMode;
+    delete[] fMIMEType;
+}
+
+Boolean MPEG4GenericRTPSource ::processSpecialHeader(BufferedPacket *packet, unsigned &resultSpecialHeaderSize) {
+    unsigned char *headerStart = packet->data();
+    unsigned       packetSize  = packet->dataSize();
+
+    fCurrentPacketBeginsFrame = fCurrentPacketCompletesFrame;
+    // whether the *previous* packet ended a frame
+
+    // The RTP "M" (marker) bit indicates the last fragment of a frame:
+    fCurrentPacketCompletesFrame = packet->rtpMarkerBit();
+
+    // default values:
+    resultSpecialHeaderSize = 0;
+    fNumAUHeaders           = 0;
+    fNextAUHeader           = 0;
+    delete[] fAUHeaders;
+    fAUHeaders = NULL;
+
+    if(fSizeLength > 0) {
+        // The packet begins with a "AU Header Section".  Parse it, to
+        // determine the "AU-header"s for each frame present in this packet:
+        resultSpecialHeaderSize += 2;
+        if(packetSize < resultSpecialHeaderSize)
+            return False;
+
+        unsigned AU_headers_length       = (headerStart[0] << 8) | headerStart[1];
+        unsigned AU_headers_length_bytes = (AU_headers_length + 7) / 8;
+        if(packetSize < resultSpecialHeaderSize + AU_headers_length_bytes)
+            return False;
+        resultSpecialHeaderSize += AU_headers_length_bytes;
+
+        // Figure out how many AU-headers are present in the packet:
+        int bitsAvail = AU_headers_length - (fSizeLength + fIndexLength);
+        if(bitsAvail >= 0 && (fSizeLength + fIndexDeltaLength) > 0) {
+            fNumAUHeaders = 1 + bitsAvail / (fSizeLength + fIndexDeltaLength);
+        }
+        if(fNumAUHeaders > 0) {
+            fAUHeaders = new AUHeader[fNumAUHeaders];
+            // Fill in each header:
+            BitVector bv(&headerStart[2], 0, AU_headers_length);
+            fAUHeaders[0].size  = bv.getBits(fSizeLength);
+            fAUHeaders[0].index = bv.getBits(fIndexLength);
+
+            for(unsigned i = 1; i < fNumAUHeaders; ++i) {
+                fAUHeaders[i].size  = bv.getBits(fSizeLength);
+                fAUHeaders[i].index = bv.getBits(fIndexDeltaLength);
+            }
+        }
+    }
+
+    return True;
+}
+
+char const *MPEG4GenericRTPSource::MIMEtype() const {
+    return fMIMEType;
+}
+
+////////// MPEG4GenericBufferedPacket
+////////// and MPEG4GenericBufferedPacketFactory implementation
+
+MPEG4GenericBufferedPacket ::MPEG4GenericBufferedPacket(MPEG4GenericRTPSource *ourSource) : fOurSource(ourSource) {}
+
+MPEG4GenericBufferedPacket::~MPEG4GenericBufferedPacket() {}
+
+unsigned MPEG4GenericBufferedPacket ::nextEnclosedFrameSize(unsigned char *& /*framePtr*/, unsigned dataSize) {
+    // WE CURRENTLY DON'T IMPLEMENT INTERLEAVING.  FIX THIS! #####
+    AUHeader *auHeader = fOurSource->fAUHeaders;
+    if(auHeader == NULL)
+        return dataSize;
+    unsigned numAUHeaders = fOurSource->fNumAUHeaders;
+
+    if(fOurSource->fNextAUHeader >= numAUHeaders) {
+        fOurSource->envir() << "MPEG4GenericBufferedPacket::nextEnclosedFrameSize(" << dataSize << "): data error (" << auHeader << ","
+                            << fOurSource->fNextAUHeader << "," << numAUHeaders << ")!\n";
+        return dataSize;
+    }
+
+    auHeader = &auHeader[fOurSource->fNextAUHeader++];
+    return auHeader->size <= dataSize ? auHeader->size : dataSize;
+}
+
+BufferedPacket *MPEG4GenericBufferedPacketFactory ::createNewPacket(MultiFramedRTPSource *ourSource) {
+    return new MPEG4GenericBufferedPacket((MPEG4GenericRTPSource *)ourSource);
+}
+
+////////// samplingFrequencyFromAudioSpecificConfig() implementation //////////
+
+static unsigned const samplingFrequencyFromIndex[16] = { 96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050, 16000, 12000, 11025, 8000, 7350, 0, 0, 0 };
+
+unsigned samplingFrequencyFromAudioSpecificConfig(char const *configStr) {
+    unsigned char *config = NULL;
+    unsigned       result = 0;  // if returned, indicates an error
+
+    do {
+        // Begin by parsing the config string:
+        unsigned configSize;
+        config = parseGeneralConfigStr(configStr, configSize);
+        if(config == NULL)
+            break;
+
+        if(configSize < 2)
+            break;
+        unsigned char samplingFrequencyIndex = ((config[0] & 0x07) << 1) | (config[1] >> 7);
+        if(samplingFrequencyIndex < 15) {
+            result = samplingFrequencyFromIndex[samplingFrequencyIndex];
+            break;
+        }
+
+        // Index == 15 means that the actual frequency is next (24 bits):
+        if(configSize < 5)
+            break;
+        result = ((config[1] & 0x7F) << 17) | (config[2] << 9) | (config[3] << 1) | (config[4] >> 7);
+    } while(0);
+
+    delete[] config;
+    return result;
+}
diff --git a/3rdparty/live555/src/liveMedia/MPEG4LATMAudioRTPSink.cpp b/3rdparty/live555/src/liveMedia/MPEG4LATMAudioRTPSink.cpp
new file mode 100644
index 00000000..65a189ce
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/MPEG4LATMAudioRTPSink.cpp
@@ -0,0 +1,68 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// RTP sink for MPEG-4 audio, using LATM multiplexing (RFC 3016)
+// Implementation
+
+#include "MPEG4LATMAudioRTPSink.hh"
+
+MPEG4LATMAudioRTPSink ::MPEG4LATMAudioRTPSink(UsageEnvironment &env, Groupsock *RTPgs, u_int8_t rtpPayloadFormat, u_int32_t rtpTimestampFrequency,
+                                              char const *streamMuxConfigString, unsigned numChannels, Boolean allowMultipleFramesPerPacket)
+    : AudioRTPSink(env, RTPgs, rtpPayloadFormat, rtpTimestampFrequency, "MP4A-LATM", numChannels),
+      fStreamMuxConfigString(strDup(streamMuxConfigString)),
+      fAllowMultipleFramesPerPacket(allowMultipleFramesPerPacket) {
+    // Set up the "a=fmtp:" SDP line for this stream:
+    char const *fmtpFmt = "a=fmtp:%d "
+                          "cpresent=0;config=%s\r\n";
+    unsigned fmtpFmtSize = strlen(fmtpFmt) + 3 /* max char len */
+                           + strlen(fStreamMuxConfigString);
+    char *fmtp = new char[fmtpFmtSize];
+    sprintf(fmtp, fmtpFmt, rtpPayloadType(), fStreamMuxConfigString);
+    fFmtpSDPLine = strDup(fmtp);
+    delete[] fmtp;
+}
+
+MPEG4LATMAudioRTPSink::~MPEG4LATMAudioRTPSink() {
+    delete[] fFmtpSDPLine;
+    delete[](char *) fStreamMuxConfigString;
+}
+
+MPEG4LATMAudioRTPSink *MPEG4LATMAudioRTPSink::createNew(UsageEnvironment &env, Groupsock *RTPgs, u_int8_t rtpPayloadFormat, u_int32_t rtpTimestampFrequency,
+                                                        char const *streamMuxConfigString, unsigned numChannels, Boolean allowMultipleFramesPerPacket) {
+    return new MPEG4LATMAudioRTPSink(env, RTPgs, rtpPayloadFormat, rtpTimestampFrequency, streamMuxConfigString, numChannels, allowMultipleFramesPerPacket);
+}
+
+Boolean MPEG4LATMAudioRTPSink ::frameCanAppearAfterPacketStart(unsigned char const * /*frameStart*/, unsigned /*numBytesInFrame*/) const {
+    return fAllowMultipleFramesPerPacket;
+}
+
+void MPEG4LATMAudioRTPSink ::doSpecialFrameHandling(unsigned fragmentationOffset, unsigned char *frameStart, unsigned numBytesInFrame,
+                                                    struct timeval framePresentationTime, unsigned numRemainingBytes) {
+    if(numRemainingBytes == 0) {
+        // This packet contains the last (or only) fragment of the frame.
+        // Set the RTP 'M' ('marker') bit:
+        setMarkerBit();
+    }
+
+    // Important: Also call our base class's doSpecialFrameHandling(),
+    // to set the packet's timestamp:
+    MultiFramedRTPSink::doSpecialFrameHandling(fragmentationOffset, frameStart, numBytesInFrame, framePresentationTime, numRemainingBytes);
+}
+
+char const *MPEG4LATMAudioRTPSink::auxSDPLine() {
+    return fFmtpSDPLine;
+}
diff --git a/3rdparty/live555/src/liveMedia/MPEG4LATMAudioRTPSource.cpp b/3rdparty/live555/src/liveMedia/MPEG4LATMAudioRTPSource.cpp
new file mode 100644
index 00000000..96872624
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/MPEG4LATMAudioRTPSource.cpp
@@ -0,0 +1,250 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// MPEG-4 audio, using LATM multiplexing
+// Implementation
+
+#include "MPEG4LATMAudioRTPSource.hh"
+
+////////// LATMBufferedPacket and LATMBufferedPacketFactory //////////
+
+class LATMBufferedPacket : public BufferedPacket {
+public:
+    LATMBufferedPacket(Boolean includeLATMDataLengthField);
+    virtual ~LATMBufferedPacket();
+
+private:  // redefined virtual functions
+    virtual unsigned nextEnclosedFrameSize(unsigned char *&framePtr, unsigned dataSize);
+
+private:
+    Boolean fIncludeLATMDataLengthField;
+};
+
+class LATMBufferedPacketFactory : public BufferedPacketFactory {
+private:  // redefined virtual functions
+    virtual BufferedPacket *createNewPacket(MultiFramedRTPSource *ourSource);
+};
+
+///////// MPEG4LATMAudioRTPSource implementation ////////
+
+MPEG4LATMAudioRTPSource *MPEG4LATMAudioRTPSource::createNew(UsageEnvironment &env, Groupsock *RTPgs, unsigned char rtpPayloadFormat,
+                                                            unsigned rtpTimestampFrequency) {
+    return new MPEG4LATMAudioRTPSource(env, RTPgs, rtpPayloadFormat, rtpTimestampFrequency);
+}
+
+MPEG4LATMAudioRTPSource ::MPEG4LATMAudioRTPSource(UsageEnvironment &env, Groupsock *RTPgs, unsigned char rtpPayloadFormat, unsigned rtpTimestampFrequency)
+    : MultiFramedRTPSource(env, RTPgs, rtpPayloadFormat, rtpTimestampFrequency, new LATMBufferedPacketFactory), fIncludeLATMDataLengthField(True) {}
+
+MPEG4LATMAudioRTPSource::~MPEG4LATMAudioRTPSource() {}
+
+void MPEG4LATMAudioRTPSource::omitLATMDataLengthField() {
+    fIncludeLATMDataLengthField = False;
+}
+
+Boolean MPEG4LATMAudioRTPSource ::processSpecialHeader(BufferedPacket *packet, unsigned &resultSpecialHeaderSize) {
+    fCurrentPacketBeginsFrame = fCurrentPacketCompletesFrame;
+    // whether the *previous* packet ended a frame
+
+    // The RTP "M" (marker) bit indicates the last fragment of a frame:
+    fCurrentPacketCompletesFrame = packet->rtpMarkerBit();
+
+    // There is no special header
+    resultSpecialHeaderSize = 0;
+    return True;
+}
+
+char const *MPEG4LATMAudioRTPSource::MIMEtype() const {
+    return "audio/MP4A-LATM";
+}
+
+////////// LATMBufferedPacket and LATMBufferedPacketFactory implementation
+
+LATMBufferedPacket::LATMBufferedPacket(Boolean includeLATMDataLengthField) : fIncludeLATMDataLengthField(includeLATMDataLengthField) {}
+
+LATMBufferedPacket::~LATMBufferedPacket() {}
+
+unsigned LATMBufferedPacket ::nextEnclosedFrameSize(unsigned char *&framePtr, unsigned dataSize) {
+    // Look at the LATM data length byte(s), to determine the size
+    // of the LATM payload.
+    unsigned resultFrameSize = 0;
+    unsigned i;
+    for(i = 0; i < dataSize; ++i) {
+        resultFrameSize += framePtr[i];
+        if(framePtr[i] != 0xFF)
+            break;
+    }
+    ++i;
+    if(fIncludeLATMDataLengthField) {
+        resultFrameSize += i;
+    }
+    else {
+        framePtr += i;
+        dataSize -= i;
+    }
+
+    return (resultFrameSize <= dataSize) ? resultFrameSize : dataSize;
+}
+
+BufferedPacket *LATMBufferedPacketFactory ::createNewPacket(MultiFramedRTPSource *ourSource) {
+    MPEG4LATMAudioRTPSource *source = (MPEG4LATMAudioRTPSource *)ourSource;
+    return new LATMBufferedPacket(source->returnedFrameIncludesLATMDataLengthField());
+}
+
+////////// parseStreamMuxConfigStr() implementation //////////
+
+static Boolean getNibble(char const *&configStr, unsigned char &resultNibble) {
+    char c = configStr[0];
+    if(c == '\0')
+        return False;  // we've reached the end
+
+    if(c >= '0' && c <= '9') {
+        resultNibble = c - '0';
+    }
+    else if(c >= 'A' && c <= 'F') {
+        resultNibble = 10 + c - 'A';
+    }
+    else if(c >= 'a' && c <= 'f') {
+        resultNibble = 10 + c - 'a';
+    }
+    else {
+        return False;
+    }
+
+    ++configStr;  // move to the next nibble
+    return True;
+}
+
+static Boolean getByte(char const *&configStr, unsigned char &resultByte) {
+    resultByte = 0;  // by default, in case parsing fails
+
+    unsigned char firstNibble;
+    if(!getNibble(configStr, firstNibble))
+        return False;
+    resultByte = firstNibble << 4;
+
+    unsigned char secondNibble = 0;
+    if(!getNibble(configStr, secondNibble) && configStr[0] != '\0') {
+        // There's a second nibble, but it's malformed
+        return False;
+    }
+    resultByte |= secondNibble;
+
+    return True;
+}
+
+Boolean parseStreamMuxConfigStr(char const *configStr,
+                                // result parameters:
+                                Boolean &audioMuxVersion, Boolean &allStreamsSameTimeFraming, unsigned char &numSubFrames, unsigned char &numProgram,
+                                unsigned char &numLayer, unsigned char *&audioSpecificConfig, unsigned &audioSpecificConfigSize) {
+    // Set default versions of the result parameters:
+    audioMuxVersion           = False;
+    allStreamsSameTimeFraming = True;
+    numSubFrames = numProgram = numLayer = 0;
+    audioSpecificConfig                  = NULL;
+    audioSpecificConfigSize              = 0;
+
+    do {
+        if(configStr == NULL)
+            break;
+
+        unsigned char nextByte;
+
+        if(!getByte(configStr, nextByte))
+            break;
+        audioMuxVersion = (nextByte & 0x80) != 0;
+        if(audioMuxVersion)
+            break;
+
+        allStreamsSameTimeFraming = ((nextByte & 0x40) >> 6) != 0;
+        numSubFrames              = (nextByte & 0x3F);
+
+        if(!getByte(configStr, nextByte))
+            break;
+        numProgram = (nextByte & 0xF0) >> 4;
+
+        numLayer = (nextByte & 0x0E) >> 1;
+
+        // The one remaining bit, and the rest of the string,
+        // are used for "audioSpecificConfig":
+        unsigned char remainingBit = nextByte & 1;
+
+        unsigned ascSize    = (strlen(configStr) + 1) / 2 + 1;
+        audioSpecificConfig = new unsigned char[ascSize];
+
+        Boolean  parseSuccess;
+        unsigned i = 0;
+        do {
+            nextByte                 = 0;
+            parseSuccess             = getByte(configStr, nextByte);
+            audioSpecificConfig[i++] = (remainingBit << 7) | ((nextByte & 0xFE) >> 1);
+            remainingBit             = nextByte & 1;
+        } while(parseSuccess);
+        if(i != ascSize)
+            break;  // part of the remaining string was bad
+
+        audioSpecificConfigSize = ascSize;
+        return True;  // parsing succeeded
+    } while(0);
+
+    delete[] audioSpecificConfig;
+    return False;  // parsing failed
+}
+
+unsigned char *parseStreamMuxConfigStr(char const *configStr,
+                                       // result parameter:
+                                       unsigned &audioSpecificConfigSize) {
+    Boolean        audioMuxVersion, allStreamsSameTimeFraming;
+    unsigned char  numSubFrames, numProgram, numLayer;
+    unsigned char *audioSpecificConfig;
+
+    if(!parseStreamMuxConfigStr(configStr, audioMuxVersion, allStreamsSameTimeFraming, numSubFrames, numProgram, numLayer, audioSpecificConfig,
+                                audioSpecificConfigSize)) {
+        audioSpecificConfigSize = 0;
+        return NULL;
+    }
+
+    return audioSpecificConfig;
+}
+
+unsigned char *parseGeneralConfigStr(char const *configStr,
+                                     // result parameter:
+                                     unsigned &configSize) {
+    unsigned char *config = NULL;
+    do {
+        if(configStr == NULL)
+            break;
+        configSize = (strlen(configStr) + 1) / 2;
+
+        config = new unsigned char[configSize];
+        if(config == NULL)
+            break;
+
+        unsigned i;
+        for(i = 0; i < configSize; ++i) {
+            if(!getByte(configStr, config[i]))
+                break;
+        }
+        if(i != configSize)
+            break;  // part of the string was bad
+
+        return config;
+    } while(0);
+
+    configSize = 0;
+    delete[] config;
+    return NULL;
+}
diff --git a/3rdparty/live555/src/liveMedia/MPEG4VideoFileServerMediaSubsession.cpp b/3rdparty/live555/src/liveMedia/MPEG4VideoFileServerMediaSubsession.cpp
new file mode 100644
index 00000000..9a86ef71
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/MPEG4VideoFileServerMediaSubsession.cpp
@@ -0,0 +1,115 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A 'ServerMediaSubsession' object that creates new, unicast, "RTPSink"s
+// on demand, from a MPEG-4 video file.
+// Implementation
+
+#include "MPEG4VideoFileServerMediaSubsession.hh"
+#include "MPEG4ESVideoRTPSink.hh"
+#include "ByteStreamFileSource.hh"
+#include "MPEG4VideoStreamFramer.hh"
+
+MPEG4VideoFileServerMediaSubsession *MPEG4VideoFileServerMediaSubsession::createNew(UsageEnvironment &env, char const *fileName, Boolean reuseFirstSource) {
+    return new MPEG4VideoFileServerMediaSubsession(env, fileName, reuseFirstSource);
+}
+
+MPEG4VideoFileServerMediaSubsession ::MPEG4VideoFileServerMediaSubsession(UsageEnvironment &env, char const *fileName, Boolean reuseFirstSource)
+    : FileServerMediaSubsession(env, fileName, reuseFirstSource), fAuxSDPLine(NULL), fDoneFlag(0), fDummyRTPSink(NULL) {}
+
+MPEG4VideoFileServerMediaSubsession::~MPEG4VideoFileServerMediaSubsession() {
+    delete[] fAuxSDPLine;
+}
+
+static void afterPlayingDummy(void *clientData) {
+    MPEG4VideoFileServerMediaSubsession *subsess = (MPEG4VideoFileServerMediaSubsession *)clientData;
+    subsess->afterPlayingDummy1();
+}
+
+void MPEG4VideoFileServerMediaSubsession::afterPlayingDummy1() {
+    // Unschedule any pending 'checking' task:
+    envir().taskScheduler().unscheduleDelayedTask(nextTask());
+    // Signal the event loop that we're done:
+    setDoneFlag();
+}
+
+static void checkForAuxSDPLine(void *clientData) {
+    MPEG4VideoFileServerMediaSubsession *subsess = (MPEG4VideoFileServerMediaSubsession *)clientData;
+    subsess->checkForAuxSDPLine1();
+}
+
+void MPEG4VideoFileServerMediaSubsession::checkForAuxSDPLine1() {
+    nextTask() = NULL;
+
+    char const *dasl;
+    if(fAuxSDPLine != NULL) {
+        // Signal the event loop that we're done:
+        setDoneFlag();
+    }
+    else if(fDummyRTPSink != NULL && (dasl = fDummyRTPSink->auxSDPLine()) != NULL) {
+        fAuxSDPLine   = strDup(dasl);
+        fDummyRTPSink = NULL;
+
+        // Signal the event loop that we're done:
+        setDoneFlag();
+    }
+    else if(!fDoneFlag) {
+        // try again after a brief delay:
+        int uSecsToDelay = 100000;  // 100 ms
+        nextTask()       = envir().taskScheduler().scheduleDelayedTask(uSecsToDelay, (TaskFunc *)checkForAuxSDPLine, this);
+    }
+}
+
+char const *MPEG4VideoFileServerMediaSubsession::getAuxSDPLine(RTPSink *rtpSink, FramedSource *inputSource) {
+    if(fAuxSDPLine != NULL)
+        return fAuxSDPLine;  // it's already been set up (for a previous client)
+
+    if(fDummyRTPSink == NULL) {  // we're not already setting it up for another, concurrent stream
+        // Note: For MPEG-4 video files, the 'config' information isn't known
+        // until we start reading the file.  This means that "rtpSink"s
+        // "auxSDPLine()" will be NULL initially, and we need to start reading data from our file until this changes.
+        fDummyRTPSink = rtpSink;
+
+        // Start reading the file:
+        fDummyRTPSink->startPlaying(*inputSource, afterPlayingDummy, this);
+
+        // Check whether the sink's 'auxSDPLine()' is ready:
+        checkForAuxSDPLine(this);
+    }
+
+    envir().taskScheduler().doEventLoop(&fDoneFlag);
+
+    return fAuxSDPLine;
+}
+
+FramedSource *MPEG4VideoFileServerMediaSubsession ::createNewStreamSource(unsigned /*clientSessionId*/, unsigned &estBitrate) {
+    estBitrate = 500;  // kbps, estimate
+
+    // Create the video source:
+    ByteStreamFileSource *fileSource = ByteStreamFileSource::createNew(envir(), fFileName);
+    if(fileSource == NULL)
+        return NULL;
+    fFileSize = fileSource->fileSize();
+
+    // Create a framer for the Video Elementary Stream:
+    return MPEG4VideoStreamFramer::createNew(envir(), fileSource);
+}
+
+RTPSink *MPEG4VideoFileServerMediaSubsession ::createNewRTPSink(Groupsock *rtpGroupsock, unsigned char rtpPayloadTypeIfDynamic,
+                                                                FramedSource * /*inputSource*/) {
+    return MPEG4ESVideoRTPSink::createNew(envir(), rtpGroupsock, rtpPayloadTypeIfDynamic);
+}
diff --git a/3rdparty/live555/src/liveMedia/MPEG4VideoStreamDiscreteFramer.cpp b/3rdparty/live555/src/liveMedia/MPEG4VideoStreamDiscreteFramer.cpp
new file mode 100644
index 00000000..67da86c2
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/MPEG4VideoStreamDiscreteFramer.cpp
@@ -0,0 +1,253 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A simplified version of "MPEG4VideoStreamFramer" that takes only complete,
+// discrete frames (rather than an arbitrary byte stream) as input.
+// This avoids the parsing and data copying overhead of the full
+// "MPEG4VideoStreamFramer".
+// Implementation
+
+#include "MPEG4VideoStreamDiscreteFramer.hh"
+
+MPEG4VideoStreamDiscreteFramer *MPEG4VideoStreamDiscreteFramer::createNew(UsageEnvironment &env, FramedSource *inputSource,
+                                                                          Boolean leavePresentationTimesUnmodified) {
+    // Need to add source type checking here???  #####
+    return new MPEG4VideoStreamDiscreteFramer(env, inputSource, leavePresentationTimesUnmodified);
+}
+
+MPEG4VideoStreamDiscreteFramer ::MPEG4VideoStreamDiscreteFramer(UsageEnvironment &env, FramedSource *inputSource, Boolean leavePresentationTimesUnmodified)
+    : MPEG4VideoStreamFramer(env, inputSource, False /*don't create a parser*/),
+      fLeavePresentationTimesUnmodified(leavePresentationTimesUnmodified),
+      vop_time_increment_resolution(0),
+      fNumVTIRBits(0),
+      fLastNonBFrameVop_time_increment(0) {
+    fLastNonBFramePresentationTime.tv_sec  = 0;
+    fLastNonBFramePresentationTime.tv_usec = 0;
+}
+
+MPEG4VideoStreamDiscreteFramer::~MPEG4VideoStreamDiscreteFramer() {}
+
+void MPEG4VideoStreamDiscreteFramer::doGetNextFrame() {
+    // Arrange to read data (which should be a complete MPEG-4 video frame)
+    // from our data source, directly into the client's input buffer.
+    // After reading this, we'll do some parsing on the frame.
+    fInputSource->getNextFrame(fTo, fMaxSize, afterGettingFrame, this, FramedSource::handleClosure, this);
+}
+
+void MPEG4VideoStreamDiscreteFramer ::afterGettingFrame(void *clientData, unsigned frameSize, unsigned numTruncatedBytes, struct timeval presentationTime,
+                                                        unsigned durationInMicroseconds) {
+    MPEG4VideoStreamDiscreteFramer *source = (MPEG4VideoStreamDiscreteFramer *)clientData;
+    source->afterGettingFrame1(frameSize, numTruncatedBytes, presentationTime, durationInMicroseconds);
+}
+
+void MPEG4VideoStreamDiscreteFramer ::afterGettingFrame1(unsigned frameSize, unsigned numTruncatedBytes, struct timeval presentationTime,
+                                                         unsigned durationInMicroseconds) {
+    // Check that the first 4 bytes are a system code:
+    if(frameSize >= 4 && fTo[0] == 0 && fTo[1] == 0 && fTo[2] == 1) {
+        fPictureEndMarker = True;  // Assume that we have a complete 'picture' here
+        unsigned i        = 3;
+        if(fTo[i] == 0xB0) {  // VISUAL_OBJECT_SEQUENCE_START_CODE
+            // The next byte is the "profile_and_level_indication":
+            if(frameSize >= 5)
+                fProfileAndLevelIndication = fTo[4];
+
+            // The start of this frame - up to the first GROUP_VOP_START_CODE
+            // or VOP_START_CODE - is stream configuration information.  Save this:
+            for(i = 7; i < frameSize; ++i) {
+                if((fTo[i] == 0xB3 /*GROUP_VOP_START_CODE*/ || fTo[i] == 0xB6 /*VOP_START_CODE*/) && fTo[i - 1] == 1 && fTo[i - 2] == 0 && fTo[i - 3] == 0) {
+                    break;  // The configuration information ends here
+                }
+            }
+            fNumConfigBytes = i < frameSize ? i - 3 : frameSize;
+            delete[] fConfigBytes;
+            fConfigBytes = new unsigned char[fNumConfigBytes];
+            for(unsigned j = 0; j < fNumConfigBytes; ++j)
+                fConfigBytes[j] = fTo[j];
+
+            // This information (should) also contain a VOL header, which we need
+            // to analyze, to get "vop_time_increment_resolution" (which we need
+            // - along with "vop_time_increment" - in order to generate accurate
+            // presentation times for "B" frames).
+            analyzeVOLHeader();
+        }
+
+        if(i < frameSize) {
+            u_int8_t nextCode = fTo[i];
+
+            if(nextCode == 0xB3 /*GROUP_VOP_START_CODE*/) {
+                // Skip to the following VOP_START_CODE (if any):
+                for(i += 4; i < frameSize; ++i) {
+                    if(fTo[i] == 0xB6 /*VOP_START_CODE*/
+                       && fTo[i - 1] == 1 && fTo[i - 2] == 0 && fTo[i - 3] == 0) {
+                        nextCode = fTo[i];
+                        break;
+                    }
+                }
+            }
+
+            if(nextCode == 0xB6 /*VOP_START_CODE*/ && i + 5 < frameSize) {
+                ++i;
+
+                // Get the "vop_coding_type" from the next byte:
+                u_int8_t nextByte        = fTo[i++];
+                u_int8_t vop_coding_type = nextByte >> 6;
+
+                // Next, get the "modulo_time_base" by counting the '1' bits that
+                // follow.  We look at the next 32-bits only.
+                // This should be enough in most cases.
+                u_int32_t next4Bytes = (fTo[i] << 24) | (fTo[i + 1] << 16) | (fTo[i + 2] << 8) | fTo[i + 3];
+                i += 4;
+                u_int32_t timeInfo         = (nextByte << (32 - 6)) | (next4Bytes >> 6);
+                unsigned  modulo_time_base = 0;
+                u_int32_t mask             = 0x80000000;
+                while((timeInfo & mask) != 0) {
+                    ++modulo_time_base;
+                    mask >>= 1;
+                }
+                mask >>= 2;
+
+                // Then, get the "vop_time_increment".
+                unsigned vop_time_increment = 0;
+                // First, make sure we have enough bits left for this:
+                if((mask >> (fNumVTIRBits - 1)) != 0) {
+                    for(unsigned i = 0; i < fNumVTIRBits; ++i) {
+                        vop_time_increment |= timeInfo & mask;
+                        mask >>= 1;
+                    }
+                    while(mask != 0) {
+                        vop_time_increment >>= 1;
+                        mask >>= 1;
+                    }
+                }
+
+                // If this is a "B" frame, then we have to tweak "presentationTime":
+                if(!fLeavePresentationTimesUnmodified && vop_coding_type == 2 /*B*/
+                   && (fLastNonBFramePresentationTime.tv_usec > 0 || fLastNonBFramePresentationTime.tv_sec > 0)) {
+                    int timeIncrement = fLastNonBFrameVop_time_increment - vop_time_increment;
+                    if(timeIncrement < 0)
+                        timeIncrement += vop_time_increment_resolution;
+                    unsigned const MILLION     = 1000000;
+                    double         usIncrement = vop_time_increment_resolution == 0 ? 0.0 : ((double)timeIncrement * MILLION) / vop_time_increment_resolution;
+                    unsigned       secondsToSubtract  = (unsigned)(usIncrement / MILLION);
+                    unsigned       uSecondsToSubtract = ((unsigned)usIncrement) % MILLION;
+
+                    presentationTime = fLastNonBFramePresentationTime;
+                    if((unsigned)presentationTime.tv_usec < uSecondsToSubtract) {
+                        presentationTime.tv_usec += MILLION;
+                        if(presentationTime.tv_sec > 0)
+                            --presentationTime.tv_sec;
+                    }
+                    presentationTime.tv_usec -= uSecondsToSubtract;
+                    if((unsigned)presentationTime.tv_sec > secondsToSubtract) {
+                        presentationTime.tv_sec -= secondsToSubtract;
+                    }
+                    else {
+                        presentationTime.tv_sec = presentationTime.tv_usec = 0;
+                    }
+                }
+                else {
+                    fLastNonBFramePresentationTime   = presentationTime;
+                    fLastNonBFrameVop_time_increment = vop_time_increment;
+                }
+            }
+        }
+    }
+
+    // Complete delivery to the client:
+    fFrameSize              = frameSize;
+    fNumTruncatedBytes      = numTruncatedBytes;
+    fPresentationTime       = presentationTime;
+    fDurationInMicroseconds = durationInMicroseconds;
+    afterGetting(this);
+}
+
+Boolean MPEG4VideoStreamDiscreteFramer::getNextFrameBit(u_int8_t &result) {
+    if(fNumBitsSeenSoFar / 8 >= fNumConfigBytes)
+        return False;
+
+    u_int8_t nextByte = fConfigBytes[fNumBitsSeenSoFar / 8];
+    result            = (nextByte >> (7 - fNumBitsSeenSoFar % 8)) & 1;
+    ++fNumBitsSeenSoFar;
+    return True;
+}
+
+Boolean MPEG4VideoStreamDiscreteFramer::getNextFrameBits(unsigned numBits, u_int32_t &result) {
+    result = 0;
+    for(unsigned i = 0; i < numBits; ++i) {
+        u_int8_t nextBit;
+        if(!getNextFrameBit(nextBit))
+            return False;
+        result = (result << 1) | nextBit;
+    }
+    return True;
+}
+
+void MPEG4VideoStreamDiscreteFramer::analyzeVOLHeader() {
+    // Begin by moving to the VOL header:
+    unsigned i;
+    for(i = 3; i < fNumConfigBytes; ++i) {
+        if(fConfigBytes[i] >= 0x20 && fConfigBytes[i] <= 0x2F && fConfigBytes[i - 1] == 1 && fConfigBytes[i - 2] == 0 && fConfigBytes[i - 3] == 0) {
+            ++i;
+            break;
+        }
+    }
+
+    fNumBitsSeenSoFar = 8 * i + 9;
+    do {
+        u_int8_t is_object_layer_identifier;
+        if(!getNextFrameBit(is_object_layer_identifier))
+            break;
+        if(is_object_layer_identifier)
+            fNumBitsSeenSoFar += 7;
+
+        u_int32_t aspect_ratio_info;
+        if(!getNextFrameBits(4, aspect_ratio_info))
+            break;
+        if(aspect_ratio_info == 15 /*extended_PAR*/)
+            fNumBitsSeenSoFar += 16;
+
+        u_int8_t vol_control_parameters;
+        if(!getNextFrameBit(vol_control_parameters))
+            break;
+        if(vol_control_parameters) {
+            fNumBitsSeenSoFar += 3;  // chroma_format; low_delay
+            u_int8_t vbw_parameters;
+            if(!getNextFrameBit(vbw_parameters))
+                break;
+            if(vbw_parameters)
+                fNumBitsSeenSoFar += 79;
+        }
+
+        fNumBitsSeenSoFar += 2;  // video_object_layer_shape
+        u_int8_t marker_bit;
+        if(!getNextFrameBit(marker_bit))
+            break;
+        if(marker_bit != 1)
+            break;  // sanity check
+
+        if(!getNextFrameBits(16, vop_time_increment_resolution))
+            break;
+        if(vop_time_increment_resolution == 0)
+            break;  // shouldn't happen
+
+        // Compute how many bits are necessary to represent this:
+        fNumVTIRBits = 0;
+        for(unsigned test = vop_time_increment_resolution; test > 0; test /= 2) {
+            ++fNumVTIRBits;
+        }
+    } while(0);
+}
diff --git a/3rdparty/live555/src/liveMedia/MPEG4VideoStreamFramer.cpp b/3rdparty/live555/src/liveMedia/MPEG4VideoStreamFramer.cpp
new file mode 100644
index 00000000..84473c72
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/MPEG4VideoStreamFramer.cpp
@@ -0,0 +1,697 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A filter that breaks up an MPEG-4 video elementary stream into
+//   frames for:
+// - Visual Object Sequence (VS) Header + Visual Object (VO) Header
+//   + Video Object Layer (VOL) Header
+// - Group of VOP (GOV) Header
+// - VOP frame
+// Implementation
+
+#include "MPEG4VideoStreamFramer.hh"
+#include "MPEGVideoStreamParser.hh"
+#include "MPEG4LATMAudioRTPSource.hh"  // for "parseGeneralConfigStr()"
+#include <string.h>
+
+////////// MPEG4VideoStreamParser definition //////////
+
+// An enum representing the current state of the parser:
+enum MPEGParseState {
+    PARSING_VISUAL_OBJECT_SEQUENCE,
+    PARSING_VISUAL_OBJECT_SEQUENCE_SEEN_CODE,
+    PARSING_VISUAL_OBJECT,
+    PARSING_VIDEO_OBJECT_LAYER,
+    PARSING_GROUP_OF_VIDEO_OBJECT_PLANE,
+    PARSING_VIDEO_OBJECT_PLANE,
+    PARSING_VISUAL_OBJECT_SEQUENCE_END_CODE
+};
+
+class MPEG4VideoStreamParser : public MPEGVideoStreamParser {
+public:
+    MPEG4VideoStreamParser(MPEG4VideoStreamFramer *usingSource, FramedSource *inputSource);
+    virtual ~MPEG4VideoStreamParser();
+
+private:  // redefined virtual functions:
+    virtual void     flushInput();
+    virtual unsigned parse();
+
+private:
+    MPEG4VideoStreamFramer *usingSource() {
+        return (MPEG4VideoStreamFramer *)fUsingSource;
+    }
+    void setParseState(MPEGParseState parseState);
+
+    unsigned parseVisualObjectSequence(Boolean haveSeenStartCode = False);
+    unsigned parseVisualObject();
+    unsigned parseVideoObjectLayer();
+    unsigned parseGroupOfVideoObjectPlane();
+    unsigned parseVideoObjectPlane();
+    unsigned parseVisualObjectSequenceEndCode();
+
+    // These are used for parsing within an already-read frame:
+    Boolean getNextFrameBit(u_int8_t &result);
+    Boolean getNextFrameBits(unsigned numBits, u_int32_t &result);
+
+    // Which are used by:
+    void analyzeVOLHeader();
+
+private:
+    MPEGParseState fCurrentParseState;
+    unsigned       fNumBitsSeenSoFar;  // used by the getNextFrameBit*() routines
+    u_int32_t      vop_time_increment_resolution;
+    unsigned       fNumVTIRBits;
+    // # of bits needed to count to "vop_time_increment_resolution"
+    u_int8_t fixed_vop_rate;
+    unsigned fixed_vop_time_increment;  // used if 'fixed_vop_rate' is set
+    unsigned fSecondsSinceLastTimeCode, fTotalTicksSinceLastTimeCode, fPrevNewTotalTicks;
+    unsigned fPrevPictureCountDelta;
+    Boolean  fJustSawTimeCode;
+};
+
+////////// MPEG4VideoStreamFramer implementation //////////
+
+MPEG4VideoStreamFramer *MPEG4VideoStreamFramer::createNew(UsageEnvironment &env, FramedSource *inputSource) {
+    // Need to add source type checking here???  #####
+    return new MPEG4VideoStreamFramer(env, inputSource);
+}
+
+unsigned char *MPEG4VideoStreamFramer ::getConfigBytes(unsigned &numBytes) const {
+    numBytes = fNumConfigBytes;
+    return fConfigBytes;
+}
+
+void MPEG4VideoStreamFramer ::setConfigInfo(u_int8_t profileAndLevelIndication, char const *configStr) {
+    fProfileAndLevelIndication = profileAndLevelIndication;
+
+    delete[] fConfigBytes;
+    fConfigBytes = parseGeneralConfigStr(configStr, fNumConfigBytes);
+}
+
+MPEG4VideoStreamFramer::MPEG4VideoStreamFramer(UsageEnvironment &env, FramedSource *inputSource, Boolean createParser)
+    : MPEGVideoStreamFramer(env, inputSource),
+      fProfileAndLevelIndication(0),
+      fConfigBytes(NULL),
+      fNumConfigBytes(0),
+      fNewConfigBytes(NULL),
+      fNumNewConfigBytes(0) {
+    fParser = createParser ? new MPEG4VideoStreamParser(this, inputSource) : NULL;
+}
+
+MPEG4VideoStreamFramer::~MPEG4VideoStreamFramer() {
+    delete[] fConfigBytes;
+    delete[] fNewConfigBytes;
+}
+
+void MPEG4VideoStreamFramer::startNewConfig() {
+    delete[] fNewConfigBytes;
+    fNewConfigBytes    = NULL;
+    fNumNewConfigBytes = 0;
+}
+
+void MPEG4VideoStreamFramer ::appendToNewConfig(unsigned char *newConfigBytes, unsigned numNewBytes) {
+    // Allocate a new block of memory for the new config bytes:
+    unsigned char *configNew = new unsigned char[fNumNewConfigBytes + numNewBytes];
+
+    // Copy the old, then the new, config bytes there:
+    memmove(configNew, fNewConfigBytes, fNumNewConfigBytes);
+    memmove(&configNew[fNumNewConfigBytes], newConfigBytes, numNewBytes);
+
+    delete[] fNewConfigBytes;
+    fNewConfigBytes = configNew;
+    fNumNewConfigBytes += numNewBytes;
+}
+
+void MPEG4VideoStreamFramer::completeNewConfig() {
+    delete[] fConfigBytes;
+    fConfigBytes       = fNewConfigBytes;
+    fNewConfigBytes    = NULL;
+    fNumConfigBytes    = fNumNewConfigBytes;
+    fNumNewConfigBytes = 0;
+}
+
+Boolean MPEG4VideoStreamFramer::isMPEG4VideoStreamFramer() const {
+    return True;
+}
+
+////////// MPEG4VideoStreamParser implementation //////////
+
+MPEG4VideoStreamParser ::MPEG4VideoStreamParser(MPEG4VideoStreamFramer *usingSource, FramedSource *inputSource)
+    : MPEGVideoStreamParser(usingSource, inputSource),
+      fCurrentParseState(PARSING_VISUAL_OBJECT_SEQUENCE),
+      vop_time_increment_resolution(0),
+      fNumVTIRBits(0),
+      fixed_vop_rate(0),
+      fixed_vop_time_increment(0),
+      fSecondsSinceLastTimeCode(0),
+      fTotalTicksSinceLastTimeCode(0),
+      fPrevNewTotalTicks(0),
+      fPrevPictureCountDelta(1),
+      fJustSawTimeCode(False) {}
+
+MPEG4VideoStreamParser::~MPEG4VideoStreamParser() {}
+
+void MPEG4VideoStreamParser::setParseState(MPEGParseState parseState) {
+    fCurrentParseState = parseState;
+    MPEGVideoStreamParser::setParseState();
+}
+
+void MPEG4VideoStreamParser::flushInput() {
+    fSecondsSinceLastTimeCode    = 0;
+    fTotalTicksSinceLastTimeCode = 0;
+    fPrevNewTotalTicks           = 0;
+    fPrevPictureCountDelta       = 1;
+
+    StreamParser::flushInput();
+    if(fCurrentParseState != PARSING_VISUAL_OBJECT_SEQUENCE) {
+        setParseState(PARSING_VISUAL_OBJECT_SEQUENCE);  // later, change to GOV or VOP? #####
+    }
+}
+
+unsigned MPEG4VideoStreamParser::parse() {
+    try {
+        switch(fCurrentParseState) {
+        case PARSING_VISUAL_OBJECT_SEQUENCE: {
+            return parseVisualObjectSequence();
+        }
+        case PARSING_VISUAL_OBJECT_SEQUENCE_SEEN_CODE: {
+            return parseVisualObjectSequence(True);
+        }
+        case PARSING_VISUAL_OBJECT: {
+            return parseVisualObject();
+        }
+        case PARSING_VIDEO_OBJECT_LAYER: {
+            return parseVideoObjectLayer();
+        }
+        case PARSING_GROUP_OF_VIDEO_OBJECT_PLANE: {
+            return parseGroupOfVideoObjectPlane();
+        }
+        case PARSING_VIDEO_OBJECT_PLANE: {
+            return parseVideoObjectPlane();
+        }
+        case PARSING_VISUAL_OBJECT_SEQUENCE_END_CODE: {
+            return parseVisualObjectSequenceEndCode();
+        }
+        default: {
+            return 0;  // shouldn't happen
+        }
+        }
+    }
+    catch(int /*e*/) {
+#ifdef DEBUG
+        fprintf(stderr, "MPEG4VideoStreamParser::parse() EXCEPTION (This is normal behavior - *not* an error)\n");
+#endif
+        return 0;  // the parsing got interrupted
+    }
+}
+
+#define VISUAL_OBJECT_SEQUENCE_START_CODE 0x000001B0
+#define VISUAL_OBJECT_SEQUENCE_END_CODE 0x000001B1
+#define GROUP_VOP_START_CODE 0x000001B3
+#define VISUAL_OBJECT_START_CODE 0x000001B5
+#define VOP_START_CODE 0x000001B6
+
+unsigned MPEG4VideoStreamParser ::parseVisualObjectSequence(Boolean haveSeenStartCode) {
+#ifdef DEBUG
+    fprintf(stderr, "parsing VisualObjectSequence\n");
+#endif
+    usingSource()->startNewConfig();
+    u_int32_t first4Bytes;
+    if(!haveSeenStartCode) {
+        while((first4Bytes = test4Bytes()) != VISUAL_OBJECT_SEQUENCE_START_CODE) {
+#ifdef DEBUG
+            fprintf(stderr, "ignoring non VS header: 0x%08x\n", first4Bytes);
+#endif
+            get1Byte();
+            setParseState(PARSING_VISUAL_OBJECT_SEQUENCE);
+            // ensures we progress over bad data
+        }
+        first4Bytes = get4Bytes();
+    }
+    else {
+        // We've already seen the start code
+        first4Bytes = VISUAL_OBJECT_SEQUENCE_START_CODE;
+    }
+    save4Bytes(first4Bytes);
+
+    // The next byte is the "profile_and_level_indication":
+    u_int8_t pali = get1Byte();
+#ifdef DEBUG
+    fprintf(stderr, "profile_and_level_indication: %02x\n", pali);
+#endif
+    saveByte(pali);
+    usingSource()->fProfileAndLevelIndication = pali;
+
+    // Now, copy all bytes that we see, up until we reach
+    // a VISUAL_OBJECT_START_CODE:
+    u_int32_t next4Bytes = get4Bytes();
+    while(next4Bytes != VISUAL_OBJECT_START_CODE) {
+        saveToNextCode(next4Bytes);
+    }
+
+    setParseState(PARSING_VISUAL_OBJECT);
+
+    // Compute this frame's presentation time:
+    usingSource()->computePresentationTime(fTotalTicksSinceLastTimeCode);
+
+    // This header forms part of the 'configuration' information:
+    usingSource()->appendToNewConfig(fStartOfFrame, curFrameSize());
+
+    return curFrameSize();
+}
+
+static inline Boolean isVideoObjectStartCode(u_int32_t code) {
+    return code >= 0x00000100 && code <= 0x0000011F;
+}
+
+unsigned MPEG4VideoStreamParser::parseVisualObject() {
+#ifdef DEBUG
+    fprintf(stderr, "parsing VisualObject\n");
+#endif
+    // Note that we've already read the VISUAL_OBJECT_START_CODE
+    save4Bytes(VISUAL_OBJECT_START_CODE);
+
+    // Next, extract the "visual_object_type" from the next 1 or 2 bytes:
+    u_int8_t nextByte = get1Byte();
+    saveByte(nextByte);
+    Boolean  is_visual_object_identifier = (nextByte & 0x80) != 0;
+    u_int8_t visual_object_type;
+    if(is_visual_object_identifier) {
+#ifdef DEBUG
+        fprintf(stderr, "visual_object_verid: 0x%x; visual_object_priority: 0x%x\n", (nextByte & 0x78) >> 3, (nextByte & 0x07));
+#endif
+        nextByte = get1Byte();
+        saveByte(nextByte);
+        visual_object_type = (nextByte & 0xF0) >> 4;
+    }
+    else {
+        visual_object_type = (nextByte & 0x78) >> 3;
+    }
+#ifdef DEBUG
+    fprintf(stderr, "visual_object_type: 0x%x\n", visual_object_type);
+#endif
+    // At present, we support only the "Video ID" "visual_object_type" (1)
+    if(visual_object_type != 1) {
+        usingSource()->envir() << "MPEG4VideoStreamParser::parseVisualObject(): Warning: We don't handle visual_object_type " << visual_object_type << "\n";
+    }
+
+    // Now, copy all bytes that we see, up until we reach
+    // a video_object_start_code
+    u_int32_t next4Bytes = get4Bytes();
+    while(!isVideoObjectStartCode(next4Bytes)) {
+        saveToNextCode(next4Bytes);
+    }
+    save4Bytes(next4Bytes);
+#ifdef DEBUG
+    fprintf(stderr, "saw a video_object_start_code: 0x%08x\n", next4Bytes);
+#endif
+
+    setParseState(PARSING_VIDEO_OBJECT_LAYER);
+
+    // Compute this frame's presentation time:
+    usingSource()->computePresentationTime(fTotalTicksSinceLastTimeCode);
+
+    // This header forms part of the 'configuration' information:
+    usingSource()->appendToNewConfig(fStartOfFrame, curFrameSize());
+
+    return curFrameSize();
+}
+
+static inline Boolean isVideoObjectLayerStartCode(u_int32_t code) {
+    return code >= 0x00000120 && code <= 0x0000012F;
+}
+
+Boolean MPEG4VideoStreamParser::getNextFrameBit(u_int8_t &result) {
+    if(fNumBitsSeenSoFar / 8 >= curFrameSize())
+        return False;
+
+    u_int8_t nextByte = fStartOfFrame[fNumBitsSeenSoFar / 8];
+    result            = (nextByte >> (7 - fNumBitsSeenSoFar % 8)) & 1;
+    ++fNumBitsSeenSoFar;
+    return True;
+}
+
+Boolean MPEG4VideoStreamParser::getNextFrameBits(unsigned numBits, u_int32_t &result) {
+    result = 0;
+    for(unsigned i = 0; i < numBits; ++i) {
+        u_int8_t nextBit;
+        if(!getNextFrameBit(nextBit))
+            return False;
+        result = (result << 1) | nextBit;
+    }
+    return True;
+}
+
+void MPEG4VideoStreamParser::analyzeVOLHeader() {
+    // Extract timing information (in particular,
+    // "vop_time_increment_resolution") from the VOL Header:
+    fNumBitsSeenSoFar = 41;
+    do {
+        u_int8_t is_object_layer_identifier;
+        if(!getNextFrameBit(is_object_layer_identifier))
+            break;
+        if(is_object_layer_identifier)
+            fNumBitsSeenSoFar += 7;
+
+        u_int32_t aspect_ratio_info;
+        if(!getNextFrameBits(4, aspect_ratio_info))
+            break;
+        if(aspect_ratio_info == 15 /*extended_PAR*/)
+            fNumBitsSeenSoFar += 16;
+
+        u_int8_t vol_control_parameters;
+        if(!getNextFrameBit(vol_control_parameters))
+            break;
+        if(vol_control_parameters) {
+            fNumBitsSeenSoFar += 3;  // chroma_format; low_delay
+            u_int8_t vbw_parameters;
+            if(!getNextFrameBit(vbw_parameters))
+                break;
+            if(vbw_parameters)
+                fNumBitsSeenSoFar += 79;
+        }
+
+        fNumBitsSeenSoFar += 2;  // video_object_layer_shape
+        u_int8_t marker_bit;
+        if(!getNextFrameBit(marker_bit))
+            break;
+        if(marker_bit != 1) {  // sanity check
+            usingSource()->envir() << "MPEG4VideoStreamParser::analyzeVOLHeader(): marker_bit 1 not set!\n";
+            break;
+        }
+
+        if(!getNextFrameBits(16, vop_time_increment_resolution))
+            break;
+#ifdef DEBUG
+        fprintf(stderr, "vop_time_increment_resolution: %d\n", vop_time_increment_resolution);
+#endif
+        if(vop_time_increment_resolution == 0) {
+            usingSource()->envir() << "MPEG4VideoStreamParser::analyzeVOLHeader(): vop_time_increment_resolution is zero!\n";
+            break;
+        }
+        // Compute how many bits are necessary to represent this:
+        fNumVTIRBits = 0;
+        for(unsigned test = vop_time_increment_resolution; test > 0; test /= 2) {
+            ++fNumVTIRBits;
+        }
+
+        if(!getNextFrameBit(marker_bit))
+            break;
+        if(marker_bit != 1) {  // sanity check
+            usingSource()->envir() << "MPEG4VideoStreamParser::analyzeVOLHeader(): marker_bit 2 not set!\n";
+            break;
+        }
+
+        if(!getNextFrameBit(fixed_vop_rate))
+            break;
+        if(fixed_vop_rate) {
+            // Get the following "fixed_vop_time_increment":
+            if(!getNextFrameBits(fNumVTIRBits, fixed_vop_time_increment))
+                break;
+#ifdef DEBUG
+            fprintf(stderr, "fixed_vop_time_increment: %d\n", fixed_vop_time_increment);
+            if(fixed_vop_time_increment == 0) {
+                usingSource()->envir() << "MPEG4VideoStreamParser::analyzeVOLHeader(): fixed_vop_time_increment is zero!\n";
+            }
+#endif
+        }
+        // Use "vop_time_increment_resolution" as the 'frame rate'
+        // (really, 'tick rate'):
+        usingSource()->fFrameRate = (double)vop_time_increment_resolution;
+#ifdef DEBUG
+        fprintf(stderr, "fixed_vop_rate: %d; 'frame' (really tick) rate: %f\n", fixed_vop_rate, usingSource()->fFrameRate);
+#endif
+
+        return;
+    } while(0);
+
+    if(fNumBitsSeenSoFar / 8 >= curFrameSize()) {
+        char errMsg[200];
+        sprintf(errMsg, "Not enough bits in VOL header: %d/8 >= %d\n", fNumBitsSeenSoFar, curFrameSize());
+        usingSource()->envir() << errMsg;
+    }
+}
+
+unsigned MPEG4VideoStreamParser::parseVideoObjectLayer() {
+#ifdef DEBUG
+    fprintf(stderr, "parsing VideoObjectLayer\n");
+#endif
+    // The first 4 bytes must be a "video_object_layer_start_code".
+    // If not, this is a 'short video header', which we currently
+    // don't support:
+    u_int32_t next4Bytes = get4Bytes();
+    if(!isVideoObjectLayerStartCode(next4Bytes)) {
+        usingSource()->envir()
+            << "MPEG4VideoStreamParser::parseVideoObjectLayer(): This appears to be a 'short video header', which we currently don't support\n";
+    }
+
+    // Now, copy all bytes that we see, up until we reach
+    // a GROUP_VOP_START_CODE or a VOP_START_CODE:
+    do {
+        saveToNextCode(next4Bytes);
+    } while(next4Bytes != GROUP_VOP_START_CODE && next4Bytes != VOP_START_CODE);
+
+    analyzeVOLHeader();
+
+    setParseState((next4Bytes == GROUP_VOP_START_CODE) ? PARSING_GROUP_OF_VIDEO_OBJECT_PLANE : PARSING_VIDEO_OBJECT_PLANE);
+
+    // Compute this frame's presentation time:
+    usingSource()->computePresentationTime(fTotalTicksSinceLastTimeCode);
+
+    // This header ends the 'configuration' information:
+    usingSource()->appendToNewConfig(fStartOfFrame, curFrameSize());
+    usingSource()->completeNewConfig();
+
+    return curFrameSize();
+}
+
+unsigned MPEG4VideoStreamParser::parseGroupOfVideoObjectPlane() {
+#ifdef DEBUG
+    fprintf(stderr, "parsing GroupOfVideoObjectPlane\n");
+#endif
+    // Note that we've already read the GROUP_VOP_START_CODE
+    save4Bytes(GROUP_VOP_START_CODE);
+
+    // Next, extract the (18-bit) time code from the next 3 bytes:
+    u_int8_t next3Bytes[3];
+    getBytes(next3Bytes, 3);
+    saveByte(next3Bytes[0]);
+    saveByte(next3Bytes[1]);
+    saveByte(next3Bytes[2]);
+    unsigned time_code         = (next3Bytes[0] << 10) | (next3Bytes[1] << 2) | (next3Bytes[2] >> 6);
+    unsigned time_code_hours   = (time_code & 0x0003E000) >> 13;
+    unsigned time_code_minutes = (time_code & 0x00001F80) >> 7;
+#if defined(DEBUG) || defined(DEBUG_TIMESTAMPS)
+    Boolean marker_bit = (time_code & 0x00000040) != 0;
+#endif
+    unsigned time_code_seconds = (time_code & 0x0000003F);
+#if defined(DEBUG) || defined(DEBUG_TIMESTAMPS)
+    fprintf(stderr, "time_code: 0x%05x, hours %d, minutes %d, marker_bit %d, seconds %d\n", time_code, time_code_hours, time_code_minutes, marker_bit,
+            time_code_seconds);
+#endif
+    fJustSawTimeCode = True;
+
+    // Now, copy all bytes that we see, up until we reach a VOP_START_CODE:
+    u_int32_t next4Bytes = get4Bytes();
+    while(next4Bytes != VOP_START_CODE) {
+        saveToNextCode(next4Bytes);
+    }
+
+    // Compute this frame's presentation time:
+    usingSource()->computePresentationTime(fTotalTicksSinceLastTimeCode);
+
+    // Record the time code:
+    usingSource()->setTimeCode(time_code_hours, time_code_minutes, time_code_seconds, 0, 0);
+    // Note: Because the GOV header can appear anywhere (not just at a 1s point), we
+    // don't pass "fTotalTicksSinceLastTimeCode" as the "picturesSinceLastGOP" parameter.
+    fSecondsSinceLastTimeCode = 0;
+    if(fixed_vop_rate)
+        fTotalTicksSinceLastTimeCode = 0;
+
+    setParseState(PARSING_VIDEO_OBJECT_PLANE);
+
+    return curFrameSize();
+}
+
+unsigned MPEG4VideoStreamParser::parseVideoObjectPlane() {
+#ifdef DEBUG
+    fprintf(stderr, "#parsing VideoObjectPlane\n");
+#endif
+    // Note that we've already read the VOP_START_CODE
+    save4Bytes(VOP_START_CODE);
+
+    // Get the "vop_coding_type" from the next byte:
+    u_int8_t nextByte = get1Byte();
+    saveByte(nextByte);
+    u_int8_t vop_coding_type = nextByte >> 6;
+
+    // Next, get the "modulo_time_base" by counting the '1' bits that follow.
+    // We look at the next 32-bits only.  This should be enough in most cases.
+    u_int32_t next4Bytes       = get4Bytes();
+    u_int32_t timeInfo         = (nextByte << (32 - 6)) | (next4Bytes >> 6);
+    unsigned  modulo_time_base = 0;
+    u_int32_t mask             = 0x80000000;
+    while((timeInfo & mask) != 0) {
+        ++modulo_time_base;
+        mask >>= 1;
+    }
+    mask >>= 1;
+
+    // Check the following marker bit:
+    if((timeInfo & mask) == 0) {
+        usingSource()->envir() << "MPEG4VideoStreamParser::parseVideoObjectPlane(): marker bit not set!\n";
+    }
+    mask >>= 1;
+
+    // Then, get the "vop_time_increment".
+    // First, make sure we have enough bits left for this:
+    if((mask >> (fNumVTIRBits - 1)) == 0) {
+        usingSource()->envir() << "MPEG4VideoStreamParser::parseVideoObjectPlane(): 32-bits are not enough to get \"vop_time_increment\"!\n";
+    }
+    unsigned vop_time_increment = 0;
+    for(unsigned i = 0; i < fNumVTIRBits; ++i) {
+        vop_time_increment |= timeInfo & mask;
+        mask >>= 1;
+    }
+    while(mask != 0) {
+        vop_time_increment >>= 1;
+        mask >>= 1;
+    }
+#ifdef DEBUG
+    fprintf(stderr, "vop_coding_type: %d(%c), modulo_time_base: %d, vop_time_increment: %d\n", vop_coding_type, "IPBS"[vop_coding_type], modulo_time_base,
+            vop_time_increment);
+#endif
+
+    // Now, copy all bytes that we see, up until we reach a code of some sort:
+    saveToNextCode(next4Bytes);
+
+    // Update our counters based on the frame timing information that we saw:
+    if(fixed_vop_time_increment > 0) {
+        // This is a 'fixed_vop_rate' stream.  Use 'fixed_vop_time_increment':
+        usingSource()->fPictureCount += fixed_vop_time_increment;
+        if(vop_time_increment > 0 || modulo_time_base > 0) {
+            fTotalTicksSinceLastTimeCode += fixed_vop_time_increment;
+            // Note: "fSecondsSinceLastTimeCode" and "fPrevNewTotalTicks" are not used.
+        }
+    }
+    else {
+        // Use 'vop_time_increment':
+        unsigned newTotalTicks = (fSecondsSinceLastTimeCode + modulo_time_base) * vop_time_increment_resolution + vop_time_increment;
+        if(newTotalTicks == fPrevNewTotalTicks && fPrevNewTotalTicks > 0) {
+            // This is apparently a buggy MPEG-4 video stream, because
+            // "vop_time_increment" did not change.  Overcome this error,
+            // by pretending that it did change.
+#ifdef DEBUG
+            fprintf(stderr, "Buggy MPEG-4 video stream: \"vop_time_increment\" did not change!\n");
+#endif
+            // The following assumes that we don't have 'B' frames.  If we do, then TARFU!
+            usingSource()->fPictureCount += vop_time_increment;
+            fTotalTicksSinceLastTimeCode += vop_time_increment;
+            fSecondsSinceLastTimeCode += modulo_time_base;
+        }
+        else {
+            if(newTotalTicks < fPrevNewTotalTicks && vop_coding_type != 2 /*B*/
+               && modulo_time_base == 0 && vop_time_increment == 0 && !fJustSawTimeCode) {
+                // This is another kind of buggy MPEG-4 video stream, in which
+                // "vop_time_increment" wraps around, but without
+                // "modulo_time_base" changing (or just having had a new time code).
+                // Overcome this by pretending that "vop_time_increment" *did* wrap around:
+#ifdef DEBUG
+                fprintf(stderr, "Buggy MPEG-4 video stream: \"vop_time_increment\" wrapped around, but without \"modulo_time_base\" changing!\n");
+#endif
+                ++fSecondsSinceLastTimeCode;
+                newTotalTicks += vop_time_increment_resolution;
+            }
+            fPrevNewTotalTicks = newTotalTicks;
+            if(vop_coding_type != 2 /*B*/) {
+                int pictureCountDelta = newTotalTicks - fTotalTicksSinceLastTimeCode;
+                if(pictureCountDelta <= 0)
+                    pictureCountDelta = fPrevPictureCountDelta;
+                // ensures that the picture count is always increasing
+                usingSource()->fPictureCount += pictureCountDelta;
+                fPrevPictureCountDelta       = pictureCountDelta;
+                fTotalTicksSinceLastTimeCode = newTotalTicks;
+                fSecondsSinceLastTimeCode += modulo_time_base;
+            }
+        }
+    }
+    fJustSawTimeCode = False;  // for next time
+
+    // The next thing to parse depends on the code that we just saw,
+    // but we are assumed to have ended the current picture:
+    usingSource()->fPictureEndMarker = True;  // HACK #####
+    switch(next4Bytes) {
+    case VISUAL_OBJECT_SEQUENCE_END_CODE: {
+        setParseState(PARSING_VISUAL_OBJECT_SEQUENCE_END_CODE);
+        break;
+    }
+    case VISUAL_OBJECT_SEQUENCE_START_CODE: {
+        setParseState(PARSING_VISUAL_OBJECT_SEQUENCE_SEEN_CODE);
+        break;
+    }
+    case VISUAL_OBJECT_START_CODE: {
+        setParseState(PARSING_VISUAL_OBJECT);
+        break;
+    }
+    case GROUP_VOP_START_CODE: {
+        setParseState(PARSING_GROUP_OF_VIDEO_OBJECT_PLANE);
+        break;
+    }
+    case VOP_START_CODE: {
+        setParseState(PARSING_VIDEO_OBJECT_PLANE);
+        break;
+    }
+    default: {
+        if(isVideoObjectStartCode(next4Bytes)) {
+            setParseState(PARSING_VIDEO_OBJECT_LAYER);
+        }
+        else if(isVideoObjectLayerStartCode(next4Bytes)) {
+            // copy all bytes that we see, up until we reach a VOP_START_CODE:
+            u_int32_t next4Bytes = get4Bytes();
+            while(next4Bytes != VOP_START_CODE) {
+                saveToNextCode(next4Bytes);
+            }
+            setParseState(PARSING_VIDEO_OBJECT_PLANE);
+        }
+        else {
+            usingSource()->envir() << "MPEG4VideoStreamParser::parseVideoObjectPlane(): Saw unexpected code " << (void *)next4Bytes << "\n";
+            setParseState(PARSING_VIDEO_OBJECT_PLANE);  // the safest way to recover...
+        }
+        break;
+    }
+    }
+
+    // Compute this frame's presentation time:
+    usingSource()->computePresentationTime(fTotalTicksSinceLastTimeCode);
+
+    return curFrameSize();
+}
+
+unsigned MPEG4VideoStreamParser::parseVisualObjectSequenceEndCode() {
+#ifdef DEBUG
+    fprintf(stderr, "parsing VISUAL_OBJECT_SEQUENCE_END_CODE\n");
+#endif
+    // Note that we've already read the VISUAL_OBJECT_SEQUENCE_END_CODE
+    save4Bytes(VISUAL_OBJECT_SEQUENCE_END_CODE);
+
+    setParseState(PARSING_VISUAL_OBJECT_SEQUENCE);
+
+    // Treat this as if we had ended a picture:
+    usingSource()->fPictureEndMarker = True;  // HACK #####
+
+    return curFrameSize();
+}
diff --git a/3rdparty/live555/src/liveMedia/MPEGVideoStreamFramer.cpp b/3rdparty/live555/src/liveMedia/MPEGVideoStreamFramer.cpp
new file mode 100644
index 00000000..6ea0cac5
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/MPEGVideoStreamFramer.cpp
@@ -0,0 +1,179 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A filter that breaks up an MPEG video elementary stream into
+//   headers and frames
+// Implementation
+
+#include "MPEGVideoStreamParser.hh"
+#include <GroupsockHelper.hh>
+
+////////// TimeCode implementation //////////
+
+TimeCode::TimeCode() : days(0), hours(0), minutes(0), seconds(0), pictures(0) {}
+
+TimeCode::~TimeCode() {}
+
+int TimeCode::operator==(TimeCode const &arg2) {
+    return pictures == arg2.pictures && seconds == arg2.seconds && minutes == arg2.minutes && hours == arg2.hours && days == arg2.days;
+}
+
+////////// MPEGVideoStreamFramer implementation //////////
+
+MPEGVideoStreamFramer::MPEGVideoStreamFramer(UsageEnvironment &env, FramedSource *inputSource)
+    : FramedFilter(env, inputSource), fFrameRate(0.0) /* until we learn otherwise */, fParser(NULL) {
+    reset();
+}
+
+MPEGVideoStreamFramer::~MPEGVideoStreamFramer() {
+    delete fParser;
+}
+
+void MPEGVideoStreamFramer::flushInput() {
+    reset();
+    if(fParser != NULL)
+        fParser->flushInput();
+}
+
+void MPEGVideoStreamFramer::reset() {
+    fPictureCount          = 0;
+    fPictureEndMarker      = True;  // So that we start looking as if we'd just ended an 'access unit'
+    fPicturesAdjustment    = 0;
+    fPictureTimeBase       = 0.0;
+    fTcSecsBase            = 0;
+    fHaveSeenFirstTimeCode = False;
+
+    // Clear the 'presentation time base', as a signal for subclasses
+    // to reset it (to our current time) when we start (or resume) streaming:
+    fPresentationTimeBase.tv_sec  = 0;
+    fPresentationTimeBase.tv_usec = 0;
+}
+
+#ifdef DEBUG
+static struct timeval firstPT;
+#endif
+void MPEGVideoStreamFramer ::computePresentationTime(unsigned numAdditionalPictures) {
+    // Computes "fPresentationTime" from the most recent GOP's
+    // time_code, along with the "numAdditionalPictures" parameter:
+    TimeCode &tc = fCurGOPTimeCode;
+
+    unsigned tcSecs      = (((tc.days * 24) + tc.hours) * 60 + tc.minutes) * 60 + tc.seconds - fTcSecsBase;
+    double   pictureTime = fFrameRate == 0.0 ? 0.0 : (tc.pictures + fPicturesAdjustment + numAdditionalPictures) / fFrameRate;
+    while(pictureTime < fPictureTimeBase) {  // "if" should be enough, but just in case
+        if(tcSecs > 0)
+            tcSecs -= 1;
+        pictureTime += 1.0;
+    }
+    pictureTime -= fPictureTimeBase;
+    if(pictureTime < 0.0)
+        pictureTime = 0.0;  // sanity check
+    unsigned pictureSeconds          = (unsigned)pictureTime;
+    double   pictureFractionOfSecond = pictureTime - (double)pictureSeconds;
+
+    fPresentationTime = fPresentationTimeBase;
+    fPresentationTime.tv_sec += tcSecs + pictureSeconds;
+    fPresentationTime.tv_usec += (long)(pictureFractionOfSecond * 1000000.0);
+    if(fPresentationTime.tv_usec >= 1000000) {
+        fPresentationTime.tv_usec -= 1000000;
+        ++fPresentationTime.tv_sec;
+    }
+#ifdef DEBUG
+    if(firstPT.tv_sec == 0 && firstPT.tv_usec == 0)
+        firstPT = fPresentationTime;
+    struct timeval diffPT;
+    diffPT.tv_sec  = fPresentationTime.tv_sec - firstPT.tv_sec;
+    diffPT.tv_usec = fPresentationTime.tv_usec - firstPT.tv_usec;
+    if(fPresentationTime.tv_usec < firstPT.tv_usec) {
+        --diffPT.tv_sec;
+        diffPT.tv_usec += 1000000;
+    }
+    fprintf(stderr, "MPEGVideoStreamFramer::computePresentationTime(%d) -> %lu.%06ld [%lu.%06ld]\n", numAdditionalPictures, fPresentationTime.tv_sec,
+            fPresentationTime.tv_usec, diffPT.tv_sec, diffPT.tv_usec);
+#endif
+}
+
+void MPEGVideoStreamFramer ::setTimeCode(unsigned hours, unsigned minutes, unsigned seconds, unsigned pictures, unsigned picturesSinceLastGOP) {
+    TimeCode &tc   = fCurGOPTimeCode;  // abbrev
+    unsigned  days = tc.days;
+    if(hours < tc.hours) {
+        // Assume that the 'day' has wrapped around:
+        ++days;
+    }
+    tc.days     = days;
+    tc.hours    = hours;
+    tc.minutes  = minutes;
+    tc.seconds  = seconds;
+    tc.pictures = pictures;
+    if(!fHaveSeenFirstTimeCode) {
+        fPictureTimeBase       = fFrameRate == 0.0 ? 0.0 : tc.pictures / fFrameRate;
+        fTcSecsBase            = (((tc.days * 24) + tc.hours) * 60 + tc.minutes) * 60 + tc.seconds;
+        fHaveSeenFirstTimeCode = True;
+    }
+    else if(fCurGOPTimeCode == fPrevGOPTimeCode) {
+        // The time code has not changed since last time.  Adjust for this:
+        fPicturesAdjustment += picturesSinceLastGOP;
+    }
+    else {
+        // Normal case: The time code changed since last time.
+        fPrevGOPTimeCode    = tc;
+        fPicturesAdjustment = 0;
+    }
+}
+
+void MPEGVideoStreamFramer::doGetNextFrame() {
+    fParser->registerReadInterest(fTo, fMaxSize);
+    continueReadProcessing();
+}
+
+void MPEGVideoStreamFramer::doStopGettingFrames() {
+    flushInput();
+    FramedFilter::doStopGettingFrames();
+}
+
+void MPEGVideoStreamFramer ::continueReadProcessing(void *clientData, unsigned char * /*ptr*/, unsigned /*size*/, struct timeval /*presentationTime*/) {
+    MPEGVideoStreamFramer *framer = (MPEGVideoStreamFramer *)clientData;
+    framer->continueReadProcessing();
+}
+
+void MPEGVideoStreamFramer::continueReadProcessing() {
+    unsigned acquiredFrameSize = fParser->parse();
+    if(acquiredFrameSize > 0) {
+        // We were able to acquire a frame from the input.
+        // It has already been copied to the reader's space.
+        fFrameSize         = acquiredFrameSize;
+        fNumTruncatedBytes = fParser->numTruncatedBytes();
+
+        // "fPresentationTime" should have already been computed.
+
+        // Compute "fDurationInMicroseconds" now:
+        fDurationInMicroseconds = (fFrameRate == 0.0 || ((int)fPictureCount) < 0) ? 0 : (unsigned)((fPictureCount * 1000000) / fFrameRate);
+#ifdef DEBUG
+        fprintf(stderr, "%d bytes @%u.%06d, fDurationInMicroseconds: %d ((%d*1000000)/%f)\n", acquiredFrameSize, fPresentationTime.tv_sec,
+                fPresentationTime.tv_usec, fDurationInMicroseconds, fPictureCount, fFrameRate);
+#endif
+        fPictureCount = 0;
+
+        // Call our own 'after getting' function.  Because we're not a 'leaf'
+        // source, we can call this directly, without risking infinite recursion.
+        afterGetting(this);
+    }
+    else {
+        // We were unable to parse a complete frame from the input, because:
+        // - we had to read more data from the source stream, or
+        // - the source stream has ended.
+    }
+}
diff --git a/3rdparty/live555/src/liveMedia/MPEGVideoStreamParser.cpp b/3rdparty/live555/src/liveMedia/MPEGVideoStreamParser.cpp
new file mode 100644
index 00000000..bdfdb8a6
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/MPEGVideoStreamParser.cpp
@@ -0,0 +1,39 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// An abstract parser for MPEG video streams
+// Implementation
+
+#include "MPEGVideoStreamParser.hh"
+
+MPEGVideoStreamParser ::MPEGVideoStreamParser(MPEGVideoStreamFramer *usingSource, FramedSource *inputSource)
+    : StreamParser(inputSource, FramedSource::handleClosure, usingSource, &MPEGVideoStreamFramer::continueReadProcessing, usingSource),
+      fUsingSource(usingSource) {}
+
+MPEGVideoStreamParser::~MPEGVideoStreamParser() {}
+
+void MPEGVideoStreamParser::restoreSavedParserState() {
+    StreamParser::restoreSavedParserState();
+    fTo                = fSavedTo;
+    fNumTruncatedBytes = fSavedNumTruncatedBytes;
+}
+
+void MPEGVideoStreamParser::registerReadInterest(unsigned char *to, unsigned maxSize) {
+    fStartOfFrame = fTo = fSavedTo = to;
+    fLimit                         = to + maxSize;
+    fNumTruncatedBytes = fSavedNumTruncatedBytes = 0;
+}
diff --git a/3rdparty/live555/src/liveMedia/MPEGVideoStreamParser.hh b/3rdparty/live555/src/liveMedia/MPEGVideoStreamParser.hh
new file mode 100644
index 00000000..9363e21b
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/MPEGVideoStreamParser.hh
@@ -0,0 +1,122 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// An abstract parser for MPEG video streams
+// C++ header
+
+#ifndef _MPEG_VIDEO_STREAM_PARSER_HH
+#define _MPEG_VIDEO_STREAM_PARSER_HH
+
+#ifndef _STREAM_PARSER_HH
+#include "StreamParser.hh"
+#endif
+#ifndef _MPEG_VIDEO_STREAM_FRAMER_HH
+#include "MPEGVideoStreamFramer.hh"
+#endif
+
+////////// MPEGVideoStreamParser definition //////////
+
+class MPEGVideoStreamParser: public StreamParser {
+public:
+  MPEGVideoStreamParser(MPEGVideoStreamFramer* usingSource,
+			FramedSource* inputSource);
+  virtual ~MPEGVideoStreamParser();
+
+public:
+  void registerReadInterest(unsigned char* to, unsigned maxSize);
+
+  virtual unsigned parse() = 0;
+      // returns the size of the frame that was acquired, or 0 if none was
+      // The number of truncated bytes (if any) is given by:
+  unsigned numTruncatedBytes() const { return fNumTruncatedBytes; }
+
+protected:
+  void setParseState() {
+    fSavedTo = fTo;
+    fSavedNumTruncatedBytes = fNumTruncatedBytes;
+    saveParserState();
+  }
+
+  // Record "byte" in the current output frame:
+  void saveByte(u_int8_t byte) {
+    if (fTo >= fLimit) { // there's no space left
+      ++fNumTruncatedBytes;
+      return;
+    }
+
+    *fTo++ = byte;
+  }
+
+  void save4Bytes(u_int32_t word) {
+    if (fTo+4 > fLimit) { // there's no space left
+      fNumTruncatedBytes += 4;
+      return;
+    }
+
+    *fTo++ = word>>24; *fTo++ = word>>16; *fTo++ = word>>8; *fTo++ = word;
+  }
+
+  // Save data until we see a sync word (0x000001xx):
+  void saveToNextCode(u_int32_t& curWord) {
+    saveByte(curWord>>24);
+    curWord = (curWord<<8)|get1Byte();
+    while ((curWord&0xFFFFFF00) != 0x00000100) {
+      if ((unsigned)(curWord&0xFF) > 1) {
+	// a sync word definitely doesn't begin anywhere in "curWord"
+	save4Bytes(curWord);
+	curWord = get4Bytes();
+      } else {
+	// a sync word might begin in "curWord", although not at its start
+	saveByte(curWord>>24);
+	unsigned char newByte = get1Byte();
+	curWord = (curWord<<8)|newByte;
+      }
+    }
+  }
+
+  // Skip data until we see a sync word (0x000001xx):
+  void skipToNextCode(u_int32_t& curWord) {
+    curWord = (curWord<<8)|get1Byte();
+    while ((curWord&0xFFFFFF00) != 0x00000100) {
+      if ((unsigned)(curWord&0xFF) > 1) {
+	// a sync word definitely doesn't begin anywhere in "curWord"
+	curWord = get4Bytes();
+      } else {
+	// a sync word might begin in "curWord", although not at its start
+	unsigned char newByte = get1Byte();
+	curWord = (curWord<<8)|newByte;
+      }
+    }
+  }
+
+protected:
+  MPEGVideoStreamFramer* fUsingSource;
+
+  // state of the frame that's currently being read:
+  unsigned char* fStartOfFrame;
+  unsigned char* fTo;
+  unsigned char* fLimit;
+  unsigned fNumTruncatedBytes;
+  unsigned curFrameSize() { return fTo - fStartOfFrame; }
+  unsigned char* fSavedTo;
+  unsigned fSavedNumTruncatedBytes;
+
+private: // redefined virtual functions
+  virtual void restoreSavedParserState();
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/Makefile.head b/3rdparty/live555/src/liveMedia/Makefile.head
new file mode 100644
index 00000000..f4e4414c
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/Makefile.head
@@ -0,0 +1,4 @@
+INCLUDES = -Iinclude -I../UsageEnvironment/include -I../groupsock/include
+PREFIX = /usr/local
+LIBDIR = $(PREFIX)/lib
+##### Change the following for your environment:
diff --git a/3rdparty/live555/src/liveMedia/Makefile.tail b/3rdparty/live555/src/liveMedia/Makefile.tail
new file mode 100644
index 00000000..1be45f65
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/Makefile.tail
@@ -0,0 +1,445 @@
+##### End of variables to change
+
+NAME = libliveMedia
+LIVEMEDIA_LIB = $(NAME).$(LIB_SUFFIX)
+ALL = $(LIVEMEDIA_LIB)
+all:	$(ALL)
+
+.$(C).$(OBJ):
+	$(C_COMPILER) -c $(C_FLAGS) $<
+.$(CPP).$(OBJ):
+	$(CPLUSPLUS_COMPILER) -c $(CPLUSPLUS_FLAGS) $<
+
+MP3_SOURCE_OBJS = MP3FileSource.$(OBJ) MP3Transcoder.$(OBJ) MP3ADU.$(OBJ) MP3ADUdescriptor.$(OBJ) MP3ADUinterleaving.$(OBJ) MP3ADUTranscoder.$(OBJ) MP3StreamState.$(OBJ) MP3Internals.$(OBJ) MP3InternalsHuffman.$(OBJ) MP3InternalsHuffmanTable.$(OBJ) MP3ADURTPSource.$(OBJ)
+MPEG_SOURCE_OBJS = MPEG1or2Demux.$(OBJ) MPEG1or2DemuxedElementaryStream.$(OBJ) MPEGVideoStreamFramer.$(OBJ) MPEG1or2VideoStreamFramer.$(OBJ) MPEG1or2VideoStreamDiscreteFramer.$(OBJ) MPEG4VideoStreamFramer.$(OBJ) MPEG4VideoStreamDiscreteFramer.$(OBJ) H264or5VideoStreamFramer.$(OBJ) H264or5VideoStreamDiscreteFramer.$(OBJ) H264VideoStreamFramer.$(OBJ) H264VideoStreamDiscreteFramer.$(OBJ) H265VideoStreamFramer.$(OBJ) H265VideoStreamDiscreteFramer.$(OBJ) MPEGVideoStreamParser.$(OBJ) MPEG1or2AudioStreamFramer.$(OBJ) MPEG1or2AudioRTPSource.$(OBJ) MPEG4LATMAudioRTPSource.$(OBJ) MPEG4ESVideoRTPSource.$(OBJ) MPEG4GenericRTPSource.$(OBJ) $(MP3_SOURCE_OBJS) MPEG1or2VideoRTPSource.$(OBJ) MPEG2TransportStreamMultiplexor.$(OBJ) MPEG2TransportStreamFromPESSource.$(OBJ) MPEG2TransportStreamFromESSource.$(OBJ) MPEG2TransportStreamFramer.$(OBJ) MPEG2TransportStreamAccumulator.$(OBJ) ADTSAudioFileSource.$(OBJ) ADTSAudioStreamDiscreteFramer.$(OBJ)
+#JPEG_SOURCE_OBJS = JPEGVideoSource.$(OBJ) JPEGVideoRTPSource.$(OBJ) JPEG2000VideoStreamFramer.$(OBJ) JPEG2000VideoStreamParser.$(OBJ) JPEG2000VideoRTPSource.$(OBJ)
+JPEG_SOURCE_OBJS = JPEGVideoSource.$(OBJ) JPEGVideoRTPSource.$(OBJ) JPEG2000VideoRTPSource.$(OBJ)
+H263_SOURCE_OBJS = H263plusVideoRTPSource.$(OBJ) H263plusVideoStreamFramer.$(OBJ) H263plusVideoStreamParser.$(OBJ)
+AC3_SOURCE_OBJS = AC3AudioStreamFramer.$(OBJ) AC3AudioRTPSource.$(OBJ)
+DV_SOURCE_OBJS = DVVideoStreamFramer.$(OBJ) DVVideoRTPSource.$(OBJ)
+MP3_SINK_OBJS = MP3ADURTPSink.$(OBJ)
+MPEG_SINK_OBJS = MPEG1or2AudioRTPSink.$(OBJ) $(MP3_SINK_OBJS) MPEG1or2VideoRTPSink.$(OBJ) MPEG4LATMAudioRTPSink.$(OBJ) MPEG4GenericRTPSink.$(OBJ) MPEG4ESVideoRTPSink.$(OBJ)
+JPEG_SINK_OBJS = JPEGVideoRTPSink.$(OBJ) JPEG2000VideoRTPSink.$(OBJ)
+H263_SINK_OBJS = H263plusVideoRTPSink.$(OBJ)
+H264_OR_5_SINK_OBJS = H264or5VideoRTPSink.$(OBJ) H264VideoRTPSink.$(OBJ) H265VideoRTPSink.$(OBJ)
+DV_SINK_OBJS = DVVideoRTPSink.$(OBJ)
+AC3_SINK_OBJS = AC3AudioRTPSink.$(OBJ)
+
+MISC_SOURCE_OBJS = MediaSource.$(OBJ) FramedSource.$(OBJ) FramedFileSource.$(OBJ) FramedFilter.$(OBJ) ByteStreamFileSource.$(OBJ) ByteStreamMultiFileSource.$(OBJ) ByteStreamMemoryBufferSource.$(OBJ) BasicUDPSource.$(OBJ) DeviceSource.$(OBJ) AudioInputDevice.$(OBJ) WAVAudioFileSource.$(OBJ) $(MPEG_SOURCE_OBJS) $(JPEG_SOURCE_OBJS) $(H263_SOURCE_OBJS) $(AC3_SOURCE_OBJS) $(DV_SOURCE_OBJS) AMRAudioSource.$(OBJ) AMRAudioFileSource.$(OBJ) InputFile.$(OBJ) StreamReplicator.$(OBJ)
+MISC_SINK_OBJS = MediaSink.$(OBJ) FileSink.$(OBJ) BasicUDPSink.$(OBJ) AMRAudioFileSink.$(OBJ) H264or5VideoFileSink.$(OBJ) H264VideoFileSink.$(OBJ) H265VideoFileSink.$(OBJ) OggFileSink.$(OBJ) $(MPEG_SINK_OBJS) $(JPEG_SINK_OBJS) $(H263_SINK_OBJS) $(H264_OR_5_SINK_OBJS) $(DV_SINK_OBJS) $(AC3_SINK_OBJS) VorbisAudioRTPSink.$(OBJ) TheoraVideoRTPSink.$(OBJ) VP8VideoRTPSink.$(OBJ) VP9VideoRTPSink.$(OBJ) GSMAudioRTPSink.$(OBJ) SimpleRTPSink.$(OBJ) AMRAudioRTPSink.$(OBJ) T140TextRTPSink.$(OBJ) OutputFile.$(OBJ) RawVideoRTPSink.$(OBJ)
+MISC_FILTER_OBJS = uLawAudioFilter.$(OBJ)
+TRANSPORT_STREAM_TRICK_PLAY_OBJS = MPEG2IndexFromTransportStream.$(OBJ) MPEG2TransportStreamIndexFile.$(OBJ) MPEG2TransportStreamTrickModeFilter.$(OBJ)
+
+RTP_SOURCE_OBJS = RTPSource.$(OBJ) MultiFramedRTPSource.$(OBJ) SimpleRTPSource.$(OBJ) H261VideoRTPSource.$(OBJ) H264VideoRTPSource.$(OBJ) H265VideoRTPSource.$(OBJ) QCELPAudioRTPSource.$(OBJ) AMRAudioRTPSource.$(OBJ) VorbisAudioRTPSource.$(OBJ) TheoraVideoRTPSource.$(OBJ) VP8VideoRTPSource.$(OBJ) VP9VideoRTPSource.$(OBJ) RawVideoRTPSource.$(OBJ)
+RTP_SINK_OBJS = RTPSink.$(OBJ) MultiFramedRTPSink.$(OBJ) AudioRTPSink.$(OBJ) VideoRTPSink.$(OBJ) TextRTPSink.$(OBJ)
+RTP_INTERFACE_OBJS = RTPInterface.$(OBJ)
+RTP_OBJS = $(RTP_SOURCE_OBJS) $(RTP_SINK_OBJS) $(RTP_INTERFACE_OBJS)
+
+RTCP_OBJS = RTCP.$(OBJ) rtcp_from_spec.$(OBJ)
+GENERIC_MEDIA_SERVER_OBJS = GenericMediaServer.$(OBJ)
+RTSP_OBJS = RTSPServer.$(OBJ) RTSPServerRegister.$(OBJ) RTSPClient.$(OBJ) RTSPCommon.$(OBJ) RTSPRegisterSender.$(OBJ)
+SIP_OBJS = SIPClient.$(OBJ)
+
+SESSION_OBJS = MediaSession.$(OBJ) ServerMediaSession.$(OBJ) PassiveServerMediaSubsession.$(OBJ) OnDemandServerMediaSubsession.$(OBJ) FileServerMediaSubsession.$(OBJ) MPEG4VideoFileServerMediaSubsession.$(OBJ) H264VideoFileServerMediaSubsession.$(OBJ) H265VideoFileServerMediaSubsession.$(OBJ) H263plusVideoFileServerMediaSubsession.$(OBJ) WAVAudioFileServerMediaSubsession.$(OBJ) AMRAudioFileServerMediaSubsession.$(OBJ) MP3AudioFileServerMediaSubsession.$(OBJ) MPEG1or2VideoFileServerMediaSubsession.$(OBJ) MPEG1or2FileServerDemux.$(OBJ) MPEG1or2DemuxedServerMediaSubsession.$(OBJ) MPEG2TransportFileServerMediaSubsession.$(OBJ) ADTSAudioFileServerMediaSubsession.$(OBJ) DVVideoFileServerMediaSubsession.$(OBJ) AC3AudioFileServerMediaSubsession.$(OBJ) MPEG2TransportUDPServerMediaSubsession.$(OBJ) ProxyServerMediaSession.$(OBJ)
+
+QUICKTIME_OBJS = QuickTimeFileSink.$(OBJ) QuickTimeGenericRTPSource.$(OBJ)
+AVI_OBJS = AVIFileSink.$(OBJ)
+
+MATROSKA_FILE_OBJS = MatroskaFile.$(OBJ) MatroskaFileParser.$(OBJ) EBMLNumber.$(OBJ) MatroskaDemuxedTrack.$(OBJ)
+MATROSKA_SERVER_MEDIA_SUBSESSION_OBJS = MatroskaFileServerMediaSubsession.$(OBJ) MP3AudioMatroskaFileServerMediaSubsession.$(OBJ)
+MATROSKA_RTSP_SERVER_OBJS = MatroskaFileServerDemux.$(OBJ) $(MATROSKA_SERVER_MEDIA_SUBSESSION_OBJS)
+MATROSKA_OBJS = $(MATROSKA_FILE_OBJS) $(MATROSKA_RTSP_SERVER_OBJS)
+
+OGG_FILE_OBJS = OggFile.$(OBJ) OggFileParser.$(OBJ) OggDemuxedTrack.$(OBJ)
+OGG_SERVER_MEDIA_SUBSESSION_OBJS = OggFileServerMediaSubsession.$(OBJ)
+OGG_RTSP_SERVER_OBJS = OggFileServerDemux.$(OBJ) $(OGG_SERVER_MEDIA_SUBSESSION_OBJS)
+OGG_OBJS = $(OGG_FILE_OBJS) $(OGG_RTSP_SERVER_OBJS)
+
+TRANSPORT_STREAM_DEMUX_OBJS = MPEG2TransportStreamDemux.$(OBJ) MPEG2TransportStreamDemuxedTrack.$(OBJ) MPEG2TransportStreamParser.$(OBJ) MPEG2TransportStreamParser_PAT.$(OBJ) MPEG2TransportStreamParser_PMT.$(OBJ) MPEG2TransportStreamParser_STREAM.$(OBJ)
+
+HLS_OBJS = HLSSegmenter.$(OBJ)
+
+SECURITY_OBJS = TLSState.$(OBJ) MIKEY.$(OBJ) SRTPCryptographicContext.$(OBJ) HMAC_SHA1.$(OBJ)
+
+MISC_OBJS = BitVector.$(OBJ) StreamParser.$(OBJ) DigestAuthentication.$(OBJ) ourMD5.$(OBJ) Base64.$(OBJ) Locale.$(OBJ)
+
+LIVEMEDIA_LIB_OBJS = Media.$(OBJ) $(MISC_SOURCE_OBJS) $(MISC_SINK_OBJS) $(MISC_FILTER_OBJS) $(RTP_OBJS) $(RTCP_OBJS) $(GENERIC_MEDIA_SERVER_OBJS) $(RTSP_OBJS) $(SIP_OBJS) $(SESSION_OBJS) $(QUICKTIME_OBJS) $(AVI_OBJS) $(TRANSPORT_STREAM_TRICK_PLAY_OBJS) $(MATROSKA_OBJS) $(OGG_OBJS) $(TRANSPORT_STREAM_DEMUX_OBJS) $(HLS_OBJS) $(SECURITY_OBJS) $(MISC_OBJS)
+
+$(LIVEMEDIA_LIB): $(LIVEMEDIA_LIB_OBJS) \
+    $(PLATFORM_SPECIFIC_LIB_OBJS)
+	$(LIBRARY_LINK)$@ $(LIBRARY_LINK_OPTS) \
+		$(LIVEMEDIA_LIB_OBJS) $(LIBS_FOR_LIVEMEDIA_LIB)
+
+Media.$(CPP):		include/Media.hh
+include/Media.hh:	include/liveMedia_version.hh
+MediaSource.$(CPP):	include/MediaSource.hh
+include/MediaSource.hh:		include/Media.hh
+FramedSource.$(CPP):	include/FramedSource.hh
+include/FramedSource.hh:	include/MediaSource.hh
+FramedFileSource.$(CPP): include/FramedFileSource.hh
+include/FramedFileSource.hh:	include/FramedSource.hh
+FramedFilter.$(CPP):	include/FramedFilter.hh
+include/FramedFilter.hh:	include/FramedSource.hh
+RTPSource.$(CPP):	include/RTPSource.hh
+include/RTPSource.hh:		include/FramedSource.hh include/RTPInterface.hh include/SRTPCryptographicContext.hh
+include/RTPInterface.hh:	include/Media.hh include/TLSState.hh
+MultiFramedRTPSource.$(CPP):	include/MultiFramedRTPSource.hh include/RTCP.hh
+include/MultiFramedRTPSource.hh:	include/RTPSource.hh
+SimpleRTPSource.$(CPP):	include/SimpleRTPSource.hh
+include/SimpleRTPSource.hh:	include/MultiFramedRTPSource.hh
+H261VideoRTPSource.$(CPP):	include/H261VideoRTPSource.hh
+include/H261VideoRTPSource.hh:	include/MultiFramedRTPSource.hh
+H264VideoRTPSource.$(CPP):      include/H264VideoRTPSource.hh include/Base64.hh
+include/H264VideoRTPSource.hh:  include/MultiFramedRTPSource.hh
+H265VideoRTPSource.$(CPP):      include/H265VideoRTPSource.hh
+include/H265VideoRTPSource.hh:  include/MultiFramedRTPSource.hh
+QCELPAudioRTPSource.$(CPP):	include/QCELPAudioRTPSource.hh include/MultiFramedRTPSource.hh include/FramedFilter.hh
+include/QCELPAudioRTPSource.hh:		include/RTPSource.hh
+AMRAudioRTPSource.$(CPP):	include/AMRAudioRTPSource.hh include/MultiFramedRTPSource.hh
+include/AMRAudioRTPSource.hh:		include/RTPSource.hh include/AMRAudioSource.hh
+VorbisAudioRTPSource.$(CPP):	include/VorbisAudioRTPSource.hh include/Base64.hh
+include/VorbisAudioRTPSource.hh:	include/MultiFramedRTPSource.hh
+TheoraVideoRTPSource.$(CPP):	include/TheoraVideoRTPSource.hh
+include/TheoraVideoRTPSource.hh:	include/MultiFramedRTPSource.hh
+VP8VideoRTPSource.$(CPP):	include/VP8VideoRTPSource.hh
+include/VP8VideoRTPSource.hh:	include/MultiFramedRTPSource.hh
+VP9VideoRTPSource.$(CPP):	include/VP9VideoRTPSource.hh
+include/VP9VideoRTPSource.hh:	include/MultiFramedRTPSource.hh
+RawVideoRTPSource.$(CPP):	include/RawVideoRTPSource.hh
+include/RawVideoRTPSource.hh:	include/MultiFramedRTPSource.hh
+ByteStreamFileSource.$(CPP):	include/ByteStreamFileSource.hh include/InputFile.hh
+include/ByteStreamFileSource.hh:	include/FramedFileSource.hh
+ByteStreamMultiFileSource.$(CPP):	include/ByteStreamMultiFileSource.hh
+include/ByteStreamMultiFileSource.hh:	include/ByteStreamFileSource.hh
+ByteStreamMemoryBufferSource.$(CPP):	include/ByteStreamMemoryBufferSource.hh
+include/ByteStreamMemoryBufferSource.hh:	include/FramedSource.hh
+BasicUDPSource.$(CPP):		include/BasicUDPSource.hh
+include/BasicUDPSource.hh:	include/FramedSource.hh
+DeviceSource.$(CPP):	include/DeviceSource.hh
+include/DeviceSource.hh:	include/FramedSource.hh
+AudioInputDevice.$(CPP):	include/AudioInputDevice.hh
+include/AudioInputDevice.hh:	include/FramedSource.hh
+WAVAudioFileSource.$(CPP):	include/WAVAudioFileSource.hh include/InputFile.hh
+include/WAVAudioFileSource.hh:	include/AudioInputDevice.hh
+MPEG1or2Demux.$(CPP):	include/MPEG1or2Demux.hh include/MPEG1or2DemuxedElementaryStream.hh StreamParser.hh
+include/MPEG1or2Demux.hh:		include/FramedSource.hh
+include/MPEG1or2DemuxedElementaryStream.hh:	include/MPEG1or2Demux.hh
+StreamParser.hh:	include/FramedSource.hh
+MPEG1or2DemuxedElementaryStream.$(CPP):	include/MPEG1or2DemuxedElementaryStream.hh
+MPEGVideoStreamFramer.$(CPP):	MPEGVideoStreamParser.hh
+MPEGVideoStreamParser.hh:	StreamParser.hh include/MPEGVideoStreamFramer.hh
+include/MPEGVideoStreamFramer.hh:	include/FramedFilter.hh
+MPEG1or2VideoStreamFramer.$(CPP):	include/MPEG1or2VideoStreamFramer.hh MPEGVideoStreamParser.hh
+include/MPEG1or2VideoStreamFramer.hh:	include/MPEGVideoStreamFramer.hh
+MPEG1or2VideoStreamDiscreteFramer.$(CPP):	include/MPEG1or2VideoStreamDiscreteFramer.hh
+include/MPEG1or2VideoStreamDiscreteFramer.hh:	include/MPEG1or2VideoStreamFramer.hh
+MPEG4VideoStreamFramer.$(CPP):	include/MPEG4VideoStreamFramer.hh MPEGVideoStreamParser.hh include/MPEG4LATMAudioRTPSource.hh
+include/MPEG4VideoStreamFramer.hh:	include/MPEGVideoStreamFramer.hh
+MPEG4VideoStreamDiscreteFramer.$(CPP):	include/MPEG4VideoStreamDiscreteFramer.hh
+include/MPEG4VideoStreamDiscreteFramer.hh:	include/MPEG4VideoStreamFramer.hh
+H264or5VideoStreamFramer.$(CPP):	include/H264or5VideoStreamFramer.hh MPEGVideoStreamParser.hh include/BitVector.hh
+include/H264or5VideoStreamFramer.hh:	include/MPEGVideoStreamFramer.hh
+H264or5VideoStreamDiscreteFramer.$(CPP):	include/H264or5VideoStreamDiscreteFramer.hh
+include/H264or5VideoStreamDiscreteFramer.hh:	include/H264or5VideoStreamFramer.hh
+H264VideoStreamFramer.$(CPP):	include/H264VideoStreamFramer.hh
+include/H264VideoStreamFramer.hh:	include/H264or5VideoStreamFramer.hh
+H264VideoStreamDiscreteFramer.$(CPP):	include/H264VideoStreamDiscreteFramer.hh
+include/H264VideoStreamDiscreteFramer.hh:	include/H264VideoStreamFramer.hh
+H265VideoStreamFramer.$(CPP):	include/H265VideoStreamFramer.hh
+include/H265VideoStreamFramer.hh:	include/H264or5VideoStreamFramer.hh
+H265VideoStreamDiscreteFramer.$(CPP):	include/H265VideoStreamDiscreteFramer.hh
+include/H265VideoStreamDiscreteFramer.hh:	include/H265VideoStreamFramer.hh
+MPEGVideoStreamParser.$(CPP):	MPEGVideoStreamParser.hh
+MPEG1or2AudioStreamFramer.$(CPP):	include/MPEG1or2AudioStreamFramer.hh StreamParser.hh MP3Internals.hh
+include/MPEG1or2AudioStreamFramer.hh:	include/FramedFilter.hh
+MPEG1or2AudioRTPSource.$(CPP):	include/MPEG1or2AudioRTPSource.hh
+include/MPEG1or2AudioRTPSource.hh:	include/MultiFramedRTPSource.hh
+MPEG4LATMAudioRTPSource.$(CPP):	include/MPEG4LATMAudioRTPSource.hh
+include/MPEG4LATMAudioRTPSource.hh:	include/MultiFramedRTPSource.hh
+MPEG4ESVideoRTPSource.$(CPP):	include/MPEG4ESVideoRTPSource.hh
+include/MPEG4ESVideoRTPSource.hh:	include/MultiFramedRTPSource.hh
+MPEG4GenericRTPSource.$(CPP):	include/MPEG4GenericRTPSource.hh include/BitVector.hh include/MPEG4LATMAudioRTPSource.hh
+include/MPEG4GenericRTPSource.hh:	include/MultiFramedRTPSource.hh
+MP3FileSource.$(CPP):	include/MP3FileSource.hh MP3StreamState.hh include/InputFile.hh
+include/MP3FileSource.hh:	include/FramedFileSource.hh
+MP3StreamState.hh:	MP3Internals.hh
+MP3Internals.hh:	include/BitVector.hh
+MP3Transcoder.$(CPP):	include/MP3ADU.hh include/MP3Transcoder.hh
+include/MP3ADU.hh:		include/FramedFilter.hh
+include/MP3Transcoder.hh:	include/MP3ADU.hh include/MP3ADUTranscoder.hh
+include/MP3ADUTranscoder.hh:	include/FramedFilter.hh
+MP3ADU.$(CPP):		include/MP3ADU.hh MP3ADUdescriptor.hh MP3Internals.hh
+MP3ADUdescriptor.$(CPP):	MP3ADUdescriptor.hh
+MP3ADUinterleaving.$(CPP):	include/MP3ADUinterleaving.hh MP3ADUdescriptor.hh
+include/MP3ADUinterleaving.hh:	include/FramedFilter.hh
+MP3ADUTranscoder.$(CPP):	include/MP3ADUTranscoder.hh MP3Internals.hh
+MP3StreamState.$(CPP):	MP3StreamState.hh include/InputFile.hh
+MP3Internals.$(CPP):	MP3InternalsHuffman.hh
+MP3InternalsHuffman.hh:	MP3Internals.hh
+MP3InternalsHuffman.$(CPP):	MP3InternalsHuffman.hh
+MP3InternalsHuffmanTable.$(CPP):	MP3InternalsHuffman.hh
+MP3ADURTPSource.$(CPP):	include/MP3ADURTPSource.hh MP3ADUdescriptor.hh
+include/MP3ADURTPSource.hh:	include/MultiFramedRTPSource.hh
+MPEG1or2VideoRTPSource.$(CPP):	include/MPEG1or2VideoRTPSource.hh
+include/MPEG1or2VideoRTPSource.hh:	include/MultiFramedRTPSource.hh
+MPEG2TransportStreamMultiplexor.$(CPP):	include/MPEG2TransportStreamMultiplexor.hh
+include/MPEG2TransportStreamMultiplexor.hh:	include/FramedSource.hh include/MPEG1or2Demux.hh
+MPEG2TransportStreamFromPESSource.$(CPP):	include/MPEG2TransportStreamFromPESSource.hh
+include/MPEG2TransportStreamFromPESSource.hh:	include/MPEG2TransportStreamMultiplexor.hh include/MPEG1or2DemuxedElementaryStream.hh
+MPEG2TransportStreamFromESSource.$(CPP):	include/MPEG2TransportStreamFromESSource.hh
+include/MPEG2TransportStreamFromESSource.hh:	include/MPEG2TransportStreamMultiplexor.hh
+MPEG2TransportStreamFramer.$(CPP):	include/MPEG2TransportStreamFramer.hh
+include/MPEG2TransportStreamFramer.hh:	include/FramedFilter.hh include/MPEG2TransportStreamIndexFile.hh
+MPEG2TransportStreamAccumulator.$(CPP):	include/MPEG2TransportStreamAccumulator.hh
+include/MPEG2TransportStreamAccumulator.hh:	include/FramedFilter.hh
+ADTSAudioFileSource.$(CPP):	include/ADTSAudioFileSource.hh include/InputFile.hh
+ADTSAudioStreamDiscreteFramer.$(CPP):	include/ADTSAudioStreamDiscreteFramer.hh
+include/ADTSAudioStreamDiscreteFramer.hh:	include/FramedFilter.hh
+JPEGVideoSource.$(CPP):		include/JPEGVideoSource.hh
+include/JPEGVideoSource.hh:	include/FramedSource.hh
+JPEGVideoRTPSource.$(CPP):	include/JPEGVideoRTPSource.hh
+include/JPEGVideoRTPSource.hh:	include/MultiFramedRTPSource.hh
+#JPEG2000VideoStreamFramer.$(CPP):	include/JPEG2000VideoStreamFramer.hh JPEG2000VideoStreamParser.hh
+#include/JPEG2000VideoStreamFramer.hh:	include/MPEGVideoStreamFramer.hh
+#JPEG2000VideoStreamParser.hh:		StreamParser.hh include/MPEGVideoStreamFramer.hh
+#JPEG2000VideoStreamParser.$(CPP):	JPEG2000VideoStreamParser.hh
+JPEG2000VideoRTPSource.$(CPP):		include/JPEG2000VideoRTPSource.hh
+include/JPEG2000VideoRTPSource.hh:	include/MultiFramedRTPSource.hh
+include/ADTSAudioFileSource.hh:	include/FramedFileSource.hh
+H263plusVideoRTPSource.$(CPP):	include/H263plusVideoRTPSource.hh
+include/H263plusVideoRTPSource.hh:	include/MultiFramedRTPSource.hh
+H263plusVideoStreamFramer.$(CPP):	include/H263plusVideoStreamFramer.hh H263plusVideoStreamParser.hh
+include/H263plusVideoStreamFramer.hh:	include/FramedFilter.hh
+H263plusVideoStreamParser.hh:	StreamParser.hh
+H263plusVideoStreamParser.$(CPP):	H263plusVideoStreamParser.hh include/H263plusVideoStreamFramer.hh
+AC3AudioStreamFramer.$(CPP):	include/AC3AudioStreamFramer.hh StreamParser.hh
+include/AC3AudioStreamFramer.hh:	include/FramedFilter.hh
+AC3AudioRTPSource.$(CPP):	include/AC3AudioRTPSource.hh
+include/AC3AudioRTPSource.hh:	include/MultiFramedRTPSource.hh
+DVVideoRTPSource.$(CPP):	include/DVVideoRTPSource.hh
+include/DVVideoRTPSource.hh:	include/MultiFramedRTPSource.hh
+AMRAudioSource.$(CPP):	include/AMRAudioSource.hh
+include/AMRAudioSource.hh:	include/FramedSource.hh
+AMRAudioFileSource.$(CPP):	include/AMRAudioFileSource.hh include/InputFile.hh
+include/AMRAudioFileSource.hh:	include/AMRAudioSource.hh
+InputFile.$(CPP):		include/InputFile.hh
+StreamReplicator.$(CPP):	include/StreamReplicator.hh
+include/StreamReplicator.hh:	include/FramedSource.hh
+MediaSink.$(CPP):	include/MediaSink.hh
+include/MediaSink.hh:		include/FramedSource.hh
+FileSink.$(CPP):	include/FileSink.hh include/OutputFile.hh
+include/FileSink.hh:		include/MediaSink.hh
+BasicUDPSink.$(CPP):	include/BasicUDPSink.hh
+include/BasicUDPSink.hh:	include/MediaSink.hh
+AMRAudioFileSink.$(CPP):	include/AMRAudioFileSink.hh include/AMRAudioSource.hh include/OutputFile.hh
+include/AMRAudioFileSink.hh:	include/FileSink.hh
+H264or5VideoFileSink.$(CPP):	include/H264or5VideoFileSink.hh include/H264VideoRTPSource.hh
+include/H264or5VideoFileSink.hh:   include/FileSink.hh
+H264VideoFileSink.$(CPP):       include/H264VideoFileSink.hh include/OutputFile.hh
+include/H264VideoFileSink.hh:   include/H264or5VideoFileSink.hh
+H265VideoFileSink.$(CPP):       include/H265VideoFileSink.hh include/OutputFile.hh
+include/H265VideoFileSink.hh:   include/H264or5VideoFileSink.hh
+OggFileSink.$(CPP):		include/OggFileSink.hh include/OutputFile.hh include/VorbisAudioRTPSource.hh include/MPEG2TransportStreamMultiplexor.hh include/FramedSource.hh
+include/OggFileSink.hh:		include/FileSink.hh
+RTPSink.$(CPP):			include/RTPSink.hh include/Base64.hh
+include/RTPSink.hh:		include/MediaSink.hh include/RTPInterface.hh include/SRTPCryptographicContext.hh
+MultiFramedRTPSink.$(CPP):	include/MultiFramedRTPSink.hh
+include/MultiFramedRTPSink.hh:		include/RTPSink.hh
+AudioRTPSink.$(CPP):		include/AudioRTPSink.hh
+include/AudioRTPSink.hh:	include/MultiFramedRTPSink.hh
+VideoRTPSink.$(CPP):		include/VideoRTPSink.hh
+include/VideoRTPSink.hh:	include/MultiFramedRTPSink.hh
+TextRTPSink.$(CPP):		include/TextRTPSink.hh
+include/TextRTPSink.hh:		include/MultiFramedRTPSink.hh
+RTPInterface.$(CPP):		include/RTPInterface.hh
+MPEG1or2AudioRTPSink.$(CPP):	include/MPEG1or2AudioRTPSink.hh
+include/MPEG1or2AudioRTPSink.hh:	include/AudioRTPSink.hh
+MP3ADURTPSink.$(CPP):	include/MP3ADURTPSink.hh
+include/MP3ADURTPSink.hh:	include/AudioRTPSink.hh
+MPEG1or2VideoRTPSink.$(CPP):	include/MPEG1or2VideoRTPSink.hh include/MPEG1or2VideoStreamFramer.hh
+include/MPEG1or2VideoRTPSink.hh:	include/VideoRTPSink.hh
+MPEG4LATMAudioRTPSink.$(CPP):	include/MPEG4LATMAudioRTPSink.hh
+include/MPEG4LATMAudioRTPSink.hh:	include/AudioRTPSink.hh
+MPEG4GenericRTPSink.$(CPP):	include/MPEG4GenericRTPSink.hh include/Locale.hh
+include/MPEG4GenericRTPSink.hh:	include/MultiFramedRTPSink.hh
+MPEG4ESVideoRTPSink.$(CPP):	include/MPEG4ESVideoRTPSink.hh include/MPEG4VideoStreamFramer.hh include/MPEG4LATMAudioRTPSource.hh
+include/MPEG4ESVideoRTPSink.hh: include/VideoRTPSink.hh
+JPEGVideoRTPSink.$(CPP):	include/JPEGVideoRTPSink.hh include/JPEGVideoSource.hh
+include/JPEGVideoRTPSink.hh:	include/VideoRTPSink.hh
+JPEG2000VideoRTPSink.$(CPP):	include/JPEG2000VideoRTPSink.hh
+include/JPEG2000VideoRTPSink.hh:	include/VideoRTPSink.hh
+H263plusVideoRTPSink.$(CPP):	include/H263plusVideoRTPSink.hh
+include/H263plusVideoRTPSink.hh:	include/VideoRTPSink.hh
+H264or5VideoRTPSink.$(CPP):	include/H264or5VideoRTPSink.hh include/H264or5VideoStreamFramer.hh
+include/H264or5VideoRTPSink.hh:	include/VideoRTPSink.hh include/FramedFilter.hh
+H264VideoRTPSink.$(CPP):	include/H264VideoRTPSink.hh include/H264VideoStreamFramer.hh include/Base64.hh include/H264VideoRTPSource.hh
+include/H264VideoRTPSink.hh:	include/H264or5VideoRTPSink.hh
+H265VideoRTPSink.$(CPP):	include/H265VideoRTPSink.hh include/H265VideoStreamFramer.hh include/Base64.hh include/BitVector.hh include/H264VideoRTPSource.hh
+include/H265VideoRTPSink.hh:	include/H264or5VideoRTPSink.hh
+DVVideoRTPSink.$(CPP):	include/DVVideoRTPSink.hh
+include/DVVideoRTPSink.hh:	include/VideoRTPSink.hh include/DVVideoStreamFramer.hh
+include/DVVideoStreamFramer.hh:	include/FramedFilter.hh
+AC3AudioRTPSink.$(CPP):		include/AC3AudioRTPSink.hh
+include/AC3AudioRTPSink.hh:	include/AudioRTPSink.hh
+VorbisAudioRTPSink.$(CPP):	include/VorbisAudioRTPSink.hh include/Base64.hh include/VorbisAudioRTPSource.hh
+include/VorbisAudioRTPSink.hh:	include/AudioRTPSink.hh
+TheoraVideoRTPSink.$(CPP):	include/TheoraVideoRTPSink.hh include/Base64.hh include/VorbisAudioRTPSource.hh include/VorbisAudioRTPSink.hh
+include/TheoraVideoRTPSink.hh:	include/VideoRTPSink.hh
+RawVideoRTPSink.$(CPP):	include/RawVideoRTPSink.hh
+include/RawVideoRTPSink.hh:	include/VideoRTPSink.hh include/RawVideoFrameParameters.hh
+VP8VideoRTPSink.$(CPP):		include/VP8VideoRTPSink.hh
+include/VP8VideoRTPSink.hh:	include/VideoRTPSink.hh
+VP9VideoRTPSink.$(CPP):		include/VP9VideoRTPSink.hh
+include/VP9VideoRTPSink.hh:	include/VideoRTPSink.hh
+GSMAudioRTPSink.$(CPP):		include/GSMAudioRTPSink.hh
+include/GSMAudioRTPSink.hh:	include/AudioRTPSink.hh
+SimpleRTPSink.$(CPP):		include/SimpleRTPSink.hh
+include/SimpleRTPSink.hh:	include/MultiFramedRTPSink.hh
+AMRAudioRTPSink.$(CPP):		include/AMRAudioRTPSink.hh include/AMRAudioSource.hh
+include/AMRAudioRTPSink.hh:	include/AudioRTPSink.hh
+T140TextRTPSink.$(CPP):		include/T140TextRTPSink.hh
+include/T140TextRTPSink.hh:	include/TextRTPSink.hh include/FramedFilter.hh
+OutputFile.$(CPP):		include/OutputFile.hh
+uLawAudioFilter.$(CPP):		include/uLawAudioFilter.hh
+include/uLawAudioFilter.hh:	include/FramedFilter.hh
+MPEG2IndexFromTransportStream.$(CPP):	include/MPEG2IndexFromTransportStream.hh
+include/MPEG2IndexFromTransportStream.hh:	include/FramedFilter.hh
+MPEG2TransportStreamIndexFile.$(CPP):	include/MPEG2TransportStreamIndexFile.hh include/InputFile.hh
+include/MPEG2TransportStreamIndexFile.hh:	include/Media.hh
+MPEG2TransportStreamTrickModeFilter.$(CPP):	include/MPEG2TransportStreamTrickModeFilter.hh include/ByteStreamFileSource.hh
+include/MPEG2TransportStreamTrickModeFilter.hh:	include/FramedFilter.hh include/MPEG2TransportStreamIndexFile.hh
+RTCP.$(CPP):		include/RTCP.hh rtcp_from_spec.h
+include/RTCP.hh:		include/RTPSink.hh include/RTPSource.hh include/SRTPCryptographicContext.hh
+rtcp_from_spec.$(C):	rtcp_from_spec.h
+GenericMediaServer.$(CPP):	include/GenericMediaServer.hh
+include/GenericMediaServer.hh:	include/ServerMediaSession.hh
+RTSPServer.$(CPP):	include/RTSPServer.hh include/RTSPCommon.hh include/RTSPRegisterSender.hh include/ProxyServerMediaSession.hh include/Base64.hh
+include/RTSPServer.hh:		include/GenericMediaServer.hh include/DigestAuthentication.hh
+RTSPServerRegister.$(CPP):	include/RTSPServer.hh
+include/ServerMediaSession.hh:	include/RTCP.hh
+RTSPClient.$(CPP):	include/RTSPClient.hh  include/RTSPCommon.hh include/Base64.hh include/Locale.hh include/ourMD5.hh
+include/RTSPClient.hh:		include/MediaSession.hh include/DigestAuthentication.hh
+RTSPCommon.$(CPP):	include/RTSPCommon.hh include/Locale.hh
+RTSPRegisterSender.$(CPP):	include/RTSPRegisterSender.hh
+include/RTSPRegisterSender.hh:	include/RTSPClient.hh
+SIPClient.$(CPP):	include/SIPClient.hh
+include/SIPClient.hh:		include/MediaSession.hh include/DigestAuthentication.hh
+MediaSession.$(CPP):	include/liveMedia.hh include/Locale.hh include/Base64.hh
+include/MediaSession.hh:	include/RTCP.hh include/FramedFilter.hh include/SRTPCryptographicContext.hh
+ServerMediaSession.$(CPP):	include/ServerMediaSession.hh
+PassiveServerMediaSubsession.$(CPP):	include/PassiveServerMediaSubsession.hh
+include/PassiveServerMediaSubsession.hh:	include/ServerMediaSession.hh include/RTPSink.hh include/RTCP.hh
+OnDemandServerMediaSubsession.$(CPP):	include/OnDemandServerMediaSubsession.hh
+include/OnDemandServerMediaSubsession.hh:	include/ServerMediaSession.hh include/RTPSink.hh include/BasicUDPSink.hh include/RTCP.hh
+FileServerMediaSubsession.$(CPP):	include/FileServerMediaSubsession.hh
+include/FileServerMediaSubsession.hh:	include/OnDemandServerMediaSubsession.hh
+MPEG4VideoFileServerMediaSubsession.$(CPP):	include/MPEG4VideoFileServerMediaSubsession.hh include/MPEG4ESVideoRTPSink.hh include/ByteStreamFileSource.hh include/MPEG4VideoStreamFramer.hh
+include/MPEG4VideoFileServerMediaSubsession.hh:	include/FileServerMediaSubsession.hh
+H264VideoFileServerMediaSubsession.$(CPP):	include/H264VideoFileServerMediaSubsession.hh include/H264VideoRTPSink.hh include/ByteStreamFileSource.hh include/H264VideoStreamFramer.hh
+include/H264VideoFileServerMediaSubsession.hh:	include/FileServerMediaSubsession.hh
+H265VideoFileServerMediaSubsession.$(CPP):	include/H265VideoFileServerMediaSubsession.hh include/H265VideoRTPSink.hh include/ByteStreamFileSource.hh include/H265VideoStreamFramer.hh
+include/H265VideoFileServerMediaSubsession.hh:	include/FileServerMediaSubsession.hh
+H263plusVideoFileServerMediaSubsession.$(CPP):	include/H263plusVideoFileServerMediaSubsession.hh include/H263plusVideoRTPSink.hh include/ByteStreamFileSource.hh include/H263plusVideoStreamFramer.hh
+include/H263plusVideoFileServerMediaSubsession.hh:	include/FileServerMediaSubsession.hh
+WAVAudioFileServerMediaSubsession.$(CPP):	include/WAVAudioFileServerMediaSubsession.hh include/WAVAudioFileSource.hh include/uLawAudioFilter.hh include/SimpleRTPSink.hh
+include/WAVAudioFileServerMediaSubsession.hh:	include/FileServerMediaSubsession.hh
+AMRAudioFileServerMediaSubsession.$(CPP):	include/AMRAudioFileServerMediaSubsession.hh include/AMRAudioRTPSink.hh include/AMRAudioFileSource.hh
+include/AMRAudioFileServerMediaSubsession.hh:	include/FileServerMediaSubsession.hh
+MP3AudioFileServerMediaSubsession.$(CPP):	include/MP3AudioFileServerMediaSubsession.hh include/MPEG1or2AudioRTPSink.hh include/MP3ADURTPSink.hh include/MP3FileSource.hh include/MP3ADU.hh
+include/MP3AudioFileServerMediaSubsession.hh:	include/FileServerMediaSubsession.hh include/MP3ADUinterleaving.hh
+MPEG1or2VideoFileServerMediaSubsession.$(CPP):	include/MPEG1or2VideoFileServerMediaSubsession.hh include/MPEG1or2VideoRTPSink.hh include/ByteStreamFileSource.hh include/MPEG1or2VideoStreamFramer.hh
+include/MPEG1or2VideoFileServerMediaSubsession.hh:	include/FileServerMediaSubsession.hh
+MPEG1or2FileServerDemux.$(CPP):	include/MPEG1or2FileServerDemux.hh include/MPEG1or2DemuxedServerMediaSubsession.hh include/ByteStreamFileSource.hh
+include/MPEG1or2FileServerDemux.hh:	include/ServerMediaSession.hh include/MPEG1or2DemuxedElementaryStream.hh
+MPEG1or2DemuxedServerMediaSubsession.$(CPP): include/MPEG1or2DemuxedServerMediaSubsession.hh include/MPEG1or2AudioStreamFramer.hh include/MPEG1or2AudioRTPSink.hh include/MPEG1or2VideoStreamFramer.hh include/MPEG1or2VideoRTPSink.hh include/AC3AudioStreamFramer.hh include/AC3AudioRTPSink.hh include/ByteStreamFileSource.hh
+include/MPEG1or2DemuxedServerMediaSubsession.hh: include/OnDemandServerMediaSubsession.hh include/MPEG1or2FileServerDemux.hh
+MPEG2TransportFileServerMediaSubsession.$(CPP):	include/MPEG2TransportFileServerMediaSubsession.hh include/SimpleRTPSink.hh
+include/MPEG2TransportFileServerMediaSubsession.hh:	include/FileServerMediaSubsession.hh include/MPEG2TransportStreamFramer.hh include/ByteStreamFileSource.hh include/MPEG2TransportStreamTrickModeFilter.hh include/MPEG2TransportStreamFromESSource.hh
+ADTSAudioFileServerMediaSubsession.$(CPP):	include/ADTSAudioFileServerMediaSubsession.hh include/ADTSAudioFileSource.hh include/MPEG4GenericRTPSink.hh
+include/ADTSAudioFileServerMediaSubsession.hh:	include/FileServerMediaSubsession.hh
+DVVideoFileServerMediaSubsession.$(CPP):	include/DVVideoFileServerMediaSubsession.hh include/DVVideoRTPSink.hh include/ByteStreamFileSource.hh include/DVVideoStreamFramer.hh
+include/DVVideoFileServerMediaSubsession.hh:	include/FileServerMediaSubsession.hh
+AC3AudioFileServerMediaSubsession.$(CPP):	include/AC3AudioFileServerMediaSubsession.hh include/AC3AudioRTPSink.hh include/ByteStreamFileSource.hh include/AC3AudioStreamFramer.hh
+include/AC3AudioFileServerMediaSubsession.hh:	include/FileServerMediaSubsession.hh
+#JPEG2000VideoFileServerMediaSubsession.$(CPP):	include/JPEG2000VideoFileServerMediaSubsession.hh
+#include/JPEG2000VideoFileServerMediaSubsession.hh:	include/FileServerMediaSubsession.hh
+MPEG2TransportUDPServerMediaSubsession.$(CPP):	include/MPEG2TransportUDPServerMediaSubsession.hh include/BasicUDPSource.hh include/SimpleRTPSource.hh include/MPEG2TransportStreamFramer.hh include/SimpleRTPSink.hh
+include/MPEG2TransportUDPServerMediaSubsession.hh:	include/OnDemandServerMediaSubsession.hh
+ProxyServerMediaSession.$(CPP):		include/liveMedia.hh include/RTSPCommon.hh
+include/ProxyServerMediaSession.hh:	include/ServerMediaSession.hh include/MediaSession.hh include/RTSPClient.hh include/MediaTranscodingTable.hh
+include/MediaTranscodingTable.hh:	include/FramedFilter.hh include/MediaSession.hh
+QuickTimeFileSink.$(CPP):	include/QuickTimeFileSink.hh include/InputFile.hh include/OutputFile.hh include/QuickTimeGenericRTPSource.hh include/H263plusVideoRTPSource.hh include/MPEG4GenericRTPSource.hh include/MPEG4LATMAudioRTPSource.hh
+include/QuickTimeFileSink.hh:	include/MediaSession.hh
+QuickTimeGenericRTPSource.$(CPP):	include/QuickTimeGenericRTPSource.hh
+include/QuickTimeGenericRTPSource.hh:	include/MultiFramedRTPSource.hh
+AVIFileSink.$(CPP):	include/AVIFileSink.hh include/InputFile.hh include/OutputFile.hh
+include/AVIFileSink.hh:	include/MediaSession.hh
+MatroskaFile.$(CPP): MatroskaFileParser.hh MatroskaDemuxedTrack.hh include/ByteStreamFileSource.hh include/H264VideoStreamDiscreteFramer.hh include/H265VideoStreamDiscreteFramer.hh include/MPEG1or2AudioRTPSink.hh include/MPEG4GenericRTPSink.hh include/AC3AudioRTPSink.hh include/SimpleRTPSink.hh include/VorbisAudioRTPSink.hh include/H264VideoRTPSink.hh include/H265VideoRTPSink.hh include/VP8VideoRTPSink.hh include/VP9VideoRTPSink.hh include/T140TextRTPSink.hh include/Base64.hh include/H264VideoFileSink.hh include/H265VideoFileSink.hh include/AMRAudioFileSink.hh include/OggFileSink.hh
+MatroskaFileParser.hh:	StreamParser.hh include/MatroskaFile.hh EBMLNumber.hh
+include/MatroskaFile.hh: include/RTPSink.hh include/FileSink.hh
+MatroskaDemuxedTrack.hh:	include/FramedSource.hh
+MatroskaFileParser.$(CPP): MatroskaFileParser.hh MatroskaDemuxedTrack.hh include/ByteStreamFileSource.hh
+EBMLNumber.$(CPP): EBMLNumber.hh
+MatroskaDemuxedTrack.$(CPP): MatroskaDemuxedTrack.hh include/MatroskaFile.hh
+MatroskaFileServerMediaSubsession.$(CPP): MatroskaFileServerMediaSubsession.hh MatroskaDemuxedTrack.hh include/FramedFilter.hh
+MatroskaFileServerMediaSubsession.hh: include/FileServerMediaSubsession.hh include/MatroskaFileServerDemux.hh
+MP3AudioMatroskaFileServerMediaSubsession.$(CPP): MP3AudioMatroskaFileServerMediaSubsession.hh MatroskaDemuxedTrack.hh
+MP3AudioMatroskaFileServerMediaSubsession.hh: include/MP3AudioFileServerMediaSubsession.hh include/MatroskaFileServerDemux.hh
+MatroskaFileServerDemux.$(CPP): include/MatroskaFileServerDemux.hh MP3AudioMatroskaFileServerMediaSubsession.hh MatroskaFileServerMediaSubsession.hh
+include/MatroskaFileServerDemux.hh: include/ServerMediaSession.hh include/MatroskaFile.hh
+OggFile.$(CPP): OggFileParser.hh OggDemuxedTrack.hh include/ByteStreamFileSource.hh include/VorbisAudioRTPSink.hh include/SimpleRTPSink.hh include/TheoraVideoRTPSink.hh
+OggFileParser.hh:	StreamParser.hh include/OggFile.hh
+include/OggFile.hh: include/RTPSink.hh
+OggDemuxedTrack.hh:	include/FramedSource.hh
+OggFileParser.$(CPP): OggFileParser.hh OggDemuxedTrack.hh
+OggDemuxedTrack.$(CPP): OggDemuxedTrack.hh include/OggFile.hh
+OggFileServerMediaSubsession.$(CPP): OggFileServerMediaSubsession.hh OggDemuxedTrack.hh include/FramedFilter.hh
+OggFileServerMediaSubsession.hh: include/FileServerMediaSubsession.hh include/OggFileServerDemux.hh
+OggFileServerDemux.$(CPP): include/OggFileServerDemux.hh OggFileServerMediaSubsession.hh
+include/OggFileServerDemux.hh: include/ServerMediaSession.hh include/OggFile.hh
+MPEG2TransportStreamDemux.$(CPP): include/MPEG2TransportStreamDemux.hh MPEG2TransportStreamParser.hh
+include/MPEG2TransportStreamDemux.hh: include/FramedSource.hh
+MPEG2TransportStreamParser.hh: StreamParser.hh MPEG2TransportStreamDemuxedTrack.hh include/MediaSink.hh
+MPEG2TransportStreamDemuxedTrack.hh: include/MPEG2TransportStreamDemux.hh
+MPEG2TransportStreamDemuxedTrack.$(CPP): MPEG2TransportStreamParser.hh
+MPEG2TransportStreamParser.$(CPP): MPEG2TransportStreamParser.hh
+MPEG2TransportStreamParser_PAT.$(CPP): MPEG2TransportStreamParser.hh
+MPEG2TransportStreamParser_PMT.$(CPP): MPEG2TransportStreamParser.hh
+MPEG2TransportStreamParser_STREAM.$(CPP): MPEG2TransportStreamParser.hh include/FileSink.hh
+HLSSegmenter.$(CPP): include/HLSSegmenter.hh include/OutputFile.hh include/MPEG2TransportStreamMultiplexor.hh
+include/HLSSegmenter.hh: include/MediaSink.hh
+TLSState.$(CPP):		include/TLSState.hh include/RTSPClient.hh
+MIKEY.$(CPP):		 include/MIKEY.hh
+HMAC_SHA1.$(CPP):	include/HMAC_SHA1.hh
+include/SRTPCryptographicContext.hh:	include/MIKEY.hh
+SRTPCryptographicContext.$(CPP):	include/SRTPCryptographicContext.hh include/HMAC_SHA1.hh
+include/HMAC_SHA1.hh:	include/HMAC_hash.hh
+BitVector.$(CPP):	include/BitVector.hh
+StreamParser.$(CPP):	StreamParser.hh
+DigestAuthentication.$(CPP):	include/DigestAuthentication.hh include/ourMD5.hh
+ourMD5.$(CPP):	include/ourMD5.hh
+Base64.$(CPP):	include/Base64.hh
+Locale.$(CPP):	include/Locale.hh
+
+include/liveMedia.hh:: include/JPEG2000VideoRTPSource.hh include/JPEG2000VideoRTPSink.hh
+#include/liveMedia.hh:: include/JPEG2000VideoStreamFramer.hh include/JPEG2000VideoFileServerMediaSubsession.hh
+
+include/liveMedia.hh:: include/MPEG1or2AudioRTPSink.hh include/MP3ADURTPSink.hh include/MPEG1or2VideoRTPSink.hh include/MPEG4ESVideoRTPSink.hh include/BasicUDPSink.hh include/AMRAudioFileSink.hh include/H264VideoFileSink.hh include/H265VideoFileSink.hh include/OggFileSink.hh include/GSMAudioRTPSink.hh include/H263plusVideoRTPSink.hh include/H264VideoRTPSink.hh include/H265VideoRTPSink.hh include/DVVideoRTPSource.hh include/DVVideoRTPSink.hh include/DVVideoStreamFramer.hh include/H264VideoStreamFramer.hh include/H265VideoStreamFramer.hh include/H264VideoStreamDiscreteFramer.hh include/H265VideoStreamDiscreteFramer.hh include/JPEGVideoRTPSink.hh include/SimpleRTPSink.hh include/uLawAudioFilter.hh include/MPEG2IndexFromTransportStream.hh include/MPEG2TransportStreamTrickModeFilter.hh include/ByteStreamMultiFileSource.hh include/ByteStreamMemoryBufferSource.hh include/BasicUDPSource.hh include/SimpleRTPSource.hh include/MPEG1or2AudioRTPSource.hh include/MPEG4LATMAudioRTPSource.hh include/MPEG4LATMAudioRTPSink.hh include/MPEG4ESVideoRTPSource.hh include/MPEG4GenericRTPSource.hh include/MP3ADURTPSource.hh include/QCELPAudioRTPSource.hh include/AMRAudioRTPSource.hh include/JPEGVideoRTPSource.hh include/JPEGVideoSource.hh include/MPEG1or2VideoRTPSource.hh include/VorbisAudioRTPSource.hh include/TheoraVideoRTPSource.hh include/VP8VideoRTPSource.hh include/VP9VideoRTPSource.hh include/RawVideoRTPSource.hh
+
+include/liveMedia.hh::	include/MPEG2TransportStreamFromPESSource.hh include/MPEG2TransportStreamFromESSource.hh include/MPEG2TransportStreamFramer.hh include/ADTSAudioFileSource.hh include/ADTSAudioStreamDiscreteFramer.hh include/H261VideoRTPSource.hh include/H263plusVideoRTPSource.hh include/H264VideoRTPSource.hh include/H265VideoRTPSource.hh include/MP3FileSource.hh include/MP3ADU.hh include/MP3ADUinterleaving.hh include/MP3Transcoder.hh include/MPEG1or2DemuxedElementaryStream.hh include/MPEG1or2AudioStreamFramer.hh include/MPEG1or2VideoStreamDiscreteFramer.hh include/MPEG4VideoStreamDiscreteFramer.hh include/H263plusVideoStreamFramer.hh include/AC3AudioStreamFramer.hh include/AC3AudioRTPSource.hh include/AC3AudioRTPSink.hh include/VorbisAudioRTPSink.hh include/TheoraVideoRTPSink.hh include/VP8VideoRTPSink.hh include/VP9VideoRTPSink.hh include/MPEG4GenericRTPSink.hh include/DeviceSource.hh include/AudioInputDevice.hh include/WAVAudioFileSource.hh include/StreamReplicator.hh include/RTSPRegisterSender.hh
+
+include/liveMedia.hh:: include/RTSPClient.hh include/SIPClient.hh include/QuickTimeFileSink.hh include/QuickTimeGenericRTPSource.hh include/AVIFileSink.hh include/PassiveServerMediaSubsession.hh include/MPEG4VideoFileServerMediaSubsession.hh include/H264VideoFileServerMediaSubsession.hh include/H265VideoFileServerMediaSubsession.hh include/WAVAudioFileServerMediaSubsession.hh include/AMRAudioFileServerMediaSubsession.hh include/AMRAudioFileSource.hh include/AMRAudioRTPSink.hh include/T140TextRTPSink.hh include/MP3AudioFileServerMediaSubsession.hh include/MPEG1or2VideoFileServerMediaSubsession.hh include/MPEG1or2FileServerDemux.hh include/MPEG2TransportFileServerMediaSubsession.hh include/H263plusVideoFileServerMediaSubsession.hh include/ADTSAudioFileServerMediaSubsession.hh include/DVVideoFileServerMediaSubsession.hh include/AC3AudioFileServerMediaSubsession.hh include/MPEG2TransportUDPServerMediaSubsession.hh include/MatroskaFileServerDemux.hh include/OggFileServerDemux.hh include/ProxyServerMediaSession.hh include/HLSSegmenter.hh include/MPEG2TransportStreamAccumulator.hh
+
+clean:
+	-rm -rf *.$(OBJ) $(ALL) core *.core *~ include/*~
+
+install: install1 $(INSTALL2)
+install1: $(LIVEMEDIA_LIB)
+	 install -d $(DESTDIR)$(PREFIX)/include/liveMedia $(DESTDIR)$(LIBDIR)
+	 install -m 644 include/*.hh $(DESTDIR)$(PREFIX)/include/liveMedia
+	 install -m 644 $(LIVEMEDIA_LIB) $(DESTDIR)$(LIBDIR)
+install_shared_libraries: $(LIVEMEDIA_LIB)
+	 ln -fs $(NAME).$(LIB_SUFFIX) $(DESTDIR)$(LIBDIR)/$(NAME).$(SHORT_LIB_SUFFIX)
+	 ln -fs $(NAME).$(LIB_SUFFIX) $(DESTDIR)$(LIBDIR)/$(NAME).so
+
+##### Any additional, platform-specific rules come here:
diff --git a/3rdparty/live555/src/liveMedia/MatroskaDemuxedTrack.cpp b/3rdparty/live555/src/liveMedia/MatroskaDemuxedTrack.cpp
new file mode 100644
index 00000000..a14d27b0
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/MatroskaDemuxedTrack.cpp
@@ -0,0 +1,56 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A media track, demultiplexed from a Matroska file
+// Implementation
+
+#include "MatroskaDemuxedTrack.hh"
+#include "MatroskaFile.hh"
+
+void MatroskaDemuxedTrack::seekToTime(double &seekNPT) {
+    fOurSourceDemux.seekToTime(seekNPT);
+}
+
+MatroskaDemuxedTrack::MatroskaDemuxedTrack(UsageEnvironment &env, unsigned trackNumber, MatroskaDemux &sourceDemux)
+    : FramedSource(env), fOurTrackNumber(trackNumber), fOurSourceDemux(sourceDemux), fOpusFrameNumber(0) {
+    reset();
+}
+
+MatroskaDemuxedTrack::~MatroskaDemuxedTrack() {
+    fOurSourceDemux.removeTrack(fOurTrackNumber);
+}
+
+void MatroskaDemuxedTrack::doGetNextFrame() {
+    fOurSourceDemux.continueReading();
+}
+
+void MatroskaDemuxedTrack::doStopGettingFrames() {
+    fOurSourceDemux.pause();
+}
+
+char const *MatroskaDemuxedTrack::MIMEtype() const {
+    MatroskaTrack *track = fOurSourceDemux.fOurFile.lookup(fOurTrackNumber);
+    if(track == NULL)
+        return "(unknown)";  // shouldn't happen
+    return track->mimeType;
+}
+
+void MatroskaDemuxedTrack::reset() {
+    fPrevPresentationTime.tv_sec  = 0;
+    fPrevPresentationTime.tv_usec = 0;
+    fDurationImbalance            = 0;
+}
diff --git a/3rdparty/live555/src/liveMedia/MatroskaDemuxedTrack.hh b/3rdparty/live555/src/liveMedia/MatroskaDemuxedTrack.hh
new file mode 100644
index 00000000..bfa3da3d
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/MatroskaDemuxedTrack.hh
@@ -0,0 +1,66 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A media track, demultiplexed from a Matroska file
+// C++ header
+
+#ifndef _MATROSKA_DEMUXED_TRACK_HH
+#define _MATROSKA_DEMUXED_TRACK_HH
+
+#ifndef _FRAMED_SOURCE_HH
+#include "FramedSource.hh"
+#endif
+
+class MatroskaDemux; // forward
+
+class MatroskaDemuxedTrack: public FramedSource {
+public:
+  void seekToTime(double& seekNPT);
+
+private: // We are created only by a MatroskaDemux (a friend)
+  friend class MatroskaDemux;
+  MatroskaDemuxedTrack(UsageEnvironment& env, unsigned trackNumber, MatroskaDemux& sourceDemux);
+  virtual ~MatroskaDemuxedTrack();
+
+private:
+  // redefined virtual functions:
+  virtual void doGetNextFrame();
+  virtual void doStopGettingFrames();
+  virtual char const* MIMEtype() const;
+
+private: // We are accessed only by MatroskaDemux and by MatroskaFileParser (a friend)
+  friend class MatroskaFileParser;
+  unsigned char* to() { return fTo; }
+  unsigned maxSize() { return fMaxSize; }
+  unsigned& frameSize() { return fFrameSize; }
+  unsigned& numTruncatedBytes() { return fNumTruncatedBytes; }
+  struct timeval& presentationTime() { return fPresentationTime; }
+  unsigned& durationInMicroseconds() { return fDurationInMicroseconds; }
+
+  struct timeval& prevPresentationTime() { return fPrevPresentationTime; }
+  int& durationImbalance() { return fDurationImbalance; }
+  void reset();
+
+private:
+  unsigned fOurTrackNumber;
+  MatroskaDemux& fOurSourceDemux;
+  struct timeval fPrevPresentationTime;
+  int fDurationImbalance;
+  unsigned fOpusFrameNumber; // hack for Opus audio
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/MatroskaFile.cpp b/3rdparty/live555/src/liveMedia/MatroskaFile.cpp
new file mode 100644
index 00000000..7aa7a4b6
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/MatroskaFile.cpp
@@ -0,0 +1,1235 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A class that encapsulates a Matroska file.
+// Implementation
+
+#include "MatroskaFileParser.hh"
+#include "MatroskaDemuxedTrack.hh"
+#include <ByteStreamFileSource.hh>
+#include <H264VideoStreamDiscreteFramer.hh>
+#include <H265VideoStreamDiscreteFramer.hh>
+#include <MPEG1or2AudioRTPSink.hh>
+#include <MPEG4GenericRTPSink.hh>
+#include <AC3AudioRTPSink.hh>
+#include <SimpleRTPSink.hh>
+#include <VorbisAudioRTPSink.hh>
+#include <H264VideoRTPSink.hh>
+#include <H265VideoRTPSink.hh>
+#include <VP8VideoRTPSink.hh>
+#include <VP9VideoRTPSink.hh>
+#include <TheoraVideoRTPSink.hh>
+#include <RawVideoRTPSink.hh>
+#include <T140TextRTPSink.hh>
+#include <Base64.hh>
+#include <H264VideoFileSink.hh>
+#include <H265VideoFileSink.hh>
+#include <AMRAudioFileSink.hh>
+#include <OggFileSink.hh>
+
+////////// CuePoint definition //////////
+
+class CuePoint {
+public:
+    CuePoint(double cueTime, u_int64_t clusterOffsetInFile, unsigned blockNumWithinCluster /* 1-based */);
+    virtual ~CuePoint();
+
+    static void addCuePoint(CuePoint *&root, double cueTime, u_int64_t clusterOffsetInFile, unsigned blockNumWithinCluster /* 1-based */,
+                            Boolean &needToReviseBalanceOfParent);
+    // If "cueTime" == "root.fCueTime", replace the existing data, otherwise add to the left or right subtree.
+    // (Note that this is a static member function because - as a result of tree rotation - "root" might change.)
+
+    Boolean lookup(double &cueTime, u_int64_t &resultClusterOffsetInFile, unsigned &resultBlockNumWithinCluster);
+
+    static void fprintf(FILE *fid, CuePoint *cuePoint);  // used for debugging; it's static to allow for "cuePoint == NULL"
+
+private:
+    // The "CuePoint" tree is implemented as an AVL Tree, to keep it balanced (for efficient lookup).
+    CuePoint *fSubTree[2];  // 0 => left; 1 => right
+    CuePoint *left() const {
+        return fSubTree[0];
+    }
+    CuePoint *right() const {
+        return fSubTree[1];
+    }
+    char fBalance;  // height of right subtree - height of left subtree
+
+    static void rotate(unsigned direction /*0 => left; 1 => right*/, CuePoint *&root);  // used to keep the tree in balance
+
+    double    fCueTime;
+    u_int64_t fClusterOffsetInFile;
+    unsigned  fBlockNumWithinCluster;  // 0-based
+};
+
+UsageEnvironment &operator<<(UsageEnvironment &env, const CuePoint *cuePoint);  // used for debugging
+
+////////// MatroskaTrackTable definition /////////
+
+// For looking up and iterating over the file's tracks:
+class MatroskaTrackTable {
+public:
+    MatroskaTrackTable();
+    virtual ~MatroskaTrackTable();
+
+    void           add(MatroskaTrack *newTrack, unsigned trackNumber);
+    MatroskaTrack *lookup(unsigned trackNumber);
+
+    unsigned numTracks() const;
+
+    class Iterator {
+    public:
+        Iterator(MatroskaTrackTable &ourTable);
+        virtual ~Iterator();
+        MatroskaTrack *next();
+
+    private:
+        HashTable::Iterator *fIter;
+    };
+
+private:
+    friend class Iterator;
+    HashTable *fTable;
+};
+
+////////// MatroskaFile implementation //////////
+
+void MatroskaFile ::createNew(UsageEnvironment &env, char const *fileName, onCreationFunc *onCreation, void *onCreationClientData,
+                              char const *preferredLanguage) {
+    new MatroskaFile(env, fileName, onCreation, onCreationClientData, preferredLanguage);
+}
+
+MatroskaFile::MatroskaFile(UsageEnvironment &env, char const *fileName, onCreationFunc *onCreation, void *onCreationClientData, char const *preferredLanguage)
+    : Medium(env),
+      fFileName(strDup(fileName)),
+      fOnCreation(onCreation),
+      fOnCreationClientData(onCreationClientData),
+      fPreferredLanguage(strDup(preferredLanguage)),
+      fTimecodeScale(1000000),
+      fSegmentDuration(0.0),
+      fSegmentDataOffset(0),
+      fClusterOffset(0),
+      fCuesOffset(0),
+      fCuePoints(NULL),
+      fChosenVideoTrackNumber(0),
+      fChosenAudioTrackNumber(0),
+      fChosenSubtitleTrackNumber(0) {
+    fTrackTable   = new MatroskaTrackTable;
+    fDemuxesTable = HashTable::create(ONE_WORD_HASH_KEYS);
+
+    FramedSource *inputSource = ByteStreamFileSource::createNew(envir(), fileName);
+    if(inputSource == NULL) {
+        // The specified input file does not exist!
+        fParserForInitialization = NULL;
+        handleEndOfTrackHeaderParsing();  // we have no file, and thus no tracks, but we still need to signal this
+    }
+    else {
+        // Initialize ourselves by parsing the file's 'Track' headers:
+        fParserForInitialization = new MatroskaFileParser(*this, inputSource, handleEndOfTrackHeaderParsing, this, NULL);
+    }
+}
+
+struct DemuxRecord {
+    MatroskaDemux *              demux;
+    MatroskaDemuxOnDeletionFunc *onDeletionFunc;
+    void *                       objectToNotify;
+};
+
+MatroskaFile::~MatroskaFile() {
+    delete fParserForInitialization;
+    delete fCuePoints;
+
+    // Delete any outstanding "MatroskaDemux"s, and the table for them:
+    DemuxRecord *demuxRecord;
+    while((demuxRecord = (DemuxRecord *)fDemuxesTable->RemoveNext()) != NULL) {
+        delete demuxRecord->demux;
+        delete demuxRecord;
+    }
+    delete fDemuxesTable;
+    delete fTrackTable;
+
+    delete[](char *) fPreferredLanguage;
+    delete[](char *) fFileName;
+}
+
+void MatroskaFile::handleEndOfTrackHeaderParsing(void *clientData) {
+    ((MatroskaFile *)clientData)->handleEndOfTrackHeaderParsing();
+}
+
+class TrackChoiceRecord {
+public:
+    unsigned trackNumber;
+    u_int8_t trackType;
+    unsigned choiceFlags;
+};
+
+void MatroskaFile::handleEndOfTrackHeaderParsing() {
+    // Having parsed all of our track headers, iterate through the tracks to figure out which ones should be played.
+    // The Matroska 'specification' is rather imprecise about this (as usual).  However, we use the following algorithm:
+    // - Use one (but no more) enabled track of each type (video, audio, subtitle).  (Ignore all tracks that are not 'enabled'.)
+    // - For each track type, choose the one that's 'forced'.
+    //     - If more than one is 'forced', choose the first one that matches our preferred language, or the first if none matches.
+    //     - If none is 'forced', choose the one that's 'default'.
+    //     - If more than one is 'default', choose the first one that matches our preferred language, or the first if none matches.
+    //     - If none is 'default', choose the first one that matches our preferred language, or the first if none matches.
+    unsigned numTracks = fTrackTable->numTracks();
+    if(numTracks > 0) {
+        TrackChoiceRecord *          trackChoice      = new TrackChoiceRecord[numTracks];
+        unsigned                     numEnabledTracks = 0;
+        MatroskaTrackTable::Iterator iter(*fTrackTable);
+        MatroskaTrack *              track;
+        while((track = iter.next()) != NULL) {
+            if(!track->isEnabled || track->trackType == 0 || track->mimeType[0] == '\0')
+                continue;  // track not enabled, or not fully-defined
+
+            trackChoice[numEnabledTracks].trackNumber = track->trackNumber;
+            trackChoice[numEnabledTracks].trackType   = track->trackType;
+
+            // Assign flags for this track so that, when sorted, the largest value becomes our choice:
+            unsigned choiceFlags = 0;
+            if(fPreferredLanguage != NULL && track->language != NULL && strcmp(fPreferredLanguage, track->language) == 0) {
+                // This track matches our preferred language:
+                choiceFlags |= 1;
+            }
+            if(track->isForced) {
+                choiceFlags |= 4;
+            }
+            else if(track->isDefault) {
+                choiceFlags |= 2;
+            }
+            trackChoice[numEnabledTracks].choiceFlags = choiceFlags;
+
+            ++numEnabledTracks;
+        }
+
+        // Choose the desired track for each track type:
+        for(u_int8_t trackType = 0x01; trackType != MATROSKA_TRACK_TYPE_OTHER; trackType <<= 1) {
+            int bestNum         = -1;
+            int bestChoiceFlags = -1;
+            for(unsigned i = 0; i < numEnabledTracks; ++i) {
+                if(trackChoice[i].trackType == trackType && (int)trackChoice[i].choiceFlags > bestChoiceFlags) {
+                    bestNum         = i;
+                    bestChoiceFlags = (int)trackChoice[i].choiceFlags;
+                }
+            }
+            if(bestChoiceFlags >= 0) {  // There is a track for this track type
+                if(trackType == MATROSKA_TRACK_TYPE_VIDEO)
+                    fChosenVideoTrackNumber = trackChoice[bestNum].trackNumber;
+                else if(trackType == MATROSKA_TRACK_TYPE_AUDIO)
+                    fChosenAudioTrackNumber = trackChoice[bestNum].trackNumber;
+                else
+                    fChosenSubtitleTrackNumber = trackChoice[bestNum].trackNumber;
+            }
+        }
+
+        delete[] trackChoice;
+    }
+
+#ifdef DEBUG
+    if(fChosenVideoTrackNumber > 0)
+        fprintf(stderr, "Chosen video track: #%d\n", fChosenVideoTrackNumber);
+    else
+        fprintf(stderr, "No chosen video track\n");
+    if(fChosenAudioTrackNumber > 0)
+        fprintf(stderr, "Chosen audio track: #%d\n", fChosenAudioTrackNumber);
+    else
+        fprintf(stderr, "No chosen audio track\n");
+    if(fChosenSubtitleTrackNumber > 0)
+        fprintf(stderr, "Chosen subtitle track: #%d\n", fChosenSubtitleTrackNumber);
+    else
+        fprintf(stderr, "No chosen subtitle track\n");
+#endif
+
+    // Delete our parser, because it's done its job now:
+    delete fParserForInitialization;
+    fParserForInitialization = NULL;
+
+    // Finally, signal our caller that we've been created and initialized:
+    if(fOnCreation != NULL)
+        (*fOnCreation)(this, fOnCreationClientData);
+}
+
+MatroskaTrack *MatroskaFile::lookup(unsigned trackNumber) const {
+    return fTrackTable->lookup(trackNumber);
+}
+
+MatroskaDemux *MatroskaFile ::newDemux(MatroskaDemuxOnDeletionFunc *onDeletionFunc, void *objectToNotify) {
+    MatroskaDemux *demux = new MatroskaDemux(*this);
+
+    DemuxRecord *demuxRecord    = new DemuxRecord();
+    demuxRecord->demux          = demux;
+    demuxRecord->onDeletionFunc = onDeletionFunc;
+    demuxRecord->objectToNotify = objectToNotify;
+
+    fDemuxesTable->Add((char const *)demux, demuxRecord);
+
+    return demux;
+}
+
+void MatroskaFile::removeDemux(MatroskaDemux *demux) {
+    DemuxRecord *demuxRecord = (DemuxRecord *)(fDemuxesTable->Lookup((char const *)demux));
+    if(demuxRecord != NULL) {
+        fDemuxesTable->Remove((char const *)demux);
+
+        if(demuxRecord->onDeletionFunc != NULL) {
+            (*demuxRecord->onDeletionFunc)(demuxRecord->objectToNotify, demux);
+        }
+        delete demuxRecord;
+    }
+}
+
+#define getPrivByte(b) \
+    if(n == 0)         \
+        break;         \
+    else               \
+        do {           \
+            b = *p++;  \
+            --n;       \
+        } while(0) /* Vorbis/Theora configuration header parsing */
+#define CHECK_PTR    \
+    if(ptr >= limit) \
+    break /* H.264/H.265 parsing */
+#define NUM_BYTES_REMAINING (unsigned)(limit - ptr) /* H.264/H.265 parsing */
+
+void MatroskaFile::getH264ConfigData(MatroskaTrack const *track, u_int8_t *&sps, unsigned &spsSize, u_int8_t *&pps, unsigned &ppsSize) {
+    sps = pps = NULL;
+    spsSize = ppsSize = 0;
+
+    do {
+        if(track == NULL)
+            break;
+
+        // Use our track's 'Codec Private' data: Bytes 5 and beyond contain SPS and PPSs:
+        if(track->codecPrivateSize < 6)
+            break;
+        u_int8_t *SPSandPPSBytes    = &track->codecPrivate[5];
+        unsigned  numSPSandPPSBytes = track->codecPrivateSize - 5;
+
+        // Extract, from "SPSandPPSBytes", one SPS NAL unit, and one PPS NAL unit.
+        // (I hope one is all we need of each.)
+        unsigned  i;
+        u_int8_t *ptr   = SPSandPPSBytes;
+        u_int8_t *limit = &SPSandPPSBytes[numSPSandPPSBytes];
+
+        unsigned numSPSs = (*ptr++) & 0x1F;
+        CHECK_PTR;
+        for(i = 0; i < numSPSs; ++i) {
+            unsigned spsSize1 = (*ptr++) << 8;
+            CHECK_PTR;
+            spsSize1 |= *ptr++;
+            CHECK_PTR;
+
+            if(spsSize1 > NUM_BYTES_REMAINING)
+                break;
+            u_int8_t nal_unit_type = ptr[0] & 0x1F;
+            if(sps == NULL && nal_unit_type == 7 /*sanity check*/) {  // save the first one
+                spsSize = spsSize1;
+                sps     = new u_int8_t[spsSize];
+                memmove(sps, ptr, spsSize);
+            }
+            ptr += spsSize1;
+        }
+
+        unsigned numPPSs = (*ptr++) & 0x1F;
+        CHECK_PTR;
+        for(i = 0; i < numPPSs; ++i) {
+            unsigned ppsSize1 = (*ptr++) << 8;
+            CHECK_PTR;
+            ppsSize1 |= *ptr++;
+            CHECK_PTR;
+
+            if(ppsSize1 > NUM_BYTES_REMAINING)
+                break;
+            u_int8_t nal_unit_type = ptr[0] & 0x1F;
+            if(pps == NULL && nal_unit_type == 8 /*sanity check*/) {  // save the first one
+                ppsSize = ppsSize1;
+                pps     = new u_int8_t[ppsSize];
+                memmove(pps, ptr, ppsSize);
+            }
+            ptr += ppsSize1;
+        }
+
+        return;
+    } while(0);
+
+    // An error occurred:
+    delete[] sps;
+    sps     = NULL;
+    spsSize = 0;
+    delete[] pps;
+    pps     = NULL;
+    ppsSize = 0;
+}
+
+void MatroskaFile::getH265ConfigData(MatroskaTrack const *track, u_int8_t *&vps, unsigned &vpsSize, u_int8_t *&sps, unsigned &spsSize, u_int8_t *&pps,
+                                     unsigned &ppsSize) {
+    vps = sps = pps = NULL;
+    vpsSize = spsSize = ppsSize = 0;
+
+    do {
+        if(track == NULL)
+            break;
+
+        u_int8_t *VPS_SPS_PPSBytes    = NULL;
+        unsigned  numVPS_SPS_PPSBytes = 0;
+        unsigned  i;
+
+        if(track->codecPrivateUsesH264FormatForH265) {
+            // The data uses the H.264-style format (but including VPS NAL unit(s)).
+            // The VPS,SPS,PPS NAL unit information starts at byte #5:
+            if(track->codecPrivateSize >= 6) {
+                numVPS_SPS_PPSBytes = track->codecPrivateSize - 5;
+                VPS_SPS_PPSBytes    = &track->codecPrivate[5];
+            }
+        }
+        else {
+            // The data uses the proper H.265-style format.
+            // The VPS,SPS,PPS NAL unit information starts at byte #22:
+            if(track->codecPrivateSize >= 23) {
+                numVPS_SPS_PPSBytes = track->codecPrivateSize - 22;
+                VPS_SPS_PPSBytes    = &track->codecPrivate[22];
+            }
+        }
+        if(VPS_SPS_PPSBytes == NULL)
+            break;  // no VPS,SPS,PPS NAL unit information was present
+
+        // Extract, from "VPS_SPS_PPSBytes", one VPS NAL unit, one SPS NAL unit, and one PPS NAL unit.
+        // (I hope one is all we need of each.)
+        u_int8_t *ptr   = VPS_SPS_PPSBytes;
+        u_int8_t *limit = &VPS_SPS_PPSBytes[numVPS_SPS_PPSBytes];
+
+        if(track->codecPrivateUsesH264FormatForH265) {
+            // The data uses the H.264-style format (but including VPS NAL unit(s)).
+            while(NUM_BYTES_REMAINING > 0) {
+                unsigned numNALUnits = (*ptr++) & 0x1F;
+                CHECK_PTR;
+                for(i = 0; i < numNALUnits; ++i) {
+                    unsigned nalUnitLength = (*ptr++) << 8;
+                    CHECK_PTR;
+                    nalUnitLength |= *ptr++;
+                    CHECK_PTR;
+
+                    if(nalUnitLength > NUM_BYTES_REMAINING)
+                        break;
+                    u_int8_t nal_unit_type = (ptr[0] & 0x7E) >> 1;
+                    if(nal_unit_type == 32) {  // VPS
+                        vpsSize = nalUnitLength;
+                        delete[] vps;
+                        vps = new u_int8_t[nalUnitLength];
+                        memmove(vps, ptr, nalUnitLength);
+                    }
+                    else if(nal_unit_type == 33) {  // SPS
+                        spsSize = nalUnitLength;
+                        delete[] sps;
+                        sps = new u_int8_t[nalUnitLength];
+                        memmove(sps, ptr, nalUnitLength);
+                    }
+                    else if(nal_unit_type == 34) {  // PPS
+                        ppsSize = nalUnitLength;
+                        delete[] pps;
+                        pps = new u_int8_t[nalUnitLength];
+                        memmove(pps, ptr, nalUnitLength);
+                    }
+                    ptr += nalUnitLength;
+                }
+            }
+        }
+        else {
+            // The data uses the proper H.265-style format.
+            unsigned numOfArrays = *ptr++;
+            CHECK_PTR;
+            for(unsigned j = 0; j < numOfArrays; ++j) {
+                ++ptr;
+                CHECK_PTR;  // skip the 'array_completeness'|'reserved'|'NAL_unit_type' byte
+
+                unsigned numNalus = (*ptr++) << 8;
+                CHECK_PTR;
+                numNalus |= *ptr++;
+                CHECK_PTR;
+
+                for(i = 0; i < numNalus; ++i) {
+                    unsigned nalUnitLength = (*ptr++) << 8;
+                    CHECK_PTR;
+                    nalUnitLength |= *ptr++;
+                    CHECK_PTR;
+
+                    if(nalUnitLength > NUM_BYTES_REMAINING)
+                        break;
+                    u_int8_t nal_unit_type = (ptr[0] & 0x7E) >> 1;
+                    if(nal_unit_type == 32) {  // VPS
+                        vpsSize = nalUnitLength;
+                        delete[] vps;
+                        vps = new u_int8_t[nalUnitLength];
+                        memmove(vps, ptr, nalUnitLength);
+                    }
+                    else if(nal_unit_type == 33) {  // SPS
+                        spsSize = nalUnitLength;
+                        delete[] sps;
+                        sps = new u_int8_t[nalUnitLength];
+                        memmove(sps, ptr, nalUnitLength);
+                    }
+                    else if(nal_unit_type == 34) {  // PPS
+                        ppsSize = nalUnitLength;
+                        delete[] pps;
+                        pps = new u_int8_t[nalUnitLength];
+                        memmove(pps, ptr, nalUnitLength);
+                    }
+                    ptr += nalUnitLength;
+                }
+            }
+        }
+
+        return;
+    } while(0);
+
+    // An error occurred:
+    delete[] vps;
+    vps     = NULL;
+    vpsSize = 0;
+    delete[] sps;
+    sps     = NULL;
+    spsSize = 0;
+    delete[] pps;
+    pps     = NULL;
+    ppsSize = 0;
+}
+
+void MatroskaFile ::getVorbisOrTheoraConfigData(MatroskaTrack const *track, u_int8_t *&identificationHeader, unsigned &identificationHeaderSize,
+                                                u_int8_t *&commentHeader, unsigned &commentHeaderSize, u_int8_t *&setupHeader, unsigned &setupHeaderSize) {
+    identificationHeader = commentHeader = setupHeader = NULL;
+    identificationHeaderSize = commentHeaderSize = setupHeaderSize = 0;
+
+    do {
+        if(track == NULL)
+            break;
+
+        // The Matroska file's 'Codec Private' data is assumed to be the codec configuration
+        // information, containing the "Identification", "Comment", and "Setup" headers.
+        // Extract these headers now:
+        Boolean   isTheora = strcmp(track->mimeType, "video/THEORA") == 0;  // otherwise, Vorbis
+        u_int8_t *p        = track->codecPrivate;
+        unsigned  n        = track->codecPrivateSize;
+        if(n == 0 || p == NULL)
+            break;  // we have no 'Codec Private' data
+
+        u_int8_t numHeaders;
+        getPrivByte(numHeaders);
+        unsigned headerSize[3];  // we don't handle any more than 2+1 headers
+
+        // Extract the sizes of each of these headers:
+        unsigned sizesSum = 0;
+        Boolean  success  = True;
+        unsigned i;
+        for(i = 0; i < numHeaders && i < 3; ++i) {
+            unsigned len = 0;
+            u_int8_t c;
+
+            do {
+                success = False;
+                getPrivByte(c);
+                success = True;
+
+                len += c;
+            } while(c == 255);
+            if(!success || len == 0)
+                break;
+
+            headerSize[i] = len;
+            sizesSum += len;
+        }
+        if(!success)
+            break;
+
+        // Compute the implicit size of the final header:
+        if(numHeaders < 3) {
+            int finalHeaderSize = n - sizesSum;
+            if(finalHeaderSize <= 0)
+                break;  // error in data; give up
+
+            headerSize[numHeaders] = (unsigned)finalHeaderSize;
+            ++numHeaders;  // include the final header now
+        }
+        else {
+            numHeaders = 3;  // The maximum number of headers that we handle
+        }
+
+        // Then, extract and classify each header:
+        for(i = 0; i < numHeaders; ++i) {
+            success                 = False;
+            unsigned  newHeaderSize = headerSize[i];
+            u_int8_t *newHeader     = new u_int8_t[newHeaderSize];
+            if(newHeader == NULL)
+                break;
+
+            u_int8_t *hdr = newHeader;
+            while(newHeaderSize-- > 0) {
+                success = False;
+                getPrivByte(*hdr++);
+                success = True;
+            }
+            if(!success) {
+                delete[] newHeader;
+                break;
+            }
+
+            u_int8_t headerType = newHeader[0];
+            if(headerType == 1 || (isTheora && headerType == 0x80)) {  // "identification" header
+                delete[] identificationHeader;
+                identificationHeader     = newHeader;
+                identificationHeaderSize = headerSize[i];
+            }
+            else if(headerType == 3 || (isTheora && headerType == 0x81)) {  // "comment" header
+                delete[] commentHeader;
+                commentHeader     = newHeader;
+                commentHeaderSize = headerSize[i];
+            }
+            else if(headerType == 5 || (isTheora && headerType == 0x82)) {  // "setup" header
+                delete[] setupHeader;
+                setupHeader     = newHeader;
+                setupHeaderSize = headerSize[i];
+            }
+            else {
+                delete[] newHeader;  // because it was a header type that we don't understand
+            }
+        }
+        if(!success)
+            break;
+
+        return;
+    } while(0);
+
+    // An error occurred:
+    delete[] identificationHeader;
+    identificationHeader     = NULL;
+    identificationHeaderSize = 0;
+    delete[] commentHeader;
+    commentHeader     = NULL;
+    commentHeaderSize = 0;
+    delete[] setupHeader;
+    setupHeader     = NULL;
+    setupHeaderSize = 0;
+}
+
+float MatroskaFile::fileDuration() {
+    if(fCuePoints == NULL)
+        return 0.0;  // Hack, because the RTSP server code assumes that duration > 0 => seekable. (fix this) #####
+
+    return segmentDuration() * (timecodeScale() / 1000000000.0f);
+}
+
+// The size of the largest key frame that we expect.  This determines our buffer sizes:
+#define MAX_KEY_FRAME_SIZE 300000
+
+FramedSource *MatroskaFile ::createSourceForStreaming(FramedSource *baseSource, unsigned trackNumber, unsigned &estBitrate,
+                                                      unsigned &numFiltersInFrontOfTrack) {
+    if(baseSource == NULL)
+        return NULL;
+
+    FramedSource *result     = baseSource;  // by default
+    estBitrate               = 100;         // by default
+    numFiltersInFrontOfTrack = 0;           // by default
+
+    // Look at the track's MIME type to set its estimated bitrate (for use by RTCP).
+    // (Later, try to be smarter about figuring out the bitrate.) #####
+    // Some MIME types also require adding a special 'framer' in front of the source.
+    MatroskaTrack *track = lookup(trackNumber);
+    if(track != NULL) {  // should always be true
+        if(strcmp(track->mimeType, "audio/MPEG") == 0) {
+            estBitrate = 128;
+        }
+        else if(strcmp(track->mimeType, "audio/AAC") == 0) {
+            estBitrate = 96;
+        }
+        else if(strcmp(track->mimeType, "audio/AC3") == 0) {
+            estBitrate = 48;
+        }
+        else if(strcmp(track->mimeType, "audio/VORBIS") == 0) {
+            estBitrate = 96;
+        }
+        else if(strcmp(track->mimeType, "video/H264") == 0) {
+            estBitrate = 500;
+            // Allow for the possibility of very large NAL units being fed to the sink object:
+            OutPacketBuffer::increaseMaxSizeTo(MAX_KEY_FRAME_SIZE);  // bytes
+
+            // Add a framer in front of the source:
+            result = H264VideoStreamDiscreteFramer::createNew(envir(), result);
+            ++numFiltersInFrontOfTrack;
+        }
+        else if(strcmp(track->mimeType, "video/H265") == 0) {
+            estBitrate = 500;
+            // Allow for the possibility of very large NAL units being fed to the sink object:
+            OutPacketBuffer::increaseMaxSizeTo(MAX_KEY_FRAME_SIZE);  // bytes
+
+            // Add a framer in front of the source:
+            result = H265VideoStreamDiscreteFramer::createNew(envir(), result);
+            ++numFiltersInFrontOfTrack;
+        }
+        else if(strcmp(track->mimeType, "video/VP8") == 0) {
+            estBitrate = 500;
+        }
+        else if(strcmp(track->mimeType, "video/VP9") == 0) {
+            estBitrate = 500;
+        }
+        else if(strcmp(track->mimeType, "video/THEORA") == 0) {
+            estBitrate = 500;
+        }
+        else if(strcmp(track->mimeType, "text/T140") == 0) {
+            estBitrate = 48;
+        }
+    }
+
+    return result;
+}
+
+char const *MatroskaFile::trackMIMEType(unsigned trackNumber) const {
+    MatroskaTrack *track = lookup(trackNumber);
+    if(track == NULL)
+        return NULL;
+
+    return track->mimeType;
+}
+
+RTPSink *MatroskaFile ::createRTPSinkForTrackNumber(unsigned trackNumber, Groupsock *rtpGroupsock, unsigned char rtpPayloadTypeIfDynamic) {
+    RTPSink *result = NULL;  // default value, if an error occurs
+
+    do {
+        MatroskaTrack *track = lookup(trackNumber);
+        if(track == NULL)
+            break;
+
+        if(strcmp(track->mimeType, "audio/L16") == 0) {
+            result = SimpleRTPSink::createNew(envir(), rtpGroupsock, rtpPayloadTypeIfDynamic, track->samplingFrequency, "audio", "L16", track->numChannels);
+        }
+        else if(strcmp(track->mimeType, "audio/MPEG") == 0) {
+            result = MPEG1or2AudioRTPSink::createNew(envir(), rtpGroupsock);
+        }
+        else if(strcmp(track->mimeType, "audio/AAC") == 0) {
+            // The Matroska file's 'Codec Private' data is assumed to be the AAC configuration
+            // information.  Use this to generate a hexadecimal 'config' string for the new RTP sink:
+            char *configStr = new char[2 * track->codecPrivateSize + 1];
+            if(configStr == NULL)
+                break;
+            // 2 hex digits per byte, plus the trailing '\0'
+            for(unsigned i = 0; i < track->codecPrivateSize; ++i) {
+                sprintf(&configStr[2 * i], "%02X", track->codecPrivate[i]);
+            }
+
+            result = MPEG4GenericRTPSink::createNew(envir(), rtpGroupsock, rtpPayloadTypeIfDynamic, track->samplingFrequency, "audio", "AAC-hbr", configStr,
+                                                    track->numChannels);
+            delete[] configStr;
+        }
+        else if(strcmp(track->mimeType, "audio/AC3") == 0) {
+            result = AC3AudioRTPSink ::createNew(envir(), rtpGroupsock, rtpPayloadTypeIfDynamic, track->samplingFrequency);
+        }
+        else if(strcmp(track->mimeType, "audio/OPUS") == 0) {
+            result = SimpleRTPSink ::createNew(envir(), rtpGroupsock, rtpPayloadTypeIfDynamic, 48000, "audio", "OPUS", 2,
+                                               False /*only 1 Opus 'packet' in each RTP packet*/);
+        }
+        else if(strcmp(track->mimeType, "audio/VORBIS") == 0 || strcmp(track->mimeType, "video/THEORA") == 0) {
+            u_int8_t *identificationHeader;
+            unsigned  identificationHeaderSize;
+            u_int8_t *commentHeader;
+            unsigned  commentHeaderSize;
+            u_int8_t *setupHeader;
+            unsigned  setupHeaderSize;
+            getVorbisOrTheoraConfigData(track, identificationHeader, identificationHeaderSize, commentHeader, commentHeaderSize, setupHeader, setupHeaderSize);
+
+            if(strcmp(track->mimeType, "video/THEORA") == 0) {
+                result = TheoraVideoRTPSink ::createNew(envir(), rtpGroupsock, rtpPayloadTypeIfDynamic, identificationHeader, identificationHeaderSize,
+                                                        commentHeader, commentHeaderSize, setupHeader, setupHeaderSize);
+            }
+            else {  // Vorbis
+                result = VorbisAudioRTPSink ::createNew(envir(), rtpGroupsock, rtpPayloadTypeIfDynamic, track->samplingFrequency, track->numChannels,
+                                                        identificationHeader, identificationHeaderSize, commentHeader, commentHeaderSize, setupHeader,
+                                                        setupHeaderSize);
+            }
+            delete[] identificationHeader;
+            delete[] commentHeader;
+            delete[] setupHeader;
+        }
+        else if(strcmp(track->mimeType, "video/RAW") == 0) {
+            result = RawVideoRTPSink::createNew(envir(), rtpGroupsock, rtpPayloadTypeIfDynamic, track->pixelWidth, track->pixelHeight, track->bitDepth,
+                                                track->colorSampling, track->colorimetry);
+        }
+        else if(strcmp(track->mimeType, "video/H264") == 0) {
+            u_int8_t *sps;
+            unsigned  spsSize;
+            u_int8_t *pps;
+            unsigned  ppsSize;
+
+            getH264ConfigData(track, sps, spsSize, pps, ppsSize);
+            result = H264VideoRTPSink::createNew(envir(), rtpGroupsock, rtpPayloadTypeIfDynamic, sps, spsSize, pps, ppsSize);
+            delete[] sps;
+            delete[] pps;
+        }
+        else if(strcmp(track->mimeType, "video/H265") == 0) {
+            u_int8_t *vps;
+            unsigned  vpsSize;
+            u_int8_t *sps;
+            unsigned  spsSize;
+            u_int8_t *pps;
+            unsigned  ppsSize;
+
+            getH265ConfigData(track, vps, vpsSize, sps, spsSize, pps, ppsSize);
+            result = H265VideoRTPSink::createNew(envir(), rtpGroupsock, rtpPayloadTypeIfDynamic, vps, vpsSize, sps, spsSize, pps, ppsSize);
+            delete[] vps;
+            delete[] sps;
+            delete[] pps;
+        }
+        else if(strcmp(track->mimeType, "video/VP8") == 0) {
+            result = VP8VideoRTPSink::createNew(envir(), rtpGroupsock, rtpPayloadTypeIfDynamic);
+        }
+        else if(strcmp(track->mimeType, "video/VP9") == 0) {
+            result = VP9VideoRTPSink::createNew(envir(), rtpGroupsock, rtpPayloadTypeIfDynamic);
+        }
+        else if(strcmp(track->mimeType, "text/T140") == 0) {
+            result = T140TextRTPSink::createNew(envir(), rtpGroupsock, rtpPayloadTypeIfDynamic);
+        }
+    } while(0);
+
+    return result;
+}
+
+FileSink *MatroskaFile::createFileSinkForTrackNumber(unsigned trackNumber, char const *fileName) {
+    FileSink *result            = NULL;   // default value, if an error occurs
+    Boolean   createOggFileSink = False;  // by default
+
+    do {
+        MatroskaTrack *track = lookup(trackNumber);
+        if(track == NULL)
+            break;
+
+        if(strcmp(track->mimeType, "video/H264") == 0) {
+            u_int8_t *sps;
+            unsigned  spsSize;
+            u_int8_t *pps;
+            unsigned  ppsSize;
+
+            getH264ConfigData(track, sps, spsSize, pps, ppsSize);
+
+            char *sps_base64 = base64Encode((char *)sps, spsSize);
+            char *pps_base64 = base64Encode((char *)pps, ppsSize);
+            delete[] sps;
+            delete[] pps;
+
+            char *sPropParameterSetsStr =
+                new char[(sps_base64 == NULL ? 0 : strlen(sps_base64)) + (pps_base64 == NULL ? 0 : strlen(pps_base64)) + 10 /*more than enough space*/];
+            sprintf(sPropParameterSetsStr, "%s,%s", sps_base64, pps_base64);
+            delete[] sps_base64;
+            delete[] pps_base64;
+
+            result = H264VideoFileSink::createNew(envir(), fileName, sPropParameterSetsStr,
+                                                  MAX_KEY_FRAME_SIZE);  // extra large buffer size for large key frames
+            delete[] sPropParameterSetsStr;
+        }
+        else if(strcmp(track->mimeType, "video/H265") == 0) {
+            u_int8_t *vps;
+            unsigned  vpsSize;
+            u_int8_t *sps;
+            unsigned  spsSize;
+            u_int8_t *pps;
+            unsigned  ppsSize;
+
+            getH265ConfigData(track, vps, vpsSize, sps, spsSize, pps, ppsSize);
+
+            char *vps_base64 = base64Encode((char *)vps, vpsSize);
+            char *sps_base64 = base64Encode((char *)sps, spsSize);
+            char *pps_base64 = base64Encode((char *)pps, ppsSize);
+            delete[] vps;
+            delete[] sps;
+            delete[] pps;
+
+            result = H265VideoFileSink::createNew(envir(), fileName, vps_base64, sps_base64, pps_base64,
+                                                  MAX_KEY_FRAME_SIZE);  // extra large buffer size for large key frames
+            delete[] vps_base64;
+            delete[] sps_base64;
+            delete[] pps_base64;
+        }
+        else if(strcmp(track->mimeType, "video/THEORA") == 0) {
+            createOggFileSink = True;
+        }
+        else if(strcmp(track->mimeType, "audio/AMR") == 0 || strcmp(track->mimeType, "audio/AMR-WB") == 0) {
+            // For AMR audio streams, we use a special sink that inserts AMR frame hdrs:
+            result = AMRAudioFileSink::createNew(envir(), fileName);
+        }
+        else if(strcmp(track->mimeType, "audio/VORBIS") == 0 || strcmp(track->mimeType, "audio/OPUS") == 0) {
+            createOggFileSink = True;
+        }
+
+        if(createOggFileSink) {
+            char *configStr = NULL;  // by default
+
+            if(strcmp(track->mimeType, "audio/VORBIS") == 0 || strcmp(track->mimeType, "video/THEORA") == 0) {
+                u_int8_t *identificationHeader;
+                unsigned  identificationHeaderSize;
+                u_int8_t *commentHeader;
+                unsigned  commentHeaderSize;
+                u_int8_t *setupHeader;
+                unsigned  setupHeaderSize;
+                getVorbisOrTheoraConfigData(track, identificationHeader, identificationHeaderSize, commentHeader, commentHeaderSize, setupHeader,
+                                            setupHeaderSize);
+                u_int32_t identField = 0xFACADE;  // Can we get a real value from the file somehow?
+                configStr = generateVorbisOrTheoraConfigStr(identificationHeader, identificationHeaderSize, commentHeader, commentHeaderSize, setupHeader,
+                                                            setupHeaderSize, identField);
+                delete[] identificationHeader;
+                delete[] commentHeader;
+                delete[] setupHeader;
+            }
+
+            result = OggFileSink::createNew(envir(), fileName, track->samplingFrequency, configStr, MAX_KEY_FRAME_SIZE);
+            delete[] configStr;
+        }
+        else if(result == NULL) {
+            // By default, just create a regular "FileSink":
+            result = FileSink::createNew(envir(), fileName, MAX_KEY_FRAME_SIZE);
+        }
+    } while(0);
+
+    return result;
+}
+
+void MatroskaFile::addTrack(MatroskaTrack *newTrack, unsigned trackNumber) {
+    fTrackTable->add(newTrack, trackNumber);
+}
+
+void MatroskaFile::addCuePoint(double cueTime, u_int64_t clusterOffsetInFile, unsigned blockNumWithinCluster) {
+    Boolean dummy = False;  // not used
+    CuePoint::addCuePoint(fCuePoints, cueTime, clusterOffsetInFile, blockNumWithinCluster, dummy);
+}
+
+Boolean MatroskaFile::lookupCuePoint(double &cueTime, u_int64_t &resultClusterOffsetInFile, unsigned &resultBlockNumWithinCluster) {
+    if(fCuePoints == NULL)
+        return False;
+
+    (void)fCuePoints->lookup(cueTime, resultClusterOffsetInFile, resultBlockNumWithinCluster);
+    return True;
+}
+
+void MatroskaFile::printCuePoints(FILE *fid) {
+    CuePoint::fprintf(fid, fCuePoints);
+}
+
+////////// MatroskaTrackTable implementation //////////
+
+MatroskaTrackTable::MatroskaTrackTable() : fTable(HashTable::create(ONE_WORD_HASH_KEYS)) {}
+
+MatroskaTrackTable::~MatroskaTrackTable() {
+    // Remove and delete all of our "MatroskaTrack" descriptors, and the hash table itself:
+    MatroskaTrack *track;
+    while((track = (MatroskaTrack *)fTable->RemoveNext()) != NULL) {
+        delete track;
+    }
+    delete fTable;
+}
+
+void MatroskaTrackTable::add(MatroskaTrack *newTrack, unsigned trackNumber) {
+    if(newTrack != NULL && newTrack->trackNumber != 0)
+        fTable->Remove((char const *)newTrack->trackNumber);
+    MatroskaTrack *existingTrack = (MatroskaTrack *)fTable->Add((char const *)trackNumber, newTrack);
+    delete existingTrack;  // in case it wasn't NULL
+}
+
+MatroskaTrack *MatroskaTrackTable::lookup(unsigned trackNumber) {
+    return (MatroskaTrack *)fTable->Lookup((char const *)trackNumber);
+}
+
+unsigned MatroskaTrackTable::numTracks() const {
+    return fTable->numEntries();
+}
+
+MatroskaTrackTable::Iterator::Iterator(MatroskaTrackTable &ourTable) {
+    fIter = HashTable::Iterator::create(*(ourTable.fTable));
+}
+
+MatroskaTrackTable::Iterator::~Iterator() {
+    delete fIter;
+}
+
+MatroskaTrack *MatroskaTrackTable::Iterator::next() {
+    char const *key;
+    return (MatroskaTrack *)fIter->next(key);
+}
+
+////////// MatroskaTrack implementation //////////
+
+MatroskaTrack::MatroskaTrack()
+    : trackNumber(0 /*not set*/),
+      trackType(0 /*unknown*/),
+      isEnabled(True),
+      isDefault(True),
+      isForced(False),
+      defaultDuration(0),
+      name(NULL),
+      language(NULL),
+      codecID(NULL),
+      samplingFrequency(0),
+      numChannels(2),
+      mimeType(""),
+      codecPrivateSize(0),
+      codecPrivate(NULL),
+      codecPrivateUsesH264FormatForH265(False),
+      codecIsOpus(False),
+      headerStrippedBytesSize(0),
+      headerStrippedBytes(NULL),
+      colorSampling(""),
+      colorimetry("BT709-2") /*Matroska default value for Primaries */,
+      pixelWidth(0),
+      pixelHeight(0),
+      bitDepth(8),
+      subframeSizeSize(0) {}
+
+MatroskaTrack::~MatroskaTrack() {
+    delete[] name;
+    delete[] language;
+    delete[] codecID;
+    delete[] codecPrivate;
+    delete[] headerStrippedBytes;
+}
+
+////////// MatroskaDemux implementation //////////
+
+MatroskaDemux::MatroskaDemux(MatroskaFile &ourFile)
+    : Medium(ourFile.envir()), fOurFile(ourFile), fDemuxedTracksTable(HashTable::create(ONE_WORD_HASH_KEYS)), fNextTrackTypeToCheck(0x1) {
+    fOurParser = new MatroskaFileParser(ourFile, ByteStreamFileSource::createNew(envir(), ourFile.fileName()), handleEndOfFile, this, this);
+}
+
+MatroskaDemux::~MatroskaDemux() {
+    // Begin by acting as if we've reached the end of the source file.  This should cause all of our demuxed tracks to get closed.
+    handleEndOfFile();
+
+    // Then delete our table of "MatroskaDemuxedTrack"s
+    // - but not the "MatroskaDemuxedTrack"s themselves; that should have already happened:
+    delete fDemuxedTracksTable;
+
+    delete fOurParser;
+    fOurFile.removeDemux(this);
+}
+
+FramedSource *MatroskaDemux::newDemuxedTrack() {
+    unsigned dummyResultTrackNumber;
+    return newDemuxedTrack(dummyResultTrackNumber);
+}
+
+FramedSource *MatroskaDemux::newDemuxedTrack(unsigned &resultTrackNumber) {
+    FramedSource *result;
+    resultTrackNumber = 0;
+
+    for(result = NULL; result == NULL && fNextTrackTypeToCheck != MATROSKA_TRACK_TYPE_OTHER; fNextTrackTypeToCheck <<= 1) {
+        if(fNextTrackTypeToCheck == MATROSKA_TRACK_TYPE_VIDEO)
+            resultTrackNumber = fOurFile.chosenVideoTrackNumber();
+        else if(fNextTrackTypeToCheck == MATROSKA_TRACK_TYPE_AUDIO)
+            resultTrackNumber = fOurFile.chosenAudioTrackNumber();
+        else if(fNextTrackTypeToCheck == MATROSKA_TRACK_TYPE_SUBTITLE)
+            resultTrackNumber = fOurFile.chosenSubtitleTrackNumber();
+
+        result = newDemuxedTrackByTrackNumber(resultTrackNumber);
+    }
+
+    return result;
+}
+
+FramedSource *MatroskaDemux::newDemuxedTrackByTrackNumber(unsigned trackNumber) {
+    if(trackNumber == 0)
+        return NULL;
+
+    FramedSource *trackSource = new MatroskaDemuxedTrack(envir(), trackNumber, *this);
+    fDemuxedTracksTable->Add((char const *)trackNumber, trackSource);
+    return trackSource;
+}
+
+MatroskaDemuxedTrack *MatroskaDemux::lookupDemuxedTrack(unsigned trackNumber) {
+    return (MatroskaDemuxedTrack *)fDemuxedTracksTable->Lookup((char const *)trackNumber);
+}
+
+void MatroskaDemux::removeTrack(unsigned trackNumber) {
+    fDemuxedTracksTable->Remove((char const *)trackNumber);
+    if(fDemuxedTracksTable->numEntries() == 0) {
+        // We no longer have any demuxed tracks, so delete ourselves now:
+        Medium::close(this);
+    }
+}
+
+void MatroskaDemux::continueReading() {
+    fOurParser->continueParsing();
+}
+
+void MatroskaDemux::seekToTime(double &seekNPT) {
+    if(fOurParser != NULL)
+        fOurParser->seekToTime(seekNPT);
+}
+
+void MatroskaDemux::pause() {
+    if(fOurParser != NULL)
+        fOurParser->pause();
+}
+
+void MatroskaDemux::handleEndOfFile(void *clientData) {
+    ((MatroskaDemux *)clientData)->handleEndOfFile();
+}
+
+void MatroskaDemux::handleEndOfFile() {
+    // Iterate through all of our 'demuxed tracks', handling 'end of input' on each one.
+    // Hack: Because this can cause the hash table to get modified underneath us, we don't call the handlers until after we've
+    // first iterated through all of the tracks.
+    unsigned numTracks = fDemuxedTracksTable->numEntries();
+    if(numTracks == 0)
+        return;
+    MatroskaDemuxedTrack **tracks = new MatroskaDemuxedTrack *[numTracks];
+
+    HashTable::Iterator *iter = HashTable::Iterator::create(*fDemuxedTracksTable);
+    unsigned             i;
+    char const *         trackNumber;
+
+    for(i = 0; i < numTracks; ++i) {
+        tracks[i] = (MatroskaDemuxedTrack *)iter->next(trackNumber);
+    }
+    delete iter;
+
+    for(i = 0; i < numTracks; ++i) {
+        if(tracks[i] == NULL)
+            continue;  // sanity check; shouldn't happen
+        tracks[i]->handleClosure();
+    }
+
+    delete[] tracks;
+}
+
+void MatroskaDemux::resetState() {
+    // Iterate through all of our 'demuxed tracks', calling 'reset()' on each one.
+    HashTable::Iterator * iter = HashTable::Iterator::create(*fDemuxedTracksTable);
+    MatroskaDemuxedTrack *demuxedTrack;
+    char const *          trackNumber;
+
+    while((demuxedTrack = (MatroskaDemuxedTrack *)iter->next(trackNumber)) != NULL) {
+        demuxedTrack->reset();
+    }
+    delete iter;
+}
+
+////////// CuePoint implementation //////////
+
+CuePoint::CuePoint(double cueTime, u_int64_t clusterOffsetInFile, unsigned blockNumWithinCluster)
+    : fBalance(0), fCueTime(cueTime), fClusterOffsetInFile(clusterOffsetInFile), fBlockNumWithinCluster(blockNumWithinCluster - 1) {
+    fSubTree[0] = fSubTree[1] = NULL;
+}
+
+CuePoint::~CuePoint() {
+    delete fSubTree[0];
+    delete fSubTree[1];
+}
+
+void CuePoint::addCuePoint(CuePoint *&root, double cueTime, u_int64_t clusterOffsetInFile, unsigned blockNumWithinCluster,
+                           Boolean &needToReviseBalanceOfParent) {
+    needToReviseBalanceOfParent = False;  // by default; may get changed below
+
+    if(root == NULL) {
+        root                        = new CuePoint(cueTime, clusterOffsetInFile, blockNumWithinCluster);
+        needToReviseBalanceOfParent = True;
+    }
+    else if(cueTime == root->fCueTime) {
+        // Replace existing data:
+        root->fClusterOffsetInFile   = clusterOffsetInFile;
+        root->fBlockNumWithinCluster = blockNumWithinCluster - 1;
+    }
+    else {
+        // Add to our left or right subtree:
+        int     direction              = cueTime > root->fCueTime;  // 0 (left) or 1 (right)
+        Boolean needToReviseOurBalance = False;
+        addCuePoint(root->fSubTree[direction], cueTime, clusterOffsetInFile, blockNumWithinCluster, needToReviseOurBalance);
+
+        if(needToReviseOurBalance) {
+            // We need to change our 'balance' number, perhaps while also performing a rotation to bring ourself back into balance:
+            if(root->fBalance == 0) {
+                // We were balanced before, but now we're unbalanced (by 1) on the "direction" side:
+                root->fBalance              = -1 + 2 * direction;  // -1 for "direction" 0; 1 for "direction" 1
+                needToReviseBalanceOfParent = True;
+            }
+            else if(root->fBalance == 1 - 2 * direction) {  // 1 for "direction" 0; -1 for "direction" 1
+                // We were unbalanced (by 1) on the side opposite to where we added an entry, so now we're balanced:
+                root->fBalance = 0;
+            }
+            else {
+                // We were unbalanced (by 1) on the side where we added an entry, so now we're unbalanced by 2, and have to rebalance:
+                if(root->fSubTree[direction]->fBalance == -1 + 2 * direction) {  // -1 for "direction" 0; 1 for "direction" 1
+                    // We're 'doubly-unbalanced' on this side, so perform a single rotation in the opposite direction:
+                    root->fBalance = root->fSubTree[direction]->fBalance = 0;
+                    rotate(1 - direction, root);
+                }
+                else {
+                    // This is the Left-Right case (for "direction" 0) or the Right-Left case (for "direction" 1); perform two rotations:
+                    char newParentCurBalance = root->fSubTree[direction]->fSubTree[1 - direction]->fBalance;
+                    if(newParentCurBalance == 1 - 2 * direction) {  // 1 for "direction" 0; -1 for "direction" 1
+                        root->fBalance                      = 0;
+                        root->fSubTree[direction]->fBalance = -1 + 2 * direction;  // -1 for "direction" 0; 1 for "direction" 1
+                    }
+                    else if(newParentCurBalance == 0) {
+                        root->fBalance                      = 0;
+                        root->fSubTree[direction]->fBalance = 0;
+                    }
+                    else {
+                        root->fBalance                      = 1 - 2 * direction;  // 1 for "direction" 0; -1 for "direction" 1
+                        root->fSubTree[direction]->fBalance = 0;
+                    }
+                    rotate(direction, root->fSubTree[direction]);
+
+                    root->fSubTree[direction]->fBalance = 0;  // the new root will be balanced
+                    rotate(1 - direction, root);
+                }
+            }
+        }
+    }
+}
+
+Boolean CuePoint::lookup(double &cueTime, u_int64_t &resultClusterOffsetInFile, unsigned &resultBlockNumWithinCluster) {
+    if(cueTime < fCueTime) {
+        if(left() == NULL) {
+            resultClusterOffsetInFile   = 0;
+            resultBlockNumWithinCluster = 0;
+            return False;
+        }
+        else {
+            return left()->lookup(cueTime, resultClusterOffsetInFile, resultBlockNumWithinCluster);
+        }
+    }
+    else {
+        if(right() == NULL || !right()->lookup(cueTime, resultClusterOffsetInFile, resultBlockNumWithinCluster)) {
+            // Use this record:
+            cueTime                     = fCueTime;
+            resultClusterOffsetInFile   = fClusterOffsetInFile;
+            resultBlockNumWithinCluster = fBlockNumWithinCluster;
+        }
+        return True;
+    }
+}
+
+void CuePoint::fprintf(FILE *fid, CuePoint *cuePoint) {
+    if(cuePoint != NULL) {
+        ::fprintf(fid, "[");
+        fprintf(fid, cuePoint->left());
+
+        ::fprintf(fid, ",%.1f{%d},", cuePoint->fCueTime, cuePoint->fBalance);
+
+        fprintf(fid, cuePoint->right());
+        ::fprintf(fid, "]");
+    }
+}
+
+void CuePoint::rotate(unsigned direction /*0 => left; 1 => right*/, CuePoint *&root) {
+    CuePoint *pivot               = root->fSubTree[1 - direction];  // ASSERT: pivot != NULL
+    root->fSubTree[1 - direction] = pivot->fSubTree[direction];
+    pivot->fSubTree[direction]    = root;
+    root                          = pivot;
+}
diff --git a/3rdparty/live555/src/liveMedia/MatroskaFileParser.cpp b/3rdparty/live555/src/liveMedia/MatroskaFileParser.cpp
new file mode 100644
index 00000000..194a503d
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/MatroskaFileParser.cpp
@@ -0,0 +1,1652 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A parser for a Matroska file.
+// Implementation
+
+#include "MatroskaFileParser.hh"
+#include "MatroskaDemuxedTrack.hh"
+#include <ByteStreamFileSource.hh>
+#include <GroupsockHelper.hh>  // for "gettimeofday()
+
+MatroskaFileParser::MatroskaFileParser(MatroskaFile &ourFile, FramedSource *inputSource, FramedSource::onCloseFunc *onEndFunc, void *onEndClientData,
+                                       MatroskaDemux *ourDemux)
+    : StreamParser(inputSource, onEndFunc, onEndClientData, continueParsing, this),
+      fOurFile(ourFile),
+      fInputSource(inputSource),
+      fOnEndFunc(onEndFunc),
+      fOnEndClientData(onEndClientData),
+      fOurDemux(ourDemux),
+      fCurOffsetInFile(0),
+      fSavedCurOffsetInFile(0),
+      fLimitOffsetInFile(0),
+      fNumHeaderBytesToSkip(0),
+      fClusterTimecode(0),
+      fBlockTimecode(0),
+      fFrameSizesWithinBlock(NULL),
+      fPresentationTimeOffset(0.0) {
+    if(ourDemux == NULL) {
+        // Initialization
+        fCurrentParseState = PARSING_START_OF_FILE;
+
+        continueParsing();
+    }
+    else {
+        fCurrentParseState = LOOKING_FOR_CLUSTER;
+        // In this case, parsing (of track data) doesn't start until a client starts reading from a track.
+    }
+}
+
+MatroskaFileParser::~MatroskaFileParser() {
+    delete[] fFrameSizesWithinBlock;
+    Medium::close(fInputSource);
+}
+
+void MatroskaFileParser::seekToTime(double &seekNPT) {
+#ifdef DEBUG
+    fprintf(stderr, "seekToTime(%f)\n", seekNPT);
+#endif
+    if(seekNPT <= 0.0) {
+#ifdef DEBUG
+        fprintf(stderr, "\t=> start of file\n");
+#endif
+        seekNPT = 0.0;
+        seekToFilePosition(0);
+    }
+    else if(seekNPT >= fOurFile.fileDuration()) {
+#ifdef DEBUG
+        fprintf(stderr, "\t=> end of file\n");
+#endif
+        seekNPT = fOurFile.fileDuration();
+        seekToEndOfFile();
+    }
+    else {
+        u_int64_t clusterOffsetInFile;
+        unsigned  blockNumWithinCluster;
+        if(!fOurFile.lookupCuePoint(seekNPT, clusterOffsetInFile, blockNumWithinCluster)) {
+#ifdef DEBUG
+            fprintf(stderr, "\t=> not supported\n");
+#endif
+            return;  // seeking not supported
+        }
+
+#ifdef DEBUG
+        fprintf(stderr, "\t=> seek time %f, file position %llu, block number within cluster %d\n", seekNPT, clusterOffsetInFile, blockNumWithinCluster);
+#endif
+        seekToFilePosition(clusterOffsetInFile);
+        fCurrentParseState = LOOKING_FOR_BLOCK;
+        // LATER handle "blockNumWithinCluster"; for now, we assume that it's 0 #####
+    }
+}
+
+void MatroskaFileParser::pause() {
+    resetPresentationTimes();
+    // to ensure that we presentation times continue from 'wall clock' time after we resume
+}
+
+void MatroskaFileParser ::continueParsing(void *clientData, unsigned char * /*ptr*/, unsigned /*size*/, struct timeval /*presentationTime*/) {
+    ((MatroskaFileParser *)clientData)->continueParsing();
+}
+
+void MatroskaFileParser::continueParsing() {
+    if(fInputSource != NULL) {
+        if(!parse()) {
+            // We didn't complete the parsing, because we had to read more data from the source, or because we're waiting for
+            // another read from downstream.  Once that happens, we'll get called again.
+            return;
+        }
+    }
+
+    // We successfully parsed the file.  Call our 'done' function now:
+    if(fOnEndFunc != NULL)
+        (*fOnEndFunc)(fOnEndClientData);
+}
+
+Boolean MatroskaFileParser::parse() {
+    Boolean areDone = False;
+
+    if(fInputSource->isCurrentlyAwaitingData())
+        return False;
+    // Our input source is currently being read. Wait until that read completes
+    try {
+        skipRemainingHeaderBytes(True);  // if any
+        do {
+            if(fInputSource->isCurrentlyAwaitingData())
+                return False;
+            // Our input source is currently being read. Wait until that read completes
+
+            switch(fCurrentParseState) {
+            case PARSING_START_OF_FILE: {
+                areDone = parseStartOfFile();
+                break;
+            }
+            case LOOKING_FOR_TRACKS: {
+                lookForNextTrack();
+                break;
+            }
+            case PARSING_TRACK: {
+                areDone = parseTrack();
+                if(areDone && fOurFile.fCuesOffset > 0) {
+                    // We've finished parsing the 'Track' information.  There are also 'Cues' in the file, so parse those before finishing:
+                    // Seek to the specified position in the file.  We were already told that the 'Cues' begins there:
+#ifdef DEBUG
+                    fprintf(stderr, "Seeking to file position %llu (the previously-reported location of 'Cues')\n", fOurFile.fCuesOffset);
+#endif
+                    seekToFilePosition(fOurFile.fCuesOffset);
+                    fCurrentParseState = PARSING_CUES;
+                    areDone            = False;
+                }
+                break;
+            }
+            case PARSING_CUES: {
+                areDone = parseCues();
+                break;
+            }
+            case LOOKING_FOR_CLUSTER: {
+                if(fOurFile.fClusterOffset > 0) {
+                    // Optimization: Seek to the specified position in the file.  We were already told that the 'Cluster' begins there:
+#ifdef DEBUG
+                    fprintf(stderr, "Optimization: Seeking to file position %llu (the previously-reported location of a 'Cluster')\n", fOurFile.fClusterOffset);
+#endif
+                    seekToFilePosition(fOurFile.fClusterOffset);
+                }
+                fCurrentParseState = LOOKING_FOR_BLOCK;
+                break;
+            }
+            case LOOKING_FOR_BLOCK: {
+                lookForNextBlock();
+                break;
+            }
+            case PARSING_BLOCK: {
+                parseBlock();
+                break;
+            }
+            case DELIVERING_FRAME_WITHIN_BLOCK: {
+                if(!deliverFrameWithinBlock())
+                    return False;
+                break;
+            }
+            case DELIVERING_FRAME_BYTES: {
+                deliverFrameBytes();
+                return False;  // Halt parsing for now.  A new 'read' from downstream will cause parsing to resume.
+                break;
+            }
+            }
+        } while(!areDone);
+
+        return True;
+    }
+    catch(int /*e*/) {
+#ifdef DEBUG
+        fprintf(stderr, "MatroskaFileParser::parse() EXCEPTION (This is normal behavior - *not* an error)\n");
+#endif
+        return False;  // the parsing got interrupted
+    }
+}
+
+Boolean MatroskaFileParser::parseStartOfFile() {
+#ifdef DEBUG
+    fprintf(stderr, "parsing start of file\n");
+#endif
+    EBMLId       id;
+    EBMLDataSize size;
+
+    // The file must begin with the standard EBML header (which we skip):
+    if(!parseEBMLIdAndSize(id, size) || id != MATROSKA_ID_EBML) {
+        fOurFile.envir() << "ERROR: File does not begin with an EBML header\n";
+        return True;  // We're done with the file, because it's not valid
+    }
+#ifdef DEBUG
+    fprintf(stderr, "MatroskaFileParser::parseStartOfFile(): Parsed id 0x%s (%s), size: %lld\n", id.hexString(), id.stringName(), size.val());
+#endif
+
+    fCurrentParseState = LOOKING_FOR_TRACKS;
+    skipHeader(size);
+
+    return False;  // because we have more parsing to do - inside the 'Track' header
+}
+
+void MatroskaFileParser::lookForNextTrack() {
+#ifdef DEBUG
+    fprintf(stderr, "looking for Track\n");
+#endif
+    EBMLId       id;
+    EBMLDataSize size;
+
+    // Read and skip over (or enter) each Matroska header, until we get to a 'Track'.
+    while(fCurrentParseState == LOOKING_FOR_TRACKS) {
+        while(!parseEBMLIdAndSize(id, size)) {
+        }
+#ifdef DEBUG
+        fprintf(stderr, "MatroskaFileParser::lookForNextTrack(): Parsed id 0x%s (%s), size: %lld\n", id.hexString(), id.stringName(), size.val());
+#endif
+        switch(id.val()) {
+        case MATROSKA_ID_SEGMENT: {  // 'Segment' header: enter this
+            // Remember the position, within the file, of the start of Segment data, because Seek Positions are relative to this:
+            fOurFile.fSegmentDataOffset = fCurOffsetInFile;
+            break;
+        }
+        case MATROSKA_ID_SEEK_HEAD: {  // 'Seek Head' header: enter this
+            break;
+        }
+        case MATROSKA_ID_SEEK: {  // 'Seek' header: enter this
+            break;
+        }
+        case MATROSKA_ID_SEEK_ID: {  // 'Seek ID' header: get this value
+            if(parseEBMLNumber(fLastSeekId)) {
+#ifdef DEBUG
+                fprintf(stderr, "\tSeek ID 0x%s:\t%s\n", fLastSeekId.hexString(), fLastSeekId.stringName());
+#endif
+            }
+            break;
+        }
+        case MATROSKA_ID_SEEK_POSITION: {  // 'Seek Position' header: get this value
+            u_int64_t seekPosition;
+            if(parseEBMLVal_unsigned64(size, seekPosition)) {
+                u_int64_t offsetInFile = fOurFile.fSegmentDataOffset + seekPosition;
+#ifdef DEBUG
+                fprintf(stderr, "\tSeek Position %llu (=> offset within the file: %llu (0x%llx))\n", seekPosition, offsetInFile, offsetInFile);
+#endif
+                // The only 'Seek Position's that we care about are for 'Cluster' and 'Cues':
+                if(fLastSeekId == MATROSKA_ID_CLUSTER) {
+                    fOurFile.fClusterOffset = offsetInFile;
+                }
+                else if(fLastSeekId == MATROSKA_ID_CUES) {
+                    fOurFile.fCuesOffset = offsetInFile;
+                }
+            }
+            break;
+        }
+        case MATROSKA_ID_INFO: {  // 'Segment Info' header: enter this
+            break;
+        }
+        case MATROSKA_ID_TIMECODE_SCALE: {  // 'Timecode Scale' header: get this value
+            unsigned timecodeScale;
+            if(parseEBMLVal_unsigned(size, timecodeScale) && timecodeScale > 0) {
+                fOurFile.fTimecodeScale = timecodeScale;
+#ifdef DEBUG
+                fprintf(stderr, "\tTimecode Scale %u ns (=> Segment Duration == %f seconds)\n", fOurFile.timecodeScale(),
+                        fOurFile.segmentDuration() * (fOurFile.fTimecodeScale / 1000000000.0f));
+#endif
+            }
+            break;
+        }
+        case MATROSKA_ID_DURATION: {  // 'Segment Duration' header: get this value
+            if(parseEBMLVal_float(size, fOurFile.fSegmentDuration)) {
+#ifdef DEBUG
+                fprintf(stderr, "\tSegment Duration %f (== %f seconds)\n", fOurFile.segmentDuration(),
+                        fOurFile.segmentDuration() * (fOurFile.fTimecodeScale / 1000000000.0f));
+#endif
+            }
+            break;
+        }
+#ifdef DEBUG
+        case MATROSKA_ID_TITLE: {  // 'Segment Title': display this value
+            char *title;
+            if(parseEBMLVal_string(size, title)) {
+#ifdef DEBUG
+                fprintf(stderr, "\tTitle: %s\n", title);
+#endif
+                delete[] title;
+            }
+            break;
+        }
+#endif
+        case MATROSKA_ID_TRACKS: {                               // enter this, and move on to parsing 'Tracks'
+            fLimitOffsetInFile = fCurOffsetInFile + size.val();  // Make sure we don't read past the end of this header
+            fCurrentParseState = PARSING_TRACK;
+            break;
+        }
+        default: {  // skip over this header
+            skipHeader(size);
+            break;
+        }
+        }
+        setParseState();
+    }
+}
+
+Boolean MatroskaFileParser::parseTrack() {
+#ifdef DEBUG
+    fprintf(stderr, "parsing Track\n");
+#endif
+    // Read and process each Matroska header, until we get to the end of the Track:
+    MatroskaTrack *track = NULL;
+    EBMLId         id;
+    EBMLDataSize   size;
+    while(fCurOffsetInFile < fLimitOffsetInFile) {
+        while(!parseEBMLIdAndSize(id, size)) {
+        }
+#ifdef DEBUG
+        if(id == MATROSKA_ID_TRACK_ENTRY)
+            fprintf(stderr, "\n");  // makes debugging output easier to read
+        fprintf(stderr, "MatroskaFileParser::parseTrack(): Parsed id 0x%s (%s), size: %lld\n", id.hexString(), id.stringName(), size.val());
+#endif
+        switch(id.val()) {
+        case MATROSKA_ID_TRACK_ENTRY: {  // 'Track Entry' header: enter this
+            // Create a new "MatroskaTrack" object for this entry:
+            if(track != NULL && track->trackNumber == 0)
+                delete track;  // We had a previous "MatroskaTrack" object that was never used
+            track = new MatroskaTrack;
+            break;
+        }
+        case MATROSKA_ID_TRACK_NUMBER: {
+            unsigned trackNumber;
+            if(parseEBMLVal_unsigned(size, trackNumber)) {
+#ifdef DEBUG
+                fprintf(stderr, "\tTrack Number %d\n", trackNumber);
+#endif
+                if(track != NULL && trackNumber != 0) {
+                    track->trackNumber = trackNumber;
+                    fOurFile.addTrack(track, trackNumber);
+                }
+            }
+            break;
+        }
+        case MATROSKA_ID_TRACK_TYPE: {
+            unsigned trackType;
+            if(parseEBMLVal_unsigned(size, trackType) && track != NULL) {
+                // We convert the Matroska 'track type' code into our own code (which we can use as a bitmap):
+                track->trackType = trackType == 1      ? MATROSKA_TRACK_TYPE_VIDEO
+                                   : trackType == 2    ? MATROSKA_TRACK_TYPE_AUDIO
+                                   : trackType == 0x11 ? MATROSKA_TRACK_TYPE_SUBTITLE
+                                                       : MATROSKA_TRACK_TYPE_OTHER;
+#ifdef DEBUG
+                fprintf(stderr, "\tTrack Type 0x%02x (%s)\n", trackType,
+                        track->trackType == MATROSKA_TRACK_TYPE_VIDEO      ? "video"
+                        : track->trackType == MATROSKA_TRACK_TYPE_AUDIO    ? "audio"
+                        : track->trackType == MATROSKA_TRACK_TYPE_SUBTITLE ? "subtitle"
+                                                                           : "<other>");
+#endif
+            }
+            break;
+        }
+        case MATROSKA_ID_FLAG_ENABLED: {
+            unsigned flagEnabled;
+            if(parseEBMLVal_unsigned(size, flagEnabled)) {
+#ifdef DEBUG
+                fprintf(stderr, "\tTrack is Enabled: %d\n", flagEnabled);
+#endif
+                if(track != NULL)
+                    track->isEnabled = flagEnabled != 0;
+            }
+            break;
+        }
+        case MATROSKA_ID_FLAG_DEFAULT: {
+            unsigned flagDefault;
+            if(parseEBMLVal_unsigned(size, flagDefault)) {
+#ifdef DEBUG
+                fprintf(stderr, "\tTrack is Default: %d\n", flagDefault);
+#endif
+                if(track != NULL)
+                    track->isDefault = flagDefault != 0;
+            }
+            break;
+        }
+        case MATROSKA_ID_FLAG_FORCED: {
+            unsigned flagForced;
+            if(parseEBMLVal_unsigned(size, flagForced)) {
+#ifdef DEBUG
+                fprintf(stderr, "\tTrack is Forced: %d\n", flagForced);
+#endif
+                if(track != NULL)
+                    track->isForced = flagForced != 0;
+            }
+            break;
+        }
+        case MATROSKA_ID_DEFAULT_DURATION: {
+            unsigned defaultDuration;
+            if(parseEBMLVal_unsigned(size, defaultDuration)) {
+#ifdef DEBUG
+                fprintf(stderr, "\tDefault duration %f ms\n", defaultDuration / 1000000.0);
+#endif
+                if(track != NULL)
+                    track->defaultDuration = defaultDuration;
+            }
+            break;
+        }
+        case MATROSKA_ID_MAX_BLOCK_ADDITION_ID: {
+            unsigned maxBlockAdditionID;
+            if(parseEBMLVal_unsigned(size, maxBlockAdditionID)) {
+#ifdef DEBUG
+                fprintf(stderr, "\tMax Block Addition ID: %u\n", maxBlockAdditionID);
+#endif
+            }
+            break;
+        }
+        case MATROSKA_ID_NAME: {
+            char *name;
+            if(parseEBMLVal_string(size, name)) {
+#ifdef DEBUG
+                fprintf(stderr, "\tName: %s\n", name);
+#endif
+                if(track != NULL) {
+                    delete[] track->name;
+                    track->name = name;
+                }
+                else {
+                    delete[] name;
+                }
+            }
+            break;
+        }
+        case MATROSKA_ID_LANGUAGE: {
+            char *language;
+            if(parseEBMLVal_string(size, language)) {
+#ifdef DEBUG
+                fprintf(stderr, "\tLanguage: %s\n", language);
+#endif
+                if(track != NULL) {
+                    delete[] track->language;
+                    track->language = language;
+                }
+                else {
+                    delete[] language;
+                }
+            }
+            break;
+        }
+        case MATROSKA_ID_CODEC: {
+            char *codecID;
+            if(parseEBMLVal_string(size, codecID)) {
+#ifdef DEBUG
+                fprintf(stderr, "\tCodec ID: %s\n", codecID);
+#endif
+                if(track != NULL) {
+                    delete[] track->codecID;
+                    track->codecID = codecID;
+
+                    // Also set the track's "mimeType" field, if we can deduce it from the "codecID":
+                    if(strcmp(codecID, "A_PCM/INT/BIG") == 0) {
+                        track->mimeType = "audio/L16";
+                    }
+                    else if(strncmp(codecID, "A_MPEG", 6) == 0) {
+                        track->mimeType = "audio/MPEG";
+                    }
+                    else if(strncmp(codecID, "A_AAC", 5) == 0) {
+                        track->mimeType = "audio/AAC";
+                    }
+                    else if(strncmp(codecID, "A_AC3", 5) == 0) {
+                        track->mimeType = "audio/AC3";
+                    }
+                    else if(strncmp(codecID, "A_VORBIS", 8) == 0) {
+                        track->mimeType = "audio/VORBIS";
+                    }
+                    else if(strcmp(codecID, "A_OPUS") == 0) {
+                        track->mimeType    = "audio/OPUS";
+                        track->codecIsOpus = True;
+                    }
+                    else if(strcmp(codecID, "V_MPEG4/ISO/AVC") == 0) {
+                        track->mimeType = "video/H264";
+                    }
+                    else if(strcmp(codecID, "V_MPEGH/ISO/HEVC") == 0) {
+                        track->mimeType = "video/H265";
+                    }
+                    else if(strncmp(codecID, "V_VP8", 5) == 0) {
+                        track->mimeType = "video/VP8";
+                    }
+                    else if(strncmp(codecID, "V_VP9", 5) == 0) {
+                        track->mimeType = "video/VP9";
+                    }
+                    else if(strncmp(codecID, "V_THEORA", 8) == 0) {
+                        track->mimeType = "video/THEORA";
+                    }
+                    else if(strncmp(codecID, "S_TEXT", 6) == 0) {
+                        track->mimeType = "text/T140";
+                    }
+                    else if(strncmp(codecID, "V_MJPEG", 7) == 0) {
+                        track->mimeType = "video/JPEG";
+                    }
+                    else if(strncmp(codecID, "V_UNCOMPRESSED", 14) == 0) {
+                        track->mimeType = "video/RAW";
+                    }
+                }
+                else {
+                    delete[] codecID;
+                }
+            }
+            break;
+        }
+        case MATROSKA_ID_CODEC_PRIVATE: {
+            u_int8_t *codecPrivate;
+            unsigned  codecPrivateSize;
+            if(parseEBMLVal_binary(size, codecPrivate)) {
+                codecPrivateSize = (unsigned)size.val();
+#ifdef DEBUG
+                fprintf(stderr, "\tCodec Private: ");
+                for(unsigned i = 0; i < codecPrivateSize; ++i)
+                    fprintf(stderr, "%02x:", codecPrivate[i]);
+                fprintf(stderr, "\n");
+#endif
+                if(track != NULL) {
+                    delete[] track->codecPrivate;
+                    track->codecPrivate     = codecPrivate;
+                    track->codecPrivateSize = codecPrivateSize;
+
+                    // Hack for H.264 and H.265: The 'codec private' data contains
+                    // the size of NAL unit lengths:
+                    if(track->codecID != NULL) {
+                        if(strcmp(track->codecID, "V_MPEG4/ISO/AVC") == 0) {  // H.264
+                            // Byte 4 of the 'codec private' data contains 'lengthSizeMinusOne':
+                            if(codecPrivateSize >= 5)
+                                track->subframeSizeSize = (codecPrivate[4] & 0x3) + 1;
+                        }
+                        else if(strcmp(track->codecID, "V_MPEGH/ISO/HEVC") == 0) {  // H.265
+                            // H.265 'codec private' data is *supposed* to use the format that's described in
+                            // http://lists.matroska.org/pipermail/matroska-devel/2013-September/004567.html
+                            // However, some Matroska files use the same format that was used for H.264.
+                            // We check for this here, by checking various fields that are supposed to be
+                            // 'all-1' in the 'correct' format:
+                            if(codecPrivateSize < 23 || (codecPrivate[13] & 0xF0) != 0xF0 || (codecPrivate[15] & 0xFC) != 0xFC
+                               || (codecPrivate[16] & 0xFC) != 0xFC || (codecPrivate[17] & 0xF8) != 0xF8 || (codecPrivate[18] & 0xF8) != 0xF8) {
+                                // The 'correct' format isn't being used, so assume the H.264 format instead:
+                                track->codecPrivateUsesH264FormatForH265 = True;
+
+                                // Byte 4 of the 'codec private' data contains 'lengthSizeMinusOne':
+                                if(codecPrivateSize >= 5)
+                                    track->subframeSizeSize = (codecPrivate[4] & 0x3) + 1;
+                            }
+                            else {
+                                // This looks like the 'correct' format:
+                                track->codecPrivateUsesH264FormatForH265 = False;
+
+                                // Byte 21 of the 'codec private' data contains 'lengthSizeMinusOne':
+                                track->subframeSizeSize = (codecPrivate[21] & 0x3) + 1;
+                            }
+                        }
+                    }
+                }
+                else {
+                    delete[] codecPrivate;
+                }
+            }
+            break;
+        }
+        case MATROSKA_ID_VIDEO: {  // 'Video settings' header: enter this
+            break;
+        }
+        case MATROSKA_ID_PIXEL_WIDTH: {
+            unsigned pixelWidth;
+            if(parseEBMLVal_unsigned(size, pixelWidth)) {
+#ifdef DEBUG
+                fprintf(stderr, "\tPixel Width %d\n", pixelWidth);
+#endif
+                if(track != NULL)
+                    track->pixelWidth = pixelWidth;
+            }
+            break;
+        }
+        case MATROSKA_ID_PIXEL_HEIGHT: {
+            unsigned pixelHeight;
+            if(parseEBMLVal_unsigned(size, pixelHeight)) {
+#ifdef DEBUG
+                fprintf(stderr, "\tPixel Height %d\n", pixelHeight);
+#endif
+                if(track != NULL)
+                    track->pixelHeight = pixelHeight;
+            }
+            break;
+        }
+        case MATROSKA_ID_DISPLAY_WIDTH: {
+            unsigned displayWidth;
+            if(parseEBMLVal_unsigned(size, displayWidth)) {
+#ifdef DEBUG
+                fprintf(stderr, "\tDisplay Width %d\n", displayWidth);
+#endif
+            }
+            break;
+        }
+        case MATROSKA_ID_DISPLAY_HEIGHT: {
+            unsigned displayHeight;
+            if(parseEBMLVal_unsigned(size, displayHeight)) {
+#ifdef DEBUG
+                fprintf(stderr, "\tDisplay Height %d\n", displayHeight);
+#endif
+            }
+            break;
+        }
+        case MATROSKA_ID_DISPLAY_UNIT: {
+            unsigned displayUnit;
+            if(parseEBMLVal_unsigned(size, displayUnit)) {
+#ifdef DEBUG
+                fprintf(stderr, "\tDisplay Unit %d\n", displayUnit);
+#endif
+            }
+            break;
+        }
+        case MATROSKA_ID_AUDIO: {  // 'Audio settings' header: enter this
+            break;
+        }
+        case MATROSKA_ID_SAMPLING_FREQUENCY: {
+            float samplingFrequency;
+            if(parseEBMLVal_float(size, samplingFrequency)) {
+                if(track != NULL) {
+                    track->samplingFrequency = (unsigned)samplingFrequency;
+#ifdef DEBUG
+                    fprintf(stderr, "\tSampling frequency %f (->%d)\n", samplingFrequency, track->samplingFrequency);
+#endif
+                }
+            }
+            break;
+        }
+        case MATROSKA_ID_OUTPUT_SAMPLING_FREQUENCY: {
+            float outputSamplingFrequency;
+            if(parseEBMLVal_float(size, outputSamplingFrequency)) {
+#ifdef DEBUG
+                fprintf(stderr, "\tOutput sampling frequency %f\n", outputSamplingFrequency);
+#endif
+            }
+            break;
+        }
+        case MATROSKA_ID_CHANNELS: {
+            unsigned numChannels;
+            if(parseEBMLVal_unsigned(size, numChannels)) {
+#ifdef DEBUG
+                fprintf(stderr, "\tChannels %d\n", numChannels);
+#endif
+                if(track != NULL)
+                    track->numChannels = numChannels;
+            }
+            break;
+        }
+        case MATROSKA_ID_BIT_DEPTH: {
+            unsigned bitDepth;
+            if(parseEBMLVal_unsigned(size, bitDepth)) {
+#ifdef DEBUG
+                fprintf(stderr, "\tBit Depth %d\n", bitDepth);
+#endif
+                if(track != NULL)
+                    track->bitDepth = bitDepth;
+            }
+            break;
+        }
+        case MATROSKA_ID_CONTENT_ENCODINGS:
+        case MATROSKA_ID_CONTENT_ENCODING: {  // 'Content Encodings' or 'Content Encoding' header: enter this
+            break;
+        }
+        case MATROSKA_ID_CONTENT_COMPRESSION: {  // 'Content Compression' header: enter this
+            // Note: We currently support only 'Header Stripping' compression, not 'zlib' compression (the default algorithm).
+            // Therefore, we disable this track, unless/until we later see that 'Header Stripping' is supported:
+            if(track != NULL)
+                track->isEnabled = False;
+            break;
+        }
+        case MATROSKA_ID_CONTENT_COMP_ALGO: {
+            unsigned contentCompAlgo;
+            if(parseEBMLVal_unsigned(size, contentCompAlgo)) {
+#ifdef DEBUG
+                fprintf(stderr, "\tContent Compression Algorithm %d (%s)\n", contentCompAlgo,
+                        contentCompAlgo == 0   ? "zlib"
+                        : contentCompAlgo == 3 ? "Header Stripping"
+                                               : "<unknown>");
+#endif
+                // The only compression algorithm that we support is #3: Header Stripping; disable the track otherwise
+                if(track != NULL)
+                    track->isEnabled = contentCompAlgo == 3;
+            }
+            break;
+        }
+        case MATROSKA_ID_CONTENT_COMP_SETTINGS: {
+            u_int8_t *headerStrippedBytes;
+            unsigned  headerStrippedBytesSize;
+            if(parseEBMLVal_binary(size, headerStrippedBytes)) {
+                headerStrippedBytesSize = (unsigned)size.val();
+#ifdef DEBUG
+                fprintf(stderr, "\tHeader Stripped Bytes: ");
+                for(unsigned i = 0; i < headerStrippedBytesSize; ++i)
+                    fprintf(stderr, "%02x:", headerStrippedBytes[i]);
+                fprintf(stderr, "\n");
+#endif
+                if(track != NULL) {
+                    delete[] track->headerStrippedBytes;
+                    track->headerStrippedBytes     = headerStrippedBytes;
+                    track->headerStrippedBytesSize = headerStrippedBytesSize;
+                }
+                else {
+                    delete[] headerStrippedBytes;
+                }
+            }
+            break;
+        }
+        case MATROSKA_ID_CONTENT_ENCRYPTION: {  // 'Content Encrpytion' header: skip this
+            // Note: We don't currently support encryption at all.  Therefore, we disable this track:
+            if(track != NULL)
+                track->isEnabled = False;
+            // Fall through to...
+        }
+        case MATROSKA_ID_COLOR_SPACE: {
+            u_int8_t *colourSpace;
+            unsigned  colourSpaceSize;
+            if(parseEBMLVal_binary(size, colourSpace)) {
+                colourSpaceSize = (unsigned)size.val();
+#ifdef DEBUG
+                fprintf(stderr, "\tColor space : %02x %02x %02x %02x\n", colourSpace[0], colourSpace[1], colourSpace[2], colourSpace[3]);
+#endif
+                if((track != NULL) && (colourSpaceSize == 4)) {
+                    // convert to sampling value (rfc 4175)
+                    if((strncmp((const char *)colourSpace, "I420", 4) == 0) || (strncmp((const char *)colourSpace, "IYUV", 4) == 0)) {
+                        track->colorSampling = "YCbCr-4:2:0";
+                    }
+                    else if((strncmp((const char *)colourSpace, "YUY2", 4) == 0) || (strncmp((const char *)colourSpace, "UYVY", 4) == 0)) {
+                        track->colorSampling = "YCbCr-4:2:2";
+                    }
+                    else if(strncmp((const char *)colourSpace, "AYUV", 4) == 0) {
+                        track->colorSampling = "YCbCr-4:4:4";
+                    }
+                    else if((strncmp((const char *)colourSpace, "Y41P", 4) == 0) || (strncmp((const char *)colourSpace, "Y41T", 4) == 0)) {
+                        track->colorSampling = "YCbCr-4:1:1";
+                    }
+                    else if(strncmp((const char *)colourSpace, "RGBA", 4) == 0) {
+                        track->colorSampling = "RGBA";
+                    }
+                    else if(strncmp((const char *)colourSpace, "BGRA", 4) == 0) {
+                        track->colorSampling = "BGRA";
+                    }
+                }
+                else {
+                    delete[] colourSpace;
+                }
+            }
+            break;
+        }
+        case MATROSKA_ID_PRIMARIES: {
+            unsigned primaries;
+            if(parseEBMLVal_unsigned(size, primaries)) {
+#ifdef DEBUG
+                fprintf(stderr, "\tPrimaries %u\n", primaries);
+#endif
+                if(track != NULL) {
+                    switch(primaries) {
+                    case 1:  // ITU-R BT.709
+                        track->colorimetry = "BT709-2";
+                        break;
+                    case 7:  // SMPTE 240M
+                        track->colorimetry = "SMPTE240M";
+                        break;
+                    case 2:  // Unspecified
+                    case 3:  // Reserved
+                    case 4:  // ITU-R BT.470M
+                    case 5:  // ITU-R BT.470BG
+                    case 6:  // SMPTE 170M
+                    case 8:  // FILM
+                    case 9:  // ITU-R BT.2020
+                    default:
+#ifdef DEBUG
+                        fprintf(stderr, "\tUnsupported color primaries %u\n", primaries);
+#endif
+                        break;
+                    }
+                }
+            }
+        }
+        default: {  // We don't process this header, so just skip over it:
+            skipHeader(size);
+            break;
+        }
+        }
+        setParseState();
+    }
+
+    fLimitOffsetInFile = 0;  // reset
+    if(track != NULL && track->trackNumber == 0)
+        delete track;  // We had a previous "MatroskaTrack" object that was never used
+    return True;       // we're done parsing track entries
+}
+
+void MatroskaFileParser::lookForNextBlock() {
+#ifdef DEBUG
+    fprintf(stderr, "looking for Block\n");
+#endif
+    // Read and skip over each Matroska header, until we get to a 'Cluster':
+    EBMLId       id;
+    EBMLDataSize size;
+    while(fCurrentParseState == LOOKING_FOR_BLOCK) {
+        while(!parseEBMLIdAndSize(id, size)) {
+        }
+#ifdef DEBUG
+        fprintf(stderr, "MatroskaFileParser::lookForNextBlock(): Parsed id 0x%s (%s), size: %lld\n", id.hexString(), id.stringName(), size.val());
+#endif
+        switch(id.val()) {
+        case MATROSKA_ID_SEGMENT: {  // 'Segment' header: enter this
+            break;
+        }
+        case MATROSKA_ID_CLUSTER: {  // 'Cluster' header: enter this
+            break;
+        }
+        case MATROSKA_ID_TIMECODE: {  // 'Timecode' header: get this value
+            unsigned timecode;
+            if(parseEBMLVal_unsigned(size, timecode)) {
+                fClusterTimecode = timecode;
+#ifdef DEBUG
+                fprintf(stderr, "\tCluster timecode: %d (== %f seconds)\n", fClusterTimecode, fClusterTimecode * (fOurFile.fTimecodeScale / 1000000000.0));
+#endif
+            }
+            break;
+        }
+        case MATROSKA_ID_BLOCK_GROUP: {  // 'Block Group' header: enter this
+            break;
+        }
+        case MATROSKA_ID_SIMPLEBLOCK:
+        case MATROSKA_ID_BLOCK: {  // 'SimpleBlock' or 'Block' header: enter this (and we're done)
+            fBlockSize         = (unsigned)size.val();
+            fCurrentParseState = PARSING_BLOCK;
+            break;
+        }
+        case MATROSKA_ID_BLOCK_DURATION: {  // 'Block Duration' header: get this value (but we currently don't do anything with it)
+            unsigned blockDuration;
+            if(parseEBMLVal_unsigned(size, blockDuration)) {
+#ifdef DEBUG
+                fprintf(stderr, "\tblock duration: %d (== %f ms)\n", blockDuration, (float)(blockDuration * fOurFile.fTimecodeScale / 1000000.0));
+#endif
+            }
+            break;
+        }
+        // Attachments are parsed only if we're in DEBUG mode (otherwise we just skip over them):
+#ifdef DEBUG
+        case MATROSKA_ID_ATTACHMENTS: {  // 'Attachments': enter this
+            break;
+        }
+        case MATROSKA_ID_ATTACHED_FILE: {  // 'Attached File': enter this
+            break;
+        }
+        case MATROSKA_ID_FILE_DESCRIPTION: {  // 'File Description': get this value
+            char *fileDescription;
+            if(parseEBMLVal_string(size, fileDescription)) {
+#ifdef DEBUG
+                fprintf(stderr, "\tFile Description: %s\n", fileDescription);
+#endif
+                delete[] fileDescription;
+            }
+            break;
+        }
+        case MATROSKA_ID_FILE_NAME: {  // 'File Name': get this value
+            char *fileName;
+            if(parseEBMLVal_string(size, fileName)) {
+#ifdef DEBUG
+                fprintf(stderr, "\tFile Name: %s\n", fileName);
+#endif
+                delete[] fileName;
+            }
+            break;
+        }
+        case MATROSKA_ID_FILE_MIME_TYPE: {  // 'File MIME Type': get this value
+            char *fileMIMEType;
+            if(parseEBMLVal_string(size, fileMIMEType)) {
+#ifdef DEBUG
+                fprintf(stderr, "\tFile MIME Type: %s\n", fileMIMEType);
+#endif
+                delete[] fileMIMEType;
+            }
+            break;
+        }
+        case MATROSKA_ID_FILE_UID: {  // 'File UID': get this value
+            unsigned fileUID;
+            if(parseEBMLVal_unsigned(size, fileUID)) {
+#ifdef DEBUG
+                fprintf(stderr, "\tFile UID: 0x%x\n", fileUID);
+#endif
+            }
+            break;
+        }
+#endif
+        default: {  // skip over this header
+            skipHeader(size);
+            break;
+        }
+        }
+        setParseState();
+    }
+}
+
+Boolean MatroskaFileParser::parseCues() {
+#if defined(DEBUG) || defined(DEBUG_CUES)
+    fprintf(stderr, "parsing Cues\n");
+#endif
+    EBMLId       id;
+    EBMLDataSize size;
+
+    // Read the next header, which should be MATROSKA_ID_CUES:
+    if(!parseEBMLIdAndSize(id, size) || id != MATROSKA_ID_CUES)
+        return True;                                     // The header wasn't what we expected, so we're done
+    fLimitOffsetInFile = fCurOffsetInFile + size.val();  // Make sure we don't read past the end of this header
+
+    double    currentCueTime             = 0.0;
+    u_int64_t currentClusterOffsetInFile = 0;
+
+    while(fCurOffsetInFile < fLimitOffsetInFile) {
+        while(!parseEBMLIdAndSize(id, size)) {
+        }
+#ifdef DEBUG_CUES
+        if(id == MATROSKA_ID_CUE_POINT)
+            fprintf(stderr, "\n");  // makes debugging output easier to read
+        fprintf(stderr, "MatroskaFileParser::parseCues(): Parsed id 0x%s (%s), size: %lld\n", id.hexString(), id.stringName(), size.val());
+#endif
+        switch(id.val()) {
+        case MATROSKA_ID_CUE_POINT: {  // 'Cue Point' header: enter this
+            break;
+        }
+        case MATROSKA_ID_CUE_TIME: {  // 'Cue Time' header: get this value
+            unsigned cueTime;
+            if(parseEBMLVal_unsigned(size, cueTime)) {
+                currentCueTime = cueTime * (fOurFile.fTimecodeScale / 1000000000.0);
+#ifdef DEBUG_CUES
+                fprintf(stderr, "\tCue Time %d (== %f seconds)\n", cueTime, currentCueTime);
+#endif
+            }
+            break;
+        }
+        case MATROSKA_ID_CUE_TRACK_POSITIONS: {  // 'Cue Track Positions' header: enter this
+            break;
+        }
+        case MATROSKA_ID_CUE_TRACK: {  // 'Cue Track' header: get this value (but only for debugging; we don't do anything with it)
+            unsigned cueTrack;
+            if(parseEBMLVal_unsigned(size, cueTrack)) {
+#ifdef DEBUG_CUES
+                fprintf(stderr, "\tCue Track %d\n", cueTrack);
+#endif
+            }
+            break;
+        }
+        case MATROSKA_ID_CUE_CLUSTER_POSITION: {  // 'Cue Cluster Position' header: get this value
+            u_int64_t cueClusterPosition;
+            if(parseEBMLVal_unsigned64(size, cueClusterPosition)) {
+                currentClusterOffsetInFile = fOurFile.fSegmentDataOffset + cueClusterPosition;
+#ifdef DEBUG_CUES
+                fprintf(stderr, "\tCue Cluster Position %llu (=> offset within the file: %llu (0x%llx))\n", cueClusterPosition, currentClusterOffsetInFile,
+                        currentClusterOffsetInFile);
+#endif
+                // Record this cue point:
+                fOurFile.addCuePoint(currentCueTime, currentClusterOffsetInFile, 1 /*default block number within cluster*/);
+            }
+            break;
+        }
+        case MATROSKA_ID_CUE_BLOCK_NUMBER: {  // 'Cue Block Number' header: get this value
+            unsigned cueBlockNumber;
+            if(parseEBMLVal_unsigned(size, cueBlockNumber) && cueBlockNumber != 0) {
+#ifdef DEBUG_CUES
+                fprintf(stderr, "\tCue Block Number %d\n", cueBlockNumber);
+#endif
+                // Record this cue point (overwriting any existing entry for this cue time):
+                fOurFile.addCuePoint(currentCueTime, currentClusterOffsetInFile, cueBlockNumber);
+            }
+            break;
+        }
+        default: {  // We don't process this header, so just skip over it:
+            skipHeader(size);
+            break;
+        }
+        }
+        setParseState();
+    }
+
+    fLimitOffsetInFile = 0;  // reset
+#if defined(DEBUG) || defined(DEBUG_CUES)
+    fprintf(stderr, "done parsing Cues\n");
+#endif
+#ifdef DEBUG_CUES
+    fprintf(stderr, "Cue Point tree: ");
+    fOurFile.printCuePoints(stderr);
+    fprintf(stderr, "\n");
+#endif
+    return True;  // we're done parsing Cues
+}
+
+typedef enum { NoLacing, XiphLacing, FixedSizeLacing, EBMLLacing } MatroskaLacingType;
+
+void MatroskaFileParser::parseBlock() {
+#ifdef DEBUG
+    fprintf(stderr, "parsing SimpleBlock or Block\n");
+#endif
+    do {
+        unsigned blockStartPos = curOffset();
+
+        // The block begins with the track number:
+        EBMLNumber trackNumber;
+        if(!parseEBMLNumber(trackNumber))
+            break;
+        fBlockTrackNumber = (unsigned)trackNumber.val();
+
+        // If this track is not being read, then skip the rest of this block, and look for another one:
+        if(fOurDemux->lookupDemuxedTrack(fBlockTrackNumber) == NULL) {
+            unsigned headerBytesSeen = curOffset() - blockStartPos;
+            if(headerBytesSeen < fBlockSize) {
+                skipBytes(fBlockSize - headerBytesSeen);
+            }
+#ifdef DEBUG
+            fprintf(stderr, "\tSkipped block for unused track number %d\n", fBlockTrackNumber);
+#endif
+            fCurrentParseState = LOOKING_FOR_BLOCK;
+            setParseState();
+            return;
+        }
+
+        MatroskaTrack *track = fOurFile.lookup(fBlockTrackNumber);
+        if(track == NULL)
+            break;  // shouldn't happen
+
+        // The next two bytes are the block's timecode (relative to the cluster timecode)
+        fBlockTimecode = (get1Byte() << 8) | get1Byte();
+
+        // The next byte indicates the type of 'lacing' used:
+        u_int8_t c = get1Byte();
+        c &= 0x6;  // we're interested in bits 5-6 only
+        MatroskaLacingType lacingType = (c == 0x0) ? NoLacing : (c == 0x02) ? XiphLacing : (c == 0x04) ? FixedSizeLacing : EBMLLacing;
+#ifdef DEBUG
+        fprintf(stderr, "\ttrack number %d, timecode %d (=> %f seconds), %s lacing\n", fBlockTrackNumber, fBlockTimecode,
+                (fClusterTimecode + fBlockTimecode) * (fOurFile.fTimecodeScale / 1000000000.0),
+                (lacingType == NoLacing)          ? "no"
+                : (lacingType == XiphLacing)      ? "Xiph"
+                : (lacingType == FixedSizeLacing) ? "fixed-size"
+                                                  : "EBML");
+#endif
+
+        if(lacingType == NoLacing) {
+            fNumFramesInBlock = 1;
+        }
+        else {
+            // The next byte tells us how many frames are present in this block
+            fNumFramesInBlock = get1Byte() + 1;
+        }
+        delete[] fFrameSizesWithinBlock;
+        fFrameSizesWithinBlock = new unsigned[fNumFramesInBlock];
+        if(fFrameSizesWithinBlock == NULL)
+            break;
+
+        if(lacingType == NoLacing) {
+            unsigned headerBytesSeen = curOffset() - blockStartPos;
+            if(headerBytesSeen > fBlockSize)
+                break;
+
+            fFrameSizesWithinBlock[0] = fBlockSize - headerBytesSeen;
+        }
+        else if(lacingType == FixedSizeLacing) {
+            unsigned headerBytesSeen = curOffset() - blockStartPos;
+            if(headerBytesSeen > fBlockSize)
+                break;
+
+            unsigned frameBytesAvailable = fBlockSize - headerBytesSeen;
+            unsigned constantFrameSize   = frameBytesAvailable / fNumFramesInBlock;
+
+            for(unsigned i = 0; i < fNumFramesInBlock; ++i) {
+                fFrameSizesWithinBlock[i] = constantFrameSize;
+            }
+            // If there are any bytes left over, assign them to the last frame:
+            fFrameSizesWithinBlock[fNumFramesInBlock - 1] += frameBytesAvailable % fNumFramesInBlock;
+        }
+        else {  // EBML or Xiph lacing
+            unsigned curFrameSize    = 0;
+            unsigned frameSizesTotal = 0;
+            unsigned i;
+
+            for(i = 0; i < fNumFramesInBlock - 1; ++i) {
+                if(lacingType == EBMLLacing) {
+                    EBMLNumber frameSize;
+                    if(!parseEBMLNumber(frameSize))
+                        break;
+                    unsigned fsv = (unsigned)frameSize.val();
+
+                    if(i == 0) {
+                        curFrameSize = fsv;
+                    }
+                    else {
+                        // The value we read is a signed value, that's added to the previous frame size, to get the current frame size:
+                        unsigned toSubtract = (fsv > 0xFFFFFF) ? 0x07FFFFFF : (fsv > 0xFFFF) ? 0x0FFFFF : (fsv > 0xFF) ? 0x1FFF : 0x3F;
+                        int      fsv_signed = fsv - toSubtract;
+                        curFrameSize += fsv_signed;
+                        if((int)curFrameSize < 0)
+                            break;
+                    }
+                }
+                else {  // Xiph lacing
+                    curFrameSize = 0;
+                    u_int8_t c;
+                    do {
+                        c = get1Byte();
+                        curFrameSize += c;
+                    } while(c == 0xFF);
+                }
+                fFrameSizesWithinBlock[i] = curFrameSize;
+                frameSizesTotal += curFrameSize;
+            }
+            if(i != fNumFramesInBlock - 1)
+                break;  // an error occurred within the "for" loop
+
+            // Compute the size of the final frame within the block (from the block's size, and the frame sizes already computed):)
+            unsigned headerBytesSeen = curOffset() - blockStartPos;
+            if(headerBytesSeen + frameSizesTotal > fBlockSize)
+                break;
+            fFrameSizesWithinBlock[i] = fBlockSize - (headerBytesSeen + frameSizesTotal);
+        }
+
+        // We're done parsing headers within the block, and (as a result) we now know the sizes of all frames within the block.
+        // If we have 'stripped bytes' that are common to (the front of) all frames, then count them now:
+        if(track->headerStrippedBytesSize != 0) {
+            for(unsigned i = 0; i < fNumFramesInBlock; ++i)
+                fFrameSizesWithinBlock[i] += track->headerStrippedBytesSize;
+        }
+#ifdef DEBUG
+        fprintf(stderr, "\tThis block contains %d frame(s); size(s):", fNumFramesInBlock);
+        unsigned frameSizesTotal = 0;
+        for(unsigned i = 0; i < fNumFramesInBlock; ++i) {
+            fprintf(stderr, " %d", fFrameSizesWithinBlock[i]);
+            frameSizesTotal += fFrameSizesWithinBlock[i];
+        }
+        if(fNumFramesInBlock > 1)
+            fprintf(stderr, " (total: %u)", frameSizesTotal);
+        fprintf(stderr, " bytes\n");
+#endif
+        // Next, start delivering these frames:
+        fCurrentParseState    = DELIVERING_FRAME_WITHIN_BLOCK;
+        fCurOffsetWithinFrame = fNextFrameNumberToDeliver = 0;
+        setParseState();
+        return;
+    } while(0);
+
+    // An error occurred.  Try to recover:
+#ifdef DEBUG
+    fprintf(stderr, "parseBlock(): Error parsing data; trying to recover...\n");
+#endif
+    fCurrentParseState = LOOKING_FOR_BLOCK;
+}
+
+Boolean MatroskaFileParser::deliverFrameWithinBlock() {
+#ifdef DEBUG
+    fprintf(stderr, "delivering frame within SimpleBlock or Block\n");
+#endif
+    do {
+        MatroskaTrack *track = fOurFile.lookup(fBlockTrackNumber);
+        if(track == NULL)
+            break;  // shouldn't happen
+
+        MatroskaDemuxedTrack *demuxedTrack = fOurDemux->lookupDemuxedTrack(fBlockTrackNumber);
+        if(demuxedTrack == NULL)
+            break;  // shouldn't happen
+        if(!demuxedTrack->isCurrentlyAwaitingData()) {
+            // Someone has been reading this stream, but isn't right now.
+            // We can't deliver this frame until he asks for it, so punt for now.
+            // The next time he asks for a frame, he'll get it.
+#ifdef DEBUG
+            fprintf(stderr, "\tdeferring delivery of frame #%d (%d bytes)", fNextFrameNumberToDeliver, fFrameSizesWithinBlock[fNextFrameNumberToDeliver]);
+            if(track->haveSubframes())
+                fprintf(stderr, "[offset %d]", fCurOffsetWithinFrame);
+            fprintf(stderr, "\n");
+#endif
+            restoreSavedParserState();  // so we read from the beginning next time
+            return False;
+        }
+
+        unsigned        frameSize;
+        u_int8_t const *specialFrameSource    = NULL;
+        u_int8_t const  opusCommentHeader[16] = { 'O', 'p', 'u', 's', 'T', 'a', 'g', 's', 0, 0, 0, 0, 0, 0, 0, 0 };
+        if(track->codecIsOpus && demuxedTrack->fOpusFrameNumber < 2) {
+            // Special case for Opus audio.  The first frame (the 'configuration' header) comes from
+            // the 'private data'.  The second frame (the 'comment' header) comes is synthesized by
+            // us here:
+            if(demuxedTrack->fOpusFrameNumber == 0) {
+                specialFrameSource = track->codecPrivate;
+                frameSize          = track->codecPrivateSize;
+            }
+            else {  // demuxedTrack->fOpusFrameNumber == 1
+                specialFrameSource = opusCommentHeader;
+                frameSize          = sizeof opusCommentHeader;
+            }
+            ++demuxedTrack->fOpusFrameNumber;
+        }
+        else {
+            frameSize = fFrameSizesWithinBlock[fNextFrameNumberToDeliver];
+            if(track->haveSubframes()) {
+                // The next "track->subframeSizeSize" bytes contain the length of a 'subframe':
+                if(fCurOffsetWithinFrame + track->subframeSizeSize > frameSize)
+                    break;  // sanity check
+                unsigned subframeSize = 0;
+                for(unsigned i = 0; i < track->subframeSizeSize; ++i) {
+                    u_int8_t c;
+                    getCommonFrameBytes(track, &c, 1, 0);
+                    if(fCurFrameNumBytesToGet > 0) {  // it'll be 1
+                        c = get1Byte();
+                        ++fCurOffsetWithinFrame;
+                    }
+                    subframeSize = subframeSize * 256 + c;
+                }
+                if(subframeSize == 0 || fCurOffsetWithinFrame + subframeSize > frameSize)
+                    break;  // sanity check
+                frameSize = subframeSize;
+            }
+        }
+
+        // Compute the presentation time of this frame (from the cluster timecode, the block timecode, and the default duration):
+        double pt = (fClusterTimecode + fBlockTimecode) * (fOurFile.fTimecodeScale / 1000000000.0)
+                    + fNextFrameNumberToDeliver * (track->defaultDuration / 1000000000.0);
+        if(fPresentationTimeOffset == 0.0) {
+            // This is the first time we've computed a presentation time.
+            // Compute an offset to make the presentation times aligned with 'wall clock' time:
+            struct timeval timeNow;
+            gettimeofday(&timeNow, NULL);
+            double ptNow            = timeNow.tv_sec + timeNow.tv_usec / 1000000.0;
+            fPresentationTimeOffset = ptNow - pt;
+        }
+        pt += fPresentationTimeOffset;
+        struct timeval presentationTime;
+        presentationTime.tv_sec  = (unsigned)pt;
+        presentationTime.tv_usec = (unsigned)((pt - presentationTime.tv_sec) * 1000000);
+        unsigned durationInMicroseconds;
+        if(specialFrameSource != NULL) {
+            durationInMicroseconds = 0;
+        }
+        else {  // normal case
+            durationInMicroseconds = track->defaultDuration / 1000;
+            if(track->haveSubframes()) {
+                // If this is a 'subframe', use a duration of 0 instead (unless it's the last 'subframe'):
+                if(fCurOffsetWithinFrame + frameSize + track->subframeSizeSize < fFrameSizesWithinBlock[fNextFrameNumberToDeliver]) {
+                    // There's room for at least one more subframe after this, so give this subframe a duration of 0
+                    durationInMicroseconds = 0;
+                }
+            }
+        }
+
+        if(track->defaultDuration == 0) {
+            // Adjust the frame duration to keep the sum of frame durations aligned with presentation times.
+            if(demuxedTrack->prevPresentationTime().tv_sec != 0) {  // not the first time for this track
+                demuxedTrack->durationImbalance() += (presentationTime.tv_sec - demuxedTrack->prevPresentationTime().tv_sec) * 1000000
+                                                     + (presentationTime.tv_usec - demuxedTrack->prevPresentationTime().tv_usec);
+            }
+            int adjustment = 0;
+            if(demuxedTrack->durationImbalance() > 0) {
+                // The duration needs to be increased.
+                int const adjustmentThreshold = 100000;  // don't increase the duration by more than this amount (in case there's a mistake)
+                adjustment = demuxedTrack->durationImbalance() > adjustmentThreshold ? adjustmentThreshold : demuxedTrack->durationImbalance();
+            }
+            else if(demuxedTrack->durationImbalance() < 0) {
+                // The duration needs to be decreased.
+                adjustment =
+                    (unsigned)(-demuxedTrack->durationImbalance()) < durationInMicroseconds ? demuxedTrack->durationImbalance() : -(int)durationInMicroseconds;
+            }
+            durationInMicroseconds += adjustment;
+            demuxedTrack->durationImbalance() -= durationInMicroseconds;  // for next time
+            demuxedTrack->prevPresentationTime() = presentationTime;      // for next time
+        }
+
+        demuxedTrack->presentationTime()       = presentationTime;
+        demuxedTrack->durationInMicroseconds() = durationInMicroseconds;
+
+        // Deliver the next block now:
+        if(frameSize > demuxedTrack->maxSize()) {
+            demuxedTrack->numTruncatedBytes() = frameSize - demuxedTrack->maxSize();
+            demuxedTrack->frameSize()         = demuxedTrack->maxSize();
+        }
+        else {  // normal case
+            demuxedTrack->numTruncatedBytes() = 0;
+            demuxedTrack->frameSize()         = frameSize;
+        }
+        getCommonFrameBytes(track, demuxedTrack->to(), demuxedTrack->frameSize(), demuxedTrack->numTruncatedBytes());
+
+        // Next, deliver (and/or skip) bytes from the input file:
+        if(specialFrameSource != NULL) {
+            memmove(demuxedTrack->to(), specialFrameSource, demuxedTrack->frameSize());
+#ifdef DEBUG
+            fprintf(stderr, "\tdelivered special frame: %d bytes", demuxedTrack->frameSize());
+            if(demuxedTrack->numTruncatedBytes() > 0)
+                fprintf(stderr, " (%d bytes truncated)", demuxedTrack->numTruncatedBytes());
+            fprintf(stderr, " @%u.%06u (%.06f from start); duration %u us\n", demuxedTrack->presentationTime().tv_sec, demuxedTrack->presentationTime().tv_usec,
+                    demuxedTrack->presentationTime().tv_sec + demuxedTrack->presentationTime().tv_usec / 1000000.0 - fPresentationTimeOffset,
+                    demuxedTrack->durationInMicroseconds());
+#endif
+            setParseState();
+            FramedSource::afterGetting(demuxedTrack);  // completes delivery
+        }
+        else {  // normal case
+            fCurrentParseState = DELIVERING_FRAME_BYTES;
+            setParseState();
+        }
+        return True;
+    } while(0);
+
+    // An error occurred.  Try to recover:
+#ifdef DEBUG
+    fprintf(stderr, "deliverFrameWithinBlock(): Error parsing data; trying to recover...\n");
+#endif
+    fCurrentParseState = LOOKING_FOR_BLOCK;
+    return True;
+}
+
+void MatroskaFileParser::deliverFrameBytes() {
+    do {
+        MatroskaTrack *track = fOurFile.lookup(fBlockTrackNumber);
+        if(track == NULL)
+            break;  // shouldn't happen
+
+        MatroskaDemuxedTrack *demuxedTrack = fOurDemux->lookupDemuxedTrack(fBlockTrackNumber);
+        if(demuxedTrack == NULL)
+            break;  // shouldn't happen
+        if(!demuxedTrack->isCurrentlyAwaitingData())
+            return;  // wait until we're asked for data
+
+        unsigned const BANK_SIZE = bankSize();
+        while(fCurFrameNumBytesToGet > 0) {
+            // Hack: We can get no more than BANK_SIZE bytes at a time:
+            unsigned numBytesToGet = fCurFrameNumBytesToGet > BANK_SIZE ? BANK_SIZE : fCurFrameNumBytesToGet;
+            getBytes(fCurFrameTo, numBytesToGet);
+            fCurFrameTo += numBytesToGet;
+            fCurFrameNumBytesToGet -= numBytesToGet;
+            fCurOffsetWithinFrame += numBytesToGet;
+            setParseState();
+        }
+        while(fCurFrameNumBytesToSkip > 0) {
+            // Hack: We can skip no more than BANK_SIZE bytes at a time:
+            unsigned numBytesToSkip = fCurFrameNumBytesToSkip > BANK_SIZE ? BANK_SIZE : fCurFrameNumBytesToSkip;
+            skipBytes(numBytesToSkip);
+            fCurFrameNumBytesToSkip -= numBytesToSkip;
+            fCurOffsetWithinFrame += numBytesToSkip;
+            setParseState();
+        }
+#ifdef DEBUG
+        fprintf(stderr, "\tdelivered frame #%d: %d bytes", fNextFrameNumberToDeliver, demuxedTrack->frameSize());
+        if(track->haveSubframes())
+            fprintf(stderr, "[offset %d]", fCurOffsetWithinFrame - track->subframeSizeSize - demuxedTrack->frameSize() - demuxedTrack->numTruncatedBytes());
+        if(demuxedTrack->numTruncatedBytes() > 0)
+            fprintf(stderr, " (%d bytes truncated)", demuxedTrack->numTruncatedBytes());
+        fprintf(stderr, " @%u.%06u (%.06f from start); duration %u us\n", demuxedTrack->presentationTime().tv_sec, demuxedTrack->presentationTime().tv_usec,
+                demuxedTrack->presentationTime().tv_sec + demuxedTrack->presentationTime().tv_usec / 1000000.0 - fPresentationTimeOffset,
+                demuxedTrack->durationInMicroseconds());
+#endif
+
+        if(!track->haveSubframes() || fCurOffsetWithinFrame + track->subframeSizeSize >= fFrameSizesWithinBlock[fNextFrameNumberToDeliver]) {
+            // Either we don't have subframes, or there's no more room for another subframe => We're completely done with this frame now:
+            ++fNextFrameNumberToDeliver;
+            fCurOffsetWithinFrame = 0;
+        }
+        if(fNextFrameNumberToDeliver == fNumFramesInBlock) {
+            // We've delivered all of the frames from this block.  Look for another block next:
+            fCurrentParseState = LOOKING_FOR_BLOCK;
+        }
+        else {
+            fCurrentParseState = DELIVERING_FRAME_WITHIN_BLOCK;
+        }
+
+        setParseState();
+        FramedSource::afterGetting(demuxedTrack);  // completes delivery
+        return;
+    } while(0);
+
+    // An error occurred.  Try to recover:
+#ifdef DEBUG
+    fprintf(stderr, "deliverFrameBytes(): Error parsing data; trying to recover...\n");
+#endif
+    fCurrentParseState = LOOKING_FOR_BLOCK;
+}
+
+void MatroskaFileParser ::getCommonFrameBytes(MatroskaTrack *track, u_int8_t *to, unsigned numBytesToGet, unsigned numBytesToSkip) {
+    if(track->headerStrippedBytesSize > fCurOffsetWithinFrame) {
+        // We have some common 'header stripped' bytes that remain to be prepended to the frame.  Use these first:
+        unsigned numRemainingHeaderStrippedBytes = track->headerStrippedBytesSize - fCurOffsetWithinFrame;
+        unsigned numHeaderStrippedBytesToGet;
+        if(numBytesToGet <= numRemainingHeaderStrippedBytes) {
+            numHeaderStrippedBytesToGet = numBytesToGet;
+            numBytesToGet               = 0;
+            if(numBytesToGet + numBytesToSkip <= numRemainingHeaderStrippedBytes) {
+                numBytesToSkip = 0;
+            }
+            else {
+                numBytesToSkip = numBytesToGet + numBytesToSkip - numRemainingHeaderStrippedBytes;
+            }
+        }
+        else {
+            numHeaderStrippedBytesToGet = numRemainingHeaderStrippedBytes;
+            numBytesToGet               = numBytesToGet - numRemainingHeaderStrippedBytes;
+        }
+
+        if(numHeaderStrippedBytesToGet > 0) {
+            memmove(to, &track->headerStrippedBytes[fCurOffsetWithinFrame], numHeaderStrippedBytesToGet);
+            to += numHeaderStrippedBytesToGet;
+            fCurOffsetWithinFrame += numHeaderStrippedBytesToGet;
+        }
+    }
+
+    fCurFrameTo             = to;
+    fCurFrameNumBytesToGet  = numBytesToGet;
+    fCurFrameNumBytesToSkip = numBytesToSkip;
+}
+
+Boolean MatroskaFileParser::parseEBMLNumber(EBMLNumber &num) {
+    unsigned i;
+    u_int8_t bitmask = 0x80;
+    for(i = 0; i < EBML_NUMBER_MAX_LEN; ++i) {
+        while(1) {
+            if(fLimitOffsetInFile > 0 && fCurOffsetInFile > fLimitOffsetInFile)
+                return False;  // We've hit our pre-set limit
+            num.data[i] = get1Byte();
+            ++fCurOffsetInFile;
+
+            // If we're looking for an id, skip any leading bytes that don't contain a '1' in the first 4 bits:
+            if(i == 0 /*we're a leading byte*/ && !num.stripLeading1 /*we're looking for an id*/ && (num.data[i] & 0xF0) == 0) {
+                setParseState();  // ensures that we make forward progress if the parsing gets interrupted
+                continue;
+            }
+            break;
+        }
+        if((num.data[0] & bitmask) != 0) {
+            // num[i] is the last byte of the id
+            if(num.stripLeading1)
+                num.data[0] &= ~bitmask;
+            break;
+        }
+        bitmask >>= 1;
+    }
+    if(i == EBML_NUMBER_MAX_LEN)
+        return False;
+
+    num.len = i + 1;
+    return True;
+}
+
+Boolean MatroskaFileParser::parseEBMLIdAndSize(EBMLId &id, EBMLDataSize &size) {
+    return parseEBMLNumber(id) && parseEBMLNumber(size);
+}
+
+Boolean MatroskaFileParser::parseEBMLVal_unsigned64(EBMLDataSize &size, u_int64_t &result) {
+    u_int64_t sv = size.val();
+    if(sv > 8)
+        return False;  // size too large
+
+    result = 0;  // initially
+    for(unsigned i = (unsigned)sv; i > 0; --i) {
+        if(fLimitOffsetInFile > 0 && fCurOffsetInFile > fLimitOffsetInFile)
+            return False;  // We've hit our pre-set limit
+
+        u_int8_t c = get1Byte();
+        ++fCurOffsetInFile;
+
+        result = result * 256 + c;
+    }
+
+    return True;
+}
+
+Boolean MatroskaFileParser::parseEBMLVal_unsigned(EBMLDataSize &size, unsigned &result) {
+    if(size.val() > 4)
+        return False;  // size too large
+
+    u_int64_t result64;
+    if(!parseEBMLVal_unsigned64(size, result64))
+        return False;
+
+    result = (unsigned)result64;
+
+    return True;
+}
+
+Boolean MatroskaFileParser::parseEBMLVal_float(EBMLDataSize &size, float &result) {
+    if(size.val() == 4) {
+        // Normal case.  Read the value as if it were a 4-byte integer, then copy it to the 'float' result:
+        unsigned resultAsUnsigned;
+        if(!parseEBMLVal_unsigned(size, resultAsUnsigned))
+            return False;
+
+        if(sizeof result != sizeof resultAsUnsigned)
+            return False;
+        memcpy(&result, &resultAsUnsigned, sizeof result);
+        return True;
+    }
+    else if(size.val() == 8) {
+        // Read the value as if it were an 8-byte integer, then copy it to a 'double', the convert that to the 'float' result:
+        u_int64_t resultAsUnsigned64;
+        if(!parseEBMLVal_unsigned64(size, resultAsUnsigned64))
+            return False;
+
+        double resultDouble;
+        if(sizeof resultDouble != sizeof resultAsUnsigned64)
+            return False;
+        memcpy(&resultDouble, &resultAsUnsigned64, sizeof resultDouble);
+
+        result = (float)resultDouble;
+        return True;
+    }
+    else {
+        // Unworkable size
+        return False;
+    }
+}
+
+Boolean MatroskaFileParser::parseEBMLVal_string(EBMLDataSize &size, char *&result) {
+    unsigned resultLength = (unsigned)size.val();
+    result                = new char[resultLength + 1];  // allow for the trailing '\0'
+    if(result == NULL)
+        return False;
+
+    char *   p = result;
+    unsigned i;
+    for(i = 0; i < resultLength; ++i) {
+        if(fLimitOffsetInFile > 0 && fCurOffsetInFile > fLimitOffsetInFile)
+            break;  // We've hit our pre-set limit
+
+        u_int8_t c = get1Byte();
+        ++fCurOffsetInFile;
+
+        *p++ = c;
+    }
+    if(i < resultLength) {  // an error occurred
+        delete[] result;
+        result = NULL;
+        return False;
+    }
+    *p = '\0';
+
+    return True;
+}
+
+Boolean MatroskaFileParser::parseEBMLVal_binary(EBMLDataSize &size, u_int8_t *&result) {
+    unsigned resultLength = (unsigned)size.val();
+    result                = new u_int8_t[resultLength];
+    if(result == NULL)
+        return False;
+
+    u_int8_t *p = result;
+    unsigned  i;
+    for(i = 0; i < resultLength; ++i) {
+        if(fLimitOffsetInFile > 0 && fCurOffsetInFile > fLimitOffsetInFile)
+            break;  // We've hit our pre-set limit
+
+        u_int8_t c = get1Byte();
+        ++fCurOffsetInFile;
+
+        *p++ = c;
+    }
+    if(i < resultLength) {  // an error occurred
+        delete[] result;
+        result = NULL;
+        return False;
+    }
+
+    return True;
+}
+
+void MatroskaFileParser::skipHeader(EBMLDataSize const &size) {
+    u_int64_t sv = (unsigned)size.val();
+#ifdef DEBUG
+    fprintf(stderr, "\tskipping %llu bytes\n", sv);
+#endif
+
+    fNumHeaderBytesToSkip = sv;
+    skipRemainingHeaderBytes(False);
+}
+
+void MatroskaFileParser::skipRemainingHeaderBytes(Boolean isContinuation) {
+    if(fNumHeaderBytesToSkip == 0)
+        return;  // common case
+
+    // Hack: To avoid tripping into a parser 'internal error' if we try to skip an excessively large
+    // distance, break up the skipping into manageable chunks, to ensure forward progress:
+    unsigned const maxBytesToSkip = bankSize();
+    while(fNumHeaderBytesToSkip > 0) {
+        unsigned numBytesToSkipNow = fNumHeaderBytesToSkip < maxBytesToSkip ? (unsigned)fNumHeaderBytesToSkip : maxBytesToSkip;
+        setParseState();
+        skipBytes(numBytesToSkipNow);
+#ifdef DEBUG
+        if(isContinuation || numBytesToSkipNow < fNumHeaderBytesToSkip) {
+            fprintf(stderr, "\t\t(skipped %u bytes; %llu bytes remaining)\n", numBytesToSkipNow, fNumHeaderBytesToSkip - numBytesToSkipNow);
+        }
+#endif
+        fCurOffsetInFile += numBytesToSkipNow;
+        fNumHeaderBytesToSkip -= numBytesToSkipNow;
+    }
+}
+
+void MatroskaFileParser::setParseState() {
+    fSavedCurOffsetInFile      = fCurOffsetInFile;
+    fSavedCurOffsetWithinFrame = fCurOffsetWithinFrame;
+    saveParserState();
+}
+
+void MatroskaFileParser::restoreSavedParserState() {
+    StreamParser::restoreSavedParserState();
+    fCurOffsetInFile      = fSavedCurOffsetInFile;
+    fCurOffsetWithinFrame = fSavedCurOffsetWithinFrame;
+}
+
+void MatroskaFileParser::seekToFilePosition(u_int64_t offsetInFile) {
+    ByteStreamFileSource *fileSource = (ByteStreamFileSource *)fInputSource;  // we know it's a "ByteStreamFileSource"
+    if(fileSource != NULL) {
+        fileSource->seekToByteAbsolute(offsetInFile);
+        resetStateAfterSeeking();
+    }
+}
+
+void MatroskaFileParser::seekToEndOfFile() {
+    ByteStreamFileSource *fileSource = (ByteStreamFileSource *)fInputSource;  // we know it's a "ByteStreamFileSource"
+    if(fileSource != NULL) {
+        fileSource->seekToEnd();
+        resetStateAfterSeeking();
+    }
+}
+
+void MatroskaFileParser::resetStateAfterSeeking() {
+    // Presentation times aren't affected by the seek; they continue advancing as normal.
+    // Therefore, ensure that they continue to be aligned with 'wall clock' time:
+    resetPresentationTimes();
+
+    // Because we're resuming parsing after seeking to a new position in the file, reset the parser state:
+    fCurOffsetInFile = fSavedCurOffsetInFile = 0;
+    fCurOffsetWithinFrame = fSavedCurOffsetWithinFrame = 0;
+    flushInput();
+}
+
+void MatroskaFileParser::resetPresentationTimes() {
+    if(fOurDemux != NULL)
+        fOurDemux->resetState();
+
+    fPresentationTimeOffset = 0.0;
+}
diff --git a/3rdparty/live555/src/liveMedia/MatroskaFileParser.hh b/3rdparty/live555/src/liveMedia/MatroskaFileParser.hh
new file mode 100644
index 00000000..b5ea2f2a
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/MatroskaFileParser.hh
@@ -0,0 +1,139 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A parser for a Matroska file.
+// C++ header
+
+#ifndef _MATROSKA_FILE_PARSER_HH
+
+#ifndef _STREAM_PARSER_HH
+#include "StreamParser.hh"
+#endif
+#ifndef _MATROSKA_FILE_HH
+#include "MatroskaFile.hh"
+#endif
+#ifndef _EBML_NUMBER_HH
+#include "EBMLNumber.hh"
+#endif
+
+// An enum representing the current state of the parser:
+enum MatroskaParseState {
+  PARSING_START_OF_FILE,
+  LOOKING_FOR_TRACKS,
+  PARSING_TRACK,
+  PARSING_CUES,
+  LOOKING_FOR_CLUSTER,
+  LOOKING_FOR_BLOCK,
+  PARSING_BLOCK,
+  DELIVERING_FRAME_WITHIN_BLOCK,
+  DELIVERING_FRAME_BYTES
+};
+
+class MatroskaFileParser: public StreamParser {
+public:
+  MatroskaFileParser(MatroskaFile& ourFile, FramedSource* inputSource,
+		     FramedSource::onCloseFunc* onEndFunc, void* onEndClientData,
+		     MatroskaDemux* ourDemux = NULL);
+  virtual ~MatroskaFileParser();
+
+  void seekToTime(double& seekNPT);
+  void pause();
+
+  // StreamParser 'client continue' function:
+  static void continueParsing(void* clientData, unsigned char* ptr, unsigned size, struct timeval presentationTime);
+  void continueParsing();
+
+private:
+  // Parsing functions:
+  Boolean parse();
+    // returns True iff we have finished parsing to the end of all 'Track' headers (on initialization)
+
+  Boolean parseStartOfFile();
+  void lookForNextTrack();
+  Boolean parseTrack();
+  Boolean parseCues();
+
+  void lookForNextBlock();
+  void parseBlock();
+  Boolean deliverFrameWithinBlock();
+  void deliverFrameBytes();
+
+  void getCommonFrameBytes(MatroskaTrack* track, u_int8_t* to, unsigned numBytesToGet, unsigned numBytesToSkip);
+
+  Boolean parseEBMLNumber(EBMLNumber& num);
+  Boolean parseEBMLIdAndSize(EBMLId& id, EBMLDataSize& size);
+  Boolean parseEBMLVal_unsigned64(EBMLDataSize& size, u_int64_t& result);
+  Boolean parseEBMLVal_unsigned(EBMLDataSize& size, unsigned& result);
+  Boolean parseEBMLVal_float(EBMLDataSize& size, float& result);
+  Boolean parseEBMLVal_string(EBMLDataSize& size, char*& result);
+    // Note: "result" is dynamically allocated; the caller must delete[] it later
+  Boolean parseEBMLVal_binary(EBMLDataSize& size, u_int8_t*& result);
+    // Note: "result" is dynamically allocated; the caller must delete[] it later
+  void skipHeader(EBMLDataSize const& size);
+  void skipRemainingHeaderBytes(Boolean isContinuation);
+
+  void setParseState();
+
+  void seekToFilePosition(u_int64_t offsetInFile);
+  void seekToEndOfFile();
+  void resetStateAfterSeeking(); // common code, called by both of the above
+
+  void resetPresentationTimes();
+      // called after a seek or pause to ensure that presentation times continue to be
+      // aligned with 'wall clock' time
+
+private: // redefined virtual functions
+  virtual void restoreSavedParserState();
+
+private:
+  // General state for parsing:
+  MatroskaFile& fOurFile;
+  FramedSource* fInputSource;
+  FramedSource::onCloseFunc* fOnEndFunc;
+  void* fOnEndClientData;
+  MatroskaDemux* fOurDemux;
+  MatroskaParseState fCurrentParseState;
+  u_int64_t fCurOffsetInFile, fSavedCurOffsetInFile, fLimitOffsetInFile;
+
+  // For skipping over (possibly large) headers:
+  u_int64_t fNumHeaderBytesToSkip;
+
+  // For parsing 'Seek ID's:
+  EBMLId fLastSeekId;
+
+  // Parameters of the most recently-parsed 'Cluster':
+  unsigned fClusterTimecode;
+
+  // Parameters of the most recently-parsed 'Block':
+  unsigned fBlockSize;
+  unsigned fBlockTrackNumber;
+  short fBlockTimecode;
+  unsigned fNumFramesInBlock;
+  unsigned* fFrameSizesWithinBlock;
+
+  // Parameters of the most recently-parsed frame within a 'Block':
+  double fPresentationTimeOffset;
+  unsigned fNextFrameNumberToDeliver;
+  unsigned fCurOffsetWithinFrame, fSavedCurOffsetWithinFrame; // used if track->haveSubframes()
+
+  // Parameters of the (sub)frame that's currently being delivered:
+  u_int8_t* fCurFrameTo;
+  unsigned fCurFrameNumBytesToGet;
+  unsigned fCurFrameNumBytesToSkip;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/MatroskaFileServerDemux.cpp b/3rdparty/live555/src/liveMedia/MatroskaFileServerDemux.cpp
new file mode 100644
index 00000000..f4e93a56
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/MatroskaFileServerDemux.cpp
@@ -0,0 +1,133 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A server demultiplexor for a Matroska file
+// Implementation
+
+#include "MatroskaFileServerDemux.hh"
+#include "MP3AudioMatroskaFileServerMediaSubsession.hh"
+#include "MatroskaFileServerMediaSubsession.hh"
+
+void MatroskaFileServerDemux ::createNew(UsageEnvironment &env, char const *fileName, onCreationFunc *onCreation, void *onCreationClientData,
+                                         char const *preferredLanguage) {
+    (void)new MatroskaFileServerDemux(env, fileName, onCreation, onCreationClientData, preferredLanguage);
+}
+
+ServerMediaSubsession *MatroskaFileServerDemux::newServerMediaSubsession() {
+    unsigned dummyResultTrackNumber;
+    return newServerMediaSubsession(dummyResultTrackNumber);
+}
+
+ServerMediaSubsession *MatroskaFileServerDemux ::newServerMediaSubsession(unsigned &resultTrackNumber) {
+    ServerMediaSubsession *result;
+    resultTrackNumber = 0;
+
+    for(result = NULL; result == NULL && fNextTrackTypeToCheck != MATROSKA_TRACK_TYPE_OTHER; fNextTrackTypeToCheck <<= 1) {
+        if(fNextTrackTypeToCheck == MATROSKA_TRACK_TYPE_VIDEO)
+            resultTrackNumber = fOurMatroskaFile->chosenVideoTrackNumber();
+        else if(fNextTrackTypeToCheck == MATROSKA_TRACK_TYPE_AUDIO)
+            resultTrackNumber = fOurMatroskaFile->chosenAudioTrackNumber();
+        else if(fNextTrackTypeToCheck == MATROSKA_TRACK_TYPE_SUBTITLE)
+            resultTrackNumber = fOurMatroskaFile->chosenSubtitleTrackNumber();
+
+        result = newServerMediaSubsessionByTrackNumber(resultTrackNumber);
+    }
+
+    return result;
+}
+
+ServerMediaSubsession *MatroskaFileServerDemux ::newServerMediaSubsessionByTrackNumber(unsigned trackNumber) {
+    MatroskaTrack *track = fOurMatroskaFile->lookup(trackNumber);
+    if(track == NULL)
+        return NULL;
+
+    // Use the track's "codecID" string to figure out which "ServerMediaSubsession" subclass to use:
+    ServerMediaSubsession *result = NULL;
+    if(strcmp(track->mimeType, "audio/MPEG") == 0) {
+        result = MP3AudioMatroskaFileServerMediaSubsession::createNew(*this, track);
+    }
+    else {
+        result = MatroskaFileServerMediaSubsession::createNew(*this, track);
+    }
+
+    if(result != NULL) {
+#ifdef DEBUG
+        fprintf(stderr, "Created 'ServerMediaSubsession' object for track #%d: %s (%s)\n", track->trackNumber, track->codecID, track->mimeType);
+#endif
+    }
+
+    return result;
+}
+
+FramedSource *MatroskaFileServerDemux::newDemuxedTrack(unsigned clientSessionId, unsigned trackNumber) {
+    MatroskaDemux *demuxToUse = NULL;
+
+    if(clientSessionId != 0 && clientSessionId == fLastClientSessionId) {
+        demuxToUse = fLastCreatedDemux;  // use the same demultiplexor as before
+                                         // Note: This code relies upon the fact that the creation of streams for different
+                                         // client sessions do not overlap - so all demuxed tracks are created for one "MatroskaDemux" at a time.
+                                         // Also, the "clientSessionId != 0" test is a hack, because 'session 0' is special; its audio and video streams
+                                         // are created and destroyed one-at-a-time, rather than both streams being
+                                         // created, and then (later) both streams being destroyed (as is the case
+                                         // for other ('real') session ids).  Because of this, a separate demultiplexor is used for each 'session 0' track.
+    }
+
+    if(demuxToUse == NULL)
+        demuxToUse = fOurMatroskaFile->newDemux(onDemuxDeletion, this);
+
+    fLastClientSessionId = clientSessionId;
+    fLastCreatedDemux    = demuxToUse;
+
+    return demuxToUse->newDemuxedTrackByTrackNumber(trackNumber);
+}
+
+MatroskaFileServerDemux ::MatroskaFileServerDemux(UsageEnvironment &env, char const *fileName, onCreationFunc *onCreation, void *onCreationClientData,
+                                                  char const *preferredLanguage)
+    : Medium(env),
+      fFileName(fileName),
+      fOnCreation(onCreation),
+      fOnCreationClientData(onCreationClientData),
+      fNextTrackTypeToCheck(0x1),
+      fLastClientSessionId(0),
+      fLastCreatedDemux(NULL) {
+    MatroskaFile::createNew(env, fileName, onMatroskaFileCreation, this, preferredLanguage);
+}
+
+MatroskaFileServerDemux::~MatroskaFileServerDemux() {
+    Medium::close(fOurMatroskaFile);
+}
+
+void MatroskaFileServerDemux::onMatroskaFileCreation(MatroskaFile *newFile, void *clientData) {
+    ((MatroskaFileServerDemux *)clientData)->onMatroskaFileCreation(newFile);
+}
+
+void MatroskaFileServerDemux::onMatroskaFileCreation(MatroskaFile *newFile) {
+    fOurMatroskaFile = newFile;
+
+    // Now, call our own creation notification function:
+    if(fOnCreation != NULL)
+        (*fOnCreation)(this, fOnCreationClientData);
+}
+
+void MatroskaFileServerDemux ::onDemuxDeletion(void *clientData, MatroskaDemux *demuxBeingDeleted) {
+    ((MatroskaFileServerDemux *)clientData)->onDemuxDeletion(demuxBeingDeleted);
+}
+
+void MatroskaFileServerDemux::onDemuxDeletion(MatroskaDemux *demuxBeingDeleted) {
+    if(fLastCreatedDemux == demuxBeingDeleted)
+        fLastCreatedDemux = NULL;
+}
diff --git a/3rdparty/live555/src/liveMedia/MatroskaFileServerMediaSubsession.cpp b/3rdparty/live555/src/liveMedia/MatroskaFileServerMediaSubsession.cpp
new file mode 100644
index 00000000..c34b9489
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/MatroskaFileServerMediaSubsession.cpp
@@ -0,0 +1,57 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A 'ServerMediaSubsession' object that creates new, unicast, "RTPSink"s
+// on demand, from a track within a Matroska file.
+// Implementation
+
+#include "MatroskaFileServerMediaSubsession.hh"
+#include "MatroskaDemuxedTrack.hh"
+#include "FramedFilter.hh"
+
+MatroskaFileServerMediaSubsession *MatroskaFileServerMediaSubsession ::createNew(MatroskaFileServerDemux &demux, MatroskaTrack *track) {
+    return new MatroskaFileServerMediaSubsession(demux, track);
+}
+
+MatroskaFileServerMediaSubsession ::MatroskaFileServerMediaSubsession(MatroskaFileServerDemux &demux, MatroskaTrack *track)
+    : FileServerMediaSubsession(demux.envir(), demux.fileName(), False), fOurDemux(demux), fTrack(track), fNumFiltersInFrontOfTrack(0) {}
+
+MatroskaFileServerMediaSubsession::~MatroskaFileServerMediaSubsession() {}
+
+float MatroskaFileServerMediaSubsession::duration() const {
+    return fOurDemux.fileDuration();
+}
+
+void MatroskaFileServerMediaSubsession ::seekStreamSource(FramedSource *inputSource, double &seekNPT, double /*streamDuration*/, u_int64_t & /*numBytes*/) {
+    for(unsigned i = 0; i < fNumFiltersInFrontOfTrack; ++i) {
+        // "inputSource" is a filter.  Go back to *its* source:
+        inputSource = ((FramedFilter *)inputSource)->inputSource();
+    }
+    ((MatroskaDemuxedTrack *)inputSource)->seekToTime(seekNPT);
+}
+
+FramedSource *MatroskaFileServerMediaSubsession ::createNewStreamSource(unsigned clientSessionId, unsigned &estBitrate) {
+    FramedSource *baseSource = fOurDemux.newDemuxedTrack(clientSessionId, fTrack->trackNumber);
+    if(baseSource == NULL)
+        return NULL;
+
+    return fOurDemux.ourMatroskaFile()->createSourceForStreaming(baseSource, fTrack->trackNumber, estBitrate, fNumFiltersInFrontOfTrack);
+}
+
+RTPSink *MatroskaFileServerMediaSubsession ::createNewRTPSink(Groupsock *rtpGroupsock, unsigned char rtpPayloadTypeIfDynamic, FramedSource * /*inputSource*/) {
+    return fOurDemux.ourMatroskaFile()->createRTPSinkForTrackNumber(fTrack->trackNumber, rtpGroupsock, rtpPayloadTypeIfDynamic);
+}
diff --git a/3rdparty/live555/src/liveMedia/MatroskaFileServerMediaSubsession.hh b/3rdparty/live555/src/liveMedia/MatroskaFileServerMediaSubsession.hh
new file mode 100644
index 00000000..5f9b5937
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/MatroskaFileServerMediaSubsession.hh
@@ -0,0 +1,55 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A 'ServerMediaSubsession' object that creates new, unicast, "RTPSink"s
+// on demand, from a track within a Matroska file.
+// C++ header
+
+#ifndef _MATROSKA_FILE_SERVER_MEDIA_SUBSESSION_HH
+#define _MATROSKA_FILE_SERVER_MEDIA_SUBSESSION_HH
+
+#ifndef _FILE_SERVER_MEDIA_SUBSESSION_HH
+#include "FileServerMediaSubsession.hh"
+#endif
+#ifndef _MATROSKA_FILE_SERVER_DEMUX_HH
+#include "MatroskaFileServerDemux.hh"
+#endif
+
+class MatroskaFileServerMediaSubsession: public FileServerMediaSubsession {
+public:
+  static MatroskaFileServerMediaSubsession*
+  createNew(MatroskaFileServerDemux& demux, MatroskaTrack* track);
+
+protected:
+  MatroskaFileServerMediaSubsession(MatroskaFileServerDemux& demux, MatroskaTrack* track);
+      // called only by createNew(), or by subclass constructors
+  virtual ~MatroskaFileServerMediaSubsession();
+
+protected: // redefined virtual functions
+  virtual float duration() const;
+  virtual void seekStreamSource(FramedSource* inputSource, double& seekNPT, double streamDuration, u_int64_t& numBytes);
+  virtual FramedSource* createNewStreamSource(unsigned clientSessionId,
+					      unsigned& estBitrate);
+  virtual RTPSink* createNewRTPSink(Groupsock* rtpGroupsock, unsigned char rtpPayloadTypeIfDynamic, FramedSource* inputSource);
+
+protected:
+  MatroskaFileServerDemux& fOurDemux;
+  MatroskaTrack* fTrack;
+  unsigned fNumFiltersInFrontOfTrack;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/Media.cpp b/3rdparty/live555/src/liveMedia/Media.cpp
new file mode 100644
index 00000000..c29472d5
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/Media.cpp
@@ -0,0 +1,154 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// Media
+// Implementation
+
+#include "Media.hh"
+#include "HashTable.hh"
+
+////////// Medium //////////
+
+Medium::Medium(UsageEnvironment &env) : fEnviron(env), fNextTask(NULL) {
+    // First generate a name for the new medium:
+    MediaLookupTable::ourMedia(env)->generateNewName(fMediumName, mediumNameMaxLen);
+    env.setResultMsg(fMediumName);
+
+    // Then add it to our table:
+    MediaLookupTable::ourMedia(env)->addNew(this, fMediumName);
+}
+
+Medium::~Medium() {
+    // Remove any tasks that might be pending for us:
+    fEnviron.taskScheduler().unscheduleDelayedTask(fNextTask);
+}
+
+Boolean Medium::lookupByName(UsageEnvironment &env, char const *mediumName, Medium *&resultMedium) {
+    resultMedium = MediaLookupTable::ourMedia(env)->lookup(mediumName);
+    if(resultMedium == NULL) {
+        env.setResultMsg("Medium ", mediumName, " does not exist");
+        return False;
+    }
+
+    return True;
+}
+
+void Medium::close(UsageEnvironment &env, char const *name) {
+    MediaLookupTable::ourMedia(env)->remove(name);
+}
+
+void Medium::close(Medium *medium) {
+    if(medium == NULL)
+        return;
+
+    close(medium->envir(), medium->name());
+}
+
+Boolean Medium::isSource() const {
+    return False;  // default implementation
+}
+
+Boolean Medium::isSink() const {
+    return False;  // default implementation
+}
+
+Boolean Medium::isRTCPInstance() const {
+    return False;  // default implementation
+}
+
+Boolean Medium::isRTSPClient() const {
+    return False;  // default implementation
+}
+
+Boolean Medium::isRTSPServer() const {
+    return False;  // default implementation
+}
+
+Boolean Medium::isMediaSession() const {
+    return False;  // default implementation
+}
+
+Boolean Medium::isServerMediaSession() const {
+    return False;  // default implementation
+}
+
+////////// _Tables implementation //////////
+
+_Tables *_Tables::getOurTables(UsageEnvironment &env, Boolean createIfNotPresent) {
+    if(env.liveMediaPriv == NULL && createIfNotPresent) {
+        env.liveMediaPriv = new _Tables(env);
+    }
+    return (_Tables *)(env.liveMediaPriv);
+}
+
+void _Tables::reclaimIfPossible() {
+    if(mediaTable == NULL && socketTable == NULL) {
+        fEnv.liveMediaPriv = NULL;
+        delete this;
+    }
+}
+
+_Tables::_Tables(UsageEnvironment &env) : mediaTable(NULL), socketTable(NULL), fEnv(env) {}
+
+_Tables::~_Tables() {}
+
+////////// MediaLookupTable implementation //////////
+
+MediaLookupTable *MediaLookupTable::ourMedia(UsageEnvironment &env) {
+    _Tables *ourTables = _Tables::getOurTables(env);
+    if(ourTables->mediaTable == NULL) {
+        // Create a new table to record the media that are to be created in
+        // this environment:
+        ourTables->mediaTable = new MediaLookupTable(env);
+    }
+    return ourTables->mediaTable;
+}
+
+Medium *MediaLookupTable::lookup(char const *name) const {
+    return (Medium *)(fTable->Lookup(name));
+}
+
+void MediaLookupTable::addNew(Medium *medium, char *mediumName) {
+    fTable->Add(mediumName, (void *)medium);
+}
+
+void MediaLookupTable::remove(char const *name) {
+    Medium *medium = lookup(name);
+    if(medium != NULL) {
+        fTable->Remove(name);
+        if(fTable->IsEmpty()) {
+            // We can also delete ourselves (to reclaim space):
+            _Tables *ourTables = _Tables::getOurTables(fEnv);
+            delete this;
+            ourTables->mediaTable = NULL;
+            ourTables->reclaimIfPossible();
+        }
+
+        delete medium;
+    }
+}
+
+void MediaLookupTable::generateNewName(char *mediumName, unsigned /*maxLen*/) {
+    // We should really use snprintf() here, but not all systems have it
+    sprintf(mediumName, "liveMedia%d", fNameGenerator++);
+}
+
+MediaLookupTable::MediaLookupTable(UsageEnvironment &env) : fEnv(env), fTable(HashTable::create(STRING_HASH_KEYS)), fNameGenerator(0) {}
+
+MediaLookupTable::~MediaLookupTable() {
+    delete fTable;
+}
diff --git a/3rdparty/live555/src/liveMedia/MediaSession.cpp b/3rdparty/live555/src/liveMedia/MediaSession.cpp
new file mode 100644
index 00000000..9f15d666
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/MediaSession.cpp
@@ -0,0 +1,1720 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A data structure that represents a session that consists of
+// potentially multiple (audio and/or video) sub-sessions
+// Implementation
+
+#include "liveMedia.hh"
+#include "Locale.hh"
+#include "Base64.hh"
+#include "GroupsockHelper.hh"
+#include <ctype.h>
+
+////////// MediaSession //////////
+
+MediaSession *MediaSession::createNew(UsageEnvironment &env, char const *sdpDescription) {
+    MediaSession *newSession = new MediaSession(env);
+    if(newSession != NULL) {
+        if(!newSession->initializeWithSDP(sdpDescription)) {
+            delete newSession;
+            return NULL;
+        }
+    }
+
+    return newSession;
+}
+
+Boolean MediaSession::lookupByName(UsageEnvironment &env, char const *instanceName, MediaSession *&resultSession) {
+    resultSession = NULL;  // unless we succeed
+
+    Medium *medium;
+    if(!Medium::lookupByName(env, instanceName, medium))
+        return False;
+
+    if(!medium->isMediaSession()) {
+        env.setResultMsg(instanceName, " is not a 'MediaSession' object");
+        return False;
+    }
+
+    resultSession = (MediaSession *)medium;
+    return True;
+}
+
+MediaSession::MediaSession(UsageEnvironment &env)
+    : Medium(env),
+      fSubsessionsHead(NULL),
+      fSubsessionsTail(NULL),
+      fConnectionEndpointName(NULL),
+      fConnectionEndpointNameAddressFamily(AF_UNSPEC),
+      fMaxPlayStartTime(0.0f),
+      fMaxPlayEndTime(0.0f),
+      fAbsStartTime(NULL),
+      fAbsEndTime(NULL),
+      fScale(1.0f),
+      fSpeed(1.0f),
+      fMediaSessionType(NULL),
+      fSessionName(NULL),
+      fSessionDescription(NULL),
+      fControlPath(NULL),
+      fMIKEYState(NULL),
+      fCrypto(NULL) {
+    fSourceFilterAddr = nullAddress();
+
+    // Get our host name, and use this for the RTCP CNAME:
+    const unsigned maxCNAMElen = 100;
+    char           CNAME[maxCNAMElen + 1];
+#ifndef CRIS
+    gethostname((char *)CNAME, maxCNAMElen);
+#else
+    // "gethostname()" isn't defined for this platform
+    sprintf(CNAME, "unknown host %d", (unsigned)(our_random() * 0x7FFFFFFF));
+#endif
+    CNAME[maxCNAMElen] = '\0';  // just in case
+    fCNAME             = strDup(CNAME);
+}
+
+MediaSession::~MediaSession() {
+    delete fSubsessionsHead;
+    delete[] fCNAME;
+    delete[] fConnectionEndpointName;
+    delete[] fAbsStartTime;
+    delete[] fAbsEndTime;
+    delete[] fMediaSessionType;
+    delete[] fSessionName;
+    delete[] fSessionDescription;
+    delete[] fControlPath;
+    delete fCrypto;
+    delete fMIKEYState;
+}
+
+Boolean MediaSession::isMediaSession() const {
+    return True;
+}
+
+MediaSubsession *MediaSession::createNewMediaSubsession() {
+    // default implementation:
+    return new MediaSubsession(*this);
+}
+
+Boolean MediaSession::initializeWithSDP(char const *sdpDescription) {
+    if(sdpDescription == NULL)
+        return False;
+
+    // Begin by processing all SDP lines until we see the first "m="
+    char const *sdpLine = sdpDescription;
+    char const *nextSDPLine;
+    while(1) {
+        if(!parseSDPLine(sdpLine, nextSDPLine))
+            return False;
+        // ##### We should really check for the correct SDP version (v=0)
+        if(sdpLine[0] == 'm')
+            break;
+        sdpLine = nextSDPLine;
+        if(sdpLine == NULL)
+            break;  // there are no m= lines at all
+
+        // Check for various special SDP lines that we understand:
+        if(parseSDPLine_s(sdpLine))
+            continue;
+        if(parseSDPLine_i(sdpLine))
+            continue;
+        if(parseSDPLine_c(sdpLine))
+            continue;
+        if(parseSDPAttribute_control(sdpLine))
+            continue;
+        if(parseSDPAttribute_range(sdpLine))
+            continue;
+        if(parseSDPAttribute_type(sdpLine))
+            continue;
+        if(parseSDPAttribute_source_filter(sdpLine))
+            continue;
+        if(parseSDPAttribute_key_mgmt(sdpLine))
+            continue;
+    }
+
+    while(sdpLine != NULL) {
+        // We have a "m=" line, representing a new sub-session:
+        MediaSubsession *subsession = createNewMediaSubsession();
+        if(subsession == NULL) {
+            envir().setResultMsg("Unable to create new MediaSubsession");
+            return False;
+        }
+
+        // Parse the line as "m=<medium_name> <client_portNum> <proto> <fmt>"
+        // or "m=<medium_name> <client_portNum>/<num_ports> <proto> <fmt>"
+        // (Should we be checking for >1 payload format number here?)#####
+        char       *mediumName   = strDupSize(sdpLine);  // ensures we have enough space
+        char const *protocolName = NULL;
+        unsigned    payloadFormat;
+        if((sscanf(sdpLine, "m=%s %hu RTP/AVP %u", mediumName, &subsession->fClientPortNum, &payloadFormat) == 3
+            || sscanf(sdpLine, "m=%s %hu/%*u RTP/AVP %u", mediumName, &subsession->fClientPortNum, &payloadFormat) == 3)
+           && payloadFormat <= 127) {
+            protocolName = "RTP";
+        }
+        else if((sscanf(sdpLine, "m=%s %hu RTP/SAVP %u", mediumName, &subsession->fClientPortNum, &payloadFormat) == 3
+                 || sscanf(sdpLine, "m=%s %hu/%*u RTP/SAVP %u", mediumName, &subsession->fClientPortNum, &payloadFormat) == 3)
+                && payloadFormat <= 127) {
+            protocolName = "SRTP";
+        }
+        else if((sscanf(sdpLine, "m=%s %hu UDP %u", mediumName, &subsession->fClientPortNum, &payloadFormat) == 3
+                 || sscanf(sdpLine, "m=%s %hu udp %u", mediumName, &subsession->fClientPortNum, &payloadFormat) == 3
+                 || sscanf(sdpLine, "m=%s %hu RAW/RAW/UDP %u", mediumName, &subsession->fClientPortNum, &payloadFormat) == 3)
+                && payloadFormat <= 127) {
+            // This is a RAW UDP source
+            protocolName = "UDP";
+        }
+        else {
+            // This "m=" line is bad; output an error message saying so:
+            char *sdpLineStr;
+            if(nextSDPLine == NULL) {
+                sdpLineStr = (char *)sdpLine;
+            }
+            else {
+                sdpLineStr                        = strDup(sdpLine);
+                sdpLineStr[nextSDPLine - sdpLine] = '\0';
+            }
+            envir() << "Bad SDP \"m=\" line: " << sdpLineStr << "\n";
+            if(sdpLineStr != (char *)sdpLine)
+                delete[] sdpLineStr;
+
+            delete[] mediumName;
+            delete subsession;
+
+            // Skip the following SDP lines, up until the next "m=":
+            while(1) {
+                sdpLine = nextSDPLine;
+                if(sdpLine == NULL)
+                    break;  // we've reached the end
+                if(!parseSDPLine(sdpLine, nextSDPLine))
+                    return False;
+
+                if(sdpLine[0] == 'm')
+                    break;  // we've reached the next subsession
+            }
+            continue;
+        }
+
+        // Insert this subsession at the end of the list:
+        if(fSubsessionsTail == NULL) {
+            fSubsessionsHead = fSubsessionsTail = subsession;
+        }
+        else {
+            fSubsessionsTail->setNext(subsession);
+            fSubsessionsTail = subsession;
+        }
+
+        subsession->serverPortNum = subsession->fClientPortNum;  // by default
+
+        char const *mStart         = sdpLine;
+        subsession->fSavedSDPLines = strDup(mStart);
+
+        subsession->fMediumName = strDup(mediumName);
+        delete[] mediumName;
+        subsession->fProtocolName     = strDup(protocolName);
+        subsession->fRTPPayloadFormat = payloadFormat;
+
+        // Process the following SDP lines, up until the next "m=":
+        while(1) {
+            sdpLine = nextSDPLine;
+            if(sdpLine == NULL)
+                break;  // we've reached the end
+            if(!parseSDPLine(sdpLine, nextSDPLine))
+                return False;
+
+            if(sdpLine[0] == 'm')
+                break;  // we've reached the next subsession
+
+            // Check for various special SDP lines that we understand:
+            if(subsession->parseSDPLine_c(sdpLine))
+                continue;
+            if(subsession->parseSDPLine_b(sdpLine))
+                continue;
+            if(subsession->parseSDPAttribute_rtpmap(sdpLine))
+                continue;
+            if(subsession->parseSDPAttribute_rtcpmux(sdpLine))
+                continue;
+            if(subsession->parseSDPAttribute_control(sdpLine))
+                continue;
+            if(subsession->parseSDPAttribute_range(sdpLine))
+                continue;
+            if(subsession->parseSDPAttribute_fmtp(sdpLine))
+                continue;
+            if(subsession->parseSDPAttribute_source_filter(sdpLine))
+                continue;
+            if(subsession->parseSDPAttribute_x_dimensions(sdpLine))
+                continue;
+            if(subsession->parseSDPAttribute_framerate(sdpLine))
+                continue;
+            if(subsession->parseSDPAttribute_key_mgmt(sdpLine))
+                continue;
+
+            // (Later, check for malformed lines, and other valid SDP lines#####)
+        }
+        if(sdpLine != NULL)
+            subsession->fSavedSDPLines[sdpLine - mStart] = '\0';
+
+        // If we don't yet know the codec name, try looking it up from the
+        // list of static payload types:
+        if(subsession->fCodecName == NULL) {
+            subsession->fCodecName = lookupPayloadFormat(subsession->fRTPPayloadFormat, subsession->fRTPTimestampFrequency, subsession->fNumChannels);
+            if(subsession->fCodecName == NULL) {
+                char typeStr[20];
+                sprintf(typeStr, "%d", subsession->fRTPPayloadFormat);
+                envir().setResultMsg("Unknown codec name for RTP payload type ", typeStr);
+                return False;
+            }
+        }
+
+        // If we don't yet know this subsession's RTP timestamp frequency
+        // (because it uses a dynamic payload type and the corresponding
+        // SDP "rtpmap" attribute erroneously didn't specify it),
+        // then guess it now:
+        if(subsession->fRTPTimestampFrequency == 0) {
+            subsession->fRTPTimestampFrequency = guessRTPTimestampFrequency(subsession->fMediumName, subsession->fCodecName);
+        }
+    }
+
+    return True;
+}
+
+Boolean MediaSession::parseSDPLine(char const *inputLine, char const *&nextLine) {
+    // Begin by finding the start of the next line (if any):
+    nextLine = NULL;
+    for(char const *ptr = inputLine; *ptr != '\0'; ++ptr) {
+        if(*ptr == '\r' || *ptr == '\n') {
+            // We found the end of the line
+            ++ptr;
+            while(*ptr == '\r' || *ptr == '\n')
+                ++ptr;
+            nextLine = ptr;
+            if(nextLine[0] == '\0')
+                nextLine = NULL;  // special case for end
+            break;
+        }
+    }
+
+    // Then, check that this line is a SDP line of the form <char>=<etc>
+    // (However, we also accept blank lines in the input.)
+    if(inputLine[0] == '\r' || inputLine[0] == '\n')
+        return True;
+    if(strlen(inputLine) < 2 || inputLine[1] != '=' || inputLine[0] < 'a' || inputLine[0] > 'z') {
+        envir().setResultMsg("Invalid SDP line: ", inputLine);
+        return False;
+    }
+
+    return True;
+}
+
+// Common code used to parse many string values within SDP lines:
+static Boolean parseStringValue(char const *sdpLine, char const *searchFormat, char *&result) {
+    Boolean parseSuccess = False;
+    char   *buffer       = strDupSize(sdpLine);
+
+    if(sscanf(sdpLine, searchFormat, buffer) == 1) {
+        delete[] result;
+        result       = strDup(buffer);
+        parseSuccess = True;
+    }
+    delete[] buffer;
+
+    return parseSuccess;
+}
+
+static Boolean parseTwoStringValues(char const *sdpLine, char const *searchFormat, char *&result1, char *&result2) {
+    Boolean parseSuccess = False;
+    size_t  sdpLineSize  = strlen(sdpLine) + 1;
+    char   *buffer1      = new char[sdpLineSize];
+    char   *buffer2      = new char[sdpLineSize];
+
+    if(sscanf(sdpLine, searchFormat, buffer1, buffer2) == 2) {
+        delete[] result1;
+        result1 = strDup(buffer1);
+        delete[] result2;
+        result2      = strDup(buffer2);
+        parseSuccess = True;
+    }
+    delete[] buffer1;
+    delete[] buffer2;
+
+    return parseSuccess;
+}
+
+static MIKEYState *parseSDPAttribute_key_mgmtToMIKEY(char const *sdpLine) {
+    char       *keyMgmtPrtclId   = NULL;
+    char       *keyMgmtData      = NULL;
+    MIKEYState *resultMIKEYState = NULL;
+
+    do {
+        // Check for a "a=key-mgmt:<prtcl-id> <keymgmt-data>" line:
+        if(!parseTwoStringValues(sdpLine, "a=key-mgmt:%s %s", keyMgmtPrtclId, keyMgmtData))
+            break;
+
+        // We understand only the 'protocol id' "mikey":
+        if(strcmp(keyMgmtPrtclId, "mikey") != 0)
+            break;
+
+        // Base64-decode the "keyMgmtData" string:
+        unsigned  keyMgmtData_decodedSize;
+        u_int8_t *keyMgmtData_decoded = base64Decode(keyMgmtData, keyMgmtData_decodedSize);
+        if(keyMgmtData_decoded == NULL)
+            break;
+
+        resultMIKEYState = MIKEYState::createNew(keyMgmtData_decoded, keyMgmtData_decodedSize);
+        delete[] keyMgmtData_decoded;
+    } while(0);
+
+    delete[] keyMgmtPrtclId;
+    delete[] keyMgmtData;
+    return resultMIKEYState;
+}
+
+Boolean MediaSession::parseSDPLine_s(char const *sdpLine) {
+    // Check for "s=<session name>" line
+    return parseStringValue(sdpLine, "s=%[^\r\n]", fSessionName);
+}
+
+Boolean MediaSession::parseSDPLine_i(char const *sdpLine) {
+    // Check for "i=<session description>" line
+    return parseStringValue(sdpLine, "i=%[^\r\n]", fSessionDescription);
+}
+
+Boolean MediaSession::parseSDPLine_c(char const *sdpLine) {
+    // Check for "c=IN IP4 <connection-endpoint>"
+    // or "c=IN IP4 <connection-endpoint>/<ttl+numAddresses>"
+    // (ditto for "c=IN IP6 ...")
+    // (Later, do something with <ttl+numAddresses> also #####)
+    if(parseStringValue(sdpLine, "c=IN IP4 %[^/\r\n]", fConnectionEndpointName)) {
+        fConnectionEndpointNameAddressFamily = AF_INET;
+        return True;
+    }
+    else if(parseStringValue(sdpLine, "c=IN IP6 %[^/\r\n]", fConnectionEndpointName)) {
+        fConnectionEndpointNameAddressFamily = AF_INET6;
+        return True;
+    }
+
+    return False;
+}
+
+Boolean MediaSession::parseSDPAttribute_type(char const *sdpLine) {
+    // Check for a "a=type:broadcast|meeting|moderated|test|H.332|recvonly" line:
+    return parseStringValue(sdpLine, "a=type: %[^ ]", fMediaSessionType);
+}
+
+Boolean MediaSession::parseSDPAttribute_control(char const *sdpLine) {
+    // Check for a "a=control:<control-path>" line:
+    return parseStringValue(sdpLine, "a=control: %s", fControlPath);
+}
+
+static Boolean parseRangeAttribute(char const *sdpLine, double &startTime, double &endTime) {
+    return sscanf(sdpLine, "a=range: npt = %lg - %lg", &startTime, &endTime) == 2;
+}
+
+static Boolean parseRangeAttribute(char const *sdpLine, char *&absStartTime, char *&absEndTime) {
+    size_t len          = strlen(sdpLine) + 1;
+    char  *as           = new char[len];
+    char  *ae           = new char[len];
+    int    sscanfResult = sscanf(sdpLine, "a=range: clock = %[^-\r\n]-%[^\r\n]", as, ae);
+    if(sscanfResult == 2) {
+        absStartTime = as;
+        absEndTime   = ae;
+    }
+    else if(sscanfResult == 1) {
+        absStartTime = as;
+        delete[] ae;
+    }
+    else {
+        delete[] as;
+        delete[] ae;
+        return False;
+    }
+
+    return True;
+}
+
+Boolean MediaSession::parseSDPAttribute_range(char const *sdpLine) {
+    // Check for a "a=range:npt=<startTime>-<endTime>" line:
+    // (Later handle other kinds of "a=range" attributes also???#####)
+    Boolean parseSuccess = False;
+
+    double playStartTime;
+    double playEndTime;
+    if(parseRangeAttribute(sdpLine, playStartTime, playEndTime)) {
+        parseSuccess = True;
+        if(playStartTime > fMaxPlayStartTime) {
+            fMaxPlayStartTime = playStartTime;
+        }
+        if(playEndTime > fMaxPlayEndTime) {
+            fMaxPlayEndTime = playEndTime;
+        }
+    }
+    else if(parseRangeAttribute(sdpLine, _absStartTime(), _absEndTime())) {
+        parseSuccess = True;
+    }
+
+    return parseSuccess;
+}
+
+static Boolean parseSourceFilterAttribute(char const *sdpLine, struct sockaddr_storage &sourceFilterAddr) {
+    // Check for a "a=source-filter:incl IN IP4 <something> <source>" line (or "IN IP6").
+    // Note: At present, we don't check that <something> really matches
+    // one of our multicast addresses.  We also don't support more than
+    // one <source> #####
+    Boolean result     = False;  // until we succeed
+    char   *sourceName = NULL;
+    do {
+        int addressFamily;
+        if(parseStringValue(sdpLine, "a=source-filter: incl IN IP4 %*s %s", sourceName)) {
+            addressFamily = AF_INET;
+        }
+        else if(parseStringValue(sdpLine, "a=source-filter: incl IN IP6 %*s %s", sourceName)) {
+            addressFamily = AF_INET6;
+        }
+        else
+            break;
+
+        // Now, convert this name to an address, if we can:
+        NetAddressList addresses(sourceName, addressFamily);
+        if(addresses.numAddresses() == 0)
+            break;
+
+        copyAddress(sourceFilterAddr, addresses.firstAddress());
+        result = True;
+    } while(0);
+
+    delete[] sourceName;
+    return result;
+}
+
+Boolean MediaSession ::parseSDPAttribute_source_filter(char const *sdpLine) {
+    return parseSourceFilterAttribute(sdpLine, fSourceFilterAddr);
+}
+
+Boolean MediaSession::parseSDPAttribute_key_mgmt(char const *sdpLine) {
+    MIKEYState *newMIKEYState = parseSDPAttribute_key_mgmtToMIKEY(sdpLine);
+    if(newMIKEYState == NULL)
+        return False;
+
+    delete fCrypto;
+    delete fMIKEYState;
+    fMIKEYState = newMIKEYState;
+    fCrypto     = new SRTPCryptographicContext(*fMIKEYState);
+
+    return True;
+}
+
+char *MediaSession::lookupPayloadFormat(unsigned char rtpPayloadType, unsigned &freq, unsigned &nCh) {
+    // Look up the codec name and timestamp frequency for known (static)
+    // RTP payload formats.
+    char const *temp = NULL;
+    switch(rtpPayloadType) {
+    case 0: {
+        temp = "PCMU";
+        freq = 8000;
+        nCh  = 1;
+        break;
+    }
+    case 2: {
+        temp = "G726-32";
+        freq = 8000;
+        nCh  = 1;
+        break;
+    }
+    case 3: {
+        temp = "GSM";
+        freq = 8000;
+        nCh  = 1;
+        break;
+    }
+    case 4: {
+        temp = "G723";
+        freq = 8000;
+        nCh  = 1;
+        break;
+    }
+    case 5: {
+        temp = "DVI4";
+        freq = 8000;
+        nCh  = 1;
+        break;
+    }
+    case 6: {
+        temp = "DVI4";
+        freq = 16000;
+        nCh  = 1;
+        break;
+    }
+    case 7: {
+        temp = "LPC";
+        freq = 8000;
+        nCh  = 1;
+        break;
+    }
+    case 8: {
+        temp = "PCMA";
+        freq = 8000;
+        nCh  = 1;
+        break;
+    }
+    case 9: {
+        temp = "G722";
+        freq = 8000;
+        nCh  = 1;
+        break;
+    }
+    case 10: {
+        temp = "L16";
+        freq = 44100;
+        nCh  = 2;
+        break;
+    }
+    case 11: {
+        temp = "L16";
+        freq = 44100;
+        nCh  = 1;
+        break;
+    }
+    case 12: {
+        temp = "QCELP";
+        freq = 8000;
+        nCh  = 1;
+        break;
+    }
+    case 14: {
+        temp = "MPA";
+        freq = 90000;
+        nCh  = 1;
+        break;
+    }
+        // 'number of channels' is actually encoded in the media stream
+    case 15: {
+        temp = "G728";
+        freq = 8000;
+        nCh  = 1;
+        break;
+    }
+    case 16: {
+        temp = "DVI4";
+        freq = 11025;
+        nCh  = 1;
+        break;
+    }
+    case 17: {
+        temp = "DVI4";
+        freq = 22050;
+        nCh  = 1;
+        break;
+    }
+    case 18: {
+        temp = "G729";
+        freq = 8000;
+        nCh  = 1;
+        break;
+    }
+    case 25: {
+        temp = "CELB";
+        freq = 90000;
+        nCh  = 1;
+        break;
+    }
+    case 26: {
+        temp = "JPEG";
+        freq = 90000;
+        nCh  = 1;
+        break;
+    }
+    case 28: {
+        temp = "NV";
+        freq = 90000;
+        nCh  = 1;
+        break;
+    }
+    case 31: {
+        temp = "H261";
+        freq = 90000;
+        nCh  = 1;
+        break;
+    }
+    case 32: {
+        temp = "MPV";
+        freq = 90000;
+        nCh  = 1;
+        break;
+    }
+    case 33: {
+        temp = "MP2T";
+        freq = 90000;
+        nCh  = 1;
+        break;
+    }
+    case 34: {
+        temp = "H263";
+        freq = 90000;
+        nCh  = 1;
+        break;
+    }
+    };
+
+    return strDup(temp);
+}
+
+unsigned MediaSession::guessRTPTimestampFrequency(char const *mediumName, char const *codecName) {
+    // By default, we assume that audio sessions use a frequency of 8000,
+    // video sessions use a frequency of 90000,
+    // and text sessions use a frequency of 1000.
+    // Begin by checking for known exceptions to this rule
+    // (where the frequency is known unambiguously (e.g., not like "DVI4"))
+    if(strcmp(codecName, "L16") == 0)
+        return 44100;
+    if(strcmp(codecName, "MPA") == 0 || strcmp(codecName, "MPA-ROBUST") == 0 || strcmp(codecName, "X-MP3-DRAFT-00") == 0)
+        return 90000;
+
+    // Now, guess default values:
+    if(strcmp(mediumName, "video") == 0 || strcmp(mediumName, "VIDEO_MJPEG") == 0)
+        return 90000;
+    else if(strcmp(mediumName, "text") == 0)
+        return 1000;
+    return 8000;  // for "audio", and any other medium
+}
+
+char *MediaSession::absStartTime() const {
+    if(fAbsStartTime != NULL)
+        return fAbsStartTime;
+
+    // If a subsession has an 'absolute' start time, then use that:
+    MediaSubsessionIterator iter(*this);
+    MediaSubsession        *subsession;
+    while((subsession = iter.next()) != NULL) {
+        if(subsession->_absStartTime() != NULL)
+            return subsession->_absStartTime();
+    }
+    return NULL;
+}
+
+char *MediaSession::absEndTime() const {
+    if(fAbsEndTime != NULL)
+        return fAbsEndTime;
+
+    // If a subsession has an 'absolute' end time, then use that:
+    MediaSubsessionIterator iter(*this);
+    MediaSubsession        *subsession;
+    while((subsession = iter.next()) != NULL) {
+        if(subsession->_absEndTime() != NULL)
+            return subsession->_absEndTime();
+    }
+    return NULL;
+}
+
+Boolean MediaSession ::initiateByMediaType(char const *mimeType, MediaSubsession *&resultSubsession, int useSpecialRTPoffset) {
+    // Look through this session's subsessions for media that match "mimeType"
+    resultSubsession = NULL;
+    MediaSubsessionIterator iter(*this);
+    MediaSubsession        *subsession;
+    while((subsession = iter.next()) != NULL) {
+        Boolean wasAlreadyInitiated = subsession->readSource() != NULL;
+        if(!wasAlreadyInitiated) {
+            // Try to create a source for this subsession:
+            if(!subsession->initiate(useSpecialRTPoffset))
+                return False;
+        }
+
+        // Make sure the source's MIME type is one that we handle:
+        if(strcmp(subsession->readSource()->MIMEtype(), mimeType) != 0) {
+            if(!wasAlreadyInitiated)
+                subsession->deInitiate();
+            continue;
+        }
+
+        resultSubsession = subsession;
+        break;  // use this
+    }
+
+    if(resultSubsession == NULL) {
+        envir().setResultMsg("Session has no usable media subsession");
+        return False;
+    }
+
+    return True;
+}
+
+////////// MediaSubsessionIterator //////////
+
+MediaSubsessionIterator::MediaSubsessionIterator(MediaSession const &session) : fOurSession(session) {
+    reset();
+}
+
+MediaSubsessionIterator::~MediaSubsessionIterator() {}
+
+MediaSubsession *MediaSubsessionIterator::next() {
+    MediaSubsession *result = fNextPtr;
+
+    if(fNextPtr != NULL)
+        fNextPtr = fNextPtr->fNext;
+
+    return result;
+}
+
+void MediaSubsessionIterator::reset() {
+    fNextPtr = fOurSession.fSubsessionsHead;
+}
+
+////////// SDPAttribute definition //////////
+
+class SDPAttribute {
+public:
+    SDPAttribute(char const *strValue, Boolean valueIsHexadecimal);
+    virtual ~SDPAttribute();
+
+    char const *strValue() const {
+        return fStrValue;
+    }
+    char const *strValueToLower() const {
+        return fStrValueToLower;
+    }
+    int intValue() const {
+        return fIntValue;
+    }
+    Boolean valueIsHexadecimal() const {
+        return fValueIsHexadecimal;
+    }
+
+private:
+    char   *fStrValue;
+    char   *fStrValueToLower;
+    int     fIntValue;
+    Boolean fValueIsHexadecimal;
+};
+
+////////// MediaSubsession //////////
+
+MediaSubsession::MediaSubsession(MediaSession &parent)
+    : serverPortNum(0),
+      sink(NULL),
+      miscPtr(NULL),
+      fParent(parent),
+      fNext(NULL),
+      fConnectionEndpointName(NULL),
+      fConnectionEndpointNameAddressFamily(AF_UNSPEC),
+      fClientPortNum(0),
+      fRTPPayloadFormat(0xFF),
+      fSavedSDPLines(NULL),
+      fMediumName(NULL),
+      fCodecName(NULL),
+      fProtocolName(NULL),
+      fRTPTimestampFrequency(0),
+      fMultiplexRTCPWithRTP(False),
+      fControlPath(NULL),
+      fMIKEYState(NULL),
+      fCrypto(NULL),
+      fSourceFilterAddr(parent.sourceFilterAddr()),
+      fBandwidth(0),
+      fPlayStartTime(0.0),
+      fPlayEndTime(0.0),
+      fAbsStartTime(NULL),
+      fAbsEndTime(NULL),
+      fVideoWidth(0),
+      fVideoHeight(0),
+      fVideoFPS(0),
+      fNumChannels(1),
+      fScale(1.0f),
+      fNPT_PTS_Offset(0.0f),
+      fAttributeTable(HashTable::create(STRING_HASH_KEYS)),
+      fRTPSocket(NULL),
+      fRTCPSocket(NULL),
+      fRTPSource(NULL),
+      fRTCPInstance(NULL),
+      fReadSource(NULL),
+      fReceiveRawMP3ADUs(False),
+      fReceiveRawJPEGFrames(False),
+      fSessionId(NULL) {
+    rtpInfo.seqNum    = 0;
+    rtpInfo.timestamp = 0;
+    rtpInfo.infoIsNew = False;
+
+    // A few attributes have unusual default values.  Set these now:
+    setAttribute("profile-level-id", "0",
+                 True /*value is hexadecimal*/);          // used with "video/H264"
+                                                          // This won't work for MPEG-4 (unless the value is <10), because for MPEG-4, the value
+                                                          // is assumed to be a decimal string, not a hexadecimal string.  NEED TO FIX #####
+    setAttribute("profile-id", "1");                      // used with "video/H265"
+    setAttribute("level-id", "93");                       // used with "video/H265"
+    setAttribute("interop-constraints", "B00000000000");  // used with "video/H265"
+    setAttribute("sampling", "RGB");                      // used with "video/JPEG2000"
+}
+
+MediaSubsession::~MediaSubsession() {
+    deInitiate();
+
+    delete[] fConnectionEndpointName;
+    delete[] fSavedSDPLines;
+    delete[] fMediumName;
+    delete[] fCodecName;
+    delete[] fProtocolName;
+    delete[] fControlPath;
+    delete fCrypto;
+    delete fMIKEYState;
+    delete[] fAbsStartTime;
+    delete[] fAbsEndTime;
+    delete[] fSessionId;
+
+    // Empty and delete our 'attributes table':
+    SDPAttribute *attr;
+    while((attr = (SDPAttribute *)fAttributeTable->RemoveNext()) != NULL) {
+        delete attr;
+    }
+    delete fAttributeTable;
+
+    delete fNext;
+}
+
+void MediaSubsession::addFilter(FramedFilter *filter) {
+    fReadSource = filter;
+}
+
+double MediaSubsession::playStartTime() const {
+    if(fPlayStartTime > 0)
+        return fPlayStartTime;
+
+    return fParent.playStartTime();
+}
+
+double MediaSubsession::playEndTime() const {
+    if(fPlayEndTime > 0)
+        return fPlayEndTime;
+
+    return fParent.playEndTime();
+}
+
+char *MediaSubsession::absStartTime() const {
+    if(fAbsStartTime != NULL)
+        return fAbsStartTime;
+
+    return fParent.absStartTime();
+}
+
+char *MediaSubsession::absEndTime() const {
+    if(fAbsEndTime != NULL)
+        return fAbsEndTime;
+
+    return fParent.absEndTime();
+}
+
+static Boolean const honorSDPPortChoice
+#ifdef IGNORE_UNICAST_SDP_PORTS
+    = False;
+#else
+    = True;
+#endif
+
+Boolean MediaSubsession::initiate(int useSpecialRTPoffset) {
+    if(fReadSource != NULL)
+        return True;  // has already been initiated
+
+    do {
+        if(fCodecName == NULL) {
+            env().setResultMsg("Codec is unspecified");
+            break;
+        }
+
+        // Create RTP and RTCP 'Groupsocks' on which to receive incoming data.
+        // (Groupsocks will work even for unicast addresses)
+        struct sockaddr_storage tempAddr;
+        getConnectionEndpointAddress(tempAddr);
+        // This could get changed later, as a result of a RTSP "SETUP"
+
+        Boolean const useSRTP       = strcmp(fProtocolName, "SRTP") == 0;
+        Boolean const protocolIsRTP = useSRTP || strcmp(fProtocolName, "RTP") == 0;
+
+        if(fClientPortNum != 0 && (honorSDPPortChoice || IsMulticastAddress(tempAddr))) {
+            // The sockets' port numbers were specified for us.  Use these:
+            if(protocolIsRTP && !fMultiplexRTCPWithRTP) {
+                fClientPortNum = fClientPortNum & ~1;
+                // use an even-numbered port for RTP, and the next (odd-numbered) port for RTCP
+            }
+            if(isSSM()) {
+                fRTPSocket = new Groupsock(env(), tempAddr, fSourceFilterAddr, fClientPortNum);
+            }
+            else {
+                fRTPSocket = new Groupsock(env(), tempAddr, fClientPortNum, 255);
+            }
+            if(fRTPSocket == NULL) {
+                env().setResultMsg("Failed to create RTP socket");
+                break;
+            }
+
+            if(protocolIsRTP) {
+                if(fMultiplexRTCPWithRTP) {
+                    // Use the RTP 'groupsock' object for RTCP as well:
+                    fRTCPSocket = fRTPSocket;
+                }
+                else {
+                    // Set our RTCP port to be the RTP port + 1:
+                    portNumBits const rtcpPortNum = fClientPortNum | 1;
+                    if(isSSM()) {
+                        fRTCPSocket = new Groupsock(env(), tempAddr, fSourceFilterAddr, rtcpPortNum);
+                    }
+                    else {
+                        fRTCPSocket = new Groupsock(env(), tempAddr, rtcpPortNum, 255);
+                    }
+                }
+            }
+        }
+        else {
+            // Port numbers were not specified in advance, so we use ephemeral port numbers.
+            // Create sockets until we get a port-number pair (even: RTP; even+1: RTCP).
+            // (However, if we're multiplexing RTCP with RTP, then we create only one socket,
+            // and the port number can be even or odd.)
+            // We need to make sure that we don't keep trying to use the same bad port numbers over
+            // and over again, so we store bad sockets in a table, and delete them all when we're done.
+            HashTable *socketHashTable = HashTable::create(ONE_WORD_HASH_KEYS);
+            if(socketHashTable == NULL)
+                break;
+            Boolean success = False;
+            NoReuse dummy(env());
+            // ensures that our new ephemeral port number won't be one that's already in use
+
+            while(1) {
+                // Create a new socket:
+                if(isSSM()) {
+                    fRTPSocket = new Groupsock(env(), tempAddr, fSourceFilterAddr, 0);
+                }
+                else {
+                    fRTPSocket = new Groupsock(env(), tempAddr, 0, 255);
+                }
+                if(fRTPSocket == NULL) {
+                    env().setResultMsg("MediaSession::initiate(): unable to create RTP and RTCP sockets");
+                    break;
+                }
+
+                // Get the client port number:
+                Port clientPort(0);
+                if(!getSourcePort(env(), fRTPSocket->socketNum(), tempAddr.ss_family, clientPort)) {
+                    break;
+                }
+                fClientPortNum = ntohs(clientPort.num());
+
+                if(fMultiplexRTCPWithRTP) {
+                    // Use this RTP 'groupsock' object for RTCP as well:
+                    fRTCPSocket = fRTPSocket;
+                    success     = True;
+                    break;
+                }
+
+                // To be usable for RTP, the client port number must be even:
+                if((fClientPortNum & 1) != 0) {  // it's odd
+                    // Record this socket in our table, and keep trying:
+                    unsigned   key      = (unsigned)fClientPortNum;
+                    Groupsock *existing = (Groupsock *)socketHashTable->Add((char const *)key, fRTPSocket);
+                    delete existing;  // in case it wasn't NULL
+                    continue;
+                }
+
+                // Make sure we can use the next (i.e., odd) port number, for RTCP:
+                portNumBits rtcpPortNum = fClientPortNum | 1;
+                if(isSSM()) {
+                    fRTCPSocket = new Groupsock(env(), tempAddr, fSourceFilterAddr, rtcpPortNum);
+                }
+                else {
+                    fRTCPSocket = new Groupsock(env(), tempAddr, rtcpPortNum, 255);
+                }
+                if(fRTCPSocket != NULL && fRTCPSocket->socketNum() >= 0) {
+                    // Success! Use these two sockets.
+                    success = True;
+                    break;
+                }
+                else {
+                    // We couldn't create the RTCP socket (perhaps that port number's already in use elsewhere?).
+                    delete fRTCPSocket;
+                    fRTCPSocket = NULL;
+
+                    // Record the first socket in our table, and keep trying:
+                    unsigned   key      = (unsigned)fClientPortNum;
+                    Groupsock *existing = (Groupsock *)socketHashTable->Add((char const *)key, fRTPSocket);
+                    delete existing;  // in case it wasn't NULL
+                    continue;
+                }
+            }
+
+            // Clean up the socket hash table (and contents):
+            Groupsock *oldGS;
+            while((oldGS = (Groupsock *)socketHashTable->RemoveNext()) != NULL) {
+                delete oldGS;
+            }
+            delete socketHashTable;
+
+            if(!success)
+                break;  // a fatal error occurred trying to create the RTP and RTCP sockets; we can't continue
+        }
+
+        // Try to use a big receive buffer for RTP - at least 0.1 second of
+        // specified bandwidth and at least 50 KB
+        unsigned rtpBufSize = fBandwidth * 25 / 2;  // 1 kbps * 0.1 s = 12.5 bytes
+        if(rtpBufSize < 50 * 1024)
+            rtpBufSize = 50 * 1024;
+        increaseReceiveBufferTo(env(), fRTPSocket->socketNum(), rtpBufSize);
+
+        if(isSSM() && fRTCPSocket != NULL) {
+            // Special case for RTCP SSM: Send RTCP packets back to the source via unicast:
+            fRTCPSocket->changeDestinationParameters(fSourceFilterAddr, 0, ~0);
+        }
+
+        // Create "fRTPSource" and "fReadSource":
+        if(!createSourceObjects(useSpecialRTPoffset))
+            break;
+
+        if(fReadSource == NULL) {
+            env().setResultMsg("Failed to create read source");
+            break;
+        }
+
+        SRTPCryptographicContext *ourCrypto = NULL;
+        if(useSRTP) {
+            // For SRTP, we need key management.  If MIKEY (key management) state wasn't given
+            // to us in the SDP description, then create it now:
+            ourCrypto = getCrypto();
+            if(ourCrypto == NULL) {  // then fMIKEYState is also NULL; create both
+                fMIKEYState = new MIKEYState();
+                ourCrypto = fCrypto = new SRTPCryptographicContext(*fMIKEYState);
+            }
+
+            if(fRTPSource != NULL)
+                fRTPSource->setCrypto(ourCrypto);
+        }
+
+        // Finally, create our RTCP instance. (It starts running automatically)
+        if(fRTPSource != NULL && fRTCPSocket != NULL) {
+            // If bandwidth is specified, use it and add 5% for RTCP overhead.
+            // Otherwise make a guess at 500 kbps.
+            unsigned totSessionBandwidth = fBandwidth ? fBandwidth + fBandwidth / 20 : 500;
+            fRTCPInstance = RTCPInstance::createNew(env(), fRTCPSocket, totSessionBandwidth, (unsigned char const *)fParent.CNAME(), NULL /* we're a client */,
+                                                    fRTPSource, False /* we're not a data transmitter */, ourCrypto);
+            if(fRTCPInstance == NULL) {
+                env().setResultMsg("Failed to create RTCP instance");
+                break;
+            }
+        }
+
+        return True;
+    } while(0);
+
+    deInitiate();
+    fClientPortNum = 0;
+    return False;
+}
+
+void MediaSubsession::deInitiate() {
+    Medium::close(fRTCPInstance);
+    fRTCPInstance = NULL;
+
+    Medium::close(fReadSource);  // this is assumed to also close fRTPSource
+    fReadSource = NULL;
+    fRTPSource  = NULL;
+
+    delete fRTPSocket;
+    if(fRTCPSocket != fRTPSocket)
+        delete fRTCPSocket;
+    fRTPSocket  = NULL;
+    fRTCPSocket = NULL;
+}
+
+Boolean MediaSubsession::setClientPortNum(unsigned short portNum) {
+    if(fReadSource != NULL) {
+        env().setResultMsg("A read source has already been created");
+        return False;
+    }
+
+    fClientPortNum = portNum;
+    return True;
+}
+
+char const *MediaSubsession::attrVal_str(char const *attrName) const {
+    SDPAttribute *attr = (SDPAttribute *)(fAttributeTable->Lookup(attrName));
+    if(attr == NULL)
+        return "";
+
+    return attr->strValue();
+}
+
+char const *MediaSubsession::attrVal_strToLower(char const *attrName) const {
+    SDPAttribute *attr = (SDPAttribute *)(fAttributeTable->Lookup(attrName));
+    if(attr == NULL)
+        return "";
+
+    return attr->strValueToLower();
+}
+
+unsigned MediaSubsession::attrVal_int(char const *attrName) const {
+    SDPAttribute *attr = (SDPAttribute *)(fAttributeTable->Lookup(attrName));
+    if(attr == NULL)
+        return 0;
+
+    return attr->intValue();
+}
+
+char const *MediaSubsession::fmtp_config() const {
+    char const *result = attrVal_str("config");
+    if(result[0] == '\0')
+        result = attrVal_str("configuration");
+
+    return result;
+}
+
+void MediaSubsession::getConnectionEndpointAddress(struct sockaddr_storage &addr) const {
+    do {
+        // Get the endpoint name from us, or from our parent session:
+        char const *endpointString = connectionEndpointName();
+        if(endpointString == NULL) {
+            endpointString = parentSession().connectionEndpointName();
+        }
+        if(endpointString == NULL)
+            break;
+
+        // Now, convert this name to an address, if we can:
+        NetAddressList addresses(endpointString, connectionEndpointNameAddressFamily());
+        if(addresses.numAddresses() == 0)
+            break;
+
+        copyAddress(addr, addresses.firstAddress());
+        return;
+    } while(0);
+
+    // Address unknown; set it to a 'null' value:
+    addr = nullAddress();
+}
+
+void MediaSubsession::setDestinations(struct sockaddr_storage const &defaultDestAddress) {
+    // Get the destination address from the connection endpoint name
+    // (This will be 0 if it's not known, in which case we use the default instead)
+    struct sockaddr_storage destAddress;
+    getConnectionEndpointAddress(destAddress);
+    if(addressIsNull(destAddress))
+        destAddress = defaultDestAddress;
+
+    // The destination TTL remains unchanged:
+    int destTTL = ~0;  // means: don't change
+
+    if(fRTPSocket != NULL) {
+        Port destPort(serverPortNum);
+        fRTPSocket->changeDestinationParameters(destAddress, destPort, destTTL);
+    }
+    if(fRTCPSocket != NULL && !isSSM() && !fMultiplexRTCPWithRTP) {
+        // Note: For SSM sessions, the dest address for RTCP was already set.
+        Port destPort(serverPortNum + 1);
+        fRTCPSocket->changeDestinationParameters(destAddress, destPort, destTTL);
+    }
+}
+
+void MediaSubsession::setSessionId(char const *sessionId) {
+    delete[] fSessionId;
+    fSessionId = strDup(sessionId);
+}
+
+double MediaSubsession::getNormalPlayTime(struct timeval const &presentationTime) {
+    // static unsigned int lastTsp = 0;
+    // unsigned int        curTsp  = rtpSource()->curPacketRTPTimestamp();
+    // unsigned int        freq    = rtpSource()->timestampFrequency();
+    // env() << "new frame: RTPTimestamp = " << curTsp << ", Freq=" << freq << ", tsp/freq=" << (double)curTsp / freq << ", dur=" << curTsp - lastTsp;
+    // lastTsp = curTsp;
+
+    return (double)rtpSource()->curPacketRTPTimestamp();  // TODO:暂时解决FemtoMega H264时间戳解析问题
+    if(rtpSource() == NULL || rtpSource()->timestampFrequency() == 0)
+        return 0.0;  // no RTP source, or bad freq!
+
+    // First, check whether our "RTPSource" object has already been synchronized using RTCP.
+    // If it hasn't, then - as a special case - we need to use the RTP timestamp to compute the NPT.
+    if(!rtpSource()->hasBeenSynchronizedUsingRTCP()) {
+        if(!rtpInfo.infoIsNew)
+            return 0.0;  // the "rtpInfo" structure has not been filled in
+        u_int32_t timestampOffset = rtpSource()->curPacketRTPTimestamp() - rtpInfo.timestamp;
+        double    nptOffset       = (timestampOffset / (double)(rtpSource()->timestampFrequency())) * scale();
+        double    npt             = playStartTime() + nptOffset;
+
+        return npt;
+    }
+    else {
+        // Common case: We have been synchronized using RTCP.  This means that the "presentationTime" parameter
+        // will be accurate, and so we should use this to compute the NPT.
+        double ptsDouble = (double)(presentationTime.tv_sec + presentationTime.tv_usec / 1000000.0);
+
+        if(rtpInfo.infoIsNew) {
+            // This is the first time we've been called with a synchronized presentation time since the "rtpInfo"
+            // structure was last filled in.  Use this "presentationTime" to compute "fNPT_PTS_Offset":
+            if(seqNumLT(rtpSource()->curPacketRTPSeqNum(), rtpInfo.seqNum))
+                return -0.1;  // sanity check; ignore old packets
+            u_int32_t timestampOffset = rtpSource()->curPacketRTPTimestamp() - rtpInfo.timestamp;
+            double    nptOffset       = (timestampOffset / (double)(rtpSource()->timestampFrequency())) * scale();
+            double    npt             = playStartTime() + nptOffset;
+            fNPT_PTS_Offset           = npt - ptsDouble * scale();
+            rtpInfo.infoIsNew         = False;  // for next time
+
+            return npt;
+        }
+        else {
+            // Use the precomputed "fNPT_PTS_Offset" to compute the NPT from the PTS:
+            if(fNPT_PTS_Offset == 0.0)
+                return 0.0;  // error: The "rtpInfo" structure was apparently never filled in
+            return (double)(ptsDouble * scale() + fNPT_PTS_Offset);
+        }
+    }
+}
+
+void MediaSubsession ::setAttribute(char const *name, char const *value, Boolean valueIsHexadecimal) {
+    // Replace any existing attribute record with this name (except that the 'valueIsHexadecimal'
+    // property will be inherited from it, if it exists).
+    SDPAttribute *oldAttr = (SDPAttribute *)fAttributeTable->Lookup(name);
+    if(oldAttr != NULL) {
+        valueIsHexadecimal = oldAttr->valueIsHexadecimal();
+        fAttributeTable->Remove(name);
+        delete oldAttr;
+    }
+
+    SDPAttribute *newAttr = new SDPAttribute(value, valueIsHexadecimal);
+    (void)fAttributeTable->Add(name, newAttr);
+}
+
+Boolean MediaSubsession::parseSDPLine_c(char const *sdpLine) {
+    // Check for "c=IN IP4 <connection-endpoint>"
+    // or "c=IN IP4 <connection-endpoint>/<ttl+numAddresses>"
+    // (ditto for "c=IN IP6 ...")
+    // (Later, do something with <ttl+numAddresses> also #####)
+    if(parseStringValue(sdpLine, "c=IN IP4 %[^/\r\n]", fConnectionEndpointName)) {
+        fConnectionEndpointNameAddressFamily = AF_INET;
+        return True;
+    }
+    else if(parseStringValue(sdpLine, "c=IN IP6 %[^/\r\n]", fConnectionEndpointName)) {
+        fConnectionEndpointNameAddressFamily = AF_INET6;
+        return True;
+    }
+
+    return False;
+}
+
+Boolean MediaSubsession::parseSDPLine_b(char const *sdpLine) {
+    // Check for "b=<bwtype>:<bandwidth>" line
+    // RTP applications are expected to use bwtype="AS"
+    return sscanf(sdpLine, "b=AS:%u", &fBandwidth) == 1;
+}
+
+Boolean MediaSubsession::parseSDPAttribute_rtpmap(char const *sdpLine) {
+    // Check for a "a=rtpmap:<fmt> <codec>/<freq>" line:
+    // (Also check without the "/<freq>"; RealNetworks omits this)
+    // Also check for a trailing "/<numChannels>".
+    Boolean parseSuccess = False;
+
+    unsigned rtpmapPayloadFormat;
+    char    *codecName             = strDupSize(sdpLine);  // ensures we have enough space
+    unsigned rtpTimestampFrequency = 0;
+    unsigned numChannels           = 1;
+    if(sscanf(sdpLine, "a=rtpmap: %u %[^/]/%u/%u", &rtpmapPayloadFormat, codecName, &rtpTimestampFrequency, &numChannels) == 4
+       || sscanf(sdpLine, "a=rtpmap: %u %[^/]/%u", &rtpmapPayloadFormat, codecName, &rtpTimestampFrequency) == 3
+       || sscanf(sdpLine, "a=rtpmap: %u %s", &rtpmapPayloadFormat, codecName) == 2) {
+        parseSuccess = True;
+        if(rtpmapPayloadFormat == fRTPPayloadFormat) {
+            // This "rtpmap" matches our payload format, so set our
+            // codec name and timestamp frequency:
+            // (First, make sure the codec name is upper case)
+            {
+                Locale l("POSIX");
+                for(char *p = codecName; *p != '\0'; ++p)
+                    *p = toupper(*p);
+            }
+            delete[] fCodecName;
+            fCodecName             = strDup(codecName);
+            fRTPTimestampFrequency = rtpTimestampFrequency;
+            fNumChannels           = numChannels;
+        }
+    }
+    delete[] codecName;
+
+    return parseSuccess;
+}
+
+Boolean MediaSubsession::parseSDPAttribute_rtcpmux(char const *sdpLine) {
+    if(strncmp(sdpLine, "a=rtcp-mux", 10) == 0) {
+        fMultiplexRTCPWithRTP = True;
+        return True;
+    }
+
+    return False;
+}
+
+Boolean MediaSubsession::parseSDPAttribute_control(char const *sdpLine) {
+    // Check for a "a=control:<control-path>" line:
+    return parseStringValue(sdpLine, "a=control: %s", fControlPath);
+}
+
+Boolean MediaSubsession::parseSDPAttribute_range(char const *sdpLine) {
+    // Check for a "a=range:npt=<startTime>-<endTime>" line:
+    // (Later handle other kinds of "a=range" attributes also???#####)
+    Boolean parseSuccess = False;
+
+    double playStartTime;
+    double playEndTime;
+    if(parseRangeAttribute(sdpLine, playStartTime, playEndTime)) {
+        parseSuccess = True;
+        if(playStartTime > fPlayStartTime) {
+            fPlayStartTime = playStartTime;
+            if(playStartTime > fParent.playStartTime()) {
+                fParent.playStartTime() = playStartTime;
+            }
+        }
+        if(playEndTime > fPlayEndTime) {
+            fPlayEndTime = playEndTime;
+            if(playEndTime > fParent.playEndTime()) {
+                fParent.playEndTime() = playEndTime;
+            }
+        }
+    }
+    else if(parseRangeAttribute(sdpLine, _absStartTime(), _absEndTime())) {
+        parseSuccess = True;
+    }
+
+    return parseSuccess;
+}
+
+Boolean MediaSubsession::parseSDPAttribute_fmtp(char const *sdpLine) {
+    // Check for a "a=fmtp:" line:
+    // Later: Check that payload format number matches; #####
+    do {
+        if(strncmp(sdpLine, "a=fmtp:", 7) != 0)
+            break;
+        sdpLine += 7;
+        while(isdigit(*sdpLine))
+            ++sdpLine;
+
+        // The remaining "sdpLine" should be a sequence of
+        //     <name>=<value>;
+        // or
+        //     <name>;
+        // parameter assignments.  Look at each of these.
+        unsigned const sdpLineLen = strlen(sdpLine);
+        char          *nameStr    = new char[sdpLineLen + 1];
+        char          *valueStr   = new char[sdpLineLen + 1];
+
+        while(*sdpLine != '\0' && *sdpLine != '\r' && *sdpLine != '\n') {
+            int sscanfResult = sscanf(sdpLine, " %[^=; \t\r\n] = %[^; \t\r\n]", nameStr, valueStr);
+            if(sscanfResult >= 1) {
+                // <name> or <name>=<value>
+                // Convert <name> to lower-case, to ease comparison:
+                Locale l("POSIX");
+                for(char *c = nameStr; *c != '\0'; ++c)
+                    *c = tolower(*c);
+
+                if(sscanfResult == 1) {
+                    // <name>
+                    setAttribute(nameStr);
+                }
+                else {
+                    // <name>=<value>
+                    setAttribute(nameStr, valueStr);
+                }
+            }
+
+            // Move to the next parameter assignment string:
+            while(*sdpLine != '\0' && *sdpLine != '\r' && *sdpLine != '\n' && *sdpLine != ';')
+                ++sdpLine;
+            while(*sdpLine == ';')
+                ++sdpLine;
+        }
+        delete[] nameStr;
+        delete[] valueStr;
+        return True;
+    } while(0);
+
+    return False;
+}
+
+Boolean MediaSubsession ::parseSDPAttribute_source_filter(char const *sdpLine) {
+    return parseSourceFilterAttribute(sdpLine, fSourceFilterAddr);
+}
+
+Boolean MediaSubsession::parseSDPAttribute_x_dimensions(char const *sdpLine) {
+    // Check for a "a=x-dimensions:<width>,<height>" line:
+    Boolean parseSuccess = False;
+
+    int width, height;
+    if(sscanf(sdpLine, "a=x-dimensions:%d,%d", &width, &height) == 2) {
+        parseSuccess = True;
+        fVideoWidth  = (unsigned short)width;
+        fVideoHeight = (unsigned short)height;
+    }
+
+    return parseSuccess;
+}
+
+Boolean MediaSubsession::parseSDPAttribute_framerate(char const *sdpLine) {
+    // Check for a "a=framerate: <fps>" or "a=x-framerate: <fps>" line:
+    Boolean parseSuccess = False;
+
+    float frate;
+    int   rate;
+    if(sscanf(sdpLine, "a=framerate: %f", &frate) == 1 || sscanf(sdpLine, "a=framerate:%f", &frate) == 1) {
+        parseSuccess = True;
+        fVideoFPS    = (unsigned)frate;
+    }
+    else if(sscanf(sdpLine, "a=x-framerate: %d", &rate) == 1) {
+        parseSuccess = True;
+        fVideoFPS    = (unsigned)rate;
+    }
+
+    return parseSuccess;
+}
+
+Boolean MediaSubsession::parseSDPAttribute_key_mgmt(char const *sdpLine) {
+    MIKEYState *newMIKEYState = parseSDPAttribute_key_mgmtToMIKEY(sdpLine);
+    if(newMIKEYState == NULL)
+        return False;
+
+    delete fCrypto;
+    delete fMIKEYState;
+    fMIKEYState = newMIKEYState;
+    fCrypto     = new SRTPCryptographicContext(*fMIKEYState);
+
+    return True;
+}
+
+Boolean MediaSubsession::createSourceObjects(int useSpecialRTPoffset) {
+    do {
+        // First, check "fProtocolName"
+        if(strcmp(fProtocolName, "UDP") == 0) {
+            // A UDP-packetized stream (*not* a RTP stream)
+            fReadSource = BasicUDPSource::createNew(env(), fRTPSocket);
+            fRTPSource  = NULL;  // Note!
+
+            if(strcmp(fCodecName, "MP2T") == 0) {  // MPEG-2 Transport Stream
+                fReadSource = MPEG2TransportStreamFramer::createNew(env(), fReadSource);
+                // this sets "durationInMicroseconds" correctly, based on the PCR values
+            }
+        }
+        else {
+            // Check "fCodecName" against the set of codecs that we support,
+            // and create our RTP source accordingly
+            // (Later make this code more efficient, as this set grows #####)
+            // (Also, add more fmts that can be implemented by SimpleRTPSource#####)
+            Boolean createSimpleRTPSource = False;  // by default; can be changed below
+            Boolean doNormalMBitRule      = False;  // default behavior if "createSimpleRTPSource" is True
+            if(strcmp(fCodecName, "QCELP") == 0) {  // QCELP audio
+                fReadSource = QCELPAudioRTPSource::createNew(env(), fRTPSocket, fRTPSource, fRTPPayloadFormat, fRTPTimestampFrequency);
+                // Note that fReadSource will differ from fRTPSource in this case
+            }
+            else if(strcmp(fCodecName, "AMR") == 0) {  // AMR audio (narrowband)
+                fReadSource = AMRAudioRTPSource::createNew(env(), fRTPSocket, fRTPSource, fRTPPayloadFormat, False /*isWideband*/, fNumChannels,
+                                                           attrVal_bool("octet-align"), attrVal_unsigned("interleaving"), attrVal_bool("robust-sorting"),
+                                                           attrVal_bool("crc"));
+                // Note that fReadSource will differ from fRTPSource in this case
+            }
+            else if(strcmp(fCodecName, "AMR-WB") == 0) {  // AMR audio (wideband)
+                fReadSource = AMRAudioRTPSource::createNew(env(), fRTPSocket, fRTPSource, fRTPPayloadFormat, True /*isWideband*/, fNumChannels,
+                                                           attrVal_bool("octet-align"), attrVal_unsigned("interleaving"), attrVal_bool("robust-sorting"),
+                                                           attrVal_bool("crc"));
+                // Note that fReadSource will differ from fRTPSource in this case
+            }
+            else if(strcmp(fCodecName, "MPA") == 0) {  // MPEG-1 or 2 audio
+                fReadSource = fRTPSource = MPEG1or2AudioRTPSource::createNew(env(), fRTPSocket, fRTPPayloadFormat, fRTPTimestampFrequency);
+            }
+            else if(strcmp(fCodecName, "MPA-ROBUST") == 0) {  // robust MP3 audio
+                fReadSource = fRTPSource = MP3ADURTPSource::createNew(env(), fRTPSocket, fRTPPayloadFormat, fRTPTimestampFrequency);
+                if(fRTPSource == NULL)
+                    break;
+
+                if(!fReceiveRawMP3ADUs) {
+                    // Add a filter that deinterleaves the ADUs after depacketizing them:
+                    MP3ADUdeinterleaver *deinterleaver = MP3ADUdeinterleaver::createNew(env(), fRTPSource);
+                    if(deinterleaver == NULL)
+                        break;
+
+                    // Add another filter that converts these ADUs to MP3 frames:
+                    fReadSource = MP3FromADUSource::createNew(env(), deinterleaver);
+                }
+            }
+            else if(strcmp(fCodecName, "X-MP3-DRAFT-00") == 0) {
+                // a non-standard variant of "MPA-ROBUST" used by RealNetworks
+                // (one 'ADU'ized MP3 frame per packet; no headers)
+                fRTPSource = SimpleRTPSource::createNew(env(), fRTPSocket, fRTPPayloadFormat, fRTPTimestampFrequency, "audio/MPA-ROBUST" /*hack*/);
+                if(fRTPSource == NULL)
+                    break;
+
+                // Add a filter that converts these ADUs to MP3 frames:
+                fReadSource = MP3FromADUSource::createNew(env(), fRTPSource, False /*no ADU header*/);
+            }
+            else if(strcmp(fCodecName, "MP4A-LATM") == 0) {  // MPEG-4 LATM audio
+                fReadSource = fRTPSource = MPEG4LATMAudioRTPSource::createNew(env(), fRTPSocket, fRTPPayloadFormat, fRTPTimestampFrequency);
+            }
+            else if(strcmp(fCodecName, "VORBIS") == 0) {  // Vorbis audio
+                fReadSource = fRTPSource = VorbisAudioRTPSource::createNew(env(), fRTPSocket, fRTPPayloadFormat, fRTPTimestampFrequency);
+            }
+            else if(strcmp(fCodecName, "THEORA") == 0) {  // Theora video
+                fReadSource = fRTPSource = TheoraVideoRTPSource::createNew(env(), fRTPSocket, fRTPPayloadFormat);
+            }
+            else if(strcmp(fCodecName, "RAW") == 0) {  // Uncompressed raw video (RFC 4175)
+                fReadSource = fRTPSource = RawVideoRTPSource::createNew(env(), fRTPSocket, fRTPPayloadFormat, fRTPTimestampFrequency);
+            }
+            else if(strcmp(fCodecName, "VP8") == 0) {  // VP8 video
+                fReadSource = fRTPSource = VP8VideoRTPSource::createNew(env(), fRTPSocket, fRTPPayloadFormat, fRTPTimestampFrequency);
+            }
+            else if(strcmp(fCodecName, "VP9") == 0) {  // VP9 video
+                fReadSource = fRTPSource = VP9VideoRTPSource::createNew(env(), fRTPSocket, fRTPPayloadFormat, fRTPTimestampFrequency);
+            }
+            else if(strcmp(fCodecName, "AC3") == 0 || strcmp(fCodecName, "EAC3") == 0) {  // AC3 audio
+                fReadSource = fRTPSource = AC3AudioRTPSource::createNew(env(), fRTPSocket, fRTPPayloadFormat, fRTPTimestampFrequency);
+            }
+            else if(strcmp(fCodecName, "MP4V-ES") == 0) {  // MPEG-4 Elementary Stream video
+                fReadSource = fRTPSource = MPEG4ESVideoRTPSource::createNew(env(), fRTPSocket, fRTPPayloadFormat, fRTPTimestampFrequency);
+            }
+            else if(strcmp(fCodecName, "MPEG4-GENERIC") == 0) {
+                fReadSource = fRTPSource =
+                    MPEG4GenericRTPSource::createNew(env(), fRTPSocket, fRTPPayloadFormat, fRTPTimestampFrequency, fMediumName, attrVal_strToLower("mode"),
+                                                     attrVal_unsigned("sizelength"), attrVal_unsigned("indexlength"), attrVal_unsigned("indexdeltalength"));
+            }
+            else if(strcmp(fCodecName, "MPV") == 0) {  // MPEG-1 or 2 video
+                fReadSource = fRTPSource = MPEG1or2VideoRTPSource::createNew(env(), fRTPSocket, fRTPPayloadFormat, fRTPTimestampFrequency);
+            }
+            else if(strcmp(fCodecName, "MP2T") == 0) {  // MPEG-2 Transport Stream
+                fRTPSource  = SimpleRTPSource::createNew(env(), fRTPSocket, fRTPPayloadFormat, fRTPTimestampFrequency, "video/MP2T", 0, False);
+                fReadSource = MPEG2TransportStreamFramer::createNew(env(), fRTPSource);
+                // this sets "durationInMicroseconds" correctly, based on the PCR values
+            }
+            else if(strcmp(fCodecName, "H261") == 0) {  // H.261
+                fReadSource = fRTPSource = H261VideoRTPSource::createNew(env(), fRTPSocket, fRTPPayloadFormat, fRTPTimestampFrequency);
+            }
+            else if(strcmp(fCodecName, "H263-1998") == 0 || strcmp(fCodecName, "H263-2000") == 0) {  // H.263+
+                fReadSource = fRTPSource = H263plusVideoRTPSource::createNew(env(), fRTPSocket, fRTPPayloadFormat, fRTPTimestampFrequency);
+            }
+            else if(strcmp(fCodecName, "H264") == 0) {
+                fReadSource = fRTPSource = H264VideoRTPSource::createNew(env(), fRTPSocket, fRTPPayloadFormat, fRTPTimestampFrequency);
+            }
+            else if(strcmp(fCodecName, "H265") == 0) {
+                Boolean expectDONFields = attrVal_unsigned("sprop-depack-buf-nalus") > 0;
+                fReadSource = fRTPSource = H265VideoRTPSource::createNew(env(), fRTPSocket, fRTPPayloadFormat, expectDONFields, fRTPTimestampFrequency);
+            }
+            else if(strcmp(fCodecName, "DV") == 0) {
+                fReadSource = fRTPSource = DVVideoRTPSource::createNew(env(), fRTPSocket, fRTPPayloadFormat, fRTPTimestampFrequency);
+            }
+            else if(strcmp(fCodecName, "JPEG") == 0) {  // motion JPEG
+                if(fReceiveRawJPEGFrames) {
+                    // Special case (used when proxying JPEG/RTP streams): Receive each JPEG/RTP packet, including the special RTP headers:
+                    fReadSource = fRTPSource = SimpleRTPSource::createNew(env(), fRTPSocket, fRTPPayloadFormat, fRTPTimestampFrequency, "video/JPEG",
+                                                                          0 /*special offset*/, False /*doNormalMBitRule => ignore the 'M' bit*/);
+                }
+                else {
+                    // Normal case: Receive each JPEG frame as a complete, displayable JPEG image:
+                    fReadSource = fRTPSource =
+                        JPEGVideoRTPSource::createNew(env(), fRTPSocket, fRTPPayloadFormat, fRTPTimestampFrequency, videoWidth(), videoHeight());
+                }
+            }
+            else if(strcmp(fCodecName, "JPEG2000") == 0) {  // JPEG 2000 video
+                fReadSource = fRTPSource =
+                    JPEG2000VideoRTPSource::createNew(env(), fRTPSocket, fRTPPayloadFormat, fRTPTimestampFrequency, attrVal_str("sampling"));
+            }
+            else if(strcmp(fCodecName, "X-QT") == 0 || strcmp(fCodecName, "X-QUICKTIME") == 0) {
+                // Generic QuickTime streams, as defined in
+                // <http://developer.apple.com/quicktime/icefloe/dispatch026.html>
+                char *mimeType = new char[strlen(mediumName()) + strlen(codecName()) + 2];
+                sprintf(mimeType, "%s/%s", mediumName(), codecName());
+                fReadSource = fRTPSource = QuickTimeGenericRTPSource::createNew(env(), fRTPSocket, fRTPPayloadFormat, fRTPTimestampFrequency, mimeType);
+                delete[] mimeType;
+            }
+            else if(strcmp(fCodecName, "PCMU") == 0                   // PCM u-law audio
+                    || strcmp(fCodecName, "GSM") == 0                 // GSM audio
+                    || strcmp(fCodecName, "DVI4") == 0                // DVI4 (IMA ADPCM) audio
+                    || strcmp(fCodecName, "PCMA") == 0                // PCM a-law audio
+                    || strcmp(fCodecName, "MP1S") == 0                // MPEG-1 System Stream
+                    || strcmp(fCodecName, "MP2P") == 0                // MPEG-2 Program Stream
+                    || strcmp(fCodecName, "L8") == 0                  // 8-bit linear audio
+                    || strcmp(fCodecName, "L16") == 0                 // 16-bit linear audio
+                    || strcmp(fCodecName, "L20") == 0                 // 20-bit linear audio (RFC 3190)
+                    || strcmp(fCodecName, "L24") == 0                 // 24-bit linear audio (RFC 3190)
+                    || strcmp(fCodecName, "G722") == 0                // G.722 audio (RFC 3551)
+                    || strcmp(fCodecName, "G726-16") == 0             // G.726, 16 kbps
+                    || strcmp(fCodecName, "G726-24") == 0             // G.726, 24 kbps
+                    || strcmp(fCodecName, "G726-32") == 0             // G.726, 32 kbps
+                    || strcmp(fCodecName, "G726-40") == 0             // G.726, 40 kbps
+                    || strcmp(fCodecName, "SPEEX") == 0               // SPEEX audio
+                    || strcmp(fCodecName, "ILBC") == 0                // iLBC audio
+                    || strcmp(fCodecName, "OPUS") == 0                // Opus audio
+                    || strcmp(fCodecName, "T140") == 0                // T.140 text (RFC 4103)
+                    || strcmp(fCodecName, "DAT12") == 0               // 12-bit nonlinear audio (RFC 3190)
+                    || strcmp(fCodecName, "VND.ONVIF.METADATA") == 0  // 'ONVIF' 'metadata' (a XML document)
+                    || strcmp(fCodecName, "OB_FMT_Y16") == 0          // orbbec stream
+                    || strcmp(fCodecName, "OB_FMT_Y8") == 0           // orbbec stream
+                    || strcmp(fCodecName, "OB_FMT_Y10") == 0          // orbbec stream
+                    || strcmp(fCodecName, "OB_FMT_RVL") == 0          // orbbec stream
+                    || strcmp(fCodecName, "OB_FMT_MJPEG") == 0        // orbbec stream
+                    || strcmp(fCodecName, "YUYV") == 0) {
+                createSimpleRTPSource = True;
+                useSpecialRTPoffset   = 0;
+                if(strcmp(fCodecName, "VND.ONVIF.METADATA") == 0 || strcmp(fCodecName, "OB_FMT_Y16") == 0 || strcmp(fCodecName, "OB_FMT_Y8") == 0
+                   || strcmp(fCodecName, "YUYV") == 0 || strcmp(fCodecName, "OB_FMT_Y10") == 0 || strcmp(fCodecName, "OB_FMT_RVL") == 0
+                   || strcmp(fCodecName, "OB_FMT_MJPEG") == 0) {
+                    // This RTP payload format uses the RTP "M" bit to indicate the end of the content (a XML document):
+                    doNormalMBitRule = True;
+                }
+            }
+            else if(useSpecialRTPoffset >= 0) {
+                // We don't know this RTP payload format, but try to receive
+                // it using a 'SimpleRTPSource' with the specified header offset:
+                createSimpleRTPSource = True;
+            }
+            else {
+                env().setResultMsg("RTP payload format unknown or not supported");
+                break;
+            }
+
+            if(createSimpleRTPSource) {
+                char *mimeType = new char[strlen(mediumName()) + strlen(codecName()) + 2];
+                sprintf(mimeType, "%s/%s", mediumName(), codecName());
+                fReadSource = fRTPSource = SimpleRTPSource::createNew(env(), fRTPSocket, fRTPPayloadFormat, fRTPTimestampFrequency, mimeType,
+                                                                      (unsigned)useSpecialRTPoffset, doNormalMBitRule);
+                delete[] mimeType;
+            }
+        }
+
+        return True;
+    } while(0);
+
+    return False;  // an error occurred
+}
+
+////////// SDPAttribute implementation //////////
+
+SDPAttribute::SDPAttribute(char const *strValue, Boolean valueIsHexadecimal)
+    : fStrValue(strDup(strValue)), fStrValueToLower(NULL), fValueIsHexadecimal(valueIsHexadecimal) {
+    if(fStrValue == NULL) {
+        // No value was given for this attribute, so consider it to be a Boolean, with value True:
+        fIntValue = 1;
+    }
+    else {
+        // Create a 'tolower' version of "fStrValue", in case it's needed:
+        Locale l("POSIX");
+        size_t strSize;
+
+        fStrValueToLower = strDupSize(fStrValue, strSize);
+        for(unsigned i = 0; i < strSize - 1; ++i)
+            fStrValueToLower[i] = tolower(fStrValue[i]);
+        fStrValueToLower[strSize - 1] = '\0';
+
+        // Try to parse "fStrValueToLower" as an integer.  If we can't, assume an integer value of 0:
+        if(sscanf(fStrValueToLower, valueIsHexadecimal ? "%x" : "%d", &fIntValue) != 1) {
+            fIntValue = 0;
+        }
+    }
+}
+
+SDPAttribute::~SDPAttribute() {
+    delete[] fStrValue;
+    delete[] fStrValueToLower;
+}
diff --git a/3rdparty/live555/src/liveMedia/MediaSink.cpp b/3rdparty/live555/src/liveMedia/MediaSink.cpp
new file mode 100644
index 00000000..7f96b0d2
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/MediaSink.cpp
@@ -0,0 +1,220 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// Media Sinks
+// Implementation
+
+#include "MediaSink.hh"
+#include "GroupsockHelper.hh"
+#include <string.h>
+
+////////// MediaSink //////////
+
+MediaSink::MediaSink(UsageEnvironment &env) : Medium(env), fSource(NULL) {}
+
+MediaSink::~MediaSink() {
+    stopPlaying();
+}
+
+Boolean MediaSink::isSink() const {
+    return True;
+}
+
+Boolean MediaSink::lookupByName(UsageEnvironment &env, char const *sinkName, MediaSink *&resultSink) {
+    resultSink = NULL;  // unless we succeed
+
+    Medium *medium;
+    if(!Medium::lookupByName(env, sinkName, medium))
+        return False;
+
+    if(!medium->isSink()) {
+        env.setResultMsg(sinkName, " is not a media sink");
+        return False;
+    }
+
+    resultSink = (MediaSink *)medium;
+    return True;
+}
+
+Boolean MediaSink::sourceIsCompatibleWithUs(MediaSource &source) {
+    // We currently support only framed sources.
+    return source.isFramedSource();
+}
+
+Boolean MediaSink::startPlaying(MediaSource &source, afterPlayingFunc *afterFunc, void *afterClientData) {
+    // Make sure we're not already being played:
+    if(fSource != NULL) {
+        envir().setResultMsg("This sink is already being played");
+        return False;
+    }
+
+    // Make sure our source is compatible:
+    if(!sourceIsCompatibleWithUs(source)) {
+        envir().setResultMsg("MediaSink::startPlaying(): source is not compatible!");
+        return False;
+    }
+    fSource = (FramedSource *)&source;
+
+    fAfterFunc       = afterFunc;
+    fAfterClientData = afterClientData;
+    return continuePlaying();
+}
+
+void MediaSink::stopPlaying() {
+    // First, tell the source that we're no longer interested:
+    if(fSource != NULL)
+        fSource->stopGettingFrames();
+
+    // Cancel any pending tasks:
+    envir().taskScheduler().unscheduleDelayedTask(nextTask());
+
+    fSource    = NULL;  // indicates that we can be played again
+    fAfterFunc = NULL;
+}
+
+void MediaSink::onSourceClosure(void *clientData) {
+    MediaSink *sink = (MediaSink *)clientData;
+    sink->onSourceClosure();
+}
+
+void MediaSink::onSourceClosure() {
+    // Cancel any pending tasks:
+    envir().taskScheduler().unscheduleDelayedTask(nextTask());
+
+    fSource = NULL;  // indicates that we can be played again
+    if(fAfterFunc != NULL) {
+        (*fAfterFunc)(fAfterClientData);
+    }
+}
+
+Boolean MediaSink::isRTPSink() const {
+    return False;  // default implementation
+}
+
+////////// OutPacketBuffer //////////
+
+unsigned OutPacketBuffer::maxSize = 60000;  // by default
+
+OutPacketBuffer ::OutPacketBuffer(unsigned preferredPacketSize, unsigned maxPacketSize, unsigned maxBufferSize)
+    : fPreferred(preferredPacketSize), fMax(maxPacketSize), fOverflowDataSize(0) {
+    if(maxBufferSize == 0)
+        maxBufferSize = maxSize;
+    unsigned maxNumPackets = (maxBufferSize + (maxPacketSize - 1)) / maxPacketSize;
+    fLimit                 = maxNumPackets * maxPacketSize;
+    fBuf                   = new unsigned char[fLimit];
+    resetPacketStart();
+    resetOffset();
+    resetOverflowData();
+}
+
+OutPacketBuffer::~OutPacketBuffer() {
+    delete[] fBuf;
+}
+
+void OutPacketBuffer::enqueue(unsigned char const *from, unsigned numBytes) {
+    if(numBytes > totalBytesAvailable()) {
+#ifdef DEBUG
+        fprintf(stderr, "OutPacketBuffer::enqueue() warning: %d > %d\n", numBytes, totalBytesAvailable());
+#endif
+        numBytes = totalBytesAvailable();
+    }
+
+    if(curPtr() != from)
+        memmove(curPtr(), from, numBytes);
+    increment(numBytes);
+}
+
+void OutPacketBuffer::enqueueWord(u_int32_t word) {
+    u_int32_t nWord = htonl(word);
+    enqueue((unsigned char *)&nWord, 4);
+}
+
+void OutPacketBuffer::insert(unsigned char const *from, unsigned numBytes, unsigned toPosition) {
+    unsigned realToPosition = fPacketStart + toPosition;
+    if(realToPosition + numBytes > fLimit) {
+        if(realToPosition > fLimit)
+            return;  // we can't do this
+        numBytes = fLimit - realToPosition;
+    }
+
+    memmove(&fBuf[realToPosition], from, numBytes);
+    if(toPosition + numBytes > fCurOffset) {
+        fCurOffset = toPosition + numBytes;
+    }
+}
+
+void OutPacketBuffer::insertWord(u_int32_t word, unsigned toPosition) {
+    u_int32_t nWord = htonl(word);
+    insert((unsigned char *)&nWord, 4, toPosition);
+}
+
+void OutPacketBuffer::extract(unsigned char *to, unsigned numBytes, unsigned fromPosition) {
+    unsigned realFromPosition = fPacketStart + fromPosition;
+    if(realFromPosition + numBytes > fLimit) {  // sanity check
+        if(realFromPosition > fLimit)
+            return;  // we can't do this
+        numBytes = fLimit - realFromPosition;
+    }
+
+    memmove(to, &fBuf[realFromPosition], numBytes);
+}
+
+u_int32_t OutPacketBuffer::extractWord(unsigned fromPosition) {
+    u_int32_t nWord;
+    extract((unsigned char *)&nWord, 4, fromPosition);
+    return ntohl(nWord);
+}
+
+void OutPacketBuffer::skipBytes(unsigned numBytes) {
+    if(numBytes > totalBytesAvailable()) {
+        numBytes = totalBytesAvailable();
+    }
+
+    increment(numBytes);
+}
+
+void OutPacketBuffer ::setOverflowData(unsigned overflowDataOffset, unsigned overflowDataSize, struct timeval const &presentationTime,
+                                       unsigned durationInMicroseconds) {
+    fOverflowDataOffset             = overflowDataOffset;
+    fOverflowDataSize               = overflowDataSize;
+    fOverflowPresentationTime       = presentationTime;
+    fOverflowDurationInMicroseconds = durationInMicroseconds;
+}
+
+void OutPacketBuffer::useOverflowData() {
+    enqueue(&fBuf[fPacketStart + fOverflowDataOffset], fOverflowDataSize);
+    fCurOffset -= fOverflowDataSize;  // undoes increment performed by "enqueue"
+    resetOverflowData();
+}
+
+void OutPacketBuffer::adjustPacketStart(unsigned numBytes) {
+    fPacketStart += numBytes;
+    if(fOverflowDataOffset >= numBytes) {
+        fOverflowDataOffset -= numBytes;
+    }
+    else {
+        fOverflowDataOffset = 0;
+        fOverflowDataSize   = 0;  // an error otherwise
+    }
+}
+
+void OutPacketBuffer::resetPacketStart() {
+    if(fOverflowDataSize > 0) {
+        fOverflowDataOffset += fPacketStart;
+    }
+    fPacketStart = 0;
+}
diff --git a/3rdparty/live555/src/liveMedia/MediaSource.cpp b/3rdparty/live555/src/liveMedia/MediaSource.cpp
new file mode 100644
index 00000000..cc0ced71
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/MediaSource.cpp
@@ -0,0 +1,87 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// Media Sources
+// Implementation
+
+#include "MediaSource.hh"
+
+////////// MediaSource //////////
+
+MediaSource::MediaSource(UsageEnvironment &env) : Medium(env) {}
+
+MediaSource::~MediaSource() {}
+
+Boolean MediaSource::isSource() const {
+    return True;
+}
+
+char const *MediaSource::MIMEtype() const {
+    return "application/OCTET-STREAM";  // default type
+}
+
+Boolean MediaSource::isFramedSource() const {
+    return False;  // default implementation
+}
+Boolean MediaSource::isRTPSource() const {
+    return False;  // default implementation
+}
+Boolean MediaSource::isMPEG1or2VideoStreamFramer() const {
+    return False;  // default implementation
+}
+Boolean MediaSource::isMPEG4VideoStreamFramer() const {
+    return False;  // default implementation
+}
+Boolean MediaSource::isH264VideoStreamFramer() const {
+    return False;  // default implementation
+}
+Boolean MediaSource::isH265VideoStreamFramer() const {
+    return False;  // default implementation
+}
+Boolean MediaSource::isDVVideoStreamFramer() const {
+    return False;  // default implementation
+}
+Boolean MediaSource::isJPEGVideoSource() const {
+    return False;  // default implementation
+}
+Boolean MediaSource::isAMRAudioSource() const {
+    return False;  // default implementation
+}
+Boolean MediaSource::isMPEG2TransportStreamMultiplexor() const {
+    return False;  // default implementation
+}
+
+Boolean MediaSource::lookupByName(UsageEnvironment &env, char const *sourceName, MediaSource *&resultSource) {
+    resultSource = NULL;  // unless we succeed
+
+    Medium *medium;
+    if(!Medium::lookupByName(env, sourceName, medium))
+        return False;
+
+    if(!medium->isSource()) {
+        env.setResultMsg(sourceName, " is not a media source");
+        return False;
+    }
+
+    resultSource = (MediaSource *)medium;
+    return True;
+}
+
+void MediaSource::getAttributes() const {
+    // Default implementation
+    envir().setResultMsg("");
+}
diff --git a/3rdparty/live555/src/liveMedia/MultiFramedRTPSink.cpp b/3rdparty/live555/src/liveMedia/MultiFramedRTPSink.cpp
new file mode 100644
index 00000000..42cffe25
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/MultiFramedRTPSink.cpp
@@ -0,0 +1,432 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// RTP sink for a common kind of payload format: Those which pack multiple,
+// complete codec frames (as many as possible) into each RTP packet.
+// Implementation
+
+#include "MultiFramedRTPSink.hh"
+#include "GroupsockHelper.hh"
+
+////////// MultiFramedRTPSink //////////
+
+void MultiFramedRTPSink::setPacketSizes(unsigned preferredPacketSize, unsigned maxPacketSize) {
+    if(preferredPacketSize > maxPacketSize || preferredPacketSize == 0)
+        return;
+    // sanity check
+
+    delete fOutBuf;
+    fOutBuf           = new OutPacketBuffer(preferredPacketSize, maxPacketSize);
+    fOurMaxPacketSize = maxPacketSize;  // save value, in case subclasses need it
+}
+
+#ifndef RTP_PAYLOAD_MAX_SIZE
+#define RTP_PAYLOAD_MAX_SIZE 1452
+// Default max packet size (1500, minus allowance for IP, UDP headers)
+// (Also, make it a multiple of 4 bytes, just in case that matters.)
+#endif
+#ifndef RTP_PAYLOAD_PREFERRED_SIZE
+#define RTP_PAYLOAD_PREFERRED_SIZE ((RTP_PAYLOAD_MAX_SIZE) < 1000 ? (RTP_PAYLOAD_MAX_SIZE) : 1000)
+#endif
+
+MultiFramedRTPSink::MultiFramedRTPSink(UsageEnvironment &env, Groupsock *rtpGS, unsigned char rtpPayloadType, unsigned rtpTimestampFrequency,
+                                       char const *rtpPayloadFormatName, unsigned numChannels)
+    : RTPSink(env, rtpGS, rtpPayloadType, rtpTimestampFrequency, rtpPayloadFormatName, numChannels),
+      fOutBuf(NULL),
+      fCurFragmentationOffset(0),
+      fPreviousFrameEndedFragmentation(False),
+      fOnSendErrorFunc(NULL),
+      fOnSendErrorData(NULL) {
+    setPacketSizes((RTP_PAYLOAD_PREFERRED_SIZE), (RTP_PAYLOAD_MAX_SIZE));
+}
+
+MultiFramedRTPSink::~MultiFramedRTPSink() {
+    delete fOutBuf;
+}
+
+void MultiFramedRTPSink ::doSpecialFrameHandling(unsigned /*fragmentationOffset*/, unsigned char * /*frameStart*/, unsigned /*numBytesInFrame*/,
+                                                 struct timeval framePresentationTime, unsigned /*numRemainingBytes*/) {
+    // default implementation: If this is the first frame in the packet,
+    // use its presentationTime for the RTP timestamp:
+    if(isFirstFrameInPacket()) {
+        setTimestamp(framePresentationTime);
+    }
+}
+
+Boolean MultiFramedRTPSink::allowFragmentationAfterStart() const {
+    return False;  // by default
+}
+
+Boolean MultiFramedRTPSink::allowOtherFramesAfterLastFragment() const {
+    return False;  // by default
+}
+
+Boolean MultiFramedRTPSink ::frameCanAppearAfterPacketStart(unsigned char const * /*frameStart*/, unsigned /*numBytesInFrame*/) const {
+    return True;  // by default
+}
+
+unsigned MultiFramedRTPSink::specialHeaderSize() const {
+    // default implementation: Assume no special header:
+    return 0;
+}
+
+unsigned MultiFramedRTPSink::frameSpecificHeaderSize() const {
+    // default implementation: Assume no frame-specific header:
+    return 0;
+}
+
+unsigned MultiFramedRTPSink::computeOverflowForNewFrame(unsigned newFrameSize) const {
+    // default implementation: Just call numOverflowBytes()
+    return fOutBuf->numOverflowBytes(newFrameSize);
+}
+
+void MultiFramedRTPSink::setMarkerBit() {
+    unsigned rtpHdr = fOutBuf->extractWord(0);
+    rtpHdr |= 0x00800000;
+    fOutBuf->insertWord(rtpHdr, 0);
+}
+
+void MultiFramedRTPSink::setTimestamp(struct timeval framePresentationTime) {
+    // First, convert the presentation time to a 32-bit RTP timestamp:
+    fCurrentTimestamp = convertToRTPTimestamp(framePresentationTime);
+
+    // Then, insert it into the RTP packet:
+    fOutBuf->insertWord(fCurrentTimestamp, fTimestampPosition);
+}
+
+void MultiFramedRTPSink::setSpecialHeaderWord(unsigned word, unsigned wordPosition) {
+    fOutBuf->insertWord(word, fSpecialHeaderPosition + 4 * wordPosition);
+}
+
+void MultiFramedRTPSink::setSpecialHeaderBytes(unsigned char const *bytes, unsigned numBytes, unsigned bytePosition) {
+    fOutBuf->insert(bytes, numBytes, fSpecialHeaderPosition + bytePosition);
+}
+
+void MultiFramedRTPSink::setFrameSpecificHeaderWord(unsigned word, unsigned wordPosition) {
+    fOutBuf->insertWord(word, fCurFrameSpecificHeaderPosition + 4 * wordPosition);
+}
+
+void MultiFramedRTPSink::setFrameSpecificHeaderBytes(unsigned char const *bytes, unsigned numBytes, unsigned bytePosition) {
+    fOutBuf->insert(bytes, numBytes, fCurFrameSpecificHeaderPosition + bytePosition);
+}
+
+void MultiFramedRTPSink::setFramePadding(unsigned numPaddingBytes) {
+    if(numPaddingBytes > 0) {
+        // Add the padding bytes (with the last one being the padding size):
+        unsigned char paddingBuffer[255];  // max padding
+        memset(paddingBuffer, 0, numPaddingBytes);
+        paddingBuffer[numPaddingBytes - 1] = numPaddingBytes;
+        fOutBuf->enqueue(paddingBuffer, numPaddingBytes);
+
+        // Set the RTP padding bit:
+        unsigned rtpHdr = fOutBuf->extractWord(0);
+        rtpHdr |= 0x20000000;
+        fOutBuf->insertWord(rtpHdr, 0);
+    }
+}
+
+Boolean MultiFramedRTPSink::continuePlaying() {
+    // Send the first packet.
+    // (This will also schedule any future sends.)
+    buildAndSendPacket(True);
+    return True;
+}
+
+void MultiFramedRTPSink::stopPlaying() {
+    fOutBuf->resetPacketStart();
+    fOutBuf->resetOffset();
+    fOutBuf->resetOverflowData();
+
+    // Then call the default "stopPlaying()" function:
+    MediaSink::stopPlaying();
+}
+
+void MultiFramedRTPSink::buildAndSendPacket(Boolean isFirstPacket) {
+    nextTask()     = NULL;
+    fIsFirstPacket = isFirstPacket;
+
+    // Set up the RTP header:
+    unsigned rtpHdr = 0x80000000;  // RTP version 2; marker ('M') bit not set (by default; it can be set later)
+    rtpHdr |= (fRTPPayloadType << 16);
+    rtpHdr |= fSeqNo;  // sequence number
+    fOutBuf->enqueueWord(rtpHdr);
+
+    // Note where the RTP timestamp will go.
+    // (We can't fill this in until we start packing payload frames.)
+    fTimestampPosition = fOutBuf->curPacketSize();
+    fOutBuf->skipBytes(4);  // leave a hole for the timestamp
+
+    fOutBuf->enqueueWord(SSRC());
+
+    // Allow for a special, payload-format-specific header following the
+    // RTP header:
+    fSpecialHeaderPosition = fOutBuf->curPacketSize();
+    fSpecialHeaderSize     = specialHeaderSize();
+    fOutBuf->skipBytes(fSpecialHeaderSize);
+
+    // Begin packing as many (complete) frames into the packet as we can:
+    fTotalFrameSpecificHeaderSizes = 0;
+    fNoFramesLeft                  = False;
+    fNumFramesUsedSoFar            = 0;
+    packFrame();
+}
+
+void MultiFramedRTPSink::packFrame() {
+    // Get the next frame.
+
+    // First, skip over the space we'll use for any frame-specific header:
+    fCurFrameSpecificHeaderPosition = fOutBuf->curPacketSize();
+    fCurFrameSpecificHeaderSize     = frameSpecificHeaderSize();
+    fOutBuf->skipBytes(fCurFrameSpecificHeaderSize);
+    fTotalFrameSpecificHeaderSizes += fCurFrameSpecificHeaderSize;
+
+    // See if we have an overflow frame that was too big for the last pkt
+    if(fOutBuf->haveOverflowData()) {
+        // Use this frame before reading a new one from the source
+        unsigned       frameSize              = fOutBuf->overflowDataSize();
+        struct timeval presentationTime       = fOutBuf->overflowPresentationTime();
+        unsigned       durationInMicroseconds = fOutBuf->overflowDurationInMicroseconds();
+        fOutBuf->useOverflowData();
+
+        afterGettingFrame1(frameSize, 0, presentationTime, durationInMicroseconds);
+    }
+    else {
+        // Normal case: we need to read a new frame from the source
+        if(fSource == NULL)
+            return;
+        fSource->getNextFrame(fOutBuf->curPtr(), fOutBuf->totalBytesAvailable(), afterGettingFrame, this, ourHandleClosure, this);
+    }
+}
+
+void MultiFramedRTPSink ::afterGettingFrame(void *clientData, unsigned numBytesRead, unsigned numTruncatedBytes, struct timeval presentationTime,
+                                            unsigned durationInMicroseconds) {
+    MultiFramedRTPSink *sink = (MultiFramedRTPSink *)clientData;
+    sink->afterGettingFrame1(numBytesRead, numTruncatedBytes, presentationTime, durationInMicroseconds);
+}
+
+void MultiFramedRTPSink ::afterGettingFrame1(unsigned frameSize, unsigned numTruncatedBytes, struct timeval presentationTime, unsigned durationInMicroseconds) {
+    if(fIsFirstPacket) {
+        // Record the fact that we're starting to play now:
+        gettimeofday(&fNextSendTime, NULL);
+    }
+
+    fMostRecentPresentationTime = presentationTime;
+    if(fInitialPresentationTime.tv_sec == 0 && fInitialPresentationTime.tv_usec == 0) {
+        fInitialPresentationTime = presentationTime;
+    }
+
+    if(numTruncatedBytes > 0) {
+        unsigned const bufferSize = fOutBuf->totalBytesAvailable();
+        envir() << "MultiFramedRTPSink::afterGettingFrame1(): The input frame data was too large for our buffer size (" << bufferSize << ").  "
+                << numTruncatedBytes << " bytes of trailing data was dropped!  Correct this by increasing \"OutPacketBuffer::maxSize\" to at least "
+                << OutPacketBuffer::maxSize + numTruncatedBytes << ", *before* creating this 'RTPSink'.  (Current value is " << OutPacketBuffer::maxSize
+                << ".)\n";
+    }
+    unsigned curFragmentationOffset = fCurFragmentationOffset;
+    unsigned numFrameBytesToUse     = frameSize;
+    unsigned overflowBytes          = 0;
+
+    // If we have already packed one or more frames into this packet,
+    // check whether this new frame is eligible to be packed after them.
+    // (This is independent of whether the packet has enough room for this
+    // new frame; that check comes later.)
+    if(fNumFramesUsedSoFar > 0) {
+        if((fPreviousFrameEndedFragmentation && !allowOtherFramesAfterLastFragment()) || !frameCanAppearAfterPacketStart(fOutBuf->curPtr(), frameSize)) {
+            // Save away this frame for next time:
+            numFrameBytesToUse = 0;
+            fOutBuf->setOverflowData(fOutBuf->curPacketSize(), frameSize, presentationTime, durationInMicroseconds);
+        }
+    }
+    fPreviousFrameEndedFragmentation = False;
+
+    if(numFrameBytesToUse > 0) {
+        // Check whether this frame overflows the packet
+        if(fOutBuf->wouldOverflow(frameSize)) {
+            // Don't use this frame now; instead, save it as overflow data, and
+            // send it in the next packet instead.  However, if the frame is too
+            // big to fit in a packet by itself, then we need to fragment it (and
+            // use some of it in this packet, if the payload format permits this.)
+            if(isTooBigForAPacket(frameSize) && (fNumFramesUsedSoFar == 0 || allowFragmentationAfterStart())) {
+                // We need to fragment this frame, and use some of it now:
+                overflowBytes = computeOverflowForNewFrame(frameSize);
+                numFrameBytesToUse -= overflowBytes;
+                fCurFragmentationOffset += numFrameBytesToUse;
+            }
+            else {
+                // We don't use any of this frame now:
+                overflowBytes      = frameSize;
+                numFrameBytesToUse = 0;
+            }
+            fOutBuf->setOverflowData(fOutBuf->curPacketSize() + numFrameBytesToUse, overflowBytes, presentationTime, durationInMicroseconds);
+        }
+        else if(fCurFragmentationOffset > 0) {
+            // This is the last fragment of a frame that was fragmented over
+            // more than one packet.  Do any special handling for this case:
+            fCurFragmentationOffset          = 0;
+            fPreviousFrameEndedFragmentation = True;
+        }
+    }
+
+    if(numFrameBytesToUse == 0 && frameSize > 0) {
+        // Send our packet now, because we have filled it up:
+        sendPacketIfNecessary();
+    }
+    else {
+        // Use this frame in our outgoing packet:
+        unsigned char *frameStart = fOutBuf->curPtr();
+        fOutBuf->increment(numFrameBytesToUse);
+        // do this now, in case "doSpecialFrameHandling()" calls "setFramePadding()" to append padding bytes
+
+        // Here's where any payload format specific processing gets done:
+        doSpecialFrameHandling(curFragmentationOffset, frameStart, numFrameBytesToUse, presentationTime, overflowBytes);
+
+        ++fNumFramesUsedSoFar;
+
+        // Update the time at which the next packet should be sent, based
+        // on the duration of the frame that we just packed into it.
+        // However, if this frame has overflow data remaining, then don't
+        // count its duration yet.
+        if(overflowBytes == 0) {
+            fNextSendTime.tv_usec += durationInMicroseconds;
+            fNextSendTime.tv_sec += fNextSendTime.tv_usec / 1000000;
+            fNextSendTime.tv_usec %= 1000000;
+        }
+
+        // Send our packet now if (i) it's already at our preferred size, or
+        // (ii) (heuristic) another frame of the same size as the one we just
+        //      read would overflow the packet, or
+        // (iii) it contains the last fragment of a fragmented frame, and we
+        //      don't allow anything else to follow this or
+        // (iv) only one frame per packet is allowed:
+        if(fOutBuf->isPreferredSize() || fOutBuf->wouldOverflow(numFrameBytesToUse)
+           || (fPreviousFrameEndedFragmentation && !allowOtherFramesAfterLastFragment())
+           || !frameCanAppearAfterPacketStart(fOutBuf->curPtr() - frameSize, frameSize)) {
+            // The packet is ready to be sent now
+            sendPacketIfNecessary();
+        }
+        else {
+            // There's room for more frames; try getting another:
+            packFrame();
+        }
+    }
+}
+
+static unsigned const rtpHeaderSize = 12;
+
+Boolean MultiFramedRTPSink::isTooBigForAPacket(unsigned numBytes) const {
+    // Check whether a 'numBytes'-byte frame - together with a RTP header and
+    // (possible) special headers - would be too big for an output packet:
+    // (Later allow for RTP extension header!) #####
+    numBytes += rtpHeaderSize + specialHeaderSize() + frameSpecificHeaderSize();
+    return fOutBuf->isTooBigForAPacket(numBytes);
+}
+
+#define MAX_UDP_PACKET_SIZE 65536
+
+void MultiFramedRTPSink::sendPacketIfNecessary() {
+    if(fNumFramesUsedSoFar > 0) {
+        // Send the packet:
+#ifdef TEST_LOSS
+        if((our_random() % 10) != 0)  // simulate 10% packet loss #####
+#endif
+            if(fCrypto != NULL) {  // Encrypt/tag the data before sending it:
+#ifndef NO_OPENSSL
+                // Hack: Because the MKI + authentication tag at the end of the packet would
+                // overwrite any following (still to be sent) frame data, we can't encrypt/tag
+                // the packet in place.  Instead, we have to make a copy (on the stack) of
+                // the packet, before encrypting/tagging/sending it:
+                if(fOutBuf->curPacketSize() + SRTP_MKI_LENGTH + SRTP_AUTH_TAG_LENGTH > MAX_UDP_PACKET_SIZE) {
+                    fprintf(stderr, "MultiFramedRTPSink::sendPacketIfNecessary(): Fatal error: packet size %d is too large for SRTP\n",
+                            fOutBuf->curPacketSize());
+                    exit(1);
+                }
+                u_int8_t packet[MAX_UDP_PACKET_SIZE];
+                memcpy(packet, fOutBuf->packet(), fOutBuf->curPacketSize());
+                unsigned newPacketSize;
+
+                if(fCrypto->processOutgoingSRTPPacket(packet, fOutBuf->curPacketSize(), newPacketSize)) {
+                    if(!fRTPInterface.sendPacket(packet, newPacketSize)) {
+                        // if failure handler has been specified, call it
+                        if(fOnSendErrorFunc != NULL)
+                            (*fOnSendErrorFunc)(fOnSendErrorData);
+                    }
+                }
+#endif
+            }
+            else {  // unencrypted
+                if(!fRTPInterface.sendPacket(fOutBuf->packet(), fOutBuf->curPacketSize())) {
+                    // if failure handler has been specified, call it
+                    if(fOnSendErrorFunc != NULL)
+                        (*fOnSendErrorFunc)(fOnSendErrorData);
+                }
+            }
+        ++fPacketCount;
+        fTotalOctetCount += fOutBuf->curPacketSize();
+        fOctetCount += fOutBuf->curPacketSize() - rtpHeaderSize - fSpecialHeaderSize - fTotalFrameSpecificHeaderSizes;
+
+        ++fSeqNo;  // for next time
+    }
+
+    if(fOutBuf->haveOverflowData() && fOutBuf->totalBytesAvailable() > fOutBuf->totalBufferSize() / 2) {
+        // Efficiency hack: Reset the packet start pointer to just in front of
+        // the overflow data (allowing for the RTP header and special headers),
+        // so that we probably don't have to "memmove()" the overflow data
+        // into place when building the next packet:
+        unsigned newPacketStart = fOutBuf->curPacketSize() - (rtpHeaderSize + fSpecialHeaderSize + frameSpecificHeaderSize());
+        fOutBuf->adjustPacketStart(newPacketStart);
+    }
+    else {
+        // Normal case: Reset the packet start pointer back to the start:
+        fOutBuf->resetPacketStart();
+    }
+    fOutBuf->resetOffset();
+    fNumFramesUsedSoFar = 0;
+
+    if(fNoFramesLeft) {
+        // We're done:
+        onSourceClosure();
+    }
+    else {
+        // We have more frames left to send.  Figure out when the next frame
+        // is due to start playing, then make sure that we wait this long before
+        // sending the next packet.
+        struct timeval timeNow;
+        gettimeofday(&timeNow, NULL);
+        int     secsDiff     = fNextSendTime.tv_sec - timeNow.tv_sec;
+        int64_t uSecondsToGo = secsDiff * 1000000 + (fNextSendTime.tv_usec - timeNow.tv_usec);
+        if(uSecondsToGo < 0 || secsDiff < 0) {  // sanity check: Make sure that the time-to-delay is non-negative:
+            uSecondsToGo = 0;
+        }
+
+        // Delay this amount of time:
+        nextTask() = envir().taskScheduler().scheduleDelayedTask(uSecondsToGo, (TaskFunc *)sendNext, this);
+    }
+}
+
+// The following is called after each delay between packet sends:
+void MultiFramedRTPSink::sendNext(void *firstArg) {
+    MultiFramedRTPSink *sink = (MultiFramedRTPSink *)firstArg;
+    sink->buildAndSendPacket(False);
+}
+
+void MultiFramedRTPSink::ourHandleClosure(void *clientData) {
+    MultiFramedRTPSink *sink = (MultiFramedRTPSink *)clientData;
+    // There are no frames left, but we may have a partially built packet
+    //  to send
+    sink->fNoFramesLeft = True;
+    sink->sendPacketIfNecessary();
+}
diff --git a/3rdparty/live555/src/liveMedia/MultiFramedRTPSource.cpp b/3rdparty/live555/src/liveMedia/MultiFramedRTPSource.cpp
new file mode 100644
index 00000000..1c1a0b7c
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/MultiFramedRTPSource.cpp
@@ -0,0 +1,634 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// RTP source for a common kind of payload format: Those that pack multiple,
+// complete codec frames (as many as possible) into each RTP packet.
+// Implementation
+
+#include "MultiFramedRTPSource.hh"
+#include "RTCP.hh"
+#include "GroupsockHelper.hh"
+#include <string.h>
+
+////////// ReorderingPacketBuffer definition //////////
+
+class ReorderingPacketBuffer {
+public:
+    ReorderingPacketBuffer(BufferedPacketFactory *packetFactory);
+    virtual ~ReorderingPacketBuffer();
+    void reset();
+
+    BufferedPacket *getFreePacket(MultiFramedRTPSource *ourSource);
+    Boolean         storePacket(BufferedPacket *bPacket);
+    BufferedPacket *getNextCompletedPacket(Boolean &packetLossPreceded);
+    void            releaseUsedPacket(BufferedPacket *packet);
+    void            freePacket(BufferedPacket *packet) {
+        if(packet != fSavedPacket) {
+            delete packet;
+        }
+        else {
+            fSavedPacketFree = True;
+        }
+    }
+    Boolean isEmpty() const {
+        return fHeadPacket == NULL;
+    }
+
+    void setThresholdTime(unsigned uSeconds) {
+        fThresholdTime = uSeconds;
+    }
+    void resetHaveSeenFirstPacket() {
+        fHaveSeenFirstPacket = False;
+    }
+
+private:
+    BufferedPacketFactory *fPacketFactory;
+    unsigned               fThresholdTime;        // uSeconds
+    Boolean                fHaveSeenFirstPacket;  // used to set initial "fNextExpectedSeqNo"
+    unsigned short         fNextExpectedSeqNo;
+    BufferedPacket *       fHeadPacket;
+    BufferedPacket *       fTailPacket;
+    BufferedPacket *       fSavedPacket;
+    // to avoid calling new/free in the common case
+    Boolean fSavedPacketFree;
+};
+
+////////// MultiFramedRTPSource implementation //////////
+
+MultiFramedRTPSource ::MultiFramedRTPSource(UsageEnvironment &env, Groupsock *RTPgs, unsigned char rtpPayloadFormat, unsigned rtpTimestampFrequency,
+                                            BufferedPacketFactory *packetFactory)
+    : RTPSource(env, RTPgs, rtpPayloadFormat, rtpTimestampFrequency) {
+    reset();
+    fReorderingBuffer = new ReorderingPacketBuffer(packetFactory);
+
+    // Try to use a big receive buffer for RTP:
+    increaseReceiveBufferTo(env, RTPgs->socketNum(), 2 * 1024 * 1024);
+}
+
+void MultiFramedRTPSource::reset() {
+    fCurrentPacketBeginsFrame    = True;  // by default
+    fCurrentPacketCompletesFrame = True;  // by default
+    fAreDoingNetworkReads        = False;
+    fPacketReadInProgress        = NULL;
+    fNeedDelivery                = False;
+    fPacketLossInFragmentedFrame = False;
+}
+
+MultiFramedRTPSource::~MultiFramedRTPSource() {
+    delete fReorderingBuffer;
+}
+
+Boolean MultiFramedRTPSource ::processSpecialHeader(BufferedPacket * /*packet*/, unsigned &resultSpecialHeaderSize) {
+    // Default implementation: Assume no special header:
+    resultSpecialHeaderSize = 0;
+    return True;
+}
+
+Boolean MultiFramedRTPSource ::packetIsUsableInJitterCalculation(unsigned char * /*packet*/, unsigned /*packetSize*/) {
+    // Default implementation:
+    return True;
+}
+
+void MultiFramedRTPSource::doStopGettingFrames() {
+    if(fPacketReadInProgress != NULL) {
+        fReorderingBuffer->freePacket(fPacketReadInProgress);
+        fPacketReadInProgress = NULL;
+    }
+    envir().taskScheduler().unscheduleDelayedTask(nextTask());
+    fRTPInterface.stopNetworkReading();
+    fReorderingBuffer->reset();
+    reset();
+}
+
+void MultiFramedRTPSource::doGetNextFrame() {
+    if(!fAreDoingNetworkReads) {
+        // Turn on background read handling of incoming packets:
+        fAreDoingNetworkReads                         = True;
+        TaskScheduler::BackgroundHandlerProc *handler = (TaskScheduler::BackgroundHandlerProc *)&networkReadHandler;
+        fRTPInterface.startNetworkReading(handler);
+    }
+
+    fSavedTo      = fTo;
+    fSavedMaxSize = fMaxSize;
+    fFrameSize    = 0;  // for now
+    fNeedDelivery = True;
+    doGetNextFrame1();
+}
+
+void MultiFramedRTPSource::doGetNextFrame1() {
+    while(fNeedDelivery) {
+        // If we already have packet data available, then deliver it now.
+        Boolean         packetLossPrecededThis;
+        BufferedPacket *nextPacket = fReorderingBuffer->getNextCompletedPacket(packetLossPrecededThis);
+        if(nextPacket == NULL)
+            break;
+
+        fNeedDelivery = False;
+
+        if(nextPacket->useCount() == 0) {
+            // Before using the packet, check whether it has a special header
+            // that needs to be processed:
+            unsigned specialHeaderSize;
+            if(!processSpecialHeader(nextPacket, specialHeaderSize)) {
+                // Something's wrong with the header; reject the packet:
+                fReorderingBuffer->releaseUsedPacket(nextPacket);
+                fNeedDelivery = True;
+                continue;
+            }
+            nextPacket->skip(specialHeaderSize);
+        }
+
+        // Check whether we're part of a multi-packet frame, and whether
+        // there was packet loss that would render this packet unusable:
+        if(fCurrentPacketBeginsFrame) {
+            if(packetLossPrecededThis || fPacketLossInFragmentedFrame) {
+                // We didn't get all of the previous frame.
+                // Forget any data that we used from it:
+                fTo        = fSavedTo;
+                fMaxSize   = fSavedMaxSize;
+                fFrameSize = 0;
+            }
+            fPacketLossInFragmentedFrame = False;
+        }
+        else if(packetLossPrecededThis) {
+            // We're in a multi-packet frame, with preceding packet loss
+            fPacketLossInFragmentedFrame = True;
+        }
+        if(fPacketLossInFragmentedFrame) {
+            // This packet is unusable; reject it:
+            fReorderingBuffer->releaseUsedPacket(nextPacket);
+            fNeedDelivery = True;
+            continue;
+        }
+
+        // The packet is usable. Deliver all or part of it to our caller:
+        unsigned frameSize;
+        nextPacket->use(fTo, fMaxSize, frameSize, fNumTruncatedBytes, fCurPacketRTPSeqNum, fCurPacketRTPTimestamp, fPresentationTime,
+                        fCurPacketHasBeenSynchronizedUsingRTCP, fCurPacketMarkerBit);
+        fFrameSize += frameSize;
+
+        if(!nextPacket->hasUsableData()) {
+            // We're completely done with this packet now
+            fReorderingBuffer->releaseUsedPacket(nextPacket);
+        }
+
+        if(fCurrentPacketCompletesFrame && fFrameSize > 0) {
+            // We have all the data that the client wants.
+            if(fNumTruncatedBytes > 0) {
+                envir() << "MultiFramedRTPSource::doGetNextFrame1(): The total received frame size exceeds the client's buffer size (" << fSavedMaxSize
+                        << ").  " << fNumTruncatedBytes << " bytes of trailing data will be dropped!\n";
+            }
+            // Call our own 'after getting' function, so that the downstream object can consume the data:
+            if(fReorderingBuffer->isEmpty()) {
+                // Common case optimization: There are no more queued incoming packets, so this code will not get
+                // executed again without having first returned to the event loop.  Call our 'after getting' function
+                // directly, because there's no risk of a long chain of recursion (and thus stack overflow):
+                afterGetting(this);
+            }
+            else {
+                // Special case: Call our 'after getting' function via the event loop.
+                nextTask() = envir().taskScheduler().scheduleDelayedTask(0, (TaskFunc *)FramedSource::afterGetting, this);
+            }
+        }
+        else {
+            // This packet contained fragmented data, and does not complete
+            // the data that the client wants.  Keep getting data:
+            fTo += frameSize;
+            fMaxSize -= frameSize;
+            fNeedDelivery = True;
+        }
+    }
+}
+
+void MultiFramedRTPSource ::setPacketReorderingThresholdTime(unsigned uSeconds) {
+    fReorderingBuffer->setThresholdTime(uSeconds);
+}
+
+#define ADVANCE(n)        \
+    do {                  \
+        bPacket->skip(n); \
+    } while(0)
+
+void MultiFramedRTPSource::networkReadHandler(MultiFramedRTPSource *source, int /*mask*/) {
+    source->networkReadHandler1();
+}
+
+void MultiFramedRTPSource::networkReadHandler1() {
+    BufferedPacket *bPacket = fPacketReadInProgress;
+    if(bPacket == NULL) {
+        // Normal case: Get a free BufferedPacket descriptor to hold the new network packet:
+        bPacket = fReorderingBuffer->getFreePacket(this);
+    }
+
+    // Read the network packet, and perform sanity checks on the RTP header:
+    Boolean readSuccess = False;
+    do {
+        struct sockaddr_storage fromAddress;
+        Boolean                 packetReadWasIncomplete = fPacketReadInProgress != NULL;
+        if(!bPacket->fillInData(fRTPInterface, fromAddress, packetReadWasIncomplete)) {
+            if(bPacket->bytesAvailable() == 0) {  // should not happen??
+                envir() << "MultiFramedRTPSource internal error: Hit limit when reading incoming packet over TCP\n";
+            }
+            fPacketReadInProgress = NULL;
+            break;
+        }
+        if(packetReadWasIncomplete) {
+            // We need additional read(s) before we can process the incoming packet:
+            fPacketReadInProgress = bPacket;
+            return;
+        }
+        else {
+            fPacketReadInProgress = NULL;
+        }
+#ifdef TEST_LOSS
+        setPacketReorderingThresholdTime(0);
+        // don't wait for 'lost' packets to arrive out-of-order later
+        if((our_random() % 10) == 0)
+            break;  // simulate 10% packet loss
+#endif
+
+        if(fCrypto != NULL) {  // The packet is SRTP; authenticate/decrypt it first
+            unsigned newPacketSize;
+            if(!fCrypto->processIncomingSRTPPacket(bPacket->data(), bPacket->dataSize(), newPacketSize))
+                break;
+            if(newPacketSize > bPacket->dataSize())
+                break;                                                    // sanity check; shouldn't happen
+            bPacket->removePadding(bPacket->dataSize() - newPacketSize);  // treat MKI+auth as padding
+        }
+
+        // Check for the 12-byte RTP header:
+        if(bPacket->dataSize() < 12)
+            break;
+        unsigned rtpHdr = ntohl(*(u_int32_t *)(bPacket->data()));
+        ADVANCE(4);
+        Boolean  rtpMarkerBit = (rtpHdr & 0x00800000) != 0;
+        unsigned rtpTimestamp = ntohl(*(u_int32_t *)(bPacket->data()));
+        ADVANCE(4);
+        unsigned rtpSSRC = ntohl(*(u_int32_t *)(bPacket->data()));
+        ADVANCE(4);
+
+        // Check the RTP version number (it should be 2):
+        if((rtpHdr & 0xC0000000) != 0x80000000)
+            break;
+
+        // Check the Payload Type.
+        unsigned char rtpPayloadType = (unsigned char)((rtpHdr & 0x007F0000) >> 16);
+        if(rtpPayloadType != rtpPayloadFormat()) {
+            if(fRTCPInstanceForMultiplexedRTCPPackets != NULL && rtpPayloadType >= 64 && rtpPayloadType <= 95) {
+                // This is a multiplexed RTCP packet, and we've been asked to deliver such packets.
+                // Do so now:
+                fRTCPInstanceForMultiplexedRTCPPackets->injectReport(bPacket->data() - 12, bPacket->dataSize() + 12, fromAddress);
+            }
+            break;
+        }
+
+        // Skip over any CSRC identifiers in the header:
+        unsigned cc = (rtpHdr >> 24) & 0x0F;
+        if(bPacket->dataSize() < cc * 4)
+            break;
+        ADVANCE(cc * 4);
+
+        // Check for (& ignore) any RTP header extension
+        if(rtpHdr & 0x10000000) {
+            if(bPacket->dataSize() < 4)
+                break;
+            unsigned extHdr = ntohl(*(u_int32_t *)(bPacket->data()));
+            ADVANCE(4);
+            unsigned remExtSize = 4 * (extHdr & 0xFFFF);
+            if(bPacket->dataSize() < remExtSize)
+                break;
+            ADVANCE(remExtSize);
+        }
+
+        // Discard any padding bytes:
+        if(rtpHdr & 0x20000000) {
+            if(bPacket->dataSize() == 0)
+                break;
+            unsigned numPaddingBytes = (unsigned)(bPacket->data())[bPacket->dataSize() - 1];
+            if(bPacket->dataSize() < numPaddingBytes)
+                break;
+            bPacket->removePadding(numPaddingBytes);
+        }
+
+        // The rest of the packet is the usable data.  Record and save it:
+        if(rtpSSRC != fLastReceivedSSRC) {
+            // The SSRC of incoming packets has changed.  Unfortunately we don't yet handle streams that contain multiple SSRCs,
+            // but we can handle a single-SSRC stream where the SSRC changes occasionally:
+            fLastReceivedSSRC = rtpSSRC;
+            fReorderingBuffer->resetHaveSeenFirstPacket();
+        }
+        unsigned short rtpSeqNo                  = (unsigned short)(rtpHdr & 0xFFFF);
+        Boolean        usableInJitterCalculation = packetIsUsableInJitterCalculation((bPacket->data()), bPacket->dataSize());
+        struct timeval presentationTime;        // computed by:
+        Boolean        hasBeenSyncedUsingRTCP;  // computed by:
+        receptionStatsDB().noteIncomingPacket(rtpSSRC, rtpSeqNo, rtpTimestamp, timestampFrequency(), usableInJitterCalculation, presentationTime,
+                                              hasBeenSyncedUsingRTCP, bPacket->dataSize());
+
+        // Fill in the rest of the packet descriptor, and store it:
+        struct timeval timeNow;
+        gettimeofday(&timeNow, NULL);
+        bPacket->assignMiscParams(rtpSeqNo, rtpTimestamp, presentationTime, hasBeenSyncedUsingRTCP, rtpMarkerBit, timeNow);
+        if(!fReorderingBuffer->storePacket(bPacket))
+            break;
+
+        readSuccess = True;
+    } while(0);
+    if(!readSuccess)
+        fReorderingBuffer->freePacket(bPacket);
+
+    doGetNextFrame1();
+    // If we didn't get proper data this time, we'll get another chance
+}
+
+////////// BufferedPacket and BufferedPacketFactory implementation /////
+
+#define MAX_PACKET_SIZE 65536
+
+BufferedPacket::BufferedPacket() : fPacketSize(MAX_PACKET_SIZE), fBuf(new unsigned char[MAX_PACKET_SIZE]), fNextPacket(NULL) {}
+
+BufferedPacket::~BufferedPacket() {
+    delete fNextPacket;
+    delete[] fBuf;
+}
+
+void BufferedPacket::reset() {
+    fHead = fTail  = 0;
+    fUseCount      = 0;
+    fIsFirstPacket = False;  // by default
+}
+
+// The following function has been deprecated:
+unsigned BufferedPacket ::nextEnclosedFrameSize(unsigned char *& /*framePtr*/, unsigned dataSize) {
+    // By default, use the entire buffered data, even though it may consist
+    // of more than one frame, on the assumption that the client doesn't
+    // care.  (This is more efficient than delivering a frame at a time)
+    return dataSize;
+}
+
+void BufferedPacket ::getNextEnclosedFrameParameters(unsigned char *&framePtr, unsigned dataSize, unsigned &frameSize, unsigned &frameDurationInMicroseconds) {
+    // By default, use the entire buffered data, even though it may consist
+    // of more than one frame, on the assumption that the client doesn't
+    // care.  (This is more efficient than delivering a frame at a time)
+
+    // For backwards-compatibility with existing uses of (the now deprecated)
+    // "nextEnclosedFrameSize()", call that function to implement this one:
+    frameSize = nextEnclosedFrameSize(framePtr, dataSize);
+
+    frameDurationInMicroseconds = 0;  // by default.  Subclasses should correct this.
+}
+
+Boolean BufferedPacket::fillInData(RTPInterface &rtpInterface, struct sockaddr_storage &fromAddress, Boolean &packetReadWasIncomplete) {
+    if(!packetReadWasIncomplete)
+        reset();
+
+    unsigned const maxBytesToRead = bytesAvailable();
+    if(maxBytesToRead == 0)
+        return False;  // exceeded buffer size when reading over TCP
+
+    unsigned      numBytesRead;
+    int           tcpSocketNum;        // not used
+    unsigned char tcpStreamChannelId;  // not used
+    if(!rtpInterface.handleRead(&fBuf[fTail], maxBytesToRead, numBytesRead, fromAddress, tcpSocketNum, tcpStreamChannelId, packetReadWasIncomplete)) {
+        return False;
+    }
+    fTail += numBytesRead;
+    return True;
+}
+
+void BufferedPacket ::assignMiscParams(unsigned short rtpSeqNo, unsigned rtpTimestamp, struct timeval presentationTime, Boolean hasBeenSyncedUsingRTCP,
+                                       Boolean rtpMarkerBit, struct timeval timeReceived) {
+    fRTPSeqNo               = rtpSeqNo;
+    fRTPTimestamp           = rtpTimestamp;
+    fPresentationTime       = presentationTime;
+    fHasBeenSyncedUsingRTCP = hasBeenSyncedUsingRTCP;
+    fRTPMarkerBit           = rtpMarkerBit;
+    fTimeReceived           = timeReceived;
+}
+
+void BufferedPacket::skip(unsigned numBytes) {
+    fHead += numBytes;
+    if(fHead > fTail)
+        fHead = fTail;
+}
+
+void BufferedPacket::removePadding(unsigned numBytes) {
+    if(numBytes > fTail - fHead)
+        numBytes = fTail - fHead;
+    fTail -= numBytes;
+}
+
+void BufferedPacket::appendData(unsigned char *newData, unsigned numBytes) {
+    if(numBytes > fPacketSize - fTail)
+        numBytes = fPacketSize - fTail;
+    memmove(&fBuf[fTail], newData, numBytes);
+    fTail += numBytes;
+}
+
+void BufferedPacket::use(unsigned char *to, unsigned toSize, unsigned &bytesUsed, unsigned &bytesTruncated, unsigned short &rtpSeqNo, unsigned &rtpTimestamp,
+                         struct timeval &presentationTime, Boolean &hasBeenSyncedUsingRTCP, Boolean &rtpMarkerBit) {
+    unsigned char *origFramePtr = &fBuf[fHead];
+    unsigned char *newFramePtr  = origFramePtr;  // may change in the call below
+    unsigned       frameSize, frameDurationInMicroseconds;
+
+    rtpSeqNo               = fRTPSeqNo;
+    rtpTimestamp           = fRTPTimestamp;
+    presentationTime       = fPresentationTime;
+    hasBeenSyncedUsingRTCP = fHasBeenSyncedUsingRTCP;
+    rtpMarkerBit           = fRTPMarkerBit;
+
+    getNextEnclosedFrameParameters(newFramePtr, fTail - fHead, frameSize, frameDurationInMicroseconds);
+    if(frameSize > toSize) {
+        bytesTruncated += frameSize - toSize;
+        bytesUsed = toSize;
+    }
+    else {
+        bytesTruncated = 0;
+        bytesUsed      = frameSize;
+    }
+
+    memmove(to, newFramePtr, bytesUsed);
+    fHead += (newFramePtr - origFramePtr) + frameSize;
+    ++fUseCount;
+
+    // Update "fPresentationTime" for the next enclosed frame (if any):
+    fPresentationTime.tv_usec += frameDurationInMicroseconds;
+    if(fPresentationTime.tv_usec >= 1000000) {
+        fPresentationTime.tv_sec += fPresentationTime.tv_usec / 1000000;
+        fPresentationTime.tv_usec = fPresentationTime.tv_usec % 1000000;
+    }
+}
+
+BufferedPacketFactory::BufferedPacketFactory() {}
+
+BufferedPacketFactory::~BufferedPacketFactory() {}
+
+BufferedPacket *BufferedPacketFactory ::createNewPacket(MultiFramedRTPSource * /*ourSource*/) {
+    return new BufferedPacket;
+}
+
+////////// ReorderingPacketBuffer implementation //////////
+
+ReorderingPacketBuffer ::ReorderingPacketBuffer(BufferedPacketFactory *packetFactory)
+    : fThresholdTime(100000) /* default reordering threshold: 100 ms */,
+      fHaveSeenFirstPacket(False),
+      fHeadPacket(NULL),
+      fTailPacket(NULL),
+      fSavedPacket(NULL),
+      fSavedPacketFree(True) {
+    fPacketFactory = (packetFactory == NULL) ? (new BufferedPacketFactory) : packetFactory;
+}
+
+ReorderingPacketBuffer::~ReorderingPacketBuffer() {
+    reset();
+    delete fPacketFactory;
+}
+
+void ReorderingPacketBuffer::reset() {
+    if(fSavedPacketFree)
+        delete fSavedPacket;  // because fSavedPacket is not in the list
+    delete fHeadPacket;       // will also delete fSavedPacket if it's in the list
+    resetHaveSeenFirstPacket();
+    fHeadPacket = fTailPacket = fSavedPacket = NULL;
+}
+
+BufferedPacket *ReorderingPacketBuffer::getFreePacket(MultiFramedRTPSource *ourSource) {
+    if(fSavedPacket == NULL) {  // we're being called for the first time
+        fSavedPacket     = fPacketFactory->createNewPacket(ourSource);
+        fSavedPacketFree = True;
+    }
+
+    if(fSavedPacketFree == True) {
+        fSavedPacketFree = False;
+        return fSavedPacket;
+    }
+    else {
+        return fPacketFactory->createNewPacket(ourSource);
+    }
+}
+
+Boolean ReorderingPacketBuffer::storePacket(BufferedPacket *bPacket) {
+    unsigned short rtpSeqNo = bPacket->rtpSeqNo();
+
+    if(!fHaveSeenFirstPacket) {
+        fNextExpectedSeqNo       = rtpSeqNo;  // initialization
+        bPacket->isFirstPacket() = True;
+        fHaveSeenFirstPacket     = True;
+    }
+
+    // Ignore this packet if its sequence number is less than the one
+    // that we're looking for (in this case, it's been excessively delayed).
+    if(seqNumLT(rtpSeqNo, fNextExpectedSeqNo))
+        return False;
+
+    if(fTailPacket == NULL) {
+        // Common case: There are no packets in the queue; this will be the first one:
+        bPacket->nextPacket() = NULL;
+        fHeadPacket = fTailPacket = bPacket;
+        return True;
+    }
+
+    if(seqNumLT(fTailPacket->rtpSeqNo(), rtpSeqNo)) {
+        // The next-most common case: There are packets already in the queue; this packet arrived in order => put it at the tail:
+        bPacket->nextPacket()     = NULL;
+        fTailPacket->nextPacket() = bPacket;
+        fTailPacket               = bPacket;
+        return True;
+    }
+
+    if(rtpSeqNo == fTailPacket->rtpSeqNo()) {
+        // This is a duplicate packet - ignore it
+        return False;
+    }
+
+    // Rare case: This packet is out-of-order.  Run through the list (from the head), to figure out where it belongs:
+    BufferedPacket *beforePtr = NULL;
+    BufferedPacket *afterPtr  = fHeadPacket;
+    while(afterPtr != NULL) {
+        if(seqNumLT(rtpSeqNo, afterPtr->rtpSeqNo()))
+            break;  // it comes here
+        if(rtpSeqNo == afterPtr->rtpSeqNo()) {
+            // This is a duplicate packet - ignore it
+            return False;
+        }
+
+        beforePtr = afterPtr;
+        afterPtr  = afterPtr->nextPacket();
+    }
+
+    // Link our new packet between "beforePtr" and "afterPtr":
+    bPacket->nextPacket() = afterPtr;
+    if(beforePtr == NULL) {
+        fHeadPacket = bPacket;
+    }
+    else {
+        beforePtr->nextPacket() = bPacket;
+    }
+
+    return True;
+}
+
+void ReorderingPacketBuffer::releaseUsedPacket(BufferedPacket *packet) {
+    // ASSERT: packet == fHeadPacket
+    // ASSERT: fNextExpectedSeqNo == packet->rtpSeqNo()
+    ++fNextExpectedSeqNo;  // because we're finished with this packet now
+
+    fHeadPacket = fHeadPacket->nextPacket();
+    if(!fHeadPacket) {
+        fTailPacket = NULL;
+    }
+    packet->nextPacket() = NULL;
+
+    freePacket(packet);
+}
+
+BufferedPacket *ReorderingPacketBuffer ::getNextCompletedPacket(Boolean &packetLossPreceded) {
+    if(fHeadPacket == NULL)
+        return NULL;
+
+    // Check whether the next packet we want is already at the head
+    // of the queue:
+    // ASSERT: fHeadPacket->rtpSeqNo() >= fNextExpectedSeqNo
+    if(fHeadPacket->rtpSeqNo() == fNextExpectedSeqNo) {
+        packetLossPreceded = fHeadPacket->isFirstPacket();
+        // (The very first packet is treated as if there was packet loss beforehand.)
+        return fHeadPacket;
+    }
+
+    // We're still waiting for our desired packet to arrive.  However, if
+    // our time threshold has been exceeded, then forget it, and return
+    // the head packet instead:
+    Boolean timeThresholdHasBeenExceeded;
+    if(fThresholdTime == 0) {
+        timeThresholdHasBeenExceeded = True;  // optimization
+    }
+    else {
+        struct timeval timeNow;
+        gettimeofday(&timeNow, NULL);
+        unsigned uSecondsSinceReceived =
+            (timeNow.tv_sec - fHeadPacket->timeReceived().tv_sec) * 1000000 + (timeNow.tv_usec - fHeadPacket->timeReceived().tv_usec);
+        timeThresholdHasBeenExceeded = uSecondsSinceReceived > fThresholdTime;
+    }
+    if(timeThresholdHasBeenExceeded) {
+        fNextExpectedSeqNo = fHeadPacket->rtpSeqNo();
+        // we've given up on earlier packets now
+        packetLossPreceded = True;
+        return fHeadPacket;
+    }
+
+    // Otherwise, keep waiting for our desired packet to arrive:
+    return NULL;
+}
diff --git a/3rdparty/live555/src/liveMedia/OggDemuxedTrack.cpp b/3rdparty/live555/src/liveMedia/OggDemuxedTrack.cpp
new file mode 100644
index 00000000..bcb31ceb
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/OggDemuxedTrack.cpp
@@ -0,0 +1,43 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A media track, demultiplexed from an Ogg file
+// Implementation
+
+#include "OggDemuxedTrack.hh"
+#include "OggFile.hh"
+
+OggDemuxedTrack::OggDemuxedTrack(UsageEnvironment &env, unsigned trackNumber, OggDemux &sourceDemux)
+    : FramedSource(env), fOurTrackNumber(trackNumber), fOurSourceDemux(sourceDemux), fCurrentPageIsContinuation(False) {
+    fNextPresentationTime.tv_sec  = 0;
+    fNextPresentationTime.tv_usec = 0;
+}
+
+OggDemuxedTrack::~OggDemuxedTrack() {
+    fOurSourceDemux.removeTrack(fOurTrackNumber);
+}
+
+void OggDemuxedTrack::doGetNextFrame() {
+    fOurSourceDemux.continueReading();
+}
+
+char const *OggDemuxedTrack::MIMEtype() const {
+    OggTrack *track = fOurSourceDemux.fOurFile.lookup(fOurTrackNumber);
+    if(track == NULL)
+        return "(unknown)";  // shouldn't happen
+    return track->mimeType;
+}
diff --git a/3rdparty/live555/src/liveMedia/OggDemuxedTrack.hh b/3rdparty/live555/src/liveMedia/OggDemuxedTrack.hh
new file mode 100644
index 00000000..6d0e6884
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/OggDemuxedTrack.hh
@@ -0,0 +1,58 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A media track, demultiplexed from an Ogg file
+// C++ header
+
+#ifndef _OGG_DEMUXED_TRACK_HH
+#define _OGG_DEMUXED_TRACK_HH
+
+#ifndef _FRAMED_SOURCE_HH
+#include "FramedSource.hh"
+#endif
+
+class OggDemux; // forward
+
+class OggDemuxedTrack: public FramedSource {
+private: // We are created only by a OggDemux (a friend)
+  friend class OggDemux;
+  OggDemuxedTrack(UsageEnvironment& env, unsigned trackNumber, OggDemux& sourceDemux);
+  virtual ~OggDemuxedTrack();
+
+private:
+  // redefined virtual functions:
+  virtual void doGetNextFrame();
+  virtual char const* MIMEtype() const;
+
+private: // We are accessed only by OggDemux and by OggFileParser (a friend)
+  friend class OggFileParser;
+  unsigned char*& to() { return fTo; }
+  unsigned& maxSize() { return fMaxSize; }
+  unsigned& frameSize() { return fFrameSize; }
+  unsigned& numTruncatedBytes() { return fNumTruncatedBytes; }
+  struct timeval& presentationTime() { return fPresentationTime; }
+  unsigned& durationInMicroseconds() { return fDurationInMicroseconds; }
+  struct timeval& nextPresentationTime() { return fNextPresentationTime; }
+
+private:
+  unsigned fOurTrackNumber;
+  OggDemux& fOurSourceDemux;
+  Boolean fCurrentPageIsContinuation;
+  struct timeval fNextPresentationTime;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/OggFile.cpp b/3rdparty/live555/src/liveMedia/OggFile.cpp
new file mode 100644
index 00000000..c8e2aca2
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/OggFile.cpp
@@ -0,0 +1,340 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A class that encapsulates an Ogg file.
+// Implementation
+
+#include "OggFileParser.hh"
+#include "OggDemuxedTrack.hh"
+#include "ByteStreamFileSource.hh"
+#include "VorbisAudioRTPSink.hh"
+#include "SimpleRTPSink.hh"
+#include "TheoraVideoRTPSink.hh"
+
+////////// OggTrackTable definition /////////
+
+// For looking up and iterating over the file's tracks:
+
+class OggTrackTable {
+public:
+    OggTrackTable();
+    virtual ~OggTrackTable();
+
+    void      add(OggTrack *newTrack);
+    OggTrack *lookup(u_int32_t trackNumber);
+
+    unsigned numTracks() const;
+
+private:
+    friend class OggTrackTableIterator;
+    HashTable *fTable;
+};
+
+////////// OggFile implementation //////////
+
+void OggFile::createNew(UsageEnvironment &env, char const *fileName, onCreationFunc *onCreation, void *onCreationClientData) {
+    new OggFile(env, fileName, onCreation, onCreationClientData);
+}
+
+OggTrack *OggFile::lookup(u_int32_t trackNumber) {
+    return fTrackTable->lookup(trackNumber);
+}
+
+struct DemuxRecord {
+    OggDemux *              demux;
+    OggDemuxOnDeletionFunc *onDeletionFunc;
+    void *                  objectToNotify;
+};
+
+OggDemux *OggFile ::newDemux(OggDemuxOnDeletionFunc *onDeletionFunc, void *objectToNotify) {
+    OggDemux *demux = new OggDemux(*this);
+
+    DemuxRecord *demuxRecord    = new DemuxRecord();
+    demuxRecord->demux          = demux;
+    demuxRecord->onDeletionFunc = onDeletionFunc;
+    demuxRecord->objectToNotify = objectToNotify;
+
+    fDemuxesTable->Add((char const *)demux, demuxRecord);
+
+    return demux;
+}
+
+void OggFile::removeDemux(OggDemux *demux) {
+    DemuxRecord *demuxRecord = (DemuxRecord *)(fDemuxesTable->Lookup((char const *)demux));
+    if(demuxRecord != NULL) {
+        fDemuxesTable->Remove((char const *)demux);
+
+        if(demuxRecord->onDeletionFunc != NULL) {
+            (*demuxRecord->onDeletionFunc)(demuxRecord->objectToNotify, demux);
+        }
+        delete demuxRecord;
+    }
+}
+
+unsigned OggFile::numTracks() const {
+    return fTrackTable->numTracks();
+}
+
+FramedSource *OggFile ::createSourceForStreaming(FramedSource *baseSource, u_int32_t trackNumber, unsigned &estBitrate, unsigned &numFiltersInFrontOfTrack) {
+    if(baseSource == NULL)
+        return NULL;
+
+    FramedSource *result     = baseSource;  // by default
+    numFiltersInFrontOfTrack = 0;           // by default
+
+    // Look at the track's MIME type to set its estimated bitrate (for use by RTCP).
+    // (Later, try to be smarter about figuring out the bitrate.) #####
+    // Some MIME types also require adding a special 'framer' in front of the source.
+    OggTrack *track = lookup(trackNumber);
+    if(track != NULL) {  // should always be true
+        estBitrate = track->estBitrate;
+    }
+
+    return result;
+}
+
+RTPSink *OggFile ::createRTPSinkForTrackNumber(u_int32_t trackNumber, Groupsock *rtpGroupsock, unsigned char rtpPayloadTypeIfDynamic) {
+    OggTrack *track = lookup(trackNumber);
+    if(track == NULL || track->mimeType == NULL)
+        return NULL;
+
+    RTPSink *result = NULL;  // default value for unknown media types
+
+    if(strcmp(track->mimeType, "audio/VORBIS") == 0) {
+        // For Vorbis audio, we use the special "identification", "comment", and "setup" headers
+        // that we read when we initially read the headers at the start of the file:
+        result = VorbisAudioRTPSink::createNew(envir(), rtpGroupsock, rtpPayloadTypeIfDynamic, track->samplingFrequency, track->numChannels,
+                                               track->vtoHdrs.header[0], track->vtoHdrs.headerSize[0], track->vtoHdrs.header[1], track->vtoHdrs.headerSize[1],
+                                               track->vtoHdrs.header[2], track->vtoHdrs.headerSize[2]);
+    }
+    else if(strcmp(track->mimeType, "audio/OPUS") == 0) {
+        result = SimpleRTPSink ::createNew(envir(), rtpGroupsock, rtpPayloadTypeIfDynamic, 48000, "audio", "OPUS", 2,
+                                           False /*only 1 Opus 'packet' in each RTP packet*/);
+    }
+    else if(strcmp(track->mimeType, "video/THEORA") == 0) {
+        // For Theora video, we use the special "identification", "comment", and "setup" headers
+        // that we read when we initially read the headers at the start of the file:
+        result = TheoraVideoRTPSink::createNew(envir(), rtpGroupsock, rtpPayloadTypeIfDynamic, track->vtoHdrs.header[0], track->vtoHdrs.headerSize[0],
+                                               track->vtoHdrs.header[1], track->vtoHdrs.headerSize[1], track->vtoHdrs.header[2], track->vtoHdrs.headerSize[2]);
+    }
+
+    return result;
+}
+
+OggFile::OggFile(UsageEnvironment &env, char const *fileName, onCreationFunc *onCreation, void *onCreationClientData)
+    : Medium(env), fFileName(strDup(fileName)), fOnCreation(onCreation), fOnCreationClientData(onCreationClientData) {
+    fTrackTable   = new OggTrackTable;
+    fDemuxesTable = HashTable::create(ONE_WORD_HASH_KEYS);
+
+    FramedSource *inputSource = ByteStreamFileSource::createNew(envir(), fileName);
+    if(inputSource == NULL) {
+        // The specified input file does not exist!
+        fParserForInitialization = NULL;
+        handleEndOfBosPageParsing();  // we have no file, and thus no tracks, but we still need to signal this
+    }
+    else {
+        // Initialize ourselves by parsing the file's headers:
+        fParserForInitialization = new OggFileParser(*this, inputSource, handleEndOfBosPageParsing, this);
+    }
+}
+
+OggFile::~OggFile() {
+    delete fParserForInitialization;
+
+    // Delete any outstanding "OggDemux"s, and the table for them:
+    DemuxRecord *demuxRecord;
+    while((demuxRecord = (DemuxRecord *)fDemuxesTable->RemoveNext()) != NULL) {
+        delete demuxRecord->demux;
+        delete demuxRecord;
+    }
+    delete fDemuxesTable;
+    delete fTrackTable;
+
+    delete[](char *) fFileName;
+}
+
+void OggFile::handleEndOfBosPageParsing(void *clientData) {
+    ((OggFile *)clientData)->handleEndOfBosPageParsing();
+}
+
+void OggFile::handleEndOfBosPageParsing() {
+    // Delete our parser, because it's done its job now:
+    delete fParserForInitialization;
+    fParserForInitialization = NULL;
+
+    // Finally, signal our caller that we've been created and initialized:
+    if(fOnCreation != NULL)
+        (*fOnCreation)(this, fOnCreationClientData);
+}
+
+void OggFile::addTrack(OggTrack *newTrack) {
+    fTrackTable->add(newTrack);
+}
+
+////////// OggTrackTable implementation /////////
+
+OggTrackTable::OggTrackTable() : fTable(HashTable::create(ONE_WORD_HASH_KEYS)) {}
+
+OggTrackTable::~OggTrackTable() {
+    // Remove and delete all of our "OggTrack" descriptors, and the hash table itself:
+    OggTrack *track;
+    while((track = (OggTrack *)fTable->RemoveNext()) != NULL) {
+        delete track;
+    }
+    delete fTable;
+}
+
+void OggTrackTable::add(OggTrack *newTrack) {
+    OggTrack *existingTrack = (OggTrack *)fTable->Add((char const *)newTrack->trackNumber, newTrack);
+    delete existingTrack;  // if any
+}
+
+OggTrack *OggTrackTable::lookup(u_int32_t trackNumber) {
+    return (OggTrack *)fTable->Lookup((char const *)trackNumber);
+}
+
+unsigned OggTrackTable::numTracks() const {
+    return fTable->numEntries();
+}
+
+OggTrackTableIterator::OggTrackTableIterator(OggTrackTable &ourTable) {
+    fIter = HashTable::Iterator::create(*(ourTable.fTable));
+}
+
+OggTrackTableIterator::~OggTrackTableIterator() {
+    delete fIter;
+}
+
+OggTrack *OggTrackTableIterator::next() {
+    char const *key;
+    return (OggTrack *)fIter->next(key);
+}
+
+////////// OggTrack implementation //////////
+
+OggTrack::OggTrack() : trackNumber(0), mimeType(NULL), samplingFrequency(48000), numChannels(2), estBitrate(100) {  // default settings
+    vtoHdrs.header[0] = vtoHdrs.header[1] = vtoHdrs.header[2] = NULL;
+    vtoHdrs.headerSize[0] = vtoHdrs.headerSize[1] = vtoHdrs.headerSize[2] = 0;
+
+    vtoHdrs.vorbis_mode_count     = 0;
+    vtoHdrs.vorbis_mode_blockflag = NULL;
+}
+
+OggTrack::~OggTrack() {
+    delete[] vtoHdrs.header[0];
+    delete[] vtoHdrs.header[1];
+    delete[] vtoHdrs.header[2];
+    delete[] vtoHdrs.vorbis_mode_blockflag;
+}
+
+///////// OggDemux implementation /////////
+
+FramedSource *OggDemux::newDemuxedTrack(u_int32_t &resultTrackNumber) {
+    OggTrack *nextTrack;
+    do {
+        nextTrack = fIter->next();
+    } while(nextTrack != NULL && nextTrack->mimeType == NULL);
+
+    if(nextTrack == NULL) {  // no more tracks
+        resultTrackNumber = 0;
+        return NULL;
+    }
+
+    resultTrackNumber         = nextTrack->trackNumber;
+    FramedSource *trackSource = new OggDemuxedTrack(envir(), resultTrackNumber, *this);
+    fDemuxedTracksTable->Add((char const *)resultTrackNumber, trackSource);
+    return trackSource;
+}
+
+FramedSource *OggDemux::newDemuxedTrackByTrackNumber(unsigned trackNumber) {
+    if(trackNumber == 0)
+        return NULL;
+
+    FramedSource *trackSource = new OggDemuxedTrack(envir(), trackNumber, *this);
+    fDemuxedTracksTable->Add((char const *)trackNumber, trackSource);
+    return trackSource;
+}
+
+OggDemuxedTrack *OggDemux::lookupDemuxedTrack(u_int32_t trackNumber) {
+    return (OggDemuxedTrack *)fDemuxedTracksTable->Lookup((char const *)trackNumber);
+}
+
+OggDemux::OggDemux(OggFile &ourFile)
+    : Medium(ourFile.envir()),
+      fOurFile(ourFile),
+      fDemuxedTracksTable(HashTable::create(ONE_WORD_HASH_KEYS)),
+      fIter(new OggTrackTableIterator(*fOurFile.fTrackTable)) {
+    FramedSource *fileSource = ByteStreamFileSource::createNew(envir(), ourFile.fileName());
+    fOurParser               = new OggFileParser(ourFile, fileSource, handleEndOfFile, this, this);
+}
+
+OggDemux::~OggDemux() {
+    // Begin by acting as if we've reached the end of the source file.
+    // This should cause all of our demuxed tracks to get closed.
+    handleEndOfFile();
+
+    // Then delete our table of "OggDemuxedTrack"s
+    // - but not the "OggDemuxedTrack"s themselves; that should have already happened:
+    delete fDemuxedTracksTable;
+
+    delete fIter;
+    delete fOurParser;
+    fOurFile.removeDemux(this);
+}
+
+void OggDemux::removeTrack(u_int32_t trackNumber) {
+    fDemuxedTracksTable->Remove((char const *)trackNumber);
+    if(fDemuxedTracksTable->numEntries() == 0) {
+        // We no longer have any demuxed tracks, so delete ourselves now:
+        Medium::close(this);
+    }
+}
+
+void OggDemux::continueReading() {
+    fOurParser->continueParsing();
+}
+
+void OggDemux::handleEndOfFile(void *clientData) {
+    ((OggDemux *)clientData)->handleEndOfFile();
+}
+
+void OggDemux::handleEndOfFile() {
+    // Iterate through all of our 'demuxed tracks', handling 'end of input' on each one.
+    // Hack: Because this can cause the hash table to get modified underneath us,
+    // we don't call the handlers until after we've first iterated through all of the tracks.
+    unsigned numTracks = fDemuxedTracksTable->numEntries();
+    if(numTracks == 0)
+        return;
+    OggDemuxedTrack **tracks = new OggDemuxedTrack *[numTracks];
+
+    HashTable::Iterator *iter = HashTable::Iterator::create(*fDemuxedTracksTable);
+    unsigned             i;
+    char const *         trackNumber;
+
+    for(i = 0; i < numTracks; ++i) {
+        tracks[i] = (OggDemuxedTrack *)iter->next(trackNumber);
+    }
+    delete iter;
+
+    for(i = 0; i < numTracks; ++i) {
+        if(tracks[i] == NULL)
+            continue;  // sanity check; shouldn't happen
+        tracks[i]->handleClosure();
+    }
+
+    delete[] tracks;
+}
diff --git a/3rdparty/live555/src/liveMedia/OggFileParser.cpp b/3rdparty/live555/src/liveMedia/OggFileParser.cpp
new file mode 100644
index 00000000..977a69da
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/OggFileParser.cpp
@@ -0,0 +1,1117 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A parser for an Ogg file.
+// Implementation
+
+#include "OggFileParser.hh"
+#include "OggDemuxedTrack.hh"
+#include <GroupsockHelper.hh>  // for "gettimeofday()
+
+PacketSizeTable::PacketSizeTable(unsigned number_page_segments)
+    : numCompletedPackets(0), totSizes(0), nextPacketNumToDeliver(0), lastPacketIsIncomplete(False) {
+    size = new unsigned[number_page_segments];
+    for(unsigned i = 0; i < number_page_segments; ++i)
+        size[i] = 0;
+}
+
+PacketSizeTable::~PacketSizeTable() {
+    delete[] size;
+}
+
+OggFileParser::OggFileParser(OggFile &ourFile, FramedSource *inputSource, FramedSource::onCloseFunc *onEndFunc, void *onEndClientData, OggDemux *ourDemux)
+    : StreamParser(inputSource, onEndFunc, onEndClientData, continueParsing, this),
+      fOurFile(ourFile),
+      fInputSource(inputSource),
+      fOnEndFunc(onEndFunc),
+      fOnEndClientData(onEndClientData),
+      fOurDemux(ourDemux),
+      fNumUnfulfilledTracks(0),
+      fPacketSizeTable(NULL),
+      fCurrentTrackNumber(0),
+      fSavedPacket(NULL) {
+    if(ourDemux == NULL) {
+        // Initialization
+        fCurrentParseState = PARSING_START_OF_FILE;
+        continueParsing();
+    }
+    else {
+        fCurrentParseState = PARSING_AND_DELIVERING_PAGES;
+        // In this case, parsing (of page data) doesn't start until a client starts reading from a track.
+    }
+}
+
+OggFileParser::~OggFileParser() {
+    delete[] fSavedPacket;
+    delete fPacketSizeTable;
+    Medium::close(fInputSource);
+}
+
+void OggFileParser::continueParsing(void *clientData, unsigned char *ptr, unsigned size, struct timeval presentationTime) {
+    ((OggFileParser *)clientData)->continueParsing();
+}
+
+void OggFileParser::continueParsing() {
+    if(fInputSource != NULL) {
+        if(fInputSource->isCurrentlyAwaitingData())
+            return;
+        // Our input source is currently being read. Wait until that read completes
+
+        if(!parse()) {
+            // We didn't complete the parsing, because we had to read more data from the source,
+            // or because we're waiting for another read from downstream.
+            // Once that happens, we'll get called again.
+            return;
+        }
+    }
+
+    // We successfully parsed the file.  Call our 'done' function now:
+    if(fOnEndFunc != NULL)
+        (*fOnEndFunc)(fOnEndClientData);
+}
+
+Boolean OggFileParser::parse() {
+    try {
+        while(1) {
+            switch(fCurrentParseState) {
+            case PARSING_START_OF_FILE: {
+                if(parseStartOfFile())
+                    return True;
+            }
+            case PARSING_AND_DELIVERING_PAGES: {
+                parseAndDeliverPages();
+            }
+            case DELIVERING_PACKET_WITHIN_PAGE: {
+                if(deliverPacketWithinPage())
+                    return False;
+            }
+            }
+        }
+    }
+    catch(int /*e*/) {
+#ifdef DEBUG
+        fprintf(stderr, "OggFileParser::parse() EXCEPTION (This is normal behavior - *not* an error)\n");
+#endif
+        return False;  // the parsing got interrupted
+    }
+}
+
+Boolean OggFileParser::parseStartOfFile() {
+#ifdef DEBUG
+    fprintf(stderr, "parsing start of file\n");
+#endif
+    // Read and parse each 'page', until we see the first non-BOS page, or until we have
+    // collected all required headers for Vorbis, Theora, or Opus track(s) (if any).
+    u_int8_t header_type_flag;
+    do {
+        header_type_flag = parseInitialPage();
+    } while((header_type_flag & 0x02) != 0 || needHeaders());
+
+#ifdef DEBUG
+    fprintf(stderr, "Finished parsing start of file\n");
+#endif
+    return True;
+}
+
+static u_int32_t byteSwap(u_int32_t x) {
+    return (x << 24) | ((x << 8) & 0x00FF0000) | ((x >> 8) & 0x0000FF00) | (x >> 24);
+}
+
+u_int8_t OggFileParser::parseInitialPage() {
+    u_int8_t  header_type_flag;
+    u_int32_t bitstream_serial_number;
+    parseStartOfPage(header_type_flag, bitstream_serial_number);
+
+    // If this is a BOS page, examine the first 8 bytes of the first 'packet', to see whether
+    // the track data type is one that we know how to stream:
+    OggTrack *track;
+    if((header_type_flag & 0x02) != 0) {                                  // BOS
+        char const *mimeType = NULL;                                      // if unknown
+        if(fPacketSizeTable != NULL && fPacketSizeTable->size[0] >= 8) {  // sanity check
+            char buf[8];
+            testBytes((u_int8_t *)buf, 8);
+
+            if(strncmp(&buf[1], "vorbis", 6) == 0) {
+                mimeType = "audio/VORBIS";
+                ++fNumUnfulfilledTracks;
+            }
+            else if(strncmp(buf, "OpusHead", 8) == 0) {
+                mimeType = "audio/OPUS";
+                ++fNumUnfulfilledTracks;
+            }
+            else if(strncmp(&buf[1], "theora", 6) == 0) {
+                mimeType = "video/THEORA";
+                ++fNumUnfulfilledTracks;
+            }
+        }
+
+        // Add a new track descriptor for this track:
+        track              = new OggTrack;
+        track->trackNumber = bitstream_serial_number;
+        track->mimeType    = mimeType;
+        fOurFile.addTrack(track);
+    }
+    else {  // not a BOS page
+        // Because this is not a BOS page, the specified track should already have been seen:
+        track = fOurFile.lookup(bitstream_serial_number);
+    }
+
+    if(track != NULL) {  // sanity check
+#ifdef DEBUG
+        fprintf(stderr, "This track's MIME type: %s\n", track->mimeType == NULL ? "(unknown)" : track->mimeType);
+#endif
+        if(track->mimeType != NULL
+           && (strcmp(track->mimeType, "audio/VORBIS") == 0 || strcmp(track->mimeType, "video/THEORA") == 0 || strcmp(track->mimeType, "audio/OPUS") == 0)) {
+            // Special-case handling of Vorbis, Theora, or Opus tracks:
+            // Make a copy of each packet, until we get the three special headers that we need:
+            Boolean isVorbis = strcmp(track->mimeType, "audio/VORBIS") == 0;
+            Boolean isTheora = strcmp(track->mimeType, "video/THEORA") == 0;
+
+            for(unsigned j = 0; j < fPacketSizeTable->numCompletedPackets && track->weNeedHeaders(); ++j) {
+                unsigned const packetSize = fPacketSizeTable->size[j];
+                if(packetSize == 0)
+                    continue;  // sanity check
+
+                delete[] fSavedPacket /*if any*/;
+                fSavedPacket = new u_int8_t[packetSize];
+                getBytes(fSavedPacket, packetSize);
+                fPacketSizeTable->totSizes -= packetSize;
+
+                // The start of the packet tells us whether its a header that we know about:
+                Boolean  headerIsKnown = False;
+                unsigned index         = 0;
+                if(isVorbis) {
+                    u_int8_t const firstByte = fSavedPacket[0];
+
+                    headerIsKnown = firstByte == 1 || firstByte == 3 || firstByte == 5;
+                    index         = (firstByte - 1) / 2;  // 1, 3, or 5 => 0, 1, or 2
+                }
+                else if(isTheora) {
+                    u_int8_t const firstByte = fSavedPacket[0];
+
+                    headerIsKnown = firstByte == 0x80 || firstByte == 0x81 || firstByte == 0x82;
+                    index         = firstByte & ~0x80;  // 0x80, 0x81, or 0x82 => 0, 1, or 2
+                }
+                else {  // Opus
+                    if(strncmp((char const *)fSavedPacket, "OpusHead", 8) == 0) {
+                        headerIsKnown = True;
+                        index         = 0;  // "identification" header
+                    }
+                    else if(strncmp((char const *)fSavedPacket, "OpusTags", 8) == 0) {
+                        headerIsKnown = True;
+                        index         = 1;  // "comment" header
+                    }
+                }
+                if(headerIsKnown) {
+#ifdef DEBUG
+                    char const *headerName[3] = { "identification", "comment", "setup" };
+                    fprintf(stderr, "Saved %d-byte %s \"%s\" header\n", packetSize, track->mimeType, headerName[index]);
+#endif
+                    // This is a header, but first check it for validity:
+                    if(!validateHeader(track, fSavedPacket, packetSize))
+                        continue;
+
+                    // Save this header (deleting any old header of the same type that we'd saved before)
+                    delete[] track->vtoHdrs.header[index];
+                    track->vtoHdrs.header[index]     = fSavedPacket;
+                    fSavedPacket                     = NULL;
+                    track->vtoHdrs.headerSize[index] = packetSize;
+
+                    if(!track->weNeedHeaders()) {
+                        // We now have all of the needed Vorbis, Theora, or Opus headers for this track:
+                        --fNumUnfulfilledTracks;
+                    }
+                    // Note: The above code won't work if a required header is fragmented over
+                    // more than one 'page'.  We assume that that won't ever happen...
+                }
+            }
+        }
+    }
+
+    // Skip over any remaining packet data bytes:
+    if(fPacketSizeTable->totSizes > 0) {
+#ifdef DEBUG
+        fprintf(stderr, "Skipping %d remaining packet data bytes\n", fPacketSizeTable->totSizes);
+#endif
+        skipBytes(fPacketSizeTable->totSizes);
+    }
+
+    return header_type_flag;
+}
+
+// A simple bit vector class for reading bits in little-endian order.
+// (We can't use our usual "BitVector" class, because that's big-endian.)
+class LEBitVector {
+public:
+    LEBitVector(u_int8_t const *p, unsigned numBytes) : fPtr(p), fEnd(&p[numBytes]), fNumBitsRemainingInCurrentByte(8) {}
+
+    u_int32_t getBits(unsigned numBits /*<=32*/) {
+        if(noMoreBits()) {
+            return 0;
+        }
+        else if(numBits == fNumBitsRemainingInCurrentByte) {
+            u_int32_t result               = (*fPtr++) >> (8 - fNumBitsRemainingInCurrentByte);
+            fNumBitsRemainingInCurrentByte = 8;
+
+            return result;
+        }
+        else if(numBits < fNumBitsRemainingInCurrentByte) {
+            u_int8_t  mask   = 0xFF >> (8 - numBits);
+            u_int32_t result = ((*fPtr) >> (8 - fNumBitsRemainingInCurrentByte)) & mask;
+            fNumBitsRemainingInCurrentByte -= numBits;
+
+            return result;
+        }
+        else {  // numBits > fNumBitsRemainingInCurrentByte
+            // Do two recursive calls to get the result:
+            unsigned  nbr       = fNumBitsRemainingInCurrentByte;
+            u_int32_t firstBits = getBits(nbr);
+            u_int32_t nextBits  = getBits(numBits - nbr);
+
+            return (nextBits << nbr) | firstBits;
+        }
+    }
+
+    void skipBits(unsigned numBits) {
+        while(numBits > 32) {
+            (void)getBits(32);
+            numBits -= 32;
+        }
+        (void)getBits(numBits);
+    }
+
+    unsigned numBitsRemaining() {
+        return (fEnd - fPtr - 1) * 8 + fNumBitsRemainingInCurrentByte;
+    }
+    Boolean noMoreBits() const {
+        return fPtr >= fEnd;
+    }
+
+private:
+    u_int8_t const *fPtr;
+    u_int8_t const *fEnd;
+    unsigned        fNumBitsRemainingInCurrentByte;  // 1..8
+};
+
+static unsigned ilog(int n) {
+    if(n < 0)
+        return 0;
+
+    unsigned x      = (unsigned)n;
+    unsigned result = 0;
+
+    while(x > 0) {
+        ++result;
+        x >>= 1;
+    }
+
+    return result;
+}
+
+static unsigned lookup1_values(unsigned codebook_entries, unsigned codebook_dimensions) {
+    // "the greatest integer value for which [return_value] to the power of [codebook_dimensions]
+    //  is less than or equal to [codebook_entries]"
+    unsigned return_value = 0;
+    unsigned powerValue;
+
+    do {
+        ++return_value;
+        // Compute powerValue = return_value ** codebook_dimensions
+        if(return_value == 1)
+            powerValue = 1;  // optimization
+        else {
+            powerValue = 1;
+            for(unsigned i = 0; i < codebook_dimensions; ++i) {
+                powerValue *= return_value;
+            }
+        }
+    } while(powerValue <= codebook_entries);
+    return_value -= 1;
+
+    return return_value;
+}
+
+static Boolean parseVorbisSetup_codebook(LEBitVector &bv) {
+    if(bv.noMoreBits())
+        return False;
+
+    unsigned sync = bv.getBits(24);
+    if(sync != 0x564342)
+        return False;
+    unsigned codebook_dimensions = bv.getBits(16);
+    unsigned codebook_entries    = bv.getBits(24);
+    unsigned ordered             = bv.getBits(1);
+#ifdef DEBUG_SETUP_HEADER
+    fprintf(stderr, "\t\t\tcodebook_dimensions: %d; codebook_entries: %d, ordered: %d\n", codebook_dimensions, codebook_entries, ordered);
+#endif
+    if(!ordered) {
+        unsigned sparse = bv.getBits(1);
+#ifdef DEBUG_SETUP_HEADER
+        fprintf(stderr, "\t\t\t!ordered: sparse %d\n", sparse);
+#endif
+        for(unsigned i = 0; i < codebook_entries; ++i) {
+            unsigned codewordLength;
+
+            if(sparse) {
+                unsigned flag = bv.getBits(1);
+                if(flag) {
+                    codewordLength = bv.getBits(5) + 1;
+                }
+                else {
+                    codewordLength = 0;
+                }
+            }
+            else {
+                codewordLength = bv.getBits(5) + 1;
+            }
+#ifdef DEBUG_SETUP_HEADER
+            fprintf(stderr, "\t\t\t\tcodeword length[%d]:\t%d\n", i, codewordLength);
+#else
+            codewordLength = codewordLength;  // to prevent compiler warning
+#endif
+        }
+    }
+    else {  // ordered
+#ifdef DEBUG_SETUP_HEADER
+        fprintf(stderr, "\t\t\tordered:\n");
+#endif
+        unsigned current_entry  = 0;
+        unsigned current_length = bv.getBits(5) + 1;
+        do {
+            unsigned number = bv.getBits(ilog(codebook_entries - current_entry));
+#ifdef DEBUG_SETUP_HEADER
+            fprintf(stderr, "\t\t\t\tcodeword length[%d..%d]:\t%d\n", current_entry, current_entry + number - 1, current_length);
+#endif
+            current_entry += number;
+            if(current_entry > codebook_entries) {
+                fprintf(stderr, "Vorbis codebook parsing error: current_entry %d > codebook_entries %d!\n", current_entry, codebook_entries);
+                return False;
+            }
+            ++current_length;
+        } while(current_entry < codebook_entries);
+    }
+
+    unsigned codebook_lookup_type = bv.getBits(4);
+#ifdef DEBUG_SETUP_HEADER
+    fprintf(stderr, "\t\t\tcodebook_lookup_type: %d\n", codebook_lookup_type);
+#endif
+    if(codebook_lookup_type > 2) {
+        fprintf(stderr, "Vorbis codebook parsing error: codebook_lookup_type %d!\n", codebook_lookup_type);
+        return False;
+    }
+    else if(codebook_lookup_type > 0) {  // 1 or 2
+        bv.skipBits(32 + 32);            // "codebook_minimum_value" and "codebook_delta_value"
+        unsigned codebook_value_bits = bv.getBits(4) + 1;
+        bv.skipBits(1);  // "codebook_lookup_p"
+        unsigned codebook_lookup_values;
+        if(codebook_lookup_type == 1) {
+            codebook_lookup_values = lookup1_values(codebook_entries, codebook_dimensions);
+        }
+        else {  // 2
+            codebook_lookup_values = codebook_entries * codebook_dimensions;
+        }
+
+        bv.skipBits(codebook_lookup_values * codebook_value_bits);  // "codebook_multiplicands"
+    }
+
+    return True;
+}
+
+static Boolean parseVorbisSetup_codebooks(LEBitVector &bv) {
+    if(bv.noMoreBits())
+        return False;
+
+    unsigned vorbis_codebook_count = bv.getBits(8) + 1;
+#ifdef DEBUG_SETUP_HEADER
+    fprintf(stderr, "\tCodebooks: vorbis_codebook_count: %d\n", vorbis_codebook_count);
+#endif
+    for(unsigned i = 0; i < vorbis_codebook_count; ++i) {
+#ifdef DEBUG_SETUP_HEADER
+        fprintf(stderr, "\t\tCodebook %d:\n", i);
+#endif
+        if(!parseVorbisSetup_codebook(bv))
+            return False;
+    }
+
+    return True;
+}
+
+static Boolean parseVorbisSetup_timeDomainTransforms(LEBitVector &bv) {
+    if(bv.noMoreBits())
+        return False;
+
+    unsigned vorbis_time_count = bv.getBits(6) + 1;
+#ifdef DEBUG_SETUP_HEADER
+    fprintf(stderr, "\tTime domain transforms: vorbis_time_count: %d\n", vorbis_time_count);
+#endif
+    for(unsigned i = 0; i < vorbis_time_count; ++i) {
+        unsigned val = bv.getBits(16);
+        if(val != 0) {
+            fprintf(stderr, "Vorbis Time domain transforms, read non-zero value %d\n", val);
+            return False;
+        }
+    }
+
+    return True;
+}
+
+static Boolean parseVorbisSetup_floors(LEBitVector &bv) {
+    if(bv.noMoreBits())
+        return False;
+
+    unsigned vorbis_floor_count = bv.getBits(6) + 1;
+#ifdef DEBUG_SETUP_HEADER
+    fprintf(stderr, "\tFloors: vorbis_floor_count: %d\n", vorbis_floor_count);
+#endif
+    for(unsigned i = 0; i < vorbis_floor_count; ++i) {
+        unsigned floorType = bv.getBits(16);
+        if(floorType == 0) {
+            bv.skipBits(8 + 16 + 16 + 6 + 8);
+            unsigned floor0_number_of_books = bv.getBits(4) + 1;
+            bv.skipBits(floor0_number_of_books * 8);
+        }
+        else if(floorType == 1) {
+            unsigned floor1_partitions = bv.getBits(5);
+
+            unsigned *floor1_partition_class_list = new unsigned[floor1_partitions];
+            unsigned  maximum_class               = 0, j;
+            for(j = 0; j < floor1_partitions; ++j) {
+                floor1_partition_class_list[j] = bv.getBits(4);
+                if(floor1_partition_class_list[j] > maximum_class)
+                    maximum_class = floor1_partition_class_list[j];
+            }
+
+            unsigned *floor1_class_dimensions = new unsigned[maximum_class + 1];
+            for(j = 0; j <= maximum_class; ++j) {
+                floor1_class_dimensions[j]       = bv.getBits(3) + 1;
+                unsigned floor1_class_subclasses = bv.getBits(2);
+                if(floor1_class_subclasses != 0) {
+                    bv.skipBits(8);  // "floor1_class_masterbooks[j]"
+                }
+
+                unsigned twoExp_floor1_class_subclasses = 1 << floor1_class_subclasses;
+                bv.skipBits(twoExp_floor1_class_subclasses * 8);  // "floor1_subclass_books[j][*]"
+            }
+
+            bv.skipBits(2);  // "floor1_multiplier"
+            unsigned rangebits = bv.getBits(4);
+            for(j = 0; j < floor1_partitions; ++j) {
+                unsigned current_class_number = floor1_partition_class_list[j];
+                bv.skipBits(floor1_class_dimensions[current_class_number] * rangebits);
+            }
+
+            delete[] floor1_partition_class_list;
+            delete[] floor1_class_dimensions;
+        }
+        else {  // floorType > 1
+            fprintf(stderr, "Vorbis Floors, read bad floor type %d\n", floorType);
+            return False;
+        }
+    }
+
+    return True;
+}
+
+static Boolean parseVorbisSetup_residues(LEBitVector &bv) {
+    if(bv.noMoreBits())
+        return False;
+
+    unsigned vorbis_residue_count = bv.getBits(6) + 1;
+#ifdef DEBUG_SETUP_HEADER
+    fprintf(stderr, "\tResidues: vorbis_residue_count: %d\n", vorbis_residue_count);
+#endif
+    for(unsigned i = 0; i < vorbis_residue_count; ++i) {
+        unsigned vorbis_residue_type = bv.getBits(16);
+        if(vorbis_residue_type > 2) {
+            fprintf(stderr, "Vorbis Residues, read bad vorbis_residue_type: %d\n", vorbis_residue_type);
+            return False;
+        }
+        else {
+            bv.skipBits(24 + 24 + 24);  // "residue_begin", "residue_end", "residue_partition_size"
+            unsigned residue_classifications = bv.getBits(6) + 1;
+            bv.skipBits(8);  // "residue_classbook"
+
+            u_int8_t *residue_cascade = new u_int8_t[residue_classifications];
+            unsigned  j;
+            for(j = 0; j < residue_classifications; ++j) {
+                u_int8_t high_bits = 0;
+                u_int8_t low_bits  = bv.getBits(3);
+                unsigned bitflag   = bv.getBits(1);
+                if(bitflag) {
+                    high_bits = bv.getBits(5);
+                }
+
+                residue_cascade[j] = (high_bits << 3) | low_bits;
+            }
+
+            for(j = 0; j < residue_classifications; ++j) {
+                u_int8_t const cascade = residue_cascade[j];
+                u_int8_t       mask    = 0x80;
+                while(mask != 0) {
+                    if((cascade & mask) != 0)
+                        bv.skipBits(8);  // "residue_books[j][*]"
+                    mask >>= 1;
+                }
+            }
+
+            delete[] residue_cascade;
+        }
+    }
+
+    return True;
+}
+
+static Boolean parseVorbisSetup_mappings(LEBitVector &bv, unsigned audio_channels) {
+    if(bv.noMoreBits())
+        return False;
+
+    unsigned vorbis_mapping_count = bv.getBits(6) + 1;
+#ifdef DEBUG_SETUP_HEADER
+    fprintf(stderr, "\tMappings: vorbis_mapping_count: %d\n", vorbis_mapping_count);
+#endif
+    for(unsigned i = 0; i < vorbis_mapping_count; ++i) {
+        unsigned vorbis_mapping_type = bv.getBits(16);
+        if(vorbis_mapping_type != 0) {
+            fprintf(stderr, "Vorbis Mappings, read bad vorbis_mapping_type: %d\n", vorbis_mapping_type);
+            return False;
+        }
+
+        unsigned vorbis_mapping_submaps = 1;
+        if(bv.getBits(1))
+            vorbis_mapping_submaps = bv.getBits(4) + 1;
+
+        if(bv.getBits(1)) {  // "square polar channel mapping is in use"
+            unsigned vorbis_mapping_coupling_steps = bv.getBits(8) + 1;
+
+            for(unsigned j = 0; j < vorbis_mapping_coupling_steps; ++j) {
+                unsigned ilog_audio_channels_minus_1 = ilog(audio_channels - 1);
+                bv.skipBits(2 * ilog_audio_channels_minus_1);  // "vorbis_mapping_magnitude", "vorbis_mapping_angle"
+            }
+        }
+
+        unsigned reserved = bv.getBits(2);
+        if(reserved != 0) {
+            fprintf(stderr, "Vorbis Mappings, read bad 'reserved' field\n");
+            return False;
+        }
+
+        if(vorbis_mapping_submaps > 1) {
+            for(unsigned j = 0; j < audio_channels; ++j) {
+                unsigned vorbis_mapping_mux = bv.getBits(4);
+
+                fprintf(stderr, "\t\t\t\tvorbis_mapping_mux[%d]: %d\n", j, vorbis_mapping_mux);
+                if(vorbis_mapping_mux >= vorbis_mapping_submaps) {
+                    fprintf(stderr, "Vorbis Mappings, read bad \"vorbis_mapping_mux\" %d (>= \"vorbis_mapping_submaps\" %d)\n", vorbis_mapping_mux,
+                            vorbis_mapping_submaps);
+                    return False;
+                }
+            }
+        }
+
+        bv.skipBits(vorbis_mapping_submaps * (8 + 8 + 8));  // "the floor and residue numbers"
+    }
+
+    return True;
+}
+
+static Boolean parseVorbisSetup_modes(LEBitVector &bv, OggTrack *track) {
+    if(bv.noMoreBits())
+        return False;
+
+    unsigned vorbis_mode_count              = bv.getBits(6) + 1;
+    unsigned ilog_vorbis_mode_count_minus_1 = ilog(vorbis_mode_count - 1);
+#ifdef DEBUG_SETUP_HEADER
+    fprintf(stderr, "\tModes: vorbis_mode_count: %d (ilog(%d-1):%d)\n", vorbis_mode_count, vorbis_mode_count, ilog_vorbis_mode_count_minus_1);
+#endif
+    track->vtoHdrs.vorbis_mode_count              = vorbis_mode_count;
+    track->vtoHdrs.ilog_vorbis_mode_count_minus_1 = ilog_vorbis_mode_count_minus_1;
+    track->vtoHdrs.vorbis_mode_blockflag          = new u_int8_t[vorbis_mode_count];
+
+    for(unsigned i = 0; i < vorbis_mode_count; ++i) {
+        track->vtoHdrs.vorbis_mode_blockflag[i] = (u_int8_t)bv.getBits(1);
+#ifdef DEBUG_SETUP_HEADER
+        fprintf(stderr, "\t\tMode %d: vorbis_mode_blockflag: %d\n", i, track->vtoHdrs.vorbis_mode_blockflag[i]);
+#endif
+        bv.skipBits(16 + 16 + 8);  // "vorbis_mode_windowtype", "vorbis_mode_transformtype", "vorbis_mode_mapping"
+    }
+
+    return True;
+}
+
+static Boolean parseVorbisSetupHeader(OggTrack *track, u_int8_t const *p, unsigned headerSize) {
+    LEBitVector bv(p, headerSize);
+    do {
+        if(!parseVorbisSetup_codebooks(bv))
+            break;
+        if(!parseVorbisSetup_timeDomainTransforms(bv))
+            break;
+        if(!parseVorbisSetup_floors(bv))
+            break;
+        if(!parseVorbisSetup_residues(bv))
+            break;
+        if(!parseVorbisSetup_mappings(bv, track->numChannels))
+            break;
+        if(!parseVorbisSetup_modes(bv, track))
+            break;
+        unsigned framingFlag = bv.getBits(1);
+        if(framingFlag == 0) {
+            fprintf(stderr, "Vorbis \"setup\" header did not end with a 'framing flag'!\n");
+            break;
+        }
+
+        return True;
+    } while(0);
+
+    // An error occurred:
+    return False;
+}
+
+#ifdef DEBUG
+#define CHECK_PTR \
+    if(p >= pEnd) \
+    return False
+#define printComment(p, len)                \
+    do {                                    \
+        for(unsigned k = 0; k < len; ++k) { \
+            CHECK_PTR;                      \
+            fprintf(stderr, "%c", *p++);    \
+        }                                   \
+    } while(0)
+#endif
+
+static Boolean validateCommentHeader(u_int8_t const *p, unsigned headerSize, unsigned isOpus = 0) {
+    if(headerSize < 15 + isOpus) {  // need 7+isOpus + 4(vendor_length) + 4(user_comment_list_length)
+        fprintf(stderr, "\"comment\" header is too short (%d bytes)\n", headerSize);
+        return False;
+    }
+
+#ifdef DEBUG
+    u_int8_t const *pEnd = &p[headerSize];
+    p += 7 + isOpus;
+
+    u_int32_t vendor_length = (p[3] << 24) | (p[2] << 16) | (p[1] << 8) | p[0];
+    p += 4;
+    fprintf(stderr, "\tvendor_string:");
+    printComment(p, vendor_length);
+    fprintf(stderr, "\n");
+
+    u_int32_t user_comment_list_length = (p[3] << 24) | (p[2] << 16) | (p[1] << 8) | p[0];
+    p += 4;
+    for(unsigned i = 0; i < user_comment_list_length; ++i) {
+        CHECK_PTR;
+        u_int32_t length = (p[3] << 24) | (p[2] << 16) | (p[1] << 8) | p[0];
+        p += 4;
+        fprintf(stderr, "\tuser_comment[%d]:", i);
+        printComment(p, length);
+        fprintf(stderr, "\n");
+    }
+#endif
+
+    return True;
+}
+
+static unsigned blocksizeFromExponent(unsigned exponent) {
+    unsigned result = 1;
+    for(unsigned i = 0; i < exponent; ++i)
+        result = 2 * result;
+    return result;
+}
+
+Boolean OggFileParser::validateHeader(OggTrack *track, u_int8_t const *p, unsigned headerSize) {
+    // Assert: headerSize >= 7 (because we've already checked "<packet_type>XXXXXX" or "OpusXXXX")
+    if(strcmp(track->mimeType, "audio/VORBIS") == 0) {
+        u_int8_t const firstByte = p[0];
+
+        if(firstByte == 1) {  // "identification" header
+            if(headerSize < 30) {
+                fprintf(stderr, "Vorbis \"identification\" header is too short (%d bytes)\n", headerSize);
+                return False;
+            }
+            else if((p[29] & 0x1) != 1) {
+                fprintf(stderr, "Vorbis \"identification\" header: 'framing_flag' is not set\n");
+                return False;
+            }
+
+            p += 7;
+            u_int32_t vorbis_version = (p[3] << 24) | (p[2] << 16) | (p[1] << 8) | p[0];
+            p += 4;
+            if(vorbis_version != 0) {
+                fprintf(stderr, "Vorbis \"identification\" header has a bad 'vorbis_version': 0x%08x\n", vorbis_version);
+                return False;
+            }
+
+            u_int8_t audio_channels = *p++;
+            if(audio_channels == 0) {
+                fprintf(stderr, "Vorbis \"identification\" header: 'audio_channels' is 0!\n");
+                return False;
+            }
+            track->numChannels = audio_channels;
+
+            u_int32_t audio_sample_rate = (p[3] << 24) | (p[2] << 16) | (p[1] << 8) | p[0];
+            p += 4;
+            if(audio_sample_rate == 0) {
+                fprintf(stderr, "Vorbis \"identification\" header: 'audio_sample_rate' is 0!\n");
+                return False;
+            }
+            track->samplingFrequency = audio_sample_rate;
+
+            p += 4;  // skip over 'bitrate_maximum'
+            u_int32_t bitrate_nominal = (p[3] << 24) | (p[2] << 16) | (p[1] << 8) | p[0];
+            p += 4;
+            if(bitrate_nominal > 0)
+                track->estBitrate = (bitrate_nominal + 500) / 1000;  // round
+
+            p += 4;  // skip over 'bitrate_maximum'
+
+            // Note the two 'block sizes' (samples per packet), and their durations in microseconds:
+            u_int8_t  blocksizeBits = *p++;
+            unsigned &blocksize_0   = track->vtoHdrs.blocksize[0];  // alias
+            unsigned &blocksize_1   = track->vtoHdrs.blocksize[1];  // alias
+            blocksize_0             = blocksizeFromExponent(blocksizeBits & 0x0F);
+            blocksize_1             = blocksizeFromExponent(blocksizeBits >> 4);
+
+            double uSecsPerSample = 1000000.0 / (track->samplingFrequency * 2);
+            // Why the "2"?  I don't know, but it seems to be necessary
+            track->vtoHdrs.uSecsPerPacket[0] = (unsigned)(uSecsPerSample * blocksize_0);
+            track->vtoHdrs.uSecsPerPacket[1] = (unsigned)(uSecsPerSample * blocksize_1);
+#ifdef DEBUG
+            fprintf(stderr, "\t%u Hz, %u-channel, %u kbps (est), block sizes: %u,%u (%u,%u us)\n", track->samplingFrequency, track->numChannels,
+                    track->estBitrate, blocksize_0, blocksize_1, track->vtoHdrs.uSecsPerPacket[0], track->vtoHdrs.uSecsPerPacket[1]);
+#endif
+            // To be valid, "blocksize_0" must be <= "blocksize_1", and both must be in [64,8192]:
+            if(!(blocksize_0 <= blocksize_1 && blocksize_0 >= 64 && blocksize_1 <= 8192)) {
+                fprintf(stderr, "Invalid Vorbis \"blocksize_0\" (%d) and/or \"blocksize_1\" (%d)!\n", blocksize_0, blocksize_1);
+                return False;
+            }
+        }
+        else if(firstByte == 3) {  // "comment" header
+            if(!validateCommentHeader(p, headerSize))
+                return False;
+        }
+        else if(firstByte == 5) {  // "setup" header
+            // Parse the "setup" header to get the values that we want:
+            // "vorbis_mode_count", and "vorbis_mode_blockflag" for each mode.  Unfortunately these come
+            // near the end of the header, so we have to parse lots of other crap first.
+            p += 7;
+            if(!parseVorbisSetupHeader(track, p, headerSize)) {
+                fprintf(stderr, "Failed to parse Vorbis \"setup\" header!\n");
+                return False;
+            }
+        }
+    }
+    else if(strcmp(track->mimeType, "video/THEORA") == 0) {
+        u_int8_t const firstByte = p[0];
+
+        if(firstByte == 0x80) {  // "identification" header
+            if(headerSize < 42) {
+                fprintf(stderr, "Theora \"identification\" header is too short (%d bytes)\n", headerSize);
+                return False;
+            }
+            else if((p[41] & 0x7) != 0) {
+                fprintf(stderr, "Theora \"identification\" header: 'res' bits are non-zero\n");
+                return False;
+            }
+
+            track->vtoHdrs.KFGSHIFT = ((p[40] & 3) << 3) | (p[41] >> 5);
+            u_int32_t FRN           = (p[22] << 24) | (p[23] << 16) | (p[24] << 8) | p[25];  // Frame rate numerator
+            u_int32_t FRD           = (p[26] << 24) | (p[27] << 16) | (p[28] << 8) | p[29];  // Frame rate numerator
+#ifdef DEBUG
+            fprintf(stderr, "\tKFGSHIFT %d, Frame rate numerator %d, Frame rate denominator %d\n", track->vtoHdrs.KFGSHIFT, FRN, FRD);
+#endif
+            if(FRN == 0 || FRD == 0) {
+                fprintf(stderr, "Theora \"identification\" header: Bad FRN and/or FRD values: %d, %d\n", FRN, FRD);
+                return False;
+            }
+            track->vtoHdrs.uSecsPerFrame = (unsigned)((1000000.0 * FRD) / FRN);
+#ifdef DEBUG
+            fprintf(stderr, "\t\t=> %u microseconds per frame\n", track->vtoHdrs.uSecsPerFrame);
+#endif
+        }
+        else if(firstByte == 0x81) {  // "comment" header
+            if(!validateCommentHeader(p, headerSize))
+                return False;
+        }
+        else if(firstByte == 0x82) {  // "setup" header
+                                      // We don't care about the contents of the Theora "setup" header; just assume it's valid
+        }
+    }
+    else {                                                  // Opus audio
+        if(strncmp((char const *)p, "OpusHead", 8) == 0) {  // "identification" header
+            // Just check the size, and the 'major' number of the version byte:
+            if(headerSize < 19 || (p[8] & 0xF0) != 0)
+                return False;
+        }
+        else {  // comment header
+            if(!validateCommentHeader(p, headerSize, 1 /*isOpus*/))
+                return False;
+        }
+    }
+
+    return True;
+}
+
+void OggFileParser::parseAndDeliverPages() {
+#ifdef DEBUG
+    fprintf(stderr, "parsing and delivering data\n");
+#endif
+    while(parseAndDeliverPage()) {
+    }
+}
+
+Boolean OggFileParser::parseAndDeliverPage() {
+    u_int8_t  header_type_flag;
+    u_int32_t bitstream_serial_number;
+    parseStartOfPage(header_type_flag, bitstream_serial_number);
+
+    OggDemuxedTrack *demuxedTrack = fOurDemux->lookupDemuxedTrack(bitstream_serial_number);
+    if(demuxedTrack == NULL) {  // this track is not being read
+#ifdef DEBUG
+        fprintf(stderr, "\tIgnoring page from unread track; skipping %d remaining packet data bytes\n", fPacketSizeTable->totSizes);
+#endif
+        skipBytes(fPacketSizeTable->totSizes);
+        return True;
+    }
+    else if(fPacketSizeTable->totSizes == 0) {
+        // This page is empty (has no packets).  Skip it and continue
+#ifdef DEBUG
+        fprintf(stderr, "\t[track: %s] Skipping empty page\n", demuxedTrack->MIMEtype());
+#endif
+        return True;
+    }
+
+    // Start delivering packets next:
+    demuxedTrack->fCurrentPageIsContinuation = (header_type_flag & 0x01) != 0;
+    fCurrentTrackNumber                      = bitstream_serial_number;
+    fCurrentParseState                       = DELIVERING_PACKET_WITHIN_PAGE;
+    saveParserState();
+    return False;
+}
+
+Boolean OggFileParser::deliverPacketWithinPage() {
+    OggDemuxedTrack *demuxedTrack = fOurDemux->lookupDemuxedTrack(fCurrentTrackNumber);
+    if(demuxedTrack == NULL)
+        return False;  // should not happen
+
+    unsigned packetNum  = fPacketSizeTable->nextPacketNumToDeliver;
+    unsigned packetSize = fPacketSizeTable->size[packetNum];
+
+    if(!demuxedTrack->isCurrentlyAwaitingData()) {
+        // Someone has been reading this stream, but isn't right now.
+        // We can't deliver this frame until he asks for it, so punt for now.
+        // The next time he asks for a frame, he'll get it.
+#ifdef DEBUG
+        fprintf(stderr, "\t[track: %s] Deferring delivery of packet %d (%d bytes%s)\n", demuxedTrack->MIMEtype(), packetNum, packetSize,
+                packetNum == fPacketSizeTable->numCompletedPackets ? " (incomplete)" : "");
+#endif
+        return True;
+    }
+
+    // Deliver the next packet:
+#ifdef DEBUG
+    fprintf(stderr, "\t[track: %s] Delivering packet %d (%d bytes%s)\n", demuxedTrack->MIMEtype(), packetNum, packetSize,
+            packetNum == fPacketSizeTable->numCompletedPackets ? " (incomplete)" : "");
+#endif
+    unsigned numBytesDelivered = packetSize < demuxedTrack->maxSize() ? packetSize : demuxedTrack->maxSize();
+    getBytes(demuxedTrack->to(), numBytesDelivered);
+    u_int8_t firstByte  = numBytesDelivered > 0 ? demuxedTrack->to()[0] : 0x00;
+    u_int8_t secondByte = numBytesDelivered > 1 ? demuxedTrack->to()[1] : 0x00;
+    demuxedTrack->to() += numBytesDelivered;
+
+    if(demuxedTrack->fCurrentPageIsContinuation) {  // the previous page's read was incomplete
+        demuxedTrack->frameSize() += numBytesDelivered;
+    }
+    else {
+        // This is the first delivery for this "doGetNextFrame()" call.
+        demuxedTrack->frameSize() = numBytesDelivered;
+    }
+    if(packetSize > demuxedTrack->maxSize()) {
+        demuxedTrack->numTruncatedBytes() += packetSize - demuxedTrack->maxSize();
+    }
+    demuxedTrack->maxSize() -= numBytesDelivered;
+
+    // Figure out the duration and presentation time of this frame.
+    unsigned  durationInMicroseconds;
+    OggTrack *track = fOurFile.lookup(demuxedTrack->fOurTrackNumber);
+
+    if(strcmp(track->mimeType, "audio/VORBIS") == 0) {
+        if((firstByte & 0x01) != 0) {  // This is a header packet
+            durationInMicroseconds = 0;
+        }
+        else {  // This is a data packet.
+            // Parse the first byte to figure out its duration.
+            // Extract the next "track->vtoHdrs.ilog_vorbis_mode_count_minus_1" bits of the first byte:
+            u_int8_t const mask       = 0xFE << (track->vtoHdrs.ilog_vorbis_mode_count_minus_1);
+            u_int8_t const modeNumber = (firstByte & ~mask) >> 1;
+            if(modeNumber >= track->vtoHdrs.vorbis_mode_count) {
+                fprintf(stderr, "Error: Bad mode number %d (>= vorbis_mode_count %d) in Vorbis packet!\n", modeNumber, track->vtoHdrs.vorbis_mode_count);
+                durationInMicroseconds = 0;
+            }
+            else {
+                unsigned blockNumber   = track->vtoHdrs.vorbis_mode_blockflag[modeNumber];
+                durationInMicroseconds = track->vtoHdrs.uSecsPerPacket[blockNumber];
+            }
+        }
+    }
+    else if(strcmp(track->mimeType, "video/THEORA") == 0) {
+        if((firstByte & 0x80) != 0) {  // This is a header packet
+            durationInMicroseconds = 0;
+        }
+        else {  // This is a data packet.
+            durationInMicroseconds = track->vtoHdrs.uSecsPerFrame;
+        }
+    }
+    else {                                                            // "audio/OPUS"
+        if(firstByte == 0x4F /*'O'*/ && secondByte == 0x70 /*'p*/) {  // This is a header packet
+            durationInMicroseconds = 0;
+        }
+        else {  // This is a data packet.
+            // Parse the first byte to figure out the duration of each frame, and then (if necessary)
+            // parse the second byte to figure out how many frames are in this packet:
+            u_int8_t       config             = firstByte >> 3;
+            u_int8_t       c                  = firstByte & 0x03;
+            unsigned const configDuration[32] = {
+                // in microseconds
+                10000, 20000, 40000, 60000,  // config 0..3
+                10000, 20000, 40000, 60000,  // config 4..7
+                10000, 20000, 40000, 60000,  // config 8..11
+                10000, 20000,                // config 12..13
+                10000, 20000,                // config 14..15
+                2500,  5000,  10000, 20000,  // config 16..19
+                2500,  5000,  10000, 20000,  // config 20..23
+                2500,  5000,  10000, 20000,  // config 24..27
+                2500,  5000,  10000, 20000   // config 28..31
+            };
+            unsigned const numFramesInPacket = c == 0 ? 1 : c == 3 ? (secondByte & 0x3F) : 2;
+            durationInMicroseconds           = numFramesInPacket * configDuration[config];
+        }
+    }
+
+    if(demuxedTrack->nextPresentationTime().tv_sec == 0 && demuxedTrack->nextPresentationTime().tv_usec == 0) {
+        // This is the first delivery.  Initialize "demuxedTrack->nextPresentationTime()":
+        gettimeofday(&demuxedTrack->nextPresentationTime(), NULL);
+    }
+    demuxedTrack->presentationTime()       = demuxedTrack->nextPresentationTime();
+    demuxedTrack->durationInMicroseconds() = durationInMicroseconds;
+
+    demuxedTrack->nextPresentationTime().tv_usec += durationInMicroseconds;
+    while(demuxedTrack->nextPresentationTime().tv_usec >= 1000000) {
+        ++demuxedTrack->nextPresentationTime().tv_sec;
+        demuxedTrack->nextPresentationTime().tv_usec -= 1000000;
+    }
+    saveParserState();
+
+    // And check whether there's a next packet in this page:
+    if(packetNum == fPacketSizeTable->numCompletedPackets) {
+        // This delivery was for an incomplete packet, at the end of the page.
+        // Return without completing delivery:
+        fCurrentParseState = PARSING_AND_DELIVERING_PAGES;
+        return False;
+    }
+
+    if(packetNum < fPacketSizeTable->numCompletedPackets - 1 || fPacketSizeTable->lastPacketIsIncomplete) {
+        // There is at least one more packet (possibly incomplete) left in this packet.
+        // Deliver it next:
+        ++fPacketSizeTable->nextPacketNumToDeliver;
+    }
+    else {
+        // Start parsing a new page next:
+        fCurrentParseState = PARSING_AND_DELIVERING_PAGES;
+    }
+
+    FramedSource::afterGetting(demuxedTrack);  // completes delivery
+    return True;
+}
+
+void OggFileParser::parseStartOfPage(u_int8_t &header_type_flag, u_int32_t &bitstream_serial_number) {
+    saveParserState();
+    // First, make sure we start with the 'capture_pattern': 0x4F676753 ('OggS'):
+    while(test4Bytes() != 0x4F676753) {
+        skipBytes(1);
+        saveParserState();  // ensures forward progress through the file
+    }
+    skipBytes(4);
+#ifdef DEBUG
+    fprintf(stderr, "\nSaw Ogg page header:\n");
+#endif
+
+    u_int8_t stream_structure_version = get1Byte();
+    if(stream_structure_version != 0) {
+        fprintf(stderr, "Saw page with unknown Ogg file version number: 0x%02x\n", stream_structure_version);
+    }
+
+    header_type_flag = get1Byte();
+#ifdef DEBUG
+    fprintf(stderr, "\theader_type_flag: 0x%02x (", header_type_flag);
+    if(header_type_flag & 0x01)
+        fprintf(stderr, "continuation ");
+    if(header_type_flag & 0x02)
+        fprintf(stderr, "bos ");
+    if(header_type_flag & 0x04)
+        fprintf(stderr, "eos ");
+    fprintf(stderr, ")\n");
+#endif
+
+    u_int32_t granule_position1    = byteSwap(get4Bytes());
+    u_int32_t granule_position2    = byteSwap(get4Bytes());
+    bitstream_serial_number        = byteSwap(get4Bytes());
+    u_int32_t page_sequence_number = byteSwap(get4Bytes());
+    u_int32_t CRC_checksum         = byteSwap(get4Bytes());
+    u_int8_t  number_page_segments = get1Byte();
+#ifdef DEBUG
+    fprintf(stderr,
+            "\tgranule_position 0x%08x%08x, bitstream_serial_number 0x%08x, page_sequence_number 0x%08x, CRC_checksum 0x%08x, number_page_segments %d\n",
+            granule_position2, granule_position1, bitstream_serial_number, page_sequence_number, CRC_checksum, number_page_segments);
+#else
+    // Dummy statements to prevent 'unused variable' compiler warnings:
+#define DUMMY_STATEMENT(x) \
+    do {                   \
+        x = x;             \
+    } while(0)
+    DUMMY_STATEMENT(granule_position1);
+    DUMMY_STATEMENT(granule_position2);
+    DUMMY_STATEMENT(page_sequence_number);
+    DUMMY_STATEMENT(CRC_checksum);
+#endif
+
+    // Look at the "segment_table" to count the sizes of the packets in this page:
+    delete fPacketSizeTable /*if any*/;
+    fPacketSizeTable      = new PacketSizeTable(number_page_segments);
+    u_int8_t lacing_value = 0;
+#ifdef DEBUG
+    fprintf(stderr, "\tsegment_table\n");
+#endif
+    for(unsigned i = 0; i < number_page_segments; ++i) {
+        lacing_value = get1Byte();
+#ifdef DEBUG
+        fprintf(stderr, "\t\t%d:\t%d", i, lacing_value);
+#endif
+        fPacketSizeTable->totSizes += lacing_value;
+        fPacketSizeTable->size[fPacketSizeTable->numCompletedPackets] += lacing_value;
+        if(lacing_value < 255) {
+            // This completes a packet:
+#ifdef DEBUG
+            fprintf(stderr, " (->%d)", fPacketSizeTable->size[fPacketSizeTable->numCompletedPackets]);
+#endif
+            ++fPacketSizeTable->numCompletedPackets;
+        }
+#ifdef DEBUG
+        fprintf(stderr, "\n");
+#endif
+    }
+
+    fPacketSizeTable->lastPacketIsIncomplete = lacing_value == 255;
+}
diff --git a/3rdparty/live555/src/liveMedia/OggFileParser.hh b/3rdparty/live555/src/liveMedia/OggFileParser.hh
new file mode 100644
index 00000000..670ffee4
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/OggFileParser.hh
@@ -0,0 +1,91 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A parser for an Ogg file
+// C++ header
+
+#ifndef _OGG_FILE_PARSER_HH
+
+#ifndef _STREAM_PARSER_HH
+#include "StreamParser.hh"
+#endif
+#ifndef _OGG_FILE_HH
+#include "OggFile.hh"
+#endif
+
+// An enum representing the current state of the parser:
+enum OggParseState {
+  PARSING_START_OF_FILE,
+  PARSING_AND_DELIVERING_PAGES,
+  DELIVERING_PACKET_WITHIN_PAGE
+};
+
+// A structure that counts the sizes of 'packets' given by each page's "segment_table":
+class PacketSizeTable {
+public:
+  PacketSizeTable(unsigned number_page_segments);
+  ~PacketSizeTable();
+
+  unsigned numCompletedPackets; // will be <= "number_page_segments"
+  unsigned* size; // an array of sizes of each of the packets
+  unsigned totSizes;
+  unsigned nextPacketNumToDeliver;
+  Boolean lastPacketIsIncomplete; // iff the last segment's 'lacing' was 255
+};
+
+class OggFileParser: public StreamParser {
+public:
+  OggFileParser(OggFile& ourFile, FramedSource* inputSource,
+		FramedSource::onCloseFunc* onEndFunc, void* onEndClientData,
+		OggDemux* ourDemux = NULL);
+  virtual ~OggFileParser();
+
+  // StreamParser 'client continue' function:
+  static void continueParsing(void* clientData, unsigned char* ptr, unsigned size, struct timeval presentationTime);
+  void continueParsing();
+
+private:
+  Boolean needHeaders() { return fNumUnfulfilledTracks > 0; }
+
+  // Parsing functions:
+  Boolean parse(); // returns True iff we have finished parsing all BOS pages (on initialization)
+
+  Boolean parseStartOfFile();
+  u_int8_t parseInitialPage(); // returns the 'header_type_flag' byte
+  void parseAndDeliverPages();
+  Boolean parseAndDeliverPage();
+  Boolean deliverPacketWithinPage();
+  void parseStartOfPage(u_int8_t& header_type_flag, u_int32_t& bitstream_serial_number);
+
+  Boolean validateHeader(OggTrack* track, u_int8_t const* p, unsigned headerSize);
+
+private:
+  // General state for parsing:
+  OggFile& fOurFile;
+  FramedSource* fInputSource;
+  FramedSource::onCloseFunc* fOnEndFunc;
+  void* fOnEndClientData;
+  OggDemux* fOurDemux;
+  OggParseState fCurrentParseState;
+
+  unsigned fNumUnfulfilledTracks;
+  PacketSizeTable* fPacketSizeTable;
+  u_int32_t fCurrentTrackNumber;
+  u_int8_t* fSavedPacket; // used to temporarily save a copy of a 'packet' from a page
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/OggFileServerDemux.cpp b/3rdparty/live555/src/liveMedia/OggFileServerDemux.cpp
new file mode 100644
index 00000000..1290f123
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/OggFileServerDemux.cpp
@@ -0,0 +1,118 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A server demultiplexor for a Ogg file
+// Implementation
+
+#include "OggFileServerDemux.hh"
+#include "OggFileServerMediaSubsession.hh"
+
+void OggFileServerDemux ::createNew(UsageEnvironment &env, char const *fileName, onCreationFunc *onCreation, void *onCreationClientData) {
+    (void)new OggFileServerDemux(env, fileName, onCreation, onCreationClientData);
+}
+
+ServerMediaSubsession *OggFileServerDemux::newServerMediaSubsession() {
+    u_int32_t dummyResultTrackNumber;
+    return newServerMediaSubsession(dummyResultTrackNumber);
+}
+
+ServerMediaSubsession *OggFileServerDemux ::newServerMediaSubsession(u_int32_t &resultTrackNumber) {
+    resultTrackNumber = 0;
+
+    OggTrack *nextTrack = fIter->next();
+    if(nextTrack == NULL)
+        return NULL;
+
+    return newServerMediaSubsessionByTrackNumber(nextTrack->trackNumber);
+}
+
+ServerMediaSubsession *OggFileServerDemux ::newServerMediaSubsessionByTrackNumber(u_int32_t trackNumber) {
+    OggTrack *track = fOurOggFile->lookup(trackNumber);
+    if(track == NULL)
+        return NULL;
+
+    ServerMediaSubsession *result = OggFileServerMediaSubsession::createNew(*this, track);
+    if(result != NULL) {
+#ifdef DEBUG
+        fprintf(stderr, "Created 'ServerMediaSubsession' object for track #%d: (%s)\n", track->trackNumber, track->mimeType);
+#endif
+    }
+
+    return result;
+}
+
+FramedSource *OggFileServerDemux::newDemuxedTrack(unsigned clientSessionId, u_int32_t trackNumber) {
+    OggDemux *demuxToUse = NULL;
+
+    if(clientSessionId != 0 && clientSessionId == fLastClientSessionId) {
+        demuxToUse = fLastCreatedDemux;  // use the same demultiplexor as before
+                                         // Note: This code relies upon the fact that the creation of streams for different
+                                         // client sessions do not overlap - so all demuxed tracks are created for one "OggDemux" at a time.
+                                         // Also, the "clientSessionId != 0" test is a hack, because 'session 0' is special; its audio and video streams
+                                         // are created and destroyed one-at-a-time, rather than both streams being
+                                         // created, and then (later) both streams being destroyed (as is the case
+                                         // for other ('real') session ids).  Because of this, a separate demultiplexor is used for each 'session 0' track.
+    }
+
+    if(demuxToUse == NULL)
+        demuxToUse = fOurOggFile->newDemux(onDemuxDeletion, this);
+
+    fLastClientSessionId = clientSessionId;
+    fLastCreatedDemux    = demuxToUse;
+
+    return demuxToUse->newDemuxedTrackByTrackNumber(trackNumber);
+}
+
+OggFileServerDemux ::OggFileServerDemux(UsageEnvironment &env, char const *fileName, onCreationFunc *onCreation, void *onCreationClientData)
+    : Medium(env),
+      fFileName(fileName),
+      fOnCreation(onCreation),
+      fOnCreationClientData(onCreationClientData),
+      fIter(NULL /*until the OggFile is created*/),
+      fLastClientSessionId(0),
+      fLastCreatedDemux(NULL) {
+    OggFile::createNew(env, fileName, onOggFileCreation, this);
+}
+
+OggFileServerDemux::~OggFileServerDemux() {
+    Medium::close(fOurOggFile);
+
+    delete fIter;
+}
+
+void OggFileServerDemux::onOggFileCreation(OggFile *newFile, void *clientData) {
+    ((OggFileServerDemux *)clientData)->onOggFileCreation(newFile);
+}
+
+void OggFileServerDemux::onOggFileCreation(OggFile *newFile) {
+    fOurOggFile = newFile;
+
+    fIter = new OggTrackTableIterator(fOurOggFile->trackTable());
+
+    // Now, call our own creation notification function:
+    if(fOnCreation != NULL)
+        (*fOnCreation)(this, fOnCreationClientData);
+}
+
+void OggFileServerDemux::onDemuxDeletion(void *clientData, OggDemux *demuxBeingDeleted) {
+    ((OggFileServerDemux *)clientData)->onDemuxDeletion(demuxBeingDeleted);
+}
+
+void OggFileServerDemux::onDemuxDeletion(OggDemux *demuxBeingDeleted) {
+    if(fLastCreatedDemux == demuxBeingDeleted)
+        fLastCreatedDemux = NULL;
+}
diff --git a/3rdparty/live555/src/liveMedia/OggFileServerMediaSubsession.cpp b/3rdparty/live555/src/liveMedia/OggFileServerMediaSubsession.cpp
new file mode 100644
index 00000000..3baa6cd4
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/OggFileServerMediaSubsession.cpp
@@ -0,0 +1,45 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A 'ServerMediaSubsession' object that creates new, unicast, "RTPSink"s
+// on demand, from a track within an Ogg file.
+// Implementation
+
+#include "OggFileServerMediaSubsession.hh"
+#include "OggDemuxedTrack.hh"
+#include "FramedFilter.hh"
+
+OggFileServerMediaSubsession *OggFileServerMediaSubsession ::createNew(OggFileServerDemux &demux, OggTrack *track) {
+    return new OggFileServerMediaSubsession(demux, track);
+}
+
+OggFileServerMediaSubsession ::OggFileServerMediaSubsession(OggFileServerDemux &demux, OggTrack *track)
+    : FileServerMediaSubsession(demux.envir(), demux.fileName(), False), fOurDemux(demux), fTrack(track), fNumFiltersInFrontOfTrack(0) {}
+
+OggFileServerMediaSubsession::~OggFileServerMediaSubsession() {}
+
+FramedSource *OggFileServerMediaSubsession ::createNewStreamSource(unsigned clientSessionId, unsigned &estBitrate) {
+    FramedSource *baseSource = fOurDemux.newDemuxedTrack(clientSessionId, fTrack->trackNumber);
+    if(baseSource == NULL)
+        return NULL;
+
+    return fOurDemux.ourOggFile()->createSourceForStreaming(baseSource, fTrack->trackNumber, estBitrate, fNumFiltersInFrontOfTrack);
+}
+
+RTPSink *OggFileServerMediaSubsession ::createNewRTPSink(Groupsock *rtpGroupsock, unsigned char rtpPayloadTypeIfDynamic, FramedSource * /*inputSource*/) {
+    return fOurDemux.ourOggFile()->createRTPSinkForTrackNumber(fTrack->trackNumber, rtpGroupsock, rtpPayloadTypeIfDynamic);
+}
diff --git a/3rdparty/live555/src/liveMedia/OggFileServerMediaSubsession.hh b/3rdparty/live555/src/liveMedia/OggFileServerMediaSubsession.hh
new file mode 100644
index 00000000..f078d89d
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/OggFileServerMediaSubsession.hh
@@ -0,0 +1,53 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A 'ServerMediaSubsession' object that creates new, unicast, "RTPSink"s
+// on demand, from a track within an Ogg file.
+// C++ header
+
+#ifndef _OGG_FILE_SERVER_MEDIA_SUBSESSION_HH
+#define _OGG_FILE_SERVER_MEDIA_SUBSESSION_HH
+
+#ifndef _FILE_SERVER_MEDIA_SUBSESSION_HH
+#include "FileServerMediaSubsession.hh"
+#endif
+#ifndef _OGG_FILE_SERVER_DEMUX_HH
+#include "OggFileServerDemux.hh"
+#endif
+
+class OggFileServerMediaSubsession: public FileServerMediaSubsession {
+public:
+  static OggFileServerMediaSubsession*
+  createNew(OggFileServerDemux& demux, OggTrack* track);
+
+protected:
+  OggFileServerMediaSubsession(OggFileServerDemux& demux, OggTrack* track);
+      // called only by createNew(), or by subclass constructors
+  virtual ~OggFileServerMediaSubsession();
+
+protected: // redefined virtual functions
+  virtual FramedSource* createNewStreamSource(unsigned clientSessionId,
+					      unsigned& estBitrate);
+  virtual RTPSink* createNewRTPSink(Groupsock* rtpGroupsock, unsigned char rtpPayloadTypeIfDynamic, FramedSource* inputSource);
+
+protected:
+  OggFileServerDemux& fOurDemux;
+  OggTrack* fTrack;
+  unsigned fNumFiltersInFrontOfTrack;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/OggFileSink.cpp b/3rdparty/live555/src/liveMedia/OggFileSink.cpp
new file mode 100644
index 00000000..ffc3b26d
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/OggFileSink.cpp
@@ -0,0 +1,303 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// 'Ogg' File Sink (recording a single media track only)
+// Implementation
+
+#include "OggFileSink.hh"
+#include "OutputFile.hh"
+#include "VorbisAudioRTPSource.hh"             // for "parseVorbisOrTheoraConfigStr()"
+#include "MPEG2TransportStreamMultiplexor.hh"  // for calculateCRC()
+#include "FramedSource.hh"
+
+OggFileSink *OggFileSink ::createNew(UsageEnvironment &env, char const *fileName, unsigned samplingFrequency, char const *configStr, unsigned bufferSize,
+                                     Boolean oneFilePerFrame) {
+    do {
+        FILE *      fid;
+        char const *perFrameFileNamePrefix;
+        if(oneFilePerFrame) {
+            // Create the fid for each frame
+            fid                    = NULL;
+            perFrameFileNamePrefix = fileName;
+        }
+        else {
+            // Normal case: create the fid once
+            fid = OpenOutputFile(env, fileName);
+            if(fid == NULL)
+                break;
+            perFrameFileNamePrefix = NULL;
+        }
+
+        return new OggFileSink(env, fid, samplingFrequency, configStr, bufferSize, perFrameFileNamePrefix);
+    } while(0);
+
+    return NULL;
+}
+
+OggFileSink::OggFileSink(UsageEnvironment &env, FILE *fid, unsigned samplingFrequency, char const *configStr, unsigned bufferSize,
+                         char const *perFrameFileNamePrefix)
+    : FileSink(env, fid, bufferSize, perFrameFileNamePrefix),
+      fSamplingFrequency(samplingFrequency),
+      fConfigStr(strDup(configStr)),
+      fHaveWrittenFirstFrame(False),
+      fHaveSeenEOF(False),
+      fGranulePosition(0),
+      fGranulePositionAdjustment(0),
+      fPageSequenceNumber(0),
+      fIsTheora(False),
+      fGranuleIncrementPerFrame(1),
+      fAltFrameSize(0),
+      fAltNumTruncatedBytes(0) {
+    fAltBuffer = new unsigned char[bufferSize];
+
+    // Initialize our 'Ogg page header' array with constant values:
+    u_int8_t *p = fPageHeaderBytes;
+    *p++        = 0x4f;
+    *p++        = 0x67;
+    *p++        = 0x67;
+    *p++        = 0x53;  // bytes 0..3: 'capture_pattern': "OggS"
+    *p++        = 0;     // byte 4: 'stream_structure_version': 0
+    *p++        = 0;     // byte 5: 'header_type_flag': set on each write
+    *p++        = 0;
+    *p++        = 0;
+    *p++        = 0;
+    *p++        = 0;
+    *p++        = 0;
+    *p++        = 0;
+    *p++        = 0;
+    *p++        = 0;
+    // bytes 6..13: 'granule_position': set on each write
+    *p++ = 1;
+    *p++ = 0;
+    *p++ = 0;
+    *p++ = 0;  // bytes 14..17: 'bitstream_serial_number': 1
+    *p++ = 0;
+    *p++ = 0;
+    *p++ = 0;
+    *p++ = 0;  // bytes 18..21: 'page_sequence_number': set on each write
+    *p++ = 0;
+    *p++ = 0;
+    *p++ = 0;
+    *p++ = 0;  // bytes 22..25: 'CRC_checksum': set on each write
+    *p   = 0;  // byte 26: 'number_page_segments': set on each write
+}
+
+OggFileSink::~OggFileSink() {
+    // We still have the previously-arrived frame, so write it to the file before we end:
+    fHaveSeenEOF = True;
+    OggFileSink::addData(fAltBuffer, fAltFrameSize, fAltPresentationTime);
+
+    delete[] fAltBuffer;
+    delete[](char *) fConfigStr;
+}
+
+Boolean OggFileSink::continuePlaying() {
+    // Identical to "FileSink::continuePlaying()",
+    // except that we use our own 'on source closure' function:
+    if(fSource == NULL)
+        return False;
+
+    fSource->getNextFrame(fBuffer, fBufferSize, FileSink::afterGettingFrame, this, ourOnSourceClosure, this);
+    return True;
+}
+
+#define PAGE_DATA_MAX_SIZE (255 * 255)
+
+void OggFileSink::addData(unsigned char const *data, unsigned dataSize, struct timeval presentationTime) {
+    if(dataSize == 0)
+        return;
+
+    // Set "fGranulePosition" for this frame:
+    if(fIsTheora) {
+        // Special case for Theora: "fGranulePosition" is supposed to be made up of a pair:
+        //   (frame count to last key frame) | (frame count since last key frame)
+        // However, because there appears to be no easy way to figure out which frames are key frames,
+        // we just assume that all frames are key frames.
+        if(!(data[0] >= 0x80 && data[0] <= 0x82)) {  // for header pages, "fGranulePosition" remains 0
+            fGranulePosition += fGranuleIncrementPerFrame;
+        }
+    }
+    else {
+        double  ptDiff = (presentationTime.tv_sec - fFirstPresentationTime.tv_sec) + (presentationTime.tv_usec - fFirstPresentationTime.tv_usec) / 1000000.0;
+        int64_t newGranulePosition = (int64_t)(fSamplingFrequency * ptDiff) + fGranulePositionAdjustment;
+        if(newGranulePosition < fGranulePosition) {
+            // Update "fGranulePositionAdjustment" so that "fGranulePosition" remains monotonic
+            fGranulePositionAdjustment += fGranulePosition - newGranulePosition;
+        }
+        else {
+            fGranulePosition = newGranulePosition;
+        }
+    }
+
+    // Write the frame to the file as a single Ogg 'page' (or perhaps as multiple pages
+    // if it's too big for a single page).  We don't aggregate more than one frame within
+    // an Ogg page because that's not legal for some headers, and because that would make
+    // it difficult for us to properly set the 'eos' (end of stream) flag on the last page.
+
+    // First, figure out how many pages to write here
+    // (a page can contain no more than PAGE_DATA_MAX_SIZE bytes)
+    unsigned numPagesToWrite = dataSize / PAGE_DATA_MAX_SIZE + 1;
+    // Note that if "dataSize" is a integral multiple of PAGE_DATA_MAX_SIZE, there will
+    // be an extra 0-size page at the end
+    for(unsigned i = 0; i < numPagesToWrite; ++i) {
+        // First, fill in the changeable parts of our 'page header' array;
+        u_int8_t header_type_flag = 0x0;
+        if(!fHaveWrittenFirstFrame && i == 0) {
+            header_type_flag |= 0x02;       // 'bos'
+            fHaveWrittenFirstFrame = True;  // for the future
+        }
+        if(i > 0)
+            header_type_flag |= 0x01;  // 'continuation'
+        if(fHaveSeenEOF && i == numPagesToWrite - 1)
+            header_type_flag |= 0x04;  // 'eos'
+        fPageHeaderBytes[5] = header_type_flag;
+
+        if(i < numPagesToWrite - 1) {
+            // For pages where the frame does not end, set 'granule_position' in the header to -1:
+            fPageHeaderBytes[6] = fPageHeaderBytes[7] = fPageHeaderBytes[8] = fPageHeaderBytes[9] = fPageHeaderBytes[10] = fPageHeaderBytes[11] =
+                fPageHeaderBytes[12] = fPageHeaderBytes[13] = 0xFF;
+        }
+        else {
+            fPageHeaderBytes[6]  = (u_int8_t)fGranulePosition;
+            fPageHeaderBytes[7]  = (u_int8_t)(fGranulePosition >> 8);
+            fPageHeaderBytes[8]  = (u_int8_t)(fGranulePosition >> 16);
+            fPageHeaderBytes[9]  = (u_int8_t)(fGranulePosition >> 24);
+            fPageHeaderBytes[10] = (u_int8_t)(fGranulePosition >> 32);
+            fPageHeaderBytes[11] = (u_int8_t)(fGranulePosition >> 40);
+            fPageHeaderBytes[12] = (u_int8_t)(fGranulePosition >> 48);
+            fPageHeaderBytes[13] = (u_int8_t)(fGranulePosition >> 56);
+        }
+
+        fPageHeaderBytes[18] = (u_int8_t)fPageSequenceNumber;
+        fPageHeaderBytes[19] = (u_int8_t)(fPageSequenceNumber >> 8);
+        fPageHeaderBytes[20] = (u_int8_t)(fPageSequenceNumber >> 16);
+        fPageHeaderBytes[21] = (u_int8_t)(fPageSequenceNumber >> 24);
+        ++fPageSequenceNumber;
+
+        unsigned pageDataSize;
+        u_int8_t number_page_segments;
+        if(dataSize >= PAGE_DATA_MAX_SIZE) {
+            pageDataSize         = PAGE_DATA_MAX_SIZE;
+            number_page_segments = 255;
+        }
+        else {
+            pageDataSize         = dataSize;
+            number_page_segments = (pageDataSize + 255) / 255;  // so that we don't end with a lacing of 255
+        }
+        fPageHeaderBytes[26] = number_page_segments;
+
+        u_int8_t segment_table[255];
+        for(unsigned j = 0; j < (unsigned)(number_page_segments - 1); ++j) {
+            segment_table[j] = 255;
+        }
+        segment_table[number_page_segments - 1] = pageDataSize % 255;
+
+        // Compute the CRC from the 'page header' array, the 'segment_table', and the frame data:
+        u_int32_t crc        = 0;
+        fPageHeaderBytes[22] = fPageHeaderBytes[23] = fPageHeaderBytes[24] = fPageHeaderBytes[25] = 0;
+        crc                                                                                       = calculateCRC(fPageHeaderBytes, 27, 0);
+        crc                                                                                       = calculateCRC(segment_table, number_page_segments, crc);
+        crc                                                                                       = calculateCRC(data, pageDataSize, crc);
+        fPageHeaderBytes[22]                                                                      = (u_int8_t)crc;
+        fPageHeaderBytes[23]                                                                      = (u_int8_t)(crc >> 8);
+        fPageHeaderBytes[24]                                                                      = (u_int8_t)(crc >> 16);
+        fPageHeaderBytes[25]                                                                      = (u_int8_t)(crc >> 24);
+
+        // Then write out the 'page header' array:
+        FileSink::addData(fPageHeaderBytes, 27, presentationTime);
+
+        // Then write out the 'segment_table':
+        FileSink::addData(segment_table, number_page_segments, presentationTime);
+
+        // Then add frame data, to complete the page:
+        FileSink::addData(data, pageDataSize, presentationTime);
+        data += pageDataSize;
+        dataSize -= pageDataSize;
+    }
+}
+
+void OggFileSink::afterGettingFrame(unsigned frameSize, unsigned numTruncatedBytes, struct timeval presentationTime) {
+    if(!fHaveWrittenFirstFrame) {
+        fFirstPresentationTime = presentationTime;
+
+        // If we have a 'config string' representing 'packed configuration headers'
+        // ("identification", "comment", "setup"), unpack them and prepend them to the file:
+        if(fConfigStr != NULL && fConfigStr[0] != '\0') {
+            u_int8_t *identificationHdr;
+            unsigned  identificationHdrSize;
+            u_int8_t *commentHdr;
+            unsigned  commentHdrSize;
+            u_int8_t *setupHdr;
+            unsigned  setupHdrSize;
+            u_int32_t identField;
+            parseVorbisOrTheoraConfigStr(fConfigStr, identificationHdr, identificationHdrSize, commentHdr, commentHdrSize, setupHdr, setupHdrSize, identField);
+            if(identificationHdrSize >= 42 && strncmp((const char *)&identificationHdr[1], "theora", 6) == 0) {
+                // Hack for Theora video: Parse the "identification" hdr to get the "KFGSHIFT" parameter:
+                fIsTheora                 = True;
+                u_int8_t const KFGSHIFT   = ((identificationHdr[40] & 3) << 3) | (identificationHdr[41] >> 5);
+                fGranuleIncrementPerFrame = (u_int64_t)(1 << KFGSHIFT);
+            }
+            OggFileSink::addData(identificationHdr, identificationHdrSize, presentationTime);
+            OggFileSink::addData(commentHdr, commentHdrSize, presentationTime);
+
+            // Hack: Handle the "setup" header as if had arrived in the previous delivery, so it'll get
+            // written properly below:
+            if(setupHdrSize > fBufferSize) {
+                fAltFrameSize         = fBufferSize;
+                fAltNumTruncatedBytes = setupHdrSize - fBufferSize;
+            }
+            else {
+                fAltFrameSize         = setupHdrSize;
+                fAltNumTruncatedBytes = 0;
+            }
+            memmove(fAltBuffer, setupHdr, fAltFrameSize);
+            fAltPresentationTime = presentationTime;
+
+            delete[] identificationHdr;
+            delete[] commentHdr;
+            delete[] setupHdr;
+        }
+    }
+
+    // Save this input frame for next time, and instead write the previous input frame now:
+    unsigned char *tmpPtr               = fBuffer;
+    fBuffer                             = fAltBuffer;
+    fAltBuffer                          = tmpPtr;
+    unsigned prevFrameSize              = fAltFrameSize;
+    fAltFrameSize                       = frameSize;
+    unsigned prevNumTruncatedBytes      = fAltNumTruncatedBytes;
+    fAltNumTruncatedBytes               = numTruncatedBytes;
+    struct timeval prevPresentationTime = fAltPresentationTime;
+    fAltPresentationTime                = presentationTime;
+
+    // Call the parent class to complete the normal file write with the (previous) input frame:
+    FileSink::afterGettingFrame(prevFrameSize, prevNumTruncatedBytes, prevPresentationTime);
+}
+
+void OggFileSink::ourOnSourceClosure(void *clientData) {
+    ((OggFileSink *)clientData)->ourOnSourceClosure();
+}
+
+void OggFileSink::ourOnSourceClosure() {
+    fHaveSeenEOF = True;
+
+    // We still have the previously-arrived frame, so write it to the file before we end:
+    OggFileSink::addData(fAltBuffer, fAltFrameSize, fAltPresentationTime);
+
+    // Handle the closure for real:
+    onSourceClosure();
+}
diff --git a/3rdparty/live555/src/liveMedia/OnDemandServerMediaSubsession.cpp b/3rdparty/live555/src/liveMedia/OnDemandServerMediaSubsession.cpp
new file mode 100644
index 00000000..451a1acc
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/OnDemandServerMediaSubsession.cpp
@@ -0,0 +1,644 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A 'ServerMediaSubsession' object that creates new, unicast, "RTPSink"s
+// on demand.
+// Implementation
+
+#include "OnDemandServerMediaSubsession.hh"
+#include <GroupsockHelper.hh>
+
+OnDemandServerMediaSubsession ::OnDemandServerMediaSubsession(UsageEnvironment &env, Boolean reuseFirstSource, portNumBits initialPortNum,
+                                                              Boolean multiplexRTCPWithRTP)
+    : ServerMediaSubsession(env),
+      fSDPLines(NULL),
+      fMIKEYStateMessage(NULL),
+      fMIKEYStateMessageSize(0),
+      fReuseFirstSource(reuseFirstSource),
+      fMultiplexRTCPWithRTP(multiplexRTCPWithRTP),
+      fLastStreamToken(NULL),
+      fAppHandlerTask(NULL),
+      fAppHandlerClientData(NULL) {
+    fDestinationsHashTable = HashTable::create(ONE_WORD_HASH_KEYS);
+    if(fMultiplexRTCPWithRTP) {
+        fInitialPortNum = initialPortNum;
+    }
+    else {
+        // Make sure RTP ports are even-numbered:
+        fInitialPortNum = (initialPortNum + 1) & ~1;
+    }
+    gethostname(fCNAME, sizeof fCNAME);
+    fCNAME[sizeof fCNAME - 1] = '\0';  // just in case
+}
+
+OnDemandServerMediaSubsession::~OnDemandServerMediaSubsession() {
+    delete[] fMIKEYStateMessage;
+    delete[] fSDPLines;
+
+    // Clean out the destinations hash table:
+    while(1) {
+        Destinations *destinations = (Destinations *)(fDestinationsHashTable->RemoveNext());
+        if(destinations == NULL)
+            break;
+        delete destinations;
+    }
+    delete fDestinationsHashTable;
+}
+
+char const *OnDemandServerMediaSubsession::sdpLines(int addressFamily) {
+    if(fSDPLines == NULL) {
+        // We need to construct a set of SDP lines that describe this
+        // subsession (as a unicast stream).  To do so, we first create
+        // dummy (unused) source and "RTPSink" objects,
+        // whose parameters we use for the SDP lines:
+        unsigned      estBitrate;
+        FramedSource *inputSource = createNewStreamSource(0, estBitrate);
+        if(inputSource == NULL)
+            return NULL;  // file not found
+
+        Groupsock *   dummyGroupsock = createGroupsock(nullAddress(addressFamily), 0);
+        unsigned char rtpPayloadType = 96 + trackNumber() - 1;  // if dynamic
+        RTPSink *     dummyRTPSink   = createNewRTPSink(dummyGroupsock, rtpPayloadType, inputSource);
+        if(dummyRTPSink != NULL) {
+            if(fParentSession->streamingUsesSRTP) {
+                fMIKEYStateMessage = dummyRTPSink->setupForSRTP(fParentSession->streamingIsEncrypted, fMIKEYStateMessageSize);
+            }
+
+            if(dummyRTPSink->estimatedBitrate() > 0)
+                estBitrate = dummyRTPSink->estimatedBitrate();
+            setSDPLinesFromRTPSink(dummyRTPSink, inputSource, estBitrate);
+            Medium::close(dummyRTPSink);
+        }
+        delete dummyGroupsock;
+        closeStreamSource(inputSource);
+    }
+
+    return fSDPLines;
+}
+
+void OnDemandServerMediaSubsession ::getStreamParameters(unsigned clientSessionId, struct sockaddr_storage const &clientAddress, Port const &clientRTPPort,
+                                                         Port const &clientRTCPPort, int tcpSocketNum, unsigned char rtpChannelId, unsigned char rtcpChannelId,
+                                                         TLSState *tlsState, struct sockaddr_storage &destinationAddress, u_int8_t & /*destinationTTL*/,
+                                                         Boolean &isMulticast, Port &serverRTPPort, Port &serverRTCPPort, void *&streamToken) {
+    if(addressIsNull(destinationAddress)) {
+        // normal case - use the client address as the destination address:
+        destinationAddress = clientAddress;
+    }
+    isMulticast = False;
+
+    if(fLastStreamToken != NULL && fReuseFirstSource) {
+        // Special case: Rather than creating a new 'StreamState',
+        // we reuse the one that we've already created:
+        serverRTPPort  = ((StreamState *)fLastStreamToken)->serverRTPPort();
+        serverRTCPPort = ((StreamState *)fLastStreamToken)->serverRTCPPort();
+        ++((StreamState *)fLastStreamToken)->referenceCount();
+        streamToken = fLastStreamToken;
+    }
+    else {
+        // Normal case: Create a new media source:
+        unsigned      streamBitrate;
+        FramedSource *mediaSource = createNewStreamSource(clientSessionId, streamBitrate);
+
+        // Create 'groupsock' and 'sink' objects for the destination,
+        // using previously unused server port numbers:
+        RTPSink *     rtpSink       = NULL;
+        BasicUDPSink *udpSink       = NULL;
+        Groupsock *   rtpGroupsock  = NULL;
+        Groupsock *   rtcpGroupsock = NULL;
+
+        if(clientRTPPort.num() != 0 || tcpSocketNum >= 0) {  // Normal case: Create destinations
+            portNumBits serverPortNum;
+            if(clientRTCPPort.num() == 0) {
+                // We're streaming raw UDP (not RTP). Create a single groupsock:
+                NoReuse dummy(envir());  // ensures that we skip over ports that are already in use
+                for(serverPortNum = fInitialPortNum;; ++serverPortNum) {
+                    serverRTPPort = serverPortNum;
+                    rtpGroupsock  = createGroupsock(nullAddress(destinationAddress.ss_family), serverRTPPort);
+                    if(rtpGroupsock->socketNum() >= 0)
+                        break;  // success
+                }
+
+                udpSink = BasicUDPSink::createNew(envir(), rtpGroupsock);
+            }
+            else {
+                // Normal case: We're streaming RTP (over UDP or TCP).  Create a pair of
+                // groupsocks (RTP and RTCP), with adjacent port numbers (RTP port number even).
+                // (If we're multiplexing RTCP and RTP over the same port number, it can be odd or even.)
+                NoReuse dummy(envir());  // ensures that we skip over ports that are already in use
+                for(portNumBits serverPortNum = fInitialPortNum;; ++serverPortNum) {
+                    serverRTPPort = serverPortNum;
+                    rtpGroupsock  = createGroupsock(nullAddress(destinationAddress.ss_family), serverRTPPort);
+                    if(rtpGroupsock->socketNum() < 0) {
+                        delete rtpGroupsock;
+                        continue;  // try again
+                    }
+
+                    if(fMultiplexRTCPWithRTP) {
+                        // Use the RTP 'groupsock' object for RTCP as well:
+                        serverRTCPPort = serverRTPPort;
+                        rtcpGroupsock  = rtpGroupsock;
+                    }
+                    else {
+                        // Create a separate 'groupsock' object (with the next (odd) port number) for RTCP:
+                        serverRTCPPort = ++serverPortNum;
+                        rtcpGroupsock  = createGroupsock(nullAddress(destinationAddress.ss_family), serverRTCPPort);
+                        if(rtcpGroupsock->socketNum() < 0) {
+                            delete rtpGroupsock;
+                            delete rtcpGroupsock;
+                            continue;  // try again
+                        }
+                    }
+
+                    break;  // success
+                }
+
+                unsigned char rtpPayloadType = 96 + trackNumber() - 1;  // if dynamic
+                rtpSink                      = mediaSource == NULL ? NULL : createNewRTPSink(rtpGroupsock, rtpPayloadType, mediaSource);
+                if(rtpSink != NULL) {
+                    if(fParentSession->streamingUsesSRTP) {
+                        rtpSink->setupForSRTP(fMIKEYStateMessage, fMIKEYStateMessageSize);
+                    }
+                    if(rtpSink->estimatedBitrate() > 0)
+                        streamBitrate = rtpSink->estimatedBitrate();
+                }
+            }
+
+            // Turn off the destinations for each groupsock.  They'll get set later
+            // (unless TCP is used instead):
+            if(rtpGroupsock != NULL)
+                rtpGroupsock->removeAllDestinations();
+            if(rtcpGroupsock != NULL)
+                rtcpGroupsock->removeAllDestinations();
+
+            if(rtpGroupsock != NULL) {
+                // Try to use a big send buffer for RTP -  at least 0.1 second of
+                // specified bandwidth and at least 50 KB
+                unsigned rtpBufSize = streamBitrate * 25 / 2;  // 1 kbps * 0.1 s = 12.5 bytes
+                if(rtpBufSize < 50 * 1024)
+                    rtpBufSize = 50 * 1024;
+                increaseSendBufferTo(envir(), rtpGroupsock->socketNum(), rtpBufSize);
+            }
+        }
+
+        // Set up the state of the stream.  The stream will get started later:
+        streamToken = fLastStreamToken =
+            new StreamState(*this, serverRTPPort, serverRTCPPort, rtpSink, udpSink, streamBitrate, mediaSource, rtpGroupsock, rtcpGroupsock);
+    }
+
+    // Record these destinations as being for this client session id:
+    Destinations *destinations;
+    if(tcpSocketNum < 0) {  // UDP
+        destinations = new Destinations(destinationAddress, clientRTPPort, clientRTCPPort);
+    }
+    else {  // TCP
+        destinations = new Destinations(tcpSocketNum, rtpChannelId, rtcpChannelId, tlsState);
+    }
+    fDestinationsHashTable->Add((char const *)clientSessionId, destinations);
+}
+
+void OnDemandServerMediaSubsession::startStream(unsigned clientSessionId, void *streamToken, TaskFunc *rtcpRRHandler, void *rtcpRRHandlerClientData,
+                                                unsigned short &rtpSeqNum, unsigned &rtpTimestamp,
+                                                ServerRequestAlternativeByteHandler *serverRequestAlternativeByteHandler,
+                                                void *                               serverRequestAlternativeByteHandlerClientData) {
+    StreamState * streamState  = (StreamState *)streamToken;
+    Destinations *destinations = (Destinations *)(fDestinationsHashTable->Lookup((char const *)clientSessionId));
+    if(streamState != NULL) {
+        streamState->startPlaying(destinations, clientSessionId, rtcpRRHandler, rtcpRRHandlerClientData, serverRequestAlternativeByteHandler,
+                                  serverRequestAlternativeByteHandlerClientData);
+        RTPSink *rtpSink = streamState->rtpSink();  // alias
+        if(rtpSink != NULL) {
+            rtpSeqNum    = rtpSink->currentSeqNo();
+            rtpTimestamp = rtpSink->presetNextTimestamp();
+        }
+    }
+}
+
+void OnDemandServerMediaSubsession::pauseStream(unsigned /*clientSessionId*/, void *streamToken) {
+    // Pausing isn't allowed if multiple clients are receiving data from
+    // the same source:
+    if(fReuseFirstSource)
+        return;
+
+    StreamState *streamState = (StreamState *)streamToken;
+    if(streamState != NULL)
+        streamState->pause();
+}
+
+void OnDemandServerMediaSubsession::seekStream(unsigned /*clientSessionId*/, void *streamToken, double &seekNPT, double streamDuration, u_int64_t &numBytes) {
+    numBytes = 0;  // by default: unknown
+
+    // Seeking isn't allowed if multiple clients are receiving data from the same source:
+    if(fReuseFirstSource)
+        return;
+
+    StreamState *streamState = (StreamState *)streamToken;
+    if(streamState != NULL && streamState->mediaSource() != NULL) {
+        seekStreamSource(streamState->mediaSource(), seekNPT, streamDuration, numBytes);
+
+        streamState->startNPT() = (float)seekNPT;
+        RTPSink *rtpSink        = streamState->rtpSink();  // alias
+        if(rtpSink != NULL)
+            rtpSink->resetPresentationTimes();
+    }
+}
+
+void OnDemandServerMediaSubsession::seekStream(unsigned /*clientSessionId*/, void *streamToken, char *&absStart, char *&absEnd) {
+    // Seeking isn't allowed if multiple clients are receiving data from the same source:
+    if(fReuseFirstSource)
+        return;
+
+    StreamState *streamState = (StreamState *)streamToken;
+    if(streamState != NULL && streamState->mediaSource() != NULL) {
+        seekStreamSource(streamState->mediaSource(), absStart, absEnd);
+    }
+}
+
+void OnDemandServerMediaSubsession::nullSeekStream(unsigned /*clientSessionId*/, void *streamToken, double streamEndTime, u_int64_t &numBytes) {
+    numBytes = 0;  // by default: unknown
+
+    StreamState *streamState = (StreamState *)streamToken;
+    if(streamState != NULL && streamState->mediaSource() != NULL) {
+        // Because we're not seeking here, get the current NPT, and remember it as the new 'start' NPT:
+        streamState->startNPT() = getCurrentNPT(streamToken);
+
+        double duration = streamEndTime - streamState->startNPT();
+        if(duration < 0.0)
+            duration = 0.0;
+        setStreamSourceDuration(streamState->mediaSource(), duration, numBytes);
+
+        RTPSink *rtpSink = streamState->rtpSink();  // alias
+        if(rtpSink != NULL)
+            rtpSink->resetPresentationTimes();
+    }
+}
+
+void OnDemandServerMediaSubsession::setStreamScale(unsigned /*clientSessionId*/, void *streamToken, float scale) {
+    // Changing the scale factor isn't allowed if multiple clients are receiving data
+    // from the same source:
+    if(fReuseFirstSource)
+        return;
+
+    StreamState *streamState = (StreamState *)streamToken;
+    if(streamState != NULL && streamState->mediaSource() != NULL) {
+        setStreamSourceScale(streamState->mediaSource(), scale);
+    }
+}
+
+float OnDemandServerMediaSubsession::getCurrentNPT(void *streamToken) {
+    do {
+        if(streamToken == NULL)
+            break;
+
+        StreamState *streamState = (StreamState *)streamToken;
+        RTPSink *    rtpSink     = streamState->rtpSink();
+        if(rtpSink == NULL)
+            break;
+
+        return streamState->startNPT() + (rtpSink->mostRecentPresentationTime().tv_sec - rtpSink->initialPresentationTime().tv_sec)
+               + (rtpSink->mostRecentPresentationTime().tv_usec - rtpSink->initialPresentationTime().tv_usec) / 1000000.0f;
+    } while(0);
+
+    return 0.0;
+}
+
+FramedSource *OnDemandServerMediaSubsession::getStreamSource(void *streamToken) {
+    if(streamToken == NULL)
+        return NULL;
+
+    StreamState *streamState = (StreamState *)streamToken;
+    return streamState->mediaSource();
+}
+
+void OnDemandServerMediaSubsession ::getRTPSinkandRTCP(void *streamToken, RTPSink const *&rtpSink, RTCPInstance const *&rtcp) {
+    if(streamToken == NULL) {
+        rtpSink = NULL;
+        rtcp    = NULL;
+        return;
+    }
+
+    StreamState *streamState = (StreamState *)streamToken;
+    rtpSink                  = streamState->rtpSink();
+    rtcp                     = streamState->rtcpInstance();
+}
+
+void OnDemandServerMediaSubsession::deleteStream(unsigned clientSessionId, void *&streamToken) {
+    StreamState *streamState = (StreamState *)streamToken;
+
+    // Look up (and remove) the destinations for this client session:
+    Destinations *destinations = (Destinations *)(fDestinationsHashTable->Lookup((char const *)clientSessionId));
+    if(destinations != NULL) {
+        fDestinationsHashTable->Remove((char const *)clientSessionId);
+
+        // Stop streaming to these destinations:
+        if(streamState != NULL)
+            streamState->endPlaying(destinations, clientSessionId);
+    }
+
+    // Delete the "StreamState" structure if it's no longer being used:
+    if(streamState != NULL) {
+        if(streamState->referenceCount() > 0)
+            --streamState->referenceCount();
+        if(streamState->referenceCount() == 0) {
+            delete streamState;
+            streamToken = NULL;
+        }
+    }
+
+    // Finally, delete the destinations themselves:
+    delete destinations;
+}
+
+char const *OnDemandServerMediaSubsession ::getAuxSDPLine(RTPSink *rtpSink, FramedSource * /*inputSource*/) {
+    // Default implementation:
+    return rtpSink == NULL ? NULL : rtpSink->auxSDPLine();
+}
+
+void OnDemandServerMediaSubsession::seekStreamSource(FramedSource * /*inputSource*/, double & /*seekNPT*/, double /*streamDuration*/, u_int64_t &numBytes) {
+    // Default implementation: Do nothing
+    numBytes = 0;
+}
+
+void OnDemandServerMediaSubsession::seekStreamSource(FramedSource * /*inputSource*/, char *&absStart, char *&absEnd) {
+    // Default implementation: do nothing (but delete[] and assign "absStart" and "absEnd" to NULL, to show that we don't handle this)
+    delete[] absStart;
+    absStart = NULL;
+    delete[] absEnd;
+    absEnd = NULL;
+}
+
+void OnDemandServerMediaSubsession ::setStreamSourceScale(FramedSource * /*inputSource*/, float /*scale*/) {
+    // Default implementation: Do nothing
+}
+
+void OnDemandServerMediaSubsession ::setStreamSourceDuration(FramedSource * /*inputSource*/, double /*streamDuration*/, u_int64_t &numBytes) {
+    // Default implementation: Do nothing
+    numBytes = 0;
+}
+
+void OnDemandServerMediaSubsession::closeStreamSource(FramedSource *inputSource) {
+    Medium::close(inputSource);
+}
+
+Groupsock *OnDemandServerMediaSubsession ::createGroupsock(struct sockaddr_storage const &addr, Port port) {
+    // Default implementation; may be redefined by subclasses:
+    return new Groupsock(envir(), addr, port, 255);
+}
+
+RTCPInstance *OnDemandServerMediaSubsession ::createRTCP(Groupsock *RTCPgs, unsigned totSessionBW, /* in kbps */
+                                                         unsigned char const *cname, RTPSink *sink) {
+    // Default implementation; may be redefined by subclasses:
+    return RTCPInstance::createNew(envir(), RTCPgs, totSessionBW, cname, sink, NULL /*we're a server*/);
+}
+
+void OnDemandServerMediaSubsession ::setRTCPAppPacketHandler(RTCPAppHandlerFunc *handler, void *clientData) {
+    fAppHandlerTask       = handler;
+    fAppHandlerClientData = clientData;
+}
+
+void OnDemandServerMediaSubsession ::sendRTCPAppPacket(u_int8_t subtype, char const *name, u_int8_t *appDependentData, unsigned appDependentDataSize) {
+    StreamState *streamState = (StreamState *)fLastStreamToken;
+    if(streamState != NULL) {
+        streamState->sendRTCPAppPacket(subtype, name, appDependentData, appDependentDataSize);
+    }
+}
+
+void OnDemandServerMediaSubsession ::setSDPLinesFromRTPSink(RTPSink *rtpSink, FramedSource *inputSource, unsigned estBitrate) {
+    char const *                   mediaType      = rtpSink->sdpMediaType();
+    unsigned char                  rtpPayloadType = rtpSink->rtpPayloadType();
+    struct sockaddr_storage const &addressForSDP  = rtpSink->groupsockBeingUsed().groupAddress();
+    portNumBits                    portNumForSDP  = ntohs(rtpSink->groupsockBeingUsed().port().num());
+
+    AddressString ipAddressStr(addressForSDP);
+    char *        rtpmapLine  = rtpSink->rtpmapLine();
+    char *        keyMgmtLine = rtpSink->keyMgmtLine();
+    char const *  rtcpmuxLine = fMultiplexRTCPWithRTP ? "a=rtcp-mux\r\n" : "";
+    char const *  rangeLine   = rangeSDPLine();
+    char const *  auxSDPLine  = getAuxSDPLine(rtpSink, inputSource);
+    if(auxSDPLine == NULL)
+        auxSDPLine = "";
+
+    char const *const sdpFmt = "m=%s %u RTP/%sAVP %d\r\n"
+                               "c=IN %s %s\r\n"
+                               "b=AS:%u\r\n"
+                               "%s"
+                               "%s"
+                               "%s"
+                               "%s"
+                               "%s"
+                               "a=control:%s\r\n";
+    unsigned sdpFmtSize = strlen(sdpFmt) + strlen(mediaType) + 5 /* max short len */ + 1 + 3 /* max char len */
+                          + 3 /*IP4 or IP6*/ + strlen(ipAddressStr.val()) + 20               /* max int len */
+                          + strlen(rtpmapLine) + strlen(keyMgmtLine) + strlen(rtcpmuxLine) + strlen(rangeLine) + strlen(auxSDPLine) + strlen(trackId());
+    char *sdpLines = new char[sdpFmtSize];
+    sprintf(sdpLines, sdpFmt,
+            mediaType,      // m= <media>
+            portNumForSDP,  // m= <port>
+            fParentSession->streamingUsesSRTP ? "S" : "",
+            rtpPayloadType,                                                          // m= <fmt list>
+            addressForSDP.ss_family == AF_INET ? "IP4" : "IP6", ipAddressStr.val(),  // c= address
+            estBitrate,                                                              // b=AS:<bandwidth>
+            rtpmapLine,                                                              // a=rtpmap:... (if present)
+            keyMgmtLine,                                                             // a=key-mgmt:... (if present)
+            rtcpmuxLine,                                                             // a=rtcp-mux:... (if present)
+            rangeLine,                                                               // a=range:... (if present)
+            auxSDPLine,                                                              // optional extra SDP line
+            trackId());                                                              // a=control:<track-id>
+    delete[](char *) rangeLine;
+    delete[] keyMgmtLine;
+    delete[] rtpmapLine;
+
+    delete[] fSDPLines;
+    fSDPLines = strDup(sdpLines);
+    delete[] sdpLines;
+}
+
+////////// StreamState implementation //////////
+
+static void afterPlayingStreamState(void *clientData) {
+    StreamState *streamState = (StreamState *)clientData;
+    if(streamState->streamDuration() == 0.0) {
+        // When the input stream ends, tear it down.  This will cause a RTCP "BYE"
+        // to be sent to each client, teling it that the stream has ended.
+        // (Because the stream didn't have a known duration, there was no other
+        //  way for clients to know when the stream ended.)
+        streamState->reclaim();
+    }
+    // Otherwise, keep the stream alive, in case a client wants to
+    // subsequently re-play the stream starting from somewhere other than the end.
+    // (This can be done only on streams that have a known duration.)
+}
+
+StreamState::StreamState(OnDemandServerMediaSubsession &master, Port const &serverRTPPort, Port const &serverRTCPPort, RTPSink *rtpSink, BasicUDPSink *udpSink,
+                         unsigned totalBW, FramedSource *mediaSource, Groupsock *rtpGS, Groupsock *rtcpGS)
+    : fMaster(master),
+      fAreCurrentlyPlaying(False),
+      fReferenceCount(1),
+      fServerRTPPort(serverRTPPort),
+      fServerRTCPPort(serverRTCPPort),
+      fRTPSink(rtpSink),
+      fUDPSink(udpSink),
+      fStreamDuration(master.duration()),
+      fTotalBW(totalBW),
+      fRTCPInstance(NULL) /* created later */,
+      fMediaSource(mediaSource),
+      fStartNPT(0.0),
+      fRTPgs(rtpGS),
+      fRTCPgs(rtcpGS) {}
+
+StreamState::~StreamState() {
+    reclaim();
+}
+
+void StreamState ::startPlaying(Destinations *dests, unsigned clientSessionId, TaskFunc *rtcpRRHandler, void *rtcpRRHandlerClientData,
+                                ServerRequestAlternativeByteHandler *serverRequestAlternativeByteHandler, void *serverRequestAlternativeByteHandlerClientData) {
+    if(dests == NULL)
+        return;
+
+    if(fRTCPInstance == NULL && fRTPSink != NULL) {
+        // Create (and start) a 'RTCP instance' for this RTP sink:
+        fRTCPInstance = fMaster.createRTCP(fRTCPgs, fTotalBW, (unsigned char *)fMaster.fCNAME, fRTPSink);
+        // Note: This starts RTCP running automatically
+        if(fRTCPInstance != NULL)
+            fRTCPInstance->setAppHandler(fMaster.fAppHandlerTask, fMaster.fAppHandlerClientData);
+    }
+
+    if(dests->isTCP) {
+        // Change RTP and RTCP to use the TCP socket instead of UDP:
+        if(fRTPSink != NULL) {
+            fRTPSink->addStreamSocket(dests->tcpSocketNum, dests->rtpChannelId, dests->tlsState);
+            RTPInterface ::setServerRequestAlternativeByteHandler(fRTPSink->envir(), dests->tcpSocketNum, serverRequestAlternativeByteHandler,
+                                                                  serverRequestAlternativeByteHandlerClientData);
+            // So that we continue to handle RTSP commands from the client
+        }
+        if(fRTCPInstance != NULL) {
+            fRTCPInstance->addStreamSocket(dests->tcpSocketNum, dests->rtcpChannelId, dests->tlsState);
+
+            struct sockaddr_storage tcpSocketNumAsAddress;  // hack
+            tcpSocketNumAsAddress.ss_family                        = AF_INET;
+            ((sockaddr_in &)tcpSocketNumAsAddress).sin_addr.s_addr = dests->tcpSocketNum;
+            fRTCPInstance->setSpecificRRHandler(tcpSocketNumAsAddress, dests->rtcpChannelId, rtcpRRHandler, rtcpRRHandlerClientData);
+        }
+    }
+    else {
+        // Tell the RTP and RTCP 'groupsocks' about this destination
+        // (in case they don't already have it):
+        if(fRTPgs != NULL)
+            fRTPgs->addDestination(dests->addr, dests->rtpPort, clientSessionId);
+        if(fRTCPgs != NULL && !(fRTCPgs == fRTPgs && dests->rtcpPort.num() == dests->rtpPort.num())) {
+            fRTCPgs->addDestination(dests->addr, dests->rtcpPort, clientSessionId);
+        }
+        if(fRTCPInstance != NULL) {
+            fRTCPInstance->setSpecificRRHandler(dests->addr, dests->rtcpPort, rtcpRRHandler, rtcpRRHandlerClientData);
+        }
+    }
+
+    if(fRTCPInstance != NULL) {
+        // Hack: Send an initial RTCP "SR" packet, before the initial RTP packet, so that receivers will (likely) be able to
+        // get RTCP-synchronized presentation times immediately:
+        fRTCPInstance->sendReport();
+    }
+
+    if(!fAreCurrentlyPlaying && fMediaSource != NULL) {
+        if(fRTPSink != NULL) {
+            fRTPSink->startPlaying(*fMediaSource, afterPlayingStreamState, this);
+            fAreCurrentlyPlaying = True;
+        }
+        else if(fUDPSink != NULL) {
+            fUDPSink->startPlaying(*fMediaSource, afterPlayingStreamState, this);
+            fAreCurrentlyPlaying = True;
+        }
+    }
+}
+
+void StreamState::pause() {
+    if(fRTPSink != NULL)
+        fRTPSink->stopPlaying();
+    if(fUDPSink != NULL)
+        fUDPSink->stopPlaying();
+    if(fMediaSource != NULL)
+        fMediaSource->stopGettingFrames();
+    fAreCurrentlyPlaying = False;
+}
+
+void StreamState::endPlaying(Destinations *dests, unsigned clientSessionId) {
+#if 0
+  // The following code is temporarily disabled, because it erroneously sends RTCP "BYE"s to all clients if multiple
+  // clients are streaming from the same data source (i.e., if "reuseFirstSource" is True), and we don't want that to happen
+  // if we're being called as a result of a single one of these clients having sent a "TEARDOWN" (rather than the whole stream
+  // having been closed, for all clients).
+  // This will be fixed for real later.
+  if (fRTCPInstance != NULL) {
+    // Hack: Explicitly send a RTCP "BYE" packet now, because the code below will prevent that from happening later,
+    // when "fRTCPInstance" gets deleted:
+    fRTCPInstance->sendBYE();
+  }
+#endif
+
+    if(dests->isTCP) {
+        if(fRTPSink != NULL) {
+            // Comment out the following, because it prevents the "RTSPClientConnection" object
+            // from being closed after handling a "TEARDOWN": #####
+            // RTPInterface::clearServerRequestAlternativeByteHandler(fRTPSink->envir(), dests->tcpSocketNum);
+            fRTPSink->removeStreamSocket(dests->tcpSocketNum, dests->rtpChannelId);
+        }
+        if(fRTCPInstance != NULL) {
+            fRTCPInstance->removeStreamSocket(dests->tcpSocketNum, dests->rtcpChannelId);
+
+            struct sockaddr_storage tcpSocketNumAsAddress;  // hack
+            tcpSocketNumAsAddress.ss_family                        = AF_INET;
+            ((sockaddr_in &)tcpSocketNumAsAddress).sin_addr.s_addr = dests->tcpSocketNum;
+            fRTCPInstance->unsetSpecificRRHandler(tcpSocketNumAsAddress, dests->rtcpChannelId);
+        }
+    }
+    else {
+        // Tell the RTP and RTCP 'groupsocks' to stop using these destinations:
+        if(fRTPgs != NULL)
+            fRTPgs->removeDestination(clientSessionId);
+        if(fRTCPgs != NULL && fRTCPgs != fRTPgs)
+            fRTCPgs->removeDestination(clientSessionId);
+        if(fRTCPInstance != NULL) {
+            fRTCPInstance->unsetSpecificRRHandler(dests->addr, dests->rtcpPort);
+        }
+    }
+}
+
+void StreamState::sendRTCPAppPacket(u_int8_t subtype, char const *name, u_int8_t *appDependentData, unsigned appDependentDataSize) {
+    if(fRTCPInstance != NULL) {
+        fRTCPInstance->sendAppPacket(subtype, name, appDependentData, appDependentDataSize);
+    }
+}
+
+void StreamState::reclaim() {
+    // Delete allocated media objects
+    Medium::close(fRTCPInstance) /* will send a RTCP BYE */;
+    fRTCPInstance = NULL;
+    Medium::close(fRTPSink);
+    fRTPSink = NULL;
+    Medium::close(fUDPSink);
+    fUDPSink = NULL;
+
+    fMaster.closeStreamSource(fMediaSource);
+    fMediaSource = NULL;
+    if(fMaster.fLastStreamToken == this)
+        fMaster.fLastStreamToken = NULL;
+
+    delete fRTPgs;
+    if(fRTCPgs != fRTPgs)
+        delete fRTCPgs;
+    fRTPgs  = NULL;
+    fRTCPgs = NULL;
+}
diff --git a/3rdparty/live555/src/liveMedia/OutputFile.cpp b/3rdparty/live555/src/liveMedia/OutputFile.cpp
new file mode 100644
index 00000000..4f26c3f5
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/OutputFile.cpp
@@ -0,0 +1,63 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// Common routines for opening/closing named output files
+// Implementation
+
+#if(defined(__WIN32__) || defined(_WIN32)) && !defined(_WIN32_WCE)
+#include <io.h>
+#include <fcntl.h>
+#endif
+#ifndef _WIN32_WCE
+#include <sys/stat.h>
+#endif
+#include <string.h>
+
+#include "OutputFile.hh"
+
+FILE *OpenOutputFile(UsageEnvironment &env, char const *fileName) {
+    FILE *fid;
+
+    // Check for special case 'file names': "stdout" and "stderr"
+    if(strcmp(fileName, "stdout") == 0) {
+        fid = stdout;
+#if(defined(__WIN32__) || defined(_WIN32)) && !defined(_WIN32_WCE)
+        _setmode(_fileno(stdout), _O_BINARY);  // convert to binary mode
+#endif
+    }
+    else if(strcmp(fileName, "stderr") == 0) {
+        fid = stderr;
+#if(defined(__WIN32__) || defined(_WIN32)) && !defined(_WIN32_WCE)
+        _setmode(_fileno(stderr), _O_BINARY);  // convert to binary mode
+#endif
+    }
+    else {
+        fid = fopen(fileName, "wb");
+    }
+
+    if(fid == NULL) {
+        env.setResultMsg("unable to open file \"", fileName, "\"");
+    }
+
+    return fid;
+}
+
+void CloseOutputFile(FILE *fid) {
+    // Don't close 'stdout' or 'stderr', in case we want to use it again later.
+    if(fid != NULL && fid != stdout && fid != stderr)
+        fclose(fid);
+}
diff --git a/3rdparty/live555/src/liveMedia/PassiveServerMediaSubsession.cpp b/3rdparty/live555/src/liveMedia/PassiveServerMediaSubsession.cpp
new file mode 100644
index 00000000..b91d1aa1
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/PassiveServerMediaSubsession.cpp
@@ -0,0 +1,218 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A 'ServerMediaSubsession' object that represents an existing
+// 'RTPSink', rather than one that creates new 'RTPSink's on demand.
+// Implementation
+
+#include "PassiveServerMediaSubsession.hh"
+#include <GroupsockHelper.hh>
+
+////////// PassiveServerMediaSubsession //////////
+
+PassiveServerMediaSubsession *PassiveServerMediaSubsession::createNew(RTPSink &rtpSink, RTCPInstance *rtcpInstance) {
+    return new PassiveServerMediaSubsession(rtpSink, rtcpInstance);
+}
+
+PassiveServerMediaSubsession ::PassiveServerMediaSubsession(RTPSink &rtpSink, RTCPInstance *rtcpInstance)
+    : ServerMediaSubsession(rtpSink.envir()), fSDPLines(NULL), fRTPSink(rtpSink), fRTCPInstance(rtcpInstance) {
+    fClientRTCPSourceRecords = HashTable::create(ONE_WORD_HASH_KEYS);
+}
+
+class RTCPSourceRecord {
+public:
+    RTCPSourceRecord(struct sockaddr_storage const &addr, Port const &port) : addr(addr), port(port) {}
+
+    struct sockaddr_storage addr;
+    Port                    port;
+};
+
+PassiveServerMediaSubsession::~PassiveServerMediaSubsession() {
+    delete[] fSDPLines;
+
+    // Clean out the RTCPSourceRecord table:
+    while(1) {
+        RTCPSourceRecord *source = (RTCPSourceRecord *)(fClientRTCPSourceRecords->RemoveNext());
+        if(source == NULL)
+            break;
+        delete source;
+    }
+
+    delete fClientRTCPSourceRecords;
+}
+
+Boolean PassiveServerMediaSubsession::rtcpIsMuxed() {
+    if(fRTCPInstance == NULL)
+        return False;
+
+    // Check whether RTP and RTCP use the same "groupsock" object:
+    return &(fRTPSink.groupsockBeingUsed()) == fRTCPInstance->RTCPgs();
+}
+
+char const *PassiveServerMediaSubsession::sdpLines(int /*addressFamily*/) {
+    if(fSDPLines == NULL) {
+        // Construct a set of SDP lines that describe this subsession:
+        // Use the components from "rtpSink".
+        if(fParentSession->streamingUsesSRTP) {  // Hack to set up for SRTP/SRTCP
+            fRTPSink.setupForSRTP(fParentSession->streamingIsEncrypted);
+            if(fRTCPInstance != NULL)
+                fRTCPInstance->setupForSRTCP();
+        }
+
+        Groupsock const &gs = fRTPSink.groupsockBeingUsed();
+        AddressString    groupAddressStr(gs.groupAddress());
+        unsigned short   portNum        = ntohs(gs.port().num());
+        unsigned char    ttl            = gs.ttl();
+        unsigned char    rtpPayloadType = fRTPSink.rtpPayloadType();
+        char const *     mediaType      = fRTPSink.sdpMediaType();
+        unsigned         estBitrate     = fRTCPInstance == NULL ? 50 : fRTCPInstance->totSessionBW();
+        char *           rtpmapLine     = fRTPSink.rtpmapLine();
+        char *           keyMgmtLine    = fRTPSink.keyMgmtLine();
+        char const *     rtcpmuxLine    = rtcpIsMuxed() ? "a=rtcp-mux\r\n" : "";
+        char const *     rangeLine      = rangeSDPLine();
+        char const *     auxSDPLine     = fRTPSink.auxSDPLine();
+        if(auxSDPLine == NULL)
+            auxSDPLine = "";
+
+        char const *const sdpFmt = "m=%s %d RTP/%sAVP %d\r\n"
+                                   "c=IN %s %s/%d\r\n"
+                                   "b=AS:%u\r\n"
+                                   "%s"
+                                   "%s"
+                                   "%s"
+                                   "%s"
+                                   "%s"
+                                   "a=control:%s\r\n";
+        unsigned sdpFmtSize = strlen(sdpFmt) + strlen(mediaType) + 5 /* max short len */ + 1 + 3 /* max char len */
+                              + 3 /*IP4 or IP6*/ + strlen(groupAddressStr.val()) + 3             /* max char len */
+                              + 20                                                               /* max int len */
+                              + strlen(rtpmapLine) + strlen(keyMgmtLine) + strlen(rtcpmuxLine) + strlen(rangeLine) + strlen(auxSDPLine) + strlen(trackId());
+        char *sdpLines = new char[sdpFmtSize];
+        sprintf(sdpLines, sdpFmt,
+                mediaType,  // m= <media>
+                portNum,    // m= <port>
+                fParentSession->streamingUsesSRTP ? "S" : "",
+                rtpPayloadType,                                          // m= <fmt list>
+                gs.groupAddress().ss_family == AF_INET ? "IP4" : "IP6",  // c= address type
+                groupAddressStr.val(),                                   // c= <connection address>
+                ttl,                                                     // c= TTL
+                estBitrate,                                              // b=AS:<bandwidth>
+                rtpmapLine,                                              // a=rtpmap:... (if present)
+                keyMgmtLine,                                             // a=key-mgmt:... (if present)
+                rtcpmuxLine,                                             // a=rtcp-mux:... (if present)
+                rangeLine,                                               // a=range:... (if present)
+                auxSDPLine,                                              // optional extra SDP line
+                trackId());                                              // a=control:<track-id>
+        delete[](char *) rangeLine;
+        delete[] keyMgmtLine;
+        delete[] rtpmapLine;
+
+        fSDPLines = strDup(sdpLines);
+        delete[] sdpLines;
+    }
+
+    return fSDPLines;
+}
+
+void PassiveServerMediaSubsession ::getStreamParameters(unsigned clientSessionId, struct sockaddr_storage const &clientAddress, Port const & /*clientRTPPort*/,
+                                                        Port const &clientRTCPPort, int /*tcpSocketNum*/, unsigned char /*rtpChannelId*/,
+                                                        unsigned char /*rtcpChannelId*/, TLSState * /*tlsState*/, struct sockaddr_storage &destinationAddress,
+                                                        u_int8_t &destinationTTL, Boolean &isMulticast, Port &serverRTPPort, Port &serverRTCPPort,
+                                                        void *&streamToken) {
+    isMulticast   = True;
+    Groupsock &gs = fRTPSink.groupsockBeingUsed();
+    if(destinationTTL == 255)
+        destinationTTL = gs.ttl();
+
+    if(addressIsNull(destinationAddress)) {
+        // normal case - use the sink's existing destination address:
+        destinationAddress = gs.groupAddress();
+    }
+    else {  // use the client-specified destination address instead:
+        gs.changeDestinationParameters(destinationAddress, 0, destinationTTL);
+        if(fRTCPInstance != NULL) {
+            Groupsock *rtcpGS = fRTCPInstance->RTCPgs();
+            rtcpGS->changeDestinationParameters(destinationAddress, 0, destinationTTL);
+        }
+    }
+    serverRTPPort = gs.port();
+    if(fRTCPInstance != NULL) {
+        Groupsock *rtcpGS = fRTCPInstance->RTCPgs();
+        serverRTCPPort    = rtcpGS->port();
+    }
+    streamToken = NULL;  // not used
+
+    // Make a record of this client's source - for RTCP RR handling:
+    RTCPSourceRecord *source = new RTCPSourceRecord(clientAddress, clientRTCPPort);
+    fClientRTCPSourceRecords->Add((char const *)clientSessionId, source);
+}
+
+void PassiveServerMediaSubsession::startStream(unsigned clientSessionId, void * /*streamToken*/, TaskFunc *rtcpRRHandler, void *rtcpRRHandlerClientData,
+                                               unsigned short &rtpSeqNum, unsigned &rtpTimestamp,
+                                               ServerRequestAlternativeByteHandler * /*serverRequestAlternativeByteHandler*/,
+                                               void * /*serverRequestAlternativeByteHandlerClientData*/) {
+    rtpSeqNum    = fRTPSink.currentSeqNo();
+    rtpTimestamp = fRTPSink.presetNextTimestamp();
+
+    // Try to use a big send buffer for RTP -  at least 0.1 second of
+    // specified bandwidth and at least 50 KB
+    unsigned streamBitrate = fRTCPInstance == NULL ? 50 : fRTCPInstance->totSessionBW();  // in kbps
+    unsigned rtpBufSize    = streamBitrate * 25 / 2;                                      // 1 kbps * 0.1 s = 12.5 bytes
+    if(rtpBufSize < 50 * 1024)
+        rtpBufSize = 50 * 1024;
+    increaseSendBufferTo(envir(), fRTPSink.groupsockBeingUsed().socketNum(), rtpBufSize);
+
+    if(fRTCPInstance != NULL) {
+        // Hack: Send a RTCP "SR" packet now, so that receivers will (likely) be able to
+        // get RTCP-synchronized presentation times immediately:
+        fRTCPInstance->sendReport();
+
+        // Set up the handler for incoming RTCP "RR" packets from this client:
+        RTCPSourceRecord *source = (RTCPSourceRecord *)(fClientRTCPSourceRecords->Lookup((char const *)clientSessionId));
+        if(source != NULL) {
+            fRTCPInstance->setSpecificRRHandler(source->addr, source->port, rtcpRRHandler, rtcpRRHandlerClientData);
+        }
+    }
+}
+
+float PassiveServerMediaSubsession::getCurrentNPT(void *streamToken) {
+    // Return the elapsed time between our "RTPSink"s creation time, and the current time:
+    struct timeval const &creationTime = fRTPSink.creationTime();  // alias
+
+    struct timeval timeNow;
+    gettimeofday(&timeNow, NULL);
+
+    return (float)(timeNow.tv_sec - creationTime.tv_sec + (timeNow.tv_usec - creationTime.tv_usec) / 1000000.0);
+}
+
+void PassiveServerMediaSubsession ::getRTPSinkandRTCP(void *streamToken, RTPSink const *&rtpSink, RTCPInstance const *&rtcp) {
+    rtpSink = &fRTPSink;
+    rtcp    = fRTCPInstance;
+}
+
+void PassiveServerMediaSubsession::deleteStream(unsigned clientSessionId, void *& /*streamToken*/) {
+    // Lookup and remove the 'RTCPSourceRecord' for this client.  Also turn off RTCP "RR" handling:
+    RTCPSourceRecord *source = (RTCPSourceRecord *)(fClientRTCPSourceRecords->Lookup((char const *)clientSessionId));
+    if(source != NULL) {
+        if(fRTCPInstance != NULL) {
+            fRTCPInstance->unsetSpecificRRHandler(source->addr, source->port);
+        }
+
+        fClientRTCPSourceRecords->Remove((char const *)clientSessionId);
+        delete source;
+    }
+}
diff --git a/3rdparty/live555/src/liveMedia/ProxyServerMediaSession.cpp b/3rdparty/live555/src/liveMedia/ProxyServerMediaSession.cpp
new file mode 100644
index 00000000..fd5664f3
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/ProxyServerMediaSession.cpp
@@ -0,0 +1,946 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A subclass of "ServerMediaSession" that can be used to create a (unicast) RTSP servers that acts as a 'proxy' for
+// another (unicast or multicast) RTSP/RTP stream.
+// Implementation
+
+#include "liveMedia.hh"
+#include "RTSPCommon.hh"
+#include "GroupsockHelper.hh"  // for "our_random()"
+
+#ifndef MILLION
+#define MILLION 1000000
+#endif
+
+// A "OnDemandServerMediaSubsession" subclass, used to implement a unicast RTSP server that's proxying another RTSP stream:
+
+class ProxyServerMediaSubsession : public OnDemandServerMediaSubsession {
+public:
+    ProxyServerMediaSubsession(MediaSubsession &mediaSubsession, portNumBits initialPortNum, Boolean multiplexRTCPWithRTP);
+    virtual ~ProxyServerMediaSubsession();
+
+    char const *codecName() const {
+        return fCodecName;
+    }
+    char const *url() const {
+        return ((ProxyServerMediaSession *)fParentSession)->url();
+    }
+
+private:  // redefined virtual functions
+    virtual FramedSource *createNewStreamSource(unsigned clientSessionId, unsigned &estBitrate);
+    virtual void          closeStreamSource(FramedSource *inputSource);
+    virtual RTPSink *     createNewRTPSink(Groupsock *rtpGroupsock, unsigned char rtpPayloadTypeIfDynamic, FramedSource *inputSource);
+    virtual Groupsock *   createGroupsock(struct sockaddr_storage const &addr, Port port);
+    virtual RTCPInstance *createRTCP(Groupsock *RTCPgs, unsigned totSessionBW, /* in kbps */
+                                     unsigned char const *cname, RTPSink *sink);
+
+private:
+    static void subsessionByeHandler(void *clientData);
+    void        subsessionByeHandler();
+
+    int verbosityLevel() const {
+        return ((ProxyServerMediaSession *)fParentSession)->fVerbosityLevel;
+    }
+
+private:
+    friend class ProxyRTSPClient;
+    MediaSubsession &           fClientMediaSubsession;  // the 'client' media subsession object that corresponds to this 'server' media subsession
+    char const *                fCodecName;              // copied from "fClientMediaSubsession" once it's been set up
+    ProxyServerMediaSubsession *fNext;                   // used when we're part of a queue
+    Boolean                     fHaveSetupStream;
+};
+
+////////// ProxyServerMediaSession implementation //////////
+
+UsageEnvironment &operator<<(UsageEnvironment &env, const ProxyServerMediaSession &psms) {  // used for debugging
+    return env << "ProxyServerMediaSession[" << psms.url() << "]";
+}
+
+ProxyRTSPClient *defaultCreateNewProxyRTSPClientFunc(ProxyServerMediaSession &ourServerMediaSession, char const *rtspURL, char const *username,
+                                                     char const *password, portNumBits tunnelOverHTTPPortNum, int verbosityLevel, int socketNumToServer) {
+    return new ProxyRTSPClient(ourServerMediaSession, rtspURL, username, password, tunnelOverHTTPPortNum, verbosityLevel, socketNumToServer);
+}
+
+ProxyServerMediaSession *ProxyServerMediaSession ::createNew(UsageEnvironment &env, GenericMediaServer *ourMediaServer, char const *inputStreamURL,
+                                                             char const *streamName, char const *username, char const *password,
+                                                             portNumBits tunnelOverHTTPPortNum, int verbosityLevel, int socketNumToServer,
+                                                             MediaTranscodingTable *transcodingTable) {
+    return new ProxyServerMediaSession(env, ourMediaServer, inputStreamURL, streamName, username, password, tunnelOverHTTPPortNum, verbosityLevel,
+                                       socketNumToServer, transcodingTable);
+}
+
+ProxyServerMediaSession ::ProxyServerMediaSession(UsageEnvironment &env, GenericMediaServer *ourMediaServer, char const *inputStreamURL, char const *streamName,
+                                                  char const *username, char const *password, portNumBits tunnelOverHTTPPortNum, int verbosityLevel,
+                                                  int socketNumToServer, MediaTranscodingTable *transcodingTable,
+                                                  createNewProxyRTSPClientFunc *ourCreateNewProxyRTSPClientFunc, portNumBits initialPortNum,
+                                                  Boolean multiplexRTCPWithRTP)
+    : ServerMediaSession(env, streamName, NULL, NULL, False, NULL),
+      describeCompletedFlag(0),
+      fOurMediaServer(ourMediaServer),
+      fClientMediaSession(NULL),
+      fVerbosityLevel(verbosityLevel),
+      fPresentationTimeSessionNormalizer(new PresentationTimeSessionNormalizer(envir())),
+      fCreateNewProxyRTSPClientFunc(ourCreateNewProxyRTSPClientFunc),
+      fTranscodingTable(transcodingTable),
+      fInitialPortNum(initialPortNum),
+      fMultiplexRTCPWithRTP(multiplexRTCPWithRTP) {
+    // Open a RTSP connection to the input stream, and send a "DESCRIBE" command.
+    // We'll use the SDP description in the response to set ourselves up.
+    fProxyRTSPClient = (*fCreateNewProxyRTSPClientFunc)(*this, inputStreamURL, username, password, tunnelOverHTTPPortNum,
+                                                        verbosityLevel > 0 ? verbosityLevel - 1 : verbosityLevel, socketNumToServer);
+    fProxyRTSPClient->sendDESCRIBE();
+}
+
+ProxyServerMediaSession::~ProxyServerMediaSession() {
+    if(fVerbosityLevel > 0) {
+        envir() << *this << "::~ProxyServerMediaSession()\n";
+    }
+
+    // Begin by sending a "TEARDOWN" command (without checking for a response):
+    if(fProxyRTSPClient != NULL && fClientMediaSession != NULL) {
+        fProxyRTSPClient->sendTeardownCommand(*fClientMediaSession, NULL, fProxyRTSPClient->auth());
+    }
+
+    // Then delete our state:
+    Medium::close(fClientMediaSession);
+    Medium::close(fProxyRTSPClient);
+    Medium::close(fPresentationTimeSessionNormalizer);
+}
+
+char const *ProxyServerMediaSession::url() const {
+    return fProxyRTSPClient == NULL ? NULL : fProxyRTSPClient->url();
+}
+
+Groupsock *ProxyServerMediaSession ::createGroupsock(struct sockaddr_storage const &addr, Port port) {
+    // Default implementation; may be redefined by subclasses:
+    return new Groupsock(envir(), addr, port, 255);
+}
+
+RTCPInstance *ProxyServerMediaSession ::createRTCP(Groupsock *RTCPgs, unsigned totSessionBW, /* in kbps */
+                                                   unsigned char const *cname, RTPSink *sink) {
+    // Default implementation; may be redefined by subclasses:
+    return RTCPInstance::createNew(envir(), RTCPgs, totSessionBW, cname, sink, NULL /*we're a server*/);
+}
+
+Boolean ProxyServerMediaSession::allowProxyingForSubsession(MediaSubsession const & /*mss*/) {
+    // Default implementation
+    return True;
+}
+
+void ProxyServerMediaSession::continueAfterDESCRIBE(char const *sdpDescription) {
+    describeCompletedFlag = 1;
+
+    // Create a (client) "MediaSession" object from the stream's SDP description ("resultString"), then iterate through its
+    // "MediaSubsession" objects, to set up corresponding "ServerMediaSubsession" objects that we'll use to serve the stream's tracks.
+    do {
+        fClientMediaSession = MediaSession::createNew(envir(), sdpDescription);
+        if(fClientMediaSession == NULL)
+            break;
+
+        MediaSubsessionIterator iter(*fClientMediaSession);
+        for(MediaSubsession *mss = iter.next(); mss != NULL; mss = iter.next()) {
+            if(!allowProxyingForSubsession(*mss))
+                continue;
+
+            ServerMediaSubsession *smss = new ProxyServerMediaSubsession(*mss, fInitialPortNum, fMultiplexRTCPWithRTP);
+            addSubsession(smss);
+            if(fVerbosityLevel > 0) {
+                envir() << *this << " added new \"ProxyServerMediaSubsession\" for " << mss->protocolName() << "/" << mss->mediumName() << "/"
+                        << mss->codecName() << " track\n";
+            }
+        }
+    } while(0);
+}
+
+void ProxyServerMediaSession::resetDESCRIBEState() {
+    // Delete all of our "ProxyServerMediaSubsession"s; they'll get set up again once we get a response to the new "DESCRIBE".
+    if(fOurMediaServer != NULL) {
+        // First, close any client connections that may have already been set up:
+        fOurMediaServer->closeAllClientSessionsForServerMediaSession(this);
+    }
+    deleteAllSubsessions();
+
+    // Finally, delete the client "MediaSession" object that we had set up after receiving the response to the previous "DESCRIBE":
+    Medium::close(fClientMediaSession);
+    fClientMediaSession = NULL;
+}
+
+///////// RTSP 'response handlers' //////////
+
+static void continueAfterDESCRIBE(RTSPClient *rtspClient, int resultCode, char *resultString) {
+    char const *res;
+
+    if(resultCode == 0) {
+        // The "DESCRIBE" command succeeded, so "resultString" should be the stream's SDP description.
+        res = resultString;
+    }
+    else {
+        // The "DESCRIBE" command failed.
+        res = NULL;
+    }
+    ((ProxyRTSPClient *)rtspClient)->continueAfterDESCRIBE(res);
+    delete[] resultString;
+}
+
+static void continueAfterSETUP(RTSPClient *rtspClient, int resultCode, char *resultString) {
+    ((ProxyRTSPClient *)rtspClient)->continueAfterSETUP(resultCode);
+    delete[] resultString;
+}
+
+static void continueAfterPLAY(RTSPClient *rtspClient, int resultCode, char *resultString) {
+    ((ProxyRTSPClient *)rtspClient)->continueAfterPLAY(resultCode);
+    delete[] resultString;
+}
+
+static void continueAfterOPTIONS(RTSPClient *rtspClient, int resultCode, char *resultString) {
+    Boolean serverSupportsGetParameter = False;
+    if(resultCode == 0) {
+        // Note whether the server told us that it supports the "GET_PARAMETER" command:
+        serverSupportsGetParameter = RTSPOptionIsSupported("GET_PARAMETER", resultString);
+    }
+    ((ProxyRTSPClient *)rtspClient)->continueAfterLivenessCommand(resultCode, serverSupportsGetParameter);
+    delete[] resultString;
+}
+
+#ifdef SEND_GET_PARAMETER_IF_SUPPORTED
+static void continueAfterGET_PARAMETER(RTSPClient *rtspClient, int resultCode, char *resultString) {
+    ((ProxyRTSPClient *)rtspClient)->continueAfterLivenessCommand(resultCode, True);
+    delete[] resultString;
+}
+#endif
+
+////////// "ProxyRTSPClient" implementation /////////
+
+UsageEnvironment &operator<<(UsageEnvironment &env, const ProxyRTSPClient &proxyRTSPClient) {  // used for debugging
+    return env << "ProxyRTSPClient[" << proxyRTSPClient.url() << "]";
+}
+
+ProxyRTSPClient::ProxyRTSPClient(ProxyServerMediaSession &ourServerMediaSession, char const *rtspURL, char const *username, char const *password,
+                                 portNumBits tunnelOverHTTPPortNum, int verbosityLevel, int socketNumToServer)
+    : RTSPClient(ourServerMediaSession.envir(), rtspURL, verbosityLevel, "ProxyRTSPClient",
+                 tunnelOverHTTPPortNum == (portNumBits)(~0) ? 0 : tunnelOverHTTPPortNum, socketNumToServer),
+      fOurServerMediaSession(ourServerMediaSession),
+      fOurURL(strDup(rtspURL)),
+      fStreamRTPOverTCP(tunnelOverHTTPPortNum != 0),
+      fSetupQueueHead(NULL),
+      fSetupQueueTail(NULL),
+      fNumSetupsDone(0),
+      fNextDESCRIBEDelay(1),
+      fServerSupportsGetParameter(False),
+      fLastCommandWasPLAY(False),
+      fDoneDESCRIBE(False),
+      fLivenessCommandTask(NULL),
+      fDESCRIBECommandTask(NULL),
+      fSubsessionTimerTask(NULL),
+      fResetTask(NULL) {
+    if(username != NULL && password != NULL) {
+        fOurAuthenticator = new Authenticator(username, password);
+    }
+    else {
+        fOurAuthenticator = NULL;
+    }
+}
+
+void ProxyRTSPClient::reset() {
+    envir().taskScheduler().unscheduleDelayedTask(fLivenessCommandTask);
+    envir().taskScheduler().unscheduleDelayedTask(fDESCRIBECommandTask);
+    envir().taskScheduler().unscheduleDelayedTask(fSubsessionTimerTask);
+    envir().taskScheduler().unscheduleDelayedTask(fResetTask);
+
+    fSetupQueueHead = fSetupQueueTail = NULL;
+    fNumSetupsDone                    = 0;
+    fNextDESCRIBEDelay                = 1;
+    fLastCommandWasPLAY               = False;
+    fDoneDESCRIBE                     = False;
+
+    RTSPClient::reset();
+}
+
+ProxyRTSPClient::~ProxyRTSPClient() {
+    reset();
+
+    delete fOurAuthenticator;
+    delete[] fOurURL;
+}
+
+int ProxyRTSPClient::connectToServer(int socketNum, portNumBits remotePortNum) {
+    int res;
+    res = RTSPClient::connectToServer(socketNum, remotePortNum);
+
+    if(res == 0 && fDoneDESCRIBE && fStreamRTPOverTCP) {
+        if(fVerbosityLevel > 0) {
+            envir() << "ProxyRTSPClient::connectToServer calling scheduleReset()\n";
+        }
+        scheduleReset();
+    }
+
+    return res;
+}
+
+void ProxyRTSPClient::continueAfterDESCRIBE(char const *sdpDescription) {
+    if(sdpDescription != NULL) {
+        fOurServerMediaSession.continueAfterDESCRIBE(sdpDescription);
+
+        // Unlike most RTSP streams, there might be a long delay between this "DESCRIBE" command (to the downstream server) and the
+        // subsequent "SETUP"/"PLAY" - which doesn't occur until the first time that a client requests the stream.
+        // To prevent the proxied connection (between us and the downstream server) from timing out, we send periodic 'liveness'
+        // ("OPTIONS" or "GET_PARAMETER") commands.  (The usual RTCP liveness mechanism wouldn't work here, because RTCP packets
+        // don't get sent until after the "PLAY" command.)
+        scheduleLivenessCommand();
+    }
+    else {
+        // The "DESCRIBE" command failed, most likely because the server or the stream is not yet running.
+        // Reschedule another "DESCRIBE" command to take place later:
+        scheduleDESCRIBECommand();
+    }
+    fDoneDESCRIBE = True;
+}
+
+void ProxyRTSPClient::continueAfterLivenessCommand(int resultCode, Boolean serverSupportsGetParameter) {
+    if(resultCode != 0) {
+        // The periodic 'liveness' command failed, suggesting that the back-end stream is no longer alive.
+        // We handle this by resetting our connection state with this server.  Any current clients will be closed, but
+        // subsequent clients will cause new RTSP "SETUP"s and "PLAY"s to get done, restarting the stream.
+        // Then continue by sending more "DESCRIBE" commands, to try to restore the stream.
+
+        fServerSupportsGetParameter = False;  // until we learn otherwise, in response to a future "OPTIONS" command
+
+        if(resultCode < 0) {
+            // The 'liveness' command failed without getting a response from the server (otherwise "resultCode" would have been > 0).
+            // This suggests that the RTSP connection itself has failed.  Print this error code, in case it's useful for debugging:
+            if(fVerbosityLevel > 0) {
+                envir() << *this << ": lost connection to server ('errno': " << -resultCode << ").  Scheduling reset...\n";
+            }
+        }
+
+        scheduleReset();
+        return;
+    }
+
+    fServerSupportsGetParameter = serverSupportsGetParameter;
+
+    // Schedule the next 'liveness' command (i.e., to tell the back-end server that we're still alive):
+    scheduleLivenessCommand();
+}
+
+#define SUBSESSION_TIMEOUT_SECONDS 5  // how many seconds to wait for the last track's "SETUP" to be done (note below)
+
+void ProxyRTSPClient::continueAfterSETUP(int resultCode) {
+    if(resultCode != 0) {
+        // The "SETUP" command failed, so arrange to reset the state. (We don't do this now, because it deletes the
+        // "ProxyServerMediaSubsession", and we can't do that during "ProxyServerMediaSubsession::createNewStreamSource()".)
+        scheduleReset();
+        return;
+    }
+
+    if(fVerbosityLevel > 0) {
+        envir() << *this << "::continueAfterSETUP(): head codec: " << fSetupQueueHead->codecName() << "; numSubsessions "
+                << fSetupQueueHead->fParentSession->numSubsessions() << "\n\tqueue:";
+        for(ProxyServerMediaSubsession *p = fSetupQueueHead; p != NULL; p = p->fNext) {
+            envir() << "\t" << p->codecName();
+        }
+        envir() << "\n";
+    }
+    envir().taskScheduler().unscheduleDelayedTask(fSubsessionTimerTask);  // in case it had been set
+
+    // Dequeue the first "ProxyServerMediaSubsession" from our 'SETUP queue'.  It will be the one for which this "SETUP" was done:
+    ProxyServerMediaSubsession *smss = fSetupQueueHead;  // Assert: != NULL
+    fSetupQueueHead                  = fSetupQueueHead->fNext;
+    if(fSetupQueueHead == NULL)
+        fSetupQueueTail = NULL;
+
+    if(fSetupQueueHead != NULL) {
+        // There are still entries in the queue, for tracks for which we have still to do a "SETUP".
+        // "SETUP" the first of these now:
+        sendSetupCommand(fSetupQueueHead->fClientMediaSubsession, ::continueAfterSETUP, False, fStreamRTPOverTCP, False, fOurAuthenticator);
+        ++fNumSetupsDone;
+        fSetupQueueHead->fHaveSetupStream = True;
+    }
+    else {
+        if(fNumSetupsDone >= smss->fParentSession->numSubsessions()) {
+            // We've now finished setting up each of our subsessions (i.e., 'tracks').
+            // Continue by sending a "PLAY" command (an 'aggregate' "PLAY" command, on the whole session):
+            sendPlayCommand(smss->fClientMediaSubsession.parentSession(), ::continueAfterPLAY, -1.0f, -1.0f, 1.0f, fOurAuthenticator);
+            // the "-1.0f" "start" parameter causes the "PLAY" to be sent without a "Range:" header, in case we'd already done
+            // a "PLAY" before (as a result of a 'subsession timeout' (note below))
+            fLastCommandWasPLAY = True;
+        }
+        else {
+            // Some of this session's subsessions (i.e., 'tracks') remain to be "SETUP".  They might get "SETUP" very soon, but it's
+            // also possible - if the remote client chose to play only some of the session's tracks - that they might not.
+            // To allow for this possibility, we set a timer.  If the timer expires without the remaining subsessions getting "SETUP",
+            // then we send a "PLAY" command anyway:
+            fSubsessionTimerTask = envir().taskScheduler().scheduleDelayedTask(SUBSESSION_TIMEOUT_SECONDS * MILLION, (TaskFunc *)subsessionTimeout, this);
+        }
+    }
+}
+
+void ProxyRTSPClient::continueAfterPLAY(int resultCode) {
+    if(resultCode != 0) {
+        // The "PLAY" command failed, so arrange to reset the state. (We don't do this now, because it deletes the
+        // "ProxyServerMediaSubsession", and we can't do that during "ProxyServerMediaSubsession::createNewStreamSource()".)
+        scheduleReset();
+        return;
+    }
+}
+
+void ProxyRTSPClient::scheduleLivenessCommand() {
+    // Delay a random time before sending another 'liveness' command.
+    unsigned delayMax = sessionTimeoutParameter();  // if the server specified a maximum time between 'liveness' probes, then use that
+    if(delayMax == 0) {
+        delayMax = 60;
+    }
+
+    // Choose a random time from [delayMax/2,delayMax-1) seconds:
+    unsigned const us_1stPart = delayMax * 500000;
+    unsigned       uSecondsToDelay;
+    if(us_1stPart <= 1000000) {
+        uSecondsToDelay = us_1stPart;
+    }
+    else {
+        unsigned const us_2ndPart = us_1stPart - 1000000;
+        uSecondsToDelay           = us_1stPart + (us_2ndPart * our_random()) % us_2ndPart;
+    }
+    fLivenessCommandTask = envir().taskScheduler().scheduleDelayedTask(uSecondsToDelay, sendLivenessCommand, this);
+}
+
+void ProxyRTSPClient::sendLivenessCommand(void *clientData) {
+    ProxyRTSPClient *rtspClient      = (ProxyRTSPClient *)clientData;
+    rtspClient->fLivenessCommandTask = NULL;
+
+    // Note.  By default, we do not send "GET_PARAMETER" as our 'liveness notification' command, even if the server previously
+    // indicated (in its response to our earlier "OPTIONS" command) that it supported "GET_PARAMETER".  This is because
+    // "GET_PARAMETER" crashes some camera servers (even though they claimed to support "GET_PARAMETER").
+#ifdef SEND_GET_PARAMETER_IF_SUPPORTED
+    MediaSession *sess = rtspClient->fOurServerMediaSession.fClientMediaSession;
+
+    if(rtspClient->fServerSupportsGetParameter && rtspClient->fNumSetupsDone > 0 && sess != NULL) {
+        rtspClient->sendGetParameterCommand(*sess, ::continueAfterGET_PARAMETER, "", rtspClient->auth());
+    }
+    else {
+#endif
+        rtspClient->sendOptionsCommand(::continueAfterOPTIONS, rtspClient->auth());
+#ifdef SEND_GET_PARAMETER_IF_SUPPORTED
+    }
+#endif
+}
+
+void ProxyRTSPClient::scheduleReset() {
+    if(fVerbosityLevel > 0) {
+        envir() << "ProxyRTSPClient::scheduleReset\n";
+    }
+    envir().taskScheduler().rescheduleDelayedTask(fResetTask, 0, doReset, this);
+}
+
+void ProxyRTSPClient::doReset() {
+    fResetTask = NULL;
+    if(fVerbosityLevel > 0) {
+        envir() << *this << "::doReset\n";
+    }
+
+    reset();
+    fOurServerMediaSession.resetDESCRIBEState();
+
+    setBaseURL(fOurURL);  // because we'll be sending an initial "DESCRIBE" all over again
+    sendDESCRIBE();
+}
+
+void ProxyRTSPClient::doReset(void *clientData) {
+    ProxyRTSPClient *rtspClient = (ProxyRTSPClient *)clientData;
+    rtspClient->doReset();
+}
+
+void ProxyRTSPClient::scheduleDESCRIBECommand() {
+    // Delay 1s, 2s, 4s, 8s ... 256s until sending the next "DESCRIBE".  Then, keep delaying a random time from [256..511] seconds:
+    unsigned secondsToDelay;
+    if(fNextDESCRIBEDelay <= 256) {
+        secondsToDelay = fNextDESCRIBEDelay;
+        fNextDESCRIBEDelay *= 2;
+    }
+    else {
+        secondsToDelay = 256 + (our_random() & 0xFF);  // [256..511] seconds
+    }
+
+    if(fVerbosityLevel > 0) {
+        envir() << *this << ": RTSP \"DESCRIBE\" command failed; trying again in " << secondsToDelay << " seconds\n";
+    }
+    fDESCRIBECommandTask = envir().taskScheduler().scheduleDelayedTask(secondsToDelay * MILLION, sendDESCRIBE, this);
+}
+
+void ProxyRTSPClient::sendDESCRIBE(void *clientData) {
+    ProxyRTSPClient *rtspClient = (ProxyRTSPClient *)clientData;
+    if(rtspClient != NULL) {
+        rtspClient->fDESCRIBECommandTask = NULL;
+        rtspClient->sendDESCRIBE();
+    }
+}
+
+void ProxyRTSPClient::sendDESCRIBE() {
+    sendDescribeCommand(::continueAfterDESCRIBE, auth());
+}
+
+void ProxyRTSPClient::subsessionTimeout(void *clientData) {
+    ((ProxyRTSPClient *)clientData)->handleSubsessionTimeout();
+}
+
+void ProxyRTSPClient::handleSubsessionTimeout() {
+    fSubsessionTimerTask = NULL;
+    // We still have one or more subsessions ('tracks') left to "SETUP".  But we can't wait any longer for them.  Send a "PLAY" now:
+    MediaSession *sess = fOurServerMediaSession.fClientMediaSession;
+    if(sess != NULL)
+        sendPlayCommand(*sess, ::continueAfterPLAY, -1.0f, -1.0f, 1.0f, fOurAuthenticator);
+    fLastCommandWasPLAY = True;
+}
+
+//////// "ProxyServerMediaSubsession" implementation //////////
+
+ProxyServerMediaSubsession ::ProxyServerMediaSubsession(MediaSubsession &mediaSubsession, portNumBits initialPortNum, Boolean multiplexRTCPWithRTP)
+    : OnDemandServerMediaSubsession(mediaSubsession.parentSession().envir(), True /*reuseFirstSource*/, initialPortNum, multiplexRTCPWithRTP),
+      fClientMediaSubsession(mediaSubsession),
+      fCodecName(strDup(mediaSubsession.codecName())),
+      fNext(NULL),
+      fHaveSetupStream(False) {}
+
+UsageEnvironment &operator<<(UsageEnvironment &env, const ProxyServerMediaSubsession &psmss) {  // used for debugging
+    return env << "ProxyServerMediaSubsession[" << psmss.url() << "," << psmss.codecName() << "]";
+}
+
+ProxyServerMediaSubsession::~ProxyServerMediaSubsession() {
+    if(verbosityLevel() > 0) {
+        envir() << *this << "::~ProxyServerMediaSubsession()\n";
+    }
+
+    delete[](char *) fCodecName;
+}
+
+FramedSource *ProxyServerMediaSubsession::createNewStreamSource(unsigned clientSessionId, unsigned &estBitrate) {
+    ProxyServerMediaSession *const sms = (ProxyServerMediaSession *)fParentSession;
+
+    if(verbosityLevel() > 0) {
+        envir() << *this << "::createNewStreamSource(session id " << clientSessionId << ")\n";
+    }
+
+    // If we haven't yet created a data source from our 'media subsession' object, initiate() it to do so:
+    if(fClientMediaSubsession.readSource() == NULL) {
+        if(sms->fTranscodingTable == NULL || !sms->fTranscodingTable->weWillTranscode("audio", "MPA-ROBUST"))
+            fClientMediaSubsession.receiveRawMP3ADUs();  // hack for proxying MPA-ROBUST streams
+        if(sms->fTranscodingTable == NULL || !sms->fTranscodingTable->weWillTranscode("video", "JPEG"))
+            fClientMediaSubsession.receiveRawJPEGFrames();  // hack for proxying JPEG/RTP streams.
+        fClientMediaSubsession.initiate();
+        if(verbosityLevel() > 0) {
+            envir() << "\tInitiated: " << *this << "\n";
+        }
+
+        if(fClientMediaSubsession.readSource() != NULL) {
+            // First, check whether we have defined a 'transcoder' filter to be used with this codec:
+            if(sms->fTranscodingTable != NULL) {
+                char *        outputCodecName;
+                FramedFilter *transcoder = sms->fTranscodingTable->lookupTranscoder(fClientMediaSubsession, outputCodecName);
+                if(transcoder != NULL) {
+                    fClientMediaSubsession.addFilter(transcoder);
+                    delete[](char *) fCodecName;
+                    fCodecName = outputCodecName;
+                }
+            }
+
+            // Then, add to the front of all data sources a filter that will 'normalize' their frames'
+            // presentation times, before the frames get re-transmitted by our server:
+            FramedFilter *normalizerFilter = sms->fPresentationTimeSessionNormalizer->createNewPresentationTimeSubsessionNormalizer(
+                fClientMediaSubsession.readSource(), fClientMediaSubsession.rtpSource(), fCodecName);
+            fClientMediaSubsession.addFilter(normalizerFilter);
+
+            // Some data sources require a 'framer' object to be added, before they can be fed into
+            // a "RTPSink".  Adjust for this now:
+            if(strcmp(fCodecName, "H264") == 0) {
+                fClientMediaSubsession.addFilter(H264VideoStreamDiscreteFramer ::createNew(envir(), fClientMediaSubsession.readSource()));
+            }
+            else if(strcmp(fCodecName, "H265") == 0) {
+                fClientMediaSubsession.addFilter(H265VideoStreamDiscreteFramer ::createNew(envir(), fClientMediaSubsession.readSource()));
+            }
+            else if(strcmp(fCodecName, "MP4V-ES") == 0) {
+                fClientMediaSubsession.addFilter(
+                    MPEG4VideoStreamDiscreteFramer ::createNew(envir(), fClientMediaSubsession.readSource(), True /* leave PTs unmodified*/));
+            }
+            else if(strcmp(fCodecName, "MPV") == 0) {
+                fClientMediaSubsession.addFilter(
+                    MPEG1or2VideoStreamDiscreteFramer ::createNew(envir(), fClientMediaSubsession.readSource(), False, 5.0, True /* leave PTs unmodified*/));
+            }
+            else if(strcmp(fCodecName, "DV") == 0) {
+                fClientMediaSubsession.addFilter(
+                    DVVideoStreamFramer ::createNew(envir(), fClientMediaSubsession.readSource(), False, True /* leave PTs unmodified*/));
+            }
+        }
+
+        if(fClientMediaSubsession.rtcpInstance() != NULL) {
+            fClientMediaSubsession.rtcpInstance()->setByeHandler(subsessionByeHandler, this);
+        }
+    }
+
+    ProxyRTSPClient *const proxyRTSPClient = sms->fProxyRTSPClient;
+    if(clientSessionId != 0) {
+        // We're being called as a result of implementing a RTSP "SETUP".
+        if(!fHaveSetupStream) {
+            // This is our first "SETUP".  Send RTSP "SETUP" and later "PLAY" commands to the proxied server, to start streaming:
+            // (Before sending "SETUP", enqueue ourselves on the "RTSPClient"s 'SETUP queue', so we'll be able to get the correct
+            //  "ProxyServerMediaSubsession" to handle the response.  (Note that responses come back in the same order as requests.))
+            Boolean queueWasEmpty = proxyRTSPClient->fSetupQueueHead == NULL;
+            if(queueWasEmpty) {
+                proxyRTSPClient->fSetupQueueHead = this;
+                proxyRTSPClient->fSetupQueueTail = this;
+            }
+            else {
+                // Add ourself to the "RTSPClient"s 'SETUP queue' (if we're not already on it):
+                ProxyServerMediaSubsession *psms;
+                for(psms = proxyRTSPClient->fSetupQueueHead; psms != NULL; psms = psms->fNext) {
+                    if(psms == this)
+                        break;
+                }
+                if(psms == NULL) {
+                    proxyRTSPClient->fSetupQueueTail->fNext = this;
+                    proxyRTSPClient->fSetupQueueTail        = this;
+                }
+            }
+
+            // Hack: If there's already a pending "SETUP" request, don't send this track's "SETUP" right away, because
+            // the server might not properly handle 'pipelined' requests.  Instead, wait until after previous "SETUP" responses come back.
+            if(queueWasEmpty) {
+                proxyRTSPClient->sendSetupCommand(fClientMediaSubsession, ::continueAfterSETUP, False, proxyRTSPClient->fStreamRTPOverTCP, False,
+                                                  proxyRTSPClient->auth());
+                ++proxyRTSPClient->fNumSetupsDone;
+                fHaveSetupStream = True;
+            }
+        }
+        else {
+            // This is a "SETUP" from a new client.  We know that there are no other currently active clients (otherwise we wouldn't
+            // have been called here), so we know that the substream was previously "PAUSE"d.  Send "PLAY" downstream once again,
+            // to resume the stream:
+            if(!proxyRTSPClient->fLastCommandWasPLAY) {  // so that we send only one "PLAY"; not one for each subsession
+                proxyRTSPClient->sendPlayCommand(fClientMediaSubsession.parentSession(), ::continueAfterPLAY, -1.0f /*resume from previous point*/, -1.0f, 1.0f,
+                                                 proxyRTSPClient->auth());
+                proxyRTSPClient->fLastCommandWasPLAY = True;
+            }
+        }
+    }
+
+    estBitrate = fClientMediaSubsession.bandwidth();
+    if(estBitrate == 0)
+        estBitrate = 50;  // kbps, estimate
+    return fClientMediaSubsession.readSource();
+}
+
+void ProxyServerMediaSubsession::closeStreamSource(FramedSource * /*inputSource*/) {
+    if(verbosityLevel() > 0) {
+        envir() << *this << "::closeStreamSource()\n";
+    }
+    // Because there's only one input source for this 'subsession' (regardless of how many downstream clients are proxying it),
+    // we don't close the input source here.  (Instead, we wait until *this* object gets deleted.)
+    // However, because (as evidenced by this function having been called) we no longer have any clients accessing the stream,
+    // then we "PAUSE" the downstream proxied stream, until a new client arrives:
+    if(fHaveSetupStream) {
+        ProxyServerMediaSession *const sms             = (ProxyServerMediaSession *)fParentSession;
+        ProxyRTSPClient *const         proxyRTSPClient = sms->fProxyRTSPClient;
+        if(proxyRTSPClient->fLastCommandWasPLAY) {  // so that we send only one "PAUSE"; not one for each subsession
+            if(fParentSession->referenceCount() > 1) {
+                // There are other client(s) still streaming other subsessions of this stream.
+                // Therefore, we don't send a "PAUSE" for the whole stream.
+                // In principle, we would send a "PAUSE" only for the sub-stream here, but some
+                // back-end servers might mis-handle that by pausing the entire stream.
+                // So instead, we do nothing here.
+                // proxyRTSPClient->sendPauseCommand(fClientMediaSubsession, NULL, proxyRTSPClient->auth());
+            }
+            else {
+                // Normal case: There are no other clients still streaming (parts of) this stream.
+                // Send a "PAUSE" for the whole stream.
+                proxyRTSPClient->sendPauseCommand(fClientMediaSubsession.parentSession(), NULL, proxyRTSPClient->auth());
+                proxyRTSPClient->fLastCommandWasPLAY = False;
+            }
+        }
+    }
+}
+
+RTPSink *ProxyServerMediaSubsession ::createNewRTPSink(Groupsock *rtpGroupsock, unsigned char rtpPayloadTypeIfDynamic, FramedSource *inputSource) {
+    if(verbosityLevel() > 0) {
+        envir() << *this << "::createNewRTPSink()\n";
+    }
+
+    // Create (and return) the appropriate "RTPSink" object for our codec:
+    // (Note: The configuration string might not be correct if a transcoder is used. FIX!) #####
+    RTPSink *newSink;
+    if(strcmp(fCodecName, "AC3") == 0 || strcmp(fCodecName, "EAC3") == 0) {
+        newSink = AC3AudioRTPSink::createNew(envir(), rtpGroupsock, rtpPayloadTypeIfDynamic, fClientMediaSubsession.rtpTimestampFrequency());
+#if 0  // This code does not work; do *not* enable it:
+  } else if (strcmp(fCodecName, "AMR") == 0 || strcmp(fCodecName, "AMR-WB") == 0) {
+    Boolean isWideband = strcmp(fCodecName, "AMR-WB") == 0;
+    newSink = AMRAudioRTPSink::createNew(envir(), rtpGroupsock, rtpPayloadTypeIfDynamic,
+					 isWideband, fClientMediaSubsession.numChannels());
+#endif
+    }
+    else if(strcmp(fCodecName, "DV") == 0) {
+        newSink = DVVideoRTPSink::createNew(envir(), rtpGroupsock, rtpPayloadTypeIfDynamic);
+    }
+    else if(strcmp(fCodecName, "GSM") == 0) {
+        newSink = GSMAudioRTPSink::createNew(envir(), rtpGroupsock);
+    }
+    else if(strcmp(fCodecName, "H263-1998") == 0 || strcmp(fCodecName, "H263-2000") == 0) {
+        newSink = H263plusVideoRTPSink::createNew(envir(), rtpGroupsock, rtpPayloadTypeIfDynamic, fClientMediaSubsession.rtpTimestampFrequency());
+    }
+    else if(strcmp(fCodecName, "H264") == 0) {
+        newSink = H264VideoRTPSink::createNew(envir(), rtpGroupsock, rtpPayloadTypeIfDynamic, fClientMediaSubsession.fmtp_spropparametersets());
+    }
+    else if(strcmp(fCodecName, "H265") == 0) {
+        newSink = H265VideoRTPSink::createNew(envir(), rtpGroupsock, rtpPayloadTypeIfDynamic, fClientMediaSubsession.fmtp_spropvps(),
+                                              fClientMediaSubsession.fmtp_spropsps(), fClientMediaSubsession.fmtp_sproppps());
+    }
+    else if(strcmp(fCodecName, "JPEG") == 0) {
+        newSink = SimpleRTPSink::createNew(envir(), rtpGroupsock, 26, 90000, "video", "JPEG", 1 /*numChannels*/, False /*allowMultipleFramesPerPacket*/,
+                                           False /*doNormalMBitRule*/);
+    }
+    else if(strcmp(fCodecName, "MP4A-LATM") == 0) {
+        newSink = MPEG4LATMAudioRTPSink::createNew(envir(), rtpGroupsock, rtpPayloadTypeIfDynamic, fClientMediaSubsession.rtpTimestampFrequency(),
+                                                   fClientMediaSubsession.fmtp_config(), fClientMediaSubsession.numChannels());
+    }
+    else if(strcmp(fCodecName, "MP4V-ES") == 0) {
+        newSink = MPEG4ESVideoRTPSink::createNew(envir(), rtpGroupsock, rtpPayloadTypeIfDynamic, fClientMediaSubsession.rtpTimestampFrequency(),
+                                                 fClientMediaSubsession.attrVal_unsigned("profile-level-id"), fClientMediaSubsession.fmtp_config());
+    }
+    else if(strcmp(fCodecName, "MPA") == 0) {
+        newSink = MPEG1or2AudioRTPSink::createNew(envir(), rtpGroupsock);
+    }
+    else if(strcmp(fCodecName, "MPA-ROBUST") == 0) {
+        newSink = MP3ADURTPSink::createNew(envir(), rtpGroupsock, rtpPayloadTypeIfDynamic);
+    }
+    else if(strcmp(fCodecName, "MPEG4-GENERIC") == 0) {
+        newSink = MPEG4GenericRTPSink::createNew(envir(), rtpGroupsock, rtpPayloadTypeIfDynamic, fClientMediaSubsession.rtpTimestampFrequency(),
+                                                 fClientMediaSubsession.mediumName(), fClientMediaSubsession.attrVal_str("mode"),
+                                                 fClientMediaSubsession.fmtp_config(), fClientMediaSubsession.numChannels());
+    }
+    else if(strcmp(fCodecName, "MPV") == 0) {
+        newSink = MPEG1or2VideoRTPSink::createNew(envir(), rtpGroupsock);
+    }
+    else if(strcmp(fCodecName, "OPUS") == 0) {
+        newSink = SimpleRTPSink::createNew(envir(), rtpGroupsock, rtpPayloadTypeIfDynamic, 48000, "audio", "OPUS", 2,
+                                           False /*only 1 Opus 'packet' in each RTP packet*/);
+    }
+    else if(strcmp(fCodecName, "T140") == 0) {
+        newSink = T140TextRTPSink::createNew(envir(), rtpGroupsock, rtpPayloadTypeIfDynamic);
+    }
+    else if(strcmp(fCodecName, "THEORA") == 0) {
+        newSink = TheoraVideoRTPSink::createNew(envir(), rtpGroupsock, rtpPayloadTypeIfDynamic, fClientMediaSubsession.fmtp_config());
+    }
+    else if(strcmp(fCodecName, "VORBIS") == 0) {
+        newSink = VorbisAudioRTPSink::createNew(envir(), rtpGroupsock, rtpPayloadTypeIfDynamic, fClientMediaSubsession.rtpTimestampFrequency(),
+                                                fClientMediaSubsession.numChannels(), fClientMediaSubsession.fmtp_config());
+    }
+    else if(strcmp(fCodecName, "VP8") == 0) {
+        newSink = VP8VideoRTPSink::createNew(envir(), rtpGroupsock, rtpPayloadTypeIfDynamic);
+    }
+    else if(strcmp(fCodecName, "VP9") == 0) {
+        newSink = VP9VideoRTPSink::createNew(envir(), rtpGroupsock, rtpPayloadTypeIfDynamic);
+    }
+    else if(strcmp(fCodecName, "AMR") == 0 || strcmp(fCodecName, "AMR-WB") == 0) {
+        // Proxying of these codecs is currently *not* supported, because the data received by the "RTPSource" object is not in a
+        // form that can be fed directly into a corresponding "RTPSink" object.
+        if(verbosityLevel() > 0) {
+            envir() << "\treturns NULL (because we currently don't support the proxying of \"" << fClientMediaSubsession.mediumName() << "/" << fCodecName
+                    << "\" streams)\n";
+        }
+        return NULL;
+    }
+    else if(strcmp(fCodecName, "QCELP") == 0 || strcmp(fCodecName, "H261") == 0 || strcmp(fCodecName, "H263-1998") == 0 || strcmp(fCodecName, "H263-2000") == 0
+            || strcmp(fCodecName, "X-QT") == 0 || strcmp(fCodecName, "X-QUICKTIME") == 0) {
+        // This codec requires a specialized RTP payload format; however, we don't yet have an appropriate "RTPSink" subclass for it:
+        if(verbosityLevel() > 0) {
+            envir() << "\treturns NULL (because we don't have a \"RTPSink\" subclass for this RTP payload format)\n";
+        }
+        return NULL;
+    }
+    else {
+        // This codec is assumed to have a simple RTP payload format that can be implemented just with a "SimpleRTPSink":
+        Boolean allowMultipleFramesPerPacket = True;  // by default
+        Boolean doNormalMBitRule             = True;  // by default
+        // Some codecs change the above default parameters:
+        if(strcmp(fCodecName, "MP2T") == 0) {
+            doNormalMBitRule = False;  // no RTP 'M' bit
+        }
+        newSink = SimpleRTPSink::createNew(envir(), rtpGroupsock, rtpPayloadTypeIfDynamic, fClientMediaSubsession.rtpTimestampFrequency(),
+                                           fClientMediaSubsession.mediumName(), fCodecName, fClientMediaSubsession.numChannels(), allowMultipleFramesPerPacket,
+                                           doNormalMBitRule);
+    }
+
+    // Because our relayed frames' presentation times are inaccurate until the input frames have been RTCP-synchronized,
+    // we temporarily disable RTCP "SR" reports for this "RTPSink" object:
+    newSink->enableRTCPReports() = False;
+
+    // Also tell our "PresentationTimeSubsessionNormalizer" object about the "RTPSink", so it can enable RTCP "SR" reports later:
+    PresentationTimeSubsessionNormalizer *ssNormalizer;
+    if(strcmp(fCodecName, "H264") == 0 || strcmp(fCodecName, "H265") == 0 || strcmp(fCodecName, "MP4V-ES") == 0 || strcmp(fCodecName, "MPV") == 0
+       || strcmp(fCodecName, "DV") == 0) {
+        // There was a separate 'framer' object in front of the "PresentationTimeSubsessionNormalizer", so go back one object to get it:
+        ssNormalizer = (PresentationTimeSubsessionNormalizer *)(((FramedFilter *)inputSource)->inputSource());
+    }
+    else {
+        ssNormalizer = (PresentationTimeSubsessionNormalizer *)inputSource;
+    }
+    ssNormalizer->setRTPSink(newSink);
+
+    return newSink;
+}
+
+Groupsock *ProxyServerMediaSubsession ::createGroupsock(struct sockaddr_storage const &addr, Port port) {
+    ProxyServerMediaSession *parentSession = (ProxyServerMediaSession *)fParentSession;
+    return parentSession->createGroupsock(addr, port);
+}
+
+RTCPInstance *ProxyServerMediaSubsession ::createRTCP(Groupsock *RTCPgs, unsigned totSessionBW, /* in kbps */
+                                                      unsigned char const *cname, RTPSink *sink) {
+    ProxyServerMediaSession *parentSession = (ProxyServerMediaSession *)fParentSession;
+    return parentSession->createRTCP(RTCPgs, totSessionBW, cname, sink);
+}
+
+void ProxyServerMediaSubsession::subsessionByeHandler(void *clientData) {
+    ((ProxyServerMediaSubsession *)clientData)->subsessionByeHandler();
+}
+
+void ProxyServerMediaSubsession::subsessionByeHandler() {
+    if(verbosityLevel() > 0) {
+        envir() << *this << ": received RTCP \"BYE\".  (The back-end stream has ended.)\n";
+    }
+
+    // This "BYE" signals that our input source has (effectively) closed, so pass this onto the front-end clients:
+    fHaveSetupStream = False;  // hack to stop "PAUSE" getting sent by:
+    if(fClientMediaSubsession.readSource() != NULL) {
+        fClientMediaSubsession.readSource()->handleClosure();
+    }
+
+    // And then treat this as if we had lost connection to the back-end server,
+    // and can reestablish streaming from it only by sending another "DESCRIBE":
+    ProxyServerMediaSession *const sms             = (ProxyServerMediaSession *)fParentSession;
+    ProxyRTSPClient *const         proxyRTSPClient = sms->fProxyRTSPClient;
+    proxyRTSPClient->scheduleReset();
+}
+
+////////// PresentationTimeSessionNormalizer and PresentationTimeSubsessionNormalizer implementations //////////
+
+// PresentationTimeSessionNormalizer:
+
+PresentationTimeSessionNormalizer::PresentationTimeSessionNormalizer(UsageEnvironment &env)
+    : Medium(env), fSubsessionNormalizers(NULL), fMasterSSNormalizer(NULL) {}
+
+PresentationTimeSessionNormalizer::~PresentationTimeSessionNormalizer() {
+    while(fSubsessionNormalizers != NULL) {
+        Medium::close(fSubsessionNormalizers);
+    }
+}
+
+PresentationTimeSubsessionNormalizer *
+PresentationTimeSessionNormalizer ::createNewPresentationTimeSubsessionNormalizer(FramedSource *inputSource, RTPSource *rtpSource, char const *codecName) {
+    fSubsessionNormalizers = new PresentationTimeSubsessionNormalizer(*this, inputSource, rtpSource, codecName, fSubsessionNormalizers);
+    return fSubsessionNormalizers;
+}
+
+void PresentationTimeSessionNormalizer ::normalizePresentationTime(PresentationTimeSubsessionNormalizer *ssNormalizer, struct timeval &toPT,
+                                                                   struct timeval const &fromPT) {
+    Boolean const hasBeenSynced = ssNormalizer->fRTPSource->hasBeenSynchronizedUsingRTCP();
+
+    if(!hasBeenSynced) {
+        // If "fromPT" has not yet been RTCP-synchronized, then it was generated by our own receiving code, and thus
+        // is already aligned with 'wall-clock' time.  Just copy it 'as is' to "toPT":
+        toPT = fromPT;
+    }
+    else {
+        if(fMasterSSNormalizer == NULL) {
+            // Make "ssNormalizer" the 'master' subsession - meaning that its presentation time is adjusted to align with 'wall clock'
+            // time, and the presentation times of other subsessions (if any) are adjusted to retain their relative separation with
+            // those of the master:
+            fMasterSSNormalizer = ssNormalizer;
+
+            struct timeval timeNow;
+            gettimeofday(&timeNow, NULL);
+
+            // Compute: fPTAdjustment = timeNow - fromPT
+            fPTAdjustment.tv_sec  = timeNow.tv_sec - fromPT.tv_sec;
+            fPTAdjustment.tv_usec = timeNow.tv_usec - fromPT.tv_usec;
+            // Note: It's OK if one or both of these fields underflows; the result still works out OK later.
+        }
+
+        // Compute a normalized presentation time: toPT = fromPT + fPTAdjustment
+        toPT.tv_sec  = fromPT.tv_sec + fPTAdjustment.tv_sec - 1;
+        toPT.tv_usec = fromPT.tv_usec + fPTAdjustment.tv_usec + MILLION;
+        while(toPT.tv_usec > MILLION) {
+            ++toPT.tv_sec;
+            toPT.tv_usec -= MILLION;
+        }
+
+        // Because "ssNormalizer"s relayed presentation times are accurate from now on, enable RTCP "SR" reports for its "RTPSink":
+        RTPSink *const rtpSink = ssNormalizer->fRTPSink;
+        if(rtpSink != NULL) {  // sanity check; should always be true
+            rtpSink->enableRTCPReports() = True;
+        }
+    }
+}
+
+void PresentationTimeSessionNormalizer ::removePresentationTimeSubsessionNormalizer(PresentationTimeSubsessionNormalizer *ssNormalizer) {
+    // Unlink "ssNormalizer" from the linked list (starting with "fSubsessionNormalizers"):
+    if(fSubsessionNormalizers == ssNormalizer) {
+        fSubsessionNormalizers = fSubsessionNormalizers->fNext;
+    }
+    else {
+        PresentationTimeSubsessionNormalizer **ssPtrPtr = &(fSubsessionNormalizers->fNext);
+        while(*ssPtrPtr != ssNormalizer)
+            ssPtrPtr = &((*ssPtrPtr)->fNext);
+        *ssPtrPtr = (*ssPtrPtr)->fNext;
+    }
+}
+
+// PresentationTimeSubsessionNormalizer:
+
+PresentationTimeSubsessionNormalizer ::PresentationTimeSubsessionNormalizer(PresentationTimeSessionNormalizer &parent, FramedSource *inputSource,
+                                                                            RTPSource *rtpSource, char const *codecName,
+                                                                            PresentationTimeSubsessionNormalizer *next)
+    : FramedFilter(parent.envir(), inputSource), fParent(parent), fRTPSource(rtpSource), fRTPSink(NULL), fCodecName(codecName), fNext(next) {}
+
+PresentationTimeSubsessionNormalizer::~PresentationTimeSubsessionNormalizer() {
+    fParent.removePresentationTimeSubsessionNormalizer(this);
+}
+
+void PresentationTimeSubsessionNormalizer::afterGettingFrame(void *clientData, unsigned frameSize, unsigned numTruncatedBytes, struct timeval presentationTime,
+                                                             unsigned durationInMicroseconds) {
+    ((PresentationTimeSubsessionNormalizer *)clientData)->afterGettingFrame(frameSize, numTruncatedBytes, presentationTime, durationInMicroseconds);
+}
+
+void PresentationTimeSubsessionNormalizer::afterGettingFrame(unsigned frameSize, unsigned numTruncatedBytes, struct timeval presentationTime,
+                                                             unsigned durationInMicroseconds) {
+    // This filter is implemented by passing all frames through unchanged, except that "fPresentationTime" is changed:
+    fFrameSize              = frameSize;
+    fNumTruncatedBytes      = numTruncatedBytes;
+    fDurationInMicroseconds = durationInMicroseconds;
+
+    fParent.normalizePresentationTime(this, fPresentationTime, presentationTime);
+
+    // Hack for JPEG/RTP proxying.  Because we're proxying JPEG by just copying the raw JPEG/RTP payloads, without interpreting them,
+    // we need to also 'copy' the RTP 'M' (marker) bit from the "RTPSource" to the "RTPSink":
+    if(fRTPSource->curPacketMarkerBit() && strcmp(fCodecName, "JPEG") == 0)
+        ((SimpleRTPSink *)fRTPSink)->setMBitOnNextPacket();
+
+    // Complete delivery:
+    FramedSource::afterGetting(this);
+}
+
+void PresentationTimeSubsessionNormalizer::doGetNextFrame() {
+    fInputSource->getNextFrame(fTo, fMaxSize, afterGettingFrame, this, FramedSource::handleClosure, this);
+}
diff --git a/3rdparty/live555/src/liveMedia/QCELPAudioRTPSource.cpp b/3rdparty/live555/src/liveMedia/QCELPAudioRTPSource.cpp
new file mode 100644
index 00000000..1b6d00a1
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/QCELPAudioRTPSource.cpp
@@ -0,0 +1,469 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// Qualcomm "PureVoice" (aka. "QCELP") Audio RTP Sources
+// Implementation
+
+#include "QCELPAudioRTPSource.hh"
+#include "MultiFramedRTPSource.hh"
+#include "FramedFilter.hh"
+#include <string.h>
+#include <stdlib.h>
+
+// This source is implemented internally by two separate sources:
+// (i) a RTP source for the raw (interleaved) QCELP frames, and
+// (ii) a deinterleaving filter that reads from this.
+// Define these two new classes here:
+
+class RawQCELPRTPSource : public MultiFramedRTPSource {
+public:
+    static RawQCELPRTPSource *createNew(UsageEnvironment &env, Groupsock *RTPgs, unsigned char rtpPayloadFormat, unsigned rtpTimestampFrequency);
+
+    unsigned char interleaveL() const {
+        return fInterleaveL;
+    }
+    unsigned char interleaveN() const {
+        return fInterleaveN;
+    }
+    unsigned char &frameIndex() {
+        return fFrameIndex;
+    }  // index within pkt
+
+private:
+    RawQCELPRTPSource(UsageEnvironment &env, Groupsock *RTPgs, unsigned char rtpPayloadFormat, unsigned rtpTimestampFrequency);
+    // called only by createNew()
+
+    virtual ~RawQCELPRTPSource();
+
+private:
+    // redefined virtual functions:
+    virtual Boolean     processSpecialHeader(BufferedPacket *packet, unsigned &resultSpecialHeaderSize);
+    virtual char const *MIMEtype() const;
+
+    virtual Boolean hasBeenSynchronizedUsingRTCP();
+
+private:
+    unsigned char fInterleaveL, fInterleaveN, fFrameIndex;
+    unsigned      fNumSuccessiveSyncedPackets;
+};
+
+class QCELPDeinterleaver : public FramedFilter {
+public:
+    static QCELPDeinterleaver *createNew(UsageEnvironment &env, RawQCELPRTPSource *inputSource);
+
+private:
+    QCELPDeinterleaver(UsageEnvironment &env, RawQCELPRTPSource *inputSource);
+    // called only by "createNew()"
+
+    virtual ~QCELPDeinterleaver();
+
+    static void afterGettingFrame(void *clientData, unsigned frameSize, unsigned numTruncatedBytes, struct timeval presentationTime,
+                                  unsigned durationInMicroseconds);
+    void        afterGettingFrame1(unsigned frameSize, struct timeval presentationTime);
+
+private:
+    // Redefined virtual functions:
+    void         doGetNextFrame();
+    virtual void doStopGettingFrames();
+
+private:
+    class QCELPDeinterleavingBuffer *fDeinterleavingBuffer;
+    Boolean                          fNeedAFrame;
+};
+
+////////// QCELPAudioRTPSource implementation //////////
+
+FramedSource *QCELPAudioRTPSource::createNew(UsageEnvironment &env, Groupsock *RTPgs, RTPSource *&resultRTPSource, unsigned char rtpPayloadFormat,
+                                             unsigned rtpTimestampFrequency) {
+    RawQCELPRTPSource *rawRTPSource;
+    resultRTPSource = rawRTPSource = RawQCELPRTPSource::createNew(env, RTPgs, rtpPayloadFormat, rtpTimestampFrequency);
+    if(resultRTPSource == NULL)
+        return NULL;
+
+    QCELPDeinterleaver *deinterleaver = QCELPDeinterleaver::createNew(env, rawRTPSource);
+    if(deinterleaver == NULL) {
+        Medium::close(resultRTPSource);
+        resultRTPSource = NULL;
+    }
+
+    return deinterleaver;
+}
+
+////////// QCELPBufferedPacket and QCELPBufferedPacketFactory //////////
+
+// A subclass of BufferedPacket, used to separate out QCELP frames.
+
+class QCELPBufferedPacket : public BufferedPacket {
+public:
+    QCELPBufferedPacket(RawQCELPRTPSource &ourSource);
+    virtual ~QCELPBufferedPacket();
+
+private:  // redefined virtual functions
+    virtual unsigned nextEnclosedFrameSize(unsigned char *&framePtr, unsigned dataSize);
+
+private:
+    RawQCELPRTPSource &fOurSource;
+};
+
+class QCELPBufferedPacketFactory : public BufferedPacketFactory {
+private:  // redefined virtual functions
+    virtual BufferedPacket *createNewPacket(MultiFramedRTPSource *ourSource);
+};
+
+///////// RawQCELPRTPSource implementation ////////
+
+RawQCELPRTPSource *RawQCELPRTPSource::createNew(UsageEnvironment &env, Groupsock *RTPgs, unsigned char rtpPayloadFormat, unsigned rtpTimestampFrequency) {
+    return new RawQCELPRTPSource(env, RTPgs, rtpPayloadFormat, rtpTimestampFrequency);
+}
+
+RawQCELPRTPSource::RawQCELPRTPSource(UsageEnvironment &env, Groupsock *RTPgs, unsigned char rtpPayloadFormat, unsigned rtpTimestampFrequency)
+    : MultiFramedRTPSource(env, RTPgs, rtpPayloadFormat, rtpTimestampFrequency, new QCELPBufferedPacketFactory),
+      fInterleaveL(0),
+      fInterleaveN(0),
+      fFrameIndex(0),
+      fNumSuccessiveSyncedPackets(0) {}
+
+RawQCELPRTPSource::~RawQCELPRTPSource() {}
+
+Boolean RawQCELPRTPSource ::processSpecialHeader(BufferedPacket *packet, unsigned &resultSpecialHeaderSize) {
+    unsigned char *headerStart = packet->data();
+    unsigned       packetSize  = packet->dataSize();
+
+    // First, check whether this packet's RTP timestamp is synchronized:
+    if(RTPSource::hasBeenSynchronizedUsingRTCP()) {
+        ++fNumSuccessiveSyncedPackets;
+    }
+    else {
+        fNumSuccessiveSyncedPackets = 0;
+    }
+
+    // There's a 1-byte header indicating the interleave parameters
+    if(packetSize < 1)
+        return False;
+
+    // Get the interleaving parameters from the 1-byte header,
+    // and check them for validity:
+    unsigned char const firstByte   = headerStart[0];
+    unsigned char const interleaveL = (firstByte & 0x38) >> 3;
+    unsigned char const interleaveN = firstByte & 0x07;
+#ifdef DEBUG
+    fprintf(stderr, "packetSize: %d, interleaveL: %d, interleaveN: %d\n", packetSize, interleaveL, interleaveN);
+#endif
+    if(interleaveL > 5 || interleaveN > interleaveL)
+        return False;  // invalid
+
+    fInterleaveL = interleaveL;
+    fInterleaveN = interleaveN;
+    fFrameIndex  = 0;  // initially
+
+    resultSpecialHeaderSize = 1;
+    return True;
+}
+
+char const *RawQCELPRTPSource::MIMEtype() const {
+    return "audio/QCELP";
+}
+
+Boolean RawQCELPRTPSource::hasBeenSynchronizedUsingRTCP() {
+    // Don't report ourselves as being synchronized until we've received
+    // at least a complete interleave cycle of synchronized packets.
+    // This ensures that the receiver is currently getting a frame from
+    // a packet that was synchronized.
+    if(fNumSuccessiveSyncedPackets > (unsigned)(fInterleaveL + 1)) {
+        fNumSuccessiveSyncedPackets = fInterleaveL + 2;  // prevents overflow
+        return True;
+    }
+    return False;
+}
+
+///// QCELPBufferedPacket and QCELPBufferedPacketFactory implementation
+
+QCELPBufferedPacket::QCELPBufferedPacket(RawQCELPRTPSource &ourSource) : fOurSource(ourSource) {}
+
+QCELPBufferedPacket::~QCELPBufferedPacket() {}
+
+unsigned QCELPBufferedPacket::nextEnclosedFrameSize(unsigned char *&framePtr, unsigned dataSize) {
+    // The size of the QCELP frame is determined by the first byte:
+    if(dataSize == 0)
+        return 0;  // sanity check
+    unsigned char const firstByte = framePtr[0];
+
+    unsigned frameSize;
+    switch(firstByte) {
+    case 0: {
+        frameSize = 1;
+        break;
+    }
+    case 1: {
+        frameSize = 4;
+        break;
+    }
+    case 2: {
+        frameSize = 8;
+        break;
+    }
+    case 3: {
+        frameSize = 17;
+        break;
+    }
+    case 4: {
+        frameSize = 35;
+        break;
+    }
+    default: {
+        frameSize = 0;
+        break;
+    }
+    }
+
+#ifdef DEBUG
+    fprintf(stderr, "QCELPBufferedPacket::nextEnclosedFrameSize(): frameSize: %d, dataSize: %d\n", frameSize, dataSize);
+#endif
+    if(dataSize < frameSize)
+        return 0;
+
+    ++fOurSource.frameIndex();
+    return frameSize;
+}
+
+BufferedPacket *QCELPBufferedPacketFactory ::createNewPacket(MultiFramedRTPSource *ourSource) {
+    return new QCELPBufferedPacket((RawQCELPRTPSource &)(*ourSource));
+}
+
+///////// QCELPDeinterleavingBuffer /////////
+// (used to implement QCELPDeinterleaver)
+
+#define QCELP_MAX_FRAME_SIZE 35
+#define QCELP_MAX_INTERLEAVE_L 5
+#define QCELP_MAX_FRAMES_PER_PACKET 10
+#define QCELP_MAX_INTERLEAVE_GROUP_SIZE ((QCELP_MAX_INTERLEAVE_L + 1) * QCELP_MAX_FRAMES_PER_PACKET)
+
+class QCELPDeinterleavingBuffer {
+public:
+    QCELPDeinterleavingBuffer();
+    virtual ~QCELPDeinterleavingBuffer();
+
+    void deliverIncomingFrame(unsigned frameSize, unsigned char interleaveL, unsigned char interleaveN, unsigned char frameIndex, unsigned short packetSeqNum,
+                              struct timeval presentationTime);
+    Boolean retrieveFrame(unsigned char *to, unsigned maxSize, unsigned &resultFrameSize, unsigned &resultNumTruncatedBytes,
+                          struct timeval &resultPresentationTime);
+
+    unsigned char *inputBuffer() {
+        return fInputBuffer;
+    }
+    unsigned inputBufferSize() const {
+        return QCELP_MAX_FRAME_SIZE;
+    }
+
+private:
+    class FrameDescriptor {
+    public:
+        FrameDescriptor();
+        virtual ~FrameDescriptor();
+
+        unsigned       frameSize;
+        unsigned char *frameData;
+        struct timeval presentationTime;
+    };
+
+    // Use two banks of descriptors - one for incoming, one for outgoing
+    FrameDescriptor fFrames[QCELP_MAX_INTERLEAVE_GROUP_SIZE][2];
+    unsigned char   fIncomingBankId;  // toggles between 0 and 1
+    unsigned char   fIncomingBinMax;  // in the incoming bank
+    unsigned char   fOutgoingBinMax;  // in the outgoing bank
+    unsigned char   fNextOutgoingBin;
+    Boolean         fHaveSeenPackets;
+    u_int16_t       fLastPacketSeqNumForGroup;
+    unsigned char * fInputBuffer;
+    struct timeval  fLastRetrievedPresentationTime;
+};
+
+////////// QCELPDeinterleaver implementation /////////
+
+QCELPDeinterleaver *QCELPDeinterleaver::createNew(UsageEnvironment &env, RawQCELPRTPSource *inputSource) {
+    return new QCELPDeinterleaver(env, inputSource);
+}
+
+QCELPDeinterleaver::QCELPDeinterleaver(UsageEnvironment &env, RawQCELPRTPSource *inputSource) : FramedFilter(env, inputSource), fNeedAFrame(False) {
+    fDeinterleavingBuffer = new QCELPDeinterleavingBuffer();
+}
+
+QCELPDeinterleaver::~QCELPDeinterleaver() {
+    delete fDeinterleavingBuffer;
+}
+
+static unsigned const uSecsPerFrame = 20000;  // 20 ms
+
+void QCELPDeinterleaver::doGetNextFrame() {
+    // First, try getting a frame from the deinterleaving buffer:
+    if(fDeinterleavingBuffer->retrieveFrame(fTo, fMaxSize, fFrameSize, fNumTruncatedBytes, fPresentationTime)) {
+        // Success!
+        fNeedAFrame = False;
+
+        fDurationInMicroseconds = uSecsPerFrame;
+
+        // Call our own 'after getting' function.  Because we're not a 'leaf'
+        // source, we can call this directly, without risking
+        // infinite recursion
+        afterGetting(this);
+        return;
+    }
+
+    // No luck, so ask our source for help:
+    fNeedAFrame = True;
+    if(!fInputSource->isCurrentlyAwaitingData()) {
+        fInputSource->getNextFrame(fDeinterleavingBuffer->inputBuffer(), fDeinterleavingBuffer->inputBufferSize(), afterGettingFrame, this,
+                                   FramedSource::handleClosure, this);
+    }
+}
+
+void QCELPDeinterleaver::doStopGettingFrames() {
+    fNeedAFrame = False;
+    fInputSource->stopGettingFrames();
+}
+
+void QCELPDeinterleaver ::afterGettingFrame(void *clientData, unsigned frameSize, unsigned /*numTruncatedBytes*/, struct timeval presentationTime,
+                                            unsigned /*durationInMicroseconds*/) {
+    QCELPDeinterleaver *deinterleaver = (QCELPDeinterleaver *)clientData;
+    deinterleaver->afterGettingFrame1(frameSize, presentationTime);
+}
+
+void QCELPDeinterleaver ::afterGettingFrame1(unsigned frameSize, struct timeval presentationTime) {
+    RawQCELPRTPSource *source = (RawQCELPRTPSource *)fInputSource;
+
+    // First, put the frame into our deinterleaving buffer:
+    fDeinterleavingBuffer->deliverIncomingFrame(frameSize, source->interleaveL(), source->interleaveN(), source->frameIndex(), source->curPacketRTPSeqNum(),
+                                                presentationTime);
+
+    // Then, try delivering a frame to the client (if he wants one):
+    if(fNeedAFrame)
+        doGetNextFrame();
+}
+
+////////// QCELPDeinterleavingBuffer implementation /////////
+
+QCELPDeinterleavingBuffer::QCELPDeinterleavingBuffer()
+    : fIncomingBankId(0), fIncomingBinMax(0), fOutgoingBinMax(0), fNextOutgoingBin(0), fHaveSeenPackets(False) {
+    fInputBuffer = new unsigned char[QCELP_MAX_FRAME_SIZE];
+}
+
+QCELPDeinterleavingBuffer::~QCELPDeinterleavingBuffer() {
+    delete[] fInputBuffer;
+}
+
+void QCELPDeinterleavingBuffer ::deliverIncomingFrame(unsigned frameSize, unsigned char interleaveL, unsigned char interleaveN, unsigned char frameIndex,
+                                                      unsigned short packetSeqNum, struct timeval presentationTime) {
+    // First perform a sanity check on the parameters:
+    // (This is overkill, as the source should have already done this.)
+    if(frameSize > QCELP_MAX_FRAME_SIZE || interleaveL > QCELP_MAX_INTERLEAVE_L || interleaveN > interleaveL || frameIndex == 0
+       || frameIndex > QCELP_MAX_FRAMES_PER_PACKET) {
+#ifdef DEBUG
+        fprintf(stderr, "QCELPDeinterleavingBuffer::deliverIncomingFrame() param sanity check failed (%d,%d,%d,%d)\n", frameSize, interleaveL, interleaveN,
+                frameIndex);
+#endif
+        return;
+    }
+
+    // The input "presentationTime" was that of the first frame in this
+    // packet.  Update it for the current frame:
+    unsigned uSecIncrement = (frameIndex - 1) * (interleaveL + 1) * uSecsPerFrame;
+    presentationTime.tv_usec += uSecIncrement;
+    presentationTime.tv_sec += presentationTime.tv_usec / 1000000;
+    presentationTime.tv_usec = presentationTime.tv_usec % 1000000;
+
+    // Next, check whether this packet is part of a new interleave group
+    if(!fHaveSeenPackets || seqNumLT(fLastPacketSeqNumForGroup, packetSeqNum)) {
+        // We've moved to a new interleave group
+        fHaveSeenPackets          = True;
+        fLastPacketSeqNumForGroup = packetSeqNum + interleaveL - interleaveN;
+
+        // Switch the incoming and outgoing banks:
+        fIncomingBankId ^= 1;
+        unsigned char tmp = fIncomingBinMax;
+        fIncomingBinMax   = fOutgoingBinMax;
+        fOutgoingBinMax   = tmp;
+        fNextOutgoingBin  = 0;
+    }
+
+    // Now move the incoming frame into the appropriate bin:
+    unsigned const   binNumber = interleaveN + (frameIndex - 1) * (interleaveL + 1);
+    FrameDescriptor &inBin     = fFrames[binNumber][fIncomingBankId];
+    unsigned char *  curBuffer = inBin.frameData;
+    inBin.frameData            = fInputBuffer;
+    inBin.frameSize            = frameSize;
+    inBin.presentationTime     = presentationTime;
+
+    if(curBuffer == NULL)
+        curBuffer = new unsigned char[QCELP_MAX_FRAME_SIZE];
+    fInputBuffer = curBuffer;
+
+    if(binNumber >= fIncomingBinMax) {
+        fIncomingBinMax = binNumber + 1;
+    }
+}
+
+Boolean QCELPDeinterleavingBuffer ::retrieveFrame(unsigned char *to, unsigned maxSize, unsigned &resultFrameSize, unsigned &resultNumTruncatedBytes,
+                                                  struct timeval &resultPresentationTime) {
+    if(fNextOutgoingBin >= fOutgoingBinMax)
+        return False;  // none left
+
+    FrameDescriptor &outBin = fFrames[fNextOutgoingBin][fIncomingBankId ^ 1];
+    unsigned char *  fromPtr;
+    unsigned char    fromSize = outBin.frameSize;
+    outBin.frameSize          = 0;  // for the next time this bin is used
+
+    // Check whether this frame is missing; if so, return an 'erasure' frame:
+    unsigned char erasure = 14;
+    if(fromSize == 0) {
+        fromPtr  = &erasure;
+        fromSize = 1;
+
+        // Compute this erasure frame's presentation time via extrapolation:
+        resultPresentationTime = fLastRetrievedPresentationTime;
+        resultPresentationTime.tv_usec += uSecsPerFrame;
+        if(resultPresentationTime.tv_usec >= 1000000) {
+            ++resultPresentationTime.tv_sec;
+            resultPresentationTime.tv_usec -= 1000000;
+        }
+    }
+    else {
+        // Normal case - a frame exists:
+        fromPtr                = outBin.frameData;
+        resultPresentationTime = outBin.presentationTime;
+    }
+
+    fLastRetrievedPresentationTime = resultPresentationTime;
+
+    if(fromSize > maxSize) {
+        resultNumTruncatedBytes = fromSize - maxSize;
+        resultFrameSize         = maxSize;
+    }
+    else {
+        resultNumTruncatedBytes = 0;
+        resultFrameSize         = fromSize;
+    }
+    memmove(to, fromPtr, resultFrameSize);
+
+    ++fNextOutgoingBin;
+    return True;
+}
+
+QCELPDeinterleavingBuffer::FrameDescriptor::FrameDescriptor() : frameSize(0), frameData(NULL) {}
+
+QCELPDeinterleavingBuffer::FrameDescriptor::~FrameDescriptor() {
+    delete[] frameData;
+}
diff --git a/3rdparty/live555/src/liveMedia/QuickTimeFileSink.cpp b/3rdparty/live555/src/liveMedia/QuickTimeFileSink.cpp
new file mode 100644
index 00000000..ff985adc
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/QuickTimeFileSink.cpp
@@ -0,0 +1,2330 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A sink that generates a QuickTime file from a composite media session
+// Implementation
+
+#include "QuickTimeFileSink.hh"
+#include "QuickTimeGenericRTPSource.hh"
+#include "GroupsockHelper.hh"
+#include "InputFile.hh"
+#include "OutputFile.hh"
+#include "H263plusVideoRTPSource.hh"   // for the special header
+#include "MPEG4GenericRTPSource.hh"    //for "samplingFrequencyFromAudioSpecificConfig()"
+#include "MPEG4LATMAudioRTPSource.hh"  // for "parseGeneralConfigStr()"
+#include "Base64.hh"
+
+#include <ctype.h>
+
+#define fourChar(x, y, z, w) (((x) << 24) | ((y) << 16) | ((z) << 8) | (w))
+
+#define H264_IDR_FRAME 0x65  // bit 8 == 0, bits 7-6 (ref) == 3, bits 5-0 (type) == 5
+
+////////// SubsessionIOState, ChunkDescriptor ///////////
+// A structure used to represent the I/O state of each input 'subsession':
+
+class ChunkDescriptor {
+public:
+    ChunkDescriptor(int64_t offsetInFile, unsigned size, unsigned frameSize, unsigned frameDuration, struct timeval presentationTime);
+
+    ChunkDescriptor *extendChunk(int64_t newOffsetInFile, unsigned newSize, unsigned newFrameSize, unsigned newFrameDuration,
+                                 struct timeval newPresentationTime);
+    // this may end up allocating a new chunk instead
+public:
+    ChunkDescriptor *fNextChunk;
+    int64_t          fOffsetInFile;
+    unsigned         fNumFrames;
+    unsigned         fFrameSize;
+    unsigned         fFrameDuration;
+    struct timeval   fPresentationTime;  // of the start of the data
+};
+
+class SubsessionBuffer {
+public:
+    SubsessionBuffer(unsigned bufferSize) : fBufferSize(bufferSize) {
+        reset();
+        fData = new unsigned char[bufferSize];
+    }
+    virtual ~SubsessionBuffer() {
+        delete[] fData;
+    }
+    void reset() {
+        fBytesInUse = 0;
+    }
+    void addBytes(unsigned numBytes) {
+        fBytesInUse += numBytes;
+    }
+
+    unsigned char *dataStart() {
+        return &fData[0];
+    }
+    unsigned char *dataEnd() {
+        return &fData[fBytesInUse];
+    }
+    unsigned bytesInUse() const {
+        return fBytesInUse;
+    }
+    unsigned bytesAvailable() const {
+        return fBufferSize - fBytesInUse;
+    }
+
+    void setPresentationTime(struct timeval const &presentationTime) {
+        fPresentationTime = presentationTime;
+    }
+    struct timeval const &presentationTime() const {
+        return fPresentationTime;
+    }
+
+private:
+    unsigned       fBufferSize;
+    struct timeval fPresentationTime;
+    unsigned char *fData;
+    unsigned       fBytesInUse;
+};
+
+class SyncFrame {
+public:
+    SyncFrame(unsigned frameNum);
+
+public:
+    class SyncFrame *nextSyncFrame;
+    unsigned         sfFrameNum;
+};
+
+// A 64-bit counter, used below:
+class Count64 {
+public:
+    Count64() : hi(0), lo(0) {}
+
+    void operator+=(unsigned arg);
+
+    u_int32_t hi, lo;
+};
+
+class SubsessionIOState {
+public:
+    SubsessionIOState(QuickTimeFileSink &sink, MediaSubsession &subsession);
+    virtual ~SubsessionIOState();
+
+    Boolean setQTstate();
+    void    setFinalQTstate();
+
+    void afterGettingFrame(unsigned packetDataSize, struct timeval presentationTime);
+    void onSourceClosure();
+
+    Boolean syncOK(struct timeval presentationTime);
+    // returns true iff data is usable despite a sync check
+
+    static void setHintTrack(SubsessionIOState *hintedTrack, SubsessionIOState *hintTrack);
+    Boolean     isHintTrack() const {
+        return fTrackHintedByUs != NULL;
+    }
+    Boolean hasHintTrack() const {
+        return fHintTrackForUs != NULL;
+    }
+
+    UsageEnvironment &envir() const {
+        return fOurSink.envir();
+    }
+
+public:
+    static unsigned    fCurrentTrackNumber;
+    unsigned           fTrackID;
+    SubsessionIOState *fHintTrackForUs;
+    SubsessionIOState *fTrackHintedByUs;
+
+    SubsessionBuffer * fBuffer, *fPrevBuffer;
+    QuickTimeFileSink &fOurSink;
+    MediaSubsession &  fOurSubsession;
+
+    unsigned short fLastPacketRTPSeqNum;
+    Boolean        fOurSourceIsActive;
+
+    Boolean        fHaveBeenSynced;  // used in synchronizing with other streams
+    struct timeval fSyncTime;
+
+    Boolean     fQTEnableTrack;
+    unsigned    fQTcomponentSubtype;
+    char const *fQTcomponentName;
+    typedef unsigned (QuickTimeFileSink::*atomCreationFunc)();
+    atomCreationFunc fQTMediaInformationAtomCreator;
+    atomCreationFunc fQTMediaDataAtomCreator;
+    char const *     fQTAudioDataType;
+    unsigned short   fQTSoundSampleVersion;
+    unsigned         fQTTimeScale;
+    unsigned         fQTTimeUnitsPerSample;
+    unsigned         fQTBytesPerFrame;
+    unsigned         fQTSamplesPerFrame;
+    // These next fields are derived from the ones above,
+    // plus the information from each chunk:
+    unsigned fQTTotNumSamples;
+    unsigned fQTDurationM;  // in media time units
+    unsigned fQTDurationT;  // in track time units
+    int64_t  fTKHD_durationPosn;
+    // position of the duration in the output 'tkhd' atom
+    unsigned fQTInitialOffsetDuration;
+    // if there's a pause at the beginning
+
+    ChunkDescriptor *fHeadChunk, *fTailChunk;
+    unsigned         fNumChunks;
+    SyncFrame *      fHeadSyncFrame, *fTailSyncFrame;
+
+    // Counters to be used in the hint track's 'udta'/'hinf' atom;
+    struct hinf {
+        Count64 trpy;
+        Count64 nump;
+        Count64 tpyl;
+        // Is 'maxr' needed? Computing this would be a PITA. #####
+        Count64 dmed;
+        Count64 dimm;
+        // 'drep' is always 0
+        // 'tmin' and 'tmax' are always 0
+        unsigned pmax;
+        unsigned dmax;
+    } fHINF;
+
+private:
+    void useFrame(SubsessionBuffer &buffer);
+    void useFrameForHinting(unsigned frameSize, struct timeval presentationTime, unsigned startSampleNumber);
+
+    // used by the above two routines:
+    unsigned useFrame1(unsigned sourceDataSize, struct timeval presentationTime, unsigned frameDuration, int64_t destFileOffset);
+    // returns the number of samples in this data
+
+private:
+    // A structure used for temporarily storing frame state:
+    struct {
+        unsigned       frameSize;
+        struct timeval presentationTime;
+        int64_t        destFileOffset;  // used for non-hint tracks only
+
+        // The remaining fields are used for hint tracks only:
+        unsigned       startSampleNumber;
+        unsigned short seqNum;
+        unsigned       rtpHeader;
+        unsigned char  numSpecialHeaders;                               // used when our RTP source has special headers
+        unsigned       specialHeaderBytesLength;                        // ditto
+        unsigned char  specialHeaderBytes[SPECIAL_HEADER_BUFFER_SIZE];  // ditto
+        unsigned       packetSizes[256];
+    } fPrevFrameState;
+};
+
+////////// QuickTimeFileSink implementation //////////
+
+QuickTimeFileSink::QuickTimeFileSink(UsageEnvironment &env, MediaSession &inputSession, char const *outputFileName, unsigned bufferSize,
+                                     unsigned short movieWidth, unsigned short movieHeight, unsigned movieFPS, Boolean packetLossCompensate,
+                                     Boolean syncStreams, Boolean generateHintTracks, Boolean generateMP4Format)
+    : Medium(env),
+      fInputSession(inputSession),
+      fBufferSize(bufferSize),
+      fPacketLossCompensate(packetLossCompensate),
+      fSyncStreams(syncStreams),
+      fGenerateMP4Format(generateMP4Format),
+      fAreCurrentlyBeingPlayed(False),
+      fLargestRTPtimestampFrequency(0),
+      fNumSubsessions(0),
+      fNumSyncedSubsessions(0),
+      fHaveCompletedOutputFile(False),
+      fMovieWidth(movieWidth),
+      fMovieHeight(movieHeight),
+      fMovieFPS(movieFPS),
+      fMaxTrackDurationM(0) {
+    fOutFid = OpenOutputFile(env, outputFileName);
+    if(fOutFid == NULL)
+        return;
+
+    fNewestSyncTime.tv_sec = fNewestSyncTime.tv_usec = 0;
+    fFirstDataTime.tv_sec = fFirstDataTime.tv_usec = (unsigned)(~0);
+
+    // Set up I/O state for each input subsession:
+    MediaSubsessionIterator iter(fInputSession);
+    MediaSubsession *       subsession;
+    while((subsession = iter.next()) != NULL) {
+        // Ignore subsessions without a data source:
+        FramedSource *subsessionSource = subsession->readSource();
+        if(subsessionSource == NULL)
+            continue;
+
+        // If "subsession's" SDP description specified screen dimension
+        // or frame rate parameters, then use these.  (Note that this must
+        // be done before the call to "setQTState()" below.)
+        if(subsession->videoWidth() != 0) {
+            fMovieWidth = subsession->videoWidth();
+        }
+        if(subsession->videoHeight() != 0) {
+            fMovieHeight = subsession->videoHeight();
+        }
+        if(subsession->videoFPS() != 0) {
+            fMovieFPS = subsession->videoFPS();
+        }
+
+        SubsessionIOState *ioState = new SubsessionIOState(*this, *subsession);
+        if(ioState == NULL || !ioState->setQTstate()) {
+            // We're not able to output a QuickTime track for this subsession
+            delete ioState;
+            ioState = NULL;
+            continue;
+        }
+        subsession->miscPtr = (void *)ioState;
+
+        if(generateHintTracks) {
+            // Also create a hint track for this track:
+            SubsessionIOState *hintTrack = new SubsessionIOState(*this, *subsession);
+            SubsessionIOState::setHintTrack(ioState, hintTrack);
+            if(!hintTrack->setQTstate()) {
+                delete hintTrack;
+                SubsessionIOState::setHintTrack(ioState, NULL);
+            }
+        }
+
+        // Also set a 'BYE' handler for this subsession's RTCP instance:
+        if(subsession->rtcpInstance() != NULL) {
+            subsession->rtcpInstance()->setByeHandler(onRTCPBye, ioState);
+        }
+
+        unsigned rtpTimestampFrequency = subsession->rtpTimestampFrequency();
+        if(rtpTimestampFrequency > fLargestRTPtimestampFrequency) {
+            fLargestRTPtimestampFrequency = rtpTimestampFrequency;
+        }
+
+        ++fNumSubsessions;
+    }
+
+    // Use the current time as the file's creation and modification
+    // time.  Use Apple's time format: seconds (UTC) since January 1, 1904
+
+    gettimeofday(&fStartTime, NULL);
+    fAppleCreationTime = fStartTime.tv_sec - 0x83da4f80;
+
+    // Begin by writing a "mdat" atom at the start of the file.
+    // (Later, when we've finished copying data to the file, we'll come
+    // back and fill in its size.)
+    fMDATposition = TellFile64(fOutFid);
+    addAtomHeader64("mdat");
+    // add 64Bit offset
+    fMDATposition += 8;
+}
+
+QuickTimeFileSink::~QuickTimeFileSink() {
+    completeOutputFile();
+
+    // Then, stop streaming and delete each active "SubsessionIOState":
+    MediaSubsessionIterator iter(fInputSession);
+    MediaSubsession *       subsession;
+    while((subsession = iter.next()) != NULL) {
+        if(subsession->readSource() != NULL)
+            subsession->readSource()->stopGettingFrames();
+
+        SubsessionIOState *ioState = (SubsessionIOState *)(subsession->miscPtr);
+        if(ioState == NULL)
+            continue;
+
+        delete ioState->fHintTrackForUs;  // if any
+        delete ioState;
+    }
+
+    // Finally, close our output file:
+    CloseOutputFile(fOutFid);
+}
+
+QuickTimeFileSink *QuickTimeFileSink::createNew(UsageEnvironment &env, MediaSession &inputSession, char const *outputFileName, unsigned bufferSize,
+                                                unsigned short movieWidth, unsigned short movieHeight, unsigned movieFPS, Boolean packetLossCompensate,
+                                                Boolean syncStreams, Boolean generateHintTracks, Boolean generateMP4Format) {
+    QuickTimeFileSink *newSink = new QuickTimeFileSink(env, inputSession, outputFileName, bufferSize, movieWidth, movieHeight, movieFPS, packetLossCompensate,
+                                                       syncStreams, generateHintTracks, generateMP4Format);
+    if(newSink == NULL || newSink->fOutFid == NULL) {
+        Medium::close(newSink);
+        return NULL;
+    }
+
+    return newSink;
+}
+
+void QuickTimeFileSink ::noteRecordedFrame(MediaSubsession & /*inputSubsession*/, unsigned /*packetDataSize*/, struct timeval const & /*presentationTime*/) {
+    // Default implementation: Do nothing
+}
+
+Boolean QuickTimeFileSink::startPlaying(afterPlayingFunc *afterFunc, void *afterClientData) {
+    // Make sure we're not already being played:
+    if(fAreCurrentlyBeingPlayed) {
+        envir().setResultMsg("This sink has already been played");
+        return False;
+    }
+
+    fAreCurrentlyBeingPlayed = True;
+    fAfterFunc               = afterFunc;
+    fAfterClientData         = afterClientData;
+
+    return continuePlaying();
+}
+
+Boolean QuickTimeFileSink::continuePlaying() {
+    // Run through each of our input session's 'subsessions',
+    // asking for a frame from each one:
+    Boolean                 haveActiveSubsessions = False;
+    MediaSubsessionIterator iter(fInputSession);
+    MediaSubsession *       subsession;
+    while((subsession = iter.next()) != NULL) {
+        FramedSource *subsessionSource = subsession->readSource();
+        if(subsessionSource == NULL)
+            continue;
+
+        if(subsessionSource->isCurrentlyAwaitingData())
+            continue;
+
+        SubsessionIOState *ioState = (SubsessionIOState *)(subsession->miscPtr);
+        if(ioState == NULL)
+            continue;
+
+        haveActiveSubsessions = True;
+        unsigned char *toPtr  = ioState->fBuffer->dataEnd();
+        unsigned       toSize = ioState->fBuffer->bytesAvailable();
+        subsessionSource->getNextFrame(toPtr, toSize, afterGettingFrame, ioState, onSourceClosure, ioState);
+    }
+    if(!haveActiveSubsessions) {
+        envir().setResultMsg("No subsessions are currently active");
+        return False;
+    }
+
+    return True;
+}
+
+void QuickTimeFileSink ::afterGettingFrame(void *clientData, unsigned packetDataSize, unsigned numTruncatedBytes, struct timeval presentationTime,
+                                           unsigned /*durationInMicroseconds*/) {
+    SubsessionIOState *ioState = (SubsessionIOState *)clientData;
+    if(!ioState->syncOK(presentationTime)) {
+        // Ignore this data:
+        ioState->fOurSink.continuePlaying();
+        return;
+    }
+    if(numTruncatedBytes > 0) {
+        ioState->envir() << "QuickTimeFileSink::afterGettingFrame(): The input frame data was too large for our buffer.  " << numTruncatedBytes
+                         << " bytes of trailing data was dropped!  Correct this by increasing the \"bufferSize\" parameter in the \"createNew()\" call.\n";
+    }
+    ioState->afterGettingFrame(packetDataSize, presentationTime);
+}
+
+void QuickTimeFileSink::onSourceClosure(void *clientData) {
+    SubsessionIOState *ioState = (SubsessionIOState *)clientData;
+    ioState->onSourceClosure();
+}
+
+void QuickTimeFileSink::onSourceClosure1() {
+    // Check whether *all* of the subsession sources have closed.
+    // If not, do nothing for now:
+    MediaSubsessionIterator iter(fInputSession);
+    MediaSubsession *       subsession;
+    while((subsession = iter.next()) != NULL) {
+        SubsessionIOState *ioState = (SubsessionIOState *)(subsession->miscPtr);
+        if(ioState == NULL)
+            continue;
+
+        if(ioState->fOurSourceIsActive)
+            return;  // this source hasn't closed
+    }
+
+    completeOutputFile();
+
+    // Call our specified 'after' function:
+    if(fAfterFunc != NULL) {
+        (*fAfterFunc)(fAfterClientData);
+    }
+}
+
+void QuickTimeFileSink::onRTCPBye(void *clientData) {
+    SubsessionIOState *ioState = (SubsessionIOState *)clientData;
+
+    struct timeval timeNow;
+    gettimeofday(&timeNow, NULL);
+    unsigned secsDiff = timeNow.tv_sec - ioState->fOurSink.fStartTime.tv_sec;
+
+    MediaSubsession &subsession = ioState->fOurSubsession;
+    ioState->envir() << "Received RTCP \"BYE\" on \"" << subsession.mediumName() << "/" << subsession.codecName() << "\" subsession (after " << secsDiff
+                     << " seconds)\n";
+
+    // Handle the reception of a RTCP "BYE" as if the source had closed:
+    ioState->onSourceClosure();
+}
+
+static Boolean timevalGE(struct timeval const &tv1, struct timeval const &tv2) {
+    return (unsigned)tv1.tv_sec > (unsigned)tv2.tv_sec || (tv1.tv_sec == tv2.tv_sec && (unsigned)tv1.tv_usec >= (unsigned)tv2.tv_usec);
+}
+
+void QuickTimeFileSink::completeOutputFile() {
+    if(fHaveCompletedOutputFile || fOutFid == NULL)
+        return;
+
+    // Begin by filling in the initial "mdat" atom with the current
+    // file size:
+    int64_t curFileSize = TellFile64(fOutFid);
+    setWord64(fMDATposition, (u_int64_t)curFileSize);
+
+    // Then, note the time of the first received data:
+    MediaSubsessionIterator iter(fInputSession);
+    MediaSubsession *       subsession;
+    while((subsession = iter.next()) != NULL) {
+        SubsessionIOState *ioState = (SubsessionIOState *)(subsession->miscPtr);
+        if(ioState == NULL)
+            continue;
+
+        ChunkDescriptor *const headChunk = ioState->fHeadChunk;
+        if(headChunk != NULL && timevalGE(fFirstDataTime, headChunk->fPresentationTime)) {
+            fFirstDataTime = headChunk->fPresentationTime;
+        }
+    }
+
+    // Then, update the QuickTime-specific state for each active track:
+    iter.reset();
+    while((subsession = iter.next()) != NULL) {
+        SubsessionIOState *ioState = (SubsessionIOState *)(subsession->miscPtr);
+        if(ioState == NULL)
+            continue;
+
+        ioState->setFinalQTstate();
+        // Do the same for a hint track (if any):
+        if(ioState->hasHintTrack()) {
+            ioState->fHintTrackForUs->setFinalQTstate();
+        }
+    }
+
+    if(fGenerateMP4Format) {
+        // Begin with a "ftyp" atom:
+        addAtom_ftyp();
+    }
+
+    // Then, add a "moov" atom for the file metadata:
+    addAtom_moov();
+
+    // We're done:
+    fHaveCompletedOutputFile = True;
+}
+
+////////// SubsessionIOState, ChunkDescriptor implementation ///////////
+
+unsigned SubsessionIOState::fCurrentTrackNumber = 0;
+
+SubsessionIOState::SubsessionIOState(QuickTimeFileSink &sink, MediaSubsession &subsession)
+    : fHintTrackForUs(NULL),
+      fTrackHintedByUs(NULL),
+      fOurSink(sink),
+      fOurSubsession(subsession),
+      fLastPacketRTPSeqNum(0),
+      fHaveBeenSynced(False),
+      fQTTotNumSamples(0),
+      fHeadChunk(NULL),
+      fTailChunk(NULL),
+      fNumChunks(0),
+      fHeadSyncFrame(NULL),
+      fTailSyncFrame(NULL) {
+    fTrackID = ++fCurrentTrackNumber;
+
+    fBuffer     = new SubsessionBuffer(fOurSink.fBufferSize);
+    fPrevBuffer = sink.fPacketLossCompensate ? new SubsessionBuffer(fOurSink.fBufferSize) : NULL;
+
+    FramedSource *subsessionSource = subsession.readSource();
+    fOurSourceIsActive             = subsessionSource != NULL;
+
+    fPrevFrameState.presentationTime.tv_sec  = 0;
+    fPrevFrameState.presentationTime.tv_usec = 0;
+    fPrevFrameState.seqNum                   = 0;
+}
+
+SubsessionIOState::~SubsessionIOState() {
+    delete fBuffer;
+    delete fPrevBuffer;
+
+    // Delete the list of chunk descriptors:
+    ChunkDescriptor *chunk = fHeadChunk;
+    while(chunk != NULL) {
+        ChunkDescriptor *next = chunk->fNextChunk;
+        delete chunk;
+        chunk = next;
+    }
+
+    // Delete the list of sync frames:
+    SyncFrame *syncFrame = fHeadSyncFrame;
+    while(syncFrame != NULL) {
+        SyncFrame *next = syncFrame->nextSyncFrame;
+        delete syncFrame;
+        syncFrame = next;
+    }
+}
+
+Boolean SubsessionIOState::setQTstate() {
+    char const *noCodecWarning1 = "Warning: We don't implement a QuickTime ";
+    char const *noCodecWarning2 = " Media Data Type for the \"";
+    char const *noCodecWarning3 = "\" track, so we'll insert a dummy \"????\" Media Data Atom instead.  A separate, codec-specific editing pass will be needed "
+                                  "before this track can be played.\n";
+
+    do {
+        fQTEnableTrack        = True;                                    // enable this track in the movie by default
+        fQTTimeScale          = fOurSubsession.rtpTimestampFrequency();  // by default
+        fQTTimeUnitsPerSample = 1;                                       // by default
+        fQTBytesPerFrame      = 0;
+        // by default - indicates that the whole packet data is a frame
+        fQTSamplesPerFrame = 1;  // by default
+
+        // Make sure our subsession's medium is one that we know how to
+        // represent in a QuickTime file:
+        if(isHintTrack()) {
+            // Hint tracks are treated specially
+            fQTEnableTrack                 = False;  // hint tracks are marked as inactive
+            fQTcomponentSubtype            = fourChar('h', 'i', 'n', 't');
+            fQTcomponentName               = "hint media handler";
+            fQTMediaInformationAtomCreator = &QuickTimeFileSink::addAtom_gmhd;
+            fQTMediaDataAtomCreator        = &QuickTimeFileSink::addAtom_rtp;
+        }
+        else if(strcmp(fOurSubsession.mediumName(), "audio") == 0) {
+            fQTcomponentSubtype            = fourChar('s', 'o', 'u', 'n');
+            fQTcomponentName               = "Apple Sound Media Handler";
+            fQTMediaInformationAtomCreator = &QuickTimeFileSink::addAtom_smhd;
+            fQTMediaDataAtomCreator        = &QuickTimeFileSink::addAtom_soundMediaGeneral;  // by default
+            fQTSoundSampleVersion          = 0;                                              // by default
+
+            // Make sure that our subsession's codec is one that we can handle:
+            if(strcmp(fOurSubsession.codecName(), "X-QT") == 0 || strcmp(fOurSubsession.codecName(), "X-QUICKTIME") == 0) {
+                fQTMediaDataAtomCreator = &QuickTimeFileSink::addAtom_genericMedia;
+            }
+            else if(strcmp(fOurSubsession.codecName(), "PCMU") == 0) {
+                fQTAudioDataType = "ulaw";
+                fQTBytesPerFrame = 1;
+            }
+            else if(strcmp(fOurSubsession.codecName(), "GSM") == 0) {
+                fQTAudioDataType   = "agsm";
+                fQTBytesPerFrame   = 33;
+                fQTSamplesPerFrame = 160;
+            }
+            else if(strcmp(fOurSubsession.codecName(), "PCMA") == 0) {
+                fQTAudioDataType = "alaw";
+                fQTBytesPerFrame = 1;
+            }
+            else if(strcmp(fOurSubsession.codecName(), "QCELP") == 0) {
+                fQTMediaDataAtomCreator = &QuickTimeFileSink::addAtom_Qclp;
+                fQTSamplesPerFrame      = 160;
+            }
+            else if(strcmp(fOurSubsession.codecName(), "MPEG4-GENERIC") == 0 || strcmp(fOurSubsession.codecName(), "MP4A-LATM") == 0) {
+                fQTMediaDataAtomCreator = &QuickTimeFileSink::addAtom_mp4a;
+                fQTTimeUnitsPerSample   = 1024;  // QT considers each frame to be a 'sample'
+                // The time scale (frequency) comes from the 'config' information.
+                // It might be different from the RTP timestamp frequency (e.g., aacPlus).
+                unsigned frequencyFromConfig = samplingFrequencyFromAudioSpecificConfig(fOurSubsession.fmtp_config());
+                if(frequencyFromConfig != 0)
+                    fQTTimeScale = frequencyFromConfig;
+            }
+            else {
+                envir() << noCodecWarning1 << "Audio" << noCodecWarning2 << fOurSubsession.codecName() << noCodecWarning3;
+                fQTMediaDataAtomCreator = &QuickTimeFileSink::addAtom_dummy;
+                fQTEnableTrack          = False;  // disable this track in the movie
+            }
+        }
+        else if(strcmp(fOurSubsession.mediumName(), "video") == 0) {
+            fQTcomponentSubtype            = fourChar('v', 'i', 'd', 'e');
+            fQTcomponentName               = "Apple Video Media Handler";
+            fQTMediaInformationAtomCreator = &QuickTimeFileSink::addAtom_vmhd;
+
+            // Make sure that our subsession's codec is one that we can handle:
+            if(strcmp(fOurSubsession.codecName(), "X-QT") == 0 || strcmp(fOurSubsession.codecName(), "X-QUICKTIME") == 0) {
+                fQTMediaDataAtomCreator = &QuickTimeFileSink::addAtom_genericMedia;
+            }
+            else if(strcmp(fOurSubsession.codecName(), "H263-1998") == 0 || strcmp(fOurSubsession.codecName(), "H263-2000") == 0) {
+                fQTMediaDataAtomCreator = &QuickTimeFileSink::addAtom_h263;
+                fQTTimeScale            = 600;
+                fQTTimeUnitsPerSample   = fQTTimeScale / fOurSink.fMovieFPS;
+            }
+            else if(strcmp(fOurSubsession.codecName(), "H264") == 0) {
+                fQTMediaDataAtomCreator = &QuickTimeFileSink::addAtom_avc1;
+                fQTTimeScale            = 600;
+                fQTTimeUnitsPerSample   = fQTTimeScale / fOurSink.fMovieFPS;
+            }
+            else if(strcmp(fOurSubsession.codecName(), "MP4V-ES") == 0) {
+                fQTMediaDataAtomCreator = &QuickTimeFileSink::addAtom_mp4v;
+                fQTTimeScale            = 600;
+                fQTTimeUnitsPerSample   = fQTTimeScale / fOurSink.fMovieFPS;
+            }
+            else {
+                envir() << noCodecWarning1 << "Video" << noCodecWarning2 << fOurSubsession.codecName() << noCodecWarning3;
+                fQTMediaDataAtomCreator = &QuickTimeFileSink::addAtom_dummy;
+                fQTEnableTrack          = False;  // disable this track in the movie
+            }
+        }
+        else {
+            envir() << "Warning: We don't implement a QuickTime Media Handler for media type \"" << fOurSubsession.mediumName() << "\"";
+            break;
+        }
+
+#ifdef QT_SUPPORT_PARTIALLY_ONLY
+        envir()
+            << "Warning: We don't have sufficient codec-specific information (e.g., sample sizes) to fully generate the \"" << fOurSubsession.mediumName()
+            << "/" << fOurSubsession.codecName()
+            << "\" track, so we'll disable this track in the movie.  A separate, codec-specific editing pass will be needed before this track can be played\n";
+        fQTEnableTrack = False;  // disable this track in the movie
+#endif
+
+        return True;
+    } while(0);
+
+    envir() << ", so a track for the \"" << fOurSubsession.mediumName() << "/" << fOurSubsession.codecName()
+            << "\" subsession will not be included in the output QuickTime file\n";
+    return False;
+}
+
+void SubsessionIOState::setFinalQTstate() {
+    // Compute derived parameters, by running through the list of chunks:
+    fQTDurationT = 0;
+
+    ChunkDescriptor *chunk = fHeadChunk;
+    while(chunk != NULL) {
+        unsigned const numFrames = chunk->fNumFrames;
+        unsigned const dur       = numFrames * chunk->fFrameDuration;
+        fQTDurationT += dur;
+
+        chunk = chunk->fNextChunk;
+    }
+
+    // Convert this duration from track to movie time scale:
+    double scaleFactor = fOurSink.movieTimeScale() / (double)fQTTimeScale;
+    fQTDurationM       = (unsigned)(fQTDurationT * scaleFactor);
+
+    if(fQTDurationM > fOurSink.fMaxTrackDurationM) {
+        fOurSink.fMaxTrackDurationM = fQTDurationM;
+    }
+}
+
+void SubsessionIOState::afterGettingFrame(unsigned packetDataSize, struct timeval presentationTime) {
+    // Begin by checking whether there was a gap in the RTP stream.
+    // If so, try to compensate for this (if desired):
+    if(fOurSubsession.rtpSource() != NULL) {  // we have a RTP stream
+        unsigned short rtpSeqNum = fOurSubsession.rtpSource()->curPacketRTPSeqNum();
+        if(fOurSink.fPacketLossCompensate && fPrevBuffer->bytesInUse() > 0) {
+            short seqNumGap = rtpSeqNum - fLastPacketRTPSeqNum;
+            for(short i = 1; i < seqNumGap; ++i) {
+                // Insert a copy of the previous frame, to compensate for the loss:
+                useFrame(*fPrevBuffer);
+            }
+        }
+        fLastPacketRTPSeqNum = rtpSeqNum;
+    }
+
+    // Now, continue working with the frame that we just got
+    fOurSink.noteRecordedFrame(fOurSubsession, packetDataSize, presentationTime);
+
+    if(fBuffer->bytesInUse() == 0) {
+        fBuffer->setPresentationTime(presentationTime);
+    }
+    fBuffer->addBytes(packetDataSize);
+
+    // If our RTP source is a "QuickTimeGenericRTPSource", then
+    // use its 'qtState' to set some parameters that we need:
+    if(fOurSubsession.rtpSource() != NULL  // we have a RTP stream
+       && fQTMediaDataAtomCreator == &QuickTimeFileSink::addAtom_genericMedia) {
+        QuickTimeGenericRTPSource *         rtpSource = (QuickTimeGenericRTPSource *)fOurSubsession.rtpSource();
+        QuickTimeGenericRTPSource::QTState &qtState   = rtpSource->qtState;
+        fQTTimeScale                                  = qtState.timescale;
+        if(qtState.width != 0) {
+            fOurSink.fMovieWidth = qtState.width;
+        }
+        if(qtState.height != 0) {
+            fOurSink.fMovieHeight = qtState.height;
+        }
+
+        // Also, if the media type in the "sdAtom" is one that we recognize
+        // to have a special parameters, then fix this here:
+        if(qtState.sdAtomSize >= 8) {
+            char const *atom      = qtState.sdAtom;
+            unsigned    mediaType = fourChar(atom[4], atom[5], atom[6], atom[7]);
+            switch(mediaType) {
+            case fourChar('a', 'g', 's', 'm'): {
+                fQTBytesPerFrame   = 33;
+                fQTSamplesPerFrame = 160;
+                break;
+            }
+            case fourChar('Q', 'c', 'l', 'p'): {
+                fQTBytesPerFrame   = 35;
+                fQTSamplesPerFrame = 160;
+                break;
+            }
+            case fourChar('H', 'c', 'l', 'p'): {
+                fQTBytesPerFrame   = 17;
+                fQTSamplesPerFrame = 160;
+                break;
+            }
+            case fourChar('h', '2', '6', '3'): {
+                fQTTimeUnitsPerSample = fQTTimeScale / fOurSink.fMovieFPS;
+                break;
+            }
+            }
+        }
+    }
+    else if(fQTMediaDataAtomCreator == &QuickTimeFileSink::addAtom_Qclp) {
+        // For QCELP data, make a note of the frame size (even though it's the
+        // same as the packet data size), because it varies depending on the
+        // 'rate' of the stream, and this size gets used later when setting up
+        // the 'Qclp' QuickTime atom:
+        fQTBytesPerFrame = packetDataSize;
+    }
+
+    useFrame(*fBuffer);
+    if(fOurSink.fPacketLossCompensate) {
+        // Save this frame, in case we need it for recovery:
+        SubsessionBuffer *tmp = fPrevBuffer;  // assert: != NULL
+        fPrevBuffer           = fBuffer;
+        fBuffer               = tmp;
+    }
+    fBuffer->reset();  // for the next input
+
+    // Now, try getting more frames:
+    fOurSink.continuePlaying();
+}
+
+void SubsessionIOState::useFrame(SubsessionBuffer &buffer) {
+    unsigned char *const  frameSource              = buffer.dataStart();
+    unsigned const        frameSize                = buffer.bytesInUse();
+    struct timeval const &presentationTime         = buffer.presentationTime();
+    int64_t const         destFileOffset           = TellFile64(fOurSink.fOutFid);
+    unsigned              sampleNumberOfFrameStart = fQTTotNumSamples + 1;
+    Boolean               avcHack                  = fQTMediaDataAtomCreator == &QuickTimeFileSink::addAtom_avc1;
+
+    // If we're not syncing streams, or this subsession is not video, then
+    // just give this frame a fixed duration:
+    if(!fOurSink.fSyncStreams || fQTcomponentSubtype != fourChar('v', 'i', 'd', 'e')) {
+        unsigned const frameDuration  = fQTTimeUnitsPerSample * fQTSamplesPerFrame;
+        unsigned       frameSizeToUse = frameSize;
+        if(avcHack)
+            frameSizeToUse += 4;  // H.264/AVC gets the frame size prefix
+
+        fQTTotNumSamples += useFrame1(frameSizeToUse, presentationTime, frameDuration, destFileOffset);
+    }
+    else {
+        // For synced video streams, we use the difference between successive
+        // frames' presentation times as the 'frame duration'.  So, record
+        // information about the *previous* frame:
+        struct timeval const &ppt = fPrevFrameState.presentationTime;  // abbrev
+        if(ppt.tv_sec != 0 || ppt.tv_usec != 0) {
+            // There has been a previous frame.
+            double duration = (presentationTime.tv_sec - ppt.tv_sec) + (presentationTime.tv_usec - ppt.tv_usec) / 1000000.0;
+            if(duration < 0.0)
+                duration = 0.0;
+            unsigned frameDuration  = (unsigned)((2 * duration * fQTTimeScale + 1) / 2);  // round
+            unsigned frameSizeToUse = fPrevFrameState.frameSize;
+            if(avcHack)
+                frameSizeToUse += 4;  // H.264/AVC gets the frame size prefix
+
+            unsigned numSamples = useFrame1(frameSizeToUse, ppt, frameDuration, fPrevFrameState.destFileOffset);
+            fQTTotNumSamples += numSamples;
+            sampleNumberOfFrameStart = fQTTotNumSamples + 1;
+        }
+
+        if(avcHack && (*frameSource == H264_IDR_FRAME)) {
+            SyncFrame *newSyncFrame = new SyncFrame(fQTTotNumSamples + 1);
+            if(fTailSyncFrame == NULL) {
+                fHeadSyncFrame = newSyncFrame;
+            }
+            else {
+                fTailSyncFrame->nextSyncFrame = newSyncFrame;
+            }
+            fTailSyncFrame = newSyncFrame;
+        }
+
+        // Remember the current frame for next time:
+        fPrevFrameState.frameSize        = frameSize;
+        fPrevFrameState.presentationTime = presentationTime;
+        fPrevFrameState.destFileOffset   = destFileOffset;
+    }
+
+    if(avcHack)
+        fOurSink.addWord(frameSize);
+
+    // Write the data into the file:
+    fwrite(frameSource, 1, frameSize, fOurSink.fOutFid);
+
+    // If we have a hint track, then write to it also (only if we have a RTP stream):
+    if(hasHintTrack() && fOurSubsession.rtpSource() != NULL) {
+        // Because presentation times are used for RTP packet timestamps,
+        // we don't starting writing to the hint track until we've been synced:
+        if(!fHaveBeenSynced) {
+            fHaveBeenSynced = fOurSubsession.rtpSource()->hasBeenSynchronizedUsingRTCP();
+        }
+        if(fHaveBeenSynced) {
+            fHintTrackForUs->useFrameForHinting(frameSize, presentationTime, sampleNumberOfFrameStart);
+        }
+    }
+}
+
+void SubsessionIOState::useFrameForHinting(unsigned frameSize, struct timeval presentationTime, unsigned startSampleNumber) {
+    // At this point, we have a single, combined frame - not individual packets.
+    // For the hint track, we need to split the frame back up into separate packets.
+    // However, for some RTP sources, then we also need to reuse the special
+    // header bytes that were at the start of each of the RTP packets.
+    Boolean hack263            = strcmp(fOurSubsession.codecName(), "H263-1998") == 0;
+    Boolean hackm4a_generic    = strcmp(fOurSubsession.mediumName(), "audio") == 0 && strcmp(fOurSubsession.codecName(), "MPEG4-GENERIC") == 0;
+    Boolean hackm4a_latm       = strcmp(fOurSubsession.mediumName(), "audio") == 0 && strcmp(fOurSubsession.codecName(), "MP4A-LATM") == 0;
+    Boolean hackm4a            = hackm4a_generic || hackm4a_latm;
+    Boolean haveSpecialHeaders = (hack263 || hackm4a_generic);
+
+    // If there has been a previous frame, then output a 'hint sample' for it.
+    // (We use the current frame's presentation time to compute the previous
+    // hint sample's duration.)
+    RTPSource *const      rs  = fOurSubsession.rtpSource();        // abbrev (ASSERT: != NULL)
+    struct timeval const &ppt = fPrevFrameState.presentationTime;  // abbrev
+    if(ppt.tv_sec != 0 || ppt.tv_usec != 0) {
+        double duration = (presentationTime.tv_sec - ppt.tv_sec) + (presentationTime.tv_usec - ppt.tv_usec) / 1000000.0;
+        if(duration < 0.0)
+            duration = 0.0;
+        unsigned msDuration = (unsigned)(duration * 1000);  // milliseconds
+        if(msDuration > fHINF.dmax)
+            fHINF.dmax = msDuration;
+        unsigned hintSampleDuration = (unsigned)((2 * duration * fQTTimeScale + 1) / 2);  // round
+        if(hackm4a) {
+            // Because multiple AAC frames can appear in a RTP packet, the presentation
+            // times of the second and subsequent frames will not be accurate.
+            // So, use the known "hintSampleDuration" instead:
+            hintSampleDuration = fTrackHintedByUs->fQTTimeUnitsPerSample;
+
+            // Also, if the 'time scale' was different from the RTP timestamp frequency,
+            // (as can happen with aacPlus), then we need to scale "hintSampleDuration"
+            // accordingly:
+            if(fTrackHintedByUs->fQTTimeScale != fOurSubsession.rtpTimestampFrequency()) {
+                unsigned const scalingFactor = fOurSubsession.rtpTimestampFrequency() / fTrackHintedByUs->fQTTimeScale;
+                hintSampleDuration *= scalingFactor;
+            }
+        }
+
+        int64_t const hintSampleDestFileOffset = TellFile64(fOurSink.fOutFid);
+
+        unsigned const maxPacketSize               = 1450;
+        unsigned short numPTEntries                = (fPrevFrameState.frameSize + (maxPacketSize - 1)) / maxPacketSize;  // normal case
+        unsigned char *immediateDataPtr            = NULL;
+        unsigned       immediateDataBytesRemaining = 0;
+        if(haveSpecialHeaders) {  // special case
+            numPTEntries                = fPrevFrameState.numSpecialHeaders;
+            immediateDataPtr            = fPrevFrameState.specialHeaderBytes;
+            immediateDataBytesRemaining = fPrevFrameState.specialHeaderBytesLength;
+        }
+        unsigned hintSampleSize = fOurSink.addHalfWord(numPTEntries);  // Entry count
+        hintSampleSize += fOurSink.addHalfWord(0x0000);                // Reserved
+
+        unsigned offsetWithinSample = 0;
+        for(unsigned i = 0; i < numPTEntries; ++i) {
+            // Output a Packet Table entry (representing a single RTP packet):
+            unsigned short numDTEntries = 1;
+            unsigned short seqNum       = fPrevFrameState.seqNum++;
+            // Note: This assumes that the input stream had no packets lost #####
+            unsigned rtpHeader = fPrevFrameState.rtpHeader;
+            if(i + 1 < numPTEntries) {
+                // This is not the last RTP packet, so clear the marker bit:
+                rtpHeader &= ~(1 << 23);
+            }
+            unsigned dataFrameSize = (i + 1 < numPTEntries) ? maxPacketSize : fPrevFrameState.frameSize - i * maxPacketSize;  // normal case
+            unsigned sampleNumber  = fPrevFrameState.startSampleNumber;
+
+            unsigned char immediateDataLen = 0;
+            if(haveSpecialHeaders) {  // special case
+                ++numDTEntries;       // to include a Data Table entry for the special hdr
+                if(immediateDataBytesRemaining > 0) {
+                    if(hack263) {
+                        immediateDataLen = *immediateDataPtr++;
+                        --immediateDataBytesRemaining;
+                        if(immediateDataLen > immediateDataBytesRemaining) {
+                            // shouldn't happen (length byte was bad)
+                            immediateDataLen = immediateDataBytesRemaining;
+                        }
+                    }
+                    else {
+                        immediateDataLen = fPrevFrameState.specialHeaderBytesLength;
+                    }
+                }
+                dataFrameSize = fPrevFrameState.packetSizes[i] - immediateDataLen;
+
+                if(hack263) {
+                    Boolean PbitSet = immediateDataLen >= 1 && (immediateDataPtr[0] & 0x4) != 0;
+                    if(PbitSet) {
+                        offsetWithinSample += 2;  // to omit the two leading 0 bytes
+                    }
+                }
+            }
+
+            // Output the Packet Table:
+            hintSampleSize += fOurSink.addWord(0);  // Relative transmission time
+            hintSampleSize += fOurSink.addWord(rtpHeader | seqNum);
+            // RTP header info + RTP sequence number
+            hintSampleSize += fOurSink.addHalfWord(0x0000);        // Flags
+            hintSampleSize += fOurSink.addHalfWord(numDTEntries);  // Entry count
+            unsigned totalPacketSize = 0;
+
+            // Output the Data Table:
+            if(haveSpecialHeaders) {
+                //   use the "Immediate Data" format (1):
+                hintSampleSize += fOurSink.addByte(1);  // Source
+                unsigned char len = immediateDataLen > 14 ? 14 : immediateDataLen;
+                hintSampleSize += fOurSink.addByte(len);  // Length
+                totalPacketSize += len;
+                fHINF.dimm += len;
+                unsigned char j;
+                for(j = 0; j < len; ++j) {
+                    hintSampleSize += fOurSink.addByte(immediateDataPtr[j]);  // Data
+                }
+                for(j = len; j < 14; ++j) {
+                    hintSampleSize += fOurSink.addByte(0);  // Data (padding)
+                }
+
+                immediateDataPtr += immediateDataLen;
+                immediateDataBytesRemaining -= immediateDataLen;
+            }
+            //   use the "Sample Data" format (2):
+            hintSampleSize += fOurSink.addByte(2);                  // Source
+            hintSampleSize += fOurSink.addByte(0);                  // Track ref index
+            hintSampleSize += fOurSink.addHalfWord(dataFrameSize);  // Length
+            totalPacketSize += dataFrameSize;
+            fHINF.dmed += dataFrameSize;
+            hintSampleSize += fOurSink.addWord(sampleNumber);        // Sample number
+            hintSampleSize += fOurSink.addWord(offsetWithinSample);  // Offset
+            // Get "bytes|samples per compression block" from the hinted track:
+            unsigned short const bytesPerCompressionBlock   = fTrackHintedByUs->fQTBytesPerFrame;
+            unsigned short const samplesPerCompressionBlock = fTrackHintedByUs->fQTSamplesPerFrame;
+            hintSampleSize += fOurSink.addHalfWord(bytesPerCompressionBlock);
+            hintSampleSize += fOurSink.addHalfWord(samplesPerCompressionBlock);
+
+            offsetWithinSample += dataFrameSize;  // for the next iteration (if any)
+
+            // Tally statistics for this packet:
+            fHINF.nump += 1;
+            fHINF.tpyl += totalPacketSize;
+            totalPacketSize += 12;  // add in the size of the RTP header
+            fHINF.trpy += totalPacketSize;
+            if(totalPacketSize > fHINF.pmax)
+                fHINF.pmax = totalPacketSize;
+        }
+
+        // Make note of this completed hint sample frame:
+        fQTTotNumSamples += useFrame1(hintSampleSize, ppt, hintSampleDuration, hintSampleDestFileOffset);
+    }
+
+    // Remember this frame for next time:
+    fPrevFrameState.frameSize         = frameSize;
+    fPrevFrameState.presentationTime  = presentationTime;
+    fPrevFrameState.startSampleNumber = startSampleNumber;
+    fPrevFrameState.rtpHeader         = rs->curPacketMarkerBit() << 23 | (rs->rtpPayloadFormat() & 0x7F) << 16;
+    if(hack263) {
+        H263plusVideoRTPSource *rs_263           = (H263plusVideoRTPSource *)rs;
+        fPrevFrameState.numSpecialHeaders        = rs_263->fNumSpecialHeaders;
+        fPrevFrameState.specialHeaderBytesLength = rs_263->fSpecialHeaderBytesLength;
+        unsigned i;
+        for(i = 0; i < rs_263->fSpecialHeaderBytesLength; ++i) {
+            fPrevFrameState.specialHeaderBytes[i] = rs_263->fSpecialHeaderBytes[i];
+        }
+        for(i = 0; i < rs_263->fNumSpecialHeaders; ++i) {
+            fPrevFrameState.packetSizes[i] = rs_263->fPacketSizes[i];
+        }
+    }
+    else if(hackm4a_generic) {
+        // Synthesize a special header, so that this frame can be in its own RTP packet.
+        unsigned const sizeLength  = fOurSubsession.attrVal_unsigned("sizelength");
+        unsigned const indexLength = fOurSubsession.attrVal_unsigned("indexlength");
+        if(sizeLength + indexLength != 16) {
+            envir() << "Warning: unexpected 'sizeLength' " << sizeLength << " and 'indexLength' " << indexLength << "seen when creating hint track\n";
+        }
+        fPrevFrameState.numSpecialHeaders        = 1;
+        fPrevFrameState.specialHeaderBytesLength = 4;
+        fPrevFrameState.specialHeaderBytes[0]    = 0;   // AU_headers_length (high byte)
+        fPrevFrameState.specialHeaderBytes[1]    = 16;  // AU_headers_length (low byte)
+        fPrevFrameState.specialHeaderBytes[2]    = ((frameSize << indexLength) & 0xFF00) >> 8;
+        fPrevFrameState.specialHeaderBytes[3]    = (frameSize << indexLength);
+        fPrevFrameState.packetSizes[0]           = fPrevFrameState.specialHeaderBytesLength + frameSize;
+    }
+}
+
+unsigned SubsessionIOState::useFrame1(unsigned sourceDataSize, struct timeval presentationTime, unsigned frameDuration, int64_t destFileOffset) {
+    // Figure out the actual frame size for this data:
+    unsigned frameSize = fQTBytesPerFrame;
+    if(frameSize == 0) {
+        // The entire packet data is assumed to be a frame:
+        frameSize = sourceDataSize;
+    }
+    unsigned const numFrames  = sourceDataSize / frameSize;
+    unsigned const numSamples = numFrames * fQTSamplesPerFrame;
+
+    // Record the information about which 'chunk' this data belongs to:
+    ChunkDescriptor *newTailChunk;
+    if(fTailChunk == NULL) {
+        newTailChunk = fHeadChunk = new ChunkDescriptor(destFileOffset, sourceDataSize, frameSize, frameDuration, presentationTime);
+    }
+    else {
+        newTailChunk = fTailChunk->extendChunk(destFileOffset, sourceDataSize, frameSize, frameDuration, presentationTime);
+    }
+    if(newTailChunk != fTailChunk) {
+        // This data created a new chunk, rather than extending the old one
+        ++fNumChunks;
+        fTailChunk = newTailChunk;
+    }
+
+    return numSamples;
+}
+
+void SubsessionIOState::onSourceClosure() {
+    fOurSourceIsActive = False;
+    fOurSink.onSourceClosure1();
+}
+
+Boolean SubsessionIOState::syncOK(struct timeval presentationTime) {
+    QuickTimeFileSink &s = fOurSink;  // abbreviation
+    if(!s.fSyncStreams || fOurSubsession.rtpSource() == NULL)
+        return True;  // we don't care
+
+    if(s.fNumSyncedSubsessions < s.fNumSubsessions) {
+        // Not all subsessions have yet been synced.  Check whether ours was
+        // one of the unsynced ones, and, if so, whether it is now synced:
+        if(!fHaveBeenSynced) {
+            // We weren't synchronized before
+            if(fOurSubsession.rtpSource()->hasBeenSynchronizedUsingRTCP()) {
+                // H264 ?
+                if(fQTMediaDataAtomCreator == &QuickTimeFileSink::addAtom_avc1) {
+                    // special case: audio + H264 video: wait until audio is in sync
+                    if((s.fNumSubsessions == 2) && (s.fNumSyncedSubsessions < (s.fNumSubsessions - 1)))
+                        return False;
+
+                    // if audio is in sync, wait for the next IDR frame to start
+                    unsigned char *const frameSource = fBuffer->dataStart();
+                    if(*frameSource != H264_IDR_FRAME)
+                        return False;
+                }
+                // But now we are
+                fHaveBeenSynced = True;
+                fSyncTime       = presentationTime;
+                ++s.fNumSyncedSubsessions;
+
+                if(timevalGE(fSyncTime, s.fNewestSyncTime)) {
+                    s.fNewestSyncTime = fSyncTime;
+                }
+            }
+        }
+    }
+
+    // Check again whether all subsessions have been synced:
+    if(s.fNumSyncedSubsessions < s.fNumSubsessions)
+        return False;
+
+    // Allow this data if it is more recent than the newest sync time:
+    return timevalGE(presentationTime, s.fNewestSyncTime);
+}
+
+void SubsessionIOState::setHintTrack(SubsessionIOState *hintedTrack, SubsessionIOState *hintTrack) {
+    if(hintedTrack != NULL)
+        hintedTrack->fHintTrackForUs = hintTrack;
+    if(hintTrack != NULL)
+        hintTrack->fTrackHintedByUs = hintedTrack;
+}
+
+SyncFrame::SyncFrame(unsigned frameNum) : nextSyncFrame(NULL), sfFrameNum(frameNum) {}
+
+void Count64::operator+=(unsigned arg) {
+    unsigned newLo = lo + arg;
+    if(newLo < lo) {  // lo has overflowed
+        ++hi;
+    }
+    lo = newLo;
+}
+
+ChunkDescriptor ::ChunkDescriptor(int64_t offsetInFile, unsigned size, unsigned frameSize, unsigned frameDuration, struct timeval presentationTime)
+    : fNextChunk(NULL),
+      fOffsetInFile(offsetInFile),
+      fNumFrames(size / frameSize),
+      fFrameSize(frameSize),
+      fFrameDuration(frameDuration),
+      fPresentationTime(presentationTime) {}
+
+ChunkDescriptor *ChunkDescriptor ::extendChunk(int64_t newOffsetInFile, unsigned newSize, unsigned newFrameSize, unsigned newFrameDuration,
+                                               struct timeval newPresentationTime) {
+    // First, check whether the new space is just at the end of this
+    // existing chunk:
+    if(newOffsetInFile == fOffsetInFile + fNumFrames * fFrameSize) {
+        // We can extend this existing chunk, provided that the frame size
+        // and frame duration have not changed:
+        if(newFrameSize == fFrameSize && newFrameDuration == fFrameDuration) {
+            fNumFrames += newSize / fFrameSize;
+            return this;
+        }
+    }
+
+    // We'll allocate a new ChunkDescriptor, and link it to the end of us:
+    ChunkDescriptor *newDescriptor = new ChunkDescriptor(newOffsetInFile, newSize, newFrameSize, newFrameDuration, newPresentationTime);
+
+    fNextChunk = newDescriptor;
+
+    return newDescriptor;
+}
+
+////////// QuickTime-specific implementation //////////
+
+unsigned QuickTimeFileSink::addWord64(u_int64_t word) {
+    addByte((unsigned char)(word >> 56));
+    addByte((unsigned char)(word >> 48));
+    addByte((unsigned char)(word >> 40));
+    addByte((unsigned char)(word >> 32));
+    addByte((unsigned char)(word >> 24));
+    addByte((unsigned char)(word >> 16));
+    addByte((unsigned char)(word >> 8));
+    addByte((unsigned char)(word));
+
+    return 8;
+}
+
+unsigned QuickTimeFileSink::addWord(unsigned word) {
+    addByte(word >> 24);
+    addByte(word >> 16);
+    addByte(word >> 8);
+    addByte(word);
+
+    return 4;
+}
+
+unsigned QuickTimeFileSink::addHalfWord(unsigned short halfWord) {
+    addByte((unsigned char)(halfWord >> 8));
+    addByte((unsigned char)halfWord);
+
+    return 2;
+}
+
+unsigned QuickTimeFileSink::addZeroWords(unsigned numWords) {
+    for(unsigned i = 0; i < numWords; ++i) {
+        addWord(0);
+    }
+
+    return numWords * 4;
+}
+
+unsigned QuickTimeFileSink::add4ByteString(char const *str) {
+    addByte(str[0]);
+    addByte(str[1]);
+    addByte(str[2]);
+    addByte(str[3]);
+
+    return 4;
+}
+
+unsigned QuickTimeFileSink::addArbitraryString(char const *str, Boolean oneByteLength) {
+    unsigned size = 0;
+    if(oneByteLength) {
+        // Begin with a byte containing the string length:
+        unsigned strLength = strlen(str);
+        if(strLength >= 256) {
+            envir() << "QuickTimeFileSink::addArbitraryString(\"" << str << "\") saw string longer than we know how to handle (" << strLength << "\n";
+        }
+        size += addByte((unsigned char)strLength);
+    }
+
+    while(*str != '\0') {
+        size += addByte(*str++);
+    }
+
+    return size;
+}
+
+unsigned QuickTimeFileSink::addAtomHeader(char const *atomName) {
+    // Output a placeholder for the 4-byte size:
+    addWord(0);
+
+    // Output the 4-byte atom name:
+    add4ByteString(atomName);
+
+    return 8;
+}
+
+unsigned QuickTimeFileSink::addAtomHeader64(char const *atomName) {
+    // Output 64Bit size marker
+    addWord(1);
+
+    // Output the 4-byte atom name:
+    add4ByteString(atomName);
+
+    addWord64(0);
+
+    return 16;
+}
+
+void QuickTimeFileSink::setWord(int64_t filePosn, unsigned size) {
+    do {
+        if(SeekFile64(fOutFid, filePosn, SEEK_SET) < 0)
+            break;
+        addWord(size);
+        if(SeekFile64(fOutFid, 0, SEEK_END) < 0)
+            break;  // go back to where we were
+
+        return;
+    } while(0);
+
+    // One of the SeekFile64()s failed, probable because we're not a seekable file
+    envir() << "QuickTimeFileSink::setWord(): SeekFile64 failed (err " << envir().getErrno() << ")\n";
+}
+
+void QuickTimeFileSink::setWord64(int64_t filePosn, u_int64_t size) {
+    do {
+        if(SeekFile64(fOutFid, filePosn, SEEK_SET) < 0)
+            break;
+        addWord64(size);
+        if(SeekFile64(fOutFid, 0, SEEK_END) < 0)
+            break;  // go back to where we were
+
+        return;
+    } while(0);
+
+    // One of the SeekFile64()s failed, probable because we're not a seekable file
+    envir() << "QuickTimeFileSink::setWord64(): SeekFile64 failed (err " << envir().getErrno() << ")\n";
+}
+
+// Methods for writing particular atoms.  Note the following macros:
+
+#define addAtom(name)                                \
+    unsigned QuickTimeFileSink::addAtom_##name() {   \
+        int64_t  initFilePosn = TellFile64(fOutFid); \
+        unsigned size         = addAtomHeader("" #name "")
+
+#define addAtomEnd               \
+    setWord(initFilePosn, size); \
+    return size;                 \
+    }
+
+addAtom(ftyp);
+size += add4ByteString("mp42");
+size += addWord(0x00000000);
+size += add4ByteString("mp42");
+size += add4ByteString("isom");
+addAtomEnd;
+
+addAtom(moov);
+size += addAtom_mvhd();
+
+if(fGenerateMP4Format) {
+    size += addAtom_iods();
+}
+
+// Add a 'trak' atom for each subsession:
+// (For some unknown reason, QuickTime Player (5.0 at least)
+//  doesn't display the movie correctly unless the audio track
+//  (if present) appears before the video track.  So ensure this here.)
+MediaSubsessionIterator iter(fInputSession);
+MediaSubsession *       subsession;
+while((subsession = iter.next()) != NULL) {
+    fCurrentIOState = (SubsessionIOState *)(subsession->miscPtr);
+    if(fCurrentIOState == NULL)
+        continue;
+    if(strcmp(subsession->mediumName(), "audio") != 0)
+        continue;
+
+    size += addAtom_trak();
+
+    if(fCurrentIOState->hasHintTrack()) {
+        // This track has a hint track; output it also:
+        fCurrentIOState = fCurrentIOState->fHintTrackForUs;
+        size += addAtom_trak();
+    }
+}
+iter.reset();
+while((subsession = iter.next()) != NULL) {
+    fCurrentIOState = (SubsessionIOState *)(subsession->miscPtr);
+    if(fCurrentIOState == NULL)
+        continue;
+    if(strcmp(subsession->mediumName(), "audio") == 0)
+        continue;
+
+    size += addAtom_trak();
+
+    if(fCurrentIOState->hasHintTrack()) {
+        // This track has a hint track; output it also:
+        fCurrentIOState = fCurrentIOState->fHintTrackForUs;
+        size += addAtom_trak();
+    }
+}
+addAtomEnd;
+
+addAtom(mvhd);
+size += addWord(0x00000000);          // Version + Flags
+size += addWord(fAppleCreationTime);  // Creation time
+size += addWord(fAppleCreationTime);  // Modification time
+
+// For the "Time scale" field, use the largest RTP timestamp frequency
+// that we saw in any of the subsessions.
+size += addWord(movieTimeScale());  // Time scale
+
+unsigned const duration = fMaxTrackDurationM;
+fMVHD_durationPosn      = TellFile64(fOutFid);
+size += addWord(duration);  // Duration
+
+size += addWord(0x00010000);                                  // Preferred rate
+size += addWord(0x01000000);                                  // Preferred volume + Reserved[0]
+size += addZeroWords(2);                                      // Reserved[1-2]
+size += addWord(0x00010000);                                  // matrix top left corner
+size += addZeroWords(3);                                      // matrix
+size += addWord(0x00010000);                                  // matrix center
+size += addZeroWords(3);                                      // matrix
+size += addWord(0x40000000);                                  // matrix bottom right corner
+size += addZeroWords(6);                                      // various time fields
+size += addWord(SubsessionIOState::fCurrentTrackNumber + 1);  // Next track ID
+addAtomEnd;
+
+addAtom(iods);
+size += addWord(0x00000000);  // Version + Flags
+size += addWord(0x10808080);
+size += addWord(0x07004FFF);
+size += addWord(0xFF0FFFFF);
+addAtomEnd;
+
+addAtom(trak);
+size += addAtom_tkhd();
+
+// If we're synchronizing the media streams (or are a hint track),
+// add an edit list that helps do this:
+if(fCurrentIOState->fHeadChunk != NULL && (fSyncStreams || fCurrentIOState->isHintTrack())) {
+    size += addAtom_edts();
+}
+
+// If we're generating a hint track, add a 'tref' atom:
+if(fCurrentIOState->isHintTrack())
+    size += addAtom_tref();
+
+size += addAtom_mdia();
+
+// If we're generating a hint track, add a 'udta' atom:
+if(fCurrentIOState->isHintTrack())
+    size += addAtom_udta();
+addAtomEnd;
+
+addAtom(tkhd);
+if(fCurrentIOState->fQTEnableTrack) {
+    size += addWord(0x0000000F);  // Version +  Flags
+}
+else {
+    // Disable this track in the movie:
+    size += addWord(0x00000000);  // Version +  Flags
+}
+size += addWord(fAppleCreationTime);         // Creation time
+size += addWord(fAppleCreationTime);         // Modification time
+size += addWord(fCurrentIOState->fTrackID);  // Track ID
+size += addWord(0x00000000);                 // Reserved
+
+unsigned const duration             = fCurrentIOState->fQTDurationM;  // movie units
+fCurrentIOState->fTKHD_durationPosn = TellFile64(fOutFid);
+size += addWord(duration);    // Duration
+size += addZeroWords(3);      // Reserved+Layer+Alternate grp
+size += addWord(0x01000000);  // Volume + Reserved
+size += addWord(0x00010000);  // matrix top left corner
+size += addZeroWords(3);      // matrix
+size += addWord(0x00010000);  // matrix center
+size += addZeroWords(3);      // matrix
+size += addWord(0x40000000);  // matrix bottom right corner
+if(strcmp(fCurrentIOState->fOurSubsession.mediumName(), "video") == 0) {
+    size += addWord(fMovieWidth << 16);   // Track width
+    size += addWord(fMovieHeight << 16);  // Track height
+}
+else {
+    size += addZeroWords(2);  // not video: leave width and height fields zero
+}
+addAtomEnd;
+
+addAtom(edts);
+size += addAtom_elst();
+addAtomEnd;
+
+#define addEdit1(duration, trackPosition)                                               \
+    do {                                                                                \
+        unsigned trackDuration = (unsigned)((2 * (duration)*movieTimeScale() + 1) / 2); \
+        /* in movie time units */                                                       \
+        size += addWord(trackDuration); /* Track duration */                            \
+        totalDurationOfEdits += trackDuration;                                          \
+        size += addWord(trackPosition); /* Media time */                                \
+        size += addWord(0x00010000);    /* Media rate (1x) */                           \
+        ++numEdits;                                                                     \
+    } while(0)
+#define addEdit(duration) addEdit1((duration), editTrackPosition)
+#define addEmptyEdit(duration) addEdit1((duration), (~0))
+
+addAtom(elst);
+size += addWord(0x00000000);  // Version + Flags
+
+// Add a dummy "Number of entries" field
+// (and remember its position).  We'll fill this field in later:
+int64_t numEntriesPosition = TellFile64(fOutFid);
+size += addWord(0);  // dummy for "Number of entries"
+unsigned numEdits             = 0;
+unsigned totalDurationOfEdits = 0;  // in movie time units
+
+// Run through our chunks, looking at their presentation times.
+// From these, figure out the edits that need to be made to keep
+// the track media data in sync with the presentation times.
+
+double const syncThreshold = 0.1;  // 100 ms
+                                   // don't allow the track to get out of sync by more than this
+
+struct timeval editStartTime        = fFirstDataTime;
+unsigned       editTrackPosition    = 0;
+unsigned       currentTrackPosition = 0;
+double         trackDurationOfEdit  = 0.0;
+unsigned       chunkDuration        = 0;
+
+ChunkDescriptor *chunk = fCurrentIOState->fHeadChunk;
+while(chunk != NULL) {
+    struct timeval const &chunkStartTime      = chunk->fPresentationTime;
+    double                movieDurationOfEdit = (chunkStartTime.tv_sec - editStartTime.tv_sec) + (chunkStartTime.tv_usec - editStartTime.tv_usec) / 1000000.0;
+    trackDurationOfEdit                       = (currentTrackPosition - editTrackPosition) / (double)(fCurrentIOState->fQTTimeScale);
+
+    double outOfSync = movieDurationOfEdit - trackDurationOfEdit;
+
+    if(outOfSync > syncThreshold) {
+        // The track's data is too short, so end this edit, add a new
+        // 'empty' edit after it, and start a new edit
+        // (at the current track posn.):
+        if(trackDurationOfEdit > 0.0)
+            addEdit(trackDurationOfEdit);
+        addEmptyEdit(outOfSync);
+
+        editStartTime     = chunkStartTime;
+        editTrackPosition = currentTrackPosition;
+    }
+    else if(outOfSync < -syncThreshold) {
+        // The track's data is too long, so end this edit, and start
+        // a new edit (pointing at the current track posn.):
+        if(movieDurationOfEdit > 0.0)
+            addEdit(movieDurationOfEdit);
+
+        editStartTime     = chunkStartTime;
+        editTrackPosition = currentTrackPosition;
+    }
+
+    // Note the duration of this chunk:
+    unsigned numChannels = fCurrentIOState->fOurSubsession.numChannels();
+    chunkDuration        = chunk->fNumFrames * chunk->fFrameDuration / numChannels;
+    currentTrackPosition += chunkDuration;
+
+    chunk = chunk->fNextChunk;
+}
+
+// Write out the final edit
+trackDurationOfEdit += (double)chunkDuration / fCurrentIOState->fQTTimeScale;
+if(trackDurationOfEdit > 0.0)
+    addEdit(trackDurationOfEdit);
+
+// Now go back and fill in the "Number of entries" field:
+setWord(numEntriesPosition, numEdits);
+
+// Also, if the sum of all of the edit durations exceeds the
+// track duration that we already computed (from sample durations),
+// then reset the track duration to this new value:
+if(totalDurationOfEdits > fCurrentIOState->fQTDurationM) {
+    fCurrentIOState->fQTDurationM = totalDurationOfEdits;
+    setWord(fCurrentIOState->fTKHD_durationPosn, totalDurationOfEdits);
+
+    // Also, check whether the overall movie duration needs to change:
+    if(totalDurationOfEdits > fMaxTrackDurationM) {
+        fMaxTrackDurationM = totalDurationOfEdits;
+        setWord(fMVHD_durationPosn, totalDurationOfEdits);
+    }
+
+    // Also, convert to track time scale:
+    double scaleFactor            = fCurrentIOState->fQTTimeScale / (double)movieTimeScale();
+    fCurrentIOState->fQTDurationT = (unsigned)(totalDurationOfEdits * scaleFactor);
+}
+addAtomEnd;
+
+addAtom(tref);
+size += addAtom_hint();
+addAtomEnd;
+
+addAtom(hint);
+SubsessionIOState *hintedTrack = fCurrentIOState->fTrackHintedByUs;
+// Assert: hintedTrack != NULL
+size += addWord(hintedTrack->fTrackID);
+addAtomEnd;
+
+addAtom(mdia);
+size += addAtom_mdhd();
+size += addAtom_hdlr();
+size += addAtom_minf();
+addAtomEnd;
+
+addAtom(mdhd);
+size += addWord(0x00000000);          // Version + Flags
+size += addWord(fAppleCreationTime);  // Creation time
+size += addWord(fAppleCreationTime);  // Modification time
+
+unsigned const timeScale = fCurrentIOState->fQTTimeScale;
+size += addWord(timeScale);  // Time scale
+
+unsigned const duration = fCurrentIOState->fQTDurationT;  // track units
+size += addWord(duration);                                // Duration
+
+size += addWord(0x00000000);  // Language+Quality
+addAtomEnd;
+
+addAtom(hdlr);
+size += addWord(0x00000000);     // Version + Flags
+size += add4ByteString("mhlr");  // Component type
+size += addWord(fCurrentIOState->fQTcomponentSubtype);
+// Component subtype
+size += add4ByteString("appl");  // Component manufacturer
+size += addWord(0x00000000);     // Component flags
+size += addWord(0x00000000);     // Component flags mask
+size += addArbitraryString(fCurrentIOState->fQTcomponentName);
+// Component name
+addAtomEnd;
+
+addAtom(minf);
+SubsessionIOState::atomCreationFunc mediaInformationAtomCreator = fCurrentIOState->fQTMediaInformationAtomCreator;
+size += (this->*mediaInformationAtomCreator)();
+size += addAtom_hdlr2();
+size += addAtom_dinf();
+size += addAtom_stbl();
+addAtomEnd;
+
+addAtom(smhd);
+size += addZeroWords(2);  // Version+Flags+Balance+Reserved
+addAtomEnd;
+
+addAtom(vmhd);
+size += addWord(0x00000001);  // Version + Flags
+size += addWord(0x00408000);  // Graphics mode + Opcolor[red]
+size += addWord(0x80008000);  // Opcolor[green} + Opcolor[blue]
+addAtomEnd;
+
+addAtom(gmhd);
+size += addAtom_gmin();
+addAtomEnd;
+
+addAtom(gmin);
+size += addWord(0x00000000);  // Version + Flags
+// The following fields probably aren't used for hint tracks, so just
+// use values that I've seen in other files:
+size += addWord(0x00408000);  // Graphics mode + Opcolor (1st 2 bytes)
+size += addWord(0x80008000);  // Opcolor (last 4 bytes)
+size += addWord(0x00000000);  // Balance + Reserved
+addAtomEnd;
+
+unsigned QuickTimeFileSink::addAtom_hdlr2() {
+    int64_t  initFilePosn = TellFile64(fOutFid);
+    unsigned size         = addAtomHeader("hdlr");
+    size += addWord(0x00000000);                             // Version + Flags
+    size += add4ByteString("dhlr");                          // Component type
+    size += add4ByteString("alis");                          // Component subtype
+    size += add4ByteString("appl");                          // Component manufacturer
+    size += addZeroWords(2);                                 // Component flags+Component flags mask
+    size += addArbitraryString("Apple Alias Data Handler");  // Component name
+    addAtomEnd;
+
+    addAtom(dinf);
+    size += addAtom_dref();
+    addAtomEnd;
+
+    addAtom(dref);
+    size += addWord(0x00000000);  // Version + Flags
+    size += addWord(0x00000001);  // Number of entries
+    size += addAtom_alis();
+    addAtomEnd;
+
+    addAtom(alis);
+    size += addWord(0x00000001);  // Version + Flags
+    addAtomEnd;
+
+    addAtom(stbl);
+    size += addAtom_stsd();
+    size += addAtom_stts();
+    if(fCurrentIOState->fQTcomponentSubtype == fourChar('v', 'i', 'd', 'e')) {
+        size += addAtom_stss();  // only for video streams
+    }
+    size += addAtom_stsc();
+    size += addAtom_stsz();
+    size += addAtom_co64();
+    addAtomEnd;
+
+    addAtom(stsd);
+    size += addWord(0x00000000);  // Version+Flags
+    size += addWord(0x00000001);  // Number of entries
+    SubsessionIOState::atomCreationFunc mediaDataAtomCreator = fCurrentIOState->fQTMediaDataAtomCreator;
+    size += (this->*mediaDataAtomCreator)();
+    addAtomEnd;
+
+    unsigned QuickTimeFileSink::addAtom_genericMedia() {
+        int64_t initFilePosn = TellFile64(fOutFid);
+
+        // Our source is assumed to be a "QuickTimeGenericRTPSource"
+        // Use its "sdAtom" state for our contents:
+        QuickTimeGenericRTPSource *rtpSource = (QuickTimeGenericRTPSource *)fCurrentIOState->fOurSubsession.rtpSource();
+        unsigned                   size      = 0;
+        if(rtpSource != NULL) {
+            QuickTimeGenericRTPSource::QTState &qtState = rtpSource->qtState;
+            char const *                        from    = qtState.sdAtom;
+            size                                        = qtState.sdAtomSize;
+            for(unsigned i = 0; i < size; ++i)
+                addByte(from[i]);
+        }
+        addAtomEnd;
+
+        unsigned QuickTimeFileSink::addAtom_soundMediaGeneral() {
+            int64_t  initFilePosn = TellFile64(fOutFid);
+            unsigned size         = addAtomHeader(fCurrentIOState->fQTAudioDataType);
+
+            // General sample description fields:
+            size += addWord(0x00000000);  // Reserved
+            size += addWord(0x00000001);  // Reserved+Data reference index
+                                          // Sound sample description fields:
+            unsigned short const version = fCurrentIOState->fQTSoundSampleVersion;
+            size += addWord(version << 16);  // Version+Revision level
+            size += addWord(0x00000000);     // Vendor
+            unsigned short numChannels = (unsigned short)(fCurrentIOState->fOurSubsession.numChannels());
+            size += addHalfWord(numChannels);  // Number of channels
+            size += addHalfWord(0x0010);       // Sample size
+            //  size += addWord(0x00000000); // Compression ID+Packet size
+            size += addWord(0xfffe0000);  // Compression ID+Packet size #####
+
+            unsigned const sampleRateFixedPoint = fCurrentIOState->fQTTimeScale << 16;
+            size += addWord(sampleRateFixedPoint);  // Sample rate
+            addAtomEnd;
+
+            unsigned QuickTimeFileSink::addAtom_Qclp() {
+                // The beginning of this atom looks just like a general Sound Media atom,
+                // except with a version field of 1:
+                int64_t initFilePosn                   = TellFile64(fOutFid);
+                fCurrentIOState->fQTAudioDataType      = "Qclp";
+                fCurrentIOState->fQTSoundSampleVersion = 1;
+                unsigned size                          = addAtom_soundMediaGeneral();
+
+                // Next, add the four fields that are particular to version 1:
+                // (Later, parameterize these #####)
+                size += addWord(0x000000a0);  // samples per packet
+                size += addWord(0x00000000);  // ???
+                size += addWord(0x00000000);  // ???
+                size += addWord(0x00000002);  // bytes per sample (uncompressed)
+
+                // Other special fields are in a 'wave' atom that follows:
+                size += addAtom_wave();
+                addAtomEnd;
+
+                addAtom(wave);
+                size += addAtom_frma();
+                if(strcmp(fCurrentIOState->fQTAudioDataType, "Qclp") == 0) {
+                    size += addWord(0x00000014);     // ???
+                    size += add4ByteString("Qclp");  // ???
+                    if(fCurrentIOState->fQTBytesPerFrame == 35) {
+                        size += addAtom_Fclp();  // full-rate QCELP
+                    }
+                    else {
+                        size += addAtom_Hclp();   // half-rate QCELP
+                    }                             // what about other QCELP 'rates'??? #####
+                    size += addWord(0x00000008);  // ???
+                    size += addWord(0x00000000);  // ???
+                    size += addWord(0x00000000);  // ???
+                    size += addWord(0x00000008);  // ???
+                }
+                else if(strcmp(fCurrentIOState->fQTAudioDataType, "mp4a") == 0) {
+                    size += addWord(0x0000000c);     // ???
+                    size += add4ByteString("mp4a");  // ???
+                    size += addWord(0x00000000);     // ???
+                    size += addAtom_esds();          // ESDescriptor
+                    size += addWord(0x00000008);     // ???
+                    size += addWord(0x00000000);     // ???
+                }
+                addAtomEnd;
+
+                addAtom(frma);
+                size += add4ByteString(fCurrentIOState->fQTAudioDataType);  // ???
+                addAtomEnd;
+
+                addAtom(Fclp);
+                size += addWord(0x00000000);  // ???
+                addAtomEnd;
+
+                addAtom(Hclp);
+                size += addWord(0x00000000);  // ???
+                addAtomEnd;
+
+                unsigned QuickTimeFileSink::addAtom_mp4a() {
+                    unsigned size = 0;
+                    // The beginning of this atom looks just like a general Sound Media atom,
+                    // except with a version field of 1:
+                    int64_t initFilePosn              = TellFile64(fOutFid);
+                    fCurrentIOState->fQTAudioDataType = "mp4a";
+
+                    if(fGenerateMP4Format) {
+                        fCurrentIOState->fQTSoundSampleVersion = 0;
+                        size                                   = addAtom_soundMediaGeneral();
+                        size += addAtom_esds();
+                    }
+                    else {
+                        fCurrentIOState->fQTSoundSampleVersion = 1;
+                        size                                   = addAtom_soundMediaGeneral();
+
+                        // Next, add the four fields that are particular to version 1:
+                        // (Later, parameterize these #####)
+                        size += addWord(fCurrentIOState->fQTTimeUnitsPerSample);
+                        size += addWord(0x00000001);  // ???
+                        size += addWord(0x00000001);  // ???
+                        size += addWord(0x00000002);  // bytes per sample (uncompressed)
+
+                        // Other special fields are in a 'wave' atom that follows:
+                        size += addAtom_wave();
+                    }
+                    addAtomEnd;
+
+                    addAtom(esds);
+                    // Get the source's 'config' information.  (We need the size now.)
+                    unsigned         configSize;
+                    MediaSubsession &subsession = fCurrentIOState->fOurSubsession;
+                    unsigned char *  config     = parseGeneralConfigStr(subsession.fmtp_config(), configSize);
+
+                    if(strcmp(subsession.mediumName(), "audio") == 0) {  // MPEG-4 audio
+                        size += addWord(0x00000000);                     // ???
+                        size += addWord(0x03808080);                     // ES_DescrTag+length coding
+                        size += addWord((31 + configSize) << 24);        // length (includes 'config' and SLConfigDescriptor)
+                        // DecoderConfigDescriptor
+                        size += addWord(0x04808080);                              // DecoderConfigDescrTag + length coding
+                        size += addWord(((17 + configSize) << 24) | 0x00401500);  // length (includes 'config' info)
+                        size += addWord(0x18000000);                              // ???
+                        size += addWord(0x6d600000);                              // ???
+                        size += addWord(0x6d600580);                              // ???
+                        size += addByte(0x80);
+                        size += addByte(0x80);  // ???
+                    }
+                    else if(strcmp(subsession.mediumName(), "video") == 0) {      // MPEG-4 video
+                        size += addWord(0x00000000);                              // ???
+                        size += addWord(((22 + configSize) << 16) | 0x03000000);  // ES_DescrTag + length (incl. 'config')
+                        size += addWord(0x1f042b20);                              // ???
+                        size += addWord(0x1104fd46);                              // ???
+                        size += addWord(0x000d4e10);                              // ???
+                        size += addWord(0x000d4e10);                              // ???
+                        size += addByte(0x05);                                    // ???
+                    }
+
+                    // Add the source's 'config' information:
+                    size += addByte(configSize);
+                    for(unsigned i = 0; i < configSize; ++i) {
+                        size += addByte(config[i]);
+                    }
+                    delete[] config;
+
+                    // SLConfigDescriptor:
+                    if(strcmp(subsession.mediumName(), "audio") == 0) {  // MPEG-4 audio
+                        size += addWord(0x06808080);                     // SLConfigDescrTag + length coding
+                        size += addHalfWord(0x0102);                     // length(1) + ???
+                    }
+                    else {                            // MPEG-4 video
+                        size += addHalfWord(0x0601);  // SLConfigDescrTag + length(1)
+                        size += addByte(0x02);        // ???
+                    }
+                    addAtomEnd;
+
+                    addAtom(srcq);
+                    //#####
+                    size += addWord(0x00000040);  // ???
+                                                  //#####
+                    addAtomEnd;
+
+                    addAtom(h263);
+                    // General sample description fields:
+                    size += addWord(0x00000000);     // Reserved
+                    size += addWord(0x00000001);     // Reserved+Data reference index
+                                                     // Video sample description fields:
+                    size += addWord(0x00020001);     // Version+Revision level
+                    size += add4ByteString("appl");  // Vendor
+                    size += addWord(0x00000000);     // Temporal quality
+                    size += addWord(0x000002fc);     // Spatial quality
+                    unsigned const widthAndHeight = (fMovieWidth << 16) | fMovieHeight;
+                    size += addWord(widthAndHeight);  // Width+height
+                    size += addWord(0x00480000);      // Horizontal resolution
+                    size += addWord(0x00480000);      // Vertical resolution
+                    size += addWord(0x00000000);      // Data size
+                    size += addWord(0x00010548);      // Frame count+Compressor name (start)
+                                                      // "H.263"
+                    size += addWord(0x2e323633);      // Compressor name (continued)
+                    size += addZeroWords(6);          // Compressor name (continued - zero)
+                    size += addWord(0x00000018);      // Compressor name (final)+Depth
+                    size += addHalfWord(0xffff);      // Color table id
+                    addAtomEnd;
+
+                    addAtom(avc1);
+                    // General sample description fields:
+                    size += addWord(0x00000000);     // Reserved
+                    size += addWord(0x00000001);     // Reserved+Data       reference index
+                                                     // Video sample       description     fields:
+                    size += addWord(0x00000000);     // Version+Revision level
+                    size += add4ByteString("appl");  // Vendor
+                    size += addWord(0x00000000);     // Temporal quality
+                    size += addWord(0x00000000);     // Spatial quality
+                    unsigned const widthAndHeight = (fMovieWidth << 16) | fMovieHeight;
+                    size += addWord(widthAndHeight);  // Width+height
+                    size += addWord(0x00480000);      // Horizontal resolution
+                    size += addWord(0x00480000);      // Vertical resolution
+                    size += addWord(0x00000000);      // Data size
+                    size += addWord(0x00010548);      // Frame count+Compressor name (start)
+                                                      // "H.264"
+                    size += addWord(0x2e323634);      // Compressor name (continued)
+                    size += addZeroWords(6);          // Compressor name (continued - zero)
+                    size += addWord(0x00000018);      // Compressor name (final)+Depth
+                    size += addHalfWord(0xffff);      // Color table id
+                    size += addAtom_avcC();
+                    addAtomEnd;
+
+                    addAtom(avcC);
+                    // Begin by Base-64 decoding the "sprop" parameter sets strings:
+                    char *psets = strDup(fCurrentIOState->fOurSubsession.fmtp_spropparametersets());
+                    if(psets == NULL)
+                        return 0;
+
+                    size_t comma_pos       = strcspn(psets, ",");
+                    psets[comma_pos]       = '\0';
+                    char const *   sps_b64 = psets;
+                    char const *   pps_b64 = &psets[comma_pos + 1];
+                    unsigned       sps_count;
+                    unsigned char *sps_data = base64Decode(sps_b64, sps_count, false);
+                    unsigned       pps_count;
+                    unsigned char *pps_data = base64Decode(pps_b64, pps_count, false);
+
+                    // Then add the decoded data:
+                    size += addByte(0x01);         // configuration version
+                    size += addByte(sps_data[1]);  // profile
+                    size += addByte(sps_data[2]);  // profile compat
+                    size += addByte(sps_data[3]);  // level
+                    size += addByte(0xff);         /* 0b11111100 | lengthsize = 0x11 */
+                    size += addByte(0xe0 | (sps_count > 0 ? 1 : 0));
+                    if(sps_count > 0) {
+                        size += addHalfWord(sps_count);
+                        for(unsigned i = 0; i < sps_count; i++) {
+                            size += addByte(sps_data[i]);
+                        }
+                    }
+                    size += addByte(pps_count > 0 ? 1 : 0);
+                    if(pps_count > 0) {
+                        size += addHalfWord(pps_count);
+                        for(unsigned i = 0; i < pps_count; i++) {
+                            size += addByte(pps_data[i]);
+                        }
+                    }
+
+                    // Finally, delete the data that we allocated:
+                    delete[] pps_data;
+                    delete[] sps_data;
+                    delete[] psets;
+                    addAtomEnd;
+
+                    addAtom(mp4v);
+                    // General sample description fields:
+                    size += addWord(0x00000000);     // Reserved
+                    size += addWord(0x00000001);     // Reserved+Data reference index
+                                                     // Video sample description fields:
+                    size += addWord(0x00020001);     // Version+Revision level
+                    size += add4ByteString("appl");  // Vendor
+                    size += addWord(0x00000200);     // Temporal quality
+                    size += addWord(0x00000400);     // Spatial quality
+                    unsigned const widthAndHeight = (fMovieWidth << 16) | fMovieHeight;
+                    size += addWord(widthAndHeight);  // Width+height
+                    size += addWord(0x00480000);      // Horizontal resolution
+                    size += addWord(0x00480000);      // Vertical resolution
+                    size += addWord(0x00000000);      // Data size
+                    size += addWord(0x00010c4d);      // Frame count+Compressor name (start)
+                                                      // "MPEG-4 Video"
+                    size += addWord(0x5045472d);      // Compressor name (continued)
+                    size += addWord(0x34205669);      // Compressor name (continued)
+                    size += addWord(0x64656f00);      // Compressor name (continued)
+                    size += addZeroWords(4);          // Compressor name (continued - zero)
+                    size += addWord(0x00000018);      // Compressor name (final)+Depth
+                    size += addHalfWord(0xffff);      // Color table id
+                    size += addAtom_esds();           // ESDescriptor
+                    size += addWord(0x00000000);      // ???
+                    addAtomEnd;
+
+                    unsigned QuickTimeFileSink::addAtom_rtp() {
+                        int64_t  initFilePosn = TellFile64(fOutFid);
+                        unsigned size         = addAtomHeader("rtp ");
+
+                        size += addWord(0x00000000);  // Reserved (1st 4 bytes)
+                        size += addWord(0x00000001);  // Reserved (last 2 bytes) + Data ref index
+                        size += addWord(0x00010001);  // Hint track version + Last compat htv
+                        size += addWord(1450);        // Max packet size
+
+                        size += addAtom_tims();
+                        addAtomEnd;
+
+                        addAtom(tims);
+                        size += addWord(fCurrentIOState->fOurSubsession.rtpTimestampFrequency());
+                        addAtomEnd;
+
+                        addAtom(stts);                // Time-to-Sample
+                        size += addWord(0x00000000);  // Version+flags
+
+                        // First, add a dummy "Number of entries" field
+                        // (and remember its position).  We'll fill this field in later:
+                        int64_t numEntriesPosition = TellFile64(fOutFid);
+                        size += addWord(0);  // dummy for "Number of entries"
+
+                        // Then, run through the chunk descriptors, and enter the entries
+                        // in this (compressed) Time-to-Sample table:
+                        unsigned         numEntries = 0, numSamplesSoFar = 0;
+                        unsigned         prevSampleDuration = 0;
+                        unsigned const   samplesPerFrame    = fCurrentIOState->fQTSamplesPerFrame;
+                        ChunkDescriptor *chunk              = fCurrentIOState->fHeadChunk;
+                        while(chunk != NULL) {
+                            unsigned const sampleDuration = chunk->fFrameDuration / samplesPerFrame;
+                            if(sampleDuration != prevSampleDuration) {
+                                // This chunk will start a new table entry,
+                                // so write out the old one (if any):
+                                if(chunk != fCurrentIOState->fHeadChunk) {
+                                    ++numEntries;
+                                    size += addWord(numSamplesSoFar);     // Sample count
+                                    size += addWord(prevSampleDuration);  // Sample duration
+                                    numSamplesSoFar = 0;
+                                }
+                            }
+
+                            unsigned const numSamples = chunk->fNumFrames * samplesPerFrame;
+                            numSamplesSoFar += numSamples;
+                            prevSampleDuration = sampleDuration;
+                            chunk              = chunk->fNextChunk;
+                        }
+
+                        // Then, write out the last entry:
+                        ++numEntries;
+                        size += addWord(numSamplesSoFar);     // Sample count
+                        size += addWord(prevSampleDuration);  // Sample duration
+
+                        // Now go back and fill in the "Number of entries" field:
+                        setWord(numEntriesPosition, numEntries);
+                        addAtomEnd;
+
+                        addAtom(stss);                // Sync-Sample
+                        size += addWord(0x00000000);  // Version+flags
+
+                        // First, add a dummy "Number of entries" field
+                        // (and remember its position).  We'll fill this field in later:
+                        int64_t numEntriesPosition = TellFile64(fOutFid);
+                        size += addWord(0);  // dummy for "Number of entries"
+
+                        unsigned numEntries = 0, numSamplesSoFar = 0;
+                        if(fCurrentIOState->fHeadSyncFrame != NULL) {
+                            SyncFrame *currentSyncFrame = fCurrentIOState->fHeadSyncFrame;
+
+                            // First, count the number of frames (to use as a sanity check; see below):
+                            unsigned totNumFrames = 0;
+                            for(ChunkDescriptor *chunk = fCurrentIOState->fHeadChunk; chunk != NULL; chunk = chunk->fNextChunk)
+                                totNumFrames += chunk->fNumFrames;
+
+                            while(currentSyncFrame != NULL) {
+                                if(currentSyncFrame->sfFrameNum >= totNumFrames)
+                                    break;  // sanity check
+
+                                ++numEntries;
+                                size += addWord(currentSyncFrame->sfFrameNum);
+                                currentSyncFrame = currentSyncFrame->nextSyncFrame;
+                            }
+                        }
+                        else {
+                            // First, run through the chunk descriptors, counting up the total number of samples:
+                            unsigned const   samplesPerFrame = fCurrentIOState->fQTSamplesPerFrame;
+                            ChunkDescriptor *chunk           = fCurrentIOState->fHeadChunk;
+                            while(chunk != NULL) {
+                                unsigned const numSamples = chunk->fNumFrames * samplesPerFrame;
+                                numSamplesSoFar += numSamples;
+                                chunk = chunk->fNextChunk;
+                            }
+
+                            // Then, write out the sample numbers that we deem correspond to 'sync samples':
+                            unsigned i;
+                            for(i = 0; i < numSamplesSoFar; i += 12) {
+                                // For an explanation of the constant "12", see http://lists.live555.com/pipermail/live-devel/2009-July/010969.html
+                                // (Perhaps we should really try to keep track of which 'samples' ('frames' for video) really are 'key frames'?)
+                                size += addWord(i + 1);
+                                ++numEntries;
+                            }
+
+                            // Then, write out the last entry (if we haven't already done so):
+                            if(i != (numSamplesSoFar - 1)) {
+                                size += addWord(numSamplesSoFar);
+                                ++numEntries;
+                            }
+                        }
+
+                        // Now go back and fill in the "Number of entries" field:
+                        setWord(numEntriesPosition, numEntries);
+                        addAtomEnd;
+
+                        addAtom(stsc);                // Sample-to-Chunk
+                        size += addWord(0x00000000);  // Version+flags
+
+                        // First, add a dummy "Number of entries" field
+                        // (and remember its position).  We'll fill this field in later:
+                        int64_t numEntriesPosition = TellFile64(fOutFid);
+                        size += addWord(0);  // dummy for "Number of entries"
+
+                        // Then, run through the chunk descriptors, and enter the entries
+                        // in this (compressed) Sample-to-Chunk table:
+                        unsigned         numEntries = 0, chunkNumber = 0;
+                        unsigned         prevSamplesPerChunk = ~0;
+                        unsigned const   samplesPerFrame     = fCurrentIOState->fQTSamplesPerFrame;
+                        ChunkDescriptor *chunk               = fCurrentIOState->fHeadChunk;
+                        while(chunk != NULL) {
+                            ++chunkNumber;
+                            unsigned const samplesPerChunk = chunk->fNumFrames * samplesPerFrame;
+                            if(samplesPerChunk != prevSamplesPerChunk) {
+                                // This chunk will be a new table entry:
+                                ++numEntries;
+                                size += addWord(chunkNumber);      // Chunk number
+                                size += addWord(samplesPerChunk);  // Samples per chunk
+                                size += addWord(0x00000001);       // Sample description ID
+
+                                prevSamplesPerChunk = samplesPerChunk;
+                            }
+                            chunk = chunk->fNextChunk;
+                        }
+
+                        // Now go back and fill in the "Number of entries" field:
+                        setWord(numEntriesPosition, numEntries);
+                        addAtomEnd;
+
+                        addAtom(stsz);                // Sample Size
+                        size += addWord(0x00000000);  // Version+flags
+
+                        // Begin by checking whether our chunks all have the same
+                        // 'bytes-per-sample'.  This determines whether this atom's table
+                        // has just a single entry, or multiple entries.
+                        Boolean          haveSingleEntryTable = True;
+                        double           firstBPS             = 0.0;
+                        ChunkDescriptor *chunk                = fCurrentIOState->fHeadChunk;
+                        while(chunk != NULL) {
+                            double bps = (double)(chunk->fFrameSize) / (fCurrentIOState->fQTSamplesPerFrame);
+                            if(bps < 1.0) {
+                                // I don't think a multiple-entry table would make sense in
+                                // this case, so assume a single entry table ??? #####
+                                break;
+                            }
+
+                            if(firstBPS == 0.0) {
+                                firstBPS = bps;
+                            }
+                            else if(bps != firstBPS) {
+                                haveSingleEntryTable = False;
+                                break;
+                            }
+
+                            chunk = chunk->fNextChunk;
+                        }
+
+                        unsigned sampleSize;
+                        if(haveSingleEntryTable) {
+                            if(fCurrentIOState->isHintTrack() && fCurrentIOState->fHeadChunk != NULL) {
+                                sampleSize = fCurrentIOState->fHeadChunk->fFrameSize / fCurrentIOState->fQTSamplesPerFrame;
+                            }
+                            else {
+                                // The following doesn't seem right, but seems to do the right thing:
+                                sampleSize = fCurrentIOState->fQTTimeUnitsPerSample;  //???
+                            }
+                        }
+                        else {
+                            sampleSize = 0;  // indicates a multiple-entry table
+                        }
+                        size += addWord(sampleSize);  // Sample size
+                        unsigned const totNumSamples = fCurrentIOState->fQTTotNumSamples;
+                        size += addWord(totNumSamples);  // Number of entries
+
+                        if(!haveSingleEntryTable) {
+                            // Multiple-entry table:
+                            // Run through the chunk descriptors, entering the sample sizes:
+                            ChunkDescriptor *chunk = fCurrentIOState->fHeadChunk;
+                            while(chunk != NULL) {
+                                unsigned numSamples = chunk->fNumFrames * (fCurrentIOState->fQTSamplesPerFrame);
+                                unsigned sampleSize = chunk->fFrameSize / (fCurrentIOState->fQTSamplesPerFrame);
+                                for(unsigned i = 0; i < numSamples; ++i) {
+                                    size += addWord(sampleSize);
+                                }
+
+                                chunk = chunk->fNextChunk;
+                            }
+                        }
+                        addAtomEnd;
+
+                        addAtom(co64);                                 // Chunk Offset
+                        size += addWord(0x00000000);                   // Version+flags
+                        size += addWord(fCurrentIOState->fNumChunks);  // Number of entries
+
+                        // Run through the chunk descriptors, entering the file offsets:
+                        ChunkDescriptor *chunk = fCurrentIOState->fHeadChunk;
+                        while(chunk != NULL) {
+                            size += addWord64(chunk->fOffsetInFile);
+
+                            chunk = chunk->fNextChunk;
+                        }
+                        addAtomEnd;
+
+                        addAtom(udta);
+                        size += addAtom_name();
+                        size += addAtom_hnti();
+                        size += addAtom_hinf();
+                        addAtomEnd;
+
+                        addAtom(name);
+                        char description[100];
+                        sprintf(description, "Hinted %s track", fCurrentIOState->fOurSubsession.mediumName());
+                        size += addArbitraryString(description, False);  // name of object
+                        addAtomEnd;
+
+                        addAtom(hnti);
+                        size += addAtom_sdp();
+                        addAtomEnd;
+
+                        unsigned QuickTimeFileSink::addAtom_sdp() {
+                            int64_t  initFilePosn = TellFile64(fOutFid);
+                            unsigned size         = addAtomHeader("sdp ");
+
+                            // Add this subsession's SDP lines:
+                            char const *sdpLines = fCurrentIOState->fOurSubsession.savedSDPLines();
+                            // We need to change any "a=control:trackID=" values to be this
+                            // track's actual track id:
+                            char *      newSDPLines       = new char[strlen(sdpLines) + 100 /*overkill*/];
+                            char const *searchStr         = "a=control:trackid=";
+                            Boolean     foundSearchString = False;
+                            char const *p1, *p2, *p3;
+                            for(p1 = sdpLines; *p1 != '\0'; ++p1) {
+                                for(p2 = p1, p3 = searchStr; tolower(*p2) == *p3; ++p2, ++p3) {
+                                }
+                                if(*p3 == '\0') {
+                                    // We found the end of the search string, at p2.
+                                    int beforeTrackNumPosn = p2 - sdpLines;
+                                    // Look for the subsequent track number, and skip over it:
+                                    int trackNumLength;
+                                    if(sscanf(p2, " %*d%n", &trackNumLength) < 0)
+                                        break;
+                                    int afterTrackNumPosn = beforeTrackNumPosn + trackNumLength;
+
+                                    // Replace the old track number with the correct one:
+                                    int i;
+                                    for(i = 0; i < beforeTrackNumPosn; ++i)
+                                        newSDPLines[i] = sdpLines[i];
+                                    sprintf(&newSDPLines[i], "%d", fCurrentIOState->fTrackID);
+                                    i     = afterTrackNumPosn;
+                                    int j = i + strlen(&newSDPLines[i]);
+                                    while(1) {
+                                        if((newSDPLines[j] = sdpLines[i]) == '\0')
+                                            break;
+                                        ++i;
+                                        ++j;
+                                    }
+
+                                    foundSearchString = True;
+                                    break;
+                                }
+                            }
+
+                            if(!foundSearchString) {
+                                // Because we didn't find a "a=control:trackID=<trackId>" line,
+                                // add one of our own:
+                                sprintf(newSDPLines, "%s%s%d\r\n", sdpLines, searchStr, fCurrentIOState->fTrackID);
+                            }
+
+                            size += addArbitraryString(newSDPLines, False);
+                            delete[] newSDPLines;
+                            addAtomEnd;
+
+                            addAtom(hinf);
+                            size += addAtom_totl();
+                            size += addAtom_npck();
+                            size += addAtom_tpay();
+                            size += addAtom_trpy();
+                            size += addAtom_nump();
+                            size += addAtom_tpyl();
+                            // Is 'maxr' required? #####
+                            size += addAtom_dmed();
+                            size += addAtom_dimm();
+                            size += addAtom_drep();
+                            size += addAtom_tmin();
+                            size += addAtom_tmax();
+                            size += addAtom_pmax();
+                            size += addAtom_dmax();
+                            size += addAtom_payt();
+                            addAtomEnd;
+
+                            addAtom(totl);
+                            size += addWord(fCurrentIOState->fHINF.trpy.lo);
+                            addAtomEnd;
+
+                            addAtom(npck);
+                            size += addWord(fCurrentIOState->fHINF.nump.lo);
+                            addAtomEnd;
+
+                            addAtom(tpay);
+                            size += addWord(fCurrentIOState->fHINF.tpyl.lo);
+                            addAtomEnd;
+
+                            addAtom(trpy);
+                            size += addWord(fCurrentIOState->fHINF.trpy.hi);
+                            size += addWord(fCurrentIOState->fHINF.trpy.lo);
+                            addAtomEnd;
+
+                            addAtom(nump);
+                            size += addWord(fCurrentIOState->fHINF.nump.hi);
+                            size += addWord(fCurrentIOState->fHINF.nump.lo);
+                            addAtomEnd;
+
+                            addAtom(tpyl);
+                            size += addWord(fCurrentIOState->fHINF.tpyl.hi);
+                            size += addWord(fCurrentIOState->fHINF.tpyl.lo);
+                            addAtomEnd;
+
+                            addAtom(dmed);
+                            size += addWord(fCurrentIOState->fHINF.dmed.hi);
+                            size += addWord(fCurrentIOState->fHINF.dmed.lo);
+                            addAtomEnd;
+
+                            addAtom(dimm);
+                            size += addWord(fCurrentIOState->fHINF.dimm.hi);
+                            size += addWord(fCurrentIOState->fHINF.dimm.lo);
+                            addAtomEnd;
+
+                            addAtom(drep);
+                            size += addWord(0);
+                            size += addWord(0);
+                            addAtomEnd;
+
+                            addAtom(tmin);
+                            size += addWord(0);
+                            addAtomEnd;
+
+                            addAtom(tmax);
+                            size += addWord(0);
+                            addAtomEnd;
+
+                            addAtom(pmax);
+                            size += addWord(fCurrentIOState->fHINF.pmax);
+                            addAtomEnd;
+
+                            addAtom(dmax);
+                            size += addWord(fCurrentIOState->fHINF.dmax);
+                            addAtomEnd;
+
+                            addAtom(payt);
+                            MediaSubsession &ourSubsession = fCurrentIOState->fOurSubsession;
+                            RTPSource *      rtpSource     = ourSubsession.rtpSource();
+                            if(rtpSource != NULL) {
+                                size += addWord(rtpSource->rtpPayloadFormat());
+
+                                // Also, add a 'rtpmap' string: <mime-subtype>/<rtp-frequency>
+                                unsigned rtpmapStringLength = strlen(ourSubsession.codecName()) + 20;
+                                char *   rtpmapString       = new char[rtpmapStringLength];
+                                sprintf(rtpmapString, "%s/%d", ourSubsession.codecName(), rtpSource->timestampFrequency());
+                                size += addArbitraryString(rtpmapString);
+                                delete[] rtpmapString;
+                            }
+                            addAtomEnd;
+
+                            // A dummy atom (with name "????"):
+                            unsigned QuickTimeFileSink::addAtom_dummy() {
+                                int64_t  initFilePosn = TellFile64(fOutFid);
+                                unsigned size         = addAtomHeader("????");
+                                addAtomEnd;
diff --git a/3rdparty/live555/src/liveMedia/QuickTimeGenericRTPSource.cpp b/3rdparty/live555/src/liveMedia/QuickTimeGenericRTPSource.cpp
new file mode 100644
index 00000000..b654cb47
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/QuickTimeGenericRTPSource.cpp
@@ -0,0 +1,272 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// RTP Sources containing generic QuickTime stream data, as defined in
+//     <http://developer.apple.com/quicktime/icefloe/dispatch026.html>
+// Implementation
+
+#include "QuickTimeGenericRTPSource.hh"
+
+///// QTGenericBufferedPacket and QTGenericBufferedPacketFactory /////
+
+// A subclass of BufferedPacket, used to separate out
+// individual frames (when PCK == 2)
+
+class QTGenericBufferedPacket : public BufferedPacket {
+public:
+    QTGenericBufferedPacket(QuickTimeGenericRTPSource &ourSource);
+    virtual ~QTGenericBufferedPacket();
+
+private:  // redefined virtual functions
+    virtual unsigned nextEnclosedFrameSize(unsigned char *&framePtr, unsigned dataSize);
+
+private:
+    QuickTimeGenericRTPSource &fOurSource;
+};
+
+class QTGenericBufferedPacketFactory : public BufferedPacketFactory {
+private:  // redefined virtual functions
+    virtual BufferedPacket *createNewPacket(MultiFramedRTPSource *ourSource);
+};
+
+////////// QuickTimeGenericRTPSource //////////
+
+QuickTimeGenericRTPSource *QuickTimeGenericRTPSource::createNew(UsageEnvironment &env, Groupsock *RTPgs, unsigned char rtpPayloadFormat,
+                                                                unsigned rtpTimestampFrequency, char const *mimeTypeString) {
+    return new QuickTimeGenericRTPSource(env, RTPgs, rtpPayloadFormat, rtpTimestampFrequency, mimeTypeString);
+}
+
+QuickTimeGenericRTPSource ::QuickTimeGenericRTPSource(UsageEnvironment &env, Groupsock *RTPgs, unsigned char rtpPayloadFormat, unsigned rtpTimestampFrequency,
+                                                      char const *mimeTypeString)
+    : MultiFramedRTPSource(env, RTPgs, rtpPayloadFormat, rtpTimestampFrequency, new QTGenericBufferedPacketFactory), fMIMEtypeString(strDup(mimeTypeString)) {
+    qtState.PCK        = 0;
+    qtState.timescale  = 0;
+    qtState.sdAtom     = NULL;
+    qtState.sdAtomSize = qtState.width = qtState.height = 0;
+}
+
+QuickTimeGenericRTPSource::~QuickTimeGenericRTPSource() {
+    delete[] qtState.sdAtom;
+    delete[](char *) fMIMEtypeString;
+}
+
+Boolean QuickTimeGenericRTPSource ::processSpecialHeader(BufferedPacket *packet, unsigned &resultSpecialHeaderSize) {
+    unsigned char *headerStart = packet->data();
+    unsigned       packetSize  = packet->dataSize();
+
+    // The "QuickTime Header" must be at least 4 bytes in size:
+    // Extract the known fields from the first 4 bytes:
+    unsigned expectedHeaderSize = 4;
+    if(packetSize < expectedHeaderSize)
+        return False;
+
+    unsigned char VER = (headerStart[0] & 0xF0) >> 4;
+    if(VER > 1)
+        return False;  // unknown header version
+    qtState.PCK = (headerStart[0] & 0x0C) >> 2;
+#ifdef DEBUG
+    Boolean S = (headerStart[0] & 0x02) != 0;
+#endif
+    Boolean Q = (headerStart[0] & 0x01) != 0;
+
+    Boolean L = (headerStart[1] & 0x80) != 0;
+
+#ifdef DEBUG
+    Boolean        D         = (headerStart[2] & 0x80) != 0;
+    unsigned short payloadId = ((headerStart[2] & 0x7F) << 8) | headerStart[3];
+#endif
+    headerStart += 4;
+
+#ifdef DEBUG
+    fprintf(stderr, "PCK: %d, S: %d, Q: %d, L: %d, D: %d, payloadId: %d\n", qtState.PCK, S, Q, L, D, payloadId);
+#endif
+
+    if(Q) {  // A "QuickTime Payload Description" follows
+        expectedHeaderSize += 4;
+        if(packetSize < expectedHeaderSize)
+            return False;
+
+#ifdef DEBUG
+        Boolean K = (headerStart[0] & 0x80) != 0;
+        Boolean F = (headerStart[0] & 0x40) != 0;
+        Boolean A = (headerStart[0] & 0x20) != 0;
+        Boolean Z = (headerStart[0] & 0x10) != 0;
+#endif
+        unsigned payloadDescriptionLength = (headerStart[2] << 8) | headerStart[3];
+        headerStart += 4;
+
+#ifdef DEBUG
+        fprintf(stderr, "\tK: %d, F: %d, A: %d, Z: %d, payloadDescriptionLength: %d\n", K, F, A, Z, payloadDescriptionLength);
+#endif
+        // Make sure "payloadDescriptionLength" is valid
+        if(payloadDescriptionLength < 12)
+            return False;
+        expectedHeaderSize += (payloadDescriptionLength - 4);
+        unsigned nonPaddedSize = expectedHeaderSize;
+        expectedHeaderSize += 3;
+        expectedHeaderSize -= expectedHeaderSize % 4;  // adds padding
+        if(packetSize < expectedHeaderSize)
+            return False;
+        unsigned char padding = expectedHeaderSize - nonPaddedSize;
+
+#ifdef DEBUG
+        unsigned mediaType = (headerStart[0] << 24) | (headerStart[1] << 16) | (headerStart[2] << 8) | headerStart[3];
+#endif
+        qtState.timescale = (headerStart[4] << 24) | (headerStart[5] << 16) | (headerStart[6] << 8) | headerStart[7];
+        headerStart += 8;
+
+        payloadDescriptionLength -= 12;
+#ifdef DEBUG
+        fprintf(stderr, "\tmediaType: '%c%c%c%c', timescale: %d, %d bytes of TLVs left\n", mediaType >> 24, (mediaType & 0xFF0000) >> 16,
+                (mediaType & 0xFF00) >> 8, mediaType & 0xFF, qtState.timescale, payloadDescriptionLength);
+#endif
+
+        while(payloadDescriptionLength > 3) {
+            unsigned short tlvLength = (headerStart[0] << 8) | headerStart[1];
+            unsigned short tlvType   = (headerStart[2] << 8) | headerStart[3];
+            payloadDescriptionLength -= 4;
+            if(tlvLength > payloadDescriptionLength)
+                return False;  // bad TLV
+            headerStart += 4;
+#ifdef DEBUG
+            fprintf(stderr, "\t\tTLV '%c%c', length %d, leaving %d remaining bytes\n", tlvType >> 8, tlvType & 0xFF, tlvLength,
+                    payloadDescriptionLength - tlvLength);
+            for(int i = 0; i < tlvLength; ++i)
+                fprintf(stderr, "%02x:", headerStart[i]);
+            fprintf(stderr, "\n");
+#endif
+
+            // Check for 'TLV's that we can use for our 'qtState'
+            switch(tlvType) {
+            case('s' << 8 | 'd'): {  // session description atom
+                // Sanity check: the first 4 bytes of this must equal "tlvLength":
+                unsigned atomLength = (headerStart[0] << 24) | (headerStart[1] << 16) | (headerStart[2] << 8) | (headerStart[3]);
+                if(atomLength != (unsigned)tlvLength)
+                    break;
+
+                delete[] qtState.sdAtom;
+                qtState.sdAtom = new char[tlvLength];
+                memmove(qtState.sdAtom, headerStart, tlvLength);
+                qtState.sdAtomSize = tlvLength;
+                break;
+            }
+            case('t' << 8 | 'w'): {  // track width
+                qtState.width = (headerStart[0] << 8) | headerStart[1];
+                break;
+            }
+            case('t' << 8 | 'h'): {  // track height
+                qtState.height = (headerStart[0] << 8) | headerStart[1];
+                break;
+            }
+            }
+
+            payloadDescriptionLength -= tlvLength;
+            headerStart += tlvLength;
+        }
+        if(payloadDescriptionLength > 0)
+            return False;  // malformed TLV data
+        headerStart += padding;
+    }
+
+    if(L) {  // Sample-Specific info follows
+        expectedHeaderSize += 4;
+        if(packetSize < expectedHeaderSize)
+            return False;
+
+        unsigned ssInfoLength = (headerStart[2] << 8) | headerStart[3];
+        headerStart += 4;
+
+#ifdef DEBUG
+        fprintf(stderr, "\tssInfoLength: %d\n", ssInfoLength);
+#endif
+        // Make sure "ssInfoLength" is valid
+        if(ssInfoLength < 4)
+            return False;
+        expectedHeaderSize += (ssInfoLength - 4);
+        unsigned nonPaddedSize = expectedHeaderSize;
+        expectedHeaderSize += 3;
+        expectedHeaderSize -= expectedHeaderSize % 4;  // adds padding
+        if(packetSize < expectedHeaderSize)
+            return False;
+        unsigned char padding = expectedHeaderSize - nonPaddedSize;
+
+        ssInfoLength -= 4;
+        while(ssInfoLength > 3) {
+            unsigned short tlvLength = (headerStart[0] << 8) | headerStart[1];
+#ifdef DEBUG
+            unsigned short tlvType = (headerStart[2] << 8) | headerStart[3];
+#endif
+            ssInfoLength -= 4;
+            if(tlvLength > ssInfoLength)
+                return False;  // bad TLV
+#ifdef DEBUG
+            fprintf(stderr, "\t\tTLV '%c%c', length %d, leaving %d remaining bytes\n", tlvType >> 8, tlvType & 0xFF, tlvLength, ssInfoLength - tlvLength);
+            for(int i = 0; i < tlvLength; ++i)
+                fprintf(stderr, "%02x:", headerStart[4 + i]);
+            fprintf(stderr, "\n");
+#endif
+            ssInfoLength -= tlvLength;
+            headerStart += 4 + tlvLength;
+        }
+        if(ssInfoLength > 0)
+            return False;  // malformed TLV data
+        headerStart += padding;
+    }
+
+    fCurrentPacketBeginsFrame = fCurrentPacketCompletesFrame;
+    // whether the *previous* packet ended a frame
+    fCurrentPacketCompletesFrame = packet->rtpMarkerBit();
+
+    resultSpecialHeaderSize = expectedHeaderSize;
+#ifdef DEBUG
+    fprintf(stderr, "Result special header size: %d\n", resultSpecialHeaderSize);
+#endif
+    return True;
+}
+
+char const *QuickTimeGenericRTPSource::MIMEtype() const {
+    if(fMIMEtypeString == NULL)
+        return MultiFramedRTPSource::MIMEtype();
+
+    return fMIMEtypeString;
+}
+
+////////// QTGenericBufferedPacket and QTGenericBufferedPacketFactory impl
+
+QTGenericBufferedPacket ::QTGenericBufferedPacket(QuickTimeGenericRTPSource &ourSource) : fOurSource(ourSource) {}
+
+QTGenericBufferedPacket::~QTGenericBufferedPacket() {}
+
+unsigned QTGenericBufferedPacket::nextEnclosedFrameSize(unsigned char *&framePtr, unsigned dataSize) {
+    // We use the entire packet for a frame, unless "PCK" == 2
+    if(fOurSource.qtState.PCK != 2)
+        return dataSize;
+
+    if(dataSize < 8)
+        return 0;  // sanity check
+
+    unsigned short sampleLength = (framePtr[2] << 8) | framePtr[3];
+    // later, extract and use the "timestamp" field #####
+    framePtr += 8;
+    dataSize -= 8;
+
+    return sampleLength < dataSize ? sampleLength : dataSize;
+}
+
+BufferedPacket *QTGenericBufferedPacketFactory ::createNewPacket(MultiFramedRTPSource *ourSource) {
+    return new QTGenericBufferedPacket((QuickTimeGenericRTPSource &)(*ourSource));
+}
diff --git a/3rdparty/live555/src/liveMedia/RTCP.cpp b/3rdparty/live555/src/liveMedia/RTCP.cpp
new file mode 100644
index 00000000..8375d5fa
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/RTCP.cpp
@@ -0,0 +1,1441 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// RTCP
+// Implementation
+
+#include "RTCP.hh"
+#include "GroupsockHelper.hh"
+#include "rtcp_from_spec.h"
+#if defined(__WIN32__) || defined(_WIN32) || defined(_QNX4)
+#define snprintf _snprintf
+#endif
+
+////////// RTCPMemberDatabase //////////
+
+class RTCPMemberDatabase {
+public:
+    RTCPMemberDatabase(RTCPInstance &ourRTCPInstance)
+        : fOurRTCPInstance(ourRTCPInstance), fNumMembers(1 /*ourself*/), fTable(HashTable::create(ONE_WORD_HASH_KEYS)) {}
+
+    virtual ~RTCPMemberDatabase() {
+        delete fTable;
+    }
+
+    Boolean isMember(u_int32_t ssrc) const {
+        return fTable->Lookup((char *)(long)ssrc) != NULL;
+    }
+
+    Boolean noteMembership(u_int32_t ssrc, unsigned curTimeCount) {
+        Boolean isNew = !isMember(ssrc);
+
+        if(isNew) {
+            ++fNumMembers;
+        }
+
+        // Record the current time, so we can age stale members
+        fTable->Add((char *)(long)ssrc, (void *)(long)curTimeCount);
+
+        return isNew;
+    }
+
+    Boolean remove(u_int32_t ssrc) {
+        Boolean wasPresent = fTable->Remove((char *)(long)ssrc);
+        if(wasPresent) {
+            --fNumMembers;
+        }
+        return wasPresent;
+    }
+
+    unsigned numMembers() const {
+        return fNumMembers;
+    }
+
+    void reapOldMembers(unsigned threshold);
+
+private:
+    RTCPInstance &fOurRTCPInstance;
+    unsigned      fNumMembers;
+    HashTable *   fTable;
+};
+
+void RTCPMemberDatabase::reapOldMembers(unsigned threshold) {
+    Boolean   foundOldMember;
+    u_int32_t oldSSRC = 0;
+
+    do {
+        foundOldMember = False;
+
+        HashTable::Iterator *iter = HashTable::Iterator::create(*fTable);
+        uintptr_t            timeCount;
+        char const *         key;
+        while((timeCount = (uintptr_t)(iter->next(key))) != 0) {
+#ifdef DEBUG
+            fprintf(stderr, "reap: checking SSRC 0x%lx: %ld (threshold %d)\n", (unsigned long)key, timeCount, threshold);
+#endif
+            if(timeCount < (uintptr_t)threshold) {  // this SSRC is old
+                uintptr_t ssrc = (uintptr_t)key;
+                oldSSRC        = (u_int32_t)ssrc;
+                foundOldMember = True;
+            }
+        }
+        delete iter;
+
+        if(foundOldMember) {
+#ifdef DEBUG
+            fprintf(stderr, "reap: removing SSRC 0x%x\n", oldSSRC);
+#endif
+            fOurRTCPInstance.removeSSRC(oldSSRC, True);
+        }
+    } while(foundOldMember);
+}
+
+////////// RTCPInstance //////////
+
+static double dTimeNow() {
+    struct timeval timeNow;
+    gettimeofday(&timeNow, NULL);
+    return (double)(timeNow.tv_sec + timeNow.tv_usec / 1000000.0);
+}
+
+static unsigned const maxRTCPPacketSize = 1438;
+// bytes (1500, minus some allowance for IP, UDP headers; SRTCP trailers)
+static unsigned const preferredRTCPPacketSize = 1000;  // bytes
+
+RTCPInstance::RTCPInstance(UsageEnvironment &env, Groupsock *RTCPgs, unsigned totSessionBW, unsigned char const *cname, RTPSink *sink, RTPSource *source,
+                           Boolean isSSMTransmitter, SRTPCryptographicContext *crypto)
+    : Medium(env),
+      fRTCPInterface(this, RTCPgs),
+      fTotSessionBW(totSessionBW),
+      fSink(sink),
+      fSource(source),
+      fIsSSMTransmitter(isSSMTransmitter),
+      fCrypto(crypto),
+      fCNAME(RTCP_SDES_CNAME, cname),
+      fOutgoingReportCount(1),
+      fAveRTCPSize(0),
+      fIsInitial(1),
+      fPrevNumMembers(0),
+      fLastSentSize(0),
+      fLastReceivedSize(0),
+      fLastReceivedSSRC(0),
+      fTypeOfEvent(EVENT_UNKNOWN),
+      fTypeOfPacket(PACKET_UNKNOWN_TYPE),
+      fHaveJustSentPacket(False),
+      fLastPacketSentSize(0),
+      fByeHandlerTask(NULL),
+      fByeWithReasonHandlerTask(NULL),
+      fByeHandlerClientData(NULL),
+      fSRHandlerTask(NULL),
+      fSRHandlerClientData(NULL),
+      fRRHandlerTask(NULL),
+      fRRHandlerClientData(NULL),
+      fSpecificRRHandlerTable(NULL),
+      fAppHandlerTask(NULL),
+      fAppHandlerClientData(NULL) {
+#ifdef DEBUG
+    fprintf(stderr, "RTCPInstance[%p]::RTCPInstance()\n", this);
+#endif
+    setupForSRTCP();
+
+    if(fTotSessionBW == 0) {  // not allowed!
+        env << "RTCPInstance::RTCPInstance error: totSessionBW parameter should not be zero!\n";
+        fTotSessionBW = 1;
+    }
+
+    if(isSSMTransmitter)
+        RTCPgs->multicastSendOnly();  // don't receive multicast
+
+    double timeNow  = dTimeNow();
+    fPrevReportTime = fNextReportTime = timeNow;
+
+    fKnownMembers = new RTCPMemberDatabase(*this);
+    fInBuf        = new unsigned char[maxRTCPPacketSize];
+    if(fKnownMembers == NULL || fInBuf == NULL)
+        return;
+    fNumBytesAlreadyRead = 0;
+
+    fOutBuf = new OutPacketBuffer(preferredRTCPPacketSize, maxRTCPPacketSize, 1500);
+    if(fOutBuf == NULL)
+        return;
+
+    if(fSource != NULL && fSource->RTPgs() == RTCPgs) {
+        // We're receiving RTCP reports that are multiplexed with RTP, so ask the RTP source
+        // to give them to us:
+        fSource->registerForMultiplexedRTCPPackets(this);
+    }
+    else {
+        // Arrange to handle incoming reports from the network:
+        TaskScheduler::BackgroundHandlerProc *handler = (TaskScheduler::BackgroundHandlerProc *)&incomingReportHandler;
+        fRTCPInterface.startNetworkReading(handler);
+    }
+
+    // Send our first report.
+    fTypeOfEvent = EVENT_REPORT;
+    onExpire(this);
+}
+
+struct RRHandlerRecord {
+    TaskFunc *rrHandlerTask;
+    void *    rrHandlerClientData;
+};
+
+RTCPInstance::~RTCPInstance() {
+#ifdef DEBUG
+    fprintf(stderr, "RTCPInstance[%p]::~RTCPInstance()\n", this);
+#endif
+    // Begin by sending a BYE.  We have to do this immediately, without
+    // 'reconsideration', because "this" is going away.
+    fTypeOfEvent = EVENT_BYE;  // not used, but...
+    sendBYE();
+
+    if(fSource != NULL && fSource->RTPgs() == fRTCPInterface.gs()) {
+        // We were receiving RTCP reports that were multiplexed with RTP, so tell the RTP source
+        // to stop giving them to us:
+        fSource->deregisterForMultiplexedRTCPPackets();
+        fRTCPInterface.forgetOurGroupsock();
+        // so that the "fRTCPInterface" destructor doesn't turn off background read handling
+    }
+
+    if(fSpecificRRHandlerTable != NULL) {
+        AddressPortLookupTable::Iterator iter(*fSpecificRRHandlerTable);
+        RRHandlerRecord *                rrHandler;
+        while((rrHandler = (RRHandlerRecord *)iter.next()) != NULL) {
+            delete rrHandler;
+        }
+        delete fSpecificRRHandlerTable;
+    }
+
+    delete fKnownMembers;
+    delete fOutBuf;
+    delete[] fInBuf;
+}
+
+void RTCPInstance::noteArrivingRR(struct sockaddr_storage const &fromAddressAndPort, int tcpSocketNum, unsigned char tcpStreamChannelId) {
+    // If a 'RR handler' was set, call it now:
+
+    // Specific RR handler:
+    if(fSpecificRRHandlerTable != NULL) {
+        struct sockaddr_storage fromAddress;
+        portNumBits             fromPortNum;
+        if(tcpSocketNum < 0) {
+            // Normal case: We read the RTCP packet over UDP
+            fromAddress = fromAddressAndPort;
+            fromPortNum = ntohs(portNum(fromAddressAndPort));
+        }
+        else {
+            // Special case: We read the RTCP packet over TCP (interleaved)
+            // Hack: Use the TCP socket number and channel id to look up the handler
+            fromAddress.ss_family                        = AF_INET;
+            ((sockaddr_in &)fromAddress).sin_addr.s_addr = tcpSocketNum;
+            fromPortNum                                  = tcpStreamChannelId;
+        }
+        Port             fromPort(fromPortNum);
+        RRHandlerRecord *rrHandler = (RRHandlerRecord *)(fSpecificRRHandlerTable->Lookup(fromAddress, fromPort));
+        if(rrHandler != NULL) {
+            if(rrHandler->rrHandlerTask != NULL) {
+                (*(rrHandler->rrHandlerTask))(rrHandler->rrHandlerClientData);
+            }
+        }
+    }
+
+    // General RR handler:
+    if(fRRHandlerTask != NULL)
+        (*fRRHandlerTask)(fRRHandlerClientData);
+}
+
+RTCPInstance *RTCPInstance::createNew(UsageEnvironment &env, Groupsock *RTCPgs, unsigned totSessionBW, unsigned char const *cname, RTPSink *sink,
+                                      RTPSource *source, Boolean isSSMTransmitter, SRTPCryptographicContext *crypt) {
+    return new RTCPInstance(env, RTCPgs, totSessionBW, cname, sink, source, isSSMTransmitter, crypt);
+}
+
+Boolean RTCPInstance::lookupByName(UsageEnvironment &env, char const *instanceName, RTCPInstance *&resultInstance) {
+    resultInstance = NULL;  // unless we succeed
+
+    Medium *medium;
+    if(!Medium::lookupByName(env, instanceName, medium))
+        return False;
+
+    if(!medium->isRTCPInstance()) {
+        env.setResultMsg(instanceName, " is not a RTCP instance");
+        return False;
+    }
+
+    resultInstance = (RTCPInstance *)medium;
+    return True;
+}
+
+Boolean RTCPInstance::isRTCPInstance() const {
+    return True;
+}
+
+unsigned RTCPInstance::numMembers() const {
+    if(fKnownMembers == NULL)
+        return 0;
+
+    return fKnownMembers->numMembers();
+}
+
+void RTCPInstance::setupForSRTCP() {
+    if(fCrypto == NULL && fSink != NULL) {  // take crypto state (if any) from the sink instead:
+        fCrypto = fSink->getCrypto();
+    }
+}
+
+void RTCPInstance::setByeHandler(TaskFunc *handlerTask, void *clientData, Boolean handleActiveParticipantsOnly) {
+    fByeHandlerTask                  = handlerTask;
+    fByeWithReasonHandlerTask        = NULL;
+    fByeHandlerClientData            = clientData;
+    fByeHandleActiveParticipantsOnly = handleActiveParticipantsOnly;
+}
+
+void RTCPInstance::setByeWithReasonHandler(ByeWithReasonHandlerFunc *handlerTask, void *clientData, Boolean handleActiveParticipantsOnly) {
+    fByeHandlerTask                  = NULL;
+    fByeWithReasonHandlerTask        = handlerTask;
+    fByeHandlerClientData            = clientData;
+    fByeHandleActiveParticipantsOnly = handleActiveParticipantsOnly;
+}
+
+void RTCPInstance::setSRHandler(TaskFunc *handlerTask, void *clientData) {
+    fSRHandlerTask       = handlerTask;
+    fSRHandlerClientData = clientData;
+}
+
+void RTCPInstance::setRRHandler(TaskFunc *handlerTask, void *clientData) {
+    fRRHandlerTask       = handlerTask;
+    fRRHandlerClientData = clientData;
+}
+
+void RTCPInstance ::setSpecificRRHandler(struct sockaddr_storage const &fromAddress, Port fromPort, TaskFunc *handlerTask, void *clientData) {
+    if(handlerTask == NULL && clientData == NULL) {
+        unsetSpecificRRHandler(fromAddress, fromPort);
+        return;
+    }
+
+    RRHandlerRecord *rrHandler     = new RRHandlerRecord;
+    rrHandler->rrHandlerTask       = handlerTask;
+    rrHandler->rrHandlerClientData = clientData;
+    if(fSpecificRRHandlerTable == NULL) {
+        fSpecificRRHandlerTable = new AddressPortLookupTable;
+    }
+    RRHandlerRecord *existingRecord = (RRHandlerRecord *)fSpecificRRHandlerTable->Add(fromAddress, fromPort, rrHandler);
+    delete existingRecord;  // if any
+}
+
+void RTCPInstance ::unsetSpecificRRHandler(struct sockaddr_storage const &fromAddress, Port fromPort) {
+    if(fSpecificRRHandlerTable == NULL)
+        return;
+
+    RRHandlerRecord *rrHandler = (RRHandlerRecord *)(fSpecificRRHandlerTable->Lookup(fromAddress, fromPort));
+    if(rrHandler != NULL) {
+        fSpecificRRHandlerTable->Remove(fromAddress, fromPort);
+        delete rrHandler;
+    }
+}
+
+void RTCPInstance::setAppHandler(RTCPAppHandlerFunc *handlerTask, void *clientData) {
+    fAppHandlerTask       = handlerTask;
+    fAppHandlerClientData = clientData;
+}
+
+void RTCPInstance::sendAppPacket(u_int8_t subtype, char const *name, u_int8_t *appDependentData, unsigned appDependentDataSize) {
+    // Set up the first 4 bytes: V,PT,subtype,PT,length:
+    u_int32_t rtcpHdr = 0x80000000;  // version 2, no padding
+    rtcpHdr |= (subtype & 0x1F) << 24;
+    rtcpHdr |= (RTCP_PT_APP << 16);
+    unsigned length = 2 + (appDependentDataSize + 3) / 4;
+    rtcpHdr |= (length & 0xFFFF);
+    fOutBuf->enqueueWord(rtcpHdr);
+
+    // Set up the next 4 bytes: SSRC:
+    fOutBuf->enqueueWord(fSource != NULL ? fSource->SSRC() : fSink != NULL ? fSink->SSRC() : 0);
+
+    // Set up the next 4 bytes: name:
+    char nameBytes[4];
+    nameBytes[0] = nameBytes[1] = nameBytes[2] = nameBytes[3] = '\0';  // by default
+    if(name != NULL) {
+        snprintf(nameBytes, 4, "%s", name);
+    }
+    fOutBuf->enqueue((u_int8_t *)nameBytes, 4);
+
+    // Set up the remaining bytes (if any): application-dependent data (+ padding):
+    if(appDependentData != NULL && appDependentDataSize > 0) {
+        fOutBuf->enqueue(appDependentData, appDependentDataSize);
+
+        unsigned       modulo      = appDependentDataSize % 4;
+        unsigned       paddingSize = modulo == 0 ? 0 : 4 - modulo;
+        u_int8_t const paddingByte = 0x00;
+        for(unsigned i = 0; i < paddingSize; ++i)
+            fOutBuf->enqueue(&paddingByte, 1);
+    }
+
+    // Finally, send the packet:
+    sendBuiltPacket();
+}
+
+void RTCPInstance::setStreamSocket(int sockNum, unsigned char streamChannelId, TLSState *tlsState) {
+    // Turn off background read handling:
+    fRTCPInterface.stopNetworkReading();
+
+    // Switch to RTCP-over-TCP:
+    fRTCPInterface.setStreamSocket(sockNum, streamChannelId, tlsState);
+
+    // Turn background reading back on:
+    TaskScheduler::BackgroundHandlerProc *handler = (TaskScheduler::BackgroundHandlerProc *)&incomingReportHandler;
+    fRTCPInterface.startNetworkReading(handler);
+}
+
+void RTCPInstance::addStreamSocket(int sockNum, unsigned char streamChannelId, TLSState *tlsState) {
+    // First, turn off background read handling for the default (UDP) socket:
+    envir().taskScheduler().turnOffBackgroundReadHandling(fRTCPInterface.gs()->socketNum());
+
+    // Add the RTCP-over-TCP interface:
+    fRTCPInterface.addStreamSocket(sockNum, streamChannelId, tlsState);
+
+    // Turn on background reading for this socket (in case it's not on already):
+    TaskScheduler::BackgroundHandlerProc *handler = (TaskScheduler::BackgroundHandlerProc *)&incomingReportHandler;
+    fRTCPInterface.startNetworkReading(handler);
+}
+
+void RTCPInstance ::injectReport(u_int8_t const *packet, unsigned packetSize, struct sockaddr_storage const &fromAddress) {
+    if(packetSize > maxRTCPPacketSize)
+        packetSize = maxRTCPPacketSize;
+    memmove(fInBuf, packet, packetSize);
+
+    processIncomingReport(packetSize, fromAddress, -1, 0xFF);  // assume report received over UDP
+}
+
+static unsigned const IP_UDP_HDR_SIZE = 28;
+// overhead (bytes) of IP and UDP hdrs
+
+#define ADVANCE(n) \
+    pkt += (n);    \
+    packetSize -= (n)
+
+void RTCPInstance::incomingReportHandler(RTCPInstance *instance, int /*mask*/) {
+    instance->incomingReportHandler1();
+}
+
+void RTCPInstance::incomingReportHandler1() {
+    do {
+        if(fNumBytesAlreadyRead >= maxRTCPPacketSize) {
+            envir() << "RTCPInstance error: Hit limit when reading incoming packet over TCP. (fNumBytesAlreadyRead (" << fNumBytesAlreadyRead
+                    << ") >= maxRTCPPacketSize (" << maxRTCPPacketSize
+                    << ")).  The remote endpoint is using a buggy implementation of RTP/RTCP-over-TCP.  Please upgrade it!\n";
+            break;
+        }
+
+        unsigned                numBytesRead;
+        struct sockaddr_storage fromAddress;
+        int                     tcpSocketNum;
+        unsigned char           tcpStreamChannelId;
+        Boolean                 packetReadWasIncomplete;
+        Boolean readResult = fRTCPInterface.handleRead(&fInBuf[fNumBytesAlreadyRead], maxRTCPPacketSize - fNumBytesAlreadyRead, numBytesRead, fromAddress,
+                                                       tcpSocketNum, tcpStreamChannelId, packetReadWasIncomplete);
+
+        unsigned packetSize = 0;
+        if(packetReadWasIncomplete) {
+            fNumBytesAlreadyRead += numBytesRead;
+            return;  // more reads are needed to get the entire packet
+        }
+        else {  // normal case: We've read the entire packet
+            packetSize           = fNumBytesAlreadyRead + numBytesRead;
+            fNumBytesAlreadyRead = 0;  // for next time
+        }
+        if(!readResult)
+            break;
+
+        // Ignore the packet if it was looped-back from ourself:
+        Boolean packetWasFromOurHost = False;
+        if(RTCPgs()->wasLoopedBackFromUs(envir(), fromAddress)) {
+            packetWasFromOurHost = True;
+            // However, we still want to handle incoming RTCP packets from
+            // *other processes* on the same machine.  To distinguish this
+            // case from a true loop-back, check whether we've just sent a
+            // packet of the same size.  (This check isn't perfect, but it seems
+            // to be the best we can do.)
+            if(fHaveJustSentPacket && fLastPacketSentSize == packetSize) {
+                // This is a true loop-back:
+                fHaveJustSentPacket = False;
+                break;  // ignore this packet
+            }
+        }
+
+        if(fIsSSMTransmitter && !packetWasFromOurHost) {
+            // This packet is assumed to have been received via unicast (because we're
+            // a SSM transmitter, and SSM receivers send back RTCP "RR" packets via unicast).
+            // 'Reflect' the packet by resending it to the multicast group, so that any other receivers
+            // can also get to see it.
+
+            // NOTE: Denial-of-service attacks are possible here.
+            // Users of this software may wish to add their own,
+            // application-specific mechanism for 'authenticating' the
+            // validity of this packet before reflecting it.
+
+            // NOTE: The test for "!packetWasFromOurHost" means that we won't reflect RTCP packets
+            // that come from other processes on the same host as us.  The reason for this is that the
+            // 'packet size' test above is not 100% reliable; some packets that were truly looped back
+            // from us might not be detected as such, and this might lead to infinite
+            // forwarding/receiving of some packets.  To avoid this possibility, we reflect only
+            // RTCP packets that we know for sure originated elsewhere.
+            // (Note, though, that if we ever re-enable the code in "Groupsock::multicastSendOnly()",
+            // then we could remove the test for "!packetWasFromOurHost".)
+            fRTCPInterface.sendPacket(fInBuf, packetSize);
+            fHaveJustSentPacket = True;
+            fLastPacketSentSize = packetSize;
+        }
+
+        processIncomingReport(packetSize, fromAddress, tcpSocketNum, tcpStreamChannelId);
+    } while(0);
+}
+
+void RTCPInstance ::processIncomingReport(unsigned packetSize, struct sockaddr_storage const &fromAddressAndPort, int tcpSocketNum,
+                                          unsigned char tcpStreamChannelId) {
+    do {
+        if(fCrypto != NULL) {  // The packet is assumed to be SRTCP.  Verify/decrypt it first:
+            unsigned newPacketSize;
+            if(!fCrypto->processIncomingSRTCPPacket(fInBuf, packetSize, newPacketSize))
+                break;
+            packetSize = newPacketSize;
+        }
+
+        Boolean        callByeHandler = False;
+        char *         reason         = NULL;  // by default, unless/until a BYE packet with a 'reason' arrives
+        unsigned char *pkt            = fInBuf;
+
+#ifdef DEBUG
+        fprintf(stderr, "[%p]saw incoming RTCP packet (from ", this);
+        if(tcpSocketNum < 0) {
+            // Note that "fromAddressAndPort" is valid only if we're receiving over UDP (not over TCP):
+            fprintf(stderr, "address %s, port %d", AddressString(fromAddressAndPort).val(), ntohs(portNum(fromAddressAndPort)));
+        }
+        else {
+            fprintf(stderr, "TCP socket #%d, stream channel id %d", tcpSocketNum, tcpStreamChannelId);
+        }
+        fprintf(stderr, ")\n");
+        for(unsigned i = 0; i < packetSize; ++i) {
+            if(i % 4 == 0)
+                fprintf(stderr, " ");
+            fprintf(stderr, "%02x", pkt[i]);
+        }
+        fprintf(stderr, "\n");
+#endif
+        int totPacketSize = IP_UDP_HDR_SIZE + packetSize;
+
+        // Check the RTCP packet for validity:
+        // It must at least contain a header (4 bytes), and this header
+        // must be version=2, with no padding bit, and a payload type of
+        // SR (200), RR (201), or APP (204):
+        if(packetSize < 4)
+            break;
+        unsigned rtcpHdr = ntohl(*(u_int32_t *)pkt);
+        if((rtcpHdr & 0xE0FE0000) != (0x80000000 | (RTCP_PT_SR << 16)) && (rtcpHdr & 0xE0FF0000) != (0x80000000 | (RTCP_PT_APP << 16))) {
+#ifdef DEBUG
+            fprintf(stderr, "rejected bad RTCP packet: header 0x%08x\n", rtcpHdr);
+#endif
+            break;
+        }
+
+        // Process each of the individual RTCP 'subpackets' in (what may be)
+        // a compound RTCP packet.
+        int      typeOfPacket     = PACKET_UNKNOWN_TYPE;
+        unsigned reportSenderSSRC = 0;
+        Boolean  packetOK         = False;
+        while(1) {
+            u_int8_t rc     = (rtcpHdr >> 24) & 0x1F;
+            u_int8_t pt     = (rtcpHdr >> 16) & 0xFF;
+            unsigned length = 4 * (rtcpHdr & 0xFFFF);  // doesn't count hdr
+            ADVANCE(4);                                // skip over the header
+            if(length > packetSize)
+                break;
+
+            // Assume that each RTCP subpacket begins with a 4-byte SSRC:
+            if(length < 4)
+                break;
+            length -= 4;
+            reportSenderSSRC = ntohl(*(u_int32_t *)pkt);
+            ADVANCE(4);
+#ifdef HACK_FOR_CHROME_WEBRTC_BUG
+            if(reportSenderSSRC == 0x00000001 && pt == RTCP_PT_RR) {
+                // Chrome (and Opera) WebRTC receivers have a bug that causes them to always send
+                // SSRC 1 in their "RR"s.  To work around this (to help us distinguish between different
+                // receivers), we use a fake SSRC in this case consisting of the IP address, XORed with
+                // the port number:
+                reportSenderSSRC = fromAddressAndPort.sin_addr.s_addr ^ portNum(fromAddressAndPort);
+            }
+#endif
+
+            Boolean subPacketOK = False;
+            switch(pt) {
+            case RTCP_PT_SR: {
+#ifdef DEBUG
+                fprintf(stderr, "SR\n");
+#endif
+                if(length < 20)
+                    break;
+                length -= 20;
+
+                // Extract the NTP timestamp, and note this:
+                unsigned NTPmsw = ntohl(*(u_int32_t *)pkt);
+                ADVANCE(4);
+                unsigned NTPlsw = ntohl(*(u_int32_t *)pkt);
+                ADVANCE(4);
+                unsigned rtpTimestamp = ntohl(*(u_int32_t *)pkt);
+                ADVANCE(4);
+                if(fSource != NULL) {
+                    RTPReceptionStatsDB &receptionStats = fSource->receptionStatsDB();
+                    receptionStats.noteIncomingSR(reportSenderSSRC, NTPmsw, NTPlsw, rtpTimestamp);
+                }
+                ADVANCE(8);  // skip over packet count, octet count
+
+                // If a 'SR handler' was set, call it now:
+                if(fSRHandlerTask != NULL)
+                    (*fSRHandlerTask)(fSRHandlerClientData);
+
+                // The rest of the SR is handled like a RR (so, no "break;" here)
+            }
+            case RTCP_PT_RR: {
+#ifdef DEBUG
+                fprintf(stderr, "RR\n");
+#endif
+                unsigned reportBlocksSize = rc * (6 * 4);
+                if(length < reportBlocksSize)
+                    break;
+                length -= reportBlocksSize;
+
+                if(fSink != NULL) {
+                    // Use this information to update stats about our transmissions:
+                    RTPTransmissionStatsDB &transmissionStats = fSink->transmissionStatsDB();
+                    for(unsigned i = 0; i < rc; ++i) {
+                        unsigned senderSSRC = ntohl(*(u_int32_t *)pkt);
+                        ADVANCE(4);
+                        // We care only about reports about our own transmission, not others'
+                        if(senderSSRC == fSink->SSRC()) {
+                            unsigned lossStats = ntohl(*(u_int32_t *)pkt);
+                            ADVANCE(4);
+                            unsigned highestReceived = ntohl(*(u_int32_t *)pkt);
+                            ADVANCE(4);
+                            unsigned jitter = ntohl(*(u_int32_t *)pkt);
+                            ADVANCE(4);
+                            unsigned timeLastSR = ntohl(*(u_int32_t *)pkt);
+                            ADVANCE(4);
+                            unsigned timeSinceLastSR = ntohl(*(u_int32_t *)pkt);
+                            ADVANCE(4);
+                            transmissionStats.noteIncomingRR(reportSenderSSRC, fromAddressAndPort, lossStats, highestReceived, jitter, timeLastSR,
+                                                             timeSinceLastSR);
+                        }
+                        else {
+                            ADVANCE(4 * 5);
+                        }
+                    }
+                }
+                else {
+                    ADVANCE(reportBlocksSize);
+                }
+
+                if(pt == RTCP_PT_RR) {  // i.e., we didn't fall through from 'SR'
+                    noteArrivingRR(fromAddressAndPort, tcpSocketNum, tcpStreamChannelId);
+                }
+
+                subPacketOK  = True;
+                typeOfPacket = PACKET_RTCP_REPORT;
+                break;
+            }
+            case RTCP_PT_BYE: {
+#ifdef DEBUG
+                fprintf(stderr, "BYE");
+#endif
+                // Check whether there was a 'reason for leaving':
+                if(length > 0) {
+                    u_int8_t reasonLength = *pkt;
+                    if(reasonLength > length - 1) {
+                        // The 'reason' length field is too large!
+#ifdef DEBUG
+                        fprintf(stderr, "\nError: The 'reason' length %d is too large (it should be <= %d)\n", reasonLength, length - 1);
+#endif
+                        reasonLength = length - 1;
+                    }
+                    reason = new char[reasonLength + 1];
+                    for(unsigned i = 0; i < reasonLength; ++i) {
+                        reason[i] = pkt[1 + i];
+                    }
+                    reason[reasonLength] = '\0';
+#ifdef DEBUG
+                    fprintf(stderr, " (reason:%s)", reason);
+#endif
+                }
+#ifdef DEBUG
+                fprintf(stderr, "\n");
+#endif
+                // If a 'BYE handler' was set, arrange for it to be called at the end of this routine.
+                // (Note: We don't call it immediately, in case it happens to cause "this" to be deleted.)
+                if((fByeHandlerTask != NULL || fByeWithReasonHandlerTask != NULL)
+                   && (!fByeHandleActiveParticipantsOnly || (fSource != NULL && fSource->receptionStatsDB().lookup(reportSenderSSRC) != NULL)
+                       || (fSink != NULL && fSink->transmissionStatsDB().lookup(reportSenderSSRC) != NULL))) {
+                    callByeHandler = True;
+                }
+
+                // We should really check for & handle >1 SSRCs being present #####
+
+                subPacketOK  = True;
+                typeOfPacket = PACKET_BYE;
+                break;
+            }
+            case RTCP_PT_APP: {
+                u_int8_t &subtype = rc;  // In "APP" packets, the "rc" field gets used as "subtype"
+#ifdef DEBUG
+                fprintf(stderr, "APP (subtype 0x%02x)\n", subtype);
+#endif
+                if(length < 4) {
+#ifdef DEBUG
+                    fprintf(stderr, "\tError: No \"name\" field!\n");
+#endif
+                    break;
+                }
+                length -= 4;
+#ifdef DEBUG
+                fprintf(stderr, "\tname:%c%c%c%c\n", pkt[0], pkt[1], pkt[2], pkt[3]);
+#endif
+                u_int32_t nameBytes = (pkt[0] << 24) | (pkt[1] << 16) | (pkt[2] << 8) | (pkt[3]);
+                ADVANCE(4);  // skip over "name", to the 'application-dependent data'
+#ifdef DEBUG
+                fprintf(stderr, "\tapplication-dependent data size: %d bytes\n", length);
+#endif
+
+                // If an 'APP' packet handler was set, call it now:
+                if(fAppHandlerTask != NULL) {
+                    (*fAppHandlerTask)(fAppHandlerClientData, subtype, nameBytes, pkt, length);
+                }
+                subPacketOK  = True;
+                typeOfPacket = PACKET_RTCP_APP;
+                break;
+            }
+                // Other RTCP packet types that we don't yet handle:
+            case RTCP_PT_SDES: {
+#ifdef DEBUG
+                // 'Handle' SDES packets only in debugging code, by printing out the 'SDES items':
+                fprintf(stderr, "SDES\n");
+
+                // Process each 'chunk':
+                Boolean chunkOK = False;
+                ADVANCE(-4);
+                length += 4;          // hack so that we see the first SSRC/CSRC again
+                while(length >= 8) {  // A valid chunk must be at least 8 bytes long
+                    chunkOK = False;  // until we learn otherwise
+
+                    u_int32_t SSRC_CSRC = ntohl(*(u_int32_t *)pkt);
+                    ADVANCE(4);
+                    length -= 4;
+                    fprintf(stderr, "\tSSRC/CSRC: 0x%08x\n", SSRC_CSRC);
+
+                    // Process each 'SDES item' in the chunk:
+                    u_int8_t itemType = *pkt;
+                    ADVANCE(1);
+                    --length;
+                    while(itemType != 0) {
+                        unsigned itemLen = *pkt;
+                        ADVANCE(1);
+                        --length;
+                        // Make sure "itemLen" allows for at least 1 zero byte at the end of the chunk:
+                        if(itemLen + 1 > length || pkt[itemLen] != 0)
+                            break;
+
+                        fprintf(stderr, "\t\t%s:%s\n",
+                                itemType == 1   ? "CNAME"
+                                : itemType == 2 ? "NAME"
+                                : itemType == 3 ? "EMAIL"
+                                : itemType == 4 ? "PHONE"
+                                : itemType == 5 ? "LOC"
+                                : itemType == 6 ? "TOOL"
+                                : itemType == 7 ? "NOTE"
+                                : itemType == 8 ? "PRIV"
+                                                : "(unknown)",
+                                itemType < 8 ? (char *)pkt  // hack, because we know it's '\0'-terminated
+                                             : "???" /* don't try to print out PRIV or unknown items */);
+                        ADVANCE(itemLen);
+                        length -= itemLen;
+
+                        itemType = *pkt;
+                        ADVANCE(1);
+                        --length;
+                    }
+                    if(itemType != 0)
+                        break;  // bad 'SDES item'
+
+                    // Thus, itemType == 0.  This zero 'type' marks the end of the list of SDES items.
+                    // Skip over remaining zero padding bytes, so that this chunk ends on a 4-byte boundary:
+                    while(length % 4 > 0 && *pkt == 0) {
+                        ADVANCE(1);
+                        --length;
+                    }
+                    if(length % 4 > 0)
+                        break;  // Bad (non-zero) padding byte
+
+                    chunkOK = True;
+                }
+                if(!chunkOK || length > 0)
+                    break;  // bad chunk, or not enough bytes for the last chunk
+#endif
+                subPacketOK = True;
+                break;
+            }
+            case RTCP_PT_RTPFB: {
+#ifdef DEBUG
+                fprintf(stderr, "RTPFB(unhandled)\n");
+#endif
+                subPacketOK = True;
+                break;
+            }
+            case RTCP_PT_PSFB: {
+#ifdef DEBUG
+                fprintf(stderr, "PSFB(unhandled)\n");
+                // Temporary code to show "Receiver Estimated Maximum Bitrate" (REMB) feedback reports:
+                //#####
+                if(length >= 12 && pkt[4] == 'R' && pkt[5] == 'E' && pkt[6] == 'M' && pkt[7] == 'B') {
+                    u_int8_t  exp      = pkt[9] >> 2;
+                    u_int32_t mantissa = ((pkt[9] & 0x03) << 16) | (pkt[10] << 8) | pkt[11];
+                    double    remb     = (double)mantissa;
+                    while(exp > 0) {
+                        remb *= 2.0;
+                        exp /= 2;
+                    }
+                    fprintf(stderr, "\tReceiver Estimated Max Bitrate (REMB): %g bps\n", remb);
+                }
+#endif
+                subPacketOK = True;
+                break;
+            }
+            case RTCP_PT_XR: {
+#ifdef DEBUG
+                fprintf(stderr, "XR(unhandled)\n");
+#endif
+                subPacketOK = True;
+                break;
+            }
+            case RTCP_PT_AVB: {
+#ifdef DEBUG
+                fprintf(stderr, "AVB(unhandled)\n");
+#endif
+                subPacketOK = True;
+                break;
+            }
+            case RTCP_PT_RSI: {
+#ifdef DEBUG
+                fprintf(stderr, "RSI(unhandled)\n");
+#endif
+                subPacketOK = True;
+                break;
+            }
+            case RTCP_PT_TOKEN: {
+#ifdef DEBUG
+                fprintf(stderr, "TOKEN(unhandled)\n");
+#endif
+                subPacketOK = True;
+                break;
+            }
+            case RTCP_PT_IDMS: {
+#ifdef DEBUG
+                fprintf(stderr, "IDMS(unhandled)\n");
+#endif
+                subPacketOK = True;
+                break;
+            }
+            default: {
+#ifdef DEBUG
+                fprintf(stderr, "UNKNOWN TYPE(0x%x)\n", pt);
+#endif
+                subPacketOK = True;
+                break;
+            }
+            }
+            if(!subPacketOK)
+                break;
+
+                // need to check for (& handle) SSRC collision! #####
+
+#ifdef DEBUG
+            fprintf(stderr, "validated RTCP subpacket: rc:%d, pt:%d, bytes remaining:%d, report sender SSRC:0x%08x\n", rc, pt, length, reportSenderSSRC);
+#endif
+
+            // Skip over any remaining bytes in this subpacket:
+            ADVANCE(length);
+
+            // Check whether another RTCP 'subpacket' follows:
+            if(packetSize == 0) {
+                packetOK = True;
+                break;
+            }
+            else if(packetSize < 4) {
+#ifdef DEBUG
+                fprintf(stderr, "extraneous %d bytes at end of RTCP packet!\n", packetSize);
+#endif
+                break;
+            }
+            rtcpHdr = ntohl(*(u_int32_t *)pkt);
+            if((rtcpHdr & 0xC0000000) != 0x80000000) {
+#ifdef DEBUG
+                fprintf(stderr, "bad RTCP subpacket: header 0x%08x\n", rtcpHdr);
+#endif
+                break;
+            }
+        }
+
+        if(!packetOK) {
+#ifdef DEBUG
+            fprintf(stderr, "rejected bad RTCP subpacket: header 0x%08x\n", rtcpHdr);
+#endif
+            break;
+        }
+        else {
+#ifdef DEBUG
+            fprintf(stderr, "validated entire RTCP packet\n");
+#endif
+        }
+
+        onReceive(typeOfPacket, totPacketSize, reportSenderSSRC);
+
+        // Finally, if we need to call a "BYE" handler, do so now (in case it causes "this" to get deleted):
+        if(callByeHandler) {
+            if(fByeHandlerTask != NULL) {  // call a BYE handler without including a 'reason'
+                TaskFunc *byeHandler = fByeHandlerTask;
+                fByeHandlerTask      = NULL;  // because we call the handler only once, by default
+                (*byeHandler)(fByeHandlerClientData);
+            }
+            else if(fByeWithReasonHandlerTask != NULL) {  // call a BYE handler that includes a 'reason'
+                ByeWithReasonHandlerFunc *byeHandler = fByeWithReasonHandlerTask;
+                fByeWithReasonHandlerTask            = NULL;  // because we call the handler only once, by default
+                (*byeHandler)(fByeHandlerClientData, reason);
+                // Note that the handler function is responsible for delete[]ing "reason"
+            }
+        }
+    } while(0);
+}
+
+void RTCPInstance::onReceive(int typeOfPacket, int totPacketSize, u_int32_t ssrc) {
+    fTypeOfPacket     = typeOfPacket;
+    fLastReceivedSize = totPacketSize;
+    fLastReceivedSSRC = ssrc;
+
+    int members = (int)numMembers();
+    int senders = (fSink != NULL) ? 1 : 0;
+
+    OnReceive(this,              // p
+              this,              // e
+              &members,          // members
+              &fPrevNumMembers,  // pmembers
+              &senders,          // senders
+              &fAveRTCPSize,     // avg_rtcp_size
+              &fPrevReportTime,  // tp
+              dTimeNow(),        // tc
+              fNextReportTime);
+}
+
+void RTCPInstance::sendReport() {
+#ifdef DEBUG
+    fprintf(stderr, "sending REPORT\n");
+#endif
+    // Begin by including a SR and/or RR report:
+    if(!addReport())
+        return;
+
+    // Then, include a SDES:
+    addSDES();
+
+    // Send the report:
+    sendBuiltPacket();
+
+    // Periodically clean out old members from our SSRC membership database:
+    const unsigned membershipReapPeriod = 5;
+    if((++fOutgoingReportCount) % membershipReapPeriod == 0) {
+        unsigned threshold = fOutgoingReportCount - membershipReapPeriod;
+        fKnownMembers->reapOldMembers(threshold);
+    }
+}
+
+void RTCPInstance::sendBYE(char const *reason) {
+#ifdef DEBUG
+    if(reason != NULL) {
+        fprintf(stderr, "sending BYE (reason:%s)\n", reason);
+    }
+    else {
+        fprintf(stderr, "sending BYE\n");
+    }
+#endif
+    // The packet must begin with a SR and/or RR report:
+    (void)addReport(True);
+
+    addBYE(reason);
+    sendBuiltPacket();
+}
+
+void RTCPInstance::sendBuiltPacket() {
+#ifdef DEBUG
+    fprintf(stderr, "sending RTCP packet\n");
+    unsigned char *p = fOutBuf->packet();
+    for(unsigned i = 0; i < fOutBuf->curPacketSize(); ++i) {
+        if(i % 4 == 0)
+            fprintf(stderr, " ");
+        fprintf(stderr, "%02x", p[i]);
+    }
+    fprintf(stderr, "\n");
+#endif
+    unsigned reportSize = fOutBuf->curPacketSize();
+    if(fCrypto != NULL) {  // Encrypt/tag the data before sending it:
+        unsigned newReportSize;
+        if(!fCrypto->processOutgoingSRTCPPacket(fOutBuf->packet(), reportSize, newReportSize))
+            return;
+        reportSize = newReportSize;
+    }
+    fRTCPInterface.sendPacket(fOutBuf->packet(), reportSize);
+    fOutBuf->resetOffset();
+
+    fLastSentSize       = IP_UDP_HDR_SIZE + reportSize;
+    fHaveJustSentPacket = True;
+    fLastPacketSentSize = reportSize;
+}
+
+int RTCPInstance::checkNewSSRC() {
+    return fKnownMembers->noteMembership(fLastReceivedSSRC, fOutgoingReportCount);
+}
+
+void RTCPInstance::removeLastReceivedSSRC() {
+    removeSSRC(fLastReceivedSSRC, False /*keep stats around*/);
+}
+
+void RTCPInstance::removeSSRC(u_int32_t ssrc, Boolean alsoRemoveStats) {
+    fKnownMembers->remove(ssrc);
+
+    if(alsoRemoveStats) {
+        // Also, remove records of this SSRC from any reception or transmission stats
+        if(fSource != NULL)
+            fSource->receptionStatsDB().removeRecord(ssrc);
+        if(fSink != NULL)
+            fSink->transmissionStatsDB().removeRecord(ssrc);
+    }
+}
+
+void RTCPInstance::onExpire(RTCPInstance *instance) {
+    instance->onExpire1();
+}
+
+// Member functions to build specific kinds of report:
+
+Boolean RTCPInstance::addReport(Boolean alwaysAdd) {
+    // Include a SR or a RR, depending on whether we have an associated sink or source:
+    if(fSink != NULL) {
+        if(!alwaysAdd) {
+            if(!fSink->enableRTCPReports())
+                return False;
+
+            // Hack: Don't send a SR during those (brief) times when the timestamp of the
+            // next outgoing RTP packet has been preset, to ensure that that timestamp gets
+            // used for that outgoing packet. (David Bertrand, 2006.07.18)
+            if(fSink->nextTimestampHasBeenPreset())
+                return False;
+        }
+
+        addSR();
+    }
+    if(fSource != NULL) {
+        if(!alwaysAdd) {
+            if(!fSource->enableRTCPReports())
+                return False;
+        }
+
+        addRR();
+    }
+
+    return True;
+}
+
+void RTCPInstance::addSR() {
+    // ASSERT: fSink != NULL
+
+    enqueueCommonReportPrefix(RTCP_PT_SR, fSink->SSRC(), 5 /* extra words in a SR */);
+
+    // Now, add the 'sender info' for our sink
+
+    // Insert the NTP and RTP timestamps for the 'wallclock time':
+    struct timeval timeNow;
+    gettimeofday(&timeNow, NULL);
+    fOutBuf->enqueueWord(timeNow.tv_sec + 0x83AA7E80);
+    // NTP timestamp most-significant word (1970 epoch -> 1900 epoch)
+    double fractionalPart = (timeNow.tv_usec / 15625.0) * 0x04000000;  // 2^32/10^6
+    fOutBuf->enqueueWord((unsigned)(fractionalPart + 0.5));
+    // NTP timestamp least-significant word
+    unsigned rtpTimestamp = fSink->convertToRTPTimestamp(timeNow);
+    fOutBuf->enqueueWord(rtpTimestamp);  // RTP ts
+
+    // Insert the packet and byte counts:
+    fOutBuf->enqueueWord(fSink->packetCount());
+    fOutBuf->enqueueWord(fSink->octetCount());
+
+    enqueueCommonReportSuffix();
+}
+
+void RTCPInstance::addRR() {
+    // ASSERT: fSource != NULL
+
+    enqueueCommonReportPrefix(RTCP_PT_RR, fSource->SSRC());
+    enqueueCommonReportSuffix();
+}
+
+void RTCPInstance::enqueueCommonReportPrefix(unsigned char packetType, u_int32_t SSRC, unsigned numExtraWords) {
+    unsigned numReportingSources;
+    if(fSource == NULL) {
+        numReportingSources = 0;  // we don't receive anything
+    }
+    else {
+        RTPReceptionStatsDB &allReceptionStats = fSource->receptionStatsDB();
+        numReportingSources                    = allReceptionStats.numActiveSourcesSinceLastReset();
+        // This must be <32, to fit in 5 bits:
+        if(numReportingSources >= 32) {
+            numReportingSources = 32;
+        }
+        // Later: support adding more reports to handle >32 sources (unlikely)#####
+    }
+
+    unsigned rtcpHdr = 0x80000000;  // version 2, no padding
+    rtcpHdr |= (numReportingSources << 24);
+    rtcpHdr |= (packetType << 16);
+    rtcpHdr |= (1 + numExtraWords + 6 * numReportingSources);
+    // each report block is 6 32-bit words long
+    fOutBuf->enqueueWord(rtcpHdr);
+
+    fOutBuf->enqueueWord(SSRC);
+}
+
+void RTCPInstance::enqueueCommonReportSuffix() {
+    // Output the report blocks for each source:
+    if(fSource != NULL) {
+        RTPReceptionStatsDB &allReceptionStats = fSource->receptionStatsDB();
+
+        RTPReceptionStatsDB::Iterator iterator(allReceptionStats);
+        while(1) {
+            RTPReceptionStats *receptionStats = iterator.next();
+            if(receptionStats == NULL)
+                break;
+            enqueueReportBlock(receptionStats);
+        }
+
+        allReceptionStats.reset();  // because we have just generated a report
+    }
+}
+
+void RTCPInstance::enqueueReportBlock(RTPReceptionStats *stats) {
+    fOutBuf->enqueueWord(stats->SSRC());
+
+    unsigned highestExtSeqNumReceived = stats->highestExtSeqNumReceived();
+
+    unsigned totNumExpected = highestExtSeqNumReceived - stats->baseExtSeqNumReceived();
+    int      totNumLost     = totNumExpected - stats->totNumPacketsReceived();
+    // 'Clamp' this loss number to a 24-bit signed value:
+    if(totNumLost > 0x007FFFFF) {
+        totNumLost = 0x007FFFFF;
+    }
+    else if(totNumLost < 0) {
+        if(totNumLost < -0x00800000)
+            totNumLost = 0x00800000;  // unlikely, but...
+        totNumLost &= 0x00FFFFFF;
+    }
+
+    unsigned      numExpectedSinceLastReset = highestExtSeqNumReceived - stats->lastResetExtSeqNumReceived();
+    int           numLostSinceLastReset     = numExpectedSinceLastReset - stats->numPacketsReceivedSinceLastReset();
+    unsigned char lossFraction;
+    if(numExpectedSinceLastReset == 0 || numLostSinceLastReset < 0) {
+        lossFraction = 0;
+    }
+    else {
+        lossFraction = (unsigned char)((numLostSinceLastReset << 8) / numExpectedSinceLastReset);
+    }
+
+    fOutBuf->enqueueWord((lossFraction << 24) | totNumLost);
+    fOutBuf->enqueueWord(highestExtSeqNumReceived);
+
+    fOutBuf->enqueueWord(stats->jitter());
+
+    unsigned NTPmsw = stats->lastReceivedSR_NTPmsw();
+    unsigned NTPlsw = stats->lastReceivedSR_NTPlsw();
+    unsigned LSR    = ((NTPmsw & 0xFFFF) << 16) | (NTPlsw >> 16);  // middle 32 bits
+    fOutBuf->enqueueWord(LSR);
+
+    // Figure out how long has elapsed since the last SR rcvd from this src:
+    struct timeval const &LSRtime = stats->lastReceivedSR_time();  // "last SR"
+    struct timeval        timeNow, timeSinceLSR;
+    gettimeofday(&timeNow, NULL);
+    if(timeNow.tv_usec < LSRtime.tv_usec) {
+        timeNow.tv_usec += 1000000;
+        timeNow.tv_sec -= 1;
+    }
+    timeSinceLSR.tv_sec  = timeNow.tv_sec - LSRtime.tv_sec;
+    timeSinceLSR.tv_usec = timeNow.tv_usec - LSRtime.tv_usec;
+    // The enqueued time is in units of 1/65536 seconds.
+    // (Note that 65536/1000000 == 1024/15625)
+    unsigned DLSR;
+    if(LSR == 0) {
+        DLSR = 0;
+    }
+    else {
+        DLSR = (timeSinceLSR.tv_sec << 16) | ((((timeSinceLSR.tv_usec << 11) + 15625) / 31250) & 0xFFFF);
+    }
+    fOutBuf->enqueueWord(DLSR);
+}
+
+void RTCPInstance::addSDES() {
+    // For now we support only the CNAME item; later support more #####
+
+    // Begin by figuring out the size of the entire SDES report:
+    unsigned numBytes = 4;
+    // counts the SSRC, but not the header; it'll get subtracted out
+    numBytes += fCNAME.totalSize();  // includes id and length
+    numBytes += 1;                   // the special END item
+
+    unsigned num4ByteWords = (numBytes + 3) / 4;
+
+    unsigned rtcpHdr = 0x81000000;  // version 2, no padding, 1 SSRC chunk
+    rtcpHdr |= (RTCP_PT_SDES << 16);
+    rtcpHdr |= num4ByteWords;
+    fOutBuf->enqueueWord(rtcpHdr);
+
+    if(fSource != NULL) {
+        fOutBuf->enqueueWord(fSource->SSRC());
+    }
+    else if(fSink != NULL) {
+        fOutBuf->enqueueWord(fSink->SSRC());
+    }
+
+    // Add the CNAME:
+    fOutBuf->enqueue(fCNAME.data(), fCNAME.totalSize());
+
+    // Add the 'END' item (i.e., a zero byte), plus any more needed to pad:
+    unsigned            numPaddingBytesNeeded = 4 - (fOutBuf->curPacketSize() % 4);
+    unsigned char const zero                  = '\0';
+    while(numPaddingBytesNeeded-- > 0)
+        fOutBuf->enqueue(&zero, 1);
+}
+
+void RTCPInstance::addBYE(char const *reason) {
+    u_int32_t rtcpHdr = 0x81000000;  // version 2, no padding, 1 SSRC
+    rtcpHdr |= (RTCP_PT_BYE << 16);
+    u_int16_t num32BitWords     = 2;  // by default, two 32-bit words total (i.e., with 1 SSRC)
+    u_int8_t  reasonLength8Bits = 0;  // by default
+    if(reason != NULL) {
+        // We need to add more 32-bit words for the 'length+reason':
+        unsigned const reasonLength = strlen(reason);
+        reasonLength8Bits           = reasonLength < 0xFF ? (u_int8_t)reasonLength : 0xFF;
+        unsigned numExtraWords      = ((1 /*reason length field*/ + reasonLength8Bits) + 3) / 4;
+
+        num32BitWords += numExtraWords;
+    }
+    rtcpHdr |= (num32BitWords - 1);  // length field
+    fOutBuf->enqueueWord(rtcpHdr);
+
+    if(fSource != NULL) {
+        fOutBuf->enqueueWord(fSource->SSRC());
+    }
+    else if(fSink != NULL) {
+        fOutBuf->enqueueWord(fSink->SSRC());
+    }
+
+    num32BitWords -= 2;  // ASSERT: num32BitWords >= 0
+    if(num32BitWords > 0) {
+        // Add a length+'reason for leaving':
+        // First word:
+        u_int32_t lengthPlusFirst3ReasonBytes = reasonLength8Bits << 24;
+        unsigned  index                       = 0;
+        if(reasonLength8Bits > index)
+            lengthPlusFirst3ReasonBytes |= ((u_int8_t)reason[index++]) << 16;
+        if(reasonLength8Bits > index)
+            lengthPlusFirst3ReasonBytes |= ((u_int8_t)reason[index++]) << 8;
+        if(reasonLength8Bits > index)
+            lengthPlusFirst3ReasonBytes |= (u_int8_t)reason[index++];
+        fOutBuf->enqueueWord(lengthPlusFirst3ReasonBytes);
+
+        // Any subsequent words:
+        if(reasonLength8Bits > 3) {
+            // ASSERT: num32BitWords > 1
+            while(--num32BitWords > 0) {
+                u_int32_t fourMoreReasonBytes = 0;
+                if(reasonLength8Bits > index)
+                    fourMoreReasonBytes |= ((u_int8_t)reason[index++]) << 24;
+                if(reasonLength8Bits > index)
+                    fourMoreReasonBytes |= ((u_int8_t)reason[index++]) << 16;
+                if(reasonLength8Bits > index)
+                    fourMoreReasonBytes |= ((u_int8_t)reason[index++]) << 8;
+                if(reasonLength8Bits > index)
+                    fourMoreReasonBytes |= (u_int8_t)reason[index++];
+                fOutBuf->enqueueWord(fourMoreReasonBytes);
+            }
+        }
+    }
+}
+
+void RTCPInstance::schedule(double nextTime) {
+    fNextReportTime = nextTime;
+
+    double secondsToDelay = nextTime - dTimeNow();
+    if(secondsToDelay < 0)
+        secondsToDelay = 0;
+#ifdef DEBUG
+    fprintf(stderr, "schedule(%f->%f)\n", secondsToDelay, nextTime);
+#endif
+    int64_t usToGo = (int64_t)(secondsToDelay * 1000000);
+    nextTask()     = envir().taskScheduler().scheduleDelayedTask(usToGo, (TaskFunc *)RTCPInstance::onExpire, this);
+}
+
+void RTCPInstance::reschedule(double nextTime) {
+    envir().taskScheduler().unscheduleDelayedTask(nextTask());
+    schedule(nextTime);
+}
+
+void RTCPInstance::onExpire1() {
+    nextTask() = NULL;
+
+    // Note: fTotSessionBW is kbits per second
+    double rtcpBW = 0.05 * fTotSessionBW * 1024 / 8;  // -> bytes per second
+
+    OnExpire(this,                     // event
+             numMembers(),             // members
+             (fSink != NULL) ? 1 : 0,  // senders
+             rtcpBW,                   // rtcp_bw
+             (fSink != NULL) ? 1 : 0,  // we_sent
+             &fAveRTCPSize,            // ave_rtcp_size
+             &fIsInitial,              // initial
+             dTimeNow(),               // tc
+             &fPrevReportTime,         // tp
+             &fPrevNumMembers          // pmembers
+    );
+}
+
+////////// SDESItem //////////
+
+SDESItem::SDESItem(unsigned char tag, unsigned char const *value) {
+    unsigned length = strlen((char const *)value);
+    if(length > 0xFF)
+        length = 0xFF;  // maximum data length for a SDES item
+
+    fData[0] = tag;
+    fData[1] = (unsigned char)length;
+    memmove(&fData[2], value, length);
+}
+
+unsigned SDESItem::totalSize() const {
+    return 2 + (unsigned)fData[1];
+}
+
+////////// Implementation of routines imported by the "rtcp_from_spec" C code
+
+extern "C" void Schedule(double nextTime, event e) {
+    RTCPInstance *instance = (RTCPInstance *)e;
+    if(instance == NULL)
+        return;
+
+    instance->schedule(nextTime);
+}
+
+extern "C" void Reschedule(double nextTime, event e) {
+    RTCPInstance *instance = (RTCPInstance *)e;
+    if(instance == NULL)
+        return;
+
+    instance->reschedule(nextTime);
+}
+
+extern "C" void SendRTCPReport(event e) {
+    RTCPInstance *instance = (RTCPInstance *)e;
+    if(instance == NULL)
+        return;
+
+    instance->sendReport();
+}
+
+extern "C" void SendBYEPacket(event e) {
+    RTCPInstance *instance = (RTCPInstance *)e;
+    if(instance == NULL)
+        return;
+
+    instance->sendBYE();
+}
+
+extern "C" int TypeOfEvent(event e) {
+    RTCPInstance *instance = (RTCPInstance *)e;
+    if(instance == NULL)
+        return EVENT_UNKNOWN;
+
+    return instance->typeOfEvent();
+}
+
+extern "C" int SentPacketSize(event e) {
+    RTCPInstance *instance = (RTCPInstance *)e;
+    if(instance == NULL)
+        return 0;
+
+    return instance->sentPacketSize();
+}
+
+extern "C" int PacketType(packet p) {
+    RTCPInstance *instance = (RTCPInstance *)p;
+    if(instance == NULL)
+        return PACKET_UNKNOWN_TYPE;
+
+    return instance->packetType();
+}
+
+extern "C" int ReceivedPacketSize(packet p) {
+    RTCPInstance *instance = (RTCPInstance *)p;
+    if(instance == NULL)
+        return 0;
+
+    return instance->receivedPacketSize();
+}
+
+extern "C" int NewMember(packet p) {
+    RTCPInstance *instance = (RTCPInstance *)p;
+    if(instance == NULL)
+        return 0;
+
+    return instance->checkNewSSRC();
+}
+
+extern "C" int NewSender(packet /*p*/) {
+    return 0;  // we don't yet recognize senders other than ourselves #####
+}
+
+extern "C" void AddMember(packet /*p*/) {
+    // Do nothing; all of the real work was done when NewMember() was called
+}
+
+extern "C" void AddSender(packet /*p*/) {
+    // we don't yet recognize senders other than ourselves #####
+}
+
+extern "C" void RemoveMember(packet p) {
+    RTCPInstance *instance = (RTCPInstance *)p;
+    if(instance == NULL)
+        return;
+
+    instance->removeLastReceivedSSRC();
+}
+
+extern "C" void RemoveSender(packet /*p*/) {
+    // we don't yet recognize senders other than ourselves #####
+}
+
+extern "C" double drand30() {
+    unsigned tmp = our_random() & 0x3FFFFFFF;  // a random 30-bit integer
+    return tmp / (double)(1024 * 1024 * 1024);
+}
diff --git a/3rdparty/live555/src/liveMedia/RTPInterface.cpp b/3rdparty/live555/src/liveMedia/RTPInterface.cpp
new file mode 100644
index 00000000..aa93f4c3
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/RTPInterface.cpp
@@ -0,0 +1,664 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// An abstraction of a network interface used for RTP (or RTCP).
+// (This allows the RTP-over-TCP hack (RFC 2326, section 10.12) to
+// be implemented transparently.)
+// Implementation
+
+#include "RTPInterface.hh"
+#include <GroupsockHelper.hh>
+#include <stdio.h>
+
+////////// Helper Functions - Definition //////////
+
+// Helper routines and data structures, used to implement
+// sending/receiving RTP/RTCP over a TCP socket:
+
+class tcpStreamRecord {
+public:
+    tcpStreamRecord(int streamSocketNum, unsigned char streamChannelId, TLSState *tlsState, tcpStreamRecord *next);
+    virtual ~tcpStreamRecord();
+
+public:
+    tcpStreamRecord *fNext;
+    int              fStreamSocketNum;
+    unsigned char    fStreamChannelId;
+    TLSState *       fTLSState;
+};
+
+// Reading RTP-over-TCP is implemented using two levels of hash tables.
+// The top-level hash table maps TCP socket numbers to a
+// "SocketDescriptor" that contains a hash table for each of the
+// sub-channels that are reading from this socket.
+
+static HashTable *socketHashTable(UsageEnvironment &env, Boolean createIfNotPresent = True) {
+    _Tables *ourTables = _Tables::getOurTables(env, createIfNotPresent);
+    if(ourTables == NULL)
+        return NULL;
+
+    if(ourTables->socketTable == NULL) {
+        // Create a new socket number -> SocketDescriptor mapping table:
+        ourTables->socketTable = HashTable::create(ONE_WORD_HASH_KEYS);
+    }
+    return (HashTable *)(ourTables->socketTable);
+}
+
+class SocketDescriptor {
+public:
+    SocketDescriptor(UsageEnvironment &env, int socketNum, TLSState *tlsState);
+    virtual ~SocketDescriptor();
+
+    void          registerRTPInterface(unsigned char streamChannelId, RTPInterface *rtpInterface);
+    RTPInterface *lookupRTPInterface(unsigned char streamChannelId);
+    void          deregisterRTPInterface(unsigned char streamChannelId);
+
+    void setServerRequestAlternativeByteHandler(ServerRequestAlternativeByteHandler *handler, void *clientData) {
+        fServerRequestAlternativeByteHandler           = handler;
+        fServerRequestAlternativeByteHandlerClientData = clientData;
+    }
+
+private:
+    static void tcpReadHandler(SocketDescriptor *, int mask);
+    Boolean     tcpReadHandler1(int mask);
+
+private:
+    UsageEnvironment &                   fEnv;
+    int                                  fOurSocketNum;
+    TLSState *                           fTLSState;
+    HashTable *                          fSubChannelHashTable;
+    ServerRequestAlternativeByteHandler *fServerRequestAlternativeByteHandler;
+    void *                               fServerRequestAlternativeByteHandlerClientData;
+    u_int8_t                             fStreamChannelId, fSizeByte1;
+    Boolean                              fReadErrorOccurred, fDeleteMyselfNext, fAreInReadHandlerLoop;
+    enum { AWAITING_DOLLAR, AWAITING_STREAM_CHANNEL_ID, AWAITING_SIZE1, AWAITING_SIZE2, AWAITING_PACKET_DATA } fTCPReadingState;
+};
+
+static SocketDescriptor *lookupSocketDescriptor(UsageEnvironment &env, int sockNum, TLSState *tlsState = NULL, Boolean createIfNotFound = True) {
+    HashTable *table = socketHashTable(env, createIfNotFound);
+    if(table == NULL)
+        return NULL;
+
+    char const *      key              = (char const *)(long)sockNum;
+    SocketDescriptor *socketDescriptor = (SocketDescriptor *)(table->Lookup(key));
+    if(socketDescriptor == NULL) {
+        if(createIfNotFound) {
+            socketDescriptor = new SocketDescriptor(env, sockNum, tlsState);
+            table->Add((char const *)(long)(sockNum), socketDescriptor);
+        }
+        else if(table->IsEmpty()) {
+            // We can also delete the table (to reclaim space):
+            _Tables *ourTables = _Tables::getOurTables(env);
+            delete table;
+            ourTables->socketTable = NULL;
+            ourTables->reclaimIfPossible();
+        }
+    }
+
+    return socketDescriptor;
+}
+
+static void removeSocketDescription(UsageEnvironment &env, int sockNum) {
+    char const *key   = (char const *)(long)sockNum;
+    HashTable * table = socketHashTable(env);
+    table->Remove(key);
+
+    if(table->IsEmpty()) {
+        // We can also delete the table (to reclaim space):
+        _Tables *ourTables = _Tables::getOurTables(env);
+        delete table;
+        ourTables->socketTable = NULL;
+        ourTables->reclaimIfPossible();
+    }
+}
+
+////////// RTPInterface - Implementation //////////
+
+RTPInterface::RTPInterface(Medium *owner, Groupsock *gs)
+    : fOwner(owner),
+      fGS(gs),
+      fTCPStreams(NULL),
+      fNextTCPReadSize(0),
+      fNextTCPReadStreamSocketNum(-1),
+      fNextTCPReadStreamChannelId(0xFF),
+      fNextTCPReadTLSState(NULL),
+      fReadHandlerProc(NULL),
+      fAuxReadHandlerFunc(NULL),
+      fAuxReadHandlerClientData(NULL) {
+    // Make the socket non-blocking, even though it will be read from only asynchronously, when packets arrive.
+    // The reason for this is that, in some OSs, reads on a blocking socket can (allegedly) sometimes block,
+    // even if the socket was previously reported (e.g., by "select()") as having data available.
+    // (This can supposedly happen if the UDP checksum fails, for example.)
+    makeSocketNonBlocking(fGS->socketNum());
+    increaseSendBufferTo(envir(), fGS->socketNum(), 50 * 1024);
+}
+
+RTPInterface::~RTPInterface() {
+    stopNetworkReading();
+    delete fTCPStreams;
+}
+
+void RTPInterface::setStreamSocket(int sockNum, unsigned char streamChannelId, TLSState *tlsState) {
+    fGS->removeAllDestinations();
+    envir().taskScheduler().disableBackgroundHandling(fGS->socketNum());  // turn off any reading on our datagram socket
+    fGS->reset();                                                         // and close our datagram socket, because we won't be using it anymore
+
+    addStreamSocket(sockNum, streamChannelId, tlsState);
+}
+
+void RTPInterface::addStreamSocket(int sockNum, unsigned char streamChannelId, TLSState *tlsState) {
+    if(sockNum < 0)
+        return;
+
+    for(tcpStreamRecord *streams = fTCPStreams; streams != NULL; streams = streams->fNext) {
+        if(streams->fStreamSocketNum == sockNum && streams->fStreamChannelId == streamChannelId) {
+            return;  // we already have it
+        }
+    }
+
+    fTCPStreams = new tcpStreamRecord(sockNum, streamChannelId, tlsState, fTCPStreams);
+
+    // Also, make sure this new socket is set up for receiving RTP/RTCP-over-TCP:
+    SocketDescriptor *socketDescriptor = lookupSocketDescriptor(envir(), sockNum, tlsState);
+    socketDescriptor->registerRTPInterface(streamChannelId, this);
+}
+
+static void deregisterSocket(UsageEnvironment &env, int sockNum, unsigned char streamChannelId) {
+    SocketDescriptor *socketDescriptor = lookupSocketDescriptor(env, sockNum, NULL, False);
+    if(socketDescriptor != NULL) {
+        socketDescriptor->deregisterRTPInterface(streamChannelId);
+        // Note: This may delete "socketDescriptor",
+        // if no more interfaces are using this socket
+    }
+}
+
+void RTPInterface::removeStreamSocket(int sockNum, unsigned char streamChannelId) {
+    // Remove - from our list of 'TCP streams' - the record of the (sockNum,streamChannelId) pair.
+    // (However "streamChannelId" == 0xFF is a special case, meaning remove all
+    //  (sockNum,*) pairs.)
+
+    while(1) {
+        tcpStreamRecord **streamsPtr = &fTCPStreams;
+
+        while(*streamsPtr != NULL) {
+            if((*streamsPtr)->fStreamSocketNum == sockNum && (streamChannelId == 0xFF || streamChannelId == (*streamsPtr)->fStreamChannelId)) {
+                // Delete the record pointed to by *streamsPtr :
+                unsigned char    streamChannelIdToRemove = (*streamsPtr)->fStreamChannelId;
+                tcpStreamRecord *next                    = (*streamsPtr)->fNext;
+                (*streamsPtr)->fNext                     = NULL;
+                delete(*streamsPtr);
+                *streamsPtr = next;
+
+                // And 'deregister' this socket,channelId pair:
+                deregisterSocket(envir(), sockNum, streamChannelIdToRemove);
+
+                if(streamChannelId != 0xFF)
+                    return;  // we're done
+                break;       // start again from the beginning of the list, in case the list has changed
+            }
+            else {
+                streamsPtr = &((*streamsPtr)->fNext);
+            }
+        }
+        if(*streamsPtr == NULL)
+            break;
+    }
+}
+
+void RTPInterface::setServerRequestAlternativeByteHandler(UsageEnvironment &env, int socketNum, ServerRequestAlternativeByteHandler *handler,
+                                                          void *clientData) {
+    SocketDescriptor *socketDescriptor = lookupSocketDescriptor(env, socketNum, NULL, False);
+
+    if(socketDescriptor != NULL)
+        socketDescriptor->setServerRequestAlternativeByteHandler(handler, clientData);
+}
+
+void RTPInterface::clearServerRequestAlternativeByteHandler(UsageEnvironment &env, int socketNum) {
+    setServerRequestAlternativeByteHandler(env, socketNum, NULL, NULL);
+}
+
+Boolean RTPInterface::sendPacket(unsigned char *packet, unsigned packetSize) {
+    Boolean success = True;  // we'll return False instead if any of the sends fail
+
+    // Normal case: Send as a UDP packet:
+    if(!fGS->output(envir(), packet, packetSize))
+        success = False;
+
+    // Also, send over each of our TCP sockets:
+    tcpStreamRecord *nextStream;
+    for(tcpStreamRecord *stream = fTCPStreams; stream != NULL; stream = nextStream) {
+        nextStream = stream->fNext;  // Set this now, in case the following deletes "stream":
+        if(!sendRTPorRTCPPacketOverTCP(packet, packetSize, stream->fStreamSocketNum, stream->fStreamChannelId, stream->fTLSState)) {
+            success = False;
+        }
+    }
+
+    return success;
+}
+
+void RTPInterface ::startNetworkReading(TaskScheduler::BackgroundHandlerProc *handlerProc) {
+    // Normal case: Arrange to read UDP packets:
+    envir().taskScheduler().turnOnBackgroundReadHandling(fGS->socketNum(), handlerProc, fOwner);
+
+    // Also, receive RTP over TCP, on each of our TCP connections:
+    fReadHandlerProc = handlerProc;
+    for(tcpStreamRecord *streams = fTCPStreams; streams != NULL; streams = streams->fNext) {
+        // Get a socket descriptor for "streams->fStreamSocketNum":
+        SocketDescriptor *socketDescriptor = lookupSocketDescriptor(envir(), streams->fStreamSocketNum);
+
+        // Tell it about our subChannel:
+        socketDescriptor->registerRTPInterface(streams->fStreamChannelId, this);
+    }
+}
+
+Boolean RTPInterface::handleRead(unsigned char *buffer, unsigned bufferMaxSize, unsigned &bytesRead, struct sockaddr_storage &fromAddress, int &tcpSocketNum,
+                                 unsigned char &tcpStreamChannelId, Boolean &packetReadWasIncomplete) {
+    packetReadWasIncomplete = False;  // by default
+    Boolean readSuccess;
+    if(fNextTCPReadStreamSocketNum < 0) {
+        // Normal case: read from the (datagram) 'groupsock':
+        tcpSocketNum = -1;
+        readSuccess  = fGS->handleRead(buffer, bufferMaxSize, bytesRead, fromAddress);
+    }
+    else {
+        // Read from the TCP connection:
+        tcpSocketNum       = fNextTCPReadStreamSocketNum;
+        tcpStreamChannelId = fNextTCPReadStreamChannelId;
+
+        bytesRead               = 0;
+        unsigned totBytesToRead = fNextTCPReadSize;
+        if(totBytesToRead > bufferMaxSize)
+            totBytesToRead = bufferMaxSize;
+        unsigned curBytesToRead = totBytesToRead;
+        int      curBytesRead;
+        // Because we're calling "readSocket()" on a stream socket, we don't expect "fromAddress"
+        // to be filled in, so set it to a 'dummy' value instead:
+        fromAddress.ss_family                        = AF_INET;
+        ((sockaddr_in &)fromAddress).sin_addr.s_addr = 0;
+        ((sockaddr_in &)fromAddress).sin_port        = 0;
+
+        while((curBytesRead = (fNextTCPReadTLSState != NULL && fNextTCPReadTLSState->isNeeded)
+                                  ? fNextTCPReadTLSState->read(&buffer[bytesRead], curBytesToRead)
+                                  : readSocket(envir(), fNextTCPReadStreamSocketNum, &buffer[bytesRead], curBytesToRead, fromAddress))
+              > 0) {
+            bytesRead += curBytesRead;
+            if(bytesRead >= totBytesToRead)
+                break;
+            curBytesToRead -= curBytesRead;
+        }
+        fNextTCPReadSize -= bytesRead;
+        if(fNextTCPReadSize == 0) {
+            // We've read all of the data that we asked for
+            readSuccess = True;
+        }
+        else if(curBytesRead < 0) {
+            // There was an error reading the socket
+            bytesRead   = 0;
+            readSuccess = False;
+        }
+        else {
+            // We need to read more bytes, and there was not an error reading the socket
+            packetReadWasIncomplete = True;
+            return True;
+        }
+        fNextTCPReadStreamSocketNum = -1;  // default, for next time
+    }
+
+    if(readSuccess && fAuxReadHandlerFunc != NULL) {
+        // Also pass the newly-read packet data to our auxilliary handler:
+        (*fAuxReadHandlerFunc)(fAuxReadHandlerClientData, buffer, bytesRead);
+    }
+    return readSuccess;
+}
+
+void RTPInterface::stopNetworkReading() {
+    // Normal case
+    if(fGS != NULL)
+        envir().taskScheduler().turnOffBackgroundReadHandling(fGS->socketNum());
+
+    // Also turn off read handling on each of our TCP connections:
+    for(tcpStreamRecord *streams = fTCPStreams; streams != NULL; streams = streams->fNext) {
+        deregisterSocket(envir(), streams->fStreamSocketNum, streams->fStreamChannelId);
+    }
+}
+
+////////// Helper Functions - Implementation /////////
+
+Boolean RTPInterface::sendRTPorRTCPPacketOverTCP(u_int8_t *packet, unsigned packetSize, int socketNum, unsigned char streamChannelId, TLSState *tlsState) {
+#ifdef DEBUG_SEND
+    fprintf(stderr, "sendRTPorRTCPPacketOverTCP: %d bytes over channel %d (socket %d)\n", packetSize, streamChannelId, socketNum);
+    fflush(stderr);
+#endif
+    // Send a RTP/RTCP packet over TCP, using the encoding defined in RFC 2326, section 10.12:
+    //     $<streamChannelId><packetSize><packet>
+    // (If the initial "send()" of '$<streamChannelId><packetSize>' succeeds, then we force
+    // the subsequent "send()" for the <packet> data to succeed, even if we have to do so with
+    // a blocking "send()".)
+    do {
+        u_int8_t framingHeader[4];
+        framingHeader[0] = '$';
+        framingHeader[1] = streamChannelId;
+        framingHeader[2] = (u_int8_t)((packetSize & 0xFF00) >> 8);
+        framingHeader[3] = (u_int8_t)(packetSize & 0xFF);
+        if(!sendDataOverTCP(socketNum, tlsState, framingHeader, 4, False))
+            break;
+
+        if(!sendDataOverTCP(socketNum, tlsState, packet, packetSize, True))
+            break;
+#ifdef DEBUG_SEND
+        fprintf(stderr, "sendRTPorRTCPPacketOverTCP: completed\n");
+        fflush(stderr);
+#endif
+
+        return True;
+    } while(0);
+
+#ifdef DEBUG_SEND
+    fprintf(stderr, "sendRTPorRTCPPacketOverTCP: failed! (errno %d)\n", envir().getErrno());
+    fflush(stderr);
+#endif
+    return False;
+}
+
+#ifndef RTPINTERFACE_BLOCKING_WRITE_TIMEOUT_MS
+#define RTPINTERFACE_BLOCKING_WRITE_TIMEOUT_MS 500
+#endif
+
+Boolean RTPInterface::sendDataOverTCP(int socketNum, TLSState *tlsState, u_int8_t const *data, unsigned dataSize, Boolean forceSendToSucceed) {
+    int sendResult =
+        (tlsState != NULL && tlsState->isNeeded) ? tlsState->write((char const *)data, dataSize) : send(socketNum, (char const *)data, dataSize, 0 /*flags*/);
+    if(sendResult < (int)dataSize) {
+        // The TCP send() failed - at least partially.
+
+        unsigned numBytesSentSoFar = sendResult < 0 ? 0 : (unsigned)sendResult;
+        if(numBytesSentSoFar > 0 || (forceSendToSucceed && envir().getErrno() == EAGAIN)) {
+            // The OS's TCP send buffer has filled up (because the stream's bitrate has exceeded
+            // the capacity of the TCP connection!).
+            // Force this data write to succeed, by blocking if necessary until it does:
+            unsigned numBytesRemainingToSend = dataSize - numBytesSentSoFar;
+#ifdef DEBUG_SEND
+            fprintf(stderr, "sendDataOverTCP: resending %d-byte send (blocking)\n", numBytesRemainingToSend);
+            fflush(stderr);
+#endif
+            makeSocketBlocking(socketNum, RTPINTERFACE_BLOCKING_WRITE_TIMEOUT_MS);
+            sendResult = (tlsState != NULL && tlsState->isNeeded)
+                             ? tlsState->write((char const *)(&data[numBytesSentSoFar]), numBytesRemainingToSend)
+                             : send(socketNum, (char const *)(&data[numBytesSentSoFar]), numBytesRemainingToSend, 0 /*flags*/);
+            makeSocketNonBlocking(socketNum);
+            if((unsigned)sendResult != numBytesRemainingToSend) {
+                // The blocking "send()" failed, or timed out.  In either case, we assume that the
+                // TCP connection has failed (or is 'hanging' indefinitely), and we stop using it
+                // (for both RTP and RTP).
+                // (If we kept using the socket here, the RTP or RTCP packet write would be in an
+                //  incomplete, inconsistent state.)
+#ifdef DEBUG_SEND
+                fprintf(stderr, "sendDataOverTCP: blocking send() failed (delivering %d bytes out of %d); closing socket %d\n", sendResult,
+                        numBytesRemainingToSend, socketNum);
+                fflush(stderr);
+#endif
+                removeStreamSocket(socketNum, 0xFF);
+                return False;
+            }
+
+            return True;
+        }
+        else if(sendResult < 0 && envir().getErrno() != EAGAIN) {
+            // Because the "send()" call failed, assume that the socket is now unusable, so stop
+            // using it (for both RTP and RTCP):
+            removeStreamSocket(socketNum, 0xFF);
+        }
+
+        return False;
+    }
+
+    return True;
+}
+
+SocketDescriptor::SocketDescriptor(UsageEnvironment &env, int socketNum, TLSState *tlsState)
+    : fEnv(env),
+      fOurSocketNum(socketNum),
+      fTLSState(tlsState),
+      fSubChannelHashTable(HashTable::create(ONE_WORD_HASH_KEYS)),
+      fServerRequestAlternativeByteHandler(NULL),
+      fServerRequestAlternativeByteHandlerClientData(NULL),
+      fReadErrorOccurred(False),
+      fDeleteMyselfNext(False),
+      fAreInReadHandlerLoop(False),
+      fTCPReadingState(AWAITING_DOLLAR) {}
+
+SocketDescriptor::~SocketDescriptor() {
+    fEnv.taskScheduler().turnOffBackgroundReadHandling(fOurSocketNum);
+    removeSocketDescription(fEnv, fOurSocketNum);
+
+    if(fSubChannelHashTable != NULL) {
+        // Remove knowledge of this socket from any "RTPInterface"s that are using it:
+        HashTable::Iterator *iter = HashTable::Iterator::create(*fSubChannelHashTable);
+        RTPInterface *       rtpInterface;
+        char const *         key;
+
+        while((rtpInterface = (RTPInterface *)(iter->next(key))) != NULL) {
+            u_int64_t     streamChannelIdLong = (u_int64_t)key;
+            unsigned char streamChannelId     = (unsigned char)streamChannelIdLong;
+
+            rtpInterface->removeStreamSocket(fOurSocketNum, streamChannelId);
+        }
+        delete iter;
+
+        // Then remove the hash table entries themselves, and then remove the hash table:
+        while(fSubChannelHashTable->RemoveNext() != NULL) {
+        }
+        delete fSubChannelHashTable;
+    }
+
+    // Finally:
+    if(fServerRequestAlternativeByteHandler != NULL) {
+        // Hack: Pass a special character to our alternative byte handler, to tell it that either
+        // - an error occurred when reading the TCP socket, or
+        // - no error occurred, but it needs to take over control of the TCP socket once again.
+        u_int8_t specialChar = fReadErrorOccurred ? 0xFF : 0xFE;
+        (*fServerRequestAlternativeByteHandler)(fServerRequestAlternativeByteHandlerClientData, specialChar);
+    }
+}
+
+void SocketDescriptor::registerRTPInterface(unsigned char streamChannelId, RTPInterface *rtpInterface) {
+    Boolean isFirstRegistration = fSubChannelHashTable->IsEmpty();
+#if defined(DEBUG_SEND) || defined(DEBUG_RECEIVE)
+    fprintf(stderr, "SocketDescriptor(socket %d)::registerRTPInterface(channel %d): isFirstRegistration %d\n", fOurSocketNum, streamChannelId,
+            isFirstRegistration);
+#endif
+    fSubChannelHashTable->Add((char const *)(long)streamChannelId, rtpInterface);
+
+    if(isFirstRegistration) {
+        // Arrange to handle reads on this TCP socket:
+        TaskScheduler::BackgroundHandlerProc *handler = (TaskScheduler::BackgroundHandlerProc *)&tcpReadHandler;
+        fEnv.taskScheduler().setBackgroundHandling(fOurSocketNum, SOCKET_READABLE | SOCKET_EXCEPTION, handler, this);
+    }
+}
+
+RTPInterface *SocketDescriptor ::lookupRTPInterface(unsigned char streamChannelId) {
+    char const *lookupArg = (char const *)(long)streamChannelId;
+    return (RTPInterface *)(fSubChannelHashTable->Lookup(lookupArg));
+}
+
+void SocketDescriptor ::deregisterRTPInterface(unsigned char streamChannelId) {
+#if defined(DEBUG_SEND) || defined(DEBUG_RECEIVE)
+    fprintf(stderr, "SocketDescriptor(socket %d)::deregisterRTPInterface(channel %d)\n", fOurSocketNum, streamChannelId);
+#endif
+    fSubChannelHashTable->Remove((char const *)(long)streamChannelId);
+
+    if(fSubChannelHashTable->IsEmpty()) {
+        // No more interfaces are using us, so it's curtains for us now:
+        if(fAreInReadHandlerLoop) {
+            fDeleteMyselfNext = True;  // we can't delete ourself yet, but we'll do so from "tcpReadHandler()" below
+        }
+        else {
+            delete this;
+        }
+    }
+}
+
+void SocketDescriptor::tcpReadHandler(SocketDescriptor *socketDescriptor, int mask) {
+    // Call the read handler until it returns false, with a limit to avoid starving other sockets
+    unsigned count                          = 2000;
+    socketDescriptor->fAreInReadHandlerLoop = True;
+    while(!socketDescriptor->fDeleteMyselfNext && socketDescriptor->tcpReadHandler1(mask) && --count > 0) {
+    }
+    socketDescriptor->fAreInReadHandlerLoop = False;
+    if(socketDescriptor->fDeleteMyselfNext)
+        delete socketDescriptor;
+}
+
+Boolean SocketDescriptor::tcpReadHandler1(int mask) {
+    // We expect the following data over the TCP channel:
+    //   optional RTSP command or response bytes (before the first '$' character)
+    //   a '$' character
+    //   a 1-byte channel id
+    //   a 2-byte packet size (in network byte order)
+    //   the packet data.
+    // However, because the socket is being read asynchronously, this data might arrive in pieces.
+
+    u_int8_t                c;
+    struct sockaddr_storage dummy;  // not used
+    if(fTCPReadingState != AWAITING_PACKET_DATA) {
+        int result = (fTLSState != NULL && fTLSState->isNeeded) ? fTLSState->read(&c, 1) : readSocket(fEnv, fOurSocketNum, &c, 1, dummy);
+        if(result == 0) {  // There was no more data to read
+            return False;
+        }
+        else if(result != 1) {  // error reading TCP socket, so we will no longer handle it
+#ifdef DEBUG_RECEIVE
+            fprintf(stderr, "SocketDescriptor(socket %d)::tcpReadHandler(): readSocket(1 byte) returned %d (error)\n", fOurSocketNum, result);
+#endif
+            fReadErrorOccurred = True;
+            fDeleteMyselfNext  = True;
+            return False;
+        }
+    }
+
+    Boolean callAgain = True;
+    switch(fTCPReadingState) {
+    case AWAITING_DOLLAR: {
+        if(c == '$') {
+#ifdef DEBUG_RECEIVE
+            fprintf(stderr, "SocketDescriptor(socket %d)::tcpReadHandler(): Saw '$'\n", fOurSocketNum);
+#endif
+            fTCPReadingState = AWAITING_STREAM_CHANNEL_ID;
+        }
+        else {
+            // This character is part of a RTSP request or command, which is handled separately:
+            if(fServerRequestAlternativeByteHandler != NULL && c != 0xFF && c != 0xFE) {
+                // Hack: 0xFF and 0xFE are used as special signaling characters, so don't send them
+                (*fServerRequestAlternativeByteHandler)(fServerRequestAlternativeByteHandlerClientData, c);
+            }
+        }
+        break;
+    }
+    case AWAITING_STREAM_CHANNEL_ID: {
+        // The byte that we read is the stream channel id.
+        if(lookupRTPInterface(c) != NULL) {  // sanity check
+            fStreamChannelId = c;
+            fTCPReadingState = AWAITING_SIZE1;
+        }
+        else {
+            // This wasn't a stream channel id that we expected.  We're (somehow) in a strange state.  Try to recover:
+#ifdef DEBUG_RECEIVE
+            fprintf(stderr, "SocketDescriptor(socket %d)::tcpReadHandler(): Saw nonexistent stream channel id: 0x%02x\n", fOurSocketNum, c);
+#endif
+            fTCPReadingState = AWAITING_DOLLAR;
+        }
+        break;
+    }
+    case AWAITING_SIZE1: {
+        // The byte that we read is the first (high) byte of the 16-bit RTP or RTCP packet 'size'.
+        fSizeByte1       = c;
+        fTCPReadingState = AWAITING_SIZE2;
+        break;
+    }
+    case AWAITING_SIZE2: {
+        // The byte that we read is the second (low) byte of the 16-bit RTP or RTCP packet 'size'.
+        unsigned short size = (fSizeByte1 << 8) | c;
+
+        // Record the information about the packet data that will be read next:
+        RTPInterface *rtpInterface = lookupRTPInterface(fStreamChannelId);
+        if(rtpInterface != NULL) {
+            rtpInterface->fNextTCPReadSize            = size;
+            rtpInterface->fNextTCPReadStreamSocketNum = fOurSocketNum;
+            rtpInterface->fNextTCPReadStreamChannelId = fStreamChannelId;
+            rtpInterface->fNextTCPReadTLSState        = fTLSState;
+        }
+        fTCPReadingState = AWAITING_PACKET_DATA;
+        break;
+    }
+    case AWAITING_PACKET_DATA: {
+        callAgain        = False;
+        fTCPReadingState = AWAITING_DOLLAR;  // the next state, unless we end up having to read more data in the current state
+        // Call the appropriate read handler to get the packet data from the TCP stream:
+        RTPInterface *rtpInterface = lookupRTPInterface(fStreamChannelId);
+        if(rtpInterface != NULL) {
+            if(rtpInterface->fNextTCPReadSize == 0) {
+                // We've already read all the data for this packet.
+                break;
+            }
+            if(rtpInterface->fReadHandlerProc != NULL) {
+#ifdef DEBUG_RECEIVE
+                fprintf(stderr, "SocketDescriptor(socket %d)::tcpReadHandler(): reading %d bytes on channel %d\n", fOurSocketNum,
+                        rtpInterface->fNextTCPReadSize, rtpInterface->fNextTCPReadStreamChannelId);
+#endif
+                fTCPReadingState = AWAITING_PACKET_DATA;
+                rtpInterface->fReadHandlerProc(rtpInterface->fOwner, mask);
+            }
+            else {
+#ifdef DEBUG_RECEIVE
+                fprintf(stderr,
+                        "SocketDescriptor(socket %d)::tcpReadHandler(): No handler proc for \"rtpInterface\" for channel %d; need to skip %d remaining bytes\n",
+                        fOurSocketNum, fStreamChannelId, rtpInterface->fNextTCPReadSize);
+#endif
+                int result = (fTLSState != NULL && fTLSState->isNeeded) ? fTLSState->read(&c, 1) : readSocket(fEnv, fOurSocketNum, &c, 1, dummy);
+                if(result < 0) {  // error reading TCP socket, so we will no longer handle it
+#ifdef DEBUG_RECEIVE
+                    fprintf(stderr, "SocketDescriptor(socket %d)::tcpReadHandler(): readSocket(1 byte) returned %d (error)\n", fOurSocketNum, result);
+#endif
+                    fReadErrorOccurred = True;
+                    fDeleteMyselfNext  = True;
+                    return False;
+                }
+                else {
+                    fTCPReadingState = AWAITING_PACKET_DATA;
+                    if(result == 1) {
+                        --rtpInterface->fNextTCPReadSize;
+                        callAgain = True;
+                    }
+                }
+            }
+        }
+#ifdef DEBUG_RECEIVE
+        else
+            fprintf(stderr, "SocketDescriptor(socket %d)::tcpReadHandler(): No \"rtpInterface\" for channel %d\n", fOurSocketNum, fStreamChannelId);
+#endif
+    }
+    }
+
+    return callAgain;
+}
+
+////////// tcpStreamRecord implementation //////////
+
+tcpStreamRecord ::tcpStreamRecord(int streamSocketNum, unsigned char streamChannelId, TLSState *tlsState, tcpStreamRecord *next)
+    : fNext(next), fStreamSocketNum(streamSocketNum), fStreamChannelId(streamChannelId), fTLSState(tlsState) {}
+
+tcpStreamRecord::~tcpStreamRecord() {
+    delete fNext;
+}
diff --git a/3rdparty/live555/src/liveMedia/RTPSink.cpp b/3rdparty/live555/src/liveMedia/RTPSink.cpp
new file mode 100644
index 00000000..081e77b5
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/RTPSink.cpp
@@ -0,0 +1,402 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// RTP Sinks
+// Implementation
+
+#include "RTPSink.hh"
+#include "Base64.hh"
+#include "GroupsockHelper.hh"
+
+////////// RTPSink //////////
+
+Boolean RTPSink::lookupByName(UsageEnvironment &env, char const *sinkName, RTPSink *&resultSink) {
+    resultSink = NULL;  // unless we succeed
+
+    MediaSink *sink;
+    if(!MediaSink::lookupByName(env, sinkName, sink))
+        return False;
+
+    if(!sink->isRTPSink()) {
+        env.setResultMsg(sinkName, " is not a RTP sink");
+        return False;
+    }
+
+    resultSink = (RTPSink *)sink;
+    return True;
+}
+
+Boolean RTPSink::isRTPSink() const {
+    return True;
+}
+
+RTPSink::RTPSink(UsageEnvironment &env, Groupsock *rtpGS, unsigned char rtpPayloadType, unsigned rtpTimestampFrequency, char const *rtpPayloadFormatName,
+                 unsigned numChannels)
+    : MediaSink(env),
+      fRTPInterface(this, rtpGS),
+      fRTPPayloadType(rtpPayloadType),
+      fPacketCount(0),
+      fOctetCount(0),
+      fTotalOctetCount(0),
+      fMIKEYState(NULL),
+      fCrypto(NULL),
+      fTimestampFrequency(rtpTimestampFrequency),
+      fNextTimestampHasBeenPreset(False),
+      fEnableRTCPReports(True),
+      fNumChannels(numChannels),
+      fEstimatedBitrate(0) {
+    fRTPPayloadFormatName = strDup(rtpPayloadFormatName == NULL ? "???" : rtpPayloadFormatName);
+    gettimeofday(&fCreationTime, NULL);
+    fTotalOctetCountStartTime = fCreationTime;
+    resetPresentationTimes();
+
+    fSeqNo         = (u_int16_t)our_random();
+    fSSRC          = our_random32();
+    fTimestampBase = our_random32();
+
+    fTransmissionStatsDB = new RTPTransmissionStatsDB(*this);
+}
+
+RTPSink::~RTPSink() {
+    delete fTransmissionStatsDB;
+    delete[](char *) fRTPPayloadFormatName;
+    delete fCrypto;
+    delete fMIKEYState;
+    fRTPInterface.forgetOurGroupsock();
+    // so that the "fRTPInterface" destructor doesn't turn off background read handling (in case
+    // its 'groupsock' is being shared with something else that does background read handling).
+}
+
+u_int32_t RTPSink::convertToRTPTimestamp(struct timeval tv) {
+    // Begin by converting from "struct timeval" units to RTP timestamp units:
+    u_int32_t timestampIncrement = (fTimestampFrequency * tv.tv_sec);
+    timestampIncrement += (u_int32_t)(fTimestampFrequency * (tv.tv_usec / 1000000.0) + 0.5);  // note: rounding
+
+    // Then add this to our 'timestamp base':
+    if(fNextTimestampHasBeenPreset) {
+        // Make the returned timestamp the same as the current "fTimestampBase",
+        // so that timestamps begin with the value that was previously preset:
+        fTimestampBase -= timestampIncrement;
+        fNextTimestampHasBeenPreset = False;
+    }
+
+    u_int32_t const rtpTimestamp = fTimestampBase + timestampIncrement;
+#ifdef DEBUG_TIMESTAMPS
+    fprintf(stderr, "fTimestampBase: 0x%08x, tv: %lu.%06ld\n\t=> RTP timestamp: 0x%08x\n", fTimestampBase, tv.tv_sec, tv.tv_usec, rtpTimestamp);
+    fflush(stderr);
+#endif
+
+    return rtpTimestamp;
+}
+
+u_int32_t RTPSink::presetNextTimestamp() {
+    struct timeval timeNow;
+    gettimeofday(&timeNow, NULL);
+
+    u_int32_t tsNow = convertToRTPTimestamp(timeNow);
+    if(!groupsockBeingUsed().hasMultipleDestinations()) {
+        // Don't adjust the timestamp stream if we already have another destination ongoing
+        fTimestampBase              = tsNow;
+        fNextTimestampHasBeenPreset = True;
+    }
+
+    return tsNow;
+}
+
+void RTPSink::getTotalBitrate(unsigned &outNumBytes, double &outElapsedTime) {
+    struct timeval timeNow;
+    gettimeofday(&timeNow, NULL);
+
+    outNumBytes    = fTotalOctetCount;
+    outElapsedTime = (double)(timeNow.tv_sec - fTotalOctetCountStartTime.tv_sec) + (timeNow.tv_usec - fTotalOctetCountStartTime.tv_usec) / 1000000.0;
+
+    fTotalOctetCount          = 0;
+    fTotalOctetCountStartTime = timeNow;
+}
+
+void RTPSink::resetPresentationTimes() {
+    fInitialPresentationTime.tv_sec = fMostRecentPresentationTime.tv_sec = 0;
+    fInitialPresentationTime.tv_usec = fMostRecentPresentationTime.tv_usec = 0;
+}
+
+void RTPSink::setupForSRTP(Boolean useEncryption) {
+    // Set up keying state for streaming via SRTP:
+    delete fCrypto;
+    delete fMIKEYState;
+    fMIKEYState = new MIKEYState(useEncryption);
+    fCrypto     = new SRTPCryptographicContext(*fMIKEYState);
+}
+
+u_int8_t *RTPSink::setupForSRTP(Boolean useEncryption, unsigned &resultMIKEYStateMessageSize) {
+    // Set up keying state for streaming via SRTP:
+    setupForSRTP(useEncryption);
+
+    u_int8_t *MIKEYStateMessage = fMIKEYState->generateMessage(resultMIKEYStateMessageSize);
+    return MIKEYStateMessage;
+}
+
+void RTPSink::setupForSRTP(u_int8_t const *MIKEYStateMessage, unsigned MIKEYStateMessageSize) {
+    // Set up keying state for streaming via SRTP:
+    delete fCrypto;
+    delete fMIKEYState;
+    fMIKEYState = MIKEYState::createNew(MIKEYStateMessage, MIKEYStateMessageSize);
+    fCrypto     = new SRTPCryptographicContext(*fMIKEYState);
+}
+
+char const *RTPSink::sdpMediaType() const {
+    return "data";
+    // default SDP media (m=) type, unless redefined by subclasses
+}
+
+char *RTPSink::rtpmapLine() const {
+    if(rtpPayloadType() >= 96) {  // the payload format type is dynamic
+        char *encodingParamsPart;
+        if(numChannels() != 1) {
+            encodingParamsPart = new char[1 + 20 /* max int len */];
+            sprintf(encodingParamsPart, "/%d", numChannels());
+        }
+        else {
+            encodingParamsPart = strDup("");
+        }
+        char const *const rtpmapFmt = "a=rtpmap:%d %s/%d%s\r\n";
+        unsigned rtpmapLineSize = strlen(rtpmapFmt) + 3 /* max char len */ + strlen(rtpPayloadFormatName()) + 20 /* max int len */ + strlen(encodingParamsPart);
+        char *   rtpmapLine     = new char[rtpmapLineSize];
+        sprintf(rtpmapLine, rtpmapFmt, rtpPayloadType(), rtpPayloadFormatName(), rtpTimestampFrequency(), encodingParamsPart);
+        delete[] encodingParamsPart;
+
+        return rtpmapLine;
+    }
+    else {
+        // The payload format is static, so there's no "a=rtpmap:" line:
+        return strDup("");
+    }
+}
+
+char *RTPSink::keyMgmtLine() {
+    u_int8_t *mikeyMessage;
+    unsigned  mikeyMessageSize;
+    if(fMIKEYState != NULL && (mikeyMessage = fMIKEYState->generateMessage(mikeyMessageSize)) != NULL) {
+        char const *const keyMgmtFmt        = "a=key-mgmt:mikey %s\r\n";
+        char *            base64EncodedData = base64Encode((char *)mikeyMessage, mikeyMessageSize);
+        delete[] mikeyMessage;
+
+        unsigned keyMgmtLineSize = strlen(keyMgmtFmt) + strlen(base64EncodedData);
+        char *   keyMgmtLine     = new char[keyMgmtLineSize];
+        sprintf(keyMgmtLine, keyMgmtFmt, base64EncodedData);
+        delete[] base64EncodedData;
+
+        return keyMgmtLine;
+    }
+    else {  // no "a=key-mgmt:" line
+        return strDup("");
+    }
+}
+
+char const *RTPSink::auxSDPLine() {
+    return NULL;  // by default
+}
+
+////////// RTPTransmissionStatsDB //////////
+
+RTPTransmissionStatsDB::RTPTransmissionStatsDB(RTPSink &rtpSink) : fOurRTPSink(rtpSink), fTable(HashTable::create(ONE_WORD_HASH_KEYS)) {
+    fNumReceivers = 0;
+}
+
+RTPTransmissionStatsDB::~RTPTransmissionStatsDB() {
+    // First, remove and delete all stats records from the table:
+    RTPTransmissionStats *stats;
+    while((stats = (RTPTransmissionStats *)fTable->RemoveNext()) != NULL) {
+        delete stats;
+    }
+
+    // Then, delete the table itself:
+    delete fTable;
+}
+
+void RTPTransmissionStatsDB ::noteIncomingRR(u_int32_t SSRC, struct sockaddr_storage const &lastFromAddress, unsigned lossStats, unsigned lastPacketNumReceived,
+                                             unsigned jitter, unsigned lastSRTime, unsigned diffSR_RRTime) {
+    RTPTransmissionStats *stats = lookup(SSRC);
+    if(stats == NULL) {
+        // This is the first time we've heard of this SSRC.
+        // Create a new record for it:
+        stats = new RTPTransmissionStats(fOurRTPSink, SSRC);
+        if(stats == NULL)
+            return;
+        add(SSRC, stats);
+#ifdef DEBUG_RR
+        fprintf(stderr, "Adding new entry for SSRC %x in RTPTransmissionStatsDB\n", SSRC);
+#endif
+    }
+
+    stats->noteIncomingRR(lastFromAddress, lossStats, lastPacketNumReceived, jitter, lastSRTime, diffSR_RRTime);
+}
+
+void RTPTransmissionStatsDB::removeRecord(u_int32_t SSRC) {
+    RTPTransmissionStats *stats = lookup(SSRC);
+    if(stats != NULL) {
+        long SSRC_long = (long)SSRC;
+        fTable->Remove((char const *)SSRC_long);
+        --fNumReceivers;
+        delete stats;
+    }
+}
+
+RTPTransmissionStatsDB::Iterator ::Iterator(RTPTransmissionStatsDB &receptionStatsDB) : fIter(HashTable::Iterator::create(*(receptionStatsDB.fTable))) {}
+
+RTPTransmissionStatsDB::Iterator::~Iterator() {
+    delete fIter;
+}
+
+RTPTransmissionStats *RTPTransmissionStatsDB::Iterator::next() {
+    char const *key;  // dummy
+
+    return (RTPTransmissionStats *)(fIter->next(key));
+}
+
+RTPTransmissionStats *RTPTransmissionStatsDB::lookup(u_int32_t SSRC) const {
+    long SSRC_long = (long)SSRC;
+    return (RTPTransmissionStats *)(fTable->Lookup((char const *)SSRC_long));
+}
+
+void RTPTransmissionStatsDB::add(u_int32_t SSRC, RTPTransmissionStats *stats) {
+    long SSRC_long = (long)SSRC;
+    fTable->Add((char const *)SSRC_long, stats);
+    ++fNumReceivers;
+}
+
+////////// RTPTransmissionStats //////////
+
+RTPTransmissionStats::RTPTransmissionStats(RTPSink &rtpSink, u_int32_t SSRC)
+    : fOurRTPSink(rtpSink),
+      fSSRC(SSRC),
+      fLastPacketNumReceived(0),
+      fPacketLossRatio(0),
+      fTotNumPacketsLost(0),
+      fJitter(0),
+      fLastSRTime(0),
+      fDiffSR_RRTime(0),
+      fAtLeastTwoRRsHaveBeenReceived(False),
+      fFirstPacket(True),
+      fTotalOctetCount_hi(0),
+      fTotalOctetCount_lo(0),
+      fTotalPacketCount_hi(0),
+      fTotalPacketCount_lo(0) {
+    gettimeofday(&fTimeCreated, NULL);
+
+    fLastOctetCount  = rtpSink.octetCount();
+    fLastPacketCount = rtpSink.packetCount();
+}
+
+RTPTransmissionStats::~RTPTransmissionStats() {}
+
+void RTPTransmissionStats ::noteIncomingRR(struct sockaddr_storage const &lastFromAddress, unsigned lossStats, unsigned lastPacketNumReceived, unsigned jitter,
+                                           unsigned lastSRTime, unsigned diffSR_RRTime) {
+    if(fFirstPacket) {
+        fFirstPacket            = False;
+        fFirstPacketNumReported = lastPacketNumReceived;
+    }
+    else {
+        fAtLeastTwoRRsHaveBeenReceived = True;
+        fOldLastPacketNumReceived      = fLastPacketNumReceived;
+        fOldTotNumPacketsLost          = fTotNumPacketsLost;
+    }
+    gettimeofday(&fTimeReceived, NULL);
+
+    fLastFromAddress       = lastFromAddress;
+    fPacketLossRatio       = lossStats >> 24;
+    fTotNumPacketsLost     = lossStats & 0xFFFFFF;
+    fLastPacketNumReceived = lastPacketNumReceived;
+    fJitter                = jitter;
+    fLastSRTime            = lastSRTime;
+    fDiffSR_RRTime         = diffSR_RRTime;
+#ifdef DEBUG_RR
+    fprintf(stderr,
+            "RTCP RR data (received at %lu.%06ld): lossStats 0x%08x, lastPacketNumReceived 0x%08x, jitter 0x%08x, lastSRTime 0x%08x, diffSR_RRTime 0x%08x\n",
+            fTimeReceived.tv_sec, fTimeReceived.tv_usec, lossStats, lastPacketNumReceived, jitter, lastSRTime, diffSR_RRTime);
+    unsigned rtd = roundTripDelay();
+    fprintf(stderr, "=> round-trip delay: 0x%04x (== %f seconds)\n", rtd, rtd / 65536.0);
+#endif
+
+    // Update our counts of the total number of octets and packets sent towards
+    // this receiver:
+    u_int32_t newOctetCount          = fOurRTPSink.octetCount();
+    u_int32_t octetCountDiff         = newOctetCount - fLastOctetCount;
+    fLastOctetCount                  = newOctetCount;
+    u_int32_t prevTotalOctetCount_lo = fTotalOctetCount_lo;
+    fTotalOctetCount_lo += octetCountDiff;
+    if(fTotalOctetCount_lo < prevTotalOctetCount_lo) {  // wrap around
+        ++fTotalOctetCount_hi;
+    }
+
+    u_int32_t newPacketCount          = fOurRTPSink.packetCount();
+    u_int32_t packetCountDiff         = newPacketCount - fLastPacketCount;
+    fLastPacketCount                  = newPacketCount;
+    u_int32_t prevTotalPacketCount_lo = fTotalPacketCount_lo;
+    fTotalPacketCount_lo += packetCountDiff;
+    if(fTotalPacketCount_lo < prevTotalPacketCount_lo) {  // wrap around
+        ++fTotalPacketCount_hi;
+    }
+}
+
+unsigned RTPTransmissionStats::roundTripDelay() const {
+    // Compute the round-trip delay that was indicated by the most recently-received
+    // RTCP RR packet.  Use the method noted in the RTP/RTCP specification (RFC 3350).
+
+    if(fLastSRTime == 0) {
+        // Either no RTCP RR packet has been received yet, or else the
+        // reporting receiver has not yet received any RTCP SR packets from us:
+        return 0;
+    }
+
+    // First, convert the time that we received the last RTCP RR packet to NTP format,
+    // in units of 1/65536 (2^-16) seconds:
+    unsigned lastReceivedTimeNTP_high = fTimeReceived.tv_sec + 0x83AA7E80;           // 1970 epoch -> 1900 epoch
+    double   fractionalPart           = (fTimeReceived.tv_usec * 0x0400) / 15625.0;  // 2^16/10^6
+    unsigned lastReceivedTimeNTP      = (unsigned)((lastReceivedTimeNTP_high << 16) + fractionalPart + 0.5);
+
+    int rawResult = lastReceivedTimeNTP - fLastSRTime - fDiffSR_RRTime;
+    if(rawResult < 0) {
+        // This can happen if there's clock drift between the sender and receiver,
+        // and if the round-trip time was very small.
+        rawResult = 0;
+    }
+    return (unsigned)rawResult;
+}
+
+void RTPTransmissionStats::getTotalOctetCount(u_int32_t &hi, u_int32_t &lo) {
+    hi = fTotalOctetCount_hi;
+    lo = fTotalOctetCount_lo;
+}
+
+void RTPTransmissionStats::getTotalPacketCount(u_int32_t &hi, u_int32_t &lo) {
+    hi = fTotalPacketCount_hi;
+    lo = fTotalPacketCount_lo;
+}
+
+unsigned RTPTransmissionStats::packetsReceivedSinceLastRR() const {
+    if(!fAtLeastTwoRRsHaveBeenReceived)
+        return 0;
+
+    return fLastPacketNumReceived - fOldLastPacketNumReceived;
+}
+
+int RTPTransmissionStats::packetsLostBetweenRR() const {
+    if(!fAtLeastTwoRRsHaveBeenReceived)
+        return 0;
+
+    return fTotNumPacketsLost - fOldTotNumPacketsLost;
+}
diff --git a/3rdparty/live555/src/liveMedia/RTPSource.cpp b/3rdparty/live555/src/liveMedia/RTPSource.cpp
new file mode 100644
index 00000000..655279bb
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/RTPSource.cpp
@@ -0,0 +1,388 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// RTP Sources
+// Implementation
+
+#include "RTPSource.hh"
+#include "GroupsockHelper.hh"
+
+////////// RTPSource //////////
+
+Boolean RTPSource::lookupByName(UsageEnvironment &env, char const *sourceName, RTPSource *&resultSource) {
+    resultSource = NULL;  // unless we succeed
+
+    MediaSource *source;
+    if(!MediaSource::lookupByName(env, sourceName, source))
+        return False;
+
+    if(!source->isRTPSource()) {
+        env.setResultMsg(sourceName, " is not a RTP source");
+        return False;
+    }
+
+    resultSource = (RTPSource *)source;
+    return True;
+}
+
+Boolean RTPSource::hasBeenSynchronizedUsingRTCP() {
+    return fCurPacketHasBeenSynchronizedUsingRTCP;
+}
+
+Boolean RTPSource::isRTPSource() const {
+    return True;
+}
+
+RTPSource::RTPSource(UsageEnvironment &env, Groupsock *RTPgs, unsigned char rtpPayloadFormat, u_int32_t rtpTimestampFrequency)
+    : FramedSource(env),
+      fRTPInterface(this, RTPgs),
+      fCurPacketHasBeenSynchronizedUsingRTCP(False),
+      fLastReceivedSSRC(0),
+      fRTCPInstanceForMultiplexedRTCPPackets(NULL),
+      fCrypto(NULL),
+      fRTPPayloadFormat(rtpPayloadFormat),
+      fTimestampFrequency(rtpTimestampFrequency),
+      fSSRC(our_random32()),
+      fEnableRTCPReports(True) {
+    fReceptionStatsDB = new RTPReceptionStatsDB();
+}
+
+RTPSource::~RTPSource() {
+    delete fReceptionStatsDB;
+}
+
+void RTPSource::getAttributes() const {
+    envir().setResultMsg("");  // Fix later to get attributes from  header #####
+}
+
+////////// RTPReceptionStatsDB //////////
+
+RTPReceptionStatsDB::RTPReceptionStatsDB() : fTable(HashTable::create(ONE_WORD_HASH_KEYS)), fTotNumPacketsReceived(0) {
+    reset();
+}
+
+void RTPReceptionStatsDB::reset() {
+    fNumActiveSourcesSinceLastReset = 0;
+
+    Iterator           iter(*this);
+    RTPReceptionStats *stats;
+    while((stats = iter.next()) != NULL) {
+        stats->reset();
+    }
+}
+
+RTPReceptionStatsDB::~RTPReceptionStatsDB() {
+    // First, remove and delete all stats records from the table:
+    RTPReceptionStats *stats;
+    while((stats = (RTPReceptionStats *)fTable->RemoveNext()) != NULL) {
+        delete stats;
+    }
+
+    // Then, delete the table itself:
+    delete fTable;
+}
+
+void RTPReceptionStatsDB ::noteIncomingPacket(u_int32_t SSRC, u_int16_t seqNum, u_int32_t rtpTimestamp, unsigned timestampFrequency,
+                                              Boolean useForJitterCalculation, struct timeval &resultPresentationTime, Boolean &resultHasBeenSyncedUsingRTCP,
+                                              unsigned packetSize) {
+    ++fTotNumPacketsReceived;
+    RTPReceptionStats *stats = lookup(SSRC);
+    if(stats == NULL) {
+        // This is the first time we've heard from this SSRC.
+        // Create a new record for it:
+        stats = new RTPReceptionStats(SSRC, seqNum);
+        if(stats == NULL)
+            return;
+        add(SSRC, stats);
+    }
+
+    if(stats->numPacketsReceivedSinceLastReset() == 0) {
+        ++fNumActiveSourcesSinceLastReset;
+    }
+
+    stats->noteIncomingPacket(seqNum, rtpTimestamp, timestampFrequency, useForJitterCalculation, resultPresentationTime, resultHasBeenSyncedUsingRTCP,
+                              packetSize);
+}
+
+void RTPReceptionStatsDB ::noteIncomingSR(u_int32_t SSRC, u_int32_t ntpTimestampMSW, u_int32_t ntpTimestampLSW, u_int32_t rtpTimestamp) {
+    RTPReceptionStats *stats = lookup(SSRC);
+    if(stats == NULL) {
+        // This is the first time we've heard of this SSRC.
+        // Create a new record for it:
+        stats = new RTPReceptionStats(SSRC);
+        if(stats == NULL)
+            return;
+        add(SSRC, stats);
+    }
+
+    stats->noteIncomingSR(ntpTimestampMSW, ntpTimestampLSW, rtpTimestamp);
+}
+
+void RTPReceptionStatsDB::removeRecord(u_int32_t SSRC) {
+    RTPReceptionStats *stats = lookup(SSRC);
+    if(stats != NULL) {
+        long SSRC_long = (long)SSRC;
+        fTable->Remove((char const *)SSRC_long);
+        delete stats;
+    }
+}
+
+RTPReceptionStatsDB::Iterator ::Iterator(RTPReceptionStatsDB &receptionStatsDB) : fIter(HashTable::Iterator::create(*(receptionStatsDB.fTable))) {}
+
+RTPReceptionStatsDB::Iterator::~Iterator() {
+    delete fIter;
+}
+
+RTPReceptionStats *RTPReceptionStatsDB::Iterator::next(Boolean includeInactiveSources) {
+    char const *key;  // dummy
+
+    // If asked, skip over any sources that haven't been active
+    // since the last reset:
+    RTPReceptionStats *stats;
+    do {
+        stats = (RTPReceptionStats *)(fIter->next(key));
+    } while(stats != NULL && !includeInactiveSources && stats->numPacketsReceivedSinceLastReset() == 0);
+
+    return stats;
+}
+
+RTPReceptionStats *RTPReceptionStatsDB::lookup(u_int32_t SSRC) const {
+    long SSRC_long = (long)SSRC;
+    return (RTPReceptionStats *)(fTable->Lookup((char const *)SSRC_long));
+}
+
+void RTPReceptionStatsDB::add(u_int32_t SSRC, RTPReceptionStats *stats) {
+    long SSRC_long = (long)SSRC;
+    fTable->Add((char const *)SSRC_long, stats);
+}
+
+////////// RTPReceptionStats //////////
+
+RTPReceptionStats::RTPReceptionStats(u_int32_t SSRC, u_int16_t initialSeqNum) {
+    initSeqNum(initialSeqNum);
+    init(SSRC);
+}
+
+RTPReceptionStats::RTPReceptionStats(u_int32_t SSRC) {
+    init(SSRC);
+}
+
+RTPReceptionStats::~RTPReceptionStats() {}
+
+void RTPReceptionStats::init(u_int32_t SSRC) {
+    fSSRC                  = SSRC;
+    fTotNumPacketsReceived = 0;
+    fTotBytesReceived_hi = fTotBytesReceived_lo = 0;
+    fBaseExtSeqNumReceived                      = 0;
+    fHighestExtSeqNumReceived                   = 0;
+    fHaveSeenInitialSequenceNumber              = False;
+    fLastTransit                                = ~0;
+    fPreviousPacketRTPTimestamp                 = 0;
+    fJitter                                     = 0.0;
+    fLastReceivedSR_NTPmsw = fLastReceivedSR_NTPlsw = 0;
+    fLastReceivedSR_time.tv_sec = fLastReceivedSR_time.tv_usec = 0;
+    fLastPacketReceptionTime.tv_sec = fLastPacketReceptionTime.tv_usec = 0;
+    fMinInterPacketGapUS                                               = 0x7FFFFFFF;
+    fMaxInterPacketGapUS                                               = 0;
+    fTotalInterPacketGaps.tv_sec = fTotalInterPacketGaps.tv_usec = 0;
+    fHasBeenSynchronized                                         = False;
+    fSyncTime.tv_sec = fSyncTime.tv_usec = 0;
+    reset();
+}
+
+void RTPReceptionStats::initSeqNum(u_int16_t initialSeqNum) {
+    fBaseExtSeqNumReceived         = 0x10000 | initialSeqNum;
+    fHighestExtSeqNumReceived      = 0x10000 | initialSeqNum;
+    fHaveSeenInitialSequenceNumber = True;
+}
+
+#ifndef MILLION
+#define MILLION 1000000
+#endif
+
+void RTPReceptionStats ::noteIncomingPacket(u_int16_t seqNum, u_int32_t rtpTimestamp, unsigned timestampFrequency, Boolean useForJitterCalculation,
+                                            struct timeval &resultPresentationTime, Boolean &resultHasBeenSyncedUsingRTCP, unsigned packetSize) {
+    if(!fHaveSeenInitialSequenceNumber)
+        initSeqNum(seqNum);
+
+    ++fNumPacketsReceivedSinceLastReset;
+    ++fTotNumPacketsReceived;
+    u_int32_t prevTotBytesReceived_lo = fTotBytesReceived_lo;
+    fTotBytesReceived_lo += packetSize;
+    if(fTotBytesReceived_lo < prevTotBytesReceived_lo) {  // wrap-around
+        ++fTotBytesReceived_hi;
+    }
+
+    // Check whether the new sequence number is the highest yet seen:
+    unsigned oldSeqNum        = (fHighestExtSeqNumReceived & 0xFFFF);
+    unsigned seqNumCycle      = (fHighestExtSeqNumReceived & 0xFFFF0000);
+    unsigned seqNumDifference = (unsigned)((int)seqNum - (int)oldSeqNum);
+    unsigned newSeqNum        = 0;
+    if(seqNumLT((u_int16_t)oldSeqNum, seqNum)) {
+        // This packet was not an old packet received out of order, so check it:
+
+        if(seqNumDifference >= 0x8000) {
+            // The sequence number wrapped around, so start a new cycle:
+            seqNumCycle += 0x10000;
+        }
+
+        newSeqNum = seqNumCycle | seqNum;
+        if(newSeqNum > fHighestExtSeqNumReceived) {
+            fHighestExtSeqNumReceived = newSeqNum;
+        }
+    }
+    else if(fTotNumPacketsReceived > 1) {
+        // This packet was an old packet received out of order
+
+        if((int)seqNumDifference >= 0x8000) {
+            // The sequence number wrapped around, so switch to an old cycle:
+            seqNumCycle -= 0x10000;
+        }
+
+        newSeqNum = seqNumCycle | seqNum;
+        if(newSeqNum < fBaseExtSeqNumReceived) {
+            fBaseExtSeqNumReceived = newSeqNum;
+        }
+    }
+
+    // Record the inter-packet delay
+    struct timeval timeNow;
+    gettimeofday(&timeNow, NULL);
+    if(fLastPacketReceptionTime.tv_sec != 0 || fLastPacketReceptionTime.tv_usec != 0) {
+        unsigned gap = (timeNow.tv_sec - fLastPacketReceptionTime.tv_sec) * MILLION + timeNow.tv_usec - fLastPacketReceptionTime.tv_usec;
+        if(gap > fMaxInterPacketGapUS) {
+            fMaxInterPacketGapUS = gap;
+        }
+        if(gap < fMinInterPacketGapUS) {
+            fMinInterPacketGapUS = gap;
+        }
+        fTotalInterPacketGaps.tv_usec += gap;
+        if(fTotalInterPacketGaps.tv_usec >= MILLION) {
+            ++fTotalInterPacketGaps.tv_sec;
+            fTotalInterPacketGaps.tv_usec -= MILLION;
+        }
+    }
+    fLastPacketReceptionTime = timeNow;
+
+    // Compute the current 'jitter' using the received packet's RTP timestamp,
+    // and the RTP timestamp that would correspond to the current time.
+    // (Use the code from appendix A.8 in the RTP spec.)
+    // Note, however, that we don't use this packet if its timestamp is
+    // the same as that of the previous packet (this indicates a multi-packet
+    // fragment), or if we've been explicitly told not to use this packet.
+    if(useForJitterCalculation && rtpTimestamp != fPreviousPacketRTPTimestamp) {
+        unsigned arrival = (timestampFrequency * timeNow.tv_sec);
+        arrival += (unsigned)((2.0 * timestampFrequency * timeNow.tv_usec + 1000000.0) / 2000000);
+        // note: rounding
+        int transit = arrival - rtpTimestamp;
+        if(fLastTransit == (~0))
+            fLastTransit = transit;  // hack for first time
+        int d        = transit - fLastTransit;
+        fLastTransit = transit;
+        if(d < 0)
+            d = -d;
+        fJitter += (1.0 / 16.0) * ((double)d - fJitter);
+    }
+
+    // Return the 'presentation time' that corresponds to "rtpTimestamp":
+    if(fSyncTime.tv_sec == 0 && fSyncTime.tv_usec == 0) {
+        // This is the first timestamp that we've seen, so use the current
+        // 'wall clock' time as the synchronization time.  (This will be
+        // corrected later when we receive RTCP SRs.)
+        fSyncTimestamp = rtpTimestamp;
+        fSyncTime      = timeNow;
+    }
+
+    int timestampDiff = rtpTimestamp - fSyncTimestamp;
+    // Note: This works even if the timestamp wraps around
+    // (as long as "int" is 32 bits)
+
+    // Divide this by the timestamp frequency to get real time:
+    double timeDiff = timestampDiff / (double)timestampFrequency;
+
+    // Add this to the 'sync time' to get our result:
+    unsigned const million = 1000000;
+    unsigned       seconds, uSeconds;
+    if(timeDiff >= 0.0) {
+        seconds  = fSyncTime.tv_sec + (unsigned)(timeDiff);
+        uSeconds = fSyncTime.tv_usec + (unsigned)((timeDiff - (unsigned)timeDiff) * million);
+        if(uSeconds >= million) {
+            uSeconds -= million;
+            ++seconds;
+        }
+    }
+    else {
+        timeDiff = -timeDiff;
+        seconds  = fSyncTime.tv_sec - (unsigned)(timeDiff);
+        uSeconds = fSyncTime.tv_usec - (unsigned)((timeDiff - (unsigned)timeDiff) * million);
+        if((int)uSeconds < 0) {
+            uSeconds += million;
+            --seconds;
+        }
+    }
+    resultPresentationTime.tv_sec  = seconds;
+    resultPresentationTime.tv_usec = uSeconds;
+    resultHasBeenSyncedUsingRTCP   = fHasBeenSynchronized;
+
+    // Save these as the new synchronization timestamp & time:
+    fSyncTimestamp = rtpTimestamp;
+    fSyncTime      = resultPresentationTime;
+
+    fPreviousPacketRTPTimestamp = rtpTimestamp;
+}
+
+void RTPReceptionStats::noteIncomingSR(u_int32_t ntpTimestampMSW, u_int32_t ntpTimestampLSW, u_int32_t rtpTimestamp) {
+    fLastReceivedSR_NTPmsw = ntpTimestampMSW;
+    fLastReceivedSR_NTPlsw = ntpTimestampLSW;
+
+    gettimeofday(&fLastReceivedSR_time, NULL);
+
+    // Use this SR to update time synchronization information:
+    fSyncTimestamp       = rtpTimestamp;
+    fSyncTime.tv_sec     = ntpTimestampMSW - 0x83AA7E80;              // 1/1/1900 -> 1/1/1970
+    double microseconds  = (ntpTimestampLSW * 15625.0) / 0x04000000;  // 10^6/2^32
+    fSyncTime.tv_usec    = (unsigned)(microseconds + 0.5);
+    fHasBeenSynchronized = True;
+}
+
+double RTPReceptionStats::totNumKBytesReceived() const {
+    double const hiMultiplier = 0x20000000 / 125.0;  // == (2^32)/(10^3)
+    return fTotBytesReceived_hi * hiMultiplier + fTotBytesReceived_lo / 1000.0;
+}
+
+unsigned RTPReceptionStats::jitter() const {
+    return (unsigned)fJitter;
+}
+
+void RTPReceptionStats::reset() {
+    fNumPacketsReceivedSinceLastReset = 0;
+    fLastResetExtSeqNumReceived       = fHighestExtSeqNumReceived;
+}
+
+Boolean seqNumLT(u_int16_t s1, u_int16_t s2) {
+    // a 'less-than' on 16-bit sequence numbers
+    int diff = s2 - s1;
+    if(diff > 0) {
+        return (diff < 0x8000);
+    }
+    else if(diff < 0) {
+        return (diff < -0x8000);
+    }
+    else {  // diff == 0
+        return False;
+    }
+}
diff --git a/3rdparty/live555/src/liveMedia/RTSPClient.cpp b/3rdparty/live555/src/liveMedia/RTSPClient.cpp
new file mode 100644
index 00000000..c7a640ca
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/RTSPClient.cpp
@@ -0,0 +1,2309 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A generic RTSP client
+// Implementation
+
+#include "RTSPClient.hh"
+#include "RTSPCommon.hh"
+#include "Base64.hh"
+#include "Locale.hh"
+#include <GroupsockHelper.hh>
+#include "ourMD5.hh"
+
+RTSPClient *RTSPClient::createNew(UsageEnvironment &env, char const *rtspURL, int verbosityLevel, char const *applicationName,
+                                  portNumBits tunnelOverHTTPPortNum, int socketNumToServer) {
+    return new RTSPClient(env, rtspURL, verbosityLevel, applicationName, tunnelOverHTTPPortNum, socketNumToServer);
+}
+
+unsigned RTSPClient::sendDescribeCommand(responseHandler *responseHandler, Authenticator *authenticator) {
+    if(fCurrentAuthenticator < authenticator)
+        fCurrentAuthenticator = *authenticator;
+    return sendRequest(new RequestRecord(++fCSeq, "DESCRIBE", responseHandler));
+}
+
+unsigned RTSPClient::sendOptionsCommand(responseHandler *responseHandler, Authenticator *authenticator) {
+    if(fCurrentAuthenticator < authenticator)
+        fCurrentAuthenticator = *authenticator;
+    return sendRequest(new RequestRecord(++fCSeq, "OPTIONS", responseHandler));
+}
+
+unsigned RTSPClient::sendAnnounceCommand(char const *sdpDescription, responseHandler *responseHandler, Authenticator *authenticator) {
+    if(fCurrentAuthenticator < authenticator)
+        fCurrentAuthenticator = *authenticator;
+    return sendRequest(new RequestRecord(++fCSeq, "ANNOUNCE", responseHandler, NULL, NULL, False, 0.0, 0.0, 0.0, sdpDescription));
+}
+
+unsigned RTSPClient::sendSetupCommand(MediaSubsession &subsession, responseHandler *responseHandler, Boolean streamOutgoing, Boolean streamUsingTCP,
+                                      Boolean forceMulticastOnUnspecified, Authenticator *authenticator) {
+    if(fTunnelOverHTTPPortNum != 0)
+        streamUsingTCP = True;  // RTSP-over-HTTP tunneling uses TCP (by definition)
+    if(fCurrentAuthenticator < authenticator)
+        fCurrentAuthenticator = *authenticator;
+
+    u_int32_t booleanFlags = 0;
+    if(streamUsingTCP)
+        booleanFlags |= 0x1;
+    if(streamOutgoing)
+        booleanFlags |= 0x2;
+    if(forceMulticastOnUnspecified)
+        booleanFlags |= 0x4;
+    return sendRequest(new RequestRecord(++fCSeq, "SETUP", responseHandler, NULL, &subsession, booleanFlags));
+}
+
+unsigned RTSPClient::sendPlayCommand(MediaSession &session, responseHandler *responseHandler, double start, double end, float scale,
+                                     Authenticator *authenticator) {
+    if(fCurrentAuthenticator < authenticator)
+        fCurrentAuthenticator = *authenticator;
+    sendDummyUDPPackets(session);  // hack to improve NAT traversal
+    return sendRequest(new RequestRecord(++fCSeq, "PLAY", responseHandler, &session, NULL, 0, start, end, scale));
+}
+
+unsigned RTSPClient::sendPlayCommand(MediaSubsession &subsession, responseHandler *responseHandler, double start, double end, float scale,
+                                     Authenticator *authenticator) {
+    if(fCurrentAuthenticator < authenticator)
+        fCurrentAuthenticator = *authenticator;
+    sendDummyUDPPackets(subsession);  // hack to improve NAT traversal
+    return sendRequest(new RequestRecord(++fCSeq, "PLAY", responseHandler, NULL, &subsession, 0, start, end, scale));
+}
+
+unsigned RTSPClient::sendPlayCommand(MediaSession &session, responseHandler *responseHandler, char const *absStartTime, char const *absEndTime, float scale,
+                                     Authenticator *authenticator) {
+    if(fCurrentAuthenticator < authenticator)
+        fCurrentAuthenticator = *authenticator;
+    sendDummyUDPPackets(session);  // hack to improve NAT traversal
+    return sendRequest(new RequestRecord(++fCSeq, responseHandler, absStartTime, absEndTime, scale, &session, NULL));
+}
+
+unsigned RTSPClient::sendPlayCommand(MediaSubsession &subsession, responseHandler *responseHandler, char const *absStartTime, char const *absEndTime,
+                                     float scale, Authenticator *authenticator) {
+    if(fCurrentAuthenticator < authenticator)
+        fCurrentAuthenticator = *authenticator;
+    sendDummyUDPPackets(subsession);  // hack to improve NAT traversal
+    return sendRequest(new RequestRecord(++fCSeq, responseHandler, absStartTime, absEndTime, scale, NULL, &subsession));
+}
+
+unsigned RTSPClient::sendPauseCommand(MediaSession &session, responseHandler *responseHandler, Authenticator *authenticator) {
+    if(fCurrentAuthenticator < authenticator)
+        fCurrentAuthenticator = *authenticator;
+    return sendRequest(new RequestRecord(++fCSeq, "PAUSE", responseHandler, &session));
+}
+
+unsigned RTSPClient::sendPauseCommand(MediaSubsession &subsession, responseHandler *responseHandler, Authenticator *authenticator) {
+    if(fCurrentAuthenticator < authenticator)
+        fCurrentAuthenticator = *authenticator;
+    return sendRequest(new RequestRecord(++fCSeq, "PAUSE", responseHandler, NULL, &subsession));
+}
+
+unsigned RTSPClient::sendRecordCommand(MediaSession &session, responseHandler *responseHandler, Authenticator *authenticator) {
+    if(fCurrentAuthenticator < authenticator)
+        fCurrentAuthenticator = *authenticator;
+    return sendRequest(new RequestRecord(++fCSeq, "RECORD", responseHandler, &session));
+}
+
+unsigned RTSPClient::sendRecordCommand(MediaSubsession &subsession, responseHandler *responseHandler, Authenticator *authenticator) {
+    if(fCurrentAuthenticator < authenticator)
+        fCurrentAuthenticator = *authenticator;
+    return sendRequest(new RequestRecord(++fCSeq, "RECORD", responseHandler, NULL, &subsession));
+}
+
+unsigned RTSPClient::sendTeardownCommand(MediaSession &session, responseHandler *responseHandler, Authenticator *authenticator) {
+    if(fCurrentAuthenticator < authenticator)
+        fCurrentAuthenticator = *authenticator;
+    return sendRequest(new RequestRecord(++fCSeq, "TEARDOWN", responseHandler, &session));
+}
+
+unsigned RTSPClient::sendTeardownCommand(MediaSubsession &subsession, responseHandler *responseHandler, Authenticator *authenticator) {
+    if(fCurrentAuthenticator < authenticator)
+        fCurrentAuthenticator = *authenticator;
+    return sendRequest(new RequestRecord(++fCSeq, "TEARDOWN", responseHandler, NULL, &subsession));
+}
+
+unsigned RTSPClient::sendSetParameterCommand(MediaSession &session, responseHandler *responseHandler, char const *parameterName, char const *parameterValue,
+                                             Authenticator *authenticator) {
+    if(fCurrentAuthenticator < authenticator)
+        fCurrentAuthenticator = *authenticator;
+    char *paramString = new char[strlen(parameterName) + strlen(parameterValue) + 10];
+    sprintf(paramString, "%s: %s\r\n", parameterName, parameterValue);
+    unsigned result = sendRequest(new RequestRecord(++fCSeq, "SET_PARAMETER", responseHandler, &session, NULL, False, 0.0, 0.0, 0.0, paramString));
+    delete[] paramString;
+    return result;
+}
+
+unsigned RTSPClient::sendGetParameterCommand(MediaSession &session, responseHandler *responseHandler, char const *parameterName, Authenticator *authenticator) {
+    if(fCurrentAuthenticator < authenticator)
+        fCurrentAuthenticator = *authenticator;
+
+    // We assume that:
+    //    parameterName is NULL or "" means: Send no body in the request.
+    //    parameterName is non-empty means: Send "<parameterName>\r\n" as the request body.
+    unsigned parameterNameLen = parameterName == NULL ? 0 : strlen(parameterName);
+    char    *paramString      = new char[parameterNameLen + 3];  // the 3 is for \r\n + the '\0' byte
+    if(parameterName == NULL || parameterName[0] == '\0') {
+        paramString[0] = '\0';
+    }
+    else {
+        sprintf(paramString, "%s\r\n", parameterName);
+    }
+    unsigned result = sendRequest(new RequestRecord(++fCSeq, "GET_PARAMETER", responseHandler, &session, NULL, False, 0.0, 0.0, 0.0, paramString));
+    delete[] paramString;
+    return result;
+}
+
+static char *createRequireString(char const *requireValue) {
+    char buf[100];
+    if(requireValue == NULL) {
+        // This is the default value; we don't need a "Require:" header:
+        buf[0] = '\0';
+    }
+    else {
+        snprintf(buf, sizeof buf, "Require: %s\r\n", requireValue);
+    }
+
+    return strDup(buf);
+}
+
+void RTSPClient::setRequireValue(char const *requireValue) {
+    delete[] fRequireStr;
+    fRequireStr = createRequireString(requireValue);
+}
+
+void RTSPClient::sendDummyUDPPackets(MediaSession &session, unsigned numDummyPackets) {
+    MediaSubsessionIterator iter(session);
+    MediaSubsession        *subsession;
+
+    while((subsession = iter.next()) != NULL) {
+        sendDummyUDPPackets(*subsession, numDummyPackets);
+    }
+}
+
+void RTSPClient::sendDummyUDPPackets(MediaSubsession &subsession, unsigned numDummyPackets) {
+    // Hack: To increase the likelihood of UDP packets from the server reaching us,
+    // if we're behind a NAT, send a few 'dummy' UDP packets to the server now.
+    // (We do this on both our RTP port and our RTCP port.)
+    Groupsock *gs1 = NULL;
+    Groupsock *gs2 = NULL;
+    if(subsession.rtpSource() != NULL)
+        gs1 = subsession.rtpSource()->RTPgs();
+    if(subsession.rtcpInstance() != NULL)
+        gs2 = subsession.rtcpInstance()->RTCPgs();
+    u_int32_t const dummy = 0xFEEDFACE;
+    for(unsigned i = 0; i < numDummyPackets; ++i) {
+        if(gs1 != NULL)
+            gs1->output(envir(), (unsigned char *)&dummy, sizeof dummy);
+        if(gs2 != NULL)
+            gs2->output(envir(), (unsigned char *)&dummy, sizeof dummy);
+    }
+}
+
+void RTSPClient::setSpeed(MediaSession &session, float speed) {
+    // Optionally set download speed for session to be used later on PLAY command:
+    // The user should call this function after the MediaSession is instantiated, but before the
+    // first "sendPlayCommand()" is called.
+    session.speed() = speed;
+    MediaSubsessionIterator iter(session);
+    MediaSubsession        *subsession;
+
+    while((subsession = iter.next()) != NULL) {
+        subsession->speed() = speed;
+    }
+}
+
+Boolean RTSPClient::changeResponseHandler(unsigned cseq, responseHandler *newResponseHandler) {
+    // Look for the matching request record in each of our 'pending requests' queues:
+    RequestRecord *request;
+    if((request = fRequestsAwaitingConnection.findByCSeq(cseq)) != NULL || (request = fRequestsAwaitingHTTPTunneling.findByCSeq(cseq)) != NULL
+       || (request = fRequestsAwaitingResponse.findByCSeq(cseq)) != NULL) {
+        request->handler() = newResponseHandler;
+        return True;
+    }
+
+    return False;
+}
+
+Boolean RTSPClient::lookupByName(UsageEnvironment &env, char const *instanceName, RTSPClient *&resultClient) {
+    resultClient = NULL;  // unless we succeed
+
+    Medium *medium;
+    if(!Medium::lookupByName(env, instanceName, medium))
+        return False;
+
+    if(!medium->isRTSPClient()) {
+        env.setResultMsg(instanceName, " is not a RTSP client");
+        return False;
+    }
+
+    resultClient = (RTSPClient *)medium;
+    return True;
+}
+
+static void copyUsernameOrPasswordStringFromURL(char *dest, char const *src, unsigned len) {
+    // Normally, we just copy from the source to the destination.  However, if the source contains
+    // %-encoded characters, then we decode them while doing the copy:
+    while(len > 0) {
+        int nBefore = 0;
+        int nAfter  = 0;
+
+        if(*src == '%' && len >= 3 && sscanf(src + 1, "%n%2hhx%n", &nBefore, dest, &nAfter) == 1) {
+            unsigned codeSize = nAfter - nBefore;  // should be 1 or 2
+
+            ++dest;
+            src += (1 + codeSize);
+            len -= (1 + codeSize);
+        }
+        else {
+            *dest++ = *src++;
+            --len;
+        }
+    }
+    *dest = '\0';
+}
+
+Boolean RTSPClient::parseRTSPURL(char const *url, char *&username, char *&password, NetAddress &address, portNumBits &portNum, char const **urlSuffix) {
+    do {
+        // Parse the URL as "rtsp://[<username>[:<password>]@]<server-address-or-name>[:<port>][/<stream-name>]" (or "rtsps://...")
+        char const    *rtspPrefix        = "rtsp://";
+        unsigned const rtspPrefixLength  = 7;
+        char const    *rtspsPrefix       = "rtsps://";
+        unsigned const rtspsPrefixLength = 8;
+
+        portNumBits defaultPortNumber;
+        char const *from;
+        if(_strncasecmp(url, rtspPrefix, rtspPrefixLength) == 0) {
+            defaultPortNumber = 554;
+            from              = &url[rtspPrefixLength];
+        }
+        else if(_strncasecmp(url, rtspsPrefix, rtspsPrefixLength) == 0) {
+            useTLS();
+            defaultPortNumber = 322;
+            from              = &url[rtspsPrefixLength];
+        }
+        else {
+            envir().setResultMsg("URL does not begin with \"rtsp://\" or \"rtsps://\"");
+            break;
+        }
+
+        unsigned const parseBufferSize = 100;
+        char           parseBuffer[parseBufferSize];
+
+        // Check whether "<username>[:<password>]@" occurs next.
+        // We do this by checking whether '@' appears before the end of the URL, or before the first '/'.
+        username = password            = NULL;  // default return values
+        char const *colonPasswordStart = NULL;
+        char const *lastAtPtr          = NULL;
+        for(char const *p = from; *p != '\0' && *p != '/'; ++p) {
+            if(*p == ':' && colonPasswordStart == NULL) {
+                colonPasswordStart = p;
+            }
+            else if(*p == '@') {
+                lastAtPtr = p;
+            }
+        }
+        if(lastAtPtr != NULL) {
+            // We found <username> (and perhaps <password>).  Copy them into newly-allocated result strings:
+            if(colonPasswordStart == NULL || colonPasswordStart > lastAtPtr)
+                colonPasswordStart = lastAtPtr;
+
+            char const *usernameStart = from;
+            unsigned    usernameLen   = colonPasswordStart - usernameStart;
+            username                  = new char[usernameLen + 1];  // allow for the trailing '\0'
+            copyUsernameOrPasswordStringFromURL(username, usernameStart, usernameLen);
+
+            char const *passwordStart = colonPasswordStart;
+            if(passwordStart < lastAtPtr)
+                ++passwordStart;  // skip over the ':'
+            unsigned passwordLen = lastAtPtr - passwordStart;
+            password             = new char[passwordLen + 1];  // allow for the trailing '\0'
+            copyUsernameOrPasswordStringFromURL(password, passwordStart, passwordLen);
+
+            from = lastAtPtr + 1;  // skip over the '@'
+        }
+
+        // Next, parse <server-address-or-name>
+        char   *to                 = &parseBuffer[0];
+        Boolean isInSquareBrackets = False;  //  by default
+        if(*from == '[') {
+            ++from;
+            isInSquareBrackets = True;
+        }
+        unsigned i;
+        for(i = 0; i < parseBufferSize; ++i) {
+            if(*from == '\0' || (*from == ':' && !isInSquareBrackets) || *from == '/' || (*from == ']' && isInSquareBrackets)) {
+                // We've completed parsing the address
+                *to = '\0';
+                if(*from == ']' && isInSquareBrackets)
+                    ++from;
+                break;
+            }
+            *to++ = *from++;
+        }
+        if(i == parseBufferSize) {
+            envir().setResultMsg("URL is too long");
+            break;
+        }
+
+        NetAddressList addresses(parseBuffer);
+        if(addresses.numAddresses() == 0) {
+            envir().setResultMsg("Failed to find network address for \"", parseBuffer, "\"");
+            break;
+        }
+        address = *(addresses.firstAddress());
+
+        portNum       = defaultPortNumber;  // unless it's specified explicitly in the URL
+        char nextChar = *from;
+        if(nextChar == ':') {
+            int portNumInt;
+            if(sscanf(++from, "%d", &portNumInt) != 1) {
+                envir().setResultMsg("No port number follows ':'");
+                break;
+            }
+            if(portNumInt < 1 || portNumInt > 65535) {
+                envir().setResultMsg("Bad port number");
+                break;
+            }
+            portNum = (portNumBits)portNumInt;
+            while(*from >= '0' && *from <= '9')
+                ++from;  // skip over port number
+        }
+
+        // The remainder of the URL is the suffix:
+        if(urlSuffix != NULL)
+            *urlSuffix = from;
+
+        return True;
+    } while(0);
+
+    // An error occurred in the parsing:
+    return False;
+}
+
+void RTSPClient::setUserAgentString(char const *userAgentName) {
+    if(userAgentName == NULL)
+        return;
+
+    // Change the existing user agent header string:
+    char const *const formatStr  = "User-Agent: %s\r\n";
+    unsigned const    headerSize = strlen(formatStr) + strlen(userAgentName);
+    delete[] fUserAgentHeaderStr;
+    fUserAgentHeaderStr = new char[headerSize];
+    sprintf(fUserAgentHeaderStr, formatStr, userAgentName);
+    fUserAgentHeaderStrLen = strlen(fUserAgentHeaderStr);
+}
+
+unsigned RTSPClient::responseBufferSize = 20000;  // default value; you can reassign this in your application if you need to
+
+RTSPClient::RTSPClient(UsageEnvironment &env, char const *rtspURL, int verbosityLevel, char const *applicationName, portNumBits tunnelOverHTTPPortNum,
+                       int socketNumToServer)
+    : Medium(env),
+      desiredMaxIncomingPacketSize(0),
+      fVerbosityLevel(verbosityLevel),
+      fCSeq(1),
+      fAllowBasicAuthentication(True),
+      fTunnelOverHTTPPortNum(tunnelOverHTTPPortNum),
+      fUserAgentHeaderStr(NULL),
+      fUserAgentHeaderStrLen(0),
+      fInputSocketNum(-1),
+      fOutputSocketNum(-1),
+      fBaseURL(NULL),
+      fTCPStreamIdCount(0),
+      fLastSessionId(NULL),
+      fSessionTimeoutParameter(0),
+      fRequireStr(NULL),
+      fSessionCookieCounter(0),
+      fHTTPTunnelingConnectionIsPending(False),
+      fTLS(*this) {
+    setBaseURL(rtspURL);
+
+    fResponseBuffer = new char[responseBufferSize + 1];
+    resetResponseBuffer();
+
+    setRequireValue();
+
+    if(socketNumToServer >= 0) {
+        // This socket number is (assumed to be) already connected to the server.
+        // Use it, and arrange to handle responses to requests sent on it:
+        fInputSocketNum = fOutputSocketNum = socketNumToServer;
+        env.taskScheduler().setBackgroundHandling(fInputSocketNum, SOCKET_READABLE | SOCKET_EXCEPTION,
+                                                  (TaskScheduler::BackgroundHandlerProc *)&incomingDataHandler, this);
+    }
+
+    // Set the "User-Agent:" header to use in each request:
+    char const *const libName       = "LIVE555 Streaming Media v";
+    char const *const libVersionStr = LIVEMEDIA_LIBRARY_VERSION_STRING;
+    char const       *libPrefix;
+    char const       *libSuffix;
+    if(applicationName == NULL || applicationName[0] == '\0') {
+        applicationName = libPrefix = libSuffix = "";
+    }
+    else {
+        libPrefix = " (";
+        libSuffix = ")";
+    }
+    unsigned userAgentNameSize = strlen(applicationName) + strlen(libPrefix) + strlen(libName) + strlen(libVersionStr) + strlen(libSuffix) + 1;
+    char    *userAgentName     = new char[userAgentNameSize];
+    sprintf(userAgentName, "%s%s%s%s%s", applicationName, libPrefix, libName, libVersionStr, libSuffix);
+    setUserAgentString(userAgentName);
+    delete[] userAgentName;
+}
+
+RTSPClient::~RTSPClient() {
+    reset();
+
+    delete[] fRequireStr;
+    delete[] fResponseBuffer;
+    delete[] fUserAgentHeaderStr;
+}
+
+void RTSPClient::reset() {
+    resetTCPSockets();
+    resetResponseBuffer();
+    fRequestsAwaitingConnection.reset();
+    fRequestsAwaitingHTTPTunneling.reset();
+    fRequestsAwaitingResponse.reset();
+
+    setBaseURL(NULL);
+
+    fCurrentAuthenticator.reset();
+
+    delete[] fLastSessionId;
+    fLastSessionId = NULL;
+}
+
+void RTSPClient::setBaseURL(char const *url) {
+    delete[] fBaseURL;
+    fBaseURL = strDup(url);
+}
+
+int RTSPClient::grabSocket() {
+    int inputSocket = fInputSocketNum;
+    RTPInterface::clearServerRequestAlternativeByteHandler(envir(), fInputSocketNum);  // in case we were receiving RTP-over-TCP
+    fInputSocketNum = -1;
+
+    return inputSocket;
+}
+
+unsigned RTSPClient::sendRequest(RequestRecord *request) {
+    char *cmd = NULL;
+    do {
+        Boolean connectionIsPending = False;
+        if(!fRequestsAwaitingConnection.isEmpty()) {
+            // A connection is currently pending (with at least one enqueued request).  Enqueue this request also:
+            connectionIsPending = True;
+        }
+        else if(fInputSocketNum < 0) {  // we need to open a connection
+            int connectResult = openConnection();
+            if(connectResult < 0)
+                break;  // an error occurred
+            else if(connectResult == 0) {
+                // A connection is pending
+                connectionIsPending = True;
+            }  // else the connection succeeded.  Continue sending the command.
+        }
+        if(connectionIsPending) {
+            fRequestsAwaitingConnection.enqueue(request);
+            return request->cseq();
+        }
+
+        // If requested (and we're not already doing it, or have done it), set up the special protocol for tunneling RTSP-over-HTTP:
+        if(fTunnelOverHTTPPortNum != 0 && strcmp(request->commandName(), "GET") != 0 && fOutputSocketNum == fInputSocketNum) {
+            if(!setupHTTPTunneling1())
+                break;
+            fRequestsAwaitingHTTPTunneling.enqueue(request);
+            return request->cseq();
+        }
+
+        // Construct and send the command:
+
+        // First, construct command-specific headers that we need:
+
+        char   *cmdURL             = fBaseURL;  // by default
+        Boolean cmdURLWasAllocated = False;
+
+        char const *protocolStr = "RTSP/1.0";  // by default
+
+        char   *extraHeaders              = (char *)"";  // by default
+        Boolean extraHeadersWereAllocated = False;
+
+        char   *contentLengthHeader             = (char *)"";  // by default
+        Boolean contentLengthHeaderWasAllocated = False;
+
+        if(!setRequestFields(request, cmdURL, cmdURLWasAllocated, protocolStr, extraHeaders, extraHeadersWereAllocated)) {
+            break;
+        }
+
+        char const *contentStr = request->contentStr();  // by default
+        if(contentStr == NULL)
+            contentStr = "";
+        unsigned contentStrLen = strlen(contentStr);
+        if(contentStrLen > 0) {
+            char const *contentLengthHeaderFmt  = "Content-Length: %d\r\n";
+            unsigned    contentLengthHeaderSize = strlen(contentLengthHeaderFmt) + 20 /* max int len */;
+            contentLengthHeader                 = new char[contentLengthHeaderSize];
+            sprintf(contentLengthHeader, contentLengthHeaderFmt, contentStrLen);
+            contentLengthHeaderWasAllocated = True;
+        }
+
+        char *authenticatorStr = createAuthenticatorString(request->commandName(), fBaseURL);
+
+        char const *const cmdFmt  = "%s %s %s\r\n"
+                                    "CSeq: %d\r\n"
+                                    "%s"
+                                    "%s"
+                                    "%s"
+                                    "%s"
+                                    "%s"
+                                    "\r\n"
+                                    "%s";
+        unsigned          cmdSize = strlen(cmdFmt) + strlen(request->commandName()) + strlen(cmdURL) + strlen(protocolStr) + 20 /* max int len */
+                           + strlen(authenticatorStr) + fUserAgentHeaderStrLen + strlen(fRequireStr) + strlen(extraHeaders) + strlen(contentLengthHeader)
+                           + contentStrLen;
+        cmd = new char[cmdSize];
+        sprintf(cmd, cmdFmt, request->commandName(), cmdURL, protocolStr, request->cseq(), authenticatorStr, fUserAgentHeaderStr, fRequireStr, extraHeaders,
+                contentLengthHeader, contentStr);
+        delete[] authenticatorStr;
+        if(cmdURLWasAllocated)
+            delete[] cmdURL;
+        if(extraHeadersWereAllocated)
+            delete[] extraHeaders;
+        if(contentLengthHeaderWasAllocated)
+            delete[] contentLengthHeader;
+
+        if(fVerbosityLevel >= 1)
+            envir() << "Sending request: " << cmd << "\n";
+
+        if(fTunnelOverHTTPPortNum != 0 && strcmp(request->commandName(), "GET") != 0 && strcmp(request->commandName(), "POST") != 0) {
+            // When we're tunneling RTSP-over-HTTP, we Base-64-encode the request before we send it.
+            // (However, we don't do this for the HTTP "GET" and "POST" commands that we use to set up the tunnel.)
+            char *origCmd = cmd;
+            cmd           = base64Encode(origCmd, strlen(cmd));
+            if(fVerbosityLevel >= 1)
+                envir() << "\tThe request was base-64 encoded to: " << cmd << "\n\n";
+            delete[] origCmd;
+        }
+
+        if(write(cmd, strlen(cmd)) < 0) {
+            char const    *errFmt    = "%s write() failed: ";
+            unsigned const errLength = strlen(errFmt) + strlen(request->commandName());
+            char          *err       = new char[errLength];
+            sprintf(err, errFmt, request->commandName());
+            envir().setResultErrMsg(err);
+            delete[] err;
+            break;
+        }
+
+        // The command send succeeded, so enqueue the request record, so that its response (when it comes) can be handled.
+        // However, note that we do not expect a response to a POST command with RTSP-over-HTTP, so don't enqueue that.
+        int cseq = request->cseq();
+
+        if(fTunnelOverHTTPPortNum == 0 || strcmp(request->commandName(), "POST") != 0) {
+            fRequestsAwaitingResponse.enqueue(request);
+        }
+        else {
+            delete request;
+        }
+
+        delete[] cmd;
+        return cseq;
+    } while(0);
+
+    // An error occurred, so call the response handler immediately (indicating the error):
+    delete[] cmd;
+    handleRequestError(request);
+    delete request;
+    return 0;
+}
+
+static char *createSessionString(char const *sessionId) {
+    char *sessionStr;
+    if(sessionId != NULL) {
+        sessionStr = new char[20 + strlen(sessionId)];
+        sprintf(sessionStr, "Session: %s\r\n", sessionId);
+    }
+    else {
+        sessionStr = strDup("");
+    }
+    return sessionStr;
+}
+
+// Add support for faster download using the "speed:" option on PLAY
+static char *createSpeedString(float speed) {
+    char buf[100];
+    if(speed == 1.0f) {
+        // This is the default value; we don't need a "Speed:" header:
+        buf[0] = '\0';
+    }
+    else {
+        sprintf(buf, "Speed: %.3f\r\n", speed);
+    }
+
+    return strDup(buf);
+}
+
+static char *createScaleString(float scale, float currentScale) {
+    char buf[100];
+    if(scale == 1.0f && currentScale == 1.0f) {
+        // This is the default value; we don't need a "Scale:" header:
+        buf[0] = '\0';
+    }
+    else {
+        Locale l("C", Numeric);
+        sprintf(buf, "Scale: %f\r\n", scale);
+    }
+
+    return strDup(buf);
+}
+
+static char *createRangeString(double start, double end, char const *absStartTime, char const *absEndTime) {
+    char buf[100];
+
+    if(absStartTime != NULL) {
+        // Create a "Range:" header that specifies 'absolute' time values:
+
+        if(absEndTime == NULL) {
+            // There's no end time:
+            snprintf(buf, sizeof buf, "Range: clock=%s-\r\n", absStartTime);
+        }
+        else {
+            // There's both a start and an end time; include them both in the "Range:" hdr
+            snprintf(buf, sizeof buf, "Range: clock=%s-%s\r\n", absStartTime, absEndTime);
+        }
+    }
+    else {
+        // Create a "Range:" header that specifies relative (i.e., NPT) time values:
+
+        if(start < 0) {
+            // We're resuming from a PAUSE; there's no "Range:" header at all
+            buf[0] = '\0';
+        }
+        else if(end < 0) {
+            // There's no end time:
+            Locale l("C", Numeric);
+            sprintf(buf, "Range: npt=%.3f-\r\n", start);
+        }
+        else {
+            // There's both a start and an end time; include them both in the "Range:" hdr
+            Locale l("C", Numeric);
+            sprintf(buf, "Range: npt=%.3f-%.3f\r\n", start, end);
+        }
+    }
+
+    return strDup(buf);
+}
+
+Boolean RTSPClient::setRequestFields(RequestRecord *request, char *&cmdURL, Boolean &cmdURLWasAllocated, char const *&protocolStr, char *&extraHeaders,
+                                     Boolean &extraHeadersWereAllocated) {
+    // Set various fields that will appear in our outgoing request, depending upon the particular command that we are sending.
+
+    if(strcmp(request->commandName(), "DESCRIBE") == 0) {
+        extraHeaders = (char *)"Accept: application/sdp\r\n";
+    }
+    else if(strcmp(request->commandName(), "OPTIONS") == 0) {
+        // If we're currently part of a session, create a "Session:" header (in case the server wants this to indicate
+        // client 'liveness); this makes up our 'extra headers':
+        extraHeaders              = createSessionString(fLastSessionId);
+        extraHeadersWereAllocated = True;
+    }
+    else if(strcmp(request->commandName(), "ANNOUNCE") == 0) {
+        extraHeaders = (char *)"Content-Type: application/sdp\r\n";
+    }
+    else if(strcmp(request->commandName(), "SETUP") == 0) {
+        MediaSubsession &subsession                  = *request->subsession();
+        Boolean          streamUsingTCP              = (request->booleanFlags() & 0x1) != 0;
+        Boolean          streamOutgoing              = (request->booleanFlags() & 0x2) != 0;
+        Boolean          forceMulticastOnUnspecified = (request->booleanFlags() & 0x4) != 0;
+
+        char const *prefix, *separator, *suffix;
+        constructSubsessionURL(subsession, prefix, separator, suffix);
+
+        char const *transportFmt;
+        if(strcmp(subsession.protocolName(), "RTP") == 0) {
+            transportFmt = "Transport: RTP/AVP%s%s%s=%d-%d\r\n";
+        }
+        else if(strcmp(subsession.protocolName(), "SRTP") == 0) {
+            transportFmt = "Transport: RTP/SAVP%s%s%s=%d-%d\r\n";
+        }
+        else {  // "UDP"
+            suffix       = "";
+            transportFmt = "Transport: RAW/RAW/UDP%s%s%s=%d-%d\r\n";
+        }
+
+        cmdURL             = new char[strlen(prefix) + strlen(separator) + strlen(suffix) + 1];
+        cmdURLWasAllocated = True;
+        sprintf(cmdURL, "%s%s%s", prefix, separator, suffix);
+
+        // Construct a "Transport:" header.
+        char const *transportTypeStr;
+        char const *modeStr = streamOutgoing ? ";mode=receive" : "";
+        // Note: I think the above is nonstandard, but DSS wants it this way
+        char const *portTypeStr;
+        portNumBits rtpNumber, rtcpNumber;
+        if(streamUsingTCP) {  // streaming over the RTSP connection
+            transportTypeStr = "/TCP;unicast";
+            portTypeStr      = ";interleaved";
+            rtpNumber        = fTCPStreamIdCount++;
+            rtcpNumber       = fTCPStreamIdCount++;
+        }
+        else {  // normal RTP streaming
+            struct sockaddr_storage connectionAddress;
+            subsession.getConnectionEndpointAddress(connectionAddress);
+            Boolean requestMulticastStreaming = IsMulticastAddress(connectionAddress) || (forceMulticastOnUnspecified && addressIsNull(connectionAddress));
+            transportTypeStr                  = requestMulticastStreaming ? ";multicast" : ";unicast";
+            portTypeStr                       = requestMulticastStreaming ? ";port" : ";client_port";
+            rtpNumber                         = subsession.clientPortNum();
+            if(rtpNumber == 0) {
+                envir().setResultMsg("Client port number unknown\n");
+                delete[] cmdURL;
+                return False;
+            }
+            rtcpNumber = subsession.rtcpIsMuxed() ? rtpNumber : rtpNumber + 1;
+        }
+        unsigned transportSize = strlen(transportFmt) + strlen(transportTypeStr) + strlen(modeStr) + strlen(portTypeStr) + 2 * 5 /* max port len */;
+        char    *transportStr  = new char[transportSize];
+        sprintf(transportStr, transportFmt, transportTypeStr, modeStr, portTypeStr, rtpNumber, rtcpNumber);
+
+        // When sending more than one "SETUP" request, include a "Session:" header in the 2nd and later commands:
+        char *sessionStr = createSessionString(fLastSessionId);
+
+        // Optionally include a "Blocksize:" string:
+        char *blocksizeStr = createBlocksizeString(streamUsingTCP);
+
+        // Optionally include a "KeyMgmt:" string:
+        char *keyMgmtStr = createKeyMgmtString(cmdURL, subsession);
+
+        // The "Transport:", "Session:" (if present), "Blocksize:" (if present), and "KeyMgmt:" (if present)
+        // headers make up the 'extra headers':
+        extraHeaders              = new char[transportSize + strlen(sessionStr) + strlen(blocksizeStr) + strlen(keyMgmtStr) + 1];
+        extraHeadersWereAllocated = True;
+        sprintf(extraHeaders, "%s%s%s%s", transportStr, sessionStr, blocksizeStr, keyMgmtStr);
+        delete[] transportStr;
+        delete[] sessionStr;
+        delete[] blocksizeStr;
+        delete[] keyMgmtStr;
+    }
+    else if(strcmp(request->commandName(), "GET") == 0 || strcmp(request->commandName(), "POST") == 0) {
+        // We will be sending a HTTP (not a RTSP) request.
+        // Begin by re-parsing our RTSP URL, to get the stream name (which we'll use as our 'cmdURL'
+        // in the subsequent request), and the server address (which we'll use in a "Host:" header):
+        char       *username;
+        char       *password;
+        NetAddress  destAddress;
+        portNumBits urlPortNum;
+        if(!parseRTSPURL(fBaseURL, username, password, destAddress, urlPortNum, (char const **)&cmdURL))
+            return False;
+        if(cmdURL[0] == '\0')
+            cmdURL = (char *)"/";
+        delete[] username;
+        delete[] password;
+
+        struct sockaddr_storage serverAddr;
+        copyAddress(serverAddr, &destAddress);
+        AddressString serverAddressString(serverAddr);
+
+        protocolStr = "HTTP/1.0";
+
+        if(strcmp(request->commandName(), "GET") == 0) {
+            // Create a 'session cookie' string, using MD5:
+            struct {
+                struct timeval timestamp;
+                unsigned       counter;
+            } seedData;
+            gettimeofday(&seedData.timestamp, NULL);
+            seedData.counter = ++fSessionCookieCounter;
+            our_MD5Data((unsigned char *)(&seedData), sizeof seedData, fSessionCookie);
+            // DSS seems to require that the 'session cookie' string be 22 bytes long:
+            fSessionCookie[23] = '\0';
+
+            char const *const extraHeadersFmt  = "Host: %s\r\n"
+                                                 "x-sessioncookie: %s\r\n"
+                                                 "Accept: application/x-rtsp-tunnelled\r\n"
+                                                 "Pragma: no-cache\r\n"
+                                                 "Cache-Control: no-cache\r\n";
+            unsigned          extraHeadersSize = strlen(extraHeadersFmt) + strlen(serverAddressString.val()) + strlen(fSessionCookie);
+            extraHeaders                       = new char[extraHeadersSize];
+            extraHeadersWereAllocated          = True;
+            sprintf(extraHeaders, extraHeadersFmt, serverAddressString.val(), fSessionCookie);
+        }
+        else {  // "POST"
+            char const *const extraHeadersFmt  = "Host: %s\r\n"
+                                                 "x-sessioncookie: %s\r\n"
+                                                 "Content-Type: application/x-rtsp-tunnelled\r\n"
+                                                 "Pragma: no-cache\r\n"
+                                                 "Cache-Control: no-cache\r\n"
+                                                 "Content-Length: 32767\r\n"
+                                                 "Expires: Sun, 9 Jan 1972 00:00:00 GMT\r\n";
+            unsigned          extraHeadersSize = strlen(extraHeadersFmt) + strlen(serverAddressString.val()) + strlen(fSessionCookie);
+            extraHeaders                       = new char[extraHeadersSize];
+            extraHeadersWereAllocated          = True;
+            sprintf(extraHeaders, extraHeadersFmt, serverAddressString.val(), fSessionCookie);
+        }
+    }
+    else {  // "PLAY", "PAUSE", "TEARDOWN", "RECORD", "SET_PARAMETER", "GET_PARAMETER"
+        // First, make sure that we have a RTSP session in progress
+        if(fLastSessionId == NULL) {
+            envir().setResultMsg("No RTSP session is currently in progress\n");
+            return False;
+        }
+
+        char const *sessionId;
+        float       originalScale;
+        if(request->session() != NULL) {
+            // Session-level operation
+            cmdURL = (char *)sessionURL(*request->session());
+
+            sessionId     = fLastSessionId;
+            originalScale = request->session()->scale();
+        }
+        else {
+            // Media-level operation
+            char const *prefix, *separator, *suffix;
+            constructSubsessionURL(*request->subsession(), prefix, separator, suffix);
+            cmdURL             = new char[strlen(prefix) + strlen(separator) + strlen(suffix) + 1];
+            cmdURLWasAllocated = True;
+            sprintf(cmdURL, "%s%s%s", prefix, separator, suffix);
+
+            sessionId     = request->subsession()->sessionId();
+            originalScale = request->subsession()->scale();
+        }
+
+        if(strcmp(request->commandName(), "PLAY") == 0) {
+            // Create possible "Session:", "Scale:", "Speed:", and "Range:" headers;
+            // these make up the 'extra headers':
+            char *sessionStr          = createSessionString(sessionId);
+            char *scaleStr            = createScaleString(request->scale(), originalScale);
+            float speed               = request->session() != NULL ? request->session()->speed() : request->subsession()->speed();
+            char *speedStr            = createSpeedString(speed);
+            char *rangeStr            = createRangeString(request->start(), request->end(), request->absStartTime(), request->absEndTime());
+            extraHeaders              = new char[strlen(sessionStr) + strlen(scaleStr) + strlen(speedStr) + strlen(rangeStr) + 1];
+            extraHeadersWereAllocated = True;
+            sprintf(extraHeaders, "%s%s%s%s", sessionStr, scaleStr, speedStr, rangeStr);
+            delete[] sessionStr;
+            delete[] scaleStr;
+            delete[] speedStr;
+            delete[] rangeStr;
+        }
+        else {
+            // Create a "Session:" header; this makes up our 'extra headers':
+            extraHeaders              = createSessionString(sessionId);
+            extraHeadersWereAllocated = True;
+        }
+    }
+
+    return True;
+}
+
+Boolean RTSPClient::isRTSPClient() const {
+    return True;
+}
+
+void RTSPClient::resetTCPSockets() {
+    if(fInputSocketNum >= 0) {
+        RTPInterface::clearServerRequestAlternativeByteHandler(envir(), fInputSocketNum);  // in case we were receiving RTP-over-TCP
+        envir().taskScheduler().disableBackgroundHandling(fInputSocketNum);
+        ::closeSocket(fInputSocketNum);
+        if(fOutputSocketNum != fInputSocketNum) {
+            envir().taskScheduler().disableBackgroundHandling(fOutputSocketNum);
+            ::closeSocket(fOutputSocketNum);
+        }
+    }
+    fInputSocketNum = fOutputSocketNum = -1;
+}
+
+void RTSPClient::resetResponseBuffer() {
+    fResponseBytesAlreadySeen = 0;
+    fResponseBufferBytesLeft  = responseBufferSize;
+}
+
+int RTSPClient::openConnection() {
+    do {
+        // Set up a connection to the server.  Begin by parsing the URL:
+
+        char       *username;
+        char       *password;
+        NetAddress  destAddress;
+        portNumBits urlPortNum;
+        char const *urlSuffix;
+        if(!parseRTSPURL(fBaseURL, username, password, destAddress, urlPortNum, &urlSuffix))
+            break;
+        portNumBits destPortNum = fTunnelOverHTTPPortNum == 0 ? urlPortNum : fTunnelOverHTTPPortNum;
+        if(destPortNum == 322)
+            useTLS();  // port 322 is a special case: "rtsps"
+
+        if(username != NULL || password != NULL) {
+            fCurrentAuthenticator.setUsernameAndPassword(username, password);
+            delete[] username;
+            delete[] password;
+        }
+
+        // We don't yet have a TCP socket (or we used to have one, but it got closed).  Set it up now.
+        copyAddress(fServerAddress, &destAddress);
+        fInputSocketNum = setupStreamSocket(envir(), 0, fServerAddress.ss_family);
+        if(fInputSocketNum < 0)
+            break;
+        ignoreSigPipeOnSocket(fInputSocketNum);  // so that servers on the same host that get killed don't also kill us
+        if(fOutputSocketNum < 0)
+            fOutputSocketNum = fInputSocketNum;
+        if(fVerbosityLevel >= 1)
+            envir() << "Created new TCP socket " << fInputSocketNum << " for connection\n";
+
+        // Connect to the remote endpoint:
+        int connectResult = connectToServer(fInputSocketNum, destPortNum);
+        if(connectResult < 0)
+            break;
+        else if(connectResult > 0) {
+            if(fTLS.isNeeded) {
+                // We need to complete an additional TLS connection:
+                connectResult = fTLS.connect(fInputSocketNum);
+                if(connectResult < 0)
+                    break;
+                if(connectResult > 0 && fVerbosityLevel >= 1)
+                    envir() << "...TLS connection completed\n";
+            }
+
+            if(connectResult > 0 && fVerbosityLevel >= 1)
+                envir() << "...local connection opened\n";
+        }
+
+        return connectResult;
+    } while(0);
+
+    resetTCPSockets();
+    return -1;
+}
+
+int RTSPClient::connectToServer(int socketNum, portNumBits remotePortNum) {
+    setPortNum(fServerAddress, htons(remotePortNum));
+    if(fVerbosityLevel >= 1) {
+        envir() << "Connecting to " << AddressString(fServerAddress).val() << ", port " << remotePortNum << " on socket " << socketNum << "...\n";
+    }
+    if(connect(socketNum, (struct sockaddr *)&fServerAddress, addressSize(fServerAddress)) != 0) {
+        int const err = envir().getErrno();
+        if(err == EINPROGRESS || err == EWOULDBLOCK) {
+            // The connection is pending; we'll need to handle it later.  Wait for our socket to be 'writable', or have an exception.
+            envir().taskScheduler().setBackgroundHandling(socketNum, SOCKET_WRITABLE | SOCKET_EXCEPTION,
+                                                          (TaskScheduler::BackgroundHandlerProc *)&connectionHandler, this);
+            return 0;
+        }
+        envir().setResultErrMsg("connect() failed: ");
+        if(fVerbosityLevel >= 1)
+            envir() << "..." << envir().getResultMsg() << "\n";
+        return -1;
+    }
+
+    // The connection succeeded.  Arrange to handle responses to requests sent on it:
+    envir().taskScheduler().setBackgroundHandling(fInputSocketNum, SOCKET_READABLE | SOCKET_EXCEPTION,
+                                                  (TaskScheduler::BackgroundHandlerProc *)&incomingDataHandler, this);
+
+    return 1;
+}
+
+char *RTSPClient::createAuthenticatorString(char const *cmd, char const *url) {
+    Authenticator &auth = fCurrentAuthenticator;  // alias, for brevity
+    if(auth.realm() != NULL && auth.username() != NULL && auth.password() != NULL) {
+        // We have a filled-in authenticator, so use it:
+        char *authenticatorStr;
+        if(auth.nonce() != NULL) {  // Digest authentication
+            char const *const authFmt  = "Authorization: Digest username=\"%s\", realm=\"%s\", "
+                                         "nonce=\"%s\", uri=\"%s\", response=\"%s\"\r\n";
+            char const       *response = auth.computeDigestResponse(cmd, url);
+            unsigned authBufSize = strlen(authFmt) + strlen(auth.username()) + strlen(auth.realm()) + strlen(auth.nonce()) + strlen(url) + strlen(response);
+            authenticatorStr     = new char[authBufSize];
+            sprintf(authenticatorStr, authFmt, auth.username(), auth.realm(), auth.nonce(), url, response);
+            auth.reclaimDigestResponse(response);
+        }
+        else {  // Basic authentication
+            char const *const authFmt = "Authorization: Basic %s\r\n";
+
+            unsigned usernamePasswordLength = strlen(auth.username()) + 1 + strlen(auth.password());
+            char    *usernamePassword       = new char[usernamePasswordLength + 1];
+            sprintf(usernamePassword, "%s:%s", auth.username(), auth.password());
+
+            char          *response    = base64Encode(usernamePassword, usernamePasswordLength);
+            unsigned const authBufSize = strlen(authFmt) + strlen(response) + 1;
+            authenticatorStr           = new char[authBufSize];
+            sprintf(authenticatorStr, authFmt, response);
+            delete[] response;
+            delete[] usernamePassword;
+        }
+
+        return authenticatorStr;
+    }
+
+    // We don't have a (filled-in) authenticator.
+    return strDup("");
+}
+
+char *RTSPClient::createBlocksizeString(Boolean streamUsingTCP) {
+    char     *blocksizeStr;
+    u_int16_t maxPacketSize = desiredMaxIncomingPacketSize;
+
+    // Allow for the RTP header (if streaming over TCP)
+    // or the IP/UDP/RTP headers (if streaming over UDP):
+    u_int16_t const headerAllowance = streamUsingTCP ? 12 : 50 /*conservative*/;
+    if(maxPacketSize < headerAllowance) {
+        maxPacketSize = 0;
+    }
+    else {
+        maxPacketSize -= headerAllowance;
+    }
+
+    if(maxPacketSize > 0) {
+        blocksizeStr = new char[25];  // more than enough space
+        sprintf(blocksizeStr, "Blocksize: %u\r\n", maxPacketSize);
+    }
+    else {
+        blocksizeStr = strDup("");
+    }
+    return blocksizeStr;
+}
+
+char *RTSPClient::createKeyMgmtString(char const *url, MediaSubsession const &subsession) {
+    char       *keyMgmtStr;
+    MIKEYState *mikeyState;
+    u_int8_t   *mikeyMessage;
+    unsigned    mikeyMessageSize;
+
+    if((mikeyState = subsession.getMIKEYState()) == NULL || (mikeyMessage = mikeyState->generateMessage(mikeyMessageSize)) == NULL) {
+        keyMgmtStr = strDup("");
+    }
+    else {
+        char const *keyMgmtFmt        = "KeyMgmt: prot=mikey; uri=\"%s\"; data=\"%s\"\r\n";
+        char       *base64EncodedData = base64Encode((char *)mikeyMessage, mikeyMessageSize);
+        delete[] mikeyMessage;
+
+        unsigned keyMgmtSize = strlen(keyMgmtFmt) + strlen(url) + strlen(base64EncodedData);
+        keyMgmtStr           = new char[keyMgmtSize];
+        sprintf(keyMgmtStr, keyMgmtFmt, url, base64EncodedData);
+        delete[] base64EncodedData;
+    }
+
+    return keyMgmtStr;
+}
+
+void RTSPClient::handleRequestError(RequestRecord *request) {
+    int resultCode = -envir().getErrno();
+    if(resultCode == 0) {
+        // Choose some generic error code instead:
+#if defined(__WIN32__) || defined(_WIN32) || defined(_QNX4)
+        resultCode = -WSAENOTCONN;
+#else
+        resultCode = -ENOTCONN;
+#endif
+    }
+    if(request->handler() != NULL)
+        (*request->handler())(this, resultCode, strDup(envir().getResultMsg()));
+}
+
+Boolean RTSPClient ::parseResponseCode(char const *line, unsigned &responseCode, char const *&responseString) {
+    if(sscanf(line, "RTSP/%*s%u", &responseCode) != 1 && sscanf(line, "HTTP/%*s%u", &responseCode) != 1)
+        return False;
+    // Note: We check for HTTP responses as well as RTSP responses, both in order to setup RTSP-over-HTTP tunneling,
+    // and so that we get back a meaningful error if the client tried to mistakenly send a RTSP command to a HTTP-only server.
+
+    // Use everything after the RTSP/* (or HTTP/*) as the response string:
+    responseString = line;
+    while(responseString[0] != '\0' && responseString[0] != ' ' && responseString[0] != '\t')
+        ++responseString;
+    while(responseString[0] != '\0' && (responseString[0] == ' ' || responseString[0] == '\t'))
+        ++responseString;  // skip whitespace
+
+    return True;
+}
+
+void RTSPClient::handleIncomingRequest() {
+    // Parse the request string into command name and 'CSeq', then 'handle' the command (by responding that we don't support it):
+    char     cmdName[RTSP_PARAM_STRING_MAX];
+    char     urlPreSuffix[RTSP_PARAM_STRING_MAX];
+    char     urlSuffix[RTSP_PARAM_STRING_MAX];
+    char     cseq[RTSP_PARAM_STRING_MAX];
+    char     sessionId[RTSP_PARAM_STRING_MAX];
+    unsigned contentLength;
+    Boolean  urlIsRTSPS;
+    if(!parseRTSPRequestString(fResponseBuffer, fResponseBytesAlreadySeen, cmdName, sizeof cmdName, urlPreSuffix, sizeof urlPreSuffix, urlSuffix,
+                               sizeof urlSuffix, cseq, sizeof cseq, sessionId, sizeof sessionId, contentLength, urlIsRTSPS)) {
+        return;
+    }
+    else {
+        if(fVerbosityLevel >= 1) {
+            envir() << "Received incoming RTSP request: " << fResponseBuffer << "\n";
+        }
+        char tmpBuf[2 * RTSP_PARAM_STRING_MAX];
+        snprintf(tmpBuf, sizeof tmpBuf, "RTSP/1.0 405 Method Not Allowed\r\nCSeq: %s\r\n\r\n", cseq);
+        write(tmpBuf, strlen(tmpBuf));
+    }
+}
+
+Boolean RTSPClient::checkForHeader(char const *line, char const *headerName, unsigned headerNameLength, char const *&headerParams) {
+    if(_strncasecmp(line, headerName, headerNameLength) != 0)
+        return False;
+
+    // The line begins with the desired header name.  Trim off any whitespace, and return the header parameters:
+    unsigned paramIndex = headerNameLength;
+    while(line[paramIndex] != '\0' && (line[paramIndex] == ' ' || line[paramIndex] == '\t'))
+        ++paramIndex;
+    if(line[paramIndex] == '\0')
+        return False;  // the header is assumed to be bad if it has no parameters
+
+    headerParams = &line[paramIndex];
+    return True;
+}
+
+Boolean RTSPClient::parseTransportParams(char const *paramsStr, char *&serverAddressStr, portNumBits &serverPortNum, unsigned char &rtpChannelId,
+                                         unsigned char &rtcpChannelId) {
+    // Initialize the return parameters to 'not found' values:
+    serverAddressStr = NULL;
+    serverPortNum    = 0;
+    rtpChannelId = rtcpChannelId = 0xFF;
+    if(paramsStr == NULL)
+        return False;
+
+    char       *foundServerAddressStr = NULL;
+    Boolean     foundServerPortNum    = False;
+    portNumBits clientPortNum         = 0;
+    Boolean     foundClientPortNum    = False;
+    Boolean     foundChannelIds       = False;
+    unsigned    rtpCid, rtcpCid;
+    Boolean     isMulticast         = True;  // by default
+    char       *foundDestinationStr = NULL;
+    portNumBits multicastPortNumRTP, multicastPortNumRTCP;
+    Boolean     foundMulticastPortNum = False;
+
+    // Run through each of the parameters, looking for ones that we handle:
+    char const *fields = paramsStr;
+    char       *field  = strDupSize(fields);
+    while(sscanf(fields, "%[^;]", field) == 1) {
+        if(sscanf(field, "server_port=%hu", &serverPortNum) == 1) {
+            foundServerPortNum = True;
+        }
+        else if(sscanf(field, "client_port=%hu", &clientPortNum) == 1) {
+            foundClientPortNum = True;
+        }
+        else if(_strncasecmp(field, "source=", 7) == 0) {
+            delete[] foundServerAddressStr;
+            foundServerAddressStr = strDup(field + 7);
+        }
+        else if(sscanf(field, "interleaved=%u-%u", &rtpCid, &rtcpCid) == 2) {
+            rtpChannelId    = (unsigned char)rtpCid;
+            rtcpChannelId   = (unsigned char)rtcpCid;
+            foundChannelIds = True;
+        }
+        else if(strcmp(field, "unicast") == 0) {
+            isMulticast = False;
+        }
+        else if(_strncasecmp(field, "destination=", 12) == 0) {
+            delete[] foundDestinationStr;
+            foundDestinationStr = strDup(field + 12);
+        }
+        else if(sscanf(field, "port=%hu-%hu", &multicastPortNumRTP, &multicastPortNumRTCP) == 2 || sscanf(field, "port=%hu", &multicastPortNumRTP) == 1) {
+            foundMulticastPortNum = True;
+        }
+
+        fields += strlen(field);
+        while(fields[0] == ';')
+            ++fields;  // skip over all leading ';' chars
+        if(fields[0] == '\0')
+            break;
+    }
+    delete[] field;
+
+    // If we're multicast, and have a "destination=" (multicast) address, then use this
+    // as the 'server' address (because some weird servers don't specify the multicast
+    // address earlier, in the "DESCRIBE" response's SDP:
+    if(isMulticast && foundDestinationStr != NULL && foundMulticastPortNum) {
+        delete[] foundServerAddressStr;
+        serverAddressStr = foundDestinationStr;
+        serverPortNum    = multicastPortNumRTP;
+        return True;
+    }
+    delete[] foundDestinationStr;
+
+    // We have a valid "Transport:" header if any of the following are true:
+    //   - We saw a "interleaved=" field, indicating RTP/RTCP-over-TCP streaming, or
+    //   - We saw a "server_port=" field, or
+    //   - We saw a "client_port=" field.
+    //     If we didn't also see a "server_port=" field, then the server port is assumed to be the same as the client port.
+    if(foundChannelIds || foundServerPortNum || foundClientPortNum) {
+        if(foundClientPortNum && !foundServerPortNum) {
+            serverPortNum = clientPortNum;
+        }
+        serverAddressStr = foundServerAddressStr;
+        return True;
+    }
+
+    delete[] foundServerAddressStr;
+    return False;
+}
+
+Boolean RTSPClient::parseScaleParam(char const *paramStr, float &scale) {
+    Locale l("C", Numeric);
+    return sscanf(paramStr, "%f", &scale) == 1;
+}
+
+Boolean RTSPClient::parseSpeedParam(char const *paramStr, float &speed) {
+    Locale l("C", Numeric);
+    return sscanf(paramStr, "%f", &speed) >= 1;
+}
+
+Boolean RTSPClient::parseRTPInfoParams(char const *&paramsStr, u_int16_t &seqNum, u_int32_t &timestamp) {
+    if(paramsStr == NULL || paramsStr[0] == '\0')
+        return False;
+    while(paramsStr[0] == ',')
+        ++paramsStr;
+
+    // "paramsStr" now consists of a ';'-separated list of parameters, ending with ',' or '\0'.
+    char *field = strDupSize(paramsStr);
+
+    Boolean sawSeq = False, sawRtptime = False;
+    while(sscanf(paramsStr, "%[^;,]", field) == 1) {
+        if(sscanf(field, "seq=%hu", &seqNum) == 1) {
+            sawSeq = True;
+        }
+        else if(sscanf(field, "rtptime=%u", &timestamp) == 1) {
+            sawRtptime = True;
+        }
+
+        paramsStr += strlen(field);
+        if(paramsStr[0] == '\0' || paramsStr[0] == ',')
+            break;
+        // ASSERT: paramsStr[0] == ';'
+        ++paramsStr;  // skip over the ';'
+    }
+
+    delete[] field;
+    // For the "RTP-Info:" parameters to be useful to us, we need to have seen both the "seq=" and "rtptime=" parameters:
+    return sawSeq && sawRtptime;
+}
+
+Boolean RTSPClient::handleSETUPResponse(MediaSubsession &subsession, char const *sessionParamsStr, char const *transportParamsStr, Boolean streamUsingTCP) {
+    char   *sessionId = new char[responseBufferSize];  // ensures we have enough space
+    Boolean success   = False;
+    do {
+        // Check for a session id:
+        if(sessionParamsStr == NULL || sscanf(sessionParamsStr, "%[^;]", sessionId) != 1) {
+            envir().setResultMsg("Missing or bad \"Session:\" header");
+            break;
+        }
+        subsession.setSessionId(sessionId);
+        delete[] fLastSessionId;
+        fLastSessionId = strDup(sessionId);
+
+        // Also look for an optional "; timeout = " parameter following this:
+        char const *afterSessionId = sessionParamsStr + strlen(sessionId);
+        int         timeoutVal;
+        if(sscanf(afterSessionId, "; timeout = %d", &timeoutVal) == 1) {
+            fSessionTimeoutParameter = timeoutVal;
+        }
+
+        // Parse the "Transport:" header parameters:
+        char         *serverAddressStr;
+        portNumBits   serverPortNum;
+        unsigned char rtpChannelId, rtcpChannelId;
+        if(!parseTransportParams(transportParamsStr, serverAddressStr, serverPortNum, rtpChannelId, rtcpChannelId)) {
+            envir().setResultMsg("Missing or bad \"Transport:\" header");
+            break;
+        }
+        delete[] subsession.connectionEndpointName();
+        subsession.connectionEndpointName() = serverAddressStr;
+        subsession.serverPortNum            = serverPortNum;
+        subsession.rtpChannelId             = rtpChannelId;
+        subsession.rtcpChannelId            = rtcpChannelId;
+
+        if(streamUsingTCP) {
+            // Tell the subsession to receive RTP (and send/receive RTCP) over the RTSP stream:
+            if(subsession.rtpSource() != NULL) {
+                subsession.rtpSource()->setStreamSocket(fInputSocketNum, subsession.rtpChannelId, &fTLS);
+                // So that we continue to receive & handle RTSP commands and responses from the server
+                subsession.rtpSource()->enableRTCPReports() = False;
+                // To avoid confusing the server (which won't start handling RTP/RTCP-over-TCP until "PLAY"), don't send RTCP "RR"s yet
+                increaseReceiveBufferTo(envir(), fInputSocketNum, 50 * 1024);
+            }
+            if(subsession.rtcpInstance() != NULL)
+                subsession.rtcpInstance()->setStreamSocket(fInputSocketNum, subsession.rtcpChannelId, &fTLS);
+            RTPInterface::setServerRequestAlternativeByteHandler(envir(), fInputSocketNum, handleAlternativeRequestByte, this);
+        }
+        else {
+            // Normal case.
+            // Set the RTP and RTCP sockets' destination address and port from the information in the SETUP response (if present):
+            struct sockaddr_storage destAddress;
+            subsession.getConnectionEndpointAddress(destAddress);
+            if(addressIsNull(destAddress)) {
+                destAddress = fServerAddress;
+            }
+            subsession.setDestinations(destAddress);
+        }
+
+        success = True;
+    } while(0);
+
+    delete[] sessionId;
+    return success;
+}
+
+Boolean RTSPClient::handlePLAYResponse(MediaSession *session, MediaSubsession *subsession, char const *scaleParamsStr, char const *speedParamsStr,
+                                       char const *rangeParamsStr, char const *rtpInfoParamsStr) {
+    Boolean scaleOK = False, rangeOK = False, speedOK = False;
+    do {
+        if(session != NULL) {
+            // The command was on the whole session
+            if(scaleParamsStr != NULL && !parseScaleParam(scaleParamsStr, session->scale()))
+                break;
+            scaleOK = True;
+            if(speedParamsStr != NULL && !parseSpeedParam(speedParamsStr, session->speed()))
+                break;
+            speedOK = True;
+            Boolean startTimeIsNow;
+            if(rangeParamsStr != NULL
+               && !parseRangeParam(rangeParamsStr, session->playStartTime(), session->playEndTime(), session->_absStartTime(), session->_absEndTime(),
+                                   startTimeIsNow))
+                break;
+            rangeOK = True;
+
+            MediaSubsessionIterator iter(*session);
+            MediaSubsession        *subsession;
+            while((subsession = iter.next()) != NULL) {
+                subsession->scale() = session->scale();
+                subsession->speed() = session->speed();
+
+                u_int16_t seqNum;
+                u_int32_t timestamp;
+                subsession->rtpInfo.infoIsNew = False;
+                if(parseRTPInfoParams(rtpInfoParamsStr, seqNum, timestamp)) {
+                    subsession->rtpInfo.seqNum    = seqNum;
+                    subsession->rtpInfo.timestamp = timestamp;
+                    subsession->rtpInfo.infoIsNew = True;
+                }
+
+                if(subsession->rtpSource() != NULL)
+                    subsession->rtpSource()->enableRTCPReports() = True;  // start sending RTCP "RR"s now
+            }
+        }
+        else {
+            // The command was on a subsession
+            if(scaleParamsStr != NULL && !parseScaleParam(scaleParamsStr, subsession->scale()))
+                break;
+            scaleOK = True;
+            if(speedParamsStr != NULL && !parseSpeedParam(speedParamsStr, subsession->speed()))
+                break;
+            speedOK = True;
+            Boolean startTimeIsNow;
+            if(rangeParamsStr != NULL
+               && !parseRangeParam(rangeParamsStr, subsession->_playStartTime(), subsession->_playEndTime(), subsession->_absStartTime(),
+                                   subsession->_absEndTime(), startTimeIsNow))
+                break;
+            rangeOK = True;
+
+            u_int16_t seqNum;
+            u_int32_t timestamp;
+            subsession->rtpInfo.infoIsNew = False;
+            if(parseRTPInfoParams(rtpInfoParamsStr, seqNum, timestamp)) {
+                subsession->rtpInfo.seqNum    = seqNum;
+                subsession->rtpInfo.timestamp = timestamp;
+                subsession->rtpInfo.infoIsNew = True;
+            }
+
+            if(subsession->rtpSource() != NULL)
+                subsession->rtpSource()->enableRTCPReports() = True;  // start sending RTCP "RR"s now
+        }
+
+        return True;
+    } while(0);
+
+    // An error occurred:
+    if(!scaleOK) {
+        envir().setResultMsg("Bad \"Scale:\" header");
+    }
+    else if(!speedOK) {
+        envir().setResultMsg("Bad \"Speed:\" header");
+    }
+    else if(!rangeOK) {
+        envir().setResultMsg("Bad \"Range:\" header");
+    }
+    else {
+        envir().setResultMsg("Bad \"RTP-Info:\" header");
+    }
+    return False;
+}
+
+Boolean RTSPClient::handleTEARDOWNResponse(MediaSession & /*session*/, MediaSubsession & /*subsession*/) {
+    // Because we don't expect to always get a response to "TEARDOWN", we don't need to do anything if we do get one:
+    return True;
+}
+
+Boolean RTSPClient::handleGET_PARAMETERResponse(char const *parameterName, char *&resultValueString, char *resultValueStringEnd) {
+    do {
+        // If "parameterName" is non-empty, it may be (possibly followed by ':' and whitespace) at the start of the result string:
+        if(parameterName != NULL && parameterName[0] != '\0') {
+            if(parameterName[1] == '\0')
+                break;  // sanity check; there should have been \r\n at the end of "parameterName"
+
+            unsigned parameterNameLen = strlen(parameterName);
+            // ASSERT: parameterNameLen >= 2;
+            parameterNameLen -= 2;  // because of the trailing \r\n
+            if(resultValueString + parameterNameLen > resultValueStringEnd)
+                break;  // not enough space
+            if(parameterNameLen > 0 && _strncasecmp(resultValueString, parameterName, parameterNameLen) == 0) {
+                resultValueString += parameterNameLen;
+                // ASSERT: resultValueString <= resultValueStringEnd
+                if(resultValueString == resultValueStringEnd)
+                    break;
+
+                if(resultValueString[0] == ':')
+                    ++resultValueString;
+                while(resultValueString < resultValueStringEnd && (resultValueString[0] == ' ' || resultValueString[0] == '\t')) {
+                    ++resultValueString;
+                }
+            }
+        }
+
+        // The rest of "resultValueStr" should be our desired result, but first trim off any \r and/or \n characters at the end:
+        char saved            = *resultValueStringEnd;
+        *resultValueStringEnd = '\0';
+        unsigned resultLen    = strlen(resultValueString);
+        *resultValueStringEnd = saved;
+
+        while(resultLen > 0 && (resultValueString[resultLen - 1] == '\r' || resultValueString[resultLen - 1] == '\n'))
+            --resultLen;
+        resultValueString[resultLen] = '\0';
+
+        return True;
+    } while(0);
+
+    // An error occurred:
+    envir().setResultMsg("Bad \"GET_PARAMETER\" response");
+    return False;
+}
+
+Boolean RTSPClient::handleAuthenticationFailure(char const *paramsStr) {
+    if(paramsStr == NULL)
+        return False;  // There was no "WWW-Authenticate:" header; we can't proceed.
+
+    // Fill in "fCurrentAuthenticator" with the information from the "WWW-Authenticate:" header:
+    Boolean realmHasChanged = False;  // by default
+    Boolean isStale         = False;  // by default
+    char   *realm           = strDupSize(paramsStr);
+    char   *nonce           = strDupSize(paramsStr);
+    char   *stale           = strDupSize(paramsStr);
+    Boolean success         = True;
+    if(sscanf(paramsStr, "Digest realm=\"%[^\"]\", nonce=\"%[^\"]\", stale=%[a-zA-Z]", realm, nonce, stale) == 3) {
+        realmHasChanged = fCurrentAuthenticator.realm() == NULL || strcmp(fCurrentAuthenticator.realm(), realm) != 0;
+        isStale         = _strncasecmp(stale, "true", 4) == 0;
+        fCurrentAuthenticator.setRealmAndNonce(realm, nonce);
+    }
+    else if(sscanf(paramsStr, "Digest realm=\"%[^\"]\", nonce=\"%[^\"]\"", realm, nonce) == 2) {
+        realmHasChanged = fCurrentAuthenticator.realm() == NULL || strcmp(fCurrentAuthenticator.realm(), realm) != 0;
+        fCurrentAuthenticator.setRealmAndNonce(realm, nonce);
+    }
+    else if(sscanf(paramsStr, "Basic realm=\"%[^\"]\"", realm) == 1 && fAllowBasicAuthentication) {
+        realmHasChanged = fCurrentAuthenticator.realm() == NULL || strcmp(fCurrentAuthenticator.realm(), realm) != 0;
+        fCurrentAuthenticator.setRealmAndNonce(realm, NULL);  // Basic authentication
+    }
+    else {
+        success = False;  // bad "WWW-Authenticate:" header
+    }
+    delete[] realm;
+    delete[] nonce;
+    delete[] stale;
+
+    if(success) {
+        if((!realmHasChanged && !isStale) || fCurrentAuthenticator.username() == NULL || fCurrentAuthenticator.password() == NULL) {
+            // We already tried with the same realm (and a non-stale nonce),
+            // or don't have a username and/or password, so the new "WWW-Authenticate:" header
+            // information won't help us.  We remain unauthenticated.
+            success = False;
+        }
+    }
+
+    return success;
+}
+
+Boolean RTSPClient::resendCommand(RequestRecord *request) {
+    if(fVerbosityLevel >= 1)
+        envir() << "Resending...\n";
+    if(request != NULL && strcmp(request->commandName(), "GET") != 0)
+        request->cseq() = ++fCSeq;
+    return sendRequest(request) != 0;
+}
+
+char const *RTSPClient::sessionURL(MediaSession const &session) const {
+    char const *url = session.controlPath();
+    if(url == NULL || strcmp(url, "*") == 0)
+        url = fBaseURL;
+
+    return url;
+}
+
+void RTSPClient::handleAlternativeRequestByte(void *rtspClient, u_int8_t requestByte) {
+    ((RTSPClient *)rtspClient)->handleAlternativeRequestByte1(requestByte);
+}
+
+void RTSPClient::handleAlternativeRequestByte1(u_int8_t requestByte) {
+    if(requestByte == 0xFF) {
+        // Hack: The new handler of the input TCP socket encountered an error reading it.  Indicate this:
+        handleResponseBytes(-1);
+    }
+    else if(requestByte == 0xFE) {
+        // Another hack: The new handler of the input TCP socket no longer needs it, so take back control:
+        envir().taskScheduler().setBackgroundHandling(fInputSocketNum, SOCKET_READABLE | SOCKET_EXCEPTION,
+                                                      (TaskScheduler::BackgroundHandlerProc *)&incomingDataHandler, this);
+    }
+    else {
+        // Normal case:
+        fResponseBuffer[fResponseBytesAlreadySeen] = requestByte;
+        handleResponseBytes(1);
+    }
+}
+
+static Boolean isAbsoluteURL(char const *url) {
+    // Assumption: "url" is absolute if it contains a ':', before any
+    // occurrence of '/'
+    while(*url != '\0' && *url != '/') {
+        if(*url == ':')
+            return True;
+        ++url;
+    }
+
+    return False;
+}
+
+void RTSPClient::constructSubsessionURL(MediaSubsession const &subsession, char const *&prefix, char const *&separator, char const *&suffix) {
+    // Figure out what the URL describing "subsession" will look like.
+    // The URL is returned in three parts: prefix; separator; suffix
+    // ##### NOTE: This code doesn't really do the right thing if "sessionURL()"
+    // doesn't end with a "/", and "subsession.controlPath()" is relative.
+    // The right thing would have been to truncate "sessionURL()" back to the
+    // rightmost "/", and then add "subsession.controlPath()".
+    // In practice, though, each "DESCRIBE" response typically contains
+    // a "Content-Base:" header that consists of "sessionURL()" followed by
+    // a "/", in which case this code ends up giving the correct result.
+    // However, we should really fix this code to do the right thing, and
+    // also check for and use the "Content-Base:" header appropriately. #####
+    prefix = sessionURL(subsession.parentSession());
+    if(prefix == NULL)
+        prefix = "";
+
+    suffix = subsession.controlPath();
+    if(suffix == NULL)
+        suffix = "";
+
+    if(isAbsoluteURL(suffix)) {
+        prefix = separator = "";
+    }
+    else {
+        unsigned prefixLen = strlen(prefix);
+        separator          = (prefixLen == 0 || prefix[prefixLen - 1] == '/' || suffix[0] == '/') ? "" : "/";
+    }
+}
+
+Boolean RTSPClient::setupHTTPTunneling1() {
+    // Set up RTSP-over-HTTP tunneling, as described in
+    //     http://mirror.informatimago.com/next/developer.apple.com/quicktime/icefloe/dispatch028.html
+    // and http://images.apple.com/br/quicktime/pdf/QTSS_Modules.pdf
+    if(fVerbosityLevel >= 1) {
+        envir() << "Requesting RTSP-over-HTTP tunneling (on port " << fTunnelOverHTTPPortNum << ")\n\n";
+    }
+
+    // Begin by sending a HTTP "GET", to set up the server->client link.  Continue when we handle the response:
+    return sendRequest(new RequestRecord(1, "GET", responseHandlerForHTTP_GET)) != 0;
+}
+
+void RTSPClient::responseHandlerForHTTP_GET(RTSPClient *rtspClient, int responseCode, char *responseString) {
+    if(rtspClient != NULL)
+        rtspClient->responseHandlerForHTTP_GET1(responseCode, responseString);
+}
+
+void RTSPClient::responseHandlerForHTTP_GET1(int responseCode, char *responseString) {
+    RequestRecord *request;
+    do {
+        delete[] responseString;  // we don't need it (but are responsible for deleting it)
+        if(responseCode != 0)
+            break;  // The HTTP "GET" failed.
+
+        // Having successfully set up (using the HTTP "GET" command) the server->client link, set up a second TCP connection
+        // (to the same server & port as before) for the client->server link.  All future output will be to this new socket.
+        fOutputSocketNum = setupStreamSocket(envir(), 0, fServerAddress.ss_family);
+        if(fOutputSocketNum < 0)
+            break;
+        ignoreSigPipeOnSocket(fOutputSocketNum);  // so that servers on the same host that killed don't also kill us
+
+        fHTTPTunnelingConnectionIsPending = True;
+        int connectResult                 = connectToServer(fOutputSocketNum, fTunnelOverHTTPPortNum);
+        if(connectResult < 0)
+            break;  // an error occurred
+        else if(connectResult == 0) {
+            // A connection is pending.  Continue setting up RTSP-over-HTTP when the connection completes.
+            // First, move the pending requests to the 'awaiting connection' queue:
+            while((request = fRequestsAwaitingHTTPTunneling.dequeue()) != NULL) {
+                fRequestsAwaitingConnection.enqueue(request);
+            }
+            return;
+        }
+
+        // The connection succeeded.  Continue setting up RTSP-over-HTTP:
+        if(!setupHTTPTunneling2())
+            break;
+
+        // RTSP-over-HTTP tunneling succeeded.  Resume the pending request(s):
+        while((request = fRequestsAwaitingHTTPTunneling.dequeue()) != NULL) {
+            sendRequest(request);
+        }
+        return;
+    } while(0);
+
+    // An error occurred.  Dequeue the pending request(s), and tell them about the error:
+    fHTTPTunnelingConnectionIsPending = False;
+    resetTCPSockets();  // do this now, in case an error handler deletes "this"
+    RequestQueue requestQueue(fRequestsAwaitingHTTPTunneling);
+    while((request = requestQueue.dequeue()) != NULL) {
+        handleRequestError(request);
+        delete request;
+    }
+}
+
+Boolean RTSPClient::setupHTTPTunneling2() {
+    fHTTPTunnelingConnectionIsPending = False;
+
+    // Send a HTTP "POST", to set up the client->server link.  (Note that we won't see a reply to the "POST".)
+    return sendRequest(new RequestRecord(1, "POST", NULL)) != 0;
+}
+
+void RTSPClient::connectionHandler(void *instance, int /*mask*/) {
+    RTSPClient *client = (RTSPClient *)instance;
+    client->connectionHandler1();
+}
+
+void RTSPClient::connectionHandler1() {
+    // Restore normal handling on our sockets:
+    envir().taskScheduler().disableBackgroundHandling(fOutputSocketNum);
+    envir().taskScheduler().setBackgroundHandling(fInputSocketNum, SOCKET_READABLE | SOCKET_EXCEPTION,
+                                                  (TaskScheduler::BackgroundHandlerProc *)&incomingDataHandler, this);
+
+    // Move all requests awaiting connection into a new, temporary queue, to clear "fRequestsAwaitingConnection"
+    // (so that "sendRequest()" doesn't get confused by "fRequestsAwaitingConnection" being nonempty, and enqueue them all over again).
+    RequestQueue   tmpRequestQueue(fRequestsAwaitingConnection);
+    RequestRecord *request;
+
+    // Find out whether the connection succeeded or failed:
+    do {
+        int       err = 0;
+        SOCKLEN_T len = sizeof err;
+        // Note: Normally "fOutputSocketNum" == "fInputSocketNum" here, except when we're connecting
+        // to the second (i.e., "POST") connection when doing RTSP-over-HTTP:
+        if(getsockopt(fOutputSocketNum, SOL_SOCKET, SO_ERROR, (char *)&err, reinterpret_cast<socklen_t *>(&len)) < 0 || err != 0) {
+            envir().setResultErrMsg("Connection to server failed: ", err);
+            if(fVerbosityLevel >= 1)
+                envir() << "..." << envir().getResultMsg() << "\n";
+            break;
+        }
+
+        // The connection succeeded.  If the connection came about from an attempt to set up RTSP-over-HTTP, finish this now:
+        if(fHTTPTunnelingConnectionIsPending && !setupHTTPTunneling2())
+            break;
+
+        if(fTLS.isNeeded) {
+            // We need to complete an additional TLS connection:
+            int tlsConnectResult = fTLS.connect(fInputSocketNum);
+            if(tlsConnectResult < 0)
+                break;  // error in TLS connection
+            if(tlsConnectResult > 0 && fVerbosityLevel >= 1)
+                envir() << "...TLS connection completed\n";
+            if(tlsConnectResult == 0) {
+                // The connection is still pending.  Continue deferring...
+                while((request = tmpRequestQueue.dequeue()) != NULL) {
+                    fRequestsAwaitingConnection.enqueue(request);
+                }
+                return;
+            }
+        }
+
+        // The connection is complete.  Resume sending all pending requests:
+        if(fVerbosityLevel >= 1)
+            envir() << "...remote connection opened\n";
+        while((request = tmpRequestQueue.dequeue()) != NULL) {
+            sendRequest(request);
+        }
+        return;
+    } while(0);
+
+    // An error occurred.  Tell all pending requests about the error:
+    resetTCPSockets();  // do this now, in case an error handler deletes "this"
+    while((request = tmpRequestQueue.dequeue()) != NULL) {
+        handleRequestError(request);
+        delete request;
+    }
+}
+
+void RTSPClient::incomingDataHandler(void *instance, int /*mask*/) {
+    RTSPClient *client = (RTSPClient *)instance;
+    client->incomingDataHandler1();
+}
+
+void RTSPClient::incomingDataHandler1() {
+    int bytesRead = read((u_int8_t *)&fResponseBuffer[fResponseBytesAlreadySeen], fResponseBufferBytesLeft);
+    handleResponseBytes(bytesRead);
+}
+
+static char *getLine(char *startOfLine) {
+    // returns the start of the next line, or NULL if none.  Note that this modifies the input string to add '\0' characters.
+    for(char *ptr = startOfLine; *ptr != '\0'; ++ptr) {
+        // Check for the end of line: \r\n (but also accept \r or \n by itself):
+        if(*ptr == '\r' || *ptr == '\n') {
+            // We found the end of the line
+            if(*ptr == '\r') {
+                *ptr++ = '\0';
+                if(*ptr == '\n')
+                    ++ptr;
+            }
+            else {
+                *ptr++ = '\0';
+            }
+            return ptr;
+        }
+    }
+
+    return NULL;
+}
+
+void RTSPClient::handleResponseBytes(int newBytesRead) {
+    do {
+        if(newBytesRead >= 0 && (unsigned)newBytesRead < fResponseBufferBytesLeft)
+            break;  // data was read OK; process it below
+
+        if(newBytesRead >= (int)fResponseBufferBytesLeft) {
+            // We filled up our response buffer.  Treat this as an error (for the first response handler):
+            envir().setResultMsg("RTSP response was truncated. Increase \"RTSPClient::responseBufferSize\"");
+        }
+
+        // An error occurred while reading our TCP socket.  Call all pending response handlers, indicating this error.
+        // (However, the "RTSP response was truncated" error is applied to the first response handler only.)
+        resetResponseBuffer();
+        RequestRecord *request;
+        if(newBytesRead > 0) {  // The "RTSP response was truncated" error
+            if((request = fRequestsAwaitingResponse.dequeue()) != NULL) {
+                handleRequestError(request);
+                delete request;
+            }
+        }
+        else {
+            RequestQueue requestQueue(fRequestsAwaitingResponse);
+            resetTCPSockets();  // do this now, in case an error handler deletes "this"
+
+            while((request = requestQueue.dequeue()) != NULL) {
+                handleRequestError(request);
+                delete request;
+            }
+        }
+        return;
+    } while(0);
+
+    fResponseBufferBytesLeft -= newBytesRead;
+    fResponseBytesAlreadySeen += newBytesRead;
+    fResponseBuffer[fResponseBytesAlreadySeen] = '\0';
+    // envir() << "fResponseBuffer:  " << fResponseBuffer; /*<< " new bytes of response data.\n";*/
+    if(fVerbosityLevel >= 1 && newBytesRead > 1)
+        envir() << "Received " << newBytesRead << " new bytes of response data.\n";
+
+    unsigned numExtraBytesAfterResponse = 0;
+    Boolean  responseSuccess            = False;  // by default
+    do {
+        // Data was read OK.  Look through the data that we've read so far, to see if it contains <CR><LF><CR><LF>.
+        // (If not, wait for more data to arrive.)
+        Boolean     endOfHeaders = False;
+        char const *ptr          = fResponseBuffer;
+        if(fResponseBytesAlreadySeen > 3) {
+            char const *const ptrEnd = &fResponseBuffer[fResponseBytesAlreadySeen - 3];
+            while(ptr < ptrEnd) {
+                if(*ptr++ == '\r' && *ptr++ == '\n' && *ptr++ == '\r' && *ptr++ == '\n') {
+                    // This is it
+                    endOfHeaders = True;
+                    break;
+                }
+            }
+        }
+
+        if(!endOfHeaders)
+            return;  // subsequent reads will be needed to get the complete response
+
+        // Now that we have the complete response headers (ending with <CR><LF><CR><LF>), parse them to get the response code, CSeq,
+        // and various other header parameters.  To do this, we first make a copy of the received header data, because we'll be
+        // modifying it by adding '\0' bytes.
+        char          *headerDataCopy;
+        unsigned       responseCode             = 200;
+        char const    *responseStr              = NULL;
+        RequestRecord *foundRequest             = NULL;
+        char const    *sessionParamsStr         = NULL;
+        char const    *transportParamsStr       = NULL;
+        char const    *scaleParamsStr           = NULL;
+        char const    *speedParamsStr           = NULL;
+        char const    *rangeParamsStr           = NULL;
+        char const    *rtpInfoParamsStr         = NULL;
+        char const    *wwwAuthenticateParamsStr = NULL;
+        char const    *publicParamsStr          = NULL;
+        char          *bodyStart                = NULL;
+        unsigned       numBodyBytes             = 0;
+        responseSuccess                         = False;
+        do {
+            headerDataCopy = new char[responseBufferSize];
+            strncpy(headerDataCopy, fResponseBuffer, fResponseBytesAlreadySeen);
+            headerDataCopy[fResponseBytesAlreadySeen] = '\0';
+
+            char *lineStart;
+            char *nextLineStart = headerDataCopy;
+            do {
+                lineStart     = nextLineStart;
+                nextLineStart = getLine(lineStart);
+            } while(lineStart[0] == '\0' && nextLineStart != NULL);  // skip over any blank lines at the start
+            if(!parseResponseCode(lineStart, responseCode, responseStr)) {
+                // This does not appear to be a RTSP response; perhaps it's a RTSP request instead?
+                handleIncomingRequest();
+                break;  // we're done with this data
+            }
+
+            // Scan through the headers, handling the ones that we're interested in:
+            Boolean  reachedEndOfHeaders;
+            unsigned cseq          = 0;
+            unsigned contentLength = 0;
+
+            while(1) {
+                reachedEndOfHeaders = True;  // by default; may get changed below
+                lineStart           = nextLineStart;
+                if(lineStart == NULL)
+                    break;
+
+                nextLineStart = getLine(lineStart);
+                if(lineStart[0] == '\0')
+                    break;  // this is a blank line
+                reachedEndOfHeaders = False;
+
+                char const *headerParamsStr;
+                if(checkForHeader(lineStart, "CSeq:", 5, headerParamsStr)) {
+                    if(sscanf(headerParamsStr, "%u", &cseq) != 1 || cseq <= 0) {
+                        envir().setResultMsg("Bad \"CSeq:\" header: \"", lineStart, "\"");
+                        break;
+                    }
+                    // Find the handler function for "cseq":
+                    RequestRecord *request;
+                    while((request = fRequestsAwaitingResponse.dequeue()) != NULL) {
+                        if(request->cseq() < cseq) {  // assumes that the CSeq counter will never wrap around
+                            // We never received (and will never receive) a response for this handler, so delete it:
+                            if(fVerbosityLevel >= 1 && strcmp(request->commandName(), "POST") != 0) {
+                                envir() << "WARNING: The server did not respond to our \"" << request->commandName() << "\" request (CSeq: " << request->cseq()
+                                        << ").  The server appears to be buggy (perhaps not handling pipelined requests properly).\n";
+                            }
+                            delete request;
+                        }
+                        else if(request->cseq() == cseq) {
+                            // This is the handler that we want. Remove its record, but remember it, so that we can later call its handler:
+                            foundRequest = request;
+                            break;
+                        }
+                        else {  // request->cseq() > cseq
+                            // No handler was registered for this response, so ignore it.
+                            break;
+                        }
+                    }
+                }
+                else if(checkForHeader(lineStart, "Content-Length:", 15, headerParamsStr)) {
+                    if(sscanf(headerParamsStr, "%u", &contentLength) != 1) {
+                        envir().setResultMsg("Bad \"Content-Length:\" header: \"", lineStart, "\"");
+                        break;
+                    }
+                }
+                else if(checkForHeader(lineStart, "Content-Base:", 13, headerParamsStr)) {
+                    setBaseURL(headerParamsStr);
+                }
+                else if(checkForHeader(lineStart, "Session:", 8, sessionParamsStr)) {
+                }
+                else if(checkForHeader(lineStart, "Transport:", 10, transportParamsStr)) {
+                }
+                else if(checkForHeader(lineStart, "Scale:", 6, scaleParamsStr)) {
+                }
+                else if(checkForHeader(lineStart, "Speed:",
+                                       // NOTE: Should you feel the need to modify this code,
+                                       6,
+                                       // please first email the "live-devel" mailing list
+                                       speedParamsStr
+                                       // (see http://live555.com/liveMedia/faq.html#mailing-list-address for details),
+                                       )) {
+                    // to check whether your proposed modification is appropriate/correct,
+                }
+                else if(checkForHeader(lineStart, "Range:",
+                                       // and, if so, whether instead it could be included in
+                                       6,
+                                       // a future release of the "LIVE555 Streaming Media" software,
+                                       rangeParamsStr
+                                       // so that other projects that use the code could benefit (not just your own project).
+                                       )) {
+                }
+                else if(checkForHeader(lineStart, "RTP-Info:", 9, rtpInfoParamsStr)) {
+                }
+                else if(checkForHeader(lineStart, "WWW-Authenticate:", 17, headerParamsStr)) {
+                    // If we've already seen a "WWW-Authenticate:" header, then we replace it with this new one only if
+                    // the new one specifies "Digest" authentication:
+                    if(wwwAuthenticateParamsStr == NULL || _strncasecmp(headerParamsStr, "Digest", 6) == 0) {
+                        wwwAuthenticateParamsStr = headerParamsStr;
+                    }
+                }
+                else if(checkForHeader(lineStart, "Public:", 7, publicParamsStr)) {
+                }
+                else if(checkForHeader(lineStart, "Allow:", 6, publicParamsStr)) {
+                    // Note: we accept "Allow:" instead of "Public:", so that "OPTIONS" requests made to HTTP servers will work.
+                }
+                else if(checkForHeader(lineStart, "Location:", 9, headerParamsStr)) {
+                    setBaseURL(headerParamsStr);
+                }
+                else if(checkForHeader(lineStart, "com.ses.streamID:", 17, headerParamsStr)) {
+                    // Replace the tail of the 'base URL' with the value of this header parameter:
+                    char *oldBaseURLTail = strrchr(fBaseURL, '/');
+                    if(oldBaseURLTail != NULL) {
+                        unsigned newBaseURLLen = (oldBaseURLTail - fBaseURL) + 8 /* for "/stream=" */ + strlen(headerParamsStr);
+                        char    *newBaseURL    = new char[newBaseURLLen + 1];
+                        // Note: We couldn't use "asprintf()", because some compilers don't support it
+                        sprintf(newBaseURL, "%.*s/stream=%s", (int)(oldBaseURLTail - fBaseURL), fBaseURL, headerParamsStr);
+                        setBaseURL(newBaseURL);
+                        delete[] newBaseURL;
+                    }
+                }
+                else if(checkForHeader(lineStart, "Connection:", 11, headerParamsStr)) {
+                    if(fTunnelOverHTTPPortNum == 0 && _strncasecmp(headerParamsStr, "Close", 5) == 0) {
+                        resetTCPSockets();
+                    }
+                }
+            }
+            if(!reachedEndOfHeaders)
+                break;  // an error occurred
+
+            if(foundRequest == NULL) {
+                // Hack: The response didn't have a "CSeq:" header; assume it's for our most recent request:
+                foundRequest = fRequestsAwaitingResponse.dequeue();
+            }
+
+            // If we saw a "Content-Length:" header, then make sure that we have the amount of data that it specified:
+            unsigned bodyOffset = nextLineStart == NULL ? fResponseBytesAlreadySeen : nextLineStart - headerDataCopy;
+            bodyStart           = &fResponseBuffer[bodyOffset];
+            numBodyBytes        = fResponseBytesAlreadySeen - bodyOffset;
+            if(contentLength > numBodyBytes) {
+                // We need to read more data.  First, make sure we have enough space for it:
+                unsigned numExtraBytesNeeded = contentLength - numBodyBytes;
+                unsigned remainingBufferSize = responseBufferSize - fResponseBytesAlreadySeen;
+                if(numExtraBytesNeeded > remainingBufferSize) {
+                    char tmpBuf[200];
+                    sprintf(tmpBuf, "Response buffer size (%d) is too small for \"Content-Length:\" %d (need a buffer size of >= %d bytes\n",
+                            responseBufferSize, contentLength, fResponseBytesAlreadySeen + numExtraBytesNeeded);
+                    envir().setResultMsg(tmpBuf);
+                    break;
+                }
+
+                if(fVerbosityLevel >= 1) {
+                    envir() << "Have received " << fResponseBytesAlreadySeen << " total bytes of a "
+                            << (foundRequest != NULL ? foundRequest->commandName() : "(unknown)") << " RTSP response; awaiting " << numExtraBytesNeeded
+                            << " bytes more.\n";
+                }
+                delete[] headerDataCopy;
+                if(foundRequest != NULL)
+                    fRequestsAwaitingResponse.putAtHead(foundRequest);  // put our request record back; we need it again
+                return;                                                 // We need to read more data
+            }
+
+            // We now have a complete response (including all bytes specified by the "Content-Length:" header, if any).
+            char *responseEnd          = bodyStart + contentLength;
+            numExtraBytesAfterResponse = &fResponseBuffer[fResponseBytesAlreadySeen] - responseEnd;
+
+            if(fVerbosityLevel >= 1) {
+                char saved   = *responseEnd;
+                *responseEnd = '\0';
+                envir() << "Received a complete " << (foundRequest != NULL ? foundRequest->commandName() : "(unknown)") << " response:\n"
+                        << fResponseBuffer << "\n";
+                if(numExtraBytesAfterResponse > 0)
+                    envir() << "\t(plus " << numExtraBytesAfterResponse << " additional bytes)\n";
+                *responseEnd = saved;
+            }
+
+            if(foundRequest != NULL) {
+                Boolean needToResendCommand = False;  // by default...
+                if(responseCode == 200) {
+                    // Do special-case response handling for some commands:
+                    if(strcmp(foundRequest->commandName(), "SETUP") == 0) {
+                        if(!handleSETUPResponse(*foundRequest->subsession(), sessionParamsStr, transportParamsStr, foundRequest->booleanFlags() & 0x1))
+                            break;
+                    }
+                    else if(strcmp(foundRequest->commandName(), "PLAY") == 0) {
+                        if(!handlePLAYResponse(foundRequest->session(), foundRequest->subsession(), scaleParamsStr, speedParamsStr, rangeParamsStr,
+                                               rtpInfoParamsStr))
+                            break;
+                    }
+                    else if(strcmp(foundRequest->commandName(), "TEARDOWN") == 0) {
+                        if(!handleTEARDOWNResponse(*foundRequest->session(), *foundRequest->subsession()))
+                            break;
+                    }
+                    else if(strcmp(foundRequest->commandName(), "GET_PARAMETER") == 0) {
+                        if(!handleGET_PARAMETERResponse(foundRequest->contentStr(), bodyStart, responseEnd))
+                            break;
+                    }
+                }
+                else if(responseCode == 401 && handleAuthenticationFailure(wwwAuthenticateParamsStr)) {
+                    // We need to resend the command, with an "Authorization:" header:
+                    needToResendCommand = True;
+
+                    if(strcmp(foundRequest->commandName(), "GET") == 0) {
+                        // Note: If a HTTP "GET" command (for RTSP-over-HTTP tunneling) returns "401 Unauthorized", then we resend it
+                        // (with an "Authorization:" header), just as we would for a RTSP command.  However, we do so using a new TCP connection,
+                        // because some servers close the original connection after returning the "401 Unauthorized".
+                        resetTCPSockets();  // forces the opening of a new connection for the resent command
+                    }
+                }
+                else if(responseCode == 301 || responseCode == 302) {  // redirection
+                    resetTCPSockets();                                 // because we need to connect somewhere else next
+                    needToResendCommand = True;
+                }
+
+                if(needToResendCommand) {
+                    resetResponseBuffer();
+                    (void)resendCommand(foundRequest);
+                    delete[] headerDataCopy;
+                    return;  // without calling our response handler; the response to the resent command will do that
+                }
+            }
+
+            responseSuccess = True;
+        } while(0);
+
+        // If we have a handler function for this response, call it.
+        // But first, reset our response buffer, in case the handler goes to the event loop, and we end up getting called recursively:
+        if(numExtraBytesAfterResponse > 0) {
+            // An unusual case; usually due to having received pipelined responses.  Move the extra bytes to the front of the buffer:
+            char *responseEnd = &fResponseBuffer[fResponseBytesAlreadySeen - numExtraBytesAfterResponse];
+
+            // But first: A hack to save a copy of the response 'body', in case it's needed below for "resultString":
+            numBodyBytes -= numExtraBytesAfterResponse;
+            if(numBodyBytes > 0) {
+                char saved   = *responseEnd;
+                *responseEnd = '\0';
+                bodyStart    = strDup(bodyStart);
+                *responseEnd = saved;
+            }
+
+            memmove(fResponseBuffer, responseEnd, numExtraBytesAfterResponse);
+            fResponseBytesAlreadySeen                   = numExtraBytesAfterResponse;
+            fResponseBufferBytesLeft                    = responseBufferSize - numExtraBytesAfterResponse;
+            fResponseBuffer[numExtraBytesAfterResponse] = '\0';
+        }
+        else {
+            resetResponseBuffer();
+        }
+        if(foundRequest != NULL && foundRequest->handler() != NULL) {
+            int   resultCode;
+            char *resultString;
+            if(responseSuccess) {
+                if(responseCode == 200) {
+                    resultCode   = 0;
+                    resultString = numBodyBytes > 0 ? strDup(bodyStart) : strDup(publicParamsStr);
+                    // Note: The "strDup(bodyStart)" call assumes that the body is encoded without interior '\0' bytes
+                }
+                else {
+                    resultCode   = responseCode;
+                    resultString = strDup(responseStr);
+                    envir().setResultMsg(responseStr);
+                }
+                (*foundRequest->handler())(this, resultCode, resultString);
+            }
+            else {
+                // An error occurred parsing the response, so call the handler, indicating an error:
+                handleRequestError(foundRequest);
+            }
+        }
+        delete foundRequest;
+        delete[] headerDataCopy;
+        if(numExtraBytesAfterResponse > 0 && numBodyBytes > 0)
+            delete[] bodyStart;
+    } while(numExtraBytesAfterResponse > 0 && responseSuccess);
+}
+
+int RTSPClient::write(const char *data, unsigned count) {
+    if(fTLS.isNeeded) {
+        return fTLS.write(data, count);
+    }
+    else {
+        return send(fOutputSocketNum, data, count, 0);
+    }
+}
+
+int RTSPClient::read(u_int8_t *buffer, unsigned bufferSize) {
+    if(fTLS.isNeeded) {
+        return fTLS.read(buffer, bufferSize);
+    }
+    else {
+        struct sockaddr_storage dummy;  // 'from' address - not used
+        return readSocket(envir(), fInputSocketNum, buffer, bufferSize, dummy);
+    }
+}
+
+////////// RTSPClient::RequestRecord implementation //////////
+
+RTSPClient::RequestRecord::RequestRecord(unsigned cseq, char const *commandName, responseHandler *handler, MediaSession *session, MediaSubsession *subsession,
+                                         u_int32_t booleanFlags, double start, double end, float scale, char const *contentStr)
+    : fNext(NULL),
+      fCSeq(cseq),
+      fCommandName(commandName),
+      fSession(session),
+      fSubsession(subsession),
+      fBooleanFlags(booleanFlags),
+      fStart(start),
+      fEnd(end),
+      fAbsStartTime(NULL),
+      fAbsEndTime(NULL),
+      fScale(scale),
+      fContentStr(strDup(contentStr)),
+      fHandler(handler) {}
+
+RTSPClient::RequestRecord::RequestRecord(unsigned cseq, responseHandler *handler, char const *absStartTime, char const *absEndTime, float scale,
+                                         MediaSession *session, MediaSubsession *subsession)
+    : fNext(NULL),
+      fCSeq(cseq),
+      fCommandName("PLAY"),
+      fSession(session),
+      fSubsession(subsession),
+      fBooleanFlags(0),
+      fStart(0.0f),
+      fEnd(-1.0f),
+      fAbsStartTime(strDup(absStartTime)),
+      fAbsEndTime(strDup(absEndTime)),
+      fScale(scale),
+      fContentStr(NULL),
+      fHandler(handler) {}
+
+RTSPClient::RequestRecord::~RequestRecord() {
+    // Delete the rest of the list first:
+    delete fNext;
+
+    delete[] fAbsStartTime;
+    delete[] fAbsEndTime;
+    delete[] fContentStr;
+}
+
+////////// RTSPClient::RequestQueue implementation //////////
+
+RTSPClient::RequestQueue::RequestQueue() : fHead(NULL), fTail(NULL) {}
+
+RTSPClient::RequestQueue::RequestQueue(RequestQueue &origQueue) : fHead(NULL), fTail(NULL) {
+    RequestRecord *request;
+    while((request = origQueue.dequeue()) != NULL) {
+        enqueue(request);
+    }
+}
+
+RTSPClient::RequestQueue::~RequestQueue() {
+    reset();
+}
+
+void RTSPClient::RequestQueue::enqueue(RequestRecord *request) {
+    if(fTail == NULL) {
+        fHead = request;
+    }
+    else {
+        fTail->next() = request;
+    }
+    fTail = request;
+}
+
+RTSPClient::RequestRecord *RTSPClient::RequestQueue::dequeue() {
+    RequestRecord *request = fHead;
+    if(fHead == fTail) {
+        fHead = NULL;
+        fTail = NULL;
+    }
+    else {
+        fHead = fHead->next();
+    }
+    if(request != NULL)
+        request->next() = NULL;
+    return request;
+}
+
+void RTSPClient::RequestQueue::putAtHead(RequestRecord *request) {
+    request->next() = fHead;
+    fHead           = request;
+    if(fTail == NULL) {
+        fTail = request;
+    }
+}
+
+RTSPClient::RequestRecord *RTSPClient::RequestQueue::findByCSeq(unsigned cseq) {
+    RequestRecord *request;
+    for(request = fHead; request != NULL; request = request->next()) {
+        if(request->cseq() == cseq)
+            return request;
+    }
+    return NULL;
+}
+
+void RTSPClient::RequestQueue::reset() {
+    delete fHead;
+    fHead = fTail = NULL;
+}
+
+#ifndef OMIT_REGISTER_HANDLING
+////////// HandlerServerForREGISTERCommand implementation /////////
+
+HandlerServerForREGISTERCommand *HandlerServerForREGISTERCommand ::createNew(UsageEnvironment &env, onRTSPClientCreationFunc *creationFunc, Port ourPort,
+                                                                             UserAuthenticationDatabase *authDatabase, int verbosityLevel,
+                                                                             char const *applicationName) {
+    int ourSocketIPv4 = setUpOurSocket(env, ourPort, AF_INET);
+    int ourSocketIPv6 = setUpOurSocket(env, ourPort, AF_INET6);
+    if(ourSocketIPv4 < 0 && ourSocketIPv6 < 0)
+        return NULL;
+
+    return new HandlerServerForREGISTERCommand(env, creationFunc, ourSocketIPv4, ourSocketIPv6, ourPort, authDatabase, verbosityLevel, applicationName);
+}
+
+HandlerServerForREGISTERCommand ::HandlerServerForREGISTERCommand(UsageEnvironment &env, onRTSPClientCreationFunc *creationFunc, int ourSocketIPv4,
+                                                                  int ourSocketIPv6, Port ourPort, UserAuthenticationDatabase *authDatabase, int verbosityLevel,
+                                                                  char const *applicationName)
+    : RTSPServer(env, ourSocketIPv4, ourSocketIPv6, ourPort, authDatabase, 30 /*small reclamationTestSeconds*/),
+      fCreationFunc(creationFunc),
+      fVerbosityLevel(verbosityLevel),
+      fApplicationName(strDup(applicationName)) {}
+
+HandlerServerForREGISTERCommand::~HandlerServerForREGISTERCommand() {
+    delete[] fApplicationName;
+}
+
+RTSPClient *HandlerServerForREGISTERCommand ::createNewRTSPClient(char const *rtspURL, int verbosityLevel, char const *applicationName, int socketNumToServer) {
+    // Default implementation: create a basic "RTSPClient":
+    return RTSPClient::createNew(envir(), rtspURL, verbosityLevel, applicationName, 0, socketNumToServer);
+}
+
+char const *HandlerServerForREGISTERCommand::allowedCommandNames() {
+    return "OPTIONS, REGISTER";
+}
+
+Boolean HandlerServerForREGISTERCommand ::weImplementREGISTER(char const *cmd /*"REGISTER" or "DEREGISTER"*/, char const * /*proxyURLSuffix*/,
+                                                              char      *&responseStr) {
+    responseStr = NULL;
+    // By default, we implement only "REGISTER"; not "DEREGISTER".  Subclass to implement "DEREGISTER"
+    return strcmp(cmd, "REGISTER") == 0;
+}
+
+void HandlerServerForREGISTERCommand ::implementCmd_REGISTER(char const *cmd /*"REGISTER" or "DEREGISTER"*/, char const *url, char const *urlSuffix,
+                                                             int socketToRemoteServer, Boolean deliverViaTCP, char const * /*proxyURLSuffix*/) {
+    if(strcmp(cmd, "REGISTER") == 0) {  // By default, we don't implement "DEREGISTER"
+        // Create a new "RTSPClient" object, and call our 'creation function' with it:
+        RTSPClient *newRTSPClient = createNewRTSPClient(url, fVerbosityLevel, fApplicationName, socketToRemoteServer);
+
+        if(fCreationFunc != NULL)
+            (*fCreationFunc)(newRTSPClient, deliverViaTCP);
+    }
+}
+#endif
diff --git a/3rdparty/live555/src/liveMedia/RTSPCommon.cpp b/3rdparty/live555/src/liveMedia/RTSPCommon.cpp
new file mode 100644
index 00000000..10242de4
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/RTSPCommon.cpp
@@ -0,0 +1,409 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// Common routines used by both RTSP clients and servers
+// Implementation
+
+#include "RTSPCommon.hh"
+#include "Locale.hh"
+#include <string.h>
+#include <stdio.h>
+#include <ctype.h>  // for "isxdigit()
+#include <time.h>   // for "strftime()" and "gmtime()"
+
+static void decodeURL(char *url) {
+    // Replace (in place) any %<hex><hex> sequences with the appropriate 8-bit character.
+    char *cursor = url;
+    while(*cursor) {
+        if((cursor[0] == '%') && cursor[1] && isxdigit(cursor[1]) && cursor[2] && isxdigit(cursor[2])) {
+            // We saw a % followed by 2 hex digits, so we copy the literal hex value into the URL, then advance the cursor past it:
+            char hex[3];
+            hex[0] = cursor[1];
+            hex[1] = cursor[2];
+            hex[2] = '\0';
+            *url++ = (char)strtol(hex, NULL, 16);
+            cursor += 3;
+        }
+        else {
+            // Common case: This is a normal character or a bogus % expression, so just copy it
+            *url++ = *cursor++;
+        }
+    }
+
+    *url = '\0';
+}
+
+Boolean parseRTSPRequestString(char const *reqStr, unsigned reqStrSize, char *resultCmdName, unsigned resultCmdNameMaxSize, char *resultURLPreSuffix,
+                               unsigned resultURLPreSuffixMaxSize, char *resultURLSuffix, unsigned resultURLSuffixMaxSize, char *resultCSeq,
+                               unsigned resultCSeqMaxSize, char *resultSessionIdStr, unsigned resultSessionIdStrMaxSize, unsigned &contentLength,
+                               Boolean &urlIsRTSPS) {
+    // This parser is currently rather dumb; it should be made smarter #####
+    urlIsRTSPS = False;  // by default
+
+    // "Be liberal in what you accept": Skip over any whitespace at the start of the request:
+    unsigned i;
+    for(i = 0; i < reqStrSize; ++i) {
+        char c = reqStr[i];
+        if(!(c == ' ' || c == '\t' || c == '\r' || c == '\n' || c == '\0'))
+            break;
+    }
+    if(i == reqStrSize)
+        return False;  // The request consisted of nothing but whitespace!
+
+    // Then read everything up to the next space (or tab) as the command name:
+    Boolean  parseSucceeded = False;
+    unsigned i1             = 0;
+    for(; i1 < resultCmdNameMaxSize - 1 && i < reqStrSize; ++i, ++i1) {
+        char c = reqStr[i];
+        if(c == ' ' || c == '\t') {
+            parseSucceeded = True;
+            break;
+        }
+
+        resultCmdName[i1] = c;
+    }
+    resultCmdName[i1] = '\0';
+    if(!parseSucceeded)
+        return False;
+
+    // Skip over the prefix of any "rtsp://" or "rtsp:/" (or "rtsps://" or "rtsps:/")
+    // URL that follows:
+    unsigned j = i + 1;
+    while(j < reqStrSize && (reqStr[j] == ' ' || reqStr[j] == '\t'))
+        ++j;  // skip over any additional white space
+    for(; (int)j < (int)(reqStrSize - 8); ++j) {
+        if((reqStr[j] == 'r' || reqStr[j] == 'R') && (reqStr[j + 1] == 't' || reqStr[j + 1] == 'T') && (reqStr[j + 2] == 's' || reqStr[j + 2] == 'S')
+           && (reqStr[j + 3] == 'p' || reqStr[j + 3] == 'P')) {
+            if(reqStr[j + 4] == 's' || reqStr[j + 4] == 'S') {
+                urlIsRTSPS = True;
+                ++j;
+            }
+            if(reqStr[j + 4] == ':' && reqStr[j + 5] == '/') {
+                j += 6;
+                if(reqStr[j] == '/') {
+                    // This is a "rtsp(s)://" URL; skip over the host:port part that follows:
+                    ++j;
+                    while(j < reqStrSize && reqStr[j] != '/' && reqStr[j] != ' ')
+                        ++j;
+                }
+                else {
+                    // This is a "rtsp(s):/" URL; back up to the "/":
+                    --j;
+                }
+                i = j;
+                break;
+            }
+        }
+    }
+
+    // Look for the URL suffix (before the following "RTSP/"):
+    parseSucceeded = False;
+    for(unsigned k = i + 1; (int)k < (int)(reqStrSize - 5); ++k) {
+        if(reqStr[k] == 'R' && reqStr[k + 1] == 'T' && reqStr[k + 2] == 'S' && reqStr[k + 3] == 'P' && reqStr[k + 4] == '/') {
+            while(--k >= i && reqStr[k] == ' ') {
+            }  // go back over all spaces before "RTSP/"
+            unsigned k1 = k;
+            while(k1 > i && reqStr[k1] != '/')
+                --k1;
+
+            // ASSERT: At this point
+            //   i: first space or slash after "host" or "host:port"
+            //   k: last non-space before "RTSP/"
+            //   k1: last slash in the range [i,k]
+
+            // The URL suffix comes from [k1+1,k]
+            // Copy "resultURLSuffix":
+            unsigned n = 0, k2 = k1 + 1;
+            if(k2 <= k) {
+                if(k - k1 + 1 > resultURLSuffixMaxSize)
+                    return False;  // there's no room
+                while(k2 <= k)
+                    resultURLSuffix[n++] = reqStr[k2++];
+            }
+            resultURLSuffix[n] = '\0';
+
+            // The URL 'pre-suffix' comes from [i+1,k1-1]
+            // Copy "resultURLPreSuffix":
+            n  = 0;
+            k2 = i + 1;
+            if(k2 + 1 <= k1) {
+                if(k1 - i > resultURLPreSuffixMaxSize)
+                    return False;  // there's no room
+                while(k2 <= k1 - 1)
+                    resultURLPreSuffix[n++] = reqStr[k2++];
+            }
+            resultURLPreSuffix[n] = '\0';
+            decodeURL(resultURLPreSuffix);
+
+            i              = k + 7;  // to go past " RTSP/"
+            parseSucceeded = True;
+            break;
+        }
+    }
+    if(!parseSucceeded)
+        return False;
+
+    // Look for "CSeq:" (mandatory, case insensitive), skip whitespace,
+    // then read everything up to the next \r or \n as 'CSeq':
+    parseSucceeded = False;
+    for(j = i; (int)j < (int)(reqStrSize - 5); ++j) {
+        if(_strncasecmp("CSeq:", &reqStr[j], 5) == 0) {
+            j += 5;
+            while(j < reqStrSize && (reqStr[j] == ' ' || reqStr[j] == '\t'))
+                ++j;
+            unsigned n;
+            for(n = 0; n < resultCSeqMaxSize - 1 && j < reqStrSize; ++n, ++j) {
+                char c = reqStr[j];
+                if(c == '\r' || c == '\n') {
+                    parseSucceeded = True;
+                    break;
+                }
+
+                resultCSeq[n] = c;
+            }
+            resultCSeq[n] = '\0';
+            break;
+        }
+    }
+    if(!parseSucceeded)
+        return False;
+
+    // Look for "Session:" (optional, case insensitive), skip whitespace,
+    // then read everything up to the next \r or \n as 'Session':
+    resultSessionIdStr[0] = '\0';  // default value (empty string)
+    for(j = i; (int)j < (int)(reqStrSize - 8); ++j) {
+        if(_strncasecmp("Session:", &reqStr[j], 8) == 0) {
+            j += 8;
+            while(j < reqStrSize && (reqStr[j] == ' ' || reqStr[j] == '\t'))
+                ++j;
+            unsigned n;
+            for(n = 0; n < resultSessionIdStrMaxSize - 1 && j < reqStrSize; ++n, ++j) {
+                char c = reqStr[j];
+                if(c == '\r' || c == '\n') {
+                    break;
+                }
+
+                resultSessionIdStr[n] = c;
+            }
+            resultSessionIdStr[n] = '\0';
+            break;
+        }
+    }
+
+    // Also: Look for "Content-Length:" (optional, case insensitive)
+    contentLength = 0;  // default value
+    for(j = i; (int)j < (int)(reqStrSize - 15); ++j) {
+        if(_strncasecmp("Content-Length:", &(reqStr[j]), 15) == 0) {
+            j += 15;
+            while(j < reqStrSize && (reqStr[j] == ' ' || reqStr[j] == '\t'))
+                ++j;
+            unsigned num;
+            if(sscanf(&reqStr[j], "%u", &num) == 1) {
+                contentLength = num;
+            }
+        }
+    }
+    return True;
+}
+
+Boolean parseRangeParam(char const *paramStr, double &rangeStart, double &rangeEnd, char *&absStartTime, char *&absEndTime, Boolean &startTimeIsNow) {
+    delete[] absStartTime;
+    delete[] absEndTime;
+    absStartTime = absEndTime = NULL;   // by default, unless "paramStr" is a "clock=..." string
+    startTimeIsNow            = False;  // by default
+    double start, end;
+    int    numCharsMatched1 = 0, numCharsMatched2 = 0, numCharsMatched3 = 0, numCharsMatched4 = 0;
+    int    startHour = 0, startMin = 0, endHour = 0, endMin = 0;
+    double startSec = 0.0, endSec = 0.0;
+    Locale l("C", Numeric);
+    if(sscanf(paramStr, "npt = %d:%d:%lf - %d:%d:%lf", &startHour, &startMin, &startSec, &endHour, &endMin, &endSec) == 6) {
+        rangeStart = startHour * 3600 + startMin * 60 + startSec;
+        rangeEnd   = endHour * 3600 + endMin * 60 + endSec;
+    }
+    else if(sscanf(paramStr, "npt =%lf - %d:%d:%lf", &start, &endHour, &endMin, &endSec) == 4) {
+        rangeStart = start;
+        rangeEnd   = endHour * 3600 + endMin * 60 + endSec;
+    }
+    else if(sscanf(paramStr, "npt = %d:%d:%lf -", &startHour, &startMin, &startSec) == 3) {
+        rangeStart = startHour * 3600 + startMin * 60 + startSec;
+        rangeEnd   = 0.0;
+    }
+    else if(sscanf(paramStr, "npt = %lf - %lf", &start, &end) == 2) {
+        rangeStart = start;
+        rangeEnd   = end;
+    }
+    else if(sscanf(paramStr, "npt = %n%lf -", &numCharsMatched1, &start) == 1) {
+        if(paramStr[numCharsMatched1] == '-') {
+            // special case for "npt = -<endtime>", which matches here:
+            rangeStart     = 0.0;
+            startTimeIsNow = True;
+            rangeEnd       = -start;
+        }
+        else {
+            rangeStart = start;
+            rangeEnd   = 0.0;
+        }
+    }
+    else if(sscanf(paramStr, "npt = now - %lf", &end) == 1) {
+        rangeStart     = 0.0;
+        startTimeIsNow = True;
+        rangeEnd       = end;
+    }
+    else if(sscanf(paramStr, "npt = now -%n", &numCharsMatched2) == 0 && numCharsMatched2 > 0) {
+        rangeStart     = 0.0;
+        startTimeIsNow = True;
+        rangeEnd       = 0.0;
+    }
+    else if(sscanf(paramStr, "clock = %n", &numCharsMatched3) == 0 && numCharsMatched3 > 0) {
+        rangeStart = rangeEnd = 0.0;
+
+        char const *utcTimes     = &paramStr[numCharsMatched3];
+        size_t      len          = strlen(utcTimes) + 1;
+        char *      as           = new char[len];
+        char *      ae           = new char[len];
+        int         sscanfResult = sscanf(utcTimes, "%[^-]-%[^\r\n]", as, ae);
+        if(sscanfResult == 2) {
+            absStartTime = as;
+            absEndTime   = ae;
+        }
+        else if(sscanfResult == 1) {
+            absStartTime = as;
+            delete[] ae;
+        }
+        else {
+            delete[] as;
+            delete[] ae;
+            return False;
+        }
+    }
+    else if(sscanf(paramStr, "smtpe = %n", &numCharsMatched4) == 0 && numCharsMatched4 > 0) {
+        // We accept "smtpe=" parameters, but currently do not interpret them.
+    }
+    else {
+        return False;  // The header is malformed
+    }
+
+    return True;
+}
+
+Boolean parseRangeHeader(char const *buf, double &rangeStart, double &rangeEnd, char *&absStartTime, char *&absEndTime, Boolean &startTimeIsNow) {
+    // First, find "Range:"
+    while(1) {
+        if(*buf == '\0')
+            return False;  // not found
+        if(_strncasecmp(buf, "Range: ", 7) == 0)
+            break;
+        ++buf;
+    }
+
+    char const *fields = buf + 7;
+    while(*fields == ' ')
+        ++fields;
+    return parseRangeParam(fields, rangeStart, rangeEnd, absStartTime, absEndTime, startTimeIsNow);
+}
+
+Boolean parseScaleHeader(char const *buf, float &scale) {
+    // Initialize the result parameter to a default value:
+    scale = 1.0;
+
+    // First, find "Scale:"
+    while(1) {
+        if(*buf == '\0')
+            return False;  // not found
+        if(_strncasecmp(buf, "Scale:", 6) == 0)
+            break;
+        ++buf;
+    }
+
+    char const *fields = buf + 6;
+    while(*fields == ' ')
+        ++fields;
+    float sc;
+    if(sscanf(fields, "%f", &sc) == 1) {
+        scale = sc;
+    }
+    else {
+        return False;  // The header is malformed
+    }
+
+    return True;
+}
+
+// Used to implement "RTSPOptionIsSupported()":
+static Boolean isSeparator(char c) {
+    return c == ' ' || c == ',' || c == ';' || c == ':';
+}
+
+Boolean RTSPOptionIsSupported(char const *commandName, char const *optionsResponseString) {
+    do {
+        if(commandName == NULL || optionsResponseString == NULL)
+            break;
+
+        unsigned const commandNameLen = strlen(commandName);
+        if(commandNameLen == 0)
+            break;
+
+        // "optionsResponseString" is assumed to be a list of command names, separated by " " and/or ",", ";", or ":"
+        // Scan through these, looking for "commandName".
+        while(1) {
+            // Skip over separators:
+            while(*optionsResponseString != '\0' && isSeparator(*optionsResponseString))
+                ++optionsResponseString;
+            if(*optionsResponseString == '\0')
+                break;
+
+            // At this point, "optionsResponseString" begins with a command name (with perhaps a separator afterwads).
+            if(strncmp(commandName, optionsResponseString, commandNameLen) == 0) {
+                // We have at least a partial match here.
+                optionsResponseString += commandNameLen;
+                if(*optionsResponseString == '\0' || isSeparator(*optionsResponseString))
+                    return True;
+            }
+
+            // No match.  Skip over the rest of the command name:
+            while(*optionsResponseString != '\0' && !isSeparator(*optionsResponseString))
+                ++optionsResponseString;
+        }
+    } while(0);
+
+    return False;
+}
+
+char const *dateHeader() {
+    static char buf[200];
+#if !defined(_WIN32_WCE)
+    time_t tt = time(NULL);
+    strftime(buf, sizeof buf, "Date: %a, %b %d %Y %H:%M:%S GMT\r\n", gmtime(&tt));
+#else
+    // WinCE apparently doesn't have "time()", "strftime()", or "gmtime()",
+    // so generate the "Date:" header a different, WinCE-specific way.
+    // (Thanks to Pierre l'Hussiez for this code)
+    // RSF: But where is the "Date: " string?  This code doesn't look quite right...
+    SYSTEMTIME SystemTime;
+    GetSystemTime(&SystemTime);
+    WCHAR dateFormat[] = L"ddd, MMM dd yyyy";
+    WCHAR timeFormat[] = L"HH:mm:ss GMT\r\n";
+    WCHAR inBuf[200];
+    DWORD locale = LOCALE_NEUTRAL;
+
+    int ret        = GetDateFormat(locale, 0, &SystemTime, (LPTSTR)dateFormat, (LPTSTR)inBuf, sizeof inBuf);
+    inBuf[ret - 1] = ' ';
+    ret            = GetTimeFormat(locale, 0, &SystemTime, (LPTSTR)timeFormat, (LPTSTR)inBuf + ret, (sizeof inBuf) - ret);
+    wcstombs(buf, inBuf, wcslen(inBuf));
+#endif
+    return buf;
+}
diff --git a/3rdparty/live555/src/liveMedia/RTSPRegisterSender.cpp b/3rdparty/live555/src/liveMedia/RTSPRegisterSender.cpp
new file mode 100644
index 00000000..1f9762cb
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/RTSPRegisterSender.cpp
@@ -0,0 +1,194 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// Special objects which, when created, sends a custom RTSP "REGISTER" (or "DEREGISTER") command
+// to a specified client.
+// Implementation
+
+#include "RTSPRegisterSender.hh"
+
+////////// RTSPRegisterOrDeregisterSender implementation /////////
+
+RTSPRegisterOrDeregisterSender ::RTSPRegisterOrDeregisterSender(UsageEnvironment &env, char const *remoteClientNameOrAddress, portNumBits remoteClientPortNum,
+                                                                Authenticator *authenticator, int verbosityLevel, char const *applicationName)
+    : RTSPClient(env, NULL, verbosityLevel, applicationName, 0, -1), fRemoteClientPortNum(remoteClientPortNum) {
+    // Set up a connection to the remote client.  To do this, we create a fake "rtsp://" URL for it:
+    char const *fakeRTSPURLFmt  = "rtsp://%s:%u/";
+    unsigned    fakeRTSPURLSize = strlen(fakeRTSPURLFmt) + strlen(remoteClientNameOrAddress) + 5 /* max port num len */;
+    char *      fakeRTSPURL     = new char[fakeRTSPURLSize];
+    sprintf(fakeRTSPURL, fakeRTSPURLFmt, remoteClientNameOrAddress, remoteClientPortNum);
+    setBaseURL(fakeRTSPURL);
+    delete[] fakeRTSPURL;
+
+    if(authenticator != NULL)
+        fCurrentAuthenticator = *authenticator;
+}
+
+RTSPRegisterOrDeregisterSender::~RTSPRegisterOrDeregisterSender() {}
+
+RTSPRegisterOrDeregisterSender::RequestRecord_REGISTER_or_DEREGISTER ::RequestRecord_REGISTER_or_DEREGISTER(unsigned cseq, char const *cmdName,
+                                                                                                            RTSPClient::responseHandler *rtspResponseHandler,
+                                                                                                            char const *rtspURLToRegisterOrDeregister,
+                                                                                                            char const *proxyURLSuffix)
+    : RTSPClient::RequestRecord(cseq, cmdName, rtspResponseHandler),
+      fRTSPURLToRegisterOrDeregister(strDup(rtspURLToRegisterOrDeregister)),
+      fProxyURLSuffix(strDup(proxyURLSuffix)) {}
+
+RTSPRegisterOrDeregisterSender::RequestRecord_REGISTER_or_DEREGISTER ::~RequestRecord_REGISTER_or_DEREGISTER() {
+    delete[] fRTSPURLToRegisterOrDeregister;
+    delete[] fProxyURLSuffix;
+}
+
+////////// RTSPRegisterSender implementation /////////
+
+RTSPRegisterSender *RTSPRegisterSender ::createNew(UsageEnvironment &env, char const *remoteClientNameOrAddress, portNumBits remoteClientPortNum,
+                                                   char const *rtspURLToRegister, RTSPClient::responseHandler *rtspResponseHandler,
+                                                   Authenticator *authenticator, Boolean requestStreamingViaTCP, char const *proxyURLSuffix,
+                                                   Boolean reuseConnection, int verbosityLevel, char const *applicationName) {
+    return new RTSPRegisterSender(env, remoteClientNameOrAddress, remoteClientPortNum, rtspURLToRegister, rtspResponseHandler, authenticator,
+                                  requestStreamingViaTCP, proxyURLSuffix, reuseConnection, verbosityLevel, applicationName);
+}
+
+void RTSPRegisterSender::grabConnection(int &sock, struct sockaddr_storage &remoteAddress) {
+    sock = grabSocket();
+
+    remoteAddress = fServerAddress;
+    setPortNum(remoteAddress, htons(fRemoteClientPortNum));
+}
+
+RTSPRegisterSender ::RTSPRegisterSender(UsageEnvironment &env, char const *remoteClientNameOrAddress, portNumBits remoteClientPortNum,
+                                        char const *rtspURLToRegister, RTSPClient::responseHandler *rtspResponseHandler, Authenticator *authenticator,
+                                        Boolean requestStreamingViaTCP, char const *proxyURLSuffix, Boolean reuseConnection, int verbosityLevel,
+                                        char const *applicationName)
+    : RTSPRegisterOrDeregisterSender(env, remoteClientNameOrAddress, remoteClientPortNum, authenticator, verbosityLevel, applicationName) {
+    // Send the "REGISTER" request:
+    (void)sendRequest(new RequestRecord_REGISTER(++fCSeq, rtspResponseHandler, rtspURLToRegister, reuseConnection, requestStreamingViaTCP, proxyURLSuffix));
+}
+
+RTSPRegisterSender::~RTSPRegisterSender() {}
+
+Boolean RTSPRegisterSender::setRequestFields(RequestRecord *request, char *&cmdURL, Boolean &cmdURLWasAllocated, char const *&protocolStr, char *&extraHeaders,
+                                             Boolean &extraHeadersWereAllocated) {
+    if(strcmp(request->commandName(), "REGISTER") == 0) {
+        RequestRecord_REGISTER *request_REGISTER = (RequestRecord_REGISTER *)request;
+
+        setBaseURL(request_REGISTER->rtspURLToRegister());
+        cmdURL             = (char *)url();
+        cmdURLWasAllocated = False;
+
+        // Generate the "Transport:" header that will contain our REGISTER-specific parameters.  This will be "extraHeaders".
+        // First, generate the "proxy_url_suffix" parameter string, if any:
+        char *proxyURLSuffixParameterStr;
+        if(request_REGISTER->proxyURLSuffix() == NULL) {
+            proxyURLSuffixParameterStr = strDup("");
+        }
+        else {
+            char const *proxyURLSuffixParameterFmt  = "; proxy_url_suffix=%s";
+            unsigned    proxyURLSuffixParameterSize = strlen(proxyURLSuffixParameterFmt) + strlen(request_REGISTER->proxyURLSuffix());
+            proxyURLSuffixParameterStr              = new char[proxyURLSuffixParameterSize];
+            sprintf(proxyURLSuffixParameterStr, proxyURLSuffixParameterFmt, request_REGISTER->proxyURLSuffix());
+        }
+
+        char const *transportHeaderFmt  = "Transport: %spreferred_delivery_protocol=%s%s\r\n";
+        unsigned    transportHeaderSize = strlen(transportHeaderFmt) + 100 /*conservative*/ + strlen(proxyURLSuffixParameterStr);
+        char *      transportHeaderStr  = new char[transportHeaderSize];
+        sprintf(transportHeaderStr, transportHeaderFmt, request_REGISTER->reuseConnection() ? "reuse_connection; " : "",
+                request_REGISTER->requestStreamingViaTCP() ? "interleaved" : "udp", proxyURLSuffixParameterStr);
+        delete[] proxyURLSuffixParameterStr;
+
+        extraHeaders              = transportHeaderStr;
+        extraHeadersWereAllocated = True;
+
+        return True;
+    }
+    else {
+        return RTSPClient::setRequestFields(request, cmdURL, cmdURLWasAllocated, protocolStr, extraHeaders, extraHeadersWereAllocated);
+    }
+}
+
+RTSPRegisterSender::RequestRecord_REGISTER ::RequestRecord_REGISTER(unsigned cseq, RTSPClient::responseHandler *rtspResponseHandler,
+                                                                    char const *rtspURLToRegister, Boolean reuseConnection, Boolean requestStreamingViaTCP,
+                                                                    char const *proxyURLSuffix)
+    : RTSPRegisterOrDeregisterSender::RequestRecord_REGISTER_or_DEREGISTER(cseq, "REGISTER", rtspResponseHandler, rtspURLToRegister, proxyURLSuffix),
+      fReuseConnection(reuseConnection),
+      fRequestStreamingViaTCP(requestStreamingViaTCP) {}
+
+RTSPRegisterSender::RequestRecord_REGISTER::~RequestRecord_REGISTER() {}
+
+////////// RTSPDeregisterSender implementation /////////
+
+RTSPDeregisterSender *RTSPDeregisterSender ::createNew(UsageEnvironment &env, char const *remoteClientNameOrAddress, portNumBits remoteClientPortNum,
+                                                       char const *rtspURLToDeregister, RTSPClient::responseHandler *rtspResponseHandler,
+                                                       Authenticator *authenticator, char const *proxyURLSuffix, int verbosityLevel,
+                                                       char const *applicationName) {
+    return new RTSPDeregisterSender(env, remoteClientNameOrAddress, remoteClientPortNum, rtspURLToDeregister, rtspResponseHandler, authenticator,
+                                    proxyURLSuffix, verbosityLevel, applicationName);
+}
+
+RTSPDeregisterSender ::RTSPDeregisterSender(UsageEnvironment &env, char const *remoteClientNameOrAddress, portNumBits remoteClientPortNum,
+                                            char const *rtspURLToDeregister, RTSPClient::responseHandler *rtspResponseHandler, Authenticator *authenticator,
+                                            char const *proxyURLSuffix, int verbosityLevel, char const *applicationName)
+    : RTSPRegisterOrDeregisterSender(env, remoteClientNameOrAddress, remoteClientPortNum, authenticator, verbosityLevel, applicationName) {
+    // Send the "DEREGISTER" request:
+    (void)sendRequest(new RequestRecord_DEREGISTER(++fCSeq, rtspResponseHandler, rtspURLToDeregister, proxyURLSuffix));
+}
+
+RTSPDeregisterSender::~RTSPDeregisterSender() {}
+
+Boolean RTSPDeregisterSender::setRequestFields(RequestRecord *request, char *&cmdURL, Boolean &cmdURLWasAllocated, char const *&protocolStr,
+                                               char *&extraHeaders, Boolean &extraHeadersWereAllocated) {
+    if(strcmp(request->commandName(), "DEREGISTER") == 0) {
+        RequestRecord_DEREGISTER *request_DEREGISTER = (RequestRecord_DEREGISTER *)request;
+
+        setBaseURL(request_DEREGISTER->rtspURLToDeregister());
+        cmdURL             = (char *)url();
+        cmdURLWasAllocated = False;
+
+        // Generate the "Transport:" header that will contain our DEREGISTER-specific parameters.  This will be "extraHeaders".
+        // First, generate the "proxy_url_suffix" parameter string, if any:
+        char *proxyURLSuffixParameterStr;
+        if(request_DEREGISTER->proxyURLSuffix() == NULL) {
+            proxyURLSuffixParameterStr = strDup("");
+        }
+        else {
+            char const *proxyURLSuffixParameterFmt  = "proxy_url_suffix=%s";
+            unsigned    proxyURLSuffixParameterSize = strlen(proxyURLSuffixParameterFmt) + strlen(request_DEREGISTER->proxyURLSuffix());
+            proxyURLSuffixParameterStr              = new char[proxyURLSuffixParameterSize];
+            sprintf(proxyURLSuffixParameterStr, proxyURLSuffixParameterFmt, request_DEREGISTER->proxyURLSuffix());
+        }
+
+        char const *transportHeaderFmt  = "Transport: %s\r\n";
+        unsigned    transportHeaderSize = strlen(transportHeaderFmt) + strlen(proxyURLSuffixParameterStr);
+        char *      transportHeaderStr  = new char[transportHeaderSize];
+        sprintf(transportHeaderStr, transportHeaderFmt, proxyURLSuffixParameterStr);
+        delete[] proxyURLSuffixParameterStr;
+
+        extraHeaders              = transportHeaderStr;
+        extraHeadersWereAllocated = True;
+
+        return True;
+    }
+    else {
+        return RTSPClient::setRequestFields(request, cmdURL, cmdURLWasAllocated, protocolStr, extraHeaders, extraHeadersWereAllocated);
+    }
+}
+
+RTSPDeregisterSender::RequestRecord_DEREGISTER ::RequestRecord_DEREGISTER(unsigned cseq, RTSPClient::responseHandler *rtspResponseHandler,
+                                                                          char const *rtspURLToDeregister, char const *proxyURLSuffix)
+    : RTSPRegisterOrDeregisterSender::RequestRecord_REGISTER_or_DEREGISTER(cseq, "DEREGISTER", rtspResponseHandler, rtspURLToDeregister, proxyURLSuffix) {}
+
+RTSPDeregisterSender::RequestRecord_DEREGISTER::~RequestRecord_DEREGISTER() {}
diff --git a/3rdparty/live555/src/liveMedia/RTSPServer.cpp b/3rdparty/live555/src/liveMedia/RTSPServer.cpp
new file mode 100644
index 00000000..c2c8b63b
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/RTSPServer.cpp
@@ -0,0 +1,2015 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A RTSP server
+// Implementation
+
+#include "RTSPServer.hh"
+#include "RTSPCommon.hh"
+#include "RTSPRegisterSender.hh"
+#include "Base64.hh"
+#include <GroupsockHelper.hh>
+
+////////// RTSPServer implementation //////////
+
+RTSPServer *RTSPServer::createNew(UsageEnvironment &env, Port ourPort, UserAuthenticationDatabase *authDatabase, unsigned reclamationSeconds) {
+    int ourSocketIPv4 = setUpOurSocket(env, ourPort, AF_INET);
+    int ourSocketIPv6 = setUpOurSocket(env, ourPort, AF_INET6);
+    if(ourSocketIPv4 < 0 && ourSocketIPv6 < 0)
+        return NULL;
+
+    return new RTSPServer(env, ourSocketIPv4, ourSocketIPv6, ourPort, authDatabase, reclamationSeconds);
+}
+
+Boolean RTSPServer::lookupByName(UsageEnvironment &env, char const *name, RTSPServer *&resultServer) {
+    resultServer = NULL;  // unless we succeed
+
+    Medium *medium;
+    if(!Medium::lookupByName(env, name, medium))
+        return False;
+
+    if(!medium->isRTSPServer()) {
+        env.setResultMsg(name, " is not a RTSP server");
+        return False;
+    }
+
+    resultServer = (RTSPServer *)medium;
+    return True;
+}
+
+char *RTSPServer ::rtspURL(ServerMediaSession const *serverMediaSession, int clientSocket, Boolean useIPv6) const {
+    char *      urlPrefix   = rtspURLPrefix(clientSocket, useIPv6);
+    char const *sessionName = serverMediaSession->streamName();
+
+    char *resultURL = new char[strlen(urlPrefix) + strlen(sessionName) + 1];
+    sprintf(resultURL, "%s%s", urlPrefix, sessionName);
+
+    delete[] urlPrefix;
+    return resultURL;
+}
+
+char *RTSPServer::rtspURLPrefix(int clientSocket, Boolean useIPv6) const {
+    struct sockaddr_storage ourAddress;
+
+    if(clientSocket < 0) {
+        // Use our default IP address in the URL:
+        if(!useIPv6) {  // IPv4
+            ourAddress.ss_family                        = AF_INET;
+            ((sockaddr_in &)ourAddress).sin_addr.s_addr = ourIPv4Address(envir());
+        }
+        else {
+            ourAddress.ss_family            = AF_INET6;
+            ipv6AddressBits const &ourAddr6 = ourIPv6Address(envir());
+            for(unsigned i = 0; i < 16; ++i)
+                ((sockaddr_in6 &)ourAddress).sin6_addr.s6_addr[i] = ourAddr6[i];
+        }
+    }
+    else {
+        SOCKLEN_T namelen = sizeof ourAddress;
+
+        getsockname(clientSocket, (struct sockaddr *)&ourAddress, reinterpret_cast<socklen_t *>(&namelen));
+    }
+
+    char urlBuffer[100];  // more than big enough for "rtsp://<ip-address>:<port>/"
+
+    char const *addressPrefixInURL = ourAddress.ss_family == AF_INET6 ? "[" : "";
+    char const *addressSuffixInURL = ourAddress.ss_family == AF_INET6 ? "]" : "";
+
+    portNumBits defaultPortNum   = fWeServeSRTP ? 322 : 554;
+    portNumBits portNumHostOrder = ntohs(fServerPort.num());
+    if(portNumHostOrder == defaultPortNum) {
+        sprintf(urlBuffer, "rtsp%s://%s%s%s/", fWeServeSRTP ? "s" : "", addressPrefixInURL, AddressString(ourAddress).val(), addressSuffixInURL);
+    }
+    else {
+        sprintf(urlBuffer, "rtsp%s://%s%s%s:%hu/", fWeServeSRTP ? "s" : "", addressPrefixInURL, AddressString(ourAddress).val(), addressSuffixInURL,
+                portNumHostOrder);
+    }
+
+    return strDup(urlBuffer);
+}
+
+UserAuthenticationDatabase *RTSPServer::setAuthenticationDatabase(UserAuthenticationDatabase *newDB) {
+    UserAuthenticationDatabase *oldDB = fAuthDB;
+    fAuthDB                           = newDB;
+
+    return oldDB;
+}
+
+Boolean RTSPServer::setUpTunnelingOverHTTP(Port httpPort) {
+    fHTTPServerSocketIPv4 = setUpOurSocket(envir(), httpPort, AF_INET);
+    fHTTPServerSocketIPv6 = setUpOurSocket(envir(), httpPort, AF_INET6);
+    if(fHTTPServerSocketIPv4 >= 0 || fHTTPServerSocketIPv6 >= 0) {
+        fHTTPServerPort = httpPort;
+        envir().taskScheduler().turnOnBackgroundReadHandling(fHTTPServerSocketIPv4, incomingConnectionHandlerHTTPIPv4, this);
+        envir().taskScheduler().turnOnBackgroundReadHandling(fHTTPServerSocketIPv6, incomingConnectionHandlerHTTPIPv6, this);
+        return True;
+    }
+
+    return False;
+}
+
+portNumBits RTSPServer::httpServerPortNum() const {
+    return ntohs(fHTTPServerPort.num());
+}
+
+void RTSPServer ::setTLSState(char const *certFileName, char const *privKeyFileName, Boolean weServeSRTP, Boolean weEncryptSRTP) {
+    setTLSFileNames(certFileName, privKeyFileName);
+    fOurConnectionsUseTLS = True;
+    fWeServeSRTP          = weServeSRTP;
+    fWeEncryptSRTP        = weEncryptSRTP;
+
+    if(fWeServeSRTP)
+        disableStreamingRTPOverTCP();
+    // If you want to stream RTP-over-TCP using a secure TCP connection, then stream over TLS,
+    // but without SRTP (as that would add extra overhead for no benefit).
+}
+
+char const *RTSPServer::allowedCommandNames() {
+    return "OPTIONS, DESCRIBE, SETUP, TEARDOWN, PLAY, PAUSE, GET_PARAMETER, SET_PARAMETER";
+}
+
+UserAuthenticationDatabase *RTSPServer::getAuthenticationDatabaseForCommand(char const * /*cmdName*/) {
+    // default implementation
+    return fAuthDB;
+}
+
+Boolean RTSPServer::specialClientAccessCheck(int /*clientSocket*/, struct sockaddr_storage const & /*clientAddr*/, char const * /*urlSuffix*/) {
+    // default implementation
+    return True;
+}
+
+Boolean RTSPServer::specialClientUserAccessCheck(int /*clientSocket*/, struct sockaddr_storage const & /*clientAddr*/, char const * /*urlSuffix*/,
+                                                 char const * /*username*/) {
+    // default implementation; no further access restrictions:
+    return True;
+}
+
+RTSPServer::RTSPServer(UsageEnvironment &env, int ourSocketIPv4, int ourSocketIPv6, Port ourPort, UserAuthenticationDatabase *authDatabase,
+                       unsigned reclamationSeconds)
+    : GenericMediaServer(env, ourSocketIPv4, ourSocketIPv6, ourPort, reclamationSeconds),
+      fHTTPServerSocketIPv4(-1),
+      fHTTPServerSocketIPv6(-1),
+      fHTTPServerPort(0),
+      fClientConnectionsForHTTPTunneling(NULL),  // will get created if needed
+      fTCPStreamingDatabase(HashTable::create(ONE_WORD_HASH_KEYS)),
+      fPendingRegisterOrDeregisterRequests(HashTable::create(ONE_WORD_HASH_KEYS)),
+      fRegisterOrDeregisterRequestCounter(0),
+      fAuthDB(authDatabase),
+      fAllowStreamingRTPOverTCP(True),
+      fOurConnectionsUseTLS(False),
+      fWeServeSRTP(False) {
+    portNumBits serverPortNumHostOrder = ntohs(fServerPort.num());
+}
+
+// A data structure that is used to implement "fTCPStreamingDatabase"
+// (and the "noteTCPStreamingOnSocket()" and "stopTCPStreamingOnSocket()" member functions):
+class streamingOverTCPRecord {
+public:
+    streamingOverTCPRecord(u_int32_t sessionId, unsigned trackNum, streamingOverTCPRecord *next) : fNext(next), fSessionId(sessionId), fTrackNum(trackNum) {}
+    virtual ~streamingOverTCPRecord() {
+        delete fNext;
+    }
+
+    streamingOverTCPRecord *fNext;
+    u_int32_t               fSessionId;
+    unsigned                fTrackNum;
+};
+
+RTSPServer::~RTSPServer() {
+    // Turn off background HTTP read handling (if any):
+    envir().taskScheduler().turnOffBackgroundReadHandling(fHTTPServerSocketIPv4);
+    ::closeSocket(fHTTPServerSocketIPv4);
+    envir().taskScheduler().turnOffBackgroundReadHandling(fHTTPServerSocketIPv6);
+    ::closeSocket(fHTTPServerSocketIPv6);
+
+    cleanup();  // Removes all "ClientSession" and "ClientConnection" objects, and their tables.
+    delete fClientConnectionsForHTTPTunneling;
+
+    // Delete any pending REGISTER requests:
+    RTSPRegisterOrDeregisterSender *r;
+    while((r = (RTSPRegisterOrDeregisterSender *)fPendingRegisterOrDeregisterRequests->getFirst()) != NULL) {
+        delete r;
+    }
+    delete fPendingRegisterOrDeregisterRequests;
+
+    // Empty out and close "fTCPStreamingDatabase":
+    streamingOverTCPRecord *sotcp;
+    while((sotcp = (streamingOverTCPRecord *)fTCPStreamingDatabase->getFirst()) != NULL) {
+        delete sotcp;
+    }
+    delete fTCPStreamingDatabase;
+}
+
+Boolean RTSPServer::isRTSPServer() const {
+    return True;
+}
+
+void RTSPServer::addServerMediaSession(ServerMediaSession *serverMediaSession) {
+    GenericMediaServer::addServerMediaSession(serverMediaSession);
+    if(serverMediaSession != NULL) {
+        serverMediaSession->streamingUsesSRTP    = fWeServeSRTP;
+        serverMediaSession->streamingIsEncrypted = fWeEncryptSRTP;
+    }
+}
+
+void RTSPServer::incomingConnectionHandlerHTTPIPv4(void *instance, int /*mask*/) {
+    RTSPServer *server = (RTSPServer *)instance;
+    server->incomingConnectionHandlerHTTPIPv4();
+}
+void RTSPServer::incomingConnectionHandlerHTTPIPv4() {
+    incomingConnectionHandlerOnSocket(fHTTPServerSocketIPv4);
+}
+void RTSPServer::incomingConnectionHandlerHTTPIPv6(void *instance, int /*mask*/) {
+    RTSPServer *server = (RTSPServer *)instance;
+    server->incomingConnectionHandlerHTTPIPv6();
+}
+void RTSPServer::incomingConnectionHandlerHTTPIPv6() {
+    incomingConnectionHandlerOnSocket(fHTTPServerSocketIPv6);
+}
+
+void RTSPServer ::noteTCPStreamingOnSocket(int socketNum, RTSPClientSession *clientSession, unsigned trackNum) {
+    streamingOverTCPRecord *sotcpCur = (streamingOverTCPRecord *)fTCPStreamingDatabase->Lookup((char const *)socketNum);
+    streamingOverTCPRecord *sotcpNew = new streamingOverTCPRecord(clientSession->fOurSessionId, trackNum, sotcpCur);
+    fTCPStreamingDatabase->Add((char const *)socketNum, sotcpNew);
+}
+
+void RTSPServer ::unnoteTCPStreamingOnSocket(int socketNum, RTSPClientSession *clientSession, unsigned trackNum) {
+    if(socketNum < 0)
+        return;
+    streamingOverTCPRecord *sotcpHead = (streamingOverTCPRecord *)fTCPStreamingDatabase->Lookup((char const *)socketNum);
+    if(sotcpHead == NULL)
+        return;
+
+    // Look for a record of the (session,track); remove it if found:
+    streamingOverTCPRecord *sotcp     = sotcpHead;
+    streamingOverTCPRecord *sotcpPrev = sotcpHead;
+    do {
+        if(sotcp->fSessionId == clientSession->fOurSessionId && sotcp->fTrackNum == trackNum)
+            break;
+        sotcpPrev = sotcp;
+        sotcp     = sotcp->fNext;
+    } while(sotcp != NULL);
+    if(sotcp == NULL)
+        return;  // not found
+
+    if(sotcp == sotcpHead) {
+        // We found it at the head of the list.  Remove it and reinsert the tail into the hash table:
+        sotcpHead    = sotcp->fNext;
+        sotcp->fNext = NULL;
+        delete sotcp;
+
+        if(sotcpHead == NULL) {
+            // There were no more entries on the list.  Remove the original entry from the hash table:
+            fTCPStreamingDatabase->Remove((char const *)socketNum);
+        }
+        else {
+            // Add the rest of the list into the hash table (replacing the original):
+            fTCPStreamingDatabase->Add((char const *)socketNum, sotcpHead);
+        }
+    }
+    else {
+        // We found it on the list, but not at the head.  Unlink it:
+        sotcpPrev->fNext = sotcp->fNext;
+        sotcp->fNext     = NULL;
+        delete sotcp;
+    }
+}
+
+void RTSPServer::stopTCPStreamingOnSocket(int socketNum) {
+    // Close any stream that is streaming over "socketNum" (using RTP/RTCP-over-TCP streaming):
+    streamingOverTCPRecord *sotcp = (streamingOverTCPRecord *)fTCPStreamingDatabase->Lookup((char const *)socketNum);
+    if(sotcp != NULL) {
+        do {
+            RTSPClientSession *clientSession = (RTSPServer::RTSPClientSession *)lookupClientSession(sotcp->fSessionId);
+            if(clientSession != NULL) {
+                clientSession->deleteStreamByTrack(sotcp->fTrackNum);
+            }
+
+            streamingOverTCPRecord *sotcpNext = sotcp->fNext;
+            sotcp->fNext                      = NULL;
+            delete sotcp;
+            sotcp = sotcpNext;
+        } while(sotcp != NULL);
+        fTCPStreamingDatabase->Remove((char const *)socketNum);
+    }
+}
+
+////////// RTSPServer::RTSPClientConnection implementation //////////
+
+RTSPServer::RTSPClientConnection ::RTSPClientConnection(RTSPServer &ourServer, int clientSocket, struct sockaddr_storage const &clientAddr, Boolean useTLS)
+    : GenericMediaServer::ClientConnection(ourServer, clientSocket, clientAddr, useTLS),
+      fOurRTSPServer(ourServer),
+      fClientInputSocket(fOurSocket),
+      fClientOutputSocket(fOurSocket),
+      fAddressFamily(clientAddr.ss_family),
+      fIsActive(True),
+      fRecursionCount(0),
+      fOurSessionCookie(NULL),
+      fScheduledDelayedTask(0) {
+    resetRequestBuffer();
+}
+
+RTSPServer::RTSPClientConnection::~RTSPClientConnection() {
+    if(fOurSessionCookie != NULL) {
+        // We were being used for RTSP-over-HTTP tunneling. Also remove ourselves from the 'session cookie' hash table before we go:
+        fOurRTSPServer.fClientConnectionsForHTTPTunneling->Remove(fOurSessionCookie);
+        delete[] fOurSessionCookie;
+    }
+
+    closeSocketsRTSP();
+}
+
+// Handler routines for specific RTSP commands:
+
+void RTSPServer::RTSPClientConnection::handleCmd_OPTIONS() {
+    snprintf((char *)fResponseBuffer, sizeof fResponseBuffer, "RTSP/1.0 200 OK\r\nCSeq: %s\r\n%sPublic: %s\r\n\r\n", fCurrentCSeq, dateHeader(),
+             fOurRTSPServer.allowedCommandNames());
+}
+
+void RTSPServer::RTSPClientConnection ::handleCmd_GET_PARAMETER(char const * /*fullRequestStr*/) {
+    // By default, we implement "GET_PARAMETER" (on the entire server) just as a 'no op', and send back a dummy response.
+    // (If you want to handle this type of "GET_PARAMETER" differently, you can do so by defining a subclass of "RTSPServer"
+    // and "RTSPServer::RTSPClientConnection", and then reimplement this virtual function in your subclass.)
+    setRTSPResponse("200 OK", LIVEMEDIA_LIBRARY_VERSION_STRING);
+}
+
+void RTSPServer::RTSPClientConnection ::handleCmd_SET_PARAMETER(char const * /*fullRequestStr*/) {
+    // By default, we implement "SET_PARAMETER" (on the entire server) just as a 'no op', and send back an empty response.
+    // (If you want to handle this type of "SET_PARAMETER" differently, you can do so by defining a subclass of "RTSPServer"
+    // and "RTSPServer::RTSPClientConnection", and then reimplement this virtual function in your subclass.)
+    setRTSPResponse("200 OK");
+}
+
+void RTSPServer::RTSPClientConnection ::handleCmd_DESCRIBE(char const *urlPreSuffix, char const *urlSuffix, char const *fullRequestStr) {
+    char urlTotalSuffix[2 * RTSP_PARAM_STRING_MAX];
+    // enough space for urlPreSuffix/urlSuffix'\0'
+    urlTotalSuffix[0] = '\0';
+    if(urlPreSuffix[0] != '\0') {
+        strcat(urlTotalSuffix, urlPreSuffix);
+        strcat(urlTotalSuffix, "/");
+    }
+    strcat(urlTotalSuffix, urlSuffix);
+
+    if(!authenticationOK("DESCRIBE", urlTotalSuffix, fullRequestStr))
+        return;
+
+    // We should really check that the request contains an "Accept:" #####
+    // for "application/sdp", because that's what we're sending back #####
+
+    // Begin by looking up the "ServerMediaSession" object for the specified "urlTotalSuffix":
+    fOurServer.lookupServerMediaSession(urlTotalSuffix, DESCRIBELookupCompletionFunction, this);
+}
+
+void RTSPServer::RTSPClientConnection ::DESCRIBELookupCompletionFunction(void *clientData, ServerMediaSession *sessionLookedUp) {
+    RTSPServer::RTSPClientConnection *connection = (RTSPServer::RTSPClientConnection *)clientData;
+    connection->handleCmd_DESCRIBE_afterLookup(sessionLookedUp);
+}
+
+void RTSPServer::RTSPClientConnection ::handleCmd_DESCRIBE_afterLookup(ServerMediaSession *session) {
+    char *sdpDescription = NULL;
+    char *rtspURL        = NULL;
+    do {
+        if(session == NULL) {
+            handleCmd_notFound();
+            break;
+        }
+
+        // Increment the "ServerMediaSession" object's reference count, in case someone removes it
+        // while we're using it:
+        session->incrementReferenceCount();
+
+        // Then, assemble a SDP description for this session:
+        sdpDescription = session->generateSDPDescription(fAddressFamily);
+        if(sdpDescription == NULL) {
+            // This usually means that a file name that was specified for a
+            // "ServerMediaSubsession" does not exist.
+            setRTSPResponse("404 File Not Found, Or In Incorrect Format");
+            break;
+        }
+        unsigned sdpDescriptionSize = strlen(sdpDescription);
+
+        // Also, generate our RTSP URL, for the "Content-Base:" header
+        // (which is necessary to ensure that the correct URL gets used in subsequent "SETUP" requests).
+        rtspURL = fOurRTSPServer.rtspURL(session, fClientInputSocket);
+
+        snprintf((char *)fResponseBuffer, sizeof fResponseBuffer,
+                 "RTSP/1.0 200 OK\r\nCSeq: %s\r\n"
+                 "%s"
+                 "Content-Base: %s/\r\n"
+                 "Content-Type: application/sdp\r\n"
+                 "Content-Length: %d\r\n\r\n"
+                 "%s",
+                 fCurrentCSeq, dateHeader(), rtspURL, sdpDescriptionSize, sdpDescription);
+    } while(0);
+
+    if(session != NULL) {
+        // Decrement its reference count, now that we're done using it:
+        session->decrementReferenceCount();
+        if(session->referenceCount() == 0 && session->deleteWhenUnreferenced()) {
+            fOurServer.removeServerMediaSession(session);
+        }
+    }
+
+    delete[] sdpDescription;
+    delete[] rtspURL;
+}
+
+static void lookForHeader(char const *headerName, char const *source, unsigned sourceLen, char *resultStr, unsigned resultMaxSize) {
+    resultStr[0]           = '\0';  // by default, return an empty string
+    unsigned headerNameLen = strlen(headerName);
+    for(int i = 0; i < (int)(sourceLen - headerNameLen); ++i) {
+        if(strncmp(&source[i], headerName, headerNameLen) == 0 && source[i + headerNameLen] == ':') {
+            // We found the header.  Skip over any whitespace, then copy the rest of the line to "resultStr":
+            for(i += headerNameLen + 1; i < (int)sourceLen && (source[i] == ' ' || source[i] == '\t'); ++i) {
+            }
+            for(unsigned j = i; j < sourceLen; ++j) {
+                if(source[j] == '\r' || source[j] == '\n') {
+                    // We've found the end of the line.  Copy it to the result (if it will fit):
+                    if(j - i + 1 > resultMaxSize)
+                        return;  // it wouldn't fit
+                    char const *resultSource    = &source[i];
+                    char const *resultSourceEnd = &source[j];
+                    while(resultSource < resultSourceEnd)
+                        *resultStr++ = *resultSource++;
+                    *resultStr = '\0';
+                    return;
+                }
+            }
+        }
+    }
+}
+
+void RTSPServer::RTSPClientConnection::handleCmd_bad() {
+    // Don't do anything with "fCurrentCSeq", because it might be nonsense
+    snprintf((char *)fResponseBuffer, sizeof fResponseBuffer, "RTSP/1.0 400 Bad Request\r\n%sAllow: %s\r\n\r\n", dateHeader(),
+             fOurRTSPServer.allowedCommandNames());
+}
+
+void RTSPServer::RTSPClientConnection::handleCmd_notSupported() {
+    snprintf((char *)fResponseBuffer, sizeof fResponseBuffer, "RTSP/1.0 405 Method Not Allowed\r\nCSeq: %s\r\n%sAllow: %s\r\n\r\n", fCurrentCSeq, dateHeader(),
+             fOurRTSPServer.allowedCommandNames());
+}
+
+void RTSPServer::RTSPClientConnection::handleCmd_redirect(char const *urlSuffix) {
+    snprintf((char *)fResponseBuffer, sizeof fResponseBuffer,
+             "RTSP/1.0 301 Moved Permanently\r\n"
+             "CSeq: %s\r\n"
+             "%s"
+             "Location: %s%s\r\n\r\n",
+             fCurrentCSeq, dateHeader(), fOurRTSPServer.rtspURLPrefix(fClientInputSocket), urlSuffix);
+}
+
+void RTSPServer::RTSPClientConnection::handleCmd_notFound() {
+    setRTSPResponse("404 Stream Not Found");
+}
+
+void RTSPServer::RTSPClientConnection::handleCmd_sessionNotFound() {
+    setRTSPResponse("454 Session Not Found");
+}
+
+void RTSPServer::RTSPClientConnection::handleCmd_unsupportedTransport() {
+    setRTSPResponse("461 Unsupported Transport");
+}
+
+Boolean RTSPServer::RTSPClientConnection::parseHTTPRequestString(char *resultCmdName, unsigned resultCmdNameMaxSize, char *urlSuffix, unsigned urlSuffixMaxSize,
+                                                                 char *sessionCookie, unsigned sessionCookieMaxSize, char *acceptStr,
+                                                                 unsigned acceptStrMaxSize) {
+    // Check for the limited HTTP requests that we expect for specifying RTSP-over-HTTP tunneling.
+    // This parser is currently rather dumb; it should be made smarter #####
+    char const *   reqStr     = (char const *)fRequestBuffer;
+    unsigned const reqStrSize = fRequestBytesAlreadySeen;
+
+    // Read everything up to the first space as the command name:
+    Boolean  parseSucceeded = False;
+    unsigned i;
+    for(i = 0; i < resultCmdNameMaxSize - 1 && i < reqStrSize; ++i) {
+        char c = reqStr[i];
+        if(c == ' ' || c == '\t') {
+            parseSucceeded = True;
+            break;
+        }
+
+        resultCmdName[i] = c;
+    }
+    resultCmdName[i] = '\0';
+    if(!parseSucceeded)
+        return False;
+
+    // Look for the string "HTTP/", before the first \r or \n:
+    parseSucceeded = False;
+    for(; i < reqStrSize - 5 && reqStr[i] != '\r' && reqStr[i] != '\n'; ++i) {
+        if(reqStr[i] == 'H' && reqStr[i + 1] == 'T' && reqStr[i + 2] == 'T' && reqStr[i + 3] == 'P' && reqStr[i + 4] == '/') {
+            i += 5;  // to advance past the "HTTP/"
+            parseSucceeded = True;
+            break;
+        }
+    }
+    if(!parseSucceeded)
+        return False;
+
+    // Get the 'URL suffix' that occurred before this:
+    unsigned k = i - 6;
+    while(k > 0 && reqStr[k] == ' ')
+        --k;  // back up over white space
+    unsigned j = k;
+    while(j > 0 && reqStr[j] != ' ' && reqStr[j] != '/')
+        --j;
+    // The URL suffix is in position (j,k]:
+    if(k - j + 1 > urlSuffixMaxSize)
+        return False;  // there's no room>
+    unsigned n = 0;
+    while(++j <= k)
+        urlSuffix[n++] = reqStr[j];
+    urlSuffix[n] = '\0';
+
+    // Look for various headers that we're interested in:
+    lookForHeader("x-sessioncookie", &reqStr[i], reqStrSize - i, sessionCookie, sessionCookieMaxSize);
+    lookForHeader("Accept", &reqStr[i], reqStrSize - i, acceptStr, acceptStrMaxSize);
+
+    return True;
+}
+
+void RTSPServer::RTSPClientConnection::handleHTTPCmd_notSupported() {
+    snprintf((char *)fResponseBuffer, sizeof fResponseBuffer, "HTTP/1.0 405 Method Not Allowed\r\n%s\r\n\r\n", dateHeader());
+}
+
+void RTSPServer::RTSPClientConnection::handleHTTPCmd_notFound() {
+    snprintf((char *)fResponseBuffer, sizeof fResponseBuffer, "HTTP/1.0 404 Not Found\r\n%s\r\n\r\n", dateHeader());
+}
+
+void RTSPServer::RTSPClientConnection::handleHTTPCmd_OPTIONS() {
+#ifdef DEBUG
+    fprintf(stderr, "Handled HTTP \"OPTIONS\" request\n");
+#endif
+    // Construct a response to the "OPTIONS" command that notes that our special headers (for RTSP-over-HTTP tunneling) are allowed:
+    snprintf((char *)fResponseBuffer, sizeof fResponseBuffer,
+             "HTTP/1.0 200 OK\r\n"
+             "%s"
+             "Access-Control-Allow-Origin: *\r\n"
+             "Access-Control-Allow-Methods: POST, GET, OPTIONS\r\n"
+             "Access-Control-Allow-Headers: x-sessioncookie, Pragma, Cache-Control\r\n"
+             "Access-Control-Max-Age: 1728000\r\n"
+             "\r\n",
+             dateHeader());
+}
+
+void RTSPServer::RTSPClientConnection::handleHTTPCmd_TunnelingGET(char const *sessionCookie) {
+    // Record ourself as having this 'session cookie', so that a subsequent HTTP "POST" command (with the same 'session cookie')
+    // can find us:
+    if(fOurRTSPServer.fClientConnectionsForHTTPTunneling == NULL) {
+        fOurRTSPServer.fClientConnectionsForHTTPTunneling = HashTable::create(STRING_HASH_KEYS);
+    }
+    delete[] fOurSessionCookie;
+    fOurSessionCookie = strDup(sessionCookie);
+    fOurRTSPServer.fClientConnectionsForHTTPTunneling->Add(sessionCookie, (void *)this);
+#ifdef DEBUG
+    fprintf(stderr, "Handled HTTP \"GET\" request (client output socket: %d)\n", fClientOutputSocket);
+#endif
+
+    // Construct our response:
+    snprintf((char *)fResponseBuffer, sizeof fResponseBuffer,
+             "HTTP/1.0 200 OK\r\n"
+             "%s"
+             "Cache-Control: no-cache\r\n"
+             "Pragma: no-cache\r\n"
+             "Content-Type: application/x-rtsp-tunnelled\r\n"
+             "\r\n",
+             dateHeader());
+}
+
+Boolean RTSPServer::RTSPClientConnection ::handleHTTPCmd_TunnelingPOST(char const *sessionCookie, unsigned char const *extraData, unsigned extraDataSize) {
+    // Use the "sessionCookie" string to look up the separate "RTSPClientConnection" object that should have been used to handle
+    // an earlier HTTP "GET" request:
+    if(fOurRTSPServer.fClientConnectionsForHTTPTunneling == NULL) {
+        fOurRTSPServer.fClientConnectionsForHTTPTunneling = HashTable::create(STRING_HASH_KEYS);
+    }
+    RTSPServer::RTSPClientConnection *prevClientConnection =
+        (RTSPServer::RTSPClientConnection *)(fOurRTSPServer.fClientConnectionsForHTTPTunneling->Lookup(sessionCookie));
+    if(prevClientConnection == NULL || prevClientConnection == this) {
+        // Either there was no previous HTTP "GET" request, or it was on the same connection; treat this "POST" request as bad:
+        handleHTTPCmd_notSupported();
+        fIsActive = False;  // triggers deletion of ourself
+        return False;
+    }
+#ifdef DEBUG
+    fprintf(stderr, "Handled HTTP \"POST\" request (client input socket: %d)\n", fClientInputSocket);
+#endif
+
+    // Change the previous "RTSPClientSession" object's input socket to ours.  It will be used for subsequent requests:
+    prevClientConnection->changeClientInputSocket(fClientInputSocket, extraData, extraDataSize);
+    fClientInputSocket = fClientOutputSocket = -1;  // so the socket doesn't get closed when we get deleted
+    return True;
+}
+
+void RTSPServer::RTSPClientConnection::handleHTTPCmd_StreamingGET(char const * /*urlSuffix*/, char const * /*fullRequestStr*/) {
+    // By default, we don't support requests to access streams via HTTP:
+    handleHTTPCmd_notSupported();
+}
+
+void RTSPServer::RTSPClientConnection::resetRequestBuffer() {
+    ClientConnection::resetRequestBuffer();
+
+    fLastCRLF             = &fRequestBuffer[-3];  // hack: Ensures that we don't think we have end-of-msg if the data starts with <CR><LF>
+    fBase64RemainderCount = 0;
+}
+
+void RTSPServer::RTSPClientConnection::closeSocketsRTSP() {
+    // First, tell our server to stop any streaming that it might be doing over our output socket:
+    fOurRTSPServer.stopTCPStreamingOnSocket(fClientOutputSocket);
+
+    // Turn off background handling on our input socket (and output socket, if different); then close it (or them):
+    if(fClientOutputSocket != fClientInputSocket) {
+        envir().taskScheduler().disableBackgroundHandling(fClientOutputSocket);
+        ::closeSocket(fClientOutputSocket);
+    }
+    fClientOutputSocket = -1;
+
+    closeSockets();  // closes fClientInputSocket
+}
+
+void RTSPServer::RTSPClientConnection::handleAlternativeRequestByte(void *instance, u_int8_t requestByte) {
+    RTSPClientConnection *connection = (RTSPClientConnection *)instance;
+    connection->handleAlternativeRequestByte1(requestByte);
+}
+
+void RTSPServer::RTSPClientConnection::handleAlternativeRequestByte1(u_int8_t requestByte) {
+    if(requestByte == 0xFF) {
+        // Hack: The new handler of the input TCP socket encountered an error reading it.  Indicate this:
+        handleRequestBytes(-1);
+    }
+    else if(requestByte == 0xFE) {
+        // Another hack: The new handler of the input TCP socket no longer needs it, so take back control of it:
+        envir().taskScheduler().setBackgroundHandling(fClientInputSocket, SOCKET_READABLE | SOCKET_EXCEPTION, incomingRequestHandler, this);
+    }
+    else {
+        // Normal case: Add this character to our buffer; then try to handle the data that we have buffered so far:
+        if(fRequestBufferBytesLeft == 0 || fRequestBytesAlreadySeen >= REQUEST_BUFFER_SIZE)
+            return;
+        fRequestBuffer[fRequestBytesAlreadySeen] = requestByte;
+        handleRequestBytes(1);
+    }
+}
+
+void RTSPServer::RTSPClientConnection::handleRequestBytes(int newBytesRead) {
+    int numBytesRemaining = 0;
+    ++fRecursionCount;
+
+    do {
+        RTSPServer::RTSPClientSession *clientSession = NULL;
+
+        if(newBytesRead < 0 || (unsigned)newBytesRead >= fRequestBufferBytesLeft) {
+            // Either the client socket has died, or the request was too big for us.
+            // Terminate this connection:
+#ifdef DEBUG
+            fprintf(stderr, "RTSPClientConnection[%p]::handleRequestBytes() read %d new bytes (of %d); terminating connection!\n", this, newBytesRead,
+                    fRequestBufferBytesLeft);
+#endif
+            fIsActive = False;
+            break;
+        }
+
+        Boolean        endOfMsg = False;
+        unsigned char *ptr      = &fRequestBuffer[fRequestBytesAlreadySeen];
+#ifdef DEBUG
+        ptr[newBytesRead] = '\0';
+        fprintf(stderr, "RTSPClientConnection[%p]::handleRequestBytes() %s %d new bytes:%s\n", this, numBytesRemaining > 0 ? "processing" : "read",
+                newBytesRead, ptr);
+#endif
+
+        if(fClientOutputSocket != fClientInputSocket && numBytesRemaining == 0) {
+            // We're doing RTSP-over-HTTP tunneling, and input commands are assumed to have been Base64-encoded.
+            // We therefore Base64-decode as much of this new data as we can (i.e., up to a multiple of 4 bytes).
+
+            // But first, we remove any whitespace that may be in the input data:
+            unsigned toIndex = 0;
+            for(int fromIndex = 0; fromIndex < newBytesRead; ++fromIndex) {
+                char c = ptr[fromIndex];
+                if(!(c == ' ' || c == '\t' || c == '\r' || c == '\n')) {  // not 'whitespace': space,tab,CR,NL
+                    ptr[toIndex++] = c;
+                }
+            }
+            newBytesRead = toIndex;
+
+            unsigned numBytesToDecode        = fBase64RemainderCount + newBytesRead;
+            unsigned newBase64RemainderCount = numBytesToDecode % 4;
+            numBytesToDecode -= newBase64RemainderCount;
+            if(numBytesToDecode > 0) {
+                ptr[newBytesRead] = '\0';
+                unsigned       decodedSize;
+                unsigned char *decodedBytes = base64Decode((char const *)(ptr - fBase64RemainderCount), numBytesToDecode, decodedSize);
+#ifdef DEBUG
+                fprintf(stderr, "Base64-decoded %d input bytes into %d new bytes:", numBytesToDecode, decodedSize);
+                for(unsigned k = 0; k < decodedSize; ++k)
+                    fprintf(stderr, "%c", decodedBytes[k]);
+                fprintf(stderr, "\n");
+#endif
+
+                // Copy the new decoded bytes in place of the old ones (we can do this because there are fewer decoded bytes than original):
+                unsigned char *to = ptr - fBase64RemainderCount;
+                for(unsigned i = 0; i < decodedSize; ++i)
+                    *to++ = decodedBytes[i];
+
+                // Then copy any remaining (undecoded) bytes to the end:
+                for(unsigned j = 0; j < newBase64RemainderCount; ++j)
+                    *to++ = (ptr - fBase64RemainderCount + numBytesToDecode)[j];
+
+                newBytesRead = decodedSize - fBase64RemainderCount + newBase64RemainderCount;
+                // adjust to allow for the size of the new decoded data (+ remainder)
+                delete[] decodedBytes;
+            }
+            fBase64RemainderCount = newBase64RemainderCount;
+        }
+
+        unsigned char *tmpPtr = fLastCRLF + 2;
+        if(fBase64RemainderCount == 0) {  // no more Base-64 bytes remain to be read/decoded
+            // Look for the end of the message: <CR><LF><CR><LF>
+            if(tmpPtr < fRequestBuffer)
+                tmpPtr = fRequestBuffer;
+            while(tmpPtr < &ptr[newBytesRead - 1]) {
+                if(*tmpPtr == '\r' && *(tmpPtr + 1) == '\n') {
+                    if(tmpPtr - fLastCRLF == 2) {  // This is it:
+                        endOfMsg = True;
+                        break;
+                    }
+                    fLastCRLF = tmpPtr;
+                }
+                ++tmpPtr;
+            }
+        }
+
+        fRequestBufferBytesLeft -= newBytesRead;
+        fRequestBytesAlreadySeen += newBytesRead;
+
+        if(!endOfMsg)
+            break;  // subsequent reads will be needed to complete the request
+
+        // Parse the request string into command name and 'CSeq', then handle the command:
+        fRequestBuffer[fRequestBytesAlreadySeen] = '\0';
+        char     cmdName[RTSP_PARAM_STRING_MAX];
+        char     urlPreSuffix[RTSP_PARAM_STRING_MAX];
+        char     urlSuffix[RTSP_PARAM_STRING_MAX];
+        char     cseq[RTSP_PARAM_STRING_MAX];
+        char     sessionIdStr[RTSP_PARAM_STRING_MAX];
+        unsigned contentLength = 0;
+        Boolean  urlIsRTSPS;
+        Boolean  playAfterSetup = False;
+        fLastCRLF[2]            = '\0';  // temporarily, for parsing
+        Boolean parseSucceeded =
+            parseRTSPRequestString((char *)fRequestBuffer, fLastCRLF + 2 - fRequestBuffer, cmdName, sizeof cmdName, urlPreSuffix, sizeof urlPreSuffix,
+                                   urlSuffix, sizeof urlSuffix, cseq, sizeof cseq, sessionIdStr, sizeof sessionIdStr, contentLength, urlIsRTSPS);
+        fLastCRLF[2] = '\r';  // restore its value
+        // Check first for a bogus "Content-Length" value that would cause a pointer wraparound:
+        if(tmpPtr + 2 + contentLength < tmpPtr + 2) {
+#ifdef DEBUG
+            fprintf(stderr, "parseRTSPRequestString() returned a bogus \"Content-Length:\" value: 0x%x (%d)\n", contentLength, (int)contentLength);
+#endif
+            contentLength  = 0;
+            parseSucceeded = False;
+        }
+        if(parseSucceeded) {
+#ifdef DEBUG
+            fprintf(stderr,
+                    "parseRTSPRequestString() succeeded, returning cmdName \"%s\", urlPreSuffix \"%s\", urlSuffix \"%s\", CSeq \"%s\", Content-Length %u, with "
+                    "%d bytes following the message.\n",
+                    cmdName, urlPreSuffix, urlSuffix, cseq, contentLength, ptr + newBytesRead - (tmpPtr + 2));
+#endif
+            // If there was a "Content-Length:" header, then make sure we've received all of the data that it specified:
+            if(ptr + newBytesRead < tmpPtr + 2 + contentLength)
+                break;  // we still need more data; subsequent reads will give it to us
+
+            // If the request included a "Session:" id, and it refers to a client session that's
+            // current ongoing, then use this command to indicate 'liveness' on that client session:
+            Boolean const requestIncludedSessionId = sessionIdStr[0] != '\0';
+            if(requestIncludedSessionId) {
+                clientSession = (RTSPServer::RTSPClientSession *)(fOurRTSPServer.lookupClientSession(sessionIdStr));
+                if(clientSession != NULL)
+                    clientSession->noteLiveness();
+            }
+
+            // We now have a complete RTSP request.
+            // Handle the specified command (beginning with commands that are session-independent):
+            fCurrentCSeq = cseq;
+
+            // If the request specified the wrong type of URL
+            // (i.e., "rtsps" instead of "rtsp", or vice versa), then send back a 'redirect':
+            if(urlIsRTSPS != fOurRTSPServer.fWeServeSRTP) {
+#ifdef DEBUG
+                fprintf(stderr, "Calling handleCmd_redirect()\n");
+#endif
+                handleCmd_redirect(urlSuffix);
+            }
+            else if(strcmp(cmdName, "OPTIONS") == 0) {
+                // If the "OPTIONS" command included a "Session:" id for a session that doesn't exist,
+                // then treat this as an error:
+                if(requestIncludedSessionId && clientSession == NULL) {
+#ifdef DEBUG
+                    fprintf(stderr, "Calling handleCmd_sessionNotFound() (case 1)\n");
+#endif
+                    handleCmd_sessionNotFound();
+                }
+                else {
+                    // Normal case:
+                    handleCmd_OPTIONS();
+                }
+            }
+            else if(urlPreSuffix[0] == '\0' && urlSuffix[0] == '*' && urlSuffix[1] == '\0') {
+                // The special "*" URL means: an operation on the entire server.  This works only for GET_PARAMETER and SET_PARAMETER:
+                if(strcmp(cmdName, "GET_PARAMETER") == 0) {
+                    handleCmd_GET_PARAMETER((char const *)fRequestBuffer);
+                }
+                else if(strcmp(cmdName, "SET_PARAMETER") == 0) {
+                    handleCmd_SET_PARAMETER((char const *)fRequestBuffer);
+                }
+                else {
+                    handleCmd_notSupported();
+                }
+            }
+            else if(strcmp(cmdName, "DESCRIBE") == 0) {
+                handleCmd_DESCRIBE(urlPreSuffix, urlSuffix, (char const *)fRequestBuffer);
+            }
+            else if(strcmp(cmdName, "SETUP") == 0) {
+                Boolean areAuthenticated = True;
+
+                if(!requestIncludedSessionId) {
+                    // No session id was present in the request.
+                    // So create a new "RTSPClientSession" object for this request.
+
+                    // But first, make sure that we're authenticated to perform this command:
+                    char urlTotalSuffix[2 * RTSP_PARAM_STRING_MAX];
+                    // enough space for urlPreSuffix/urlSuffix'\0'
+                    urlTotalSuffix[0] = '\0';
+                    if(urlPreSuffix[0] != '\0') {
+                        strcat(urlTotalSuffix, urlPreSuffix);
+                        strcat(urlTotalSuffix, "/");
+                    }
+                    strcat(urlTotalSuffix, urlSuffix);
+                    if(authenticationOK("SETUP", urlTotalSuffix, (char const *)fRequestBuffer)) {
+                        clientSession = (RTSPServer::RTSPClientSession *)fOurRTSPServer.createNewClientSessionWithId();
+                    }
+                    else {
+                        areAuthenticated = False;
+                    }
+                }
+                if(clientSession != NULL) {
+                    clientSession->handleCmd_SETUP(this, urlPreSuffix, urlSuffix, (char const *)fRequestBuffer);
+                    playAfterSetup = clientSession->fStreamAfterSETUP;
+                }
+                else if(areAuthenticated) {
+#ifdef DEBUG
+                    fprintf(stderr, "Calling handleCmd_sessionNotFound() (case 2)\n");
+#endif
+                    handleCmd_sessionNotFound();
+                }
+            }
+            else if(strcmp(cmdName, "TEARDOWN") == 0 || strcmp(cmdName, "PLAY") == 0 || strcmp(cmdName, "PAUSE") == 0 || strcmp(cmdName, "GET_PARAMETER") == 0
+                    || strcmp(cmdName, "SET_PARAMETER") == 0) {
+                if(clientSession != NULL) {
+                    clientSession->handleCmd_withinSession(this, cmdName, urlPreSuffix, urlSuffix, (char const *)fRequestBuffer);
+                }
+                else {
+#ifdef DEBUG
+                    fprintf(stderr, "Calling handleCmd_sessionNotFound() (case 3)\n");
+#endif
+                    handleCmd_sessionNotFound();
+                }
+            }
+            else if(strcmp(cmdName, "REGISTER") == 0 || strcmp(cmdName, "DEREGISTER") == 0) {
+                // Because - unlike other commands - an implementation of this command needs
+                // the entire URL, we re-parse the command to get it:
+                char *url = strDupSize((char *)fRequestBuffer);
+                if(sscanf((char *)fRequestBuffer, "%*s %s", url) == 1) {
+                    // Check for special command-specific parameters in a "Transport:" header:
+                    Boolean reuseConnection, deliverViaTCP;
+                    char *  proxyURLSuffix;
+                    parseTransportHeaderForREGISTER((const char *)fRequestBuffer, reuseConnection, deliverViaTCP, proxyURLSuffix);
+
+                    handleCmd_REGISTER(cmdName, url, urlSuffix, (char const *)fRequestBuffer, reuseConnection, deliverViaTCP, proxyURLSuffix);
+                    delete[] proxyURLSuffix;
+                }
+                else {
+                    handleCmd_bad();
+                }
+                delete[] url;
+            }
+            else {
+                // The command is one that we don't handle:
+                handleCmd_notSupported();
+            }
+        }
+        else {
+#ifdef DEBUG
+            fprintf(stderr, "parseRTSPRequestString() failed; checking now for HTTP commands (for RTSP-over-HTTP tunneling)...\n");
+#endif
+            // The request was not (valid) RTSP, but check for a special case: HTTP commands (for setting up RTSP-over-HTTP tunneling):
+            char sessionCookie[RTSP_PARAM_STRING_MAX];
+            char acceptStr[RTSP_PARAM_STRING_MAX];
+            *fLastCRLF     = '\0';  // temporarily, for parsing
+            parseSucceeded = parseHTTPRequestString(cmdName, sizeof cmdName, urlSuffix, sizeof urlPreSuffix, sessionCookie, sizeof sessionCookie, acceptStr,
+                                                    sizeof acceptStr);
+            *fLastCRLF     = '\r';
+            if(parseSucceeded) {
+#ifdef DEBUG
+                fprintf(stderr, "parseHTTPRequestString() succeeded, returning cmdName \"%s\", urlSuffix \"%s\", sessionCookie \"%s\", acceptStr \"%s\"\n",
+                        cmdName, urlSuffix, sessionCookie, acceptStr);
+#endif
+                // Check that the HTTP command is valid for RTSP-over-HTTP tunneling: There must be a 'session cookie'.
+                Boolean isValidHTTPCmd = True;
+                if(strcmp(cmdName, "OPTIONS") == 0) {
+                    handleHTTPCmd_OPTIONS();
+                }
+                else if(sessionCookie[0] == '\0') {
+                    // There was no "x-sessioncookie:" header.  If there was an "Accept: application/x-rtsp-tunnelled" header,
+                    // then this is a bad tunneling request.  Otherwise, assume that it's an attempt to access the stream via HTTP.
+                    if(strcmp(acceptStr, "application/x-rtsp-tunnelled") == 0) {
+                        isValidHTTPCmd = False;
+                    }
+                    else {
+                        handleHTTPCmd_StreamingGET(urlSuffix, (char const *)fRequestBuffer);
+                    }
+                }
+                else if(strcmp(cmdName, "GET") == 0) {
+                    handleHTTPCmd_TunnelingGET(sessionCookie);
+                }
+                else if(strcmp(cmdName, "POST") == 0) {
+                    // We might have received additional data following the HTTP "POST" command - i.e., the first Base64-encoded RTSP command.
+                    // Check for this, and handle it if it exists:
+                    unsigned char const *extraData     = fLastCRLF + 4;
+                    unsigned             extraDataSize = &fRequestBuffer[fRequestBytesAlreadySeen] - extraData;
+                    if(handleHTTPCmd_TunnelingPOST(sessionCookie, extraData, extraDataSize)) {
+                        // We don't respond to the "POST" command, and we go away:
+                        fIsActive = False;
+                        break;
+                    }
+                }
+                else {
+                    isValidHTTPCmd = False;
+                }
+                if(!isValidHTTPCmd) {
+                    handleHTTPCmd_notSupported();
+                }
+            }
+            else {
+#ifdef DEBUG
+                fprintf(stderr, "parseHTTPRequestString() failed!\n");
+#endif
+                handleCmd_bad();
+            }
+        }
+
+#ifdef DEBUG
+        fprintf(stderr, "sending response: %s", fResponseBuffer);
+#endif
+        unsigned const numBytesToWrite = strlen((char *)fResponseBuffer);
+        if(fTLS.isNeeded) {
+            fTLS.write((char const *)fResponseBuffer, numBytesToWrite);
+        }
+        else {
+            send(fClientOutputSocket, (char const *)fResponseBuffer, numBytesToWrite, 0);
+        }
+
+        if(playAfterSetup) {
+            // The client has asked for streaming to commence now, rather than after a
+            // subsequent "PLAY" command.  So, simulate the effect of a "PLAY" command:
+            clientSession->handleCmd_withinSession(this, "PLAY", urlPreSuffix, urlSuffix, (char const *)fRequestBuffer);
+        }
+
+        // Check whether there are extra bytes remaining in the buffer, after the end of the request (a rare case).
+        // If so, move them to the front of our buffer, and keep processing it, because it might be a following, pipelined request.
+        unsigned requestSize = (fLastCRLF + 4 - fRequestBuffer) + contentLength;
+        numBytesRemaining    = fRequestBytesAlreadySeen - requestSize;
+        resetRequestBuffer();  // to prepare for any subsequent request
+
+        if(numBytesRemaining > 0) {
+            memmove(fRequestBuffer, &fRequestBuffer[requestSize], numBytesRemaining);
+            newBytesRead = numBytesRemaining;
+        }
+    } while(numBytesRemaining > 0);
+
+    --fRecursionCount;
+    // If it has a scheduledDelayedTask, don't delete the instance or close the sockets. The sockets can be reused in the task.
+    if(!fIsActive && fScheduledDelayedTask <= 0) {
+        if(fRecursionCount > 0)
+            closeSockets();
+        else
+            delete this;
+        // Note: The "fRecursionCount" test is for a pathological situation where we reenter the event loop and get called recursively
+        // while handling a command (e.g., while handling a "DESCRIBE", to get a SDP description).
+        // In such a case we don't want to actually delete ourself until we leave the outermost call.
+    }
+}
+
+#define SKIP_WHITESPACE                                           \
+    while(*fields != '\0' && (*fields == ' ' || *fields == '\t')) \
+    ++fields
+
+static Boolean parseAuthorizationHeader(char const *buf, char const *&username, char const *&realm, char const *&nonce, char const *&uri,
+                                        char const *&response) {
+    // Initialize the result parameters to default values:
+    username = realm = nonce = uri = response = NULL;
+
+    // First, find "Authorization:"
+    while(1) {
+        if(*buf == '\0')
+            return False;  // not found
+        if(_strncasecmp(buf, "Authorization: Digest ", 22) == 0)
+            break;
+        ++buf;
+    }
+
+    // Then, run through each of the fields, looking for ones we handle:
+    char const *fields    = buf + 22;
+    char *      parameter = strDupSize(fields);
+    char *      value     = strDupSize(fields);
+    char *      p;
+    Boolean     success;
+    do {
+        // Parse: <parameter>="<value>"
+        success      = False;
+        parameter[0] = value[0] = '\0';
+        SKIP_WHITESPACE;
+        for(p = parameter; *fields != '\0' && *fields != ' ' && *fields != '\t' && *fields != '=';)
+            *p++ = *fields++;
+        SKIP_WHITESPACE;
+        if(*fields++ != '=')
+            break;  // parsing failed
+        *p = '\0';  // complete parsing <parameter>
+        SKIP_WHITESPACE;
+        if(*fields++ != '"')
+            break;  // parsing failed
+        for(p = value; *fields != '\0' && *fields != '"';)
+            *p++ = *fields++;
+        if(*fields++ != '"')
+            break;  // parsing failed
+        *p = '\0';  // complete parsing <value>
+        SKIP_WHITESPACE;
+        success = True;
+
+        // Copy values for parameters that we understand:
+        if(strcmp(parameter, "username") == 0) {
+            username = strDup(value);
+        }
+        else if(strcmp(parameter, "realm") == 0) {
+            realm = strDup(value);
+        }
+        else if(strcmp(parameter, "nonce") == 0) {
+            nonce = strDup(value);
+        }
+        else if(strcmp(parameter, "uri") == 0) {
+            uri = strDup(value);
+        }
+        else if(strcmp(parameter, "response") == 0) {
+            response = strDup(value);
+        }
+
+        // Check for a ',', indicating that more <parameter>="<value>" pairs follow:
+    } while(*fields++ == ',');
+
+    delete[] parameter;
+    delete[] value;
+    return success;
+}
+
+Boolean RTSPServer::RTSPClientConnection ::authenticationOK(char const *cmdName, char const *urlSuffix, char const *fullRequestStr) {
+    if(!fOurRTSPServer.specialClientAccessCheck(fClientInputSocket, fClientAddr, urlSuffix)) {
+        setRTSPResponse("401 Unauthorized");
+        return False;
+    }
+
+    // If we weren't set up with an authentication database, we're OK:
+    UserAuthenticationDatabase *authDB = fOurRTSPServer.getAuthenticationDatabaseForCommand(cmdName);
+    if(authDB == NULL)
+        return True;
+
+    char const *username = NULL;
+    char const *realm    = NULL;
+    char const *nonce    = NULL;
+    char const *uri      = NULL;
+    char const *response = NULL;
+    Boolean     success  = False;
+
+    do {
+        // To authenticate, we first need to have a nonce set up
+        // from a previous attempt:
+        if(fCurrentAuthenticator.nonce() == NULL)
+            break;
+
+        // Next, the request needs to contain an "Authorization:" header,
+        // containing a username, (our) realm, (our) nonce, uri,
+        // and response string:
+        if(!parseAuthorizationHeader(fullRequestStr, username, realm, nonce, uri, response) || username == NULL || realm == NULL
+           || strcmp(realm, fCurrentAuthenticator.realm()) != 0 || nonce == NULL || strcmp(nonce, fCurrentAuthenticator.nonce()) != 0 || uri == NULL
+           || response == NULL) {
+            break;
+        }
+
+        // Next, the username has to be known to us:
+        char const *password = authDB->lookupPassword(username);
+#ifdef DEBUG
+        fprintf(stderr, "lookupPassword(%s) returned password %s\n", username, password);
+#endif
+        if(password == NULL)
+            break;
+        fCurrentAuthenticator.setUsernameAndPassword(username, password, authDB->passwordsAreMD5());
+
+        // Finally, compute a digest response from the information that we have,
+        // and compare it to the one that we were given:
+        char const *ourResponse = fCurrentAuthenticator.computeDigestResponse(cmdName, uri);
+        success                 = (strcmp(ourResponse, response) == 0);
+        fCurrentAuthenticator.reclaimDigestResponse(ourResponse);
+    } while(0);
+
+    delete[](char *) realm;
+    delete[](char *) nonce;
+    delete[](char *) uri;
+    delete[](char *) response;
+
+    if(success) {
+        // The user has been authenticated.
+        // Now allow subclasses a chance to validate the user against the IP address and/or URL suffix.
+        if(!fOurRTSPServer.specialClientUserAccessCheck(fClientInputSocket, fClientAddr, urlSuffix, username)) {
+            // Note: We don't return a "WWW-Authenticate" header here, because the user is valid,
+            // even though the server has decided that they should not have access.
+            setRTSPResponse("401 Unauthorized");
+            delete[](char *) username;
+            return False;
+        }
+    }
+    delete[](char *) username;
+    if(success)
+        return True;
+
+    // If we get here, we failed to authenticate the user.
+    // Send back a "401 Unauthorized" response, with a new random nonce:
+    fCurrentAuthenticator.setRealmAndRandomNonce(authDB->realm());
+    snprintf((char *)fResponseBuffer, sizeof fResponseBuffer,
+             "RTSP/1.0 401 Unauthorized\r\n"
+             "CSeq: %s\r\n"
+             "%s"
+             "WWW-Authenticate: Digest realm=\"%s\", nonce=\"%s\"\r\n\r\n",
+             fCurrentCSeq, dateHeader(), fCurrentAuthenticator.realm(), fCurrentAuthenticator.nonce());
+    return False;
+}
+
+void RTSPServer::RTSPClientConnection ::setRTSPResponse(char const *responseStr) {
+    snprintf((char *)fResponseBuffer, sizeof fResponseBuffer,
+             "RTSP/1.0 %s\r\n"
+             "CSeq: %s\r\n"
+             "%s\r\n",
+             responseStr, fCurrentCSeq, dateHeader());
+}
+
+void RTSPServer::RTSPClientConnection ::setRTSPResponse(char const *responseStr, u_int32_t sessionId) {
+    snprintf((char *)fResponseBuffer, sizeof fResponseBuffer,
+             "RTSP/1.0 %s\r\n"
+             "CSeq: %s\r\n"
+             "%s"
+             "Session: %08X\r\n\r\n",
+             responseStr, fCurrentCSeq, dateHeader(), sessionId);
+}
+
+void RTSPServer::RTSPClientConnection ::setRTSPResponse(char const *responseStr, char const *contentStr) {
+    if(contentStr == NULL)
+        contentStr = "";
+    unsigned const contentLen = strlen(contentStr);
+
+    snprintf((char *)fResponseBuffer, sizeof fResponseBuffer,
+             "RTSP/1.0 %s\r\n"
+             "CSeq: %s\r\n"
+             "%s"
+             "Content-Length: %d\r\n\r\n"
+             "%s",
+             responseStr, fCurrentCSeq, dateHeader(), contentLen, contentStr);
+}
+
+void RTSPServer::RTSPClientConnection ::setRTSPResponse(char const *responseStr, u_int32_t sessionId, char const *contentStr) {
+    if(contentStr == NULL)
+        contentStr = "";
+    unsigned const contentLen = strlen(contentStr);
+
+    snprintf((char *)fResponseBuffer, sizeof fResponseBuffer,
+             "RTSP/1.0 %s\r\n"
+             "CSeq: %s\r\n"
+             "%s"
+             "Session: %08X\r\n"
+             "Content-Length: %d\r\n\r\n"
+             "%s",
+             responseStr, fCurrentCSeq, dateHeader(), sessionId, contentLen, contentStr);
+}
+
+void RTSPServer::RTSPClientConnection ::changeClientInputSocket(int newSocketNum, unsigned char const *extraData, unsigned extraDataSize) {
+    envir().taskScheduler().disableBackgroundHandling(fClientInputSocket);
+    fClientInputSocket = newSocketNum;
+    envir().taskScheduler().setBackgroundHandling(fClientInputSocket, SOCKET_READABLE | SOCKET_EXCEPTION, incomingRequestHandler, this);
+
+    // Also write any extra data to our buffer, and handle it:
+    if(extraDataSize > 0 && extraDataSize <= fRequestBufferBytesLeft /*sanity check; should always be true*/) {
+        unsigned char *ptr = &fRequestBuffer[fRequestBytesAlreadySeen];
+        for(unsigned i = 0; i < extraDataSize; ++i) {
+            ptr[i] = extraData[i];
+        }
+        handleRequestBytes(extraDataSize);
+    }
+}
+
+////////// RTSPServer::RTSPClientSession implementation //////////
+
+RTSPServer::RTSPClientSession ::RTSPClientSession(RTSPServer &ourServer, u_int32_t sessionId)
+    : GenericMediaServer::ClientSession(ourServer, sessionId),
+      fOurRTSPServer(ourServer),
+      fIsMulticast(False),
+      fStreamAfterSETUP(False),
+      fTCPStreamIdCount(0),
+      fNumStreamStates(0),
+      fStreamStates(NULL) {}
+
+RTSPServer::RTSPClientSession::~RTSPClientSession() {
+    reclaimStreamStates();
+}
+
+void RTSPServer::RTSPClientSession::deleteStreamByTrack(unsigned trackNum) {
+    if(trackNum >= fNumStreamStates)
+        return;  // sanity check; shouldn't happen
+    if(fStreamStates[trackNum].subsession != NULL) {
+        fStreamStates[trackNum].subsession->deleteStream(fOurSessionId, fStreamStates[trackNum].streamToken);
+        fStreamStates[trackNum].subsession = NULL;
+    }
+
+    // Optimization: If all subsessions have now been deleted, then we can delete ourself now:
+    Boolean noSubsessionsRemain = True;
+    for(unsigned i = 0; i < fNumStreamStates; ++i) {
+        if(fStreamStates[i].subsession != NULL) {
+            noSubsessionsRemain = False;
+            break;
+        }
+    }
+    if(noSubsessionsRemain)
+        delete this;
+}
+
+void RTSPServer::RTSPClientSession::reclaimStreamStates() {
+    for(unsigned i = 0; i < fNumStreamStates; ++i) {
+        if(fStreamStates[i].subsession != NULL) {
+            fOurRTSPServer.unnoteTCPStreamingOnSocket(fStreamStates[i].tcpSocketNum, this, i);
+            fStreamStates[i].subsession->deleteStream(fOurSessionId, fStreamStates[i].streamToken);
+        }
+    }
+    delete[] fStreamStates;
+    fStreamStates    = NULL;
+    fNumStreamStates = 0;
+}
+
+typedef enum StreamingMode { RTP_UDP, RTP_TCP, RAW_UDP } StreamingMode;
+
+static void parseTransportHeader(char const *buf, StreamingMode &streamingMode, char *&streamingModeString, char *&destinationAddressStr,
+                                 u_int8_t &     destinationTTL,
+                                 portNumBits &  clientRTPPortNum,   // if UDP
+                                 portNumBits &  clientRTCPPortNum,  // if UDP
+                                 unsigned char &rtpChannelId,       // if TCP
+                                 unsigned char &rtcpChannelId       // if TCP
+) {
+    // Initialize the result parameters to default values:
+    streamingMode         = RTP_UDP;
+    streamingModeString   = NULL;
+    destinationAddressStr = NULL;
+    destinationTTL        = 255;
+    clientRTPPortNum      = 0;
+    clientRTCPPortNum     = 1;
+    rtpChannelId = rtcpChannelId = 0xFF;
+
+    portNumBits p1, p2;
+    unsigned    ttl, rtpCid, rtcpCid;
+
+    // First, find "Transport:"
+    while(1) {
+        if(*buf == '\0')
+            return;  // not found
+        if(*buf == '\r' && *(buf + 1) == '\n' && *(buf + 2) == '\r')
+            return;  // end of the headers => not found
+        if(_strncasecmp(buf, "Transport:", 10) == 0)
+            break;
+        ++buf;
+    }
+
+    // Then, run through each of the fields, looking for ones we handle:
+    char const *fields = buf + 10;
+    while(*fields == ' ')
+        ++fields;
+    char *field = strDupSize(fields);
+    while(sscanf(fields, "%[^;\r\n]", field) == 1) {
+        if(strcmp(field, "RTP/AVP/TCP") == 0) {
+            streamingMode = RTP_TCP;
+        }
+        else if(strcmp(field, "RAW/RAW/UDP") == 0 || strcmp(field, "MP2T/H2221/UDP") == 0) {
+            streamingMode       = RAW_UDP;
+            streamingModeString = strDup(field);
+        }
+        else if(_strncasecmp(field, "destination=", 12) == 0) {
+            delete[] destinationAddressStr;
+            destinationAddressStr = strDup(field + 12);
+        }
+        else if(sscanf(field, "ttl%u", &ttl) == 1) {
+            destinationTTL = (u_int8_t)ttl;
+        }
+        else if(sscanf(field, "client_port=%hu-%hu", &p1, &p2) == 2) {
+            clientRTPPortNum  = p1;
+            clientRTCPPortNum = streamingMode == RAW_UDP ? 0 : p2;  // ignore the second port number if the client asked for raw UDP
+        }
+        else if(sscanf(field, "client_port=%hu", &p1) == 1) {
+            clientRTPPortNum  = p1;
+            clientRTCPPortNum = streamingMode == RAW_UDP ? 0 : p1 + 1;
+        }
+        else if(sscanf(field, "interleaved=%u-%u", &rtpCid, &rtcpCid) == 2) {
+            rtpChannelId  = (unsigned char)rtpCid;
+            rtcpChannelId = (unsigned char)rtcpCid;
+        }
+
+        fields += strlen(field);
+        while(*fields == ';' || *fields == ' ' || *fields == '\t')
+            ++fields;  // skip over separating ';' chars or whitespace
+        if(*fields == '\0' || *fields == '\r' || *fields == '\n')
+            break;
+    }
+    delete[] field;
+}
+
+static Boolean parsePlayNowHeader(char const *buf) {
+    // Find "x-playNow:" header, if present
+    while(1) {
+        if(*buf == '\0')
+            return False;  // not found
+        if(_strncasecmp(buf, "x-playNow:", 10) == 0)
+            break;
+        ++buf;
+    }
+
+    return True;
+}
+
+void RTSPServer::RTSPClientSession ::handleCmd_SETUP(RTSPServer::RTSPClientConnection *ourClientConnection, char const *urlPreSuffix, char const *urlSuffix,
+                                                     char const *fullRequestStr) {
+    // Normally, "urlPreSuffix" should be the session (stream) name, and "urlSuffix" should be the subsession (track) name.
+    // However (being "liberal in what we accept"), we also handle 'aggregate' SETUP requests (i.e., without a track name),
+    // in the special case where we have only a single track.  I.e., in this case, we also handle:
+    //    "urlPreSuffix" is empty and "urlSuffix" is the session (stream) name, or
+    //    "urlPreSuffix" concatenated with "urlSuffix" (with "/" inbetween) is the session (stream) name.
+    fOurClientConnection = ourClientConnection;
+    fURLPreSuffix        = urlPreSuffix;
+    fURLSuffix           = urlSuffix;
+    fFullRequestStr      = fullRequestStr;
+    fTrackId             = urlSuffix;  // in the normal case
+
+    // Begin by checking whether the specified stream name exists:
+    char const *streamName = urlPreSuffix;  // in the normal case
+    fOurServer.lookupServerMediaSession(streamName, SETUPLookupCompletionFunction1, this, fOurServerMediaSession == NULL);
+}
+
+void RTSPServer::RTSPClientSession ::SETUPLookupCompletionFunction1(void *clientData, ServerMediaSession *sessionLookedUp) {
+    RTSPServer::RTSPClientSession *session = (RTSPServer::RTSPClientSession *)clientData;
+    session->handleCmd_SETUP_afterLookup1(sessionLookedUp);
+}
+
+void RTSPServer::RTSPClientSession ::handleCmd_SETUP_afterLookup1(ServerMediaSession *sms) {
+    if(sms != NULL) {
+        // The lookup succeeded; continue working with the returned "ServerMediaSession":
+        handleCmd_SETUP_afterLookup2(sms);
+        return;
+    }
+
+    // The lookup failed.  Check for the special case (noted above), before we give up:
+    char const *streamName;
+    char *      concatenatedStreamName = NULL;
+
+    if(fURLPreSuffix[0] == '\0') {
+        streamName = fURLSuffix;
+    }
+    else {
+        concatenatedStreamName = new char[strlen(fURLPreSuffix) + strlen(fURLSuffix) + 2];  // allow for the "/" and the trailing '\0'
+        sprintf(concatenatedStreamName, "%s/%s", fURLPreSuffix, fURLSuffix);
+        streamName = concatenatedStreamName;
+    }
+    fTrackId = NULL;
+
+    // Check again:
+    fOurServer.lookupServerMediaSession(streamName, SETUPLookupCompletionFunction2, this, fOurServerMediaSession == NULL);
+    delete[] concatenatedStreamName;
+}
+
+void RTSPServer::RTSPClientSession ::SETUPLookupCompletionFunction2(void *clientData, ServerMediaSession *sessionLookedUp) {
+    RTSPServer::RTSPClientSession *session = (RTSPServer::RTSPClientSession *)clientData;
+    session->handleCmd_SETUP_afterLookup2(sessionLookedUp);
+}
+
+void RTSPServer::RTSPClientSession ::handleCmd_SETUP_afterLookup2(ServerMediaSession *sms) {
+    do {
+        if(sms == NULL) {
+            if(fOurServerMediaSession == NULL) {
+                // The client asked for a stream that doesn't exist (and this session descriptor has not been used before):
+                fOurClientConnection->handleCmd_notFound();
+            }
+            else {
+                // The client asked for a stream that doesn't exist, but using a stream id for a stream that does exist. Bad request:
+                fOurClientConnection->handleCmd_bad();
+            }
+            break;
+        }
+        else {
+            if(fOurServerMediaSession == NULL) {
+                // We're accessing the "ServerMediaSession" for the first time.
+                fOurServerMediaSession = sms;
+                fOurServerMediaSession->incrementReferenceCount();
+            }
+            else if(sms != fOurServerMediaSession) {
+                // The client asked for a stream that's different from the one originally requested for this stream id.  Bad request:
+                fOurClientConnection->handleCmd_bad();
+                break;
+            }
+        }
+
+        if(fStreamStates == NULL) {
+            // This is the first "SETUP" for this session.  Set up our array of states for all of this session's subsessions (tracks):
+            fNumStreamStates = fOurServerMediaSession->numSubsessions();
+            fStreamStates    = new struct streamState[fNumStreamStates];
+
+            ServerMediaSubsessionIterator iter(*fOurServerMediaSession);
+            ServerMediaSubsession *       subsession;
+            for(unsigned i = 0; i < fNumStreamStates; ++i) {
+                subsession                    = iter.next();
+                fStreamStates[i].subsession   = subsession;
+                fStreamStates[i].tcpSocketNum = -1;    // for now; may get set for RTP-over-TCP streaming
+                fStreamStates[i].streamToken  = NULL;  // for now; it may be changed by the "getStreamParameters()" call that comes later
+            }
+#ifdef LOG_RTSPSERVER_ACCESS
+            FILE *logfid = fopen("live555.log", "a");
+            if(logfid != NULL) {
+                time_t tm    = time(NULL);
+                char * tmstr = ctime(&tm);
+                fwrite(fURLPreSuffix, 1, strlen(fURLPreSuffix), logfid);
+                fwrite(", ", 1, 2, logfid);
+                fwrite(tmstr, 1, strlen(tmstr), logfid);
+                fclose(logfid);
+            }
+#endif
+        }
+
+        // Look up information for the specified subsession (track):
+        ServerMediaSubsession *subsession = NULL;
+        unsigned               trackNum;
+        if(fTrackId != NULL && fTrackId[0] != '\0') {  // normal case
+            for(trackNum = 0; trackNum < fNumStreamStates; ++trackNum) {
+                subsession = fStreamStates[trackNum].subsession;
+                if(subsession != NULL && strcmp(fTrackId, subsession->trackId()) == 0)
+                    break;
+            }
+            if(trackNum >= fNumStreamStates) {
+                // The specified track id doesn't exist, so this request fails:
+                fOurClientConnection->handleCmd_notFound();
+                break;
+            }
+        }
+        else {
+            // Weird case: there was no track id in the URL.
+            // This works only if we have only one subsession:
+            if(fNumStreamStates != 1 || fStreamStates[0].subsession == NULL) {
+                fOurClientConnection->handleCmd_bad();
+                break;
+            }
+            trackNum   = 0;
+            subsession = fStreamStates[trackNum].subsession;
+        }
+        // ASSERT: subsession != NULL
+
+        void *&token = fStreamStates[trackNum].streamToken;  // alias
+        if(token != NULL) {
+            // We already handled a "SETUP" for this track (to the same client),
+            // so stop any existing streaming of it, before we set it up again:
+            subsession->pauseStream(fOurSessionId, token);
+            fOurRTSPServer.unnoteTCPStreamingOnSocket(fStreamStates[trackNum].tcpSocketNum, this, trackNum);
+            subsession->deleteStream(fOurSessionId, token);
+        }
+
+        // Look for a "Transport:" header in the request string, to extract client parameters:
+        StreamingMode streamingMode;
+        char *        streamingModeString = NULL;  // set when RAW_UDP streaming is specified
+        char *        clientsDestinationAddressStr;
+        u_int8_t      clientsDestinationTTL;
+        portNumBits   clientRTPPortNum, clientRTCPPortNum;
+        unsigned char rtpChannelId, rtcpChannelId;
+        parseTransportHeader(fFullRequestStr, streamingMode, streamingModeString, clientsDestinationAddressStr, clientsDestinationTTL, clientRTPPortNum,
+                             clientRTCPPortNum, rtpChannelId, rtcpChannelId);
+        if((streamingMode == RTP_TCP && rtpChannelId == 0xFF)
+           || (streamingMode != RTP_TCP && fOurClientConnection->fClientOutputSocket != fOurClientConnection->fClientInputSocket)) {
+            // An anomolous situation, caused by a buggy client.  Either:
+            //     1/ TCP streaming was requested, but with no "interleaving=" fields.  (QuickTime Player sometimes does this.), or
+            //     2/ TCP streaming was not requested, but we're doing RTSP-over-HTTP tunneling (which implies TCP streaming).
+            // In either case, we assume TCP streaming, and set the RTP and RTCP channel ids to proper values:
+            streamingMode = RTP_TCP;
+            rtpChannelId  = fTCPStreamIdCount;
+            rtcpChannelId = fTCPStreamIdCount + 1;
+        }
+        if(streamingMode == RTP_TCP)
+            fTCPStreamIdCount += 2;
+
+        Port clientRTPPort(clientRTPPortNum);
+        Port clientRTCPPort(clientRTCPPortNum);
+
+        // Next, check whether a "Range:" or "x-playNow:" header is present in the request.
+        // This isn't legal, but some clients do this to combine "SETUP" and "PLAY":
+        double  rangeStart = 0.0, rangeEnd = 0.0;
+        char *  absStart = NULL;
+        char *  absEnd   = NULL;
+        Boolean startTimeIsNow;
+        if(parseRangeHeader(fFullRequestStr, rangeStart, rangeEnd, absStart, absEnd, startTimeIsNow)) {
+            delete[] absStart;
+            delete[] absEnd;
+            fStreamAfterSETUP = True;
+        }
+        else if(parsePlayNowHeader(fFullRequestStr)) {
+            fStreamAfterSETUP = True;
+        }
+        else {
+            fStreamAfterSETUP = False;
+        }
+
+        // Then, get server parameters from the 'subsession':
+        if(streamingMode == RTP_TCP) {
+            // Note that we'll be streaming over the RTSP TCP connection:
+            fStreamStates[trackNum].tcpSocketNum = fOurClientConnection->fClientOutputSocket;
+            fOurRTSPServer.noteTCPStreamingOnSocket(fStreamStates[trackNum].tcpSocketNum, this, trackNum);
+        }
+        struct sockaddr_storage destinationAddress = nullAddress();
+        // used to indicate that the address is 'unassigned'
+        u_int8_t destinationTTL = 255;
+#ifdef RTSP_ALLOW_CLIENT_DESTINATION_SETTING
+        if(clientsDestinationAddressStr != NULL) {
+            // Use the client-provided "destination" address.
+            // Note: This potentially allows the server to be used in denial-of-service
+            // attacks, so don't enable this code unless you're sure that clients are
+            // trusted.
+            NetAddressList destAddresses(clientsDestinationAddressStr);
+            if(destAddresses.numAddresses() > 0) {
+                copyAddress(destinationAddress, destAddresses.firstAddress());
+            }
+        }
+        // Also use the client-provided TTL.
+        destinationTTL = clientsDestinationTTL;
+#endif
+        delete[] clientsDestinationAddressStr;
+        Port serverRTPPort(0);
+        Port serverRTCPPort(0);
+
+        // Make sure that we transmit on the same interface that's used by the client
+        // (in case we're a multi-homed server):
+        struct sockaddr_storage sourceAddr;
+        SOCKLEN_T               namelen = sizeof sourceAddr;
+        getsockname(fOurClientConnection->fClientInputSocket, (struct sockaddr *)&sourceAddr,
+                    reinterpret_cast<socklen_t *>(&namelen));
+
+        subsession->getStreamParameters(fOurSessionId, fOurClientConnection->fClientAddr, clientRTPPort, clientRTCPPort, fStreamStates[trackNum].tcpSocketNum,
+                                        rtpChannelId, rtcpChannelId, &fOurClientConnection->fTLS, destinationAddress, destinationTTL, fIsMulticast,
+                                        serverRTPPort, serverRTCPPort, fStreamStates[trackNum].streamToken);
+
+        AddressString destAddrStr(destinationAddress);
+        AddressString sourceAddrStr(sourceAddr);
+        char          timeoutParameterString[100];
+        if(fOurRTSPServer.fReclamationSeconds > 0) {
+            sprintf(timeoutParameterString, ";timeout=%u", fOurRTSPServer.fReclamationSeconds);
+        }
+        else {
+            timeoutParameterString[0] = '\0';
+        }
+        if(fIsMulticast) {
+            switch(streamingMode) {
+            case RTP_UDP: {
+                snprintf((char *)fOurClientConnection->fResponseBuffer, sizeof fOurClientConnection->fResponseBuffer,
+                         "RTSP/1.0 200 OK\r\n"
+                         "CSeq: %s\r\n"
+                         "%s"
+                         "Transport: RTP/%s;multicast;destination=%s;source=%s;port=%d-%d;ttl=%d\r\n"
+                         "Session: %08X%s\r\n\r\n",
+                         fOurClientConnection->fCurrentCSeq, dateHeader(), fOurRTSPServer.fWeServeSRTP ? "SAVP" : "AVP", destAddrStr.val(), sourceAddrStr.val(),
+                         ntohs(serverRTPPort.num()), ntohs(serverRTCPPort.num()), destinationTTL, fOurSessionId, timeoutParameterString);
+                break;
+            }
+            case RTP_TCP: {
+                // multicast streams can't be sent via TCP
+                fOurClientConnection->handleCmd_unsupportedTransport();
+                break;
+            }
+            case RAW_UDP: {
+                snprintf((char *)fOurClientConnection->fResponseBuffer, sizeof fOurClientConnection->fResponseBuffer,
+                         "RTSP/1.0 200 OK\r\n"
+                         "CSeq: %s\r\n"
+                         "%s"
+                         "Transport: %s;multicast;destination=%s;source=%s;port=%d;ttl=%d\r\n"
+                         "Session: %08X%s\r\n\r\n",
+                         fOurClientConnection->fCurrentCSeq, dateHeader(), streamingModeString, destAddrStr.val(), sourceAddrStr.val(),
+                         ntohs(serverRTPPort.num()), destinationTTL, fOurSessionId, timeoutParameterString);
+                break;
+            }
+            }
+        }
+        else {
+            switch(streamingMode) {
+            case RTP_UDP: {
+                snprintf((char *)fOurClientConnection->fResponseBuffer, sizeof fOurClientConnection->fResponseBuffer,
+                         "RTSP/1.0 200 OK\r\n"
+                         "CSeq: %s\r\n"
+                         "%s"
+                         "Transport: RTP/%s;unicast;destination=%s;source=%s;client_port=%d-%d;server_port=%d-%d\r\n"
+                         "Session: %08X%s\r\n\r\n",
+                         fOurClientConnection->fCurrentCSeq, dateHeader(), fOurRTSPServer.fWeServeSRTP ? "SAVP" : "AVP", destAddrStr.val(), sourceAddrStr.val(),
+                         ntohs(clientRTPPort.num()), ntohs(clientRTCPPort.num()), ntohs(serverRTPPort.num()), ntohs(serverRTCPPort.num()), fOurSessionId,
+                         timeoutParameterString);
+                break;
+            }
+            case RTP_TCP: {
+                if(!fOurRTSPServer.fAllowStreamingRTPOverTCP) {
+                    fOurClientConnection->handleCmd_unsupportedTransport();
+                }
+                else {
+                    snprintf((char *)fOurClientConnection->fResponseBuffer, sizeof fOurClientConnection->fResponseBuffer,
+                             "RTSP/1.0 200 OK\r\n"
+                             "CSeq: %s\r\n"
+                             "%s"
+                             "Transport: RTP/AVP/TCP;unicast;destination=%s;source=%s;interleaved=%d-%d\r\n"
+                             "Session: %08X%s\r\n\r\n",
+                             fOurClientConnection->fCurrentCSeq, dateHeader(), destAddrStr.val(), sourceAddrStr.val(), rtpChannelId, rtcpChannelId,
+                             fOurSessionId, timeoutParameterString);
+                }
+                break;
+            }
+            case RAW_UDP: {
+                snprintf((char *)fOurClientConnection->fResponseBuffer, sizeof fOurClientConnection->fResponseBuffer,
+                         "RTSP/1.0 200 OK\r\n"
+                         "CSeq: %s\r\n"
+                         "%s"
+                         "Transport: %s;unicast;destination=%s;source=%s;client_port=%d;server_port=%d\r\n"
+                         "Session: %08X%s\r\n\r\n",
+                         fOurClientConnection->fCurrentCSeq, dateHeader(), streamingModeString, destAddrStr.val(), sourceAddrStr.val(),
+                         ntohs(clientRTPPort.num()), ntohs(serverRTPPort.num()), fOurSessionId, timeoutParameterString);
+                break;
+            }
+            }
+        }
+        delete[] streamingModeString;
+    } while(0);
+}
+
+void RTSPServer::RTSPClientSession ::handleCmd_withinSession(RTSPServer::RTSPClientConnection *ourClientConnection, char const *cmdName,
+                                                             char const *urlPreSuffix, char const *urlSuffix, char const *fullRequestStr) {
+    // This will either be:
+    // - a non-aggregated operation, if "urlPreSuffix" is the session (stream)
+    //   name and "urlSuffix" is the subsession (track) name, or
+    // - an aggregated operation, if "urlSuffix" is the session (stream) name,
+    //   or "urlPreSuffix" is the session (stream) name, and "urlSuffix" is empty,
+    //   or "urlPreSuffix" and "urlSuffix" are both nonempty, but when concatenated, (with "/") form the session (stream) name.
+    // Begin by figuring out which of these it is:
+    ServerMediaSubsession *subsession;
+
+    if(fOurServerMediaSession == NULL) {  // There wasn't a previous SETUP!
+        ourClientConnection->handleCmd_notSupported();
+        return;
+    }
+    else if(urlSuffix[0] != '\0' && strcmp(fOurServerMediaSession->streamName(), urlPreSuffix) == 0) {
+        // Non-aggregated operation.
+        // Look up the media subsession whose track id is "urlSuffix":
+        ServerMediaSubsessionIterator iter(*fOurServerMediaSession);
+        while((subsession = iter.next()) != NULL) {
+            if(strcmp(subsession->trackId(), urlSuffix) == 0)
+                break;  // success
+        }
+        if(subsession == NULL) {  // no such track!
+            ourClientConnection->handleCmd_notFound();
+            return;
+        }
+    }
+    else if(strcmp(fOurServerMediaSession->streamName(), urlSuffix) == 0
+            || (urlSuffix[0] == '\0' && strcmp(fOurServerMediaSession->streamName(), urlPreSuffix) == 0)) {
+        // Aggregated operation
+        subsession = NULL;
+    }
+    else if(urlPreSuffix[0] != '\0' && urlSuffix[0] != '\0') {
+        // Aggregated operation, if <urlPreSuffix>/<urlSuffix> is the session (stream) name:
+        unsigned const urlPreSuffixLen = strlen(urlPreSuffix);
+        if(strncmp(fOurServerMediaSession->streamName(), urlPreSuffix, urlPreSuffixLen) == 0 && fOurServerMediaSession->streamName()[urlPreSuffixLen] == '/'
+           && strcmp(&(fOurServerMediaSession->streamName())[urlPreSuffixLen + 1], urlSuffix) == 0) {
+            subsession = NULL;
+        }
+        else {
+            ourClientConnection->handleCmd_notFound();
+            return;
+        }
+    }
+    else {  // the request doesn't match a known stream and/or track at all!
+        ourClientConnection->handleCmd_notFound();
+        return;
+    }
+
+    if(strcmp(cmdName, "TEARDOWN") == 0) {
+        handleCmd_TEARDOWN(ourClientConnection, subsession);
+    }
+    else if(strcmp(cmdName, "PLAY") == 0) {
+        handleCmd_PLAY(ourClientConnection, subsession, fullRequestStr);
+    }
+    else if(strcmp(cmdName, "PAUSE") == 0) {
+        handleCmd_PAUSE(ourClientConnection, subsession);
+    }
+    else if(strcmp(cmdName, "GET_PARAMETER") == 0) {
+        handleCmd_GET_PARAMETER(ourClientConnection, subsession, fullRequestStr);
+    }
+    else if(strcmp(cmdName, "SET_PARAMETER") == 0) {
+        handleCmd_SET_PARAMETER(ourClientConnection, subsession, fullRequestStr);
+    }
+}
+
+void RTSPServer::RTSPClientSession ::handleCmd_TEARDOWN(RTSPServer::RTSPClientConnection *ourClientConnection, ServerMediaSubsession *subsession) {
+    unsigned i;
+    for(i = 0; i < fNumStreamStates; ++i) {
+        if(subsession == NULL /* means: aggregated operation */
+           || subsession == fStreamStates[i].subsession) {
+            if(fStreamStates[i].subsession != NULL) {
+                fOurRTSPServer.unnoteTCPStreamingOnSocket(fStreamStates[i].tcpSocketNum, this, i);
+                fStreamStates[i].subsession->deleteStream(fOurSessionId, fStreamStates[i].streamToken);
+                fStreamStates[i].subsession = NULL;
+            }
+        }
+    }
+
+    setRTSPResponse(ourClientConnection, "200 OK");
+
+    // Optimization: If all subsessions have now been torn down, then we know that we can reclaim our object now.
+    // (Without this optimization, however, this object would still get reclaimed later, as a result of a 'liveness' timeout.)
+    Boolean noSubsessionsRemain = True;
+    for(i = 0; i < fNumStreamStates; ++i) {
+        if(fStreamStates[i].subsession != NULL) {
+            noSubsessionsRemain = False;
+            break;
+        }
+    }
+    if(noSubsessionsRemain)
+        delete this;
+}
+
+void RTSPServer::RTSPClientSession ::handleCmd_PLAY(RTSPServer::RTSPClientConnection *ourClientConnection, ServerMediaSubsession *subsession,
+                                                    char const *fullRequestStr) {
+    char *   rtspURL     = fOurRTSPServer.rtspURL(fOurServerMediaSession, ourClientConnection->fClientInputSocket);
+    unsigned rtspURLSize = strlen(rtspURL);
+
+    // Parse the client's "Scale:" header, if any:
+    float   scale;
+    Boolean sawScaleHeader = parseScaleHeader(fullRequestStr, scale);
+
+    // Try to set the stream's scale factor to this value:
+    if(subsession == NULL /*aggregate op*/) {
+        fOurServerMediaSession->testScaleFactor(scale);
+    }
+    else {
+        subsession->testScaleFactor(scale);
+    }
+
+    char  buf[100];
+    char *scaleHeader;
+    if(!sawScaleHeader) {
+        buf[0] = '\0';  // Because we didn't see a Scale: header, don't send one back
+    }
+    else {
+        sprintf(buf, "Scale: %f\r\n", scale);
+    }
+    scaleHeader = strDup(buf);
+
+    // Parse the client's "Range:" header, if any:
+    float   duration   = 0.0;
+    double  rangeStart = 0.0, rangeEnd = 0.0;
+    char *  absStart = NULL;
+    char *  absEnd   = NULL;
+    Boolean startTimeIsNow;
+    Boolean sawRangeHeader = parseRangeHeader(fullRequestStr, rangeStart, rangeEnd, absStart, absEnd, startTimeIsNow);
+
+    if(sawRangeHeader && absStart == NULL /*not seeking by 'absolute' time*/) {
+        // Use this information, plus the stream's duration (if known), to create our own "Range:" header, for the response:
+        duration = subsession == NULL /*aggregate op*/
+                       ? fOurServerMediaSession->duration()
+                       : subsession->duration();
+        if(duration < 0.0) {
+            // We're an aggregate PLAY, but the subsessions have different durations.
+            // Use the largest of these durations in our header
+            duration = -duration;
+        }
+
+        // Make sure that "rangeStart" and "rangeEnd" (from the client's "Range:" header)
+        // have sane values, before we send back our own "Range:" header in our response:
+        if(rangeStart < 0.0)
+            rangeStart = 0.0;
+        else if(rangeStart > duration)
+            rangeStart = duration;
+        if(rangeEnd < 0.0)
+            rangeEnd = 0.0;
+        else if(rangeEnd > duration)
+            rangeEnd = duration;
+        if((scale > 0.0 && rangeStart > rangeEnd && rangeEnd > 0.0) || (scale < 0.0 && rangeStart < rangeEnd)) {
+            // "rangeStart" and "rangeEnd" were the wrong way around; swap them:
+            double tmp = rangeStart;
+            rangeStart = rangeEnd;
+            rangeEnd   = tmp;
+        }
+    }
+
+    // Create a "RTP-Info:" line.  It will get filled in from each subsession's state:
+    char const *rtpInfoFmt = "%s"  // "RTP-Info:", plus any preceding rtpInfo items
+                             "%s"  // comma separator, if needed
+                             "url=%s/%s"
+                             ";seq=%d"
+                             ";rtptime=%u";
+    unsigned rtpInfoFmtSize = strlen(rtpInfoFmt);
+    char *   rtpInfo        = strDup("RTP-Info: ");
+    unsigned i, numRTPInfoItems = 0;
+
+    // Do any required seeking/scaling on each subsession, before starting streaming.
+    // (However, we don't do this if the "PLAY" request was for just a single subsession
+    // of a multiple-subsession stream; for such streams, seeking/scaling can be done
+    // only with an aggregate "PLAY".)
+    for(i = 0; i < fNumStreamStates; ++i) {
+        if(subsession == NULL /* means: aggregated operation */ || fNumStreamStates == 1) {
+            if(fStreamStates[i].subsession != NULL) {
+                if(sawScaleHeader) {
+                    fStreamStates[i].subsession->setStreamScale(fOurSessionId, fStreamStates[i].streamToken, scale);
+                }
+                if(absStart != NULL) {
+                    // Special case handling for seeking by 'absolute' time:
+
+                    fStreamStates[i].subsession->seekStream(fOurSessionId, fStreamStates[i].streamToken, absStart, absEnd);
+                }
+                else {
+                    // Seeking by relative (NPT) time:
+
+                    u_int64_t numBytes;
+                    if(!sawRangeHeader || startTimeIsNow) {
+                        // We're resuming streaming without seeking, so we just do a 'null' seek
+                        // (to get our NPT, and to specify when to end streaming):
+                        fStreamStates[i].subsession->nullSeekStream(fOurSessionId, fStreamStates[i].streamToken, rangeEnd, numBytes);
+                    }
+                    else {
+                        // We do a real 'seek':
+                        double streamDuration = 0.0;  // by default; means: stream until the end of the media
+                        if(rangeEnd > 0.0 && (rangeEnd + 0.001) < duration) {
+                            // the 0.001 is because we limited the values to 3 decimal places
+                            // We want the stream to end early.  Set the duration we want:
+                            streamDuration = rangeEnd - rangeStart;
+                            if(streamDuration < 0.0)
+                                streamDuration = -streamDuration;
+                            // should happen only if scale < 0.0
+                        }
+                        fStreamStates[i].subsession->seekStream(fOurSessionId, fStreamStates[i].streamToken, rangeStart, streamDuration, numBytes);
+                    }
+                }
+            }
+        }
+    }
+
+    // Create the "Range:" header that we'll send back in our response.
+    // (Note that we do this after seeking, in case the seeking operation changed the range start time.)
+    char *rangeHeader;
+    if(absStart != NULL) {
+        // We're seeking by 'absolute' time:
+        char *rangeHeaderBuf;
+
+        if(absEnd == NULL) {
+            rangeHeaderBuf = new char[100 + strlen(absStart)];  // ample space
+            sprintf(rangeHeaderBuf, "Range: clock=%s-\r\n", absStart);
+        }
+        else {
+            rangeHeaderBuf = new char[100 + strlen(absStart) + strlen(absEnd)];  // ample space
+            sprintf(rangeHeaderBuf, "Range: clock=%s-%s\r\n", absStart, absEnd);
+        }
+        delete[] absStart;
+        delete[] absEnd;
+        rangeHeader = strDup(rangeHeaderBuf);
+        delete[] rangeHeaderBuf;
+    }
+    else {
+        // We're seeking by relative (NPT) time:
+        if(!sawRangeHeader || startTimeIsNow) {
+            // We didn't seek, so in our response, begin the range with the current NPT (normal play time):
+            float curNPT = 0.0;
+            for(i = 0; i < fNumStreamStates; ++i) {
+                if(subsession == NULL /* means: aggregated operation */
+                   || subsession == fStreamStates[i].subsession) {
+                    if(fStreamStates[i].subsession == NULL)
+                        continue;
+                    float npt = fStreamStates[i].subsession->getCurrentNPT(fStreamStates[i].streamToken);
+                    if(npt > curNPT)
+                        curNPT = npt;
+                    // Note: If this is an aggregate "PLAY" on a multi-subsession stream,
+                    // then it's conceivable that the NPTs of each subsession may differ
+                    // (if there has been a previous seek on just one subsession).
+                    // In this (unusual) case, we just return the largest NPT; I hope that turns out OK...
+                }
+            }
+            rangeStart = curNPT;
+        }
+
+        if(rangeEnd == 0.0 && scale >= 0.0) {
+            sprintf(buf, "Range: npt=%.3f-\r\n", rangeStart);
+        }
+        else {
+            sprintf(buf, "Range: npt=%.3f-%.3f\r\n", rangeStart, rangeEnd);
+        }
+        rangeHeader = strDup(buf);
+    }
+
+    // Now, start streaming:
+    for(i = 0; i < fNumStreamStates; ++i) {
+        if(subsession == NULL /* means: aggregated operation */
+           || subsession == fStreamStates[i].subsession) {
+            unsigned short rtpSeqNum    = 0;
+            unsigned       rtpTimestamp = 0;
+            if(fStreamStates[i].subsession == NULL)
+                continue;
+            fStreamStates[i].subsession->startStream(fOurSessionId, fStreamStates[i].streamToken, (TaskFunc *)noteClientLiveness, this, rtpSeqNum, rtpTimestamp,
+                                                     RTSPServer::RTSPClientConnection::handleAlternativeRequestByte, ourClientConnection);
+            const char *urlSuffix   = fStreamStates[i].subsession->trackId();
+            char *      prevRTPInfo = rtpInfo;
+            unsigned    rtpInfoSize = rtpInfoFmtSize + strlen(prevRTPInfo) + 1 + rtspURLSize + strlen(urlSuffix) + 5 /*max unsigned short len*/
+                                   + 10                                                                              /*max unsigned (32-bit) len*/
+                                   + 2 /*allows for trailing \r\n at final end of string*/;
+            rtpInfo = new char[rtpInfoSize];
+            sprintf(rtpInfo, rtpInfoFmt, prevRTPInfo, numRTPInfoItems++ == 0 ? "" : ",", rtspURL, urlSuffix, rtpSeqNum, rtpTimestamp);
+            delete[] prevRTPInfo;
+        }
+    }
+    if(numRTPInfoItems == 0) {
+        rtpInfo[0] = '\0';
+    }
+    else {
+        unsigned rtpInfoLen     = strlen(rtpInfo);
+        rtpInfo[rtpInfoLen]     = '\r';
+        rtpInfo[rtpInfoLen + 1] = '\n';
+        rtpInfo[rtpInfoLen + 2] = '\0';
+    }
+
+    // Fill in the response:
+    snprintf((char *)ourClientConnection->fResponseBuffer, sizeof ourClientConnection->fResponseBuffer,
+             "RTSP/1.0 200 OK\r\n"
+             "CSeq: %s\r\n"
+             "%s"
+             "%s"
+             "%s"
+             "Session: %08X\r\n"
+             "%s\r\n",
+             ourClientConnection->fCurrentCSeq, dateHeader(), scaleHeader, rangeHeader, fOurSessionId, rtpInfo);
+    delete[] rtpInfo;
+    delete[] rangeHeader;
+    delete[] scaleHeader;
+    delete[] rtspURL;
+}
+
+void RTSPServer::RTSPClientSession ::handleCmd_PAUSE(RTSPServer::RTSPClientConnection *ourClientConnection, ServerMediaSubsession *subsession) {
+    for(unsigned i = 0; i < fNumStreamStates; ++i) {
+        if(subsession == NULL /* means: aggregated operation */
+           || subsession == fStreamStates[i].subsession) {
+            if(fStreamStates[i].subsession != NULL) {
+                fStreamStates[i].subsession->pauseStream(fOurSessionId, fStreamStates[i].streamToken);
+            }
+        }
+    }
+
+    setRTSPResponse(ourClientConnection, "200 OK", fOurSessionId);
+}
+
+void RTSPServer::RTSPClientSession ::handleCmd_GET_PARAMETER(RTSPServer::RTSPClientConnection *ourClientConnection, ServerMediaSubsession * /*subsession*/,
+                                                             char const * /*fullRequestStr*/) {
+    // By default, we implement "GET_PARAMETER" just as a 'keep alive', and send back a dummy response.
+    // (If you want to handle "GET_PARAMETER" properly, you can do so by defining a subclass of "RTSPServer"
+    // and "RTSPServer::RTSPClientSession", and then reimplement this virtual function in your subclass.)
+    setRTSPResponse(ourClientConnection, "200 OK", fOurSessionId, LIVEMEDIA_LIBRARY_VERSION_STRING);
+}
+
+void RTSPServer::RTSPClientSession ::handleCmd_SET_PARAMETER(RTSPServer::RTSPClientConnection *ourClientConnection, ServerMediaSubsession * /*subsession*/,
+                                                             char const * /*fullRequestStr*/) {
+    // By default, we implement "SET_PARAMETER" just as a 'keep alive', and send back an empty response.
+    // (If you want to handle "SET_PARAMETER" properly, you can do so by defining a subclass of "RTSPServer"
+    // and "RTSPServer::RTSPClientSession", and then reimplement this virtual function in your subclass.)
+    setRTSPResponse(ourClientConnection, "200 OK", fOurSessionId);
+}
+
+GenericMediaServer::ClientConnection *RTSPServer::createNewClientConnection(int clientSocket, struct sockaddr_storage const &clientAddr) {
+    return new RTSPClientConnection(*this, clientSocket, clientAddr, fOurConnectionsUseTLS);
+}
+
+GenericMediaServer::ClientSession *RTSPServer::createNewClientSession(u_int32_t sessionId) {
+    return new RTSPClientSession(*this, sessionId);
+}
diff --git a/3rdparty/live555/src/liveMedia/RTSPServerRegister.cpp b/3rdparty/live555/src/liveMedia/RTSPServerRegister.cpp
new file mode 100644
index 00000000..92576789
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/RTSPServerRegister.cpp
@@ -0,0 +1,438 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A RTSP server
+// Implementation of functionality related to the "REGISTER" and "DEREGISTER" commands
+
+#include "RTSPServer.hh"
+#include "RTSPCommon.hh"
+#include "RTSPRegisterSender.hh"
+#include "ProxyServerMediaSession.hh"
+#include "GroupsockHelper.hh"
+
+////////// Implementation of "RTSPServer::registerStream()": //////////
+
+static void rtspRegisterResponseHandler(RTSPClient *rtspClient, int resultCode, char *resultString);  // forward
+
+// A class that represents the state of a "REGISTER" request in progress:
+class RegisterRequestRecord : public RTSPRegisterSender {
+public:
+    RegisterRequestRecord(RTSPServer &ourServer, unsigned requestId, char const *remoteClientNameOrAddress, portNumBits remoteClientPortNum,
+                          char const *rtspURLToRegister, RTSPServer::responseHandlerForREGISTER *responseHandler, Authenticator *authenticator,
+                          Boolean requestStreamingViaTCP, char const *proxyURLSuffix)
+        : RTSPRegisterSender(ourServer.envir(), remoteClientNameOrAddress, remoteClientPortNum, rtspURLToRegister, rtspRegisterResponseHandler, authenticator,
+                             requestStreamingViaTCP, proxyURLSuffix, True /*reuseConnection*/,
+#ifdef DEBUG
+                             1 /*verbosityLevel*/,
+#else
+                             0 /*verbosityLevel*/,
+#endif
+                             NULL),
+          fOurServer(ourServer),
+          fRequestId(requestId),
+          fResponseHandler(responseHandler) {
+        // Add ourself to our server's 'pending REGISTER or DEREGISTER requests' table:
+        ourServer.fPendingRegisterOrDeregisterRequests->Add((char const *)this, this);
+    }
+
+    virtual ~RegisterRequestRecord() {
+        // Remove ourself from the server's 'pending REGISTER or DEREGISTER requests' hash table before we go:
+        fOurServer.fPendingRegisterOrDeregisterRequests->Remove((char const *)this);
+    }
+
+    void handleResponse(int resultCode, char *resultString) {
+        if(resultCode == 0) {
+            // The "REGISTER" request succeeded, so use the still-open RTSP socket to await incoming commands from the remote endpoint:
+            int                     sock;
+            struct sockaddr_storage remoteAddress;
+
+            grabConnection(sock, remoteAddress);
+            if(sock >= 0) {
+                increaseSendBufferTo(envir(), sock, 50 * 1024);  // in anticipation of streaming over it
+                (void)fOurServer.createNewClientConnection(sock, remoteAddress);
+            }
+        }
+
+        if(fResponseHandler != NULL) {
+            // Call our (REGISTER-specific) response handler now:
+            (*fResponseHandler)(&fOurServer, fRequestId, resultCode, resultString);
+        }
+        else {
+            // We need to delete[] "resultString" before we leave:
+            delete[] resultString;
+        }
+
+        // We're completely done with the REGISTER command now, so delete ourself now:
+        Medium::close(this);
+    }
+
+private:
+    RTSPServer &                            fOurServer;
+    unsigned                                fRequestId;
+    RTSPServer::responseHandlerForREGISTER *fResponseHandler;
+};
+
+static void rtspRegisterResponseHandler(RTSPClient *rtspClient, int resultCode, char *resultString) {
+    RegisterRequestRecord *registerRequestRecord = (RegisterRequestRecord *)rtspClient;
+
+    registerRequestRecord->handleResponse(resultCode, resultString);
+}
+
+unsigned RTSPServer::registerStream(ServerMediaSession *serverMediaSession, char const *remoteClientNameOrAddress, portNumBits remoteClientPortNum,
+                                    responseHandlerForREGISTER *responseHandler, char const *username, char const *password, Boolean receiveOurStreamViaTCP,
+                                    char const *proxyURLSuffix) {
+    // Create a new "RegisterRequestRecord" that will send the "REGISTER" command.
+    // (This object will automatically get deleted after we get a response to the "REGISTER" command, or if we're deleted.)
+    Authenticator *authenticator = NULL;
+    if(username != NULL) {
+        if(password == NULL)
+            password = "";
+        authenticator = new Authenticator(username, password);
+    }
+    unsigned    requestId = ++fRegisterOrDeregisterRequestCounter;
+    char const *url       = rtspURL(serverMediaSession);
+    new RegisterRequestRecord(*this, requestId, remoteClientNameOrAddress, remoteClientPortNum, url, responseHandler, authenticator, receiveOurStreamViaTCP,
+                              proxyURLSuffix);
+
+    delete[](char *) url;  // we can do this here because it was copied to the "RegisterRequestRecord"
+    delete authenticator;  // ditto
+    return requestId;
+}
+
+////////// Implementation of "RTSPServer::deregisterStream()": //////////
+
+static void rtspDeregisterResponseHandler(RTSPClient *rtspClient, int resultCode, char *resultString);  // forward
+
+// A class that represents the state of a "DEREGISTER" request in progress:
+class DeregisterRequestRecord : public RTSPDeregisterSender {
+public:
+    DeregisterRequestRecord(RTSPServer &ourServer, unsigned requestId, char const *remoteClientNameOrAddress, portNumBits remoteClientPortNum,
+                            char const *rtspURLToDeregister, RTSPServer::responseHandlerForDEREGISTER *responseHandler, Authenticator *authenticator,
+                            char const *proxyURLSuffix)
+        : RTSPDeregisterSender(ourServer.envir(), remoteClientNameOrAddress, remoteClientPortNum, rtspURLToDeregister, rtspDeregisterResponseHandler,
+                               authenticator, proxyURLSuffix,
+#ifdef DEBUG
+                               1 /*verbosityLevel*/,
+#else
+                               0 /*verbosityLevel*/,
+#endif
+                               NULL),
+          fOurServer(ourServer),
+          fRequestId(requestId),
+          fResponseHandler(responseHandler) {
+        // Add ourself to our server's 'pending REGISTER or DEREGISTER requests' table:
+        ourServer.fPendingRegisterOrDeregisterRequests->Add((char const *)this, this);
+    }
+
+    virtual ~DeregisterRequestRecord() {
+        // Remove ourself from the server's 'pending REGISTER or DEREGISTER requests' hash table before we go:
+        fOurServer.fPendingRegisterOrDeregisterRequests->Remove((char const *)this);
+    }
+
+    void handleResponse(int resultCode, char *resultString) {
+        if(fResponseHandler != NULL) {
+            // Call our (DEREGISTER-specific) response handler now:
+            (*fResponseHandler)(&fOurServer, fRequestId, resultCode, resultString);
+        }
+        else {
+            // We need to delete[] "resultString" before we leave:
+            delete[] resultString;
+        }
+
+        // We're completely done with the DEREGISTER command now, so delete ourself now:
+        Medium::close(this);
+    }
+
+private:
+    RTSPServer &                              fOurServer;
+    unsigned                                  fRequestId;
+    RTSPServer::responseHandlerForDEREGISTER *fResponseHandler;
+};
+
+static void rtspDeregisterResponseHandler(RTSPClient *rtspClient, int resultCode, char *resultString) {
+    DeregisterRequestRecord *deregisterRequestRecord = (DeregisterRequestRecord *)rtspClient;
+
+    deregisterRequestRecord->handleResponse(resultCode, resultString);
+}
+
+unsigned RTSPServer::deregisterStream(ServerMediaSession *serverMediaSession, char const *remoteClientNameOrAddress, portNumBits remoteClientPortNum,
+                                      responseHandlerForDEREGISTER *responseHandler, char const *username, char const *password, char const *proxyURLSuffix) {
+    // Create a new "DeregisterRequestRecord" that will send the "DEREGISTER" command.
+    // (This object will automatically get deleted after we get a response to the "DEREGISTER" command, or if we're deleted.)
+    Authenticator *authenticator = NULL;
+    if(username != NULL) {
+        if(password == NULL)
+            password = "";
+        authenticator = new Authenticator(username, password);
+    }
+    unsigned    requestId = ++fRegisterOrDeregisterRequestCounter;
+    char const *url       = rtspURL(serverMediaSession);
+    new DeregisterRequestRecord(*this, requestId, remoteClientNameOrAddress, remoteClientPortNum, url, responseHandler, authenticator, proxyURLSuffix);
+
+    delete[](char *) url;  // we can do this here because it was copied to the "DeregisterRequestRecord"
+    delete authenticator;  // ditto
+    return requestId;
+}
+
+Boolean RTSPServer::weImplementREGISTER(char const * /*cmd*/ /*"REGISTER" or "DEREGISTER"*/, char const * /*proxyURLSuffix*/, char *&responseStr) {
+    // By default, servers do not implement our custom "REGISTER"/"DEREGISTER" commands:
+    responseStr = NULL;
+    return False;
+}
+
+void RTSPServer::implementCmd_REGISTER(char const * /*cmd*/ /*"REGISTER" or "DEREGISTER"*/, char const * /*url*/, char const * /*urlSuffix*/,
+                                       int /*socketToRemoteServer*/, Boolean /*deliverViaTCP*/, char const * /*proxyURLSuffix*/) {
+    // By default, this function is a 'noop'
+}
+
+// Special mechanism for handling our custom "REGISTER" command:
+
+RTSPServer::RTSPClientConnection::ParamsForREGISTER ::ParamsForREGISTER(char const *                      cmd /*"REGISTER" or "DEREGISTER"*/,
+                                                                        RTSPServer::RTSPClientConnection *ourConnection, char const *url, char const *urlSuffix,
+                                                                        Boolean reuseConnection, Boolean deliverViaTCP, char const *proxyURLSuffix)
+    : fCmd(strDup(cmd)),
+      fOurConnection(ourConnection),
+      fURL(strDup(url)),
+      fURLSuffix(strDup(urlSuffix)),
+      fReuseConnection(reuseConnection),
+      fDeliverViaTCP(deliverViaTCP),
+      fProxyURLSuffix(strDup(proxyURLSuffix)) {}
+
+RTSPServer::RTSPClientConnection::ParamsForREGISTER::~ParamsForREGISTER() {
+    delete[](char *) fCmd;
+    delete[] fURL;
+    delete[] fURLSuffix;
+    delete[] fProxyURLSuffix;
+}
+
+#define DELAY_USECS_AFTER_REGISTER_RESPONSE 100000 /*100ms*/
+
+void RTSPServer ::RTSPClientConnection::handleCmd_REGISTER(char const *cmd /*"REGISTER" or "DEREGISTER"*/, char const *url, char const *urlSuffix,
+                                                           char const *fullRequestStr, Boolean reuseConnection, Boolean deliverViaTCP,
+                                                           char const *proxyURLSuffix) {
+    char *responseStr;
+    if(fOurRTSPServer.weImplementREGISTER(cmd, proxyURLSuffix, responseStr)) {
+        // The "REGISTER"/"DEREGISTER" command - if we implement it - may require access control:
+        if(!authenticationOK(cmd, urlSuffix, fullRequestStr))
+            return;
+
+        // We implement the "REGISTER"/"DEREGISTER" command by first replying to it, then actually
+        // handling it (in a separate event-loop task, that will get called after the reply has
+        // been done).
+        // Hack: If we're going to reuse the command's connection for subsequent RTSP commands, then we
+        // delay the actual handling of the command slightly, to make it less likely that the first
+        // subsequent RTSP command (e.g., "DESCRIBE") will end up in the client's reponse buffer before
+        // the socket (at the far end) gets reused for RTSP command handling.
+        setRTSPResponse(responseStr == NULL ? "200 OK" : responseStr);
+        delete[] responseStr;
+
+        ParamsForREGISTER *registerParams = new ParamsForREGISTER(cmd, this, url, urlSuffix, reuseConnection, deliverViaTCP, proxyURLSuffix);
+        envir().taskScheduler().scheduleDelayedTask(reuseConnection ? DELAY_USECS_AFTER_REGISTER_RESPONSE : 0, (TaskFunc *)continueHandlingREGISTER,
+                                                    registerParams);
+        ++fScheduledDelayedTask;
+    }
+    else if(responseStr != NULL) {
+        setRTSPResponse(responseStr);
+        delete[] responseStr;
+    }
+    else {
+        handleCmd_notSupported();
+    }
+}
+
+// A special version of "parseTransportHeader()", used just for parsing the "Transport:" header in an incoming "REGISTER" command:
+void parseTransportHeaderForREGISTER(char const *buf, Boolean &reuseConnection, Boolean &deliverViaTCP, char *&proxyURLSuffix) {
+    // Initialize the result parameters to default values:
+    reuseConnection = False;
+    deliverViaTCP   = False;
+    proxyURLSuffix  = NULL;
+
+    // First, find "Transport:"
+    while(1) {
+        if(*buf == '\0')
+            return;  // not found
+        if(*buf == '\r' && *(buf + 1) == '\n' && *(buf + 2) == '\r')
+            return;  // end of the headers => not found
+        if(_strncasecmp(buf, "Transport:", 10) == 0)
+            break;
+        ++buf;
+    }
+
+    // Then, run through each of the fields, looking for ones we handle:
+    char const *fields = buf + 10;
+    while(*fields == ' ')
+        ++fields;
+    char *field = strDupSize(fields);
+    while(sscanf(fields, "%[^;\r\n]", field) == 1) {
+        if(strcmp(field, "reuse_connection") == 0) {
+            reuseConnection = True;
+        }
+        else if(_strncasecmp(field, "preferred_delivery_protocol=udp", 31) == 0) {
+            deliverViaTCP = False;
+        }
+        else if(_strncasecmp(field, "preferred_delivery_protocol=interleaved", 39) == 0) {
+            deliverViaTCP = True;
+        }
+        else if(_strncasecmp(field, "proxy_url_suffix=", 17) == 0) {
+            delete[] proxyURLSuffix;
+            proxyURLSuffix = strDup(field + 17);
+        }
+
+        fields += strlen(field);
+        while(*fields == ';' || *fields == ' ' || *fields == '\t')
+            ++fields;  // skip over separating ';' chars or whitespace
+        if(*fields == '\0' || *fields == '\r' || *fields == '\n')
+            break;
+    }
+    delete[] field;
+}
+
+void RTSPServer::RTSPClientConnection::continueHandlingREGISTER(ParamsForREGISTER *params) {
+    params->fOurConnection->continueHandlingREGISTER1(params);
+}
+
+void RTSPServer::RTSPClientConnection::continueHandlingREGISTER1(ParamsForREGISTER *params) {
+    --fScheduledDelayedTask;
+
+    // Reuse our socket if requested:
+    int socketNumToBackEndServer = params->fReuseConnection ? fClientOutputSocket : -1;
+
+    RTSPServer *ourServer = &fOurRTSPServer;  // copy the pointer now, in case we "delete this" below
+
+    if(socketNumToBackEndServer >= 0) {
+        // Because our socket will no longer be used by the server to handle incoming requests, we can now delete this
+        // "RTSPClientConnection" object.  We do this now, in case the "implementCmd_REGISTER()" call below would also end up
+        // deleting this.
+        fClientInputSocket = fClientOutputSocket = -1;  // so the socket doesn't get closed when we get deleted
+        delete this;
+    }
+    else if(!fIsActive && fRecursionCount <= 0 && fScheduledDelayedTask <= 0) {
+        delete this;
+    }
+
+    ourServer->implementCmd_REGISTER(params->fCmd, params->fURL, params->fURLSuffix, socketNumToBackEndServer, params->fDeliverViaTCP, params->fProxyURLSuffix);
+    delete params;
+}
+
+///////// RTSPServerWithREGISTERProxying implementation /////////
+
+RTSPServerWithREGISTERProxying *RTSPServerWithREGISTERProxying ::createNew(UsageEnvironment &env, Port ourPort, UserAuthenticationDatabase *authDatabase,
+                                                                           UserAuthenticationDatabase *authDatabaseForREGISTER, unsigned reclamationSeconds,
+                                                                           Boolean streamRTPOverTCP, int verbosityLevelForProxying, char const *backEndUsername,
+                                                                           char const *backEndPassword) {
+    int ourSocketIPv4 = setUpOurSocket(env, ourPort, AF_INET);
+    int ourSocketIPv6 = setUpOurSocket(env, ourPort, AF_INET6);
+    if(ourSocketIPv4 < 0 && ourSocketIPv6 < 0)
+        return NULL;
+
+    return new RTSPServerWithREGISTERProxying(env, ourSocketIPv4, ourSocketIPv6, ourPort, authDatabase, authDatabaseForREGISTER, reclamationSeconds,
+                                              streamRTPOverTCP, verbosityLevelForProxying, backEndUsername, backEndPassword);
+}
+
+RTSPServerWithREGISTERProxying ::RTSPServerWithREGISTERProxying(UsageEnvironment &env, int ourSocketIPv4, int ourSocketIPv6, Port ourPort,
+                                                                UserAuthenticationDatabase *authDatabase, UserAuthenticationDatabase *authDatabaseForREGISTER,
+                                                                unsigned reclamationSeconds, Boolean streamRTPOverTCP, int verbosityLevelForProxying,
+                                                                char const *backEndUsername, char const *backEndPassword)
+    : RTSPServer(env, ourSocketIPv4, ourSocketIPv6, ourPort, authDatabase, reclamationSeconds),
+      fStreamRTPOverTCP(streamRTPOverTCP),
+      fVerbosityLevelForProxying(verbosityLevelForProxying),
+      fRegisteredProxyCounter(0),
+      fAllowedCommandNames(NULL),
+      fAuthDBForREGISTER(authDatabaseForREGISTER),
+      fBackEndUsername(strDup(backEndUsername)),
+      fBackEndPassword(strDup(backEndPassword)) {}
+
+RTSPServerWithREGISTERProxying::~RTSPServerWithREGISTERProxying() {
+    delete[] fAllowedCommandNames;
+    delete[] fBackEndUsername;
+    delete[] fBackEndPassword;
+}
+
+char const *RTSPServerWithREGISTERProxying::allowedCommandNames() {
+    if(fAllowedCommandNames == NULL) {
+        char const *baseAllowedCommandNames = RTSPServer::allowedCommandNames();
+        char const *newAllowedCommandName   = ", REGISTER, DEREGISTER";
+        fAllowedCommandNames                = new char[strlen(baseAllowedCommandNames) + strlen(newAllowedCommandName) + 1 /* for '\0' */];
+        sprintf(fAllowedCommandNames, "%s%s", baseAllowedCommandNames, newAllowedCommandName);
+    }
+    return fAllowedCommandNames;
+}
+
+Boolean RTSPServerWithREGISTERProxying ::weImplementREGISTER(char const *cmd /*"REGISTER" or "DEREGISTER"*/, char const *proxyURLSuffix, char *&responseStr) {
+    // First, check whether we have already proxied a stream as "proxyURLSuffix":
+    if(proxyURLSuffix != NULL) {
+        ServerMediaSession *sms = getServerMediaSession(proxyURLSuffix);
+        if((strcmp(cmd, "REGISTER") == 0 && sms != NULL) || (strcmp(cmd, "DEREGISTER") == 0 && sms == NULL)) {
+            responseStr = strDup("451 Invalid parameter");
+            return False;
+        }
+    }
+
+    // Otherwise, we will implement it:
+    responseStr = NULL;
+    return True;
+}
+
+void RTSPServerWithREGISTERProxying ::implementCmd_REGISTER(char const *cmd /*"REGISTER" or "DEREGISTER"*/, char const *url, char const * /*urlSuffix*/,
+                                                            int socketToRemoteServer, Boolean deliverViaTCP, char const *proxyURLSuffix) {
+    // Continue setting up proxying for the specified URL.
+    // By default:
+    //    - We use "registeredProxyStream-N" as the (front-end) stream name (ignoring the back-end stream's 'urlSuffix'),
+    //      unless "proxyURLSuffix" is non-NULL (in which case we use that)
+    //    - There is no 'username' and 'password' for the back-end stream.  (Thus, access-controlled back-end streams will fail.)
+    //    - If "fStreamRTPOverTCP" is True, then we request delivery over TCP, regardless of the value of "deliverViaTCP".
+    //      (Otherwise, if "fStreamRTPOverTCP" is False, we use the value of "deliverViaTCP" to decide this.)
+    // To change this default behavior, you will need to subclass "RTSPServerWithREGISTERProxying", and reimplement this function.
+
+    char const *proxyStreamName;
+    char        proxyStreamNameBuf[100];
+    if(proxyURLSuffix == NULL) {
+        sprintf(proxyStreamNameBuf, "registeredProxyStream-%u", ++fRegisteredProxyCounter);
+        proxyStreamName = proxyStreamNameBuf;
+    }
+    else {
+        proxyStreamName = proxyURLSuffix;
+    }
+
+    if(strcmp(cmd, "REGISTER") == 0) {
+        if(fStreamRTPOverTCP)
+            deliverViaTCP = True;
+        portNumBits tunnelOverHTTPPortNum = deliverViaTCP ? (portNumBits)(~0) : 0;
+        // We don't support streaming from the back-end via RTSP/RTP/RTCP-over-HTTP; only via RTP/RTCP-over-TCP or RTP/RTCP-over-UDP
+
+        ServerMediaSession *sms = ProxyServerMediaSession::createNew(envir(), this, url, proxyStreamName, fBackEndUsername, fBackEndPassword,
+                                                                     tunnelOverHTTPPortNum, fVerbosityLevelForProxying, socketToRemoteServer);
+        addServerMediaSession(sms);
+
+        // (Regardless of the verbosity level) announce the fact that we're proxying this new stream, and the URL to use to access it:
+        char *proxyStreamURL = rtspURL(sms);
+        envir() << "Proxying the registered back-end stream \"" << url << "\".\n";
+        envir() << "\tPlay this stream using the URL: " << proxyStreamURL << "\n";
+        delete[] proxyStreamURL;
+    }
+    else {  // "DEREGISTER"
+        //    deleteServerMediaSession(lookupServerMediaSession(proxyStreamName));
+        lookupServerMediaSession(proxyStreamName, &GenericMediaServer::deleteServerMediaSession);
+    }
+}
+
+UserAuthenticationDatabase *RTSPServerWithREGISTERProxying::getAuthenticationDatabaseForCommand(char const *cmdName) {
+    if(strcmp(cmdName, "REGISTER") == 0)
+        return fAuthDBForREGISTER;
+
+    return RTSPServer::getAuthenticationDatabaseForCommand(cmdName);
+}
diff --git a/3rdparty/live555/src/liveMedia/RawVideoRTPSink.cpp b/3rdparty/live555/src/liveMedia/RawVideoRTPSink.cpp
new file mode 100644
index 00000000..24ccce4e
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/RawVideoRTPSink.cpp
@@ -0,0 +1,307 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// RTP sink for Raw video
+// Implementation
+
+#include "RawVideoRTPSink.hh"
+
+RawVideoRTPSink *RawVideoRTPSink ::createNew(UsageEnvironment &env, Groupsock *RTPgs, u_int8_t rtpPayloadFormat, unsigned width, unsigned height,
+                                             unsigned depth, char const *sampling, char const *colorimetry) {
+    if(sampling == NULL || colorimetry == NULL)
+        return NULL;
+
+    return new RawVideoRTPSink(env, RTPgs, rtpPayloadFormat, width, height, depth, sampling, colorimetry);
+}
+
+RawVideoRTPSink ::RawVideoRTPSink(UsageEnvironment &env, Groupsock *RTPgs, u_int8_t rtpPayloadFormat, unsigned width, unsigned height, unsigned depth,
+                                  char const *sampling, char const *colorimetry)
+    : VideoRTPSink(env, RTPgs, rtpPayloadFormat, 90000, "RAW"), fLineIndex(0), fP(width, height, depth, sampling) {
+
+    // Construct our "a=fmtp:" SDP line:
+    // ASSERT: sampling != NULL && colorimetry != NULL
+    unsigned const fmtpSDPLineMaxSize = 200 + strlen(sampling) + strlen(colorimetry);  // more than enough space
+    fFmtpSDPLine                      = new char[fmtpSDPLineMaxSize];
+    sprintf(fFmtpSDPLine, "a=fmtp:%d sampling=%s;width=%u;height=%u;depth=%u;colorimetry=%s\r\n", rtpPayloadType(), sampling, width, height, depth,
+            colorimetry);
+}
+
+RawVideoRTPSink::~RawVideoRTPSink() {
+    delete[] fFmtpSDPLine;
+}
+
+char const *RawVideoRTPSink::auxSDPLine() {
+    return fFmtpSDPLine;
+}
+
+void RawVideoRTPSink ::doSpecialFrameHandling(unsigned fragmentationOffset, unsigned char *frameStart, unsigned numBytesInFrame,
+                                              struct timeval framePresentationTime, unsigned numRemainingBytes) {
+    u_int16_t *lengths;
+    u_int16_t *offsets;
+    unsigned   numLines          = getNumLinesInPacket(fragmentationOffset, lengths, offsets);
+    unsigned   specialHeaderSize = 2 + (6 * numLines);
+    u_int8_t * specialHeader     = new u_int8_t[specialHeaderSize];
+
+    // Extended Sequence Number (not used)
+    specialHeader[0] = specialHeader[1] = 0;
+
+    unsigned index = 2;
+    for(unsigned i = 0; i < numLines; ++i) {
+        // Increment line number if necessary:
+        if((offsets[i] == 0) && fragmentationOffset != 0) {
+            fLineIndex += fP.scanLineIterationStep;
+        }
+
+        // Set length:
+        specialHeader[index++] = lengths[i] >> 8;
+        specialHeader[index++] = (u_int8_t)lengths[i];
+
+        // Set field+line index:
+        u_int8_t const fieldIdent = 0;  // we assume non-interlaced video
+        specialHeader[index++]    = ((fLineIndex >> 8) & 0x7F) | (fieldIdent << 7);
+        specialHeader[index++]    = (u_int8_t)fLineIndex;
+
+        // Set continuation+offset:
+        u_int8_t const continuationBit = i < numLines - 1;
+        specialHeader[index++]         = ((offsets[i] >> 8) & 0x7F) | (continuationBit << 7);
+        specialHeader[index++]         = (u_int8_t)offsets[i];
+    }
+
+    setSpecialHeaderBytes(specialHeader, specialHeaderSize);
+
+    if(numRemainingBytes == 0) {
+        // This packet contains the last (or only) fragment of the frame.
+        // Set the RTP 'M' ('marker') bit:
+        setMarkerBit();
+        // Reset line index
+        fLineIndex = 0;
+    }
+
+    // Also set the RTP timestamp:
+    setTimestamp(framePresentationTime);
+
+    delete[] specialHeader;
+    delete[] lengths;
+    delete[] offsets;
+}
+
+Boolean RawVideoRTPSink::frameCanAppearAfterPacketStart(unsigned char const * /*frameStart*/, unsigned /*numBytesInFrame*/) const {
+    // Only one frame per packet:
+    return False;
+}
+
+unsigned RawVideoRTPSink::specialHeaderSize() const {
+    u_int16_t *lengths;
+    u_int16_t *offsets;
+    unsigned   numLines = getNumLinesInPacket(curFragmentationOffset(), lengths, offsets);
+    delete[] lengths;
+    delete[] offsets;
+    return 2 + (6 * numLines);
+}
+
+unsigned RawVideoRTPSink ::getNumLinesInPacket(unsigned fragOffset, u_int16_t *&lengths, u_int16_t *&offsets) const {
+    lengths = offsets = NULL;  // initially
+
+    unsigned const rtpHeaderSize     = 12;
+    unsigned       specialHeaderSize = 2;  // Extended Sequence Number
+    unsigned const packetMaxSize     = ourMaxPacketSize();
+    unsigned       numLines          = 0;
+    unsigned       remainingSizeInPacket;
+
+    if(fragOffset >= fP.frameSize) {
+        envir() << "RawVideoRTPSink::getNumLinesInPacket(): bad fragOffset " << fragOffset << "\n";
+        return 0;
+    }
+
+#define MAX_LINES_IN_PACKET 100
+    u_int16_t lengthArray[MAX_LINES_IN_PACKET] = { 0 };
+    u_int16_t offsetArray[MAX_LINES_IN_PACKET] = { 0 };
+    unsigned  curDataTotalLength               = 0;
+    unsigned  offsetWithinLine                 = fragOffset % fP.scanLineSize;
+    unsigned  remainingLineSize                = fP.scanLineSize - offsetWithinLine;
+
+    while(1) {
+        if(packetMaxSize - specialHeaderSize - rtpHeaderSize - 6 <= curDataTotalLength) {
+            break;  // packet sanity check
+        }
+
+        // add one line
+        if(++numLines > MAX_LINES_IN_PACKET)
+            return 0;
+        specialHeaderSize += 6;
+
+        remainingSizeInPacket = packetMaxSize - specialHeaderSize - rtpHeaderSize - curDataTotalLength;
+        remainingSizeInPacket -= remainingSizeInPacket % fP.pgroupSize;  // use only multiple of pgroup
+        lengthArray[numLines - 1] = remainingLineSize < remainingSizeInPacket ? remainingLineSize : remainingSizeInPacket;
+        offsetArray[numLines - 1] = (offsetWithinLine * fP.numPixelsInPgroup) / fP.pgroupSize;
+        // Note that the offsets are in specified to be in pixels (not octets, nor pgroups)
+        if(remainingLineSize >= remainingSizeInPacket) {
+            break;  // packet is full
+        }
+
+        // All subsequent lines in the packet will have offset 0
+        curDataTotalLength += lengthArray[numLines - 1];
+        offsetWithinLine  = 0;
+        remainingLineSize = fP.scanLineSize;
+
+        if(fragOffset + curDataTotalLength >= fP.frameSize) {
+            break;  // end of the frame.
+        }
+    }
+
+    lengths = new u_int16_t[numLines];
+    offsets = new u_int16_t[numLines];
+    for(unsigned i = 0; i < numLines; i++) {
+        lengths[i] = lengthArray[i];
+        offsets[i] = offsetArray[i];
+    }
+
+    return numLines;
+}
+
+unsigned RawVideoRTPSink::computeOverflowForNewFrame(unsigned newFrameSize) const {
+    unsigned initialOverflow = MultiFramedRTPSink::computeOverflowForNewFrame(newFrameSize);
+
+    // Adjust (increase) this overflow to be a multiple of the pgroup value:
+    unsigned numFrameBytesUsed = newFrameSize - initialOverflow;
+    initialOverflow += numFrameBytesUsed % fP.pgroupSize;
+
+    return initialOverflow;
+}
+
+///////// RawVideoFrameParameters implementation /////////
+
+RawVideoFrameParameters ::RawVideoFrameParameters(unsigned width, unsigned height, unsigned depth, char const *sampling) {
+    scanLineIterationStep = 1;  // by default; different for YCbCr-4:2:0
+    numPixelsInPgroup     = 1;  // by default
+    pgroupSize            = 2;  // use this for unknown (sampling, depth)s
+
+    if(strcmp(sampling, "RGB") == 0 || strcmp(sampling, "BGR") == 0) {
+        switch(depth) {
+        case 8:
+            pgroupSize = 3;
+            break;
+        case 10:
+            pgroupSize        = 15;
+            numPixelsInPgroup = 4;
+            break;
+        case 12:
+            pgroupSize        = 9;
+            numPixelsInPgroup = 2;
+            break;
+        case 16:
+            pgroupSize = 6;
+            break;
+        }
+    }
+    else if(strcmp(sampling, "RGBA") == 0 || strcmp(sampling, "BGRA") == 0) {
+        switch(depth) {
+        case 8:
+            pgroupSize = 4;
+            break;
+        case 10:
+            pgroupSize = 5;
+            break;
+        case 12:
+            pgroupSize = 6;
+            break;
+        case 16:
+            pgroupSize = 8;
+            break;
+        }
+    }
+    else if(strcmp(sampling, "YCbCr-4:4:4") == 0) {
+        switch(depth) {
+        case 8:
+            pgroupSize = 3;
+            break;
+        case 10:
+            pgroupSize        = 15;
+            numPixelsInPgroup = 4;
+            break;
+        case 12:
+            pgroupSize        = 9;
+            numPixelsInPgroup = 2;
+            break;
+        case 16:
+            pgroupSize = 6;
+            break;
+        }
+    }
+    else if(strcmp(sampling, "YCbCr-4:2:2") == 0) {
+        switch(depth) {
+        case 8:
+            pgroupSize = 4;
+            break;
+        case 10:
+            pgroupSize = 5;
+            break;
+        case 12:
+            pgroupSize = 6;
+            break;
+        case 16:
+            pgroupSize = 8;
+            break;
+        }
+        numPixelsInPgroup = 2;
+    }
+    else if(strcmp(sampling, "YCbCr-4:1:1") == 0) {
+        switch(depth) {
+        case 8:
+            pgroupSize = 6;
+            break;
+        case 10:
+            pgroupSize = 15;
+            break;
+        case 12:
+            pgroupSize = 9;
+            break;
+        case 16:
+            pgroupSize = 12;
+            break;
+        }
+        numPixelsInPgroup = 4;
+    }
+    else if(strcmp(sampling, "YCbCr-4:2:0") == 0) {
+        switch(depth) {
+        case 8:
+            pgroupSize = 6;
+            break;
+        case 10:
+            pgroupSize = 15;
+            break;
+        case 12:
+            pgroupSize = 9;
+            break;
+        case 16:
+            pgroupSize = 12;
+            break;
+        }
+        numPixelsInPgroup     = 4;
+        scanLineIterationStep = 2;
+    }
+
+    unsigned const numPgroupsPerScanLine = (width * scanLineIterationStep + (numPixelsInPgroup - 1)) / numPixelsInPgroup;
+    // Note: This rounds up to the next 'pgroup'; see RFC 4175, section 4.3, paragraph 2
+
+    scanLineSize = numPgroupsPerScanLine * pgroupSize;
+    // Note: This is actually the size of 'scanLineIterationStep' scan lines
+
+    frameSize = (height * scanLineSize) / scanLineIterationStep;
+}
+
+RawVideoFrameParameters::~RawVideoFrameParameters() {}
diff --git a/3rdparty/live555/src/liveMedia/RawVideoRTPSource.cpp b/3rdparty/live555/src/liveMedia/RawVideoRTPSource.cpp
new file mode 100644
index 00000000..490f3933
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/RawVideoRTPSource.cpp
@@ -0,0 +1,172 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// Raw Video RTP Sources (RFC 4175)
+// Implementation
+
+#include "RawVideoRTPSource.hh"
+
+////////// RawVideoBufferedPacket and RawVideoBufferedPacketFactory //////////
+
+class RawVideoBufferedPacket : public BufferedPacket {
+public:
+    RawVideoBufferedPacket(RawVideoRTPSource *ourSource);
+    virtual ~RawVideoBufferedPacket();
+
+private:  // redefined virtual functions
+    virtual void getNextEnclosedFrameParameters(unsigned char *&framePtr, unsigned dataSize, unsigned &frameSize, unsigned &frameDurationInMicroseconds);
+
+private:
+    RawVideoRTPSource *fOurSource;
+};
+
+class RawVideoBufferedPacketFactory : public BufferedPacketFactory {
+private:  // redefined virtual functions
+    virtual BufferedPacket *createNewPacket(MultiFramedRTPSource *ourSource);
+};
+
+////////// LineHeader //////////
+
+struct LineHeader {
+    u_int16_t length;
+    u_int16_t fieldIdAndLineNumber;
+    u_int16_t offsetWithinLine;
+};
+
+///////// RawVideoRTPSource implementation (RFC 4175) ////////
+
+RawVideoRTPSource *RawVideoRTPSource::createNew(UsageEnvironment &env, Groupsock *RTPgs, unsigned char rtpPayloadFormat, unsigned rtpTimestampFrequency) {
+    return new RawVideoRTPSource(env, RTPgs, rtpPayloadFormat, rtpTimestampFrequency);
+}
+
+RawVideoRTPSource ::RawVideoRTPSource(UsageEnvironment &env, Groupsock *RTPgs, unsigned char rtpPayloadFormat, unsigned rtpTimestampFrequency)
+    : MultiFramedRTPSource(env, RTPgs, rtpPayloadFormat, rtpTimestampFrequency, new RawVideoBufferedPacketFactory),
+      fNumLines(0),
+      fNextLine(0),
+      fLineHeaders(NULL) {}
+
+RawVideoRTPSource::~RawVideoRTPSource() {
+    delete[] fLineHeaders;
+}
+
+u_int16_t RawVideoRTPSource::currentLineNumber() const {
+    if(fNextLine == 0 || fLineHeaders == NULL)
+        return 0;  // we've called this function too soon!
+    return fLineHeaders[fNextLine - 1].fieldIdAndLineNumber & 0x7FFF;
+}
+
+u_int8_t RawVideoRTPSource::currentLineFieldId() const {
+    if(fNextLine == 0 || fLineHeaders == NULL)
+        return 0;  // we've called this function too soon!
+    return (fLineHeaders[fNextLine - 1].fieldIdAndLineNumber & 0x8000) >> 15;
+}
+
+u_int16_t RawVideoRTPSource::currentOffsetWithinLine() const {
+    if(fNextLine == 0 || fLineHeaders == NULL)
+        return 0;  // we've called this function too soon!
+    return fLineHeaders[fNextLine - 1].offsetWithinLine;
+}
+
+Boolean RawVideoRTPSource ::processSpecialHeader(BufferedPacket *packet, unsigned &resultSpecialHeaderSize) {
+
+    unsigned char *headerStart = packet->data();
+    unsigned       packetSize  = packet->dataSize();
+
+    // The first 2 bytes of the header are the "Extended Sequence Number".
+    // In the current implementation, we ignore this.
+    if(packetSize < 2)
+        return False;
+    headerStart += 2;
+    unsigned char *lineHeaderStart = headerStart;
+    packetSize -= 2;
+
+    // The rest of the header should consist of N*6 bytes (with N >= 1) for each line included.
+    // Count how many of these there are:
+    unsigned numLines = 0;
+    while(1) {
+        if(packetSize < 6)
+            return False;  // there's not enough room for another line header
+        ++numLines;
+        Boolean continuationBit = (headerStart[4] & 0x80) >> 7;
+        headerStart += 6;
+        packetSize -= 6;
+
+        // Check the "C" (continuation) bit of this header to see whether any more line headers follow:
+        if(continuationBit == 0)
+            break;  // no more line headers follow
+    }
+
+    // We now know how many lines are contained in this payload.  Allocate and fill in "fLineHeaders":
+    fNumLines = numLines;  // ASSERT: >= 1
+    fNextLine = 0;
+    delete[] fLineHeaders;
+    fLineHeaders         = new LineHeader[fNumLines];
+    unsigned totalLength = 0;
+    for(unsigned i = 0; i < fNumLines; ++i) {
+        fLineHeaders[i].length = (lineHeaderStart[0] << 8) + lineHeaderStart[1];
+        totalLength += fLineHeaders[i].length;
+        fLineHeaders[i].fieldIdAndLineNumber = (lineHeaderStart[2] << 8) + lineHeaderStart[3];
+        fLineHeaders[i].offsetWithinLine     = ((lineHeaderStart[4] & 0x7F) << 8) + lineHeaderStart[5];
+        lineHeaderStart += 6;
+    }
+
+    // Make sure that we have enough bytes for all of the line lengths promised:
+    if(totalLength > packetSize) {
+        fNumLines = 0;
+        delete[] fLineHeaders;
+        fLineHeaders = NULL;
+        return False;
+    }
+
+    // Everything looks good:
+    fCurrentPacketBeginsFrame = (fLineHeaders[0].fieldIdAndLineNumber & 0x7FFF) == 0 && fLineHeaders[0].offsetWithinLine == 0;
+    // Don't set "fCurrentPacketCompletesFrame" until we've processed the last line in the packet
+    resultSpecialHeaderSize = headerStart - packet->data();
+    return True;
+}
+
+char const *RawVideoRTPSource::MIMEtype() const {
+    return "video/RAW";
+}
+
+////////// RawVideoBufferedPacket and RawVideoBufferedPacketFactory implementation //////////
+
+RawVideoBufferedPacket ::RawVideoBufferedPacket(RawVideoRTPSource *ourSource) : fOurSource(ourSource) {}
+
+RawVideoBufferedPacket::~RawVideoBufferedPacket() {}
+
+void RawVideoBufferedPacket::getNextEnclosedFrameParameters(unsigned char *& /*framePtr*/, unsigned dataSize, unsigned &frameSize,
+                                                            unsigned &frameDurationInMicroseconds) {
+    frameDurationInMicroseconds = 0;  // because all lines within the same packet are from the same frame
+
+    if(fOurSource->fNextLine >= fOurSource->fNumLines) {
+        fOurSource->envir() << "RawVideoBufferedPacket::nextEnclosedFrameParameters(" << dataSize << "): data error (" << fOurSource->fNextLine
+                            << " >= " << fOurSource->fNumLines << ")!\n";
+        frameSize = dataSize;
+        return;
+    }
+
+    // This line ('subframe') completes a frame if it's the last line in the packet,
+    // and the packet's 'M' bit was set:
+    fOurSource->fCurrentPacketCompletesFrame = fOurSource->fCurPacketMarkerBit && fOurSource->fNextLine == fOurSource->fNumLines - 1;
+
+    frameSize = fOurSource->fLineHeaders[fOurSource->fNextLine++].length;
+}
+
+BufferedPacket *RawVideoBufferedPacketFactory ::createNewPacket(MultiFramedRTPSource *ourSource) {
+    return new RawVideoBufferedPacket((RawVideoRTPSource *)ourSource);
+}
diff --git a/3rdparty/live555/src/liveMedia/SIPClient.cpp b/3rdparty/live555/src/liveMedia/SIPClient.cpp
new file mode 100644
index 00000000..b63f0cbb
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/SIPClient.cpp
@@ -0,0 +1,938 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A generic SIP client
+// Implementation
+
+#include "SIPClient.hh"
+#include "GroupsockHelper.hh"
+
+#if defined(__WIN32__) || defined(_WIN32) || defined(_QNX4)
+#define _strncasecmp _strnicmp
+#else
+#define _strncasecmp strncasecmp
+#endif
+
+////////// SIPClient //////////
+
+SIPClient *SIPClient ::createNew(UsageEnvironment &env, unsigned char desiredAudioRTPPayloadFormat, char const *mimeSubtype, int verbosityLevel,
+                                 char const *applicationName) {
+    return new SIPClient(env, desiredAudioRTPPayloadFormat, mimeSubtype, verbosityLevel, applicationName);
+}
+
+void SIPClient::setUserAgentString(char const *userAgentName) {
+    if(userAgentName == NULL)
+        return;
+
+    // Change the existing user agent header string:
+    char const *const formatStr  = "User-Agent: %s\r\n";
+    unsigned const    headerSize = strlen(formatStr) + strlen(userAgentName);
+    delete[] fUserAgentHeaderStr;
+    fUserAgentHeaderStr = new char[headerSize];
+    sprintf(fUserAgentHeaderStr, formatStr, userAgentName);
+    fUserAgentHeaderStrLen = strlen(fUserAgentHeaderStr);
+}
+
+SIPClient::SIPClient(UsageEnvironment &env, unsigned char desiredAudioRTPPayloadFormat, char const *mimeSubtype, int verbosityLevel,
+                     char const *applicationName)
+    : Medium(env),
+      fT1(500000 /* 500 ms */),
+      fDesiredAudioRTPPayloadFormat(desiredAudioRTPPayloadFormat),
+      fVerbosityLevel(verbosityLevel),
+      fCSeq(0),
+      fUserAgentHeaderStr(NULL),
+      fUserAgentHeaderStrLen(0),
+      fURL(NULL),
+      fURLSize(0),
+      fToTagStr(NULL),
+      fToTagStrSize(0),
+      fUserName(NULL),
+      fUserNameSize(0),
+      fInviteSDPDescription(NULL),
+      fInviteSDPDescriptionReturned(NULL),
+      fInviteCmd(NULL),
+      fInviteCmdSize(0) {
+    if(mimeSubtype == NULL)
+        mimeSubtype = "";
+    fMIMESubtype     = strDup(mimeSubtype);
+    fMIMESubtypeSize = strlen(fMIMESubtype);
+
+    if(applicationName == NULL)
+        applicationName = "";
+    fApplicationName     = strDup(applicationName);
+    fApplicationNameSize = strlen(fApplicationName);
+
+    struct sockaddr_storage ourAddress;
+    ourAddress.ss_family                               = AF_INET;  // Later, fix to support IPv6
+    ((struct sockaddr_in &)ourAddress).sin_addr.s_addr = ourIPv4Address(env);
+    fOurAddressStr                                     = strDup(AddressString(ourAddress).val());
+    fOurAddressStrSize                                 = strlen(fOurAddressStr);
+
+    fOurSocket = new Groupsock(env, ourAddress, 0, 255);
+    if(fOurSocket == NULL) {
+        env << "ERROR: Failed to create socket for addr " << fOurAddressStr << ": " << env.getResultMsg() << "\n";
+    }
+
+    // Now, find out our source port number.  Hack: Do this by first trying to
+    // send a 0-length packet, so that the "getSourcePort()" call will work.
+    fOurSocket->output(envir(), (unsigned char *)"", 0);
+    Port srcPort(0);
+    getSourcePort(env, fOurSocket->socketNum(), AF_INET, srcPort);  // later, allow for IPv6
+    if(srcPort.num() != 0) {
+        fOurPortNum = ntohs(srcPort.num());
+    }
+    else {
+        // No luck.  Try again using a default port number:
+        fOurPortNum = 5060;
+        delete fOurSocket;
+        fOurSocket = new Groupsock(env, ourAddress, fOurPortNum, 255);
+        if(fOurSocket == NULL) {
+            env << "ERROR: Failed to create socket for addr " << fOurAddressStr << ", port " << fOurPortNum << ": " << env.getResultMsg() << "\n";
+        }
+    }
+
+    // Set the "User-Agent:" header to use in each request:
+    char const *const libName       = "LIVE555 Streaming Media v";
+    char const *const libVersionStr = LIVEMEDIA_LIBRARY_VERSION_STRING;
+    char const *      libPrefix;
+    char const *      libSuffix;
+    if(applicationName == NULL || applicationName[0] == '\0') {
+        applicationName = libPrefix = libSuffix = "";
+    }
+    else {
+        libPrefix = " (";
+        libSuffix = ")";
+    }
+    unsigned userAgentNameSize = fApplicationNameSize + strlen(libPrefix) + strlen(libName) + strlen(libVersionStr) + strlen(libSuffix) + 1;
+    char *   userAgentName     = new char[userAgentNameSize];
+    sprintf(userAgentName, "%s%s%s%s%s", applicationName, libPrefix, libName, libVersionStr, libSuffix);
+    setUserAgentString(userAgentName);
+    delete[] userAgentName;
+
+    reset();
+}
+
+SIPClient::~SIPClient() {
+    reset();
+
+    delete[] fUserAgentHeaderStr;
+    delete fOurSocket;
+    delete[](char *) fOurAddressStr;
+    delete[](char *) fApplicationName;
+    delete[](char *) fMIMESubtype;
+}
+
+void SIPClient::reset() {
+    fWorkingAuthenticator = NULL;
+    delete[] fInviteCmd;
+    fInviteCmd     = NULL;
+    fInviteCmdSize = 0;
+    delete[] fInviteSDPDescription;
+    fInviteSDPDescription = NULL;
+
+    delete[](char *) fUserName;
+    fUserName     = strDup(fApplicationName);
+    fUserNameSize = strlen(fUserName);
+
+    fValidAuthenticator.reset();
+
+    delete[](char *) fToTagStr;
+    fToTagStr           = NULL;
+    fToTagStrSize       = 0;
+    fServerPortNum      = 0;
+    fServerAddressIsSet = False;
+    delete[](char *) fURL;
+    fURL     = NULL;
+    fURLSize = 0;
+}
+
+void SIPClient::setProxyServer(struct sockaddr_storage const &proxyServerAddress, portNumBits proxyServerPortNum) {
+    fServerAddress      = proxyServerAddress;
+    fServerAddressIsSet = True;
+
+    fServerPortNum = proxyServerPortNum;
+
+    if(fOurSocket != NULL) {
+        fOurSocket->changeDestinationParameters(fServerAddress, fServerPortNum, 255);
+    }
+}
+
+static char *getLine(char *startOfLine) {
+    // returns the start of the next line, or NULL if none
+    for(char *ptr = startOfLine; *ptr != '\0'; ++ptr) {
+        if(*ptr == '\r' || *ptr == '\n') {
+            // We found the end of the line
+            *ptr++ = '\0';
+            if(*ptr == '\n')
+                ++ptr;
+            return ptr;
+        }
+    }
+
+    return NULL;
+}
+
+char *SIPClient::invite(char const *url, Authenticator *authenticator) {
+    // First, check whether "url" contains a username:password to be used:
+    char *username;
+    char *password;
+    if(authenticator == NULL && parseSIPURLUsernamePassword(url, username, password)) {
+        char *result = inviteWithPassword(url, username, password);
+        delete[] username;
+        delete[] password;  // they were dynamically allocated
+        return result;
+    }
+
+    if(!processURL(url))
+        return NULL;
+
+    delete[](char *) fURL;
+    fURL     = strDup(url);
+    fURLSize = strlen(fURL);
+
+    fCallId  = our_random32();
+    fFromTag = our_random32();
+
+    return invite1(authenticator);
+}
+
+char *SIPClient::invite1(Authenticator *authenticator) {
+    do {
+        // Send the INVITE command:
+
+        // First, construct an authenticator string:
+        fValidAuthenticator.reset();
+        fWorkingAuthenticator  = authenticator;
+        char *authenticatorStr = createAuthenticatorString(fWorkingAuthenticator, "INVITE", fURL);
+
+        // Then, construct the SDP description to be sent in the INVITE:
+        char *   rtpmapLine;
+        unsigned rtpmapLineSize;
+        if(fMIMESubtypeSize > 0) {
+            char const *const rtpmapFmt     = "a=rtpmap:%u %s/8000\r\n";
+            unsigned          rtpmapFmtSize = strlen(rtpmapFmt) + 3 /* max char len */ + fMIMESubtypeSize;
+            rtpmapLine                      = new char[rtpmapFmtSize];
+            sprintf(rtpmapLine, rtpmapFmt, fDesiredAudioRTPPayloadFormat, fMIMESubtype);
+            rtpmapLineSize = strlen(rtpmapLine);
+        }
+        else {
+            // Static payload type => no "a=rtpmap:" line
+            rtpmapLine     = strDup("");
+            rtpmapLineSize = 0;
+        }
+        char const *const inviteSDPFmt = "v=0\r\n"
+                                         "o=- %u %u IN IP4 %s\r\n"
+                                         // Later, use "IP6" if our address is IPv6-only
+                                         "s=%s session\r\n"
+                                         "c=IN IP4 %s\r\n"
+                                         // Later, use "IP6" if our address is IPv6-only
+                                         "t=0 0\r\n"
+                                         "m=audio %u RTP/AVP %u\r\n"
+                                         "%s";
+        unsigned inviteSDPFmtSize = strlen(inviteSDPFmt) + 20 /* max int len */ + 20 + fOurAddressStrSize + fApplicationNameSize + fOurAddressStrSize
+                                    + 5 /* max short len */ + 3 /* max char len */
+                                    + rtpmapLineSize;
+        delete[] fInviteSDPDescription;
+        fInviteSDPDescription = new char[inviteSDPFmtSize];
+        sprintf(fInviteSDPDescription, inviteSDPFmt, fCallId, fCSeq, fOurAddressStr, fApplicationName, fOurAddressStr, fClientStartPortNum,
+                fDesiredAudioRTPPayloadFormat, rtpmapLine);
+        unsigned inviteSDPSize = strlen(fInviteSDPDescription);
+        delete[] rtpmapLine;
+
+        char const *const cmdFmt = "INVITE %s SIP/2.0\r\n"
+                                   "From: %s <sip:%s@%s>;tag=%u\r\n"
+                                   "Via: SIP/2.0/UDP %s:%u\r\n"
+                                   "Max-Forwards: 70\r\n"
+                                   "To: %s\r\n"
+                                   "Contact: sip:%s@%s:%u\r\n"
+                                   "Call-ID: %u@%s\r\n"
+                                   "CSeq: %d INVITE\r\n"
+                                   "Content-Type: application/sdp\r\n"
+                                   "%s" /* Proxy-Authorization: line (if any) */
+                                   "%s" /* User-Agent: line */
+                                   "Content-Length: %d\r\n\r\n"
+                                   "%s";
+        unsigned inviteCmdSize = strlen(cmdFmt) + fURLSize + 2 * fUserNameSize + fOurAddressStrSize + 20 /* max int len */
+                                 + fOurAddressStrSize + 5                                                /* max port len */
+                                 + fURLSize + fUserNameSize + fOurAddressStrSize + 5 + 20 + fOurAddressStrSize + 20 + strlen(authenticatorStr)
+                                 + fUserAgentHeaderStrLen + 20 + inviteSDPSize;
+        delete[] fInviteCmd;
+        fInviteCmd = new char[inviteCmdSize];
+        sprintf(fInviteCmd, cmdFmt, fURL, fUserName, fUserName, fOurAddressStr, fFromTag, fOurAddressStr, fOurPortNum, fURL, fUserName, fOurAddressStr,
+                fOurPortNum, fCallId, fOurAddressStr, ++fCSeq, authenticatorStr, fUserAgentHeaderStr, inviteSDPSize, fInviteSDPDescription);
+        fInviteCmdSize = strlen(fInviteCmd);
+        delete[] authenticatorStr;
+
+        // Before sending the "INVITE", arrange to handle any response packets,
+        // and set up timers:
+        fInviteClientState   = Calling;
+        fEventLoopStopFlag   = 0;
+        TaskScheduler &sched = envir().taskScheduler();  // abbrev.
+        sched.turnOnBackgroundReadHandling(fOurSocket->socketNum(), &inviteResponseHandler, this);
+        fTimerALen   = 1 * fT1;  // initially
+        fTimerACount = 0;        // initially
+        fTimerA      = sched.scheduleDelayedTask(fTimerALen, timerAHandler, this);
+        fTimerB      = sched.scheduleDelayedTask(64 * fT1, timerBHandler, this);
+        fTimerD      = NULL;  // for now
+
+        if(!sendINVITE())
+            break;
+
+        // Enter the event loop, to handle response packets, and timeouts:
+        envir().taskScheduler().doEventLoop(&fEventLoopStopFlag);
+
+        // We're finished with this "INVITE".
+        // Turn off response handling and timers:
+        sched.turnOffBackgroundReadHandling(fOurSocket->socketNum());
+        sched.unscheduleDelayedTask(fTimerA);
+        sched.unscheduleDelayedTask(fTimerB);
+        sched.unscheduleDelayedTask(fTimerD);
+
+        // NOTE: We return the SDP description that we used in the "INVITE",
+        // not the one that we got from the server.
+        // ##### Later: match the codecs in the response (offer, answer) #####
+        if(fInviteSDPDescription != NULL) {
+            return strDup(fInviteSDPDescription);
+        }
+    } while(0);
+
+    return NULL;
+}
+
+void SIPClient::inviteResponseHandler(void *clientData, int /*mask*/) {
+    SIPClient *client       = (SIPClient *)clientData;
+    unsigned   responseCode = client->getResponseCode();
+    client->doInviteStateMachine(responseCode);
+}
+
+// Special 'response codes' that represent timers expiring:
+unsigned const timerAFires = 0xAAAAAAAA;
+unsigned const timerBFires = 0xBBBBBBBB;
+unsigned const timerDFires = 0xDDDDDDDD;
+
+void SIPClient::timerAHandler(void *clientData) {
+    SIPClient *client = (SIPClient *)clientData;
+    client->fTimerA   = NULL;
+    if(client->fVerbosityLevel >= 1) {
+        client->envir() << "RETRANSMISSION " << ++client->fTimerACount << ", after " << client->fTimerALen / 1000000.0 << " additional seconds\n";
+    }
+    client->doInviteStateMachine(timerAFires);
+}
+
+void SIPClient::timerBHandler(void *clientData) {
+    SIPClient *client = (SIPClient *)clientData;
+    client->fTimerB   = NULL;
+    if(client->fVerbosityLevel >= 1) {
+        client->envir() << "RETRANSMISSION TIMEOUT, after " << 64 * client->fT1 / 1000000.0 << " seconds\n";
+        fflush(stderr);
+    }
+    client->doInviteStateMachine(timerBFires);
+}
+
+void SIPClient::timerDHandler(void *clientData) {
+    SIPClient *client = (SIPClient *)clientData;
+    client->fTimerD   = NULL;
+    if(client->fVerbosityLevel >= 1) {
+        client->envir() << "TIMER D EXPIRED\n";
+    }
+    client->doInviteStateMachine(timerDFires);
+}
+
+void SIPClient::doInviteStateMachine(unsigned responseCode) {
+    // Implement the state transition diagram (RFC 3261, Figure 5)
+    TaskScheduler &sched = envir().taskScheduler();  // abbrev.
+    switch(fInviteClientState) {
+    case Calling: {
+        if(responseCode == timerAFires) {
+            // Restart timer A (with double the timeout interval):
+            fTimerALen *= 2;
+            fTimerA = sched.scheduleDelayedTask(fTimerALen, timerAHandler, this);
+
+            fInviteClientState = Calling;
+            if(!sendINVITE())
+                doInviteStateTerminated(0);
+        }
+        else {
+            // Turn off timers A & B before moving to a new state:
+            sched.unscheduleDelayedTask(fTimerA);
+            sched.unscheduleDelayedTask(fTimerB);
+
+            if(responseCode == timerBFires) {
+                envir().setResultMsg("No response from server");
+                doInviteStateTerminated(0);
+            }
+            else if(responseCode >= 100 && responseCode <= 199) {
+                fInviteClientState = Proceeding;
+            }
+            else if(responseCode >= 200 && responseCode <= 299) {
+                doInviteStateTerminated(responseCode);
+            }
+            else if(responseCode >= 400 && responseCode <= 499) {
+                doInviteStateTerminated(responseCode);
+                // this isn't what the spec says, but it seems right...
+            }
+            else if(responseCode >= 300 && responseCode <= 699) {
+                fInviteClientState = Completed;
+                fTimerD            = sched.scheduleDelayedTask(32000000, timerDHandler, this);
+                if(!sendACK())
+                    doInviteStateTerminated(0);
+            }
+        }
+        break;
+    }
+
+    case Proceeding: {
+        if(responseCode >= 100 && responseCode <= 199) {
+            fInviteClientState = Proceeding;
+        }
+        else if(responseCode >= 200 && responseCode <= 299) {
+            doInviteStateTerminated(responseCode);
+        }
+        else if(responseCode >= 400 && responseCode <= 499) {
+            doInviteStateTerminated(responseCode);
+            // this isn't what the spec says, but it seems right...
+        }
+        else if(responseCode >= 300 && responseCode <= 699) {
+            fInviteClientState = Completed;
+            fTimerD            = sched.scheduleDelayedTask(32000000, timerDHandler, this);
+            if(!sendACK())
+                doInviteStateTerminated(0);
+        }
+        break;
+    }
+
+    case Completed: {
+        if(responseCode == timerDFires) {
+            envir().setResultMsg("Transaction terminated");
+            doInviteStateTerminated(0);
+        }
+        else if(responseCode >= 300 && responseCode <= 699) {
+            fInviteClientState = Completed;
+            if(!sendACK())
+                doInviteStateTerminated(0);
+        }
+        break;
+    }
+
+    case Terminated: {
+        doInviteStateTerminated(responseCode);
+        break;
+    }
+    }
+}
+
+void SIPClient::doInviteStateTerminated(unsigned responseCode) {
+    fInviteClientState = Terminated;  // FWIW...
+    if(responseCode < 200 || responseCode > 299) {
+        // We failed, so return NULL;
+        delete[] fInviteSDPDescription;
+        fInviteSDPDescription = NULL;
+        delete[] fInviteSDPDescriptionReturned;
+        fInviteSDPDescriptionReturned = NULL;
+    }
+
+    // Unblock the event loop:
+    fEventLoopStopFlag = ~0;
+}
+
+Boolean SIPClient::sendINVITE() {
+    if(!sendRequest(fInviteCmd, fInviteCmdSize)) {
+        envir().setResultErrMsg("INVITE send() failed: ");
+        return False;
+    }
+    return True;
+}
+
+unsigned SIPClient::getResponseCode() {
+    unsigned responseCode = 0;
+    do {
+        // Get the response from the server:
+        unsigned const readBufSize = 10000;
+        char           readBuffer[readBufSize + 1];
+        char *         readBuf = readBuffer;
+
+        char *   firstLine     = NULL;
+        char *   nextLineStart = NULL;
+        unsigned bytesRead     = getResponse(readBuf, readBufSize);
+        if(bytesRead == 0)
+            break;
+        if(fVerbosityLevel >= 1) {
+            envir() << "Received INVITE response: " << readBuf << "\n";
+        }
+
+        // Inspect the first line to get the response code:
+        firstLine     = readBuf;
+        nextLineStart = getLine(firstLine);
+        if(!parseResponseCode(firstLine, responseCode))
+            break;
+
+        if(responseCode != 200) {
+            if(responseCode >= 400 && responseCode <= 499 && fWorkingAuthenticator != NULL) {
+                // We have an authentication failure, so fill in
+                // "*fWorkingAuthenticator" using the contents of a following
+                // "Proxy-Authenticate:" or "WWW-Authenticate:" line.  (Once we compute a 'response' for
+                // "fWorkingAuthenticator", it can be used in a subsequent request
+                // - that will hopefully succeed.)
+                char *lineStart;
+                while(1) {
+                    lineStart = nextLineStart;
+                    if(lineStart == NULL)
+                        break;
+
+                    nextLineStart = getLine(lineStart);
+                    if(lineStart[0] == '\0')
+                        break;  // this is a blank line
+
+                    char *realm = strDupSize(lineStart);
+                    char *nonce = strDupSize(lineStart);
+                    // ##### Check for the format of "Proxy-Authenticate:" lines from
+                    // ##### known server types.
+                    // ##### This is a crock! We should make the parsing more general
+                    Boolean foundAuthenticateHeader = False;
+                    if(
+                        // Asterisk #####
+                        sscanf(lineStart, "Proxy-Authenticate: Digest realm=\"%[^\"]\", nonce=\"%[^\"]\"", realm, nonce) == 2
+                        || sscanf(lineStart, "WWW-Authenticate: Digest realm=\"%[^\"]\", nonce=\"%[^\"]\"", realm, nonce) == 2 ||
+                        // Cisco ATA #####
+                        sscanf(lineStart, "Proxy-Authenticate: Digest algorithm=MD5,domain=\"%*[^\"]\",nonce=\"%[^\"]\", realm=\"%[^\"]\"", nonce, realm)
+                            == 2) {
+                        fWorkingAuthenticator->setRealmAndNonce(realm, nonce);
+                        foundAuthenticateHeader = True;
+                    }
+                    delete[] realm;
+                    delete[] nonce;
+                    if(foundAuthenticateHeader)
+                        break;
+                }
+            }
+            envir().setResultMsg("cannot handle INVITE response: ", firstLine);
+            break;
+        }
+
+        // Skip every subsequent header line, until we see a blank line.
+        // While doing so, check for "To:" and "Content-Length:" lines.
+        // The remaining data is assumed to be the SDP descriptor that we want.
+        // We should really do some more checking on the headers here - e.g., to
+        // check for "Content-type: application/sdp", "CSeq", etc. #####
+        int   contentLength = -1;
+        char *lineStart;
+        while(1) {
+            lineStart = nextLineStart;
+            if(lineStart == NULL)
+                break;
+
+            nextLineStart = getLine(lineStart);
+            if(lineStart[0] == '\0')
+                break;  // this is a blank line
+
+            char *toTagStr = strDupSize(lineStart);
+            if(sscanf(lineStart, "To:%*[^;]; tag=%s", toTagStr) == 1) {
+                delete[](char *) fToTagStr;
+                fToTagStr     = strDup(toTagStr);
+                fToTagStrSize = strlen(fToTagStr);
+            }
+            delete[] toTagStr;
+
+            if(sscanf(lineStart, "Content-Length: %d", &contentLength) == 1 || sscanf(lineStart, "Content-length: %d", &contentLength) == 1) {
+                if(contentLength < 0) {
+                    envir().setResultMsg("Bad \"Content-Length:\" header: \"", lineStart, "\"");
+                    break;
+                }
+            }
+        }
+
+        // We're now at the end of the response header lines
+        if(lineStart == NULL) {
+            envir().setResultMsg("no content following header lines: ", readBuf);
+            break;
+        }
+
+        // Use the remaining data as the SDP descr, but first, check
+        // the "Content-Length:" header (if any) that we saw.  We may need to
+        // read more data, or we may have extraneous data in the buffer.
+        char *bodyStart = nextLineStart;
+        if(bodyStart != NULL && contentLength >= 0) {
+            // We saw a "Content-Length:" header
+            unsigned numBodyBytes = &readBuf[bytesRead] - bodyStart;
+            if(contentLength > (int)numBodyBytes) {
+                // We need to read more data.  First, make sure we have enough
+                // space for it:
+                unsigned numExtraBytesNeeded = contentLength - numBodyBytes;
+#ifdef USING_TCP
+                // THIS CODE WORKS ONLY FOR TCP: #####
+                unsigned remainingBufferSize = readBufSize - (bytesRead + (readBuf - readBuffer));
+                if(numExtraBytesNeeded > remainingBufferSize) {
+                    char tmpBuf[200];
+                    sprintf(tmpBuf, "Read buffer size (%d) is too small for \"Content-Length:\" %d (need a buffer size of >= %d bytes\n", readBufSize,
+                            contentLength, readBufSize + numExtraBytesNeeded - remainingBufferSize);
+                    envir().setResultMsg(tmpBuf);
+                    break;
+                }
+
+                // Keep reading more data until we have enough:
+                if(fVerbosityLevel >= 1) {
+                    envir() << "Need to read " << numExtraBytesNeeded << " extra bytes\n";
+                }
+                while(numExtraBytesNeeded > 0) {
+                    char *                  ptr = &readBuf[bytesRead];
+                    unsigned                bytesRead2;
+                    struct sockaddr_storage dummy;  // not used
+                    Boolean                 readSuccess = fOurSocket->handleRead((unsigned char *)ptr, numExtraBytesNeeded, bytesRead2, dummy);
+                    if(!readSuccess)
+                        break;
+                    ptr[bytesRead2] = '\0';
+                    if(fVerbosityLevel >= 1) {
+                        envir() << "Read " << bytesRead2 << " extra bytes: " << ptr << "\n";
+                    }
+
+                    bytesRead += bytesRead2;
+                    numExtraBytesNeeded -= bytesRead2;
+                }
+#endif
+                if(numExtraBytesNeeded > 0)
+                    break;  // one of the reads failed
+            }
+
+            bodyStart[contentLength] = '\0';  // trims any extra data
+            delete[] fInviteSDPDescriptionReturned;
+            fInviteSDPDescriptionReturned = strDup(bodyStart);
+        }
+    } while(0);
+
+    return responseCode;
+}
+
+char *SIPClient::inviteWithPassword(char const *url, char const *username, char const *password) {
+    delete[](char *) fUserName;
+    fUserName     = strDup(username);
+    fUserNameSize = strlen(fUserName);
+
+    Authenticator authenticator(username, password);
+    char *        inviteResult = invite(url, &authenticator);
+    if(inviteResult != NULL) {
+        // We are already authorized
+        return inviteResult;
+    }
+
+    // The "realm" and "nonce" fields should have been filled in:
+    if(authenticator.realm() == NULL || authenticator.nonce() == NULL) {
+        // We haven't been given enough information to try again, so fail:
+        return NULL;
+    }
+
+    // Try again (but with the same CallId):
+    inviteResult = invite1(&authenticator);
+    if(inviteResult != NULL) {
+        // The authenticator worked, so use it in future requests:
+        fValidAuthenticator = authenticator;
+    }
+
+    return inviteResult;
+}
+
+Boolean SIPClient::sendACK() {
+    char *cmd = NULL;
+    do {
+        char const *const cmdFmt = "ACK %s SIP/2.0\r\n"
+                                   "From: %s <sip:%s@%s>;tag=%u\r\n"
+                                   "Via: SIP/2.0/UDP %s:%u\r\n"
+                                   "Max-Forwards: 70\r\n"
+                                   "To: %s;tag=%s\r\n"
+                                   "Call-ID: %u@%s\r\n"
+                                   "CSeq: %d ACK\r\n"
+                                   "Content-Length: 0\r\n\r\n";
+        unsigned cmdSize = strlen(cmdFmt) + fURLSize + 2 * fUserNameSize + fOurAddressStrSize + 20 /* max int len */
+                           + fOurAddressStrSize + 5                                                /* max port len */
+                           + fURLSize + fToTagStrSize + 20 + fOurAddressStrSize + 20;
+        cmd = new char[cmdSize];
+        sprintf(cmd, cmdFmt, fURL, fUserName, fUserName, fOurAddressStr, fFromTag, fOurAddressStr, fOurPortNum, fURL, fToTagStr, fCallId, fOurAddressStr,
+                fCSeq /* note: it's the same as before; not incremented */);
+
+        if(!sendRequest(cmd, strlen(cmd))) {
+            envir().setResultErrMsg("ACK send() failed: ");
+            break;
+        }
+
+        delete[] cmd;
+        return True;
+    } while(0);
+
+    delete[] cmd;
+    return False;
+}
+
+Boolean SIPClient::sendBYE() {
+    // NOTE: This should really be retransmitted, for reliability #####
+    char *cmd = NULL;
+    do {
+        char const *const cmdFmt = "BYE %s SIP/2.0\r\n"
+                                   "From: %s <sip:%s@%s>;tag=%u\r\n"
+                                   "Via: SIP/2.0/UDP %s:%u\r\n"
+                                   "Max-Forwards: 70\r\n"
+                                   "To: %s;tag=%s\r\n"
+                                   "Call-ID: %u@%s\r\n"
+                                   "CSeq: %d BYE\r\n"
+                                   "Content-Length: 0\r\n\r\n";
+        unsigned cmdSize = strlen(cmdFmt) + fURLSize + 2 * fUserNameSize + fOurAddressStrSize + 20 /* max int len */
+                           + fOurAddressStrSize + 5                                                /* max port len */
+                           + fURLSize + fToTagStrSize + 20 + fOurAddressStrSize + 20;
+        cmd = new char[cmdSize];
+        sprintf(cmd, cmdFmt, fURL, fUserName, fUserName, fOurAddressStr, fFromTag, fOurAddressStr, fOurPortNum, fURL, fToTagStr, fCallId, fOurAddressStr,
+                ++fCSeq);
+
+        if(!sendRequest(cmd, strlen(cmd))) {
+            envir().setResultErrMsg("BYE send() failed: ");
+            break;
+        }
+
+        delete[] cmd;
+        return True;
+    } while(0);
+
+    delete[] cmd;
+    return False;
+}
+
+Boolean SIPClient::processURL(char const *url) {
+    do {
+        // If we don't already have a server address/port, then
+        // get these by parsing the URL:
+        if(!fServerAddressIsSet) {
+            NetAddress destAddress;
+            if(!parseSIPURL(envir(), url, destAddress, fServerPortNum))
+                break;
+            copyAddress(fServerAddress, &destAddress);
+            fServerAddressIsSet = True;
+
+            if(fOurSocket != NULL) {
+                fOurSocket->changeDestinationParameters(fServerAddress, fServerPortNum, 255);
+            }
+        }
+
+        return True;
+    } while(0);
+
+    return False;
+}
+
+Boolean SIPClient::parseSIPURL(UsageEnvironment &env, char const *url, NetAddress &address, portNumBits &portNum) {
+    do {
+        // Parse the URL as "sip:<username>@<server-name-or-address>:<port>/<etc>"
+        // (with ":<port>" and "/<etc>" optional)
+        // Also, skip over any "<username>[:<password>]@" preceding <address>
+        char const *   prefix       = "sip:";
+        unsigned const prefixLength = 4;
+        if(_strncasecmp(url, prefix, prefixLength) != 0) {
+            env.setResultMsg("URL is not of the form \"", prefix, "\"");
+            break;
+        }
+
+        unsigned const parseBufferSize = 100;
+        char           parseBuffer[parseBufferSize];
+        unsigned       addressStartIndex = prefixLength;
+        while(url[addressStartIndex] != '\0' && url[addressStartIndex++] != '@') {
+        }
+        char const *from = &url[addressStartIndex];
+
+        // Skip over any "<username>[:<password>]@"
+        char const *from1 = from;
+        while(*from1 != '\0' && *from1 != '/') {
+            if(*from1 == '@') {
+                from = ++from1;
+                break;
+            }
+            ++from1;
+        }
+
+        // Next, parse <server-address-or-name>
+        char *  to                 = &parseBuffer[0];
+        Boolean isInSquareBrackets = False;  //  by default
+        if(*from == '[') {
+            ++from;
+            isInSquareBrackets = True;
+        }
+        unsigned i;
+        for(i = 0; i < parseBufferSize; ++i) {
+            if(*from == '\0' || (*from == ':' && !isInSquareBrackets) || *from == '/' || (*from == ']' && isInSquareBrackets)) {
+                // We've completed parsing the address
+                *to = '\0';
+                if(*from == ']' && isInSquareBrackets)
+                    ++from;
+                break;
+            }
+            *to++ = *from++;
+        }
+        if(i == parseBufferSize) {
+            env.setResultMsg("URL is too long");
+            break;
+        }
+
+        NetAddressList addresses(parseBuffer);
+        if(addresses.numAddresses() == 0) {
+            env.setResultMsg("Failed to find network address for \"", parseBuffer, "\"");
+            break;
+        }
+        address = *(addresses.firstAddress());
+
+        portNum       = 5060;  // default value
+        char nextChar = *from;
+        if(nextChar == ':') {
+            int portNumInt;
+            if(sscanf(++from, "%d", &portNumInt) != 1) {
+                env.setResultMsg("No port number follows ':'");
+                break;
+            }
+            if(portNumInt < 1 || portNumInt > 65535) {
+                env.setResultMsg("Bad port number");
+                break;
+            }
+            portNum = (portNumBits)portNumInt;
+        }
+
+        return True;
+    } while(0);
+
+    return False;
+}
+
+Boolean SIPClient::parseSIPURLUsernamePassword(char const *url, char *&username, char *&password) {
+    username = password = NULL;  // by default
+    do {
+        // Parse the URL as "sip:<username>[:<password>]@<whatever>"
+        char const *   prefix       = "sip:";
+        unsigned const prefixLength = 4;
+        if(_strncasecmp(url, prefix, prefixLength) != 0)
+            break;
+
+        // Look for the ':' and '@':
+        unsigned usernameIndex = prefixLength;
+        unsigned colonIndex = 0, atIndex = 0;
+        for(unsigned i = usernameIndex; url[i] != '\0' && url[i] != '/'; ++i) {
+            if(url[i] == ':' && colonIndex == 0) {
+                colonIndex = i;
+            }
+            else if(url[i] == '@') {
+                atIndex = i;
+                break;  // we're done
+            }
+        }
+        if(atIndex == 0)
+            break;  // no '@' found
+
+        char *urlCopy    = strDup(url);
+        urlCopy[atIndex] = '\0';
+        if(colonIndex > 0) {
+            urlCopy[colonIndex] = '\0';
+            password            = strDup(&urlCopy[colonIndex + 1]);
+        }
+        else {
+            password = strDup("");
+        }
+        username = strDup(&urlCopy[usernameIndex]);
+        delete[] urlCopy;
+
+        return True;
+    } while(0);
+
+    return False;
+}
+
+char *SIPClient::createAuthenticatorString(Authenticator const *authenticator, char const *cmd, char const *url) {
+    if(authenticator != NULL && authenticator->realm() != NULL && authenticator->nonce() != NULL && authenticator->username() != NULL
+       && authenticator->password() != NULL) {
+        // We've been provided a filled-in authenticator, so use it:
+        char const *const authFmt     = "Authorization: Digest username=\"%s\", realm=\"%s\", nonce=\"%s\", response=\"%s\", uri=\"%s\"\r\n";
+        char const *      response    = authenticator->computeDigestResponse(cmd, url);
+        unsigned          authBufSize = strlen(authFmt) + strlen(authenticator->username()) + strlen(authenticator->realm()) + strlen(authenticator->nonce())
+                               + strlen(url) + strlen(response);
+        char *authenticatorStr = new char[authBufSize];
+        sprintf(authenticatorStr, authFmt, authenticator->username(), authenticator->realm(), authenticator->nonce(), response, url);
+        authenticator->reclaimDigestResponse(response);
+
+        return authenticatorStr;
+    }
+
+    return strDup("");
+}
+
+Boolean SIPClient::sendRequest(char const *requestString, unsigned requestLength) {
+    if(fVerbosityLevel >= 1) {
+        envir() << "Sending request: " << requestString << "\n";
+    }
+    // NOTE: We should really check that "requestLength" is not #####
+    // too large for UDP (see RFC 3261, section 18.1.1) #####
+    return fOurSocket->output(envir(), (unsigned char *)requestString, requestLength);
+}
+
+unsigned SIPClient::getResponse(char *&responseBuffer, unsigned responseBufferSize) {
+    if(responseBufferSize == 0)
+        return 0;              // just in case...
+    responseBuffer[0] = '\0';  // ditto
+
+    // Keep reading data from the socket until we see "\r\n\r\n" (except
+    // at the start), or until we fill up our buffer.
+    // Don't read any more than this.
+    char *  p               = responseBuffer;
+    Boolean haveSeenNonCRLF = False;
+    int     bytesRead       = 0;
+    while(bytesRead < (int)responseBufferSize) {
+        unsigned                bytesReadNow;
+        struct sockaddr_storage dummy;  // not used
+        unsigned char *         toPosn      = (unsigned char *)(responseBuffer + bytesRead);
+        Boolean                 readSuccess = fOurSocket->handleRead(toPosn, responseBufferSize - bytesRead, bytesReadNow, dummy);
+        if(!readSuccess || bytesReadNow == 0) {
+            envir().setResultMsg("SIP response was truncated");
+            break;
+        }
+        bytesRead += bytesReadNow;
+
+        // Check whether we have "\r\n\r\n":
+        char *lastToCheck = responseBuffer + bytesRead - 4;
+        if(lastToCheck < responseBuffer)
+            continue;
+        for(; p <= lastToCheck; ++p) {
+            if(haveSeenNonCRLF) {
+                if(*p == '\r' && *(p + 1) == '\n' && *(p + 2) == '\r' && *(p + 3) == '\n') {
+                    responseBuffer[bytesRead] = '\0';
+
+                    // Before returning, trim any \r or \n from the start:
+                    while(*responseBuffer == '\r' || *responseBuffer == '\n') {
+                        ++responseBuffer;
+                        --bytesRead;
+                    }
+                    return bytesRead;
+                }
+            }
+            else {
+                if(*p != '\r' && *p != '\n') {
+                    haveSeenNonCRLF = True;
+                }
+            }
+        }
+    }
+
+    return 0;
+}
+
+Boolean SIPClient::parseResponseCode(char const *line, unsigned &responseCode) {
+    if(sscanf(line, "%*s%u", &responseCode) != 1) {
+        envir().setResultMsg("no response code in line: \"", line, "\"");
+        return False;
+    }
+
+    return True;
+}
diff --git a/3rdparty/live555/src/liveMedia/SRTPCryptographicContext.cpp b/3rdparty/live555/src/liveMedia/SRTPCryptographicContext.cpp
new file mode 100644
index 00000000..af603e7a
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/SRTPCryptographicContext.cpp
@@ -0,0 +1,580 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022, Live Networks, Inc.  All rights reserved
+//
+// The SRTP 'Cryptographic Context', used in all of our uses of SRTP.
+// Implementation
+
+#include "SRTPCryptographicContext.hh"
+#ifndef NO_OPENSSL
+#include "HMAC_SHA1.hh"
+#include <openssl/evp.h>
+#endif
+
+#ifdef DEBUG
+#include <stdio.h>
+#endif
+
+SRTPCryptographicContext ::SRTPCryptographicContext(MIKEYState const &mikeyState)
+#ifndef NO_OPENSSL
+    : fMIKEYState(mikeyState), fHaveReceivedSRTPPackets(False), fHaveSentSRTPPackets(False), fSRTCPIndex(0) {
+    // Begin by doing a key derivation, to generate the keying data that we need:
+    performKeyDerivation();
+#else
+    {
+#endif
+}
+
+SRTPCryptographicContext::~SRTPCryptographicContext() {}
+
+Boolean SRTPCryptographicContext ::processIncomingSRTPPacket(u_int8_t *buffer, unsigned inPacketSize, unsigned &outPacketSize) {
+#ifndef NO_OPENSSL
+    do {
+        if(inPacketSize < 12) {  // For SRTP, 12 is the minimum packet size (if unauthenticated)
+#ifdef DEBUG
+            fprintf(stderr, "SRTPCryptographicContext::processIncomingSRTPPacket(): Error: Packet size %d is too short for SRTP!\n", inPacketSize);
+#endif
+            break;
+        }
+
+        unsigned const numBytesPastEncryption = SRTP_MKI_LENGTH + (weAuthenticate() ? SRTP_AUTH_TAG_LENGTH : 0);
+        if(inPacketSize <= numBytesPastEncryption) {
+#ifdef DEBUG
+            fprintf(stderr, "SRTPCryptographicContext::processIncomingSRTPPacket(): Error: Packet size %d is too short for encrpytion and/or authentication!\n",
+                    inPacketSize);
+#endif
+            break;
+        }
+
+        // Begin by figuring out this packet's 'index' (ROC and RTP sequence number),
+        // and the ROC and RTP sequence number that will be used subsequently, provided that
+        // this packet authenticates OK:
+        u_int16_t const rtpSeqNum = (buffer[2] << 8) | buffer[3];
+        u_int32_t       nextROC, thisPacketsROC;
+        u_int16_t       nextHighRTPSeqNum;
+
+        if(!fHaveReceivedSRTPPackets) {
+            // First time:
+            nextROC = thisPacketsROC = fReceptionROC = 0;
+            nextHighRTPSeqNum                        = rtpSeqNum;
+        }
+        else {
+            // Check whether the sequence number has rolled over, or is out-of-order:
+            u_int16_t const SEQ_NUM_THRESHOLD = 0x1000;
+            if(rtpSeqNum >= fPreviousHighRTPSeqNum) {
+                // normal case, or out-of-order packet that crosses a rollover:
+                if(rtpSeqNum - fPreviousHighRTPSeqNum < SEQ_NUM_THRESHOLD) {
+                    // normal case:
+                    nextROC = thisPacketsROC = fReceptionROC;
+                    nextHighRTPSeqNum        = rtpSeqNum;
+                }
+                else {
+                    // out-of-order packet that crosses a rollover:
+                    nextROC           = fReceptionROC;
+                    thisPacketsROC    = fReceptionROC - 1;
+                    nextHighRTPSeqNum = fPreviousHighRTPSeqNum;
+                }
+            }
+            else {
+                // rollover, or out-of-order packet that crosses a rollover:
+                if(fPreviousHighRTPSeqNum - rtpSeqNum > SEQ_NUM_THRESHOLD) {
+                    // rollover:
+                    nextROC = thisPacketsROC = fReceptionROC + 1;
+                    nextHighRTPSeqNum        = rtpSeqNum;
+                }
+                else {
+                    // out-of-order packet (that doesn't cross a rollover):
+                    nextROC = thisPacketsROC = fReceptionROC;
+                    nextHighRTPSeqNum        = fPreviousHighRTPSeqNum;
+                }
+            }
+        }
+
+        if(weAuthenticate()) {
+            // Authenticate the packet.
+            unsigned const  numBytesToAuthenticate = inPacketSize - (SRTP_MKI_LENGTH + SRTP_AUTH_TAG_LENGTH);  // ASSERT: > 0
+            u_int8_t const *authenticationTag      = &buffer[inPacketSize - SRTP_AUTH_TAG_LENGTH];
+
+            if(!verifySRTPAuthenticationTag(buffer, numBytesToAuthenticate, thisPacketsROC, authenticationTag)) {
+#ifdef DEBUG
+                fprintf(stderr, "SRTPCryptographicContext::processIncomingSRTPPacket(): Failed to authenticate incoming SRTP packet!\n");
+#endif
+                break;
+            }
+        }
+
+        // Now that we've verified the packet, set the 'index values' for next time:
+        fReceptionROC            = nextROC;
+        fPreviousHighRTPSeqNum   = nextHighRTPSeqNum;
+        fHaveReceivedSRTPPackets = True;
+
+        if(weEncryptSRTP()) {
+            // Decrypt the SRTP packet.  It has the index "thisPacketsROC" with "rtpSeqNum":
+            u_int64_t index = (thisPacketsROC << 16) | rtpSeqNum;
+
+            // Figure out the RTP header size.  This will tell us which bytes to decrypt:
+            unsigned rtpHeaderSize = 12;              // at least the basic 12-byte header
+            rtpHeaderSize += (buffer[0] & 0x0F) * 4;  // # CSRC identifiers
+            if((buffer[0] & 0x10) != 0) {
+                // There's a RTP extension header.  Add its size:
+                if(inPacketSize < rtpHeaderSize + 4) {
+#ifdef DEBUG
+                    fprintf(stderr,
+                            "SRTPCryptographicContext::processIncomingSRTPPacket(): Error: Packet size %d is shorter than the minimum specified RTP header "
+                            "size %d!\n",
+                            inPacketSize, rtpHeaderSize + 4);
+#endif
+                    break;
+                }
+                u_int16_t const hdrExtLength = (buffer[rtpHeaderSize + 2] << 8) | buffer[rtpHeaderSize + 3];
+                rtpHeaderSize += 4 + hdrExtLength * 4;
+            }
+
+            unsigned const offsetToEncryptedBytes = rtpHeaderSize;
+            unsigned       numEncryptedBytes      = inPacketSize - numBytesPastEncryption;  // ASSERT: > 0
+            if(offsetToEncryptedBytes > numEncryptedBytes) {
+#ifdef DEBUG
+                fprintf(stderr, "SRTPCryptographicContext::processIncomingSRTPPacket(): Error: RTP header size %d (expected <= %d) is too large!\n",
+                        rtpHeaderSize, numEncryptedBytes);
+#endif
+                break;
+            }
+            numEncryptedBytes -= offsetToEncryptedBytes;
+
+            u_int32_t const SSRC = (buffer[8] << 24) | (buffer[9] << 16) | (buffer[10] << 8) | buffer[11];
+            decryptSRTPPacket(index, SSRC, &buffer[offsetToEncryptedBytes], numEncryptedBytes);
+            outPacketSize = inPacketSize - numBytesPastEncryption;  // trim to what we use
+        }
+
+        return True;
+    } while(0);
+#endif
+
+    // An error occurred in the handling of the packet:
+    return False;
+}
+
+Boolean SRTPCryptographicContext ::processIncomingSRTCPPacket(u_int8_t *buffer, unsigned inPacketSize, unsigned &outPacketSize) {
+#ifndef NO_OPENSSL
+    do {
+        if(inPacketSize < 12) {
+            // For SRTCP, 8 is the minumum RTCP packet size, but there's also a mandatory
+            //   4-byte "E+SRTCP index" word.
+#ifdef DEBUG
+            fprintf(stderr, "SRTPCryptographicContext::processIncomingSRTCPPacket(): Error: Packet size %d is too short for SRTCP!\n", inPacketSize);
+#endif
+            break;
+        }
+
+        unsigned const numBytesPastEncryption = 4 /*E+SRTCP index*/ + SRTP_MKI_LENGTH + (weAuthenticate() ? SRTP_AUTH_TAG_LENGTH : 0);
+        if(inPacketSize <= numBytesPastEncryption) {
+#ifdef DEBUG
+            fprintf(stderr,
+                    "SRTPCryptographicContext::processIncomingSRTCPPacket(): Error: Packet size %d is too short for encrpytion and/or authentication!\n",
+                    inPacketSize);
+#endif
+            break;
+        }
+
+        if(weAuthenticate()) {
+            // Authenticate the packet.
+            unsigned const  numBytesToAuthenticate = inPacketSize - (SRTP_MKI_LENGTH + SRTP_AUTH_TAG_LENGTH);  // ASSERT: > 0
+            u_int8_t const *authenticationTag      = &buffer[inPacketSize - SRTP_AUTH_TAG_LENGTH];
+
+            if(!verifySRTCPAuthenticationTag(buffer, numBytesToAuthenticate, authenticationTag)) {
+#ifdef DEBUG
+                fprintf(stderr, "SRTPCryptographicContext::processIncomingSRTCPPacket(): Failed to authenticate incoming SRTCP packet!\n");
+#endif
+                break;
+            }
+        }
+
+        if(weEncryptSRTCP()) {
+            // Decrypt the SRTCP packet:
+            unsigned        numEncryptedBytes = inPacketSize - numBytesPastEncryption;  // ASSERT: > 0
+            u_int8_t const *p                 = &buffer[numEncryptedBytes];             // E + SRTCP index
+            u_int32_t       E_plus_SRTCPIndex = (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3];
+            if((E_plus_SRTCPIndex & 0x80000000) != 0) {
+                // The packet is encrypted
+                unsigned const offsetToEncryptedBytes = 8;
+                if(offsetToEncryptedBytes > numEncryptedBytes) {
+#ifdef DEBUG
+                    fprintf(stderr, "SRTPCryptographicContext::processIncomingSRTCPPacket(): Error: RTCP packet size %d is too small!\n", numEncryptedBytes);
+#endif
+                    break;
+                }
+                numEncryptedBytes -= offsetToEncryptedBytes;
+
+                u_int32_t       index = E_plus_SRTCPIndex & 0x7FFFFFFF;
+                u_int32_t const SSRC  = (buffer[4] << 24) | (buffer[5] << 16) | (buffer[6] << 8) | buffer[7];
+                decryptSRTCPPacket(index, SSRC, &buffer[offsetToEncryptedBytes], numEncryptedBytes);
+            }
+            outPacketSize = inPacketSize - numBytesPastEncryption;  // trim to what we use
+        }
+
+        return True;
+    } while(0);
+#endif
+
+    // An error occurred in the handling of the packet:
+    return False;
+}
+
+Boolean SRTPCryptographicContext ::processOutgoingSRTPPacket(u_int8_t *buffer, unsigned inPacketSize, unsigned &outPacketSize) {
+#ifndef NO_OPENSSL
+    do {
+        unsigned const minRTPHeaderSize = 12;
+        if(inPacketSize < minRTPHeaderSize) {  // packet is too small
+            // Hack: Let small, non RTCP packets through w/o encryption; they may be used to
+            // punch through NATs
+            outPacketSize = inPacketSize;
+            return True;
+        }
+
+        // Encrypt the appropriate part of the packet.
+        if(weEncryptSRTP()) {
+            // Figure out the RTP header size.  This will tell us which bytes to encrypt:
+            unsigned rtpHeaderSize = 12;              // at least the basic 12-byte header
+            rtpHeaderSize += (buffer[0] & 0x0F) * 4;  // # CSRC identifiers
+            if((buffer[0] & 0x10) != 0) {
+                // There's a RTP extension header.  Add its size:
+                if(inPacketSize < rtpHeaderSize + 4) {
+#ifdef DEBUG
+                    fprintf(stderr,
+                            "SRTPCryptographicContext::processOutgoingSRTPPacket(): Error: Packet size %d is shorter than the minimum specified RTP header "
+                            "size %d!\n",
+                            inPacketSize, rtpHeaderSize + 4);
+#endif
+                    break;
+                }
+                u_int16_t const hdrExtLength = (buffer[rtpHeaderSize + 2] << 8) | buffer[rtpHeaderSize + 3];
+                rtpHeaderSize += 4 + hdrExtLength * 4;
+            }
+
+            unsigned const offsetToEncryptedBytes = rtpHeaderSize;
+            if(inPacketSize < offsetToEncryptedBytes) {
+#ifdef DEBUG
+                fprintf(stderr, "SRTPCryptographicContext::processOutgoingSRTPPacket(): Error: Packet size %d is too small (should be >= %d)!\n", inPacketSize,
+                        offsetToEncryptedBytes);
+#endif
+                break;
+            }
+
+            // Figure out this packet's 'index' (ROC|rtpSeqNum):
+            u_int16_t const rtpSeqNum = (buffer[2] << 8) | buffer[3];
+            if(!fHaveSentSRTPPackets) {
+                fSendingROC          = 0;
+                fHaveSentSRTPPackets = True;  // for the future
+            }
+            else {
+                if(rtpSeqNum == 0)
+                    ++fSendingROC;  // increment the ROC when the RTP seq num rolls over
+            }
+            u_int64_t index = (fSendingROC << 16) | rtpSeqNum;
+
+            unsigned const  numEncryptedBytes = inPacketSize - offsetToEncryptedBytes;  // ASSERT: >= 0
+            u_int32_t const SSRC              = (buffer[8] << 24) | (buffer[9] << 16) | (buffer[10] << 8) | buffer[11];
+            encryptSRTPPacket(index, SSRC, &buffer[offsetToEncryptedBytes], numEncryptedBytes);
+        }
+
+        outPacketSize = inPacketSize;  // initially
+
+        unsigned const mkiPosition = outPacketSize;  // where the MKI will go
+
+        if(weAuthenticate()) {
+            // Append the ROC to the payload, because it's used to generate the authentication tag.
+            // (Next, the MKI will take its place.)
+            buffer[outPacketSize++] = fSendingROC >> 24;
+            buffer[outPacketSize++] = fSendingROC >> 16;
+            buffer[outPacketSize++] = fSendingROC >> 8;
+            buffer[outPacketSize++] = fSendingROC;
+
+            // Generate and add an authentication tag over the whole packet, plus the ROC:
+            outPacketSize += generateSRTPAuthenticationTag(buffer, outPacketSize, &buffer[outPacketSize]);
+        }
+
+        // Add the MKI:
+        buffer[mkiPosition]     = MKI() >> 24;
+        buffer[mkiPosition + 1] = MKI() >> 16;
+        buffer[mkiPosition + 2] = MKI() >> 8;
+        buffer[mkiPosition + 3] = MKI();
+
+        return True;
+    } while(0);
+#endif
+
+    // An error occurred:
+    return False;
+}
+
+Boolean SRTPCryptographicContext ::processOutgoingSRTCPPacket(u_int8_t *buffer, unsigned inPacketSize, unsigned &outPacketSize) {
+#ifndef NO_OPENSSL
+    do {
+        // Encrypt the appropriate part of the packet.
+        u_int8_t eFlag = 0x00;
+        if(weEncryptSRTCP()) {
+            unsigned const unencryptedHeaderSize = 8;
+            if(inPacketSize < unencryptedHeaderSize) {  // packet is too small
+                // Hack: Let small, non RTCP packets through w/o encryption; they may be used to
+                // punch through NATs
+                outPacketSize = inPacketSize;
+                return True;
+            }
+            unsigned const encryptedDataSize = inPacketSize - unencryptedHeaderSize;
+
+            u_int8_t *const dataToEncrypt = &buffer[unencryptedHeaderSize];
+            u_int32_t const ssrc          = (buffer[4] << 24) | (buffer[5] << 16) | (buffer[6] << 8) | buffer[7];
+            encryptSRTCPPacket(fSRTCPIndex, ssrc, dataToEncrypt, encryptedDataSize);
+            eFlag = 0x80;
+        }
+
+        outPacketSize = inPacketSize;  // initially
+
+        // Add 4 bytes for the 'E' flag and SRTCP index:
+        buffer[outPacketSize++] = (fSRTCPIndex >> 24) | eFlag;
+        buffer[outPacketSize++] = fSRTCPIndex >> 16;
+        buffer[outPacketSize++] = fSRTCPIndex >> 8;
+        buffer[outPacketSize++] = fSRTCPIndex;
+        ++fSRTCPIndex;  // for next time
+
+        // Add the MKI:
+        buffer[outPacketSize++] = MKI() >> 24;
+        buffer[outPacketSize++] = MKI() >> 16;
+        buffer[outPacketSize++] = MKI() >> 8;
+        buffer[outPacketSize++] = MKI();
+
+        // Generate and add an authentication tag over the data built so far (except the MKI)
+        outPacketSize += generateSRTCPAuthenticationTag(buffer, outPacketSize - SRTP_MKI_LENGTH, &buffer[outPacketSize]);
+
+        return True;
+    } while(0);
+#endif
+
+    // An error occurred:
+    return False;
+}
+
+#ifndef NO_OPENSSL
+unsigned SRTPCryptographicContext ::generateSRTPAuthenticationTag(u_int8_t const *dataToAuthenticate, unsigned numBytesToAuthenticate,
+                                                                  u_int8_t *resultAuthenticationTag) {
+    return generateAuthenticationTag(fDerivedKeys.srtp, dataToAuthenticate, numBytesToAuthenticate, resultAuthenticationTag);
+}
+
+unsigned SRTPCryptographicContext ::generateSRTCPAuthenticationTag(u_int8_t const *dataToAuthenticate, unsigned numBytesToAuthenticate,
+                                                                   u_int8_t *resultAuthenticationTag) {
+    return generateAuthenticationTag(fDerivedKeys.srtcp, dataToAuthenticate, numBytesToAuthenticate, resultAuthenticationTag);
+}
+
+Boolean SRTPCryptographicContext ::verifySRTPAuthenticationTag(u_int8_t *dataToAuthenticate, unsigned numBytesToAuthenticate, u_int32_t roc,
+                                                               u_int8_t const *authenticationTag) {
+    // Append the (4-byte) 'ROC' (roll-over counter) to "dataToAuthenticate" before computing
+    // the authentication tag.  We can do this because we have enough space after
+    // "dataToAuthenticate":
+    //   - If we're encrypted, then there's assumed to be a (4-byte) MKI there.  Just overwrite
+    //     that.  (If we need the MKI, we could copy it beforehand; later, allow for there being
+    //     no MKI #####)
+    //   - If we're not encrypted, then the ROC will overwrite part of the existing
+    //     authentication tag, so we need to make a copy of this.
+    u_int8_t const *existingAuthenticationTag;
+    Boolean         haveMKI = True;  // later, allow for there being no MKI #####
+    u_int8_t        authenticationTagCopy[SRTP_AUTH_TAG_LENGTH];
+
+    if(fMIKEYState.encryptSRTP() && haveMKI) {
+        existingAuthenticationTag = authenticationTag;
+    }
+    else {
+        memcpy(authenticationTagCopy, authenticationTag, sizeof authenticationTagCopy);
+        existingAuthenticationTag = authenticationTagCopy;
+    }
+
+    dataToAuthenticate[numBytesToAuthenticate++] = roc >> 24;
+    dataToAuthenticate[numBytesToAuthenticate++] = roc >> 16;
+    dataToAuthenticate[numBytesToAuthenticate++] = roc >> 8;
+    dataToAuthenticate[numBytesToAuthenticate++] = roc;
+
+    return verifyAuthenticationTag(fDerivedKeys.srtp, dataToAuthenticate, numBytesToAuthenticate, existingAuthenticationTag);
+}
+
+Boolean SRTPCryptographicContext ::verifySRTCPAuthenticationTag(u_int8_t const *dataToAuthenticate, unsigned numBytesToAuthenticate,
+                                                                u_int8_t const *authenticationTag) {
+    return verifyAuthenticationTag(fDerivedKeys.srtcp, dataToAuthenticate, numBytesToAuthenticate, authenticationTag);
+}
+
+void SRTPCryptographicContext ::decryptSRTPPacket(u_int64_t index, u_int32_t ssrc, u_int8_t *data, unsigned numDataBytes) {
+    cryptData(fDerivedKeys.srtp, index, ssrc, data, numDataBytes);
+}
+
+void SRTPCryptographicContext ::decryptSRTCPPacket(u_int32_t index, u_int32_t ssrc, u_int8_t *data, unsigned numDataBytes) {
+    cryptData(fDerivedKeys.srtcp, (u_int64_t)index, ssrc, data, numDataBytes);
+}
+
+void SRTPCryptographicContext ::encryptSRTPPacket(u_int64_t index, u_int32_t ssrc, u_int8_t *data, unsigned numDataBytes) {
+    cryptData(fDerivedKeys.srtp, index, ssrc, data, numDataBytes);
+}
+
+void SRTPCryptographicContext ::encryptSRTCPPacket(u_int32_t index, u_int32_t ssrc, u_int8_t *data, unsigned numDataBytes) {
+    cryptData(fDerivedKeys.srtcp, (u_int64_t)index, ssrc, data, numDataBytes);
+}
+
+unsigned SRTPCryptographicContext ::generateAuthenticationTag(derivedKeys &keysToUse, u_int8_t const *dataToAuthenticate, unsigned numBytesToAuthenticate,
+                                                              u_int8_t *resultAuthenticationTag) {
+    if(SRTP_AUTH_TAG_LENGTH > SHA1_DIGEST_LEN)
+        return 0;  // sanity check; shouldn't happen
+    u_int8_t computedAuthTag[SHA1_DIGEST_LEN];
+    HMAC_SHA1(keysToUse.authKey, sizeof keysToUse.authKey, dataToAuthenticate, numBytesToAuthenticate, computedAuthTag);
+
+    for(unsigned i = 0; i < SRTP_AUTH_TAG_LENGTH; ++i) {
+        resultAuthenticationTag[i] = computedAuthTag[i];
+    }
+
+    return SRTP_AUTH_TAG_LENGTH;
+}
+
+Boolean SRTPCryptographicContext ::verifyAuthenticationTag(derivedKeys &keysToUse, u_int8_t const *dataToAuthenticate, unsigned numBytesToAuthenticate,
+                                                           u_int8_t const *authenticationTag) {
+    u_int8_t computedAuthTag[SHA1_DIGEST_LEN];
+    HMAC_SHA1(keysToUse.authKey, sizeof keysToUse.authKey, dataToAuthenticate, numBytesToAuthenticate, computedAuthTag);
+
+    if(SRTP_AUTH_TAG_LENGTH > SHA1_DIGEST_LEN)
+        return False;  // sanity check
+    for(unsigned i = 0; i < SRTP_AUTH_TAG_LENGTH; ++i) {
+        if(computedAuthTag[i] != authenticationTag[i])
+            return False;
+    }
+    return True;
+}
+
+void SRTPCryptographicContext::cryptData(derivedKeys &keys, u_int64_t index, u_int32_t ssrc, u_int8_t *data, unsigned numDataBytes) {
+    // Begin by constructing the IV: (salt * 2^16) XOR (ssrc * 2^64) XOR (index * 2^16)
+    u_int8_t iv[SRTP_CIPHER_KEY_LENGTH];
+
+    memmove(iv, keys.salt, SRTP_CIPHER_SALT_LENGTH);
+    iv[SRTP_CIPHER_SALT_LENGTH] = iv[SRTP_CIPHER_SALT_LENGTH + 1] = 0;
+    // (This is based upon the fact that SRTP_CIPHER_KEY_LENGTH == SRTP_CIPHER_SALT_LENGTH + 2)
+
+    iv[sizeof iv - 12] ^= ssrc >> 24;
+    iv[sizeof iv - 11] ^= ssrc >> 16;
+    iv[sizeof iv - 10] ^= ssrc >> 8;
+    iv[sizeof iv - 9] ^= ssrc;
+
+    iv[sizeof iv - 8] ^= index >> 40;
+    iv[sizeof iv - 7] ^= index >> 32;
+    iv[sizeof iv - 6] ^= index >> 24;
+    iv[sizeof iv - 5] ^= index >> 16;
+    iv[sizeof iv - 4] ^= index >> 8;
+    iv[sizeof iv - 3] ^= index;
+
+    // Now generate as many blocks of the keystream as we need, by repeatedly encrypting
+    // the IV using our cipher key.  (After each step, we increment the IV by 1.)
+    // We then XOR the keystream into the provided data, to do the en/decryption.
+    do {
+        EVP_CIPHER_CTX *ctx = EVP_CIPHER_CTX_new();
+        if(ctx == NULL)
+            break;
+
+        if(EVP_EncryptInit(ctx, EVP_aes_128_ecb(), keys.cipherKey, NULL /*no IV*/) != 1)
+            break;
+        // Note: We use ECB mode here, because we're using our "iv" as plaintext
+
+        while(numDataBytes > 0) {
+            u_int8_t keyStream[SRTP_CIPHER_KEY_LENGTH];
+            int      numBytesEncrypted;
+            if(EVP_EncryptUpdate(ctx, keyStream, &numBytesEncrypted, iv, SRTP_CIPHER_KEY_LENGTH) != 1)
+                break;
+
+            unsigned numBytesToUse = numDataBytes < numBytesEncrypted ? numDataBytes : numBytesEncrypted;
+            for(unsigned i = 0; i < numBytesToUse; ++i)
+                data[i] ^= keyStream[i];
+            data += numBytesToUse;
+            numDataBytes -= numBytesToUse;
+
+            // Increment the IV by 1:
+            u_int8_t *ptr = &iv[sizeof iv];
+            do {
+                --ptr;
+                ++*ptr;
+            } while(*ptr == 0x00);
+        }
+
+        EVP_CIPHER_CTX_free(ctx);
+    } while(0);
+}
+
+void SRTPCryptographicContext::performKeyDerivation() {
+    // Perform a key derivation for the master key+salt, as defined
+    // by RFC 3711, section 4.3:
+    deriveKeysFromMaster(masterKey(), masterSalt(), fDerivedKeys);
+}
+
+#define deriveKey(label, resultKey) deriveSingleKey(masterKey, salt, label, sizeof resultKey, resultKey)
+
+void SRTPCryptographicContext ::deriveKeysFromMaster(u_int8_t const *masterKey, u_int8_t const *salt, allDerivedKeys &allKeysResult) {
+    // Derive cipher, salt, and auth keys for both SRTP and SRTCP:
+    deriveKey(label_srtp_encryption, allKeysResult.srtp.cipherKey);
+    deriveKey(label_srtp_msg_auth, allKeysResult.srtp.authKey);
+    deriveKey(label_srtp_salt, allKeysResult.srtp.salt);
+
+    deriveKey(label_srtcp_encryption, allKeysResult.srtcp.cipherKey);
+    deriveKey(label_srtcp_msg_auth, allKeysResult.srtcp.authKey);
+    deriveKey(label_srtcp_salt, allKeysResult.srtcp.salt);
+}
+
+#define KDF_PRF_CIPHER_BLOCK_LENGTH 16
+
+void SRTPCryptographicContext ::deriveSingleKey(u_int8_t const *masterKey, u_int8_t const *salt, SRTPKeyDerivationLabel label, unsigned resultKeyLength,
+                                                u_int8_t *resultKey) {
+    u_int8_t counter[KDF_PRF_CIPHER_BLOCK_LENGTH];
+    // Fill in the first bytes of "counter" with our 'salt'; set the remaining bytes to zero:
+    memmove(counter, salt, SRTP_CIPHER_SALT_LENGTH);
+    for(unsigned i = SRTP_CIPHER_SALT_LENGTH; i < sizeof counter; ++i) {
+        counter[i] = 0;
+    }
+
+    // XOR "label" into byte 7 of "counter":
+    counter[7] ^= label;
+
+    // And use the resulting "counter" as the plaintext:
+    u_int8_t const *plaintext = counter;
+
+    // Generate the key by repeatedly encrypting the plaintext:
+    do {
+        EVP_CIPHER_CTX *ctx = EVP_CIPHER_CTX_new();
+        if(ctx == NULL)
+            break;
+
+        if(EVP_EncryptInit(ctx, EVP_aes_128_ecb(), masterKey, NULL /*no IV*/) != 1)
+            break;
+        // Note: We use ECB mode here, because there's no IV
+
+        unsigned numBytesRemaining = resultKeyLength;
+        while(numBytesRemaining > 0) {
+            u_int8_t ciphertext[KDF_PRF_CIPHER_BLOCK_LENGTH];
+            int      numBytesEncrypted;
+            if(EVP_EncryptUpdate(ctx, ciphertext, &numBytesEncrypted, plaintext, KDF_PRF_CIPHER_BLOCK_LENGTH) != 1)
+                break;
+
+            unsigned numBytesToCopy = numBytesRemaining < numBytesEncrypted ? numBytesRemaining : numBytesEncrypted;
+            memmove(resultKey, ciphertext, numBytesToCopy);
+            resultKey += numBytesToCopy;
+            numBytesRemaining -= numBytesToCopy;
+            ++counter[15];  // for next time
+        }
+
+        EVP_CIPHER_CTX_free(ctx);
+    } while(0);
+}
+#endif
diff --git a/3rdparty/live555/src/liveMedia/ServerMediaSession.cpp b/3rdparty/live555/src/liveMedia/ServerMediaSession.cpp
new file mode 100644
index 00000000..899cf089
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/ServerMediaSession.cpp
@@ -0,0 +1,458 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A data structure that represents a session that consists of
+// potentially multiple (audio and/or video) sub-sessions
+// (This data structure is used for media *streamers* - i.e., servers.
+//  For media receivers, use "MediaSession" instead.)
+// Implementation
+
+#include "ServerMediaSession.hh"
+#include <GroupsockHelper.hh>
+#include <math.h>
+#if defined(__WIN32__) || defined(_WIN32) || defined(_QNX4)
+#define snprintf _snprintf
+#endif
+
+////////// ServerMediaSession //////////
+
+ServerMediaSession *ServerMediaSession ::createNew(UsageEnvironment &env, char const *streamName, char const *info, char const *description, Boolean isSSM,
+                                                   char const *miscSDPLines) {
+    return new ServerMediaSession(env, streamName, info, description, isSSM, miscSDPLines);
+}
+
+Boolean ServerMediaSession ::lookupByName(UsageEnvironment &env, char const *mediumName, ServerMediaSession *&resultSession) {
+    resultSession = NULL;  // unless we succeed
+
+    Medium *medium;
+    if(!Medium::lookupByName(env, mediumName, medium))
+        return False;
+
+    if(!medium->isServerMediaSession()) {
+        env.setResultMsg(mediumName, " is not a 'ServerMediaSession' object");
+        return False;
+    }
+
+    resultSession = (ServerMediaSession *)medium;
+    return True;
+}
+
+static char const *const libNameStr    = "LIVE555 Streaming Media v";
+char const *const        libVersionStr = LIVEMEDIA_LIBRARY_VERSION_STRING;
+
+ServerMediaSession::ServerMediaSession(UsageEnvironment &env, char const *streamName, char const *info, char const *description, Boolean isSSM,
+                                       char const *miscSDPLines)
+    : Medium(env),
+      streamingUsesSRTP(False),
+      streamingIsEncrypted(False),
+      fIsSSM(isSSM),
+      fSubsessionsHead(NULL),
+      fSubsessionsTail(NULL),
+      fSubsessionCounter(0),
+      fReferenceCount(0),
+      fDeleteWhenUnreferenced(False) {
+    fStreamName = strDup(streamName == NULL ? "" : streamName);
+
+    char *libNamePlusVersionStr = NULL;  // by default
+    if(info == NULL || description == NULL) {
+        libNamePlusVersionStr = new char[strlen(libNameStr) + strlen(libVersionStr) + 1];
+        sprintf(libNamePlusVersionStr, "%s%s", libNameStr, libVersionStr);
+    }
+    fInfoSDPString        = strDup(info == NULL ? libNamePlusVersionStr : info);
+    fDescriptionSDPString = strDup(description == NULL ? libNamePlusVersionStr : description);
+    delete[] libNamePlusVersionStr;
+
+    fMiscSDPLines = strDup(miscSDPLines == NULL ? "" : miscSDPLines);
+
+    gettimeofday(&fCreationTime, NULL);
+}
+
+ServerMediaSession::~ServerMediaSession() {
+    deleteAllSubsessions();
+    delete[] fStreamName;
+    delete[] fInfoSDPString;
+    delete[] fDescriptionSDPString;
+    delete[] fMiscSDPLines;
+}
+
+Boolean ServerMediaSession::addSubsession(ServerMediaSubsession *subsession) {
+    if(subsession->fParentSession != NULL)
+        return False;  // it's already used
+
+    if(fSubsessionsTail == NULL) {
+        fSubsessionsHead = subsession;
+    }
+    else {
+        fSubsessionsTail->fNext = subsession;
+    }
+    fSubsessionsTail = subsession;
+
+    subsession->fParentSession = this;
+    subsession->fTrackNumber   = ++fSubsessionCounter;
+    return True;
+}
+
+void ServerMediaSession::testScaleFactor(float &scale) {
+    // First, try setting all subsessions to the desired scale.
+    // If the subsessions' actual scales differ from each other, choose the
+    // value that's closest to 1, and then try re-setting all subsessions to that
+    // value.  If the subsessions' actual scales still differ, re-set them all to 1.
+    float                  minSSScale      = 1.0;
+    float                  maxSSScale      = 1.0;
+    float                  bestSSScale     = 1.0;
+    float                  bestDistanceTo1 = 0.0;
+    ServerMediaSubsession *subsession;
+    for(subsession = fSubsessionsHead; subsession != NULL; subsession = subsession->fNext) {
+        float ssscale = scale;
+        subsession->testScaleFactor(ssscale);
+        if(subsession == fSubsessionsHead) {  // this is the first subsession
+            minSSScale = maxSSScale = bestSSScale = ssscale;
+            bestDistanceTo1                       = (float)fabs(ssscale - 1.0f);
+        }
+        else {
+            if(ssscale < minSSScale) {
+                minSSScale = ssscale;
+            }
+            else if(ssscale > maxSSScale) {
+                maxSSScale = ssscale;
+            }
+
+            float distanceTo1 = (float)fabs(ssscale - 1.0f);
+            if(distanceTo1 < bestDistanceTo1) {
+                bestSSScale     = ssscale;
+                bestDistanceTo1 = distanceTo1;
+            }
+        }
+    }
+    if(minSSScale == maxSSScale) {
+        // All subsessions are at the same scale: minSSScale == bestSSScale == maxSSScale
+        scale = minSSScale;
+        return;
+    }
+
+    // The scales for each subsession differ.  Try to set each one to the value
+    // that's closest to 1:
+    for(subsession = fSubsessionsHead; subsession != NULL; subsession = subsession->fNext) {
+        float ssscale = bestSSScale;
+        subsession->testScaleFactor(ssscale);
+        if(ssscale != bestSSScale)
+            break;  // no luck
+    }
+    if(subsession == NULL) {
+        // All subsessions are at the same scale: bestSSScale
+        scale = bestSSScale;
+        return;
+    }
+
+    // Still no luck.  Set each subsession's scale to 1:
+    for(subsession = fSubsessionsHead; subsession != NULL; subsession = subsession->fNext) {
+        float ssscale = 1;
+        subsession->testScaleFactor(ssscale);
+    }
+    scale = 1;
+}
+
+float ServerMediaSession::duration() const {
+    float minSubsessionDuration = 0.0;
+    float maxSubsessionDuration = 0.0;
+    for(ServerMediaSubsession *subsession = fSubsessionsHead; subsession != NULL; subsession = subsession->fNext) {
+        // Hack: If any subsession supports seeking by 'absolute' time, then return a negative value, to indicate that only subsessions
+        // will have a "a=range:" attribute:
+        char *absStartTime = NULL;
+        char *absEndTime   = NULL;
+        subsession->getAbsoluteTimeRange(absStartTime, absEndTime);
+        if(absStartTime != NULL)
+            return -1.0f;
+
+        float ssduration = subsession->duration();
+        if(subsession == fSubsessionsHead) {  // this is the first subsession
+            minSubsessionDuration = maxSubsessionDuration = ssduration;
+        }
+        else if(ssduration < minSubsessionDuration) {
+            minSubsessionDuration = ssduration;
+        }
+        else if(ssduration > maxSubsessionDuration) {
+            maxSubsessionDuration = ssduration;
+        }
+    }
+
+    if(maxSubsessionDuration != minSubsessionDuration) {
+        return -maxSubsessionDuration;  // because subsession durations differ
+    }
+    else {
+        return maxSubsessionDuration;  // all subsession durations are the same
+    }
+}
+
+void ServerMediaSession::noteLiveness() {
+    // default implementation: do nothing
+}
+
+void ServerMediaSession::deleteAllSubsessions() {
+    Medium::close(fSubsessionsHead);
+    fSubsessionsHead = fSubsessionsTail = NULL;
+    fSubsessionCounter                  = 0;
+}
+
+Boolean ServerMediaSession::isServerMediaSession() const {
+    return True;
+}
+
+char *ServerMediaSession::generateSDPDescription(int addressFamily) {
+    struct sockaddr_storage ourAddress;
+    if(addressFamily == AF_INET) {
+        ourAddress.ss_family                        = AF_INET;
+        ((sockaddr_in &)ourAddress).sin_addr.s_addr = ourIPv4Address(envir());
+    }
+    else {  // IPv6
+        ourAddress.ss_family = AF_INET6;
+        for(unsigned i = 0; i < 16; ++i) {
+            ((sockaddr_in6 &)ourAddress).sin6_addr.s6_addr[i] = ourIPv6Address(envir())[i];
+        }
+    }
+
+    AddressString ipAddressStr(ourAddress);
+    unsigned      ipAddressStrSize = strlen(ipAddressStr.val());
+
+    // For a SSM sessions, we need a "a=source-filter: incl ..." line also:
+    char *sourceFilterLine;
+    if(fIsSSM) {
+        char const *const sourceFilterFmt = "a=source-filter: incl IN %s * %s\r\n"
+                                            "a=rtcp-unicast: reflection\r\n";
+        unsigned const sourceFilterFmtSize = strlen(sourceFilterFmt) + 3 /*IP4 or IP6*/ + ipAddressStrSize + 1;
+
+        sourceFilterLine = new char[sourceFilterFmtSize];
+        sprintf(sourceFilterLine, sourceFilterFmt, addressFamily == AF_INET ? "IP4" : "IP6", ipAddressStr.val());
+    }
+    else {
+        sourceFilterLine = strDup("");
+    }
+
+    char *rangeLine = NULL;  // for now
+    char *sdp       = NULL;  // for now
+
+    do {
+        // Count the lengths of each subsession's media-level SDP lines.
+        // (We do this first, because the call to "subsession->sdpLines()"
+        // causes correct subsession 'duration()'s to be calculated later.)
+        unsigned               sdpLength = 0;
+        ServerMediaSubsession *subsession;
+        for(subsession = fSubsessionsHead; subsession != NULL; subsession = subsession->fNext) {
+            char const *sdpLines = subsession->sdpLines(addressFamily);
+            if(sdpLines == NULL)
+                continue;  // the media's not available
+            sdpLength += strlen(sdpLines);
+        }
+        if(sdpLength == 0)
+            break;  // the session has no usable subsessions
+
+        // Unless subsessions have differing durations, we also have a "a=range:" line:
+        float dur = duration();
+        if(dur == 0.0) {
+            rangeLine = strDup("a=range:npt=now-\r\n");
+        }
+        else if(dur > 0.0) {
+            char buf[100];
+            sprintf(buf, "a=range:npt=0-%.3f\r\n", dur);
+            rangeLine = strDup(buf);
+        }
+        else {  // subsessions have differing durations, so "a=range:" lines go there
+            rangeLine = strDup("");
+        }
+
+        char const *const sdpPrefixFmt = "v=0\r\n"
+                                         "o=- %ld%06ld %d IN %s %s\r\n"
+                                         "s=%s\r\n"
+                                         "i=%s\r\n"
+                                         "t=0 0\r\n"
+                                         "a=tool:%s%s\r\n"
+                                         "a=type:broadcast\r\n"
+                                         "a=control:*\r\n"
+                                         "%s"
+                                         "%s"
+                                         "a=x-qt-text-nam:%s\r\n"
+                                         "a=x-qt-text-inf:%s\r\n"
+                                         "%s";
+        sdpLength += strlen(sdpPrefixFmt) + 20 + 6 + 20 + 3 /*IP4 or IP6*/ + ipAddressStrSize + strlen(fDescriptionSDPString) + strlen(fInfoSDPString)
+                     + strlen(libNameStr) + strlen(libVersionStr) + strlen(sourceFilterLine) + strlen(rangeLine) + strlen(fDescriptionSDPString)
+                     + strlen(fInfoSDPString) + strlen(fMiscSDPLines);
+        sdpLength += 1000;  // in case the length of the "subsession->sdpLines()" calls below change
+        sdp = new char[sdpLength];
+        if(sdp == NULL)
+            break;
+
+        // Generate the SDP prefix (session-level lines):
+        snprintf(sdp, sdpLength, sdpPrefixFmt, fCreationTime.tv_sec, fCreationTime.tv_usec,  // o= <session id>
+                 1,                                                                          // o= <version> // (needs to change if params are modified)
+                 addressFamily == AF_INET ? "IP4" : "IP6",                                   // o= <address family>
+                 ipAddressStr.val(),                                                         // o= <address>
+                 fDescriptionSDPString,                                                      // s= <description>
+                 fInfoSDPString,                                                             // i= <info>
+                 libNameStr, libVersionStr,                                                  // a=tool:
+                 sourceFilterLine,                                                           // a=source-filter: incl (if a SSM session)
+                 rangeLine,                                                                  // a=range: line
+                 fDescriptionSDPString,                                                      // a=x-qt-text-nam: line
+                 fInfoSDPString,                                                             // a=x-qt-text-inf: line
+                 fMiscSDPLines);                                                             // miscellaneous session SDP lines (if any)
+
+        // Then, add the (media-level) lines for each subsession:
+        char *mediaSDP = sdp;
+        for(subsession = fSubsessionsHead; subsession != NULL; subsession = subsession->fNext) {
+            unsigned mediaSDPLength = strlen(mediaSDP);
+            mediaSDP += mediaSDPLength;
+            sdpLength -= mediaSDPLength;
+            if(sdpLength <= 1)
+                break;  // the SDP has somehow become too long
+
+            char const *sdpLines = subsession->sdpLines(addressFamily);
+            if(sdpLines != NULL)
+                snprintf(mediaSDP, sdpLength, "%s", sdpLines);
+        }
+    } while(0);
+
+    delete[] rangeLine;
+    delete[] sourceFilterLine;
+    return sdp;
+}
+
+////////// ServerMediaSubsessionIterator //////////
+
+ServerMediaSubsessionIterator ::ServerMediaSubsessionIterator(ServerMediaSession &session) : fOurSession(session) {
+    reset();
+}
+
+ServerMediaSubsessionIterator::~ServerMediaSubsessionIterator() {}
+
+ServerMediaSubsession *ServerMediaSubsessionIterator::next() {
+    ServerMediaSubsession *result = fNextPtr;
+
+    if(fNextPtr != NULL)
+        fNextPtr = fNextPtr->fNext;
+
+    return result;
+}
+
+void ServerMediaSubsessionIterator::reset() {
+    fNextPtr = fOurSession.fSubsessionsHead;
+}
+
+////////// ServerMediaSubsession //////////
+
+ServerMediaSubsession::ServerMediaSubsession(UsageEnvironment &env) : Medium(env), fParentSession(NULL), fNext(NULL), fTrackNumber(0), fTrackId(NULL) {}
+
+ServerMediaSubsession::~ServerMediaSubsession() {
+    delete[](char *) fTrackId;
+    Medium::close(fNext);
+}
+
+char const *ServerMediaSubsession::trackId() {
+    if(fTrackNumber == 0)
+        return NULL;  // not yet in a ServerMediaSession
+
+    if(fTrackId == NULL) {
+        char buf[100];
+        sprintf(buf, "track%d", fTrackNumber);
+        fTrackId = strDup(buf);
+    }
+    return fTrackId;
+}
+
+void ServerMediaSubsession::pauseStream(unsigned /*clientSessionId*/, void * /*streamToken*/) {
+    // default implementation: do nothing
+}
+void ServerMediaSubsession::seekStream(unsigned /*clientSessionId*/, void * /*streamToken*/, double & /*seekNPT*/, double /*streamDuration*/,
+                                       u_int64_t &numBytes) {
+    // default implementation: do nothing
+    numBytes = 0;
+}
+void ServerMediaSubsession::seekStream(unsigned /*clientSessionId*/, void * /*streamToken*/, char *&absStart, char *&absEnd) {
+    // default implementation: do nothing (but delete[] and assign "absStart" and "absEnd" to NULL, to show that we don't handle this)
+    delete[] absStart;
+    absStart = NULL;
+    delete[] absEnd;
+    absEnd = NULL;
+}
+void ServerMediaSubsession::nullSeekStream(unsigned /*clientSessionId*/, void * /*streamToken*/, double streamEndTime, u_int64_t &numBytes) {
+    // default implementation: do nothing
+    numBytes = 0;
+}
+void ServerMediaSubsession::setStreamScale(unsigned /*clientSessionId*/, void * /*streamToken*/, float /*scale*/) {
+    // default implementation: do nothing
+}
+float ServerMediaSubsession::getCurrentNPT(void * /*streamToken*/) {
+    // default implementation: return 0.0
+    return 0.0;
+}
+FramedSource *ServerMediaSubsession::getStreamSource(void * /*streamToken*/) {
+    // default implementation: return NULL
+    return NULL;
+}
+void ServerMediaSubsession::deleteStream(unsigned /*clientSessionId*/, void *& /*streamToken*/) {
+    // default implementation: do nothing
+}
+
+void ServerMediaSubsession::testScaleFactor(float &scale) {
+    // default implementation: Support scale = 1 only
+    scale = 1;
+}
+
+float ServerMediaSubsession::duration() const {
+    // default implementation: assume an unbounded session:
+    return 0.0;
+}
+
+void ServerMediaSubsession::getAbsoluteTimeRange(char *&absStartTime, char *&absEndTime) const {
+    // default implementation: We don't support seeking by 'absolute' time, so indicate this by setting both parameters to NULL:
+    absStartTime = absEndTime = NULL;
+}
+
+char const *ServerMediaSubsession::rangeSDPLine() const {
+    // First, check for the special case where we support seeking by 'absolute' time:
+    char *absStart = NULL;
+    char *absEnd   = NULL;
+    getAbsoluteTimeRange(absStart, absEnd);
+    if(absStart != NULL) {
+        char buf[100];
+
+        if(absEnd != NULL) {
+            sprintf(buf, "a=range:clock=%s-%s\r\n", absStart, absEnd);
+        }
+        else {
+            sprintf(buf, "a=range:clock=%s-\r\n", absStart);
+        }
+        return strDup(buf);
+    }
+
+    if(fParentSession == NULL)
+        return NULL;
+
+    // If all of our parent's subsessions have the same duration
+    // (as indicated by "fParentSession->duration() >= 0"), there's no "a=range:" line:
+    if(fParentSession->duration() >= 0.0)
+        return strDup("");
+
+    // Use our own duration for a "a=range:" line:
+    float ourDuration = duration();
+    if(ourDuration == 0.0) {
+        return strDup("a=range:npt=now-\r\n");
+    }
+    else {
+        char buf[100];
+        sprintf(buf, "a=range:npt=0-%.3f\r\n", ourDuration);
+        return strDup(buf);
+    }
+}
diff --git a/3rdparty/live555/src/liveMedia/SimpleRTPSink.cpp b/3rdparty/live555/src/liveMedia/SimpleRTPSink.cpp
new file mode 100644
index 00000000..ba49b993
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/SimpleRTPSink.cpp
@@ -0,0 +1,70 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A simple RTP sink that packs frames into each outgoing
+//     packet, without any fragmentation or special headers.
+// Implementation
+
+#include "SimpleRTPSink.hh"
+
+SimpleRTPSink::SimpleRTPSink(UsageEnvironment &env, Groupsock *RTPgs, unsigned char rtpPayloadFormat, unsigned rtpTimestampFrequency,
+                             char const *sdpMediaTypeString, char const *rtpPayloadFormatName, unsigned numChannels, Boolean allowMultipleFramesPerPacket,
+                             Boolean doNormalMBitRule)
+    : MultiFramedRTPSink(env, RTPgs, rtpPayloadFormat, rtpTimestampFrequency, rtpPayloadFormatName, numChannels),
+      fAllowMultipleFramesPerPacket(allowMultipleFramesPerPacket),
+      fSetMBitOnNextPacket(False) {
+    fSDPMediaTypeString  = strDup(sdpMediaTypeString == NULL ? "unknown" : sdpMediaTypeString);
+    fSetMBitOnLastFrames = doNormalMBitRule && strcmp(fSDPMediaTypeString, "audio") != 0;
+}
+
+SimpleRTPSink::~SimpleRTPSink() {
+    delete[](char *) fSDPMediaTypeString;
+}
+
+SimpleRTPSink *SimpleRTPSink::createNew(UsageEnvironment &env, Groupsock *RTPgs, unsigned char rtpPayloadFormat, unsigned rtpTimestampFrequency,
+                                        char const *sdpMediaTypeString, char const *rtpPayloadFormatName, unsigned numChannels,
+                                        Boolean allowMultipleFramesPerPacket, Boolean doNormalMBitRule) {
+    return new SimpleRTPSink(env, RTPgs, rtpPayloadFormat, rtpTimestampFrequency, sdpMediaTypeString, rtpPayloadFormatName, numChannels,
+                             allowMultipleFramesPerPacket, doNormalMBitRule);
+}
+
+void SimpleRTPSink::doSpecialFrameHandling(unsigned fragmentationOffset, unsigned char *frameStart, unsigned numBytesInFrame,
+                                           struct timeval framePresentationTime, unsigned numRemainingBytes) {
+    if(numRemainingBytes == 0) {
+        // This packet contains the last (or only) fragment of the frame.
+        // Set the RTP 'M' ('marker') bit, if appropriate:
+        if(fSetMBitOnLastFrames)
+            setMarkerBit();
+    }
+    if(fSetMBitOnNextPacket) {
+        // An external object has asked for the 'M' bit to be set on the next packet:
+        setMarkerBit();
+        fSetMBitOnNextPacket = False;
+    }
+
+    // Important: Also call our base class's doSpecialFrameHandling(),
+    // to set the packet's timestamp:
+    MultiFramedRTPSink::doSpecialFrameHandling(fragmentationOffset, frameStart, numBytesInFrame, framePresentationTime, numRemainingBytes);
+}
+
+Boolean SimpleRTPSink::frameCanAppearAfterPacketStart(unsigned char const * /*frameStart*/, unsigned /*numBytesInFrame*/) const {
+    return fAllowMultipleFramesPerPacket;
+}
+
+char const *SimpleRTPSink::sdpMediaType() const {
+    return fSDPMediaTypeString;
+}
diff --git a/3rdparty/live555/src/liveMedia/SimpleRTPSource.cpp b/3rdparty/live555/src/liveMedia/SimpleRTPSource.cpp
new file mode 100644
index 00000000..c03c785d
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/SimpleRTPSource.cpp
@@ -0,0 +1,53 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A RTP source for a simple RTP payload format that
+//     - doesn't have any special headers following the RTP header
+//     - doesn't have any special framing apart from the packet data itself
+// Implementation
+
+#include "SimpleRTPSource.hh"
+#include <string.h>
+
+SimpleRTPSource *SimpleRTPSource::createNew(UsageEnvironment &env, Groupsock *RTPgs, unsigned char rtpPayloadFormat, unsigned rtpTimestampFrequency,
+                                            char const *mimeTypeString, unsigned offset, Boolean doNormalMBitRule) {
+    return new SimpleRTPSource(env, RTPgs, rtpPayloadFormat, rtpTimestampFrequency, mimeTypeString, offset, doNormalMBitRule);
+}
+
+SimpleRTPSource ::SimpleRTPSource(UsageEnvironment &env, Groupsock *RTPgs, unsigned char rtpPayloadFormat, unsigned rtpTimestampFrequency,
+                                  char const *mimeTypeString, unsigned offset, Boolean doNormalMBitRule)
+    : MultiFramedRTPSource(env, RTPgs, rtpPayloadFormat, rtpTimestampFrequency), fMIMEtypeString(strDup(mimeTypeString)), fOffset(offset) {
+    fUseMBitForFrameEnd = doNormalMBitRule && strncmp(mimeTypeString, "audio/", 6) != 0;
+}
+
+SimpleRTPSource::~SimpleRTPSource() {
+    delete[](char *) fMIMEtypeString;
+}
+
+Boolean SimpleRTPSource ::processSpecialHeader(BufferedPacket *packet, unsigned &resultSpecialHeaderSize) {
+    fCurrentPacketCompletesFrame = !fUseMBitForFrameEnd || packet->rtpMarkerBit();
+
+    resultSpecialHeaderSize = fOffset;
+    return True;
+}
+
+char const *SimpleRTPSource::MIMEtype() const {
+    if(fMIMEtypeString == NULL)
+        return MultiFramedRTPSource::MIMEtype();
+
+    return fMIMEtypeString;
+}
diff --git a/3rdparty/live555/src/liveMedia/StreamParser.cpp b/3rdparty/live555/src/liveMedia/StreamParser.cpp
new file mode 100644
index 00000000..93da7d26
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/StreamParser.cpp
@@ -0,0 +1,211 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// Abstract class for parsing a byte stream
+// Implementation
+
+#include "StreamParser.hh"
+
+#include <string.h>
+#include <stdlib.h>
+
+#define BANK_SIZE 150000
+
+void StreamParser::flushInput() {
+    fCurParserIndex = fSavedParserIndex = 0;
+    fSavedRemainingUnparsedBits = fRemainingUnparsedBits = 0;
+    fTotNumValidBytes                                    = 0;
+}
+
+StreamParser::StreamParser(FramedSource *inputSource, FramedSource::onCloseFunc *onInputCloseFunc, void *onInputCloseClientData,
+                           clientContinueFunc *clientContinueFunc, void *clientContinueClientData)
+    : fInputSource(inputSource),
+      fClientOnInputCloseFunc(onInputCloseFunc),
+      fClientOnInputCloseClientData(onInputCloseClientData),
+      fClientContinueFunc(clientContinueFunc),
+      fClientContinueClientData(clientContinueClientData),
+      fSavedParserIndex(0),
+      fSavedRemainingUnparsedBits(0),
+      fCurParserIndex(0),
+      fRemainingUnparsedBits(0),
+      fTotNumValidBytes(0),
+      fHaveSeenEOF(False) {
+    fBank[0]    = new unsigned char[BANK_SIZE];
+    fBank[1]    = new unsigned char[BANK_SIZE];
+    fCurBankNum = 0;
+    fCurBank    = fBank[fCurBankNum];
+
+    fLastSeenPresentationTime.tv_sec  = 0;
+    fLastSeenPresentationTime.tv_usec = 0;
+}
+
+StreamParser::~StreamParser() {
+    delete[] fBank[0];
+    delete[] fBank[1];
+}
+
+void StreamParser::saveParserState() {
+    fSavedParserIndex           = fCurParserIndex;
+    fSavedRemainingUnparsedBits = fRemainingUnparsedBits;
+}
+
+void StreamParser::restoreSavedParserState() {
+    fCurParserIndex        = fSavedParserIndex;
+    fRemainingUnparsedBits = fSavedRemainingUnparsedBits;
+}
+
+void StreamParser::skipBits(unsigned numBits) {
+    if(numBits <= fRemainingUnparsedBits) {
+        fRemainingUnparsedBits -= numBits;
+    }
+    else {
+        numBits -= fRemainingUnparsedBits;
+
+        unsigned numBytesToExamine = (numBits + 7) / 8;  // round up
+        ensureValidBytes(numBytesToExamine);
+        fCurParserIndex += numBytesToExamine;
+
+        fRemainingUnparsedBits = 8 * numBytesToExamine - numBits;
+    }
+}
+
+unsigned StreamParser::getBits(unsigned numBits) {
+    if(numBits <= fRemainingUnparsedBits) {
+        unsigned char lastByte = *lastParsed();
+        lastByte >>= (fRemainingUnparsedBits - numBits);
+        fRemainingUnparsedBits -= numBits;
+
+        return (unsigned)lastByte & ~((~0u) << numBits);
+    }
+    else {
+        unsigned char lastByte;
+        if(fRemainingUnparsedBits > 0) {
+            lastByte = *lastParsed();
+        }
+        else {
+            lastByte = 0;
+        }
+
+        unsigned remainingBits = numBits - fRemainingUnparsedBits;  // > 0
+
+        // For simplicity, read the next 4 bytes, even though we might not
+        // need all of them here:
+        unsigned result = test4Bytes();
+
+        result >>= (32 - remainingBits);
+        result |= (lastByte << remainingBits);
+        if(numBits < 32)
+            result &= ~((~0u) << numBits);
+
+        unsigned const numRemainingBytes = (remainingBits + 7) / 8;
+        fCurParserIndex += numRemainingBytes;
+        fRemainingUnparsedBits = 8 * numRemainingBytes - remainingBits;
+
+        return result;
+    }
+}
+
+unsigned StreamParser::bankSize() const {
+    return BANK_SIZE;
+}
+
+#define NO_MORE_BUFFERED_INPUT 1
+
+void StreamParser::ensureValidBytes1(unsigned numBytesNeeded) {
+    // We need to read some more bytes from the input source.
+    // First, clarify how much data to ask for:
+    unsigned maxInputFrameSize = fInputSource->maxFrameSize();
+    if(maxInputFrameSize > numBytesNeeded)
+        numBytesNeeded = maxInputFrameSize;
+
+    // First, check whether these new bytes would overflow the current
+    // bank.  If so, start using a new bank now.
+    if(fCurParserIndex + numBytesNeeded > BANK_SIZE) {
+        // Swap banks, but save any still-needed bytes from the old bank:
+        unsigned             numBytesToSave = fTotNumValidBytes - fSavedParserIndex;
+        unsigned char const *from           = &curBank()[fSavedParserIndex];
+
+        fCurBankNum = (fCurBankNum + 1) % 2;
+        fCurBank    = fBank[fCurBankNum];
+        memmove(curBank(), from, numBytesToSave);
+        fCurParserIndex   = fCurParserIndex - fSavedParserIndex;
+        fSavedParserIndex = 0;
+        fTotNumValidBytes = numBytesToSave;
+    }
+
+    // ASSERT: fCurParserIndex + numBytesNeeded > fTotNumValidBytes
+    //      && fCurParserIndex + numBytesNeeded <= BANK_SIZE
+    if(fCurParserIndex + numBytesNeeded > BANK_SIZE) {
+        // If this happens, it means that we have too much saved parser state.
+        // To fix this, increase BANK_SIZE as appropriate.
+        fInputSource->envir() << "StreamParser internal error (" << fCurParserIndex << " + " << numBytesNeeded << " > " << BANK_SIZE << ")\n";
+        fInputSource->envir().internalError();
+    }
+
+    // Try to read as many new bytes as will fit in the current bank:
+    unsigned maxNumBytesToRead = BANK_SIZE - fTotNumValidBytes;
+    fInputSource->getNextFrame(&curBank()[fTotNumValidBytes], maxNumBytesToRead, afterGettingBytes, this, onInputClosure, this);
+
+    throw NO_MORE_BUFFERED_INPUT;
+}
+
+void StreamParser::afterGettingBytes(void *clientData, unsigned numBytesRead, unsigned /*numTruncatedBytes*/, struct timeval presentationTime,
+                                     unsigned /*durationInMicroseconds*/) {
+    StreamParser *parser = (StreamParser *)clientData;
+    if(parser != NULL)
+        parser->afterGettingBytes1(numBytesRead, presentationTime);
+}
+
+void StreamParser::afterGettingBytes1(unsigned numBytesRead, struct timeval presentationTime) {
+    // Sanity check: Make sure we didn't get too many bytes for our bank:
+    if(fTotNumValidBytes + numBytesRead > BANK_SIZE) {
+        fInputSource->envir() << "StreamParser::afterGettingBytes() warning: read " << numBytesRead << " bytes; expected no more than "
+                              << BANK_SIZE - fTotNumValidBytes << "\n";
+    }
+
+    fLastSeenPresentationTime = presentationTime;
+
+    unsigned char *ptr = &curBank()[fTotNumValidBytes];
+    fTotNumValidBytes += numBytesRead;
+
+    // Continue our original calling source where it left off:
+    restoreSavedParserState();
+    // Sigh... this is a crock; things would have been a lot simpler
+    // here if we were using threads, with synchronous I/O...
+    fClientContinueFunc(fClientContinueClientData, ptr, numBytesRead, presentationTime);
+}
+
+void StreamParser::onInputClosure(void *clientData) {
+    StreamParser *parser = (StreamParser *)clientData;
+    if(parser != NULL)
+        parser->onInputClosure1();
+}
+
+void StreamParser::onInputClosure1() {
+    if(!fHaveSeenEOF) {
+        // We're hitting EOF for the first time.  Set our 'EOF' flag, and continue parsing, as if we'd just read 0 bytes of data.
+        // This allows the parser to re-parse any remaining unparsed data (perhaps while testing for EOF at the end):
+        fHaveSeenEOF = True;
+        afterGettingBytes1(0, fLastSeenPresentationTime);
+    }
+    else {
+        // We're hitting EOF for the second time.  Now, we handle the source input closure:
+        fHaveSeenEOF = False;
+        if(fClientOnInputCloseFunc != NULL)
+            (*fClientOnInputCloseFunc)(fClientOnInputCloseClientData);
+    }
+}
diff --git a/3rdparty/live555/src/liveMedia/StreamParser.hh b/3rdparty/live555/src/liveMedia/StreamParser.hh
new file mode 100644
index 00000000..b80de425
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/StreamParser.hh
@@ -0,0 +1,167 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// Abstract class for parsing a byte stream
+// C++ header
+
+#ifndef _STREAM_PARSER_HH
+#define _STREAM_PARSER_HH
+
+#ifndef _FRAMED_SOURCE_HH
+#include "FramedSource.hh"
+#endif
+
+class StreamParser {
+public:
+  virtual void flushInput();
+
+protected: // we're a virtual base class
+  typedef void (clientContinueFunc)(void* clientData,
+				    unsigned char* ptr, unsigned size,
+				    struct timeval presentationTime);
+  StreamParser(FramedSource* inputSource,
+	       FramedSource::onCloseFunc* onInputCloseFunc,
+	       void* onInputCloseClientData,
+	       clientContinueFunc* clientContinueFunc,
+	       void* clientContinueClientData);
+  virtual ~StreamParser();
+
+  void saveParserState();
+  virtual void restoreSavedParserState();
+
+  u_int32_t get4Bytes() { // byte-aligned; returned in big-endian order
+    u_int32_t result = test4Bytes();
+    fCurParserIndex += 4;
+    fRemainingUnparsedBits = 0;
+
+    return result;
+  }
+  u_int32_t test4Bytes() { // as above, but doesn't advance ptr
+    ensureValidBytes(4);
+
+    unsigned char const* ptr = nextToParse();
+    return (ptr[0]<<24)|(ptr[1]<<16)|(ptr[2]<<8)|ptr[3];
+  }
+
+  u_int16_t get2Bytes() {
+    ensureValidBytes(2);
+
+    unsigned char const* ptr = nextToParse();
+    u_int16_t result = (ptr[0]<<8)|ptr[1];
+
+    fCurParserIndex += 2;
+    fRemainingUnparsedBits = 0;
+
+    return result;
+  }
+  u_int16_t test2Bytes() {
+    ensureValidBytes(2);
+
+    unsigned char const* ptr = nextToParse();
+    return (ptr[0]<<8)|ptr[1];
+  }
+
+
+  u_int8_t get1Byte() { // byte-aligned
+    ensureValidBytes(1);
+    fRemainingUnparsedBits = 0;
+    return curBank()[fCurParserIndex++];
+  }
+  u_int8_t test1Byte() { // as above, but doesn't advance ptr
+    ensureValidBytes(1);
+    return nextToParse()[0];
+  }
+
+  void getBytes(u_int8_t* to, unsigned numBytes) {
+    testBytes(to, numBytes);
+    fCurParserIndex += numBytes;
+    fRemainingUnparsedBits = 0;
+  }
+  void testBytes(u_int8_t* to, unsigned numBytes) { // as above, but doesn't advance ptr
+    ensureValidBytes(numBytes);
+    memmove(to, nextToParse(), numBytes);
+  }
+  void skipBytes(unsigned numBytes) {
+    ensureValidBytes(numBytes);
+    fCurParserIndex += numBytes;
+  }
+
+  void skipBits(unsigned numBits);
+  unsigned getBits(unsigned numBits);
+      // numBits <= 32; returns data into low-order bits of result
+
+  unsigned curOffset() const { return fCurParserIndex; }
+
+  unsigned& totNumValidBytes() { return fTotNumValidBytes; }
+
+  Boolean haveSeenEOF() const { return fHaveSeenEOF; }
+
+  unsigned bankSize() const;
+
+private:
+  unsigned char* curBank() { return fCurBank; }
+  unsigned char* nextToParse() { return &curBank()[fCurParserIndex]; }
+  unsigned char* lastParsed() { return &curBank()[fCurParserIndex-1]; }
+
+  // makes sure that at least "numBytes" valid bytes remain:
+  void ensureValidBytes(unsigned numBytesNeeded) {
+    // common case: inlined:
+    if (fCurParserIndex + numBytesNeeded <= fTotNumValidBytes) return;
+
+    ensureValidBytes1(numBytesNeeded);
+  }
+  void ensureValidBytes1(unsigned numBytesNeeded);
+
+  static void afterGettingBytes(void* clientData, unsigned numBytesRead,
+				unsigned numTruncatedBytes,
+				struct timeval presentationTime,
+				unsigned durationInMicroseconds);
+  void afterGettingBytes1(unsigned numBytesRead, struct timeval presentationTime);
+
+  static void onInputClosure(void* clientData);
+  void onInputClosure1();
+
+private:
+  FramedSource* fInputSource; // should be a byte-stream source??
+  FramedSource::onCloseFunc* fClientOnInputCloseFunc;
+  void* fClientOnInputCloseClientData;
+  clientContinueFunc* fClientContinueFunc;
+  void* fClientContinueClientData;
+
+  // Use a pair of 'banks', and swap between them as they fill up:
+  unsigned char* fBank[2];
+  unsigned char fCurBankNum;
+  unsigned char* fCurBank;
+
+  // The most recent 'saved' parse position:
+  unsigned fSavedParserIndex; // <= fCurParserIndex
+  unsigned char fSavedRemainingUnparsedBits;
+
+  // The current position of the parser within the current bank:
+  unsigned fCurParserIndex; // <= fTotNumValidBytes
+  unsigned char fRemainingUnparsedBits; // in previous byte: [0,7]
+
+  // The total number of valid bytes stored in the current bank:
+  unsigned fTotNumValidBytes; // <= BANK_SIZE
+
+  // Whether we have seen EOF on the input source:
+  Boolean fHaveSeenEOF;
+
+  struct timeval fLastSeenPresentationTime; // hack used for EOF handling
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/StreamReplicator.cpp b/3rdparty/live555/src/liveMedia/StreamReplicator.cpp
new file mode 100644
index 00000000..0d310f0d
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/StreamReplicator.cpp
@@ -0,0 +1,347 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// An class that can be used to create (possibly multiple) 'replicas' of an incoming stream.
+// Implementation.
+
+#include "StreamReplicator.hh"
+
+////////// Definition of "StreamReplica": The class that implements each stream replica //////////
+
+class StreamReplica : public FramedSource {
+protected:
+    friend class StreamReplicator;
+    StreamReplica(StreamReplicator &ourReplicator);  // called only by "StreamReplicator::createStreamReplica()"
+    virtual ~StreamReplica();
+
+private:  // redefined virtual functions:
+    virtual void doGetNextFrame();
+    virtual void doStopGettingFrames();
+
+private:
+    static void copyReceivedFrame(StreamReplica *toReplica, StreamReplica *fromReplica);
+
+private:
+    StreamReplicator &fOurReplicator;
+    int               fFrameIndex;  // 0 or 1, depending upon which frame we're currently requesting; could also be -1 if we've stopped playing
+
+    // Replicas that are currently awaiting data are kept in a (singly-linked) list:
+    StreamReplica *fNext;
+};
+
+////////// StreamReplicator implementation //////////
+
+StreamReplicator *StreamReplicator::createNew(UsageEnvironment &env, FramedSource *inputSource, Boolean deleteWhenLastReplicaDies) {
+    return new StreamReplicator(env, inputSource, deleteWhenLastReplicaDies);
+}
+
+StreamReplicator::StreamReplicator(UsageEnvironment &env, FramedSource *inputSource, Boolean deleteWhenLastReplicaDies)
+    : Medium(env),
+      fInputSource(inputSource),
+      fDeleteWhenLastReplicaDies(deleteWhenLastReplicaDies),
+      fInputSourceHasClosed(False),
+      fNumReplicas(0),
+      fNumActiveReplicas(0),
+      fNumDeliveriesMadeSoFar(0),
+      fFrameIndex(0),
+      fPrimaryReplica(NULL),
+      fReplicasAwaitingCurrentFrame(NULL),
+      fReplicasAwaitingNextFrame(NULL) {}
+
+StreamReplicator::~StreamReplicator() {
+    Medium::close(fInputSource);
+}
+
+FramedSource *StreamReplicator::createStreamReplica() {
+    ++fNumReplicas;
+    return new StreamReplica(*this);
+}
+
+void StreamReplicator::getNextFrame(StreamReplica *replica) {
+    if(fInputSourceHasClosed) {  // handle closure instead
+        replica->handleClosure();
+        return;
+    }
+
+    if(replica->fFrameIndex == -1) {
+        // This replica had stopped playing (or had just been created), but is now actively reading.  Note this:
+        replica->fFrameIndex = fFrameIndex;
+        ++fNumActiveReplicas;
+    }
+
+    if(fPrimaryReplica == NULL) {
+        // This is the first replica to request the next unread frame.  Make it the 'primary' replica - meaning that we read the frame
+        // into its buffer, and then copy from this into the other replicas' buffers.
+        fPrimaryReplica = replica;
+
+        // Arrange to read the next frame into this replica's buffer:
+        if(fInputSource != NULL)
+            fInputSource->getNextFrame(fPrimaryReplica->fTo, fPrimaryReplica->fMaxSize, afterGettingFrame, this, onSourceClosure, this);
+    }
+    else if(replica->fFrameIndex != fFrameIndex) {
+        // This replica is already asking for the next frame (because it has already received the current frame).  Enqueue it:
+        replica->fNext             = fReplicasAwaitingNextFrame;
+        fReplicasAwaitingNextFrame = replica;
+    }
+    else {
+        // This replica is asking for the current frame.  Enqueue it:
+        replica->fNext                = fReplicasAwaitingCurrentFrame;
+        fReplicasAwaitingCurrentFrame = replica;
+
+        if(fInputSource != NULL && !fInputSource->isCurrentlyAwaitingData()) {
+            // The current frame has already arrived, so deliver it to this replica now:
+            deliverReceivedFrame();
+        }
+    }
+}
+
+void StreamReplicator::deactivateStreamReplica(StreamReplica *replicaBeingDeactivated) {
+    if(replicaBeingDeactivated->fFrameIndex == -1)
+        return;  // this replica has already been deactivated (or was never activated at all)
+
+    // Assert: fNumActiveReplicas > 0
+    if(fNumActiveReplicas == 0)
+        fprintf(stderr, "StreamReplicator::deactivateStreamReplica() Internal Error!\n");  // should not happen
+    --fNumActiveReplicas;
+
+    // Forget about any frame delivery that might have just been made to this replica:
+    if(replicaBeingDeactivated->fFrameIndex != fFrameIndex && fNumDeliveriesMadeSoFar > 0)
+        --fNumDeliveriesMadeSoFar;
+
+    replicaBeingDeactivated->fFrameIndex = -1;
+
+    // Check whether the replica being deactivated is the 'primary' replica, or is enqueued awaiting a frame:
+    if(replicaBeingDeactivated == fPrimaryReplica) {
+        // We need to replace the 'primary replica', if we can:
+        if(fReplicasAwaitingCurrentFrame == NULL) {
+            // There's currently no replacement 'primary replica'
+            fPrimaryReplica = NULL;
+        }
+        else {
+            // There's another replica that we can use as a replacement 'primary replica':
+            fPrimaryReplica               = fReplicasAwaitingCurrentFrame;
+            fReplicasAwaitingCurrentFrame = fReplicasAwaitingCurrentFrame->fNext;
+            fPrimaryReplica->fNext        = NULL;
+        }
+
+        // Check whether the read into the old primary replica's buffer is still pending, or has completed:
+        if(fInputSource != NULL) {
+            if(fInputSource->isCurrentlyAwaitingData()) {
+                // We have a pending read into the old primary replica's buffer.
+                // We need to stop it, and retry the read with a new primary (if available)
+                fInputSource->stopGettingFrames();
+
+                if(fPrimaryReplica != NULL) {
+                    fInputSource->getNextFrame(fPrimaryReplica->fTo, fPrimaryReplica->fMaxSize, afterGettingFrame, this, onSourceClosure, this);
+                }
+            }
+            else {
+                // The read into the old primary replica's buffer has already completed.  Copy the data to the new primary replica (if any):
+                if(fPrimaryReplica != NULL) {
+                    StreamReplica::copyReceivedFrame(fPrimaryReplica, replicaBeingDeactivated);
+                }
+                else {
+                    // We don't have a new primary replica, so we can't copy the received frame to any new replica that might ask for it.
+                    // Fortunately this should be a very rare occurrence.
+                }
+            }
+        }
+    }
+    else {
+        // The replica that's being removed was not our 'primary replica', but make sure it's not on either of our queues:
+        if(fReplicasAwaitingCurrentFrame != NULL) {
+            if(replicaBeingDeactivated == fReplicasAwaitingCurrentFrame) {
+                fReplicasAwaitingCurrentFrame  = replicaBeingDeactivated->fNext;
+                replicaBeingDeactivated->fNext = NULL;
+            }
+            else {
+                for(StreamReplica *r1 = fReplicasAwaitingCurrentFrame; r1->fNext != NULL; r1 = r1->fNext) {
+                    if(r1->fNext == replicaBeingDeactivated) {
+                        r1->fNext                      = replicaBeingDeactivated->fNext;
+                        replicaBeingDeactivated->fNext = NULL;
+                        break;
+                    }
+                }
+            }
+        }
+        if(fReplicasAwaitingNextFrame != NULL) {
+            if(replicaBeingDeactivated == fReplicasAwaitingNextFrame) {
+                fReplicasAwaitingNextFrame     = replicaBeingDeactivated->fNext;
+                replicaBeingDeactivated->fNext = NULL;
+            }
+            else {
+                for(StreamReplica *r2 = fReplicasAwaitingNextFrame; r2->fNext != NULL; r2 = r2->fNext) {
+                    if(r2->fNext == replicaBeingDeactivated) {
+                        r2->fNext                      = replicaBeingDeactivated->fNext;
+                        replicaBeingDeactivated->fNext = NULL;
+                        break;
+                    }
+                }
+            }
+        }
+
+        // Check for the possibility that - now that a replica has been deactivated - all other
+        // replicas have received the current frame, and so now we need to complete delivery to
+        // the primary replica:
+        if(fPrimaryReplica != NULL && fInputSource != NULL && !fInputSource->isCurrentlyAwaitingData())
+            deliverReceivedFrame();
+    }
+
+    if(fNumActiveReplicas == 0 && fInputSource != NULL)
+        fInputSource->stopGettingFrames();  // tell our source to stop too
+}
+
+void StreamReplicator::removeStreamReplica(StreamReplica *replicaBeingRemoved) {
+    // First, handle the replica that's being removed the same way that we would if it were merely being deactivated:
+    deactivateStreamReplica(replicaBeingRemoved);
+
+    // Assert: fNumReplicas > 0
+    if(fNumReplicas == 0)
+        fprintf(stderr, "StreamReplicator::removeStreamReplica() Internal Error!\n");  // should not happen
+    --fNumReplicas;
+
+    // If this was the last replica, then delete ourselves (if we were set up to do so):
+    if(fNumReplicas == 0 && fDeleteWhenLastReplicaDies) {
+        Medium::close(this);
+        return;
+    }
+}
+
+void StreamReplicator::afterGettingFrame(void *clientData, unsigned frameSize, unsigned numTruncatedBytes, struct timeval presentationTime,
+                                         unsigned durationInMicroseconds) {
+    ((StreamReplicator *)clientData)->afterGettingFrame(frameSize, numTruncatedBytes, presentationTime, durationInMicroseconds);
+}
+
+void StreamReplicator::afterGettingFrame(unsigned frameSize, unsigned numTruncatedBytes, struct timeval presentationTime, unsigned durationInMicroseconds) {
+    // The frame was read into our primary replica's buffer.  Update the primary replica's state, but don't complete delivery to it
+    // just yet.  We do that later, after we're sure that we've delivered it to all other replicas.
+    fPrimaryReplica->fFrameSize              = frameSize;
+    fPrimaryReplica->fNumTruncatedBytes      = numTruncatedBytes;
+    fPrimaryReplica->fPresentationTime       = presentationTime;
+    fPrimaryReplica->fDurationInMicroseconds = durationInMicroseconds;
+
+    deliverReceivedFrame();
+}
+
+void StreamReplicator::onSourceClosure(void *clientData) {
+    ((StreamReplicator *)clientData)->onSourceClosure();
+}
+
+void StreamReplicator::onSourceClosure() {
+    fInputSourceHasClosed = True;
+
+    // Signal the closure to each replica that is currently awaiting a frame:
+    StreamReplica *replica;
+    while((replica = fReplicasAwaitingCurrentFrame) != NULL) {
+        fReplicasAwaitingCurrentFrame = replica->fNext;
+        replica->fNext                = NULL;
+        replica->handleClosure();
+    }
+    while((replica = fReplicasAwaitingNextFrame) != NULL) {
+        fReplicasAwaitingNextFrame = replica->fNext;
+        replica->fNext             = NULL;
+        replica->handleClosure();
+    }
+    if((replica = fPrimaryReplica) != NULL) {
+        fPrimaryReplica = NULL;
+        replica->handleClosure();
+    }
+}
+
+void StreamReplicator::deliverReceivedFrame() {
+    // The 'primary replica' has received its copy of the current frame.
+    // Copy it (and complete delivery) to any other replica that has requested this frame.
+    // Then, if no more requests for this frame are expected, complete delivery to the 'primary replica' itself.
+    StreamReplica *replica;
+    while((replica = fReplicasAwaitingCurrentFrame) != NULL) {
+        fReplicasAwaitingCurrentFrame = replica->fNext;
+        replica->fNext                = NULL;
+
+        // Assert: fPrimaryReplica != NULL
+        if(fPrimaryReplica == NULL)
+            fprintf(stderr, "StreamReplicator::deliverReceivedFrame() Internal Error 1!\n");  // shouldn't happen
+        StreamReplica::copyReceivedFrame(replica, fPrimaryReplica);
+        replica->fFrameIndex = 1 - replica->fFrameIndex;  // toggle it (0<->1), because this replica no longer awaits the current frame
+        ++fNumDeliveriesMadeSoFar;
+
+        // Assert: fNumDeliveriesMadeSoFar < fNumActiveReplicas; // because we still have the 'primary replica' to deliver to
+        if(!(fNumDeliveriesMadeSoFar < fNumActiveReplicas))
+            fprintf(stderr, "StreamReplicator::deliverReceivedFrame() Internal Error 2(%d,%d)!\n", fNumDeliveriesMadeSoFar,
+                    fNumActiveReplicas);  // should not happen
+
+        // Complete delivery to this replica:
+        FramedSource::afterGetting(replica);
+    }
+
+    if(fNumDeliveriesMadeSoFar == fNumActiveReplicas - 1 && fPrimaryReplica != NULL) {
+        // No more requests for this frame are expected, so complete delivery to the 'primary replica':
+        replica                 = fPrimaryReplica;
+        fPrimaryReplica         = NULL;
+        replica->fFrameIndex    = 1 - replica->fFrameIndex;  // toggle it (0<->1), because this replica no longer awaits the current frame
+        fFrameIndex             = 1 - fFrameIndex;           // toggle it (0<->1) for the next frame
+        fNumDeliveriesMadeSoFar = 0;                         // reset for the next frame
+
+        if(fReplicasAwaitingNextFrame != NULL) {
+            // One of the other replicas has already requested the next frame, so make it the next 'primary replica':
+            fPrimaryReplica            = fReplicasAwaitingNextFrame;
+            fReplicasAwaitingNextFrame = fReplicasAwaitingNextFrame->fNext;
+            fPrimaryReplica->fNext     = NULL;
+
+            // Arrange to read the next frame into this replica's buffer:
+            if(fInputSource != NULL)
+                fInputSource->getNextFrame(fPrimaryReplica->fTo, fPrimaryReplica->fMaxSize, afterGettingFrame, this, onSourceClosure, this);
+        }
+
+        // Move any other replicas that had already requested the next frame to the 'requesting current frame' list:
+        // Assert: fReplicasAwaitingCurrentFrame == NULL;
+        if(!(fReplicasAwaitingCurrentFrame == NULL))
+            fprintf(stderr, "StreamReplicator::deliverReceivedFrame() Internal Error 3!\n");  // should not happen
+        fReplicasAwaitingCurrentFrame = fReplicasAwaitingNextFrame;
+        fReplicasAwaitingNextFrame    = NULL;
+
+        // Complete delivery to the 'primary' replica (thereby completing all deliveries for this frame):
+        FramedSource::afterGetting(replica);
+    }
+}
+
+////////// StreamReplica implementation //////////
+
+StreamReplica::StreamReplica(StreamReplicator &ourReplicator)
+    : FramedSource(ourReplicator.envir()), fOurReplicator(ourReplicator), fFrameIndex(-1 /*we haven't started playing yet*/), fNext(NULL) {}
+
+StreamReplica::~StreamReplica() {
+    fOurReplicator.removeStreamReplica(this);
+}
+
+void StreamReplica::doGetNextFrame() {
+    fOurReplicator.getNextFrame(this);
+}
+
+void StreamReplica::doStopGettingFrames() {
+    fOurReplicator.deactivateStreamReplica(this);
+}
+
+void StreamReplica::copyReceivedFrame(StreamReplica *toReplica, StreamReplica *fromReplica) {
+    // First, figure out how much data to copy.  ("toReplica" might have a smaller buffer than "fromReplica".)
+    unsigned numNewBytesToTruncate = toReplica->fMaxSize < fromReplica->fFrameSize ? fromReplica->fFrameSize - toReplica->fMaxSize : 0;
+    toReplica->fFrameSize          = fromReplica->fFrameSize - numNewBytesToTruncate;
+    toReplica->fNumTruncatedBytes  = fromReplica->fNumTruncatedBytes + numNewBytesToTruncate;
+
+    memmove(toReplica->fTo, fromReplica->fTo, toReplica->fFrameSize);
+    toReplica->fPresentationTime       = fromReplica->fPresentationTime;
+    toReplica->fDurationInMicroseconds = fromReplica->fDurationInMicroseconds;
+}
diff --git a/3rdparty/live555/src/liveMedia/T140TextRTPSink.cpp b/3rdparty/live555/src/liveMedia/T140TextRTPSink.cpp
new file mode 100644
index 00000000..1bc3d49a
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/T140TextRTPSink.cpp
@@ -0,0 +1,175 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// RTP sink for T.140 text (RFC 2793)
+// Implementation
+
+#include "T140TextRTPSink.hh"
+#include <GroupsockHelper.hh>  // for "gettimeofday()"
+
+////////// T140TextRTPSink implementation //////////
+
+T140TextRTPSink::T140TextRTPSink(UsageEnvironment &env, Groupsock *RTPgs, unsigned char rtpPayloadFormat)
+    : TextRTPSink(env, RTPgs, rtpPayloadFormat, 1000 /*mandatory RTP timestamp frequency for this payload format*/, "T140"),
+      fOurIdleFilter(NULL),
+      fAreInIdlePeriod(True) {}
+
+T140TextRTPSink::~T140TextRTPSink() {
+    fSource = fOurIdleFilter;  // hack: in case "fSource" had gotten set to NULL before we were called
+    stopPlaying();             // call this now, because we won't have our 'idle filter' when the base class destructor calls it later.
+
+    // Close our 'idle filter' as well:
+    Medium::close(fOurIdleFilter);
+    fSource = NULL;  // for the base class destructor, which gets called next
+}
+
+T140TextRTPSink *T140TextRTPSink::createNew(UsageEnvironment &env, Groupsock *RTPgs, unsigned char rtpPayloadFormat) {
+    return new T140TextRTPSink(env, RTPgs, rtpPayloadFormat);
+}
+
+Boolean T140TextRTPSink::continuePlaying() {
+    // First, check whether we have an 'idle filter' set up yet. If not, create it now, and insert it in front of our existing source:
+    if(fOurIdleFilter == NULL) {
+        fOurIdleFilter = new T140IdleFilter(envir(), fSource);
+    }
+    else {
+        fOurIdleFilter->reassignInputSource(fSource);
+    }
+    fSource = fOurIdleFilter;
+
+    // Then call the parent class's implementation:
+    return MultiFramedRTPSink::continuePlaying();
+}
+
+void T140TextRTPSink::doSpecialFrameHandling(unsigned /*fragmentationOffset*/, unsigned char * /*frameStart*/, unsigned numBytesInFrame,
+                                             struct timeval framePresentationTime, unsigned /*numRemainingBytes*/) {
+    // Set the RTP 'M' (marker) bit if we have just ended an idle period - i.e., if we were in an idle period, but just got data:
+    if(fAreInIdlePeriod && numBytesInFrame > 0)
+        setMarkerBit();
+    fAreInIdlePeriod = numBytesInFrame == 0;
+
+    setTimestamp(framePresentationTime);
+}
+
+Boolean T140TextRTPSink::frameCanAppearAfterPacketStart(unsigned char const * /*frameStart*/, unsigned /*numBytesInFrame*/) const {
+    return False;  // We don't concatenate input data; instead, send it out immediately
+}
+
+////////// T140IdleFilter implementation //////////
+
+T140IdleFilter::T140IdleFilter(UsageEnvironment &env, FramedSource *inputSource)
+    : FramedFilter(env, inputSource), fIdleTimerTask(NULL), fBufferSize(OutPacketBuffer::maxSize), fNumBufferedBytes(0) {
+    fBuffer = new char[fBufferSize];
+}
+
+T140IdleFilter::~T140IdleFilter() {
+    envir().taskScheduler().unscheduleDelayedTask(fIdleTimerTask);
+
+    delete[] fBuffer;
+    detachInputSource();  // so that the subsequent ~FramedFilter() doesn't delete it
+}
+
+#define IDLE_TIMEOUT_MICROSECONDS 300000 /* 300 ms */
+
+void T140IdleFilter::doGetNextFrame() {
+    // First, see if we have buffered data that we can deliver:
+    if(fNumBufferedBytes > 0) {
+        deliverFromBuffer();
+        return;
+    }
+
+    // We don't have any buffered data, so ask our input source for data (unless we've already done so).
+    // But also set a timer to expire if this doesn't arrive promptly:
+    fIdleTimerTask = envir().taskScheduler().scheduleDelayedTask(IDLE_TIMEOUT_MICROSECONDS, handleIdleTimeout, this);
+    if(fInputSource != NULL && !fInputSource->isCurrentlyAwaitingData()) {
+        fInputSource->getNextFrame((unsigned char *)fBuffer, fBufferSize, afterGettingFrame, this, onSourceClosure, this);
+    }
+}
+
+void T140IdleFilter::afterGettingFrame(void *clientData, unsigned frameSize, unsigned numTruncatedBytes, struct timeval presentationTime,
+                                       unsigned durationInMicroseconds) {
+    ((T140IdleFilter *)clientData)->afterGettingFrame(frameSize, numTruncatedBytes, presentationTime, durationInMicroseconds);
+}
+
+void T140IdleFilter::afterGettingFrame(unsigned frameSize, unsigned numTruncatedBytes, struct timeval presentationTime, unsigned durationInMicroseconds) {
+    // First, cancel any pending idle timer:
+    envir().taskScheduler().unscheduleDelayedTask(fIdleTimerTask);
+
+    // Then note the new data that we have in our buffer:
+    fNumBufferedBytes                   = frameSize;
+    fBufferedNumTruncatedBytes          = numTruncatedBytes;
+    fBufferedDataPresentationTime       = presentationTime;
+    fBufferedDataDurationInMicroseconds = durationInMicroseconds;
+
+    // Then, attempt to deliver this data.  (If we can't deliver it now, we'll do so the next time the reader asks for data.)
+    if(isCurrentlyAwaitingData())
+        (void)deliverFromBuffer();
+}
+
+void T140IdleFilter::doStopGettingFrames() {
+    // Cancel any pending idle timer:
+    envir().taskScheduler().unscheduleDelayedTask(fIdleTimerTask);
+
+    // And call the parent's implementation of this virtual function:
+    FramedFilter::doStopGettingFrames();
+}
+
+void T140IdleFilter::handleIdleTimeout(void *clientData) {
+    ((T140IdleFilter *)clientData)->handleIdleTimeout();
+}
+
+void T140IdleFilter::handleIdleTimeout() {
+    fIdleTimerTask = NULL;
+    // No data has arrived from the upstream source within our specified 'idle period' (after data was requested from downstream).
+    // Send an empty 'idle' frame to our downstream "T140TextRTPSink".  (This will cause an empty RTP packet to get sent.)
+    deliverEmptyFrame();
+}
+
+void T140IdleFilter::deliverFromBuffer() {
+    if(fNumBufferedBytes <= fMaxSize) {  // common case
+        fNumTruncatedBytes = fBufferedNumTruncatedBytes;
+        fFrameSize         = fNumBufferedBytes;
+    }
+    else {
+        fNumTruncatedBytes = fBufferedNumTruncatedBytes + fNumBufferedBytes - fMaxSize;
+        fFrameSize         = fMaxSize;
+    }
+
+    memmove(fTo, fBuffer, fFrameSize);
+    fPresentationTime       = fBufferedDataPresentationTime;
+    fDurationInMicroseconds = fBufferedDataDurationInMicroseconds;
+
+    fNumBufferedBytes = 0;  // reset buffer
+
+    FramedSource::afterGetting(this);  // complete delivery
+}
+
+void T140IdleFilter::deliverEmptyFrame() {
+    fFrameSize = fNumTruncatedBytes = 0;
+    gettimeofday(&fPresentationTime, NULL);
+    FramedSource::afterGetting(this);  // complete delivery
+}
+
+void T140IdleFilter::onSourceClosure(void *clientData) {
+    ((T140IdleFilter *)clientData)->onSourceClosure();
+}
+
+void T140IdleFilter::onSourceClosure() {
+    envir().taskScheduler().unscheduleDelayedTask(fIdleTimerTask);
+
+    handleClosure();
+}
diff --git a/3rdparty/live555/src/liveMedia/TLSState.cpp b/3rdparty/live555/src/liveMedia/TLSState.cpp
new file mode 100644
index 00000000..6194e139
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/TLSState.cpp
@@ -0,0 +1,248 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// State encapsulating a TLS connection
+// Implementation
+
+#include "TLSState.hh"
+#include "RTSPClient.hh"
+#ifndef NO_OPENSSL
+#include <openssl/err.h>
+#endif
+
+////////// TLSState implementation //////////
+
+TLSState::TLSState()
+    : isNeeded(False)
+#ifndef NO_OPENSSL
+      ,
+      fHasBeenSetup(False),
+      fCtx(NULL),
+      fCon(NULL)
+#endif
+{
+}
+
+TLSState::~TLSState() {
+#ifndef NO_OPENSSL
+    reset();
+#endif
+}
+
+int TLSState::write(const char *data, unsigned count) {
+#ifndef NO_OPENSSL
+    return SSL_write(fCon, data, count);
+#else
+    return -1;
+#endif
+}
+
+int TLSState::read(u_int8_t *buffer, unsigned bufferSize) {
+#ifndef NO_OPENSSL
+    int result = SSL_read(fCon, buffer, bufferSize);
+    if(result <= 0) {
+        if(SSL_get_error(fCon, result) == SSL_ERROR_WANT_READ) {
+            // The data can't be delivered yet.  Return 0 (bytes read); we'll try again later
+            return 0;
+        }
+        return -1;  // assume that the connection has closed
+    }
+    return result;
+#else
+    return 0;
+#endif
+}
+
+#ifndef NO_OPENSSL
+void TLSState::initLibrary() {
+    static Boolean SSLLibraryHasBeenInitialized = False;
+    if(!SSLLibraryHasBeenInitialized) {
+        (void)SSL_library_init();
+        SSLLibraryHasBeenInitialized = True;
+    }
+}
+
+void TLSState::reset() {
+    if(fHasBeenSetup)
+        SSL_shutdown(fCon);
+
+    if(fCon != NULL) {
+        SSL_free(fCon);
+        fCon = NULL;
+    }
+    if(fCtx != NULL) {
+        SSL_CTX_free(fCtx);
+        fCtx = NULL;
+    }
+}
+#endif
+
+////////// ClientTLSState implementation //////////
+
+ClientTLSState::ClientTLSState(RTSPClient &client)
+#ifndef NO_OPENSSL
+    : fClient(client)
+#endif
+{
+}
+
+ClientTLSState::~ClientTLSState() {}
+
+int ClientTLSState::connect(int socketNum) {
+#ifndef NO_OPENSSL
+    if(!fHasBeenSetup && !setup(socketNum))
+        return -1;  // error
+
+    // Complete the SSL-level connection to the server:
+    int sslConnectResult  = SSL_connect(fCon);
+    int sslGetErrorResult = SSL_get_error(fCon, sslConnectResult);
+
+    if(sslConnectResult > 0) {
+        return sslConnectResult;  // connection has completed
+    }
+    else if(sslConnectResult < 0 && (sslGetErrorResult == SSL_ERROR_WANT_READ || sslGetErrorResult == SSL_ERROR_WANT_WRITE)) {
+        // We need to wait until the socket is readable or writable:
+        fClient.envir().taskScheduler().setBackgroundHandling(socketNum, sslGetErrorResult == SSL_ERROR_WANT_READ ? SOCKET_READABLE : SOCKET_WRITABLE,
+                                                              (TaskScheduler::BackgroundHandlerProc *)&RTSPClient::connectionHandler, &fClient);
+        return 0;  // connection is pending
+    }
+    else {
+        fClient.envir().setResultErrMsg("TLS connection to server failed: ", sslGetErrorResult);
+        return -1;  // error
+    }
+#else
+    return -1;
+#endif
+}
+
+#ifndef NO_OPENSSL
+Boolean ClientTLSState::setup(int socketNum) {
+    do {
+        initLibrary();
+
+        SSL_METHOD const *meth = SSLv23_client_method();
+        if(meth == NULL)
+            break;
+
+        fCtx = SSL_CTX_new(meth);
+        if(fCtx == NULL)
+            break;
+
+        fCon = SSL_new(fCtx);
+        if(fCon == NULL)
+            break;
+
+        BIO *bio = BIO_new_socket(socketNum, BIO_NOCLOSE);
+        SSL_set_bio(fCon, bio, bio);
+
+        SSL_set_connect_state(fCon);
+
+        fHasBeenSetup = True;
+        return True;
+    } while(0);
+
+    // An error occurred:
+    reset();
+    return False;
+}
+#endif
+
+////////// ServerTLSState implementation //////////
+
+ServerTLSState::ServerTLSState(UsageEnvironment &env)
+    : tlsAcceptIsNeeded(False)
+#ifndef NO_OPENSSL
+      ,
+      fEnv(env),
+      fCertificateFileName(NULL),
+      fPrivateKeyFileName(NULL)
+#endif
+{
+}
+
+ServerTLSState::~ServerTLSState() {}
+
+void ServerTLSState ::setCertificateAndPrivateKeyFileNames(char const *certFileName, char const *privKeyFileName) {
+#ifndef NO_OPENSSL
+    fCertificateFileName = certFileName;
+    fPrivateKeyFileName  = privKeyFileName;
+#endif
+}
+
+int ServerTLSState::accept(int socketNum) {
+#ifndef NO_OPENSSL
+    if(!fHasBeenSetup && !setup(socketNum))
+        return -1;  // error
+
+    int sslAcceptResult   = SSL_accept(fCon);
+    int sslGetErrorResult = SSL_get_error(fCon, sslAcceptResult);
+
+    if(sslAcceptResult > 0) {
+        return sslAcceptResult;  // success
+    }
+    else if(sslAcceptResult < 0 && sslGetErrorResult == SSL_ERROR_WANT_READ) {
+        // We need to wait until the socket is readable:
+        return 0;  // connection is pending
+    }
+    else {
+        fEnv.setResultErrMsg("SSL_accept() call failed: ", sslGetErrorResult);
+        return -1;  // error
+    }
+#else
+    return -1;
+#endif
+}
+
+#ifndef NO_OPENSSL
+Boolean ServerTLSState::setup(int socketNum) {
+    do {
+        initLibrary();
+
+        SSL_METHOD const *meth = SSLv23_server_method();
+        if(meth == NULL)
+            break;
+
+        fCtx = SSL_CTX_new(meth);
+        if(fCtx == NULL)
+            break;
+
+        if(SSL_CTX_set_ecdh_auto(fCtx, 1) != 1)
+            break;
+
+        if(SSL_CTX_use_certificate_file(fCtx, fCertificateFileName, SSL_FILETYPE_PEM) != 1)
+            break;
+
+        if(SSL_CTX_use_PrivateKey_file(fCtx, fPrivateKeyFileName, SSL_FILETYPE_PEM) != 1)
+            break;
+
+        fCon = SSL_new(fCtx);
+        if(fCon == NULL)
+            break;
+
+        BIO *bio = BIO_new_socket(socketNum, BIO_NOCLOSE);
+        SSL_set_bio(fCon, bio, bio);
+
+        fHasBeenSetup = True;
+        return True;
+    } while(0);
+
+    // An error occurred:
+    ERR_print_errors_fp(stderr);
+    reset();
+    return False;
+}
+#endif
diff --git a/3rdparty/live555/src/liveMedia/TextRTPSink.cpp b/3rdparty/live555/src/liveMedia/TextRTPSink.cpp
new file mode 100644
index 00000000..af6fd245
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/TextRTPSink.cpp
@@ -0,0 +1,31 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A generic RTP sink for text codecs (abstract base class)
+// Implementation
+
+#include "TextRTPSink.hh"
+
+TextRTPSink::TextRTPSink(UsageEnvironment &env, Groupsock *rtpgs, unsigned char rtpPayloadType, unsigned rtpTimestampFrequency,
+                         char const *rtpPayloadFormatName)
+    : MultiFramedRTPSink(env, rtpgs, rtpPayloadType, rtpTimestampFrequency, rtpPayloadFormatName) {}
+
+TextRTPSink::~TextRTPSink() {}
+
+char const *TextRTPSink::sdpMediaType() const {
+    return "text";
+}
diff --git a/3rdparty/live555/src/liveMedia/TheoraVideoRTPSink.cpp b/3rdparty/live555/src/liveMedia/TheoraVideoRTPSink.cpp
new file mode 100644
index 00000000..69d7fe37
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/TheoraVideoRTPSink.cpp
@@ -0,0 +1,159 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// RTP sink for Theora video
+// Implementation
+
+#include "TheoraVideoRTPSink.hh"
+#include "Base64.hh"
+#include "VorbisAudioRTPSource.hh"  // for parseVorbisOrTheoraConfigStr()
+#include "VorbisAudioRTPSink.hh"    // for generateVorbisOrTheoraConfigStr()
+
+TheoraVideoRTPSink *TheoraVideoRTPSink ::createNew(UsageEnvironment &env, Groupsock *RTPgs, u_int8_t rtpPayloadFormat, u_int8_t *identificationHeader,
+                                                   unsigned identificationHeaderSize, u_int8_t *commentHeader, unsigned commentHeaderSize,
+                                                   u_int8_t *setupHeader, unsigned setupHeaderSize, u_int32_t identField) {
+    return new TheoraVideoRTPSink(env, RTPgs, rtpPayloadFormat, identificationHeader, identificationHeaderSize, commentHeader, commentHeaderSize, setupHeader,
+                                  setupHeaderSize, identField);
+}
+
+TheoraVideoRTPSink *TheoraVideoRTPSink ::createNew(UsageEnvironment &env, Groupsock *RTPgs, u_int8_t rtpPayloadFormat, char const *configStr) {
+    // Begin by decoding and unpacking the configuration string:
+    u_int8_t *identificationHeader;
+    unsigned  identificationHeaderSize;
+    u_int8_t *commentHeader;
+    unsigned  commentHeaderSize;
+    u_int8_t *setupHeader;
+    unsigned  setupHeaderSize;
+    u_int32_t identField;
+
+    parseVorbisOrTheoraConfigStr(configStr, identificationHeader, identificationHeaderSize, commentHeader, commentHeaderSize, setupHeader, setupHeaderSize,
+                                 identField);
+
+    TheoraVideoRTPSink *resultSink = new TheoraVideoRTPSink(env, RTPgs, rtpPayloadFormat, identificationHeader, identificationHeaderSize, commentHeader,
+                                                            commentHeaderSize, setupHeader, setupHeaderSize, identField);
+    delete[] identificationHeader;
+    delete[] commentHeader;
+    delete[] setupHeader;
+
+    return resultSink;
+}
+
+TheoraVideoRTPSink ::TheoraVideoRTPSink(UsageEnvironment &env, Groupsock *RTPgs, u_int8_t rtpPayloadFormat, u_int8_t *identificationHeader,
+                                        unsigned identificationHeaderSize, u_int8_t *commentHeader, unsigned commentHeaderSize, u_int8_t *setupHeader,
+                                        unsigned setupHeaderSize, u_int32_t identField)
+    : VideoRTPSink(env, RTPgs, rtpPayloadFormat, 90000, "THEORA"), fIdent(identField), fFmtpSDPLine(NULL) {
+    static const char *pf_to_str[] = {
+        "YCbCr-4:2:0",
+        "Reserved",
+        "YCbCr-4:2:2",
+        "YCbCr-4:4:4",
+    };
+
+    unsigned width  = 1280;  // default value
+    unsigned height = 720;   // default value
+    unsigned pf     = 0;     // default value
+    if(identificationHeaderSize >= 42) {
+        // Parse this header to get the "width", "height", "pf" (pixel format), and
+        // 'nominal bitrate' parameters:
+        u_int8_t *p             = identificationHeader;  // alias
+        width                   = (p[14] << 16) | (p[15] << 8) | p[16];
+        height                  = (p[17] << 16) | (p[18] << 8) | p[19];
+        pf                      = (p[41] & 0x18) >> 3;
+        unsigned nominalBitrate = (p[37] << 16) | (p[38] << 8) | p[39];
+        if(nominalBitrate > 0)
+            estimatedBitrate() = nominalBitrate / 1000;
+    }
+
+    // Generate a 'config' string from the supplied configuration headers:
+    char *base64PackedHeaders = generateVorbisOrTheoraConfigStr(identificationHeader, identificationHeaderSize, commentHeader, commentHeaderSize, setupHeader,
+                                                                setupHeaderSize, identField);
+    if(base64PackedHeaders == NULL)
+        return;
+
+    // Then use this 'config' string to construct our "a=fmtp:" SDP line:
+    unsigned fmtpSDPLineMaxSize = 200 + strlen(base64PackedHeaders);  // 200 => more than enough space
+    fFmtpSDPLine                = new char[fmtpSDPLineMaxSize];
+    sprintf(fFmtpSDPLine, "a=fmtp:%d sampling=%s;width=%u;height=%u;delivery-method=out_band/rtsp;configuration=%s\r\n", rtpPayloadType(), pf_to_str[pf], width,
+            height, base64PackedHeaders);
+    delete[] base64PackedHeaders;
+}
+
+TheoraVideoRTPSink::~TheoraVideoRTPSink() {
+    delete[] fFmtpSDPLine;
+}
+
+char const *TheoraVideoRTPSink::auxSDPLine() {
+    return fFmtpSDPLine;
+}
+
+void TheoraVideoRTPSink ::doSpecialFrameHandling(unsigned fragmentationOffset, unsigned char *frameStart, unsigned numBytesInFrame,
+                                                 struct timeval framePresentationTime, unsigned numRemainingBytes) {
+    // Set the 4-byte "payload header", as defined in http://svn.xiph.org/trunk/theora/doc/draft-ietf-avt-rtp-theora-00.txt
+    u_int8_t header[6];
+
+    // The three bytes of the header are our "Ident":
+    header[0] = fIdent >> 16;
+    header[1] = fIdent >> 8;
+    header[2] = fIdent;
+
+    // The final byte contains the "F", "TDT", and "numPkts" fields:
+    u_int8_t F;  // Fragment type
+    if(numRemainingBytes > 0) {
+        if(fragmentationOffset > 0) {
+            F = 2 << 6;  // continuation fragment
+        }
+        else {
+            F = 1 << 6;  // start fragment
+        }
+    }
+    else {
+        if(fragmentationOffset > 0) {
+            F = 3 << 6;  // end fragment
+        }
+        else {
+            F = 0 << 6;  // not fragmented
+        }
+    }
+    u_int8_t const TDT     = 0 << 4;                                   // Theora Data Type (always a "Raw Theora payload")
+    u_int8_t       numPkts = F == 0 ? (numFramesUsedSoFar() + 1) : 0;  // set to 0 when we're a fragment
+    header[3]              = F | TDT | numPkts;
+
+    // There's also a 2-byte 'frame-specific' header: The length of the
+    // Theora data:
+    header[4] = numBytesInFrame >> 8;
+    header[5] = numBytesInFrame;
+    setSpecialHeaderBytes(header, sizeof(header));
+
+    if(numRemainingBytes == 0) {
+        // This packet contains the last (or only) fragment of the frame.
+        // Set the RTP 'M' ('marker') bit:
+        setMarkerBit();
+    }
+
+    // Important: Also call our base class's doSpecialFrameHandling(),
+    // to set the packet's timestamp:
+    MultiFramedRTPSink::doSpecialFrameHandling(fragmentationOffset, frameStart, numBytesInFrame, framePresentationTime, numRemainingBytes);
+}
+
+Boolean TheoraVideoRTPSink::frameCanAppearAfterPacketStart(unsigned char const * /*frameStart*/, unsigned /*numBytesInFrame*/) const {
+    // Only one frame per packet:
+    return False;
+}
+
+unsigned TheoraVideoRTPSink::specialHeaderSize() const {
+    return 6;
+}
diff --git a/3rdparty/live555/src/liveMedia/TheoraVideoRTPSource.cpp b/3rdparty/live555/src/liveMedia/TheoraVideoRTPSource.cpp
new file mode 100644
index 00000000..0628318d
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/TheoraVideoRTPSource.cpp
@@ -0,0 +1,99 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// Theora Video RTP Sources
+// Implementation
+
+#include "TheoraVideoRTPSource.hh"
+
+////////// TheoraBufferedPacket and TheoraBufferedPacketFactory //////////
+
+class TheoraBufferedPacket : public BufferedPacket {
+public:
+    TheoraBufferedPacket();
+    virtual ~TheoraBufferedPacket();
+
+private:  // redefined virtual functions
+    virtual unsigned nextEnclosedFrameSize(unsigned char *&framePtr, unsigned dataSize);
+};
+
+class TheoraBufferedPacketFactory : public BufferedPacketFactory {
+private:  // redefined virtual functions
+    virtual BufferedPacket *createNewPacket(MultiFramedRTPSource *ourSource);
+};
+
+///////// TheoraVideoRTPSource implementation ////////
+
+TheoraVideoRTPSource *TheoraVideoRTPSource::createNew(UsageEnvironment &env, Groupsock *RTPgs, unsigned char rtpPayloadFormat) {
+    return new TheoraVideoRTPSource(env, RTPgs, rtpPayloadFormat);
+}
+
+TheoraVideoRTPSource ::TheoraVideoRTPSource(UsageEnvironment &env, Groupsock *RTPgs, unsigned char rtpPayloadFormat)
+    : MultiFramedRTPSource(env, RTPgs, rtpPayloadFormat, 90000, new TheoraBufferedPacketFactory), fCurPacketIdent(0) {}
+
+TheoraVideoRTPSource::~TheoraVideoRTPSource() {}
+
+Boolean TheoraVideoRTPSource ::processSpecialHeader(BufferedPacket *packet, unsigned &resultSpecialHeaderSize) {
+    unsigned char *headerStart = packet->data();
+    unsigned       packetSize  = packet->dataSize();
+
+    resultSpecialHeaderSize = 4;
+    if(packetSize < resultSpecialHeaderSize)
+        return False;  // packet was too small
+
+    // The first 3 bytes of the header are the "Ident" field:
+    fCurPacketIdent = (headerStart[0] << 16) | (headerStart[1] << 8) | headerStart[2];
+
+    // The 4th byte is F|TDT|numPkts.
+    // Reject any packet with TDT == 3:
+    if((headerStart[3] & 0x30) == 0x30)
+        return False;
+
+    u_int8_t F                   = headerStart[3] >> 6;
+    fCurrentPacketBeginsFrame    = F <= 1;            // "Not Fragmented" or "Start Fragment"
+    fCurrentPacketCompletesFrame = F == 0 || F == 3;  // "Not Fragmented" or "End Fragment"
+
+    return True;
+}
+
+char const *TheoraVideoRTPSource::MIMEtype() const {
+    return "video/THEORA";
+}
+
+////////// TheoraBufferedPacket and TheoraBufferedPacketFactory implementation //////////
+
+TheoraBufferedPacket::TheoraBufferedPacket() {}
+
+TheoraBufferedPacket::~TheoraBufferedPacket() {}
+
+unsigned TheoraBufferedPacket ::nextEnclosedFrameSize(unsigned char *&framePtr, unsigned dataSize) {
+    if(dataSize < 2) {
+        // There's not enough space for a 2-byte header.  TARFU!  Just return the data that's left:
+        return dataSize;
+    }
+
+    unsigned frameSize = (framePtr[0] << 8) | framePtr[1];
+    framePtr += 2;
+    if(frameSize > dataSize - 2)
+        return dataSize - 2;  // inconsistent frame size => just return all the data that's left
+
+    return frameSize;
+}
+
+BufferedPacket *TheoraBufferedPacketFactory ::createNewPacket(MultiFramedRTPSource * /*ourSource*/) {
+    return new TheoraBufferedPacket();
+}
diff --git a/3rdparty/live555/src/liveMedia/VP8VideoRTPSink.cpp b/3rdparty/live555/src/liveMedia/VP8VideoRTPSink.cpp
new file mode 100644
index 00000000..6541f292
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/VP8VideoRTPSink.cpp
@@ -0,0 +1,57 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// RTP sink for VP8 video
+// Implementation
+
+#include "VP8VideoRTPSink.hh"
+
+VP8VideoRTPSink ::VP8VideoRTPSink(UsageEnvironment &env, Groupsock *RTPgs, unsigned char rtpPayloadFormat)
+    : VideoRTPSink(env, RTPgs, rtpPayloadFormat, 90000, "VP8") {}
+
+VP8VideoRTPSink::~VP8VideoRTPSink() {}
+
+VP8VideoRTPSink *VP8VideoRTPSink::createNew(UsageEnvironment &env, Groupsock *RTPgs, unsigned char rtpPayloadFormat) {
+    return new VP8VideoRTPSink(env, RTPgs, rtpPayloadFormat);
+}
+
+Boolean VP8VideoRTPSink ::frameCanAppearAfterPacketStart(unsigned char const * /*frameStart*/, unsigned /*numBytesInFrame*/) const {
+    // A packet can contain only one frame
+    return False;
+}
+
+void VP8VideoRTPSink ::doSpecialFrameHandling(unsigned       fragmentationOffset, unsigned char * /*frameStart*/, unsigned /*numBytesInFrame*/,
+                                              struct timeval framePresentationTime, unsigned numRemainingBytes) {
+    // Set the "VP8 Payload Descriptor" (just the minimal required 1-byte version):
+    u_int8_t vp8PayloadDescriptor = fragmentationOffset == 0 ? 0x10 : 0x00;
+    // X = R = N = 0; PartID = 0; S = 1 iff this is the first (or only) fragment of the frame
+    setSpecialHeaderBytes(&vp8PayloadDescriptor, 1);
+
+    if(numRemainingBytes == 0) {
+        // This packet contains the last (or only) fragment of the frame.
+        // Set the RTP 'M' ('marker') bit:
+        setMarkerBit();
+    }
+
+    // Also set the RTP timestamp:
+    setTimestamp(framePresentationTime);
+}
+
+unsigned VP8VideoRTPSink::specialHeaderSize() const {
+    // We include only the required 1-byte form of the "VP8 Payload Descriptor":
+    return 1;
+}
diff --git a/3rdparty/live555/src/liveMedia/VP8VideoRTPSource.cpp b/3rdparty/live555/src/liveMedia/VP8VideoRTPSource.cpp
new file mode 100644
index 00000000..578e93ed
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/VP8VideoRTPSource.cpp
@@ -0,0 +1,84 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// VP8 Video RTP Sources
+// Implementation
+
+#include "VP8VideoRTPSource.hh"
+
+VP8VideoRTPSource *VP8VideoRTPSource::createNew(UsageEnvironment &env, Groupsock *RTPgs, unsigned char rtpPayloadFormat, unsigned rtpTimestampFrequency) {
+    return new VP8VideoRTPSource(env, RTPgs, rtpPayloadFormat, rtpTimestampFrequency);
+}
+
+VP8VideoRTPSource ::VP8VideoRTPSource(UsageEnvironment &env, Groupsock *RTPgs, unsigned char rtpPayloadFormat, unsigned rtpTimestampFrequency)
+    : MultiFramedRTPSource(env, RTPgs, rtpPayloadFormat, rtpTimestampFrequency) {}
+
+VP8VideoRTPSource::~VP8VideoRTPSource() {}
+
+#define incrHeader                 \
+    do {                           \
+        ++resultSpecialHeaderSize; \
+        ++headerStart;             \
+        if(--packetSize == 0)      \
+            return False;          \
+    } while(0)
+
+Boolean VP8VideoRTPSource ::processSpecialHeader(BufferedPacket *packet, unsigned &resultSpecialHeaderSize) {
+    unsigned char *headerStart = packet->data();
+    unsigned       packetSize  = packet->dataSize();
+
+    // The special header is from 1 to 6 bytes long.
+    if(packetSize == 0)
+        return False;             // error
+    resultSpecialHeaderSize = 1;  // unless we learn otherwise
+
+    u_int8_t const byte1  = *headerStart;
+    Boolean const  X      = (byte1 & 0x80) != 0;
+    Boolean const  S      = (byte1 & 0x10) != 0;
+    u_int8_t const PartID = byte1 & 0x0F;
+
+    fCurrentPacketBeginsFrame    = S && PartID == 0;
+    fCurrentPacketCompletesFrame = packet->rtpMarkerBit();  // RTP header's "M" bit
+
+    if(X) {
+        incrHeader;
+
+        u_int8_t const byte2 = *headerStart;
+        Boolean const  I     = (byte2 & 0x80) != 0;
+        Boolean const  L     = (byte2 & 0x40) != 0;
+        Boolean const  T     = (byte2 & 0x20) != 0;
+        Boolean const  K     = (byte2 & 0x10) != 0;
+
+        if(I) {
+            incrHeader;
+            if((*headerStart) & 0x80) {  // extension flag in the PictureID is set
+                incrHeader;
+            }
+        }
+
+        if(L)
+            incrHeader;
+        if(T || K)
+            incrHeader;
+    }
+
+    return True;
+}
+
+char const *VP8VideoRTPSource::MIMEtype() const {
+    return "video/VP8";
+}
diff --git a/3rdparty/live555/src/liveMedia/VP9VideoRTPSink.cpp b/3rdparty/live555/src/liveMedia/VP9VideoRTPSink.cpp
new file mode 100644
index 00000000..a09f3a29
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/VP9VideoRTPSink.cpp
@@ -0,0 +1,60 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// RTP sink for VP9 video
+// Implementation
+
+#include "VP9VideoRTPSink.hh"
+
+VP9VideoRTPSink ::VP9VideoRTPSink(UsageEnvironment &env, Groupsock *RTPgs, unsigned char rtpPayloadFormat)
+    : VideoRTPSink(env, RTPgs, rtpPayloadFormat, 90000, "VP9") {}
+
+VP9VideoRTPSink::~VP9VideoRTPSink() {}
+
+VP9VideoRTPSink *VP9VideoRTPSink::createNew(UsageEnvironment &env, Groupsock *RTPgs, unsigned char rtpPayloadFormat) {
+    return new VP9VideoRTPSink(env, RTPgs, rtpPayloadFormat);
+}
+
+Boolean VP9VideoRTPSink ::frameCanAppearAfterPacketStart(unsigned char const * /*frameStart*/, unsigned /*numBytesInFrame*/) const {
+    // A packet can contain only one frame
+    return False;
+}
+
+void VP9VideoRTPSink ::doSpecialFrameHandling(unsigned       fragmentationOffset, unsigned char * /*frameStart*/, unsigned /*numBytesInFrame*/,
+                                              struct timeval framePresentationTime, unsigned numRemainingBytes) {
+    // Set the "VP9 Payload Descriptor" (just the minimal required 1-byte version):
+    u_int8_t vp9PayloadDescriptor = fragmentationOffset == 0 ? 0x10 : 0x00;
+    // I = L = F = V = U = 0; S = 1 iff this is the first (or only) fragment of the frame
+
+    if(numRemainingBytes == 0) {
+        // This packet contains the last (or only) fragment of the frame.
+        // Set the E bit:
+        vp9PayloadDescriptor |= 0x08;
+        // Also set the RTP 'M' ('marker') bit:
+        setMarkerBit();
+    }
+
+    setSpecialHeaderBytes(&vp9PayloadDescriptor, 1);
+
+    // Also set the RTP timestamp:
+    setTimestamp(framePresentationTime);
+}
+
+unsigned VP9VideoRTPSink::specialHeaderSize() const {
+    // We include only the required 1-byte form of the "VP9 Payload Descriptor":
+    return 1;
+}
diff --git a/3rdparty/live555/src/liveMedia/VP9VideoRTPSource.cpp b/3rdparty/live555/src/liveMedia/VP9VideoRTPSource.cpp
new file mode 100644
index 00000000..80d1f093
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/VP9VideoRTPSource.cpp
@@ -0,0 +1,107 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// VP9 Video RTP Sources
+// Implementation
+
+#include "VP9VideoRTPSource.hh"
+
+VP9VideoRTPSource *VP9VideoRTPSource::createNew(UsageEnvironment &env, Groupsock *RTPgs, unsigned char rtpPayloadFormat, unsigned rtpTimestampFrequency) {
+    return new VP9VideoRTPSource(env, RTPgs, rtpPayloadFormat, rtpTimestampFrequency);
+}
+
+VP9VideoRTPSource ::VP9VideoRTPSource(UsageEnvironment &env, Groupsock *RTPgs, unsigned char rtpPayloadFormat, unsigned rtpTimestampFrequency)
+    : MultiFramedRTPSource(env, RTPgs, rtpPayloadFormat, rtpTimestampFrequency) {}
+
+VP9VideoRTPSource::~VP9VideoRTPSource() {}
+
+#define incrHeader                 \
+    do {                           \
+        ++resultSpecialHeaderSize; \
+        ++headerStart;             \
+        if(--packetSize == 0)      \
+            return False;          \
+    } while(0)
+
+Boolean VP9VideoRTPSource ::processSpecialHeader(BufferedPacket *packet, unsigned &resultSpecialHeaderSize) {
+    unsigned char *headerStart = packet->data();
+    unsigned       packetSize  = packet->dataSize();
+
+    // Figure out the size of the special header.
+    if(packetSize == 0)
+        return False;             // error
+    resultSpecialHeaderSize = 1;  // unless we learn otherwise
+
+    u_int8_t const byte1 = *headerStart;
+    Boolean const  I     = (byte1 & 0x80) != 0;
+    Boolean const  L     = (byte1 & 0x40) != 0;
+    Boolean const  F     = (byte1 & 0x20) != 0;
+    Boolean const  B     = (byte1 & 0x10) != 0;
+    Boolean const  E     = (byte1 & 0x08) != 0;
+    Boolean const  V     = (byte1 & 0x04) != 0;
+    Boolean const  U     = (byte1 & 0x02) != 0;
+
+    fCurrentPacketBeginsFrame    = B;
+    fCurrentPacketCompletesFrame = E;
+    // use this instead of the RTP header's 'M' bit (which might not be accurate)
+
+    if(I) {  // PictureID present
+        incrHeader;
+        Boolean const M = ((*headerStart) & 0x80) != 0;
+        if(M)
+            incrHeader;
+    }
+
+    if(L) {  // Layer indices present
+        incrHeader;
+        if(F) {  // Reference indices present
+            incrHeader;
+            unsigned R = (*headerStart) & 0x03;
+            while(R-- > 0) {
+                incrHeader;
+                Boolean const X = ((*headerStart) & 0x10) != 0;
+                if(X)
+                    incrHeader;
+            }
+        }
+    }
+
+    if(V) {  // Scalability Structure (SS) present
+        incrHeader;
+        unsigned patternLength = *headerStart;
+        while(patternLength-- > 0) {
+            incrHeader;
+            unsigned R = (*headerStart) & 0x03;
+            while(R-- > 0) {
+                incrHeader;
+                Boolean const X = ((*headerStart) & 0x10) != 0;
+                if(X)
+                    incrHeader;
+            }
+        }
+    }
+
+    if(U) {            // Scalability Structure Update (SU) present
+        return False;  // This structure isn't yet defined in the VP9 payload format I-D
+    }
+
+    return True;
+}
+
+char const *VP9VideoRTPSource::MIMEtype() const {
+    return "video/VP9";
+}
diff --git a/3rdparty/live555/src/liveMedia/VideoRTPSink.cpp b/3rdparty/live555/src/liveMedia/VideoRTPSink.cpp
new file mode 100644
index 00000000..012d9eaf
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/VideoRTPSink.cpp
@@ -0,0 +1,31 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A generic RTP sink for video codecs (abstract base class)
+// Implementation
+
+#include "VideoRTPSink.hh"
+
+VideoRTPSink::VideoRTPSink(UsageEnvironment &env, Groupsock *rtpgs, unsigned char rtpPayloadType, unsigned rtpTimestampFrequency,
+                           char const *rtpPayloadFormatName)
+    : MultiFramedRTPSink(env, rtpgs, rtpPayloadType, rtpTimestampFrequency, rtpPayloadFormatName) {}
+
+VideoRTPSink::~VideoRTPSink() {}
+
+char const *VideoRTPSink::sdpMediaType() const {
+    return "video";
+}
diff --git a/3rdparty/live555/src/liveMedia/VorbisAudioRTPSink.cpp b/3rdparty/live555/src/liveMedia/VorbisAudioRTPSink.cpp
new file mode 100644
index 00000000..c6e25aba
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/VorbisAudioRTPSink.cpp
@@ -0,0 +1,259 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// RTP sink for Vorbis audio
+// Implementation
+
+#include "VorbisAudioRTPSink.hh"
+#include "Base64.hh"
+#include "VorbisAudioRTPSource.hh"  // for parseVorbisOrTheoraConfigStr()
+
+VorbisAudioRTPSink *VorbisAudioRTPSink ::createNew(UsageEnvironment &env, Groupsock *RTPgs, u_int8_t rtpPayloadFormat, u_int32_t rtpTimestampFrequency,
+                                                   unsigned numChannels, u_int8_t *identificationHeader, unsigned identificationHeaderSize,
+                                                   u_int8_t *commentHeader, unsigned commentHeaderSize, u_int8_t *setupHeader, unsigned setupHeaderSize,
+                                                   u_int32_t identField) {
+    return new VorbisAudioRTPSink(env, RTPgs, rtpPayloadFormat, rtpTimestampFrequency, numChannels, identificationHeader, identificationHeaderSize,
+                                  commentHeader, commentHeaderSize, setupHeader, setupHeaderSize, identField);
+}
+
+VorbisAudioRTPSink *VorbisAudioRTPSink ::createNew(UsageEnvironment &env, Groupsock *RTPgs, u_int8_t rtpPayloadFormat, u_int32_t rtpTimestampFrequency,
+                                                   unsigned numChannels, char const *configStr) {
+    // Begin by decoding and unpacking the configuration string:
+    u_int8_t *identificationHeader;
+    unsigned  identificationHeaderSize;
+    u_int8_t *commentHeader;
+    unsigned  commentHeaderSize;
+    u_int8_t *setupHeader;
+    unsigned  setupHeaderSize;
+    u_int32_t identField;
+
+    parseVorbisOrTheoraConfigStr(configStr, identificationHeader, identificationHeaderSize, commentHeader, commentHeaderSize, setupHeader, setupHeaderSize,
+                                 identField);
+
+    VorbisAudioRTPSink *resultSink =
+        new VorbisAudioRTPSink(env, RTPgs, rtpPayloadFormat, rtpTimestampFrequency, numChannels, identificationHeader, identificationHeaderSize, commentHeader,
+                               commentHeaderSize, setupHeader, setupHeaderSize, identField);
+    delete[] identificationHeader;
+    delete[] commentHeader;
+    delete[] setupHeader;
+
+    return resultSink;
+}
+
+VorbisAudioRTPSink ::VorbisAudioRTPSink(UsageEnvironment &env, Groupsock *RTPgs, u_int8_t rtpPayloadFormat, u_int32_t rtpTimestampFrequency,
+                                        unsigned numChannels, u_int8_t *identificationHeader, unsigned identificationHeaderSize, u_int8_t *commentHeader,
+                                        unsigned commentHeaderSize, u_int8_t *setupHeader, unsigned setupHeaderSize, u_int32_t identField)
+    : AudioRTPSink(env, RTPgs, rtpPayloadFormat, rtpTimestampFrequency, "VORBIS", numChannels), fIdent(identField), fFmtpSDPLine(NULL) {
+    if(identificationHeaderSize >= 28) {
+        // Get the 'bitrate' values from this header, and use them to set our estimated bitrate:
+        u_int32_t val;
+        u_int8_t *p;
+
+        p                   = &identificationHeader[16];
+        val                 = ((p[3] * 256 + p[2]) * 256 + p[1]) * 256 + p[0];  // i.e., little-endian
+        int bitrate_maximum = (int)val;
+        if(bitrate_maximum < 0)
+            bitrate_maximum = 0;
+
+        p                   = &identificationHeader[20];
+        val                 = ((p[3] * 256 + p[2]) * 256 + p[1]) * 256 + p[0];  // i.e., little-endian
+        int bitrate_nominal = (int)val;
+        if(bitrate_nominal < 0)
+            bitrate_nominal = 0;
+
+        p                   = &identificationHeader[24];
+        val                 = ((p[3] * 256 + p[2]) * 256 + p[1]) * 256 + p[0];  // i.e., little-endian
+        int bitrate_minimum = (int)val;
+        if(bitrate_minimum < 0)
+            bitrate_minimum = 0;
+
+        int bitrate = bitrate_nominal > 0 ? bitrate_nominal : bitrate_maximum > 0 ? bitrate_maximum : bitrate_minimum > 0 ? bitrate_minimum : 0;
+        if(bitrate > 0)
+            estimatedBitrate() = ((unsigned)bitrate) / 1000;
+    }
+
+    // Generate a 'config' string from the supplied configuration headers:
+    char *base64PackedHeaders = generateVorbisOrTheoraConfigStr(identificationHeader, identificationHeaderSize, commentHeader, commentHeaderSize, setupHeader,
+                                                                setupHeaderSize, identField);
+    if(base64PackedHeaders == NULL)
+        return;
+
+    // Then use this 'config' string to construct our "a=fmtp:" SDP line:
+    unsigned fmtpSDPLineMaxSize = 50 + strlen(base64PackedHeaders);  // 50 => more than enough space
+    fFmtpSDPLine                = new char[fmtpSDPLineMaxSize];
+    sprintf(fFmtpSDPLine, "a=fmtp:%d configuration=%s\r\n", rtpPayloadType(), base64PackedHeaders);
+    delete[] base64PackedHeaders;
+}
+
+VorbisAudioRTPSink::~VorbisAudioRTPSink() {
+    delete[] fFmtpSDPLine;
+}
+
+char const *VorbisAudioRTPSink::auxSDPLine() {
+    return fFmtpSDPLine;
+}
+
+void VorbisAudioRTPSink ::doSpecialFrameHandling(unsigned fragmentationOffset, unsigned char *frameStart, unsigned numBytesInFrame,
+                                                 struct timeval framePresentationTime, unsigned numRemainingBytes) {
+    // Set the 4-byte "payload header", as defined in RFC 5215, section 2.2:
+    u_int8_t header[4];
+
+    // The first three bytes of the header are our "Ident":
+    header[0] = fIdent >> 16;
+    header[1] = fIdent >> 8;
+    header[2] = fIdent;
+
+    // The final byte contains the "F", "VDT", and "numPkts" fields:
+    u_int8_t F;  // Fragment type
+    if(numRemainingBytes > 0) {
+        if(fragmentationOffset > 0) {
+            F = 2 << 6;  // continuation fragment
+        }
+        else {
+            F = 1 << 6;  // start fragment
+        }
+    }
+    else {
+        if(fragmentationOffset > 0) {
+            F = 3 << 6;  // end fragment
+        }
+        else {
+            F = 0 << 6;  // not fragmented
+        }
+    }
+    u_int8_t const VDT     = 0 << 4;                                   // Vorbis Data Type (always a "Raw Vorbis payload")
+    u_int8_t       numPkts = F == 0 ? (numFramesUsedSoFar() + 1) : 0;  // set to 0 when we're a fragment
+    header[3]              = F | VDT | numPkts;
+
+    setSpecialHeaderBytes(header, sizeof header);
+
+    // There's also a 2-byte 'frame-specific' header: The length of the Vorbis data:
+    u_int8_t frameSpecificHeader[2];
+    frameSpecificHeader[0] = numBytesInFrame >> 8;
+    frameSpecificHeader[1] = numBytesInFrame;
+    setFrameSpecificHeaderBytes(frameSpecificHeader, 2);
+
+    // Important: Also call our base class's doSpecialFrameHandling(),
+    // to set the packet's timestamp:
+    MultiFramedRTPSink::doSpecialFrameHandling(fragmentationOffset, frameStart, numBytesInFrame, framePresentationTime, numRemainingBytes);
+}
+
+Boolean VorbisAudioRTPSink::frameCanAppearAfterPacketStart(unsigned char const * /*frameStart*/, unsigned /*numBytesInFrame*/) const {
+    // We allow more than one frame to be packed into an outgoing RTP packet, but no more than 15:
+    return numFramesUsedSoFar() <= 15;
+}
+
+unsigned VorbisAudioRTPSink::specialHeaderSize() const {
+    return 4;
+}
+
+unsigned VorbisAudioRTPSink::frameSpecificHeaderSize() const {
+    return 2;
+}
+
+////////// generateVorbisOrTheoraConfigStr() implementation //////////
+
+char *generateVorbisOrTheoraConfigStr(u_int8_t *identificationHeader, unsigned identificationHeaderSize, u_int8_t *commentHeader, unsigned commentHeaderSize,
+                                      u_int8_t *setupHeader, unsigned setupHeaderSize, u_int32_t identField) {
+    // First, count how many headers (<=3) are included, and how many bytes will be used
+    // to encode these headers' sizes:
+    unsigned numHeaders = 0;
+    unsigned sizeSize[2];  // The number of bytes used to encode the lengths of the first two headers (but not the length of the 3rd)
+    sizeSize[0] = sizeSize[1] = 0;
+    if(identificationHeaderSize > 0) {
+        sizeSize[numHeaders++] = identificationHeaderSize < 128 ? 1 : identificationHeaderSize < 16384 ? 2 : 3;
+    }
+    if(commentHeaderSize > 0) {
+        sizeSize[numHeaders++] = commentHeaderSize < 128 ? 1 : commentHeaderSize < 16384 ? 2 : 3;
+    }
+    if(setupHeaderSize > 0) {
+        ++numHeaders;
+    }
+    else {
+        sizeSize[1] = 0;  // We have at most two headers, so the second one's length isn't encoded
+    }
+    if(numHeaders == 0)
+        return NULL;  // With no headers, we can't set up a configuration
+    if(numHeaders == 1)
+        sizeSize[0] = 0;  // With only one header, its length isn't encoded
+
+    // Then figure out the size of the packed configuration headers, and allocate space for this:
+    unsigned length = identificationHeaderSize + commentHeaderSize + setupHeaderSize;
+    // The "length" field in the packed headers
+    if(length > (unsigned)0xFFFF)
+        return NULL;                                          // too big for a 16-bit field; we can't handle this
+    unsigned packedHeadersSize = 4                            // "Number of packed headers" field
+                                 + 3                          // "ident" field
+                                 + 2                          // "length" field
+                                 + 1                          // "n. of headers" field
+                                 + sizeSize[0] + sizeSize[1]  // "length1" and "length2" (if present) fields
+                                 + length;
+    u_int8_t *packedHeaders = new u_int8_t[packedHeadersSize];
+    if(packedHeaders == NULL)
+        return NULL;
+
+    // Fill in the 'packed headers':
+    u_int8_t *p = packedHeaders;
+    *p++        = 0;
+    *p++        = 0;
+    *p++        = 0;
+    *p++        = 1;  // "Number of packed headers": 1
+    *p++        = identField >> 16;
+    *p++        = identField >> 8;
+    *p++        = identField;  // "Ident" (24 bits)
+    *p++        = length >> 8;
+    *p++        = length;          // "length" (16 bits)
+    *p++        = numHeaders - 1;  // "n. of headers"
+    if(numHeaders > 1) {
+        // Fill in the "length1" header:
+        unsigned length1 = identificationHeaderSize > 0 ? identificationHeaderSize : commentHeaderSize;
+        if(length1 >= 16384) {
+            *p++ = 0x80;  // flag, but no more, because we know length1 <= 32767
+        }
+        if(length1 >= 128) {
+            *p++ = 0x80 | ((length1 & 0x3F80) >> 7);  // flag + the second 7 bits
+        }
+        *p++ = length1 & 0x7F;  // the low 7 bits
+
+        if(numHeaders > 2) {  // numHeaders == 3
+            // Fill in the "length2" header (for the 'Comment' header):
+            unsigned length2 = commentHeaderSize;
+            if(length2 >= 16384) {
+                *p++ = 0x80;  // flag, but no more, because we know length2 <= 32767
+            }
+            if(length2 >= 128) {
+                *p++ = 0x80 | ((length2 & 0x3F80) >> 7);  // flag + the second 7 bits
+            }
+            *p++ = length2 & 0x7F;  // the low 7 bits
+        }
+    }
+    // Copy each header:
+    if(identificationHeader != NULL)
+        memmove(p, identificationHeader, identificationHeaderSize);
+    p += identificationHeaderSize;
+    if(commentHeader != NULL)
+        memmove(p, commentHeader, commentHeaderSize);
+    p += commentHeaderSize;
+    if(setupHeader != NULL)
+        memmove(p, setupHeader, setupHeaderSize);
+
+    // Having set up the 'packed configuration headers', Base-64-encode this, for our result:
+    char *base64PackedHeaders = base64Encode((char const *)packedHeaders, packedHeadersSize);
+    delete[] packedHeaders;
+
+    return base64PackedHeaders;
+}
diff --git a/3rdparty/live555/src/liveMedia/VorbisAudioRTPSource.cpp b/3rdparty/live555/src/liveMedia/VorbisAudioRTPSource.cpp
new file mode 100644
index 00000000..6c96fba1
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/VorbisAudioRTPSource.cpp
@@ -0,0 +1,209 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// Vorbis Audio RTP Sources
+// Implementation
+
+#include "VorbisAudioRTPSource.hh"
+#include "Base64.hh"
+
+////////// VorbisBufferedPacket and VorbisBufferedPacketFactory //////////
+
+class VorbisBufferedPacket : public BufferedPacket {
+public:
+    VorbisBufferedPacket();
+    virtual ~VorbisBufferedPacket();
+
+private:  // redefined virtual functions
+    virtual unsigned nextEnclosedFrameSize(unsigned char *&framePtr, unsigned dataSize);
+};
+
+class VorbisBufferedPacketFactory : public BufferedPacketFactory {
+private:  // redefined virtual functions
+    virtual BufferedPacket *createNewPacket(MultiFramedRTPSource *ourSource);
+};
+
+///////// VorbisAudioRTPSource implementation ////////
+
+VorbisAudioRTPSource *VorbisAudioRTPSource::createNew(UsageEnvironment &env, Groupsock *RTPgs, unsigned char rtpPayloadFormat, unsigned rtpTimestampFrequency) {
+    return new VorbisAudioRTPSource(env, RTPgs, rtpPayloadFormat, rtpTimestampFrequency);
+}
+
+VorbisAudioRTPSource ::VorbisAudioRTPSource(UsageEnvironment &env, Groupsock *RTPgs, unsigned char rtpPayloadFormat, unsigned rtpTimestampFrequency)
+    : MultiFramedRTPSource(env, RTPgs, rtpPayloadFormat, rtpTimestampFrequency, new VorbisBufferedPacketFactory), fCurPacketIdent(0) {}
+
+VorbisAudioRTPSource::~VorbisAudioRTPSource() {}
+
+Boolean VorbisAudioRTPSource ::processSpecialHeader(BufferedPacket *packet, unsigned &resultSpecialHeaderSize) {
+    unsigned char *headerStart = packet->data();
+    unsigned       packetSize  = packet->dataSize();
+
+    resultSpecialHeaderSize = 4;
+    if(packetSize < resultSpecialHeaderSize)
+        return False;  // packet was too small
+
+    // The first 3 bytes of the header are the "Ident" field:
+    fCurPacketIdent = (headerStart[0] << 16) | (headerStart[1] << 8) | headerStart[2];
+
+    // The 4th byte is F|VDT|numPkts.
+    // Reject any packet with VDT == 3:
+    if((headerStart[3] & 0x30) == 0x30)
+        return False;
+
+    u_int8_t F                   = headerStart[3] >> 6;
+    fCurrentPacketBeginsFrame    = F <= 1;            // "Not Fragmented" or "Start Fragment"
+    fCurrentPacketCompletesFrame = F == 0 || F == 3;  // "Not Fragmented" or "End Fragment"
+
+    return True;
+}
+
+char const *VorbisAudioRTPSource::MIMEtype() const {
+    return "audio/VORBIS";
+}
+
+////////// VorbisBufferedPacket and VorbisBufferedPacketFactory implementation //////////
+
+VorbisBufferedPacket::VorbisBufferedPacket() {}
+
+VorbisBufferedPacket::~VorbisBufferedPacket() {}
+
+unsigned VorbisBufferedPacket ::nextEnclosedFrameSize(unsigned char *&framePtr, unsigned dataSize) {
+    if(dataSize < 2) {
+        // There's not enough space for a 2-byte header.  TARFU!  Just return the data that's left:
+        return dataSize;
+    }
+
+    unsigned frameSize = (framePtr[0] << 8) | framePtr[1];
+    framePtr += 2;
+    if(frameSize > dataSize - 2)
+        return dataSize - 2;  // inconsistent frame size => just return all the data that's left
+
+    return frameSize;
+}
+
+BufferedPacket *VorbisBufferedPacketFactory ::createNewPacket(MultiFramedRTPSource * /*ourSource*/) {
+    return new VorbisBufferedPacket();
+}
+
+////////// parseVorbisOrTheoraConfigStr() implementation //////////
+
+#define ADVANCE(n)  \
+    do {            \
+        p += (n);   \
+        rem -= (n); \
+    } while(0)
+#define GET_ENCODED_VAL(n)                    \
+    do {                                      \
+        u_int8_t byte;                        \
+        n = 0;                                \
+        do {                                  \
+            if(rem == 0)                      \
+                break;                        \
+            byte = *p;                        \
+            n    = (n * 128) + (byte & 0x7F); \
+            ADVANCE(1);                       \
+        } while(byte & 0x80);                 \
+    } while(0);                               \
+    if(rem == 0)                              \
+    break
+
+void parseVorbisOrTheoraConfigStr(char const *configStr, u_int8_t *&identificationHdr, unsigned &identificationHdrSize, u_int8_t *&commentHdr,
+                                  unsigned &commentHdrSize, u_int8_t *&setupHdr, unsigned &setupHdrSize, u_int32_t &identField) {
+    identificationHdr = commentHdr = setupHdr = NULL;           // default values, if an error occur
+    identificationHdrSize = commentHdrSize = setupHdrSize = 0;  // ditto
+    identField                                            = 0;  // ditto
+
+    // Begin by Base64-decoding the configuration string:
+    unsigned  configDataSize;
+    u_int8_t *configData = base64Decode(configStr, configDataSize);
+    u_int8_t *p          = configData;
+    unsigned  rem        = configDataSize;
+
+    do {
+        if(rem < 4)
+            break;
+        u_int32_t numPackedHeaders = (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3];
+        ADVANCE(4);
+        if(numPackedHeaders == 0)
+            break;
+
+        // Use the first 'packed header' only.
+        if(rem < 3)
+            break;
+        identField = (p[0] << 16) | (p[1] << 8) | p[2];
+        ADVANCE(3);
+
+        if(rem < 2)
+            break;
+        u_int16_t length = (p[0] << 8) | p[1];
+        ADVANCE(2);
+
+        unsigned numHeaders;
+        GET_ENCODED_VAL(numHeaders);
+
+        Boolean success = False;
+        for(unsigned i = 0; i < numHeaders + 1 && i < 3; ++i) {
+            success = False;
+            unsigned headerSize;
+            if(i < numHeaders) {
+                // The header size is encoded:
+                GET_ENCODED_VAL(headerSize);
+                if(headerSize > length)
+                    break;
+                length -= headerSize;
+            }
+            else {
+                // The last header is implicit:
+                headerSize = length;
+            }
+
+            // Allocate space for the header bytes; we'll fill it in later
+            if(i == 0) {
+                identificationHdrSize = headerSize;
+                identificationHdr     = new u_int8_t[identificationHdrSize];
+            }
+            else if(i == 1) {
+                commentHdrSize = headerSize;
+                commentHdr     = new u_int8_t[commentHdrSize];
+            }
+            else {  // i == 2
+                setupHdrSize = headerSize;
+                setupHdr     = new u_int8_t[setupHdrSize];
+            }
+
+            success = True;
+        }
+        if(!success)
+            break;
+
+        // Copy the remaining config bytes into the appropriate 'header' buffers:
+        if(identificationHdr != NULL) {
+            memmove(identificationHdr, p, identificationHdrSize);
+            ADVANCE(identificationHdrSize);
+            if(commentHdr != NULL) {
+                memmove(commentHdr, p, commentHdrSize);
+                ADVANCE(commentHdrSize);
+                if(setupHdr != NULL) {
+                    memmove(setupHdr, p, setupHdrSize);
+                    ADVANCE(setupHdrSize);
+                }
+            }
+        }
+    } while(0);
+
+    delete[] configData;
+}
diff --git a/3rdparty/live555/src/liveMedia/WAVAudioFileServerMediaSubsession.cpp b/3rdparty/live555/src/liveMedia/WAVAudioFileServerMediaSubsession.cpp
new file mode 100644
index 00000000..12189f18
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/WAVAudioFileServerMediaSubsession.cpp
@@ -0,0 +1,232 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A 'ServerMediaSubsession' object that creates new, unicast, "RTPSink"s
+// on demand, from an WAV audio file.
+// Implementation
+
+#include "WAVAudioFileServerMediaSubsession.hh"
+#include "WAVAudioFileSource.hh"
+#include "uLawAudioFilter.hh"
+#include "SimpleRTPSink.hh"
+
+WAVAudioFileServerMediaSubsession *WAVAudioFileServerMediaSubsession ::createNew(UsageEnvironment &env, char const *fileName, Boolean reuseFirstSource,
+                                                                                 Boolean convertToULaw) {
+    return new WAVAudioFileServerMediaSubsession(env, fileName, reuseFirstSource, convertToULaw);
+}
+
+WAVAudioFileServerMediaSubsession ::WAVAudioFileServerMediaSubsession(UsageEnvironment &env, char const *fileName, Boolean reuseFirstSource,
+                                                                      Boolean convertToULaw)
+    : FileServerMediaSubsession(env, fileName, reuseFirstSource), fConvertToULaw(convertToULaw) {}
+
+WAVAudioFileServerMediaSubsession ::~WAVAudioFileServerMediaSubsession() {}
+
+void WAVAudioFileServerMediaSubsession ::seekStreamSource(FramedSource *inputSource, double &seekNPT, double streamDuration, u_int64_t &numBytes) {
+    WAVAudioFileSource *wavSource;
+    if(fBitsPerSample > 8) {
+        // "inputSource" is a filter; its input source is the original WAV file source:
+        wavSource = (WAVAudioFileSource *)(((FramedFilter *)inputSource)->inputSource());
+    }
+    else {
+        // "inputSource" is the original WAV file source:
+        wavSource = (WAVAudioFileSource *)inputSource;
+    }
+
+    unsigned seekSampleNumber = (unsigned)(seekNPT * fSamplingFrequency);
+    unsigned seekByteNumber   = seekSampleNumber * ((fNumChannels * fBitsPerSample) / 8);
+
+    wavSource->seekToPCMByte(seekByteNumber);
+
+    setStreamSourceDuration(inputSource, streamDuration, numBytes);
+}
+
+void WAVAudioFileServerMediaSubsession ::setStreamSourceDuration(FramedSource *inputSource, double streamDuration, u_int64_t &numBytes) {
+    WAVAudioFileSource *wavSource;
+    if(fBitsPerSample > 8) {
+        // "inputSource" is a filter; its input source is the original WAV file source:
+        wavSource = (WAVAudioFileSource *)(((FramedFilter *)inputSource)->inputSource());
+    }
+    else {
+        // "inputSource" is the original WAV file source:
+        wavSource = (WAVAudioFileSource *)inputSource;
+    }
+
+    unsigned numDurationSamples = (unsigned)(streamDuration * fSamplingFrequency);
+    unsigned numDurationBytes   = numDurationSamples * ((fNumChannels * fBitsPerSample) / 8);
+    numBytes                    = (u_int64_t)numDurationBytes;
+
+    wavSource->limitNumBytesToStream(numDurationBytes);
+}
+
+void WAVAudioFileServerMediaSubsession ::setStreamSourceScale(FramedSource *inputSource, float scale) {
+    int                 iScale = (int)scale;
+    WAVAudioFileSource *wavSource;
+    if(fBitsPerSample > 8) {
+        // "inputSource" is a filter; its input source is the original WAV file source:
+        wavSource = (WAVAudioFileSource *)(((FramedFilter *)inputSource)->inputSource());
+    }
+    else {
+        // "inputSource" is the original WAV file source:
+        wavSource = (WAVAudioFileSource *)inputSource;
+    }
+
+    wavSource->setScaleFactor(iScale);
+}
+
+FramedSource *WAVAudioFileServerMediaSubsession ::createNewStreamSource(unsigned /*clientSessionId*/, unsigned &estBitrate) {
+    FramedSource *resultSource = NULL;
+    do {
+        WAVAudioFileSource *wavSource = WAVAudioFileSource::createNew(envir(), fFileName);
+        if(wavSource == NULL)
+            break;
+
+        // Get attributes of the audio source:
+
+        fAudioFormat   = wavSource->getAudioFormat();
+        fBitsPerSample = wavSource->bitsPerSample();
+        // We handle only 4,8,16,20,24 bits-per-sample audio:
+        if(fBitsPerSample % 4 != 0 || fBitsPerSample < 4 || fBitsPerSample > 24 || fBitsPerSample == 12) {
+            envir() << "The input file contains " << fBitsPerSample << " bit-per-sample audio, which we don't handle\n";
+            break;
+        }
+        fSamplingFrequency     = wavSource->samplingFrequency();
+        fNumChannels           = wavSource->numChannels();
+        unsigned bitsPerSecond = fSamplingFrequency * fBitsPerSample * fNumChannels;
+
+        fFileDuration = (float)((8.0 * wavSource->numPCMBytes()) / (fSamplingFrequency * fNumChannels * fBitsPerSample));
+
+        // Add in any filter necessary to transform the data prior to streaming:
+        resultSource = wavSource;  // by default
+        if(fAudioFormat == WA_PCM) {
+            if(fBitsPerSample == 16) {
+                // Note that samples in the WAV audio file are in little-endian order.
+                if(fConvertToULaw) {
+                    // Add a filter that converts from raw 16-bit PCM audio to 8-bit u-law audio:
+                    resultSource = uLawFromPCMAudioSource::createNew(envir(), wavSource, 1 /*little-endian*/);
+                    bitsPerSecond /= 2;
+                }
+                else {
+                    // Add a filter that converts from little-endian to network (big-endian) order:
+                    resultSource = EndianSwap16::createNew(envir(), wavSource);
+                }
+            }
+            else if(fBitsPerSample == 20 || fBitsPerSample == 24) {
+                // Add a filter that converts from little-endian to network (big-endian) order:
+                resultSource = EndianSwap24::createNew(envir(), wavSource);
+            }
+        }
+
+        estBitrate = (bitsPerSecond + 500) / 1000;  // kbps
+        return resultSource;
+    } while(0);
+
+    // An error occurred:
+    Medium::close(resultSource);
+    return NULL;
+}
+
+RTPSink *WAVAudioFileServerMediaSubsession ::createNewRTPSink(Groupsock *rtpGroupsock, unsigned char rtpPayloadTypeIfDynamic, FramedSource * /*inputSource*/) {
+    do {
+        char const *  mimeType;
+        unsigned char payloadFormatCode = rtpPayloadTypeIfDynamic;  // by default, unless a static RTP payload type can be used
+        if(fAudioFormat == WA_PCM) {
+            if(fBitsPerSample == 16) {
+                if(fConvertToULaw) {
+                    mimeType = "PCMU";
+                    if(fSamplingFrequency == 8000 && fNumChannels == 1) {
+                        payloadFormatCode = 0;  // a static RTP payload type
+                    }
+                }
+                else {
+                    mimeType = "L16";
+                    if(fSamplingFrequency == 44100 && fNumChannels == 2) {
+                        payloadFormatCode = 10;  // a static RTP payload type
+                    }
+                    else if(fSamplingFrequency == 44100 && fNumChannels == 1) {
+                        payloadFormatCode = 11;  // a static RTP payload type
+                    }
+                }
+            }
+            else if(fBitsPerSample == 20) {
+                mimeType = "L20";
+            }
+            else if(fBitsPerSample == 24) {
+                mimeType = "L24";
+            }
+            else {  // fBitsPerSample == 8 (we assume that fBitsPerSample == 4 is only for WA_IMA_ADPCM)
+                mimeType = "L8";
+            }
+        }
+        else if(fAudioFormat == WA_PCMU) {
+            mimeType = "PCMU";
+            if(fSamplingFrequency == 8000 && fNumChannels == 1) {
+                payloadFormatCode = 0;  // a static RTP payload type
+            }
+        }
+        else if(fAudioFormat == WA_PCMA) {
+            mimeType = "PCMA";
+            if(fSamplingFrequency == 8000 && fNumChannels == 1) {
+                payloadFormatCode = 8;  // a static RTP payload type
+            }
+        }
+        else if(fAudioFormat == WA_IMA_ADPCM) {
+            mimeType = "DVI4";
+            // Use a static payload type, if one is defined:
+            if(fNumChannels == 1) {
+                if(fSamplingFrequency == 8000) {
+                    payloadFormatCode = 5;  // a static RTP payload type
+                }
+                else if(fSamplingFrequency == 16000) {
+                    payloadFormatCode = 6;  // a static RTP payload type
+                }
+                else if(fSamplingFrequency == 11025) {
+                    payloadFormatCode = 16;  // a static RTP payload type
+                }
+                else if(fSamplingFrequency == 22050) {
+                    payloadFormatCode = 17;  // a static RTP payload type
+                }
+            }
+        }
+        else {  // unknown format
+            break;
+        }
+
+        return SimpleRTPSink::createNew(envir(), rtpGroupsock, payloadFormatCode, fSamplingFrequency, "audio", mimeType, fNumChannels);
+    } while(0);
+
+    // An error occurred:
+    return NULL;
+}
+
+void WAVAudioFileServerMediaSubsession::testScaleFactor(float &scale) {
+    if(fFileDuration <= 0.0) {
+        // The file is non-seekable, so is probably a live input source.
+        // We don't support scale factors other than 1
+        scale = 1;
+    }
+    else {
+        // We support any integral scale, other than 0
+        int iScale = scale < 0.0 ? (int)(scale - 0.5) : (int)(scale + 0.5);  // round
+        if(iScale == 0)
+            iScale = 1;
+        scale = (float)iScale;
+    }
+}
+
+float WAVAudioFileServerMediaSubsession::duration() const {
+    return fFileDuration;
+}
diff --git a/3rdparty/live555/src/liveMedia/WAVAudioFileSource.cpp b/3rdparty/live555/src/liveMedia/WAVAudioFileSource.cpp
new file mode 100644
index 00000000..b62fa476
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/WAVAudioFileSource.cpp
@@ -0,0 +1,392 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A WAV audio file source
+// Implementation
+
+#include "WAVAudioFileSource.hh"
+#include "InputFile.hh"
+#include "GroupsockHelper.hh"
+
+////////// WAVAudioFileSource //////////
+
+WAVAudioFileSource *WAVAudioFileSource::createNew(UsageEnvironment &env, char const *fileName) {
+    do {
+        FILE *fid = OpenInputFile(env, fileName);
+        if(fid == NULL)
+            break;
+
+        WAVAudioFileSource *newSource = new WAVAudioFileSource(env, fid);
+        if(newSource != NULL && newSource->bitsPerSample() == 0) {
+            // The WAV file header was apparently invalid.
+            Medium::close(newSource);
+            break;
+        }
+
+        newSource->fFileSize = (unsigned)GetFileSize(fileName, fid);
+
+        return newSource;
+    } while(0);
+
+    return NULL;
+}
+
+unsigned WAVAudioFileSource::numPCMBytes() const {
+    if(fFileSize < fWAVHeaderSize)
+        return 0;
+    return fFileSize - fWAVHeaderSize;
+}
+
+void WAVAudioFileSource::setScaleFactor(int scale) {
+    if(!fFidIsSeekable)
+        return;  // we can't do 'trick play' operations on non-seekable files
+
+    fScaleFactor = scale;
+
+    if(fScaleFactor < 0 && TellFile64(fFid) > 0) {
+        // Because we're reading backwards, seek back one sample, to ensure that
+        // (i)  we start reading the last sample before the start point, and
+        // (ii) we don't hit end-of-file on the first read.
+        int bytesPerSample = (fNumChannels * fBitsPerSample) / 8;
+        if(bytesPerSample == 0)
+            bytesPerSample = 1;
+        SeekFile64(fFid, -bytesPerSample, SEEK_CUR);
+    }
+}
+
+void WAVAudioFileSource::seekToPCMByte(unsigned byteNumber) {
+    byteNumber += fWAVHeaderSize;
+    if(byteNumber > fFileSize)
+        byteNumber = fFileSize;
+
+    SeekFile64(fFid, byteNumber, SEEK_SET);
+}
+
+void WAVAudioFileSource::limitNumBytesToStream(unsigned numBytesToStream) {
+    fNumBytesToStream      = numBytesToStream;
+    fLimitNumBytesToStream = fNumBytesToStream > 0;
+}
+
+unsigned char WAVAudioFileSource::getAudioFormat() {
+    return fAudioFormat;
+}
+
+#define nextc fgetc(fid)
+
+static Boolean get4Bytes(FILE *fid, u_int32_t &result) {  // little-endian
+    int c0, c1, c2, c3;
+    if((c0 = nextc) == EOF || (c1 = nextc) == EOF || (c2 = nextc) == EOF || (c3 = nextc) == EOF)
+        return False;
+    result = (c3 << 24) | (c2 << 16) | (c1 << 8) | c0;
+    return True;
+}
+
+static Boolean get2Bytes(FILE *fid, u_int16_t &result) {  // little-endian
+    int c0, c1;
+    if((c0 = nextc) == EOF || (c1 = nextc) == EOF)
+        return False;
+    result = (c1 << 8) | c0;
+    return True;
+}
+
+static Boolean skipBytes(FILE *fid, int num) {
+    while(num-- > 0) {
+        if(nextc == EOF)
+            return False;
+    }
+    return True;
+}
+
+WAVAudioFileSource::WAVAudioFileSource(UsageEnvironment &env, FILE *fid)
+    : AudioInputDevice(env, 0, 0, 0, 0) /* set the real parameters later */,
+      fFid(fid),
+      fFidIsSeekable(False),
+      fLastPlayTime(0),
+      fHaveStartedReading(False),
+      fWAVHeaderSize(0),
+      fFileSize(0),
+      fScaleFactor(1),
+      fLimitNumBytesToStream(False),
+      fNumBytesToStream(0),
+      fAudioFormat(WA_UNKNOWN) {
+    // Check the WAV file header for validity.
+    // Note: The following web pages contain info about the WAV format:
+    // http://www.ringthis.com/dev/wave_format.htm
+    // http://www.lightlink.com/tjweber/StripWav/Canon.html
+    // http://www.onicos.com/staff/iz/formats/wav.html
+
+    Boolean success = False;  // until we learn otherwise
+    do {
+        // RIFF Chunk:
+        if(nextc != 'R' || nextc != 'I' || nextc != 'F' || nextc != 'F')
+            break;
+        if(!skipBytes(fid, 4))
+            break;
+        if(nextc != 'W' || nextc != 'A' || nextc != 'V' || nextc != 'E')
+            break;
+
+        // Skip over any chunk that's not a FORMAT ('fmt ') chunk:
+        u_int32_t tmp;
+        if(!get4Bytes(fid, tmp))
+            break;
+        while(tmp != 0x20746d66 /*'fmt ', little-endian*/) {
+            // Skip this chunk:
+            u_int32_t chunkLength;
+            if(!get4Bytes(fid, chunkLength))
+                break;
+            if(!skipBytes(fid, chunkLength))
+                break;
+            if(!get4Bytes(fid, tmp))
+                break;
+        }
+
+        // FORMAT Chunk (the 4-byte header code has already been parsed):
+        unsigned formatLength;
+        if(!get4Bytes(fid, formatLength))
+            break;
+        unsigned short audioFormat;
+        if(!get2Bytes(fid, audioFormat))
+            break;
+
+        fAudioFormat = (unsigned char)audioFormat;
+        if(fAudioFormat != WA_PCM && fAudioFormat != WA_PCMA && fAudioFormat != WA_PCMU && fAudioFormat != WA_IMA_ADPCM) {
+            // It's a format that we don't (yet) understand
+            env.setResultMsg("Audio format is not one that we handle (PCM/PCMU/PCMA or IMA ADPCM)");
+            break;
+        }
+        unsigned short numChannels;
+        if(!get2Bytes(fid, numChannels))
+            break;
+        fNumChannels = (unsigned char)numChannels;
+        if(fNumChannels < 1 || fNumChannels > 2) {  // invalid # channels
+            char errMsg[100];
+            sprintf(errMsg, "Bad # channels: %d", fNumChannels);
+            env.setResultMsg(errMsg);
+            break;
+        }
+        if(!get4Bytes(fid, fSamplingFrequency))
+            break;
+        if(fSamplingFrequency == 0) {
+            env.setResultMsg("Bad sampling frequency: 0");
+            break;
+        }
+        if(!skipBytes(fid, 6))
+            break;  // "nAvgBytesPerSec" (4 bytes) + "nBlockAlign" (2 bytes)
+        unsigned short bitsPerSample;
+        if(!get2Bytes(fid, bitsPerSample))
+            break;
+        fBitsPerSample = (unsigned char)bitsPerSample;
+        if(fBitsPerSample == 0) {
+            env.setResultMsg("Bad bits-per-sample: 0");
+            break;
+        }
+        if(!skipBytes(fid, formatLength - 16))
+            break;
+
+        // FACT chunk (optional):
+        int c = nextc;
+        if(c == 'f') {
+            if(nextc != 'a' || nextc != 'c' || nextc != 't')
+                break;
+            unsigned factLength;
+            if(!get4Bytes(fid, factLength))
+                break;
+            if(!skipBytes(fid, factLength))
+                break;
+            c = nextc;
+        }
+
+        // EYRE chunk (optional):
+        if(c == 'e') {
+            if(nextc != 'y' || nextc != 'r' || nextc != 'e')
+                break;
+            unsigned eyreLength;
+            if(!get4Bytes(fid, eyreLength))
+                break;
+            if(!skipBytes(fid, eyreLength))
+                break;
+            c = nextc;
+        }
+
+        // DATA Chunk:
+        if(c != 'd' || nextc != 'a' || nextc != 't' || nextc != 'a')
+            break;
+        if(!skipBytes(fid, 4))
+            break;
+
+        // The header is good; the remaining data are the sample bytes.
+        fWAVHeaderSize = (unsigned)TellFile64(fid);
+        success        = True;
+    } while(0);
+
+    if(!success) {
+        env.setResultMsg("Bad WAV file format");
+        // Set "fBitsPerSample" to zero, to indicate failure:
+        fBitsPerSample = 0;
+        return;
+    }
+
+    fPlayTimePerSample = 1e6 / (double)fSamplingFrequency;
+
+    // Although PCM is a sample-based format, we group samples into
+    // 'frames' for efficient delivery to clients.  Set up our preferred
+    // frame size to be close to 20 ms, if possible, but always no greater
+    // than 1400 bytes (to ensure that it will fit in a single RTP packet)
+    unsigned maxSamplesPerFrame     = (1400 * 8) / (fNumChannels * fBitsPerSample);
+    unsigned desiredSamplesPerFrame = (unsigned)(0.02 * fSamplingFrequency);
+    unsigned samplesPerFrame        = desiredSamplesPerFrame < maxSamplesPerFrame ? desiredSamplesPerFrame : maxSamplesPerFrame;
+    fPreferredFrameSize             = (samplesPerFrame * fNumChannels * fBitsPerSample) / 8;
+
+    fFidIsSeekable = FileIsSeekable(fFid);
+#ifndef READ_FROM_FILES_SYNCHRONOUSLY
+    // Now that we've finished reading the WAV header, all future reads (of audio samples) from the file will be asynchronous:
+    makeSocketNonBlocking(fileno(fFid));
+#endif
+}
+
+WAVAudioFileSource::~WAVAudioFileSource() {
+    if(fFid == NULL)
+        return;
+
+#ifndef READ_FROM_FILES_SYNCHRONOUSLY
+    envir().taskScheduler().turnOffBackgroundReadHandling(fileno(fFid));
+#endif
+
+    CloseInputFile(fFid);
+}
+
+void WAVAudioFileSource::doGetNextFrame() {
+    if(feof(fFid) || ferror(fFid) || (fLimitNumBytesToStream && fNumBytesToStream == 0)) {
+        handleClosure();
+        return;
+    }
+
+    fFrameSize = 0;  // until it's set later
+#ifdef READ_FROM_FILES_SYNCHRONOUSLY
+    doReadFromFile();
+#else
+    if(!fHaveStartedReading) {
+        // Await readable data from the file:
+        envir().taskScheduler().turnOnBackgroundReadHandling(fileno(fFid), (TaskScheduler::BackgroundHandlerProc *)&fileReadableHandler, this);
+        fHaveStartedReading = True;
+    }
+#endif
+}
+
+void WAVAudioFileSource::doStopGettingFrames() {
+    envir().taskScheduler().unscheduleDelayedTask(nextTask());
+#ifndef READ_FROM_FILES_SYNCHRONOUSLY
+    envir().taskScheduler().turnOffBackgroundReadHandling(fileno(fFid));
+    fHaveStartedReading = False;
+#endif
+}
+
+void WAVAudioFileSource::fileReadableHandler(WAVAudioFileSource *source, int /*mask*/) {
+    if(!source->isCurrentlyAwaitingData()) {
+        source->doStopGettingFrames();  // we're not ready for the data yet
+        return;
+    }
+    source->doReadFromFile();
+}
+
+void WAVAudioFileSource::doReadFromFile() {
+    // Try to read as many bytes as will fit in the buffer provided (or "fPreferredFrameSize" if less)
+    if(fLimitNumBytesToStream && fNumBytesToStream < fMaxSize) {
+        fMaxSize = fNumBytesToStream;
+    }
+    if(fPreferredFrameSize < fMaxSize) {
+        fMaxSize = fPreferredFrameSize;
+    }
+    unsigned bytesPerSample = (fNumChannels * fBitsPerSample) / 8;
+    if(bytesPerSample == 0)
+        bytesPerSample = 1;  // because we can't read less than a byte at a time
+
+    // For 'trick play', read one sample at a time; otherwise (normal case) read samples in bulk:
+    unsigned bytesToRead = fScaleFactor == 1 ? fMaxSize - fMaxSize % bytesPerSample : bytesPerSample;
+    unsigned numBytesRead;
+    while(1) {  // loop for 'trick play' only
+#ifdef READ_FROM_FILES_SYNCHRONOUSLY
+        numBytesRead = fread(fTo, 1, bytesToRead, fFid);
+#else
+        if(fFidIsSeekable) {
+            numBytesRead = fread(fTo, 1, bytesToRead, fFid);
+        }
+        else {
+            // For non-seekable files (e.g., pipes), call "read()" rather than "fread()", to ensure that the read doesn't block:
+            numBytesRead = read(fileno(fFid), fTo, bytesToRead);
+        }
+#endif
+        if(numBytesRead == 0) {
+            handleClosure();
+            return;
+        }
+        fFrameSize += numBytesRead;
+        fTo += numBytesRead;
+        fMaxSize -= numBytesRead;
+        fNumBytesToStream -= numBytesRead;
+
+        // If we did an asynchronous read, and didn't read an integral number of samples, then we need to wait for another read:
+#ifndef READ_FROM_FILES_SYNCHRONOUSLY
+        if(fFrameSize % bytesPerSample > 0)
+            return;
+#endif
+
+        // If we're doing 'trick play', then seek to the appropriate place for reading the next sample,
+        // and keep reading until we fill the provided buffer:
+        if(fScaleFactor != 1) {
+            SeekFile64(fFid, (fScaleFactor - 1) * bytesPerSample, SEEK_CUR);
+            if(fMaxSize < bytesPerSample)
+                break;
+        }
+        else {
+            break;  // from the loop (normal case)
+        }
+    }
+
+    // Set the 'presentation time' and 'duration' of this frame:
+    if(fPresentationTime.tv_sec == 0 && fPresentationTime.tv_usec == 0) {
+        // This is the first frame, so use the current time:
+        gettimeofday(&fPresentationTime, NULL);
+    }
+    else {
+        // Increment by the play time of the previous data:
+        unsigned uSeconds = fPresentationTime.tv_usec + fLastPlayTime;
+        fPresentationTime.tv_sec += uSeconds / 1000000;
+        fPresentationTime.tv_usec = uSeconds % 1000000;
+    }
+
+    // Remember the play time of this data:
+    fDurationInMicroseconds = fLastPlayTime = (unsigned)((fPlayTimePerSample * fFrameSize) / bytesPerSample);
+
+    // Inform the reader that he has data:
+#ifdef READ_FROM_FILES_SYNCHRONOUSLY
+    // To avoid possible infinite recursion, we need to return to the event loop to do this:
+    nextTask() = envir().taskScheduler().scheduleDelayedTask(0, (TaskFunc *)FramedSource::afterGetting, this);
+#else
+    // Because the file read was done from the event loop, we can call the
+    // 'after getting' function directly, without risk of infinite recursion:
+    FramedSource::afterGetting(this);
+#endif
+}
+
+Boolean WAVAudioFileSource::setInputPort(int /*portIndex*/) {
+    return True;
+}
+
+double WAVAudioFileSource::getAverageLevel() const {
+    return 0.0;  //##### fix this later
+}
diff --git a/3rdparty/live555/src/liveMedia/include/AC3AudioFileServerMediaSubsession.hh b/3rdparty/live555/src/liveMedia/include/AC3AudioFileServerMediaSubsession.hh
new file mode 100644
index 00000000..d716e8b8
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/AC3AudioFileServerMediaSubsession.hh
@@ -0,0 +1,48 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A 'ServerMediaSubsession' object that creates new, unicast, "RTPSink"s
+// on demand, from an AC3 audio file.
+// C++ header
+
+#ifndef _AC3_AUDIO_FILE_SERVER_MEDIA_SUBSESSION_HH
+#define _AC3_AUDIO_FILE_SERVER_MEDIA_SUBSESSION_HH
+
+#ifndef _FILE_SERVER_MEDIA_SUBSESSION_HH
+#include "FileServerMediaSubsession.hh"
+#endif
+
+class AC3AudioFileServerMediaSubsession: public FileServerMediaSubsession{
+public:
+  static AC3AudioFileServerMediaSubsession*
+  createNew(UsageEnvironment& env, char const* fileName, Boolean reuseFirstSource);
+
+private:
+  AC3AudioFileServerMediaSubsession(UsageEnvironment& env,
+				      char const* fileName, Boolean reuseFirstSource);
+      // called only by createNew();
+  virtual ~AC3AudioFileServerMediaSubsession();
+
+private: // redefined virtual functions
+  virtual FramedSource* createNewStreamSource(unsigned clientSessionId,
+					      unsigned& estBitrate);
+  virtual RTPSink* createNewRTPSink(Groupsock* rtpGroupsock,
+                                    unsigned char rtpPayloadTypeIfDynamic,
+				    FramedSource* inputSource);
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/AC3AudioRTPSink.hh b/3rdparty/live555/src/liveMedia/include/AC3AudioRTPSink.hh
new file mode 100644
index 00000000..ee367dc3
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/AC3AudioRTPSink.hh
@@ -0,0 +1,57 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// RTP sink for AC3 audio
+// C++ header
+
+#ifndef _AC3_AUDIO_RTP_SINK_HH
+#define _AC3_AUDIO_RTP_SINK_HH
+
+#ifndef _AUDIO_RTP_SINK_HH
+#include "AudioRTPSink.hh"
+#endif
+
+class AC3AudioRTPSink: public AudioRTPSink {
+public:
+  static AC3AudioRTPSink* createNew(UsageEnvironment& env,
+				    Groupsock* RTPgs,
+				    u_int8_t rtpPayloadFormat,
+				    u_int32_t rtpTimestampFrequency);
+
+protected:
+  AC3AudioRTPSink(UsageEnvironment& env, Groupsock* RTPgs,
+		  u_int8_t rtpPayloadFormat,
+		  u_int32_t rtpTimestampFrequency);
+	// called only by createNew()
+
+  virtual ~AC3AudioRTPSink();
+
+private: // redefined virtual functions:
+  virtual Boolean frameCanAppearAfterPacketStart(unsigned char const* frameStart,
+						 unsigned numBytesInFrame) const;
+  virtual void doSpecialFrameHandling(unsigned fragmentationOffset,
+                                      unsigned char* frameStart,
+                                      unsigned numBytesInFrame,
+                                      struct timeval framePresentationTime,
+                                      unsigned numRemainingBytes);
+  virtual unsigned specialHeaderSize() const;
+
+private:
+  unsigned char fTotNumFragmentsUsed; // used only if a frame gets fragmented across multiple packets
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/AC3AudioRTPSource.hh b/3rdparty/live555/src/liveMedia/include/AC3AudioRTPSource.hh
new file mode 100644
index 00000000..1f5c9879
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/AC3AudioRTPSource.hh
@@ -0,0 +1,51 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// AC3 Audio RTP Sources
+// C++ header
+
+#ifndef _AC3_AUDIO_RTP_SOURCE_HH
+#define _AC3_AUDIO_RTP_SOURCE_HH
+
+#ifndef _MULTI_FRAMED_RTP_SOURCE_HH
+#include "MultiFramedRTPSource.hh"
+#endif
+
+class AC3AudioRTPSource: public MultiFramedRTPSource {
+public:
+  static AC3AudioRTPSource*
+  createNew(UsageEnvironment& env, Groupsock* RTPgs,
+	    unsigned char rtpPayloadFormat,
+	    unsigned rtpTimestampFrequency);
+
+protected:
+  virtual ~AC3AudioRTPSource();
+
+private:
+  AC3AudioRTPSource(UsageEnvironment& env, Groupsock* RTPgs,
+		     unsigned char rtpPayloadFormat,
+		     unsigned rtpTimestampFrequency);
+      // called only by createNew()
+
+private:
+  // redefined virtual functions:
+  virtual Boolean processSpecialHeader(BufferedPacket* packet,
+                                       unsigned& resultSpecialHeaderSize);
+  virtual char const* MIMEtype() const;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/AC3AudioStreamFramer.hh b/3rdparty/live555/src/liveMedia/include/AC3AudioStreamFramer.hh
new file mode 100644
index 00000000..06cb89f0
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/AC3AudioStreamFramer.hh
@@ -0,0 +1,70 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A filter that breaks up an AC3 audio elementary stream into frames
+// C++ header
+
+#ifndef _AC3_AUDIO_STREAM_FRAMER_HH
+#define _AC3_AUDIO_STREAM_FRAMER_HH
+
+#ifndef _FRAMED_FILTER_HH
+#include "FramedFilter.hh"
+#endif
+
+class AC3AudioStreamFramer: public FramedFilter {
+public:
+  static AC3AudioStreamFramer*
+  createNew(UsageEnvironment& env, FramedSource* inputSource,
+	    unsigned char streamCode = 0);
+  // If "streamCode" != 0, then we assume that there's a 1-byte code at the beginning of each chunk of data that we read from
+  // our source.  If that code is not the value we want, we discard the chunk of data.
+  // However, if "streamCode" == 0 (the default), then we don't expect this 1-byte code.
+
+  unsigned samplingRate();
+
+  void flushInput(); // called if there is a discontinuity (seeking) in the input
+
+private:
+  AC3AudioStreamFramer(UsageEnvironment& env, FramedSource* inputSource,
+		       unsigned char streamCode);
+      // called only by createNew()
+  virtual ~AC3AudioStreamFramer();
+
+  static void handleNewData(void* clientData,
+			    unsigned char* ptr, unsigned size,
+			    struct timeval presentationTime);
+  void handleNewData(unsigned char* ptr, unsigned size);
+
+  void parseNextFrame();
+
+private:
+  // redefined virtual functions:
+  virtual void doGetNextFrame();
+
+private:
+  struct timeval currentFramePlayTime() const;
+
+private:
+  struct timeval fNextFramePresentationTime;
+
+private: // parsing state
+  class AC3AudioStreamParser* fParser;
+  unsigned char fOurStreamCode;
+  friend class AC3AudioStreamParser; // hack
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/ADTSAudioFileServerMediaSubsession.hh b/3rdparty/live555/src/liveMedia/include/ADTSAudioFileServerMediaSubsession.hh
new file mode 100644
index 00000000..921ab0ef
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/ADTSAudioFileServerMediaSubsession.hh
@@ -0,0 +1,48 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A 'ServerMediaSubsession' object that creates new, unicast, "RTPSink"s
+// on demand, from an AAC audio file in ADTS format
+// C++ header
+
+#ifndef _ADTS_AUDIO_FILE_SERVER_MEDIA_SUBSESSION_HH
+#define _ADTS_AUDIO_FILE_SERVER_MEDIA_SUBSESSION_HH
+
+#ifndef _FILE_SERVER_MEDIA_SUBSESSION_HH
+#include "FileServerMediaSubsession.hh"
+#endif
+
+class ADTSAudioFileServerMediaSubsession: public FileServerMediaSubsession{
+public:
+  static ADTSAudioFileServerMediaSubsession*
+  createNew(UsageEnvironment& env, char const* fileName, Boolean reuseFirstSource);
+
+protected:
+  ADTSAudioFileServerMediaSubsession(UsageEnvironment& env,
+				      char const* fileName, Boolean reuseFirstSource);
+      // called only by createNew();
+  virtual ~ADTSAudioFileServerMediaSubsession();
+
+protected: // redefined virtual functions
+  virtual FramedSource* createNewStreamSource(unsigned clientSessionId,
+					      unsigned& estBitrate);
+  virtual RTPSink* createNewRTPSink(Groupsock* rtpGroupsock,
+                                    unsigned char rtpPayloadTypeIfDynamic,
+				    FramedSource* inputSource);
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/ADTSAudioFileSource.hh b/3rdparty/live555/src/liveMedia/include/ADTSAudioFileSource.hh
new file mode 100644
index 00000000..89627f5d
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/ADTSAudioFileSource.hh
@@ -0,0 +1,56 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A source object for AAC audio files in ADTS format
+// C++ header
+
+#ifndef _ADTS_AUDIO_FILE_SOURCE_HH
+#define _ADTS_AUDIO_FILE_SOURCE_HH
+
+#ifndef _FRAMED_FILE_SOURCE_HH
+#include "FramedFileSource.hh"
+#endif
+
+class ADTSAudioFileSource: public FramedFileSource {
+public:
+  static ADTSAudioFileSource* createNew(UsageEnvironment& env,
+				       char const* fileName);
+
+  unsigned samplingFrequency() const { return fSamplingFrequency; }
+  unsigned numChannels() const { return fNumChannels; }
+  char const* configStr() const { return fConfigStr; }
+      // returns the 'AudioSpecificConfig' for this stream (in ASCII form)
+
+private:
+  ADTSAudioFileSource(UsageEnvironment& env, FILE* fid, u_int8_t profile,
+		      u_int8_t samplingFrequencyIndex, u_int8_t channelConfiguration);
+	// called only by createNew()
+
+  virtual ~ADTSAudioFileSource();
+
+private:
+  // redefined virtual functions:
+  virtual void doGetNextFrame();
+
+private:
+  unsigned fSamplingFrequency;
+  unsigned fNumChannels;
+  unsigned fuSecsPerFrame;
+  char fConfigStr[5];
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/ADTSAudioStreamDiscreteFramer.hh b/3rdparty/live555/src/liveMedia/include/ADTSAudioStreamDiscreteFramer.hh
new file mode 100644
index 00000000..2dbc96f3
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/ADTSAudioStreamDiscreteFramer.hh
@@ -0,0 +1,61 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A filter that reads (discrete) AAC audio frames, and outputs each frame with
+// a preceding ADTS header.
+// C++ header
+
+#ifndef _ADTS_AUDIO_STREAM_DISCRETE_FRAMER_HH
+#define _ADTS_AUDIO_STREAM_DISCRETE_FRAMER_HH
+
+#ifndef _FRAMED_FILTER_HH
+#include "FramedFilter.hh"
+#endif
+
+#define ADTS_HEADER_SIZE 7 // we don't include a checksum
+
+class ADTSAudioStreamDiscreteFramer: public FramedFilter {
+public:
+  static ADTSAudioStreamDiscreteFramer*
+  createNew(UsageEnvironment& env, FramedSource* inputSource, char const* configStr);
+    // "configStr" should be a 4-character hexadecimal string for a 2-byte value
+
+protected:
+  ADTSAudioStreamDiscreteFramer(UsageEnvironment& env, FramedSource* inputSource,
+				u_int8_t profile, u_int8_t samplingFrequencyIndex, u_int8_t channelConfiguration);
+      // called only by createNew()
+  virtual ~ADTSAudioStreamDiscreteFramer();
+
+protected:
+  // redefined virtual functions:
+  virtual void doGetNextFrame();
+
+protected:
+  static void afterGettingFrame(void* clientData, unsigned frameSize,
+                                unsigned numTruncatedBytes,
+                                struct timeval presentationTime,
+                                unsigned durationInMicroseconds);
+  void afterGettingFrame1(unsigned frameSize,
+                          unsigned numTruncatedBytes,
+                          struct timeval presentationTime,
+                          unsigned durationInMicroseconds);
+
+private:
+  u_int8_t fADTSHeader[ADTS_HEADER_SIZE];
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/AMRAudioFileServerMediaSubsession.hh b/3rdparty/live555/src/liveMedia/include/AMRAudioFileServerMediaSubsession.hh
new file mode 100644
index 00000000..a49b2044
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/AMRAudioFileServerMediaSubsession.hh
@@ -0,0 +1,48 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A 'ServerMediaSubsession' object that creates new, unicast, "RTPSink"s
+// on demand, from an AMR audio file.
+// C++ header
+
+#ifndef _AMR_AUDIO_FILE_SERVER_MEDIA_SUBSESSION_HH
+#define _AMR_AUDIO_FILE_SERVER_MEDIA_SUBSESSION_HH
+
+#ifndef _FILE_SERVER_MEDIA_SUBSESSION_HH
+#include "FileServerMediaSubsession.hh"
+#endif
+
+class AMRAudioFileServerMediaSubsession: public FileServerMediaSubsession{
+public:
+  static AMRAudioFileServerMediaSubsession*
+  createNew(UsageEnvironment& env, char const* fileName, Boolean reuseFirstSource);
+
+private:
+  AMRAudioFileServerMediaSubsession(UsageEnvironment& env,
+				      char const* fileName, Boolean reuseFirstSource);
+      // called only by createNew();
+  virtual ~AMRAudioFileServerMediaSubsession();
+
+private: // redefined virtual functions
+  virtual FramedSource* createNewStreamSource(unsigned clientSessionId,
+					      unsigned& estBitrate);
+  virtual RTPSink* createNewRTPSink(Groupsock* rtpGroupsock,
+                                    unsigned char rtpPayloadTypeIfDynamic,
+				    FramedSource* inputSource);
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/AMRAudioFileSink.hh b/3rdparty/live555/src/liveMedia/include/AMRAudioFileSink.hh
new file mode 100644
index 00000000..116c435e
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/AMRAudioFileSink.hh
@@ -0,0 +1,51 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// AMR Audio File Sinks
+// C++ header
+
+#ifndef _AMR_AUDIO_FILE_SINK_HH
+#define _AMR_AUDIO_FILE_SINK_HH
+
+#ifndef _FILE_SINK_HH
+#include "FileSink.hh"
+#endif
+
+class AMRAudioFileSink: public FileSink {
+public:
+  static AMRAudioFileSink* createNew(UsageEnvironment& env, char const* fileName,
+				     unsigned bufferSize = 10000,
+				     Boolean oneFilePerFrame = False);
+  // (See "FileSink.hh" for a description of these parameters.)
+
+protected:
+  AMRAudioFileSink(UsageEnvironment& env, FILE* fid, unsigned bufferSize,
+		   char const* perFrameFileNamePrefix);
+      // called only by createNew()
+  virtual ~AMRAudioFileSink();
+
+protected: // redefined virtual functions:
+  virtual Boolean sourceIsCompatibleWithUs(MediaSource& source);
+  virtual void afterGettingFrame(unsigned frameSize,
+				 unsigned numTruncatedBytes,
+				 struct timeval presentationTime);
+
+protected:
+  Boolean fHaveWrittenHeader;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/AMRAudioFileSource.hh b/3rdparty/live555/src/liveMedia/include/AMRAudioFileSource.hh
new file mode 100644
index 00000000..4a5219e8
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/AMRAudioFileSource.hh
@@ -0,0 +1,48 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A source object for AMR audio files (as defined in RFC 4867, section 5)
+// C++ header
+
+#ifndef _AMR_AUDIO_FILE_SOURCE_HH
+#define _AMR_AUDIO_FILE_SOURCE_HH
+
+#ifndef _AMR_AUDIO_SOURCE_HH
+#include "AMRAudioSource.hh"
+#endif
+
+class AMRAudioFileSource: public AMRAudioSource {
+public:
+  static AMRAudioFileSource* createNew(UsageEnvironment& env,
+				       char const* fileName);
+
+private:
+  AMRAudioFileSource(UsageEnvironment& env, FILE* fid,
+		     Boolean isWideband, unsigned numChannels);
+	// called only by createNew()
+
+  virtual ~AMRAudioFileSource();
+
+private:
+  // redefined virtual functions:
+  virtual void doGetNextFrame();
+
+private:
+  FILE* fFid;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/AMRAudioRTPSink.hh b/3rdparty/live555/src/liveMedia/include/AMRAudioRTPSink.hh
new file mode 100644
index 00000000..418ab82d
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/AMRAudioRTPSink.hh
@@ -0,0 +1,65 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// RTP sink for AMR audio (RFC 4867)
+// C++ header
+
+#ifndef _AMR_AUDIO_RTP_SINK_HH
+#define _AMR_AUDIO_RTP_SINK_HH
+
+#ifndef _AUDIO_RTP_SINK_HH
+#include "AudioRTPSink.hh"
+#endif
+
+class AMRAudioRTPSink: public AudioRTPSink {
+public:
+  static AMRAudioRTPSink* createNew(UsageEnvironment& env,
+				    Groupsock* RTPgs,
+				    unsigned char rtpPayloadFormat,
+				    Boolean sourceIsWideband = False,
+				    unsigned numChannelsInSource = 1);
+
+  Boolean sourceIsWideband() const { return fSourceIsWideband; }
+
+protected:
+  AMRAudioRTPSink(UsageEnvironment& env, Groupsock* RTPgs,
+		  unsigned char rtpPayloadFormat,
+		  Boolean sourceIsWideband, unsigned numChannelsInSource);
+	// called only by createNew()
+
+  virtual ~AMRAudioRTPSink();
+
+private: // redefined virtual functions:
+  virtual Boolean sourceIsCompatibleWithUs(MediaSource& source);
+  virtual void doSpecialFrameHandling(unsigned fragmentationOffset,
+                                      unsigned char* frameStart,
+                                      unsigned numBytesInFrame,
+                                      struct timeval framePresentationTime,
+                                      unsigned numRemainingBytes);
+  virtual Boolean
+  frameCanAppearAfterPacketStart(unsigned char const* frameStart,
+				 unsigned numBytesInFrame) const;
+
+  virtual unsigned specialHeaderSize() const;
+  virtual char const* auxSDPLine();
+
+private:
+  Boolean fSourceIsWideband;
+  char* fFmtpSDPLine;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/AMRAudioRTPSource.hh b/3rdparty/live555/src/liveMedia/include/AMRAudioRTPSource.hh
new file mode 100644
index 00000000..99d13b1f
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/AMRAudioRTPSource.hh
@@ -0,0 +1,53 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// AMR Audio RTP Sources (RFC 4867)
+// C++ header
+
+#ifndef _AMR_AUDIO_RTP_SOURCE_HH
+#define _AMR_AUDIO_RTP_SOURCE_HH
+
+#ifndef _RTP_SOURCE_HH
+#include "RTPSource.hh"
+#endif
+#ifndef _AMR_AUDIO_SOURCE_HH
+#include "AMRAudioSource.hh"
+#endif
+
+class AMRAudioRTPSource {
+public:
+  static AMRAudioSource* createNew(UsageEnvironment& env,
+				   Groupsock* RTPgs,
+				   RTPSource*& resultRTPSource,
+				   unsigned char rtpPayloadFormat,
+				   Boolean isWideband = False,
+				   unsigned numChannels = 1,
+				   Boolean isOctetAligned = True,
+				   unsigned interleaving = 0,
+				     // relevant only if "isOctetAligned"
+				     // The maximum # of frame-blocks in a group
+				     // 0 means: no interleaving
+				   Boolean robustSortingOrder = False,
+				     // relevant only if "isOctetAligned"
+				   Boolean CRCsArePresent = False
+				     // relevant only if "isOctetAligned"
+				   );
+      // This returns a source to read from, but "resultRTPSource" will
+      // point to RTP-related state.
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/AMRAudioSource.hh b/3rdparty/live555/src/liveMedia/include/AMRAudioSource.hh
new file mode 100644
index 00000000..5422590e
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/AMRAudioSource.hh
@@ -0,0 +1,52 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A source object for AMR audio sources
+// C++ header
+
+#ifndef _AMR_AUDIO_SOURCE_HH
+#define _AMR_AUDIO_SOURCE_HH
+
+#ifndef _FRAMED_SOURCE_HH
+#include "FramedSource.hh"
+#endif
+
+class AMRAudioSource: public FramedSource {
+public:
+  Boolean isWideband() const { return fIsWideband; }
+  unsigned numChannels() const { return fNumChannels; }
+
+  u_int8_t lastFrameHeader() const { return fLastFrameHeader; }
+  // The frame header for the most recently read frame (RFC 4867, sec. 5.3)
+
+protected:
+  AMRAudioSource(UsageEnvironment& env, Boolean isWideband, unsigned numChannels);
+	// virtual base class
+  virtual ~AMRAudioSource();
+
+private:
+  // redefined virtual functions:
+  virtual char const* MIMEtype() const;
+  virtual Boolean isAMRAudioSource() const;
+
+protected:
+  Boolean fIsWideband;
+  unsigned fNumChannels;
+  u_int8_t fLastFrameHeader;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/AVIFileSink.hh b/3rdparty/live555/src/liveMedia/include/AVIFileSink.hh
new file mode 100644
index 00000000..e7b55fbc
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/AVIFileSink.hh
@@ -0,0 +1,115 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A sink that generates an AVI file from a composite media session
+// C++ header
+
+#ifndef _AVI_FILE_SINK_HH
+#define _AVI_FILE_SINK_HH
+
+#ifndef _MEDIA_SESSION_HH
+#include "MediaSession.hh"
+#endif
+
+class AVIFileSink: public Medium {
+public:
+  static AVIFileSink* createNew(UsageEnvironment& env,
+				MediaSession& inputSession,
+				char const* outputFileName,
+				unsigned bufferSize = 20000,
+				unsigned short movieWidth = 240,
+				unsigned short movieHeight = 180,
+				unsigned movieFPS = 15,
+				Boolean packetLossCompensate = False);
+
+  typedef void (afterPlayingFunc)(void* clientData);
+  Boolean startPlaying(afterPlayingFunc* afterFunc,
+                       void* afterClientData);
+
+  unsigned numActiveSubsessions() const { return fNumSubsessions; }
+
+private:
+  AVIFileSink(UsageEnvironment& env, MediaSession& inputSession,
+	      char const* outputFileName, unsigned bufferSize,
+	      unsigned short movieWidth, unsigned short movieHeight,
+	      unsigned movieFPS, Boolean packetLossCompensate);
+      // called only by createNew()
+  virtual ~AVIFileSink();
+
+  Boolean continuePlaying();
+  static void afterGettingFrame(void* clientData, unsigned frameSize,
+				unsigned numTruncatedBytes,
+				struct timeval presentationTime,
+				unsigned durationInMicroseconds);
+  static void onSourceClosure(void* clientData);
+  void onSourceClosure1();
+  static void onRTCPBye(void* clientData);
+  void addIndexRecord(class AVIIndexRecord* newIndexRecord);
+  void completeOutputFile();
+
+private:
+  friend class AVISubsessionIOState;
+  MediaSession& fInputSession;
+  FILE* fOutFid;
+  class AVIIndexRecord *fIndexRecordsHead, *fIndexRecordsTail;
+  unsigned fNumIndexRecords;
+  unsigned fBufferSize;
+  Boolean fPacketLossCompensate;
+  Boolean fAreCurrentlyBeingPlayed;
+  afterPlayingFunc* fAfterFunc;
+  void* fAfterClientData;
+  unsigned fNumSubsessions;
+  unsigned fNumBytesWritten;
+  struct timeval fStartTime;
+  Boolean fHaveCompletedOutputFile;
+
+private:
+  ///// Definitions specific to the AVI file format:
+
+  unsigned addWord(unsigned word); // outputs "word" in little-endian order
+  unsigned addHalfWord(unsigned short halfWord);
+  unsigned addByte(unsigned char byte) {
+    putc(byte, fOutFid);
+    return 1;
+  }
+  unsigned addZeroWords(unsigned numWords);
+  unsigned add4ByteString(char const* str);
+  void setWord(unsigned filePosn, unsigned size);
+
+  // Define member functions for outputting various types of file header:
+#define _header(name) unsigned addFileHeader_##name()
+  _header(AVI);
+      _header(hdrl);
+          _header(avih);
+          _header(strl);
+              _header(strh);
+              _header(strf);
+              _header(JUNK);
+//        _header(JUNK);
+      _header(movi);
+private:
+  unsigned short fMovieWidth, fMovieHeight;
+  unsigned fMovieFPS;
+  unsigned fRIFFSizePosition, fRIFFSizeValue;
+  unsigned fAVIHMaxBytesPerSecondPosition;
+  unsigned fAVIHFrameCountPosition;
+  unsigned fMoviSizePosition, fMoviSizeValue;
+  class AVISubsessionIOState* fCurrentIOState;
+  unsigned fJunkNumber;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/AudioInputDevice.hh b/3rdparty/live555/src/liveMedia/include/AudioInputDevice.hh
new file mode 100644
index 00000000..bf68a1f0
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/AudioInputDevice.hh
@@ -0,0 +1,71 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// Generic audio input device (such as a microphone, or an input sound card)
+// C++ header
+
+#ifndef _AUDIO_INPUT_DEVICE_HH
+#define _AUDIO_INPUT_DEVICE_HH
+
+#ifndef _FRAMED_SOURCE_HH
+#include "FramedSource.hh"
+#endif
+
+class AudioPortNames {
+public:
+  AudioPortNames();
+  virtual ~AudioPortNames();
+
+  unsigned numPorts;
+  char** portName;
+};
+
+class AudioInputDevice: public FramedSource {
+public:
+  unsigned char bitsPerSample() const { return fBitsPerSample; }
+  unsigned char numChannels() const { return fNumChannels; }
+  unsigned samplingFrequency() const { return fSamplingFrequency; }
+
+  virtual Boolean setInputPort(int portIndex) = 0;
+  virtual double getAverageLevel() const = 0;
+
+  static AudioInputDevice*
+  createNew(UsageEnvironment& env, int inputPortNumber,
+	    unsigned char bitsPerSample, unsigned char numChannels,
+	    unsigned samplingFrequency, unsigned granularityInMS = 20);
+  static AudioPortNames* getPortNames();
+
+  static char** allowedDeviceNames;
+  // If this is set to non-NULL, then it's a NULL-terminated array of strings
+  // of device names that we are allowed to access.
+
+protected:
+  AudioInputDevice(UsageEnvironment& env,
+		   unsigned char bitsPerSample,
+		   unsigned char numChannels,
+		   unsigned samplingFrequency,
+		   unsigned granularityInMS);
+	// we're an abstract base class
+
+  virtual ~AudioInputDevice();
+
+protected:
+  unsigned char fBitsPerSample, fNumChannels;
+  unsigned fSamplingFrequency;
+  unsigned fGranularityInMS;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/AudioRTPSink.hh b/3rdparty/live555/src/liveMedia/include/AudioRTPSink.hh
new file mode 100644
index 00000000..52e22227
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/AudioRTPSink.hh
@@ -0,0 +1,42 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A generic RTP sink for audio codecs (abstract base class)
+// C++ header
+
+#ifndef _AUDIO_RTP_SINK_HH
+#define _AUDIO_RTP_SINK_HH
+
+#ifndef _MULTI_FRAMED_RTP_SINK_HH
+#include "MultiFramedRTPSink.hh"
+#endif
+
+class AudioRTPSink: public MultiFramedRTPSink {
+protected:
+  AudioRTPSink(UsageEnvironment& env,
+	       Groupsock* rtpgs, unsigned char rtpPayloadType,
+	       unsigned rtpTimestampFrequency,
+	       char const* rtpPayloadFormatName,
+	       unsigned numChannels = 1);
+  // (we're an abstract base class)
+  virtual ~AudioRTPSink();
+
+private: // redefined virtual functions:
+  virtual char const* sdpMediaType() const;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/Base64.hh b/3rdparty/live555/src/liveMedia/include/Base64.hh
new file mode 100644
index 00000000..0d7db5db
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/Base64.hh
@@ -0,0 +1,43 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// Base64 encoding and decoding
+// C++ header
+
+#ifndef _BASE64_HH
+#define _BASE64_HH
+
+#ifndef _BOOLEAN_HH
+#include "Boolean.hh"
+#endif
+
+unsigned char* base64Decode(char const* in, unsigned& resultSize,
+			    Boolean trimTrailingZeros = True);
+    // returns a newly allocated array - of size "resultSize" - that
+    // the caller is responsible for delete[]ing.
+
+unsigned char* base64Decode(char const* in, unsigned inSize,
+			    unsigned& resultSize,
+			    Boolean trimTrailingZeros = True);
+    // As above, but includes the size of the input string (i.e., the number of bytes to decode) as a parameter.
+    // This saves an extra call to "strlen()" if we already know the length of the input string.
+
+char* base64Encode(char const* orig, unsigned origLength);
+    // returns a 0-terminated string that
+    // the caller is responsible for delete[]ing.
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/BasicUDPSink.hh b/3rdparty/live555/src/liveMedia/include/BasicUDPSink.hh
new file mode 100644
index 00000000..23055342
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/BasicUDPSink.hh
@@ -0,0 +1,62 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A simple UDP sink (i.e., without RTP or other headers added); one frame per packet
+// C++ header
+
+#ifndef _BASIC_UDP_SINK_HH
+#define _BASIC_UDP_SINK_HH
+
+#ifndef _MEDIA_SINK_HH
+#include "MediaSink.hh"
+#endif
+#ifndef _GROUPSOCK_HH
+#include <Groupsock.hh>
+#endif
+
+class BasicUDPSink: public MediaSink {
+public:
+  static BasicUDPSink* createNew(UsageEnvironment& env, Groupsock* gs,
+				  unsigned maxPayloadSize = 1450);
+protected:
+  BasicUDPSink(UsageEnvironment& env, Groupsock* gs, unsigned maxPayloadSize);
+      // called only by createNew()
+  virtual ~BasicUDPSink();
+
+private: // redefined virtual functions:
+  virtual Boolean continuePlaying();
+
+private:
+  void continuePlaying1();
+
+  static void afterGettingFrame(void* clientData, unsigned frameSize,
+				unsigned numTruncatedBytes,
+				struct timeval presentationTime,
+				unsigned durationInMicroseconds);
+  void afterGettingFrame1(unsigned frameSize, unsigned numTruncatedBytes,
+			  unsigned durationInMicroseconds);
+
+  static void sendNext(void* firstArg);
+
+private:
+  Groupsock* fGS;
+  unsigned fMaxPayloadSize;
+  unsigned char* fOutputBuffer;
+  struct timeval fNextSendTime;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/BasicUDPSource.hh b/3rdparty/live555/src/liveMedia/include/BasicUDPSource.hh
new file mode 100644
index 00000000..76191634
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/BasicUDPSource.hh
@@ -0,0 +1,56 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A simple UDP source, where every UDP payload is a complete frame
+// C++ header
+
+#ifndef _BASIC_UDP_SOURCE_HH
+#define _BASIC_UDP_SOURCE_HH
+
+#ifndef _FRAMED_SOURCE_HH
+#include "FramedSource.hh"
+#endif
+#ifndef _GROUPSOCK_HH
+#include "Groupsock.hh"
+#endif
+
+class BasicUDPSource: public FramedSource {
+public:
+  static BasicUDPSource* createNew(UsageEnvironment& env, Groupsock* inputGS);
+
+  virtual ~BasicUDPSource();
+
+  Groupsock* gs() const { return fInputGS; }
+
+private:
+  BasicUDPSource(UsageEnvironment& env, Groupsock* inputGS);
+      // called only by createNew()
+
+  static void incomingPacketHandler(BasicUDPSource* source, int mask);
+  void incomingPacketHandler1();
+
+private: // redefined virtual functions:
+  virtual unsigned maxFrameSize() const;
+  virtual void doGetNextFrame();
+  virtual void doStopGettingFrames();
+
+private:
+  Groupsock* fInputGS;
+  Boolean fHaveStartedReading;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/BitVector.hh b/3rdparty/live555/src/liveMedia/include/BitVector.hh
new file mode 100644
index 00000000..5b04943f
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/BitVector.hh
@@ -0,0 +1,67 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// Bit Vector data structure
+// C++ header
+
+#ifndef _BIT_VECTOR_HH
+#define _BIT_VECTOR_HH
+
+#ifndef _BOOLEAN_HH
+#include "Boolean.hh"
+#endif
+
+class BitVector {
+public:
+  BitVector(unsigned char* baseBytePtr,
+	    unsigned baseBitOffset,
+	    unsigned totNumBits);
+
+  void setup(unsigned char* baseBytePtr,
+	     unsigned baseBitOffset,
+	     unsigned totNumBits);
+
+  void putBits(unsigned from, unsigned numBits); // "numBits" <= 32
+  void put1Bit(unsigned bit);
+
+  unsigned getBits(unsigned numBits); // "numBits" <= 32
+  unsigned get1Bit();
+  Boolean get1BitBoolean() { return get1Bit() != 0; }
+
+  void skipBits(unsigned numBits);
+
+  unsigned curBitIndex() const { return fCurBitIndex; }
+  unsigned totNumBits() const { return fTotNumBits; }
+  unsigned numBitsRemaining() const { return fTotNumBits - fCurBitIndex; }
+
+  unsigned get_expGolomb();
+      // Returns the value of the next bits, assuming that they were encoded using an exponential-Golomb code of order 0
+  int get_expGolombSigned(); // signed version of the above
+
+private:
+  unsigned char* fBaseBytePtr;
+  unsigned fBaseBitOffset;
+  unsigned fTotNumBits;
+  unsigned fCurBitIndex;
+};
+
+// A general bit copy operation:
+void shiftBits(unsigned char* toBasePtr, unsigned toBitOffset,
+	       unsigned char const* fromBasePtr, unsigned fromBitOffset,
+	       unsigned numBits);
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/ByteStreamFileSource.hh b/3rdparty/live555/src/liveMedia/include/ByteStreamFileSource.hh
new file mode 100644
index 00000000..3ea89741
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/ByteStreamFileSource.hh
@@ -0,0 +1,82 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A file source that is a plain byte stream (rather than frames)
+// C++ header
+
+#ifndef _BYTE_STREAM_FILE_SOURCE_HH
+#define _BYTE_STREAM_FILE_SOURCE_HH
+
+#ifndef _FRAMED_FILE_SOURCE_HH
+#include "FramedFileSource.hh"
+#endif
+
+class ByteStreamFileSource: public FramedFileSource {
+public:
+  static ByteStreamFileSource* createNew(UsageEnvironment& env,
+					 char const* fileName,
+					 unsigned preferredFrameSize = 0,
+					 unsigned playTimePerFrame = 0);
+  // "preferredFrameSize" == 0 means 'no preference'
+  // "playTimePerFrame" is in microseconds
+
+  static ByteStreamFileSource* createNew(UsageEnvironment& env,
+					 FILE* fid,
+					 unsigned preferredFrameSize = 0,
+					 unsigned playTimePerFrame = 0);
+      // an alternative version of "createNew()" that's used if you already have
+      // an open file.
+
+  u_int64_t fileSize() const { return fFileSize; }
+      // 0 means zero-length, unbounded, or unknown
+
+  void seekToByteAbsolute(u_int64_t byteNumber, u_int64_t numBytesToStream = 0);
+    // if "numBytesToStream" is >0, then we limit the stream to that number of bytes, before treating it as EOF
+  void seekToByteRelative(int64_t offset, u_int64_t numBytesToStream = 0);
+  void seekToEnd(); // to force EOF handling on the next read
+
+protected:
+  ByteStreamFileSource(UsageEnvironment& env,
+		       FILE* fid,
+		       unsigned preferredFrameSize,
+		       unsigned playTimePerFrame);
+	// called only by createNew()
+
+  virtual ~ByteStreamFileSource();
+
+  static void fileReadableHandler(ByteStreamFileSource* source, int mask);
+  void doReadFromFile();
+
+private:
+  // redefined virtual functions:
+  virtual void doGetNextFrame();
+  virtual void doStopGettingFrames();
+
+protected:
+  u_int64_t fFileSize;
+
+private:
+  unsigned fPreferredFrameSize;
+  unsigned fPlayTimePerFrame;
+  Boolean fFidIsSeekable;
+  unsigned fLastPlayTime;
+  Boolean fHaveStartedReading;
+  Boolean fLimitNumBytesToStream;
+  u_int64_t fNumBytesToStream; // used iff "fLimitNumBytesToStream" is True
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/ByteStreamMemoryBufferSource.hh b/3rdparty/live555/src/liveMedia/include/ByteStreamMemoryBufferSource.hh
new file mode 100644
index 00000000..b3b0cebb
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/ByteStreamMemoryBufferSource.hh
@@ -0,0 +1,70 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A class for streaming data from a (static) memory buffer, as if it were a file.
+// C++ header
+
+#ifndef _BYTE_STREAM_MEMORY_BUFFER_SOURCE_HH
+#define _BYTE_STREAM_MEMORY_BUFFER_SOURCE_HH
+
+#ifndef _FRAMED_SOURCE_HH
+#include "FramedSource.hh"
+#endif
+
+class ByteStreamMemoryBufferSource: public FramedSource {
+public:
+  static ByteStreamMemoryBufferSource* createNew(UsageEnvironment& env,
+						 u_int8_t* buffer, u_int64_t bufferSize,
+						 Boolean deleteBufferOnClose = True,
+						 unsigned preferredFrameSize = 0,
+						 unsigned playTimePerFrame = 0);
+      // "preferredFrameSize" == 0 means 'no preference'
+      // "playTimePerFrame" is in microseconds
+
+  u_int64_t bufferSize() const { return fBufferSize; }
+
+  void seekToByteAbsolute(u_int64_t byteNumber, u_int64_t numBytesToStream = 0);
+    // if "numBytesToStream" is >0, then we limit the stream to that number of bytes, before treating it as EOF
+  void seekToByteRelative(int64_t offset, u_int64_t numBytesToStream = 0);
+
+protected:
+  ByteStreamMemoryBufferSource(UsageEnvironment& env,
+			       u_int8_t* buffer, u_int64_t bufferSize,
+			       Boolean deleteBufferOnClose,
+			       unsigned preferredFrameSize,
+			       unsigned playTimePerFrame);
+	// called only by createNew()
+
+  virtual ~ByteStreamMemoryBufferSource();
+
+private:
+  // redefined virtual functions:
+  virtual void doGetNextFrame();
+
+private:
+  u_int8_t* fBuffer;
+  u_int64_t fBufferSize;
+  u_int64_t fCurIndex;
+  Boolean fDeleteBufferOnClose;
+  unsigned fPreferredFrameSize;
+  unsigned fPlayTimePerFrame;
+  unsigned fLastPlayTime;
+  Boolean fLimitNumBytesToStream;
+  u_int64_t fNumBytesToStream; // used iff "fLimitNumBytesToStream" is True
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/ByteStreamMultiFileSource.hh b/3rdparty/live555/src/liveMedia/include/ByteStreamMultiFileSource.hh
new file mode 100644
index 00000000..9519cfcd
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/ByteStreamMultiFileSource.hh
@@ -0,0 +1,69 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A source that consists of multiple byte-stream files, read sequentially.
+// (The input is an array of file names, with a terminating 'file name' of NULL.)
+// C++ header
+
+#ifndef _BYTE_STREAM_MULTI_FILE_SOURCE_HH
+#define _BYTE_STREAM_MULTI_FILE_SOURCE_HH
+
+#ifndef _BYTE_STREAM_FILE_SOURCE_HH
+#include "ByteStreamFileSource.hh"
+#endif
+
+class ByteStreamMultiFileSource: public FramedSource {
+public:
+  static ByteStreamMultiFileSource*
+  createNew(UsageEnvironment& env, char const** fileNameArray,
+	    unsigned preferredFrameSize = 0, unsigned playTimePerFrame = 0);
+  // "fileNameArray" is a pointer to an array of (char const*) file names, with
+  // A 'file name' of NULL indicating the end of the array
+
+  Boolean haveStartedNewFile() const { return fHaveStartedNewFile; }
+  // True iff the most recently delivered frame was the first from a newly-opened file
+
+protected:
+  ByteStreamMultiFileSource(UsageEnvironment& env, char const** fileNameArray,
+			    unsigned preferredFrameSize, unsigned playTimePerFrame);
+	// called only by createNew()
+
+  virtual ~ByteStreamMultiFileSource();
+
+private:
+  // redefined virtual functions:
+  virtual void doGetNextFrame();
+
+private:
+  static void onSourceClosure(void* clientData);
+  void onSourceClosure1();
+  static void afterGettingFrame(void* clientData,
+				unsigned frameSize, unsigned numTruncatedBytes,
+                                struct timeval presentationTime,
+				unsigned durationInMicroseconds);
+
+private:
+  unsigned fPreferredFrameSize;
+  unsigned fPlayTimePerFrame;
+  unsigned fNumSources;
+  unsigned fCurrentlyReadSourceNumber;
+  Boolean fHaveStartedNewFile;
+  char const** fFileNameArray;
+  ByteStreamFileSource** fSourceArray;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/DVVideoFileServerMediaSubsession.hh b/3rdparty/live555/src/liveMedia/include/DVVideoFileServerMediaSubsession.hh
new file mode 100644
index 00000000..1e11507a
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/DVVideoFileServerMediaSubsession.hh
@@ -0,0 +1,51 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A 'ServerMediaSubsession' object that creates new, unicast, "RTPSink"s
+// on demand, from a DV video file.
+// C++ header
+
+#ifndef _DV_VIDEO_FILE_SERVER_MEDIA_SUBSESSION_HH
+#define _DV_VIDEO_FILE_SERVER_MEDIA_SUBSESSION_HH
+
+#ifndef _FILE_SERVER_MEDIA_SUBSESSION_HH
+#include "FileServerMediaSubsession.hh"
+#endif
+
+class DVVideoFileServerMediaSubsession: public FileServerMediaSubsession{
+public:
+  static DVVideoFileServerMediaSubsession*
+  createNew(UsageEnvironment& env, char const* fileName, Boolean reuseFirstSource);
+
+private:
+  DVVideoFileServerMediaSubsession(UsageEnvironment& env, char const* fileName, Boolean reuseFirstSource);
+      // called only by createNew();
+  virtual ~DVVideoFileServerMediaSubsession();
+
+private: // redefined virtual functions
+  virtual char const* getAuxSDPLine(RTPSink* rtpSink, FramedSource* inputSource);
+  virtual void seekStreamSource(FramedSource* inputSource, double& seekNPT, double streamDuration, u_int64_t& numBytes);
+  virtual void setStreamSourceDuration(FramedSource* inputSource, double streamDuration, u_int64_t& numBytes);
+  virtual FramedSource* createNewStreamSource(unsigned clientSessionId, unsigned& estBitrate);
+  virtual RTPSink* createNewRTPSink(Groupsock* rtpGroupsock, unsigned char rtpPayloadTypeIfDynamic, FramedSource* inputSource);
+  virtual float duration() const;
+
+private:
+  float fFileDuration; // in seconds
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/DVVideoRTPSink.hh b/3rdparty/live555/src/liveMedia/include/DVVideoRTPSink.hh
new file mode 100644
index 00000000..9f5a2db6
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/DVVideoRTPSink.hh
@@ -0,0 +1,57 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// RTP sink for DV video (RFC 3189)
+// (Thanks to Ben Hutchings for prototyping this.)
+// C++ header
+
+#ifndef _DV_VIDEO_RTP_SINK_HH
+#define _DV_VIDEO_RTP_SINK_HH
+
+#ifndef _VIDEO_RTP_SINK_HH
+#include "VideoRTPSink.hh"
+#endif
+#ifndef _DV_VIDEO_STREAM_FRAMER_HH
+#include "DVVideoStreamFramer.hh"
+#endif
+
+class DVVideoRTPSink: public VideoRTPSink {
+public:
+  static DVVideoRTPSink* createNew(UsageEnvironment& env, Groupsock* RTPgs, unsigned char rtpPayloadFormat);
+  char const* auxSDPLineFromFramer(DVVideoStreamFramer* framerSource);
+
+protected:
+  DVVideoRTPSink(UsageEnvironment& env, Groupsock* RTPgs, unsigned char rtpPayloadFormat);
+	// called only by createNew()
+
+  virtual ~DVVideoRTPSink();
+
+private: // redefined virtual functions:
+  virtual Boolean sourceIsCompatibleWithUs(MediaSource& source);
+  virtual void doSpecialFrameHandling(unsigned fragmentationOffset,
+                                      unsigned char* frameStart,
+                                      unsigned numBytesInFrame,
+                                      struct timeval framePresentationTime,
+                                      unsigned numRemainingBytes);
+  virtual unsigned computeOverflowForNewFrame(unsigned newFrameSize) const;
+  virtual char const* auxSDPLine();
+
+private:
+  char* fFmtpSDPLine;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/DVVideoRTPSource.hh b/3rdparty/live555/src/liveMedia/include/DVVideoRTPSource.hh
new file mode 100644
index 00000000..832d3960
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/DVVideoRTPSource.hh
@@ -0,0 +1,51 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// DV Video RTP Sources
+// C++ header
+
+#ifndef _DV_VIDEO_RTP_SOURCE_HH
+#define _DV_VIDEO_RTP_SOURCE_HH
+
+#ifndef _MULTI_FRAMED_RTP_SOURCE_HH
+#include "MultiFramedRTPSource.hh"
+#endif
+
+class DVVideoRTPSource: public MultiFramedRTPSource {
+public:
+  static DVVideoRTPSource*
+  createNew(UsageEnvironment& env, Groupsock* RTPgs,
+	    unsigned char rtpPayloadFormat,
+	    unsigned rtpTimestampFrequency);
+
+protected:
+  virtual ~DVVideoRTPSource();
+
+private:
+  DVVideoRTPSource(UsageEnvironment& env, Groupsock* RTPgs,
+		   unsigned char rtpPayloadFormat,
+		   unsigned rtpTimestampFrequency);
+      // called only by createNew()
+
+private:
+  // redefined virtual functions:
+  virtual Boolean processSpecialHeader(BufferedPacket* packet,
+                                       unsigned& resultSpecialHeaderSize);
+  virtual char const* MIMEtype() const;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/DVVideoStreamFramer.hh b/3rdparty/live555/src/liveMedia/include/DVVideoStreamFramer.hh
new file mode 100644
index 00000000..adfdc42b
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/DVVideoStreamFramer.hh
@@ -0,0 +1,72 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A filter that parses a DV input stream into DV frames to deliver to the downstream object
+// C++ header
+
+#ifndef _DV_VIDEO_STREAM_FRAMER_HH
+#define _DV_VIDEO_STREAM_FRAMER_HH
+
+#ifndef _FRAMED_FILTER_HH
+#include "FramedFilter.hh"
+#endif
+
+#define DV_DIF_BLOCK_SIZE 80
+#define DV_NUM_BLOCKS_PER_SEQUENCE 150
+#define DV_SAVED_INITIAL_BLOCKS_SIZE ((DV_NUM_BLOCKS_PER_SEQUENCE+6-1)*DV_DIF_BLOCK_SIZE)
+    /* enough data to ensure that it contains an intact 6-block header (which occurs at the start of a 150-block sequence) */
+
+class DVVideoStreamFramer: public FramedFilter {
+public:
+  static DVVideoStreamFramer*
+  createNew(UsageEnvironment& env, FramedSource* inputSource,
+	    Boolean sourceIsSeekable = False, Boolean leavePresentationTimesUnmodified = False);
+      // Set "sourceIsSeekable" to True if the input source is a seekable object (e.g. a file), and the server that uses us
+      // does a seek-to-zero on the source before reading from it.  (Our RTSP server implementation does this.)
+  char const* profileName();
+  Boolean getFrameParameters(unsigned& frameSize/*bytes*/, double& frameDuration/*microseconds*/);
+
+protected:
+  DVVideoStreamFramer(UsageEnvironment& env, FramedSource* inputSource,
+		      Boolean sourceIsSeekable, Boolean leavePresentationTimesUnmodified);
+      // called only by createNew(), or by subclass constructors
+  virtual ~DVVideoStreamFramer();
+
+protected:
+  // redefined virtual functions:
+  virtual Boolean isDVVideoStreamFramer() const;
+  virtual void doGetNextFrame();
+
+protected:
+  void getAndDeliverData(); // used to implement "doGetNextFrame()"
+  static void afterGettingFrame(void* clientData, unsigned frameSize,
+                                unsigned numTruncatedBytes,
+                                struct timeval presentationTime,
+                                unsigned durationInMicroseconds);
+  void afterGettingFrame(unsigned frameSize, unsigned numTruncatedBytes, struct timeval presentationTime);
+  void getProfile();
+
+protected:
+  Boolean fLeavePresentationTimesUnmodified;
+  void const* fOurProfile;
+  struct timeval fNextFramePresentationTime;
+  unsigned char fSavedInitialBlocks[DV_SAVED_INITIAL_BLOCKS_SIZE];
+  char fInitialBlocksPresent;
+  Boolean fSourceIsSeekable;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/DeviceSource.hh b/3rdparty/live555/src/liveMedia/include/DeviceSource.hh
new file mode 100644
index 00000000..c41bef7b
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/DeviceSource.hh
@@ -0,0 +1,66 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A template for a MediaSource encapsulating an audio/video input device
+// 
+// NOTE: Sections of this code labeled "%%% TO BE WRITTEN %%%" are incomplete, and needto be written by the programmer
+// (depending on the features of the particulardevice).
+// C++ header
+
+#ifndef _DEVICE_SOURCE_HH
+#define _DEVICE_SOURCE_HH
+
+#ifndef _FRAMED_SOURCE_HH
+#include "FramedSource.hh"
+#endif
+
+// The following class can be used to define specific encoder parameters
+class DeviceParameters {
+  //%%% TO BE WRITTEN %%%
+};
+
+class DeviceSource: public FramedSource {
+public:
+  static DeviceSource* createNew(UsageEnvironment& env,
+				 DeviceParameters params);
+
+public:
+  static EventTriggerId eventTriggerId;
+  // Note that this is defined here to be a static class variable, because this code is intended to illustrate how to
+  // encapsulate a *single* device - not a set of devices.
+  // You can, however, redefine this to be a non-static member variable.
+
+protected:
+  DeviceSource(UsageEnvironment& env, DeviceParameters params);
+  // called only by createNew(), or by subclass constructors
+  virtual ~DeviceSource();
+
+private:
+  // redefined virtual functions:
+  virtual void doGetNextFrame();
+  //virtual void doStopGettingFrames(); // optional
+
+private:
+  static void deliverFrame0(void* clientData);
+  void deliverFrame();
+
+private:
+  static unsigned referenceCount; // used to count how many instances of this class currently exist
+  DeviceParameters fParams;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/DigestAuthentication.hh b/3rdparty/live555/src/liveMedia/include/DigestAuthentication.hh
new file mode 100644
index 00000000..1b637b99
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/DigestAuthentication.hh
@@ -0,0 +1,75 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A class used for digest authentication.
+// C++ header
+
+#ifndef _DIGEST_AUTHENTICATION_HH
+#define _DIGEST_AUTHENTICATION_HH
+
+#ifndef _BOOLEAN_HH
+#include <Boolean.hh>
+#endif
+
+// A class used for digest authentication.
+// The "realm", and "nonce" fields are supplied by the server
+// (in a "401 Unauthorized" response).
+// The "username" and "password" fields are supplied by the client.
+class Authenticator {
+public:
+  Authenticator();
+  Authenticator(char const* username, char const* password, Boolean passwordIsMD5 = False);
+      // If "passwordIsMD5" is True, then "password" is actually the value computed
+      // by md5(<username>:<realm>:<actual-password>)
+  Authenticator(const Authenticator& orig);
+  Authenticator& operator=(const Authenticator& rightSide);
+  Boolean operator<(const Authenticator* rightSide);
+  virtual ~Authenticator();
+
+  void reset();
+  void setRealmAndNonce(char const* realm, char const* nonce);
+  void setRealmAndRandomNonce(char const* realm);
+      // as above, except that the nonce is created randomly.
+      // (This is used by servers.)
+  void setUsernameAndPassword(char const* username, char const* password, Boolean passwordIsMD5 = False);
+      // If "passwordIsMD5" is True, then "password" is actually the value computed
+      // by md5(<username>:<realm>:<actual-password>)
+
+  char const* realm() const { return fRealm; }
+  char const* nonce() const { return fNonce; }
+  char const* username() const { return fUsername; }
+  char const* password() const { return fPassword; }
+
+  char const* computeDigestResponse(char const* cmd, char const* url) const;
+      // The returned string from this function must later be freed by calling:
+  void reclaimDigestResponse(char const* responseStr) const;
+
+private:
+  void resetRealmAndNonce();
+  void resetUsernameAndPassword();
+  void assignRealmAndNonce(char const* realm, char const* nonce);
+  void assignUsernameAndPassword(char const* username, char const* password, Boolean passwordIsMD5);
+  void assign(char const* realm, char const* nonce,
+	      char const* username, char const* password, Boolean passwordIsMD5);
+
+private:
+  char* fRealm; char* fNonce;
+  char* fUsername; char* fPassword;
+  Boolean fPasswordIsMD5;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/FileServerMediaSubsession.hh b/3rdparty/live555/src/liveMedia/include/FileServerMediaSubsession.hh
new file mode 100644
index 00000000..963273e2
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/FileServerMediaSubsession.hh
@@ -0,0 +1,43 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A 'ServerMediaSubsession' object that creates new, unicast, "RTPSink"s
+// on demand, from a file.
+// C++ header
+
+#ifndef _FILE_SERVER_MEDIA_SUBSESSION_HH
+#define _FILE_SERVER_MEDIA_SUBSESSION_HH
+
+#ifndef _SERVER_MEDIA_SESSION_HH
+#include "ServerMediaSession.hh"
+#endif
+#ifndef _ON_DEMAND_SERVER_MEDIA_SUBSESSION_HH
+#include "OnDemandServerMediaSubsession.hh"
+#endif
+
+class FileServerMediaSubsession: public OnDemandServerMediaSubsession {
+protected: // we're a virtual base class
+  FileServerMediaSubsession(UsageEnvironment& env, char const* fileName,
+			    Boolean reuseFirstSource);
+  virtual ~FileServerMediaSubsession();
+
+protected:
+  char const* fFileName;
+  u_int64_t fFileSize; // if known
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/FileSink.hh b/3rdparty/live555/src/liveMedia/include/FileSink.hh
new file mode 100644
index 00000000..19fe7968
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/FileSink.hh
@@ -0,0 +1,71 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// File Sinks
+// C++ header
+
+#ifndef _FILE_SINK_HH
+#define _FILE_SINK_HH
+
+#ifndef _MEDIA_SINK_HH
+#include "MediaSink.hh"
+#endif
+
+class FileSink: public MediaSink {
+public:
+  static FileSink* createNew(UsageEnvironment& env, char const* fileName,
+			     unsigned bufferSize = 20000,
+			     Boolean oneFilePerFrame = False);
+  // "bufferSize" should be at least as large as the largest expected
+  //   input frame.
+  // "oneFilePerFrame" - if True - specifies that each input frame will
+  //   be written to a separate file (using the presentation time as a
+  //   file name suffix).  The default behavior ("oneFilePerFrame" == False)
+  //   is to output all incoming data into a single file.
+
+  virtual void addData(unsigned char const* data, unsigned dataSize,
+		       struct timeval presentationTime);
+  // (Available in case a client wants to add extra data to the output file)
+
+protected:
+  FileSink(UsageEnvironment& env, FILE* fid, unsigned bufferSize,
+	   char const* perFrameFileNamePrefix);
+      // called only by createNew()
+  virtual ~FileSink();
+
+protected: // redefined virtual functions:
+  virtual Boolean continuePlaying();
+
+protected:
+  static void afterGettingFrame(void* clientData, unsigned frameSize,
+				unsigned numTruncatedBytes,
+				struct timeval presentationTime,
+				unsigned durationInMicroseconds);
+  virtual void afterGettingFrame(unsigned frameSize,
+				 unsigned numTruncatedBytes,
+				 struct timeval presentationTime);
+
+  FILE* fOutFid;
+  unsigned char* fBuffer;
+  unsigned fBufferSize;
+  char* fPerFrameFileNamePrefix; // used if "oneFilePerFrame" is True
+  char* fPerFrameFileNameBuffer; // used if "oneFilePerFrame" is True
+  struct timeval fPrevPresentationTime;
+  unsigned fSamePresentationTimeCounter;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/FramedFileSource.hh b/3rdparty/live555/src/liveMedia/include/FramedFileSource.hh
new file mode 100644
index 00000000..2804f7c2
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/FramedFileSource.hh
@@ -0,0 +1,37 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// Framed File Sources
+// C++ header
+
+#ifndef _FRAMED_FILE_SOURCE_HH
+#define _FRAMED_FILE_SOURCE_HH
+
+#ifndef _FRAMED_SOURCE_HH
+#include "FramedSource.hh"
+#endif
+
+class FramedFileSource: public FramedSource {
+protected:
+  FramedFileSource(UsageEnvironment& env, FILE* fid); // abstract base class
+  virtual ~FramedFileSource();
+
+protected:
+  FILE* fFid;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/FramedFilter.hh b/3rdparty/live555/src/liveMedia/include/FramedFilter.hh
new file mode 100644
index 00000000..9d77c675
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/FramedFilter.hh
@@ -0,0 +1,52 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// Framed Filters
+// C++ header
+
+#ifndef _FRAMED_FILTER_HH
+#define _FRAMED_FILTER_HH
+
+#ifndef _FRAMED_SOURCE_HH
+#include "FramedSource.hh"
+#endif
+
+class FramedFilter: public FramedSource {
+public:
+  FramedSource* inputSource() const { return fInputSource; }
+
+  void reassignInputSource(FramedSource* newInputSource) { fInputSource = newInputSource; }
+
+  // Call before destruction if you want to prevent the destructor from closing the input source
+  void detachInputSource();
+
+protected:
+  FramedFilter(UsageEnvironment& env, FramedSource* inputSource);
+	 // abstract base class
+  virtual ~FramedFilter();
+
+protected:
+  // Redefined virtual functions (with default 'null' implementations):
+  virtual char const* MIMEtype() const;
+  virtual void getAttributes() const;
+  virtual void doStopGettingFrames();
+
+protected:
+  FramedSource* fInputSource;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/FramedSource.hh b/3rdparty/live555/src/liveMedia/include/FramedSource.hh
new file mode 100644
index 00000000..8d78eba3
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/FramedSource.hh
@@ -0,0 +1,95 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// Framed Sources
+// C++ header
+
+#ifndef _FRAMED_SOURCE_HH
+#define _FRAMED_SOURCE_HH
+
+#ifndef _NET_COMMON_H
+#include "NetCommon.h"
+#endif
+#ifndef _MEDIA_SOURCE_HH
+#include "MediaSource.hh"
+#endif
+
+class FramedSource: public MediaSource {
+public:
+  static Boolean lookupByName(UsageEnvironment& env, char const* sourceName,
+			      FramedSource*& resultSource);
+
+  typedef void (afterGettingFunc)(void* clientData, unsigned frameSize,
+				  unsigned numTruncatedBytes,
+				  struct timeval presentationTime,
+				  unsigned durationInMicroseconds);
+  typedef void (onCloseFunc)(void* clientData);
+  void getNextFrame(unsigned char* to, unsigned maxSize,
+		    afterGettingFunc* afterGettingFunc,
+		    void* afterGettingClientData,
+		    onCloseFunc* onCloseFunc,
+		    void* onCloseClientData);
+
+  static void handleClosure(void* clientData);
+  void handleClosure();
+      // This should be called (on ourself) if the source is discovered
+      // to be closed (i.e., no longer readable)
+
+  void stopGettingFrames();
+
+  virtual unsigned maxFrameSize() const;
+      // size of the largest possible frame that we may serve, or 0
+      // if no such maximum is known (default)
+
+  virtual void doGetNextFrame() = 0;
+      // called by getNextFrame()
+
+  Boolean isCurrentlyAwaitingData() const {return fIsCurrentlyAwaitingData;}
+
+  static void afterGetting(FramedSource* source);
+      // doGetNextFrame() should arrange for this to be called after the
+      // frame has been read (*iff* it is read successfully)
+
+protected:
+  FramedSource(UsageEnvironment& env); // abstract base class
+  virtual ~FramedSource();
+
+  virtual void doStopGettingFrames();
+
+protected:
+  // The following variables are typically accessed/set by doGetNextFrame()
+  unsigned char* fTo; // in
+  unsigned fMaxSize; // in
+  unsigned fFrameSize; // out
+  unsigned fNumTruncatedBytes; // out
+  struct timeval fPresentationTime; // out
+  unsigned fDurationInMicroseconds; // out
+
+private:
+  // redefined virtual functions:
+  virtual Boolean isFramedSource() const;
+
+private:
+  afterGettingFunc* fAfterGettingFunc;
+  void* fAfterGettingClientData;
+  onCloseFunc* fOnCloseFunc;
+  void* fOnCloseClientData;
+
+  Boolean fIsCurrentlyAwaitingData;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/GSMAudioRTPSink.hh b/3rdparty/live555/src/liveMedia/include/GSMAudioRTPSink.hh
new file mode 100644
index 00000000..8c137174
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/GSMAudioRTPSink.hh
@@ -0,0 +1,44 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// RTP sink for GSM audio
+// C++ header
+
+#ifndef _GSM_AUDIO_RTP_SINK_HH
+#define _GSM_AUDIO_RTP_SINK_HH
+
+#ifndef _AUDIO_RTP_SINK_HH
+#include "AudioRTPSink.hh"
+#endif
+
+class GSMAudioRTPSink: public AudioRTPSink {
+public:
+  static GSMAudioRTPSink* createNew(UsageEnvironment& env, Groupsock* RTPgs);
+
+protected:
+  GSMAudioRTPSink(UsageEnvironment& env, Groupsock* RTPgs);
+	// called only by createNew()
+
+  virtual ~GSMAudioRTPSink();
+
+private: // redefined virtual functions:
+  virtual
+  Boolean frameCanAppearAfterPacketStart(unsigned char const* frameStart,
+					 unsigned numBytesInFrame) const;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/GenericMediaServer.hh b/3rdparty/live555/src/liveMedia/include/GenericMediaServer.hh
new file mode 100644
index 00000000..583abdb1
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/GenericMediaServer.hh
@@ -0,0 +1,222 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A generic media server class, used to implement a RTSP server, and any other server that uses
+//  "ServerMediaSession" objects to describe media to be served.
+// C++ header
+
+#ifndef _GENERIC_MEDIA_SERVER_HH
+#define _GENERIC_MEDIA_SERVER_HH
+
+#ifndef _MEDIA_HH
+#include "Media.hh"
+#endif
+#ifndef _SERVER_MEDIA_SESSION_HH
+#include "ServerMediaSession.hh"
+#endif
+
+#ifndef REQUEST_BUFFER_SIZE
+#define REQUEST_BUFFER_SIZE 20000 // for incoming requests
+#endif
+#ifndef RESPONSE_BUFFER_SIZE
+#define RESPONSE_BUFFER_SIZE 20000
+#endif
+
+// Typedef for a handler function that gets called when "lookupServerMediaSession()"
+// (defined below) completes:
+typedef void lookupServerMediaSessionCompletionFunc(void* clientData,
+						    ServerMediaSession* sessionLookedUp);
+
+class GenericMediaServer: public Medium {
+public:
+  virtual void addServerMediaSession(ServerMediaSession* serverMediaSession);
+
+  virtual void lookupServerMediaSession(char const* streamName,
+					lookupServerMediaSessionCompletionFunc* completionFunc,
+					void* completionClientData,
+					Boolean isFirstLookupInSession = True);
+      // Note: This is a virtual function, so can be reimplemented by subclasses.
+  void lookupServerMediaSession(char const* streamName,
+				void (GenericMediaServer::*memberFunc)(ServerMediaSession*));
+      // Special case of "lookupServerMediaSession()" where the 'completion function' is a
+      // member function of "GenericMediaServer" (and the 'completion client data' is "this".)
+
+  void removeServerMediaSession(ServerMediaSession* serverMediaSession);
+      // Removes the "ServerMediaSession" object from our lookup table, so it will no longer be accessible by new clients.
+      // (However, any *existing* client sessions that use this "ServerMediaSession" object will continue streaming.
+      //  The "ServerMediaSession" object will not get deleted until all of these client sessions have closed.)
+      // (To both delete the "ServerMediaSession" object *and* close all client sessions that use it,
+      //  call "deleteServerMediaSession(serverMediaSession)" instead.)
+  virtual void removeServerMediaSession(char const* streamName);
+     // ditto
+
+  void closeAllClientSessionsForServerMediaSession(ServerMediaSession* serverMediaSession);
+      // Closes (from the server) all client sessions that are currently using this "ServerMediaSession" object.
+      // Note, however, that the "ServerMediaSession" object remains accessible by new clients.
+  virtual void closeAllClientSessionsForServerMediaSession(char const* streamName);
+     // ditto
+
+  void deleteServerMediaSession(ServerMediaSession* serverMediaSession);
+      // Equivalent to:
+      //     "closeAllClientSessionsForServerMediaSession(serverMediaSession); removeServerMediaSession(serverMediaSession);"
+  virtual void deleteServerMediaSession(char const* streamName);
+      // Equivalent to:
+      //     "closeAllClientSessionsForServerMediaSession(streamName); removeServerMediaSession(streamName);
+
+  unsigned numClientSessions() const { return fClientSessions->numEntries(); }
+
+protected:
+  GenericMediaServer(UsageEnvironment& env, int ourSocketIPv4, int ourSocketIPv6, Port ourPort,
+		     unsigned reclamationSeconds);
+      // If "reclamationSeconds" > 0, then the "ClientSession" state for each client will get
+      // reclaimed if no activity from the client is detected in at least "reclamationSeconds".
+  // we're an abstract base class
+  virtual ~GenericMediaServer();
+  void cleanup(); // MUST be called in the destructor of any subclass of us
+
+  static int setUpOurSocket(UsageEnvironment& env, Port& ourPort, int domain);
+
+  static void incomingConnectionHandlerIPv4(void*, int /*mask*/);
+  static void incomingConnectionHandlerIPv6(void*, int /*mask*/);
+  void incomingConnectionHandlerIPv4();
+  void incomingConnectionHandlerIPv6();
+  void incomingConnectionHandlerOnSocket(int serverSocket);
+
+  void setTLSFileNames(char const* certFileName, char const* privKeyFileName);
+
+public: // should be protected, but some old compilers complain otherwise
+  // The state of a TCP connection used by a client:
+  class ClientConnection {
+  protected:
+    ClientConnection(GenericMediaServer& ourServer,
+		     int clientSocket, struct sockaddr_storage const& clientAddr,
+		     Boolean useTLS);
+    virtual ~ClientConnection();
+
+    UsageEnvironment& envir() { return fOurServer.envir(); }
+    void closeSockets();
+
+    static void incomingRequestHandler(void*, int /*mask*/);
+    void incomingRequestHandler();
+    virtual void handleRequestBytes(int newBytesRead) = 0;
+    void resetRequestBuffer();
+
+  protected:
+    friend class GenericMediaServer;
+    friend class ClientSession;
+    friend class RTSPServer; // needed to make some broken Windows compilers work; remove this in the future when we end support for Windows
+    GenericMediaServer& fOurServer;
+    int fOurSocket;
+    struct sockaddr_storage fClientAddr;
+    unsigned char fRequestBuffer[REQUEST_BUFFER_SIZE];
+    unsigned char fResponseBuffer[RESPONSE_BUFFER_SIZE];
+    unsigned fRequestBytesAlreadySeen, fRequestBufferBytesLeft;
+
+    // Optional support for TLS:
+    ServerTLSState fTLS;
+  };
+
+  // The state of an individual client session (using one or more sequential TCP connections) handled by a server:
+  class ClientSession {
+  protected:
+    ClientSession(GenericMediaServer& ourServer, u_int32_t sessionId);
+    virtual ~ClientSession();
+
+    UsageEnvironment& envir() { return fOurServer.envir(); }
+    void noteLiveness();
+    static void noteClientLiveness(ClientSession* clientSession);
+    static void livenessTimeoutTask(ClientSession* clientSession);
+
+  protected:
+    friend class GenericMediaServer;
+    friend class ClientConnection;
+    GenericMediaServer& fOurServer;
+    u_int32_t fOurSessionId;
+    ServerMediaSession* fOurServerMediaSession;
+    TaskToken fLivenessCheckTask;
+  };
+
+protected:
+  virtual ClientConnection* createNewClientConnection(int clientSocket, struct sockaddr_storage const& clientAddr) = 0;
+  virtual ClientSession* createNewClientSession(u_int32_t sessionId) = 0;
+
+  ClientSession* createNewClientSessionWithId();
+      // Generates a new (unused) random session id, and calls the "createNewClientSession()"
+      // virtual function with this session id as parameter.
+
+  // Lookup a "ClientSession" object by sessionId (integer, and string):
+  ClientSession* lookupClientSession(u_int32_t sessionId);
+  ClientSession* lookupClientSession(char const* sessionIdStr);
+
+  // An iterator over our "ServerMediaSession" objects:
+  class ServerMediaSessionIterator {
+  public:
+    ServerMediaSessionIterator(GenericMediaServer& server);
+    virtual ~ServerMediaSessionIterator();
+    ServerMediaSession* next();
+  private:
+    HashTable::Iterator* fOurIterator;
+  };
+
+  // The basic, synchronous "ServerMediaSession" lookup operation; only for subclasses:
+  ServerMediaSession* getServerMediaSession(char const* streamName);
+  
+protected:
+  friend class ClientConnection;
+  friend class ClientSession;	
+  friend class ServerMediaSessionIterator;
+  int fServerSocketIPv4, fServerSocketIPv6;
+  Port fServerPort;
+  unsigned fReclamationSeconds;
+
+private:
+  HashTable* fServerMediaSessions; // maps 'stream name' strings to "ServerMediaSession" objects
+  HashTable* fClientConnections; // the "ClientConnection" objects that we're using
+  HashTable* fClientSessions; // maps 'session id' strings to "ClientSession" objects
+  u_int32_t fPreviousClientSessionId;
+
+  char const* fTLSCertificateFileName;
+  char const* fTLSPrivateKeyFileName;
+};
+
+// A data structure used for optional user/password authentication:
+
+class UserAuthenticationDatabase {
+public:
+  UserAuthenticationDatabase(char const* realm = NULL,
+			     Boolean passwordsAreMD5 = False);
+    // If "passwordsAreMD5" is True, then each password stored into, or removed from,
+    // the database is actually the value computed
+    // by md5(<username>:<realm>:<actual-password>)
+  virtual ~UserAuthenticationDatabase();
+
+  virtual void addUserRecord(char const* username, char const* password);
+  virtual void removeUserRecord(char const* username);
+
+  virtual char const* lookupPassword(char const* username);
+      // returns NULL if the user name was not present
+
+  char const* realm() { return fRealm; }
+  Boolean passwordsAreMD5() { return fPasswordsAreMD5; }
+
+protected:
+  HashTable* fTable;
+  char* fRealm;
+  Boolean fPasswordsAreMD5;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/H261VideoRTPSource.hh b/3rdparty/live555/src/liveMedia/include/H261VideoRTPSource.hh
new file mode 100644
index 00000000..3a44d96c
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/H261VideoRTPSource.hh
@@ -0,0 +1,56 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// H.261 Video RTP Sources
+// C++ header
+
+#ifndef _H261_VIDEO_RTP_SOURCE_HH
+#define _H261_VIDEO_RTP_SOURCE_HH
+
+#ifndef _MULTI_FRAMED_RTP_SOURCE_HH
+#include "MultiFramedRTPSource.hh"
+#endif
+
+class H261VideoRTPSource: public MultiFramedRTPSource {
+public:
+  static H261VideoRTPSource*
+  createNew(UsageEnvironment& env, Groupsock* RTPgs,
+	    unsigned char rtpPayloadFormat = 31,
+	    unsigned rtpTimestampFrequency = 90000);
+
+  u_int32_t lastSpecialHeader() const {return fLastSpecialHeader;}
+
+protected:
+  virtual ~H261VideoRTPSource();
+
+private:
+  H261VideoRTPSource(UsageEnvironment& env, Groupsock* RTPgs,
+			 unsigned char rtpPayloadFormat,
+			 unsigned rtpTimestampFrequency);
+      // called only by createNew()
+
+private:
+  // redefined virtual functions:
+  virtual Boolean processSpecialHeader(BufferedPacket* packet,
+                                       unsigned& resultSpecialHeaderSize);
+  virtual char const* MIMEtype() const;
+
+private:
+  u_int32_t fLastSpecialHeader;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/H263plusVideoFileServerMediaSubsession.hh b/3rdparty/live555/src/liveMedia/include/H263plusVideoFileServerMediaSubsession.hh
new file mode 100644
index 00000000..1e94fa9d
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/H263plusVideoFileServerMediaSubsession.hh
@@ -0,0 +1,48 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A 'ServerMediaSubsession' object that creates new, unicast, "RTPSink"s
+// on demand, from a H.263 video file.
+// C++ header
+
+#ifndef _H263PLUS_VIDEO_FILE_SERVER_MEDIA_SUBSESSION_HH
+#define _H263PLUS_VIDEO_FILE_SERVER_MEDIA_SUBSESSION_HH
+
+#ifndef _FILE_SERVER_MEDIA_SUBSESSION_HH
+#include "FileServerMediaSubsession.hh"
+#endif
+
+class H263plusVideoFileServerMediaSubsession: public FileServerMediaSubsession{
+public:
+  static H263plusVideoFileServerMediaSubsession*
+  createNew(UsageEnvironment& env, char const* fileName, Boolean reuseFirstSource);
+
+private:
+  H263plusVideoFileServerMediaSubsession(UsageEnvironment& env,
+					 char const* fileName, Boolean reuseFirstSource);
+      // called only by createNew();
+  virtual ~H263plusVideoFileServerMediaSubsession();
+
+private: // redefined virtual functions
+  virtual FramedSource* createNewStreamSource(unsigned clientSessionId,
+					      unsigned& estBitrate);
+  virtual RTPSink* createNewRTPSink(Groupsock* rtpGroupsock,
+                                    unsigned char rtpPayloadTypeIfDynamic,
+				                    FramedSource* inputSource);
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/H263plusVideoRTPSink.hh b/3rdparty/live555/src/liveMedia/include/H263plusVideoRTPSink.hh
new file mode 100644
index 00000000..5b6b216c
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/H263plusVideoRTPSink.hh
@@ -0,0 +1,54 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// RTP sink for H.263+ video (RFC 4629)
+// C++ header
+
+#ifndef _H263_PLUS_VIDEO_RTP_SINK_HH
+#define _H263_PLUS_VIDEO_RTP_SINK_HH
+
+#ifndef _VIDEO_RTP_SINK_HH
+#include "VideoRTPSink.hh"
+#endif
+
+class H263plusVideoRTPSink: public VideoRTPSink {
+public:
+  static H263plusVideoRTPSink* createNew(UsageEnvironment& env, Groupsock* RTPgs,
+					 unsigned char rtpPayloadFormat,
+					 u_int32_t rtpTimestampFrequency = 90000);
+
+protected:
+  H263plusVideoRTPSink(UsageEnvironment& env, Groupsock* RTPgs,
+		       unsigned char rtpPayloadFormat,
+		       u_int32_t rtpTimestampFrequency);
+	// called only by createNew()
+
+  virtual ~H263plusVideoRTPSink();
+
+private: // redefined virtual functions:
+  virtual void doSpecialFrameHandling(unsigned fragmentationOffset,
+                                      unsigned char* frameStart,
+                                      unsigned numBytesInFrame,
+                                      struct timeval framePresentationTime,
+                                      unsigned numRemainingBytes);
+  virtual
+  Boolean frameCanAppearAfterPacketStart(unsigned char const* frameStart,
+					 unsigned numBytesInFrame) const;
+  virtual unsigned specialHeaderSize() const;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/H263plusVideoRTPSource.hh b/3rdparty/live555/src/liveMedia/include/H263plusVideoRTPSource.hh
new file mode 100644
index 00000000..7ddbef03
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/H263plusVideoRTPSource.hh
@@ -0,0 +1,60 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// H.263+ Video RTP Sources
+// C++ header
+
+#ifndef _H263_PLUS_VIDEO_RTP_SOURCE_HH
+#define _H263_PLUS_VIDEO_RTP_SOURCE_HH
+
+#ifndef _MULTI_FRAMED_RTP_SOURCE_HH
+#include "MultiFramedRTPSource.hh"
+#endif
+
+#define SPECIAL_HEADER_BUFFER_SIZE 1000
+
+class H263plusVideoRTPSource: public MultiFramedRTPSource {
+public:
+  static H263plusVideoRTPSource*
+  createNew(UsageEnvironment& env, Groupsock* RTPgs,
+	    unsigned char rtpPayloadFormat,
+	    unsigned rtpTimestampFrequency = 90000);
+
+  // A data structure that stores copies of the special header bytes
+  // from the most recent frame's RTP packets:
+  unsigned char fNumSpecialHeaders;
+  unsigned fSpecialHeaderBytesLength;
+  unsigned char fSpecialHeaderBytes[SPECIAL_HEADER_BUFFER_SIZE];
+  unsigned fPacketSizes[256];
+
+protected:
+  virtual ~H263plusVideoRTPSource();
+
+private:
+  H263plusVideoRTPSource(UsageEnvironment& env, Groupsock* RTPgs,
+			 unsigned char rtpPayloadFormat,
+			 unsigned rtpTimestampFrequency);
+      // called only by createNew()
+
+private:
+  // redefined virtual functions:
+  virtual Boolean processSpecialHeader(BufferedPacket* packet,
+                                       unsigned& resultSpecialHeaderSize);
+  virtual char const* MIMEtype() const;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/H263plusVideoStreamFramer.hh b/3rdparty/live555/src/liveMedia/include/H263plusVideoStreamFramer.hh
new file mode 100644
index 00000000..18b3e8f4
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/H263plusVideoStreamFramer.hh
@@ -0,0 +1,64 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A filter that breaks up an H263 video elementary stream into frames.
+// Author Benhard Feiten
+
+#ifndef _H263PLUS_VIDEO_STREAM_FRAMER_HH
+#define _H263PLUS_VIDEO_STREAM_FRAMER_HH
+
+#ifndef _FRAMED_FILTER_HH
+#include "FramedFilter.hh"
+#endif
+
+
+class H263plusVideoStreamFramer: public FramedFilter {
+public:
+
+  static H263plusVideoStreamFramer* createNew(UsageEnvironment& env, FramedSource* inputSource);
+
+  Boolean& pictureEndMarker() { return fPictureEndMarker; }    // a hack for implementing the RTP 'M' bit
+
+protected:
+  // Constructor called only by createNew(), or by subclass constructors
+  H263plusVideoStreamFramer(UsageEnvironment& env,
+			                FramedSource* inputSource,
+			                Boolean createParser = True);
+  virtual ~H263plusVideoStreamFramer();
+
+
+public:
+  static void continueReadProcessing(void* clientData,
+				     unsigned char* ptr, unsigned size,
+				     struct timeval presentationTime);
+  void continueReadProcessing();
+
+private:
+  virtual void doGetNextFrame();
+  virtual Boolean isH263plusVideoStreamFramer() const;
+
+protected:
+  double   fFrameRate;
+  unsigned fPictureCount; // hack used to implement doGetNextFrame() ??
+  Boolean  fPictureEndMarker;
+
+private:
+  class H263plusVideoStreamParser* fParser;
+  struct timeval fPresentationTimeBase;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/H264VideoFileServerMediaSubsession.hh b/3rdparty/live555/src/liveMedia/include/H264VideoFileServerMediaSubsession.hh
new file mode 100644
index 00000000..055fdc02
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/H264VideoFileServerMediaSubsession.hh
@@ -0,0 +1,61 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A 'ServerMediaSubsession' object that creates new, unicast, "RTPSink"s
+// on demand, from a H264 Elementary Stream video file.
+// C++ header
+
+#ifndef _H264_VIDEO_FILE_SERVER_MEDIA_SUBSESSION_HH
+#define _H264_VIDEO_FILE_SERVER_MEDIA_SUBSESSION_HH
+
+#ifndef _FILE_SERVER_MEDIA_SUBSESSION_HH
+#include "FileServerMediaSubsession.hh"
+#endif
+
+class H264VideoFileServerMediaSubsession: public FileServerMediaSubsession {
+public:
+  static H264VideoFileServerMediaSubsession*
+  createNew(UsageEnvironment& env, char const* fileName, Boolean reuseFirstSource);
+
+  // Used to implement "getAuxSDPLine()":
+  void checkForAuxSDPLine1();
+  void afterPlayingDummy1();
+
+protected:
+  H264VideoFileServerMediaSubsession(UsageEnvironment& env,
+				      char const* fileName, Boolean reuseFirstSource);
+      // called only by createNew();
+  virtual ~H264VideoFileServerMediaSubsession();
+
+  void setDoneFlag() { fDoneFlag = ~0; }
+
+protected: // redefined virtual functions
+  virtual char const* getAuxSDPLine(RTPSink* rtpSink,
+				    FramedSource* inputSource);
+  virtual FramedSource* createNewStreamSource(unsigned clientSessionId,
+					      unsigned& estBitrate);
+  virtual RTPSink* createNewRTPSink(Groupsock* rtpGroupsock,
+                                    unsigned char rtpPayloadTypeIfDynamic,
+				    FramedSource* inputSource);
+
+private:
+  char* fAuxSDPLine;
+  char fDoneFlag; // used when setting up "fAuxSDPLine"
+  RTPSink* fDummyRTPSink; // ditto
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/H264VideoFileSink.hh b/3rdparty/live555/src/liveMedia/include/H264VideoFileSink.hh
new file mode 100644
index 00000000..e85a2633
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/H264VideoFileSink.hh
@@ -0,0 +1,47 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// H.264 Video File Sinks
+// C++ header
+
+#ifndef _H264_VIDEO_FILE_SINK_HH
+#define _H264_VIDEO_FILE_SINK_HH
+
+#ifndef _H264_OR_5_VIDEO_FILE_SINK_HH
+#include "H264or5VideoFileSink.hh"
+#endif
+
+class H264VideoFileSink: public H264or5VideoFileSink {
+public:
+  static H264VideoFileSink* createNew(UsageEnvironment& env, char const* fileName,
+				      char const* sPropParameterSetsStr = NULL,
+      // "sPropParameterSetsStr" is an optional 'SDP format' string
+      // (comma-separated Base64-encoded) representing SPS and/or PPS NAL-units
+      // to prepend to the output
+				      unsigned bufferSize = 100000,
+				      Boolean oneFilePerFrame = False);
+      // See "FileSink.hh" for a description of these parameters.
+
+protected:
+  H264VideoFileSink(UsageEnvironment& env, FILE* fid,
+		    char const* sPropParameterSetsStr,
+		    unsigned bufferSize, char const* perFrameFileNamePrefix);
+      // called only by createNew()
+  virtual ~H264VideoFileSink();
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/H264VideoRTPSink.hh b/3rdparty/live555/src/liveMedia/include/H264VideoRTPSink.hh
new file mode 100644
index 00000000..f5c6057a
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/H264VideoRTPSink.hh
@@ -0,0 +1,59 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// RTP sink for H.264 video (RFC 3984)
+// C++ header
+
+#ifndef _H264_VIDEO_RTP_SINK_HH
+#define _H264_VIDEO_RTP_SINK_HH
+
+#ifndef _H264_OR_5_VIDEO_RTP_SINK_HH
+#include "H264or5VideoRTPSink.hh"
+#endif
+
+class H264VideoRTPSink: public H264or5VideoRTPSink {
+public:
+  static H264VideoRTPSink*
+  createNew(UsageEnvironment& env, Groupsock* RTPgs, unsigned char rtpPayloadFormat);
+  static H264VideoRTPSink*
+  createNew(UsageEnvironment& env, Groupsock* RTPgs, unsigned char rtpPayloadFormat,
+	    u_int8_t const* sps, unsigned spsSize, u_int8_t const* pps, unsigned ppsSize);
+    // an optional variant of "createNew()", useful if we know, in advance,
+    // the stream's SPS and PPS NAL units.
+    // This avoids us having to 'pre-read' from the input source in order to get these values.
+  static H264VideoRTPSink*
+  createNew(UsageEnvironment& env, Groupsock* RTPgs, unsigned char rtpPayloadFormat,
+	    char const* sPropParameterSetsStr);
+    // an optional variant of "createNew()", useful if we know, in advance,
+    // the stream's SPS and PPS NAL units.
+    // This avoids us having to 'pre-read' from the input source in order to get these values.
+
+protected:
+  H264VideoRTPSink(UsageEnvironment& env, Groupsock* RTPgs, unsigned char rtpPayloadFormat,
+		   u_int8_t const* sps = NULL, unsigned spsSize = 0,
+		   u_int8_t const* pps = NULL, unsigned ppsSize = 0);
+	// called only by createNew()
+  virtual ~H264VideoRTPSink();
+
+protected: // redefined virtual functions:
+  virtual char const* auxSDPLine();
+
+private: // redefined virtual functions:
+  virtual Boolean sourceIsCompatibleWithUs(MediaSource& source);
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/H264VideoRTPSource.hh b/3rdparty/live555/src/liveMedia/include/H264VideoRTPSource.hh
new file mode 100644
index 00000000..02f7b3f7
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/H264VideoRTPSource.hh
@@ -0,0 +1,70 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// H.264 Video RTP Sources
+// C++ header
+
+#ifndef _H264_VIDEO_RTP_SOURCE_HH
+#define _H264_VIDEO_RTP_SOURCE_HH
+
+#ifndef _MULTI_FRAMED_RTP_SOURCE_HH
+#include "MultiFramedRTPSource.hh"
+#endif
+
+class H264VideoRTPSource: public MultiFramedRTPSource {
+public:
+  static H264VideoRTPSource*
+  createNew(UsageEnvironment& env, Groupsock* RTPgs,
+	    unsigned char rtpPayloadFormat,
+	    unsigned rtpTimestampFrequency = 90000);
+
+protected:
+  H264VideoRTPSource(UsageEnvironment& env, Groupsock* RTPgs,
+			 unsigned char rtpPayloadFormat,
+			 unsigned rtpTimestampFrequency);
+      // called only by createNew()
+
+  virtual ~H264VideoRTPSource();
+
+protected:
+  // redefined virtual functions:
+  virtual Boolean processSpecialHeader(BufferedPacket* packet,
+                                       unsigned& resultSpecialHeaderSize);
+  virtual char const* MIMEtype() const;
+
+private:
+  friend class H264BufferedPacket;
+  unsigned char fCurPacketNALUnitType;
+};
+
+class SPropRecord {
+public:
+  ~SPropRecord() { delete[] sPropBytes; }
+
+  unsigned sPropLength; // in bytes
+  unsigned char* sPropBytes;
+};
+
+SPropRecord* parseSPropParameterSets(char const* sPropParameterSetsStr,
+				     // result parameter:
+				     unsigned& numSPropRecords);
+    // Returns the binary value of each 'parameter set' specified in a
+    // "sprop-parameter-sets" string (in the SDP description for a H.264/RTP stream).
+    // The value is returned as an array (length "numSPropRecords") of "SPropRecord"s.
+    // This array is dynamically allocated by this routine, and must be delete[]d by the caller.
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/H264VideoStreamDiscreteFramer.hh b/3rdparty/live555/src/liveMedia/include/H264VideoStreamDiscreteFramer.hh
new file mode 100644
index 00000000..5feac72a
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/H264VideoStreamDiscreteFramer.hh
@@ -0,0 +1,48 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A simplified version of "H264VideoStreamFramer" that takes only complete,
+// discrete frames (rather than an arbitrary byte stream) as input.
+// This avoids the parsing and data copying overhead of the full
+// "H264VideoStreamFramer".
+// C++ header
+
+#ifndef _H264_VIDEO_STREAM_DISCRETE_FRAMER_HH
+#define _H264_VIDEO_STREAM_DISCRETE_FRAMER_HH
+
+#ifndef _H264_OR_5_VIDEO_STREAM_DISCRETE_FRAMER_HH
+#include "H264or5VideoStreamDiscreteFramer.hh"
+#endif
+
+class H264VideoStreamDiscreteFramer: public H264or5VideoStreamDiscreteFramer {
+public:
+  static H264VideoStreamDiscreteFramer*
+  createNew(UsageEnvironment& env, FramedSource* inputSource,
+	    Boolean includeStartCodeInOutput = False, Boolean insertAccessUnitDelimiters = False);
+
+protected:
+  H264VideoStreamDiscreteFramer(UsageEnvironment& env, FramedSource* inputSource,
+				Boolean includeStartCodeInOutput, Boolean insertAccessUnitDelimiters);
+      // called only by createNew()
+  virtual ~H264VideoStreamDiscreteFramer();
+
+private:
+  // redefined virtual functions:
+  virtual Boolean isH264VideoStreamFramer() const;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/H264VideoStreamFramer.hh b/3rdparty/live555/src/liveMedia/include/H264VideoStreamFramer.hh
new file mode 100644
index 00000000..6059840e
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/H264VideoStreamFramer.hh
@@ -0,0 +1,45 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A filter that breaks up a H.264 Video Elementary Stream into NAL units.
+// C++ header
+
+#ifndef _H264_VIDEO_STREAM_FRAMER_HH
+#define _H264_VIDEO_STREAM_FRAMER_HH
+
+#ifndef _H264_OR_5_VIDEO_STREAM_FRAMER_HH
+#include "H264or5VideoStreamFramer.hh"
+#endif
+
+class H264VideoStreamFramer: public H264or5VideoStreamFramer {
+public:
+  static H264VideoStreamFramer* createNew(UsageEnvironment& env, FramedSource* inputSource,
+					  Boolean includeStartCodeInOutput = False,
+					  Boolean insertAccessUnitDelimiters = False);
+
+protected:
+  H264VideoStreamFramer(UsageEnvironment& env, FramedSource* inputSource,
+			Boolean createParser,
+			Boolean includeStartCodeInOutput, Boolean insertAccessUnitDelimiters);
+      // called only by "createNew()"
+  virtual ~H264VideoStreamFramer();
+
+  // redefined virtual functions:
+  virtual Boolean isH264VideoStreamFramer() const;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/H264or5VideoFileSink.hh b/3rdparty/live555/src/liveMedia/include/H264or5VideoFileSink.hh
new file mode 100644
index 00000000..3ec214a5
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/H264or5VideoFileSink.hh
@@ -0,0 +1,46 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// H.264 or H.265 Video File Sinks
+// C++ header
+
+#ifndef _H264_OR_5_VIDEO_FILE_SINK_HH
+#define _H264_OR_5_VIDEO_FILE_SINK_HH
+
+#ifndef _FILE_SINK_HH
+#include "FileSink.hh"
+#endif
+
+class H264or5VideoFileSink: public FileSink {
+protected:
+  H264or5VideoFileSink(UsageEnvironment& env, FILE* fid,
+		       unsigned bufferSize, char const* perFrameFileNamePrefix,
+		       char const* sPropParameterSetsStr1,
+		       char const* sPropParameterSetsStr2 = NULL,
+		       char const* sPropParameterSetsStr3 = NULL);
+      // we're an abstract base class
+  virtual ~H264or5VideoFileSink();
+
+protected: // redefined virtual functions:
+  virtual void afterGettingFrame(unsigned frameSize, unsigned numTruncatedBytes, struct timeval presentationTime);
+
+private:
+  char const* fSPropParameterSetsStr[3];
+  Boolean fHaveWrittenFirstFrame;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/H264or5VideoRTPSink.hh b/3rdparty/live555/src/liveMedia/include/H264or5VideoRTPSink.hh
new file mode 100644
index 00000000..2c2bfcac
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/H264or5VideoRTPSink.hh
@@ -0,0 +1,60 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// RTP sink for H.264 or H.265 video
+// C++ header
+
+#ifndef _H264_OR_5_VIDEO_RTP_SINK_HH
+#define _H264_OR_5_VIDEO_RTP_SINK_HH
+
+#ifndef _VIDEO_RTP_SINK_HH
+#include "VideoRTPSink.hh"
+#endif
+#ifndef _FRAMED_FILTER_HH
+#include "FramedFilter.hh"
+#endif
+
+class H264or5VideoRTPSink: public VideoRTPSink {
+protected:
+  H264or5VideoRTPSink(int hNumber, // 264 or 265
+		      UsageEnvironment& env, Groupsock* RTPgs, unsigned char rtpPayloadFormat,
+		      u_int8_t const* vps = NULL, unsigned vpsSize = 0,
+		      u_int8_t const* sps = NULL, unsigned spsSize = 0,
+		      u_int8_t const* pps = NULL, unsigned ppsSize = 0);
+	// we're an abstrace base class
+  virtual ~H264or5VideoRTPSink();
+
+private: // redefined virtual functions:
+  virtual Boolean continuePlaying();
+  virtual void doSpecialFrameHandling(unsigned fragmentationOffset,
+                                      unsigned char* frameStart,
+                                      unsigned numBytesInFrame,
+                                      struct timeval framePresentationTime,
+                                      unsigned numRemainingBytes);
+  virtual Boolean frameCanAppearAfterPacketStart(unsigned char const* frameStart,
+						 unsigned numBytesInFrame) const;
+
+protected:
+  int fHNumber;
+  FramedFilter* fOurFragmenter;
+  char* fFmtpSDPLine;
+  u_int8_t* fVPS; unsigned fVPSSize;
+  u_int8_t* fSPS; unsigned fSPSSize;
+  u_int8_t* fPPS; unsigned fPPSSize;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/H264or5VideoStreamDiscreteFramer.hh b/3rdparty/live555/src/liveMedia/include/H264or5VideoStreamDiscreteFramer.hh
new file mode 100644
index 00000000..f02b903f
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/H264or5VideoStreamDiscreteFramer.hh
@@ -0,0 +1,56 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A simplified version of "H264or5VideoStreamFramer" that takes only complete,
+// discrete frames (rather than an arbitrary byte stream) as input.
+// This avoids the parsing and data copying overhead of the full
+// "H264or5VideoStreamFramer".
+// C++ header
+
+#ifndef _H264_OR_5_VIDEO_STREAM_DISCRETE_FRAMER_HH
+#define _H264_OR_5_VIDEO_STREAM_DISCRETE_FRAMER_HH
+
+#ifndef _H264_OR_5_VIDEO_STREAM_FRAMER_HH
+#include "H264or5VideoStreamFramer.hh"
+#endif
+
+class H264or5VideoStreamDiscreteFramer: public H264or5VideoStreamFramer {
+protected:
+  H264or5VideoStreamDiscreteFramer(int hNumber, UsageEnvironment& env, FramedSource* inputSource,
+				   Boolean includeStartCodeInOutput,
+				   Boolean insertAccessUnitDelimiters);
+      // we're an abstract base class
+  virtual ~H264or5VideoStreamDiscreteFramer();
+
+protected:
+  // redefined virtual functions:
+  virtual void doGetNextFrame();
+
+protected:
+  static void afterGettingFrame(void* clientData, unsigned frameSize,
+                                unsigned numTruncatedBytes,
+                                struct timeval presentationTime,
+                                unsigned durationInMicroseconds);
+  void afterGettingFrame1(unsigned frameSize,
+                          unsigned numTruncatedBytes,
+                          struct timeval presentationTime,
+                          unsigned durationInMicroseconds);
+
+  virtual Boolean nalUnitEndsAccessUnit(u_int8_t nal_unit_type);
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/H264or5VideoStreamFramer.hh b/3rdparty/live555/src/liveMedia/include/H264or5VideoStreamFramer.hh
new file mode 100644
index 00000000..0dc5b7a5
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/H264or5VideoStreamFramer.hh
@@ -0,0 +1,92 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A filter that breaks up a H.264 or H.265 Video Elementary Stream into NAL units.
+// C++ header
+
+#ifndef _H264_OR_5_VIDEO_STREAM_FRAMER_HH
+#define _H264_OR_5_VIDEO_STREAM_FRAMER_HH
+
+#ifndef _MPEG_VIDEO_STREAM_FRAMER_HH
+#include "MPEGVideoStreamFramer.hh"
+#endif
+
+class H264or5VideoStreamFramer: public MPEGVideoStreamFramer {
+public:
+  void getVPSandSPSandPPS(u_int8_t*& vps, unsigned& vpsSize,
+			  u_int8_t*& sps, unsigned& spsSize,
+			  u_int8_t*& pps, unsigned& ppsSize) const {
+    // Returns pointers to copies of the most recently seen VPS (video parameter set)
+    // SPS (sequence parameter set) and PPS (picture parameter set) NAL units.
+    // (NULL pointers are returned if the NAL units have not yet been seen.)
+    vps = fLastSeenVPS; vpsSize = fLastSeenVPSSize;
+    sps = fLastSeenSPS; spsSize = fLastSeenSPSSize;
+    pps = fLastSeenPPS; ppsSize = fLastSeenPPSSize;
+  }
+
+  void setVPSandSPSandPPS(u_int8_t* vps, unsigned vpsSize,
+			  u_int8_t* sps, unsigned spsSize,
+			  u_int8_t* pps, unsigned ppsSize) {
+    // Assigns copies of the VPS, SPS and PPS NAL units.  If this function is not called,
+    // then these NAL units are assigned only if/when they appear in the input stream.
+    saveCopyOfVPS(vps, vpsSize);
+    saveCopyOfSPS(sps, spsSize);
+    saveCopyOfPPS(pps, ppsSize);
+  }
+
+protected:
+  H264or5VideoStreamFramer(int hNumber, // 264 or 265
+			   UsageEnvironment& env, FramedSource* inputSource,
+			   Boolean createParser,
+			   Boolean includeStartCodeInOutput, Boolean insertAccessUnitDelimiters);
+      // We're an abstract base class.
+  virtual ~H264or5VideoStreamFramer();
+
+  void saveCopyOfVPS(u_int8_t* from, unsigned size);
+  void saveCopyOfSPS(u_int8_t* from, unsigned size);
+  void saveCopyOfPPS(u_int8_t* from, unsigned size);
+
+  void setPresentationTime();
+
+  Boolean isVPS(u_int8_t nal_unit_type);
+  Boolean isSPS(u_int8_t nal_unit_type);
+  Boolean isPPS(u_int8_t nal_unit_type);
+  Boolean isVCL(u_int8_t nal_unit_type);
+
+protected: // redefined virtual functions
+  virtual void doGetNextFrame();
+
+protected:
+  int fHNumber;
+  Boolean fIncludeStartCodeInOutput, fInsertAccessUnitDelimiters;
+  u_int8_t* fLastSeenVPS;
+  unsigned fLastSeenVPSSize;
+  u_int8_t* fLastSeenSPS;
+  unsigned fLastSeenSPSSize;
+  u_int8_t* fLastSeenPPS;
+  unsigned fLastSeenPPSSize;
+  struct timeval fNextPresentationTime; // the presentation time to be used for the next NAL unit to be parsed/delivered after this
+  friend class H264or5VideoStreamParser; // hack
+};
+
+// A general routine for making a copy of a (H.264 or H.265) NAL unit,
+// removing 'emulation' bytes from the copy:
+unsigned removeH264or5EmulationBytes(u_int8_t* to, unsigned toMaxSize,
+				     u_int8_t const* from, unsigned fromSize);
+    // returns the size of the copy; it will be <= min(toMaxSize,fromSize)
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/H265VideoFileServerMediaSubsession.hh b/3rdparty/live555/src/liveMedia/include/H265VideoFileServerMediaSubsession.hh
new file mode 100644
index 00000000..eff7a065
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/H265VideoFileServerMediaSubsession.hh
@@ -0,0 +1,61 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A 'ServerMediaSubsession' object that creates new, unicast, "RTPSink"s
+// on demand, from a H265 Elementary Stream video file.
+// C++ header
+
+#ifndef _H265_VIDEO_FILE_SERVER_MEDIA_SUBSESSION_HH
+#define _H265_VIDEO_FILE_SERVER_MEDIA_SUBSESSION_HH
+
+#ifndef _FILE_SERVER_MEDIA_SUBSESSION_HH
+#include "FileServerMediaSubsession.hh"
+#endif
+
+class H265VideoFileServerMediaSubsession: public FileServerMediaSubsession {
+public:
+  static H265VideoFileServerMediaSubsession*
+  createNew(UsageEnvironment& env, char const* fileName, Boolean reuseFirstSource);
+
+  // Used to implement "getAuxSDPLine()":
+  void checkForAuxSDPLine1();
+  void afterPlayingDummy1();
+
+protected:
+  H265VideoFileServerMediaSubsession(UsageEnvironment& env,
+				      char const* fileName, Boolean reuseFirstSource);
+      // called only by createNew();
+  virtual ~H265VideoFileServerMediaSubsession();
+
+  void setDoneFlag() { fDoneFlag = ~0; }
+
+protected: // redefined virtual functions
+  virtual char const* getAuxSDPLine(RTPSink* rtpSink,
+				    FramedSource* inputSource);
+  virtual FramedSource* createNewStreamSource(unsigned clientSessionId,
+					      unsigned& estBitrate);
+  virtual RTPSink* createNewRTPSink(Groupsock* rtpGroupsock,
+                                    unsigned char rtpPayloadTypeIfDynamic,
+				    FramedSource* inputSource);
+
+private:
+  char* fAuxSDPLine;
+  char fDoneFlag; // used when setting up "fAuxSDPLine"
+  RTPSink* fDummyRTPSink; // ditto
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/H265VideoFileSink.hh b/3rdparty/live555/src/liveMedia/include/H265VideoFileSink.hh
new file mode 100644
index 00000000..928404a1
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/H265VideoFileSink.hh
@@ -0,0 +1,51 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// H.265 Video File Sinks
+// C++ header
+
+#ifndef _H265_VIDEO_FILE_SINK_HH
+#define _H265_VIDEO_FILE_SINK_HH
+
+#ifndef _H264_OR_5_VIDEO_FILE_SINK_HH
+#include "H264or5VideoFileSink.hh"
+#endif
+
+class H265VideoFileSink: public H264or5VideoFileSink {
+public:
+  static H265VideoFileSink* createNew(UsageEnvironment& env, char const* fileName,
+				      char const* sPropVPSStr = NULL,
+				      char const* sPropSPSStr = NULL,
+				      char const* sPropPPSStr = NULL,
+      // The "sProp*Str" parameters are optional 'SDP format' strings
+      // (comma-separated Base64-encoded) representing VPS, SPS, and/or PPS NAL-units
+      // to prepend to the output
+				      unsigned bufferSize = 100000,
+				      Boolean oneFilePerFrame = False);
+      // See "FileSink.hh" for a description of these parameters.
+
+protected:
+  H265VideoFileSink(UsageEnvironment& env, FILE* fid,
+		    char const* sPropVPSStr,
+		    char const* sPropSPSStr,
+		    char const* sPropPPSStr,
+		    unsigned bufferSize, char const* perFrameFileNamePrefix);
+      // called only by createNew()
+  virtual ~H265VideoFileSink();
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/H265VideoRTPSink.hh b/3rdparty/live555/src/liveMedia/include/H265VideoRTPSink.hh
new file mode 100644
index 00000000..941aa27b
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/H265VideoRTPSink.hh
@@ -0,0 +1,62 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// RTP sink for H.265 video
+// C++ header
+
+#ifndef _H265_VIDEO_RTP_SINK_HH
+#define _H265_VIDEO_RTP_SINK_HH
+
+#ifndef _H264_OR_5_VIDEO_RTP_SINK_HH
+#include "H264or5VideoRTPSink.hh"
+#endif
+
+class H265VideoRTPSink: public H264or5VideoRTPSink {
+public:
+  static H265VideoRTPSink*
+  createNew(UsageEnvironment& env, Groupsock* RTPgs, unsigned char rtpPayloadFormat);
+  static H265VideoRTPSink*
+  createNew(UsageEnvironment& env, Groupsock* RTPgs, unsigned char rtpPayloadFormat,
+	    u_int8_t const* vps, unsigned vpsSize,
+	    u_int8_t const* sps, unsigned spsSize,
+	    u_int8_t const* pps, unsigned ppsSize);
+    // an optional variant of "createNew()", useful if we know, in advance,
+    // the stream's VPS, SPS and PPS NAL units.
+    // This avoids us having to 'pre-read' from the input source in order to get these values.
+  static H265VideoRTPSink*
+  createNew(UsageEnvironment& env, Groupsock* RTPgs, unsigned char rtpPayloadFormat,
+	    char const* sPropVPSStr, char const* sPropSPSStr, char const* sPropPPSStr);
+    // an optional variant of "createNew()", useful if we know, in advance,
+    // the stream's VPS, SPS and PPS NAL units.
+    // This avoids us having to 'pre-read' from the input source in order to get these values.
+
+protected:
+  H265VideoRTPSink(UsageEnvironment& env, Groupsock* RTPgs, unsigned char rtpPayloadFormat,
+		   u_int8_t const* vps = NULL, unsigned vpsSize = 0,
+		   u_int8_t const* sps = NULL, unsigned spsSize = 0,
+		   u_int8_t const* pps = NULL, unsigned ppsSize = 0);
+	// called only by createNew()
+  virtual ~H265VideoRTPSink();
+
+protected: // redefined virtual functions:
+  virtual char const* auxSDPLine();
+
+private: // redefined virtual functions:
+  virtual Boolean sourceIsCompatibleWithUs(MediaSource& source);
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/H265VideoRTPSource.hh b/3rdparty/live555/src/liveMedia/include/H265VideoRTPSource.hh
new file mode 100644
index 00000000..22bceadb
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/H265VideoRTPSource.hh
@@ -0,0 +1,67 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// H.265 Video RTP Sources
+// C++ header
+
+#ifndef _H265_VIDEO_RTP_SOURCE_HH
+#define _H265_VIDEO_RTP_SOURCE_HH
+
+#ifndef _MULTI_FRAMED_RTP_SOURCE_HH
+#include "MultiFramedRTPSource.hh"
+#endif
+
+class H265VideoRTPSource: public MultiFramedRTPSource {
+public:
+  static H265VideoRTPSource*
+  createNew(UsageEnvironment& env, Groupsock* RTPgs,
+	    unsigned char rtpPayloadFormat,
+	    Boolean expectDONFields = False,
+	    unsigned rtpTimestampFrequency = 90000);
+      // "expectDONFields" is True iff we expect incoming H.265/RTP packets to contain
+      // DONL and DOND fields.  I.e., if "tx-mode == "MST" or sprop-depack-buf-nalus > 0".
+
+  u_int64_t currentNALUnitAbsDon() const { return fCurrentNALUnitAbsDon; }
+      // the 'absolute decoding order number (AbsDon)' for the most-recently delivered NAL unit
+
+protected:
+  H265VideoRTPSource(UsageEnvironment& env, Groupsock* RTPgs,
+		     unsigned char rtpPayloadFormat,
+		     Boolean expectDONFields,		     
+		     unsigned rtpTimestampFrequency);
+      // called only by createNew()
+
+  virtual ~H265VideoRTPSource();
+
+protected:
+  // redefined virtual functions:
+  virtual Boolean processSpecialHeader(BufferedPacket* packet,
+                                       unsigned& resultSpecialHeaderSize);
+  virtual char const* MIMEtype() const;
+
+private:
+  void computeAbsDonFromDON(u_int16_t DON);
+
+private:
+  friend class H265BufferedPacket;
+  Boolean fExpectDONFields;
+  unsigned char fCurPacketNALUnitType;
+  u_int16_t fPreviousNALUnitDON;
+  u_int64_t fCurrentNALUnitAbsDon;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/H265VideoStreamDiscreteFramer.hh b/3rdparty/live555/src/liveMedia/include/H265VideoStreamDiscreteFramer.hh
new file mode 100644
index 00000000..98fff512
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/H265VideoStreamDiscreteFramer.hh
@@ -0,0 +1,48 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A simplified version of "H265VideoStreamFramer" that takes only complete,
+// discrete frames (rather than an arbitrary byte stream) as input.
+// This avoids the parsing and data copying overhead of the full
+// "H265VideoStreamFramer".
+// C++ header
+
+#ifndef _H265_VIDEO_STREAM_DISCRETE_FRAMER_HH
+#define _H265_VIDEO_STREAM_DISCRETE_FRAMER_HH
+
+#ifndef _H264_OR_5_VIDEO_STREAM_DISCRETE_FRAMER_HH
+#include "H264or5VideoStreamDiscreteFramer.hh"
+#endif
+
+class H265VideoStreamDiscreteFramer: public H264or5VideoStreamDiscreteFramer {
+public:
+  static H265VideoStreamDiscreteFramer*
+  createNew(UsageEnvironment& env, FramedSource* inputSource,
+	    Boolean includeStartCodeInOutput = False, Boolean insertAccessUnitDelimiters = False);
+
+protected:
+  H265VideoStreamDiscreteFramer(UsageEnvironment& env, FramedSource* inputSource,
+				Boolean includeStartCodeInOutput, Boolean insertAccessUnitDelimiters);
+      // called only by createNew()
+  virtual ~H265VideoStreamDiscreteFramer();
+
+private:
+  // redefined virtual functions:
+  virtual Boolean isH265VideoStreamFramer() const;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/H265VideoStreamFramer.hh b/3rdparty/live555/src/liveMedia/include/H265VideoStreamFramer.hh
new file mode 100644
index 00000000..bf5e036f
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/H265VideoStreamFramer.hh
@@ -0,0 +1,45 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A filter that breaks up a H.265 Video Elementary Stream into NAL units.
+// C++ header
+
+#ifndef _H265_VIDEO_STREAM_FRAMER_HH
+#define _H265_VIDEO_STREAM_FRAMER_HH
+
+#ifndef _H264_OR_5_VIDEO_STREAM_FRAMER_HH
+#include "H264or5VideoStreamFramer.hh"
+#endif
+
+class H265VideoStreamFramer: public H264or5VideoStreamFramer {
+public:
+  static H265VideoStreamFramer* createNew(UsageEnvironment& env, FramedSource* inputSource,
+					  Boolean includeStartCodeInOutput = False,
+					  Boolean insertAccessUnitDelimiters = False);
+
+protected:
+  H265VideoStreamFramer(UsageEnvironment& env, FramedSource* inputSource,
+			Boolean createParser,
+			Boolean includeStartCodeInOutput, Boolean insertAccessUnitDelimiters);
+      // called only by "createNew()"
+  virtual ~H265VideoStreamFramer();
+
+  // redefined virtual functions:
+  virtual Boolean isH265VideoStreamFramer() const;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/HLSSegmenter.hh b/3rdparty/live555/src/liveMedia/include/HLSSegmenter.hh
new file mode 100644
index 00000000..74573776
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/HLSSegmenter.hh
@@ -0,0 +1,76 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A media sink that takes - as input - a MPEG Transport Stream, and outputs a series
+// of MPEG Transport Stream files, each representing a segment of the input stream,
+// suitable for HLS (Apple's "HTTP Live Streaming").
+// C++ header
+
+#ifndef _HLS_SEGMENTER_HH
+#define _HLS_SEGMENTER_HH
+
+#ifndef _MEDIA_SINK_HH
+#include "MediaSink.hh"
+#endif
+
+class HLSSegmenter: public MediaSink {
+public:
+  typedef void (onEndOfSegmentFunc)(void* clientData,
+				    char const* segmentFileName, double segmentDuration);
+  static HLSSegmenter* createNew(UsageEnvironment& env,
+				 unsigned segmentationDuration, char const* fileNamePrefix,
+				 onEndOfSegmentFunc* onEndOfSegmentFunc = NULL,
+				 void* onEndOfSegmentClientData = NULL);
+
+private:
+  HLSSegmenter(UsageEnvironment& env, unsigned segmentationDuration, char const* fileNamePrefix,
+	       onEndOfSegmentFunc* onEndOfSegmentFunc, void* onEndOfSegmentClientData);
+    // called only by createNew()
+  virtual ~HLSSegmenter();
+
+  static void ourEndOfSegmentHandler(void* clientData, double segmentDuration);
+  void ourEndOfSegmentHandler(double segmentDuration);
+
+  Boolean openNextOutputSegment();
+
+  static void afterGettingFrame(void* clientData, unsigned frameSize,
+                                unsigned numTruncatedBytes,
+                                struct timeval presentationTime,
+                                unsigned durationInMicroseconds);
+  virtual void afterGettingFrame(unsigned frameSize,
+                                 unsigned numTruncatedBytes);
+
+  static void ourOnSourceClosure(void* clientData);
+  void ourOnSourceClosure();
+
+private: // redefined virtual functions:
+  virtual Boolean sourceIsCompatibleWithUs(MediaSource& source);
+  virtual Boolean continuePlaying();
+
+private:
+  unsigned fSegmentationDuration;
+  char const* fFileNamePrefix;
+  onEndOfSegmentFunc* fOnEndOfSegmentFunc;
+  void* fOnEndOfSegmentClientData;
+  Boolean fHaveConfiguredUpstreamSource;
+  unsigned fCurrentSegmentCounter;
+  char* fOutputSegmentFileName;
+  FILE* fOutFid;
+  unsigned char* fOutputFileBuffer;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/HMAC_SHA1.hh b/3rdparty/live555/src/liveMedia/include/HMAC_SHA1.hh
new file mode 100644
index 00000000..9ba5409a
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/HMAC_SHA1.hh
@@ -0,0 +1,34 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022, Live Networks, Inc.  All rights reserved
+//
+// A function for computing the HMAC_SHA1 digest
+// Definition
+
+#ifndef _HMAC_SHA1_HH
+#define _HMAC_SHA1_HH
+
+#ifndef NO_OPENSSL
+#ifndef _HMAC_HASH_HH
+#include "HMAC_hash.hh"
+#endif
+
+#define SHA1_DIGEST_LEN 20
+
+HMAC_hash HMAC_SHA1;
+#endif
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/HMAC_hash.hh b/3rdparty/live555/src/liveMedia/include/HMAC_hash.hh
new file mode 100644
index 00000000..973ecea6
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/HMAC_hash.hh
@@ -0,0 +1,37 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022, Live Networks, Inc.  All rights reserved
+//
+// Generic HMA_HASH functions
+// Definition
+
+#ifndef _HMAC_HASH_HH
+#define _HMAC_HASH_HH
+
+#ifndef _NET_COMMON_H
+#include "NetCommon.h"
+#endif
+
+// All HMAC hash functions have the following signature:
+typedef void HMAC_hash(u_int8_t const* key, unsigned keyLength,
+		       u_int8_t const* text, unsigned textLength,
+		       u_int8_t* resultDigest);
+    // "resultDigest" must point to an array of sufficient size to hold the digest
+
+#define HMAC_BLOCK_SIZE 64
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/InputFile.hh b/3rdparty/live555/src/liveMedia/include/InputFile.hh
new file mode 100644
index 00000000..d51d5298
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/InputFile.hh
@@ -0,0 +1,67 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// Common routines for opening/closing named input files
+// C++ header
+
+#ifndef _INPUT_FILE_HH
+#define _INPUT_FILE_HH
+
+#include <UsageEnvironment.hh>
+#include <stdio.h>
+
+#if (defined(__WIN32__) || defined(_WIN32) || defined(_WIN32_WCE))
+#ifndef _WIN32_WCE
+// Include header files that might be needed by Windows (in code that uses this header file):
+#include <io.h>
+#include <fcntl.h>
+#endif
+
+#define READ_FROM_FILES_SYNCHRONOUSLY 1
+    // Because Windows is a silly toy operating system that doesn't (reliably) treat
+    // open files as being readable sockets (which can be handled within the default
+    // "BasicTaskScheduler" event loop, using "select()"), we implement file reading
+    // in Windows using synchronous, rather than asynchronous, I/O.  This can severely
+    // limit the scalability of servers using this code that run on Windows.
+    // If this is a problem for you, then either use a better operating system,
+    // or else write your own Windows-specific event loop ("TaskScheduler" subclass)
+    // that can handle readable data in Windows open files as an event.
+#endif
+
+#ifndef _WIN32_WCE
+#include <sys/stat.h>
+#endif
+
+FILE* OpenInputFile(UsageEnvironment& env, char const* fileName);
+
+void CloseInputFile(FILE* fid);
+
+#undef GetFileSize // because some platforms already define this as a macro
+u_int64_t GetFileSize(char const* fileName, FILE* fid);
+    // 0 means zero-length, unbounded, or unknown
+
+int64_t SeekFile64(FILE *fid, int64_t offset, int whence);
+    // A platform-independent routine for seeking within (possibly) large files
+
+int64_t TellFile64(FILE *fid);
+    // A platform-independent routine for reporting the position within
+    // (possibly) large files
+
+Boolean FileIsSeekable(FILE *fid);
+    // Tests whether "fid" is seekable, by trying to seek within it.
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/JPEG2000VideoRTPSink.hh b/3rdparty/live555/src/liveMedia/include/JPEG2000VideoRTPSink.hh
new file mode 100644
index 00000000..6ab61f76
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/JPEG2000VideoRTPSink.hh
@@ -0,0 +1,46 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+
+
+#ifndef _JPEG2000_VIDEO_RTP_SINK_HH
+#define _JPEG2000_VIDEO_RTP_SINK_HH
+
+#ifndef _VIDEO_RTP_SINK_HH
+#include "VideoRTPSink.hh"
+#endif
+
+class JPEG2000VideoRTPSink: public VideoRTPSink {
+public:
+  static JPEG2000VideoRTPSink* createNew(UsageEnvironment& env, Groupsock* RTPgs);
+
+protected:
+  JPEG2000VideoRTPSink(UsageEnvironment& env, Groupsock* RTPgs);
+	// called only by createNew()
+
+  virtual ~JPEG2000VideoRTPSink();
+
+private: // redefined virtual functions:
+  virtual void doSpecialFrameHandling(unsigned fragmentationOffset,
+                                      unsigned char* frameStart,
+                                      unsigned numBytesInFrame,
+                                      struct timeval framePresentationTime,
+                                      unsigned numRemainingBytes);
+  virtual unsigned specialHeaderSize() const;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/JPEG2000VideoRTPSource.hh b/3rdparty/live555/src/liveMedia/include/JPEG2000VideoRTPSource.hh
new file mode 100644
index 00000000..dc148d5b
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/JPEG2000VideoRTPSource.hh
@@ -0,0 +1,53 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+
+#ifndef _JPEG2000_VIDEO_RTP_SOURCE_HH
+#define _JPEG2000_VIDEO_RTP_SOURCE_HH
+
+#ifndef _MULTI_FRAMED_RTP_SOURCE_HH
+#include "MultiFramedRTPSource.hh"
+#endif
+
+class JPEG2000VideoRTPSource: public MultiFramedRTPSource {
+public:
+  static JPEG2000VideoRTPSource* createNew(UsageEnvironment& env, Groupsock* RTPgs,
+					   unsigned char rtpPayloadFormat,
+					   unsigned rtpTimestampFrequency,
+					   char const* sampling);
+
+protected:
+  virtual ~JPEG2000VideoRTPSource();
+
+protected:
+  JPEG2000VideoRTPSource(UsageEnvironment& env, Groupsock* RTPgs,
+			 unsigned char rtpPayloadFormat,
+			 unsigned rtpTimestampFrequency,
+			 char const* sampling);
+    // called only by createNew()
+
+private:
+  // redefined virtual functions:
+  virtual Boolean processSpecialHeader(BufferedPacket* packet,
+                                       unsigned& resultSpecialHeaderSize);
+  virtual char const* MIMEtype() const;
+
+private:
+  char* fSampling;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/JPEGVideoRTPSink.hh b/3rdparty/live555/src/liveMedia/include/JPEGVideoRTPSink.hh
new file mode 100644
index 00000000..5cd91907
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/JPEGVideoRTPSink.hh
@@ -0,0 +1,52 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// RTP sink for JPEG video (RFC 2435)
+// C++ header
+
+#ifndef _JPEG_VIDEO_RTP_SINK_HH
+#define _JPEG_VIDEO_RTP_SINK_HH
+
+#ifndef _VIDEO_RTP_SINK_HH
+#include "VideoRTPSink.hh"
+#endif
+
+class JPEGVideoRTPSink: public VideoRTPSink {
+public:
+  static JPEGVideoRTPSink* createNew(UsageEnvironment& env, Groupsock* RTPgs);
+
+protected:
+  JPEGVideoRTPSink(UsageEnvironment& env, Groupsock* RTPgs);
+	// called only by createNew()
+
+  virtual ~JPEGVideoRTPSink();
+
+private: // redefined virtual functions:
+  virtual Boolean sourceIsCompatibleWithUs(MediaSource& source);
+
+  virtual void doSpecialFrameHandling(unsigned fragmentationOffset,
+                                      unsigned char* frameStart,
+                                      unsigned numBytesInFrame,
+                                      struct timeval framePresentationTime,
+                                      unsigned numRemainingBytes);
+  virtual
+  Boolean frameCanAppearAfterPacketStart(unsigned char const* frameStart,
+					 unsigned numBytesInFrame) const;
+  virtual unsigned specialHeaderSize() const;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/JPEGVideoRTPSource.hh b/3rdparty/live555/src/liveMedia/include/JPEGVideoRTPSource.hh
new file mode 100644
index 00000000..ffcc68ea
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/JPEGVideoRTPSource.hh
@@ -0,0 +1,59 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// JPEG Video (RFC 2435) RTP Sources
+// C++ header
+
+#ifndef _JPEG_VIDEO_RTP_SOURCE_HH
+#define _JPEG_VIDEO_RTP_SOURCE_HH
+
+#ifndef _MULTI_FRAMED_RTP_SOURCE_HH
+#include "MultiFramedRTPSource.hh"
+#endif
+
+#define MAX_JPEG_HEADER_SIZE 1024
+
+class JPEGVideoRTPSource: public MultiFramedRTPSource {
+public:
+  static JPEGVideoRTPSource*
+  createNew(UsageEnvironment& env, Groupsock* RTPgs,
+	    unsigned char rtpPayloadFormat = 26,
+	    unsigned rtpPayloadFrequency = 90000,
+	    unsigned defaultWidth = 0, unsigned defaultHeight = 0);
+
+protected:
+  virtual ~JPEGVideoRTPSource();
+
+private:
+  JPEGVideoRTPSource(UsageEnvironment& env, Groupsock* RTPgs,
+		     unsigned char rtpPayloadFormat,
+		     unsigned rtpTimestampFrequency,
+		     unsigned defaultWidth, unsigned defaultHeight);
+      // called only by createNew()
+
+  // Image dimensions from the SDP description, if any
+  unsigned fDefaultWidth, fDefaultHeight;
+
+private:
+  // redefined virtual functions:
+  virtual Boolean processSpecialHeader(BufferedPacket* packet,
+                                       unsigned& resultSpecialHeaderSize);
+
+  virtual char const* MIMEtype() const;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/JPEGVideoSource.hh b/3rdparty/live555/src/liveMedia/include/JPEGVideoSource.hh
new file mode 100644
index 00000000..cc77e55b
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/JPEGVideoSource.hh
@@ -0,0 +1,55 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// JPEG video sources
+// C++ header
+
+#ifndef _JPEG_VIDEO_SOURCE_HH
+#define _JPEG_VIDEO_SOURCE_HH
+
+#ifndef _FRAMED_SOURCE_HH
+#include "FramedSource.hh"
+#endif
+
+class JPEGVideoSource: public FramedSource {
+public:
+  virtual u_int8_t type() = 0;
+  virtual u_int8_t qFactor() = 0;
+  virtual u_int8_t width() = 0; // # pixels/8 (or 0 for 2048 pixels)
+  virtual u_int8_t height() = 0; // # pixels/8 (or 0 for 2048 pixels)
+
+  virtual u_int8_t const* quantizationTables(u_int8_t& precision,
+					     u_int16_t& length);
+    // If "qFactor()" returns a value >= 128, then this function is called
+    // to tell us the quantization tables that are being used.
+    // (The default implementation of this function just returns NULL.)
+    // "precision" and "length" are as defined in RFC 2435, section 3.1.8.
+
+  virtual u_int16_t restartInterval();
+    // If restart intervals are being used (i.e., 64 <= type() <= 127), then this function must be
+    // redefined - by a subclass - to return a non-zero value.
+
+protected:
+  JPEGVideoSource(UsageEnvironment& env); // abstract base class
+  virtual ~JPEGVideoSource();
+
+private:
+  // redefined virtual functions:
+  virtual Boolean isJPEGVideoSource() const;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/Locale.hh b/3rdparty/live555/src/liveMedia/include/Locale.hh
new file mode 100644
index 00000000..c90326c9
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/Locale.hh
@@ -0,0 +1,79 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// Support for temporarily setting the locale (e.g., to "C" or "POSIX") for (e.g.) parsing or printing
+// floating-point numbers in protocol headers, or calling toupper()/tolower() on human-input strings.
+// C++ header
+
+#ifndef _LOCALE_HH
+#define _LOCALE_HH
+
+// If you're on a system that (for whatever reason) doesn't have either the "setlocale()" or the "newlocale()" function, then
+// add "-DLOCALE_NOT_USED" to your "config.*" file.
+
+// If you're on a system that (for whatever reason) has "setlocale()" but not "newlocale()", then
+// add "-DNEWLOCALE_NOT_USED" to your "config.*" file.
+// (Note that -DLOCALE_NOT_USED implies -DNEWLOCALE_NOT_USED; you do not need both.)
+// Also, for Windows systems, we define "NEWLOCALE_NOT_USED" by default, because at least some Windows systems
+// (or their development environments) don't have "newlocale()".  If, however, your Windows system *does* have "newlocale()",
+// then you can override this by defining "NEWLOCALE_USED" before #including this file.
+
+// Finally, some old development environments need a header file "xlocale.h" to use "newlocale()".
+// Should you need this header file, add "-DNEED_XLOCALE_H" to your "config.*" file.
+
+
+
+#ifdef NEWLOCALE_USED
+#undef LOCALE_NOT_USED
+#undef NEWLOCALE_NOT_USED
+#else
+#if defined(__WIN32__) || defined(_WIN32)
+#define NEWLOCALE_NOT_USED 1
+#endif
+#endif
+
+#ifndef LOCALE_NOT_USED
+#include <locale.h>
+#ifndef NEWLOCALE_NOT_USED
+#ifdef NEED_XLOCALE_H 
+#include <xlocale.h>
+#endif
+#endif
+#endif
+#ifdef OS_MACOS
+#include <xlocale.h>
+#endif
+
+enum LocaleCategory { All, Numeric }; // define and implement more categories later, as needed
+
+class Locale {
+public:
+  Locale(char const* newLocale, LocaleCategory category = All);
+  virtual ~Locale();
+
+private:
+#ifndef LOCALE_NOT_USED
+#ifndef NEWLOCALE_NOT_USED
+  locale_t fLocale, fPrevLocale;
+#else
+  int fCategoryNum;
+  char* fPrevLocale;
+#endif
+#endif
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/MIKEY.hh b/3rdparty/live555/src/liveMedia/include/MIKEY.hh
new file mode 100644
index 00000000..4932c505
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/MIKEY.hh
@@ -0,0 +1,75 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A data structure that implements a MIKEY message (RFC 3830)
+// C++ header
+
+#ifndef _MIKEY_HH
+#define _MIKEY_HH
+
+#ifndef _NET_COMMON_H
+#include "NetCommon.h"
+#endif
+#ifndef _BOOLEAN_HH
+#include "Boolean.hh"
+#endif
+
+class MIKEYState {
+public:
+  MIKEYState(Boolean useEncryption = True); // initialize with default parameters
+  virtual ~MIKEYState();
+
+  static MIKEYState* createNew(u_int8_t const* messageToParse, unsigned messageSize);
+      // (Attempts to) parse a binary MIKEY message, returning a new "MIKEYState" if successful
+      // (or NULL if unsuccessful).
+
+  u_int8_t* generateMessage(unsigned& messageSize) const;
+      // Returns a binary message representing the current MIKEY state, of size "messageSize" bytes.
+      // This array is dynamically allocated by this routine, and must be delete[]d by the caller.
+
+  // Accessors for the encryption/authentication parameters:
+  Boolean encryptSRTP() const { return fEncryptSRTP; }
+  Boolean encryptSRTCP() const { return fEncryptSRTCP; }
+  u_int8_t const* keyData() const { return fKeyData; }
+  u_int32_t MKI() const { return fMKI; }
+  Boolean useAuthentication() const { return fUseAuthentication; }
+
+private:
+  MIKEYState(u_int8_t const* messageToParse, unsigned messageSize, Boolean& parsedOK);
+      // called only by "createNew()"
+
+  void addNewPayload(class MIKEYPayload* newPayload);
+  Boolean parseHDRPayload(u_int8_t const*& ptr, u_int8_t const* endPtr, u_int8_t& nextPayloadType);
+  Boolean parseNonHDRPayload(u_int8_t const*& ptr, u_int8_t const* endPtr, u_int8_t& nextPayloadType);
+  
+private:
+  // Encryption/authentication parameters, either set by default
+  // (if the first (parameterless) constructor is used), or set by parsing an input message
+  // (if the second constructor is used):
+  Boolean fEncryptSRTP;
+  Boolean fEncryptSRTCP;
+  u_int8_t fKeyData[16+14]; // encryption key + salt
+  u_int32_t fMKI; // used only if encryption is used. (We assume a MKI length of 4.)
+  Boolean fUseAuthentication;
+
+  // Our internal binary representation of the MIKEY payloads:
+  class MIKEYPayload* fHeaderPayload;
+  class MIKEYPayload* fTailPayload;
+  unsigned fTotalPayloadByteCount;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/MP3ADU.hh b/3rdparty/live555/src/liveMedia/include/MP3ADU.hh
new file mode 100644
index 00000000..089fd38d
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/MP3ADU.hh
@@ -0,0 +1,94 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// 'ADU' MP3 streams (for improved loss-tolerance)
+// C++ header
+
+#ifndef _MP3_ADU_HH
+#define _MP3_ADU_HH
+
+#ifndef _FRAMED_FILTER_HH
+#include "FramedFilter.hh"
+#endif
+
+class ADUFromMP3Source: public FramedFilter {
+public:
+  static ADUFromMP3Source* createNew(UsageEnvironment& env,
+				     FramedSource* inputSource,
+				     Boolean includeADUdescriptors = True);
+
+  void resetInput();
+      // This is called whenever there's a discontinuity in the input MP3 source
+      // (e.g., due to seeking within the source).  It causes any still-unprocessed
+      // MP3 frame data within our queue to be discarded, so that it does not
+      // erroneously get used by backpointers from the new MP3 frames.
+
+  Boolean setScaleFactor(int scale);
+
+protected:
+  ADUFromMP3Source(UsageEnvironment& env,
+		   FramedSource* inputSource,
+		   Boolean includeADUdescriptors);
+      // called only by createNew()
+  virtual ~ADUFromMP3Source();
+
+private:
+  // Redefined virtual functions:
+  virtual void doGetNextFrame();
+  virtual char const* MIMEtype() const;
+
+private:
+  Boolean doGetNextFrame1();
+
+private:
+  Boolean fAreEnqueueingMP3Frame;
+  class SegmentQueue* fSegments;
+  Boolean fIncludeADUdescriptors;
+  unsigned fTotalDataSizeBeforePreviousRead;
+  int fScale;
+  unsigned fFrameCounter;
+};
+
+class MP3FromADUSource: public FramedFilter {
+public:
+  static MP3FromADUSource* createNew(UsageEnvironment& env,
+				     FramedSource* inputSource,
+                                     Boolean includeADUdescriptors = True);
+
+protected:
+  MP3FromADUSource(UsageEnvironment& env,
+		   FramedSource* inputSource,
+		   Boolean includeADUdescriptors);
+      // called only by createNew()
+  virtual ~MP3FromADUSource();
+
+private:
+  // Redefined virtual functions:
+  virtual void doGetNextFrame();
+  virtual char const* MIMEtype() const;
+
+private:
+  Boolean needToGetAnADU();
+  void insertDummyADUsIfNecessary();
+  Boolean generateFrameFromHeadADU();
+
+private:
+  Boolean fAreEnqueueingADU;
+  class SegmentQueue* fSegments;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/MP3ADURTPSink.hh b/3rdparty/live555/src/liveMedia/include/MP3ADURTPSink.hh
new file mode 100644
index 00000000..fa7c09eb
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/MP3ADURTPSink.hh
@@ -0,0 +1,55 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// RTP sink for 'ADUized' MP3 frames ("mpa-robust")
+// C++ header
+
+#ifndef _MP3_ADU_RTP_SINK_HH
+#define _MP3_ADU_RTP_SINK_HH
+
+#ifndef _AUDIO_RTP_SINK_HH
+#include "AudioRTPSink.hh"
+#endif
+
+class MP3ADURTPSink: public AudioRTPSink {
+public:
+  static MP3ADURTPSink* createNew(UsageEnvironment& env, Groupsock* RTPgs,
+				  unsigned char RTPPayloadType);
+
+protected:
+  virtual ~MP3ADURTPSink();
+
+private:
+  MP3ADURTPSink(UsageEnvironment& env, Groupsock* RTPgs,
+		unsigned char RTPPayloadType);
+	// called only by createNew()
+
+
+private:
+  // Redefined virtual functions:
+  virtual void doSpecialFrameHandling(unsigned fragmentationOffset,
+                                      unsigned char* frameStart,
+                                      unsigned numBytesInFrame,
+                                      struct timeval framePresentationTime,
+                                      unsigned numRemainingBytes);
+  virtual unsigned specialHeaderSize() const;
+
+private:
+  unsigned fCurADUSize; // used when fragmenting over multiple RTP packets
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/MP3ADURTPSource.hh b/3rdparty/live555/src/liveMedia/include/MP3ADURTPSource.hh
new file mode 100644
index 00000000..ef577abe
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/MP3ADURTPSource.hh
@@ -0,0 +1,49 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// RTP source for 'ADUized' MP3 frames ("mpa-robust")
+// C++ header
+
+#ifndef _MP3_ADU_SOURCE_HH
+#define _MP3_ADU_SOURCE_HH
+
+#ifndef _MULTI_FRAMED_RTP_SOURCE_HH
+#include "MultiFramedRTPSource.hh"
+#endif
+
+class MP3ADURTPSource: public MultiFramedRTPSource {
+public:
+  static MP3ADURTPSource*
+  createNew(UsageEnvironment& env, Groupsock* RTPgs,
+	    unsigned char rtpPayloadFormat,
+	    unsigned rtpTimestampFrequency = 90000);
+
+protected:
+  virtual ~MP3ADURTPSource();
+
+private:
+  MP3ADURTPSource(UsageEnvironment& env, Groupsock* RTPgs,
+		  unsigned char rtpPayloadFormat,
+		  unsigned rtpTimestampFrequency);
+      // called only by createNew()
+
+private:
+  // redefined virtual functions:
+  virtual char const* MIMEtype() const;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/MP3ADUTranscoder.hh b/3rdparty/live555/src/liveMedia/include/MP3ADUTranscoder.hh
new file mode 100644
index 00000000..42e6eb58
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/MP3ADUTranscoder.hh
@@ -0,0 +1,64 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// Transcoder for ADUized MP3 frames
+// C++ header
+
+#ifndef _MP3_ADU_TRANSCODER_HH
+#define _MP3_ADU_TRANSCODER_HH
+
+#ifndef _FRAMED_FILTER_HH
+#include "FramedFilter.hh"
+#endif
+
+class MP3ADUTranscoder: public FramedFilter {
+public:
+  static MP3ADUTranscoder* createNew(UsageEnvironment& env,
+				  unsigned outBitrate /* in kbps */,
+				  FramedSource* inputSource);
+
+  unsigned outBitrate() const { return fOutBitrate; }
+protected:
+  MP3ADUTranscoder(UsageEnvironment& env,
+		unsigned outBitrate /* in kbps */,
+		FramedSource* inputSource);
+      // called only by createNew()
+  virtual ~MP3ADUTranscoder();
+
+private:
+  // redefined virtual functions:
+  virtual void doGetNextFrame();
+  virtual void getAttributes() const;
+
+private:
+  static void afterGettingFrame(void* clientData,
+				unsigned numBytesRead, unsigned numTruncatedBytes,
+				struct timeval presentationTime,
+				unsigned durationInMicroseconds);
+  void afterGettingFrame1(unsigned numBytesRead, unsigned numTruncatedBytes,
+			  struct timeval presentationTime,
+			  unsigned durationInMicroseconds);
+
+private:
+  unsigned fOutBitrate; // in kbps
+  unsigned fAvailableBytesForBackpointer;
+
+  unsigned char* fOrigADU;
+      // used to store incoming ADU prior to transcoding
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/MP3ADUinterleaving.hh b/3rdparty/live555/src/liveMedia/include/MP3ADUinterleaving.hh
new file mode 100644
index 00000000..fa1a2f09
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/MP3ADUinterleaving.hh
@@ -0,0 +1,129 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// Interleaving of MP3 ADUs
+// C++ header
+
+#ifndef _MP3_ADU_INTERLEAVING_HH
+#define _MP3_ADU_INTERLEAVING_HH
+
+#ifndef _FRAMED_FILTER_HH
+#include "FramedFilter.hh"
+#endif
+
+// A data structure used to represent an interleaving
+#define MAX_CYCLE_SIZE 256
+class Interleaving {
+public:
+  Interleaving(unsigned cycleSize, unsigned char const* cycleArray);
+  virtual ~Interleaving();
+
+  unsigned cycleSize() const {return fCycleSize;}
+  unsigned char lookupInverseCycle(unsigned char index) const {
+    return fInverseCycle[index];
+  }
+
+private:
+  unsigned fCycleSize;
+  unsigned char fInverseCycle[MAX_CYCLE_SIZE];
+};
+
+// This class is used only as a base for the following two:
+
+class MP3ADUinterleaverBase: public FramedFilter {
+protected:
+  MP3ADUinterleaverBase(UsageEnvironment& env,
+			FramedSource* inputSource);
+      // abstract base class
+  virtual ~MP3ADUinterleaverBase();
+
+  static FramedSource* getInputSource(UsageEnvironment& env,
+				      char const* inputSourceName);
+  static void afterGettingFrame(void* clientData,
+				unsigned numBytesRead,
+				unsigned numTruncatedBytes,
+				struct timeval presentationTime,
+				unsigned durationInMicroseconds);
+  virtual void afterGettingFrame(unsigned numBytesRead,
+				 struct timeval presentationTime,
+				 unsigned durationInMicroseconds) = 0;
+};
+
+// This class is used to convert an ADU sequence from non-interleaved
+// to interleaved form:
+
+class MP3ADUinterleaver: public MP3ADUinterleaverBase {
+public:
+  static MP3ADUinterleaver* createNew(UsageEnvironment& env,
+				      Interleaving const& interleaving,
+				      FramedSource* inputSource);
+
+protected:
+  MP3ADUinterleaver(UsageEnvironment& env,
+		    Interleaving const& interleaving,
+		    FramedSource* inputSource);
+      // called only by createNew()
+  virtual ~MP3ADUinterleaver();
+
+private:
+  // redefined virtual functions:
+  virtual void doGetNextFrame();
+  virtual void afterGettingFrame(unsigned numBytesRead,
+				 struct timeval presentationTime,
+				 unsigned durationInMicroseconds);
+
+private:
+  void releaseOutgoingFrame();
+
+private:
+  Interleaving const fInterleaving;
+  class InterleavingFrames* fFrames;
+  unsigned char fPositionOfNextIncomingFrame;
+  unsigned fII, fICC;
+};
+
+// This class is used to convert an ADU sequence from interleaved
+// to non-interleaved form:
+
+class MP3ADUdeinterleaver: public MP3ADUinterleaverBase {
+public:
+  static MP3ADUdeinterleaver* createNew(UsageEnvironment& env,
+					FramedSource* inputSource);
+
+protected:
+  MP3ADUdeinterleaver(UsageEnvironment& env,
+		      FramedSource* inputSource);
+      // called only by createNew()
+  virtual ~MP3ADUdeinterleaver();
+
+private:
+  // redefined virtual functions:
+  virtual void doGetNextFrame();
+  virtual void afterGettingFrame(unsigned numBytesRead,
+				 struct timeval presentationTime,
+				 unsigned durationInMicroseconds);
+
+private:
+  void releaseOutgoingFrame();
+
+private:
+  class DeinterleavingFrames* fFrames;
+  unsigned fIIlastSeen, fICClastSeen;
+};
+
+#endif
+
diff --git a/3rdparty/live555/src/liveMedia/include/MP3AudioFileServerMediaSubsession.hh b/3rdparty/live555/src/liveMedia/include/MP3AudioFileServerMediaSubsession.hh
new file mode 100644
index 00000000..6e23b6d0
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/MP3AudioFileServerMediaSubsession.hh
@@ -0,0 +1,73 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A 'ServerMediaSubsession' object that creates new, unicast, "RTPSink"s
+// on demand, from an MP3 audio file.
+// (Actually, any MPEG-1 or MPEG-2 audio file should work.)
+// C++ header
+
+#ifndef _MP3_AUDIO_FILE_SERVER_MEDIA_SUBSESSION_HH
+#define _MP3_AUDIO_FILE_SERVER_MEDIA_SUBSESSION_HH
+
+#ifndef _FILE_SERVER_MEDIA_SUBSESSION_HH
+#include "FileServerMediaSubsession.hh"
+#endif
+#ifndef _MP3_ADU_INTERLEAVING_HH
+#include "MP3ADUinterleaving.hh"
+#endif
+#ifndef _MP3_ADU_HH
+#include "MP3ADU.hh"
+#endif
+
+class MP3AudioFileServerMediaSubsession: public FileServerMediaSubsession{
+public:
+  static MP3AudioFileServerMediaSubsession*
+  createNew(UsageEnvironment& env, char const* fileName, Boolean reuseFirstSource,
+	    Boolean generateADUs, Interleaving* interleaving);
+      // Note: "interleaving" is used only if "generateADUs" is True,
+      // (and a value of NULL means 'no interleaving')
+
+protected:
+  MP3AudioFileServerMediaSubsession(UsageEnvironment& env,
+				    char const* fileName, Boolean reuseFirstSource,
+				    Boolean generateADUs,
+				    Interleaving* interleaving);
+      // called only by createNew();
+  virtual ~MP3AudioFileServerMediaSubsession();
+
+  FramedSource* createNewStreamSourceCommon(FramedSource* baseMP3Source, unsigned mp3NumBytes, unsigned& estBitrate);
+  void getBaseStreams(FramedSource* frontStream,
+		      FramedSource*& sourceMP3Stream, ADUFromMP3Source*& aduStream/*if any*/);
+
+protected: // redefined virtual functions
+  virtual void seekStreamSource(FramedSource* inputSource, double& seekNPT, double streamDuration, u_int64_t& numBytes);
+  virtual void setStreamSourceScale(FramedSource* inputSource, float scale);
+  virtual FramedSource* createNewStreamSource(unsigned clientSessionId,
+					      unsigned& estBitrate);
+  virtual RTPSink* createNewRTPSink(Groupsock* rtpGroupsock,
+                                    unsigned char rtpPayloadTypeIfDynamic,
+				    FramedSource* inputSource);
+  virtual void testScaleFactor(float& scale);
+  virtual float duration() const;
+
+protected:
+  Boolean fGenerateADUs;
+  Interleaving* fInterleaving;
+  float fFileDuration;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/MP3FileSource.hh b/3rdparty/live555/src/liveMedia/include/MP3FileSource.hh
new file mode 100644
index 00000000..1fd4b2f7
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/MP3FileSource.hh
@@ -0,0 +1,71 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// MP3 File Sources
+// C++ header
+
+#ifndef _MP3_FILE_SOURCE_HH
+#define _MP3_FILE_SOURCE_HH
+
+#ifndef _FRAMED_FILE_SOURCE_HH
+#include "FramedFileSource.hh"
+#endif
+
+class MP3StreamState; // forward
+
+class MP3FileSource: public FramedFileSource {
+public:
+  static MP3FileSource* createNew(UsageEnvironment& env, char const* fileName);
+
+  float filePlayTime() const;
+  unsigned fileSize() const;
+  void setPresentationTimeScale(unsigned scale);
+  void seekWithinFile(double seekNPT, double streamDuration);
+      // if "streamDuration" is >0.0, then we limit the stream to that duration, before treating it as EOF
+
+protected:
+  MP3FileSource(UsageEnvironment& env, FILE* fid);
+	// called only by createNew()
+
+  virtual ~MP3FileSource();
+
+protected:
+  void assignStream(FILE* fid, unsigned filesize);
+  Boolean initializeStream();
+
+  MP3StreamState* streamState() {return fStreamState;}
+
+private:
+  // redefined virtual functions:
+  virtual void doGetNextFrame();
+  virtual char const* MIMEtype() const;
+  virtual void getAttributes() const;
+
+private:
+  static void fileReadableHandler(MP3FileSource* source, int mask);
+
+private:
+  MP3StreamState* fStreamState;
+  Boolean fFidIsSeekable;
+  Boolean fHaveStartedReading;
+  unsigned fHaveBeenInitialized;
+  struct timeval fFirstFramePresentationTime; // set on stream init
+  Boolean fLimitNumBytesToStream;
+  unsigned fNumBytesToStream; // used iff "fLimitNumBytesToStream" is True
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/MP3Transcoder.hh b/3rdparty/live555/src/liveMedia/include/MP3Transcoder.hh
new file mode 100644
index 00000000..ffec2402
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/MP3Transcoder.hh
@@ -0,0 +1,44 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// MP3 Transcoder
+// C++ header
+
+#ifndef _MP3_TRANSCODER_HH
+#define _MP3_TRANSCODER_HH
+
+#ifndef _MP3_ADU_HH
+#include "MP3ADU.hh"
+#endif
+#ifndef _MP3_ADU_TRANSCODER_HH
+#include "MP3ADUTranscoder.hh"
+#endif
+
+class MP3Transcoder: public MP3FromADUSource {
+public:
+  static MP3Transcoder* createNew(UsageEnvironment& env,
+				  unsigned outBitrate /* in kbps */,
+				  FramedSource* inputSource);
+
+protected:
+  MP3Transcoder(UsageEnvironment& env,
+		MP3ADUTranscoder* aduTranscoder);
+      // called only by createNew()
+  virtual ~MP3Transcoder();
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/MPEG1or2AudioRTPSink.hh b/3rdparty/live555/src/liveMedia/include/MPEG1or2AudioRTPSink.hh
new file mode 100644
index 00000000..00ef685d
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/MPEG1or2AudioRTPSink.hh
@@ -0,0 +1,48 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// RTP sink for MPEG audio (RFC 2250)
+// C++ header
+
+#ifndef _MPEG_1OR2_AUDIO_RTP_SINK_HH
+#define _MPEG_1OR2_AUDIO_RTP_SINK_HH
+
+#ifndef _AUDIO_RTP_SINK_HH
+#include "AudioRTPSink.hh"
+#endif
+
+class MPEG1or2AudioRTPSink: public AudioRTPSink {
+public:
+  static MPEG1or2AudioRTPSink* createNew(UsageEnvironment& env,
+				     Groupsock* RTPgs);
+
+protected:
+  MPEG1or2AudioRTPSink(UsageEnvironment& env, Groupsock* RTPgs);
+	// called only by createNew()
+
+  virtual ~MPEG1or2AudioRTPSink();
+
+private: // redefined virtual functions:
+  virtual void doSpecialFrameHandling(unsigned fragmentationOffset,
+                                      unsigned char* frameStart,
+                                      unsigned numBytesInFrame,
+                                      struct timeval framePresentationTime,
+                                      unsigned numRemainingBytes);
+  virtual unsigned specialHeaderSize() const;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/MPEG1or2AudioRTPSource.hh b/3rdparty/live555/src/liveMedia/include/MPEG1or2AudioRTPSource.hh
new file mode 100644
index 00000000..fa78e035
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/MPEG1or2AudioRTPSource.hh
@@ -0,0 +1,51 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// MPEG-1 or MPEG-2 Audio RTP Sources
+// C++ header
+
+#ifndef _MPEG_1OR2_AUDIO_RTP_SOURCE_HH
+#define _MPEG_1OR2_AUDIO_RTP_SOURCE_HH
+
+#ifndef _MULTI_FRAMED_RTP_SOURCE_HH
+#include "MultiFramedRTPSource.hh"
+#endif
+
+class MPEG1or2AudioRTPSource: public MultiFramedRTPSource {
+public:
+  static MPEG1or2AudioRTPSource*
+  createNew(UsageEnvironment& env, Groupsock* RTPgs,
+	    unsigned char rtpPayloadFormat = 14,
+	    unsigned rtpTimestampFrequency = 90000);
+
+protected:
+  virtual ~MPEG1or2AudioRTPSource();
+
+private:
+  MPEG1or2AudioRTPSource(UsageEnvironment& env, Groupsock* RTPgs,
+		     unsigned char rtpPayloadFormat,
+		     unsigned rtpTimestampFrequency);
+      // called only by createNew()
+
+private:
+  // redefined virtual functions:
+  virtual Boolean processSpecialHeader(BufferedPacket* packet,
+                                       unsigned& resultSpecialHeaderSize);
+  virtual char const* MIMEtype() const;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/MPEG1or2AudioStreamFramer.hh b/3rdparty/live555/src/liveMedia/include/MPEG1or2AudioStreamFramer.hh
new file mode 100644
index 00000000..244bcc5c
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/MPEG1or2AudioStreamFramer.hh
@@ -0,0 +1,70 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A filter that breaks up an MPEG (1,2) audio elementary stream into frames
+// C++ header
+
+#ifndef _MPEG_1OR2_AUDIO_STREAM_FRAMER_HH
+#define _MPEG_1OR2_AUDIO_STREAM_FRAMER_HH
+
+#ifndef _FRAMED_FILTER_HH
+#include "FramedFilter.hh"
+#endif
+
+class MPEG1or2AudioStreamFramer: public FramedFilter {
+public:
+  static MPEG1or2AudioStreamFramer*
+  createNew(UsageEnvironment& env, FramedSource* inputSource,
+	    Boolean syncWithInputSource = False);
+  // If "syncWithInputSource" is True, the stream's presentation time
+  // will be reset to that of the input source, whenever new data
+  // is read from it.
+
+  void flushInput(); // called if there is a discontinuity (seeking) in the input
+
+private:
+  MPEG1or2AudioStreamFramer(UsageEnvironment& env, FramedSource* inputSource,
+			    Boolean syncWithInputSource);
+      // called only by createNew()
+  virtual ~MPEG1or2AudioStreamFramer();
+
+  static void continueReadProcessing(void* clientData,
+				     unsigned char* ptr, unsigned size,
+				     struct timeval presentationTime);
+  void continueReadProcessing();
+
+  void resetPresentationTime(struct timeval newPresentationTime);
+      // useful if we're being synced with a separate (e.g., video) stream
+
+private:
+  // redefined virtual functions:
+  virtual void doGetNextFrame();
+
+private:
+  void reset();
+  struct timeval currentFramePlayTime() const;
+
+private:
+  Boolean fSyncWithInputSource;
+  struct timeval fNextFramePresentationTime;
+
+private: // parsing state
+  class MPEG1or2AudioStreamParser* fParser;
+  friend class MPEG1or2AudioStreamParser; // hack
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/MPEG1or2Demux.hh b/3rdparty/live555/src/liveMedia/include/MPEG1or2Demux.hh
new file mode 100644
index 00000000..a09364dd
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/MPEG1or2Demux.hh
@@ -0,0 +1,158 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// Demultiplexer for a MPEG 1 or 2 Program Stream
+// C++ header
+
+#ifndef _MPEG_1OR2_DEMUX_HH
+#define _MPEG_1OR2_DEMUX_HH
+
+#ifndef _FRAMED_SOURCE_HH
+#include "FramedSource.hh"
+#endif
+
+class MPEG1or2DemuxedElementaryStream; // forward
+
+typedef void MPEG1or2DemuxOnDeletionFunc(void* objectToNotify, class MPEG1or2Demux* demuxBeingDeleted);
+
+class MPEG1or2Demux: public Medium {
+public:
+  static MPEG1or2Demux* createNew(UsageEnvironment& env,
+				  FramedSource* inputSource,
+				  Boolean reclaimWhenLastESDies = False,
+				  MPEG1or2DemuxOnDeletionFunc* onDeletionFunc = NULL,
+				  void* objectToNotify = NULL);
+  // If "reclaimWhenLastESDies" is True, the the demux is deleted when
+  // all "MPEG1or2DemuxedElementaryStream"s that we created get deleted.
+
+  MPEG1or2DemuxedElementaryStream* newElementaryStream(u_int8_t streamIdTag);
+
+  // Specialized versions of the above for audio and video:
+  MPEG1or2DemuxedElementaryStream* newAudioStream();
+  MPEG1or2DemuxedElementaryStream* newVideoStream();
+
+  // A hack for getting raw, undemuxed PES packets from the Program Stream:
+  MPEG1or2DemuxedElementaryStream* newRawPESStream();
+
+  void getNextFrame(u_int8_t streamIdTag,
+		    unsigned char* to, unsigned maxSize,
+		    FramedSource::afterGettingFunc* afterGettingFunc,
+		    void* afterGettingClientData,
+		    FramedSource::onCloseFunc* onCloseFunc,
+		    void* onCloseClientData);
+      // similar to FramedSource::getNextFrame(), except that it also
+      // takes a stream id tag as parameter.
+
+  void stopGettingFrames(u_int8_t streamIdTag);
+      // similar to FramedSource::stopGettingFrames(), except that it also
+      // takes a stream id tag as parameter.
+
+  static void handleClosure(void* clientData);
+      // This should be called (on ourself) if the source is discovered
+      // to be closed (i.e., no longer readable)
+
+  FramedSource* inputSource() const { return fInputSource; }
+
+  class SCR {
+  public:
+    SCR();
+
+    u_int8_t highBit;
+    u_int32_t remainingBits;
+    u_int16_t extension;
+
+    Boolean isValid;
+  };
+  SCR& lastSeenSCR() { return fLastSeenSCR; }
+
+  unsigned char mpegVersion() const { return fMPEGversion; }
+
+  void flushInput(); // should be called before any 'seek' on the underlying source
+
+private:
+  MPEG1or2Demux(UsageEnvironment& env,
+		FramedSource* inputSource, Boolean reclaimWhenLastESDies,
+		MPEG1or2DemuxOnDeletionFunc* onDeletionFunc, void* objectToNotify);
+      // called only by createNew()
+  virtual ~MPEG1or2Demux();
+
+  void registerReadInterest(u_int8_t streamIdTag,
+			    unsigned char* to, unsigned maxSize,
+			    FramedSource::afterGettingFunc* afterGettingFunc,
+			    void* afterGettingClientData,
+			    FramedSource::onCloseFunc* onCloseFunc,
+			    void* onCloseClientData);
+
+  Boolean useSavedData(u_int8_t streamIdTag,
+		       unsigned char* to, unsigned maxSize,
+		       FramedSource::afterGettingFunc* afterGettingFunc,
+		       void* afterGettingClientData);
+
+  static void continueReadProcessing(void* clientData,
+				     unsigned char* ptr, unsigned size,
+				     struct timeval presentationTime);
+  void continueReadProcessing();
+
+private:
+  friend class MPEG1or2DemuxedElementaryStream;
+  void noteElementaryStreamDeletion(MPEG1or2DemuxedElementaryStream* es);
+
+private:
+  FramedSource* fInputSource;
+  SCR fLastSeenSCR;
+  unsigned char fMPEGversion;
+
+  unsigned char fNextAudioStreamNumber;
+  unsigned char fNextVideoStreamNumber;
+  Boolean fReclaimWhenLastESDies;
+  unsigned fNumOutstandingESs;
+
+  // A descriptor for each possible stream id tag:
+  typedef struct OutputDescriptor {
+    // input parameters
+    unsigned char* to; unsigned maxSize;
+    FramedSource::afterGettingFunc* fAfterGettingFunc;
+    void* afterGettingClientData;
+    FramedSource::onCloseFunc* fOnCloseFunc;
+    void* onCloseClientData;
+
+    // output parameters
+    unsigned frameSize; struct timeval presentationTime;
+    class SavedData; // forward
+    SavedData* savedDataHead;
+    SavedData* savedDataTail;
+    unsigned savedDataTotalSize;
+
+    // status parameters
+    Boolean isPotentiallyReadable;
+    Boolean isCurrentlyActive;
+    Boolean isCurrentlyAwaitingData;
+  } OutputDescriptor_t;
+  OutputDescriptor_t fOutput[256];
+
+  unsigned fNumPendingReads;
+  Boolean fHaveUndeliveredData;
+
+  MPEG1or2DemuxOnDeletionFunc* fOnDeletionFunc;
+  void* fOnDeletionObjectToNotify;
+
+private: // parsing state
+  class MPEGProgramStreamParser* fParser;
+  friend class MPEGProgramStreamParser; // hack
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/MPEG1or2DemuxedElementaryStream.hh b/3rdparty/live555/src/liveMedia/include/MPEG1or2DemuxedElementaryStream.hh
new file mode 100644
index 00000000..276abe74
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/MPEG1or2DemuxedElementaryStream.hh
@@ -0,0 +1,69 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A MPEG 1 or 2 Elementary Stream, demultiplexed from a Program Stream
+// C++ header
+
+#ifndef _MPEG_1OR2_DEMUXED_ELEMENTARY_STREAM_HH
+#define _MPEG_1OR2_DEMUXED_ELEMENTARY_STREAM_HH
+
+#ifndef _MPEG_1OR2_DEMUX_HH
+#include "MPEG1or2Demux.hh"
+#endif
+
+class MPEG1or2DemuxedElementaryStream: public FramedSource {
+public:
+  MPEG1or2Demux::SCR lastSeenSCR() const { return fLastSeenSCR; }
+
+  unsigned char mpegVersion() const { return fMPEGversion; }
+
+  MPEG1or2Demux& sourceDemux() const { return fOurSourceDemux; }
+
+private: // We are created only by a MPEG1or2Demux (a friend)
+  MPEG1or2DemuxedElementaryStream(UsageEnvironment& env,
+			      u_int8_t streamIdTag,
+			      MPEG1or2Demux& sourceDemux);
+  virtual ~MPEG1or2DemuxedElementaryStream();
+
+private:
+  // redefined virtual functions:
+  virtual void doGetNextFrame();
+  virtual void doStopGettingFrames();
+  virtual char const* MIMEtype() const;
+  virtual unsigned maxFrameSize() const;
+
+private:
+  static void afterGettingFrame(void* clientData,
+				unsigned frameSize, unsigned numTruncatedBytes,
+				struct timeval presentationTime,
+				unsigned durationInMicroseconds);
+
+  void afterGettingFrame1(unsigned frameSize, unsigned numTruncatedBytes,
+			  struct timeval presentationTime,
+			  unsigned durationInMicroseconds);
+
+private:
+  u_int8_t fOurStreamIdTag;
+  MPEG1or2Demux& fOurSourceDemux;
+  char const* fMIMEtype;
+  MPEG1or2Demux::SCR fLastSeenSCR;
+  unsigned char fMPEGversion;
+
+  friend class MPEG1or2Demux;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/MPEG1or2DemuxedServerMediaSubsession.hh b/3rdparty/live555/src/liveMedia/include/MPEG1or2DemuxedServerMediaSubsession.hh
new file mode 100644
index 00000000..fd853b95
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/MPEG1or2DemuxedServerMediaSubsession.hh
@@ -0,0 +1,63 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A 'ServerMediaSubsession' object that creates new, unicast, "RTPSink"s
+// on demand, from a MPEG-1 or 2 demuxer.
+// C++ header
+
+#ifndef _MPEG_1OR2_DEMUXED_SERVER_MEDIA_SUBSESSION_HH
+#define _MPEG_1OR2_DEMUXED_SERVER_MEDIA_SUBSESSION_HH
+
+#ifndef _ON_DEMAND_SERVER_MEDIA_SUBSESSION_HH
+#include "OnDemandServerMediaSubsession.hh"
+#endif
+#ifndef _MPEG_1OR2_FILE_SERVER_DEMUX_HH
+#include "MPEG1or2FileServerDemux.hh"
+#endif
+
+class MPEG1or2DemuxedServerMediaSubsession: public OnDemandServerMediaSubsession{
+public:
+  static MPEG1or2DemuxedServerMediaSubsession*
+  createNew(MPEG1or2FileServerDemux& demux, u_int8_t streamIdTag,
+	    Boolean reuseFirstSource,
+	    Boolean iFramesOnly = False, double vshPeriod = 5.0);
+  // The last two parameters are relevant for video streams only
+
+private:
+  MPEG1or2DemuxedServerMediaSubsession(MPEG1or2FileServerDemux& demux,
+				       u_int8_t streamIdTag, Boolean reuseFirstSource,
+				       Boolean iFramesOnly, double vshPeriod);
+      // called only by createNew();
+  virtual ~MPEG1or2DemuxedServerMediaSubsession();
+
+private: // redefined virtual functions
+  virtual void seekStreamSource(FramedSource* inputSource, double& seekNPT, double streamDuration, u_int64_t& numBytes);
+  virtual FramedSource* createNewStreamSource(unsigned clientSessionId,
+					      unsigned& estBitrate);
+  virtual RTPSink* createNewRTPSink(Groupsock* rtpGroupsock,
+                                    unsigned char rtpPayloadTypeIfDynamic,
+				    FramedSource* inputSource);
+  virtual float duration() const;
+
+private:
+  MPEG1or2FileServerDemux& fOurDemux;
+  u_int8_t fStreamIdTag;
+  Boolean fIFramesOnly; // for video streams
+  double fVSHPeriod; // for video streams
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/MPEG1or2FileServerDemux.hh b/3rdparty/live555/src/liveMedia/include/MPEG1or2FileServerDemux.hh
new file mode 100644
index 00000000..120880c8
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/MPEG1or2FileServerDemux.hh
@@ -0,0 +1,70 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A server demultiplexer for a MPEG 1 or 2 Program Stream
+// C++ header
+
+#ifndef _MPEG_1OR2_FILE_SERVER_DEMUX_HH
+#define _MPEG_1OR2_FILE_SERVER_DEMUX_HH
+
+#ifndef _SERVER_MEDIA_SESSION_HH
+#include "ServerMediaSession.hh"
+#endif
+#ifndef _MPEG_1OR2_DEMUXED_ELEMENTARY_STREAM_HH
+#include "MPEG1or2DemuxedElementaryStream.hh"
+#endif
+
+class MPEG1or2FileServerDemux: public Medium {
+public:
+  static MPEG1or2FileServerDemux*
+  createNew(UsageEnvironment& env, char const* fileName, Boolean reuseFirstSource);
+
+  ServerMediaSubsession* newAudioServerMediaSubsession(); // MPEG-1 or 2 audio
+  ServerMediaSubsession* newVideoServerMediaSubsession(Boolean iFramesOnly = False,
+						       double vshPeriod = 5.0
+		       /* how often (in seconds) to inject a Video_Sequence_Header,
+			  if one doesn't already appear in the stream */);
+  ServerMediaSubsession* newAC3AudioServerMediaSubsession(); // AC-3 audio (from VOB)
+
+  unsigned fileSize() const { return fFileSize; }
+  float fileDuration() const { return fFileDuration; }
+
+private:
+  MPEG1or2FileServerDemux(UsageEnvironment& env, char const* fileName,
+			  Boolean reuseFirstSource);
+      // called only by createNew();
+  virtual ~MPEG1or2FileServerDemux();
+
+private:
+  friend class MPEG1or2DemuxedServerMediaSubsession;
+  MPEG1or2DemuxedElementaryStream* newElementaryStream(unsigned clientSessionId,
+						       u_int8_t streamIdTag);
+
+  static void onDemuxDeletion(void* clientData, MPEG1or2Demux* demuxBeingDeleted);
+  void onDemuxDeletion(MPEG1or2Demux* demuxBeingDeleted);
+
+private:
+  char const* fFileName;
+  unsigned fFileSize;
+  float fFileDuration;
+  Boolean fReuseFirstSource;
+  MPEG1or2Demux* fSession0Demux;
+  MPEG1or2Demux* fLastCreatedDemux;
+  unsigned fLastClientSessionId;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/MPEG1or2VideoFileServerMediaSubsession.hh b/3rdparty/live555/src/liveMedia/include/MPEG1or2VideoFileServerMediaSubsession.hh
new file mode 100644
index 00000000..31505b03
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/MPEG1or2VideoFileServerMediaSubsession.hh
@@ -0,0 +1,59 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A 'ServerMediaSubsession' object that creates new, unicast, "RTPSink"s
+// on demand, from a MPEG-1 or 2 Elementary Stream video file.
+// C++ header
+
+#ifndef _MPEG_1OR2_VIDEO_FILE_SERVER_MEDIA_SUBSESSION_HH
+#define _MPEG_1OR2_VIDEO_FILE_SERVER_MEDIA_SUBSESSION_HH
+
+#ifndef _FILE_SERVER_MEDIA_SUBSESSION_HH
+#include "FileServerMediaSubsession.hh"
+#endif
+
+class MPEG1or2VideoFileServerMediaSubsession: public FileServerMediaSubsession{
+public:
+  static MPEG1or2VideoFileServerMediaSubsession*
+  createNew(UsageEnvironment& env, char const* fileName, Boolean reuseFirstSource,
+	    Boolean iFramesOnly = False,
+	    double vshPeriod = 5.0
+	    /* how often (in seconds) to inject a Video_Sequence_Header,
+	       if one doesn't already appear in the stream */);
+
+private:
+  MPEG1or2VideoFileServerMediaSubsession(UsageEnvironment& env,
+					 char const* fileName,
+					 Boolean reuseFirstSource,
+					 Boolean iFramesOnly,
+					 double vshPeriod);
+      // called only by createNew();
+  virtual ~MPEG1or2VideoFileServerMediaSubsession();
+
+private: // redefined virtual functions
+  virtual FramedSource* createNewStreamSource(unsigned clientSessionId,
+					      unsigned& estBitrate);
+  virtual RTPSink* createNewRTPSink(Groupsock* rtpGroupsock,
+                                    unsigned char rtpPayloadTypeIfDynamic,
+				    FramedSource* inputSource);
+
+private:
+  Boolean fIFramesOnly;
+  double fVSHPeriod;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/MPEG1or2VideoRTPSink.hh b/3rdparty/live555/src/liveMedia/include/MPEG1or2VideoRTPSink.hh
new file mode 100644
index 00000000..271ed932
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/MPEG1or2VideoRTPSink.hh
@@ -0,0 +1,69 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// RTP sink for MPEG video (RFC 2250)
+// C++ header
+
+#ifndef _MPEG_1OR2_VIDEO_RTP_SINK_HH
+#define _MPEG_1OR2_VIDEO_RTP_SINK_HH
+
+#ifndef _VIDEO_RTP_SINK_HH
+#include "VideoRTPSink.hh"
+#endif
+
+class MPEG1or2VideoRTPSink: public VideoRTPSink {
+public:
+  static MPEG1or2VideoRTPSink* createNew(UsageEnvironment& env, Groupsock* RTPgs);
+
+protected:
+  MPEG1or2VideoRTPSink(UsageEnvironment& env, Groupsock* RTPgs);
+	// called only by createNew()
+
+  virtual ~MPEG1or2VideoRTPSink();
+
+private: // redefined virtual functions:
+  virtual Boolean sourceIsCompatibleWithUs(MediaSource& source);
+
+  virtual void doSpecialFrameHandling(unsigned fragmentationOffset,
+                                      unsigned char* frameStart,
+                                      unsigned numBytesInFrame,
+                                      struct timeval framePresentationTime,
+                                      unsigned numRemainingBytes);
+  virtual Boolean allowFragmentationAfterStart() const;
+  virtual
+  Boolean frameCanAppearAfterPacketStart(unsigned char const* frameStart,
+					 unsigned numBytesInFrame) const;
+  virtual unsigned specialHeaderSize() const;
+
+private:
+  // MPEG video-specific state, used to decide how to fill out the
+  // video-specific header, and when to include multiple 'frames' in a
+  // single outgoing RTP packet.  Eventually we should somehow get this
+  // state from the source (MPEG1or2VideoStreamFramer) instead, as the source
+  // already has this info itself.
+  struct {
+    unsigned temporal_reference;
+    unsigned char picture_coding_type;
+    unsigned char vector_code_bits; // FBV,BFC,FFV,FFC from RFC 2250, sec. 3.4
+  } fPictureState;
+  Boolean fPreviousFrameWasSlice;
+      // used to implement frameCanAppearAfterPacketStart()
+  Boolean fSequenceHeaderPresent;
+  Boolean fPacketBeginsSlice, fPacketEndsSlice;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/MPEG1or2VideoRTPSource.hh b/3rdparty/live555/src/liveMedia/include/MPEG1or2VideoRTPSource.hh
new file mode 100644
index 00000000..6964daa6
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/MPEG1or2VideoRTPSource.hh
@@ -0,0 +1,53 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// MPEG-1 or MPEG-2 Video RTP Sources
+// C++ header
+
+#ifndef _MPEG_1OR2_VIDEO_RTP_SOURCE_HH
+#define _MPEG_1OR2_VIDEO_RTP_SOURCE_HH
+
+#ifndef _MULTI_FRAMED_RTP_SOURCE_HH
+#include "MultiFramedRTPSource.hh"
+#endif
+
+class MPEG1or2VideoRTPSource: public MultiFramedRTPSource {
+public:
+  static MPEG1or2VideoRTPSource*
+  createNew(UsageEnvironment& env, Groupsock* RTPgs,
+	    unsigned char rtpPayloadFormat = 32,
+	    unsigned rtpPayloadFrequency = 90000);
+
+protected:
+  virtual ~MPEG1or2VideoRTPSource();
+
+private:
+  MPEG1or2VideoRTPSource(UsageEnvironment& env, Groupsock* RTPgs,
+		     unsigned char rtpPayloadFormat,
+		     unsigned rtpTimestampFrequency);
+      // called only by createNew()
+
+private:
+  // redefined virtual functions:
+  virtual Boolean processSpecialHeader(BufferedPacket* packet,
+                                       unsigned& resultSpecialHeaderSize);
+  virtual Boolean packetIsUsableInJitterCalculation(unsigned char* packet,
+						    unsigned packetSize);
+  virtual char const* MIMEtype() const;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/MPEG1or2VideoStreamDiscreteFramer.hh b/3rdparty/live555/src/liveMedia/include/MPEG1or2VideoStreamDiscreteFramer.hh
new file mode 100644
index 00000000..43f3bc7d
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/MPEG1or2VideoStreamDiscreteFramer.hh
@@ -0,0 +1,76 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A simplified version of "MPEG1or2VideoStreamFramer" that takes only
+// complete, discrete frames (rather than an arbitrary byte stream) as input.
+// This avoids the parsing and data copying overhead of the full
+// "MPEG1or2VideoStreamFramer".
+// C++ header
+
+#ifndef _MPEG1or2_VIDEO_STREAM_DISCRETE_FRAMER_HH
+#define _MPEG1or2_VIDEO_STREAM_DISCRETE_FRAMER_HH
+
+#ifndef _MPEG1or2_VIDEO_STREAM_FRAMER_HH
+#include "MPEG1or2VideoStreamFramer.hh"
+#endif
+
+#define VSH_MAX_SIZE 1000
+
+class MPEG1or2VideoStreamDiscreteFramer: public MPEG1or2VideoStreamFramer {
+public:
+  static MPEG1or2VideoStreamDiscreteFramer*
+  createNew(UsageEnvironment& env, FramedSource* inputSource,
+            Boolean iFramesOnly = False, // see MPEG1or2VideoStreamFramer.hh
+            double vshPeriod = 5.0, // see MPEG1or2VideoStreamFramer.hh
+	    Boolean leavePresentationTimesUnmodified = False);
+
+protected:
+  MPEG1or2VideoStreamDiscreteFramer(UsageEnvironment& env,
+                                    FramedSource* inputSource,
+                                    Boolean iFramesOnly, double vshPeriod, Boolean leavePresentationTimesUnmodified);
+  // called only by createNew()
+  virtual ~MPEG1or2VideoStreamDiscreteFramer();
+
+protected:
+  // redefined virtual functions:
+  virtual void doGetNextFrame();
+
+protected:
+  static void afterGettingFrame(void* clientData, unsigned frameSize,
+                                unsigned numTruncatedBytes,
+                                struct timeval presentationTime,
+                                unsigned durationInMicroseconds);
+  void afterGettingFrame1(unsigned frameSize,
+                          unsigned numTruncatedBytes,
+                          struct timeval presentationTime,
+                          unsigned durationInMicroseconds);
+
+protected:
+  Boolean fLeavePresentationTimesUnmodified;
+  struct timeval fLastNonBFramePresentationTime;
+  unsigned fLastNonBFrameTemporal_reference;
+
+  // A saved copy of the most recently seen 'video_sequence_header',
+  // in case we need to insert it into the stream periodically:
+  unsigned char fSavedVSHBuffer[VSH_MAX_SIZE];
+  unsigned fSavedVSHSize;
+  double fSavedVSHTimestamp;
+  Boolean fIFramesOnly;
+  double fVSHPeriod;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/MPEG1or2VideoStreamFramer.hh b/3rdparty/live555/src/liveMedia/include/MPEG1or2VideoStreamFramer.hh
new file mode 100644
index 00000000..e4c62d53
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/MPEG1or2VideoStreamFramer.hh
@@ -0,0 +1,56 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A filter that breaks up an MPEG 1 or 2 video elementary stream into
+//   frames for: Video_Sequence_Header, GOP_Header, Picture_Header
+// C++ header
+
+#ifndef _MPEG_1OR2_VIDEO_STREAM_FRAMER_HH
+#define _MPEG_1OR2_VIDEO_STREAM_FRAMER_HH
+
+#ifndef _MPEG_VIDEO_STREAM_FRAMER_HH
+#include "MPEGVideoStreamFramer.hh"
+#endif
+
+class MPEG1or2VideoStreamFramer: public MPEGVideoStreamFramer {
+public:
+  static MPEG1or2VideoStreamFramer*
+      createNew(UsageEnvironment& env, FramedSource* inputSource,
+		Boolean iFramesOnly = False,
+		double vshPeriod = 5.0
+		/* how often (in seconds) to inject a Video_Sequence_Header,
+		   if one doesn't already appear in the stream */);
+
+protected:
+  MPEG1or2VideoStreamFramer(UsageEnvironment& env,
+			    FramedSource* inputSource,
+			    Boolean iFramesOnly, double vshPeriod,
+			    Boolean createParser = True);
+      // called only by createNew(), or by subclass constructors
+  virtual ~MPEG1or2VideoStreamFramer();
+
+private:
+  // redefined virtual functions:
+  virtual Boolean isMPEG1or2VideoStreamFramer() const;
+
+private:
+  double getCurrentPTS() const;
+
+  friend class MPEG1or2VideoStreamParser; // hack
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/MPEG2IndexFromTransportStream.hh b/3rdparty/live555/src/liveMedia/include/MPEG2IndexFromTransportStream.hh
new file mode 100644
index 00000000..3ea0ba1f
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/MPEG2IndexFromTransportStream.hh
@@ -0,0 +1,95 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A filter that produces a sequence of I-frame indices from a MPEG-2 Transport Stream
+// C++ header
+
+#ifndef _MPEG2_IFRAME_INDEX_FROM_TRANSPORT_STREAM_HH
+#define _MPEG2_IFRAME_INDEX_FROM_TRANSPORT_STREAM_HH
+
+#ifndef _FRAMED_FILTER_HH
+#include "FramedFilter.hh"
+#endif
+
+#ifndef TRANSPORT_PACKET_SIZE
+#define TRANSPORT_PACKET_SIZE 188
+#endif
+
+#ifndef MAX_PES_PACKET_SIZE
+#define MAX_PES_PACKET_SIZE 65536
+#endif
+
+class IndexRecord; // forward
+
+class MPEG2IFrameIndexFromTransportStream: public FramedFilter {
+public:
+  static MPEG2IFrameIndexFromTransportStream*
+  createNew(UsageEnvironment& env, FramedSource* inputSource);
+
+protected:
+  MPEG2IFrameIndexFromTransportStream(UsageEnvironment& env,
+				      FramedSource* inputSource);
+      // called only by createNew()
+  virtual ~MPEG2IFrameIndexFromTransportStream();
+
+private:
+  // Redefined virtual functions:
+  virtual void doGetNextFrame();
+
+private:
+  static void afterGettingFrame(void* clientData, unsigned frameSize,
+				unsigned numTruncatedBytes,
+				struct timeval presentationTime,
+				unsigned durationInMicroseconds);
+  void afterGettingFrame1(unsigned frameSize,
+			  unsigned numTruncatedBytes,
+			  struct timeval presentationTime,
+			  unsigned durationInMicroseconds);
+
+  static void handleInputClosure(void* clientData);
+  void handleInputClosure1();
+
+  void analyzePAT(unsigned char* pkt, unsigned size);
+  void analyzePMT(unsigned char* pkt, unsigned size);
+
+  Boolean deliverIndexRecord();
+  Boolean parseFrame();
+  Boolean parseToNextCode(unsigned char& nextCode);
+  void compactParseBuffer();
+  void addToTail(IndexRecord* newIndexRecord);
+
+private:
+  Boolean fIsH264; // True iff the video is H.264 (encapsulated in a Transport Stream)
+  Boolean fIsH265; // True iff the video is H.265 (encapsulated in a Transport Stream)
+  unsigned long fInputTransportPacketCounter;
+  unsigned fClosureNumber;
+  u_int8_t fLastContinuityCounter;
+  float fFirstPCR, fLastPCR;
+  Boolean fHaveSeenFirstPCR;
+  u_int16_t fPMT_PID, fVideo_PID;
+      // Note: We assume: 1 program per Transport Stream; 1 video stream per program
+  unsigned char fInputBuffer[TRANSPORT_PACKET_SIZE];
+  unsigned char* fParseBuffer;
+  unsigned fParseBufferSize;
+  unsigned fParseBufferFrameStart;
+  unsigned fParseBufferParseEnd;
+  unsigned fParseBufferDataEnd;
+  IndexRecord* fHeadIndexRecord;
+  IndexRecord* fTailIndexRecord;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/MPEG2TransportFileServerMediaSubsession.hh b/3rdparty/live555/src/liveMedia/include/MPEG2TransportFileServerMediaSubsession.hh
new file mode 100644
index 00000000..a68c1a6b
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/MPEG2TransportFileServerMediaSubsession.hh
@@ -0,0 +1,131 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A 'ServerMediaSubsession' object that creates new, unicast, "RTPSink"s
+// on demand, from a MPEG-2 Transport Stream file.
+// C++ header
+
+#ifndef _MPEG2_TRANSPORT_FILE_SERVER_MEDIA_SUBSESSION_HH
+#define _MPEG2_TRANSPORT_FILE_SERVER_MEDIA_SUBSESSION_HH
+
+#ifndef _FILE_SERVER_MEDIA_SUBSESSION_HH
+#include "FileServerMediaSubsession.hh"
+#endif
+#ifndef _MPEG2_TRANSPORT_STREAM_FRAMER_HH
+#include "MPEG2TransportStreamFramer.hh"
+#endif
+#ifndef _BYTE_STREAM_FILE_SOURCE_HH
+#include "ByteStreamFileSource.hh"
+#endif
+#ifndef _MPEG2_TRANSPORT_STREAM_TRICK_MODE_FILTER_HH
+#include "MPEG2TransportStreamTrickModeFilter.hh"
+#endif
+#ifndef _MPEG2_TRANSPORT_STREAM_FROM_ES_SOURCE_HH
+#include "MPEG2TransportStreamFromESSource.hh"
+#endif
+
+class ClientTrickPlayState; // forward
+
+class MPEG2TransportFileServerMediaSubsession: public FileServerMediaSubsession {
+public:
+  static MPEG2TransportFileServerMediaSubsession*
+  createNew(UsageEnvironment& env,
+	    char const* dataFileName, char const* indexFileName,
+	    Boolean reuseFirstSource);
+
+protected:
+  MPEG2TransportFileServerMediaSubsession(UsageEnvironment& env,
+					  char const* fileName,
+					  MPEG2TransportStreamIndexFile* indexFile,
+					  Boolean reuseFirstSource);
+      // called only by createNew();
+  virtual ~MPEG2TransportFileServerMediaSubsession();
+
+  virtual ClientTrickPlayState* newClientTrickPlayState();
+
+private: // redefined virtual functions
+  // Note that because - to implement 'trick play' operations - we're operating on
+  // more than just the input source, we reimplement some functions that are
+  // already implemented in "OnDemandServerMediaSubsession", rather than
+  // reimplementing "seekStreamSource()" and "setStreamSourceScale()":
+  virtual void startStream(unsigned clientSessionId, void* streamToken,
+                           TaskFunc* rtcpRRHandler,
+                           void* rtcpRRHandlerClientData,
+                           unsigned short& rtpSeqNum,
+                           unsigned& rtpTimestamp,
+			   ServerRequestAlternativeByteHandler* serverRequestAlternativeByteHandler,
+                           void* serverRequestAlternativeByteHandlerClientData);
+  virtual void pauseStream(unsigned clientSessionId, void* streamToken);
+  virtual void seekStream(unsigned clientSessionId, void* streamToken, double& seekNPT, double streamDuration, u_int64_t& numBytes);
+  virtual void setStreamScale(unsigned clientSessionId, void* streamToken, float scale);
+  virtual void deleteStream(unsigned clientSessionId, void*& streamToken);
+
+  // The virtual functions that are usually implemented by "ServerMediaSubsession"s:
+  virtual FramedSource* createNewStreamSource(unsigned clientSessionId,
+					      unsigned& estBitrate);
+  virtual RTPSink* createNewRTPSink(Groupsock* rtpGroupsock,
+                                    unsigned char rtpPayloadTypeIfDynamic,
+				    FramedSource* inputSource);
+
+  virtual void testScaleFactor(float& scale);
+  virtual float duration() const;
+
+private:
+  ClientTrickPlayState* lookupClient(unsigned clientSessionId);
+
+private:
+  MPEG2TransportStreamIndexFile* fIndexFile;
+  float fDuration;
+  HashTable* fClientSessionHashTable; // indexed by client session id
+};
+
+
+// This class encapsulates the 'trick play' state for each current client (for
+// a given "MPEG2TransportFileServerMediaSubsession" - i.e., Transport Stream file).
+// It is used only within the implementation of "MPEG2TransportFileServerMediaSubsession", but is included here,
+// in case subclasses of "MPEG2TransportFileServerMediaSubsession" want to use it.
+
+class ClientTrickPlayState {
+public:
+  ClientTrickPlayState(MPEG2TransportStreamIndexFile* indexFile);
+
+  // Functions to bring "fNPT", "fTSRecordNum" and "fIxRecordNum" in sync:
+  unsigned long updateStateFromNPT(double npt, double seekDuration);
+  void updateStateOnScaleChange();
+  void updateStateOnPlayChange(Boolean reverseToPreviousVSH);
+
+  void handleStreamDeletion();
+  void setSource(MPEG2TransportStreamFramer* framer);
+
+  void setNextScale(float nextScale) { fNextScale = nextScale; }
+  Boolean areChangingScale() const { return fNextScale != fScale; }
+
+protected:
+  void updateTSRecordNum();
+  void reseekOriginalTransportStreamSource();
+
+protected:
+  MPEG2TransportStreamIndexFile* fIndexFile;
+  ByteStreamFileSource* fOriginalTransportStreamSource;
+  MPEG2TransportStreamTrickModeFilter* fTrickModeFilter;
+  MPEG2TransportStreamFromESSource* fTrickPlaySource;
+  MPEG2TransportStreamFramer* fFramer;
+  float fScale, fNextScale, fNPT;
+  unsigned long fTSRecordNum, fIxRecordNum;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/MPEG2TransportStreamAccumulator.hh b/3rdparty/live555/src/liveMedia/include/MPEG2TransportStreamAccumulator.hh
new file mode 100644
index 00000000..5200f20b
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/MPEG2TransportStreamAccumulator.hh
@@ -0,0 +1,60 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// Collects a stream of incoming MPEG Transport Stream packets into
+//  a chunk sufficiently large to send in a single outgoing (RTP or UDP) packet.
+// C++ header
+
+#ifndef _MPEG2_TRANSPORT_STREAM_ACCUMULATOR_HH
+#define _MPEG2_TRANSPORT_STREAM_ACCUMULATOR_HH
+
+#ifndef _FRAMED_FILTER_HH
+#include "FramedFilter.hh"
+#endif
+
+class MPEG2TransportStreamAccumulator: public FramedFilter {
+public:
+  static MPEG2TransportStreamAccumulator* createNew(UsageEnvironment& env,
+						    FramedSource* inputSource,
+						    unsigned maxPacketSize = 1456);
+
+protected:
+  MPEG2TransportStreamAccumulator(UsageEnvironment& env,
+				  FramedSource* inputSource, unsigned maxPacketSize);
+      // called only by createNew()
+  virtual ~MPEG2TransportStreamAccumulator();
+
+private:
+  // redefined virtual functions:
+  virtual void doGetNextFrame();
+
+private:
+  static void afterGettingFrame(void* clientData, unsigned frameSize,
+                                unsigned numTruncatedBytes,
+                                struct timeval presentationTime,
+                                unsigned durationInMicroseconds);
+  void afterGettingFrame1(unsigned frameSize,
+                          unsigned numTruncatedBytes,
+                          struct timeval presentationTime,
+                          unsigned durationInMicroseconds);
+
+private:
+  unsigned const fDesiredPacketSize;
+  unsigned fNumBytesGathered;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/MPEG2TransportStreamDemux.hh b/3rdparty/live555/src/liveMedia/include/MPEG2TransportStreamDemux.hh
new file mode 100644
index 00000000..11cc570e
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/MPEG2TransportStreamDemux.hh
@@ -0,0 +1,50 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// Demultiplexer for a MPEG Transport Stream
+// C++ header
+
+#ifndef _MPEG2_TRANSPORT_STREAM_DEMUX_HH
+#define _MPEG2_TRANSPORT_STREAM_DEMUX_HH
+
+#ifndef _FRAMED_SOURCE_HH
+#include "FramedSource.hh"
+#endif
+
+class MPEG2TransportStreamDemux: public Medium {
+public:
+  static MPEG2TransportStreamDemux* createNew(UsageEnvironment& env,
+					      FramedSource* inputSource,
+					      FramedSource::onCloseFunc* onCloseFunc,
+					      void* onCloseClientData);
+
+private:
+  MPEG2TransportStreamDemux(UsageEnvironment& env, FramedSource* inputSource,
+			    FramedSource::onCloseFunc* onCloseFunc, void* onCloseClientData);
+      // called only by createNew()
+  virtual ~MPEG2TransportStreamDemux();
+
+  static void handleEndOfFile(void* clientData);
+  void handleEndOfFile();
+
+private:
+  class MPEG2TransportStreamParser* fParser;
+  FramedSource::onCloseFunc* fOnCloseFunc;
+  void* fOnCloseClientData;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/MPEG2TransportStreamFramer.hh b/3rdparty/live555/src/liveMedia/include/MPEG2TransportStreamFramer.hh
new file mode 100644
index 00000000..7b953c95
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/MPEG2TransportStreamFramer.hh
@@ -0,0 +1,78 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A filter that passes through (unchanged) chunks that contain an integral number
+// of MPEG-2 Transport Stream packets, but returning (in "fDurationInMicroseconds")
+// an updated estimate of the time gap between chunks.
+// C++ header
+
+#ifndef _MPEG2_TRANSPORT_STREAM_FRAMER_HH
+#define _MPEG2_TRANSPORT_STREAM_FRAMER_HH
+
+#ifndef _FRAMED_FILTER_HH
+#include "FramedFilter.hh"
+#endif
+
+#ifndef _HASH_TABLE_HH
+#include "HashTable.hh"
+#endif
+
+class MPEG2TransportStreamFramer: public FramedFilter {
+public:
+  static MPEG2TransportStreamFramer*
+  createNew(UsageEnvironment& env, FramedSource* inputSource);
+
+  u_int64_t tsPacketCount() const { return fTSPacketCount; }
+
+  void changeInputSource(FramedSource* newInputSource) { fInputSource = newInputSource; }
+
+  void clearPIDStatusTable();
+  void setNumTSPacketsToStream(unsigned long numTSRecordsToStream);
+  void setPCRLimit(float pcrLimit);
+
+protected:
+  MPEG2TransportStreamFramer(UsageEnvironment& env, FramedSource* inputSource);
+      // called only by createNew()
+  virtual ~MPEG2TransportStreamFramer();
+
+private:
+  // Redefined virtual functions:
+  virtual void doGetNextFrame();
+  virtual void doStopGettingFrames();
+
+private:
+  static void afterGettingFrame(void* clientData, unsigned frameSize,
+				unsigned numTruncatedBytes,
+				struct timeval presentationTime,
+				unsigned durationInMicroseconds);
+  void afterGettingFrame1(unsigned frameSize,
+			  struct timeval presentationTime);
+
+  Boolean updateTSPacketDurationEstimate(unsigned char* pkt, double timeNow);
+
+private:
+  u_int64_t fTSPacketCount;
+  double fTSPacketDurationEstimate;
+  HashTable* fPIDStatusTable;
+  u_int64_t fTSPCRCount;
+  Boolean fLimitNumTSPacketsToStream;
+  unsigned long fNumTSPacketsToStream; // used iff "fLimitNumTSPacketsToStream" is True
+  Boolean fLimitTSPacketsToStreamByPCR;
+  float fPCRLimit; // used iff "fLimitTSPacketsToStreamByPCR" is True
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/MPEG2TransportStreamFromESSource.hh b/3rdparty/live555/src/liveMedia/include/MPEG2TransportStreamFromESSource.hh
new file mode 100644
index 00000000..ffb94862
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/MPEG2TransportStreamFromESSource.hh
@@ -0,0 +1,66 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A filter for converting one or more MPEG Elementary Streams
+// to a MPEG-2 Transport Stream
+// C++ header
+
+#ifndef _MPEG2_TRANSPORT_STREAM_FROM_ES_SOURCE_HH
+#define _MPEG2_TRANSPORT_STREAM_FROM_ES_SOURCE_HH
+
+#ifndef _MPEG2_TRANSPORT_STREAM_MULTIPLEXOR_HH
+#include "MPEG2TransportStreamMultiplexor.hh"
+#endif
+
+class MPEG2TransportStreamFromESSource: public MPEG2TransportStreamMultiplexor {
+public:
+  static MPEG2TransportStreamFromESSource* createNew(UsageEnvironment& env);
+
+  void addNewVideoSource(FramedSource* inputSource, int mpegVersion, int16_t PID = -1);
+      // Note: For MPEG-4 video, set "mpegVersion" to 4; for H.264 video, set "mpegVersion" to 5;
+      //     for H.265 video, set "mpegVersion" to 6
+  void addNewAudioSource(FramedSource* inputSource, int mpegVersion, int16_t PID = -1);
+      // Note: For Opus audio, set "mpegVersion" to 3
+  
+      // Note: In these functions, if "PID" is not -1, then it (currently, just the low 8 bits)
+      // is used as the stream's PID.  Otherwise (if "PID" is -1) the 'stream_id' is used as
+      // the PID.
+
+  static unsigned maxInputESFrameSize;
+
+protected:
+  MPEG2TransportStreamFromESSource(UsageEnvironment& env);
+      // called only by createNew()
+  virtual ~MPEG2TransportStreamFromESSource();
+
+  void addNewInputSource(FramedSource* inputSource,
+			 u_int8_t streamId, int mpegVersion, int16_t PID = -1);
+  // used to implement addNew*Source() above
+
+private:
+  // Redefined virtual functions:
+  virtual void doStopGettingFrames();
+  virtual void awaitNewBuffer(unsigned char* oldBuffer);
+
+private:
+  friend class InputESSourceRecord;
+  class InputESSourceRecord* fInputSources;
+  unsigned fVideoSourceCounter, fAudioSourceCounter;
+  Boolean fAwaitingBackgroundDelivery;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/MPEG2TransportStreamFromPESSource.hh b/3rdparty/live555/src/liveMedia/include/MPEG2TransportStreamFromPESSource.hh
new file mode 100644
index 00000000..87044ed8
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/MPEG2TransportStreamFromPESSource.hh
@@ -0,0 +1,62 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A filter for converting a stream of MPEG PES packets to a MPEG-2 Transport Stream
+// C++ header
+
+#ifndef _MPEG2_TRANSPORT_STREAM_FROM_PES_SOURCE_HH
+#define _MPEG2_TRANSPORT_STREAM_FROM_PES_SOURCE_HH
+
+#ifndef _MPEG2_TRANSPORT_STREAM_MULTIPLEXOR_HH
+#include "MPEG2TransportStreamMultiplexor.hh"
+#endif
+#ifndef _MPEG_1OR2_DEMUXED_ELEMENTARY_STREAM_HH
+#include "MPEG1or2DemuxedElementaryStream.hh"
+#endif
+
+class MPEG2TransportStreamFromPESSource: public MPEG2TransportStreamMultiplexor {
+public:
+  static MPEG2TransportStreamFromPESSource*
+  createNew(UsageEnvironment& env, MPEG1or2DemuxedElementaryStream* inputSource);
+
+protected:
+  MPEG2TransportStreamFromPESSource(UsageEnvironment& env,
+				    MPEG1or2DemuxedElementaryStream* inputSource);
+      // called only by createNew()
+  virtual ~MPEG2TransportStreamFromPESSource();
+
+private:
+  // Redefined virtual functions:
+  virtual void doStopGettingFrames();
+  virtual void awaitNewBuffer(unsigned char* oldBuffer);
+
+private:
+  static void afterGettingFrame(void* clientData, unsigned frameSize,
+				unsigned numTruncatedBytes,
+				struct timeval presentationTime,
+				unsigned durationInMicroseconds);
+  void afterGettingFrame1(unsigned frameSize,
+			  unsigned numTruncatedBytes,
+			  struct timeval presentationTime,
+			  unsigned durationInMicroseconds);
+
+private:
+  MPEG1or2DemuxedElementaryStream* fInputSource;
+  unsigned char* fInputBuffer;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/MPEG2TransportStreamIndexFile.hh b/3rdparty/live555/src/liveMedia/include/MPEG2TransportStreamIndexFile.hh
new file mode 100644
index 00000000..b21d108c
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/MPEG2TransportStreamIndexFile.hh
@@ -0,0 +1,96 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A class that encapsulates MPEG-2 Transport Stream 'index files'/
+// These index files are used to implement 'trick play' operations
+// (seek-by-time, fast forward, reverse play) on Transport Stream files.
+//
+// C++ header
+
+#ifndef _MPEG2_TRANSPORT_STREAM_INDEX_FILE_HH
+#define _MPEG2_TRANSPORT_STREAM_INDEX_FILE_HH
+
+#ifndef _MEDIA_HH
+#include "Media.hh"
+#endif
+
+#define INDEX_RECORD_SIZE 11
+
+class MPEG2TransportStreamIndexFile: public Medium {
+public:
+  static MPEG2TransportStreamIndexFile* createNew(UsageEnvironment& env,
+						  char const* indexFileName);
+
+  virtual ~MPEG2TransportStreamIndexFile();
+
+  // Functions that map between a playing time and a Transport packet number
+  // in the original Transport Stream file:
+
+  void lookupTSPacketNumFromNPT(float& npt, unsigned long& tsPacketNumber,
+			    unsigned long& indexRecordNumber);
+    // Looks up the Transport Stream Packet number corresponding to "npt".
+	// (This may modify "npt" to a more exact value.)
+        // (We also return the index record number that we looked up.)
+
+  void lookupPCRFromTSPacketNum(unsigned long& tsPacketNumber, Boolean reverseToPreviousCleanPoint,
+				float& pcr, unsigned long& indexRecordNumber);
+    // Looks up the PCR timestamp for the transport packet "tsPacketNumber".
+	// (Adjust "tsPacketNumber" only if "reverseToPreviousCleanPoint" is True.)
+        // (We also return the index record number that we looked up.)
+
+  // Miscellaneous functions used to implement 'trick play':
+  Boolean readIndexRecordValues(unsigned long indexRecordNum,
+				unsigned long& transportPacketNum, u_int8_t& offset,
+				u_int8_t& size, float& pcr, u_int8_t& recordType);
+  float getPlayingDuration();
+  void stopReading() { closeFid(); }
+
+  int mpegVersion();
+      // returns the best guess for the version of MPEG being used for data within the underlying Transport Stream file.
+      // (1,2,4, or 5 (representing H.264).  0 means 'don't know' (usually because the index file is empty))
+
+private:
+  MPEG2TransportStreamIndexFile(UsageEnvironment& env, char const* indexFileName);
+
+  Boolean openFid();
+  Boolean seekToIndexRecord(unsigned long indexRecordNumber);
+  Boolean readIndexRecord(unsigned long indexRecordNum); // into "fBuf"
+  Boolean readOneIndexRecord(unsigned long indexRecordNum); // closes "fFid" at end
+  void closeFid();
+
+  u_int8_t recordTypeFromBuf() { return fBuf[0]; }
+  u_int8_t offsetFromBuf() { return fBuf[1]; }
+  u_int8_t sizeFromBuf() { return fBuf[2]; }
+  float pcrFromBuf(); // after "fBuf" has been read
+  unsigned long tsPacketNumFromBuf();
+  void setMPEGVersionFromRecordType(u_int8_t recordType);
+
+  Boolean rewindToCleanPoint(unsigned long&ixFound);
+      // used to implement "lookupTSPacketNumber()"
+
+private:
+  char* fFileName;
+  FILE* fFid; // used internally when reading from the file
+  int fMPEGVersion;
+  unsigned long fCurrentIndexRecordNum; // within "fFid"
+  float fCachedPCR;
+  unsigned long fCachedTSPacketNumber, fCachedIndexRecordNumber;
+  unsigned long fNumIndexRecords;
+  unsigned char fBuf[INDEX_RECORD_SIZE]; // used for reading index records from file
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/MPEG2TransportStreamMultiplexor.hh b/3rdparty/live555/src/liveMedia/include/MPEG2TransportStreamMultiplexor.hh
new file mode 100644
index 00000000..e623ecca
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/MPEG2TransportStreamMultiplexor.hh
@@ -0,0 +1,120 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A class for generating MPEG-2 Transport Stream from one or more input
+// Elementary Stream data sources
+// C++ header
+
+#ifndef _MPEG2_TRANSPORT_STREAM_MULTIPLEXOR_HH
+#define _MPEG2_TRANSPORT_STREAM_MULTIPLEXOR_HH
+
+#ifndef _FRAMED_SOURCE_HH
+#include "FramedSource.hh"
+#endif
+#ifndef _MPEG_1OR2_DEMUX_HH
+#include "MPEG1or2Demux.hh" // for SCR
+#endif
+
+#define PID_TABLE_SIZE 0x2000 // 2^13
+
+class MPEG2TransportStreamMultiplexor: public FramedSource {
+public:
+  typedef void (onEndOfSegmentFunc)(void* clientData, double segmentDuration);
+  void setTimedSegmentation(unsigned segmentationDuration,
+			    onEndOfSegmentFunc* onEndOfSegmentFunc = NULL,
+			    void* onEndOfSegmentClientData = NULL);
+      // Specifies that PAT and PMT packets should be output every "segmentationDuration" seconds.
+      // (If "segmentationDuration" is 0 (the default value), then PAT and PMT packets are output
+      // at a preset frequency.)
+      // The optional function "onEndOfSegmentFunc" is called after each segment is output.
+  double currentSegmentDuration() const { return fCurrentSegmentDuration; }
+      // Valid only if "setTimedSegmentation()" was previously called with "segmentationDuration" > 0
+
+  Boolean canDeliverNewFrameImmediately() const { return fInputBufferBytesUsed < fInputBufferSize; }
+      // Can be used by a downstream reader to test whether the next call to "doGetNextFrame()"
+      // will deliver data immediately).
+
+protected:
+  MPEG2TransportStreamMultiplexor(UsageEnvironment& env);
+  virtual ~MPEG2TransportStreamMultiplexor();
+
+  virtual void awaitNewBuffer(unsigned char* oldBuffer) = 0;
+      // implemented by subclasses
+
+  void handleNewBuffer(unsigned char* buffer, unsigned bufferSize,
+		       int mpegVersion, MPEG1or2Demux::SCR scr, int16_t PID = -1);
+      // called by "awaitNewBuffer()"
+      // Note: For MPEG-4 video, set "mpegVersion" to 4; for H.264 video, set "mpegVersion" to 5;
+      //     for H.265 video, set "mpegVersion" to 6.
+      //     For Opus audio, set "mpegVersion" to 3.
+      // The buffer is assumed to be a PES packet, with a proper PES header.
+      // If "PID" is not -1, then it (currently, only the low 8 bits) is used as the stream's PID,
+      // otherwise the "stream_id" in the PES header is reused to be the stream's PID.
+
+private:
+  // Redefined virtual functions:
+  virtual Boolean isMPEG2TransportStreamMultiplexor() const;
+  virtual void doGetNextFrame();
+
+private:
+  void deliverDataToClient(u_int16_t pid, unsigned char* buffer, unsigned bufferSize,
+			   unsigned& startPositionInBuffer);
+
+  void deliverPATPacket();
+  void deliverPMTPacket(Boolean hasChanged);
+
+  void setProgramStreamMap(unsigned frameSize);
+
+protected:
+  Boolean fHaveVideoStreams;
+
+private:
+  unsigned fOutgoingPacketCounter;
+  unsigned fProgramMapVersion;
+  u_int8_t fPreviousInputProgramMapVersion, fCurrentInputProgramMapVersion;
+      // These two fields are used if we see "program_stream_map"s in the input.
+  struct {
+    unsigned counter;
+    u_int8_t streamType; // for use in Program Maps
+  } fPIDState[PID_TABLE_SIZE];
+  u_int16_t fPCR_PID, fCurrentPID; // only the low 13 bits are used
+  MPEG1or2Demux::SCR fPCR;
+  unsigned char* fInputBuffer;
+  unsigned fInputBufferSize, fInputBufferBytesUsed;
+  Boolean fIsFirstAdaptationField;
+  unsigned fSegmentationDuration;
+      // if nonzero, this is the number of seconds between successive 'segments'.  Each 'segment'
+      // begins with a PAT, followed by a PMT.
+      // if zero (the default value), then the frequency of PATs and PMTs depends on the constants
+      // PAT_PERIOD_IF_UNTIMED and PMT_PERIOD_IF_UNTIMED, defined in the .cpp file.
+  Boolean segmentationIsTimed() const { return fSegmentationDuration > 0; }
+  u_int8_t fSegmentationIndication;
+      // used only if fSegmentationDuration > 0:
+      // 1 if a segment has just ended and the next packet is to be a PAT
+      // 2 if a segment has just ended and the following PAT has been sent; a PMT is next
+      // 0 otherwise
+  double fCurrentSegmentDuration, fPreviousPTS; // used only if fSegmentationDuration > 0
+  onEndOfSegmentFunc* fOnEndOfSegmentFunc; // used only if fSegmentationDuration > 0
+  void* fOnEndOfSegmentClientData; // ditto
+};
+
+
+// The CRC calculation function that Transport Streams use.  We make this function public
+// here in case it's useful elsewhere:
+u_int32_t calculateCRC(u_int8_t const* data, unsigned dataLength, u_int32_t initialValue = 0xFFFFFFFF);
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/MPEG2TransportStreamTrickModeFilter.hh b/3rdparty/live555/src/liveMedia/include/MPEG2TransportStreamTrickModeFilter.hh
new file mode 100644
index 00000000..b8f5c3a5
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/MPEG2TransportStreamTrickModeFilter.hh
@@ -0,0 +1,99 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.// A filter that converts a MPEG Transport Stream file - with corresponding index file
+// - to a corresponding Video Elementary Stream.  It also uses a "scale" parameter
+// to implement 'trick mode' (fast forward or reverse play, using I-frames) on
+// the video stream.
+// C++ header
+
+#ifndef _MPEG2_TRANSPORT_STREAM_TRICK_MODE_FILTER_HH
+#define _MPEG2_TRANSPORT_STREAM_TRICK_MODE_FILTER_HH
+
+#ifndef _FRAMED_FILTER_HH
+#include "FramedFilter.hh"
+#endif
+
+#ifndef _MPEG2_TRANSPORT_STREAM_INDEX_FILE_HH
+#include "MPEG2TransportStreamIndexFile.hh"
+#endif
+
+#ifndef TRANSPORT_PACKET_SIZE
+#define TRANSPORT_PACKET_SIZE 188
+#endif
+
+class MPEG2TransportStreamTrickModeFilter: public FramedFilter {
+public:
+  static MPEG2TransportStreamTrickModeFilter*
+  createNew(UsageEnvironment& env, FramedSource* inputSource,
+	    MPEG2TransportStreamIndexFile* indexFile, int scale);
+
+  Boolean seekTo(unsigned long tsPacketNumber, unsigned long indexRecordNumber);
+
+  unsigned long nextIndexRecordNum() const { return fNextIndexRecordNum; }
+
+  void forgetInputSource() { fInputSource = NULL; }
+      // this lets us delete this without also deleting the input Transport Stream
+
+protected:
+  MPEG2TransportStreamTrickModeFilter(UsageEnvironment& env, FramedSource* inputSource,
+				      MPEG2TransportStreamIndexFile* indexFile, int scale);
+      // called only by createNew()
+  virtual ~MPEG2TransportStreamTrickModeFilter();
+
+private:
+  // Redefined virtual functions:
+  virtual void doGetNextFrame();
+  virtual void doStopGettingFrames();
+
+private:
+  void attemptDeliveryToClient();
+  void seekToTransportPacket(unsigned long tsPacketNum);
+  void readTransportPacket(unsigned long tsPacketNum); // asynchronously
+
+  static void afterGettingFrame(void* clientData, unsigned frameSize,
+				unsigned numTruncatedBytes,
+				struct timeval presentationTime,
+				unsigned durationInMicroseconds);
+  void afterGettingFrame1(unsigned frameSize);
+
+  static void onSourceClosure(void* clientData);
+  void onSourceClosure1();
+
+private:
+  Boolean fHaveStarted;
+  MPEG2TransportStreamIndexFile* fIndexFile;
+  int fScale; // absolute value
+  int fDirection; // 1 => forward; -1 => reverse
+  enum {
+    SKIPPING_FRAME,
+    DELIVERING_SAVED_FRAME,
+    SAVING_AND_DELIVERING_FRAME
+  } fState;
+  unsigned fFrameCount;
+  unsigned long fNextIndexRecordNum; // next to be read from the index file
+  unsigned long fNextTSPacketNum; // next to be read from the transport stream file
+  unsigned char fInputBuffer[TRANSPORT_PACKET_SIZE];
+  unsigned long fCurrentTSPacketNum; // corresponding to data currently in the buffer
+  unsigned long fDesiredTSPacketNum;
+  u_int8_t fDesiredDataOffset, fDesiredDataSize;
+  float fDesiredDataPCR, fFirstPCR;
+  unsigned long fSavedFrameIndexRecordStart;
+  unsigned long fSavedSequentialIndexRecordNum;
+  Boolean fUseSavedFrameNextTime;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/MPEG2TransportUDPServerMediaSubsession.hh b/3rdparty/live555/src/liveMedia/include/MPEG2TransportUDPServerMediaSubsession.hh
new file mode 100644
index 00000000..d1342015
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/MPEG2TransportUDPServerMediaSubsession.hh
@@ -0,0 +1,55 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A 'ServerMediaSubsession' object that creates new, unicast, "RTPSink"s
+// on demand, from an incoming UDP (or RTP/UDP) MPEG-2 Transport Stream
+// C++ header
+
+#ifndef _MPEG2_TRANSPORT_UDP_SERVER_MEDIA_SUBSESSION_HH
+#define _MPEG2_TRANSPORT_UDP_SERVER_MEDIA_SUBSESSION_HH
+
+#ifndef _ON_DEMAND_SERVER_MEDIA_SUBSESSION_HH
+#include "OnDemandServerMediaSubsession.hh"
+#endif
+
+class MPEG2TransportUDPServerMediaSubsession: public OnDemandServerMediaSubsession {
+public:
+  static MPEG2TransportUDPServerMediaSubsession*
+  createNew(UsageEnvironment& env,
+	    char const* inputAddressStr, // An IP multicast address, or use "0.0.0.0" or NULL for unicast input
+	    Port const& inputPort,
+	    Boolean inputStreamIsRawUDP = False); // otherwise (default) the input stream is RTP/UDP
+protected:
+  MPEG2TransportUDPServerMediaSubsession(UsageEnvironment& env,
+					 char const* inputAddressStr, Port const& inputPort, Boolean inputStreamIsRawUDP);
+      // called only by createNew();
+  virtual ~MPEG2TransportUDPServerMediaSubsession();
+
+protected: // redefined virtual functions
+  virtual FramedSource* createNewStreamSource(unsigned clientSessionId,
+					      unsigned& estBitrate);
+  virtual RTPSink* createNewRTPSink(Groupsock* rtpGroupsock,
+				    unsigned char rtpPayloadTypeIfDynamic,
+				    FramedSource* inputSource);
+protected:
+  char const* fInputAddressStr;
+  Port fInputPort;
+  Groupsock* fInputGroupsock;
+  Boolean fInputStreamIsRawUDP;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/MPEG4ESVideoRTPSink.hh b/3rdparty/live555/src/liveMedia/include/MPEG4ESVideoRTPSink.hh
new file mode 100644
index 00000000..382476e5
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/MPEG4ESVideoRTPSink.hh
@@ -0,0 +1,72 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// RTP sink for MPEG-4 Elementary Stream video (RFC 3016)
+// C++ header
+
+#ifndef _MPEG4ES_VIDEO_RTP_SINK_HH
+#define _MPEG4ES_VIDEO_RTP_SINK_HH
+
+#ifndef _VIDEO_RTP_SINK_HH
+#include "VideoRTPSink.hh"
+#endif
+
+class MPEG4ESVideoRTPSink: public VideoRTPSink {
+public:
+  static MPEG4ESVideoRTPSink* createNew(UsageEnvironment& env,
+					Groupsock* RTPgs, unsigned char rtpPayloadFormat,
+					u_int32_t rtpTimestampFrequency = 90000);
+  static MPEG4ESVideoRTPSink* createNew(UsageEnvironment& env,
+					Groupsock* RTPgs, unsigned char rtpPayloadFormat, u_int32_t rtpTimestampFrequency,
+					u_int8_t profileAndLevelIndication, char const* configStr);
+    // an optional variant of "createNew()", useful if we know, in advance, the stream's 'configuration' info.
+
+
+protected:
+  MPEG4ESVideoRTPSink(UsageEnvironment& env, Groupsock* RTPgs, unsigned char rtpPayloadFormat, u_int32_t rtpTimestampFrequency,
+		      u_int8_t profileAndLevelIndication = 0, char const* configStr = NULL);
+	// called only by createNew()
+
+  virtual ~MPEG4ESVideoRTPSink();
+
+protected: // redefined virtual functions:
+  virtual Boolean sourceIsCompatibleWithUs(MediaSource& source);
+
+  virtual void doSpecialFrameHandling(unsigned fragmentationOffset,
+                                      unsigned char* frameStart,
+                                      unsigned numBytesInFrame,
+                                      struct timeval framePresentationTime,
+                                      unsigned numRemainingBytes);
+  virtual Boolean allowFragmentationAfterStart() const;
+  virtual Boolean
+  frameCanAppearAfterPacketStart(unsigned char const* frameStart,
+				 unsigned numBytesInFrame) const;
+
+  virtual char const* auxSDPLine();
+
+protected:
+  Boolean fVOPIsPresent;
+
+private:
+  u_int8_t fProfileAndLevelIndication;
+  unsigned char* fConfigBytes;
+  unsigned fNumConfigBytes;
+
+  char* fFmtpSDPLine;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/MPEG4ESVideoRTPSource.hh b/3rdparty/live555/src/liveMedia/include/MPEG4ESVideoRTPSource.hh
new file mode 100644
index 00000000..1003cb0f
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/MPEG4ESVideoRTPSource.hh
@@ -0,0 +1,51 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// MP4V-ES video RTP stream sources
+// C++ header
+
+#ifndef _MPEG4_ES_VIDEO_RTP_SOURCE_HH
+#define _MPEG4_ES_VIDEO_RTP_SOURCE_HH
+
+#ifndef _MULTI_FRAMED_RTP_SOURCE_HH
+#include "MultiFramedRTPSource.hh"
+#endif
+
+class MPEG4ESVideoRTPSource: public MultiFramedRTPSource {
+public:
+  static MPEG4ESVideoRTPSource*
+  createNew(UsageEnvironment& env, Groupsock* RTPgs,
+	    unsigned char rtpPayloadFormat,
+	    unsigned rtpTimestampFrequency);
+
+protected:
+  virtual ~MPEG4ESVideoRTPSource();
+
+private:
+  MPEG4ESVideoRTPSource(UsageEnvironment& env, Groupsock* RTPgs,
+			unsigned char rtpPayloadFormat,
+			unsigned rtpTimestampFrequency);
+      // called only by createNew()
+
+private:
+  // redefined virtual functions:
+  virtual Boolean processSpecialHeader(BufferedPacket* packet,
+                                       unsigned& resultSpecialHeaderSize);
+  virtual char const* MIMEtype() const;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/MPEG4GenericRTPSink.hh b/3rdparty/live555/src/liveMedia/include/MPEG4GenericRTPSink.hh
new file mode 100644
index 00000000..447c7d6c
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/MPEG4GenericRTPSink.hh
@@ -0,0 +1,70 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// MPEG4-GENERIC ("audio", "video", or "application") RTP stream sinks
+// C++ header
+
+#ifndef _MPEG4_GENERIC_RTP_SINK_HH
+#define _MPEG4_GENERIC_RTP_SINK_HH
+
+#ifndef _MULTI_FRAMED_RTP_SINK_HH
+#include "MultiFramedRTPSink.hh"
+#endif
+
+class MPEG4GenericRTPSink: public MultiFramedRTPSink {
+public:
+  static MPEG4GenericRTPSink*
+  createNew(UsageEnvironment& env, Groupsock* RTPgs,
+	    u_int8_t rtpPayloadFormat, u_int32_t rtpTimestampFrequency,
+	    char const* sdpMediaTypeString, char const* mpeg4Mode,
+	    char const* configString,
+	    unsigned numChannels = 1);
+
+protected:
+  MPEG4GenericRTPSink(UsageEnvironment& env, Groupsock* RTPgs,
+		      u_int8_t rtpPayloadFormat,
+		      u_int32_t rtpTimestampFrequency,
+		      char const* sdpMediaTypeString,
+		      char const* mpeg4Mode, char const* configString,
+		      unsigned numChannels);
+	// called only by createNew()
+
+  virtual ~MPEG4GenericRTPSink();
+
+private: // redefined virtual functions:
+  virtual
+  Boolean frameCanAppearAfterPacketStart(unsigned char const* frameStart,
+					 unsigned numBytesInFrame) const;
+  virtual void doSpecialFrameHandling(unsigned fragmentationOffset,
+                                      unsigned char* frameStart,
+                                      unsigned numBytesInFrame,
+                                      struct timeval framePresentationTime,
+                                      unsigned numRemainingBytes);
+  virtual unsigned specialHeaderSize() const;
+
+  virtual char const* sdpMediaType() const;
+
+  virtual char const* auxSDPLine(); // for the "a=fmtp:" SDP line
+
+private:
+  char const* fSDPMediaTypeString;
+  char const* fMPEG4Mode;
+  char const* fConfigString;
+  char* fFmtpSDPLine;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/MPEG4GenericRTPSource.hh b/3rdparty/live555/src/liveMedia/include/MPEG4GenericRTPSource.hh
new file mode 100644
index 00000000..b32d0766
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/MPEG4GenericRTPSource.hh
@@ -0,0 +1,78 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// MPEG4-GENERIC ("audio", "video", or "application") RTP stream sources
+// C++ header
+
+#ifndef _MPEG4_GENERIC_RTP_SOURCE_HH
+#define _MPEG4_GENERIC_RTP_SOURCE_HH
+
+#ifndef _MULTI_FRAMED_RTP_SOURCE_HH
+#include "MultiFramedRTPSource.hh"
+#endif
+
+class MPEG4GenericRTPSource: public MultiFramedRTPSource {
+public:
+  static MPEG4GenericRTPSource*
+  createNew(UsageEnvironment& env, Groupsock* RTPgs,
+	    unsigned char rtpPayloadFormat,
+	    unsigned rtpTimestampFrequency,
+	    char const* mediumName,
+	    char const* mode, unsigned sizeLength, unsigned indexLength,
+	    unsigned indexDeltaLength
+	    // add other parameters later
+	    );
+  // mediumName is "audio", "video", or "application"
+  // it *cannot* be NULL
+
+protected:
+  MPEG4GenericRTPSource(UsageEnvironment& env, Groupsock* RTPgs,
+			unsigned char rtpPayloadFormat,
+			unsigned rtpTimestampFrequency,
+			char const* mediumName,
+			char const* mode,
+			unsigned sizeLength, unsigned indexLength,
+			unsigned indexDeltaLength
+			);
+      // called only by createNew(), or by subclass constructors
+  virtual ~MPEG4GenericRTPSource();
+
+protected:
+  // redefined virtual functions:
+  virtual Boolean processSpecialHeader(BufferedPacket* packet,
+                                       unsigned& resultSpecialHeaderSize);
+  virtual char const* MIMEtype() const;
+
+private:
+  char* fMIMEType;
+
+  char* fMode;
+  unsigned fSizeLength, fIndexLength, fIndexDeltaLength;
+  unsigned fNumAUHeaders; // in the most recently read packet
+  unsigned fNextAUHeader; // index of the next AU Header to read
+  struct AUHeader* fAUHeaders;
+
+  friend class MPEG4GenericBufferedPacket;
+};
+
+
+
+// A function that looks up the sampling frequency from an
+// "AudioSpecificConfig" string.  (0 means 'unknown')
+unsigned samplingFrequencyFromAudioSpecificConfig(char const* configStr);
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/MPEG4LATMAudioRTPSink.hh b/3rdparty/live555/src/liveMedia/include/MPEG4LATMAudioRTPSink.hh
new file mode 100644
index 00000000..ddaea8e5
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/MPEG4LATMAudioRTPSink.hh
@@ -0,0 +1,69 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// RTP sink for MPEG-4 audio, using LATM multiplexing (RFC 3016)
+// (Note that the initial 'size' field is assumed to be present at the start of
+//  each frame.)
+// C++ header
+
+#ifndef _MPEG4_LATM_AUDIO_RTP_SINK_HH
+#define _MPEG4_LATM_AUDIO_RTP_SINK_HH
+
+#ifndef _AUDIO_RTP_SINK_HH
+#include "AudioRTPSink.hh"
+#endif
+
+class MPEG4LATMAudioRTPSink: public AudioRTPSink {
+public:
+  static MPEG4LATMAudioRTPSink* createNew(UsageEnvironment& env,
+					  Groupsock* RTPgs,
+					  unsigned char rtpPayloadFormat,
+					  u_int32_t rtpTimestampFrequency,
+					  char const* streamMuxConfigString,
+					  unsigned numChannels,
+					  Boolean allowMultipleFramesPerPacket = False);
+
+protected:
+  MPEG4LATMAudioRTPSink(UsageEnvironment& env, Groupsock* RTPgs,
+			unsigned char rtpPayloadFormat,
+			u_int32_t rtpTimestampFrequency,
+			char const* streamMuxConfigString,
+			unsigned numChannels,
+			Boolean allowMultipleFramesPerPacket);
+	// called only by createNew()
+
+  virtual ~MPEG4LATMAudioRTPSink();
+
+private: // redefined virtual functions:
+  virtual void doSpecialFrameHandling(unsigned fragmentationOffset,
+                                      unsigned char* frameStart,
+                                      unsigned numBytesInFrame,
+                                      struct timeval framePresentationTime,
+                                      unsigned numRemainingBytes);
+  virtual Boolean
+  frameCanAppearAfterPacketStart(unsigned char const* frameStart,
+				 unsigned numBytesInFrame) const;
+
+  virtual char const* auxSDPLine(); // for the "a=fmtp:" SDP line
+
+private:
+  char const* fStreamMuxConfigString;
+  char* fFmtpSDPLine;
+  Boolean fAllowMultipleFramesPerPacket;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/MPEG4LATMAudioRTPSource.hh b/3rdparty/live555/src/liveMedia/include/MPEG4LATMAudioRTPSource.hh
new file mode 100644
index 00000000..8674fd8e
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/MPEG4LATMAudioRTPSource.hh
@@ -0,0 +1,101 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// MPEG-4 audio, using LATM multiplexing
+// C++ header
+
+#ifndef _MPEG4_LATM_AUDIO_RTP_SOURCE_HH
+#define _MPEG4_LATM_AUDIO_RTP_SOURCE_HH
+
+#ifndef _MULTI_FRAMED_RTP_SOURCE_HH
+#include "MultiFramedRTPSource.hh"
+#endif
+
+class MPEG4LATMAudioRTPSource: public MultiFramedRTPSource {
+public:
+  static MPEG4LATMAudioRTPSource*
+  createNew(UsageEnvironment& env, Groupsock* RTPgs,
+	    unsigned char rtpPayloadFormat,
+	    unsigned rtpTimestampFrequency);
+
+  // By default, the LATM data length field is included at the beginning of each
+  // returned frame.  To omit this field, call the following:
+  void omitLATMDataLengthField();
+
+  Boolean returnedFrameIncludesLATMDataLengthField() const { return fIncludeLATMDataLengthField; }
+
+protected:
+  virtual ~MPEG4LATMAudioRTPSource();
+
+private:
+  MPEG4LATMAudioRTPSource(UsageEnvironment& env, Groupsock* RTPgs,
+			  unsigned char rtpPayloadFormat,
+			  unsigned rtpTimestampFrequency);
+      // called only by createNew()
+
+private:
+  // redefined virtual functions:
+  virtual Boolean processSpecialHeader(BufferedPacket* packet,
+                                       unsigned& resultSpecialHeaderSize);
+  virtual char const* MIMEtype() const;
+
+private:
+  Boolean fIncludeLATMDataLengthField;
+};
+
+
+// A utility for parsing a "StreamMuxConfig" string
+Boolean
+parseStreamMuxConfigStr(char const* configStr,
+			// result parameters:
+			Boolean& audioMuxVersion,
+			Boolean& allStreamsSameTimeFraming,
+			unsigned char& numSubFrames,
+			unsigned char& numProgram,
+			unsigned char& numLayer,
+			unsigned char*& audioSpecificConfig,
+			unsigned& audioSpecificConfigSize);
+    // Parses "configStr" as a sequence of hexadecimal digits, representing
+    // a "StreamMuxConfig" (as defined in ISO.IEC 14496-3, table 1.21).
+    // Returns, in "audioSpecificConfig", a binary representation of
+    // the enclosed "AudioSpecificConfig" structure (of size
+    // "audioSpecificConfigSize" bytes).  The memory for this is allocated
+    // dynamically by this function; the caller is responsible for
+    // freeing it.  Other values, that precede "AudioSpecificConfig",
+    // are returned in the other parameters.
+    // Returns True iff the parsing succeeds.
+    // IMPORTANT NOTE: The implementation of this function currently assumes
+    // that everything after the first "numLayer" field is an
+    // "AudioSpecificConfig".  Therefore, it will not work properly if
+    // "audioMuxVersion" != 0, "numProgram" > 0, or "numLayer" > 0.
+    // Also, any 'other data' or CRC info will be included at
+    // the end of "audioSpecificConfig".
+
+unsigned char* parseStreamMuxConfigStr(char const* configStr,
+				       // result parameter:
+				       unsigned& audioSpecificConfigSize);
+    // A variant of the above that returns just the "AudioSpecificConfig" data
+    // (or NULL) if the parsing failed, without bothering with the other
+    // result parameters.
+
+unsigned char* parseGeneralConfigStr(char const* configStr,
+				     // result parameter:
+				     unsigned& configSize);
+    // A routine that parses an arbitrary config string, returning
+    // the result in binary form.
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/MPEG4VideoFileServerMediaSubsession.hh b/3rdparty/live555/src/liveMedia/include/MPEG4VideoFileServerMediaSubsession.hh
new file mode 100644
index 00000000..eaa9dd21
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/MPEG4VideoFileServerMediaSubsession.hh
@@ -0,0 +1,61 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A 'ServerMediaSubsession' object that creates new, unicast, "RTPSink"s
+// on demand, from a MPEG-4 video file.
+// C++ header
+
+#ifndef _MPEG4_VIDEO_FILE_SERVER_MEDIA_SUBSESSION_HH
+#define _MPEG4_VIDEO_FILE_SERVER_MEDIA_SUBSESSION_HH
+
+#ifndef _FILE_SERVER_MEDIA_SUBSESSION_HH
+#include "FileServerMediaSubsession.hh"
+#endif
+
+class MPEG4VideoFileServerMediaSubsession: public FileServerMediaSubsession{
+public:
+  static MPEG4VideoFileServerMediaSubsession*
+  createNew(UsageEnvironment& env, char const* fileName, Boolean reuseFirstSource);
+
+  // Used to implement "getAuxSDPLine()":
+  void checkForAuxSDPLine1();
+  void afterPlayingDummy1();
+
+protected:
+  MPEG4VideoFileServerMediaSubsession(UsageEnvironment& env,
+				      char const* fileName, Boolean reuseFirstSource);
+      // called only by createNew();
+  virtual ~MPEG4VideoFileServerMediaSubsession();
+
+  void setDoneFlag() { fDoneFlag = ~0; }
+
+protected: // redefined virtual functions
+  virtual char const* getAuxSDPLine(RTPSink* rtpSink,
+				    FramedSource* inputSource);
+  virtual FramedSource* createNewStreamSource(unsigned clientSessionId,
+					      unsigned& estBitrate);
+  virtual RTPSink* createNewRTPSink(Groupsock* rtpGroupsock,
+                                    unsigned char rtpPayloadTypeIfDynamic,
+				    FramedSource* inputSource);
+
+private:
+  char* fAuxSDPLine;
+  char fDoneFlag; // used when setting up "fAuxSDPLine"
+  RTPSink* fDummyRTPSink; // ditto
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/MPEG4VideoStreamDiscreteFramer.hh b/3rdparty/live555/src/liveMedia/include/MPEG4VideoStreamDiscreteFramer.hh
new file mode 100644
index 00000000..018f431c
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/MPEG4VideoStreamDiscreteFramer.hh
@@ -0,0 +1,73 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A simplified version of "MPEG4VideoStreamFramer" that takes only complete,
+// discrete frames (rather than an arbitrary byte stream) as input.
+// This avoids the parsing and data copying overhead of the full
+// "MPEG4VideoStreamFramer".
+// C++ header
+
+#ifndef _MPEG4_VIDEO_STREAM_DISCRETE_FRAMER_HH
+#define _MPEG4_VIDEO_STREAM_DISCRETE_FRAMER_HH
+
+#ifndef _MPEG4_VIDEO_STREAM_FRAMER_HH
+#include "MPEG4VideoStreamFramer.hh"
+#endif
+
+class MPEG4VideoStreamDiscreteFramer: public MPEG4VideoStreamFramer {
+public:
+  static MPEG4VideoStreamDiscreteFramer*
+  createNew(UsageEnvironment& env, FramedSource* inputSource, Boolean leavePresentationTimesUnmodified = False);
+
+protected:
+  MPEG4VideoStreamDiscreteFramer(UsageEnvironment& env,
+				 FramedSource* inputSource, Boolean leavePresentationTimesUnmodified);
+      // called only by createNew()
+  virtual ~MPEG4VideoStreamDiscreteFramer();
+
+protected:
+  // redefined virtual functions:
+  virtual void doGetNextFrame();
+
+protected:
+  static void afterGettingFrame(void* clientData, unsigned frameSize,
+                                unsigned numTruncatedBytes,
+                                struct timeval presentationTime,
+                                unsigned durationInMicroseconds);
+  void afterGettingFrame1(unsigned frameSize,
+                          unsigned numTruncatedBytes,
+                          struct timeval presentationTime,
+                          unsigned durationInMicroseconds);
+
+  Boolean getNextFrameBit(u_int8_t& result);
+  Boolean getNextFrameBits(unsigned numBits, u_int32_t& result);
+    // Which are used by:
+  void analyzeVOLHeader();
+
+protected:
+  Boolean fLeavePresentationTimesUnmodified;
+  u_int32_t vop_time_increment_resolution;
+  unsigned fNumVTIRBits;
+  // # of bits needed to count to "vop_time_increment_resolution"
+  struct timeval fLastNonBFramePresentationTime;
+  unsigned fLastNonBFrameVop_time_increment;
+
+private:
+  unsigned fNumBitsSeenSoFar; // used by the getNextFrameBit*() routines
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/MPEG4VideoStreamFramer.hh b/3rdparty/live555/src/liveMedia/include/MPEG4VideoStreamFramer.hh
new file mode 100644
index 00000000..bc581a9a
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/MPEG4VideoStreamFramer.hh
@@ -0,0 +1,75 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A filter that breaks up an MPEG-4 video elementary stream into
+//   frames for:
+// - Visual Object Sequence (VS) Header + Visual Object (VO) Header
+//   + Video Object Layer (VOL) Header
+// - Group of VOP (GOV) Header
+// - VOP frame
+// C++ header
+
+#ifndef _MPEG4_VIDEO_STREAM_FRAMER_HH
+#define _MPEG4_VIDEO_STREAM_FRAMER_HH
+
+#ifndef _MPEG_VIDEO_STREAM_FRAMER_HH
+#include "MPEGVideoStreamFramer.hh"
+#endif
+
+class MPEG4VideoStreamFramer: public MPEGVideoStreamFramer {
+public:
+  static MPEG4VideoStreamFramer*
+  createNew(UsageEnvironment& env, FramedSource* inputSource);
+
+  u_int8_t profile_and_level_indication() const {
+    return fProfileAndLevelIndication;
+  }
+
+  unsigned char* getConfigBytes(unsigned& numBytes) const;
+
+  void setConfigInfo(u_int8_t profileAndLevelIndication, char const* configStr);
+    // Assigns the "profile_and_level_indication" number, and the 'config' bytes.
+    // If this function is not called, then this data is only assigned later, when it appears in the input stream.
+
+protected:
+  MPEG4VideoStreamFramer(UsageEnvironment& env,
+			 FramedSource* inputSource,
+			 Boolean createParser = True);
+      // called only by createNew(), or by subclass constructors
+  virtual ~MPEG4VideoStreamFramer();
+
+  void startNewConfig();
+  void appendToNewConfig(unsigned char* newConfigBytes,
+			 unsigned numNewBytes);
+  void completeNewConfig();
+
+private:
+  // redefined virtual functions:
+  virtual Boolean isMPEG4VideoStreamFramer() const;
+
+protected:
+  u_int8_t fProfileAndLevelIndication;
+  unsigned char* fConfigBytes;
+  unsigned fNumConfigBytes;
+
+private:
+  unsigned char* fNewConfigBytes;
+  unsigned fNumNewConfigBytes;
+  friend class MPEG4VideoStreamParser; // hack
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/MPEGVideoStreamFramer.hh b/3rdparty/live555/src/liveMedia/include/MPEGVideoStreamFramer.hh
new file mode 100644
index 00000000..4a767007
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/MPEGVideoStreamFramer.hh
@@ -0,0 +1,85 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A filter that breaks up an MPEG video elementary stream into
+//   headers and frames
+// C++ header
+
+#ifndef _MPEG_VIDEO_STREAM_FRAMER_HH
+#define _MPEG_VIDEO_STREAM_FRAMER_HH
+
+#ifndef _FRAMED_FILTER_HH
+#include "FramedFilter.hh"
+#endif
+
+class TimeCode {
+public:
+  TimeCode();
+  virtual ~TimeCode();
+
+  int operator==(TimeCode const& arg2);
+  unsigned days, hours, minutes, seconds, pictures;
+};
+
+class MPEGVideoStreamFramer: public FramedFilter {
+public:
+  Boolean& pictureEndMarker() { return fPictureEndMarker; }
+      // a hack for implementing the RTP 'M' bit
+
+  void flushInput(); // called if there is a discontinuity (seeking) in the input
+
+protected:
+  MPEGVideoStreamFramer(UsageEnvironment& env, FramedSource* inputSource);
+      // we're an abstract base class
+  virtual ~MPEGVideoStreamFramer();
+
+  void computePresentationTime(unsigned numAdditionalPictures);
+      // sets "fPresentationTime"
+  void setTimeCode(unsigned hours, unsigned minutes, unsigned seconds,
+		   unsigned pictures, unsigned picturesSinceLastGOP);
+
+protected: // redefined virtual functions
+  virtual void doGetNextFrame();
+  virtual void doStopGettingFrames();
+
+private:
+  void reset();
+
+  static void continueReadProcessing(void* clientData,
+				     unsigned char* ptr, unsigned size,
+				     struct timeval presentationTime);
+  void continueReadProcessing();
+
+protected:
+  double fFrameRate; // Note: For MPEG-4, this is really a 'tick rate'
+  unsigned fPictureCount; // hack used to implement doGetNextFrame()
+  Boolean fPictureEndMarker;
+  struct timeval fPresentationTimeBase;
+
+  // parsing state
+  class MPEGVideoStreamParser* fParser;
+  friend class MPEGVideoStreamParser; // hack
+
+private:
+  TimeCode fCurGOPTimeCode, fPrevGOPTimeCode;
+  unsigned fPicturesAdjustment;
+  double fPictureTimeBase;
+  unsigned fTcSecsBase;
+  Boolean fHaveSeenFirstTimeCode;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/MatroskaFile.hh b/3rdparty/live555/src/liveMedia/include/MatroskaFile.hh
new file mode 100644
index 00000000..73f08970
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/MatroskaFile.hh
@@ -0,0 +1,218 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A class that encapsulates a Matroska file.
+// C++ header
+
+#ifndef _MATROSKA_FILE_HH
+#define _MATROSKA_FILE_HH
+
+#ifndef _RTP_SINK_HH
+#include "RTPSink.hh"
+#endif
+#ifndef _FILE_SINK_HH
+#include "FileSink.hh"
+#endif
+#ifndef _HASH_TABLE_HH
+#include "HashTable.hh"
+#endif
+
+class MatroskaTrack; // forward
+class MatroskaDemux; // forward
+
+typedef void MatroskaDemuxOnDeletionFunc(void* objectToNotify, MatroskaDemux* demuxBeingDeleted);
+
+class MatroskaFile: public Medium {
+public:
+  typedef void (onCreationFunc)(MatroskaFile* newFile, void* clientData);
+  static void createNew(UsageEnvironment& env, char const* fileName, onCreationFunc* onCreation, void* onCreationClientData,
+			char const* preferredLanguage = "eng");
+    // Note: Unlike most "createNew()" functions, this one doesn't return a new object immediately.  Instead, because this class
+    // requires file reading (to parse the Matroska 'Track' headers) before a new object can be initialized, the creation of a new
+    // object is signalled by calling - from the event loop - an 'onCreationFunc' that is passed as a parameter to "createNew()".
+
+  MatroskaTrack* lookup(unsigned trackNumber) const;
+
+  MatroskaDemux* newDemux(MatroskaDemuxOnDeletionFunc* onDeletionFunc = NULL, void* objectToNotify = NULL);
+      // Creates a demultiplexor for extracting tracks from this file.
+      // (Separate clients will typically have separate demultiplexors.)
+
+  // Parameters of the file ('Segment'); set when the file is parsed:
+  unsigned timecodeScale() { return fTimecodeScale; } // in nanoseconds
+  float segmentDuration() { return fSegmentDuration; } // in units of "timecodeScale()"
+  float fileDuration(); // in seconds
+  
+  char const* fileName() const { return fFileName; }
+
+  unsigned chosenVideoTrackNumber() { return fChosenVideoTrackNumber; }
+  unsigned chosenAudioTrackNumber() { return fChosenAudioTrackNumber; }
+  unsigned chosenSubtitleTrackNumber() { return fChosenSubtitleTrackNumber; }
+
+  FramedSource*
+  createSourceForStreaming(FramedSource* baseSource, unsigned trackNumber,
+			   unsigned& estBitrate, unsigned& numFiltersInFrontOfTrack);
+    // Takes a data source (which must be a demultiplexed track from this file) and returns
+    // a (possibly modified) data source that can be used for streaming.
+
+  char const* trackMIMEType(unsigned trackNumber) const;
+      // in the form "<medium-name>/<CODEC-NAME>", or NULL if no such track exists
+
+  RTPSink* createRTPSinkForTrackNumber(unsigned trackNumber, Groupsock* rtpGroupsock,
+				       unsigned char rtpPayloadTypeIfDynamic);
+    // Creates a "RTPSink" object that would be appropriate for streaming the specified track,
+    // or NULL if no appropriate "RTPSink" exists
+
+  FileSink* createFileSinkForTrackNumber(unsigned trackNumber, char const* fileName);
+    // Creates a "FileSink" object that would be appropriate for recording the contents of
+    // the specified track, or NULL if no appropriate "FileSink" exists.
+
+private:
+  MatroskaFile(UsageEnvironment& env, char const* fileName, onCreationFunc* onCreation, void* onCreationClientData,
+	       char const* preferredLanguage);
+      // called only by createNew()
+  virtual ~MatroskaFile();
+
+  static void handleEndOfTrackHeaderParsing(void* clientData);
+  void handleEndOfTrackHeaderParsing();
+
+  void addTrack(MatroskaTrack* newTrack, unsigned trackNumber);
+  void addCuePoint(double cueTime, u_int64_t clusterOffsetInFile, unsigned blockNumWithinCluster);
+  Boolean lookupCuePoint(double& cueTime, u_int64_t& resultClusterOffsetInFile, unsigned& resultBlockNumWithinCluster);
+  void printCuePoints(FILE* fid);
+
+  void removeDemux(MatroskaDemux* demux);
+
+  void getH264ConfigData(MatroskaTrack const* track,
+			 u_int8_t*& sps, unsigned& spsSize,
+			 u_int8_t*& pps, unsigned& ppsSize);
+    // "sps","pps" are dynamically allocated by this function, and must be delete[]d afterwards
+  void getH265ConfigData(MatroskaTrack const* track,
+			 u_int8_t*& vps, unsigned& vpsSize,
+			 u_int8_t*& sps, unsigned& spsSize,
+			 u_int8_t*& pps, unsigned& ppsSize);
+    // "vps","sps","pps" are dynamically allocated by this function, and must be delete[]d afterwards
+
+  void getVorbisOrTheoraConfigData(MatroskaTrack const* track,
+				   u_int8_t*& identificationHeader, unsigned& identificationHeaderSize,
+				   u_int8_t*& commentHeader, unsigned& commentHeaderSize,
+				   u_int8_t*& setupHeader, unsigned& setupHeaderSize);
+    // "identificationHeader", "commentHeader", "setupHeader" are dynamically allocated by this function, and must be delete[]d afterwards
+
+private:
+  friend class MatroskaFileParser;
+  friend class MatroskaDemux;
+  char const* fFileName;
+  onCreationFunc* fOnCreation;
+  void* fOnCreationClientData;
+  char const* fPreferredLanguage;
+
+  unsigned fTimecodeScale; // in nanoseconds
+  float fSegmentDuration; // in units of "fTimecodeScale"
+  u_int64_t fSegmentDataOffset, fClusterOffset, fCuesOffset;
+
+  class MatroskaTrackTable* fTrackTable;
+  HashTable* fDemuxesTable;
+  class CuePoint* fCuePoints;
+  unsigned fChosenVideoTrackNumber, fChosenAudioTrackNumber, fChosenSubtitleTrackNumber;
+  class MatroskaFileParser* fParserForInitialization;
+};
+
+// We define our own track type codes as bits (powers of 2), so we can use the set of track types as a bitmap, representing a set:
+// (Note that MATROSKA_TRACK_TYPE_OTHER must be last, and have the largest value.)
+#define MATROSKA_TRACK_TYPE_VIDEO 0x01
+#define MATROSKA_TRACK_TYPE_AUDIO 0x02
+#define MATROSKA_TRACK_TYPE_SUBTITLE 0x04
+#define MATROSKA_TRACK_TYPE_OTHER 0x08
+
+class MatroskaTrack {
+public:
+  MatroskaTrack();
+  virtual ~MatroskaTrack();
+
+  // track parameters
+  unsigned trackNumber;
+  u_int8_t trackType;
+  Boolean isEnabled, isDefault, isForced;
+  unsigned defaultDuration;
+  char* name;
+  char* language;
+  char* codecID;
+  unsigned samplingFrequency;
+  unsigned numChannels;
+  char const* mimeType;
+  unsigned codecPrivateSize;
+  u_int8_t* codecPrivate;
+  Boolean codecPrivateUsesH264FormatForH265; // a hack specifically for H.265 video tracks
+  Boolean codecIsOpus; // a hack for Opus audio
+  unsigned headerStrippedBytesSize;
+  u_int8_t* headerStrippedBytes;
+  char const* colorSampling;
+  char const* colorimetry;
+  unsigned pixelWidth;
+  unsigned pixelHeight;
+  unsigned bitDepth;
+  unsigned subframeSizeSize; // 0 means: frames do not have subframes (the default behavior)
+  Boolean haveSubframes() const { return subframeSizeSize > 0; }
+};
+
+class MatroskaDemux: public Medium {
+public:
+  FramedSource* newDemuxedTrack();
+  FramedSource* newDemuxedTrack(unsigned& resultTrackNumber);
+      // Returns a new stream ("FramedSource" subclass) that represents the next preferred media
+      // track (video, audio, subtitle - in that order) from the file. (Preferred media tracks
+      // are based on the file's language preference.)
+      // This function returns NULL when no more media tracks exist.
+
+  FramedSource* newDemuxedTrackByTrackNumber(unsigned trackNumber);
+      // As above, but creates a new stream for a specific track number within the Matroska file.
+      // (You should not call this function more than once with the same track number.)
+
+    // Note: We assume that:
+    // - Every track created by "newDemuxedTrack()" is later read
+    // - All calls to "newDemuxedTrack()" are made before any track is read
+
+protected:
+  friend class MatroskaFile;
+  friend class MatroskaFileParser;
+  class MatroskaDemuxedTrack* lookupDemuxedTrack(unsigned trackNumber);
+
+  MatroskaDemux(MatroskaFile& ourFile); // we're created only by a "MatroskaFile" (a friend)
+  virtual ~MatroskaDemux();
+
+private:
+  friend class MatroskaDemuxedTrack;
+  void removeTrack(unsigned trackNumber);
+  void continueReading(); // called by a demuxed track to tell us that it has a pending read ("doGetNextFrame()")
+  void seekToTime(double& seekNPT);
+  void pause();
+
+  static void handleEndOfFile(void* clientData);
+  void handleEndOfFile();
+
+  void resetState();
+
+private:
+  MatroskaFile& fOurFile;
+  class MatroskaFileParser* fOurParser;
+  HashTable* fDemuxedTracksTable;
+
+  // Used to implement "newServerMediaSubsession()":
+  u_int8_t fNextTrackTypeToCheck;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/MatroskaFileServerDemux.hh b/3rdparty/live555/src/liveMedia/include/MatroskaFileServerDemux.hh
new file mode 100644
index 00000000..73dcbbad
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/MatroskaFileServerDemux.hh
@@ -0,0 +1,88 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A server demultiplexor for a Matroska file
+// C++ header
+
+#ifndef _MATROSKA_FILE_SERVER_DEMUX_HH
+#define _MATROSKA_FILE_SERVER_DEMUX_HH
+
+#ifndef _SERVER_MEDIA_SESSION_HH
+#include "ServerMediaSession.hh"
+#endif
+
+#ifndef _MATROSKA_FILE_HH
+#include "MatroskaFile.hh"
+#endif
+
+class MatroskaFileServerDemux: public Medium {
+public:
+  typedef void (onCreationFunc)(MatroskaFileServerDemux* newDemux, void* clientData);
+  static void createNew(UsageEnvironment& env, char const* fileName,
+			onCreationFunc* onCreation, void* onCreationClientData,
+			char const* preferredLanguage = "eng");
+    // Note: Unlike most "createNew()" functions, this one doesn't return a new object immediately.  Instead, because this class
+    // requires file reading (to parse the Matroska 'Track' headers) before a new object can be initialized, the creation of a new
+    // object is signalled by calling - from the event loop - an 'onCreationFunc' that is passed as a parameter to "createNew()". 
+
+  ServerMediaSubsession* newServerMediaSubsession();
+  ServerMediaSubsession* newServerMediaSubsession(unsigned& resultTrackNumber);
+    // Returns a new "ServerMediaSubsession" object that represents the next preferred media track
+    // (video, audio, subtitle - in that order) from the file. (Preferred media tracks are based on the file's language preference.)
+    // This function returns NULL when no more media tracks exist.
+
+  ServerMediaSubsession* newServerMediaSubsessionByTrackNumber(unsigned trackNumber);
+    // As above, but creates a new "ServerMediaSubsession" object for a specific track number within the Matroska file.
+    // (You should not call this function more than once with the same track number.)
+
+  // The following public: member functions are called only by the "ServerMediaSubsession" objects:
+
+  MatroskaFile* ourMatroskaFile() { return fOurMatroskaFile; }
+  char const* fileName() const { return fFileName; }
+  float fileDuration() const { return fOurMatroskaFile->fileDuration(); }
+
+  FramedSource* newDemuxedTrack(unsigned clientSessionId, unsigned trackNumber);
+    // Used by the "ServerMediaSubsession" objects to implement their "createNewStreamSource()" virtual function.
+
+private:
+  MatroskaFileServerDemux(UsageEnvironment& env, char const* fileName,
+			  onCreationFunc* onCreation, void* onCreationClientData,
+			  char const* preferredLanguage);
+      // called only by createNew()
+  virtual ~MatroskaFileServerDemux();
+
+  static void onMatroskaFileCreation(MatroskaFile* newFile, void* clientData);
+  void onMatroskaFileCreation(MatroskaFile* newFile);
+
+  static void onDemuxDeletion(void* clientData, MatroskaDemux* demuxBeingDeleted);
+  void onDemuxDeletion(MatroskaDemux* demuxBeingDeleted);
+
+private:
+  char const* fFileName; 
+  onCreationFunc* fOnCreation;
+  void* fOnCreationClientData;
+  MatroskaFile* fOurMatroskaFile;
+
+  // Used to implement "newServerMediaSubsession()":
+  u_int8_t fNextTrackTypeToCheck;
+
+  // Used to set up demuxing, to implement "newDemuxedTrack()":
+  unsigned fLastClientSessionId;
+  MatroskaDemux* fLastCreatedDemux;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/Media.hh b/3rdparty/live555/src/liveMedia/include/Media.hh
new file mode 100644
index 00000000..0f5c5904
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/Media.hh
@@ -0,0 +1,137 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// Medium
+// C++ header
+
+#ifndef _MEDIA_HH
+#define _MEDIA_HH
+
+#ifndef _LIVEMEDIA_VERSION_HH
+#include "liveMedia_version.hh"
+#endif
+
+#ifndef _HASH_TABLE_HH
+#include "HashTable.hh"
+#endif
+
+#ifndef _USAGE_ENVIRONMENT_HH
+#include "UsageEnvironment.hh"
+#endif
+
+// Lots of files end up needing the following, so just #include them here:
+#ifndef _NET_COMMON_H
+#include "NetCommon.h"
+#endif
+#include <stdio.h>
+
+// The following makes the Borland compiler happy:
+#ifdef __BORLANDC__
+#define _strnicmp strnicmp
+#define fabsf(x) fabs(x)
+#endif
+
+#define mediumNameMaxLen 30
+
+class Medium {
+public:
+  static Boolean lookupByName(UsageEnvironment& env,
+			      char const* mediumName,
+			      Medium*& resultMedium);
+  static void close(UsageEnvironment& env, char const* mediumName);
+  static void close(Medium* medium); // alternative close() method using ptrs
+      // (has no effect if medium == NULL)
+
+  UsageEnvironment& envir() const {return fEnviron;}
+
+  char const* name() const {return fMediumName;}
+
+  // Test for specific types of media:
+  virtual Boolean isSource() const;
+  virtual Boolean isSink() const;
+  virtual Boolean isRTCPInstance() const;
+  virtual Boolean isRTSPClient() const;
+  virtual Boolean isRTSPServer() const;
+  virtual Boolean isMediaSession() const;
+  virtual Boolean isServerMediaSession() const;
+
+protected:
+  friend class MediaLookupTable;
+  Medium(UsageEnvironment& env); // abstract base class
+  virtual ~Medium(); // instances are deleted using close() only
+
+  TaskToken& nextTask() {
+	return fNextTask;
+  }
+
+private:
+  UsageEnvironment& fEnviron;
+  char fMediumName[mediumNameMaxLen];
+  TaskToken fNextTask;
+};
+
+
+// A data structure for looking up a Medium by its string name.
+// (It is used only to implement "Medium", but we make it visible here, in case developers want to use it to iterate over
+//  the whole set of "Medium" objects that we've created.)
+class MediaLookupTable {
+public:
+  static MediaLookupTable* ourMedia(UsageEnvironment& env);
+  HashTable const& getTable() { return *fTable; }
+
+protected:
+  MediaLookupTable(UsageEnvironment& env);
+  virtual ~MediaLookupTable();
+
+private:
+  friend class Medium;
+
+  Medium* lookup(char const* name) const;
+  // Returns NULL if none already exists
+
+  void addNew(Medium* medium, char* mediumName);
+  void remove(char const* name);
+
+  void generateNewName(char* mediumName, unsigned maxLen);
+
+private:
+  UsageEnvironment& fEnv;
+  HashTable* fTable;
+  unsigned fNameGenerator;
+};
+
+
+// The structure pointed to by the "liveMediaPriv" UsageEnvironment field:
+class _Tables {
+public:
+  static _Tables* getOurTables(UsageEnvironment& env, Boolean createIfNotPresent = True);
+      // returns a pointer to a "_Tables" structure (creating it if necessary)
+  void reclaimIfPossible();
+      // used to delete ourselves when we're no longer used
+
+  MediaLookupTable* mediaTable;
+  void* socketTable;
+
+protected:
+  _Tables(UsageEnvironment& env);
+  virtual ~_Tables();
+
+private:
+  UsageEnvironment& fEnv;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/MediaSession.hh b/3rdparty/live555/src/liveMedia/include/MediaSession.hh
new file mode 100644
index 00000000..96833c8e
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/MediaSession.hh
@@ -0,0 +1,370 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A data structure that represents a session that consists of
+// potentially multiple (audio and/or video) sub-sessions
+// (This data structure is used for media *receivers* - i.e., clients.
+//  For media streamers, use "ServerMediaSession" instead.)
+// C++ header
+
+/* NOTE: To support receiving your own custom RTP payload format, you must first define a new
+   subclass of "MultiFramedRTPSource" (or "BasicUDPSource") that implements it.
+   Then define your own subclass of "MediaSession" and "MediaSubsession", as follows:
+   - In your subclass of "MediaSession" (named, for example, "myMediaSession"):
+       - Define and implement your own static member function
+           static myMediaSession* createNew(UsageEnvironment& env, char const* sdpDescription);
+	 and call this - instead of "MediaSession::createNew()" - in your application,
+	 when you create a new "MediaSession" object.
+       - Reimplement the "createNewMediaSubsession()" virtual function, as follows:
+           MediaSubsession* myMediaSession::createNewMediaSubsession() { return new myMediaSubsession(*this); }
+   - In your subclass of "MediaSubsession" (named, for example, "myMediaSubsession"):
+       - Reimplement the "createSourceObjects()" virtual function, perhaps similar to this:
+           Boolean myMediaSubsession::createSourceObjects(int useSpecialRTPoffset) {
+	     if (strcmp(fCodecName, "X-MY-RTP-PAYLOAD-FORMAT") == 0) {
+	       // This subsession uses our custom RTP payload format:
+	       fReadSource = fRTPSource = myRTPPayloadFormatRTPSource::createNew( <parameters> );
+	       return True;
+	     } else {
+	       // This subsession uses some other RTP payload format - perhaps one that we already implement:
+	       return ::createSourceObjects(useSpecialRTPoffset);
+	     }
+	   }  
+*/
+
+#ifndef _MEDIA_SESSION_HH
+#define _MEDIA_SESSION_HH
+
+#ifndef _RTCP_HH
+#include "RTCP.hh"
+#endif
+#ifndef _FRAMED_FILTER_HH
+#include "FramedFilter.hh"
+#endif
+#ifndef _SRTP_CRYPTOGRAPHIC_CONTEXT_HH
+#include "SRTPCryptographicContext.hh"
+#endif
+
+class MediaSubsession; // forward
+
+class MediaSession: public Medium {
+public:
+  static MediaSession* createNew(UsageEnvironment& env,
+				 char const* sdpDescription);
+
+  static Boolean lookupByName(UsageEnvironment& env, char const* sourceName,
+			      MediaSession*& resultSession);
+
+  Boolean hasSubsessions() const { return fSubsessionsHead != NULL; }
+
+  char* connectionEndpointName() const { return fConnectionEndpointName; }
+  int connectionEndpointNameAddressFamily() const { return fConnectionEndpointNameAddressFamily; }
+  char const* CNAME() const { return fCNAME; }
+  struct sockaddr_storage const& sourceFilterAddr() const { return fSourceFilterAddr; }
+  float& scale() { return fScale; }
+  float& speed() { return fSpeed; }
+  char* mediaSessionType() const { return fMediaSessionType; }
+  char* sessionName() const { return fSessionName; }
+  char* sessionDescription() const { return fSessionDescription; }
+  char const* controlPath() const { return fControlPath; }
+
+  double& playStartTime() { return fMaxPlayStartTime; }
+  double& playEndTime() { return fMaxPlayEndTime; }
+  char* absStartTime() const;
+  char* absEndTime() const;
+  // Used only to set the local fields:
+  char*& _absStartTime() { return fAbsStartTime; }
+  char*& _absEndTime() { return fAbsEndTime; }
+
+  Boolean initiateByMediaType(char const* mimeType,
+			      MediaSubsession*& resultSubsession,
+			      int useSpecialRTPoffset = -1);
+      // Initiates the first subsession with the specified MIME type
+      // Returns the resulting subsession, or 'multi source' (not both)
+
+  MIKEYState* getMIKEYState() const { return fMIKEYState; }
+  SRTPCryptographicContext* getCrypto() const { return fCrypto; }
+
+protected: // redefined virtual functions
+  virtual Boolean isMediaSession() const;
+
+protected:
+  MediaSession(UsageEnvironment& env);
+      // called only by createNew();
+  virtual ~MediaSession();
+
+  virtual MediaSubsession* createNewMediaSubsession();
+
+  Boolean initializeWithSDP(char const* sdpDescription);
+  Boolean parseSDPLine(char const* input, char const*& nextLine);
+  Boolean parseSDPLine_s(char const* sdpLine);
+  Boolean parseSDPLine_i(char const* sdpLine);
+  Boolean parseSDPLine_c(char const* sdpLine);
+  Boolean parseSDPAttribute_type(char const* sdpLine);
+  Boolean parseSDPAttribute_control(char const* sdpLine);
+  Boolean parseSDPAttribute_range(char const* sdpLine);
+  Boolean parseSDPAttribute_source_filter(char const* sdpLine);
+  Boolean parseSDPAttribute_key_mgmt(char const* sdpLine);
+
+  static char* lookupPayloadFormat(unsigned char rtpPayloadType,
+				   unsigned& rtpTimestampFrequency,
+				   unsigned& numChannels);
+  static unsigned guessRTPTimestampFrequency(char const* mediumName,
+					     char const* codecName);
+
+protected:
+  friend class MediaSubsessionIterator;
+  char* fCNAME; // used for RTCP
+
+  // Linkage fields:
+  MediaSubsession* fSubsessionsHead;
+  MediaSubsession* fSubsessionsTail;
+
+  // Fields set from a SDP description:
+  char* fConnectionEndpointName;
+  int fConnectionEndpointNameAddressFamily;
+  double fMaxPlayStartTime;
+  double fMaxPlayEndTime;
+  char* fAbsStartTime;
+  char* fAbsEndTime;
+  struct sockaddr_storage fSourceFilterAddr; // used for SSM
+  float fScale; // set from a RTSP "Scale:" header
+  float fSpeed;
+  char* fMediaSessionType; // holds a=type value
+  char* fSessionName; // holds s=<session name> value
+  char* fSessionDescription; // holds i=<session description> value
+  char* fControlPath; // holds optional a=control: string
+
+  // Optional key management and crypto state:
+  MIKEYState* fMIKEYState;
+  SRTPCryptographicContext* fCrypto;
+};
+
+
+class MediaSubsessionIterator {
+public:
+  MediaSubsessionIterator(MediaSession const& session);
+  virtual ~MediaSubsessionIterator();
+
+  MediaSubsession* next(); // NULL if none
+  void reset();
+
+private:
+  MediaSession const& fOurSession;
+  MediaSubsession* fNextPtr;
+};
+
+
+class MediaSubsession {
+public:
+  MediaSession& parentSession() { return fParent; }
+  MediaSession const& parentSession() const { return fParent; }
+
+  unsigned short clientPortNum() const { return fClientPortNum; }
+  unsigned char rtpPayloadFormat() const { return fRTPPayloadFormat; }
+  char const* savedSDPLines() const { return fSavedSDPLines; }
+  char const* mediumName() const { return fMediumName; }
+  char const* codecName() const { return fCodecName; }
+  char const* protocolName() const { return fProtocolName; }
+  char const* controlPath() const { return fControlPath; }
+
+  Boolean isSSM() const { return !addressIsNull(fSourceFilterAddr); }
+
+  unsigned short videoWidth() const { return fVideoWidth; }
+  unsigned short videoHeight() const { return fVideoHeight; }
+  unsigned videoFPS() const { return fVideoFPS; }
+  unsigned numChannels() const { return fNumChannels; }
+  float& scale() { return fScale; }
+  float& speed() { return fSpeed; }
+
+  RTPSource* rtpSource() { return fRTPSource; }
+  RTCPInstance* rtcpInstance() { return fRTCPInstance; }
+  unsigned rtpTimestampFrequency() const { return fRTPTimestampFrequency; }
+  Boolean rtcpIsMuxed() const { return fMultiplexRTCPWithRTP; }
+  FramedSource* readSource() { return fReadSource; }
+    // This is the source that client sinks read from.  It is usually
+    // (but not necessarily) the same as "rtpSource()"
+  void addFilter(FramedFilter* filter);
+    // Changes "readSource()" to "filter" (which must have just been created with "readSource()" as its input)
+
+  double playStartTime() const;
+  double playEndTime() const;
+  char* absStartTime() const;
+  char* absEndTime() const;
+  // Used only to set the local fields:
+  double& _playStartTime() { return fPlayStartTime; }
+  double& _playEndTime() { return fPlayEndTime; }
+  char*& _absStartTime() { return fAbsStartTime; }
+  char*& _absEndTime() { return fAbsEndTime; }
+
+  Boolean initiate(int useSpecialRTPoffset = -1);
+      // Creates a "RTPSource" for this subsession. (Has no effect if it's
+      // already been created.)  Returns True iff this succeeds.
+  void deInitiate(); // Destroys any previously created RTPSource
+  Boolean setClientPortNum(unsigned short portNum);
+      // Sets the preferred client port number that any "RTPSource" for
+      // this subsession would use.  (By default, the client port number
+      // is gotten from the original SDP description, or - if the SDP
+      // description does not specfy a client port number - an ephemeral
+      // (even) port number is chosen.)  This routine must *not* be
+      // called after initiate().
+  void receiveRawMP3ADUs() { fReceiveRawMP3ADUs = True; } // optional hack for audio/MPA-ROBUST; must not be called after initiate()
+  void receiveRawJPEGFrames() { fReceiveRawJPEGFrames = True; } // optional hack for video/JPEG; must not be called after initiate()
+  char*& connectionEndpointName() { return fConnectionEndpointName; }
+  char const* connectionEndpointName() const {
+    return fConnectionEndpointName;
+  }
+  int connectionEndpointNameAddressFamily() const {
+    return fConnectionEndpointNameAddressFamily == AF_UNSPEC
+      ? parentSession().connectionEndpointNameAddressFamily()
+      : fConnectionEndpointNameAddressFamily;
+  }
+
+  // 'Bandwidth' parameter, set in the "b=" SDP line:
+  unsigned bandwidth() const { return fBandwidth; }
+
+  // General SDP attribute accessor functions:
+  char const* attrVal_str(char const* attrName) const;
+      // returns "" if attribute doesn't exist (and has no default value), or is not a string
+  char const* attrVal_strToLower(char const* attrName) const;
+      // returns "" if attribute doesn't exist (and has no default value), or is not a string
+  unsigned attrVal_int(char const* attrName) const;
+      // also returns 0 if attribute doesn't exist (and has no default value)
+  unsigned attrVal_unsigned(char const* attrName) const { return (unsigned)attrVal_int(attrName); }
+  Boolean attrVal_bool(char const* attrName) const { return attrVal_int(attrName) != 0; }
+
+  // Old, now-deprecated SDP attribute accessor functions, kept here for backwards-compatibility:
+  char const* fmtp_config() const;
+  char const* fmtp_configuration() const { return fmtp_config(); }
+  char const* fmtp_spropparametersets() const { return attrVal_str("sprop-parameter-sets"); }
+  char const* fmtp_spropvps() const { return attrVal_str("sprop-vps"); }
+  char const* fmtp_spropsps() const { return attrVal_str("sprop-sps"); }
+  char const* fmtp_sproppps() const { return attrVal_str("sprop-pps"); }
+
+  void getConnectionEndpointAddress(struct sockaddr_storage& addr) const;
+      // Converts "fConnectionEndpointName" to an address (or 0 if unknown)
+  void setDestinations(struct sockaddr_storage const& defaultDestAddress);
+      // Uses "fConnectionEndpointName" and "serverPortNum" to set
+      // the destination address and port of the RTP and RTCP objects.
+      // This is typically called by RTSP clients after doing "SETUP".
+
+  char const* sessionId() const { return fSessionId; }
+  void setSessionId(char const* sessionId);
+
+  // Public fields that external callers can use to keep state.
+  // (They are responsible for all storage management on these fields)
+  unsigned short serverPortNum; // in host byte order (used by RTSP)
+  unsigned char rtpChannelId, rtcpChannelId; // used by RTSP (for RTP/TCP)
+  MediaSink* sink; // callers can use this to keep track of who's playing us
+  void* miscPtr; // callers can use this for whatever they want
+
+  // Parameters set from a RTSP "RTP-Info:" header:
+  struct {
+    u_int16_t seqNum;
+    u_int32_t timestamp;
+    Boolean infoIsNew; // not part of the RTSP header; instead, set whenever this struct is filled in
+  } rtpInfo;
+
+  double getNormalPlayTime(struct timeval const& presentationTime);
+  // Computes the stream's "Normal Play Time" (NPT) from the given "presentationTime".
+  // (For the definition of "Normal Play Time", see RFC 2326, section 3.6.)
+  // This function is useful only if the "rtpInfo" structure was previously filled in
+  // (e.g., by a "RTP-Info:" header in a RTSP response).
+  // Also, for this function to work properly, the RTP stream's presentation times must (eventually) be
+  // synchronized via RTCP.
+  // (Note: If this function returns a negative number, then the result should be ignored by the caller.)
+
+  MIKEYState* getMIKEYState() const { return fMIKEYState != NULL ? fMIKEYState : fParent.getMIKEYState(); }
+  SRTPCryptographicContext* getCrypto() const { return fCrypto != NULL ? fCrypto : fParent.getCrypto(); }
+
+protected:
+  friend class MediaSession;
+  friend class MediaSubsessionIterator;
+  MediaSubsession(MediaSession& parent);
+  virtual ~MediaSubsession();
+
+  UsageEnvironment& env() { return fParent.envir(); }
+  void setNext(MediaSubsession* next) { fNext = next; }
+
+  void setAttribute(char const* name, char const* value = NULL, Boolean valueIsHexadecimal = False);
+
+  Boolean parseSDPLine_c(char const* sdpLine);
+  Boolean parseSDPLine_b(char const* sdpLine);
+  Boolean parseSDPAttribute_rtpmap(char const* sdpLine);
+  Boolean parseSDPAttribute_rtcpmux(char const* sdpLine);
+  Boolean parseSDPAttribute_control(char const* sdpLine);
+  Boolean parseSDPAttribute_range(char const* sdpLine);
+  Boolean parseSDPAttribute_fmtp(char const* sdpLine);
+  Boolean parseSDPAttribute_source_filter(char const* sdpLine);
+  Boolean parseSDPAttribute_x_dimensions(char const* sdpLine);
+  Boolean parseSDPAttribute_framerate(char const* sdpLine);
+  Boolean parseSDPAttribute_key_mgmt(char const* sdpLine);
+
+  virtual Boolean createSourceObjects(int useSpecialRTPoffset);
+    // create "fRTPSource" and "fReadSource" member objects, after we've been initialized via SDP
+
+protected:
+  // Linkage fields:
+  MediaSession& fParent;
+  MediaSubsession* fNext;
+
+  // Fields set from a SDP description:
+  char* fConnectionEndpointName; // may also be set by RTSP SETUP response
+  int fConnectionEndpointNameAddressFamily;
+  unsigned short fClientPortNum; // in host byte order
+      // This field is also set by initiate()
+  unsigned char fRTPPayloadFormat;
+  char* fSavedSDPLines;
+  char* fMediumName;
+  char* fCodecName;
+  char* fProtocolName;
+  unsigned fRTPTimestampFrequency;
+  Boolean fMultiplexRTCPWithRTP;
+  char* fControlPath; // holds optional a=control: string
+
+  // Optional key management and crypto state:
+  MIKEYState* fMIKEYState;
+  SRTPCryptographicContext* fCrypto;
+
+  struct sockaddr_storage fSourceFilterAddr; // used for SSM
+  unsigned fBandwidth; // in kilobits-per-second, from b= line
+
+  double fPlayStartTime;
+  double fPlayEndTime;
+  char* fAbsStartTime;
+  char* fAbsEndTime;
+  unsigned short fVideoWidth, fVideoHeight;
+     // screen dimensions (set by an optional a=x-dimensions: <w>,<h> line)
+  unsigned fVideoFPS;
+     // frame rate (set by an optional "a=framerate: <fps>" or "a=x-framerate: <fps>" line)
+  unsigned fNumChannels;
+     // optionally set by "a=rtpmap:" lines for audio sessions.  Default: 1
+  float fScale; // set from a RTSP "Scale:" header
+  float fSpeed;
+  double fNPT_PTS_Offset; // set by "getNormalPlayTime()"; add this to a PTS to get NPT
+  HashTable* fAttributeTable; // for "a=fmtp:" attributes.  (Later an array by payload type #####)
+
+  // Fields set or used by initiate():
+  Groupsock* fRTPSocket; Groupsock* fRTCPSocket; // works even for unicast
+  RTPSource* fRTPSource; RTCPInstance* fRTCPInstance;
+  FramedSource* fReadSource;
+  Boolean fReceiveRawMP3ADUs, fReceiveRawJPEGFrames;
+
+  // Other fields:
+  char* fSessionId; // used by RTSP
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/MediaSink.hh b/3rdparty/live555/src/liveMedia/include/MediaSink.hh
new file mode 100644
index 00000000..a172bb0d
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/MediaSink.hh
@@ -0,0 +1,135 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// Media Sinks
+// C++ header
+
+#ifndef _MEDIA_SINK_HH
+#define _MEDIA_SINK_HH
+
+#ifndef _FRAMED_SOURCE_HH
+#include "FramedSource.hh"
+#endif
+
+class MediaSink: public Medium {
+public:
+  static Boolean lookupByName(UsageEnvironment& env, char const* sinkName,
+			      MediaSink*& resultSink);
+
+  typedef void (afterPlayingFunc)(void* clientData);
+  Boolean startPlaying(MediaSource& source,
+		       afterPlayingFunc* afterFunc,
+		       void* afterClientData);
+  virtual void stopPlaying();
+
+  // Test for specific types of sink:
+  virtual Boolean isRTPSink() const;
+
+  FramedSource* source() const {return fSource;}
+
+protected:
+  MediaSink(UsageEnvironment& env); // abstract base class
+  virtual ~MediaSink();
+
+  virtual Boolean sourceIsCompatibleWithUs(MediaSource& source);
+      // called by startPlaying()
+  virtual Boolean continuePlaying() = 0;
+      // called by startPlaying()
+
+  static void onSourceClosure(void* clientData); // can be used in "getNextFrame()" calls
+  void onSourceClosure();
+      // should be called (on ourselves) by continuePlaying() when it
+      // discovers that the source we're playing from has closed.
+
+  FramedSource* fSource;
+
+private:
+  // redefined virtual functions:
+  virtual Boolean isSink() const;
+
+private:
+  // The following fields are used when we're being played:
+  afterPlayingFunc* fAfterFunc;
+  void* fAfterClientData;
+};
+
+// A data structure that a sink may use for an output packet:
+class OutPacketBuffer {
+public:
+  OutPacketBuffer(unsigned preferredPacketSize, unsigned maxPacketSize,
+		  unsigned maxBufferSize = 0);
+      // if "maxBufferSize" is >0, use it - instead of "maxSize" to compute the buffer size
+  ~OutPacketBuffer();
+
+  static unsigned maxSize;
+  static void increaseMaxSizeTo(unsigned newMaxSize) { if (newMaxSize > OutPacketBuffer::maxSize) OutPacketBuffer::maxSize = newMaxSize; }
+
+  unsigned char* curPtr() const {return &fBuf[fPacketStart + fCurOffset];}
+  unsigned totalBytesAvailable() const {
+    return fLimit - (fPacketStart + fCurOffset);
+  }
+  unsigned totalBufferSize() const { return fLimit; }
+  unsigned char* packet() const {return &fBuf[fPacketStart];}
+  unsigned curPacketSize() const {return fCurOffset;}
+
+  void increment(unsigned numBytes) {fCurOffset += numBytes;}
+
+  void enqueue(unsigned char const* from, unsigned numBytes);
+  void enqueueWord(u_int32_t word);
+  void insert(unsigned char const* from, unsigned numBytes, unsigned toPosition);
+  void insertWord(u_int32_t word, unsigned toPosition);
+  void extract(unsigned char* to, unsigned numBytes, unsigned fromPosition);
+  u_int32_t extractWord(unsigned fromPosition);
+
+  void skipBytes(unsigned numBytes);
+
+  Boolean isPreferredSize() const {return fCurOffset >= fPreferred;}
+  Boolean wouldOverflow(unsigned numBytes) const {
+    return (fCurOffset+numBytes) > fMax;
+  }
+  unsigned numOverflowBytes(unsigned numBytes) const {
+    return (fCurOffset+numBytes) - fMax;
+  }
+  Boolean isTooBigForAPacket(unsigned numBytes) const {
+    return numBytes > fMax;
+  }
+
+  void setOverflowData(unsigned overflowDataOffset,
+		       unsigned overflowDataSize,
+		       struct timeval const& presentationTime,
+		       unsigned durationInMicroseconds);
+  unsigned overflowDataSize() const {return fOverflowDataSize;}
+  struct timeval overflowPresentationTime() const {return fOverflowPresentationTime;}
+  unsigned overflowDurationInMicroseconds() const {return fOverflowDurationInMicroseconds;}
+  Boolean haveOverflowData() const {return fOverflowDataSize > 0;}
+  void useOverflowData();
+
+  void adjustPacketStart(unsigned numBytes);
+  void resetPacketStart();
+  void resetOffset() { fCurOffset = 0; }
+  void resetOverflowData() { fOverflowDataOffset = fOverflowDataSize = 0; }
+
+private:
+  unsigned fPacketStart, fCurOffset, fPreferred, fMax, fLimit;
+  unsigned char* fBuf;
+
+  unsigned fOverflowDataOffset, fOverflowDataSize;
+  struct timeval fOverflowPresentationTime;
+  unsigned fOverflowDurationInMicroseconds;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/MediaSource.hh b/3rdparty/live555/src/liveMedia/include/MediaSource.hh
new file mode 100644
index 00000000..ffbf2609
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/MediaSource.hh
@@ -0,0 +1,59 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// Media Sources
+// C++ header
+
+#ifndef _MEDIA_SOURCE_HH
+#define _MEDIA_SOURCE_HH
+
+#ifndef _MEDIA_HH
+#include "Media.hh"
+#endif
+
+class MediaSource: public Medium {
+public:
+  static Boolean lookupByName(UsageEnvironment& env, char const* sourceName,
+			      MediaSource*& resultSource);
+  virtual void getAttributes() const;
+      // attributes are returned in "env's" 'result message'
+
+  // The MIME type of this source:
+  virtual char const* MIMEtype() const;
+
+  // Test for specific types of source:
+  virtual Boolean isFramedSource() const;
+  virtual Boolean isRTPSource() const;
+  virtual Boolean isMPEG1or2VideoStreamFramer() const;
+  virtual Boolean isMPEG4VideoStreamFramer() const;
+  virtual Boolean isH264VideoStreamFramer() const;
+  virtual Boolean isH265VideoStreamFramer() const;
+  virtual Boolean isDVVideoStreamFramer() const;
+  virtual Boolean isJPEGVideoSource() const;
+  virtual Boolean isAMRAudioSource() const;
+  virtual Boolean isMPEG2TransportStreamMultiplexor() const;
+
+protected:
+  MediaSource(UsageEnvironment& env); // abstract base class
+  virtual ~MediaSource();
+
+private:
+  // redefined virtual functions:
+  virtual Boolean isSource() const;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/MediaTranscodingTable.hh b/3rdparty/live555/src/liveMedia/include/MediaTranscodingTable.hh
new file mode 100644
index 00000000..fa569439
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/MediaTranscodingTable.hh
@@ -0,0 +1,66 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A class that implements a database that can be accessed to create
+// "FramedFilter" (subclass) objects that transcode one codec into another.
+// The implementation of this class just returns NULL for each codec lookup;
+// To actually implement transcoding, you would subclass it.
+// C++ header
+
+#ifndef _MEDIA_TRANSCODING_TABLE_HH
+#define _MEDIA_TRANSCODING_TABLE_HH
+
+#ifndef _FRAMED_FILTER_HH
+#include "FramedFilter.hh"
+#endif
+#ifndef _MEDIA_SESSION_HH
+#include "MediaSession.hh"
+#endif
+
+class MediaTranscodingTable: public Medium {
+public:
+  virtual FramedFilter*
+  lookupTranscoder(MediaSubsession& /*inputCodecDescription*/, // in
+		   char*& outputCodecName/* out; must be delete[]d later */) {
+    // Default implementation: Return NULL (indicating: no transcoding).
+    // You would reimplement this virtual function in a subclass to return a new 'transcoding'
+    // "FramedFilter" (subclass) object for each ("mediumName","codecName") that you wish to
+    // transcode (or return NULL for no transcoding).
+    // (Note that "inputCodecDescription" must have a non-NULL "readSource()"; this is used
+    //  as the input to the new "FramedFilter" (subclass) object.)
+    outputCodecName = NULL;
+    return NULL;
+  }
+
+  virtual Boolean weWillTranscode(char const* /*mediumName*/, char const* /*codecName*/) {
+    // Default implementation: Return False.
+    // You would reimplement this in a subclass - returning True for each
+    // <mediumName>/<codecName> for which you'll do transcoding.
+    // Note: Unlike "lookupTranscoder()", this function does not actually create any 'transcoding'
+    // filter objects.  (It may be called before "MediaSubsession::initiate()".)
+    return False;
+  }
+
+protected: // we are to be subclassed only
+  MediaTranscodingTable(UsageEnvironment& env)
+    : Medium(env) {
+  }
+  virtual ~MediaTranscodingTable() {
+  }
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/MultiFramedRTPSink.hh b/3rdparty/live555/src/liveMedia/include/MultiFramedRTPSink.hh
new file mode 100644
index 00000000..d86cc62c
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/MultiFramedRTPSink.hh
@@ -0,0 +1,140 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// RTP sink for a common kind of payload format: Those which pack multiple,
+// complete codec frames (as many as possible) into each RTP packet.
+// C++ header
+
+#ifndef _MULTI_FRAMED_RTP_SINK_HH
+#define _MULTI_FRAMED_RTP_SINK_HH
+
+#ifndef _RTP_SINK_HH
+#include "RTPSink.hh"
+#endif
+
+class MultiFramedRTPSink: public RTPSink {
+public:
+  void setPacketSizes(unsigned preferredPacketSize, unsigned maxPacketSize);
+
+  typedef void (onSendErrorFunc)(void* clientData);
+  void setOnSendErrorFunc(onSendErrorFunc* onSendErrorFunc, void* onSendErrorFuncData) {
+    // Can be used to set a callback function to be called if there's an error sending RTP packets on our socket.
+    fOnSendErrorFunc = onSendErrorFunc;
+    fOnSendErrorData = onSendErrorFuncData;
+  }
+
+protected:
+  MultiFramedRTPSink(UsageEnvironment& env,
+		     Groupsock* rtpgs, unsigned char rtpPayloadType,
+		     unsigned rtpTimestampFrequency,
+		     char const* rtpPayloadFormatName,
+		     unsigned numChannels = 1);
+	// we're a virtual base class
+
+  virtual ~MultiFramedRTPSink();
+
+  virtual void doSpecialFrameHandling(unsigned fragmentationOffset,
+				      unsigned char* frameStart,
+				      unsigned numBytesInFrame,
+				      struct timeval framePresentationTime,
+				      unsigned numRemainingBytes);
+      // perform any processing specific to the particular payload format
+  virtual Boolean allowFragmentationAfterStart() const;
+      // whether a frame can be fragmented if other frame(s) appear earlier
+      // in the packet (by default: False)
+  virtual Boolean allowOtherFramesAfterLastFragment() const;
+      // whether other frames can be packed into a packet following the
+      // final fragment of a previous, fragmented frame (by default: False)
+  virtual Boolean frameCanAppearAfterPacketStart(unsigned char const* frameStart,
+						 unsigned numBytesInFrame) const;
+      // whether this frame can appear in position >1 in a pkt (default: True)
+  virtual unsigned specialHeaderSize() const;
+      // returns the size of any special header used (following the RTP header) (default: 0)
+  virtual unsigned frameSpecificHeaderSize() const;
+      // returns the size of any frame-specific header used (before each frame
+      // within the packet) (default: 0)
+  virtual unsigned computeOverflowForNewFrame(unsigned newFrameSize) const;
+      // returns the number of overflow bytes that would be produced by adding a new
+      // frame of size "newFrameSize" to the current RTP packet.
+      // (By default, this just calls "numOverflowBytes()", but subclasses can redefine
+      // this to (e.g.) impose a granularity upon RTP payload fragments.)
+
+  // Functions that might be called by doSpecialFrameHandling(), or other subclass virtual functions:
+  Boolean isFirstPacket() const { return fIsFirstPacket; }
+  Boolean isFirstFrameInPacket() const { return fNumFramesUsedSoFar == 0; }
+  unsigned curFragmentationOffset() const { return fCurFragmentationOffset; }
+  void setMarkerBit();
+  void setTimestamp(struct timeval framePresentationTime);
+  void setSpecialHeaderWord(unsigned word, /* 32 bits, in host order */
+			    unsigned wordPosition = 0);
+  void setSpecialHeaderBytes(unsigned char const* bytes, unsigned numBytes,
+			     unsigned bytePosition = 0);
+  void setFrameSpecificHeaderWord(unsigned word, /* 32 bits, in host order */
+				  unsigned wordPosition = 0);
+  void setFrameSpecificHeaderBytes(unsigned char const* bytes, unsigned numBytes,
+				   unsigned bytePosition = 0);
+  void setFramePadding(unsigned numPaddingBytes);
+  unsigned numFramesUsedSoFar() const { return fNumFramesUsedSoFar; }
+  unsigned ourMaxPacketSize() const { return fOurMaxPacketSize; }
+
+public: // redefined virtual functions:
+  virtual void stopPlaying();
+
+protected: // redefined virtual functions:
+  virtual Boolean continuePlaying();
+
+private:
+  void buildAndSendPacket(Boolean isFirstPacket);
+  void packFrame();
+  void sendPacketIfNecessary();
+  static void sendNext(void* firstArg);
+  friend void sendNext(void*);
+
+  static void afterGettingFrame(void* clientData,
+				unsigned numBytesRead, unsigned numTruncatedBytes,
+				struct timeval presentationTime,
+				unsigned durationInMicroseconds);
+  void afterGettingFrame1(unsigned numBytesRead, unsigned numTruncatedBytes,
+			  struct timeval presentationTime,
+			  unsigned durationInMicroseconds);
+  Boolean isTooBigForAPacket(unsigned numBytes) const;
+
+  static void ourHandleClosure(void* clientData);
+
+private:
+  OutPacketBuffer* fOutBuf;
+
+  Boolean fNoFramesLeft;
+  unsigned fNumFramesUsedSoFar;
+  unsigned fCurFragmentationOffset;
+  Boolean fPreviousFrameEndedFragmentation;
+
+  Boolean fIsFirstPacket;
+  struct timeval fNextSendTime;
+  unsigned fTimestampPosition;
+  unsigned fSpecialHeaderPosition;
+  unsigned fSpecialHeaderSize; // size in bytes of any special header used
+  unsigned fCurFrameSpecificHeaderPosition;
+  unsigned fCurFrameSpecificHeaderSize; // size in bytes of cur frame-specific header
+  unsigned fTotalFrameSpecificHeaderSizes; // size of all frame-specific hdrs in pkt
+  unsigned fOurMaxPacketSize;
+
+  onSendErrorFunc* fOnSendErrorFunc;
+  void* fOnSendErrorData;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/MultiFramedRTPSource.hh b/3rdparty/live555/src/liveMedia/include/MultiFramedRTPSource.hh
new file mode 100644
index 00000000..a8bfcb6a
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/MultiFramedRTPSource.hh
@@ -0,0 +1,159 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// RTP source for a common kind of payload format: Those which pack multiple,
+// complete codec frames (as many as possible) into each RTP packet.
+// C++ header
+
+#ifndef _MULTI_FRAMED_RTP_SOURCE_HH
+#define _MULTI_FRAMED_RTP_SOURCE_HH
+
+#ifndef _RTP_SOURCE_HH
+#include "RTPSource.hh"
+#endif
+
+class BufferedPacket; // forward
+class BufferedPacketFactory; // forward
+
+class MultiFramedRTPSource: public RTPSource {
+protected:
+  MultiFramedRTPSource(UsageEnvironment& env, Groupsock* RTPgs,
+		       unsigned char rtpPayloadFormat,
+		       unsigned rtpTimestampFrequency,
+		       BufferedPacketFactory* packetFactory = NULL);
+      // virtual base class
+  virtual ~MultiFramedRTPSource();
+
+  virtual Boolean processSpecialHeader(BufferedPacket* packet,
+				       unsigned& resultSpecialHeaderSize);
+      // Subclasses redefine this to handle any special, payload format
+      // specific header that follows the RTP header.
+
+  virtual Boolean packetIsUsableInJitterCalculation(unsigned char* packet,
+						    unsigned packetSize);
+      // The default implementation returns True, but this can be redefined
+
+protected:
+  Boolean fCurrentPacketBeginsFrame;
+  Boolean fCurrentPacketCompletesFrame;
+
+protected:
+  // redefined virtual functions:
+  virtual void doGetNextFrame();
+  virtual void doStopGettingFrames();
+
+private:
+  // redefined virtual functions:
+  virtual void setPacketReorderingThresholdTime(unsigned uSeconds);
+
+private:
+  void reset();
+  void doGetNextFrame1();
+
+  static void networkReadHandler(MultiFramedRTPSource* source, int /*mask*/);
+  void networkReadHandler1();
+
+  Boolean fAreDoingNetworkReads;
+  BufferedPacket* fPacketReadInProgress;
+  Boolean fNeedDelivery;
+  Boolean fPacketLossInFragmentedFrame;
+  unsigned char* fSavedTo;
+  unsigned fSavedMaxSize;
+
+  // A buffer to (optionally) hold incoming pkts that have been reorderered
+  class ReorderingPacketBuffer* fReorderingBuffer;
+};
+
+
+// A 'packet data' class that's used to implement the above.
+// Note that this can be subclassed - if desired - to redefine
+// "nextEnclosedFrameParameters()".
+
+class BufferedPacket {
+public:
+  BufferedPacket();
+  virtual ~BufferedPacket();
+
+  Boolean hasUsableData() const { return fTail > fHead; }
+  unsigned useCount() const { return fUseCount; }
+
+  Boolean fillInData(RTPInterface& rtpInterface, struct sockaddr_storage& fromAddress, Boolean& packetReadWasIncomplete);
+  void assignMiscParams(unsigned short rtpSeqNo, unsigned rtpTimestamp,
+			struct timeval presentationTime,
+			Boolean hasBeenSyncedUsingRTCP,
+			Boolean rtpMarkerBit, struct timeval timeReceived);
+  void skip(unsigned numBytes); // used to skip over an initial header
+  void removePadding(unsigned numBytes); // used to remove trailing bytes
+  void appendData(unsigned char* newData, unsigned numBytes);
+  void use(unsigned char* to, unsigned toSize,
+	   unsigned& bytesUsed, unsigned& bytesTruncated,
+	   unsigned short& rtpSeqNo, unsigned& rtpTimestamp,
+	   struct timeval& presentationTime,
+	   Boolean& hasBeenSyncedUsingRTCP, Boolean& rtpMarkerBit);
+
+  BufferedPacket*& nextPacket() { return fNextPacket; }
+
+  unsigned short rtpSeqNo() const { return fRTPSeqNo; }
+  struct timeval const& timeReceived() const { return fTimeReceived; }
+
+  unsigned char* data() const { return &fBuf[fHead]; }
+  unsigned dataSize() const { return fTail-fHead; }
+  Boolean rtpMarkerBit() const { return fRTPMarkerBit; }
+  Boolean& isFirstPacket() { return fIsFirstPacket; }
+  unsigned bytesAvailable() const { return fPacketSize - fTail; }
+
+protected:
+  virtual void reset();
+  virtual unsigned nextEnclosedFrameSize(unsigned char*& framePtr,
+					 unsigned dataSize);
+      // The above function has been deprecated.  Instead, new subclasses should use:
+  virtual void getNextEnclosedFrameParameters(unsigned char*& framePtr,
+					      unsigned dataSize,
+					      unsigned& frameSize,
+					      unsigned& frameDurationInMicroseconds);
+
+  unsigned fPacketSize;
+  unsigned char* fBuf;
+  unsigned fHead;
+  unsigned fTail;
+
+private:
+  BufferedPacket* fNextPacket; // used to link together packets
+
+  unsigned fUseCount;
+  unsigned short fRTPSeqNo;
+  unsigned fRTPTimestamp;
+  struct timeval fPresentationTime; // corresponding to "fRTPTimestamp"
+  Boolean fHasBeenSyncedUsingRTCP;
+  Boolean fRTPMarkerBit;
+  Boolean fIsFirstPacket;
+  struct timeval fTimeReceived;
+};
+
+// A 'factory' class for creating "BufferedPacket" objects.
+// If you want to subclass "BufferedPacket", then you'll also
+// want to subclass this, to redefine createNewPacket()
+
+class BufferedPacketFactory {
+public:
+  BufferedPacketFactory();
+  virtual ~BufferedPacketFactory();
+
+  virtual BufferedPacket* createNewPacket(MultiFramedRTPSource* ourSource);
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/OggFile.hh b/3rdparty/live555/src/liveMedia/include/OggFile.hh
new file mode 100644
index 00000000..11d50a72
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/OggFile.hh
@@ -0,0 +1,179 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A class that encapsulates an Ogg file
+// C++ header
+
+#ifndef _OGG_FILE_HH
+#define _OGG_FILE_HH
+
+#ifndef _RTP_SINK_HH
+#include "RTPSink.hh"
+#endif
+#ifndef _HASH_TABLE_HH
+#include "HashTable.hh"
+#endif
+
+class OggTrack; // forward
+class OggDemux; // forward
+
+typedef void OggDemuxOnDeletionFunc(void* objectToNotify, OggDemux* demuxBeingDeleted);
+
+class OggFile: public Medium {
+public:
+  typedef void (onCreationFunc)(OggFile* newFile, void* clientData);
+  static void createNew(UsageEnvironment& env, char const* fileName,
+			onCreationFunc* onCreation, void* onCreationClientData);
+      // Note: Unlike most "createNew()" functions, this one doesn't return a new object
+      // immediately.  Instead, because this class requires file reading (to parse the
+      // Ogg track headers) before a new object can be initialized, the creation of a new object
+      // is signalled by calling - from the event loop - an 'onCreationFunc' that is passed as
+      // a parameter to "createNew()".
+
+  OggTrack* lookup(u_int32_t trackNumber);
+
+  OggDemux* newDemux(OggDemuxOnDeletionFunc* onDeletionFunc = NULL, void* objectToNotify = NULL);
+      // Creates a demultiplexor for extracting tracks from this file.
+      // (Separate clients will typically have separate demultiplexors.)
+
+  char const* fileName() const { return fFileName; }
+  unsigned numTracks() const;
+
+  FramedSource*
+  createSourceForStreaming(FramedSource* baseSource, u_int32_t trackNumber,
+                           unsigned& estBitrate, unsigned& numFiltersInFrontOfTrack);
+    // Takes a data source (which must be a demultiplexed track from this file) and returns
+    // a (possibly modified) data source that can be used for streaming.
+
+  RTPSink* createRTPSinkForTrackNumber(u_int32_t trackNumber, Groupsock* rtpGroupsock,
+                                       unsigned char rtpPayloadTypeIfDynamic);
+    // Creates a "RTPSink" object that would be appropriate for streaming the specified track,
+    // or NULL if no appropriate "RTPSink" exists
+
+  class OggTrackTable& trackTable() { return *fTrackTable; }
+
+private:
+  OggFile(UsageEnvironment& env, char const* fileName, onCreationFunc* onCreation, void* onCreationClientData);
+    // called only by createNew()
+  virtual ~OggFile();
+
+  static void handleEndOfBosPageParsing(void* clientData);
+  void handleEndOfBosPageParsing();
+
+  void addTrack(OggTrack* newTrack);
+  void removeDemux(OggDemux* demux);
+
+private:
+  friend class OggFileParser;
+  friend class OggDemux;
+  char const* fFileName;
+  onCreationFunc* fOnCreation;
+  void* fOnCreationClientData;
+
+  class OggTrackTable* fTrackTable;
+  HashTable* fDemuxesTable;
+  class OggFileParser* fParserForInitialization;
+};
+
+class OggTrack {
+public:
+  OggTrack();
+  virtual ~OggTrack();
+
+  // track parameters
+  u_int32_t trackNumber; // bitstream serial number
+  char const* mimeType; // NULL if not known
+
+  unsigned samplingFrequency, numChannels; // for audio tracks
+  unsigned estBitrate; // estimate, in kbps (for RTCP)
+
+  // Special headers for Vorbis audio, Theora video, and Opus audio tracks:
+  struct _vtoHdrs {
+    u_int8_t* header[3]; // "identification", "comment", "setup"
+    unsigned headerSize[3];
+
+    // Fields specific to Vorbis audio:
+    unsigned blocksize[2]; // samples per frame (packet)
+    unsigned uSecsPerPacket[2]; // computed as (blocksize[i]*1000000)/samplingFrequency
+    unsigned vorbis_mode_count;
+    unsigned ilog_vorbis_mode_count_minus_1;
+    u_int8_t* vorbis_mode_blockflag;
+        // an array (of size "vorbis_mode_count") of indexes into the (2-entry) "blocksize" array
+
+    // Fields specific to Theora video:
+    u_int8_t KFGSHIFT;
+    unsigned uSecsPerFrame;
+
+  } vtoHdrs;
+
+  Boolean weNeedHeaders() const {
+    return
+      vtoHdrs.header[0] == NULL ||
+      vtoHdrs.header[1] == NULL ||
+      (vtoHdrs.header[2] == NULL && strcmp(mimeType, "audio/OPUS") != 0);
+    }
+};
+
+class OggTrackTableIterator {
+public:
+  OggTrackTableIterator(class OggTrackTable& ourTable);
+  virtual ~OggTrackTableIterator();
+
+  OggTrack* next();
+
+private:
+  HashTable::Iterator* fIter;
+};
+
+class OggDemux: public Medium {
+public:
+  FramedSource* newDemuxedTrack(u_int32_t& resultTrackNumber);
+    // Returns a new stream ("FramedSource" subclass) that represents the next media track
+    // from the file.  This function returns NULL when no more media tracks exist.
+
+  FramedSource* newDemuxedTrackByTrackNumber(unsigned trackNumber);
+      // As above, but creates a new stream for a specific track number within the Matroska file.
+      // (You should not call this function more than once with the same track number.)
+
+      // Note: We assume that:
+      // - Every track created by "newDemuxedTrack()" is later read
+      // - All calls to "newDemuxedTrack()" are made before any track is read
+
+protected:
+  friend class OggFile;
+  friend class OggFileParser;
+  class OggDemuxedTrack* lookupDemuxedTrack(u_int32_t trackNumber);
+
+  OggDemux(OggFile& ourFile);
+  virtual ~OggDemux();
+
+private:
+  friend class OggDemuxedTrack;
+  void removeTrack(u_int32_t trackNumber);
+  void continueReading(); // called by a demuxed track to tell us that it has a pending read ("doGetNextFrame()")
+
+  static void handleEndOfFile(void* clientData);
+  void handleEndOfFile();
+
+private:
+  OggFile& fOurFile;
+  class OggFileParser* fOurParser;
+  HashTable* fDemuxedTracksTable;
+  OggTrackTableIterator* fIter;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/OggFileServerDemux.hh b/3rdparty/live555/src/liveMedia/include/OggFileServerDemux.hh
new file mode 100644
index 00000000..fa4913ed
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/OggFileServerDemux.hh
@@ -0,0 +1,85 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A server demultiplexor for an Ogg file
+// C++ header
+
+#ifndef _OGG_FILE_SERVER_DEMUX_HH
+#define _OGG_FILE_SERVER_DEMUX_HH
+
+#ifndef _SERVER_MEDIA_SESSION_HH
+#include "ServerMediaSession.hh"
+#endif
+
+#ifndef _OGG_FILE_HH
+#include "OggFile.hh"
+#endif
+
+class OggFileServerDemux: public Medium {
+public:
+  typedef void (onCreationFunc)(OggFileServerDemux* newDemux, void* clientData);
+  static void createNew(UsageEnvironment& env, char const* fileName,
+			onCreationFunc* onCreation, void* onCreationClientData);
+    // Note: Unlike most "createNew()" functions, this one doesn't return a new object immediately.  Instead, because this class
+    // requires file reading (to parse the Ogg 'Track' headers) before a new object can be initialized, the creation of a new
+    // object is signalled by calling - from the event loop - an 'onCreationFunc' that is passed as a parameter to "createNew()". 
+
+  ServerMediaSubsession* newServerMediaSubsession();
+  ServerMediaSubsession* newServerMediaSubsession(u_int32_t& resultTrackNumber);
+    // Returns a new "ServerMediaSubsession" object that represents the next media track
+    // from the file.  This function returns NULL when no more media tracks exist.
+
+  ServerMediaSubsession* newServerMediaSubsessionByTrackNumber(u_int32_t trackNumber);
+  // As above, but creates a new "ServerMediaSubsession" object for a specific track number
+  // within the Ogg file.
+  // (You should not call this function more than once with the same track number.)
+
+  // The following public: member functions are called only by the "ServerMediaSubsession" objects:
+
+  OggFile* ourOggFile() { return fOurOggFile; }
+  char const* fileName() const { return fFileName; }
+
+  FramedSource* newDemuxedTrack(unsigned clientSessionId, u_int32_t trackNumber);
+    // Used by the "ServerMediaSubsession" objects to implement their "createNewStreamSource()" virtual function.
+
+private:
+  OggFileServerDemux(UsageEnvironment& env, char const* fileName,
+		     onCreationFunc* onCreation, void* onCreationClientData);
+      // called only by createNew()
+  virtual ~OggFileServerDemux();
+
+  static void onOggFileCreation(OggFile* newFile, void* clientData);
+  void onOggFileCreation(OggFile* newFile);
+
+  static void onDemuxDeletion(void* clientData, OggDemux* demuxBeingDeleted);
+  void onDemuxDeletion(OggDemux* demuxBeingDeleted);
+  
+private:
+  char const* fFileName; 
+  onCreationFunc* fOnCreation;
+  void* fOnCreationClientData;
+  OggFile* fOurOggFile;
+
+  // Used to implement "newServerMediaSubsession()":
+  OggTrackTableIterator* fIter;
+
+  // Used to set up demuxing, to implement "newDemuxedTrack()":
+  unsigned fLastClientSessionId;
+  OggDemux* fLastCreatedDemux;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/OggFileSink.hh b/3rdparty/live555/src/liveMedia/include/OggFileSink.hh
new file mode 100644
index 00000000..471822a6
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/OggFileSink.hh
@@ -0,0 +1,79 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// 'Ogg' File Sink (recording a single media track only)
+// C++ header
+
+#ifndef _OGG_FILE_SINK_HH
+#define _OGG_FILE_SINK_HH
+
+#ifndef _FILE_SINK_HH
+#include "FileSink.hh"
+#endif
+
+class OggFileSink: public FileSink {
+public:
+  static OggFileSink* createNew(UsageEnvironment& env, char const* fileName,
+				unsigned samplingFrequency = 0, // used for granule_position
+				char const* configStr = NULL,
+      // "configStr" is an optional 'SDP format' string (Base64-encoded)
+      // representing 'packed configuration headers' ("identification", "comment", "setup")
+      // to prepend to the output.  (For 'Vorbis" audio and 'Theora' video.)
+				unsigned bufferSize = 100000,
+				Boolean oneFilePerFrame = False);
+      // See "FileSink.hh" for a description of these parameters.
+
+protected:
+  OggFileSink(UsageEnvironment& env, FILE* fid, unsigned samplingFrequency, char const* configStr,
+	      unsigned bufferSize, char const* perFrameFileNamePrefix);
+      // called only by createNew()
+  virtual ~OggFileSink();
+
+protected: // redefined virtual functions:
+  virtual Boolean continuePlaying();
+  virtual void addData(unsigned char const* data, unsigned dataSize,
+		       struct timeval presentationTime);
+  virtual void afterGettingFrame(unsigned frameSize, unsigned numTruncatedBytes,
+				 struct timeval presentationTime);
+
+private:
+  static void ourOnSourceClosure(void* clientData);
+  void ourOnSourceClosure();
+
+private:
+  unsigned fSamplingFrequency;
+  char const* fConfigStr;
+  Boolean fHaveWrittenFirstFrame, fHaveSeenEOF;
+  struct timeval fFirstPresentationTime;
+  int64_t fGranulePosition;
+  int64_t fGranulePositionAdjustment; // used to ensure that "fGranulePosition" stays monotonic
+  u_int32_t fPageSequenceNumber;
+  u_int8_t fPageHeaderBytes[27];
+      // the header of each Ogg page, through the "number_page_segments" byte
+
+  // Special fields used for Theora video:
+  Boolean fIsTheora;
+  u_int64_t fGranuleIncrementPerFrame; // == 1 << KFGSHIFT
+
+  // Because the last Ogg page before EOF needs to have a special 'eos' bit set in the header,
+  // we need to defer the writing of each incoming frame.  To do this, we maintain a 2nd buffer:
+  unsigned char* fAltBuffer;
+  unsigned fAltFrameSize, fAltNumTruncatedBytes;
+  struct timeval fAltPresentationTime;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/OnDemandServerMediaSubsession.hh b/3rdparty/live555/src/liveMedia/include/OnDemandServerMediaSubsession.hh
new file mode 100644
index 00000000..f9087fba
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/OnDemandServerMediaSubsession.hh
@@ -0,0 +1,233 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A 'ServerMediaSubsession' object that creates new, unicast, "RTPSink"s
+// on demand.
+// C++ header
+
+#ifndef _ON_DEMAND_SERVER_MEDIA_SUBSESSION_HH
+#define _ON_DEMAND_SERVER_MEDIA_SUBSESSION_HH
+
+#ifndef _SERVER_MEDIA_SESSION_HH
+#include "ServerMediaSession.hh"
+#endif
+#ifndef _RTP_SINK_HH
+#include "RTPSink.hh"
+#endif
+#ifndef _BASIC_UDP_SINK_HH
+#include "BasicUDPSink.hh"
+#endif
+#ifndef _RTCP_HH
+#include "RTCP.hh"
+#endif
+
+class OnDemandServerMediaSubsession: public ServerMediaSubsession {
+protected: // we're a virtual base class
+  OnDemandServerMediaSubsession(UsageEnvironment& env, Boolean reuseFirstSource,
+				portNumBits initialPortNum = 6970,
+				Boolean multiplexRTCPWithRTP = False);
+  virtual ~OnDemandServerMediaSubsession();
+
+protected: // redefined virtual functions
+  virtual char const* sdpLines(int addressFamily);
+  virtual void getStreamParameters(unsigned clientSessionId,
+				   struct sockaddr_storage const& clientAddress,
+                                   Port const& clientRTPPort,
+                                   Port const& clientRTCPPort,
+				   int tcpSocketNum,
+                                   unsigned char rtpChannelId,
+                                   unsigned char rtcpChannelId,
+				   TLSState* tlsState,
+                                   struct sockaddr_storage& destinationAddress,
+				   u_int8_t& destinationTTL,
+                                   Boolean& isMulticast,
+                                   Port& serverRTPPort,
+                                   Port& serverRTCPPort,
+                                   void*& streamToken);
+  virtual void startStream(unsigned clientSessionId, void* streamToken,
+			   TaskFunc* rtcpRRHandler,
+			   void* rtcpRRHandlerClientData,
+			   unsigned short& rtpSeqNum,
+                           unsigned& rtpTimestamp,
+			   ServerRequestAlternativeByteHandler* serverRequestAlternativeByteHandler,
+                           void* serverRequestAlternativeByteHandlerClientData);
+  virtual void pauseStream(unsigned clientSessionId, void* streamToken);
+  virtual void seekStream(unsigned clientSessionId, void* streamToken, double& seekNPT, double streamDuration, u_int64_t& numBytes);
+  virtual void seekStream(unsigned clientSessionId, void* streamToken, char*& absStart, char*& absEnd);
+  virtual void nullSeekStream(unsigned clientSessionId, void* streamToken,
+			      double streamEndTime, u_int64_t& numBytes);
+  virtual void setStreamScale(unsigned clientSessionId, void* streamToken, float scale);
+  virtual float getCurrentNPT(void* streamToken);
+  virtual FramedSource* getStreamSource(void* streamToken);
+  virtual void getRTPSinkandRTCP(void* streamToken,
+				 RTPSink const*& rtpSink, RTCPInstance const*& rtcp);
+  virtual void deleteStream(unsigned clientSessionId, void*& streamToken);
+
+protected: // new virtual functions, possibly redefined by subclasses
+  virtual char const* getAuxSDPLine(RTPSink* rtpSink,
+				    FramedSource* inputSource);
+  virtual void seekStreamSource(FramedSource* inputSource, double& seekNPT, double streamDuration, u_int64_t& numBytes);
+    // This routine is used to seek by relative (i.e., NPT) time.
+    // "streamDuration", if >0.0, specifies how much data to stream, past "seekNPT".  (If <=0.0, all remaining data is streamed.)
+    // "numBytes" returns the size (in bytes) of the data to be streamed, or 0 if unknown or unlimited.
+  virtual void seekStreamSource(FramedSource* inputSource, char*& absStart, char*& absEnd);
+    // This routine is used to seek by 'absolute' time.
+    // "absStart" should be a string of the form "YYYYMMDDTHHMMSSZ" or "YYYYMMDDTHHMMSS.<frac>Z".
+    // "absEnd" should be either NULL (for no end time), or a string of the same form as "absStart".
+    // These strings may be modified in-place, or can be reassigned to a newly-allocated value (after delete[]ing the original).
+  virtual void setStreamSourceScale(FramedSource* inputSource, float scale);
+  virtual void setStreamSourceDuration(FramedSource* inputSource, double streamDuration, u_int64_t& numBytes);
+  virtual void closeStreamSource(FramedSource* inputSource);
+
+protected: // new virtual functions, defined by all subclasses
+  virtual FramedSource* createNewStreamSource(unsigned clientSessionId,
+					      unsigned& estBitrate) = 0;
+      // "estBitrate" is the stream's estimated bitrate, in kbps
+  virtual RTPSink* createNewRTPSink(Groupsock* rtpGroupsock,
+				    unsigned char rtpPayloadTypeIfDynamic,
+				    FramedSource* inputSource) = 0;
+
+protected: // new virtual functions, may be redefined by a subclass:
+  virtual Groupsock* createGroupsock(struct sockaddr_storage const& addr, Port port);
+  virtual RTCPInstance* createRTCP(Groupsock* RTCPgs, unsigned totSessionBW, /* in kbps */
+				   unsigned char const* cname, RTPSink* sink);
+
+public:
+  void multiplexRTCPWithRTP() { fMultiplexRTCPWithRTP = True; }
+    // An alternative to passing the "multiplexRTCPWithRTP" parameter as True in the constructor
+
+  void setRTCPAppPacketHandler(RTCPAppHandlerFunc* handler, void* clientData);
+    // Sets a handler to be called if a RTCP "APP" packet arrives from any future client.
+    // (Any current clients are not affected; any "APP" packets from them will continue to be
+    // handled by whatever handler existed when the client sent its first RTSP "PLAY" command.)
+    // (Call with (NULL, NULL) to remove an existing handler - for future clients only)
+
+  void sendRTCPAppPacket(u_int8_t subtype, char const* name,
+			 u_int8_t* appDependentData, unsigned appDependentDataSize);
+    // Sends a custom RTCP "APP" packet to the most recent client (if "reuseFirstSource" was False),
+    // or to all current clients (if "reuseFirstSource" was True).
+    // The parameters correspond to their
+    // respective fields as described in the RTP/RTCP definition (RFC 3550).
+    // Note that only the low-order 5 bits of "subtype" are used, and only the first 4 bytes
+    // of "name" are used.  (If "name" has fewer than 4 bytes, or is NULL,
+    // then the remaining bytes are '\0'.)
+
+protected:
+  void setSDPLinesFromRTPSink(RTPSink* rtpSink, FramedSource* inputSource,
+			      unsigned estBitrate);
+      // used to implement "sdpLines()"
+
+protected:
+  char* fSDPLines;
+  u_int8_t* fMIKEYStateMessage; // used if we're streaming SRTP
+  unsigned fMIKEYStateMessageSize; // ditto
+  HashTable* fDestinationsHashTable; // indexed by client session id
+
+private:
+  Boolean fReuseFirstSource;
+  portNumBits fInitialPortNum;
+  Boolean fMultiplexRTCPWithRTP;
+  void* fLastStreamToken;
+  char fCNAME[100]; // for RTCP
+  RTCPAppHandlerFunc* fAppHandlerTask;
+  void* fAppHandlerClientData;
+  friend class StreamState;
+};
+
+
+// A class that represents the state of an ongoing stream.  This is used only internally, in the implementation of
+// "OnDemandServerMediaSubsession", but we expose the definition here, in case subclasses of "OnDemandServerMediaSubsession"
+// want to access it.
+
+class Destinations {
+public:
+  Destinations(struct sockaddr_storage const& destAddr,
+               Port const& rtpDestPort,
+               Port const& rtcpDestPort)
+    : isTCP(False), addr(destAddr), rtpPort(rtpDestPort), rtcpPort(rtcpDestPort) {
+  }
+  Destinations(int tcpSockNum, unsigned char rtpChanId, unsigned char rtcpChanId,
+	       TLSState* tlsSt)
+    : isTCP(True), rtpPort(0) /*dummy*/, rtcpPort(0) /*dummy*/,
+      tcpSocketNum(tcpSockNum), rtpChannelId(rtpChanId), rtcpChannelId(rtcpChanId),
+      tlsState(tlsSt) {
+  }
+
+public:
+  Boolean isTCP;
+  struct sockaddr_storage addr;
+  Port rtpPort;
+  Port rtcpPort;
+  int tcpSocketNum;
+  unsigned char rtpChannelId, rtcpChannelId;
+  TLSState* tlsState;
+};
+
+class StreamState {
+public:
+  StreamState(OnDemandServerMediaSubsession& master,
+              Port const& serverRTPPort, Port const& serverRTCPPort,
+	      RTPSink* rtpSink, BasicUDPSink* udpSink,
+	      unsigned totalBW, FramedSource* mediaSource,
+	      Groupsock* rtpGS, Groupsock* rtcpGS);
+  virtual ~StreamState();
+
+  void startPlaying(Destinations* destinations, unsigned clientSessionId,
+		    TaskFunc* rtcpRRHandler, void* rtcpRRHandlerClientData,
+		    ServerRequestAlternativeByteHandler* serverRequestAlternativeByteHandler,
+                    void* serverRequestAlternativeByteHandlerClientData);
+  void pause();
+  void sendRTCPAppPacket(u_int8_t subtype, char const* name,
+			 u_int8_t* appDependentData, unsigned appDependentDataSize);
+  void endPlaying(Destinations* destinations, unsigned clientSessionId);
+  void reclaim();
+
+  unsigned& referenceCount() { return fReferenceCount; }
+
+  Port const& serverRTPPort() const { return fServerRTPPort; }
+  Port const& serverRTCPPort() const { return fServerRTCPPort; }
+
+  RTPSink* rtpSink() const { return fRTPSink; }
+  RTCPInstance* rtcpInstance() const { return fRTCPInstance; }
+
+  float streamDuration() const { return fStreamDuration; }
+
+  FramedSource* mediaSource() const { return fMediaSource; }
+  float& startNPT() { return fStartNPT; }
+
+private:
+  OnDemandServerMediaSubsession& fMaster;
+  Boolean fAreCurrentlyPlaying;
+  unsigned fReferenceCount;
+
+  Port fServerRTPPort, fServerRTCPPort;
+
+  RTPSink* fRTPSink;
+  BasicUDPSink* fUDPSink;
+
+  float fStreamDuration;
+  unsigned fTotalBW;
+  RTCPInstance* fRTCPInstance;
+
+  FramedSource* fMediaSource;
+  float fStartNPT; // initial 'normal play time'; reset after each seek
+
+  Groupsock* fRTPgs;
+  Groupsock* fRTCPgs;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/OutputFile.hh b/3rdparty/live555/src/liveMedia/include/OutputFile.hh
new file mode 100644
index 00000000..83f958eb
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/OutputFile.hh
@@ -0,0 +1,31 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// Common routines for opening/closing named output files
+// C++ header
+
+#ifndef _OUTPUT_FILE_HH
+#define _OUTPUT_FILE_HH
+
+#include <UsageEnvironment.hh>
+#include <stdio.h>
+
+FILE* OpenOutputFile(UsageEnvironment& env, char const* fileName);
+
+void CloseOutputFile(FILE* fid);
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/PassiveServerMediaSubsession.hh b/3rdparty/live555/src/liveMedia/include/PassiveServerMediaSubsession.hh
new file mode 100644
index 00000000..98ea24c0
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/PassiveServerMediaSubsession.hh
@@ -0,0 +1,83 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A 'ServerMediaSubsession' object that represents an existing
+// 'RTPSink', rather than one that creates new 'RTPSink's on demand.
+// C++ header
+
+#ifndef _PASSIVE_SERVER_MEDIA_SUBSESSION_HH
+#define _PASSIVE_SERVER_MEDIA_SUBSESSION_HH
+
+#ifndef _SERVER_MEDIA_SESSION_HH
+#include "ServerMediaSession.hh"
+#endif
+
+#ifndef _RTP_SINK_HH
+#include "RTPSink.hh"
+#endif
+#ifndef _RTCP_HH
+#include "RTCP.hh"
+#endif
+
+class PassiveServerMediaSubsession: public ServerMediaSubsession {
+public:
+  static PassiveServerMediaSubsession* createNew(RTPSink& rtpSink,
+						 RTCPInstance* rtcpInstance = NULL);
+
+protected:
+  PassiveServerMediaSubsession(RTPSink& rtpSink, RTCPInstance* rtcpInstance);
+      // called only by createNew();
+  virtual ~PassiveServerMediaSubsession();
+
+  virtual Boolean rtcpIsMuxed();
+
+protected: // redefined virtual functions
+  virtual char const* sdpLines(int addressFamily);
+  virtual void getStreamParameters(unsigned clientSessionId,
+				   struct sockaddr_storage const& clientAddress,
+                                   Port const& clientRTPPort,
+                                   Port const& clientRTCPPort,
+				   int tcpSocketNum,
+                                   unsigned char rtpChannelId,
+                                   unsigned char rtcpChannelId,
+				   TLSState* tlsSTate,
+                                   struct sockaddr_storage& destinationAddress,
+				   u_int8_t& destinationTTL,
+                                   Boolean& isMulticast,
+                                   Port& serverRTPPort,
+                                   Port& serverRTCPPort,
+                                   void*& streamToken);
+  virtual void startStream(unsigned clientSessionId, void* streamToken,
+			   TaskFunc* rtcpRRHandler,
+			   void* rtcpRRHandlerClientData,
+                           unsigned short& rtpSeqNum,
+                           unsigned& rtpTimestamp,
+			   ServerRequestAlternativeByteHandler* serverRequestAlternativeByteHandler,
+                           void* serverRequestAlternativeByteHandlerClientData);
+  virtual float getCurrentNPT(void* streamToken);
+  virtual void getRTPSinkandRTCP(void* streamToken,
+				 RTPSink const*& rtpSink, RTCPInstance const*& rtcp);
+  virtual void deleteStream(unsigned clientSessionId, void*& streamToken);
+
+protected:
+  char* fSDPLines;
+  RTPSink& fRTPSink;
+  RTCPInstance* fRTCPInstance;
+  HashTable* fClientRTCPSourceRecords; // indexed by client session id; used to implement RTCP "RR" handling
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/ProxyServerMediaSession.hh b/3rdparty/live555/src/liveMedia/include/ProxyServerMediaSession.hh
new file mode 100644
index 00000000..1c41ee52
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/ProxyServerMediaSession.hh
@@ -0,0 +1,238 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A subclass of "ServerMediaSession" that can be used to create a (unicast) RTSP servers that acts as a 'proxy' for
+// another (unicast or multicast) RTSP/RTP stream.
+// C++ header
+
+#ifndef _PROXY_SERVER_MEDIA_SESSION_HH
+#define _PROXY_SERVER_MEDIA_SESSION_HH
+
+#ifndef _SERVER_MEDIA_SESSION_HH
+#include "ServerMediaSession.hh"
+#endif
+#ifndef _MEDIA_SESSION_HH
+#include "MediaSession.hh"
+#endif
+#ifndef _RTSP_CLIENT_HH
+#include "RTSPClient.hh"
+#endif
+#ifndef _MEDIA_TRANSCODING_TABLE_HH
+#include "MediaTranscodingTable.hh"
+#endif
+
+// A subclass of "RTSPClient", used to refer to the particular "ProxyServerMediaSession" object being used.
+// It is used only within the implementation of "ProxyServerMediaSession", but is defined here, in case developers wish to
+// subclass it.
+
+class ProxyRTSPClient: public RTSPClient {
+public:
+  ProxyRTSPClient(class ProxyServerMediaSession& ourServerMediaSession, char const* rtspURL,
+                  char const* username, char const* password,
+                  portNumBits tunnelOverHTTPPortNum, int verbosityLevel, int socketNumToServer);
+  virtual ~ProxyRTSPClient();
+
+  void continueAfterDESCRIBE(char const* sdpDescription);
+  void continueAfterLivenessCommand(int resultCode, Boolean serverSupportsGetParameter);
+  void continueAfterSETUP(int resultCode);
+  void continueAfterPLAY(int resultCode);
+  void scheduleReset();
+
+private:
+  void reset();
+  int connectToServer(int socketNum, portNumBits remotePortNum);
+
+  Authenticator* auth() { return fOurAuthenticator; }
+
+  void scheduleLivenessCommand();
+  static void sendLivenessCommand(void* clientData);
+  void doReset();
+  static void doReset(void* clientData);
+
+  void scheduleDESCRIBECommand();
+  static void sendDESCRIBE(void* clientData);
+  void sendDESCRIBE();
+
+  static void subsessionTimeout(void* clientData);
+  void handleSubsessionTimeout();
+
+private:
+  friend class ProxyServerMediaSession;
+  friend class ProxyServerMediaSubsession;
+  ProxyServerMediaSession& fOurServerMediaSession;
+  char* fOurURL;
+  Authenticator* fOurAuthenticator;
+  Boolean fStreamRTPOverTCP;
+  class ProxyServerMediaSubsession *fSetupQueueHead, *fSetupQueueTail;
+  unsigned fNumSetupsDone;
+  unsigned fNextDESCRIBEDelay; // in seconds
+  Boolean fServerSupportsGetParameter, fLastCommandWasPLAY, fDoneDESCRIBE;
+  TaskToken fLivenessCommandTask, fDESCRIBECommandTask, fSubsessionTimerTask, fResetTask;
+};
+
+
+typedef ProxyRTSPClient*
+createNewProxyRTSPClientFunc(ProxyServerMediaSession& ourServerMediaSession,
+			     char const* rtspURL,
+			     char const* username, char const* password,
+			     portNumBits tunnelOverHTTPPortNum, int verbosityLevel,
+			     int socketNumToServer);
+ProxyRTSPClient*
+defaultCreateNewProxyRTSPClientFunc(ProxyServerMediaSession& ourServerMediaSession,
+				    char const* rtspURL,
+				    char const* username, char const* password,
+				    portNumBits tunnelOverHTTPPortNum, int verbosityLevel,
+				    int socketNumToServer);
+
+class ProxyServerMediaSession: public ServerMediaSession {
+public:
+  static ProxyServerMediaSession* createNew(UsageEnvironment& env,
+					    GenericMediaServer* ourMediaServer, // Note: We can be used by just one server
+					    char const* inputStreamURL, // the "rtsp://" URL of the stream we'll be proxying
+					    char const* streamName = NULL,
+					    char const* username = NULL, char const* password = NULL,
+					    portNumBits tunnelOverHTTPPortNum = 0,
+					        // for streaming the *proxied* (i.e., back-end) stream
+					    int verbosityLevel = 0,
+					    int socketNumToServer = -1,
+					    MediaTranscodingTable* transcodingTable = NULL);
+      // Hack: "tunnelOverHTTPPortNum" == 0xFFFF (i.e., all-ones) means: Stream RTP/RTCP-over-TCP, but *not* using HTTP
+      // "verbosityLevel" == 1 means display basic proxy setup info; "verbosityLevel" == 2 means display RTSP client protocol also.
+      // If "socketNumToServer" is >= 0, then it is the socket number of an already-existing TCP connection to the server.
+      //      (In this case, "inputStreamURL" must point to the socket's endpoint, so that it can be accessed via the socket.)
+
+  virtual ~ProxyServerMediaSession();
+
+  char const* url() const;
+
+  char describeCompletedFlag;
+    // initialized to 0; set to 1 when the back-end "DESCRIBE" completes.
+    // (This can be used as a 'watch variable' in "doEventLoop()".)
+  Boolean describeCompletedSuccessfully() const { return fClientMediaSession != NULL; }
+    // This can be used - along with "describeCompletedFlag" - to check whether the back-end "DESCRIBE" completed *successfully*.
+
+protected:
+  ProxyServerMediaSession(UsageEnvironment& env, GenericMediaServer* ourMediaServer,
+			  char const* inputStreamURL, char const* streamName,
+			  char const* username, char const* password,
+			  portNumBits tunnelOverHTTPPortNum, int verbosityLevel,
+			  int socketNumToServer,
+			  MediaTranscodingTable* transcodingTable,
+			  createNewProxyRTSPClientFunc* ourCreateNewProxyRTSPClientFunc
+			  = defaultCreateNewProxyRTSPClientFunc,
+			  portNumBits initialPortNum = 6970,
+			  Boolean multiplexRTCPWithRTP = False);
+
+  // If you subclass "ProxyRTSPClient", then you will also need to define your own function
+  // - with signature "createNewProxyRTSPClientFunc" (see above) - that creates a new object
+  // of this subclass.  You should also subclass "ProxyServerMediaSession" and, in your
+  // subclass's constructor, initialize the parent class (i.e., "ProxyServerMediaSession")
+  // constructor by passing your new function as the "ourCreateNewProxyRTSPClientFunc"
+  // parameter.
+
+  // Subclasses may redefine the following functions, if they want "ProxyServerSubsession"s
+  // to create subclassed "Groupsock" and/or "RTCPInstance" objects:
+  virtual Groupsock* createGroupsock(struct sockaddr_storage const& addr, Port port);
+  virtual RTCPInstance* createRTCP(Groupsock* RTCPgs, unsigned totSessionBW, /* in kbps */
+				   unsigned char const* cname, RTPSink* sink);
+
+  virtual Boolean allowProxyingForSubsession(MediaSubsession const& mss);
+  // By default, this function always returns True.  However, a subclass may redefine this
+  // if it wishes to restrict which subsessions of a stream get proxied - e.g., if it wishes
+  // to proxy only video tracks, but not audio (or other) tracks.
+
+protected:
+  GenericMediaServer* fOurMediaServer;
+  ProxyRTSPClient* fProxyRTSPClient;
+  MediaSession* fClientMediaSession;
+
+private:
+  friend class ProxyRTSPClient;
+  friend class ProxyServerMediaSubsession;
+  void continueAfterDESCRIBE(char const* sdpDescription);
+  void resetDESCRIBEState(); // undoes what was done by "contineAfterDESCRIBE()"
+
+private:
+  int fVerbosityLevel;
+  class PresentationTimeSessionNormalizer* fPresentationTimeSessionNormalizer;
+  createNewProxyRTSPClientFunc* fCreateNewProxyRTSPClientFunc;
+  MediaTranscodingTable* fTranscodingTable;
+  portNumBits fInitialPortNum;
+  Boolean fMultiplexRTCPWithRTP;
+};
+
+
+////////// PresentationTimeSessionNormalizer and PresentationTimeSubsessionNormalizer definitions //////////
+
+// The following two classes are used by proxies to convert incoming streams' presentation times into wall-clock-aligned
+// presentation times that are suitable for our "RTPSink"s (for the corresponding outgoing streams).
+// (For multi-subsession (i.e., audio+video) sessions, the outgoing streams' presentation times retain the same relative
+//  separation as those of the incoming streams.)
+
+class PresentationTimeSubsessionNormalizer: public FramedFilter {
+public:
+  void setRTPSink(RTPSink* rtpSink) { fRTPSink = rtpSink; }
+
+private:
+  friend class PresentationTimeSessionNormalizer;
+  PresentationTimeSubsessionNormalizer(PresentationTimeSessionNormalizer& parent, FramedSource* inputSource, RTPSource* rtpSource,
+				       char const* codecName, PresentationTimeSubsessionNormalizer* next);
+      // called only from within "PresentationTimeSessionNormalizer"
+  virtual ~PresentationTimeSubsessionNormalizer();
+
+  static void afterGettingFrame(void* clientData, unsigned frameSize,
+                                unsigned numTruncatedBytes,
+                                struct timeval presentationTime,
+                                unsigned durationInMicroseconds);
+  void afterGettingFrame(unsigned frameSize,
+			 unsigned numTruncatedBytes,
+			 struct timeval presentationTime,
+			 unsigned durationInMicroseconds);
+
+private: // redefined virtual functions:
+  virtual void doGetNextFrame();
+
+private:
+  PresentationTimeSessionNormalizer& fParent;
+  RTPSource* fRTPSource;
+  RTPSink* fRTPSink;
+  char const* fCodecName;
+  PresentationTimeSubsessionNormalizer* fNext;
+};
+
+class PresentationTimeSessionNormalizer: public Medium {
+public:
+  PresentationTimeSessionNormalizer(UsageEnvironment& env);
+  virtual ~PresentationTimeSessionNormalizer();
+
+  PresentationTimeSubsessionNormalizer*
+  createNewPresentationTimeSubsessionNormalizer(FramedSource* inputSource, RTPSource* rtpSource, char const* codecName);
+
+private: // called only from within "~PresentationTimeSubsessionNormalizer":
+  friend class PresentationTimeSubsessionNormalizer;
+  void normalizePresentationTime(PresentationTimeSubsessionNormalizer* ssNormalizer,
+				 struct timeval& toPT, struct timeval const& fromPT);
+  void removePresentationTimeSubsessionNormalizer(PresentationTimeSubsessionNormalizer* ssNormalizer);
+
+private:
+  PresentationTimeSubsessionNormalizer* fSubsessionNormalizers;
+  PresentationTimeSubsessionNormalizer* fMasterSSNormalizer; // used for subsessions that have been RTCP-synced
+
+  struct timeval fPTAdjustment; // Added to (RTCP-synced) subsession presentation times to 'normalize' them with wall-clock time.
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/QCELPAudioRTPSource.hh b/3rdparty/live555/src/liveMedia/include/QCELPAudioRTPSource.hh
new file mode 100644
index 00000000..2beef07d
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/QCELPAudioRTPSource.hh
@@ -0,0 +1,39 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// Qualcomm "PureVoice" (aka. "QCELP") Audio RTP Sources
+// C++ header
+
+#ifndef _QCELP_AUDIO_RTP_SOURCE_HH
+#define _QCELP_AUDIO_RTP_SOURCE_HH
+
+#ifndef _RTP_SOURCE_HH
+#include "RTPSource.hh"
+#endif
+
+class QCELPAudioRTPSource {
+public:
+  static FramedSource* createNew(UsageEnvironment& env,
+				 Groupsock* RTPgs,
+				 RTPSource*& resultRTPSource,
+				 unsigned char rtpPayloadFormat = 12,
+				 unsigned rtpTimestampFrequency = 8000);
+      // This returns a source to read from, but "resultRTPSource" will
+      // point to RTP-related state.
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/QuickTimeFileSink.hh b/3rdparty/live555/src/liveMedia/include/QuickTimeFileSink.hh
new file mode 100644
index 00000000..b351f396
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/QuickTimeFileSink.hh
@@ -0,0 +1,192 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A sink that generates a QuickTime file from a composite media session
+// C++ header
+
+#ifndef _QUICKTIME_FILE_SINK_HH
+#define _QUICKTIME_FILE_SINK_HH
+
+#ifndef _MEDIA_SESSION_HH
+#include "MediaSession.hh"
+#endif
+
+class QuickTimeFileSink: public Medium {
+public:
+  static QuickTimeFileSink* createNew(UsageEnvironment& env,
+				      MediaSession& inputSession,
+				      char const* outputFileName,
+				      unsigned bufferSize = 20000,
+				      unsigned short movieWidth = 240,
+				      unsigned short movieHeight = 180,
+				      unsigned movieFPS = 15,
+				      Boolean packetLossCompensate = False,
+				      Boolean syncStreams = False,
+				      Boolean generateHintTracks = False,
+				      Boolean generateMP4Format = False);
+
+  typedef void (afterPlayingFunc)(void* clientData);
+  Boolean startPlaying(afterPlayingFunc* afterFunc,
+                       void* afterClientData);
+
+  unsigned numActiveSubsessions() const { return fNumSubsessions; }
+
+protected:
+  QuickTimeFileSink(UsageEnvironment& env, MediaSession& inputSession,
+		    char const* outputFileName, unsigned bufferSize,
+		    unsigned short movieWidth, unsigned short movieHeight,
+		    unsigned movieFPS, Boolean packetLossCompensate,
+		    Boolean syncStreams, Boolean generateHintTracks,
+		    Boolean generateMP4Format);
+      // called only by createNew()
+  virtual ~QuickTimeFileSink();
+
+  virtual void noteRecordedFrame(MediaSubsession& inputSubsession,
+				 unsigned packetDataSize, struct timeval const& presentationTime);
+
+private:
+  Boolean continuePlaying();
+  static void afterGettingFrame(void* clientData, unsigned frameSize,
+				unsigned numTruncatedBytes,
+				struct timeval presentationTime,
+				unsigned durationInMicroseconds);
+  static void onSourceClosure(void* clientData);
+  void onSourceClosure1();
+  static void onRTCPBye(void* clientData);
+  void completeOutputFile();
+
+private:
+  friend class SubsessionIOState;
+  MediaSession& fInputSession;
+  FILE* fOutFid;
+  unsigned fBufferSize;
+  Boolean fPacketLossCompensate;
+  Boolean fSyncStreams, fGenerateMP4Format;
+  struct timeval fNewestSyncTime, fFirstDataTime;
+  Boolean fAreCurrentlyBeingPlayed;
+  afterPlayingFunc* fAfterFunc;
+  void* fAfterClientData;
+  unsigned fAppleCreationTime;
+  unsigned fLargestRTPtimestampFrequency;
+  unsigned fNumSubsessions, fNumSyncedSubsessions;
+  struct timeval fStartTime;
+  Boolean fHaveCompletedOutputFile;
+
+private:
+  ///// Definitions specific to the QuickTime file format:
+
+  unsigned addWord64(u_int64_t word);
+  unsigned addWord(unsigned word);
+  unsigned addHalfWord(unsigned short halfWord);
+  unsigned addByte(unsigned char byte) {
+    putc(byte, fOutFid);
+    return 1;
+  }
+  unsigned addZeroWords(unsigned numWords);
+  unsigned add4ByteString(char const* str);
+  unsigned addArbitraryString(char const* str,
+			      Boolean oneByteLength = True);
+  unsigned addAtomHeader(char const* atomName);
+  unsigned addAtomHeader64(char const* atomName);
+      // strlen(atomName) must be 4
+  void setWord(int64_t filePosn, unsigned size);
+  void setWord64(int64_t filePosn, u_int64_t size);
+
+  unsigned movieTimeScale() const {return fLargestRTPtimestampFrequency;}
+
+  // Define member functions for outputting various types of atom:
+#define _atom(name) unsigned addAtom_##name()
+  _atom(ftyp); // for MP4 format files
+  _atom(moov);
+      _atom(mvhd);
+  _atom(iods); // for MP4 format files
+      _atom(trak);
+          _atom(tkhd);
+          _atom(edts);
+              _atom(elst);
+          _atom(tref);
+              _atom(hint);
+          _atom(mdia);
+              _atom(mdhd);
+              _atom(hdlr);
+              _atom(minf);
+                  _atom(smhd);
+                  _atom(vmhd);
+                  _atom(gmhd);
+                      _atom(gmin);
+                  unsigned addAtom_hdlr2();
+                  _atom(dinf);
+                      _atom(dref);
+                          _atom(alis);
+                  _atom(stbl);
+                      _atom(stsd);
+                          unsigned addAtom_genericMedia();
+                          unsigned addAtom_soundMediaGeneral();
+                          _atom(ulaw);
+                          _atom(alaw);
+                          _atom(Qclp);
+                              _atom(wave);
+                                  _atom(frma);
+                                  _atom(Fclp);
+                                  _atom(Hclp);
+                          _atom(mp4a);
+//                            _atom(wave);
+//                                _atom(frma);
+                                  _atom(esds);
+                                  _atom(srcq);
+                          _atom(h263);
+                          _atom(avc1);
+                              _atom(avcC);
+                          _atom(mp4v);
+                          _atom(rtp);
+                              _atom(tims);
+                      _atom(stts);
+                      _atom(stss);
+                      _atom(stsc);
+                      _atom(stsz);
+                      _atom(co64);
+          _atom(udta);
+              _atom(name);
+              _atom(hnti);
+                  _atom(sdp);
+              _atom(hinf);
+                  _atom(totl);
+                  _atom(npck);
+                  _atom(tpay);
+                  _atom(trpy);
+                  _atom(nump);
+                  _atom(tpyl);
+                  _atom(dmed);
+                  _atom(dimm);
+                  _atom(drep);
+                  _atom(tmin);
+                  _atom(tmax);
+                  _atom(pmax);
+                  _atom(dmax);
+                  _atom(payt);
+  unsigned addAtom_dummy();
+
+private:
+  unsigned short fMovieWidth, fMovieHeight;
+  unsigned fMovieFPS;
+  int64_t fMDATposition;
+  int64_t fMVHD_durationPosn;
+  unsigned fMaxTrackDurationM; // in movie time units
+  class SubsessionIOState* fCurrentIOState;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/QuickTimeGenericRTPSource.hh b/3rdparty/live555/src/liveMedia/include/QuickTimeGenericRTPSource.hh
new file mode 100644
index 00000000..01831049
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/QuickTimeGenericRTPSource.hh
@@ -0,0 +1,68 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// RTP Sources containing generic QuickTime stream data, as defined in
+//     <http://developer.apple.com/quicktime/icefloe/dispatch026.html>
+// C++ header
+
+#ifndef _QUICKTIME_GENERIC_RTP_SOURCE_HH
+#define _QUICKTIME_GENERIC_RTP_SOURCE_HH
+
+#ifndef _MULTI_FRAMED_RTP_SOURCE_HH
+#include "MultiFramedRTPSource.hh"
+#endif
+
+class QuickTimeGenericRTPSource: public MultiFramedRTPSource {
+public:
+  static QuickTimeGenericRTPSource*
+  createNew(UsageEnvironment& env, Groupsock* RTPgs,
+	    unsigned char rtpPayloadFormat, unsigned rtpTimestampFrequency,
+	    char const* mimeTypeString);
+
+  // QuickTime-specific information, set from the QuickTime header
+  // in each packet.  This, along with the data following the header,
+  // is used by receivers.
+  struct QTState {
+    char PCK;
+    unsigned timescale;
+    char* sdAtom;
+    unsigned sdAtomSize;
+    unsigned short width, height;
+    // later add other state as needed #####
+  } qtState;
+
+protected:
+  virtual ~QuickTimeGenericRTPSource();
+
+private:
+  QuickTimeGenericRTPSource(UsageEnvironment& env, Groupsock* RTPgs,
+			    unsigned char rtpPayloadFormat,
+			    unsigned rtpTimestampFrequency,
+			    char const* mimeTypeString);
+      // called only by createNew()
+
+private:
+  // redefined virtual functions:
+  virtual Boolean processSpecialHeader(BufferedPacket* packet,
+                                       unsigned& resultSpecialHeaderSize);
+  virtual char const* MIMEtype() const;
+
+private:
+  char const* fMIMEtypeString;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/RTCP.hh b/3rdparty/live555/src/liveMedia/include/RTCP.hh
new file mode 100644
index 00000000..16a1da27
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/RTCP.hh
@@ -0,0 +1,250 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// RTCP
+// C++ header
+
+#ifndef _RTCP_HH
+#define _RTCP_HH
+
+#ifndef _RTP_SINK_HH
+#include "RTPSink.hh"
+#endif
+#ifndef _RTP_SOURCE_HH
+#include "RTPSource.hh"
+#endif
+#ifndef _SRTP_CRYPTOGRAPHIC_CONTEXT_HH
+#include "SRTPCryptographicContext.hh"
+#endif
+
+class SDESItem {
+public:
+  SDESItem(unsigned char tag, unsigned char const* value);
+
+  unsigned char const* data() const {return fData;}
+  unsigned totalSize() const;
+
+private:
+  unsigned char fData[2 + 0xFF]; // first 2 bytes are tag and length
+};
+
+typedef void RTCPAppHandlerFunc(void* clientData,
+				u_int8_t subtype, u_int32_t nameBytes/*big-endian order*/,
+				u_int8_t* appDependentData, unsigned appDependentDataSize);
+
+class RTCPMemberDatabase; // forward
+
+typedef void ByeWithReasonHandlerFunc(void* clientData, char const* reason);
+
+class RTCPInstance: public Medium {
+public:
+  static RTCPInstance* createNew(UsageEnvironment& env, Groupsock* RTCPgs,
+				 unsigned totSessionBW, /* in kbps */
+				 unsigned char const* cname,
+				 RTPSink* sink,
+				 RTPSource* source,
+				 Boolean isSSMTransmitter = False,
+				 SRTPCryptographicContext* crypto = NULL);
+
+  static Boolean lookupByName(UsageEnvironment& env, char const* instanceName,
+                              RTCPInstance*& resultInstance);
+
+  unsigned numMembers() const;
+  unsigned totSessionBW() const { return fTotSessionBW; }
+
+  void setupForSRTCP();
+  
+  void setByeHandler(TaskFunc* handlerTask, void* clientData,
+		     Boolean handleActiveParticipantsOnly = True);
+      // Assigns a handler routine to be called if a "BYE" arrives.
+      // The handler is called once only; for subsequent "BYE"s,
+      // "setByeHandler()" would need to be called again.
+      // If "handleActiveParticipantsOnly" is True, then the handler is called
+      // only if the SSRC is for a known sender (if we have a "RTPSource"),
+      // or if the SSRC is for a known receiver (if we have a "RTPSink").
+      // This prevents (for example) the handler for a multicast receiver being
+      // called if some other multicast receiver happens to exit.
+      // If "handleActiveParticipantsOnly" is False, then the handler is called
+      // for any incoming RTCP "BYE".
+      // (To remove an existing "BYE" handler, call "setByeHandler()" again, with a "handlerTask" of NULL.)
+  void setByeWithReasonHandler(ByeWithReasonHandlerFunc* handlerTask, void* clientData,
+			       Boolean handleActiveParticipantsOnly = True);
+      // Like "setByeHandler()", except that a string 'reason for the bye' (received as part of
+      // the RTCP "BYE" packet) is passed to the handler function (along with "clientData").
+      // (The 'reason' parameter to the handler function will be a dynamically-allocated string,
+      // or NULL, and should be delete[]d by the handler function.)
+  void setSRHandler(TaskFunc* handlerTask, void* clientData);
+  void setRRHandler(TaskFunc* handlerTask, void* clientData);
+      // Assigns a handler routine to be called if a "SR" or "RR" packet
+      // (respectively) arrives.  Unlike "setByeHandler()", the handler will
+      // be called once for each incoming "SR" or "RR".  (To turn off handling,
+      // call the function again with "handlerTask" (and "clientData") as NULL.)
+  void setSpecificRRHandler(struct sockaddr_storage const& fromAddress, Port fromPort,
+			    TaskFunc* handlerTask, void* clientData);
+      // Like "setRRHandler()", but applies only to "RR" packets that come from
+      // a specific source address and port.  (Note that if both a specific
+      // and a general "RR" handler function is set, then both will be called.)
+  void unsetSpecificRRHandler(struct sockaddr_storage const& fromAddress, Port fromPort); // equivalent to setSpecificRRHandler(..., NULL, NULL);
+  void setAppHandler(RTCPAppHandlerFunc* handlerTask, void* clientData);
+      // Assigns a handler routine to be called whenever an "APP" packet arrives.  (To turn off
+      // handling, call the function again with "handlerTask" (and "clientData") as NULL.)
+  void sendAppPacket(u_int8_t subtype, char const* name,
+		     u_int8_t* appDependentData, unsigned appDependentDataSize);
+      // Sends a custom RTCP "APP" packet to the peer(s).  The parameters correspond to their
+      // respective fields as described in the RTP/RTCP definition (RFC 3550).
+      // Note that only the low-order 5 bits of "subtype" are used, and only the first 4 bytes
+      // of "name" are used.  (If "name" has fewer than 4 bytes, or is NULL,
+      // then the remaining bytes are '\0'.)
+
+  Groupsock* RTCPgs() const { return fRTCPInterface.gs(); }
+
+  void setStreamSocket(int sockNum, unsigned char streamChannelId, TLSState* tlsState);
+  void addStreamSocket(int sockNum, unsigned char streamChannelId, TLSState* tlsState);
+  void removeStreamSocket(int sockNum, unsigned char streamChannelId) {
+    fRTCPInterface.removeStreamSocket(sockNum, streamChannelId);
+  }
+    // hacks to allow sending RTP over TCP (RFC 2236, section 10.12)
+
+  void setAuxilliaryReadHandler(AuxHandlerFunc* handlerFunc,
+                                void* handlerClientData) {
+    fRTCPInterface.setAuxilliaryReadHandler(handlerFunc,
+					    handlerClientData);
+  }
+
+  void injectReport(u_int8_t const* packet, unsigned packetSize, struct sockaddr_storage const& fromAddress);
+    // Allows an outside party to inject an RTCP report (from other than the network interface)
+
+protected:
+  RTCPInstance(UsageEnvironment& env, Groupsock* RTPgs, unsigned totSessionBW,
+	       unsigned char const* cname,
+	       RTPSink* sink, RTPSource* source,
+	       Boolean isSSMTransmitter,
+	       SRTPCryptographicContext* crypto);
+      // called only by createNew()
+  virtual ~RTCPInstance();
+
+  virtual void noteArrivingRR(struct sockaddr_storage const& fromAddressAndPort,
+			      int tcpSocketNum, unsigned char tcpStreamChannelId);
+
+  void incomingReportHandler1();
+
+private:
+  // redefined virtual functions:
+  virtual Boolean isRTCPInstance() const;
+
+private:
+  Boolean addReport(Boolean alwaysAdd = False);
+    void addSR();
+    void addRR();
+      void enqueueCommonReportPrefix(unsigned char packetType, u_int32_t SSRC,
+				     unsigned numExtraWords = 0);
+      void enqueueCommonReportSuffix();
+        void enqueueReportBlock(RTPReceptionStats* receptionStats);
+  void addSDES();
+  void addBYE(char const* reason);
+
+  void sendBuiltPacket();
+
+  static void onExpire(RTCPInstance* instance);
+  void onExpire1();
+
+  static void incomingReportHandler(RTCPInstance* instance, int /*mask*/);
+  void processIncomingReport(unsigned packetSize, struct sockaddr_storage const& fromAddressAndPort,
+			     int tcpSocketNum, unsigned char tcpStreamChannelId);
+  void onReceive(int typeOfPacket, int totPacketSize, u_int32_t ssrc);
+
+private:
+  u_int8_t* fInBuf;
+  unsigned fNumBytesAlreadyRead;
+  OutPacketBuffer* fOutBuf;
+  RTPInterface fRTCPInterface;
+  unsigned fTotSessionBW;
+  RTPSink* fSink;
+  RTPSource* fSource;
+  Boolean fIsSSMTransmitter;
+  SRTPCryptographicContext* fCrypto;
+
+  SDESItem fCNAME;
+  RTCPMemberDatabase* fKnownMembers;
+  unsigned fOutgoingReportCount; // used for SSRC member aging
+
+  double fAveRTCPSize;
+  int fIsInitial;
+  double fPrevReportTime;
+  double fNextReportTime;
+  int fPrevNumMembers;
+
+  int fLastSentSize;
+  int fLastReceivedSize;
+  u_int32_t fLastReceivedSSRC;
+  int fTypeOfEvent;
+  int fTypeOfPacket;
+  Boolean fHaveJustSentPacket;
+  unsigned fLastPacketSentSize;
+
+  TaskFunc* fByeHandlerTask;
+  ByeWithReasonHandlerFunc* fByeWithReasonHandlerTask;
+  void* fByeHandlerClientData;
+  Boolean fByeHandleActiveParticipantsOnly;
+  TaskFunc* fSRHandlerTask;
+  void* fSRHandlerClientData;
+  TaskFunc* fRRHandlerTask;
+  void* fRRHandlerClientData;
+  AddressPortLookupTable* fSpecificRRHandlerTable;
+  RTCPAppHandlerFunc* fAppHandlerTask;
+  void* fAppHandlerClientData;
+
+public: // because this stuff is used by an external "C" function
+  void schedule(double nextTime);
+  void reschedule(double nextTime);
+  void sendReport();
+  void sendBYE(char const* reason = NULL);
+  int typeOfEvent() {return fTypeOfEvent;}
+  int sentPacketSize() {return fLastSentSize;}
+  int packetType() {return fTypeOfPacket;}
+  int receivedPacketSize() {return fLastReceivedSize;}
+  int checkNewSSRC();
+  void removeLastReceivedSSRC();
+  void removeSSRC(u_int32_t ssrc, Boolean alsoRemoveStats);
+};
+
+// RTCP packet types:
+const unsigned char RTCP_PT_SR = 200;
+const unsigned char RTCP_PT_RR = 201;
+const unsigned char RTCP_PT_SDES = 202;
+const unsigned char RTCP_PT_BYE = 203;
+const unsigned char RTCP_PT_APP = 204;
+const unsigned char RTCP_PT_RTPFB = 205; // Generic RTP Feedback [RFC4585]
+const unsigned char RTCP_PT_PSFB = 206; // Payload-specific [RFC4585]
+const unsigned char RTCP_PT_XR = 207; // extended report [RFC3611]
+const unsigned char RTCP_PT_AVB = 208; // AVB RTCP packet ["Standard for Layer 3 Transport Protocol for Time Sensitive Applications in Local Area Networks." Work in progress.]
+const unsigned char RTCP_PT_RSI = 209; // Receiver Summary Information [RFC5760]
+const unsigned char RTCP_PT_TOKEN = 210; // Port Mapping [RFC6284]
+const unsigned char RTCP_PT_IDMS = 211; // IDMS Settings [RFC7272]
+
+// SDES tags:
+const unsigned char RTCP_SDES_END = 0;
+const unsigned char RTCP_SDES_CNAME = 1;
+const unsigned char RTCP_SDES_NAME = 2;
+const unsigned char RTCP_SDES_EMAIL = 3;
+const unsigned char RTCP_SDES_PHONE = 4;
+const unsigned char RTCP_SDES_LOC = 5;
+const unsigned char RTCP_SDES_TOOL = 6;
+const unsigned char RTCP_SDES_NOTE = 7;
+const unsigned char RTCP_SDES_PRIV = 8;
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/RTPInterface.hh b/3rdparty/live555/src/liveMedia/include/RTPInterface.hh
new file mode 100644
index 00000000..c1afc87c
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/RTPInterface.hh
@@ -0,0 +1,115 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// An abstraction of a network interface used for RTP (or RTCP).
+// (This allows the RTP-over-TCP hack (RFC 2326, section 10.12) to
+// be implemented transparently.)
+// C++ header
+
+#ifndef _RTP_INTERFACE_HH
+#define _RTP_INTERFACE_HH
+
+#ifndef _MEDIA_HH
+#include "Media.hh"
+#endif
+#ifndef _TLS_STATE_HH
+#include "TLSState.hh"
+#endif
+#ifndef _GROUPSOCK_HH
+#include <Groupsock.hh>
+#endif
+
+// Typedef for an optional auxilliary handler function, to be called
+// when each new packet is read:
+typedef void AuxHandlerFunc(void* clientData, unsigned char* packet,
+			    unsigned& packetSize);
+
+typedef void ServerRequestAlternativeByteHandler(void* instance, u_int8_t requestByte);
+// A hack that allows a handler for RTP/RTCP packets received over TCP to process RTSP commands that may also appear within
+// the same TCP connection.  A RTSP server implementation would supply a function like this - as a parameter to
+// "ServerMediaSubsession::startStream()".
+
+class RTPInterface {
+public:
+  RTPInterface(Medium* owner, Groupsock* gs);
+  virtual ~RTPInterface();
+
+  Groupsock* gs() const { return fGS; }
+
+  void setStreamSocket(int sockNum, unsigned char streamChannelId, TLSState* tlsState);
+  void addStreamSocket(int sockNum, unsigned char streamChannelId, TLSState* tlsState);
+  void removeStreamSocket(int sockNum, unsigned char streamChannelId);
+  static void setServerRequestAlternativeByteHandler(UsageEnvironment& env, int socketNum,
+						     ServerRequestAlternativeByteHandler* handler, void* clientData);
+  static void clearServerRequestAlternativeByteHandler(UsageEnvironment& env, int socketNum);
+
+  Boolean sendPacket(unsigned char* packet, unsigned packetSize);
+  void startNetworkReading(TaskScheduler::BackgroundHandlerProc*
+                           handlerProc);
+  Boolean handleRead(unsigned char* buffer, unsigned bufferMaxSize,
+		     // out parameters:
+		     unsigned& bytesRead, struct sockaddr_storage& fromAddress,
+		     int& tcpSocketNum, unsigned char& tcpStreamChannelId,
+		     Boolean& packetReadWasIncomplete);
+  // Note: If "tcpSocketNum" < 0, then the packet was received over UDP, and "tcpStreamChannelId"
+  //   is undefined (and irrelevant).
+
+
+  // Otherwise (if "tcpSocketNum" >= 0), the packet was received (interleaved) over TCP, and
+  //   "tcpStreamChannelId" will return the channel id.
+
+  void stopNetworkReading();
+
+  UsageEnvironment& envir() const { return fOwner->envir(); }
+
+  void setAuxilliaryReadHandler(AuxHandlerFunc* handlerFunc,
+				void* handlerClientData) {
+    fAuxReadHandlerFunc = handlerFunc;
+    fAuxReadHandlerClientData = handlerClientData;
+  }
+
+  void forgetOurGroupsock() { fGS = NULL; }
+    // This may be called - *only immediately prior* to deleting this - to prevent our destructor
+    // from turning off background reading on the 'groupsock'.  (This is in case the 'groupsock'
+    // is also being read from elsewhere.)
+
+private:
+  // Helper functions for sending a RTP or RTCP packet over a TCP connection:
+  Boolean sendRTPorRTCPPacketOverTCP(unsigned char* packet, unsigned packetSize,
+				     int socketNum, unsigned char streamChannelId,
+				     TLSState* tlsState);
+  Boolean sendDataOverTCP(int socketNum, TLSState* tlsState,
+			  u_int8_t const* data, unsigned dataSize, Boolean forceSendToSucceed);
+
+private:
+  friend class SocketDescriptor;
+  Medium* fOwner;
+  Groupsock* fGS;
+  class tcpStreamRecord* fTCPStreams; // optional, for RTP-over-TCP streaming/receiving
+
+  unsigned short fNextTCPReadSize;
+    // how much data (if any) is available to be read from the TCP stream
+  int fNextTCPReadStreamSocketNum;
+  unsigned char fNextTCPReadStreamChannelId;
+  TLSState* fNextTCPReadTLSState;
+  TaskScheduler::BackgroundHandlerProc* fReadHandlerProc; // if any
+
+  AuxHandlerFunc* fAuxReadHandlerFunc;
+  void* fAuxReadHandlerClientData;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/RTPSink.hh b/3rdparty/live555/src/liveMedia/include/RTPSink.hh
new file mode 100644
index 00000000..553d8160
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/RTPSink.hh
@@ -0,0 +1,250 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// RTP Sinks
+// C++ header
+
+#ifndef _RTP_SINK_HH
+#define _RTP_SINK_HH
+
+#ifndef _MEDIA_SINK_HH
+#include "MediaSink.hh"
+#endif
+#ifndef _RTP_INTERFACE_HH
+#include "RTPInterface.hh"
+#endif
+#ifndef _SRTP_CRYPTOGRAPHIC_CONTEXT_HH
+#include "SRTPCryptographicContext.hh"
+#endif
+
+class RTPTransmissionStatsDB; // forward
+
+class RTPSink: public MediaSink {
+public:
+  static Boolean lookupByName(UsageEnvironment& env, char const* sinkName,
+			      RTPSink*& resultSink);
+
+  // used by RTSP servers:
+  Groupsock const& groupsockBeingUsed() const { return *(fRTPInterface.gs()); }
+  Groupsock& groupsockBeingUsed() { return *(fRTPInterface.gs()); }
+
+  unsigned char rtpPayloadType() const { return fRTPPayloadType; }
+  unsigned rtpTimestampFrequency() const { return fTimestampFrequency; }
+  void setRTPTimestampFrequency(unsigned freq) {
+    fTimestampFrequency = freq;
+  }
+  char const* rtpPayloadFormatName() const {return fRTPPayloadFormatName;}
+
+  unsigned numChannels() const { return fNumChannels; }
+
+  void setupForSRTP(Boolean useEncryption);
+      // sets up keying/encryption state for streaming via SRTP, using default values.
+  u_int8_t* setupForSRTP(Boolean useEncryption, unsigned& resultMIKEYStateMessageSize);
+      // as above, but returns the binary MIKEY state
+  void setupForSRTP(u_int8_t const* MIKEYStateMessage, unsigned MIKEYStateMessageSize);
+      // as above, but takes a MIKEY state message as parameter
+
+  virtual char const* sdpMediaType() const; // for use in SDP m= lines
+  virtual char* rtpmapLine() const; // returns a string to be delete[]d
+  virtual char* keyMgmtLine(); // returns a string to be delete[]d
+  virtual char const* auxSDPLine();
+      // optional SDP line (e.g. a=fmtp:...)
+
+  u_int16_t currentSeqNo() const { return fSeqNo; }
+  u_int32_t presetNextTimestamp();
+      // ensures that the next timestamp to be used will correspond to
+      // the current 'wall clock' time.
+
+  RTPTransmissionStatsDB& transmissionStatsDB() const {
+    return *fTransmissionStatsDB;
+  }
+
+  Boolean nextTimestampHasBeenPreset() const { return fNextTimestampHasBeenPreset; }
+  Boolean& enableRTCPReports() { return fEnableRTCPReports; }
+
+  void getTotalBitrate(unsigned& outNumBytes, double& outElapsedTime);
+      // returns the number of bytes sent since the last time that we
+      // were called, and resets the counter.
+
+  struct timeval const& creationTime() const { return fCreationTime; }
+  struct timeval const& initialPresentationTime() const { return fInitialPresentationTime; }
+  struct timeval const& mostRecentPresentationTime() const { return fMostRecentPresentationTime; }
+  void resetPresentationTimes();
+
+  // Hacks to allow sending RTP over TCP (RFC 2236, section 10.12):
+  void setStreamSocket(int sockNum, unsigned char streamChannelId, TLSState* tlsState) {
+    fRTPInterface.setStreamSocket(sockNum, streamChannelId, tlsState);
+  }
+  void addStreamSocket(int sockNum, unsigned char streamChannelId, TLSState* tlsState) {
+    fRTPInterface.addStreamSocket(sockNum, streamChannelId, tlsState);
+  }
+  void removeStreamSocket(int sockNum, unsigned char streamChannelId) {
+    fRTPInterface.removeStreamSocket(sockNum, streamChannelId);
+  }
+  unsigned& estimatedBitrate() { return fEstimatedBitrate; } // kbps; usually 0 (i.e., unset)
+
+  u_int32_t SSRC() const {return fSSRC;}
+     // later need a means of changing the SSRC if there's a collision #####
+
+  SRTPCryptographicContext* getCrypto() const { return fCrypto; }
+
+protected:
+  RTPSink(UsageEnvironment& env,
+	  Groupsock* rtpGS, unsigned char rtpPayloadType,
+	  u_int32_t rtpTimestampFrequency,
+	  char const* rtpPayloadFormatName,
+	  unsigned numChannels);
+	// abstract base class
+
+  virtual ~RTPSink();
+
+  // used by RTCP:
+  friend class RTCPInstance;
+  friend class RTPTransmissionStats;
+  u_int32_t convertToRTPTimestamp(struct timeval tv);
+  unsigned packetCount() const {return fPacketCount;}
+  unsigned octetCount() const {return fOctetCount;}
+
+protected:
+  RTPInterface fRTPInterface;
+  unsigned char fRTPPayloadType;
+  unsigned fPacketCount, fOctetCount, fTotalOctetCount /*incl RTP hdr*/;
+  struct timeval fTotalOctetCountStartTime, fInitialPresentationTime, fMostRecentPresentationTime;
+  u_int32_t fCurrentTimestamp;
+  u_int16_t fSeqNo;
+
+  // Optional key management and crypto state; used if we are streaming SRTP
+  MIKEYState* fMIKEYState;
+  SRTPCryptographicContext* fCrypto;
+
+private:
+  // redefined virtual functions:
+  virtual Boolean isRTPSink() const;
+
+private:
+  u_int32_t fSSRC, fTimestampBase;
+  unsigned fTimestampFrequency;
+  Boolean fNextTimestampHasBeenPreset;
+  Boolean fEnableRTCPReports; // whether RTCP "SR" reports should be sent for this sink (default: True)
+  char const* fRTPPayloadFormatName;
+  unsigned fNumChannels;
+  struct timeval fCreationTime;
+  unsigned fEstimatedBitrate; // set on creation if known; otherwise 0
+
+  RTPTransmissionStatsDB* fTransmissionStatsDB;
+};
+
+
+class RTPTransmissionStats; // forward
+
+class RTPTransmissionStatsDB {
+public:
+  unsigned numReceivers() const { return fNumReceivers; }
+
+  class Iterator {
+  public:
+    Iterator(RTPTransmissionStatsDB& receptionStatsDB);
+    virtual ~Iterator();
+
+    RTPTransmissionStats* next();
+        // NULL if none
+
+  private:
+    HashTable::Iterator* fIter;
+  };
+
+  // The following is called whenever a RTCP RR packet is received:
+  void noteIncomingRR(u_int32_t SSRC, struct sockaddr_storage const& lastFromAddress,
+                      unsigned lossStats, unsigned lastPacketNumReceived,
+                      unsigned jitter, unsigned lastSRTime, unsigned diffSR_RRTime);
+
+  // The following is called when a RTCP BYE packet is received:
+  void removeRecord(u_int32_t SSRC);
+
+  RTPTransmissionStats* lookup(u_int32_t SSRC) const;
+
+private: // constructor and destructor, called only by RTPSink:
+  friend class RTPSink;
+  RTPTransmissionStatsDB(RTPSink& rtpSink);
+  virtual ~RTPTransmissionStatsDB();
+
+private:
+  void add(u_int32_t SSRC, RTPTransmissionStats* stats);
+
+private:
+  friend class Iterator;
+  unsigned fNumReceivers;
+  RTPSink& fOurRTPSink;
+  HashTable* fTable;
+};
+
+class RTPTransmissionStats {
+public:
+  u_int32_t SSRC() const {return fSSRC;}
+  struct sockaddr_storage const& lastFromAddress() const {return fLastFromAddress;}
+  unsigned lastPacketNumReceived() const {return fLastPacketNumReceived;}
+  unsigned firstPacketNumReported() const {return fFirstPacketNumReported;}
+  unsigned totNumPacketsLost() const {return fTotNumPacketsLost;}
+  unsigned jitter() const {return fJitter;}
+  unsigned lastSRTime() const { return fLastSRTime; }
+  unsigned diffSR_RRTime() const { return fDiffSR_RRTime; }
+  unsigned roundTripDelay() const;
+      // The round-trip delay (in units of 1/65536 seconds) computed from
+      // the most recently-received RTCP RR packet.
+  struct timeval const& timeCreated() const {return fTimeCreated;}
+  struct timeval const& lastTimeReceived() const {return fTimeReceived;}
+  void getTotalOctetCount(u_int32_t& hi, u_int32_t& lo);
+  void getTotalPacketCount(u_int32_t& hi, u_int32_t& lo);
+
+  // Information which requires at least two RRs to have been received:
+  unsigned packetsReceivedSinceLastRR() const;
+  u_int8_t packetLossRatio() const { return fPacketLossRatio; }
+     // as an 8-bit fixed-point number
+  int packetsLostBetweenRR() const;
+
+private:
+  // called only by RTPTransmissionStatsDB:
+  friend class RTPTransmissionStatsDB;
+  RTPTransmissionStats(RTPSink& rtpSink, u_int32_t SSRC);
+  virtual ~RTPTransmissionStats();
+
+  void noteIncomingRR(struct sockaddr_storage const& lastFromAddress,
+		      unsigned lossStats, unsigned lastPacketNumReceived,
+                      unsigned jitter,
+		      unsigned lastSRTime, unsigned diffSR_RRTime);
+
+private:
+  RTPSink& fOurRTPSink;
+  u_int32_t fSSRC;
+  struct sockaddr_storage fLastFromAddress;
+  unsigned fLastPacketNumReceived;
+  u_int8_t fPacketLossRatio;
+  unsigned fTotNumPacketsLost;
+  unsigned fJitter;
+  unsigned fLastSRTime;
+  unsigned fDiffSR_RRTime;
+  struct timeval fTimeCreated, fTimeReceived;
+  Boolean fAtLeastTwoRRsHaveBeenReceived;
+  unsigned fOldLastPacketNumReceived;
+  unsigned fOldTotNumPacketsLost;
+  Boolean fFirstPacket;
+  unsigned fFirstPacketNumReported;
+  u_int32_t fLastOctetCount, fTotalOctetCount_hi, fTotalOctetCount_lo;
+  u_int32_t fLastPacketCount, fTotalPacketCount_hi, fTotalPacketCount_lo;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/RTPSource.hh b/3rdparty/live555/src/liveMedia/include/RTPSource.hh
new file mode 100644
index 00000000..07cc7086
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/RTPSource.hh
@@ -0,0 +1,272 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// RTP Sources
+// C++ header
+
+#ifndef _RTP_SOURCE_HH
+#define _RTP_SOURCE_HH
+
+#ifndef _FRAMED_SOURCE_HH
+#include "FramedSource.hh"
+#endif
+#ifndef _RTP_INTERFACE_HH
+#include "RTPInterface.hh"
+#endif
+#ifndef _SRTP_CRYPTOGRAPHIC_CONTEXT_HH
+#include "SRTPCryptographicContext.hh"
+#endif
+
+class RTPReceptionStatsDB; // forward
+
+class RTPSource: public FramedSource {
+public:
+  static Boolean lookupByName(UsageEnvironment& env, char const* sourceName,
+			      RTPSource*& resultSource);
+
+  Boolean curPacketMarkerBit() const { return fCurPacketMarkerBit; }
+
+  unsigned char rtpPayloadFormat() const { return fRTPPayloadFormat; }
+
+  virtual Boolean hasBeenSynchronizedUsingRTCP();
+
+  Groupsock* RTPgs() const { return fRTPInterface.gs(); }
+
+  virtual void setPacketReorderingThresholdTime(unsigned uSeconds) = 0;
+
+  void setCrypto(SRTPCryptographicContext* crypto) { fCrypto = crypto; }
+
+  // used by RTCP:
+  u_int32_t SSRC() const { return fSSRC; }
+      // Note: This is *our* SSRC, not the SSRC in incoming RTP packets.
+     // later need a means of changing the SSRC if there's a collision #####
+  void registerForMultiplexedRTCPPackets(class RTCPInstance* rtcpInstance) {
+    fRTCPInstanceForMultiplexedRTCPPackets = rtcpInstance;
+  }
+  void deregisterForMultiplexedRTCPPackets() { registerForMultiplexedRTCPPackets(NULL); }
+
+  unsigned timestampFrequency() const {return fTimestampFrequency;}
+
+  RTPReceptionStatsDB& receptionStatsDB() const {
+    return *fReceptionStatsDB;
+  }
+
+  u_int32_t lastReceivedSSRC() const { return fLastReceivedSSRC; }
+  // Note: This is the SSRC in the most recently received RTP packet; not *our* SSRC
+
+  Boolean& enableRTCPReports() { return fEnableRTCPReports; }
+  Boolean const& enableRTCPReports() const { return fEnableRTCPReports; }
+
+  void setStreamSocket(int sockNum, unsigned char streamChannelId, TLSState* tlsState) {
+    // hack to allow sending RTP over TCP (RFC 2236, section 10.12)
+    fRTPInterface.setStreamSocket(sockNum, streamChannelId, tlsState);
+  }
+
+  void setAuxilliaryReadHandler(AuxHandlerFunc* handlerFunc,
+                                void* handlerClientData) {
+    fRTPInterface.setAuxilliaryReadHandler(handlerFunc,
+					   handlerClientData);
+  }
+
+  // Note that RTP receivers will usually not need to call either of the following two functions, because
+  // RTP sequence numbers and timestamps are usually not useful to receivers.
+  // (Our implementation of RTP reception already does all needed handling of RTP sequence numbers and timestamps.)
+  u_int16_t curPacketRTPSeqNum() const { return fCurPacketRTPSeqNum; }
+private: friend class MediaSubsession; // "MediaSubsession" is the only outside class that ever needs to see RTP timestamps!
+  u_int32_t curPacketRTPTimestamp() const { return fCurPacketRTPTimestamp; }
+
+protected:
+  RTPSource(UsageEnvironment& env, Groupsock* RTPgs,
+	    unsigned char rtpPayloadFormat, u_int32_t rtpTimestampFrequency);
+      // abstract base class
+  virtual ~RTPSource();
+
+protected:
+  RTPInterface fRTPInterface;
+  u_int16_t fCurPacketRTPSeqNum;
+  u_int32_t fCurPacketRTPTimestamp;
+  Boolean fCurPacketMarkerBit;
+  Boolean fCurPacketHasBeenSynchronizedUsingRTCP;
+  u_int32_t fLastReceivedSSRC;
+  class RTCPInstance* fRTCPInstanceForMultiplexedRTCPPackets;
+  SRTPCryptographicContext* fCrypto;
+
+private:
+  // redefined virtual functions:
+  virtual Boolean isRTPSource() const;
+  virtual void getAttributes() const;
+
+private:
+  unsigned char fRTPPayloadFormat;
+  unsigned fTimestampFrequency;
+  u_int32_t fSSRC;
+  Boolean fEnableRTCPReports; // whether RTCP "RR" reports should be sent for this source (default: True)
+
+  RTPReceptionStatsDB* fReceptionStatsDB;
+};
+
+
+class RTPReceptionStats; // forward
+
+class RTPReceptionStatsDB {
+public:
+  unsigned totNumPacketsReceived() const { return fTotNumPacketsReceived; }
+  unsigned numActiveSourcesSinceLastReset() const {
+    return fNumActiveSourcesSinceLastReset;
+ }
+
+  void reset();
+      // resets periodic stats (called each time they're used to
+      // generate a reception report)
+
+  class Iterator {
+  public:
+    Iterator(RTPReceptionStatsDB& receptionStatsDB);
+    virtual ~Iterator();
+
+    RTPReceptionStats* next(Boolean includeInactiveSources = False);
+        // NULL if none
+
+  private:
+    HashTable::Iterator* fIter;
+  };
+
+  // The following is called whenever a RTP packet is received:
+  void noteIncomingPacket(u_int32_t SSRC, u_int16_t seqNum,
+			  u_int32_t rtpTimestamp,
+			  unsigned timestampFrequency,
+			  Boolean useForJitterCalculation,
+			  struct timeval& resultPresentationTime,
+			  Boolean& resultHasBeenSyncedUsingRTCP,
+			  unsigned packetSize /* payload only */);
+
+  // The following is called whenever a RTCP SR packet is received:
+  void noteIncomingSR(u_int32_t SSRC,
+		      u_int32_t ntpTimestampMSW, u_int32_t ntpTimestampLSW,
+		      u_int32_t rtpTimestamp);
+
+  // The following is called when a RTCP BYE packet is received:
+  void removeRecord(u_int32_t SSRC);
+
+  RTPReceptionStats* lookup(u_int32_t SSRC) const;
+
+protected: // constructor and destructor, called only by RTPSource:
+  friend class RTPSource;
+  RTPReceptionStatsDB();
+  virtual ~RTPReceptionStatsDB();
+
+protected:
+  void add(u_int32_t SSRC, RTPReceptionStats* stats);
+
+protected:
+  friend class Iterator;
+  unsigned fNumActiveSourcesSinceLastReset;
+
+private:
+  HashTable* fTable;
+  unsigned fTotNumPacketsReceived; // for all SSRCs
+};
+
+class RTPReceptionStats {
+public:
+  u_int32_t SSRC() const { return fSSRC; }
+  unsigned numPacketsReceivedSinceLastReset() const {
+    return fNumPacketsReceivedSinceLastReset;
+  }
+  unsigned totNumPacketsReceived() const { return fTotNumPacketsReceived; }
+  double totNumKBytesReceived() const;
+
+  unsigned totNumPacketsExpected() const {
+    return (fHighestExtSeqNumReceived - fBaseExtSeqNumReceived) + 1;
+  }
+
+  unsigned baseExtSeqNumReceived() const { return fBaseExtSeqNumReceived; }
+  unsigned lastResetExtSeqNumReceived() const {
+    return fLastResetExtSeqNumReceived;
+  }
+  unsigned highestExtSeqNumReceived() const {
+    return fHighestExtSeqNumReceived;
+  }
+
+  unsigned jitter() const;
+
+  unsigned lastReceivedSR_NTPmsw() const { return fLastReceivedSR_NTPmsw; }
+  unsigned lastReceivedSR_NTPlsw() const { return fLastReceivedSR_NTPlsw; }
+  struct timeval const& lastReceivedSR_time() const {
+    return fLastReceivedSR_time;
+  }
+
+  unsigned minInterPacketGapUS() const { return fMinInterPacketGapUS; }
+  unsigned maxInterPacketGapUS() const { return fMaxInterPacketGapUS; }
+  struct timeval const& totalInterPacketGaps() const {
+    return fTotalInterPacketGaps;
+  }
+
+protected:
+  // called only by RTPReceptionStatsDB:
+  friend class RTPReceptionStatsDB;
+  RTPReceptionStats(u_int32_t SSRC, u_int16_t initialSeqNum);
+  RTPReceptionStats(u_int32_t SSRC);
+  virtual ~RTPReceptionStats();
+
+private:
+  void noteIncomingPacket(u_int16_t seqNum, u_int32_t rtpTimestamp,
+			  unsigned timestampFrequency,
+			  Boolean useForJitterCalculation,
+			  struct timeval& resultPresentationTime,
+			  Boolean& resultHasBeenSyncedUsingRTCP,
+			  unsigned packetSize /* payload only */);
+  void noteIncomingSR(u_int32_t ntpTimestampMSW, u_int32_t ntpTimestampLSW,
+		      u_int32_t rtpTimestamp);
+  void init(u_int32_t SSRC);
+  void initSeqNum(u_int16_t initialSeqNum);
+  void reset();
+      // resets periodic stats (called each time they're used to
+      // generate a reception report)
+
+protected:
+  u_int32_t fSSRC;
+  unsigned fNumPacketsReceivedSinceLastReset;
+  unsigned fTotNumPacketsReceived;
+  u_int32_t fTotBytesReceived_hi, fTotBytesReceived_lo;
+  Boolean fHaveSeenInitialSequenceNumber;
+  unsigned fBaseExtSeqNumReceived;
+  unsigned fLastResetExtSeqNumReceived;
+  unsigned fHighestExtSeqNumReceived;
+  int fLastTransit; // used in the jitter calculation
+  u_int32_t fPreviousPacketRTPTimestamp;
+  double fJitter;
+  // The following are recorded whenever we receive a RTCP SR for this SSRC:
+  unsigned fLastReceivedSR_NTPmsw; // NTP timestamp (from SR), most-signif
+  unsigned fLastReceivedSR_NTPlsw; // NTP timestamp (from SR), least-signif
+  struct timeval fLastReceivedSR_time;
+  struct timeval fLastPacketReceptionTime;
+  unsigned fMinInterPacketGapUS, fMaxInterPacketGapUS;
+  struct timeval fTotalInterPacketGaps;
+
+private:
+  // Used to convert from RTP timestamp to 'wall clock' time:
+  Boolean fHasBeenSynchronized;
+  u_int32_t fSyncTimestamp;
+  struct timeval fSyncTime;
+};
+
+
+Boolean seqNumLT(u_int16_t s1, u_int16_t s2);
+  // a 'less-than' on 16-bit sequence numbers
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/RTSPClient.hh b/3rdparty/live555/src/liveMedia/include/RTSPClient.hh
new file mode 100644
index 00000000..eda7bd3a
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/RTSPClient.hh
@@ -0,0 +1,414 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A generic RTSP client - for a single "rtsp://" URL
+// C++ header
+
+#ifndef _RTSP_CLIENT_HH
+#define _RTSP_CLIENT_HH
+
+#ifndef _MEDIA_SESSION_HH
+#include "MediaSession.hh"
+#endif
+#ifndef _NET_ADDRESS_HH
+#include "NetAddress.hh"
+#endif
+#ifndef _DIGEST_AUTHENTICATION_HH
+#include "DigestAuthentication.hh"
+#endif
+#ifndef _TLS_STATE_HH
+#include "TLSState.hh"
+#endif
+#ifndef OMIT_REGISTER_HANDLING
+#ifndef _RTSP_SERVER_HH
+#include "RTSPServer.hh" // For the optional "HandlerForREGISTERCommand" mini-server
+#endif
+#endif
+
+class RTSPClient: public Medium {
+public:
+  static RTSPClient* createNew(UsageEnvironment& env, char const* rtspURL,
+			       int verbosityLevel = 0,
+			       char const* applicationName = NULL,
+			       portNumBits tunnelOverHTTPPortNum = 0,
+			       int socketNumToServer = -1);
+  // If "tunnelOverHTTPPortNum" is non-zero, we tunnel RTSP (and RTP)
+  //     over a HTTP connection with the given port number, using the technique
+  //     described in Apple's document <http://developer.apple.com/documentation/QuickTime/QTSS/Concepts/chapter_2_section_14.html>
+  // If "socketNumToServer" is >= 0, then it is the socket number of an already-existing TCP connection to the server.
+  //     (In this case, "rtspURL" must point to the socket's endpoint, so that it can be accessed via the socket.)
+
+  typedef void (responseHandler)(RTSPClient* rtspClient,
+				 int resultCode, char* resultString);
+      // A function that is called in response to a RTSP command.  The parameters are as follows:
+      //     "rtspClient": The "RTSPClient" object on which the original command was issued.
+      //     "resultCode": If zero, then the command completed successfully.  If non-zero, then the command did not complete
+      //         successfully, and "resultCode" indicates the error, as follows:
+      //             A positive "resultCode" is a RTSP error code (for example, 404 means "not found")
+      //             A negative "resultCode" indicates a socket/network error; 0-"resultCode" is the standard "errno" code.
+      //     "resultString": A ('\0'-terminated) string returned along with the response, or else NULL.
+      //         In particular:
+      //             "resultString" for a successful "DESCRIBE" command will be the media session's SDP description.
+      //             "resultString" for a successful "OPTIONS" command will be a list of allowed commands.
+      //         Note that this string can be present (i.e., not NULL) even if "resultCode" is non-zero - i.e., an error message.
+      //         Also, "resultString" can be NULL, even if "resultCode" is zero (e.g., if the RTSP command succeeded, but without
+      //             including an appropriate result header).
+      //         Note also that this string is dynamically allocated, and must be freed by the handler (or the caller)
+      //             - using "delete[]".
+
+  unsigned sendDescribeCommand(responseHandler* responseHandler, Authenticator* authenticator = NULL);
+      // Issues a RTSP "DESCRIBE" command, then returns the "CSeq" sequence number that was used in the command.
+      // The (programmer-supplied) "responseHandler" function is called later to handle the response
+      //     (or is called immediately - with an error code - if the command cannot be sent).
+      // "authenticator" (optional) is used for access control.  If you have username and password strings, you can use this by
+      //     passing an actual parameter that you created by creating an "Authenticator(username, password) object".
+      //     (Note that if you supply a non-NULL "authenticator" parameter, you need do this only for the first command you send.)
+
+  unsigned sendOptionsCommand(responseHandler* responseHandler, Authenticator* authenticator = NULL);
+      // Issues a RTSP "OPTIONS" command, then returns the "CSeq" sequence number that was used in the command.
+      // (The "responseHandler" and "authenticator" parameters are as described for "sendDescribeCommand".)
+
+  unsigned sendAnnounceCommand(char const* sdpDescription, responseHandler* responseHandler, Authenticator* authenticator = NULL);
+      // Issues a RTSP "ANNOUNCE" command (with "sdpDescription" as parameter),
+      //     then returns the "CSeq" sequence number that was used in the command.
+      // (The "responseHandler" and "authenticator" parameters are as described for "sendDescribeCommand".)
+
+  unsigned sendSetupCommand(MediaSubsession& subsession, responseHandler* responseHandler,
+			    Boolean streamOutgoing = False,
+			    Boolean streamUsingTCP = False,
+			    Boolean forceMulticastOnUnspecified = False,
+			    Authenticator* authenticator = NULL);
+      // Issues a RTSP "SETUP" command, then returns the "CSeq" sequence number that was used in the command.
+      // (The "responseHandler" and "authenticator" parameters are as described for "sendDescribeCommand".)
+
+  unsigned sendPlayCommand(MediaSession& session, responseHandler* responseHandler,
+			   double start = 0.0f, double end = -1.0f, float scale = 1.0f,
+			   Authenticator* authenticator = NULL);
+      // Issues an aggregate RTSP "PLAY" command on "session", then returns the "CSeq" sequence number that was used in the command.
+      // (Note: start=-1 means 'resume'; end=-1 means 'play to end')
+      // (The "responseHandler" and "authenticator" parameters are as described for "sendDescribeCommand".)
+  unsigned sendPlayCommand(MediaSubsession& subsession, responseHandler* responseHandler,
+			   double start = 0.0f, double end = -1.0f, float scale = 1.0f,
+			   Authenticator* authenticator = NULL);
+      // Issues a RTSP "PLAY" command on "subsession", then returns the "CSeq" sequence number that was used in the command.
+      // (Note: start=-1 means 'resume'; end=-1 means 'play to end')
+      // (The "responseHandler" and "authenticator" parameters are as described for "sendDescribeCommand".)
+
+  // Alternative forms of "sendPlayCommand()", used to send "PLAY" commands that include an 'absolute' time range:
+  // (The "absStartTime" string (and "absEndTime" string, if present) *must* be of the form
+  //  "YYYYMMDDTHHMMSSZ" or "YYYYMMDDTHHMMSS.<frac>Z")
+  unsigned sendPlayCommand(MediaSession& session, responseHandler* responseHandler,
+			   char const* absStartTime, char const* absEndTime = NULL, float scale = 1.0f,
+			   Authenticator* authenticator = NULL);
+  unsigned sendPlayCommand(MediaSubsession& subsession, responseHandler* responseHandler,
+			   char const* absStartTime, char const* absEndTime = NULL, float scale = 1.0f,
+			   Authenticator* authenticator = NULL);
+
+  unsigned sendPauseCommand(MediaSession& session, responseHandler* responseHandler, Authenticator* authenticator = NULL);
+      // Issues an aggregate RTSP "PAUSE" command on "session", then returns the "CSeq" sequence number that was used in the command.
+      // (The "responseHandler" and "authenticator" parameters are as described for "sendDescribeCommand".)
+  unsigned sendPauseCommand(MediaSubsession& subsession, responseHandler* responseHandler, Authenticator* authenticator = NULL);
+      // Issues a RTSP "PAUSE" command on "subsession", then returns the "CSeq" sequence number that was used in the command.
+      // (The "responseHandler" and "authenticator" parameters are as described for "sendDescribeCommand".)
+
+  unsigned sendRecordCommand(MediaSession& session, responseHandler* responseHandler, Authenticator* authenticator = NULL);
+      // Issues an aggregate RTSP "RECORD" command on "session", then returns the "CSeq" sequence number that was used in the command.
+      // (The "responseHandler" and "authenticator" parameters are as described for "sendDescribeCommand".)
+  unsigned sendRecordCommand(MediaSubsession& subsession, responseHandler* responseHandler, Authenticator* authenticator = NULL);
+      // Issues a RTSP "RECORD" command on "subsession", then returns the "CSeq" sequence number that was used in the command.
+      // (The "responseHandler" and "authenticator" parameters are as described for "sendDescribeCommand".)
+
+  unsigned sendTeardownCommand(MediaSession& session, responseHandler* responseHandler, Authenticator* authenticator = NULL);
+      // Issues an aggregate RTSP "TEARDOWN" command on "session", then returns the "CSeq" sequence number that was used in the command.
+      // (The "responseHandler" and "authenticator" parameters are as described for "sendDescribeCommand".)
+  unsigned sendTeardownCommand(MediaSubsession& subsession, responseHandler* responseHandler, Authenticator* authenticator = NULL);
+      // Issues a RTSP "TEARDOWN" command on "subsession", then returns the "CSeq" sequence number that was used in the command.
+      // (The "responseHandler" and "authenticator" parameters are as described for "sendDescribeCommand".)
+
+  unsigned sendSetParameterCommand(MediaSession& session, responseHandler* responseHandler,
+				   char const* parameterName, char const* parameterValue,
+				   Authenticator* authenticator = NULL);
+      // Issues an aggregate RTSP "SET_PARAMETER" command on "session", then returns the "CSeq" sequence number that was used in the command.
+      // (The "responseHandler" and "authenticator" parameters are as described for "sendDescribeCommand".)
+
+  unsigned sendGetParameterCommand(MediaSession& session, responseHandler* responseHandler, char const* parameterName,
+				   Authenticator* authenticator = NULL);
+      // Issues an aggregate RTSP "GET_PARAMETER" command on "session", then returns the "CSeq" sequence number that was used in the command.
+      // (The "responseHandler" and "authenticator" parameters are as described for "sendDescribeCommand".)
+
+  void setRequireValue(char const* requireValue = NULL);
+      // Sets a string to be used as the value of a "Require:" header to be included in
+      // subsequent RTSP commands.  Call "setRequireValue()" again (i.e., with no parameter)
+      // to clear this (and so stop "Require:" headers from being included in subsequent cmds).
+
+  void sendDummyUDPPackets(MediaSession& session, unsigned numDummyPackets = 2);
+  void sendDummyUDPPackets(MediaSubsession& subsession, unsigned numDummyPackets = 2);
+      // Sends short 'dummy' (i.e., non-RTP or RTCP) UDP packets towards the server, to increase
+      // the likelihood of RTP/RTCP packets from the server reaching us if we're behind a NAT.
+      // (If we requested RTP-over-TCP streaming, then these functions have no effect.)
+      // Our implementation automatically does this just prior to sending each "PLAY" command;
+      // You should not call these functions yourself unless you know what you're doing.
+
+  void setSpeed(MediaSession& session, float speed = 1.0f);
+      // Set (recorded) media download speed to given value to support faster download using 'Speed:'
+      // option on 'PLAY' command.
+
+  Boolean changeResponseHandler(unsigned cseq, responseHandler* newResponseHandler);
+      // Changes the response handler for the previously-performed command (whose operation returned "cseq").
+      // (To turn off any response handling for the command, use a "newResponseHandler" value of NULL.  This might be done as part
+      //  of an implementation of a 'timeout handler' on the command, for example.)
+      // This function returns True iff "cseq" was for a valid previously-performed command (whose response is still unhandled).
+
+  int socketNum() const { return fInputSocketNum; }
+
+  static Boolean lookupByName(UsageEnvironment& env,
+			      char const* sourceName,
+			      RTSPClient*& resultClient);
+
+  Boolean parseRTSPURL(char const* url,
+		       char*& username, char*& password, NetAddress& address, portNumBits& portNum, char const** urlSuffix = NULL);
+      // Parses "url" as "rtsp://[<username>[:<password>]@]<server-address-or-name>[:<port>][/<stream-name>]"
+      // (Note that the returned "username" and "password" are either NULL, or heap-allocated strings that the caller must later delete[].)
+
+  void setUserAgentString(char const* userAgentName);
+      // sets an alternative string to be used in RTSP "User-Agent:" headers
+
+  void disallowBasicAuthentication() { fAllowBasicAuthentication = False; }
+      // call this if you don't want the server to request 'Basic' authentication
+      // (which would cause the client to send usernames and passwords over the net).
+
+  unsigned sessionTimeoutParameter() const { return fSessionTimeoutParameter; }
+
+  char const* url() const { return fBaseURL; }
+
+  void useTLS() { fTLS.isNeeded = True; }
+
+  static unsigned responseBufferSize;
+
+public: // Some compilers complain if this is "private:"
+  // The state of a request-in-progress:
+  class RequestRecord {
+  public:
+    RequestRecord(unsigned cseq, char const* commandName, responseHandler* handler,
+		  MediaSession* session = NULL, MediaSubsession* subsession = NULL, u_int32_t booleanFlags = 0,
+		  double start = 0.0f, double end = -1.0f, float scale = 1.0f, char const* contentStr = NULL);
+    RequestRecord(unsigned cseq, responseHandler* handler,
+		  char const* absStartTime, char const* absEndTime = NULL, float scale = 1.0f,
+		  MediaSession* session = NULL, MediaSubsession* subsession = NULL);
+        // alternative constructor for creating "PLAY" requests that include 'absolute' time values
+    virtual ~RequestRecord();
+
+    RequestRecord*& next() { return fNext; }
+    unsigned& cseq() { return fCSeq; }
+    char const* commandName() const { return fCommandName; }
+    MediaSession* session() const { return fSession; }
+    MediaSubsession* subsession() const { return fSubsession; }
+    u_int32_t booleanFlags() const { return fBooleanFlags; }
+    double start() const { return fStart; }
+    double end() const { return fEnd; }
+    char const* absStartTime() const { return fAbsStartTime; }
+    char const* absEndTime() const { return fAbsEndTime; }
+    float scale() const { return fScale; }
+    char* contentStr() const { return fContentStr; }
+    responseHandler*& handler() { return fHandler; }
+
+  private:
+    RequestRecord* fNext;
+    unsigned fCSeq;
+    char const* fCommandName;
+    MediaSession* fSession;
+    MediaSubsession* fSubsession;
+    u_int32_t fBooleanFlags;
+    double fStart, fEnd;
+    char *fAbsStartTime, *fAbsEndTime; // used for optional 'absolute' (i.e., "time=") range specifications
+    float fScale;
+    char* fContentStr;
+    responseHandler* fHandler;
+  };
+
+protected:
+  RTSPClient(UsageEnvironment& env, char const* rtspURL,
+	     int verbosityLevel, char const* applicationName, portNumBits tunnelOverHTTPPortNum, int socketNumToServer);
+      // called only by createNew();
+  virtual ~RTSPClient();
+
+  void reset();
+  void setBaseURL(char const* url);
+  int grabSocket(); // allows a subclass to reuse our input socket, so that it won't get closed when we're deleted
+  virtual unsigned sendRequest(RequestRecord* request);
+  virtual Boolean setRequestFields(RequestRecord* request,
+				   char*& cmdURL, Boolean& cmdURLWasAllocated,
+				   char const*& protocolStr,
+				   char*& extraHeaders, Boolean& extraHeadersWereAllocated);
+      // used to implement "sendRequest()"; subclasses may reimplement this (e.g., when implementing a new command name)
+  virtual int connectToServer(int socketNum, portNumBits remotePortNum); // used to implement "openConnection()"; result values: -1: failure; 0: pending; 1: success
+
+private: // redefined virtual functions
+  virtual Boolean isRTSPClient() const;
+
+private:
+  class RequestQueue {
+  public:
+    RequestQueue();
+    RequestQueue(RequestQueue& origQueue); // moves the queue contents to the new queue
+    virtual ~RequestQueue();
+
+    void enqueue(RequestRecord* request); // "request" must not be NULL
+    RequestRecord* dequeue();
+    void putAtHead(RequestRecord* request); // "request" must not be NULL
+    RequestRecord* findByCSeq(unsigned cseq);
+    Boolean isEmpty() const { return fHead == NULL; }
+    void reset();
+
+  private:
+    RequestRecord* fHead;
+    RequestRecord* fTail;
+  };
+
+  void resetTCPSockets();
+  void resetResponseBuffer();
+  int openConnection(); // result values: -1: failure; 0: pending; 1: success
+  char* createAuthenticatorString(char const* cmd, char const* url);
+  char* createBlocksizeString(Boolean streamUsingTCP);
+  char* createKeyMgmtString(char const* url, MediaSubsession const& subsession);
+  void handleRequestError(RequestRecord* request);
+  Boolean parseResponseCode(char const* line, unsigned& responseCode, char const*& responseString);
+  void handleIncomingRequest();
+  static Boolean checkForHeader(char const* line, char const* headerName, unsigned headerNameLength, char const*& headerParams);
+  Boolean parseTransportParams(char const* paramsStr,
+			       char*& serverAddressStr, portNumBits& serverPortNum,
+			       unsigned char& rtpChannelId, unsigned char& rtcpChannelId);
+  Boolean parseScaleParam(char const* paramStr, float& scale);
+  Boolean parseSpeedParam(char const* paramStr, float& speed);
+  Boolean parseRTPInfoParams(char const*& paramStr, u_int16_t& seqNum, u_int32_t& timestamp);
+  Boolean handleSETUPResponse(MediaSubsession& subsession, char const* sessionParamsStr, char const* transportParamsStr,
+			      Boolean streamUsingTCP);
+  Boolean handlePLAYResponse(MediaSession* session, MediaSubsession* subsession,
+                             char const* scaleParamsStr, const char* speedParamsStr,
+			     char const* rangeParamsStr, char const* rtpInfoParamsStr);
+  Boolean handleTEARDOWNResponse(MediaSession& session, MediaSubsession& subsession);
+  Boolean handleGET_PARAMETERResponse(char const* parameterName, char*& resultValueString, char* resultValueStringEnd);
+  Boolean handleAuthenticationFailure(char const* wwwAuthenticateParamsStr);
+  Boolean resendCommand(RequestRecord* request);
+  char const* sessionURL(MediaSession const& session) const;
+  static void handleAlternativeRequestByte(void*, u_int8_t requestByte);
+  void handleAlternativeRequestByte1(u_int8_t requestByte);
+  void constructSubsessionURL(MediaSubsession const& subsession,
+			      char const*& prefix,
+			      char const*& separator,
+			      char const*& suffix);
+
+  // Support for tunneling RTSP-over-HTTP:
+  Boolean setupHTTPTunneling1(); // send the HTTP "GET"
+  static void responseHandlerForHTTP_GET(RTSPClient* rtspClient, int responseCode, char* responseString);
+  void responseHandlerForHTTP_GET1(int responseCode, char* responseString);
+  Boolean setupHTTPTunneling2(); // send the HTTP "POST"
+
+  // Support for asynchronous connections to the server:
+  static void connectionHandler(void*, int /*mask*/);
+  void connectionHandler1();
+
+  // Support for handling data sent back by a server:
+  static void incomingDataHandler(void*, int /*mask*/);
+  void incomingDataHandler1();
+  void handleResponseBytes(int newBytesRead);
+
+  // Writing/reading data over a (already set-up) connection:
+  int write(const char* data, unsigned count);
+  int read(u_int8_t* buffer, unsigned bufferSize);
+
+public:
+  u_int16_t desiredMaxIncomingPacketSize;
+    // If set to a value >0, then a "Blocksize:" header with this value (minus an allowance for
+    // IP, UDP, and RTP headers) will be sent with each "SETUP" request.
+
+protected:
+  int fVerbosityLevel;
+  unsigned fCSeq; // sequence number, used in consecutive requests
+  Authenticator fCurrentAuthenticator;
+  Boolean fAllowBasicAuthentication;
+  struct sockaddr_storage fServerAddress;
+
+private:
+  portNumBits fTunnelOverHTTPPortNum;
+  char* fUserAgentHeaderStr;
+  unsigned fUserAgentHeaderStrLen;
+  int fInputSocketNum, fOutputSocketNum;
+  char* fBaseURL;
+  unsigned char fTCPStreamIdCount; // used for (optional) RTP/TCP
+  char* fLastSessionId;
+  unsigned fSessionTimeoutParameter; // optionally set in response "Session:" headers
+  char* fResponseBuffer;
+  unsigned fResponseBytesAlreadySeen, fResponseBufferBytesLeft;
+  RequestQueue fRequestsAwaitingConnection, fRequestsAwaitingHTTPTunneling, fRequestsAwaitingResponse;
+  char* fRequireStr;
+
+  // Support for tunneling RTSP-over-HTTP:
+  char fSessionCookie[33];
+  unsigned fSessionCookieCounter;
+  Boolean fHTTPTunnelingConnectionIsPending;
+
+  // Optional support for TLS:
+  ClientTLSState fTLS;
+  friend class ClientTLSState;
+};
+
+
+#ifndef OMIT_REGISTER_HANDLING
+////////// HandlerServerForREGISTERCommand /////////
+
+// A simple server that creates a new "RTSPClient" object whenever a "REGISTER" request arrives (specifying the "rtsp://" URL
+// of a stream).  The new "RTSPClient" object will be created with the specified URL, and passed to the provided handler function.
+
+typedef void onRTSPClientCreationFunc(RTSPClient* newRTSPClient, Boolean requestStreamingOverTCP);
+
+class HandlerServerForREGISTERCommand: public RTSPServer {
+public:
+  static HandlerServerForREGISTERCommand* createNew(UsageEnvironment& env, onRTSPClientCreationFunc* creationFunc,
+						    Port ourPort = 0, UserAuthenticationDatabase* authDatabase = NULL,
+						    int verbosityLevel = 0, char const* applicationName = NULL);
+      // If ourPort.num() == 0, we'll choose the port number ourself.  (Use the following function to get it.)
+  portNumBits serverPortNum() const { return ntohs(fServerPort.num()); }
+
+protected:
+  HandlerServerForREGISTERCommand(UsageEnvironment& env, onRTSPClientCreationFunc* creationFunc, int ourSocketIPv4, int ourSocketIPv6, Port ourPort,
+				  UserAuthenticationDatabase* authDatabase, int verbosityLevel, char const* applicationName);
+      // called only by createNew();
+  virtual ~HandlerServerForREGISTERCommand();
+
+  virtual RTSPClient* createNewRTSPClient(char const* rtspURL, int verbosityLevel, char const* applicationName,
+					  int socketNumToServer);
+      // This function - by default - creates a (base) "RTSPClient" object.  If you want to create a subclass
+      // of "RTSPClient" instead, then subclass this class, and redefine this virtual function.
+
+protected: // redefined virtual functions
+  virtual char const* allowedCommandNames(); // "OPTIONS", "REGISTER", and (perhaps) "DEREGISTER" only
+  virtual Boolean weImplementREGISTER(char const* cmd/*"REGISTER" or "DEREGISTER"*/,
+				      char const* proxyURLSuffix, char*& responseStr);
+      // redefined to return True (for cmd=="REGISTER")
+  virtual void implementCmd_REGISTER(char const* cmd/*"REGISTER" or "DEREGISTER"*/,
+				     char const* url, char const* urlSuffix, int socketToRemoteServer,
+				     Boolean deliverViaTCP, char const* proxyURLSuffix);
+
+private:
+  onRTSPClientCreationFunc* fCreationFunc;
+  int fVerbosityLevel;
+  char* fApplicationName;
+};
+#endif
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/RTSPCommon.hh b/3rdparty/live555/src/liveMedia/include/RTSPCommon.hh
new file mode 100644
index 00000000..32962051
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/RTSPCommon.hh
@@ -0,0 +1,65 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// Common routines used by both RTSP clients and servers
+// C++ header
+
+#ifndef _RTSP_COMMON_HH
+#define _RTSP_COMMON_HH
+
+#ifndef _BOOLEAN_HH
+#include "Boolean.hh"
+#endif
+
+#ifndef _MEDIA_HH
+#include <Media.hh> // includes some definitions perhaps needed for Borland compilers?
+#endif
+
+#if defined(__WIN32__) || defined(_WIN32) || defined(_QNX4)
+#define _strncasecmp _strnicmp
+#define snprintf _snprintf
+#else
+#define _strncasecmp strncasecmp
+#endif
+
+#define RTSP_PARAM_STRING_MAX 200
+
+Boolean parseRTSPRequestString(char const *reqStr, unsigned reqStrSize, // in
+			       char *resultCmdName, // out
+			       unsigned resultCmdNameMaxSize, // in
+			       char* resultURLPreSuffix, // out
+			       unsigned resultURLPreSuffixMaxSize, // in
+			       char* resultURLSuffix, // out
+			       unsigned resultURLSuffixMaxSize, // in
+			       char* resultCSeq, // out
+			       unsigned resultCSeqMaxSize, // in
+			       char* resultSessionId, // out
+			       unsigned resultSessionIdMaxSize, // in
+			       unsigned& contentLength, Boolean& urlIsRTSPS); // out
+
+Boolean parseRangeParam(char const* paramStr, double& rangeStart, double& rangeEnd, char*& absStartTime, char*& absEndTime, Boolean& startTimeIsNow);
+Boolean parseRangeHeader(char const* buf, double& rangeStart, double& rangeEnd, char*& absStartTime, char*& absEndTime, Boolean& startTimeIsNow);
+
+Boolean parseScaleHeader(char const* buf, float& scale);
+
+Boolean RTSPOptionIsSupported(char const* commandName, char const* optionsResponseString);
+    // Returns True iff the RTSP command "commandName" is mentioned as one of the commands supported in "optionsResponseString"
+    // (which should be the 'resultString' from a previous RTSP "OPTIONS" request).
+
+char const* dateHeader(); // A "Date:" header that can be used in a RTSP (or HTTP) response 
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/RTSPRegisterSender.hh b/3rdparty/live555/src/liveMedia/include/RTSPRegisterSender.hh
new file mode 100644
index 00000000..c7cc4d21
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/RTSPRegisterSender.hh
@@ -0,0 +1,138 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// Special objects which, when created, sends a custom RTSP "REGISTER" (or "DEREGISTER") command
+// to a specified client.
+// C++ header
+
+#ifndef _RTSP_REGISTER_SENDER_HH
+#define _RTSP_REGISTER_SENDER_HH
+
+#ifndef _RTSP_CLIENT_HH
+#include "RTSPClient.hh"
+#endif
+
+class RTSPRegisterOrDeregisterSender: public RTSPClient {
+public:
+  virtual ~RTSPRegisterOrDeregisterSender();
+protected: // we're a virtual base class
+  RTSPRegisterOrDeregisterSender(UsageEnvironment& env,
+				 char const* remoteClientNameOrAddress, portNumBits remoteClientPortNum,
+				 Authenticator* authenticator,
+				 int verbosityLevel, char const* applicationName);
+
+public: // Some compilers complain if this is "protected:"
+  // A subclass of "RTSPClient::RequestRecord", specific to our "REGISTER" and "DEREGISTER" commands:
+  class RequestRecord_REGISTER_or_DEREGISTER: public RTSPClient::RequestRecord {
+  public:
+    RequestRecord_REGISTER_or_DEREGISTER(unsigned cseq, char const* cmdName, RTSPClient::responseHandler* rtspResponseHandler, char const* rtspURLToRegisterOrDeregister, char const* proxyURLSuffix);
+    virtual ~RequestRecord_REGISTER_or_DEREGISTER();
+
+    char const* proxyURLSuffix() const { return fProxyURLSuffix; }
+
+  protected:
+    char* fRTSPURLToRegisterOrDeregister;
+    char* fProxyURLSuffix;
+  };
+
+protected:
+  portNumBits fRemoteClientPortNum;
+};
+
+//////////
+
+class RTSPRegisterSender: public RTSPRegisterOrDeregisterSender {
+public:
+  static RTSPRegisterSender*
+  createNew(UsageEnvironment& env,
+	    char const* remoteClientNameOrAddress, portNumBits remoteClientPortNum, char const* rtspURLToRegister,
+	    RTSPClient::responseHandler* rtspResponseHandler, Authenticator* authenticator = NULL,
+	    Boolean requestStreamingViaTCP = False, char const* proxyURLSuffix = NULL, Boolean reuseConnection = False,
+	    int verbosityLevel = 0, char const* applicationName = NULL);
+
+  void grabConnection(int& sock, struct sockaddr_storage& remoteAddress); // so that the socket doesn't get closed when we're deleted
+
+protected:
+  RTSPRegisterSender(UsageEnvironment& env,
+		     char const* remoteClientNameOrAddress, portNumBits remoteClientPortNum, char const* rtspURLToRegister,
+		     RTSPClient::responseHandler* rtspResponseHandler, Authenticator* authenticator,
+		     Boolean requestStreamingViaTCP, char const* proxyURLSuffix, Boolean reuseConnection,
+		     int verbosityLevel, char const* applicationName);
+    // called only by "createNew()"
+  virtual ~RTSPRegisterSender();
+
+  // Redefined virtual functions:
+  virtual Boolean setRequestFields(RequestRecord* request,
+                                   char*& cmdURL, Boolean& cmdURLWasAllocated,
+                                   char const*& protocolStr,
+                                   char*& extraHeaders, Boolean& extraHeadersWereAllocated);
+
+public: // Some compilers complain if this is "protected:"
+  // A subclass of "RequestRecord_REGISTER_or_DEREGISTER", specific to our "REGISTER" command:
+  class RequestRecord_REGISTER: public RTSPRegisterOrDeregisterSender::RequestRecord_REGISTER_or_DEREGISTER {
+  public:
+    RequestRecord_REGISTER(unsigned cseq, RTSPClient::responseHandler* rtspResponseHandler, char const* rtspURLToRegister,
+			   Boolean reuseConnection, Boolean requestStreamingViaTCP, char const* proxyURLSuffix);
+    virtual ~RequestRecord_REGISTER();
+
+    char const* rtspURLToRegister() const { return fRTSPURLToRegisterOrDeregister; }
+    Boolean reuseConnection() const { return fReuseConnection; }
+    Boolean requestStreamingViaTCP() const { return fRequestStreamingViaTCP; }
+
+  private:
+    Boolean fReuseConnection, fRequestStreamingViaTCP;
+  };
+};
+
+//////////
+
+class RTSPDeregisterSender: public RTSPRegisterOrDeregisterSender {
+public:
+  static RTSPDeregisterSender*
+  createNew(UsageEnvironment& env,
+	    char const* remoteClientNameOrAddress, portNumBits remoteClientPortNum, char const* rtspURLToDeregister,
+	    RTSPClient::responseHandler* rtspResponseHandler, Authenticator* authenticator = NULL,
+	    char const* proxyURLSuffix = NULL,
+	    int verbosityLevel = 0, char const* applicationName = NULL);
+
+protected:
+  RTSPDeregisterSender(UsageEnvironment& env,
+		       char const* remoteClientNameOrAddress, portNumBits remoteClientPortNum, char const* rtspURLToDeregister,
+		     RTSPClient::responseHandler* rtspResponseHandler, Authenticator* authenticator,
+		     char const* proxyURLSuffix,
+		     int verbosityLevel, char const* applicationName);
+    // called only by "createNew()"
+  virtual ~RTSPDeregisterSender();
+
+  // Redefined virtual functions:
+  virtual Boolean setRequestFields(RequestRecord* request,
+                                   char*& cmdURL, Boolean& cmdURLWasAllocated,
+                                   char const*& protocolStr,
+                                   char*& extraHeaders, Boolean& extraHeadersWereAllocated);
+
+public: // Some compilers complain if this is "protected:"
+  // A subclass of "RequestRecord_REGISTER_or_DEREGISTER", specific to our "DEREGISTER" command:
+  class RequestRecord_DEREGISTER: public RTSPRegisterOrDeregisterSender::RequestRecord_REGISTER_or_DEREGISTER {
+  public:
+    RequestRecord_DEREGISTER(unsigned cseq, RTSPClient::responseHandler* rtspResponseHandler, char const* rtspURLToDeregister, char const* proxyURLSuffix);
+    virtual ~RequestRecord_DEREGISTER();
+
+    char const* rtspURLToDeregister() const { return fRTSPURLToRegisterOrDeregister; }
+  };
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/RTSPServer.hh b/3rdparty/live555/src/liveMedia/include/RTSPServer.hh
new file mode 100644
index 00000000..1c83da9d
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/RTSPServer.hh
@@ -0,0 +1,389 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A RTSP server
+// C++ header
+
+#ifndef _RTSP_SERVER_HH
+#define _RTSP_SERVER_HH
+
+#ifndef _GENERIC_MEDIA_SERVER_HH
+#include "GenericMediaServer.hh"
+#endif
+#ifndef _DIGEST_AUTHENTICATION_HH
+#include "DigestAuthentication.hh"
+#endif
+
+class RTSPServer: public GenericMediaServer {
+public:
+  static RTSPServer* createNew(UsageEnvironment& env, Port ourPort = 554,
+			       UserAuthenticationDatabase* authDatabase = NULL,
+			       unsigned reclamationSeconds = 65);
+      // If ourPort.num() == 0, we'll choose the port number
+      // Note: The caller is responsible for reclaiming "authDatabase"
+      // If "reclamationSeconds" > 0, then the "RTSPClientSession" state for
+      //     each client will get reclaimed (and the corresponding RTP stream(s)
+      //     torn down) if no RTSP commands - or RTCP "RR" packets - from the
+      //     client are received in at least "reclamationSeconds" seconds.
+
+  static Boolean lookupByName(UsageEnvironment& env, char const* name,
+			      RTSPServer*& resultServer);
+
+  typedef void (responseHandlerForREGISTER)(RTSPServer* rtspServer, unsigned requestId, int resultCode, char* resultString);
+  unsigned registerStream(ServerMediaSession* serverMediaSession,
+			  char const* remoteClientNameOrAddress, portNumBits remoteClientPortNum,
+			  responseHandlerForREGISTER* responseHandler,
+			  char const* username = NULL, char const* password = NULL,
+			  Boolean receiveOurStreamViaTCP = False,
+			  char const* proxyURLSuffix = NULL);
+  // 'Register' the stream represented by "serverMediaSession" with the given remote client (specifed by name and port number).
+  // This is done using our custom "REGISTER" RTSP command.
+  // The function returns a unique number that can be used to identify the request; this number is also passed to "responseHandler".
+  // When a response is received from the remote client (or the "REGISTER" request fails), the specified response handler
+  //   (if non-NULL) is called.  (Note that the "resultString" passed to the handler was dynamically allocated,
+  //   and should be delete[]d by the handler after use.)
+  // If "receiveOurStreamViaTCP" is True, then we're requesting that the remote client access our stream using RTP/RTCP-over-TCP.
+  //   (Otherwise, the remote client may choose regular RTP/RTCP-over-UDP streaming.)
+  // "proxyURLSuffix" (optional) is used only when the remote client is also a proxy server.
+  //   It tells the proxy server the suffix that it should use in its "rtsp://" URL (when front-end clients access the stream)
+
+  typedef void (responseHandlerForDEREGISTER)(RTSPServer* rtspServer, unsigned requestId, int resultCode, char* resultString);
+  unsigned deregisterStream(ServerMediaSession* serverMediaSession,
+			    char const* remoteClientNameOrAddress, portNumBits remoteClientPortNum,
+			    responseHandlerForDEREGISTER* responseHandler,
+			    char const* username = NULL, char const* password = NULL,
+			    char const* proxyURLSuffix = NULL);
+  // Used to turn off a previous "registerStream()" - using our custom "DEREGISTER" RTSP command.
+  
+  char* rtspURL(ServerMediaSession const* serverMediaSession,
+		int clientSocket = -1, Boolean useIPv6 = False) const;
+      // returns a "rtsp://" URL that could be used to access the
+      // specified session (which must already have been added to
+      // us using "addServerMediaSession()".
+      // This string is dynamically allocated; caller should delete[]
+      // (If "clientSocket" is non-negative, then it is used (by calling "getsockname()") to determine
+      //  the IP address to be used in the URL.)
+  // Shortcuts:
+  char* ipv4rtspURL(ServerMediaSession const* serverMediaSession, int clientSocket = -1) {
+    return rtspURL(serverMediaSession, clientSocket, False);
+  }
+  char* ipv6rtspURL(ServerMediaSession const* serverMediaSession, int clientSocket = -1) {
+    return rtspURL(serverMediaSession, clientSocket, True);
+  }
+
+  char* rtspURLPrefix(int clientSocket = -1, Boolean useIPv6 = False) const;
+      // like "rtspURL()", except that it returns just the common prefix used by
+      // each session's "rtsp://" URL.
+      // This string is dynamically allocated; caller should delete[]
+  // Shortcuts:
+  char* ipv4rtspURLPrefix(int clientSocket = -1) { return rtspURLPrefix(clientSocket, False); }
+  char* ipv6rtspURLPrefix(int clientSocket = -1) { return rtspURLPrefix(clientSocket, True); }
+
+  UserAuthenticationDatabase* setAuthenticationDatabase(UserAuthenticationDatabase* newDB);
+      // Changes the server's authentication database to "newDB", returning a pointer to the old database (if there was one).
+      // "newDB" may be NULL (you can use this to disable authentication at runtime, if desired).
+
+  void disableStreamingRTPOverTCP() {
+    fAllowStreamingRTPOverTCP = False;
+  }
+
+  Boolean setUpTunnelingOverHTTP(Port httpPort);
+      // (Attempts to) enable RTSP-over-HTTP tunneling on the specified port.
+      // Returns True iff the specified port can be used in this way (i.e., it's not already being used for a separate HTTP server).
+      // Note: RTSP-over-HTTP tunneling is described in
+      //  http://mirror.informatimago.com/next/developer.apple.com/quicktime/icefloe/dispatch028.html
+      //  and http://images.apple.com/br/quicktime/pdf/QTSS_Modules.pdf
+  portNumBits httpServerPortNum() const; // in host byte order.  (Returns 0 if not present.)
+
+  void setTLSState(char const* certFileName, char const* privKeyFileName,
+		   Boolean weServeSRTP = True, Boolean weEncryptSRTP = True);
+
+protected:
+  RTSPServer(UsageEnvironment& env,
+	     int ourSocketIPv4, int ourSocketIPv6, Port ourPort,
+	     UserAuthenticationDatabase* authDatabase,
+	     unsigned reclamationSeconds);
+      // called only by createNew();
+  virtual ~RTSPServer();
+
+  virtual char const* allowedCommandNames(); // used to implement "RTSPClientConnection::handleCmd_OPTIONS()"
+  virtual Boolean weImplementREGISTER(char const* cmd/*"REGISTER" or "DEREGISTER"*/,
+				      char const* proxyURLSuffix, char*& responseStr);
+      // used to implement "RTSPClientConnection::handleCmd_REGISTER()"
+      // Note: "responseStr" is dynamically allocated (or NULL), and should be delete[]d after the call
+  virtual void implementCmd_REGISTER(char const* cmd/*"REGISTER" or "DEREGISTER"*/,
+				     char const* url, char const* urlSuffix, int socketToRemoteServer,
+				     Boolean deliverViaTCP, char const* proxyURLSuffix);
+      // used to implement "RTSPClientConnection::handleCmd_REGISTER()"
+
+  virtual UserAuthenticationDatabase* getAuthenticationDatabaseForCommand(char const* cmdName);
+  virtual Boolean specialClientAccessCheck(int clientSocket, struct sockaddr_storage const& clientAddr,
+					   char const* urlSuffix);
+      // a hook that allows subclassed servers to do server-specific access checking
+      // on each client (e.g., based on client IP address), without using digest authentication.
+  virtual Boolean specialClientUserAccessCheck(int clientSocket, struct sockaddr_storage const& clientAddr,
+					       char const* urlSuffix, char const *username);
+      // another hook that allows subclassed servers to do server-specific access checking
+      // - this time after normal digest authentication has already taken place (and would otherwise allow access).
+      // (This test can only be used to further restrict access, not to grant additional access.)
+
+public: // redefined virtual functions
+  virtual Boolean isRTSPServer() const;
+  virtual void addServerMediaSession(ServerMediaSession* serverMediaSession);
+
+public: // should be protected, but some old compilers complain otherwise
+  // The state of a TCP connection used by a RTSP client:
+  class RTSPClientSession; // forward
+  class RTSPClientConnection: public GenericMediaServer::ClientConnection {
+  public:
+    // A data structure that's used to implement the "REGISTER" command:
+    class ParamsForREGISTER {
+    public:
+      ParamsForREGISTER(char const* cmd/*"REGISTER" or "DEREGISTER"*/,
+			RTSPClientConnection* ourConnection, char const* url, char const* urlSuffix,
+			Boolean reuseConnection, Boolean deliverViaTCP, char const* proxyURLSuffix);
+      virtual ~ParamsForREGISTER();
+    private:
+      friend class RTSPClientConnection;
+      char const* fCmd;
+      RTSPClientConnection* fOurConnection;
+      char* fURL;
+      char* fURLSuffix;
+      Boolean fReuseConnection, fDeliverViaTCP;
+      char* fProxyURLSuffix;
+    };
+  protected: // redefined virtual functions:
+    virtual void handleRequestBytes(int newBytesRead);
+
+  protected:
+    RTSPClientConnection(RTSPServer& ourServer,
+			 int clientSocket, struct sockaddr_storage const& clientAddr,
+			 Boolean useTLS = False);
+    virtual ~RTSPClientConnection();
+
+    friend class RTSPServer;
+    friend class RTSPClientSession;
+
+    // Make the handler functions for each command virtual, to allow subclasses to reimplement them, if necessary:
+    virtual void handleCmd_OPTIONS();
+        // You probably won't need to subclass/reimplement this function; reimplement "RTSPServer::allowedCommandNames()" instead.
+    virtual void handleCmd_GET_PARAMETER(char const* fullRequestStr); // when operating on the entire server
+    virtual void handleCmd_SET_PARAMETER(char const* fullRequestStr); // when operating on the entire server
+    virtual void handleCmd_DESCRIBE(char const* urlPreSuffix, char const* urlSuffix, char const* fullRequestStr);
+    static void DESCRIBELookupCompletionFunction(void* clientData, ServerMediaSession* sessionLookedUp);
+    virtual void handleCmd_DESCRIBE_afterLookup(ServerMediaSession* session);
+    virtual void handleCmd_REGISTER(char const* cmd/*"REGISTER" or "DEREGISTER"*/,
+				    char const* url, char const* urlSuffix, char const* fullRequestStr,
+				    Boolean reuseConnection, Boolean deliverViaTCP, char const* proxyURLSuffix);
+        // You probably won't need to subclass/reimplement this function;
+        //     reimplement "RTSPServer::weImplementREGISTER()" and "RTSPServer::implementCmd_REGISTER()" instead.
+    virtual void handleCmd_bad();
+    virtual void handleCmd_notSupported();
+    virtual void handleCmd_redirect(char const* urlSuffix);
+    virtual void handleCmd_notFound();
+    virtual void handleCmd_sessionNotFound();
+    virtual void handleCmd_unsupportedTransport();
+    // Support for optional RTSP-over-HTTP tunneling:
+    virtual Boolean parseHTTPRequestString(char* resultCmdName, unsigned resultCmdNameMaxSize,
+					   char* urlSuffix, unsigned urlSuffixMaxSize,
+					   char* sessionCookie, unsigned sessionCookieMaxSize,
+					   char* acceptStr, unsigned acceptStrMaxSize);
+    virtual void handleHTTPCmd_notSupported();
+    virtual void handleHTTPCmd_notFound();
+    virtual void handleHTTPCmd_OPTIONS();
+    virtual void handleHTTPCmd_TunnelingGET(char const* sessionCookie);
+    virtual Boolean handleHTTPCmd_TunnelingPOST(char const* sessionCookie, unsigned char const* extraData, unsigned extraDataSize);
+    virtual void handleHTTPCmd_StreamingGET(char const* urlSuffix, char const* fullRequestStr);
+  protected:
+    void resetRequestBuffer();
+    void closeSocketsRTSP();
+    static void handleAlternativeRequestByte(void*, u_int8_t requestByte);
+    void handleAlternativeRequestByte1(u_int8_t requestByte);
+    Boolean authenticationOK(char const* cmdName, char const* urlSuffix, char const* fullRequestStr);
+    void changeClientInputSocket(int newSocketNum, unsigned char const* extraData, unsigned extraDataSize);
+      // used to implement RTSP-over-HTTP tunneling
+    static void continueHandlingREGISTER(ParamsForREGISTER* params);
+    virtual void continueHandlingREGISTER1(ParamsForREGISTER* params);
+
+    // Shortcuts for setting up a RTSP response (prior to sending it):
+    void setRTSPResponse(char const* responseStr);
+    void setRTSPResponse(char const* responseStr, u_int32_t sessionId);
+    void setRTSPResponse(char const* responseStr, char const* contentStr);
+    void setRTSPResponse(char const* responseStr, u_int32_t sessionId, char const* contentStr);
+
+    RTSPServer& fOurRTSPServer; // same as ::fOurServer
+    int& fClientInputSocket; // aliased to ::fOurSocket
+    int fClientOutputSocket;
+    int fAddressFamily;
+    Boolean fIsActive;
+    unsigned char* fLastCRLF;
+    unsigned fRecursionCount;
+    char const* fCurrentCSeq;
+    Authenticator fCurrentAuthenticator; // used if access control is needed
+    char* fOurSessionCookie; // used for optional RTSP-over-HTTP tunneling
+    unsigned fBase64RemainderCount; // used for optional RTSP-over-HTTP tunneling (possible values: 0,1,2,3)
+    unsigned fScheduledDelayedTask;
+  };
+
+  // The state of an individual client session (using one or more sequential TCP connections) handled by a RTSP server:
+  class RTSPClientSession: public GenericMediaServer::ClientSession {
+  protected:
+    RTSPClientSession(RTSPServer& ourServer, u_int32_t sessionId);
+    virtual ~RTSPClientSession();
+
+    friend class RTSPServer;
+    friend class RTSPClientConnection;
+    // Make the handler functions for each command virtual, to allow subclasses to redefine them:
+    virtual void handleCmd_SETUP(RTSPClientConnection* ourClientConnection,
+				 char const* urlPreSuffix, char const* urlSuffix, char const* fullRequestStr);
+    static void SETUPLookupCompletionFunction1(void* clientData, ServerMediaSession* sessionLookedUp);
+    virtual void handleCmd_SETUP_afterLookup1(ServerMediaSession* sms);
+    static void SETUPLookupCompletionFunction2(void* clientData, ServerMediaSession* sessionLookedUp);
+    virtual void handleCmd_SETUP_afterLookup2(ServerMediaSession* sms);
+    virtual void handleCmd_withinSession(RTSPClientConnection* ourClientConnection,
+					 char const* cmdName,
+					 char const* urlPreSuffix, char const* urlSuffix,
+					 char const* fullRequestStr);
+    virtual void handleCmd_TEARDOWN(RTSPClientConnection* ourClientConnection,
+				    ServerMediaSubsession* subsession);
+    virtual void handleCmd_PLAY(RTSPClientConnection* ourClientConnection,
+				ServerMediaSubsession* subsession, char const* fullRequestStr);
+    virtual void handleCmd_PAUSE(RTSPClientConnection* ourClientConnection,
+				 ServerMediaSubsession* subsession);
+    virtual void handleCmd_GET_PARAMETER(RTSPClientConnection* ourClientConnection,
+					 ServerMediaSubsession* subsession, char const* fullRequestStr);
+    virtual void handleCmd_SET_PARAMETER(RTSPClientConnection* ourClientConnection,
+					 ServerMediaSubsession* subsession, char const* fullRequestStr);
+  protected:
+    void deleteStreamByTrack(unsigned trackNum);
+    void reclaimStreamStates();
+    Boolean isMulticast() const { return fIsMulticast; }
+
+    // Shortcuts for setting up a RTSP response (prior to sending it):
+    void setRTSPResponse(RTSPClientConnection* ourClientConnection, char const* responseStr) { ourClientConnection->setRTSPResponse(responseStr); }
+    void setRTSPResponse(RTSPClientConnection* ourClientConnection, char const* responseStr, u_int32_t sessionId) { ourClientConnection->setRTSPResponse(responseStr, sessionId); }
+    void setRTSPResponse(RTSPClientConnection* ourClientConnection, char const* responseStr, char const* contentStr) { ourClientConnection->setRTSPResponse(responseStr, contentStr); }
+    void setRTSPResponse(RTSPClientConnection* ourClientConnection, char const* responseStr, u_int32_t sessionId, char const* contentStr) { ourClientConnection->setRTSPResponse(responseStr, sessionId, contentStr); }
+
+  protected:
+    RTSPServer& fOurRTSPServer; // same as ::fOurServer
+    Boolean fIsMulticast, fStreamAfterSETUP;
+    unsigned char fTCPStreamIdCount; // used for (optional) RTP/TCP
+    Boolean usesTCPTransport() const { return fTCPStreamIdCount > 0; }
+    unsigned fNumStreamStates;
+    struct streamState {
+      ServerMediaSubsession* subsession;
+      int tcpSocketNum;
+      void* streamToken;
+    } * fStreamStates;
+
+    // Member variables used to implement "handleCmd_SETUP()":
+    RTSPServer::RTSPClientConnection* fOurClientConnection;
+    char const* fURLPreSuffix; char const* fURLSuffix; char const* fFullRequestStr; char const* fTrackId;
+  };
+
+protected: // redefined virtual functions
+  // If you subclass "RTSPClientConnection", then you must also redefine this virtual function in order
+  // to create new objects of your subclass:
+  virtual ClientConnection* createNewClientConnection(int clientSocket, struct sockaddr_storage const& clientAddr);
+
+protected:
+  // If you subclass "RTSPClientSession", then you must also redefine this virtual function in order
+  // to create new objects of your subclass:
+  virtual ClientSession* createNewClientSession(u_int32_t sessionId);
+
+private:
+  static void incomingConnectionHandlerHTTPIPv4(void*, int /*mask*/);
+  void incomingConnectionHandlerHTTPIPv4();
+  static void incomingConnectionHandlerHTTPIPv6(void*, int /*mask*/);
+  void incomingConnectionHandlerHTTPIPv6();
+
+  void noteTCPStreamingOnSocket(int socketNum, RTSPClientSession* clientSession, unsigned trackNum);
+  void unnoteTCPStreamingOnSocket(int socketNum, RTSPClientSession* clientSession, unsigned trackNum);
+  void stopTCPStreamingOnSocket(int socketNum);
+
+private:
+  friend class RTSPClientConnection;
+  friend class RTSPClientSession;
+  friend class RegisterRequestRecord;
+  friend class DeregisterRequestRecord;
+  int fHTTPServerSocketIPv4, fHTTPServerSocketIPv6; // for optional RTSP-over-HTTP tunneling
+  Port fHTTPServerPort; // ditto
+  HashTable* fClientConnectionsForHTTPTunneling; // maps client-supplied 'session cookie' strings to "RTSPClientConnection"s
+    // (used only for optional RTSP-over-HTTP tunneling)
+  HashTable* fTCPStreamingDatabase;
+    // maps TCP socket numbers to ids of sessions that are streaming over it (RTP/RTCP-over-TCP)
+  HashTable* fPendingRegisterOrDeregisterRequests;
+  unsigned fRegisterOrDeregisterRequestCounter;
+  UserAuthenticationDatabase* fAuthDB;
+  Boolean fAllowStreamingRTPOverTCP; // by default, True
+  Boolean fOurConnectionsUseTLS; // by default, False
+  Boolean fWeServeSRTP; // used only if "fOurConnectionsUseTLS" is True
+  Boolean fWeEncryptSRTP; // used only if "fWeServeSRTP" is True
+};
+
+
+////////// A subclass of "RTSPServer" that implements the "REGISTER" command to set up proxying on the specified URL //////////
+
+class RTSPServerWithREGISTERProxying: public RTSPServer {
+public:
+  static RTSPServerWithREGISTERProxying* createNew(UsageEnvironment& env, Port ourPort = 554,
+						   UserAuthenticationDatabase* authDatabase = NULL,
+						   UserAuthenticationDatabase* authDatabaseForREGISTER = NULL,
+						   unsigned reclamationSeconds = 65,
+						   Boolean streamRTPOverTCP = False,
+						   int verbosityLevelForProxying = 0,
+						   char const* backEndUsername = NULL,
+						   char const* backEndPassword = NULL);
+
+protected:
+  RTSPServerWithREGISTERProxying(UsageEnvironment& env, int ourSocketIPv4, int ourSocketIPv6, Port ourPort,
+				 UserAuthenticationDatabase* authDatabase, UserAuthenticationDatabase* authDatabaseForREGISTER,
+				 unsigned reclamationSeconds,
+				 Boolean streamRTPOverTCP, int verbosityLevelForProxying,
+				 char const* backEndUsername, char const* backEndPassword);
+  // called only by createNew();
+  virtual ~RTSPServerWithREGISTERProxying();
+
+protected: // redefined virtual functions
+  virtual char const* allowedCommandNames();
+  virtual Boolean weImplementREGISTER(char const* cmd/*"REGISTER" or "DEREGISTER"*/,
+				      char const* proxyURLSuffix, char*& responseStr);
+  virtual void implementCmd_REGISTER(char const* cmd/*"REGISTER" or "DEREGISTER"*/,
+				     char const* url, char const* urlSuffix, int socketToRemoteServer,
+				     Boolean deliverViaTCP, char const* proxyURLSuffix);
+  virtual UserAuthenticationDatabase* getAuthenticationDatabaseForCommand(char const* cmdName);
+
+private:
+  Boolean fStreamRTPOverTCP;
+  int fVerbosityLevelForProxying;
+  unsigned fRegisteredProxyCounter;
+  char* fAllowedCommandNames;
+  UserAuthenticationDatabase* fAuthDBForREGISTER;
+  char* fBackEndUsername;
+  char* fBackEndPassword;
+}; 
+
+
+// A special version of "parseTransportHeader()", used just for parsing the "Transport:" header
+// in an incoming "REGISTER" command:
+void parseTransportHeaderForREGISTER(char const* buf, // in
+				     Boolean &reuseConnection, // out
+				     Boolean& deliverViaTCP, // out
+				     char*& proxyURLSuffix); // out
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/RawVideoFrameParameters.hh b/3rdparty/live555/src/liveMedia/include/RawVideoFrameParameters.hh
new file mode 100644
index 00000000..da566599
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/RawVideoFrameParameters.hh
@@ -0,0 +1,37 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// Parameters used for streaming (transmitting and receiving) raw video frames over RTP
+// C++ header
+
+#ifndef _RAW_VIDEO_FRAME_PARAMETERS_HH
+#define _RAW_VIDEO_FRAME_PARAMETERS_HH
+
+class RawVideoFrameParameters {
+public:
+  RawVideoFrameParameters(unsigned width, unsigned height, unsigned depth, char const* sampling);
+  virtual ~RawVideoFrameParameters();
+
+public:
+  u_int16_t pgroupSize; // in octets
+  u_int16_t numPixelsInPgroup;
+  u_int32_t scanLineSize; // in octets
+  u_int32_t frameSize; // in octets
+  u_int16_t scanLineIterationStep; // usually 1, but 2 for sampling=="YCbCr-4:2:0"
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/RawVideoRTPSink.hh b/3rdparty/live555/src/liveMedia/include/RawVideoRTPSink.hh
new file mode 100644
index 00000000..f11f2a79
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/RawVideoRTPSink.hh
@@ -0,0 +1,71 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// RTP sink for Raw video
+// C++ header
+
+#ifndef _RAW_VIDEO_RTP_SINK_HH
+#define _RAW_VIDEO_RTP_SINK_HH
+
+#ifndef _VIDEO_RTP_SINK_HH
+#include "VideoRTPSink.hh"
+#endif
+
+#ifndef _RAW_VIDEO_FRAME_PARAMETERS_HH
+#include "RawVideoFrameParameters.hh"
+#endif
+
+class RawVideoRTPSink: public VideoRTPSink {
+public:
+  static RawVideoRTPSink*
+  createNew(UsageEnvironment& env, Groupsock* RTPgs, u_int8_t rtpPayloadFormat,
+	    unsigned width, unsigned height, unsigned depth, // as defined by RFC 4175, sec 6.1
+	    char const* sampling, char const* colorimetry);
+
+protected:
+  RawVideoRTPSink(UsageEnvironment& env, Groupsock* RTPgs,
+                  u_int8_t rtpPayloadFormat,
+                  unsigned width, unsigned height, unsigned depth,
+                  char const* sampling, char const* colorimetry);
+  // called only by createNew()
+  
+  virtual ~RawVideoRTPSink();
+  
+private: // redefined virtual functions:
+  virtual char const* auxSDPLine(); // for the "a=fmtp:" SDP line
+  
+  virtual void doSpecialFrameHandling(unsigned fragmentationOffset,
+                      unsigned char* frameStart,
+                      unsigned numBytesInFrame,
+                      struct timeval framePresentationTime,
+                      unsigned numRemainingBytes);
+  virtual Boolean frameCanAppearAfterPacketStart(unsigned char const* frameStart,
+                         unsigned numBytesInFrame) const;
+  virtual unsigned specialHeaderSize() const;
+  virtual unsigned computeOverflowForNewFrame(unsigned newFrameSize) const;
+  
+private:
+  char* fFmtpSDPLine;
+  unsigned fLineIndex;
+  RawVideoFrameParameters fP;
+
+  unsigned getNumLinesInPacket(unsigned fragOffset, u_int16_t*& lengths, u_int16_t*& offsets) const;
+  //  return the number of lines, their lengths and offsets from the fragmentation offset of the whole frame.
+  // call delete[] on lengths and offsets after use of the function
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/RawVideoRTPSource.hh b/3rdparty/live555/src/liveMedia/include/RawVideoRTPSource.hh
new file mode 100644
index 00000000..76002044
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/RawVideoRTPSource.hh
@@ -0,0 +1,60 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// Raw Video RTP Sources (RFC 4175)
+// C++ header
+
+#ifndef _RAW_VIDEO_RTP_SOURCE_HH
+#define _RAW_VIDEO_RTP_SOURCE_HH
+
+#ifndef _MULTI_FRAMED_RTP_SOURCE_HH
+#include "MultiFramedRTPSource.hh"
+#endif
+
+class RawVideoRTPSource: public MultiFramedRTPSource {
+public:
+  static RawVideoRTPSource* createNew(UsageEnvironment& env, Groupsock* RTPgs,
+				      unsigned char rtpPayloadFormat,
+				      unsigned rtpTimestampFrequency);
+
+  u_int16_t currentLineNumber() const; // of the most recently-read/processed scan line
+  u_int8_t currentLineFieldId() const; // of the most recently-read/processed scan line (0 or 1)
+  u_int16_t currentOffsetWithinLine() const; // of the most recently-read/processed scan line
+
+protected:
+  RawVideoRTPSource(UsageEnvironment& env, Groupsock* RTPgs,
+		    unsigned char rtpPayloadFormat,
+                    unsigned rtpTimestampFrequency = 90000);
+      // called only by createNew()
+
+  virtual ~RawVideoRTPSource();
+
+protected:
+  // redefined virtual functions:
+  virtual Boolean processSpecialHeader(BufferedPacket* packet,
+                                       unsigned& resultSpecialHeaderSize);
+  virtual char const* MIMEtype() const;
+
+private:
+  unsigned fNumLines; // in the most recently read packet
+  unsigned fNextLine; // index of the next AU Header to read
+  struct LineHeader* fLineHeaders;
+
+  friend class RawVideoBufferedPacket;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/SIPClient.hh b/3rdparty/live555/src/liveMedia/include/SIPClient.hh
new file mode 100644
index 00000000..6a8c8f90
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/SIPClient.hh
@@ -0,0 +1,150 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A generic SIP client
+// C++ header
+
+#ifndef _SIP_CLIENT_HH
+#define _SIP_CLIENT_HH
+
+#ifndef _MEDIA_SESSION_HH
+#include "MediaSession.hh"
+#endif
+#ifndef _NET_ADDRESS_HH
+#include "NetAddress.hh"
+#endif
+#ifndef _DIGEST_AUTHENTICATION_HH
+#include "DigestAuthentication.hh"
+#endif
+
+// Possible states in the "INVITE" transition diagram (RFC 3261, Figure 5)
+enum inviteClientState { Calling, Proceeding, Completed, Terminated };
+
+class SIPClient: public Medium {
+public:
+  static SIPClient* createNew(UsageEnvironment& env,
+			      unsigned char desiredAudioRTPPayloadFormat,
+			      char const* mimeSubtype = NULL,
+			      int verbosityLevel = 0,
+			      char const* applicationName = NULL);
+
+  void setProxyServer(struct sockaddr_storage const& proxyServerAddress,
+		      portNumBits proxyServerPortNum);
+
+  void setClientStartPortNum(portNumBits clientStartPortNum) {
+    fClientStartPortNum = clientStartPortNum;
+  }
+
+  char* invite(char const* url, Authenticator* authenticator = NULL);
+      // Issues a SIP "INVITE" command
+      // Returns the session SDP description if this command succeeds
+  char* inviteWithPassword(char const* url,
+			   char const* username, char const* password);
+      // Uses "invite()" to do an "INVITE" - first
+      // without using "password", then (if we get an Unauthorized
+      // response) with an authentication response computed from "password"
+
+  Boolean sendACK(); // on current call
+  Boolean sendBYE(); // on current call
+
+  static Boolean parseSIPURL(UsageEnvironment& env, char const* url,
+			     NetAddress& address, portNumBits& portNum);
+      // (ignores any "<username>[:<password>]@" in "url")
+  static Boolean parseSIPURLUsernamePassword(char const* url,
+					     char*& username,
+					     char*& password);
+  char const* getInviteSdpReply() const { return fInviteSDPDescriptionReturned; }
+
+  void setUserAgentString(char const* userAgentName);
+       // sets an alternative string to be used in SIP "User-Agent:" headers
+
+protected:
+  virtual ~SIPClient();
+
+private:
+  SIPClient(UsageEnvironment& env,
+	    unsigned char desiredAudioRTPPayloadFormat,
+	    char const* mimeSubtype,
+	    int verbosityLevel,
+	    char const* applicationName);
+      // called only by createNew();
+
+  void reset();
+
+  // Routines used to implement invite*():
+  char* invite1(Authenticator* authenticator);
+  Boolean processURL(char const* url);
+  Boolean sendINVITE();
+  static void inviteResponseHandler(void* clientData, int mask);
+  void doInviteStateMachine(unsigned responseCode);
+  void doInviteStateTerminated(unsigned responseCode);
+  TaskToken fTimerA, fTimerB, fTimerD;
+  static void timerAHandler(void* clientData);
+  static void timerBHandler(void* clientData);
+  static void timerDHandler(void* clientData);
+  unsigned const fT1; // in microseconds
+  unsigned fTimerALen; // in microseconds; initially fT1, then doubles
+  unsigned fTimerACount;
+
+  // Routines used to implement all commands:
+  char* createAuthenticatorString(Authenticator const* authenticator,
+				  char const* cmd, char const* url);
+  Boolean sendRequest(char const* requestString, unsigned requestLength);
+  unsigned getResponseCode();
+  unsigned getResponse(char*& responseBuffer, unsigned responseBufferSize);
+  Boolean parseResponseCode(char const* line, unsigned& responseCode);
+
+private:
+  // Set for all calls:
+  unsigned char fDesiredAudioRTPPayloadFormat;
+  char* fMIMESubtype;
+  unsigned fMIMESubtypeSize;
+  int fVerbosityLevel;
+  unsigned fCSeq; // sequence number, used in consecutive requests
+  char const* fApplicationName;
+  unsigned fApplicationNameSize;
+  char const* fOurAddressStr;
+  unsigned fOurAddressStrSize;
+  portNumBits fOurPortNum;
+  Groupsock* fOurSocket;
+  char* fUserAgentHeaderStr;
+  unsigned fUserAgentHeaderStrLen;
+
+  // Set for each call:
+  char const* fURL;
+  unsigned fURLSize;
+  struct sockaddr_storage fServerAddress;
+  Boolean fServerAddressIsSet;
+  portNumBits fServerPortNum; // in host order
+  portNumBits fClientStartPortNum; // in host order
+  unsigned fCallId, fFromTag; // set by us
+  char const* fToTagStr; // set by the responder
+  unsigned fToTagStrSize;
+  Authenticator fValidAuthenticator;
+  char const* fUserName; // 'user' name used in "From:" & "Contact:" lines
+  unsigned fUserNameSize;
+
+  char* fInviteSDPDescription;
+  char* fInviteSDPDescriptionReturned;
+  char* fInviteCmd;
+  unsigned fInviteCmdSize;
+  Authenticator* fWorkingAuthenticator;
+  inviteClientState fInviteClientState;
+  char fEventLoopStopFlag;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/SRTPCryptographicContext.hh b/3rdparty/live555/src/liveMedia/include/SRTPCryptographicContext.hh
new file mode 100644
index 00000000..97ca8f63
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/SRTPCryptographicContext.hh
@@ -0,0 +1,152 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// The SRTP 'Cryptographic Context', used in all of our uses of SRTP.
+// Definition
+
+#ifndef _SRTP_CRYPTOGRAPHIC_CONTEXT_HH
+#define _SRTP_CRYPTOGRAPHIC_CONTEXT_HH
+
+#ifndef _MIKEY_HH
+#include "MIKEY.hh"
+#endif
+
+class SRTPCryptographicContext {
+public:
+  SRTPCryptographicContext(MIKEYState const& mikeyState);
+  virtual ~SRTPCryptographicContext();
+
+  // Authenticate (if necessary) and decrypt (if necessary) incoming SRTP and SRTCP packets.
+  // Returns True iff the packet is well-formed and authenticates OK.
+  // ("outPacketSize" will be <= "inPacketSize".)
+  Boolean processIncomingSRTPPacket(u_int8_t* buffer, unsigned inPacketSize,
+				    unsigned& outPacketSize);
+  Boolean processIncomingSRTCPPacket(u_int8_t* buffer, unsigned inPacketSize,
+				     unsigned& outPacketSize);
+
+  // Encrypt (if necessary) and add an authentication tag (if necessary) to an outgoing
+  // RTP and RTCP packet.
+  // Returns True iff the packet is well-formed.
+  // ("outPacketSize" will be >= "inPacketSize"; there must be enough space at the end of
+  //  "buffer" for the extra (4+10 bytes for SRTP; 4+4+10 bytes for SRTCP).)
+  Boolean processOutgoingSRTPPacket(u_int8_t* buffer, unsigned inPacketSize,
+				    unsigned& outPacketSize);
+  Boolean processOutgoingSRTCPPacket(u_int8_t* buffer, unsigned inPacketSize,
+				     unsigned& outPacketSize);
+
+#ifndef NO_OPENSSL
+private:
+  // Definitions specific to the "SRTP_AES128_CM_HMAC_SHA1_80" ciphersuite.
+  // Later generalize to support more SRTP ciphersuites #####
+#define SRTP_CIPHER_KEY_LENGTH (128/8) // in bytes
+#define SRTP_CIPHER_SALT_LENGTH (112/8) // in bytes
+#define SRTP_MKI_LENGTH 4 // in bytes
+#define SRTP_AUTH_KEY_LENGTH (160/8) // in bytes
+#define SRTP_AUTH_TAG_LENGTH (80/8) // in bytes
+
+  struct derivedKeys {
+    u_int8_t cipherKey[SRTP_CIPHER_KEY_LENGTH];
+    u_int8_t salt[SRTP_CIPHER_SALT_LENGTH];
+    u_int8_t authKey[SRTP_AUTH_KEY_LENGTH];
+  };
+
+  struct allDerivedKeys {
+    derivedKeys srtp;
+    derivedKeys srtcp;
+  };
+
+  typedef enum {
+		label_srtp_encryption  = 0x00,
+		label_srtp_msg_auth    = 0x01,
+		label_srtp_salt        = 0x02,
+		label_srtcp_encryption = 0x03,
+		label_srtcp_msg_auth   = 0x04,
+		label_srtcp_salt       = 0x05
+  } SRTPKeyDerivationLabel;
+
+  unsigned generateSRTPAuthenticationTag(u_int8_t const* dataToAuthenticate, unsigned numBytesToAuthenticate,
+					 u_int8_t* resultAuthenticationTag);
+      // returns the size of the resulting authentication tag
+  unsigned generateSRTCPAuthenticationTag(u_int8_t const* dataToAuthenticate, unsigned numBytesToAuthenticate,
+					  u_int8_t* resultAuthenticationTag);
+      // returns the size of the resulting authentication tag
+
+  Boolean verifySRTPAuthenticationTag(u_int8_t* dataToAuthenticate, unsigned numBytesToAuthenticate,
+				      u_int32_t roc, u_int8_t const* authenticationTag);
+  Boolean verifySRTCPAuthenticationTag(u_int8_t const* dataToAuthenticate, unsigned numBytesToAuthenticate,
+				       u_int8_t const* authenticationTag);
+
+  void decryptSRTPPacket(u_int64_t index, u_int32_t ssrc, u_int8_t* data, unsigned numDataBytes);
+  void decryptSRTCPPacket(u_int32_t index, u_int32_t ssrc, u_int8_t* data, unsigned numDataBytes);
+
+  void encryptSRTPPacket(u_int64_t index, u_int32_t ssrc, u_int8_t* data, unsigned numDataBytes);
+  void encryptSRTCPPacket(u_int32_t index, u_int32_t ssrc, u_int8_t* data, unsigned numDataBytes);
+
+  unsigned generateAuthenticationTag(derivedKeys& keysToUse,
+				     u_int8_t const* dataToAuthenticate, unsigned numBytesToAuthenticate,
+				     u_int8_t* resultAuthenticationTag);
+      // returns the size of the resulting authentication tag
+      // "resultAuthenticationTag" must point to an array of at least SRTP_AUTH_TAG_LENGTH
+  Boolean verifyAuthenticationTag(derivedKeys& keysToUse,
+				  u_int8_t const* dataToAuthenticate, unsigned numBytesToAuthenticate,
+				  u_int8_t const* authenticationTag);
+
+  void cryptData(derivedKeys& keys, u_int64_t index, u_int32_t ssrc,
+		 u_int8_t* data, unsigned numDataBytes);
+
+  void performKeyDerivation();
+
+  void deriveKeysFromMaster(u_int8_t const* masterKey, u_int8_t const* salt,
+			    allDerivedKeys& allKeysResult);
+      // used to implement "performKeyDerivation()"
+  void deriveSingleKey(u_int8_t const* masterKey, u_int8_t const* salt,
+		       SRTPKeyDerivationLabel label,
+		       unsigned resultKeyLength, u_int8_t* resultKey);
+      // used to implement "deriveKeysFromMaster()".
+      // ("resultKey" must be an existing buffer, of size >= "resultKeyLength")
+
+private:
+  MIKEYState const& fMIKEYState;
+
+  // Master key + salt:
+  u_int8_t const* masterKeyPlusSalt() const { return fMIKEYState.keyData(); }
+
+  u_int8_t const* masterKey() const { return &masterKeyPlusSalt()[0]; }
+  u_int8_t const* masterSalt() const { return &masterKeyPlusSalt()[SRTP_CIPHER_KEY_LENGTH]; }
+
+  Boolean weEncryptSRTP() const { return fMIKEYState.encryptSRTP(); }
+  Boolean weEncryptSRTCP() const { return fMIKEYState.encryptSRTCP(); }
+  Boolean weAuthenticate() const { return fMIKEYState.useAuthentication(); }
+  u_int32_t MKI() const { return fMIKEYState.MKI(); }
+
+  // Derived (i.e., session) keys:
+  allDerivedKeys fDerivedKeys;
+
+  // State used for handling the reception of SRTP packets:
+  Boolean fHaveReceivedSRTPPackets;
+  u_int16_t fPreviousHighRTPSeqNum;
+  u_int32_t fReceptionROC; // rollover counter
+
+  // State used for handling the sending of SRTP packets:
+  Boolean fHaveSentSRTPPackets;
+  u_int32_t fSendingROC;
+
+  // State used for handling the sending of SRTCP packets:
+  u_int32_t fSRTCPIndex;
+#endif
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/ServerMediaSession.hh b/3rdparty/live555/src/liveMedia/include/ServerMediaSession.hh
new file mode 100644
index 00000000..942d8c93
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/ServerMediaSession.hh
@@ -0,0 +1,200 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A data structure that represents a session that consists of
+// potentially multiple (audio and/or video) sub-sessions
+// (This data structure is used for media *streamers* - i.e., servers.
+//  For media receivers, use "MediaSession" instead.)
+// C++ header
+
+#ifndef _SERVER_MEDIA_SESSION_HH
+#define _SERVER_MEDIA_SESSION_HH
+
+#ifndef _RTCP_HH
+#include "RTCP.hh"
+#endif
+
+class ServerMediaSubsession; // forward
+
+class ServerMediaSession: public Medium {
+public:
+  static ServerMediaSession* createNew(UsageEnvironment& env,
+				       char const* streamName = NULL,
+				       char const* info = NULL,
+				       char const* description = NULL,
+				       Boolean isSSM = False,
+				       char const* miscSDPLines = NULL);
+
+  static Boolean lookupByName(UsageEnvironment& env,
+                              char const* mediumName,
+                              ServerMediaSession*& resultSession);
+
+  char* generateSDPDescription(int addressFamily); // based on the entire session
+      // Note: The caller is responsible for freeing the returned string
+
+  char const* streamName() const { return fStreamName; }
+
+  Boolean addSubsession(ServerMediaSubsession* subsession);
+  unsigned numSubsessions() const { return fSubsessionCounter; }
+
+  void testScaleFactor(float& scale); // sets "scale" to the actual supported scale
+  float duration() const;
+    // a result == 0 means an unbounded session (the default)
+    // a result < 0 means: subsession durations differ; the result is -(the largest).
+    // a result > 0 means: this is the duration of a bounded session
+
+  virtual void noteLiveness();
+    // called whenever a client - accessing this media - notes liveness.
+    // The default implementation does nothing, but subclasses can redefine this - e.g., if you
+    // want to remove long-unused "ServerMediaSession"s from the server.
+
+  unsigned referenceCount() const { return fReferenceCount; }
+  void incrementReferenceCount() { ++fReferenceCount; }
+  void decrementReferenceCount() { if (fReferenceCount > 0) --fReferenceCount; }
+  Boolean& deleteWhenUnreferenced() { return fDeleteWhenUnreferenced; }
+
+  void deleteAllSubsessions();
+    // Removes and deletes all subsessions added by "addSubsession()", returning us to an 'empty' state
+    // Note: If you have already added this "ServerMediaSession" to a "RTSPServer" then, before calling this function,
+    //   you must first close any client connections that use it,
+    //   by calling "RTSPServer::closeAllClientSessionsForServerMediaSession()".
+
+  Boolean streamingUsesSRTP; // by default, False
+  Boolean streamingIsEncrypted; // by default, False
+
+protected:
+  ServerMediaSession(UsageEnvironment& env, char const* streamName,
+		     char const* info, char const* description,
+		     Boolean isSSM, char const* miscSDPLines);
+  // called only by "createNew()"
+
+  virtual ~ServerMediaSession();
+
+private: // redefined virtual functions
+  virtual Boolean isServerMediaSession() const;
+
+private:
+  Boolean fIsSSM;
+
+  // Linkage fields:
+  friend class ServerMediaSubsessionIterator;
+  ServerMediaSubsession* fSubsessionsHead;
+  ServerMediaSubsession* fSubsessionsTail;
+  unsigned fSubsessionCounter;
+
+  char* fStreamName;
+  char* fInfoSDPString;
+  char* fDescriptionSDPString;
+  char* fMiscSDPLines;
+  struct timeval fCreationTime;
+  unsigned fReferenceCount;
+  Boolean fDeleteWhenUnreferenced;
+};
+
+
+class ServerMediaSubsessionIterator {
+public:
+  ServerMediaSubsessionIterator(ServerMediaSession& session);
+  virtual ~ServerMediaSubsessionIterator();
+
+  ServerMediaSubsession* next(); // NULL if none
+  void reset();
+
+private:
+  ServerMediaSession& fOurSession;
+  ServerMediaSubsession* fNextPtr;
+};
+
+
+class ServerMediaSubsession: public Medium {
+public:
+  unsigned trackNumber() const { return fTrackNumber; }
+  char const* trackId();
+  virtual char const* sdpLines(int addressFamily) = 0;
+  virtual void getStreamParameters(unsigned clientSessionId, // in
+				   struct sockaddr_storage const& clientAddress, // in
+				   Port const& clientRTPPort, // in
+				   Port const& clientRTCPPort, // in
+				   int tcpSocketNum, // in (-1 means use UDP, not TCP)
+				   unsigned char rtpChannelId, // in (used if TCP)
+				   unsigned char rtcpChannelId, // in (used if TCP)
+				   TLSState* tlsState, // in (used if TCP)
+				   struct sockaddr_storage& destinationAddress, // in out
+				   u_int8_t& destinationTTL, // in out
+				   Boolean& isMulticast, // out
+				   Port& serverRTPPort, // out
+				   Port& serverRTCPPort, // out
+				   void*& streamToken // out
+				   ) = 0;
+  virtual void startStream(unsigned clientSessionId, void* streamToken,
+			   TaskFunc* rtcpRRHandler,
+			   void* rtcpRRHandlerClientData,
+			   unsigned short& rtpSeqNum,
+			   unsigned& rtpTimestamp,
+			   ServerRequestAlternativeByteHandler* serverRequestAlternativeByteHandler,
+			   void* serverRequestAlternativeByteHandlerClientData) = 0;
+  virtual void pauseStream(unsigned clientSessionId, void* streamToken);
+  virtual void seekStream(unsigned clientSessionId, void* streamToken, double& seekNPT,
+			  double streamDuration, u_int64_t& numBytes);
+     // This routine is used to seek by relative (i.e., NPT) time.
+     // "streamDuration", if >0.0, specifies how much data to stream, past "seekNPT".  (If <=0.0, all remaining data is streamed.)
+     // "numBytes" returns the size (in bytes) of the data to be streamed, or 0 if unknown or unlimited.
+  virtual void seekStream(unsigned clientSessionId, void* streamToken, char*& absStart, char*& absEnd);
+     // This routine is used to seek by 'absolute' time.
+     // "absStart" should be a string of the form "YYYYMMDDTHHMMSSZ" or "YYYYMMDDTHHMMSS.<frac>Z".
+     // "absEnd" should be either NULL (for no end time), or a string of the same form as "absStart".
+     // These strings may be modified in-place, or can be reassigned to a newly-allocated value (after delete[]ing the original).
+  virtual void nullSeekStream(unsigned clientSessionId, void* streamToken,
+			      double streamEndTime, u_int64_t& numBytes);
+     // Called whenever we're handling a "PLAY" command without a specified start time.
+  virtual void setStreamScale(unsigned clientSessionId, void* streamToken, float scale);
+  virtual float getCurrentNPT(void* streamToken);
+  virtual FramedSource* getStreamSource(void* streamToken);
+  virtual void getRTPSinkandRTCP(void* streamToken,
+				 RTPSink const*& rtpSink, RTCPInstance const*& rtcp) = 0;
+     // Returns pointers to the "RTPSink" and "RTCPInstance" objects for "streamToken".
+     // (This can be useful if you want to get the associated 'Groupsock' objects, for example.)
+     // You must not delete these objects, or start/stop playing them; instead, that is done
+     // using the "startStream()" and "deleteStream()" functions.
+  virtual void deleteStream(unsigned clientSessionId, void*& streamToken);
+
+  virtual void testScaleFactor(float& scale); // sets "scale" to the actual supported scale
+  virtual float duration() const;
+    // returns 0 for an unbounded session (the default)
+    // returns > 0 for a bounded session
+  virtual void getAbsoluteTimeRange(char*& absStartTime, char*& absEndTime) const;
+    // Subclasses can reimplement this iff they support seeking by 'absolute' time.
+
+protected: // we're a virtual base class
+  ServerMediaSubsession(UsageEnvironment& env);
+  virtual ~ServerMediaSubsession();
+
+  char const* rangeSDPLine() const;
+      // returns a string to be delete[]d
+
+  ServerMediaSession* fParentSession;
+
+private:
+  friend class ServerMediaSession;
+  friend class ServerMediaSubsessionIterator;
+  ServerMediaSubsession* fNext;
+
+  unsigned fTrackNumber; // within an enclosing ServerMediaSession
+  char const* fTrackId;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/SimpleRTPSink.hh b/3rdparty/live555/src/liveMedia/include/SimpleRTPSink.hh
new file mode 100644
index 00000000..c01e8144
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/SimpleRTPSink.hh
@@ -0,0 +1,76 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A simple RTP sink that packs frames into each outgoing
+//     packet, without any fragmentation or special headers.
+// C++ header
+
+#ifndef _SIMPLE_RTP_SINK_HH
+#define _SIMPLE_RTP_SINK_HH
+
+#ifndef _MULTI_FRAMED_RTP_SINK_HH
+#include "MultiFramedRTPSink.hh"
+#endif
+
+class SimpleRTPSink: public MultiFramedRTPSink {
+public:
+  static SimpleRTPSink*
+  createNew(UsageEnvironment& env, Groupsock* RTPgs,
+	    unsigned char rtpPayloadFormat,
+	    unsigned rtpTimestampFrequency,
+	    char const* sdpMediaTypeString,
+	    char const* rtpPayloadFormatName,
+	    unsigned numChannels = 1,
+	    Boolean allowMultipleFramesPerPacket = True,
+	    Boolean doNormalMBitRule = True);
+  // "doNormalMBitRule" means: If the medium (i.e., "sdpMediaTypeString") is other than "audio", set the RTP "M" bit
+  // on each outgoing packet iff it contains the last (or only) fragment of a frame.
+  // Otherwise (i.e., if "doNormalMBitRule" is False, or the medium is "audio"), leave the "M" bit unset.
+
+  void setMBitOnNextPacket() { fSetMBitOnNextPacket = True; } // hack for optionally setting the RTP 'M' bit from outside the class
+
+protected:
+  SimpleRTPSink(UsageEnvironment& env, Groupsock* RTPgs,
+		unsigned char rtpPayloadFormat,
+		unsigned rtpTimestampFrequency,
+		char const* sdpMediaTypeString,
+		char const* rtpPayloadFormatName,
+		unsigned numChannels,
+		Boolean allowMultipleFramesPerPacket,
+		Boolean doNormalMBitRule);
+	// called only by createNew()
+
+  virtual ~SimpleRTPSink();
+
+protected: // redefined virtual functions
+  virtual void doSpecialFrameHandling(unsigned fragmentationOffset,
+                                      unsigned char* frameStart,
+                                      unsigned numBytesInFrame,
+                                      struct timeval framePresentationTime,
+                                      unsigned numRemainingBytes);
+  virtual
+  Boolean frameCanAppearAfterPacketStart(unsigned char const* frameStart,
+					 unsigned numBytesInFrame) const;
+  virtual char const* sdpMediaType() const;
+
+private:
+  char const* fSDPMediaTypeString;
+  Boolean fAllowMultipleFramesPerPacket;
+  Boolean fSetMBitOnLastFrames, fSetMBitOnNextPacket;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/SimpleRTPSource.hh b/3rdparty/live555/src/liveMedia/include/SimpleRTPSource.hh
new file mode 100644
index 00000000..fec9da43
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/SimpleRTPSource.hh
@@ -0,0 +1,65 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A RTP source for a simple RTP payload format that
+//     - doesn't have any special headers following the RTP header
+//       (if necessary, the "offset" parameter can be used to specify a
+//        special header that we just skip over)
+//     - doesn't have any special framing apart from the packet data itself
+// C++ header
+
+#ifndef _SIMPLE_RTP_SOURCE_HH
+#define _SIMPLE_RTP_SOURCE_HH
+
+#ifndef _MULTI_FRAMED_RTP_SOURCE_HH
+#include "MultiFramedRTPSource.hh"
+#endif
+
+class SimpleRTPSource: public MultiFramedRTPSource {
+public:
+  static SimpleRTPSource* createNew(UsageEnvironment& env, Groupsock* RTPgs,
+				    unsigned char rtpPayloadFormat,
+				    unsigned rtpTimestampFrequency,
+				    char const* mimeTypeString,
+				    unsigned offset = 0,
+				    Boolean doNormalMBitRule = True);
+  // "doNormalMBitRule" means: If the medium is not audio, use the RTP "M"
+  // bit on each incoming packet to indicate the last (or only) fragment
+  // of a frame.  Otherwise (i.e., if "doNormalMBitRule" is False, or the medium is "audio"), the "M" bit is ignored.
+
+protected:
+  SimpleRTPSource(UsageEnvironment& env, Groupsock* RTPgs,
+		  unsigned char rtpPayloadFormat,
+		  unsigned rtpTimestampFrequency,
+		  char const* mimeTypeString, unsigned offset,
+		  Boolean doNormalMBitRule);
+      // called only by createNew(), or by subclass constructors
+  virtual ~SimpleRTPSource();
+
+protected:
+  // redefined virtual functions:
+  virtual Boolean processSpecialHeader(BufferedPacket* packet,
+                                       unsigned& resultSpecialHeaderSize);
+  virtual char const* MIMEtype() const;
+
+private:
+  char const* fMIMEtypeString;
+  unsigned fOffset;
+  Boolean fUseMBitForFrameEnd;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/StreamReplicator.hh b/3rdparty/live555/src/liveMedia/include/StreamReplicator.hh
new file mode 100644
index 00000000..aeada751
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/StreamReplicator.hh
@@ -0,0 +1,84 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// An class that can be used to create (possibly multiple) 'replicas' of an incoming stream.
+// C++ header
+
+#ifndef _STREAM_REPLICATOR_HH
+#define _STREAM_REPLICATOR_HH
+
+#ifndef _FRAMED_SOURCE_HH
+#include "FramedSource.hh"
+#endif
+
+class StreamReplica; // forward
+
+class StreamReplicator: public Medium {
+public:
+  static StreamReplicator* createNew(UsageEnvironment& env, FramedSource* inputSource, Boolean deleteWhenLastReplicaDies = True);
+    // If "deleteWhenLastReplicaDies" is True (the default), then the "StreamReplicator" object is deleted when (and only when)
+    //   all replicas have been deleted.  (In this case, you must *not* call "Medium::close()" on the "StreamReplicator" object,
+    //   unless you never created any replicas from it to begin with.)
+    // If "deleteWhenLastReplicaDies" is False, then the "StreamReplicator" object remains in existence, even when all replicas
+    //   have been deleted.  (This allows you to create new replicas later, if you wish.)  In this case, you delete the
+    //   "StreamReplicator" object by calling "Medium::close()" on it - but you must do so only when "numReplicas()" returns 0.
+
+  FramedSource* createStreamReplica();
+
+  unsigned numReplicas() const { return fNumReplicas; }
+
+  FramedSource* inputSource() const { return fInputSource; }
+
+  // Call before destruction if you want to prevent the destructor from closing the input source
+  void detachInputSource() { fInputSource = NULL; }
+
+protected:
+  StreamReplicator(UsageEnvironment& env, FramedSource* inputSource, Boolean deleteWhenLastReplicaDies);
+    // called only by "createNew()"
+  virtual ~StreamReplicator();
+
+private:
+  // Routines called by replicas to implement frame delivery, and the stopping/restarting/deletion of replicas:
+  friend class StreamReplica;
+  void getNextFrame(StreamReplica* replica);
+  void deactivateStreamReplica(StreamReplica* replica);
+  void removeStreamReplica(StreamReplica* replica);
+
+private:
+  static void afterGettingFrame(void* clientData, unsigned frameSize,
+                                unsigned numTruncatedBytes,
+                                struct timeval presentationTime,
+                                unsigned durationInMicroseconds);
+  void afterGettingFrame(unsigned frameSize, unsigned numTruncatedBytes,
+			 struct timeval presentationTime, unsigned durationInMicroseconds);
+
+  static void onSourceClosure(void* clientData);
+  void onSourceClosure();
+
+  void deliverReceivedFrame();
+
+private:
+  FramedSource* fInputSource;
+  Boolean fDeleteWhenLastReplicaDies, fInputSourceHasClosed; 
+  unsigned fNumReplicas, fNumActiveReplicas, fNumDeliveriesMadeSoFar;
+  int fFrameIndex; // 0 or 1; used to figure out if a replica is requesting the current frame, or the next frame
+
+  StreamReplica* fPrimaryReplica; // the first replica that requests each frame.  We use its buffer when copying to the others.
+  StreamReplica* fReplicasAwaitingCurrentFrame; // other than the 'primary' replica
+  StreamReplica* fReplicasAwaitingNextFrame; // replicas that have already received the current frame, and have asked for the next
+};
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/T140TextRTPSink.hh b/3rdparty/live555/src/liveMedia/include/T140TextRTPSink.hh
new file mode 100644
index 00000000..b157e67b
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/T140TextRTPSink.hh
@@ -0,0 +1,103 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// RTP sink for T.140 text (RFC 2793)
+// C++ header
+
+#ifndef _T140_TEXT_RTP_SINK_HH
+#define _T140_TEXT_RTP_SINK_HH
+
+#ifndef _TEXT_RTP_SINK_HH
+#include "TextRTPSink.hh"
+#endif
+#ifndef _FRAMED_FILTER_HH
+#include "FramedFilter.hh"
+#endif
+
+class T140IdleFilter;
+
+class T140TextRTPSink: public TextRTPSink {
+public:
+  static T140TextRTPSink* createNew(UsageEnvironment& env, Groupsock* RTPgs, unsigned char rtpPayloadFormat);
+
+protected:
+  T140TextRTPSink(UsageEnvironment& env, Groupsock* RTPgs, unsigned char rtpPayloadFormat);
+	// called only by createNew()
+
+  virtual ~T140TextRTPSink();
+
+protected: // redefined virtual functions:
+  virtual Boolean continuePlaying();
+  virtual void doSpecialFrameHandling(unsigned fragmentationOffset,
+                                      unsigned char* frameStart,
+                                      unsigned numBytesInFrame,
+                                      struct timeval framePresentationTime,
+                                      unsigned numRemainingBytes);
+  virtual Boolean frameCanAppearAfterPacketStart(unsigned char const* frameStart,
+						 unsigned numBytesInFrame) const;
+
+protected:
+  T140IdleFilter* fOurIdleFilter;
+  Boolean fAreInIdlePeriod;
+};
+
+
+////////// T140IdleFilter definition //////////
+
+// Because the T.140 text RTP payload format specification recommends that (empty) RTP packets be sent during 'idle periods'
+// when no new text is available, we implement "T140TextRTPSink" using a separate "T140IdleFilter" class - sitting in front
+// -  that delivers, to the "T140TextRTPSink", a continuous sequence of (possibly) empty frames.
+// (Note: This class should be used only by "T140TextRTPSink", or a subclass.)
+
+class T140IdleFilter: public FramedFilter {
+public:
+  T140IdleFilter(UsageEnvironment& env, FramedSource* inputSource);
+  virtual ~T140IdleFilter();
+
+private: // redefined virtual functions:
+  virtual void doGetNextFrame();
+  virtual void doStopGettingFrames();
+
+private:
+  static void afterGettingFrame(void* clientData, unsigned frameSize,
+				unsigned numTruncatedBytes,
+                                struct timeval presentationTime,
+                                unsigned durationInMicroseconds);
+  void afterGettingFrame(unsigned frameSize,
+			 unsigned numTruncatedBytes,
+			 struct timeval presentationTime,
+			 unsigned durationInMicroseconds);
+
+  static void handleIdleTimeout(void* clientData);
+  void handleIdleTimeout();
+
+  void deliverFromBuffer();
+  void deliverEmptyFrame();
+
+  static void onSourceClosure(void* clientData);
+  void onSourceClosure();
+
+private:
+  TaskToken fIdleTimerTask;
+  unsigned fBufferSize, fNumBufferedBytes;
+  char* fBuffer;
+  unsigned fBufferedNumTruncatedBytes; // a count of truncated bytes from the upstream
+  struct timeval fBufferedDataPresentationTime;
+  unsigned fBufferedDataDurationInMicroseconds;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/TLSState.hh b/3rdparty/live555/src/liveMedia/include/TLSState.hh
new file mode 100644
index 00000000..deb841f5
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/TLSState.hh
@@ -0,0 +1,99 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// State encapsulating a TLS connection
+// C++ header
+
+#ifndef _TLS_STATE_HH
+#define _TLS_STATE_HH
+
+#ifndef _NET_COMMON_H
+#include "NetCommon.h"
+#endif
+#ifndef _BOOLEAN_HH
+#include "Boolean.hh"
+#endif
+#ifndef _USAGE_ENVIRONMENT_HH
+#include "UsageEnvironment.hh"
+#endif
+
+#ifndef NO_OPENSSL
+#define NO_OPENSSL
+// #include <openssl/ssl.h>
+#endif
+
+class TLSState {
+public:
+  Boolean isNeeded;
+
+  int write(const char* data, unsigned count);
+  int read(u_int8_t* buffer, unsigned bufferSize);
+
+protected: // we're an abstract base class
+  TLSState();
+  virtual ~TLSState();
+
+#ifndef NO_OPENSSL
+  void initLibrary();
+  void reset();
+
+protected:
+  Boolean fHasBeenSetup;
+  SSL_CTX* fCtx;
+  SSL* fCon;
+#endif
+};
+
+class ClientTLSState: public TLSState {
+public:
+  ClientTLSState(class RTSPClient& client);
+  virtual ~ClientTLSState();
+
+  int connect(int socketNum); // returns: <0 (error), 0 (pending), >0 (success)
+
+#ifndef NO_OPENSSL
+private:
+  Boolean setup(int socketNum);
+
+private:
+  class RTSPClient& fClient;
+#endif
+};
+
+class ServerTLSState: public TLSState {
+public:
+  ServerTLSState(UsageEnvironment& env);
+  virtual ~ServerTLSState();
+
+  void setCertificateAndPrivateKeyFileNames(char const* certFileName, char const* privKeyFileName);
+
+  int accept(int socketNum); // returns: <0 (error), 0 (pending), >0 (success)
+
+  Boolean tlsAcceptIsNeeded;
+
+#ifndef NO_OPENSSL
+private:
+  Boolean setup(int socketNum);
+
+private:
+  UsageEnvironment& fEnv;
+  char const* fCertificateFileName;
+  char const* fPrivateKeyFileName;
+#endif
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/TextRTPSink.hh b/3rdparty/live555/src/liveMedia/include/TextRTPSink.hh
new file mode 100644
index 00000000..d50e4476
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/TextRTPSink.hh
@@ -0,0 +1,41 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A generic RTP sink for text codecs (abstract base class)
+// C++ header
+
+#ifndef _TEXT_RTP_SINK_HH
+#define _TEXT_RTP_SINK_HH
+
+#ifndef _MULTI_FRAMED_RTP_SINK_HH
+#include "MultiFramedRTPSink.hh"
+#endif
+
+class TextRTPSink: public MultiFramedRTPSink {
+protected:
+  TextRTPSink(UsageEnvironment& env,
+	      Groupsock* rtpgs, unsigned char rtpPayloadType,
+	      unsigned rtpTimestampFrequency,
+	      char const* rtpPayloadFormatName);
+  // (we're an abstract base class)
+  virtual ~TextRTPSink();
+
+private: // redefined virtual functions:
+  virtual char const* sdpMediaType() const;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/TheoraVideoRTPSink.hh b/3rdparty/live555/src/liveMedia/include/TheoraVideoRTPSink.hh
new file mode 100644
index 00000000..23f2040b
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/TheoraVideoRTPSink.hh
@@ -0,0 +1,72 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// RTP sink for Theora video
+// C++ header
+
+#ifndef _THEORA_VIDEO_RTP_SINK_HH
+#define _THEORA_VIDEO_RTP_SINK_HH
+
+#ifndef _VIDEO_RTP_SINK_HH
+#include "VideoRTPSink.hh"
+#endif
+
+class TheoraVideoRTPSink: public VideoRTPSink {
+public:
+  static TheoraVideoRTPSink*
+  createNew(UsageEnvironment& env, Groupsock* RTPgs, u_int8_t rtpPayloadFormat,
+	    // The following headers provide the 'configuration' information, for the SDP description:
+	    u_int8_t* identificationHeader, unsigned identificationHeaderSize,
+	    u_int8_t* commentHeader, unsigned commentHeaderSize,
+	    u_int8_t* setupHeader, unsigned setupHeaderSize,
+	    u_int32_t identField = 0xFACADE);
+  
+  static TheoraVideoRTPSink*
+  createNew(UsageEnvironment& env, Groupsock* RTPgs, u_int8_t rtpPayloadFormat,
+            char const* configStr);
+  // an optional variant of "createNew()" that takes a Base-64-encoded 'configuration' string,
+  // rather than the raw configuration headers as parameter.
+
+protected:
+  TheoraVideoRTPSink(UsageEnvironment& env, Groupsock* RTPgs,
+		     u_int8_t rtpPayloadFormat,
+		     u_int8_t* identificationHeader, unsigned identificationHeaderSize,
+		     u_int8_t* commentHeader, unsigned commentHeaderSize,
+		     u_int8_t* setupHeader, unsigned setupHeaderSize,
+		     u_int32_t identField);
+  // called only by createNew()
+  
+  virtual ~TheoraVideoRTPSink();
+  
+private: // redefined virtual functions:
+  virtual char const* auxSDPLine(); // for the "a=fmtp:" SDP line
+  
+  virtual void doSpecialFrameHandling(unsigned fragmentationOffset,
+				      unsigned char* frameStart,
+				      unsigned numBytesInFrame,
+				      struct timeval framePresentationTime,
+				      unsigned numRemainingBytes);
+  virtual Boolean frameCanAppearAfterPacketStart(unsigned char const* frameStart,
+						 unsigned numBytesInFrame) const;
+  virtual unsigned specialHeaderSize() const;
+  
+private:
+  u_int32_t fIdent; // "Ident" field used by this stream.  (Only the low 24 bits of this are used.)
+  char* fFmtpSDPLine;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/TheoraVideoRTPSource.hh b/3rdparty/live555/src/liveMedia/include/TheoraVideoRTPSource.hh
new file mode 100644
index 00000000..bee1d2f4
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/TheoraVideoRTPSource.hh
@@ -0,0 +1,53 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// Theora Video Audio RTP Sources
+// C++ header
+
+#ifndef _THEORA_VIDEO_RTP_SOURCE_HH
+#define _THEORA_VIDEO_RTP_SOURCE_HH
+
+#ifndef _MULTI_FRAMED_RTP_SOURCE_HH
+#include "MultiFramedRTPSource.hh"
+#endif
+
+class TheoraVideoRTPSource: public MultiFramedRTPSource {
+public:
+  static TheoraVideoRTPSource*
+  createNew(UsageEnvironment& env, Groupsock* RTPgs,
+	    unsigned char rtpPayloadFormat);
+
+  u_int32_t curPacketIdent() const { return fCurPacketIdent; } // The current "Ident" field; only the low-order 24 bits are used
+
+protected:
+  TheoraVideoRTPSource(UsageEnvironment& env, Groupsock* RTPgs,
+		       unsigned char rtpPayloadFormat);
+      // called only by createNew()
+
+  virtual ~TheoraVideoRTPSource();
+
+protected:
+  // redefined virtual functions:
+  virtual Boolean processSpecialHeader(BufferedPacket* packet,
+                                       unsigned& resultSpecialHeaderSize);
+  virtual char const* MIMEtype() const;
+
+private:
+  u_int32_t fCurPacketIdent; // only the low-order 24 bits are used
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/VP8VideoRTPSink.hh b/3rdparty/live555/src/liveMedia/include/VP8VideoRTPSink.hh
new file mode 100644
index 00000000..50a42dbe
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/VP8VideoRTPSink.hh
@@ -0,0 +1,50 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// RTP sink for VP8 video
+// C++ header
+
+#ifndef _VP8_VIDEO_RTP_SINK_HH
+#define _VP8_VIDEO_RTP_SINK_HH
+
+#ifndef _VIDEO_RTP_SINK_HH
+#include "VideoRTPSink.hh"
+#endif
+
+class VP8VideoRTPSink: public VideoRTPSink {
+public:
+  static VP8VideoRTPSink* createNew(UsageEnvironment& env, Groupsock* RTPgs, unsigned char rtpPayloadFormat);
+
+protected:
+  VP8VideoRTPSink(UsageEnvironment& env, Groupsock* RTPgs, unsigned char rtpPayloadFormat);
+	// called only by createNew()
+
+  virtual ~VP8VideoRTPSink();
+
+private: // redefined virtual functions:
+  virtual void doSpecialFrameHandling(unsigned fragmentationOffset,
+                                      unsigned char* frameStart,
+                                      unsigned numBytesInFrame,
+                                      struct timeval framePresentationTime,
+                                      unsigned numRemainingBytes);
+  virtual
+  Boolean frameCanAppearAfterPacketStart(unsigned char const* frameStart,
+					 unsigned numBytesInFrame) const;
+  virtual unsigned specialHeaderSize() const;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/VP8VideoRTPSource.hh b/3rdparty/live555/src/liveMedia/include/VP8VideoRTPSource.hh
new file mode 100644
index 00000000..c00f29ef
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/VP8VideoRTPSource.hh
@@ -0,0 +1,50 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// VP8 Video RTP Sources
+// C++ header
+
+#ifndef _VP8_VIDEO_RTP_SOURCE_HH
+#define _VP8_VIDEO_RTP_SOURCE_HH
+
+#ifndef _MULTI_FRAMED_RTP_SOURCE_HH
+#include "MultiFramedRTPSource.hh"
+#endif
+
+class VP8VideoRTPSource: public MultiFramedRTPSource {
+public:
+  static VP8VideoRTPSource*
+  createNew(UsageEnvironment& env, Groupsock* RTPgs,
+	    unsigned char rtpPayloadFormat,
+	    unsigned rtpTimestampFrequency = 90000);
+
+protected:
+  VP8VideoRTPSource(UsageEnvironment& env, Groupsock* RTPgs,
+		    unsigned char rtpPayloadFormat,
+		    unsigned rtpTimestampFrequency);
+      // called only by createNew()
+
+  virtual ~VP8VideoRTPSource();
+
+protected:
+  // redefined virtual functions:
+  virtual Boolean processSpecialHeader(BufferedPacket* packet,
+                                       unsigned& resultSpecialHeaderSize);
+  virtual char const* MIMEtype() const;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/VP9VideoRTPSink.hh b/3rdparty/live555/src/liveMedia/include/VP9VideoRTPSink.hh
new file mode 100644
index 00000000..7797143d
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/VP9VideoRTPSink.hh
@@ -0,0 +1,50 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// RTP sink for VP9 video
+// C++ header
+
+#ifndef _VP9_VIDEO_RTP_SINK_HH
+#define _VP9_VIDEO_RTP_SINK_HH
+
+#ifndef _VIDEO_RTP_SINK_HH
+#include "VideoRTPSink.hh"
+#endif
+
+class VP9VideoRTPSink: public VideoRTPSink {
+public:
+  static VP9VideoRTPSink* createNew(UsageEnvironment& env, Groupsock* RTPgs, unsigned char rtpPayloadFormat);
+
+protected:
+  VP9VideoRTPSink(UsageEnvironment& env, Groupsock* RTPgs, unsigned char rtpPayloadFormat);
+	// called only by createNew()
+
+  virtual ~VP9VideoRTPSink();
+
+private: // redefined virtual functions:
+  virtual void doSpecialFrameHandling(unsigned fragmentationOffset,
+                                      unsigned char* frameStart,
+                                      unsigned numBytesInFrame,
+                                      struct timeval framePresentationTime,
+                                      unsigned numRemainingBytes);
+  virtual
+  Boolean frameCanAppearAfterPacketStart(unsigned char const* frameStart,
+					 unsigned numBytesInFrame) const;
+  virtual unsigned specialHeaderSize() const;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/VP9VideoRTPSource.hh b/3rdparty/live555/src/liveMedia/include/VP9VideoRTPSource.hh
new file mode 100644
index 00000000..5e48749c
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/VP9VideoRTPSource.hh
@@ -0,0 +1,50 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// VP9 Video RTP Sources
+// C++ header
+
+#ifndef _VP9_VIDEO_RTP_SOURCE_HH
+#define _VP9_VIDEO_RTP_SOURCE_HH
+
+#ifndef _MULTI_FRAMED_RTP_SOURCE_HH
+#include "MultiFramedRTPSource.hh"
+#endif
+
+class VP9VideoRTPSource: public MultiFramedRTPSource {
+public:
+  static VP9VideoRTPSource*
+  createNew(UsageEnvironment& env, Groupsock* RTPgs,
+	    unsigned char rtpPayloadFormat,
+	    unsigned rtpTimestampFrequency = 90000);
+
+protected:
+  VP9VideoRTPSource(UsageEnvironment& env, Groupsock* RTPgs,
+		    unsigned char rtpPayloadFormat,
+		    unsigned rtpTimestampFrequency);
+      // called only by createNew()
+
+  virtual ~VP9VideoRTPSource();
+
+protected:
+  // redefined virtual functions:
+  virtual Boolean processSpecialHeader(BufferedPacket* packet,
+                                       unsigned& resultSpecialHeaderSize);
+  virtual char const* MIMEtype() const;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/VideoRTPSink.hh b/3rdparty/live555/src/liveMedia/include/VideoRTPSink.hh
new file mode 100644
index 00000000..77364958
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/VideoRTPSink.hh
@@ -0,0 +1,41 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A generic RTP sink for video codecs (abstract base class)
+// C++ header
+
+#ifndef _VIDEO_RTP_SINK_HH
+#define _VIDEO_RTP_SINK_HH
+
+#ifndef _MULTI_FRAMED_RTP_SINK_HH
+#include "MultiFramedRTPSink.hh"
+#endif
+
+class VideoRTPSink: public MultiFramedRTPSink {
+protected:
+  VideoRTPSink(UsageEnvironment& env,
+	       Groupsock* rtpgs, unsigned char rtpPayloadType,
+	       unsigned rtpTimestampFrequency,
+	       char const* rtpPayloadFormatName);
+  // (we're an abstract base class)
+  virtual ~VideoRTPSink();
+
+private: // redefined virtual functions:
+  virtual char const* sdpMediaType() const;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/VorbisAudioRTPSink.hh b/3rdparty/live555/src/liveMedia/include/VorbisAudioRTPSink.hh
new file mode 100644
index 00000000..d3de942d
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/VorbisAudioRTPSink.hh
@@ -0,0 +1,85 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// RTP sink for Vorbis audio
+// C++ header
+
+#ifndef _VORBIS_AUDIO_RTP_SINK_HH
+#define _VORBIS_AUDIO_RTP_SINK_HH
+
+#ifndef _AUDIO_RTP_SINK_HH
+#include "AudioRTPSink.hh"
+#endif
+
+class VorbisAudioRTPSink: public AudioRTPSink {
+public:
+  static VorbisAudioRTPSink*
+  createNew(UsageEnvironment& env, Groupsock* RTPgs, u_int8_t rtpPayloadFormat,
+	    u_int32_t rtpTimestampFrequency, unsigned numChannels,
+	    // The following headers provide the 'configuration' information, for the SDP description:
+	    u_int8_t* identificationHeader, unsigned identificationHeaderSize,
+	    u_int8_t* commentHeader, unsigned commentHeaderSize,
+	    u_int8_t* setupHeader, unsigned setupHeaderSize,
+	    u_int32_t identField = 0xFACADE);
+
+  static VorbisAudioRTPSink*
+  createNew(UsageEnvironment& env, Groupsock* RTPgs, u_int8_t rtpPayloadFormat,
+	    u_int32_t rtpTimestampFrequency, unsigned numChannels,
+	    char const* configStr);
+    // an optional variant of "createNew()" that takes a Base-64-encoded 'configuration' string,
+    // rather than the raw configuration headers as parameter.
+
+protected:
+  VorbisAudioRTPSink(UsageEnvironment& env, Groupsock* RTPgs,
+		     u_int8_t rtpPayloadFormat, u_int32_t rtpTimestampFrequency, unsigned numChannels,
+		     u_int8_t* identificationHeader, unsigned identificationHeaderSize,
+		     u_int8_t* commentHeader, unsigned commentHeaderSize,
+		     u_int8_t* setupHeader, unsigned setupHeaderSize,
+		     u_int32_t identField);
+	// called only by createNew()
+
+  virtual ~VorbisAudioRTPSink();
+
+private: // redefined virtual functions:
+  virtual char const* auxSDPLine(); // for the "a=fmtp:" SDP line
+
+  virtual void doSpecialFrameHandling(unsigned fragmentationOffset,
+                                      unsigned char* frameStart,
+                                      unsigned numBytesInFrame,
+                                      struct timeval framePresentationTime,
+                                      unsigned numRemainingBytes);
+  virtual Boolean frameCanAppearAfterPacketStart(unsigned char const* frameStart,
+						 unsigned numBytesInFrame) const;
+  virtual unsigned specialHeaderSize() const;
+  virtual unsigned frameSpecificHeaderSize() const;
+
+private:
+  u_int32_t fIdent; // "Ident" field used by this stream.  (Only the low 24 bits of this are used.)
+  char* fFmtpSDPLine;
+};
+
+
+// A general function used by both "VorbisAudioRTPSink" and "TheoraVideoRTPSink" to construct
+// a Base64-encoded 'config' string (for SDP) from "identification", "comment", "setup" headers.
+// (Note: The result string was heap-allocated, and the caller should delete[] it afterwards.)
+
+char* generateVorbisOrTheoraConfigStr(u_int8_t* identificationHeader, unsigned identificationHeaderSize,
+				      u_int8_t* commentHeader, unsigned commentHeaderSize,
+				      u_int8_t* setupHeader, unsigned setupHeaderSize,
+				      u_int32_t identField);
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/VorbisAudioRTPSource.hh b/3rdparty/live555/src/liveMedia/include/VorbisAudioRTPSource.hh
new file mode 100644
index 00000000..aae00bb4
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/VorbisAudioRTPSource.hh
@@ -0,0 +1,66 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// Vorbis Audio RTP Sources
+// C++ header
+
+#ifndef _VORBIS_AUDIO_RTP_SOURCE_HH
+#define _VORBIS_AUDIO_RTP_SOURCE_HH
+
+#ifndef _MULTI_FRAMED_RTP_SOURCE_HH
+#include "MultiFramedRTPSource.hh"
+#endif
+
+class VorbisAudioRTPSource: public MultiFramedRTPSource {
+public:
+  static VorbisAudioRTPSource*
+  createNew(UsageEnvironment& env, Groupsock* RTPgs,
+	    unsigned char rtpPayloadFormat,
+	    unsigned rtpTimestampFrequency);
+
+  u_int32_t curPacketIdent() const { return fCurPacketIdent; } // The current "Ident" field; only the low-order 24 bits are used
+
+protected:
+  VorbisAudioRTPSource(UsageEnvironment& env, Groupsock* RTPgs,
+		       unsigned char rtpPayloadFormat,
+		       unsigned rtpTimestampFrequency);
+      // called only by createNew()
+
+  virtual ~VorbisAudioRTPSource();
+
+protected:
+  // redefined virtual functions:
+  virtual Boolean processSpecialHeader(BufferedPacket* packet,
+                                       unsigned& resultSpecialHeaderSize);
+  virtual char const* MIMEtype() const;
+
+private:
+  u_int32_t fCurPacketIdent; // only the low-order 24 bits are used
+};
+
+void parseVorbisOrTheoraConfigStr(char const* configStr,
+				  u_int8_t*& identificationHdr, unsigned& identificationHdrSize,
+				  u_int8_t*& commentHdr, unsigned& commentHdrSize,
+				  u_int8_t*& setupHdr, unsigned& setupHdrSize,
+				  u_int32_t& identField);
+    // Returns (in each of the result parameters) unpacked Vorbis or Theora
+    // "identification", "comment", and "setup" headers that were specified in a
+    // "config" string (in the SDP description for a Vorbis/RTP or Theora/RTP stream).
+    // Each of the "*Hdr" result arrays are dynamically allocated by this routine,
+    // and must be delete[]d by the caller.
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/WAVAudioFileServerMediaSubsession.hh b/3rdparty/live555/src/liveMedia/include/WAVAudioFileServerMediaSubsession.hh
new file mode 100644
index 00000000..7663f2cb
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/WAVAudioFileServerMediaSubsession.hh
@@ -0,0 +1,68 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A 'ServerMediaSubsession' object that creates new, unicast, "RTPSink"s
+// on demand, from an WAV audio file.
+// C++ header
+
+#ifndef _WAV_AUDIO_FILE_SERVER_MEDIA_SUBSESSION_HH
+#define _WAV_AUDIO_FILE_SERVER_MEDIA_SUBSESSION_HH
+
+#ifndef _FILE_SERVER_MEDIA_SUBSESSION_HH
+#include "FileServerMediaSubsession.hh"
+#endif
+
+class WAVAudioFileServerMediaSubsession: public FileServerMediaSubsession{
+public:
+  static WAVAudioFileServerMediaSubsession*
+  createNew(UsageEnvironment& env, char const* fileName, Boolean reuseFirstSource,
+	    Boolean convertToULaw = False);
+      // If "convertToULaw" is True, 16-bit audio streams are converted to
+      // 8-bit u-law audio prior to streaming.
+
+protected:
+  WAVAudioFileServerMediaSubsession(UsageEnvironment& env, char const* fileName,
+				    Boolean reuseFirstSource, Boolean convertToULaw);
+      // called only by createNew();
+  virtual ~WAVAudioFileServerMediaSubsession();
+
+protected: // redefined virtual functions
+  virtual void seekStreamSource(FramedSource* inputSource, double& seekNPT, double streamDuration, u_int64_t& numBytes);
+  virtual void setStreamSourceScale(FramedSource* inputSource, float scale);
+  virtual void setStreamSourceDuration(FramedSource* inputSource, double streamDuration, u_int64_t& numBytes);
+
+  virtual FramedSource* createNewStreamSource(unsigned clientSessionId,
+					      unsigned& estBitrate);
+  virtual RTPSink* createNewRTPSink(Groupsock* rtpGroupsock,
+                                    unsigned char rtpPayloadTypeIfDynamic,
+				    FramedSource* inputSource);
+  virtual void testScaleFactor(float& scale);
+  virtual float duration() const;
+
+protected:
+  Boolean fConvertToULaw;
+
+  // The following parameters of the input stream are set after
+  // "createNewStreamSource" is called:
+  unsigned char fAudioFormat;
+  unsigned char fBitsPerSample;
+  unsigned fSamplingFrequency;
+  unsigned fNumChannels;
+  float fFileDuration;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/WAVAudioFileSource.hh b/3rdparty/live555/src/liveMedia/include/WAVAudioFileSource.hh
new file mode 100644
index 00000000..502873e6
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/WAVAudioFileSource.hh
@@ -0,0 +1,86 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// A WAV audio file source
+// NOTE: Samples are returned in little-endian order (the same order in which
+// they were stored in the file).
+// C++ header
+
+#ifndef _WAV_AUDIO_FILE_SOURCE_HH
+#define _WAV_AUDIO_FILE_SOURCE_HH
+
+#ifndef _AUDIO_INPUT_DEVICE_HH
+#include "AudioInputDevice.hh"
+#endif
+
+typedef enum {
+  WA_PCM = 0x01,
+  WA_PCMA = 0x06,
+  WA_PCMU = 0x07,
+  WA_IMA_ADPCM = 0x11,
+  WA_UNKNOWN
+} WAV_AUDIO_FORMAT;
+
+
+class WAVAudioFileSource: public AudioInputDevice {
+public:
+
+  static WAVAudioFileSource* createNew(UsageEnvironment& env,
+					char const* fileName);
+
+  unsigned numPCMBytes() const;
+  void setScaleFactor(int scale);
+  void seekToPCMByte(unsigned byteNumber);
+  void limitNumBytesToStream(unsigned numBytesToStream);
+      // if "numBytesToStream" is >0, then we limit the stream to that number of bytes, before treating it as EOF
+
+  unsigned char getAudioFormat();
+
+protected:
+  WAVAudioFileSource(UsageEnvironment& env, FILE* fid);
+	// called only by createNew()
+
+  virtual ~WAVAudioFileSource();
+
+  static void fileReadableHandler(WAVAudioFileSource* source, int mask);
+  void doReadFromFile();
+
+private:
+  // redefined virtual functions:
+  virtual void doGetNextFrame();
+  virtual void doStopGettingFrames();
+  virtual Boolean setInputPort(int portIndex);
+  virtual double getAverageLevel() const;
+
+protected:
+  unsigned fPreferredFrameSize;
+
+private:
+  FILE* fFid;
+  double fPlayTimePerSample; // useconds
+  Boolean fFidIsSeekable;
+  unsigned fLastPlayTime; // useconds
+  Boolean fHaveStartedReading;
+  unsigned fWAVHeaderSize;
+  unsigned fFileSize;
+  int fScaleFactor;
+  Boolean fLimitNumBytesToStream;
+  unsigned fNumBytesToStream; // used iff "fLimitNumBytesToStream" is True
+  unsigned char fAudioFormat;
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/liveMedia.hh b/3rdparty/live555/src/liveMedia/include/liveMedia.hh
new file mode 100644
index 00000000..543f54a8
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/liveMedia.hh
@@ -0,0 +1,137 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// Inclusion of header files representing the interface
+// for the entire library
+//
+// Programs that use the library can include this header file,
+// instead of each of the individual media header files
+
+#ifndef _LIVEMEDIA_HH
+#define _LIVEMEDIA_HH
+#include "JPEG2000VideoRTPSource.hh"
+#include "JPEG2000VideoRTPSink.hh"
+//#include "JPEG2000VideoStreamFramer.hh"
+//#include "JPEG2000VideoFileServerMediaSubsession.hh"
+#include "MPEG1or2AudioRTPSink.hh"
+#include "MP3ADURTPSink.hh"
+#include "MPEG1or2VideoRTPSink.hh"
+#include "MPEG4ESVideoRTPSink.hh"
+#include "AMRAudioFileSink.hh"
+#include "H264VideoFileSink.hh"
+#include "H265VideoFileSink.hh"
+#include "OggFileSink.hh"
+#include "BasicUDPSink.hh"
+#include "GSMAudioRTPSink.hh"
+#include "H263plusVideoRTPSink.hh"
+#include "H264VideoRTPSink.hh"
+#include "H265VideoRTPSink.hh"
+#include "DVVideoRTPSource.hh"
+#include "DVVideoRTPSink.hh"
+#include "DVVideoStreamFramer.hh"
+#include "H264VideoStreamFramer.hh"
+#include "H265VideoStreamFramer.hh"
+#include "H264VideoStreamDiscreteFramer.hh"
+#include "H265VideoStreamDiscreteFramer.hh"
+#include "JPEGVideoRTPSink.hh"
+#include "SimpleRTPSink.hh"
+#include "uLawAudioFilter.hh"
+#include "MPEG2IndexFromTransportStream.hh"
+#include "MPEG2TransportStreamTrickModeFilter.hh"
+#include "ByteStreamMultiFileSource.hh"
+#include "ByteStreamMemoryBufferSource.hh"
+#include "BasicUDPSource.hh"
+#include "SimpleRTPSource.hh"
+#include "MPEG1or2AudioRTPSource.hh"
+#include "MPEG4LATMAudioRTPSource.hh"
+#include "MPEG4LATMAudioRTPSink.hh"
+#include "MPEG4ESVideoRTPSource.hh"
+#include "MPEG4GenericRTPSource.hh"
+#include "MP3ADURTPSource.hh"
+#include "QCELPAudioRTPSource.hh"
+#include "AMRAudioRTPSource.hh"
+#include "JPEGVideoRTPSource.hh"
+#include "JPEGVideoSource.hh"
+#include "MPEG1or2VideoRTPSource.hh"
+#include "VorbisAudioRTPSource.hh"
+#include "TheoraVideoRTPSource.hh"
+#include "VP8VideoRTPSource.hh"
+#include "VP9VideoRTPSource.hh"
+#include "RawVideoRTPSource.hh"
+#include "MPEG2TransportStreamFromPESSource.hh"
+#include "MPEG2TransportStreamFromESSource.hh"
+#include "MPEG2TransportStreamFramer.hh"
+#include "ADTSAudioFileSource.hh"
+#include "ADTSAudioStreamDiscreteFramer.hh"
+#include "H261VideoRTPSource.hh"
+#include "H263plusVideoRTPSource.hh"
+#include "H264VideoRTPSource.hh"
+#include "H265VideoRTPSource.hh"
+#include "MP3FileSource.hh"
+#include "MP3ADU.hh"
+#include "MP3ADUinterleaving.hh"
+#include "MP3Transcoder.hh"
+#include "MPEG1or2DemuxedElementaryStream.hh"
+#include "MPEG1or2AudioStreamFramer.hh"
+#include "H263plusVideoStreamFramer.hh"
+#include "AC3AudioStreamFramer.hh"
+#include "AC3AudioRTPSource.hh"
+#include "AC3AudioRTPSink.hh"
+#include "VorbisAudioRTPSink.hh"
+#include "TheoraVideoRTPSink.hh"
+#include "VP8VideoRTPSink.hh"
+#include "VP9VideoRTPSink.hh"
+#include "MPEG4GenericRTPSink.hh"
+#include "RawVideoRTPSink.hh"
+#include "MPEG1or2VideoStreamDiscreteFramer.hh"
+#include "MPEG4VideoStreamDiscreteFramer.hh"
+#include "DeviceSource.hh"
+#include "AudioInputDevice.hh"
+#include "WAVAudioFileSource.hh"
+#include "StreamReplicator.hh"
+#include "RTSPRegisterSender.hh"
+#include "RTSPClient.hh"
+#include "SIPClient.hh"
+#include "QuickTimeFileSink.hh"
+#include "QuickTimeGenericRTPSource.hh"
+#include "AVIFileSink.hh"
+#include "PassiveServerMediaSubsession.hh"
+#include "MPEG4VideoFileServerMediaSubsession.hh"
+#include "H264VideoFileServerMediaSubsession.hh"
+#include "H265VideoFileServerMediaSubsession.hh"
+#include "WAVAudioFileServerMediaSubsession.hh"
+#include "AMRAudioFileServerMediaSubsession.hh"
+#include "AMRAudioFileSource.hh"
+#include "AMRAudioRTPSink.hh"
+#include "T140TextRTPSink.hh"
+#include "MP3AudioFileServerMediaSubsession.hh"
+#include "MPEG1or2VideoFileServerMediaSubsession.hh"
+#include "MPEG1or2FileServerDemux.hh"
+#include "MPEG2TransportFileServerMediaSubsession.hh"
+#include "H263plusVideoFileServerMediaSubsession.hh"
+#include "ADTSAudioFileServerMediaSubsession.hh"
+#include "DVVideoFileServerMediaSubsession.hh"
+#include "AC3AudioFileServerMediaSubsession.hh"
+#include "MPEG2TransportUDPServerMediaSubsession.hh"
+#include "MatroskaFileServerDemux.hh"
+#include "OggFileServerDemux.hh"
+#include "MPEG2TransportStreamDemux.hh"
+#include "ProxyServerMediaSession.hh"
+#include "HLSSegmenter.hh"
+#include "MPEG2TransportStreamAccumulator.hh"
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/liveMedia_version.hh b/3rdparty/live555/src/liveMedia/include/liveMedia_version.hh
new file mode 100644
index 00000000..7bbbbee5
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/liveMedia_version.hh
@@ -0,0 +1,25 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// Version information for the "liveMedia" library
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+
+#ifndef _LIVEMEDIA_VERSION_HH
+#define _LIVEMEDIA_VERSION_HH
+
+#define LIVEMEDIA_LIBRARY_VERSION_STRING	"2022.04.26"
+#define LIVEMEDIA_LIBRARY_VERSION_INT		1650931200
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/ourMD5.hh b/3rdparty/live555/src/liveMedia/include/ourMD5.hh
new file mode 100644
index 00000000..84cdf102
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/ourMD5.hh
@@ -0,0 +1,38 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// Because MD5 may not be implemented (at least, with the same interface) on all systems,
+// we have our own implementation.
+// C++ header
+
+#ifndef _OUR_MD5_HH
+#define _OUR_MD5_HH
+
+extern char* our_MD5Data(unsigned char const* data, unsigned dataSize, char* outputDigest);
+    // "outputDigest" must be either NULL (in which case this function returns a heap-allocated
+    // buffer, which should be later delete[]d by the caller), or else it must point to
+    // a (>=)33-byte buffer (which this function will also return).
+
+extern unsigned char* our_MD5DataRaw(unsigned char const* data, unsigned dataSize,
+				     unsigned char* outputDigest);
+    // Like "ourMD5Data()", except that it returns the digest in 'raw' binary form, rather than
+    // as an ASCII hex string.
+    // "outputDigest" must be either NULL (in which case this function returns a heap-allocated
+    // buffer, which should be later delete[]d by the caller), or else it must point to
+    // a (>=)16-byte buffer (which this function will also return).
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/include/uLawAudioFilter.hh b/3rdparty/live555/src/liveMedia/include/uLawAudioFilter.hh
new file mode 100644
index 00000000..2df1e248
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/include/uLawAudioFilter.hh
@@ -0,0 +1,208 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// Filters for converting between raw PCM audio and uLaw
+// C++ header
+
+#ifndef _ULAW_AUDIO_FILTER_HH
+#define _ULAW_AUDIO_FILTER_HH
+
+#ifndef _FRAMED_FILTER_HH
+#include "FramedFilter.hh"
+#endif
+
+////////// 16-bit PCM (in various byte orderings) -> 8-bit u-Law //////////
+
+class uLawFromPCMAudioSource: public FramedFilter {
+public:
+  static uLawFromPCMAudioSource*
+  createNew(UsageEnvironment& env, FramedSource* inputSource,
+	    int byteOrdering = 0);
+  // "byteOrdering" == 0 => host order (the default)
+  // "byteOrdering" == 1 => little-endian order
+  // "byteOrdering" == 2 => network (i.e., big-endian) order
+
+protected:
+  uLawFromPCMAudioSource(UsageEnvironment& env, FramedSource* inputSource,
+			 int byteOrdering);
+      // called only by createNew()
+  virtual ~uLawFromPCMAudioSource();
+
+private:
+  // Redefined virtual functions:
+  virtual void doGetNextFrame();
+
+private:
+  static void afterGettingFrame(void* clientData, unsigned frameSize,
+				unsigned numTruncatedBytes,
+				struct timeval presentationTime,
+				unsigned durationInMicroseconds);
+  void afterGettingFrame1(unsigned frameSize,
+			  unsigned numTruncatedBytes,
+			  struct timeval presentationTime,
+			  unsigned durationInMicroseconds);
+
+private:
+  int fByteOrdering;
+  unsigned char* fInputBuffer;
+  unsigned fInputBufferSize;
+};
+
+
+////////// u-Law -> 16-bit PCM (in host order) //////////
+
+class PCMFromuLawAudioSource: public FramedFilter {
+public:
+  static PCMFromuLawAudioSource*
+  createNew(UsageEnvironment& env, FramedSource* inputSource);
+
+protected:
+  PCMFromuLawAudioSource(UsageEnvironment& env,
+			 FramedSource* inputSource);
+      // called only by createNew()
+  virtual ~PCMFromuLawAudioSource();
+
+private:
+  // Redefined virtual functions:
+  virtual void doGetNextFrame();
+
+private:
+  static void afterGettingFrame(void* clientData, unsigned frameSize,
+				unsigned numTruncatedBytes,
+				struct timeval presentationTime,
+				unsigned durationInMicroseconds);
+  void afterGettingFrame1(unsigned frameSize,
+			  unsigned numTruncatedBytes,
+			  struct timeval presentationTime,
+			  unsigned durationInMicroseconds);
+
+private:
+  unsigned char* fInputBuffer;
+  unsigned fInputBufferSize;
+};
+
+
+////////// 16-bit values (in host order) -> 16-bit network order //////////
+
+class NetworkFromHostOrder16: public FramedFilter {
+public:
+  static NetworkFromHostOrder16*
+  createNew(UsageEnvironment& env, FramedSource* inputSource);
+
+protected:
+  NetworkFromHostOrder16(UsageEnvironment& env, FramedSource* inputSource);
+      // called only by createNew()
+  virtual ~NetworkFromHostOrder16();
+
+private:
+  // Redefined virtual functions:
+  virtual void doGetNextFrame();
+
+private:
+  static void afterGettingFrame(void* clientData, unsigned frameSize,
+				unsigned numTruncatedBytes,
+				struct timeval presentationTime,
+				unsigned durationInMicroseconds);
+  void afterGettingFrame1(unsigned frameSize,
+			  unsigned numTruncatedBytes,
+			  struct timeval presentationTime,
+			  unsigned durationInMicroseconds);
+};
+
+
+////////// 16-bit values (in network order) -> 16-bit host order //////////
+
+class HostFromNetworkOrder16: public FramedFilter {
+public:
+  static HostFromNetworkOrder16*
+  createNew(UsageEnvironment& env, FramedSource* inputSource);
+
+protected:
+  HostFromNetworkOrder16(UsageEnvironment& env, FramedSource* inputSource);
+      // called only by createNew()
+  virtual ~HostFromNetworkOrder16();
+
+private:
+  // Redefined virtual functions:
+  virtual void doGetNextFrame();
+
+private:
+  static void afterGettingFrame(void* clientData, unsigned frameSize,
+				unsigned numTruncatedBytes,
+				struct timeval presentationTime,
+				unsigned durationInMicroseconds);
+  void afterGettingFrame1(unsigned frameSize,
+			  unsigned numTruncatedBytes,
+			  struct timeval presentationTime,
+			  unsigned durationInMicroseconds);
+};
+
+
+////////// 16-bit values: little-endian <-> big-endian //////////
+
+class EndianSwap16: public FramedFilter {
+public:
+  static EndianSwap16* createNew(UsageEnvironment& env, FramedSource* inputSource);
+
+protected:
+  EndianSwap16(UsageEnvironment& env, FramedSource* inputSource);
+      // called only by createNew()
+  virtual ~EndianSwap16();
+
+private:
+  // Redefined virtual functions:
+  virtual void doGetNextFrame();
+
+private:
+  static void afterGettingFrame(void* clientData, unsigned frameSize,
+				unsigned numTruncatedBytes,
+				struct timeval presentationTime,
+				unsigned durationInMicroseconds);
+  void afterGettingFrame1(unsigned frameSize,
+			  unsigned numTruncatedBytes,
+			  struct timeval presentationTime,
+			  unsigned durationInMicroseconds);
+};
+
+
+////////// 24-bit values: little-endian <-> big-endian //////////
+
+class EndianSwap24: public FramedFilter {
+public:
+  static EndianSwap24* createNew(UsageEnvironment& env, FramedSource* inputSource);
+
+protected:
+  EndianSwap24(UsageEnvironment& env, FramedSource* inputSource);
+      // called only by createNew()
+  virtual ~EndianSwap24();
+
+private:
+  // Redefined virtual functions:
+  virtual void doGetNextFrame();
+
+private:
+  static void afterGettingFrame(void* clientData, unsigned frameSize,
+				unsigned numTruncatedBytes,
+				struct timeval presentationTime,
+				unsigned durationInMicroseconds);
+  void afterGettingFrame1(unsigned frameSize,
+			  unsigned numTruncatedBytes,
+			  struct timeval presentationTime,
+			  unsigned durationInMicroseconds);
+};
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/ourMD5.cpp b/3rdparty/live555/src/liveMedia/ourMD5.cpp
new file mode 100644
index 00000000..6ac99a32
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/ourMD5.cpp
@@ -0,0 +1,328 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// Because MD5 may not be implemented (at least, with the same interface) on all systems,
+// we have our own implementation.
+// Implementation
+
+#include "ourMD5.hh"
+#include <NetCommon.h>  // for u_int32_t, u_int64_t
+#include <string.h>
+
+#define DIGEST_SIZE_IN_BYTES 16
+#define DIGEST_SIZE_IN_HEX_DIGITS (2 * DIGEST_SIZE_IN_BYTES)
+#define DIGEST_SIZE_AS_STRING (DIGEST_SIZE_IN_HEX_DIGITS + 1)
+
+// The state of a MD5 computation in progress:
+
+class MD5Context {
+public:
+    MD5Context();
+    ~MD5Context();
+
+    void addData(unsigned char const *inputData, unsigned inputDataSize);
+    void end(char *outputDigest /*must point to an array of size DIGEST_SIZE_AS_STRING*/);
+    void finalize(unsigned char *outputDigestInBytes);
+    // Like "end()", except that the argument is a byte array, of size DIGEST_SIZE_IN_BYTES.
+    // This function is used to implement "end()".
+
+private:
+    void zeroize();                                        // to remove potentially sensitive information
+    void transform64Bytes(unsigned char const block[64]);  // does the actual MD5 transform
+
+private:
+    u_int32_t     fState[4];  // ABCD
+    u_int64_t     fBitCount;  // number of bits, modulo 2^64
+    unsigned char fWorkingBuffer[64];
+};
+
+char *our_MD5Data(unsigned char const *data, unsigned dataSize, char *outputDigest) {
+    MD5Context ctx;
+
+    ctx.addData(data, dataSize);
+
+    if(outputDigest == NULL)
+        outputDigest = new char[DIGEST_SIZE_AS_STRING];
+    ctx.end(outputDigest);
+
+    return outputDigest;
+}
+
+unsigned char *our_MD5DataRaw(unsigned char const *data, unsigned dataSize, unsigned char *outputDigest) {
+    MD5Context ctx;
+
+    ctx.addData(data, dataSize);
+
+    if(outputDigest == NULL)
+        outputDigest = new unsigned char[DIGEST_SIZE_IN_BYTES];
+    ctx.finalize(outputDigest);
+
+    return outputDigest;
+}
+
+////////// MD5Context implementation //////////
+
+MD5Context::MD5Context() : fBitCount(0) {
+    // Initialize with magic constants:
+    fState[0] = 0x67452301;
+    fState[1] = 0xefcdab89;
+    fState[2] = 0x98badcfe;
+    fState[3] = 0x10325476;
+}
+
+MD5Context::~MD5Context() {
+    zeroize();
+}
+
+void MD5Context::addData(unsigned char const *inputData, unsigned inputDataSize) {
+    // Begin by noting how much of our 64-byte working buffer remains unfilled:
+    u_int64_t const byteCount            = fBitCount >> 3;
+    unsigned        bufferBytesInUse     = (unsigned)(byteCount & 0x3F);
+    unsigned        bufferBytesRemaining = 64 - bufferBytesInUse;
+
+    // Then update our bit count:
+    fBitCount += inputDataSize << 3;
+
+    unsigned i = 0;
+    if(inputDataSize >= bufferBytesRemaining) {
+        // We have enough input data to do (64-byte) MD5 transforms.
+        // Do this now, starting with a transform on our working buffer, then with
+        // (as many as possible) transforms on rest of the input data.
+
+        memcpy((unsigned char *)&fWorkingBuffer[bufferBytesInUse], (unsigned char *)inputData, bufferBytesRemaining);
+        transform64Bytes(fWorkingBuffer);
+        bufferBytesInUse = 0;
+
+        for(i = bufferBytesRemaining; i + 63 < inputDataSize; i += 64) {
+            transform64Bytes(&inputData[i]);
+        }
+    }
+
+    // Copy any remaining (and currently un-transformed) input data into our working buffer:
+    if(i < inputDataSize) {
+        memcpy((unsigned char *)&fWorkingBuffer[bufferBytesInUse], (unsigned char *)&inputData[i], inputDataSize - i);
+    }
+}
+
+void MD5Context::end(char *outputDigest) {
+    unsigned char digestInBytes[DIGEST_SIZE_IN_BYTES];
+    finalize(digestInBytes);
+
+    // Convert the digest from bytes (binary) to hex digits:
+    static char const hex[] = "0123456789abcdef";
+    unsigned          i;
+    for(i = 0; i < DIGEST_SIZE_IN_BYTES; ++i) {
+        outputDigest[2 * i]     = hex[digestInBytes[i] >> 4];
+        outputDigest[2 * i + 1] = hex[digestInBytes[i] & 0x0F];
+    }
+    outputDigest[2 * i] = '\0';
+}
+
+// Routines that unpack 32 and 64-bit values into arrays of bytes (in little-endian order).
+// (These are used to implement "finalize()".)
+
+static void unpack32(unsigned char out[4], u_int32_t in) {
+    for(unsigned i = 0; i < 4; ++i) {
+        out[i] = (unsigned char)((in >> (8 * i)) & 0xFF);
+    }
+}
+
+static void unpack64(unsigned char out[8], u_int64_t in) {
+    for(unsigned i = 0; i < 8; ++i) {
+        out[i] = (unsigned char)((in >> (8 * i)) & 0xFF);
+    }
+}
+
+static unsigned char const PADDING[64] = { 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                                           0,    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
+
+void MD5Context::finalize(unsigned char *outputDigestInBytes) {
+    // Unpack our bit count:
+    unsigned char bitCountInBytes[8];
+    unpack64(bitCountInBytes, fBitCount);
+
+    // Before 'finalizing', make sure that we transform any remaining bytes in our working buffer:
+    u_int64_t const byteCount        = fBitCount >> 3;
+    unsigned        bufferBytesInUse = (unsigned)(byteCount & 0x3F);
+    unsigned        numPaddingBytes  = (bufferBytesInUse < 56) ? (56 - bufferBytesInUse) : (64 + 56 - bufferBytesInUse);
+    addData(PADDING, numPaddingBytes);
+
+    addData(bitCountInBytes, 8);
+
+    // Unpack our 'state' into the output digest:
+    unpack32(&outputDigestInBytes[0], fState[0]);
+    unpack32(&outputDigestInBytes[4], fState[1]);
+    unpack32(&outputDigestInBytes[8], fState[2]);
+    unpack32(&outputDigestInBytes[12], fState[3]);
+
+    zeroize();
+}
+
+void MD5Context::zeroize() {
+    fState[0] = fState[1] = fState[2] = fState[3] = 0;
+    fBitCount                                     = 0;
+    for(unsigned i = 0; i < 64; ++i)
+        fWorkingBuffer[i] = 0;
+}
+
+////////// Implementation of the MD5 transform ("MD5Context::transform64Bytes()") //////////
+
+// Constants for the transform:
+#define S11 7
+#define S12 12
+#define S13 17
+#define S14 22
+#define S21 5
+#define S22 9
+#define S23 14
+#define S24 20
+#define S31 4
+#define S32 11
+#define S33 16
+#define S34 23
+#define S41 6
+#define S42 10
+#define S43 15
+#define S44 21
+
+// Basic MD5 functions:
+#define F(x, y, z) (((x) & (y)) | ((~x) & (z)))
+#define G(x, y, z) (((x) & (z)) | ((y) & (~z)))
+#define H(x, y, z) ((x) ^ (y) ^ (z))
+#define I(x, y, z) ((y) ^ ((x) | (~z)))
+
+// Rotate "x" left "n" bits:
+#define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
+
+// Other transforms:
+#define FF(a, b, c, d, x, s, ac)                         \
+    {                                                    \
+        (a) += F((b), (c), (d)) + (x) + (u_int32_t)(ac); \
+        (a) = ROTATE_LEFT((a), (s));                     \
+        (a) += (b);                                      \
+    }
+#define GG(a, b, c, d, x, s, ac)                         \
+    {                                                    \
+        (a) += G((b), (c), (d)) + (x) + (u_int32_t)(ac); \
+        (a) = ROTATE_LEFT((a), (s));                     \
+        (a) += (b);                                      \
+    }
+#define HH(a, b, c, d, x, s, ac)                         \
+    {                                                    \
+        (a) += H((b), (c), (d)) + (x) + (u_int32_t)(ac); \
+        (a) = ROTATE_LEFT((a), (s));                     \
+        (a) += (b);                                      \
+    }
+#define II(a, b, c, d, x, s, ac)                         \
+    {                                                    \
+        (a) += I((b), (c), (d)) + (x) + (u_int32_t)(ac); \
+        (a) = ROTATE_LEFT((a), (s));                     \
+        (a) += (b);                                      \
+    }
+
+void MD5Context::transform64Bytes(unsigned char const block[64]) {
+    u_int32_t a = fState[0], b = fState[1], c = fState[2], d = fState[3];
+
+    // Begin by packing "block" into an array ("x") of 16 32-bit values (in little-endian order):
+    u_int32_t x[16];
+    for(unsigned i = 0, j = 0; i < 16; ++i, j += 4) {
+        x[i] = ((u_int32_t)block[j]) | (((u_int32_t)block[j + 1]) << 8) | (((u_int32_t)block[j + 2]) << 16) | (((u_int32_t)block[j + 3]) << 24);
+    }
+
+    // Now, perform the transform on the array "x":
+
+    // Round 1
+    FF(a, b, c, d, x[0], S11, 0xd76aa478);   // 1
+    FF(d, a, b, c, x[1], S12, 0xe8c7b756);   // 2
+    FF(c, d, a, b, x[2], S13, 0x242070db);   // 3
+    FF(b, c, d, a, x[3], S14, 0xc1bdceee);   // 4
+    FF(a, b, c, d, x[4], S11, 0xf57c0faf);   // 5
+    FF(d, a, b, c, x[5], S12, 0x4787c62a);   // 6
+    FF(c, d, a, b, x[6], S13, 0xa8304613);   // 7
+    FF(b, c, d, a, x[7], S14, 0xfd469501);   // 8
+    FF(a, b, c, d, x[8], S11, 0x698098d8);   // 9
+    FF(d, a, b, c, x[9], S12, 0x8b44f7af);   // 10
+    FF(c, d, a, b, x[10], S13, 0xffff5bb1);  // 11
+    FF(b, c, d, a, x[11], S14, 0x895cd7be);  // 12
+    FF(a, b, c, d, x[12], S11, 0x6b901122);  // 13
+    FF(d, a, b, c, x[13], S12, 0xfd987193);  // 14
+    FF(c, d, a, b, x[14], S13, 0xa679438e);  // 15
+    FF(b, c, d, a, x[15], S14, 0x49b40821);  // 16
+
+    // Round 2
+    GG(a, b, c, d, x[1], S21, 0xf61e2562);   // 17
+    GG(d, a, b, c, x[6], S22, 0xc040b340);   // 18
+    GG(c, d, a, b, x[11], S23, 0x265e5a51);  // 19
+    GG(b, c, d, a, x[0], S24, 0xe9b6c7aa);   // 20
+    GG(a, b, c, d, x[5], S21, 0xd62f105d);   // 21
+    GG(d, a, b, c, x[10], S22, 0x2441453);   // 22
+    GG(c, d, a, b, x[15], S23, 0xd8a1e681);  // 23
+    GG(b, c, d, a, x[4], S24, 0xe7d3fbc8);   // 24
+    GG(a, b, c, d, x[9], S21, 0x21e1cde6);   // 25
+    GG(d, a, b, c, x[14], S22, 0xc33707d6);  // 26
+    GG(c, d, a, b, x[3], S23, 0xf4d50d87);   // 27
+    GG(b, c, d, a, x[8], S24, 0x455a14ed);   // 28
+    GG(a, b, c, d, x[13], S21, 0xa9e3e905);  // 29
+    GG(d, a, b, c, x[2], S22, 0xfcefa3f8);   // 30
+    GG(c, d, a, b, x[7], S23, 0x676f02d9);   // 31
+    GG(b, c, d, a, x[12], S24, 0x8d2a4c8a);  // 32
+
+    // Round 3
+    HH(a, b, c, d, x[5], S31, 0xfffa3942);   // 33
+    HH(d, a, b, c, x[8], S32, 0x8771f681);   // 34
+    HH(c, d, a, b, x[11], S33, 0x6d9d6122);  // 35
+    HH(b, c, d, a, x[14], S34, 0xfde5380c);  // 36
+    HH(a, b, c, d, x[1], S31, 0xa4beea44);   // 37
+    HH(d, a, b, c, x[4], S32, 0x4bdecfa9);   // 38
+    HH(c, d, a, b, x[7], S33, 0xf6bb4b60);   // 39
+    HH(b, c, d, a, x[10], S34, 0xbebfbc70);  // 40
+    HH(a, b, c, d, x[13], S31, 0x289b7ec6);  // 41
+    HH(d, a, b, c, x[0], S32, 0xeaa127fa);   // 42
+    HH(c, d, a, b, x[3], S33, 0xd4ef3085);   // 43
+    HH(b, c, d, a, x[6], S34, 0x4881d05);    // 44
+    HH(a, b, c, d, x[9], S31, 0xd9d4d039);   // 45
+    HH(d, a, b, c, x[12], S32, 0xe6db99e5);  // 46
+    HH(c, d, a, b, x[15], S33, 0x1fa27cf8);  // 47
+    HH(b, c, d, a, x[2], S34, 0xc4ac5665);   // 48
+
+    // Round 4
+    II(a, b, c, d, x[0], S41, 0xf4292244);   // 49
+    II(d, a, b, c, x[7], S42, 0x432aff97);   // 50
+    II(c, d, a, b, x[14], S43, 0xab9423a7);  // 51
+    II(b, c, d, a, x[5], S44, 0xfc93a039);   // 52
+    II(a, b, c, d, x[12], S41, 0x655b59c3);  // 53
+    II(d, a, b, c, x[3], S42, 0x8f0ccc92);   // 54
+    II(c, d, a, b, x[10], S43, 0xffeff47d);  // 55
+    II(b, c, d, a, x[1], S44, 0x85845dd1);   // 56
+    II(a, b, c, d, x[8], S41, 0x6fa87e4f);   // 57
+    II(d, a, b, c, x[15], S42, 0xfe2ce6e0);  // 58
+    II(c, d, a, b, x[6], S43, 0xa3014314);   // 59
+    II(b, c, d, a, x[13], S44, 0x4e0811a1);  // 60
+    II(a, b, c, d, x[4], S41, 0xf7537e82);   // 61
+    II(d, a, b, c, x[11], S42, 0xbd3af235);  // 62
+    II(c, d, a, b, x[2], S43, 0x2ad7d2bb);   // 63
+    II(b, c, d, a, x[9], S44, 0xeb86d391);   // 64
+
+    fState[0] += a;
+    fState[1] += b;
+    fState[2] += c;
+    fState[3] += d;
+
+    // Zeroize sensitive information.
+    for(unsigned k = 0; k < 16; ++k)
+        x[k] = 0;
+}
diff --git a/3rdparty/live555/src/liveMedia/rtcp_from_spec.c b/3rdparty/live555/src/liveMedia/rtcp_from_spec.c
new file mode 100644
index 00000000..58caab4b
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/rtcp_from_spec.c
@@ -0,0 +1,250 @@
+/* RTCP code taken directly from the most recent RTP specification: RFC 3550
+ *         Copyright (C) The Internet Society (2003).  All Rights Reserved.
+ * Implementation
+ */
+
+#include "rtcp_from_spec.h"
+
+/*****
+
+A.7 Computing the RTCP Transmission Interval
+
+   The following functions implement the RTCP transmission and reception
+   rules described in Section 6.2. These rules are coded in several
+   functions:
+
+       o  rtcp_interval() computes the deterministic calculated
+          interval, measured in seconds.  The parameters are defined in
+          Section 6.3.
+
+       o  OnExpire() is called when the RTCP transmission timer expires.
+
+       o  OnReceive() is called whenever an RTCP packet is received.
+
+   Both OnExpire() and OnReceive() have event e as an argument. This is
+   the next scheduled event for that participant, either an RTCP report
+   or a BYE packet.  It is assumed that the following functions are
+   available:
+
+       o  Schedule(time t, event e) schedules an event e to occur at
+          time t. When time t arrives, the function OnExpire is called
+          with e as an argument.
+
+       o  Reschedule(time t, event e) reschedules a previously scheduled
+          event e for time t.
+
+       o  SendRTCPReport(event e) sends an RTCP report.
+
+       o  SendBYEPacket(event e) sends a BYE packet.
+
+       o  TypeOfEvent(event e) returns EVENT_BYE if the event being
+          processed is for a BYE packet to be sent, else it returns
+          EVENT_REPORT.
+
+       o  PacketType(p) returns PACKET_RTCP_REPORT if packet p is an
+          RTCP report (not BYE), PACKET_BYE if its a BYE RTCP packet,
+          and PACKET_RTP if its a regular RTP data packet.
+
+       o  ReceivedPacketSize() and SentPacketSize() return the size of
+          the referenced packet in octets.
+
+       o  NewMember(p) returns a 1 if the participant who sent packet p
+          is not currently in the member list, 0 otherwise. Note this
+          function is not sufficient for a complete implementation
+          because each CSRC identifier in an RTP packet and each SSRC in
+          a BYE packet should be processed.
+
+       o  NewSender(p) returns a 1 if the participant who sent packet p
+          is not currently in the sender sublist of the member list, 0
+          otherwise.
+
+       o  AddMember() and RemoveMember() to add and remove participants
+          from the member list.
+
+       o  AddSender() and RemoveSender() to add and remove participants
+          from the sender sublist of the member list.
+*****/
+
+double rtcp_interval(int members, int senders, double rtcp_bw, int we_sent, double avg_rtcp_size, int initial) {
+    /*
+     * Minimum average time between RTCP packets from this site (in
+     * seconds).  This time prevents the reports from `clumping' when
+     * sessions are small and the law of large numbers isn't helping
+     * to smooth out the traffic.  It also keeps the report interval
+     * from becoming ridiculously small during transient outages like
+     * a network partition.
+     */
+    double const RTCP_MIN_TIME = 5.;
+    /*
+     * Fraction of the RTCP bandwidth to be shared among active
+     * senders.  (This fraction was chosen so that in a typical
+     * session with one or two active senders, the computed report
+     * time would be roughly equal to the minimum report time so that
+     * we don't unnecessarily slow down receiver reports.) The
+     * receiver fraction must be 1 - the sender fraction.
+     */
+    double const RTCP_SENDER_BW_FRACTION = 0.25;
+    double const RTCP_RCVR_BW_FRACTION   = (1 - RTCP_SENDER_BW_FRACTION);
+    /*
+     * To compensate for "unconditional reconsideration" converging to a
+     * value below the intended average.
+     */
+    double const COMPENSATION = 2.71828 - 1.5;
+
+    double t; /* interval */
+    double rtcp_min_time = RTCP_MIN_TIME;
+    int    n; /* no. of members for computation */
+
+    /*
+     * Very first call at application start-up uses half the min
+     * delay for quicker notification while still allowing some time
+     * before reporting for randomization and to learn about other
+     * sources so the report interval will converge to the correct
+     * interval more quickly.
+     */
+    if(initial) {
+        rtcp_min_time /= 2;
+    }
+
+    /*
+     * If there were active senders, give them at least a minimum
+     * share of the RTCP bandwidth.  Otherwise all participants share
+     * the RTCP bandwidth equally.
+     */
+    n = members;
+    if(senders > 0 && senders < members * RTCP_SENDER_BW_FRACTION) {
+        if(we_sent) {
+            rtcp_bw *= RTCP_SENDER_BW_FRACTION;
+            n = senders;
+        }
+        else {
+            rtcp_bw *= RTCP_RCVR_BW_FRACTION;
+            n -= senders;
+        }
+    }
+
+    /*
+     * The effective number of sites times the average packet size is
+     * the total number of octets sent when each site sends a report.
+     * Dividing this by the effective bandwidth gives the time
+     * interval over which those packets must be sent in order to
+     * meet the bandwidth target, with a minimum enforced.  In that
+     * time interval we send one report so this time is also our
+     * average time between reports.
+     */
+    t = avg_rtcp_size * n / rtcp_bw;
+    if(t < rtcp_min_time)
+        t = rtcp_min_time;
+
+    /*
+     * To avoid traffic bursts from unintended synchronization with
+     * other sites, we then pick our actual next report interval as a
+     * random number uniformly distributed between 0.5*t and 1.5*t.
+     */
+    t = t * (drand48() + 0.5);
+    t = t / COMPENSATION;
+    return t;
+}
+
+void OnExpire(event e, int members, int senders, double rtcp_bw, int we_sent, double *avg_rtcp_size, int *initial, time_tp tc, time_tp *tp, int *pmembers) {
+    /* This function is responsible for deciding whether to send
+     * an RTCP report or BYE packet now, or to reschedule transmission.
+     * It is also responsible for updating the pmembers, initial, tp,
+     * and avg_rtcp_size state variables. This function should be called
+     * upon expiration of the event timer used by Schedule(). */
+
+    double t;  /* Interval */
+    double tn; /* Next transmit time */
+
+    /* In the case of a BYE, we use "unconditional reconsideration" to
+     * reschedule the transmission of the BYE if necessary */
+
+    if(TypeOfEvent(e) == EVENT_BYE) {
+        t  = rtcp_interval(members, senders, rtcp_bw, we_sent, *avg_rtcp_size, *initial);
+        tn = *tp + t;
+        if(tn <= tc) {
+            SendBYEPacket(e);
+            exit(1);
+        }
+        else {
+            Schedule(tn, e);
+        }
+    }
+    else if(TypeOfEvent(e) == EVENT_REPORT) {
+        t  = rtcp_interval(members, senders, rtcp_bw, we_sent, *avg_rtcp_size, *initial);
+        tn = *tp + t;
+
+        if(tn <= tc) {
+            SendRTCPReport(e);
+            *avg_rtcp_size = (1. / 16.) * SentPacketSize(e) + (15. / 16.) * (*avg_rtcp_size);
+            *tp            = tc;
+
+            /* We must redraw the interval. Don't reuse the
+               one computed above, since its not actually
+               distributed the same, as we are conditioned
+               on it being small enough to cause a packet to
+               be sent */
+
+            t = rtcp_interval(members, senders, rtcp_bw, we_sent, *avg_rtcp_size, *initial);
+
+            Schedule(t + tc, e);
+            *initial = 0;
+        }
+        else {
+            Schedule(tn, e);
+        }
+        *pmembers = members;
+    }
+}
+
+void OnReceive(packet p, event e, int *members, int *pmembers, int *senders, double *avg_rtcp_size, double *tp, double tc, double tn) {
+    /* What we do depends on whether we have left the group, and
+     * are waiting to send a BYE (TypeOfEvent(e) == EVENT_BYE) or
+     * an RTCP report. p represents the packet that was just received. */
+
+    if(PacketType(p) == PACKET_RTCP_REPORT) {
+        if(NewMember(p) && (TypeOfEvent(e) == EVENT_REPORT)) {
+            AddMember(p);
+            *members += 1;
+        }
+        *avg_rtcp_size = (1. / 16.) * ReceivedPacketSize(p) + (15. / 16.) * (*avg_rtcp_size);
+    }
+    else if(PacketType(p) == PACKET_RTP) {
+        if(NewMember(p) && (TypeOfEvent(e) == EVENT_REPORT)) {
+            AddMember(p);
+            *members += 1;
+        }
+        if(NewSender(p) && (TypeOfEvent(e) == EVENT_REPORT)) {
+            AddSender(p);
+            *senders += 1;
+        }
+    }
+    else if(PacketType(p) == PACKET_BYE) {
+        *avg_rtcp_size = (1. / 16.) * ReceivedPacketSize(p) + (15. / 16.) * (*avg_rtcp_size);
+
+        if(TypeOfEvent(e) == EVENT_REPORT) {
+            if(NewSender(p) == FALSE) {
+                RemoveSender(p);
+                *senders -= 1;
+            }
+
+            if(NewMember(p) == FALSE) {
+                RemoveMember(p);
+                *members -= 1;
+            }
+
+            if(*members < *pmembers) {
+                tn  = tc + (((double)*members) / (*pmembers)) * (tn - tc);
+                *tp = tc - (((double)*members) / (*pmembers)) * (tc - *tp);
+
+                /* Reschedule the next report for time tn */
+
+                Reschedule(tn, e);
+                *pmembers = *members;
+            }
+        }
+        else if(TypeOfEvent(e) == EVENT_BYE) {
+            *members += 1;
+        }
+    }
+}
diff --git a/3rdparty/live555/src/liveMedia/rtcp_from_spec.h b/3rdparty/live555/src/liveMedia/rtcp_from_spec.h
new file mode 100644
index 00000000..323c0612
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/rtcp_from_spec.h
@@ -0,0 +1,102 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+/*
+ * "liveMedia"
+ * Copyright (c) 1996-2022, Live Networks, Inc.  All rights reserved
+ *
+ * RTCP code taken directly from the most recent RTP specification: RFC 3550
+ * C header
+ */
+
+#ifndef _RTCP_FROM_SPEC_H
+#define _RTCP_FROM_SPEC_H
+
+#include <stdlib.h>
+
+/* Definitions of _ANSI_ARGS and EXTERN that will work in either
+   C or C++ code:
+ */
+#undef _ANSI_ARGS_
+#if((defined(__STDC__) || defined(SABER)) && !defined(NO_PROTOTYPE)) || defined(__cplusplus) || defined(USE_PROTOTYPE)
+#define _ANSI_ARGS_(x) x
+#else
+#define _ANSI_ARGS_(x) ()
+#endif
+#ifdef __cplusplus
+#define EXTERN extern "C"
+#else
+#define EXTERN extern
+#endif
+
+/* The code from the spec assumes a type "event"; make this a void*: */
+typedef void *event;
+
+#define EVENT_UNKNOWN 0
+#define EVENT_REPORT 1
+#define EVENT_BYE 2
+
+/* The code from the spec assumes a type "time_tp"; make this a double: */
+typedef double time_tp;
+
+/* The code from the spec assumes a type "packet"; make this a void*: */
+typedef void *packet;
+
+#define PACKET_UNKNOWN_TYPE 0
+#define PACKET_RTP 1
+#define PACKET_RTCP_REPORT 2
+#define PACKET_BYE 3
+#define PACKET_RTCP_APP 4
+
+/* The code from the spec calls drand48(), but we have drand30() instead */
+#define drand48 drand30
+
+/* The code calls "exit()", but we don't want to exit, so make it a noop: */
+#define exit(n) \
+    do {        \
+    } while(0)
+
+#ifndef FALSE
+#define FALSE 0
+#endif
+#ifndef TRUE
+#define TRUE 1
+#endif
+
+/* EXPORTS: */
+
+EXTERN void OnExpire _ANSI_ARGS_((event, int, int, double, int, double *, int *, time_tp, time_tp *, int *));
+
+EXTERN void OnReceive _ANSI_ARGS_((packet, event, int *, int *, int *, double *, double *, double, double));
+
+/* IMPORTS: */
+
+EXTERN void Schedule          _ANSI_ARGS_((double, event));
+EXTERN void Reschedule        _ANSI_ARGS_((double, event));
+EXTERN void SendRTCPReport    _ANSI_ARGS_((event));
+EXTERN void SendBYEPacket     _ANSI_ARGS_((event));
+EXTERN int TypeOfEvent        _ANSI_ARGS_((event));
+EXTERN int SentPacketSize     _ANSI_ARGS_((event));
+EXTERN int PacketType         _ANSI_ARGS_((packet));
+EXTERN int ReceivedPacketSize _ANSI_ARGS_((packet));
+EXTERN int NewMember          _ANSI_ARGS_((packet));
+EXTERN int NewSender          _ANSI_ARGS_((packet));
+EXTERN void AddMember         _ANSI_ARGS_((packet));
+EXTERN void AddSender         _ANSI_ARGS_((packet));
+EXTERN void RemoveMember      _ANSI_ARGS_((packet));
+EXTERN void RemoveSender      _ANSI_ARGS_((packet));
+EXTERN double drand30         _ANSI_ARGS_((void));
+
+#endif
diff --git a/3rdparty/live555/src/liveMedia/uLawAudioFilter.cpp b/3rdparty/live555/src/liveMedia/uLawAudioFilter.cpp
new file mode 100644
index 00000000..ca99a03f
--- /dev/null
+++ b/3rdparty/live555/src/liveMedia/uLawAudioFilter.cpp
@@ -0,0 +1,345 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2022 Live Networks, Inc.  All rights reserved.
+// Filters for converting between raw PCM audio and uLaw
+// Implementation
+
+#include "uLawAudioFilter.hh"
+
+////////// 16-bit PCM (in various byte orders) -> 8-bit u-Law //////////
+
+uLawFromPCMAudioSource *uLawFromPCMAudioSource ::createNew(UsageEnvironment &env, FramedSource *inputSource, int byteOrdering) {
+    // "byteOrdering" must be 0, 1, or 2:
+    if(byteOrdering < 0 || byteOrdering > 2) {
+        env.setResultMsg("uLawFromPCMAudioSource::createNew(): bad \"byteOrdering\" parameter");
+        return NULL;
+    }
+    return new uLawFromPCMAudioSource(env, inputSource, byteOrdering);
+}
+
+uLawFromPCMAudioSource ::uLawFromPCMAudioSource(UsageEnvironment &env, FramedSource *inputSource, int byteOrdering)
+    : FramedFilter(env, inputSource), fByteOrdering(byteOrdering), fInputBuffer(NULL), fInputBufferSize(0) {}
+
+uLawFromPCMAudioSource::~uLawFromPCMAudioSource() {
+    delete[] fInputBuffer;
+}
+
+void uLawFromPCMAudioSource::doGetNextFrame() {
+    // Figure out how many bytes of input data to ask for, and increase
+    // our input buffer if necessary:
+    unsigned bytesToRead = fMaxSize * 2;  // because we're converting 16 bits->8
+    if(bytesToRead > fInputBufferSize) {
+        delete[] fInputBuffer;
+        fInputBuffer     = new unsigned char[bytesToRead];
+        fInputBufferSize = bytesToRead;
+    }
+
+    // Arrange to read samples into the input buffer:
+    fInputSource->getNextFrame(fInputBuffer, bytesToRead, afterGettingFrame, this, FramedSource::handleClosure, this);
+}
+
+void uLawFromPCMAudioSource ::afterGettingFrame(void *clientData, unsigned frameSize, unsigned numTruncatedBytes, struct timeval presentationTime,
+                                                unsigned durationInMicroseconds) {
+    uLawFromPCMAudioSource *source = (uLawFromPCMAudioSource *)clientData;
+    source->afterGettingFrame1(frameSize, numTruncatedBytes, presentationTime, durationInMicroseconds);
+}
+
+#define BIAS 0x84  // the add-in bias for 16 bit samples
+#define CLIP 32635
+
+static unsigned char uLawFrom16BitLinear(u_int16_t sample) {
+    static int const exp_lut[256] = { 0, 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5,
+                                      5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+                                      6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+                                      6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+                                      7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+                                      7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+                                      7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7 };
+    unsigned char    sign         = (sample >> 8) & 0x80;
+    if(sign != 0)
+        sample = -sample;  // get the magnitude
+
+    if(sample > CLIP)
+        sample = CLIP;  // clip the magnitude
+    sample += BIAS;
+
+    unsigned char exponent = exp_lut[(sample >> 7) & 0xFF];
+    unsigned char mantissa = (sample >> (exponent + 3)) & 0x0F;
+    unsigned char result   = ~(sign | (exponent << 4) | mantissa);
+    if(result == 0)
+        result = 0x02;  // CCITT trap
+
+    return result;
+}
+
+void uLawFromPCMAudioSource ::afterGettingFrame1(unsigned frameSize, unsigned numTruncatedBytes, struct timeval presentationTime,
+                                                 unsigned durationInMicroseconds) {
+    // Translate raw 16-bit PCM samples (in the input buffer)
+    // into uLaw samples (in the output buffer).
+    unsigned numSamples = frameSize / 2;
+    switch(fByteOrdering) {
+    case 0: {  // host order
+        u_int16_t *inputSample = (u_int16_t *)fInputBuffer;
+        for(unsigned i = 0; i < numSamples; ++i) {
+            fTo[i] = uLawFrom16BitLinear(inputSample[i]);
+        }
+        break;
+    }
+    case 1: {  // little-endian order
+        for(unsigned i = 0; i < numSamples; ++i) {
+            u_int16_t const newValue = (fInputBuffer[2 * i + 1] << 8) | fInputBuffer[2 * i];
+            fTo[i]                   = uLawFrom16BitLinear(newValue);
+        }
+        break;
+    }
+    case 2: {  // network (i.e., big-endian) order
+        for(unsigned i = 0; i < numSamples; ++i) {
+            u_int16_t const newValue = (fInputBuffer[2 * i] << 8) | fInputBuffer[2 * i + i];
+            fTo[i]                   = uLawFrom16BitLinear(newValue);
+        }
+        break;
+    }
+    }
+
+    // Complete delivery to the client:
+    fFrameSize              = numSamples;
+    fNumTruncatedBytes      = numTruncatedBytes;
+    fPresentationTime       = presentationTime;
+    fDurationInMicroseconds = durationInMicroseconds;
+    afterGetting(this);
+}
+
+////////// u-Law -> 16-bit PCM (in host order) //////////
+
+PCMFromuLawAudioSource *PCMFromuLawAudioSource ::createNew(UsageEnvironment &env, FramedSource *inputSource) {
+    return new PCMFromuLawAudioSource(env, inputSource);
+}
+
+PCMFromuLawAudioSource ::PCMFromuLawAudioSource(UsageEnvironment &env, FramedSource *inputSource)
+    : FramedFilter(env, inputSource), fInputBuffer(NULL), fInputBufferSize(0) {}
+
+PCMFromuLawAudioSource::~PCMFromuLawAudioSource() {
+    delete[] fInputBuffer;
+}
+
+void PCMFromuLawAudioSource::doGetNextFrame() {
+    // Figure out how many bytes of input data to ask for, and increase
+    // our input buffer if necessary:
+    unsigned bytesToRead = fMaxSize / 2;  // because we're converting 8 bits->16
+    if(bytesToRead > fInputBufferSize) {
+        delete[] fInputBuffer;
+        fInputBuffer     = new unsigned char[bytesToRead];
+        fInputBufferSize = bytesToRead;
+    }
+
+    // Arrange to read samples into the input buffer:
+    fInputSource->getNextFrame(fInputBuffer, bytesToRead, afterGettingFrame, this, FramedSource::handleClosure, this);
+}
+
+void PCMFromuLawAudioSource ::afterGettingFrame(void *clientData, unsigned frameSize, unsigned numTruncatedBytes, struct timeval presentationTime,
+                                                unsigned durationInMicroseconds) {
+    PCMFromuLawAudioSource *source = (PCMFromuLawAudioSource *)clientData;
+    source->afterGettingFrame1(frameSize, numTruncatedBytes, presentationTime, durationInMicroseconds);
+}
+
+static u_int16_t linear16FromuLaw(unsigned char uLawByte) {
+    static int const exp_lut[8] = { 0, 132, 396, 924, 1980, 4092, 8316, 16764 };
+    uLawByte                    = ~uLawByte;
+
+    Boolean       sign     = (uLawByte & 0x80) != 0;
+    unsigned char exponent = (uLawByte >> 4) & 0x07;
+    unsigned char mantissa = uLawByte & 0x0F;
+
+    u_int16_t result = exp_lut[exponent] + (mantissa << (exponent + 3));
+    if(sign)
+        result = -result;
+    return result;
+}
+
+void PCMFromuLawAudioSource ::afterGettingFrame1(unsigned frameSize, unsigned numTruncatedBytes, struct timeval presentationTime,
+                                                 unsigned durationInMicroseconds) {
+    // Translate uLaw samples (in the input buffer)
+    // into 16-bit PCM samples (in the output buffer), in host order.
+    unsigned   numSamples   = frameSize;
+    u_int16_t *outputSample = (u_int16_t *)fTo;
+    for(unsigned i = 0; i < numSamples; ++i) {
+        outputSample[i] = linear16FromuLaw(fInputBuffer[i]);
+    }
+
+    // Complete delivery to the client:
+    fFrameSize              = numSamples * 2;
+    fNumTruncatedBytes      = numTruncatedBytes;
+    fPresentationTime       = presentationTime;
+    fDurationInMicroseconds = durationInMicroseconds;
+    afterGetting(this);
+}
+
+////////// 16-bit values (in host order) -> 16-bit network order //////////
+
+NetworkFromHostOrder16 *NetworkFromHostOrder16 ::createNew(UsageEnvironment &env, FramedSource *inputSource) {
+    return new NetworkFromHostOrder16(env, inputSource);
+}
+
+NetworkFromHostOrder16 ::NetworkFromHostOrder16(UsageEnvironment &env, FramedSource *inputSource) : FramedFilter(env, inputSource) {}
+
+NetworkFromHostOrder16::~NetworkFromHostOrder16() {}
+
+void NetworkFromHostOrder16::doGetNextFrame() {
+    // Arrange to read data directly into the client's buffer:
+    fInputSource->getNextFrame(fTo, fMaxSize, afterGettingFrame, this, FramedSource::handleClosure, this);
+}
+
+void NetworkFromHostOrder16 ::afterGettingFrame(void *clientData, unsigned frameSize, unsigned numTruncatedBytes, struct timeval presentationTime,
+                                                unsigned durationInMicroseconds) {
+    NetworkFromHostOrder16 *source = (NetworkFromHostOrder16 *)clientData;
+    source->afterGettingFrame1(frameSize, numTruncatedBytes, presentationTime, durationInMicroseconds);
+}
+
+void NetworkFromHostOrder16 ::afterGettingFrame1(unsigned frameSize, unsigned numTruncatedBytes, struct timeval presentationTime,
+                                                 unsigned durationInMicroseconds) {
+    // Translate the 16-bit values that we have just read from host
+    // to network order (in-place)
+    unsigned   numValues = frameSize / 2;
+    u_int16_t *value     = (u_int16_t *)fTo;
+    for(unsigned i = 0; i < numValues; ++i) {
+        value[i] = htons(value[i]);
+    }
+
+    // Complete delivery to the client:
+    fFrameSize              = numValues * 2;
+    fNumTruncatedBytes      = numTruncatedBytes;
+    fPresentationTime       = presentationTime;
+    fDurationInMicroseconds = durationInMicroseconds;
+    afterGetting(this);
+}
+
+////////// 16-bit values (in network order) -> 16-bit host order //////////
+
+HostFromNetworkOrder16 *HostFromNetworkOrder16 ::createNew(UsageEnvironment &env, FramedSource *inputSource) {
+    return new HostFromNetworkOrder16(env, inputSource);
+}
+
+HostFromNetworkOrder16 ::HostFromNetworkOrder16(UsageEnvironment &env, FramedSource *inputSource) : FramedFilter(env, inputSource) {}
+
+HostFromNetworkOrder16::~HostFromNetworkOrder16() {}
+
+void HostFromNetworkOrder16::doGetNextFrame() {
+    // Arrange to read data directly into the client's buffer:
+    fInputSource->getNextFrame(fTo, fMaxSize, afterGettingFrame, this, FramedSource::handleClosure, this);
+}
+
+void HostFromNetworkOrder16 ::afterGettingFrame(void *clientData, unsigned frameSize, unsigned numTruncatedBytes, struct timeval presentationTime,
+                                                unsigned durationInMicroseconds) {
+    HostFromNetworkOrder16 *source = (HostFromNetworkOrder16 *)clientData;
+    source->afterGettingFrame1(frameSize, numTruncatedBytes, presentationTime, durationInMicroseconds);
+}
+
+void HostFromNetworkOrder16 ::afterGettingFrame1(unsigned frameSize, unsigned numTruncatedBytes, struct timeval presentationTime,
+                                                 unsigned durationInMicroseconds) {
+    // Translate the 16-bit values that we have just read from network
+    // to host order (in-place):
+    unsigned   numValues = frameSize / 2;
+    u_int16_t *value     = (u_int16_t *)fTo;
+    for(unsigned i = 0; i < numValues; ++i) {
+        value[i] = ntohs(value[i]);
+    }
+
+    // Complete delivery to the client:
+    fFrameSize              = numValues * 2;
+    fNumTruncatedBytes      = numTruncatedBytes;
+    fPresentationTime       = presentationTime;
+    fDurationInMicroseconds = durationInMicroseconds;
+    afterGetting(this);
+}
+
+////////// 16-bit values: little-endian <-> big-endian //////////
+
+EndianSwap16 *EndianSwap16::createNew(UsageEnvironment &env, FramedSource *inputSource) {
+    return new EndianSwap16(env, inputSource);
+}
+
+EndianSwap16::EndianSwap16(UsageEnvironment &env, FramedSource *inputSource) : FramedFilter(env, inputSource) {}
+
+EndianSwap16::~EndianSwap16() {}
+
+void EndianSwap16::doGetNextFrame() {
+    // Arrange to read data directly into the client's buffer:
+    fInputSource->getNextFrame(fTo, fMaxSize, afterGettingFrame, this, FramedSource::handleClosure, this);
+}
+
+void EndianSwap16::afterGettingFrame(void *clientData, unsigned frameSize, unsigned numTruncatedBytes, struct timeval presentationTime,
+                                     unsigned durationInMicroseconds) {
+    EndianSwap16 *source = (EndianSwap16 *)clientData;
+    source->afterGettingFrame1(frameSize, numTruncatedBytes, presentationTime, durationInMicroseconds);
+}
+
+void EndianSwap16::afterGettingFrame1(unsigned frameSize, unsigned numTruncatedBytes, struct timeval presentationTime, unsigned durationInMicroseconds) {
+    // Swap the byte order of the 16-bit values that we have just read (in place):
+    unsigned   numValues = frameSize / 2;
+    u_int16_t *value     = (u_int16_t *)fTo;
+    for(unsigned i = 0; i < numValues; ++i) {
+        u_int16_t const orig = value[i];
+        value[i]             = ((orig & 0xFF) << 8) | ((orig & 0xFF00) >> 8);
+    }
+
+    // Complete delivery to the client:
+    fFrameSize              = numValues * 2;
+    fNumTruncatedBytes      = numTruncatedBytes + (frameSize - fFrameSize);
+    fPresentationTime       = presentationTime;
+    fDurationInMicroseconds = durationInMicroseconds;
+    afterGetting(this);
+}
+
+////////// 24-bit values: little-endian <-> big-endian //////////
+
+EndianSwap24 *EndianSwap24::createNew(UsageEnvironment &env, FramedSource *inputSource) {
+    return new EndianSwap24(env, inputSource);
+}
+
+EndianSwap24::EndianSwap24(UsageEnvironment &env, FramedSource *inputSource) : FramedFilter(env, inputSource) {}
+
+EndianSwap24::~EndianSwap24() {}
+
+void EndianSwap24::doGetNextFrame() {
+    // Arrange to read data directly into the client's buffer:
+    fInputSource->getNextFrame(fTo, fMaxSize, afterGettingFrame, this, FramedSource::handleClosure, this);
+}
+
+void EndianSwap24::afterGettingFrame(void *clientData, unsigned frameSize, unsigned numTruncatedBytes, struct timeval presentationTime,
+                                     unsigned durationInMicroseconds) {
+    EndianSwap24 *source = (EndianSwap24 *)clientData;
+    source->afterGettingFrame1(frameSize, numTruncatedBytes, presentationTime, durationInMicroseconds);
+}
+
+void EndianSwap24::afterGettingFrame1(unsigned frameSize, unsigned numTruncatedBytes, struct timeval presentationTime, unsigned durationInMicroseconds) {
+    // Swap the byte order of the 24-bit values that we have just read (in place):
+    unsigned const numValues = frameSize / 3;
+    u_int8_t *     p         = fTo;
+    for(unsigned i = 0; i < numValues; ++i) {
+        u_int8_t tmp = p[0];
+        p[0]         = p[2];
+        p[2]         = tmp;
+        p += 3;
+    }
+
+    // Complete delivery to the client:
+    fFrameSize              = numValues * 3;
+    fNumTruncatedBytes      = numTruncatedBytes + (frameSize - fFrameSize);
+    fPresentationTime       = presentationTime;
+    fDurationInMicroseconds = durationInMicroseconds;
+    afterGetting(this);
+}
diff --git a/3rdparty/live555/src/mediaServer/CMakeLists.txt b/3rdparty/live555/src/mediaServer/CMakeLists.txt
new file mode 100644
index 00000000..0607475e
--- /dev/null
+++ b/3rdparty/live555/src/mediaServer/CMakeLists.txt
@@ -0,0 +1,13 @@
+cmake_minimum_required(VERSION 3.0.0)
+
+aux_source_directory(./ MEDIA_SERVER_SRCS)
+add_executable(mediaServer ${MEDIA_SERVER_SRCS})
+
+target_link_libraries(mediaServer PRIVATE live555)
+target_include_directories(mediaServer
+    PRIVATE
+    ${LIVE555_INCLUDE_DIRS}
+)
+# if (WIN32)
+#     target_link_libraries(mediaServer PRIVATE Ws2_32)
+# endif ()
\ No newline at end of file
diff --git a/3rdparty/live555/src/mediaServer/DynamicRTSPServer.cpp b/3rdparty/live555/src/mediaServer/DynamicRTSPServer.cpp
new file mode 100644
index 00000000..d70401c2
--- /dev/null
+++ b/3rdparty/live555/src/mediaServer/DynamicRTSPServer.cpp
@@ -0,0 +1,249 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// Copyright (c) 1996-2022, Live Networks, Inc.  All rights reserved
+// A subclass of "RTSPServer" that creates "ServerMediaSession"s on demand,
+// based on whether or not the specified stream name exists as a file
+// Implementation
+
+#include "DynamicRTSPServer.hh"
+#include <liveMedia.hh>
+#include <string.h>
+
+DynamicRTSPServer *DynamicRTSPServer::createNew(UsageEnvironment &env, Port ourPort, UserAuthenticationDatabase *authDatabase,
+                                                unsigned reclamationTestSeconds) {
+    int ourSocketIPv4 = setUpOurSocket(env, ourPort, AF_INET);
+    int ourSocketIPv6 = setUpOurSocket(env, ourPort, AF_INET6);
+    if(ourSocketIPv4 < 0 && ourSocketIPv6 < 0)
+        return NULL;
+
+    return new DynamicRTSPServer(env, ourSocketIPv4, ourSocketIPv6, ourPort, authDatabase, reclamationTestSeconds);
+}
+
+DynamicRTSPServer::DynamicRTSPServer(UsageEnvironment &env, int ourSocketIPv4, int ourSocketIPv6, Port ourPort, UserAuthenticationDatabase *authDatabase,
+                                     unsigned reclamationTestSeconds)
+    : RTSPServer(env, ourSocketIPv4, ourSocketIPv6, ourPort, authDatabase, reclamationTestSeconds) {}
+
+DynamicRTSPServer::~DynamicRTSPServer() {}
+
+static ServerMediaSession *createNewSMS(UsageEnvironment &env, char const *fileName, FILE *fid);  // forward
+
+void DynamicRTSPServer ::lookupServerMediaSession(char const *streamName, lookupServerMediaSessionCompletionFunc *completionFunc, void *completionClientData,
+                                                  Boolean isFirstLookupInSession) {
+    // First, check whether the specified "streamName" exists as a local file:
+    FILE *        fid        = fopen(streamName, "rb");
+    Boolean const fileExists = fid != NULL;
+
+    // Next, check whether we already have a "ServerMediaSession" for this file:
+    ServerMediaSession *sms       = getServerMediaSession(streamName);
+    Boolean const       smsExists = sms != NULL;
+
+    // Handle the four possibilities for "fileExists" and "smsExists":
+    if(!fileExists) {
+        if(smsExists) {
+            // "sms" was created for a file that no longer exists. Remove it:
+            removeServerMediaSession(sms);
+        }
+
+        sms = NULL;
+    }
+    else {
+        if(smsExists && isFirstLookupInSession) {
+            // Remove the existing "ServerMediaSession" and create a new one, in case the underlying
+            // file has changed in some way:
+            removeServerMediaSession(sms);
+            sms = NULL;
+        }
+
+        if(sms == NULL) {
+            sms = createNewSMS(envir(), streamName, fid);
+            addServerMediaSession(sms);
+        }
+
+        fclose(fid);
+    }
+
+    if(completionFunc != NULL) {
+        (*completionFunc)(completionClientData, sms);
+    }
+}
+
+// Special code for handling Matroska files:
+struct MatroskaDemuxCreationState {
+    MatroskaFileServerDemux *demux;
+    char                     watchVariable;
+};
+static void onMatroskaDemuxCreation(MatroskaFileServerDemux *newDemux, void *clientData) {
+    MatroskaDemuxCreationState *creationState = (MatroskaDemuxCreationState *)clientData;
+    creationState->demux                      = newDemux;
+    creationState->watchVariable              = 1;
+}
+// END Special code for handling Matroska files:
+
+// Special code for handling Ogg files:
+struct OggDemuxCreationState {
+    OggFileServerDemux *demux;
+    char                watchVariable;
+};
+static void onOggDemuxCreation(OggFileServerDemux *newDemux, void *clientData) {
+    OggDemuxCreationState *creationState = (OggDemuxCreationState *)clientData;
+    creationState->demux                 = newDemux;
+    creationState->watchVariable         = 1;
+}
+// END Special code for handling Ogg files:
+
+#define NEW_SMS(description)                                                                   \
+    do {                                                                                       \
+        char const *descStr = description ", streamed by the LIVE555 Media Server";            \
+        sms                 = ServerMediaSession::createNew(env, fileName, fileName, descStr); \
+    } while(0)
+
+static ServerMediaSession *createNewSMS(UsageEnvironment &env, char const *fileName, FILE * /*fid*/) {
+    // Use the file name extension to determine the type of "ServerMediaSession":
+    char const *extension = strrchr(fileName, '.');
+    if(extension == NULL)
+        return NULL;
+
+    ServerMediaSession *sms         = NULL;
+    Boolean const       reuseSource = False;
+    if(strcmp(extension, ".aac") == 0) {
+        // Assumed to be an AAC Audio (ADTS format) file:
+        NEW_SMS("AAC Audio");
+        sms->addSubsession(ADTSAudioFileServerMediaSubsession::createNew(env, fileName, reuseSource));
+    }
+    else if(strcmp(extension, ".amr") == 0) {
+        // Assumed to be an AMR Audio file:
+        NEW_SMS("AMR Audio");
+        sms->addSubsession(AMRAudioFileServerMediaSubsession::createNew(env, fileName, reuseSource));
+    }
+    else if(strcmp(extension, ".ac3") == 0) {
+        // Assumed to be an AC-3 Audio file:
+        NEW_SMS("AC-3 Audio");
+        sms->addSubsession(AC3AudioFileServerMediaSubsession::createNew(env, fileName, reuseSource));
+    }
+    else if(strcmp(extension, ".m4e") == 0) {
+        // Assumed to be a MPEG-4 Video Elementary Stream file:
+        NEW_SMS("MPEG-4 Video");
+        sms->addSubsession(MPEG4VideoFileServerMediaSubsession::createNew(env, fileName, reuseSource));
+    }
+    else if(strcmp(extension, ".264") == 0) {
+        // Assumed to be a H.264 Video Elementary Stream file:
+        NEW_SMS("H.264 Video");
+        OutPacketBuffer::maxSize = 100000;  // allow for some possibly large H.264 frames
+        sms->addSubsession(H264VideoFileServerMediaSubsession::createNew(env, fileName, reuseSource));
+    }
+    else if(strcmp(extension, ".265") == 0) {
+        // Assumed to be a H.265 Video Elementary Stream file:
+        NEW_SMS("H.265 Video");
+        OutPacketBuffer::maxSize = 100000;  // allow for some possibly large H.265 frames
+        sms->addSubsession(H265VideoFileServerMediaSubsession::createNew(env, fileName, reuseSource));
+    }
+    else if(strcmp(extension, ".mp3") == 0) {
+        // Assumed to be a MPEG-1 or 2 Audio file:
+        NEW_SMS("MPEG-1 or 2 Audio");
+        // To stream using 'ADUs' rather than raw MP3 frames, uncomment the following:
+        //#define STREAM_USING_ADUS 1
+        // To also reorder ADUs before streaming, uncomment the following:
+        //#define INTERLEAVE_ADUS 1
+        // (For more information about ADUs and interleaving,
+        //  see <http://www.live555.com/rtp-mp3/>)
+        Boolean       useADUs      = False;
+        Interleaving *interleaving = NULL;
+#ifdef STREAM_USING_ADUS
+        useADUs = True;
+#ifdef INTERLEAVE_ADUS
+        unsigned char  interleaveCycle[]   = { 0, 2, 1, 3 };  // or choose your own...
+        unsigned const interleaveCycleSize = (sizeof interleaveCycle) / (sizeof(unsigned char));
+        interleaving                       = new Interleaving(interleaveCycleSize, interleaveCycle);
+#endif
+#endif
+        sms->addSubsession(MP3AudioFileServerMediaSubsession::createNew(env, fileName, reuseSource, useADUs, interleaving));
+    }
+    else if(strcmp(extension, ".mpg") == 0) {
+        // Assumed to be a MPEG-1 or 2 Program Stream (audio+video) file:
+        NEW_SMS("MPEG-1 or 2 Program Stream");
+        MPEG1or2FileServerDemux *demux = MPEG1or2FileServerDemux::createNew(env, fileName, reuseSource);
+        sms->addSubsession(demux->newVideoServerMediaSubsession());
+        sms->addSubsession(demux->newAudioServerMediaSubsession());
+    }
+    else if(strcmp(extension, ".vob") == 0) {
+        // Assumed to be a VOB (MPEG-2 Program Stream, with AC-3 audio) file:
+        NEW_SMS("VOB (MPEG-2 video with AC-3 audio)");
+        MPEG1or2FileServerDemux *demux = MPEG1or2FileServerDemux::createNew(env, fileName, reuseSource);
+        sms->addSubsession(demux->newVideoServerMediaSubsession());
+        sms->addSubsession(demux->newAC3AudioServerMediaSubsession());
+    }
+    else if(strcmp(extension, ".ts") == 0) {
+        // Assumed to be a MPEG Transport Stream file:
+        // Use an index file name that's the same as the TS file name, except with ".tsx":
+        unsigned indexFileNameLen = strlen(fileName) + 2;  // allow for trailing "x\0"
+        char *   indexFileName    = new char[indexFileNameLen];
+        sprintf(indexFileName, "%sx", fileName);
+        NEW_SMS("MPEG Transport Stream");
+        sms->addSubsession(MPEG2TransportFileServerMediaSubsession::createNew(env, fileName, indexFileName, reuseSource));
+        delete[] indexFileName;
+    }
+    else if(strcmp(extension, ".wav") == 0) {
+        // Assumed to be a WAV Audio file:
+        NEW_SMS("WAV Audio Stream");
+        // To convert 16-bit PCM data to 8-bit u-law, prior to streaming,
+        // change the following to True:
+        Boolean convertToULaw = False;
+        sms->addSubsession(WAVAudioFileServerMediaSubsession::createNew(env, fileName, reuseSource, convertToULaw));
+    }
+    else if(strcmp(extension, ".dv") == 0) {
+        // Assumed to be a DV Video file
+        // First, make sure that the RTPSinks' buffers will be large enough to handle the huge size of DV frames (as big as 288000).
+        OutPacketBuffer::maxSize = 300000;
+
+        NEW_SMS("DV Video");
+        sms->addSubsession(DVVideoFileServerMediaSubsession::createNew(env, fileName, reuseSource));
+    }
+    else if(strcmp(extension, ".mkv") == 0 || strcmp(extension, ".webm") == 0) {
+        // Assumed to be a Matroska file (note that WebM ('.webm') files are also Matroska files)
+        OutPacketBuffer::maxSize = 300000;  // allow for some possibly large VP8 or VP9 frames
+        NEW_SMS("Matroska video+audio+(optional)subtitles");
+
+        // Create a Matroska file server demultiplexor for the specified file.
+        // (We enter the event loop to wait for this to complete.)
+        MatroskaDemuxCreationState creationState;
+        creationState.watchVariable = 0;
+        MatroskaFileServerDemux::createNew(env, fileName, onMatroskaDemuxCreation, &creationState);
+        env.taskScheduler().doEventLoop(&creationState.watchVariable);
+
+        ServerMediaSubsession *smss;
+        while((smss = creationState.demux->newServerMediaSubsession()) != NULL) {
+            sms->addSubsession(smss);
+        }
+    }
+    else if(strcmp(extension, ".ogg") == 0 || strcmp(extension, ".ogv") == 0 || strcmp(extension, ".opus") == 0) {
+        // Assumed to be an Ogg file
+        NEW_SMS("Ogg video and/or audio");
+
+        // Create a Ogg file server demultiplexor for the specified file.
+        // (We enter the event loop to wait for this to complete.)
+        OggDemuxCreationState creationState;
+        creationState.watchVariable = 0;
+        OggFileServerDemux::createNew(env, fileName, onOggDemuxCreation, &creationState);
+        env.taskScheduler().doEventLoop(&creationState.watchVariable);
+
+        ServerMediaSubsession *smss;
+        while((smss = creationState.demux->newServerMediaSubsession()) != NULL) {
+            sms->addSubsession(smss);
+        }
+    }
+
+    return sms;
+}
diff --git a/3rdparty/live555/src/mediaServer/DynamicRTSPServer.hh b/3rdparty/live555/src/mediaServer/DynamicRTSPServer.hh
new file mode 100644
index 00000000..bcdff9b4
--- /dev/null
+++ b/3rdparty/live555/src/mediaServer/DynamicRTSPServer.hh
@@ -0,0 +1,47 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// Copyright (c) 1996-2022, Live Networks, Inc.  All rights reserved
+// A subclass of "RTSPServer" that creates "ServerMediaSession"s on demand,
+// based on whether or not the specified stream name exists as a file
+// Header file
+
+#ifndef _DYNAMIC_RTSP_SERVER_HH
+#define _DYNAMIC_RTSP_SERVER_HH
+
+#ifndef _RTSP_SERVER_HH
+#include "RTSPServer.hh"
+#endif
+
+class DynamicRTSPServer: public RTSPServer {
+public:
+  static DynamicRTSPServer* createNew(UsageEnvironment& env, Port ourPort,
+				      UserAuthenticationDatabase* authDatabase,
+				      unsigned reclamationTestSeconds = 65);
+
+protected:
+  DynamicRTSPServer(UsageEnvironment& env, int ourSocketIPv4, int ourSocketIPv6, Port ourPort,
+		    UserAuthenticationDatabase* authDatabase, unsigned reclamationTestSeconds);
+  // called only by createNew();
+  virtual ~DynamicRTSPServer();
+
+protected: // redefined virtual functions
+  virtual void lookupServerMediaSession(char const* streamName,
+					lookupServerMediaSessionCompletionFunc* completionFunc,
+					void* completionClientData,
+					Boolean isFirstLookupInSession);
+};
+
+#endif
diff --git a/3rdparty/live555/src/mediaServer/Makefile.head b/3rdparty/live555/src/mediaServer/Makefile.head
new file mode 100644
index 00000000..327a98ea
--- /dev/null
+++ b/3rdparty/live555/src/mediaServer/Makefile.head
@@ -0,0 +1,8 @@
+PREFIX = /usr/local
+INCLUDES = -I../UsageEnvironment/include -I../groupsock/include -I../liveMedia/include -I../BasicUsageEnvironment/include
+# Default library filename suffixes for each library that we link with.  The "config.*" file might redefine these later.
+libliveMedia_LIB_SUFFIX = $(LIB_SUFFIX)
+libBasicUsageEnvironment_LIB_SUFFIX = $(LIB_SUFFIX)
+libUsageEnvironment_LIB_SUFFIX = $(LIB_SUFFIX)
+libgroupsock_LIB_SUFFIX = $(LIB_SUFFIX)
+##### Change the following for your environment:
diff --git a/3rdparty/live555/src/mediaServer/Makefile.tail b/3rdparty/live555/src/mediaServer/Makefile.tail
new file mode 100644
index 00000000..1452000a
--- /dev/null
+++ b/3rdparty/live555/src/mediaServer/Makefile.tail
@@ -0,0 +1,40 @@
+##### End of variables to change
+
+MEDIA_SERVER = live555MediaServer$(EXE)
+
+ALL = $(MEDIA_SERVER)
+all: $(ALL)
+
+.$(C).$(OBJ):
+	$(C_COMPILER) -c $(C_FLAGS) $<
+.$(CPP).$(OBJ):
+	$(CPLUSPLUS_COMPILER) -c $(CPLUSPLUS_FLAGS) $<
+
+MEDIA_SERVER_OBJS = live555MediaServer.$(OBJ) DynamicRTSPServer.$(OBJ)
+
+live555MediaServer.$(CPP):	DynamicRTSPServer.hh version.hh
+DynamicRTSPServer.$(CPP):	DynamicRTSPServer.hh
+
+USAGE_ENVIRONMENT_DIR = ../UsageEnvironment
+USAGE_ENVIRONMENT_LIB = $(USAGE_ENVIRONMENT_DIR)/libUsageEnvironment.$(libUsageEnvironment_LIB_SUFFIX)
+BASIC_USAGE_ENVIRONMENT_DIR = ../BasicUsageEnvironment
+BASIC_USAGE_ENVIRONMENT_LIB = $(BASIC_USAGE_ENVIRONMENT_DIR)/libBasicUsageEnvironment.$(libBasicUsageEnvironment_LIB_SUFFIX)
+LIVEMEDIA_DIR = ../liveMedia
+LIVEMEDIA_LIB = $(LIVEMEDIA_DIR)/libliveMedia.$(libliveMedia_LIB_SUFFIX)
+GROUPSOCK_DIR = ../groupsock
+GROUPSOCK_LIB = $(GROUPSOCK_DIR)/libgroupsock.$(libgroupsock_LIB_SUFFIX)
+LOCAL_LIBS =	$(LIVEMEDIA_LIB) $(GROUPSOCK_LIB) \
+		$(BASIC_USAGE_ENVIRONMENT_LIB) $(USAGE_ENVIRONMENT_LIB)
+LIBS =			$(LOCAL_LIBS) $(LIBS_FOR_CONSOLE_APPLICATION)
+
+live555MediaServer$(EXE):	$(MEDIA_SERVER_OBJS) $(LOCAL_LIBS)
+	$(LINK)$@ $(CONSOLE_LINK_OPTS) $(MEDIA_SERVER_OBJS) $(LIBS)
+
+clean:
+	-rm -rf *.$(OBJ) $(ALL) core *.core *~ include/*~
+
+install: $(MEDIA_SERVER)
+	  install -d $(DESTDIR)$(PREFIX)/bin
+	  install -m 755 $(MEDIA_SERVER) $(DESTDIR)$(PREFIX)/bin
+
+##### Any additional, platform-specific rules come here:
diff --git a/3rdparty/live555/src/mediaServer/live555MediaServer.cpp b/3rdparty/live555/src/mediaServer/live555MediaServer.cpp
new file mode 100644
index 00000000..a2c32a2b
--- /dev/null
+++ b/3rdparty/live555/src/mediaServer/live555MediaServer.cpp
@@ -0,0 +1,104 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// Copyright (c) 1996-2022, Live Networks, Inc.  All rights reserved
+// LIVE555 Media Server
+// main program
+
+#include <BasicUsageEnvironment.hh>
+#include "DynamicRTSPServer.hh"
+#include "version.hh"
+#include <GroupsockHelper.hh>  // for "weHaveAnIPv*Address()"
+
+int main(int argc, char **argv) {
+    // Begin by setting up our usage environment:
+    TaskScheduler *   scheduler = BasicTaskScheduler::createNew();
+    UsageEnvironment *env       = BasicUsageEnvironment::createNew(*scheduler);
+
+    UserAuthenticationDatabase *authDB = NULL;
+#ifdef ACCESS_CONTROL
+    // To implement client access control to the RTSP server, do the following:
+    authDB = new UserAuthenticationDatabase;
+    authDB->addUserRecord("username1", "password1");  // replace these with real strings
+                                                      // Repeat the above with each <username>, <password> that you wish to allow
+                                                      // access to the server.
+#endif
+
+    // Create the RTSP server.  Try first with the default port number (554),
+    // and then with the alternative port number (8554):
+    RTSPServer *rtspServer;
+    portNumBits rtspServerPortNum = 554;
+    rtspServer                    = DynamicRTSPServer::createNew(*env, rtspServerPortNum, authDB);
+    if(rtspServer == NULL) {
+        rtspServerPortNum = 8554;
+        rtspServer        = DynamicRTSPServer::createNew(*env, rtspServerPortNum, authDB);
+    }
+    if(rtspServer == NULL) {
+        *env << "Failed to create RTSP server: " << env->getResultMsg() << "\n";
+        exit(1);
+    }
+
+    *env << "LIVE555 Media Server\n";
+    *env << "\tversion " << MEDIA_SERVER_VERSION_STRING << " (LIVE555 Streaming Media library version " << LIVEMEDIA_LIBRARY_VERSION_STRING << ").\n";
+
+    *env << "Play streams from this server using the URL\n";
+    if(weHaveAnIPv4Address(*env)) {
+        char *rtspURLPrefix = rtspServer->ipv4rtspURLPrefix();
+        *env << "\t" << rtspURLPrefix << "<filename>\n";
+        delete[] rtspURLPrefix;
+        if(weHaveAnIPv6Address(*env))
+            *env << "or\n";
+    }
+    if(weHaveAnIPv6Address(*env)) {
+        char *rtspURLPrefix = rtspServer->ipv6rtspURLPrefix();
+        *env << "\t" << rtspURLPrefix << "<filename>\n";
+        delete[] rtspURLPrefix;
+    }
+    *env << "where <filename> is a file present in the current directory.\n";
+
+    *env << "Each file's type is inferred from its name suffix:\n";
+    *env << "\t\".264\" => a H.264 Video Elementary Stream file\n";
+    *env << "\t\".265\" => a H.265 Video Elementary Stream file\n";
+    *env << "\t\".aac\" => an AAC Audio (ADTS format) file\n";
+    *env << "\t\".ac3\" => an AC-3 Audio file\n";
+    *env << "\t\".amr\" => an AMR Audio file\n";
+    *env << "\t\".dv\" => a DV Video file\n";
+    *env << "\t\".m4e\" => a MPEG-4 Video Elementary Stream file\n";
+    *env << "\t\".mkv\" => a Matroska audio+video+(optional)subtitles file\n";
+    *env << "\t\".mp3\" => a MPEG-1 or 2 Audio file\n";
+    *env << "\t\".mpg\" => a MPEG-1 or 2 Program Stream (audio+video) file\n";
+    *env << "\t\".ogg\" or \".ogv\" or \".opus\" => an Ogg audio and/or video file\n";
+    *env << "\t\".ts\" => a MPEG Transport Stream file\n";
+    *env << "\t\t(a \".tsx\" index file - if present - provides server 'trick play' support)\n";
+    *env << "\t\".vob\" => a VOB (MPEG-2 video with AC-3 audio) file\n";
+    *env << "\t\".wav\" => a WAV Audio file\n";
+    *env << "\t\".webm\" => a WebM audio(Vorbis)+video(VP8) file\n";
+    *env << "See http://www.live555.com/mediaServer/ for additional documentation.\n";
+
+    // Also, attempt to create a HTTP server for RTSP-over-HTTP tunneling.
+    // Try first with the default HTTP port (80), and then with the alternative HTTP
+    // port numbers (8000 and 8080).
+
+    if(rtspServer->setUpTunnelingOverHTTP(80) || rtspServer->setUpTunnelingOverHTTP(8000) || rtspServer->setUpTunnelingOverHTTP(8080)) {
+        *env << "(We use port " << rtspServer->httpServerPortNum() << " for optional RTSP-over-HTTP tunneling).)\n";
+    }
+    else {
+        *env << "(RTSP-over-HTTP tunneling is not available.)\n";
+    }
+
+    env->taskScheduler().doEventLoop();  // does not return
+
+    return 0;  // only to prevent compiler warning
+}
diff --git a/3rdparty/live555/src/mediaServer/version.hh b/3rdparty/live555/src/mediaServer/version.hh
new file mode 100644
index 00000000..941f5184
--- /dev/null
+++ b/3rdparty/live555/src/mediaServer/version.hh
@@ -0,0 +1,25 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// Copyright (c) 1996-2022, Live Networks, Inc.  All rights reserved
+// Version information for the LIVE555 Media Server application
+// Header file
+
+#ifndef _MEDIA_SERVER_VERSION_HH
+#define _MEDIA_SERVER_VERSION_HH
+
+#define MEDIA_SERVER_VERSION_STRING "1.10"
+
+#endif
diff --git a/3rdparty/live555/src/proxyServer/Makefile.head b/3rdparty/live555/src/proxyServer/Makefile.head
new file mode 100644
index 00000000..327a98ea
--- /dev/null
+++ b/3rdparty/live555/src/proxyServer/Makefile.head
@@ -0,0 +1,8 @@
+PREFIX = /usr/local
+INCLUDES = -I../UsageEnvironment/include -I../groupsock/include -I../liveMedia/include -I../BasicUsageEnvironment/include
+# Default library filename suffixes for each library that we link with.  The "config.*" file might redefine these later.
+libliveMedia_LIB_SUFFIX = $(LIB_SUFFIX)
+libBasicUsageEnvironment_LIB_SUFFIX = $(LIB_SUFFIX)
+libUsageEnvironment_LIB_SUFFIX = $(LIB_SUFFIX)
+libgroupsock_LIB_SUFFIX = $(LIB_SUFFIX)
+##### Change the following for your environment:
diff --git a/3rdparty/live555/src/proxyServer/Makefile.tail b/3rdparty/live555/src/proxyServer/Makefile.tail
new file mode 100644
index 00000000..da85cfe0
--- /dev/null
+++ b/3rdparty/live555/src/proxyServer/Makefile.tail
@@ -0,0 +1,37 @@
+##### End of variables to change
+
+PROXY_SERVER = live555ProxyServer$(EXE)
+
+ALL = $(PROXY_SERVER)
+all: $(ALL)
+
+.$(C).$(OBJ):
+	$(C_COMPILER) -c $(C_FLAGS) $<
+.$(CPP).$(OBJ):
+	$(CPLUSPLUS_COMPILER) -c $(CPLUSPLUS_FLAGS) $<
+
+PROXY_SERVER_OBJS = live555ProxyServer.$(OBJ)
+
+USAGE_ENVIRONMENT_DIR = ../UsageEnvironment
+USAGE_ENVIRONMENT_LIB = $(USAGE_ENVIRONMENT_DIR)/libUsageEnvironment.$(libUsageEnvironment_LIB_SUFFIX)
+BASIC_USAGE_ENVIRONMENT_DIR = ../BasicUsageEnvironment
+BASIC_USAGE_ENVIRONMENT_LIB = $(BASIC_USAGE_ENVIRONMENT_DIR)/libBasicUsageEnvironment.$(libBasicUsageEnvironment_LIB_SUFFIX)
+LIVEMEDIA_DIR = ../liveMedia
+LIVEMEDIA_LIB = $(LIVEMEDIA_DIR)/libliveMedia.$(libliveMedia_LIB_SUFFIX)
+GROUPSOCK_DIR = ../groupsock
+GROUPSOCK_LIB = $(GROUPSOCK_DIR)/libgroupsock.$(libgroupsock_LIB_SUFFIX)
+LOCAL_LIBS =	$(LIVEMEDIA_LIB) $(GROUPSOCK_LIB) \
+		$(BASIC_USAGE_ENVIRONMENT_LIB) $(USAGE_ENVIRONMENT_LIB)
+LIBS =			$(LOCAL_LIBS) $(LIBS_FOR_CONSOLE_APPLICATION)
+
+live555ProxyServer$(EXE):	$(PROXY_SERVER_OBJS) $(LOCAL_LIBS)
+	$(LINK)$@ $(CONSOLE_LINK_OPTS) $(PROXY_SERVER_OBJS) $(LIBS)
+
+clean:
+	-rm -rf *.$(OBJ) $(ALL) core *.core *~ include/*~
+
+install: $(PROXY_SERVER)
+	  install -d $(DESTDIR)$(PREFIX)/bin
+	  install -m 755 $(PROXY_SERVER) $(DESTDIR)$(PREFIX)/bin
+
+##### Any additional, platform-specific rules come here:
diff --git a/3rdparty/live555/src/proxyServer/live555ProxyServer.cpp b/3rdparty/live555/src/proxyServer/live555ProxyServer.cpp
new file mode 100644
index 00000000..2ac65b88
--- /dev/null
+++ b/3rdparty/live555/src/proxyServer/live555ProxyServer.cpp
@@ -0,0 +1,260 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// Copyright (c) 1996-2022, Live Networks, Inc.  All rights reserved
+// LIVE555 Proxy Server
+// main program
+
+#include "liveMedia.hh"
+#include "BasicUsageEnvironment.hh"
+
+char const *                progName;
+UsageEnvironment *          env;
+UserAuthenticationDatabase *authDB            = NULL;
+UserAuthenticationDatabase *authDBForREGISTER = NULL;
+
+// Default values of command-line parameters:
+int         verbosityLevel        = 0;
+Boolean     streamRTPOverTCP      = False;
+portNumBits tunnelOverHTTPPortNum = 0;
+portNumBits rtspServerPortNum     = 554;
+char *      username              = NULL;
+char *      password              = NULL;
+Boolean     proxyREGISTERRequests = False;
+char *      usernameForREGISTER   = NULL;
+char *      passwordForREGISTER   = NULL;
+
+static RTSPServer *createRTSPServer(Port port) {
+    if(proxyREGISTERRequests) {
+        return RTSPServerWithREGISTERProxying::createNew(*env, port, authDB, authDBForREGISTER, 65, streamRTPOverTCP, verbosityLevel, username, password);
+    }
+    else {
+        return RTSPServer::createNew(*env, port, authDB);
+    }
+}
+
+void usage() {
+    *env << "Usage: " << progName << " [-v|-V]"
+         << " [-t|-T <http-port>]"
+         << " [-p <rtspServer-port>]"
+         << " [-u <username> <password>]"
+         << " [-R] [-U <username-for-REGISTER> <password-for-REGISTER>]"
+         << " <rtsp-url-1> ... <rtsp-url-n>\n";
+    exit(1);
+}
+
+int main(int argc, char **argv) {
+    // Increase the maximum size of video frames that we can 'proxy' without truncation.
+    // (Such frames are unreasonably large; the back-end servers should really not be sending frames this large!)
+    OutPacketBuffer::maxSize = 100000;  // bytes
+
+    // Begin by setting up our usage environment:
+    TaskScheduler *scheduler = BasicTaskScheduler::createNew();
+    env                      = BasicUsageEnvironment::createNew(*scheduler);
+
+    *env << "LIVE555 Proxy Server\n"
+         << "\t(LIVE555 Streaming Media library version " << LIVEMEDIA_LIBRARY_VERSION_STRING << "; licensed under the GNU LGPL)\n\n";
+
+    // Check command-line arguments: optional parameters, then one or more rtsp:// URLs (of streams to be proxied):
+    progName = argv[0];
+    if(argc < 2)
+        usage();
+    while(argc > 1) {
+        // Process initial command-line options (beginning with "-"):
+        char *const opt = argv[1];
+        if(opt[0] != '-')
+            break;  // the remaining parameters are assumed to be "rtsp://" URLs
+
+        switch(opt[1]) {
+        case 'v': {  // verbose output
+            verbosityLevel = 1;
+            break;
+        }
+
+        case 'V': {  // more verbose output
+            verbosityLevel = 2;
+            break;
+        }
+
+        case 't': {
+            // Stream RTP and RTCP over the TCP 'control' connection.
+            // (This is for the 'back end' (i.e., proxied) stream only.)
+            streamRTPOverTCP = True;
+            break;
+        }
+
+        case 'T': {
+            // stream RTP and RTCP over a HTTP connection
+            if(argc > 2 && argv[2][0] != '-') {
+                // The next argument is the HTTP server port number:
+                if(sscanf(argv[2], "%hu", &tunnelOverHTTPPortNum) == 1 && tunnelOverHTTPPortNum > 0) {
+                    ++argv;
+                    --argc;
+                    break;
+                }
+            }
+
+            // If we get here, the option was specified incorrectly:
+            usage();
+            break;
+        }
+
+        case 'p': {
+            // specify a rtsp server port number
+            if(argc > 2 && argv[2][0] != '-') {
+                // The next argument is the rtsp server port number:
+                if(sscanf(argv[2], "%hu", &rtspServerPortNum) == 1 && rtspServerPortNum > 0) {
+                    ++argv;
+                    --argc;
+                    break;
+                }
+            }
+
+            // If we get here, the option was specified incorrectly:
+            usage();
+            break;
+        }
+
+        case 'u': {  // specify a username and password (to be used if the 'back end' (i.e., proxied) stream requires authentication)
+            if(argc < 4)
+                usage();  // there's no argv[3] (for the "password")
+            username = argv[2];
+            password = argv[3];
+            argv += 2;
+            argc -= 2;
+            break;
+        }
+
+        case 'U': {  // specify a username and password to use to authenticate incoming "REGISTER" commands
+            if(argc < 4)
+                usage();  // there's no argv[3] (for the "password")
+            usernameForREGISTER = argv[2];
+            passwordForREGISTER = argv[3];
+
+            if(authDBForREGISTER == NULL)
+                authDBForREGISTER = new UserAuthenticationDatabase;
+            authDBForREGISTER->addUserRecord(usernameForREGISTER, passwordForREGISTER);
+            argv += 2;
+            argc -= 2;
+            break;
+        }
+
+        case 'R': {  // Handle incoming "REGISTER" requests by proxying the specified stream:
+            proxyREGISTERRequests = True;
+            break;
+        }
+
+        default: {
+            usage();
+            break;
+        }
+        }
+
+        ++argv;
+        --argc;
+    }
+    if(argc < 2 && !proxyREGISTERRequests)
+        usage();  // there must be at least one URL at the end
+    // Make sure that the remaining arguments appear to be "rtsp://" (or "rtsps://") URLs:
+    int i;
+    for(i = 1; i < argc; ++i) {
+        if(strncmp(argv[i], "rtsp://", 7) != 0 && strncmp(argv[i], "rtsps://", 8) != 0)
+            usage();
+    }
+    // Do some additional checking for invalid command-line argument combinations:
+    if(authDBForREGISTER != NULL && !proxyREGISTERRequests) {
+        *env << "The '-U <username-for-REGISTER> <password-for-REGISTER>' option can be used only with -R\n";
+        usage();
+    }
+    if(streamRTPOverTCP) {
+        if(tunnelOverHTTPPortNum > 0) {
+            *env << "The -t and -T options cannot both be used!\n";
+            usage();
+        }
+        else {
+            tunnelOverHTTPPortNum = (portNumBits)(~0);  // hack to tell "ProxyServerMediaSession" to stream over TCP, but not using HTTP
+        }
+    }
+
+#ifdef ACCESS_CONTROL
+    // To implement client access control to the RTSP server, do the following:
+    authDB = new UserAuthenticationDatabase;
+    authDB->addUserRecord("username1", "password1");  // replace these with real strings
+                                                      // Repeat this line with each <username>, <password> that you wish to allow access to the server.
+#endif
+
+    // Create the RTSP server. Try first with the configured port number,
+    // and then with the default port number (554) if different,
+    // and then with the alternative port number (8554):
+    RTSPServer *rtspServer;
+    rtspServer = createRTSPServer(rtspServerPortNum);
+    if(rtspServer == NULL) {
+        if(rtspServerPortNum != 554) {
+            *env << "Unable to create a RTSP server with port number " << rtspServerPortNum << ": " << env->getResultMsg() << "\n";
+            *env << "Trying instead with the standard port numbers (554 and 8554)...\n";
+
+            rtspServerPortNum = 554;
+            rtspServer        = createRTSPServer(rtspServerPortNum);
+        }
+    }
+    if(rtspServer == NULL) {
+        rtspServerPortNum = 8554;
+        rtspServer        = createRTSPServer(rtspServerPortNum);
+    }
+    if(rtspServer == NULL) {
+        *env << "Failed to create RTSP server: " << env->getResultMsg() << "\n";
+        exit(1);
+    }
+
+    // Create a proxy for each "rtsp://" URL specified on the command line:
+    for(i = 1; i < argc; ++i) {
+        char const *proxiedStreamURL = argv[i];
+        char        streamName[30];
+        if(argc == 2) {
+            sprintf(streamName, "%s", "proxyStream");  // there's just one stream; give it this name
+        }
+        else {
+            sprintf(streamName, "proxyStream-%d", i);  // there's more than one stream; distinguish them by name
+        }
+        ServerMediaSession *sms =
+            ProxyServerMediaSession::createNew(*env, rtspServer, proxiedStreamURL, streamName, username, password, tunnelOverHTTPPortNum, verbosityLevel);
+        rtspServer->addServerMediaSession(sms);
+
+        char *proxyStreamURL = rtspServer->rtspURL(sms);
+        *env << "RTSP stream, proxying the stream \"" << proxiedStreamURL << "\"\n";
+        *env << "\tPlay this stream using the URL: " << proxyStreamURL << "\n";
+        delete[] proxyStreamURL;
+    }
+
+    if(proxyREGISTERRequests) {
+        *env << "(We handle incoming \"REGISTER\" requests on port " << rtspServerPortNum << ")\n";
+    }
+
+    // Also, attempt to create a HTTP server for RTSP-over-HTTP tunneling.
+    // Try first with the default HTTP port (80), and then with the alternative HTTP
+    // port numbers (8000 and 8080).
+
+    if(rtspServer->setUpTunnelingOverHTTP(80) || rtspServer->setUpTunnelingOverHTTP(8000) || rtspServer->setUpTunnelingOverHTTP(8080)) {
+        *env << "\n(We use port " << rtspServer->httpServerPortNum() << " for optional RTSP-over-HTTP tunneling.)\n";
+    }
+    else {
+        *env << "\n(RTSP-over-HTTP tunneling is not available.)\n";
+    }
+
+    // Now, enter the event loop:
+    env->taskScheduler().doEventLoop();  // does not return
+
+    return 0;  // only to prevent compiler warning
+}
diff --git a/3rdparty/live555/src/testProgs/#playCommon.cpp# b/3rdparty/live555/src/testProgs/#playCommon.cpp#
new file mode 100644
index 00000000..e56501e9
--- /dev/null
+++ b/3rdparty/live555/src/testProgs/#playCommon.cpp#
@@ -0,0 +1,1565 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// Copyright (c) 1996-2022, Live Networks, Inc.  All rights reserved
+// A common framework, used for the "openRTSP" and "playSIP" applications
+// Implementation
+//
+// NOTE: If you want to develop your own RTSP client application (or embed RTSP client functionality into your own application),
+// then we don't recommend using this code as a model, because it is too complex (with many options).
+// Instead, we recommend using the "testRTSPClient" application code as a model.
+
+#include "playCommon.hh"
+#include "BasicUsageEnvironment.hh"
+#include "GroupsockHelper.hh"
+
+#if defined(__WIN32__) || defined(_WIN32)
+#define snprintf _snprintf
+#else
+#include <signal.h>
+#define USE_SIGNALS 1
+#endif
+
+// Forward function definitions:
+void continueAfterClientCreation0(RTSPClient* client, Boolean requestStreamingOverTCP);
+void continueAfterClientCreation1();
+void continueAfterOPTIONS(RTSPClient* client, int resultCode, char* resultString);
+void continueAfterDESCRIBE(RTSPClient* client, int resultCode, char* resultString);
+void continueAfterSETUP(RTSPClient* client, int resultCode, char* resultString);
+void continueAfterPLAY(RTSPClient* client, int resultCode, char* resultString);
+void continueAfterTEARDOWN(RTSPClient* client, int resultCode, char* resultString);
+
+void createOutputFiles(char const* periodicFilenameSuffix);
+void createPeriodicOutputFiles();
+void setupStreams();
+void closeMediaSinks();
+void subsessionAfterPlaying(void* clientData);
+void subsessionByeHandler(void* clientData, char const* reason);
+void sessionAfterPlaying(void* clientData = NULL);
+void sessionTimerHandler(void* clientData);
+void periodicFileOutputTimerHandler(void* clientData);
+void shutdown(int exitCode = 1);
+void signalHandlerShutdown(int sig);
+void checkForPacketArrival(void* clientData);
+void checkInterPacketGaps(void* clientData);
+void checkSessionTimeoutBrokenServer(void* clientData);
+void beginQOSMeasurement();
+
+char const* progName;
+UsageEnvironment* env;
+Medium* ourClient = NULL;
+Authenticator* ourAuthenticator = NULL;
+char const* streamURL = NULL;
+MediaSession* session = NULL;
+TaskToken sessionTimerTask = NULL;
+TaskToken sessionTimeoutBrokenServerTask = NULL;
+TaskToken arrivalCheckTimerTask = NULL;
+TaskToken interPacketGapCheckTimerTask = NULL;
+TaskToken qosMeasurementTimerTask = NULL;
+TaskToken periodicFileOutputTask = NULL;
+Boolean createReceivers = True;
+Boolean outputQuickTimeFile = False;
+Boolean generateMP4Format = False;
+QuickTimeFileSink* qtOut = NULL;
+Boolean outputAVIFile = False;
+AVIFileSink* aviOut = NULL;
+Boolean audioOnly = False;
+Boolean videoOnly = False;
+Boolean applicationOnly = False;
+char const* singleMedium = NULL;
+int verbosityLevel = 1; // by default, print verbose output
+double duration = 0;
+double durationSlop = -1.0; // extra seconds to play at the end
+double initialSeekTime = 0.0f;
+char* initialAbsoluteSeekTime = NULL;
+char* initialAbsoluteSeekEndTime = NULL;
+float scale = 1.0f;
+double endTime;
+unsigned interPacketGapMaxTime = 0;
+unsigned totNumPacketsReceived = ~0; // used if checking inter-packet gaps
+Boolean playContinuously = False;
+int simpleRTPoffsetArg = -1;
+Boolean sendOptionsRequest = True;
+Boolean sendOptionsRequestOnly = False;
+Boolean oneFilePerFrame = False;
+Boolean notifyOnPacketArrival = False;
+Boolean sendKeepAlivesToBrokenServers = False;
+unsigned sessionTimeoutParameter = 0;
+Boolean streamUsingTCP = False;
+Boolean forceMulticastOnUnspecified = False;
+unsigned short desiredPortNum = 0;
+portNumBits tunnelOverHTTPPortNum = 0;
+char* username = NULL;
+char* password = NULL;
+char* proxyServerName = NULL;
+unsigned short proxyServerPortNum = 0;
+unsigned char desiredAudioRTPPayloadFormat = 0;
+char* mimeSubtype = NULL;
+unsigned short movieWidth = 240; // default
+Boolean movieWidthOptionSet = False;
+unsigned short movieHeight = 180; // default
+Boolean movieHeightOptionSet = False;
+unsigned movieFPS = 15; // default
+Boolean movieFPSOptionSet = False;
+char const* fileNamePrefix = "";
+unsigned fileSinkBufferSize = 100000;
+unsigned socketInputBufferSize = 0;
+Boolean packetLossCompensate = False;
+Boolean syncStreams = False;
+Boolean generateHintTracks = False;
+Boolean waitForResponseToTEARDOWN = True;
+unsigned qosMeasurementIntervalMS = 0; // 0 means: Don't output QOS data
+char* userAgent = NULL;
+unsigned fileOutputInterval = 0; // seconds
+unsigned fileOutputSecondsSoFar = 0; // seconds
+Boolean createHandlerServerForREGISTERCommand = False;
+portNumBits handlerServerForREGISTERCommandPortNum = 0;
+HandlerServerForREGISTERCommand* handlerServerForREGISTERCommand;
+char* usernameForREGISTER = NULL;
+char* passwordForREGISTER = NULL;
+UserAuthenticationDatabase* authDBForREGISTER = NULL;
+
+struct timeval startTime;
+
+void usage() {
+  *env << "Usage: " << progName
+       << " [-p <startPortNum>] [-r|-q|-4|-i] [-a|-v] [-V] [-d <duration>] [-D <max-inter-packet-gap-time> [-c] [-S <offset>] [-n] [-O]"
+	   << (controlConnectionUsesTCP ? " [-t|-T <http-port>]" : "")
+       << " [-u <username> <password>"
+	   << (allowProxyServers ? " [<proxy-server> [<proxy-server-port>]]" : "")
+       << "]" << (supportCodecSelection ? " [-A <audio-codec-rtp-payload-format-code>|-M <mime-subtype-name>]" : "")
+       << " [-s <initial-seek-time>]|[-U <absolute-seek-time>] [-E <absolute-seek-end-time>] [-z <scale>] [-g user-agent]"
+       << " [-k <username-for-REGISTER> <password-for-REGISTER>]"
+       << " [-P <interval-in-seconds>] [-K]"
+       << " [-w <width> -h <height>] [-f <frames-per-second>] [-y] [-H] [-Q [<measurement-interval>]] [-F <filename-prefix>] [-b <file-sink-buffer-size>] [-B <input-socket-buffer-size>] [-I <input-interface-ip-address>] [-m] [<url>|-R [<port-num>]] (or " << progName << " -o [-V] <url>)\n";
+  shutdown();
+}
+
+int main(int argc, char** argv) {
+  // Begin by setting up our usage environment:
+  TaskScheduler* scheduler = BasicTaskScheduler::createNew();
+  env = BasicUsageEnvironment::createNew(*scheduler);
+
+  progName = argv[0];
+
+  gettimeofday(&startTime, NULL);
+
+#ifdef USE_SIGNALS
+  // Allow ourselves to be shut down gracefully by a SIGHUP or a SIGUSR1:
+  signal(SIGHUP, signalHandlerShutdown);
+  signal(SIGUSR1, signalHandlerShutdown);
+#endif
+
+  // unfortunately we can't use getopt() here, as Windoze doesn't have it
+  while (argc > 1) {
+    char* const opt = argv[1];
+    if (opt[0] != '-') {
+      if (argc == 2) break; // only the URL is left
+      usage();
+    }
+
+    switch (opt[1]) {
+    case 'p': { // specify start port number
+      int portArg;
+      if (sscanf(argv[2], "%d", &portArg) != 1) {
+	usage();
+      }
+      if (portArg <= 0 || portArg >= 65536 || portArg&1) {
+	*env << "bad port number: " << portArg
+		<< " (must be even, and in the range (0,65536))\n";
+	usage();
+      }
+      desiredPortNum = (unsigned short)portArg;
+      ++argv; --argc;
+      break;
+    }
+
+    case 'r': { // do not receive data (instead, just 'play' the stream(s))
+      createReceivers = False;
+      break;
+    }
+
+    case 'q': { // output a QuickTime file (to stdout)
+      outputQuickTimeFile = True;
+      break;
+    }
+
+    case '4': { // output a 'mp4'-format file (to stdout)
+      outputQuickTimeFile = True;
+      generateMP4Format = True;
+      break;
+    }
+
+    case 'i': { // output an AVI file (to stdout)
+      outputAVIFile = True;
+      break;
+    }
+
+    case 'I': { // specify input interface...
+      NetAddressList addresses(argv[2]);
+      if (addresses.numAddresses() == 0) {
+	*env << "Failed to find network address for \"" << argv[2] << "\"";
+	break;
+      }
+
+      struct sockaddr_storage interfaceAddress;
+
+      copyAddress(interfaceAddress, addresses.firstAddress());
+      if (interfaceAddress.ss_family == AF_INET) { // later, support IPv6 also
+	ReceivingInterfaceAddr = ((sockaddr_in&)interfaceAddress).sin_addr.s_addr;
+      }
+      ++argv; --argc;
+      break;
+    }
+
+    case 'a': { // receive/record an audio stream only
+      audioOnly = True;
+      singleMedium = "audio";
+      break;
+    }
+
+    case 'v': { // receive/record a video stream only
+      videoOnly = True;
+      singleMedium = "video";
+      break;
+    }
+
+    case 'L': { // receive/record an 'application' (e.g., metadata) stream only
+      applicationOnly = True;
+      singleMedium = "application";
+      break;
+    }
+
+    case 'V': { // disable verbose output
+      verbosityLevel = 0;
+      break;
+    }
+
+    case 'd': { // specify duration, or how much to delay after end time
+      float arg;
+      if (sscanf(argv[2], "%g", &arg) != 1) {
+	usage();
+      }
+      if (argv[2][0] == '-') { // not "arg<0", in case argv[2] was "-0"
+	// a 'negative' argument was specified; use this for "durationSlop":
+	duration = 0; // use whatever's in the SDP
+	durationSlop = -arg;
+      } else {
+	duration = arg;
+	durationSlop = 0;
+      }
+      ++argv; --argc;
+      break;
+    }
+
+    case 'D': { // specify maximum number of seconds to wait for packets:
+      if (sscanf(argv[2], "%u", &interPacketGapMaxTime) != 1) {
+	usage();
+      }
+      ++argv; --argc;
+      break;
+    }
+
+    case 'c': { // play continuously
+      playContinuously = True;
+      break;
+    }
+
+    case 'S': { // specify an offset to use with "SimpleRTPSource"s
+      if (sscanf(argv[2], "%d", &simpleRTPoffsetArg) != 1) {
+	usage();
+      }
+      if (simpleRTPoffsetArg < 0) {
+	*env << "offset argument to \"-S\" must be >= 0\n";
+	usage();
+      }
+      ++argv; --argc;
+      break;
+    }
+
+    case 'm': { // output multiple files - one for each frame
+      oneFilePerFrame = True;
+      break;
+    }
+
+    case 'n': { // notify the user when the first data packet arrives
+      notifyOnPacketArrival = True;
+      break;
+    }
+
+    case 'O': { // Don't send an "OPTIONS" request before "DESCRIBE"
+      sendOptionsRequest = False;
+      break;
+    }
+
+    case 'o': { // Send only the "OPTIONS" request to the server
+      sendOptionsRequestOnly = True;
+      break;
+    }
+
+    case 'P': { // specify an interval (in seconds) between writing successive output files
+      int fileOutputIntervalInt;
+      if (sscanf(argv[2], "%d", &fileOutputIntervalInt) != 1 || fileOutputIntervalInt <= 0) {
+	usage();
+      }
+      fileOutputInterval = (unsigned)fileOutputIntervalInt;
+      ++argv; --argc;
+      break;
+    }
+
+    case 't': {
+      // stream RTP and RTCP over the TCP 'control' connection
+      if (controlConnectionUsesTCP) {
+	streamUsingTCP = True;
+      } else {
+	usage();
+      }
+      break;
+    }
+
+    case 'T': {
+      // stream RTP and RTCP over a HTTP connection
+      if (controlConnectionUsesTCP) {
+	if (argc > 3 && argv[2][0] != '-') {
+	  // The next argument is the HTTP server port number:
+	  if (sscanf(argv[2], "%hu", &tunnelOverHTTPPortNum) == 1
+	      && tunnelOverHTTPPortNum > 0) {
+	    ++argv; --argc;
+	    break;
+	  }
+	}
+      }
+
+      // If we get here, the option was specified incorrectly:
+      usage();
+      break;
+    }
+
+    case 'u': { // specify a username and password
+      if (argc < 4) usage(); // there's no argv[3] (for the "password")
+      username = argv[2];
+      password = argv[3];
+      argv+=2; argc-=2;
+      if (allowProxyServers && argc > 3 && argv[2][0] != '-') {
+	// The next argument is the name of a proxy server:
+	proxyServerName = argv[2];
+	++argv; --argc;
+
+	if (argc > 3 && argv[2][0] != '-') {
+	  // The next argument is the proxy server port number:
+	  if (sscanf(argv[2], "%hu", &proxyServerPortNum) != 1) {
+	    usage();
+	  }
+	  ++argv; --argc;
+	}
+      }
+
+      ourAuthenticator = new Authenticator(username, password);
+      break;
+    }
+
+    case 'k': { // specify a username and password to be used to authentication an incoming "REGISTER" command (for use with -R)
+      if (argc < 4) usage(); // there's no argv[3] (for the "password")
+      usernameForREGISTER = argv[2];
+      passwordForREGISTER = argv[3];
+      argv+=2; argc-=2;
+
+      if (authDBForREGISTER == NULL) authDBForREGISTER = new UserAuthenticationDatabase;
+      authDBForREGISTER->addUserRecord(usernameForREGISTER, passwordForREGISTER);
+      break;
+    }
+
+    case 'K': { // Send periodic 'keep-alive' requests to keep broken server sessions alive
+      sendKeepAlivesToBrokenServers = True;
+      break;
+    }
+
+    case 'A': { // specify a desired audio RTP payload format
+      unsigned formatArg;
+      if (sscanf(argv[2], "%u", &formatArg) != 1
+	  || formatArg >= 96) {
+	usage();
+      }
+      desiredAudioRTPPayloadFormat = (unsigned char)formatArg;
+      ++argv; --argc;
+      break;
+    }
+
+    case 'M': { // specify a MIME subtype for a dynamic RTP payload type
+      mimeSubtype = argv[2];
+      if (desiredAudioRTPPayloadFormat==0) desiredAudioRTPPayloadFormat =96;
+      ++argv; --argc;
+      break;
+    }
+
+    case 'w': { // specify a width (pixels) for an output QuickTime or AVI movie
+      if (sscanf(argv[2], "%hu", &movieWidth) != 1) {
+	usage();
+      }
+      movieWidthOptionSet = True;
+      ++argv; --argc;
+      break;
+    }
+
+    case 'h': { // specify a height (pixels) for an output QuickTime or AVI movie
+      if (sscanf(argv[2], "%hu", &movieHeight) != 1) {
+	usage();
+      }
+      movieHeightOptionSet = True;
+      ++argv; --argc;
+      break;
+    }
+
+    case 'f': { // specify a frame rate (per second) for an output QT or AVI movie
+      if (sscanf(argv[2], "%u", &movieFPS) != 1) {
+	usage();
+      }
+      movieFPSOptionSet = True;
+      ++argv; --argc;
+      break;
+    }
+
+    case 'F': { // specify a prefix for the audio and video output files
+      fileNamePrefix = argv[2];
+      ++argv; --argc;
+      break;
+    }
+
+    case 'g': { // specify a user agent name to use in outgoing requests
+      userAgent = argv[2];
+      ++argv; --argc;
+      break;
+    }
+
+    case 'b': { // specify the size of buffers for "FileSink"s
+      if (sscanf(argv[2], "%u", &fileSinkBufferSize) != 1) {
+	usage();
+      }
+      ++argv; --argc;
+      break;
+    }
+
+    case 'B': { // specify the size of input socket buffers
+      if (sscanf(argv[2], "%u", &socketInputBufferSize) != 1) {
+	usage();
+      }
+      ++argv; --argc;
+      break;
+    }
+
+    // Note: The following option is deprecated, and may someday be removed:
+    case 'l': { // try to compensate for packet loss by repeating frames
+      packetLossCompensate = True;
+      break;
+    }
+
+    case 'y': { // synchronize audio and video streams
+      syncStreams = True;
+      break;
+    }
+
+    case 'H': { // generate hint tracks (as well as the regular data tracks)
+      generateHintTracks = True;
+      break;
+    }
+
+    case 'Q': { // output QOS measurements
+      qosMeasurementIntervalMS = 1000; // default: 1 second
+
+      if (argc > 3 && argv[2][0] != '-') {
+	// The next argument is the measurement interval,
+	// in multiples of 100 ms
+	if (sscanf(argv[2], "%u", &qosMeasurementIntervalMS) != 1) {
+	  usage();
+	}
+	qosMeasurementIntervalMS *= 100;
+	++argv; --argc;
+      }
+      break;
+    }
+
+    case 's': { // specify initial seek time (trick play)
+      double arg;
+      if (sscanf(argv[2], "%lg", &arg) != 1 || arg < 0) {
+	usage();
+      }
+      initialSeekTime = arg;
+      ++argv; --argc;
+      break;
+    }
+
+    case 'U': {
+      // specify initial absolute seek time (trick play), using a string of the form "YYYYMMDDTHHMMSSZ" or "YYYYMMDDTHHMMSS.<frac>Z"
+      initialAbsoluteSeekTime = argv[2];
+      ++argv; --argc;
+      break;
+    }
+
+    case 'E': {
+      // specify initial absolute seek END time (trick play), using a string of the form "YYYYMMDDTHHMMSSZ" or "YYYYMMDDTHHMMSS.<frac>Z"
+      initialAbsoluteSeekEndTime = argv[2];
+      ++argv; --argc;
+      break;
+    }
+    case 'z': { // scale (trick play)
+      float arg;
+      if (sscanf(argv[2], "%g", &arg) != 1 || arg == 0.0f) {
+	usage();
+      }
+      scale = arg;
+      ++argv; --argc;
+      break;
+    }
+
+    case 'R': {
+      // set up a handler server for incoming "REGISTER" commands
+      createHandlerServerForREGISTERCommand = True;
+      if (argc > 2 && argv[2][0] != '-') {
+	// The next argument is the REGISTER handler server port number:
+	if (sscanf(argv[2], "%hu", &handlerServerForREGISTERCommandPortNum) == 1 && handlerServerForREGISTERCommandPortNum > 0) {
+	  ++argv; --argc;
+	  break;
+	}
+      }
+      break;
+    }
+
+    case 'C': {
+      forceMulticastOnUnspecified = True;
+      break;
+    }
+
+    default: {
+      *env << "Invalid option: " << opt << "\n";
+      usage();
+      break;
+    }
+    }
+
+    ++argv; --argc;
+  }
+
+  // There must be exactly one "rtsp://" URL at the end (unless '-R' was used, in which case there's no URL)
+  if (!( (argc == 2 && !createHandlerServerForREGISTERCommand) || (argc == 1 && createHandlerServerForREGISTERCommand) )) usage();
+  if (outputQuickTimeFile && outputAVIFile) {
+    *env << "The -i and -q (or -4) options cannot both be used!\n";
+    usage();
+  }
+  Boolean outputCompositeFile = outputQuickTimeFile || outputAVIFile;
+  if (!createReceivers && (outputCompositeFile || oneFilePerFrame || fileOutputInterval > 0)) {
+    *env << "The -r option cannot be used with -q, -4, -i, -m, or -P!\n";
+    usage();
+  }
+  if (oneFilePerFrame && fileOutputInterval > 0) {
+    *env << "The -m and -P options cannot both be used!\n";
+    usage();
+  }
+  if (outputCompositeFile && !movieWidthOptionSet) {
+    *env << "Warning: The -q, -4 or -i option was used, but not -w.  Assuming a video width of "
+	 << movieWidth << " pixels\n";
+  }
+  if (outputCompositeFile && !movieHeightOptionSet) {
+    *env << "Warning: The -q, -4 or -i option was used, but not -h.  Assuming a video height of "
+	 << movieHeight << " pixels\n";
+  }
+  if (outputCompositeFile && !movieFPSOptionSet) {
+    *env << "Warning: The -q, -4 or -i option was used, but not -f.  Assuming a video frame rate of "
+	 << movieFPS << " frames-per-second\n";
+  }
+k
+
+    *env << "The -a and -v options cannot both be used!\n";
+    usage();
+  }
+  if (sendOptionsRequestOnly && !sendOptionsRequest) {
+    *env << "The -o and -O options cannot both be used!\n";
+    usage();
+  }
+  if (initialAbsoluteSeekTime != NULL && initialSeekTime != 0.0f) {
+    *env << "The -s and -U options cannot both be used!\n";
+    usage();
+  }
+  if (initialAbsoluteSeekTime == NULL && initialAbsoluteSeekEndTime != NULL) {
+    *env << "The -E option requires the -U option!\n";
+    usage();
+  }
+  if (authDBForREGISTER != NULL && !createHandlerServerForREGISTERCommand) {
+    *env << "If \"-k <username> <password>\" is used, then -R (or \"-R <port-num>\") must also be used!\n";
+    usage();
+  }
+  if (tunnelOverHTTPPortNum > 0) {
+    if (streamUsingTCP) {
+      *env << "The -t and -T options cannot both be used!\n";
+      usage();
+    } else {
+      streamUsingTCP = True;
+    }
+  }
+  if (!createReceivers && notifyOnPacketArrival) {
+    *env << "Warning: Because we're not receiving stream data, the -n flag has no effect\n";
+  }
+  if (durationSlop < 0) {
+    // This parameter wasn't set, so use a default value.
+    // If we're measuring QOS stats, then don't add any slop, to avoid
+    // having 'empty' measurement intervals at the end.
+    durationSlop = qosMeasurementIntervalMS > 0 ? 0.0 : 5.0;
+  }
+
+  streamURL = argv[1];
+
+  // Create (or arrange to create) our client object:
+  if (createHandlerServerForREGISTERCommand) {
+    handlerServerForREGISTERCommand
+      = HandlerServerForREGISTERCommand::createNew(*env, continueAfterClientCreation0,
+						   handlerServerForREGISTERCommandPortNum, authDBForREGISTER,
+						   verbosityLevel, progName);
+    if (handlerServerForREGISTERCommand == NULL) {
+      *env << "Failed to create a server for handling incoming \"REGISTER\" commands: " << env->getResultMsg() << "\n";
+      shutdown();
+    } else {
+      *env << "Awaiting an incoming \"REGISTER\" command on port " << handlerServerForREGISTERCommand->serverPortNum() << "\n";
+    }
+  } else {
+    ourClient = createClient(*env, streamURL, verbosityLevel, progName);
+    if (ourClient == NULL) {
+      *env << "Failed to create " << clientProtocolName << " client: " << env->getResultMsg() << "\n";
+      shutdown();
+    }
+    continueAfterClientCreation1();
+  }
+
+  // All subsequent activity takes place within the event loop:
+  env->taskScheduler().doEventLoop(); // does not return
+
+  return 0; // only to prevent compiler warning
+}
+
+void continueAfterClientCreation0(RTSPClient* newRTSPClient, Boolean requestStreamingOverTCP) {
+  if (newRTSPClient == NULL) return;
+
+  streamUsingTCP = requestStreamingOverTCP;
+
+  assignClient(ourClient = newRTSPClient);
+  streamURL = newRTSPClient->url();
+
+  // Having handled one "REGISTER" command (giving us a "rtsp://" URL to stream from), we don't handle any more:
+  Medium::close(handlerServerForREGISTERCommand); handlerServerForREGISTERCommand = NULL;
+
+  continueAfterClientCreation1();
+}
+
+void continueAfterClientCreation1() {
+  setUserAgentString(userAgent);
+
+  if (sendOptionsRequest) {
+    // Begin by sending an "OPTIONS" command:
+    getOptions(continueAfterOPTIONS);
+  } else {
+    continueAfterOPTIONS(NULL, 0, NULL);
+  }
+}
+
+void continueAfterOPTIONS(RTSPClient*, int resultCode, char* resultString) {
+  if (sendOptionsRequestOnly) {
+    if (resultCode != 0) {
+      *env << clientProtocolName << " \"OPTIONS\" request failed: " << resultString << "\n";
+    } else {
+      *env << clientProtocolName << " \"OPTIONS\" request returned: " << resultString << "\n";
+    }
+    shutdown();
+  }
+  delete[] resultString;
+
+  // Next, get a SDP description for the stream:
+  getSDPDescription(continueAfterDESCRIBE);
+}
+
+void continueAfterDESCRIBE(RTSPClient*, int resultCode, char* resultString) {
+  if (resultCode != 0) {
+    *env << "Failed to get a SDP description for the URL \"" << streamURL << "\": " << resultString << "\n";
+    delete[] resultString;
+    shutdown();
+  }
+
+  char* sdpDescription = resultString;
+  *env << "Opened URL \"" << streamURL << "\", returning a SDP description:\n" << sdpDescription << "\n";
+
+  // Create a media session object from this SDP description:
+  session = MediaSession::createNew(*env, sdpDescription);
+  delete[] sdpDescription;
+  if (session == NULL) {
+    *env << "Failed to create a MediaSession object from the SDP description: " << env->getResultMsg() << "\n";
+    shutdown();
+  } else if (!session->hasSubsessions()) {
+    *env << "This session has no media subsessions (i.e., no \"m=\" lines)\n";
+    shutdown();
+  }
+
+  // Then, setup the "RTPSource"s for the session:
+  MediaSubsessionIterator iter(*session);
+  MediaSubsession *subsession;
+  Boolean madeProgress = False;
+  char const* singleMediumToTest = singleMedium;
+  while ((subsession = iter.next()) != NULL) {
+    // If we've asked to receive only a single medium, then check this now:
+    if (singleMediumToTest != NULL) {
+      if (strcmp(subsession->mediumName(), singleMediumToTest) != 0) {
+		  *env << "Ignoring \"" << subsession->mediumName()
+			  << "/" << subsession->codecName()
+			  << "\" subsession, because we've asked to receive a single " << singleMedium
+			  << " session only\n";
+	continue;
+      } else {
+	// Receive this subsession only
+	singleMediumToTest = "xxxxx";
+	    // this hack ensures that we get only 1 subsession of this type
+      }
+    }
+
+    if (desiredPortNum != 0) {
+      subsession->setClientPortNum(desiredPortNum);
+      desiredPortNum += 2;
+    }
+
+    if (createReceivers) {
+      if (!subsession->initiate(simpleRTPoffsetArg)) {
+	*env << "Unable to create receiver for \"" << subsession->mediumName()
+	     << "/" << subsession->codecName()
+	     << "\" subsession: " << env->getResultMsg() << "\n";
+      } else {
+	*env << "Created receiver for \"" << subsession->mediumName()
+	     << "/" << subsession->codecName() << "\" subsession (";
+	if (subsession->rtcpIsMuxed()) {
+	  *env << "client port " << subsession->clientPortNum();
+	} else {
+	  *env << "client ports " << subsession->clientPortNum()
+	       << "-" << subsession->clientPortNum()+1;
+	}
+	*env << ")\n";
+	madeProgress = True;
+	
+	if (subsession->rtpSource() != NULL) {
+	  // Because we're saving the incoming data, rather than playing
+	  // it in real time, allow an especially large time threshold
+	  // (1 second) for reordering misordered incoming packets:
+	  unsigned const thresh = 1000000; // 1 second
+	  subsession->rtpSource()->setPacketReorderingThresholdTime(thresh);
+	  
+	  // Set the RTP source's OS socket buffer size as appropriate - either if we were explicitly asked (using -B),
+	  // or if the desired FileSink buffer size happens to be larger than the current OS socket buffer size.
+	  // (The latter case is a heuristic, on the assumption that if the user asked for a large FileSink buffer size,
+	  // then the input data rate may be large enough to justify increasing the OS socket buffer size also.)
+	  int socketNum = subsession->rtpSource()->RTPgs()->socketNum();
+	  unsigned curBufferSize = getReceiveBufferSize(*env, socketNum);
+	  if (socketInputBufferSize > 0 || fileSinkBufferSize > curBufferSize) {
+	    unsigned newBufferSize = socketInputBufferSize > 0 ? socketInputBufferSize : fileSinkBufferSize;
+	    newBufferSize = setReceiveBufferTo(*env, socketNum, newBufferSize);
+	    if (socketInputBufferSize > 0) { // The user explicitly asked for the new socket buffer size; announce it:
+	      *env << "Changed socket receive buffer size for the \""
+		   << subsession->mediumName()
+		   << "/" << subsession->codecName()
+		   << "\" subsession from "
+		   << curBufferSize << " to "
+		   << newBufferSize << " bytes\n";
+	    }
+	  }
+	}
+      }
+    } else {
+      if (subsession->clientPortNum() == 0) {
+	*env << "No client port was specified for the \""
+	     << subsession->mediumName()
+	     << "/" << subsession->codecName()
+	     << "\" subsession.  (Try adding the \"-p <portNum>\" option.)\n";
+      } else {
+		madeProgress = True;
+      }
+    }
+  }
+  if (!madeProgress) shutdown();
+
+  // Perform additional 'setup' on each subsession, before playing them:
+  setupStreams();
+}
+
+MediaSubsession *subsession;
+Boolean madeProgress = False;
+void continueAfterSETUP(RTSPClient* client, int resultCode, char* resultString) {
+  if (resultCode == 0) {
+      *env << "Setup \"" << subsession->mediumName()
+	   << "/" << subsession->codecName()
+	   << "\" subsession (";
+      if (subsession->rtcpIsMuxed()) {
+	*env << "client port " << subsession->clientPortNum();
+      } else {
+	*env << "client ports " << subsession->clientPortNum()
+	     << "-" << subsession->clientPortNum()+1;
+      }
+      *env << ")\n";
+      madeProgress = True;
+  } else {
+    *env << "Failed to setup \"" << subsession->mediumName()
+	 << "/" << subsession->codecName()
+	 << "\" subsession: " << resultString << "\n";
+  }
+  delete[] resultString;
+
+  if (client != NULL) sessionTimeoutParameter = client->sessionTimeoutParameter();
+
+  // Set up the next subsession, if any:
+  setupStreams();
+}
+
+void createOutputFiles(char const* periodicFilenameSuffix) {
+  char outFileName[1000];
+
+  if (outputQuickTimeFile || outputAVIFile) {
+    if (periodicFilenameSuffix[0] == '\0') {
+      // Normally (unless the '-P <interval-in-seconds>' option was given) we output to 'stdout':
+      sprintf(outFileName, "stdout");
+    } else {
+      // Otherwise output to a type-specific file name, containing "periodicFilenameSuffix":
+      char const* prefix = fileNamePrefix[0] == '\0' ? "output" : fileNamePrefix;
+      snprintf(outFileName, sizeof outFileName, "%s%s.%s", prefix, periodicFilenameSuffix,
+	       outputAVIFile ? "avi" : generateMP4Format ? "mp4" : "mov");
+    }
+
+    if (outputQuickTimeFile) {
+      qtOut = QuickTimeFileSink::createNew(*env, *session, outFileName,
+					   fileSinkBufferSize,
+					   movieWidth, movieHeight,
+					   movieFPS,
+					   packetLossCompensate,
+					   syncStreams,
+					   generateHintTracks,
+					   generateMP4Format);
+      if (qtOut == NULL) {
+	*env << "Failed to create a \"QuickTimeFileSink\" for outputting to \""
+	     << outFileName << "\": " << env->getResultMsg() << "\n";
+	shutdown();
+      } else {
+	*env << "Outputting to the file: \"" << outFileName << "\"\n";
+      }
+      
+      qtOut->startPlaying(sessionAfterPlaying, NULL);
+    } else { // outputAVIFile
+      aviOut = AVIFileSink::createNew(*env, *session, outFileName,
+				      fileSinkBufferSize,
+				      movieWidth, movieHeight,
+				      movieFPS,
+				      packetLossCompensate);
+      if (aviOut == NULL) {
+	*env << "Failed to create an \"AVIFileSink\" for outputting to \""
+	     << outFileName << "\": " << env->getResultMsg() << "\n";
+	shutdown();
+      } else {
+	*env << "Outputting to the file: \"" << outFileName << "\"\n";
+      }
+      
+      aviOut->startPlaying(sessionAfterPlaying, NULL);
+    }
+  } else {
+    // Create and start "FileSink"s for each subsession:
+    madeProgress = False;
+    MediaSubsessionIterator iter(*session);
+    while ((subsession = iter.next()) != NULL) {
+      if (subsession->readSource() == NULL) continue; // was not initiated
+      
+      // Create an output file for each desired stream:
+      if (singleMedium == NULL || periodicFilenameSuffix[0] != '\0') {
+	// Output file name is
+	//     "<filename-prefix><medium_name>-<codec_name>-<counter><periodicFilenameSuffix>"
+	static unsigned streamCounter = 0;
+	snprintf(outFileName, sizeof outFileName, "%s%s-%s-%d%s",
+		 fileNamePrefix, subsession->mediumName(),
+		 subsession->codecName(), ++streamCounter, periodicFilenameSuffix);
+      } else {
+	// When outputting a single medium only, we output to 'stdout
+	// (unless the '-P <interval-in-seconds>' option was given):
+	sprintf(outFileName, "stdout");
+      }
+
+      FileSink* fileSink = NULL;
+      Boolean createOggFileSink = False; // by default
+      if (strcmp(subsession->mediumName(), "video") == 0) {
+	if (strcmp(subsession->codecName(), "H264") == 0) {
+	  // For H.264 video stream, we use a special sink that adds 'start codes',
+	  // and (at the start) the SPS and PPS NAL units:
+	  fileSink = H264VideoFileSink::createNew(*env, outFileName,
+						  subsession->fmtp_spropparametersets(),
+						  fileSinkBufferSize, oneFilePerFrame);
+	} else if (strcmp(subsession->codecName(), "H265") == 0) {
+	  // For H.265 video stream, we use a special sink that adds 'start codes',
+	  // and (at the start) the VPS, SPS, and PPS NAL units:
+	  fileSink = H265VideoFileSink::createNew(*env, outFileName,
+						  subsession->fmtp_spropvps(),
+						  subsession->fmtp_spropsps(),
+						  subsession->fmtp_sproppps(),
+						  fileSinkBufferSize, oneFilePerFrame);
+	} else if (strcmp(subsession->codecName(), "THEORA") == 0) {
+	  createOggFileSink = True;
+	}
+      } else if (strcmp(subsession->mediumName(), "audio") == 0) {
+	if (strcmp(subsession->codecName(), "AMR") == 0 ||
+	    strcmp(subsession->codecName(), "AMR-WB") == 0) {
+	  // For AMR audio streams, we use a special sink that inserts AMR frame hdrs:
+	  fileSink = AMRAudioFileSink::createNew(*env, outFileName,
+						 fileSinkBufferSize, oneFilePerFrame);
+	} else if (strcmp(subsession->codecName(), "VORBIS") == 0 ||
+		   strcmp(subsession->codecName(), "OPUS") == 0) {
+	  createOggFileSink = True;
+	} else if (strcmp(subsession->codecName(), "MPEG4-GENERIC") == 0) {
+	  // For AAC audio, we use a regular file sink, but add a 'ADTS framer' filter
+	  // to the end of the data source, so that the resulting file is playable:
+	  FramedFilter* adtsFramer
+	    = ADTSAudioStreamDiscreteFramer::createNew(*env, subsession->readSource(),
+						       subsession->fmtp_config());
+	  subsession->addFilter(adtsFramer);
+	}
+      }
+      if (createOggFileSink) {
+	fileSink = OggFileSink
+	  ::createNew(*env, outFileName,
+		      subsession->rtpTimestampFrequency(), subsession->fmtp_config());
+      } else if (fileSink == NULL) {
+	// Normal case:
+	fileSink = FileSink::createNew(*env, outFileName,
+				       fileSinkBufferSize, oneFilePerFrame);
+      }
+      subsession->sink = fileSink;
+
+      if (subsession->sink == NULL) {
+	*env << "Failed to create FileSink for \"" << outFileName
+	     << "\": " << env->getResultMsg() << "\n";
+      } else {
+	if (singleMedium == NULL) {
+	  *env << "Created output file: \"" << outFileName << "\"\n";
+	} else {
+	  *env << "Outputting data from the \"" << subsession->mediumName()
+	       << "/" << subsession->codecName()
+	       << "\" subsession to \"" << outFileName << "\"\n";
+	}
+	
+	if (strcmp(subsession->mediumName(), "video") == 0 &&
+	    strcmp(subsession->codecName(), "MP4V-ES") == 0 &&
+	    subsession->fmtp_config() != NULL) {
+	  // For MPEG-4 video RTP streams, the 'config' information
+	  // from the SDP description contains useful VOL etc. headers.
+	  // Insert this data at the front of the output file:
+	  unsigned configLen;
+	  unsigned char* configData
+	    = parseGeneralConfigStr(subsession->fmtp_config(), configLen);
+	  struct timeval timeNow;
+	  gettimeofday(&timeNow, NULL);
+	  fileSink->addData(configData, configLen, timeNow);
+	  delete[] configData;
+	}
+	
+	subsession->sink->startPlaying(*(subsession->readSource()),
+				       subsessionAfterPlaying,
+				       subsession);
+	
+	// Also set a handler to be called if a RTCP "BYE" arrives
+	// for this subsession:
+	if (subsession->rtcpInstance() != NULL) {
+	  subsession->rtcpInstance()->setByeWithReasonHandler(subsessionByeHandler, subsession);
+	}
+	
+	madeProgress = True;
+      }
+    }
+    if (!madeProgress) shutdown();
+  }
+}
+
+void createPeriodicOutputFiles() {
+  // Create a filename suffix that notes the time interval that's being recorded:
+  char periodicFileNameSuffix[100];
+  snprintf(periodicFileNameSuffix, sizeof periodicFileNameSuffix, "-%05d-%05d",
+	   fileOutputSecondsSoFar, fileOutputSecondsSoFar + fileOutputInterval);
+  createOutputFiles(periodicFileNameSuffix);
+
+  // Schedule an event for writing the next output file:
+  periodicFileOutputTask
+    = env->taskScheduler().scheduleDelayedTask(fileOutputInterval*1000000,
+					       (TaskFunc*)periodicFileOutputTimerHandler,
+					       (void*)NULL);
+}
+
+void setupStreams() {
+  static MediaSubsessionIterator* setupIter = NULL;
+  if (setupIter == NULL) setupIter = new MediaSubsessionIterator(*session);
+  while ((subsession = setupIter->next()) != NULL) {
+    // We have another subsession left to set up:
+    if (subsession->clientPortNum() == 0) continue; // port # was not set
+
+    setupSubsession(subsession, streamUsingTCP, forceMulticastOnUnspecified, continueAfterSETUP);
+    return;
+  }
+
+  // We're done setting up subsessions.
+  delete setupIter;
+  if (!madeProgress) shutdown();
+
+  // Create output files:
+  if (createReceivers) {
+    if (fileOutputInterval > 0) {
+      createPeriodicOutputFiles();
+    } else {
+      createOutputFiles("");
+    }
+  }
+
+  // Finally, start playing each subsession, to start the data flow:
+  if (duration == 0) {
+    if (scale > 0) duration = session->playEndTime() - initialSeekTime; // use SDP end time
+    else if (scale < 0) duration = initialSeekTime;
+  }
+  if (duration < 0) duration = 0.0;
+
+  endTime = initialSeekTime;
+  if (scale > 0) {
+    if (duration <= 0) endTime = -1.0f;
+    else endTime = initialSeekTime + duration;
+  } else {
+    endTime = initialSeekTime - duration;
+    if (endTime < 0) endTime = 0.0f;
+  }
+
+  char const* absStartTime = initialAbsoluteSeekTime != NULL ? initialAbsoluteSeekTime : session->absStartTime();
+  char const* absEndTime = initialAbsoluteSeekEndTime != NULL ? initialAbsoluteSeekEndTime : session->absEndTime();
+  if (absStartTime != NULL) {
+    // Either we or the server have specified that seeking should be done by 'absolute' time:
+    startPlayingSession(session, absStartTime, absEndTime, scale, continueAfterPLAY);
+  } else {
+    // Normal case: Seek by relative time (NPT):
+    startPlayingSession(session, initialSeekTime, endTime, scale, continueAfterPLAY);
+  }
+}
+
+void continueAfterPLAY(RTSPClient*, int resultCode, char* resultString) {
+  if (resultCode != 0) {
+    *env << "Failed to start playing session: " << resultString << "\n";
+    delete[] resultString;
+    shutdown();
+    return;
+  } else {
+    *env << "Started playing session\n";
+  }
+  delete[] resultString;
+
+  if (qosMeasurementIntervalMS > 0) {
+    // Begin periodic QOS measurements:
+    beginQOSMeasurement();
+  }
+
+  // Figure out how long to delay (if at all) before shutting down, or
+  // repeating the playing
+  Boolean timerIsBeingUsed = False;
+  double secondsToDelay = duration;
+  if (duration > 0) {
+    // First, adjust "duration" based on any change to the play range (that was specified in the "PLAY" response):
+    double rangeAdjustment = (session->playEndTime() - session->playStartTime()) - (endTime - initialSeekTime);
+    if (duration + rangeAdjustment > 0.0) duration += rangeAdjustment;
+
+    timerIsBeingUsed = True;
+    double absScale = scale > 0 ? scale : -scale; // ASSERT: scale != 0
+    secondsToDelay = duration/absScale + durationSlop;
+
+    int64_t uSecsToDelay = (int64_t)(secondsToDelay*1000000.0);
+    sessionTimerTask = env->taskScheduler().scheduleDelayedTask(uSecsToDelay, (TaskFunc*)sessionTimerHandler, (void*)NULL);
+  }
+
+  char const* actionString
+    = createReceivers? "Receiving streamed data":"Data is being streamed";
+  if (timerIsBeingUsed) {
+    *env << actionString
+		<< " (for up to " << secondsToDelay
+		<< " seconds)...\n";
+  } else {
+#ifdef USE_SIGNALS
+    pid_t ourPid = getpid();
+    *env << actionString
+		<< " (signal with \"kill -HUP " << (int)ourPid
+		<< "\" or \"kill -USR1 " << (int)ourPid
+		<< "\" to terminate)...\n";
+#else
+    *env << actionString << "...\n";
+#endif
+  }
+
+  sessionTimeoutBrokenServerTask = NULL;
+
+  // Watch for incoming packets (if desired):
+  checkForPacketArrival(NULL);
+  checkInterPacketGaps(NULL);
+  checkSessionTimeoutBrokenServer(NULL);
+}
+
+void closeMediaSinks() {
+  Medium::close(qtOut); qtOut = NULL;
+  Medium::close(aviOut); aviOut = NULL;
+
+  if (session == NULL) return;
+  MediaSubsessionIterator iter(*session);
+  MediaSubsession* subsession;
+  while ((subsession = iter.next()) != NULL) {
+    Medium::close(subsession->sink);
+    subsession->sink = NULL;
+  }
+}
+
+void subsessionAfterPlaying(void* clientData) {
+  // Begin by closing this media subsession's stream:
+  MediaSubsession* subsession = (MediaSubsession*)clientData;
+  Medium::close(subsession->sink);
+  subsession->sink = NULL;
+
+  // Next, check whether *all* subsessions' streams have now been closed:
+  MediaSession& session = subsession->parentSession();
+  MediaSubsessionIterator iter(session);
+  while ((subsession = iter.next()) != NULL) {
+    if (subsession->sink != NULL) return; // this subsession is still active
+  }
+
+  // All subsessions' streams have now been closed
+  sessionAfterPlaying();
+}
+
+void subsessionByeHandler(void* clientData, char const* reason) {
+  struct timeval timeNow;
+  gettimeofday(&timeNow, NULL);
+  unsigned secsDiff = timeNow.tv_sec - startTime.tv_sec;
+
+  MediaSubsession* subsession = (MediaSubsession*)clientData;
+  *env << "Received RTCP \"BYE\"";
+  if (reason != NULL) {
+    *env << " (reason:\"" << reason << "\")";
+    delete[] (char*)reason;
+  }
+  *env << " on \"" << subsession->mediumName()
+	<< "/" << subsession->codecName()
+	<< "\" subsession (after " << secsDiff
+	<< " seconds)\n";
+
+  // Act now as if the subsession had closed:
+  subsessionAfterPlaying(subsession);
+}
+
+void sessionAfterPlaying(void* /*clientData*/) {
+  if (!playContinuously) {
+    shutdown(0);
+  } else {
+    // We've been asked to play the stream(s) over again.
+    // First, reset state from the current session:
+    if (env != NULL) {
+      // Keep this running:      env->taskScheduler().unscheduleDelayedTask(periodicFileOutputTask);
+      env->taskScheduler().unscheduleDelayedTask(sessionTimerTask);
+      env->taskScheduler().unscheduleDelayedTask(sessionTimeoutBrokenServerTask);
+      env->taskScheduler().unscheduleDelayedTask(arrivalCheckTimerTask);
+      env->taskScheduler().unscheduleDelayedTask(interPacketGapCheckTimerTask);
+      env->taskScheduler().unscheduleDelayedTask(qosMeasurementTimerTask);
+    }
+    totNumPacketsReceived = ~0;
+
+    startPlayingSession(session, initialSeekTime, endTime, scale, continueAfterPLAY);
+  }
+}
+
+void sessionTimerHandler(void* /*clientData*/) {
+  sessionTimerTask = NULL;
+
+  sessionAfterPlaying();
+}
+
+void periodicFileOutputTimerHandler(void* /*clientData*/) {
+  periodicFileOutputTask = NULL;
+  fileOutputSecondsSoFar += fileOutputInterval;
+
+  // First, close the existing output files:
+  closeMediaSinks();
+
+  // Then, create new output files:
+  createPeriodicOutputFiles();
+}
+
+class qosMeasurementRecord {
+public:
+  qosMeasurementRecord(struct timeval const& startTime, RTPSource* src)
+    : fSource(src), fNext(NULL),
+      kbits_per_second_min(1e20), kbits_per_second_max(0),
+      kBytesTotal(0.0),
+      packet_loss_fraction_min(1.0), packet_loss_fraction_max(0.0),
+      totNumPacketsReceived(0), totNumPacketsExpected(0) {
+    measurementEndTime = measurementStartTime = startTime;
+
+    RTPReceptionStatsDB::Iterator statsIter(src->receptionStatsDB());
+    // Assume that there's only one SSRC source (usually the case):
+    RTPReceptionStats* stats = statsIter.next(True);
+    if (stats != NULL) {
+      kBytesTotal = stats->totNumKBytesReceived();
+      totNumPacketsReceived = stats->totNumPacketsReceived();
+      totNumPacketsExpected = stats->totNumPacketsExpected();
+    }
+  }
+  virtual ~qosMeasurementRecord() { delete fNext; }
+
+  void periodicQOSMeasurement(struct timeval const& timeNow);
+
+public:
+  RTPSource* fSource;
+  qosMeasurementRecord* fNext;
+
+public:
+  struct timeval measurementStartTime, measurementEndTime;
+  double kbits_per_second_min, kbits_per_second_max;
+  double kBytesTotal;
+  double packet_loss_fraction_min, packet_loss_fraction_max;
+  unsigned totNumPacketsReceived, totNumPacketsExpected;
+};
+
+static qosMeasurementRecord* qosRecordHead = NULL;
+
+static void periodicQOSMeasurement(void* clientData); // forward
+
+static unsigned nextQOSMeasurementUSecs;
+
+static void scheduleNextQOSMeasurement() {
+  nextQOSMeasurementUSecs += qosMeasurementIntervalMS*1000;
+  struct timeval timeNow;
+  gettimeofday(&timeNow, NULL);
+  unsigned timeNowUSecs = timeNow.tv_sec*1000000 + timeNow.tv_usec;
+  int usecsToDelay = nextQOSMeasurementUSecs - timeNowUSecs;
+
+  qosMeasurementTimerTask = env->taskScheduler().scheduleDelayedTask(
+     usecsToDelay, (TaskFunc*)periodicQOSMeasurement, (void*)NULL);
+}
+
+static void periodicQOSMeasurement(void* /*clientData*/) {
+  struct timeval timeNow;
+  gettimeofday(&timeNow, NULL);
+
+  for (qosMeasurementRecord* qosRecord = qosRecordHead;
+       qosRecord != NULL; qosRecord = qosRecord->fNext) {
+    qosRecord->periodicQOSMeasurement(timeNow);
+  }
+
+  // Do this again later:
+  scheduleNextQOSMeasurement();
+}
+
+void qosMeasurementRecord
+::periodicQOSMeasurement(struct timeval const& timeNow) {
+  unsigned secsDiff = timeNow.tv_sec - measurementEndTime.tv_sec;
+  int usecsDiff = timeNow.tv_usec - measurementEndTime.tv_usec;
+  double timeDiff = secsDiff + usecsDiff/1000000.0;
+  measurementEndTime = timeNow;
+
+  RTPReceptionStatsDB::Iterator statsIter(fSource->receptionStatsDB());
+  // Assume that there's only one SSRC source (usually the case):
+  RTPReceptionStats* stats = statsIter.next(True);
+  if (stats != NULL) {
+    double kBytesTotalNow = stats->totNumKBytesReceived();
+    double kBytesDeltaNow = kBytesTotalNow - kBytesTotal;
+    kBytesTotal = kBytesTotalNow;
+
+    double kbpsNow = timeDiff == 0.0 ? 0.0 : 8*kBytesDeltaNow/timeDiff;
+    if (kbpsNow < 0.0) kbpsNow = 0.0; // in case of roundoff error
+    if (kbpsNow < kbits_per_second_min) kbits_per_second_min = kbpsNow;
+    if (kbpsNow > kbits_per_second_max) kbits_per_second_max = kbpsNow;
+
+    unsigned totReceivedNow = stats->totNumPacketsReceived();
+    unsigned totExpectedNow = stats->totNumPacketsExpected();
+    unsigned deltaReceivedNow = totReceivedNow - totNumPacketsReceived;
+    unsigned deltaExpectedNow = totExpectedNow - totNumPacketsExpected;
+    totNumPacketsReceived = totReceivedNow;
+    totNumPacketsExpected = totExpectedNow;
+
+    double lossFractionNow = deltaExpectedNow == 0 ? 0.0
+      : 1.0 - deltaReceivedNow/(double)deltaExpectedNow;
+    //if (lossFractionNow < 0.0) lossFractionNow = 0.0; //reordering can cause
+    if (lossFractionNow < packet_loss_fraction_min) {
+      packet_loss_fraction_min = lossFractionNow;
+    }
+    if (lossFractionNow > packet_loss_fraction_max) {
+      packet_loss_fraction_max = lossFractionNow;
+    }
+  }
+}
+
+void beginQOSMeasurement() {
+  // Set up a measurement record for each active subsession:
+  struct timeval startTime;
+  gettimeofday(&startTime, NULL);
+  nextQOSMeasurementUSecs = startTime.tv_sec*1000000 + startTime.tv_usec;
+  qosMeasurementRecord* qosRecordTail = NULL;
+  MediaSubsessionIterator iter(*session);
+  MediaSubsession* subsession;
+  while ((subsession = iter.next()) != NULL) {
+    RTPSource* src = subsession->rtpSource();
+    if (src == NULL) continue;
+
+    qosMeasurementRecord* qosRecord
+      = new qosMeasurementRecord(startTime, src);
+    if (qosRecordHead == NULL) qosRecordHead = qosRecord;
+    if (qosRecordTail != NULL) qosRecordTail->fNext = qosRecord;
+    qosRecordTail  = qosRecord;
+  }
+
+  // Then schedule the first of the periodic measurements:
+  scheduleNextQOSMeasurement();
+}
+
+void printQOSData(int exitCode) {
+  *env << "begin_QOS_statistics\n";
+  
+  // Print out stats for each active subsession:
+  qosMeasurementRecord* curQOSRecord = qosRecordHead;
+  if (session != NULL) {
+    MediaSubsessionIterator iter(*session);
+    MediaSubsession* subsession;
+    while ((subsession = iter.next()) != NULL) {
+      RTPSource* src = subsession->rtpSource();
+      if (src == NULL) continue;
+      
+      *env << "subsession\t" << subsession->mediumName()
+	   << "/" << subsession->codecName() << "\n";
+      
+      unsigned numPacketsReceived = 0, numPacketsExpected = 0;
+      
+      if (curQOSRecord != NULL) {
+	numPacketsReceived = curQOSRecord->totNumPacketsReceived;
+	numPacketsExpected = curQOSRecord->totNumPacketsExpected;
+      }
+      *env << "num_packets_received\t" << numPacketsReceived << "\n";
+      *env << "num_packets_lost\t" << int(numPacketsExpected - numPacketsReceived) << "\n";
+      
+      if (curQOSRecord != NULL) {
+	unsigned secsDiff = curQOSRecord->measurementEndTime.tv_sec
+	  - curQOSRecord->measurementStartTime.tv_sec;
+	int usecsDiff = curQOSRecord->measurementEndTime.tv_usec
+	  - curQOSRecord->measurementStartTime.tv_usec;
+	double measurementTime = secsDiff + usecsDiff/1000000.0;
+	*env << "elapsed_measurement_time\t" << measurementTime << "\n";
+	
+	*env << "kBytes_received_total\t" << curQOSRecord->kBytesTotal << "\n";
+	
+	*env << "measurement_sampling_interval_ms\t" << qosMeasurementIntervalMS << "\n";
+	
+	if (curQOSRecord->kbits_per_second_max == 0) {
+	  // special case: we didn't receive any data:
+	  *env <<
+	    "kbits_per_second_min\tunavailable\n"
+	    "kbits_per_second_ave\tunavailable\n"
+	    "kbits_per_second_max\tunavailable\n";
+	} else {
+	  *env << "kbits_per_second_min\t" << curQOSRecord->kbits_per_second_min << "\n";
+	  *env << "kbits_per_second_ave\t"
+	       << (measurementTime == 0.0 ? 0.0 : 8*curQOSRecord->kBytesTotal/measurementTime) << "\n";
+	  *env << "kbits_per_second_max\t" << curQOSRecord->kbits_per_second_max << "\n";
+	}
+	
+	*env << "packet_loss_percentage_min\t" << 100*curQOSRecord->packet_loss_fraction_min << "\n";
+	double packetLossFraction = numPacketsExpected == 0 ? 1.0
+	  : 1.0 - numPacketsReceived/(double)numPacketsExpected;
+	if (packetLossFraction < 0.0) packetLossFraction = 0.0;
+	*env << "packet_loss_percentage_ave\t" << 100*packetLossFraction << "\n";
+	*env << "packet_loss_percentage_max\t"
+	     << (packetLossFraction == 1.0 ? 100.0 : 100*curQOSRecord->packet_loss_fraction_max) << "\n";
+	
+	RTPReceptionStatsDB::Iterator statsIter(src->receptionStatsDB());
+	// Assume that there's only one SSRC source (usually the case):
+	RTPReceptionStats* stats = statsIter.next(True);
+	if (stats != NULL) {
+	  *env << "inter_packet_gap_ms_min\t" << stats->minInterPacketGapUS()/1000.0 << "\n";
+	  struct timeval totalGaps = stats->totalInterPacketGaps();
+	  double totalGapsMS = totalGaps.tv_sec*1000.0 + totalGaps.tv_usec/1000.0;
+	  unsigned totNumPacketsReceived = stats->totNumPacketsReceived();
+	  *env << "inter_packet_gap_ms_ave\t"
+	       << (totNumPacketsReceived == 0 ? 0.0 : totalGapsMS/totNumPacketsReceived) << "\n";
+	  *env << "inter_packet_gap_ms_max\t" << stats->maxInterPacketGapUS()/1000.0 << "\n";
+	}
+	
+	curQOSRecord = curQOSRecord->fNext;
+      }
+    }
+  }
+
+  *env << "end_QOS_statistics\n";
+  delete qosRecordHead;
+}
+
+Boolean areAlreadyShuttingDown = False;
+int shutdownExitCode;
+void shutdown(int exitCode) {
+  if (areAlreadyShuttingDown) return; // in case we're called after receiving a RTCP "BYE" while in the middle of a "TEARDOWN".
+  areAlreadyShuttingDown = True;
+
+  shutdownExitCode = exitCode;
+  if (env != NULL) {
+    env->taskScheduler().unscheduleDelayedTask(periodicFileOutputTask);
+    env->taskScheduler().unscheduleDelayedTask(sessionTimerTask);
+    env->taskScheduler().unscheduleDelayedTask(sessionTimeoutBrokenServerTask);
+    env->taskScheduler().unscheduleDelayedTask(arrivalCheckTimerTask);
+    env->taskScheduler().unscheduleDelayedTask(interPacketGapCheckTimerTask);
+    env->taskScheduler().unscheduleDelayedTask(qosMeasurementTimerTask);
+  }
+
+  if (qosMeasurementIntervalMS > 0) {
+    printQOSData(exitCode);
+  }
+
+  // Teardown, then shutdown, any outstanding RTP/RTCP subsessions
+  Boolean shutdownImmediately = True; // by default
+  if (session != NULL) {
+    RTSPClient::responseHandler* responseHandlerForTEARDOWN = NULL; // unless:
+    if (waitForResponseToTEARDOWN) {
+      shutdownImmediately = False;
+      responseHandlerForTEARDOWN = continueAfterTEARDOWN;
+    }
+    tearDownSession(session, responseHandlerForTEARDOWN);
+  }
+
+  if (shutdownImmediately) continueAfterTEARDOWN(NULL, 0, NULL);
+}
+
+void continueAfterTEARDOWN(RTSPClient*, int /*resultCode*/, char* resultString) {
+  delete[] resultString;
+
+  // Now that we've stopped any more incoming data from arriving, close our output files:
+  closeMediaSinks();
+  Medium::close(session);
+
+  // Finally, shut down our client:
+  delete ourAuthenticator;
+  delete authDBForREGISTER;
+  Medium::close(ourClient);
+
+  // Adios...
+  exit(shutdownExitCode);
+}
+
+void signalHandlerShutdown(int /*sig*/) {
+  *env << "Got shutdown signal\n";
+  waitForResponseToTEARDOWN = False; // to ensure that we end, even if the server does not respond to our TEARDOWN
+  shutdown(0);
+}
+
+void checkForPacketArrival(void* /*clientData*/) {
+  arrivalCheckTimerTask = NULL;
+  if (!notifyOnPacketArrival) return; // we're not checking
+
+  // Check each subsession, to see whether it has received data packets:
+  unsigned numSubsessionsChecked = 0;
+  unsigned numSubsessionsWithReceivedData = 0;
+  unsigned numSubsessionsThatHaveBeenSynced = 0;
+
+  MediaSubsessionIterator iter(*session);
+  MediaSubsession* subsession;
+  while ((subsession = iter.next()) != NULL) {
+    RTPSource* src = subsession->rtpSource();
+    if (src == NULL) continue;
+    ++numSubsessionsChecked;
+
+    if (src->receptionStatsDB().numActiveSourcesSinceLastReset() > 0) {
+      // At least one data packet has arrived
+      ++numSubsessionsWithReceivedData;
+    }
+    if (src->hasBeenSynchronizedUsingRTCP()) {
+      ++numSubsessionsThatHaveBeenSynced;
+    }
+  }
+
+  unsigned numSubsessionsToCheck = numSubsessionsChecked;
+  // Special case for "QuickTimeFileSink"s and "AVIFileSink"s:
+  // They might not use all of the input sources:
+  if (qtOut != NULL) {
+    numSubsessionsToCheck = qtOut->numActiveSubsessions();
+  } else if (aviOut != NULL) {
+    numSubsessionsToCheck = aviOut->numActiveSubsessions();
+  }
+
+  Boolean notifyTheUser;
+  if (!syncStreams) {
+    notifyTheUser = numSubsessionsWithReceivedData > 0; // easy case
+  } else {
+    notifyTheUser = numSubsessionsWithReceivedData >= numSubsessionsToCheck
+      && numSubsessionsThatHaveBeenSynced == numSubsessionsChecked;
+    // Note: A subsession with no active sources is considered to be synced
+  }
+  if (notifyTheUser) {
+    struct timeval timeNow;
+    gettimeofday(&timeNow, NULL);
+	char timestampStr[100];
+	sprintf(timestampStr, "%ld%03ld", timeNow.tv_sec, (long)(timeNow.tv_usec/1000));
+    *env << (syncStreams ? "Synchronized d" : "D")
+		<< "ata packets have begun arriving [" << timestampStr << "]\007\n";
+    return;
+  }
+
+  // No luck, so reschedule this check again, after a delay:
+  int uSecsToDelay = 100000; // 100 ms
+  arrivalCheckTimerTask
+    = env->taskScheduler().scheduleDelayedTask(uSecsToDelay,
+			       (TaskFunc*)checkForPacketArrival, NULL);
+}
+
+void checkInterPacketGaps(void* /*clientData*/) {
+  interPacketGapCheckTimerTask = NULL;
+  if (interPacketGapMaxTime == 0) return; // we're not checking
+
+  // Check each subsession, counting up how many packets have been received:
+  unsigned newTotNumPacketsReceived = 0;
+
+  MediaSubsessionIterator iter(*session);
+  MediaSubsession* subsession;
+  while ((subsession = iter.next()) != NULL) {
+    RTPSource* src = subsession->rtpSource();
+    if (src == NULL) continue;
+    newTotNumPacketsReceived += src->receptionStatsDB().totNumPacketsReceived();
+  }
+
+  if (newTotNumPacketsReceived == totNumPacketsReceived) {
+    // No additional packets have been received since the last time we
+    // checked, so end this stream:
+    *env << "Closing session, because we stopped receiving packets.\n";
+    interPacketGapCheckTimerTask = NULL;
+    sessionAfterPlaying();
+  } else {
+    totNumPacketsReceived = newTotNumPacketsReceived;
+    // Check again, after the specified delay:
+    interPacketGapCheckTimerTask
+      = env->taskScheduler().scheduleDelayedTask(interPacketGapMaxTime*1000000,
+				 (TaskFunc*)checkInterPacketGaps, NULL);
+  }
+}
+
+void checkSessionTimeoutBrokenServer(void* /*clientData*/) {
+  if (!sendKeepAlivesToBrokenServers) return; // we're not checking
+
+  // Send an "OPTIONS" request, starting with the second call
+  if (sessionTimeoutBrokenServerTask != NULL) {
+    getOptions(NULL);
+  }
+  
+  unsigned sessionTimeout = sessionTimeoutParameter == 0 ? 60/*default*/ : sessionTimeoutParameter;
+  unsigned secondsUntilNextKeepAlive = sessionTimeout <= 5 ? 1 : sessionTimeout - 5;
+      // Reduce the interval a little, to be on the safe side
+
+  sessionTimeoutBrokenServerTask 
+    = env->taskScheduler().scheduleDelayedTask(secondsUntilNextKeepAlive*1000000,
+			 (TaskFunc*)checkSessionTimeoutBrokenServer, NULL);
+					       
+}
diff --git a/3rdparty/live555/src/testProgs/CMakeLists.txt b/3rdparty/live555/src/testProgs/CMakeLists.txt
new file mode 100644
index 00000000..d492d0e3
--- /dev/null
+++ b/3rdparty/live555/src/testProgs/CMakeLists.txt
@@ -0,0 +1,13 @@
+cmake_minimum_required(VERSION 3.0.0)
+
+add_executable(testRtspClient testRTSPClient.cpp)
+target_include_directories(testRtspClient
+    PRIVATE
+    ${LIVE555_INCLUDE_DIRS}
+)
+target_link_libraries(testRtspClient PRIVATE live555)
+
+
+# if (WIN32)
+#     target_link_libraries(testRtspClient PRIVATE Ws2_32)
+# endif ()
\ No newline at end of file
diff --git a/3rdparty/live555/src/testProgs/MPEG2TransportStreamIndexer.cpp b/3rdparty/live555/src/testProgs/MPEG2TransportStreamIndexer.cpp
new file mode 100644
index 00000000..24d01419
--- /dev/null
+++ b/3rdparty/live555/src/testProgs/MPEG2TransportStreamIndexer.cpp
@@ -0,0 +1,88 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// Copyright (c) 1996-2022, Live Networks, Inc.  All rights reserved
+// A program that reads an existing MPEG-2 Transport Stream file,
+// and generates a separate index file that can be used - by our RTSP server
+// implementation - to support 'trick play' operations when streaming the
+// Transport Stream file.
+// main program
+
+#include <liveMedia.hh>
+#include <BasicUsageEnvironment.hh>
+
+void afterPlaying(void *clientData);  // forward
+
+UsageEnvironment *env;
+char const *      programName;
+
+void usage() {
+    *env << "usage: " << programName << " <transport-stream-file-name>\n";
+    *env << "\twhere <transport-stream-file-name> ends with \".ts\"\n";
+    exit(1);
+}
+
+int main(int argc, char const **argv) {
+    // Begin by setting up our usage environment:
+    TaskScheduler *scheduler = BasicTaskScheduler::createNew();
+    env                      = BasicUsageEnvironment::createNew(*scheduler);
+
+    // Parse the command line:
+    programName = argv[0];
+    if(argc != 2)
+        usage();
+
+    char const *inputFileName = argv[1];
+    // Check whether the input file name ends with ".ts":
+    int len = strlen(inputFileName);
+    if(len < 4 || strcmp(&inputFileName[len - 3], ".ts") != 0) {
+        *env << "ERROR: input file name \"" << inputFileName << "\" does not end with \".ts\"\n";
+        usage();
+    }
+
+    // Open the input file (as a 'byte stream file source'):
+    FramedSource *input = ByteStreamFileSource::createNew(*env, inputFileName, TRANSPORT_PACKET_SIZE);
+    if(input == NULL) {
+        *env << "Failed to open input file \"" << inputFileName << "\" (does it exist?)\n";
+        exit(1);
+    }
+
+    // Create a filter that indexes the input Transport Stream data:
+    FramedSource *indexer = MPEG2IFrameIndexFromTransportStream::createNew(*env, input);
+
+    // The output file name is the same as the input file name, except with suffix ".tsx":
+    char *outputFileName = new char[len + 2];  // allow for trailing x\0
+    sprintf(outputFileName, "%sx", inputFileName);
+
+    // Open the output file (for writing), as a 'file sink':
+    MediaSink *output = FileSink::createNew(*env, outputFileName);
+    if(output == NULL) {
+        *env << "Failed to open output file \"" << outputFileName << "\"\n";
+        exit(1);
+    }
+
+    // Start playing, to generate the output index file:
+    *env << "Writing index file \"" << outputFileName << "\"...";
+    output->startPlaying(*indexer, afterPlaying, NULL);
+
+    env->taskScheduler().doEventLoop();  // does not return
+
+    return 0;  // only to prevent compiler warning
+}
+
+void afterPlaying(void * /*clientData*/) {
+    *env << "...done\n";
+    exit(0);
+}
diff --git a/3rdparty/live555/src/testProgs/Makefile.head b/3rdparty/live555/src/testProgs/Makefile.head
new file mode 100644
index 00000000..327a98ea
--- /dev/null
+++ b/3rdparty/live555/src/testProgs/Makefile.head
@@ -0,0 +1,8 @@
+PREFIX = /usr/local
+INCLUDES = -I../UsageEnvironment/include -I../groupsock/include -I../liveMedia/include -I../BasicUsageEnvironment/include
+# Default library filename suffixes for each library that we link with.  The "config.*" file might redefine these later.
+libliveMedia_LIB_SUFFIX = $(LIB_SUFFIX)
+libBasicUsageEnvironment_LIB_SUFFIX = $(LIB_SUFFIX)
+libUsageEnvironment_LIB_SUFFIX = $(LIB_SUFFIX)
+libgroupsock_LIB_SUFFIX = $(LIB_SUFFIX)
+##### Change the following for your environment:
diff --git a/3rdparty/live555/src/testProgs/Makefile.tail b/3rdparty/live555/src/testProgs/Makefile.tail
new file mode 100644
index 00000000..07aa0521
--- /dev/null
+++ b/3rdparty/live555/src/testProgs/Makefile.tail
@@ -0,0 +1,178 @@
+##### End of variables to change
+
+MULTICAST_STREAMER_APPS = testMP3Streamer$(EXE) testMPEG1or2VideoStreamer$(EXE) testMPEG1or2AudioVideoStreamer$(EXE) testMPEG2TransportStreamer$(EXE) testMPEG4VideoStreamer$(EXE) testH264VideoStreamer$(EXE) testH265VideoStreamer$(EXE) testDVVideoStreamer$(EXE) testWAVAudioStreamer$(EXE) testAMRAudioStreamer$(EXE) testMKVStreamer$(EXE) testOggStreamer$(EXE) vobStreamer$(EXE)
+MULTICAST_RECEIVER_APPS = testMP3Receiver$(EXE) testMPEG1or2VideoReceiver$(EXE) testMPEG2TransportReceiver$(EXE) sapWatch$(EXE)
+MULTICAST_MISC_APPS = testRelay$(EXE) testReplicator$(EXE)
+MULTICAST_APPS = $(MULTICAST_STREAMER_APPS) $(MULTICAST_RECEIVER_APPS) $(MULTICAST_MISC_APPS)
+
+UNICAST_STREAMER_APPS = testOnDemandRTSPServer$(EXE)
+UNICAST_RECEIVER_APPS = testRTSPClient$(EXE) openRTSP$(EXE) playSIP$(EXE)
+UNICAST_APPS = $(UNICAST_STREAMER_APPS) $(UNICAST_RECEIVER_APPS)
+
+HLS_APPS = testH264VideoToHLSSegments$(EXE)
+
+MISC_APPS = testMPEG1or2Splitter$(EXE) testMPEG1or2ProgramToTransportStream$(EXE) testH264VideoToTransportStream$(EXE) testH265VideoToTransportStream$(EXE) MPEG2TransportStreamIndexer$(EXE) testMPEG2TransportStreamTrickPlay$(EXE) registerRTSPStream$(EXE) testMKVSplitter$(EXE) testMPEG2TransportStreamSplitter$(EXE) mikeyParse$(EXE)
+
+ALL = $(MULTICAST_APPS) $(UNICAST_APPS) $(HLS_APPS) $(MISC_APPS)
+all: $(ALL)
+
+extra:	testGSMStreamer$(EXE)
+
+.$(C).$(OBJ):
+	$(C_COMPILER) -c $(C_FLAGS) $<
+.$(CPP).$(OBJ):
+	$(CPLUSPLUS_COMPILER) -c $(CPLUSPLUS_FLAGS) $<
+
+HELPER_OBJS = announceURL.$(OBJ)
+MP3_STREAMER_OBJS = testMP3Streamer.$(OBJ)
+MP3_RECEIVER_OBJS = testMP3Receiver.$(OBJ)
+RELAY_OBJS = testRelay.$(OBJ)
+REPLICATOR_OBJS = testReplicator.$(OBJ)
+H264_VIDEO_TO_HLS_SEGMENTS_OBJS = testH264VideoToHLSSegments.$(OBJ)
+MPEG_1OR2_SPLITTER_OBJS = testMPEG1or2Splitter.$(OBJ)
+MPEG_1OR2_VIDEO_STREAMER_OBJS = testMPEG1or2VideoStreamer.$(OBJ)
+MPEG_1OR2_VIDEO_RECEIVER_OBJS = testMPEG1or2VideoReceiver.$(OBJ)
+MPEG2_TRANSPORT_RECEIVER_OBJS = testMPEG2TransportReceiver.$(OBJ)
+MPEG_1OR2_AUDIO_VIDEO_STREAMER_OBJS = testMPEG1or2AudioVideoStreamer.$(OBJ)
+MPEG2_TRANSPORT_STREAMER_OBJS = testMPEG2TransportStreamer.$(OBJ)
+MPEG4_VIDEO_STREAMER_OBJS = testMPEG4VideoStreamer.$(OBJ)
+H264_VIDEO_STREAMER_OBJS = testH264VideoStreamer.$(OBJ)
+H265_VIDEO_STREAMER_OBJS = testH265VideoStreamer.$(OBJ)
+DV_VIDEO_STREAMER_OBJS = testDVVideoStreamer.$(OBJ)
+WAV_AUDIO_STREAMER_OBJS = testWAVAudioStreamer.$(OBJ)
+AMR_AUDIO_STREAMER_OBJS	= testAMRAudioStreamer.$(OBJ)
+ON_DEMAND_RTSP_SERVER_OBJS	= testOnDemandRTSPServer.$(OBJ)
+MKV_STREAMER_OBJS	= testMKVStreamer.$(OBJ)
+OGG_STREAMER_OBJS	= testOggStreamer.$(OBJ)
+VOB_STREAMER_OBJS	= vobStreamer.$(OBJ)
+TEST_RTSP_CLIENT_OBJS    = testRTSPClient.$(OBJ)
+OPEN_RTSP_OBJS    = openRTSP.$(OBJ) playCommon.$(OBJ)
+PLAY_SIP_OBJS     = playSIP.$(OBJ) playCommon.$(OBJ)
+SAP_WATCH_OBJS = sapWatch.$(OBJ)
+MPEG_1OR2_PROGRAM_TO_TRANSPORT_STREAM_OBJS = testMPEG1or2ProgramToTransportStream.$(OBJ)
+H264_VIDEO_TO_TRANSPORT_STREAM_OBJS = testH264VideoToTransportStream.$(OBJ)
+H265_VIDEO_TO_TRANSPORT_STREAM_OBJS = testH265VideoToTransportStream.$(OBJ)
+MPEG2_TRANSPORT_STREAM_INDEXER_OBJS = MPEG2TransportStreamIndexer.$(OBJ)
+MPEG2_TRANSPORT_STREAM_TRICK_PLAY_OBJS = testMPEG2TransportStreamTrickPlay.$(OBJ)
+REGISTER_RTSP_STREAM_OBJS = registerRTSPStream.$(OBJ)
+TEST_MKV_SPLITTER_OBJS = testMKVSplitter.$(OBJ)
+TEST_MPEG2_TRANSPORT_STREAM_SPLITTER_OBJS = testMPEG2TransportStreamSplitter.$(OBJ)
+MIKEY_PARSE_OBJS = mikeyParse.$(OBJ)
+
+GSM_STREAMER_OBJS = testGSMStreamer.$(OBJ) testGSMEncoder.$(OBJ)
+
+announceURL.$(CPP): 			   announceURL.hh
+
+testMP3Streamer.$(CPP):			   announceURL.hh
+testMPEG1or2VideoStreamer.$(CPP):	   announceURL.hh
+testMPEG1or2AudioVideoStreamer.$(CPP):	   announceURL.hh
+testMPEG2TransportStreamer.$(CPP):	   announceURL.hh
+testMPEG4VideoStreamer.$(CPP):		   announceURL.hh
+testH264VideoStreamer.$(CPP):		   announceURL.hh
+testH265VideoStreamer.$(CPP):		   announceURL.hh
+testDVVideoStreamer.$(CPP):		   announceURL.hh
+testWAVAudioStreamer.$(CPP):		   announceURL.hh
+testAMRAudioStreamer.$(CPP):		   announceURL.hh
+testOnDemandRTSPServer.$(CPP):		   announceURL.hh
+testMKVStreamer.$(CPP):			   announceURL.hh
+testOggStreamer.$(CPP):			   announceURL.hh
+vobStreamer.$(CPP):			   announceURL.hh
+
+testGSMStreamer.$(CPP):			   announceURL.hh
+
+openRTSP.$(CPP):	playCommon.hh
+playCommon.$(CPP):	playCommon.hh
+playSIP.$(CPP):		playCommon.hh
+
+USAGE_ENVIRONMENT_DIR = ../UsageEnvironment
+USAGE_ENVIRONMENT_LIB = $(USAGE_ENVIRONMENT_DIR)/libUsageEnvironment.$(libUsageEnvironment_LIB_SUFFIX)
+BASIC_USAGE_ENVIRONMENT_DIR = ../BasicUsageEnvironment
+BASIC_USAGE_ENVIRONMENT_LIB = $(BASIC_USAGE_ENVIRONMENT_DIR)/libBasicUsageEnvironment.$(libBasicUsageEnvironment_LIB_SUFFIX)
+LIVEMEDIA_DIR = ../liveMedia
+LIVEMEDIA_LIB = $(LIVEMEDIA_DIR)/libliveMedia.$(libliveMedia_LIB_SUFFIX)
+GROUPSOCK_DIR = ../groupsock
+GROUPSOCK_LIB = $(GROUPSOCK_DIR)/libgroupsock.$(libgroupsock_LIB_SUFFIX)
+LOCAL_LIBS =	$(LIVEMEDIA_LIB) $(GROUPSOCK_LIB) \
+		$(BASIC_USAGE_ENVIRONMENT_LIB) $(USAGE_ENVIRONMENT_LIB)
+LIBS =			$(LOCAL_LIBS) $(LIBS_FOR_CONSOLE_APPLICATION)
+
+testMP3Streamer$(EXE):	$(MP3_STREAMER_OBJS) $(HELPER_OBJS) $(LOCAL_LIBS)
+	$(LINK)$@ $(CONSOLE_LINK_OPTS) $(MP3_STREAMER_OBJS) $(HELPER_OBJS) $(LIBS)
+testMP3Receiver$(EXE):	$(MP3_RECEIVER_OBJS) $(LOCAL_LIBS)
+	$(LINK)$@ $(CONSOLE_LINK_OPTS) $(MP3_RECEIVER_OBJS) $(LIBS)
+testRelay$(EXE):	$(RELAY_OBJS) $(LOCAL_LIBS)
+	$(LINK)$@ $(CONSOLE_LINK_OPTS) $(RELAY_OBJS) $(LIBS)
+testReplicator$(EXE):	$(REPLICATOR_OBJS) $(LOCAL_LIBS)
+	$(LINK)$@ $(CONSOLE_LINK_OPTS) $(REPLICATOR_OBJS) $(LIBS)
+testH264VideoToHLSSegments$(EXE):      $(H264_VIDEO_TO_HLS_SEGMENTS_OBJS) $(LOCAL_LIBS)
+	$(LINK)$@ $(CONSOLE_LINK_OPTS) $(H264_VIDEO_TO_HLS_SEGMENTS_OBJS) $(LIBS)
+testMPEG1or2Splitter$(EXE):	$(MPEG_1OR2_SPLITTER_OBJS) $(LOCAL_LIBS)
+	$(LINK)$@ $(CONSOLE_LINK_OPTS) $(MPEG_1OR2_SPLITTER_OBJS) $(LIBS)
+testMPEG1or2VideoStreamer$(EXE):	$(MPEG_1OR2_VIDEO_STREAMER_OBJS) $(HELPER_OBJS) $(LOCAL_LIBS)
+	$(LINK)$@ $(CONSOLE_LINK_OPTS) $(MPEG_1OR2_VIDEO_STREAMER_OBJS) $(HELPER_OBJS) $(LIBS)
+testMPEG1or2VideoReceiver$(EXE):	$(MPEG_1OR2_VIDEO_RECEIVER_OBJS) $(LOCAL_LIBS)
+	$(LINK)$@ $(CONSOLE_LINK_OPTS) $(MPEG_1OR2_VIDEO_RECEIVER_OBJS) $(LIBS)
+testMPEG1or2AudioVideoStreamer$(EXE):	$(MPEG_1OR2_AUDIO_VIDEO_STREAMER_OBJS) $(HELPER_OBJS) $(LOCAL_LIBS)
+	$(LINK)$@ $(CONSOLE_LINK_OPTS) $(MPEG_1OR2_AUDIO_VIDEO_STREAMER_OBJS) $(HELPER_OBJS) $(LIBS)
+testMPEG2TransportStreamer$(EXE):	$(MPEG2_TRANSPORT_STREAMER_OBJS) $(HELPER_OBJS) $(LOCAL_LIBS)
+	$(LINK)$@ $(CONSOLE_LINK_OPTS) $(MPEG2_TRANSPORT_STREAMER_OBJS) $(HELPER_OBJS) $(LIBS)
+testMPEG2TransportReceiver$(EXE):	$(MPEG2_TRANSPORT_RECEIVER_OBJS) $(LOCAL_LIBS)
+	$(LINK)$@ $(CONSOLE_LINK_OPTS) $(MPEG2_TRANSPORT_RECEIVER_OBJS) $(LIBS)
+testMPEG4VideoStreamer$(EXE):	$(MPEG4_VIDEO_STREAMER_OBJS) $(HELPER_OBJS) $(LOCAL_LIBS)
+	$(LINK)$@ $(CONSOLE_LINK_OPTS) $(MPEG4_VIDEO_STREAMER_OBJS) $(HELPER_OBJS) $(LIBS)
+testH264VideoStreamer$(EXE):	$(H264_VIDEO_STREAMER_OBJS) $(HELPER_OBJS) $(LOCAL_LIBS)
+	$(LINK)$@ $(CONSOLE_LINK_OPTS) $(H264_VIDEO_STREAMER_OBJS) $(HELPER_OBJS) $(LIBS)
+testH265VideoStreamer$(EXE):	$(H265_VIDEO_STREAMER_OBJS) $(HELPER_OBJS) $(LOCAL_LIBS)
+	$(LINK)$@ $(CONSOLE_LINK_OPTS) $(H265_VIDEO_STREAMER_OBJS) $(HELPER_OBJS) $(LIBS)
+testDVVideoStreamer$(EXE):	$(DV_VIDEO_STREAMER_OBJS) $(HELPER_OBJS) $(LOCAL_LIBS)
+	$(LINK)$@ $(CONSOLE_LINK_OPTS) $(DV_VIDEO_STREAMER_OBJS) $(HELPER_OBJS) $(LIBS)
+testWAVAudioStreamer$(EXE):	$(WAV_AUDIO_STREAMER_OBJS) $(HELPER_OBJS) $(LOCAL_LIBS)
+	$(LINK)$@ $(CONSOLE_LINK_OPTS) $(WAV_AUDIO_STREAMER_OBJS) $(HELPER_OBJS) $(LIBS)
+testAMRAudioStreamer$(EXE):	$(AMR_AUDIO_STREAMER_OBJS) $(HELPER_OBJS) $(LOCAL_LIBS)
+	$(LINK)$@ $(CONSOLE_LINK_OPTS) $(AMR_AUDIO_STREAMER_OBJS) $(HELPER_OBJS) $(LIBS)
+testOnDemandRTSPServer$(EXE):	$(ON_DEMAND_RTSP_SERVER_OBJS) $(HELPER_OBJS) $(LOCAL_LIBS)
+	$(LINK)$@ $(CONSOLE_LINK_OPTS) $(ON_DEMAND_RTSP_SERVER_OBJS) $(HELPER_OBJS) $(LIBS)
+testMKVStreamer$(EXE):	$(MKV_STREAMER_OBJS) $(HELPER_OBJS) $(LOCAL_LIBS)
+	$(LINK)$@ $(CONSOLE_LINK_OPTS) $(MKV_STREAMER_OBJS) $(HELPER_OBJS) $(LIBS)
+testOggStreamer$(EXE):	$(OGG_STREAMER_OBJS) $(HELPER_OBJS) $(LOCAL_LIBS)
+	$(LINK)$@ $(CONSOLE_LINK_OPTS) $(OGG_STREAMER_OBJS) $(HELPER_OBJS) $(LIBS)
+vobStreamer$(EXE):	$(VOB_STREAMER_OBJS) $(HELPER_OBJS) $(LOCAL_LIBS)
+	$(LINK)$@ $(CONSOLE_LINK_OPTS) $(VOB_STREAMER_OBJS) $(HELPER_OBJS) $(LIBS)
+testRTSPClient$(EXE):	$(TEST_RTSP_CLIENT_OBJS) $(LOCAL_LIBS)
+	$(LINK)$@ $(CONSOLE_LINK_OPTS) $(TEST_RTSP_CLIENT_OBJS) $(LIBS)
+openRTSP$(EXE):	$(OPEN_RTSP_OBJS) $(LOCAL_LIBS)
+	$(LINK)$@ $(CONSOLE_LINK_OPTS) $(OPEN_RTSP_OBJS) $(LIBS)
+playSIP$(EXE):	$(PLAY_SIP_OBJS) $(LOCAL_LIBS)
+	$(LINK)$@ $(CONSOLE_LINK_OPTS) $(PLAY_SIP_OBJS) $(LIBS)
+sapWatch$(EXE):	$(SAP_WATCH_OBJS) $(LOCAL_LIBS)
+	$(LINK)$@ $(CONSOLE_LINK_OPTS) $(SAP_WATCH_OBJS) $(LIBS)
+testMPEG1or2ProgramToTransportStream$(EXE):	$(MPEG_1OR2_PROGRAM_TO_TRANSPORT_STREAM_OBJS) $(LOCAL_LIBS)
+	$(LINK)$@ $(CONSOLE_LINK_OPTS) $(MPEG_1OR2_PROGRAM_TO_TRANSPORT_STREAM_OBJS) $(LIBS)
+testH264VideoToTransportStream$(EXE):	$(H264_VIDEO_TO_TRANSPORT_STREAM_OBJS) $(LOCAL_LIBS)
+	$(LINK)$@ $(CONSOLE_LINK_OPTS) $(H264_VIDEO_TO_TRANSPORT_STREAM_OBJS) $(LIBS)
+testH265VideoToTransportStream$(EXE):	$(H265_VIDEO_TO_TRANSPORT_STREAM_OBJS) $(LOCAL_LIBS)
+	$(LINK)$@ $(CONSOLE_LINK_OPTS) $(H265_VIDEO_TO_TRANSPORT_STREAM_OBJS) $(LIBS)
+MPEG2TransportStreamIndexer$(EXE):	$(MPEG2_TRANSPORT_STREAM_INDEXER_OBJS) $(LOCAL_LIBS)
+	$(LINK)$@ $(CONSOLE_LINK_OPTS) $(MPEG2_TRANSPORT_STREAM_INDEXER_OBJS) $(LIBS)
+testMPEG2TransportStreamTrickPlay$(EXE):	$(MPEG2_TRANSPORT_STREAM_TRICK_PLAY_OBJS) $(LOCAL_LIBS)
+	$(LINK)$@ $(CONSOLE_LINK_OPTS) $(MPEG2_TRANSPORT_STREAM_TRICK_PLAY_OBJS) $(LIBS)
+registerRTSPStream$(EXE):	$(REGISTER_RTSP_STREAM_OBJS) $(LOCAL_LIBS)
+	$(LINK)$@ $(CONSOLE_LINK_OPTS) $(REGISTER_RTSP_STREAM_OBJS) $(LIBS)
+testMKVSplitter$(EXE):	$(TEST_MKV_SPLITTER_OBJS) $(LOCAL_LIBS)
+	$(LINK)$@ $(CONSOLE_LINK_OPTS) $(TEST_MKV_SPLITTER_OBJS) $(LIBS)
+testMPEG2TransportStreamSplitter$(EXE): $(TEST_MPEG2_TRANSPORT_STREAM_SPLITTER_OBJS) $(LOCAL_LIBS)
+	$(LINK)$@ $(CONSOLE_LINK_OPTS) $(TEST_MPEG2_TRANSPORT_STREAM_SPLITTER_OBJS) $(LIBS)
+mikeyParse$(EXE):    $(MIKEY_PARSE_OBJS) $(LOCAL_LIBS)
+	$(LINK)$@ $(CONSOLE_LINK_OPTS) $(MIKEY_PARSE_OBJS) $(LIBS)
+
+testGSMStreamer$(EXE):	$(GSM_STREAMER_OBJS) $(HELPER_OBJS) $(LOCAL_LIBS)
+	$(LINK)$@ $(CONSOLE_LINK_OPTS) $(GSM_STREAMER_OBJS) $(HELPER_OBJS) $(LIBS)
+
+clean:
+	-rm -rf *.$(OBJ) $(ALL) core *.core *~ include/*~
+
+install: $(ALL)
+	  install -d $(DESTDIR)$(PREFIX)/bin
+	  install -m 755 $(ALL) $(DESTDIR)$(PREFIX)/bin
+
+##### Any additional, platform-specific rules come here:
diff --git a/3rdparty/live555/src/testProgs/announceURL.cpp b/3rdparty/live555/src/testProgs/announceURL.cpp
new file mode 100644
index 00000000..12521b5a
--- /dev/null
+++ b/3rdparty/live555/src/testProgs/announceURL.cpp
@@ -0,0 +1,44 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// Copyright (c) 1996-2022, Live Networks, Inc.  All rights reserved
+// A common function that outputs the URL(s) that can be used to access a stream
+// served by a RTSP server.
+// Implementation
+
+#include "announceURL.hh"
+#include <GroupsockHelper.hh>  // for "weHaveAnIPv*Address()"
+
+void announceURL(RTSPServer *rtspServer, ServerMediaSession *sms) {
+    if(rtspServer == NULL || sms == NULL)
+        return;  // sanity check
+
+    UsageEnvironment &env = rtspServer->envir();
+
+    env << "Play this stream using the URL ";
+    if(weHaveAnIPv4Address(env)) {
+        char *url = rtspServer->ipv4rtspURL(sms);
+        env << "\"" << url << "\"";
+        delete[] url;
+        if(weHaveAnIPv6Address(env))
+            env << " or ";
+    }
+    if(weHaveAnIPv6Address(env)) {
+        char *url = rtspServer->ipv6rtspURL(sms);
+        env << "\"" << url << "\"";
+        delete[] url;
+    }
+    env << "\n";
+}
diff --git a/3rdparty/live555/src/testProgs/announceURL.hh b/3rdparty/live555/src/testProgs/announceURL.hh
new file mode 100644
index 00000000..87dcca75
--- /dev/null
+++ b/3rdparty/live555/src/testProgs/announceURL.hh
@@ -0,0 +1,30 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// Copyright (c) 1996-2022, Live Networks, Inc.  All rights reserved
+// A common function that outputs the URL(s) that can be used to access a stream
+// served by a RTSP server.
+// C++ header
+
+#ifndef _ANNOUNCE_URL_HH
+#define _ANNOUNCE_URL_HH
+
+#ifndef _LIVEMEDIA_HH
+#include "liveMedia.hh"
+#endif
+
+void announceURL(RTSPServer* rtspServer, ServerMediaSession* sms);
+
+#endif
diff --git a/3rdparty/live555/src/testProgs/mikeyParse.cpp b/3rdparty/live555/src/testProgs/mikeyParse.cpp
new file mode 100644
index 00000000..8823a527
--- /dev/null
+++ b/3rdparty/live555/src/testProgs/mikeyParse.cpp
@@ -0,0 +1,418 @@
+// Parses MIKEY data (from Base64)
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <Base64.hh>
+#include <NetCommon.h>
+
+static u_int32_t get4Bytes(u_int8_t const *&ptr) {
+    u_int32_t result = (ptr[0] << 24) | (ptr[1] << 16) | (ptr[2] << 8) | ptr[3];
+    ptr += 4;
+    return result;
+}
+
+static u_int16_t get2Bytes(u_int8_t const *&ptr) {
+    u_int16_t result = (ptr[0] << 8) | ptr[1];
+    ptr += 2;
+    return result;
+}
+
+static u_int8_t getByte(u_int8_t const *&ptr) {
+    u_int8_t result = ptr[0];
+    ptr += 1;
+    return result;
+}
+
+Boolean parseMikeyUnknown(u_int8_t const *& /*ptr*/, u_int8_t const * /*endPtr*/, u_int8_t & /*nextPayloadType*/) {
+    fprintf(stderr, "\tUnknown or unhandled payload type\n");
+    return False;
+}
+
+char const *payloadTypeName[256];
+char const *dataTypeComment[256];
+#define testSize(n)            \
+    do {                       \
+        if(ptr + (n) > endPtr) \
+            return False;      \
+    } while(0)
+
+Boolean parseMikeyHDR(u_int8_t const *&ptr, u_int8_t const *endPtr, u_int8_t &nextPayloadType) {
+    testSize(10);  // up to the start of "CS ID map info"
+
+    fprintf(stderr, "\tversion: %d\n", getByte(ptr));
+
+    u_int8_t const dataType = getByte(ptr);
+    fprintf(stderr, "\tdata type: %d (%s)\n", dataType, dataTypeComment[dataType]);
+
+    nextPayloadType = getByte(ptr);
+    fprintf(stderr, "\tnext payload: %d (%s)\n", nextPayloadType, payloadTypeName[nextPayloadType]);
+
+    u_int8_t const V_PRF = getByte(ptr);
+    u_int8_t const PRF   = V_PRF & 0x7F;
+    fprintf(stderr, "\tV:%d; PRF:%d (%s)\n", V_PRF >> 7, PRF, PRF == 0 ? "MIKEY-1" : "unknown");
+
+    fprintf(stderr, "\tCSB ID:0x%08x\n", get4Bytes(ptr));
+
+    u_int8_t numCryptoSessions = getByte(ptr);
+    fprintf(stderr, "\t#CS:%d\n", numCryptoSessions);
+
+    u_int8_t const CS_ID_map_type = getByte(ptr);
+    fprintf(stderr, "\tCS ID map type:%d (%s)\n", CS_ID_map_type, CS_ID_map_type == 0 ? "SRTP-ID" : "unknown");
+    if(CS_ID_map_type != 0)
+        return False;
+
+    fprintf(stderr, "\tCS ID map info:\n");
+    testSize(numCryptoSessions * (1 + 4 + 4));  // the size of the "CS ID map info"
+    for(u_int8_t i = 1; i <= numCryptoSessions; ++i) {
+        u_int8_t  policy_no = getByte(ptr);
+        u_int32_t ssrc      = get4Bytes(ptr);
+        u_int32_t roc       = get4Bytes(ptr);
+
+        fprintf(stderr, "\tPolicy_no_%d: %d;\tSSRC_%d: 0x%08x; ROC_%d: 0x%08x\n", i, policy_no, i, ssrc, i, roc);
+    }
+
+    return True;
+}
+
+static Boolean parseKeyDataSubPayload(u_int8_t const *&ptr, u_int8_t const *endPtr, u_int8_t &nextPayloadType) {
+    fprintf(stderr, "\tEncr data:\n");
+    testSize(4);  // up to the start of "Key data"
+
+    nextPayloadType = getByte(ptr);
+    fprintf(stderr, "\t\tnext payload: %d (%s)\n", nextPayloadType, payloadTypeName[nextPayloadType]);
+
+    u_int8_t Type_KV = getByte(ptr);
+    u_int8_t Type    = Type_KV >> 4;
+    u_int8_t KV      = Type_KV & 0x0F;
+    fprintf(stderr, "\t\tType: %d (%s)\n", Type, Type == 0 ? "TGK" : Type == 1 ? "TGK+SALT" : Type == 2 ? "TEK" : Type == 3 ? "TEK+SALT" : "unknown");
+    if(Type > 3)
+        return False;
+    Boolean hasSalt = Type == 1 || Type == 3;
+
+    fprintf(stderr, "\t\tKey Validity: %d (%s)\n", KV, KV == 0 ? "NULL" : KV == 1 ? "SPI/MKI" : KV == 2 ? "Interval" : "unknown");
+    Boolean hasKV = KV != 0;
+
+    u_int16_t keyDataLen = get2Bytes(ptr);
+    fprintf(stderr, "\t\tKey data len: %d\n", keyDataLen);
+
+    testSize(keyDataLen);
+    fprintf(stderr, "\t\tKey data: ");
+    for(unsigned i = 0; i < keyDataLen; ++i)
+        fprintf(stderr, ":%02x", getByte(ptr));
+    fprintf(stderr, "\n");
+
+    if(hasSalt) {
+        testSize(2);
+        u_int16_t saltLen = get2Bytes(ptr);
+        fprintf(stderr, "\t\tSalt len: %d\n", saltLen);
+
+        testSize(saltLen);
+        fprintf(stderr, "\t\tSalt data: ");
+        for(unsigned i = 0; i < saltLen; ++i)
+            fprintf(stderr, ":%02x", getByte(ptr));
+        fprintf(stderr, "\n");
+    }
+
+    if(hasKV) {
+        fprintf(stderr, "\t\tKV (key validity) data:\n");
+        if(KV == 1) {  // SPI/MKI
+            testSize(1);
+            u_int8_t SPILength = getByte(ptr);
+            fprintf(stderr, "\t\t\tSPI Length: %d\n", SPILength);
+
+            testSize(SPILength);
+            fprintf(stderr, "\t\t\tSPI: ");
+            for(unsigned i = 0; i < SPILength; ++i)
+                fprintf(stderr, ":%02x", getByte(ptr));
+            fprintf(stderr, "\n");
+        }
+        else if(KV == 2) {  // Interval
+            testSize(1);
+            u_int8_t VFLength = getByte(ptr);
+            fprintf(stderr, "\t\t\tVF Length: %d\n", VFLength);
+
+            testSize(VFLength);
+            fprintf(stderr, "\t\t\tVF: ");
+            for(unsigned i = 0; i < VFLength; ++i)
+                fprintf(stderr, ":%02x", getByte(ptr));
+            fprintf(stderr, "\n");
+
+            testSize(1);
+            u_int8_t VTLength = getByte(ptr);
+            fprintf(stderr, "\t\t\tVT Length: %d\n", VTLength);
+
+            testSize(VTLength);
+            fprintf(stderr, "\t\t\tVT: ");
+            for(unsigned i = 0; i < VTLength; ++i)
+                fprintf(stderr, ":%02x", getByte(ptr));
+            fprintf(stderr, "\n");
+        }
+    }
+
+    return True;
+}
+
+Boolean parseMikeyKEMAC(u_int8_t const *&ptr, u_int8_t const *endPtr, u_int8_t &nextPayloadType) {
+    testSize(4);  // up to the start of "Encr data"
+
+    nextPayloadType = getByte(ptr);
+    fprintf(stderr, "\tnext payload: %d (%s)\n", nextPayloadType, payloadTypeName[nextPayloadType]);
+
+    u_int8_t encrAlg = getByte(ptr);
+    fprintf(stderr, "\tEncr alg: %d (%s)\n", encrAlg, encrAlg == 0 ? "NULL" : encrAlg == 1 ? "AES-CM-128" : encrAlg == 2 ? "AES-KW-128" : "unknown");
+
+    u_int16_t encrDataLen = get2Bytes(ptr);
+    fprintf(stderr, "\tencr data len: %d\n", encrDataLen);
+
+    testSize(encrDataLen + 1 /*allow for "Mac alg"*/);
+    u_int8_t const *endOfKeyData = ptr + encrDataLen;
+
+    // Allow for multiple key data sub-payloads
+    while(ptr < endOfKeyData) {
+        if(!parseKeyDataSubPayload(ptr, endOfKeyData, nextPayloadType))
+            return False;
+    }
+
+    u_int8_t macAlg = getByte(ptr);
+    fprintf(stderr, "\tMAC alg: %d (%s)\n", macAlg, macAlg == 0 ? "NULL" : macAlg == 1 ? "HMAC-SHA-1-160" : "unknown");
+    if(macAlg > 1)
+        return False;
+    if(macAlg == 1) {                     // HMAC-SHA-1-160
+        unsigned const macLen = 160 / 8;  // bytes
+        fprintf(stderr, "\t\tMAC: ");
+        for(unsigned i = 0; i < macLen; ++i)
+            fprintf(stderr, ":%02x", getByte(ptr));
+        fprintf(stderr, "\n");
+    }
+
+    return True;
+}
+
+Boolean parseMikeyT(u_int8_t const *&ptr, u_int8_t const *endPtr, u_int8_t &nextPayloadType) {
+    testSize(2);  // up to the start of "TS value"
+
+    nextPayloadType = getByte(ptr);
+    fprintf(stderr, "\tnext payload: %d (%s)\n", nextPayloadType, payloadTypeName[nextPayloadType]);
+
+    u_int8_t TS_type = getByte(ptr);
+    unsigned TS_value_len;
+    fprintf(stderr, "\tTS type: %d (", TS_type);
+    switch(TS_type) {
+    case 0: {
+        fprintf(stderr, "NTP-UTC)\n");
+        TS_value_len = 8;  // 64 bits
+        break;
+    }
+    case 1: {
+        fprintf(stderr, "NTP)\n");
+        TS_value_len = 8;  // 64 bits
+        break;
+    }
+    case 2: {
+        fprintf(stderr, "COUNTER)\n");
+        TS_value_len = 4;  // 32 bits
+        break;
+    }
+    default: {
+        fprintf(stderr, "unknown)\n");
+        return False;
+    }
+    }
+
+    testSize(TS_value_len);
+    fprintf(stderr, "\tTS value:");
+    for(unsigned i = 0; i < TS_value_len; ++i)
+        fprintf(stderr, ":%02x", getByte(ptr));
+    fprintf(stderr, "\n");
+
+    return True;
+}
+
+#define MAX_SRTP_POLICY_PARAM_TYPE 12
+static char const *SRTPPolicyParamTypeExplanation[] = {
+    "Encryption algorithm",        "Session Encryption key length", "Authentication algorithm", "Session Authentication key length", "Session Salt key length",
+    "SRTP Pseudo Random Function", "Key derivation rate",           "SRTP encryption off/on",   "SRTCP encryption off/on",           "Sender's FEC order",
+    "SRTP authentication off/on",  "Authentication tag length",     "SRTP prefix length",
+};
+
+static Boolean parseSRTPPolicyParam(u_int8_t const *&ptr, u_int8_t const *endPtr) {
+    fprintf(stderr, "\tPolicy param:\n");
+    while(ptr < endPtr) {
+        testSize(2);
+
+        u_int8_t ppType = getByte(ptr);
+        fprintf(stderr, "\t\ttype: %d (%s); ", ppType, ppType > MAX_SRTP_POLICY_PARAM_TYPE ? "unknown" : SRTPPolicyParamTypeExplanation[ppType]);
+
+        u_int8_t ppLen = getByte(ptr);
+        fprintf(stderr, "length: %d; value: ", ppLen);
+
+        testSize(ppLen);
+        u_int8_t ppVal = 0xFF;
+        if(ppLen == 1) {
+            ppVal = getByte(ptr);
+            fprintf(stderr, "%d", ppVal);
+        }
+        else {
+            for(unsigned j = 0; j < ppLen; ++j)
+                fprintf(stderr, ":%02x", getByte(ptr));
+        }
+
+        switch(ppType) {
+        case 0: {  // Encryption algorithm
+            fprintf(stderr, " (%s)", ppVal == 0 ? "NULL" : ppVal == 1 ? "AES-CM" : ppVal == 2 ? "AES-F8" : "unknown");
+            break;
+        }
+        case 2: {  // Authentication algorithm
+            fprintf(stderr, " (%s)", ppVal == 0 ? "NULL" : ppVal == 1 ? "HMAC-SHA-1" : "unknown");
+            break;
+        }
+        case 5: {  // SRTP Pseudo Random Function
+            fprintf(stderr, " (%s)", ppVal == 0 ? "AES-CM" : "unknown");
+            break;
+        }
+        case 9: {  // sender's FEC order
+            fprintf(stderr, " (%s)", ppVal == 0 ? "First FEC, then SRTP" : "unknown");
+            break;
+        }
+        }
+        fprintf(stderr, "\n");
+    }
+
+    return True;
+}
+
+Boolean parseMikeySP(u_int8_t const *&ptr, u_int8_t const *endPtr, u_int8_t &nextPayloadType) {
+    testSize(2);  // up to the start of "Policy param"
+
+    nextPayloadType = getByte(ptr);
+    fprintf(stderr, "\tnext payload: %d (%s)\n", nextPayloadType, payloadTypeName[nextPayloadType]);
+
+    fprintf(stderr, "\tPolicy number: %d\n", getByte(ptr));
+
+    u_int8_t protocolType = getByte(ptr);
+    fprintf(stderr, "\tProtocol type: %d (%s)\n", protocolType, protocolType == 0 ? "SRTP" : "unknown");
+    if(protocolType != 0)
+        return False;
+
+    u_int16_t policyParam_len = get2Bytes(ptr);
+    fprintf(stderr, "\tPolicy param len: %d\n", policyParam_len);
+
+    testSize(policyParam_len);
+    return parseSRTPPolicyParam(ptr, ptr + policyParam_len);
+}
+
+Boolean parseMikeyRAND(u_int8_t const *&ptr, u_int8_t const *endPtr, u_int8_t &nextPayloadType) {
+    testSize(2);  // up to the start of "RAND"
+
+    nextPayloadType = getByte(ptr);
+    fprintf(stderr, "\tnext payload: %d (%s)\n", nextPayloadType, payloadTypeName[nextPayloadType]);
+
+    u_int8_t RAND_len = getByte(ptr);
+    fprintf(stderr, "\tRAND len: %d", RAND_len);
+
+    testSize(RAND_len);
+    fprintf(stderr, "\tRAND:");
+    for(unsigned i = 0; i < RAND_len; ++i)
+        fprintf(stderr, ":%02x", getByte(ptr));
+    fprintf(stderr, "\n");
+
+    return True;
+}
+
+typedef Boolean(parseMikeyPayloadFunc)(u_int8_t const *&ptr, u_int8_t const *endPtr, u_int8_t &nextPayloadType);
+parseMikeyPayloadFunc *payloadParser[256];
+
+int main(int argc, char **argv) {
+    if(argc != 2) {
+        fprintf(stderr, "Usage: %s <base64Data>\n", argv[0]);
+        exit(1);
+    }
+    char const *base64Data = argv[1];
+
+    unsigned  mikeyDataSize;
+    u_int8_t *mikeyData = base64Decode(base64Data, mikeyDataSize);
+
+    fprintf(stderr, "Base64Data \"%s\" produces %d bytes of MIKEY data:\n", base64Data, mikeyDataSize);
+    for(unsigned i = 0; i < mikeyDataSize; ++i)
+        fprintf(stderr, ":%02x", mikeyData[i]);
+    fprintf(stderr, "\n");
+
+    for(unsigned i = 0; i < 256; ++i) {
+        payloadTypeName[i] = "unknown or unhandled";
+        payloadParser[i]   = parseMikeyUnknown;
+
+        dataTypeComment[i] = "unknown";
+    }
+
+    // Populate known payload types:
+    payloadTypeName[0] = "Last payload";
+
+    payloadTypeName[1] = "KEMAC";
+    payloadParser[1]   = parseMikeyKEMAC;
+
+    payloadTypeName[2] = "PKE";
+
+    payloadTypeName[3] = "DH";
+
+    payloadTypeName[4] = "SIGN";
+
+    payloadTypeName[5] = "T";
+    payloadParser[5]   = parseMikeyT;
+
+    payloadTypeName[6] = "ID";
+
+    payloadTypeName[7] = "CERT";
+
+    payloadTypeName[8] = "CHASH";
+
+    payloadTypeName[9] = "V";
+
+    payloadTypeName[10] = "SP";
+    payloadParser[10]   = parseMikeySP;
+
+    payloadTypeName[11] = "RAND";
+    payloadParser[11]   = parseMikeyRAND;
+
+    payloadTypeName[12] = "ERR";
+
+    payloadTypeName[20] = "Key data";
+
+    payloadTypeName[21] = "General Ext.";
+
+    // Populate known data types:
+    dataTypeComment[0] = "Initiator's pre-shared key message";
+    dataTypeComment[1] = "Verification message of a pre-shared key message";
+    dataTypeComment[2] = "Initiator's public-key transport message";
+    dataTypeComment[3] = "Verification message of a public-key message";
+    dataTypeComment[4] = "Initiator's DH exchange message";
+    dataTypeComment[5] = "Responder's DH exchange message";
+    dataTypeComment[6] = "Error message";
+
+    u_int8_t const *ptr    = mikeyData;
+    u_int8_t *const endPtr = &mikeyData[mikeyDataSize];
+    u_int8_t        nextPayloadType;
+
+    do {
+        // Begin by parsing an initial "HDR":
+        fprintf(stderr, "HDR:\n");
+        if(!parseMikeyHDR(ptr, endPtr, nextPayloadType))
+            break;
+
+        // Then parse each successive payload:
+        while(nextPayloadType != 0 /* Last payload */) {
+            fprintf(stderr, "%s:\n", payloadTypeName[nextPayloadType]);
+            if(!(*payloadParser[nextPayloadType])(ptr, endPtr, nextPayloadType))
+                break;
+        }
+    } while(0);
+
+    if(ptr < endPtr) {
+        fprintf(stderr, "+%ld bytes of unparsed data: ", endPtr - ptr);
+        while(ptr < endPtr)
+            fprintf(stderr, ":%02x", *ptr++);
+        fprintf(stderr, "\n");
+    }
+
+    delete[] mikeyData;
+    return 0;
+}
diff --git a/3rdparty/live555/src/testProgs/openRTSP.cpp b/3rdparty/live555/src/testProgs/openRTSP.cpp
new file mode 100644
index 00000000..b2d2557b
--- /dev/null
+++ b/3rdparty/live555/src/testProgs/openRTSP.cpp
@@ -0,0 +1,68 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// Copyright (c) 1996-2022, Live Networks, Inc.  All rights reserved
+// A RTSP client application that opens a RTSP URL argument,
+// and extracts and records the data from each incoming RTP stream.
+//
+// NOTE: If you want to develop your own RTSP client application (or embed RTSP client functionality into your own application),
+// then we don't recommend using this code as a model, because it is too complex (with many options).
+// Instead, we recommend using the "testRTSPClient" application code as a model.
+
+#include "playCommon.hh"
+
+RTSPClient *ourRTSPClient = NULL;
+Medium *    createClient(UsageEnvironment &env, char const *url, int verbosityLevel, char const *applicationName) {
+    extern portNumBits tunnelOverHTTPPortNum;
+    return ourRTSPClient = RTSPClient::createNew(env, url, verbosityLevel, applicationName, tunnelOverHTTPPortNum);
+}
+
+void assignClient(Medium *client) {
+    ourRTSPClient = (RTSPClient *)client;
+}
+
+void getOptions(RTSPClient::responseHandler *afterFunc) {
+    ourRTSPClient->sendOptionsCommand(afterFunc, ourAuthenticator);
+}
+
+void getSDPDescription(RTSPClient::responseHandler *afterFunc) {
+    ourRTSPClient->sendDescribeCommand(afterFunc, ourAuthenticator);
+}
+
+void setupSubsession(MediaSubsession *subsession, Boolean streamUsingTCP, Boolean forceMulticastOnUnspecified, RTSPClient::responseHandler *afterFunc) {
+
+    ourRTSPClient->sendSetupCommand(*subsession, afterFunc, False, streamUsingTCP, forceMulticastOnUnspecified, ourAuthenticator);
+}
+
+void startPlayingSession(MediaSession *session, double start, double end, float scale, RTSPClient::responseHandler *afterFunc) {
+    ourRTSPClient->sendPlayCommand(*session, afterFunc, start, end, scale, ourAuthenticator);
+}
+
+void startPlayingSession(MediaSession *session, char const *absStartTime, char const *absEndTime, float scale, RTSPClient::responseHandler *afterFunc) {
+    ourRTSPClient->sendPlayCommand(*session, afterFunc, absStartTime, absEndTime, scale, ourAuthenticator);
+}
+
+void tearDownSession(MediaSession *session, RTSPClient::responseHandler *afterFunc) {
+    ourRTSPClient->sendTeardownCommand(*session, afterFunc, ourAuthenticator);
+}
+
+void setUserAgentString(char const *userAgentString) {
+    ourRTSPClient->setUserAgentString(userAgentString);
+}
+
+Boolean     allowProxyServers        = False;
+Boolean     controlConnectionUsesTCP = True;
+Boolean     supportCodecSelection    = False;
+char const *clientProtocolName       = "RTSP";
diff --git a/3rdparty/live555/src/testProgs/playCommon.cpp b/3rdparty/live555/src/testProgs/playCommon.cpp
new file mode 100644
index 00000000..f14bdb07
--- /dev/null
+++ b/3rdparty/live555/src/testProgs/playCommon.cpp
@@ -0,0 +1,1594 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// Copyright (c) 1996-2022, Live Networks, Inc.  All rights reserved
+// A common framework, used for the "openRTSP" and "playSIP" applications
+// Implementation
+//
+// NOTE: If you want to develop your own RTSP client application (or embed RTSP client functionality into your own application),
+// then we don't recommend using this code as a model, because it is too complex (with many options).
+// Instead, we recommend using the "testRTSPClient" application code as a model.
+
+#include "playCommon.hh"
+#include "BasicUsageEnvironment.hh"
+#include "GroupsockHelper.hh"
+
+#if defined(__WIN32__) || defined(_WIN32)
+#define snprintf _snprintf
+#else
+#include <signal.h>
+#define USE_SIGNALS 1
+#endif
+
+// Forward function definitions:
+void continueAfterClientCreation0(RTSPClient *client, Boolean requestStreamingOverTCP);
+void continueAfterClientCreation1();
+void continueAfterOPTIONS(RTSPClient *client, int resultCode, char *resultString);
+void continueAfterDESCRIBE(RTSPClient *client, int resultCode, char *resultString);
+void continueAfterSETUP(RTSPClient *client, int resultCode, char *resultString);
+void continueAfterPLAY(RTSPClient *client, int resultCode, char *resultString);
+void continueAfterTEARDOWN(RTSPClient *client, int resultCode, char *resultString);
+
+void createOutputFiles(char const *periodicFilenameSuffix);
+void createPeriodicOutputFiles();
+void setupStreams();
+void closeMediaSinks();
+void subsessionAfterPlaying(void *clientData);
+void subsessionByeHandler(void *clientData, char const *reason);
+void sessionAfterPlaying(void *clientData = NULL);
+void sessionTimerHandler(void *clientData);
+void periodicFileOutputTimerHandler(void *clientData);
+void shutdown(int exitCode = 1);
+void signalHandlerShutdown(int sig);
+void checkForPacketArrival(void *clientData);
+void checkInterPacketGaps(void *clientData);
+void checkSessionTimeoutBrokenServer(void *clientData);
+void beginQOSMeasurement();
+
+char const *                     progName;
+UsageEnvironment *               env;
+Medium *                         ourClient                      = NULL;
+Authenticator *                  ourAuthenticator               = NULL;
+char const *                     streamURL                      = NULL;
+MediaSession *                   session                        = NULL;
+TaskToken                        sessionTimerTask               = NULL;
+TaskToken                        sessionTimeoutBrokenServerTask = NULL;
+TaskToken                        arrivalCheckTimerTask          = NULL;
+TaskToken                        interPacketGapCheckTimerTask   = NULL;
+TaskToken                        qosMeasurementTimerTask        = NULL;
+TaskToken                        periodicFileOutputTask         = NULL;
+Boolean                          createReceivers                = True;
+Boolean                          outputQuickTimeFile            = False;
+Boolean                          generateMP4Format              = False;
+QuickTimeFileSink *              qtOut                          = NULL;
+Boolean                          outputAVIFile                  = False;
+AVIFileSink *                    aviOut                         = NULL;
+Boolean                          audioOnly                      = False;
+Boolean                          videoOnly                      = False;
+Boolean                          applicationOnly                = False;
+char const *                     singleMedium                   = NULL;
+int                              verbosityLevel                 = 1;  // by default, print verbose output
+double                           duration                       = 0;
+double                           durationSlop                   = -1.0;  // extra seconds to play at the end
+double                           initialSeekTime                = 0.0f;
+char *                           initialAbsoluteSeekTime        = NULL;
+char *                           initialAbsoluteSeekEndTime     = NULL;
+float                            scale                          = 1.0f;
+double                           endTime;
+unsigned                         interPacketGapMaxTime                  = 0;
+unsigned                         totNumPacketsReceived                  = ~0;  // used if checking inter-packet gaps
+Boolean                          playContinuously                       = False;
+int                              simpleRTPoffsetArg                     = -1;
+Boolean                          sendOptionsRequest                     = True;
+Boolean                          sendOptionsRequestOnly                 = False;
+Boolean                          oneFilePerFrame                        = False;
+Boolean                          notifyOnPacketArrival                  = False;
+Boolean                          sendKeepAlivesToBrokenServers          = False;
+unsigned                         sessionTimeoutParameter                = 0;
+Boolean                          streamUsingTCP                         = False;
+Boolean                          forceMulticastOnUnspecified            = False;
+unsigned short                   desiredPortNum                         = 0;
+portNumBits                      tunnelOverHTTPPortNum                  = 0;
+char *                           username                               = NULL;
+char *                           password                               = NULL;
+char *                           proxyServerName                        = NULL;
+unsigned short                   proxyServerPortNum                     = 0;
+unsigned char                    desiredAudioRTPPayloadFormat           = 0;
+char *                           mimeSubtype                            = NULL;
+unsigned short                   movieWidth                             = 240;  // default
+Boolean                          movieWidthOptionSet                    = False;
+unsigned short                   movieHeight                            = 180;  // default
+Boolean                          movieHeightOptionSet                   = False;
+unsigned                         movieFPS                               = 15;  // default
+Boolean                          movieFPSOptionSet                      = False;
+char const *                     fileNamePrefix                         = "";
+unsigned                         fileSinkBufferSize                     = 100000;
+unsigned                         socketInputBufferSize                  = 0;
+Boolean                          packetLossCompensate                   = False;
+Boolean                          syncStreams                            = False;
+Boolean                          generateHintTracks                     = False;
+Boolean                          waitForResponseToTEARDOWN              = True;
+unsigned                         qosMeasurementIntervalMS               = 0;  // 0 means: Don't output QOS data
+char *                           userAgent                              = NULL;
+unsigned                         fileOutputInterval                     = 0;  // seconds
+unsigned                         fileOutputSecondsSoFar                 = 0;  // seconds
+Boolean                          createHandlerServerForREGISTERCommand  = False;
+portNumBits                      handlerServerForREGISTERCommandPortNum = 0;
+HandlerServerForREGISTERCommand *handlerServerForREGISTERCommand;
+char *                           usernameForREGISTER = NULL;
+char *                           passwordForREGISTER = NULL;
+UserAuthenticationDatabase *     authDBForREGISTER   = NULL;
+
+struct timeval startTime;
+
+void usage() {
+    *env << "Usage: " << progName
+         << " [-p <startPortNum>] [-r|-q|-4|-i] [-a|-v] [-V] [-d <duration>] [-D <max-inter-packet-gap-time> [-c] [-S <offset>] [-n] [-O]"
+         << (controlConnectionUsesTCP ? " [-t|-T <http-port>]" : "") << " [-u <username> <password>"
+         << (allowProxyServers ? " [<proxy-server> [<proxy-server-port>]]" : "") << "]"
+         << (supportCodecSelection ? " [-A <audio-codec-rtp-payload-format-code>|-M <mime-subtype-name>]" : "")
+         << " [-s <initial-seek-time>]|[-U <absolute-seek-time>] [-E <absolute-seek-end-time>] [-z <scale>] [-g user-agent]"
+         << " [-k <username-for-REGISTER> <password-for-REGISTER>]"
+         << " [-P <interval-in-seconds>] [-K]"
+         << " [-w <width> -h <height>] [-f <frames-per-second>] [-y] [-H] [-Q [<measurement-interval>]] [-F <filename-prefix>] [-b <file-sink-buffer-size>] "
+            "[-B <input-socket-buffer-size>] [-I <input-interface-ip-address>] [-m] [<url>|-R [<port-num>]] (or "
+         << progName << " -o [-V] <url>)\n";
+    shutdown();
+}
+
+int main(int argc, char **argv) {
+    // Begin by setting up our usage environment:
+    TaskScheduler *scheduler = BasicTaskScheduler::createNew();
+    env                      = BasicUsageEnvironment::createNew(*scheduler);
+
+    progName = argv[0];
+
+    gettimeofday(&startTime, NULL);
+
+#ifdef USE_SIGNALS
+    // Allow ourselves to be shut down gracefully by a SIGHUP or a SIGUSR1:
+    signal(SIGHUP, signalHandlerShutdown);
+    signal(SIGUSR1, signalHandlerShutdown);
+#endif
+
+    // unfortunately we can't use getopt() here, as Windoze doesn't have it
+    while(argc > 1) {
+        char *const opt = argv[1];
+        if(opt[0] != '-') {
+            if(argc == 2)
+                break;  // only the URL is left
+            usage();
+        }
+
+        switch(opt[1]) {
+        case 'p': {  // specify start port number
+            int portArg;
+            if(sscanf(argv[2], "%d", &portArg) != 1) {
+                usage();
+            }
+            if(portArg <= 0 || portArg >= 65536 || portArg & 1) {
+                *env << "bad port number: " << portArg << " (must be even, and in the range (0,65536))\n";
+                usage();
+            }
+            desiredPortNum = (unsigned short)portArg;
+            ++argv;
+            --argc;
+            break;
+        }
+
+        case 'r': {  // do not receive data (instead, just 'play' the stream(s))
+            createReceivers = False;
+            break;
+        }
+
+        case 'q': {  // output a QuickTime file (to stdout)
+            outputQuickTimeFile = True;
+            break;
+        }
+
+        case '4': {  // output a 'mp4'-format file (to stdout)
+            outputQuickTimeFile = True;
+            generateMP4Format   = True;
+            break;
+        }
+
+        case 'i': {  // output an AVI file (to stdout)
+            outputAVIFile = True;
+            break;
+        }
+
+        case 'I': {  // specify input interface...
+            NetAddressList addresses(argv[2]);
+            if(addresses.numAddresses() == 0) {
+                *env << "Failed to find network address for \"" << argv[2] << "\"";
+                break;
+            }
+
+            struct sockaddr_storage interfaceAddress;
+
+            copyAddress(interfaceAddress, addresses.firstAddress());
+            if(interfaceAddress.ss_family == AF_INET) {  // later, support IPv6 also
+                ReceivingInterfaceAddr = ((sockaddr_in &)interfaceAddress).sin_addr.s_addr;
+            }
+            ++argv;
+            --argc;
+            break;
+        }
+
+        case 'a': {  // receive/record an audio stream only
+            audioOnly    = True;
+            singleMedium = "audio";
+            break;
+        }
+
+        case 'v': {  // receive/record a video stream only
+            videoOnly    = True;
+            singleMedium = "video";
+            break;
+        }
+
+        case 'L': {  // receive/record an 'application' (e.g., metadata) stream only
+            applicationOnly = True;
+            singleMedium    = "application";
+            break;
+        }
+
+        case 'V': {  // disable verbose output
+            verbosityLevel = 0;
+            break;
+        }
+
+        case 'd': {  // specify duration, or how much to delay after end time
+            float arg;
+            if(sscanf(argv[2], "%g", &arg) != 1) {
+                usage();
+            }
+            if(argv[2][0] == '-') {  // not "arg<0", in case argv[2] was "-0"
+                // a 'negative' argument was specified; use this for "durationSlop":
+                duration     = 0;  // use whatever's in the SDP
+                durationSlop = -arg;
+            }
+            else {
+                duration     = arg;
+                durationSlop = 0;
+            }
+            ++argv;
+            --argc;
+            break;
+        }
+
+        case 'D': {  // specify maximum number of seconds to wait for packets:
+            if(sscanf(argv[2], "%u", &interPacketGapMaxTime) != 1) {
+                usage();
+            }
+            ++argv;
+            --argc;
+            break;
+        }
+
+        case 'c': {  // play continuously
+            playContinuously = True;
+            break;
+        }
+
+        case 'S': {  // specify an offset to use with "SimpleRTPSource"s
+            if(sscanf(argv[2], "%d", &simpleRTPoffsetArg) != 1) {
+                usage();
+            }
+            if(simpleRTPoffsetArg < 0) {
+                *env << "offset argument to \"-S\" must be >= 0\n";
+                usage();
+            }
+            ++argv;
+            --argc;
+            break;
+        }
+
+        case 'm': {  // output multiple files - one for each frame
+            oneFilePerFrame = True;
+            break;
+        }
+
+        case 'n': {  // notify the user when the first data packet arrives
+            notifyOnPacketArrival = True;
+            break;
+        }
+
+        case 'O': {  // Don't send an "OPTIONS" request before "DESCRIBE"
+            sendOptionsRequest = False;
+            break;
+        }
+
+        case 'o': {  // Send only the "OPTIONS" request to the server
+            sendOptionsRequestOnly = True;
+            break;
+        }
+
+        case 'P': {  // specify an interval (in seconds) between writing successive output files
+            int fileOutputIntervalInt;
+            if(sscanf(argv[2], "%d", &fileOutputIntervalInt) != 1 || fileOutputIntervalInt <= 0) {
+                usage();
+            }
+            fileOutputInterval = (unsigned)fileOutputIntervalInt;
+            ++argv;
+            --argc;
+            break;
+        }
+
+        case 't': {
+            // stream RTP and RTCP over the TCP 'control' connection
+            if(controlConnectionUsesTCP) {
+                streamUsingTCP = True;
+            }
+            else {
+                usage();
+            }
+            break;
+        }
+
+        case 'T': {
+            // stream RTP and RTCP over a HTTP connection
+            if(controlConnectionUsesTCP) {
+                if(argc > 3 && argv[2][0] != '-') {
+                    // The next argument is the HTTP server port number:
+                    if(sscanf(argv[2], "%hu", &tunnelOverHTTPPortNum) == 1 && tunnelOverHTTPPortNum > 0) {
+                        ++argv;
+                        --argc;
+                        break;
+                    }
+                }
+            }
+
+            // If we get here, the option was specified incorrectly:
+            usage();
+            break;
+        }
+
+        case 'u': {  // specify a username and password
+            if(argc < 4)
+                usage();  // there's no argv[3] (for the "password")
+            username = argv[2];
+            password = argv[3];
+            argv += 2;
+            argc -= 2;
+            if(allowProxyServers && argc > 3 && argv[2][0] != '-') {
+                // The next argument is the name of a proxy server:
+                proxyServerName = argv[2];
+                ++argv;
+                --argc;
+
+                if(argc > 3 && argv[2][0] != '-') {
+                    // The next argument is the proxy server port number:
+                    if(sscanf(argv[2], "%hu", &proxyServerPortNum) != 1) {
+                        usage();
+                    }
+                    ++argv;
+                    --argc;
+                }
+            }
+
+            ourAuthenticator = new Authenticator(username, password);
+            break;
+        }
+
+        case 'k': {  // specify a username and password to be used to authentication an incoming "REGISTER" command (for use with -R)
+            if(argc < 4)
+                usage();  // there's no argv[3] (for the "password")
+            usernameForREGISTER = argv[2];
+            passwordForREGISTER = argv[3];
+            argv += 2;
+            argc -= 2;
+
+            if(authDBForREGISTER == NULL)
+                authDBForREGISTER = new UserAuthenticationDatabase;
+            authDBForREGISTER->addUserRecord(usernameForREGISTER, passwordForREGISTER);
+            break;
+        }
+
+        case 'K': {  // Send periodic 'keep-alive' requests to keep broken server sessions alive
+            sendKeepAlivesToBrokenServers = True;
+            break;
+        }
+
+        case 'A': {  // specify a desired audio RTP payload format
+            unsigned formatArg;
+            if(sscanf(argv[2], "%u", &formatArg) != 1 || formatArg >= 96) {
+                usage();
+            }
+            desiredAudioRTPPayloadFormat = (unsigned char)formatArg;
+            ++argv;
+            --argc;
+            break;
+        }
+
+        case 'M': {  // specify a MIME subtype for a dynamic RTP payload type
+            mimeSubtype = argv[2];
+            if(desiredAudioRTPPayloadFormat == 0)
+                desiredAudioRTPPayloadFormat = 96;
+            ++argv;
+            --argc;
+            break;
+        }
+
+        case 'w': {  // specify a width (pixels) for an output QuickTime or AVI movie
+            if(sscanf(argv[2], "%hu", &movieWidth) != 1) {
+                usage();
+            }
+            movieWidthOptionSet = True;
+            ++argv;
+            --argc;
+            break;
+        }
+
+        case 'h': {  // specify a height (pixels) for an output QuickTime or AVI movie
+            if(sscanf(argv[2], "%hu", &movieHeight) != 1) {
+                usage();
+            }
+            movieHeightOptionSet = True;
+            ++argv;
+            --argc;
+            break;
+        }
+
+        case 'f': {  // specify a frame rate (per second) for an output QT or AVI movie
+            if(sscanf(argv[2], "%u", &movieFPS) != 1) {
+                usage();
+            }
+            movieFPSOptionSet = True;
+            ++argv;
+            --argc;
+            break;
+        }
+
+        case 'F': {  // specify a prefix for the audio and video output files
+            fileNamePrefix = argv[2];
+            ++argv;
+            --argc;
+            break;
+        }
+
+        case 'g': {  // specify a user agent name to use in outgoing requests
+            userAgent = argv[2];
+            ++argv;
+            --argc;
+            break;
+        }
+
+        case 'b': {  // specify the size of buffers for "FileSink"s
+            if(sscanf(argv[2], "%u", &fileSinkBufferSize) != 1) {
+                usage();
+            }
+            ++argv;
+            --argc;
+            break;
+        }
+
+        case 'B': {  // specify the size of input socket buffers
+            if(sscanf(argv[2], "%u", &socketInputBufferSize) != 1) {
+                usage();
+            }
+            ++argv;
+            --argc;
+            break;
+        }
+
+        // Note: The following option is deprecated, and may someday be removed:
+        case 'l': {  // try to compensate for packet loss by repeating frames
+            packetLossCompensate = True;
+            break;
+        }
+
+        case 'y': {  // synchronize audio and video streams
+            syncStreams = True;
+            break;
+        }
+
+        case 'H': {  // generate hint tracks (as well as the regular data tracks)
+            generateHintTracks = True;
+            break;
+        }
+
+        case 'Q': {                           // output QOS measurements
+            qosMeasurementIntervalMS = 1000;  // default: 1 second
+
+            if(argc > 3 && argv[2][0] != '-') {
+                // The next argument is the measurement interval,
+                // in multiples of 100 ms
+                if(sscanf(argv[2], "%u", &qosMeasurementIntervalMS) != 1) {
+                    usage();
+                }
+                qosMeasurementIntervalMS *= 100;
+                ++argv;
+                --argc;
+            }
+            break;
+        }
+
+        case 's': {  // specify initial seek time (trick play)
+            double arg;
+            if(sscanf(argv[2], "%lg", &arg) != 1 || arg < 0) {
+                usage();
+            }
+            initialSeekTime = arg;
+            ++argv;
+            --argc;
+            break;
+        }
+
+        case 'U': {
+            // specify initial absolute seek time (trick play), using a string of the form "YYYYMMDDTHHMMSSZ" or "YYYYMMDDTHHMMSS.<frac>Z"
+            initialAbsoluteSeekTime = argv[2];
+            ++argv;
+            --argc;
+            break;
+        }
+
+        case 'E': {
+            // specify initial absolute seek END time (trick play), using a string of the form "YYYYMMDDTHHMMSSZ" or "YYYYMMDDTHHMMSS.<frac>Z"
+            initialAbsoluteSeekEndTime = argv[2];
+            ++argv;
+            --argc;
+            break;
+        }
+        case 'z': {  // scale (trick play)
+            float arg;
+            if(sscanf(argv[2], "%g", &arg) != 1 || arg == 0.0f) {
+                usage();
+            }
+            scale = arg;
+            ++argv;
+            --argc;
+            break;
+        }
+
+        case 'R': {
+            // set up a handler server for incoming "REGISTER" commands
+            createHandlerServerForREGISTERCommand = True;
+            if(argc > 2 && argv[2][0] != '-') {
+                // The next argument is the REGISTER handler server port number:
+                if(sscanf(argv[2], "%hu", &handlerServerForREGISTERCommandPortNum) == 1 && handlerServerForREGISTERCommandPortNum > 0) {
+                    ++argv;
+                    --argc;
+                    break;
+                }
+            }
+            break;
+        }
+
+        case 'C': {
+            forceMulticastOnUnspecified = True;
+            break;
+        }
+
+        default: {
+            *env << "Invalid option: " << opt << "\n";
+            usage();
+            break;
+        }
+        }
+
+        ++argv;
+        --argc;
+    }
+
+    // There must be exactly one "rtsp://" URL at the end (unless '-R' was used, in which case there's no URL)
+    if(!((argc == 2 && !createHandlerServerForREGISTERCommand) || (argc == 1 && createHandlerServerForREGISTERCommand)))
+        usage();
+    if(outputQuickTimeFile && outputAVIFile) {
+        *env << "The -i and -q (or -4) options cannot both be used!\n";
+        usage();
+    }
+    Boolean outputCompositeFile = outputQuickTimeFile || outputAVIFile;
+    if(!createReceivers && (outputCompositeFile || oneFilePerFrame || fileOutputInterval > 0)) {
+        *env << "The -r option cannot be used with -q, -4, -i, -m, or -P!\n";
+        usage();
+    }
+    if(oneFilePerFrame && fileOutputInterval > 0) {
+        *env << "The -m and -P options cannot both be used!\n";
+        usage();
+    }
+    if(outputCompositeFile && !movieWidthOptionSet) {
+        *env << "Warning: The -q, -4 or -i option was used, but not -w.  Assuming a video width of " << movieWidth << " pixels\n";
+    }
+    if(outputCompositeFile && !movieHeightOptionSet) {
+        *env << "Warning: The -q, -4 or -i option was used, but not -h.  Assuming a video height of " << movieHeight << " pixels\n";
+    }
+    if(outputCompositeFile && !movieFPSOptionSet) {
+        *env << "Warning: The -q, -4 or -i option was used, but not -f.  Assuming a video frame rate of " << movieFPS << " frames-per-second\n";
+    }
+    if(audioOnly && videoOnly) {
+        *env << "The -a and -v options cannot both be used!\n";
+        usage();
+    }
+    if(audioOnly && applicationOnly) {
+        *env << "The -a and -L options cannot both be used!\n";
+        usage();
+    }
+    if(videoOnly && applicationOnly) {
+        *env << "The -v and -L options cannot both be used!\n";
+        usage();
+    }
+    if(sendOptionsRequestOnly && !sendOptionsRequest) {
+        *env << "The -o and -O options cannot both be used!\n";
+        usage();
+    }
+    if(initialAbsoluteSeekTime != NULL && initialSeekTime != 0.0f) {
+        *env << "The -s and -U options cannot both be used!\n";
+        usage();
+    }
+    if(initialAbsoluteSeekTime == NULL && initialAbsoluteSeekEndTime != NULL) {
+        *env << "The -E option requires the -U option!\n";
+        usage();
+    }
+    if(authDBForREGISTER != NULL && !createHandlerServerForREGISTERCommand) {
+        *env << "If \"-k <username> <password>\" is used, then -R (or \"-R <port-num>\") must also be used!\n";
+        usage();
+    }
+    if(tunnelOverHTTPPortNum > 0) {
+        if(streamUsingTCP) {
+            *env << "The -t and -T options cannot both be used!\n";
+            usage();
+        }
+        else {
+            streamUsingTCP = True;
+        }
+    }
+    if(!createReceivers && notifyOnPacketArrival) {
+        *env << "Warning: Because we're not receiving stream data, the -n flag has no effect\n";
+    }
+    if(durationSlop < 0) {
+        // This parameter wasn't set, so use a default value.
+        // If we're measuring QOS stats, then don't add any slop, to avoid
+        // having 'empty' measurement intervals at the end.
+        durationSlop = qosMeasurementIntervalMS > 0 ? 0.0 : 5.0;
+    }
+
+    streamURL = argv[1];
+
+    // Create (or arrange to create) our client object:
+    if(createHandlerServerForREGISTERCommand) {
+        handlerServerForREGISTERCommand = HandlerServerForREGISTERCommand::createNew(*env, continueAfterClientCreation0, handlerServerForREGISTERCommandPortNum,
+                                                                                     authDBForREGISTER, verbosityLevel, progName);
+        if(handlerServerForREGISTERCommand == NULL) {
+            *env << "Failed to create a server for handling incoming \"REGISTER\" commands: " << env->getResultMsg() << "\n";
+            shutdown();
+        }
+        else {
+            *env << "Awaiting an incoming \"REGISTER\" command on port " << handlerServerForREGISTERCommand->serverPortNum() << "\n";
+        }
+    }
+    else {
+        ourClient = createClient(*env, streamURL, verbosityLevel, progName);
+        if(ourClient == NULL) {
+            *env << "Failed to create " << clientProtocolName << " client: " << env->getResultMsg() << "\n";
+            shutdown();
+        }
+        continueAfterClientCreation1();
+    }
+
+    // All subsequent activity takes place within the event loop:
+    env->taskScheduler().doEventLoop();  // does not return
+
+    return 0;  // only to prevent compiler warning
+}
+
+void continueAfterClientCreation0(RTSPClient *newRTSPClient, Boolean requestStreamingOverTCP) {
+    if(newRTSPClient == NULL)
+        return;
+
+    streamUsingTCP = requestStreamingOverTCP;
+
+    assignClient(ourClient = newRTSPClient);
+    streamURL = newRTSPClient->url();
+
+    // Having handled one "REGISTER" command (giving us a "rtsp://" URL to stream from), we don't handle any more:
+    Medium::close(handlerServerForREGISTERCommand);
+    handlerServerForREGISTERCommand = NULL;
+
+    continueAfterClientCreation1();
+}
+
+void continueAfterClientCreation1() {
+    setUserAgentString(userAgent);
+
+    if(sendOptionsRequest) {
+        // Begin by sending an "OPTIONS" command:
+        getOptions(continueAfterOPTIONS);
+    }
+    else {
+        continueAfterOPTIONS(NULL, 0, NULL);
+    }
+}
+
+void continueAfterOPTIONS(RTSPClient *, int resultCode, char *resultString) {
+    if(sendOptionsRequestOnly) {
+        if(resultCode != 0) {
+            *env << clientProtocolName << " \"OPTIONS\" request failed: " << resultString << "\n";
+        }
+        else {
+            *env << clientProtocolName << " \"OPTIONS\" request returned: " << resultString << "\n";
+        }
+        shutdown();
+    }
+    delete[] resultString;
+
+    // Next, get a SDP description for the stream:
+    getSDPDescription(continueAfterDESCRIBE);
+}
+
+void continueAfterDESCRIBE(RTSPClient *, int resultCode, char *resultString) {
+    if(resultCode != 0) {
+        *env << "Failed to get a SDP description for the URL \"" << streamURL << "\": " << resultString << "\n";
+        delete[] resultString;
+        shutdown();
+    }
+
+    char *sdpDescription = resultString;
+    *env << "Opened URL \"" << streamURL << "\", returning a SDP description:\n" << sdpDescription << "\n";
+
+    // Create a media session object from this SDP description:
+    session = MediaSession::createNew(*env, sdpDescription);
+    delete[] sdpDescription;
+    if(session == NULL) {
+        *env << "Failed to create a MediaSession object from the SDP description: " << env->getResultMsg() << "\n";
+        shutdown();
+    }
+    else if(!session->hasSubsessions()) {
+        *env << "This session has no media subsessions (i.e., no \"m=\" lines)\n";
+        shutdown();
+    }
+
+    // Then, setup the "RTPSource"s for the session:
+    MediaSubsessionIterator iter(*session);
+    MediaSubsession *       subsession;
+    Boolean                 madeProgress       = False;
+    char const *            singleMediumToTest = singleMedium;
+    while((subsession = iter.next()) != NULL) {
+        // If we've asked to receive only a single medium, then check this now:
+        if(singleMediumToTest != NULL) {
+            if(strcmp(subsession->mediumName(), singleMediumToTest) != 0) {
+                *env << "Ignoring \"" << subsession->mediumName() << "/" << subsession->codecName() << "\" subsession, because we've asked to receive a single "
+                     << singleMedium << " session only\n";
+                continue;
+            }
+            else {
+                // Receive this subsession only
+                singleMediumToTest = "xxxxx";
+                // this hack ensures that we get only 1 subsession of this type
+            }
+        }
+
+        if(desiredPortNum != 0) {
+            subsession->setClientPortNum(desiredPortNum);
+            desiredPortNum += 2;
+        }
+
+        if(createReceivers) {
+            if(!subsession->initiate(simpleRTPoffsetArg)) {
+                *env << "Unable to create receiver for \"" << subsession->mediumName() << "/" << subsession->codecName()
+                     << "\" subsession: " << env->getResultMsg() << "\n";
+            }
+            else {
+                *env << "Created receiver for \"" << subsession->mediumName() << "/" << subsession->codecName() << "\" subsession (";
+                if(subsession->rtcpIsMuxed()) {
+                    *env << "client port " << subsession->clientPortNum();
+                }
+                else {
+                    *env << "client ports " << subsession->clientPortNum() << "-" << subsession->clientPortNum() + 1;
+                }
+                *env << ")\n";
+                madeProgress = True;
+
+                if(subsession->rtpSource() != NULL) {
+                    // Because we're saving the incoming data, rather than playing
+                    // it in real time, allow an especially large time threshold
+                    // (1 second) for reordering misordered incoming packets:
+                    unsigned const thresh = 1000000;  // 1 second
+                    subsession->rtpSource()->setPacketReorderingThresholdTime(thresh);
+
+                    // Set the RTP source's OS socket buffer size as appropriate - either if we were explicitly asked (using -B),
+                    // or if the desired FileSink buffer size happens to be larger than the current OS socket buffer size.
+                    // (The latter case is a heuristic, on the assumption that if the user asked for a large FileSink buffer size,
+                    // then the input data rate may be large enough to justify increasing the OS socket buffer size also.)
+                    int      socketNum     = subsession->rtpSource()->RTPgs()->socketNum();
+                    unsigned curBufferSize = getReceiveBufferSize(*env, socketNum);
+                    if(socketInputBufferSize > 0 || fileSinkBufferSize > curBufferSize) {
+                        unsigned newBufferSize = socketInputBufferSize > 0 ? socketInputBufferSize : fileSinkBufferSize;
+                        newBufferSize          = setReceiveBufferTo(*env, socketNum, newBufferSize);
+                        if(socketInputBufferSize > 0) {  // The user explicitly asked for the new socket buffer size; announce it:
+                            *env << "Changed socket receive buffer size for the \"" << subsession->mediumName() << "/" << subsession->codecName()
+                                 << "\" subsession from " << curBufferSize << " to " << newBufferSize << " bytes\n";
+                        }
+                    }
+                }
+            }
+        }
+        else {
+            if(subsession->clientPortNum() == 0) {
+                *env << "No client port was specified for the \"" << subsession->mediumName() << "/" << subsession->codecName()
+                     << "\" subsession.  (Try adding the \"-p <portNum>\" option.)\n";
+            }
+            else {
+                madeProgress = True;
+            }
+        }
+    }
+    if(!madeProgress)
+        shutdown();
+
+    // Perform additional 'setup' on each subsession, before playing them:
+    setupStreams();
+}
+
+MediaSubsession *subsession;
+Boolean          madeProgress = False;
+void             continueAfterSETUP(RTSPClient *client, int resultCode, char *resultString) {
+    if(resultCode == 0) {
+        *env << "Setup \"" << subsession->mediumName() << "/" << subsession->codecName() << "\" subsession (";
+        if(subsession->rtcpIsMuxed()) {
+            *env << "client port " << subsession->clientPortNum();
+        }
+        else {
+            *env << "client ports " << subsession->clientPortNum() << "-" << subsession->clientPortNum() + 1;
+        }
+        *env << ")\n";
+        madeProgress = True;
+    }
+    else {
+        *env << "Failed to setup \"" << subsession->mediumName() << "/" << subsession->codecName() << "\" subsession: " << resultString << "\n";
+    }
+    delete[] resultString;
+
+    if(client != NULL)
+        sessionTimeoutParameter = client->sessionTimeoutParameter();
+
+    // Set up the next subsession, if any:
+    setupStreams();
+}
+
+void createOutputFiles(char const *periodicFilenameSuffix) {
+    char outFileName[1000];
+
+    if(outputQuickTimeFile || outputAVIFile) {
+        if(periodicFilenameSuffix[0] == '\0') {
+            // Normally (unless the '-P <interval-in-seconds>' option was given) we output to 'stdout':
+            sprintf(outFileName, "stdout");
+        }
+        else {
+            // Otherwise output to a type-specific file name, containing "periodicFilenameSuffix":
+            char const *prefix = fileNamePrefix[0] == '\0' ? "output" : fileNamePrefix;
+            snprintf(outFileName, sizeof outFileName, "%s%s.%s", prefix, periodicFilenameSuffix, outputAVIFile ? "avi" : generateMP4Format ? "mp4" : "mov");
+        }
+
+        if(outputQuickTimeFile) {
+            qtOut = QuickTimeFileSink::createNew(*env, *session, outFileName, fileSinkBufferSize, movieWidth, movieHeight, movieFPS, packetLossCompensate,
+                                                 syncStreams, generateHintTracks, generateMP4Format);
+            if(qtOut == NULL) {
+                *env << "Failed to create a \"QuickTimeFileSink\" for outputting to \"" << outFileName << "\": " << env->getResultMsg() << "\n";
+                shutdown();
+            }
+            else {
+                *env << "Outputting to the file: \"" << outFileName << "\"\n";
+            }
+
+            qtOut->startPlaying(sessionAfterPlaying, NULL);
+        }
+        else {  // outputAVIFile
+            aviOut = AVIFileSink::createNew(*env, *session, outFileName, fileSinkBufferSize, movieWidth, movieHeight, movieFPS, packetLossCompensate);
+            if(aviOut == NULL) {
+                *env << "Failed to create an \"AVIFileSink\" for outputting to \"" << outFileName << "\": " << env->getResultMsg() << "\n";
+                shutdown();
+            }
+            else {
+                *env << "Outputting to the file: \"" << outFileName << "\"\n";
+            }
+
+            aviOut->startPlaying(sessionAfterPlaying, NULL);
+        }
+    }
+    else {
+        // Create and start "FileSink"s for each subsession:
+        madeProgress = False;
+        MediaSubsessionIterator iter(*session);
+        while((subsession = iter.next()) != NULL) {
+            if(subsession->readSource() == NULL)
+                continue;  // was not initiated
+
+            // Create an output file for each desired stream:
+            if(singleMedium == NULL || periodicFilenameSuffix[0] != '\0') {
+                // Output file name is
+                //     "<filename-prefix><medium_name>-<codec_name>-<counter><periodicFilenameSuffix>"
+                static unsigned streamCounter = 0;
+                snprintf(outFileName, sizeof outFileName, "%s%s-%s-%d%s", fileNamePrefix, subsession->mediumName(), subsession->codecName(), ++streamCounter,
+                         periodicFilenameSuffix);
+            }
+            else {
+                // When outputting a single medium only, we output to 'stdout
+                // (unless the '-P <interval-in-seconds>' option was given):
+                sprintf(outFileName, "stdout");
+            }
+
+            FileSink *fileSink          = NULL;
+            Boolean   createOggFileSink = False;  // by default
+            if(strcmp(subsession->mediumName(), "video") == 0) {
+                if(strcmp(subsession->codecName(), "H264") == 0) {
+                    // For H.264 video stream, we use a special sink that adds 'start codes',
+                    // and (at the start) the SPS and PPS NAL units:
+                    fileSink = H264VideoFileSink::createNew(*env, outFileName, subsession->fmtp_spropparametersets(), fileSinkBufferSize, oneFilePerFrame);
+                }
+                else if(strcmp(subsession->codecName(), "H265") == 0) {
+                    // For H.265 video stream, we use a special sink that adds 'start codes',
+                    // and (at the start) the VPS, SPS, and PPS NAL units:
+                    fileSink = H265VideoFileSink::createNew(*env, outFileName, subsession->fmtp_spropvps(), subsession->fmtp_spropsps(),
+                                                            subsession->fmtp_sproppps(), fileSinkBufferSize, oneFilePerFrame);
+                }
+                else if(strcmp(subsession->codecName(), "THEORA") == 0) {
+                    createOggFileSink = True;
+                }
+            }
+            else if(strcmp(subsession->mediumName(), "audio") == 0) {
+                if(strcmp(subsession->codecName(), "AMR") == 0 || strcmp(subsession->codecName(), "AMR-WB") == 0) {
+                    // For AMR audio streams, we use a special sink that inserts AMR frame hdrs:
+                    fileSink = AMRAudioFileSink::createNew(*env, outFileName, fileSinkBufferSize, oneFilePerFrame);
+                }
+                else if(strcmp(subsession->codecName(), "VORBIS") == 0 || strcmp(subsession->codecName(), "OPUS") == 0) {
+                    createOggFileSink = True;
+                }
+                else if(strcmp(subsession->codecName(), "MPEG4-GENERIC") == 0) {
+                    // For AAC audio, we use a regular file sink, but add a 'ADTS framer' filter
+                    // to the end of the data source, so that the resulting file is playable:
+                    FramedFilter *adtsFramer = ADTSAudioStreamDiscreteFramer::createNew(*env, subsession->readSource(), subsession->fmtp_config());
+                    subsession->addFilter(adtsFramer);
+                }
+            }
+            if(createOggFileSink) {
+                fileSink = OggFileSink ::createNew(*env, outFileName, subsession->rtpTimestampFrequency(), subsession->fmtp_config());
+            }
+            else if(fileSink == NULL) {
+                // Normal case:
+                fileSink = FileSink::createNew(*env, outFileName, fileSinkBufferSize, oneFilePerFrame);
+            }
+            subsession->sink = fileSink;
+
+            if(subsession->sink == NULL) {
+                *env << "Failed to create FileSink for \"" << outFileName << "\": " << env->getResultMsg() << "\n";
+            }
+            else {
+                if(singleMedium == NULL) {
+                    *env << "Created output file: \"" << outFileName << "\"\n";
+                }
+                else {
+                    *env << "Outputting data from the \"" << subsession->mediumName() << "/" << subsession->codecName() << "\" subsession to \"" << outFileName
+                         << "\"\n";
+                }
+
+                if(strcmp(subsession->mediumName(), "video") == 0 && strcmp(subsession->codecName(), "MP4V-ES") == 0 && subsession->fmtp_config() != NULL) {
+                    // For MPEG-4 video RTP streams, the 'config' information
+                    // from the SDP description contains useful VOL etc. headers.
+                    // Insert this data at the front of the output file:
+                    unsigned       configLen;
+                    unsigned char *configData = parseGeneralConfigStr(subsession->fmtp_config(), configLen);
+                    struct timeval timeNow;
+                    gettimeofday(&timeNow, NULL);
+                    fileSink->addData(configData, configLen, timeNow);
+                    delete[] configData;
+                }
+
+                subsession->sink->startPlaying(*(subsession->readSource()), subsessionAfterPlaying, subsession);
+
+                // Also set a handler to be called if a RTCP "BYE" arrives
+                // for this subsession:
+                if(subsession->rtcpInstance() != NULL) {
+                    subsession->rtcpInstance()->setByeWithReasonHandler(subsessionByeHandler, subsession);
+                }
+
+                madeProgress = True;
+            }
+        }
+        if(!madeProgress)
+            shutdown();
+    }
+}
+
+void createPeriodicOutputFiles() {
+    // Create a filename suffix that notes the time interval that's being recorded:
+    char periodicFileNameSuffix[100];
+    snprintf(periodicFileNameSuffix, sizeof periodicFileNameSuffix, "-%05d-%05d", fileOutputSecondsSoFar, fileOutputSecondsSoFar + fileOutputInterval);
+    createOutputFiles(periodicFileNameSuffix);
+
+    // Schedule an event for writing the next output file:
+    periodicFileOutputTask = env->taskScheduler().scheduleDelayedTask(fileOutputInterval * 1000000, (TaskFunc *)periodicFileOutputTimerHandler, (void *)NULL);
+}
+
+void setupStreams() {
+    static MediaSubsessionIterator *setupIter = NULL;
+    if(setupIter == NULL)
+        setupIter = new MediaSubsessionIterator(*session);
+    while((subsession = setupIter->next()) != NULL) {
+        // We have another subsession left to set up:
+        if(subsession->clientPortNum() == 0)
+            continue;  // port # was not set
+
+        setupSubsession(subsession, streamUsingTCP, forceMulticastOnUnspecified, continueAfterSETUP);
+        return;
+    }
+
+    // We're done setting up subsessions.
+    delete setupIter;
+    if(!madeProgress)
+        shutdown();
+
+    // Create output files:
+    if(createReceivers) {
+        if(fileOutputInterval > 0) {
+            createPeriodicOutputFiles();
+        }
+        else {
+            createOutputFiles("");
+        }
+    }
+
+    // Finally, start playing each subsession, to start the data flow:
+    if(duration == 0) {
+        if(scale > 0)
+            duration = session->playEndTime() - initialSeekTime;  // use SDP end time
+        else if(scale < 0)
+            duration = initialSeekTime;
+    }
+    if(duration < 0)
+        duration = 0.0;
+
+    endTime = initialSeekTime;
+    if(scale > 0) {
+        if(duration <= 0)
+            endTime = -1.0f;
+        else
+            endTime = initialSeekTime + duration;
+    }
+    else {
+        endTime = initialSeekTime - duration;
+        if(endTime < 0)
+            endTime = 0.0f;
+    }
+
+    char const *absStartTime = initialAbsoluteSeekTime != NULL ? initialAbsoluteSeekTime : session->absStartTime();
+    char const *absEndTime   = initialAbsoluteSeekEndTime != NULL ? initialAbsoluteSeekEndTime : session->absEndTime();
+    if(absStartTime != NULL) {
+        // Either we or the server have specified that seeking should be done by 'absolute' time:
+        startPlayingSession(session, absStartTime, absEndTime, scale, continueAfterPLAY);
+    }
+    else {
+        // Normal case: Seek by relative time (NPT):
+        startPlayingSession(session, initialSeekTime, endTime, scale, continueAfterPLAY);
+    }
+}
+
+void continueAfterPLAY(RTSPClient *, int resultCode, char *resultString) {
+    if(resultCode != 0) {
+        *env << "Failed to start playing session: " << resultString << "\n";
+        delete[] resultString;
+        shutdown();
+        return;
+    }
+    else {
+        *env << "Started playing session\n";
+    }
+    delete[] resultString;
+
+    if(qosMeasurementIntervalMS > 0) {
+        // Begin periodic QOS measurements:
+        beginQOSMeasurement();
+    }
+
+    // Figure out how long to delay (if at all) before shutting down, or
+    // repeating the playing
+    Boolean timerIsBeingUsed = False;
+    double  secondsToDelay   = duration;
+    if(duration > 0) {
+        // First, adjust "duration" based on any change to the play range (that was specified in the "PLAY" response):
+        double rangeAdjustment = (session->playEndTime() - session->playStartTime()) - (endTime - initialSeekTime);
+        if(duration + rangeAdjustment > 0.0)
+            duration += rangeAdjustment;
+
+        timerIsBeingUsed = True;
+        double absScale  = scale > 0 ? scale : -scale;  // ASSERT: scale != 0
+        secondsToDelay   = duration / absScale + durationSlop;
+
+        int64_t uSecsToDelay = (int64_t)(secondsToDelay * 1000000.0);
+        sessionTimerTask     = env->taskScheduler().scheduleDelayedTask(uSecsToDelay, (TaskFunc *)sessionTimerHandler, (void *)NULL);
+    }
+
+    char const *actionString = createReceivers ? "Receiving streamed data" : "Data is being streamed";
+    if(timerIsBeingUsed) {
+        *env << actionString << " (for up to " << secondsToDelay << " seconds)...\n";
+    }
+    else {
+#ifdef USE_SIGNALS
+        pid_t ourPid = getpid();
+        *env << actionString << " (signal with \"kill -HUP " << (int)ourPid << "\" or \"kill -USR1 " << (int)ourPid << "\" to terminate)...\n";
+#else
+        *env << actionString << "...\n";
+#endif
+    }
+
+    sessionTimeoutBrokenServerTask = NULL;
+
+    // Watch for incoming packets (if desired):
+    checkForPacketArrival(NULL);
+    checkInterPacketGaps(NULL);
+    checkSessionTimeoutBrokenServer(NULL);
+}
+
+void closeMediaSinks() {
+    Medium::close(qtOut);
+    qtOut = NULL;
+    Medium::close(aviOut);
+    aviOut = NULL;
+
+    if(session == NULL)
+        return;
+    MediaSubsessionIterator iter(*session);
+    MediaSubsession *       subsession;
+    while((subsession = iter.next()) != NULL) {
+        Medium::close(subsession->sink);
+        subsession->sink = NULL;
+    }
+}
+
+void subsessionAfterPlaying(void *clientData) {
+    // Begin by closing this media subsession's stream:
+    MediaSubsession *subsession = (MediaSubsession *)clientData;
+    Medium::close(subsession->sink);
+    subsession->sink = NULL;
+
+    // Next, check whether *all* subsessions' streams have now been closed:
+    MediaSession &          session = subsession->parentSession();
+    MediaSubsessionIterator iter(session);
+    while((subsession = iter.next()) != NULL) {
+        if(subsession->sink != NULL)
+            return;  // this subsession is still active
+    }
+
+    // All subsessions' streams have now been closed
+    sessionAfterPlaying();
+}
+
+void subsessionByeHandler(void *clientData, char const *reason) {
+    struct timeval timeNow;
+    gettimeofday(&timeNow, NULL);
+    unsigned secsDiff = timeNow.tv_sec - startTime.tv_sec;
+
+    MediaSubsession *subsession = (MediaSubsession *)clientData;
+    *env << "Received RTCP \"BYE\"";
+    if(reason != NULL) {
+        *env << " (reason:\"" << reason << "\")";
+        delete[](char *) reason;
+    }
+    *env << " on \"" << subsession->mediumName() << "/" << subsession->codecName() << "\" subsession (after " << secsDiff << " seconds)\n";
+
+    // Act now as if the subsession had closed:
+    subsessionAfterPlaying(subsession);
+}
+
+void sessionAfterPlaying(void * /*clientData*/) {
+    if(!playContinuously) {
+        shutdown(0);
+    }
+    else {
+        // We've been asked to play the stream(s) over again.
+        // First, reset state from the current session:
+        if(env != NULL) {
+            // Keep this running:      env->taskScheduler().unscheduleDelayedTask(periodicFileOutputTask);
+            env->taskScheduler().unscheduleDelayedTask(sessionTimerTask);
+            env->taskScheduler().unscheduleDelayedTask(sessionTimeoutBrokenServerTask);
+            env->taskScheduler().unscheduleDelayedTask(arrivalCheckTimerTask);
+            env->taskScheduler().unscheduleDelayedTask(interPacketGapCheckTimerTask);
+            env->taskScheduler().unscheduleDelayedTask(qosMeasurementTimerTask);
+        }
+        totNumPacketsReceived = ~0;
+
+        startPlayingSession(session, initialSeekTime, endTime, scale, continueAfterPLAY);
+    }
+}
+
+void sessionTimerHandler(void * /*clientData*/) {
+    sessionTimerTask = NULL;
+
+    sessionAfterPlaying();
+}
+
+void periodicFileOutputTimerHandler(void * /*clientData*/) {
+    periodicFileOutputTask = NULL;
+    fileOutputSecondsSoFar += fileOutputInterval;
+
+    // First, close the existing output files:
+    closeMediaSinks();
+
+    // Then, create new output files:
+    createPeriodicOutputFiles();
+}
+
+class qosMeasurementRecord {
+public:
+    qosMeasurementRecord(struct timeval const &startTime, RTPSource *src)
+        : fSource(src),
+          fNext(NULL),
+          kbits_per_second_min(1e20),
+          kbits_per_second_max(0),
+          kBytesTotal(0.0),
+          packet_loss_fraction_min(1.0),
+          packet_loss_fraction_max(0.0),
+          totNumPacketsReceived(0),
+          totNumPacketsExpected(0) {
+        measurementEndTime = measurementStartTime = startTime;
+
+        RTPReceptionStatsDB::Iterator statsIter(src->receptionStatsDB());
+        // Assume that there's only one SSRC source (usually the case):
+        RTPReceptionStats *stats = statsIter.next(True);
+        if(stats != NULL) {
+            kBytesTotal           = stats->totNumKBytesReceived();
+            totNumPacketsReceived = stats->totNumPacketsReceived();
+            totNumPacketsExpected = stats->totNumPacketsExpected();
+        }
+    }
+    virtual ~qosMeasurementRecord() {
+        delete fNext;
+    }
+
+    void periodicQOSMeasurement(struct timeval const &timeNow);
+
+public:
+    RTPSource *           fSource;
+    qosMeasurementRecord *fNext;
+
+public:
+    struct timeval measurementStartTime, measurementEndTime;
+    double         kbits_per_second_min, kbits_per_second_max;
+    double         kBytesTotal;
+    double         packet_loss_fraction_min, packet_loss_fraction_max;
+    unsigned       totNumPacketsReceived, totNumPacketsExpected;
+};
+
+static qosMeasurementRecord *qosRecordHead = NULL;
+
+static void periodicQOSMeasurement(void *clientData);  // forward
+
+static unsigned nextQOSMeasurementUSecs;
+
+static void scheduleNextQOSMeasurement() {
+    nextQOSMeasurementUSecs += qosMeasurementIntervalMS * 1000;
+    struct timeval timeNow;
+    gettimeofday(&timeNow, NULL);
+    unsigned timeNowUSecs = timeNow.tv_sec * 1000000 + timeNow.tv_usec;
+    int      usecsToDelay = nextQOSMeasurementUSecs - timeNowUSecs;
+
+    qosMeasurementTimerTask = env->taskScheduler().scheduleDelayedTask(usecsToDelay, (TaskFunc *)periodicQOSMeasurement, (void *)NULL);
+}
+
+static void periodicQOSMeasurement(void * /*clientData*/) {
+    struct timeval timeNow;
+    gettimeofday(&timeNow, NULL);
+
+    for(qosMeasurementRecord *qosRecord = qosRecordHead; qosRecord != NULL; qosRecord = qosRecord->fNext) {
+        qosRecord->periodicQOSMeasurement(timeNow);
+    }
+
+    // Do this again later:
+    scheduleNextQOSMeasurement();
+}
+
+void qosMeasurementRecord ::periodicQOSMeasurement(struct timeval const &timeNow) {
+    unsigned secsDiff  = timeNow.tv_sec - measurementEndTime.tv_sec;
+    int      usecsDiff = timeNow.tv_usec - measurementEndTime.tv_usec;
+    double   timeDiff  = secsDiff + usecsDiff / 1000000.0;
+    measurementEndTime = timeNow;
+
+    RTPReceptionStatsDB::Iterator statsIter(fSource->receptionStatsDB());
+    // Assume that there's only one SSRC source (usually the case):
+    RTPReceptionStats *stats = statsIter.next(True);
+    if(stats != NULL) {
+        double kBytesTotalNow = stats->totNumKBytesReceived();
+        double kBytesDeltaNow = kBytesTotalNow - kBytesTotal;
+        kBytesTotal           = kBytesTotalNow;
+
+        double kbpsNow = timeDiff == 0.0 ? 0.0 : 8 * kBytesDeltaNow / timeDiff;
+        if(kbpsNow < 0.0)
+            kbpsNow = 0.0;  // in case of roundoff error
+        if(kbpsNow < kbits_per_second_min)
+            kbits_per_second_min = kbpsNow;
+        if(kbpsNow > kbits_per_second_max)
+            kbits_per_second_max = kbpsNow;
+
+        unsigned totReceivedNow   = stats->totNumPacketsReceived();
+        unsigned totExpectedNow   = stats->totNumPacketsExpected();
+        unsigned deltaReceivedNow = totReceivedNow - totNumPacketsReceived;
+        unsigned deltaExpectedNow = totExpectedNow - totNumPacketsExpected;
+        totNumPacketsReceived     = totReceivedNow;
+        totNumPacketsExpected     = totExpectedNow;
+
+        double lossFractionNow = deltaExpectedNow == 0 ? 0.0 : 1.0 - deltaReceivedNow / (double)deltaExpectedNow;
+        // if (lossFractionNow < 0.0) lossFractionNow = 0.0; //reordering can cause
+        if(lossFractionNow < packet_loss_fraction_min) {
+            packet_loss_fraction_min = lossFractionNow;
+        }
+        if(lossFractionNow > packet_loss_fraction_max) {
+            packet_loss_fraction_max = lossFractionNow;
+        }
+    }
+}
+
+void beginQOSMeasurement() {
+    // Set up a measurement record for each active subsession:
+    struct timeval startTime;
+    gettimeofday(&startTime, NULL);
+    nextQOSMeasurementUSecs               = startTime.tv_sec * 1000000 + startTime.tv_usec;
+    qosMeasurementRecord *  qosRecordTail = NULL;
+    MediaSubsessionIterator iter(*session);
+    MediaSubsession *       subsession;
+    while((subsession = iter.next()) != NULL) {
+        RTPSource *src = subsession->rtpSource();
+        if(src == NULL)
+            continue;
+
+        qosMeasurementRecord *qosRecord = new qosMeasurementRecord(startTime, src);
+        if(qosRecordHead == NULL)
+            qosRecordHead = qosRecord;
+        if(qosRecordTail != NULL)
+            qosRecordTail->fNext = qosRecord;
+        qosRecordTail = qosRecord;
+    }
+
+    // Then schedule the first of the periodic measurements:
+    scheduleNextQOSMeasurement();
+}
+
+void printQOSData(int exitCode) {
+    *env << "begin_QOS_statistics\n";
+
+    // Print out stats for each active subsession:
+    qosMeasurementRecord *curQOSRecord = qosRecordHead;
+    if(session != NULL) {
+        MediaSubsessionIterator iter(*session);
+        MediaSubsession *       subsession;
+        while((subsession = iter.next()) != NULL) {
+            RTPSource *src = subsession->rtpSource();
+            if(src == NULL)
+                continue;
+
+            *env << "subsession\t" << subsession->mediumName() << "/" << subsession->codecName() << "\n";
+
+            unsigned numPacketsReceived = 0, numPacketsExpected = 0;
+
+            if(curQOSRecord != NULL) {
+                numPacketsReceived = curQOSRecord->totNumPacketsReceived;
+                numPacketsExpected = curQOSRecord->totNumPacketsExpected;
+            }
+            *env << "num_packets_received\t" << numPacketsReceived << "\n";
+            *env << "num_packets_lost\t" << int(numPacketsExpected - numPacketsReceived) << "\n";
+
+            if(curQOSRecord != NULL) {
+                unsigned secsDiff        = curQOSRecord->measurementEndTime.tv_sec - curQOSRecord->measurementStartTime.tv_sec;
+                int      usecsDiff       = curQOSRecord->measurementEndTime.tv_usec - curQOSRecord->measurementStartTime.tv_usec;
+                double   measurementTime = secsDiff + usecsDiff / 1000000.0;
+                *env << "elapsed_measurement_time\t" << measurementTime << "\n";
+
+                *env << "kBytes_received_total\t" << curQOSRecord->kBytesTotal << "\n";
+
+                *env << "measurement_sampling_interval_ms\t" << qosMeasurementIntervalMS << "\n";
+
+                if(curQOSRecord->kbits_per_second_max == 0) {
+                    // special case: we didn't receive any data:
+                    *env << "kbits_per_second_min\tunavailable\n"
+                            "kbits_per_second_ave\tunavailable\n"
+                            "kbits_per_second_max\tunavailable\n";
+                }
+                else {
+                    *env << "kbits_per_second_min\t" << curQOSRecord->kbits_per_second_min << "\n";
+                    *env << "kbits_per_second_ave\t" << (measurementTime == 0.0 ? 0.0 : 8 * curQOSRecord->kBytesTotal / measurementTime) << "\n";
+                    *env << "kbits_per_second_max\t" << curQOSRecord->kbits_per_second_max << "\n";
+                }
+
+                *env << "packet_loss_percentage_min\t" << 100 * curQOSRecord->packet_loss_fraction_min << "\n";
+                double packetLossFraction = numPacketsExpected == 0 ? 1.0 : 1.0 - numPacketsReceived / (double)numPacketsExpected;
+                if(packetLossFraction < 0.0)
+                    packetLossFraction = 0.0;
+                *env << "packet_loss_percentage_ave\t" << 100 * packetLossFraction << "\n";
+                *env << "packet_loss_percentage_max\t" << (packetLossFraction == 1.0 ? 100.0 : 100 * curQOSRecord->packet_loss_fraction_max) << "\n";
+
+                RTPReceptionStatsDB::Iterator statsIter(src->receptionStatsDB());
+                // Assume that there's only one SSRC source (usually the case):
+                RTPReceptionStats *stats = statsIter.next(True);
+                if(stats != NULL) {
+                    *env << "inter_packet_gap_ms_min\t" << stats->minInterPacketGapUS() / 1000.0 << "\n";
+                    struct timeval totalGaps             = stats->totalInterPacketGaps();
+                    double         totalGapsMS           = totalGaps.tv_sec * 1000.0 + totalGaps.tv_usec / 1000.0;
+                    unsigned       totNumPacketsReceived = stats->totNumPacketsReceived();
+                    *env << "inter_packet_gap_ms_ave\t" << (totNumPacketsReceived == 0 ? 0.0 : totalGapsMS / totNumPacketsReceived) << "\n";
+                    *env << "inter_packet_gap_ms_max\t" << stats->maxInterPacketGapUS() / 1000.0 << "\n";
+                }
+
+                curQOSRecord = curQOSRecord->fNext;
+            }
+        }
+    }
+
+    *env << "end_QOS_statistics\n";
+    delete qosRecordHead;
+}
+
+Boolean areAlreadyShuttingDown = False;
+int     shutdownExitCode;
+void    shutdown(int exitCode) {
+    if(areAlreadyShuttingDown)
+        return;  // in case we're called after receiving a RTCP "BYE" while in the middle of a "TEARDOWN".
+    areAlreadyShuttingDown = True;
+
+    shutdownExitCode = exitCode;
+    if(env != NULL) {
+        env->taskScheduler().unscheduleDelayedTask(periodicFileOutputTask);
+        env->taskScheduler().unscheduleDelayedTask(sessionTimerTask);
+        env->taskScheduler().unscheduleDelayedTask(sessionTimeoutBrokenServerTask);
+        env->taskScheduler().unscheduleDelayedTask(arrivalCheckTimerTask);
+        env->taskScheduler().unscheduleDelayedTask(interPacketGapCheckTimerTask);
+        env->taskScheduler().unscheduleDelayedTask(qosMeasurementTimerTask);
+    }
+
+    if(qosMeasurementIntervalMS > 0) {
+        printQOSData(exitCode);
+    }
+
+    // Teardown, then shutdown, any outstanding RTP/RTCP subsessions
+    Boolean shutdownImmediately = True;  // by default
+    if(session != NULL) {
+        RTSPClient::responseHandler *responseHandlerForTEARDOWN = NULL;  // unless:
+        if(waitForResponseToTEARDOWN) {
+            shutdownImmediately        = False;
+            responseHandlerForTEARDOWN = continueAfterTEARDOWN;
+        }
+        tearDownSession(session, responseHandlerForTEARDOWN);
+    }
+
+    if(shutdownImmediately)
+        continueAfterTEARDOWN(NULL, 0, NULL);
+}
+
+void continueAfterTEARDOWN(RTSPClient *, int /*resultCode*/, char *resultString) {
+    delete[] resultString;
+
+    // Now that we've stopped any more incoming data from arriving, close our output files:
+    closeMediaSinks();
+    Medium::close(session);
+
+    // Finally, shut down our client:
+    delete ourAuthenticator;
+    delete authDBForREGISTER;
+    Medium::close(ourClient);
+
+    // Adios...
+    exit(shutdownExitCode);
+}
+
+void signalHandlerShutdown(int /*sig*/) {
+    *env << "Got shutdown signal\n";
+    waitForResponseToTEARDOWN = False;  // to ensure that we end, even if the server does not respond to our TEARDOWN
+    shutdown(0);
+}
+
+void checkForPacketArrival(void * /*clientData*/) {
+    arrivalCheckTimerTask = NULL;
+    if(!notifyOnPacketArrival)
+        return;  // we're not checking
+
+    // Check each subsession, to see whether it has received data packets:
+    unsigned numSubsessionsChecked            = 0;
+    unsigned numSubsessionsWithReceivedData   = 0;
+    unsigned numSubsessionsThatHaveBeenSynced = 0;
+
+    MediaSubsessionIterator iter(*session);
+    MediaSubsession *       subsession;
+    while((subsession = iter.next()) != NULL) {
+        RTPSource *src = subsession->rtpSource();
+        if(src == NULL)
+            continue;
+        ++numSubsessionsChecked;
+
+        if(src->receptionStatsDB().numActiveSourcesSinceLastReset() > 0) {
+            // At least one data packet has arrived
+            ++numSubsessionsWithReceivedData;
+        }
+        if(src->hasBeenSynchronizedUsingRTCP()) {
+            ++numSubsessionsThatHaveBeenSynced;
+        }
+    }
+
+    unsigned numSubsessionsToCheck = numSubsessionsChecked;
+    // Special case for "QuickTimeFileSink"s and "AVIFileSink"s:
+    // They might not use all of the input sources:
+    if(qtOut != NULL) {
+        numSubsessionsToCheck = qtOut->numActiveSubsessions();
+    }
+    else if(aviOut != NULL) {
+        numSubsessionsToCheck = aviOut->numActiveSubsessions();
+    }
+
+    Boolean notifyTheUser;
+    if(!syncStreams) {
+        notifyTheUser = numSubsessionsWithReceivedData > 0;  // easy case
+    }
+    else {
+        notifyTheUser = numSubsessionsWithReceivedData >= numSubsessionsToCheck && numSubsessionsThatHaveBeenSynced == numSubsessionsChecked;
+        // Note: A subsession with no active sources is considered to be synced
+    }
+    if(notifyTheUser) {
+        struct timeval timeNow;
+        gettimeofday(&timeNow, NULL);
+        char timestampStr[100];
+        sprintf(timestampStr, "%ld%03ld", timeNow.tv_sec, (long)(timeNow.tv_usec / 1000));
+        *env << (syncStreams ? "Synchronized d" : "D") << "ata packets have begun arriving [" << timestampStr << "]\007\n";
+        return;
+    }
+
+    // No luck, so reschedule this check again, after a delay:
+    int uSecsToDelay      = 100000;  // 100 ms
+    arrivalCheckTimerTask = env->taskScheduler().scheduleDelayedTask(uSecsToDelay, (TaskFunc *)checkForPacketArrival, NULL);
+}
+
+void checkInterPacketGaps(void * /*clientData*/) {
+    interPacketGapCheckTimerTask = NULL;
+    if(interPacketGapMaxTime == 0)
+        return;  // we're not checking
+
+    // Check each subsession, counting up how many packets have been received:
+    unsigned newTotNumPacketsReceived = 0;
+
+    MediaSubsessionIterator iter(*session);
+    MediaSubsession *       subsession;
+    while((subsession = iter.next()) != NULL) {
+        RTPSource *src = subsession->rtpSource();
+        if(src == NULL)
+            continue;
+        newTotNumPacketsReceived += src->receptionStatsDB().totNumPacketsReceived();
+    }
+
+    if(newTotNumPacketsReceived == totNumPacketsReceived) {
+        // No additional packets have been received since the last time we
+        // checked, so end this stream:
+        *env << "Closing session, because we stopped receiving packets.\n";
+        interPacketGapCheckTimerTask = NULL;
+        sessionAfterPlaying();
+    }
+    else {
+        totNumPacketsReceived = newTotNumPacketsReceived;
+        // Check again, after the specified delay:
+        interPacketGapCheckTimerTask = env->taskScheduler().scheduleDelayedTask(interPacketGapMaxTime * 1000000, (TaskFunc *)checkInterPacketGaps, NULL);
+    }
+}
+
+void checkSessionTimeoutBrokenServer(void * /*clientData*/) {
+    if(!sendKeepAlivesToBrokenServers)
+        return;  // we're not checking
+
+    // Send an "OPTIONS" request, starting with the second call
+    if(sessionTimeoutBrokenServerTask != NULL) {
+        getOptions(NULL);
+    }
+
+    unsigned sessionTimeout            = sessionTimeoutParameter == 0 ? 60 /*default*/ : sessionTimeoutParameter;
+    unsigned secondsUntilNextKeepAlive = sessionTimeout <= 5 ? 1 : sessionTimeout - 5;
+    // Reduce the interval a little, to be on the safe side
+
+    sessionTimeoutBrokenServerTask =
+        env->taskScheduler().scheduleDelayedTask(secondsUntilNextKeepAlive * 1000000, (TaskFunc *)checkSessionTimeoutBrokenServer, NULL);
+}
diff --git a/3rdparty/live555/src/testProgs/playCommon.hh b/3rdparty/live555/src/testProgs/playCommon.hh
new file mode 100644
index 00000000..a9e7debb
--- /dev/null
+++ b/3rdparty/live555/src/testProgs/playCommon.hh
@@ -0,0 +1,47 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// Copyright (c) 1996-2022, Live Networks, Inc.  All rights reserved
+// A common framework, used for the "openRTSP" and "playSIP" applications
+// Interfaces
+
+#include "liveMedia.hh"
+
+extern Medium* createClient(UsageEnvironment& env, char const* URL, int verbosityLevel, char const* applicationName);
+extern void assignClient(Medium* client);
+extern RTSPClient* ourRTSPClient;
+extern SIPClient* ourSIPClient;
+
+extern void getOptions(RTSPClient::responseHandler* afterFunc);
+
+extern void getSDPDescription(RTSPClient::responseHandler* afterFunc);
+
+extern void setupSubsession(MediaSubsession* subsession, Boolean streamUsingTCP, Boolean forceMulticastOnUnspecified, RTSPClient::responseHandler* afterFunc);
+
+extern void startPlayingSession(MediaSession* session, double start, double end, float scale, RTSPClient::responseHandler* afterFunc);
+
+extern void startPlayingSession(MediaSession* session, char const* absStartTime, char const* absEndTime, float scale, RTSPClient::responseHandler* afterFunc);
+  // For playing by 'absolute' time (using strings of the form "YYYYMMDDTHHMMSSZ" or "YYYYMMDDTHHMMSS.<frac>Z"
+
+extern void tearDownSession(MediaSession* session, RTSPClient::responseHandler* afterFunc);
+
+extern void setUserAgentString(char const* userAgentString);
+
+extern Authenticator* ourAuthenticator;
+extern Boolean allowProxyServers;
+extern Boolean controlConnectionUsesTCP;
+extern Boolean supportCodecSelection;
+extern char const* clientProtocolName;
+extern unsigned statusCode;
diff --git a/3rdparty/live555/src/testProgs/playSIP.cpp b/3rdparty/live555/src/testProgs/playSIP.cpp
new file mode 100644
index 00000000..26be7fed
--- /dev/null
+++ b/3rdparty/live555/src/testProgs/playSIP.cpp
@@ -0,0 +1,192 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// Copyright (c) 1996-2022, Live Networks, Inc.  All rights reserved
+// A SIP client test program that opens a SIP URL argument,
+// and extracts the data from each incoming RTP stream.
+
+#include "playCommon.hh"
+#include "SIPClient.hh"
+
+static char *getLine(char *startOfLine) {
+    // returns the start of the next line, or NULL if none
+    for(char *ptr = startOfLine; *ptr != '\0'; ++ptr) {
+        if(*ptr == '\r' || *ptr == '\n') {
+            // We found the end of the line
+            *ptr++ = '\0';
+            if(*ptr == '\n')
+                ++ptr;
+            return ptr;
+        }
+    }
+
+    return NULL;
+}
+
+SIPClient *ourSIPClient = NULL;
+Medium *   createClient(UsageEnvironment &env, char const * /*url*/, int verbosityLevel, char const *applicationName) {
+    // First, trim any directory prefixes from "applicationName":
+    char const *suffix = &applicationName[strlen(applicationName)];
+    while(suffix != applicationName) {
+        if(*suffix == '/' || *suffix == '\\') {
+            applicationName = ++suffix;
+            break;
+        }
+        --suffix;
+    }
+
+    extern unsigned char desiredAudioRTPPayloadFormat;
+    extern char *        mimeSubtype;
+    return ourSIPClient = SIPClient::createNew(env, desiredAudioRTPPayloadFormat, mimeSubtype, verbosityLevel, applicationName);
+}
+
+// The followign function is implemented, but is not used for "playSIP":
+void assignClient(Medium * /*client*/) {}
+
+void getOptions(RTSPClient::responseHandler *afterFunc) {
+    ourSIPClient->envir().setResultMsg("NOT SUPPORTED IN CLIENT");
+    afterFunc(NULL, -1, strDup(ourSIPClient->envir().getResultMsg()));
+}
+
+void getSDPDescription(RTSPClient::responseHandler *afterFunc) {
+    extern char *proxyServerName;
+    if(proxyServerName != NULL) {
+        // Tell the SIP client about the proxy:
+        NetAddressList addresses(proxyServerName);
+        if(addresses.numAddresses() == 0) {
+            ourSIPClient->envir() << "Failed to find network address for \"" << proxyServerName << "\"\n";
+        }
+        else {
+            struct sockaddr_storage proxyServerAddress;
+            copyAddress(proxyServerAddress, addresses.firstAddress());
+
+            extern unsigned short proxyServerPortNum;
+            if(proxyServerPortNum == 0)
+                proxyServerPortNum = 5060;  // default
+
+            ourSIPClient->setProxyServer(proxyServerAddress, proxyServerPortNum);
+        }
+    }
+
+    extern unsigned short desiredPortNum;
+    unsigned short        clientStartPortNum = desiredPortNum;
+    if(clientStartPortNum == 0)
+        clientStartPortNum = 8000;  // default
+    ourSIPClient->setClientStartPortNum(clientStartPortNum);
+
+    extern char const *streamURL;
+    char const *       username = ourAuthenticator == NULL ? NULL : ourAuthenticator->username();
+    char const *       password = ourAuthenticator == NULL ? NULL : ourAuthenticator->password();
+    char *             result;
+    if(username != NULL && password != NULL) {
+        result = ourSIPClient->inviteWithPassword(streamURL, username, password);
+    }
+    else {
+        result = ourSIPClient->invite(streamURL);
+    }
+
+    int resultCode = result == NULL ? -1 : 0;
+    afterFunc(NULL, resultCode, strDup(result));
+}
+
+void setupSubsession(MediaSubsession *subsession, Boolean /*streamUsingTCP*/, Boolean /*forceMulticastOnUnspecified*/, RTSPClient::responseHandler *afterFunc) {
+    subsession->setSessionId("mumble");  // anything that's non-NULL will work
+
+    ////////// BEGIN hack code that should really be implemented in SIPClient //////////
+    // Parse the "Transport:" header parameters:
+    // We do not send audio, but we need port for RTCP
+    char *        serverAddressStr;
+    portNumBits   serverPortNum;
+    unsigned char rtpChannelId, rtcpChannelId;
+
+    rtpChannelId = rtcpChannelId = 0xff;
+    serverPortNum                = 0;
+    serverAddressStr             = NULL;
+
+    char *sdp = strDup(ourSIPClient->getInviteSdpReply());
+
+    char *lineStart;
+    char *nextLineStart = sdp;
+    while(1) {
+        lineStart = nextLineStart;
+        if(lineStart == NULL) {
+            break;
+        }
+        nextLineStart = getLine(lineStart);
+
+        char *toTagStr = strDupSize(lineStart);
+
+        if(sscanf(lineStart, "m=audio %[^/\r\n]", toTagStr) == 1) {
+            sscanf(toTagStr, "%hu", &serverPortNum);
+        }
+        else if(sscanf(lineStart, "c=IN IP4 %[^/\r\n]", toTagStr) == 1) {
+            serverAddressStr = strDup(toTagStr);
+        }
+        delete[] toTagStr;
+    }
+
+    if(sdp != NULL) {
+        delete[] sdp;
+    }
+
+    delete[] subsession->connectionEndpointName();
+    subsession->connectionEndpointName() = serverAddressStr;
+    subsession->serverPortNum            = serverPortNum;
+    subsession->rtpChannelId             = rtpChannelId;
+    subsession->rtcpChannelId            = rtcpChannelId;
+
+    // Set the RTP and RTCP sockets' destination address and port from the information in the SETUP response (if present):
+    struct sockaddr_storage destAddress;
+    subsession->getConnectionEndpointAddress(destAddress);
+    if(!addressIsNull(destAddress)) {
+        subsession->setDestinations(destAddress);
+    }
+    ////////// END hack code that should really be implemented in SIPClient //////////
+
+    afterFunc(NULL, 0, NULL);
+}
+
+void startPlayingSession(MediaSession * /*session*/, double /*start*/, double /*end*/, float /*scale*/, RTSPClient::responseHandler *afterFunc) {
+    if(ourSIPClient->sendACK()) {
+        //##### This isn't quite right, because we should really be allowing
+        //##### for the possibility of this ACK getting lost, by retransmitting
+        //##### it *each time* we get a 2xx response from the server.
+        afterFunc(NULL, 0, NULL);
+    }
+    else {
+        afterFunc(NULL, -1, strDup(ourSIPClient->envir().getResultMsg()));
+    }
+}
+void startPlayingSession(MediaSession * /*session*/, const char * /*start*/, const char * /*end*/, float /*scale*/, RTSPClient::responseHandler *afterFunc) {
+    startPlayingSession(NULL, (double)0, (double)0, 0, afterFunc);
+}
+
+void tearDownSession(MediaSession * /*session*/, RTSPClient::responseHandler *afterFunc) {
+    if(ourSIPClient == NULL || ourSIPClient->sendBYE()) {
+        afterFunc(NULL, 0, NULL);
+    }
+    else {
+        afterFunc(NULL, -1, strDup(ourSIPClient->envir().getResultMsg()));
+    }
+}
+
+void setUserAgentString(char const *userAgentString) {
+    ourSIPClient->setUserAgentString(userAgentString);
+}
+
+Boolean     allowProxyServers        = True;
+Boolean     controlConnectionUsesTCP = False;
+Boolean     supportCodecSelection    = True;
+char const *clientProtocolName       = "SIP";
diff --git a/3rdparty/live555/src/testProgs/registerRTSPStream.cpp b/3rdparty/live555/src/testProgs/registerRTSPStream.cpp
new file mode 100644
index 00000000..af0e7c92
--- /dev/null
+++ b/3rdparty/live555/src/testProgs/registerRTSPStream.cpp
@@ -0,0 +1,107 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// Copyright (c) 1996-2022, Live Networks, Inc.  All rights reserved
+// A demonstration application that uses our custom RTSP "REGISTER" command to register a stream
+// (given by "rtsp://" URL) with a RTSP client or proxy server
+// main program
+
+#include "liveMedia.hh"
+#include "BasicUsageEnvironment.hh"
+
+char const *      programName;
+UsageEnvironment *env;
+
+Boolean     requestStreamingViaTCP = False;
+char const *username               = NULL;
+char const *password               = NULL;
+
+void registerResponseHandler(RTSPClient *rtspClient, int resultCode, char *resultString) {
+    Medium::close(rtspClient);
+
+    // We're done:
+    exit(0);
+}
+
+void usage() {
+    *env << "usage: " << programName
+         << " [-t] [-u <username> <password>] "
+            "<remote-client-or-proxy-server-name-or-address> <remote-client-or-proxy-server-port-number> <rtsp-URL-to-register>"
+            " [proxy-URL-suffix]\n";
+    exit(1);
+}
+
+int main(int argc, char const **argv) {
+    // Begin by setting up our usage environment:
+    TaskScheduler *scheduler = BasicTaskScheduler::createNew();
+    env                      = BasicUsageEnvironment::createNew(*scheduler);
+
+    // Parse command-line options and arguments:
+    // (Unfortunately we can't use getopt() here; Windoze doesn't have it)
+    programName = argv[0];
+    while(argc > 2) {
+        char const *const opt = argv[1];
+        if(opt[0] != '-')
+            break;
+        switch(opt[1]) {
+        case 't': {  // ask the remote client to access the stream via TCP instead of UDP
+            requestStreamingViaTCP = True;
+            break;
+        }
+
+        case 'u': {  // specify a username and password
+            if(argc < 4)
+                usage();  // there's no argv[3] (for the "password")
+            username = argv[2];
+            password = argv[3];
+            argv += 2;
+            argc -= 2;
+            break;
+        }
+
+        default: {
+            usage();
+            break;
+        }
+        }
+
+        ++argv;
+        --argc;
+    }
+    if(argc != 4 && argc != 5)
+        usage();
+
+    char const *remoteClientNameOrAddress = argv[1];
+
+    portNumBits remoteClientPortNum;
+    if(sscanf(argv[2], "%hu", &remoteClientPortNum) != 1 || remoteClientPortNum == 0 || remoteClientPortNum == 0xFFFF)
+        usage();
+
+    char const *rtspURLToRegister = argv[3];
+
+    char const *proxyURLSuffix = argc == 5 ? argv[4] : NULL;
+
+    Authenticator *ourAuthenticator = username == NULL ? NULL : new Authenticator(username, password);
+
+    // We have the command-line arguments.  Send the command:
+
+    RTSPRegisterSender::createNew(*env, remoteClientNameOrAddress, remoteClientPortNum, rtspURLToRegister, registerResponseHandler, ourAuthenticator,
+                                  requestStreamingViaTCP, proxyURLSuffix, False /*reuseConnection*/, 1 /*verbosityLevel*/, programName);
+    // Note: This object will be deleted later, by the response handler
+
+    env->taskScheduler().doEventLoop();  // does not return
+
+    return 0;  // only to prevent compiler warning
+}
diff --git a/3rdparty/live555/src/testProgs/sapWatch.cpp b/3rdparty/live555/src/testProgs/sapWatch.cpp
new file mode 100644
index 00000000..9062731e
--- /dev/null
+++ b/3rdparty/live555/src/testProgs/sapWatch.cpp
@@ -0,0 +1,73 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// Copyright (c) 1996-2022, Live Networks, Inc.  All rights reserved
+// A program that receives and prints SDP/SAP announcements
+// (on the default SDP/SAP directory: 224.2.127.254/9875)
+
+#include "Groupsock.hh"
+#include "GroupsockHelper.hh"
+#include "BasicUsageEnvironment.hh"
+#include <stdio.h>
+
+static unsigned const maxPacketSize = 65536;
+static unsigned char  packet[maxPacketSize + 1];
+
+int main(int argc, char **argv) {
+    // Begin by setting up our usage environment:
+    TaskScheduler *   scheduler = BasicTaskScheduler::createNew();
+    UsageEnvironment *env       = BasicUsageEnvironment::createNew(*scheduler);
+
+    // Create a 'groupsock' for the input multicast group,port:
+    char const *            sessionAddressStr = "224.2.127.254";
+    NetAddressList          sessionAddresses(sessionAddressStr);
+    struct sockaddr_storage sessionAddress;
+    copyAddress(sessionAddress, sessionAddresses.firstAddress());
+
+    const Port          port(9875);
+    const unsigned char ttl = 0;  // we're only reading from this mcast group
+
+    Groupsock inputGroupsock(*env, sessionAddress, port, ttl);
+
+    // Start reading and printing incoming packets
+    // (Because this is the only thing we do, we can just do this
+    // synchronously, in a loop, so we don't need to set up an asynchronous
+    // event handler like we do in most of the other test programs.)
+    unsigned                packetSize;
+    struct sockaddr_storage fromAddress;
+    while(inputGroupsock.handleRead(packet, maxPacketSize, packetSize, fromAddress)) {
+        printf("\n[packet from %s (%d bytes)]\n", AddressString(fromAddress).val(), packetSize);
+
+        // Ignore the first 8 bytes (SAP header).
+        if(packetSize < 8) {
+            *env << "Ignoring short packet from " << AddressString(fromAddress).val() << "%s!\n";
+            continue;
+        }
+
+        // convert "application/sdp\0" -> "application/sdp\0x20"
+        // or all other nonprintable characters to blank, except new line
+        unsigned idx = 8;
+        while(idx < packetSize) {
+            if(packet[idx] < 0x20 && packet[idx] != '\n')
+                packet[idx] = 0x20;
+            idx++;
+        }
+
+        packet[packetSize] = '\0';  // just in case
+        printf("%s", (char *)(packet + 8));
+    }
+
+    return 0;  // only to prevent compiler warning
+}
diff --git a/3rdparty/live555/src/testProgs/testAMRAudioStreamer.cpp b/3rdparty/live555/src/testProgs/testAMRAudioStreamer.cpp
new file mode 100644
index 00000000..31d3ac54
--- /dev/null
+++ b/3rdparty/live555/src/testProgs/testAMRAudioStreamer.cpp
@@ -0,0 +1,113 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// Copyright (c) 1996-2022, Live Networks, Inc.  All rights reserved
+// A test program that reads an AMR audio file (as defined in RFC 3267)
+// and streams it using RTP
+// main program
+
+#include "liveMedia.hh"
+
+#include "BasicUsageEnvironment.hh"
+#include "announceURL.hh"
+#include "GroupsockHelper.hh"
+
+UsageEnvironment *  env;
+char const *        inputFileName = "test.amr";
+AMRAudioFileSource *audioSource;
+RTPSink *           audioSink;
+
+void play();  // forward
+
+int main(int argc, char **argv) {
+    // Begin by setting up our usage environment:
+    TaskScheduler *scheduler = BasicTaskScheduler::createNew();
+    env                      = BasicUsageEnvironment::createNew(*scheduler);
+
+    // Create 'groupsocks' for RTP and RTCP:
+    struct sockaddr_storage destinationAddress;
+    destinationAddress.ss_family                               = AF_INET;
+    ((struct sockaddr_in &)destinationAddress).sin_addr.s_addr = chooseRandomIPv4SSMAddress(*env);
+    // Note: This is a multicast address.  If you wish instead to stream
+    // using unicast, then you should use the "testOnDemandRTSPServer"
+    // test program - not this test program - as a model.
+
+    const unsigned short rtpPortNum  = 16666;
+    const unsigned short rtcpPortNum = rtpPortNum + 1;
+    const unsigned char  ttl         = 255;
+
+    const Port rtpPort(rtpPortNum);
+    const Port rtcpPort(rtcpPortNum);
+
+    Groupsock rtpGroupsock(*env, destinationAddress, rtpPort, ttl);
+    rtpGroupsock.multicastSendOnly();  // we're a SSM source
+    Groupsock rtcpGroupsock(*env, destinationAddress, rtcpPort, ttl);
+    rtcpGroupsock.multicastSendOnly();  // we're a SSM source
+
+    // Create a 'AMR Audio RTP' sink from the RTP 'groupsock':
+    audioSink = AMRAudioRTPSink::createNew(*env, &rtpGroupsock, 96);
+
+    // Create (and start) a 'RTCP instance' for this RTP sink:
+    const unsigned estimatedSessionBandwidth = 10;  // in kbps; for RTCP b/w share
+    const unsigned maxCNAMElen               = 100;
+    unsigned char  CNAME[maxCNAMElen + 1];
+    gethostname((char *)CNAME, maxCNAMElen);
+    CNAME[maxCNAMElen] = '\0';  // just in case
+    RTCPInstance *rtcp =
+        RTCPInstance::createNew(*env, &rtcpGroupsock, estimatedSessionBandwidth, CNAME, audioSink, NULL /* we're a server */, True /* we're a SSM source */);
+    // Note: This starts RTCP running automatically
+
+    // Create and start a RTSP server to serve this stream.
+    RTSPServer *rtspServer = RTSPServer::createNew(*env, 8554);
+    if(rtspServer == NULL) {
+        *env << "Failed to create RTSP server: " << env->getResultMsg() << "\n";
+        exit(1);
+    }
+    ServerMediaSession *sms = ServerMediaSession::createNew(*env, "testStream", inputFileName, "Session streamed by \"testAMRAudioStreamer\"", True /*SSM*/);
+    sms->addSubsession(PassiveServerMediaSubsession::createNew(*audioSink, rtcp));
+    rtspServer->addServerMediaSession(sms);
+    announceURL(rtspServer, sms);
+
+    // Start the streaming:
+    *env << "Beginning streaming...\n";
+    play();
+
+    env->taskScheduler().doEventLoop();  // does not return
+
+    return 0;  // only to prevent compiler warning
+}
+
+void afterPlaying(void * /*clientData*/) {
+    *env << "...done reading from file\n";
+
+    audioSink->stopPlaying();
+    Medium::close(audioSource);
+    // Note that this also closes the input file that this source read from.
+
+    play();
+}
+
+void play() {
+    // Open the input file as an 'AMR audio file source':
+    AMRAudioFileSource *audioSource = AMRAudioFileSource::createNew(*env, inputFileName);
+    if(audioSource == NULL) {
+        *env << "Unable to open file \"" << inputFileName << "\" as an AMR audio file source: " << env->getResultMsg() << "\n";
+        exit(1);
+    }
+
+    // Finally, start playing:
+    *env << "Beginning to read from file...\n";
+    audioSink->startPlaying(*audioSource, afterPlaying, audioSink);
+}
diff --git a/3rdparty/live555/src/testProgs/testDVVideoStreamer.cpp b/3rdparty/live555/src/testProgs/testDVVideoStreamer.cpp
new file mode 100644
index 00000000..65c8d13e
--- /dev/null
+++ b/3rdparty/live555/src/testProgs/testDVVideoStreamer.cpp
@@ -0,0 +1,120 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// Copyright (c) 1996-2022, Live Networks, Inc.  All rights reserved
+// A test program that reads a DV Video Elementary Stream file,
+// and streams it using RTP
+// main program
+
+#include "liveMedia.hh"
+
+#include "BasicUsageEnvironment.hh"
+#include "announceURL.hh"
+#include "GroupsockHelper.hh"
+
+UsageEnvironment *   env;
+char const *         inputFileName = "test.dv";
+DVVideoStreamFramer *videoSource;
+RTPSink *            videoSink;
+
+void play();  // forward
+
+int main(int argc, char **argv) {
+    // Begin by setting up our usage environment:
+    TaskScheduler *scheduler = BasicTaskScheduler::createNew();
+    env                      = BasicUsageEnvironment::createNew(*scheduler);
+
+    // Create 'groupsocks' for RTP and RTCP:
+    struct sockaddr_storage destinationAddress;
+    destinationAddress.ss_family                               = AF_INET;
+    ((struct sockaddr_in &)destinationAddress).sin_addr.s_addr = chooseRandomIPv4SSMAddress(*env);
+    // Note: This is a multicast address.  If you wish instead to stream
+    // using unicast, then you should use the "testOnDemandRTSPServer"
+    // test program - not this test program - as a model.
+
+    const unsigned short rtpPortNum  = 18888;
+    const unsigned short rtcpPortNum = rtpPortNum + 1;
+    const unsigned char  ttl         = 255;
+
+    const Port rtpPort(rtpPortNum);
+    const Port rtcpPort(rtcpPortNum);
+
+    Groupsock rtpGroupsock(*env, destinationAddress, rtpPort, ttl);
+    rtpGroupsock.multicastSendOnly();  // we're a SSM source
+    Groupsock rtcpGroupsock(*env, destinationAddress, rtcpPort, ttl);
+    rtcpGroupsock.multicastSendOnly();  // we're a SSM source
+
+    // Create a 'DV Video RTP' sink from the RTP 'groupsock':
+    // (But first, make sure that its buffers will be large enough to handle the huge size of DV frames (as big as 288000).)
+    OutPacketBuffer::maxSize = 300000;
+    videoSink                = DVVideoRTPSink::createNew(*env, &rtpGroupsock, 96);
+
+    // Create (and start) a 'RTCP instance' for this RTP sink:
+    const unsigned estimatedSessionBandwidth = 50000;  // in kbps; for RTCP b/w share
+    const unsigned maxCNAMElen               = 100;
+    unsigned char  CNAME[maxCNAMElen + 1];
+    gethostname((char *)CNAME, maxCNAMElen);
+    CNAME[maxCNAMElen] = '\0';  // just in case
+    RTCPInstance *rtcp =
+        RTCPInstance::createNew(*env, &rtcpGroupsock, estimatedSessionBandwidth, CNAME, videoSink, NULL /* we're a server */, True /* we're a SSM source */);
+    // Note: This starts RTCP running automatically
+
+    RTSPServer *rtspServer = RTSPServer::createNew(*env, 8554);
+    if(rtspServer == NULL) {
+        *env << "Failed to create RTSP server: " << env->getResultMsg() << "\n";
+        exit(1);
+    }
+    ServerMediaSession *sms = ServerMediaSession::createNew(*env, "testStream", inputFileName, "Session streamed by \"testDVVideoStreamer\"", True /*SSM*/);
+    sms->addSubsession(PassiveServerMediaSubsession::createNew(*videoSink, rtcp));
+    rtspServer->addServerMediaSession(sms);
+    announceURL(rtspServer, sms);
+
+    // Start the streaming:
+    *env << "Beginning streaming...\n";
+    play();
+
+    env->taskScheduler().doEventLoop();  // does not return
+
+    return 0;  // only to prevent compiler warning
+}
+
+void afterPlaying(void * /*clientData*/) {
+    *env << "...done reading from file\n";
+
+    videoSink->stopPlaying();
+    Medium::close(videoSource);
+    // Note that this also closes the input file that this source read from.
+
+    // Start playing once again:
+    play();
+}
+
+void play() {
+    // Open the input file as a 'byte-stream file source':
+    ByteStreamFileSource *fileSource = ByteStreamFileSource::createNew(*env, inputFileName);
+    if(fileSource == NULL) {
+        *env << "Unable to open file \"" << inputFileName << "\" as a byte-stream file source\n";
+        exit(1);
+    }
+
+    FramedSource *videoES = fileSource;
+
+    // Create a framer for the Video Elementary Stream:
+    videoSource = DVVideoStreamFramer::createNew(*env, videoES);
+
+    // Finally, start playing:
+    *env << "Beginning to read from file...\n";
+    videoSink->startPlaying(*videoSource, afterPlaying, videoSink);
+}
diff --git a/3rdparty/live555/src/testProgs/testGSMStreamer.cpp b/3rdparty/live555/src/testProgs/testGSMStreamer.cpp
new file mode 100644
index 00000000..da8c8a8a
--- /dev/null
+++ b/3rdparty/live555/src/testProgs/testGSMStreamer.cpp
@@ -0,0 +1,172 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// Copyright (c) 1996-2022, Live Networks, Inc.  All rights reserved
+// A test program that streams GSM audio via RTP/RTCP
+// main program
+
+// NOTE: This program assumes the existence of a (currently nonexistent)
+// function called "createNewGSMAudioSource()".
+
+#include "liveMedia.hh"
+
+#include "BasicUsageEnvironment.hh"
+#include "announceURL.hh"
+#include "GroupsockHelper.hh"
+
+////////// Main program //////////
+
+// To stream using "source-specific multicast" (SSM), uncomment the following:
+//#define USE_SSM 1
+
+// To stream using IPv6 multicast, rather than IPv4 multicast, uncomment the following:
+//#define USE_IPV6_MULTICAST 1
+
+// To set up an internal RTSP server, uncomment the following:
+//#define IMPLEMENT_RTSP_SERVER 1
+// (Note that this RTSP server works for multicast only)
+
+#ifdef USE_SSM
+Boolean const isSSM = True;
+#else
+Boolean const isSSM = False;
+#endif
+
+#ifdef IMPLEMENT_RTSP_SERVER
+RTSPServer *rtspServer;
+#endif
+
+UsageEnvironment *env;
+
+void afterPlaying(void *clientData);  // forward
+
+// A structure to hold the state of the current session.
+// It is used in the "afterPlaying()" function to clean up the session.
+struct sessionState_t {
+    FramedSource *source;
+    RTPSink *     sink;
+    RTCPInstance *rtcpInstance;
+    Groupsock *   rtpGroupsock;
+    Groupsock *   rtcpGroupsock;
+} sessionState;
+
+void play();  // forward
+
+int main(int argc, char **argv) {
+    // Begin by setting up our usage environment:
+    TaskScheduler *scheduler = BasicTaskScheduler::createNew();
+    env                      = BasicUsageEnvironment::createNew(*scheduler);
+
+    // Create 'groupsocks' for RTP and RTCP:
+    char const *destinationAddressStr
+#ifdef USE_IPV6_MULTICAST
+#ifdef USE_SSM
+        = "FF3E::FFFF:2A2A";
+#else
+        = "FF1E::FFFF:2A2A";
+#endif
+#else
+#ifdef USE_SSM
+        = "232.255.42.42";
+#else
+        = "239.255.42.42";
+#endif
+#endif
+    // Note: This is a multicast address.  If you wish to stream using
+    // unicast instead, then replace this string with the unicast address
+    // of the (single) destination.  (You may also need to make a similar
+    // change to the receiver program.)
+
+    const unsigned short rtpPortNum  = 6666;
+    const unsigned short rtcpPortNum = rtpPortNum + 1;
+    const unsigned char  ttl         = 1;  // low, in case routers don't admin scope
+
+    NetAddressList          destinationAddresses(destinationAddressStr);
+    struct sockaddr_storage destinationAddress;
+    copyAddress(destinationAddress, destinationAddresses.firstAddress());
+
+    const Port rtpPort(rtpPortNum);
+    const Port rtcpPort(rtcpPortNum);
+
+    sessionState.rtpGroupsock  = new Groupsock(*env, destinationAddress, rtpPort, ttl);
+    sessionState.rtcpGroupsock = new Groupsock(*env, destinationAddress, rtcpPort, ttl);
+#ifdef USE_SSM
+    sessionState.rtpGroupsock->multicastSendOnly();
+    sessionState.rtcpGroupsock->multicastSendOnly();
+#endif
+
+    // Create a 'GSM RTP' sink from the RTP 'groupsock':
+    sessionState.sink = GSMAudioRTPSink::createNew(*env, sessionState.rtpGroupsock);
+
+    // Create (and start) a 'RTCP instance' for this RTP sink:
+    const unsigned estimatedSessionBandwidth = 160;  // in kbps; for RTCP b/w share
+    const unsigned maxCNAMElen               = 100;
+    unsigned char  CNAME[maxCNAMElen + 1];
+    gethostname((char *)CNAME, maxCNAMElen);
+    CNAME[maxCNAMElen] = '\0';  // just in case
+    sessionState.rtcpInstance =
+        RTCPInstance::createNew(*env, sessionState.rtcpGroupsock, estimatedSessionBandwidth, CNAME, sessionState.sink, NULL /* we're a server */, isSSM);
+    // Note: This starts RTCP running automatically
+
+#ifdef IMPLEMENT_RTSP_SERVER
+    rtspServer = RTSPServer::createNew(*env, 8554);
+    if(rtspServer == NULL) {
+        *env << "Failed to create RTSP server: " << env->getResultMsg() << "%s\n";
+        exit(1);
+    }
+    ServerMediaSession *sms = ServerMediaSession::createNew(*env, "testStream", "GSM input", "Session streamed by \"testGSMStreamer\"", isSSM);
+    sms->addSubsession(PassiveServerMediaSubsession::createNew(*sessionState.sink, sessionState.rtcpInstance));
+    rtspServer->addServerMediaSession(sms);
+    announceURL(rtspServer, sms);
+#endif
+
+    play();
+
+    env->taskScheduler().doEventLoop();  // does not return
+    return 0;                            // only to prevent compiler warning
+}
+
+void play() {
+    // Open the input source:
+    extern FramedSource *createNewGSMAudioSource(UsageEnvironment &);
+    sessionState.source = createNewGSMAudioSource(*env);
+    if(sessionState.source == NULL) {
+        *env << "Failed to create GSM source\n";
+        exit(1);
+    }
+
+    // Finally, start the streaming:
+    *env << "Beginning streaming...\n";
+    sessionState.sink->startPlaying(*sessionState.source, afterPlaying, NULL);
+}
+
+void afterPlaying(void * /*clientData*/) {
+    *env << "...done streaming\n";
+
+    sessionState.sink->stopPlaying();
+
+    // End this loop by closing the media:
+#ifdef IMPLEMENT_RTSP_SERVER
+    Medium::close(rtspServer);
+#endif
+    Medium::close(sessionState.rtcpInstance);
+    Medium::close(sessionState.sink);
+    delete sessionState.rtpGroupsock;
+    Medium::close(sessionState.source);
+    delete sessionState.rtcpGroupsock;
+
+    // And start another loop:
+    play();
+}
diff --git a/3rdparty/live555/src/testProgs/testH264VideoStreamer.cpp b/3rdparty/live555/src/testProgs/testH264VideoStreamer.cpp
new file mode 100644
index 00000000..f704c1c1
--- /dev/null
+++ b/3rdparty/live555/src/testProgs/testH264VideoStreamer.cpp
@@ -0,0 +1,124 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+**********/
+// Copyright (c) 1996-2022, Live Networks, Inc.  All rights reserved
+// A test program that reads a H.264 Elementary Stream video file
+// and streams it using RTP
+// main program
+//
+// NOTE: For this application to work, the H.264 Elementary Stream video file *must* contain SPS and PPS NAL units,
+// ideally at or near the start of the file.  These SPS and PPS NAL units are used to specify 'configuration' information
+// that is set in the output stream's SDP description (by the RTSP server that is built in to this application).
+// Note also that - unlike some other "*Streamer" demo applications - the resulting stream can be received only using a
+// RTSP client (such as "openRTSP")
+
+#include <liveMedia.hh>
+
+#include <BasicUsageEnvironment.hh>
+#include "announceURL.hh"
+#include <GroupsockHelper.hh>
+
+UsageEnvironment *     env;
+char const *           inputFileName = "test.264";
+H264VideoStreamFramer *videoSource;
+RTPSink *              videoSink;
+
+void play();  // forward
+
+int main(int argc, char **argv) {
+    // Begin by setting up our usage environment:
+    TaskScheduler *scheduler = BasicTaskScheduler::createNew();
+    env                      = BasicUsageEnvironment::createNew(*scheduler);
+
+    // Create 'groupsocks' for RTP and RTCP:
+    struct sockaddr_storage destinationAddress;
+    destinationAddress.ss_family                               = AF_INET;
+    ((struct sockaddr_in &)destinationAddress).sin_addr.s_addr = chooseRandomIPv4SSMAddress(*env);
+    // Note: This is a multicast address.  If you wish instead to stream
+    // using unicast, then you should use the "testOnDemandRTSPServer"
+    // test program - not this test program - as a model.
+
+    const unsigned short rtpPortNum  = 18888;
+    const unsigned short rtcpPortNum = rtpPortNum + 1;
+    const unsigned char  ttl         = 255;
+
+    const Port rtpPort(rtpPortNum);
+    const Port rtcpPort(rtcpPortNum);
+
+    Groupsock rtpGroupsock(*env, destinationAddress, rtpPort, ttl);
+    rtpGroupsock.multicastSendOnly();  // we're a SSM source
+    Groupsock rtcpGroupsock(*env, destinationAddress, rtcpPort, ttl);
+    rtcpGroupsock.multicastSendOnly();  // we're a SSM source
+
+    // Create a 'H264 Video RTP' sink from the RTP 'groupsock':
+    OutPacketBuffer::maxSize = 100000;
+    videoSink                = H264VideoRTPSink::createNew(*env, &rtpGroupsock, 96);
+
+    // Create (and start) a 'RTCP instance' for this RTP sink:
+    const unsigned estimatedSessionBandwidth = 500;  // in kbps; for RTCP b/w share
+    const unsigned maxCNAMElen               = 100;
+    unsigned char  CNAME[maxCNAMElen + 1];
+    gethostname((char *)CNAME, maxCNAMElen);
+    CNAME[maxCNAMElen] = '\0';  // just in case
+    RTCPInstance *rtcp =
+        RTCPInstance::createNew(*env, &rtcpGroupsock, estimatedSessionBandwidth, CNAME, videoSink, NULL /* we're a server */, True /* we're a SSM source */);
+    // Note: This starts RTCP running automatically
+
+    RTSPServer *rtspServer = RTSPServer::createNew(*env, 8554);
+    if(rtspServer == NULL) {
+        *env << "Failed to create RTSP server: " << env->getResultMsg() << "\n";
+        exit(1);
+    }
+    ServerMediaSession *sms = ServerMediaSession::createNew(*env, "testStream", inputFileName, "Session streamed by \"testH264VideoStreamer\"", True /*SSM*/);
+    sms->addSubsession(PassiveServerMediaSubsession::createNew(*videoSink, rtcp));
+    rtspServer->addServerMediaSession(sms);
+    announceURL(rtspServer, sms);
+
+    // Start the streaming:
+    *env << "Beginning streaming...\n";
+    play();
+
+    env->taskScheduler().doEventLoop();  // does not return
+
+    return 0;  // only to prevent compiler warning
+}
+
+void afterPlaying(void * /*clientData*/) {
+    *env << "...done reading from file\n";
+    videoSink->stopPlaying();
+    Medium::close(videoSource);
+    // Note that this also closes the input file that this source read from.
+
+    // Start playing once again:
+    play();
+}
+
+void play() {
+    // Open the input file as a 'byte-stream file source':
+    ByteStreamFileSource *fileSource = ByteStreamFileSource::createNew(*env, inputFileName);
+    if(fileSource == NULL) {
+        *env << "Unable to open file \"" << inputFileName << "\" as a byte-stream file source\n";
+        exit(1);
+    }
+
+    FramedSource *videoES = fileSource;
+
+    // Create a framer for the Video Elementary Stream:
+    videoSource = H264VideoStreamFramer::createNew(*env, videoES);
+
+    // Finally, start playing:
+    *env << "Beginning to read from file...\n";
+    videoSink->startPlaying(*videoSource, afterPlaying, videoSink);
+}
diff --git a/3rdparty/live555/src/testProgs/testH264VideoToHLSSegments.cpp b/3rdparty/live555/src/testProgs/testH264VideoToHLSSegments.cpp
new file mode 100644
index 00000000..734179f3
--- /dev/null
+++ b/3rdparty/live555/src/testProgs/testH264VideoToHLSSegments.cpp
@@ -0,0 +1,98 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// Copyright (c) 1996-2022, Live Networks, Inc.  All rights reserved
+// A program that converts a H.264 (Elementary Stream) video file into sequence of
+// HLS (HTTP Live Streaming) segments, plus a ".m3u8" file that can be accessed via a web browser.
+// main program
+
+#include "liveMedia.hh"
+#include "BasicUsageEnvironment.hh"
+
+#define OUR_HLS_SEGMENTATION_DURATION 6
+#define OUR_HLS_FILENAME_PREFIX "hlsTest"
+char const *inputFileName = "in.264";
+FILE *      ourM3U8Fid    = NULL;
+
+void segmentationCallback(void *clientData, char const *segmentFileName, double segmentDuration);  // forward
+void afterPlaying(void *clientData);                                                               // forward
+
+UsageEnvironment *env;
+
+int main(int argc, char **argv) {
+    // Begin by setting up our usage environment:
+    TaskScheduler *scheduler = BasicTaskScheduler::createNew();
+    env                      = BasicUsageEnvironment::createNew(*scheduler);
+
+    // Open the input file as a 'byte-stream file source':
+    FramedSource *inputSource = ByteStreamFileSource::createNew(*env, inputFileName);
+    if(inputSource == NULL) {
+        *env << "Unable to open file \"" << inputFileName << "\" as a byte-stream file source\n";
+        exit(1);
+    }
+
+    // Create a 'framer' filter for this file source, to generate presentation times for each NAL unit:
+    H264VideoStreamFramer *framer = H264VideoStreamFramer::createNew(*env, inputSource, True /*includeStartCodeInOutput*/, True /*insertAccessUnitDelimiters*/);
+
+    // Then create a filter that packs the H.264 video data into a Transport Stream:
+    MPEG2TransportStreamFromESSource *tsFrames = MPEG2TransportStreamFromESSource::createNew(*env);
+    tsFrames->addNewVideoSource(framer, 5 /*mpegVersion: H.264*/);
+
+    // Create a 'HLS Segmenter' as the media sink:
+    MediaSink *outputSink = HLSSegmenter::createNew(*env, OUR_HLS_SEGMENTATION_DURATION, OUR_HLS_FILENAME_PREFIX, segmentationCallback);
+
+    // Finally, start playing:
+    *env << "Beginning to read...\n";
+    outputSink->startPlaying(*tsFrames, afterPlaying, NULL);
+
+    env->taskScheduler().doEventLoop();  // does not return
+
+    return 0;  // only to prevent compiler warning
+}
+
+void segmentationCallback(void * /*clientData*/, char const *segmentFileName, double segmentDuration) {
+    if(ourM3U8Fid == NULL) {
+        // Open our ".m3u8" file for output, and write the prefix:
+        char *ourM3U8FileName = new char[strlen(OUR_HLS_FILENAME_PREFIX) + 5 /*strlen(".m3u8")*/ + 1];
+        sprintf(ourM3U8FileName, "%s.m3u8", OUR_HLS_FILENAME_PREFIX);
+        ourM3U8Fid = fopen(ourM3U8FileName, "wb");
+
+        fprintf(ourM3U8Fid,
+                "#EXTM3U\n"
+                "#EXT-X-VERSION:3\n"
+                "#EXT-X-INDEPENDENT-SEGMENTS\n"
+                "#EXT-X-TARGETDURATION:%u\n"
+                "#EXT-X-MEDIA-SEQUENCE:0\n",
+                OUR_HLS_SEGMENTATION_DURATION);
+    }
+
+    // Update our ".m3u8" file with information about this most recent segment:
+    fprintf(ourM3U8Fid,
+            "#EXTINF:%f,\n"
+            "%s\n",
+            segmentDuration, segmentFileName);
+
+    fprintf(stderr, "Wrote segment \"%s\" (duration: %f seconds)\n", segmentFileName, segmentDuration);
+}
+
+void afterPlaying(void * /*clientData*/) {
+    *env << "...Done reading\n";
+
+    // Complete and close our ".m3u8" file:
+    fprintf(ourM3U8Fid, "#EXT-X-ENDLIST\n");
+
+    fprintf(stderr, "Wrote %s.m3u8\n", OUR_HLS_FILENAME_PREFIX);
+    exit(0);
+}
diff --git a/3rdparty/live555/src/testProgs/testH264VideoToTransportStream.cpp b/3rdparty/live555/src/testProgs/testH264VideoToTransportStream.cpp
new file mode 100644
index 00000000..6aa2264f
--- /dev/null
+++ b/3rdparty/live555/src/testProgs/testH264VideoToTransportStream.cpp
@@ -0,0 +1,69 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// Copyright (c) 1996-2022, Live Networks, Inc.  All rights reserved
+// A program that converts a H.264 (Elementary Stream) video file into a Transport Stream file.
+// main program
+
+#include "liveMedia.hh"
+#include "BasicUsageEnvironment.hh"
+
+char const *inputFileName  = "in.264";
+char const *outputFileName = "out.ts";
+
+void afterPlaying(void *clientData);  // forward
+
+UsageEnvironment *env;
+
+int main(int argc, char **argv) {
+    // Begin by setting up our usage environment:
+    TaskScheduler *scheduler = BasicTaskScheduler::createNew();
+    env                      = BasicUsageEnvironment::createNew(*scheduler);
+
+    // Open the input file as a 'byte-stream file source':
+    FramedSource *inputSource = ByteStreamFileSource::createNew(*env, inputFileName);
+    if(inputSource == NULL) {
+        *env << "Unable to open file \"" << inputFileName << "\" as a byte-stream file source\n";
+        exit(1);
+    }
+
+    // Create a 'framer' filter for this file source, to generate presentation times for each NAL unit:
+    H264VideoStreamFramer *framer = H264VideoStreamFramer::createNew(*env, inputSource, True /*includeStartCodeInOutput*/);
+
+    // Then create a filter that packs the H.264 video data into a Transport Stream:
+    MPEG2TransportStreamFromESSource *tsFrames = MPEG2TransportStreamFromESSource::createNew(*env);
+    tsFrames->addNewVideoSource(framer, 5 /*mpegVersion: H.264*/);
+
+    // Open the output file as a 'file sink':
+    MediaSink *outputSink = FileSink::createNew(*env, outputFileName);
+    if(outputSink == NULL) {
+        *env << "Unable to open file \"" << outputFileName << "\" as a file sink\n";
+        exit(1);
+    }
+
+    // Finally, start playing:
+    *env << "Beginning to read...\n";
+    outputSink->startPlaying(*tsFrames, afterPlaying, NULL);
+
+    env->taskScheduler().doEventLoop();  // does not return
+
+    return 0;  // only to prevent compiler warning
+}
+
+void afterPlaying(void * /*clientData*/) {
+    *env << "Done reading.\n";
+    *env << "Wrote output file: \"" << outputFileName << "\"\n";
+    exit(0);
+}
diff --git a/3rdparty/live555/src/testProgs/testH265VideoStreamer.cpp b/3rdparty/live555/src/testProgs/testH265VideoStreamer.cpp
new file mode 100644
index 00000000..f522dd4f
--- /dev/null
+++ b/3rdparty/live555/src/testProgs/testH265VideoStreamer.cpp
@@ -0,0 +1,125 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+**********/
+// Copyright (c) 1996-2022, Live Networks, Inc.  All rights reserved
+// A test program that reads a H.265 Elementary Stream video file
+// and streams it using RTP
+// main program
+//
+// NOTE: For this application to work, the H.265 Elementary Stream video file *must* contain
+// VPS, SPS and PPS NAL units, ideally at or near the start of the file.
+// These VPS, SPS and PPS NAL units are used to specify 'configuration' information that is set in
+// the output stream's SDP description (by the RTSP server that is built in to this application).
+// Note also that - unlike some other "*Streamer" demo applications - the resulting stream can be
+// received only using a RTSP client (such as "openRTSP")
+
+#include <liveMedia.hh>
+
+#include <BasicUsageEnvironment.hh>
+#include "announceURL.hh"
+#include <GroupsockHelper.hh>
+
+UsageEnvironment *     env;
+char const *           inputFileName = "test.265";
+H265VideoStreamFramer *videoSource;
+RTPSink *              videoSink;
+
+void play();  // forward
+
+int main(int argc, char **argv) {
+    // Begin by setting up our usage environment:
+    TaskScheduler *scheduler = BasicTaskScheduler::createNew();
+    env                      = BasicUsageEnvironment::createNew(*scheduler);
+
+    // Create 'groupsocks' for RTP and RTCP:
+    struct sockaddr_storage destinationAddress;
+    destinationAddress.ss_family                               = AF_INET;
+    ((struct sockaddr_in &)destinationAddress).sin_addr.s_addr = chooseRandomIPv4SSMAddress(*env);
+    // Note: This is a multicast address.  If you wish instead to stream
+    // using unicast, then you should use the "testOnDemandRTSPServer"
+    // test program - not this test program - as a model.
+
+    const unsigned short rtpPortNum  = 18888;
+    const unsigned short rtcpPortNum = rtpPortNum + 1;
+    const unsigned char  ttl         = 255;
+
+    const Port rtpPort(rtpPortNum);
+    const Port rtcpPort(rtcpPortNum);
+
+    Groupsock rtpGroupsock(*env, destinationAddress, rtpPort, ttl);
+    rtpGroupsock.multicastSendOnly();  // we're a SSM source
+    Groupsock rtcpGroupsock(*env, destinationAddress, rtcpPort, ttl);
+    rtcpGroupsock.multicastSendOnly();  // we're a SSM source
+
+    // Create a 'H265 Video RTP' sink from the RTP 'groupsock':
+    OutPacketBuffer::maxSize = 100000;
+    videoSink                = H265VideoRTPSink::createNew(*env, &rtpGroupsock, 96);
+
+    // Create (and start) a 'RTCP instance' for this RTP sink:
+    const unsigned estimatedSessionBandwidth = 500;  // in kbps; for RTCP b/w share
+    const unsigned maxCNAMElen               = 100;
+    unsigned char  CNAME[maxCNAMElen + 1];
+    gethostname((char *)CNAME, maxCNAMElen);
+    CNAME[maxCNAMElen] = '\0';  // just in case
+    RTCPInstance *rtcp =
+        RTCPInstance::createNew(*env, &rtcpGroupsock, estimatedSessionBandwidth, CNAME, videoSink, NULL /* we're a server */, True /* we're a SSM source */);
+    // Note: This starts RTCP running automatically
+
+    RTSPServer *rtspServer = RTSPServer::createNew(*env, 8554);
+    if(rtspServer == NULL) {
+        *env << "Failed to create RTSP server: " << env->getResultMsg() << "\n";
+        exit(1);
+    }
+    ServerMediaSession *sms = ServerMediaSession::createNew(*env, "testStream", inputFileName, "Session streamed by \"testH265VideoStreamer\"", True /*SSM*/);
+    sms->addSubsession(PassiveServerMediaSubsession::createNew(*videoSink, rtcp));
+    rtspServer->addServerMediaSession(sms);
+    announceURL(rtspServer, sms);
+
+    // Start the streaming:
+    *env << "Beginning streaming...\n";
+    play();
+
+    env->taskScheduler().doEventLoop();  // does not return
+
+    return 0;  // only to prevent compiler warning
+}
+
+void afterPlaying(void * /*clientData*/) {
+    *env << "...done reading from file\n";
+    videoSink->stopPlaying();
+    Medium::close(videoSource);
+    // Note that this also closes the input file that this source read from.
+
+    // Start playing once again:
+    play();
+}
+
+void play() {
+    // Open the input file as a 'byte-stream file source':
+    ByteStreamFileSource *fileSource = ByteStreamFileSource::createNew(*env, inputFileName);
+    if(fileSource == NULL) {
+        *env << "Unable to open file \"" << inputFileName << "\" as a byte-stream file source\n";
+        exit(1);
+    }
+
+    FramedSource *videoES = fileSource;
+
+    // Create a framer for the Video Elementary Stream:
+    videoSource = H265VideoStreamFramer::createNew(*env, videoES);
+
+    // Finally, start playing:
+    *env << "Beginning to read from file...\n";
+    videoSink->startPlaying(*videoSource, afterPlaying, videoSink);
+}
diff --git a/3rdparty/live555/src/testProgs/testH265VideoToTransportStream.cpp b/3rdparty/live555/src/testProgs/testH265VideoToTransportStream.cpp
new file mode 100644
index 00000000..598607a2
--- /dev/null
+++ b/3rdparty/live555/src/testProgs/testH265VideoToTransportStream.cpp
@@ -0,0 +1,69 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// Copyright (c) 1996-2022, Live Networks, Inc.  All rights reserved
+// A program that converts a H.265 (Elementary Stream) video file into a Transport Stream file.
+// main program
+
+#include "liveMedia.hh"
+#include "BasicUsageEnvironment.hh"
+
+char const *inputFileName  = "in.265";
+char const *outputFileName = "out.ts";
+
+void afterPlaying(void *clientData);  // forward
+
+UsageEnvironment *env;
+
+int main(int argc, char **argv) {
+    // Begin by setting up our usage environment:
+    TaskScheduler *scheduler = BasicTaskScheduler::createNew();
+    env                      = BasicUsageEnvironment::createNew(*scheduler);
+
+    // Open the input file as a 'byte-stream file source':
+    FramedSource *inputSource = ByteStreamFileSource::createNew(*env, inputFileName);
+    if(inputSource == NULL) {
+        *env << "Unable to open file \"" << inputFileName << "\" as a byte-stream file source\n";
+        exit(1);
+    }
+
+    // Create a 'framer' filter for this file source, to generate presentation times for each NAL unit:
+    H265VideoStreamFramer *framer = H265VideoStreamFramer::createNew(*env, inputSource, True /*includeStartCodeInOutput*/);
+
+    // Then create a filter that packs the H.265 video data into a Transport Stream:
+    MPEG2TransportStreamFromESSource *tsFrames = MPEG2TransportStreamFromESSource::createNew(*env);
+    tsFrames->addNewVideoSource(framer, 6 /*mpegVersion: H.265*/);
+
+    // Open the output file as a 'file sink':
+    MediaSink *outputSink = FileSink::createNew(*env, outputFileName);
+    if(outputSink == NULL) {
+        *env << "Unable to open file \"" << outputFileName << "\" as a file sink\n";
+        exit(1);
+    }
+
+    // Finally, start playing:
+    *env << "Beginning to read...\n";
+    outputSink->startPlaying(*tsFrames, afterPlaying, NULL);
+
+    env->taskScheduler().doEventLoop();  // does not return
+
+    return 0;  // only to prevent compiler warning
+}
+
+void afterPlaying(void * /*clientData*/) {
+    *env << "Done reading.\n";
+    *env << "Wrote output file: \"" << outputFileName << "\"\n";
+    exit(0);
+}
diff --git a/3rdparty/live555/src/testProgs/testMKVSplitter.cpp b/3rdparty/live555/src/testProgs/testMKVSplitter.cpp
new file mode 100644
index 00000000..768857bc
--- /dev/null
+++ b/3rdparty/live555/src/testProgs/testMKVSplitter.cpp
@@ -0,0 +1,141 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+**********/
+// Copyright (c) 1996-2022, Live Networks, Inc.  All rights reserved
+// A test program that reads a ".mkv" (i.e., Matroska) file, demultiplexes each track
+// (video, audio, subtitles), and outputs each track to a file.
+// main program
+
+#include <liveMedia.hh>
+#include <BasicUsageEnvironment.hh>
+
+UsageEnvironment *env;
+char const *      programName;
+char const *      inputFileName;
+
+// An array of structures representing the state of the video, audio, and subtitle tracks:
+static struct {
+    unsigned      trackNumber;
+    FramedSource *source;
+    FileSink *    sink;
+} trackState[3];
+
+void onMatroskaFileCreation(MatroskaFile *newFile, void *clientData);  // forward
+
+void usage() {
+    *env << "usage: " << programName << " <input-Matroska-or-WebM-file-name>\n";
+    exit(1);
+}
+
+int main(int argc, char **argv) {
+    // Begin by setting up our usage environment:
+    TaskScheduler *scheduler = BasicTaskScheduler::createNew();
+    env                      = BasicUsageEnvironment::createNew(*scheduler);
+
+    // Parse the command line:
+    programName = argv[0];
+    if(argc != 2)
+        usage();
+    inputFileName = argv[1];
+
+    // Arrange to create a "MatroskaFile" object for the specified file.
+    // (Note that this object is not created immediately, but instead via a callback.)
+    MatroskaFile::createNew(*env, inputFileName, onMatroskaFileCreation, NULL);
+
+    env->taskScheduler().doEventLoop();  // does not return
+
+    return 0;  // only to prevent compiler warning
+}
+
+void play();  // forward
+
+void onMatroskaFileCreation(MatroskaFile *matroskaFile, void * /*clientData*/) {
+    // Create a new demultiplexor for the file:
+    MatroskaDemux *matroskaDemux = matroskaFile->newDemux();
+
+    // Create source streams and file sinks for each preferred track;
+
+    unsigned numActiveTracks = 0;
+    for(unsigned i = 0; i < 3; ++i) {
+        unsigned trackNumber;
+        trackState[i].source      = matroskaDemux->newDemuxedTrack(trackNumber);
+        trackState[i].trackNumber = trackNumber;
+        trackState[i].sink        = NULL;  // by default; may get changed below
+
+        if(trackState[i].source == NULL)
+            continue;
+
+        char const *mimeType = matroskaFile->trackMIMEType(trackNumber);
+        if(mimeType == NULL || mimeType[0] == '\0')
+            continue;
+
+        // Create the file name from "mimeType" by replacing "/" with "-", and adding the
+        // track number at the end:
+        char *fileName = new char[strlen(mimeType) + 100 /*more than enough space*/];
+        sprintf(fileName, "%s-%d", mimeType, trackNumber);
+        for(unsigned j = 0; fileName[j] != '\0'; ++j) {
+            if(fileName[j] == '/') {
+                fileName[j] = '-';
+                break;
+            }
+        }
+
+        trackState[i].sink = matroskaFile->createFileSinkForTrackNumber(trackNumber, fileName);
+        if(trackState[i].sink != NULL) {
+            ++numActiveTracks;
+            fprintf(stderr, "Created output file \"%s\" for track %d\n", fileName, trackNumber);
+        }
+    }
+
+    if(numActiveTracks == 0) {
+        *env << "Error: The Matroska file \"" << inputFileName << "\" has no streamable tracks\n";
+        *env << "(Perhaps the file does not exist, or is not a 'Matroska' file.)\n";
+        exit(1);
+    }
+
+    // Start the streaming:
+    play();
+}
+
+void afterPlaying(void * /*clientData*/) {
+    *env << "...done reading from file\n";
+
+    // Stop playing all sinks, then close the source streams
+    // (which will also close the demultiplexor itself):
+    unsigned i;
+    for(i = 0; i < 3; ++i) {
+        if(trackState[i].sink != NULL)
+            trackState[i].sink->stopPlaying();
+        Medium::close(trackState[i].source);
+        trackState[i].source = NULL;
+    }
+
+    // Finally, close the sinks:
+    for(i = 0; i < 3; ++i)
+        Medium::close(trackState[i].sink);
+
+    exit(0);
+}
+
+void play() {
+    *env << "Beginning to read from file...\n";
+
+    // Start playing each track's RTP sink from its corresponding source:
+    for(unsigned i = 0; i < 3; ++i) {
+        if(trackState[i].sink != NULL && trackState[i].source != NULL) {
+            trackState[i].sink->startPlaying(*trackState[i].source, afterPlaying, NULL);
+        }
+    }
+}
diff --git a/3rdparty/live555/src/testProgs/testMKVStreamer.cpp b/3rdparty/live555/src/testProgs/testMKVStreamer.cpp
new file mode 100644
index 00000000..4f45954b
--- /dev/null
+++ b/3rdparty/live555/src/testProgs/testMKVStreamer.cpp
@@ -0,0 +1,171 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+**********/
+// Copyright (c) 1996-2022, Live Networks, Inc.  All rights reserved
+// A test program that reads a ".mkv" (i.e., Matroska) file, demultiplexes each track
+// (video, audio, subtitles), and streams each track using RTP multicast.
+// main program
+
+#include <liveMedia.hh>
+
+#include <BasicUsageEnvironment.hh>
+#include "announceURL.hh"
+#include <GroupsockHelper.hh>
+
+UsageEnvironment *      env;
+char const *            inputFileName = "test.mkv";
+struct sockaddr_storage destinationAddress;
+RTSPServer *            rtspServer;
+ServerMediaSession *    sms;
+MatroskaFile *          matroskaFile;
+MatroskaDemux *         matroskaDemux;
+
+// An array of structures representing the state of the video, audio, and subtitle tracks:
+static struct {
+    unsigned      trackNumber;
+    FramedSource *source;
+    RTPSink *     sink;
+    RTCPInstance *rtcp;
+} trackState[3];
+
+void onMatroskaFileCreation(MatroskaFile *newFile, void *clientData);  // forward
+
+int main(int argc, char **argv) {
+    // Begin by setting up our usage environment:
+    TaskScheduler *scheduler = BasicTaskScheduler::createNew();
+    env                      = BasicUsageEnvironment::createNew(*scheduler);
+
+    // Define our destination (multicast) IP address:
+    destinationAddress.ss_family                               = AF_INET;
+    ((struct sockaddr_in &)destinationAddress).sin_addr.s_addr = chooseRandomIPv4SSMAddress(*env);
+    // Note: This is a multicast address.  If you wish instead to stream
+    // using unicast, then you should use the "testOnDemandRTSPServer"
+    // test program - not this test program - as a model.
+
+    // Create our RTSP server.  (Receivers will need to use RTSP to access the stream.)
+    rtspServer = RTSPServer::createNew(*env, 8554);
+    if(rtspServer == NULL) {
+        *env << "Failed to create RTSP server: " << env->getResultMsg() << "\n";
+        exit(1);
+    }
+    sms = ServerMediaSession::createNew(*env, "testStream", inputFileName, "Session streamed by \"testMKVStreamer\"", True /*SSM*/);
+
+    // Arrange to create a "MatroskaFile" object for the specified file.
+    // (Note that this object is not created immediately, but instead via a callback.)
+    MatroskaFile::createNew(*env, inputFileName, onMatroskaFileCreation, NULL);
+
+    env->taskScheduler().doEventLoop();  // does not return
+
+    return 0;  // only to prevent compiler warning
+}
+
+void play();  // forward
+
+void onMatroskaFileCreation(MatroskaFile *newFile, void * /*clientData*/) {
+    matroskaFile = newFile;
+
+    // Create a new demultiplexor for the file:
+    matroskaDemux = matroskaFile->newDemux();
+
+    // Create source streams, "RTPSink"s, and "RTCPInstance"s for each preferred track;
+    unsigned short      rtpPortNum = 44444;
+    const unsigned char ttl        = 255;
+
+    const unsigned maxCNAMElen = 100;
+    unsigned char  CNAME[maxCNAMElen + 1];
+    gethostname((char *)CNAME, maxCNAMElen);
+    CNAME[maxCNAMElen] = '\0';  // just in case
+
+    for(unsigned i = 0; i < 3; ++i) {
+        unsigned      trackNumber;
+        FramedSource *baseSource  = matroskaDemux->newDemuxedTrack(trackNumber);
+        trackState[i].trackNumber = trackNumber;
+
+        unsigned estBitrate, numFiltersInFrontOfTrack;
+        trackState[i].source = matroskaFile->createSourceForStreaming(baseSource, trackNumber, estBitrate, numFiltersInFrontOfTrack);
+        trackState[i].sink   = NULL;  // by default; may get changed below
+        trackState[i].rtcp   = NULL;  // ditto
+
+        if(trackState[i].source != NULL) {
+            Groupsock *rtpGroupsock  = new Groupsock(*env, destinationAddress, rtpPortNum, ttl);
+            Groupsock *rtcpGroupsock = new Groupsock(*env, destinationAddress, rtpPortNum + 1, ttl);
+            rtpPortNum += 2;
+
+            trackState[i].sink = matroskaFile->createRTPSinkForTrackNumber(trackNumber, rtpGroupsock, 96 + i);
+            if(trackState[i].sink != NULL) {
+                if(trackState[i].sink->estimatedBitrate() > 0) {
+                    estBitrate = trackState[i].sink->estimatedBitrate();  // hack
+                }
+                trackState[i].rtcp = RTCPInstance::createNew(*env, rtcpGroupsock, estBitrate, CNAME, trackState[i].sink, NULL /* we're a server */,
+                                                             True /* we're a SSM source */);
+                // Note: This starts RTCP running automatically
+
+                // Having set up a track for streaming, add it to our RTSP server's "ServerMediaSession":
+                sms->addSubsession(PassiveServerMediaSubsession::createNew(*trackState[i].sink, trackState[i].rtcp));
+            }
+        }
+    }
+
+    if(sms->numSubsessions() == 0) {
+        *env << "Error: The Matroska file \"" << inputFileName << "\" has no streamable tracks\n";
+        *env << "(Perhaps the file does not exist, or is not a 'Matroska' file.)\n";
+        exit(1);
+    }
+
+    rtspServer->addServerMediaSession(sms);
+    announceURL(rtspServer, sms);
+
+    // Start the streaming:
+    play();
+}
+
+void afterPlaying(void * /*clientData*/) {
+    *env << "...done reading from file\n";
+
+    // Stop playing all "RTPSink"s, then close the source streams
+    // (which will also close the demultiplexor itself):
+    unsigned i;
+    for(i = 0; i < 3; ++i) {
+        if(trackState[i].sink != NULL)
+            trackState[i].sink->stopPlaying();
+        Medium::close(trackState[i].source);
+        trackState[i].source = NULL;
+    }
+
+    // Create a new demultiplexor from our Matroska file, then new data sources for each track:
+    matroskaDemux = matroskaFile->newDemux();
+    for(i = 0; i < 3; ++i) {
+        if(trackState[i].trackNumber != 0) {
+            FramedSource *baseSource = matroskaDemux->newDemuxedTrackByTrackNumber(trackState[i].trackNumber);
+
+            unsigned estBitrate, numFiltersInFrontOfTrack;
+            trackState[i].source = matroskaFile->createSourceForStreaming(baseSource, trackState[i].trackNumber, estBitrate, numFiltersInFrontOfTrack);
+        }
+    }
+
+    // Start playing once again:
+    play();
+}
+
+void play() {
+    *env << "Beginning to read from file...\n";
+
+    // Start playing each track's RTP sink from its corresponding source:
+    for(unsigned i = 0; i < 3; ++i) {
+        if(trackState[i].sink != NULL && trackState[i].source != NULL) {
+            trackState[i].sink->startPlaying(*trackState[i].source, afterPlaying, NULL);
+        }
+    }
+}
diff --git a/3rdparty/live555/src/testProgs/testMP3-using-ADUs.sdp b/3rdparty/live555/src/testProgs/testMP3-using-ADUs.sdp
new file mode 100644
index 00000000..d1649144
--- /dev/null
+++ b/3rdparty/live555/src/testProgs/testMP3-using-ADUs.sdp
@@ -0,0 +1,10 @@
+v=0
+o=- 49452 4 IN IP4 127.0.0.1
+s=Test MP3 session
+i=Parameters for the session streamed by "testMP3Streamer"
+t=0 0
+a=tool:testMP3Streamer
+a=type:broadcast
+m=audio 6666 RTP/AVP 96
+c=IN IP4 239.255.42.42/127
+a=rtpmap:96 mpa-robust/90000
diff --git a/3rdparty/live555/src/testProgs/testMP3.sdp b/3rdparty/live555/src/testProgs/testMP3.sdp
new file mode 100644
index 00000000..750ba795
--- /dev/null
+++ b/3rdparty/live555/src/testProgs/testMP3.sdp
@@ -0,0 +1,9 @@
+v=0
+o=- 49452 4 IN IP4 127.0.0.1
+s=Test MP3 session
+i=Parameters for the session streamed by "testMP3Streamer"
+t=0 0
+a=tool:testMP3Streamer
+a=type:broadcast
+m=audio 6666 RTP/AVP 14
+c=IN IP4 239.255.42.42/127
diff --git a/3rdparty/live555/src/testProgs/testMP3Receiver.cpp b/3rdparty/live555/src/testProgs/testMP3Receiver.cpp
new file mode 100644
index 00000000..0017d0db
--- /dev/null
+++ b/3rdparty/live555/src/testProgs/testMP3Receiver.cpp
@@ -0,0 +1,156 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// Copyright (c) 1996-2022, Live Networks, Inc.  All rights reserved
+// A test program that receives a RTP/RTCP multicast MP3 stream,
+// and outputs the resulting MP3 file stream to 'stdout'
+// main program
+
+#include "liveMedia.hh"
+#include "GroupsockHelper.hh"
+#include "BasicUsageEnvironment.hh"
+
+// To receive a stream of 'ADUs' rather than raw MP3 frames, uncomment this:
+//#define STREAM_USING_ADUS 1
+// (For more information about ADUs and interleaving,
+//  see <http://www.live555.com/rtp-mp3/>)
+
+// To receive a "source-specific multicast" (SSM) stream, uncomment this:
+//#define USE_SSM 1
+
+// To stream using IPv6 multicast, rather than IPv4 multicast, uncomment the following:
+//#define USE_IPV6_MULTICAST 1
+
+void afterPlaying(void *clientData);  // forward
+
+// A structure to hold the state of the current session.
+// It is used in the "afterPlaying()" function to clean up the session.
+struct sessionState_t {
+    FramedSource *source;
+    FileSink *    sink;
+    RTCPInstance *rtcpInstance;
+} sessionState;
+
+UsageEnvironment *env;
+
+int main(int argc, char **argv) {
+    // Begin by setting up our usage environment:
+    TaskScheduler *scheduler = BasicTaskScheduler::createNew();
+    env                      = BasicUsageEnvironment::createNew(*scheduler);
+
+    // Create the data sink for 'stdout':
+    sessionState.sink = FileSink::createNew(*env, "stdout");
+    // Note: The string "stdout" is handled as a special case.
+    // A real file name could have been used instead.
+
+    // Create 'groupsocks' for RTP and RTCP:
+    char const *sessionAddressStr
+#ifdef USE_IPV6_MULTICAST
+#ifdef USE_SSM
+        = "FF3E::FFFF:2A2A";
+#else
+        = "FF1E::FFFF:2A2A";
+#endif
+#else
+#ifdef USE_SSM
+        = "232.255.42.42";
+#else
+        = "239.255.42.42";
+#endif
+#endif
+    // Note: If the session is unicast rather than multicast,
+    // then replace this string with "0.0.0.0"
+    const unsigned short rtpPortNum  = 6666;
+    const unsigned short rtcpPortNum = rtpPortNum + 1;
+#ifndef USE_SSM
+    const unsigned char ttl = 1;  // low, in case routers don't admin scope
+#endif
+
+    NetAddressList          sessionAddresses(sessionAddressStr);
+    struct sockaddr_storage sessionAddress;
+    copyAddress(sessionAddress, sessionAddresses.firstAddress());
+
+    const Port rtpPort(rtpPortNum);
+    const Port rtcpPort(rtcpPortNum);
+
+#ifdef USE_SSM
+    char const *sourceAddressStr = "aaa.bbb.ccc.ddd";
+    // replace this with the real source address
+    NetAddressList          sourceFilterAddresses(sourceAddressStr);
+    struct sockaddr_storage sourceFilterAddress;
+    copyAddress(sourceFilterAddress, sourceFilterAddresses.firstAddress());
+
+    Groupsock rtpGroupsock(*env, sessionAddress, sourceFilterAddress, rtpPort);
+    Groupsock rtcpGroupsock(*env, sessionAddress, sourceFilterAddress, rtcpPort);
+    rtcpGroupsock.changeDestinationParameters(sourceFilterAddress, 0, ~0);
+    // our RTCP "RR"s are sent back using unicast
+#else
+    Groupsock rtpGroupsock(*env, sessionAddress, rtpPort, ttl);
+    Groupsock rtcpGroupsock(*env, sessionAddress, rtcpPort, ttl);
+#endif
+
+    RTPSource *rtpSource;
+#ifndef STREAM_USING_ADUS
+    // Create the data source: a "MPEG Audio RTP source"
+    rtpSource = MPEG1or2AudioRTPSource::createNew(*env, &rtpGroupsock);
+#else
+    // Create the data source: a "MP3 *ADU* RTP source"
+    unsigned char rtpPayloadFormat = 96;  // a dynamic payload type
+    rtpSource                      = MP3ADURTPSource::createNew(*env, &rtpGroupsock, rtpPayloadFormat);
+#endif
+
+    // Create (and start) a 'RTCP instance' for the RTP source:
+    const unsigned estimatedSessionBandwidth = 160;  // in kbps; for RTCP b/w share
+    const unsigned maxCNAMElen               = 100;
+    unsigned char  CNAME[maxCNAMElen + 1];
+    gethostname((char *)CNAME, maxCNAMElen);
+    CNAME[maxCNAMElen]        = '\0';  // just in case
+    sessionState.rtcpInstance = RTCPInstance::createNew(*env, &rtcpGroupsock, estimatedSessionBandwidth, CNAME, NULL /* we're a client */, rtpSource);
+    // Note: This starts RTCP running automatically
+
+    sessionState.source = rtpSource;
+#ifdef STREAM_USING_ADUS
+    // Add a filter that deinterleaves the ADUs after depacketizing them:
+    sessionState.source = MP3ADUdeinterleaver::createNew(*env, sessionState.source);
+    if(sessionState.source == NULL) {
+        *env << "Unable to create an ADU deinterleaving filter for the source\n";
+        exit(1);
+    }
+
+    // Add another filter that converts these ADUs to MP3s:
+    sessionState.source = MP3FromADUSource::createNew(*env, sessionState.source);
+    if(sessionState.source == NULL) {
+        *env << "Unable to create an ADU->MP3 filter for the source\n";
+        exit(1);
+    }
+#endif
+
+    // Finally, start receiving the multicast stream:
+    *env << "Beginning receiving multicast stream...\n";
+    sessionState.sink->startPlaying(*sessionState.source, afterPlaying, NULL);
+
+    env->taskScheduler().doEventLoop();  // does not return
+
+    return 0;  // only to prevent compiler warning
+}
+
+void afterPlaying(void * /*clientData*/) {
+    *env << "...done receiving\n";
+
+    // End by closing the media:
+    Medium::close(sessionState.rtcpInstance);  // Note: Sends a RTCP BYE
+    Medium::close(sessionState.sink);
+    Medium::close(sessionState.source);
+}
diff --git a/3rdparty/live555/src/testProgs/testMP3Streamer.cpp b/3rdparty/live555/src/testProgs/testMP3Streamer.cpp
new file mode 100644
index 00000000..4bbcde12
--- /dev/null
+++ b/3rdparty/live555/src/testProgs/testMP3Streamer.cpp
@@ -0,0 +1,193 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// Copyright (c) 1996-2022, Live Networks, Inc.  All rights reserved
+// A test program that streams a MP3 file via RTP/RTCP
+// main program
+
+#include "liveMedia.hh"
+
+#include "BasicUsageEnvironment.hh"
+#include "announceURL.hh"
+
+// To stream using 'ADUs' rather than raw MP3 frames, uncomment the following:
+//#define STREAM_USING_ADUS 1
+// To also reorder ADUs before streaming, uncomment the following:
+//#define INTERLEAVE_ADUS 1
+// (For more information about ADUs and interleaving,
+//  see <http://www.live555.com/rtp-mp3/>)
+
+// To stream using "source-specific multicast" (SSM), uncomment the following:
+//#define USE_SSM 1
+
+// To stream using IPv6 multicast, rather than IPv4 multicast, uncomment the following:
+//#define USE_IPV6_MULTICAST 1
+
+// To set up an internal RTSP server, uncomment the following:
+//#define IMPLEMENT_RTSP_SERVER 1
+// (Note that this RTSP server works for multicast only)
+
+#ifdef USE_SSM
+Boolean const isSSM = True;
+#else
+Boolean const isSSM = False;
+#endif
+
+#ifdef IMPLEMENT_RTSP_SERVER
+RTSPServer *rtspServer;
+#endif
+
+UsageEnvironment *env;
+
+// A structure to hold the state of the current session.
+// It is used in the "afterPlaying()" function to clean up the session.
+struct sessionState_t {
+    FramedSource *source;
+    RTPSink *     sink;
+    RTCPInstance *rtcpInstance;
+    Groupsock *   rtpGroupsock;
+    Groupsock *   rtcpGroupsock;
+} sessionState;
+
+char const *inputFileName = "test.mp3";
+
+void play();  // forward
+
+int main(int argc, char **argv) {
+    // Begin by setting up our usage environment:
+    TaskScheduler *scheduler = BasicTaskScheduler::createNew();
+    env                      = BasicUsageEnvironment::createNew(*scheduler);
+
+    // Create 'groupsocks' for RTP and RTCP:
+    char const *destinationAddressStr
+#ifdef USE_IPV6_MULTICAST
+#ifdef USE_SSM
+        = "FF3E::FFFF:2A2A";
+#else
+        = "FF1E::FFFF:2A2A";
+#endif
+#else
+#ifdef USE_SSM
+        = "232.255.42.42";
+#else
+        = "239.255.42.42";
+#endif
+#endif
+    // Note: This is a multicast address.  If you wish to stream using
+    // unicast instead, then replace this string with the unicast address
+    // of the (single) destination.  (You may also need to make a similar
+    // change to the receiver program.)
+
+    const unsigned short rtpPortNum  = 6666;
+    const unsigned short rtcpPortNum = rtpPortNum + 1;
+    const unsigned char  ttl         = 1;  // low, in case routers don't admin scope
+
+    NetAddressList          destinationAddresses(destinationAddressStr);
+    struct sockaddr_storage destinationAddress;
+    copyAddress(destinationAddress, destinationAddresses.firstAddress());
+
+    const Port rtpPort(rtpPortNum);
+    const Port rtcpPort(rtcpPortNum);
+
+    sessionState.rtpGroupsock  = new Groupsock(*env, destinationAddress, rtpPort, ttl);
+    sessionState.rtcpGroupsock = new Groupsock(*env, destinationAddress, rtcpPort, ttl);
+#ifdef USE_SSM
+    sessionState.rtpGroupsock->multicastSendOnly();
+    sessionState.rtcpGroupsock->multicastSendOnly();
+#endif
+
+    // Create a 'MP3 RTP' sink from the RTP 'groupsock':
+#ifdef STREAM_USING_ADUS
+    unsigned char rtpPayloadFormat = 96;  // A dynamic payload format code
+    sessionState.sink              = MP3ADURTPSink::createNew(*env, sessionState.rtpGroupsock, rtpPayloadFormat);
+#else
+    sessionState.sink = MPEG1or2AudioRTPSink::createNew(*env, sessionState.rtpGroupsock);
+#endif
+
+    // Create (and start) a 'RTCP instance' for this RTP sink:
+    const unsigned estimatedSessionBandwidth = 160;  // in kbps; for RTCP b/w share
+    const unsigned maxCNAMElen               = 100;
+    unsigned char  CNAME[maxCNAMElen + 1];
+    gethostname((char *)CNAME, maxCNAMElen);
+    CNAME[maxCNAMElen] = '\0';  // just in case
+    sessionState.rtcpInstance =
+        RTCPInstance::createNew(*env, sessionState.rtcpGroupsock, estimatedSessionBandwidth, CNAME, sessionState.sink, NULL /* we're a server */, isSSM);
+    // Note: This starts RTCP running automatically
+
+#ifdef IMPLEMENT_RTSP_SERVER
+    rtspServer = RTSPServer::createNew(*env, 8554);
+    if(rtspServer == NULL) {
+        *env << "Failed to create RTSP server: " << env->getResultMsg() << "\n";
+        exit(1);
+    }
+    ServerMediaSession *sms = ServerMediaSession::createNew(*env, "testStream", inputFileName, "Session streamed by \"testMP3Streamer\"", isSSM);
+    sms->addSubsession(PassiveServerMediaSubsession::createNew(*sessionState.sink, sessionState.rtcpInstance));
+    rtspServer->addServerMediaSession(sms);
+    announceURL(rtspServer, sms);
+#endif
+
+    play();
+
+    env->taskScheduler().doEventLoop();  // does not return
+    return 0;                            // only to prevent compiler warning
+}
+
+void afterPlaying(void *clientData);  // forward
+
+void play() {
+    // Open the file as a 'MP3 file source':
+    sessionState.source = MP3FileSource::createNew(*env, inputFileName);
+    if(sessionState.source == NULL) {
+        *env << "Unable to open file \"" << inputFileName << "\" as a MP3 file source\n";
+        exit(1);
+    }
+
+#ifdef STREAM_USING_ADUS
+    // Add a filter that converts the source MP3s to ADUs:
+    sessionState.source = ADUFromMP3Source::createNew(*env, sessionState.source);
+    if(sessionState.source == NULL) {
+        *env << "Unable to create a MP3->ADU filter for the source\n";
+        exit(1);
+    }
+
+#ifdef INTERLEAVE_ADUS
+    // Add another filter that interleaves the ADUs before packetizing them:
+    unsigned char  interleaveCycle[]   = { 0, 2, 1, 3 };  // or choose your own order...
+    unsigned const interleaveCycleSize = (sizeof interleaveCycle) / (sizeof(unsigned char));
+    Interleaving   interleaving(interleaveCycleSize, interleaveCycle);
+    sessionState.source = MP3ADUinterleaver::createNew(*env, interleaving, sessionState.source);
+    if(sessionState.source == NULL) {
+        *env << "Unable to create an ADU interleaving filter for the source\n";
+        exit(1);
+    }
+#endif
+#endif
+
+    // Finally, start the streaming:
+    *env << "Beginning streaming...\n";
+    sessionState.sink->startPlaying(*sessionState.source, afterPlaying, NULL);
+}
+
+void afterPlaying(void * /*clientData*/) {
+    *env << "...done streaming\n";
+
+    sessionState.sink->stopPlaying();
+
+    // End this loop by closing the current source:
+    Medium::close(sessionState.source);
+
+    // And start another loop:
+    play();
+}
diff --git a/3rdparty/live555/src/testProgs/testMPEG1or2AudioVideo.sdp b/3rdparty/live555/src/testProgs/testMPEG1or2AudioVideo.sdp
new file mode 100644
index 00000000..3cb77755
--- /dev/null
+++ b/3rdparty/live555/src/testProgs/testMPEG1or2AudioVideo.sdp
@@ -0,0 +1,11 @@
+v=0
+o=- 49451 3 IN IP4 127.0.0.1
+s=Test MPEG Audio+Video session
+i=Parameters for the session streamed by "testMPEG1or2AudioVideoStreamer"
+t=0 0
+a=tool:testMPEG1or2AudioVideoStreamer
+a=type:broadcast
+m=audio 6666 RTP/AVP 14
+c=IN IP4 239.255.42.42/127
+m=video 8888 RTP/AVP 32
+c=IN IP4 239.255.42.42/127
diff --git a/3rdparty/live555/src/testProgs/testMPEG1or2AudioVideoStreamer.cpp b/3rdparty/live555/src/testProgs/testMPEG1or2AudioVideoStreamer.cpp
new file mode 100644
index 00000000..9c3e635d
--- /dev/null
+++ b/3rdparty/live555/src/testProgs/testMPEG1or2AudioVideoStreamer.cpp
@@ -0,0 +1,202 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// Copyright (c) 1996-2022, Live Networks, Inc.  All rights reserved
+// A test program that reads a MPEG-1 or 2 Program Stream file,
+// splits it into Audio and Video Elementary Streams,
+// and streams both using RTP
+// main program
+
+#include "liveMedia.hh"
+
+#include "BasicUsageEnvironment.hh"
+#include "announceURL.hh"
+#include "GroupsockHelper.hh"
+
+UsageEnvironment *env;
+char const *      inputFileName = "test.mpg";
+MPEG1or2Demux *   mpegDemux;
+FramedSource *    audioSource;
+FramedSource *    videoSource;
+RTPSink *         audioSink;
+RTPSink *         videoSink;
+
+void play();  // forward
+
+// To stream using "source-specific multicast" (SSM), uncomment the following:
+//#define USE_SSM 1
+
+// To stream using IPv6 multicast, rather than IPv4 multicast, uncomment the following:
+//#define USE_IPV6_MULTICAST 1
+
+// To set up an internal RTSP server, uncomment the following:
+//#define IMPLEMENT_RTSP_SERVER 1
+// (Note that this RTSP server works for multicast only)
+
+// To stream *only* MPEG "I" frames (e.g., to reduce network bandwidth),
+// change the following "False" to "True":
+Boolean iFramesOnly = False;
+
+#ifdef USE_SSM
+Boolean const isSSM = True;
+#else
+Boolean const isSSM = False;
+#endif
+
+int main(int argc, char **argv) {
+    // Begin by setting up our usage environment:
+    TaskScheduler *scheduler = BasicTaskScheduler::createNew();
+    env                      = BasicUsageEnvironment::createNew(*scheduler);
+
+    // Create 'groupsocks' for RTP and RTCP:
+    char const *destinationAddressStr
+#ifdef USE_IPV6_MULTICAST
+#ifdef USE_SSM
+        = "FF3E::FFFF:2A2A";
+#else
+        = "FF1E::FFFF:2A2A";
+#endif
+#else
+#ifdef USE_SSM
+        = "232.255.42.42";
+#else
+        = "239.255.42.42";
+#endif
+#endif
+    // Note: This is a multicast address.  If you wish to stream using
+    // unicast instead, then replace this string with the unicast address
+    // of the (single) destination.  (You may also need to make a similar
+    // change to the receiver program.)
+
+    const unsigned short rtpPortNumAudio  = 6666;
+    const unsigned short rtcpPortNumAudio = rtpPortNumAudio + 1;
+    const unsigned short rtpPortNumVideo  = 8888;
+    const unsigned short rtcpPortNumVideo = rtpPortNumVideo + 1;
+    const unsigned char  ttl              = 7;  // low, in case routers don't admin scope
+
+    NetAddressList          destinationAddresses(destinationAddressStr);
+    struct sockaddr_storage destinationAddress;
+    copyAddress(destinationAddress, destinationAddresses.firstAddress());
+
+    const Port rtpPortAudio(rtpPortNumAudio);
+    const Port rtcpPortAudio(rtcpPortNumAudio);
+    const Port rtpPortVideo(rtpPortNumVideo);
+    const Port rtcpPortVideo(rtcpPortNumVideo);
+
+    Groupsock rtpGroupsockAudio(*env, destinationAddress, rtpPortAudio, ttl);
+    Groupsock rtcpGroupsockAudio(*env, destinationAddress, rtcpPortAudio, ttl);
+    Groupsock rtpGroupsockVideo(*env, destinationAddress, rtpPortVideo, ttl);
+    Groupsock rtcpGroupsockVideo(*env, destinationAddress, rtcpPortVideo, ttl);
+#ifdef USE_SSM
+    rtpGroupsockAudio.multicastSendOnly();
+    rtcpGroupsockAudio.multicastSendOnly();
+    rtpGroupsockVideo.multicastSendOnly();
+    rtcpGroupsockVideo.multicastSendOnly();
+#endif
+
+    // Create a 'MPEG Audio RTP' sink from the RTP 'groupsock':
+    audioSink = MPEG1or2AudioRTPSink::createNew(*env, &rtpGroupsockAudio);
+
+    // Create (and start) a 'RTCP instance' for this RTP sink:
+    const unsigned estimatedSessionBandwidthAudio = 160;  // in kbps; for RTCP b/w share
+    const unsigned maxCNAMElen                    = 100;
+    unsigned char  CNAME[maxCNAMElen + 1];
+    gethostname((char *)CNAME, maxCNAMElen);
+    CNAME[maxCNAMElen] = '\0';  // just in case
+#ifdef IMPLEMENT_RTSP_SERVER
+    RTCPInstance *audioRTCP =
+#endif
+        RTCPInstance::createNew(*env, &rtcpGroupsockAudio, estimatedSessionBandwidthAudio, CNAME, audioSink, NULL /* we're a server */, isSSM);
+    // Note: This starts RTCP running automatically
+
+    // Create a 'MPEG Video RTP' sink from the RTP 'groupsock':
+    videoSink = MPEG1or2VideoRTPSink::createNew(*env, &rtpGroupsockVideo);
+
+    // Create (and start) a 'RTCP instance' for this RTP sink:
+    const unsigned estimatedSessionBandwidthVideo = 4500;  // in kbps; for RTCP b/w share
+#ifdef IMPLEMENT_RTSP_SERVER
+    RTCPInstance *videoRTCP =
+#endif
+        RTCPInstance::createNew(*env, &rtcpGroupsockVideo, estimatedSessionBandwidthVideo, CNAME, videoSink, NULL /* we're a server */, isSSM);
+    // Note: This starts RTCP running automatically
+
+#ifdef IMPLEMENT_RTSP_SERVER
+    RTSPServer *rtspServer = RTSPServer::createNew(*env, 8554);
+    if(rtspServer == NULL) {
+        *env << "Failed to create RTSP server: " << env->getResultMsg() << "\n";
+        exit(1);
+    }
+    ServerMediaSession *sms = ServerMediaSession::createNew(*env, "testStream", inputFileName, "Session streamed by \"testMPEG1or2AudioVideoStreamer\"", isSSM);
+    sms->addSubsession(PassiveServerMediaSubsession::createNew(*audioSink, audioRTCP));
+    sms->addSubsession(PassiveServerMediaSubsession::createNew(*videoSink, videoRTCP));
+    rtspServer->addServerMediaSession(sms);
+    announceURL(rtspServer, sms);
+#endif
+
+    // Finally, start the streaming:
+    *env << "Beginning streaming...\n";
+    play();
+
+    env->taskScheduler().doEventLoop();  // does not return
+
+    return 0;  // only to prevent compiler warning
+}
+
+void afterPlaying(void *clientData) {
+    // One of the sinks has ended playing.
+    // Check whether any of the sources have a pending read.  If so,
+    // wait until its sink ends playing also:
+    if(audioSource->isCurrentlyAwaitingData() || videoSource->isCurrentlyAwaitingData())
+        return;
+
+    // Now that both sinks have ended, close both input sources,
+    // and start playing again:
+    *env << "...done reading from file\n";
+
+    audioSink->stopPlaying();
+    videoSink->stopPlaying();
+    // ensures that both are shut down
+    Medium::close(audioSource);
+    Medium::close(videoSource);
+    Medium::close(mpegDemux);
+    // Note: This also closes the input file that this source read from.
+
+    // Start playing once again:
+    play();
+}
+
+void play() {
+    // Open the input file as a 'byte-stream file source':
+    ByteStreamFileSource *fileSource = ByteStreamFileSource::createNew(*env, inputFileName);
+    if(fileSource == NULL) {
+        *env << "Unable to open file \"" << inputFileName << "\" as a byte-stream file source\n";
+        exit(1);
+    }
+
+    // We must demultiplex Audio and Video Elementary Streams
+    // from the input source:
+    mpegDemux             = MPEG1or2Demux::createNew(*env, fileSource);
+    FramedSource *audioES = mpegDemux->newAudioStream();
+    FramedSource *videoES = mpegDemux->newVideoStream();
+
+    // Create a framer for each Elementary Stream:
+    audioSource = MPEG1or2AudioStreamFramer::createNew(*env, audioES);
+    videoSource = MPEG1or2VideoStreamFramer::createNew(*env, videoES, iFramesOnly);
+
+    // Finally, start playing each sink.
+    *env << "Beginning to read from file...\n";
+    videoSink->startPlaying(*videoSource, afterPlaying, videoSink);
+    audioSink->startPlaying(*audioSource, afterPlaying, audioSink);
+}
diff --git a/3rdparty/live555/src/testProgs/testMPEG1or2ProgramToTransportStream.cpp b/3rdparty/live555/src/testProgs/testMPEG1or2ProgramToTransportStream.cpp
new file mode 100644
index 00000000..d36f4a60
--- /dev/null
+++ b/3rdparty/live555/src/testProgs/testMPEG1or2ProgramToTransportStream.cpp
@@ -0,0 +1,72 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// Copyright (c) 1996-2022, Live Networks, Inc.  All rights reserved
+// A program that converts a MPEG-1 or 2 Program Stream file into
+// a Transport Stream file.
+// main program
+
+#include "liveMedia.hh"
+#include "BasicUsageEnvironment.hh"
+
+char const *inputFileName  = "in.mpg";
+char const *outputFileName = "out.ts";
+
+void afterPlaying(void *clientData);  // forward
+
+UsageEnvironment *env;
+
+int main(int argc, char **argv) {
+    // Begin by setting up our usage environment:
+    TaskScheduler *scheduler = BasicTaskScheduler::createNew();
+    env                      = BasicUsageEnvironment::createNew(*scheduler);
+
+    // Open the input file as a 'byte-stream file source':
+    FramedSource *inputSource = ByteStreamFileSource::createNew(*env, inputFileName);
+    if(inputSource == NULL) {
+        *env << "Unable to open file \"" << inputFileName << "\" as a byte-stream file source\n";
+        exit(1);
+    }
+
+    // Create a MPEG demultiplexor that reads from that source.
+    MPEG1or2Demux *baseDemultiplexor = MPEG1or2Demux::createNew(*env, inputSource);
+
+    // Create, from this, a source that returns raw PES packets:
+    MPEG1or2DemuxedElementaryStream *pesSource = baseDemultiplexor->newRawPESStream();
+
+    // And, from this, a filter that converts to MPEG-2 Transport Stream frames:
+    FramedSource *tsFrames = MPEG2TransportStreamFromPESSource::createNew(*env, pesSource);
+
+    // Open the output file as a 'file sink':
+    MediaSink *outputSink = FileSink::createNew(*env, outputFileName);
+    if(outputSink == NULL) {
+        *env << "Unable to open file \"" << outputFileName << "\" as a file sink\n";
+        exit(1);
+    }
+
+    // Finally, start playing:
+    *env << "Beginning to read...\n";
+    outputSink->startPlaying(*tsFrames, afterPlaying, NULL);
+
+    env->taskScheduler().doEventLoop();  // does not return
+
+    return 0;  // only to prevent compiler warning
+}
+
+void afterPlaying(void * /*clientData*/) {
+    *env << "Done reading.\n";
+    *env << "Wrote output file: \"" << outputFileName << "\"\n";
+    exit(0);
+}
diff --git a/3rdparty/live555/src/testProgs/testMPEG1or2Splitter.cpp b/3rdparty/live555/src/testProgs/testMPEG1or2Splitter.cpp
new file mode 100644
index 00000000..594d38f3
--- /dev/null
+++ b/3rdparty/live555/src/testProgs/testMPEG1or2Splitter.cpp
@@ -0,0 +1,99 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// Copyright (c) 1996-2022, Live Networks, Inc.  All rights reserved
+// A test program that splits a MPEG-1 or 2 Program Stream file into
+// video and audio output files.
+// main program
+
+#include "liveMedia.hh"
+#include "BasicUsageEnvironment.hh"
+#include <stdlib.h>
+
+char const *inputFileName        = "in.mpg";
+char const *outputFileName_video = "out_video.mpg";
+char const *outputFileName_audio = "out_audio.mpg";
+
+void afterPlaying(void *clientData);  // forward
+
+// A structure to hold the state of the current session.
+// It is used in the "afterPlaying()" function to clean up the session.
+struct sessionState_t {
+    MPEG1or2Demux *baseDemultiplexor;
+    MediaSource *  videoSource;
+    MediaSource *  audioSource;
+    FileSink *     videoSink;
+    FileSink *     audioSink;
+} sessionState;
+
+UsageEnvironment *env;
+
+int main(int argc, char **argv) {
+    // Begin by setting up our usage environment:
+    TaskScheduler *scheduler = BasicTaskScheduler::createNew();
+    env                      = BasicUsageEnvironment::createNew(*scheduler);
+
+    // Open the input file as a 'byte-stream file source':
+    ByteStreamFileSource *inputSource = ByteStreamFileSource::createNew(*env, inputFileName);
+    if(inputSource == NULL) {
+        *env << "Unable to open file \"" << inputFileName << "\" as a byte-stream file source\n";
+        exit(1);
+    }
+
+    // Create a MPEG demultiplexor that reads from that source.
+    sessionState.baseDemultiplexor = MPEG1or2Demux::createNew(*env, inputSource);
+
+    // Create, from this, our own sources (video and audio):
+    sessionState.videoSource = sessionState.baseDemultiplexor->newVideoStream();
+    sessionState.audioSource = sessionState.baseDemultiplexor->newAudioStream();
+
+    // Create the data sinks (output files):
+    sessionState.videoSink = FileSink::createNew(*env, outputFileName_video);
+    sessionState.audioSink = FileSink::createNew(*env, outputFileName_audio);
+
+    // Finally, start playing each sink.
+    *env << "Beginning to read...\n";
+    sessionState.videoSink->startPlaying(*sessionState.videoSource, afterPlaying, sessionState.videoSink);
+    sessionState.audioSink->startPlaying(*sessionState.audioSource, afterPlaying, sessionState.audioSink);
+
+    env->taskScheduler().doEventLoop();  // does not return
+
+    return 0;  // only to prevent compiler warning
+}
+
+void afterPlaying(void *clientData) {
+    Medium *finishedSink = (Medium *)clientData;
+
+    if(finishedSink == sessionState.videoSink) {
+        *env << "No more video\n";
+        Medium::close(sessionState.videoSink);
+        Medium::close(sessionState.videoSource);
+        sessionState.videoSink = NULL;
+    }
+    else if(finishedSink == sessionState.audioSink) {
+        *env << "No more audio\n";
+        Medium::close(sessionState.audioSink);
+        Medium::close(sessionState.audioSource);
+        sessionState.audioSink = NULL;
+    }
+
+    if(sessionState.videoSink == NULL && sessionState.audioSink == NULL) {
+        *env << "...finished reading\n";
+
+        Medium::close(sessionState.baseDemultiplexor);
+
+        exit(0);
+    }
+}
diff --git a/3rdparty/live555/src/testProgs/testMPEG1or2Video.sdp b/3rdparty/live555/src/testProgs/testMPEG1or2Video.sdp
new file mode 100644
index 00000000..c3b9c73b
--- /dev/null
+++ b/3rdparty/live555/src/testProgs/testMPEG1or2Video.sdp
@@ -0,0 +1,9 @@
+v=0
+o=- 49451 3 IN IP4 127.0.0.1
+s=Test MPEG Video session
+i=Parameters for the session streamed by "testMPEG1or2VideoStreamer"
+t=0 0
+a=tool:testMPEG1or2VideoStreamer
+a=type:broadcast
+m=video 8888 RTP/AVP 32
+c=IN IP4 239.255.42.42/127
diff --git a/3rdparty/live555/src/testProgs/testMPEG1or2VideoReceiver.cpp b/3rdparty/live555/src/testProgs/testMPEG1or2VideoReceiver.cpp
new file mode 100644
index 00000000..0fd99bc8
--- /dev/null
+++ b/3rdparty/live555/src/testProgs/testMPEG1or2VideoReceiver.cpp
@@ -0,0 +1,117 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// Copyright (c) 1996-2022, Live Networks, Inc.  All rights reserved
+// A test program that receives a RTP/RTCP multicast MPEG video stream,
+// and outputs the resulting MPEG file stream to 'stdout'
+// main program
+
+#include "liveMedia.hh"
+#include "GroupsockHelper.hh"
+
+#include "BasicUsageEnvironment.hh"
+
+// To receive a "source-specific multicast" (SSM) stream, uncomment this:
+//#define USE_SSM 1
+
+void afterPlaying(void *clientData);  // forward
+
+// A structure to hold the state of the current session.
+// It is used in the "afterPlaying()" function to clean up the session.
+struct sessionState_t {
+    RTPSource *   source;
+    MediaSink *   sink;
+    RTCPInstance *rtcpInstance;
+} sessionState;
+
+UsageEnvironment *env;
+
+int main(int argc, char **argv) {
+    // Begin by setting up our usage environment:
+    TaskScheduler *scheduler = BasicTaskScheduler::createNew();
+    env                      = BasicUsageEnvironment::createNew(*scheduler);
+
+    // Create the data sink for 'stdout':
+    sessionState.sink = FileSink::createNew(*env, "stdout");
+    // Note: The string "stdout" is handled as a special case.
+    // A real file name could have been used instead.
+
+    // Create 'groupsocks' for RTP and RTCP:
+    char const *sessionAddressStr
+#ifdef USE_SSM
+        = "232.255.42.42";
+#else
+        = "239.255.42.42";
+    // Note: If the session is unicast rather than multicast,
+    // then replace this string with "0.0.0.0"
+#endif
+    const unsigned short rtpPortNum  = 8888;
+    const unsigned short rtcpPortNum = rtpPortNum + 1;
+#ifndef USE_SSM
+    const unsigned char ttl = 1;  // low, in case routers don't admin scope
+#endif
+
+    NetAddressList          sessionAddresses(sessionAddressStr);
+    struct sockaddr_storage sessionAddress;
+    copyAddress(sessionAddress, sessionAddresses.firstAddress());
+
+    const Port rtpPort(rtpPortNum);
+    const Port rtcpPort(rtcpPortNum);
+
+#ifdef USE_SSM
+    char const *sourceAddressStr = "aaa.bbb.ccc.ddd";
+    // replace this with the real source address
+    NetAddressList          sourceFilterAddresses(sourceAddressStr);
+    struct sockaddr_storage sourceFilterAddress;
+    copyAddress(sourceFilterAddress, sourceFilterAddresses.firstAddress());
+
+    Groupsock rtpGroupsock(*env, sessionAddress, sourceFilterAddress, rtpPort);
+    Groupsock rtcpGroupsock(*env, sessionAddress, sourceFilterAddress, rtcpPort);
+    rtcpGroupsock.changeDestinationParameters(sourceFilterAddress, 0, ~0);
+    // our RTCP "RR"s are sent back using unicast
+#else
+    Groupsock rtpGroupsock(*env, sessionAddress, rtpPort, ttl);
+    Groupsock rtcpGroupsock(*env, sessionAddress, rtcpPort, ttl);
+#endif
+
+    // Create the data source: a "MPEG Video RTP source"
+    sessionState.source = MPEG1or2VideoRTPSource::createNew(*env, &rtpGroupsock);
+
+    // Create (and start) a 'RTCP instance' for the RTP source:
+    const unsigned estimatedSessionBandwidth = 4500;  // in kbps; for RTCP b/w share
+    const unsigned maxCNAMElen               = 100;
+    unsigned char  CNAME[maxCNAMElen + 1];
+    gethostname((char *)CNAME, maxCNAMElen);
+    CNAME[maxCNAMElen]        = '\0';  // just in case
+    sessionState.rtcpInstance = RTCPInstance::createNew(*env, &rtcpGroupsock, estimatedSessionBandwidth, CNAME, NULL /* we're a client */, sessionState.source);
+    // Note: This starts RTCP running automatically
+
+    // Finally, start receiving the multicast stream:
+    *env << "Beginning receiving multicast stream...\n";
+    sessionState.sink->startPlaying(*sessionState.source, afterPlaying, NULL);
+
+    env->taskScheduler().doEventLoop();  // does not return
+
+    return 0;  // only to prevent compiler warning
+}
+
+void afterPlaying(void * /*clientData*/) {
+    *env << "...done receiving\n";
+
+    // End by closing the media:
+    Medium::close(sessionState.rtcpInstance);  // Note: Sends a RTCP BYE
+    Medium::close(sessionState.sink);
+    Medium::close(sessionState.source);
+}
diff --git a/3rdparty/live555/src/testProgs/testMPEG1or2VideoStreamer.cpp b/3rdparty/live555/src/testProgs/testMPEG1or2VideoStreamer.cpp
new file mode 100644
index 00000000..650210a7
--- /dev/null
+++ b/3rdparty/live555/src/testProgs/testMPEG1or2VideoStreamer.cpp
@@ -0,0 +1,167 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// Copyright (c) 1996-2022, Live Networks, Inc.  All rights reserved
+// A test program that reads a MPEG-1 or 2 Video Elementary Stream file,
+// and streams it using RTP
+// main program
+
+#include "liveMedia.hh"
+
+#include "BasicUsageEnvironment.hh"
+#include "announceURL.hh"
+#include "GroupsockHelper.hh"
+
+// Uncomment the following if the input file is a MPEG Program Stream
+// rather than a MPEG Video Elementary Stream
+//#define SOURCE_IS_PROGRAM_STREAM 1
+
+// To stream using "source-specific multicast" (SSM), uncomment the following:
+//#define USE_SSM 1
+
+// To stream using IPv6 multicast, rather than IPv4 multicast, uncomment the following:
+//#define USE_IPV6_MULTICAST 1
+
+// To set up an internal RTSP server, uncomment the following:
+//#define IMPLEMENT_RTSP_SERVER 1
+// (Note that this RTSP server works for multicast only)
+
+// To stream *only* MPEG "I" frames (e.g., to reduce network bandwidth),
+// change the following "False" to "True":
+Boolean iFramesOnly = False;
+
+#ifdef USE_SSM
+Boolean const isSSM = True;
+#else
+Boolean const isSSM = False;
+#endif
+
+UsageEnvironment *env;
+char const *      inputFileName = "test.mpg";
+#ifdef SOURCE_IS_PROGRAM_STREAM
+MPEG1or2Demux *mpegDemux;
+#endif
+MediaSource *videoSource;
+RTPSink *    videoSink;
+
+void play();  // forward
+
+int main(int argc, char **argv) {
+    // Begin by setting up our usage environment:
+    TaskScheduler *scheduler = BasicTaskScheduler::createNew();
+    env                      = BasicUsageEnvironment::createNew(*scheduler);
+
+    // Create 'groupsocks' for RTP and RTCP:
+    char const *destinationAddressStr
+#ifdef USE_SSM
+        = "232.255.42.42";
+#else
+        = "239.255.42.42";
+    // Note: This is a multicast address.  If you wish to stream using
+    // unicast instead, then replace this string with the unicast address
+    // of the (single) destination.  (You may also need to make a similar
+    // change to the receiver program.)
+#endif
+    const unsigned short rtpPortNum  = 8888;
+    const unsigned short rtcpPortNum = rtpPortNum + 1;
+    const unsigned char  ttl         = 7;  // low, in case routers don't admin scope
+
+    NetAddressList          destinationAddresses(destinationAddressStr);
+    struct sockaddr_storage destinationAddress;
+    copyAddress(destinationAddress, destinationAddresses.firstAddress());
+    const Port rtpPort(rtpPortNum);
+    const Port rtcpPort(rtcpPortNum);
+
+    Groupsock rtpGroupsock(*env, destinationAddress, rtpPort, ttl);
+    Groupsock rtcpGroupsock(*env, destinationAddress, rtcpPort, ttl);
+#ifdef USE_SSM
+    rtpGroupsock.multicastSendOnly();
+    rtcpGroupsock.multicastSendOnly();
+#endif
+
+    // Create a 'MPEG Video RTP' sink from the RTP 'groupsock':
+    videoSink = MPEG1or2VideoRTPSink::createNew(*env, &rtpGroupsock);
+
+    // Create (and start) a 'RTCP instance' for this RTP sink:
+    const unsigned estimatedSessionBandwidth = 4500;  // in kbps; for RTCP b/w share
+    const unsigned maxCNAMElen               = 100;
+    unsigned char  CNAME[maxCNAMElen + 1];
+    gethostname((char *)CNAME, maxCNAMElen);
+    CNAME[maxCNAMElen] = '\0';  // just in case
+#ifdef IMPLEMENT_RTSP_SERVER
+    RTCPInstance *rtcp =
+#endif
+        RTCPInstance::createNew(*env, &rtcpGroupsock, estimatedSessionBandwidth, CNAME, videoSink, NULL /* we're a server */, isSSM);
+    // Note: This starts RTCP running automatically
+
+#ifdef IMPLEMENT_RTSP_SERVER
+    RTSPServer *rtspServer = RTSPServer::createNew(*env, 8554);
+    if(rtspServer == NULL) {
+        *env << "Failed to create RTSP server: " << env->getResultMsg() << "\n";
+        exit(1);
+    }
+    ServerMediaSession *sms = ServerMediaSession::createNew(*env, "testStream", inputFileName, "Session streamed by \"testMPEG1or2VideoStreamer\"", isSSM);
+    sms->addSubsession(PassiveServerMediaSubsession::createNew(*videoSink, rtcp));
+    rtspServer->addServerMediaSession(sms);
+    announceURL(rtspServer, sms);
+#endif
+
+    // Finally, start the streaming:
+    *env << "Beginning streaming...\n";
+    play();
+
+    env->taskScheduler().doEventLoop();  // does not return
+
+    return 0;  // only to prevent compiler warning
+}
+
+void afterPlaying(void * /*clientData*/) {
+    *env << "...done reading from file\n";
+
+    videoSink->stopPlaying();
+    Medium::close(videoSource);
+#ifdef SOURCE_IS_PROGRAM_STREAM
+    Medium::close(mpegDemux);
+#endif
+    // Note that this also closes the input file that this source read from.
+
+    play();
+}
+
+void play() {
+    // Open the input file as a 'byte-stream file source':
+    ByteStreamFileSource *fileSource = ByteStreamFileSource::createNew(*env, inputFileName);
+    if(fileSource == NULL) {
+        *env << "Unable to open file \"" << inputFileName << "\" as a byte-stream file source\n";
+        exit(1);
+    }
+
+    FramedSource *videoES;
+#ifdef SOURCE_IS_PROGRAM_STREAM
+    // We must demultiplex a Video Elementary Stream from the input source:
+    mpegDemux = MPEG1or2Demux::createNew(*env, fileSource);
+    videoES   = mpegDemux->newVideoStream();
+#else
+    // The input source is assumed to already be a Video Elementary Stream:
+    videoES = fileSource;
+#endif
+
+    // Create a framer for the Video Elementary Stream:
+    videoSource = MPEG1or2VideoStreamFramer::createNew(*env, videoES, iFramesOnly);
+
+    // Finally, start playing:
+    *env << "Beginning to read from file...\n";
+    videoSink->startPlaying(*videoSource, afterPlaying, videoSink);
+}
diff --git a/3rdparty/live555/src/testProgs/testMPEG2Transport.sdp b/3rdparty/live555/src/testProgs/testMPEG2Transport.sdp
new file mode 100644
index 00000000..5d2d69f5
--- /dev/null
+++ b/3rdparty/live555/src/testProgs/testMPEG2Transport.sdp
@@ -0,0 +1,9 @@
+v=0
+o=- 49451 3 IN IP4 127.0.0.1
+s=Test MPEG-2 Transport Stream session
+i=Parameters for the session streamed by "testMPEG2TransportStreamer"
+t=0 0
+a=tool:testMPEG2TransportStreamer
+a=type:broadcast
+m=video 1234 RTP/AVP 33
+c=IN IP4 239.255.42.42/127
diff --git a/3rdparty/live555/src/testProgs/testMPEG2TransportReceiver.cpp b/3rdparty/live555/src/testProgs/testMPEG2TransportReceiver.cpp
new file mode 100644
index 00000000..85e81c15
--- /dev/null
+++ b/3rdparty/live555/src/testProgs/testMPEG2TransportReceiver.cpp
@@ -0,0 +1,117 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// Copyright (c) 1996-2022, Live Networks, Inc.  All rights reserved
+// A test program that receives a RTP/RTCP multicast MPEG-2 Transport Stream,
+// and outputs the resulting Transport Stream data to 'stdout'
+// main program
+
+#include "liveMedia.hh"
+#include "GroupsockHelper.hh"
+
+#include "BasicUsageEnvironment.hh"
+
+// To receive a "source-specific multicast" (SSM) stream, uncomment this:
+//#define USE_SSM 1
+
+void afterPlaying(void *clientData);  // forward
+
+// A structure to hold the state of the current session.
+// It is used in the "afterPlaying()" function to clean up the session.
+struct sessionState_t {
+    RTPSource *   source;
+    MediaSink *   sink;
+    RTCPInstance *rtcpInstance;
+} sessionState;
+
+UsageEnvironment *env;
+
+int main(int argc, char **argv) {
+    // Begin by setting up our usage environment:
+    TaskScheduler *scheduler = BasicTaskScheduler::createNew();
+    env                      = BasicUsageEnvironment::createNew(*scheduler);
+
+    // Create the data sink for 'stdout':
+    sessionState.sink = FileSink::createNew(*env, "stdout");
+    // Note: The string "stdout" is handled as a special case.
+    // A real file name could have been used instead.
+
+    // Create 'groupsocks' for RTP and RTCP:
+    char const *sessionAddressStr
+#ifdef USE_SSM
+        = "232.255.42.42";
+#else
+        = "239.255.42.42";
+    // Note: If the session is unicast rather than multicast,
+    // then replace this string with "0.0.0.0"
+#endif
+    const unsigned short rtpPortNum  = 1234;
+    const unsigned short rtcpPortNum = rtpPortNum + 1;
+#ifndef USE_SSM
+    const unsigned char ttl = 1;  // low, in case routers don't admin scope
+#endif
+
+    NetAddressList          sessionAddresses(sessionAddressStr);
+    struct sockaddr_storage sessionAddress;
+    copyAddress(sessionAddress, sessionAddresses.firstAddress());
+
+    const Port rtpPort(rtpPortNum);
+    const Port rtcpPort(rtcpPortNum);
+
+#ifdef USE_SSM
+    char const *sourceAddressStr = "aaa.bbb.ccc.ddd";
+    // replace this with the real source address
+    NetAddressList          sourceFilterAddresses(sourceAddressStr);
+    struct sockaddr_storage sourceFilterAddress;
+    copyAddress(sourceFilterAddress, sourceFilterAddresses.firstAddress());
+
+    Groupsock rtpGroupsock(*env, sessionAddress, sourceFilterAddress, rtpPort);
+    Groupsock rtcpGroupsock(*env, sessionAddress, sourceFilterAddress, rtcpPort);
+    rtcpGroupsock.changeDestinationParameters(sourceFilterAddress, 0, ~0);
+    // our RTCP "RR"s are sent back using unicast
+#else
+    Groupsock rtpGroupsock(*env, sessionAddress, rtpPort, ttl);
+    Groupsock rtcpGroupsock(*env, sessionAddress, rtcpPort, ttl);
+#endif
+
+    // Create the data source: a "MPEG-2 TransportStream RTP source" (which uses a 'simple' RTP payload format):
+    sessionState.source = SimpleRTPSource::createNew(*env, &rtpGroupsock, 33, 90000, "video/MP2T", 0, False /*no 'M' bit*/);
+
+    // Create (and start) a 'RTCP instance' for the RTP source:
+    const unsigned estimatedSessionBandwidth = 5000;  // in kbps; for RTCP b/w share
+    const unsigned maxCNAMElen               = 100;
+    unsigned char  CNAME[maxCNAMElen + 1];
+    gethostname((char *)CNAME, maxCNAMElen);
+    CNAME[maxCNAMElen]        = '\0';  // just in case
+    sessionState.rtcpInstance = RTCPInstance::createNew(*env, &rtcpGroupsock, estimatedSessionBandwidth, CNAME, NULL /* we're a client */, sessionState.source);
+    // Note: This starts RTCP running automatically
+
+    // Finally, start receiving the multicast stream:
+    *env << "Beginning receiving multicast stream...\n";
+    sessionState.sink->startPlaying(*sessionState.source, afterPlaying, NULL);
+
+    env->taskScheduler().doEventLoop();  // does not return
+
+    return 0;  // only to prevent compiler warning
+}
+
+void afterPlaying(void * /*clientData*/) {
+    *env << "...done receiving\n";
+
+    // End by closing the media:
+    Medium::close(sessionState.rtcpInstance);  // Note: Sends a RTCP BYE
+    Medium::close(sessionState.sink);
+    Medium::close(sessionState.source);
+}
diff --git a/3rdparty/live555/src/testProgs/testMPEG2TransportStreamSplitter.cpp b/3rdparty/live555/src/testProgs/testMPEG2TransportStreamSplitter.cpp
new file mode 100644
index 00000000..302fa633
--- /dev/null
+++ b/3rdparty/live555/src/testProgs/testMPEG2TransportStreamSplitter.cpp
@@ -0,0 +1,65 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// Copyright (c) 1996-2022, Live Networks, Inc.  All rights reserved
+// A test program that splits a MPEG Transport Stream input (on 'stdin')
+// into separate video and audio output files.
+// main program
+
+#include <liveMedia.hh>
+#include <BasicUsageEnvironment.hh>
+
+UsageEnvironment *         env;
+char const *               programName;
+char const *               inputFileName     = "stdin";
+MPEG2TransportStreamDemux *baseDemultiplexor = NULL;
+
+void usage() {
+    *env << "usage: " << programName << " takes no arguments (it reads from \"stdin\")\n";
+    exit(1);
+}
+
+void afterReading(void *);
+
+int main(int argc, char **argv) {
+    // Begin by setting up our usage environment:
+    TaskScheduler *scheduler = BasicTaskScheduler::createNew();
+    env                      = BasicUsageEnvironment::createNew(*scheduler);
+
+    // Parse the command line:
+    programName = argv[0];
+    if(argc != 1)
+        usage();
+
+    // Open the input file as a 'byte-stream file source':
+    ByteStreamFileSource *inputSource = ByteStreamFileSource::createNew(*env, inputFileName);
+    if(inputSource == NULL) {
+        *env << "Unable to open file \"" << inputFileName << "\" as a byte-stream file source\n";
+        exit(1);
+    }
+
+    // Create a demultiplexor that reads from that source, creating new 'demultiplexed tracks'
+    // as they appear:
+    baseDemultiplexor = MPEG2TransportStreamDemux::createNew(*env, inputSource, afterReading, NULL);
+
+    env->taskScheduler().doEventLoop();  // does not return
+
+    return 0;  // only to prevent compiler warning
+}
+
+void afterReading(void * /*clientData*/) {
+    *env << "...done\n";
+    exit(0);
+}
diff --git a/3rdparty/live555/src/testProgs/testMPEG2TransportStreamTrickPlay.cpp b/3rdparty/live555/src/testProgs/testMPEG2TransportStreamTrickPlay.cpp
new file mode 100644
index 00000000..3c84521b
--- /dev/null
+++ b/3rdparty/live555/src/testProgs/testMPEG2TransportStreamTrickPlay.cpp
@@ -0,0 +1,123 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// Copyright (c) 1996-2022, Live Networks, Inc.  All rights reserved
+// A program that tests 'trick mode' operations on a MPEG-2 Transport Stream file,
+// by generating a new Transport Stream file that represents the result of the
+// 'trick mode' operation (seeking and/or fast forward/reverse play).
+// For this to work, there must also be an index file present, in the same directory
+// as the Transport Stream file, and with the same name prefix.  (The Transport
+// Stream file has name suffix ".ts"; the index file has name suffix ".tsx".)
+// main program
+
+#include <liveMedia.hh>
+#include <BasicUsageEnvironment.hh>
+
+void afterPlaying(void *clientData);  // forward
+
+UsageEnvironment *env;
+char const *      programName;
+
+void usage() {
+    *env << "usage: " << programName << " <input-transport-stream-file-name> <start-time> <scale> <output-transport-stream-file-name>\n";
+    *env << "\twhere\t<transport-stream-file-name> ends with \".ts\"\n";
+    *env << "\t\t<start-time> is the starting play time in seconds (0 for the start)\n";
+    *env << "\t\t<scale> is a non-zero integer, representing the playing speed (use 1 for normal play; use a negative number for reverse play)\n";
+    exit(1);
+}
+
+int main(int argc, char const **argv) {
+    // Begin by setting up our usage environment:
+    TaskScheduler *scheduler = BasicTaskScheduler::createNew();
+    env                      = BasicUsageEnvironment::createNew(*scheduler);
+
+    // Parse the command line:
+    programName = argv[0];
+    if(argc != 5)
+        usage();
+
+    char const *inputFileName = argv[1];
+    // Check whether the input file name ends with ".ts":
+    int len = strlen(inputFileName);
+    if(len < 4 || strcmp(&inputFileName[len - 3], ".ts") != 0) {
+        *env << "ERROR: input file name \"" << inputFileName << "\" does not end with \".ts\"\n";
+        usage();
+    }
+
+    // Parse the <start-time> and <scale> parameters:
+    float startTime;
+    if(sscanf(argv[2], "%f", &startTime) != 1 || startTime < 0.0f)
+        usage();
+
+    int scale;
+    if(sscanf(argv[3], "%d", &scale) != 1 || scale == 0)
+        usage();
+
+    // Open the input file (as a 'byte stream file source'):
+    FramedSource *input = ByteStreamFileSource::createNew(*env, inputFileName, TRANSPORT_PACKET_SIZE);
+    if(input == NULL) {
+        *env << "Failed to open input file \"" << inputFileName << "\" (does it exist?)\n";
+        exit(1);
+    }
+
+    // Check whether the corresponding index file exists.
+    // The index file name is the same as the input file name, except with suffix ".tsx":
+    char *indexFileName = new char[len + 2];  // allow for trailing x\0
+    sprintf(indexFileName, "%sx", inputFileName);
+    MPEG2TransportStreamIndexFile *indexFile = MPEG2TransportStreamIndexFile::createNew(*env, indexFileName);
+    if(indexFile == NULL) {
+        *env << "Failed to open index file \"" << indexFileName << "\" (does it exist?)\n";
+        exit(1);
+    }
+
+    // Create a filter that generates trick mode data from the input and index files:
+    MPEG2TransportStreamTrickModeFilter *trickModeFilter = MPEG2TransportStreamTrickModeFilter::createNew(*env, input, indexFile, scale);
+
+    if(startTime > 0.0f) {
+        // Seek the input Transport Stream and Index files to the specified start time:
+        unsigned long tsRecordNumber, indexRecordNumber;
+        indexFile->lookupTSPacketNumFromNPT(startTime, tsRecordNumber, indexRecordNumber);
+        if(!trickModeFilter->seekTo(tsRecordNumber, indexRecordNumber)) {  // TARFU!
+            *env << "Failed to seek trick mode filter to ts #" << (unsigned)tsRecordNumber << ", ix #" << (unsigned)indexRecordNumber << "(for time "
+                 << startTime << ")\n";
+            exit(1);
+        }
+    }
+
+    // Generate a new Transport Stream from the Trick Mode filter:
+    MPEG2TransportStreamFromESSource *newTransportStream = MPEG2TransportStreamFromESSource::createNew(*env);
+    newTransportStream->addNewVideoSource(trickModeFilter, indexFile->mpegVersion());
+
+    // Open the output file (for writing), as a 'file sink':
+    char const *outputFileName = argv[4];
+    MediaSink * output         = FileSink::createNew(*env, outputFileName);
+    if(output == NULL) {
+        *env << "Failed to open output file \"" << outputFileName << "\"\n";
+        exit(1);
+    }
+
+    // Start playing, to generate the output file:
+    *env << "Writing output file \"" << outputFileName << "\" (start time " << startTime << ", scale " << scale << ")...";
+    output->startPlaying(*newTransportStream, afterPlaying, NULL);
+
+    env->taskScheduler().doEventLoop();  // does not return
+
+    return 0;  // only to prevent compiler warning
+}
+
+void afterPlaying(void * /*clientData*/) {
+    *env << "...done\n";
+    exit(0);
+}
diff --git a/3rdparty/live555/src/testProgs/testMPEG2TransportStreamer.cpp b/3rdparty/live555/src/testProgs/testMPEG2TransportStreamer.cpp
new file mode 100644
index 00000000..53d5d1b9
--- /dev/null
+++ b/3rdparty/live555/src/testProgs/testMPEG2TransportStreamer.cpp
@@ -0,0 +1,159 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// Copyright (c) 1996-2022, Live Networks, Inc.  All rights reserved
+// A test program that reads a MPEG-2 Transport Stream file,
+// and streams it using RTP
+// main program
+
+#include "liveMedia.hh"
+
+#include "BasicUsageEnvironment.hh"
+#include "announceURL.hh"
+#include "GroupsockHelper.hh"
+
+// To stream using "source-specific multicast" (SSM), uncomment the following:
+//#define USE_SSM 1
+
+// To stream using IPv6 multicast, rather than IPv4 multicast, uncomment the following:
+//#define USE_IPV6_MULTICAST 1
+
+// To set up an internal RTSP server, uncomment the following:
+//#define IMPLEMENT_RTSP_SERVER 1
+// (Note that this RTSP server works for multicast only)
+
+#ifdef USE_SSM
+Boolean const isSSM = True;
+#else
+Boolean const isSSM = False;
+#endif
+
+#define TRANSPORT_PACKET_SIZE 188
+#define TRANSPORT_PACKETS_PER_NETWORK_PACKET 7
+// The product of these two numbers must be enough to fit within a network packet
+
+UsageEnvironment *env;
+char const *      inputFileName = "test.ts";
+FramedSource *    videoSource;
+RTPSink *         videoSink;
+
+void play();  // forward
+
+int main(int argc, char **argv) {
+    // Begin by setting up our usage environment:
+    TaskScheduler *scheduler = BasicTaskScheduler::createNew();
+    env                      = BasicUsageEnvironment::createNew(*scheduler);
+
+    // Create 'groupsocks' for RTP and RTCP:
+    char const *destinationAddressStr
+#ifdef USE_IPV6_MULTICAST
+#ifdef USE_SSM
+        = "FF3E::FFFF:2A2A";
+#else
+        = "FF1E::FFFF:2A2A";
+#endif
+#else
+#ifdef USE_SSM
+        = "232.255.42.42";
+#else
+        = "239.255.42.42";
+#endif
+#endif
+    // Note: This is a multicast address.  If you wish to stream using
+    // unicast instead, then replace this string with the unicast address
+    // of the (single) destination.  (You may also need to make a similar
+    // change to the receiver program.)
+
+    const unsigned short rtpPortNum  = 1234;
+    const unsigned short rtcpPortNum = rtpPortNum + 1;
+    const unsigned char  ttl         = 7;  // low, in case routers don't admin scope
+
+    NetAddressList          destinationAddresses(destinationAddressStr);
+    struct sockaddr_storage destinationAddress;
+    copyAddress(destinationAddress, destinationAddresses.firstAddress());
+
+    const Port rtpPort(rtpPortNum);
+    const Port rtcpPort(rtcpPortNum);
+
+    Groupsock rtpGroupsock(*env, destinationAddress, rtpPort, ttl);
+    Groupsock rtcpGroupsock(*env, destinationAddress, rtcpPort, ttl);
+#ifdef USE_SSM
+    rtpGroupsock.multicastSendOnly();
+    rtcpGroupsock.multicastSendOnly();
+#endif
+
+    // Create an appropriate 'RTP sink' from the RTP 'groupsock':
+    videoSink = SimpleRTPSink::createNew(*env, &rtpGroupsock, 33, 90000, "video", "MP2T", 1, True, False /*no 'M' bit*/);
+
+    // Create (and start) a 'RTCP instance' for this RTP sink:
+    const unsigned estimatedSessionBandwidth = 5000;  // in kbps; for RTCP b/w share
+    const unsigned maxCNAMElen               = 100;
+    unsigned char  CNAME[maxCNAMElen + 1];
+    gethostname((char *)CNAME, maxCNAMElen);
+    CNAME[maxCNAMElen] = '\0';  // just in case
+#ifdef IMPLEMENT_RTSP_SERVER
+    RTCPInstance *rtcp =
+#endif
+        RTCPInstance::createNew(*env, &rtcpGroupsock, estimatedSessionBandwidth, CNAME, videoSink, NULL /* we're a server */, isSSM);
+    // Note: This starts RTCP running automatically
+
+#ifdef IMPLEMENT_RTSP_SERVER
+    RTSPServer *rtspServer = RTSPServer::createNew(*env, 8554);
+    if(rtspServer == NULL) {
+        *env << "Failed to create RTSP server: " << env->getResultMsg() << "\n";
+        exit(1);
+    }
+    ServerMediaSession *sms = ServerMediaSession::createNew(*env, "testStream", inputFileName, "Session streamed by \"testMPEG2TransportStreamer\"", isSSM);
+    sms->addSubsession(PassiveServerMediaSubsession::createNew(*videoSink, rtcp));
+    rtspServer->addServerMediaSession(sms);
+    announceURL(rtspServer, sms);
+#endif
+
+    // Finally, start the streaming:
+    *env << "Beginning streaming...\n";
+    play();
+
+    env->taskScheduler().doEventLoop();  // does not return
+
+    return 0;  // only to prevent compiler warning
+}
+
+void afterPlaying(void * /*clientData*/) {
+    *env << "...done reading from file\n";
+
+    videoSink->stopPlaying();
+    Medium::close(videoSource);
+    // Note that this also closes the input file that this source read from.
+
+    play();
+}
+
+void play() {
+    unsigned const inputDataChunkSize = TRANSPORT_PACKETS_PER_NETWORK_PACKET * TRANSPORT_PACKET_SIZE;
+
+    // Open the input file as a 'byte-stream file source':
+    ByteStreamFileSource *fileSource = ByteStreamFileSource::createNew(*env, inputFileName, inputDataChunkSize);
+    if(fileSource == NULL) {
+        *env << "Unable to open file \"" << inputFileName << "\" as a byte-stream file source\n";
+        exit(1);
+    }
+
+    // Create a 'framer' for the input source (to give us proper inter-packet gaps):
+    videoSource = MPEG2TransportStreamFramer::createNew(*env, fileSource);
+
+    // Finally, start playing:
+    *env << "Beginning to read from file...\n";
+    videoSink->startPlaying(*videoSource, afterPlaying, videoSink);
+}
diff --git a/3rdparty/live555/src/testProgs/testMPEG4VideoStreamer.cpp b/3rdparty/live555/src/testProgs/testMPEG4VideoStreamer.cpp
new file mode 100644
index 00000000..b652ccf5
--- /dev/null
+++ b/3rdparty/live555/src/testProgs/testMPEG4VideoStreamer.cpp
@@ -0,0 +1,118 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// Copyright (c) 1996-2022, Live Networks, Inc.  All rights reserved
+// A test program that reads a MPEG-4 Video Elementary Stream file,
+// and streams it using RTP
+// main program
+
+#include "liveMedia.hh"
+
+#include "BasicUsageEnvironment.hh"
+#include "announceURL.hh"
+#include "GroupsockHelper.hh"
+
+UsageEnvironment *      env;
+char const *            inputFileName = "test.m4e";
+MPEG4VideoStreamFramer *videoSource;
+RTPSink *               videoSink;
+
+void play();  // forward
+
+int main(int argc, char **argv) {
+    // Begin by setting up our usage environment:
+    TaskScheduler *scheduler = BasicTaskScheduler::createNew();
+    env                      = BasicUsageEnvironment::createNew(*scheduler);
+
+    // Create 'groupsocks' for RTP and RTCP:
+    struct sockaddr_storage destinationAddress;
+    destinationAddress.ss_family                               = AF_INET;
+    ((struct sockaddr_in &)destinationAddress).sin_addr.s_addr = chooseRandomIPv4SSMAddress(*env);
+    // Note: This is a multicast address.  If you wish instead to stream
+    // using unicast, then you should use the "testOnDemandRTSPServer"
+    // test program - not this test program - as a model.
+
+    const unsigned short rtpPortNum  = 18888;
+    const unsigned short rtcpPortNum = rtpPortNum + 1;
+    const unsigned char  ttl         = 255;
+
+    const Port rtpPort(rtpPortNum);
+    const Port rtcpPort(rtcpPortNum);
+
+    Groupsock rtpGroupsock(*env, destinationAddress, rtpPort, ttl);
+    rtpGroupsock.multicastSendOnly();  // we're a SSM source
+    Groupsock rtcpGroupsock(*env, destinationAddress, rtcpPort, ttl);
+    rtcpGroupsock.multicastSendOnly();  // we're a SSM source
+
+    // Create a 'MPEG-4 Video RTP' sink from the RTP 'groupsock':
+    videoSink = MPEG4ESVideoRTPSink::createNew(*env, &rtpGroupsock, 96);
+
+    // Create (and start) a 'RTCP instance' for this RTP sink:
+    const unsigned estimatedSessionBandwidth = 500;  // in kbps; for RTCP b/w share
+    const unsigned maxCNAMElen               = 100;
+    unsigned char  CNAME[maxCNAMElen + 1];
+    gethostname((char *)CNAME, maxCNAMElen);
+    CNAME[maxCNAMElen] = '\0';  // just in case
+    RTCPInstance *rtcp =
+        RTCPInstance::createNew(*env, &rtcpGroupsock, estimatedSessionBandwidth, CNAME, videoSink, NULL /* we're a server */, True /* we're a SSM source */);
+    // Note: This starts RTCP running automatically
+
+    RTSPServer *rtspServer = RTSPServer::createNew(*env, 8554);
+    if(rtspServer == NULL) {
+        *env << "Failed to create RTSP server: " << env->getResultMsg() << "\n";
+        exit(1);
+    }
+    ServerMediaSession *sms = ServerMediaSession::createNew(*env, "testStream", inputFileName, "Session streamed by \"testMPEG4VideoStreamer\"", True /*SSM*/);
+    sms->addSubsession(PassiveServerMediaSubsession::createNew(*videoSink, rtcp));
+    rtspServer->addServerMediaSession(sms);
+    announceURL(rtspServer, sms);
+
+    // Start the streaming:
+    *env << "Beginning streaming...\n";
+    play();
+
+    env->taskScheduler().doEventLoop();  // does not return
+
+    return 0;  // only to prevent compiler warning
+}
+
+void afterPlaying(void * /*clientData*/) {
+    *env << "...done reading from file\n";
+
+    videoSink->stopPlaying();
+    Medium::close(videoSource);
+    // Note that this also closes the input file that this source read from.
+
+    // Start playing once again:
+    play();
+}
+
+void play() {
+    // Open the input file as a 'byte-stream file source':
+    ByteStreamFileSource *fileSource = ByteStreamFileSource::createNew(*env, inputFileName);
+    if(fileSource == NULL) {
+        *env << "Unable to open file \"" << inputFileName << "\" as a byte-stream file source\n";
+        exit(1);
+    }
+
+    FramedSource *videoES = fileSource;
+
+    // Create a framer for the Video Elementary Stream:
+    videoSource = MPEG4VideoStreamFramer::createNew(*env, videoES);
+
+    // Finally, start playing:
+    *env << "Beginning to read from file...\n";
+    videoSink->startPlaying(*videoSource, afterPlaying, videoSink);
+}
diff --git a/3rdparty/live555/src/testProgs/testOggStreamer.cpp b/3rdparty/live555/src/testProgs/testOggStreamer.cpp
new file mode 100644
index 00000000..2c9d45a3
--- /dev/null
+++ b/3rdparty/live555/src/testProgs/testOggStreamer.cpp
@@ -0,0 +1,175 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+**********/
+// Copyright (c) 1996-2022, Live Networks, Inc.  All rights reserved
+// A test program that reads a ".ogg" (i.e., Ogg) file, demultiplexes each track
+// (audio and/or video), and streams each track using RTP multicast.
+// main program
+
+#include <liveMedia.hh>
+
+#include <BasicUsageEnvironment.hh>
+#include "announceURL.hh"
+#include <GroupsockHelper.hh>
+
+UsageEnvironment *      env;
+char const *            inputFileName = "test.ogg";
+struct sockaddr_storage destinationAddress;
+RTSPServer *            rtspServer;
+ServerMediaSession *    sms;
+OggFile *               oggFile;
+OggDemux *              oggDemux;
+unsigned                numTracks;
+
+// A structure representing the state of a track:
+struct TrackState {
+    u_int32_t     trackNumber;
+    FramedSource *source;
+    RTPSink *     sink;
+    RTCPInstance *rtcp;
+};
+TrackState *trackState;
+
+void onOggFileCreation(OggFile *newFile, void *clientData);  // forward
+
+int main(int argc, char **argv) {
+    // Begin by setting up our usage environment:
+    TaskScheduler *scheduler = BasicTaskScheduler::createNew();
+    env                      = BasicUsageEnvironment::createNew(*scheduler);
+
+    // Define our destination (multicast) IP address:
+    destinationAddress.ss_family                               = AF_INET;
+    ((struct sockaddr_in &)destinationAddress).sin_addr.s_addr = chooseRandomIPv4SSMAddress(*env);
+    // Note: This is a multicast address.  If you wish instead to stream
+    // using unicast, then you should use the "testOnDemandRTSPServer"
+    // test program - not this test program - as a model.
+
+    // Create our RTSP server.  (Receivers will need to use RTSP to access the stream.)
+    rtspServer = RTSPServer::createNew(*env, 8554);
+    if(rtspServer == NULL) {
+        *env << "Failed to create RTSP server: " << env->getResultMsg() << "\n";
+        exit(1);
+    }
+    sms = ServerMediaSession::createNew(*env, "testStream", inputFileName, "Session streamed by \"testMKVStreamer\"", True /*SSM*/);
+
+    // Arrange to create an "OggFile" object for the specified file.
+    // (Note that this object is not created immediately, but instead via a callback.)
+    OggFile::createNew(*env, inputFileName, onOggFileCreation, NULL);
+
+    env->taskScheduler().doEventLoop();  // does not return
+
+    return 0;  // only to prevent compiler warning
+}
+
+void play();  // forward
+
+void onOggFileCreation(OggFile *newFile, void *clientData) {
+    oggFile = newFile;
+
+    // Create a new demultiplexor for the file:
+    oggDemux = oggFile->newDemux();
+
+    // Create source streams, "RTPSink"s, and "RTCPInstance"s for each preferred track;
+    unsigned short      rtpPortNum = 22222;
+    const unsigned char ttl        = 255;
+
+    const unsigned maxCNAMElen = 100;
+    unsigned char  CNAME[maxCNAMElen + 1];
+    gethostname((char *)CNAME, maxCNAMElen);
+    CNAME[maxCNAMElen] = '\0';  // just in case
+
+    numTracks  = oggFile->numTracks();
+    trackState = new TrackState[numTracks];
+    for(unsigned i = 0; i < numTracks; ++i) {
+        u_int32_t     trackNumber;
+        FramedSource *baseSource  = oggDemux->newDemuxedTrack(trackNumber);
+        trackState[i].trackNumber = trackNumber;
+
+        unsigned estBitrate, numFiltersInFrontOfTrack;
+        trackState[i].source = oggFile->createSourceForStreaming(baseSource, trackNumber, estBitrate, numFiltersInFrontOfTrack);
+        trackState[i].sink   = NULL;  // by default; may get changed below
+        trackState[i].rtcp   = NULL;  // ditto
+
+        if(trackState[i].source != NULL) {
+            Groupsock *rtpGroupsock  = new Groupsock(*env, destinationAddress, rtpPortNum, ttl);
+            Groupsock *rtcpGroupsock = new Groupsock(*env, destinationAddress, rtpPortNum + 1, ttl);
+            rtpPortNum += 2;
+
+            trackState[i].sink = oggFile->createRTPSinkForTrackNumber(trackNumber, rtpGroupsock, 96 + i);
+            if(trackState[i].sink != NULL) {
+                if(trackState[i].sink->estimatedBitrate() > 0) {
+                    estBitrate = trackState[i].sink->estimatedBitrate();  // hack
+                }
+                trackState[i].rtcp = RTCPInstance::createNew(*env, rtcpGroupsock, estBitrate, CNAME, trackState[i].sink, NULL /* we're a server */,
+                                                             True /* we're a SSM source */);
+                // Note: This starts RTCP running automatically
+
+                // Having set up a track for streaming, add it to our RTSP server's "ServerMediaSession":
+                sms->addSubsession(PassiveServerMediaSubsession::createNew(*trackState[i].sink, trackState[i].rtcp));
+            }
+        }
+    }
+
+    if(sms->numSubsessions() == 0) {
+        *env << "Error: The Ogg file \"" << inputFileName << "\" has no streamable tracks\n";
+        *env << "(Perhaps the file does not exist, is not an 'Ogg' file, or has no tracks that we know how to stream.)\n";
+        exit(1);
+    }
+
+    rtspServer->addServerMediaSession(sms);
+    announceURL(rtspServer, sms);
+
+    // Start the streaming:
+    play();
+}
+
+void afterPlaying(void * /*clientData*/) {
+    *env << "...done reading from file\n";
+
+    // Stop playing all "RTPSink"s, then close the source streams
+    // (which will also close the demultiplexor itself):
+    unsigned i;
+    for(i = 0; i < numTracks; ++i) {
+        if(trackState[i].sink != NULL)
+            trackState[i].sink->stopPlaying();
+        Medium::close(trackState[i].source);
+        trackState[i].source = NULL;
+    }
+
+    // Create a new demultiplexor from our Ogg file, then new data sources for each track:
+    oggDemux = oggFile->newDemux();
+    for(i = 0; i < numTracks; ++i) {
+        if(trackState[i].trackNumber != 0) {
+            FramedSource *baseSource = oggDemux->newDemuxedTrack(trackState[i].trackNumber);
+
+            unsigned estBitrate, numFiltersInFrontOfTrack;
+            trackState[i].source = oggFile->createSourceForStreaming(baseSource, trackState[i].trackNumber, estBitrate, numFiltersInFrontOfTrack);
+        }
+    }
+
+    // Start playing once again:
+    play();
+}
+
+void play() {
+    *env << "Beginning to read from file...\n";
+
+    // Start playing each track's RTP sink from its corresponding source:
+    for(unsigned i = 0; i < numTracks; ++i) {
+        if(trackState[i].sink != NULL && trackState[i].source != NULL) {
+            trackState[i].sink->startPlaying(*trackState[i].source, afterPlaying, NULL);
+        }
+    }
+}
diff --git a/3rdparty/live555/src/testProgs/testOnDemandRTSPServer.cpp b/3rdparty/live555/src/testProgs/testOnDemandRTSPServer.cpp
new file mode 100644
index 00000000..23245912
--- /dev/null
+++ b/3rdparty/live555/src/testProgs/testOnDemandRTSPServer.cpp
@@ -0,0 +1,400 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// Copyright (c) 1996-2022, Live Networks, Inc.  All rights reserved
+// A test program that demonstrates how to stream - via unicast RTP
+// - various kinds of file on demand, using a built-in RTSP server.
+// main program
+
+#include "liveMedia.hh"
+
+#include "BasicUsageEnvironment.hh"
+#include "announceURL.hh"
+
+UsageEnvironment *env;
+
+// To make the second and subsequent client for each stream reuse the same
+// input stream as the first client (rather than playing the file from the
+// start for each client), change the following "False" to "True":
+Boolean reuseFirstSource = False;
+
+// To stream *only* MPEG-1 or 2 video "I" frames
+// (e.g., to reduce network bandwidth),
+// change the following "False" to "True":
+Boolean iFramesOnly = False;
+
+static void announceStream(RTSPServer *rtspServer, ServerMediaSession *sms, char const *streamName, char const *inputFileName);  // forward
+
+static char newDemuxWatchVariable;
+
+static MatroskaFileServerDemux *matroskaDemux;
+static void                     onMatroskaDemuxCreation(MatroskaFileServerDemux *newDemux, void * /*clientData*/) {
+    matroskaDemux         = newDemux;
+    newDemuxWatchVariable = 1;
+}
+
+static OggFileServerDemux *oggDemux;
+static void                onOggDemuxCreation(OggFileServerDemux *newDemux, void * /*clientData*/) {
+    oggDemux              = newDemux;
+    newDemuxWatchVariable = 1;
+}
+
+int main(int argc, char **argv) {
+    // Begin by setting up our usage environment:
+    TaskScheduler *scheduler = BasicTaskScheduler::createNew();
+    env                      = BasicUsageEnvironment::createNew(*scheduler);
+
+    UserAuthenticationDatabase *authDB = NULL;
+#ifdef ACCESS_CONTROL
+    // To implement client access control to the RTSP server, do the following:
+    authDB = new UserAuthenticationDatabase;
+    authDB->addUserRecord("username1", "password1");  // replace these with real strings
+                                                      // Repeat the above with each <username>, <password> that you wish to allow
+                                                      // access to the server.
+#endif
+
+    // Create the RTSP server:
+    RTSPServer *rtspServer = RTSPServer::createNew(*env, 8554, authDB);
+    if(rtspServer == NULL) {
+        *env << "Failed to create RTSP server: " << env->getResultMsg() << "\n";
+        exit(1);
+    }
+
+    char const *descriptionString = "Session streamed by \"testOnDemandRTSPServer\"";
+
+    // Set up each of the possible streams that can be served by the
+    // RTSP server.  Each such stream is implemented using a
+    // "ServerMediaSession" object, plus one or more
+    // "ServerMediaSubsession" objects for each audio/video substream.
+
+    // A MPEG-4 video elementary stream:
+    {
+        char const *        streamName    = "mpeg4ESVideoTest";
+        char const *        inputFileName = "test.m4e";
+        ServerMediaSession *sms           = ServerMediaSession::createNew(*env, streamName, streamName, descriptionString);
+        sms->addSubsession(MPEG4VideoFileServerMediaSubsession ::createNew(*env, inputFileName, reuseFirstSource));
+        rtspServer->addServerMediaSession(sms);
+
+        announceStream(rtspServer, sms, streamName, inputFileName);
+    }
+
+    // A H.264 video elementary stream:
+    {
+        char const *        streamName    = "h264ESVideoTest";
+        char const *        inputFileName = "test.264";
+        ServerMediaSession *sms           = ServerMediaSession::createNew(*env, streamName, streamName, descriptionString);
+        sms->addSubsession(H264VideoFileServerMediaSubsession ::createNew(*env, inputFileName, reuseFirstSource));
+        rtspServer->addServerMediaSession(sms);
+
+        announceStream(rtspServer, sms, streamName, inputFileName);
+    }
+
+    // A H.265 video elementary stream:
+    {
+        char const *        streamName    = "h265ESVideoTest";
+        char const *        inputFileName = "test.265";
+        ServerMediaSession *sms           = ServerMediaSession::createNew(*env, streamName, streamName, descriptionString);
+        sms->addSubsession(H265VideoFileServerMediaSubsession ::createNew(*env, inputFileName, reuseFirstSource));
+        rtspServer->addServerMediaSession(sms);
+
+        announceStream(rtspServer, sms, streamName, inputFileName);
+    }
+
+    // A MPEG-1 or 2 audio+video program stream:
+    {
+        char const *streamName    = "mpeg1or2AudioVideoTest";
+        char const *inputFileName = "test.mpg";
+        // NOTE: This *must* be a Program Stream; not an Elementary Stream
+        ServerMediaSession *     sms   = ServerMediaSession::createNew(*env, streamName, streamName, descriptionString);
+        MPEG1or2FileServerDemux *demux = MPEG1or2FileServerDemux::createNew(*env, inputFileName, reuseFirstSource);
+        sms->addSubsession(demux->newVideoServerMediaSubsession(iFramesOnly));
+        sms->addSubsession(demux->newAudioServerMediaSubsession());
+        rtspServer->addServerMediaSession(sms);
+
+        announceStream(rtspServer, sms, streamName, inputFileName);
+    }
+
+    // A MPEG-1 or 2 video elementary stream:
+    {
+        char const *streamName    = "mpeg1or2ESVideoTest";
+        char const *inputFileName = "testv.mpg";
+        // NOTE: This *must* be a Video Elementary Stream; not a Program Stream
+        ServerMediaSession *sms = ServerMediaSession::createNew(*env, streamName, streamName, descriptionString);
+        sms->addSubsession(MPEG1or2VideoFileServerMediaSubsession ::createNew(*env, inputFileName, reuseFirstSource, iFramesOnly));
+        rtspServer->addServerMediaSession(sms);
+
+        announceStream(rtspServer, sms, streamName, inputFileName);
+    }
+
+    // A MP3 audio stream (actually, any MPEG-1 or 2 audio file will work):
+    // To stream using 'ADUs' rather than raw MP3 frames, uncomment the following:
+    //#define STREAM_USING_ADUS 1
+    // To also reorder ADUs before streaming, uncomment the following:
+    //#define INTERLEAVE_ADUS 1
+    // (For more information about ADUs and interleaving,
+    //  see <http://www.live555.com/rtp-mp3/>)
+    {
+        char const *        streamName    = "mp3AudioTest";
+        char const *        inputFileName = "test.mp3";
+        ServerMediaSession *sms           = ServerMediaSession::createNew(*env, streamName, streamName, descriptionString);
+        Boolean             useADUs       = False;
+        Interleaving *      interleaving  = NULL;
+#ifdef STREAM_USING_ADUS
+        useADUs = True;
+#ifdef INTERLEAVE_ADUS
+        unsigned char  interleaveCycle[]   = { 0, 2, 1, 3 };  // or choose your own...
+        unsigned const interleaveCycleSize = (sizeof interleaveCycle) / (sizeof(unsigned char));
+        interleaving                       = new Interleaving(interleaveCycleSize, interleaveCycle);
+#endif
+#endif
+        sms->addSubsession(MP3AudioFileServerMediaSubsession ::createNew(*env, inputFileName, reuseFirstSource, useADUs, interleaving));
+        rtspServer->addServerMediaSession(sms);
+
+        announceStream(rtspServer, sms, streamName, inputFileName);
+    }
+
+    // A WAV audio stream:
+    {
+        char const *        streamName    = "wavAudioTest";
+        char const *        inputFileName = "test.wav";
+        ServerMediaSession *sms           = ServerMediaSession::createNew(*env, streamName, streamName, descriptionString);
+        // To convert 16-bit PCM data to 8-bit u-law, prior to streaming,
+        // change the following to True:
+        Boolean convertToULaw = False;
+        sms->addSubsession(WAVAudioFileServerMediaSubsession ::createNew(*env, inputFileName, reuseFirstSource, convertToULaw));
+        rtspServer->addServerMediaSession(sms);
+
+        announceStream(rtspServer, sms, streamName, inputFileName);
+    }
+
+    // An AMR audio stream:
+    {
+        char const *        streamName    = "amrAudioTest";
+        char const *        inputFileName = "test.amr";
+        ServerMediaSession *sms           = ServerMediaSession::createNew(*env, streamName, streamName, descriptionString);
+        sms->addSubsession(AMRAudioFileServerMediaSubsession ::createNew(*env, inputFileName, reuseFirstSource));
+        rtspServer->addServerMediaSession(sms);
+
+        announceStream(rtspServer, sms, streamName, inputFileName);
+    }
+
+    // A 'VOB' file (e.g., from an unencrypted DVD):
+    {
+        char const *        streamName    = "vobTest";
+        char const *        inputFileName = "test.vob";
+        ServerMediaSession *sms           = ServerMediaSession::createNew(*env, streamName, streamName, descriptionString);
+        // Note: VOB files are MPEG-2 Program Stream files, but using AC-3 audio
+        MPEG1or2FileServerDemux *demux = MPEG1or2FileServerDemux::createNew(*env, inputFileName, reuseFirstSource);
+        sms->addSubsession(demux->newVideoServerMediaSubsession(iFramesOnly));
+        sms->addSubsession(demux->newAC3AudioServerMediaSubsession());
+        rtspServer->addServerMediaSession(sms);
+
+        announceStream(rtspServer, sms, streamName, inputFileName);
+    }
+
+    // A MPEG-2 Transport Stream:
+    {
+        char const *        streamName    = "mpeg2TransportStreamTest";
+        char const *        inputFileName = "test.ts";
+        char const *        indexFileName = "test.tsx";
+        ServerMediaSession *sms           = ServerMediaSession::createNew(*env, streamName, streamName, descriptionString);
+        sms->addSubsession(MPEG2TransportFileServerMediaSubsession ::createNew(*env, inputFileName, indexFileName, reuseFirstSource));
+        rtspServer->addServerMediaSession(sms);
+
+        announceStream(rtspServer, sms, streamName, inputFileName);
+    }
+
+    // An AAC audio stream (ADTS-format file):
+    {
+        char const *        streamName    = "aacAudioTest";
+        char const *        inputFileName = "test.aac";
+        ServerMediaSession *sms           = ServerMediaSession::createNew(*env, streamName, streamName, descriptionString);
+        sms->addSubsession(ADTSAudioFileServerMediaSubsession ::createNew(*env, inputFileName, reuseFirstSource));
+        rtspServer->addServerMediaSession(sms);
+
+        announceStream(rtspServer, sms, streamName, inputFileName);
+    }
+
+    // A DV video stream:
+    {
+        // First, make sure that the RTPSinks' buffers will be large enough to handle the huge size of DV frames (as big as 288000).
+        OutPacketBuffer::maxSize = 300000;
+
+        char const *        streamName    = "dvVideoTest";
+        char const *        inputFileName = "test.dv";
+        ServerMediaSession *sms           = ServerMediaSession::createNew(*env, streamName, streamName, descriptionString);
+        sms->addSubsession(DVVideoFileServerMediaSubsession ::createNew(*env, inputFileName, reuseFirstSource));
+        rtspServer->addServerMediaSession(sms);
+
+        announceStream(rtspServer, sms, streamName, inputFileName);
+    }
+
+    // A AC3 video elementary stream:
+    {
+        char const *        streamName    = "ac3AudioTest";
+        char const *        inputFileName = "test.ac3";
+        ServerMediaSession *sms           = ServerMediaSession::createNew(*env, streamName, streamName, descriptionString);
+
+        sms->addSubsession(AC3AudioFileServerMediaSubsession ::createNew(*env, inputFileName, reuseFirstSource));
+
+        rtspServer->addServerMediaSession(sms);
+
+        announceStream(rtspServer, sms, streamName, inputFileName);
+    }
+
+    // A Matroska ('.mkv') file, with video+audio+subtitle streams:
+    {
+        char const *        streamName    = "matroskaFileTest";
+        char const *        inputFileName = "test.mkv";
+        ServerMediaSession *sms           = ServerMediaSession::createNew(*env, streamName, streamName, descriptionString);
+
+        newDemuxWatchVariable = 0;
+        MatroskaFileServerDemux::createNew(*env, inputFileName, onMatroskaDemuxCreation, NULL);
+        env->taskScheduler().doEventLoop(&newDemuxWatchVariable);
+
+        Boolean                sessionHasTracks = False;
+        ServerMediaSubsession *smss;
+        while((smss = matroskaDemux->newServerMediaSubsession()) != NULL) {
+            sms->addSubsession(smss);
+            sessionHasTracks = True;
+        }
+        if(sessionHasTracks) {
+            rtspServer->addServerMediaSession(sms);
+        }
+        // otherwise, because the stream has no tracks, we don't add a ServerMediaSession to the server.
+
+        announceStream(rtspServer, sms, streamName, inputFileName);
+    }
+
+    // A WebM ('.webm') file, with video(VP8)+audio(Vorbis) streams:
+    // (Note: ".webm' files are special types of Matroska files, so we use the same code as the Matroska ('.mkv') file code above.)
+    {
+        char const *        streamName    = "webmFileTest";
+        char const *        inputFileName = "test.webm";
+        ServerMediaSession *sms           = ServerMediaSession::createNew(*env, streamName, streamName, descriptionString);
+
+        newDemuxWatchVariable = 0;
+        MatroskaFileServerDemux::createNew(*env, inputFileName, onMatroskaDemuxCreation, NULL);
+        env->taskScheduler().doEventLoop(&newDemuxWatchVariable);
+
+        Boolean                sessionHasTracks = False;
+        ServerMediaSubsession *smss;
+        while((smss = matroskaDemux->newServerMediaSubsession()) != NULL) {
+            sms->addSubsession(smss);
+            sessionHasTracks = True;
+        }
+        if(sessionHasTracks) {
+            rtspServer->addServerMediaSession(sms);
+        }
+        // otherwise, because the stream has no tracks, we don't add a ServerMediaSession to the server.
+
+        announceStream(rtspServer, sms, streamName, inputFileName);
+    }
+
+    // An Ogg ('.ogg') file, with video and/or audio streams:
+    {
+        char const *        streamName    = "oggFileTest";
+        char const *        inputFileName = "test.ogg";
+        ServerMediaSession *sms           = ServerMediaSession::createNew(*env, streamName, streamName, descriptionString);
+
+        newDemuxWatchVariable = 0;
+        OggFileServerDemux::createNew(*env, inputFileName, onOggDemuxCreation, NULL);
+        env->taskScheduler().doEventLoop(&newDemuxWatchVariable);
+
+        Boolean                sessionHasTracks = False;
+        ServerMediaSubsession *smss;
+        while((smss = oggDemux->newServerMediaSubsession()) != NULL) {
+            sms->addSubsession(smss);
+            sessionHasTracks = True;
+        }
+        if(sessionHasTracks) {
+            rtspServer->addServerMediaSession(sms);
+        }
+        // otherwise, because the stream has no tracks, we don't add a ServerMediaSession to the server.
+
+        announceStream(rtspServer, sms, streamName, inputFileName);
+    }
+
+    // An Opus ('.opus') audio file:
+    // (Note: ".opus' files are special types of Ogg files, so we use the same code as the Ogg ('.ogg') file code above.)
+    {
+        char const *        streamName    = "opusFileTest";
+        char const *        inputFileName = "test.opus";
+        ServerMediaSession *sms           = ServerMediaSession::createNew(*env, streamName, streamName, descriptionString);
+
+        newDemuxWatchVariable = 0;
+        OggFileServerDemux::createNew(*env, inputFileName, onOggDemuxCreation, NULL);
+        env->taskScheduler().doEventLoop(&newDemuxWatchVariable);
+
+        Boolean                sessionHasTracks = False;
+        ServerMediaSubsession *smss;
+        while((smss = oggDemux->newServerMediaSubsession()) != NULL) {
+            sms->addSubsession(smss);
+            sessionHasTracks = True;
+        }
+        if(sessionHasTracks) {
+            rtspServer->addServerMediaSession(sms);
+        }
+        // otherwise, because the stream has no tracks, we don't add a ServerMediaSession to the server.
+
+        announceStream(rtspServer, sms, streamName, inputFileName);
+    }
+
+    // A MPEG-2 Transport Stream, coming from a live UDP (raw-UDP or RTP/UDP) source:
+    {
+        char const *streamName      = "mpeg2TransportStreamFromUDPSourceTest";
+        char const *inputAddressStr = "239.255.42.42";
+        // This causes the server to take its input from the stream sent by the "testMPEG2TransportStreamer" demo application.
+        // (Note: If the input UDP source is unicast rather than multicast, then change this to NULL.)
+        portNumBits const inputPortNum = 1234;
+        // This causes the server to take its input from the stream sent by the "testMPEG2TransportStreamer" demo application.
+        Boolean const       inputStreamIsRawUDP = False;
+        ServerMediaSession *sms                 = ServerMediaSession::createNew(*env, streamName, streamName, descriptionString);
+        sms->addSubsession(MPEG2TransportUDPServerMediaSubsession ::createNew(*env, inputAddressStr, inputPortNum, inputStreamIsRawUDP));
+        rtspServer->addServerMediaSession(sms);
+
+        *env << "\n\"" << streamName << "\" stream, from a UDP Transport Stream input source \n\t(";
+        if(inputAddressStr != NULL) {
+            *env << "IP multicast address " << inputAddressStr << ",";
+        }
+        else {
+            *env << "unicast;";
+        }
+        *env << " port " << inputPortNum << ")\n";
+        announceURL(rtspServer, sms);
+    }
+
+    // Also, attempt to create a HTTP server for RTSP-over-HTTP tunneling.
+    // Try first with the default HTTP port (80), and then with the alternative HTTP
+    // port numbers (8000 and 8080).
+
+    if(rtspServer->setUpTunnelingOverHTTP(80) || rtspServer->setUpTunnelingOverHTTP(8000) || rtspServer->setUpTunnelingOverHTTP(8080)) {
+        *env << "\n(We use port " << rtspServer->httpServerPortNum() << " for optional RTSP-over-HTTP tunneling.)\n";
+    }
+    else {
+        *env << "\n(RTSP-over-HTTP tunneling is not available.)\n";
+    }
+
+    env->taskScheduler().doEventLoop();  // does not return
+
+    return 0;  // only to prevent compiler warning
+}
+
+static void announceStream(RTSPServer *rtspServer, ServerMediaSession *sms, char const *streamName, char const *inputFileName) {
+    UsageEnvironment &env = rtspServer->envir();
+
+    env << "\n\"" << streamName << "\" stream, from the file \"" << inputFileName << "\"\n";
+    announceURL(rtspServer, sms);
+}
diff --git a/3rdparty/live555/src/testProgs/testRTSPClient.cpp b/3rdparty/live555/src/testProgs/testRTSPClient.cpp
new file mode 100644
index 00000000..20299878
--- /dev/null
+++ b/3rdparty/live555/src/testProgs/testRTSPClient.cpp
@@ -0,0 +1,523 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// Copyright (c) 1996-2022, Live Networks, Inc.  All rights reserved
+// A demo application, showing how to create and run a RTSP client (that can potentially receive multiple streams concurrently).
+//
+// NOTE: This code - although it builds a running application - is intended only to illustrate how to develop your own RTSP
+// client application.  For a full-featured RTSP client application - with much more functionality, and many options - see
+// "openRTSP": http://www.live555.com/openRTSP/
+
+#include "liveMedia.hh"
+#include "BasicUsageEnvironment.hh"
+
+// Forward function definitions:
+
+// RTSP 'response handlers':
+void continueAfterDESCRIBE(RTSPClient *rtspClient, int resultCode, char *resultString);
+void continueAfterSETUP(RTSPClient *rtspClient, int resultCode, char *resultString);
+void continueAfterPLAY(RTSPClient *rtspClient, int resultCode, char *resultString);
+
+// Other event handler functions:
+void subsessionAfterPlaying(void *clientData);  // called when a stream's subsession (e.g., audio or video substream) ends
+void subsessionByeHandler(void *clientData, char const *reason);
+// called when a RTCP "BYE" is received for a subsession
+void streamStopEventHandler(void *clientData);
+// called at the end of a stream's expected duration (if the stream has not already signaled its end using a RTCP "BYE")
+
+// The main streaming routine (for each "rtsp://" URL):
+void openURL(UsageEnvironment &env, char const *progName, char const *rtspURL);
+
+// Used to iterate through each stream's 'subsessions', setting up each one:
+void setupNextSubsession(RTSPClient *rtspClient);
+
+// Used to shut down and close a stream (including its "RTSPClient" object):
+void shutdownStream(RTSPClient *rtspClient, int exitCode = 1);
+
+// A function that outputs a string that identifies each stream (for debugging output).  Modify this if you wish:
+UsageEnvironment &operator<<(UsageEnvironment &env, const RTSPClient &rtspClient) {
+    return env << "[URL:\"" << rtspClient.url() << "\"]: ";
+}
+
+// A function that outputs a string that identifies each subsession (for debugging output).  Modify this if you wish:
+UsageEnvironment &operator<<(UsageEnvironment &env, const MediaSubsession &subsession) {
+    return env << subsession.mediumName() << "/" << subsession.codecName();
+}
+
+void usage(UsageEnvironment &env, char const *progName) {
+    env << "Usage: " << progName << " <rtsp-url-1> ... <rtsp-url-N>\n";
+    env << "\t(where each <rtsp-url-i> is a \"rtsp://\" URL)\n";
+}
+
+char eventLoopWatchVariable = 0;
+
+int main(int argc, char **argv) {
+    // Begin by setting up our usage environment:
+    TaskScheduler *   scheduler = BasicTaskScheduler::createNew();
+    UsageEnvironment *env       = BasicUsageEnvironment::createNew(*scheduler);
+
+    // We need at least one "rtsp://" URL argument:
+    if(argc < 2) {
+        usage(*env, argv[0]);
+        return 1;
+    }
+
+    // There are argc-1 URLs: argv[1] through argv[argc-1].  Open and start streaming each one:
+    for(int i = 1; i <= argc - 1; ++i) {
+        openURL(*env, argv[0], argv[i]);
+    }
+
+    // All subsequent activity takes place within the event loop:
+    env->taskScheduler().doEventLoop(&eventLoopWatchVariable);
+    // This function call does not return, unless, at some point in time, "eventLoopWatchVariable" gets set to something non-zero.
+
+    return 0;
+
+    // If you choose to continue the application past this point (i.e., if you comment out the "return 0;" statement above),
+    // and if you don't intend to do anything more with the "TaskScheduler" and "UsageEnvironment" objects,
+    // then you can also reclaim the (small) memory used by these objects by uncommenting the following code:
+    /*
+      env->reclaim(); env = NULL;
+      delete scheduler; scheduler = NULL;
+    */
+}
+
+// Define a class to hold per-stream state that we maintain throughout each stream's lifetime:
+
+class StreamClientState {
+public:
+    StreamClientState();
+    virtual ~StreamClientState();
+
+public:
+    MediaSubsessionIterator *iter;
+    MediaSession *           session;
+    MediaSubsession *        subsession;
+    TaskToken                streamTimerTask;
+    double                   duration;
+};
+
+// If you're streaming just a single stream (i.e., just from a single URL, once), then you can define and use just a single
+// "StreamClientState" structure, as a global variable in your application.  However, because - in this demo application - we're
+// showing how to play multiple streams, concurrently, we can't do that.  Instead, we have to have a separate "StreamClientState"
+// structure for each "RTSPClient".  To do this, we subclass "RTSPClient", and add a "StreamClientState" field to the subclass:
+
+class ourRTSPClient : public RTSPClient {
+public:
+    static ourRTSPClient *createNew(UsageEnvironment &env, char const *rtspURL, int verbosityLevel = 0, char const *applicationName = NULL,
+                                    portNumBits tunnelOverHTTPPortNum = 0);
+
+protected:
+    ourRTSPClient(UsageEnvironment &env, char const *rtspURL, int verbosityLevel, char const *applicationName, portNumBits tunnelOverHTTPPortNum);
+    // called only by createNew();
+    virtual ~ourRTSPClient();
+
+public:
+    StreamClientState scs;
+};
+
+// Define a data sink (a subclass of "MediaSink") to receive the data for each subsession (i.e., each audio or video 'substream').
+// In practice, this might be a class (or a chain of classes) that decodes and then renders the incoming audio or video.
+// Or it might be a "FileSink", for outputting the received data into a file (as is done by the "openRTSP" application).
+// In this example code, however, we define a simple 'dummy' sink that receives incoming data, but does nothing with it.
+
+class DummySink : public MediaSink {
+public:
+    static DummySink *createNew(UsageEnvironment &env,
+                                MediaSubsession & subsession,  // identifies the kind of data that's being received
+                                char const *      streamId = NULL);  // identifies the stream itself (optional)
+
+private:
+    DummySink(UsageEnvironment &env, MediaSubsession &subsession, char const *streamId);
+    // called only by "createNew()"
+    virtual ~DummySink();
+
+    static void afterGettingFrame(void *clientData, unsigned frameSize, unsigned numTruncatedBytes, struct timeval presentationTime,
+                                  unsigned durationInMicroseconds);
+    void        afterGettingFrame(unsigned frameSize, unsigned numTruncatedBytes, struct timeval presentationTime, unsigned durationInMicroseconds);
+
+private:
+    // redefined virtual functions:
+    virtual Boolean continuePlaying();
+
+private:
+    u_int8_t *       fReceiveBuffer;
+    MediaSubsession &fSubsession;
+    char *           fStreamId;
+};
+
+#define RTSP_CLIENT_VERBOSITY_LEVEL 1  // by default, print verbose output from each "RTSPClient"
+
+static unsigned rtspClientCount = 0;  // Counts how many streams (i.e., "RTSPClient"s) are currently in use.
+
+void openURL(UsageEnvironment &env, char const *progName, char const *rtspURL) {
+    // Begin by creating a "RTSPClient" object.  Note that there is a separate "RTSPClient" object for each stream that we wish
+    // to receive (even if more than stream uses the same "rtsp://" URL).
+    RTSPClient *rtspClient = ourRTSPClient::createNew(env, rtspURL, RTSP_CLIENT_VERBOSITY_LEVEL, progName);
+    if(rtspClient == NULL) {
+        env << "Failed to create a RTSP client for URL \"" << rtspURL << "\": " << env.getResultMsg() << "\n";
+        return;
+    }
+
+    ++rtspClientCount;
+
+    // Next, send a RTSP "DESCRIBE" command, to get a SDP description for the stream.
+    // Note that this command - like all RTSP commands - is sent asynchronously; we do not block, waiting for a response.
+    // Instead, the following function call returns immediately, and we handle the RTSP response later, from within the event loop:
+    rtspClient->sendDescribeCommand(continueAfterDESCRIBE);
+}
+
+// Implementation of the RTSP 'response handlers':
+
+void continueAfterDESCRIBE(RTSPClient *rtspClient, int resultCode, char *resultString) {
+    do {
+        UsageEnvironment & env = rtspClient->envir();                 // alias
+        StreamClientState &scs = ((ourRTSPClient *)rtspClient)->scs;  // alias
+
+        if(resultCode != 0) {
+            env << *rtspClient << "Failed to get a SDP description: " << resultString << "\n";
+            delete[] resultString;
+            break;
+        }
+
+        char *const sdpDescription = resultString;
+        env << *rtspClient << "Got a SDP description:\n" << sdpDescription << "\n";
+
+        // Create a media session object from this SDP description:
+        scs.session = MediaSession::createNew(env, sdpDescription);
+        delete[] sdpDescription;  // because we don't need it anymore
+        if(scs.session == NULL) {
+            env << *rtspClient << "Failed to create a MediaSession object from the SDP description: " << env.getResultMsg() << "\n";
+            break;
+        }
+        else if(!scs.session->hasSubsessions()) {
+            env << *rtspClient << "This session has no media subsessions (i.e., no \"m=\" lines)\n";
+            break;
+        }
+
+        // Then, create and set up our data source objects for the session.  We do this by iterating over the session's 'subsessions',
+        // calling "MediaSubsession::initiate()", and then sending a RTSP "SETUP" command, on each one.
+        // (Each 'subsession' will have its own data source.)
+        scs.iter = new MediaSubsessionIterator(*scs.session);
+        setupNextSubsession(rtspClient);
+        return;
+    } while(0);
+
+    // An unrecoverable error occurred with this stream.
+    shutdownStream(rtspClient);
+}
+
+// By default, we request that the server stream its data using RTP/UDP.
+// If, instead, you want to request that the server stream via RTP-over-TCP, change the following to True:
+#define REQUEST_STREAMING_OVER_TCP False
+
+void setupNextSubsession(RTSPClient *rtspClient) {
+    UsageEnvironment & env = rtspClient->envir();                 // alias
+    StreamClientState &scs = ((ourRTSPClient *)rtspClient)->scs;  // alias
+
+    scs.subsession = scs.iter->next();
+    if(scs.subsession != NULL) {
+        if(!scs.subsession->initiate()) {
+            env << *rtspClient << "Failed to initiate the \"" << *scs.subsession << "\" subsession: " << env.getResultMsg() << "\n";
+            setupNextSubsession(rtspClient);  // give up on this subsession; go to the next one
+        }
+        else {
+            env << *rtspClient << "Initiated the \"" << *scs.subsession << "\" subsession (";
+            if(scs.subsession->rtcpIsMuxed()) {
+                env << "client port " << scs.subsession->clientPortNum();
+            }
+            else {
+                env << "client ports " << scs.subsession->clientPortNum() << "-" << scs.subsession->clientPortNum() + 1;
+            }
+            env << ")\n";
+
+            // Continue setting up this subsession, by sending a RTSP "SETUP" command:
+            rtspClient->sendSetupCommand(*scs.subsession, continueAfterSETUP, False, REQUEST_STREAMING_OVER_TCP);
+        }
+        return;
+    }
+
+    // We've finished setting up all of the subsessions.  Now, send a RTSP "PLAY" command to start the streaming:
+    if(scs.session->absStartTime() != NULL) {
+        // Special case: The stream is indexed by 'absolute' time, so send an appropriate "PLAY" command:
+        rtspClient->sendPlayCommand(*scs.session, continueAfterPLAY, scs.session->absStartTime(), scs.session->absEndTime());
+    }
+    else {
+        scs.duration = scs.session->playEndTime() - scs.session->playStartTime();
+        rtspClient->sendPlayCommand(*scs.session, continueAfterPLAY);
+    }
+}
+
+void continueAfterSETUP(RTSPClient *rtspClient, int resultCode, char *resultString) {
+    do {
+        UsageEnvironment & env = rtspClient->envir();                 // alias
+        StreamClientState &scs = ((ourRTSPClient *)rtspClient)->scs;  // alias
+
+        if(resultCode != 0) {
+            env << *rtspClient << "Failed to set up the \"" << *scs.subsession << "\" subsession: " << resultString << "\n";
+            break;
+        }
+
+        env << *rtspClient << "Set up the \"" << *scs.subsession << "\" subsession (";
+        if(scs.subsession->rtcpIsMuxed()) {
+            env << "client port " << scs.subsession->clientPortNum();
+        }
+        else {
+            env << "client ports " << scs.subsession->clientPortNum() << "-" << scs.subsession->clientPortNum() + 1;
+        }
+        env << ")\n";
+
+        // Having successfully setup the subsession, create a data sink for it, and call "startPlaying()" on it.
+        // (This will prepare the data sink to receive data; the actual flow of data from the client won't start happening until later,
+        // after we've sent a RTSP "PLAY" command.)
+
+        scs.subsession->sink = DummySink::createNew(env, *scs.subsession, rtspClient->url());
+        // perhaps use your own custom "MediaSink" subclass instead
+        if(scs.subsession->sink == NULL) {
+            env << *rtspClient << "Failed to create a data sink for the \"" << *scs.subsession << "\" subsession: " << env.getResultMsg() << "\n";
+            break;
+        }
+
+        env << *rtspClient << "Created a data sink for the \"" << *scs.subsession << "\" subsession\n";
+        scs.subsession->miscPtr = rtspClient;  // a hack to let subsession handler functions get the "RTSPClient" from the subsession
+        scs.subsession->sink->startPlaying(*(scs.subsession->readSource()), subsessionAfterPlaying, scs.subsession);
+        // Also set a handler to be called if a RTCP "BYE" arrives for this subsession:
+        if(scs.subsession->rtcpInstance() != NULL) {
+            scs.subsession->rtcpInstance()->setByeWithReasonHandler(subsessionByeHandler, scs.subsession);
+        }
+    } while(0);
+    delete[] resultString;
+
+    // Set up the next subsession, if any:
+    setupNextSubsession(rtspClient);
+}
+
+void continueAfterPLAY(RTSPClient *rtspClient, int resultCode, char *resultString) {
+    Boolean success = False;
+
+    do {
+        UsageEnvironment & env = rtspClient->envir();                 // alias
+        StreamClientState &scs = ((ourRTSPClient *)rtspClient)->scs;  // alias
+
+        if(resultCode != 0) {
+            env << *rtspClient << "Failed to start playing session: " << resultString << "\n";
+            break;
+        }
+
+        // Set a timer to be handled at the end of the stream's expected duration (if the stream does not already signal its end
+        // using a RTCP "BYE").  This is optional.  If, instead, you want to keep the stream active - e.g., so you can later
+        // 'seek' back within it and do another RTSP "PLAY" - then you can omit this code.
+        // (Alternatively, if you don't want to receive the entire stream, you could set this timer for some shorter value.)
+        if(scs.duration > 0) {
+            unsigned const delaySlop = 2;  // number of seconds extra to delay, after the stream's expected duration.  (This is optional.)
+            scs.duration += delaySlop;
+            unsigned uSecsToDelay = (unsigned)(scs.duration * 1000000);
+            scs.streamTimerTask   = env.taskScheduler().scheduleDelayedTask(uSecsToDelay, (TaskFunc *)streamStopEventHandler, rtspClient);
+        }
+
+        env << *rtspClient << "Started playing session";
+        if(scs.duration > 0) {
+            env << " (for up to " << scs.duration << " seconds)";
+        }
+        env << "...\n";
+
+        success = True;
+    } while(0);
+    delete[] resultString;
+
+    if(!success) {
+        // An unrecoverable error occurred with this stream.
+        shutdownStream(rtspClient);
+    }
+}
+
+// Implementation of the other event handlers:
+
+void subsessionAfterPlaying(void *clientData) {
+    MediaSubsession *subsession = (MediaSubsession *)clientData;
+    RTSPClient *     rtspClient = (RTSPClient *)(subsession->miscPtr);
+
+    // Begin by closing this subsession's stream:
+    Medium::close(subsession->sink);
+    subsession->sink = NULL;
+
+    // Next, check whether *all* subsessions' streams have now been closed:
+    MediaSession &          session = subsession->parentSession();
+    MediaSubsessionIterator iter(session);
+    while((subsession = iter.next()) != NULL) {
+        if(subsession->sink != NULL)
+            return;  // this subsession is still active
+    }
+
+    // All subsessions' streams have now been closed, so shutdown the client:
+    shutdownStream(rtspClient);
+}
+
+void subsessionByeHandler(void *clientData, char const *reason) {
+    MediaSubsession * subsession = (MediaSubsession *)clientData;
+    RTSPClient *      rtspClient = (RTSPClient *)subsession->miscPtr;
+    UsageEnvironment &env        = rtspClient->envir();  // alias
+
+    env << *rtspClient << "Received RTCP \"BYE\"";
+    if(reason != NULL) {
+        env << " (reason:\"" << reason << "\")";
+        delete[](char *) reason;
+    }
+    env << " on \"" << *subsession << "\" subsession\n";
+
+    // Now act as if the subsession had closed:
+    subsessionAfterPlaying(subsession);
+}
+
+void streamStopEventHandler(void *clientData) {
+    ourRTSPClient *    rtspClient = (ourRTSPClient *)clientData;
+    StreamClientState &scs        = rtspClient->scs;  // alias
+
+    scs.streamTimerTask = NULL;
+
+    // Shut down the stream:
+    shutdownStream(rtspClient);
+}
+
+void shutdownStream(RTSPClient *rtspClient, int exitCode) {
+    UsageEnvironment & env = rtspClient->envir();                 // alias
+    StreamClientState &scs = ((ourRTSPClient *)rtspClient)->scs;  // alias
+
+    // First, check whether any subsessions have still to be closed:
+    if(scs.session != NULL) {
+        Boolean                 someSubsessionsWereActive = False;
+        MediaSubsessionIterator iter(*scs.session);
+        MediaSubsession *       subsession;
+
+        while((subsession = iter.next()) != NULL) {
+            if(subsession->sink != NULL) {
+                Medium::close(subsession->sink);
+                subsession->sink = NULL;
+
+                if(subsession->rtcpInstance() != NULL) {
+                    subsession->rtcpInstance()->setByeHandler(NULL, NULL);  // in case the server sends a RTCP "BYE" while handling "TEARDOWN"
+                }
+
+                someSubsessionsWereActive = True;
+            }
+        }
+
+        if(someSubsessionsWereActive) {
+            // Send a RTSP "TEARDOWN" command, to tell the server to shutdown the stream.
+            // Don't bother handling the response to the "TEARDOWN".
+            rtspClient->sendTeardownCommand(*scs.session, NULL);
+        }
+    }
+
+    env << *rtspClient << "Closing the stream.\n";
+    Medium::close(rtspClient);
+    // Note that this will also cause this stream's "StreamClientState" structure to get reclaimed.
+
+    if(--rtspClientCount == 0) {
+        // The final stream has ended, so exit the application now.
+        // (Of course, if you're embedding this code into your own application, you might want to comment this out,
+        // and replace it with "eventLoopWatchVariable = 1;", so that we leave the LIVE555 event loop, and continue running "main()".)
+        exit(exitCode);
+    }
+}
+
+// Implementation of "ourRTSPClient":
+
+ourRTSPClient *ourRTSPClient::createNew(UsageEnvironment &env, char const *rtspURL, int verbosityLevel, char const *applicationName,
+                                        portNumBits tunnelOverHTTPPortNum) {
+    return new ourRTSPClient(env, rtspURL, verbosityLevel, applicationName, tunnelOverHTTPPortNum);
+}
+
+ourRTSPClient::ourRTSPClient(UsageEnvironment &env, char const *rtspURL, int verbosityLevel, char const *applicationName, portNumBits tunnelOverHTTPPortNum)
+    : RTSPClient(env, rtspURL, verbosityLevel, applicationName, tunnelOverHTTPPortNum, -1) {}
+
+ourRTSPClient::~ourRTSPClient() {}
+
+// Implementation of "StreamClientState":
+
+StreamClientState::StreamClientState() : iter(NULL), session(NULL), subsession(NULL), streamTimerTask(NULL), duration(0.0) {}
+
+StreamClientState::~StreamClientState() {
+    delete iter;
+    if(session != NULL) {
+        // We also need to delete "session", and unschedule "streamTimerTask" (if set)
+        UsageEnvironment &env = session->envir();  // alias
+
+        env.taskScheduler().unscheduleDelayedTask(streamTimerTask);
+        Medium::close(session);
+    }
+}
+
+// Implementation of "DummySink":
+
+// Even though we're not going to be doing anything with the incoming data, we still need to receive it.
+// Define the size of the buffer that we'll use:
+#define DUMMY_SINK_RECEIVE_BUFFER_SIZE 100000
+
+DummySink *DummySink::createNew(UsageEnvironment &env, MediaSubsession &subsession, char const *streamId) {
+    return new DummySink(env, subsession, streamId);
+}
+
+DummySink::DummySink(UsageEnvironment &env, MediaSubsession &subsession, char const *streamId) : MediaSink(env), fSubsession(subsession) {
+    fStreamId      = strDup(streamId);
+    fReceiveBuffer = new u_int8_t[DUMMY_SINK_RECEIVE_BUFFER_SIZE];
+}
+
+DummySink::~DummySink() {
+    delete[] fReceiveBuffer;
+    delete[] fStreamId;
+}
+
+void DummySink::afterGettingFrame(void *clientData, unsigned frameSize, unsigned numTruncatedBytes, struct timeval presentationTime,
+                                  unsigned durationInMicroseconds) {
+    DummySink *sink = (DummySink *)clientData;
+    sink->afterGettingFrame(frameSize, numTruncatedBytes, presentationTime, durationInMicroseconds);
+}
+
+// If you don't want to see debugging output for each received frame, then comment out the following line:
+#define DEBUG_PRINT_EACH_RECEIVED_FRAME 1
+
+void DummySink::afterGettingFrame(unsigned frameSize, unsigned numTruncatedBytes, struct timeval presentationTime, unsigned /*durationInMicroseconds*/) {
+    // We've just received a frame of data.  (Optionally) print out information about it:
+#ifdef DEBUG_PRINT_EACH_RECEIVED_FRAME
+    if(fStreamId != NULL)
+        envir() << "Stream \"" << fStreamId << "\"; ";
+    envir() << fSubsession.mediumName() << "/" << fSubsession.codecName() << ":\tReceived " << frameSize << " bytes";
+    if(numTruncatedBytes > 0)
+        envir() << " (with " << numTruncatedBytes << " bytes truncated)";
+    char uSecsStr[6 + 1];  // used to output the 'microseconds' part of the presentation time
+    sprintf(uSecsStr, "%06u", (unsigned)presentationTime.tv_usec);
+    envir() << ".\tPresentation time: " << (int)presentationTime.tv_sec << "." << uSecsStr;
+    if(fSubsession.rtpSource() != NULL && !fSubsession.rtpSource()->hasBeenSynchronizedUsingRTCP()) {
+        envir() << "!";  // mark the debugging output to indicate that this presentation time is not RTCP-synchronized
+    }
+#ifdef DEBUG_PRINT_NPT
+    envir() << "\tNPT: " << fSubsession.getNormalPlayTime(presentationTime);
+#endif
+    envir() << "\n";
+#endif
+
+    // Then continue, to request the next frame of data:
+    continuePlaying();
+}
+
+Boolean DummySink::continuePlaying() {
+    if(fSource == NULL)
+        return False;  // sanity check (should not happen)
+
+    // Request the next frame of data from our input source.  "afterGettingFrame()" will get called later, when it arrives:
+    fSource->getNextFrame(fReceiveBuffer, DUMMY_SINK_RECEIVE_BUFFER_SIZE, afterGettingFrame, this, onSourceClosure, this);
+    return True;
+}
diff --git a/3rdparty/live555/src/testProgs/testRelay.cpp b/3rdparty/live555/src/testProgs/testRelay.cpp
new file mode 100644
index 00000000..b9c37e2d
--- /dev/null
+++ b/3rdparty/live555/src/testProgs/testRelay.cpp
@@ -0,0 +1,88 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// Copyright (c) 1996-2022, Live Networks, Inc.  All rights reserved
+// A test program that receives a UDP multicast stream
+// and retransmits it to another (multicast or unicast) address & port
+// main program
+
+#include <liveMedia.hh>
+#include "BasicUsageEnvironment.hh"
+#include "GroupsockHelper.hh"
+
+UsageEnvironment *env;
+
+// To receive a "source-specific multicast" (SSM) stream, uncomment this:
+//#define USE_SSM 1
+
+int main(int argc, char **argv) {
+    // Begin by setting up our usage environment:
+    TaskScheduler *scheduler = BasicTaskScheduler::createNew();
+    env                      = BasicUsageEnvironment::createNew(*scheduler);
+
+    // Create a 'groupsock' for the input multicast group,port:
+    char const *inputAddressStr
+#ifdef USE_SSM
+        = "232.255.42.42";
+#else
+        = "239.255.42.42";
+#endif
+    NetAddressList          inputAddresses(inputAddressStr);
+    struct sockaddr_storage inputAddress;
+    copyAddress(inputAddress, inputAddresses.firstAddress());
+
+    Port const          inputPort(8888);
+    unsigned char const inputTTL = 0;  // we're only reading from this mcast group
+
+#ifdef USE_SSM
+    char const *sourceAddressStr = "aaa.bbb.ccc.ddd";
+    // replace this with the real source address
+    NetAddressList          sourceFilterAddresses(sourceAddressStr);
+    struct sockaddr_storage sourceFilterAddress;
+    copyAddress(sourceFilterAddress, sourceFilterAddresses.firstAddress());
+
+    Groupsock inputGroupsock(*env, inputAddress, sourceFilterAddress, inputPort);
+#else
+    Groupsock inputGroupsock(*env, inputAddress, inputPort, inputTTL);
+#endif
+
+    // Then create a liveMedia 'source' object, encapsulating this groupsock:
+    FramedSource *source = BasicUDPSource::createNew(*env, &inputGroupsock);
+
+    // Create a 'groupsock' for the destination address and port:
+    char const *outputAddressStr = "239.255.43.43";  // this could also be unicast
+                                                     // Note: You may change "outputAddressStr" to use a different multicast
+                                                     // (or unicast address), but do *not* change it to use the same multicast
+                                                     // address as "inputAddressStr".
+    NetAddressList          outputAddresses(outputAddressStr);
+    struct sockaddr_storage outputAddress;
+    copyAddress(outputAddress, outputAddresses.firstAddress());
+
+    Port const          outputPort(4444);
+    unsigned char const outputTTL = 255;
+
+    Groupsock outputGroupsock(*env, outputAddress, outputPort, outputTTL);
+
+    // Then create a liveMedia 'sink' object, encapsulating this groupsock:
+    unsigned const maxPacketSize = 65536;  // allow for large UDP packets
+    MediaSink *    sink          = BasicUDPSink::createNew(*env, &outputGroupsock, maxPacketSize);
+
+    // Now, start playing, feeding the sink object from the source:
+    sink->startPlaying(*source, NULL, NULL);
+
+    env->taskScheduler().doEventLoop();  // does not return
+
+    return 0;  // only to prevent compiler warning
+}
diff --git a/3rdparty/live555/src/testProgs/testReplicator.cpp b/3rdparty/live555/src/testProgs/testReplicator.cpp
new file mode 100644
index 00000000..1cd3384d
--- /dev/null
+++ b/3rdparty/live555/src/testProgs/testReplicator.cpp
@@ -0,0 +1,117 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// Copyright (c) 1996-2022, Live Networks, Inc.  All rights reserved
+// A demo application that receives a UDP multicast stream, replicates it (using the "StreamReplicator" class),
+// and retransmits one replica stream to another (multicast or unicast) address & port,
+// and writes the other replica stream to a file.
+//
+// main program
+
+#include <liveMedia.hh>
+#include "BasicUsageEnvironment.hh"
+#include "GroupsockHelper.hh"
+
+UsageEnvironment *env;
+
+// To receive a "source-specific multicast" (SSM) stream, uncomment this:
+//#define USE_SSM 1
+
+void startReplicaUDPSink(StreamReplicator *replicator, char const *outputAddressStr, portNumBits outputPortNum);  // forward
+void startReplicaFileSink(StreamReplicator *replicator, char const *outputFileName);                              // forward
+
+int main(int argc, char **argv) {
+    // Begin by setting up our usage environment:
+    TaskScheduler *scheduler = BasicTaskScheduler::createNew();
+    env                      = BasicUsageEnvironment::createNew(*scheduler);
+
+    // Create a 'groupsock' for the input multicast group,port:
+    char const *inputAddressStr
+#ifdef USE_SSM
+        = "232.255.42.42";
+#else
+        = "239.255.42.42";
+#endif
+    NetAddressList          inputAddresses(inputAddressStr);
+    struct sockaddr_storage inputAddress;
+    copyAddress(inputAddress, inputAddresses.firstAddress());
+
+    Port const          inputPort(8888);
+    unsigned char const inputTTL = 0;  // we're only reading from this mcast group
+
+#ifdef USE_SSM
+    char const *sourceAddressStr = "aaa.bbb.ccc.ddd";
+    // replace this with the real source address
+    NetAddressList          sourceFilterAddresses(sourceAddressStr);
+    struct sockaddr_storage sourceFilterAddress;
+    copyAddress(sourceFilterAddress, sourceFilterAddresses.firstAddress());
+
+    Groupsock inputGroupsock(*env, inputAddress, sourceFilterAddress, inputPort);
+#else
+    Groupsock inputGroupsock(*env, inputAddress, inputPort, inputTTL);
+#endif
+
+    // Then create a liveMedia 'source' object, encapsulating this groupsock:
+    FramedSource *source = BasicUDPSource::createNew(*env, &inputGroupsock);
+
+    // And feed this into a 'stream replicator':
+    StreamReplicator *replicator = StreamReplicator::createNew(*env, source);
+
+    // Then create a network (UDP) 'sink' object to receive a replica of the input stream, and start it.
+    // If you wish, you can duplicate this line - with different network addresses and ports - to create multiple output UDP streams:
+    startReplicaUDPSink(replicator, "239.255.43.43", 4444);
+
+    // Then create a file 'sink' object to receive a replica of the input stream, and start it.
+    // If you wish, you can duplicate this line - with a different file name - to create multiple output files:
+    startReplicaFileSink(replicator, "test.out");
+
+    // Finally, enter the 'event loop' (which is where most of the 'real work' in a LIVE555-based application gets done):
+    env->taskScheduler().doEventLoop();  // does not return
+
+    return 0;  // only to prevent compiler warning
+}
+
+void startReplicaUDPSink(StreamReplicator *replicator, char const *outputAddressStr, portNumBits outputPortNum) {
+    // Begin by creating an input stream from our replicator:
+    FramedSource *source = replicator->createStreamReplica();
+
+    // Create a 'groupsock' for the destination address and port:
+    NetAddressList          outputAddresses(outputAddressStr);
+    struct sockaddr_storage outputAddress;
+    copyAddress(outputAddress, outputAddresses.firstAddress());
+
+    Port const          outputPort(outputPortNum);
+    unsigned char const outputTTL = 255;
+
+    Groupsock *outputGroupsock = new Groupsock(*env, outputAddress, outputPort, outputTTL);
+
+    // Then create a liveMedia 'sink' object, encapsulating this groupsock:
+    unsigned const maxPacketSize = 65536;  // allow for large UDP packets
+    MediaSink *    sink          = BasicUDPSink::createNew(*env, outputGroupsock, maxPacketSize);
+
+    // Now, start playing, feeding the sink object from the source:
+    sink->startPlaying(*source, NULL, NULL);
+}
+
+void startReplicaFileSink(StreamReplicator *replicator, char const *outputFileName) {
+    // Begin by creating an input stream from our replicator:
+    FramedSource *source = replicator->createStreamReplica();
+
+    // Then create a 'file sink' object to receive thie replica stream:
+    MediaSink *sink = FileSink::createNew(*env, outputFileName);
+
+    // Now, start playing, feeding the sink object from the source:
+    sink->startPlaying(*source, NULL, NULL);
+}
diff --git a/3rdparty/live555/src/testProgs/testWAVAudioStreamer.cpp b/3rdparty/live555/src/testProgs/testWAVAudioStreamer.cpp
new file mode 100644
index 00000000..8114479a
--- /dev/null
+++ b/3rdparty/live555/src/testProgs/testWAVAudioStreamer.cpp
@@ -0,0 +1,235 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// Copyright (c) 1996-2022, Live Networks, Inc.  All rights reserved
+// A test program that streams a WAV audio file via RTP/RTCP
+// main program
+
+#include "liveMedia.hh"
+
+#include "BasicUsageEnvironment.hh"
+#include "announceURL.hh"
+#include "GroupsockHelper.hh"
+
+// To convert 16-bit samples to 8-bit u-law ("u" is the Greek letter "mu")
+// encoding, before streaming, uncomment the following line:
+//#define CONVERT_TO_ULAW 1
+
+UsageEnvironment *env;
+
+void play();  // forward
+
+int main(int argc, char **argv) {
+    // Begin by setting up our usage environment:
+    TaskScheduler *scheduler = BasicTaskScheduler::createNew();
+    env                      = BasicUsageEnvironment::createNew(*scheduler);
+
+    play();
+
+    env->taskScheduler().doEventLoop();  // does not return
+    return 0;                            // only to prevent compiler warnings
+}
+
+char const *inputFileName = "test.wav";
+
+void afterPlaying(void *clientData);  // forward
+
+// A structure to hold the state of the current session.
+// It is used in the "afterPlaying()" function to clean up the session.
+struct sessionState_t {
+    FramedSource *source;
+    RTPSink *     sink;
+    RTCPInstance *rtcpInstance;
+    Groupsock *   rtpGroupsock;
+    Groupsock *   rtcpGroupsock;
+    RTSPServer *  rtspServer;
+} sessionState;
+
+void play() {
+    // Open the file as a 'WAV' file:
+    WAVAudioFileSource *wavSource = WAVAudioFileSource::createNew(*env, inputFileName);
+    if(wavSource == NULL) {
+        *env << "Unable to open file \"" << inputFileName << "\" as a WAV audio file source: " << env->getResultMsg() << "\n";
+        exit(1);
+    }
+
+    // Get attributes of the audio source:
+    unsigned char       audioFormat   = wavSource->getAudioFormat();
+    unsigned char const bitsPerSample = wavSource->bitsPerSample();
+    // We handle only 4,8,16,20,24 bits-per-sample audio:
+    if(bitsPerSample % 4 != 0 || bitsPerSample < 4 || bitsPerSample > 24 || bitsPerSample == 12) {
+        *env << "The input file contains " << bitsPerSample << " bit-per-sample audio, which we don't handle\n";
+        exit(1);
+    }
+    unsigned const      samplingFrequency = wavSource->samplingFrequency();
+    unsigned char const numChannels       = wavSource->numChannels();
+    unsigned            bitsPerSecond     = samplingFrequency * bitsPerSample * numChannels;
+    *env << "Audio source parameters:\n\t" << samplingFrequency << " Hz, ";
+    *env << bitsPerSample << " bits-per-sample, ";
+    *env << numChannels << " channels => ";
+    *env << bitsPerSecond << " bits-per-second\n";
+
+    char const *  mimeType;
+    unsigned char payloadFormatCode = 96;  // by default, unless a static RTP payload type can be used
+
+    // Add in any filter necessary to transform the data prior to streaming.
+    // (This is where any audio compression would get added.)
+    sessionState.source = wavSource;  // by default
+    if(audioFormat == WA_PCM) {
+        if(bitsPerSample == 16) {
+            // Note that samples in the WAV audio file are in little-endian order.
+#ifdef CONVERT_TO_ULAW
+            // Add a filter that converts from raw 16-bit PCM audio (in little-endian order) to 8-bit u-law audio:
+            sessionState.source = uLawFromPCMAudioSource::createNew(*env, wavSource, 1 /*little-endian*/);
+            if(sessionState.source == NULL) {
+                *env << "Unable to create a u-law filter from the PCM audio source: " << env->getResultMsg() << "\n";
+                exit(1);
+            }
+            bitsPerSecond /= 2;
+            *env << "Converting to 8-bit u-law audio for streaming => " << bitsPerSecond << " bits-per-second\n";
+            mimeType = "PCMU";
+            if(samplingFrequency == 8000 && numChannels == 1) {
+                payloadFormatCode = 0;  // a static RTP payload type
+            }
+#else
+            // Add a filter that converts from little-endian to network (big-endian) order:
+            sessionState.source = EndianSwap16::createNew(*env, wavSource);
+            if(sessionState.source == NULL) {
+                *env << "Unable to create a little->bit-endian order filter from the PCM audio source: " << env->getResultMsg() << "\n";
+                exit(1);
+            }
+            *env << "Converting to network byte order for streaming\n";
+            mimeType = "L16";
+            if(samplingFrequency == 44100 && numChannels == 2) {
+                payloadFormatCode = 10;  // a static RTP payload type
+            }
+            else if(samplingFrequency == 44100 && numChannels == 1) {
+                payloadFormatCode = 11;  // a static RTP payload type
+            }
+#endif
+        }
+        else if(bitsPerSample == 20 || bitsPerSample == 24) {
+            // Add a filter that converts from little-endian to network (big-endian) order:
+            sessionState.source = EndianSwap24::createNew(*env, wavSource);
+            if(sessionState.source == NULL) {
+                *env << "Unable to create a little->bit-endian order filter from the PCM audio source: " << env->getResultMsg() << "\n";
+                exit(1);
+            }
+            *env << "Converting to network byte order for streaming\n";
+            mimeType = bitsPerSample == 20 ? "L20" : "L24";
+        }
+        else {  // bitsPerSample == 8 (we assume that bitsPerSample == 4 is only for WA_IMA_ADPCM)
+            // Don't do any transformation; send the 8-bit PCM data 'as is':
+            mimeType = "L8";
+        }
+    }
+    else if(audioFormat == WA_PCMU) {
+        mimeType = "PCMU";
+        if(samplingFrequency == 8000 && numChannels == 1) {
+            payloadFormatCode = 0;  // a static RTP payload type
+        }
+    }
+    else if(audioFormat == WA_PCMA) {
+        mimeType = "PCMA";
+        if(samplingFrequency == 8000 && numChannels == 1) {
+            payloadFormatCode = 8;  // a static RTP payload type
+        }
+    }
+    else if(audioFormat == WA_IMA_ADPCM) {
+        mimeType = "DVI4";
+        // Use a static payload type, if one is defined:
+        if(numChannels == 1) {
+            if(samplingFrequency == 8000) {
+                payloadFormatCode = 5;  // a static RTP payload type
+            }
+            else if(samplingFrequency == 16000) {
+                payloadFormatCode = 6;  // a static RTP payload type
+            }
+            else if(samplingFrequency == 11025) {
+                payloadFormatCode = 16;  // a static RTP payload type
+            }
+            else if(samplingFrequency == 22050) {
+                payloadFormatCode = 17;  // a static RTP payload type
+            }
+        }
+    }
+    else {  // unknown format
+        *env << "Unknown audio format code \"" << audioFormat << "\" in WAV file header\n";
+        exit(1);
+    }
+
+    // Create 'groupsocks' for RTP and RTCP:
+    struct sockaddr_storage destinationAddress;
+    destinationAddress.ss_family                               = AF_INET;
+    ((struct sockaddr_in &)destinationAddress).sin_addr.s_addr = chooseRandomIPv4SSMAddress(*env);
+    // Note: This is a multicast address.  If you wish instead to stream
+    // using unicast, then you should use the "testOnDemandRTSPServer" demo application,
+    // or the "LIVE555 Media Server" - not this application - as a model.
+
+    const unsigned short rtpPortNum  = 2222;
+    const unsigned short rtcpPortNum = rtpPortNum + 1;
+    const unsigned char  ttl         = 255;
+
+    const Port rtpPort(rtpPortNum);
+    const Port rtcpPort(rtcpPortNum);
+
+    sessionState.rtpGroupsock = new Groupsock(*env, destinationAddress, rtpPort, ttl);
+    sessionState.rtpGroupsock->multicastSendOnly();  // we're a SSM source
+    sessionState.rtcpGroupsock = new Groupsock(*env, destinationAddress, rtcpPort, ttl);
+    sessionState.rtcpGroupsock->multicastSendOnly();  // we're a SSM source
+
+    // Create an appropriate audio RTP sink (using "SimpleRTPSink") from the RTP 'groupsock':
+    sessionState.sink = SimpleRTPSink::createNew(*env, sessionState.rtpGroupsock, payloadFormatCode, samplingFrequency, "audio", mimeType, numChannels);
+
+    // Create (and start) a 'RTCP instance' for this RTP sink:
+    const unsigned estimatedSessionBandwidth = (bitsPerSecond + 500) / 1000;  // in kbps; for RTCP b/w share
+    const unsigned maxCNAMElen               = 100;
+    unsigned char  CNAME[maxCNAMElen + 1];
+    gethostname((char *)CNAME, maxCNAMElen);
+    CNAME[maxCNAMElen]        = '\0';  // just in case
+    sessionState.rtcpInstance = RTCPInstance::createNew(*env, sessionState.rtcpGroupsock, estimatedSessionBandwidth, CNAME, sessionState.sink,
+                                                        NULL /* we're a server */, True /* we're a SSM source*/);
+    // Note: This starts RTCP running automatically
+
+    // Create and start a RTSP server to serve this stream:
+    sessionState.rtspServer = RTSPServer::createNew(*env, 8554);
+    if(sessionState.rtspServer == NULL) {
+        *env << "Failed to create RTSP server: " << env->getResultMsg() << "\n";
+        exit(1);
+    }
+    ServerMediaSession *sms = ServerMediaSession::createNew(*env, "testStream", inputFileName, "Session streamed by \"testWAVAudiotreamer\"", True /*SSM*/);
+    sms->addSubsession(PassiveServerMediaSubsession::createNew(*sessionState.sink, sessionState.rtcpInstance));
+    sessionState.rtspServer->addServerMediaSession(sms);
+    announceURL(sessionState.rtspServer, sms);
+
+    // Finally, start the streaming:
+    *env << "Beginning streaming...\n";
+    sessionState.sink->startPlaying(*sessionState.source, afterPlaying, NULL);
+}
+
+void afterPlaying(void * /*clientData*/) {
+    *env << "...done streaming\n";
+
+    // End by closing the media:
+    Medium::close(sessionState.rtspServer);
+    Medium::close(sessionState.rtcpInstance);
+    Medium::close(sessionState.sink);
+    delete sessionState.rtpGroupsock;
+    Medium::close(sessionState.source);
+    delete sessionState.rtcpGroupsock;
+
+    // We're done:
+    exit(0);
+}
diff --git a/3rdparty/live555/src/testProgs/vobStreamer.cpp b/3rdparty/live555/src/testProgs/vobStreamer.cpp
new file mode 100644
index 00000000..060ed84c
--- /dev/null
+++ b/3rdparty/live555/src/testProgs/vobStreamer.cpp
@@ -0,0 +1,292 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+**********/
+// Copyright (c) 1996-2022, Live Networks, Inc.  All rights reserved
+// A test program that reads a VOB file
+// splits it into Audio (AC3) and Video (MPEG) Elementary Streams,
+// and streams both using RTP.
+// main program
+
+#include "liveMedia.hh"
+
+#include "AC3AudioStreamFramer.hh"
+#include "BasicUsageEnvironment.hh"
+#include "announceURL.hh"
+#include "GroupsockHelper.hh"
+
+char const *programName;
+// Whether to stream *only* "I" (key) frames
+// (e.g., to reduce network bandwidth):
+Boolean iFramesOnly = False;
+
+unsigned const VOB_AUDIO     = 1 << 0;
+unsigned const VOB_VIDEO     = 1 << 1;
+unsigned       mediaToStream = VOB_AUDIO | VOB_VIDEO;  // by default
+
+char const **inputFileNames;
+char const **curInputFileName;
+Boolean      haveReadOneFile = False;
+
+UsageEnvironment *    env;
+MPEG1or2Demux *       mpegDemux;
+AC3AudioStreamFramer *audioSource              = NULL;
+FramedSource *        videoSource              = NULL;
+RTPSink *             audioSink                = NULL;
+RTCPInstance *        audioRTCP                = NULL;
+RTPSink *             videoSink                = NULL;
+RTCPInstance *        videoRTCP                = NULL;
+RTSPServer *          rtspServer               = NULL;
+unsigned short const  defaultRTSPServerPortNum = 554;
+unsigned short        rtspServerPortNum        = defaultRTSPServerPortNum;
+
+Groupsock *rtpGroupsockAudio;
+Groupsock *rtcpGroupsockAudio;
+Groupsock *rtpGroupsockVideo;
+Groupsock *rtcpGroupsockVideo;
+
+void usage() {
+    *env << "usage: " << programName
+         << " [-i] [-a|-v] "
+            "[-p <RTSP-server-port-number>] "
+            "<VOB-file>...<VOB-file>\n";
+    exit(1);
+}
+
+void play();  // forward
+
+int main(int argc, char const **argv) {
+    // Begin by setting up our usage environment:
+    TaskScheduler *scheduler = BasicTaskScheduler::createNew();
+    env                      = BasicUsageEnvironment::createNew(*scheduler);
+
+    // Parse command-line options:
+    // (Unfortunately we can't use getopt() here; Windoze doesn't have it)
+    programName = argv[0];
+    while(argc > 2) {
+        char const *const opt = argv[1];
+        if(opt[0] != '-')
+            break;
+        switch(opt[1]) {
+
+        case 'i': {  // transmit video I-frames only
+            iFramesOnly = True;
+            break;
+        }
+
+        case 'a': {  // transmit audio, but not video
+            mediaToStream &= ~VOB_VIDEO;
+            break;
+        }
+
+        case 'v': {  // transmit video, but not audio
+            mediaToStream &= ~VOB_AUDIO;
+            break;
+        }
+
+        case 'p': {  // specify port number for built-in RTSP server
+            int portArg;
+            if(sscanf(argv[2], "%d", &portArg) != 1) {
+                usage();
+            }
+            if(portArg <= 0 || portArg >= 65536) {
+                *env << "bad port number: " << portArg << " (must be in the range (0,65536))\n";
+                usage();
+            }
+            rtspServerPortNum = (unsigned short)portArg;
+            ++argv;
+            --argc;
+            break;
+        }
+
+        default: {
+            usage();
+            break;
+        }
+        }
+
+        ++argv;
+        --argc;
+    }
+    if(argc < 2)
+        usage();
+    if(mediaToStream == 0) {
+        *env << "The -a and -v flags cannot both be used!\n";
+        usage();
+    }
+    if(iFramesOnly && (mediaToStream & VOB_VIDEO) == 0) {
+        *env << "Warning: Because we're not streaming video, the -i flag has no effect.\n";
+    }
+
+    inputFileNames   = &argv[1];
+    curInputFileName = inputFileNames;
+
+    // Create 'groupsocks' for RTP and RTCP:
+    struct sockaddr_storage destinationAddress;
+    destinationAddress.ss_family                               = AF_INET;
+    ((struct sockaddr_in &)destinationAddress).sin_addr.s_addr = chooseRandomIPv4SSMAddress(*env);
+    // Note: This is a multicast address.  If you wish instead to stream
+    // using unicast, then you should use the "testOnDemandRTSPServer"
+    // test program - not this test program - as a model.
+
+    const unsigned short rtpPortNumAudio  = 4444;
+    const unsigned short rtcpPortNumAudio = rtpPortNumAudio + 1;
+    const unsigned short rtpPortNumVideo  = 8888;
+    const unsigned short rtcpPortNumVideo = rtpPortNumVideo + 1;
+    const unsigned char  ttl              = 255;
+
+    const Port rtpPortAudio(rtpPortNumAudio);
+    const Port rtcpPortAudio(rtcpPortNumAudio);
+    const Port rtpPortVideo(rtpPortNumVideo);
+    const Port rtcpPortVideo(rtcpPortNumVideo);
+
+    const unsigned maxCNAMElen = 100;
+    unsigned char  CNAME[maxCNAMElen + 1];
+    gethostname((char *)CNAME, maxCNAMElen);
+    CNAME[maxCNAMElen] = '\0';  // just in case
+
+    if(mediaToStream & VOB_AUDIO) {
+        rtpGroupsockAudio = new Groupsock(*env, destinationAddress, rtpPortAudio, ttl);
+        rtpGroupsockAudio->multicastSendOnly();  // because we're a SSM source
+
+        // Create an 'AC3 Audio RTP' sink from the RTP 'groupsock':
+        audioSink = AC3AudioRTPSink::createNew(*env, rtpGroupsockAudio, 96, 0);
+        // set the RTP timestamp frequency 'for real' later
+
+        // Create (and start) a 'RTCP instance' for this RTP sink:
+        rtcpGroupsockAudio = new Groupsock(*env, destinationAddress, rtcpPortAudio, ttl);
+        rtcpGroupsockAudio->multicastSendOnly();              // because we're a SSM source
+        const unsigned estimatedSessionBandwidthAudio = 160;  // in kbps; for RTCP b/w share
+        audioRTCP = RTCPInstance::createNew(*env, rtcpGroupsockAudio, estimatedSessionBandwidthAudio, CNAME, audioSink, NULL /* we're a server */,
+                                            True /* we're a SSM source */);
+        // Note: This starts RTCP running automatically
+    }
+
+    if(mediaToStream & VOB_VIDEO) {
+        rtpGroupsockVideo = new Groupsock(*env, destinationAddress, rtpPortVideo, ttl);
+        rtpGroupsockVideo->multicastSendOnly();  // because we're a SSM source
+
+        // Create a 'MPEG Video RTP' sink from the RTP 'groupsock':
+        videoSink = MPEG1or2VideoRTPSink::createNew(*env, rtpGroupsockVideo);
+
+        // Create (and start) a 'RTCP instance' for this RTP sink:
+        rtcpGroupsockVideo = new Groupsock(*env, destinationAddress, rtcpPortVideo, ttl);
+        rtcpGroupsockVideo->multicastSendOnly();               // because we're a SSM source
+        const unsigned estimatedSessionBandwidthVideo = 4500;  // in kbps; for RTCP b/w share
+        videoRTCP = RTCPInstance::createNew(*env, rtcpGroupsockVideo, estimatedSessionBandwidthVideo, CNAME, videoSink, NULL /* we're a server */,
+                                            True /* we're a SSM source */);
+        // Note: This starts RTCP running automatically
+    }
+
+    if(rtspServer == NULL) {
+        rtspServer = RTSPServer::createNew(*env, rtspServerPortNum);
+        if(rtspServer == NULL) {
+            *env << "Failed to create RTSP server: " << env->getResultMsg() << "\n";
+            *env << "To change the RTSP server's port number, use the \"-p <port number>\" option.\n";
+            exit(1);
+        }
+        ServerMediaSession *sms = ServerMediaSession::createNew(*env, "vobStream", *curInputFileName, "Session streamed by \"vobStreamer\"", True /*SSM*/);
+        if(audioSink != NULL)
+            sms->addSubsession(PassiveServerMediaSubsession::createNew(*audioSink, audioRTCP));
+        if(videoSink != NULL)
+            sms->addSubsession(PassiveServerMediaSubsession::createNew(*videoSink, videoRTCP));
+        rtspServer->addServerMediaSession(sms);
+
+        *env << "Created RTSP server.\n";
+        announceURL(rtspServer, sms);
+    }
+
+    // Finally, start the streaming:
+    *env << "Beginning streaming...\n";
+    play();
+
+    env->taskScheduler().doEventLoop();  // does not return
+
+    return 0;  // only to prevent compiler warning
+}
+
+void afterPlaying(void *clientData) {
+    // One of the sinks has ended playing.
+    // Check whether any of the sources have a pending read.  If so,
+    // wait until its sink ends playing also:
+    if((audioSource != NULL && audioSource->isCurrentlyAwaitingData()) || (videoSource != NULL && videoSource->isCurrentlyAwaitingData())) {
+        return;
+    }
+
+    // Now that both sinks have ended, close both input sources,
+    // and start playing again:
+    *env << "...done reading from file\n";
+
+    if(audioSink != NULL)
+        audioSink->stopPlaying();
+    if(videoSink != NULL)
+        videoSink->stopPlaying();
+    // ensures that both are shut down
+    Medium::close(audioSource);
+    Medium::close(videoSource);
+    Medium::close(mpegDemux);
+    // Note: This also closes the input file that this source read from.
+
+    // Move to the next file name (if any):
+    ++curInputFileName;
+
+    // Start playing once again:
+    play();
+}
+
+void play() {
+    if(*curInputFileName == NULL) {
+        // We have reached the end of the file name list.
+        // Start again, unless we didn't succeed in reading any files:
+        if(!haveReadOneFile)
+            exit(1);
+        haveReadOneFile  = False;
+        curInputFileName = inputFileNames;
+    }
+
+    // Open the current input file as a 'byte-stream file source':
+    ByteStreamFileSource *fileSource = ByteStreamFileSource::createNew(*env, *curInputFileName);
+    if(fileSource == NULL) {
+        *env << "Unable to open file \"" << *curInputFileName << "\" as a byte-stream file source\n";
+        // Try the next file instead:
+        ++curInputFileName;
+        play();
+        return;
+    }
+    haveReadOneFile = True;
+
+    // We must demultiplex Audio and Video Elementary Streams
+    // from the input source:
+    mpegDemux = MPEG1or2Demux::createNew(*env, fileSource);
+    if(mediaToStream & VOB_AUDIO) {
+        FramedSource *audioES = mpegDemux->newElementaryStream(0xBD);
+        // Because, in a VOB file, the AC3 audio has stream id 0xBD
+        audioSource = AC3AudioStreamFramer::createNew(*env, audioES, 0x80);
+    }
+    if(mediaToStream & VOB_VIDEO) {
+        FramedSource *videoES = mpegDemux->newVideoStream();
+
+        videoSource = MPEG1or2VideoStreamFramer::createNew(*env, videoES, iFramesOnly);
+    }
+
+    // Finally, start playing each sink.
+    *env << "Beginning to read from \"" << *curInputFileName << "\"...\n";
+    if(videoSink != NULL) {
+        videoSink->startPlaying(*videoSource, afterPlaying, videoSink);
+    }
+    if(audioSink != NULL) {
+        audioSink->setRTPTimestampFrequency(audioSource->samplingRate());
+        audioSink->startPlaying(*audioSource, afterPlaying, audioSink);
+    }
+}
diff --git a/3rdparty/live555/src/win32config b/3rdparty/live555/src/win32config
new file mode 100644
index 00000000..e74cb22a
--- /dev/null
+++ b/3rdparty/live555/src/win32config
@@ -0,0 +1,47 @@
+# Comment out the following line to produce Makefiles that generate debuggable code:
+NODEBUG=1
+
+# The following definition ensures that we are properly matching
+# the WinSock2 library file with the correct header files.
+# (will link with "ws2_32.lib" and include "winsock2.h" & "Ws2tcpip.h")
+TARGETOS = WINNT
+
+# If for some reason you wish to use WinSock1 instead, uncomment the
+# following two definitions.
+# (will link with "wsock32.lib" and include "winsock.h")
+#TARGETOS = WIN95
+#APPVER = 4.0
+
+!include    <ntwin32.mak>
+
+UI_OPTS =		$(guilflags) $(guilibsdll)
+# Use the following to get a console (e.g., for debugging):
+CONSOLE_UI_OPTS =		$(conlflags) $(conlibsdll)
+CPU=i386
+
+TOOLS32	=		c:\Program Files\DevStudio\Vc
+COMPILE_OPTS =		$(INCLUDES) $(cdebug) $(cflags) $(cvarsdll) -I. -I"$(TOOLS32)\include" -DNO_OPENSSL=1
+C =			c
+C_COMPILER =		"$(TOOLS32)\bin\cl"
+C_FLAGS =		$(COMPILE_OPTS)
+CPP =			cpp
+CPLUSPLUS_COMPILER =	$(C_COMPILER)
+CPLUSPLUS_FLAGS =	$(COMPILE_OPTS)
+OBJ =			obj
+LINK =			$(link) -out:
+LIBRARY_LINK =		lib -out:
+LINK_OPTS_0 =		$(linkdebug) msvcirt.lib
+LIBRARY_LINK_OPTS =	
+LINK_OPTS =		$(LINK_OPTS_0) $(UI_OPTS)
+CONSOLE_LINK_OPTS =	$(LINK_OPTS_0) $(CONSOLE_UI_OPTS)
+SERVICE_LINK_OPTS =     kernel32.lib advapi32.lib shell32.lib -subsystem:console,$(APPVER)
+LIB_SUFFIX =		lib
+LIBS_FOR_CONSOLE_APPLICATION =
+LIBS_FOR_GUI_APPLICATION =
+MULTIMEDIA_LIBS =	winmm.lib
+EXE =			.exe
+PLATFORM = Windows
+
+rc32 = "$(TOOLS32)\bin\rc"
+.rc.res:
+	$(rc32) $<
diff --git a/3rdparty/live555/src/win32config.Borland b/3rdparty/live555/src/win32config.Borland
new file mode 100644
index 00000000..edc12190
--- /dev/null
+++ b/3rdparty/live555/src/win32config.Borland
@@ -0,0 +1,46 @@
+# Comment out the following line to produce Makefiles that generate debuggable code:
+NODEBUG=1
+
+# The following definition ensures that we are properly matching
+# the WinSock2 library file with the correct header files.
+# (will link with "ws2_32.lib" and include "winsock2.h" & "Ws2tcpip.h")
+TARGETOS = WINNT
+
+# If for some reason you wish to use WinSock1 instead, uncomment the
+# following two definitions.
+# (will link with "wsock32.lib" and include "winsock.h")
+#TARGETOS = WIN95
+#APPVER = 4.0
+
+#!include    <ntwin32.mak>
+
+UI_OPTS =		$(guilflags) $(guilibsdll)
+# Use the following to get a console (e.g., for debugging):
+CONSOLE_UI_OPTS =		$(conlflags) $(conlibsdll)
+CPU=i386
+
+TOOLS32	=		C:\Progra~1\Borland\CBuilder5
+COMPILE_OPTS =		$(INCLUDES) $(cdebug) $(cflags) $(cvarsdll) -I. -I$(TOOLS32)\include -DNO_OPENSSL=1
+C =			c
+C_COMPILER =		$(TOOLS32)\bin\bcc32
+C_FLAGS =		$(COMPILE_OPTS)
+CPP =			cpp
+CPLUSPLUS_COMPILER =	$(C_COMPILER)
+CPLUSPLUS_FLAGS =	$(COMPILE_OPTS)
+OBJ =			obj
+LINK =			$(TOOLS32)\bin\ilink32
+LIBRARY_LINK =		$(TOOLS32)\bin\tlib 
+LINK_OPTS_0 =		$(linkdebug) msvcirt.lib
+LIBRARY_LINK_OPTS =	/u
+LINK_OPTS =		$(LINK_OPTS_0) $(UI_OPTS)
+CONSOLE_LINK_OPTS =	c0x32 
+
+SERVICE_LINK_OPTS =     kernel32.lib advapi32.lib shell32.lib -subsystem:console,$(APPVER)
+LIB_SUFFIX =		lib
+LIBS_FOR_CONSOLE_APPLICATION = cw32.lib import32.lib
+LIBS_FOR_GUI_APPLICATION = ,,cw32
+EXE =	
+
+rc32 = $(TOOLS32)\bin\brc32"
+.rc.res:
+	$(rc32) $<
diff --git a/3rdparty/readme.md b/3rdparty/readme.md
new file mode 100644
index 00000000..0829b04e
--- /dev/null
+++ b/3rdparty/readme.md
@@ -0,0 +1,18 @@
+# Third-party Libraries
+
+This folder contains third-party libraries used by the OrbbecSDK.
+
+The libraries included in this folder are:
+
+| Library        | Description                                                                   | License      | Link                                              |
+| -------------- | ----------------------------------------------------------------------------- | ------------ | ------------------------------------------------- |
+| libusb         | A cross-platform library for USB device access                                | LGPL-2.1     | <https://github.com/libusb/libusb>                |
+| libuvc         | A cross-platform library for USB video device access                          | BSD          | <https://github.com/ktossell/libuvc>              |
+| spdlog v1.11.0 | A fast C++ logging library                                                    | MIT          | <https://github.com/gabime/spdlog>                |
+| dylib v2.2.1   | A cross-platform shared library loader                                        | MIT          | <https://github.com/martin-olivier/dylib>         |
+| libjpeg-turbo v2.0   | A JPEG image codec library         | BSD-3-Clause | <https://github.com/libjpeg-turbo/libjpeg-turbo>  |
+| libyuv         | An open source project that includes YUV scaling and conversion functionality | BSD-3-Clause | <https://chromium.googlesource.com/libyuv/libyuv> |
+| live555        | A library for streaming media over the network                                | LGPL         | <http://www.live555.com/>                           |
+| tinyxml2       | A simple, small, efficient, C++ XML parser                                    | Zlib         | <https://github.com/leethomason/tinyxml2>           |
+| cmrc           | A Resource Compiler in a Single CMake Script                                  | MIT          | <https://github.com/vector-of-bool/cmrc>          |
+| josncpp        | A C++ library for interacting with JSON.                                      | MIT          | <https://github.com/open-source-parsers/jsoncpp>   |
\ No newline at end of file
diff --git a/3rdparty/spdlog/CMakeLists.txt b/3rdparty/spdlog/CMakeLists.txt
new file mode 100644
index 00000000..a8f4c11c
--- /dev/null
+++ b/3rdparty/spdlog/CMakeLists.txt
@@ -0,0 +1,9 @@
+cmake_minimum_required(VERSION 3.5)
+
+add_subdirectory(src)
+ob_source_group(spdlog::spdlog)
+set_target_properties(spdlog PROPERTIES FOLDER "dependencies")
+
+get_target_property(compile_options spdlog COMPILE_OPTIONS)
+list(REMOVE_ITEM compile_options "-Werror" "/WX")
+set_target_properties(spdlog PROPERTIES COMPILE_OPTIONS "${compile_options}")
diff --git a/3rdparty/spdlog/src/.clang-format b/3rdparty/spdlog/src/.clang-format
new file mode 100644
index 00000000..222faea4
--- /dev/null
+++ b/3rdparty/spdlog/src/.clang-format
@@ -0,0 +1,109 @@
+---
+Language:        Cpp
+# BasedOnStyle:  LLVM
+AccessModifierOffset: -4
+AlignAfterOpenBracket: DontAlign
+AlignConsecutiveAssignments: false
+AlignConsecutiveDeclarations: false
+AlignEscapedNewlines: Right
+AlignOperands:   true
+AlignTrailingComments: true
+AllowAllParametersOfDeclarationOnNextLine: true
+AllowShortBlocksOnASingleLine: true
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: Empty
+AllowShortIfStatementsOnASingleLine: false
+AllowShortLoopsOnASingleLine: false
+AlwaysBreakAfterDefinitionReturnType: None
+AlwaysBreakAfterReturnType: None
+AlwaysBreakBeforeMultilineStrings: false
+AlwaysBreakTemplateDeclarations: true
+BinPackArguments: true
+BinPackParameters: true
+BraceWrapping:     
+  AfterClass:      true
+  AfterControlStatement: true
+  AfterEnum:       true
+  AfterFunction:   true
+  AfterNamespace:  false
+  AfterObjCDeclaration: true
+  AfterStruct:     true
+  AfterUnion:      true
+  BeforeCatch:     true
+  BeforeElse:      true
+  IndentBraces:    false
+  SplitEmptyFunction: false
+  SplitEmptyRecord: false
+  SplitEmptyNamespace: false
+BreakBeforeBinaryOperators: None
+BreakBeforeBraces: Custom
+BreakBeforeInheritanceComma: false
+BreakBeforeTernaryOperators: true
+BreakConstructorInitializersBeforeComma: true
+BreakConstructorInitializers: BeforeColon
+BreakAfterJavaFieldAnnotations: false
+BreakStringLiterals: true
+ColumnLimit:     140
+CommentPragmas:  '^ IWYU pragma:'
+CompactNamespaces:  false
+ConstructorInitializerAllOnOneLineOrOnePerLine: false
+ConstructorInitializerIndentWidth: 4
+ContinuationIndentWidth: 4
+Cpp11BracedListStyle: true
+DerivePointerAlignment: false
+DisableFormat:   false
+ExperimentalAutoDetectBinPacking: false
+FixNamespaceComments: true
+ForEachMacros:   
+  - foreach
+  - Q_FOREACH
+  - BOOST_FOREACH
+IncludeCategories: 
+  - Regex:           '^"(llvm|llvm-c|clang|clang-c)/'
+    Priority:        2
+  - Regex:           '^(<|"(gtest|gmock|isl|json)/)'
+    Priority:        3
+  - Regex:           '.*'
+    Priority:        1
+IncludeIsMainRegex: '(Test)?$'
+IndentCaseLabels: false
+IndentWidth:     4
+IndentWrappedFunctionNames: false
+JavaScriptQuotes: Leave
+JavaScriptWrapImports: true
+KeepEmptyLinesAtTheStartOfBlocks: true
+MacroBlockBegin: ''
+MacroBlockEnd:   ''
+MaxEmptyLinesToKeep: 1
+NamespaceIndentation: None
+ObjCBlockIndentWidth: 2
+ObjCSpaceAfterProperty: false
+ObjCSpaceBeforeProtocolList: true
+PenaltyBreakAssignment: 2
+PenaltyBreakBeforeFirstCallParameter: 19
+PenaltyBreakComment: 300
+PenaltyBreakFirstLessLess: 120
+PenaltyBreakString: 1000
+PenaltyExcessCharacter: 1000000
+PenaltyReturnTypeOnItsOwnLine: 60
+PointerAlignment: Right
+ReflowComments:  true
+SortIncludes:    false
+SortUsingDeclarations: true
+SpaceAfterCStyleCast: false
+SpaceAfterTemplateKeyword: false
+SpaceBeforeAssignmentOperators: true
+SpaceBeforeParens: ControlStatements
+SpaceInEmptyParentheses: false
+SpacesBeforeTrailingComments: 1
+SpacesInAngles:  false
+SpacesInContainerLiterals: true
+SpacesInCStyleCastParentheses: false
+SpacesInParentheses: false
+SpacesInSquareBrackets: false
+Standard:        Cpp11
+TabWidth:        8
+UseTab:          Never
+IndentPPDirectives: AfterHash
+...
+
diff --git a/3rdparty/spdlog/src/.clang-tidy b/3rdparty/spdlog/src/.clang-tidy
new file mode 100644
index 00000000..34239d6b
--- /dev/null
+++ b/3rdparty/spdlog/src/.clang-tidy
@@ -0,0 +1,54 @@
+Checks: 'cppcoreguidelines-*,
+performance-*,
+modernize-*,
+google-*,
+misc-*
+cert-*,
+readability-*,
+clang-analyzer-*,
+-performance-unnecessary-value-param,
+-modernize-use-trailing-return-type,
+-google-runtime-references,
+-misc-non-private-member-variables-in-classes,
+-readability-braces-around-statements,
+-google-readability-braces-around-statements,
+-cppcoreguidelines-avoid-magic-numbers,
+-readability-magic-numbers,
+-readability-magic-numbers,
+-cppcoreguidelines-pro-type-vararg,
+-cppcoreguidelines-pro-bounds-pointer-arithmetic,
+-cppcoreguidelines-avoid-c-arrays,
+-modernize-avoid-c-arrays,
+-cppcoreguidelines-pro-bounds-array-to-pointer-decay,
+-readability-named-parameter,
+-cert-env33-c
+'
+
+
+WarningsAsErrors: ''
+HeaderFilterRegex: '*spdlog/[^f].*'
+AnalyzeTemporaryDtors: false
+FormatStyle:     none
+
+CheckOptions:    
+  - key:             google-readability-braces-around-statements.ShortStatementLines
+    value:           '1'
+  - key:             google-readability-function-size.StatementThreshold
+    value:           '800'
+  - key:             google-readability-namespace-comments.ShortNamespaceLines
+    value:           '10'
+  - key:             google-readability-namespace-comments.SpacesBeforeComments
+    value:           '2'
+  - key:             modernize-loop-convert.MaxCopySize
+    value:           '16'
+  - key:             modernize-loop-convert.MinConfidence
+    value:           reasonable
+  - key:             modernize-loop-convert.NamingStyle
+    value:           CamelCase
+  - key:             modernize-pass-by-value.IncludeStyle
+    value:           llvm
+  - key:             modernize-replace-auto-ptr.IncludeStyle
+    value:           llvm
+  - key:             modernize-use-nullptr.NullMacros
+    value:           'NULL'
+
diff --git a/3rdparty/spdlog/src/.gitattributes b/3rdparty/spdlog/src/.gitattributes
new file mode 100644
index 00000000..fe505b27
--- /dev/null
+++ b/3rdparty/spdlog/src/.gitattributes
@@ -0,0 +1 @@
+* text=false
diff --git a/3rdparty/spdlog/src/.gitignore b/3rdparty/spdlog/src/.gitignore
new file mode 100644
index 00000000..c4688ca7
--- /dev/null
+++ b/3rdparty/spdlog/src/.gitignore
@@ -0,0 +1,92 @@
+# Auto generated files
+[Dd]ebug/
+[Rr]elease/
+build/*
+*.slo
+*.lo
+*.o
+*.obj
+*.suo
+*.tlog
+*.ilk
+*.log
+*.pdb
+*.idb
+*.iobj
+*.ipdb
+*.opensdf
+*.sdf
+
+# Compiled Dynamic libraries
+*.so
+*.Dylib
+*.dll
+
+# Compiled Static libraries
+*.lai
+*.la
+*.a
+*.lib
+
+# Executables
+*.exe
+*.out
+*.app
+
+# Codelite
+.codelite
+
+# KDevelop
+*.kdev4
+
+# .orig files
+*.orig
+
+# example  files
+example/*
+!example/example.cpp
+!example/bench.cpp
+!example/utils.h
+!example/Makefile*
+!example/example.sln
+!example/example.vcxproj
+!example/CMakeLists.txt
+!example/meson.build
+!example/multisink.cpp
+!example/jni
+
+# generated files
+generated
+version.rc
+
+# Cmake
+CMakeCache.txt
+CMakeFiles
+CMakeScripts
+Makefile
+cmake_install.cmake
+install_manifest.txt
+/tests/tests.VC.VC.opendb
+/tests/tests.VC.db
+/tests/tests
+/tests/logs/*
+spdlogConfig.cmake
+spdlogConfigVersion.cmake
+
+# idea
+.idea/
+cmake-build-*/
+*.db
+*.ipch
+*.filters
+*.db-wal
+*.opendb
+*.db-shm
+*.vcxproj
+*.tcl
+*.user
+*.sln
+
+# macos
+*.DS_store
+*.xcodeproj/
diff --git a/3rdparty/spdlog/src/CMakeLists.txt b/3rdparty/spdlog/src/CMakeLists.txt
new file mode 100644
index 00000000..3830dfe2
--- /dev/null
+++ b/3rdparty/spdlog/src/CMakeLists.txt
@@ -0,0 +1,353 @@
+# Copyright(c) 2019 spdlog authors Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+cmake_minimum_required(VERSION 3.10...3.21)
+
+# ---------------------------------------------------------------------------------------
+# Start spdlog project
+# ---------------------------------------------------------------------------------------
+include(cmake/utils.cmake)
+include(cmake/ide.cmake)
+
+spdlog_extract_version()
+
+project(spdlog VERSION ${SPDLOG_VERSION} LANGUAGES CXX)
+message(STATUS "Build spdlog: ${SPDLOG_VERSION}")
+
+include(GNUInstallDirs)
+
+# ---------------------------------------------------------------------------------------
+# Set default build to release
+# ---------------------------------------------------------------------------------------
+if(NOT CMAKE_BUILD_TYPE)
+    set(CMAKE_BUILD_TYPE "Release" CACHE STRING "Choose Release or Debug" FORCE)
+endif()
+
+# ---------------------------------------------------------------------------------------
+# Compiler config
+# ---------------------------------------------------------------------------------------
+if(SPDLOG_USE_STD_FORMAT)
+    set(CMAKE_CXX_STANDARD 20)
+    set(CMAKE_CXX_STANDARD_REQUIRED ON)
+elseif(NOT CMAKE_CXX_STANDARD)
+    set(CMAKE_CXX_STANDARD 11)
+    set(CMAKE_CXX_STANDARD_REQUIRED ON)
+endif()
+
+# make sure __cplusplus is defined when using msvc and enable parallel build
+if(MSVC)
+    string(APPEND CMAKE_CXX_FLAGS " /Zc:__cplusplus /MP")
+endif()
+
+set(CMAKE_CXX_EXTENSIONS OFF)
+
+if(CMAKE_SYSTEM_NAME MATCHES "CYGWIN" OR CMAKE_SYSTEM_NAME MATCHES "MSYS")
+    set(CMAKE_CXX_EXTENSIONS ON)
+endif()
+
+# ---------------------------------------------------------------------------------------
+# Set SPDLOG_MASTER_PROJECT to ON if we are building spdlog
+# ---------------------------------------------------------------------------------------
+# Check if spdlog is being used directly or via add_subdirectory, but allow overriding
+if(NOT DEFINED SPDLOG_MASTER_PROJECT)
+    if(CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR)
+        set(SPDLOG_MASTER_PROJECT ON)
+    else()
+        set(SPDLOG_MASTER_PROJECT OFF)
+    endif()
+endif()
+
+option(SPDLOG_BUILD_ALL "Build all artifacts" OFF)
+
+# build shared option
+option(SPDLOG_BUILD_SHARED "Build shared library" OFF)
+
+# precompiled headers option
+option(SPDLOG_ENABLE_PCH "Build static or shared library using precompiled header to speed up compilation time" OFF)
+
+# build position independent code
+option(SPDLOG_BUILD_PIC "Build position independent code (-fPIC)" OFF)
+
+# example options
+option(SPDLOG_BUILD_EXAMPLE "Build example" ${SPDLOG_MASTER_PROJECT})
+option(SPDLOG_BUILD_EXAMPLE_HO "Build header only example" OFF)
+
+# testing options
+option(SPDLOG_BUILD_TESTS "Build tests" OFF)
+option(SPDLOG_BUILD_TESTS_HO "Build tests using the header only version" OFF)
+
+# bench options
+option(SPDLOG_BUILD_BENCH "Build benchmarks (Requires https://github.com/google/benchmark.git to be installed)" OFF)
+
+# sanitizer options
+option(SPDLOG_SANITIZE_ADDRESS "Enable address sanitizer in tests" OFF)
+
+# warning options
+option(SPDLOG_BUILD_WARNINGS "Enable compiler warnings" OFF)
+
+# install options
+option(SPDLOG_SYSTEM_INCLUDES "Include as system headers (skip for clang-tidy)." OFF)
+option(SPDLOG_INSTALL "Generate the install target" ${SPDLOG_MASTER_PROJECT})
+option(SPDLOG_USE_STD_FORMAT "Use std::format instead of fmt library." OFF)
+option(SPDLOG_FMT_EXTERNAL "Use external fmt library instead of bundled" OFF)
+option(SPDLOG_FMT_EXTERNAL_HO "Use external fmt header-only library instead of bundled" OFF)
+option(SPDLOG_NO_EXCEPTIONS "Compile with -fno-exceptions. Call abort() on any spdlog exceptions" OFF)
+
+if(SPDLOG_FMT_EXTERNAL AND SPDLOG_FMT_EXTERNAL_HO)
+    message(FATAL_ERROR "SPDLOG_FMT_EXTERNAL and SPDLOG_FMT_EXTERNAL_HO are mutually exclusive")
+endif()
+
+if(SPDLOG_USE_STD_FORMAT AND SPDLOG_FMT_EXTERNAL_HO)
+    message(FATAL_ERROR "SPDLOG_USE_STD_FORMAT and SPDLOG_FMT_EXTERNAL_HO are mutually exclusive")
+endif()
+
+if(SPDLOG_USE_STD_FORMAT AND SPDLOG_FMT_EXTERNAL)
+    message(FATAL_ERROR "SPDLOG_USE_STD_FORMAT and SPDLOG_FMT_EXTERNAL are mutually exclusive")
+endif()
+
+# misc tweakme options
+if(WIN32)
+    option(SPDLOG_WCHAR_SUPPORT "Support wchar api" OFF)
+    option(SPDLOG_WCHAR_FILENAMES "Support wchar filenames" OFF)
+else()
+    set(SPDLOG_WCHAR_SUPPORT OFF CACHE BOOL "non supported option" FORCE)
+    set(SPDLOG_WCHAR_FILENAMES OFF CACHE BOOL "non supported option" FORCE)
+endif()
+
+if(${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
+    option(SPDLOG_CLOCK_COARSE "Use CLOCK_REALTIME_COARSE instead of the regular clock," OFF)
+else()
+    set(SPDLOG_CLOCK_COARSE OFF CACHE BOOL "non supported option" FORCE)
+endif()
+
+option(SPDLOG_PREVENT_CHILD_FD "Prevent from child processes to inherit log file descriptors" OFF)
+option(SPDLOG_NO_THREAD_ID "prevent spdlog from querying the thread id on each log call if thread id is not needed" OFF)
+option(SPDLOG_NO_TLS "prevent spdlog from using thread local storage" OFF)
+option(
+    SPDLOG_NO_ATOMIC_LEVELS
+    "prevent spdlog from using of std::atomic log levels (use only if your code never modifies log levels concurrently"
+    OFF)
+option(SPDLOG_DISABLE_DEFAULT_LOGGER "Disable default logger creation" OFF)
+
+# clang-tidy
+if(${CMAKE_VERSION} VERSION_GREATER "3.5")
+    option(SPDLOG_TIDY "run clang-tidy" OFF)
+endif()
+
+if(SPDLOG_TIDY)
+    set(CMAKE_CXX_CLANG_TIDY "clang-tidy")
+    set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+    message(STATUS "Enabled clang-tidy")
+endif()
+
+if(SPDLOG_BUILD_PIC)
+    set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+endif()
+
+find_package(Threads REQUIRED)
+message(STATUS "Build type: " ${CMAKE_BUILD_TYPE})
+# ---------------------------------------------------------------------------------------
+# Static/Shared library
+# ---------------------------------------------------------------------------------------
+set(SPDLOG_SRCS src/spdlog.cpp src/stdout_sinks.cpp src/color_sinks.cpp src/file_sinks.cpp src/async.cpp src/cfg.cpp)
+
+if(NOT SPDLOG_USE_STD_FORMAT AND NOT SPDLOG_FMT_EXTERNAL AND NOT SPDLOG_FMT_EXTERNAL_HO)
+    list(APPEND SPDLOG_SRCS src/bundled_fmtlib_format.cpp)
+endif()
+
+if(SPDLOG_BUILD_SHARED OR BUILD_SHARED_LIBS)
+    if(WIN32)
+        configure_file(${CMAKE_CURRENT_SOURCE_DIR}/cmake/version.rc.in ${CMAKE_CURRENT_BINARY_DIR}/version.rc @ONLY)
+        list(APPEND SPDLOG_SRCS ${CMAKE_CURRENT_BINARY_DIR}/version.rc)
+    endif()
+    add_library(spdlog SHARED ${SPDLOG_SRCS} ${SPDLOG_ALL_HEADERS})
+    target_compile_definitions(spdlog PUBLIC SPDLOG_SHARED_LIB)
+    if(MSVC)
+        target_compile_options(spdlog PUBLIC $<$<AND:$<CXX_COMPILER_ID:MSVC>,$<NOT:$<COMPILE_LANGUAGE:CUDA>>>:/wd4251
+                                             /wd4275>)
+    endif()
+    if(NOT SPDLOG_USE_STD_FORMAT AND NOT SPDLOG_FMT_EXTERNAL AND NOT SPDLOG_FMT_EXTERNAL_HO)
+        target_compile_definitions(spdlog PRIVATE FMT_EXPORT PUBLIC FMT_SHARED)
+    endif()
+else()
+    add_library(spdlog STATIC ${SPDLOG_SRCS} ${SPDLOG_ALL_HEADERS})
+endif()
+
+add_library(spdlog::spdlog ALIAS spdlog)
+
+set(SPDLOG_INCLUDES_LEVEL "")
+if(SPDLOG_SYSTEM_INCLUDES)
+    set(SPDLOG_INCLUDES_LEVEL "SYSTEM")
+endif()
+
+target_compile_definitions(spdlog PUBLIC SPDLOG_COMPILED_LIB)
+target_include_directories(spdlog ${SPDLOG_INCLUDES_LEVEL} PUBLIC "$<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/include>"
+                                         "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>")
+target_link_libraries(spdlog PUBLIC Threads::Threads)
+spdlog_enable_warnings(spdlog)
+
+set_target_properties(spdlog PROPERTIES VERSION ${SPDLOG_VERSION} SOVERSION ${SPDLOG_VERSION_MAJOR}.${SPDLOG_VERSION_MINOR})
+set_target_properties(spdlog PROPERTIES DEBUG_POSTFIX d)
+
+if(COMMAND target_precompile_headers AND SPDLOG_ENABLE_PCH)
+    configure_file(${CMAKE_CURRENT_SOURCE_DIR}/cmake/pch.h.in ${PROJECT_BINARY_DIR}/spdlog_pch.h @ONLY)
+    target_precompile_headers(spdlog PRIVATE ${PROJECT_BINARY_DIR}/spdlog_pch.h)
+endif()
+
+# ---------------------------------------------------------------------------------------
+# Header only version
+# ---------------------------------------------------------------------------------------
+add_library(spdlog_header_only INTERFACE)
+add_library(spdlog::spdlog_header_only ALIAS spdlog_header_only)
+
+target_include_directories(spdlog_header_only ${SPDLOG_INCLUDES_LEVEL} INTERFACE "$<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/include>"
+                                                        "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>")
+target_link_libraries(spdlog_header_only INTERFACE Threads::Threads)
+
+# ---------------------------------------------------------------------------------------
+# Use fmt package if using external fmt
+# ---------------------------------------------------------------------------------------
+if(SPDLOG_FMT_EXTERNAL OR SPDLOG_FMT_EXTERNAL_HO)
+    if(NOT TARGET fmt::fmt)
+        find_package(fmt CONFIG REQUIRED)
+    endif()
+    target_compile_definitions(spdlog PUBLIC SPDLOG_FMT_EXTERNAL)
+    target_compile_definitions(spdlog_header_only INTERFACE SPDLOG_FMT_EXTERNAL)
+
+    # use external fmt-header-nly
+    if(SPDLOG_FMT_EXTERNAL_HO)
+        target_link_libraries(spdlog PUBLIC fmt::fmt-header-only)
+        target_link_libraries(spdlog_header_only INTERFACE fmt::fmt-header-only)
+    else() # use external compile fmt
+        target_link_libraries(spdlog PUBLIC fmt::fmt)
+        target_link_libraries(spdlog_header_only INTERFACE fmt::fmt)
+    endif()
+
+    set(PKG_CONFIG_REQUIRES fmt) # add dependency to pkg-config
+endif()
+
+# ---------------------------------------------------------------------------------------
+# Add required libraries for Android CMake build
+# ---------------------------------------------------------------------------------------
+if(ANDROID)
+    target_link_libraries(spdlog PUBLIC log)
+    target_link_libraries(spdlog_header_only INTERFACE log)
+endif()
+
+# ---------------------------------------------------------------------------------------
+# Misc definitions according to tweak options
+# ---------------------------------------------------------------------------------------
+set(SPDLOG_WCHAR_TO_UTF8_SUPPORT ${SPDLOG_WCHAR_SUPPORT})
+foreach(
+    SPDLOG_OPTION
+    SPDLOG_WCHAR_TO_UTF8_SUPPORT
+    SPDLOG_WCHAR_FILENAMES
+    SPDLOG_NO_EXCEPTIONS
+    SPDLOG_CLOCK_COARSE
+    SPDLOG_PREVENT_CHILD_FD
+    SPDLOG_NO_THREAD_ID
+    SPDLOG_NO_TLS
+    SPDLOG_NO_ATOMIC_LEVELS
+    SPDLOG_DISABLE_DEFAULT_LOGGER
+    SPDLOG_USE_STD_FORMAT)
+    if(${SPDLOG_OPTION})
+        target_compile_definitions(spdlog PUBLIC ${SPDLOG_OPTION})
+        target_compile_definitions(spdlog_header_only INTERFACE ${SPDLOG_OPTION})
+    endif()
+endforeach()
+
+if(SPDLOG_NO_EXCEPTIONS AND NOT MSVC)
+    target_compile_options(spdlog PRIVATE -fno-exceptions)
+endif()
+
+# ---------------------------------------------------------------------------------------
+# Build binaries
+# ---------------------------------------------------------------------------------------
+if(SPDLOG_BUILD_EXAMPLE OR SPDLOG_BUILD_EXAMPLE_HO OR SPDLOG_BUILD_ALL)
+    message(STATUS "Generating example(s)")
+    add_subdirectory(example)
+    spdlog_enable_warnings(example)
+    if(SPDLOG_BUILD_EXAMPLE_HO)
+        spdlog_enable_warnings(example_header_only)
+    endif()
+endif()
+
+if(SPDLOG_BUILD_TESTS OR SPDLOG_BUILD_TESTS_HO OR SPDLOG_BUILD_ALL)
+    message(STATUS "Generating tests")
+    enable_testing()
+    add_subdirectory(tests)
+endif()
+
+if(SPDLOG_BUILD_BENCH OR SPDLOG_BUILD_ALL)
+    message(STATUS "Generating benchmarks")
+    add_subdirectory(bench)
+endif()
+
+# ---------------------------------------------------------------------------------------
+# Install
+# ---------------------------------------------------------------------------------------
+if(SPDLOG_INSTALL)
+    message(STATUS "Generating install")
+    set(project_config_in "${CMAKE_CURRENT_LIST_DIR}/cmake/spdlogConfig.cmake.in")
+    set(project_config_out "${CMAKE_CURRENT_BINARY_DIR}/spdlogConfig.cmake")
+    set(config_targets_file "spdlogConfigTargets.cmake")
+    set(version_config_file "${CMAKE_CURRENT_BINARY_DIR}/spdlogConfigVersion.cmake")
+    set(export_dest_dir "${CMAKE_INSTALL_LIBDIR}/cmake/spdlog")
+    set(pkgconfig_install_dir "${CMAKE_INSTALL_LIBDIR}/pkgconfig")
+    set(pkg_config "${CMAKE_BINARY_DIR}/${PROJECT_NAME}.pc")
+
+    # ---------------------------------------------------------------------------------------
+    # Include files
+    # ---------------------------------------------------------------------------------------
+    install(DIRECTORY include/ DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}" PATTERN "fmt/bundled" EXCLUDE)
+    install(
+        TARGETS spdlog spdlog_header_only
+        EXPORT spdlog
+        LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+        ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+        RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
+
+    if(NOT SPDLOG_USE_STD_FORMAT AND NOT SPDLOG_FMT_EXTERNAL AND NOT SPDLOG_FMT_EXTERNAL_HO)
+        install(DIRECTORY include/${PROJECT_NAME}/fmt/bundled/
+                DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/${PROJECT_NAME}/fmt/bundled/")
+    endif()
+
+    # ---------------------------------------------------------------------------------------
+    # Install pkg-config file
+    # ---------------------------------------------------------------------------------------
+    if (IS_ABSOLUTE "${CMAKE_INSTALL_INCLUDEDIR}")
+        set(PKG_CONFIG_INCLUDEDIR "${CMAKE_INSTALL_INCLUDEDIR}")
+    else()
+        set(PKG_CONFIG_INCLUDEDIR "\${prefix}/${CMAKE_INSTALL_INCLUDEDIR}")
+    endif()
+    if (IS_ABSOLUTE "${CMAKE_INSTALL_LIBDIR}")
+        set(PKG_CONFIG_LIBDIR "${CMAKE_INSTALL_LIBDIR}")
+    else()
+        set(PKG_CONFIG_LIBDIR "\${exec_prefix}/${CMAKE_INSTALL_LIBDIR}")
+    endif()
+    get_target_property(PKG_CONFIG_DEFINES spdlog INTERFACE_COMPILE_DEFINITIONS)
+    string(REPLACE ";" " -D" PKG_CONFIG_DEFINES "${PKG_CONFIG_DEFINES}")
+    string(CONCAT PKG_CONFIG_DEFINES "-D" "${PKG_CONFIG_DEFINES}")
+    configure_file("cmake/${PROJECT_NAME}.pc.in" "${pkg_config}" @ONLY)
+    install(FILES "${pkg_config}" DESTINATION "${pkgconfig_install_dir}")
+
+    # ---------------------------------------------------------------------------------------
+    # Install CMake config files
+    # ---------------------------------------------------------------------------------------
+    export(
+      TARGETS spdlog
+      NAMESPACE spdlog::
+      FILE "${CMAKE_CURRENT_BINARY_DIR}/${config_targets_file}")
+    install(EXPORT spdlog DESTINATION ${export_dest_dir} NAMESPACE spdlog:: FILE ${config_targets_file})
+
+    include(CMakePackageConfigHelpers)
+    configure_package_config_file("${project_config_in}" "${project_config_out}"
+        INSTALL_DESTINATION ${export_dest_dir})
+
+    write_basic_package_version_file("${version_config_file}" COMPATIBILITY SameMajorVersion)
+    install(FILES "${project_config_out}" "${version_config_file}" DESTINATION "${export_dest_dir}")
+
+    # ---------------------------------------------------------------------------------------
+    # Support creation of installable packages
+    # ---------------------------------------------------------------------------------------
+    include(cmake/spdlogCPack.cmake)
+endif()
diff --git a/3rdparty/spdlog/src/INSTALL b/3rdparty/spdlog/src/INSTALL
new file mode 100644
index 00000000..47d4a7df
--- /dev/null
+++ b/3rdparty/spdlog/src/INSTALL
@@ -0,0 +1,24 @@
+Header only version:
+==================================================================
+Just copy the files to your build tree and use a C++11 compiler.
+Or use CMake:
+  add_executable(example_header_only example.cpp)
+  target_link_libraries(example_header_only spdlog::spdlog_header_only)
+
+
+Compiled library version:
+==================================================================
+CMake:
+  add_executable(example example.cpp)
+  target_link_libraries(example spdlog::spdlog)
+
+Or copy src/spdlog.cpp to your build tree and pass the -DSPDLOG_COMPILED_LIB to the compiler.
+
+Tested on:
+gcc 4.8.1 and above
+clang 3.5
+Visual Studio 2013
+
+
+
+
diff --git a/3rdparty/spdlog/src/LICENSE b/3rdparty/spdlog/src/LICENSE
new file mode 100644
index 00000000..c15941bc
--- /dev/null
+++ b/3rdparty/spdlog/src/LICENSE
@@ -0,0 +1,26 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Gabi Melman.                                       
+
+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.
+
+-- NOTE: Third party dependency used by this software --
+This software depends on the fmt lib (MIT License),
+and users must comply to its license: https://github.com/fmtlib/fmt/blob/master/LICENSE.rst
+
diff --git a/3rdparty/spdlog/src/README.md b/3rdparty/spdlog/src/README.md
new file mode 100644
index 00000000..627297c3
--- /dev/null
+++ b/3rdparty/spdlog/src/README.md
@@ -0,0 +1,484 @@
+# spdlog
+
+Very fast, header-only/compiled, C++ logging library. [![ci](https://github.com/gabime/spdlog/actions/workflows/ci.yml/badge.svg)](https://github.com/gabime/spdlog/actions/workflows/ci.yml)&nbsp; [![Build status](https://ci.appveyor.com/api/projects/status/d2jnxclg20vd0o50?svg=true&branch=v1.x)](https://ci.appveyor.com/project/gabime/spdlog) [![Release](https://img.shields.io/github/release/gabime/spdlog.svg)](https://github.com/gabime/spdlog/releases/latest)
+
+## Install 
+#### Header-only version
+Copy the include [folder](https://github.com/gabime/spdlog/tree/v1.x/include/spdlog) to your build tree and use a C++11 compiler.
+
+#### Compiled version (recommended - much faster compile times)
+```console
+$ git clone https://github.com/gabime/spdlog.git
+$ cd spdlog && mkdir build && cd build
+$ cmake .. && make -j
+```
+      
+   see example [CMakeLists.txt](https://github.com/gabime/spdlog/blob/v1.x/example/CMakeLists.txt) on how to use.
+
+## Platforms
+ * Linux, FreeBSD, OpenBSD, Solaris, AIX
+ * Windows (msvc 2013+, cygwin)
+ * macOS (clang 3.5+)
+ * Android
+
+## Package managers:
+* Debian: `sudo apt install libspdlog-dev`
+* Homebrew: `brew install spdlog`
+* MacPorts: `sudo port install spdlog`
+* FreeBSD:  `pkg install spdlog`
+* Fedora: `dnf install spdlog`
+* Gentoo: `emerge dev-libs/spdlog`
+* Arch Linux: `pacman -S spdlog`
+* openSUSE: `sudo zypper in spdlog-devel`
+* vcpkg: `vcpkg install spdlog`
+* conan: `spdlog/[>=1.4.1]`
+* conda: `conda install -c conda-forge spdlog`
+* build2: ```depends: spdlog ^1.8.2```
+
+
+## Features
+* Very fast (see [benchmarks](#benchmarks) below).
+* Headers only or compiled
+* Feature-rich formatting, using the excellent [fmt](https://github.com/fmtlib/fmt) library.
+* Asynchronous mode (optional)
+* [Custom](https://github.com/gabime/spdlog/wiki/3.-Custom-formatting) formatting.
+* Multi/Single threaded loggers.
+* Various log targets:
+    * Rotating log files.
+    * Daily log files.
+    * Console logging (colors supported).
+    * syslog.
+    * Windows event log.
+    * Windows debugger (```OutputDebugString(..)```).
+    * Easily [extendable](https://github.com/gabime/spdlog/wiki/4.-Sinks#implementing-your-own-sink) with custom log targets.
+* Log filtering - log levels can be modified at runtime as well as compile time.
+* Support for loading log levels from argv or environment var.
+* [Backtrace](#backtrace-support) support - store debug messages in a ring buffer and display them later on demand.
+ 
+## Usage samples
+
+#### Basic usage
+```c++
+#include "spdlog/spdlog.h"
+
+int main() 
+{
+    spdlog::info("Welcome to spdlog!");
+    spdlog::error("Some error message with arg: {}", 1);
+    
+    spdlog::warn("Easy padding in numbers like {:08d}", 12);
+    spdlog::critical("Support for int: {0:d};  hex: {0:x};  oct: {0:o}; bin: {0:b}", 42);
+    spdlog::info("Support for floats {:03.2f}", 1.23456);
+    spdlog::info("Positional args are {1} {0}..", "too", "supported");
+    spdlog::info("{:<30}", "left aligned");
+    
+    spdlog::set_level(spdlog::level::debug); // Set global log level to debug
+    spdlog::debug("This message should be displayed..");    
+    
+    // change log pattern
+    spdlog::set_pattern("[%H:%M:%S %z] [%n] [%^---%L---%$] [thread %t] %v");
+    
+    // Compile time log levels
+    // define SPDLOG_ACTIVE_LEVEL to desired level
+    SPDLOG_TRACE("Some trace message with param {}", 42);
+    SPDLOG_DEBUG("Some debug message");
+}
+
+```
+---
+#### Create stdout/stderr logger object
+```c++
+#include "spdlog/spdlog.h"
+#include "spdlog/sinks/stdout_color_sinks.h"
+void stdout_example()
+{
+    // create a color multi-threaded logger
+    auto console = spdlog::stdout_color_mt("console");    
+    auto err_logger = spdlog::stderr_color_mt("stderr");    
+    spdlog::get("console")->info("loggers can be retrieved from a global registry using the spdlog::get(logger_name)");
+}
+```
+
+---
+#### Basic file logger
+```c++
+#include "spdlog/sinks/basic_file_sink.h"
+void basic_logfile_example()
+{
+    try 
+    {
+        auto logger = spdlog::basic_logger_mt("basic_logger", "logs/basic-log.txt");
+    }
+    catch (const spdlog::spdlog_ex &ex)
+    {
+        std::cout << "Log init failed: " << ex.what() << std::endl;
+    }
+}
+```
+---
+#### Rotating files
+```c++
+#include "spdlog/sinks/rotating_file_sink.h"
+void rotating_example()
+{
+    // Create a file rotating logger with 5 MB size max and 3 rotated files
+    auto max_size = 1048576 * 5;
+    auto max_files = 3;
+    auto logger = spdlog::rotating_logger_mt("some_logger_name", "logs/rotating.txt", max_size, max_files);
+}
+```
+
+---
+#### Daily files
+```c++
+
+#include "spdlog/sinks/daily_file_sink.h"
+void daily_example()
+{
+    // Create a daily logger - a new file is created every day at 2:30 am
+    auto logger = spdlog::daily_logger_mt("daily_logger", "logs/daily.txt", 2, 30);
+}
+
+```
+
+---
+#### Backtrace support
+```c++
+// Debug messages can be stored in a ring buffer instead of being logged immediately.
+// This is useful to display debug logs only when needed (e.g. when an error happens).
+// When needed, call dump_backtrace() to dump them to your log.
+
+spdlog::enable_backtrace(32); // Store the latest 32 messages in a buffer. 
+// or my_logger->enable_backtrace(32)..
+for(int i = 0; i < 100; i++)
+{
+  spdlog::debug("Backtrace message {}", i); // not logged yet..
+}
+// e.g. if some error happened:
+spdlog::dump_backtrace(); // log them now! show the last 32 messages
+// or my_logger->dump_backtrace(32)..
+```
+
+---
+#### Periodic flush
+```c++
+// periodically flush all *registered* loggers every 3 seconds:
+// warning: only use if all your loggers are thread-safe ("_mt" loggers)
+spdlog::flush_every(std::chrono::seconds(3));
+
+```
+
+---
+#### Stopwatch
+```c++
+// Stopwatch support for spdlog
+#include "spdlog/stopwatch.h"
+void stopwatch_example()
+{
+    spdlog::stopwatch sw;    
+    spdlog::debug("Elapsed {}", sw);
+    spdlog::debug("Elapsed {:.3}", sw);       
+}
+
+```
+
+---
+#### Log binary data in hex
+```c++
+// many types of std::container<char> types can be used.
+// ranges are supported too.
+// format flags:
+// {:X} - print in uppercase.
+// {:s} - don't separate each byte with space.
+// {:p} - don't print the position on each line start.
+// {:n} - don't split the output into lines.
+// {:a} - show ASCII if :n is not set.
+
+#include "spdlog/fmt/bin_to_hex.h"
+
+void binary_example()
+{
+    auto console = spdlog::get("console");
+    std::array<char, 80> buf;
+    console->info("Binary example: {}", spdlog::to_hex(buf));
+    console->info("Another binary example:{:n}", spdlog::to_hex(std::begin(buf), std::begin(buf) + 10));
+    // more examples:
+    // logger->info("uppercase: {:X}", spdlog::to_hex(buf));
+    // logger->info("uppercase, no delimiters: {:Xs}", spdlog::to_hex(buf));
+    // logger->info("uppercase, no delimiters, no position info: {:Xsp}", spdlog::to_hex(buf));
+}
+
+```
+
+---
+#### Logger with multi sinks - each with a different format and log level
+```c++
+
+// create a logger with 2 targets, with different log levels and formats.
+// The console will show only warnings or errors, while the file will log all.
+void multi_sink_example()
+{
+    auto console_sink = std::make_shared<spdlog::sinks::stdout_color_sink_mt>();
+    console_sink->set_level(spdlog::level::warn);
+    console_sink->set_pattern("[multi_sink_example] [%^%l%$] %v");
+
+    auto file_sink = std::make_shared<spdlog::sinks::basic_file_sink_mt>("logs/multisink.txt", true);
+    file_sink->set_level(spdlog::level::trace);
+
+    spdlog::logger logger("multi_sink", {console_sink, file_sink});
+    logger.set_level(spdlog::level::debug);
+    logger.warn("this should appear in both console and file");
+    logger.info("this message should not appear in the console, only in the file");
+}
+```
+
+---
+#### User-defined callbacks about log events
+```c++
+
+// create a logger with a lambda function callback, the callback will be called
+// each time something is logged to the logger
+void callback_example()
+{
+    auto callback_sink = std::make_shared<spdlog::sinks::callback_sink_mt>([](const spdlog::details::log_msg &msg) {
+         // for example you can be notified by sending an email to yourself
+    });
+    callback_sink->set_level(spdlog::level::err);
+
+    auto console_sink = std::make_shared<spdlog::sinks::stdout_color_sink_mt>();
+    spdlog::logger logger("custom_callback_logger", {console_sink, callback_sink});
+
+    logger.info("some info log");
+    logger.error("critical issue"); // will notify you
+}
+```
+
+---
+#### Asynchronous logging
+```c++
+#include "spdlog/async.h"
+#include "spdlog/sinks/basic_file_sink.h"
+void async_example()
+{
+    // default thread pool settings can be modified *before* creating the async logger:
+    // spdlog::init_thread_pool(8192, 1); // queue with 8k items and 1 backing thread.
+    auto async_file = spdlog::basic_logger_mt<spdlog::async_factory>("async_file_logger", "logs/async_log.txt");
+    // alternatively:
+    // auto async_file = spdlog::create_async<spdlog::sinks::basic_file_sink_mt>("async_file_logger", "logs/async_log.txt");   
+}
+
+```
+
+---
+#### Asynchronous logger with multi sinks  
+```c++
+#include "spdlog/sinks/stdout_color_sinks.h"
+#include "spdlog/sinks/rotating_file_sink.h"
+
+void multi_sink_example2()
+{
+    spdlog::init_thread_pool(8192, 1);
+    auto stdout_sink = std::make_shared<spdlog::sinks::stdout_color_sink_mt >();
+    auto rotating_sink = std::make_shared<spdlog::sinks::rotating_file_sink_mt>("mylog.txt", 1024*1024*10, 3);
+    std::vector<spdlog::sink_ptr> sinks {stdout_sink, rotating_sink};
+    auto logger = std::make_shared<spdlog::async_logger>("loggername", sinks.begin(), sinks.end(), spdlog::thread_pool(), spdlog::async_overflow_policy::block);
+    spdlog::register_logger(logger);
+}
+```
+ 
+---
+#### User-defined types
+```c++
+template<>
+struct fmt::formatter<my_type> : fmt::formatter<std::string>
+{
+    auto format(my_type my, format_context &ctx) -> decltype(ctx.out())
+    {
+        return format_to(ctx.out(), "[my_type i={}]", my.i);
+    }
+};
+
+void user_defined_example()
+{
+    spdlog::info("user defined type: {}", my_type(14));
+}
+
+```
+
+---
+#### User-defined flags in the log pattern
+```c++ 
+// Log patterns can contain custom flags.
+// the following example will add new flag '%*' - which will be bound to a <my_formatter_flag> instance.
+#include "spdlog/pattern_formatter.h"
+class my_formatter_flag : public spdlog::custom_flag_formatter
+{
+public:
+    void format(const spdlog::details::log_msg &, const std::tm &, spdlog::memory_buf_t &dest) override
+    {
+        std::string some_txt = "custom-flag";
+        dest.append(some_txt.data(), some_txt.data() + some_txt.size());
+    }
+
+    std::unique_ptr<custom_flag_formatter> clone() const override
+    {
+        return spdlog::details::make_unique<my_formatter_flag>();
+    }
+};
+
+void custom_flags_example()
+{    
+    auto formatter = std::make_unique<spdlog::pattern_formatter>();
+    formatter->add_flag<my_formatter_flag>('*').set_pattern("[%n] [%*] [%^%l%$] %v");
+    spdlog::set_formatter(std::move(formatter));
+}
+
+```
+
+---
+#### Custom error handler
+```c++
+void err_handler_example()
+{
+    // can be set globally or per logger(logger->set_error_handler(..))
+    spdlog::set_error_handler([](const std::string &msg) { spdlog::get("console")->error("*** LOGGER ERROR ***: {}", msg); });
+    spdlog::get("console")->info("some invalid message to trigger an error {}{}{}{}", 3);
+}
+
+```
+
+---
+#### syslog 
+```c++
+#include "spdlog/sinks/syslog_sink.h"
+void syslog_example()
+{
+    std::string ident = "spdlog-example";
+    auto syslog_logger = spdlog::syslog_logger_mt("syslog", ident, LOG_PID);
+    syslog_logger->warn("This is warning that will end up in syslog.");
+}
+```
+---
+#### Android example 
+```c++
+#include "spdlog/sinks/android_sink.h"
+void android_example()
+{
+    std::string tag = "spdlog-android";
+    auto android_logger = spdlog::android_logger_mt("android", tag);
+    android_logger->critical("Use \"adb shell logcat\" to view this message.");
+}
+```
+
+---
+#### Load log levels from the env variable or argv
+
+```c++
+#include "spdlog/cfg/env.h"
+int main (int argc, char *argv[])
+{
+    spdlog::cfg::load_env_levels();
+    // or from the command line:
+    // ./example SPDLOG_LEVEL=info,mylogger=trace
+    // #include "spdlog/cfg/argv.h" // for loading levels from argv
+    // spdlog::cfg::load_argv_levels(argc, argv);
+}
+```
+So then you can:
+
+```console
+$ export SPDLOG_LEVEL=info,mylogger=trace
+$ ./example
+```
+
+
+---
+#### Log file open/close event handlers
+```c++
+// You can get callbacks from spdlog before/after a log file has been opened or closed. 
+// This is useful for cleanup procedures or for adding something to the start/end of the log file.
+void file_events_example()
+{
+    // pass the spdlog::file_event_handlers to file sinks for open/close log file notifications
+    spdlog::file_event_handlers handlers;
+    handlers.before_open = [](spdlog::filename_t filename) { spdlog::info("Before opening {}", filename); };
+    handlers.after_open = [](spdlog::filename_t filename, std::FILE *fstream) { fputs("After opening\n", fstream); };
+    handlers.before_close = [](spdlog::filename_t filename, std::FILE *fstream) { fputs("Before closing\n", fstream); };
+    handlers.after_close = [](spdlog::filename_t filename) { spdlog::info("After closing {}", filename); };
+    auto my_logger = spdlog::basic_logger_st("some_logger", "logs/events-sample.txt", true, handlers);        
+}
+```
+
+---
+#### Replace the Default Logger
+```c++
+void replace_default_logger_example()
+{
+    auto new_logger = spdlog::basic_logger_mt("new_default_logger", "logs/new-default-log.txt", true);
+    spdlog::set_default_logger(new_logger);
+    spdlog::info("new logger log message");
+}
+```
+
+---
+## Benchmarks
+
+Below are some [benchmarks](https://github.com/gabime/spdlog/blob/v1.x/bench/bench.cpp) done in Ubuntu 64 bit, Intel i7-4770 CPU @ 3.40GHz
+
+#### Synchronous mode
+```
+[info] **************************************************************
+[info] Single thread, 1,000,000 iterations
+[info] **************************************************************
+[info] basic_st         Elapsed: 0.17 secs        5,777,626/sec
+[info] rotating_st      Elapsed: 0.18 secs        5,475,894/sec
+[info] daily_st         Elapsed: 0.20 secs        5,062,659/sec
+[info] empty_logger     Elapsed: 0.07 secs       14,127,300/sec
+[info] **************************************************************
+[info] C-string (400 bytes). Single thread, 1,000,000 iterations
+[info] **************************************************************
+[info] basic_st         Elapsed: 0.41 secs        2,412,483/sec
+[info] rotating_st      Elapsed: 0.72 secs        1,389,196/sec
+[info] daily_st         Elapsed: 0.42 secs        2,393,298/sec
+[info] null_st          Elapsed: 0.04 secs       27,446,957/sec
+[info] **************************************************************
+[info] 10 threads, competing over the same logger object, 1,000,000 iterations
+[info] **************************************************************
+[info] basic_mt         Elapsed: 0.60 secs        1,659,613/sec
+[info] rotating_mt      Elapsed: 0.62 secs        1,612,493/sec
+[info] daily_mt         Elapsed: 0.61 secs        1,638,305/sec
+[info] null_mt          Elapsed: 0.16 secs        6,272,758/sec
+```
+#### Asynchronous mode
+```
+[info] -------------------------------------------------
+[info] Messages     : 1,000,000
+[info] Threads      : 10
+[info] Queue        : 8,192 slots
+[info] Queue memory : 8,192 x 272 = 2,176 KB 
+[info] -------------------------------------------------
+[info] 
+[info] *********************************
+[info] Queue Overflow Policy: block
+[info] *********************************
+[info] Elapsed: 1.70784 secs     585,535/sec
+[info] Elapsed: 1.69805 secs     588,910/sec
+[info] Elapsed: 1.7026 secs      587,337/sec
+[info] 
+[info] *********************************
+[info] Queue Overflow Policy: overrun
+[info] *********************************
+[info] Elapsed: 0.372816 secs    2,682,285/sec
+[info] Elapsed: 0.379758 secs    2,633,255/sec
+[info] Elapsed: 0.373532 secs    2,677,147/sec
+
+```
+
+## Documentation
+Documentation can be found in the [wiki](https://github.com/gabime/spdlog/wiki/1.-QuickStart) pages.
+
+---
+
+Thanks to [JetBrains](https://www.jetbrains.com/?from=spdlog) for donating product licenses to help develop **spdlog** <a href="https://www.jetbrains.com/?from=spdlog"><img src="logos/jetbrains-variant-4.svg" width="94" align="center" /></a>
+
+
diff --git a/3rdparty/spdlog/src/appveyor.yml b/3rdparty/spdlog/src/appveyor.yml
new file mode 100644
index 00000000..f2757f30
--- /dev/null
+++ b/3rdparty/spdlog/src/appveyor.yml
@@ -0,0 +1,89 @@
+version: 1.0.{build}
+image: Visual Studio 2017
+environment:
+  matrix:
+    - GENERATOR: '"Visual Studio 15 2017 Win64"'
+      BUILD_TYPE: Debug
+      BUILD_SHARED: 'OFF'
+      FATAL_ERRORS: 'OFF'
+      WCHAR: 'ON'
+      WCHAR_FILES: 'OFF'
+      BUILD_EXAMPLE: 'ON'
+      USE_STD_FORMAT: 'OFF'
+      CXX_STANDARD: 11
+    - GENERATOR: '"Visual Studio 15 2017 Win64"'
+      BUILD_TYPE: Release
+      BUILD_SHARED: 'OFF'
+      FATAL_ERRORS: 'OFF'
+      WCHAR: 'OFF'
+      WCHAR_FILES: 'OFF'
+      BUILD_EXAMPLE: 'ON'
+      USE_STD_FORMAT: 'OFF'
+      CXX_STANDARD: 11
+    - GENERATOR: '"Visual Studio 15 2017 Win64"'
+      BUILD_TYPE: Release
+      BUILD_SHARED: 'ON'
+      FATAL_ERRORS: 'OFF'
+      WCHAR: 'OFF'
+      WCHAR_FILES: 'OFF'
+      BUILD_EXAMPLE: 'ON'
+      USE_STD_FORMAT: 'OFF'
+      CXX_STANDARD: 11
+    - GENERATOR: '"Visual Studio 15 2017 Win64"'
+      BUILD_TYPE: Release
+      BUILD_SHARED: 'ON'
+      FATAL_ERRORS: 'OFF'
+      WCHAR: 'ON'
+      WCHAR_FILES: 'ON'
+      BUILD_EXAMPLE: 'OFF'
+      USE_STD_FORMAT: 'OFF'
+      CXX_STANDARD: 11
+    - GENERATOR: '"Visual Studio 16 2019" -A x64'
+      BUILD_TYPE: Release
+      BUILD_SHARED: 'ON'
+      FATAL_ERRORS: 'ON'
+      WCHAR: 'OFF'
+      WCHAR_FILES: 'OFF'
+      BUILD_EXAMPLE: 'OFF'
+      USE_STD_FORMAT: 'OFF'
+      CXX_STANDARD: 17
+      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
+    - GENERATOR: '"Visual Studio 17 2022" -A x64'
+      BUILD_TYPE: Release
+      BUILD_SHARED: 'ON'
+      FATAL_ERRORS: 'ON'
+      WCHAR: 'OFF'
+      WCHAR_FILES: 'OFF'
+      BUILD_EXAMPLE: 'OFF'
+      USE_STD_FORMAT: 'ON'
+      CXX_STANDARD: 20
+      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2022
+    - GENERATOR: '"Visual Studio 17 2022" -A x64'
+      BUILD_TYPE: Release
+      BUILD_SHARED: 'ON'
+      FATAL_ERRORS: 'ON'
+      WCHAR: 'ON'
+      WCHAR_FILES: 'ON'
+      BUILD_EXAMPLE: 'OFF'
+      USE_STD_FORMAT: 'ON'
+      CXX_STANDARD: 20
+      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2022
+build_script:
+  - cmd: >-
+      set
+
+      mkdir build
+
+      cd build
+
+      set PATH=%PATH%;C:\Program Files\Git\usr\bin
+
+      cmake -G %GENERATOR% -D CMAKE_BUILD_TYPE=%BUILD_TYPE% -D BUILD_SHARED_LIBS=%BUILD_SHARED% -D SPDLOG_WCHAR_SUPPORT=%WCHAR% -D SPDLOG_WCHAR_FILENAMES=%WCHAR_FILES% -D SPDLOG_BUILD_EXAMPLE=%BUILD_EXAMPLE% -D SPDLOG_BUILD_EXAMPLE_HO=%BUILD_EXAMPLE% -D SPDLOG_BUILD_TESTS=ON -D SPDLOG_BUILD_TESTS_HO=OFF -D SPDLOG_BUILD_WARNINGS=%FATAL_ERRORS% -D SPDLOG_USE_STD_FORMAT=%USE_STD_FORMAT% -D CMAKE_CXX_STANDARD=%CXX_STANDARD% ..
+
+      cmake --build . --config %BUILD_TYPE%
+
+before_test:
+  - set PATH=%PATH%;C:\projects\spdlog\build\_deps\catch2-build\src\%BUILD_TYPE%;C:\projects\spdlog\build\%BUILD_TYPE%
+  
+test_script:
+  - C:\projects\spdlog\build\tests\%BUILD_TYPE%\spdlog-utests.exe
diff --git a/3rdparty/spdlog/src/bench/CMakeLists.txt b/3rdparty/spdlog/src/bench/CMakeLists.txt
new file mode 100644
index 00000000..144f50b8
--- /dev/null
+++ b/3rdparty/spdlog/src/bench/CMakeLists.txt
@@ -0,0 +1,41 @@
+# Copyright(c) 2019 spdlog authors Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+cmake_minimum_required(VERSION 3.10)
+project(spdlog_bench CXX)
+
+if(NOT TARGET spdlog)
+    # Stand-alone build
+    find_package(spdlog CONFIG REQUIRED)
+endif()
+
+find_package(Threads REQUIRED)
+find_package(benchmark CONFIG)
+if(NOT benchmark_FOUND)
+    message(STATUS "Using CMake Version ${CMAKE_VERSION}")
+    if(${CMAKE_VERSION} VERSION_GREATER_EQUAL "3.11.0")
+        # User can fetch googlebenchmark
+        message(STATUS "Downloading GoogleBenchmark")
+        include(FetchContent)
+
+        # disable tests  
+        set(BENCHMARK_ENABLE_TESTING OFF CACHE INTERNAL "")        
+        # Do not build and run googlebenchmark tests
+        FetchContent_Declare(googlebenchmark GIT_REPOSITORY https://github.com/google/benchmark.git GIT_TAG v1.6.0)
+        FetchContent_MakeAvailable(googlebenchmark)
+    else()
+        message(FATAL_ERROR "GoogleBenchmark is missing. Use CMake >= 3.11 or download it")
+    endif()
+endif()
+
+add_executable(bench bench.cpp)
+spdlog_enable_warnings(bench)
+target_link_libraries(bench PRIVATE spdlog::spdlog)
+
+add_executable(async_bench async_bench.cpp)
+target_link_libraries(async_bench PRIVATE spdlog::spdlog)
+
+add_executable(latency latency.cpp)
+target_link_libraries(latency PRIVATE benchmark::benchmark spdlog::spdlog)
+
+add_executable(formatter-bench formatter-bench.cpp)
+target_link_libraries(formatter-bench PRIVATE benchmark::benchmark spdlog::spdlog)
diff --git a/3rdparty/spdlog/src/bench/async_bench.cpp b/3rdparty/spdlog/src/bench/async_bench.cpp
new file mode 100644
index 00000000..cf4d9754
--- /dev/null
+++ b/3rdparty/spdlog/src/bench/async_bench.cpp
@@ -0,0 +1,186 @@
+//
+// Copyright(c) 2015 Gabi Melman.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+//
+
+//
+// bench.cpp : spdlog benchmarks
+//
+#include "spdlog/spdlog.h"
+#include "spdlog/async.h"
+#include "spdlog/sinks/basic_file_sink.h"
+
+#if defined(SPDLOG_USE_STD_FORMAT)
+#    include <format>
+#elif defined(SPDLOG_FMT_EXTERNAL)
+#    include <fmt/format.h>
+#else
+#    include "spdlog/fmt/bundled/format.h"
+#endif
+
+#include "utils.h"
+#include <atomic>
+#include <iostream>
+#include <memory>
+#include <string>
+#include <thread>
+
+using namespace std;
+using namespace std::chrono;
+using namespace spdlog;
+using namespace spdlog::sinks;
+using namespace utils;
+
+void bench_mt(int howmany, std::shared_ptr<spdlog::logger> log, int thread_count);
+
+#ifdef _MSC_VER
+#    pragma warning(push)
+#    pragma warning(disable : 4996) // disable fopen warning under msvc
+#endif                              // _MSC_VER
+
+int count_lines(const char *filename)
+{
+    int counter = 0;
+    auto *infile = fopen(filename, "r");
+    int ch;
+    while (EOF != (ch = getc(infile)))
+    {
+        if ('\n' == ch)
+            counter++;
+    }
+    fclose(infile);
+
+    return counter;
+}
+
+void verify_file(const char *filename, int expected_count)
+{
+    spdlog::info("Verifying {} to contain {} line..", filename, expected_count);
+    auto count = count_lines(filename);
+    if (count != expected_count)
+    {
+        spdlog::error("Test failed. {} has {} lines instead of {}", filename, count, expected_count);
+        exit(1);
+    }
+    spdlog::info("Line count OK ({})\n", count);
+}
+
+#ifdef _MSC_VER
+#    pragma warning(pop)
+#endif
+
+int main(int argc, char *argv[])
+{
+
+    int howmany = 1000000;
+    int queue_size = std::min(howmany + 2, 8192);
+    int threads = 10;
+    int iters = 3;
+
+    try
+    {
+        spdlog::set_pattern("[%^%l%$] %v");
+        if (argc == 1)
+        {
+            spdlog::info("Usage: {} <message_count> <threads> <q_size> <iterations>", argv[0]);
+            return 0;
+        }
+
+        if (argc > 1)
+            howmany = atoi(argv[1]);
+        if (argc > 2)
+            threads = atoi(argv[2]);
+        if (argc > 3)
+        {
+            queue_size = atoi(argv[3]);
+            if (queue_size > 500000)
+            {
+                spdlog::error("Max queue size allowed: 500,000");
+                exit(1);
+            }
+        }
+
+        if (argc > 4)
+            iters = atoi(argv[4]);
+
+        auto slot_size = sizeof(spdlog::details::async_msg);
+        spdlog::info("-------------------------------------------------");
+        spdlog::info("Messages     : {:L}", howmany);
+        spdlog::info("Threads      : {:L}", threads);
+        spdlog::info("Queue        : {:L} slots", queue_size);
+        spdlog::info("Queue memory : {:L} x {:L} = {:L} KB ", queue_size, slot_size, (queue_size * slot_size) / 1024);
+        spdlog::info("Total iters  : {:L}", iters);
+        spdlog::info("-------------------------------------------------");
+
+        const char *filename = "logs/basic_async.log";
+        spdlog::info("");
+        spdlog::info("*********************************");
+        spdlog::info("Queue Overflow Policy: block");
+        spdlog::info("*********************************");
+        for (int i = 0; i < iters; i++)
+        {
+            auto tp = std::make_shared<details::thread_pool>(queue_size, 1);
+            auto file_sink = std::make_shared<spdlog::sinks::basic_file_sink_mt>(filename, true);
+            auto logger = std::make_shared<async_logger>("async_logger", std::move(file_sink), std::move(tp), async_overflow_policy::block);
+            bench_mt(howmany, std::move(logger), threads);
+            // verify_file(filename, howmany);
+        }
+
+        spdlog::info("");
+        spdlog::info("*********************************");
+        spdlog::info("Queue Overflow Policy: overrun");
+        spdlog::info("*********************************");
+        // do same test but discard oldest if queue is full instead of blocking
+        filename = "logs/basic_async-overrun.log";
+        for (int i = 0; i < iters; i++)
+        {
+            auto tp = std::make_shared<details::thread_pool>(queue_size, 1);
+            auto file_sink = std::make_shared<spdlog::sinks::basic_file_sink_mt>(filename, true);
+            auto logger =
+                std::make_shared<async_logger>("async_logger", std::move(file_sink), std::move(tp), async_overflow_policy::overrun_oldest);
+            bench_mt(howmany, std::move(logger), threads);
+        }
+        spdlog::shutdown();
+    }
+    catch (std::exception &ex)
+    {
+        std::cerr << "Error: " << ex.what() << std::endl;
+        perror("Last error");
+        return 1;
+    }
+    return 0;
+}
+
+void thread_fun(std::shared_ptr<spdlog::logger> logger, int howmany)
+{
+    for (int i = 0; i < howmany; i++)
+    {
+        logger->info("Hello logger: msg number {}", i);
+    }
+}
+
+void bench_mt(int howmany, std::shared_ptr<spdlog::logger> logger, int thread_count)
+{
+    using std::chrono::high_resolution_clock;
+    vector<std::thread> threads;
+    auto start = high_resolution_clock::now();
+
+    int msgs_per_thread = howmany / thread_count;
+    int msgs_per_thread_mod = howmany % thread_count;
+    for (int t = 0; t < thread_count; ++t)
+    {
+        if (t == 0 && msgs_per_thread_mod)
+            threads.push_back(std::thread(thread_fun, logger, msgs_per_thread + msgs_per_thread_mod));
+        else
+            threads.push_back(std::thread(thread_fun, logger, msgs_per_thread));
+    }
+
+    for (auto &t : threads)
+    {
+        t.join();
+    };
+
+    auto delta = high_resolution_clock::now() - start;
+    auto delta_d = duration_cast<duration<double>>(delta).count();
+    spdlog::info("Elapsed: {} secs\t {:L}/sec", delta_d, int(howmany / delta_d));
+}
diff --git a/3rdparty/spdlog/src/bench/bench.cpp b/3rdparty/spdlog/src/bench/bench.cpp
new file mode 100644
index 00000000..ae47f047
--- /dev/null
+++ b/3rdparty/spdlog/src/bench/bench.cpp
@@ -0,0 +1,248 @@
+//
+// Copyright(c) 2015 Gabi Melman.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+//
+
+//
+// bench.cpp : spdlog benchmarks
+//
+#include "spdlog/spdlog.h"
+#include "spdlog/sinks/basic_file_sink.h"
+#include "spdlog/sinks/daily_file_sink.h"
+#include "spdlog/sinks/null_sink.h"
+#include "spdlog/sinks/rotating_file_sink.h"
+
+#if defined(SPDLOG_USE_STD_FORMAT)
+#    include <format>
+#elif defined(SPDLOG_FMT_EXTERNAL)
+#    include <fmt/format.h>
+#else
+#    include "spdlog/fmt/bundled/format.h"
+#endif
+
+#include "utils.h"
+#include <atomic>
+#include <cstdlib> // EXIT_FAILURE
+#include <memory>
+#include <string>
+#include <thread>
+
+void bench(int howmany, std::shared_ptr<spdlog::logger> log);
+void bench_mt(int howmany, std::shared_ptr<spdlog::logger> log, size_t thread_count);
+
+// void bench_default_api(int howmany, std::shared_ptr<spdlog::logger> log);
+// void bench_c_string(int howmany, std::shared_ptr<spdlog::logger> log);
+
+static const size_t file_size = 30 * 1024 * 1024;
+static const size_t rotating_files = 5;
+static const int max_threads = 1000;
+
+void bench_threaded_logging(size_t threads, int iters)
+{
+    spdlog::info("**************************************************************");
+    spdlog::info(spdlog::fmt_lib::format(std::locale("en_US.UTF-8"), "Multi threaded: {:L} threads, {:L} messages", threads, iters));
+    spdlog::info("**************************************************************");
+
+    auto basic_mt = spdlog::basic_logger_mt("basic_mt", "logs/basic_mt.log", true);
+    bench_mt(iters, std::move(basic_mt), threads);
+    auto basic_mt_tracing = spdlog::basic_logger_mt("basic_mt/backtrace-on", "logs/basic_mt.log", true);
+    basic_mt_tracing->enable_backtrace(32);
+    bench_mt(iters, std::move(basic_mt_tracing), threads);
+
+    spdlog::info("");
+    auto rotating_mt = spdlog::rotating_logger_mt("rotating_mt", "logs/rotating_mt.log", file_size, rotating_files);
+    bench_mt(iters, std::move(rotating_mt), threads);
+    auto rotating_mt_tracing = spdlog::rotating_logger_mt("rotating_mt/backtrace-on", "logs/rotating_mt.log", file_size, rotating_files);
+    rotating_mt_tracing->enable_backtrace(32);
+    bench_mt(iters, std::move(rotating_mt_tracing), threads);
+
+    spdlog::info("");
+    auto daily_mt = spdlog::daily_logger_mt("daily_mt", "logs/daily_mt.log");
+    bench_mt(iters, std::move(daily_mt), threads);
+    auto daily_mt_tracing = spdlog::daily_logger_mt("daily_mt/backtrace-on", "logs/daily_mt.log");
+    daily_mt_tracing->enable_backtrace(32);
+    bench_mt(iters, std::move(daily_mt_tracing), threads);
+
+    spdlog::info("");
+    auto empty_logger = std::make_shared<spdlog::logger>("level-off");
+    empty_logger->set_level(spdlog::level::off);
+    bench(iters, empty_logger);
+    auto empty_logger_tracing = std::make_shared<spdlog::logger>("level-off/backtrace-on");
+    empty_logger_tracing->set_level(spdlog::level::off);
+    empty_logger_tracing->enable_backtrace(32);
+    bench(iters, empty_logger_tracing);
+}
+
+void bench_single_threaded(int iters)
+{
+    spdlog::info("**************************************************************");
+    spdlog::info(spdlog::fmt_lib::format(std::locale("en_US.UTF-8"), "Single threaded: {} messages", iters));
+    spdlog::info("**************************************************************");
+
+    auto basic_st = spdlog::basic_logger_st("basic_st", "logs/basic_st.log", true);
+    bench(iters, std::move(basic_st));
+
+    auto basic_st_tracing = spdlog::basic_logger_st("basic_st/backtrace-on", "logs/basic_st.log", true);
+    bench(iters, std::move(basic_st_tracing));
+
+    spdlog::info("");
+    auto rotating_st = spdlog::rotating_logger_st("rotating_st", "logs/rotating_st.log", file_size, rotating_files);
+    bench(iters, std::move(rotating_st));
+    auto rotating_st_tracing = spdlog::rotating_logger_st("rotating_st/backtrace-on", "logs/rotating_st.log", file_size, rotating_files);
+    rotating_st_tracing->enable_backtrace(32);
+    bench(iters, std::move(rotating_st_tracing));
+
+    spdlog::info("");
+    auto daily_st = spdlog::daily_logger_st("daily_st", "logs/daily_st.log");
+    bench(iters, std::move(daily_st));
+    auto daily_st_tracing = spdlog::daily_logger_st("daily_st/backtrace-on", "logs/daily_st.log");
+    daily_st_tracing->enable_backtrace(32);
+    bench(iters, std::move(daily_st_tracing));
+
+    spdlog::info("");
+    auto empty_logger = std::make_shared<spdlog::logger>("level-off");
+    empty_logger->set_level(spdlog::level::off);
+    bench(iters, empty_logger);
+
+    auto empty_logger_tracing = std::make_shared<spdlog::logger>("level-off/backtrace-on");
+    empty_logger_tracing->set_level(spdlog::level::off);
+    empty_logger_tracing->enable_backtrace(32);
+    bench(iters, empty_logger_tracing);
+}
+
+int main(int argc, char *argv[])
+{
+    spdlog::set_automatic_registration(false);
+    spdlog::default_logger()->set_pattern("[%^%l%$] %v");
+    int iters = 250000;
+    size_t threads = 4;
+    try
+    {
+
+        if (argc > 1)
+        {
+            iters = std::stoi(argv[1]);
+        }
+        if (argc > 2)
+        {
+            threads = std::stoul(argv[2]);
+        }
+
+        if (threads > max_threads)
+        {
+            throw std::runtime_error(spdlog::fmt_lib::format("Number of threads exceeds maximum({})", max_threads));
+        }
+
+        bench_single_threaded(iters);
+        bench_threaded_logging(1, iters);
+        bench_threaded_logging(threads, iters);
+    }
+    catch (std::exception &ex)
+    {
+        spdlog::error(ex.what());
+        return EXIT_FAILURE;
+    }
+    return EXIT_SUCCESS;
+}
+
+void bench(int howmany, std::shared_ptr<spdlog::logger> log)
+{
+    using std::chrono::duration;
+    using std::chrono::duration_cast;
+    using std::chrono::high_resolution_clock;
+
+    auto start = high_resolution_clock::now();
+    for (auto i = 0; i < howmany; ++i)
+    {
+        log->info("Hello logger: msg number {}", i);
+    }
+
+    auto delta = high_resolution_clock::now() - start;
+    auto delta_d = duration_cast<duration<double>>(delta).count();
+
+    spdlog::info(spdlog::fmt_lib::format(
+        std::locale("en_US.UTF-8"), "{:<30} Elapsed: {:0.2f} secs {:>16L}/sec", log->name(), delta_d, int(howmany / delta_d)));
+    spdlog::drop(log->name());
+}
+
+void bench_mt(int howmany, std::shared_ptr<spdlog::logger> log, size_t thread_count)
+{
+    using std::chrono::duration;
+    using std::chrono::duration_cast;
+    using std::chrono::high_resolution_clock;
+
+    std::vector<std::thread> threads;
+    threads.reserve(thread_count);
+    auto start = high_resolution_clock::now();
+    for (size_t t = 0; t < thread_count; ++t)
+    {
+        threads.emplace_back([&]() {
+            for (int j = 0; j < howmany / static_cast<int>(thread_count); j++)
+            {
+                log->info("Hello logger: msg number {}", j);
+            }
+        });
+    }
+
+    for (auto &t : threads)
+    {
+        t.join();
+    };
+
+    auto delta = high_resolution_clock::now() - start;
+    auto delta_d = duration_cast<duration<double>>(delta).count();
+    spdlog::info(spdlog::fmt_lib::format(
+        std::locale("en_US.UTF-8"), "{:<30} Elapsed: {:0.2f} secs {:>16L}/sec", log->name(), delta_d, int(howmany / delta_d)));
+    spdlog::drop(log->name());
+}
+
+/*
+void bench_default_api(int howmany, std::shared_ptr<spdlog::logger> log)
+{
+    using std::chrono::high_resolution_clock;
+    using std::chrono::duration;
+    using std::chrono::duration_cast;
+
+    auto orig_default = spdlog::default_logger();
+    spdlog::set_default_logger(log);
+    auto start = high_resolution_clock::now();
+    for (auto i = 0; i < howmany; ++i)
+    {
+        spdlog::info("Hello logger: msg number {}", i);
+    }
+
+    auto delta = high_resolution_clock::now() - start;
+    auto delta_d = duration_cast<duration<double>>(delta).count();
+    spdlog::drop(log->name());
+    spdlog::set_default_logger(std::move(orig_default));
+    spdlog::info("{:<30} Elapsed: {:0.2f} secs {:>16}/sec", log->name(), delta_d, int(howmany / delta_d));
+}
+
+void bench_c_string(int howmany, std::shared_ptr<spdlog::logger> log)
+{
+    using std::chrono::high_resolution_clock;
+    using std::chrono::duration;
+    using std::chrono::duration_cast;
+
+    const char *msg = "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Vestibulum pharetra metus cursus "
+                      "lacus placerat congue. Nulla egestas, mauris a tincidunt tempus, enim lectus volutpat mi, eu consequat sem "
+                      "libero nec massa. In dapibus ipsum a diam rhoncus gravida. Etiam non dapibus eros. Donec fringilla dui sed "
+                      "augue pretium, nec scelerisque est maximus. Nullam convallis, sem nec blandit maximus, nisi turpis ornare "
+                      "nisl, sit amet volutpat neque massa eu odio. Maecenas malesuada quam ex, posuere congue nibh turpis duis.";
+
+    auto orig_default = spdlog::default_logger();
+    spdlog::set_default_logger(log);
+    auto start = high_resolution_clock::now();
+    for (auto i = 0; i < howmany; ++i)
+    {
+        spdlog::log(spdlog::level::info, msg);
+    }
+
+    auto delta = high_resolution_clock::now() - start;
+    auto delta_d = duration_cast<duration<double>>(delta).count();
+    spdlog::drop(log->name());
+    spdlog::set_default_logger(std::move(orig_default));
+    spdlog::info("{:<30} Elapsed: {:0.2f} secs {:>16}/sec", log->name(), delta_d, int(howmany / delta_d));
+}
+
+*/
\ No newline at end of file
diff --git a/3rdparty/spdlog/src/bench/formatter-bench.cpp b/3rdparty/spdlog/src/bench/formatter-bench.cpp
new file mode 100644
index 00000000..1454c6bb
--- /dev/null
+++ b/3rdparty/spdlog/src/bench/formatter-bench.cpp
@@ -0,0 +1,80 @@
+//
+// Copyright(c) 2018 Gabi Melman.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+//
+
+#include "benchmark/benchmark.h"
+
+#include "spdlog/spdlog.h"
+#include "spdlog/pattern_formatter.h"
+
+void bench_formatter(benchmark::State &state, std::string pattern)
+{
+    auto formatter = spdlog::details::make_unique<spdlog::pattern_formatter>(pattern);
+    spdlog::memory_buf_t dest;
+    std::string logger_name = "logger-name";
+    const char *text = "Hello. This is some message with length of 80                                   ";
+
+    spdlog::source_loc source_loc{"a/b/c/d/myfile.cpp", 123, "some_func()"};
+    spdlog::details::log_msg msg(source_loc, logger_name, spdlog::level::info, text);
+
+    for (auto _ : state)
+    {
+        dest.clear();
+        formatter->format(msg, dest);
+        benchmark::DoNotOptimize(dest);
+    }
+}
+
+void bench_formatters()
+{
+    // basic patterns(single flag)
+    std::string all_flags = "+vtPnlLaAbBcCYDmdHIMSefFprRTXzEisg@luioO%";
+    std::vector<std::string> basic_patterns;
+    for (auto &flag : all_flags)
+    {
+        auto pattern = std::string("%") + flag;
+        benchmark::RegisterBenchmark(pattern.c_str(), &bench_formatter, pattern);
+
+        //        pattern = std::string("%16") + flag;
+        //        benchmark::RegisterBenchmark(pattern.c_str(), &bench_formatter, pattern);
+        //
+        //        // bench center padding
+        //        pattern = std::string("%=16") + flag;
+        //        benchmark::RegisterBenchmark(pattern.c_str(), &bench_formatter, pattern);
+    }
+
+    // complex patterns
+    std::vector<std::string> patterns = {
+        "[%D %X] [%l] [%n] %v",
+        "[%Y-%m-%d %H:%M:%S.%e] [%l] [%n] %v",
+        "[%Y-%m-%d %H:%M:%S.%e] [%l] [%n] [%t] %v",
+    };
+    for (auto &pattern : patterns)
+    {
+        benchmark::RegisterBenchmark(pattern.c_str(), &bench_formatter, pattern)->Iterations(2500000);
+    }
+}
+
+int main(int argc, char *argv[])
+{
+
+    spdlog::set_pattern("[%^%l%$] %v");
+    if (argc != 2)
+    {
+        spdlog::error("Usage: {} <pattern> (or \"all\" to bench all)", argv[0]);
+        exit(1);
+    }
+
+    std::string pattern = argv[1];
+    if (pattern == "all")
+    {
+        bench_formatters();
+    }
+    else
+    {
+        benchmark::RegisterBenchmark(pattern.c_str(), &bench_formatter, pattern);
+    }
+    benchmark::Initialize(&argc, argv);
+    benchmark::RunSpecifiedBenchmarks();
+}
diff --git a/3rdparty/spdlog/src/bench/latency.cpp b/3rdparty/spdlog/src/bench/latency.cpp
new file mode 100644
index 00000000..a3f12c48
--- /dev/null
+++ b/3rdparty/spdlog/src/bench/latency.cpp
@@ -0,0 +1,166 @@
+//
+// Copyright(c) 2018 Gabi Melman.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+//
+
+//
+// latency.cpp : spdlog latency benchmarks
+//
+
+#include "benchmark/benchmark.h"
+
+#include "spdlog/spdlog.h"
+#include "spdlog/async.h"
+#include "spdlog/sinks/basic_file_sink.h"
+#include "spdlog/sinks/daily_file_sink.h"
+#include "spdlog/sinks/null_sink.h"
+#include "spdlog/sinks/rotating_file_sink.h"
+
+void bench_c_string(benchmark::State &state, std::shared_ptr<spdlog::logger> logger)
+{
+    const char *msg = "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Vestibulum pharetra metus cursus "
+                      "lacus placerat congue. Nulla egestas, mauris a tincidunt tempus, enim lectus volutpat mi, eu consequat sem "
+                      "libero nec massa. In dapibus ipsum a diam rhoncus gravida. Etiam non dapibus eros. Donec fringilla dui sed "
+                      "augue pretium, nec scelerisque est maximus. Nullam convallis, sem nec blandit maximus, nisi turpis ornare "
+                      "nisl, sit amet volutpat neque massa eu odio. Maecenas malesuada quam ex, posuere congue nibh turpis duis.";
+
+    for (auto _ : state)
+    {
+        logger->info(msg);
+    }
+}
+
+void bench_logger(benchmark::State &state, std::shared_ptr<spdlog::logger> logger)
+{
+    int i = 0;
+    for (auto _ : state)
+    {
+        logger->info("Hello logger: msg number {}...............", ++i);
+    }
+}
+
+void bench_disabled_macro(benchmark::State &state, std::shared_ptr<spdlog::logger> logger)
+{
+    int i = 0;
+    benchmark::DoNotOptimize(i);      // prevent unused warnings
+    benchmark::DoNotOptimize(logger); // prevent unused warnings
+    for (auto _ : state)
+    {
+        SPDLOG_LOGGER_DEBUG(logger, "Hello logger: msg number {}...............", i++);
+        SPDLOG_DEBUG("Hello logger: msg number {}...............", i++);
+    }
+}
+
+#ifdef __linux__
+void bench_dev_null()
+{
+    auto dev_null_st = spdlog::basic_logger_st("/dev/null_st", "/dev/null");
+    benchmark::RegisterBenchmark("/dev/null_st", bench_logger, std::move(dev_null_st))->UseRealTime();
+    spdlog::drop("/dev/null_st");
+
+    auto dev_null_mt = spdlog::basic_logger_mt("/dev/null_mt", "/dev/null");
+    benchmark::RegisterBenchmark("/dev/null_mt", bench_logger, std::move(dev_null_mt))->UseRealTime();
+    spdlog::drop("/dev/null_mt");
+}
+#endif // __linux__
+
+int main(int argc, char *argv[])
+{
+    using spdlog::sinks::null_sink_mt;
+    using spdlog::sinks::null_sink_st;
+
+    size_t file_size = 30 * 1024 * 1024;
+    size_t rotating_files = 5;
+    int n_threads = benchmark::CPUInfo::Get().num_cpus;
+
+    auto full_bench = argc > 1 && std::string(argv[1]) == "full";
+
+    // disabled loggers
+    auto disabled_logger = std::make_shared<spdlog::logger>("bench", std::make_shared<null_sink_mt>());
+    disabled_logger->set_level(spdlog::level::off);
+    benchmark::RegisterBenchmark("disabled-at-compile-time", bench_disabled_macro, disabled_logger);
+    benchmark::RegisterBenchmark("disabled-at-runtime", bench_logger, disabled_logger);
+    // with backtrace of 64
+    auto tracing_disabled_logger = std::make_shared<spdlog::logger>("bench", std::make_shared<null_sink_mt>());
+    tracing_disabled_logger->enable_backtrace(64);
+    benchmark::RegisterBenchmark("disabled-at-runtime/backtrace", bench_logger, tracing_disabled_logger);
+
+    auto null_logger_st = std::make_shared<spdlog::logger>("bench", std::make_shared<null_sink_st>());
+    benchmark::RegisterBenchmark("null_sink_st (500_bytes c_str)", bench_c_string, std::move(null_logger_st));
+    benchmark::RegisterBenchmark("null_sink_st", bench_logger, null_logger_st);
+    // with backtrace of 64
+    auto tracing_null_logger_st = std::make_shared<spdlog::logger>("bench", std::make_shared<null_sink_st>());
+    tracing_null_logger_st->enable_backtrace(64);
+    benchmark::RegisterBenchmark("null_sink_st/backtrace", bench_logger, tracing_null_logger_st);
+
+#ifdef __linux
+    bench_dev_null();
+#endif // __linux__
+
+    if (full_bench)
+    {
+        // basic_st
+        auto basic_st = spdlog::basic_logger_st("basic_st", "latency_logs/basic_st.log", true);
+        benchmark::RegisterBenchmark("basic_st", bench_logger, std::move(basic_st))->UseRealTime();
+        spdlog::drop("basic_st");
+        // with backtrace of 64
+        auto tracing_basic_st = spdlog::basic_logger_st("tracing_basic_st", "latency_logs/tracing_basic_st.log", true);
+        tracing_basic_st->enable_backtrace(64);
+        benchmark::RegisterBenchmark("basic_st/backtrace", bench_logger, std::move(tracing_basic_st))->UseRealTime();
+        spdlog::drop("tracing_basic_st");
+
+        // rotating st
+        auto rotating_st = spdlog::rotating_logger_st("rotating_st", "latency_logs/rotating_st.log", file_size, rotating_files);
+        benchmark::RegisterBenchmark("rotating_st", bench_logger, std::move(rotating_st))->UseRealTime();
+        spdlog::drop("rotating_st");
+        // with backtrace of 64
+        auto tracing_rotating_st =
+            spdlog::rotating_logger_st("tracing_rotating_st", "latency_logs/tracing_rotating_st.log", file_size, rotating_files);
+        benchmark::RegisterBenchmark("rotating_st/backtrace", bench_logger, std::move(tracing_rotating_st))->UseRealTime();
+        spdlog::drop("tracing_rotating_st");
+
+        // daily st
+        auto daily_st = spdlog::daily_logger_mt("daily_st", "latency_logs/daily_st.log");
+        benchmark::RegisterBenchmark("daily_st", bench_logger, std::move(daily_st))->UseRealTime();
+        spdlog::drop("daily_st");
+        auto tracing_daily_st = spdlog::daily_logger_mt("tracing_daily_st", "latency_logs/daily_st.log");
+        benchmark::RegisterBenchmark("daily_st/backtrace", bench_logger, std::move(tracing_daily_st))->UseRealTime();
+        spdlog::drop("tracing_daily_st");
+
+        //
+        // Multi threaded bench, 10 loggers using same logger concurrently
+        //
+        auto null_logger_mt = std::make_shared<spdlog::logger>("bench", std::make_shared<null_sink_mt>());
+        benchmark::RegisterBenchmark("null_sink_mt", bench_logger, null_logger_mt)->Threads(n_threads)->UseRealTime();
+
+        // basic_mt
+        auto basic_mt = spdlog::basic_logger_mt("basic_mt", "latency_logs/basic_mt.log", true);
+        benchmark::RegisterBenchmark("basic_mt", bench_logger, std::move(basic_mt))->Threads(n_threads)->UseRealTime();
+        spdlog::drop("basic_mt");
+
+        // rotating mt
+        auto rotating_mt = spdlog::rotating_logger_mt("rotating_mt", "latency_logs/rotating_mt.log", file_size, rotating_files);
+        benchmark::RegisterBenchmark("rotating_mt", bench_logger, std::move(rotating_mt))->Threads(n_threads)->UseRealTime();
+        spdlog::drop("rotating_mt");
+
+        // daily mt
+        auto daily_mt = spdlog::daily_logger_mt("daily_mt", "latency_logs/daily_mt.log");
+        benchmark::RegisterBenchmark("daily_mt", bench_logger, std::move(daily_mt))->Threads(n_threads)->UseRealTime();
+        spdlog::drop("daily_mt");
+    }
+
+    // async
+    auto queue_size = 1024 * 1024 * 3;
+    auto tp = std::make_shared<spdlog::details::thread_pool>(queue_size, 1);
+    auto async_logger = std::make_shared<spdlog::async_logger>(
+        "async_logger", std::make_shared<null_sink_mt>(), std::move(tp), spdlog::async_overflow_policy::overrun_oldest);
+    benchmark::RegisterBenchmark("async_logger", bench_logger, async_logger)->Threads(n_threads)->UseRealTime();
+
+    auto async_logger_tracing = std::make_shared<spdlog::async_logger>(
+        "async_logger_tracing", std::make_shared<null_sink_mt>(), std::move(tp), spdlog::async_overflow_policy::overrun_oldest);
+    async_logger_tracing->enable_backtrace(32);
+    benchmark::RegisterBenchmark("async_logger/tracing", bench_logger, async_logger_tracing)->Threads(n_threads)->UseRealTime();
+
+    benchmark::Initialize(&argc, argv);
+    benchmark::RunSpecifiedBenchmarks();
+}
diff --git a/3rdparty/spdlog/src/bench/utils.h b/3rdparty/spdlog/src/bench/utils.h
new file mode 100644
index 00000000..91610128
--- /dev/null
+++ b/3rdparty/spdlog/src/bench/utils.h
@@ -0,0 +1,34 @@
+//
+// Copyright(c) 2015 Gabi Melman.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+//
+
+#pragma once
+
+#include <iomanip>
+#include <locale>
+#include <sstream>
+
+namespace utils {
+
+template<typename T>
+inline std::string format(const T &value)
+{
+    static std::locale loc("");
+    std::stringstream ss;
+    ss.imbue(loc);
+    ss << value;
+    return ss.str();
+}
+
+template<>
+inline std::string format(const double &value)
+{
+    static std::locale loc("");
+    std::stringstream ss;
+    ss.imbue(loc);
+    ss << std::fixed << std::setprecision(1) << value;
+    return ss.str();
+}
+
+} // namespace utils
diff --git a/3rdparty/spdlog/src/cmake/ide.cmake b/3rdparty/spdlog/src/cmake/ide.cmake
new file mode 100644
index 00000000..a0656a5e
--- /dev/null
+++ b/3rdparty/spdlog/src/cmake/ide.cmake
@@ -0,0 +1,18 @@
+# ---------------------------------------------------------------------------------------
+# IDE support for headers
+# ---------------------------------------------------------------------------------------
+set(SPDLOG_HEADERS_DIR "${CMAKE_CURRENT_LIST_DIR}/../include")
+
+file(GLOB SPDLOG_TOP_HEADERS "${SPDLOG_HEADERS_DIR}/spdlog/*.h")
+file(GLOB SPDLOG_DETAILS_HEADERS "${SPDLOG_HEADERS_DIR}/spdlog/details/*.h")
+file(GLOB SPDLOG_SINKS_HEADERS "${SPDLOG_HEADERS_DIR}/spdlog/sinks/*.h")
+file(GLOB SPDLOG_FMT_HEADERS "${SPDLOG_HEADERS_DIR}/spdlog/fmt/*.h")
+file(GLOB SPDLOG_FMT_BUNDELED_HEADERS "${SPDLOG_HEADERS_DIR}/spdlog/fmt/bundled/*.h")
+set(SPDLOG_ALL_HEADERS ${SPDLOG_TOP_HEADERS} ${SPDLOG_DETAILS_HEADERS} ${SPDLOG_SINKS_HEADERS} ${SPDLOG_FMT_HEADERS}
+                       ${SPDLOG_FMT_BUNDELED_HEADERS})
+
+source_group("Header Files\\spdlog" FILES ${SPDLOG_TOP_HEADERS})
+source_group("Header Files\\spdlog\\details" FILES ${SPDLOG_DETAILS_HEADERS})
+source_group("Header Files\\spdlog\\sinks" FILES ${SPDLOG_SINKS_HEADERS})
+source_group("Header Files\\spdlog\\fmt" FILES ${SPDLOG_FMT_HEADERS})
+source_group("Header Files\\spdlog\\fmt\\bundled\\" FILES ${SPDLOG_FMT_BUNDELED_HEADERS})
diff --git a/3rdparty/spdlog/src/cmake/pch.h.in b/3rdparty/spdlog/src/cmake/pch.h.in
new file mode 100644
index 00000000..a5f94150
--- /dev/null
+++ b/3rdparty/spdlog/src/cmake/pch.h.in
@@ -0,0 +1,258 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+// details/pattern_formatter-inl.h
+// fmt/bin_to_hex.h
+// fmt/bundled/format-inl.h
+#include <cctype>
+
+// details/file_helper-inl.h
+// details/os-inl.h
+// fmt/bundled/core.h
+// fmt/bundled/posix.h
+// logger-inl.h
+// sinks/daily_file_sink.h
+// sinks/stdout_sinks.h
+#include <cstdio>
+
+// details/os-inl.h
+// fmt/bundled/posix.h
+#include <cstdlib>
+
+// details/os-inl.h
+// details/pattern_formatter-inl.h
+// fmt/bundled/core.h
+// fmt/bundled/format-inl.h
+#include <cstring>
+
+// details/os-inl.h
+// details/os.h
+// details/pattern_formatter-inl.h
+// details/pattern_formatter.h
+// fmt/bundled/chrono.h
+// sinks/daily_file_sink.h
+// sinks/rotating_file_sink-inl.h
+#include <ctime>
+
+// fmt/bundled/format-inl.h
+#include <climits>
+
+// fmt/bundled/format-inl.h
+#include <cwchar>
+
+// fmt/bundled/format-inl.h
+// fmt/bundled/format.h
+#include <cmath>
+
+// fmt/bundled/format-inl.h
+#include <cstdarg>
+
+// details/file_helper-inl.h
+// fmt/bundled/format.h
+// fmt/bundled/posix.h
+// sinks/rotating_file_sink-inl.h
+#include <cerrno>
+
+// details/circular_q.h
+// details/thread_pool-inl.h
+// fmt/bundled/format-inl.h
+#include <cassert>
+
+// async_logger-inl.h
+// cfg/helpers-inl.h
+// log_levels.h
+// common.h
+// details/file_helper-inl.h
+// details/log_msg.h
+// details/os-inl.h
+// details/pattern_formatter-inl.h
+// details/pattern_formatter.h
+// details/registry-inl.h
+// details/registry.h
+// details/tcp_client-windows.h
+// details/tcp_client.h
+// fmt/bundled/core.h
+// sinks/android_sink.h
+// sinks/ansicolor_sink.h
+// sinks/basic_file_sink.h
+// sinks/daily_file_sink.h
+// sinks/dup_filter_sink.h
+// sinks/msvc_sink.h
+// sinks/ringbuffer_sink.h
+// sinks/rotating_file_sink-inl.h
+// sinks/rotating_file_sink.h
+// sinks/syslog_sink.h
+// sinks/tcp_sink.h
+// sinks/win_eventlog_sink.h
+// sinks/wincolor_sink.h
+// spdlog.h:
+#include <string>
+
+// cfg/helpers-inl.h
+// fmt/bundled/chrono.h
+#include <sstream>
+
+// fmt/bundled/ostream.h
+// sinks/ostream_sink.h
+#include <ostream>
+
+// cfg/log_levels.h
+// details/registry-inl.h
+// details/registry.h
+#include <unordered_map>
+
+// details/circular_q.h
+// details/pattern_formatter-inl.h
+// details/pattern_formatter.h
+// details/thread_pool.h
+// fmt/bundled/compile.h
+// logger.h
+// sinks/dist_sink.h
+// sinks/ringbuffer_sink.h
+// sinks/win_eventlog_sink.h
+#include <vector>
+
+// details/os-inl.h
+// details/pattern_formatter-inl.h
+// sinks/ansicolor_sink.h
+// sinks/syslog_sink.h
+// sinks/systemd_sink.h
+// sinks/wincolor_sink.h
+#include <array>
+
+// details/file_helper-inl.h
+// details/file_helper.h
+// sinks/rotating_file_sink-inl.h
+#include <tuple>
+
+// details/os-inl.h
+// fmt/bundled/format.h
+// fmt/bundled/printf.h
+#include <limits>
+
+// common.h
+// details/backtracer.h
+// details/null_mutex.h
+#include <atomic>
+
+// common.h
+// details/backtracer.h
+// details/null_mutex.h
+#include <locale>
+
+// common.h
+#include <initializer_list>
+
+// common.h
+#include <exception>
+
+// common.h
+// details/fmt_helper.h
+// fmt/bundled/core.h
+// fmt/bundled/ranges.h
+#include <type_traits>
+
+// cfg/helpers-inl.h
+// details/null_mutex.h
+// details/pattern_formatter-inl.h
+#include <utility>
+
+// async.h
+// async_logger-inl.h
+// common.h
+// details/pattern_formatter-inl.h
+// details/pattern_formatter.h
+// details/registry-inl.h
+// details/registry.h
+// details/thread_pool.h
+// fmt/bundled/format.h
+// sinks/ansicolor_sink.h
+// sinks/base_sink-inl.h
+// sinks/dist_sink.h
+// sinks/stdout_sinks-inl.h
+// sinks/wincolor_sink.h
+// spdlog.h
+#include <memory>
+
+// async.h
+// common.h
+// details/backtracer.h
+// details/periodic_worker.h
+// details/registry-inl.h
+// details/registry.h
+// details/thread_pool.h
+// sinks/tcp_sink.h
+// spdlog.h
+#include <functional>
+
+// details/mpmc_blocking_q.h
+// details/periodic_worker.h
+#include <condition_variable>
+
+// details/os-inl.h
+// fmt/bundled/format.h
+// fmt/bundled/printf.h
+// sinks/dist_sink.h
+#include <algorithm>
+
+// common.h
+// details/file_helper-inl.h
+// details/fmt_helper.h
+// details/os-inl.h
+// details/pattern_formatter-inl.h
+// details/pattern_formatter.h
+// details/periodic_worker.h
+// details/registry-inl.h
+// details/registry.h
+// details/thread_pool.h
+// fmt/bundled/chrono.h
+// sinks/android_sink.h
+// sinks/daily_file_sink.h
+// sinks/dup_filter_sink.h
+// sinks/rotating_file_sink-inl.h
+// sinks/rotating_file_sink.h
+// sinks/tcp_sink.h
+// spdlog.h
+#include <chrono>
+
+// details/file_helper-inl.h
+// details/os-inl.h
+// details/pattern_formatter-inl.h
+// details/periodic_worker.h
+// details/thread_pool.h
+// sinks/android_sink.h
+#include <thread>
+
+// async.h
+// details/backtracer.h
+// details/console_globals.h
+// details/mpmc_blocking_q.h
+// details/pattern_formatter-inl.h
+// details/periodic_worker.h
+// details/registry.h
+// sinks/android_sink.h
+// sinks/ansicolor_sink.h
+// sinks/basic_file_sink.h
+// sinks/daily_file_sink.h
+// sinks/dist_sink.h
+// sinks/dup_filter_sink.h
+// sinks/msvc_sink.h
+// sinks/null_sink.h
+// sinks/ostream_sink.h
+// sinks/ringbuffer_sink.h
+// sinks/rotating_file_sink-inl.h
+// sinks/rotating_file_sink.h
+// sinks/tcp_sink.h
+// sinks/win_eventlog_sink.h
+// sinks/wincolor_sink.h
+//
+// color_sinks.cpp
+// file_sinks.cpp
+// spdlog.cpp
+// stdout_sinks.cpp
+#include <mutex>
+
+// spdlog
+#include <spdlog/common.h>
\ No newline at end of file
diff --git a/3rdparty/spdlog/src/cmake/spdlog.pc.in b/3rdparty/spdlog/src/cmake/spdlog.pc.in
new file mode 100644
index 00000000..ffab5d6f
--- /dev/null
+++ b/3rdparty/spdlog/src/cmake/spdlog.pc.in
@@ -0,0 +1,13 @@
+prefix=@CMAKE_INSTALL_PREFIX@
+exec_prefix=${prefix}
+includedir=@PKG_CONFIG_INCLUDEDIR@
+libdir=@PKG_CONFIG_LIBDIR@
+
+Name: lib@PROJECT_NAME@
+Description: Fast C++ logging library.
+URL: https://github.com/gabime/@PROJECT_NAME@
+Version: @SPDLOG_VERSION@
+CFlags: -I${includedir} @PKG_CONFIG_DEFINES@
+Libs: -L${libdir} -lspdlog -pthread
+Requires: @PKG_CONFIG_REQUIRES@
+
diff --git a/3rdparty/spdlog/src/cmake/spdlogCPack.cmake b/3rdparty/spdlog/src/cmake/spdlogCPack.cmake
new file mode 100644
index 00000000..58bf4013
--- /dev/null
+++ b/3rdparty/spdlog/src/cmake/spdlogCPack.cmake
@@ -0,0 +1,60 @@
+set(CPACK_GENERATOR "TGZ;ZIP" CACHE STRING "Semicolon separated list of generators")
+
+set(CPACK_INCLUDE_TOPLEVEL_DIRECTORY 0)
+set(CPACK_INSTALL_CMAKE_PROJECTS "${CMAKE_BINARY_DIR}" "${PROJECT_NAME}" ALL .)
+
+set(CPACK_PROJECT_URL "https://github.com/gabime/spdlog")
+set(CPACK_PACKAGE_VENDOR "Gabi Melman")
+set(CPACK_PACKAGE_CONTACT "Gabi Melman <gmelman1@gmail.com>")
+set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "Fast C++ logging library")
+set(CPACK_PACKAGE_VERSION_MAJOR ${PROJECT_VERSION_MAJOR})
+set(CPACK_PACKAGE_VERSION_MINOR ${PROJECT_VERSION_MINOR})
+set(CPACK_PACKAGE_VERSION_PATCH ${PROJECT_VERSION_PATCH})
+set(CPACK_PACKAGE_VERSION ${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH})
+if(PROJECT_VERSION_TWEAK)
+    set(CPACK_PACKAGE_VERSION ${CPACK_PACKAGE_VERSION}.${PROJECT_VERSION_TWEAK})
+endif()
+set(CPACK_PACKAGE_RELOCATABLE ON CACHE BOOL "Build relocatable package")
+
+set(CPACK_RPM_PACKAGE_LICENSE "MIT")
+set(CPACK_RPM_PACKAGE_GROUP "Development/Libraries")
+set(CPACK_DEBIAN_PACKAGE_SECTION "libs")
+set(CPACK_RPM_PACKAGE_URL ${CPACK_PROJECT_URL})
+set(CPACK_DEBIAN_PACKAGE_HOMEPAGE ${CPACK_PROJECT_URL})
+set(CPACK_RPM_PACKAGE_DESCRIPTION "Very fast, header-only/compiled, C++ logging library.")
+set(CPACK_DEBIAN_PACKAGE_DESCRIPTION "Very fast, header-only/compiled, C++ logging library.")
+
+if(CPACK_PACKAGE_NAME)
+    set(CPACK_RPM_FILE_NAME "${CPACK_PACKAGE_NAME}-${CPACK_PACKAGE_VERSION}")
+    set(CPACK_DEBIAN_FILE_NAME "${CPACK_PACKAGE_NAME}-${CPACK_PACKAGE_VERSION}")
+else()
+    set(CPACK_RPM_FILE_NAME "${PROJECT_NAME}-${CPACK_PACKAGE_VERSION}")
+    set(CPACK_DEBIAN_FILE_NAME "${PROJECT_NAME}-${CPACK_PACKAGE_VERSION}")
+    set(CPACK_RPM_PACKAGE_NAME "${PROJECT_NAME}")
+    set(CPACK_DEBIAN_PACKAGE_NAME "${PROJECT_NAME}")
+endif()
+
+if(CPACK_RPM_PACKAGE_RELEASE)
+    set(CPACK_RPM_FILE_NAME "${CPACK_RPM_FILE_NAME}-${CPACK_RPM_PACKAGE_RELEASE}")
+endif()
+if(CPACK_DEBIAN_PACKAGE_RELEASE)
+    set(CPACK_DEBIAN_FILE_NAME "${CPACK_DEBIAN_FILE_NAME}-${CPACK_DEBIAN_PACKAGE_RELEASE}")
+endif()
+
+if(CPACK_RPM_PACKAGE_ARCHITECTURE)
+    set(CPACK_RPM_FILE_NAME "${CPACK_RPM_FILE_NAME}.${CPACK_RPM_PACKAGE_ARCHITECTURE}")
+endif()
+if(CPACK_DEBIAN_PACKAGE_ARCHITECTURE)
+    set(CPACK_DEBIAN_FILE_NAME "${CPACK_DEBIAN_FILE_NAME}.${CPACK_DEBIAN_PACKAGE_ARCHITECTURE}")
+endif()
+set(CPACK_RPM_FILE_NAME "${CPACK_RPM_FILE_NAME}.rpm")
+set(CPACK_DEBIAN_FILE_NAME "${CPACK_DEBIAN_FILE_NAME}.deb")
+
+if(NOT CPACK_PACKAGE_RELOCATABLE)
+    # Depend on pkgconfig rpm to create the system pkgconfig folder
+    set(CPACK_RPM_PACKAGE_REQUIRES pkgconfig)
+    set(CPACK_RPM_EXCLUDE_FROM_AUTO_FILELIST_ADDITION
+        "${CPACK_PACKAGING_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}/pkgconfig")
+endif()
+
+include(CPack)
diff --git a/3rdparty/spdlog/src/cmake/spdlogConfig.cmake.in b/3rdparty/spdlog/src/cmake/spdlogConfig.cmake.in
new file mode 100644
index 00000000..d8a3ac16
--- /dev/null
+++ b/3rdparty/spdlog/src/cmake/spdlogConfig.cmake.in
@@ -0,0 +1,20 @@
+# Copyright(c) 2019 spdlog authors
+# Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+@PACKAGE_INIT@
+
+find_package(Threads REQUIRED)
+
+set(SPDLOG_FMT_EXTERNAL @SPDLOG_FMT_EXTERNAL@)
+set(SPDLOG_FMT_EXTERNAL_HO @SPDLOG_FMT_EXTERNAL_HO@)
+set(config_targets_file @config_targets_file@)
+
+if(SPDLOG_FMT_EXTERNAL OR SPDLOG_FMT_EXTERNAL_HO)
+    include(CMakeFindDependencyMacro)
+    find_dependency(fmt CONFIG)
+endif()
+
+
+include("${CMAKE_CURRENT_LIST_DIR}/${config_targets_file}")
+
+check_required_components(spdlog)
diff --git a/3rdparty/spdlog/src/cmake/utils.cmake b/3rdparty/spdlog/src/cmake/utils.cmake
new file mode 100644
index 00000000..85fcd80f
--- /dev/null
+++ b/3rdparty/spdlog/src/cmake/utils.cmake
@@ -0,0 +1,62 @@
+# Get spdlog version from include/spdlog/version.h and put it in SPDLOG_VERSION
+function(spdlog_extract_version)
+    file(READ "${CMAKE_CURRENT_LIST_DIR}/include/spdlog/version.h" file_contents)
+    string(REGEX MATCH "SPDLOG_VER_MAJOR ([0-9]+)" _ "${file_contents}")
+    if(NOT CMAKE_MATCH_COUNT EQUAL 1)
+        message(FATAL_ERROR "Could not extract major version number from spdlog/version.h")
+    endif()
+    set(ver_major ${CMAKE_MATCH_1})
+
+    string(REGEX MATCH "SPDLOG_VER_MINOR ([0-9]+)" _ "${file_contents}")
+    if(NOT CMAKE_MATCH_COUNT EQUAL 1)
+        message(FATAL_ERROR "Could not extract minor version number from spdlog/version.h")
+    endif()
+
+    set(ver_minor ${CMAKE_MATCH_1})
+    string(REGEX MATCH "SPDLOG_VER_PATCH ([0-9]+)" _ "${file_contents}")
+    if(NOT CMAKE_MATCH_COUNT EQUAL 1)
+        message(FATAL_ERROR "Could not extract patch version number from spdlog/version.h")
+    endif()
+    set(ver_patch ${CMAKE_MATCH_1})
+
+    set(SPDLOG_VERSION_MAJOR ${ver_major} PARENT_SCOPE)
+    set(SPDLOG_VERSION_MINOR ${ver_minor} PARENT_SCOPE)
+    set(SPDLOG_VERSION_PATCH ${ver_patch} PARENT_SCOPE)
+    set(SPDLOG_VERSION "${ver_major}.${ver_minor}.${ver_patch}" PARENT_SCOPE)
+endfunction()
+
+# Turn on warnings on the given target
+function(spdlog_enable_warnings target_name)
+    if(SPDLOG_BUILD_WARNINGS)
+        if(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
+            list(APPEND MSVC_OPTIONS "/W3")
+            if(MSVC_VERSION GREATER 1900) # Allow non fatal security warnings for msvc 2015
+                list(APPEND MSVC_OPTIONS "/WX")
+            endif()
+        endif()
+
+        target_compile_options(
+            ${target_name}
+            PRIVATE $<$<OR:$<CXX_COMPILER_ID:Clang>,$<CXX_COMPILER_ID:AppleClang>,$<CXX_COMPILER_ID:GNU>>:
+                    -Wall
+                    -Wextra
+                    -Wconversion
+                    -pedantic
+                    -Werror
+                    -Wfatal-errors>
+                    $<$<CXX_COMPILER_ID:MSVC>:${MSVC_OPTIONS}>)
+    endif()
+endfunction()
+
+# Enable address sanitizer (gcc/clang only)
+function(spdlog_enable_sanitizer target_name)
+    if(NOT CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang")
+        message(FATAL_ERROR "Sanitizer supported only for gcc/clang")
+    endif()
+    message(STATUS "Address sanitizer enabled")
+    target_compile_options(${target_name} PRIVATE -fsanitize=address,undefined)
+    target_compile_options(${target_name} PRIVATE -fno-sanitize=signed-integer-overflow)
+    target_compile_options(${target_name} PRIVATE -fno-sanitize-recover=all)
+    target_compile_options(${target_name} PRIVATE -fno-omit-frame-pointer)
+    target_link_libraries(${target_name} PRIVATE -fsanitize=address,undefined -fuse-ld=gold)
+endfunction()
diff --git a/3rdparty/spdlog/src/cmake/version.rc.in b/3rdparty/spdlog/src/cmake/version.rc.in
new file mode 100644
index 00000000..a86c1385
--- /dev/null
+++ b/3rdparty/spdlog/src/cmake/version.rc.in
@@ -0,0 +1,42 @@
+#define APSTUDIO_READONLY_SYMBOLS
+#include <windows.h>
+#undef APSTUDIO_READONLY_SYMBOLS
+
+LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US
+
+
+VS_VERSION_INFO VERSIONINFO
+ FILEVERSION @SPDLOG_VERSION_MAJOR@,@SPDLOG_VERSION_MINOR@,@SPDLOG_VERSION_PATCH@,0
+ PRODUCTVERSION @SPDLOG_VERSION_MAJOR@,@SPDLOG_VERSION_MINOR@,@SPDLOG_VERSION_PATCH@,0
+ FILEFLAGSMASK 0x3fL
+#ifdef _DEBUG
+ FILEFLAGS 0x1L
+#else
+ FILEFLAGS 0x0L
+#endif
+ FILEOS 0x40004L
+ FILETYPE 0x2L
+ FILESUBTYPE 0x0L
+BEGIN
+    BLOCK "StringFileInfo"
+    BEGIN
+        BLOCK "040904b0"
+        BEGIN
+            VALUE "FileDescription", "spdlog dll\0"
+            VALUE "FileVersion", "@SPDLOG_VERSION@.0\0"
+            VALUE "InternalName", "spdlog.dll\0"
+            VALUE "LegalCopyright", "Copyright (C) spdlog\0"
+            VALUE "ProductName", "spdlog\0"
+            VALUE "ProductVersion", "@SPDLOG_VERSION@.0\0"
+        END
+    END
+    BLOCK "VarFileInfo"
+    BEGIN
+        VALUE "Translation", 0x409, 1200
+    END
+END
+
+
+
+
+
diff --git a/3rdparty/spdlog/src/example/CMakeLists.txt b/3rdparty/spdlog/src/example/CMakeLists.txt
new file mode 100644
index 00000000..a7863493
--- /dev/null
+++ b/3rdparty/spdlog/src/example/CMakeLists.txt
@@ -0,0 +1,23 @@
+# Copyright(c) 2019 spdlog authors Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+cmake_minimum_required(VERSION 3.10)
+project(spdlog_examples CXX)
+
+if(NOT TARGET spdlog)
+    # Stand-alone build
+    find_package(spdlog REQUIRED)
+endif()
+
+# ---------------------------------------------------------------------------------------
+# Example of using pre-compiled library
+# ---------------------------------------------------------------------------------------
+add_executable(example example.cpp)
+target_link_libraries(example PRIVATE spdlog::spdlog $<$<BOOL:${MINGW}>:ws2_32>)
+
+# ---------------------------------------------------------------------------------------
+# Example of using header-only library
+# ---------------------------------------------------------------------------------------
+if(SPDLOG_BUILD_EXAMPLE_HO)
+    add_executable(example_header_only example.cpp)
+    target_link_libraries(example_header_only PRIVATE spdlog::spdlog_header_only)
+endif()
diff --git a/3rdparty/spdlog/src/example/example.cpp b/3rdparty/spdlog/src/example/example.cpp
new file mode 100644
index 00000000..ec31baaa
--- /dev/null
+++ b/3rdparty/spdlog/src/example/example.cpp
@@ -0,0 +1,391 @@
+//
+// Copyright(c) 2015 Gabi Melman.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+// spdlog usage example
+
+#include <cstdio>
+#include <chrono>
+
+void load_levels_example();
+void stdout_logger_example();
+void basic_example();
+void rotating_example();
+void daily_example();
+void callback_example();
+void async_example();
+void binary_example();
+void vector_example();
+void stopwatch_example();
+void trace_example();
+void multi_sink_example();
+void user_defined_example();
+void err_handler_example();
+void syslog_example();
+void udp_example();
+void custom_flags_example();
+void file_events_example();
+void replace_default_logger_example();
+
+#include "spdlog/spdlog.h"
+#include "spdlog/cfg/env.h"  // support for loading levels from the environment variable
+#include "spdlog/fmt/ostr.h" // support for user defined types
+
+int main(int, char *[])
+{
+    // Log levels can be loaded from argv/env using "SPDLOG_LEVEL"
+    load_levels_example();
+
+    spdlog::info("Welcome to spdlog version {}.{}.{}  !", SPDLOG_VER_MAJOR, SPDLOG_VER_MINOR, SPDLOG_VER_PATCH);
+
+    spdlog::warn("Easy padding in numbers like {:08d}", 12);
+    spdlog::critical("Support for int: {0:d};  hex: {0:x};  oct: {0:o}; bin: {0:b}", 42);
+    spdlog::info("Support for floats {:03.2f}", 1.23456);
+    spdlog::info("Positional args are {1} {0}..", "too", "supported");
+    spdlog::info("{:>8} aligned, {:<8} aligned", "right", "left");
+
+    // Runtime log levels
+    spdlog::set_level(spdlog::level::info); // Set global log level to info
+    spdlog::debug("This message should not be displayed!");
+    spdlog::set_level(spdlog::level::trace); // Set specific logger's log level
+    spdlog::debug("This message should be displayed..");
+
+    // Customize msg format for all loggers
+    spdlog::set_pattern("[%H:%M:%S %z] [%^%L%$] [thread %t] %v");
+    spdlog::info("This an info message with custom format");
+    spdlog::set_pattern("%+"); // back to default format
+    spdlog::set_level(spdlog::level::info);
+
+    // Backtrace support
+    // Loggers can store in a ring buffer all messages (including debug/trace) for later inspection.
+    // When needed, call dump_backtrace() to see what happened:
+    spdlog::enable_backtrace(10); // create ring buffer with capacity of 10  messages
+    for (int i = 0; i < 100; i++)
+    {
+        spdlog::debug("Backtrace message {}", i); // not logged..
+    }
+    // e.g. if some error happened:
+    spdlog::dump_backtrace(); // log them now!
+
+    try
+    {
+        stdout_logger_example();
+        basic_example();
+        rotating_example();
+        daily_example();
+        callback_example();
+        async_example();
+        binary_example();
+        vector_example();
+        multi_sink_example();
+        user_defined_example();
+        err_handler_example();
+        trace_example();
+        stopwatch_example();
+        udp_example();
+        custom_flags_example();
+        file_events_example();
+        replace_default_logger_example();
+
+        // Flush all *registered* loggers using a worker thread every 3 seconds.
+        // note: registered loggers *must* be thread safe for this to work correctly!
+        spdlog::flush_every(std::chrono::seconds(3));
+
+        // Apply some function on all registered loggers
+        spdlog::apply_all([&](std::shared_ptr<spdlog::logger> l) { l->info("End of example."); });
+
+        // Release all spdlog resources, and drop all loggers in the registry.
+        // This is optional (only mandatory if using windows + async log).
+        spdlog::shutdown();
+    }
+
+    // Exceptions will only be thrown upon failed logger or sink construction (not during logging).
+    catch (const spdlog::spdlog_ex &ex)
+    {
+        std::printf("Log initialization failed: %s\n", ex.what());
+        return 1;
+    }
+}
+
+#include "spdlog/sinks/stdout_color_sinks.h"
+// or #include "spdlog/sinks/stdout_sinks.h" if no colors needed.
+void stdout_logger_example()
+{
+    // Create color multi threaded logger.
+    auto console = spdlog::stdout_color_mt("console");
+    // or for stderr:
+    // auto console = spdlog::stderr_color_mt("error-logger");
+}
+
+#include "spdlog/sinks/basic_file_sink.h"
+void basic_example()
+{
+    // Create basic file logger (not rotated).
+    auto my_logger = spdlog::basic_logger_mt("file_logger", "logs/basic-log.txt", true);
+}
+
+#include "spdlog/sinks/rotating_file_sink.h"
+void rotating_example()
+{
+    // Create a file rotating logger with 5mb size max and 3 rotated files.
+    auto rotating_logger = spdlog::rotating_logger_mt("some_logger_name", "logs/rotating.txt", 1048576 * 5, 3);
+}
+
+#include "spdlog/sinks/daily_file_sink.h"
+void daily_example()
+{
+    // Create a daily logger - a new file is created every day on 2:30am.
+    auto daily_logger = spdlog::daily_logger_mt("daily_logger", "logs/daily.txt", 2, 30);
+}
+
+#include "spdlog/sinks/callback_sink.h"
+void callback_example()
+{
+    // Create the logger
+    auto logger = spdlog::callback_logger_mt("custom_callback_logger", [](const spdlog::details::log_msg & /*msg*/) {
+        // do what you need to do with msg
+    });
+}
+
+#include "spdlog/cfg/env.h"
+void load_levels_example()
+{
+    // Set the log level to "info" and mylogger to "trace":
+    // SPDLOG_LEVEL=info,mylogger=trace && ./example
+    spdlog::cfg::load_env_levels();
+    // or from command line:
+    // ./example SPDLOG_LEVEL=info,mylogger=trace
+    // #include "spdlog/cfg/argv.h" // for loading levels from argv
+    // spdlog::cfg::load_argv_levels(args, argv);
+}
+
+#include "spdlog/async.h"
+void async_example()
+{
+    // Default thread pool settings can be modified *before* creating the async logger:
+    // spdlog::init_thread_pool(32768, 1); // queue with max 32k items 1 backing thread.
+    auto async_file = spdlog::basic_logger_mt<spdlog::async_factory>("async_file_logger", "logs/async_log.txt");
+    // alternatively:
+    // auto async_file = spdlog::create_async<spdlog::sinks::basic_file_sink_mt>("async_file_logger", "logs/async_log.txt");
+
+    for (int i = 1; i < 101; ++i)
+    {
+        async_file->info("Async message #{}", i);
+    }
+}
+
+// Log binary data as hex.
+// Many types of std::container<char> types can be used.
+// Iterator ranges are supported too.
+// Format flags:
+// {:X} - print in uppercase.
+// {:s} - don't separate each byte with space.
+// {:p} - don't print the position on each line start.
+// {:n} - don't split the output to lines.
+
+#include "spdlog/fmt/bin_to_hex.h"
+void binary_example()
+{
+    std::vector<char> buf(80);
+    for (int i = 0; i < 80; i++)
+    {
+        buf.push_back(static_cast<char>(i & 0xff));
+    }
+    spdlog::info("Binary example: {}", spdlog::to_hex(buf));
+    spdlog::info("Another binary example:{:n}", spdlog::to_hex(std::begin(buf), std::begin(buf) + 10));
+    // more examples:
+    // logger->info("uppercase: {:X}", spdlog::to_hex(buf));
+    // logger->info("uppercase, no delimiters: {:Xs}", spdlog::to_hex(buf));
+    // logger->info("uppercase, no delimiters, no position info: {:Xsp}", spdlog::to_hex(buf));
+    // logger->info("hexdump style: {:a}", spdlog::to_hex(buf));
+    // logger->info("hexdump style, 20 chars per line {:a}", spdlog::to_hex(buf, 20));
+}
+
+// Log a vector of numbers
+#ifndef SPDLOG_USE_STD_FORMAT
+#    include "spdlog/fmt/ranges.h"
+void vector_example()
+{
+    std::vector<int> vec = {1, 2, 3};
+    spdlog::info("Vector example: {}", vec);
+}
+
+#else
+void vector_example() {}
+#endif
+
+// ! DSPDLOG_USE_STD_FORMAT
+
+// Compile time log levels.
+// define SPDLOG_ACTIVE_LEVEL to required level (e.g. SPDLOG_LEVEL_TRACE)
+void trace_example()
+{
+    // trace from default logger
+    SPDLOG_TRACE("Some trace message.. {} ,{}", 1, 3.23);
+    // debug from default logger
+    SPDLOG_DEBUG("Some debug message.. {} ,{}", 1, 3.23);
+
+    // trace from logger object
+    auto logger = spdlog::get("file_logger");
+    SPDLOG_LOGGER_TRACE(logger, "another trace message");
+}
+
+// stopwatch example
+#include "spdlog/stopwatch.h"
+#include <thread>
+void stopwatch_example()
+{
+    spdlog::stopwatch sw;
+    std::this_thread::sleep_for(std::chrono::milliseconds(123));
+    spdlog::info("Stopwatch: {} seconds", sw);
+}
+
+#include "spdlog/sinks/udp_sink.h"
+void udp_example()
+{
+    spdlog::sinks::udp_sink_config cfg("127.0.0.1", 11091);
+    auto my_logger = spdlog::udp_logger_mt("udplog", cfg);
+    my_logger->set_level(spdlog::level::debug);
+    my_logger->info("hello world");
+}
+
+// A logger with multiple sinks (stdout and file) - each with a different format and log level.
+void multi_sink_example()
+{
+    auto console_sink = std::make_shared<spdlog::sinks::stdout_color_sink_mt>();
+    console_sink->set_level(spdlog::level::warn);
+    console_sink->set_pattern("[multi_sink_example] [%^%l%$] %v");
+
+    auto file_sink = std::make_shared<spdlog::sinks::basic_file_sink_mt>("logs/multisink.txt", true);
+    file_sink->set_level(spdlog::level::trace);
+
+    spdlog::logger logger("multi_sink", {console_sink, file_sink});
+    logger.set_level(spdlog::level::debug);
+    logger.warn("this should appear in both console and file");
+    logger.info("this message should not appear in the console, only in the file");
+}
+
+// User defined types logging
+struct my_type
+{
+    int i = 0;
+    explicit my_type(int i)
+        : i(i){};
+};
+
+#ifndef SPDLOG_USE_STD_FORMAT // when using fmtlib
+template<>
+struct fmt::formatter<my_type> : fmt::formatter<std::string>
+{
+    auto format(my_type my, format_context &ctx) -> decltype(ctx.out())
+    {
+        return fmt::format_to(ctx.out(), "[my_type i={}]", my.i);
+    }
+};
+
+#else // when using std::format
+template<>
+struct std::formatter<my_type> : std::formatter<std::string>
+{
+    auto format(my_type my, format_context &ctx) -> decltype(ctx.out())
+    {
+        return format_to(ctx.out(), "[my_type i={}]", my.i);
+    }
+};
+#endif
+
+void user_defined_example()
+{
+    spdlog::info("user defined type: {}", my_type(14));
+}
+
+// Custom error handler. Will be triggered on log failure.
+void err_handler_example()
+{
+    // can be set globally or per logger(logger->set_error_handler(..))
+    spdlog::set_error_handler([](const std::string &msg) { printf("*** Custom log error handler: %s ***\n", msg.c_str()); });
+}
+
+// syslog example (linux/osx/freebsd)
+#ifndef _WIN32
+#    include "spdlog/sinks/syslog_sink.h"
+void syslog_example()
+{
+    std::string ident = "spdlog-example";
+    auto syslog_logger = spdlog::syslog_logger_mt("syslog", ident, LOG_PID);
+    syslog_logger->warn("This is warning that will end up in syslog.");
+}
+#endif
+
+// Android example.
+#if defined(__ANDROID__)
+#    include "spdlog/sinks/android_sink.h"
+void android_example()
+{
+    std::string tag = "spdlog-android";
+    auto android_logger = spdlog::android_logger_mt("android", tag);
+    android_logger->critical("Use \"adb shell logcat\" to view this message.");
+}
+#endif
+
+// Log patterns can contain custom flags.
+// this will add custom flag '%*' which will be bound to a <my_formatter_flag> instance
+#include "spdlog/pattern_formatter.h"
+class my_formatter_flag : public spdlog::custom_flag_formatter
+{
+public:
+    void format(const spdlog::details::log_msg &, const std::tm &, spdlog::memory_buf_t &dest) override
+    {
+        std::string some_txt = "custom-flag";
+        dest.append(some_txt.data(), some_txt.data() + some_txt.size());
+    }
+
+    std::unique_ptr<custom_flag_formatter> clone() const override
+    {
+        return spdlog::details::make_unique<my_formatter_flag>();
+    }
+};
+
+void custom_flags_example()
+{
+
+    using spdlog::details::make_unique; // for pre c++14
+    auto formatter = make_unique<spdlog::pattern_formatter>();
+    formatter->add_flag<my_formatter_flag>('*').set_pattern("[%n] [%*] [%^%l%$] %v");
+    // set the new formatter using spdlog::set_formatter(formatter) or logger->set_formatter(formatter)
+    // spdlog::set_formatter(std::move(formatter));
+}
+
+void file_events_example()
+{
+    // pass the spdlog::file_event_handlers to file sinks for open/close log file notifications
+    spdlog::file_event_handlers handlers;
+    handlers.before_open = [](spdlog::filename_t filename) { spdlog::info("Before opening {}", filename); };
+    handlers.after_open = [](spdlog::filename_t filename, std::FILE *fstream) {
+        spdlog::info("After opening {}", filename);
+        fputs("After opening\n", fstream);
+    };
+    handlers.before_close = [](spdlog::filename_t filename, std::FILE *fstream) {
+        spdlog::info("Before closing {}", filename);
+        fputs("Before closing\n", fstream);
+    };
+    handlers.after_close = [](spdlog::filename_t filename) { spdlog::info("After closing {}", filename); };
+    auto file_sink = std::make_shared<spdlog::sinks::basic_file_sink_mt>("logs/events-sample.txt", true, handlers);
+    spdlog::logger my_logger("some_logger", file_sink);
+    my_logger.info("Some log line");
+}
+
+void replace_default_logger_example()
+{
+    // store the old logger so we don't break other examples.
+    auto old_logger = spdlog::default_logger();
+
+    auto new_logger = spdlog::basic_logger_mt("new_default_logger", "logs/new-default-log.txt", true);
+    spdlog::set_default_logger(new_logger);
+    spdlog::set_level(spdlog::level::info);
+    spdlog::debug("This message should not be displayed!");
+    spdlog::set_level(spdlog::level::trace);
+    spdlog::debug("This message should be displayed..");
+
+    spdlog::set_default_logger(old_logger);
+}
diff --git a/3rdparty/spdlog/src/include/spdlog/async.h b/3rdparty/spdlog/src/include/spdlog/async.h
new file mode 100644
index 00000000..94f9f6d9
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/async.h
@@ -0,0 +1,99 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+//
+// Async logging using global thread pool
+// All loggers created here share same global thread pool.
+// Each log message is pushed to a queue along with a shared pointer to the
+// logger.
+// If a logger deleted while having pending messages in the queue, it's actual
+// destruction will defer
+// until all its messages are processed by the thread pool.
+// This is because each message in the queue holds a shared_ptr to the
+// originating logger.
+
+#include <spdlog/async_logger.h>
+#include <spdlog/details/registry.h>
+#include <spdlog/details/thread_pool.h>
+
+#include <memory>
+#include <mutex>
+#include <functional>
+
+namespace spdlog {
+
+namespace details {
+static const size_t default_async_q_size = 8192;
+}
+
+// async logger factory - creates async loggers backed with thread pool.
+// if a global thread pool doesn't already exist, create it with default queue
+// size of 8192 items and single thread.
+template<async_overflow_policy OverflowPolicy = async_overflow_policy::block>
+struct async_factory_impl
+{
+    template<typename Sink, typename... SinkArgs>
+    static std::shared_ptr<async_logger> create(std::string logger_name, SinkArgs &&...args)
+    {
+        auto &registry_inst = details::registry::instance();
+
+        // create global thread pool if not already exists..
+
+        auto &mutex = registry_inst.tp_mutex();
+        std::lock_guard<std::recursive_mutex> tp_lock(mutex);
+        auto tp = registry_inst.get_tp();
+        if (tp == nullptr)
+        {
+            tp = std::make_shared<details::thread_pool>(details::default_async_q_size, 1U);
+            registry_inst.set_tp(tp);
+        }
+
+        auto sink = std::make_shared<Sink>(std::forward<SinkArgs>(args)...);
+        auto new_logger = std::make_shared<async_logger>(std::move(logger_name), std::move(sink), std::move(tp), OverflowPolicy);
+        registry_inst.initialize_logger(new_logger);
+        return new_logger;
+    }
+};
+
+using async_factory = async_factory_impl<async_overflow_policy::block>;
+using async_factory_nonblock = async_factory_impl<async_overflow_policy::overrun_oldest>;
+
+template<typename Sink, typename... SinkArgs>
+inline std::shared_ptr<spdlog::logger> create_async(std::string logger_name, SinkArgs &&...sink_args)
+{
+    return async_factory::create<Sink>(std::move(logger_name), std::forward<SinkArgs>(sink_args)...);
+}
+
+template<typename Sink, typename... SinkArgs>
+inline std::shared_ptr<spdlog::logger> create_async_nb(std::string logger_name, SinkArgs &&...sink_args)
+{
+    return async_factory_nonblock::create<Sink>(std::move(logger_name), std::forward<SinkArgs>(sink_args)...);
+}
+
+// set global thread pool.
+inline void init_thread_pool(
+    size_t q_size, size_t thread_count, std::function<void()> on_thread_start, std::function<void()> on_thread_stop)
+{
+    auto tp = std::make_shared<details::thread_pool>(q_size, thread_count, on_thread_start, on_thread_stop);
+    details::registry::instance().set_tp(std::move(tp));
+}
+
+inline void init_thread_pool(size_t q_size, size_t thread_count, std::function<void()> on_thread_start)
+{
+    init_thread_pool(q_size, thread_count, on_thread_start, [] {});
+}
+
+inline void init_thread_pool(size_t q_size, size_t thread_count)
+{
+    init_thread_pool(
+        q_size, thread_count, [] {}, [] {});
+}
+
+// get the global thread pool.
+inline std::shared_ptr<spdlog::details::thread_pool> thread_pool()
+{
+    return details::registry::instance().get_tp();
+}
+} // namespace spdlog
diff --git a/3rdparty/spdlog/src/include/spdlog/async_logger-inl.h b/3rdparty/spdlog/src/include/spdlog/async_logger-inl.h
new file mode 100644
index 00000000..a1c27a59
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/async_logger-inl.h
@@ -0,0 +1,92 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#ifndef SPDLOG_HEADER_ONLY
+#    include <spdlog/async_logger.h>
+#endif
+
+#include <spdlog/sinks/sink.h>
+#include <spdlog/details/thread_pool.h>
+
+#include <memory>
+#include <string>
+
+SPDLOG_INLINE spdlog::async_logger::async_logger(
+    std::string logger_name, sinks_init_list sinks_list, std::weak_ptr<details::thread_pool> tp, async_overflow_policy overflow_policy)
+    : async_logger(std::move(logger_name), sinks_list.begin(), sinks_list.end(), std::move(tp), overflow_policy)
+{}
+
+SPDLOG_INLINE spdlog::async_logger::async_logger(
+    std::string logger_name, sink_ptr single_sink, std::weak_ptr<details::thread_pool> tp, async_overflow_policy overflow_policy)
+    : async_logger(std::move(logger_name), {std::move(single_sink)}, std::move(tp), overflow_policy)
+{}
+
+// send the log message to the thread pool
+SPDLOG_INLINE void spdlog::async_logger::sink_it_(const details::log_msg &msg)
+{
+    if (auto pool_ptr = thread_pool_.lock())
+    {
+        pool_ptr->post_log(shared_from_this(), msg, overflow_policy_);
+    }
+    else
+    {
+        throw_spdlog_ex("async log: thread pool doesn't exist anymore");
+    }
+}
+
+// send flush request to the thread pool
+SPDLOG_INLINE void spdlog::async_logger::flush_()
+{
+    if (auto pool_ptr = thread_pool_.lock())
+    {
+        pool_ptr->post_flush(shared_from_this(), overflow_policy_);
+    }
+    else
+    {
+        throw_spdlog_ex("async flush: thread pool doesn't exist anymore");
+    }
+}
+
+//
+// backend functions - called from the thread pool to do the actual job
+//
+SPDLOG_INLINE void spdlog::async_logger::backend_sink_it_(const details::log_msg &msg)
+{
+    for (auto &sink : sinks_)
+    {
+        if (sink->should_log(msg.level))
+        {
+            SPDLOG_TRY
+            {
+                sink->log(msg);
+            }
+            SPDLOG_LOGGER_CATCH(msg.source)
+        }
+    }
+
+    if (should_flush_(msg))
+    {
+        backend_flush_();
+    }
+}
+
+SPDLOG_INLINE void spdlog::async_logger::backend_flush_()
+{
+    for (auto &sink : sinks_)
+    {
+        SPDLOG_TRY
+        {
+            sink->flush();
+        }
+        SPDLOG_LOGGER_CATCH(source_loc())
+    }
+}
+
+SPDLOG_INLINE std::shared_ptr<spdlog::logger> spdlog::async_logger::clone(std::string new_name)
+{
+    auto cloned = std::make_shared<spdlog::async_logger>(*this);
+    cloned->name_ = std::move(new_name);
+    return cloned;
+}
diff --git a/3rdparty/spdlog/src/include/spdlog/async_logger.h b/3rdparty/spdlog/src/include/spdlog/async_logger.h
new file mode 100644
index 00000000..91a93fcb
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/async_logger.h
@@ -0,0 +1,68 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+// Fast asynchronous logger.
+// Uses pre allocated queue.
+// Creates a single back thread to pop messages from the queue and log them.
+//
+// Upon each log write the logger:
+//    1. Checks if its log level is enough to log the message
+//    2. Push a new copy of the message to a queue (or block the caller until
+//    space is available in the queue)
+// Upon destruction, logs all remaining messages in the queue before
+// destructing..
+
+#include <spdlog/logger.h>
+
+namespace spdlog {
+
+// Async overflow policy - block by default.
+enum class async_overflow_policy
+{
+    block,         // Block until message can be enqueued
+    overrun_oldest // Discard oldest message in the queue if full when trying to
+                   // add new item.
+};
+
+namespace details {
+class thread_pool;
+}
+
+class SPDLOG_API async_logger final : public std::enable_shared_from_this<async_logger>, public logger
+{
+    friend class details::thread_pool;
+
+public:
+    template<typename It>
+    async_logger(std::string logger_name, It begin, It end, std::weak_ptr<details::thread_pool> tp,
+        async_overflow_policy overflow_policy = async_overflow_policy::block)
+        : logger(std::move(logger_name), begin, end)
+        , thread_pool_(std::move(tp))
+        , overflow_policy_(overflow_policy)
+    {}
+
+    async_logger(std::string logger_name, sinks_init_list sinks_list, std::weak_ptr<details::thread_pool> tp,
+        async_overflow_policy overflow_policy = async_overflow_policy::block);
+
+    async_logger(std::string logger_name, sink_ptr single_sink, std::weak_ptr<details::thread_pool> tp,
+        async_overflow_policy overflow_policy = async_overflow_policy::block);
+
+    std::shared_ptr<logger> clone(std::string new_name) override;
+
+protected:
+    void sink_it_(const details::log_msg &msg) override;
+    void flush_() override;
+    void backend_sink_it_(const details::log_msg &incoming_log_msg);
+    void backend_flush_();
+
+private:
+    std::weak_ptr<details::thread_pool> thread_pool_;
+    async_overflow_policy overflow_policy_;
+};
+} // namespace spdlog
+
+#ifdef SPDLOG_HEADER_ONLY
+#    include "async_logger-inl.h"
+#endif
diff --git a/3rdparty/spdlog/src/include/spdlog/cfg/argv.h b/3rdparty/spdlog/src/include/spdlog/cfg/argv.h
new file mode 100644
index 00000000..36d9f1c4
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/cfg/argv.h
@@ -0,0 +1,44 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+#include <spdlog/cfg/helpers.h>
+#include <spdlog/details/registry.h>
+
+//
+// Init log levels using each argv entry that starts with "SPDLOG_LEVEL="
+//
+// set all loggers to debug level:
+// example.exe "SPDLOG_LEVEL=debug"
+
+// set logger1 to trace level
+// example.exe "SPDLOG_LEVEL=logger1=trace"
+
+// turn off all logging except for logger1 and logger2:
+// example.exe "SPDLOG_LEVEL=off,logger1=debug,logger2=info"
+
+namespace spdlog {
+namespace cfg {
+
+// search for SPDLOG_LEVEL= in the args and use it to init the levels
+inline void load_argv_levels(int argc, const char **argv)
+{
+    const std::string spdlog_level_prefix = "SPDLOG_LEVEL=";
+    for (int i = 1; i < argc; i++)
+    {
+        std::string arg = argv[i];
+        if (arg.find(spdlog_level_prefix) == 0)
+        {
+            auto levels_string = arg.substr(spdlog_level_prefix.size());
+            helpers::load_levels(levels_string);
+        }
+    }
+}
+
+inline void load_argv_levels(int argc, char **argv)
+{
+    load_argv_levels(argc, const_cast<const char **>(argv));
+}
+
+} // namespace cfg
+} // namespace spdlog
diff --git a/3rdparty/spdlog/src/include/spdlog/cfg/env.h b/3rdparty/spdlog/src/include/spdlog/cfg/env.h
new file mode 100644
index 00000000..1f39ebbb
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/cfg/env.h
@@ -0,0 +1,38 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+#include <spdlog/cfg/helpers.h>
+#include <spdlog/details/registry.h>
+#include <spdlog/details/os.h>
+
+//
+// Init levels and patterns from env variables SPDLOG_LEVEL
+// Inspired from Rust's "env_logger" crate (https://crates.io/crates/env_logger).
+// Note - fallback to "info" level on unrecognized levels
+//
+// Examples:
+//
+// set global level to debug:
+// export SPDLOG_LEVEL=debug
+//
+// turn off all logging except for logger1:
+// export SPDLOG_LEVEL="*=off,logger1=debug"
+//
+
+// turn off all logging except for logger1 and logger2:
+// export SPDLOG_LEVEL="off,logger1=debug,logger2=info"
+
+namespace spdlog {
+namespace cfg {
+inline void load_env_levels()
+{
+    auto env_val = details::os::getenv("SPDLOG_LEVEL");
+    if (!env_val.empty())
+    {
+        helpers::load_levels(env_val);
+    }
+}
+
+} // namespace cfg
+} // namespace spdlog
diff --git a/3rdparty/spdlog/src/include/spdlog/cfg/helpers-inl.h b/3rdparty/spdlog/src/include/spdlog/cfg/helpers-inl.h
new file mode 100644
index 00000000..675a13af
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/cfg/helpers-inl.h
@@ -0,0 +1,120 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#ifndef SPDLOG_HEADER_ONLY
+#    include <spdlog/cfg/helpers.h>
+#endif
+
+#include <spdlog/spdlog.h>
+#include <spdlog/details/os.h>
+#include <spdlog/details/registry.h>
+
+#include <algorithm>
+#include <string>
+#include <utility>
+#include <sstream>
+
+namespace spdlog {
+namespace cfg {
+namespace helpers {
+
+// inplace convert to lowercase
+inline std::string &to_lower_(std::string &str)
+{
+    std::transform(
+        str.begin(), str.end(), str.begin(), [](char ch) { return static_cast<char>((ch >= 'A' && ch <= 'Z') ? ch + ('a' - 'A') : ch); });
+    return str;
+}
+
+// inplace trim spaces
+inline std::string &trim_(std::string &str)
+{
+    const char *spaces = " \n\r\t";
+    str.erase(str.find_last_not_of(spaces) + 1);
+    str.erase(0, str.find_first_not_of(spaces));
+    return str;
+}
+
+// return (name,value) trimmed pair from given "name=value" string.
+// return empty string on missing parts
+// "key=val" => ("key", "val")
+// " key  =  val " => ("key", "val")
+// "key=" => ("key", "")
+// "val" => ("", "val")
+
+inline std::pair<std::string, std::string> extract_kv_(char sep, const std::string &str)
+{
+    auto n = str.find(sep);
+    std::string k, v;
+    if (n == std::string::npos)
+    {
+        v = str;
+    }
+    else
+    {
+        k = str.substr(0, n);
+        v = str.substr(n + 1);
+    }
+    return std::make_pair(trim_(k), trim_(v));
+}
+
+// return vector of key/value pairs from sequence of "K1=V1,K2=V2,.."
+// "a=AAA,b=BBB,c=CCC,.." => {("a","AAA"),("b","BBB"),("c", "CCC"),...}
+inline std::unordered_map<std::string, std::string> extract_key_vals_(const std::string &str)
+{
+    std::string token;
+    std::istringstream token_stream(str);
+    std::unordered_map<std::string, std::string> rv{};
+    while (std::getline(token_stream, token, ','))
+    {
+        if (token.empty())
+        {
+            continue;
+        }
+        auto kv = extract_kv_('=', token);
+        rv[kv.first] = kv.second;
+    }
+    return rv;
+}
+
+SPDLOG_INLINE void load_levels(const std::string &input)
+{
+    if (input.empty() || input.size() > 512)
+    {
+        return;
+    }
+
+    auto key_vals = extract_key_vals_(input);
+    std::unordered_map<std::string, level::level_enum> levels;
+    level::level_enum global_level = level::info;
+    bool global_level_found = false;
+
+    for (auto &name_level : key_vals)
+    {
+        auto &logger_name = name_level.first;
+        auto level_name = to_lower_(name_level.second);
+        auto level = level::from_str(level_name);
+        // ignore unrecognized level names
+        if (level == level::off && level_name != "off")
+        {
+            continue;
+        }
+        if (logger_name.empty()) // no logger name indicate global level
+        {
+            global_level_found = true;
+            global_level = level;
+        }
+        else
+        {
+            levels[logger_name] = level;
+        }
+    }
+
+    details::registry::instance().set_levels(std::move(levels), global_level_found ? &global_level : nullptr);
+}
+
+} // namespace helpers
+} // namespace cfg
+} // namespace spdlog
diff --git a/3rdparty/spdlog/src/include/spdlog/cfg/helpers.h b/3rdparty/spdlog/src/include/spdlog/cfg/helpers.h
new file mode 100644
index 00000000..ab7584e0
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/cfg/helpers.h
@@ -0,0 +1,29 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#include <spdlog/common.h>
+#include <unordered_map>
+
+namespace spdlog {
+namespace cfg {
+namespace helpers {
+//
+// Init levels from given string
+//
+// Examples:
+//
+// set global level to debug: "debug"
+// turn off all logging except for logger1: "off,logger1=debug"
+// turn off all logging except for logger1 and logger2: "off,logger1=debug,logger2=info"
+//
+SPDLOG_API void load_levels(const std::string &txt);
+} // namespace helpers
+
+} // namespace cfg
+} // namespace spdlog
+
+#ifdef SPDLOG_HEADER_ONLY
+#    include "helpers-inl.h"
+#endif // SPDLOG_HEADER_ONLY
diff --git a/3rdparty/spdlog/src/include/spdlog/common-inl.h b/3rdparty/spdlog/src/include/spdlog/common-inl.h
new file mode 100644
index 00000000..728f9831
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/common-inl.h
@@ -0,0 +1,82 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#ifndef SPDLOG_HEADER_ONLY
+#    include <spdlog/common.h>
+#endif
+
+#include <algorithm>
+#include <iterator>
+
+namespace spdlog {
+namespace level {
+
+#if __cplusplus >= 201703L
+constexpr
+#endif
+    static string_view_t level_string_views[] SPDLOG_LEVEL_NAMES;
+
+static const char *short_level_names[] SPDLOG_SHORT_LEVEL_NAMES;
+
+SPDLOG_INLINE const string_view_t &to_string_view(spdlog::level::level_enum l) SPDLOG_NOEXCEPT
+{
+    return level_string_views[l];
+}
+
+SPDLOG_INLINE const char *to_short_c_str(spdlog::level::level_enum l) SPDLOG_NOEXCEPT
+{
+    return short_level_names[l];
+}
+
+SPDLOG_INLINE spdlog::level::level_enum from_str(const std::string &name) SPDLOG_NOEXCEPT
+{
+    auto it = std::find(std::begin(level_string_views), std::end(level_string_views), name);
+    if (it != std::end(level_string_views))
+        return static_cast<level::level_enum>(std::distance(std::begin(level_string_views), it));
+
+    // check also for "warn" and "err" before giving up..
+    if (name == "warn")
+    {
+        return level::warn;
+    }
+    if (name == "err")
+    {
+        return level::err;
+    }
+    return level::off;
+}
+} // namespace level
+
+SPDLOG_INLINE spdlog_ex::spdlog_ex(std::string msg)
+    : msg_(std::move(msg))
+{}
+
+SPDLOG_INLINE spdlog_ex::spdlog_ex(const std::string &msg, int last_errno)
+{
+#ifdef SPDLOG_USE_STD_FORMAT
+    msg_ = std::system_error(std::error_code(last_errno, std::generic_category()), msg).what();
+#else
+    memory_buf_t outbuf;
+    fmt::format_system_error(outbuf, last_errno, msg.c_str());
+    msg_ = fmt::to_string(outbuf);
+#endif
+}
+
+SPDLOG_INLINE const char *spdlog_ex::what() const SPDLOG_NOEXCEPT
+{
+    return msg_.c_str();
+}
+
+SPDLOG_INLINE void throw_spdlog_ex(const std::string &msg, int last_errno)
+{
+    SPDLOG_THROW(spdlog_ex(msg, last_errno));
+}
+
+SPDLOG_INLINE void throw_spdlog_ex(std::string msg)
+{
+    SPDLOG_THROW(spdlog_ex(std::move(msg)));
+}
+
+} // namespace spdlog
diff --git a/3rdparty/spdlog/src/include/spdlog/common.h b/3rdparty/spdlog/src/include/spdlog/common.h
new file mode 100644
index 00000000..76d9b58d
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/common.h
@@ -0,0 +1,419 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#include <spdlog/tweakme.h>
+#include <spdlog/details/null_mutex.h>
+
+#include <atomic>
+#include <chrono>
+#include <initializer_list>
+#include <memory>
+#include <exception>
+#include <string>
+#include <type_traits>
+#include <functional>
+#include <cstdio>
+
+#ifdef SPDLOG_USE_STD_FORMAT
+#    include <version>
+#    if __cpp_lib_format >= 202207L
+#        include <format>
+#    else
+#        include <string_view>
+#    endif
+#endif
+
+#ifdef SPDLOG_COMPILED_LIB
+#    undef SPDLOG_HEADER_ONLY
+#    if defined(SPDLOG_SHARED_LIB)
+#        if defined(_WIN32)
+#            ifdef spdlog_EXPORTS
+#                define SPDLOG_API __declspec(dllexport)
+#            else // !spdlog_EXPORTS
+#                define SPDLOG_API __declspec(dllimport)
+#            endif
+#        else // !defined(_WIN32)
+#            define SPDLOG_API __attribute__((visibility("default")))
+#        endif
+#    else // !defined(SPDLOG_SHARED_LIB)
+#        define SPDLOG_API
+#    endif
+#    define SPDLOG_INLINE
+#else // !defined(SPDLOG_COMPILED_LIB)
+#    define SPDLOG_API
+#    define SPDLOG_HEADER_ONLY
+#    define SPDLOG_INLINE inline
+#endif // #ifdef SPDLOG_COMPILED_LIB
+
+#include <spdlog/fmt/fmt.h>
+
+#if !defined(SPDLOG_USE_STD_FORMAT) && FMT_VERSION >= 80000 // backward compatibility with fmt versions older than 8
+#    define SPDLOG_FMT_RUNTIME(format_string) fmt::runtime(format_string)
+#    define SPDLOG_FMT_STRING(format_string) FMT_STRING(format_string)
+#    if defined(SPDLOG_WCHAR_FILENAMES) || defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT)
+#        include <spdlog/fmt/xchar.h>
+#    endif
+#else
+#    define SPDLOG_FMT_RUNTIME(format_string) format_string
+#    define SPDLOG_FMT_STRING(format_string) format_string
+#endif
+
+// visual studio up to 2013 does not support noexcept nor constexpr
+#if defined(_MSC_VER) && (_MSC_VER < 1900)
+#    define SPDLOG_NOEXCEPT _NOEXCEPT
+#    define SPDLOG_CONSTEXPR
+#    define SPDLOG_CONSTEXPR_FUNC inline
+#else
+#    define SPDLOG_NOEXCEPT noexcept
+#    define SPDLOG_CONSTEXPR constexpr
+#    if __cplusplus >= 201402L
+#        define SPDLOG_CONSTEXPR_FUNC constexpr
+#    else
+#        define SPDLOG_CONSTEXPR_FUNC inline
+#    endif
+#endif
+
+#if defined(__GNUC__) || defined(__clang__)
+#    define SPDLOG_DEPRECATED __attribute__((deprecated))
+#elif defined(_MSC_VER)
+#    define SPDLOG_DEPRECATED __declspec(deprecated)
+#else
+#    define SPDLOG_DEPRECATED
+#endif
+
+// disable thread local on msvc 2013
+#ifndef SPDLOG_NO_TLS
+#    if (defined(_MSC_VER) && (_MSC_VER < 1900)) || defined(__cplusplus_winrt)
+#        define SPDLOG_NO_TLS 1
+#    endif
+#endif
+
+#ifndef SPDLOG_FUNCTION
+#    define SPDLOG_FUNCTION static_cast<const char *>(__FUNCTION__)
+#endif
+
+#ifdef SPDLOG_NO_EXCEPTIONS
+#    define SPDLOG_TRY
+#    define SPDLOG_THROW(ex)                                                                                                               \
+        do                                                                                                                                 \
+        {                                                                                                                                  \
+            printf("spdlog fatal error: %s\n", ex.what());                                                                                 \
+            std::abort();                                                                                                                  \
+        } while (0)
+#    define SPDLOG_CATCH_STD
+#else
+#    define SPDLOG_TRY try
+#    define SPDLOG_THROW(ex) throw(ex)
+#    define SPDLOG_CATCH_STD                                                                                                               \
+        catch (const std::exception &) {}
+#endif
+
+namespace spdlog {
+
+class formatter;
+
+namespace sinks {
+class sink;
+}
+
+#if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES)
+using filename_t = std::wstring;
+// allow macro expansion to occur in SPDLOG_FILENAME_T
+#    define SPDLOG_FILENAME_T_INNER(s) L##s
+#    define SPDLOG_FILENAME_T(s) SPDLOG_FILENAME_T_INNER(s)
+#else
+using filename_t = std::string;
+#    define SPDLOG_FILENAME_T(s) s
+#endif
+
+using log_clock = std::chrono::system_clock;
+using sink_ptr = std::shared_ptr<sinks::sink>;
+using sinks_init_list = std::initializer_list<sink_ptr>;
+using err_handler = std::function<void(const std::string &err_msg)>;
+#ifdef SPDLOG_USE_STD_FORMAT
+namespace fmt_lib = std;
+
+using string_view_t = std::string_view;
+using memory_buf_t = std::string;
+
+template<typename... Args>
+#    if __cpp_lib_format >= 202207L
+using format_string_t = std::format_string<Args...>;
+#    else
+using format_string_t = std::string_view;
+#    endif
+
+template<class T, class Char = char>
+struct is_convertible_to_basic_format_string : std::integral_constant<bool, std::is_convertible<T, std::basic_string_view<Char>>::value>
+{};
+
+#    if defined(SPDLOG_WCHAR_FILENAMES) || defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT)
+using wstring_view_t = std::wstring_view;
+using wmemory_buf_t = std::wstring;
+
+template<typename... Args>
+#        if __cpp_lib_format >= 202207L
+using wformat_string_t = std::wformat_string<Args...>;
+#        else
+using wformat_string_t = std::wstring_view;
+#        endif
+#    endif
+#    define SPDLOG_BUF_TO_STRING(x) x
+#else // use fmt lib instead of std::format
+namespace fmt_lib = fmt;
+
+using string_view_t = fmt::basic_string_view<char>;
+using memory_buf_t = fmt::basic_memory_buffer<char, 250>;
+
+template<typename... Args>
+using format_string_t = fmt::format_string<Args...>;
+
+template<class T>
+using remove_cvref_t = typename std::remove_cv<typename std::remove_reference<T>::type>::type;
+
+template<typename Char>
+#    if FMT_VERSION >= 90101
+using fmt_runtime_string = fmt::runtime_format_string<Char>;
+#    else
+using fmt_runtime_string = fmt::basic_runtime<Char>;
+#    endif
+
+// clang doesn't like SFINAE disabled constructor in std::is_convertible<> so have to repeat the condition from basic_format_string here,
+// in addition, fmt::basic_runtime<Char> is only convertible to basic_format_string<Char> but not basic_string_view<Char>
+template<class T, class Char = char>
+struct is_convertible_to_basic_format_string
+    : std::integral_constant<bool,
+          std::is_convertible<T, fmt::basic_string_view<Char>>::value || std::is_same<remove_cvref_t<T>, fmt_runtime_string<Char>>::value>
+{};
+
+#    if defined(SPDLOG_WCHAR_FILENAMES) || defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT)
+using wstring_view_t = fmt::basic_string_view<wchar_t>;
+using wmemory_buf_t = fmt::basic_memory_buffer<wchar_t, 250>;
+
+template<typename... Args>
+using wformat_string_t = fmt::wformat_string<Args...>;
+#    endif
+#    define SPDLOG_BUF_TO_STRING(x) fmt::to_string(x)
+#endif
+
+#ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT
+#    ifndef _WIN32
+#        error SPDLOG_WCHAR_TO_UTF8_SUPPORT only supported on windows
+#    endif // _WIN32
+#endif     // SPDLOG_WCHAR_TO_UTF8_SUPPORT
+
+template<class T>
+struct is_convertible_to_any_format_string : std::integral_constant<bool, is_convertible_to_basic_format_string<T, char>::value ||
+                                                                              is_convertible_to_basic_format_string<T, wchar_t>::value>
+{};
+
+#if defined(SPDLOG_NO_ATOMIC_LEVELS)
+using level_t = details::null_atomic_int;
+#else
+using level_t = std::atomic<int>;
+#endif
+
+#define SPDLOG_LEVEL_TRACE 0
+#define SPDLOG_LEVEL_DEBUG 1
+#define SPDLOG_LEVEL_INFO 2
+#define SPDLOG_LEVEL_WARN 3
+#define SPDLOG_LEVEL_ERROR 4
+#define SPDLOG_LEVEL_CRITICAL 5
+#define SPDLOG_LEVEL_OFF 6
+
+#if !defined(SPDLOG_ACTIVE_LEVEL)
+#    define SPDLOG_ACTIVE_LEVEL SPDLOG_LEVEL_INFO
+#endif
+
+// Log level enum
+namespace level {
+enum level_enum : int
+{
+    trace = SPDLOG_LEVEL_TRACE,
+    debug = SPDLOG_LEVEL_DEBUG,
+    info = SPDLOG_LEVEL_INFO,
+    warn = SPDLOG_LEVEL_WARN,
+    err = SPDLOG_LEVEL_ERROR,
+    critical = SPDLOG_LEVEL_CRITICAL,
+    off = SPDLOG_LEVEL_OFF,
+    n_levels
+};
+
+#define SPDLOG_LEVEL_NAME_TRACE spdlog::string_view_t("trace", 5)
+#define SPDLOG_LEVEL_NAME_DEBUG spdlog::string_view_t("debug", 5)
+#define SPDLOG_LEVEL_NAME_INFO spdlog::string_view_t("info", 4)
+#define SPDLOG_LEVEL_NAME_WARNING spdlog::string_view_t("warning", 7)
+#define SPDLOG_LEVEL_NAME_ERROR spdlog::string_view_t("error", 5)
+#define SPDLOG_LEVEL_NAME_CRITICAL spdlog::string_view_t("critical", 8)
+#define SPDLOG_LEVEL_NAME_OFF spdlog::string_view_t("off", 3)
+
+#if !defined(SPDLOG_LEVEL_NAMES)
+#    define SPDLOG_LEVEL_NAMES                                                                                                             \
+        {                                                                                                                                  \
+            SPDLOG_LEVEL_NAME_TRACE, SPDLOG_LEVEL_NAME_DEBUG, SPDLOG_LEVEL_NAME_INFO, SPDLOG_LEVEL_NAME_WARNING, SPDLOG_LEVEL_NAME_ERROR,  \
+                SPDLOG_LEVEL_NAME_CRITICAL, SPDLOG_LEVEL_NAME_OFF                                                                          \
+        }
+#endif
+
+#if !defined(SPDLOG_SHORT_LEVEL_NAMES)
+
+#    define SPDLOG_SHORT_LEVEL_NAMES                                                                                                       \
+        {                                                                                                                                  \
+            "T", "D", "I", "W", "E", "C", "O"                                                                                              \
+        }
+#endif
+
+SPDLOG_API const string_view_t &to_string_view(spdlog::level::level_enum l) SPDLOG_NOEXCEPT;
+SPDLOG_API const char *to_short_c_str(spdlog::level::level_enum l) SPDLOG_NOEXCEPT;
+SPDLOG_API spdlog::level::level_enum from_str(const std::string &name) SPDLOG_NOEXCEPT;
+
+} // namespace level
+
+//
+// Color mode used by sinks with color support.
+//
+enum class color_mode
+{
+    always,
+    automatic,
+    never
+};
+
+//
+// Pattern time - specific time getting to use for pattern_formatter.
+// local time by default
+//
+enum class pattern_time_type
+{
+    local, // log localtime
+    utc    // log utc
+};
+
+//
+// Log exception
+//
+class SPDLOG_API spdlog_ex : public std::exception
+{
+public:
+    explicit spdlog_ex(std::string msg);
+    spdlog_ex(const std::string &msg, int last_errno);
+    const char *what() const SPDLOG_NOEXCEPT override;
+
+private:
+    std::string msg_;
+};
+
+[[noreturn]] SPDLOG_API void throw_spdlog_ex(const std::string &msg, int last_errno);
+[[noreturn]] SPDLOG_API void throw_spdlog_ex(std::string msg);
+
+struct source_loc
+{
+    SPDLOG_CONSTEXPR source_loc() = default;
+    SPDLOG_CONSTEXPR source_loc(const char *filename_in, int line_in, const char *funcname_in)
+        : filename{filename_in}
+        , line{line_in}
+        , funcname{funcname_in}
+    {}
+
+    SPDLOG_CONSTEXPR bool empty() const SPDLOG_NOEXCEPT
+    {
+        return line == 0;
+    }
+    const char *filename{nullptr};
+    int line{0};
+    const char *funcname{nullptr};
+};
+
+struct file_event_handlers
+{
+    file_event_handlers()
+        : before_open(nullptr)
+        , after_open(nullptr)
+        , before_close(nullptr)
+        , after_close(nullptr)
+    {}
+
+    std::function<void(const filename_t &filename)> before_open;
+    std::function<void(const filename_t &filename, std::FILE *file_stream)> after_open;
+    std::function<void(const filename_t &filename, std::FILE *file_stream)> before_close;
+    std::function<void(const filename_t &filename)> after_close;
+};
+
+namespace details {
+
+// to_string_view
+
+SPDLOG_CONSTEXPR_FUNC spdlog::string_view_t to_string_view(const memory_buf_t &buf) SPDLOG_NOEXCEPT
+{
+    return spdlog::string_view_t{buf.data(), buf.size()};
+}
+
+SPDLOG_CONSTEXPR_FUNC spdlog::string_view_t to_string_view(spdlog::string_view_t str) SPDLOG_NOEXCEPT
+{
+    return str;
+}
+
+#if defined(SPDLOG_WCHAR_FILENAMES) || defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT)
+SPDLOG_CONSTEXPR_FUNC spdlog::wstring_view_t to_string_view(const wmemory_buf_t &buf) SPDLOG_NOEXCEPT
+{
+    return spdlog::wstring_view_t{buf.data(), buf.size()};
+}
+
+SPDLOG_CONSTEXPR_FUNC spdlog::wstring_view_t to_string_view(spdlog::wstring_view_t str) SPDLOG_NOEXCEPT
+{
+    return str;
+}
+#endif
+
+#ifndef SPDLOG_USE_STD_FORMAT
+template<typename T, typename... Args>
+inline fmt::basic_string_view<T> to_string_view(fmt::basic_format_string<T, Args...> fmt)
+{
+    return fmt;
+}
+#elif __cpp_lib_format >= 202207L
+template<typename T, typename... Args>
+SPDLOG_CONSTEXPR_FUNC std::basic_string_view<T> to_string_view(std::basic_format_string<T, Args...> fmt) SPDLOG_NOEXCEPT
+{
+    return fmt.get();
+}
+#endif
+
+// make_unique support for pre c++14
+
+#if __cplusplus >= 201402L // C++14 and beyond
+using std::enable_if_t;
+using std::make_unique;
+#else
+template<bool B, class T = void>
+using enable_if_t = typename std::enable_if<B, T>::type;
+
+template<typename T, typename... Args>
+std::unique_ptr<T> make_unique(Args &&...args)
+{
+    static_assert(!std::is_array<T>::value, "arrays not supported");
+    return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
+}
+#endif
+
+// to avoid useless casts (see https://github.com/nlohmann/json/issues/2893#issuecomment-889152324)
+template<typename T, typename U, enable_if_t<!std::is_same<T, U>::value, int> = 0>
+constexpr T conditional_static_cast(U value)
+{
+    return static_cast<T>(value);
+}
+
+template<typename T, typename U, enable_if_t<std::is_same<T, U>::value, int> = 0>
+constexpr T conditional_static_cast(U value)
+{
+    return value;
+}
+
+} // namespace details
+} // namespace spdlog
+
+#ifdef SPDLOG_HEADER_ONLY
+#    include "common-inl.h"
+#endif
diff --git a/3rdparty/spdlog/src/include/spdlog/details/backtracer-inl.h b/3rdparty/spdlog/src/include/spdlog/details/backtracer-inl.h
new file mode 100644
index 00000000..40eba408
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/details/backtracer-inl.h
@@ -0,0 +1,75 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#ifndef SPDLOG_HEADER_ONLY
+#    include <spdlog/details/backtracer.h>
+#endif
+namespace spdlog {
+namespace details {
+SPDLOG_INLINE backtracer::backtracer(const backtracer &other)
+{
+    std::lock_guard<std::mutex> lock(other.mutex_);
+    enabled_ = other.enabled();
+    messages_ = other.messages_;
+}
+
+SPDLOG_INLINE backtracer::backtracer(backtracer &&other) SPDLOG_NOEXCEPT
+{
+    std::lock_guard<std::mutex> lock(other.mutex_);
+    enabled_ = other.enabled();
+    messages_ = std::move(other.messages_);
+}
+
+SPDLOG_INLINE backtracer &backtracer::operator=(backtracer other)
+{
+    std::lock_guard<std::mutex> lock(mutex_);
+    enabled_ = other.enabled();
+    messages_ = std::move(other.messages_);
+    return *this;
+}
+
+SPDLOG_INLINE void backtracer::enable(size_t size)
+{
+    std::lock_guard<std::mutex> lock{mutex_};
+    enabled_.store(true, std::memory_order_relaxed);
+    messages_ = circular_q<log_msg_buffer>{size};
+}
+
+SPDLOG_INLINE void backtracer::disable()
+{
+    std::lock_guard<std::mutex> lock{mutex_};
+    enabled_.store(false, std::memory_order_relaxed);
+}
+
+SPDLOG_INLINE bool backtracer::enabled() const
+{
+    return enabled_.load(std::memory_order_relaxed);
+}
+
+SPDLOG_INLINE void backtracer::push_back(const log_msg &msg)
+{
+    std::lock_guard<std::mutex> lock{mutex_};
+    messages_.push_back(log_msg_buffer{msg});
+}
+
+SPDLOG_INLINE bool backtracer::empty() const
+{
+    std::lock_guard<std::mutex> lock{mutex_};
+    return messages_.empty();
+}
+
+// pop all items in the q and apply the given fun on each of them.
+SPDLOG_INLINE void backtracer::foreach_pop(std::function<void(const details::log_msg &)> fun)
+{
+    std::lock_guard<std::mutex> lock{mutex_};
+    while (!messages_.empty())
+    {
+        auto &front_msg = messages_.front();
+        fun(front_msg);
+        messages_.pop_front();
+    }
+}
+} // namespace details
+} // namespace spdlog
diff --git a/3rdparty/spdlog/src/include/spdlog/details/backtracer.h b/3rdparty/spdlog/src/include/spdlog/details/backtracer.h
new file mode 100644
index 00000000..13785d85
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/details/backtracer.h
@@ -0,0 +1,46 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#include <spdlog/details/log_msg_buffer.h>
+#include <spdlog/details/circular_q.h>
+
+#include <atomic>
+#include <mutex>
+#include <functional>
+
+// Store log messages in circular buffer.
+// Useful for storing debug data in case of error/warning happens.
+
+namespace spdlog {
+namespace details {
+class SPDLOG_API backtracer
+{
+    mutable std::mutex mutex_;
+    std::atomic<bool> enabled_{false};
+    circular_q<log_msg_buffer> messages_;
+
+public:
+    backtracer() = default;
+    backtracer(const backtracer &other);
+
+    backtracer(backtracer &&other) SPDLOG_NOEXCEPT;
+    backtracer &operator=(backtracer other);
+
+    void enable(size_t size);
+    void disable();
+    bool enabled() const;
+    void push_back(const log_msg &msg);
+    bool empty() const;
+
+    // pop all items in the q and apply the given fun on each of them.
+    void foreach_pop(std::function<void(const details::log_msg &)> fun);
+};
+
+} // namespace details
+} // namespace spdlog
+
+#ifdef SPDLOG_HEADER_ONLY
+#    include "backtracer-inl.h"
+#endif
diff --git a/3rdparty/spdlog/src/include/spdlog/details/circular_q.h b/3rdparty/spdlog/src/include/spdlog/details/circular_q.h
new file mode 100644
index 00000000..e4fd5fd4
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/details/circular_q.h
@@ -0,0 +1,146 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+// circular q view of std::vector.
+#pragma once
+
+#include <vector>
+#include <cassert>
+
+namespace spdlog {
+namespace details {
+template<typename T>
+class circular_q
+{
+    size_t max_items_ = 0;
+    typename std::vector<T>::size_type head_ = 0;
+    typename std::vector<T>::size_type tail_ = 0;
+    size_t overrun_counter_ = 0;
+    std::vector<T> v_;
+
+public:
+    using value_type = T;
+
+    // empty ctor - create a disabled queue with no elements allocated at all
+    circular_q() = default;
+
+    explicit circular_q(size_t max_items)
+        : max_items_(max_items + 1) // one item is reserved as marker for full q
+        , v_(max_items_)
+    {}
+
+    circular_q(const circular_q &) = default;
+    circular_q &operator=(const circular_q &) = default;
+
+    // move cannot be default,
+    // since we need to reset head_, tail_, etc to zero in the moved object
+    circular_q(circular_q &&other) SPDLOG_NOEXCEPT
+    {
+        copy_moveable(std::move(other));
+    }
+
+    circular_q &operator=(circular_q &&other) SPDLOG_NOEXCEPT
+    {
+        copy_moveable(std::move(other));
+        return *this;
+    }
+
+    // push back, overrun (oldest) item if no room left
+    void push_back(T &&item)
+    {
+        if (max_items_ > 0)
+        {
+            v_[tail_] = std::move(item);
+            tail_ = (tail_ + 1) % max_items_;
+
+            if (tail_ == head_) // overrun last item if full
+            {
+                head_ = (head_ + 1) % max_items_;
+                ++overrun_counter_;
+            }
+        }
+    }
+
+    // Return reference to the front item.
+    // If there are no elements in the container, the behavior is undefined.
+    const T &front() const
+    {
+        return v_[head_];
+    }
+
+    T &front()
+    {
+        return v_[head_];
+    }
+
+    // Return number of elements actually stored
+    size_t size() const
+    {
+        if (tail_ >= head_)
+        {
+            return tail_ - head_;
+        }
+        else
+        {
+            return max_items_ - (head_ - tail_);
+        }
+    }
+
+    // Return const reference to item by index.
+    // If index is out of range 0…size()-1, the behavior is undefined.
+    const T &at(size_t i) const
+    {
+        assert(i < size());
+        return v_[(head_ + i) % max_items_];
+    }
+
+    // Pop item from front.
+    // If there are no elements in the container, the behavior is undefined.
+    void pop_front()
+    {
+        head_ = (head_ + 1) % max_items_;
+    }
+
+    bool empty() const
+    {
+        return tail_ == head_;
+    }
+
+    bool full() const
+    {
+        // head is ahead of the tail by 1
+        if (max_items_ > 0)
+        {
+            return ((tail_ + 1) % max_items_) == head_;
+        }
+        return false;
+    }
+
+    size_t overrun_counter() const
+    {
+        return overrun_counter_;
+    }
+
+    void reset_overrun_counter()
+    {
+        overrun_counter_ = 0;
+    }
+
+private:
+    // copy from other&& and reset it to disabled state
+    void copy_moveable(circular_q &&other) SPDLOG_NOEXCEPT
+    {
+        max_items_ = other.max_items_;
+        head_ = other.head_;
+        tail_ = other.tail_;
+        overrun_counter_ = other.overrun_counter_;
+        v_ = std::move(other.v_);
+
+        // put &&other in disabled, but valid state
+        other.max_items_ = 0;
+        other.head_ = other.tail_ = 0;
+        other.overrun_counter_ = 0;
+    }
+};
+} // namespace details
+} // namespace spdlog
diff --git a/3rdparty/spdlog/src/include/spdlog/details/console_globals.h b/3rdparty/spdlog/src/include/spdlog/details/console_globals.h
new file mode 100644
index 00000000..665201dd
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/details/console_globals.h
@@ -0,0 +1,32 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#include <spdlog/details/null_mutex.h>
+#include <mutex>
+
+namespace spdlog {
+namespace details {
+
+struct console_mutex
+{
+    using mutex_t = std::mutex;
+    static mutex_t &mutex()
+    {
+        static mutex_t s_mutex;
+        return s_mutex;
+    }
+};
+
+struct console_nullmutex
+{
+    using mutex_t = null_mutex;
+    static mutex_t &mutex()
+    {
+        static mutex_t s_mutex;
+        return s_mutex;
+    }
+};
+} // namespace details
+} // namespace spdlog
diff --git a/3rdparty/spdlog/src/include/spdlog/details/file_helper-inl.h b/3rdparty/spdlog/src/include/spdlog/details/file_helper-inl.h
new file mode 100644
index 00000000..74c89a87
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/details/file_helper-inl.h
@@ -0,0 +1,180 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#ifndef SPDLOG_HEADER_ONLY
+#    include <spdlog/details/file_helper.h>
+#endif
+
+#include <spdlog/details/os.h>
+#include <spdlog/common.h>
+
+#include <cerrno>
+#include <chrono>
+#include <cstdio>
+#include <string>
+#include <thread>
+#include <tuple>
+
+namespace spdlog {
+namespace details {
+
+SPDLOG_INLINE file_helper::file_helper(const file_event_handlers &event_handlers)
+    : event_handlers_(event_handlers)
+{}
+
+SPDLOG_INLINE file_helper::~file_helper()
+{
+    close();
+}
+
+SPDLOG_INLINE void file_helper::open(const filename_t &fname, bool truncate)
+{
+    close();
+    filename_ = fname;
+
+    auto *mode = SPDLOG_FILENAME_T("ab");
+    auto *trunc_mode = SPDLOG_FILENAME_T("wb");
+
+    if (event_handlers_.before_open)
+    {
+        event_handlers_.before_open(filename_);
+    }
+    for (int tries = 0; tries < open_tries_; ++tries)
+    {
+        // create containing folder if not exists already.
+        os::create_dir(os::dir_name(fname));
+        if (truncate)
+        {
+            // Truncate by opening-and-closing a tmp file in "wb" mode, always
+            // opening the actual log-we-write-to in "ab" mode, since that
+            // interacts more politely with eternal processes that might
+            // rotate/truncate the file underneath us.
+            std::FILE *tmp;
+            if (os::fopen_s(&tmp, fname, trunc_mode))
+            {
+                continue;
+            }
+            std::fclose(tmp);
+        }
+        if (!os::fopen_s(&fd_, fname, mode))
+        {
+            if (event_handlers_.after_open)
+            {
+                event_handlers_.after_open(filename_, fd_);
+            }
+            return;
+        }
+
+        details::os::sleep_for_millis(open_interval_);
+    }
+
+    throw_spdlog_ex("Failed opening file " + os::filename_to_str(filename_) + " for writing", errno);
+}
+
+SPDLOG_INLINE void file_helper::reopen(bool truncate)
+{
+    if (filename_.empty())
+    {
+        throw_spdlog_ex("Failed re opening file - was not opened before");
+    }
+    this->open(filename_, truncate);
+}
+
+SPDLOG_INLINE void file_helper::flush()
+{
+    if (std::fflush(fd_) != 0)
+    {
+        throw_spdlog_ex("Failed flush to file " + os::filename_to_str(filename_), errno);
+    }
+}
+
+SPDLOG_INLINE void file_helper::sync()
+{
+    if (!os::fsync(fd_))
+    {
+        throw_spdlog_ex("Failed to fsync file " + os::filename_to_str(filename_), errno);
+    }
+}
+
+SPDLOG_INLINE void file_helper::close()
+{
+    if (fd_ != nullptr)
+    {
+        if (event_handlers_.before_close)
+        {
+            event_handlers_.before_close(filename_, fd_);
+        }
+
+        std::fclose(fd_);
+        fd_ = nullptr;
+
+        if (event_handlers_.after_close)
+        {
+            event_handlers_.after_close(filename_);
+        }
+    }
+}
+
+SPDLOG_INLINE void file_helper::write(const memory_buf_t &buf)
+{
+    size_t msg_size = buf.size();
+    auto data = buf.data();
+    if (std::fwrite(data, 1, msg_size, fd_) != msg_size)
+    {
+        throw_spdlog_ex("Failed writing to file " + os::filename_to_str(filename_), errno);
+    }
+}
+
+SPDLOG_INLINE size_t file_helper::size() const
+{
+    if (fd_ == nullptr)
+    {
+        throw_spdlog_ex("Cannot use size() on closed file " + os::filename_to_str(filename_));
+    }
+    return os::filesize(fd_);
+}
+
+SPDLOG_INLINE const filename_t &file_helper::filename() const
+{
+    return filename_;
+}
+
+//
+// return file path and its extension:
+//
+// "mylog.txt" => ("mylog", ".txt")
+// "mylog" => ("mylog", "")
+// "mylog." => ("mylog.", "")
+// "/dir1/dir2/mylog.txt" => ("/dir1/dir2/mylog", ".txt")
+//
+// the starting dot in filenames is ignored (hidden files):
+//
+// ".mylog" => (".mylog". "")
+// "my_folder/.mylog" => ("my_folder/.mylog", "")
+// "my_folder/.mylog.txt" => ("my_folder/.mylog", ".txt")
+SPDLOG_INLINE std::tuple<filename_t, filename_t> file_helper::split_by_extension(const filename_t &fname)
+{
+    auto ext_index = fname.rfind('.');
+
+    // no valid extension found - return whole path and empty string as
+    // extension
+    if (ext_index == filename_t::npos || ext_index == 0 || ext_index == fname.size() - 1)
+    {
+        return std::make_tuple(fname, filename_t());
+    }
+
+    // treat cases like "/etc/rc.d/somelogfile or "/abc/.hiddenfile"
+    auto folder_index = fname.find_last_of(details::os::folder_seps_filename);
+    if (folder_index != filename_t::npos && folder_index >= ext_index - 1)
+    {
+        return std::make_tuple(fname, filename_t());
+    }
+
+    // finally - return a valid base and extension tuple
+    return std::make_tuple(fname.substr(0, ext_index), fname.substr(ext_index));
+}
+
+} // namespace details
+} // namespace spdlog
diff --git a/3rdparty/spdlog/src/include/spdlog/details/file_helper.h b/3rdparty/spdlog/src/include/spdlog/details/file_helper.h
new file mode 100644
index 00000000..f42a5eb1
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/details/file_helper.h
@@ -0,0 +1,62 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#include <spdlog/common.h>
+#include <tuple>
+
+namespace spdlog {
+namespace details {
+
+// Helper class for file sinks.
+// When failing to open a file, retry several times(5) with a delay interval(10 ms).
+// Throw spdlog_ex exception on errors.
+
+class SPDLOG_API file_helper
+{
+public:
+    file_helper() = default;
+    explicit file_helper(const file_event_handlers &event_handlers);
+
+    file_helper(const file_helper &) = delete;
+    file_helper &operator=(const file_helper &) = delete;
+    ~file_helper();
+
+    void open(const filename_t &fname, bool truncate = false);
+    void reopen(bool truncate);
+    void flush();
+    void sync();
+    void close();
+    void write(const memory_buf_t &buf);
+    size_t size() const;
+    const filename_t &filename() const;
+
+    //
+    // return file path and its extension:
+    //
+    // "mylog.txt" => ("mylog", ".txt")
+    // "mylog" => ("mylog", "")
+    // "mylog." => ("mylog.", "")
+    // "/dir1/dir2/mylog.txt" => ("/dir1/dir2/mylog", ".txt")
+    //
+    // the starting dot in filenames is ignored (hidden files):
+    //
+    // ".mylog" => (".mylog". "")
+    // "my_folder/.mylog" => ("my_folder/.mylog", "")
+    // "my_folder/.mylog.txt" => ("my_folder/.mylog", ".txt")
+    static std::tuple<filename_t, filename_t> split_by_extension(const filename_t &fname);
+
+private:
+    const int open_tries_ = 5;
+    const unsigned int open_interval_ = 10;
+    std::FILE *fd_{nullptr};
+    filename_t filename_;
+    file_event_handlers event_handlers_;
+};
+} // namespace details
+} // namespace spdlog
+
+#ifdef SPDLOG_HEADER_ONLY
+#    include "file_helper-inl.h"
+#endif
diff --git a/3rdparty/spdlog/src/include/spdlog/details/fmt_helper.h b/3rdparty/spdlog/src/include/spdlog/details/fmt_helper.h
new file mode 100644
index 00000000..d9867180
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/details/fmt_helper.h
@@ -0,0 +1,164 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+#pragma once
+
+#include <chrono>
+#include <type_traits>
+#include <iterator>
+#include <spdlog/fmt/fmt.h>
+#include <spdlog/common.h>
+
+#ifdef SPDLOG_USE_STD_FORMAT
+#    include <charconv>
+#    include <limits>
+#endif
+
+// Some fmt helpers to efficiently format and pad ints and strings
+namespace spdlog {
+namespace details {
+namespace fmt_helper {
+
+inline void append_string_view(spdlog::string_view_t view, memory_buf_t &dest)
+{
+    auto *buf_ptr = view.data();
+    dest.append(buf_ptr, buf_ptr + view.size());
+}
+
+#ifdef SPDLOG_USE_STD_FORMAT
+template<typename T>
+inline void append_int(T n, memory_buf_t &dest)
+{
+    // Buffer should be large enough to hold all digits (digits10 + 1) and a sign
+    SPDLOG_CONSTEXPR const auto BUF_SIZE = std::numeric_limits<T>::digits10 + 2;
+    char buf[BUF_SIZE];
+
+    auto [ptr, ec] = std::to_chars(buf, buf + BUF_SIZE, n, 10);
+    if (ec == std::errc())
+    {
+        dest.append(buf, ptr);
+    }
+    else
+    {
+        throw_spdlog_ex("Failed to format int", static_cast<int>(ec));
+    }
+}
+#else
+template<typename T>
+inline void append_int(T n, memory_buf_t &dest)
+{
+    fmt::format_int i(n);
+    dest.append(i.data(), i.data() + i.size());
+}
+#endif
+
+template<typename T>
+SPDLOG_CONSTEXPR_FUNC unsigned int count_digits_fallback(T n)
+{
+    // taken from fmt: https://github.com/fmtlib/fmt/blob/8.0.1/include/fmt/format.h#L899-L912
+    unsigned int count = 1;
+    for (;;)
+    {
+        // Integer division is slow so do it for a group of four digits instead
+        // of for every digit. The idea comes from the talk by Alexandrescu
+        // "Three Optimization Tips for C++". See speed-test for a comparison.
+        if (n < 10)
+            return count;
+        if (n < 100)
+            return count + 1;
+        if (n < 1000)
+            return count + 2;
+        if (n < 10000)
+            return count + 3;
+        n /= 10000u;
+        count += 4;
+    }
+}
+
+template<typename T>
+inline unsigned int count_digits(T n)
+{
+    using count_type = typename std::conditional<(sizeof(T) > sizeof(uint32_t)), uint64_t, uint32_t>::type;
+#ifdef SPDLOG_USE_STD_FORMAT
+    return count_digits_fallback(static_cast<count_type>(n));
+#else
+    return static_cast<unsigned int>(fmt::
+// fmt 7.0.0 renamed the internal namespace to detail.
+// See: https://github.com/fmtlib/fmt/issues/1538
+#    if FMT_VERSION < 70000
+            internal
+#    else
+            detail
+#    endif
+        ::count_digits(static_cast<count_type>(n)));
+#endif
+}
+
+inline void pad2(int n, memory_buf_t &dest)
+{
+    if (n >= 0 && n < 100) // 0-99
+    {
+        dest.push_back(static_cast<char>('0' + n / 10));
+        dest.push_back(static_cast<char>('0' + n % 10));
+    }
+    else // unlikely, but just in case, let fmt deal with it
+    {
+        fmt_lib::format_to(std::back_inserter(dest), SPDLOG_FMT_STRING("{:02}"), n);
+    }
+}
+
+template<typename T>
+inline void pad_uint(T n, unsigned int width, memory_buf_t &dest)
+{
+    static_assert(std::is_unsigned<T>::value, "pad_uint must get unsigned T");
+    for (auto digits = count_digits(n); digits < width; digits++)
+    {
+        dest.push_back('0');
+    }
+    append_int(n, dest);
+}
+
+template<typename T>
+inline void pad3(T n, memory_buf_t &dest)
+{
+    static_assert(std::is_unsigned<T>::value, "pad3 must get unsigned T");
+    if (n < 1000)
+    {
+        dest.push_back(static_cast<char>(n / 100 + '0'));
+        n = n % 100;
+        dest.push_back(static_cast<char>((n / 10) + '0'));
+        dest.push_back(static_cast<char>((n % 10) + '0'));
+    }
+    else
+    {
+        append_int(n, dest);
+    }
+}
+
+template<typename T>
+inline void pad6(T n, memory_buf_t &dest)
+{
+    pad_uint(n, 6, dest);
+}
+
+template<typename T>
+inline void pad9(T n, memory_buf_t &dest)
+{
+    pad_uint(n, 9, dest);
+}
+
+// return fraction of a second of the given time_point.
+// e.g.
+// fraction<std::milliseconds>(tp) -> will return the millis part of the second
+template<typename ToDuration>
+inline ToDuration time_fraction(log_clock::time_point tp)
+{
+    using std::chrono::duration_cast;
+    using std::chrono::seconds;
+    auto duration = tp.time_since_epoch();
+    auto secs = duration_cast<seconds>(duration);
+    return duration_cast<ToDuration>(duration) - duration_cast<ToDuration>(secs);
+}
+
+} // namespace fmt_helper
+} // namespace details
+} // namespace spdlog
diff --git a/3rdparty/spdlog/src/include/spdlog/details/log_msg-inl.h b/3rdparty/spdlog/src/include/spdlog/details/log_msg-inl.h
new file mode 100644
index 00000000..c6e8a7e0
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/details/log_msg-inl.h
@@ -0,0 +1,37 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#ifndef SPDLOG_HEADER_ONLY
+#    include <spdlog/details/log_msg.h>
+#endif
+
+#include <spdlog/details/os.h>
+
+namespace spdlog {
+namespace details {
+
+SPDLOG_INLINE log_msg::log_msg(spdlog::log_clock::time_point log_time, spdlog::source_loc loc, string_view_t a_logger_name,
+    spdlog::level::level_enum lvl, spdlog::string_view_t msg)
+    : logger_name(a_logger_name)
+    , level(lvl)
+    , time(log_time)
+#ifndef SPDLOG_NO_THREAD_ID
+    , thread_id(os::thread_id())
+#endif
+    , source(loc)
+    , payload(msg)
+{}
+
+SPDLOG_INLINE log_msg::log_msg(
+    spdlog::source_loc loc, string_view_t a_logger_name, spdlog::level::level_enum lvl, spdlog::string_view_t msg)
+    : log_msg(os::now(), loc, a_logger_name, lvl, msg)
+{}
+
+SPDLOG_INLINE log_msg::log_msg(string_view_t a_logger_name, spdlog::level::level_enum lvl, spdlog::string_view_t msg)
+    : log_msg(os::now(), source_loc{}, a_logger_name, lvl, msg)
+{}
+
+} // namespace details
+} // namespace spdlog
diff --git a/3rdparty/spdlog/src/include/spdlog/details/log_msg.h b/3rdparty/spdlog/src/include/spdlog/details/log_msg.h
new file mode 100644
index 00000000..fed51abd
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/details/log_msg.h
@@ -0,0 +1,37 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#include <spdlog/common.h>
+#include <string>
+
+namespace spdlog {
+namespace details {
+struct SPDLOG_API log_msg
+{
+    log_msg() = default;
+    log_msg(log_clock::time_point log_time, source_loc loc, string_view_t logger_name, level::level_enum lvl, string_view_t msg);
+    log_msg(source_loc loc, string_view_t logger_name, level::level_enum lvl, string_view_t msg);
+    log_msg(string_view_t logger_name, level::level_enum lvl, string_view_t msg);
+    log_msg(const log_msg &other) = default;
+    log_msg &operator=(const log_msg &other) = default;
+
+    string_view_t logger_name;
+    level::level_enum level{level::off};
+    log_clock::time_point time;
+    size_t thread_id{0};
+
+    // wrapping the formatted text with color (updated by pattern_formatter).
+    mutable size_t color_range_start{0};
+    mutable size_t color_range_end{0};
+
+    source_loc source;
+    string_view_t payload;
+};
+} // namespace details
+} // namespace spdlog
+
+#ifdef SPDLOG_HEADER_ONLY
+#    include "log_msg-inl.h"
+#endif
diff --git a/3rdparty/spdlog/src/include/spdlog/details/log_msg_buffer-inl.h b/3rdparty/spdlog/src/include/spdlog/details/log_msg_buffer-inl.h
new file mode 100644
index 00000000..84d83dc2
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/details/log_msg_buffer-inl.h
@@ -0,0 +1,58 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#ifndef SPDLOG_HEADER_ONLY
+#    include <spdlog/details/log_msg_buffer.h>
+#endif
+
+namespace spdlog {
+namespace details {
+
+SPDLOG_INLINE log_msg_buffer::log_msg_buffer(const log_msg &orig_msg)
+    : log_msg{orig_msg}
+{
+    buffer.append(logger_name.begin(), logger_name.end());
+    buffer.append(payload.begin(), payload.end());
+    update_string_views();
+}
+
+SPDLOG_INLINE log_msg_buffer::log_msg_buffer(const log_msg_buffer &other)
+    : log_msg{other}
+{
+    buffer.append(logger_name.begin(), logger_name.end());
+    buffer.append(payload.begin(), payload.end());
+    update_string_views();
+}
+
+SPDLOG_INLINE log_msg_buffer::log_msg_buffer(log_msg_buffer &&other) SPDLOG_NOEXCEPT : log_msg{other}, buffer{std::move(other.buffer)}
+{
+    update_string_views();
+}
+
+SPDLOG_INLINE log_msg_buffer &log_msg_buffer::operator=(const log_msg_buffer &other)
+{
+    log_msg::operator=(other);
+    buffer.clear();
+    buffer.append(other.buffer.data(), other.buffer.data() + other.buffer.size());
+    update_string_views();
+    return *this;
+}
+
+SPDLOG_INLINE log_msg_buffer &log_msg_buffer::operator=(log_msg_buffer &&other) SPDLOG_NOEXCEPT
+{
+    log_msg::operator=(other);
+    buffer = std::move(other.buffer);
+    update_string_views();
+    return *this;
+}
+
+SPDLOG_INLINE void log_msg_buffer::update_string_views()
+{
+    logger_name = string_view_t{buffer.data(), logger_name.size()};
+    payload = string_view_t{buffer.data() + logger_name.size(), payload.size()};
+}
+
+} // namespace details
+} // namespace spdlog
diff --git a/3rdparty/spdlog/src/include/spdlog/details/log_msg_buffer.h b/3rdparty/spdlog/src/include/spdlog/details/log_msg_buffer.h
new file mode 100644
index 00000000..81055065
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/details/log_msg_buffer.h
@@ -0,0 +1,33 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#include <spdlog/details/log_msg.h>
+
+namespace spdlog {
+namespace details {
+
+// Extend log_msg with internal buffer to store its payload.
+// This is needed since log_msg holds string_views that points to stack data.
+
+class SPDLOG_API log_msg_buffer : public log_msg
+{
+    memory_buf_t buffer;
+    void update_string_views();
+
+public:
+    log_msg_buffer() = default;
+    explicit log_msg_buffer(const log_msg &orig_msg);
+    log_msg_buffer(const log_msg_buffer &other);
+    log_msg_buffer(log_msg_buffer &&other) SPDLOG_NOEXCEPT;
+    log_msg_buffer &operator=(const log_msg_buffer &other);
+    log_msg_buffer &operator=(log_msg_buffer &&other) SPDLOG_NOEXCEPT;
+};
+
+} // namespace details
+} // namespace spdlog
+
+#ifdef SPDLOG_HEADER_ONLY
+#    include "log_msg_buffer-inl.h"
+#endif
diff --git a/3rdparty/spdlog/src/include/spdlog/details/mpmc_blocking_q.h b/3rdparty/spdlog/src/include/spdlog/details/mpmc_blocking_q.h
new file mode 100644
index 00000000..101ea8c0
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/details/mpmc_blocking_q.h
@@ -0,0 +1,154 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+// multi producer-multi consumer blocking queue.
+// enqueue(..) - will block until room found to put the new message.
+// enqueue_nowait(..) - will return immediately with false if no room left in
+// the queue.
+// dequeue_for(..) - will block until the queue is not empty or timeout have
+// passed.
+
+#include <spdlog/details/circular_q.h>
+
+#include <condition_variable>
+#include <mutex>
+
+namespace spdlog {
+namespace details {
+
+template<typename T>
+class mpmc_blocking_queue
+{
+public:
+    using item_type = T;
+    explicit mpmc_blocking_queue(size_t max_items)
+        : q_(max_items)
+    {}
+
+#ifndef __MINGW32__
+    // try to enqueue and block if no room left
+    void enqueue(T &&item)
+    {
+        {
+            std::unique_lock<std::mutex> lock(queue_mutex_);
+            pop_cv_.wait(lock, [this] { return !this->q_.full(); });
+            q_.push_back(std::move(item));
+        }
+        push_cv_.notify_one();
+    }
+
+    // enqueue immediately. overrun oldest message in the queue if no room left.
+    void enqueue_nowait(T &&item)
+    {
+        {
+            std::unique_lock<std::mutex> lock(queue_mutex_);
+            q_.push_back(std::move(item));
+        }
+        push_cv_.notify_one();
+    }
+
+    // dequeue with a timeout.
+    // Return true, if succeeded dequeue item, false otherwise
+    bool dequeue_for(T &popped_item, std::chrono::milliseconds wait_duration)
+    {
+        {
+            std::unique_lock<std::mutex> lock(queue_mutex_);
+            if (!push_cv_.wait_for(lock, wait_duration, [this] { return !this->q_.empty(); }))
+            {
+                return false;
+            }
+            popped_item = std::move(q_.front());
+            q_.pop_front();
+        }
+        pop_cv_.notify_one();
+        return true;
+    }
+
+    // blocking dequeue without a timeout.
+    void dequeue(T &popped_item)
+    {
+        {
+            std::unique_lock<std::mutex> lock(queue_mutex_);
+            push_cv_.wait(lock, [this] { return !this->q_.empty(); });
+            popped_item = std::move(q_.front());
+            q_.pop_front();
+        }
+        pop_cv_.notify_one();
+    }
+
+#else
+    // apparently mingw deadlocks if the mutex is released before cv.notify_one(),
+    // so release the mutex at the very end each function.
+
+    // try to enqueue and block if no room left
+    void enqueue(T &&item)
+    {
+        std::unique_lock<std::mutex> lock(queue_mutex_);
+        pop_cv_.wait(lock, [this] { return !this->q_.full(); });
+        q_.push_back(std::move(item));
+        push_cv_.notify_one();
+    }
+
+    // enqueue immediately. overrun oldest message in the queue if no room left.
+    void enqueue_nowait(T &&item)
+    {
+        std::unique_lock<std::mutex> lock(queue_mutex_);
+        q_.push_back(std::move(item));
+        push_cv_.notify_one();
+    }
+
+    // dequeue with a timeout.
+    // Return true, if succeeded dequeue item, false otherwise
+    bool dequeue_for(T &popped_item, std::chrono::milliseconds wait_duration)
+    {
+        std::unique_lock<std::mutex> lock(queue_mutex_);
+        if (!push_cv_.wait_for(lock, wait_duration, [this] { return !this->q_.empty(); }))
+        {
+            return false;
+        }
+        popped_item = std::move(q_.front());
+        q_.pop_front();
+        pop_cv_.notify_one();
+        return true;
+    }
+
+    // blocking dequeue without a timeout.
+    void dequeue(T &popped_item)
+    {
+        std::unique_lock<std::mutex> lock(queue_mutex_);
+        push_cv_.wait(lock, [this] { return !this->q_.empty(); });
+        popped_item = std::move(q_.front());
+        q_.pop_front();
+        pop_cv_.notify_one();
+    }
+
+#endif
+
+    size_t overrun_counter()
+    {
+        std::unique_lock<std::mutex> lock(queue_mutex_);
+        return q_.overrun_counter();
+    }
+
+    size_t size()
+    {
+        std::unique_lock<std::mutex> lock(queue_mutex_);
+        return q_.size();
+    }
+
+    void reset_overrun_counter()
+    {
+        std::unique_lock<std::mutex> lock(queue_mutex_);
+        q_.reset_overrun_counter();
+    }
+
+private:
+    std::mutex queue_mutex_;
+    std::condition_variable push_cv_;
+    std::condition_variable pop_cv_;
+    spdlog::details::circular_q<T> q_;
+};
+} // namespace details
+} // namespace spdlog
diff --git a/3rdparty/spdlog/src/include/spdlog/details/null_mutex.h b/3rdparty/spdlog/src/include/spdlog/details/null_mutex.h
new file mode 100644
index 00000000..6550a7bf
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/details/null_mutex.h
@@ -0,0 +1,45 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#include <atomic>
+#include <utility>
+// null, no cost dummy "mutex" and dummy "atomic" int
+
+namespace spdlog {
+namespace details {
+struct null_mutex
+{
+    void lock() const {}
+    void unlock() const {}
+};
+
+struct null_atomic_int
+{
+    int value;
+    null_atomic_int() = default;
+
+    explicit null_atomic_int(int new_value)
+        : value(new_value)
+    {}
+
+    int load(std::memory_order = std::memory_order_relaxed) const
+    {
+        return value;
+    }
+
+    void store(int new_value, std::memory_order = std::memory_order_relaxed)
+    {
+        value = new_value;
+    }
+
+    int exchange(int new_value, std::memory_order = std::memory_order_relaxed)
+    {
+        std::swap(new_value, value);
+        return new_value; // return value before the call
+    }
+};
+
+} // namespace details
+} // namespace spdlog
diff --git a/3rdparty/spdlog/src/include/spdlog/details/os-inl.h b/3rdparty/spdlog/src/include/spdlog/details/os-inl.h
new file mode 100644
index 00000000..ea8864ea
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/details/os-inl.h
@@ -0,0 +1,635 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#ifndef SPDLOG_HEADER_ONLY
+#    include <spdlog/details/os.h>
+#endif
+
+#include <spdlog/common.h>
+
+#include <algorithm>
+#include <chrono>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <ctime>
+#include <string>
+#include <thread>
+#include <array>
+#include <sys/stat.h>
+#include <sys/types.h>
+
+#ifdef _WIN32
+
+#    include <io.h>      // for _get_osfhandle, _isatty, _fileno
+#    include <process.h> // for _get_pid
+#    include <spdlog/details/windows_include.h>
+#    include <fileapi.h> // for FlushFileBuffers
+
+#    ifdef __MINGW32__
+#        include <share.h>
+#    endif
+
+#    if defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) || defined(SPDLOG_WCHAR_FILENAMES)
+#        include <limits>
+#        include <cassert>
+#    endif
+
+#    include <direct.h> // for _mkdir/_wmkdir
+
+#else // unix
+
+#    include <fcntl.h>
+#    include <unistd.h>
+
+#    ifdef __linux__
+#        include <sys/syscall.h> //Use gettid() syscall under linux to get thread id
+
+#    elif defined(_AIX)
+#        include <pthread.h> // for pthread_getthrds_np
+
+#    elif defined(__DragonFly__) || defined(__FreeBSD__)
+#        include <pthread_np.h> // for pthread_getthreadid_np
+
+#    elif defined(__NetBSD__)
+#        include <lwp.h> // for _lwp_self
+
+#    elif defined(__sun)
+#        include <thread.h> // for thr_self
+#    endif
+
+#endif // unix
+
+#if defined __APPLE__
+#    include <AvailabilityMacros.h>
+#endif
+
+#ifndef __has_feature          // Clang - feature checking macros.
+#    define __has_feature(x) 0 // Compatibility with non-clang compilers.
+#endif
+
+namespace spdlog {
+namespace details {
+namespace os {
+
+SPDLOG_INLINE spdlog::log_clock::time_point now() SPDLOG_NOEXCEPT
+{
+
+#if defined __linux__ && defined SPDLOG_CLOCK_COARSE
+    timespec ts;
+    ::clock_gettime(CLOCK_REALTIME_COARSE, &ts);
+    return std::chrono::time_point<log_clock, typename log_clock::duration>(
+        std::chrono::duration_cast<typename log_clock::duration>(std::chrono::seconds(ts.tv_sec) + std::chrono::nanoseconds(ts.tv_nsec)));
+
+#else
+    return log_clock::now();
+#endif
+}
+SPDLOG_INLINE std::tm localtime(const std::time_t &time_tt) SPDLOG_NOEXCEPT
+{
+
+#ifdef _WIN32
+    std::tm tm;
+    ::localtime_s(&tm, &time_tt);
+#else
+    std::tm tm;
+    ::localtime_r(&time_tt, &tm);
+#endif
+    return tm;
+}
+
+SPDLOG_INLINE std::tm localtime() SPDLOG_NOEXCEPT
+{
+    std::time_t now_t = ::time(nullptr);
+    return localtime(now_t);
+}
+
+SPDLOG_INLINE std::tm gmtime(const std::time_t &time_tt) SPDLOG_NOEXCEPT
+{
+
+#ifdef _WIN32
+    std::tm tm;
+    ::gmtime_s(&tm, &time_tt);
+#else
+    std::tm tm;
+    ::gmtime_r(&time_tt, &tm);
+#endif
+    return tm;
+}
+
+SPDLOG_INLINE std::tm gmtime() SPDLOG_NOEXCEPT
+{
+    std::time_t now_t = ::time(nullptr);
+    return gmtime(now_t);
+}
+
+// fopen_s on non windows for writing
+SPDLOG_INLINE bool fopen_s(FILE **fp, const filename_t &filename, const filename_t &mode)
+{
+#ifdef _WIN32
+#    ifdef SPDLOG_WCHAR_FILENAMES
+    *fp = ::_wfsopen((filename.c_str()), mode.c_str(), _SH_DENYNO);
+#    else
+    *fp = ::_fsopen((filename.c_str()), mode.c_str(), _SH_DENYNO);
+#    endif
+#    if defined(SPDLOG_PREVENT_CHILD_FD)
+    if (*fp != nullptr)
+    {
+        auto file_handle = reinterpret_cast<HANDLE>(_get_osfhandle(::_fileno(*fp)));
+        if (!::SetHandleInformation(file_handle, HANDLE_FLAG_INHERIT, 0))
+        {
+            ::fclose(*fp);
+            *fp = nullptr;
+        }
+    }
+#    endif
+#else // unix
+#    if defined(SPDLOG_PREVENT_CHILD_FD)
+    const int mode_flag = mode == SPDLOG_FILENAME_T("ab") ? O_APPEND : O_TRUNC;
+    const int fd = ::open((filename.c_str()), O_CREAT | O_WRONLY | O_CLOEXEC | mode_flag, mode_t(0644));
+    if (fd == -1)
+    {
+        return true;
+    }
+    *fp = ::fdopen(fd, mode.c_str());
+    if (*fp == nullptr)
+    {
+        ::close(fd);
+    }
+#    else
+    *fp = ::fopen((filename.c_str()), mode.c_str());
+#    endif
+#endif
+
+    return *fp == nullptr;
+}
+
+SPDLOG_INLINE int remove(const filename_t &filename) SPDLOG_NOEXCEPT
+{
+#if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES)
+    return ::_wremove(filename.c_str());
+#else
+    return std::remove(filename.c_str());
+#endif
+}
+
+SPDLOG_INLINE int remove_if_exists(const filename_t &filename) SPDLOG_NOEXCEPT
+{
+    return path_exists(filename) ? remove(filename) : 0;
+}
+
+SPDLOG_INLINE int rename(const filename_t &filename1, const filename_t &filename2) SPDLOG_NOEXCEPT
+{
+#if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES)
+    return ::_wrename(filename1.c_str(), filename2.c_str());
+#else
+    return std::rename(filename1.c_str(), filename2.c_str());
+#endif
+}
+
+// Return true if path exists (file or directory)
+SPDLOG_INLINE bool path_exists(const filename_t &filename) SPDLOG_NOEXCEPT
+{
+#ifdef _WIN32
+#    ifdef SPDLOG_WCHAR_FILENAMES
+    auto attribs = ::GetFileAttributesW(filename.c_str());
+#    else
+    auto attribs = ::GetFileAttributesA(filename.c_str());
+#    endif
+    return attribs != INVALID_FILE_ATTRIBUTES;
+#else // common linux/unix all have the stat system call
+    struct stat buffer;
+    return (::stat(filename.c_str(), &buffer) == 0);
+#endif
+}
+
+#ifdef _MSC_VER
+// avoid warning about unreachable statement at the end of filesize()
+#    pragma warning(push)
+#    pragma warning(disable : 4702)
+#endif
+
+// Return file size according to open FILE* object
+SPDLOG_INLINE size_t filesize(FILE *f)
+{
+    if (f == nullptr)
+    {
+        throw_spdlog_ex("Failed getting file size. fd is null");
+    }
+#if defined(_WIN32) && !defined(__CYGWIN__)
+    int fd = ::_fileno(f);
+#    if defined(_WIN64) // 64 bits
+    __int64 ret = ::_filelengthi64(fd);
+    if (ret >= 0)
+    {
+        return static_cast<size_t>(ret);
+    }
+
+#    else // windows 32 bits
+    long ret = ::_filelength(fd);
+    if (ret >= 0)
+    {
+        return static_cast<size_t>(ret);
+    }
+#    endif
+
+#else // unix
+// OpenBSD and AIX doesn't compile with :: before the fileno(..)
+#    if defined(__OpenBSD__) || defined(_AIX)
+    int fd = fileno(f);
+#    else
+    int fd = ::fileno(f);
+#    endif
+// 64 bits(but not in osx, linux/musl or cygwin, where fstat64 is deprecated)
+#    if ((defined(__linux__) && defined(__GLIBC__)) || defined(__sun) || defined(_AIX)) && (defined(__LP64__) || defined(_LP64))
+    struct stat64 st;
+    if (::fstat64(fd, &st) == 0)
+    {
+        return static_cast<size_t>(st.st_size);
+    }
+#    else // other unix or linux 32 bits or cygwin
+    struct stat st;
+    if (::fstat(fd, &st) == 0)
+    {
+        return static_cast<size_t>(st.st_size);
+    }
+#    endif
+#endif
+    throw_spdlog_ex("Failed getting file size from fd", errno);
+    return 0; // will not be reached.
+}
+
+#ifdef _MSC_VER
+#    pragma warning(pop)
+#endif
+
+// Return utc offset in minutes or throw spdlog_ex on failure
+SPDLOG_INLINE int utc_minutes_offset(const std::tm &tm)
+{
+
+#ifdef _WIN32
+#    if _WIN32_WINNT < _WIN32_WINNT_WS08
+    TIME_ZONE_INFORMATION tzinfo;
+    auto rv = ::GetTimeZoneInformation(&tzinfo);
+#    else
+    DYNAMIC_TIME_ZONE_INFORMATION tzinfo;
+    auto rv = ::GetDynamicTimeZoneInformation(&tzinfo);
+#    endif
+    if (rv == TIME_ZONE_ID_INVALID)
+        throw_spdlog_ex("Failed getting timezone info. ", errno);
+
+    int offset = -tzinfo.Bias;
+    if (tm.tm_isdst)
+    {
+        offset -= tzinfo.DaylightBias;
+    }
+    else
+    {
+        offset -= tzinfo.StandardBias;
+    }
+    return offset;
+#else
+
+#    if defined(sun) || defined(__sun) || defined(_AIX) || (defined(__NEWLIB__) && !defined(__TM_GMTOFF)) ||                               \
+        (!defined(_BSD_SOURCE) && !defined(_GNU_SOURCE))
+    // 'tm_gmtoff' field is BSD extension and it's missing on SunOS/Solaris
+    struct helper
+    {
+        static long int calculate_gmt_offset(const std::tm &localtm = details::os::localtime(), const std::tm &gmtm = details::os::gmtime())
+        {
+            int local_year = localtm.tm_year + (1900 - 1);
+            int gmt_year = gmtm.tm_year + (1900 - 1);
+
+            long int days = (
+                // difference in day of year
+                localtm.tm_yday -
+                gmtm.tm_yday
+
+                // + intervening leap days
+                + ((local_year >> 2) - (gmt_year >> 2)) - (local_year / 100 - gmt_year / 100) +
+                ((local_year / 100 >> 2) - (gmt_year / 100 >> 2))
+
+                // + difference in years * 365 */
+                + static_cast<long int>(local_year - gmt_year) * 365);
+
+            long int hours = (24 * days) + (localtm.tm_hour - gmtm.tm_hour);
+            long int mins = (60 * hours) + (localtm.tm_min - gmtm.tm_min);
+            long int secs = (60 * mins) + (localtm.tm_sec - gmtm.tm_sec);
+
+            return secs;
+        }
+    };
+
+    auto offset_seconds = helper::calculate_gmt_offset(tm);
+#    else
+    auto offset_seconds = tm.tm_gmtoff;
+#    endif
+
+    return static_cast<int>(offset_seconds / 60);
+#endif
+}
+
+// Return current thread id as size_t
+// It exists because the std::this_thread::get_id() is much slower(especially
+// under VS 2013)
+SPDLOG_INLINE size_t _thread_id() SPDLOG_NOEXCEPT
+{
+#ifdef _WIN32
+    return static_cast<size_t>(::GetCurrentThreadId());
+#elif defined(__linux__)
+#    if defined(__ANDROID__) && defined(__ANDROID_API__) && (__ANDROID_API__ < 21)
+#        define SYS_gettid __NR_gettid
+#    endif
+    return static_cast<size_t>(::syscall(SYS_gettid));
+#elif defined(_AIX)
+    struct __pthrdsinfo buf;
+    int reg_size = 0;
+    pthread_t pt = pthread_self();
+    int retval = pthread_getthrds_np(&pt, PTHRDSINFO_QUERY_TID, &buf, sizeof(buf), NULL, &reg_size);
+    int tid = (!retval) ? buf.__pi_tid : 0;
+    return static_cast<size_t>(tid);
+#elif defined(__DragonFly__) || defined(__FreeBSD__)
+    return static_cast<size_t>(::pthread_getthreadid_np());
+#elif defined(__NetBSD__)
+    return static_cast<size_t>(::_lwp_self());
+#elif defined(__OpenBSD__)
+    return static_cast<size_t>(::getthrid());
+#elif defined(__sun)
+    return static_cast<size_t>(::thr_self());
+#elif __APPLE__
+    uint64_t tid;
+    // There is no pthread_threadid_np prior to 10.6, and it is not supported on any PPC,
+    // including 10.6.8 Rosetta. __POWERPC__ is Apple-specific define encompassing ppc and ppc64.
+#    if (MAC_OS_X_VERSION_MAX_ALLOWED < 1060) || defined(__POWERPC__)
+    tid = pthread_mach_thread_np(pthread_self());
+#    elif MAC_OS_X_VERSION_MIN_REQUIRED < 1060
+    if (&pthread_threadid_np)
+    {
+        pthread_threadid_np(nullptr, &tid);
+    }
+    else
+    {
+        tid = pthread_mach_thread_np(pthread_self());
+    }
+#    else
+    pthread_threadid_np(nullptr, &tid);
+#    endif
+    return static_cast<size_t>(tid);
+#else // Default to standard C++11 (other Unix)
+    return static_cast<size_t>(std::hash<std::thread::id>()(std::this_thread::get_id()));
+#endif
+}
+
+// Return current thread id as size_t (from thread local storage)
+SPDLOG_INLINE size_t thread_id() SPDLOG_NOEXCEPT
+{
+#if defined(SPDLOG_NO_TLS)
+    return _thread_id();
+#else // cache thread id in tls
+    static thread_local const size_t tid = _thread_id();
+    return tid;
+#endif
+}
+
+// This is avoid msvc issue in sleep_for that happens if the clock changes.
+// See https://github.com/gabime/spdlog/issues/609
+SPDLOG_INLINE void sleep_for_millis(unsigned int milliseconds) SPDLOG_NOEXCEPT
+{
+#if defined(_WIN32)
+    ::Sleep(milliseconds);
+#else
+    std::this_thread::sleep_for(std::chrono::milliseconds(milliseconds));
+#endif
+}
+
+// wchar support for windows file names (SPDLOG_WCHAR_FILENAMES must be defined)
+#if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES)
+SPDLOG_INLINE std::string filename_to_str(const filename_t &filename)
+{
+    memory_buf_t buf;
+    wstr_to_utf8buf(filename, buf);
+    return SPDLOG_BUF_TO_STRING(buf);
+}
+#else
+SPDLOG_INLINE std::string filename_to_str(const filename_t &filename)
+{
+    return filename;
+}
+#endif
+
+SPDLOG_INLINE int pid() SPDLOG_NOEXCEPT
+{
+
+#ifdef _WIN32
+    return conditional_static_cast<int>(::GetCurrentProcessId());
+#else
+    return conditional_static_cast<int>(::getpid());
+#endif
+}
+
+// Determine if the terminal supports colors
+// Based on: https://github.com/agauniyal/rang/
+SPDLOG_INLINE bool is_color_terminal() SPDLOG_NOEXCEPT
+{
+#ifdef _WIN32
+    return true;
+#else
+
+    static const bool result = []() {
+        const char *env_colorterm_p = std::getenv("COLORTERM");
+        if (env_colorterm_p != nullptr)
+        {
+            return true;
+        }
+
+        static constexpr std::array<const char *, 16> terms = {{"ansi", "color", "console", "cygwin", "gnome", "konsole", "kterm", "linux",
+            "msys", "putty", "rxvt", "screen", "vt100", "xterm", "alacritty", "vt102"}};
+
+        const char *env_term_p = std::getenv("TERM");
+        if (env_term_p == nullptr)
+        {
+            return false;
+        }
+
+        return std::any_of(terms.begin(), terms.end(), [&](const char *term) { return std::strstr(env_term_p, term) != nullptr; });
+    }();
+
+    return result;
+#endif
+}
+
+// Determine if the terminal attached
+// Source: https://github.com/agauniyal/rang/
+SPDLOG_INLINE bool in_terminal(FILE *file) SPDLOG_NOEXCEPT
+{
+
+#ifdef _WIN32
+    return ::_isatty(_fileno(file)) != 0;
+#else
+    return ::isatty(fileno(file)) != 0;
+#endif
+}
+
+#if (defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) || defined(SPDLOG_WCHAR_FILENAMES)) && defined(_WIN32)
+SPDLOG_INLINE void wstr_to_utf8buf(wstring_view_t wstr, memory_buf_t &target)
+{
+    if (wstr.size() > static_cast<size_t>((std::numeric_limits<int>::max)()) / 2 - 1)
+    {
+        throw_spdlog_ex("UTF-16 string is too big to be converted to UTF-8");
+    }
+
+    int wstr_size = static_cast<int>(wstr.size());
+    if (wstr_size == 0)
+    {
+        target.resize(0);
+        return;
+    }
+
+    int result_size = static_cast<int>(target.capacity());
+    if ((wstr_size + 1) * 2 > result_size)
+    {
+        result_size = ::WideCharToMultiByte(CP_UTF8, 0, wstr.data(), wstr_size, NULL, 0, NULL, NULL);
+    }
+
+    if (result_size > 0)
+    {
+        target.resize(result_size);
+        result_size = ::WideCharToMultiByte(CP_UTF8, 0, wstr.data(), wstr_size, target.data(), result_size, NULL, NULL);
+
+        if (result_size > 0)
+        {
+            target.resize(result_size);
+            return;
+        }
+    }
+
+    throw_spdlog_ex(fmt_lib::format("WideCharToMultiByte failed. Last error: {}", ::GetLastError()));
+}
+
+SPDLOG_INLINE void utf8_to_wstrbuf(string_view_t str, wmemory_buf_t &target)
+{
+    if (str.size() > static_cast<size_t>((std::numeric_limits<int>::max)()) - 1)
+    {
+        throw_spdlog_ex("UTF-8 string is too big to be converted to UTF-16");
+    }
+
+    int str_size = static_cast<int>(str.size());
+    if (str_size == 0)
+    {
+        target.resize(0);
+        return;
+    }
+
+    // find the size to allocate for the result buffer
+    int result_size = ::MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, str.data(), str_size, NULL, 0);
+
+    if (result_size > 0)
+    {
+        target.resize(result_size);
+        result_size = ::MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, str.data(), str_size, target.data(), result_size);
+        if (result_size > 0)
+        {
+            assert(result_size == target.size());
+            return;
+        }
+    }
+
+    throw_spdlog_ex(fmt_lib::format("MultiByteToWideChar failed. Last error: {}", ::GetLastError()));
+}
+#endif // (defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) || defined(SPDLOG_WCHAR_FILENAMES)) && defined(_WIN32)
+
+// return true on success
+static SPDLOG_INLINE bool mkdir_(const filename_t &path)
+{
+#ifdef _WIN32
+#    ifdef SPDLOG_WCHAR_FILENAMES
+    return ::_wmkdir(path.c_str()) == 0;
+#    else
+    return ::_mkdir(path.c_str()) == 0;
+#    endif
+#else
+    return ::mkdir(path.c_str(), mode_t(0755)) == 0;
+#endif
+}
+
+// create the given directory - and all directories leading to it
+// return true on success or if the directory already exists
+SPDLOG_INLINE bool create_dir(const filename_t &path)
+{
+    if (path_exists(path))
+    {
+        return true;
+    }
+
+    if (path.empty())
+    {
+        return false;
+    }
+
+    size_t search_offset = 0;
+    do
+    {
+        auto token_pos = path.find_first_of(folder_seps_filename, search_offset);
+        // treat the entire path as a folder if no folder separator not found
+        if (token_pos == filename_t::npos)
+        {
+            token_pos = path.size();
+        }
+
+        auto subdir = path.substr(0, token_pos);
+
+        if (!subdir.empty() && !path_exists(subdir) && !mkdir_(subdir))
+        {
+            return false; // return error if failed creating dir
+        }
+        search_offset = token_pos + 1;
+    } while (search_offset < path.size());
+
+    return true;
+}
+
+// Return directory name from given path or empty string
+// "abc/file" => "abc"
+// "abc/" => "abc"
+// "abc" => ""
+// "abc///" => "abc//"
+SPDLOG_INLINE filename_t dir_name(const filename_t &path)
+{
+    auto pos = path.find_last_of(folder_seps_filename);
+    return pos != filename_t::npos ? path.substr(0, pos) : filename_t{};
+}
+
+std::string SPDLOG_INLINE getenv(const char *field)
+{
+
+#if defined(_MSC_VER)
+#    if defined(__cplusplus_winrt)
+    return std::string{}; // not supported under uwp
+#    else
+    size_t len = 0;
+    char buf[128];
+    bool ok = ::getenv_s(&len, buf, sizeof(buf), field) == 0;
+    return ok ? buf : std::string{};
+#    endif
+#else // revert to getenv
+    char *buf = ::getenv(field);
+    return buf ? buf : std::string{};
+#endif
+}
+
+// Do fsync by FILE handlerpointer
+// Return true on success
+SPDLOG_INLINE bool fsync(FILE *fp)
+{
+#ifdef _WIN32
+    return FlushFileBuffers(reinterpret_cast<HANDLE>(_get_osfhandle(_fileno(fp)))) != 0;
+#else
+    return ::fsync(fileno(fp)) == 0;
+#endif
+}
+
+} // namespace os
+} // namespace details
+} // namespace spdlog
diff --git a/3rdparty/spdlog/src/include/spdlog/details/os.h b/3rdparty/spdlog/src/include/spdlog/details/os.h
new file mode 100644
index 00000000..37b00874
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/details/os.h
@@ -0,0 +1,122 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#include <spdlog/common.h>
+#include <ctime> // std::time_t
+
+namespace spdlog {
+namespace details {
+namespace os {
+
+SPDLOG_API spdlog::log_clock::time_point now() SPDLOG_NOEXCEPT;
+
+SPDLOG_API std::tm localtime(const std::time_t &time_tt) SPDLOG_NOEXCEPT;
+
+SPDLOG_API std::tm localtime() SPDLOG_NOEXCEPT;
+
+SPDLOG_API std::tm gmtime(const std::time_t &time_tt) SPDLOG_NOEXCEPT;
+
+SPDLOG_API std::tm gmtime() SPDLOG_NOEXCEPT;
+
+// eol definition
+#if !defined(SPDLOG_EOL)
+#    ifdef _WIN32
+#        define SPDLOG_EOL "\r\n"
+#    else
+#        define SPDLOG_EOL "\n"
+#    endif
+#endif
+
+SPDLOG_CONSTEXPR static const char *default_eol = SPDLOG_EOL;
+
+// folder separator
+#if !defined(SPDLOG_FOLDER_SEPS)
+#    ifdef _WIN32
+#        define SPDLOG_FOLDER_SEPS "\\/"
+#    else
+#        define SPDLOG_FOLDER_SEPS "/"
+#    endif
+#endif
+
+SPDLOG_CONSTEXPR static const char folder_seps[] = SPDLOG_FOLDER_SEPS;
+SPDLOG_CONSTEXPR static const filename_t::value_type folder_seps_filename[] = SPDLOG_FILENAME_T(SPDLOG_FOLDER_SEPS);
+
+// fopen_s on non windows for writing
+SPDLOG_API bool fopen_s(FILE **fp, const filename_t &filename, const filename_t &mode);
+
+// Remove filename. return 0 on success
+SPDLOG_API int remove(const filename_t &filename) SPDLOG_NOEXCEPT;
+
+// Remove file if exists. return 0 on success
+// Note: Non atomic (might return failure to delete if concurrently deleted by other process/thread)
+SPDLOG_API int remove_if_exists(const filename_t &filename) SPDLOG_NOEXCEPT;
+
+SPDLOG_API int rename(const filename_t &filename1, const filename_t &filename2) SPDLOG_NOEXCEPT;
+
+// Return if file exists.
+SPDLOG_API bool path_exists(const filename_t &filename) SPDLOG_NOEXCEPT;
+
+// Return file size according to open FILE* object
+SPDLOG_API size_t filesize(FILE *f);
+
+// Return utc offset in minutes or throw spdlog_ex on failure
+SPDLOG_API int utc_minutes_offset(const std::tm &tm = details::os::localtime());
+
+// Return current thread id as size_t
+// It exists because the std::this_thread::get_id() is much slower(especially
+// under VS 2013)
+SPDLOG_API size_t _thread_id() SPDLOG_NOEXCEPT;
+
+// Return current thread id as size_t (from thread local storage)
+SPDLOG_API size_t thread_id() SPDLOG_NOEXCEPT;
+
+// This is avoid msvc issue in sleep_for that happens if the clock changes.
+// See https://github.com/gabime/spdlog/issues/609
+SPDLOG_API void sleep_for_millis(unsigned int milliseconds) SPDLOG_NOEXCEPT;
+
+SPDLOG_API std::string filename_to_str(const filename_t &filename);
+
+SPDLOG_API int pid() SPDLOG_NOEXCEPT;
+
+// Determine if the terminal supports colors
+// Source: https://github.com/agauniyal/rang/
+SPDLOG_API bool is_color_terminal() SPDLOG_NOEXCEPT;
+
+// Determine if the terminal attached
+// Source: https://github.com/agauniyal/rang/
+SPDLOG_API bool in_terminal(FILE *file) SPDLOG_NOEXCEPT;
+
+#if (defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) || defined(SPDLOG_WCHAR_FILENAMES)) && defined(_WIN32)
+SPDLOG_API void wstr_to_utf8buf(wstring_view_t wstr, memory_buf_t &target);
+
+SPDLOG_API void utf8_to_wstrbuf(string_view_t str, wmemory_buf_t &target);
+#endif
+
+// Return directory name from given path or empty string
+// "abc/file" => "abc"
+// "abc/" => "abc"
+// "abc" => ""
+// "abc///" => "abc//"
+SPDLOG_API filename_t dir_name(const filename_t &path);
+
+// Create a dir from the given path.
+// Return true if succeeded or if this dir already exists.
+SPDLOG_API bool create_dir(const filename_t &path);
+
+// non thread safe, cross platform getenv/getenv_s
+// return empty string if field not found
+SPDLOG_API std::string getenv(const char *field);
+
+// Do fsync by FILE objectpointer.
+// Return true on success.
+SPDLOG_API bool fsync(FILE *fp);
+
+} // namespace os
+} // namespace details
+} // namespace spdlog
+
+#ifdef SPDLOG_HEADER_ONLY
+#    include "os-inl.h"
+#endif
diff --git a/3rdparty/spdlog/src/include/spdlog/details/periodic_worker-inl.h b/3rdparty/spdlog/src/include/spdlog/details/periodic_worker-inl.h
new file mode 100644
index 00000000..520a2b33
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/details/periodic_worker-inl.h
@@ -0,0 +1,28 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#ifndef SPDLOG_HEADER_ONLY
+#    include <spdlog/details/periodic_worker.h>
+#endif
+
+namespace spdlog {
+namespace details {
+
+// stop the worker thread and join it
+SPDLOG_INLINE periodic_worker::~periodic_worker()
+{
+    if (worker_thread_.joinable())
+    {
+        {
+            std::lock_guard<std::mutex> lock(mutex_);
+            active_ = false;
+        }
+        cv_.notify_one();
+        worker_thread_.join();
+    }
+}
+
+} // namespace details
+} // namespace spdlog
diff --git a/3rdparty/spdlog/src/include/spdlog/details/periodic_worker.h b/3rdparty/spdlog/src/include/spdlog/details/periodic_worker.h
new file mode 100644
index 00000000..d7d69b28
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/details/periodic_worker.h
@@ -0,0 +1,60 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+// periodic worker thread - periodically executes the given callback function.
+//
+// RAII over the owned thread:
+//    creates the thread on construction.
+//    stops and joins the thread on destruction (if the thread is executing a callback, wait for it to finish first).
+
+#include <chrono>
+#include <condition_variable>
+#include <functional>
+#include <mutex>
+#include <thread>
+namespace spdlog {
+namespace details {
+
+class SPDLOG_API periodic_worker
+{
+public:
+    template<typename Rep, typename Period>
+    periodic_worker(const std::function<void()> &callback_fun, std::chrono::duration<Rep, Period> interval)
+    {
+        active_ = (interval > std::chrono::duration<Rep, Period>::zero());
+        if (!active_)
+        {
+            return;
+        }
+
+        worker_thread_ = std::thread([this, callback_fun, interval]() {
+            for (;;)
+            {
+                std::unique_lock<std::mutex> lock(this->mutex_);
+                if (this->cv_.wait_for(lock, interval, [this] { return !this->active_; }))
+                {
+                    return; // active_ == false, so exit this thread
+                }
+                callback_fun();
+            }
+        });
+    }
+    periodic_worker(const periodic_worker &) = delete;
+    periodic_worker &operator=(const periodic_worker &) = delete;
+    // stop the worker thread and join it
+    ~periodic_worker();
+
+private:
+    bool active_;
+    std::thread worker_thread_;
+    std::mutex mutex_;
+    std::condition_variable cv_;
+};
+} // namespace details
+} // namespace spdlog
+
+#ifdef SPDLOG_HEADER_ONLY
+#    include "periodic_worker-inl.h"
+#endif
diff --git a/3rdparty/spdlog/src/include/spdlog/details/registry-inl.h b/3rdparty/spdlog/src/include/spdlog/details/registry-inl.h
new file mode 100644
index 00000000..e81f8acd
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/details/registry-inl.h
@@ -0,0 +1,321 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#ifndef SPDLOG_HEADER_ONLY
+#    include <spdlog/details/registry.h>
+#endif
+
+#include <spdlog/common.h>
+#include <spdlog/details/periodic_worker.h>
+#include <spdlog/logger.h>
+#include <spdlog/pattern_formatter.h>
+
+#ifndef SPDLOG_DISABLE_DEFAULT_LOGGER
+// support for the default stdout color logger
+#    ifdef _WIN32
+#        include <spdlog/sinks/wincolor_sink.h>
+#    else
+#        include <spdlog/sinks/ansicolor_sink.h>
+#    endif
+#endif // SPDLOG_DISABLE_DEFAULT_LOGGER
+
+#include <chrono>
+#include <functional>
+#include <memory>
+#include <string>
+#include <unordered_map>
+
+namespace spdlog {
+namespace details {
+
+SPDLOG_INLINE registry::registry()
+    : formatter_(new pattern_formatter())
+{
+
+#ifndef SPDLOG_DISABLE_DEFAULT_LOGGER
+    // create default logger (ansicolor_stdout_sink_mt or wincolor_stdout_sink_mt in windows).
+#    ifdef _WIN32
+    auto color_sink = std::make_shared<sinks::wincolor_stdout_sink_mt>();
+#    else
+    auto color_sink = std::make_shared<sinks::ansicolor_stdout_sink_mt>();
+#    endif
+
+    const char *default_logger_name = "";
+    default_logger_ = std::make_shared<spdlog::logger>(default_logger_name, std::move(color_sink));
+    loggers_[default_logger_name] = default_logger_;
+
+#endif // SPDLOG_DISABLE_DEFAULT_LOGGER
+}
+
+SPDLOG_INLINE registry::~registry() = default;
+
+SPDLOG_INLINE void registry::register_logger(std::shared_ptr<logger> new_logger)
+{
+    std::lock_guard<std::mutex> lock(logger_map_mutex_);
+    register_logger_(std::move(new_logger));
+}
+
+SPDLOG_INLINE void registry::initialize_logger(std::shared_ptr<logger> new_logger)
+{
+    std::lock_guard<std::mutex> lock(logger_map_mutex_);
+    new_logger->set_formatter(formatter_->clone());
+
+    if (err_handler_)
+    {
+        new_logger->set_error_handler(err_handler_);
+    }
+
+    // set new level according to previously configured level or default level
+    auto it = log_levels_.find(new_logger->name());
+    auto new_level = it != log_levels_.end() ? it->second : global_log_level_;
+    new_logger->set_level(new_level);
+
+    new_logger->flush_on(flush_level_);
+
+    if (backtrace_n_messages_ > 0)
+    {
+        new_logger->enable_backtrace(backtrace_n_messages_);
+    }
+
+    if (automatic_registration_)
+    {
+        register_logger_(std::move(new_logger));
+    }
+}
+
+SPDLOG_INLINE std::shared_ptr<logger> registry::get(const std::string &logger_name)
+{
+    std::lock_guard<std::mutex> lock(logger_map_mutex_);
+    auto found = loggers_.find(logger_name);
+    return found == loggers_.end() ? nullptr : found->second;
+}
+
+SPDLOG_INLINE std::shared_ptr<logger> registry::default_logger()
+{
+    std::lock_guard<std::mutex> lock(logger_map_mutex_);
+    return default_logger_;
+}
+
+// Return raw ptr to the default logger.
+// To be used directly by the spdlog default api (e.g. spdlog::info)
+// This make the default API faster, but cannot be used concurrently with set_default_logger().
+// e.g do not call set_default_logger() from one thread while calling spdlog::info() from another.
+SPDLOG_INLINE logger *registry::get_default_raw()
+{
+    return default_logger_.get();
+}
+
+// set default logger.
+// default logger is stored in default_logger_ (for faster retrieval) and in the loggers_ map.
+SPDLOG_INLINE void registry::set_default_logger(std::shared_ptr<logger> new_default_logger)
+{
+    std::lock_guard<std::mutex> lock(logger_map_mutex_);
+    // remove previous default logger from the map
+    if (default_logger_ != nullptr)
+    {
+        loggers_.erase(default_logger_->name());
+    }
+    if (new_default_logger != nullptr)
+    {
+        loggers_[new_default_logger->name()] = new_default_logger;
+    }
+    default_logger_ = std::move(new_default_logger);
+}
+
+SPDLOG_INLINE void registry::set_tp(std::shared_ptr<thread_pool> tp)
+{
+    std::lock_guard<std::recursive_mutex> lock(tp_mutex_);
+    tp_ = std::move(tp);
+}
+
+SPDLOG_INLINE std::shared_ptr<thread_pool> registry::get_tp()
+{
+    std::lock_guard<std::recursive_mutex> lock(tp_mutex_);
+    return tp_;
+}
+
+// Set global formatter. Each sink in each logger will get a clone of this object
+SPDLOG_INLINE void registry::set_formatter(std::unique_ptr<formatter> formatter)
+{
+    std::lock_guard<std::mutex> lock(logger_map_mutex_);
+    formatter_ = std::move(formatter);
+    for (auto &l : loggers_)
+    {
+        l.second->set_formatter(formatter_->clone());
+    }
+}
+
+SPDLOG_INLINE void registry::enable_backtrace(size_t n_messages)
+{
+    std::lock_guard<std::mutex> lock(logger_map_mutex_);
+    backtrace_n_messages_ = n_messages;
+
+    for (auto &l : loggers_)
+    {
+        l.second->enable_backtrace(n_messages);
+    }
+}
+
+SPDLOG_INLINE void registry::disable_backtrace()
+{
+    std::lock_guard<std::mutex> lock(logger_map_mutex_);
+    backtrace_n_messages_ = 0;
+    for (auto &l : loggers_)
+    {
+        l.second->disable_backtrace();
+    }
+}
+
+SPDLOG_INLINE void registry::set_level(level::level_enum log_level)
+{
+    std::lock_guard<std::mutex> lock(logger_map_mutex_);
+    for (auto &l : loggers_)
+    {
+        l.second->set_level(log_level);
+    }
+    global_log_level_ = log_level;
+}
+
+SPDLOG_INLINE void registry::flush_on(level::level_enum log_level)
+{
+    std::lock_guard<std::mutex> lock(logger_map_mutex_);
+    for (auto &l : loggers_)
+    {
+        l.second->flush_on(log_level);
+    }
+    flush_level_ = log_level;
+}
+
+SPDLOG_INLINE void registry::set_error_handler(err_handler handler)
+{
+    std::lock_guard<std::mutex> lock(logger_map_mutex_);
+    for (auto &l : loggers_)
+    {
+        l.second->set_error_handler(handler);
+    }
+    err_handler_ = std::move(handler);
+}
+
+SPDLOG_INLINE void registry::apply_all(const std::function<void(const std::shared_ptr<logger>)> &fun)
+{
+    std::lock_guard<std::mutex> lock(logger_map_mutex_);
+    for (auto &l : loggers_)
+    {
+        fun(l.second);
+    }
+}
+
+SPDLOG_INLINE void registry::flush_all()
+{
+    std::lock_guard<std::mutex> lock(logger_map_mutex_);
+    for (auto &l : loggers_)
+    {
+        l.second->flush();
+    }
+}
+
+SPDLOG_INLINE void registry::drop(const std::string &logger_name)
+{
+    std::lock_guard<std::mutex> lock(logger_map_mutex_);
+    auto is_default_logger = default_logger_ && default_logger_->name() == logger_name;
+    loggers_.erase(logger_name);
+    if (is_default_logger)
+    {
+        default_logger_.reset();
+    }
+}
+
+SPDLOG_INLINE void registry::drop_all()
+{
+    std::lock_guard<std::mutex> lock(logger_map_mutex_);
+    loggers_.clear();
+    default_logger_.reset();
+}
+
+// clean all resources and threads started by the registry
+SPDLOG_INLINE void registry::shutdown()
+{
+    {
+        std::lock_guard<std::mutex> lock(flusher_mutex_);
+        periodic_flusher_.reset();
+    }
+
+    drop_all();
+
+    {
+        std::lock_guard<std::recursive_mutex> lock(tp_mutex_);
+        tp_.reset();
+    }
+}
+
+SPDLOG_INLINE std::recursive_mutex &registry::tp_mutex()
+{
+    return tp_mutex_;
+}
+
+SPDLOG_INLINE void registry::set_automatic_registration(bool automatic_registration)
+{
+    std::lock_guard<std::mutex> lock(logger_map_mutex_);
+    automatic_registration_ = automatic_registration;
+}
+
+SPDLOG_INLINE void registry::set_levels(log_levels levels, level::level_enum *global_level)
+{
+    std::lock_guard<std::mutex> lock(logger_map_mutex_);
+    log_levels_ = std::move(levels);
+    auto global_level_requested = global_level != nullptr;
+    global_log_level_ = global_level_requested ? *global_level : global_log_level_;
+
+    for (auto &logger : loggers_)
+    {
+        auto logger_entry = log_levels_.find(logger.first);
+        if (logger_entry != log_levels_.end())
+        {
+            logger.second->set_level(logger_entry->second);
+        }
+        else if (global_level_requested)
+        {
+            logger.second->set_level(*global_level);
+        }
+    }
+}
+
+SPDLOG_INLINE std::shared_ptr<registry> registry::instance_ptr()
+{
+    static std::shared_ptr<registry> s_instance = std::shared_ptr<registry>(new registry());
+    return s_instance;
+}
+
+SPDLOG_INLINE registry &registry::instance()
+{
+    static registry &s_instance = *instance_ptr();
+    return s_instance;
+}
+
+SPDLOG_INLINE void registry::apply_logger_env_levels(std::shared_ptr<logger> new_logger)
+{
+    std::lock_guard<std::mutex> lock(logger_map_mutex_);
+    auto it = log_levels_.find(new_logger->name());
+    auto new_level = it != log_levels_.end() ? it->second : global_log_level_;
+    new_logger->set_level(new_level);
+}
+
+SPDLOG_INLINE void registry::throw_if_exists_(const std::string &logger_name)
+{
+    if (loggers_.find(logger_name) != loggers_.end())
+    {
+        throw_spdlog_ex("logger with name '" + logger_name + "' already exists");
+    }
+}
+
+SPDLOG_INLINE void registry::register_logger_(std::shared_ptr<logger> new_logger)
+{
+    auto logger_name = new_logger->name();
+    throw_if_exists_(logger_name);
+    loggers_[logger_name] = std::move(new_logger);
+}
+
+} // namespace details
+} // namespace spdlog
diff --git a/3rdparty/spdlog/src/include/spdlog/details/registry.h b/3rdparty/spdlog/src/include/spdlog/details/registry.h
new file mode 100644
index 00000000..efa547cf
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/details/registry.h
@@ -0,0 +1,127 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+// Loggers registry of unique name->logger pointer
+// An attempt to create a logger with an already existing name will result with spdlog_ex exception.
+// If user requests a non existing logger, nullptr will be returned
+// This class is thread safe
+
+#include <spdlog/common.h>
+#include <spdlog/details/periodic_worker.h>
+
+#include <chrono>
+#include <functional>
+#include <memory>
+#include <string>
+#include <unordered_map>
+#include <mutex>
+
+namespace spdlog {
+class logger;
+
+namespace details {
+class thread_pool;
+
+class SPDLOG_API registry
+{
+public:
+    using log_levels = std::unordered_map<std::string, level::level_enum>;
+    registry(const registry &) = delete;
+    registry &operator=(const registry &) = delete;
+
+    void register_logger(std::shared_ptr<logger> new_logger);
+    void initialize_logger(std::shared_ptr<logger> new_logger);
+    std::shared_ptr<logger> get(const std::string &logger_name);
+    std::shared_ptr<logger> default_logger();
+
+    // Return raw ptr to the default logger.
+    // To be used directly by the spdlog default api (e.g. spdlog::info)
+    // This make the default API faster, but cannot be used concurrently with set_default_logger().
+    // e.g do not call set_default_logger() from one thread while calling spdlog::info() from another.
+    logger *get_default_raw();
+
+    // set default logger.
+    // default logger is stored in default_logger_ (for faster retrieval) and in the loggers_ map.
+    void set_default_logger(std::shared_ptr<logger> new_default_logger);
+
+    void set_tp(std::shared_ptr<thread_pool> tp);
+
+    std::shared_ptr<thread_pool> get_tp();
+
+    // Set global formatter. Each sink in each logger will get a clone of this object
+    void set_formatter(std::unique_ptr<formatter> formatter);
+
+    void enable_backtrace(size_t n_messages);
+
+    void disable_backtrace();
+
+    void set_level(level::level_enum log_level);
+
+    void flush_on(level::level_enum log_level);
+
+    template<typename Rep, typename Period>
+    void flush_every(std::chrono::duration<Rep, Period> interval)
+    {
+        std::lock_guard<std::mutex> lock(flusher_mutex_);
+        auto clbk = [this]() { this->flush_all(); };
+        periodic_flusher_ = details::make_unique<periodic_worker>(clbk, interval);
+    }
+
+    void set_error_handler(err_handler handler);
+
+    void apply_all(const std::function<void(const std::shared_ptr<logger>)> &fun);
+
+    void flush_all();
+
+    void drop(const std::string &logger_name);
+
+    void drop_all();
+
+    // clean all resources and threads started by the registry
+    void shutdown();
+
+    std::recursive_mutex &tp_mutex();
+
+    void set_automatic_registration(bool automatic_registration);
+
+    // set levels for all existing/future loggers. global_level can be null if should not set.
+    void set_levels(log_levels levels, level::level_enum *global_level);
+
+    // add for handle instance outside spdlog
+    static std::shared_ptr<registry> instance_ptr();
+
+    static registry &instance();
+
+    void apply_logger_env_levels(std::shared_ptr<logger> new_logger);
+
+    ~registry();
+
+private:
+    registry();
+
+    void throw_if_exists_(const std::string &logger_name);
+    void register_logger_(std::shared_ptr<logger> new_logger);
+    bool set_level_from_cfg_(logger *logger);
+    std::mutex logger_map_mutex_, flusher_mutex_;
+    std::recursive_mutex tp_mutex_;
+    std::unordered_map<std::string, std::shared_ptr<logger>> loggers_;
+    log_levels log_levels_;
+    std::unique_ptr<formatter> formatter_;
+    spdlog::level::level_enum global_log_level_ = level::info;
+    level::level_enum flush_level_ = level::off;
+    err_handler err_handler_;
+    std::shared_ptr<thread_pool> tp_;
+    std::unique_ptr<periodic_worker> periodic_flusher_;
+    std::shared_ptr<logger> default_logger_;
+    bool automatic_registration_ = true;
+    size_t backtrace_n_messages_ = 0;
+};
+
+} // namespace details
+} // namespace spdlog
+
+#ifdef SPDLOG_HEADER_ONLY
+#    include "registry-inl.h"
+#endif
diff --git a/3rdparty/spdlog/src/include/spdlog/details/synchronous_factory.h b/3rdparty/spdlog/src/include/spdlog/details/synchronous_factory.h
new file mode 100644
index 00000000..e1e42268
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/details/synchronous_factory.h
@@ -0,0 +1,24 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#include "registry.h"
+
+namespace spdlog {
+
+// Default logger factory-  creates synchronous loggers
+class logger;
+
+struct synchronous_factory
+{
+    template<typename Sink, typename... SinkArgs>
+    static std::shared_ptr<spdlog::logger> create(std::string logger_name, SinkArgs &&...args)
+    {
+        auto sink = std::make_shared<Sink>(std::forward<SinkArgs>(args)...);
+        auto new_logger = std::make_shared<spdlog::logger>(std::move(logger_name), std::move(sink));
+        details::registry::instance().initialize_logger(new_logger);
+        return new_logger;
+    }
+};
+} // namespace spdlog
diff --git a/3rdparty/spdlog/src/include/spdlog/details/tcp_client-windows.h b/3rdparty/spdlog/src/include/spdlog/details/tcp_client-windows.h
new file mode 100644
index 00000000..9d3647aa
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/details/tcp_client-windows.h
@@ -0,0 +1,160 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#define WIN32_LEAN_AND_MEAN
+// tcp client helper
+#include <spdlog/common.h>
+#include <spdlog/details/os.h>
+
+#include <winsock2.h>
+#include <windows.h>
+#include <ws2tcpip.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string>
+
+#pragma comment(lib, "Ws2_32.lib")
+#pragma comment(lib, "Mswsock.lib")
+#pragma comment(lib, "AdvApi32.lib")
+
+namespace spdlog {
+namespace details {
+class tcp_client
+{
+    SOCKET socket_ = INVALID_SOCKET;
+
+    static void init_winsock_()
+    {
+        WSADATA wsaData;
+        auto rv = WSAStartup(MAKEWORD(2, 2), &wsaData);
+        if (rv != 0)
+        {
+            throw_winsock_error_("WSAStartup failed", ::WSAGetLastError());
+        }
+    }
+
+    static void throw_winsock_error_(const std::string &msg, int last_error)
+    {
+        char buf[512];
+        ::FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, last_error,
+            MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), buf, (sizeof(buf) / sizeof(char)), NULL);
+
+        throw_spdlog_ex(fmt_lib::format("tcp_sink - {}: {}", msg, buf));
+    }
+
+public:
+    tcp_client()
+    {
+        init_winsock_();
+    }
+
+    ~tcp_client()
+    {
+        close();
+        ::WSACleanup();
+    }
+
+    bool is_connected() const
+    {
+        return socket_ != INVALID_SOCKET;
+    }
+
+    void close()
+    {
+        ::closesocket(socket_);
+        socket_ = INVALID_SOCKET;
+    }
+
+    SOCKET fd() const
+    {
+        return socket_;
+    }
+
+    // try to connect or throw on failure
+    void connect(const std::string &host, int port)
+    {
+        if (is_connected())
+        {
+            close();
+        }
+        struct addrinfo hints
+        {};
+        ZeroMemory(&hints, sizeof(hints));
+
+        hints.ai_family = AF_INET;       // IPv4
+        hints.ai_socktype = SOCK_STREAM; // TCP
+        hints.ai_flags = AI_NUMERICSERV; // port passed as as numeric value
+        hints.ai_protocol = 0;
+
+        auto port_str = std::to_string(port);
+        struct addrinfo *addrinfo_result;
+        auto rv = ::getaddrinfo(host.c_str(), port_str.c_str(), &hints, &addrinfo_result);
+        int last_error = 0;
+        if (rv != 0)
+        {
+            last_error = ::WSAGetLastError();
+            WSACleanup();
+            throw_winsock_error_("getaddrinfo failed", last_error);
+        }
+
+        // Try each address until we successfully connect(2).
+
+        for (auto *rp = addrinfo_result; rp != nullptr; rp = rp->ai_next)
+        {
+            socket_ = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol);
+            if (socket_ == INVALID_SOCKET)
+            {
+                last_error = ::WSAGetLastError();
+                WSACleanup();
+                continue;
+            }
+            if (::connect(socket_, rp->ai_addr, (int)rp->ai_addrlen) == 0)
+            {
+                break;
+            }
+            else
+            {
+                last_error = ::WSAGetLastError();
+                close();
+            }
+        }
+        ::freeaddrinfo(addrinfo_result);
+        if (socket_ == INVALID_SOCKET)
+        {
+            WSACleanup();
+            throw_winsock_error_("connect failed", last_error);
+        }
+
+        // set TCP_NODELAY
+        int enable_flag = 1;
+        ::setsockopt(socket_, IPPROTO_TCP, TCP_NODELAY, reinterpret_cast<char *>(&enable_flag), sizeof(enable_flag));
+    }
+
+    // Send exactly n_bytes of the given data.
+    // On error close the connection and throw.
+    void send(const char *data, size_t n_bytes)
+    {
+        size_t bytes_sent = 0;
+        while (bytes_sent < n_bytes)
+        {
+            const int send_flags = 0;
+            auto write_result = ::send(socket_, data + bytes_sent, (int)(n_bytes - bytes_sent), send_flags);
+            if (write_result == SOCKET_ERROR)
+            {
+                int last_error = ::WSAGetLastError();
+                close();
+                throw_winsock_error_("send failed", last_error);
+            }
+
+            if (write_result == 0) // (probably should not happen but in any case..)
+            {
+                break;
+            }
+            bytes_sent += static_cast<size_t>(write_result);
+        }
+    }
+};
+} // namespace details
+} // namespace spdlog
diff --git a/3rdparty/spdlog/src/include/spdlog/details/tcp_client.h b/3rdparty/spdlog/src/include/spdlog/details/tcp_client.h
new file mode 100644
index 00000000..e4d7a48e
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/details/tcp_client.h
@@ -0,0 +1,146 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#ifdef _WIN32
+#    error include tcp_client-windows.h instead
+#endif
+
+// tcp client helper
+#include <spdlog/common.h>
+#include <spdlog/details/os.h>
+
+#include <sys/socket.h>
+#include <arpa/inet.h>
+#include <unistd.h>
+#include <netdb.h>
+#include <netinet/tcp.h>
+#include <netinet/in.h>
+
+#include <string>
+
+namespace spdlog {
+namespace details {
+class tcp_client
+{
+    int socket_ = -1;
+
+public:
+    bool is_connected() const
+    {
+        return socket_ != -1;
+    }
+
+    void close()
+    {
+        if (is_connected())
+        {
+            ::close(socket_);
+            socket_ = -1;
+        }
+    }
+
+    int fd() const
+    {
+        return socket_;
+    }
+
+    ~tcp_client()
+    {
+        close();
+    }
+
+    // try to connect or throw on failure
+    void connect(const std::string &host, int port)
+    {
+        close();
+        struct addrinfo hints
+        {};
+        memset(&hints, 0, sizeof(struct addrinfo));
+        hints.ai_family = AF_INET;       // IPv4
+        hints.ai_socktype = SOCK_STREAM; // TCP
+        hints.ai_flags = AI_NUMERICSERV; // port passed as as numeric value
+        hints.ai_protocol = 0;
+
+        auto port_str = std::to_string(port);
+        struct addrinfo *addrinfo_result;
+        auto rv = ::getaddrinfo(host.c_str(), port_str.c_str(), &hints, &addrinfo_result);
+        if (rv != 0)
+        {
+            throw_spdlog_ex(fmt_lib::format("::getaddrinfo failed: {}", gai_strerror(rv)));
+        }
+
+        // Try each address until we successfully connect(2).
+        int last_errno = 0;
+        for (auto *rp = addrinfo_result; rp != nullptr; rp = rp->ai_next)
+        {
+#if defined(SOCK_CLOEXEC)
+            const int flags = SOCK_CLOEXEC;
+#else
+            const int flags = 0;
+#endif
+            socket_ = ::socket(rp->ai_family, rp->ai_socktype | flags, rp->ai_protocol);
+            if (socket_ == -1)
+            {
+                last_errno = errno;
+                continue;
+            }
+            rv = ::connect(socket_, rp->ai_addr, rp->ai_addrlen);
+            if (rv == 0)
+            {
+                break;
+            }
+            last_errno = errno;
+            ::close(socket_);
+            socket_ = -1;
+        }
+        ::freeaddrinfo(addrinfo_result);
+        if (socket_ == -1)
+        {
+            throw_spdlog_ex("::connect failed", last_errno);
+        }
+
+        // set TCP_NODELAY
+        int enable_flag = 1;
+        ::setsockopt(socket_, IPPROTO_TCP, TCP_NODELAY, reinterpret_cast<char *>(&enable_flag), sizeof(enable_flag));
+
+        // prevent sigpipe on systems where MSG_NOSIGNAL is not available
+#if defined(SO_NOSIGPIPE) && !defined(MSG_NOSIGNAL)
+        ::setsockopt(socket_, SOL_SOCKET, SO_NOSIGPIPE, reinterpret_cast<char *>(&enable_flag), sizeof(enable_flag));
+#endif
+
+#if !defined(SO_NOSIGPIPE) && !defined(MSG_NOSIGNAL)
+#    error "tcp_sink would raise SIGPIPE since neither SO_NOSIGPIPE nor MSG_NOSIGNAL are available"
+#endif
+    }
+
+    // Send exactly n_bytes of the given data.
+    // On error close the connection and throw.
+    void send(const char *data, size_t n_bytes)
+    {
+        size_t bytes_sent = 0;
+        while (bytes_sent < n_bytes)
+        {
+#if defined(MSG_NOSIGNAL)
+            const int send_flags = MSG_NOSIGNAL;
+#else
+            const int send_flags = 0;
+#endif
+            auto write_result = ::send(socket_, data + bytes_sent, n_bytes - bytes_sent, send_flags);
+            if (write_result < 0)
+            {
+                close();
+                throw_spdlog_ex("write(2) failed", errno);
+            }
+
+            if (write_result == 0) // (probably should not happen but in any case..)
+            {
+                break;
+            }
+            bytes_sent += static_cast<size_t>(write_result);
+        }
+    }
+};
+} // namespace details
+} // namespace spdlog
diff --git a/3rdparty/spdlog/src/include/spdlog/details/thread_pool-inl.h b/3rdparty/spdlog/src/include/spdlog/details/thread_pool-inl.h
new file mode 100644
index 00000000..dbd424ff
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/details/thread_pool-inl.h
@@ -0,0 +1,137 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#ifndef SPDLOG_HEADER_ONLY
+#    include <spdlog/details/thread_pool.h>
+#endif
+
+#include <spdlog/common.h>
+#include <cassert>
+
+namespace spdlog {
+namespace details {
+
+SPDLOG_INLINE thread_pool::thread_pool(
+    size_t q_max_items, size_t threads_n, std::function<void()> on_thread_start, std::function<void()> on_thread_stop)
+    : q_(q_max_items)
+{
+    if (threads_n == 0 || threads_n > 1000)
+    {
+        throw_spdlog_ex("spdlog::thread_pool(): invalid threads_n param (valid "
+                        "range is 1-1000)");
+    }
+    for (size_t i = 0; i < threads_n; i++)
+    {
+        threads_.emplace_back([this, on_thread_start, on_thread_stop] {
+            on_thread_start();
+            this->thread_pool::worker_loop_();
+            on_thread_stop();
+        });
+    }
+}
+
+SPDLOG_INLINE thread_pool::thread_pool(size_t q_max_items, size_t threads_n, std::function<void()> on_thread_start)
+    : thread_pool(q_max_items, threads_n, on_thread_start, [] {})
+{}
+
+SPDLOG_INLINE thread_pool::thread_pool(size_t q_max_items, size_t threads_n)
+    : thread_pool(
+          q_max_items, threads_n, [] {}, [] {})
+{}
+
+// message all threads to terminate gracefully join them
+SPDLOG_INLINE thread_pool::~thread_pool()
+{
+    SPDLOG_TRY
+    {
+        for (size_t i = 0; i < threads_.size(); i++)
+        {
+            post_async_msg_(async_msg(async_msg_type::terminate), async_overflow_policy::block);
+        }
+
+        for (auto &t : threads_)
+        {
+            t.join();
+        }
+    }
+    SPDLOG_CATCH_STD
+}
+
+void SPDLOG_INLINE thread_pool::post_log(async_logger_ptr &&worker_ptr, const details::log_msg &msg, async_overflow_policy overflow_policy)
+{
+    async_msg async_m(std::move(worker_ptr), async_msg_type::log, msg);
+    post_async_msg_(std::move(async_m), overflow_policy);
+}
+
+void SPDLOG_INLINE thread_pool::post_flush(async_logger_ptr &&worker_ptr, async_overflow_policy overflow_policy)
+{
+    post_async_msg_(async_msg(std::move(worker_ptr), async_msg_type::flush), overflow_policy);
+}
+
+size_t SPDLOG_INLINE thread_pool::overrun_counter()
+{
+    return q_.overrun_counter();
+}
+
+void SPDLOG_INLINE thread_pool::reset_overrun_counter()
+{
+    q_.reset_overrun_counter();
+}
+
+size_t SPDLOG_INLINE thread_pool::queue_size()
+{
+    return q_.size();
+}
+
+void SPDLOG_INLINE thread_pool::post_async_msg_(async_msg &&new_msg, async_overflow_policy overflow_policy)
+{
+    if (overflow_policy == async_overflow_policy::block)
+    {
+        q_.enqueue(std::move(new_msg));
+    }
+    else
+    {
+        q_.enqueue_nowait(std::move(new_msg));
+    }
+}
+
+void SPDLOG_INLINE thread_pool::worker_loop_()
+{
+    while (process_next_msg_()) {}
+}
+
+// process next message in the queue
+// return true if this thread should still be active (while no terminate msg
+// was received)
+bool SPDLOG_INLINE thread_pool::process_next_msg_()
+{
+    async_msg incoming_async_msg;
+    q_.dequeue(incoming_async_msg);
+
+    switch (incoming_async_msg.msg_type)
+    {
+    case async_msg_type::log: {
+        incoming_async_msg.worker_ptr->backend_sink_it_(incoming_async_msg);
+        return true;
+    }
+    case async_msg_type::flush: {
+        incoming_async_msg.worker_ptr->backend_flush_();
+        return true;
+    }
+
+    case async_msg_type::terminate: {
+        return false;
+    }
+
+    default: {
+        assert(false);
+    }
+    }
+
+    return true;
+}
+
+} // namespace details
+} // namespace spdlog
diff --git a/3rdparty/spdlog/src/include/spdlog/details/thread_pool.h b/3rdparty/spdlog/src/include/spdlog/details/thread_pool.h
new file mode 100644
index 00000000..52c569b8
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/details/thread_pool.h
@@ -0,0 +1,122 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#include <spdlog/details/log_msg_buffer.h>
+#include <spdlog/details/mpmc_blocking_q.h>
+#include <spdlog/details/os.h>
+
+#include <chrono>
+#include <memory>
+#include <thread>
+#include <vector>
+#include <functional>
+
+namespace spdlog {
+class async_logger;
+
+namespace details {
+
+using async_logger_ptr = std::shared_ptr<spdlog::async_logger>;
+
+enum class async_msg_type
+{
+    log,
+    flush,
+    terminate
+};
+
+// Async msg to move to/from the queue
+// Movable only. should never be copied
+struct async_msg : log_msg_buffer
+{
+    async_msg_type msg_type{async_msg_type::log};
+    async_logger_ptr worker_ptr;
+
+    async_msg() = default;
+    ~async_msg() = default;
+
+    // should only be moved in or out of the queue..
+    async_msg(const async_msg &) = delete;
+
+// support for vs2013 move
+#if defined(_MSC_VER) && _MSC_VER <= 1800
+    async_msg(async_msg &&other)
+        : log_msg_buffer(std::move(other))
+        , msg_type(other.msg_type)
+        , worker_ptr(std::move(other.worker_ptr))
+    {}
+
+    async_msg &operator=(async_msg &&other)
+    {
+        *static_cast<log_msg_buffer *>(this) = std::move(other);
+        msg_type = other.msg_type;
+        worker_ptr = std::move(other.worker_ptr);
+        return *this;
+    }
+#else // (_MSC_VER) && _MSC_VER <= 1800
+    async_msg(async_msg &&) = default;
+    async_msg &operator=(async_msg &&) = default;
+#endif
+
+    // construct from log_msg with given type
+    async_msg(async_logger_ptr &&worker, async_msg_type the_type, const details::log_msg &m)
+        : log_msg_buffer{m}
+        , msg_type{the_type}
+        , worker_ptr{std::move(worker)}
+    {}
+
+    async_msg(async_logger_ptr &&worker, async_msg_type the_type)
+        : log_msg_buffer{}
+        , msg_type{the_type}
+        , worker_ptr{std::move(worker)}
+    {}
+
+    explicit async_msg(async_msg_type the_type)
+        : async_msg{nullptr, the_type}
+    {}
+};
+
+class SPDLOG_API thread_pool
+{
+public:
+    using item_type = async_msg;
+    using q_type = details::mpmc_blocking_queue<item_type>;
+
+    thread_pool(size_t q_max_items, size_t threads_n, std::function<void()> on_thread_start, std::function<void()> on_thread_stop);
+    thread_pool(size_t q_max_items, size_t threads_n, std::function<void()> on_thread_start);
+    thread_pool(size_t q_max_items, size_t threads_n);
+
+    // message all threads to terminate gracefully and join them
+    ~thread_pool();
+
+    thread_pool(const thread_pool &) = delete;
+    thread_pool &operator=(thread_pool &&) = delete;
+
+    void post_log(async_logger_ptr &&worker_ptr, const details::log_msg &msg, async_overflow_policy overflow_policy);
+    void post_flush(async_logger_ptr &&worker_ptr, async_overflow_policy overflow_policy);
+    size_t overrun_counter();
+    void reset_overrun_counter();
+    size_t queue_size();
+
+private:
+    q_type q_;
+
+    std::vector<std::thread> threads_;
+
+    void post_async_msg_(async_msg &&new_msg, async_overflow_policy overflow_policy);
+    void worker_loop_();
+
+    // process next message in the queue
+    // return true if this thread should still be active (while no terminate msg
+    // was received)
+    bool process_next_msg_();
+};
+
+} // namespace details
+} // namespace spdlog
+
+#ifdef SPDLOG_HEADER_ONLY
+#    include "thread_pool-inl.h"
+#endif
diff --git a/3rdparty/spdlog/src/include/spdlog/details/udp_client-windows.h b/3rdparty/spdlog/src/include/spdlog/details/udp_client-windows.h
new file mode 100644
index 00000000..10894ee6
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/details/udp_client-windows.h
@@ -0,0 +1,113 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+// Helper RAII over winsock udp client socket.
+// Will throw on construction if socket creation failed.
+
+#include <spdlog/common.h>
+#include <spdlog/details/os.h>
+#include <spdlog/details/windows_include.h>
+#include <winsock2.h>
+#include <ws2tcpip.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string>
+
+#if defined(_MSC_VER)
+#    pragma comment(lib, "Ws2_32.lib")
+#    pragma comment(lib, "Mswsock.lib")
+#    pragma comment(lib, "AdvApi32.lib")
+#endif
+
+namespace spdlog {
+namespace details {
+class udp_client
+{
+    static constexpr int TX_BUFFER_SIZE = 1024 * 10;
+    SOCKET socket_ = INVALID_SOCKET;
+    sockaddr_in addr_ = {};
+
+    static void init_winsock_()
+    {
+        WSADATA wsaData;
+        auto rv = ::WSAStartup(MAKEWORD(2, 2), &wsaData);
+        if (rv != 0)
+        {
+            throw_winsock_error_("WSAStartup failed", ::WSAGetLastError());
+        }
+    }
+
+    static void throw_winsock_error_(const std::string &msg, int last_error)
+    {
+        char buf[512];
+        ::FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, last_error,
+            MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), buf, (sizeof(buf) / sizeof(char)), NULL);
+
+        throw_spdlog_ex(fmt_lib::format("udp_sink - {}: {}", msg, buf));
+    }
+
+    void cleanup_()
+    {
+        if (socket_ != INVALID_SOCKET)
+        {
+            ::closesocket(socket_);
+        }
+        socket_ = INVALID_SOCKET;
+        ::WSACleanup();
+    }
+
+public:
+    udp_client(const std::string &host, uint16_t port)
+    {
+        init_winsock_();
+
+        addr_.sin_family = PF_INET;
+        addr_.sin_port = htons(port);
+        addr_.sin_addr.s_addr = INADDR_ANY;
+        if (InetPtonA(PF_INET, host.c_str(), &addr_.sin_addr.s_addr) != 1)
+        {
+            int last_error = ::WSAGetLastError();
+            ::WSACleanup();
+            throw_winsock_error_("error: Invalid address!", last_error);
+        }
+
+        socket_ = ::socket(PF_INET, SOCK_DGRAM, 0);
+        if (socket_ == INVALID_SOCKET)
+        {
+            int last_error = ::WSAGetLastError();
+            ::WSACleanup();
+            throw_winsock_error_("error: Create Socket failed", last_error);
+        }
+
+        int option_value = TX_BUFFER_SIZE;
+        if (::setsockopt(socket_, SOL_SOCKET, SO_SNDBUF, reinterpret_cast<const char *>(&option_value), sizeof(option_value)) < 0)
+        {
+            int last_error = ::WSAGetLastError();
+            cleanup_();
+            throw_winsock_error_("error: setsockopt(SO_SNDBUF) Failed!", last_error);
+        }
+    }
+
+    ~udp_client()
+    {
+        cleanup_();
+    }
+
+    SOCKET fd() const
+    {
+        return socket_;
+    }
+
+    void send(const char *data, size_t n_bytes)
+    {
+        socklen_t tolen = sizeof(struct sockaddr);
+        if (::sendto(socket_, data, static_cast<int>(n_bytes), 0, (struct sockaddr *)&addr_, tolen) == -1)
+        {
+            throw_spdlog_ex("sendto(2) failed", errno);
+        }
+    }
+};
+} // namespace details
+} // namespace spdlog
diff --git a/3rdparty/spdlog/src/include/spdlog/details/udp_client.h b/3rdparty/spdlog/src/include/spdlog/details/udp_client.h
new file mode 100644
index 00000000..2db5b89e
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/details/udp_client.h
@@ -0,0 +1,94 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+// Helper RAII over unix udp client socket.
+// Will throw on construction if the socket creation failed.
+
+#ifdef _WIN32
+#    error "include udp_client-windows.h instead"
+#endif
+
+#include <spdlog/common.h>
+#include <spdlog/details/os.h>
+
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <unistd.h>
+#include <netdb.h>
+#include <netinet/udp.h>
+
+#include <string>
+
+namespace spdlog {
+namespace details {
+
+class udp_client
+{
+    static constexpr int TX_BUFFER_SIZE = 1024 * 10;
+    int socket_ = -1;
+    struct sockaddr_in sockAddr_;
+
+    void cleanup_()
+    {
+        if (socket_ != -1)
+        {
+            ::close(socket_);
+            socket_ = -1;
+        }
+    }
+
+public:
+    udp_client(const std::string &host, uint16_t port)
+    {
+        socket_ = ::socket(PF_INET, SOCK_DGRAM, 0);
+        if (socket_ < 0)
+        {
+            throw_spdlog_ex("error: Create Socket Failed!");
+        }
+
+        int option_value = TX_BUFFER_SIZE;
+        if (::setsockopt(socket_, SOL_SOCKET, SO_SNDBUF, reinterpret_cast<const char *>(&option_value), sizeof(option_value)) < 0)
+        {
+            cleanup_();
+            throw_spdlog_ex("error: setsockopt(SO_SNDBUF) Failed!");
+        }
+
+        sockAddr_.sin_family = AF_INET;
+        sockAddr_.sin_port = htons(port);
+
+        if (::inet_aton(host.c_str(), &sockAddr_.sin_addr) == 0)
+        {
+            cleanup_();
+            throw_spdlog_ex("error: Invalid address!");
+        }
+
+        ::memset(sockAddr_.sin_zero, 0x00, sizeof(sockAddr_.sin_zero));
+    }
+
+    ~udp_client()
+    {
+        cleanup_();
+    }
+
+    int fd() const
+    {
+        return socket_;
+    }
+
+    // Send exactly n_bytes of the given data.
+    // On error close the connection and throw.
+    void send(const char *data, size_t n_bytes)
+    {
+        ssize_t toslen = 0;
+        socklen_t tolen = sizeof(struct sockaddr);
+        if ((toslen = ::sendto(socket_, data, n_bytes, 0, (struct sockaddr *)&sockAddr_, tolen)) == -1)
+        {
+            throw_spdlog_ex("sendto(2) failed", errno);
+        }
+    }
+};
+} // namespace details
+} // namespace spdlog
diff --git a/3rdparty/spdlog/src/include/spdlog/details/windows_include.h b/3rdparty/spdlog/src/include/spdlog/details/windows_include.h
new file mode 100644
index 00000000..a92390b9
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/details/windows_include.h
@@ -0,0 +1,11 @@
+#pragma once
+
+#ifndef NOMINMAX
+#    define NOMINMAX // prevent windows redefining min/max
+#endif
+
+#ifndef WIN32_LEAN_AND_MEAN
+#    define WIN32_LEAN_AND_MEAN
+#endif
+
+#include <windows.h>
diff --git a/3rdparty/spdlog/src/include/spdlog/fmt/bin_to_hex.h b/3rdparty/spdlog/src/include/spdlog/fmt/bin_to_hex.h
new file mode 100644
index 00000000..1cb51ce6
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/fmt/bin_to_hex.h
@@ -0,0 +1,248 @@
+//
+// Copyright(c) 2015 Gabi Melman.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+//
+
+#pragma once
+
+#include <cctype>
+#include <spdlog/common.h>
+
+#if defined(__has_include)
+#    if __has_include(<version>)
+#        include <version>
+#    endif
+#endif
+
+#if __cpp_lib_span >= 202002L
+#    include <span>
+#endif
+
+//
+// Support for logging binary data as hex
+// format flags, any combination of the following:
+// {:X} - print in uppercase.
+// {:s} - don't separate each byte with space.
+// {:p} - don't print the position on each line start.
+// {:n} - don't split the output to lines.
+// {:a} - show ASCII if :n is not set
+
+//
+// Examples:
+//
+// std::vector<char> v(200, 0x0b);
+// logger->info("Some buffer {}", spdlog::to_hex(v));
+// char buf[128];
+// logger->info("Some buffer {:X}", spdlog::to_hex(std::begin(buf), std::end(buf)));
+// logger->info("Some buffer {:X}", spdlog::to_hex(std::begin(buf), std::end(buf), 16));
+
+namespace spdlog {
+namespace details {
+
+template<typename It>
+class dump_info
+{
+public:
+    dump_info(It range_begin, It range_end, size_t size_per_line)
+        : begin_(range_begin)
+        , end_(range_end)
+        , size_per_line_(size_per_line)
+    {}
+
+    // do not use begin() and end() to avoid collision with fmt/ranges
+    It get_begin() const
+    {
+        return begin_;
+    }
+    It get_end() const
+    {
+        return end_;
+    }
+    size_t size_per_line() const
+    {
+        return size_per_line_;
+    }
+
+private:
+    It begin_, end_;
+    size_t size_per_line_;
+};
+} // namespace details
+
+// create a dump_info that wraps the given container
+template<typename Container>
+inline details::dump_info<typename Container::const_iterator> to_hex(const Container &container, size_t size_per_line = 32)
+{
+    static_assert(sizeof(typename Container::value_type) == 1, "sizeof(Container::value_type) != 1");
+    using Iter = typename Container::const_iterator;
+    return details::dump_info<Iter>(std::begin(container), std::end(container), size_per_line);
+}
+
+#if __cpp_lib_span >= 202002L
+
+template<typename Value, size_t Extent>
+inline details::dump_info<typename std::span<Value, Extent>::iterator> to_hex(
+    const std::span<Value, Extent> &container, size_t size_per_line = 32)
+{
+    using Container = std::span<Value, Extent>;
+    static_assert(sizeof(typename Container::value_type) == 1, "sizeof(Container::value_type) != 1");
+    using Iter = typename Container::iterator;
+    return details::dump_info<Iter>(std::begin(container), std::end(container), size_per_line);
+}
+
+#endif
+
+// create dump_info from ranges
+template<typename It>
+inline details::dump_info<It> to_hex(const It range_begin, const It range_end, size_t size_per_line = 32)
+{
+    return details::dump_info<It>(range_begin, range_end, size_per_line);
+}
+
+} // namespace spdlog
+
+namespace
+#ifdef SPDLOG_USE_STD_FORMAT
+    std
+#else
+    fmt
+#endif
+{
+
+template<typename T>
+struct formatter<spdlog::details::dump_info<T>, char>
+{
+    const char delimiter = ' ';
+    bool put_newlines = true;
+    bool put_delimiters = true;
+    bool use_uppercase = false;
+    bool put_positions = true; // position on start of each line
+    bool show_ascii = false;
+
+    // parse the format string flags
+    template<typename ParseContext>
+    SPDLOG_CONSTEXPR_FUNC auto parse(ParseContext &ctx) -> decltype(ctx.begin())
+    {
+        auto it = ctx.begin();
+        while (it != ctx.end() && *it != '}')
+        {
+            switch (*it)
+            {
+            case 'X':
+                use_uppercase = true;
+                break;
+            case 's':
+                put_delimiters = false;
+                break;
+            case 'p':
+                put_positions = false;
+                break;
+            case 'n':
+                put_newlines = false;
+                show_ascii = false;
+                break;
+            case 'a':
+                if (put_newlines)
+                {
+                    show_ascii = true;
+                }
+                break;
+            }
+
+            ++it;
+        }
+        return it;
+    }
+
+    // format the given bytes range as hex
+    template<typename FormatContext, typename Container>
+    auto format(const spdlog::details::dump_info<Container> &the_range, FormatContext &ctx) -> decltype(ctx.out())
+    {
+        SPDLOG_CONSTEXPR const char *hex_upper = "0123456789ABCDEF";
+        SPDLOG_CONSTEXPR const char *hex_lower = "0123456789abcdef";
+        const char *hex_chars = use_uppercase ? hex_upper : hex_lower;
+
+#if !defined(SPDLOG_USE_STD_FORMAT) && FMT_VERSION < 60000
+        auto inserter = ctx.begin();
+#else
+        auto inserter = ctx.out();
+#endif
+
+        int size_per_line = static_cast<int>(the_range.size_per_line());
+        auto start_of_line = the_range.get_begin();
+        for (auto i = the_range.get_begin(); i != the_range.get_end(); i++)
+        {
+            auto ch = static_cast<unsigned char>(*i);
+
+            if (put_newlines && (i == the_range.get_begin() || i - start_of_line >= size_per_line))
+            {
+                if (show_ascii && i != the_range.get_begin())
+                {
+                    *inserter++ = delimiter;
+                    *inserter++ = delimiter;
+                    for (auto j = start_of_line; j < i; j++)
+                    {
+                        auto pc = static_cast<unsigned char>(*j);
+                        *inserter++ = std::isprint(pc) ? static_cast<char>(*j) : '.';
+                    }
+                }
+
+                put_newline(inserter, static_cast<size_t>(i - the_range.get_begin()));
+
+                // put first byte without delimiter in front of it
+                *inserter++ = hex_chars[(ch >> 4) & 0x0f];
+                *inserter++ = hex_chars[ch & 0x0f];
+                start_of_line = i;
+                continue;
+            }
+
+            if (put_delimiters && i != the_range.get_begin())
+            {
+                *inserter++ = delimiter;
+            }
+
+            *inserter++ = hex_chars[(ch >> 4) & 0x0f];
+            *inserter++ = hex_chars[ch & 0x0f];
+        }
+        if (show_ascii) // add ascii to last line
+        {
+            if (the_range.get_end() - the_range.get_begin() > size_per_line)
+            {
+                auto blank_num = size_per_line - (the_range.get_end() - start_of_line);
+                while (blank_num-- > 0)
+                {
+                    *inserter++ = delimiter;
+                    *inserter++ = delimiter;
+                    if (put_delimiters)
+                    {
+                        *inserter++ = delimiter;
+                    }
+                }
+            }
+            *inserter++ = delimiter;
+            *inserter++ = delimiter;
+            for (auto j = start_of_line; j != the_range.get_end(); j++)
+            {
+                auto pc = static_cast<unsigned char>(*j);
+                *inserter++ = std::isprint(pc) ? static_cast<char>(*j) : '.';
+            }
+        }
+        return inserter;
+    }
+
+    // put newline(and position header)
+    template<typename It>
+    void put_newline(It inserter, std::size_t pos)
+    {
+#ifdef _WIN32
+        *inserter++ = '\r';
+#endif
+        *inserter++ = '\n';
+
+        if (put_positions)
+        {
+            spdlog::fmt_lib::format_to(inserter, SPDLOG_FMT_STRING("{:04X}: "), pos);
+        }
+    }
+};
+} // namespace std
diff --git a/3rdparty/spdlog/src/include/spdlog/fmt/bundled/args.h b/3rdparty/spdlog/src/include/spdlog/fmt/bundled/args.h
new file mode 100644
index 00000000..6160d10e
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/fmt/bundled/args.h
@@ -0,0 +1,258 @@
+// Formatting library for C++ - dynamic format arguments
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#ifndef FMT_ARGS_H_
+#define FMT_ARGS_H_
+
+#include <functional> // std::reference_wrapper
+#include <memory>     // std::unique_ptr
+#include <vector>
+
+#include "core.h"
+
+FMT_BEGIN_NAMESPACE
+
+namespace detail {
+
+template<typename T>
+struct is_reference_wrapper : std::false_type
+{};
+template<typename T>
+struct is_reference_wrapper<std::reference_wrapper<T>> : std::true_type
+{};
+
+template<typename T>
+const T &unwrap(const T &v)
+{
+    return v;
+}
+template<typename T>
+const T &unwrap(const std::reference_wrapper<T> &v)
+{
+    return static_cast<const T &>(v);
+}
+
+class dynamic_arg_list
+{
+    // Workaround for clang's -Wweak-vtables. Unlike for regular classes, for
+    // templates it doesn't complain about inability to deduce single translation
+    // unit for placing vtable. So storage_node_base is made a fake template.
+    template<typename = void>
+    struct node
+    {
+        virtual ~node() = default;
+        std::unique_ptr<node<>> next;
+    };
+
+    template<typename T>
+    struct typed_node : node<>
+    {
+        T value;
+
+        template<typename Arg>
+        FMT_CONSTEXPR typed_node(const Arg &arg)
+            : value(arg)
+        {}
+
+        template<typename Char>
+        FMT_CONSTEXPR typed_node(const basic_string_view<Char> &arg)
+            : value(arg.data(), arg.size())
+        {}
+    };
+
+    std::unique_ptr<node<>> head_;
+
+public:
+    template<typename T, typename Arg>
+    const T &push(const Arg &arg)
+    {
+        auto new_node = std::unique_ptr<typed_node<T>>(new typed_node<T>(arg));
+        auto &value = new_node->value;
+        new_node->next = std::move(head_);
+        head_ = std::move(new_node);
+        return value;
+    }
+};
+} // namespace detail
+
+/**
+  \rst
+  A dynamic version of `fmt::format_arg_store`.
+  It's equipped with a storage to potentially temporary objects which lifetimes
+  could be shorter than the format arguments object.
+
+  It can be implicitly converted into `~fmt::basic_format_args` for passing
+  into type-erased formatting functions such as `~fmt::vformat`.
+  \endrst
+ */
+template<typename Context>
+class dynamic_format_arg_store
+#if FMT_GCC_VERSION && FMT_GCC_VERSION < 409
+    // Workaround a GCC template argument substitution bug.
+    : public basic_format_args<Context>
+#endif
+{
+private:
+    using char_type = typename Context::char_type;
+
+    template<typename T>
+    struct need_copy
+    {
+        static constexpr detail::type mapped_type = detail::mapped_type_constant<T, Context>::value;
+
+        enum
+        {
+            value = !(detail::is_reference_wrapper<T>::value || std::is_same<T, basic_string_view<char_type>>::value ||
+                      std::is_same<T, detail::std_string_view<char_type>>::value ||
+                      (mapped_type != detail::type::cstring_type && mapped_type != detail::type::string_type &&
+                          mapped_type != detail::type::custom_type))
+        };
+    };
+
+    template<typename T>
+    using stored_type =
+        conditional_t<std::is_convertible<T, std::basic_string<char_type>>::value && !detail::is_reference_wrapper<T>::value,
+            std::basic_string<char_type>, T>;
+
+    // Storage of basic_format_arg must be contiguous.
+    std::vector<basic_format_arg<Context>> data_;
+    std::vector<detail::named_arg_info<char_type>> named_info_;
+
+    // Storage of arguments not fitting into basic_format_arg must grow
+    // without relocation because items in data_ refer to it.
+    detail::dynamic_arg_list dynamic_args_;
+
+    friend class basic_format_args<Context>;
+
+    unsigned long long get_types() const
+    {
+        return detail::is_unpacked_bit | data_.size() |
+               (named_info_.empty() ? 0ULL : static_cast<unsigned long long>(detail::has_named_args_bit));
+    }
+
+    const basic_format_arg<Context> *data() const
+    {
+        return named_info_.empty() ? data_.data() : data_.data() + 1;
+    }
+
+    template<typename T>
+    void emplace_arg(const T &arg)
+    {
+        data_.emplace_back(detail::make_arg<Context>(arg));
+    }
+
+    template<typename T>
+    void emplace_arg(const detail::named_arg<char_type, T> &arg)
+    {
+        if (named_info_.empty())
+        {
+            constexpr const detail::named_arg_info<char_type> *zero_ptr{nullptr};
+            data_.insert(data_.begin(), {zero_ptr, 0});
+        }
+        data_.emplace_back(detail::make_arg<Context>(detail::unwrap(arg.value)));
+        auto pop_one = [](std::vector<basic_format_arg<Context>> *data) { data->pop_back(); };
+        std::unique_ptr<std::vector<basic_format_arg<Context>>, decltype(pop_one)> guard{&data_, pop_one};
+        named_info_.push_back({arg.name, static_cast<int>(data_.size() - 2u)});
+        data_[0].value_.named_args = {named_info_.data(), named_info_.size()};
+        guard.release();
+    }
+
+public:
+    constexpr dynamic_format_arg_store() = default;
+
+    /**
+      \rst
+      Adds an argument into the dynamic store for later passing to a formatting
+      function.
+
+      Note that custom types and string types (but not string views) are copied
+      into the store dynamically allocating memory if necessary.
+
+      **Example**::
+
+        fmt::dynamic_format_arg_store<fmt::format_context> store;
+        store.push_back(42);
+        store.push_back("abc");
+        store.push_back(1.5f);
+        std::string result = fmt::vformat("{} and {} and {}", store);
+      \endrst
+    */
+    template<typename T>
+    void push_back(const T &arg)
+    {
+        if (detail::const_check(need_copy<T>::value))
+            emplace_arg(dynamic_args_.push<stored_type<T>>(arg));
+        else
+            emplace_arg(detail::unwrap(arg));
+    }
+
+    /**
+      \rst
+      Adds a reference to the argument into the dynamic store for later passing to
+      a formatting function.
+
+      **Example**::
+
+        fmt::dynamic_format_arg_store<fmt::format_context> store;
+        char band[] = "Rolling Stones";
+        store.push_back(std::cref(band));
+        band[9] = 'c'; // Changing str affects the output.
+        std::string result = fmt::vformat("{}", store);
+        // result == "Rolling Scones"
+      \endrst
+    */
+    template<typename T>
+    void push_back(std::reference_wrapper<T> arg)
+    {
+        static_assert(need_copy<T>::value, "objects of built-in types and string views are always copied");
+        emplace_arg(arg.get());
+    }
+
+    /**
+      Adds named argument into the dynamic store for later passing to a formatting
+      function. ``std::reference_wrapper`` is supported to avoid copying of the
+      argument. The name is always copied into the store.
+    */
+    template<typename T>
+    void push_back(const detail::named_arg<char_type, T> &arg)
+    {
+        const char_type *arg_name = dynamic_args_.push<std::basic_string<char_type>>(arg.name).c_str();
+        if (detail::const_check(need_copy<T>::value))
+        {
+            emplace_arg(fmt::arg(arg_name, dynamic_args_.push<stored_type<T>>(arg.value)));
+        }
+        else
+        {
+            emplace_arg(fmt::arg(arg_name, arg.value));
+        }
+    }
+
+    /** Erase all elements from the store */
+    void clear()
+    {
+        data_.clear();
+        named_info_.clear();
+        dynamic_args_ = detail::dynamic_arg_list();
+    }
+
+    /**
+      \rst
+      Reserves space to store at least *new_cap* arguments including
+      *new_cap_named* named arguments.
+      \endrst
+    */
+    void reserve(size_t new_cap, size_t new_cap_named)
+    {
+        FMT_ASSERT(new_cap >= new_cap_named, "Set of arguments includes set of named arguments");
+        data_.reserve(new_cap);
+        named_info_.reserve(new_cap_named);
+    }
+};
+
+FMT_END_NAMESPACE
+
+#endif // FMT_ARGS_H_
diff --git a/3rdparty/spdlog/src/include/spdlog/fmt/bundled/chrono.h b/3rdparty/spdlog/src/include/spdlog/fmt/bundled/chrono.h
new file mode 100644
index 00000000..debf1e4e
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/fmt/bundled/chrono.h
@@ -0,0 +1,2512 @@
+// Formatting library for C++ - chrono support
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#ifndef FMT_CHRONO_H_
+#define FMT_CHRONO_H_
+
+#include <algorithm>
+#include <chrono>
+#include <cmath>   // std::isfinite
+#include <cstring> // std::memcpy
+#include <ctime>
+#include <iterator>
+#include <locale>
+#include <ostream>
+#include <type_traits>
+
+#include "format.h"
+
+FMT_BEGIN_NAMESPACE
+
+// Enable tzset.
+#ifndef FMT_USE_TZSET
+// UWP doesn't provide _tzset.
+#    if FMT_HAS_INCLUDE("winapifamily.h")
+#        include <winapifamily.h>
+#    endif
+#    if defined(_WIN32) && (!defined(WINAPI_FAMILY) || (WINAPI_FAMILY == WINAPI_FAMILY_DESKTOP_APP))
+#        define FMT_USE_TZSET 1
+#    else
+#        define FMT_USE_TZSET 0
+#    endif
+#endif
+
+// Enable safe chrono durations, unless explicitly disabled.
+#ifndef FMT_SAFE_DURATION_CAST
+#    define FMT_SAFE_DURATION_CAST 1
+#endif
+#if FMT_SAFE_DURATION_CAST
+
+// For conversion between std::chrono::durations without undefined
+// behaviour or erroneous results.
+// This is a stripped down version of duration_cast, for inclusion in fmt.
+// See https://github.com/pauldreik/safe_duration_cast
+//
+// Copyright Paul Dreik 2019
+namespace safe_duration_cast {
+
+template<typename To, typename From,
+    FMT_ENABLE_IF(!std::is_same<From, To>::value && std::numeric_limits<From>::is_signed == std::numeric_limits<To>::is_signed)>
+FMT_CONSTEXPR To lossless_integral_conversion(const From from, int &ec)
+{
+    ec = 0;
+    using F = std::numeric_limits<From>;
+    using T = std::numeric_limits<To>;
+    static_assert(F::is_integer, "From must be integral");
+    static_assert(T::is_integer, "To must be integral");
+
+    // A and B are both signed, or both unsigned.
+    if (detail::const_check(F::digits <= T::digits))
+    {
+        // From fits in To without any problem.
+    }
+    else
+    {
+        // From does not always fit in To, resort to a dynamic check.
+        if (from < (T::min)() || from > (T::max)())
+        {
+            // outside range.
+            ec = 1;
+            return {};
+        }
+    }
+    return static_cast<To>(from);
+}
+
+/**
+ * converts From to To, without loss. If the dynamic value of from
+ * can't be converted to To without loss, ec is set.
+ */
+template<typename To, typename From,
+    FMT_ENABLE_IF(!std::is_same<From, To>::value && std::numeric_limits<From>::is_signed != std::numeric_limits<To>::is_signed)>
+FMT_CONSTEXPR To lossless_integral_conversion(const From from, int &ec)
+{
+    ec = 0;
+    using F = std::numeric_limits<From>;
+    using T = std::numeric_limits<To>;
+    static_assert(F::is_integer, "From must be integral");
+    static_assert(T::is_integer, "To must be integral");
+
+    if (detail::const_check(F::is_signed && !T::is_signed))
+    {
+        // From may be negative, not allowed!
+        if (fmt::detail::is_negative(from))
+        {
+            ec = 1;
+            return {};
+        }
+        // From is positive. Can it always fit in To?
+        if (detail::const_check(F::digits > T::digits) && from > static_cast<From>(detail::max_value<To>()))
+        {
+            ec = 1;
+            return {};
+        }
+    }
+
+    if (detail::const_check(!F::is_signed && T::is_signed && F::digits >= T::digits) && from > static_cast<From>(detail::max_value<To>()))
+    {
+        ec = 1;
+        return {};
+    }
+    return static_cast<To>(from); // Lossless conversion.
+}
+
+template<typename To, typename From, FMT_ENABLE_IF(std::is_same<From, To>::value)>
+FMT_CONSTEXPR To lossless_integral_conversion(const From from, int &ec)
+{
+    ec = 0;
+    return from;
+} // function
+
+// clang-format off
+/**
+ * converts From to To if possible, otherwise ec is set.
+ *
+ * input                            |    output
+ * ---------------------------------|---------------
+ * NaN                              | NaN
+ * Inf                              | Inf
+ * normal, fits in output           | converted (possibly lossy)
+ * normal, does not fit in output   | ec is set
+ * subnormal                        | best effort
+ * -Inf                             | -Inf
+ */
+// clang-format on
+template<typename To, typename From, FMT_ENABLE_IF(!std::is_same<From, To>::value)>
+FMT_CONSTEXPR To safe_float_conversion(const From from, int &ec)
+{
+    ec = 0;
+    using T = std::numeric_limits<To>;
+    static_assert(std::is_floating_point<From>::value, "From must be floating");
+    static_assert(std::is_floating_point<To>::value, "To must be floating");
+
+    // catch the only happy case
+    if (std::isfinite(from))
+    {
+        if (from >= T::lowest() && from <= (T::max)())
+        {
+            return static_cast<To>(from);
+        }
+        // not within range.
+        ec = 1;
+        return {};
+    }
+
+    // nan and inf will be preserved
+    return static_cast<To>(from);
+} // function
+
+template<typename To, typename From, FMT_ENABLE_IF(std::is_same<From, To>::value)>
+FMT_CONSTEXPR To safe_float_conversion(const From from, int &ec)
+{
+    ec = 0;
+    static_assert(std::is_floating_point<From>::value, "From must be floating");
+    return from;
+}
+
+/**
+ * safe duration cast between integral durations
+ */
+template<typename To, typename FromRep, typename FromPeriod, FMT_ENABLE_IF(std::is_integral<FromRep>::value),
+    FMT_ENABLE_IF(std::is_integral<typename To::rep>::value)>
+To safe_duration_cast(std::chrono::duration<FromRep, FromPeriod> from, int &ec)
+{
+    using From = std::chrono::duration<FromRep, FromPeriod>;
+    ec = 0;
+    // the basic idea is that we need to convert from count() in the from type
+    // to count() in the To type, by multiplying it with this:
+    struct Factor : std::ratio_divide<typename From::period, typename To::period>
+    {};
+
+    static_assert(Factor::num > 0, "num must be positive");
+    static_assert(Factor::den > 0, "den must be positive");
+
+    // the conversion is like this: multiply from.count() with Factor::num
+    // /Factor::den and convert it to To::rep, all this without
+    // overflow/underflow. let's start by finding a suitable type that can hold
+    // both To, From and Factor::num
+    using IntermediateRep = typename std::common_type<typename From::rep, typename To::rep, decltype(Factor::num)>::type;
+
+    // safe conversion to IntermediateRep
+    IntermediateRep count = lossless_integral_conversion<IntermediateRep>(from.count(), ec);
+    if (ec)
+        return {};
+    // multiply with Factor::num without overflow or underflow
+    if (detail::const_check(Factor::num != 1))
+    {
+        const auto max1 = detail::max_value<IntermediateRep>() / Factor::num;
+        if (count > max1)
+        {
+            ec = 1;
+            return {};
+        }
+        const auto min1 = (std::numeric_limits<IntermediateRep>::min)() / Factor::num;
+        if (!std::is_unsigned<IntermediateRep>::value && count < min1)
+        {
+            ec = 1;
+            return {};
+        }
+        count *= Factor::num;
+    }
+
+    if (detail::const_check(Factor::den != 1))
+        count /= Factor::den;
+    auto tocount = lossless_integral_conversion<typename To::rep>(count, ec);
+    return ec ? To() : To(tocount);
+}
+
+/**
+ * safe duration_cast between floating point durations
+ */
+template<typename To, typename FromRep, typename FromPeriod, FMT_ENABLE_IF(std::is_floating_point<FromRep>::value),
+    FMT_ENABLE_IF(std::is_floating_point<typename To::rep>::value)>
+To safe_duration_cast(std::chrono::duration<FromRep, FromPeriod> from, int &ec)
+{
+    using From = std::chrono::duration<FromRep, FromPeriod>;
+    ec = 0;
+    if (std::isnan(from.count()))
+    {
+        // nan in, gives nan out. easy.
+        return To{std::numeric_limits<typename To::rep>::quiet_NaN()};
+    }
+    // maybe we should also check if from is denormal, and decide what to do about
+    // it.
+
+    // +-inf should be preserved.
+    if (std::isinf(from.count()))
+    {
+        return To{from.count()};
+    }
+
+    // the basic idea is that we need to convert from count() in the from type
+    // to count() in the To type, by multiplying it with this:
+    struct Factor : std::ratio_divide<typename From::period, typename To::period>
+    {};
+
+    static_assert(Factor::num > 0, "num must be positive");
+    static_assert(Factor::den > 0, "den must be positive");
+
+    // the conversion is like this: multiply from.count() with Factor::num
+    // /Factor::den and convert it to To::rep, all this without
+    // overflow/underflow. let's start by finding a suitable type that can hold
+    // both To, From and Factor::num
+    using IntermediateRep = typename std::common_type<typename From::rep, typename To::rep, decltype(Factor::num)>::type;
+
+    // force conversion of From::rep -> IntermediateRep to be safe,
+    // even if it will never happen be narrowing in this context.
+    IntermediateRep count = safe_float_conversion<IntermediateRep>(from.count(), ec);
+    if (ec)
+    {
+        return {};
+    }
+
+    // multiply with Factor::num without overflow or underflow
+    if (detail::const_check(Factor::num != 1))
+    {
+        constexpr auto max1 = detail::max_value<IntermediateRep>() / static_cast<IntermediateRep>(Factor::num);
+        if (count > max1)
+        {
+            ec = 1;
+            return {};
+        }
+        constexpr auto min1 = std::numeric_limits<IntermediateRep>::lowest() / static_cast<IntermediateRep>(Factor::num);
+        if (count < min1)
+        {
+            ec = 1;
+            return {};
+        }
+        count *= static_cast<IntermediateRep>(Factor::num);
+    }
+
+    // this can't go wrong, right? den>0 is checked earlier.
+    if (detail::const_check(Factor::den != 1))
+    {
+        using common_t = typename std::common_type<IntermediateRep, intmax_t>::type;
+        count /= static_cast<common_t>(Factor::den);
+    }
+
+    // convert to the to type, safely
+    using ToRep = typename To::rep;
+
+    const ToRep tocount = safe_float_conversion<ToRep>(count, ec);
+    if (ec)
+    {
+        return {};
+    }
+    return To{tocount};
+}
+} // namespace safe_duration_cast
+#endif
+
+// Prevents expansion of a preceding token as a function-style macro.
+// Usage: f FMT_NOMACRO()
+#define FMT_NOMACRO
+
+namespace detail {
+template<typename T = void>
+struct null
+{};
+inline null<> localtime_r FMT_NOMACRO(...)
+{
+    return null<>();
+}
+inline null<> localtime_s(...)
+{
+    return null<>();
+}
+inline null<> gmtime_r(...)
+{
+    return null<>();
+}
+inline null<> gmtime_s(...)
+{
+    return null<>();
+}
+
+inline const std::locale &get_classic_locale()
+{
+    static const auto &locale = std::locale::classic();
+    return locale;
+}
+
+template<typename CodeUnit>
+struct codecvt_result
+{
+    static constexpr const size_t max_size = 32;
+    CodeUnit buf[max_size];
+    CodeUnit *end;
+};
+template<typename CodeUnit>
+constexpr const size_t codecvt_result<CodeUnit>::max_size;
+
+template<typename CodeUnit>
+void write_codecvt(codecvt_result<CodeUnit> &out, string_view in_buf, const std::locale &loc)
+{
+#if FMT_CLANG_VERSION
+#    pragma clang diagnostic push
+#    pragma clang diagnostic ignored "-Wdeprecated"
+    auto &f = std::use_facet<std::codecvt<CodeUnit, char, std::mbstate_t>>(loc);
+#    pragma clang diagnostic pop
+#else
+    auto &f = std::use_facet<std::codecvt<CodeUnit, char, std::mbstate_t>>(loc);
+#endif
+    auto mb = std::mbstate_t();
+    const char *from_next = nullptr;
+    auto result = f.in(mb, in_buf.begin(), in_buf.end(), from_next, std::begin(out.buf), std::end(out.buf), out.end);
+    if (result != std::codecvt_base::ok)
+        FMT_THROW(format_error("failed to format time"));
+}
+
+template<typename OutputIt>
+auto write_encoded_tm_str(OutputIt out, string_view in, const std::locale &loc) -> OutputIt
+{
+    if (detail::is_utf8() && loc != get_classic_locale())
+    {
+        // char16_t and char32_t codecvts are broken in MSVC (linkage errors) and
+        // gcc-4.
+#if FMT_MSC_VERSION != 0 || (defined(__GLIBCXX__) && !defined(_GLIBCXX_USE_DUAL_ABI))
+        // The _GLIBCXX_USE_DUAL_ABI macro is always defined in libstdc++ from gcc-5
+        // and newer.
+        using code_unit = wchar_t;
+#else
+        using code_unit = char32_t;
+#endif
+
+        using unit_t = codecvt_result<code_unit>;
+        unit_t unit;
+        write_codecvt(unit, in, loc);
+        // In UTF-8 is used one to four one-byte code units.
+        auto &&buf = basic_memory_buffer<char, unit_t::max_size * 4>();
+        for (code_unit *p = unit.buf; p != unit.end; ++p)
+        {
+            uint32_t c = static_cast<uint32_t>(*p);
+            if (sizeof(code_unit) == 2 && c >= 0xd800 && c <= 0xdfff)
+            {
+                // surrogate pair
+                ++p;
+                if (p == unit.end || (c & 0xfc00) != 0xd800 || (*p & 0xfc00) != 0xdc00)
+                {
+                    FMT_THROW(format_error("failed to format time"));
+                }
+                c = (c << 10) + static_cast<uint32_t>(*p) - 0x35fdc00;
+            }
+            if (c < 0x80)
+            {
+                buf.push_back(static_cast<char>(c));
+            }
+            else if (c < 0x800)
+            {
+                buf.push_back(static_cast<char>(0xc0 | (c >> 6)));
+                buf.push_back(static_cast<char>(0x80 | (c & 0x3f)));
+            }
+            else if ((c >= 0x800 && c <= 0xd7ff) || (c >= 0xe000 && c <= 0xffff))
+            {
+                buf.push_back(static_cast<char>(0xe0 | (c >> 12)));
+                buf.push_back(static_cast<char>(0x80 | ((c & 0xfff) >> 6)));
+                buf.push_back(static_cast<char>(0x80 | (c & 0x3f)));
+            }
+            else if (c >= 0x10000 && c <= 0x10ffff)
+            {
+                buf.push_back(static_cast<char>(0xf0 | (c >> 18)));
+                buf.push_back(static_cast<char>(0x80 | ((c & 0x3ffff) >> 12)));
+                buf.push_back(static_cast<char>(0x80 | ((c & 0xfff) >> 6)));
+                buf.push_back(static_cast<char>(0x80 | (c & 0x3f)));
+            }
+            else
+            {
+                FMT_THROW(format_error("failed to format time"));
+            }
+        }
+        return copy_str<char>(buf.data(), buf.data() + buf.size(), out);
+    }
+    return copy_str<char>(in.data(), in.data() + in.size(), out);
+}
+
+template<typename Char, typename OutputIt, FMT_ENABLE_IF(!std::is_same<Char, char>::value)>
+auto write_tm_str(OutputIt out, string_view sv, const std::locale &loc) -> OutputIt
+{
+    codecvt_result<Char> unit;
+    write_codecvt(unit, sv, loc);
+    return copy_str<Char>(unit.buf, unit.end, out);
+}
+
+template<typename Char, typename OutputIt, FMT_ENABLE_IF(std::is_same<Char, char>::value)>
+auto write_tm_str(OutputIt out, string_view sv, const std::locale &loc) -> OutputIt
+{
+    return write_encoded_tm_str(out, sv, loc);
+}
+
+template<typename Char>
+inline void do_write(buffer<Char> &buf, const std::tm &time, const std::locale &loc, char format, char modifier)
+{
+    auto &&format_buf = formatbuf<std::basic_streambuf<Char>>(buf);
+    auto &&os = std::basic_ostream<Char>(&format_buf);
+    os.imbue(loc);
+    using iterator = std::ostreambuf_iterator<Char>;
+    const auto &facet = std::use_facet<std::time_put<Char, iterator>>(loc);
+    auto end = facet.put(os, os, Char(' '), &time, format, modifier);
+    if (end.failed())
+        FMT_THROW(format_error("failed to format time"));
+}
+
+template<typename Char, typename OutputIt, FMT_ENABLE_IF(!std::is_same<Char, char>::value)>
+auto write(OutputIt out, const std::tm &time, const std::locale &loc, char format, char modifier = 0) -> OutputIt
+{
+    auto &&buf = get_buffer<Char>(out);
+    do_write<Char>(buf, time, loc, format, modifier);
+    return buf.out();
+}
+
+template<typename Char, typename OutputIt, FMT_ENABLE_IF(std::is_same<Char, char>::value)>
+auto write(OutputIt out, const std::tm &time, const std::locale &loc, char format, char modifier = 0) -> OutputIt
+{
+    auto &&buf = basic_memory_buffer<Char>();
+    do_write<char>(buf, time, loc, format, modifier);
+    return write_encoded_tm_str(out, string_view(buf.data(), buf.size()), loc);
+}
+
+} // namespace detail
+
+FMT_MODULE_EXPORT_BEGIN
+
+/**
+  Converts given time since epoch as ``std::time_t`` value into calendar time,
+  expressed in local time. Unlike ``std::localtime``, this function is
+  thread-safe on most platforms.
+ */
+inline std::tm localtime(std::time_t time)
+{
+    struct dispatcher
+    {
+        std::time_t time_;
+        std::tm tm_;
+
+        dispatcher(std::time_t t)
+            : time_(t)
+        {}
+
+        bool run()
+        {
+            using namespace fmt::detail;
+            return handle(localtime_r(&time_, &tm_));
+        }
+
+        bool handle(std::tm *tm)
+        {
+            return tm != nullptr;
+        }
+
+        bool handle(detail::null<>)
+        {
+            using namespace fmt::detail;
+            return fallback(localtime_s(&tm_, &time_));
+        }
+
+        bool fallback(int res)
+        {
+            return res == 0;
+        }
+
+#if !FMT_MSC_VERSION
+        bool fallback(detail::null<>)
+        {
+            using namespace fmt::detail;
+            std::tm *tm = std::localtime(&time_);
+            if (tm)
+                tm_ = *tm;
+            return tm != nullptr;
+        }
+#endif
+    };
+    dispatcher lt(time);
+    // Too big time values may be unsupported.
+    if (!lt.run())
+        FMT_THROW(format_error("time_t value out of range"));
+    return lt.tm_;
+}
+
+inline std::tm localtime(std::chrono::time_point<std::chrono::system_clock> time_point)
+{
+    return localtime(std::chrono::system_clock::to_time_t(time_point));
+}
+
+/**
+  Converts given time since epoch as ``std::time_t`` value into calendar time,
+  expressed in Coordinated Universal Time (UTC). Unlike ``std::gmtime``, this
+  function is thread-safe on most platforms.
+ */
+inline std::tm gmtime(std::time_t time)
+{
+    struct dispatcher
+    {
+        std::time_t time_;
+        std::tm tm_;
+
+        dispatcher(std::time_t t)
+            : time_(t)
+        {}
+
+        bool run()
+        {
+            using namespace fmt::detail;
+            return handle(gmtime_r(&time_, &tm_));
+        }
+
+        bool handle(std::tm *tm)
+        {
+            return tm != nullptr;
+        }
+
+        bool handle(detail::null<>)
+        {
+            using namespace fmt::detail;
+            return fallback(gmtime_s(&tm_, &time_));
+        }
+
+        bool fallback(int res)
+        {
+            return res == 0;
+        }
+
+#if !FMT_MSC_VERSION
+        bool fallback(detail::null<>)
+        {
+            std::tm *tm = std::gmtime(&time_);
+            if (tm)
+                tm_ = *tm;
+            return tm != nullptr;
+        }
+#endif
+    };
+    dispatcher gt(time);
+    // Too big time values may be unsupported.
+    if (!gt.run())
+        FMT_THROW(format_error("time_t value out of range"));
+    return gt.tm_;
+}
+
+inline std::tm gmtime(std::chrono::time_point<std::chrono::system_clock> time_point)
+{
+    return gmtime(std::chrono::system_clock::to_time_t(time_point));
+}
+
+FMT_BEGIN_DETAIL_NAMESPACE
+
+// Writes two-digit numbers a, b and c separated by sep to buf.
+// The method by Pavel Novikov based on
+// https://johnnylee-sde.github.io/Fast-unsigned-integer-to-time-string/.
+inline void write_digit2_separated(char *buf, unsigned a, unsigned b, unsigned c, char sep)
+{
+    unsigned long long digits = a | (b << 24) | (static_cast<unsigned long long>(c) << 48);
+    // Convert each value to BCD.
+    // We have x = a * 10 + b and we want to convert it to BCD y = a * 16 + b.
+    // The difference is
+    //   y - x = a * 6
+    // a can be found from x:
+    //   a = floor(x / 10)
+    // then
+    //   y = x + a * 6 = x + floor(x / 10) * 6
+    // floor(x / 10) is (x * 205) >> 11 (needs 16 bits).
+    digits += (((digits * 205) >> 11) & 0x000f00000f00000f) * 6;
+    // Put low nibbles to high bytes and high nibbles to low bytes.
+    digits = ((digits & 0x00f00000f00000f0) >> 4) | ((digits & 0x000f00000f00000f) << 8);
+    auto usep = static_cast<unsigned long long>(sep);
+    // Add ASCII '0' to each digit byte and insert separators.
+    digits |= 0x3030003030003030 | (usep << 16) | (usep << 40);
+
+    constexpr const size_t len = 8;
+    if (const_check(is_big_endian()))
+    {
+        char tmp[len];
+        std::memcpy(tmp, &digits, len);
+        std::reverse_copy(tmp, tmp + len, buf);
+    }
+    else
+    {
+        std::memcpy(buf, &digits, len);
+    }
+}
+
+template<typename Period>
+FMT_CONSTEXPR inline const char *get_units()
+{
+    if (std::is_same<Period, std::atto>::value)
+        return "as";
+    if (std::is_same<Period, std::femto>::value)
+        return "fs";
+    if (std::is_same<Period, std::pico>::value)
+        return "ps";
+    if (std::is_same<Period, std::nano>::value)
+        return "ns";
+    if (std::is_same<Period, std::micro>::value)
+        return "µs";
+    if (std::is_same<Period, std::milli>::value)
+        return "ms";
+    if (std::is_same<Period, std::centi>::value)
+        return "cs";
+    if (std::is_same<Period, std::deci>::value)
+        return "ds";
+    if (std::is_same<Period, std::ratio<1>>::value)
+        return "s";
+    if (std::is_same<Period, std::deca>::value)
+        return "das";
+    if (std::is_same<Period, std::hecto>::value)
+        return "hs";
+    if (std::is_same<Period, std::kilo>::value)
+        return "ks";
+    if (std::is_same<Period, std::mega>::value)
+        return "Ms";
+    if (std::is_same<Period, std::giga>::value)
+        return "Gs";
+    if (std::is_same<Period, std::tera>::value)
+        return "Ts";
+    if (std::is_same<Period, std::peta>::value)
+        return "Ps";
+    if (std::is_same<Period, std::exa>::value)
+        return "Es";
+    if (std::is_same<Period, std::ratio<60>>::value)
+        return "m";
+    if (std::is_same<Period, std::ratio<3600>>::value)
+        return "h";
+    return nullptr;
+}
+
+enum class numeric_system
+{
+    standard,
+    // Alternative numeric system, e.g. 十二 instead of 12 in ja_JP locale.
+    alternative
+};
+
+// Parses a put_time-like format string and invokes handler actions.
+template<typename Char, typename Handler>
+FMT_CONSTEXPR const Char *parse_chrono_format(const Char *begin, const Char *end, Handler &&handler)
+{
+    auto ptr = begin;
+    while (ptr != end)
+    {
+        auto c = *ptr;
+        if (c == '}')
+            break;
+        if (c != '%')
+        {
+            ++ptr;
+            continue;
+        }
+        if (begin != ptr)
+            handler.on_text(begin, ptr);
+        ++ptr; // consume '%'
+        if (ptr == end)
+            FMT_THROW(format_error("invalid format"));
+        c = *ptr++;
+        switch (c)
+        {
+        case '%':
+            handler.on_text(ptr - 1, ptr);
+            break;
+        case 'n': {
+            const Char newline[] = {'\n'};
+            handler.on_text(newline, newline + 1);
+            break;
+        }
+        case 't': {
+            const Char tab[] = {'\t'};
+            handler.on_text(tab, tab + 1);
+            break;
+        }
+        // Year:
+        case 'Y':
+            handler.on_year(numeric_system::standard);
+            break;
+        case 'y':
+            handler.on_short_year(numeric_system::standard);
+            break;
+        case 'C':
+            handler.on_century(numeric_system::standard);
+            break;
+        case 'G':
+            handler.on_iso_week_based_year();
+            break;
+        case 'g':
+            handler.on_iso_week_based_short_year();
+            break;
+        // Day of the week:
+        case 'a':
+            handler.on_abbr_weekday();
+            break;
+        case 'A':
+            handler.on_full_weekday();
+            break;
+        case 'w':
+            handler.on_dec0_weekday(numeric_system::standard);
+            break;
+        case 'u':
+            handler.on_dec1_weekday(numeric_system::standard);
+            break;
+        // Month:
+        case 'b':
+        case 'h':
+            handler.on_abbr_month();
+            break;
+        case 'B':
+            handler.on_full_month();
+            break;
+        case 'm':
+            handler.on_dec_month(numeric_system::standard);
+            break;
+        // Day of the year/month:
+        case 'U':
+            handler.on_dec0_week_of_year(numeric_system::standard);
+            break;
+        case 'W':
+            handler.on_dec1_week_of_year(numeric_system::standard);
+            break;
+        case 'V':
+            handler.on_iso_week_of_year(numeric_system::standard);
+            break;
+        case 'j':
+            handler.on_day_of_year();
+            break;
+        case 'd':
+            handler.on_day_of_month(numeric_system::standard);
+            break;
+        case 'e':
+            handler.on_day_of_month_space(numeric_system::standard);
+            break;
+        // Hour, minute, second:
+        case 'H':
+            handler.on_24_hour(numeric_system::standard);
+            break;
+        case 'I':
+            handler.on_12_hour(numeric_system::standard);
+            break;
+        case 'M':
+            handler.on_minute(numeric_system::standard);
+            break;
+        case 'S':
+            handler.on_second(numeric_system::standard);
+            break;
+        // Other:
+        case 'c':
+            handler.on_datetime(numeric_system::standard);
+            break;
+        case 'x':
+            handler.on_loc_date(numeric_system::standard);
+            break;
+        case 'X':
+            handler.on_loc_time(numeric_system::standard);
+            break;
+        case 'D':
+            handler.on_us_date();
+            break;
+        case 'F':
+            handler.on_iso_date();
+            break;
+        case 'r':
+            handler.on_12_hour_time();
+            break;
+        case 'R':
+            handler.on_24_hour_time();
+            break;
+        case 'T':
+            handler.on_iso_time();
+            break;
+        case 'p':
+            handler.on_am_pm();
+            break;
+        case 'Q':
+            handler.on_duration_value();
+            break;
+        case 'q':
+            handler.on_duration_unit();
+            break;
+        case 'z':
+            handler.on_utc_offset();
+            break;
+        case 'Z':
+            handler.on_tz_name();
+            break;
+        // Alternative representation:
+        case 'E': {
+            if (ptr == end)
+                FMT_THROW(format_error("invalid format"));
+            c = *ptr++;
+            switch (c)
+            {
+            case 'Y':
+                handler.on_year(numeric_system::alternative);
+                break;
+            case 'y':
+                handler.on_offset_year();
+                break;
+            case 'C':
+                handler.on_century(numeric_system::alternative);
+                break;
+            case 'c':
+                handler.on_datetime(numeric_system::alternative);
+                break;
+            case 'x':
+                handler.on_loc_date(numeric_system::alternative);
+                break;
+            case 'X':
+                handler.on_loc_time(numeric_system::alternative);
+                break;
+            default:
+                FMT_THROW(format_error("invalid format"));
+            }
+            break;
+        }
+        case 'O':
+            if (ptr == end)
+                FMT_THROW(format_error("invalid format"));
+            c = *ptr++;
+            switch (c)
+            {
+            case 'y':
+                handler.on_short_year(numeric_system::alternative);
+                break;
+            case 'm':
+                handler.on_dec_month(numeric_system::alternative);
+                break;
+            case 'U':
+                handler.on_dec0_week_of_year(numeric_system::alternative);
+                break;
+            case 'W':
+                handler.on_dec1_week_of_year(numeric_system::alternative);
+                break;
+            case 'V':
+                handler.on_iso_week_of_year(numeric_system::alternative);
+                break;
+            case 'd':
+                handler.on_day_of_month(numeric_system::alternative);
+                break;
+            case 'e':
+                handler.on_day_of_month_space(numeric_system::alternative);
+                break;
+            case 'w':
+                handler.on_dec0_weekday(numeric_system::alternative);
+                break;
+            case 'u':
+                handler.on_dec1_weekday(numeric_system::alternative);
+                break;
+            case 'H':
+                handler.on_24_hour(numeric_system::alternative);
+                break;
+            case 'I':
+                handler.on_12_hour(numeric_system::alternative);
+                break;
+            case 'M':
+                handler.on_minute(numeric_system::alternative);
+                break;
+            case 'S':
+                handler.on_second(numeric_system::alternative);
+                break;
+            default:
+                FMT_THROW(format_error("invalid format"));
+            }
+            break;
+        default:
+            FMT_THROW(format_error("invalid format"));
+        }
+        begin = ptr;
+    }
+    if (begin != ptr)
+        handler.on_text(begin, ptr);
+    return ptr;
+}
+
+template<typename Derived>
+struct null_chrono_spec_handler
+{
+    FMT_CONSTEXPR void unsupported()
+    {
+        static_cast<Derived *>(this)->unsupported();
+    }
+    FMT_CONSTEXPR void on_year(numeric_system)
+    {
+        unsupported();
+    }
+    FMT_CONSTEXPR void on_short_year(numeric_system)
+    {
+        unsupported();
+    }
+    FMT_CONSTEXPR void on_offset_year()
+    {
+        unsupported();
+    }
+    FMT_CONSTEXPR void on_century(numeric_system)
+    {
+        unsupported();
+    }
+    FMT_CONSTEXPR void on_iso_week_based_year()
+    {
+        unsupported();
+    }
+    FMT_CONSTEXPR void on_iso_week_based_short_year()
+    {
+        unsupported();
+    }
+    FMT_CONSTEXPR void on_abbr_weekday()
+    {
+        unsupported();
+    }
+    FMT_CONSTEXPR void on_full_weekday()
+    {
+        unsupported();
+    }
+    FMT_CONSTEXPR void on_dec0_weekday(numeric_system)
+    {
+        unsupported();
+    }
+    FMT_CONSTEXPR void on_dec1_weekday(numeric_system)
+    {
+        unsupported();
+    }
+    FMT_CONSTEXPR void on_abbr_month()
+    {
+        unsupported();
+    }
+    FMT_CONSTEXPR void on_full_month()
+    {
+        unsupported();
+    }
+    FMT_CONSTEXPR void on_dec_month(numeric_system)
+    {
+        unsupported();
+    }
+    FMT_CONSTEXPR void on_dec0_week_of_year(numeric_system)
+    {
+        unsupported();
+    }
+    FMT_CONSTEXPR void on_dec1_week_of_year(numeric_system)
+    {
+        unsupported();
+    }
+    FMT_CONSTEXPR void on_iso_week_of_year(numeric_system)
+    {
+        unsupported();
+    }
+    FMT_CONSTEXPR void on_day_of_year()
+    {
+        unsupported();
+    }
+    FMT_CONSTEXPR void on_day_of_month(numeric_system)
+    {
+        unsupported();
+    }
+    FMT_CONSTEXPR void on_day_of_month_space(numeric_system)
+    {
+        unsupported();
+    }
+    FMT_CONSTEXPR void on_24_hour(numeric_system)
+    {
+        unsupported();
+    }
+    FMT_CONSTEXPR void on_12_hour(numeric_system)
+    {
+        unsupported();
+    }
+    FMT_CONSTEXPR void on_minute(numeric_system)
+    {
+        unsupported();
+    }
+    FMT_CONSTEXPR void on_second(numeric_system)
+    {
+        unsupported();
+    }
+    FMT_CONSTEXPR void on_datetime(numeric_system)
+    {
+        unsupported();
+    }
+    FMT_CONSTEXPR void on_loc_date(numeric_system)
+    {
+        unsupported();
+    }
+    FMT_CONSTEXPR void on_loc_time(numeric_system)
+    {
+        unsupported();
+    }
+    FMT_CONSTEXPR void on_us_date()
+    {
+        unsupported();
+    }
+    FMT_CONSTEXPR void on_iso_date()
+    {
+        unsupported();
+    }
+    FMT_CONSTEXPR void on_12_hour_time()
+    {
+        unsupported();
+    }
+    FMT_CONSTEXPR void on_24_hour_time()
+    {
+        unsupported();
+    }
+    FMT_CONSTEXPR void on_iso_time()
+    {
+        unsupported();
+    }
+    FMT_CONSTEXPR void on_am_pm()
+    {
+        unsupported();
+    }
+    FMT_CONSTEXPR void on_duration_value()
+    {
+        unsupported();
+    }
+    FMT_CONSTEXPR void on_duration_unit()
+    {
+        unsupported();
+    }
+    FMT_CONSTEXPR void on_utc_offset()
+    {
+        unsupported();
+    }
+    FMT_CONSTEXPR void on_tz_name()
+    {
+        unsupported();
+    }
+};
+
+struct tm_format_checker : null_chrono_spec_handler<tm_format_checker>
+{
+    FMT_NORETURN void unsupported()
+    {
+        FMT_THROW(format_error("no format"));
+    }
+
+    template<typename Char>
+    FMT_CONSTEXPR void on_text(const Char *, const Char *)
+    {}
+    FMT_CONSTEXPR void on_year(numeric_system) {}
+    FMT_CONSTEXPR void on_short_year(numeric_system) {}
+    FMT_CONSTEXPR void on_offset_year() {}
+    FMT_CONSTEXPR void on_century(numeric_system) {}
+    FMT_CONSTEXPR void on_iso_week_based_year() {}
+    FMT_CONSTEXPR void on_iso_week_based_short_year() {}
+    FMT_CONSTEXPR void on_abbr_weekday() {}
+    FMT_CONSTEXPR void on_full_weekday() {}
+    FMT_CONSTEXPR void on_dec0_weekday(numeric_system) {}
+    FMT_CONSTEXPR void on_dec1_weekday(numeric_system) {}
+    FMT_CONSTEXPR void on_abbr_month() {}
+    FMT_CONSTEXPR void on_full_month() {}
+    FMT_CONSTEXPR void on_dec_month(numeric_system) {}
+    FMT_CONSTEXPR void on_dec0_week_of_year(numeric_system) {}
+    FMT_CONSTEXPR void on_dec1_week_of_year(numeric_system) {}
+    FMT_CONSTEXPR void on_iso_week_of_year(numeric_system) {}
+    FMT_CONSTEXPR void on_day_of_year() {}
+    FMT_CONSTEXPR void on_day_of_month(numeric_system) {}
+    FMT_CONSTEXPR void on_day_of_month_space(numeric_system) {}
+    FMT_CONSTEXPR void on_24_hour(numeric_system) {}
+    FMT_CONSTEXPR void on_12_hour(numeric_system) {}
+    FMT_CONSTEXPR void on_minute(numeric_system) {}
+    FMT_CONSTEXPR void on_second(numeric_system) {}
+    FMT_CONSTEXPR void on_datetime(numeric_system) {}
+    FMT_CONSTEXPR void on_loc_date(numeric_system) {}
+    FMT_CONSTEXPR void on_loc_time(numeric_system) {}
+    FMT_CONSTEXPR void on_us_date() {}
+    FMT_CONSTEXPR void on_iso_date() {}
+    FMT_CONSTEXPR void on_12_hour_time() {}
+    FMT_CONSTEXPR void on_24_hour_time() {}
+    FMT_CONSTEXPR void on_iso_time() {}
+    FMT_CONSTEXPR void on_am_pm() {}
+    FMT_CONSTEXPR void on_utc_offset() {}
+    FMT_CONSTEXPR void on_tz_name() {}
+};
+
+inline const char *tm_wday_full_name(int wday)
+{
+    static constexpr const char *full_name_list[] = {"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"};
+    return wday >= 0 && wday <= 6 ? full_name_list[wday] : "?";
+}
+inline const char *tm_wday_short_name(int wday)
+{
+    static constexpr const char *short_name_list[] = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
+    return wday >= 0 && wday <= 6 ? short_name_list[wday] : "???";
+}
+
+inline const char *tm_mon_full_name(int mon)
+{
+    static constexpr const char *full_name_list[] = {
+        "January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"};
+    return mon >= 0 && mon <= 11 ? full_name_list[mon] : "?";
+}
+inline const char *tm_mon_short_name(int mon)
+{
+    static constexpr const char *short_name_list[] = {
+        "Jan",
+        "Feb",
+        "Mar",
+        "Apr",
+        "May",
+        "Jun",
+        "Jul",
+        "Aug",
+        "Sep",
+        "Oct",
+        "Nov",
+        "Dec",
+    };
+    return mon >= 0 && mon <= 11 ? short_name_list[mon] : "???";
+}
+
+template<typename T, typename = void>
+struct has_member_data_tm_gmtoff : std::false_type
+{};
+template<typename T>
+struct has_member_data_tm_gmtoff<T, void_t<decltype(T::tm_gmtoff)>> : std::true_type
+{};
+
+template<typename T, typename = void>
+struct has_member_data_tm_zone : std::false_type
+{};
+template<typename T>
+struct has_member_data_tm_zone<T, void_t<decltype(T::tm_zone)>> : std::true_type
+{};
+
+#if FMT_USE_TZSET
+inline void tzset_once()
+{
+    static bool init = []() -> bool {
+        _tzset();
+        return true;
+    }();
+    ignore_unused(init);
+}
+#endif
+
+template<typename OutputIt, typename Char>
+class tm_writer
+{
+private:
+    static constexpr int days_per_week = 7;
+
+    const std::locale &loc_;
+    const bool is_classic_;
+    OutputIt out_;
+    const std::tm &tm_;
+
+    auto tm_sec() const noexcept -> int
+    {
+        FMT_ASSERT(tm_.tm_sec >= 0 && tm_.tm_sec <= 61, "");
+        return tm_.tm_sec;
+    }
+    auto tm_min() const noexcept -> int
+    {
+        FMT_ASSERT(tm_.tm_min >= 0 && tm_.tm_min <= 59, "");
+        return tm_.tm_min;
+    }
+    auto tm_hour() const noexcept -> int
+    {
+        FMT_ASSERT(tm_.tm_hour >= 0 && tm_.tm_hour <= 23, "");
+        return tm_.tm_hour;
+    }
+    auto tm_mday() const noexcept -> int
+    {
+        FMT_ASSERT(tm_.tm_mday >= 1 && tm_.tm_mday <= 31, "");
+        return tm_.tm_mday;
+    }
+    auto tm_mon() const noexcept -> int
+    {
+        FMT_ASSERT(tm_.tm_mon >= 0 && tm_.tm_mon <= 11, "");
+        return tm_.tm_mon;
+    }
+    auto tm_year() const noexcept -> long long
+    {
+        return 1900ll + tm_.tm_year;
+    }
+    auto tm_wday() const noexcept -> int
+    {
+        FMT_ASSERT(tm_.tm_wday >= 0 && tm_.tm_wday <= 6, "");
+        return tm_.tm_wday;
+    }
+    auto tm_yday() const noexcept -> int
+    {
+        FMT_ASSERT(tm_.tm_yday >= 0 && tm_.tm_yday <= 365, "");
+        return tm_.tm_yday;
+    }
+
+    auto tm_hour12() const noexcept -> int
+    {
+        const auto h = tm_hour();
+        const auto z = h < 12 ? h : h - 12;
+        return z == 0 ? 12 : z;
+    }
+
+    // POSIX and the C Standard are unclear or inconsistent about what %C and %y
+    // do if the year is negative or exceeds 9999. Use the convention that %C
+    // concatenated with %y yields the same output as %Y, and that %Y contains at
+    // least 4 characters, with more only if necessary.
+    auto split_year_lower(long long year) const noexcept -> int
+    {
+        auto l = year % 100;
+        if (l < 0)
+            l = -l; // l in [0, 99]
+        return static_cast<int>(l);
+    }
+
+    // Algorithm:
+    // https://en.wikipedia.org/wiki/ISO_week_date#Calculating_the_week_number_from_a_month_and_day_of_the_month_or_ordinal_date
+    auto iso_year_weeks(long long curr_year) const noexcept -> int
+    {
+        const auto prev_year = curr_year - 1;
+        const auto curr_p = (curr_year + curr_year / 4 - curr_year / 100 + curr_year / 400) % days_per_week;
+        const auto prev_p = (prev_year + prev_year / 4 - prev_year / 100 + prev_year / 400) % days_per_week;
+        return 52 + ((curr_p == 4 || prev_p == 3) ? 1 : 0);
+    }
+    auto iso_week_num(int tm_yday, int tm_wday) const noexcept -> int
+    {
+        return (tm_yday + 11 - (tm_wday == 0 ? days_per_week : tm_wday)) / days_per_week;
+    }
+    auto tm_iso_week_year() const noexcept -> long long
+    {
+        const auto year = tm_year();
+        const auto w = iso_week_num(tm_yday(), tm_wday());
+        if (w < 1)
+            return year - 1;
+        if (w > iso_year_weeks(year))
+            return year + 1;
+        return year;
+    }
+    auto tm_iso_week_of_year() const noexcept -> int
+    {
+        const auto year = tm_year();
+        const auto w = iso_week_num(tm_yday(), tm_wday());
+        if (w < 1)
+            return iso_year_weeks(year - 1);
+        if (w > iso_year_weeks(year))
+            return 1;
+        return w;
+    }
+
+    void write1(int value)
+    {
+        *out_++ = static_cast<char>('0' + to_unsigned(value) % 10);
+    }
+    void write2(int value)
+    {
+        const char *d = digits2(to_unsigned(value) % 100);
+        *out_++ = *d++;
+        *out_++ = *d;
+    }
+
+    void write_year_extended(long long year)
+    {
+        // At least 4 characters.
+        int width = 4;
+        if (year < 0)
+        {
+            *out_++ = '-';
+            year = 0 - year;
+            --width;
+        }
+        uint32_or_64_or_128_t<long long> n = to_unsigned(year);
+        const int num_digits = count_digits(n);
+        if (width > num_digits)
+            out_ = std::fill_n(out_, width - num_digits, '0');
+        out_ = format_decimal<Char>(out_, n, num_digits).end;
+    }
+    void write_year(long long year)
+    {
+        if (year >= 0 && year < 10000)
+        {
+            write2(static_cast<int>(year / 100));
+            write2(static_cast<int>(year % 100));
+        }
+        else
+        {
+            write_year_extended(year);
+        }
+    }
+
+    void write_utc_offset(long offset)
+    {
+        if (offset < 0)
+        {
+            *out_++ = '-';
+            offset = -offset;
+        }
+        else
+        {
+            *out_++ = '+';
+        }
+        offset /= 60;
+        write2(static_cast<int>(offset / 60));
+        write2(static_cast<int>(offset % 60));
+    }
+    template<typename T, FMT_ENABLE_IF(has_member_data_tm_gmtoff<T>::value)>
+    void format_utc_offset_impl(const T &tm)
+    {
+        write_utc_offset(tm.tm_gmtoff);
+    }
+    template<typename T, FMT_ENABLE_IF(!has_member_data_tm_gmtoff<T>::value)>
+    void format_utc_offset_impl(const T &tm)
+    {
+#if defined(_WIN32) && defined(_UCRT)
+#    if FMT_USE_TZSET
+        tzset_once();
+#    endif
+        long offset = 0;
+        _get_timezone(&offset);
+        if (tm.tm_isdst)
+        {
+            long dstbias = 0;
+            _get_dstbias(&dstbias);
+            offset += dstbias;
+        }
+        write_utc_offset(-offset);
+#else
+        ignore_unused(tm);
+        format_localized('z');
+#endif
+    }
+
+    template<typename T, FMT_ENABLE_IF(has_member_data_tm_zone<T>::value)>
+    void format_tz_name_impl(const T &tm)
+    {
+        if (is_classic_)
+            out_ = write_tm_str<Char>(out_, tm.tm_zone, loc_);
+        else
+            format_localized('Z');
+    }
+    template<typename T, FMT_ENABLE_IF(!has_member_data_tm_zone<T>::value)>
+    void format_tz_name_impl(const T &)
+    {
+        format_localized('Z');
+    }
+
+    void format_localized(char format, char modifier = 0)
+    {
+        out_ = write<Char>(out_, tm_, loc_, format, modifier);
+    }
+
+public:
+    tm_writer(const std::locale &loc, OutputIt out, const std::tm &tm)
+        : loc_(loc)
+        , is_classic_(loc_ == get_classic_locale())
+        , out_(out)
+        , tm_(tm)
+    {}
+
+    OutputIt out() const
+    {
+        return out_;
+    }
+
+    FMT_CONSTEXPR void on_text(const Char *begin, const Char *end)
+    {
+        out_ = copy_str<Char>(begin, end, out_);
+    }
+
+    void on_abbr_weekday()
+    {
+        if (is_classic_)
+            out_ = write(out_, tm_wday_short_name(tm_wday()));
+        else
+            format_localized('a');
+    }
+    void on_full_weekday()
+    {
+        if (is_classic_)
+            out_ = write(out_, tm_wday_full_name(tm_wday()));
+        else
+            format_localized('A');
+    }
+    void on_dec0_weekday(numeric_system ns)
+    {
+        if (is_classic_ || ns == numeric_system::standard)
+            return write1(tm_wday());
+        format_localized('w', 'O');
+    }
+    void on_dec1_weekday(numeric_system ns)
+    {
+        if (is_classic_ || ns == numeric_system::standard)
+        {
+            auto wday = tm_wday();
+            write1(wday == 0 ? days_per_week : wday);
+        }
+        else
+        {
+            format_localized('u', 'O');
+        }
+    }
+
+    void on_abbr_month()
+    {
+        if (is_classic_)
+            out_ = write(out_, tm_mon_short_name(tm_mon()));
+        else
+            format_localized('b');
+    }
+    void on_full_month()
+    {
+        if (is_classic_)
+            out_ = write(out_, tm_mon_full_name(tm_mon()));
+        else
+            format_localized('B');
+    }
+
+    void on_datetime(numeric_system ns)
+    {
+        if (is_classic_)
+        {
+            on_abbr_weekday();
+            *out_++ = ' ';
+            on_abbr_month();
+            *out_++ = ' ';
+            on_day_of_month_space(numeric_system::standard);
+            *out_++ = ' ';
+            on_iso_time();
+            *out_++ = ' ';
+            on_year(numeric_system::standard);
+        }
+        else
+        {
+            format_localized('c', ns == numeric_system::standard ? '\0' : 'E');
+        }
+    }
+    void on_loc_date(numeric_system ns)
+    {
+        if (is_classic_)
+            on_us_date();
+        else
+            format_localized('x', ns == numeric_system::standard ? '\0' : 'E');
+    }
+    void on_loc_time(numeric_system ns)
+    {
+        if (is_classic_)
+            on_iso_time();
+        else
+            format_localized('X', ns == numeric_system::standard ? '\0' : 'E');
+    }
+    void on_us_date()
+    {
+        char buf[8];
+        write_digit2_separated(buf, to_unsigned(tm_mon() + 1), to_unsigned(tm_mday()), to_unsigned(split_year_lower(tm_year())), '/');
+        out_ = copy_str<Char>(std::begin(buf), std::end(buf), out_);
+    }
+    void on_iso_date()
+    {
+        auto year = tm_year();
+        char buf[10];
+        size_t offset = 0;
+        if (year >= 0 && year < 10000)
+        {
+            copy2(buf, digits2(static_cast<size_t>(year / 100)));
+        }
+        else
+        {
+            offset = 4;
+            write_year_extended(year);
+            year = 0;
+        }
+        write_digit2_separated(buf + 2, static_cast<unsigned>(year % 100), to_unsigned(tm_mon() + 1), to_unsigned(tm_mday()), '-');
+        out_ = copy_str<Char>(std::begin(buf) + offset, std::end(buf), out_);
+    }
+
+    void on_utc_offset()
+    {
+        format_utc_offset_impl(tm_);
+    }
+    void on_tz_name()
+    {
+        format_tz_name_impl(tm_);
+    }
+
+    void on_year(numeric_system ns)
+    {
+        if (is_classic_ || ns == numeric_system::standard)
+            return write_year(tm_year());
+        format_localized('Y', 'E');
+    }
+    void on_short_year(numeric_system ns)
+    {
+        if (is_classic_ || ns == numeric_system::standard)
+            return write2(split_year_lower(tm_year()));
+        format_localized('y', 'O');
+    }
+    void on_offset_year()
+    {
+        if (is_classic_)
+            return write2(split_year_lower(tm_year()));
+        format_localized('y', 'E');
+    }
+
+    void on_century(numeric_system ns)
+    {
+        if (is_classic_ || ns == numeric_system::standard)
+        {
+            auto year = tm_year();
+            auto upper = year / 100;
+            if (year >= -99 && year < 0)
+            {
+                // Zero upper on negative year.
+                *out_++ = '-';
+                *out_++ = '0';
+            }
+            else if (upper >= 0 && upper < 100)
+            {
+                write2(static_cast<int>(upper));
+            }
+            else
+            {
+                out_ = write<Char>(out_, upper);
+            }
+        }
+        else
+        {
+            format_localized('C', 'E');
+        }
+    }
+
+    void on_dec_month(numeric_system ns)
+    {
+        if (is_classic_ || ns == numeric_system::standard)
+            return write2(tm_mon() + 1);
+        format_localized('m', 'O');
+    }
+
+    void on_dec0_week_of_year(numeric_system ns)
+    {
+        if (is_classic_ || ns == numeric_system::standard)
+            return write2((tm_yday() + days_per_week - tm_wday()) / days_per_week);
+        format_localized('U', 'O');
+    }
+    void on_dec1_week_of_year(numeric_system ns)
+    {
+        if (is_classic_ || ns == numeric_system::standard)
+        {
+            auto wday = tm_wday();
+            write2((tm_yday() + days_per_week - (wday == 0 ? (days_per_week - 1) : (wday - 1))) / days_per_week);
+        }
+        else
+        {
+            format_localized('W', 'O');
+        }
+    }
+    void on_iso_week_of_year(numeric_system ns)
+    {
+        if (is_classic_ || ns == numeric_system::standard)
+            return write2(tm_iso_week_of_year());
+        format_localized('V', 'O');
+    }
+
+    void on_iso_week_based_year()
+    {
+        write_year(tm_iso_week_year());
+    }
+    void on_iso_week_based_short_year()
+    {
+        write2(split_year_lower(tm_iso_week_year()));
+    }
+
+    void on_day_of_year()
+    {
+        auto yday = tm_yday() + 1;
+        write1(yday / 100);
+        write2(yday % 100);
+    }
+    void on_day_of_month(numeric_system ns)
+    {
+        if (is_classic_ || ns == numeric_system::standard)
+            return write2(tm_mday());
+        format_localized('d', 'O');
+    }
+    void on_day_of_month_space(numeric_system ns)
+    {
+        if (is_classic_ || ns == numeric_system::standard)
+        {
+            auto mday = to_unsigned(tm_mday()) % 100;
+            const char *d2 = digits2(mday);
+            *out_++ = mday < 10 ? ' ' : d2[0];
+            *out_++ = d2[1];
+        }
+        else
+        {
+            format_localized('e', 'O');
+        }
+    }
+
+    void on_24_hour(numeric_system ns)
+    {
+        if (is_classic_ || ns == numeric_system::standard)
+            return write2(tm_hour());
+        format_localized('H', 'O');
+    }
+    void on_12_hour(numeric_system ns)
+    {
+        if (is_classic_ || ns == numeric_system::standard)
+            return write2(tm_hour12());
+        format_localized('I', 'O');
+    }
+    void on_minute(numeric_system ns)
+    {
+        if (is_classic_ || ns == numeric_system::standard)
+            return write2(tm_min());
+        format_localized('M', 'O');
+    }
+    void on_second(numeric_system ns)
+    {
+        if (is_classic_ || ns == numeric_system::standard)
+            return write2(tm_sec());
+        format_localized('S', 'O');
+    }
+
+    void on_12_hour_time()
+    {
+        if (is_classic_)
+        {
+            char buf[8];
+            write_digit2_separated(buf, to_unsigned(tm_hour12()), to_unsigned(tm_min()), to_unsigned(tm_sec()), ':');
+            out_ = copy_str<Char>(std::begin(buf), std::end(buf), out_);
+            *out_++ = ' ';
+            on_am_pm();
+        }
+        else
+        {
+            format_localized('r');
+        }
+    }
+    void on_24_hour_time()
+    {
+        write2(tm_hour());
+        *out_++ = ':';
+        write2(tm_min());
+    }
+    void on_iso_time()
+    {
+        char buf[8];
+        write_digit2_separated(buf, to_unsigned(tm_hour()), to_unsigned(tm_min()), to_unsigned(tm_sec()), ':');
+        out_ = copy_str<Char>(std::begin(buf), std::end(buf), out_);
+    }
+
+    void on_am_pm()
+    {
+        if (is_classic_)
+        {
+            *out_++ = tm_hour() < 12 ? 'A' : 'P';
+            *out_++ = 'M';
+        }
+        else
+        {
+            format_localized('p');
+        }
+    }
+
+    // These apply to chrono durations but not tm.
+    void on_duration_value() {}
+    void on_duration_unit() {}
+};
+
+struct chrono_format_checker : null_chrono_spec_handler<chrono_format_checker>
+{
+    FMT_NORETURN void unsupported()
+    {
+        FMT_THROW(format_error("no date"));
+    }
+
+    template<typename Char>
+    FMT_CONSTEXPR void on_text(const Char *, const Char *)
+    {}
+    FMT_CONSTEXPR void on_24_hour(numeric_system) {}
+    FMT_CONSTEXPR void on_12_hour(numeric_system) {}
+    FMT_CONSTEXPR void on_minute(numeric_system) {}
+    FMT_CONSTEXPR void on_second(numeric_system) {}
+    FMT_CONSTEXPR void on_12_hour_time() {}
+    FMT_CONSTEXPR void on_24_hour_time() {}
+    FMT_CONSTEXPR void on_iso_time() {}
+    FMT_CONSTEXPR void on_am_pm() {}
+    FMT_CONSTEXPR void on_duration_value() {}
+    FMT_CONSTEXPR void on_duration_unit() {}
+};
+
+template<typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
+inline bool isfinite(T)
+{
+    return true;
+}
+
+// Converts value to Int and checks that it's in the range [0, upper).
+template<typename T, typename Int, FMT_ENABLE_IF(std::is_integral<T>::value)>
+inline Int to_nonnegative_int(T value, Int upper)
+{
+    FMT_ASSERT(std::is_unsigned<Int>::value || (value >= 0 && to_unsigned(value) <= to_unsigned(upper)), "invalid value");
+    (void)upper;
+    return static_cast<Int>(value);
+}
+template<typename T, typename Int, FMT_ENABLE_IF(!std::is_integral<T>::value)>
+inline Int to_nonnegative_int(T value, Int upper)
+{
+    if (value < 0 || value > static_cast<T>(upper))
+        FMT_THROW(format_error("invalid value"));
+    return static_cast<Int>(value);
+}
+
+template<typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
+inline T mod(T x, int y)
+{
+    return x % static_cast<T>(y);
+}
+template<typename T, FMT_ENABLE_IF(std::is_floating_point<T>::value)>
+inline T mod(T x, int y)
+{
+    return std::fmod(x, static_cast<T>(y));
+}
+
+// If T is an integral type, maps T to its unsigned counterpart, otherwise
+// leaves it unchanged (unlike std::make_unsigned).
+template<typename T, bool INTEGRAL = std::is_integral<T>::value>
+struct make_unsigned_or_unchanged
+{
+    using type = T;
+};
+
+template<typename T>
+struct make_unsigned_or_unchanged<T, true>
+{
+    using type = typename std::make_unsigned<T>::type;
+};
+
+#if FMT_SAFE_DURATION_CAST
+// throwing version of safe_duration_cast
+template<typename To, typename FromRep, typename FromPeriod>
+To fmt_safe_duration_cast(std::chrono::duration<FromRep, FromPeriod> from)
+{
+    int ec;
+    To to = safe_duration_cast::safe_duration_cast<To>(from, ec);
+    if (ec)
+        FMT_THROW(format_error("cannot format duration"));
+    return to;
+}
+#endif
+
+template<typename Rep, typename Period, FMT_ENABLE_IF(std::is_integral<Rep>::value)>
+inline std::chrono::duration<Rep, std::milli> get_milliseconds(std::chrono::duration<Rep, Period> d)
+{
+    // this may overflow and/or the result may not fit in the
+    // target type.
+#if FMT_SAFE_DURATION_CAST
+    using CommonSecondsType = typename std::common_type<decltype(d), std::chrono::seconds>::type;
+    const auto d_as_common = fmt_safe_duration_cast<CommonSecondsType>(d);
+    const auto d_as_whole_seconds = fmt_safe_duration_cast<std::chrono::seconds>(d_as_common);
+    // this conversion should be nonproblematic
+    const auto diff = d_as_common - d_as_whole_seconds;
+    const auto ms = fmt_safe_duration_cast<std::chrono::duration<Rep, std::milli>>(diff);
+    return ms;
+#else
+    auto s = std::chrono::duration_cast<std::chrono::seconds>(d);
+    return std::chrono::duration_cast<std::chrono::milliseconds>(d - s);
+#endif
+}
+
+// Counts the number of fractional digits in the range [0, 18] according to the
+// C++20 spec. If more than 18 fractional digits are required then returns 6 for
+// microseconds precision.
+template<long long Num, long long Den, int N = 0, bool Enabled = (N < 19) && (Num <= max_value<long long>() / 10)>
+struct count_fractional_digits
+{
+    static constexpr int value = Num % Den == 0 ? N : count_fractional_digits<Num * 10, Den, N + 1>::value;
+};
+
+// Base case that doesn't instantiate any more templates
+// in order to avoid overflow.
+template<long long Num, long long Den, int N>
+struct count_fractional_digits<Num, Den, N, false>
+{
+    static constexpr int value = (Num % Den == 0) ? N : 6;
+};
+
+constexpr long long pow10(std::uint32_t n)
+{
+    return n == 0 ? 1 : 10 * pow10(n - 1);
+}
+
+template<class Rep, class Period, FMT_ENABLE_IF(std::numeric_limits<Rep>::is_signed)>
+constexpr std::chrono::duration<Rep, Period> abs(std::chrono::duration<Rep, Period> d)
+{
+    // We need to compare the duration using the count() method directly
+    // due to a compiler bug in clang-11 regarding the spaceship operator,
+    // when -Wzero-as-null-pointer-constant is enabled.
+    // In clang-12 the bug has been fixed. See
+    // https://bugs.llvm.org/show_bug.cgi?id=46235 and the reproducible example:
+    // https://www.godbolt.org/z/Knbb5joYx.
+    return d.count() >= d.zero().count() ? d : -d;
+}
+
+template<class Rep, class Period, FMT_ENABLE_IF(!std::numeric_limits<Rep>::is_signed)>
+constexpr std::chrono::duration<Rep, Period> abs(std::chrono::duration<Rep, Period> d)
+{
+    return d;
+}
+
+template<typename Char, typename Rep, typename OutputIt, FMT_ENABLE_IF(std::is_integral<Rep>::value)>
+OutputIt format_duration_value(OutputIt out, Rep val, int)
+{
+    return write<Char>(out, val);
+}
+
+template<typename Char, typename Rep, typename OutputIt, FMT_ENABLE_IF(std::is_floating_point<Rep>::value)>
+OutputIt format_duration_value(OutputIt out, Rep val, int precision)
+{
+    auto specs = basic_format_specs<Char>();
+    specs.precision = precision;
+    specs.type = precision >= 0 ? presentation_type::fixed_lower : presentation_type::general_lower;
+    return write<Char>(out, val, specs);
+}
+
+template<typename Char, typename OutputIt>
+OutputIt copy_unit(string_view unit, OutputIt out, Char)
+{
+    return std::copy(unit.begin(), unit.end(), out);
+}
+
+template<typename OutputIt>
+OutputIt copy_unit(string_view unit, OutputIt out, wchar_t)
+{
+    // This works when wchar_t is UTF-32 because units only contain characters
+    // that have the same representation in UTF-16 and UTF-32.
+    utf8_to_utf16 u(unit);
+    return std::copy(u.c_str(), u.c_str() + u.size(), out);
+}
+
+template<typename Char, typename Period, typename OutputIt>
+OutputIt format_duration_unit(OutputIt out)
+{
+    if (const char *unit = get_units<Period>())
+        return copy_unit(string_view(unit), out, Char());
+    *out++ = '[';
+    out = write<Char>(out, Period::num);
+    if (const_check(Period::den != 1))
+    {
+        *out++ = '/';
+        out = write<Char>(out, Period::den);
+    }
+    *out++ = ']';
+    *out++ = 's';
+    return out;
+}
+
+class get_locale
+{
+private:
+    union
+    {
+        std::locale locale_;
+    };
+    bool has_locale_ = false;
+
+public:
+    get_locale(bool localized, locale_ref loc)
+        : has_locale_(localized)
+    {
+        if (localized)
+            ::new (&locale_) std::locale(loc.template get<std::locale>());
+    }
+    ~get_locale()
+    {
+        if (has_locale_)
+            locale_.~locale();
+    }
+    operator const std::locale &() const
+    {
+        return has_locale_ ? locale_ : get_classic_locale();
+    }
+};
+
+template<typename FormatContext, typename OutputIt, typename Rep, typename Period>
+struct chrono_formatter
+{
+    FormatContext &context;
+    OutputIt out;
+    int precision;
+    bool localized = false;
+    // rep is unsigned to avoid overflow.
+    using rep =
+        conditional_t<std::is_integral<Rep>::value && sizeof(Rep) < sizeof(int), unsigned, typename make_unsigned_or_unchanged<Rep>::type>;
+    rep val;
+    using seconds = std::chrono::duration<rep>;
+    seconds s;
+    using milliseconds = std::chrono::duration<rep, std::milli>;
+    bool negative;
+
+    using char_type = typename FormatContext::char_type;
+    using tm_writer_type = tm_writer<OutputIt, char_type>;
+
+    chrono_formatter(FormatContext &ctx, OutputIt o, std::chrono::duration<Rep, Period> d)
+        : context(ctx)
+        , out(o)
+        , val(static_cast<rep>(d.count()))
+        , negative(false)
+    {
+        if (d.count() < 0)
+        {
+            val = 0 - val;
+            negative = true;
+        }
+
+        // this may overflow and/or the result may not fit in the
+        // target type.
+#if FMT_SAFE_DURATION_CAST
+        // might need checked conversion (rep!=Rep)
+        auto tmpval = std::chrono::duration<rep, Period>(val);
+        s = fmt_safe_duration_cast<seconds>(tmpval);
+#else
+        s = std::chrono::duration_cast<seconds>(std::chrono::duration<rep, Period>(val));
+#endif
+    }
+
+    // returns true if nan or inf, writes to out.
+    bool handle_nan_inf()
+    {
+        if (isfinite(val))
+        {
+            return false;
+        }
+        if (isnan(val))
+        {
+            write_nan();
+            return true;
+        }
+        // must be +-inf
+        if (val > 0)
+        {
+            write_pinf();
+        }
+        else
+        {
+            write_ninf();
+        }
+        return true;
+    }
+
+    Rep hour() const
+    {
+        return static_cast<Rep>(mod((s.count() / 3600), 24));
+    }
+
+    Rep hour12() const
+    {
+        Rep hour = static_cast<Rep>(mod((s.count() / 3600), 12));
+        return hour <= 0 ? 12 : hour;
+    }
+
+    Rep minute() const
+    {
+        return static_cast<Rep>(mod((s.count() / 60), 60));
+    }
+    Rep second() const
+    {
+        return static_cast<Rep>(mod(s.count(), 60));
+    }
+
+    std::tm time() const
+    {
+        auto time = std::tm();
+        time.tm_hour = to_nonnegative_int(hour(), 24);
+        time.tm_min = to_nonnegative_int(minute(), 60);
+        time.tm_sec = to_nonnegative_int(second(), 60);
+        return time;
+    }
+
+    void write_sign()
+    {
+        if (negative)
+        {
+            *out++ = '-';
+            negative = false;
+        }
+    }
+
+    void write(Rep value, int width)
+    {
+        write_sign();
+        if (isnan(value))
+            return write_nan();
+        uint32_or_64_or_128_t<int> n = to_unsigned(to_nonnegative_int(value, max_value<int>()));
+        int num_digits = detail::count_digits(n);
+        if (width > num_digits)
+            out = std::fill_n(out, width - num_digits, '0');
+        out = format_decimal<char_type>(out, n, num_digits).end;
+    }
+
+    template<typename Duration>
+    void write_fractional_seconds(Duration d)
+    {
+        FMT_ASSERT(!std::is_floating_point<typename Duration::rep>::value, "");
+        constexpr auto num_fractional_digits = count_fractional_digits<Duration::period::num, Duration::period::den>::value;
+
+        using subsecond_precision =
+            std::chrono::duration<typename std::common_type<typename Duration::rep, std::chrono::seconds::rep>::type,
+                std::ratio<1, detail::pow10(num_fractional_digits)>>;
+        if (std::ratio_less<typename subsecond_precision::period, std::chrono::seconds::period>::value)
+        {
+            *out++ = '.';
+            auto fractional = detail::abs(d) - std::chrono::duration_cast<std::chrono::seconds>(d);
+            auto subseconds = std::chrono::treat_as_floating_point<typename subsecond_precision::rep>::value
+                                  ? fractional.count()
+                                  : std::chrono::duration_cast<subsecond_precision>(fractional).count();
+            uint32_or_64_or_128_t<long long> n = to_unsigned(to_nonnegative_int(subseconds, max_value<long long>()));
+            int num_digits = detail::count_digits(n);
+            if (num_fractional_digits > num_digits)
+                out = std::fill_n(out, num_fractional_digits - num_digits, '0');
+            out = format_decimal<char_type>(out, n, num_digits).end;
+        }
+    }
+
+    void write_nan()
+    {
+        std::copy_n("nan", 3, out);
+    }
+    void write_pinf()
+    {
+        std::copy_n("inf", 3, out);
+    }
+    void write_ninf()
+    {
+        std::copy_n("-inf", 4, out);
+    }
+
+    template<typename Callback, typename... Args>
+    void format_tm(const tm &time, Callback cb, Args... args)
+    {
+        if (isnan(val))
+            return write_nan();
+        get_locale loc(localized, context.locale());
+        auto w = tm_writer_type(loc, out, time);
+        (w.*cb)(args...);
+        out = w.out();
+    }
+
+    void on_text(const char_type *begin, const char_type *end)
+    {
+        std::copy(begin, end, out);
+    }
+
+    // These are not implemented because durations don't have date information.
+    void on_abbr_weekday() {}
+    void on_full_weekday() {}
+    void on_dec0_weekday(numeric_system) {}
+    void on_dec1_weekday(numeric_system) {}
+    void on_abbr_month() {}
+    void on_full_month() {}
+    void on_datetime(numeric_system) {}
+    void on_loc_date(numeric_system) {}
+    void on_loc_time(numeric_system) {}
+    void on_us_date() {}
+    void on_iso_date() {}
+    void on_utc_offset() {}
+    void on_tz_name() {}
+    void on_year(numeric_system) {}
+    void on_short_year(numeric_system) {}
+    void on_offset_year() {}
+    void on_century(numeric_system) {}
+    void on_iso_week_based_year() {}
+    void on_iso_week_based_short_year() {}
+    void on_dec_month(numeric_system) {}
+    void on_dec0_week_of_year(numeric_system) {}
+    void on_dec1_week_of_year(numeric_system) {}
+    void on_iso_week_of_year(numeric_system) {}
+    void on_day_of_year() {}
+    void on_day_of_month(numeric_system) {}
+    void on_day_of_month_space(numeric_system) {}
+
+    void on_24_hour(numeric_system ns)
+    {
+        if (handle_nan_inf())
+            return;
+
+        if (ns == numeric_system::standard)
+            return write(hour(), 2);
+        auto time = tm();
+        time.tm_hour = to_nonnegative_int(hour(), 24);
+        format_tm(time, &tm_writer_type::on_24_hour, ns);
+    }
+
+    void on_12_hour(numeric_system ns)
+    {
+        if (handle_nan_inf())
+            return;
+
+        if (ns == numeric_system::standard)
+            return write(hour12(), 2);
+        auto time = tm();
+        time.tm_hour = to_nonnegative_int(hour12(), 12);
+        format_tm(time, &tm_writer_type::on_12_hour, ns);
+    }
+
+    void on_minute(numeric_system ns)
+    {
+        if (handle_nan_inf())
+            return;
+
+        if (ns == numeric_system::standard)
+            return write(minute(), 2);
+        auto time = tm();
+        time.tm_min = to_nonnegative_int(minute(), 60);
+        format_tm(time, &tm_writer_type::on_minute, ns);
+    }
+
+    void on_second(numeric_system ns)
+    {
+        if (handle_nan_inf())
+            return;
+
+        if (ns == numeric_system::standard)
+        {
+            if (std::is_floating_point<rep>::value)
+            {
+                constexpr auto num_fractional_digits = count_fractional_digits<Period::num, Period::den>::value;
+                auto buf = memory_buffer();
+                format_to(std::back_inserter(buf), runtime("{:.{}f}"),
+                    std::fmod(val * static_cast<rep>(Period::num) / static_cast<rep>(Period::den), static_cast<rep>(60)),
+                    num_fractional_digits);
+                if (negative)
+                    *out++ = '-';
+                if (buf.size() < 2 || buf[1] == '.')
+                    *out++ = '0';
+                out = std::copy(buf.begin(), buf.end(), out);
+            }
+            else
+            {
+                write(second(), 2);
+                write_fractional_seconds(std::chrono::duration<rep, Period>(val));
+            }
+            return;
+        }
+        auto time = tm();
+        time.tm_sec = to_nonnegative_int(second(), 60);
+        format_tm(time, &tm_writer_type::on_second, ns);
+    }
+
+    void on_12_hour_time()
+    {
+        if (handle_nan_inf())
+            return;
+        format_tm(time(), &tm_writer_type::on_12_hour_time);
+    }
+
+    void on_24_hour_time()
+    {
+        if (handle_nan_inf())
+        {
+            *out++ = ':';
+            handle_nan_inf();
+            return;
+        }
+
+        write(hour(), 2);
+        *out++ = ':';
+        write(minute(), 2);
+    }
+
+    void on_iso_time()
+    {
+        on_24_hour_time();
+        *out++ = ':';
+        if (handle_nan_inf())
+            return;
+        on_second(numeric_system::standard);
+    }
+
+    void on_am_pm()
+    {
+        if (handle_nan_inf())
+            return;
+        format_tm(time(), &tm_writer_type::on_am_pm);
+    }
+
+    void on_duration_value()
+    {
+        if (handle_nan_inf())
+            return;
+        write_sign();
+        out = format_duration_value<char_type>(out, val, precision);
+    }
+
+    void on_duration_unit()
+    {
+        out = format_duration_unit<char_type, Period>(out);
+    }
+};
+
+FMT_END_DETAIL_NAMESPACE
+
+#if defined(__cpp_lib_chrono) && __cpp_lib_chrono >= 201907
+using weekday = std::chrono::weekday;
+#else
+// A fallback version of weekday.
+class weekday
+{
+private:
+    unsigned char value;
+
+public:
+    weekday() = default;
+    explicit constexpr weekday(unsigned wd) noexcept
+        : value(static_cast<unsigned char>(wd != 7 ? wd : 0))
+    {}
+    constexpr unsigned c_encoding() const noexcept
+    {
+        return value;
+    }
+};
+
+class year_month_day
+{};
+#endif
+
+// A rudimentary weekday formatter.
+template<typename Char>
+struct formatter<weekday, Char>
+{
+private:
+    bool localized = false;
+
+public:
+    FMT_CONSTEXPR auto parse(basic_format_parse_context<Char> &ctx) -> decltype(ctx.begin())
+    {
+        auto begin = ctx.begin(), end = ctx.end();
+        if (begin != end && *begin == 'L')
+        {
+            ++begin;
+            localized = true;
+        }
+        return begin;
+    }
+
+    template<typename FormatContext>
+    auto format(weekday wd, FormatContext &ctx) const -> decltype(ctx.out())
+    {
+        auto time = std::tm();
+        time.tm_wday = static_cast<int>(wd.c_encoding());
+        detail::get_locale loc(localized, ctx.locale());
+        auto w = detail::tm_writer<decltype(ctx.out()), Char>(loc, ctx.out(), time);
+        w.on_abbr_weekday();
+        return w.out();
+    }
+};
+
+template<typename Rep, typename Period, typename Char>
+struct formatter<std::chrono::duration<Rep, Period>, Char>
+{
+private:
+    basic_format_specs<Char> specs;
+    int precision = -1;
+    using arg_ref_type = detail::arg_ref<Char>;
+    arg_ref_type width_ref;
+    arg_ref_type precision_ref;
+    bool localized = false;
+    basic_string_view<Char> format_str;
+    using duration = std::chrono::duration<Rep, Period>;
+
+    struct spec_handler
+    {
+        formatter &f;
+        basic_format_parse_context<Char> &context;
+        basic_string_view<Char> format_str;
+
+        template<typename Id>
+        FMT_CONSTEXPR arg_ref_type make_arg_ref(Id arg_id)
+        {
+            context.check_arg_id(arg_id);
+            return arg_ref_type(arg_id);
+        }
+
+        FMT_CONSTEXPR arg_ref_type make_arg_ref(basic_string_view<Char> arg_id)
+        {
+            context.check_arg_id(arg_id);
+            return arg_ref_type(arg_id);
+        }
+
+        FMT_CONSTEXPR arg_ref_type make_arg_ref(detail::auto_id)
+        {
+            return arg_ref_type(context.next_arg_id());
+        }
+
+        void on_error(const char *msg)
+        {
+            FMT_THROW(format_error(msg));
+        }
+        FMT_CONSTEXPR void on_fill(basic_string_view<Char> fill)
+        {
+            f.specs.fill = fill;
+        }
+        FMT_CONSTEXPR void on_align(align_t align)
+        {
+            f.specs.align = align;
+        }
+        FMT_CONSTEXPR void on_width(int width)
+        {
+            f.specs.width = width;
+        }
+        FMT_CONSTEXPR void on_precision(int _precision)
+        {
+            f.precision = _precision;
+        }
+        FMT_CONSTEXPR void end_precision() {}
+
+        template<typename Id>
+        FMT_CONSTEXPR void on_dynamic_width(Id arg_id)
+        {
+            f.width_ref = make_arg_ref(arg_id);
+        }
+
+        template<typename Id>
+        FMT_CONSTEXPR void on_dynamic_precision(Id arg_id)
+        {
+            f.precision_ref = make_arg_ref(arg_id);
+        }
+    };
+
+    using iterator = typename basic_format_parse_context<Char>::iterator;
+    struct parse_range
+    {
+        iterator begin;
+        iterator end;
+    };
+
+    FMT_CONSTEXPR parse_range do_parse(basic_format_parse_context<Char> &ctx)
+    {
+        auto begin = ctx.begin(), end = ctx.end();
+        if (begin == end || *begin == '}')
+            return {begin, begin};
+        spec_handler handler{*this, ctx, format_str};
+        begin = detail::parse_align(begin, end, handler);
+        if (begin == end)
+            return {begin, begin};
+        begin = detail::parse_width(begin, end, handler);
+        if (begin == end)
+            return {begin, begin};
+        if (*begin == '.')
+        {
+            if (std::is_floating_point<Rep>::value)
+                begin = detail::parse_precision(begin, end, handler);
+            else
+                handler.on_error("precision not allowed for this argument type");
+        }
+        if (begin != end && *begin == 'L')
+        {
+            ++begin;
+            localized = true;
+        }
+        end = detail::parse_chrono_format(begin, end, detail::chrono_format_checker());
+        return {begin, end};
+    }
+
+public:
+    FMT_CONSTEXPR auto parse(basic_format_parse_context<Char> &ctx) -> decltype(ctx.begin())
+    {
+        auto range = do_parse(ctx);
+        format_str = basic_string_view<Char>(&*range.begin, detail::to_unsigned(range.end - range.begin));
+        return range.end;
+    }
+
+    template<typename FormatContext>
+    auto format(const duration &d, FormatContext &ctx) const -> decltype(ctx.out())
+    {
+        auto specs_copy = specs;
+        auto precision_copy = precision;
+        auto begin = format_str.begin(), end = format_str.end();
+        // As a possible future optimization, we could avoid extra copying if width
+        // is not specified.
+        basic_memory_buffer<Char> buf;
+        auto out = std::back_inserter(buf);
+        detail::handle_dynamic_spec<detail::width_checker>(specs_copy.width, width_ref, ctx);
+        detail::handle_dynamic_spec<detail::precision_checker>(precision_copy, precision_ref, ctx);
+        if (begin == end || *begin == '}')
+        {
+            out = detail::format_duration_value<Char>(out, d.count(), precision_copy);
+            detail::format_duration_unit<Char, Period>(out);
+        }
+        else
+        {
+            detail::chrono_formatter<FormatContext, decltype(out), Rep, Period> f(ctx, out, d);
+            f.precision = precision_copy;
+            f.localized = localized;
+            detail::parse_chrono_format(begin, end, f);
+        }
+        return detail::write(ctx.out(), basic_string_view<Char>(buf.data(), buf.size()), specs_copy);
+    }
+};
+
+template<typename Char, typename Duration>
+struct formatter<std::chrono::time_point<std::chrono::system_clock, Duration>, Char> : formatter<std::tm, Char>
+{
+    FMT_CONSTEXPR formatter()
+    {
+        basic_string_view<Char> default_specs = detail::string_literal<Char, '%', 'F', ' ', '%', 'T'>{};
+        this->do_parse(default_specs.begin(), default_specs.end());
+    }
+
+    template<typename FormatContext>
+    auto format(std::chrono::time_point<std::chrono::system_clock> val, FormatContext &ctx) const -> decltype(ctx.out())
+    {
+        return formatter<std::tm, Char>::format(localtime(val), ctx);
+    }
+};
+
+template<typename Char>
+struct formatter<std::tm, Char>
+{
+private:
+    enum class spec
+    {
+        unknown,
+        year_month_day,
+        hh_mm_ss,
+    };
+    spec spec_ = spec::unknown;
+    basic_string_view<Char> specs;
+
+protected:
+    template<typename It>
+    FMT_CONSTEXPR auto do_parse(It begin, It end) -> It
+    {
+        if (begin != end && *begin == ':')
+            ++begin;
+        end = detail::parse_chrono_format(begin, end, detail::tm_format_checker());
+        // Replace default spec only if the new spec is not empty.
+        if (end != begin)
+            specs = {begin, detail::to_unsigned(end - begin)};
+        return end;
+    }
+
+public:
+    FMT_CONSTEXPR auto parse(basic_format_parse_context<Char> &ctx) -> decltype(ctx.begin())
+    {
+        auto end = this->do_parse(ctx.begin(), ctx.end());
+        // basic_string_view<>::compare isn't constexpr before C++17.
+        if (specs.size() == 2 && specs[0] == Char('%'))
+        {
+            if (specs[1] == Char('F'))
+                spec_ = spec::year_month_day;
+            else if (specs[1] == Char('T'))
+                spec_ = spec::hh_mm_ss;
+        }
+        return end;
+    }
+
+    template<typename FormatContext>
+    auto format(const std::tm &tm, FormatContext &ctx) const -> decltype(ctx.out())
+    {
+        const auto loc_ref = ctx.locale();
+        detail::get_locale loc(static_cast<bool>(loc_ref), loc_ref);
+        auto w = detail::tm_writer<decltype(ctx.out()), Char>(loc, ctx.out(), tm);
+        if (spec_ == spec::year_month_day)
+            w.on_iso_date();
+        else if (spec_ == spec::hh_mm_ss)
+            w.on_iso_time();
+        else
+            detail::parse_chrono_format(specs.begin(), specs.end(), w);
+        return w.out();
+    }
+};
+
+FMT_MODULE_EXPORT_END
+FMT_END_NAMESPACE
+
+#endif // FMT_CHRONO_H_
diff --git a/3rdparty/spdlog/src/include/spdlog/fmt/bundled/color.h b/3rdparty/spdlog/src/include/spdlog/fmt/bundled/color.h
new file mode 100644
index 00000000..c69467d5
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/fmt/bundled/color.h
@@ -0,0 +1,745 @@
+// Formatting library for C++ - color support
+//
+// Copyright (c) 2018 - present, Victor Zverovich and fmt contributors
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#ifndef FMT_COLOR_H_
+#define FMT_COLOR_H_
+
+#include "format.h"
+
+FMT_BEGIN_NAMESPACE
+FMT_MODULE_EXPORT_BEGIN
+
+enum class color : uint32_t
+{
+    alice_blue = 0xF0F8FF,              // rgb(240,248,255)
+    antique_white = 0xFAEBD7,           // rgb(250,235,215)
+    aqua = 0x00FFFF,                    // rgb(0,255,255)
+    aquamarine = 0x7FFFD4,              // rgb(127,255,212)
+    azure = 0xF0FFFF,                   // rgb(240,255,255)
+    beige = 0xF5F5DC,                   // rgb(245,245,220)
+    bisque = 0xFFE4C4,                  // rgb(255,228,196)
+    black = 0x000000,                   // rgb(0,0,0)
+    blanched_almond = 0xFFEBCD,         // rgb(255,235,205)
+    blue = 0x0000FF,                    // rgb(0,0,255)
+    blue_violet = 0x8A2BE2,             // rgb(138,43,226)
+    brown = 0xA52A2A,                   // rgb(165,42,42)
+    burly_wood = 0xDEB887,              // rgb(222,184,135)
+    cadet_blue = 0x5F9EA0,              // rgb(95,158,160)
+    chartreuse = 0x7FFF00,              // rgb(127,255,0)
+    chocolate = 0xD2691E,               // rgb(210,105,30)
+    coral = 0xFF7F50,                   // rgb(255,127,80)
+    cornflower_blue = 0x6495ED,         // rgb(100,149,237)
+    cornsilk = 0xFFF8DC,                // rgb(255,248,220)
+    crimson = 0xDC143C,                 // rgb(220,20,60)
+    cyan = 0x00FFFF,                    // rgb(0,255,255)
+    dark_blue = 0x00008B,               // rgb(0,0,139)
+    dark_cyan = 0x008B8B,               // rgb(0,139,139)
+    dark_golden_rod = 0xB8860B,         // rgb(184,134,11)
+    dark_gray = 0xA9A9A9,               // rgb(169,169,169)
+    dark_green = 0x006400,              // rgb(0,100,0)
+    dark_khaki = 0xBDB76B,              // rgb(189,183,107)
+    dark_magenta = 0x8B008B,            // rgb(139,0,139)
+    dark_olive_green = 0x556B2F,        // rgb(85,107,47)
+    dark_orange = 0xFF8C00,             // rgb(255,140,0)
+    dark_orchid = 0x9932CC,             // rgb(153,50,204)
+    dark_red = 0x8B0000,                // rgb(139,0,0)
+    dark_salmon = 0xE9967A,             // rgb(233,150,122)
+    dark_sea_green = 0x8FBC8F,          // rgb(143,188,143)
+    dark_slate_blue = 0x483D8B,         // rgb(72,61,139)
+    dark_slate_gray = 0x2F4F4F,         // rgb(47,79,79)
+    dark_turquoise = 0x00CED1,          // rgb(0,206,209)
+    dark_violet = 0x9400D3,             // rgb(148,0,211)
+    deep_pink = 0xFF1493,               // rgb(255,20,147)
+    deep_sky_blue = 0x00BFFF,           // rgb(0,191,255)
+    dim_gray = 0x696969,                // rgb(105,105,105)
+    dodger_blue = 0x1E90FF,             // rgb(30,144,255)
+    fire_brick = 0xB22222,              // rgb(178,34,34)
+    floral_white = 0xFFFAF0,            // rgb(255,250,240)
+    forest_green = 0x228B22,            // rgb(34,139,34)
+    fuchsia = 0xFF00FF,                 // rgb(255,0,255)
+    gainsboro = 0xDCDCDC,               // rgb(220,220,220)
+    ghost_white = 0xF8F8FF,             // rgb(248,248,255)
+    gold = 0xFFD700,                    // rgb(255,215,0)
+    golden_rod = 0xDAA520,              // rgb(218,165,32)
+    gray = 0x808080,                    // rgb(128,128,128)
+    green = 0x008000,                   // rgb(0,128,0)
+    green_yellow = 0xADFF2F,            // rgb(173,255,47)
+    honey_dew = 0xF0FFF0,               // rgb(240,255,240)
+    hot_pink = 0xFF69B4,                // rgb(255,105,180)
+    indian_red = 0xCD5C5C,              // rgb(205,92,92)
+    indigo = 0x4B0082,                  // rgb(75,0,130)
+    ivory = 0xFFFFF0,                   // rgb(255,255,240)
+    khaki = 0xF0E68C,                   // rgb(240,230,140)
+    lavender = 0xE6E6FA,                // rgb(230,230,250)
+    lavender_blush = 0xFFF0F5,          // rgb(255,240,245)
+    lawn_green = 0x7CFC00,              // rgb(124,252,0)
+    lemon_chiffon = 0xFFFACD,           // rgb(255,250,205)
+    light_blue = 0xADD8E6,              // rgb(173,216,230)
+    light_coral = 0xF08080,             // rgb(240,128,128)
+    light_cyan = 0xE0FFFF,              // rgb(224,255,255)
+    light_golden_rod_yellow = 0xFAFAD2, // rgb(250,250,210)
+    light_gray = 0xD3D3D3,              // rgb(211,211,211)
+    light_green = 0x90EE90,             // rgb(144,238,144)
+    light_pink = 0xFFB6C1,              // rgb(255,182,193)
+    light_salmon = 0xFFA07A,            // rgb(255,160,122)
+    light_sea_green = 0x20B2AA,         // rgb(32,178,170)
+    light_sky_blue = 0x87CEFA,          // rgb(135,206,250)
+    light_slate_gray = 0x778899,        // rgb(119,136,153)
+    light_steel_blue = 0xB0C4DE,        // rgb(176,196,222)
+    light_yellow = 0xFFFFE0,            // rgb(255,255,224)
+    lime = 0x00FF00,                    // rgb(0,255,0)
+    lime_green = 0x32CD32,              // rgb(50,205,50)
+    linen = 0xFAF0E6,                   // rgb(250,240,230)
+    magenta = 0xFF00FF,                 // rgb(255,0,255)
+    maroon = 0x800000,                  // rgb(128,0,0)
+    medium_aquamarine = 0x66CDAA,       // rgb(102,205,170)
+    medium_blue = 0x0000CD,             // rgb(0,0,205)
+    medium_orchid = 0xBA55D3,           // rgb(186,85,211)
+    medium_purple = 0x9370DB,           // rgb(147,112,219)
+    medium_sea_green = 0x3CB371,        // rgb(60,179,113)
+    medium_slate_blue = 0x7B68EE,       // rgb(123,104,238)
+    medium_spring_green = 0x00FA9A,     // rgb(0,250,154)
+    medium_turquoise = 0x48D1CC,        // rgb(72,209,204)
+    medium_violet_red = 0xC71585,       // rgb(199,21,133)
+    midnight_blue = 0x191970,           // rgb(25,25,112)
+    mint_cream = 0xF5FFFA,              // rgb(245,255,250)
+    misty_rose = 0xFFE4E1,              // rgb(255,228,225)
+    moccasin = 0xFFE4B5,                // rgb(255,228,181)
+    navajo_white = 0xFFDEAD,            // rgb(255,222,173)
+    navy = 0x000080,                    // rgb(0,0,128)
+    old_lace = 0xFDF5E6,                // rgb(253,245,230)
+    olive = 0x808000,                   // rgb(128,128,0)
+    olive_drab = 0x6B8E23,              // rgb(107,142,35)
+    orange = 0xFFA500,                  // rgb(255,165,0)
+    orange_red = 0xFF4500,              // rgb(255,69,0)
+    orchid = 0xDA70D6,                  // rgb(218,112,214)
+    pale_golden_rod = 0xEEE8AA,         // rgb(238,232,170)
+    pale_green = 0x98FB98,              // rgb(152,251,152)
+    pale_turquoise = 0xAFEEEE,          // rgb(175,238,238)
+    pale_violet_red = 0xDB7093,         // rgb(219,112,147)
+    papaya_whip = 0xFFEFD5,             // rgb(255,239,213)
+    peach_puff = 0xFFDAB9,              // rgb(255,218,185)
+    peru = 0xCD853F,                    // rgb(205,133,63)
+    pink = 0xFFC0CB,                    // rgb(255,192,203)
+    plum = 0xDDA0DD,                    // rgb(221,160,221)
+    powder_blue = 0xB0E0E6,             // rgb(176,224,230)
+    purple = 0x800080,                  // rgb(128,0,128)
+    rebecca_purple = 0x663399,          // rgb(102,51,153)
+    red = 0xFF0000,                     // rgb(255,0,0)
+    rosy_brown = 0xBC8F8F,              // rgb(188,143,143)
+    royal_blue = 0x4169E1,              // rgb(65,105,225)
+    saddle_brown = 0x8B4513,            // rgb(139,69,19)
+    salmon = 0xFA8072,                  // rgb(250,128,114)
+    sandy_brown = 0xF4A460,             // rgb(244,164,96)
+    sea_green = 0x2E8B57,               // rgb(46,139,87)
+    sea_shell = 0xFFF5EE,               // rgb(255,245,238)
+    sienna = 0xA0522D,                  // rgb(160,82,45)
+    silver = 0xC0C0C0,                  // rgb(192,192,192)
+    sky_blue = 0x87CEEB,                // rgb(135,206,235)
+    slate_blue = 0x6A5ACD,              // rgb(106,90,205)
+    slate_gray = 0x708090,              // rgb(112,128,144)
+    snow = 0xFFFAFA,                    // rgb(255,250,250)
+    spring_green = 0x00FF7F,            // rgb(0,255,127)
+    steel_blue = 0x4682B4,              // rgb(70,130,180)
+    tan = 0xD2B48C,                     // rgb(210,180,140)
+    teal = 0x008080,                    // rgb(0,128,128)
+    thistle = 0xD8BFD8,                 // rgb(216,191,216)
+    tomato = 0xFF6347,                  // rgb(255,99,71)
+    turquoise = 0x40E0D0,               // rgb(64,224,208)
+    violet = 0xEE82EE,                  // rgb(238,130,238)
+    wheat = 0xF5DEB3,                   // rgb(245,222,179)
+    white = 0xFFFFFF,                   // rgb(255,255,255)
+    white_smoke = 0xF5F5F5,             // rgb(245,245,245)
+    yellow = 0xFFFF00,                  // rgb(255,255,0)
+    yellow_green = 0x9ACD32             // rgb(154,205,50)
+};                                      // enum class color
+
+enum class terminal_color : uint8_t
+{
+    black = 30,
+    red,
+    green,
+    yellow,
+    blue,
+    magenta,
+    cyan,
+    white,
+    bright_black = 90,
+    bright_red,
+    bright_green,
+    bright_yellow,
+    bright_blue,
+    bright_magenta,
+    bright_cyan,
+    bright_white
+};
+
+enum class emphasis : uint8_t
+{
+    bold = 1,
+    faint = 1 << 1,
+    italic = 1 << 2,
+    underline = 1 << 3,
+    blink = 1 << 4,
+    reverse = 1 << 5,
+    conceal = 1 << 6,
+    strikethrough = 1 << 7,
+};
+
+// rgb is a struct for red, green and blue colors.
+// Using the name "rgb" makes some editors show the color in a tooltip.
+struct rgb
+{
+    FMT_CONSTEXPR rgb()
+        : r(0)
+        , g(0)
+        , b(0)
+    {}
+    FMT_CONSTEXPR rgb(uint8_t r_, uint8_t g_, uint8_t b_)
+        : r(r_)
+        , g(g_)
+        , b(b_)
+    {}
+    FMT_CONSTEXPR rgb(uint32_t hex)
+        : r((hex >> 16) & 0xFF)
+        , g((hex >> 8) & 0xFF)
+        , b(hex & 0xFF)
+    {}
+    FMT_CONSTEXPR rgb(color hex)
+        : r((uint32_t(hex) >> 16) & 0xFF)
+        , g((uint32_t(hex) >> 8) & 0xFF)
+        , b(uint32_t(hex) & 0xFF)
+    {}
+    uint8_t r;
+    uint8_t g;
+    uint8_t b;
+};
+
+FMT_BEGIN_DETAIL_NAMESPACE
+
+// color is a struct of either a rgb color or a terminal color.
+struct color_type
+{
+    FMT_CONSTEXPR color_type() noexcept
+        : is_rgb()
+        , value{}
+    {}
+    FMT_CONSTEXPR color_type(color rgb_color) noexcept
+        : is_rgb(true)
+        , value{}
+    {
+        value.rgb_color = static_cast<uint32_t>(rgb_color);
+    }
+    FMT_CONSTEXPR color_type(rgb rgb_color) noexcept
+        : is_rgb(true)
+        , value{}
+    {
+        value.rgb_color = (static_cast<uint32_t>(rgb_color.r) << 16) | (static_cast<uint32_t>(rgb_color.g) << 8) | rgb_color.b;
+    }
+    FMT_CONSTEXPR color_type(terminal_color term_color) noexcept
+        : is_rgb()
+        , value{}
+    {
+        value.term_color = static_cast<uint8_t>(term_color);
+    }
+    bool is_rgb;
+    union color_union
+    {
+        uint8_t term_color;
+        uint32_t rgb_color;
+    } value;
+};
+
+FMT_END_DETAIL_NAMESPACE
+
+/** A text style consisting of foreground and background colors and emphasis. */
+class text_style
+{
+public:
+    FMT_CONSTEXPR text_style(emphasis em = emphasis()) noexcept
+        : set_foreground_color()
+        , set_background_color()
+        , ems(em)
+    {}
+
+    FMT_CONSTEXPR text_style &operator|=(const text_style &rhs)
+    {
+        if (!set_foreground_color)
+        {
+            set_foreground_color = rhs.set_foreground_color;
+            foreground_color = rhs.foreground_color;
+        }
+        else if (rhs.set_foreground_color)
+        {
+            if (!foreground_color.is_rgb || !rhs.foreground_color.is_rgb)
+                FMT_THROW(format_error("can't OR a terminal color"));
+            foreground_color.value.rgb_color |= rhs.foreground_color.value.rgb_color;
+        }
+
+        if (!set_background_color)
+        {
+            set_background_color = rhs.set_background_color;
+            background_color = rhs.background_color;
+        }
+        else if (rhs.set_background_color)
+        {
+            if (!background_color.is_rgb || !rhs.background_color.is_rgb)
+                FMT_THROW(format_error("can't OR a terminal color"));
+            background_color.value.rgb_color |= rhs.background_color.value.rgb_color;
+        }
+
+        ems = static_cast<emphasis>(static_cast<uint8_t>(ems) | static_cast<uint8_t>(rhs.ems));
+        return *this;
+    }
+
+    friend FMT_CONSTEXPR text_style operator|(text_style lhs, const text_style &rhs)
+    {
+        return lhs |= rhs;
+    }
+
+    FMT_CONSTEXPR bool has_foreground() const noexcept
+    {
+        return set_foreground_color;
+    }
+    FMT_CONSTEXPR bool has_background() const noexcept
+    {
+        return set_background_color;
+    }
+    FMT_CONSTEXPR bool has_emphasis() const noexcept
+    {
+        return static_cast<uint8_t>(ems) != 0;
+    }
+    FMT_CONSTEXPR detail::color_type get_foreground() const noexcept
+    {
+        FMT_ASSERT(has_foreground(), "no foreground specified for this style");
+        return foreground_color;
+    }
+    FMT_CONSTEXPR detail::color_type get_background() const noexcept
+    {
+        FMT_ASSERT(has_background(), "no background specified for this style");
+        return background_color;
+    }
+    FMT_CONSTEXPR emphasis get_emphasis() const noexcept
+    {
+        FMT_ASSERT(has_emphasis(), "no emphasis specified for this style");
+        return ems;
+    }
+
+private:
+    FMT_CONSTEXPR text_style(bool is_foreground, detail::color_type text_color) noexcept
+        : set_foreground_color()
+        , set_background_color()
+        , ems()
+    {
+        if (is_foreground)
+        {
+            foreground_color = text_color;
+            set_foreground_color = true;
+        }
+        else
+        {
+            background_color = text_color;
+            set_background_color = true;
+        }
+    }
+
+    friend FMT_CONSTEXPR text_style fg(detail::color_type foreground) noexcept;
+
+    friend FMT_CONSTEXPR text_style bg(detail::color_type background) noexcept;
+
+    detail::color_type foreground_color;
+    detail::color_type background_color;
+    bool set_foreground_color;
+    bool set_background_color;
+    emphasis ems;
+};
+
+/** Creates a text style from the foreground (text) color. */
+FMT_CONSTEXPR inline text_style fg(detail::color_type foreground) noexcept
+{
+    return text_style(true, foreground);
+}
+
+/** Creates a text style from the background color. */
+FMT_CONSTEXPR inline text_style bg(detail::color_type background) noexcept
+{
+    return text_style(false, background);
+}
+
+FMT_CONSTEXPR inline text_style operator|(emphasis lhs, emphasis rhs) noexcept
+{
+    return text_style(lhs) | rhs;
+}
+
+FMT_BEGIN_DETAIL_NAMESPACE
+
+template<typename Char>
+struct ansi_color_escape
+{
+    FMT_CONSTEXPR ansi_color_escape(detail::color_type text_color, const char *esc) noexcept
+    {
+        // If we have a terminal color, we need to output another escape code
+        // sequence.
+        if (!text_color.is_rgb)
+        {
+            bool is_background = esc == string_view("\x1b[48;2;");
+            uint32_t value = text_color.value.term_color;
+            // Background ASCII codes are the same as the foreground ones but with
+            // 10 more.
+            if (is_background)
+                value += 10u;
+
+            size_t index = 0;
+            buffer[index++] = static_cast<Char>('\x1b');
+            buffer[index++] = static_cast<Char>('[');
+
+            if (value >= 100u)
+            {
+                buffer[index++] = static_cast<Char>('1');
+                value %= 100u;
+            }
+            buffer[index++] = static_cast<Char>('0' + value / 10u);
+            buffer[index++] = static_cast<Char>('0' + value % 10u);
+
+            buffer[index++] = static_cast<Char>('m');
+            buffer[index++] = static_cast<Char>('\0');
+            return;
+        }
+
+        for (int i = 0; i < 7; i++)
+        {
+            buffer[i] = static_cast<Char>(esc[i]);
+        }
+        rgb color(text_color.value.rgb_color);
+        to_esc(color.r, buffer + 7, ';');
+        to_esc(color.g, buffer + 11, ';');
+        to_esc(color.b, buffer + 15, 'm');
+        buffer[19] = static_cast<Char>(0);
+    }
+    FMT_CONSTEXPR ansi_color_escape(emphasis em) noexcept
+    {
+        uint8_t em_codes[num_emphases] = {};
+        if (has_emphasis(em, emphasis::bold))
+            em_codes[0] = 1;
+        if (has_emphasis(em, emphasis::faint))
+            em_codes[1] = 2;
+        if (has_emphasis(em, emphasis::italic))
+            em_codes[2] = 3;
+        if (has_emphasis(em, emphasis::underline))
+            em_codes[3] = 4;
+        if (has_emphasis(em, emphasis::blink))
+            em_codes[4] = 5;
+        if (has_emphasis(em, emphasis::reverse))
+            em_codes[5] = 7;
+        if (has_emphasis(em, emphasis::conceal))
+            em_codes[6] = 8;
+        if (has_emphasis(em, emphasis::strikethrough))
+            em_codes[7] = 9;
+
+        size_t index = 0;
+        for (size_t i = 0; i < num_emphases; ++i)
+        {
+            if (!em_codes[i])
+                continue;
+            buffer[index++] = static_cast<Char>('\x1b');
+            buffer[index++] = static_cast<Char>('[');
+            buffer[index++] = static_cast<Char>('0' + em_codes[i]);
+            buffer[index++] = static_cast<Char>('m');
+        }
+        buffer[index++] = static_cast<Char>(0);
+    }
+    FMT_CONSTEXPR operator const Char *() const noexcept
+    {
+        return buffer;
+    }
+
+    FMT_CONSTEXPR const Char *begin() const noexcept
+    {
+        return buffer;
+    }
+    FMT_CONSTEXPR_CHAR_TRAITS const Char *end() const noexcept
+    {
+        return buffer + std::char_traits<Char>::length(buffer);
+    }
+
+private:
+    static constexpr size_t num_emphases = 8;
+    Char buffer[7u + 3u * num_emphases + 1u];
+
+    static FMT_CONSTEXPR void to_esc(uint8_t c, Char *out, char delimiter) noexcept
+    {
+        out[0] = static_cast<Char>('0' + c / 100);
+        out[1] = static_cast<Char>('0' + c / 10 % 10);
+        out[2] = static_cast<Char>('0' + c % 10);
+        out[3] = static_cast<Char>(delimiter);
+    }
+    static FMT_CONSTEXPR bool has_emphasis(emphasis em, emphasis mask) noexcept
+    {
+        return static_cast<uint8_t>(em) & static_cast<uint8_t>(mask);
+    }
+};
+
+template<typename Char>
+FMT_CONSTEXPR ansi_color_escape<Char> make_foreground_color(detail::color_type foreground) noexcept
+{
+    return ansi_color_escape<Char>(foreground, "\x1b[38;2;");
+}
+
+template<typename Char>
+FMT_CONSTEXPR ansi_color_escape<Char> make_background_color(detail::color_type background) noexcept
+{
+    return ansi_color_escape<Char>(background, "\x1b[48;2;");
+}
+
+template<typename Char>
+FMT_CONSTEXPR ansi_color_escape<Char> make_emphasis(emphasis em) noexcept
+{
+    return ansi_color_escape<Char>(em);
+}
+
+template<typename Char>
+inline void fputs(const Char *chars, FILE *stream)
+{
+    int result = std::fputs(chars, stream);
+    if (result < 0)
+        FMT_THROW(system_error(errno, FMT_STRING("cannot write to file")));
+}
+
+template<>
+inline void fputs<wchar_t>(const wchar_t *chars, FILE *stream)
+{
+    int result = std::fputws(chars, stream);
+    if (result < 0)
+        FMT_THROW(system_error(errno, FMT_STRING("cannot write to file")));
+}
+
+template<typename Char>
+inline void reset_color(FILE *stream)
+{
+    fputs("\x1b[0m", stream);
+}
+
+template<>
+inline void reset_color<wchar_t>(FILE *stream)
+{
+    fputs(L"\x1b[0m", stream);
+}
+
+template<typename Char>
+inline void reset_color(buffer<Char> &buffer)
+{
+    auto reset_color = string_view("\x1b[0m");
+    buffer.append(reset_color.begin(), reset_color.end());
+}
+
+template<typename T>
+struct styled_arg
+{
+    const T &value;
+    text_style style;
+};
+
+template<typename Char>
+void vformat_to(buffer<Char> &buf, const text_style &ts, basic_string_view<Char> format_str,
+    basic_format_args<buffer_context<type_identity_t<Char>>> args)
+{
+    bool has_style = false;
+    if (ts.has_emphasis())
+    {
+        has_style = true;
+        auto emphasis = detail::make_emphasis<Char>(ts.get_emphasis());
+        buf.append(emphasis.begin(), emphasis.end());
+    }
+    if (ts.has_foreground())
+    {
+        has_style = true;
+        auto foreground = detail::make_foreground_color<Char>(ts.get_foreground());
+        buf.append(foreground.begin(), foreground.end());
+    }
+    if (ts.has_background())
+    {
+        has_style = true;
+        auto background = detail::make_background_color<Char>(ts.get_background());
+        buf.append(background.begin(), background.end());
+    }
+    detail::vformat_to(buf, format_str, args, {});
+    if (has_style)
+        detail::reset_color<Char>(buf);
+}
+
+FMT_END_DETAIL_NAMESPACE
+
+template<typename S, typename Char = char_t<S>>
+void vprint(std::FILE *f, const text_style &ts, const S &format, basic_format_args<buffer_context<type_identity_t<Char>>> args)
+{
+    basic_memory_buffer<Char> buf;
+    detail::vformat_to(buf, ts, detail::to_string_view(format), args);
+    if (detail::is_utf8())
+    {
+        detail::print(f, basic_string_view<Char>(buf.begin(), buf.size()));
+    }
+    else
+    {
+        buf.push_back(Char(0));
+        detail::fputs(buf.data(), f);
+    }
+}
+
+/**
+  \rst
+  Formats a string and prints it to the specified file stream using ANSI
+  escape sequences to specify text formatting.
+
+  **Example**::
+
+    fmt::print(fmt::emphasis::bold | fg(fmt::color::red),
+               "Elapsed time: {0:.2f} seconds", 1.23);
+  \endrst
+ */
+template<typename S, typename... Args, FMT_ENABLE_IF(detail::is_string<S>::value)>
+void print(std::FILE *f, const text_style &ts, const S &format_str, const Args &...args)
+{
+    vprint(f, ts, format_str, fmt::make_format_args<buffer_context<char_t<S>>>(args...));
+}
+
+/**
+  \rst
+  Formats a string and prints it to stdout using ANSI escape sequences to
+  specify text formatting.
+
+  **Example**::
+
+    fmt::print(fmt::emphasis::bold | fg(fmt::color::red),
+               "Elapsed time: {0:.2f} seconds", 1.23);
+  \endrst
+ */
+template<typename S, typename... Args, FMT_ENABLE_IF(detail::is_string<S>::value)>
+void print(const text_style &ts, const S &format_str, const Args &...args)
+{
+    return print(stdout, ts, format_str, args...);
+}
+
+template<typename S, typename Char = char_t<S>>
+inline std::basic_string<Char> vformat(
+    const text_style &ts, const S &format_str, basic_format_args<buffer_context<type_identity_t<Char>>> args)
+{
+    basic_memory_buffer<Char> buf;
+    detail::vformat_to(buf, ts, detail::to_string_view(format_str), args);
+    return fmt::to_string(buf);
+}
+
+/**
+  \rst
+  Formats arguments and returns the result as a string using ANSI
+  escape sequences to specify text formatting.
+
+  **Example**::
+
+    #include <fmt/color.h>
+    std::string message = fmt::format(fmt::emphasis::bold | fg(fmt::color::red),
+                                      "The answer is {}", 42);
+  \endrst
+*/
+template<typename S, typename... Args, typename Char = char_t<S>>
+inline std::basic_string<Char> format(const text_style &ts, const S &format_str, const Args &...args)
+{
+    return fmt::vformat(ts, detail::to_string_view(format_str), fmt::make_format_args<buffer_context<Char>>(args...));
+}
+
+/**
+  Formats a string with the given text_style and writes the output to ``out``.
+ */
+template<typename OutputIt, typename Char, FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value)>
+OutputIt vformat_to(
+    OutputIt out, const text_style &ts, basic_string_view<Char> format_str, basic_format_args<buffer_context<type_identity_t<Char>>> args)
+{
+    auto &&buf = detail::get_buffer<Char>(out);
+    detail::vformat_to(buf, ts, format_str, args);
+    return detail::get_iterator(buf);
+}
+
+/**
+  \rst
+  Formats arguments with the given text_style, writes the result to the output
+  iterator ``out`` and returns the iterator past the end of the output range.
+
+  **Example**::
+
+    std::vector<char> out;
+    fmt::format_to(std::back_inserter(out),
+                   fmt::emphasis::bold | fg(fmt::color::red), "{}", 42);
+  \endrst
+*/
+template<typename OutputIt, typename S, typename... Args,
+    bool enable = detail::is_output_iterator<OutputIt, char_t<S>>::value &&detail::is_string<S>::value>
+inline auto format_to(OutputIt out, const text_style &ts, const S &format_str, Args &&...args) ->
+    typename std::enable_if<enable, OutputIt>::type
+{
+    return vformat_to(out, ts, detail::to_string_view(format_str), fmt::make_format_args<buffer_context<char_t<S>>>(args...));
+}
+
+template<typename T, typename Char>
+struct formatter<detail::styled_arg<T>, Char> : formatter<T, Char>
+{
+    template<typename FormatContext>
+    auto format(const detail::styled_arg<T> &arg, FormatContext &ctx) const -> decltype(ctx.out())
+    {
+        const auto &ts = arg.style;
+        const auto &value = arg.value;
+        auto out = ctx.out();
+
+        bool has_style = false;
+        if (ts.has_emphasis())
+        {
+            has_style = true;
+            auto emphasis = detail::make_emphasis<Char>(ts.get_emphasis());
+            out = std::copy(emphasis.begin(), emphasis.end(), out);
+        }
+        if (ts.has_foreground())
+        {
+            has_style = true;
+            auto foreground = detail::make_foreground_color<Char>(ts.get_foreground());
+            out = std::copy(foreground.begin(), foreground.end(), out);
+        }
+        if (ts.has_background())
+        {
+            has_style = true;
+            auto background = detail::make_background_color<Char>(ts.get_background());
+            out = std::copy(background.begin(), background.end(), out);
+        }
+        out = formatter<T, Char>::format(value, ctx);
+        if (has_style)
+        {
+            auto reset_color = string_view("\x1b[0m");
+            out = std::copy(reset_color.begin(), reset_color.end(), out);
+        }
+        return out;
+    }
+};
+
+/**
+  \rst
+  Returns an argument that will be formatted using ANSI escape sequences,
+  to be used in a formatting function.
+
+  **Example**::
+
+    fmt::print("Elapsed time: {0:.2f} seconds",
+               fmt::styled(1.23, fmt::fg(fmt::color::green) |
+                                 fmt::bg(fmt::color::blue)));
+  \endrst
+ */
+template<typename T>
+FMT_CONSTEXPR auto styled(const T &value, text_style ts) -> detail::styled_arg<remove_cvref_t<T>>
+{
+    return detail::styled_arg<remove_cvref_t<T>>{value, ts};
+}
+
+FMT_MODULE_EXPORT_END
+FMT_END_NAMESPACE
+
+#endif // FMT_COLOR_H_
diff --git a/3rdparty/spdlog/src/include/spdlog/fmt/bundled/compile.h b/3rdparty/spdlog/src/include/spdlog/fmt/bundled/compile.h
new file mode 100644
index 00000000..ebf0a7ef
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/fmt/bundled/compile.h
@@ -0,0 +1,706 @@
+// Formatting library for C++ - experimental format string compilation
+//
+// Copyright (c) 2012 - present, Victor Zverovich and fmt contributors
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#ifndef FMT_COMPILE_H_
+#define FMT_COMPILE_H_
+
+#include "format.h"
+
+FMT_BEGIN_NAMESPACE
+namespace detail {
+
+template<typename Char, typename InputIt>
+FMT_CONSTEXPR inline counting_iterator copy_str(InputIt begin, InputIt end, counting_iterator it)
+{
+    return it + (end - begin);
+}
+
+template<typename OutputIt>
+class truncating_iterator_base
+{
+protected:
+    OutputIt out_;
+    size_t limit_;
+    size_t count_ = 0;
+
+    truncating_iterator_base()
+        : out_()
+        , limit_(0)
+    {}
+
+    truncating_iterator_base(OutputIt out, size_t limit)
+        : out_(out)
+        , limit_(limit)
+    {}
+
+public:
+    using iterator_category = std::output_iterator_tag;
+    using value_type = typename std::iterator_traits<OutputIt>::value_type;
+    using difference_type = std::ptrdiff_t;
+    using pointer = void;
+    using reference = void;
+    FMT_UNCHECKED_ITERATOR(truncating_iterator_base);
+
+    OutputIt base() const
+    {
+        return out_;
+    }
+    size_t count() const
+    {
+        return count_;
+    }
+};
+
+// An output iterator that truncates the output and counts the number of objects
+// written to it.
+template<typename OutputIt, typename Enable = typename std::is_void<typename std::iterator_traits<OutputIt>::value_type>::type>
+class truncating_iterator;
+
+template<typename OutputIt>
+class truncating_iterator<OutputIt, std::false_type> : public truncating_iterator_base<OutputIt>
+{
+    mutable typename truncating_iterator_base<OutputIt>::value_type blackhole_;
+
+public:
+    using value_type = typename truncating_iterator_base<OutputIt>::value_type;
+
+    truncating_iterator() = default;
+
+    truncating_iterator(OutputIt out, size_t limit)
+        : truncating_iterator_base<OutputIt>(out, limit)
+    {}
+
+    truncating_iterator &operator++()
+    {
+        if (this->count_++ < this->limit_)
+            ++this->out_;
+        return *this;
+    }
+
+    truncating_iterator operator++(int)
+    {
+        auto it = *this;
+        ++*this;
+        return it;
+    }
+
+    value_type &operator*() const
+    {
+        return this->count_ < this->limit_ ? *this->out_ : blackhole_;
+    }
+};
+
+template<typename OutputIt>
+class truncating_iterator<OutputIt, std::true_type> : public truncating_iterator_base<OutputIt>
+{
+public:
+    truncating_iterator() = default;
+
+    truncating_iterator(OutputIt out, size_t limit)
+        : truncating_iterator_base<OutputIt>(out, limit)
+    {}
+
+    template<typename T>
+    truncating_iterator &operator=(T val)
+    {
+        if (this->count_++ < this->limit_)
+            *this->out_++ = val;
+        return *this;
+    }
+
+    truncating_iterator &operator++()
+    {
+        return *this;
+    }
+    truncating_iterator &operator++(int)
+    {
+        return *this;
+    }
+    truncating_iterator &operator*()
+    {
+        return *this;
+    }
+};
+
+// A compile-time string which is compiled into fast formatting code.
+class compiled_string
+{};
+
+template<typename S>
+struct is_compiled_string : std::is_base_of<compiled_string, S>
+{};
+
+/**
+  \rst
+  Converts a string literal *s* into a format string that will be parsed at
+  compile time and converted into efficient formatting code. Requires C++17
+  ``constexpr if`` compiler support.
+
+  **Example**::
+
+    // Converts 42 into std::string using the most efficient method and no
+    // runtime format string processing.
+    std::string s = fmt::format(FMT_COMPILE("{}"), 42);
+  \endrst
+ */
+#if defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction)
+#    define FMT_COMPILE(s) FMT_STRING_IMPL(s, fmt::detail::compiled_string, explicit)
+#else
+#    define FMT_COMPILE(s) FMT_STRING(s)
+#endif
+
+#if FMT_USE_NONTYPE_TEMPLATE_ARGS
+template<typename Char, size_t N, fmt::detail_exported::fixed_string<Char, N> Str>
+struct udl_compiled_string : compiled_string
+{
+    using char_type = Char;
+    explicit constexpr operator basic_string_view<char_type>() const
+    {
+        return {Str.data, N - 1};
+    }
+};
+#endif
+
+template<typename T, typename... Tail>
+const T &first(const T &value, const Tail &...)
+{
+    return value;
+}
+
+#if defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction)
+template<typename... Args>
+struct type_list
+{};
+
+// Returns a reference to the argument at index N from [first, rest...].
+template<int N, typename T, typename... Args>
+constexpr const auto &get([[maybe_unused]] const T &first, [[maybe_unused]] const Args &...rest)
+{
+    static_assert(N < 1 + sizeof...(Args), "index is out of bounds");
+    if constexpr (N == 0)
+        return first;
+    else
+        return detail::get<N - 1>(rest...);
+}
+
+template<typename Char, typename... Args>
+constexpr int get_arg_index_by_name(basic_string_view<Char> name, type_list<Args...>)
+{
+    return get_arg_index_by_name<Args...>(name);
+}
+
+template<int N, typename>
+struct get_type_impl;
+
+template<int N, typename... Args>
+struct get_type_impl<N, type_list<Args...>>
+{
+    using type = remove_cvref_t<decltype(detail::get<N>(std::declval<Args>()...))>;
+};
+
+template<int N, typename T>
+using get_type = typename get_type_impl<N, T>::type;
+
+template<typename T>
+struct is_compiled_format : std::false_type
+{};
+
+template<typename Char>
+struct text
+{
+    basic_string_view<Char> data;
+    using char_type = Char;
+
+    template<typename OutputIt, typename... Args>
+    constexpr OutputIt format(OutputIt out, const Args &...) const
+    {
+        return write<Char>(out, data);
+    }
+};
+
+template<typename Char>
+struct is_compiled_format<text<Char>> : std::true_type
+{};
+
+template<typename Char>
+constexpr text<Char> make_text(basic_string_view<Char> s, size_t pos, size_t size)
+{
+    return {{&s[pos], size}};
+}
+
+template<typename Char>
+struct code_unit
+{
+    Char value;
+    using char_type = Char;
+
+    template<typename OutputIt, typename... Args>
+    constexpr OutputIt format(OutputIt out, const Args &...) const
+    {
+        return write<Char>(out, value);
+    }
+};
+
+// This ensures that the argument type is convertible to `const T&`.
+template<typename T, int N, typename... Args>
+constexpr const T &get_arg_checked(const Args &...args)
+{
+    const auto &arg = detail::get<N>(args...);
+    if constexpr (detail::is_named_arg<remove_cvref_t<decltype(arg)>>())
+    {
+        return arg.value;
+    }
+    else
+    {
+        return arg;
+    }
+}
+
+template<typename Char>
+struct is_compiled_format<code_unit<Char>> : std::true_type
+{};
+
+// A replacement field that refers to argument N.
+template<typename Char, typename T, int N>
+struct field
+{
+    using char_type = Char;
+
+    template<typename OutputIt, typename... Args>
+    constexpr OutputIt format(OutputIt out, const Args &...args) const
+    {
+        return write<Char>(out, get_arg_checked<T, N>(args...));
+    }
+};
+
+template<typename Char, typename T, int N>
+struct is_compiled_format<field<Char, T, N>> : std::true_type
+{};
+
+// A replacement field that refers to argument with name.
+template<typename Char>
+struct runtime_named_field
+{
+    using char_type = Char;
+    basic_string_view<Char> name;
+
+    template<typename OutputIt, typename T>
+    constexpr static bool try_format_argument(OutputIt &out,
+        // [[maybe_unused]] due to unused-but-set-parameter warning in GCC 7,8,9
+        [[maybe_unused]] basic_string_view<Char> arg_name, const T &arg)
+    {
+        if constexpr (is_named_arg<typename std::remove_cv<T>::type>::value)
+        {
+            if (arg_name == arg.name)
+            {
+                out = write<Char>(out, arg.value);
+                return true;
+            }
+        }
+        return false;
+    }
+
+    template<typename OutputIt, typename... Args>
+    constexpr OutputIt format(OutputIt out, const Args &...args) const
+    {
+        bool found = (try_format_argument(out, name, args) || ...);
+        if (!found)
+        {
+            FMT_THROW(format_error("argument with specified name is not found"));
+        }
+        return out;
+    }
+};
+
+template<typename Char>
+struct is_compiled_format<runtime_named_field<Char>> : std::true_type
+{};
+
+// A replacement field that refers to argument N and has format specifiers.
+template<typename Char, typename T, int N>
+struct spec_field
+{
+    using char_type = Char;
+    formatter<T, Char> fmt;
+
+    template<typename OutputIt, typename... Args>
+    constexpr FMT_INLINE OutputIt format(OutputIt out, const Args &...args) const
+    {
+        const auto &vargs = fmt::make_format_args<basic_format_context<OutputIt, Char>>(args...);
+        basic_format_context<OutputIt, Char> ctx(out, vargs);
+        return fmt.format(get_arg_checked<T, N>(args...), ctx);
+    }
+};
+
+template<typename Char, typename T, int N>
+struct is_compiled_format<spec_field<Char, T, N>> : std::true_type
+{};
+
+template<typename L, typename R>
+struct concat
+{
+    L lhs;
+    R rhs;
+    using char_type = typename L::char_type;
+
+    template<typename OutputIt, typename... Args>
+    constexpr OutputIt format(OutputIt out, const Args &...args) const
+    {
+        out = lhs.format(out, args...);
+        return rhs.format(out, args...);
+    }
+};
+
+template<typename L, typename R>
+struct is_compiled_format<concat<L, R>> : std::true_type
+{};
+
+template<typename L, typename R>
+constexpr concat<L, R> make_concat(L lhs, R rhs)
+{
+    return {lhs, rhs};
+}
+
+struct unknown_format
+{};
+
+template<typename Char>
+constexpr size_t parse_text(basic_string_view<Char> str, size_t pos)
+{
+    for (size_t size = str.size(); pos != size; ++pos)
+    {
+        if (str[pos] == '{' || str[pos] == '}')
+            break;
+    }
+    return pos;
+}
+
+template<typename Args, size_t POS, int ID, typename S>
+constexpr auto compile_format_string(S format_str);
+
+template<typename Args, size_t POS, int ID, typename T, typename S>
+constexpr auto parse_tail(T head, S format_str)
+{
+    if constexpr (POS != basic_string_view<typename S::char_type>(format_str).size())
+    {
+        constexpr auto tail = compile_format_string<Args, POS, ID>(format_str);
+        if constexpr (std::is_same<remove_cvref_t<decltype(tail)>, unknown_format>())
+            return tail;
+        else
+            return make_concat(head, tail);
+    }
+    else
+    {
+        return head;
+    }
+}
+
+template<typename T, typename Char>
+struct parse_specs_result
+{
+    formatter<T, Char> fmt;
+    size_t end;
+    int next_arg_id;
+};
+
+constexpr int manual_indexing_id = -1;
+
+template<typename T, typename Char>
+constexpr parse_specs_result<T, Char> parse_specs(basic_string_view<Char> str, size_t pos, int next_arg_id)
+{
+    str.remove_prefix(pos);
+    auto ctx = compile_parse_context<Char>(str, max_value<int>(), nullptr, {}, next_arg_id);
+    auto f = formatter<T, Char>();
+    auto end = f.parse(ctx);
+    return {f, pos + fmt::detail::to_unsigned(end - str.data()), next_arg_id == 0 ? manual_indexing_id : ctx.next_arg_id()};
+}
+
+template<typename Char>
+struct arg_id_handler
+{
+    arg_ref<Char> arg_id;
+
+    constexpr int operator()()
+    {
+        FMT_ASSERT(false, "handler cannot be used with automatic indexing");
+        return 0;
+    }
+    constexpr int operator()(int id)
+    {
+        arg_id = arg_ref<Char>(id);
+        return 0;
+    }
+    constexpr int operator()(basic_string_view<Char> id)
+    {
+        arg_id = arg_ref<Char>(id);
+        return 0;
+    }
+
+    constexpr void on_error(const char *message)
+    {
+        FMT_THROW(format_error(message));
+    }
+};
+
+template<typename Char>
+struct parse_arg_id_result
+{
+    arg_ref<Char> arg_id;
+    const Char *arg_id_end;
+};
+
+template<int ID, typename Char>
+constexpr auto parse_arg_id(const Char *begin, const Char *end)
+{
+    auto handler = arg_id_handler<Char>{arg_ref<Char>{}};
+    auto arg_id_end = parse_arg_id(begin, end, handler);
+    return parse_arg_id_result<Char>{handler.arg_id, arg_id_end};
+}
+
+template<typename T, typename Enable = void>
+struct field_type
+{
+    using type = remove_cvref_t<T>;
+};
+
+template<typename T>
+struct field_type<T, enable_if_t<detail::is_named_arg<T>::value>>
+{
+    using type = remove_cvref_t<decltype(T::value)>;
+};
+
+template<typename T, typename Args, size_t END_POS, int ARG_INDEX, int NEXT_ID, typename S>
+constexpr auto parse_replacement_field_then_tail(S format_str)
+{
+    using char_type = typename S::char_type;
+    constexpr auto str = basic_string_view<char_type>(format_str);
+    constexpr char_type c = END_POS != str.size() ? str[END_POS] : char_type();
+    if constexpr (c == '}')
+    {
+        return parse_tail<Args, END_POS + 1, NEXT_ID>(field<char_type, typename field_type<T>::type, ARG_INDEX>(), format_str);
+    }
+    else if constexpr (c != ':')
+    {
+        FMT_THROW(format_error("expected ':'"));
+    }
+    else
+    {
+        constexpr auto result = parse_specs<typename field_type<T>::type>(str, END_POS + 1, NEXT_ID == manual_indexing_id ? 0 : NEXT_ID);
+        if constexpr (result.end >= str.size() || str[result.end] != '}')
+        {
+            FMT_THROW(format_error("expected '}'"));
+            return 0;
+        }
+        else
+        {
+            return parse_tail<Args, result.end + 1, result.next_arg_id>(
+                spec_field<char_type, typename field_type<T>::type, ARG_INDEX>{result.fmt}, format_str);
+        }
+    }
+}
+
+// Compiles a non-empty format string and returns the compiled representation
+// or unknown_format() on unrecognized input.
+template<typename Args, size_t POS, int ID, typename S>
+constexpr auto compile_format_string(S format_str)
+{
+    using char_type = typename S::char_type;
+    constexpr auto str = basic_string_view<char_type>(format_str);
+    if constexpr (str[POS] == '{')
+    {
+        if constexpr (POS + 1 == str.size())
+            FMT_THROW(format_error("unmatched '{' in format string"));
+        if constexpr (str[POS + 1] == '{')
+        {
+            return parse_tail<Args, POS + 2, ID>(make_text(str, POS, 1), format_str);
+        }
+        else if constexpr (str[POS + 1] == '}' || str[POS + 1] == ':')
+        {
+            static_assert(ID != manual_indexing_id, "cannot switch from manual to automatic argument indexing");
+            constexpr auto next_id = ID != manual_indexing_id ? ID + 1 : manual_indexing_id;
+            return parse_replacement_field_then_tail<get_type<ID, Args>, Args, POS + 1, ID, next_id>(format_str);
+        }
+        else
+        {
+            constexpr auto arg_id_result = parse_arg_id<ID>(str.data() + POS + 1, str.data() + str.size());
+            constexpr auto arg_id_end_pos = arg_id_result.arg_id_end - str.data();
+            constexpr char_type c = arg_id_end_pos != str.size() ? str[arg_id_end_pos] : char_type();
+            static_assert(c == '}' || c == ':', "missing '}' in format string");
+            if constexpr (arg_id_result.arg_id.kind == arg_id_kind::index)
+            {
+                static_assert(ID == manual_indexing_id || ID == 0, "cannot switch from automatic to manual argument indexing");
+                constexpr auto arg_index = arg_id_result.arg_id.val.index;
+                return parse_replacement_field_then_tail<get_type<arg_index, Args>, Args, arg_id_end_pos, arg_index, manual_indexing_id>(
+                    format_str);
+            }
+            else if constexpr (arg_id_result.arg_id.kind == arg_id_kind::name)
+            {
+                constexpr auto arg_index = get_arg_index_by_name(arg_id_result.arg_id.val.name, Args{});
+                if constexpr (arg_index != invalid_arg_index)
+                {
+                    constexpr auto next_id = ID != manual_indexing_id ? ID + 1 : manual_indexing_id;
+                    return parse_replacement_field_then_tail<decltype(get_type<arg_index, Args>::value), Args, arg_id_end_pos, arg_index,
+                        next_id>(format_str);
+                }
+                else
+                {
+                    if constexpr (c == '}')
+                    {
+                        return parse_tail<Args, arg_id_end_pos + 1, ID>(
+                            runtime_named_field<char_type>{arg_id_result.arg_id.val.name}, format_str);
+                    }
+                    else if constexpr (c == ':')
+                    {
+                        return unknown_format(); // no type info for specs parsing
+                    }
+                }
+            }
+        }
+    }
+    else if constexpr (str[POS] == '}')
+    {
+        if constexpr (POS + 1 == str.size())
+            FMT_THROW(format_error("unmatched '}' in format string"));
+        return parse_tail<Args, POS + 2, ID>(make_text(str, POS, 1), format_str);
+    }
+    else
+    {
+        constexpr auto end = parse_text(str, POS + 1);
+        if constexpr (end - POS > 1)
+        {
+            return parse_tail<Args, end, ID>(make_text(str, POS, end - POS), format_str);
+        }
+        else
+        {
+            return parse_tail<Args, end, ID>(code_unit<char_type>{str[POS]}, format_str);
+        }
+    }
+}
+
+template<typename... Args, typename S, FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
+constexpr auto compile(S format_str)
+{
+    constexpr auto str = basic_string_view<typename S::char_type>(format_str);
+    if constexpr (str.size() == 0)
+    {
+        return detail::make_text(str, 0, 0);
+    }
+    else
+    {
+        constexpr auto result = detail::compile_format_string<detail::type_list<Args...>, 0, 0>(format_str);
+        return result;
+    }
+}
+#endif // defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction)
+} // namespace detail
+
+FMT_MODULE_EXPORT_BEGIN
+
+#if defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction)
+
+template<typename CompiledFormat, typename... Args, typename Char = typename CompiledFormat::char_type,
+    FMT_ENABLE_IF(detail::is_compiled_format<CompiledFormat>::value)>
+FMT_INLINE std::basic_string<Char> format(const CompiledFormat &cf, const Args &...args)
+{
+    auto s = std::basic_string<Char>();
+    cf.format(std::back_inserter(s), args...);
+    return s;
+}
+
+template<typename OutputIt, typename CompiledFormat, typename... Args, FMT_ENABLE_IF(detail::is_compiled_format<CompiledFormat>::value)>
+constexpr FMT_INLINE OutputIt format_to(OutputIt out, const CompiledFormat &cf, const Args &...args)
+{
+    return cf.format(out, args...);
+}
+
+template<typename S, typename... Args, FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
+FMT_INLINE std::basic_string<typename S::char_type> format(const S &, Args &&...args)
+{
+    if constexpr (std::is_same<typename S::char_type, char>::value)
+    {
+        constexpr auto str = basic_string_view<typename S::char_type>(S());
+        if constexpr (str.size() == 2 && str[0] == '{' && str[1] == '}')
+        {
+            const auto &first = detail::first(args...);
+            if constexpr (detail::is_named_arg<remove_cvref_t<decltype(first)>>::value)
+            {
+                return fmt::to_string(first.value);
+            }
+            else
+            {
+                return fmt::to_string(first);
+            }
+        }
+    }
+    constexpr auto compiled = detail::compile<Args...>(S());
+    if constexpr (std::is_same<remove_cvref_t<decltype(compiled)>, detail::unknown_format>())
+    {
+        return fmt::format(static_cast<basic_string_view<typename S::char_type>>(S()), std::forward<Args>(args)...);
+    }
+    else
+    {
+        return fmt::format(compiled, std::forward<Args>(args)...);
+    }
+}
+
+template<typename OutputIt, typename S, typename... Args, FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
+FMT_CONSTEXPR OutputIt format_to(OutputIt out, const S &, Args &&...args)
+{
+    constexpr auto compiled = detail::compile<Args...>(S());
+    if constexpr (std::is_same<remove_cvref_t<decltype(compiled)>, detail::unknown_format>())
+    {
+        return fmt::format_to(out, static_cast<basic_string_view<typename S::char_type>>(S()), std::forward<Args>(args)...);
+    }
+    else
+    {
+        return fmt::format_to(out, compiled, std::forward<Args>(args)...);
+    }
+}
+#endif
+
+template<typename OutputIt, typename S, typename... Args, FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
+format_to_n_result<OutputIt> format_to_n(OutputIt out, size_t n, const S &format_str, Args &&...args)
+{
+    auto it = fmt::format_to(detail::truncating_iterator<OutputIt>(out, n), format_str, std::forward<Args>(args)...);
+    return {it.base(), it.count()};
+}
+
+template<typename S, typename... Args, FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
+FMT_CONSTEXPR20 size_t formatted_size(const S &format_str, const Args &...args)
+{
+    return fmt::format_to(detail::counting_iterator(), format_str, args...).count();
+}
+
+template<typename S, typename... Args, FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
+void print(std::FILE *f, const S &format_str, const Args &...args)
+{
+    memory_buffer buffer;
+    fmt::format_to(std::back_inserter(buffer), format_str, args...);
+    detail::print(f, {buffer.data(), buffer.size()});
+}
+
+template<typename S, typename... Args, FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
+void print(const S &format_str, const Args &...args)
+{
+    print(stdout, format_str, args...);
+}
+
+#if FMT_USE_NONTYPE_TEMPLATE_ARGS
+inline namespace literals {
+template<detail_exported::fixed_string Str>
+constexpr auto operator""_cf()
+{
+    using char_t = remove_cvref_t<decltype(Str.data[0])>;
+    return detail::udl_compiled_string<char_t, sizeof(Str.data) / sizeof(char_t), Str>();
+}
+} // namespace literals
+#endif
+
+FMT_MODULE_EXPORT_END
+FMT_END_NAMESPACE
+
+#endif // FMT_COMPILE_H_
diff --git a/3rdparty/spdlog/src/include/spdlog/fmt/bundled/core.h b/3rdparty/spdlog/src/include/spdlog/fmt/bundled/core.h
new file mode 100644
index 00000000..22aef4e5
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/fmt/bundled/core.h
@@ -0,0 +1,3939 @@
+// Formatting library for C++ - the core API for char/UTF-8
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#ifndef FMT_CORE_H_
+#define FMT_CORE_H_
+
+#include <cstddef> // std::byte
+#include <cstdio>  // std::FILE
+#include <cstring> // std::strlen
+#include <iterator>
+#include <limits>
+#include <string>
+#include <type_traits>
+
+// The fmt library version in the form major * 10000 + minor * 100 + patch.
+#define FMT_VERSION 90100
+
+#if defined(__clang__) && !defined(__ibmxl__)
+#    define FMT_CLANG_VERSION (__clang_major__ * 100 + __clang_minor__)
+#else
+#    define FMT_CLANG_VERSION 0
+#endif
+
+#if defined(__GNUC__) && !defined(__clang__) && !defined(__INTEL_COMPILER) && !defined(__NVCOMPILER)
+#    define FMT_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)
+#else
+#    define FMT_GCC_VERSION 0
+#endif
+
+#ifndef FMT_GCC_PRAGMA
+// Workaround _Pragma bug https://gcc.gnu.org/bugzilla/show_bug.cgi?id=59884.
+#    if FMT_GCC_VERSION >= 504
+#        define FMT_GCC_PRAGMA(arg) _Pragma(arg)
+#    else
+#        define FMT_GCC_PRAGMA(arg)
+#    endif
+#endif
+
+#ifdef __ICL
+#    define FMT_ICC_VERSION __ICL
+#elif defined(__INTEL_COMPILER)
+#    define FMT_ICC_VERSION __INTEL_COMPILER
+#else
+#    define FMT_ICC_VERSION 0
+#endif
+
+#ifdef _MSC_VER
+#    define FMT_MSC_VERSION _MSC_VER
+#    define FMT_MSC_WARNING(...) __pragma(warning(__VA_ARGS__))
+#else
+#    define FMT_MSC_VERSION 0
+#    define FMT_MSC_WARNING(...)
+#endif
+
+#ifdef _MSVC_LANG
+#    define FMT_CPLUSPLUS _MSVC_LANG
+#else
+#    define FMT_CPLUSPLUS __cplusplus
+#endif
+
+#ifdef __has_feature
+#    define FMT_HAS_FEATURE(x) __has_feature(x)
+#else
+#    define FMT_HAS_FEATURE(x) 0
+#endif
+
+#if (defined(__has_include) || FMT_ICC_VERSION >= 1600 || FMT_MSC_VERSION > 1900) && !defined(__INTELLISENSE__)
+#    define FMT_HAS_INCLUDE(x) __has_include(x)
+#else
+#    define FMT_HAS_INCLUDE(x) 0
+#endif
+
+#ifdef __has_cpp_attribute
+#    define FMT_HAS_CPP_ATTRIBUTE(x) __has_cpp_attribute(x)
+#else
+#    define FMT_HAS_CPP_ATTRIBUTE(x) 0
+#endif
+
+#define FMT_HAS_CPP14_ATTRIBUTE(attribute) (FMT_CPLUSPLUS >= 201402L && FMT_HAS_CPP_ATTRIBUTE(attribute))
+
+#define FMT_HAS_CPP17_ATTRIBUTE(attribute) (FMT_CPLUSPLUS >= 201703L && FMT_HAS_CPP_ATTRIBUTE(attribute))
+
+// Check if relaxed C++14 constexpr is supported.
+// GCC doesn't allow throw in constexpr until version 6 (bug 67371).
+#ifndef FMT_USE_CONSTEXPR
+#    if (FMT_HAS_FEATURE(cxx_relaxed_constexpr) || FMT_MSC_VERSION >= 1912 || (FMT_GCC_VERSION >= 600 && FMT_CPLUSPLUS >= 201402L)) &&     \
+        !FMT_ICC_VERSION && !defined(__NVCC__)
+#        define FMT_USE_CONSTEXPR 1
+#    else
+#        define FMT_USE_CONSTEXPR 0
+#    endif
+#endif
+#if FMT_USE_CONSTEXPR
+#    define FMT_CONSTEXPR constexpr
+#else
+#    define FMT_CONSTEXPR
+#endif
+
+#if ((FMT_CPLUSPLUS >= 202002L) && (!defined(_GLIBCXX_RELEASE) || _GLIBCXX_RELEASE > 9)) ||                                                \
+    (FMT_CPLUSPLUS >= 201709L && FMT_GCC_VERSION >= 1002)
+#    define FMT_CONSTEXPR20 constexpr
+#else
+#    define FMT_CONSTEXPR20
+#endif
+
+// Check if constexpr std::char_traits<>::{compare,length} are supported.
+#if defined(__GLIBCXX__)
+#    if FMT_CPLUSPLUS >= 201703L && defined(_GLIBCXX_RELEASE) && _GLIBCXX_RELEASE >= 7 // GCC 7+ libstdc++ has _GLIBCXX_RELEASE.
+#        define FMT_CONSTEXPR_CHAR_TRAITS constexpr
+#    endif
+#elif defined(_LIBCPP_VERSION) && FMT_CPLUSPLUS >= 201703L && _LIBCPP_VERSION >= 4000
+#    define FMT_CONSTEXPR_CHAR_TRAITS constexpr
+#elif FMT_MSC_VERSION >= 1914 && FMT_CPLUSPLUS >= 201703L
+#    define FMT_CONSTEXPR_CHAR_TRAITS constexpr
+#endif
+#ifndef FMT_CONSTEXPR_CHAR_TRAITS
+#    define FMT_CONSTEXPR_CHAR_TRAITS
+#endif
+
+// Check if exceptions are disabled.
+#ifndef FMT_EXCEPTIONS
+#    if (defined(__GNUC__) && !defined(__EXCEPTIONS)) || (FMT_MSC_VERSION && !_HAS_EXCEPTIONS)
+#        define FMT_EXCEPTIONS 0
+#    else
+#        define FMT_EXCEPTIONS 1
+#    endif
+#endif
+
+#ifndef FMT_DEPRECATED
+#    if FMT_HAS_CPP14_ATTRIBUTE(deprecated) || FMT_MSC_VERSION >= 1900
+#        define FMT_DEPRECATED [[deprecated]]
+#    else
+#        if (defined(__GNUC__) && !defined(__LCC__)) || defined(__clang__)
+#            define FMT_DEPRECATED __attribute__((deprecated))
+#        elif FMT_MSC_VERSION
+#            define FMT_DEPRECATED __declspec(deprecated)
+#        else
+#            define FMT_DEPRECATED /* deprecated */
+#        endif
+#    endif
+#endif
+
+// [[noreturn]] is disabled on MSVC and NVCC because of bogus unreachable code
+// warnings.
+#if FMT_EXCEPTIONS && FMT_HAS_CPP_ATTRIBUTE(noreturn) && !FMT_MSC_VERSION && !defined(__NVCC__)
+#    define FMT_NORETURN [[noreturn]]
+#else
+#    define FMT_NORETURN
+#endif
+
+#if FMT_HAS_CPP17_ATTRIBUTE(fallthrough)
+#    define FMT_FALLTHROUGH [[fallthrough]]
+#elif defined(__clang__)
+#    define FMT_FALLTHROUGH [[clang::fallthrough]]
+#elif FMT_GCC_VERSION >= 700 && (!defined(__EDG_VERSION__) || __EDG_VERSION__ >= 520)
+#    define FMT_FALLTHROUGH [[gnu::fallthrough]]
+#else
+#    define FMT_FALLTHROUGH
+#endif
+
+#ifndef FMT_NODISCARD
+#    if FMT_HAS_CPP17_ATTRIBUTE(nodiscard)
+#        define FMT_NODISCARD [[nodiscard]]
+#    else
+#        define FMT_NODISCARD
+#    endif
+#endif
+
+#ifndef FMT_USE_FLOAT
+#    define FMT_USE_FLOAT 1
+#endif
+#ifndef FMT_USE_DOUBLE
+#    define FMT_USE_DOUBLE 1
+#endif
+#ifndef FMT_USE_LONG_DOUBLE
+#    define FMT_USE_LONG_DOUBLE 1
+#endif
+
+#ifndef FMT_INLINE
+#    if FMT_GCC_VERSION || FMT_CLANG_VERSION
+#        define FMT_INLINE inline __attribute__((always_inline))
+#    else
+#        define FMT_INLINE inline
+#    endif
+#endif
+
+// An inline std::forward replacement.
+#define FMT_FORWARD(...) static_cast<decltype(__VA_ARGS__) &&>(__VA_ARGS__)
+
+#ifdef _MSC_VER
+#    define FMT_UNCHECKED_ITERATOR(It) using _Unchecked_type = It // Mark iterator as checked.
+#else
+#    define FMT_UNCHECKED_ITERATOR(It) using unchecked_type = It
+#endif
+
+#ifndef FMT_BEGIN_NAMESPACE
+#    define FMT_BEGIN_NAMESPACE                                                                                                            \
+        namespace fmt {                                                                                                                    \
+        inline namespace v9 {
+#    define FMT_END_NAMESPACE                                                                                                              \
+        }                                                                                                                                  \
+        }
+#endif
+
+#ifndef FMT_MODULE_EXPORT
+#    define FMT_MODULE_EXPORT
+#    define FMT_MODULE_EXPORT_BEGIN
+#    define FMT_MODULE_EXPORT_END
+#    define FMT_BEGIN_DETAIL_NAMESPACE namespace detail {
+#    define FMT_END_DETAIL_NAMESPACE }
+#endif
+
+#if !defined(FMT_HEADER_ONLY) && defined(_WIN32)
+#    define FMT_CLASS_API FMT_MSC_WARNING(suppress : 4275)
+#    ifdef FMT_EXPORT
+#        define FMT_API __declspec(dllexport)
+#    elif defined(FMT_SHARED)
+#        define FMT_API __declspec(dllimport)
+#    endif
+#else
+#    define FMT_CLASS_API
+#    if defined(FMT_EXPORT) || defined(FMT_SHARED)
+#        if defined(__GNUC__) || defined(__clang__)
+#            define FMT_API __attribute__((visibility("default")))
+#        endif
+#    endif
+#endif
+#ifndef FMT_API
+#    define FMT_API
+#endif
+
+// libc++ supports string_view in pre-c++17.
+#if FMT_HAS_INCLUDE(<string_view>) && (FMT_CPLUSPLUS >= 201703L || defined(_LIBCPP_VERSION))
+#    include <string_view>
+#    define FMT_USE_STRING_VIEW
+#elif FMT_HAS_INCLUDE("experimental/string_view") && FMT_CPLUSPLUS >= 201402L
+#    include <experimental/string_view>
+#    define FMT_USE_EXPERIMENTAL_STRING_VIEW
+#endif
+
+#ifndef FMT_UNICODE
+#    define FMT_UNICODE !FMT_MSC_VERSION
+#endif
+
+#ifndef FMT_CONSTEVAL
+#    if ((FMT_GCC_VERSION >= 1000 || FMT_CLANG_VERSION >= 1101) && FMT_CPLUSPLUS >= 202002L && !defined(__apple_build_version__)) ||       \
+        (defined(__cpp_consteval) && (!FMT_MSC_VERSION || _MSC_FULL_VER >= 193030704))
+// consteval is broken in MSVC before VS2022 and Apple clang 13.
+#        define FMT_CONSTEVAL consteval
+#        define FMT_HAS_CONSTEVAL
+#    else
+#        define FMT_CONSTEVAL
+#    endif
+#endif
+
+#ifndef FMT_USE_NONTYPE_TEMPLATE_ARGS
+#    if defined(__cpp_nontype_template_args) &&                                                                                            \
+        ((FMT_GCC_VERSION >= 903 && FMT_CPLUSPLUS >= 201709L) || __cpp_nontype_template_args >= 201911L) && !defined(__NVCOMPILER)
+#        define FMT_USE_NONTYPE_TEMPLATE_ARGS 1
+#    else
+#        define FMT_USE_NONTYPE_TEMPLATE_ARGS 0
+#    endif
+#endif
+
+// Enable minimal optimizations for more compact code in debug mode.
+FMT_GCC_PRAGMA("GCC push_options")
+#if !defined(__OPTIMIZE__) && !defined(__NVCOMPILER)
+FMT_GCC_PRAGMA("GCC optimize(\"Og\")")
+#endif
+
+FMT_BEGIN_NAMESPACE
+FMT_MODULE_EXPORT_BEGIN
+
+// Implementations of enable_if_t and other metafunctions for older systems.
+template<bool B, typename T = void>
+using enable_if_t = typename std::enable_if<B, T>::type;
+template<bool B, typename T, typename F>
+using conditional_t = typename std::conditional<B, T, F>::type;
+template<bool B>
+using bool_constant = std::integral_constant<bool, B>;
+template<typename T>
+using remove_reference_t = typename std::remove_reference<T>::type;
+template<typename T>
+using remove_const_t = typename std::remove_const<T>::type;
+template<typename T>
+using remove_cvref_t = typename std::remove_cv<remove_reference_t<T>>::type;
+template<typename T>
+struct type_identity
+{
+    using type = T;
+};
+template<typename T>
+using type_identity_t = typename type_identity<T>::type;
+template<typename T>
+using underlying_t = typename std::underlying_type<T>::type;
+
+template<typename...>
+struct disjunction : std::false_type
+{};
+template<typename P>
+struct disjunction<P> : P
+{};
+template<typename P1, typename... Pn>
+struct disjunction<P1, Pn...> : conditional_t<bool(P1::value), P1, disjunction<Pn...>>
+{};
+
+template<typename...>
+struct conjunction : std::true_type
+{};
+template<typename P>
+struct conjunction<P> : P
+{};
+template<typename P1, typename... Pn>
+struct conjunction<P1, Pn...> : conditional_t<bool(P1::value), conjunction<Pn...>, P1>
+{};
+
+struct monostate
+{
+    constexpr monostate() {}
+};
+
+// An enable_if helper to be used in template parameters which results in much
+// shorter symbols: https://godbolt.org/z/sWw4vP. Extra parentheses are needed
+// to workaround a bug in MSVC 2019 (see #1140 and #1186).
+#ifdef FMT_DOC
+#    define FMT_ENABLE_IF(...)
+#else
+#    define FMT_ENABLE_IF(...) enable_if_t<(__VA_ARGS__), int> = 0
+#endif
+
+FMT_BEGIN_DETAIL_NAMESPACE
+
+// Suppresses "unused variable" warnings with the method described in
+// https://herbsutter.com/2009/10/18/mailbag-shutting-up-compiler-warnings/.
+// (void)var does not work on many Intel compilers.
+template<typename... T>
+FMT_CONSTEXPR void ignore_unused(const T &...)
+{}
+
+constexpr FMT_INLINE auto is_constant_evaluated(bool default_value = false) noexcept -> bool
+{
+#ifdef __cpp_lib_is_constant_evaluated
+    ignore_unused(default_value);
+    return std::is_constant_evaluated();
+#else
+    return default_value;
+#endif
+}
+
+// Suppresses "conditional expression is constant" warnings.
+template<typename T>
+constexpr FMT_INLINE auto const_check(T value) -> T
+{
+    return value;
+}
+
+FMT_NORETURN FMT_API void assert_fail(const char *file, int line, const char *message);
+
+#ifndef FMT_ASSERT
+#    ifdef NDEBUG
+// FMT_ASSERT is not empty to avoid -Wempty-body.
+#        define FMT_ASSERT(condition, message) ::fmt::detail::ignore_unused((condition), (message))
+#    else
+#        define FMT_ASSERT(condition, message)                                                                                             \
+            ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */                                                        \
+                    ? (void)0                                                                                                              \
+                    : ::fmt::detail::assert_fail(__FILE__, __LINE__, (message)))
+#    endif
+#endif
+
+#if defined(FMT_USE_STRING_VIEW)
+template<typename Char>
+using std_string_view = std::basic_string_view<Char>;
+#elif defined(FMT_USE_EXPERIMENTAL_STRING_VIEW)
+template<typename Char>
+using std_string_view = std::experimental::basic_string_view<Char>;
+#else
+template<typename T>
+struct std_string_view
+{};
+#endif
+
+#ifdef FMT_USE_INT128
+// Do nothing.
+#elif defined(__SIZEOF_INT128__) && !defined(__NVCC__) && !(FMT_CLANG_VERSION && FMT_MSC_VERSION)
+#    define FMT_USE_INT128 1
+using int128_opt = __int128_t; // An optional native 128-bit integer.
+using uint128_opt = __uint128_t;
+template<typename T>
+inline auto convert_for_visit(T value) -> T
+{
+    return value;
+}
+#else
+#    define FMT_USE_INT128 0
+#endif
+#if !FMT_USE_INT128
+enum class int128_opt
+{
+};
+enum class uint128_opt
+{
+};
+// Reduce template instantiations.
+template<typename T>
+auto convert_for_visit(T) -> monostate
+{
+    return {};
+}
+#endif
+
+// Casts a nonnegative integer to unsigned.
+template<typename Int>
+FMT_CONSTEXPR auto to_unsigned(Int value) -> typename std::make_unsigned<Int>::type
+{
+    FMT_ASSERT(std::is_unsigned<Int>::value || value >= 0, "negative value");
+    return static_cast<typename std::make_unsigned<Int>::type>(value);
+}
+
+FMT_MSC_WARNING(suppress : 4566) constexpr unsigned char micro[] = "\u00B5";
+
+constexpr auto is_utf8() -> bool
+{
+    // Avoid buggy sign extensions in MSVC's constant evaluation mode (#2297).
+    using uchar = unsigned char;
+    return FMT_UNICODE || (sizeof(micro) == 3 && uchar(micro[0]) == 0xC2 && uchar(micro[1]) == 0xB5);
+}
+FMT_END_DETAIL_NAMESPACE
+
+/**
+  An implementation of ``std::basic_string_view`` for pre-C++17. It provides a
+  subset of the API. ``fmt::basic_string_view`` is used for format strings even
+  if ``std::string_view`` is available to prevent issues when a library is
+  compiled with a different ``-std`` option than the client code (which is not
+  recommended).
+ */
+template<typename Char>
+class basic_string_view
+{
+private:
+    const Char *data_;
+    size_t size_;
+
+public:
+    using value_type = Char;
+    using iterator = const Char *;
+
+    constexpr basic_string_view() noexcept
+        : data_(nullptr)
+        , size_(0)
+    {}
+
+    /** Constructs a string reference object from a C string and a size. */
+    constexpr basic_string_view(const Char *s, size_t count) noexcept
+        : data_(s)
+        , size_(count)
+    {}
+
+    /**
+      \rst
+      Constructs a string reference object from a C string computing
+      the size with ``std::char_traits<Char>::length``.
+      \endrst
+     */
+    FMT_CONSTEXPR_CHAR_TRAITS
+    FMT_INLINE
+    basic_string_view(const Char *s)
+        : data_(s)
+        , size_(detail::const_check(std::is_same<Char, char>::value && !detail::is_constant_evaluated(true))
+                    ? std::strlen(reinterpret_cast<const char *>(s))
+                    : std::char_traits<Char>::length(s))
+    {}
+
+    /** Constructs a string reference from a ``std::basic_string`` object. */
+    template<typename Traits, typename Alloc>
+    FMT_CONSTEXPR basic_string_view(const std::basic_string<Char, Traits, Alloc> &s) noexcept
+        : data_(s.data())
+        , size_(s.size())
+    {}
+
+    template<typename S, FMT_ENABLE_IF(std::is_same<S, detail::std_string_view<Char>>::value)>
+    FMT_CONSTEXPR basic_string_view(S s) noexcept
+        : data_(s.data())
+        , size_(s.size())
+    {}
+
+    /** Returns a pointer to the string data. */
+    constexpr auto data() const noexcept -> const Char *
+    {
+        return data_;
+    }
+
+    /** Returns the string size. */
+    constexpr auto size() const noexcept -> size_t
+    {
+        return size_;
+    }
+
+    constexpr auto begin() const noexcept -> iterator
+    {
+        return data_;
+    }
+    constexpr auto end() const noexcept -> iterator
+    {
+        return data_ + size_;
+    }
+
+    constexpr auto operator[](size_t pos) const noexcept -> const Char &
+    {
+        return data_[pos];
+    }
+
+    FMT_CONSTEXPR void remove_prefix(size_t n) noexcept
+    {
+        data_ += n;
+        size_ -= n;
+    }
+
+    // Lexicographically compare this string reference to other.
+    FMT_CONSTEXPR_CHAR_TRAITS auto compare(basic_string_view other) const -> int
+    {
+        size_t str_size = size_ < other.size_ ? size_ : other.size_;
+        int result = std::char_traits<Char>::compare(data_, other.data_, str_size);
+        if (result == 0)
+            result = size_ == other.size_ ? 0 : (size_ < other.size_ ? -1 : 1);
+        return result;
+    }
+
+    FMT_CONSTEXPR_CHAR_TRAITS friend auto operator==(basic_string_view lhs, basic_string_view rhs) -> bool
+    {
+        return lhs.compare(rhs) == 0;
+    }
+    friend auto operator!=(basic_string_view lhs, basic_string_view rhs) -> bool
+    {
+        return lhs.compare(rhs) != 0;
+    }
+    friend auto operator<(basic_string_view lhs, basic_string_view rhs) -> bool
+    {
+        return lhs.compare(rhs) < 0;
+    }
+    friend auto operator<=(basic_string_view lhs, basic_string_view rhs) -> bool
+    {
+        return lhs.compare(rhs) <= 0;
+    }
+    friend auto operator>(basic_string_view lhs, basic_string_view rhs) -> bool
+    {
+        return lhs.compare(rhs) > 0;
+    }
+    friend auto operator>=(basic_string_view lhs, basic_string_view rhs) -> bool
+    {
+        return lhs.compare(rhs) >= 0;
+    }
+};
+
+using string_view = basic_string_view<char>;
+
+/** Specifies if ``T`` is a character type. Can be specialized by users. */
+template<typename T>
+struct is_char : std::false_type
+{};
+template<>
+struct is_char<char> : std::true_type
+{};
+
+FMT_BEGIN_DETAIL_NAMESPACE
+
+// A base class for compile-time strings.
+struct compile_string
+{};
+
+template<typename S>
+struct is_compile_string : std::is_base_of<compile_string, S>
+{};
+
+// Returns a string view of `s`.
+template<typename Char, FMT_ENABLE_IF(is_char<Char>::value)>
+FMT_INLINE auto to_string_view(const Char *s) -> basic_string_view<Char>
+{
+    return s;
+}
+template<typename Char, typename Traits, typename Alloc>
+inline auto to_string_view(const std::basic_string<Char, Traits, Alloc> &s) -> basic_string_view<Char>
+{
+    return s;
+}
+template<typename Char>
+constexpr auto to_string_view(basic_string_view<Char> s) -> basic_string_view<Char>
+{
+    return s;
+}
+template<typename Char, FMT_ENABLE_IF(!std::is_empty<std_string_view<Char>>::value)>
+inline auto to_string_view(std_string_view<Char> s) -> basic_string_view<Char>
+{
+    return s;
+}
+template<typename S, FMT_ENABLE_IF(is_compile_string<S>::value)>
+constexpr auto to_string_view(const S &s) -> basic_string_view<typename S::char_type>
+{
+    return basic_string_view<typename S::char_type>(s);
+}
+void to_string_view(...);
+
+// Specifies whether S is a string type convertible to fmt::basic_string_view.
+// It should be a constexpr function but MSVC 2017 fails to compile it in
+// enable_if and MSVC 2015 fails to compile it as an alias template.
+// ADL invocation of to_string_view is DEPRECATED!
+template<typename S>
+struct is_string : std::is_class<decltype(to_string_view(std::declval<S>()))>
+{};
+
+template<typename S, typename = void>
+struct char_t_impl
+{};
+template<typename S>
+struct char_t_impl<S, enable_if_t<is_string<S>::value>>
+{
+    using result = decltype(to_string_view(std::declval<S>()));
+    using type = typename result::value_type;
+};
+
+enum class type
+{
+    none_type,
+    // Integer types should go first,
+    int_type,
+    uint_type,
+    long_long_type,
+    ulong_long_type,
+    int128_type,
+    uint128_type,
+    bool_type,
+    char_type,
+    last_integer_type = char_type,
+    // followed by floating-point types.
+    float_type,
+    double_type,
+    long_double_type,
+    last_numeric_type = long_double_type,
+    cstring_type,
+    string_type,
+    pointer_type,
+    custom_type
+};
+
+// Maps core type T to the corresponding type enum constant.
+template<typename T, typename Char>
+struct type_constant : std::integral_constant<type, type::custom_type>
+{};
+
+#define FMT_TYPE_CONSTANT(Type, constant)                                                                                                  \
+    template<typename Char>                                                                                                                \
+    struct type_constant<Type, Char> : std::integral_constant<type, type::constant>                                                        \
+    {}
+
+FMT_TYPE_CONSTANT(int, int_type);
+FMT_TYPE_CONSTANT(unsigned, uint_type);
+FMT_TYPE_CONSTANT(long long, long_long_type);
+FMT_TYPE_CONSTANT(unsigned long long, ulong_long_type);
+FMT_TYPE_CONSTANT(int128_opt, int128_type);
+FMT_TYPE_CONSTANT(uint128_opt, uint128_type);
+FMT_TYPE_CONSTANT(bool, bool_type);
+FMT_TYPE_CONSTANT(Char, char_type);
+FMT_TYPE_CONSTANT(float, float_type);
+FMT_TYPE_CONSTANT(double, double_type);
+FMT_TYPE_CONSTANT(long double, long_double_type);
+FMT_TYPE_CONSTANT(const Char *, cstring_type);
+FMT_TYPE_CONSTANT(basic_string_view<Char>, string_type);
+FMT_TYPE_CONSTANT(const void *, pointer_type);
+
+constexpr bool is_integral_type(type t)
+{
+    return t > type::none_type && t <= type::last_integer_type;
+}
+
+constexpr bool is_arithmetic_type(type t)
+{
+    return t > type::none_type && t <= type::last_numeric_type;
+}
+
+FMT_NORETURN FMT_API void throw_format_error(const char *message);
+
+struct error_handler
+{
+    constexpr error_handler() = default;
+    constexpr error_handler(const error_handler &) = default;
+
+    // This function is intentionally not constexpr to give a compile-time error.
+    FMT_NORETURN void on_error(const char *message)
+    {
+        throw_format_error(message);
+    }
+};
+FMT_END_DETAIL_NAMESPACE
+
+/** String's character type. */
+template<typename S>
+using char_t = typename detail::char_t_impl<S>::type;
+
+/**
+  \rst
+  Parsing context consisting of a format string range being parsed and an
+  argument counter for automatic indexing.
+  You can use the ``format_parse_context`` type alias for ``char`` instead.
+  \endrst
+ */
+template<typename Char, typename ErrorHandler = detail::error_handler>
+class basic_format_parse_context : private ErrorHandler
+{
+private:
+    basic_string_view<Char> format_str_;
+    int next_arg_id_;
+
+    FMT_CONSTEXPR void do_check_arg_id(int id);
+
+public:
+    using char_type = Char;
+    using iterator = typename basic_string_view<Char>::iterator;
+
+    explicit constexpr basic_format_parse_context(basic_string_view<Char> format_str, ErrorHandler eh = {}, int next_arg_id = 0)
+        : ErrorHandler(eh)
+        , format_str_(format_str)
+        , next_arg_id_(next_arg_id)
+    {}
+
+    /**
+      Returns an iterator to the beginning of the format string range being
+      parsed.
+     */
+    constexpr auto begin() const noexcept -> iterator
+    {
+        return format_str_.begin();
+    }
+
+    /**
+      Returns an iterator past the end of the format string range being parsed.
+     */
+    constexpr auto end() const noexcept -> iterator
+    {
+        return format_str_.end();
+    }
+
+    /** Advances the begin iterator to ``it``. */
+    FMT_CONSTEXPR void advance_to(iterator it)
+    {
+        format_str_.remove_prefix(detail::to_unsigned(it - begin()));
+    }
+
+    /**
+      Reports an error if using the manual argument indexing; otherwise returns
+      the next argument index and switches to the automatic indexing.
+     */
+    FMT_CONSTEXPR auto next_arg_id() -> int
+    {
+        if (next_arg_id_ < 0)
+        {
+            on_error("cannot switch from manual to automatic argument indexing");
+            return 0;
+        }
+        int id = next_arg_id_++;
+        do_check_arg_id(id);
+        return id;
+    }
+
+    /**
+      Reports an error if using the automatic argument indexing; otherwise
+      switches to the manual indexing.
+     */
+    FMT_CONSTEXPR void check_arg_id(int id)
+    {
+        if (next_arg_id_ > 0)
+        {
+            on_error("cannot switch from automatic to manual argument indexing");
+            return;
+        }
+        next_arg_id_ = -1;
+        do_check_arg_id(id);
+    }
+    FMT_CONSTEXPR void check_arg_id(basic_string_view<Char>) {}
+    FMT_CONSTEXPR void check_dynamic_spec(int arg_id);
+
+    FMT_CONSTEXPR void on_error(const char *message)
+    {
+        ErrorHandler::on_error(message);
+    }
+
+    constexpr auto error_handler() const -> ErrorHandler
+    {
+        return *this;
+    }
+};
+
+using format_parse_context = basic_format_parse_context<char>;
+
+FMT_BEGIN_DETAIL_NAMESPACE
+// A parse context with extra data used only in compile-time checks.
+template<typename Char, typename ErrorHandler = detail::error_handler>
+class compile_parse_context : public basic_format_parse_context<Char, ErrorHandler>
+{
+private:
+    int num_args_;
+    const type *types_;
+    using base = basic_format_parse_context<Char, ErrorHandler>;
+
+public:
+    explicit FMT_CONSTEXPR compile_parse_context(
+        basic_string_view<Char> format_str, int num_args, const type *types, ErrorHandler eh = {}, int next_arg_id = 0)
+        : base(format_str, eh, next_arg_id)
+        , num_args_(num_args)
+        , types_(types)
+    {}
+
+    constexpr auto num_args() const -> int
+    {
+        return num_args_;
+    }
+    constexpr auto arg_type(int id) const -> type
+    {
+        return types_[id];
+    }
+
+    FMT_CONSTEXPR auto next_arg_id() -> int
+    {
+        int id = base::next_arg_id();
+        if (id >= num_args_)
+            this->on_error("argument not found");
+        return id;
+    }
+
+    FMT_CONSTEXPR void check_arg_id(int id)
+    {
+        base::check_arg_id(id);
+        if (id >= num_args_)
+            this->on_error("argument not found");
+    }
+    using base::check_arg_id;
+
+    FMT_CONSTEXPR void check_dynamic_spec(int arg_id)
+    {
+        if (arg_id < num_args_ && types_ && !is_integral_type(types_[arg_id]))
+            this->on_error("width/precision is not integer");
+    }
+};
+FMT_END_DETAIL_NAMESPACE
+
+template<typename Char, typename ErrorHandler>
+FMT_CONSTEXPR void basic_format_parse_context<Char, ErrorHandler>::do_check_arg_id(int id)
+{
+    // Argument id is only checked at compile-time during parsing because
+    // formatting has its own validation.
+    if (detail::is_constant_evaluated() && FMT_GCC_VERSION >= 1200)
+    {
+        using context = detail::compile_parse_context<Char, ErrorHandler>;
+        if (id >= static_cast<context *>(this)->num_args())
+            on_error("argument not found");
+    }
+}
+
+template<typename Char, typename ErrorHandler>
+FMT_CONSTEXPR void basic_format_parse_context<Char, ErrorHandler>::check_dynamic_spec(int arg_id)
+{
+    if (detail::is_constant_evaluated())
+    {
+        using context = detail::compile_parse_context<Char, ErrorHandler>;
+        static_cast<context *>(this)->check_dynamic_spec(arg_id);
+    }
+}
+
+template<typename Context>
+class basic_format_arg;
+template<typename Context>
+class basic_format_args;
+template<typename Context>
+class dynamic_format_arg_store;
+
+// A formatter for objects of type T.
+template<typename T, typename Char = char, typename Enable = void>
+struct formatter
+{
+    // A deleted default constructor indicates a disabled formatter.
+    formatter() = delete;
+};
+
+// Specifies if T has an enabled formatter specialization. A type can be
+// formattable even if it doesn't have a formatter e.g. via a conversion.
+template<typename T, typename Context>
+using has_formatter = std::is_constructible<typename Context::template formatter_type<T>>;
+
+// Checks whether T is a container with contiguous storage.
+template<typename T>
+struct is_contiguous : std::false_type
+{};
+template<typename Char>
+struct is_contiguous<std::basic_string<Char>> : std::true_type
+{};
+
+class appender;
+
+FMT_BEGIN_DETAIL_NAMESPACE
+
+template<typename Context, typename T>
+constexpr auto has_const_formatter_impl(T *)
+    -> decltype(typename Context::template formatter_type<T>().format(std::declval<const T &>(), std::declval<Context &>()), true)
+{
+    return true;
+}
+template<typename Context>
+constexpr auto has_const_formatter_impl(...) -> bool
+{
+    return false;
+}
+template<typename T, typename Context>
+constexpr auto has_const_formatter() -> bool
+{
+    return has_const_formatter_impl<Context>(static_cast<T *>(nullptr));
+}
+
+// Extracts a reference to the container from back_insert_iterator.
+template<typename Container>
+inline auto get_container(std::back_insert_iterator<Container> it) -> Container &
+{
+    using base = std::back_insert_iterator<Container>;
+    struct accessor : base
+    {
+        accessor(base b)
+            : base(b)
+        {}
+        using base::container;
+    };
+    return *accessor(it).container;
+}
+
+template<typename Char, typename InputIt, typename OutputIt>
+FMT_CONSTEXPR auto copy_str(InputIt begin, InputIt end, OutputIt out) -> OutputIt
+{
+    while (begin != end)
+        *out++ = static_cast<Char>(*begin++);
+    return out;
+}
+
+template<typename Char, typename T, typename U, FMT_ENABLE_IF(std::is_same<remove_const_t<T>, U>::value &&is_char<U>::value)>
+FMT_CONSTEXPR auto copy_str(T *begin, T *end, U *out) -> U *
+{
+    if (is_constant_evaluated())
+        return copy_str<Char, T *, U *>(begin, end, out);
+    auto size = to_unsigned(end - begin);
+    memcpy(out, begin, size * sizeof(U));
+    return out + size;
+}
+
+/**
+  \rst
+  A contiguous memory buffer with an optional growing ability. It is an internal
+  class and shouldn't be used directly, only via `~fmt::basic_memory_buffer`.
+  \endrst
+ */
+template<typename T>
+class buffer
+{
+private:
+    T *ptr_;
+    size_t size_;
+    size_t capacity_;
+
+protected:
+    // Don't initialize ptr_ since it is not accessed to save a few cycles.
+    FMT_MSC_WARNING(suppress : 26495)
+    buffer(size_t sz) noexcept
+        : size_(sz)
+        , capacity_(sz)
+    {}
+
+    FMT_CONSTEXPR20 buffer(T *p = nullptr, size_t sz = 0, size_t cap = 0) noexcept
+        : ptr_(p)
+        , size_(sz)
+        , capacity_(cap)
+    {}
+
+    FMT_CONSTEXPR20 ~buffer() = default;
+    buffer(buffer &&) = default;
+
+    /** Sets the buffer data and capacity. */
+    FMT_CONSTEXPR void set(T *buf_data, size_t buf_capacity) noexcept
+    {
+        ptr_ = buf_data;
+        capacity_ = buf_capacity;
+    }
+
+    /** Increases the buffer capacity to hold at least *capacity* elements. */
+    virtual FMT_CONSTEXPR20 void grow(size_t capacity) = 0;
+
+public:
+    using value_type = T;
+    using const_reference = const T &;
+
+    buffer(const buffer &) = delete;
+    void operator=(const buffer &) = delete;
+
+    auto begin() noexcept -> T *
+    {
+        return ptr_;
+    }
+    auto end() noexcept -> T *
+    {
+        return ptr_ + size_;
+    }
+
+    auto begin() const noexcept -> const T *
+    {
+        return ptr_;
+    }
+    auto end() const noexcept -> const T *
+    {
+        return ptr_ + size_;
+    }
+
+    /** Returns the size of this buffer. */
+    constexpr auto size() const noexcept -> size_t
+    {
+        return size_;
+    }
+
+    /** Returns the capacity of this buffer. */
+    constexpr auto capacity() const noexcept -> size_t
+    {
+        return capacity_;
+    }
+
+    /** Returns a pointer to the buffer data. */
+    FMT_CONSTEXPR auto data() noexcept -> T *
+    {
+        return ptr_;
+    }
+
+    /** Returns a pointer to the buffer data. */
+    FMT_CONSTEXPR auto data() const noexcept -> const T *
+    {
+        return ptr_;
+    }
+
+    /** Clears this buffer. */
+    void clear()
+    {
+        size_ = 0;
+    }
+
+    // Tries resizing the buffer to contain *count* elements. If T is a POD type
+    // the new elements may not be initialized.
+    FMT_CONSTEXPR20 void try_resize(size_t count)
+    {
+        try_reserve(count);
+        size_ = count <= capacity_ ? count : capacity_;
+    }
+
+    // Tries increasing the buffer capacity to *new_capacity*. It can increase the
+    // capacity by a smaller amount than requested but guarantees there is space
+    // for at least one additional element either by increasing the capacity or by
+    // flushing the buffer if it is full.
+    FMT_CONSTEXPR20 void try_reserve(size_t new_capacity)
+    {
+        if (new_capacity > capacity_)
+            grow(new_capacity);
+    }
+
+    FMT_CONSTEXPR20 void push_back(const T &value)
+    {
+        try_reserve(size_ + 1);
+        ptr_[size_++] = value;
+    }
+
+    /** Appends data to the end of the buffer. */
+    template<typename U>
+    void append(const U *begin, const U *end);
+
+    template<typename Idx>
+    FMT_CONSTEXPR auto operator[](Idx index) -> T &
+    {
+        return ptr_[index];
+    }
+    template<typename Idx>
+    FMT_CONSTEXPR auto operator[](Idx index) const -> const T &
+    {
+        return ptr_[index];
+    }
+};
+
+struct buffer_traits
+{
+    explicit buffer_traits(size_t) {}
+    auto count() const -> size_t
+    {
+        return 0;
+    }
+    auto limit(size_t size) -> size_t
+    {
+        return size;
+    }
+};
+
+class fixed_buffer_traits
+{
+private:
+    size_t count_ = 0;
+    size_t limit_;
+
+public:
+    explicit fixed_buffer_traits(size_t limit)
+        : limit_(limit)
+    {}
+    auto count() const -> size_t
+    {
+        return count_;
+    }
+    auto limit(size_t size) -> size_t
+    {
+        size_t n = limit_ > count_ ? limit_ - count_ : 0;
+        count_ += size;
+        return size < n ? size : n;
+    }
+};
+
+// A buffer that writes to an output iterator when flushed.
+template<typename OutputIt, typename T, typename Traits = buffer_traits>
+class iterator_buffer final : public Traits, public buffer<T>
+{
+private:
+    OutputIt out_;
+    enum
+    {
+        buffer_size = 256
+    };
+    T data_[buffer_size];
+
+protected:
+    FMT_CONSTEXPR20 void grow(size_t) override
+    {
+        if (this->size() == buffer_size)
+            flush();
+    }
+
+    void flush()
+    {
+        auto size = this->size();
+        this->clear();
+        out_ = copy_str<T>(data_, data_ + this->limit(size), out_);
+    }
+
+public:
+    explicit iterator_buffer(OutputIt out, size_t n = buffer_size)
+        : Traits(n)
+        , buffer<T>(data_, 0, buffer_size)
+        , out_(out)
+    {}
+    iterator_buffer(iterator_buffer &&other)
+        : Traits(other)
+        , buffer<T>(data_, 0, buffer_size)
+        , out_(other.out_)
+    {}
+    ~iterator_buffer()
+    {
+        flush();
+    }
+
+    auto out() -> OutputIt
+    {
+        flush();
+        return out_;
+    }
+    auto count() const -> size_t
+    {
+        return Traits::count() + this->size();
+    }
+};
+
+template<typename T>
+class iterator_buffer<T *, T, fixed_buffer_traits> final : public fixed_buffer_traits, public buffer<T>
+{
+private:
+    T *out_;
+    enum
+    {
+        buffer_size = 256
+    };
+    T data_[buffer_size];
+
+protected:
+    FMT_CONSTEXPR20 void grow(size_t) override
+    {
+        if (this->size() == this->capacity())
+            flush();
+    }
+
+    void flush()
+    {
+        size_t n = this->limit(this->size());
+        if (this->data() == out_)
+        {
+            out_ += n;
+            this->set(data_, buffer_size);
+        }
+        this->clear();
+    }
+
+public:
+    explicit iterator_buffer(T *out, size_t n = buffer_size)
+        : fixed_buffer_traits(n)
+        , buffer<T>(out, 0, n)
+        , out_(out)
+    {}
+    iterator_buffer(iterator_buffer &&other)
+        : fixed_buffer_traits(other)
+        , buffer<T>(std::move(other))
+        , out_(other.out_)
+    {
+        if (this->data() != out_)
+        {
+            this->set(data_, buffer_size);
+            this->clear();
+        }
+    }
+    ~iterator_buffer()
+    {
+        flush();
+    }
+
+    auto out() -> T *
+    {
+        flush();
+        return out_;
+    }
+    auto count() const -> size_t
+    {
+        return fixed_buffer_traits::count() + this->size();
+    }
+};
+
+template<typename T>
+class iterator_buffer<T *, T> final : public buffer<T>
+{
+protected:
+    FMT_CONSTEXPR20 void grow(size_t) override {}
+
+public:
+    explicit iterator_buffer(T *out, size_t = 0)
+        : buffer<T>(out, 0, ~size_t())
+    {}
+
+    auto out() -> T *
+    {
+        return &*this->end();
+    }
+};
+
+// A buffer that writes to a container with the contiguous storage.
+template<typename Container>
+class iterator_buffer<std::back_insert_iterator<Container>, enable_if_t<is_contiguous<Container>::value, typename Container::value_type>>
+    final : public buffer<typename Container::value_type>
+{
+private:
+    Container &container_;
+
+protected:
+    FMT_CONSTEXPR20 void grow(size_t capacity) override
+    {
+        container_.resize(capacity);
+        this->set(&container_[0], capacity);
+    }
+
+public:
+    explicit iterator_buffer(Container &c)
+        : buffer<typename Container::value_type>(c.size())
+        , container_(c)
+    {}
+    explicit iterator_buffer(std::back_insert_iterator<Container> out, size_t = 0)
+        : iterator_buffer(get_container(out))
+    {}
+
+    auto out() -> std::back_insert_iterator<Container>
+    {
+        return std::back_inserter(container_);
+    }
+};
+
+// A buffer that counts the number of code units written discarding the output.
+template<typename T = char>
+class counting_buffer final : public buffer<T>
+{
+private:
+    enum
+    {
+        buffer_size = 256
+    };
+    T data_[buffer_size];
+    size_t count_ = 0;
+
+protected:
+    FMT_CONSTEXPR20 void grow(size_t) override
+    {
+        if (this->size() != buffer_size)
+            return;
+        count_ += this->size();
+        this->clear();
+    }
+
+public:
+    counting_buffer()
+        : buffer<T>(data_, 0, buffer_size)
+    {}
+
+    auto count() -> size_t
+    {
+        return count_ + this->size();
+    }
+};
+
+template<typename T>
+using buffer_appender = conditional_t<std::is_same<T, char>::value, appender, std::back_insert_iterator<buffer<T>>>;
+
+// Maps an output iterator to a buffer.
+template<typename T, typename OutputIt>
+auto get_buffer(OutputIt out) -> iterator_buffer<OutputIt, T>
+{
+    return iterator_buffer<OutputIt, T>(out);
+}
+
+template<typename Buffer>
+auto get_iterator(Buffer &buf) -> decltype(buf.out())
+{
+    return buf.out();
+}
+template<typename T>
+auto get_iterator(buffer<T> &buf) -> buffer_appender<T>
+{
+    return buffer_appender<T>(buf);
+}
+
+template<typename T, typename Char = char, typename Enable = void>
+struct fallback_formatter
+{
+    fallback_formatter() = delete;
+};
+
+// Specifies if T has an enabled fallback_formatter specialization.
+template<typename T, typename Char>
+using has_fallback_formatter =
+#ifdef FMT_DEPRECATED_OSTREAM
+    std::is_constructible<fallback_formatter<T, Char>>;
+#else
+    std::false_type;
+#endif
+
+struct view
+{};
+
+template<typename Char, typename T>
+struct named_arg : view
+{
+    const Char *name;
+    const T &value;
+    named_arg(const Char *n, const T &v)
+        : name(n)
+        , value(v)
+    {}
+};
+
+template<typename Char>
+struct named_arg_info
+{
+    const Char *name;
+    int id;
+};
+
+template<typename T, typename Char, size_t NUM_ARGS, size_t NUM_NAMED_ARGS>
+struct arg_data
+{
+    // args_[0].named_args points to named_args_ to avoid bloating format_args.
+    // +1 to workaround a bug in gcc 7.5 that causes duplicated-branches warning.
+    T args_[1 + (NUM_ARGS != 0 ? NUM_ARGS : +1)];
+    named_arg_info<Char> named_args_[NUM_NAMED_ARGS];
+
+    template<typename... U>
+    arg_data(const U &...init)
+        : args_{T(named_args_, NUM_NAMED_ARGS), init...}
+    {}
+    arg_data(const arg_data &other) = delete;
+    auto args() const -> const T *
+    {
+        return args_ + 1;
+    }
+    auto named_args() -> named_arg_info<Char> *
+    {
+        return named_args_;
+    }
+};
+
+template<typename T, typename Char, size_t NUM_ARGS>
+struct arg_data<T, Char, NUM_ARGS, 0>
+{
+    // +1 to workaround a bug in gcc 7.5 that causes duplicated-branches warning.
+    T args_[NUM_ARGS != 0 ? NUM_ARGS : +1];
+
+    template<typename... U>
+    FMT_CONSTEXPR FMT_INLINE arg_data(const U &...init)
+        : args_{init...}
+    {}
+    FMT_CONSTEXPR FMT_INLINE auto args() const -> const T *
+    {
+        return args_;
+    }
+    FMT_CONSTEXPR FMT_INLINE auto named_args() -> std::nullptr_t
+    {
+        return nullptr;
+    }
+};
+
+template<typename Char>
+inline void init_named_args(named_arg_info<Char> *, int, int)
+{}
+
+template<typename T>
+struct is_named_arg : std::false_type
+{};
+template<typename T>
+struct is_statically_named_arg : std::false_type
+{};
+
+template<typename T, typename Char>
+struct is_named_arg<named_arg<Char, T>> : std::true_type
+{};
+
+template<typename Char, typename T, typename... Tail, FMT_ENABLE_IF(!is_named_arg<T>::value)>
+void init_named_args(named_arg_info<Char> *named_args, int arg_count, int named_arg_count, const T &, const Tail &...args)
+{
+    init_named_args(named_args, arg_count + 1, named_arg_count, args...);
+}
+
+template<typename Char, typename T, typename... Tail, FMT_ENABLE_IF(is_named_arg<T>::value)>
+void init_named_args(named_arg_info<Char> *named_args, int arg_count, int named_arg_count, const T &arg, const Tail &...args)
+{
+    named_args[named_arg_count++] = {arg.name, arg_count};
+    init_named_args(named_args, arg_count + 1, named_arg_count, args...);
+}
+
+template<typename... Args>
+FMT_CONSTEXPR FMT_INLINE void init_named_args(std::nullptr_t, int, int, const Args &...)
+{}
+
+template<bool B = false>
+constexpr auto count() -> size_t
+{
+    return B ? 1 : 0;
+}
+template<bool B1, bool B2, bool... Tail>
+constexpr auto count() -> size_t
+{
+    return (B1 ? 1 : 0) + count<B2, Tail...>();
+}
+
+template<typename... Args>
+constexpr auto count_named_args() -> size_t
+{
+    return count<is_named_arg<Args>::value...>();
+}
+
+template<typename... Args>
+constexpr auto count_statically_named_args() -> size_t
+{
+    return count<is_statically_named_arg<Args>::value...>();
+}
+
+struct unformattable
+{};
+struct unformattable_char : unformattable
+{};
+struct unformattable_const : unformattable
+{};
+struct unformattable_pointer : unformattable
+{};
+
+template<typename Char>
+struct string_value
+{
+    const Char *data;
+    size_t size;
+};
+
+template<typename Char>
+struct named_arg_value
+{
+    const named_arg_info<Char> *data;
+    size_t size;
+};
+
+template<typename Context>
+struct custom_value
+{
+    using parse_context = typename Context::parse_context_type;
+    void *value;
+    void (*format)(void *arg, parse_context &parse_ctx, Context &ctx);
+};
+
+// A formatting argument value.
+template<typename Context>
+class value
+{
+public:
+    using char_type = typename Context::char_type;
+
+    union
+    {
+        monostate no_value;
+        int int_value;
+        unsigned uint_value;
+        long long long_long_value;
+        unsigned long long ulong_long_value;
+        int128_opt int128_value;
+        uint128_opt uint128_value;
+        bool bool_value;
+        char_type char_value;
+        float float_value;
+        double double_value;
+        long double long_double_value;
+        const void *pointer;
+        string_value<char_type> string;
+        custom_value<Context> custom;
+        named_arg_value<char_type> named_args;
+    };
+
+    constexpr FMT_INLINE value()
+        : no_value()
+    {}
+    constexpr FMT_INLINE value(int val)
+        : int_value(val)
+    {}
+    constexpr FMT_INLINE value(unsigned val)
+        : uint_value(val)
+    {}
+    constexpr FMT_INLINE value(long long val)
+        : long_long_value(val)
+    {}
+    constexpr FMT_INLINE value(unsigned long long val)
+        : ulong_long_value(val)
+    {}
+    FMT_INLINE value(int128_opt val)
+        : int128_value(val)
+    {}
+    FMT_INLINE value(uint128_opt val)
+        : uint128_value(val)
+    {}
+    constexpr FMT_INLINE value(float val)
+        : float_value(val)
+    {}
+    constexpr FMT_INLINE value(double val)
+        : double_value(val)
+    {}
+    FMT_INLINE value(long double val)
+        : long_double_value(val)
+    {}
+    constexpr FMT_INLINE value(bool val)
+        : bool_value(val)
+    {}
+    constexpr FMT_INLINE value(char_type val)
+        : char_value(val)
+    {}
+    FMT_CONSTEXPR FMT_INLINE value(const char_type *val)
+    {
+        string.data = val;
+        if (is_constant_evaluated())
+            string.size = {};
+    }
+    FMT_CONSTEXPR FMT_INLINE value(basic_string_view<char_type> val)
+    {
+        string.data = val.data();
+        string.size = val.size();
+    }
+    FMT_INLINE value(const void *val)
+        : pointer(val)
+    {}
+    FMT_INLINE value(const named_arg_info<char_type> *args, size_t size)
+        : named_args{args, size}
+    {}
+
+    template<typename T>
+    FMT_CONSTEXPR FMT_INLINE value(T &val)
+    {
+        using value_type = remove_cvref_t<T>;
+        custom.value = const_cast<value_type *>(&val);
+        // Get the formatter type through the context to allow different contexts
+        // have different extension points, e.g. `formatter<T>` for `format` and
+        // `printf_formatter<T>` for `printf`.
+        custom.format = format_custom_arg<value_type,
+            conditional_t<has_formatter<value_type, Context>::value, typename Context::template formatter_type<value_type>,
+                fallback_formatter<value_type, char_type>>>;
+    }
+    value(unformattable);
+    value(unformattable_char);
+    value(unformattable_const);
+    value(unformattable_pointer);
+
+private:
+    // Formats an argument of a custom type, such as a user-defined class.
+    template<typename T, typename Formatter>
+    static void format_custom_arg(void *arg, typename Context::parse_context_type &parse_ctx, Context &ctx)
+    {
+        auto f = Formatter();
+        parse_ctx.advance_to(f.parse(parse_ctx));
+        using qualified_type = conditional_t<has_const_formatter<T, Context>(), const T, T>;
+        ctx.advance_to(f.format(*static_cast<qualified_type *>(arg), ctx));
+    }
+};
+
+template<typename Context, typename T>
+FMT_CONSTEXPR auto make_arg(T &&value) -> basic_format_arg<Context>;
+
+// To minimize the number of types we need to deal with, long is translated
+// either to int or to long long depending on its size.
+enum
+{
+    long_short = sizeof(long) == sizeof(int)
+};
+using long_type = conditional_t<long_short, int, long long>;
+using ulong_type = conditional_t<long_short, unsigned, unsigned long long>;
+
+#ifdef __cpp_lib_byte
+inline auto format_as(std::byte b) -> unsigned char
+{
+    return static_cast<unsigned char>(b);
+}
+#endif
+
+template<typename T>
+struct has_format_as
+{
+    template<typename U, typename V = decltype(format_as(U())), FMT_ENABLE_IF(std::is_enum<U>::value &&std::is_integral<V>::value)>
+    static auto check(U *) -> std::true_type;
+    static auto check(...) -> std::false_type;
+
+    enum
+    {
+        value = decltype(check(static_cast<T *>(nullptr)))::value
+    };
+};
+
+// Maps formatting arguments to core types.
+// arg_mapper reports errors by returning unformattable instead of using
+// static_assert because it's used in the is_formattable trait.
+template<typename Context>
+struct arg_mapper
+{
+    using char_type = typename Context::char_type;
+
+    FMT_CONSTEXPR FMT_INLINE auto map(signed char val) -> int
+    {
+        return val;
+    }
+    FMT_CONSTEXPR FMT_INLINE auto map(unsigned char val) -> unsigned
+    {
+        return val;
+    }
+    FMT_CONSTEXPR FMT_INLINE auto map(short val) -> int
+    {
+        return val;
+    }
+    FMT_CONSTEXPR FMT_INLINE auto map(unsigned short val) -> unsigned
+    {
+        return val;
+    }
+    FMT_CONSTEXPR FMT_INLINE auto map(int val) -> int
+    {
+        return val;
+    }
+    FMT_CONSTEXPR FMT_INLINE auto map(unsigned val) -> unsigned
+    {
+        return val;
+    }
+    FMT_CONSTEXPR FMT_INLINE auto map(long val) -> long_type
+    {
+        return val;
+    }
+    FMT_CONSTEXPR FMT_INLINE auto map(unsigned long val) -> ulong_type
+    {
+        return val;
+    }
+    FMT_CONSTEXPR FMT_INLINE auto map(long long val) -> long long
+    {
+        return val;
+    }
+    FMT_CONSTEXPR FMT_INLINE auto map(unsigned long long val) -> unsigned long long
+    {
+        return val;
+    }
+    FMT_CONSTEXPR FMT_INLINE auto map(int128_opt val) -> int128_opt
+    {
+        return val;
+    }
+    FMT_CONSTEXPR FMT_INLINE auto map(uint128_opt val) -> uint128_opt
+    {
+        return val;
+    }
+    FMT_CONSTEXPR FMT_INLINE auto map(bool val) -> bool
+    {
+        return val;
+    }
+
+    template<typename T, FMT_ENABLE_IF(std::is_same<T, char>::value || std::is_same<T, char_type>::value)>
+    FMT_CONSTEXPR FMT_INLINE auto map(T val) -> char_type
+    {
+        return val;
+    }
+    template<typename T, enable_if_t<(std::is_same<T, wchar_t>::value ||
+#ifdef __cpp_char8_t
+                                         std::is_same<T, char8_t>::value ||
+#endif
+                                         std::is_same<T, char16_t>::value || std::is_same<T, char32_t>::value) &&
+                                         !std::is_same<T, char_type>::value,
+                             int> = 0>
+    FMT_CONSTEXPR FMT_INLINE auto map(T) -> unformattable_char
+    {
+        return {};
+    }
+
+    FMT_CONSTEXPR FMT_INLINE auto map(float val) -> float
+    {
+        return val;
+    }
+    FMT_CONSTEXPR FMT_INLINE auto map(double val) -> double
+    {
+        return val;
+    }
+    FMT_CONSTEXPR FMT_INLINE auto map(long double val) -> long double
+    {
+        return val;
+    }
+
+    FMT_CONSTEXPR FMT_INLINE auto map(char_type *val) -> const char_type *
+    {
+        return val;
+    }
+    FMT_CONSTEXPR FMT_INLINE auto map(const char_type *val) -> const char_type *
+    {
+        return val;
+    }
+    template<typename T, FMT_ENABLE_IF(is_string<T>::value && !std::is_pointer<T>::value && std::is_same<char_type, char_t<T>>::value)>
+    FMT_CONSTEXPR FMT_INLINE auto map(const T &val) -> basic_string_view<char_type>
+    {
+        return to_string_view(val);
+    }
+    template<typename T, FMT_ENABLE_IF(is_string<T>::value && !std::is_pointer<T>::value && !std::is_same<char_type, char_t<T>>::value)>
+    FMT_CONSTEXPR FMT_INLINE auto map(const T &) -> unformattable_char
+    {
+        return {};
+    }
+    template<typename T, FMT_ENABLE_IF(std::is_convertible<T, basic_string_view<char_type>>::value && !is_string<T>::value &&
+                                       !has_formatter<T, Context>::value && !has_fallback_formatter<T, char_type>::value)>
+    FMT_CONSTEXPR FMT_INLINE auto map(const T &val) -> basic_string_view<char_type>
+    {
+        return basic_string_view<char_type>(val);
+    }
+    template<typename T, FMT_ENABLE_IF(std::is_convertible<T, std_string_view<char_type>>::value &&
+                                       !std::is_convertible<T, basic_string_view<char_type>>::value && !is_string<T>::value &&
+                                       !has_formatter<T, Context>::value && !has_fallback_formatter<T, char_type>::value)>
+    FMT_CONSTEXPR FMT_INLINE auto map(const T &val) -> basic_string_view<char_type>
+    {
+        return std_string_view<char_type>(val);
+    }
+
+    FMT_CONSTEXPR FMT_INLINE auto map(void *val) -> const void *
+    {
+        return val;
+    }
+    FMT_CONSTEXPR FMT_INLINE auto map(const void *val) -> const void *
+    {
+        return val;
+    }
+    FMT_CONSTEXPR FMT_INLINE auto map(std::nullptr_t val) -> const void *
+    {
+        return val;
+    }
+
+    // We use SFINAE instead of a const T* parameter to avoid conflicting with
+    // the C array overload.
+    template<typename T, FMT_ENABLE_IF(std::is_pointer<T>::value || std::is_member_pointer<T>::value ||
+                                       std::is_function<typename std::remove_pointer<T>::type>::value ||
+                                       (std::is_convertible<const T &, const void *>::value &&
+                                           !std::is_convertible<const T &, const char_type *>::value && !has_formatter<T, Context>::value))>
+    FMT_CONSTEXPR auto map(const T &) -> unformattable_pointer
+    {
+        return {};
+    }
+
+    template<typename T, std::size_t N, FMT_ENABLE_IF(!std::is_same<T, wchar_t>::value)>
+    FMT_CONSTEXPR FMT_INLINE auto map(const T (&values)[N]) -> const T (&)[N]
+    {
+        return values;
+    }
+
+    template<typename T, FMT_ENABLE_IF(std::is_enum<T>::value &&std::is_convertible<T, int>::value && !has_format_as<T>::value &&
+                                       !has_formatter<T, Context>::value && !has_fallback_formatter<T, char_type>::value)>
+    FMT_DEPRECATED FMT_CONSTEXPR FMT_INLINE auto map(const T &val)
+        -> decltype(std::declval<arg_mapper>().map(static_cast<underlying_t<T>>(val)))
+    {
+        return map(static_cast<underlying_t<T>>(val));
+    }
+
+    template<typename T, FMT_ENABLE_IF(has_format_as<T>::value && !has_formatter<T, Context>::value)>
+    FMT_CONSTEXPR FMT_INLINE auto map(const T &val) -> decltype(std::declval<arg_mapper>().map(format_as(T())))
+    {
+        return map(format_as(val));
+    }
+
+    template<typename T, typename U = remove_cvref_t<T>>
+    struct formattable : bool_constant<has_const_formatter<U, Context>() || !std::is_const<remove_reference_t<T>>::value ||
+                                       has_fallback_formatter<U, char_type>::value>
+    {};
+
+#if (FMT_MSC_VERSION != 0 && FMT_MSC_VERSION < 1910) || FMT_ICC_VERSION != 0 || defined(__NVCC__)
+    // Workaround a bug in MSVC and Intel (Issue 2746).
+    template<typename T>
+    FMT_CONSTEXPR FMT_INLINE auto do_map(T &&val) -> T &
+    {
+        return val;
+    }
+#else
+    template<typename T, FMT_ENABLE_IF(formattable<T>::value)>
+    FMT_CONSTEXPR FMT_INLINE auto do_map(T &&val) -> T &
+    {
+        return val;
+    }
+    template<typename T, FMT_ENABLE_IF(!formattable<T>::value)>
+    FMT_CONSTEXPR FMT_INLINE auto do_map(T &&) -> unformattable_const
+    {
+        return {};
+    }
+#endif
+
+    template<typename T, typename U = remove_cvref_t<T>,
+        FMT_ENABLE_IF(!is_string<U>::value && !is_char<U>::value && !std::is_array<U>::value && !std::is_pointer<U>::value &&
+                      !has_format_as<U>::value && (has_formatter<U, Context>::value || has_fallback_formatter<U, char_type>::value))>
+    FMT_CONSTEXPR FMT_INLINE auto map(T &&val) -> decltype(this->do_map(std::forward<T>(val)))
+    {
+        return do_map(std::forward<T>(val));
+    }
+
+    template<typename T, FMT_ENABLE_IF(is_named_arg<T>::value)>
+    FMT_CONSTEXPR FMT_INLINE auto map(const T &named_arg) -> decltype(std::declval<arg_mapper>().map(named_arg.value))
+    {
+        return map(named_arg.value);
+    }
+
+    auto map(...) -> unformattable
+    {
+        return {};
+    }
+};
+
+// A type constant after applying arg_mapper<Context>.
+template<typename T, typename Context>
+using mapped_type_constant = type_constant<decltype(arg_mapper<Context>().map(std::declval<const T &>())), typename Context::char_type>;
+
+enum
+{
+    packed_arg_bits = 4
+};
+// Maximum number of arguments with packed types.
+enum
+{
+    max_packed_args = 62 / packed_arg_bits
+};
+enum : unsigned long long
+{
+    is_unpacked_bit = 1ULL << 63
+};
+enum : unsigned long long
+{
+    has_named_args_bit = 1ULL << 62
+};
+
+FMT_END_DETAIL_NAMESPACE
+
+// An output iterator that appends to a buffer.
+// It is used to reduce symbol sizes for the common case.
+class appender : public std::back_insert_iterator<detail::buffer<char>>
+{
+    using base = std::back_insert_iterator<detail::buffer<char>>;
+
+    template<typename T>
+    friend auto get_buffer(appender out) -> detail::buffer<char> &
+    {
+        return detail::get_container(out);
+    }
+
+public:
+    using std::back_insert_iterator<detail::buffer<char>>::back_insert_iterator;
+    appender(base it) noexcept
+        : base(it)
+    {}
+    FMT_UNCHECKED_ITERATOR(appender);
+
+    auto operator++() noexcept -> appender &
+    {
+        return *this;
+    }
+    auto operator++(int) noexcept -> appender
+    {
+        return *this;
+    }
+};
+
+// A formatting argument. It is a trivially copyable/constructible type to
+// allow storage in basic_memory_buffer.
+template<typename Context>
+class basic_format_arg
+{
+private:
+    detail::value<Context> value_;
+    detail::type type_;
+
+    template<typename ContextType, typename T>
+    friend FMT_CONSTEXPR auto detail::make_arg(T &&value) -> basic_format_arg<ContextType>;
+
+    template<typename Visitor, typename Ctx>
+    friend FMT_CONSTEXPR auto visit_format_arg(Visitor &&vis, const basic_format_arg<Ctx> &arg) -> decltype(vis(0));
+
+    friend class basic_format_args<Context>;
+    friend class dynamic_format_arg_store<Context>;
+
+    using char_type = typename Context::char_type;
+
+    template<typename T, typename Char, size_t NUM_ARGS, size_t NUM_NAMED_ARGS>
+    friend struct detail::arg_data;
+
+    basic_format_arg(const detail::named_arg_info<char_type> *args, size_t size)
+        : value_(args, size)
+    {}
+
+public:
+    class handle
+    {
+    public:
+        explicit handle(detail::custom_value<Context> custom)
+            : custom_(custom)
+        {}
+
+        void format(typename Context::parse_context_type &parse_ctx, Context &ctx) const
+        {
+            custom_.format(custom_.value, parse_ctx, ctx);
+        }
+
+    private:
+        detail::custom_value<Context> custom_;
+    };
+
+    constexpr basic_format_arg()
+        : type_(detail::type::none_type)
+    {}
+
+    constexpr explicit operator bool() const noexcept
+    {
+        return type_ != detail::type::none_type;
+    }
+
+    auto type() const -> detail::type
+    {
+        return type_;
+    }
+
+    auto is_integral() const -> bool
+    {
+        return detail::is_integral_type(type_);
+    }
+    auto is_arithmetic() const -> bool
+    {
+        return detail::is_arithmetic_type(type_);
+    }
+};
+
+/**
+  \rst
+  Visits an argument dispatching to the appropriate visit method based on
+  the argument type. For example, if the argument type is ``double`` then
+  ``vis(value)`` will be called with the value of type ``double``.
+  \endrst
+ */
+template<typename Visitor, typename Context>
+FMT_CONSTEXPR FMT_INLINE auto visit_format_arg(Visitor &&vis, const basic_format_arg<Context> &arg) -> decltype(vis(0))
+{
+    switch (arg.type_)
+    {
+    case detail::type::none_type:
+        break;
+    case detail::type::int_type:
+        return vis(arg.value_.int_value);
+    case detail::type::uint_type:
+        return vis(arg.value_.uint_value);
+    case detail::type::long_long_type:
+        return vis(arg.value_.long_long_value);
+    case detail::type::ulong_long_type:
+        return vis(arg.value_.ulong_long_value);
+    case detail::type::int128_type:
+        return vis(detail::convert_for_visit(arg.value_.int128_value));
+    case detail::type::uint128_type:
+        return vis(detail::convert_for_visit(arg.value_.uint128_value));
+    case detail::type::bool_type:
+        return vis(arg.value_.bool_value);
+    case detail::type::char_type:
+        return vis(arg.value_.char_value);
+    case detail::type::float_type:
+        return vis(arg.value_.float_value);
+    case detail::type::double_type:
+        return vis(arg.value_.double_value);
+    case detail::type::long_double_type:
+        return vis(arg.value_.long_double_value);
+    case detail::type::cstring_type:
+        return vis(arg.value_.string.data);
+    case detail::type::string_type:
+        using sv = basic_string_view<typename Context::char_type>;
+        return vis(sv(arg.value_.string.data, arg.value_.string.size));
+    case detail::type::pointer_type:
+        return vis(arg.value_.pointer);
+    case detail::type::custom_type:
+        return vis(typename basic_format_arg<Context>::handle(arg.value_.custom));
+    }
+    return vis(monostate());
+}
+
+FMT_BEGIN_DETAIL_NAMESPACE
+
+template<typename Char, typename InputIt>
+auto copy_str(InputIt begin, InputIt end, appender out) -> appender
+{
+    get_container(out).append(begin, end);
+    return out;
+}
+
+template<typename Char, typename R, typename OutputIt>
+FMT_CONSTEXPR auto copy_str(R &&rng, OutputIt out) -> OutputIt
+{
+    return detail::copy_str<Char>(rng.begin(), rng.end(), out);
+}
+
+#if FMT_GCC_VERSION && FMT_GCC_VERSION < 500
+// A workaround for gcc 4.8 to make void_t work in a SFINAE context.
+template<typename... Ts>
+struct void_t_impl
+{
+    using type = void;
+};
+template<typename... Ts>
+using void_t = typename detail::void_t_impl<Ts...>::type;
+#else
+template<typename...>
+using void_t = void;
+#endif
+
+template<typename It, typename T, typename Enable = void>
+struct is_output_iterator : std::false_type
+{};
+
+template<typename It, typename T>
+struct is_output_iterator<It, T,
+    void_t<typename std::iterator_traits<It>::iterator_category, decltype(*std::declval<It>() = std::declval<T>())>> : std::true_type
+{};
+
+template<typename OutputIt>
+struct is_back_insert_iterator : std::false_type
+{};
+template<typename Container>
+struct is_back_insert_iterator<std::back_insert_iterator<Container>> : std::true_type
+{};
+
+template<typename OutputIt>
+struct is_contiguous_back_insert_iterator : std::false_type
+{};
+template<typename Container>
+struct is_contiguous_back_insert_iterator<std::back_insert_iterator<Container>> : is_contiguous<Container>
+{};
+template<>
+struct is_contiguous_back_insert_iterator<appender> : std::true_type
+{};
+
+// A type-erased reference to an std::locale to avoid a heavy <locale> include.
+class locale_ref
+{
+private:
+    const void *locale_; // A type-erased pointer to std::locale.
+
+public:
+    constexpr locale_ref()
+        : locale_(nullptr)
+    {}
+    template<typename Locale>
+    explicit locale_ref(const Locale &loc);
+
+    explicit operator bool() const noexcept
+    {
+        return locale_ != nullptr;
+    }
+
+    template<typename Locale>
+    auto get() const -> Locale;
+};
+
+template<typename>
+constexpr auto encode_types() -> unsigned long long
+{
+    return 0;
+}
+
+template<typename Context, typename Arg, typename... Args>
+constexpr auto encode_types() -> unsigned long long
+{
+    return static_cast<unsigned>(mapped_type_constant<Arg, Context>::value) | (encode_types<Context, Args...>() << packed_arg_bits);
+}
+
+template<typename Context, typename T>
+FMT_CONSTEXPR FMT_INLINE auto make_value(T &&val) -> value<Context>
+{
+    const auto &arg = arg_mapper<Context>().map(FMT_FORWARD(val));
+
+    constexpr bool formattable_char = !std::is_same<decltype(arg), const unformattable_char &>::value;
+    static_assert(formattable_char, "Mixing character types is disallowed.");
+
+    constexpr bool formattable_const = !std::is_same<decltype(arg), const unformattable_const &>::value;
+    static_assert(formattable_const, "Cannot format a const argument.");
+
+    // Formatting of arbitrary pointers is disallowed. If you want to output
+    // a pointer cast it to "void *" or "const void *". In particular, this
+    // forbids formatting of "[const] volatile char *" which is printed as bool
+    // by iostreams.
+    constexpr bool formattable_pointer = !std::is_same<decltype(arg), const unformattable_pointer &>::value;
+    static_assert(formattable_pointer, "Formatting of non-void pointers is disallowed.");
+
+    constexpr bool formattable = !std::is_same<decltype(arg), const unformattable &>::value;
+    static_assert(formattable, "Cannot format an argument. To make type T formattable provide a "
+                               "formatter<T> specialization: https://fmt.dev/latest/api.html#udt");
+    return {arg};
+}
+
+template<typename Context, typename T>
+FMT_CONSTEXPR auto make_arg(T &&value) -> basic_format_arg<Context>
+{
+    basic_format_arg<Context> arg;
+    arg.type_ = mapped_type_constant<T, Context>::value;
+    arg.value_ = make_value<Context>(value);
+    return arg;
+}
+
+// The type template parameter is there to avoid an ODR violation when using
+// a fallback formatter in one translation unit and an implicit conversion in
+// another (not recommended).
+template<bool IS_PACKED, typename Context, type, typename T, FMT_ENABLE_IF(IS_PACKED)>
+FMT_CONSTEXPR FMT_INLINE auto make_arg(T &&val) -> value<Context>
+{
+    return make_value<Context>(val);
+}
+
+template<bool IS_PACKED, typename Context, type, typename T, FMT_ENABLE_IF(!IS_PACKED)>
+FMT_CONSTEXPR inline auto make_arg(T &&value) -> basic_format_arg<Context>
+{
+    return make_arg<Context>(value);
+}
+FMT_END_DETAIL_NAMESPACE
+
+// Formatting context.
+template<typename OutputIt, typename Char>
+class basic_format_context
+{
+public:
+    /** The character type for the output. */
+    using char_type = Char;
+
+private:
+    OutputIt out_;
+    basic_format_args<basic_format_context> args_;
+    detail::locale_ref loc_;
+
+public:
+    using iterator = OutputIt;
+    using format_arg = basic_format_arg<basic_format_context>;
+    using parse_context_type = basic_format_parse_context<Char>;
+    template<typename T>
+    using formatter_type = formatter<T, char_type>;
+
+    basic_format_context(basic_format_context &&) = default;
+    basic_format_context(const basic_format_context &) = delete;
+    void operator=(const basic_format_context &) = delete;
+    /**
+     Constructs a ``basic_format_context`` object. References to the arguments are
+     stored in the object so make sure they have appropriate lifetimes.
+     */
+    constexpr basic_format_context(
+        OutputIt out, basic_format_args<basic_format_context> ctx_args, detail::locale_ref loc = detail::locale_ref())
+        : out_(out)
+        , args_(ctx_args)
+        , loc_(loc)
+    {}
+
+    constexpr auto arg(int id) const -> format_arg
+    {
+        return args_.get(id);
+    }
+    FMT_CONSTEXPR auto arg(basic_string_view<char_type> name) -> format_arg
+    {
+        return args_.get(name);
+    }
+    FMT_CONSTEXPR auto arg_id(basic_string_view<char_type> name) -> int
+    {
+        return args_.get_id(name);
+    }
+    auto args() const -> const basic_format_args<basic_format_context> &
+    {
+        return args_;
+    }
+
+    FMT_CONSTEXPR auto error_handler() -> detail::error_handler
+    {
+        return {};
+    }
+    void on_error(const char *message)
+    {
+        error_handler().on_error(message);
+    }
+
+    // Returns an iterator to the beginning of the output range.
+    FMT_CONSTEXPR auto out() -> iterator
+    {
+        return out_;
+    }
+
+    // Advances the begin iterator to ``it``.
+    void advance_to(iterator it)
+    {
+        if (!detail::is_back_insert_iterator<iterator>())
+            out_ = it;
+    }
+
+    FMT_CONSTEXPR auto locale() -> detail::locale_ref
+    {
+        return loc_;
+    }
+};
+
+template<typename Char>
+using buffer_context = basic_format_context<detail::buffer_appender<Char>, Char>;
+using format_context = buffer_context<char>;
+
+// Workaround an alias issue: https://stackoverflow.com/q/62767544/471164.
+#define FMT_BUFFER_CONTEXT(Char) basic_format_context<detail::buffer_appender<Char>, Char>
+
+template<typename T, typename Char = char>
+using is_formattable = bool_constant<
+    !std::is_base_of<detail::unformattable, decltype(detail::arg_mapper<buffer_context<Char>>().map(std::declval<T>()))>::value &&
+    !detail::has_fallback_formatter<T, Char>::value>;
+
+/**
+  \rst
+  An array of references to arguments. It can be implicitly converted into
+  `~fmt::basic_format_args` for passing into type-erased formatting functions
+  such as `~fmt::vformat`.
+  \endrst
+ */
+template<typename Context, typename... Args>
+class format_arg_store
+#if FMT_GCC_VERSION && FMT_GCC_VERSION < 409
+    // Workaround a GCC template argument substitution bug.
+    : public basic_format_args<Context>
+#endif
+{
+private:
+    static const size_t num_args = sizeof...(Args);
+    static const size_t num_named_args = detail::count_named_args<Args...>();
+    static const bool is_packed = num_args <= detail::max_packed_args;
+
+    using value_type = conditional_t<is_packed, detail::value<Context>, basic_format_arg<Context>>;
+
+    detail::arg_data<value_type, typename Context::char_type, num_args, num_named_args> data_;
+
+    friend class basic_format_args<Context>;
+
+    static constexpr unsigned long long desc = (is_packed ? detail::encode_types<Context, Args...>() : detail::is_unpacked_bit | num_args) |
+                                               (num_named_args != 0 ? static_cast<unsigned long long>(detail::has_named_args_bit) : 0);
+
+public:
+    template<typename... T>
+    FMT_CONSTEXPR FMT_INLINE format_arg_store(T &&...args)
+        :
+#if FMT_GCC_VERSION && FMT_GCC_VERSION < 409
+        basic_format_args<Context>(*this)
+        ,
+#endif
+        data_{detail::make_arg<is_packed, Context, detail::mapped_type_constant<remove_cvref_t<T>, Context>::value>(FMT_FORWARD(args))...}
+    {
+        detail::init_named_args(data_.named_args(), 0, 0, args...);
+    }
+};
+
+/**
+  \rst
+  Constructs a `~fmt::format_arg_store` object that contains references to
+  arguments and can be implicitly converted to `~fmt::format_args`. `Context`
+  can be omitted in which case it defaults to `~fmt::context`.
+  See `~fmt::arg` for lifetime considerations.
+  \endrst
+ */
+template<typename Context = format_context, typename... Args>
+constexpr auto make_format_args(Args &&...args) -> format_arg_store<Context, remove_cvref_t<Args>...>
+{
+    return {FMT_FORWARD(args)...};
+}
+
+/**
+  \rst
+  Returns a named argument to be used in a formatting function.
+  It should only be used in a call to a formatting function or
+  `dynamic_format_arg_store::push_back`.
+
+  **Example**::
+
+    fmt::print("Elapsed time: {s:.2f} seconds", fmt::arg("s", 1.23));
+  \endrst
+ */
+template<typename Char, typename T>
+inline auto arg(const Char *name, const T &arg) -> detail::named_arg<Char, T>
+{
+    static_assert(!detail::is_named_arg<T>(), "nested named arguments");
+    return {name, arg};
+}
+
+/**
+  \rst
+  A view of a collection of formatting arguments. To avoid lifetime issues it
+  should only be used as a parameter type in type-erased functions such as
+  ``vformat``::
+
+    void vlog(string_view format_str, format_args args);  // OK
+    format_args args = make_format_args(42);  // Error: dangling reference
+  \endrst
+ */
+template<typename Context>
+class basic_format_args
+{
+public:
+    using size_type = int;
+    using format_arg = basic_format_arg<Context>;
+
+private:
+    // A descriptor that contains information about formatting arguments.
+    // If the number of arguments is less or equal to max_packed_args then
+    // argument types are passed in the descriptor. This reduces binary code size
+    // per formatting function call.
+    unsigned long long desc_;
+    union
+    {
+        // If is_packed() returns true then argument values are stored in values_;
+        // otherwise they are stored in args_. This is done to improve cache
+        // locality and reduce compiled code size since storing larger objects
+        // may require more code (at least on x86-64) even if the same amount of
+        // data is actually copied to stack. It saves ~10% on the bloat test.
+        const detail::value<Context> *values_;
+        const format_arg *args_;
+    };
+
+    constexpr auto is_packed() const -> bool
+    {
+        return (desc_ & detail::is_unpacked_bit) == 0;
+    }
+    auto has_named_args() const -> bool
+    {
+        return (desc_ & detail::has_named_args_bit) != 0;
+    }
+
+    FMT_CONSTEXPR auto type(int index) const -> detail::type
+    {
+        int shift = index * detail::packed_arg_bits;
+        unsigned int mask = (1 << detail::packed_arg_bits) - 1;
+        return static_cast<detail::type>((desc_ >> shift) & mask);
+    }
+
+    constexpr FMT_INLINE basic_format_args(unsigned long long desc, const detail::value<Context> *values)
+        : desc_(desc)
+        , values_(values)
+    {}
+    constexpr basic_format_args(unsigned long long desc, const format_arg *args)
+        : desc_(desc)
+        , args_(args)
+    {}
+
+public:
+    constexpr basic_format_args()
+        : desc_(0)
+        , args_(nullptr)
+    {}
+
+    /**
+     \rst
+     Constructs a `basic_format_args` object from `~fmt::format_arg_store`.
+     \endrst
+     */
+    template<typename... Args>
+    constexpr FMT_INLINE basic_format_args(const format_arg_store<Context, Args...> &store)
+        : basic_format_args(format_arg_store<Context, Args...>::desc, store.data_.args())
+    {}
+
+    /**
+     \rst
+     Constructs a `basic_format_args` object from
+     `~fmt::dynamic_format_arg_store`.
+     \endrst
+     */
+    constexpr FMT_INLINE basic_format_args(const dynamic_format_arg_store<Context> &store)
+        : basic_format_args(store.get_types(), store.data())
+    {}
+
+    /**
+     \rst
+     Constructs a `basic_format_args` object from a dynamic set of arguments.
+     \endrst
+     */
+    constexpr basic_format_args(const format_arg *args, int count)
+        : basic_format_args(detail::is_unpacked_bit | detail::to_unsigned(count), args)
+    {}
+
+    /** Returns the argument with the specified id. */
+    FMT_CONSTEXPR auto get(int id) const -> format_arg
+    {
+        format_arg arg;
+        if (!is_packed())
+        {
+            if (id < max_size())
+                arg = args_[id];
+            return arg;
+        }
+        if (id >= detail::max_packed_args)
+            return arg;
+        arg.type_ = type(id);
+        if (arg.type_ == detail::type::none_type)
+            return arg;
+        arg.value_ = values_[id];
+        return arg;
+    }
+
+    template<typename Char>
+    auto get(basic_string_view<Char> name) const -> format_arg
+    {
+        int id = get_id(name);
+        return id >= 0 ? get(id) : format_arg();
+    }
+
+    template<typename Char>
+    auto get_id(basic_string_view<Char> name) const -> int
+    {
+        if (!has_named_args())
+            return -1;
+        const auto &named_args = (is_packed() ? values_[-1] : args_[-1].value_).named_args;
+        for (size_t i = 0; i < named_args.size; ++i)
+        {
+            if (named_args.data[i].name == name)
+                return named_args.data[i].id;
+        }
+        return -1;
+    }
+
+    auto max_size() const -> int
+    {
+        unsigned long long max_packed = detail::max_packed_args;
+        return static_cast<int>(is_packed() ? max_packed : desc_ & ~detail::is_unpacked_bit);
+    }
+};
+
+/** An alias to ``basic_format_args<format_context>``. */
+// A separate type would result in shorter symbols but break ABI compatibility
+// between clang and gcc on ARM (#1919).
+using format_args = basic_format_args<format_context>;
+
+// We cannot use enum classes as bit fields because of a gcc bug, so we put them
+// in namespaces instead (https://gcc.gnu.org/bugzilla/show_bug.cgi?id=61414).
+// Additionally, if an underlying type is specified, older gcc incorrectly warns
+// that the type is too small. Both bugs are fixed in gcc 9.3.
+#if FMT_GCC_VERSION && FMT_GCC_VERSION < 903
+#    define FMT_ENUM_UNDERLYING_TYPE(type)
+#else
+#    define FMT_ENUM_UNDERLYING_TYPE(type) : type
+#endif
+namespace align {
+enum type FMT_ENUM_UNDERLYING_TYPE(unsigned char){none, left, right, center, numeric};
+}
+using align_t = align::type;
+namespace sign {
+enum type FMT_ENUM_UNDERLYING_TYPE(unsigned char){none, minus, plus, space};
+}
+using sign_t = sign::type;
+
+FMT_BEGIN_DETAIL_NAMESPACE
+
+// Workaround an array initialization issue in gcc 4.8.
+template<typename Char>
+struct fill_t
+{
+private:
+    enum
+    {
+        max_size = 4
+    };
+    Char data_[max_size] = {Char(' '), Char(0), Char(0), Char(0)};
+    unsigned char size_ = 1;
+
+public:
+    FMT_CONSTEXPR void operator=(basic_string_view<Char> s)
+    {
+        auto size = s.size();
+        if (size > max_size)
+            return throw_format_error("invalid fill");
+        for (size_t i = 0; i < size; ++i)
+            data_[i] = s[i];
+        size_ = static_cast<unsigned char>(size);
+    }
+
+    constexpr auto size() const -> size_t
+    {
+        return size_;
+    }
+    constexpr auto data() const -> const Char *
+    {
+        return data_;
+    }
+
+    FMT_CONSTEXPR auto operator[](size_t index) -> Char &
+    {
+        return data_[index];
+    }
+    FMT_CONSTEXPR auto operator[](size_t index) const -> const Char &
+    {
+        return data_[index];
+    }
+};
+FMT_END_DETAIL_NAMESPACE
+
+enum class presentation_type : unsigned char
+{
+    none,
+    // Integer types should go first,
+    dec,            // 'd'
+    oct,            // 'o'
+    hex_lower,      // 'x'
+    hex_upper,      // 'X'
+    bin_lower,      // 'b'
+    bin_upper,      // 'B'
+    hexfloat_lower, // 'a'
+    hexfloat_upper, // 'A'
+    exp_lower,      // 'e'
+    exp_upper,      // 'E'
+    fixed_lower,    // 'f'
+    fixed_upper,    // 'F'
+    general_lower,  // 'g'
+    general_upper,  // 'G'
+    chr,            // 'c'
+    string,         // 's'
+    pointer,        // 'p'
+    debug           // '?'
+};
+
+// Format specifiers for built-in and string types.
+template<typename Char>
+struct basic_format_specs
+{
+    int width;
+    int precision;
+    presentation_type type;
+    align_t align : 4;
+    sign_t sign : 3;
+    bool alt : 1; // Alternate form ('#').
+    bool localized : 1;
+    detail::fill_t<Char> fill;
+
+    constexpr basic_format_specs()
+        : width(0)
+        , precision(-1)
+        , type(presentation_type::none)
+        , align(align::none)
+        , sign(sign::none)
+        , alt(false)
+        , localized(false)
+    {}
+};
+
+using format_specs = basic_format_specs<char>;
+
+FMT_BEGIN_DETAIL_NAMESPACE
+
+enum class arg_id_kind
+{
+    none,
+    index,
+    name
+};
+
+// An argument reference.
+template<typename Char>
+struct arg_ref
+{
+    FMT_CONSTEXPR arg_ref()
+        : kind(arg_id_kind::none)
+        , val()
+    {}
+
+    FMT_CONSTEXPR explicit arg_ref(int index)
+        : kind(arg_id_kind::index)
+        , val(index)
+    {}
+    FMT_CONSTEXPR explicit arg_ref(basic_string_view<Char> name)
+        : kind(arg_id_kind::name)
+        , val(name)
+    {}
+
+    FMT_CONSTEXPR auto operator=(int idx) -> arg_ref &
+    {
+        kind = arg_id_kind::index;
+        val.index = idx;
+        return *this;
+    }
+
+    arg_id_kind kind;
+    union value
+    {
+        FMT_CONSTEXPR value(int id = 0)
+            : index{id}
+        {}
+        FMT_CONSTEXPR value(basic_string_view<Char> n)
+            : name(n)
+        {}
+
+        int index;
+        basic_string_view<Char> name;
+    } val;
+};
+
+// Format specifiers with width and precision resolved at formatting rather
+// than parsing time to allow re-using the same parsed specifiers with
+// different sets of arguments (precompilation of format strings).
+template<typename Char>
+struct dynamic_format_specs : basic_format_specs<Char>
+{
+    arg_ref<Char> width_ref;
+    arg_ref<Char> precision_ref;
+};
+
+struct auto_id
+{};
+
+// A format specifier handler that sets fields in basic_format_specs.
+template<typename Char>
+class specs_setter
+{
+protected:
+    basic_format_specs<Char> &specs_;
+
+public:
+    explicit FMT_CONSTEXPR specs_setter(basic_format_specs<Char> &specs)
+        : specs_(specs)
+    {}
+
+    FMT_CONSTEXPR specs_setter(const specs_setter &other)
+        : specs_(other.specs_)
+    {}
+
+    FMT_CONSTEXPR void on_align(align_t align)
+    {
+        specs_.align = align;
+    }
+    FMT_CONSTEXPR void on_fill(basic_string_view<Char> fill)
+    {
+        specs_.fill = fill;
+    }
+    FMT_CONSTEXPR void on_sign(sign_t s)
+    {
+        specs_.sign = s;
+    }
+    FMT_CONSTEXPR void on_hash()
+    {
+        specs_.alt = true;
+    }
+    FMT_CONSTEXPR void on_localized()
+    {
+        specs_.localized = true;
+    }
+
+    FMT_CONSTEXPR void on_zero()
+    {
+        if (specs_.align == align::none)
+            specs_.align = align::numeric;
+        specs_.fill[0] = Char('0');
+    }
+
+    FMT_CONSTEXPR void on_width(int width)
+    {
+        specs_.width = width;
+    }
+    FMT_CONSTEXPR void on_precision(int precision)
+    {
+        specs_.precision = precision;
+    }
+    FMT_CONSTEXPR void end_precision() {}
+
+    FMT_CONSTEXPR void on_type(presentation_type type)
+    {
+        specs_.type = type;
+    }
+};
+
+// Format spec handler that saves references to arguments representing dynamic
+// width and precision to be resolved at formatting time.
+template<typename ParseContext>
+class dynamic_specs_handler : public specs_setter<typename ParseContext::char_type>
+{
+public:
+    using char_type = typename ParseContext::char_type;
+
+    FMT_CONSTEXPR dynamic_specs_handler(dynamic_format_specs<char_type> &specs, ParseContext &ctx)
+        : specs_setter<char_type>(specs)
+        , specs_(specs)
+        , context_(ctx)
+    {}
+
+    FMT_CONSTEXPR dynamic_specs_handler(const dynamic_specs_handler &other)
+        : specs_setter<char_type>(other)
+        , specs_(other.specs_)
+        , context_(other.context_)
+    {}
+
+    template<typename Id>
+    FMT_CONSTEXPR void on_dynamic_width(Id arg_id)
+    {
+        specs_.width_ref = make_arg_ref(arg_id);
+    }
+
+    template<typename Id>
+    FMT_CONSTEXPR void on_dynamic_precision(Id arg_id)
+    {
+        specs_.precision_ref = make_arg_ref(arg_id);
+    }
+
+    FMT_CONSTEXPR void on_error(const char *message)
+    {
+        context_.on_error(message);
+    }
+
+private:
+    dynamic_format_specs<char_type> &specs_;
+    ParseContext &context_;
+
+    using arg_ref_type = arg_ref<char_type>;
+
+    FMT_CONSTEXPR auto make_arg_ref(int arg_id) -> arg_ref_type
+    {
+        context_.check_arg_id(arg_id);
+        context_.check_dynamic_spec(arg_id);
+        return arg_ref_type(arg_id);
+    }
+
+    FMT_CONSTEXPR auto make_arg_ref(auto_id) -> arg_ref_type
+    {
+        int arg_id = context_.next_arg_id();
+        context_.check_dynamic_spec(arg_id);
+        return arg_ref_type(arg_id);
+    }
+
+    FMT_CONSTEXPR auto make_arg_ref(basic_string_view<char_type> arg_id) -> arg_ref_type
+    {
+        context_.check_arg_id(arg_id);
+        basic_string_view<char_type> format_str(context_.begin(), to_unsigned(context_.end() - context_.begin()));
+        return arg_ref_type(arg_id);
+    }
+};
+
+template<typename Char>
+constexpr bool is_ascii_letter(Char c)
+{
+    return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z');
+}
+
+// Converts a character to ASCII. Returns a number > 127 on conversion failure.
+template<typename Char, FMT_ENABLE_IF(std::is_integral<Char>::value)>
+constexpr auto to_ascii(Char c) -> Char
+{
+    return c;
+}
+template<typename Char, FMT_ENABLE_IF(std::is_enum<Char>::value)>
+constexpr auto to_ascii(Char c) -> underlying_t<Char>
+{
+    return c;
+}
+
+FMT_CONSTEXPR inline auto code_point_length_impl(char c) -> int
+{
+    return "\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\0\0\0\0\0\0\0\0\2\2\2\2\3\3\4"[static_cast<unsigned char>(c) >> 3];
+}
+
+template<typename Char>
+FMT_CONSTEXPR auto code_point_length(const Char *begin) -> int
+{
+    if (const_check(sizeof(Char) != 1))
+        return 1;
+    int len = code_point_length_impl(static_cast<char>(*begin));
+
+    // Compute the pointer to the next character early so that the next
+    // iteration can start working on the next character. Neither Clang
+    // nor GCC figure out this reordering on their own.
+    return len + !len;
+}
+
+// Return the result via the out param to workaround gcc bug 77539.
+template<bool IS_CONSTEXPR, typename T, typename Ptr = const T *>
+FMT_CONSTEXPR auto find(Ptr first, Ptr last, T value, Ptr &out) -> bool
+{
+    for (out = first; out != last; ++out)
+    {
+        if (*out == value)
+            return true;
+    }
+    return false;
+}
+
+template<>
+inline auto find<false, char>(const char *first, const char *last, char value, const char *&out) -> bool
+{
+    out = static_cast<const char *>(std::memchr(first, value, to_unsigned(last - first)));
+    return out != nullptr;
+}
+
+// Parses the range [begin, end) as an unsigned integer. This function assumes
+// that the range is non-empty and the first character is a digit.
+template<typename Char>
+FMT_CONSTEXPR auto parse_nonnegative_int(const Char *&begin, const Char *end, int error_value) noexcept -> int
+{
+    FMT_ASSERT(begin != end && '0' <= *begin && *begin <= '9', "");
+    unsigned value = 0, prev = 0;
+    auto p = begin;
+    do
+    {
+        prev = value;
+        value = value * 10 + unsigned(*p - '0');
+        ++p;
+    } while (p != end && '0' <= *p && *p <= '9');
+    auto num_digits = p - begin;
+    begin = p;
+    if (num_digits <= std::numeric_limits<int>::digits10)
+        return static_cast<int>(value);
+    // Check for overflow.
+    const unsigned max = to_unsigned((std::numeric_limits<int>::max)());
+    return num_digits == std::numeric_limits<int>::digits10 + 1 && prev * 10ull + unsigned(p[-1] - '0') <= max ? static_cast<int>(value)
+                                                                                                               : error_value;
+}
+
+// Parses fill and alignment.
+template<typename Char, typename Handler>
+FMT_CONSTEXPR auto parse_align(const Char *begin, const Char *end, Handler &&handler) -> const Char *
+{
+    FMT_ASSERT(begin != end, "");
+    auto align = align::none;
+    auto p = begin + code_point_length(begin);
+    if (end - p <= 0)
+        p = begin;
+    for (;;)
+    {
+        switch (to_ascii(*p))
+        {
+        case '<':
+            align = align::left;
+            break;
+        case '>':
+            align = align::right;
+            break;
+        case '^':
+            align = align::center;
+            break;
+        default:
+            break;
+        }
+        if (align != align::none)
+        {
+            if (p != begin)
+            {
+                auto c = *begin;
+                if (c == '{')
+                    return handler.on_error("invalid fill character '{'"), begin;
+                handler.on_fill(basic_string_view<Char>(begin, to_unsigned(p - begin)));
+                begin = p + 1;
+            }
+            else
+                ++begin;
+            handler.on_align(align);
+            break;
+        }
+        else if (p == begin)
+        {
+            break;
+        }
+        p = begin;
+    }
+    return begin;
+}
+
+template<typename Char>
+FMT_CONSTEXPR bool is_name_start(Char c)
+{
+    return ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || '_' == c;
+}
+
+template<typename Char, typename IDHandler>
+FMT_CONSTEXPR auto do_parse_arg_id(const Char *begin, const Char *end, IDHandler &&handler) -> const Char *
+{
+    FMT_ASSERT(begin != end, "");
+    Char c = *begin;
+    if (c >= '0' && c <= '9')
+    {
+        int index = 0;
+        if (c != '0')
+            index = parse_nonnegative_int(begin, end, (std::numeric_limits<int>::max)());
+        else
+            ++begin;
+        if (begin == end || (*begin != '}' && *begin != ':'))
+            handler.on_error("invalid format string");
+        else
+            handler(index);
+        return begin;
+    }
+    if (!is_name_start(c))
+    {
+        handler.on_error("invalid format string");
+        return begin;
+    }
+    auto it = begin;
+    do
+    {
+        ++it;
+    } while (it != end && (is_name_start(c = *it) || ('0' <= c && c <= '9')));
+    handler(basic_string_view<Char>(begin, to_unsigned(it - begin)));
+    return it;
+}
+
+template<typename Char, typename IDHandler>
+FMT_CONSTEXPR FMT_INLINE auto parse_arg_id(const Char *begin, const Char *end, IDHandler &&handler) -> const Char *
+{
+    Char c = *begin;
+    if (c != '}' && c != ':')
+        return do_parse_arg_id(begin, end, handler);
+    handler();
+    return begin;
+}
+
+template<typename Char, typename Handler>
+FMT_CONSTEXPR auto parse_width(const Char *begin, const Char *end, Handler &&handler) -> const Char *
+{
+    using detail::auto_id;
+    struct width_adapter
+    {
+        Handler &handler;
+
+        FMT_CONSTEXPR void operator()()
+        {
+            handler.on_dynamic_width(auto_id());
+        }
+        FMT_CONSTEXPR void operator()(int id)
+        {
+            handler.on_dynamic_width(id);
+        }
+        FMT_CONSTEXPR void operator()(basic_string_view<Char> id)
+        {
+            handler.on_dynamic_width(id);
+        }
+        FMT_CONSTEXPR void on_error(const char *message)
+        {
+            if (message)
+                handler.on_error(message);
+        }
+    };
+
+    FMT_ASSERT(begin != end, "");
+    if ('0' <= *begin && *begin <= '9')
+    {
+        int width = parse_nonnegative_int(begin, end, -1);
+        if (width != -1)
+            handler.on_width(width);
+        else
+            handler.on_error("number is too big");
+    }
+    else if (*begin == '{')
+    {
+        ++begin;
+        if (begin != end)
+            begin = parse_arg_id(begin, end, width_adapter{handler});
+        if (begin == end || *begin != '}')
+            return handler.on_error("invalid format string"), begin;
+        ++begin;
+    }
+    return begin;
+}
+
+template<typename Char, typename Handler>
+FMT_CONSTEXPR auto parse_precision(const Char *begin, const Char *end, Handler &&handler) -> const Char *
+{
+    using detail::auto_id;
+    struct precision_adapter
+    {
+        Handler &handler;
+
+        FMT_CONSTEXPR void operator()()
+        {
+            handler.on_dynamic_precision(auto_id());
+        }
+        FMT_CONSTEXPR void operator()(int id)
+        {
+            handler.on_dynamic_precision(id);
+        }
+        FMT_CONSTEXPR void operator()(basic_string_view<Char> id)
+        {
+            handler.on_dynamic_precision(id);
+        }
+        FMT_CONSTEXPR void on_error(const char *message)
+        {
+            if (message)
+                handler.on_error(message);
+        }
+    };
+
+    ++begin;
+    auto c = begin != end ? *begin : Char();
+    if ('0' <= c && c <= '9')
+    {
+        auto precision = parse_nonnegative_int(begin, end, -1);
+        if (precision != -1)
+            handler.on_precision(precision);
+        else
+            handler.on_error("number is too big");
+    }
+    else if (c == '{')
+    {
+        ++begin;
+        if (begin != end)
+            begin = parse_arg_id(begin, end, precision_adapter{handler});
+        if (begin == end || *begin++ != '}')
+            return handler.on_error("invalid format string"), begin;
+    }
+    else
+    {
+        return handler.on_error("missing precision specifier"), begin;
+    }
+    handler.end_precision();
+    return begin;
+}
+
+template<typename Char>
+FMT_CONSTEXPR auto parse_presentation_type(Char type) -> presentation_type
+{
+    switch (to_ascii(type))
+    {
+    case 'd':
+        return presentation_type::dec;
+    case 'o':
+        return presentation_type::oct;
+    case 'x':
+        return presentation_type::hex_lower;
+    case 'X':
+        return presentation_type::hex_upper;
+    case 'b':
+        return presentation_type::bin_lower;
+    case 'B':
+        return presentation_type::bin_upper;
+    case 'a':
+        return presentation_type::hexfloat_lower;
+    case 'A':
+        return presentation_type::hexfloat_upper;
+    case 'e':
+        return presentation_type::exp_lower;
+    case 'E':
+        return presentation_type::exp_upper;
+    case 'f':
+        return presentation_type::fixed_lower;
+    case 'F':
+        return presentation_type::fixed_upper;
+    case 'g':
+        return presentation_type::general_lower;
+    case 'G':
+        return presentation_type::general_upper;
+    case 'c':
+        return presentation_type::chr;
+    case 's':
+        return presentation_type::string;
+    case 'p':
+        return presentation_type::pointer;
+    case '?':
+        return presentation_type::debug;
+    default:
+        return presentation_type::none;
+    }
+}
+
+// Parses standard format specifiers and sends notifications about parsed
+// components to handler.
+template<typename Char, typename SpecHandler>
+FMT_CONSTEXPR FMT_INLINE auto parse_format_specs(const Char *begin, const Char *end, SpecHandler &&handler) -> const Char *
+{
+    if (1 < end - begin && begin[1] == '}' && is_ascii_letter(*begin) && *begin != 'L')
+    {
+        presentation_type type = parse_presentation_type(*begin++);
+        if (type == presentation_type::none)
+            handler.on_error("invalid type specifier");
+        handler.on_type(type);
+        return begin;
+    }
+
+    if (begin == end)
+        return begin;
+
+    begin = parse_align(begin, end, handler);
+    if (begin == end)
+        return begin;
+
+    // Parse sign.
+    switch (to_ascii(*begin))
+    {
+    case '+':
+        handler.on_sign(sign::plus);
+        ++begin;
+        break;
+    case '-':
+        handler.on_sign(sign::minus);
+        ++begin;
+        break;
+    case ' ':
+        handler.on_sign(sign::space);
+        ++begin;
+        break;
+    default:
+        break;
+    }
+    if (begin == end)
+        return begin;
+
+    if (*begin == '#')
+    {
+        handler.on_hash();
+        if (++begin == end)
+            return begin;
+    }
+
+    // Parse zero flag.
+    if (*begin == '0')
+    {
+        handler.on_zero();
+        if (++begin == end)
+            return begin;
+    }
+
+    begin = parse_width(begin, end, handler);
+    if (begin == end)
+        return begin;
+
+    // Parse precision.
+    if (*begin == '.')
+    {
+        begin = parse_precision(begin, end, handler);
+        if (begin == end)
+            return begin;
+    }
+
+    if (*begin == 'L')
+    {
+        handler.on_localized();
+        ++begin;
+    }
+
+    // Parse type.
+    if (begin != end && *begin != '}')
+    {
+        presentation_type type = parse_presentation_type(*begin++);
+        if (type == presentation_type::none)
+            handler.on_error("invalid type specifier");
+        handler.on_type(type);
+    }
+    return begin;
+}
+
+template<typename Char, typename Handler>
+FMT_CONSTEXPR auto parse_replacement_field(const Char *begin, const Char *end, Handler &&handler) -> const Char *
+{
+    struct id_adapter
+    {
+        Handler &handler;
+        int arg_id;
+
+        FMT_CONSTEXPR void operator()()
+        {
+            arg_id = handler.on_arg_id();
+        }
+        FMT_CONSTEXPR void operator()(int id)
+        {
+            arg_id = handler.on_arg_id(id);
+        }
+        FMT_CONSTEXPR void operator()(basic_string_view<Char> id)
+        {
+            arg_id = handler.on_arg_id(id);
+        }
+        FMT_CONSTEXPR void on_error(const char *message)
+        {
+            if (message)
+                handler.on_error(message);
+        }
+    };
+
+    ++begin;
+    if (begin == end)
+        return handler.on_error("invalid format string"), end;
+    if (*begin == '}')
+    {
+        handler.on_replacement_field(handler.on_arg_id(), begin);
+    }
+    else if (*begin == '{')
+    {
+        handler.on_text(begin, begin + 1);
+    }
+    else
+    {
+        auto adapter = id_adapter{handler, 0};
+        begin = parse_arg_id(begin, end, adapter);
+        Char c = begin != end ? *begin : Char();
+        if (c == '}')
+        {
+            handler.on_replacement_field(adapter.arg_id, begin);
+        }
+        else if (c == ':')
+        {
+            begin = handler.on_format_specs(adapter.arg_id, begin + 1, end);
+            if (begin == end || *begin != '}')
+                return handler.on_error("unknown format specifier"), end;
+        }
+        else
+        {
+            return handler.on_error("missing '}' in format string"), end;
+        }
+    }
+    return begin + 1;
+}
+
+template<bool IS_CONSTEXPR, typename Char, typename Handler>
+FMT_CONSTEXPR FMT_INLINE void parse_format_string(basic_string_view<Char> format_str, Handler &&handler)
+{
+    // Workaround a name-lookup bug in MSVC's modules implementation.
+    using detail::find;
+
+    auto begin = format_str.data();
+    auto end = begin + format_str.size();
+    if (end - begin < 32)
+    {
+        // Use a simple loop instead of memchr for small strings.
+        const Char *p = begin;
+        while (p != end)
+        {
+            auto c = *p++;
+            if (c == '{')
+            {
+                handler.on_text(begin, p - 1);
+                begin = p = parse_replacement_field(p - 1, end, handler);
+            }
+            else if (c == '}')
+            {
+                if (p == end || *p != '}')
+                    return handler.on_error("unmatched '}' in format string");
+                handler.on_text(begin, p);
+                begin = ++p;
+            }
+        }
+        handler.on_text(begin, end);
+        return;
+    }
+    struct writer
+    {
+        FMT_CONSTEXPR void operator()(const Char *from, const Char *to)
+        {
+            if (from == to)
+                return;
+            for (;;)
+            {
+                const Char *p = nullptr;
+                if (!find<IS_CONSTEXPR>(from, to, Char('}'), p))
+                    return handler_.on_text(from, to);
+                ++p;
+                if (p == to || *p != '}')
+                    return handler_.on_error("unmatched '}' in format string");
+                handler_.on_text(from, p);
+                from = p + 1;
+            }
+        }
+        Handler &handler_;
+    } write = {handler};
+    while (begin != end)
+    {
+        // Doing two passes with memchr (one for '{' and another for '}') is up to
+        // 2.5x faster than the naive one-pass implementation on big format strings.
+        const Char *p = begin;
+        if (*begin != '{' && !find<IS_CONSTEXPR>(begin + 1, end, Char('{'), p))
+            return write(begin, end);
+        write(begin, p);
+        begin = parse_replacement_field(p, end, handler);
+    }
+}
+
+template<typename T, bool = is_named_arg<T>::value>
+struct strip_named_arg
+{
+    using type = T;
+};
+template<typename T>
+struct strip_named_arg<T, true>
+{
+    using type = remove_cvref_t<decltype(T::value)>;
+};
+
+template<typename T, typename ParseContext>
+FMT_CONSTEXPR auto parse_format_specs(ParseContext &ctx) -> decltype(ctx.begin())
+{
+    using char_type = typename ParseContext::char_type;
+    using context = buffer_context<char_type>;
+    using stripped_type = typename strip_named_arg<T>::type;
+    using mapped_type = conditional_t<mapped_type_constant<T, context>::value != type::custom_type,
+        decltype(arg_mapper<context>().map(std::declval<const T &>())), stripped_type>;
+    auto f = conditional_t<has_formatter<mapped_type, context>::value, formatter<mapped_type, char_type>,
+        fallback_formatter<stripped_type, char_type>>();
+    return f.parse(ctx);
+}
+
+template<typename ErrorHandler>
+FMT_CONSTEXPR void check_int_type_spec(presentation_type type, ErrorHandler &&eh)
+{
+    if (type > presentation_type::bin_upper && type != presentation_type::chr)
+        eh.on_error("invalid type specifier");
+}
+
+// Checks char specs and returns true if the type spec is char (and not int).
+template<typename Char, typename ErrorHandler = error_handler>
+FMT_CONSTEXPR auto check_char_specs(const basic_format_specs<Char> &specs, ErrorHandler &&eh = {}) -> bool
+{
+    if (specs.type != presentation_type::none && specs.type != presentation_type::chr && specs.type != presentation_type::debug)
+    {
+        check_int_type_spec(specs.type, eh);
+        return false;
+    }
+    if (specs.align == align::numeric || specs.sign != sign::none || specs.alt)
+        eh.on_error("invalid format specifier for char");
+    return true;
+}
+
+// A floating-point presentation format.
+enum class float_format : unsigned char
+{
+    general, // General: exponent notation or fixed point based on magnitude.
+    exp,     // Exponent notation with the default precision of 6, e.g. 1.2e-3.
+    fixed,   // Fixed point with the default precision of 6, e.g. 0.0012.
+    hex
+};
+
+struct float_specs
+{
+    int precision;
+    float_format format : 8;
+    sign_t sign : 8;
+    bool upper : 1;
+    bool locale : 1;
+    bool binary32 : 1;
+    bool showpoint : 1;
+};
+
+template<typename ErrorHandler = error_handler, typename Char>
+FMT_CONSTEXPR auto parse_float_type_spec(const basic_format_specs<Char> &specs, ErrorHandler &&eh = {}) -> float_specs
+{
+    auto result = float_specs();
+    result.showpoint = specs.alt;
+    result.locale = specs.localized;
+    switch (specs.type)
+    {
+    case presentation_type::none:
+        result.format = float_format::general;
+        break;
+    case presentation_type::general_upper:
+        result.upper = true;
+        FMT_FALLTHROUGH;
+    case presentation_type::general_lower:
+        result.format = float_format::general;
+        break;
+    case presentation_type::exp_upper:
+        result.upper = true;
+        FMT_FALLTHROUGH;
+    case presentation_type::exp_lower:
+        result.format = float_format::exp;
+        result.showpoint |= specs.precision != 0;
+        break;
+    case presentation_type::fixed_upper:
+        result.upper = true;
+        FMT_FALLTHROUGH;
+    case presentation_type::fixed_lower:
+        result.format = float_format::fixed;
+        result.showpoint |= specs.precision != 0;
+        break;
+    case presentation_type::hexfloat_upper:
+        result.upper = true;
+        FMT_FALLTHROUGH;
+    case presentation_type::hexfloat_lower:
+        result.format = float_format::hex;
+        break;
+    default:
+        eh.on_error("invalid type specifier");
+        break;
+    }
+    return result;
+}
+
+template<typename ErrorHandler = error_handler>
+FMT_CONSTEXPR auto check_cstring_type_spec(presentation_type type, ErrorHandler &&eh = {}) -> bool
+{
+    if (type == presentation_type::none || type == presentation_type::string || type == presentation_type::debug)
+        return true;
+    if (type != presentation_type::pointer)
+        eh.on_error("invalid type specifier");
+    return false;
+}
+
+template<typename ErrorHandler = error_handler>
+FMT_CONSTEXPR void check_string_type_spec(presentation_type type, ErrorHandler &&eh = {})
+{
+    if (type != presentation_type::none && type != presentation_type::string && type != presentation_type::debug)
+        eh.on_error("invalid type specifier");
+}
+
+template<typename ErrorHandler>
+FMT_CONSTEXPR void check_pointer_type_spec(presentation_type type, ErrorHandler &&eh)
+{
+    if (type != presentation_type::none && type != presentation_type::pointer)
+        eh.on_error("invalid type specifier");
+}
+
+// A parse_format_specs handler that checks if specifiers are consistent with
+// the argument type.
+template<typename Handler>
+class specs_checker : public Handler
+{
+private:
+    detail::type arg_type_;
+
+    FMT_CONSTEXPR void require_numeric_argument()
+    {
+        if (!is_arithmetic_type(arg_type_))
+            this->on_error("format specifier requires numeric argument");
+    }
+
+public:
+    FMT_CONSTEXPR specs_checker(const Handler &handler, detail::type arg_type)
+        : Handler(handler)
+        , arg_type_(arg_type)
+    {}
+
+    FMT_CONSTEXPR void on_align(align_t align)
+    {
+        if (align == align::numeric)
+            require_numeric_argument();
+        Handler::on_align(align);
+    }
+
+    FMT_CONSTEXPR void on_sign(sign_t s)
+    {
+        require_numeric_argument();
+        if (is_integral_type(arg_type_) && arg_type_ != type::int_type && arg_type_ != type::long_long_type &&
+            arg_type_ != type::int128_type && arg_type_ != type::char_type)
+        {
+            this->on_error("format specifier requires signed argument");
+        }
+        Handler::on_sign(s);
+    }
+
+    FMT_CONSTEXPR void on_hash()
+    {
+        require_numeric_argument();
+        Handler::on_hash();
+    }
+
+    FMT_CONSTEXPR void on_localized()
+    {
+        require_numeric_argument();
+        Handler::on_localized();
+    }
+
+    FMT_CONSTEXPR void on_zero()
+    {
+        require_numeric_argument();
+        Handler::on_zero();
+    }
+
+    FMT_CONSTEXPR void end_precision()
+    {
+        if (is_integral_type(arg_type_) || arg_type_ == type::pointer_type)
+            this->on_error("precision not allowed for this argument type");
+    }
+};
+
+constexpr int invalid_arg_index = -1;
+
+#if FMT_USE_NONTYPE_TEMPLATE_ARGS
+template<int N, typename T, typename... Args, typename Char>
+constexpr auto get_arg_index_by_name(basic_string_view<Char> name) -> int
+{
+    if constexpr (detail::is_statically_named_arg<T>())
+    {
+        if (name == T::name)
+            return N;
+    }
+    if constexpr (sizeof...(Args) > 0)
+        return get_arg_index_by_name<N + 1, Args...>(name);
+    (void)name; // Workaround an MSVC bug about "unused" parameter.
+    return invalid_arg_index;
+}
+#endif
+
+template<typename... Args, typename Char>
+FMT_CONSTEXPR auto get_arg_index_by_name(basic_string_view<Char> name) -> int
+{
+#if FMT_USE_NONTYPE_TEMPLATE_ARGS
+    if constexpr (sizeof...(Args) > 0)
+        return get_arg_index_by_name<0, Args...>(name);
+#endif
+    (void)name;
+    return invalid_arg_index;
+}
+
+template<typename Char, typename ErrorHandler, typename... Args>
+class format_string_checker
+{
+private:
+    // In the future basic_format_parse_context will replace compile_parse_context
+    // here and will use is_constant_evaluated and downcasting to access the data
+    // needed for compile-time checks: https://godbolt.org/z/GvWzcTjh1.
+    using parse_context_type = compile_parse_context<Char, ErrorHandler>;
+    static constexpr int num_args = sizeof...(Args);
+
+    // Format specifier parsing function.
+    using parse_func = const Char *(*)(parse_context_type &);
+
+    parse_context_type context_;
+    parse_func parse_funcs_[num_args > 0 ? static_cast<size_t>(num_args) : 1];
+    type types_[num_args > 0 ? static_cast<size_t>(num_args) : 1];
+
+public:
+    explicit FMT_CONSTEXPR format_string_checker(basic_string_view<Char> format_str, ErrorHandler eh)
+        : context_(format_str, num_args, types_, eh)
+        , parse_funcs_{&parse_format_specs<Args, parse_context_type>...}
+        , types_{mapped_type_constant<Args, basic_format_context<Char *, Char>>::value...}
+    {}
+
+    FMT_CONSTEXPR void on_text(const Char *, const Char *) {}
+
+    FMT_CONSTEXPR auto on_arg_id() -> int
+    {
+        return context_.next_arg_id();
+    }
+    FMT_CONSTEXPR auto on_arg_id(int id) -> int
+    {
+        return context_.check_arg_id(id), id;
+    }
+    FMT_CONSTEXPR auto on_arg_id(basic_string_view<Char> id) -> int
+    {
+#if FMT_USE_NONTYPE_TEMPLATE_ARGS
+        auto index = get_arg_index_by_name<Args...>(id);
+        if (index == invalid_arg_index)
+            on_error("named argument is not found");
+        return context_.check_arg_id(index), index;
+#else
+        (void)id;
+        on_error("compile-time checks for named arguments require C++20 support");
+        return 0;
+#endif
+    }
+
+    FMT_CONSTEXPR void on_replacement_field(int, const Char *) {}
+
+    FMT_CONSTEXPR auto on_format_specs(int id, const Char *begin, const Char *) -> const Char *
+    {
+        context_.advance_to(context_.begin() + (begin - &*context_.begin()));
+        // id >= 0 check is a workaround for gcc 10 bug (#2065).
+        return id >= 0 && id < num_args ? parse_funcs_[id](context_) : begin;
+    }
+
+    FMT_CONSTEXPR void on_error(const char *message)
+    {
+        context_.on_error(message);
+    }
+};
+
+// Reports a compile-time error if S is not a valid format string.
+template<typename..., typename S, FMT_ENABLE_IF(!is_compile_string<S>::value)>
+FMT_INLINE void check_format_string(const S &)
+{
+#ifdef FMT_ENFORCE_COMPILE_STRING
+    static_assert(is_compile_string<S>::value, "FMT_ENFORCE_COMPILE_STRING requires all format strings to use "
+                                               "FMT_STRING.");
+#endif
+}
+template<typename... Args, typename S, FMT_ENABLE_IF(is_compile_string<S>::value)>
+void check_format_string(S format_str)
+{
+    FMT_CONSTEXPR auto s = basic_string_view<typename S::char_type>(format_str);
+    using checker = format_string_checker<typename S::char_type, error_handler, remove_cvref_t<Args>...>;
+    FMT_CONSTEXPR bool invalid_format = (parse_format_string<true>(s, checker(s, {})), true);
+    ignore_unused(invalid_format);
+}
+
+template<typename Char>
+void vformat_to(
+    buffer<Char> &buf, basic_string_view<Char> fmt, basic_format_args<FMT_BUFFER_CONTEXT(type_identity_t<Char>)> args, locale_ref loc = {});
+
+FMT_API void vprint_mojibake(std::FILE *, string_view, format_args);
+#ifndef _WIN32
+inline void vprint_mojibake(std::FILE *, string_view, format_args) {}
+#endif
+FMT_END_DETAIL_NAMESPACE
+
+// A formatter specialization for the core types corresponding to detail::type
+// constants.
+template<typename T, typename Char>
+struct formatter<T, Char, enable_if_t<detail::type_constant<T, Char>::value != detail::type::custom_type>>
+{
+private:
+    detail::dynamic_format_specs<Char> specs_;
+
+public:
+    // Parses format specifiers stopping either at the end of the range or at the
+    // terminating '}'.
+    template<typename ParseContext>
+    FMT_CONSTEXPR auto parse(ParseContext &ctx) -> decltype(ctx.begin())
+    {
+        auto begin = ctx.begin(), end = ctx.end();
+        if (begin == end)
+            return begin;
+        using handler_type = detail::dynamic_specs_handler<ParseContext>;
+        auto type = detail::type_constant<T, Char>::value;
+        auto checker = detail::specs_checker<handler_type>(handler_type(specs_, ctx), type);
+        auto it = detail::parse_format_specs(begin, end, checker);
+        auto eh = ctx.error_handler();
+        switch (type)
+        {
+        case detail::type::none_type:
+            FMT_ASSERT(false, "invalid argument type");
+            break;
+        case detail::type::bool_type:
+            if (specs_.type == presentation_type::none || specs_.type == presentation_type::string)
+            {
+                break;
+            }
+            FMT_FALLTHROUGH;
+        case detail::type::int_type:
+        case detail::type::uint_type:
+        case detail::type::long_long_type:
+        case detail::type::ulong_long_type:
+        case detail::type::int128_type:
+        case detail::type::uint128_type:
+            detail::check_int_type_spec(specs_.type, eh);
+            break;
+        case detail::type::char_type:
+            detail::check_char_specs(specs_, eh);
+            break;
+        case detail::type::float_type:
+            if (detail::const_check(FMT_USE_FLOAT))
+                detail::parse_float_type_spec(specs_, eh);
+            else
+                FMT_ASSERT(false, "float support disabled");
+            break;
+        case detail::type::double_type:
+            if (detail::const_check(FMT_USE_DOUBLE))
+                detail::parse_float_type_spec(specs_, eh);
+            else
+                FMT_ASSERT(false, "double support disabled");
+            break;
+        case detail::type::long_double_type:
+            if (detail::const_check(FMT_USE_LONG_DOUBLE))
+                detail::parse_float_type_spec(specs_, eh);
+            else
+                FMT_ASSERT(false, "long double support disabled");
+            break;
+        case detail::type::cstring_type:
+            detail::check_cstring_type_spec(specs_.type, eh);
+            break;
+        case detail::type::string_type:
+            detail::check_string_type_spec(specs_.type, eh);
+            break;
+        case detail::type::pointer_type:
+            detail::check_pointer_type_spec(specs_.type, eh);
+            break;
+        case detail::type::custom_type:
+            // Custom format specifiers are checked in parse functions of
+            // formatter specializations.
+            break;
+        }
+        return it;
+    }
+
+    template<detail::type U = detail::type_constant<T, Char>::value,
+        enable_if_t<(U == detail::type::string_type || U == detail::type::cstring_type || U == detail::type::char_type), int> = 0>
+    FMT_CONSTEXPR void set_debug_format()
+    {
+        specs_.type = presentation_type::debug;
+    }
+
+    template<typename FormatContext>
+    FMT_CONSTEXPR auto format(const T &val, FormatContext &ctx) const -> decltype(ctx.out());
+};
+
+#define FMT_FORMAT_AS(Type, Base)                                                                                                          \
+    template<typename Char>                                                                                                                \
+    struct formatter<Type, Char> : formatter<Base, Char>                                                                                   \
+    {                                                                                                                                      \
+        template<typename FormatContext>                                                                                                   \
+        auto format(Type const &val, FormatContext &ctx) const -> decltype(ctx.out())                                                      \
+        {                                                                                                                                  \
+            return formatter<Base, Char>::format(static_cast<Base>(val), ctx);                                                             \
+        }                                                                                                                                  \
+    }
+
+FMT_FORMAT_AS(signed char, int);
+FMT_FORMAT_AS(unsigned char, unsigned);
+FMT_FORMAT_AS(short, int);
+FMT_FORMAT_AS(unsigned short, unsigned);
+FMT_FORMAT_AS(long, long long);
+FMT_FORMAT_AS(unsigned long, unsigned long long);
+FMT_FORMAT_AS(Char *, const Char *);
+FMT_FORMAT_AS(std::basic_string<Char>, basic_string_view<Char>);
+FMT_FORMAT_AS(std::nullptr_t, const void *);
+FMT_FORMAT_AS(detail::std_string_view<Char>, basic_string_view<Char>);
+
+template<typename Char>
+struct basic_runtime
+{
+    basic_string_view<Char> str;
+};
+
+/** A compile-time format string. */
+template<typename Char, typename... Args>
+class basic_format_string
+{
+private:
+    basic_string_view<Char> str_;
+
+public:
+    template<typename S, FMT_ENABLE_IF(std::is_convertible<const S &, basic_string_view<Char>>::value)>
+    FMT_CONSTEVAL FMT_INLINE basic_format_string(const S &s)
+        : str_(s)
+    {
+        static_assert(
+            detail::count<(std::is_base_of<detail::view, remove_reference_t<Args>>::value && std::is_reference<Args>::value)...>() == 0,
+            "passing views as lvalues is disallowed");
+#ifdef FMT_HAS_CONSTEVAL
+        if constexpr (detail::count_named_args<Args...>() == detail::count_statically_named_args<Args...>())
+        {
+            using checker = detail::format_string_checker<Char, detail::error_handler, remove_cvref_t<Args>...>;
+            detail::parse_format_string<true>(str_, checker(s, {}));
+        }
+#else
+        detail::check_format_string<Args...>(s);
+#endif
+    }
+    basic_format_string(basic_runtime<Char> r)
+        : str_(r.str)
+    {}
+
+    FMT_INLINE operator basic_string_view<Char>() const
+    {
+        return str_;
+    }
+};
+
+#if FMT_GCC_VERSION && FMT_GCC_VERSION < 409
+// Workaround broken conversion on older gcc.
+template<typename...>
+using format_string = string_view;
+inline auto runtime(string_view s) -> string_view
+{
+    return s;
+}
+#else
+template<typename... Args>
+using format_string = basic_format_string<char, type_identity_t<Args>...>;
+/**
+  \rst
+  Creates a runtime format string.
+
+  **Example**::
+
+    // Check format string at runtime instead of compile-time.
+    fmt::print(fmt::runtime("{:d}"), "I am not a number");
+  \endrst
+ */
+inline auto runtime(string_view s) -> basic_runtime<char>
+{
+    return {{s}};
+}
+#endif
+
+FMT_API auto vformat(string_view fmt, format_args args) -> std::string;
+
+/**
+  \rst
+  Formats ``args`` according to specifications in ``fmt`` and returns the result
+  as a string.
+
+  **Example**::
+
+    #include <fmt/core.h>
+    std::string message = fmt::format("The answer is {}.", 42);
+  \endrst
+*/
+template<typename... T>
+FMT_NODISCARD FMT_INLINE auto format(format_string<T...> fmt, T &&...args) -> std::string
+{
+    return vformat(fmt, fmt::make_format_args(args...));
+}
+
+/** Formats a string and writes the output to ``out``. */
+template<typename OutputIt, FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, char>::value)>
+auto vformat_to(OutputIt out, string_view fmt, format_args args) -> OutputIt
+{
+    using detail::get_buffer;
+    auto &&buf = get_buffer<char>(out);
+    detail::vformat_to(buf, fmt, args, {});
+    return detail::get_iterator(buf);
+}
+
+/**
+ \rst
+ Formats ``args`` according to specifications in ``fmt``, writes the result to
+ the output iterator ``out`` and returns the iterator past the end of the output
+ range. `format_to` does not append a terminating null character.
+
+ **Example**::
+
+   auto out = std::vector<char>();
+   fmt::format_to(std::back_inserter(out), "{}", 42);
+ \endrst
+ */
+template<typename OutputIt, typename... T, FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, char>::value)>
+FMT_INLINE auto format_to(OutputIt out, format_string<T...> fmt, T &&...args) -> OutputIt
+{
+    return vformat_to(out, fmt, fmt::make_format_args(args...));
+}
+
+template<typename OutputIt>
+struct format_to_n_result
+{
+    /** Iterator past the end of the output range. */
+    OutputIt out;
+    /** Total (not truncated) output size. */
+    size_t size;
+};
+
+template<typename OutputIt, typename... T, FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, char>::value)>
+auto vformat_to_n(OutputIt out, size_t n, string_view fmt, format_args args) -> format_to_n_result<OutputIt>
+{
+    using traits = detail::fixed_buffer_traits;
+    auto buf = detail::iterator_buffer<OutputIt, char, traits>(out, n);
+    detail::vformat_to(buf, fmt, args, {});
+    return {buf.out(), buf.count()};
+}
+
+/**
+  \rst
+  Formats ``args`` according to specifications in ``fmt``, writes up to ``n``
+  characters of the result to the output iterator ``out`` and returns the total
+  (not truncated) output size and the iterator past the end of the output range.
+  `format_to_n` does not append a terminating null character.
+  \endrst
+ */
+template<typename OutputIt, typename... T, FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, char>::value)>
+FMT_INLINE auto format_to_n(OutputIt out, size_t n, format_string<T...> fmt, T &&...args) -> format_to_n_result<OutputIt>
+{
+    return vformat_to_n(out, n, fmt, fmt::make_format_args(args...));
+}
+
+/** Returns the number of chars in the output of ``format(fmt, args...)``. */
+template<typename... T>
+FMT_NODISCARD FMT_INLINE auto formatted_size(format_string<T...> fmt, T &&...args) -> size_t
+{
+    auto buf = detail::counting_buffer<>();
+    detail::vformat_to(buf, string_view(fmt), fmt::make_format_args(args...), {});
+    return buf.count();
+}
+
+FMT_API void vprint(string_view fmt, format_args args);
+FMT_API void vprint(std::FILE *f, string_view fmt, format_args args);
+
+/**
+  \rst
+  Formats ``args`` according to specifications in ``fmt`` and writes the output
+  to ``stdout``.
+
+  **Example**::
+
+    fmt::print("Elapsed time: {0:.2f} seconds", 1.23);
+  \endrst
+ */
+template<typename... T>
+FMT_INLINE void print(format_string<T...> fmt, T &&...args)
+{
+    const auto &vargs = fmt::make_format_args(args...);
+    return detail::is_utf8() ? vprint(fmt, vargs) : detail::vprint_mojibake(stdout, fmt, vargs);
+}
+
+/**
+  \rst
+  Formats ``args`` according to specifications in ``fmt`` and writes the
+  output to the file ``f``.
+
+  **Example**::
+
+    fmt::print(stderr, "Don't {}!", "panic");
+  \endrst
+ */
+template<typename... T>
+FMT_INLINE void print(std::FILE *f, format_string<T...> fmt, T &&...args)
+{
+    const auto &vargs = fmt::make_format_args(args...);
+    return detail::is_utf8() ? vprint(f, fmt, vargs) : detail::vprint_mojibake(f, fmt, vargs);
+}
+
+FMT_MODULE_EXPORT_END
+FMT_GCC_PRAGMA("GCC pop_options")
+FMT_END_NAMESPACE
+
+#ifdef FMT_HEADER_ONLY
+#    include "format.h"
+#endif
+#endif // FMT_CORE_H_
diff --git a/3rdparty/spdlog/src/include/spdlog/fmt/bundled/fmt.license.rst b/3rdparty/spdlog/src/include/spdlog/fmt/bundled/fmt.license.rst
new file mode 100644
index 00000000..f0ec3db4
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/fmt/bundled/fmt.license.rst
@@ -0,0 +1,27 @@
+Copyright (c) 2012 - present, Victor Zverovich
+
+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.
+
+--- Optional exception to the license ---
+
+As an exception, if, as a result of your compiling your source code, portions
+of this Software are embedded into a machine-executable object form of such
+source code, you may redistribute such embedded portions in such object form
+without including the above copyright and permission notices.
diff --git a/3rdparty/spdlog/src/include/spdlog/fmt/bundled/format-inl.h b/3rdparty/spdlog/src/include/spdlog/fmt/bundled/format-inl.h
new file mode 100644
index 00000000..23d263bb
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/fmt/bundled/format-inl.h
@@ -0,0 +1,2928 @@
+// Formatting library for C++ - implementation
+//
+// Copyright (c) 2012 - 2016, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#ifndef FMT_FORMAT_INL_H_
+#define FMT_FORMAT_INL_H_
+
+#include <algorithm>
+#include <cctype>
+#include <cerrno> // errno
+#include <climits>
+#include <cmath>
+#include <cstdarg>
+#include <cstring> // std::memmove
+#include <cwchar>
+#include <exception>
+
+#ifndef FMT_STATIC_THOUSANDS_SEPARATOR
+#    include <locale>
+#endif
+
+#ifdef _WIN32
+#    include <io.h> // _isatty
+#endif
+
+#include "format.h"
+
+FMT_BEGIN_NAMESPACE
+namespace detail {
+
+FMT_FUNC void assert_fail(const char *file, int line, const char *message)
+{
+    // Use unchecked std::fprintf to avoid triggering another assertion when
+    // writing to stderr fails
+    std::fprintf(stderr, "%s:%d: assertion failed: %s", file, line, message);
+    // Chosen instead of std::abort to satisfy Clang in CUDA mode during device
+    // code pass.
+    std::terminate();
+}
+
+FMT_FUNC void throw_format_error(const char *message)
+{
+    FMT_THROW(format_error(message));
+}
+
+FMT_FUNC void format_error_code(detail::buffer<char> &out, int error_code, string_view message) noexcept
+{
+    // Report error code making sure that the output fits into
+    // inline_buffer_size to avoid dynamic memory allocation and potential
+    // bad_alloc.
+    out.try_resize(0);
+    static const char SEP[] = ": ";
+    static const char ERROR_STR[] = "error ";
+    // Subtract 2 to account for terminating null characters in SEP and ERROR_STR.
+    size_t error_code_size = sizeof(SEP) + sizeof(ERROR_STR) - 2;
+    auto abs_value = static_cast<uint32_or_64_or_128_t<int>>(error_code);
+    if (detail::is_negative(error_code))
+    {
+        abs_value = 0 - abs_value;
+        ++error_code_size;
+    }
+    error_code_size += detail::to_unsigned(detail::count_digits(abs_value));
+    auto it = buffer_appender<char>(out);
+    if (message.size() <= inline_buffer_size - error_code_size)
+        format_to(it, FMT_STRING("{}{}"), message, SEP);
+    format_to(it, FMT_STRING("{}{}"), ERROR_STR, error_code);
+    FMT_ASSERT(out.size() <= inline_buffer_size, "");
+}
+
+FMT_FUNC void report_error(format_func func, int error_code, const char *message) noexcept
+{
+    memory_buffer full_message;
+    func(full_message, error_code, message);
+    // Don't use fwrite_fully because the latter may throw.
+    if (std::fwrite(full_message.data(), full_message.size(), 1, stderr) > 0)
+        std::fputc('\n', stderr);
+}
+
+// A wrapper around fwrite that throws on error.
+inline void fwrite_fully(const void *ptr, size_t size, size_t count, FILE *stream)
+{
+    size_t written = std::fwrite(ptr, size, count, stream);
+    if (written < count)
+        FMT_THROW(system_error(errno, FMT_STRING("cannot write to file")));
+}
+
+#ifndef FMT_STATIC_THOUSANDS_SEPARATOR
+template<typename Locale>
+locale_ref::locale_ref(const Locale &loc)
+    : locale_(&loc)
+{
+    static_assert(std::is_same<Locale, std::locale>::value, "");
+}
+
+template<typename Locale>
+Locale locale_ref::get() const
+{
+    static_assert(std::is_same<Locale, std::locale>::value, "");
+    return locale_ ? *static_cast<const std::locale *>(locale_) : std::locale();
+}
+
+template<typename Char>
+FMT_FUNC auto thousands_sep_impl(locale_ref loc) -> thousands_sep_result<Char>
+{
+    auto &facet = std::use_facet<std::numpunct<Char>>(loc.get<std::locale>());
+    auto grouping = facet.grouping();
+    auto thousands_sep = grouping.empty() ? Char() : facet.thousands_sep();
+    return {std::move(grouping), thousands_sep};
+}
+template<typename Char>
+FMT_FUNC Char decimal_point_impl(locale_ref loc)
+{
+    return std::use_facet<std::numpunct<Char>>(loc.get<std::locale>()).decimal_point();
+}
+#else
+template<typename Char>
+FMT_FUNC auto thousands_sep_impl(locale_ref) -> thousands_sep_result<Char>
+{
+    return {"\03", FMT_STATIC_THOUSANDS_SEPARATOR};
+}
+template<typename Char>
+FMT_FUNC Char decimal_point_impl(locale_ref)
+{
+    return '.';
+}
+#endif
+} // namespace detail
+
+#if !FMT_MSC_VERSION
+FMT_API FMT_FUNC format_error::~format_error() noexcept = default;
+#endif
+
+FMT_FUNC std::system_error vsystem_error(int error_code, string_view format_str, format_args args)
+{
+    auto ec = std::error_code(error_code, std::generic_category());
+    return std::system_error(ec, vformat(format_str, args));
+}
+
+namespace detail {
+
+template<typename F>
+inline bool operator==(basic_fp<F> x, basic_fp<F> y)
+{
+    return x.f == y.f && x.e == y.e;
+}
+
+// Compilers should be able to optimize this into the ror instruction.
+FMT_CONSTEXPR inline uint32_t rotr(uint32_t n, uint32_t r) noexcept
+{
+    r &= 31;
+    return (n >> r) | (n << (32 - r));
+}
+FMT_CONSTEXPR inline uint64_t rotr(uint64_t n, uint32_t r) noexcept
+{
+    r &= 63;
+    return (n >> r) | (n << (64 - r));
+}
+
+// Computes 128-bit result of multiplication of two 64-bit unsigned integers.
+inline uint128_fallback umul128(uint64_t x, uint64_t y) noexcept
+{
+#if FMT_USE_INT128
+    auto p = static_cast<uint128_opt>(x) * static_cast<uint128_opt>(y);
+    return {static_cast<uint64_t>(p >> 64), static_cast<uint64_t>(p)};
+#elif defined(_MSC_VER) && defined(_M_X64)
+    auto result = uint128_fallback();
+    result.lo_ = _umul128(x, y, &result.hi_);
+    return result;
+#else
+    const uint64_t mask = static_cast<uint64_t>(max_value<uint32_t>());
+
+    uint64_t a = x >> 32;
+    uint64_t b = x & mask;
+    uint64_t c = y >> 32;
+    uint64_t d = y & mask;
+
+    uint64_t ac = a * c;
+    uint64_t bc = b * c;
+    uint64_t ad = a * d;
+    uint64_t bd = b * d;
+
+    uint64_t intermediate = (bd >> 32) + (ad & mask) + (bc & mask);
+
+    return {ac + (intermediate >> 32) + (ad >> 32) + (bc >> 32), (intermediate << 32) + (bd & mask)};
+#endif
+}
+
+// Implementation of Dragonbox algorithm: https://github.com/jk-jeon/dragonbox.
+namespace dragonbox {
+// Computes upper 64 bits of multiplication of two 64-bit unsigned integers.
+inline uint64_t umul128_upper64(uint64_t x, uint64_t y) noexcept
+{
+#if FMT_USE_INT128
+    auto p = static_cast<uint128_opt>(x) * static_cast<uint128_opt>(y);
+    return static_cast<uint64_t>(p >> 64);
+#elif defined(_MSC_VER) && defined(_M_X64)
+    return __umulh(x, y);
+#else
+    return umul128(x, y).high();
+#endif
+}
+
+// Computes upper 128 bits of multiplication of a 64-bit unsigned integer and a
+// 128-bit unsigned integer.
+inline uint128_fallback umul192_upper128(uint64_t x, uint128_fallback y) noexcept
+{
+    uint128_fallback r = umul128(x, y.high());
+    r += umul128_upper64(x, y.low());
+    return r;
+}
+
+// Computes upper 64 bits of multiplication of a 32-bit unsigned integer and a
+// 64-bit unsigned integer.
+inline uint64_t umul96_upper64(uint32_t x, uint64_t y) noexcept
+{
+    return umul128_upper64(static_cast<uint64_t>(x) << 32, y);
+}
+
+// Computes lower 128 bits of multiplication of a 64-bit unsigned integer and a
+// 128-bit unsigned integer.
+inline uint128_fallback umul192_lower128(uint64_t x, uint128_fallback y) noexcept
+{
+    uint64_t high = x * y.high();
+    uint128_fallback high_low = umul128(x, y.low());
+    return {high + high_low.high(), high_low.low()};
+}
+
+// Computes lower 64 bits of multiplication of a 32-bit unsigned integer and a
+// 64-bit unsigned integer.
+inline uint64_t umul96_lower64(uint32_t x, uint64_t y) noexcept
+{
+    return x * y;
+}
+
+// Computes floor(log10(pow(2, e))) for e in [-2620, 2620] using the method from
+// https://fmt.dev/papers/Dragonbox.pdf#page=28, section 6.1.
+inline int floor_log10_pow2(int e) noexcept
+{
+    FMT_ASSERT(e <= 2620 && e >= -2620, "too large exponent");
+    static_assert((-1 >> 1) == -1, "right shift is not arithmetic");
+    return (e * 315653) >> 20;
+}
+
+// Various fast log computations.
+inline int floor_log2_pow10(int e) noexcept
+{
+    FMT_ASSERT(e <= 1233 && e >= -1233, "too large exponent");
+    return (e * 1741647) >> 19;
+}
+inline int floor_log10_pow2_minus_log10_4_over_3(int e) noexcept
+{
+    FMT_ASSERT(e <= 2936 && e >= -2985, "too large exponent");
+    return (e * 631305 - 261663) >> 21;
+}
+
+static constexpr struct
+{
+    uint32_t divisor;
+    int shift_amount;
+} div_small_pow10_infos[] = {{10, 16}, {100, 16}};
+
+// Replaces n by floor(n / pow(10, N)) returning true if and only if n is
+// divisible by pow(10, N).
+// Precondition: n <= pow(10, N + 1).
+template<int N>
+bool check_divisibility_and_divide_by_pow10(uint32_t &n) noexcept
+{
+    // The numbers below are chosen such that:
+    //   1. floor(n/d) = floor(nm / 2^k) where d=10 or d=100,
+    //   2. nm mod 2^k < m if and only if n is divisible by d,
+    // where m is magic_number, k is shift_amount
+    // and d is divisor.
+    //
+    // Item 1 is a common technique of replacing division by a constant with
+    // multiplication, see e.g. "Division by Invariant Integers Using
+    // Multiplication" by Granlund and Montgomery (1994). magic_number (m) is set
+    // to ceil(2^k/d) for large enough k.
+    // The idea for item 2 originates from Schubfach.
+    constexpr auto info = div_small_pow10_infos[N - 1];
+    FMT_ASSERT(n <= info.divisor * 10, "n is too large");
+    constexpr uint32_t magic_number = (1u << info.shift_amount) / info.divisor + 1;
+    n *= magic_number;
+    const uint32_t comparison_mask = (1u << info.shift_amount) - 1;
+    bool result = (n & comparison_mask) < magic_number;
+    n >>= info.shift_amount;
+    return result;
+}
+
+// Computes floor(n / pow(10, N)) for small n and N.
+// Precondition: n <= pow(10, N + 1).
+template<int N>
+uint32_t small_division_by_pow10(uint32_t n) noexcept
+{
+    constexpr auto info = div_small_pow10_infos[N - 1];
+    FMT_ASSERT(n <= info.divisor * 10, "n is too large");
+    constexpr uint32_t magic_number = (1u << info.shift_amount) / info.divisor + 1;
+    return (n * magic_number) >> info.shift_amount;
+}
+
+// Computes floor(n / 10^(kappa + 1)) (float)
+inline uint32_t divide_by_10_to_kappa_plus_1(uint32_t n) noexcept
+{
+    // 1374389535 = ceil(2^37/100)
+    return static_cast<uint32_t>((static_cast<uint64_t>(n) * 1374389535) >> 37);
+}
+// Computes floor(n / 10^(kappa + 1)) (double)
+inline uint64_t divide_by_10_to_kappa_plus_1(uint64_t n) noexcept
+{
+    // 2361183241434822607 = ceil(2^(64+7)/1000)
+    return umul128_upper64(n, 2361183241434822607ull) >> 7;
+}
+
+// Various subroutines using pow10 cache
+template<class T>
+struct cache_accessor;
+
+template<>
+struct cache_accessor<float>
+{
+    using carrier_uint = float_info<float>::carrier_uint;
+    using cache_entry_type = uint64_t;
+
+    static uint64_t get_cached_power(int k) noexcept
+    {
+        FMT_ASSERT(k >= float_info<float>::min_k && k <= float_info<float>::max_k, "k is out of range");
+        static constexpr const uint64_t pow10_significands[] = {0x81ceb32c4b43fcf5, 0xa2425ff75e14fc32, 0xcad2f7f5359a3b3f,
+            0xfd87b5f28300ca0e, 0x9e74d1b791e07e49, 0xc612062576589ddb, 0xf79687aed3eec552, 0x9abe14cd44753b53, 0xc16d9a0095928a28,
+            0xf1c90080baf72cb2, 0x971da05074da7bef, 0xbce5086492111aeb, 0xec1e4a7db69561a6, 0x9392ee8e921d5d08, 0xb877aa3236a4b44a,
+            0xe69594bec44de15c, 0x901d7cf73ab0acda, 0xb424dc35095cd810, 0xe12e13424bb40e14, 0x8cbccc096f5088cc, 0xafebff0bcb24aaff,
+            0xdbe6fecebdedd5bf, 0x89705f4136b4a598, 0xabcc77118461cefd, 0xd6bf94d5e57a42bd, 0x8637bd05af6c69b6, 0xa7c5ac471b478424,
+            0xd1b71758e219652c, 0x83126e978d4fdf3c, 0xa3d70a3d70a3d70b, 0xcccccccccccccccd, 0x8000000000000000, 0xa000000000000000,
+            0xc800000000000000, 0xfa00000000000000, 0x9c40000000000000, 0xc350000000000000, 0xf424000000000000, 0x9896800000000000,
+            0xbebc200000000000, 0xee6b280000000000, 0x9502f90000000000, 0xba43b74000000000, 0xe8d4a51000000000, 0x9184e72a00000000,
+            0xb5e620f480000000, 0xe35fa931a0000000, 0x8e1bc9bf04000000, 0xb1a2bc2ec5000000, 0xde0b6b3a76400000, 0x8ac7230489e80000,
+            0xad78ebc5ac620000, 0xd8d726b7177a8000, 0x878678326eac9000, 0xa968163f0a57b400, 0xd3c21bcecceda100, 0x84595161401484a0,
+            0xa56fa5b99019a5c8, 0xcecb8f27f4200f3a, 0x813f3978f8940985, 0xa18f07d736b90be6, 0xc9f2c9cd04674edf, 0xfc6f7c4045812297,
+            0x9dc5ada82b70b59e, 0xc5371912364ce306, 0xf684df56c3e01bc7, 0x9a130b963a6c115d, 0xc097ce7bc90715b4, 0xf0bdc21abb48db21,
+            0x96769950b50d88f5, 0xbc143fa4e250eb32, 0xeb194f8e1ae525fe, 0x92efd1b8d0cf37bf, 0xb7abc627050305ae, 0xe596b7b0c643c71a,
+            0x8f7e32ce7bea5c70, 0xb35dbf821ae4f38c, 0xe0352f62a19e306f};
+        return pow10_significands[k - float_info<float>::min_k];
+    }
+
+    struct compute_mul_result
+    {
+        carrier_uint result;
+        bool is_integer;
+    };
+    struct compute_mul_parity_result
+    {
+        bool parity;
+        bool is_integer;
+    };
+
+    static compute_mul_result compute_mul(carrier_uint u, const cache_entry_type &cache) noexcept
+    {
+        auto r = umul96_upper64(u, cache);
+        return {static_cast<carrier_uint>(r >> 32), static_cast<carrier_uint>(r) == 0};
+    }
+
+    static uint32_t compute_delta(const cache_entry_type &cache, int beta) noexcept
+    {
+        return static_cast<uint32_t>(cache >> (64 - 1 - beta));
+    }
+
+    static compute_mul_parity_result compute_mul_parity(carrier_uint two_f, const cache_entry_type &cache, int beta) noexcept
+    {
+        FMT_ASSERT(beta >= 1, "");
+        FMT_ASSERT(beta < 64, "");
+
+        auto r = umul96_lower64(two_f, cache);
+        return {((r >> (64 - beta)) & 1) != 0, static_cast<uint32_t>(r >> (32 - beta)) == 0};
+    }
+
+    static carrier_uint compute_left_endpoint_for_shorter_interval_case(const cache_entry_type &cache, int beta) noexcept
+    {
+        return static_cast<carrier_uint>(
+            (cache - (cache >> (num_significand_bits<float>() + 2))) >> (64 - num_significand_bits<float>() - 1 - beta));
+    }
+
+    static carrier_uint compute_right_endpoint_for_shorter_interval_case(const cache_entry_type &cache, int beta) noexcept
+    {
+        return static_cast<carrier_uint>(
+            (cache + (cache >> (num_significand_bits<float>() + 1))) >> (64 - num_significand_bits<float>() - 1 - beta));
+    }
+
+    static carrier_uint compute_round_up_for_shorter_interval_case(const cache_entry_type &cache, int beta) noexcept
+    {
+        return (static_cast<carrier_uint>(cache >> (64 - num_significand_bits<float>() - 2 - beta)) + 1) / 2;
+    }
+};
+
+template<>
+struct cache_accessor<double>
+{
+    using carrier_uint = float_info<double>::carrier_uint;
+    using cache_entry_type = uint128_fallback;
+
+    static uint128_fallback get_cached_power(int k) noexcept
+    {
+        FMT_ASSERT(k >= float_info<double>::min_k && k <= float_info<double>::max_k, "k is out of range");
+
+        static constexpr const uint128_fallback pow10_significands[] = {
+#if FMT_USE_FULL_CACHE_DRAGONBOX
+            {0xff77b1fcbebcdc4f, 0x25e8e89c13bb0f7b},
+            {0x9faacf3df73609b1, 0x77b191618c54e9ad},
+            {0xc795830d75038c1d, 0xd59df5b9ef6a2418},
+            {0xf97ae3d0d2446f25, 0x4b0573286b44ad1e},
+            {0x9becce62836ac577, 0x4ee367f9430aec33},
+            {0xc2e801fb244576d5, 0x229c41f793cda740},
+            {0xf3a20279ed56d48a, 0x6b43527578c11110},
+            {0x9845418c345644d6, 0x830a13896b78aaaa},
+            {0xbe5691ef416bd60c, 0x23cc986bc656d554},
+            {0xedec366b11c6cb8f, 0x2cbfbe86b7ec8aa9},
+            {0x94b3a202eb1c3f39, 0x7bf7d71432f3d6aa},
+            {0xb9e08a83a5e34f07, 0xdaf5ccd93fb0cc54},
+            {0xe858ad248f5c22c9, 0xd1b3400f8f9cff69},
+            {0x91376c36d99995be, 0x23100809b9c21fa2},
+            {0xb58547448ffffb2d, 0xabd40a0c2832a78b},
+            {0xe2e69915b3fff9f9, 0x16c90c8f323f516d},
+            {0x8dd01fad907ffc3b, 0xae3da7d97f6792e4},
+            {0xb1442798f49ffb4a, 0x99cd11cfdf41779d},
+            {0xdd95317f31c7fa1d, 0x40405643d711d584},
+            {0x8a7d3eef7f1cfc52, 0x482835ea666b2573},
+            {0xad1c8eab5ee43b66, 0xda3243650005eed0},
+            {0xd863b256369d4a40, 0x90bed43e40076a83},
+            {0x873e4f75e2224e68, 0x5a7744a6e804a292},
+            {0xa90de3535aaae202, 0x711515d0a205cb37},
+            {0xd3515c2831559a83, 0x0d5a5b44ca873e04},
+            {0x8412d9991ed58091, 0xe858790afe9486c3},
+            {0xa5178fff668ae0b6, 0x626e974dbe39a873},
+            {0xce5d73ff402d98e3, 0xfb0a3d212dc81290},
+            {0x80fa687f881c7f8e, 0x7ce66634bc9d0b9a},
+            {0xa139029f6a239f72, 0x1c1fffc1ebc44e81},
+            {0xc987434744ac874e, 0xa327ffb266b56221},
+            {0xfbe9141915d7a922, 0x4bf1ff9f0062baa9},
+            {0x9d71ac8fada6c9b5, 0x6f773fc3603db4aa},
+            {0xc4ce17b399107c22, 0xcb550fb4384d21d4},
+            {0xf6019da07f549b2b, 0x7e2a53a146606a49},
+            {0x99c102844f94e0fb, 0x2eda7444cbfc426e},
+            {0xc0314325637a1939, 0xfa911155fefb5309},
+            {0xf03d93eebc589f88, 0x793555ab7eba27cb},
+            {0x96267c7535b763b5, 0x4bc1558b2f3458df},
+            {0xbbb01b9283253ca2, 0x9eb1aaedfb016f17},
+            {0xea9c227723ee8bcb, 0x465e15a979c1cadd},
+            {0x92a1958a7675175f, 0x0bfacd89ec191eca},
+            {0xb749faed14125d36, 0xcef980ec671f667c},
+            {0xe51c79a85916f484, 0x82b7e12780e7401b},
+            {0x8f31cc0937ae58d2, 0xd1b2ecb8b0908811},
+            {0xb2fe3f0b8599ef07, 0x861fa7e6dcb4aa16},
+            {0xdfbdcece67006ac9, 0x67a791e093e1d49b},
+            {0x8bd6a141006042bd, 0xe0c8bb2c5c6d24e1},
+            {0xaecc49914078536d, 0x58fae9f773886e19},
+            {0xda7f5bf590966848, 0xaf39a475506a899f},
+            {0x888f99797a5e012d, 0x6d8406c952429604},
+            {0xaab37fd7d8f58178, 0xc8e5087ba6d33b84},
+            {0xd5605fcdcf32e1d6, 0xfb1e4a9a90880a65},
+            {0x855c3be0a17fcd26, 0x5cf2eea09a550680},
+            {0xa6b34ad8c9dfc06f, 0xf42faa48c0ea481f},
+            {0xd0601d8efc57b08b, 0xf13b94daf124da27},
+            {0x823c12795db6ce57, 0x76c53d08d6b70859},
+            {0xa2cb1717b52481ed, 0x54768c4b0c64ca6f},
+            {0xcb7ddcdda26da268, 0xa9942f5dcf7dfd0a},
+            {0xfe5d54150b090b02, 0xd3f93b35435d7c4d},
+            {0x9efa548d26e5a6e1, 0xc47bc5014a1a6db0},
+            {0xc6b8e9b0709f109a, 0x359ab6419ca1091c},
+            {0xf867241c8cc6d4c0, 0xc30163d203c94b63},
+            {0x9b407691d7fc44f8, 0x79e0de63425dcf1e},
+            {0xc21094364dfb5636, 0x985915fc12f542e5},
+            {0xf294b943e17a2bc4, 0x3e6f5b7b17b2939e},
+            {0x979cf3ca6cec5b5a, 0xa705992ceecf9c43},
+            {0xbd8430bd08277231, 0x50c6ff782a838354},
+            {0xece53cec4a314ebd, 0xa4f8bf5635246429},
+            {0x940f4613ae5ed136, 0x871b7795e136be9a},
+            {0xb913179899f68584, 0x28e2557b59846e40},
+            {0xe757dd7ec07426e5, 0x331aeada2fe589d0},
+            {0x9096ea6f3848984f, 0x3ff0d2c85def7622},
+            {0xb4bca50b065abe63, 0x0fed077a756b53aa},
+            {0xe1ebce4dc7f16dfb, 0xd3e8495912c62895},
+            {0x8d3360f09cf6e4bd, 0x64712dd7abbbd95d},
+            {0xb080392cc4349dec, 0xbd8d794d96aacfb4},
+            {0xdca04777f541c567, 0xecf0d7a0fc5583a1},
+            {0x89e42caaf9491b60, 0xf41686c49db57245},
+            {0xac5d37d5b79b6239, 0x311c2875c522ced6},
+            {0xd77485cb25823ac7, 0x7d633293366b828c},
+            {0x86a8d39ef77164bc, 0xae5dff9c02033198},
+            {0xa8530886b54dbdeb, 0xd9f57f830283fdfd},
+            {0xd267caa862a12d66, 0xd072df63c324fd7c},
+            {0x8380dea93da4bc60, 0x4247cb9e59f71e6e},
+            {0xa46116538d0deb78, 0x52d9be85f074e609},
+            {0xcd795be870516656, 0x67902e276c921f8c},
+            {0x806bd9714632dff6, 0x00ba1cd8a3db53b7},
+            {0xa086cfcd97bf97f3, 0x80e8a40eccd228a5},
+            {0xc8a883c0fdaf7df0, 0x6122cd128006b2ce},
+            {0xfad2a4b13d1b5d6c, 0x796b805720085f82},
+            {0x9cc3a6eec6311a63, 0xcbe3303674053bb1},
+            {0xc3f490aa77bd60fc, 0xbedbfc4411068a9d},
+            {0xf4f1b4d515acb93b, 0xee92fb5515482d45},
+            {0x991711052d8bf3c5, 0x751bdd152d4d1c4b},
+            {0xbf5cd54678eef0b6, 0xd262d45a78a0635e},
+            {0xef340a98172aace4, 0x86fb897116c87c35},
+            {0x9580869f0e7aac0e, 0xd45d35e6ae3d4da1},
+            {0xbae0a846d2195712, 0x8974836059cca10a},
+            {0xe998d258869facd7, 0x2bd1a438703fc94c},
+            {0x91ff83775423cc06, 0x7b6306a34627ddd0},
+            {0xb67f6455292cbf08, 0x1a3bc84c17b1d543},
+            {0xe41f3d6a7377eeca, 0x20caba5f1d9e4a94},
+            {0x8e938662882af53e, 0x547eb47b7282ee9d},
+            {0xb23867fb2a35b28d, 0xe99e619a4f23aa44},
+            {0xdec681f9f4c31f31, 0x6405fa00e2ec94d5},
+            {0x8b3c113c38f9f37e, 0xde83bc408dd3dd05},
+            {0xae0b158b4738705e, 0x9624ab50b148d446},
+            {0xd98ddaee19068c76, 0x3badd624dd9b0958},
+            {0x87f8a8d4cfa417c9, 0xe54ca5d70a80e5d7},
+            {0xa9f6d30a038d1dbc, 0x5e9fcf4ccd211f4d},
+            {0xd47487cc8470652b, 0x7647c32000696720},
+            {0x84c8d4dfd2c63f3b, 0x29ecd9f40041e074},
+            {0xa5fb0a17c777cf09, 0xf468107100525891},
+            {0xcf79cc9db955c2cc, 0x7182148d4066eeb5},
+            {0x81ac1fe293d599bf, 0xc6f14cd848405531},
+            {0xa21727db38cb002f, 0xb8ada00e5a506a7d},
+            {0xca9cf1d206fdc03b, 0xa6d90811f0e4851d},
+            {0xfd442e4688bd304a, 0x908f4a166d1da664},
+            {0x9e4a9cec15763e2e, 0x9a598e4e043287ff},
+            {0xc5dd44271ad3cdba, 0x40eff1e1853f29fe},
+            {0xf7549530e188c128, 0xd12bee59e68ef47d},
+            {0x9a94dd3e8cf578b9, 0x82bb74f8301958cf},
+            {0xc13a148e3032d6e7, 0xe36a52363c1faf02},
+            {0xf18899b1bc3f8ca1, 0xdc44e6c3cb279ac2},
+            {0x96f5600f15a7b7e5, 0x29ab103a5ef8c0ba},
+            {0xbcb2b812db11a5de, 0x7415d448f6b6f0e8},
+            {0xebdf661791d60f56, 0x111b495b3464ad22},
+            {0x936b9fcebb25c995, 0xcab10dd900beec35},
+            {0xb84687c269ef3bfb, 0x3d5d514f40eea743},
+            {0xe65829b3046b0afa, 0x0cb4a5a3112a5113},
+            {0x8ff71a0fe2c2e6dc, 0x47f0e785eaba72ac},
+            {0xb3f4e093db73a093, 0x59ed216765690f57},
+            {0xe0f218b8d25088b8, 0x306869c13ec3532d},
+            {0x8c974f7383725573, 0x1e414218c73a13fc},
+            {0xafbd2350644eeacf, 0xe5d1929ef90898fb},
+            {0xdbac6c247d62a583, 0xdf45f746b74abf3a},
+            {0x894bc396ce5da772, 0x6b8bba8c328eb784},
+            {0xab9eb47c81f5114f, 0x066ea92f3f326565},
+            {0xd686619ba27255a2, 0xc80a537b0efefebe},
+            {0x8613fd0145877585, 0xbd06742ce95f5f37},
+            {0xa798fc4196e952e7, 0x2c48113823b73705},
+            {0xd17f3b51fca3a7a0, 0xf75a15862ca504c6},
+            {0x82ef85133de648c4, 0x9a984d73dbe722fc},
+            {0xa3ab66580d5fdaf5, 0xc13e60d0d2e0ebbb},
+            {0xcc963fee10b7d1b3, 0x318df905079926a9},
+            {0xffbbcfe994e5c61f, 0xfdf17746497f7053},
+            {0x9fd561f1fd0f9bd3, 0xfeb6ea8bedefa634},
+            {0xc7caba6e7c5382c8, 0xfe64a52ee96b8fc1},
+            {0xf9bd690a1b68637b, 0x3dfdce7aa3c673b1},
+            {0x9c1661a651213e2d, 0x06bea10ca65c084f},
+            {0xc31bfa0fe5698db8, 0x486e494fcff30a63},
+            {0xf3e2f893dec3f126, 0x5a89dba3c3efccfb},
+            {0x986ddb5c6b3a76b7, 0xf89629465a75e01d},
+            {0xbe89523386091465, 0xf6bbb397f1135824},
+            {0xee2ba6c0678b597f, 0x746aa07ded582e2d},
+            {0x94db483840b717ef, 0xa8c2a44eb4571cdd},
+            {0xba121a4650e4ddeb, 0x92f34d62616ce414},
+            {0xe896a0d7e51e1566, 0x77b020baf9c81d18},
+            {0x915e2486ef32cd60, 0x0ace1474dc1d122f},
+            {0xb5b5ada8aaff80b8, 0x0d819992132456bb},
+            {0xe3231912d5bf60e6, 0x10e1fff697ed6c6a},
+            {0x8df5efabc5979c8f, 0xca8d3ffa1ef463c2},
+            {0xb1736b96b6fd83b3, 0xbd308ff8a6b17cb3},
+            {0xddd0467c64bce4a0, 0xac7cb3f6d05ddbdf},
+            {0x8aa22c0dbef60ee4, 0x6bcdf07a423aa96c},
+            {0xad4ab7112eb3929d, 0x86c16c98d2c953c7},
+            {0xd89d64d57a607744, 0xe871c7bf077ba8b8},
+            {0x87625f056c7c4a8b, 0x11471cd764ad4973},
+            {0xa93af6c6c79b5d2d, 0xd598e40d3dd89bd0},
+            {0xd389b47879823479, 0x4aff1d108d4ec2c4},
+            {0x843610cb4bf160cb, 0xcedf722a585139bb},
+            {0xa54394fe1eedb8fe, 0xc2974eb4ee658829},
+            {0xce947a3da6a9273e, 0x733d226229feea33},
+            {0x811ccc668829b887, 0x0806357d5a3f5260},
+            {0xa163ff802a3426a8, 0xca07c2dcb0cf26f8},
+            {0xc9bcff6034c13052, 0xfc89b393dd02f0b6},
+            {0xfc2c3f3841f17c67, 0xbbac2078d443ace3},
+            {0x9d9ba7832936edc0, 0xd54b944b84aa4c0e},
+            {0xc5029163f384a931, 0x0a9e795e65d4df12},
+            {0xf64335bcf065d37d, 0x4d4617b5ff4a16d6},
+            {0x99ea0196163fa42e, 0x504bced1bf8e4e46},
+            {0xc06481fb9bcf8d39, 0xe45ec2862f71e1d7},
+            {0xf07da27a82c37088, 0x5d767327bb4e5a4d},
+            {0x964e858c91ba2655, 0x3a6a07f8d510f870},
+            {0xbbe226efb628afea, 0x890489f70a55368c},
+            {0xeadab0aba3b2dbe5, 0x2b45ac74ccea842f},
+            {0x92c8ae6b464fc96f, 0x3b0b8bc90012929e},
+            {0xb77ada0617e3bbcb, 0x09ce6ebb40173745},
+            {0xe55990879ddcaabd, 0xcc420a6a101d0516},
+            {0x8f57fa54c2a9eab6, 0x9fa946824a12232e},
+            {0xb32df8e9f3546564, 0x47939822dc96abfa},
+            {0xdff9772470297ebd, 0x59787e2b93bc56f8},
+            {0x8bfbea76c619ef36, 0x57eb4edb3c55b65b},
+            {0xaefae51477a06b03, 0xede622920b6b23f2},
+            {0xdab99e59958885c4, 0xe95fab368e45ecee},
+            {0x88b402f7fd75539b, 0x11dbcb0218ebb415},
+            {0xaae103b5fcd2a881, 0xd652bdc29f26a11a},
+            {0xd59944a37c0752a2, 0x4be76d3346f04960},
+            {0x857fcae62d8493a5, 0x6f70a4400c562ddc},
+            {0xa6dfbd9fb8e5b88e, 0xcb4ccd500f6bb953},
+            {0xd097ad07a71f26b2, 0x7e2000a41346a7a8},
+            {0x825ecc24c873782f, 0x8ed400668c0c28c9},
+            {0xa2f67f2dfa90563b, 0x728900802f0f32fb},
+            {0xcbb41ef979346bca, 0x4f2b40a03ad2ffba},
+            {0xfea126b7d78186bc, 0xe2f610c84987bfa9},
+            {0x9f24b832e6b0f436, 0x0dd9ca7d2df4d7ca},
+            {0xc6ede63fa05d3143, 0x91503d1c79720dbc},
+            {0xf8a95fcf88747d94, 0x75a44c6397ce912b},
+            {0x9b69dbe1b548ce7c, 0xc986afbe3ee11abb},
+            {0xc24452da229b021b, 0xfbe85badce996169},
+            {0xf2d56790ab41c2a2, 0xfae27299423fb9c4},
+            {0x97c560ba6b0919a5, 0xdccd879fc967d41b},
+            {0xbdb6b8e905cb600f, 0x5400e987bbc1c921},
+            {0xed246723473e3813, 0x290123e9aab23b69},
+            {0x9436c0760c86e30b, 0xf9a0b6720aaf6522},
+            {0xb94470938fa89bce, 0xf808e40e8d5b3e6a},
+            {0xe7958cb87392c2c2, 0xb60b1d1230b20e05},
+            {0x90bd77f3483bb9b9, 0xb1c6f22b5e6f48c3},
+            {0xb4ecd5f01a4aa828, 0x1e38aeb6360b1af4},
+            {0xe2280b6c20dd5232, 0x25c6da63c38de1b1},
+            {0x8d590723948a535f, 0x579c487e5a38ad0f},
+            {0xb0af48ec79ace837, 0x2d835a9df0c6d852},
+            {0xdcdb1b2798182244, 0xf8e431456cf88e66},
+            {0x8a08f0f8bf0f156b, 0x1b8e9ecb641b5900},
+            {0xac8b2d36eed2dac5, 0xe272467e3d222f40},
+            {0xd7adf884aa879177, 0x5b0ed81dcc6abb10},
+            {0x86ccbb52ea94baea, 0x98e947129fc2b4ea},
+            {0xa87fea27a539e9a5, 0x3f2398d747b36225},
+            {0xd29fe4b18e88640e, 0x8eec7f0d19a03aae},
+            {0x83a3eeeef9153e89, 0x1953cf68300424ad},
+            {0xa48ceaaab75a8e2b, 0x5fa8c3423c052dd8},
+            {0xcdb02555653131b6, 0x3792f412cb06794e},
+            {0x808e17555f3ebf11, 0xe2bbd88bbee40bd1},
+            {0xa0b19d2ab70e6ed6, 0x5b6aceaeae9d0ec5},
+            {0xc8de047564d20a8b, 0xf245825a5a445276},
+            {0xfb158592be068d2e, 0xeed6e2f0f0d56713},
+            {0x9ced737bb6c4183d, 0x55464dd69685606c},
+            {0xc428d05aa4751e4c, 0xaa97e14c3c26b887},
+            {0xf53304714d9265df, 0xd53dd99f4b3066a9},
+            {0x993fe2c6d07b7fab, 0xe546a8038efe402a},
+            {0xbf8fdb78849a5f96, 0xde98520472bdd034},
+            {0xef73d256a5c0f77c, 0x963e66858f6d4441},
+            {0x95a8637627989aad, 0xdde7001379a44aa9},
+            {0xbb127c53b17ec159, 0x5560c018580d5d53},
+            {0xe9d71b689dde71af, 0xaab8f01e6e10b4a7},
+            {0x9226712162ab070d, 0xcab3961304ca70e9},
+            {0xb6b00d69bb55c8d1, 0x3d607b97c5fd0d23},
+            {0xe45c10c42a2b3b05, 0x8cb89a7db77c506b},
+            {0x8eb98a7a9a5b04e3, 0x77f3608e92adb243},
+            {0xb267ed1940f1c61c, 0x55f038b237591ed4},
+            {0xdf01e85f912e37a3, 0x6b6c46dec52f6689},
+            {0x8b61313bbabce2c6, 0x2323ac4b3b3da016},
+            {0xae397d8aa96c1b77, 0xabec975e0a0d081b},
+            {0xd9c7dced53c72255, 0x96e7bd358c904a22},
+            {0x881cea14545c7575, 0x7e50d64177da2e55},
+            {0xaa242499697392d2, 0xdde50bd1d5d0b9ea},
+            {0xd4ad2dbfc3d07787, 0x955e4ec64b44e865},
+            {0x84ec3c97da624ab4, 0xbd5af13bef0b113f},
+            {0xa6274bbdd0fadd61, 0xecb1ad8aeacdd58f},
+            {0xcfb11ead453994ba, 0x67de18eda5814af3},
+            {0x81ceb32c4b43fcf4, 0x80eacf948770ced8},
+            {0xa2425ff75e14fc31, 0xa1258379a94d028e},
+            {0xcad2f7f5359a3b3e, 0x096ee45813a04331},
+            {0xfd87b5f28300ca0d, 0x8bca9d6e188853fd},
+            {0x9e74d1b791e07e48, 0x775ea264cf55347e},
+            {0xc612062576589dda, 0x95364afe032a819e},
+            {0xf79687aed3eec551, 0x3a83ddbd83f52205},
+            {0x9abe14cd44753b52, 0xc4926a9672793543},
+            {0xc16d9a0095928a27, 0x75b7053c0f178294},
+            {0xf1c90080baf72cb1, 0x5324c68b12dd6339},
+            {0x971da05074da7bee, 0xd3f6fc16ebca5e04},
+            {0xbce5086492111aea, 0x88f4bb1ca6bcf585},
+            {0xec1e4a7db69561a5, 0x2b31e9e3d06c32e6},
+            {0x9392ee8e921d5d07, 0x3aff322e62439fd0},
+            {0xb877aa3236a4b449, 0x09befeb9fad487c3},
+            {0xe69594bec44de15b, 0x4c2ebe687989a9b4},
+            {0x901d7cf73ab0acd9, 0x0f9d37014bf60a11},
+            {0xb424dc35095cd80f, 0x538484c19ef38c95},
+            {0xe12e13424bb40e13, 0x2865a5f206b06fba},
+            {0x8cbccc096f5088cb, 0xf93f87b7442e45d4},
+            {0xafebff0bcb24aafe, 0xf78f69a51539d749},
+            {0xdbe6fecebdedd5be, 0xb573440e5a884d1c},
+            {0x89705f4136b4a597, 0x31680a88f8953031},
+            {0xabcc77118461cefc, 0xfdc20d2b36ba7c3e},
+            {0xd6bf94d5e57a42bc, 0x3d32907604691b4d},
+            {0x8637bd05af6c69b5, 0xa63f9a49c2c1b110},
+            {0xa7c5ac471b478423, 0x0fcf80dc33721d54},
+            {0xd1b71758e219652b, 0xd3c36113404ea4a9},
+            {0x83126e978d4fdf3b, 0x645a1cac083126ea},
+            {0xa3d70a3d70a3d70a, 0x3d70a3d70a3d70a4},
+            {0xcccccccccccccccc, 0xcccccccccccccccd},
+            {0x8000000000000000, 0x0000000000000000},
+            {0xa000000000000000, 0x0000000000000000},
+            {0xc800000000000000, 0x0000000000000000},
+            {0xfa00000000000000, 0x0000000000000000},
+            {0x9c40000000000000, 0x0000000000000000},
+            {0xc350000000000000, 0x0000000000000000},
+            {0xf424000000000000, 0x0000000000000000},
+            {0x9896800000000000, 0x0000000000000000},
+            {0xbebc200000000000, 0x0000000000000000},
+            {0xee6b280000000000, 0x0000000000000000},
+            {0x9502f90000000000, 0x0000000000000000},
+            {0xba43b74000000000, 0x0000000000000000},
+            {0xe8d4a51000000000, 0x0000000000000000},
+            {0x9184e72a00000000, 0x0000000000000000},
+            {0xb5e620f480000000, 0x0000000000000000},
+            {0xe35fa931a0000000, 0x0000000000000000},
+            {0x8e1bc9bf04000000, 0x0000000000000000},
+            {0xb1a2bc2ec5000000, 0x0000000000000000},
+            {0xde0b6b3a76400000, 0x0000000000000000},
+            {0x8ac7230489e80000, 0x0000000000000000},
+            {0xad78ebc5ac620000, 0x0000000000000000},
+            {0xd8d726b7177a8000, 0x0000000000000000},
+            {0x878678326eac9000, 0x0000000000000000},
+            {0xa968163f0a57b400, 0x0000000000000000},
+            {0xd3c21bcecceda100, 0x0000000000000000},
+            {0x84595161401484a0, 0x0000000000000000},
+            {0xa56fa5b99019a5c8, 0x0000000000000000},
+            {0xcecb8f27f4200f3a, 0x0000000000000000},
+            {0x813f3978f8940984, 0x4000000000000000},
+            {0xa18f07d736b90be5, 0x5000000000000000},
+            {0xc9f2c9cd04674ede, 0xa400000000000000},
+            {0xfc6f7c4045812296, 0x4d00000000000000},
+            {0x9dc5ada82b70b59d, 0xf020000000000000},
+            {0xc5371912364ce305, 0x6c28000000000000},
+            {0xf684df56c3e01bc6, 0xc732000000000000},
+            {0x9a130b963a6c115c, 0x3c7f400000000000},
+            {0xc097ce7bc90715b3, 0x4b9f100000000000},
+            {0xf0bdc21abb48db20, 0x1e86d40000000000},
+            {0x96769950b50d88f4, 0x1314448000000000},
+            {0xbc143fa4e250eb31, 0x17d955a000000000},
+            {0xeb194f8e1ae525fd, 0x5dcfab0800000000},
+            {0x92efd1b8d0cf37be, 0x5aa1cae500000000},
+            {0xb7abc627050305ad, 0xf14a3d9e40000000},
+            {0xe596b7b0c643c719, 0x6d9ccd05d0000000},
+            {0x8f7e32ce7bea5c6f, 0xe4820023a2000000},
+            {0xb35dbf821ae4f38b, 0xdda2802c8a800000},
+            {0xe0352f62a19e306e, 0xd50b2037ad200000},
+            {0x8c213d9da502de45, 0x4526f422cc340000},
+            {0xaf298d050e4395d6, 0x9670b12b7f410000},
+            {0xdaf3f04651d47b4c, 0x3c0cdd765f114000},
+            {0x88d8762bf324cd0f, 0xa5880a69fb6ac800},
+            {0xab0e93b6efee0053, 0x8eea0d047a457a00},
+            {0xd5d238a4abe98068, 0x72a4904598d6d880},
+            {0x85a36366eb71f041, 0x47a6da2b7f864750},
+            {0xa70c3c40a64e6c51, 0x999090b65f67d924},
+            {0xd0cf4b50cfe20765, 0xfff4b4e3f741cf6d},
+            {0x82818f1281ed449f, 0xbff8f10e7a8921a5},
+            {0xa321f2d7226895c7, 0xaff72d52192b6a0e},
+            {0xcbea6f8ceb02bb39, 0x9bf4f8a69f764491},
+            {0xfee50b7025c36a08, 0x02f236d04753d5b5},
+            {0x9f4f2726179a2245, 0x01d762422c946591},
+            {0xc722f0ef9d80aad6, 0x424d3ad2b7b97ef6},
+            {0xf8ebad2b84e0d58b, 0xd2e0898765a7deb3},
+            {0x9b934c3b330c8577, 0x63cc55f49f88eb30},
+            {0xc2781f49ffcfa6d5, 0x3cbf6b71c76b25fc},
+            {0xf316271c7fc3908a, 0x8bef464e3945ef7b},
+            {0x97edd871cfda3a56, 0x97758bf0e3cbb5ad},
+            {0xbde94e8e43d0c8ec, 0x3d52eeed1cbea318},
+            {0xed63a231d4c4fb27, 0x4ca7aaa863ee4bde},
+            {0x945e455f24fb1cf8, 0x8fe8caa93e74ef6b},
+            {0xb975d6b6ee39e436, 0xb3e2fd538e122b45},
+            {0xe7d34c64a9c85d44, 0x60dbbca87196b617},
+            {0x90e40fbeea1d3a4a, 0xbc8955e946fe31ce},
+            {0xb51d13aea4a488dd, 0x6babab6398bdbe42},
+            {0xe264589a4dcdab14, 0xc696963c7eed2dd2},
+            {0x8d7eb76070a08aec, 0xfc1e1de5cf543ca3},
+            {0xb0de65388cc8ada8, 0x3b25a55f43294bcc},
+            {0xdd15fe86affad912, 0x49ef0eb713f39ebf},
+            {0x8a2dbf142dfcc7ab, 0x6e3569326c784338},
+            {0xacb92ed9397bf996, 0x49c2c37f07965405},
+            {0xd7e77a8f87daf7fb, 0xdc33745ec97be907},
+            {0x86f0ac99b4e8dafd, 0x69a028bb3ded71a4},
+            {0xa8acd7c0222311bc, 0xc40832ea0d68ce0d},
+            {0xd2d80db02aabd62b, 0xf50a3fa490c30191},
+            {0x83c7088e1aab65db, 0x792667c6da79e0fb},
+            {0xa4b8cab1a1563f52, 0x577001b891185939},
+            {0xcde6fd5e09abcf26, 0xed4c0226b55e6f87},
+            {0x80b05e5ac60b6178, 0x544f8158315b05b5},
+            {0xa0dc75f1778e39d6, 0x696361ae3db1c722},
+            {0xc913936dd571c84c, 0x03bc3a19cd1e38ea},
+            {0xfb5878494ace3a5f, 0x04ab48a04065c724},
+            {0x9d174b2dcec0e47b, 0x62eb0d64283f9c77},
+            {0xc45d1df942711d9a, 0x3ba5d0bd324f8395},
+            {0xf5746577930d6500, 0xca8f44ec7ee3647a},
+            {0x9968bf6abbe85f20, 0x7e998b13cf4e1ecc},
+            {0xbfc2ef456ae276e8, 0x9e3fedd8c321a67f},
+            {0xefb3ab16c59b14a2, 0xc5cfe94ef3ea101f},
+            {0x95d04aee3b80ece5, 0xbba1f1d158724a13},
+            {0xbb445da9ca61281f, 0x2a8a6e45ae8edc98},
+            {0xea1575143cf97226, 0xf52d09d71a3293be},
+            {0x924d692ca61be758, 0x593c2626705f9c57},
+            {0xb6e0c377cfa2e12e, 0x6f8b2fb00c77836d},
+            {0xe498f455c38b997a, 0x0b6dfb9c0f956448},
+            {0x8edf98b59a373fec, 0x4724bd4189bd5ead},
+            {0xb2977ee300c50fe7, 0x58edec91ec2cb658},
+            {0xdf3d5e9bc0f653e1, 0x2f2967b66737e3ee},
+            {0x8b865b215899f46c, 0xbd79e0d20082ee75},
+            {0xae67f1e9aec07187, 0xecd8590680a3aa12},
+            {0xda01ee641a708de9, 0xe80e6f4820cc9496},
+            {0x884134fe908658b2, 0x3109058d147fdcde},
+            {0xaa51823e34a7eede, 0xbd4b46f0599fd416},
+            {0xd4e5e2cdc1d1ea96, 0x6c9e18ac7007c91b},
+            {0x850fadc09923329e, 0x03e2cf6bc604ddb1},
+            {0xa6539930bf6bff45, 0x84db8346b786151d},
+            {0xcfe87f7cef46ff16, 0xe612641865679a64},
+            {0x81f14fae158c5f6e, 0x4fcb7e8f3f60c07f},
+            {0xa26da3999aef7749, 0xe3be5e330f38f09e},
+            {0xcb090c8001ab551c, 0x5cadf5bfd3072cc6},
+            {0xfdcb4fa002162a63, 0x73d9732fc7c8f7f7},
+            {0x9e9f11c4014dda7e, 0x2867e7fddcdd9afb},
+            {0xc646d63501a1511d, 0xb281e1fd541501b9},
+            {0xf7d88bc24209a565, 0x1f225a7ca91a4227},
+            {0x9ae757596946075f, 0x3375788de9b06959},
+            {0xc1a12d2fc3978937, 0x0052d6b1641c83af},
+            {0xf209787bb47d6b84, 0xc0678c5dbd23a49b},
+            {0x9745eb4d50ce6332, 0xf840b7ba963646e1},
+            {0xbd176620a501fbff, 0xb650e5a93bc3d899},
+            {0xec5d3fa8ce427aff, 0xa3e51f138ab4cebf},
+            {0x93ba47c980e98cdf, 0xc66f336c36b10138},
+            {0xb8a8d9bbe123f017, 0xb80b0047445d4185},
+            {0xe6d3102ad96cec1d, 0xa60dc059157491e6},
+            {0x9043ea1ac7e41392, 0x87c89837ad68db30},
+            {0xb454e4a179dd1877, 0x29babe4598c311fc},
+            {0xe16a1dc9d8545e94, 0xf4296dd6fef3d67b},
+            {0x8ce2529e2734bb1d, 0x1899e4a65f58660d},
+            {0xb01ae745b101e9e4, 0x5ec05dcff72e7f90},
+            {0xdc21a1171d42645d, 0x76707543f4fa1f74},
+            {0x899504ae72497eba, 0x6a06494a791c53a9},
+            {0xabfa45da0edbde69, 0x0487db9d17636893},
+            {0xd6f8d7509292d603, 0x45a9d2845d3c42b7},
+            {0x865b86925b9bc5c2, 0x0b8a2392ba45a9b3},
+            {0xa7f26836f282b732, 0x8e6cac7768d7141f},
+            {0xd1ef0244af2364ff, 0x3207d795430cd927},
+            {0x8335616aed761f1f, 0x7f44e6bd49e807b9},
+            {0xa402b9c5a8d3a6e7, 0x5f16206c9c6209a7},
+            {0xcd036837130890a1, 0x36dba887c37a8c10},
+            {0x802221226be55a64, 0xc2494954da2c978a},
+            {0xa02aa96b06deb0fd, 0xf2db9baa10b7bd6d},
+            {0xc83553c5c8965d3d, 0x6f92829494e5acc8},
+            {0xfa42a8b73abbf48c, 0xcb772339ba1f17fa},
+            {0x9c69a97284b578d7, 0xff2a760414536efc},
+            {0xc38413cf25e2d70d, 0xfef5138519684abb},
+            {0xf46518c2ef5b8cd1, 0x7eb258665fc25d6a},
+            {0x98bf2f79d5993802, 0xef2f773ffbd97a62},
+            {0xbeeefb584aff8603, 0xaafb550ffacfd8fb},
+            {0xeeaaba2e5dbf6784, 0x95ba2a53f983cf39},
+            {0x952ab45cfa97a0b2, 0xdd945a747bf26184},
+            {0xba756174393d88df, 0x94f971119aeef9e5},
+            {0xe912b9d1478ceb17, 0x7a37cd5601aab85e},
+            {0x91abb422ccb812ee, 0xac62e055c10ab33b},
+            {0xb616a12b7fe617aa, 0x577b986b314d600a},
+            {0xe39c49765fdf9d94, 0xed5a7e85fda0b80c},
+            {0x8e41ade9fbebc27d, 0x14588f13be847308},
+            {0xb1d219647ae6b31c, 0x596eb2d8ae258fc9},
+            {0xde469fbd99a05fe3, 0x6fca5f8ed9aef3bc},
+            {0x8aec23d680043bee, 0x25de7bb9480d5855},
+            {0xada72ccc20054ae9, 0xaf561aa79a10ae6b},
+            {0xd910f7ff28069da4, 0x1b2ba1518094da05},
+            {0x87aa9aff79042286, 0x90fb44d2f05d0843},
+            {0xa99541bf57452b28, 0x353a1607ac744a54},
+            {0xd3fa922f2d1675f2, 0x42889b8997915ce9},
+            {0x847c9b5d7c2e09b7, 0x69956135febada12},
+            {0xa59bc234db398c25, 0x43fab9837e699096},
+            {0xcf02b2c21207ef2e, 0x94f967e45e03f4bc},
+            {0x8161afb94b44f57d, 0x1d1be0eebac278f6},
+            {0xa1ba1ba79e1632dc, 0x6462d92a69731733},
+            {0xca28a291859bbf93, 0x7d7b8f7503cfdcff},
+            {0xfcb2cb35e702af78, 0x5cda735244c3d43f},
+            {0x9defbf01b061adab, 0x3a0888136afa64a8},
+            {0xc56baec21c7a1916, 0x088aaa1845b8fdd1},
+            {0xf6c69a72a3989f5b, 0x8aad549e57273d46},
+            {0x9a3c2087a63f6399, 0x36ac54e2f678864c},
+            {0xc0cb28a98fcf3c7f, 0x84576a1bb416a7de},
+            {0xf0fdf2d3f3c30b9f, 0x656d44a2a11c51d6},
+            {0x969eb7c47859e743, 0x9f644ae5a4b1b326},
+            {0xbc4665b596706114, 0x873d5d9f0dde1fef},
+            {0xeb57ff22fc0c7959, 0xa90cb506d155a7eb},
+            {0x9316ff75dd87cbd8, 0x09a7f12442d588f3},
+            {0xb7dcbf5354e9bece, 0x0c11ed6d538aeb30},
+            {0xe5d3ef282a242e81, 0x8f1668c8a86da5fb},
+            {0x8fa475791a569d10, 0xf96e017d694487bd},
+            {0xb38d92d760ec4455, 0x37c981dcc395a9ad},
+            {0xe070f78d3927556a, 0x85bbe253f47b1418},
+            {0x8c469ab843b89562, 0x93956d7478ccec8f},
+            {0xaf58416654a6babb, 0x387ac8d1970027b3},
+            {0xdb2e51bfe9d0696a, 0x06997b05fcc0319f},
+            {0x88fcf317f22241e2, 0x441fece3bdf81f04},
+            {0xab3c2fddeeaad25a, 0xd527e81cad7626c4},
+            {0xd60b3bd56a5586f1, 0x8a71e223d8d3b075},
+            {0x85c7056562757456, 0xf6872d5667844e4a},
+            {0xa738c6bebb12d16c, 0xb428f8ac016561dc},
+            {0xd106f86e69d785c7, 0xe13336d701beba53},
+            {0x82a45b450226b39c, 0xecc0024661173474},
+            {0xa34d721642b06084, 0x27f002d7f95d0191},
+            {0xcc20ce9bd35c78a5, 0x31ec038df7b441f5},
+            {0xff290242c83396ce, 0x7e67047175a15272},
+            {0x9f79a169bd203e41, 0x0f0062c6e984d387},
+            {0xc75809c42c684dd1, 0x52c07b78a3e60869},
+            {0xf92e0c3537826145, 0xa7709a56ccdf8a83},
+            {0x9bbcc7a142b17ccb, 0x88a66076400bb692},
+            {0xc2abf989935ddbfe, 0x6acff893d00ea436},
+            {0xf356f7ebf83552fe, 0x0583f6b8c4124d44},
+            {0x98165af37b2153de, 0xc3727a337a8b704b},
+            {0xbe1bf1b059e9a8d6, 0x744f18c0592e4c5d},
+            {0xeda2ee1c7064130c, 0x1162def06f79df74},
+            {0x9485d4d1c63e8be7, 0x8addcb5645ac2ba9},
+            {0xb9a74a0637ce2ee1, 0x6d953e2bd7173693},
+            {0xe8111c87c5c1ba99, 0xc8fa8db6ccdd0438},
+            {0x910ab1d4db9914a0, 0x1d9c9892400a22a3},
+            {0xb54d5e4a127f59c8, 0x2503beb6d00cab4c},
+            {0xe2a0b5dc971f303a, 0x2e44ae64840fd61e},
+            {0x8da471a9de737e24, 0x5ceaecfed289e5d3},
+            {0xb10d8e1456105dad, 0x7425a83e872c5f48},
+            {0xdd50f1996b947518, 0xd12f124e28f7771a},
+            {0x8a5296ffe33cc92f, 0x82bd6b70d99aaa70},
+            {0xace73cbfdc0bfb7b, 0x636cc64d1001550c},
+            {0xd8210befd30efa5a, 0x3c47f7e05401aa4f},
+            {0x8714a775e3e95c78, 0x65acfaec34810a72},
+            {0xa8d9d1535ce3b396, 0x7f1839a741a14d0e},
+            {0xd31045a8341ca07c, 0x1ede48111209a051},
+            {0x83ea2b892091e44d, 0x934aed0aab460433},
+            {0xa4e4b66b68b65d60, 0xf81da84d56178540},
+            {0xce1de40642e3f4b9, 0x36251260ab9d668f},
+            {0x80d2ae83e9ce78f3, 0xc1d72b7c6b42601a},
+            {0xa1075a24e4421730, 0xb24cf65b8612f820},
+            {0xc94930ae1d529cfc, 0xdee033f26797b628},
+            {0xfb9b7cd9a4a7443c, 0x169840ef017da3b2},
+            {0x9d412e0806e88aa5, 0x8e1f289560ee864f},
+            {0xc491798a08a2ad4e, 0xf1a6f2bab92a27e3},
+            {0xf5b5d7ec8acb58a2, 0xae10af696774b1dc},
+            {0x9991a6f3d6bf1765, 0xacca6da1e0a8ef2a},
+            {0xbff610b0cc6edd3f, 0x17fd090a58d32af4},
+            {0xeff394dcff8a948e, 0xddfc4b4cef07f5b1},
+            {0x95f83d0a1fb69cd9, 0x4abdaf101564f98f},
+            {0xbb764c4ca7a4440f, 0x9d6d1ad41abe37f2},
+            {0xea53df5fd18d5513, 0x84c86189216dc5ee},
+            {0x92746b9be2f8552c, 0x32fd3cf5b4e49bb5},
+            {0xb7118682dbb66a77, 0x3fbc8c33221dc2a2},
+            {0xe4d5e82392a40515, 0x0fabaf3feaa5334b},
+            {0x8f05b1163ba6832d, 0x29cb4d87f2a7400f},
+            {0xb2c71d5bca9023f8, 0x743e20e9ef511013},
+            {0xdf78e4b2bd342cf6, 0x914da9246b255417},
+            {0x8bab8eefb6409c1a, 0x1ad089b6c2f7548f},
+            {0xae9672aba3d0c320, 0xa184ac2473b529b2},
+            {0xda3c0f568cc4f3e8, 0xc9e5d72d90a2741f},
+            {0x8865899617fb1871, 0x7e2fa67c7a658893},
+            {0xaa7eebfb9df9de8d, 0xddbb901b98feeab8},
+            {0xd51ea6fa85785631, 0x552a74227f3ea566},
+            {0x8533285c936b35de, 0xd53a88958f872760},
+            {0xa67ff273b8460356, 0x8a892abaf368f138},
+            {0xd01fef10a657842c, 0x2d2b7569b0432d86},
+            {0x8213f56a67f6b29b, 0x9c3b29620e29fc74},
+            {0xa298f2c501f45f42, 0x8349f3ba91b47b90},
+            {0xcb3f2f7642717713, 0x241c70a936219a74},
+            {0xfe0efb53d30dd4d7, 0xed238cd383aa0111},
+            {0x9ec95d1463e8a506, 0xf4363804324a40ab},
+            {0xc67bb4597ce2ce48, 0xb143c6053edcd0d6},
+            {0xf81aa16fdc1b81da, 0xdd94b7868e94050b},
+            {0x9b10a4e5e9913128, 0xca7cf2b4191c8327},
+            {0xc1d4ce1f63f57d72, 0xfd1c2f611f63a3f1},
+            {0xf24a01a73cf2dccf, 0xbc633b39673c8ced},
+            {0x976e41088617ca01, 0xd5be0503e085d814},
+            {0xbd49d14aa79dbc82, 0x4b2d8644d8a74e19},
+            {0xec9c459d51852ba2, 0xddf8e7d60ed1219f},
+            {0x93e1ab8252f33b45, 0xcabb90e5c942b504},
+            {0xb8da1662e7b00a17, 0x3d6a751f3b936244},
+            {0xe7109bfba19c0c9d, 0x0cc512670a783ad5},
+            {0x906a617d450187e2, 0x27fb2b80668b24c6},
+            {0xb484f9dc9641e9da, 0xb1f9f660802dedf7},
+            {0xe1a63853bbd26451, 0x5e7873f8a0396974},
+            {0x8d07e33455637eb2, 0xdb0b487b6423e1e9},
+            {0xb049dc016abc5e5f, 0x91ce1a9a3d2cda63},
+            {0xdc5c5301c56b75f7, 0x7641a140cc7810fc},
+            {0x89b9b3e11b6329ba, 0xa9e904c87fcb0a9e},
+            {0xac2820d9623bf429, 0x546345fa9fbdcd45},
+            {0xd732290fbacaf133, 0xa97c177947ad4096},
+            {0x867f59a9d4bed6c0, 0x49ed8eabcccc485e},
+            {0xa81f301449ee8c70, 0x5c68f256bfff5a75},
+            {0xd226fc195c6a2f8c, 0x73832eec6fff3112},
+            {0x83585d8fd9c25db7, 0xc831fd53c5ff7eac},
+            {0xa42e74f3d032f525, 0xba3e7ca8b77f5e56},
+            {0xcd3a1230c43fb26f, 0x28ce1bd2e55f35ec},
+            {0x80444b5e7aa7cf85, 0x7980d163cf5b81b4},
+            {0xa0555e361951c366, 0xd7e105bcc3326220},
+            {0xc86ab5c39fa63440, 0x8dd9472bf3fefaa8},
+            {0xfa856334878fc150, 0xb14f98f6f0feb952},
+            {0x9c935e00d4b9d8d2, 0x6ed1bf9a569f33d4},
+            {0xc3b8358109e84f07, 0x0a862f80ec4700c9},
+            {0xf4a642e14c6262c8, 0xcd27bb612758c0fb},
+            {0x98e7e9cccfbd7dbd, 0x8038d51cb897789d},
+            {0xbf21e44003acdd2c, 0xe0470a63e6bd56c4},
+            {0xeeea5d5004981478, 0x1858ccfce06cac75},
+            {0x95527a5202df0ccb, 0x0f37801e0c43ebc9},
+            {0xbaa718e68396cffd, 0xd30560258f54e6bb},
+            {0xe950df20247c83fd, 0x47c6b82ef32a206a},
+            {0x91d28b7416cdd27e, 0x4cdc331d57fa5442},
+            {0xb6472e511c81471d, 0xe0133fe4adf8e953},
+            {0xe3d8f9e563a198e5, 0x58180fddd97723a7},
+            {0x8e679c2f5e44ff8f, 0x570f09eaa7ea7649},
+            {0xb201833b35d63f73, 0x2cd2cc6551e513db},
+            {0xde81e40a034bcf4f, 0xf8077f7ea65e58d2},
+            {0x8b112e86420f6191, 0xfb04afaf27faf783},
+            {0xadd57a27d29339f6, 0x79c5db9af1f9b564},
+            {0xd94ad8b1c7380874, 0x18375281ae7822bd},
+            {0x87cec76f1c830548, 0x8f2293910d0b15b6},
+            {0xa9c2794ae3a3c69a, 0xb2eb3875504ddb23},
+            {0xd433179d9c8cb841, 0x5fa60692a46151ec},
+            {0x849feec281d7f328, 0xdbc7c41ba6bcd334},
+            {0xa5c7ea73224deff3, 0x12b9b522906c0801},
+            {0xcf39e50feae16bef, 0xd768226b34870a01},
+            {0x81842f29f2cce375, 0xe6a1158300d46641},
+            {0xa1e53af46f801c53, 0x60495ae3c1097fd1},
+            {0xca5e89b18b602368, 0x385bb19cb14bdfc5},
+            {0xfcf62c1dee382c42, 0x46729e03dd9ed7b6},
+            {0x9e19db92b4e31ba9, 0x6c07a2c26a8346d2},
+            {0xc5a05277621be293, 0xc7098b7305241886},
+            {0xf70867153aa2db38, 0xb8cbee4fc66d1ea8}
+#else
+            {0xff77b1fcbebcdc4f, 0x25e8e89c13bb0f7b},
+            {0xce5d73ff402d98e3, 0xfb0a3d212dc81290},
+            {0xa6b34ad8c9dfc06f, 0xf42faa48c0ea481f},
+            {0x86a8d39ef77164bc, 0xae5dff9c02033198},
+            {0xd98ddaee19068c76, 0x3badd624dd9b0958},
+            {0xafbd2350644eeacf, 0xe5d1929ef90898fb},
+            {0x8df5efabc5979c8f, 0xca8d3ffa1ef463c2},
+            {0xe55990879ddcaabd, 0xcc420a6a101d0516},
+            {0xb94470938fa89bce, 0xf808e40e8d5b3e6a},
+            {0x95a8637627989aad, 0xdde7001379a44aa9},
+            {0xf1c90080baf72cb1, 0x5324c68b12dd6339},
+            {0xc350000000000000, 0x0000000000000000},
+            {0x9dc5ada82b70b59d, 0xf020000000000000},
+            {0xfee50b7025c36a08, 0x02f236d04753d5b5},
+            {0xcde6fd5e09abcf26, 0xed4c0226b55e6f87},
+            {0xa6539930bf6bff45, 0x84db8346b786151d},
+            {0x865b86925b9bc5c2, 0x0b8a2392ba45a9b3},
+            {0xd910f7ff28069da4, 0x1b2ba1518094da05},
+            {0xaf58416654a6babb, 0x387ac8d1970027b3},
+            {0x8da471a9de737e24, 0x5ceaecfed289e5d3},
+            {0xe4d5e82392a40515, 0x0fabaf3feaa5334b},
+            {0xb8da1662e7b00a17, 0x3d6a751f3b936244},
+            { 0x95527a5202df0ccb,
+                0x0f37801e0c43ebc9 }
+#endif
+        };
+
+#if FMT_USE_FULL_CACHE_DRAGONBOX
+        return pow10_significands[k - float_info<double>::min_k];
+#else
+        static constexpr const uint64_t powers_of_5_64[] = {0x0000000000000001, 0x0000000000000005, 0x0000000000000019, 0x000000000000007d,
+            0x0000000000000271, 0x0000000000000c35, 0x0000000000003d09, 0x000000000001312d, 0x000000000005f5e1, 0x00000000001dcd65,
+            0x00000000009502f9, 0x0000000002e90edd, 0x000000000e8d4a51, 0x0000000048c27395, 0x000000016bcc41e9, 0x000000071afd498d,
+            0x0000002386f26fc1, 0x000000b1a2bc2ec5, 0x000003782dace9d9, 0x00001158e460913d, 0x000056bc75e2d631, 0x0001b1ae4d6e2ef5,
+            0x000878678326eac9, 0x002a5a058fc295ed, 0x00d3c21bcecceda1, 0x0422ca8b0a00a425, 0x14adf4b7320334b9};
+
+        static const int compression_ratio = 27;
+
+        // Compute base index.
+        int cache_index = (k - float_info<double>::min_k) / compression_ratio;
+        int kb = cache_index * compression_ratio + float_info<double>::min_k;
+        int offset = k - kb;
+
+        // Get base cache.
+        uint128_fallback base_cache = pow10_significands[cache_index];
+        if (offset == 0)
+            return base_cache;
+
+        // Compute the required amount of bit-shift.
+        int alpha = floor_log2_pow10(kb + offset) - floor_log2_pow10(kb) - offset;
+        FMT_ASSERT(alpha > 0 && alpha < 64, "shifting error detected");
+
+        // Try to recover the real cache.
+        uint64_t pow5 = powers_of_5_64[offset];
+        uint128_fallback recovered_cache = umul128(base_cache.high(), pow5);
+        uint128_fallback middle_low = umul128(base_cache.low(), pow5);
+
+        recovered_cache += middle_low.high();
+
+        uint64_t high_to_middle = recovered_cache.high() << (64 - alpha);
+        uint64_t middle_to_low = recovered_cache.low() << (64 - alpha);
+
+        recovered_cache =
+            uint128_fallback{(recovered_cache.low() >> alpha) | high_to_middle, ((middle_low.low() >> alpha) | middle_to_low)};
+        FMT_ASSERT(recovered_cache.low() + 1 != 0, "");
+        return {recovered_cache.high(), recovered_cache.low() + 1};
+#endif
+    }
+
+    struct compute_mul_result
+    {
+        carrier_uint result;
+        bool is_integer;
+    };
+    struct compute_mul_parity_result
+    {
+        bool parity;
+        bool is_integer;
+    };
+
+    static compute_mul_result compute_mul(carrier_uint u, const cache_entry_type &cache) noexcept
+    {
+        auto r = umul192_upper128(u, cache);
+        return {r.high(), r.low() == 0};
+    }
+
+    static uint32_t compute_delta(cache_entry_type const &cache, int beta) noexcept
+    {
+        return static_cast<uint32_t>(cache.high() >> (64 - 1 - beta));
+    }
+
+    static compute_mul_parity_result compute_mul_parity(carrier_uint two_f, const cache_entry_type &cache, int beta) noexcept
+    {
+        FMT_ASSERT(beta >= 1, "");
+        FMT_ASSERT(beta < 64, "");
+
+        auto r = umul192_lower128(two_f, cache);
+        return {((r.high() >> (64 - beta)) & 1) != 0, ((r.high() << beta) | (r.low() >> (64 - beta))) == 0};
+    }
+
+    static carrier_uint compute_left_endpoint_for_shorter_interval_case(const cache_entry_type &cache, int beta) noexcept
+    {
+        return (cache.high() - (cache.high() >> (num_significand_bits<double>() + 2))) >> (64 - num_significand_bits<double>() - 1 - beta);
+    }
+
+    static carrier_uint compute_right_endpoint_for_shorter_interval_case(const cache_entry_type &cache, int beta) noexcept
+    {
+        return (cache.high() + (cache.high() >> (num_significand_bits<double>() + 1))) >> (64 - num_significand_bits<double>() - 1 - beta);
+    }
+
+    static carrier_uint compute_round_up_for_shorter_interval_case(const cache_entry_type &cache, int beta) noexcept
+    {
+        return ((cache.high() >> (64 - num_significand_bits<double>() - 2 - beta)) + 1) / 2;
+    }
+};
+
+// Various integer checks
+template<class T>
+bool is_left_endpoint_integer_shorter_interval(int exponent) noexcept
+{
+    const int case_shorter_interval_left_endpoint_lower_threshold = 2;
+    const int case_shorter_interval_left_endpoint_upper_threshold = 3;
+    return exponent >= case_shorter_interval_left_endpoint_lower_threshold &&
+           exponent <= case_shorter_interval_left_endpoint_upper_threshold;
+}
+
+// Remove trailing zeros from n and return the number of zeros removed (float)
+FMT_INLINE int remove_trailing_zeros(uint32_t &n) noexcept
+{
+    FMT_ASSERT(n != 0, "");
+    const uint32_t mod_inv_5 = 0xcccccccd;
+    const uint32_t mod_inv_25 = mod_inv_5 * mod_inv_5;
+
+    int s = 0;
+    while (true)
+    {
+        auto q = rotr(n * mod_inv_25, 2);
+        if (q > max_value<uint32_t>() / 100)
+            break;
+        n = q;
+        s += 2;
+    }
+    auto q = rotr(n * mod_inv_5, 1);
+    if (q <= max_value<uint32_t>() / 10)
+    {
+        n = q;
+        s |= 1;
+    }
+
+    return s;
+}
+
+// Removes trailing zeros and returns the number of zeros removed (double)
+FMT_INLINE int remove_trailing_zeros(uint64_t &n) noexcept
+{
+    FMT_ASSERT(n != 0, "");
+
+    // This magic number is ceil(2^90 / 10^8).
+    constexpr uint64_t magic_number = 12379400392853802749ull;
+    auto nm = umul128(n, magic_number);
+
+    // Is n is divisible by 10^8?
+    if ((nm.high() & ((1ull << (90 - 64)) - 1)) == 0 && nm.low() < magic_number)
+    {
+        // If yes, work with the quotient.
+        auto n32 = static_cast<uint32_t>(nm.high() >> (90 - 64));
+
+        const uint32_t mod_inv_5 = 0xcccccccd;
+        const uint32_t mod_inv_25 = mod_inv_5 * mod_inv_5;
+
+        int s = 8;
+        while (true)
+        {
+            auto q = rotr(n32 * mod_inv_25, 2);
+            if (q > max_value<uint32_t>() / 100)
+                break;
+            n32 = q;
+            s += 2;
+        }
+        auto q = rotr(n32 * mod_inv_5, 1);
+        if (q <= max_value<uint32_t>() / 10)
+        {
+            n32 = q;
+            s |= 1;
+        }
+
+        n = n32;
+        return s;
+    }
+
+    // If n is not divisible by 10^8, work with n itself.
+    const uint64_t mod_inv_5 = 0xcccccccccccccccd;
+    const uint64_t mod_inv_25 = mod_inv_5 * mod_inv_5;
+
+    int s = 0;
+    while (true)
+    {
+        auto q = rotr(n * mod_inv_25, 2);
+        if (q > max_value<uint64_t>() / 100)
+            break;
+        n = q;
+        s += 2;
+    }
+    auto q = rotr(n * mod_inv_5, 1);
+    if (q <= max_value<uint64_t>() / 10)
+    {
+        n = q;
+        s |= 1;
+    }
+
+    return s;
+}
+
+// The main algorithm for shorter interval case
+template<class T>
+FMT_INLINE decimal_fp<T> shorter_interval_case(int exponent) noexcept
+{
+    decimal_fp<T> ret_value;
+    // Compute k and beta
+    const int minus_k = floor_log10_pow2_minus_log10_4_over_3(exponent);
+    const int beta = exponent + floor_log2_pow10(-minus_k);
+
+    // Compute xi and zi
+    using cache_entry_type = typename cache_accessor<T>::cache_entry_type;
+    const cache_entry_type cache = cache_accessor<T>::get_cached_power(-minus_k);
+
+    auto xi = cache_accessor<T>::compute_left_endpoint_for_shorter_interval_case(cache, beta);
+    auto zi = cache_accessor<T>::compute_right_endpoint_for_shorter_interval_case(cache, beta);
+
+    // If the left endpoint is not an integer, increase it
+    if (!is_left_endpoint_integer_shorter_interval<T>(exponent))
+        ++xi;
+
+    // Try bigger divisor
+    ret_value.significand = zi / 10;
+
+    // If succeed, remove trailing zeros if necessary and return
+    if (ret_value.significand * 10 >= xi)
+    {
+        ret_value.exponent = minus_k + 1;
+        ret_value.exponent += remove_trailing_zeros(ret_value.significand);
+        return ret_value;
+    }
+
+    // Otherwise, compute the round-up of y
+    ret_value.significand = cache_accessor<T>::compute_round_up_for_shorter_interval_case(cache, beta);
+    ret_value.exponent = minus_k;
+
+    // When tie occurs, choose one of them according to the rule
+    if (exponent >= float_info<T>::shorter_interval_tie_lower_threshold && exponent <= float_info<T>::shorter_interval_tie_upper_threshold)
+    {
+        ret_value.significand = ret_value.significand % 2 == 0 ? ret_value.significand : ret_value.significand - 1;
+    }
+    else if (ret_value.significand < xi)
+    {
+        ++ret_value.significand;
+    }
+    return ret_value;
+}
+
+template<typename T>
+decimal_fp<T> to_decimal(T x) noexcept
+{
+    // Step 1: integer promotion & Schubfach multiplier calculation.
+
+    using carrier_uint = typename float_info<T>::carrier_uint;
+    using cache_entry_type = typename cache_accessor<T>::cache_entry_type;
+    auto br = bit_cast<carrier_uint>(x);
+
+    // Extract significand bits and exponent bits.
+    const carrier_uint significand_mask = (static_cast<carrier_uint>(1) << num_significand_bits<T>()) - 1;
+    carrier_uint significand = (br & significand_mask);
+    int exponent = static_cast<int>((br & exponent_mask<T>()) >> num_significand_bits<T>());
+
+    if (exponent != 0)
+    { // Check if normal.
+        exponent -= exponent_bias<T>() + num_significand_bits<T>();
+
+        // Shorter interval case; proceed like Schubfach.
+        // In fact, when exponent == 1 and significand == 0, the interval is
+        // regular. However, it can be shown that the end-results are anyway same.
+        if (significand == 0)
+            return shorter_interval_case<T>(exponent);
+
+        significand |= (static_cast<carrier_uint>(1) << num_significand_bits<T>());
+    }
+    else
+    {
+        // Subnormal case; the interval is always regular.
+        if (significand == 0)
+            return {0, 0};
+        exponent = std::numeric_limits<T>::min_exponent - num_significand_bits<T>() - 1;
+    }
+
+    const bool include_left_endpoint = (significand % 2 == 0);
+    const bool include_right_endpoint = include_left_endpoint;
+
+    // Compute k and beta.
+    const int minus_k = floor_log10_pow2(exponent) - float_info<T>::kappa;
+    const cache_entry_type cache = cache_accessor<T>::get_cached_power(-minus_k);
+    const int beta = exponent + floor_log2_pow10(-minus_k);
+
+    // Compute zi and deltai.
+    // 10^kappa <= deltai < 10^(kappa + 1)
+    const uint32_t deltai = cache_accessor<T>::compute_delta(cache, beta);
+    const carrier_uint two_fc = significand << 1;
+
+    // For the case of binary32, the result of integer check is not correct for
+    // 29711844 * 2^-82
+    // = 6.1442653300000000008655037797566933477355632930994033813476... * 10^-18
+    // and 29711844 * 2^-81
+    // = 1.2288530660000000001731007559513386695471126586198806762695... * 10^-17,
+    // and they are the unique counterexamples. However, since 29711844 is even,
+    // this does not cause any problem for the endpoints calculations; it can only
+    // cause a problem when we need to perform integer check for the center.
+    // Fortunately, with these inputs, that branch is never executed, so we are
+    // fine.
+    const typename cache_accessor<T>::compute_mul_result z_mul = cache_accessor<T>::compute_mul((two_fc | 1) << beta, cache);
+
+    // Step 2: Try larger divisor; remove trailing zeros if necessary.
+
+    // Using an upper bound on zi, we might be able to optimize the division
+    // better than the compiler; we are computing zi / big_divisor here.
+    decimal_fp<T> ret_value;
+    ret_value.significand = divide_by_10_to_kappa_plus_1(z_mul.result);
+    uint32_t r = static_cast<uint32_t>(z_mul.result - float_info<T>::big_divisor * ret_value.significand);
+
+    if (r < deltai)
+    {
+        // Exclude the right endpoint if necessary.
+        if (r == 0 && (z_mul.is_integer & !include_right_endpoint))
+        {
+            --ret_value.significand;
+            r = float_info<T>::big_divisor;
+            goto small_divisor_case_label;
+        }
+    }
+    else if (r > deltai)
+    {
+        goto small_divisor_case_label;
+    }
+    else
+    {
+        // r == deltai; compare fractional parts.
+        const typename cache_accessor<T>::compute_mul_parity_result x_mul = cache_accessor<T>::compute_mul_parity(two_fc - 1, cache, beta);
+
+        if (!(x_mul.parity | (x_mul.is_integer & include_left_endpoint)))
+            goto small_divisor_case_label;
+    }
+    ret_value.exponent = minus_k + float_info<T>::kappa + 1;
+
+    // We may need to remove trailing zeros.
+    ret_value.exponent += remove_trailing_zeros(ret_value.significand);
+    return ret_value;
+
+    // Step 3: Find the significand with the smaller divisor.
+
+small_divisor_case_label:
+    ret_value.significand *= 10;
+    ret_value.exponent = minus_k + float_info<T>::kappa;
+
+    uint32_t dist = r - (deltai / 2) + (float_info<T>::small_divisor / 2);
+    const bool approx_y_parity = ((dist ^ (float_info<T>::small_divisor / 2)) & 1) != 0;
+
+    // Is dist divisible by 10^kappa?
+    const bool divisible_by_small_divisor = check_divisibility_and_divide_by_pow10<float_info<T>::kappa>(dist);
+
+    // Add dist / 10^kappa to the significand.
+    ret_value.significand += dist;
+
+    if (!divisible_by_small_divisor)
+        return ret_value;
+
+    // Check z^(f) >= epsilon^(f).
+    // We have either yi == zi - epsiloni or yi == (zi - epsiloni) - 1,
+    // where yi == zi - epsiloni if and only if z^(f) >= epsilon^(f).
+    // Since there are only 2 possibilities, we only need to care about the
+    // parity. Also, zi and r should have the same parity since the divisor
+    // is an even number.
+    const auto y_mul = cache_accessor<T>::compute_mul_parity(two_fc, cache, beta);
+
+    // If z^(f) >= epsilon^(f), we might have a tie when z^(f) == epsilon^(f),
+    // or equivalently, when y is an integer.
+    if (y_mul.parity != approx_y_parity)
+        --ret_value.significand;
+    else if (y_mul.is_integer & (ret_value.significand % 2 != 0))
+        --ret_value.significand;
+    return ret_value;
+}
+} // namespace dragonbox
+
+#ifdef _MSC_VER
+FMT_FUNC auto fmt_snprintf(char *buf, size_t size, const char *fmt, ...) -> int
+{
+    auto args = va_list();
+    va_start(args, fmt);
+    int result = vsnprintf_s(buf, size, _TRUNCATE, fmt, args);
+    va_end(args);
+    return result;
+}
+#endif
+} // namespace detail
+
+template<>
+struct formatter<detail::bigint>
+{
+    FMT_CONSTEXPR auto parse(format_parse_context &ctx) -> format_parse_context::iterator
+    {
+        return ctx.begin();
+    }
+
+    template<typename FormatContext>
+    auto format(const detail::bigint &n, FormatContext &ctx) const -> typename FormatContext::iterator
+    {
+        auto out = ctx.out();
+        bool first = true;
+        for (auto i = n.bigits_.size(); i > 0; --i)
+        {
+            auto value = n.bigits_[i - 1u];
+            if (first)
+            {
+                out = format_to(out, FMT_STRING("{:x}"), value);
+                first = false;
+                continue;
+            }
+            out = format_to(out, FMT_STRING("{:08x}"), value);
+        }
+        if (n.exp_ > 0)
+            out = format_to(out, FMT_STRING("p{}"), n.exp_ * detail::bigint::bigit_bits);
+        return out;
+    }
+};
+
+FMT_FUNC detail::utf8_to_utf16::utf8_to_utf16(string_view s)
+{
+    for_each_codepoint(s, [this](uint32_t cp, string_view) {
+        if (cp == invalid_code_point)
+            FMT_THROW(std::runtime_error("invalid utf8"));
+        if (cp <= 0xFFFF)
+        {
+            buffer_.push_back(static_cast<wchar_t>(cp));
+        }
+        else
+        {
+            cp -= 0x10000;
+            buffer_.push_back(static_cast<wchar_t>(0xD800 + (cp >> 10)));
+            buffer_.push_back(static_cast<wchar_t>(0xDC00 + (cp & 0x3FF)));
+        }
+        return true;
+    });
+    buffer_.push_back(0);
+}
+
+FMT_FUNC void format_system_error(detail::buffer<char> &out, int error_code, const char *message) noexcept
+{
+    FMT_TRY
+    {
+        auto ec = std::error_code(error_code, std::generic_category());
+        write(std::back_inserter(out), std::system_error(ec, message).what());
+        return;
+    }
+    FMT_CATCH(...) {}
+    format_error_code(out, error_code, message);
+}
+
+FMT_FUNC void report_system_error(int error_code, const char *message) noexcept
+{
+    report_error(format_system_error, error_code, message);
+}
+
+FMT_FUNC std::string vformat(string_view fmt, format_args args)
+{
+    // Don't optimize the "{}" case to keep the binary size small and because it
+    // can be better optimized in fmt::format anyway.
+    auto buffer = memory_buffer();
+    detail::vformat_to(buffer, fmt, args);
+    return to_string(buffer);
+}
+
+namespace detail {
+#ifdef _WIN32
+using dword = conditional_t<sizeof(long) == 4, unsigned long, unsigned>;
+extern "C" __declspec(dllimport) int __stdcall WriteConsoleW( //
+    void *, const void *, dword, dword *, void *);
+
+FMT_FUNC bool write_console(std::FILE *f, string_view text)
+{
+    auto fd = _fileno(f);
+    if (_isatty(fd))
+    {
+        detail::utf8_to_utf16 u16(string_view(text.data(), text.size()));
+        auto written = detail::dword();
+        if (detail::WriteConsoleW(
+                reinterpret_cast<void *>(_get_osfhandle(fd)), u16.c_str(), static_cast<uint32_t>(u16.size()), &written, nullptr))
+        {
+            return true;
+        }
+    }
+    // We return false if the file descriptor was not TTY, or it was but
+    // SetConsoleW failed which can happen if the output has been redirected to
+    // NUL. In both cases when we return false, we should attempt to do regular
+    // write via fwrite or std::ostream::write.
+    return false;
+}
+#endif
+
+FMT_FUNC void print(std::FILE *f, string_view text)
+{
+#ifdef _WIN32
+    if (write_console(f, text))
+        return;
+#endif
+    detail::fwrite_fully(text.data(), 1, text.size(), f);
+}
+} // namespace detail
+
+FMT_FUNC void vprint(std::FILE *f, string_view format_str, format_args args)
+{
+    memory_buffer buffer;
+    detail::vformat_to(buffer, format_str, args);
+    detail::print(f, {buffer.data(), buffer.size()});
+}
+
+#ifdef _WIN32
+// Print assuming legacy (non-Unicode) encoding.
+FMT_FUNC void detail::vprint_mojibake(std::FILE *f, string_view format_str, format_args args)
+{
+    memory_buffer buffer;
+    detail::vformat_to(buffer, format_str, basic_format_args<buffer_context<char>>(args));
+    fwrite_fully(buffer.data(), 1, buffer.size(), f);
+}
+#endif
+
+FMT_FUNC void vprint(string_view format_str, format_args args)
+{
+    vprint(stdout, format_str, args);
+}
+
+namespace detail {
+
+struct singleton
+{
+    unsigned char upper;
+    unsigned char lower_count;
+};
+
+inline auto is_printable(uint16_t x, const singleton *singletons, size_t singletons_size, const unsigned char *singleton_lowers,
+    const unsigned char *normal, size_t normal_size) -> bool
+{
+    auto upper = x >> 8;
+    auto lower_start = 0;
+    for (size_t i = 0; i < singletons_size; ++i)
+    {
+        auto s = singletons[i];
+        auto lower_end = lower_start + s.lower_count;
+        if (upper < s.upper)
+            break;
+        if (upper == s.upper)
+        {
+            for (auto j = lower_start; j < lower_end; ++j)
+            {
+                if (singleton_lowers[j] == (x & 0xff))
+                    return false;
+            }
+        }
+        lower_start = lower_end;
+    }
+
+    auto xsigned = static_cast<int>(x);
+    auto current = true;
+    for (size_t i = 0; i < normal_size; ++i)
+    {
+        auto v = static_cast<int>(normal[i]);
+        auto len = (v & 0x80) != 0 ? (v & 0x7f) << 8 | normal[++i] : v;
+        xsigned -= len;
+        if (xsigned < 0)
+            break;
+        current = !current;
+    }
+    return current;
+}
+
+// This code is generated by support/printable.py.
+FMT_FUNC auto is_printable(uint32_t cp) -> bool
+{
+    static constexpr singleton singletons0[] = {
+        {0x00, 1},
+        {0x03, 5},
+        {0x05, 6},
+        {0x06, 3},
+        {0x07, 6},
+        {0x08, 8},
+        {0x09, 17},
+        {0x0a, 28},
+        {0x0b, 25},
+        {0x0c, 20},
+        {0x0d, 16},
+        {0x0e, 13},
+        {0x0f, 4},
+        {0x10, 3},
+        {0x12, 18},
+        {0x13, 9},
+        {0x16, 1},
+        {0x17, 5},
+        {0x18, 2},
+        {0x19, 3},
+        {0x1a, 7},
+        {0x1c, 2},
+        {0x1d, 1},
+        {0x1f, 22},
+        {0x20, 3},
+        {0x2b, 3},
+        {0x2c, 2},
+        {0x2d, 11},
+        {0x2e, 1},
+        {0x30, 3},
+        {0x31, 2},
+        {0x32, 1},
+        {0xa7, 2},
+        {0xa9, 2},
+        {0xaa, 4},
+        {0xab, 8},
+        {0xfa, 2},
+        {0xfb, 5},
+        {0xfd, 4},
+        {0xfe, 3},
+        {0xff, 9},
+    };
+    static constexpr unsigned char singletons0_lower[] = {
+        0xad,
+        0x78,
+        0x79,
+        0x8b,
+        0x8d,
+        0xa2,
+        0x30,
+        0x57,
+        0x58,
+        0x8b,
+        0x8c,
+        0x90,
+        0x1c,
+        0x1d,
+        0xdd,
+        0x0e,
+        0x0f,
+        0x4b,
+        0x4c,
+        0xfb,
+        0xfc,
+        0x2e,
+        0x2f,
+        0x3f,
+        0x5c,
+        0x5d,
+        0x5f,
+        0xb5,
+        0xe2,
+        0x84,
+        0x8d,
+        0x8e,
+        0x91,
+        0x92,
+        0xa9,
+        0xb1,
+        0xba,
+        0xbb,
+        0xc5,
+        0xc6,
+        0xc9,
+        0xca,
+        0xde,
+        0xe4,
+        0xe5,
+        0xff,
+        0x00,
+        0x04,
+        0x11,
+        0x12,
+        0x29,
+        0x31,
+        0x34,
+        0x37,
+        0x3a,
+        0x3b,
+        0x3d,
+        0x49,
+        0x4a,
+        0x5d,
+        0x84,
+        0x8e,
+        0x92,
+        0xa9,
+        0xb1,
+        0xb4,
+        0xba,
+        0xbb,
+        0xc6,
+        0xca,
+        0xce,
+        0xcf,
+        0xe4,
+        0xe5,
+        0x00,
+        0x04,
+        0x0d,
+        0x0e,
+        0x11,
+        0x12,
+        0x29,
+        0x31,
+        0x34,
+        0x3a,
+        0x3b,
+        0x45,
+        0x46,
+        0x49,
+        0x4a,
+        0x5e,
+        0x64,
+        0x65,
+        0x84,
+        0x91,
+        0x9b,
+        0x9d,
+        0xc9,
+        0xce,
+        0xcf,
+        0x0d,
+        0x11,
+        0x29,
+        0x45,
+        0x49,
+        0x57,
+        0x64,
+        0x65,
+        0x8d,
+        0x91,
+        0xa9,
+        0xb4,
+        0xba,
+        0xbb,
+        0xc5,
+        0xc9,
+        0xdf,
+        0xe4,
+        0xe5,
+        0xf0,
+        0x0d,
+        0x11,
+        0x45,
+        0x49,
+        0x64,
+        0x65,
+        0x80,
+        0x84,
+        0xb2,
+        0xbc,
+        0xbe,
+        0xbf,
+        0xd5,
+        0xd7,
+        0xf0,
+        0xf1,
+        0x83,
+        0x85,
+        0x8b,
+        0xa4,
+        0xa6,
+        0xbe,
+        0xbf,
+        0xc5,
+        0xc7,
+        0xce,
+        0xcf,
+        0xda,
+        0xdb,
+        0x48,
+        0x98,
+        0xbd,
+        0xcd,
+        0xc6,
+        0xce,
+        0xcf,
+        0x49,
+        0x4e,
+        0x4f,
+        0x57,
+        0x59,
+        0x5e,
+        0x5f,
+        0x89,
+        0x8e,
+        0x8f,
+        0xb1,
+        0xb6,
+        0xb7,
+        0xbf,
+        0xc1,
+        0xc6,
+        0xc7,
+        0xd7,
+        0x11,
+        0x16,
+        0x17,
+        0x5b,
+        0x5c,
+        0xf6,
+        0xf7,
+        0xfe,
+        0xff,
+        0x80,
+        0x0d,
+        0x6d,
+        0x71,
+        0xde,
+        0xdf,
+        0x0e,
+        0x0f,
+        0x1f,
+        0x6e,
+        0x6f,
+        0x1c,
+        0x1d,
+        0x5f,
+        0x7d,
+        0x7e,
+        0xae,
+        0xaf,
+        0xbb,
+        0xbc,
+        0xfa,
+        0x16,
+        0x17,
+        0x1e,
+        0x1f,
+        0x46,
+        0x47,
+        0x4e,
+        0x4f,
+        0x58,
+        0x5a,
+        0x5c,
+        0x5e,
+        0x7e,
+        0x7f,
+        0xb5,
+        0xc5,
+        0xd4,
+        0xd5,
+        0xdc,
+        0xf0,
+        0xf1,
+        0xf5,
+        0x72,
+        0x73,
+        0x8f,
+        0x74,
+        0x75,
+        0x96,
+        0x2f,
+        0x5f,
+        0x26,
+        0x2e,
+        0x2f,
+        0xa7,
+        0xaf,
+        0xb7,
+        0xbf,
+        0xc7,
+        0xcf,
+        0xd7,
+        0xdf,
+        0x9a,
+        0x40,
+        0x97,
+        0x98,
+        0x30,
+        0x8f,
+        0x1f,
+        0xc0,
+        0xc1,
+        0xce,
+        0xff,
+        0x4e,
+        0x4f,
+        0x5a,
+        0x5b,
+        0x07,
+        0x08,
+        0x0f,
+        0x10,
+        0x27,
+        0x2f,
+        0xee,
+        0xef,
+        0x6e,
+        0x6f,
+        0x37,
+        0x3d,
+        0x3f,
+        0x42,
+        0x45,
+        0x90,
+        0x91,
+        0xfe,
+        0xff,
+        0x53,
+        0x67,
+        0x75,
+        0xc8,
+        0xc9,
+        0xd0,
+        0xd1,
+        0xd8,
+        0xd9,
+        0xe7,
+        0xfe,
+        0xff,
+    };
+    static constexpr singleton singletons1[] = {
+        {0x00, 6},
+        {0x01, 1},
+        {0x03, 1},
+        {0x04, 2},
+        {0x08, 8},
+        {0x09, 2},
+        {0x0a, 5},
+        {0x0b, 2},
+        {0x0e, 4},
+        {0x10, 1},
+        {0x11, 2},
+        {0x12, 5},
+        {0x13, 17},
+        {0x14, 1},
+        {0x15, 2},
+        {0x17, 2},
+        {0x19, 13},
+        {0x1c, 5},
+        {0x1d, 8},
+        {0x24, 1},
+        {0x6a, 3},
+        {0x6b, 2},
+        {0xbc, 2},
+        {0xd1, 2},
+        {0xd4, 12},
+        {0xd5, 9},
+        {0xd6, 2},
+        {0xd7, 2},
+        {0xda, 1},
+        {0xe0, 5},
+        {0xe1, 2},
+        {0xe8, 2},
+        {0xee, 32},
+        {0xf0, 4},
+        {0xf8, 2},
+        {0xf9, 2},
+        {0xfa, 2},
+        {0xfb, 1},
+    };
+    static constexpr unsigned char singletons1_lower[] = {
+        0x0c,
+        0x27,
+        0x3b,
+        0x3e,
+        0x4e,
+        0x4f,
+        0x8f,
+        0x9e,
+        0x9e,
+        0x9f,
+        0x06,
+        0x07,
+        0x09,
+        0x36,
+        0x3d,
+        0x3e,
+        0x56,
+        0xf3,
+        0xd0,
+        0xd1,
+        0x04,
+        0x14,
+        0x18,
+        0x36,
+        0x37,
+        0x56,
+        0x57,
+        0x7f,
+        0xaa,
+        0xae,
+        0xaf,
+        0xbd,
+        0x35,
+        0xe0,
+        0x12,
+        0x87,
+        0x89,
+        0x8e,
+        0x9e,
+        0x04,
+        0x0d,
+        0x0e,
+        0x11,
+        0x12,
+        0x29,
+        0x31,
+        0x34,
+        0x3a,
+        0x45,
+        0x46,
+        0x49,
+        0x4a,
+        0x4e,
+        0x4f,
+        0x64,
+        0x65,
+        0x5c,
+        0xb6,
+        0xb7,
+        0x1b,
+        0x1c,
+        0x07,
+        0x08,
+        0x0a,
+        0x0b,
+        0x14,
+        0x17,
+        0x36,
+        0x39,
+        0x3a,
+        0xa8,
+        0xa9,
+        0xd8,
+        0xd9,
+        0x09,
+        0x37,
+        0x90,
+        0x91,
+        0xa8,
+        0x07,
+        0x0a,
+        0x3b,
+        0x3e,
+        0x66,
+        0x69,
+        0x8f,
+        0x92,
+        0x6f,
+        0x5f,
+        0xee,
+        0xef,
+        0x5a,
+        0x62,
+        0x9a,
+        0x9b,
+        0x27,
+        0x28,
+        0x55,
+        0x9d,
+        0xa0,
+        0xa1,
+        0xa3,
+        0xa4,
+        0xa7,
+        0xa8,
+        0xad,
+        0xba,
+        0xbc,
+        0xc4,
+        0x06,
+        0x0b,
+        0x0c,
+        0x15,
+        0x1d,
+        0x3a,
+        0x3f,
+        0x45,
+        0x51,
+        0xa6,
+        0xa7,
+        0xcc,
+        0xcd,
+        0xa0,
+        0x07,
+        0x19,
+        0x1a,
+        0x22,
+        0x25,
+        0x3e,
+        0x3f,
+        0xc5,
+        0xc6,
+        0x04,
+        0x20,
+        0x23,
+        0x25,
+        0x26,
+        0x28,
+        0x33,
+        0x38,
+        0x3a,
+        0x48,
+        0x4a,
+        0x4c,
+        0x50,
+        0x53,
+        0x55,
+        0x56,
+        0x58,
+        0x5a,
+        0x5c,
+        0x5e,
+        0x60,
+        0x63,
+        0x65,
+        0x66,
+        0x6b,
+        0x73,
+        0x78,
+        0x7d,
+        0x7f,
+        0x8a,
+        0xa4,
+        0xaa,
+        0xaf,
+        0xb0,
+        0xc0,
+        0xd0,
+        0xae,
+        0xaf,
+        0x79,
+        0xcc,
+        0x6e,
+        0x6f,
+        0x93,
+    };
+    static constexpr unsigned char normal0[] = {
+        0x00,
+        0x20,
+        0x5f,
+        0x22,
+        0x82,
+        0xdf,
+        0x04,
+        0x82,
+        0x44,
+        0x08,
+        0x1b,
+        0x04,
+        0x06,
+        0x11,
+        0x81,
+        0xac,
+        0x0e,
+        0x80,
+        0xab,
+        0x35,
+        0x28,
+        0x0b,
+        0x80,
+        0xe0,
+        0x03,
+        0x19,
+        0x08,
+        0x01,
+        0x04,
+        0x2f,
+        0x04,
+        0x34,
+        0x04,
+        0x07,
+        0x03,
+        0x01,
+        0x07,
+        0x06,
+        0x07,
+        0x11,
+        0x0a,
+        0x50,
+        0x0f,
+        0x12,
+        0x07,
+        0x55,
+        0x07,
+        0x03,
+        0x04,
+        0x1c,
+        0x0a,
+        0x09,
+        0x03,
+        0x08,
+        0x03,
+        0x07,
+        0x03,
+        0x02,
+        0x03,
+        0x03,
+        0x03,
+        0x0c,
+        0x04,
+        0x05,
+        0x03,
+        0x0b,
+        0x06,
+        0x01,
+        0x0e,
+        0x15,
+        0x05,
+        0x3a,
+        0x03,
+        0x11,
+        0x07,
+        0x06,
+        0x05,
+        0x10,
+        0x07,
+        0x57,
+        0x07,
+        0x02,
+        0x07,
+        0x15,
+        0x0d,
+        0x50,
+        0x04,
+        0x43,
+        0x03,
+        0x2d,
+        0x03,
+        0x01,
+        0x04,
+        0x11,
+        0x06,
+        0x0f,
+        0x0c,
+        0x3a,
+        0x04,
+        0x1d,
+        0x25,
+        0x5f,
+        0x20,
+        0x6d,
+        0x04,
+        0x6a,
+        0x25,
+        0x80,
+        0xc8,
+        0x05,
+        0x82,
+        0xb0,
+        0x03,
+        0x1a,
+        0x06,
+        0x82,
+        0xfd,
+        0x03,
+        0x59,
+        0x07,
+        0x15,
+        0x0b,
+        0x17,
+        0x09,
+        0x14,
+        0x0c,
+        0x14,
+        0x0c,
+        0x6a,
+        0x06,
+        0x0a,
+        0x06,
+        0x1a,
+        0x06,
+        0x59,
+        0x07,
+        0x2b,
+        0x05,
+        0x46,
+        0x0a,
+        0x2c,
+        0x04,
+        0x0c,
+        0x04,
+        0x01,
+        0x03,
+        0x31,
+        0x0b,
+        0x2c,
+        0x04,
+        0x1a,
+        0x06,
+        0x0b,
+        0x03,
+        0x80,
+        0xac,
+        0x06,
+        0x0a,
+        0x06,
+        0x21,
+        0x3f,
+        0x4c,
+        0x04,
+        0x2d,
+        0x03,
+        0x74,
+        0x08,
+        0x3c,
+        0x03,
+        0x0f,
+        0x03,
+        0x3c,
+        0x07,
+        0x38,
+        0x08,
+        0x2b,
+        0x05,
+        0x82,
+        0xff,
+        0x11,
+        0x18,
+        0x08,
+        0x2f,
+        0x11,
+        0x2d,
+        0x03,
+        0x20,
+        0x10,
+        0x21,
+        0x0f,
+        0x80,
+        0x8c,
+        0x04,
+        0x82,
+        0x97,
+        0x19,
+        0x0b,
+        0x15,
+        0x88,
+        0x94,
+        0x05,
+        0x2f,
+        0x05,
+        0x3b,
+        0x07,
+        0x02,
+        0x0e,
+        0x18,
+        0x09,
+        0x80,
+        0xb3,
+        0x2d,
+        0x74,
+        0x0c,
+        0x80,
+        0xd6,
+        0x1a,
+        0x0c,
+        0x05,
+        0x80,
+        0xff,
+        0x05,
+        0x80,
+        0xdf,
+        0x0c,
+        0xee,
+        0x0d,
+        0x03,
+        0x84,
+        0x8d,
+        0x03,
+        0x37,
+        0x09,
+        0x81,
+        0x5c,
+        0x14,
+        0x80,
+        0xb8,
+        0x08,
+        0x80,
+        0xcb,
+        0x2a,
+        0x38,
+        0x03,
+        0x0a,
+        0x06,
+        0x38,
+        0x08,
+        0x46,
+        0x08,
+        0x0c,
+        0x06,
+        0x74,
+        0x0b,
+        0x1e,
+        0x03,
+        0x5a,
+        0x04,
+        0x59,
+        0x09,
+        0x80,
+        0x83,
+        0x18,
+        0x1c,
+        0x0a,
+        0x16,
+        0x09,
+        0x4c,
+        0x04,
+        0x80,
+        0x8a,
+        0x06,
+        0xab,
+        0xa4,
+        0x0c,
+        0x17,
+        0x04,
+        0x31,
+        0xa1,
+        0x04,
+        0x81,
+        0xda,
+        0x26,
+        0x07,
+        0x0c,
+        0x05,
+        0x05,
+        0x80,
+        0xa5,
+        0x11,
+        0x81,
+        0x6d,
+        0x10,
+        0x78,
+        0x28,
+        0x2a,
+        0x06,
+        0x4c,
+        0x04,
+        0x80,
+        0x8d,
+        0x04,
+        0x80,
+        0xbe,
+        0x03,
+        0x1b,
+        0x03,
+        0x0f,
+        0x0d,
+    };
+    static constexpr unsigned char normal1[] = {
+        0x5e,
+        0x22,
+        0x7b,
+        0x05,
+        0x03,
+        0x04,
+        0x2d,
+        0x03,
+        0x66,
+        0x03,
+        0x01,
+        0x2f,
+        0x2e,
+        0x80,
+        0x82,
+        0x1d,
+        0x03,
+        0x31,
+        0x0f,
+        0x1c,
+        0x04,
+        0x24,
+        0x09,
+        0x1e,
+        0x05,
+        0x2b,
+        0x05,
+        0x44,
+        0x04,
+        0x0e,
+        0x2a,
+        0x80,
+        0xaa,
+        0x06,
+        0x24,
+        0x04,
+        0x24,
+        0x04,
+        0x28,
+        0x08,
+        0x34,
+        0x0b,
+        0x01,
+        0x80,
+        0x90,
+        0x81,
+        0x37,
+        0x09,
+        0x16,
+        0x0a,
+        0x08,
+        0x80,
+        0x98,
+        0x39,
+        0x03,
+        0x63,
+        0x08,
+        0x09,
+        0x30,
+        0x16,
+        0x05,
+        0x21,
+        0x03,
+        0x1b,
+        0x05,
+        0x01,
+        0x40,
+        0x38,
+        0x04,
+        0x4b,
+        0x05,
+        0x2f,
+        0x04,
+        0x0a,
+        0x07,
+        0x09,
+        0x07,
+        0x40,
+        0x20,
+        0x27,
+        0x04,
+        0x0c,
+        0x09,
+        0x36,
+        0x03,
+        0x3a,
+        0x05,
+        0x1a,
+        0x07,
+        0x04,
+        0x0c,
+        0x07,
+        0x50,
+        0x49,
+        0x37,
+        0x33,
+        0x0d,
+        0x33,
+        0x07,
+        0x2e,
+        0x08,
+        0x0a,
+        0x81,
+        0x26,
+        0x52,
+        0x4e,
+        0x28,
+        0x08,
+        0x2a,
+        0x56,
+        0x1c,
+        0x14,
+        0x17,
+        0x09,
+        0x4e,
+        0x04,
+        0x1e,
+        0x0f,
+        0x43,
+        0x0e,
+        0x19,
+        0x07,
+        0x0a,
+        0x06,
+        0x48,
+        0x08,
+        0x27,
+        0x09,
+        0x75,
+        0x0b,
+        0x3f,
+        0x41,
+        0x2a,
+        0x06,
+        0x3b,
+        0x05,
+        0x0a,
+        0x06,
+        0x51,
+        0x06,
+        0x01,
+        0x05,
+        0x10,
+        0x03,
+        0x05,
+        0x80,
+        0x8b,
+        0x62,
+        0x1e,
+        0x48,
+        0x08,
+        0x0a,
+        0x80,
+        0xa6,
+        0x5e,
+        0x22,
+        0x45,
+        0x0b,
+        0x0a,
+        0x06,
+        0x0d,
+        0x13,
+        0x39,
+        0x07,
+        0x0a,
+        0x36,
+        0x2c,
+        0x04,
+        0x10,
+        0x80,
+        0xc0,
+        0x3c,
+        0x64,
+        0x53,
+        0x0c,
+        0x48,
+        0x09,
+        0x0a,
+        0x46,
+        0x45,
+        0x1b,
+        0x48,
+        0x08,
+        0x53,
+        0x1d,
+        0x39,
+        0x81,
+        0x07,
+        0x46,
+        0x0a,
+        0x1d,
+        0x03,
+        0x47,
+        0x49,
+        0x37,
+        0x03,
+        0x0e,
+        0x08,
+        0x0a,
+        0x06,
+        0x39,
+        0x07,
+        0x0a,
+        0x81,
+        0x36,
+        0x19,
+        0x80,
+        0xb7,
+        0x01,
+        0x0f,
+        0x32,
+        0x0d,
+        0x83,
+        0x9b,
+        0x66,
+        0x75,
+        0x0b,
+        0x80,
+        0xc4,
+        0x8a,
+        0xbc,
+        0x84,
+        0x2f,
+        0x8f,
+        0xd1,
+        0x82,
+        0x47,
+        0xa1,
+        0xb9,
+        0x82,
+        0x39,
+        0x07,
+        0x2a,
+        0x04,
+        0x02,
+        0x60,
+        0x26,
+        0x0a,
+        0x46,
+        0x0a,
+        0x28,
+        0x05,
+        0x13,
+        0x82,
+        0xb0,
+        0x5b,
+        0x65,
+        0x4b,
+        0x04,
+        0x39,
+        0x07,
+        0x11,
+        0x40,
+        0x05,
+        0x0b,
+        0x02,
+        0x0e,
+        0x97,
+        0xf8,
+        0x08,
+        0x84,
+        0xd6,
+        0x2a,
+        0x09,
+        0xa2,
+        0xf7,
+        0x81,
+        0x1f,
+        0x31,
+        0x03,
+        0x11,
+        0x04,
+        0x08,
+        0x81,
+        0x8c,
+        0x89,
+        0x04,
+        0x6b,
+        0x05,
+        0x0d,
+        0x03,
+        0x09,
+        0x07,
+        0x10,
+        0x93,
+        0x60,
+        0x80,
+        0xf6,
+        0x0a,
+        0x73,
+        0x08,
+        0x6e,
+        0x17,
+        0x46,
+        0x80,
+        0x9a,
+        0x14,
+        0x0c,
+        0x57,
+        0x09,
+        0x19,
+        0x80,
+        0x87,
+        0x81,
+        0x47,
+        0x03,
+        0x85,
+        0x42,
+        0x0f,
+        0x15,
+        0x85,
+        0x50,
+        0x2b,
+        0x80,
+        0xd5,
+        0x2d,
+        0x03,
+        0x1a,
+        0x04,
+        0x02,
+        0x81,
+        0x70,
+        0x3a,
+        0x05,
+        0x01,
+        0x85,
+        0x00,
+        0x80,
+        0xd7,
+        0x29,
+        0x4c,
+        0x04,
+        0x0a,
+        0x04,
+        0x02,
+        0x83,
+        0x11,
+        0x44,
+        0x4c,
+        0x3d,
+        0x80,
+        0xc2,
+        0x3c,
+        0x06,
+        0x01,
+        0x04,
+        0x55,
+        0x05,
+        0x1b,
+        0x34,
+        0x02,
+        0x81,
+        0x0e,
+        0x2c,
+        0x04,
+        0x64,
+        0x0c,
+        0x56,
+        0x0a,
+        0x80,
+        0xae,
+        0x38,
+        0x1d,
+        0x0d,
+        0x2c,
+        0x04,
+        0x09,
+        0x07,
+        0x02,
+        0x0e,
+        0x06,
+        0x80,
+        0x9a,
+        0x83,
+        0xd8,
+        0x08,
+        0x0d,
+        0x03,
+        0x0d,
+        0x03,
+        0x74,
+        0x0c,
+        0x59,
+        0x07,
+        0x0c,
+        0x14,
+        0x0c,
+        0x04,
+        0x38,
+        0x08,
+        0x0a,
+        0x06,
+        0x28,
+        0x08,
+        0x22,
+        0x4e,
+        0x81,
+        0x54,
+        0x0c,
+        0x15,
+        0x03,
+        0x03,
+        0x05,
+        0x07,
+        0x09,
+        0x19,
+        0x07,
+        0x07,
+        0x09,
+        0x03,
+        0x0d,
+        0x07,
+        0x29,
+        0x80,
+        0xcb,
+        0x25,
+        0x0a,
+        0x84,
+        0x06,
+    };
+    auto lower = static_cast<uint16_t>(cp);
+    if (cp < 0x10000)
+    {
+        return is_printable(lower, singletons0, sizeof(singletons0) / sizeof(*singletons0), singletons0_lower, normal0, sizeof(normal0));
+    }
+    if (cp < 0x20000)
+    {
+        return is_printable(lower, singletons1, sizeof(singletons1) / sizeof(*singletons1), singletons1_lower, normal1, sizeof(normal1));
+    }
+    if (0x2a6de <= cp && cp < 0x2a700)
+        return false;
+    if (0x2b735 <= cp && cp < 0x2b740)
+        return false;
+    if (0x2b81e <= cp && cp < 0x2b820)
+        return false;
+    if (0x2cea2 <= cp && cp < 0x2ceb0)
+        return false;
+    if (0x2ebe1 <= cp && cp < 0x2f800)
+        return false;
+    if (0x2fa1e <= cp && cp < 0x30000)
+        return false;
+    if (0x3134b <= cp && cp < 0xe0100)
+        return false;
+    if (0xe01f0 <= cp && cp < 0x110000)
+        return false;
+    return cp < 0x110000;
+}
+
+} // namespace detail
+
+FMT_END_NAMESPACE
+
+#endif // FMT_FORMAT_INL_H_
diff --git a/3rdparty/spdlog/src/include/spdlog/fmt/bundled/format.h b/3rdparty/spdlog/src/include/spdlog/fmt/bundled/format.h
new file mode 100644
index 00000000..5c1bee4a
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/fmt/bundled/format.h
@@ -0,0 +1,4771 @@
+/*
+  Formatting library for C++
+
+  Copyright (c) 2012 - present, Victor Zverovich
+
+  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.
+
+  --- Optional exception to the license ---
+
+  As an exception, if, as a result of your compiling your source code, portions
+  of this Software are embedded into a machine-executable object form of such
+  source code, you may redistribute such embedded portions in such object form
+  without including the above copyright and permission notices.
+ */
+
+#ifndef FMT_FORMAT_H_
+#define FMT_FORMAT_H_
+
+#include <cmath>        // std::signbit
+#include <cstdint>      // uint32_t
+#include <cstring>      // std::memcpy
+#include <limits>       // std::numeric_limits
+#include <memory>       // std::uninitialized_copy
+#include <stdexcept>    // std::runtime_error
+#include <system_error> // std::system_error
+
+#ifdef __cpp_lib_bit_cast
+#    include <bit> // std::bitcast
+#endif
+
+#include "core.h"
+
+#if FMT_GCC_VERSION
+#    define FMT_GCC_VISIBILITY_HIDDEN __attribute__((visibility("hidden")))
+#else
+#    define FMT_GCC_VISIBILITY_HIDDEN
+#endif
+
+#ifdef __NVCC__
+#    define FMT_CUDA_VERSION (__CUDACC_VER_MAJOR__ * 100 + __CUDACC_VER_MINOR__)
+#else
+#    define FMT_CUDA_VERSION 0
+#endif
+
+#ifdef __has_builtin
+#    define FMT_HAS_BUILTIN(x) __has_builtin(x)
+#else
+#    define FMT_HAS_BUILTIN(x) 0
+#endif
+
+#if FMT_GCC_VERSION || FMT_CLANG_VERSION
+#    define FMT_NOINLINE __attribute__((noinline))
+#else
+#    define FMT_NOINLINE
+#endif
+
+#if FMT_MSC_VERSION
+#    define FMT_MSC_DEFAULT = default
+#else
+#    define FMT_MSC_DEFAULT
+#endif
+
+#ifndef FMT_THROW
+#    if FMT_EXCEPTIONS
+#        if FMT_MSC_VERSION || defined(__NVCC__)
+FMT_BEGIN_NAMESPACE
+namespace detail {
+template<typename Exception>
+inline void do_throw(const Exception &x)
+{
+    // Silence unreachable code warnings in MSVC and NVCC because these
+    // are nearly impossible to fix in a generic code.
+    volatile bool b = true;
+    if (b)
+        throw x;
+}
+} // namespace detail
+FMT_END_NAMESPACE
+#            define FMT_THROW(x) detail::do_throw(x)
+#        else
+#            define FMT_THROW(x) throw x
+#        endif
+#    else
+#        define FMT_THROW(x)                                                                                                               \
+            do                                                                                                                             \
+            {                                                                                                                              \
+                FMT_ASSERT(false, (x).what());                                                                                             \
+            } while (false)
+#    endif
+#endif
+
+#if FMT_EXCEPTIONS
+#    define FMT_TRY try
+#    define FMT_CATCH(x) catch (x)
+#else
+#    define FMT_TRY if (true)
+#    define FMT_CATCH(x) if (false)
+#endif
+
+#ifndef FMT_MAYBE_UNUSED
+#    if FMT_HAS_CPP17_ATTRIBUTE(maybe_unused)
+#        define FMT_MAYBE_UNUSED [[maybe_unused]]
+#    else
+#        define FMT_MAYBE_UNUSED
+#    endif
+#endif
+
+#ifndef FMT_USE_USER_DEFINED_LITERALS
+// EDG based compilers (Intel, NVIDIA, Elbrus, etc), GCC and MSVC support UDLs.
+#    if (FMT_HAS_FEATURE(cxx_user_literals) || FMT_GCC_VERSION >= 407 || FMT_MSC_VERSION >= 1900) &&                                       \
+        (!defined(__EDG_VERSION__) || __EDG_VERSION__ >= /* UDL feature */ 480)
+#        define FMT_USE_USER_DEFINED_LITERALS 1
+#    else
+#        define FMT_USE_USER_DEFINED_LITERALS 0
+#    endif
+#endif
+
+// Defining FMT_REDUCE_INT_INSTANTIATIONS to 1, will reduce the number of
+// integer formatter template instantiations to just one by only using the
+// largest integer type. This results in a reduction in binary size but will
+// cause a decrease in integer formatting performance.
+#if !defined(FMT_REDUCE_INT_INSTANTIATIONS)
+#    define FMT_REDUCE_INT_INSTANTIATIONS 0
+#endif
+
+// __builtin_clz is broken in clang with Microsoft CodeGen:
+// https://github.com/fmtlib/fmt/issues/519.
+#if !FMT_MSC_VERSION
+#    if FMT_HAS_BUILTIN(__builtin_clz) || FMT_GCC_VERSION || FMT_ICC_VERSION
+#        define FMT_BUILTIN_CLZ(n) __builtin_clz(n)
+#    endif
+#    if FMT_HAS_BUILTIN(__builtin_clzll) || FMT_GCC_VERSION || FMT_ICC_VERSION
+#        define FMT_BUILTIN_CLZLL(n) __builtin_clzll(n)
+#    endif
+#endif
+
+// __builtin_ctz is broken in Intel Compiler Classic on Windows:
+// https://github.com/fmtlib/fmt/issues/2510.
+#ifndef __ICL
+#    if FMT_HAS_BUILTIN(__builtin_ctz) || FMT_GCC_VERSION || FMT_ICC_VERSION || defined(__NVCOMPILER)
+#        define FMT_BUILTIN_CTZ(n) __builtin_ctz(n)
+#    endif
+#    if FMT_HAS_BUILTIN(__builtin_ctzll) || FMT_GCC_VERSION || FMT_ICC_VERSION || defined(__NVCOMPILER)
+#        define FMT_BUILTIN_CTZLL(n) __builtin_ctzll(n)
+#    endif
+#endif
+
+#if FMT_MSC_VERSION
+#    include <intrin.h> // _BitScanReverse[64], _BitScanForward[64], _umul128
+#endif
+
+// Some compilers masquerade as both MSVC and GCC-likes or otherwise support
+// __builtin_clz and __builtin_clzll, so only define FMT_BUILTIN_CLZ using the
+// MSVC intrinsics if the clz and clzll builtins are not available.
+#if FMT_MSC_VERSION && !defined(FMT_BUILTIN_CLZLL) && !defined(FMT_BUILTIN_CTZLL)
+FMT_BEGIN_NAMESPACE
+namespace detail {
+// Avoid Clang with Microsoft CodeGen's -Wunknown-pragmas warning.
+#    if !defined(__clang__)
+#        pragma intrinsic(_BitScanForward)
+#        pragma intrinsic(_BitScanReverse)
+#        if defined(_WIN64)
+#            pragma intrinsic(_BitScanForward64)
+#            pragma intrinsic(_BitScanReverse64)
+#        endif
+#    endif
+
+inline auto clz(uint32_t x) -> int
+{
+    unsigned long r = 0;
+    _BitScanReverse(&r, x);
+    FMT_ASSERT(x != 0, "");
+    // Static analysis complains about using uninitialized data
+    // "r", but the only way that can happen is if "x" is 0,
+    // which the callers guarantee to not happen.
+    FMT_MSC_WARNING(suppress : 6102)
+    return 31 ^ static_cast<int>(r);
+}
+#    define FMT_BUILTIN_CLZ(n) detail::clz(n)
+
+inline auto clzll(uint64_t x) -> int
+{
+    unsigned long r = 0;
+#    ifdef _WIN64
+    _BitScanReverse64(&r, x);
+#    else
+    // Scan the high 32 bits.
+    if (_BitScanReverse(&r, static_cast<uint32_t>(x >> 32)))
+        return 63 ^ (r + 32);
+    // Scan the low 32 bits.
+    _BitScanReverse(&r, static_cast<uint32_t>(x));
+#    endif
+    FMT_ASSERT(x != 0, "");
+    FMT_MSC_WARNING(suppress : 6102) // Suppress a bogus static analysis warning.
+    return 63 ^ static_cast<int>(r);
+}
+#    define FMT_BUILTIN_CLZLL(n) detail::clzll(n)
+
+inline auto ctz(uint32_t x) -> int
+{
+    unsigned long r = 0;
+    _BitScanForward(&r, x);
+    FMT_ASSERT(x != 0, "");
+    FMT_MSC_WARNING(suppress : 6102) // Suppress a bogus static analysis warning.
+    return static_cast<int>(r);
+}
+#    define FMT_BUILTIN_CTZ(n) detail::ctz(n)
+
+inline auto ctzll(uint64_t x) -> int
+{
+    unsigned long r = 0;
+    FMT_ASSERT(x != 0, "");
+    FMT_MSC_WARNING(suppress : 6102) // Suppress a bogus static analysis warning.
+#    ifdef _WIN64
+    _BitScanForward64(&r, x);
+#    else
+    // Scan the low 32 bits.
+    if (_BitScanForward(&r, static_cast<uint32_t>(x)))
+        return static_cast<int>(r);
+    // Scan the high 32 bits.
+    _BitScanForward(&r, static_cast<uint32_t>(x >> 32));
+    r += 32;
+#    endif
+    return static_cast<int>(r);
+}
+#    define FMT_BUILTIN_CTZLL(n) detail::ctzll(n)
+} // namespace detail
+FMT_END_NAMESPACE
+#endif
+
+FMT_BEGIN_NAMESPACE
+namespace detail {
+
+FMT_CONSTEXPR inline void abort_fuzzing_if(bool condition)
+{
+    ignore_unused(condition);
+#ifdef FMT_FUZZ
+    if (condition)
+        throw std::runtime_error("fuzzing limit reached");
+#endif
+}
+
+template<typename CharT, CharT... C>
+struct string_literal
+{
+    static constexpr CharT value[sizeof...(C)] = {C...};
+    constexpr operator basic_string_view<CharT>() const
+    {
+        return {value, sizeof...(C)};
+    }
+};
+
+#if FMT_CPLUSPLUS < 201703L
+template<typename CharT, CharT... C>
+constexpr CharT string_literal<CharT, C...>::value[sizeof...(C)];
+#endif
+
+template<typename Streambuf>
+class formatbuf : public Streambuf
+{
+private:
+    using char_type = typename Streambuf::char_type;
+    using streamsize = decltype(std::declval<Streambuf>().sputn(nullptr, 0));
+    using int_type = typename Streambuf::int_type;
+    using traits_type = typename Streambuf::traits_type;
+
+    buffer<char_type> &buffer_;
+
+public:
+    explicit formatbuf(buffer<char_type> &buf)
+        : buffer_(buf)
+    {}
+
+protected:
+    // The put area is always empty. This makes the implementation simpler and has
+    // the advantage that the streambuf and the buffer are always in sync and
+    // sputc never writes into uninitialized memory. A disadvantage is that each
+    // call to sputc always results in a (virtual) call to overflow. There is no
+    // disadvantage here for sputn since this always results in a call to xsputn.
+
+    auto overflow(int_type ch) -> int_type override
+    {
+        if (!traits_type::eq_int_type(ch, traits_type::eof()))
+            buffer_.push_back(static_cast<char_type>(ch));
+        return ch;
+    }
+
+    auto xsputn(const char_type *s, streamsize count) -> streamsize override
+    {
+        buffer_.append(s, s + count);
+        return count;
+    }
+};
+
+// Implementation of std::bit_cast for pre-C++20.
+template<typename To, typename From, FMT_ENABLE_IF(sizeof(To) == sizeof(From))>
+FMT_CONSTEXPR20 auto bit_cast(const From &from) -> To
+{
+#ifdef __cpp_lib_bit_cast
+    if (is_constant_evaluated())
+        return std::bit_cast<To>(from);
+#endif
+    auto to = To();
+    // The cast suppresses a bogus -Wclass-memaccess on GCC.
+    std::memcpy(static_cast<void *>(&to), &from, sizeof(to));
+    return to;
+}
+
+inline auto is_big_endian() -> bool
+{
+#ifdef _WIN32
+    return false;
+#elif defined(__BIG_ENDIAN__)
+    return true;
+#elif defined(__BYTE_ORDER__) && defined(__ORDER_BIG_ENDIAN__)
+    return __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__;
+#else
+    struct bytes
+    {
+        char data[sizeof(int)];
+    };
+    return bit_cast<bytes>(1).data[0] == 0;
+#endif
+}
+
+class uint128_fallback
+{
+private:
+    uint64_t lo_, hi_;
+
+    friend uint128_fallback umul128(uint64_t x, uint64_t y) noexcept;
+
+public:
+    constexpr uint128_fallback(uint64_t hi, uint64_t lo)
+        : lo_(lo)
+        , hi_(hi)
+    {}
+    constexpr uint128_fallback(uint64_t value = 0)
+        : lo_(value)
+        , hi_(0)
+    {}
+
+    constexpr uint64_t high() const noexcept
+    {
+        return hi_;
+    }
+    constexpr uint64_t low() const noexcept
+    {
+        return lo_;
+    }
+
+    template<typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
+    constexpr explicit operator T() const
+    {
+        return static_cast<T>(lo_);
+    }
+
+    friend constexpr auto operator==(const uint128_fallback &lhs, const uint128_fallback &rhs) -> bool
+    {
+        return lhs.hi_ == rhs.hi_ && lhs.lo_ == rhs.lo_;
+    }
+    friend constexpr auto operator!=(const uint128_fallback &lhs, const uint128_fallback &rhs) -> bool
+    {
+        return !(lhs == rhs);
+    }
+    friend constexpr auto operator>(const uint128_fallback &lhs, const uint128_fallback &rhs) -> bool
+    {
+        return lhs.hi_ != rhs.hi_ ? lhs.hi_ > rhs.hi_ : lhs.lo_ > rhs.lo_;
+    }
+    friend constexpr auto operator|(const uint128_fallback &lhs, const uint128_fallback &rhs) -> uint128_fallback
+    {
+        return {lhs.hi_ | rhs.hi_, lhs.lo_ | rhs.lo_};
+    }
+    friend constexpr auto operator&(const uint128_fallback &lhs, const uint128_fallback &rhs) -> uint128_fallback
+    {
+        return {lhs.hi_ & rhs.hi_, lhs.lo_ & rhs.lo_};
+    }
+    friend auto operator+(const uint128_fallback &lhs, const uint128_fallback &rhs) -> uint128_fallback
+    {
+        auto result = uint128_fallback(lhs);
+        result += rhs;
+        return result;
+    }
+    friend auto operator*(const uint128_fallback &lhs, uint32_t rhs) -> uint128_fallback
+    {
+        FMT_ASSERT(lhs.hi_ == 0, "");
+        uint64_t hi = (lhs.lo_ >> 32) * rhs;
+        uint64_t lo = (lhs.lo_ & ~uint32_t()) * rhs;
+        uint64_t new_lo = (hi << 32) + lo;
+        return {(hi >> 32) + (new_lo < lo ? 1 : 0), new_lo};
+    }
+    friend auto operator-(const uint128_fallback &lhs, uint64_t rhs) -> uint128_fallback
+    {
+        return {lhs.hi_ - (lhs.lo_ < rhs ? 1 : 0), lhs.lo_ - rhs};
+    }
+    FMT_CONSTEXPR auto operator>>(int shift) const -> uint128_fallback
+    {
+        if (shift == 64)
+            return {0, hi_};
+        if (shift > 64)
+            return uint128_fallback(0, hi_) >> (shift - 64);
+        return {hi_ >> shift, (hi_ << (64 - shift)) | (lo_ >> shift)};
+    }
+    FMT_CONSTEXPR auto operator<<(int shift) const -> uint128_fallback
+    {
+        if (shift == 64)
+            return {lo_, 0};
+        if (shift > 64)
+            return uint128_fallback(lo_, 0) << (shift - 64);
+        return {hi_ << shift | (lo_ >> (64 - shift)), (lo_ << shift)};
+    }
+    FMT_CONSTEXPR auto operator>>=(int shift) -> uint128_fallback &
+    {
+        return *this = *this >> shift;
+    }
+    FMT_CONSTEXPR void operator+=(uint128_fallback n)
+    {
+        uint64_t new_lo = lo_ + n.lo_;
+        uint64_t new_hi = hi_ + n.hi_ + (new_lo < lo_ ? 1 : 0);
+        FMT_ASSERT(new_hi >= hi_, "");
+        lo_ = new_lo;
+        hi_ = new_hi;
+    }
+
+    FMT_CONSTEXPR20 uint128_fallback &operator+=(uint64_t n) noexcept
+    {
+        if (is_constant_evaluated())
+        {
+            lo_ += n;
+            hi_ += (lo_ < n ? 1 : 0);
+            return *this;
+        }
+#if FMT_HAS_BUILTIN(__builtin_addcll) && !defined(__ibmxl__)
+        unsigned long long carry;
+        lo_ = __builtin_addcll(lo_, n, 0, &carry);
+        hi_ += carry;
+#elif FMT_HAS_BUILTIN(__builtin_ia32_addcarryx_u64) && !defined(__ibmxl__)
+        unsigned long long result;
+        auto carry = __builtin_ia32_addcarryx_u64(0, lo_, n, &result);
+        lo_ = result;
+        hi_ += carry;
+#elif defined(_MSC_VER) && defined(_M_X64)
+        auto carry = _addcarry_u64(0, lo_, n, &lo_);
+        _addcarry_u64(carry, hi_, 0, &hi_);
+#else
+        lo_ += n;
+        hi_ += (lo_ < n ? 1 : 0);
+#endif
+        return *this;
+    }
+};
+
+using uint128_t = conditional_t<FMT_USE_INT128, uint128_opt, uint128_fallback>;
+
+#ifdef UINTPTR_MAX
+using uintptr_t = ::uintptr_t;
+#else
+using uintptr_t = uint128_t;
+#endif
+
+// Returns the largest possible value for type T. Same as
+// std::numeric_limits<T>::max() but shorter and not affected by the max macro.
+template<typename T>
+constexpr auto max_value() -> T
+{
+    return (std::numeric_limits<T>::max)();
+}
+template<typename T>
+constexpr auto num_bits() -> int
+{
+    return std::numeric_limits<T>::digits;
+}
+// std::numeric_limits<T>::digits may return 0 for 128-bit ints.
+template<>
+constexpr auto num_bits<int128_opt>() -> int
+{
+    return 128;
+}
+template<>
+constexpr auto num_bits<uint128_t>() -> int
+{
+    return 128;
+}
+
+// A heterogeneous bit_cast used for converting 96-bit long double to uint128_t
+// and 128-bit pointers to uint128_fallback.
+template<typename To, typename From, FMT_ENABLE_IF(sizeof(To) > sizeof(From))>
+inline auto bit_cast(const From &from) -> To
+{
+    constexpr auto size = static_cast<int>(sizeof(From) / sizeof(unsigned));
+    struct data_t
+    {
+        unsigned value[static_cast<unsigned>(size)];
+    } data = bit_cast<data_t>(from);
+    auto result = To();
+    if (const_check(is_big_endian()))
+    {
+        for (int i = 0; i < size; ++i)
+            result = (result << num_bits<unsigned>()) | data.value[i];
+    }
+    else
+    {
+        for (int i = size - 1; i >= 0; --i)
+            result = (result << num_bits<unsigned>()) | data.value[i];
+    }
+    return result;
+}
+
+FMT_INLINE void assume(bool condition)
+{
+    (void)condition;
+#if FMT_HAS_BUILTIN(__builtin_assume) && !FMT_ICC_VERSION
+    __builtin_assume(condition);
+#endif
+}
+
+// An approximation of iterator_t for pre-C++20 systems.
+template<typename T>
+using iterator_t = decltype(std::begin(std::declval<T &>()));
+template<typename T>
+using sentinel_t = decltype(std::end(std::declval<T &>()));
+
+// A workaround for std::string not having mutable data() until C++17.
+template<typename Char>
+inline auto get_data(std::basic_string<Char> &s) -> Char *
+{
+    return &s[0];
+}
+template<typename Container>
+inline auto get_data(Container &c) -> typename Container::value_type *
+{
+    return c.data();
+}
+
+#if defined(_SECURE_SCL) && _SECURE_SCL
+// Make a checked iterator to avoid MSVC warnings.
+template<typename T>
+using checked_ptr = stdext::checked_array_iterator<T *>;
+template<typename T>
+constexpr auto make_checked(T *p, size_t size) -> checked_ptr<T>
+{
+    return {p, size};
+}
+#else
+template<typename T>
+using checked_ptr = T *;
+template<typename T>
+constexpr auto make_checked(T *p, size_t) -> T *
+{
+    return p;
+}
+#endif
+
+// Attempts to reserve space for n extra characters in the output range.
+// Returns a pointer to the reserved range or a reference to it.
+template<typename Container, FMT_ENABLE_IF(is_contiguous<Container>::value)>
+#if FMT_CLANG_VERSION >= 307 && !FMT_ICC_VERSION
+__attribute__((no_sanitize("undefined")))
+#endif
+inline auto
+reserve(std::back_insert_iterator<Container> it, size_t n) -> checked_ptr<typename Container::value_type>
+{
+    Container &c = get_container(it);
+    size_t size = c.size();
+    c.resize(size + n);
+    return make_checked(get_data(c) + size, n);
+}
+
+template<typename T>
+inline auto reserve(buffer_appender<T> it, size_t n) -> buffer_appender<T>
+{
+    buffer<T> &buf = get_container(it);
+    buf.try_reserve(buf.size() + n);
+    return it;
+}
+
+template<typename Iterator>
+constexpr auto reserve(Iterator &it, size_t) -> Iterator &
+{
+    return it;
+}
+
+template<typename OutputIt>
+using reserve_iterator = remove_reference_t<decltype(reserve(std::declval<OutputIt &>(), 0))>;
+
+template<typename T, typename OutputIt>
+constexpr auto to_pointer(OutputIt, size_t) -> T *
+{
+    return nullptr;
+}
+template<typename T>
+auto to_pointer(buffer_appender<T> it, size_t n) -> T *
+{
+    buffer<T> &buf = get_container(it);
+    auto size = buf.size();
+    if (buf.capacity() < size + n)
+        return nullptr;
+    buf.try_resize(size + n);
+    return buf.data() + size;
+}
+
+template<typename Container, FMT_ENABLE_IF(is_contiguous<Container>::value)>
+inline auto base_iterator(std::back_insert_iterator<Container> &it, checked_ptr<typename Container::value_type>)
+    -> std::back_insert_iterator<Container>
+{
+    return it;
+}
+
+template<typename Iterator>
+constexpr auto base_iterator(Iterator, Iterator it) -> Iterator
+{
+    return it;
+}
+
+// <algorithm> is spectacularly slow to compile in C++20 so use a simple fill_n
+// instead (#1998).
+template<typename OutputIt, typename Size, typename T>
+FMT_CONSTEXPR auto fill_n(OutputIt out, Size count, const T &value) -> OutputIt
+{
+    for (Size i = 0; i < count; ++i)
+        *out++ = value;
+    return out;
+}
+template<typename T, typename Size>
+FMT_CONSTEXPR20 auto fill_n(T *out, Size count, char value) -> T *
+{
+    if (is_constant_evaluated())
+    {
+        return fill_n<T *, Size, T>(out, count, value);
+    }
+    std::memset(out, value, to_unsigned(count));
+    return out + count;
+}
+
+#ifdef __cpp_char8_t
+using char8_type = char8_t;
+#else
+enum char8_type : unsigned char
+{
+};
+#endif
+
+template<typename OutChar, typename InputIt, typename OutputIt>
+FMT_CONSTEXPR FMT_NOINLINE auto copy_str_noinline(InputIt begin, InputIt end, OutputIt out) -> OutputIt
+{
+    return copy_str<OutChar>(begin, end, out);
+}
+
+// A public domain branchless UTF-8 decoder by Christopher Wellons:
+// https://github.com/skeeto/branchless-utf8
+/* Decode the next character, c, from s, reporting errors in e.
+ *
+ * Since this is a branchless decoder, four bytes will be read from the
+ * buffer regardless of the actual length of the next character. This
+ * means the buffer _must_ have at least three bytes of zero padding
+ * following the end of the data stream.
+ *
+ * Errors are reported in e, which will be non-zero if the parsed
+ * character was somehow invalid: invalid byte sequence, non-canonical
+ * encoding, or a surrogate half.
+ *
+ * The function returns a pointer to the next character. When an error
+ * occurs, this pointer will be a guess that depends on the particular
+ * error, but it will always advance at least one byte.
+ */
+FMT_CONSTEXPR inline auto utf8_decode(const char *s, uint32_t *c, int *e) -> const char *
+{
+    constexpr const int masks[] = {0x00, 0x7f, 0x1f, 0x0f, 0x07};
+    constexpr const uint32_t mins[] = {4194304, 0, 128, 2048, 65536};
+    constexpr const int shiftc[] = {0, 18, 12, 6, 0};
+    constexpr const int shifte[] = {0, 6, 4, 2, 0};
+
+    int len = code_point_length_impl(*s);
+    // Compute the pointer to the next character early so that the next
+    // iteration can start working on the next character. Neither Clang
+    // nor GCC figure out this reordering on their own.
+    const char *next = s + len + !len;
+
+    using uchar = unsigned char;
+
+    // Assume a four-byte character and load four bytes. Unused bits are
+    // shifted out.
+    *c = uint32_t(uchar(s[0]) & masks[len]) << 18;
+    *c |= uint32_t(uchar(s[1]) & 0x3f) << 12;
+    *c |= uint32_t(uchar(s[2]) & 0x3f) << 6;
+    *c |= uint32_t(uchar(s[3]) & 0x3f) << 0;
+    *c >>= shiftc[len];
+
+    // Accumulate the various error conditions.
+    *e = (*c < mins[len]) << 6;      // non-canonical encoding
+    *e |= ((*c >> 11) == 0x1b) << 7; // surrogate half?
+    *e |= (*c > 0x10FFFF) << 8;      // out of range?
+    *e |= (uchar(s[1]) & 0xc0) >> 2;
+    *e |= (uchar(s[2]) & 0xc0) >> 4;
+    *e |= uchar(s[3]) >> 6;
+    *e ^= 0x2a; // top two bits of each tail byte correct?
+    *e >>= shifte[len];
+
+    return next;
+}
+
+constexpr uint32_t invalid_code_point = ~uint32_t();
+
+// Invokes f(cp, sv) for every code point cp in s with sv being the string view
+// corresponding to the code point. cp is invalid_code_point on error.
+template<typename F>
+FMT_CONSTEXPR void for_each_codepoint(string_view s, F f)
+{
+    auto decode = [f](const char *buf_ptr, const char *ptr) {
+        auto cp = uint32_t();
+        auto error = 0;
+        auto end = utf8_decode(buf_ptr, &cp, &error);
+        bool result = f(error ? invalid_code_point : cp, string_view(ptr, error ? 1 : to_unsigned(end - buf_ptr)));
+        return result ? (error ? buf_ptr + 1 : end) : nullptr;
+    };
+    auto p = s.data();
+    const size_t block_size = 4; // utf8_decode always reads blocks of 4 chars.
+    if (s.size() >= block_size)
+    {
+        for (auto end = p + s.size() - block_size + 1; p < end;)
+        {
+            p = decode(p, p);
+            if (!p)
+                return;
+        }
+    }
+    if (auto num_chars_left = s.data() + s.size() - p)
+    {
+        char buf[2 * block_size - 1] = {};
+        copy_str<char>(p, p + num_chars_left, buf);
+        const char *buf_ptr = buf;
+        do
+        {
+            auto end = decode(buf_ptr, p);
+            if (!end)
+                return;
+            p += end - buf_ptr;
+            buf_ptr = end;
+        } while (buf_ptr - buf < num_chars_left);
+    }
+}
+
+template<typename Char>
+inline auto compute_width(basic_string_view<Char> s) -> size_t
+{
+    return s.size();
+}
+
+// Computes approximate display width of a UTF-8 string.
+FMT_CONSTEXPR inline size_t compute_width(string_view s)
+{
+    size_t num_code_points = 0;
+    // It is not a lambda for compatibility with C++14.
+    struct count_code_points
+    {
+        size_t *count;
+        FMT_CONSTEXPR auto operator()(uint32_t cp, string_view) const -> bool
+        {
+            *count += detail::to_unsigned(1 + (cp >= 0x1100 && (cp <= 0x115f ||    // Hangul Jamo init. consonants
+                                                                   cp == 0x2329 || // LEFT-POINTING ANGLE BRACKET
+                                                                   cp == 0x232a || // RIGHT-POINTING ANGLE BRACKET
+                                                                   // CJK ... Yi except IDEOGRAPHIC HALF FILL SPACE:
+                                                                   (cp >= 0x2e80 && cp <= 0xa4cf && cp != 0x303f) ||
+                                                                   (cp >= 0xac00 && cp <= 0xd7a3) ||   // Hangul Syllables
+                                                                   (cp >= 0xf900 && cp <= 0xfaff) ||   // CJK Compatibility Ideographs
+                                                                   (cp >= 0xfe10 && cp <= 0xfe19) ||   // Vertical Forms
+                                                                   (cp >= 0xfe30 && cp <= 0xfe6f) ||   // CJK Compatibility Forms
+                                                                   (cp >= 0xff00 && cp <= 0xff60) ||   // Fullwidth Forms
+                                                                   (cp >= 0xffe0 && cp <= 0xffe6) ||   // Fullwidth Forms
+                                                                   (cp >= 0x20000 && cp <= 0x2fffd) || // CJK
+                                                                   (cp >= 0x30000 && cp <= 0x3fffd) ||
+                                                                   // Miscellaneous Symbols and Pictographs + Emoticons:
+                                                                   (cp >= 0x1f300 && cp <= 0x1f64f) ||
+                                                                   // Supplemental Symbols and Pictographs:
+                                                                   (cp >= 0x1f900 && cp <= 0x1f9ff))));
+            return true;
+        }
+    };
+    for_each_codepoint(s, count_code_points{&num_code_points});
+    return num_code_points;
+}
+
+inline auto compute_width(basic_string_view<char8_type> s) -> size_t
+{
+    return compute_width(string_view(reinterpret_cast<const char *>(s.data()), s.size()));
+}
+
+template<typename Char>
+inline auto code_point_index(basic_string_view<Char> s, size_t n) -> size_t
+{
+    size_t size = s.size();
+    return n < size ? n : size;
+}
+
+// Calculates the index of the nth code point in a UTF-8 string.
+inline auto code_point_index(string_view s, size_t n) -> size_t
+{
+    const char *data = s.data();
+    size_t num_code_points = 0;
+    for (size_t i = 0, size = s.size(); i != size; ++i)
+    {
+        if ((data[i] & 0xc0) != 0x80 && ++num_code_points > n)
+            return i;
+    }
+    return s.size();
+}
+
+inline auto code_point_index(basic_string_view<char8_type> s, size_t n) -> size_t
+{
+    return code_point_index(string_view(reinterpret_cast<const char *>(s.data()), s.size()), n);
+}
+
+#ifndef FMT_USE_FLOAT128
+#    ifdef __SIZEOF_FLOAT128__
+#        define FMT_USE_FLOAT128 1
+#    else
+#        define FMT_USE_FLOAT128 0
+#    endif
+#endif
+#if FMT_USE_FLOAT128
+using float128 = __float128;
+#else
+using float128 = void;
+#endif
+template<typename T>
+using is_float128 = std::is_same<T, float128>;
+
+template<typename T>
+using is_floating_point = bool_constant<std::is_floating_point<T>::value || is_float128<T>::value>;
+
+template<typename T, bool = std::is_floating_point<T>::value>
+struct is_fast_float : bool_constant<std::numeric_limits<T>::is_iec559 && sizeof(T) <= sizeof(double)>
+{};
+template<typename T>
+struct is_fast_float<T, false> : std::false_type
+{};
+
+template<typename T>
+using is_double_double = bool_constant<std::numeric_limits<T>::digits == 106>;
+
+#ifndef FMT_USE_FULL_CACHE_DRAGONBOX
+#    define FMT_USE_FULL_CACHE_DRAGONBOX 0
+#endif
+
+template<typename T>
+template<typename U>
+void buffer<T>::append(const U *begin, const U *end)
+{
+    while (begin != end)
+    {
+        auto count = to_unsigned(end - begin);
+        try_reserve(size_ + count);
+        auto free_cap = capacity_ - size_;
+        if (free_cap < count)
+            count = free_cap;
+        std::uninitialized_copy_n(begin, count, make_checked(ptr_ + size_, count));
+        size_ += count;
+        begin += count;
+    }
+}
+
+template<typename T, typename Enable = void>
+struct is_locale : std::false_type
+{};
+template<typename T>
+struct is_locale<T, void_t<decltype(T::classic())>> : std::true_type
+{};
+} // namespace detail
+
+FMT_MODULE_EXPORT_BEGIN
+
+// The number of characters to store in the basic_memory_buffer object itself
+// to avoid dynamic memory allocation.
+enum
+{
+    inline_buffer_size = 500
+};
+
+/**
+  \rst
+  A dynamically growing memory buffer for trivially copyable/constructible types
+  with the first ``SIZE`` elements stored in the object itself.
+
+  You can use the ``memory_buffer`` type alias for ``char`` instead.
+
+  **Example**::
+
+     auto out = fmt::memory_buffer();
+     format_to(std::back_inserter(out), "The answer is {}.", 42);
+
+  This will append the following output to the ``out`` object:
+
+  .. code-block:: none
+
+     The answer is 42.
+
+  The output can be converted to an ``std::string`` with ``to_string(out)``.
+  \endrst
+ */
+template<typename T, size_t SIZE = inline_buffer_size, typename Allocator = std::allocator<T>>
+class basic_memory_buffer final : public detail::buffer<T>
+{
+private:
+    T store_[SIZE];
+
+    // Don't inherit from Allocator avoid generating type_info for it.
+    Allocator alloc_;
+
+    // Deallocate memory allocated by the buffer.
+    FMT_CONSTEXPR20 void deallocate()
+    {
+        T *data = this->data();
+        if (data != store_)
+            alloc_.deallocate(data, this->capacity());
+    }
+
+protected:
+    FMT_CONSTEXPR20 void grow(size_t size) override;
+
+public:
+    using value_type = T;
+    using const_reference = const T &;
+
+    FMT_CONSTEXPR20 explicit basic_memory_buffer(const Allocator &alloc = Allocator())
+        : alloc_(alloc)
+    {
+        this->set(store_, SIZE);
+        if (detail::is_constant_evaluated())
+            detail::fill_n(store_, SIZE, T());
+    }
+    FMT_CONSTEXPR20 ~basic_memory_buffer()
+    {
+        deallocate();
+    }
+
+private:
+    // Move data from other to this buffer.
+    FMT_CONSTEXPR20 void move(basic_memory_buffer &other)
+    {
+        alloc_ = std::move(other.alloc_);
+        T *data = other.data();
+        size_t size = other.size(), capacity = other.capacity();
+        if (data == other.store_)
+        {
+            this->set(store_, capacity);
+            detail::copy_str<T>(other.store_, other.store_ + size, detail::make_checked(store_, capacity));
+        }
+        else
+        {
+            this->set(data, capacity);
+            // Set pointer to the inline array so that delete is not called
+            // when deallocating.
+            other.set(other.store_, 0);
+            other.clear();
+        }
+        this->resize(size);
+    }
+
+public:
+    /**
+      \rst
+      Constructs a :class:`fmt::basic_memory_buffer` object moving the content
+      of the other object to it.
+      \endrst
+     */
+    FMT_CONSTEXPR20 basic_memory_buffer(basic_memory_buffer &&other) noexcept
+    {
+        move(other);
+    }
+
+    /**
+      \rst
+      Moves the content of the other ``basic_memory_buffer`` object to this one.
+      \endrst
+     */
+    auto operator=(basic_memory_buffer &&other) noexcept -> basic_memory_buffer &
+    {
+        FMT_ASSERT(this != &other, "");
+        deallocate();
+        move(other);
+        return *this;
+    }
+
+    // Returns a copy of the allocator associated with this buffer.
+    auto get_allocator() const -> Allocator
+    {
+        return alloc_;
+    }
+
+    /**
+      Resizes the buffer to contain *count* elements. If T is a POD type new
+      elements may not be initialized.
+     */
+    FMT_CONSTEXPR20 void resize(size_t count)
+    {
+        this->try_resize(count);
+    }
+
+    /** Increases the buffer capacity to *new_capacity*. */
+    void reserve(size_t new_capacity)
+    {
+        this->try_reserve(new_capacity);
+    }
+
+    // Directly append data into the buffer
+    using detail::buffer<T>::append;
+    template<typename ContiguousRange>
+    void append(const ContiguousRange &range)
+    {
+        append(range.data(), range.data() + range.size());
+    }
+};
+
+template<typename T, size_t SIZE, typename Allocator>
+FMT_CONSTEXPR20 void basic_memory_buffer<T, SIZE, Allocator>::grow(size_t size)
+{
+    detail::abort_fuzzing_if(size > 5000);
+    const size_t max_size = std::allocator_traits<Allocator>::max_size(alloc_);
+    size_t old_capacity = this->capacity();
+    size_t new_capacity = old_capacity + old_capacity / 2;
+    if (size > new_capacity)
+        new_capacity = size;
+    else if (new_capacity > max_size)
+        new_capacity = size > max_size ? size : max_size;
+    T *old_data = this->data();
+    T *new_data = std::allocator_traits<Allocator>::allocate(alloc_, new_capacity);
+    // The following code doesn't throw, so the raw pointer above doesn't leak.
+    std::uninitialized_copy(old_data, old_data + this->size(), detail::make_checked(new_data, new_capacity));
+    this->set(new_data, new_capacity);
+    // deallocate must not throw according to the standard, but even if it does,
+    // the buffer already uses the new storage and will deallocate it in
+    // destructor.
+    if (old_data != store_)
+        alloc_.deallocate(old_data, old_capacity);
+}
+
+using memory_buffer = basic_memory_buffer<char>;
+
+template<typename T, size_t SIZE, typename Allocator>
+struct is_contiguous<basic_memory_buffer<T, SIZE, Allocator>> : std::true_type
+{};
+
+namespace detail {
+#ifdef _WIN32
+FMT_API bool write_console(std::FILE *f, string_view text);
+#endif
+FMT_API void print(std::FILE *, string_view);
+} // namespace detail
+
+/** A formatting error such as invalid format string. */
+FMT_CLASS_API
+class FMT_API format_error : public std::runtime_error
+{
+public:
+    explicit format_error(const char *message)
+        : std::runtime_error(message)
+    {}
+    explicit format_error(const std::string &message)
+        : std::runtime_error(message)
+    {}
+    format_error(const format_error &) = default;
+    format_error &operator=(const format_error &) = default;
+    format_error(format_error &&) = default;
+    format_error &operator=(format_error &&) = default;
+    ~format_error() noexcept override FMT_MSC_DEFAULT;
+};
+
+namespace detail_exported {
+#if FMT_USE_NONTYPE_TEMPLATE_ARGS
+template<typename Char, size_t N>
+struct fixed_string
+{
+    constexpr fixed_string(const Char (&str)[N])
+    {
+        detail::copy_str<Char, const Char *, Char *>(static_cast<const Char *>(str), str + N, data);
+    }
+    Char data[N] = {};
+};
+#endif
+
+// Converts a compile-time string to basic_string_view.
+template<typename Char, size_t N>
+constexpr auto compile_string_to_view(const Char (&s)[N]) -> basic_string_view<Char>
+{
+    // Remove trailing NUL character if needed. Won't be present if this is used
+    // with a raw character array (i.e. not defined as a string).
+    return {s, N - (std::char_traits<Char>::to_int_type(s[N - 1]) == 0 ? 1 : 0)};
+}
+template<typename Char>
+constexpr auto compile_string_to_view(detail::std_string_view<Char> s) -> basic_string_view<Char>
+{
+    return {s.data(), s.size()};
+}
+} // namespace detail_exported
+
+FMT_BEGIN_DETAIL_NAMESPACE
+
+template<typename T>
+struct is_integral : std::is_integral<T>
+{};
+template<>
+struct is_integral<int128_opt> : std::true_type
+{};
+template<>
+struct is_integral<uint128_t> : std::true_type
+{};
+
+template<typename T>
+using is_signed = std::integral_constant<bool, std::numeric_limits<T>::is_signed || std::is_same<T, int128_opt>::value>;
+
+// Returns true if value is negative, false otherwise.
+// Same as `value < 0` but doesn't produce warnings if T is an unsigned type.
+template<typename T, FMT_ENABLE_IF(is_signed<T>::value)>
+constexpr auto is_negative(T value) -> bool
+{
+    return value < 0;
+}
+template<typename T, FMT_ENABLE_IF(!is_signed<T>::value)>
+constexpr auto is_negative(T) -> bool
+{
+    return false;
+}
+
+template<typename T>
+FMT_CONSTEXPR auto is_supported_floating_point(T) -> bool
+{
+    if (std::is_same<T, float>())
+        return FMT_USE_FLOAT;
+    if (std::is_same<T, double>())
+        return FMT_USE_DOUBLE;
+    if (std::is_same<T, long double>())
+        return FMT_USE_LONG_DOUBLE;
+    return true;
+}
+
+// Smallest of uint32_t, uint64_t, uint128_t that is large enough to
+// represent all values of an integral type T.
+template<typename T>
+using uint32_or_64_or_128_t =
+    conditional_t<num_bits<T>() <= 32 && !FMT_REDUCE_INT_INSTANTIATIONS, uint32_t, conditional_t<num_bits<T>() <= 64, uint64_t, uint128_t>>;
+template<typename T>
+using uint64_or_128_t = conditional_t<num_bits<T>() <= 64, uint64_t, uint128_t>;
+
+#define FMT_POWERS_OF_10(factor)                                                                                                           \
+    factor * 10, (factor)*100, (factor)*1000, (factor)*10000, (factor)*100000, (factor)*1000000, (factor)*10000000, (factor)*100000000,    \
+        (factor)*1000000000
+
+// Converts value in the range [0, 100) to a string.
+constexpr const char *digits2(size_t value)
+{
+    // GCC generates slightly better code when value is pointer-size.
+    return &"0001020304050607080910111213141516171819"
+            "2021222324252627282930313233343536373839"
+            "4041424344454647484950515253545556575859"
+            "6061626364656667686970717273747576777879"
+            "8081828384858687888990919293949596979899"[value * 2];
+}
+
+// Sign is a template parameter to workaround a bug in gcc 4.8.
+template<typename Char, typename Sign>
+constexpr Char sign(Sign s)
+{
+#if !FMT_GCC_VERSION || FMT_GCC_VERSION >= 604
+    static_assert(std::is_same<Sign, sign_t>::value, "");
+#endif
+    return static_cast<Char>("\0-+ "[s]);
+}
+
+template<typename T>
+FMT_CONSTEXPR auto count_digits_fallback(T n) -> int
+{
+    int count = 1;
+    for (;;)
+    {
+        // Integer division is slow so do it for a group of four digits instead
+        // of for every digit. The idea comes from the talk by Alexandrescu
+        // "Three Optimization Tips for C++". See speed-test for a comparison.
+        if (n < 10)
+            return count;
+        if (n < 100)
+            return count + 1;
+        if (n < 1000)
+            return count + 2;
+        if (n < 10000)
+            return count + 3;
+        n /= 10000u;
+        count += 4;
+    }
+}
+#if FMT_USE_INT128
+FMT_CONSTEXPR inline auto count_digits(uint128_opt n) -> int
+{
+    return count_digits_fallback(n);
+}
+#endif
+
+#ifdef FMT_BUILTIN_CLZLL
+// It is a separate function rather than a part of count_digits to workaround
+// the lack of static constexpr in constexpr functions.
+inline auto do_count_digits(uint64_t n) -> int
+{
+    // This has comparable performance to the version by Kendall Willets
+    // (https://github.com/fmtlib/format-benchmark/blob/master/digits10)
+    // but uses smaller tables.
+    // Maps bsr(n) to ceil(log10(pow(2, bsr(n) + 1) - 1)).
+    static constexpr uint8_t bsr2log10[] = {1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 9, 9, 9, 10, 10,
+        10, 10, 11, 11, 11, 12, 12, 12, 13, 13, 13, 13, 14, 14, 14, 15, 15, 15, 16, 16, 16, 16, 17, 17, 17, 18, 18, 18, 19, 19, 19, 19, 20};
+    auto t = bsr2log10[FMT_BUILTIN_CLZLL(n | 1) ^ 63];
+    static constexpr const uint64_t zero_or_powers_of_10[] = {
+        0, 0, FMT_POWERS_OF_10(1U), FMT_POWERS_OF_10(1000000000ULL), 10000000000000000000ULL};
+    return t - (n < zero_or_powers_of_10[t]);
+}
+#endif
+
+// Returns the number of decimal digits in n. Leading zeros are not counted
+// except for n == 0 in which case count_digits returns 1.
+FMT_CONSTEXPR20 inline auto count_digits(uint64_t n) -> int
+{
+#ifdef FMT_BUILTIN_CLZLL
+    if (!is_constant_evaluated())
+    {
+        return do_count_digits(n);
+    }
+#endif
+    return count_digits_fallback(n);
+}
+
+// Counts the number of digits in n. BITS = log2(radix).
+template<int BITS, typename UInt>
+FMT_CONSTEXPR auto count_digits(UInt n) -> int
+{
+#ifdef FMT_BUILTIN_CLZ
+    if (!is_constant_evaluated() && num_bits<UInt>() == 32)
+        return (FMT_BUILTIN_CLZ(static_cast<uint32_t>(n) | 1) ^ 31) / BITS + 1;
+#endif
+    // Lambda avoids unreachable code warnings from NVHPC.
+    return [](UInt m) {
+        int num_digits = 0;
+        do
+        {
+            ++num_digits;
+        } while ((m >>= BITS) != 0);
+        return num_digits;
+    }(n);
+}
+
+#ifdef FMT_BUILTIN_CLZ
+// It is a separate function rather than a part of count_digits to workaround
+// the lack of static constexpr in constexpr functions.
+FMT_INLINE auto do_count_digits(uint32_t n) -> int
+{
+// An optimization by Kendall Willets from https://bit.ly/3uOIQrB.
+// This increments the upper 32 bits (log10(T) - 1) when >= T is added.
+#    define FMT_INC(T) (((sizeof(#T) - 1ull) << 32) - T)
+    static constexpr uint64_t table[] = {
+        FMT_INC(0), FMT_INC(0), FMT_INC(0),                            // 8
+        FMT_INC(10), FMT_INC(10), FMT_INC(10),                         // 64
+        FMT_INC(100), FMT_INC(100), FMT_INC(100),                      // 512
+        FMT_INC(1000), FMT_INC(1000), FMT_INC(1000),                   // 4096
+        FMT_INC(10000), FMT_INC(10000), FMT_INC(10000),                // 32k
+        FMT_INC(100000), FMT_INC(100000), FMT_INC(100000),             // 256k
+        FMT_INC(1000000), FMT_INC(1000000), FMT_INC(1000000),          // 2048k
+        FMT_INC(10000000), FMT_INC(10000000), FMT_INC(10000000),       // 16M
+        FMT_INC(100000000), FMT_INC(100000000), FMT_INC(100000000),    // 128M
+        FMT_INC(1000000000), FMT_INC(1000000000), FMT_INC(1000000000), // 1024M
+        FMT_INC(1000000000), FMT_INC(1000000000)                       // 4B
+    };
+    auto inc = table[FMT_BUILTIN_CLZ(n | 1) ^ 31];
+    return static_cast<int>((n + inc) >> 32);
+}
+#endif
+
+// Optional version of count_digits for better performance on 32-bit platforms.
+FMT_CONSTEXPR20 inline auto count_digits(uint32_t n) -> int
+{
+#ifdef FMT_BUILTIN_CLZ
+    if (!is_constant_evaluated())
+    {
+        return do_count_digits(n);
+    }
+#endif
+    return count_digits_fallback(n);
+}
+
+template<typename Int>
+constexpr auto digits10() noexcept -> int
+{
+    return std::numeric_limits<Int>::digits10;
+}
+template<>
+constexpr auto digits10<int128_opt>() noexcept -> int
+{
+    return 38;
+}
+template<>
+constexpr auto digits10<uint128_t>() noexcept -> int
+{
+    return 38;
+}
+
+template<typename Char>
+struct thousands_sep_result
+{
+    std::string grouping;
+    Char thousands_sep;
+};
+
+template<typename Char>
+FMT_API auto thousands_sep_impl(locale_ref loc) -> thousands_sep_result<Char>;
+template<typename Char>
+inline auto thousands_sep(locale_ref loc) -> thousands_sep_result<Char>
+{
+    auto result = thousands_sep_impl<char>(loc);
+    return {result.grouping, Char(result.thousands_sep)};
+}
+template<>
+inline auto thousands_sep(locale_ref loc) -> thousands_sep_result<wchar_t>
+{
+    return thousands_sep_impl<wchar_t>(loc);
+}
+
+template<typename Char>
+FMT_API auto decimal_point_impl(locale_ref loc) -> Char;
+template<typename Char>
+inline auto decimal_point(locale_ref loc) -> Char
+{
+    return Char(decimal_point_impl<char>(loc));
+}
+template<>
+inline auto decimal_point(locale_ref loc) -> wchar_t
+{
+    return decimal_point_impl<wchar_t>(loc);
+}
+
+// Compares two characters for equality.
+template<typename Char>
+auto equal2(const Char *lhs, const char *rhs) -> bool
+{
+    return lhs[0] == Char(rhs[0]) && lhs[1] == Char(rhs[1]);
+}
+inline auto equal2(const char *lhs, const char *rhs) -> bool
+{
+    return memcmp(lhs, rhs, 2) == 0;
+}
+
+// Copies two characters from src to dst.
+template<typename Char>
+FMT_CONSTEXPR20 FMT_INLINE void copy2(Char *dst, const char *src)
+{
+    if (!is_constant_evaluated() && sizeof(Char) == sizeof(char))
+    {
+        memcpy(dst, src, 2);
+        return;
+    }
+    *dst++ = static_cast<Char>(*src++);
+    *dst = static_cast<Char>(*src);
+}
+
+template<typename Iterator>
+struct format_decimal_result
+{
+    Iterator begin;
+    Iterator end;
+};
+
+// Formats a decimal unsigned integer value writing into out pointing to a
+// buffer of specified size. The caller must ensure that the buffer is large
+// enough.
+template<typename Char, typename UInt>
+FMT_CONSTEXPR20 auto format_decimal(Char *out, UInt value, int size) -> format_decimal_result<Char *>
+{
+    FMT_ASSERT(size >= count_digits(value), "invalid digit count");
+    out += size;
+    Char *end = out;
+    while (value >= 100)
+    {
+        // Integer division is slow so do it for a group of two digits instead
+        // of for every digit. The idea comes from the talk by Alexandrescu
+        // "Three Optimization Tips for C++". See speed-test for a comparison.
+        out -= 2;
+        copy2(out, digits2(static_cast<size_t>(value % 100)));
+        value /= 100;
+    }
+    if (value < 10)
+    {
+        *--out = static_cast<Char>('0' + value);
+        return {out, end};
+    }
+    out -= 2;
+    copy2(out, digits2(static_cast<size_t>(value)));
+    return {out, end};
+}
+
+template<typename Char, typename UInt, typename Iterator, FMT_ENABLE_IF(!std::is_pointer<remove_cvref_t<Iterator>>::value)>
+FMT_CONSTEXPR inline auto format_decimal(Iterator out, UInt value, int size) -> format_decimal_result<Iterator>
+{
+    // Buffer is large enough to hold all digits (digits10 + 1).
+    Char buffer[digits10<UInt>() + 1];
+    auto end = format_decimal(buffer, value, size).end;
+    return {out, detail::copy_str_noinline<Char>(buffer, end, out)};
+}
+
+template<unsigned BASE_BITS, typename Char, typename UInt>
+FMT_CONSTEXPR auto format_uint(Char *buffer, UInt value, int num_digits, bool upper = false) -> Char *
+{
+    buffer += num_digits;
+    Char *end = buffer;
+    do
+    {
+        const char *digits = upper ? "0123456789ABCDEF" : "0123456789abcdef";
+        unsigned digit = static_cast<unsigned>(value & ((1 << BASE_BITS) - 1));
+        *--buffer = static_cast<Char>(BASE_BITS < 4 ? static_cast<char>('0' + digit) : digits[digit]);
+    } while ((value >>= BASE_BITS) != 0);
+    return end;
+}
+
+template<unsigned BASE_BITS, typename Char, typename It, typename UInt>
+inline auto format_uint(It out, UInt value, int num_digits, bool upper = false) -> It
+{
+    if (auto ptr = to_pointer<Char>(out, to_unsigned(num_digits)))
+    {
+        format_uint<BASE_BITS>(ptr, value, num_digits, upper);
+        return out;
+    }
+    // Buffer should be large enough to hold all digits (digits / BASE_BITS + 1).
+    char buffer[num_bits<UInt>() / BASE_BITS + 1];
+    format_uint<BASE_BITS>(buffer, value, num_digits, upper);
+    return detail::copy_str_noinline<Char>(buffer, buffer + num_digits, out);
+}
+
+// A converter from UTF-8 to UTF-16.
+class utf8_to_utf16
+{
+private:
+    basic_memory_buffer<wchar_t> buffer_;
+
+public:
+    FMT_API explicit utf8_to_utf16(string_view s);
+    operator basic_string_view<wchar_t>() const
+    {
+        return {&buffer_[0], size()};
+    }
+    auto size() const -> size_t
+    {
+        return buffer_.size() - 1;
+    }
+    auto c_str() const -> const wchar_t *
+    {
+        return &buffer_[0];
+    }
+    auto str() const -> std::wstring
+    {
+        return {&buffer_[0], size()};
+    }
+};
+
+namespace dragonbox {
+
+// Type-specific information that Dragonbox uses.
+template<typename T, typename Enable = void>
+struct float_info;
+
+template<>
+struct float_info<float>
+{
+    using carrier_uint = uint32_t;
+    static const int exponent_bits = 8;
+    static const int kappa = 1;
+    static const int big_divisor = 100;
+    static const int small_divisor = 10;
+    static const int min_k = -31;
+    static const int max_k = 46;
+    static const int shorter_interval_tie_lower_threshold = -35;
+    static const int shorter_interval_tie_upper_threshold = -35;
+};
+
+template<>
+struct float_info<double>
+{
+    using carrier_uint = uint64_t;
+    static const int exponent_bits = 11;
+    static const int kappa = 2;
+    static const int big_divisor = 1000;
+    static const int small_divisor = 100;
+    static const int min_k = -292;
+    static const int max_k = 326;
+    static const int shorter_interval_tie_lower_threshold = -77;
+    static const int shorter_interval_tie_upper_threshold = -77;
+};
+
+// An 80- or 128-bit floating point number.
+template<typename T>
+struct float_info<T, enable_if_t<std::numeric_limits<T>::digits == 64 || std::numeric_limits<T>::digits == 113 || is_float128<T>::value>>
+{
+    using carrier_uint = detail::uint128_t;
+    static const int exponent_bits = 15;
+};
+
+// A double-double floating point number.
+template<typename T>
+struct float_info<T, enable_if_t<is_double_double<T>::value>>
+{
+    using carrier_uint = detail::uint128_t;
+};
+
+template<typename T>
+struct decimal_fp
+{
+    using significand_type = typename float_info<T>::carrier_uint;
+    significand_type significand;
+    int exponent;
+};
+
+template<typename T>
+FMT_API auto to_decimal(T x) noexcept -> decimal_fp<T>;
+} // namespace dragonbox
+
+// Returns true iff Float has the implicit bit which is not stored.
+template<typename Float>
+constexpr bool has_implicit_bit()
+{
+    // An 80-bit FP number has a 64-bit significand an no implicit bit.
+    return std::numeric_limits<Float>::digits != 64;
+}
+
+// Returns the number of significand bits stored in Float. The implicit bit is
+// not counted since it is not stored.
+template<typename Float>
+constexpr int num_significand_bits()
+{
+    // std::numeric_limits may not support __float128.
+    return is_float128<Float>() ? 112 : (std::numeric_limits<Float>::digits - (has_implicit_bit<Float>() ? 1 : 0));
+}
+
+template<typename Float>
+constexpr auto exponent_mask() -> typename dragonbox::float_info<Float>::carrier_uint
+{
+    using uint = typename dragonbox::float_info<Float>::carrier_uint;
+    return ((uint(1) << dragonbox::float_info<Float>::exponent_bits) - 1) << num_significand_bits<Float>();
+}
+template<typename Float>
+constexpr auto exponent_bias() -> int
+{
+    // std::numeric_limits may not support __float128.
+    return is_float128<Float>() ? 16383 : std::numeric_limits<Float>::max_exponent - 1;
+}
+
+// Writes the exponent exp in the form "[+-]d{2,3}" to buffer.
+template<typename Char, typename It>
+FMT_CONSTEXPR auto write_exponent(int exp, It it) -> It
+{
+    FMT_ASSERT(-10000 < exp && exp < 10000, "exponent out of range");
+    if (exp < 0)
+    {
+        *it++ = static_cast<Char>('-');
+        exp = -exp;
+    }
+    else
+    {
+        *it++ = static_cast<Char>('+');
+    }
+    if (exp >= 100)
+    {
+        const char *top = digits2(to_unsigned(exp / 100));
+        if (exp >= 1000)
+            *it++ = static_cast<Char>(top[0]);
+        *it++ = static_cast<Char>(top[1]);
+        exp %= 100;
+    }
+    const char *d = digits2(to_unsigned(exp));
+    *it++ = static_cast<Char>(d[0]);
+    *it++ = static_cast<Char>(d[1]);
+    return it;
+}
+
+// A floating-point number f * pow(2, e) where F is an unsigned type.
+template<typename F>
+struct basic_fp
+{
+    F f;
+    int e;
+
+    static constexpr const int num_significand_bits = static_cast<int>(sizeof(F) * num_bits<unsigned char>());
+
+    constexpr basic_fp()
+        : f(0)
+        , e(0)
+    {}
+    constexpr basic_fp(uint64_t f_val, int e_val)
+        : f(f_val)
+        , e(e_val)
+    {}
+
+    // Constructs fp from an IEEE754 floating-point number.
+    template<typename Float>
+    FMT_CONSTEXPR basic_fp(Float n)
+    {
+        assign(n);
+    }
+
+    // Assigns n to this and return true iff predecessor is closer than successor.
+    template<typename Float, FMT_ENABLE_IF(!is_double_double<Float>::value)>
+    FMT_CONSTEXPR auto assign(Float n) -> bool
+    {
+        static_assert(std::numeric_limits<Float>::digits <= 113, "unsupported FP");
+        // Assume Float is in the format [sign][exponent][significand].
+        using carrier_uint = typename dragonbox::float_info<Float>::carrier_uint;
+        const auto num_float_significand_bits = detail::num_significand_bits<Float>();
+        const auto implicit_bit = carrier_uint(1) << num_float_significand_bits;
+        const auto significand_mask = implicit_bit - 1;
+        auto u = bit_cast<carrier_uint>(n);
+        f = static_cast<F>(u & significand_mask);
+        auto biased_e = static_cast<int>((u & exponent_mask<Float>()) >> num_float_significand_bits);
+        // The predecessor is closer if n is a normalized power of 2 (f == 0)
+        // other than the smallest normalized number (biased_e > 1).
+        auto is_predecessor_closer = f == 0 && biased_e > 1;
+        if (biased_e == 0)
+            biased_e = 1; // Subnormals use biased exponent 1 (min exponent).
+        else if (has_implicit_bit<Float>())
+            f += static_cast<F>(implicit_bit);
+        e = biased_e - exponent_bias<Float>() - num_float_significand_bits;
+        if (!has_implicit_bit<Float>())
+            ++e;
+        return is_predecessor_closer;
+    }
+
+    template<typename Float, FMT_ENABLE_IF(is_double_double<Float>::value)>
+    FMT_CONSTEXPR auto assign(Float n) -> bool
+    {
+        static_assert(std::numeric_limits<double>::is_iec559, "unsupported FP");
+        return assign(static_cast<double>(n));
+    }
+};
+
+using fp = basic_fp<unsigned long long>;
+
+// Normalizes the value converted from double and multiplied by (1 << SHIFT).
+template<int SHIFT = 0, typename F>
+FMT_CONSTEXPR basic_fp<F> normalize(basic_fp<F> value)
+{
+    // Handle subnormals.
+    const auto implicit_bit = F(1) << num_significand_bits<double>();
+    const auto shifted_implicit_bit = implicit_bit << SHIFT;
+    while ((value.f & shifted_implicit_bit) == 0)
+    {
+        value.f <<= 1;
+        --value.e;
+    }
+    // Subtract 1 to account for hidden bit.
+    const auto offset = basic_fp<F>::num_significand_bits - num_significand_bits<double>() - SHIFT - 1;
+    value.f <<= offset;
+    value.e -= offset;
+    return value;
+}
+
+// Computes lhs * rhs / pow(2, 64) rounded to nearest with half-up tie breaking.
+FMT_CONSTEXPR inline uint64_t multiply(uint64_t lhs, uint64_t rhs)
+{
+#if FMT_USE_INT128
+    auto product = static_cast<__uint128_t>(lhs) * rhs;
+    auto f = static_cast<uint64_t>(product >> 64);
+    return (static_cast<uint64_t>(product) & (1ULL << 63)) != 0 ? f + 1 : f;
+#else
+    // Multiply 32-bit parts of significands.
+    uint64_t mask = (1ULL << 32) - 1;
+    uint64_t a = lhs >> 32, b = lhs & mask;
+    uint64_t c = rhs >> 32, d = rhs & mask;
+    uint64_t ac = a * c, bc = b * c, ad = a * d, bd = b * d;
+    // Compute mid 64-bit of result and round.
+    uint64_t mid = (bd >> 32) + (ad & mask) + (bc & mask) + (1U << 31);
+    return ac + (ad >> 32) + (bc >> 32) + (mid >> 32);
+#endif
+}
+
+FMT_CONSTEXPR inline fp operator*(fp x, fp y)
+{
+    return {multiply(x.f, y.f), x.e + y.e + 64};
+}
+
+template<typename T = void>
+struct basic_data
+{
+    // Normalized 64-bit significands of pow(10, k), for k = -348, -340, ..., 340.
+    // These are generated by support/compute-powers.py.
+    static constexpr uint64_t pow10_significands[87] = {
+        0xfa8fd5a0081c0288,
+        0xbaaee17fa23ebf76,
+        0x8b16fb203055ac76,
+        0xcf42894a5dce35ea,
+        0x9a6bb0aa55653b2d,
+        0xe61acf033d1a45df,
+        0xab70fe17c79ac6ca,
+        0xff77b1fcbebcdc4f,
+        0xbe5691ef416bd60c,
+        0x8dd01fad907ffc3c,
+        0xd3515c2831559a83,
+        0x9d71ac8fada6c9b5,
+        0xea9c227723ee8bcb,
+        0xaecc49914078536d,
+        0x823c12795db6ce57,
+        0xc21094364dfb5637,
+        0x9096ea6f3848984f,
+        0xd77485cb25823ac7,
+        0xa086cfcd97bf97f4,
+        0xef340a98172aace5,
+        0xb23867fb2a35b28e,
+        0x84c8d4dfd2c63f3b,
+        0xc5dd44271ad3cdba,
+        0x936b9fcebb25c996,
+        0xdbac6c247d62a584,
+        0xa3ab66580d5fdaf6,
+        0xf3e2f893dec3f126,
+        0xb5b5ada8aaff80b8,
+        0x87625f056c7c4a8b,
+        0xc9bcff6034c13053,
+        0x964e858c91ba2655,
+        0xdff9772470297ebd,
+        0xa6dfbd9fb8e5b88f,
+        0xf8a95fcf88747d94,
+        0xb94470938fa89bcf,
+        0x8a08f0f8bf0f156b,
+        0xcdb02555653131b6,
+        0x993fe2c6d07b7fac,
+        0xe45c10c42a2b3b06,
+        0xaa242499697392d3,
+        0xfd87b5f28300ca0e,
+        0xbce5086492111aeb,
+        0x8cbccc096f5088cc,
+        0xd1b71758e219652c,
+        0x9c40000000000000,
+        0xe8d4a51000000000,
+        0xad78ebc5ac620000,
+        0x813f3978f8940984,
+        0xc097ce7bc90715b3,
+        0x8f7e32ce7bea5c70,
+        0xd5d238a4abe98068,
+        0x9f4f2726179a2245,
+        0xed63a231d4c4fb27,
+        0xb0de65388cc8ada8,
+        0x83c7088e1aab65db,
+        0xc45d1df942711d9a,
+        0x924d692ca61be758,
+        0xda01ee641a708dea,
+        0xa26da3999aef774a,
+        0xf209787bb47d6b85,
+        0xb454e4a179dd1877,
+        0x865b86925b9bc5c2,
+        0xc83553c5c8965d3d,
+        0x952ab45cfa97a0b3,
+        0xde469fbd99a05fe3,
+        0xa59bc234db398c25,
+        0xf6c69a72a3989f5c,
+        0xb7dcbf5354e9bece,
+        0x88fcf317f22241e2,
+        0xcc20ce9bd35c78a5,
+        0x98165af37b2153df,
+        0xe2a0b5dc971f303a,
+        0xa8d9d1535ce3b396,
+        0xfb9b7cd9a4a7443c,
+        0xbb764c4ca7a44410,
+        0x8bab8eefb6409c1a,
+        0xd01fef10a657842c,
+        0x9b10a4e5e9913129,
+        0xe7109bfba19c0c9d,
+        0xac2820d9623bf429,
+        0x80444b5e7aa7cf85,
+        0xbf21e44003acdd2d,
+        0x8e679c2f5e44ff8f,
+        0xd433179d9c8cb841,
+        0x9e19db92b4e31ba9,
+        0xeb96bf6ebadf77d9,
+        0xaf87023b9bf0ee6b,
+    };
+
+#if FMT_GCC_VERSION && FMT_GCC_VERSION < 409
+#    pragma GCC diagnostic push
+#    pragma GCC diagnostic ignored "-Wnarrowing"
+#endif
+    // Binary exponents of pow(10, k), for k = -348, -340, ..., 340, corresponding
+    // to significands above.
+    static constexpr int16_t pow10_exponents[87] = {-1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007, -980, -954, -927, -901,
+        -874, -847, -821, -794, -768, -741, -715, -688, -661, -635, -608, -582, -555, -529, -502, -475, -449, -422, -396, -369, -343, -316,
+        -289, -263, -236, -210, -183, -157, -130, -103, -77, -50, -24, 3, 30, 56, 83, 109, 136, 162, 189, 216, 242, 269, 295, 322, 348, 375,
+        402, 428, 455, 481, 508, 534, 561, 588, 614, 641, 667, 694, 720, 747, 774, 800, 827, 853, 880, 907, 933, 960, 986, 1013, 1039,
+        1066};
+#if FMT_GCC_VERSION && FMT_GCC_VERSION < 409
+#    pragma GCC diagnostic pop
+#endif
+
+    static constexpr uint64_t power_of_10_64[20] = {1, FMT_POWERS_OF_10(1ULL), FMT_POWERS_OF_10(1000000000ULL), 10000000000000000000ULL};
+};
+
+#if FMT_CPLUSPLUS < 201703L
+template<typename T>
+constexpr uint64_t basic_data<T>::pow10_significands[];
+template<typename T>
+constexpr int16_t basic_data<T>::pow10_exponents[];
+template<typename T>
+constexpr uint64_t basic_data<T>::power_of_10_64[];
+#endif
+
+// This is a struct rather than an alias to avoid shadowing warnings in gcc.
+struct data : basic_data<>
+{};
+
+// Returns a cached power of 10 `c_k = c_k.f * pow(2, c_k.e)` such that its
+// (binary) exponent satisfies `min_exponent <= c_k.e <= min_exponent + 28`.
+FMT_CONSTEXPR inline fp get_cached_power(int min_exponent, int &pow10_exponent)
+{
+    const int shift = 32;
+    // log10(2) = 0x0.4d104d427de7fbcc...
+    const int64_t significand = 0x4d104d427de7fbcc;
+    int index =
+        static_cast<int>(((min_exponent + fp::num_significand_bits - 1) * (significand >> shift) + ((int64_t(1) << shift) - 1)) // ceil
+                         >> 32 // arithmetic shift
+        );
+    // Decimal exponent of the first (smallest) cached power of 10.
+    const int first_dec_exp = -348;
+    // Difference between 2 consecutive decimal exponents in cached powers of 10.
+    const int dec_exp_step = 8;
+    index = (index - first_dec_exp - 1) / dec_exp_step + 1;
+    pow10_exponent = first_dec_exp + index * dec_exp_step;
+    // Using *(x + index) instead of x[index] avoids an issue with some compilers
+    // using the EDG frontend (e.g. nvhpc/22.3 in C++17 mode).
+    return {*(data::pow10_significands + index), *(data::pow10_exponents + index)};
+}
+
+#ifndef _MSC_VER
+#    define FMT_SNPRINTF snprintf
+#else
+FMT_API auto fmt_snprintf(char *buf, size_t size, const char *fmt, ...) -> int;
+#    define FMT_SNPRINTF fmt_snprintf
+#endif // _MSC_VER
+
+// Formats a floating-point number with snprintf using the hexfloat format.
+template<typename T>
+auto snprintf_float(T value, int precision, float_specs specs, buffer<char> &buf) -> int
+{
+    // Buffer capacity must be non-zero, otherwise MSVC's vsnprintf_s will fail.
+    FMT_ASSERT(buf.capacity() > buf.size(), "empty buffer");
+    FMT_ASSERT(specs.format == float_format::hex, "");
+    static_assert(!std::is_same<T, float>::value, "");
+
+    // Build the format string.
+    char format[7]; // The longest format is "%#.*Le".
+    char *format_ptr = format;
+    *format_ptr++ = '%';
+    if (specs.showpoint)
+        *format_ptr++ = '#';
+    if (precision >= 0)
+    {
+        *format_ptr++ = '.';
+        *format_ptr++ = '*';
+    }
+    if (std::is_same<T, long double>())
+        *format_ptr++ = 'L';
+    *format_ptr++ = specs.upper ? 'A' : 'a';
+    *format_ptr = '\0';
+
+    // Format using snprintf.
+    auto offset = buf.size();
+    for (;;)
+    {
+        auto begin = buf.data() + offset;
+        auto capacity = buf.capacity() - offset;
+        abort_fuzzing_if(precision > 100000);
+        // Suppress the warning about a nonliteral format string.
+        // Cannot use auto because of a bug in MinGW (#1532).
+        int (*snprintf_ptr)(char *, size_t, const char *, ...) = FMT_SNPRINTF;
+        int result =
+            precision >= 0 ? snprintf_ptr(begin, capacity, format, precision, value) : snprintf_ptr(begin, capacity, format, value);
+        if (result < 0)
+        {
+            // The buffer will grow exponentially.
+            buf.try_reserve(buf.capacity() + 1);
+            continue;
+        }
+        auto size = to_unsigned(result);
+        // Size equal to capacity means that the last character was truncated.
+        if (size < capacity)
+        {
+            buf.try_resize(size + offset);
+            return 0;
+        }
+        buf.try_reserve(size + offset + 1); // Add 1 for the terminating '\0'.
+    }
+}
+
+template<typename T>
+using convert_float_result = conditional_t<std::is_same<T, float>::value || sizeof(T) == sizeof(double), double, T>;
+
+template<typename T>
+constexpr auto convert_float(T value) -> convert_float_result<T>
+{
+    return static_cast<convert_float_result<T>>(value);
+}
+
+template<typename OutputIt, typename Char>
+FMT_NOINLINE FMT_CONSTEXPR auto fill(OutputIt it, size_t n, const fill_t<Char> &fill) -> OutputIt
+{
+    auto fill_size = fill.size();
+    if (fill_size == 1)
+        return detail::fill_n(it, n, fill[0]);
+    auto data = fill.data();
+    for (size_t i = 0; i < n; ++i)
+        it = copy_str<Char>(data, data + fill_size, it);
+    return it;
+}
+
+// Writes the output of f, padded according to format specifications in specs.
+// size: output size in code units.
+// width: output display width in (terminal) column positions.
+template<align::type align = align::left, typename OutputIt, typename Char, typename F>
+FMT_CONSTEXPR auto write_padded(OutputIt out, const basic_format_specs<Char> &specs, size_t size, size_t width, F &&f) -> OutputIt
+{
+    static_assert(align == align::left || align == align::right, "");
+    unsigned spec_width = to_unsigned(specs.width);
+    size_t padding = spec_width > width ? spec_width - width : 0;
+    // Shifts are encoded as string literals because static constexpr is not
+    // supported in constexpr functions.
+    auto *shifts = align == align::left ? "\x1f\x1f\x00\x01" : "\x00\x1f\x00\x01";
+    size_t left_padding = padding >> shifts[specs.align];
+    size_t right_padding = padding - left_padding;
+    auto it = reserve(out, size + padding * specs.fill.size());
+    if (left_padding != 0)
+        it = fill(it, left_padding, specs.fill);
+    it = f(it);
+    if (right_padding != 0)
+        it = fill(it, right_padding, specs.fill);
+    return base_iterator(out, it);
+}
+
+template<align::type align = align::left, typename OutputIt, typename Char, typename F>
+constexpr auto write_padded(OutputIt out, const basic_format_specs<Char> &specs, size_t size, F &&f) -> OutputIt
+{
+    return write_padded<align>(out, specs, size, size, f);
+}
+
+template<align::type align = align::left, typename Char, typename OutputIt>
+FMT_CONSTEXPR auto write_bytes(OutputIt out, string_view bytes, const basic_format_specs<Char> &specs) -> OutputIt
+{
+    return write_padded<align>(out, specs, bytes.size(), [bytes](reserve_iterator<OutputIt> it) {
+        const char *data = bytes.data();
+        return copy_str<Char>(data, data + bytes.size(), it);
+    });
+}
+
+template<typename Char, typename OutputIt, typename UIntPtr>
+auto write_ptr(OutputIt out, UIntPtr value, const basic_format_specs<Char> *specs) -> OutputIt
+{
+    int num_digits = count_digits<4>(value);
+    auto size = to_unsigned(num_digits) + size_t(2);
+    auto write = [=](reserve_iterator<OutputIt> it) {
+        *it++ = static_cast<Char>('0');
+        *it++ = static_cast<Char>('x');
+        return format_uint<4, Char>(it, value, num_digits);
+    };
+    return specs ? write_padded<align::right>(out, *specs, size, write) : base_iterator(out, write(reserve(out, size)));
+}
+
+// Returns true iff the code point cp is printable.
+FMT_API auto is_printable(uint32_t cp) -> bool;
+
+inline auto needs_escape(uint32_t cp) -> bool
+{
+    return cp < 0x20 || cp == 0x7f || cp == '"' || cp == '\\' || !is_printable(cp);
+}
+
+template<typename Char>
+struct find_escape_result
+{
+    const Char *begin;
+    const Char *end;
+    uint32_t cp;
+};
+
+template<typename Char>
+using make_unsigned_char = typename conditional_t<std::is_integral<Char>::value, std::make_unsigned<Char>, type_identity<uint32_t>>::type;
+
+template<typename Char>
+auto find_escape(const Char *begin, const Char *end) -> find_escape_result<Char>
+{
+    for (; begin != end; ++begin)
+    {
+        uint32_t cp = static_cast<make_unsigned_char<Char>>(*begin);
+        if (const_check(sizeof(Char) == 1) && cp >= 0x80)
+            continue;
+        if (needs_escape(cp))
+            return {begin, begin + 1, cp};
+    }
+    return {begin, nullptr, 0};
+}
+
+inline auto find_escape(const char *begin, const char *end) -> find_escape_result<char>
+{
+    if (!is_utf8())
+        return find_escape<char>(begin, end);
+    auto result = find_escape_result<char>{end, nullptr, 0};
+    for_each_codepoint(string_view(begin, to_unsigned(end - begin)), [&](uint32_t cp, string_view sv) {
+        if (needs_escape(cp))
+        {
+            result = {sv.begin(), sv.end(), cp};
+            return false;
+        }
+        return true;
+    });
+    return result;
+}
+
+#define FMT_STRING_IMPL(s, base, explicit)                                                                                                 \
+    [] {                                                                                                                                   \
+        /* Use the hidden visibility as a workaround for a GCC bug (#1973). */                                                             \
+        /* Use a macro-like name to avoid shadowing warnings. */                                                                           \
+        struct FMT_GCC_VISIBILITY_HIDDEN FMT_COMPILE_STRING : base                                                                         \
+        {                                                                                                                                  \
+            using char_type FMT_MAYBE_UNUSED = fmt::remove_cvref_t<decltype(s[0])>;                                                        \
+            FMT_MAYBE_UNUSED FMT_CONSTEXPR explicit operator fmt::basic_string_view<char_type>() const                                     \
+            {                                                                                                                              \
+                return fmt::detail_exported::compile_string_to_view<char_type>(s);                                                         \
+            }                                                                                                                              \
+        };                                                                                                                                 \
+        return FMT_COMPILE_STRING();                                                                                                       \
+    }()
+
+/**
+  \rst
+  Constructs a compile-time format string from a string literal *s*.
+
+  **Example**::
+
+    // A compile-time error because 'd' is an invalid specifier for strings.
+    std::string s = fmt::format(FMT_STRING("{:d}"), "foo");
+  \endrst
+ */
+#define FMT_STRING(s) FMT_STRING_IMPL(s, fmt::detail::compile_string, )
+
+template<size_t width, typename Char, typename OutputIt>
+auto write_codepoint(OutputIt out, char prefix, uint32_t cp) -> OutputIt
+{
+    *out++ = static_cast<Char>('\\');
+    *out++ = static_cast<Char>(prefix);
+    Char buf[width];
+    fill_n(buf, width, static_cast<Char>('0'));
+    format_uint<4>(buf, cp, width);
+    return copy_str<Char>(buf, buf + width, out);
+}
+
+template<typename OutputIt, typename Char>
+auto write_escaped_cp(OutputIt out, const find_escape_result<Char> &escape) -> OutputIt
+{
+    auto c = static_cast<Char>(escape.cp);
+    switch (escape.cp)
+    {
+    case '\n':
+        *out++ = static_cast<Char>('\\');
+        c = static_cast<Char>('n');
+        break;
+    case '\r':
+        *out++ = static_cast<Char>('\\');
+        c = static_cast<Char>('r');
+        break;
+    case '\t':
+        *out++ = static_cast<Char>('\\');
+        c = static_cast<Char>('t');
+        break;
+    case '"':
+        FMT_FALLTHROUGH;
+    case '\'':
+        FMT_FALLTHROUGH;
+    case '\\':
+        *out++ = static_cast<Char>('\\');
+        break;
+    default:
+        if (is_utf8())
+        {
+            if (escape.cp < 0x100)
+            {
+                return write_codepoint<2, Char>(out, 'x', escape.cp);
+            }
+            if (escape.cp < 0x10000)
+            {
+                return write_codepoint<4, Char>(out, 'u', escape.cp);
+            }
+            if (escape.cp < 0x110000)
+            {
+                return write_codepoint<8, Char>(out, 'U', escape.cp);
+            }
+        }
+        for (Char escape_char : basic_string_view<Char>(escape.begin, to_unsigned(escape.end - escape.begin)))
+        {
+            out = write_codepoint<2, Char>(out, 'x', static_cast<uint32_t>(escape_char) & 0xFF);
+        }
+        return out;
+    }
+    *out++ = c;
+    return out;
+}
+
+template<typename Char, typename OutputIt>
+auto write_escaped_string(OutputIt out, basic_string_view<Char> str) -> OutputIt
+{
+    *out++ = static_cast<Char>('"');
+    auto begin = str.begin(), end = str.end();
+    do
+    {
+        auto escape = find_escape(begin, end);
+        out = copy_str<Char>(begin, escape.begin, out);
+        begin = escape.end;
+        if (!begin)
+            break;
+        out = write_escaped_cp<OutputIt, Char>(out, escape);
+    } while (begin != end);
+    *out++ = static_cast<Char>('"');
+    return out;
+}
+
+template<typename Char, typename OutputIt>
+auto write_escaped_char(OutputIt out, Char v) -> OutputIt
+{
+    *out++ = static_cast<Char>('\'');
+    if ((needs_escape(static_cast<uint32_t>(v)) && v != static_cast<Char>('"')) || v == static_cast<Char>('\''))
+    {
+        out = write_escaped_cp(out, find_escape_result<Char>{&v, &v + 1, static_cast<uint32_t>(v)});
+    }
+    else
+    {
+        *out++ = v;
+    }
+    *out++ = static_cast<Char>('\'');
+    return out;
+}
+
+template<typename Char, typename OutputIt>
+FMT_CONSTEXPR auto write_char(OutputIt out, Char value, const basic_format_specs<Char> &specs) -> OutputIt
+{
+    bool is_debug = specs.type == presentation_type::debug;
+    return write_padded(out, specs, 1, [=](reserve_iterator<OutputIt> it) {
+        if (is_debug)
+            return write_escaped_char(it, value);
+        *it++ = value;
+        return it;
+    });
+}
+template<typename Char, typename OutputIt>
+FMT_CONSTEXPR auto write(OutputIt out, Char value, const basic_format_specs<Char> &specs, locale_ref loc = {}) -> OutputIt
+{
+    return check_char_specs(specs) ? write_char(out, value, specs) : write(out, static_cast<int>(value), specs, loc);
+}
+
+// Data for write_int that doesn't depend on output iterator type. It is used to
+// avoid template code bloat.
+template<typename Char>
+struct write_int_data
+{
+    size_t size;
+    size_t padding;
+
+    FMT_CONSTEXPR write_int_data(int num_digits, unsigned prefix, const basic_format_specs<Char> &specs)
+        : size((prefix >> 24) + to_unsigned(num_digits))
+        , padding(0)
+    {
+        if (specs.align == align::numeric)
+        {
+            auto width = to_unsigned(specs.width);
+            if (width > size)
+            {
+                padding = width - size;
+                size = width;
+            }
+        }
+        else if (specs.precision > num_digits)
+        {
+            size = (prefix >> 24) + to_unsigned(specs.precision);
+            padding = to_unsigned(specs.precision - num_digits);
+        }
+    }
+};
+
+// Writes an integer in the format
+//   <left-padding><prefix><numeric-padding><digits><right-padding>
+// where <digits> are written by write_digits(it).
+// prefix contains chars in three lower bytes and the size in the fourth byte.
+template<typename OutputIt, typename Char, typename W>
+FMT_CONSTEXPR FMT_INLINE auto write_int(
+    OutputIt out, int num_digits, unsigned prefix, const basic_format_specs<Char> &specs, W write_digits) -> OutputIt
+{
+    // Slightly faster check for specs.width == 0 && specs.precision == -1.
+    if ((specs.width | (specs.precision + 1)) == 0)
+    {
+        auto it = reserve(out, to_unsigned(num_digits) + (prefix >> 24));
+        if (prefix != 0)
+        {
+            for (unsigned p = prefix & 0xffffff; p != 0; p >>= 8)
+                *it++ = static_cast<Char>(p & 0xff);
+        }
+        return base_iterator(out, write_digits(it));
+    }
+    auto data = write_int_data<Char>(num_digits, prefix, specs);
+    return write_padded<align::right>(out, specs, data.size, [=](reserve_iterator<OutputIt> it) {
+        for (unsigned p = prefix & 0xffffff; p != 0; p >>= 8)
+            *it++ = static_cast<Char>(p & 0xff);
+        it = detail::fill_n(it, data.padding, static_cast<Char>('0'));
+        return write_digits(it);
+    });
+}
+
+template<typename Char>
+class digit_grouping
+{
+private:
+    thousands_sep_result<Char> sep_;
+
+    struct next_state
+    {
+        std::string::const_iterator group;
+        int pos;
+    };
+    next_state initial_state() const
+    {
+        return {sep_.grouping.begin(), 0};
+    }
+
+    // Returns the next digit group separator position.
+    int next(next_state &state) const
+    {
+        if (!sep_.thousands_sep)
+            return max_value<int>();
+        if (state.group == sep_.grouping.end())
+            return state.pos += sep_.grouping.back();
+        if (*state.group <= 0 || *state.group == max_value<char>())
+            return max_value<int>();
+        state.pos += *state.group++;
+        return state.pos;
+    }
+
+public:
+    explicit digit_grouping(locale_ref loc, bool localized = true)
+    {
+        if (localized)
+            sep_ = thousands_sep<Char>(loc);
+        else
+            sep_.thousands_sep = Char();
+    }
+    explicit digit_grouping(thousands_sep_result<Char> sep)
+        : sep_(sep)
+    {}
+
+    Char separator() const
+    {
+        return sep_.thousands_sep;
+    }
+
+    int count_separators(int num_digits) const
+    {
+        int count = 0;
+        auto state = initial_state();
+        while (num_digits > next(state))
+            ++count;
+        return count;
+    }
+
+    // Applies grouping to digits and write the output to out.
+    template<typename Out, typename C>
+    Out apply(Out out, basic_string_view<C> digits) const
+    {
+        auto num_digits = static_cast<int>(digits.size());
+        auto separators = basic_memory_buffer<int>();
+        separators.push_back(0);
+        auto state = initial_state();
+        while (int i = next(state))
+        {
+            if (i >= num_digits)
+                break;
+            separators.push_back(i);
+        }
+        for (int i = 0, sep_index = static_cast<int>(separators.size() - 1); i < num_digits; ++i)
+        {
+            if (num_digits - i == separators[sep_index])
+            {
+                *out++ = separator();
+                --sep_index;
+            }
+            *out++ = static_cast<Char>(digits[to_unsigned(i)]);
+        }
+        return out;
+    }
+};
+
+template<typename OutputIt, typename UInt, typename Char>
+auto write_int_localized(
+    OutputIt out, UInt value, unsigned prefix, const basic_format_specs<Char> &specs, const digit_grouping<Char> &grouping) -> OutputIt
+{
+    static_assert(std::is_same<uint64_or_128_t<UInt>, UInt>::value, "");
+    int num_digits = count_digits(value);
+    char digits[40];
+    format_decimal(digits, value, num_digits);
+    unsigned size = to_unsigned((prefix != 0 ? 1 : 0) + num_digits + grouping.count_separators(num_digits));
+    return write_padded<align::right>(out, specs, size, size, [&](reserve_iterator<OutputIt> it) {
+        if (prefix != 0)
+        {
+            char sign = static_cast<char>(prefix);
+            *it++ = static_cast<Char>(sign);
+        }
+        return grouping.apply(it, string_view(digits, to_unsigned(num_digits)));
+    });
+}
+
+template<typename OutputIt, typename UInt, typename Char>
+auto write_int_localized(OutputIt &out, UInt value, unsigned prefix, const basic_format_specs<Char> &specs, locale_ref loc) -> bool
+{
+    auto grouping = digit_grouping<Char>(loc);
+    out = write_int_localized(out, value, prefix, specs, grouping);
+    return true;
+}
+
+FMT_CONSTEXPR inline void prefix_append(unsigned &prefix, unsigned value)
+{
+    prefix |= prefix != 0 ? value << 8 : value;
+    prefix += (1u + (value > 0xff ? 1 : 0)) << 24;
+}
+
+template<typename UInt>
+struct write_int_arg
+{
+    UInt abs_value;
+    unsigned prefix;
+};
+
+template<typename T>
+FMT_CONSTEXPR auto make_write_int_arg(T value, sign_t sign) -> write_int_arg<uint32_or_64_or_128_t<T>>
+{
+    auto prefix = 0u;
+    auto abs_value = static_cast<uint32_or_64_or_128_t<T>>(value);
+    if (is_negative(value))
+    {
+        prefix = 0x01000000 | '-';
+        abs_value = 0 - abs_value;
+    }
+    else
+    {
+        constexpr const unsigned prefixes[4] = {0, 0, 0x1000000u | '+', 0x1000000u | ' '};
+        prefix = prefixes[sign];
+    }
+    return {abs_value, prefix};
+}
+
+template<typename Char, typename OutputIt, typename T>
+FMT_CONSTEXPR FMT_INLINE auto write_int(OutputIt out, write_int_arg<T> arg, const basic_format_specs<Char> &specs, locale_ref loc)
+    -> OutputIt
+{
+    static_assert(std::is_same<T, uint32_or_64_or_128_t<T>>::value, "");
+    auto abs_value = arg.abs_value;
+    auto prefix = arg.prefix;
+    switch (specs.type)
+    {
+    case presentation_type::none:
+    case presentation_type::dec: {
+        if (specs.localized && write_int_localized(out, static_cast<uint64_or_128_t<T>>(abs_value), prefix, specs, loc))
+        {
+            return out;
+        }
+        auto num_digits = count_digits(abs_value);
+        return write_int(out, num_digits, prefix, specs,
+            [=](reserve_iterator<OutputIt> it) { return format_decimal<Char>(it, abs_value, num_digits).end; });
+    }
+    case presentation_type::hex_lower:
+    case presentation_type::hex_upper: {
+        bool upper = specs.type == presentation_type::hex_upper;
+        if (specs.alt)
+            prefix_append(prefix, unsigned(upper ? 'X' : 'x') << 8 | '0');
+        int num_digits = count_digits<4>(abs_value);
+        return write_int(out, num_digits, prefix, specs,
+            [=](reserve_iterator<OutputIt> it) { return format_uint<4, Char>(it, abs_value, num_digits, upper); });
+    }
+    case presentation_type::bin_lower:
+    case presentation_type::bin_upper: {
+        bool upper = specs.type == presentation_type::bin_upper;
+        if (specs.alt)
+            prefix_append(prefix, unsigned(upper ? 'B' : 'b') << 8 | '0');
+        int num_digits = count_digits<1>(abs_value);
+        return write_int(
+            out, num_digits, prefix, specs, [=](reserve_iterator<OutputIt> it) { return format_uint<1, Char>(it, abs_value, num_digits); });
+    }
+    case presentation_type::oct: {
+        int num_digits = count_digits<3>(abs_value);
+        // Octal prefix '0' is counted as a digit, so only add it if precision
+        // is not greater than the number of digits.
+        if (specs.alt && specs.precision <= num_digits && abs_value != 0)
+            prefix_append(prefix, '0');
+        return write_int(
+            out, num_digits, prefix, specs, [=](reserve_iterator<OutputIt> it) { return format_uint<3, Char>(it, abs_value, num_digits); });
+    }
+    case presentation_type::chr:
+        return write_char(out, static_cast<Char>(abs_value), specs);
+    default:
+        throw_format_error("invalid type specifier");
+    }
+    return out;
+}
+template<typename Char, typename OutputIt, typename T>
+FMT_CONSTEXPR FMT_NOINLINE auto write_int_noinline(
+    OutputIt out, write_int_arg<T> arg, const basic_format_specs<Char> &specs, locale_ref loc) -> OutputIt
+{
+    return write_int(out, arg, specs, loc);
+}
+template<typename Char, typename OutputIt, typename T,
+    FMT_ENABLE_IF(is_integral<T>::value && !std::is_same<T, bool>::value && std::is_same<OutputIt, buffer_appender<Char>>::value)>
+FMT_CONSTEXPR FMT_INLINE auto write(OutputIt out, T value, const basic_format_specs<Char> &specs, locale_ref loc) -> OutputIt
+{
+    return write_int_noinline(out, make_write_int_arg(value, specs.sign), specs, loc);
+}
+// An inlined version of write used in format string compilation.
+template<typename Char, typename OutputIt, typename T,
+    FMT_ENABLE_IF(is_integral<T>::value && !std::is_same<T, bool>::value && !std::is_same<OutputIt, buffer_appender<Char>>::value)>
+FMT_CONSTEXPR FMT_INLINE auto write(OutputIt out, T value, const basic_format_specs<Char> &specs, locale_ref loc) -> OutputIt
+{
+    return write_int(out, make_write_int_arg(value, specs.sign), specs, loc);
+}
+
+// An output iterator that counts the number of objects written to it and
+// discards them.
+class counting_iterator
+{
+private:
+    size_t count_;
+
+public:
+    using iterator_category = std::output_iterator_tag;
+    using difference_type = std::ptrdiff_t;
+    using pointer = void;
+    using reference = void;
+    FMT_UNCHECKED_ITERATOR(counting_iterator);
+
+    struct value_type
+    {
+        template<typename T>
+        FMT_CONSTEXPR void operator=(const T &)
+        {}
+    };
+
+    FMT_CONSTEXPR counting_iterator()
+        : count_(0)
+    {}
+
+    FMT_CONSTEXPR size_t count() const
+    {
+        return count_;
+    }
+
+    FMT_CONSTEXPR counting_iterator &operator++()
+    {
+        ++count_;
+        return *this;
+    }
+    FMT_CONSTEXPR counting_iterator operator++(int)
+    {
+        auto it = *this;
+        ++*this;
+        return it;
+    }
+
+    FMT_CONSTEXPR friend counting_iterator operator+(counting_iterator it, difference_type n)
+    {
+        it.count_ += static_cast<size_t>(n);
+        return it;
+    }
+
+    FMT_CONSTEXPR value_type operator*() const
+    {
+        return {};
+    }
+};
+
+template<typename Char, typename OutputIt>
+FMT_CONSTEXPR auto write(OutputIt out, basic_string_view<Char> s, const basic_format_specs<Char> &specs) -> OutputIt
+{
+    auto data = s.data();
+    auto size = s.size();
+    if (specs.precision >= 0 && to_unsigned(specs.precision) < size)
+        size = code_point_index(s, to_unsigned(specs.precision));
+    bool is_debug = specs.type == presentation_type::debug;
+    size_t width = 0;
+    if (specs.width != 0)
+    {
+        if (is_debug)
+            width = write_escaped_string(counting_iterator{}, s).count();
+        else
+            width = compute_width(basic_string_view<Char>(data, size));
+    }
+    return write_padded(out, specs, size, width, [=](reserve_iterator<OutputIt> it) {
+        if (is_debug)
+            return write_escaped_string(it, s);
+        return copy_str<Char>(data, data + size, it);
+    });
+}
+template<typename Char, typename OutputIt>
+FMT_CONSTEXPR auto write(OutputIt out, basic_string_view<type_identity_t<Char>> s, const basic_format_specs<Char> &specs, locale_ref)
+    -> OutputIt
+{
+    check_string_type_spec(specs.type);
+    return write(out, s, specs);
+}
+template<typename Char, typename OutputIt>
+FMT_CONSTEXPR auto write(OutputIt out, const Char *s, const basic_format_specs<Char> &specs, locale_ref) -> OutputIt
+{
+    return check_cstring_type_spec(specs.type) ? write(out, basic_string_view<Char>(s), specs, {})
+                                               : write_ptr<Char>(out, bit_cast<uintptr_t>(s), &specs);
+}
+
+template<typename Char, typename OutputIt, typename T,
+    FMT_ENABLE_IF(is_integral<T>::value && !std::is_same<T, bool>::value && !std::is_same<T, Char>::value)>
+FMT_CONSTEXPR auto write(OutputIt out, T value) -> OutputIt
+{
+    auto abs_value = static_cast<uint32_or_64_or_128_t<T>>(value);
+    bool negative = is_negative(value);
+    // Don't do -abs_value since it trips unsigned-integer-overflow sanitizer.
+    if (negative)
+        abs_value = ~abs_value + 1;
+    int num_digits = count_digits(abs_value);
+    auto size = (negative ? 1 : 0) + static_cast<size_t>(num_digits);
+    auto it = reserve(out, size);
+    if (auto ptr = to_pointer<Char>(it, size))
+    {
+        if (negative)
+            *ptr++ = static_cast<Char>('-');
+        format_decimal<Char>(ptr, abs_value, num_digits);
+        return out;
+    }
+    if (negative)
+        *it++ = static_cast<Char>('-');
+    it = format_decimal<Char>(it, abs_value, num_digits).end;
+    return base_iterator(out, it);
+}
+
+template<typename Char, typename OutputIt>
+FMT_CONSTEXPR20 auto write_nonfinite(OutputIt out, bool isnan, basic_format_specs<Char> specs, const float_specs &fspecs) -> OutputIt
+{
+    auto str = isnan ? (fspecs.upper ? "NAN" : "nan") : (fspecs.upper ? "INF" : "inf");
+    constexpr size_t str_size = 3;
+    auto sign = fspecs.sign;
+    auto size = str_size + (sign ? 1 : 0);
+    // Replace '0'-padding with space for non-finite values.
+    const bool is_zero_fill = specs.fill.size() == 1 && *specs.fill.data() == static_cast<Char>('0');
+    if (is_zero_fill)
+        specs.fill[0] = static_cast<Char>(' ');
+    return write_padded(out, specs, size, [=](reserve_iterator<OutputIt> it) {
+        if (sign)
+            *it++ = detail::sign<Char>(sign);
+        return copy_str<Char>(str, str + str_size, it);
+    });
+}
+
+// A decimal floating-point number significand * pow(10, exp).
+struct big_decimal_fp
+{
+    const char *significand;
+    int significand_size;
+    int exponent;
+};
+
+constexpr auto get_significand_size(const big_decimal_fp &f) -> int
+{
+    return f.significand_size;
+}
+template<typename T>
+inline auto get_significand_size(const dragonbox::decimal_fp<T> &f) -> int
+{
+    return count_digits(f.significand);
+}
+
+template<typename Char, typename OutputIt>
+constexpr auto write_significand(OutputIt out, const char *significand, int significand_size) -> OutputIt
+{
+    return copy_str<Char>(significand, significand + significand_size, out);
+}
+template<typename Char, typename OutputIt, typename UInt>
+inline auto write_significand(OutputIt out, UInt significand, int significand_size) -> OutputIt
+{
+    return format_decimal<Char>(out, significand, significand_size).end;
+}
+template<typename Char, typename OutputIt, typename T, typename Grouping>
+FMT_CONSTEXPR20 auto write_significand(OutputIt out, T significand, int significand_size, int exponent, const Grouping &grouping)
+    -> OutputIt
+{
+    if (!grouping.separator())
+    {
+        out = write_significand<Char>(out, significand, significand_size);
+        return detail::fill_n(out, exponent, static_cast<Char>('0'));
+    }
+    auto buffer = memory_buffer();
+    write_significand<char>(appender(buffer), significand, significand_size);
+    detail::fill_n(appender(buffer), exponent, '0');
+    return grouping.apply(out, string_view(buffer.data(), buffer.size()));
+}
+
+template<typename Char, typename UInt, FMT_ENABLE_IF(std::is_integral<UInt>::value)>
+inline auto write_significand(Char *out, UInt significand, int significand_size, int integral_size, Char decimal_point) -> Char *
+{
+    if (!decimal_point)
+        return format_decimal(out, significand, significand_size).end;
+    out += significand_size + 1;
+    Char *end = out;
+    int floating_size = significand_size - integral_size;
+    for (int i = floating_size / 2; i > 0; --i)
+    {
+        out -= 2;
+        copy2(out, digits2(static_cast<std::size_t>(significand % 100)));
+        significand /= 100;
+    }
+    if (floating_size % 2 != 0)
+    {
+        *--out = static_cast<Char>('0' + significand % 10);
+        significand /= 10;
+    }
+    *--out = decimal_point;
+    format_decimal(out - integral_size, significand, integral_size);
+    return end;
+}
+
+template<typename OutputIt, typename UInt, typename Char, FMT_ENABLE_IF(!std::is_pointer<remove_cvref_t<OutputIt>>::value)>
+inline auto write_significand(OutputIt out, UInt significand, int significand_size, int integral_size, Char decimal_point) -> OutputIt
+{
+    // Buffer is large enough to hold digits (digits10 + 1) and a decimal point.
+    Char buffer[digits10<UInt>() + 2];
+    auto end = write_significand(buffer, significand, significand_size, integral_size, decimal_point);
+    return detail::copy_str_noinline<Char>(buffer, end, out);
+}
+
+template<typename OutputIt, typename Char>
+FMT_CONSTEXPR auto write_significand(OutputIt out, const char *significand, int significand_size, int integral_size, Char decimal_point)
+    -> OutputIt
+{
+    out = detail::copy_str_noinline<Char>(significand, significand + integral_size, out);
+    if (!decimal_point)
+        return out;
+    *out++ = decimal_point;
+    return detail::copy_str_noinline<Char>(significand + integral_size, significand + significand_size, out);
+}
+
+template<typename OutputIt, typename Char, typename T, typename Grouping>
+FMT_CONSTEXPR20 auto write_significand(
+    OutputIt out, T significand, int significand_size, int integral_size, Char decimal_point, const Grouping &grouping) -> OutputIt
+{
+    if (!grouping.separator())
+    {
+        return write_significand(out, significand, significand_size, integral_size, decimal_point);
+    }
+    auto buffer = basic_memory_buffer<Char>();
+    write_significand(buffer_appender<Char>(buffer), significand, significand_size, integral_size, decimal_point);
+    grouping.apply(out, basic_string_view<Char>(buffer.data(), to_unsigned(integral_size)));
+    return detail::copy_str_noinline<Char>(buffer.data() + integral_size, buffer.end(), out);
+}
+
+template<typename OutputIt, typename DecimalFP, typename Char, typename Grouping = digit_grouping<Char>>
+FMT_CONSTEXPR20 auto do_write_float(
+    OutputIt out, const DecimalFP &f, const basic_format_specs<Char> &specs, float_specs fspecs, locale_ref loc) -> OutputIt
+{
+    auto significand = f.significand;
+    int significand_size = get_significand_size(f);
+    const Char zero = static_cast<Char>('0');
+    auto sign = fspecs.sign;
+    size_t size = to_unsigned(significand_size) + (sign ? 1 : 0);
+    using iterator = reserve_iterator<OutputIt>;
+
+    Char decimal_point = fspecs.locale ? detail::decimal_point<Char>(loc) : static_cast<Char>('.');
+
+    int output_exp = f.exponent + significand_size - 1;
+    auto use_exp_format = [=]() {
+        if (fspecs.format == float_format::exp)
+            return true;
+        if (fspecs.format != float_format::general)
+            return false;
+        // Use the fixed notation if the exponent is in [exp_lower, exp_upper),
+        // e.g. 0.0001 instead of 1e-04. Otherwise use the exponent notation.
+        const int exp_lower = -4, exp_upper = 16;
+        return output_exp < exp_lower || output_exp >= (fspecs.precision > 0 ? fspecs.precision : exp_upper);
+    };
+    if (use_exp_format())
+    {
+        int num_zeros = 0;
+        if (fspecs.showpoint)
+        {
+            num_zeros = fspecs.precision - significand_size;
+            if (num_zeros < 0)
+                num_zeros = 0;
+            size += to_unsigned(num_zeros);
+        }
+        else if (significand_size == 1)
+        {
+            decimal_point = Char();
+        }
+        auto abs_output_exp = output_exp >= 0 ? output_exp : -output_exp;
+        int exp_digits = 2;
+        if (abs_output_exp >= 100)
+            exp_digits = abs_output_exp >= 1000 ? 4 : 3;
+
+        size += to_unsigned((decimal_point ? 1 : 0) + 2 + exp_digits);
+        char exp_char = fspecs.upper ? 'E' : 'e';
+        auto write = [=](iterator it) {
+            if (sign)
+                *it++ = detail::sign<Char>(sign);
+            // Insert a decimal point after the first digit and add an exponent.
+            it = write_significand(it, significand, significand_size, 1, decimal_point);
+            if (num_zeros > 0)
+                it = detail::fill_n(it, num_zeros, zero);
+            *it++ = static_cast<Char>(exp_char);
+            return write_exponent<Char>(output_exp, it);
+        };
+        return specs.width > 0 ? write_padded<align::right>(out, specs, size, write) : base_iterator(out, write(reserve(out, size)));
+    }
+
+    int exp = f.exponent + significand_size;
+    if (f.exponent >= 0)
+    {
+        // 1234e5 -> 123400000[.0+]
+        size += to_unsigned(f.exponent);
+        int num_zeros = fspecs.precision - exp;
+        abort_fuzzing_if(num_zeros > 5000);
+        if (fspecs.showpoint)
+        {
+            ++size;
+            if (num_zeros <= 0 && fspecs.format != float_format::fixed)
+                num_zeros = 1;
+            if (num_zeros > 0)
+                size += to_unsigned(num_zeros);
+        }
+        auto grouping = Grouping(loc, fspecs.locale);
+        size += to_unsigned(grouping.count_separators(exp));
+        return write_padded<align::right>(out, specs, size, [&](iterator it) {
+            if (sign)
+                *it++ = detail::sign<Char>(sign);
+            it = write_significand<Char>(it, significand, significand_size, f.exponent, grouping);
+            if (!fspecs.showpoint)
+                return it;
+            *it++ = decimal_point;
+            return num_zeros > 0 ? detail::fill_n(it, num_zeros, zero) : it;
+        });
+    }
+    else if (exp > 0)
+    {
+        // 1234e-2 -> 12.34[0+]
+        int num_zeros = fspecs.showpoint ? fspecs.precision - significand_size : 0;
+        size += 1 + to_unsigned(num_zeros > 0 ? num_zeros : 0);
+        auto grouping = Grouping(loc, fspecs.locale);
+        size += to_unsigned(grouping.count_separators(significand_size));
+        return write_padded<align::right>(out, specs, size, [&](iterator it) {
+            if (sign)
+                *it++ = detail::sign<Char>(sign);
+            it = write_significand(it, significand, significand_size, exp, decimal_point, grouping);
+            return num_zeros > 0 ? detail::fill_n(it, num_zeros, zero) : it;
+        });
+    }
+    // 1234e-6 -> 0.001234
+    int num_zeros = -exp;
+    if (significand_size == 0 && fspecs.precision >= 0 && fspecs.precision < num_zeros)
+    {
+        num_zeros = fspecs.precision;
+    }
+    bool pointy = num_zeros != 0 || significand_size != 0 || fspecs.showpoint;
+    size += 1 + (pointy ? 1 : 0) + to_unsigned(num_zeros);
+    return write_padded<align::right>(out, specs, size, [&](iterator it) {
+        if (sign)
+            *it++ = detail::sign<Char>(sign);
+        *it++ = zero;
+        if (!pointy)
+            return it;
+        *it++ = decimal_point;
+        it = detail::fill_n(it, num_zeros, zero);
+        return write_significand<Char>(it, significand, significand_size);
+    });
+}
+
+template<typename Char>
+class fallback_digit_grouping
+{
+public:
+    constexpr fallback_digit_grouping(locale_ref, bool) {}
+
+    constexpr Char separator() const
+    {
+        return Char();
+    }
+
+    constexpr int count_separators(int) const
+    {
+        return 0;
+    }
+
+    template<typename Out, typename C>
+    constexpr Out apply(Out out, basic_string_view<C>) const
+    {
+        return out;
+    }
+};
+
+template<typename OutputIt, typename DecimalFP, typename Char>
+FMT_CONSTEXPR20 auto write_float(
+    OutputIt out, const DecimalFP &f, const basic_format_specs<Char> &specs, float_specs fspecs, locale_ref loc) -> OutputIt
+{
+    if (is_constant_evaluated())
+    {
+        return do_write_float<OutputIt, DecimalFP, Char, fallback_digit_grouping<Char>>(out, f, specs, fspecs, loc);
+    }
+    else
+    {
+        return do_write_float(out, f, specs, fspecs, loc);
+    }
+}
+
+template<typename T>
+constexpr bool isnan(T value)
+{
+    return !(value >= value); // std::isnan doesn't support __float128.
+}
+
+template<typename T, typename Enable = void>
+struct has_isfinite : std::false_type
+{};
+
+template<typename T>
+struct has_isfinite<T, enable_if_t<sizeof(std::isfinite(T())) != 0>> : std::true_type
+{};
+
+template<typename T, FMT_ENABLE_IF(std::is_floating_point<T>::value &&has_isfinite<T>::value)>
+FMT_CONSTEXPR20 bool isfinite(T value)
+{
+    constexpr T inf = T(std::numeric_limits<double>::infinity());
+    if (is_constant_evaluated())
+        return !detail::isnan(value) && value != inf && value != -inf;
+    return std::isfinite(value);
+}
+template<typename T, FMT_ENABLE_IF(!has_isfinite<T>::value)>
+FMT_CONSTEXPR bool isfinite(T value)
+{
+    T inf = T(std::numeric_limits<double>::infinity());
+    // std::isfinite doesn't support __float128.
+    return !detail::isnan(value) && value != inf && value != -inf;
+}
+
+template<typename T, FMT_ENABLE_IF(is_floating_point<T>::value)>
+FMT_INLINE FMT_CONSTEXPR bool signbit(T value)
+{
+    if (is_constant_evaluated())
+    {
+#ifdef __cpp_if_constexpr
+        if constexpr (std::numeric_limits<double>::is_iec559)
+        {
+            auto bits = detail::bit_cast<uint64_t>(static_cast<double>(value));
+            return (bits >> (num_bits<uint64_t>() - 1)) != 0;
+        }
+#endif
+    }
+    return std::signbit(static_cast<double>(value));
+}
+
+enum class round_direction
+{
+    unknown,
+    up,
+    down
+};
+
+// Given the divisor (normally a power of 10), the remainder = v % divisor for
+// some number v and the error, returns whether v should be rounded up, down, or
+// whether the rounding direction can't be determined due to error.
+// error should be less than divisor / 2.
+FMT_CONSTEXPR inline round_direction get_round_direction(uint64_t divisor, uint64_t remainder, uint64_t error)
+{
+    FMT_ASSERT(remainder < divisor, "");     // divisor - remainder won't overflow.
+    FMT_ASSERT(error < divisor, "");         // divisor - error won't overflow.
+    FMT_ASSERT(error < divisor - error, ""); // error * 2 won't overflow.
+    // Round down if (remainder + error) * 2 <= divisor.
+    if (remainder <= divisor - remainder && error * 2 <= divisor - remainder * 2)
+        return round_direction::down;
+    // Round up if (remainder - error) * 2 >= divisor.
+    if (remainder >= error && remainder - error >= divisor - (remainder - error))
+    {
+        return round_direction::up;
+    }
+    return round_direction::unknown;
+}
+
+namespace digits {
+enum result
+{
+    more, // Generate more digits.
+    done, // Done generating digits.
+    error // Digit generation cancelled due to an error.
+};
+}
+
+struct gen_digits_handler
+{
+    char *buf;
+    int size;
+    int precision;
+    int exp10;
+    bool fixed;
+
+    FMT_CONSTEXPR digits::result on_digit(char digit, uint64_t divisor, uint64_t remainder, uint64_t error, bool integral)
+    {
+        FMT_ASSERT(remainder < divisor, "");
+        buf[size++] = digit;
+        if (!integral && error >= remainder)
+            return digits::error;
+        if (size < precision)
+            return digits::more;
+        if (!integral)
+        {
+            // Check if error * 2 < divisor with overflow prevention.
+            // The check is not needed for the integral part because error = 1
+            // and divisor > (1 << 32) there.
+            if (error >= divisor || error >= divisor - error)
+                return digits::error;
+        }
+        else
+        {
+            FMT_ASSERT(error == 1 && divisor > 2, "");
+        }
+        auto dir = get_round_direction(divisor, remainder, error);
+        if (dir != round_direction::up)
+            return dir == round_direction::down ? digits::done : digits::error;
+        ++buf[size - 1];
+        for (int i = size - 1; i > 0 && buf[i] > '9'; --i)
+        {
+            buf[i] = '0';
+            ++buf[i - 1];
+        }
+        if (buf[0] > '9')
+        {
+            buf[0] = '1';
+            if (fixed)
+                buf[size++] = '0';
+            else
+                ++exp10;
+        }
+        return digits::done;
+    }
+};
+
+inline FMT_CONSTEXPR20 void adjust_precision(int &precision, int exp10)
+{
+    // Adjust fixed precision by exponent because it is relative to decimal
+    // point.
+    if (exp10 > 0 && precision > max_value<int>() - exp10)
+        FMT_THROW(format_error("number is too big"));
+    precision += exp10;
+}
+
+// Generates output using the Grisu digit-gen algorithm.
+// error: the size of the region (lower, upper) outside of which numbers
+// definitely do not round to value (Delta in Grisu3).
+FMT_INLINE FMT_CONSTEXPR20 auto grisu_gen_digits(fp value, uint64_t error, int &exp, gen_digits_handler &handler) -> digits::result
+{
+    const fp one(1ULL << -value.e, value.e);
+    // The integral part of scaled value (p1 in Grisu) = value / one. It cannot be
+    // zero because it contains a product of two 64-bit numbers with MSB set (due
+    // to normalization) - 1, shifted right by at most 60 bits.
+    auto integral = static_cast<uint32_t>(value.f >> -one.e);
+    FMT_ASSERT(integral != 0, "");
+    FMT_ASSERT(integral == value.f >> -one.e, "");
+    // The fractional part of scaled value (p2 in Grisu) c = value % one.
+    uint64_t fractional = value.f & (one.f - 1);
+    exp = count_digits(integral); // kappa in Grisu.
+    // Non-fixed formats require at least one digit and no precision adjustment.
+    if (handler.fixed)
+    {
+        adjust_precision(handler.precision, exp + handler.exp10);
+        // Check if precision is satisfied just by leading zeros, e.g.
+        // format("{:.2f}", 0.001) gives "0.00" without generating any digits.
+        if (handler.precision <= 0)
+        {
+            if (handler.precision < 0)
+                return digits::done;
+            // Divide by 10 to prevent overflow.
+            uint64_t divisor = data::power_of_10_64[exp - 1] << -one.e;
+            auto dir = get_round_direction(divisor, value.f / 10, error * 10);
+            if (dir == round_direction::unknown)
+                return digits::error;
+            handler.buf[handler.size++] = dir == round_direction::up ? '1' : '0';
+            return digits::done;
+        }
+    }
+    // Generate digits for the integral part. This can produce up to 10 digits.
+    do
+    {
+        uint32_t digit = 0;
+        auto divmod_integral = [&](uint32_t divisor) {
+            digit = integral / divisor;
+            integral %= divisor;
+        };
+        // This optimization by Milo Yip reduces the number of integer divisions by
+        // one per iteration.
+        switch (exp)
+        {
+        case 10:
+            divmod_integral(1000000000);
+            break;
+        case 9:
+            divmod_integral(100000000);
+            break;
+        case 8:
+            divmod_integral(10000000);
+            break;
+        case 7:
+            divmod_integral(1000000);
+            break;
+        case 6:
+            divmod_integral(100000);
+            break;
+        case 5:
+            divmod_integral(10000);
+            break;
+        case 4:
+            divmod_integral(1000);
+            break;
+        case 3:
+            divmod_integral(100);
+            break;
+        case 2:
+            divmod_integral(10);
+            break;
+        case 1:
+            digit = integral;
+            integral = 0;
+            break;
+        default:
+            FMT_ASSERT(false, "invalid number of digits");
+        }
+        --exp;
+        auto remainder = (static_cast<uint64_t>(integral) << -one.e) + fractional;
+        auto result = handler.on_digit(static_cast<char>('0' + digit), data::power_of_10_64[exp] << -one.e, remainder, error, true);
+        if (result != digits::more)
+            return result;
+    } while (exp > 0);
+    // Generate digits for the fractional part.
+    for (;;)
+    {
+        fractional *= 10;
+        error *= 10;
+        char digit = static_cast<char>('0' + (fractional >> -one.e));
+        fractional &= one.f - 1;
+        --exp;
+        auto result = handler.on_digit(digit, one.f, fractional, error, false);
+        if (result != digits::more)
+            return result;
+    }
+}
+
+class bigint
+{
+private:
+    // A bigint is stored as an array of bigits (big digits), with bigit at index
+    // 0 being the least significant one.
+    using bigit = uint32_t;
+    using double_bigit = uint64_t;
+    enum
+    {
+        bigits_capacity = 32
+    };
+    basic_memory_buffer<bigit, bigits_capacity> bigits_;
+    int exp_;
+
+    FMT_CONSTEXPR20 bigit operator[](int index) const
+    {
+        return bigits_[to_unsigned(index)];
+    }
+    FMT_CONSTEXPR20 bigit &operator[](int index)
+    {
+        return bigits_[to_unsigned(index)];
+    }
+
+    static constexpr const int bigit_bits = num_bits<bigit>();
+
+    friend struct formatter<bigint>;
+
+    FMT_CONSTEXPR20 void subtract_bigits(int index, bigit other, bigit &borrow)
+    {
+        auto result = static_cast<double_bigit>((*this)[index]) - other - borrow;
+        (*this)[index] = static_cast<bigit>(result);
+        borrow = static_cast<bigit>(result >> (bigit_bits * 2 - 1));
+    }
+
+    FMT_CONSTEXPR20 void remove_leading_zeros()
+    {
+        int num_bigits = static_cast<int>(bigits_.size()) - 1;
+        while (num_bigits > 0 && (*this)[num_bigits] == 0)
+            --num_bigits;
+        bigits_.resize(to_unsigned(num_bigits + 1));
+    }
+
+    // Computes *this -= other assuming aligned bigints and *this >= other.
+    FMT_CONSTEXPR20 void subtract_aligned(const bigint &other)
+    {
+        FMT_ASSERT(other.exp_ >= exp_, "unaligned bigints");
+        FMT_ASSERT(compare(*this, other) >= 0, "");
+        bigit borrow = 0;
+        int i = other.exp_ - exp_;
+        for (size_t j = 0, n = other.bigits_.size(); j != n; ++i, ++j)
+            subtract_bigits(i, other.bigits_[j], borrow);
+        while (borrow > 0)
+            subtract_bigits(i, 0, borrow);
+        remove_leading_zeros();
+    }
+
+    FMT_CONSTEXPR20 void multiply(uint32_t value)
+    {
+        const double_bigit wide_value = value;
+        bigit carry = 0;
+        for (size_t i = 0, n = bigits_.size(); i < n; ++i)
+        {
+            double_bigit result = bigits_[i] * wide_value + carry;
+            bigits_[i] = static_cast<bigit>(result);
+            carry = static_cast<bigit>(result >> bigit_bits);
+        }
+        if (carry != 0)
+            bigits_.push_back(carry);
+    }
+
+    template<typename UInt, FMT_ENABLE_IF(std::is_same<UInt, uint64_t>::value || std::is_same<UInt, uint128_t>::value)>
+    FMT_CONSTEXPR20 void multiply(UInt value)
+    {
+        using half_uint = conditional_t<std::is_same<UInt, uint128_t>::value, uint64_t, uint32_t>;
+        const int shift = num_bits<half_uint>() - bigit_bits;
+        const UInt lower = static_cast<half_uint>(value);
+        const UInt upper = value >> num_bits<half_uint>();
+        UInt carry = 0;
+        for (size_t i = 0, n = bigits_.size(); i < n; ++i)
+        {
+            UInt result = lower * bigits_[i] + static_cast<bigit>(carry);
+            carry = (upper * bigits_[i] << shift) + (result >> bigit_bits) + (carry >> bigit_bits);
+            bigits_[i] = static_cast<bigit>(result);
+        }
+        while (carry != 0)
+        {
+            bigits_.push_back(static_cast<bigit>(carry));
+            carry >>= bigit_bits;
+        }
+    }
+
+    template<typename UInt, FMT_ENABLE_IF(std::is_same<UInt, uint64_t>::value || std::is_same<UInt, uint128_t>::value)>
+    FMT_CONSTEXPR20 void assign(UInt n)
+    {
+        size_t num_bigits = 0;
+        do
+        {
+            bigits_[num_bigits++] = static_cast<bigit>(n);
+            n >>= bigit_bits;
+        } while (n != 0);
+        bigits_.resize(num_bigits);
+        exp_ = 0;
+    }
+
+public:
+    FMT_CONSTEXPR20 bigint()
+        : exp_(0)
+    {}
+    explicit bigint(uint64_t n)
+    {
+        assign(n);
+    }
+
+    bigint(const bigint &) = delete;
+    void operator=(const bigint &) = delete;
+
+    FMT_CONSTEXPR20 void assign(const bigint &other)
+    {
+        auto size = other.bigits_.size();
+        bigits_.resize(size);
+        auto data = other.bigits_.data();
+        std::copy(data, data + size, make_checked(bigits_.data(), size));
+        exp_ = other.exp_;
+    }
+
+    template<typename Int>
+    FMT_CONSTEXPR20 void operator=(Int n)
+    {
+        FMT_ASSERT(n > 0, "");
+        assign(uint64_or_128_t<Int>(n));
+    }
+
+    FMT_CONSTEXPR20 int num_bigits() const
+    {
+        return static_cast<int>(bigits_.size()) + exp_;
+    }
+
+    FMT_NOINLINE FMT_CONSTEXPR20 bigint &operator<<=(int shift)
+    {
+        FMT_ASSERT(shift >= 0, "");
+        exp_ += shift / bigit_bits;
+        shift %= bigit_bits;
+        if (shift == 0)
+            return *this;
+        bigit carry = 0;
+        for (size_t i = 0, n = bigits_.size(); i < n; ++i)
+        {
+            bigit c = bigits_[i] >> (bigit_bits - shift);
+            bigits_[i] = (bigits_[i] << shift) + carry;
+            carry = c;
+        }
+        if (carry != 0)
+            bigits_.push_back(carry);
+        return *this;
+    }
+
+    template<typename Int>
+    FMT_CONSTEXPR20 bigint &operator*=(Int value)
+    {
+        FMT_ASSERT(value > 0, "");
+        multiply(uint32_or_64_or_128_t<Int>(value));
+        return *this;
+    }
+
+    friend FMT_CONSTEXPR20 int compare(const bigint &lhs, const bigint &rhs)
+    {
+        int num_lhs_bigits = lhs.num_bigits(), num_rhs_bigits = rhs.num_bigits();
+        if (num_lhs_bigits != num_rhs_bigits)
+            return num_lhs_bigits > num_rhs_bigits ? 1 : -1;
+        int i = static_cast<int>(lhs.bigits_.size()) - 1;
+        int j = static_cast<int>(rhs.bigits_.size()) - 1;
+        int end = i - j;
+        if (end < 0)
+            end = 0;
+        for (; i >= end; --i, --j)
+        {
+            bigit lhs_bigit = lhs[i], rhs_bigit = rhs[j];
+            if (lhs_bigit != rhs_bigit)
+                return lhs_bigit > rhs_bigit ? 1 : -1;
+        }
+        if (i != j)
+            return i > j ? 1 : -1;
+        return 0;
+    }
+
+    // Returns compare(lhs1 + lhs2, rhs).
+    friend FMT_CONSTEXPR20 int add_compare(const bigint &lhs1, const bigint &lhs2, const bigint &rhs)
+    {
+        auto minimum = [](int a, int b) { return a < b ? a : b; };
+        auto maximum = [](int a, int b) { return a > b ? a : b; };
+        int max_lhs_bigits = maximum(lhs1.num_bigits(), lhs2.num_bigits());
+        int num_rhs_bigits = rhs.num_bigits();
+        if (max_lhs_bigits + 1 < num_rhs_bigits)
+            return -1;
+        if (max_lhs_bigits > num_rhs_bigits)
+            return 1;
+        auto get_bigit = [](const bigint &n, int i) -> bigit { return i >= n.exp_ && i < n.num_bigits() ? n[i - n.exp_] : 0; };
+        double_bigit borrow = 0;
+        int min_exp = minimum(minimum(lhs1.exp_, lhs2.exp_), rhs.exp_);
+        for (int i = num_rhs_bigits - 1; i >= min_exp; --i)
+        {
+            double_bigit sum = static_cast<double_bigit>(get_bigit(lhs1, i)) + get_bigit(lhs2, i);
+            bigit rhs_bigit = get_bigit(rhs, i);
+            if (sum > rhs_bigit + borrow)
+                return 1;
+            borrow = rhs_bigit + borrow - sum;
+            if (borrow > 1)
+                return -1;
+            borrow <<= bigit_bits;
+        }
+        return borrow != 0 ? -1 : 0;
+    }
+
+    // Assigns pow(10, exp) to this bigint.
+    FMT_CONSTEXPR20 void assign_pow10(int exp)
+    {
+        FMT_ASSERT(exp >= 0, "");
+        if (exp == 0)
+            return *this = 1;
+        // Find the top bit.
+        int bitmask = 1;
+        while (exp >= bitmask)
+            bitmask <<= 1;
+        bitmask >>= 1;
+        // pow(10, exp) = pow(5, exp) * pow(2, exp). First compute pow(5, exp) by
+        // repeated squaring and multiplication.
+        *this = 5;
+        bitmask >>= 1;
+        while (bitmask != 0)
+        {
+            square();
+            if ((exp & bitmask) != 0)
+                *this *= 5;
+            bitmask >>= 1;
+        }
+        *this <<= exp; // Multiply by pow(2, exp) by shifting.
+    }
+
+    FMT_CONSTEXPR20 void square()
+    {
+        int num_bigits = static_cast<int>(bigits_.size());
+        int num_result_bigits = 2 * num_bigits;
+        basic_memory_buffer<bigit, bigits_capacity> n(std::move(bigits_));
+        bigits_.resize(to_unsigned(num_result_bigits));
+        auto sum = uint128_t();
+        for (int bigit_index = 0; bigit_index < num_bigits; ++bigit_index)
+        {
+            // Compute bigit at position bigit_index of the result by adding
+            // cross-product terms n[i] * n[j] such that i + j == bigit_index.
+            for (int i = 0, j = bigit_index; j >= 0; ++i, --j)
+            {
+                // Most terms are multiplied twice which can be optimized in the future.
+                sum += static_cast<double_bigit>(n[i]) * n[j];
+            }
+            (*this)[bigit_index] = static_cast<bigit>(sum);
+            sum >>= num_bits<bigit>(); // Compute the carry.
+        }
+        // Do the same for the top half.
+        for (int bigit_index = num_bigits; bigit_index < num_result_bigits; ++bigit_index)
+        {
+            for (int j = num_bigits - 1, i = bigit_index - j; i < num_bigits;)
+                sum += static_cast<double_bigit>(n[i++]) * n[j--];
+            (*this)[bigit_index] = static_cast<bigit>(sum);
+            sum >>= num_bits<bigit>();
+        }
+        remove_leading_zeros();
+        exp_ *= 2;
+    }
+
+    // If this bigint has a bigger exponent than other, adds trailing zero to make
+    // exponents equal. This simplifies some operations such as subtraction.
+    FMT_CONSTEXPR20 void align(const bigint &other)
+    {
+        int exp_difference = exp_ - other.exp_;
+        if (exp_difference <= 0)
+            return;
+        int num_bigits = static_cast<int>(bigits_.size());
+        bigits_.resize(to_unsigned(num_bigits + exp_difference));
+        for (int i = num_bigits - 1, j = i + exp_difference; i >= 0; --i, --j)
+            bigits_[j] = bigits_[i];
+        std::uninitialized_fill_n(bigits_.data(), exp_difference, 0);
+        exp_ -= exp_difference;
+    }
+
+    // Divides this bignum by divisor, assigning the remainder to this and
+    // returning the quotient.
+    FMT_CONSTEXPR20 int divmod_assign(const bigint &divisor)
+    {
+        FMT_ASSERT(this != &divisor, "");
+        if (compare(*this, divisor) < 0)
+            return 0;
+        FMT_ASSERT(divisor.bigits_[divisor.bigits_.size() - 1u] != 0, "");
+        align(divisor);
+        int quotient = 0;
+        do
+        {
+            subtract_aligned(divisor);
+            ++quotient;
+        } while (compare(*this, divisor) >= 0);
+        return quotient;
+    }
+};
+
+// format_dragon flags.
+enum dragon
+{
+    predecessor_closer = 1,
+    fixup = 2, // Run fixup to correct exp10 which can be off by one.
+    fixed = 4,
+};
+
+// Formats a floating-point number using a variation of the Fixed-Precision
+// Positive Floating-Point Printout ((FPP)^2) algorithm by Steele & White:
+// https://fmt.dev/papers/p372-steele.pdf.
+FMT_CONSTEXPR20 inline void format_dragon(basic_fp<uint128_t> value, unsigned flags, int num_digits, buffer<char> &buf, int &exp10)
+{
+    bigint numerator;   // 2 * R in (FPP)^2.
+    bigint denominator; // 2 * S in (FPP)^2.
+    // lower and upper are differences between value and corresponding boundaries.
+    bigint lower;            // (M^- in (FPP)^2).
+    bigint upper_store;      // upper's value if different from lower.
+    bigint *upper = nullptr; // (M^+ in (FPP)^2).
+    // Shift numerator and denominator by an extra bit or two (if lower boundary
+    // is closer) to make lower and upper integers. This eliminates multiplication
+    // by 2 during later computations.
+    bool is_predecessor_closer = (flags & dragon::predecessor_closer) != 0;
+    int shift = is_predecessor_closer ? 2 : 1;
+    if (value.e >= 0)
+    {
+        numerator = value.f;
+        numerator <<= value.e + shift;
+        lower = 1;
+        lower <<= value.e;
+        if (is_predecessor_closer)
+        {
+            upper_store = 1;
+            upper_store <<= value.e + 1;
+            upper = &upper_store;
+        }
+        denominator.assign_pow10(exp10);
+        denominator <<= shift;
+    }
+    else if (exp10 < 0)
+    {
+        numerator.assign_pow10(-exp10);
+        lower.assign(numerator);
+        if (is_predecessor_closer)
+        {
+            upper_store.assign(numerator);
+            upper_store <<= 1;
+            upper = &upper_store;
+        }
+        numerator *= value.f;
+        numerator <<= shift;
+        denominator = 1;
+        denominator <<= shift - value.e;
+    }
+    else
+    {
+        numerator = value.f;
+        numerator <<= shift;
+        denominator.assign_pow10(exp10);
+        denominator <<= shift - value.e;
+        lower = 1;
+        if (is_predecessor_closer)
+        {
+            upper_store = 1ULL << 1;
+            upper = &upper_store;
+        }
+    }
+    int even = static_cast<int>((value.f & 1) == 0);
+    if (!upper)
+        upper = &lower;
+    if ((flags & dragon::fixup) != 0)
+    {
+        if (add_compare(numerator, *upper, denominator) + even <= 0)
+        {
+            --exp10;
+            numerator *= 10;
+            if (num_digits < 0)
+            {
+                lower *= 10;
+                if (upper != &lower)
+                    *upper *= 10;
+            }
+        }
+        if ((flags & dragon::fixed) != 0)
+            adjust_precision(num_digits, exp10 + 1);
+    }
+    // Invariant: value == (numerator / denominator) * pow(10, exp10).
+    if (num_digits < 0)
+    {
+        // Generate the shortest representation.
+        num_digits = 0;
+        char *data = buf.data();
+        for (;;)
+        {
+            int digit = numerator.divmod_assign(denominator);
+            bool low = compare(numerator, lower) - even < 0; // numerator <[=] lower.
+            // numerator + upper >[=] pow10:
+            bool high = add_compare(numerator, *upper, denominator) + even > 0;
+            data[num_digits++] = static_cast<char>('0' + digit);
+            if (low || high)
+            {
+                if (!low)
+                {
+                    ++data[num_digits - 1];
+                }
+                else if (high)
+                {
+                    int result = add_compare(numerator, numerator, denominator);
+                    // Round half to even.
+                    if (result > 0 || (result == 0 && (digit % 2) != 0))
+                        ++data[num_digits - 1];
+                }
+                buf.try_resize(to_unsigned(num_digits));
+                exp10 -= num_digits - 1;
+                return;
+            }
+            numerator *= 10;
+            lower *= 10;
+            if (upper != &lower)
+                *upper *= 10;
+        }
+    }
+    // Generate the given number of digits.
+    exp10 -= num_digits - 1;
+    if (num_digits == 0)
+    {
+        denominator *= 10;
+        auto digit = add_compare(numerator, numerator, denominator) > 0 ? '1' : '0';
+        buf.push_back(digit);
+        return;
+    }
+    buf.try_resize(to_unsigned(num_digits));
+    for (int i = 0; i < num_digits - 1; ++i)
+    {
+        int digit = numerator.divmod_assign(denominator);
+        buf[i] = static_cast<char>('0' + digit);
+        numerator *= 10;
+    }
+    int digit = numerator.divmod_assign(denominator);
+    auto result = add_compare(numerator, numerator, denominator);
+    if (result > 0 || (result == 0 && (digit % 2) != 0))
+    {
+        if (digit == 9)
+        {
+            const auto overflow = '0' + 10;
+            buf[num_digits - 1] = overflow;
+            // Propagate the carry.
+            for (int i = num_digits - 1; i > 0 && buf[i] == overflow; --i)
+            {
+                buf[i] = '0';
+                ++buf[i - 1];
+            }
+            if (buf[0] == overflow)
+            {
+                buf[0] = '1';
+                ++exp10;
+            }
+            return;
+        }
+        ++digit;
+    }
+    buf[num_digits - 1] = static_cast<char>('0' + digit);
+}
+
+template<typename Float>
+FMT_CONSTEXPR20 auto format_float(Float value, int precision, float_specs specs, buffer<char> &buf) -> int
+{
+    // float is passed as double to reduce the number of instantiations.
+    static_assert(!std::is_same<Float, float>::value, "");
+    FMT_ASSERT(value >= 0, "value is negative");
+    auto converted_value = convert_float(value);
+
+    const bool fixed = specs.format == float_format::fixed;
+    if (value <= 0)
+    { // <= instead of == to silence a warning.
+        if (precision <= 0 || !fixed)
+        {
+            buf.push_back('0');
+            return 0;
+        }
+        buf.try_resize(to_unsigned(precision));
+        fill_n(buf.data(), precision, '0');
+        return -precision;
+    }
+
+    int exp = 0;
+    bool use_dragon = true;
+    unsigned dragon_flags = 0;
+    if (!is_fast_float<Float>())
+    {
+        const auto inv_log2_10 = 0.3010299956639812; // 1 / log2(10)
+        using info = dragonbox::float_info<decltype(converted_value)>;
+        const auto f = basic_fp<typename info::carrier_uint>(converted_value);
+        // Compute exp, an approximate power of 10, such that
+        //   10^(exp - 1) <= value < 10^exp or 10^exp <= value < 10^(exp + 1).
+        // This is based on log10(value) == log2(value) / log2(10) and approximation
+        // of log2(value) by e + num_fraction_bits idea from double-conversion.
+        exp = static_cast<int>(std::ceil((f.e + count_digits<1>(f.f) - 1) * inv_log2_10 - 1e-10));
+        dragon_flags = dragon::fixup;
+    }
+    else if (!is_constant_evaluated() && precision < 0)
+    {
+        // Use Dragonbox for the shortest format.
+        if (specs.binary32)
+        {
+            auto dec = dragonbox::to_decimal(static_cast<float>(value));
+            write<char>(buffer_appender<char>(buf), dec.significand);
+            return dec.exponent;
+        }
+        auto dec = dragonbox::to_decimal(static_cast<double>(value));
+        write<char>(buffer_appender<char>(buf), dec.significand);
+        return dec.exponent;
+    }
+    else
+    {
+        // Use Grisu + Dragon4 for the given precision:
+        // https://www.cs.tufts.edu/~nr/cs257/archive/florian-loitsch/printf.pdf.
+        const int min_exp = -60; // alpha in Grisu.
+        int cached_exp10 = 0;    // K in Grisu.
+        fp normalized = normalize(fp(converted_value));
+        const auto cached_pow = get_cached_power(min_exp - (normalized.e + fp::num_significand_bits), cached_exp10);
+        normalized = normalized * cached_pow;
+        gen_digits_handler handler{buf.data(), 0, precision, -cached_exp10, fixed};
+        if (grisu_gen_digits(normalized, 1, exp, handler) != digits::error && !is_constant_evaluated())
+        {
+            exp += handler.exp10;
+            buf.try_resize(to_unsigned(handler.size));
+            use_dragon = false;
+        }
+        else
+        {
+            exp += handler.size - cached_exp10 - 1;
+            precision = handler.precision;
+        }
+    }
+    if (use_dragon)
+    {
+        auto f = basic_fp<uint128_t>();
+        bool is_predecessor_closer = specs.binary32 ? f.assign(static_cast<float>(value)) : f.assign(converted_value);
+        if (is_predecessor_closer)
+            dragon_flags |= dragon::predecessor_closer;
+        if (fixed)
+            dragon_flags |= dragon::fixed;
+        // Limit precision to the maximum possible number of significant digits in
+        // an IEEE754 double because we don't need to generate zeros.
+        const int max_double_digits = 767;
+        if (precision > max_double_digits)
+            precision = max_double_digits;
+        format_dragon(f, dragon_flags, precision, buf, exp);
+    }
+    if (!fixed && !specs.showpoint)
+    {
+        // Remove trailing zeros.
+        auto num_digits = buf.size();
+        while (num_digits > 0 && buf[num_digits - 1] == '0')
+        {
+            --num_digits;
+            ++exp;
+        }
+        buf.try_resize(num_digits);
+    }
+    return exp;
+}
+
+template<typename Char, typename OutputIt, typename T, FMT_ENABLE_IF(is_floating_point<T>::value)>
+FMT_CONSTEXPR20 auto write(OutputIt out, T value, basic_format_specs<Char> specs, locale_ref loc = {}) -> OutputIt
+{
+    if (const_check(!is_supported_floating_point(value)))
+        return out;
+    float_specs fspecs = parse_float_type_spec(specs);
+    fspecs.sign = specs.sign;
+    if (detail::signbit(value))
+    { // value < 0 is false for NaN so use signbit.
+        fspecs.sign = sign::minus;
+        value = -value;
+    }
+    else if (fspecs.sign == sign::minus)
+    {
+        fspecs.sign = sign::none;
+    }
+
+    if (!detail::isfinite(value))
+        return write_nonfinite(out, detail::isnan(value), specs, fspecs);
+
+    if (specs.align == align::numeric && fspecs.sign)
+    {
+        auto it = reserve(out, 1);
+        *it++ = detail::sign<Char>(fspecs.sign);
+        out = base_iterator(out, it);
+        fspecs.sign = sign::none;
+        if (specs.width != 0)
+            --specs.width;
+    }
+
+    memory_buffer buffer;
+    if (fspecs.format == float_format::hex)
+    {
+        if (fspecs.sign)
+            buffer.push_back(detail::sign<char>(fspecs.sign));
+        snprintf_float(convert_float(value), specs.precision, fspecs, buffer);
+        return write_bytes<align::right>(out, {buffer.data(), buffer.size()}, specs);
+    }
+    int precision = specs.precision >= 0 || specs.type == presentation_type::none ? specs.precision : 6;
+    if (fspecs.format == float_format::exp)
+    {
+        if (precision == max_value<int>())
+            throw_format_error("number is too big");
+        else
+            ++precision;
+    }
+    else if (fspecs.format != float_format::fixed && precision == 0)
+    {
+        precision = 1;
+    }
+    if (const_check(std::is_same<T, float>()))
+        fspecs.binary32 = true;
+    int exp = format_float(convert_float(value), precision, fspecs, buffer);
+    fspecs.precision = precision;
+    auto f = big_decimal_fp{buffer.data(), static_cast<int>(buffer.size()), exp};
+    return write_float(out, f, specs, fspecs, loc);
+}
+
+template<typename Char, typename OutputIt, typename T, FMT_ENABLE_IF(is_fast_float<T>::value)>
+FMT_CONSTEXPR20 auto write(OutputIt out, T value) -> OutputIt
+{
+    if (is_constant_evaluated())
+        return write(out, value, basic_format_specs<Char>());
+    if (const_check(!is_supported_floating_point(value)))
+        return out;
+
+    auto fspecs = float_specs();
+    if (detail::signbit(value))
+    {
+        fspecs.sign = sign::minus;
+        value = -value;
+    }
+
+    constexpr auto specs = basic_format_specs<Char>();
+    using floaty = conditional_t<std::is_same<T, long double>::value, double, T>;
+    using uint = typename dragonbox::float_info<floaty>::carrier_uint;
+    uint mask = exponent_mask<floaty>();
+    if ((bit_cast<uint>(value) & mask) == mask)
+        return write_nonfinite(out, std::isnan(value), specs, fspecs);
+
+    auto dec = dragonbox::to_decimal(static_cast<floaty>(value));
+    return write_float(out, dec, specs, fspecs, {});
+}
+
+template<typename Char, typename OutputIt, typename T, FMT_ENABLE_IF(is_floating_point<T>::value && !is_fast_float<T>::value)>
+inline auto write(OutputIt out, T value) -> OutputIt
+{
+    return write(out, value, basic_format_specs<Char>());
+}
+
+template<typename Char, typename OutputIt>
+auto write(OutputIt out, monostate, basic_format_specs<Char> = {}, locale_ref = {}) -> OutputIt
+{
+    FMT_ASSERT(false, "");
+    return out;
+}
+
+template<typename Char, typename OutputIt>
+FMT_CONSTEXPR auto write(OutputIt out, basic_string_view<Char> value) -> OutputIt
+{
+    auto it = reserve(out, value.size());
+    it = copy_str_noinline<Char>(value.begin(), value.end(), it);
+    return base_iterator(out, it);
+}
+
+template<typename Char, typename OutputIt, typename T, FMT_ENABLE_IF(is_string<T>::value)>
+constexpr auto write(OutputIt out, const T &value) -> OutputIt
+{
+    return write<Char>(out, to_string_view(value));
+}
+
+// FMT_ENABLE_IF() condition separated to workaround an MSVC bug.
+template<typename Char, typename OutputIt, typename T,
+    bool check = std::is_enum<T>::value && !std::is_same<T, Char>::value &&
+                 mapped_type_constant<T, basic_format_context<OutputIt, Char>>::value != type::custom_type,
+    FMT_ENABLE_IF(check)>
+FMT_CONSTEXPR auto write(OutputIt out, T value) -> OutputIt
+{
+    return write<Char>(out, static_cast<underlying_t<T>>(value));
+}
+
+template<typename Char, typename OutputIt, typename T, FMT_ENABLE_IF(std::is_same<T, bool>::value)>
+FMT_CONSTEXPR auto write(OutputIt out, T value, const basic_format_specs<Char> &specs = {}, locale_ref = {}) -> OutputIt
+{
+    return specs.type != presentation_type::none && specs.type != presentation_type::string
+               ? write(out, value ? 1 : 0, specs, {})
+               : write_bytes(out, value ? "true" : "false", specs);
+}
+
+template<typename Char, typename OutputIt>
+FMT_CONSTEXPR auto write(OutputIt out, Char value) -> OutputIt
+{
+    auto it = reserve(out, 1);
+    *it++ = value;
+    return base_iterator(out, it);
+}
+
+template<typename Char, typename OutputIt>
+FMT_CONSTEXPR_CHAR_TRAITS auto write(OutputIt out, const Char *value) -> OutputIt
+{
+    if (!value)
+    {
+        throw_format_error("string pointer is null");
+    }
+    else
+    {
+        out = write(out, basic_string_view<Char>(value));
+    }
+    return out;
+}
+
+template<typename Char, typename OutputIt, typename T, FMT_ENABLE_IF(std::is_same<T, void>::value)>
+auto write(OutputIt out, const T *value, const basic_format_specs<Char> &specs = {}, locale_ref = {}) -> OutputIt
+{
+    check_pointer_type_spec(specs.type, error_handler());
+    return write_ptr<Char>(out, bit_cast<uintptr_t>(value), &specs);
+}
+
+// A write overload that handles implicit conversions.
+template<typename Char, typename OutputIt, typename T, typename Context = basic_format_context<OutputIt, Char>>
+FMT_CONSTEXPR auto write(OutputIt out, const T &value)
+    -> enable_if_t<std::is_class<T>::value && !is_string<T>::value && !is_floating_point<T>::value && !std::is_same<T, Char>::value &&
+                       !std::is_same<const T &, decltype(arg_mapper<Context>().map(value))>::value,
+        OutputIt>
+{
+    return write<Char>(out, arg_mapper<Context>().map(value));
+}
+
+template<typename Char, typename OutputIt, typename T, typename Context = basic_format_context<OutputIt, Char>>
+FMT_CONSTEXPR auto write(OutputIt out, const T &value)
+    -> enable_if_t<mapped_type_constant<T, Context>::value == type::custom_type, OutputIt>
+{
+    using formatter_type =
+        conditional_t<has_formatter<T, Context>::value, typename Context::template formatter_type<T>, fallback_formatter<T, Char>>;
+    auto ctx = Context(out, {}, {});
+    return formatter_type().format(value, ctx);
+}
+
+// An argument visitor that formats the argument and writes it via the output
+// iterator. It's a class and not a generic lambda for compatibility with C++11.
+template<typename Char>
+struct default_arg_formatter
+{
+    using iterator = buffer_appender<Char>;
+    using context = buffer_context<Char>;
+
+    iterator out;
+    basic_format_args<context> args;
+    locale_ref loc;
+
+    template<typename T>
+    auto operator()(T value) -> iterator
+    {
+        return write<Char>(out, value);
+    }
+    auto operator()(typename basic_format_arg<context>::handle h) -> iterator
+    {
+        basic_format_parse_context<Char> parse_ctx({});
+        context format_ctx(out, args, loc);
+        h.format(parse_ctx, format_ctx);
+        return format_ctx.out();
+    }
+};
+
+template<typename Char>
+struct arg_formatter
+{
+    using iterator = buffer_appender<Char>;
+    using context = buffer_context<Char>;
+
+    iterator out;
+    const basic_format_specs<Char> &specs;
+    locale_ref locale;
+
+    template<typename T>
+    FMT_CONSTEXPR FMT_INLINE auto operator()(T value) -> iterator
+    {
+        return detail::write(out, value, specs, locale);
+    }
+    auto operator()(typename basic_format_arg<context>::handle) -> iterator
+    {
+        // User-defined types are handled separately because they require access
+        // to the parse context.
+        return out;
+    }
+};
+
+template<typename Char>
+struct custom_formatter
+{
+    basic_format_parse_context<Char> &parse_ctx;
+    buffer_context<Char> &ctx;
+
+    void operator()(typename basic_format_arg<buffer_context<Char>>::handle h) const
+    {
+        h.format(parse_ctx, ctx);
+    }
+    template<typename T>
+    void operator()(T) const
+    {}
+};
+
+template<typename T>
+using is_integer = bool_constant<is_integral<T>::value && !std::is_same<T, bool>::value && !std::is_same<T, char>::value &&
+                                 !std::is_same<T, wchar_t>::value>;
+
+template<typename ErrorHandler>
+class width_checker
+{
+public:
+    explicit FMT_CONSTEXPR width_checker(ErrorHandler &eh)
+        : handler_(eh)
+    {}
+
+    template<typename T, FMT_ENABLE_IF(is_integer<T>::value)>
+    FMT_CONSTEXPR auto operator()(T value) -> unsigned long long
+    {
+        if (is_negative(value))
+            handler_.on_error("negative width");
+        return static_cast<unsigned long long>(value);
+    }
+
+    template<typename T, FMT_ENABLE_IF(!is_integer<T>::value)>
+    FMT_CONSTEXPR auto operator()(T) -> unsigned long long
+    {
+        handler_.on_error("width is not integer");
+        return 0;
+    }
+
+private:
+    ErrorHandler &handler_;
+};
+
+template<typename ErrorHandler>
+class precision_checker
+{
+public:
+    explicit FMT_CONSTEXPR precision_checker(ErrorHandler &eh)
+        : handler_(eh)
+    {}
+
+    template<typename T, FMT_ENABLE_IF(is_integer<T>::value)>
+    FMT_CONSTEXPR auto operator()(T value) -> unsigned long long
+    {
+        if (is_negative(value))
+            handler_.on_error("negative precision");
+        return static_cast<unsigned long long>(value);
+    }
+
+    template<typename T, FMT_ENABLE_IF(!is_integer<T>::value)>
+    FMT_CONSTEXPR auto operator()(T) -> unsigned long long
+    {
+        handler_.on_error("precision is not integer");
+        return 0;
+    }
+
+private:
+    ErrorHandler &handler_;
+};
+
+template<template<typename> class Handler, typename FormatArg, typename ErrorHandler>
+FMT_CONSTEXPR auto get_dynamic_spec(FormatArg arg, ErrorHandler eh) -> int
+{
+    unsigned long long value = visit_format_arg(Handler<ErrorHandler>(eh), arg);
+    if (value > to_unsigned(max_value<int>()))
+        eh.on_error("number is too big");
+    return static_cast<int>(value);
+}
+
+template<typename Context, typename ID>
+FMT_CONSTEXPR auto get_arg(Context &ctx, ID id) -> typename Context::format_arg
+{
+    auto arg = ctx.arg(id);
+    if (!arg)
+        ctx.on_error("argument not found");
+    return arg;
+}
+
+// The standard format specifier handler with checking.
+template<typename Char>
+class specs_handler : public specs_setter<Char>
+{
+private:
+    basic_format_parse_context<Char> &parse_context_;
+    buffer_context<Char> &context_;
+
+    // This is only needed for compatibility with gcc 4.4.
+    using format_arg = basic_format_arg<buffer_context<Char>>;
+
+    FMT_CONSTEXPR auto get_arg(auto_id) -> format_arg
+    {
+        return detail::get_arg(context_, parse_context_.next_arg_id());
+    }
+
+    FMT_CONSTEXPR auto get_arg(int arg_id) -> format_arg
+    {
+        parse_context_.check_arg_id(arg_id);
+        return detail::get_arg(context_, arg_id);
+    }
+
+    FMT_CONSTEXPR auto get_arg(basic_string_view<Char> arg_id) -> format_arg
+    {
+        parse_context_.check_arg_id(arg_id);
+        return detail::get_arg(context_, arg_id);
+    }
+
+public:
+    FMT_CONSTEXPR specs_handler(basic_format_specs<Char> &specs, basic_format_parse_context<Char> &parse_ctx, buffer_context<Char> &ctx)
+        : specs_setter<Char>(specs)
+        , parse_context_(parse_ctx)
+        , context_(ctx)
+    {}
+
+    template<typename Id>
+    FMT_CONSTEXPR void on_dynamic_width(Id arg_id)
+    {
+        this->specs_.width = get_dynamic_spec<width_checker>(get_arg(arg_id), context_.error_handler());
+    }
+
+    template<typename Id>
+    FMT_CONSTEXPR void on_dynamic_precision(Id arg_id)
+    {
+        this->specs_.precision = get_dynamic_spec<precision_checker>(get_arg(arg_id), context_.error_handler());
+    }
+
+    void on_error(const char *message)
+    {
+        context_.on_error(message);
+    }
+};
+
+template<template<typename> class Handler, typename Context>
+FMT_CONSTEXPR void handle_dynamic_spec(int &value, arg_ref<typename Context::char_type> ref, Context &ctx)
+{
+    switch (ref.kind)
+    {
+    case arg_id_kind::none:
+        break;
+    case arg_id_kind::index:
+        value = detail::get_dynamic_spec<Handler>(ctx.arg(ref.val.index), ctx.error_handler());
+        break;
+    case arg_id_kind::name:
+        value = detail::get_dynamic_spec<Handler>(ctx.arg(ref.val.name), ctx.error_handler());
+        break;
+    }
+}
+
+#if FMT_USE_USER_DEFINED_LITERALS
+template<typename Char>
+struct udl_formatter
+{
+    basic_string_view<Char> str;
+
+    template<typename... T>
+    auto operator()(T &&...args) const -> std::basic_string<Char>
+    {
+        return vformat(str, fmt::make_format_args<buffer_context<Char>>(args...));
+    }
+};
+
+#    if FMT_USE_NONTYPE_TEMPLATE_ARGS
+template<typename T, typename Char, size_t N, fmt::detail_exported::fixed_string<Char, N> Str>
+struct statically_named_arg : view
+{
+    static constexpr auto name = Str.data;
+
+    const T &value;
+    statically_named_arg(const T &v)
+        : value(v)
+    {}
+};
+
+template<typename T, typename Char, size_t N, fmt::detail_exported::fixed_string<Char, N> Str>
+struct is_named_arg<statically_named_arg<T, Char, N, Str>> : std::true_type
+{};
+
+template<typename T, typename Char, size_t N, fmt::detail_exported::fixed_string<Char, N> Str>
+struct is_statically_named_arg<statically_named_arg<T, Char, N, Str>> : std::true_type
+{};
+
+template<typename Char, size_t N, fmt::detail_exported::fixed_string<Char, N> Str>
+struct udl_arg
+{
+    template<typename T>
+    auto operator=(T &&value) const
+    {
+        return statically_named_arg<T, Char, N, Str>(std::forward<T>(value));
+    }
+};
+#    else
+template<typename Char>
+struct udl_arg
+{
+    const Char *str;
+
+    template<typename T>
+    auto operator=(T &&value) const -> named_arg<Char, T>
+    {
+        return {str, std::forward<T>(value)};
+    }
+};
+#    endif
+#endif // FMT_USE_USER_DEFINED_LITERALS
+
+template<typename Locale, typename Char>
+auto vformat(const Locale &loc, basic_string_view<Char> format_str, basic_format_args<buffer_context<type_identity_t<Char>>> args)
+    -> std::basic_string<Char>
+{
+    basic_memory_buffer<Char> buffer;
+    detail::vformat_to(buffer, format_str, args, detail::locale_ref(loc));
+    return {buffer.data(), buffer.size()};
+}
+
+using format_func = void (*)(detail::buffer<char> &, int, const char *);
+
+FMT_API void format_error_code(buffer<char> &out, int error_code, string_view message) noexcept;
+
+FMT_API void report_error(format_func func, int error_code, const char *message) noexcept;
+FMT_END_DETAIL_NAMESPACE
+
+FMT_API auto vsystem_error(int error_code, string_view format_str, format_args args) -> std::system_error;
+
+/**
+ \rst
+ Constructs :class:`std::system_error` with a message formatted with
+ ``fmt::format(fmt, args...)``.
+  *error_code* is a system error code as given by ``errno``.
+
+ **Example**::
+
+   // This throws std::system_error with the description
+   //   cannot open file 'madeup': No such file or directory
+   // or similar (system message may vary).
+   const char* filename = "madeup";
+   std::FILE* file = std::fopen(filename, "r");
+   if (!file)
+     throw fmt::system_error(errno, "cannot open file '{}'", filename);
+ \endrst
+*/
+template<typename... T>
+auto system_error(int error_code, format_string<T...> fmt, T &&...args) -> std::system_error
+{
+    return vsystem_error(error_code, fmt, fmt::make_format_args(args...));
+}
+
+/**
+  \rst
+  Formats an error message for an error returned by an operating system or a
+  language runtime, for example a file opening error, and writes it to *out*.
+  The format is the same as the one used by ``std::system_error(ec, message)``
+  where ``ec`` is ``std::error_code(error_code, std::generic_category()})``.
+  It is implementation-defined but normally looks like:
+
+  .. parsed-literal::
+     *<message>*: *<system-message>*
+
+  where *<message>* is the passed message and *<system-message>* is the system
+  message corresponding to the error code.
+  *error_code* is a system error code as given by ``errno``.
+  \endrst
+ */
+FMT_API void format_system_error(detail::buffer<char> &out, int error_code, const char *message) noexcept;
+
+// Reports a system error without throwing an exception.
+// Can be used to report errors from destructors.
+FMT_API void report_system_error(int error_code, const char *message) noexcept;
+
+/** Fast integer formatter. */
+class format_int
+{
+private:
+    // Buffer should be large enough to hold all digits (digits10 + 1),
+    // a sign and a null character.
+    enum
+    {
+        buffer_size = std::numeric_limits<unsigned long long>::digits10 + 3
+    };
+    mutable char buffer_[buffer_size];
+    char *str_;
+
+    template<typename UInt>
+    auto format_unsigned(UInt value) -> char *
+    {
+        auto n = static_cast<detail::uint32_or_64_or_128_t<UInt>>(value);
+        return detail::format_decimal(buffer_, n, buffer_size - 1).begin;
+    }
+
+    template<typename Int>
+    auto format_signed(Int value) -> char *
+    {
+        auto abs_value = static_cast<detail::uint32_or_64_or_128_t<Int>>(value);
+        bool negative = value < 0;
+        if (negative)
+            abs_value = 0 - abs_value;
+        auto begin = format_unsigned(abs_value);
+        if (negative)
+            *--begin = '-';
+        return begin;
+    }
+
+public:
+    explicit format_int(int value)
+        : str_(format_signed(value))
+    {}
+    explicit format_int(long value)
+        : str_(format_signed(value))
+    {}
+    explicit format_int(long long value)
+        : str_(format_signed(value))
+    {}
+    explicit format_int(unsigned value)
+        : str_(format_unsigned(value))
+    {}
+    explicit format_int(unsigned long value)
+        : str_(format_unsigned(value))
+    {}
+    explicit format_int(unsigned long long value)
+        : str_(format_unsigned(value))
+    {}
+
+    /** Returns the number of characters written to the output buffer. */
+    auto size() const -> size_t
+    {
+        return detail::to_unsigned(buffer_ - str_ + buffer_size - 1);
+    }
+
+    /**
+      Returns a pointer to the output buffer content. No terminating null
+      character is appended.
+     */
+    auto data() const -> const char *
+    {
+        return str_;
+    }
+
+    /**
+      Returns a pointer to the output buffer content with terminating null
+      character appended.
+     */
+    auto c_str() const -> const char *
+    {
+        buffer_[buffer_size - 1] = '\0';
+        return str_;
+    }
+
+    /**
+      \rst
+      Returns the content of the output buffer as an ``std::string``.
+      \endrst
+     */
+    auto str() const -> std::string
+    {
+        return std::string(str_, size());
+    }
+};
+
+template<typename T, typename Char>
+template<typename FormatContext>
+FMT_CONSTEXPR FMT_INLINE auto formatter<T, Char, enable_if_t<detail::type_constant<T, Char>::value != detail::type::custom_type>>::format(
+    const T &val, FormatContext &ctx) const -> decltype(ctx.out())
+{
+    if (specs_.width_ref.kind != detail::arg_id_kind::none || specs_.precision_ref.kind != detail::arg_id_kind::none)
+    {
+        auto specs = specs_;
+        detail::handle_dynamic_spec<detail::width_checker>(specs.width, specs.width_ref, ctx);
+        detail::handle_dynamic_spec<detail::precision_checker>(specs.precision, specs.precision_ref, ctx);
+        return detail::write<Char>(ctx.out(), val, specs, ctx.locale());
+    }
+    return detail::write<Char>(ctx.out(), val, specs_, ctx.locale());
+}
+
+template<typename Char>
+struct formatter<void *, Char> : formatter<const void *, Char>
+{
+    template<typename FormatContext>
+    auto format(void *val, FormatContext &ctx) const -> decltype(ctx.out())
+    {
+        return formatter<const void *, Char>::format(val, ctx);
+    }
+};
+
+template<typename Char, size_t N>
+struct formatter<Char[N], Char> : formatter<basic_string_view<Char>, Char>
+{
+    template<typename FormatContext>
+    FMT_CONSTEXPR auto format(const Char *val, FormatContext &ctx) const -> decltype(ctx.out())
+    {
+        return formatter<basic_string_view<Char>, Char>::format(val, ctx);
+    }
+};
+
+// A formatter for types known only at run time such as variant alternatives.
+//
+// Usage:
+//   using variant = std::variant<int, std::string>;
+//   template <>
+//   struct formatter<variant>: dynamic_formatter<> {
+//     auto format(const variant& v, format_context& ctx) {
+//       return visit([&](const auto& val) {
+//           return dynamic_formatter<>::format(val, ctx);
+//       }, v);
+//     }
+//   };
+template<typename Char = char>
+class dynamic_formatter
+{
+private:
+    detail::dynamic_format_specs<Char> specs_;
+    const Char *format_str_;
+
+    struct null_handler : detail::error_handler
+    {
+        void on_align(align_t) {}
+        void on_sign(sign_t) {}
+        void on_hash() {}
+    };
+
+    template<typename Context>
+    void handle_specs(Context &ctx)
+    {
+        detail::handle_dynamic_spec<detail::width_checker>(specs_.width, specs_.width_ref, ctx);
+        detail::handle_dynamic_spec<detail::precision_checker>(specs_.precision, specs_.precision_ref, ctx);
+    }
+
+public:
+    template<typename ParseContext>
+    FMT_CONSTEXPR auto parse(ParseContext &ctx) -> decltype(ctx.begin())
+    {
+        format_str_ = ctx.begin();
+        // Checks are deferred to formatting time when the argument type is known.
+        detail::dynamic_specs_handler<ParseContext> handler(specs_, ctx);
+        return detail::parse_format_specs(ctx.begin(), ctx.end(), handler);
+    }
+
+    template<typename T, typename FormatContext>
+    auto format(const T &val, FormatContext &ctx) -> decltype(ctx.out())
+    {
+        handle_specs(ctx);
+        detail::specs_checker<null_handler> checker(null_handler(), detail::mapped_type_constant<T, FormatContext>::value);
+        checker.on_align(specs_.align);
+        if (specs_.sign != sign::none)
+            checker.on_sign(specs_.sign);
+        if (specs_.alt)
+            checker.on_hash();
+        if (specs_.precision >= 0)
+            checker.end_precision();
+        return detail::write<Char>(ctx.out(), val, specs_, ctx.locale());
+    }
+};
+
+/**
+  \rst
+  Converts ``p`` to ``const void*`` for pointer formatting.
+
+  **Example**::
+
+    auto s = fmt::format("{}", fmt::ptr(p));
+  \endrst
+ */
+template<typename T>
+auto ptr(T p) -> const void *
+{
+    static_assert(std::is_pointer<T>::value, "");
+    return detail::bit_cast<const void *>(p);
+}
+template<typename T>
+auto ptr(const std::unique_ptr<T> &p) -> const void *
+{
+    return p.get();
+}
+template<typename T>
+auto ptr(const std::shared_ptr<T> &p) -> const void *
+{
+    return p.get();
+}
+
+/**
+  \rst
+  Converts ``e`` to the underlying type.
+
+  **Example**::
+
+    enum class color { red, green, blue };
+    auto s = fmt::format("{}", fmt::underlying(color::red));
+  \endrst
+ */
+template<typename Enum>
+constexpr auto underlying(Enum e) noexcept -> underlying_t<Enum>
+{
+    return static_cast<underlying_t<Enum>>(e);
+}
+
+namespace enums {
+template<typename Enum, FMT_ENABLE_IF(std::is_enum<Enum>::value)>
+constexpr auto format_as(Enum e) noexcept -> underlying_t<Enum>
+{
+    return static_cast<underlying_t<Enum>>(e);
+}
+} // namespace enums
+
+class bytes
+{
+private:
+    string_view data_;
+    friend struct formatter<bytes>;
+
+public:
+    explicit bytes(string_view data)
+        : data_(data)
+    {}
+};
+
+template<>
+struct formatter<bytes>
+{
+private:
+    detail::dynamic_format_specs<char> specs_;
+
+public:
+    template<typename ParseContext>
+    FMT_CONSTEXPR auto parse(ParseContext &ctx) -> decltype(ctx.begin())
+    {
+        using handler_type = detail::dynamic_specs_handler<ParseContext>;
+        detail::specs_checker<handler_type> handler(handler_type(specs_, ctx), detail::type::string_type);
+        auto it = parse_format_specs(ctx.begin(), ctx.end(), handler);
+        detail::check_string_type_spec(specs_.type, ctx.error_handler());
+        return it;
+    }
+
+    template<typename FormatContext>
+    auto format(bytes b, FormatContext &ctx) -> decltype(ctx.out())
+    {
+        detail::handle_dynamic_spec<detail::width_checker>(specs_.width, specs_.width_ref, ctx);
+        detail::handle_dynamic_spec<detail::precision_checker>(specs_.precision, specs_.precision_ref, ctx);
+        return detail::write_bytes(ctx.out(), b.data_, specs_);
+    }
+};
+
+// group_digits_view is not derived from view because it copies the argument.
+template<typename T>
+struct group_digits_view
+{
+    T value;
+};
+
+/**
+  \rst
+  Returns a view that formats an integer value using ',' as a locale-independent
+  thousands separator.
+
+  **Example**::
+
+    fmt::print("{}", fmt::group_digits(12345));
+    // Output: "12,345"
+  \endrst
+ */
+template<typename T>
+auto group_digits(T value) -> group_digits_view<T>
+{
+    return {value};
+}
+
+template<typename T>
+struct formatter<group_digits_view<T>> : formatter<T>
+{
+private:
+    detail::dynamic_format_specs<char> specs_;
+
+public:
+    template<typename ParseContext>
+    FMT_CONSTEXPR auto parse(ParseContext &ctx) -> decltype(ctx.begin())
+    {
+        using handler_type = detail::dynamic_specs_handler<ParseContext>;
+        detail::specs_checker<handler_type> handler(handler_type(specs_, ctx), detail::type::int_type);
+        auto it = parse_format_specs(ctx.begin(), ctx.end(), handler);
+        detail::check_string_type_spec(specs_.type, ctx.error_handler());
+        return it;
+    }
+
+    template<typename FormatContext>
+    auto format(group_digits_view<T> t, FormatContext &ctx) -> decltype(ctx.out())
+    {
+        detail::handle_dynamic_spec<detail::width_checker>(specs_.width, specs_.width_ref, ctx);
+        detail::handle_dynamic_spec<detail::precision_checker>(specs_.precision, specs_.precision_ref, ctx);
+        return detail::write_int_localized(
+            ctx.out(), static_cast<detail::uint64_or_128_t<T>>(t.value), 0, specs_, detail::digit_grouping<char>({"\3", ','}));
+    }
+};
+
+template<typename It, typename Sentinel, typename Char = char>
+struct join_view : detail::view
+{
+    It begin;
+    Sentinel end;
+    basic_string_view<Char> sep;
+
+    join_view(It b, Sentinel e, basic_string_view<Char> s)
+        : begin(b)
+        , end(e)
+        , sep(s)
+    {}
+};
+
+template<typename It, typename Sentinel, typename Char>
+struct formatter<join_view<It, Sentinel, Char>, Char>
+{
+private:
+    using value_type =
+#ifdef __cpp_lib_ranges
+        std::iter_value_t<It>;
+#else
+        typename std::iterator_traits<It>::value_type;
+#endif
+    using context = buffer_context<Char>;
+    using mapper = detail::arg_mapper<context>;
+
+    template<typename T, FMT_ENABLE_IF(has_formatter<T, context>::value)>
+    static auto map(const T &value) -> const T &
+    {
+        return value;
+    }
+    template<typename T, FMT_ENABLE_IF(!has_formatter<T, context>::value)>
+    static auto map(const T &value) -> decltype(mapper().map(value))
+    {
+        return mapper().map(value);
+    }
+
+    using formatter_type = conditional_t<is_formattable<value_type, Char>::value,
+        formatter<remove_cvref_t<decltype(map(std::declval<const value_type &>()))>, Char>, detail::fallback_formatter<value_type, Char>>;
+
+    formatter_type value_formatter_;
+
+public:
+    template<typename ParseContext>
+    FMT_CONSTEXPR auto parse(ParseContext &ctx) -> decltype(ctx.begin())
+    {
+        return value_formatter_.parse(ctx);
+    }
+
+    template<typename FormatContext>
+    auto format(const join_view<It, Sentinel, Char> &value, FormatContext &ctx) const -> decltype(ctx.out())
+    {
+        auto it = value.begin;
+        auto out = ctx.out();
+        if (it != value.end)
+        {
+            out = value_formatter_.format(map(*it), ctx);
+            ++it;
+            while (it != value.end)
+            {
+                out = detail::copy_str<Char>(value.sep.begin(), value.sep.end(), out);
+                ctx.advance_to(out);
+                out = value_formatter_.format(map(*it), ctx);
+                ++it;
+            }
+        }
+        return out;
+    }
+};
+
+/**
+  Returns a view that formats the iterator range `[begin, end)` with elements
+  separated by `sep`.
+ */
+template<typename It, typename Sentinel>
+auto join(It begin, Sentinel end, string_view sep) -> join_view<It, Sentinel>
+{
+    return {begin, end, sep};
+}
+
+/**
+  \rst
+  Returns a view that formats `range` with elements separated by `sep`.
+
+  **Example**::
+
+    std::vector<int> v = {1, 2, 3};
+    fmt::print("{}", fmt::join(v, ", "));
+    // Output: "1, 2, 3"
+
+  ``fmt::join`` applies passed format specifiers to the range elements::
+
+    fmt::print("{:02}", fmt::join(v, ", "));
+    // Output: "01, 02, 03"
+  \endrst
+ */
+template<typename Range>
+auto join(Range &&range, string_view sep) -> join_view<detail::iterator_t<Range>, detail::sentinel_t<Range>>
+{
+    return join(std::begin(range), std::end(range), sep);
+}
+
+/**
+  \rst
+  Converts *value* to ``std::string`` using the default format for type *T*.
+
+  **Example**::
+
+    #include <fmt/format.h>
+
+    std::string answer = fmt::to_string(42);
+  \endrst
+ */
+template<typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
+inline auto to_string(const T &value) -> std::string
+{
+    auto result = std::string();
+    detail::write<char>(std::back_inserter(result), value);
+    return result;
+}
+
+template<typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
+FMT_NODISCARD inline auto to_string(T value) -> std::string
+{
+    // The buffer should be large enough to store the number including the sign
+    // or "false" for bool.
+    constexpr int max_size = detail::digits10<T>() + 2;
+    char buffer[max_size > 5 ? static_cast<unsigned>(max_size) : 5];
+    char *begin = buffer;
+    return std::string(begin, detail::write<char>(begin, value));
+}
+
+template<typename Char, size_t SIZE>
+FMT_NODISCARD auto to_string(const basic_memory_buffer<Char, SIZE> &buf) -> std::basic_string<Char>
+{
+    auto size = buf.size();
+    detail::assume(size < std::basic_string<Char>().max_size());
+    return std::basic_string<Char>(buf.data(), size);
+}
+
+FMT_BEGIN_DETAIL_NAMESPACE
+
+template<typename Char>
+void vformat_to(
+    buffer<Char> &buf, basic_string_view<Char> fmt, basic_format_args<FMT_BUFFER_CONTEXT(type_identity_t<Char>)> args, locale_ref loc)
+{
+    // workaround for msvc bug regarding name-lookup in module
+    // link names into function scope
+    using detail::arg_formatter;
+    using detail::buffer_appender;
+    using detail::custom_formatter;
+    using detail::default_arg_formatter;
+    using detail::get_arg;
+    using detail::locale_ref;
+    using detail::parse_format_specs;
+    using detail::specs_checker;
+    using detail::specs_handler;
+    using detail::to_unsigned;
+    using detail::type;
+    using detail::write;
+    auto out = buffer_appender<Char>(buf);
+    if (fmt.size() == 2 && equal2(fmt.data(), "{}"))
+    {
+        auto arg = args.get(0);
+        if (!arg)
+            error_handler().on_error("argument not found");
+        visit_format_arg(default_arg_formatter<Char>{out, args, loc}, arg);
+        return;
+    }
+
+    struct format_handler : error_handler
+    {
+        basic_format_parse_context<Char> parse_context;
+        buffer_context<Char> context;
+
+        format_handler(
+            buffer_appender<Char> p_out, basic_string_view<Char> str, basic_format_args<buffer_context<Char>> p_args, locale_ref p_loc)
+            : parse_context(str)
+            , context(p_out, p_args, p_loc)
+        {}
+
+        void on_text(const Char *begin, const Char *end)
+        {
+            auto text = basic_string_view<Char>(begin, to_unsigned(end - begin));
+            context.advance_to(write<Char>(context.out(), text));
+        }
+
+        FMT_CONSTEXPR auto on_arg_id() -> int
+        {
+            return parse_context.next_arg_id();
+        }
+        FMT_CONSTEXPR auto on_arg_id(int id) -> int
+        {
+            return parse_context.check_arg_id(id), id;
+        }
+        FMT_CONSTEXPR auto on_arg_id(basic_string_view<Char> id) -> int
+        {
+            int arg_id = context.arg_id(id);
+            if (arg_id < 0)
+                on_error("argument not found");
+            return arg_id;
+        }
+
+        FMT_INLINE void on_replacement_field(int id, const Char *)
+        {
+            auto arg = get_arg(context, id);
+            context.advance_to(visit_format_arg(default_arg_formatter<Char>{context.out(), context.args(), context.locale()}, arg));
+        }
+
+        auto on_format_specs(int id, const Char *begin, const Char *end) -> const Char *
+        {
+            auto arg = get_arg(context, id);
+            if (arg.type() == type::custom_type)
+            {
+                parse_context.advance_to(parse_context.begin() + (begin - &*parse_context.begin()));
+                visit_format_arg(custom_formatter<Char>{parse_context, context}, arg);
+                return parse_context.begin();
+            }
+            auto specs = basic_format_specs<Char>();
+            specs_checker<specs_handler<Char>> handler(specs_handler<Char>(specs, parse_context, context), arg.type());
+            begin = parse_format_specs(begin, end, handler);
+            if (begin == end || *begin != '}')
+                on_error("missing '}' in format string");
+            auto f = arg_formatter<Char>{context.out(), specs, context.locale()};
+            context.advance_to(visit_format_arg(f, arg));
+            return begin;
+        }
+    };
+    detail::parse_format_string<false>(fmt, format_handler(out, fmt, args, loc));
+}
+
+#ifndef FMT_HEADER_ONLY
+extern template FMT_API auto thousands_sep_impl<char>(locale_ref) -> thousands_sep_result<char>;
+extern template FMT_API auto thousands_sep_impl<wchar_t>(locale_ref) -> thousands_sep_result<wchar_t>;
+extern template FMT_API auto decimal_point_impl(locale_ref) -> char;
+extern template FMT_API auto decimal_point_impl(locale_ref) -> wchar_t;
+#endif // FMT_HEADER_ONLY
+
+FMT_END_DETAIL_NAMESPACE
+
+#if FMT_USE_USER_DEFINED_LITERALS
+inline namespace literals {
+/**
+  \rst
+  User-defined literal equivalent of :func:`fmt::arg`.
+
+  **Example**::
+
+    using namespace fmt::literals;
+    fmt::print("Elapsed time: {s:.2f} seconds", "s"_a=1.23);
+  \endrst
+ */
+#    if FMT_USE_NONTYPE_TEMPLATE_ARGS
+template<detail_exported::fixed_string Str>
+constexpr auto operator""_a()
+{
+    using char_t = remove_cvref_t<decltype(Str.data[0])>;
+    return detail::udl_arg<char_t, sizeof(Str.data) / sizeof(char_t), Str>();
+}
+#    else
+constexpr auto operator"" _a(const char *s, size_t) -> detail::udl_arg<char>
+{
+    return {s};
+}
+#    endif
+} // namespace literals
+#endif // FMT_USE_USER_DEFINED_LITERALS
+
+template<typename Locale, FMT_ENABLE_IF(detail::is_locale<Locale>::value)>
+inline auto vformat(const Locale &loc, string_view fmt, format_args args) -> std::string
+{
+    return detail::vformat(loc, fmt, args);
+}
+
+template<typename Locale, typename... T, FMT_ENABLE_IF(detail::is_locale<Locale>::value)>
+inline auto format(const Locale &loc, format_string<T...> fmt, T &&...args) -> std::string
+{
+    return vformat(loc, string_view(fmt), fmt::make_format_args(args...));
+}
+
+template<typename OutputIt, typename Locale,
+    FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, char>::value &&detail::is_locale<Locale>::value)>
+auto vformat_to(OutputIt out, const Locale &loc, string_view fmt, format_args args) -> OutputIt
+{
+    using detail::get_buffer;
+    auto &&buf = get_buffer<char>(out);
+    detail::vformat_to(buf, fmt, args, detail::locale_ref(loc));
+    return detail::get_iterator(buf);
+}
+
+template<typename OutputIt, typename Locale, typename... T,
+    FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, char>::value &&detail::is_locale<Locale>::value)>
+FMT_INLINE auto format_to(OutputIt out, const Locale &loc, format_string<T...> fmt, T &&...args) -> OutputIt
+{
+    return vformat_to(out, loc, fmt, fmt::make_format_args(args...));
+}
+
+FMT_MODULE_EXPORT_END
+FMT_END_NAMESPACE
+
+#ifdef FMT_HEADER_ONLY
+#    define FMT_FUNC inline
+#    include "format-inl.h"
+#else
+#    define FMT_FUNC
+#endif
+
+#endif // FMT_FORMAT_H_
diff --git a/3rdparty/spdlog/src/include/spdlog/fmt/bundled/locale.h b/3rdparty/spdlog/src/include/spdlog/fmt/bundled/locale.h
new file mode 100644
index 00000000..7571b526
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/fmt/bundled/locale.h
@@ -0,0 +1,2 @@
+#include "xchar.h"
+#warning fmt/locale.h is deprecated, include fmt/format.h or fmt/xchar.h instead
diff --git a/3rdparty/spdlog/src/include/spdlog/fmt/bundled/os.h b/3rdparty/spdlog/src/include/spdlog/fmt/bundled/os.h
new file mode 100644
index 00000000..c4c02bd9
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/fmt/bundled/os.h
@@ -0,0 +1,547 @@
+// Formatting library for C++ - optional OS-specific functionality
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#ifndef FMT_OS_H_
+#define FMT_OS_H_
+
+#include <cerrno>
+#include <cstddef>
+#include <cstdio>
+#include <system_error> // std::system_error
+
+#if defined __APPLE__ || defined(__FreeBSD__)
+#    include <xlocale.h> // for LC_NUMERIC_MASK on OS X
+#endif
+
+#include "format.h"
+
+#ifndef FMT_USE_FCNTL
+// UWP doesn't provide _pipe.
+#    if FMT_HAS_INCLUDE("winapifamily.h")
+#        include <winapifamily.h>
+#    endif
+#    if (FMT_HAS_INCLUDE(<fcntl.h>) || defined(__APPLE__) || defined(__linux__)) &&                                                        \
+        (!defined(WINAPI_FAMILY) || (WINAPI_FAMILY == WINAPI_FAMILY_DESKTOP_APP))
+#        include <fcntl.h> // for O_RDONLY
+#        define FMT_USE_FCNTL 1
+#    else
+#        define FMT_USE_FCNTL 0
+#    endif
+#endif
+
+#ifndef FMT_POSIX
+#    if defined(_WIN32) && !defined(__MINGW32__)
+// Fix warnings about deprecated symbols.
+#        define FMT_POSIX(call) _##call
+#    else
+#        define FMT_POSIX(call) call
+#    endif
+#endif
+
+// Calls to system functions are wrapped in FMT_SYSTEM for testability.
+#ifdef FMT_SYSTEM
+#    define FMT_POSIX_CALL(call) FMT_SYSTEM(call)
+#else
+#    define FMT_SYSTEM(call) ::call
+#    ifdef _WIN32
+// Fix warnings about deprecated symbols.
+#        define FMT_POSIX_CALL(call) ::_##call
+#    else
+#        define FMT_POSIX_CALL(call) ::call
+#    endif
+#endif
+
+// Retries the expression while it evaluates to error_result and errno
+// equals to EINTR.
+#ifndef _WIN32
+#    define FMT_RETRY_VAL(result, expression, error_result)                                                                                \
+        do                                                                                                                                 \
+        {                                                                                                                                  \
+            (result) = (expression);                                                                                                       \
+        } while ((result) == (error_result) && errno == EINTR)
+#else
+#    define FMT_RETRY_VAL(result, expression, error_result) result = (expression)
+#endif
+
+#define FMT_RETRY(result, expression) FMT_RETRY_VAL(result, expression, -1)
+
+FMT_BEGIN_NAMESPACE
+FMT_MODULE_EXPORT_BEGIN
+
+/**
+  \rst
+  A reference to a null-terminated string. It can be constructed from a C
+  string or ``std::string``.
+
+  You can use one of the following type aliases for common character types:
+
+  +---------------+-----------------------------+
+  | Type          | Definition                  |
+  +===============+=============================+
+  | cstring_view  | basic_cstring_view<char>    |
+  +---------------+-----------------------------+
+  | wcstring_view | basic_cstring_view<wchar_t> |
+  +---------------+-----------------------------+
+
+  This class is most useful as a parameter type to allow passing
+  different types of strings to a function, for example::
+
+    template <typename... Args>
+    std::string format(cstring_view format_str, const Args & ... args);
+
+    format("{}", 42);
+    format(std::string("{}"), 42);
+  \endrst
+ */
+template<typename Char>
+class basic_cstring_view
+{
+private:
+    const Char *data_;
+
+public:
+    /** Constructs a string reference object from a C string. */
+    basic_cstring_view(const Char *s)
+        : data_(s)
+    {}
+
+    /**
+      \rst
+      Constructs a string reference from an ``std::string`` object.
+      \endrst
+     */
+    basic_cstring_view(const std::basic_string<Char> &s)
+        : data_(s.c_str())
+    {}
+
+    /** Returns the pointer to a C string. */
+    const Char *c_str() const
+    {
+        return data_;
+    }
+};
+
+using cstring_view = basic_cstring_view<char>;
+using wcstring_view = basic_cstring_view<wchar_t>;
+
+template<typename Char>
+struct formatter<std::error_code, Char>
+{
+    template<typename ParseContext>
+    FMT_CONSTEXPR auto parse(ParseContext &ctx) -> decltype(ctx.begin())
+    {
+        return ctx.begin();
+    }
+
+    template<typename FormatContext>
+    FMT_CONSTEXPR auto format(const std::error_code &ec, FormatContext &ctx) const -> decltype(ctx.out())
+    {
+        auto out = ctx.out();
+        out = detail::write_bytes(out, ec.category().name(), basic_format_specs<Char>());
+        out = detail::write<Char>(out, Char(':'));
+        out = detail::write<Char>(out, ec.value());
+        return out;
+    }
+};
+
+#ifdef _WIN32
+FMT_API const std::error_category &system_category() noexcept;
+
+FMT_BEGIN_DETAIL_NAMESPACE
+// A converter from UTF-16 to UTF-8.
+// It is only provided for Windows since other systems support UTF-8 natively.
+class utf16_to_utf8
+{
+private:
+    memory_buffer buffer_;
+
+public:
+    utf16_to_utf8() {}
+    FMT_API explicit utf16_to_utf8(basic_string_view<wchar_t> s);
+    operator string_view() const
+    {
+        return string_view(&buffer_[0], size());
+    }
+    size_t size() const
+    {
+        return buffer_.size() - 1;
+    }
+    const char *c_str() const
+    {
+        return &buffer_[0];
+    }
+    std::string str() const
+    {
+        return std::string(&buffer_[0], size());
+    }
+
+    // Performs conversion returning a system error code instead of
+    // throwing exception on conversion error. This method may still throw
+    // in case of memory allocation error.
+    FMT_API int convert(basic_string_view<wchar_t> s);
+};
+
+FMT_API void format_windows_error(buffer<char> &out, int error_code, const char *message) noexcept;
+FMT_END_DETAIL_NAMESPACE
+
+FMT_API std::system_error vwindows_error(int error_code, string_view format_str, format_args args);
+
+/**
+ \rst
+ Constructs a :class:`std::system_error` object with the description
+ of the form
+
+ .. parsed-literal::
+   *<message>*: *<system-message>*
+
+ where *<message>* is the formatted message and *<system-message>* is the
+ system message corresponding to the error code.
+ *error_code* is a Windows error code as given by ``GetLastError``.
+ If *error_code* is not a valid error code such as -1, the system message
+ will look like "error -1".
+
+ **Example**::
+
+   // This throws a system_error with the description
+   //   cannot open file 'madeup': The system cannot find the file specified.
+   // or similar (system message may vary).
+   const char *filename = "madeup";
+   LPOFSTRUCT of = LPOFSTRUCT();
+   HFILE file = OpenFile(filename, &of, OF_READ);
+   if (file == HFILE_ERROR) {
+     throw fmt::windows_error(GetLastError(),
+                              "cannot open file '{}'", filename);
+   }
+ \endrst
+*/
+template<typename... Args>
+std::system_error windows_error(int error_code, string_view message, const Args &...args)
+{
+    return vwindows_error(error_code, message, fmt::make_format_args(args...));
+}
+
+// Reports a Windows error without throwing an exception.
+// Can be used to report errors from destructors.
+FMT_API void report_windows_error(int error_code, const char *message) noexcept;
+#else
+inline const std::error_category &system_category() noexcept
+{
+    return std::system_category();
+}
+#endif // _WIN32
+
+// std::system is not available on some platforms such as iOS (#2248).
+#ifdef __OSX__
+template<typename S, typename... Args, typename Char = char_t<S>>
+void say(const S &format_str, Args &&...args)
+{
+    std::system(format("say \"{}\"", format(format_str, args...)).c_str());
+}
+#endif
+
+// A buffered file.
+class buffered_file
+{
+private:
+    FILE *file_;
+
+    friend class file;
+
+    explicit buffered_file(FILE *f)
+        : file_(f)
+    {}
+
+public:
+    buffered_file(const buffered_file &) = delete;
+    void operator=(const buffered_file &) = delete;
+
+    // Constructs a buffered_file object which doesn't represent any file.
+    buffered_file() noexcept
+        : file_(nullptr)
+    {}
+
+    // Destroys the object closing the file it represents if any.
+    FMT_API ~buffered_file() noexcept;
+
+public:
+    buffered_file(buffered_file &&other) noexcept
+        : file_(other.file_)
+    {
+        other.file_ = nullptr;
+    }
+
+    buffered_file &operator=(buffered_file &&other)
+    {
+        close();
+        file_ = other.file_;
+        other.file_ = nullptr;
+        return *this;
+    }
+
+    // Opens a file.
+    FMT_API buffered_file(cstring_view filename, cstring_view mode);
+
+    // Closes the file.
+    FMT_API void close();
+
+    // Returns the pointer to a FILE object representing this file.
+    FILE *get() const noexcept
+    {
+        return file_;
+    }
+
+    FMT_API int descriptor() const;
+
+    void vprint(string_view format_str, format_args args)
+    {
+        fmt::vprint(file_, format_str, args);
+    }
+
+    template<typename... Args>
+    inline void print(string_view format_str, const Args &...args)
+    {
+        vprint(format_str, fmt::make_format_args(args...));
+    }
+};
+
+#if FMT_USE_FCNTL
+// A file. Closed file is represented by a file object with descriptor -1.
+// Methods that are not declared with noexcept may throw
+// fmt::system_error in case of failure. Note that some errors such as
+// closing the file multiple times will cause a crash on Windows rather
+// than an exception. You can get standard behavior by overriding the
+// invalid parameter handler with _set_invalid_parameter_handler.
+class FMT_API file
+{
+private:
+    int fd_; // File descriptor.
+
+    // Constructs a file object with a given descriptor.
+    explicit file(int fd)
+        : fd_(fd)
+    {}
+
+public:
+    // Possible values for the oflag argument to the constructor.
+    enum
+    {
+        RDONLY = FMT_POSIX(O_RDONLY), // Open for reading only.
+        WRONLY = FMT_POSIX(O_WRONLY), // Open for writing only.
+        RDWR = FMT_POSIX(O_RDWR),     // Open for reading and writing.
+        CREATE = FMT_POSIX(O_CREAT),  // Create if the file doesn't exist.
+        APPEND = FMT_POSIX(O_APPEND), // Open in append mode.
+        TRUNC = FMT_POSIX(O_TRUNC)    // Truncate the content of the file.
+    };
+
+    // Constructs a file object which doesn't represent any file.
+    file() noexcept
+        : fd_(-1)
+    {}
+
+    // Opens a file and constructs a file object representing this file.
+    file(cstring_view path, int oflag);
+
+public:
+    file(const file &) = delete;
+    void operator=(const file &) = delete;
+
+    file(file &&other) noexcept
+        : fd_(other.fd_)
+    {
+        other.fd_ = -1;
+    }
+
+    // Move assignment is not noexcept because close may throw.
+    file &operator=(file &&other)
+    {
+        close();
+        fd_ = other.fd_;
+        other.fd_ = -1;
+        return *this;
+    }
+
+    // Destroys the object closing the file it represents if any.
+    ~file() noexcept;
+
+    // Returns the file descriptor.
+    int descriptor() const noexcept
+    {
+        return fd_;
+    }
+
+    // Closes the file.
+    void close();
+
+    // Returns the file size. The size has signed type for consistency with
+    // stat::st_size.
+    long long size() const;
+
+    // Attempts to read count bytes from the file into the specified buffer.
+    size_t read(void *buffer, size_t count);
+
+    // Attempts to write count bytes from the specified buffer to the file.
+    size_t write(const void *buffer, size_t count);
+
+    // Duplicates a file descriptor with the dup function and returns
+    // the duplicate as a file object.
+    static file dup(int fd);
+
+    // Makes fd be the copy of this file descriptor, closing fd first if
+    // necessary.
+    void dup2(int fd);
+
+    // Makes fd be the copy of this file descriptor, closing fd first if
+    // necessary.
+    void dup2(int fd, std::error_code &ec) noexcept;
+
+    // Creates a pipe setting up read_end and write_end file objects for reading
+    // and writing respectively.
+    static void pipe(file &read_end, file &write_end);
+
+    // Creates a buffered_file object associated with this file and detaches
+    // this file object from the file.
+    buffered_file fdopen(const char *mode);
+};
+
+// Returns the memory page size.
+long getpagesize();
+
+FMT_BEGIN_DETAIL_NAMESPACE
+
+struct buffer_size
+{
+    buffer_size() = default;
+    size_t value = 0;
+    buffer_size operator=(size_t val) const
+    {
+        auto bs = buffer_size();
+        bs.value = val;
+        return bs;
+    }
+};
+
+struct ostream_params
+{
+    int oflag = file::WRONLY | file::CREATE | file::TRUNC;
+    size_t buffer_size = BUFSIZ > 32768 ? BUFSIZ : 32768;
+
+    ostream_params() {}
+
+    template<typename... T>
+    ostream_params(T... params, int new_oflag)
+        : ostream_params(params...)
+    {
+        oflag = new_oflag;
+    }
+
+    template<typename... T>
+    ostream_params(T... params, detail::buffer_size bs)
+        : ostream_params(params...)
+    {
+        this->buffer_size = bs.value;
+    }
+
+// Intel has a bug that results in failure to deduce a constructor
+// for empty parameter packs.
+#    if defined(__INTEL_COMPILER) && __INTEL_COMPILER < 2000
+    ostream_params(int new_oflag)
+        : oflag(new_oflag)
+    {}
+    ostream_params(detail::buffer_size bs)
+        : buffer_size(bs.value)
+    {}
+#    endif
+};
+
+FMT_END_DETAIL_NAMESPACE
+
+// Added {} below to work around default constructor error known to
+// occur in Xcode versions 7.2.1 and 8.2.1.
+constexpr detail::buffer_size buffer_size{};
+
+/** A fast output stream which is not thread-safe. */
+class FMT_API ostream final : private detail::buffer<char>
+{
+private:
+    file file_;
+
+    void grow(size_t) override;
+
+    ostream(cstring_view path, const detail::ostream_params &params)
+        : file_(path, params.oflag)
+    {
+        set(new char[params.buffer_size], params.buffer_size);
+    }
+
+public:
+    ostream(ostream &&other)
+        : detail::buffer<char>(other.data(), other.size(), other.capacity())
+        , file_(std::move(other.file_))
+    {
+        other.clear();
+        other.set(nullptr, 0);
+    }
+    ~ostream()
+    {
+        flush();
+        delete[] data();
+    }
+
+    void flush()
+    {
+        if (size() == 0)
+            return;
+        file_.write(data(), size());
+        clear();
+    }
+
+    template<typename... T>
+    friend ostream output_file(cstring_view path, T... params);
+
+    void close()
+    {
+        flush();
+        file_.close();
+    }
+
+    /**
+      Formats ``args`` according to specifications in ``fmt`` and writes the
+      output to the file.
+     */
+    template<typename... T>
+    void print(format_string<T...> fmt, T &&...args)
+    {
+        vformat_to(detail::buffer_appender<char>(*this), fmt, fmt::make_format_args(args...));
+    }
+};
+
+/**
+  \rst
+  Opens a file for writing. Supported parameters passed in *params*:
+
+  * ``<integer>``: Flags passed to `open
+    <https://pubs.opengroup.org/onlinepubs/007904875/functions/open.html>`_
+    (``file::WRONLY | file::CREATE | file::TRUNC`` by default)
+  * ``buffer_size=<integer>``: Output buffer size
+
+  **Example**::
+
+    auto out = fmt::output_file("guide.txt");
+    out.print("Don't {}", "Panic");
+  \endrst
+ */
+template<typename... T>
+inline ostream output_file(cstring_view path, T... params)
+{
+    return {path, detail::ostream_params(params...)};
+}
+#endif // FMT_USE_FCNTL
+
+FMT_MODULE_EXPORT_END
+FMT_END_NAMESPACE
+
+#endif // FMT_OS_H_
diff --git a/3rdparty/spdlog/src/include/spdlog/fmt/bundled/ostream.h b/3rdparty/spdlog/src/include/spdlog/fmt/bundled/ostream.h
new file mode 100644
index 00000000..67edb213
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/fmt/bundled/ostream.h
@@ -0,0 +1,251 @@
+// Formatting library for C++ - std::ostream support
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#ifndef FMT_OSTREAM_H_
+#define FMT_OSTREAM_H_
+
+#include <fstream>
+#include <ostream>
+#if defined(_WIN32) && defined(__GLIBCXX__)
+#    include <ext/stdio_filebuf.h>
+#    include <ext/stdio_sync_filebuf.h>
+#elif defined(_WIN32) && defined(_LIBCPP_VERSION)
+#    include <__std_stream>
+#endif
+
+#include "format.h"
+
+FMT_BEGIN_NAMESPACE
+
+template<typename OutputIt, typename Char>
+class basic_printf_context;
+
+namespace detail {
+
+// Checks if T has a user-defined operator<<.
+template<typename T, typename Char, typename Enable = void>
+class is_streamable
+{
+private:
+    template<typename U>
+    static auto test(int) -> bool_constant<sizeof(std::declval<std::basic_ostream<Char> &>() << std::declval<U>()) != 0>;
+
+    template<typename>
+    static auto test(...) -> std::false_type;
+
+    using result = decltype(test<T>(0));
+
+public:
+    is_streamable() = default;
+
+    static const bool value = result::value;
+};
+
+// Formatting of built-in types and arrays is intentionally disabled because
+// it's handled by standard (non-ostream) formatters.
+template<typename T, typename Char>
+struct is_streamable<T, Char,
+    enable_if_t<std::is_arithmetic<T>::value || std::is_array<T>::value || std::is_pointer<T>::value ||
+                std::is_same<T, char8_type>::value || std::is_convertible<T, fmt::basic_string_view<Char>>::value ||
+                std::is_same<T, std_string_view<Char>>::value || (std::is_convertible<T, int>::value && !std::is_enum<T>::value)>>
+    : std::false_type
+{};
+
+// Generate a unique explicit instantion in every translation unit using a tag
+// type in an anonymous namespace.
+namespace {
+struct file_access_tag
+{};
+} // namespace
+template<class Tag, class BufType, FILE *BufType::*FileMemberPtr>
+class file_access
+{
+    friend auto get_file(BufType &obj) -> FILE *
+    {
+        return obj.*FileMemberPtr;
+    }
+};
+
+#if FMT_MSC_VERSION
+template class file_access<file_access_tag, std::filebuf, &std::filebuf::_Myfile>;
+auto get_file(std::filebuf &) -> FILE *;
+#elif defined(_WIN32) && defined(_LIBCPP_VERSION)
+template class file_access<file_access_tag, std::__stdoutbuf<char>, &std::__stdoutbuf<char>::__file_>;
+auto get_file(std::__stdoutbuf<char> &) -> FILE *;
+#endif
+
+inline bool write_ostream_unicode(std::ostream &os, fmt::string_view data)
+{
+#if FMT_MSC_VERSION
+    if (auto *buf = dynamic_cast<std::filebuf *>(os.rdbuf()))
+        if (FILE *f = get_file(*buf))
+            return write_console(f, data);
+#elif defined(_WIN32) && defined(__GLIBCXX__)
+    auto *rdbuf = os.rdbuf();
+    FILE *c_file;
+    if (auto *fbuf = dynamic_cast<__gnu_cxx::stdio_sync_filebuf<char> *>(rdbuf))
+        c_file = fbuf->file();
+    else if (auto *fbuf = dynamic_cast<__gnu_cxx::stdio_filebuf<char> *>(rdbuf))
+        c_file = fbuf->file();
+    else
+        return false;
+    if (c_file)
+        return write_console(c_file, data);
+#elif defined(_WIN32) && defined(_LIBCPP_VERSION)
+    if (auto *buf = dynamic_cast<std::__stdoutbuf<char> *>(os.rdbuf()))
+        if (FILE *f = get_file(*buf))
+            return write_console(f, data);
+#else
+    ignore_unused(os, data);
+#endif
+    return false;
+}
+inline bool write_ostream_unicode(std::wostream &, fmt::basic_string_view<wchar_t>)
+{
+    return false;
+}
+
+// Write the content of buf to os.
+// It is a separate function rather than a part of vprint to simplify testing.
+template<typename Char>
+void write_buffer(std::basic_ostream<Char> &os, buffer<Char> &buf)
+{
+    const Char *buf_data = buf.data();
+    using unsigned_streamsize = std::make_unsigned<std::streamsize>::type;
+    unsigned_streamsize size = buf.size();
+    unsigned_streamsize max_size = to_unsigned(max_value<std::streamsize>());
+    do
+    {
+        unsigned_streamsize n = size <= max_size ? size : max_size;
+        os.write(buf_data, static_cast<std::streamsize>(n));
+        buf_data += n;
+        size -= n;
+    } while (size != 0);
+}
+
+template<typename Char, typename T>
+void format_value(buffer<Char> &buf, const T &value, locale_ref loc = locale_ref())
+{
+    auto &&format_buf = formatbuf<std::basic_streambuf<Char>>(buf);
+    auto &&output = std::basic_ostream<Char>(&format_buf);
+#if !defined(FMT_STATIC_THOUSANDS_SEPARATOR)
+    if (loc)
+        output.imbue(loc.get<std::locale>());
+#endif
+    output << value;
+    output.exceptions(std::ios_base::failbit | std::ios_base::badbit);
+}
+
+template<typename T>
+struct streamed_view
+{
+    const T &value;
+};
+
+} // namespace detail
+
+// Formats an object of type T that has an overloaded ostream operator<<.
+template<typename Char>
+struct basic_ostream_formatter : formatter<basic_string_view<Char>, Char>
+{
+    void set_debug_format() = delete;
+
+    template<typename T, typename OutputIt>
+    auto format(const T &value, basic_format_context<OutputIt, Char> &ctx) const -> OutputIt
+    {
+        auto buffer = basic_memory_buffer<Char>();
+        format_value(buffer, value, ctx.locale());
+        return formatter<basic_string_view<Char>, Char>::format({buffer.data(), buffer.size()}, ctx);
+    }
+};
+
+using ostream_formatter = basic_ostream_formatter<char>;
+
+template<typename T, typename Char>
+struct formatter<detail::streamed_view<T>, Char> : basic_ostream_formatter<Char>
+{
+    template<typename OutputIt>
+    auto format(detail::streamed_view<T> view, basic_format_context<OutputIt, Char> &ctx) const -> OutputIt
+    {
+        return basic_ostream_formatter<Char>::format(view.value, ctx);
+    }
+};
+
+/**
+  \rst
+  Returns a view that formats `value` via an ostream ``operator<<``.
+
+  **Example**::
+
+    fmt::print("Current thread id: {}\n",
+               fmt::streamed(std::this_thread::get_id()));
+  \endrst
+ */
+template<typename T>
+auto streamed(const T &value) -> detail::streamed_view<T>
+{
+    return {value};
+}
+
+namespace detail {
+
+// Formats an object of type T that has an overloaded ostream operator<<.
+template<typename T, typename Char>
+struct fallback_formatter<T, Char, enable_if_t<is_streamable<T, Char>::value>> : basic_ostream_formatter<Char>
+{
+    using basic_ostream_formatter<Char>::format;
+};
+
+inline void vprint_directly(std::ostream &os, string_view format_str, format_args args)
+{
+    auto buffer = memory_buffer();
+    detail::vformat_to(buffer, format_str, args);
+    detail::write_buffer(os, buffer);
+}
+
+} // namespace detail
+
+FMT_MODULE_EXPORT template<typename Char>
+void vprint(std::basic_ostream<Char> &os, basic_string_view<type_identity_t<Char>> format_str,
+    basic_format_args<buffer_context<type_identity_t<Char>>> args)
+{
+    auto buffer = basic_memory_buffer<Char>();
+    detail::vformat_to(buffer, format_str, args);
+    if (detail::write_ostream_unicode(os, {buffer.data(), buffer.size()}))
+        return;
+    detail::write_buffer(os, buffer);
+}
+
+/**
+  \rst
+  Prints formatted data to the stream *os*.
+
+  **Example**::
+
+    fmt::print(cerr, "Don't {}!", "panic");
+  \endrst
+ */
+FMT_MODULE_EXPORT template<typename... T>
+void print(std::ostream &os, format_string<T...> fmt, T &&...args)
+{
+    const auto &vargs = fmt::make_format_args(args...);
+    if (detail::is_utf8())
+        vprint(os, fmt, vargs);
+    else
+        detail::vprint_directly(os, fmt, vargs);
+}
+
+FMT_MODULE_EXPORT
+template<typename... Args>
+void print(std::wostream &os, basic_format_string<wchar_t, type_identity_t<Args>...> fmt, Args &&...args)
+{
+    vprint(os, fmt, fmt::make_format_args<buffer_context<wchar_t>>(args...));
+}
+
+FMT_END_NAMESPACE
+
+#endif // FMT_OSTREAM_H_
diff --git a/3rdparty/spdlog/src/include/spdlog/fmt/bundled/printf.h b/3rdparty/spdlog/src/include/spdlog/fmt/bundled/printf.h
new file mode 100644
index 00000000..5ae01a15
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/fmt/bundled/printf.h
@@ -0,0 +1,756 @@
+// Formatting library for C++ - legacy printf implementation
+//
+// Copyright (c) 2012 - 2016, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#ifndef FMT_PRINTF_H_
+#define FMT_PRINTF_H_
+
+#include <algorithm> // std::max
+#include <limits>    // std::numeric_limits
+
+#include "format.h"
+
+FMT_BEGIN_NAMESPACE
+FMT_MODULE_EXPORT_BEGIN
+
+template<typename T>
+struct printf_formatter
+{
+    printf_formatter() = delete;
+};
+
+template<typename Char>
+class basic_printf_parse_context : public basic_format_parse_context<Char>
+{
+    using basic_format_parse_context<Char>::basic_format_parse_context;
+};
+
+template<typename OutputIt, typename Char>
+class basic_printf_context
+{
+private:
+    OutputIt out_;
+    basic_format_args<basic_printf_context> args_;
+
+public:
+    using char_type = Char;
+    using format_arg = basic_format_arg<basic_printf_context>;
+    using parse_context_type = basic_printf_parse_context<Char>;
+    template<typename T>
+    using formatter_type = printf_formatter<T>;
+
+    /**
+      \rst
+      Constructs a ``printf_context`` object. References to the arguments are
+      stored in the context object so make sure they have appropriate lifetimes.
+      \endrst
+     */
+    basic_printf_context(OutputIt out, basic_format_args<basic_printf_context> args)
+        : out_(out)
+        , args_(args)
+    {}
+
+    OutputIt out()
+    {
+        return out_;
+    }
+    void advance_to(OutputIt it)
+    {
+        out_ = it;
+    }
+
+    detail::locale_ref locale()
+    {
+        return {};
+    }
+
+    format_arg arg(int id) const
+    {
+        return args_.get(id);
+    }
+
+    FMT_CONSTEXPR void on_error(const char *message)
+    {
+        detail::error_handler().on_error(message);
+    }
+};
+
+FMT_BEGIN_DETAIL_NAMESPACE
+
+// Checks if a value fits in int - used to avoid warnings about comparing
+// signed and unsigned integers.
+template<bool IsSigned>
+struct int_checker
+{
+    template<typename T>
+    static bool fits_in_int(T value)
+    {
+        unsigned max = max_value<int>();
+        return value <= max;
+    }
+    static bool fits_in_int(bool)
+    {
+        return true;
+    }
+};
+
+template<>
+struct int_checker<true>
+{
+    template<typename T>
+    static bool fits_in_int(T value)
+    {
+        return value >= (std::numeric_limits<int>::min)() && value <= max_value<int>();
+    }
+    static bool fits_in_int(int)
+    {
+        return true;
+    }
+};
+
+class printf_precision_handler
+{
+public:
+    template<typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
+    int operator()(T value)
+    {
+        if (!int_checker<std::numeric_limits<T>::is_signed>::fits_in_int(value))
+            FMT_THROW(format_error("number is too big"));
+        return (std::max)(static_cast<int>(value), 0);
+    }
+
+    template<typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
+    int operator()(T)
+    {
+        FMT_THROW(format_error("precision is not integer"));
+        return 0;
+    }
+};
+
+// An argument visitor that returns true iff arg is a zero integer.
+class is_zero_int
+{
+public:
+    template<typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
+    bool operator()(T value)
+    {
+        return value == 0;
+    }
+
+    template<typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
+    bool operator()(T)
+    {
+        return false;
+    }
+};
+
+template<typename T>
+struct make_unsigned_or_bool : std::make_unsigned<T>
+{};
+
+template<>
+struct make_unsigned_or_bool<bool>
+{
+    using type = bool;
+};
+
+template<typename T, typename Context>
+class arg_converter
+{
+private:
+    using char_type = typename Context::char_type;
+
+    basic_format_arg<Context> &arg_;
+    char_type type_;
+
+public:
+    arg_converter(basic_format_arg<Context> &arg, char_type type)
+        : arg_(arg)
+        , type_(type)
+    {}
+
+    void operator()(bool value)
+    {
+        if (type_ != 's')
+            operator()<bool>(value);
+    }
+
+    template<typename U, FMT_ENABLE_IF(std::is_integral<U>::value)>
+    void operator()(U value)
+    {
+        bool is_signed = type_ == 'd' || type_ == 'i';
+        using target_type = conditional_t<std::is_same<T, void>::value, U, T>;
+        if (const_check(sizeof(target_type) <= sizeof(int)))
+        {
+            // Extra casts are used to silence warnings.
+            if (is_signed)
+            {
+                arg_ = detail::make_arg<Context>(static_cast<int>(static_cast<target_type>(value)));
+            }
+            else
+            {
+                using unsigned_type = typename make_unsigned_or_bool<target_type>::type;
+                arg_ = detail::make_arg<Context>(static_cast<unsigned>(static_cast<unsigned_type>(value)));
+            }
+        }
+        else
+        {
+            if (is_signed)
+            {
+                // glibc's printf doesn't sign extend arguments of smaller types:
+                //   std::printf("%lld", -42);  // prints "4294967254"
+                // but we don't have to do the same because it's a UB.
+                arg_ = detail::make_arg<Context>(static_cast<long long>(value));
+            }
+            else
+            {
+                arg_ = detail::make_arg<Context>(static_cast<typename make_unsigned_or_bool<U>::type>(value));
+            }
+        }
+    }
+
+    template<typename U, FMT_ENABLE_IF(!std::is_integral<U>::value)>
+    void operator()(U)
+    {} // No conversion needed for non-integral types.
+};
+
+// Converts an integer argument to T for printf, if T is an integral type.
+// If T is void, the argument is converted to corresponding signed or unsigned
+// type depending on the type specifier: 'd' and 'i' - signed, other -
+// unsigned).
+template<typename T, typename Context, typename Char>
+void convert_arg(basic_format_arg<Context> &arg, Char type)
+{
+    visit_format_arg(arg_converter<T, Context>(arg, type), arg);
+}
+
+// Converts an integer argument to char for printf.
+template<typename Context>
+class char_converter
+{
+private:
+    basic_format_arg<Context> &arg_;
+
+public:
+    explicit char_converter(basic_format_arg<Context> &arg)
+        : arg_(arg)
+    {}
+
+    template<typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
+    void operator()(T value)
+    {
+        arg_ = detail::make_arg<Context>(static_cast<typename Context::char_type>(value));
+    }
+
+    template<typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
+    void operator()(T)
+    {} // No conversion needed for non-integral types.
+};
+
+// An argument visitor that return a pointer to a C string if argument is a
+// string or null otherwise.
+template<typename Char>
+struct get_cstring
+{
+    template<typename T>
+    const Char *operator()(T)
+    {
+        return nullptr;
+    }
+    const Char *operator()(const Char *s)
+    {
+        return s;
+    }
+};
+
+// Checks if an argument is a valid printf width specifier and sets
+// left alignment if it is negative.
+template<typename Char>
+class printf_width_handler
+{
+private:
+    using format_specs = basic_format_specs<Char>;
+
+    format_specs &specs_;
+
+public:
+    explicit printf_width_handler(format_specs &specs)
+        : specs_(specs)
+    {}
+
+    template<typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
+    unsigned operator()(T value)
+    {
+        auto width = static_cast<uint32_or_64_or_128_t<T>>(value);
+        if (detail::is_negative(value))
+        {
+            specs_.align = align::left;
+            width = 0 - width;
+        }
+        unsigned int_max = max_value<int>();
+        if (width > int_max)
+            FMT_THROW(format_error("number is too big"));
+        return static_cast<unsigned>(width);
+    }
+
+    template<typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
+    unsigned operator()(T)
+    {
+        FMT_THROW(format_error("width is not integer"));
+        return 0;
+    }
+};
+
+// The ``printf`` argument formatter.
+template<typename OutputIt, typename Char>
+class printf_arg_formatter : public arg_formatter<Char>
+{
+private:
+    using base = arg_formatter<Char>;
+    using context_type = basic_printf_context<OutputIt, Char>;
+    using format_specs = basic_format_specs<Char>;
+
+    context_type &context_;
+
+    OutputIt write_null_pointer(bool is_string = false)
+    {
+        auto s = this->specs;
+        s.type = presentation_type::none;
+        return write_bytes(this->out, is_string ? "(null)" : "(nil)", s);
+    }
+
+public:
+    printf_arg_formatter(OutputIt iter, format_specs &s, context_type &ctx)
+        : base{iter, s, locale_ref()}
+        , context_(ctx)
+    {}
+
+    OutputIt operator()(monostate value)
+    {
+        return base::operator()(value);
+    }
+
+    template<typename T, FMT_ENABLE_IF(detail::is_integral<T>::value)>
+    OutputIt operator()(T value)
+    {
+        // MSVC2013 fails to compile separate overloads for bool and Char so use
+        // std::is_same instead.
+        if (std::is_same<T, Char>::value)
+        {
+            format_specs fmt_specs = this->specs;
+            if (fmt_specs.type != presentation_type::none && fmt_specs.type != presentation_type::chr)
+            {
+                return (*this)(static_cast<int>(value));
+            }
+            fmt_specs.sign = sign::none;
+            fmt_specs.alt = false;
+            fmt_specs.fill[0] = ' '; // Ignore '0' flag for char types.
+            // align::numeric needs to be overwritten here since the '0' flag is
+            // ignored for non-numeric types
+            if (fmt_specs.align == align::none || fmt_specs.align == align::numeric)
+                fmt_specs.align = align::right;
+            return write<Char>(this->out, static_cast<Char>(value), fmt_specs);
+        }
+        return base::operator()(value);
+    }
+
+    template<typename T, FMT_ENABLE_IF(std::is_floating_point<T>::value)>
+    OutputIt operator()(T value)
+    {
+        return base::operator()(value);
+    }
+
+    /** Formats a null-terminated C string. */
+    OutputIt operator()(const char *value)
+    {
+        if (value)
+            return base::operator()(value);
+        return write_null_pointer(this->specs.type != presentation_type::pointer);
+    }
+
+    /** Formats a null-terminated wide C string. */
+    OutputIt operator()(const wchar_t *value)
+    {
+        if (value)
+            return base::operator()(value);
+        return write_null_pointer(this->specs.type != presentation_type::pointer);
+    }
+
+    OutputIt operator()(basic_string_view<Char> value)
+    {
+        return base::operator()(value);
+    }
+
+    /** Formats a pointer. */
+    OutputIt operator()(const void *value)
+    {
+        return value ? base::operator()(value) : write_null_pointer();
+    }
+
+    /** Formats an argument of a custom (user-defined) type. */
+    OutputIt operator()(typename basic_format_arg<context_type>::handle handle)
+    {
+        auto parse_ctx = basic_printf_parse_context<Char>(basic_string_view<Char>());
+        handle.format(parse_ctx, context_);
+        return this->out;
+    }
+};
+
+template<typename Char>
+void parse_flags(basic_format_specs<Char> &specs, const Char *&it, const Char *end)
+{
+    for (; it != end; ++it)
+    {
+        switch (*it)
+        {
+        case '-':
+            specs.align = align::left;
+            break;
+        case '+':
+            specs.sign = sign::plus;
+            break;
+        case '0':
+            specs.fill[0] = '0';
+            break;
+        case ' ':
+            if (specs.sign != sign::plus)
+            {
+                specs.sign = sign::space;
+            }
+            break;
+        case '#':
+            specs.alt = true;
+            break;
+        default:
+            return;
+        }
+    }
+}
+
+template<typename Char, typename GetArg>
+int parse_header(const Char *&it, const Char *end, basic_format_specs<Char> &specs, GetArg get_arg)
+{
+    int arg_index = -1;
+    Char c = *it;
+    if (c >= '0' && c <= '9')
+    {
+        // Parse an argument index (if followed by '$') or a width possibly
+        // preceded with '0' flag(s).
+        int value = parse_nonnegative_int(it, end, -1);
+        if (it != end && *it == '$')
+        { // value is an argument index
+            ++it;
+            arg_index = value != -1 ? value : max_value<int>();
+        }
+        else
+        {
+            if (c == '0')
+                specs.fill[0] = '0';
+            if (value != 0)
+            {
+                // Nonzero value means that we parsed width and don't need to
+                // parse it or flags again, so return now.
+                if (value == -1)
+                    FMT_THROW(format_error("number is too big"));
+                specs.width = value;
+                return arg_index;
+            }
+        }
+    }
+    parse_flags(specs, it, end);
+    // Parse width.
+    if (it != end)
+    {
+        if (*it >= '0' && *it <= '9')
+        {
+            specs.width = parse_nonnegative_int(it, end, -1);
+            if (specs.width == -1)
+                FMT_THROW(format_error("number is too big"));
+        }
+        else if (*it == '*')
+        {
+            ++it;
+            specs.width = static_cast<int>(visit_format_arg(detail::printf_width_handler<Char>(specs), get_arg(-1)));
+        }
+    }
+    return arg_index;
+}
+
+template<typename Char, typename Context>
+void vprintf(buffer<Char> &buf, basic_string_view<Char> format, basic_format_args<Context> args)
+{
+    using OutputIt = buffer_appender<Char>;
+    auto out = OutputIt(buf);
+    auto context = basic_printf_context<OutputIt, Char>(out, args);
+    auto parse_ctx = basic_printf_parse_context<Char>(format);
+
+    // Returns the argument with specified index or, if arg_index is -1, the next
+    // argument.
+    auto get_arg = [&](int arg_index) {
+        if (arg_index < 0)
+            arg_index = parse_ctx.next_arg_id();
+        else
+            parse_ctx.check_arg_id(--arg_index);
+        return detail::get_arg(context, arg_index);
+    };
+
+    const Char *start = parse_ctx.begin();
+    const Char *end = parse_ctx.end();
+    auto it = start;
+    while (it != end)
+    {
+        if (!detail::find<false, Char>(it, end, '%', it))
+        {
+            it = end; // detail::find leaves it == nullptr if it doesn't find '%'
+            break;
+        }
+        Char c = *it++;
+        if (it != end && *it == c)
+        {
+            out = detail::write(out, basic_string_view<Char>(start, detail::to_unsigned(it - start)));
+            start = ++it;
+            continue;
+        }
+        out = detail::write(out, basic_string_view<Char>(start, detail::to_unsigned(it - 1 - start)));
+
+        basic_format_specs<Char> specs;
+        specs.align = align::right;
+
+        // Parse argument index, flags and width.
+        int arg_index = parse_header(it, end, specs, get_arg);
+        if (arg_index == 0)
+            parse_ctx.on_error("argument not found");
+
+        // Parse precision.
+        if (it != end && *it == '.')
+        {
+            ++it;
+            c = it != end ? *it : 0;
+            if ('0' <= c && c <= '9')
+            {
+                specs.precision = parse_nonnegative_int(it, end, 0);
+            }
+            else if (c == '*')
+            {
+                ++it;
+                specs.precision = static_cast<int>(visit_format_arg(detail::printf_precision_handler(), get_arg(-1)));
+            }
+            else
+            {
+                specs.precision = 0;
+            }
+        }
+
+        auto arg = get_arg(arg_index);
+        // For d, i, o, u, x, and X conversion specifiers, if a precision is
+        // specified, the '0' flag is ignored
+        if (specs.precision >= 0 && arg.is_integral())
+            specs.fill[0] = ' '; // Ignore '0' flag for non-numeric types or if '-' present.
+        if (specs.precision >= 0 && arg.type() == detail::type::cstring_type)
+        {
+            auto str = visit_format_arg(detail::get_cstring<Char>(), arg);
+            auto str_end = str + specs.precision;
+            auto nul = std::find(str, str_end, Char());
+            arg = detail::make_arg<basic_printf_context<OutputIt, Char>>(
+                basic_string_view<Char>(str, detail::to_unsigned(nul != str_end ? nul - str : specs.precision)));
+        }
+        if (specs.alt && visit_format_arg(detail::is_zero_int(), arg))
+            specs.alt = false;
+        if (specs.fill[0] == '0')
+        {
+            if (arg.is_arithmetic() && specs.align != align::left)
+                specs.align = align::numeric;
+            else
+                specs.fill[0] = ' '; // Ignore '0' flag for non-numeric types or if '-'
+                                     // flag is also present.
+        }
+
+        // Parse length and convert the argument to the required type.
+        c = it != end ? *it++ : 0;
+        Char t = it != end ? *it : 0;
+        using detail::convert_arg;
+        switch (c)
+        {
+        case 'h':
+            if (t == 'h')
+            {
+                ++it;
+                t = it != end ? *it : 0;
+                convert_arg<signed char>(arg, t);
+            }
+            else
+            {
+                convert_arg<short>(arg, t);
+            }
+            break;
+        case 'l':
+            if (t == 'l')
+            {
+                ++it;
+                t = it != end ? *it : 0;
+                convert_arg<long long>(arg, t);
+            }
+            else
+            {
+                convert_arg<long>(arg, t);
+            }
+            break;
+        case 'j':
+            convert_arg<intmax_t>(arg, t);
+            break;
+        case 'z':
+            convert_arg<size_t>(arg, t);
+            break;
+        case 't':
+            convert_arg<std::ptrdiff_t>(arg, t);
+            break;
+        case 'L':
+            // printf produces garbage when 'L' is omitted for long double, no
+            // need to do the same.
+            break;
+        default:
+            --it;
+            convert_arg<void>(arg, c);
+        }
+
+        // Parse type.
+        if (it == end)
+            FMT_THROW(format_error("invalid format string"));
+        char type = static_cast<char>(*it++);
+        if (arg.is_integral())
+        {
+            // Normalize type.
+            switch (type)
+            {
+            case 'i':
+            case 'u':
+                type = 'd';
+                break;
+            case 'c':
+                visit_format_arg(detail::char_converter<basic_printf_context<OutputIt, Char>>(arg), arg);
+                break;
+            }
+        }
+        specs.type = parse_presentation_type(type);
+        if (specs.type == presentation_type::none)
+            parse_ctx.on_error("invalid type specifier");
+
+        start = it;
+
+        // Format argument.
+        out = visit_format_arg(detail::printf_arg_formatter<OutputIt, Char>(out, specs, context), arg);
+    }
+    detail::write(out, basic_string_view<Char>(start, to_unsigned(it - start)));
+}
+FMT_END_DETAIL_NAMESPACE
+
+template<typename Char>
+using basic_printf_context_t = basic_printf_context<detail::buffer_appender<Char>, Char>;
+
+using printf_context = basic_printf_context_t<char>;
+using wprintf_context = basic_printf_context_t<wchar_t>;
+
+using printf_args = basic_format_args<printf_context>;
+using wprintf_args = basic_format_args<wprintf_context>;
+
+/**
+  \rst
+  Constructs an `~fmt::format_arg_store` object that contains references to
+  arguments and can be implicitly converted to `~fmt::printf_args`.
+  \endrst
+ */
+template<typename... T>
+inline auto make_printf_args(const T &...args) -> format_arg_store<printf_context, T...>
+{
+    return {args...};
+}
+
+/**
+  \rst
+  Constructs an `~fmt::format_arg_store` object that contains references to
+  arguments and can be implicitly converted to `~fmt::wprintf_args`.
+  \endrst
+ */
+template<typename... T>
+inline auto make_wprintf_args(const T &...args) -> format_arg_store<wprintf_context, T...>
+{
+    return {args...};
+}
+
+template<typename S, typename Char = char_t<S>>
+inline auto vsprintf(const S &fmt, basic_format_args<basic_printf_context_t<type_identity_t<Char>>> args) -> std::basic_string<Char>
+{
+    basic_memory_buffer<Char> buffer;
+    vprintf(buffer, detail::to_string_view(fmt), args);
+    return to_string(buffer);
+}
+
+/**
+  \rst
+  Formats arguments and returns the result as a string.
+
+  **Example**::
+
+    std::string message = fmt::sprintf("The answer is %d", 42);
+  \endrst
+*/
+template<typename S, typename... T, typename Char = enable_if_t<detail::is_string<S>::value, char_t<S>>>
+inline auto sprintf(const S &fmt, const T &...args) -> std::basic_string<Char>
+{
+    using context = basic_printf_context_t<Char>;
+    return vsprintf(detail::to_string_view(fmt), fmt::make_format_args<context>(args...));
+}
+
+template<typename S, typename Char = char_t<S>>
+inline auto vfprintf(std::FILE *f, const S &fmt, basic_format_args<basic_printf_context_t<type_identity_t<Char>>> args) -> int
+{
+    basic_memory_buffer<Char> buffer;
+    vprintf(buffer, detail::to_string_view(fmt), args);
+    size_t size = buffer.size();
+    return std::fwrite(buffer.data(), sizeof(Char), size, f) < size ? -1 : static_cast<int>(size);
+}
+
+/**
+  \rst
+  Prints formatted data to the file *f*.
+
+  **Example**::
+
+    fmt::fprintf(stderr, "Don't %s!", "panic");
+  \endrst
+ */
+template<typename S, typename... T, typename Char = char_t<S>>
+inline auto fprintf(std::FILE *f, const S &fmt, const T &...args) -> int
+{
+    using context = basic_printf_context_t<Char>;
+    return vfprintf(f, detail::to_string_view(fmt), fmt::make_format_args<context>(args...));
+}
+
+template<typename S, typename Char = char_t<S>>
+inline auto vprintf(const S &fmt, basic_format_args<basic_printf_context_t<type_identity_t<Char>>> args) -> int
+{
+    return vfprintf(stdout, detail::to_string_view(fmt), args);
+}
+
+/**
+  \rst
+  Prints formatted data to ``stdout``.
+
+  **Example**::
+
+    fmt::printf("Elapsed time: %.2f seconds", 1.23);
+  \endrst
+ */
+template<typename S, typename... T, FMT_ENABLE_IF(detail::is_string<S>::value)>
+inline auto printf(const S &fmt, const T &...args) -> int
+{
+    return vprintf(detail::to_string_view(fmt), fmt::make_format_args<basic_printf_context_t<char_t<S>>>(args...));
+}
+
+FMT_MODULE_EXPORT_END
+FMT_END_NAMESPACE
+
+#endif // FMT_PRINTF_H_
diff --git a/3rdparty/spdlog/src/include/spdlog/fmt/bundled/ranges.h b/3rdparty/spdlog/src/include/spdlog/fmt/bundled/ranges.h
new file mode 100644
index 00000000..caa914db
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/fmt/bundled/ranges.h
@@ -0,0 +1,771 @@
+// Formatting library for C++ - experimental range support
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+//
+// Copyright (c) 2018 - present, Remotion (Igor Schulz)
+// All Rights Reserved
+// {fmt} support for ranges, containers and types tuple interface.
+
+#ifndef FMT_RANGES_H_
+#define FMT_RANGES_H_
+
+#include <initializer_list>
+#include <tuple>
+#include <type_traits>
+
+#include "format.h"
+
+FMT_BEGIN_NAMESPACE
+
+namespace detail {
+
+template<typename RangeT, typename OutputIterator>
+OutputIterator copy(const RangeT &range, OutputIterator out)
+{
+    for (auto it = range.begin(), end = range.end(); it != end; ++it)
+        *out++ = *it;
+    return out;
+}
+
+template<typename OutputIterator>
+OutputIterator copy(const char *str, OutputIterator out)
+{
+    while (*str)
+        *out++ = *str++;
+    return out;
+}
+
+template<typename OutputIterator>
+OutputIterator copy(char ch, OutputIterator out)
+{
+    *out++ = ch;
+    return out;
+}
+
+template<typename OutputIterator>
+OutputIterator copy(wchar_t ch, OutputIterator out)
+{
+    *out++ = ch;
+    return out;
+}
+
+// Returns true if T has a std::string-like interface, like std::string_view.
+template<typename T>
+class is_std_string_like
+{
+    template<typename U>
+    static auto check(U *p) -> decltype((void)p->find('a'), p->length(), (void)p->data(), int());
+    template<typename>
+    static void check(...);
+
+public:
+    static constexpr const bool value =
+        is_string<T>::value || std::is_convertible<T, std_string_view<char>>::value || !std::is_void<decltype(check<T>(nullptr))>::value;
+};
+
+template<typename Char>
+struct is_std_string_like<fmt::basic_string_view<Char>> : std::true_type
+{};
+
+template<typename T>
+class is_map
+{
+    template<typename U>
+    static auto check(U *) -> typename U::mapped_type;
+    template<typename>
+    static void check(...);
+
+public:
+#ifdef FMT_FORMAT_MAP_AS_LIST
+    static constexpr const bool value = false;
+#else
+    static constexpr const bool value = !std::is_void<decltype(check<T>(nullptr))>::value;
+#endif
+};
+
+template<typename T>
+class is_set
+{
+    template<typename U>
+    static auto check(U *) -> typename U::key_type;
+    template<typename>
+    static void check(...);
+
+public:
+#ifdef FMT_FORMAT_SET_AS_LIST
+    static constexpr const bool value = false;
+#else
+    static constexpr const bool value = !std::is_void<decltype(check<T>(nullptr))>::value && !is_map<T>::value;
+#endif
+};
+
+template<typename... Ts>
+struct conditional_helper
+{};
+
+template<typename T, typename _ = void>
+struct is_range_ : std::false_type
+{};
+
+#if !FMT_MSC_VERSION || FMT_MSC_VERSION > 1800
+
+#    define FMT_DECLTYPE_RETURN(val)                                                                                                       \
+        ->decltype(val)                                                                                                                    \
+        {                                                                                                                                  \
+            return val;                                                                                                                    \
+        }                                                                                                                                  \
+        static_assert(true, "") // This makes it so that a semicolon is required after the
+                                // macro, which helps clang-format handle the formatting.
+
+// C array overload
+template<typename T, std::size_t N>
+auto range_begin(const T (&arr)[N]) -> const T *
+{
+    return arr;
+}
+template<typename T, std::size_t N>
+auto range_end(const T (&arr)[N]) -> const T *
+{
+    return arr + N;
+}
+
+template<typename T, typename Enable = void>
+struct has_member_fn_begin_end_t : std::false_type
+{};
+
+template<typename T>
+struct has_member_fn_begin_end_t<T, void_t<decltype(std::declval<T>().begin()), decltype(std::declval<T>().end())>> : std::true_type
+{};
+
+// Member function overload
+template<typename T>
+auto range_begin(T &&rng) FMT_DECLTYPE_RETURN(static_cast<T &&>(rng).begin());
+template<typename T>
+auto range_end(T &&rng) FMT_DECLTYPE_RETURN(static_cast<T &&>(rng).end());
+
+// ADL overload. Only participates in overload resolution if member functions
+// are not found.
+template<typename T>
+auto range_begin(T &&rng) -> enable_if_t<!has_member_fn_begin_end_t<T &&>::value, decltype(begin(static_cast<T &&>(rng)))>
+{
+    return begin(static_cast<T &&>(rng));
+}
+template<typename T>
+auto range_end(T &&rng) -> enable_if_t<!has_member_fn_begin_end_t<T &&>::value, decltype(end(static_cast<T &&>(rng)))>
+{
+    return end(static_cast<T &&>(rng));
+}
+
+template<typename T, typename Enable = void>
+struct has_const_begin_end : std::false_type
+{};
+template<typename T, typename Enable = void>
+struct has_mutable_begin_end : std::false_type
+{};
+
+template<typename T>
+struct has_const_begin_end<T, void_t<decltype(detail::range_begin(std::declval<const remove_cvref_t<T> &>())),
+                                  decltype(detail::range_end(std::declval<const remove_cvref_t<T> &>()))>> : std::true_type
+{};
+
+template<typename T>
+struct has_mutable_begin_end<T, void_t<decltype(detail::range_begin(std::declval<T>())), decltype(detail::range_end(std::declval<T>())),
+                                    enable_if_t<std::is_copy_constructible<T>::value>>> : std::true_type
+{};
+
+template<typename T>
+struct is_range_<T, void> : std::integral_constant<bool, (has_const_begin_end<T>::value || has_mutable_begin_end<T>::value)>
+{};
+#    undef FMT_DECLTYPE_RETURN
+#endif
+
+// tuple_size and tuple_element check.
+template<typename T>
+class is_tuple_like_
+{
+    template<typename U>
+    static auto check(U *p) -> decltype(std::tuple_size<U>::value, int());
+    template<typename>
+    static void check(...);
+
+public:
+    static constexpr const bool value = !std::is_void<decltype(check<T>(nullptr))>::value;
+};
+
+// Check for integer_sequence
+#if defined(__cpp_lib_integer_sequence) || FMT_MSC_VERSION >= 1900
+template<typename T, T... N>
+using integer_sequence = std::integer_sequence<T, N...>;
+template<size_t... N>
+using index_sequence = std::index_sequence<N...>;
+template<size_t N>
+using make_index_sequence = std::make_index_sequence<N>;
+#else
+template<typename T, T... N>
+struct integer_sequence
+{
+    using value_type = T;
+
+    static FMT_CONSTEXPR size_t size()
+    {
+        return sizeof...(N);
+    }
+};
+
+template<size_t... N>
+using index_sequence = integer_sequence<size_t, N...>;
+
+template<typename T, size_t N, T... Ns>
+struct make_integer_sequence : make_integer_sequence<T, N - 1, N - 1, Ns...>
+{};
+template<typename T, T... Ns>
+struct make_integer_sequence<T, 0, Ns...> : integer_sequence<T, Ns...>
+{};
+
+template<size_t N>
+using make_index_sequence = make_integer_sequence<size_t, N>;
+#endif
+
+template<typename T>
+using tuple_index_sequence = make_index_sequence<std::tuple_size<T>::value>;
+
+template<typename T, typename C, bool = is_tuple_like_<T>::value>
+class is_tuple_formattable_
+{
+public:
+    static constexpr const bool value = false;
+};
+template<typename T, typename C>
+class is_tuple_formattable_<T, C, true>
+{
+    template<std::size_t... I>
+    static std::true_type check2(index_sequence<I...>, integer_sequence<bool, (I == I)...>);
+    static std::false_type check2(...);
+    template<std::size_t... I>
+    static decltype(check2(index_sequence<I...>{},
+        integer_sequence<bool, (is_formattable<typename std::tuple_element<I, T>::type, C>::value)...>{})) check(index_sequence<I...>);
+
+public:
+    static constexpr const bool value = decltype(check(tuple_index_sequence<T>{}))::value;
+};
+
+template<class Tuple, class F, size_t... Is>
+void for_each(index_sequence<Is...>, Tuple &&tup, F &&f) noexcept
+{
+    using std::get;
+    // using free function get<I>(T) now.
+    const int _[] = {0, ((void)f(get<Is>(tup)), 0)...};
+    (void)_; // blocks warnings
+}
+
+template<class T>
+FMT_CONSTEXPR make_index_sequence<std::tuple_size<T>::value> get_indexes(T const &)
+{
+    return {};
+}
+
+template<class Tuple, class F>
+void for_each(Tuple &&tup, F &&f)
+{
+    const auto indexes = get_indexes(tup);
+    for_each(indexes, std::forward<Tuple>(tup), std::forward<F>(f));
+}
+
+#if FMT_MSC_VERSION && FMT_MSC_VERSION < 1920
+// Older MSVC doesn't get the reference type correctly for arrays.
+template<typename R>
+struct range_reference_type_impl
+{
+    using type = decltype(*detail::range_begin(std::declval<R &>()));
+};
+
+template<typename T, std::size_t N>
+struct range_reference_type_impl<T[N]>
+{
+    using type = T &;
+};
+
+template<typename T>
+using range_reference_type = typename range_reference_type_impl<T>::type;
+#else
+template<typename Range>
+using range_reference_type = decltype(*detail::range_begin(std::declval<Range &>()));
+#endif
+
+// We don't use the Range's value_type for anything, but we do need the Range's
+// reference type, with cv-ref stripped.
+template<typename Range>
+using uncvref_type = remove_cvref_t<range_reference_type<Range>>;
+
+template<typename Range>
+using uncvref_first_type = remove_cvref_t<decltype(std::declval<range_reference_type<Range>>().first)>;
+
+template<typename Range>
+using uncvref_second_type = remove_cvref_t<decltype(std::declval<range_reference_type<Range>>().second)>;
+
+template<typename OutputIt>
+OutputIt write_delimiter(OutputIt out)
+{
+    *out++ = ',';
+    *out++ = ' ';
+    return out;
+}
+
+template<typename Char, typename OutputIt>
+auto write_range_entry(OutputIt out, basic_string_view<Char> str) -> OutputIt
+{
+    return write_escaped_string(out, str);
+}
+
+template<typename Char, typename OutputIt, typename T, FMT_ENABLE_IF(std::is_convertible<T, std_string_view<char>>::value)>
+inline auto write_range_entry(OutputIt out, const T &str) -> OutputIt
+{
+    auto sv = std_string_view<Char>(str);
+    return write_range_entry<Char>(out, basic_string_view<Char>(sv));
+}
+
+template<typename Char, typename OutputIt, typename Arg, FMT_ENABLE_IF(std::is_same<Arg, Char>::value)>
+OutputIt write_range_entry(OutputIt out, const Arg v)
+{
+    return write_escaped_char(out, v);
+}
+
+template<typename Char, typename OutputIt, typename Arg,
+    FMT_ENABLE_IF(!is_std_string_like<typename std::decay<Arg>::type>::value && !std::is_same<Arg, Char>::value)>
+OutputIt write_range_entry(OutputIt out, const Arg &v)
+{
+    return write<Char>(out, v);
+}
+
+} // namespace detail
+
+template<typename T>
+struct is_tuple_like
+{
+    static constexpr const bool value = detail::is_tuple_like_<T>::value && !detail::is_range_<T>::value;
+};
+
+template<typename T, typename C>
+struct is_tuple_formattable
+{
+    static constexpr const bool value = detail::is_tuple_formattable_<T, C>::value;
+};
+
+template<typename TupleT, typename Char>
+struct formatter<TupleT, Char, enable_if_t<fmt::is_tuple_like<TupleT>::value && fmt::is_tuple_formattable<TupleT, Char>::value>>
+{
+private:
+    basic_string_view<Char> separator_ = detail::string_literal<Char, ',', ' '>{};
+    basic_string_view<Char> opening_bracket_ = detail::string_literal<Char, '('>{};
+    basic_string_view<Char> closing_bracket_ = detail::string_literal<Char, ')'>{};
+
+    // C++11 generic lambda for format().
+    template<typename FormatContext>
+    struct format_each
+    {
+        template<typename T>
+        void operator()(const T &v)
+        {
+            if (i > 0)
+                out = detail::copy_str<Char>(separator, out);
+            out = detail::write_range_entry<Char>(out, v);
+            ++i;
+        }
+        int i;
+        typename FormatContext::iterator &out;
+        basic_string_view<Char> separator;
+    };
+
+public:
+    FMT_CONSTEXPR formatter() {}
+
+    FMT_CONSTEXPR void set_separator(basic_string_view<Char> sep)
+    {
+        separator_ = sep;
+    }
+
+    FMT_CONSTEXPR void set_brackets(basic_string_view<Char> open, basic_string_view<Char> close)
+    {
+        opening_bracket_ = open;
+        closing_bracket_ = close;
+    }
+
+    template<typename ParseContext>
+    FMT_CONSTEXPR auto parse(ParseContext &ctx) -> decltype(ctx.begin())
+    {
+        return ctx.begin();
+    }
+
+    template<typename FormatContext = format_context>
+    auto format(const TupleT &values, FormatContext &ctx) const -> decltype(ctx.out())
+    {
+        auto out = ctx.out();
+        out = detail::copy_str<Char>(opening_bracket_, out);
+        detail::for_each(values, format_each<FormatContext>{0, out, separator_});
+        out = detail::copy_str<Char>(closing_bracket_, out);
+        return out;
+    }
+};
+
+template<typename T, typename Char>
+struct is_range
+{
+    static constexpr const bool value = detail::is_range_<T>::value && !detail::is_std_string_like<T>::value &&
+                                        !std::is_convertible<T, std::basic_string<Char>>::value &&
+                                        !std::is_convertible<T, detail::std_string_view<Char>>::value;
+};
+
+namespace detail {
+template<typename Context>
+struct range_mapper
+{
+    using mapper = arg_mapper<Context>;
+
+    template<typename T, FMT_ENABLE_IF(has_formatter<remove_cvref_t<T>, Context>::value)>
+    static auto map(T &&value) -> T &&
+    {
+        return static_cast<T &&>(value);
+    }
+    template<typename T, FMT_ENABLE_IF(!has_formatter<remove_cvref_t<T>, Context>::value)>
+    static auto map(T &&value) -> decltype(mapper().map(static_cast<T &&>(value)))
+    {
+        return mapper().map(static_cast<T &&>(value));
+    }
+};
+
+template<typename Char, typename Element>
+using range_formatter_type = conditional_t<is_formattable<Element, Char>::value,
+    formatter<remove_cvref_t<decltype(range_mapper<buffer_context<Char>>{}.map(std::declval<Element>()))>, Char>,
+    fallback_formatter<Element, Char>>;
+
+template<typename R>
+using maybe_const_range = conditional_t<has_const_begin_end<R>::value, const R, R>;
+
+// Workaround a bug in MSVC 2015 and earlier.
+#if !FMT_MSC_VERSION || FMT_MSC_VERSION >= 1910
+template<typename R, typename Char>
+struct is_formattable_delayed : disjunction<is_formattable<uncvref_type<maybe_const_range<R>>, Char>,
+                                    has_fallback_formatter<uncvref_type<maybe_const_range<R>>, Char>>
+{};
+#endif
+
+} // namespace detail
+
+template<typename T, typename Char, typename Enable = void>
+struct range_formatter;
+
+template<typename T, typename Char>
+struct range_formatter<T, Char,
+    enable_if_t<conjunction<std::is_same<T, remove_cvref_t<T>>,
+        disjunction<is_formattable<T, Char>, detail::has_fallback_formatter<T, Char>>>::value>>
+{
+private:
+    detail::range_formatter_type<Char, T> underlying_;
+    bool custom_specs_ = false;
+    basic_string_view<Char> separator_ = detail::string_literal<Char, ',', ' '>{};
+    basic_string_view<Char> opening_bracket_ = detail::string_literal<Char, '['>{};
+    basic_string_view<Char> closing_bracket_ = detail::string_literal<Char, ']'>{};
+
+    template<class U>
+    FMT_CONSTEXPR static auto maybe_set_debug_format(U &u, int) -> decltype(u.set_debug_format())
+    {
+        u.set_debug_format();
+    }
+
+    template<class U>
+    FMT_CONSTEXPR static void maybe_set_debug_format(U &, ...)
+    {}
+
+    FMT_CONSTEXPR void maybe_set_debug_format()
+    {
+        maybe_set_debug_format(underlying_, 0);
+    }
+
+public:
+    FMT_CONSTEXPR range_formatter() {}
+
+    FMT_CONSTEXPR auto underlying() -> detail::range_formatter_type<Char, T> &
+    {
+        return underlying_;
+    }
+
+    FMT_CONSTEXPR void set_separator(basic_string_view<Char> sep)
+    {
+        separator_ = sep;
+    }
+
+    FMT_CONSTEXPR void set_brackets(basic_string_view<Char> open, basic_string_view<Char> close)
+    {
+        opening_bracket_ = open;
+        closing_bracket_ = close;
+    }
+
+    template<typename ParseContext>
+    FMT_CONSTEXPR auto parse(ParseContext &ctx) -> decltype(ctx.begin())
+    {
+        auto it = ctx.begin();
+        auto end = ctx.end();
+        if (it == end || *it == '}')
+        {
+            maybe_set_debug_format();
+            return it;
+        }
+
+        if (*it == 'n')
+        {
+            set_brackets({}, {});
+            ++it;
+        }
+
+        if (*it == '}')
+        {
+            maybe_set_debug_format();
+            return it;
+        }
+
+        if (*it != ':')
+            FMT_THROW(format_error("no other top-level range formatters supported"));
+
+        custom_specs_ = true;
+        ++it;
+        ctx.advance_to(it);
+        return underlying_.parse(ctx);
+    }
+
+    template<typename R, class FormatContext>
+    auto format(R &&range, FormatContext &ctx) const -> decltype(ctx.out())
+    {
+        detail::range_mapper<buffer_context<Char>> mapper;
+        auto out = ctx.out();
+        out = detail::copy_str<Char>(opening_bracket_, out);
+        int i = 0;
+        auto it = detail::range_begin(range);
+        auto end = detail::range_end(range);
+        for (; it != end; ++it)
+        {
+            if (i > 0)
+                out = detail::copy_str<Char>(separator_, out);
+            ;
+            ctx.advance_to(out);
+            out = underlying_.format(mapper.map(*it), ctx);
+            ++i;
+        }
+        out = detail::copy_str<Char>(closing_bracket_, out);
+        return out;
+    }
+};
+
+enum class range_format
+{
+    disabled,
+    map,
+    set,
+    sequence,
+    string,
+    debug_string
+};
+
+namespace detail {
+template<typename T>
+struct range_format_kind_
+{
+    static constexpr auto value = std::is_same<range_reference_type<T>, T>::value ? range_format::disabled
+                                  : is_map<T>::value                              ? range_format::map
+                                  : is_set<T>::value                              ? range_format::set
+                                                                                  : range_format::sequence;
+};
+
+template<range_format K, typename R, typename Char, typename Enable = void>
+struct range_default_formatter;
+
+template<range_format K>
+using range_format_constant = std::integral_constant<range_format, K>;
+
+template<range_format K, typename R, typename Char>
+struct range_default_formatter<K, R, Char, enable_if_t<(K == range_format::sequence || K == range_format::map || K == range_format::set)>>
+{
+    using range_type = detail::maybe_const_range<R>;
+    range_formatter<detail::uncvref_type<range_type>, Char> underlying_;
+
+    FMT_CONSTEXPR range_default_formatter()
+    {
+        init(range_format_constant<K>());
+    }
+
+    FMT_CONSTEXPR void init(range_format_constant<range_format::set>)
+    {
+        underlying_.set_brackets(detail::string_literal<Char, '{'>{}, detail::string_literal<Char, '}'>{});
+    }
+
+    FMT_CONSTEXPR void init(range_format_constant<range_format::map>)
+    {
+        underlying_.set_brackets(detail::string_literal<Char, '{'>{}, detail::string_literal<Char, '}'>{});
+        underlying_.underlying().set_brackets({}, {});
+        underlying_.underlying().set_separator(detail::string_literal<Char, ':', ' '>{});
+    }
+
+    FMT_CONSTEXPR void init(range_format_constant<range_format::sequence>) {}
+
+    template<typename ParseContext>
+    FMT_CONSTEXPR auto parse(ParseContext &ctx) -> decltype(ctx.begin())
+    {
+        return underlying_.parse(ctx);
+    }
+
+    template<typename FormatContext>
+    auto format(range_type &range, FormatContext &ctx) const -> decltype(ctx.out())
+    {
+        return underlying_.format(range, ctx);
+    }
+};
+} // namespace detail
+
+template<typename T, typename Char, typename Enable = void>
+struct range_format_kind
+    : conditional_t<is_range<T, Char>::value, detail::range_format_kind_<T>, std::integral_constant<range_format, range_format::disabled>>
+{};
+
+template<typename R, typename Char>
+struct formatter<R, Char,
+    enable_if_t<conjunction<bool_constant<range_format_kind<R, Char>::value != range_format::disabled>
+// Workaround a bug in MSVC 2015 and earlier.
+#if !FMT_MSC_VERSION || FMT_MSC_VERSION >= 1910
+        ,
+        detail::is_formattable_delayed<R, Char>
+#endif
+        >::value>> : detail::range_default_formatter<range_format_kind<R, Char>::value, R, Char>
+{};
+
+template<typename Char, typename... T>
+struct tuple_join_view : detail::view
+{
+    const std::tuple<T...> &tuple;
+    basic_string_view<Char> sep;
+
+    tuple_join_view(const std::tuple<T...> &t, basic_string_view<Char> s)
+        : tuple(t)
+        , sep{s}
+    {}
+};
+
+template<typename Char, typename... T>
+using tuple_arg_join = tuple_join_view<Char, T...>;
+
+// Define FMT_TUPLE_JOIN_SPECIFIERS to enable experimental format specifiers
+// support in tuple_join. It is disabled by default because of issues with
+// the dynamic width and precision.
+#ifndef FMT_TUPLE_JOIN_SPECIFIERS
+#    define FMT_TUPLE_JOIN_SPECIFIERS 0
+#endif
+
+template<typename Char, typename... T>
+struct formatter<tuple_join_view<Char, T...>, Char>
+{
+    template<typename ParseContext>
+    FMT_CONSTEXPR auto parse(ParseContext &ctx) -> decltype(ctx.begin())
+    {
+        return do_parse(ctx, std::integral_constant<size_t, sizeof...(T)>());
+    }
+
+    template<typename FormatContext>
+    auto format(const tuple_join_view<Char, T...> &value, FormatContext &ctx) const -> typename FormatContext::iterator
+    {
+        return do_format(value, ctx, std::integral_constant<size_t, sizeof...(T)>());
+    }
+
+private:
+    std::tuple<formatter<typename std::decay<T>::type, Char>...> formatters_;
+
+    template<typename ParseContext>
+    FMT_CONSTEXPR auto do_parse(ParseContext &ctx, std::integral_constant<size_t, 0>) -> decltype(ctx.begin())
+    {
+        return ctx.begin();
+    }
+
+    template<typename ParseContext, size_t N>
+    FMT_CONSTEXPR auto do_parse(ParseContext &ctx, std::integral_constant<size_t, N>) -> decltype(ctx.begin())
+    {
+        auto end = ctx.begin();
+#if FMT_TUPLE_JOIN_SPECIFIERS
+        end = std::get<sizeof...(T) - N>(formatters_).parse(ctx);
+        if (N > 1)
+        {
+            auto end1 = do_parse(ctx, std::integral_constant<size_t, N - 1>());
+            if (end != end1)
+                FMT_THROW(format_error("incompatible format specs for tuple elements"));
+        }
+#endif
+        return end;
+    }
+
+    template<typename FormatContext>
+    auto do_format(const tuple_join_view<Char, T...> &, FormatContext &ctx, std::integral_constant<size_t, 0>) const ->
+        typename FormatContext::iterator
+    {
+        return ctx.out();
+    }
+
+    template<typename FormatContext, size_t N>
+    auto do_format(const tuple_join_view<Char, T...> &value, FormatContext &ctx, std::integral_constant<size_t, N>) const ->
+        typename FormatContext::iterator
+    {
+        auto out = std::get<sizeof...(T) - N>(formatters_).format(std::get<sizeof...(T) - N>(value.tuple), ctx);
+        if (N > 1)
+        {
+            out = std::copy(value.sep.begin(), value.sep.end(), out);
+            ctx.advance_to(out);
+            return do_format(value, ctx, std::integral_constant<size_t, N - 1>());
+        }
+        return out;
+    }
+};
+
+FMT_MODULE_EXPORT_BEGIN
+
+/**
+  \rst
+  Returns an object that formats `tuple` with elements separated by `sep`.
+
+  **Example**::
+
+    std::tuple<int, char> t = {1, 'a'};
+    fmt::print("{}", fmt::join(t, ", "));
+    // Output: "1, a"
+  \endrst
+ */
+template<typename... T>
+FMT_CONSTEXPR auto join(const std::tuple<T...> &tuple, string_view sep) -> tuple_join_view<char, T...>
+{
+    return {tuple, sep};
+}
+
+template<typename... T>
+FMT_CONSTEXPR auto join(const std::tuple<T...> &tuple, basic_string_view<wchar_t> sep) -> tuple_join_view<wchar_t, T...>
+{
+    return {tuple, sep};
+}
+
+/**
+  \rst
+  Returns an object that formats `initializer_list` with elements separated by
+  `sep`.
+
+  **Example**::
+
+    fmt::print("{}", fmt::join({1, 2, 3}, ", "));
+    // Output: "1, 2, 3"
+  \endrst
+ */
+template<typename T>
+auto join(std::initializer_list<T> list, string_view sep) -> join_view<const T *, const T *>
+{
+    return join(std::begin(list), std::end(list), sep);
+}
+
+FMT_MODULE_EXPORT_END
+FMT_END_NAMESPACE
+
+#endif // FMT_RANGES_H_
diff --git a/3rdparty/spdlog/src/include/spdlog/fmt/bundled/std.h b/3rdparty/spdlog/src/include/spdlog/fmt/bundled/std.h
new file mode 100644
index 00000000..6681ce72
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/fmt/bundled/std.h
@@ -0,0 +1,169 @@
+// Formatting library for C++ - formatters for standard library types
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#ifndef FMT_STD_H_
+#define FMT_STD_H_
+
+#include <thread>
+#include <type_traits>
+#include <utility>
+
+#include "ostream.h"
+
+#if FMT_HAS_INCLUDE(<version>)
+#    include <version>
+#endif
+// Checking FMT_CPLUSPLUS for warning suppression in MSVC.
+#if FMT_CPLUSPLUS >= 201703L
+#    if FMT_HAS_INCLUDE(<filesystem>)
+#        include <filesystem>
+#    endif
+#    if FMT_HAS_INCLUDE(<variant>)
+#        include <variant>
+#    endif
+#endif
+
+#ifdef __cpp_lib_filesystem
+FMT_BEGIN_NAMESPACE
+
+namespace detail {
+
+template<typename Char>
+void write_escaped_path(basic_memory_buffer<Char> &quoted, const std::filesystem::path &p)
+{
+    write_escaped_string<Char>(std::back_inserter(quoted), p.string<Char>());
+}
+#    ifdef _WIN32
+template<>
+inline void write_escaped_path<char>(basic_memory_buffer<char> &quoted, const std::filesystem::path &p)
+{
+    auto s = p.u8string();
+    write_escaped_string<char>(std::back_inserter(quoted), string_view(reinterpret_cast<const char *>(s.c_str()), s.size()));
+}
+#    endif
+template<>
+inline void write_escaped_path<std::filesystem::path::value_type>(
+    basic_memory_buffer<std::filesystem::path::value_type> &quoted, const std::filesystem::path &p)
+{
+    write_escaped_string<std::filesystem::path::value_type>(std::back_inserter(quoted), p.native());
+}
+
+} // namespace detail
+
+template<typename Char>
+struct formatter<std::filesystem::path, Char> : formatter<basic_string_view<Char>>
+{
+    template<typename FormatContext>
+    auto format(const std::filesystem::path &p, FormatContext &ctx) const -> typename FormatContext::iterator
+    {
+        basic_memory_buffer<Char> quoted;
+        detail::write_escaped_path(quoted, p);
+        return formatter<basic_string_view<Char>>::format(basic_string_view<Char>(quoted.data(), quoted.size()), ctx);
+    }
+};
+FMT_END_NAMESPACE
+#endif
+
+FMT_BEGIN_NAMESPACE
+template<typename Char>
+struct formatter<std::thread::id, Char> : basic_ostream_formatter<Char>
+{};
+FMT_END_NAMESPACE
+
+#ifdef __cpp_lib_variant
+FMT_BEGIN_NAMESPACE
+template<typename Char>
+struct formatter<std::monostate, Char>
+{
+    template<typename ParseContext>
+    FMT_CONSTEXPR auto parse(ParseContext &ctx) -> decltype(ctx.begin())
+    {
+        return ctx.begin();
+    }
+
+    template<typename FormatContext>
+    auto format(const std::monostate &, FormatContext &ctx) const -> decltype(ctx.out())
+    {
+        auto out = ctx.out();
+        out = detail::write<Char>(out, "monostate");
+        return out;
+    }
+};
+
+namespace detail {
+
+template<typename T>
+using variant_index_sequence = std::make_index_sequence<std::variant_size<T>::value>;
+
+// variant_size and variant_alternative check.
+template<typename T, typename U = void>
+struct is_variant_like_ : std::false_type
+{};
+template<typename T>
+struct is_variant_like_<T, std::void_t<decltype(std::variant_size<T>::value)>> : std::true_type
+{};
+
+// formattable element check
+template<typename T, typename C>
+class is_variant_formattable_
+{
+    template<std::size_t... I>
+    static std::conjunction<is_formattable<std::variant_alternative_t<I, T>, C>...> check(std::index_sequence<I...>);
+
+public:
+    static constexpr const bool value = decltype(check(variant_index_sequence<T>{}))::value;
+};
+
+template<typename Char, typename OutputIt, typename T>
+auto write_variant_alternative(OutputIt out, const T &v) -> OutputIt
+{
+    if constexpr (is_string<T>::value)
+        return write_escaped_string<Char>(out, detail::to_string_view(v));
+    else if constexpr (std::is_same_v<T, Char>)
+        return write_escaped_char(out, v);
+    else
+        return write<Char>(out, v);
+}
+
+} // namespace detail
+
+template<typename T>
+struct is_variant_like
+{
+    static constexpr const bool value = detail::is_variant_like_<T>::value;
+};
+
+template<typename T, typename C>
+struct is_variant_formattable
+{
+    static constexpr const bool value = detail::is_variant_formattable_<T, C>::value;
+};
+
+template<typename Variant, typename Char>
+struct formatter<Variant, Char, std::enable_if_t<std::conjunction_v<is_variant_like<Variant>, is_variant_formattable<Variant, Char>>>>
+{
+    template<typename ParseContext>
+    FMT_CONSTEXPR auto parse(ParseContext &ctx) -> decltype(ctx.begin())
+    {
+        return ctx.begin();
+    }
+
+    template<typename FormatContext>
+    auto format(const Variant &value, FormatContext &ctx) const -> decltype(ctx.out())
+    {
+        auto out = ctx.out();
+
+        out = detail::write<Char>(out, "variant(");
+        std::visit([&](const auto &v) { out = detail::write_variant_alternative<Char>(out, v); }, value);
+        *out++ = ')';
+        return out;
+    }
+};
+FMT_END_NAMESPACE
+#endif
+
+#endif // FMT_STD_H_
diff --git a/3rdparty/spdlog/src/include/spdlog/fmt/bundled/xchar.h b/3rdparty/spdlog/src/include/spdlog/fmt/bundled/xchar.h
new file mode 100644
index 00000000..defcb647
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/fmt/bundled/xchar.h
@@ -0,0 +1,228 @@
+// Formatting library for C++ - optional wchar_t and exotic character support
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#ifndef FMT_XCHAR_H_
+#define FMT_XCHAR_H_
+
+#include <cwchar>
+
+#include "format.h"
+
+FMT_BEGIN_NAMESPACE
+namespace detail {
+template<typename T>
+using is_exotic_char = bool_constant<!std::is_same<T, char>::value>;
+}
+
+FMT_MODULE_EXPORT_BEGIN
+
+using wstring_view = basic_string_view<wchar_t>;
+using wformat_parse_context = basic_format_parse_context<wchar_t>;
+using wformat_context = buffer_context<wchar_t>;
+using wformat_args = basic_format_args<wformat_context>;
+using wmemory_buffer = basic_memory_buffer<wchar_t>;
+
+#if FMT_GCC_VERSION && FMT_GCC_VERSION < 409
+// Workaround broken conversion on older gcc.
+template<typename... Args>
+using wformat_string = wstring_view;
+inline auto runtime(wstring_view s) -> wstring_view
+{
+    return s;
+}
+#else
+template<typename... Args>
+using wformat_string = basic_format_string<wchar_t, type_identity_t<Args>...>;
+inline auto runtime(wstring_view s) -> basic_runtime<wchar_t>
+{
+    return {{s}};
+}
+#endif
+
+template<>
+struct is_char<wchar_t> : std::true_type
+{};
+template<>
+struct is_char<detail::char8_type> : std::true_type
+{};
+template<>
+struct is_char<char16_t> : std::true_type
+{};
+template<>
+struct is_char<char32_t> : std::true_type
+{};
+
+template<typename... Args>
+constexpr format_arg_store<wformat_context, Args...> make_wformat_args(const Args &...args)
+{
+    return {args...};
+}
+
+inline namespace literals {
+#if FMT_USE_USER_DEFINED_LITERALS && !FMT_USE_NONTYPE_TEMPLATE_ARGS
+constexpr detail::udl_arg<wchar_t> operator"" _a(const wchar_t * s, size_t)
+{
+    return {s};
+}
+#endif
+} // namespace literals
+
+template<typename It, typename Sentinel>
+auto join(It begin, Sentinel end, wstring_view sep) -> join_view<It, Sentinel, wchar_t>
+{
+    return {begin, end, sep};
+}
+
+template<typename Range>
+auto join(Range &&range, wstring_view sep) -> join_view<detail::iterator_t<Range>, detail::sentinel_t<Range>, wchar_t>
+{
+    return join(std::begin(range), std::end(range), sep);
+}
+
+template<typename T>
+auto join(std::initializer_list<T> list, wstring_view sep) -> join_view<const T *, const T *, wchar_t>
+{
+    return join(std::begin(list), std::end(list), sep);
+}
+
+template<typename Char, FMT_ENABLE_IF(!std::is_same<Char, char>::value)>
+auto vformat(basic_string_view<Char> format_str, basic_format_args<buffer_context<type_identity_t<Char>>> args) -> std::basic_string<Char>
+{
+    basic_memory_buffer<Char> buffer;
+    detail::vformat_to(buffer, format_str, args);
+    return to_string(buffer);
+}
+
+template<typename... T>
+auto format(wformat_string<T...> fmt, T &&...args) -> std::wstring
+{
+    return vformat(fmt::wstring_view(fmt), fmt::make_wformat_args(args...));
+}
+
+// Pass char_t as a default template parameter instead of using
+// std::basic_string<char_t<S>> to reduce the symbol size.
+template<typename S, typename... Args, typename Char = char_t<S>,
+    FMT_ENABLE_IF(!std::is_same<Char, char>::value && !std::is_same<Char, wchar_t>::value)>
+auto format(const S &format_str, Args &&...args) -> std::basic_string<Char>
+{
+    return vformat(detail::to_string_view(format_str), fmt::make_format_args<buffer_context<Char>>(args...));
+}
+
+template<typename Locale, typename S, typename Char = char_t<S>,
+    FMT_ENABLE_IF(detail::is_locale<Locale>::value &&detail::is_exotic_char<Char>::value)>
+inline auto vformat(const Locale &loc, const S &format_str, basic_format_args<buffer_context<type_identity_t<Char>>> args)
+    -> std::basic_string<Char>
+{
+    return detail::vformat(loc, detail::to_string_view(format_str), args);
+}
+
+template<typename Locale, typename S, typename... Args, typename Char = char_t<S>,
+    FMT_ENABLE_IF(detail::is_locale<Locale>::value &&detail::is_exotic_char<Char>::value)>
+inline auto format(const Locale &loc, const S &format_str, Args &&...args) -> std::basic_string<Char>
+{
+    return detail::vformat(loc, detail::to_string_view(format_str), fmt::make_format_args<buffer_context<Char>>(args...));
+}
+
+template<typename OutputIt, typename S, typename Char = char_t<S>,
+    FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value &&detail::is_exotic_char<Char>::value)>
+auto vformat_to(OutputIt out, const S &format_str, basic_format_args<buffer_context<type_identity_t<Char>>> args) -> OutputIt
+{
+    auto &&buf = detail::get_buffer<Char>(out);
+    detail::vformat_to(buf, detail::to_string_view(format_str), args);
+    return detail::get_iterator(buf);
+}
+
+template<typename OutputIt, typename S, typename... Args, typename Char = char_t<S>,
+    FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value &&detail::is_exotic_char<Char>::value)>
+inline auto format_to(OutputIt out, const S &fmt, Args &&...args) -> OutputIt
+{
+    return vformat_to(out, detail::to_string_view(fmt), fmt::make_format_args<buffer_context<Char>>(args...));
+}
+
+template<typename Locale, typename S, typename OutputIt, typename... Args, typename Char = char_t<S>,
+    FMT_ENABLE_IF(
+        detail::is_output_iterator<OutputIt, Char>::value &&detail::is_locale<Locale>::value &&detail::is_exotic_char<Char>::value)>
+inline auto vformat_to(OutputIt out, const Locale &loc, const S &format_str, basic_format_args<buffer_context<type_identity_t<Char>>> args)
+    -> OutputIt
+{
+    auto &&buf = detail::get_buffer<Char>(out);
+    vformat_to(buf, detail::to_string_view(format_str), args, detail::locale_ref(loc));
+    return detail::get_iterator(buf);
+}
+
+template<typename OutputIt, typename Locale, typename S, typename... Args, typename Char = char_t<S>,
+    bool enable =
+        detail::is_output_iterator<OutputIt, Char>::value &&detail::is_locale<Locale>::value &&detail::is_exotic_char<Char>::value>
+inline auto format_to(OutputIt out, const Locale &loc, const S &format_str, Args &&...args) ->
+    typename std::enable_if<enable, OutputIt>::type
+{
+    return vformat_to(out, loc, to_string_view(format_str), fmt::make_format_args<buffer_context<Char>>(args...));
+}
+
+template<typename OutputIt, typename Char, typename... Args,
+    FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value &&detail::is_exotic_char<Char>::value)>
+inline auto vformat_to_n(OutputIt out, size_t n, basic_string_view<Char> format_str,
+    basic_format_args<buffer_context<type_identity_t<Char>>> args) -> format_to_n_result<OutputIt>
+{
+    detail::iterator_buffer<OutputIt, Char, detail::fixed_buffer_traits> buf(out, n);
+    detail::vformat_to(buf, format_str, args);
+    return {buf.out(), buf.count()};
+}
+
+template<typename OutputIt, typename S, typename... Args, typename Char = char_t<S>,
+    FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value &&detail::is_exotic_char<Char>::value)>
+inline auto format_to_n(OutputIt out, size_t n, const S &fmt, const Args &...args) -> format_to_n_result<OutputIt>
+{
+    return vformat_to_n(out, n, detail::to_string_view(fmt), fmt::make_format_args<buffer_context<Char>>(args...));
+}
+
+template<typename S, typename... Args, typename Char = char_t<S>, FMT_ENABLE_IF(detail::is_exotic_char<Char>::value)>
+inline auto formatted_size(const S &fmt, Args &&...args) -> size_t
+{
+    detail::counting_buffer<Char> buf;
+    detail::vformat_to(buf, detail::to_string_view(fmt), fmt::make_format_args<buffer_context<Char>>(args...));
+    return buf.count();
+}
+
+inline void vprint(std::FILE *f, wstring_view fmt, wformat_args args)
+{
+    wmemory_buffer buffer;
+    detail::vformat_to(buffer, fmt, args);
+    buffer.push_back(L'\0');
+    if (std::fputws(buffer.data(), f) == -1)
+        FMT_THROW(system_error(errno, FMT_STRING("cannot write to file")));
+}
+
+inline void vprint(wstring_view fmt, wformat_args args)
+{
+    vprint(stdout, fmt, args);
+}
+
+template<typename... T>
+void print(std::FILE *f, wformat_string<T...> fmt, T &&...args)
+{
+    return vprint(f, wstring_view(fmt), fmt::make_wformat_args(args...));
+}
+
+template<typename... T>
+void print(wformat_string<T...> fmt, T &&...args)
+{
+    return vprint(wstring_view(fmt), fmt::make_wformat_args(args...));
+}
+
+/**
+  Converts *value* to ``std::wstring`` using the default format for type *T*.
+ */
+template<typename T>
+inline auto to_wstring(const T &value) -> std::wstring
+{
+    return format(FMT_STRING(L"{}"), value);
+}
+FMT_MODULE_EXPORT_END
+FMT_END_NAMESPACE
+
+#endif // FMT_XCHAR_H_
diff --git a/3rdparty/spdlog/src/include/spdlog/fmt/chrono.h b/3rdparty/spdlog/src/include/spdlog/fmt/chrono.h
new file mode 100644
index 00000000..83fad2ff
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/fmt/chrono.h
@@ -0,0 +1,22 @@
+//
+// Copyright(c) 2016 Gabi Melman.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+//
+
+#pragma once
+//
+// include bundled or external copy of fmtlib's chrono support
+//
+
+#if !defined(SPDLOG_USE_STD_FORMAT)
+#    if !defined(SPDLOG_FMT_EXTERNAL)
+#        ifdef SPDLOG_HEADER_ONLY
+#            ifndef FMT_HEADER_ONLY
+#                define FMT_HEADER_ONLY
+#            endif
+#        endif
+#        include <spdlog/fmt/bundled/chrono.h>
+#    else
+#        include <fmt/chrono.h>
+#    endif
+#endif
diff --git a/3rdparty/spdlog/src/include/spdlog/fmt/compile.h b/3rdparty/spdlog/src/include/spdlog/fmt/compile.h
new file mode 100644
index 00000000..906e9f57
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/fmt/compile.h
@@ -0,0 +1,22 @@
+//
+// Copyright(c) 2016 Gabi Melman.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+//
+
+#pragma once
+//
+// include bundled or external copy of fmtlib's compile-time support
+//
+
+#if !defined(SPDLOG_USE_STD_FORMAT)
+#    if !defined(SPDLOG_FMT_EXTERNAL)
+#        ifdef SPDLOG_HEADER_ONLY
+#            ifndef FMT_HEADER_ONLY
+#                define FMT_HEADER_ONLY
+#            endif
+#        endif
+#        include <spdlog/fmt/bundled/compile.h>
+#    else
+#        include <fmt/compile.h>
+#    endif
+#endif
diff --git a/3rdparty/spdlog/src/include/spdlog/fmt/fmt.h b/3rdparty/spdlog/src/include/spdlog/fmt/fmt.h
new file mode 100644
index 00000000..90fcae0f
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/fmt/fmt.h
@@ -0,0 +1,33 @@
+//
+// Copyright(c) 2016-2018 Gabi Melman.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+//
+
+#pragma once
+
+//
+// Include a bundled header-only copy of fmtlib or an external one.
+// By default spdlog include its own copy.
+//
+
+#if defined(SPDLOG_USE_STD_FORMAT) // SPDLOG_USE_STD_FORMAT is defined - use std::format
+#    include <format>
+#elif !defined(SPDLOG_FMT_EXTERNAL)
+#    if !defined(SPDLOG_COMPILED_LIB) && !defined(FMT_HEADER_ONLY)
+#        define FMT_HEADER_ONLY
+#    endif
+#    ifndef FMT_USE_WINDOWS_H
+#        define FMT_USE_WINDOWS_H 0
+#    endif
+// enable the 'n' flag in for backward compatibility with fmt 6.x
+#    define FMT_DEPRECATED_N_SPECIFIER
+// enable ostream formatting for backward compatibility with fmt 8.x
+#    define FMT_DEPRECATED_OSTREAM
+
+#    include <spdlog/fmt/bundled/core.h>
+#    include <spdlog/fmt/bundled/format.h>
+
+#else // SPDLOG_FMT_EXTERNAL is defined - use external fmtlib
+#    include <fmt/core.h>
+#    include <fmt/format.h>
+#endif
diff --git a/3rdparty/spdlog/src/include/spdlog/fmt/ostr.h b/3rdparty/spdlog/src/include/spdlog/fmt/ostr.h
new file mode 100644
index 00000000..75880341
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/fmt/ostr.h
@@ -0,0 +1,22 @@
+//
+// Copyright(c) 2016 Gabi Melman.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+//
+
+#pragma once
+//
+// include bundled or external copy of fmtlib's ostream support
+//
+
+#if !defined(SPDLOG_USE_STD_FORMAT)
+#    if !defined(SPDLOG_FMT_EXTERNAL)
+#        ifdef SPDLOG_HEADER_ONLY
+#            ifndef FMT_HEADER_ONLY
+#                define FMT_HEADER_ONLY
+#            endif
+#        endif
+#        include <spdlog/fmt/bundled/ostream.h>
+#    else
+#        include <fmt/ostream.h>
+#    endif
+#endif
diff --git a/3rdparty/spdlog/src/include/spdlog/fmt/ranges.h b/3rdparty/spdlog/src/include/spdlog/fmt/ranges.h
new file mode 100644
index 00000000..9103a5f6
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/fmt/ranges.h
@@ -0,0 +1,22 @@
+//
+// Copyright(c) 2016 Gabi Melman.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+//
+
+#pragma once
+//
+// include bundled or external copy of fmtlib's ranges support
+//
+
+#if !defined(SPDLOG_USE_STD_FORMAT)
+#    if !defined(SPDLOG_FMT_EXTERNAL)
+#        ifdef SPDLOG_HEADER_ONLY
+#            ifndef FMT_HEADER_ONLY
+#                define FMT_HEADER_ONLY
+#            endif
+#        endif
+#        include <spdlog/fmt/bundled/ranges.h>
+#    else
+#        include <fmt/ranges.h>
+#    endif
+#endif
diff --git a/3rdparty/spdlog/src/include/spdlog/fmt/std.h b/3rdparty/spdlog/src/include/spdlog/fmt/std.h
new file mode 100644
index 00000000..0490cab0
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/fmt/std.h
@@ -0,0 +1,23 @@
+//
+// Copyright(c) 2016 Gabi Melman.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+//
+
+#pragma once
+//
+// include bundled or external copy of fmtlib's std support (for formatting e.g. std::filesystem::path, std::thread::id, std::monostate,
+// std::variant, ...)
+//
+
+#if !defined(SPDLOG_USE_STD_FORMAT)
+#    if !defined(SPDLOG_FMT_EXTERNAL)
+#        ifdef SPDLOG_HEADER_ONLY
+#            ifndef FMT_HEADER_ONLY
+#                define FMT_HEADER_ONLY
+#            endif
+#        endif
+#        include <spdlog/fmt/bundled/std.h>
+#    else
+#        include <fmt/std.h>
+#    endif
+#endif
diff --git a/3rdparty/spdlog/src/include/spdlog/fmt/xchar.h b/3rdparty/spdlog/src/include/spdlog/fmt/xchar.h
new file mode 100644
index 00000000..9a766e5a
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/fmt/xchar.h
@@ -0,0 +1,22 @@
+//
+// Copyright(c) 2016 Gabi Melman.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+//
+
+#pragma once
+//
+// include bundled or external copy of fmtlib's xchar support
+//
+
+#if !defined(SPDLOG_USE_STD_FORMAT)
+#    if !defined(SPDLOG_FMT_EXTERNAL)
+#        ifdef SPDLOG_HEADER_ONLY
+#            ifndef FMT_HEADER_ONLY
+#                define FMT_HEADER_ONLY
+#            endif
+#        endif
+#        include <spdlog/fmt/bundled/xchar.h>
+#    else
+#        include <fmt/xchar.h>
+#    endif
+#endif
diff --git a/3rdparty/spdlog/src/include/spdlog/formatter.h b/3rdparty/spdlog/src/include/spdlog/formatter.h
new file mode 100644
index 00000000..5086fb21
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/formatter.h
@@ -0,0 +1,18 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#include <spdlog/fmt/fmt.h>
+#include <spdlog/details/log_msg.h>
+
+namespace spdlog {
+
+class formatter
+{
+public:
+    virtual ~formatter() = default;
+    virtual void format(const details::log_msg &msg, memory_buf_t &dest) = 0;
+    virtual std::unique_ptr<formatter> clone() const = 0;
+};
+} // namespace spdlog
diff --git a/3rdparty/spdlog/src/include/spdlog/fwd.h b/3rdparty/spdlog/src/include/spdlog/fwd.h
new file mode 100644
index 00000000..d2588257
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/fwd.h
@@ -0,0 +1,18 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+namespace spdlog {
+class logger;
+class formatter;
+
+namespace sinks {
+class sink;
+}
+
+namespace level {
+enum level_enum : int;
+}
+
+} // namespace spdlog
diff --git a/3rdparty/spdlog/src/include/spdlog/logger-inl.h b/3rdparty/spdlog/src/include/spdlog/logger-inl.h
new file mode 100644
index 00000000..ff82db4c
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/logger-inl.h
@@ -0,0 +1,257 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#ifndef SPDLOG_HEADER_ONLY
+#    include <spdlog/logger.h>
+#endif
+
+#include <spdlog/sinks/sink.h>
+#include <spdlog/details/backtracer.h>
+#include <spdlog/pattern_formatter.h>
+
+#include <cstdio>
+
+namespace spdlog {
+
+// public methods
+SPDLOG_INLINE logger::logger(const logger &other)
+    : name_(other.name_)
+    , sinks_(other.sinks_)
+    , level_(other.level_.load(std::memory_order_relaxed))
+    , flush_level_(other.flush_level_.load(std::memory_order_relaxed))
+    , custom_err_handler_(other.custom_err_handler_)
+    , tracer_(other.tracer_)
+{}
+
+SPDLOG_INLINE logger::logger(logger &&other) SPDLOG_NOEXCEPT : name_(std::move(other.name_)),
+                                                               sinks_(std::move(other.sinks_)),
+                                                               level_(other.level_.load(std::memory_order_relaxed)),
+                                                               flush_level_(other.flush_level_.load(std::memory_order_relaxed)),
+                                                               custom_err_handler_(std::move(other.custom_err_handler_)),
+                                                               tracer_(std::move(other.tracer_))
+
+{}
+
+SPDLOG_INLINE logger &logger::operator=(logger other) SPDLOG_NOEXCEPT
+{
+    this->swap(other);
+    return *this;
+}
+
+SPDLOG_INLINE void logger::swap(spdlog::logger &other) SPDLOG_NOEXCEPT
+{
+    name_.swap(other.name_);
+    sinks_.swap(other.sinks_);
+
+    // swap level_
+    auto other_level = other.level_.load();
+    auto my_level = level_.exchange(other_level);
+    other.level_.store(my_level);
+
+    // swap flush level_
+    other_level = other.flush_level_.load();
+    my_level = flush_level_.exchange(other_level);
+    other.flush_level_.store(my_level);
+
+    custom_err_handler_.swap(other.custom_err_handler_);
+    std::swap(tracer_, other.tracer_);
+}
+
+SPDLOG_INLINE void swap(logger &a, logger &b)
+{
+    a.swap(b);
+}
+
+SPDLOG_INLINE void logger::set_level(level::level_enum log_level)
+{
+    level_.store(log_level);
+}
+
+SPDLOG_INLINE level::level_enum logger::level() const
+{
+    return static_cast<level::level_enum>(level_.load(std::memory_order_relaxed));
+}
+
+SPDLOG_INLINE const std::string &logger::name() const
+{
+    return name_;
+}
+
+// set formatting for the sinks in this logger.
+// each sink will get a separate instance of the formatter object.
+SPDLOG_INLINE void logger::set_formatter(std::unique_ptr<formatter> f)
+{
+    for (auto it = sinks_.begin(); it != sinks_.end(); ++it)
+    {
+        if (std::next(it) == sinks_.end())
+        {
+            // last element - we can be move it.
+            (*it)->set_formatter(std::move(f));
+            break; // to prevent clang-tidy warning
+        }
+        else
+        {
+            (*it)->set_formatter(f->clone());
+        }
+    }
+}
+
+SPDLOG_INLINE void logger::set_pattern(std::string pattern, pattern_time_type time_type)
+{
+    auto new_formatter = details::make_unique<pattern_formatter>(std::move(pattern), time_type);
+    set_formatter(std::move(new_formatter));
+}
+
+// create new backtrace sink and move to it all our child sinks
+SPDLOG_INLINE void logger::enable_backtrace(size_t n_messages)
+{
+    tracer_.enable(n_messages);
+}
+
+// restore orig sinks and level and delete the backtrace sink
+SPDLOG_INLINE void logger::disable_backtrace()
+{
+    tracer_.disable();
+}
+
+SPDLOG_INLINE void logger::dump_backtrace()
+{
+    dump_backtrace_();
+}
+
+// flush functions
+SPDLOG_INLINE void logger::flush()
+{
+    flush_();
+}
+
+SPDLOG_INLINE void logger::flush_on(level::level_enum log_level)
+{
+    flush_level_.store(log_level);
+}
+
+SPDLOG_INLINE level::level_enum logger::flush_level() const
+{
+    return static_cast<level::level_enum>(flush_level_.load(std::memory_order_relaxed));
+}
+
+// sinks
+SPDLOG_INLINE const std::vector<sink_ptr> &logger::sinks() const
+{
+    return sinks_;
+}
+
+SPDLOG_INLINE std::vector<sink_ptr> &logger::sinks()
+{
+    return sinks_;
+}
+
+// error handler
+SPDLOG_INLINE void logger::set_error_handler(err_handler handler)
+{
+    custom_err_handler_ = std::move(handler);
+}
+
+// create new logger with same sinks and configuration.
+SPDLOG_INLINE std::shared_ptr<logger> logger::clone(std::string logger_name)
+{
+    auto cloned = std::make_shared<logger>(*this);
+    cloned->name_ = std::move(logger_name);
+    return cloned;
+}
+
+// protected methods
+SPDLOG_INLINE void logger::log_it_(const spdlog::details::log_msg &log_msg, bool log_enabled, bool traceback_enabled)
+{
+    if (log_enabled)
+    {
+        sink_it_(log_msg);
+    }
+    if (traceback_enabled)
+    {
+        tracer_.push_back(log_msg);
+    }
+}
+
+SPDLOG_INLINE void logger::sink_it_(const details::log_msg &msg)
+{
+    for (auto &sink : sinks_)
+    {
+        if (sink->should_log(msg.level))
+        {
+            SPDLOG_TRY
+            {
+                sink->log(msg);
+            }
+            SPDLOG_LOGGER_CATCH(msg.source)
+        }
+    }
+
+    if (should_flush_(msg))
+    {
+        flush_();
+    }
+}
+
+SPDLOG_INLINE void logger::flush_()
+{
+    for (auto &sink : sinks_)
+    {
+        SPDLOG_TRY
+        {
+            sink->flush();
+        }
+        SPDLOG_LOGGER_CATCH(source_loc())
+    }
+}
+
+SPDLOG_INLINE void logger::dump_backtrace_()
+{
+    using details::log_msg;
+    if (tracer_.enabled() && !tracer_.empty())
+    {
+        sink_it_(log_msg{name(), level::info, "****************** Backtrace Start ******************"});
+        tracer_.foreach_pop([this](const log_msg &msg) { this->sink_it_(msg); });
+        sink_it_(log_msg{name(), level::info, "****************** Backtrace End ********************"});
+    }
+}
+
+SPDLOG_INLINE bool logger::should_flush_(const details::log_msg &msg)
+{
+    auto flush_level = flush_level_.load(std::memory_order_relaxed);
+    return (msg.level >= flush_level) && (msg.level != level::off);
+}
+
+SPDLOG_INLINE void logger::err_handler_(const std::string &msg)
+{
+    if (custom_err_handler_)
+    {
+        custom_err_handler_(msg);
+    }
+    else
+    {
+        using std::chrono::system_clock;
+        static std::mutex mutex;
+        static std::chrono::system_clock::time_point last_report_time;
+        static size_t err_counter = 0;
+        std::lock_guard<std::mutex> lk{mutex};
+        auto now = system_clock::now();
+        err_counter++;
+        if (now - last_report_time < std::chrono::seconds(1))
+        {
+            return;
+        }
+        last_report_time = now;
+        auto tm_time = details::os::localtime(system_clock::to_time_t(now));
+        char date_buf[64];
+        std::strftime(date_buf, sizeof(date_buf), "%Y-%m-%d %H:%M:%S", &tm_time);
+#if defined(USING_R) && defined(R_R_H) // if in R environment
+        REprintf("[*** LOG ERROR #%04zu ***] [%s] [%s] {%s}\n", err_counter, date_buf, name().c_str(), msg.c_str());
+#else
+        std::fprintf(stderr, "[*** LOG ERROR #%04zu ***] [%s] [%s] {%s}\n", err_counter, date_buf, name().c_str(), msg.c_str());
+#endif
+    }
+}
+} // namespace spdlog
diff --git a/3rdparty/spdlog/src/include/spdlog/logger.h b/3rdparty/spdlog/src/include/spdlog/logger.h
new file mode 100644
index 00000000..4393327c
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/logger.h
@@ -0,0 +1,428 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+// Thread safe logger (except for set_error_handler())
+// Has name, log level, vector of std::shared sink pointers and formatter
+// Upon each log write the logger:
+// 1. Checks if its log level is enough to log the message and if yes:
+// 2. Call the underlying sinks to do the job.
+// 3. Each sink use its own private copy of a formatter to format the message
+// and send to its destination.
+//
+// The use of private formatter per sink provides the opportunity to cache some
+// formatted data, and support for different format per sink.
+
+#include <spdlog/common.h>
+#include <spdlog/details/log_msg.h>
+#include <spdlog/details/backtracer.h>
+
+#ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT
+#    ifndef _WIN32
+#        error SPDLOG_WCHAR_TO_UTF8_SUPPORT only supported on windows
+#    endif
+#    include <spdlog/details/os.h>
+#endif
+
+#include <vector>
+
+#ifndef SPDLOG_NO_EXCEPTIONS
+#    define SPDLOG_LOGGER_CATCH(location)                                                                                                  \
+        catch (const std::exception &ex)                                                                                                   \
+        {                                                                                                                                  \
+            if (location.filename)                                                                                                         \
+            {                                                                                                                              \
+                err_handler_(fmt_lib::format(SPDLOG_FMT_STRING("{} [{}({})]"), ex.what(), location.filename, location.line));              \
+            }                                                                                                                              \
+            else                                                                                                                           \
+            {                                                                                                                              \
+                err_handler_(ex.what());                                                                                                   \
+            }                                                                                                                              \
+        }                                                                                                                                  \
+        catch (...)                                                                                                                        \
+        {                                                                                                                                  \
+            err_handler_("Rethrowing unknown exception in logger");                                                                        \
+            throw;                                                                                                                         \
+        }
+#else
+#    define SPDLOG_LOGGER_CATCH(location)
+#endif
+
+namespace spdlog {
+
+class SPDLOG_API logger
+{
+public:
+    // Empty logger
+    explicit logger(std::string name)
+        : name_(std::move(name))
+        , sinks_()
+    {}
+
+    // Logger with range on sinks
+    template<typename It>
+    logger(std::string name, It begin, It end)
+        : name_(std::move(name))
+        , sinks_(begin, end)
+    {}
+
+    // Logger with single sink
+    logger(std::string name, sink_ptr single_sink)
+        : logger(std::move(name), {std::move(single_sink)})
+    {}
+
+    // Logger with sinks init list
+    logger(std::string name, sinks_init_list sinks)
+        : logger(std::move(name), sinks.begin(), sinks.end())
+    {}
+
+    virtual ~logger() = default;
+
+    logger(const logger &other);
+    logger(logger &&other) SPDLOG_NOEXCEPT;
+    logger &operator=(logger other) SPDLOG_NOEXCEPT;
+    void swap(spdlog::logger &other) SPDLOG_NOEXCEPT;
+
+    template<typename... Args>
+    void log(source_loc loc, level::level_enum lvl, format_string_t<Args...> fmt, Args &&...args)
+    {
+        log_(loc, lvl, details::to_string_view(fmt), std::forward<Args>(args)...);
+    }
+
+    template<typename... Args>
+    void log(level::level_enum lvl, format_string_t<Args...> fmt, Args &&...args)
+    {
+        log(source_loc{}, lvl, fmt, std::forward<Args>(args)...);
+    }
+
+    template<typename T>
+    void log(level::level_enum lvl, const T &msg)
+    {
+        log(source_loc{}, lvl, msg);
+    }
+
+    // T cannot be statically converted to format string (including string_view/wstring_view)
+    template<class T, typename std::enable_if<!is_convertible_to_any_format_string<const T &>::value, int>::type = 0>
+    void log(source_loc loc, level::level_enum lvl, const T &msg)
+    {
+        log(loc, lvl, "{}", msg);
+    }
+
+    void log(log_clock::time_point log_time, source_loc loc, level::level_enum lvl, string_view_t msg)
+    {
+        bool log_enabled = should_log(lvl);
+        bool traceback_enabled = tracer_.enabled();
+        if (!log_enabled && !traceback_enabled)
+        {
+            return;
+        }
+
+        details::log_msg log_msg(log_time, loc, name_, lvl, msg);
+        log_it_(log_msg, log_enabled, traceback_enabled);
+    }
+
+    void log(source_loc loc, level::level_enum lvl, string_view_t msg)
+    {
+        bool log_enabled = should_log(lvl);
+        bool traceback_enabled = tracer_.enabled();
+        if (!log_enabled && !traceback_enabled)
+        {
+            return;
+        }
+
+        details::log_msg log_msg(loc, name_, lvl, msg);
+        log_it_(log_msg, log_enabled, traceback_enabled);
+    }
+
+    void log(level::level_enum lvl, string_view_t msg)
+    {
+        log(source_loc{}, lvl, msg);
+    }
+
+    template<typename... Args>
+    void trace(format_string_t<Args...> fmt, Args &&...args)
+    {
+        log(level::trace, fmt, std::forward<Args>(args)...);
+    }
+
+    template<typename... Args>
+    void debug(format_string_t<Args...> fmt, Args &&...args)
+    {
+        log(level::debug, fmt, std::forward<Args>(args)...);
+    }
+
+    template<typename... Args>
+    void info(format_string_t<Args...> fmt, Args &&...args)
+    {
+        log(level::info, fmt, std::forward<Args>(args)...);
+    }
+
+    template<typename... Args>
+    void warn(format_string_t<Args...> fmt, Args &&...args)
+    {
+        log(level::warn, fmt, std::forward<Args>(args)...);
+    }
+
+    template<typename... Args>
+    void error(format_string_t<Args...> fmt, Args &&...args)
+    {
+        log(level::err, fmt, std::forward<Args>(args)...);
+    }
+
+    template<typename... Args>
+    void critical(format_string_t<Args...> fmt, Args &&...args)
+    {
+        log(level::critical, fmt, std::forward<Args>(args)...);
+    }
+
+#ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT
+    template<typename... Args>
+    void log(source_loc loc, level::level_enum lvl, wformat_string_t<Args...> fmt, Args &&...args)
+    {
+        log_(loc, lvl, details::to_string_view(fmt), std::forward<Args>(args)...);
+    }
+
+    template<typename... Args>
+    void log(level::level_enum lvl, wformat_string_t<Args...> fmt, Args &&...args)
+    {
+        log(source_loc{}, lvl, fmt, std::forward<Args>(args)...);
+    }
+
+    void log(log_clock::time_point log_time, source_loc loc, level::level_enum lvl, wstring_view_t msg)
+    {
+        bool log_enabled = should_log(lvl);
+        bool traceback_enabled = tracer_.enabled();
+        if (!log_enabled && !traceback_enabled)
+        {
+            return;
+        }
+
+        memory_buf_t buf;
+        details::os::wstr_to_utf8buf(wstring_view_t(msg.data(), msg.size()), buf);
+        details::log_msg log_msg(log_time, loc, name_, lvl, string_view_t(buf.data(), buf.size()));
+        log_it_(log_msg, log_enabled, traceback_enabled);
+    }
+
+    void log(source_loc loc, level::level_enum lvl, wstring_view_t msg)
+    {
+        bool log_enabled = should_log(lvl);
+        bool traceback_enabled = tracer_.enabled();
+        if (!log_enabled && !traceback_enabled)
+        {
+            return;
+        }
+
+        memory_buf_t buf;
+        details::os::wstr_to_utf8buf(wstring_view_t(msg.data(), msg.size()), buf);
+        details::log_msg log_msg(loc, name_, lvl, string_view_t(buf.data(), buf.size()));
+        log_it_(log_msg, log_enabled, traceback_enabled);
+    }
+
+    void log(level::level_enum lvl, wstring_view_t msg)
+    {
+        log(source_loc{}, lvl, msg);
+    }
+
+    template<typename... Args>
+    void trace(wformat_string_t<Args...> fmt, Args &&...args)
+    {
+        log(level::trace, fmt, std::forward<Args>(args)...);
+    }
+
+    template<typename... Args>
+    void debug(wformat_string_t<Args...> fmt, Args &&...args)
+    {
+        log(level::debug, fmt, std::forward<Args>(args)...);
+    }
+
+    template<typename... Args>
+    void info(wformat_string_t<Args...> fmt, Args &&...args)
+    {
+        log(level::info, fmt, std::forward<Args>(args)...);
+    }
+
+    template<typename... Args>
+    void warn(wformat_string_t<Args...> fmt, Args &&...args)
+    {
+        log(level::warn, fmt, std::forward<Args>(args)...);
+    }
+
+    template<typename... Args>
+    void error(wformat_string_t<Args...> fmt, Args &&...args)
+    {
+        log(level::err, fmt, std::forward<Args>(args)...);
+    }
+
+    template<typename... Args>
+    void critical(wformat_string_t<Args...> fmt, Args &&...args)
+    {
+        log(level::critical, fmt, std::forward<Args>(args)...);
+    }
+#endif
+
+    template<typename T>
+    void trace(const T &msg)
+    {
+        log(level::trace, msg);
+    }
+
+    template<typename T>
+    void debug(const T &msg)
+    {
+        log(level::debug, msg);
+    }
+
+    template<typename T>
+    void info(const T &msg)
+    {
+        log(level::info, msg);
+    }
+
+    template<typename T>
+    void warn(const T &msg)
+    {
+        log(level::warn, msg);
+    }
+
+    template<typename T>
+    void error(const T &msg)
+    {
+        log(level::err, msg);
+    }
+
+    template<typename T>
+    void critical(const T &msg)
+    {
+        log(level::critical, msg);
+    }
+
+    // return true logging is enabled for the given level.
+    bool should_log(level::level_enum msg_level) const
+    {
+        return msg_level >= level_.load(std::memory_order_relaxed);
+    }
+
+    // return true if backtrace logging is enabled.
+    bool should_backtrace() const
+    {
+        return tracer_.enabled();
+    }
+
+    void set_level(level::level_enum log_level);
+
+    level::level_enum level() const;
+
+    const std::string &name() const;
+
+    // set formatting for the sinks in this logger.
+    // each sink will get a separate instance of the formatter object.
+    void set_formatter(std::unique_ptr<formatter> f);
+
+    // set formatting for the sinks in this logger.
+    // equivalent to
+    //     set_formatter(make_unique<pattern_formatter>(pattern, time_type))
+    // Note: each sink will get a new instance of a formatter object, replacing the old one.
+    void set_pattern(std::string pattern, pattern_time_type time_type = pattern_time_type::local);
+
+    // backtrace support.
+    // efficiently store all debug/trace messages in a circular buffer until needed for debugging.
+    void enable_backtrace(size_t n_messages);
+    void disable_backtrace();
+    void dump_backtrace();
+
+    // flush functions
+    void flush();
+    void flush_on(level::level_enum log_level);
+    level::level_enum flush_level() const;
+
+    // sinks
+    const std::vector<sink_ptr> &sinks() const;
+
+    std::vector<sink_ptr> &sinks();
+
+    // error handler
+    void set_error_handler(err_handler);
+
+    // create new logger with same sinks and configuration.
+    virtual std::shared_ptr<logger> clone(std::string logger_name);
+
+protected:
+    std::string name_;
+    std::vector<sink_ptr> sinks_;
+    spdlog::level_t level_{level::info};
+    spdlog::level_t flush_level_{level::off};
+    err_handler custom_err_handler_{nullptr};
+    details::backtracer tracer_;
+
+    // common implementation for after templated public api has been resolved
+    template<typename... Args>
+    void log_(source_loc loc, level::level_enum lvl, string_view_t fmt, Args &&...args)
+    {
+        bool log_enabled = should_log(lvl);
+        bool traceback_enabled = tracer_.enabled();
+        if (!log_enabled && !traceback_enabled)
+        {
+            return;
+        }
+        SPDLOG_TRY
+        {
+            memory_buf_t buf;
+#ifdef SPDLOG_USE_STD_FORMAT
+            fmt_lib::vformat_to(std::back_inserter(buf), fmt, fmt_lib::make_format_args(std::forward<Args>(args)...));
+#else
+            fmt::vformat_to(fmt::appender(buf), fmt, fmt::make_format_args(std::forward<Args>(args)...));
+#endif
+
+            details::log_msg log_msg(loc, name_, lvl, string_view_t(buf.data(), buf.size()));
+            log_it_(log_msg, log_enabled, traceback_enabled);
+        }
+        SPDLOG_LOGGER_CATCH(loc)
+    }
+
+#ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT
+    template<typename... Args>
+    void log_(source_loc loc, level::level_enum lvl, wstring_view_t fmt, Args &&...args)
+    {
+        bool log_enabled = should_log(lvl);
+        bool traceback_enabled = tracer_.enabled();
+        if (!log_enabled && !traceback_enabled)
+        {
+            return;
+        }
+        SPDLOG_TRY
+        {
+            // format to wmemory_buffer and convert to utf8
+            wmemory_buf_t wbuf;
+            fmt_lib::vformat_to(
+                std::back_inserter(wbuf), fmt, fmt_lib::make_format_args<fmt_lib::wformat_context>(std::forward<Args>(args)...));
+
+            memory_buf_t buf;
+            details::os::wstr_to_utf8buf(wstring_view_t(wbuf.data(), wbuf.size()), buf);
+            details::log_msg log_msg(loc, name_, lvl, string_view_t(buf.data(), buf.size()));
+            log_it_(log_msg, log_enabled, traceback_enabled);
+        }
+        SPDLOG_LOGGER_CATCH(loc)
+    }
+#endif // SPDLOG_WCHAR_TO_UTF8_SUPPORT
+
+    // log the given message (if the given log level is high enough),
+    // and save backtrace (if backtrace is enabled).
+    void log_it_(const details::log_msg &log_msg, bool log_enabled, bool traceback_enabled);
+    virtual void sink_it_(const details::log_msg &msg);
+    virtual void flush_();
+    void dump_backtrace_();
+    bool should_flush_(const details::log_msg &msg);
+
+    // handle errors during logging.
+    // default handler prints the error to stderr at max rate of 1 message/sec.
+    void err_handler_(const std::string &msg);
+};
+
+void swap(logger &a, logger &b);
+
+} // namespace spdlog
+
+#ifdef SPDLOG_HEADER_ONLY
+#    include "logger-inl.h"
+#endif
diff --git a/3rdparty/spdlog/src/include/spdlog/pattern_formatter-inl.h b/3rdparty/spdlog/src/include/spdlog/pattern_formatter-inl.h
new file mode 100644
index 00000000..01afbe6f
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/pattern_formatter-inl.h
@@ -0,0 +1,1436 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#ifndef SPDLOG_HEADER_ONLY
+#    include <spdlog/pattern_formatter.h>
+#endif
+
+#include <spdlog/details/fmt_helper.h>
+#include <spdlog/details/log_msg.h>
+#include <spdlog/details/os.h>
+#include <spdlog/fmt/fmt.h>
+#include <spdlog/formatter.h>
+
+#include <algorithm>
+#include <array>
+#include <chrono>
+#include <ctime>
+#include <cctype>
+#include <cstring>
+#include <iterator>
+#include <memory>
+#include <mutex>
+#include <string>
+#include <thread>
+#include <utility>
+#include <vector>
+
+namespace spdlog {
+namespace details {
+
+///////////////////////////////////////////////////////////////////////
+// name & level pattern appender
+///////////////////////////////////////////////////////////////////////
+
+class scoped_padder
+{
+public:
+    scoped_padder(size_t wrapped_size, const padding_info &padinfo, memory_buf_t &dest)
+        : padinfo_(padinfo)
+        , dest_(dest)
+    {
+        remaining_pad_ = static_cast<long>(padinfo.width_) - static_cast<long>(wrapped_size);
+        if (remaining_pad_ <= 0)
+        {
+            return;
+        }
+
+        if (padinfo_.side_ == padding_info::pad_side::left)
+        {
+            pad_it(remaining_pad_);
+            remaining_pad_ = 0;
+        }
+        else if (padinfo_.side_ == padding_info::pad_side::center)
+        {
+            auto half_pad = remaining_pad_ / 2;
+            auto reminder = remaining_pad_ & 1;
+            pad_it(half_pad);
+            remaining_pad_ = half_pad + reminder; // for the right side
+        }
+    }
+
+    template<typename T>
+    static unsigned int count_digits(T n)
+    {
+        return fmt_helper::count_digits(n);
+    }
+
+    ~scoped_padder()
+    {
+        if (remaining_pad_ >= 0)
+        {
+            pad_it(remaining_pad_);
+        }
+        else if (padinfo_.truncate_)
+        {
+            long new_size = static_cast<long>(dest_.size()) + remaining_pad_;
+            dest_.resize(static_cast<size_t>(new_size));
+        }
+    }
+
+private:
+    void pad_it(long count)
+    {
+        fmt_helper::append_string_view(string_view_t(spaces_.data(), static_cast<size_t>(count)), dest_);
+    }
+
+    const padding_info &padinfo_;
+    memory_buf_t &dest_;
+    long remaining_pad_;
+    string_view_t spaces_{"                                                                ", 64};
+};
+
+struct null_scoped_padder
+{
+    null_scoped_padder(size_t /*wrapped_size*/, const padding_info & /*padinfo*/, memory_buf_t & /*dest*/) {}
+
+    template<typename T>
+    static unsigned int count_digits(T /* number */)
+    {
+        return 0;
+    }
+};
+
+template<typename ScopedPadder>
+class name_formatter final : public flag_formatter
+{
+public:
+    explicit name_formatter(padding_info padinfo)
+        : flag_formatter(padinfo)
+    {}
+
+    void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override
+    {
+        ScopedPadder p(msg.logger_name.size(), padinfo_, dest);
+        fmt_helper::append_string_view(msg.logger_name, dest);
+    }
+};
+
+// log level appender
+template<typename ScopedPadder>
+class level_formatter final : public flag_formatter
+{
+public:
+    explicit level_formatter(padding_info padinfo)
+        : flag_formatter(padinfo)
+    {}
+
+    void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override
+    {
+        const string_view_t &level_name = level::to_string_view(msg.level);
+        ScopedPadder p(level_name.size(), padinfo_, dest);
+        fmt_helper::append_string_view(level_name, dest);
+    }
+};
+
+// short log level appender
+template<typename ScopedPadder>
+class short_level_formatter final : public flag_formatter
+{
+public:
+    explicit short_level_formatter(padding_info padinfo)
+        : flag_formatter(padinfo)
+    {}
+
+    void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override
+    {
+        string_view_t level_name{level::to_short_c_str(msg.level)};
+        ScopedPadder p(level_name.size(), padinfo_, dest);
+        fmt_helper::append_string_view(level_name, dest);
+    }
+};
+
+///////////////////////////////////////////////////////////////////////
+// Date time pattern appenders
+///////////////////////////////////////////////////////////////////////
+
+static const char *ampm(const tm &t)
+{
+    return t.tm_hour >= 12 ? "PM" : "AM";
+}
+
+static int to12h(const tm &t)
+{
+    return t.tm_hour > 12 ? t.tm_hour - 12 : t.tm_hour;
+}
+
+// Abbreviated weekday name
+static std::array<const char *, 7> days{{"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"}};
+
+template<typename ScopedPadder>
+class a_formatter final : public flag_formatter
+{
+public:
+    explicit a_formatter(padding_info padinfo)
+        : flag_formatter(padinfo)
+    {}
+
+    void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override
+    {
+        string_view_t field_value{days[static_cast<size_t>(tm_time.tm_wday)]};
+        ScopedPadder p(field_value.size(), padinfo_, dest);
+        fmt_helper::append_string_view(field_value, dest);
+    }
+};
+
+// Full weekday name
+static std::array<const char *, 7> full_days{{"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"}};
+
+template<typename ScopedPadder>
+class A_formatter : public flag_formatter
+{
+public:
+    explicit A_formatter(padding_info padinfo)
+        : flag_formatter(padinfo)
+    {}
+
+    void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override
+    {
+        string_view_t field_value{full_days[static_cast<size_t>(tm_time.tm_wday)]};
+        ScopedPadder p(field_value.size(), padinfo_, dest);
+        fmt_helper::append_string_view(field_value, dest);
+    }
+};
+
+// Abbreviated month
+static const std::array<const char *, 12> months{{"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sept", "Oct", "Nov", "Dec"}};
+
+template<typename ScopedPadder>
+class b_formatter final : public flag_formatter
+{
+public:
+    explicit b_formatter(padding_info padinfo)
+        : flag_formatter(padinfo)
+    {}
+
+    void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override
+    {
+        string_view_t field_value{months[static_cast<size_t>(tm_time.tm_mon)]};
+        ScopedPadder p(field_value.size(), padinfo_, dest);
+        fmt_helper::append_string_view(field_value, dest);
+    }
+};
+
+// Full month name
+static const std::array<const char *, 12> full_months{
+    {"January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"}};
+
+template<typename ScopedPadder>
+class B_formatter final : public flag_formatter
+{
+public:
+    explicit B_formatter(padding_info padinfo)
+        : flag_formatter(padinfo)
+    {}
+
+    void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override
+    {
+        string_view_t field_value{full_months[static_cast<size_t>(tm_time.tm_mon)]};
+        ScopedPadder p(field_value.size(), padinfo_, dest);
+        fmt_helper::append_string_view(field_value, dest);
+    }
+};
+
+// Date and time representation (Thu Aug 23 15:35:46 2014)
+template<typename ScopedPadder>
+class c_formatter final : public flag_formatter
+{
+public:
+    explicit c_formatter(padding_info padinfo)
+        : flag_formatter(padinfo)
+    {}
+
+    void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override
+    {
+        const size_t field_size = 24;
+        ScopedPadder p(field_size, padinfo_, dest);
+
+        fmt_helper::append_string_view(days[static_cast<size_t>(tm_time.tm_wday)], dest);
+        dest.push_back(' ');
+        fmt_helper::append_string_view(months[static_cast<size_t>(tm_time.tm_mon)], dest);
+        dest.push_back(' ');
+        fmt_helper::append_int(tm_time.tm_mday, dest);
+        dest.push_back(' ');
+        // time
+
+        fmt_helper::pad2(tm_time.tm_hour, dest);
+        dest.push_back(':');
+        fmt_helper::pad2(tm_time.tm_min, dest);
+        dest.push_back(':');
+        fmt_helper::pad2(tm_time.tm_sec, dest);
+        dest.push_back(' ');
+        fmt_helper::append_int(tm_time.tm_year + 1900, dest);
+    }
+};
+
+// year - 2 digit
+template<typename ScopedPadder>
+class C_formatter final : public flag_formatter
+{
+public:
+    explicit C_formatter(padding_info padinfo)
+        : flag_formatter(padinfo)
+    {}
+
+    void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override
+    {
+        const size_t field_size = 2;
+        ScopedPadder p(field_size, padinfo_, dest);
+        fmt_helper::pad2(tm_time.tm_year % 100, dest);
+    }
+};
+
+// Short MM/DD/YY date, equivalent to %m/%d/%y 08/23/01
+template<typename ScopedPadder>
+class D_formatter final : public flag_formatter
+{
+public:
+    explicit D_formatter(padding_info padinfo)
+        : flag_formatter(padinfo)
+    {}
+
+    void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override
+    {
+        const size_t field_size = 10;
+        ScopedPadder p(field_size, padinfo_, dest);
+
+        fmt_helper::pad2(tm_time.tm_mon + 1, dest);
+        dest.push_back('/');
+        fmt_helper::pad2(tm_time.tm_mday, dest);
+        dest.push_back('/');
+        fmt_helper::pad2(tm_time.tm_year % 100, dest);
+    }
+};
+
+// year - 4 digit
+template<typename ScopedPadder>
+class Y_formatter final : public flag_formatter
+{
+public:
+    explicit Y_formatter(padding_info padinfo)
+        : flag_formatter(padinfo)
+    {}
+
+    void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override
+    {
+        const size_t field_size = 4;
+        ScopedPadder p(field_size, padinfo_, dest);
+        fmt_helper::append_int(tm_time.tm_year + 1900, dest);
+    }
+};
+
+// month 1-12
+template<typename ScopedPadder>
+class m_formatter final : public flag_formatter
+{
+public:
+    explicit m_formatter(padding_info padinfo)
+        : flag_formatter(padinfo)
+    {}
+
+    void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override
+    {
+        const size_t field_size = 2;
+        ScopedPadder p(field_size, padinfo_, dest);
+        fmt_helper::pad2(tm_time.tm_mon + 1, dest);
+    }
+};
+
+// day of month 1-31
+template<typename ScopedPadder>
+class d_formatter final : public flag_formatter
+{
+public:
+    explicit d_formatter(padding_info padinfo)
+        : flag_formatter(padinfo)
+    {}
+
+    void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override
+    {
+        const size_t field_size = 2;
+        ScopedPadder p(field_size, padinfo_, dest);
+        fmt_helper::pad2(tm_time.tm_mday, dest);
+    }
+};
+
+// hours in 24 format 0-23
+template<typename ScopedPadder>
+class H_formatter final : public flag_formatter
+{
+public:
+    explicit H_formatter(padding_info padinfo)
+        : flag_formatter(padinfo)
+    {}
+
+    void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override
+    {
+        const size_t field_size = 2;
+        ScopedPadder p(field_size, padinfo_, dest);
+        fmt_helper::pad2(tm_time.tm_hour, dest);
+    }
+};
+
+// hours in 12 format 1-12
+template<typename ScopedPadder>
+class I_formatter final : public flag_formatter
+{
+public:
+    explicit I_formatter(padding_info padinfo)
+        : flag_formatter(padinfo)
+    {}
+
+    void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override
+    {
+        const size_t field_size = 2;
+        ScopedPadder p(field_size, padinfo_, dest);
+        fmt_helper::pad2(to12h(tm_time), dest);
+    }
+};
+
+// minutes 0-59
+template<typename ScopedPadder>
+class M_formatter final : public flag_formatter
+{
+public:
+    explicit M_formatter(padding_info padinfo)
+        : flag_formatter(padinfo)
+    {}
+
+    void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override
+    {
+        const size_t field_size = 2;
+        ScopedPadder p(field_size, padinfo_, dest);
+        fmt_helper::pad2(tm_time.tm_min, dest);
+    }
+};
+
+// seconds 0-59
+template<typename ScopedPadder>
+class S_formatter final : public flag_formatter
+{
+public:
+    explicit S_formatter(padding_info padinfo)
+        : flag_formatter(padinfo)
+    {}
+
+    void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override
+    {
+        const size_t field_size = 2;
+        ScopedPadder p(field_size, padinfo_, dest);
+        fmt_helper::pad2(tm_time.tm_sec, dest);
+    }
+};
+
+// milliseconds
+template<typename ScopedPadder>
+class e_formatter final : public flag_formatter
+{
+public:
+    explicit e_formatter(padding_info padinfo)
+        : flag_formatter(padinfo)
+    {}
+
+    void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override
+    {
+        auto millis = fmt_helper::time_fraction<std::chrono::milliseconds>(msg.time);
+        const size_t field_size = 3;
+        ScopedPadder p(field_size, padinfo_, dest);
+        fmt_helper::pad3(static_cast<uint32_t>(millis.count()), dest);
+    }
+};
+
+// microseconds
+template<typename ScopedPadder>
+class f_formatter final : public flag_formatter
+{
+public:
+    explicit f_formatter(padding_info padinfo)
+        : flag_formatter(padinfo)
+    {}
+
+    void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override
+    {
+        auto micros = fmt_helper::time_fraction<std::chrono::microseconds>(msg.time);
+
+        const size_t field_size = 6;
+        ScopedPadder p(field_size, padinfo_, dest);
+        fmt_helper::pad6(static_cast<size_t>(micros.count()), dest);
+    }
+};
+
+// nanoseconds
+template<typename ScopedPadder>
+class F_formatter final : public flag_formatter
+{
+public:
+    explicit F_formatter(padding_info padinfo)
+        : flag_formatter(padinfo)
+    {}
+
+    void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override
+    {
+        auto ns = fmt_helper::time_fraction<std::chrono::nanoseconds>(msg.time);
+        const size_t field_size = 9;
+        ScopedPadder p(field_size, padinfo_, dest);
+        fmt_helper::pad9(static_cast<size_t>(ns.count()), dest);
+    }
+};
+
+// seconds since epoch
+template<typename ScopedPadder>
+class E_formatter final : public flag_formatter
+{
+public:
+    explicit E_formatter(padding_info padinfo)
+        : flag_formatter(padinfo)
+    {}
+
+    void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override
+    {
+        const size_t field_size = 10;
+        ScopedPadder p(field_size, padinfo_, dest);
+        auto duration = msg.time.time_since_epoch();
+        auto seconds = std::chrono::duration_cast<std::chrono::seconds>(duration).count();
+        fmt_helper::append_int(seconds, dest);
+    }
+};
+
+// AM/PM
+template<typename ScopedPadder>
+class p_formatter final : public flag_formatter
+{
+public:
+    explicit p_formatter(padding_info padinfo)
+        : flag_formatter(padinfo)
+    {}
+
+    void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override
+    {
+        const size_t field_size = 2;
+        ScopedPadder p(field_size, padinfo_, dest);
+        fmt_helper::append_string_view(ampm(tm_time), dest);
+    }
+};
+
+// 12 hour clock 02:55:02 pm
+template<typename ScopedPadder>
+class r_formatter final : public flag_formatter
+{
+public:
+    explicit r_formatter(padding_info padinfo)
+        : flag_formatter(padinfo)
+    {}
+
+    void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override
+    {
+        const size_t field_size = 11;
+        ScopedPadder p(field_size, padinfo_, dest);
+
+        fmt_helper::pad2(to12h(tm_time), dest);
+        dest.push_back(':');
+        fmt_helper::pad2(tm_time.tm_min, dest);
+        dest.push_back(':');
+        fmt_helper::pad2(tm_time.tm_sec, dest);
+        dest.push_back(' ');
+        fmt_helper::append_string_view(ampm(tm_time), dest);
+    }
+};
+
+// 24-hour HH:MM time, equivalent to %H:%M
+template<typename ScopedPadder>
+class R_formatter final : public flag_formatter
+{
+public:
+    explicit R_formatter(padding_info padinfo)
+        : flag_formatter(padinfo)
+    {}
+
+    void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override
+    {
+        const size_t field_size = 5;
+        ScopedPadder p(field_size, padinfo_, dest);
+
+        fmt_helper::pad2(tm_time.tm_hour, dest);
+        dest.push_back(':');
+        fmt_helper::pad2(tm_time.tm_min, dest);
+    }
+};
+
+// ISO 8601 time format (HH:MM:SS), equivalent to %H:%M:%S
+template<typename ScopedPadder>
+class T_formatter final : public flag_formatter
+{
+public:
+    explicit T_formatter(padding_info padinfo)
+        : flag_formatter(padinfo)
+    {}
+
+    void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override
+    {
+        const size_t field_size = 8;
+        ScopedPadder p(field_size, padinfo_, dest);
+
+        fmt_helper::pad2(tm_time.tm_hour, dest);
+        dest.push_back(':');
+        fmt_helper::pad2(tm_time.tm_min, dest);
+        dest.push_back(':');
+        fmt_helper::pad2(tm_time.tm_sec, dest);
+    }
+};
+
+// ISO 8601 offset from UTC in timezone (+-HH:MM)
+template<typename ScopedPadder>
+class z_formatter final : public flag_formatter
+{
+public:
+    explicit z_formatter(padding_info padinfo)
+        : flag_formatter(padinfo)
+    {}
+
+    z_formatter() = default;
+    z_formatter(const z_formatter &) = delete;
+    z_formatter &operator=(const z_formatter &) = delete;
+
+    void format(const details::log_msg &msg, const std::tm &tm_time, memory_buf_t &dest) override
+    {
+        const size_t field_size = 6;
+        ScopedPadder p(field_size, padinfo_, dest);
+
+        auto total_minutes = get_cached_offset(msg, tm_time);
+        bool is_negative = total_minutes < 0;
+        if (is_negative)
+        {
+            total_minutes = -total_minutes;
+            dest.push_back('-');
+        }
+        else
+        {
+            dest.push_back('+');
+        }
+
+        fmt_helper::pad2(total_minutes / 60, dest); // hours
+        dest.push_back(':');
+        fmt_helper::pad2(total_minutes % 60, dest); // minutes
+    }
+
+private:
+    log_clock::time_point last_update_{std::chrono::seconds(0)};
+    int offset_minutes_{0};
+
+    int get_cached_offset(const log_msg &msg, const std::tm &tm_time)
+    {
+        // refresh every 10 seconds
+        if (msg.time - last_update_ >= std::chrono::seconds(10))
+        {
+            offset_minutes_ = os::utc_minutes_offset(tm_time);
+            last_update_ = msg.time;
+        }
+        return offset_minutes_;
+    }
+};
+
+// Thread id
+template<typename ScopedPadder>
+class t_formatter final : public flag_formatter
+{
+public:
+    explicit t_formatter(padding_info padinfo)
+        : flag_formatter(padinfo)
+    {}
+
+    void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override
+    {
+        const auto field_size = ScopedPadder::count_digits(msg.thread_id);
+        ScopedPadder p(field_size, padinfo_, dest);
+        fmt_helper::append_int(msg.thread_id, dest);
+    }
+};
+
+// Current pid
+template<typename ScopedPadder>
+class pid_formatter final : public flag_formatter
+{
+public:
+    explicit pid_formatter(padding_info padinfo)
+        : flag_formatter(padinfo)
+    {}
+
+    void format(const details::log_msg &, const std::tm &, memory_buf_t &dest) override
+    {
+        const auto pid = static_cast<uint32_t>(details::os::pid());
+        auto field_size = ScopedPadder::count_digits(pid);
+        ScopedPadder p(field_size, padinfo_, dest);
+        fmt_helper::append_int(pid, dest);
+    }
+};
+
+template<typename ScopedPadder>
+class v_formatter final : public flag_formatter
+{
+public:
+    explicit v_formatter(padding_info padinfo)
+        : flag_formatter(padinfo)
+    {}
+
+    void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override
+    {
+        ScopedPadder p(msg.payload.size(), padinfo_, dest);
+        fmt_helper::append_string_view(msg.payload, dest);
+    }
+};
+
+class ch_formatter final : public flag_formatter
+{
+public:
+    explicit ch_formatter(char ch)
+        : ch_(ch)
+    {}
+
+    void format(const details::log_msg &, const std::tm &, memory_buf_t &dest) override
+    {
+        dest.push_back(ch_);
+    }
+
+private:
+    char ch_;
+};
+
+// aggregate user chars to display as is
+class aggregate_formatter final : public flag_formatter
+{
+public:
+    aggregate_formatter() = default;
+
+    void add_ch(char ch)
+    {
+        str_ += ch;
+    }
+    void format(const details::log_msg &, const std::tm &, memory_buf_t &dest) override
+    {
+        fmt_helper::append_string_view(str_, dest);
+    }
+
+private:
+    std::string str_;
+};
+
+// mark the color range. expect it to be in the form of "%^colored text%$"
+class color_start_formatter final : public flag_formatter
+{
+public:
+    explicit color_start_formatter(padding_info padinfo)
+        : flag_formatter(padinfo)
+    {}
+
+    void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override
+    {
+        msg.color_range_start = dest.size();
+    }
+};
+
+class color_stop_formatter final : public flag_formatter
+{
+public:
+    explicit color_stop_formatter(padding_info padinfo)
+        : flag_formatter(padinfo)
+    {}
+
+    void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override
+    {
+        msg.color_range_end = dest.size();
+    }
+};
+
+// print source location
+template<typename ScopedPadder>
+class source_location_formatter final : public flag_formatter
+{
+public:
+    explicit source_location_formatter(padding_info padinfo)
+        : flag_formatter(padinfo)
+    {}
+
+    void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override
+    {
+        if (msg.source.empty())
+        {
+            ScopedPadder p(0, padinfo_, dest);
+            return;
+        }
+
+        size_t text_size;
+        if (padinfo_.enabled())
+        {
+            // calc text size for padding based on "filename:line"
+            text_size = std::char_traits<char>::length(msg.source.filename) + ScopedPadder::count_digits(msg.source.line) + 1;
+        }
+        else
+        {
+            text_size = 0;
+        }
+
+        ScopedPadder p(text_size, padinfo_, dest);
+        fmt_helper::append_string_view(msg.source.filename, dest);
+        dest.push_back(':');
+        fmt_helper::append_int(msg.source.line, dest);
+    }
+};
+
+// print source filename
+template<typename ScopedPadder>
+class source_filename_formatter final : public flag_formatter
+{
+public:
+    explicit source_filename_formatter(padding_info padinfo)
+        : flag_formatter(padinfo)
+    {}
+
+    void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override
+    {
+        if (msg.source.empty())
+        {
+            ScopedPadder p(0, padinfo_, dest);
+            return;
+        }
+        size_t text_size = padinfo_.enabled() ? std::char_traits<char>::length(msg.source.filename) : 0;
+        ScopedPadder p(text_size, padinfo_, dest);
+        fmt_helper::append_string_view(msg.source.filename, dest);
+    }
+};
+
+template<typename ScopedPadder>
+class short_filename_formatter final : public flag_formatter
+{
+public:
+    explicit short_filename_formatter(padding_info padinfo)
+        : flag_formatter(padinfo)
+    {}
+
+#ifdef _MSC_VER
+#    pragma warning(push)
+#    pragma warning(disable : 4127) // consider using 'if constexpr' instead
+#endif                              // _MSC_VER
+    static const char *basename(const char *filename)
+    {
+        // if the size is 2 (1 character + null terminator) we can use the more efficient strrchr
+        // the branch will be elided by optimizations
+        if (sizeof(os::folder_seps) == 2)
+        {
+            const char *rv = std::strrchr(filename, os::folder_seps[0]);
+            return rv != nullptr ? rv + 1 : filename;
+        }
+        else
+        {
+            const std::reverse_iterator<const char *> begin(filename + std::strlen(filename));
+            const std::reverse_iterator<const char *> end(filename);
+
+            const auto it = std::find_first_of(begin, end, std::begin(os::folder_seps), std::end(os::folder_seps) - 1);
+            return it != end ? it.base() : filename;
+        }
+    }
+#ifdef _MSC_VER
+#    pragma warning(pop)
+#endif // _MSC_VER
+
+    void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override
+    {
+        if (msg.source.empty())
+        {
+            ScopedPadder p(0, padinfo_, dest);
+            return;
+        }
+        auto filename = basename(msg.source.filename);
+        size_t text_size = padinfo_.enabled() ? std::char_traits<char>::length(filename) : 0;
+        ScopedPadder p(text_size, padinfo_, dest);
+        fmt_helper::append_string_view(filename, dest);
+    }
+};
+
+template<typename ScopedPadder>
+class source_linenum_formatter final : public flag_formatter
+{
+public:
+    explicit source_linenum_formatter(padding_info padinfo)
+        : flag_formatter(padinfo)
+    {}
+
+    void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override
+    {
+        if (msg.source.empty())
+        {
+            ScopedPadder p(0, padinfo_, dest);
+            return;
+        }
+
+        auto field_size = ScopedPadder::count_digits(msg.source.line);
+        ScopedPadder p(field_size, padinfo_, dest);
+        fmt_helper::append_int(msg.source.line, dest);
+    }
+};
+
+// print source funcname
+template<typename ScopedPadder>
+class source_funcname_formatter final : public flag_formatter
+{
+public:
+    explicit source_funcname_formatter(padding_info padinfo)
+        : flag_formatter(padinfo)
+    {}
+
+    void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override
+    {
+        if (msg.source.empty())
+        {
+            ScopedPadder p(0, padinfo_, dest);
+            return;
+        }
+        size_t text_size = padinfo_.enabled() ? std::char_traits<char>::length(msg.source.funcname) : 0;
+        ScopedPadder p(text_size, padinfo_, dest);
+        fmt_helper::append_string_view(msg.source.funcname, dest);
+    }
+};
+
+// print elapsed time since last message
+template<typename ScopedPadder, typename Units>
+class elapsed_formatter final : public flag_formatter
+{
+public:
+    using DurationUnits = Units;
+
+    explicit elapsed_formatter(padding_info padinfo)
+        : flag_formatter(padinfo)
+        , last_message_time_(log_clock::now())
+    {}
+
+    void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override
+    {
+        auto delta = (std::max)(msg.time - last_message_time_, log_clock::duration::zero());
+        auto delta_units = std::chrono::duration_cast<DurationUnits>(delta);
+        last_message_time_ = msg.time;
+        auto delta_count = static_cast<size_t>(delta_units.count());
+        auto n_digits = static_cast<size_t>(ScopedPadder::count_digits(delta_count));
+        ScopedPadder p(n_digits, padinfo_, dest);
+        fmt_helper::append_int(delta_count, dest);
+    }
+
+private:
+    log_clock::time_point last_message_time_;
+};
+
+// Full info formatter
+// pattern: [%Y-%m-%d %H:%M:%S.%e] [%n] [%l] [%s:%#] %v
+class full_formatter final : public flag_formatter
+{
+public:
+    explicit full_formatter(padding_info padinfo)
+        : flag_formatter(padinfo)
+    {}
+
+    void format(const details::log_msg &msg, const std::tm &tm_time, memory_buf_t &dest) override
+    {
+        using std::chrono::duration_cast;
+        using std::chrono::milliseconds;
+        using std::chrono::seconds;
+
+        // cache the date/time part for the next second.
+        auto duration = msg.time.time_since_epoch();
+        auto secs = duration_cast<seconds>(duration);
+
+        if (cache_timestamp_ != secs || cached_datetime_.size() == 0)
+        {
+            cached_datetime_.clear();
+            cached_datetime_.push_back('[');
+            fmt_helper::append_int(tm_time.tm_year + 1900, cached_datetime_);
+            cached_datetime_.push_back('-');
+
+            fmt_helper::pad2(tm_time.tm_mon + 1, cached_datetime_);
+            cached_datetime_.push_back('-');
+
+            fmt_helper::pad2(tm_time.tm_mday, cached_datetime_);
+            cached_datetime_.push_back(' ');
+
+            fmt_helper::pad2(tm_time.tm_hour, cached_datetime_);
+            cached_datetime_.push_back(':');
+
+            fmt_helper::pad2(tm_time.tm_min, cached_datetime_);
+            cached_datetime_.push_back(':');
+
+            fmt_helper::pad2(tm_time.tm_sec, cached_datetime_);
+            cached_datetime_.push_back('.');
+
+            cache_timestamp_ = secs;
+        }
+        dest.append(cached_datetime_.begin(), cached_datetime_.end());
+
+        auto millis = fmt_helper::time_fraction<milliseconds>(msg.time);
+        fmt_helper::pad3(static_cast<uint32_t>(millis.count()), dest);
+        dest.push_back(']');
+        dest.push_back(' ');
+
+        // append logger name if exists
+        if (msg.logger_name.size() > 0)
+        {
+            dest.push_back('[');
+            fmt_helper::append_string_view(msg.logger_name, dest);
+            dest.push_back(']');
+            dest.push_back(' ');
+        }
+
+        dest.push_back('[');
+        // wrap the level name with color
+        msg.color_range_start = dest.size();
+        // fmt_helper::append_string_view(level::to_c_str(msg.level), dest);
+        fmt_helper::append_string_view(level::to_string_view(msg.level), dest);
+        msg.color_range_end = dest.size();
+        dest.push_back(']');
+        dest.push_back(' ');
+
+        // add source location if present
+        if (!msg.source.empty())
+        {
+            dest.push_back('[');
+            const char *filename = details::short_filename_formatter<details::null_scoped_padder>::basename(msg.source.filename);
+            fmt_helper::append_string_view(filename, dest);
+            dest.push_back(':');
+            fmt_helper::append_int(msg.source.line, dest);
+            dest.push_back(']');
+            dest.push_back(' ');
+        }
+        // fmt_helper::append_string_view(msg.msg(), dest);
+        fmt_helper::append_string_view(msg.payload, dest);
+    }
+
+private:
+    std::chrono::seconds cache_timestamp_{0};
+    memory_buf_t cached_datetime_;
+};
+
+} // namespace details
+
+SPDLOG_INLINE pattern_formatter::pattern_formatter(
+    std::string pattern, pattern_time_type time_type, std::string eol, custom_flags custom_user_flags)
+    : pattern_(std::move(pattern))
+    , eol_(std::move(eol))
+    , pattern_time_type_(time_type)
+    , need_localtime_(false)
+    , last_log_secs_(0)
+    , custom_handlers_(std::move(custom_user_flags))
+{
+    std::memset(&cached_tm_, 0, sizeof(cached_tm_));
+    compile_pattern_(pattern_);
+}
+
+// use by default full formatter for if pattern is not given
+SPDLOG_INLINE pattern_formatter::pattern_formatter(pattern_time_type time_type, std::string eol)
+    : pattern_("%+")
+    , eol_(std::move(eol))
+    , pattern_time_type_(time_type)
+    , need_localtime_(true)
+    , last_log_secs_(0)
+{
+    std::memset(&cached_tm_, 0, sizeof(cached_tm_));
+    formatters_.push_back(details::make_unique<details::full_formatter>(details::padding_info{}));
+}
+
+SPDLOG_INLINE std::unique_ptr<formatter> pattern_formatter::clone() const
+{
+    custom_flags cloned_custom_formatters;
+    for (auto &it : custom_handlers_)
+    {
+        cloned_custom_formatters[it.first] = it.second->clone();
+    }
+    auto cloned = details::make_unique<pattern_formatter>(pattern_, pattern_time_type_, eol_, std::move(cloned_custom_formatters));
+    cloned->need_localtime(need_localtime_);
+#if defined(__GNUC__) && __GNUC__ < 5
+    return std::move(cloned);
+#else
+    return cloned;
+#endif
+}
+
+SPDLOG_INLINE void pattern_formatter::format(const details::log_msg &msg, memory_buf_t &dest)
+{
+    if (need_localtime_)
+    {
+        const auto secs = std::chrono::duration_cast<std::chrono::seconds>(msg.time.time_since_epoch());
+        if (secs != last_log_secs_)
+        {
+            cached_tm_ = get_time_(msg);
+            last_log_secs_ = secs;
+        }
+    }
+
+    for (auto &f : formatters_)
+    {
+        f->format(msg, cached_tm_, dest);
+    }
+    // write eol
+    details::fmt_helper::append_string_view(eol_, dest);
+}
+
+SPDLOG_INLINE void pattern_formatter::set_pattern(std::string pattern)
+{
+    pattern_ = std::move(pattern);
+    need_localtime_ = false;
+    compile_pattern_(pattern_);
+}
+
+SPDLOG_INLINE void pattern_formatter::need_localtime(bool need)
+{
+    need_localtime_ = need;
+}
+
+SPDLOG_INLINE std::tm pattern_formatter::get_time_(const details::log_msg &msg)
+{
+    if (pattern_time_type_ == pattern_time_type::local)
+    {
+        return details::os::localtime(log_clock::to_time_t(msg.time));
+    }
+    return details::os::gmtime(log_clock::to_time_t(msg.time));
+}
+
+template<typename Padder>
+SPDLOG_INLINE void pattern_formatter::handle_flag_(char flag, details::padding_info padding)
+{
+    // process custom flags
+    auto it = custom_handlers_.find(flag);
+    if (it != custom_handlers_.end())
+    {
+        auto custom_handler = it->second->clone();
+        custom_handler->set_padding_info(padding);
+        formatters_.push_back(std::move(custom_handler));
+        return;
+    }
+
+    // process built-in flags
+    switch (flag)
+    {
+    case ('+'): // default formatter
+        formatters_.push_back(details::make_unique<details::full_formatter>(padding));
+        need_localtime_ = true;
+        break;
+
+    case 'n': // logger name
+        formatters_.push_back(details::make_unique<details::name_formatter<Padder>>(padding));
+        break;
+
+    case 'l': // level
+        formatters_.push_back(details::make_unique<details::level_formatter<Padder>>(padding));
+        break;
+
+    case 'L': // short level
+        formatters_.push_back(details::make_unique<details::short_level_formatter<Padder>>(padding));
+        break;
+
+    case ('t'): // thread id
+        formatters_.push_back(details::make_unique<details::t_formatter<Padder>>(padding));
+        break;
+
+    case ('v'): // the message text
+        formatters_.push_back(details::make_unique<details::v_formatter<Padder>>(padding));
+        break;
+
+    case ('a'): // weekday
+        formatters_.push_back(details::make_unique<details::a_formatter<Padder>>(padding));
+        need_localtime_ = true;
+        break;
+
+    case ('A'): // short weekday
+        formatters_.push_back(details::make_unique<details::A_formatter<Padder>>(padding));
+        need_localtime_ = true;
+        break;
+
+    case ('b'):
+    case ('h'): // month
+        formatters_.push_back(details::make_unique<details::b_formatter<Padder>>(padding));
+        need_localtime_ = true;
+        break;
+
+    case ('B'): // short month
+        formatters_.push_back(details::make_unique<details::B_formatter<Padder>>(padding));
+        need_localtime_ = true;
+        break;
+
+    case ('c'): // datetime
+        formatters_.push_back(details::make_unique<details::c_formatter<Padder>>(padding));
+        need_localtime_ = true;
+        break;
+
+    case ('C'): // year 2 digits
+        formatters_.push_back(details::make_unique<details::C_formatter<Padder>>(padding));
+        need_localtime_ = true;
+        break;
+
+    case ('Y'): // year 4 digits
+        formatters_.push_back(details::make_unique<details::Y_formatter<Padder>>(padding));
+        need_localtime_ = true;
+        break;
+
+    case ('D'):
+    case ('x'): // datetime MM/DD/YY
+        formatters_.push_back(details::make_unique<details::D_formatter<Padder>>(padding));
+        need_localtime_ = true;
+        break;
+
+    case ('m'): // month 1-12
+        formatters_.push_back(details::make_unique<details::m_formatter<Padder>>(padding));
+        need_localtime_ = true;
+        break;
+
+    case ('d'): // day of month 1-31
+        formatters_.push_back(details::make_unique<details::d_formatter<Padder>>(padding));
+        need_localtime_ = true;
+        break;
+
+    case ('H'): // hours 24
+        formatters_.push_back(details::make_unique<details::H_formatter<Padder>>(padding));
+        need_localtime_ = true;
+        break;
+
+    case ('I'): // hours 12
+        formatters_.push_back(details::make_unique<details::I_formatter<Padder>>(padding));
+        need_localtime_ = true;
+        break;
+
+    case ('M'): // minutes
+        formatters_.push_back(details::make_unique<details::M_formatter<Padder>>(padding));
+        need_localtime_ = true;
+        break;
+
+    case ('S'): // seconds
+        formatters_.push_back(details::make_unique<details::S_formatter<Padder>>(padding));
+        need_localtime_ = true;
+        break;
+
+    case ('e'): // milliseconds
+        formatters_.push_back(details::make_unique<details::e_formatter<Padder>>(padding));
+        break;
+
+    case ('f'): // microseconds
+        formatters_.push_back(details::make_unique<details::f_formatter<Padder>>(padding));
+        break;
+
+    case ('F'): // nanoseconds
+        formatters_.push_back(details::make_unique<details::F_formatter<Padder>>(padding));
+        break;
+
+    case ('E'): // seconds since epoch
+        formatters_.push_back(details::make_unique<details::E_formatter<Padder>>(padding));
+        break;
+
+    case ('p'): // am/pm
+        formatters_.push_back(details::make_unique<details::p_formatter<Padder>>(padding));
+        need_localtime_ = true;
+        break;
+
+    case ('r'): // 12 hour clock 02:55:02 pm
+        formatters_.push_back(details::make_unique<details::r_formatter<Padder>>(padding));
+        need_localtime_ = true;
+        break;
+
+    case ('R'): // 24-hour HH:MM time
+        formatters_.push_back(details::make_unique<details::R_formatter<Padder>>(padding));
+        need_localtime_ = true;
+        break;
+
+    case ('T'):
+    case ('X'): // ISO 8601 time format (HH:MM:SS)
+        formatters_.push_back(details::make_unique<details::T_formatter<Padder>>(padding));
+        need_localtime_ = true;
+        break;
+
+    case ('z'): // timezone
+        formatters_.push_back(details::make_unique<details::z_formatter<Padder>>(padding));
+        need_localtime_ = true;
+        break;
+
+    case ('P'): // pid
+        formatters_.push_back(details::make_unique<details::pid_formatter<Padder>>(padding));
+        break;
+
+    case ('^'): // color range start
+        formatters_.push_back(details::make_unique<details::color_start_formatter>(padding));
+        break;
+
+    case ('$'): // color range end
+        formatters_.push_back(details::make_unique<details::color_stop_formatter>(padding));
+        break;
+
+    case ('@'): // source location (filename:filenumber)
+        formatters_.push_back(details::make_unique<details::source_location_formatter<Padder>>(padding));
+        break;
+
+    case ('s'): // short source filename - without directory name
+        formatters_.push_back(details::make_unique<details::short_filename_formatter<Padder>>(padding));
+        break;
+
+    case ('g'): // full source filename
+        formatters_.push_back(details::make_unique<details::source_filename_formatter<Padder>>(padding));
+        break;
+
+    case ('#'): // source line number
+        formatters_.push_back(details::make_unique<details::source_linenum_formatter<Padder>>(padding));
+        break;
+
+    case ('!'): // source funcname
+        formatters_.push_back(details::make_unique<details::source_funcname_formatter<Padder>>(padding));
+        break;
+
+    case ('%'): // % char
+        formatters_.push_back(details::make_unique<details::ch_formatter>('%'));
+        break;
+
+    case ('u'): // elapsed time since last log message in nanos
+        formatters_.push_back(details::make_unique<details::elapsed_formatter<Padder, std::chrono::nanoseconds>>(padding));
+        break;
+
+    case ('i'): // elapsed time since last log message in micros
+        formatters_.push_back(details::make_unique<details::elapsed_formatter<Padder, std::chrono::microseconds>>(padding));
+        break;
+
+    case ('o'): // elapsed time since last log message in millis
+        formatters_.push_back(details::make_unique<details::elapsed_formatter<Padder, std::chrono::milliseconds>>(padding));
+        break;
+
+    case ('O'): // elapsed time since last log message in seconds
+        formatters_.push_back(details::make_unique<details::elapsed_formatter<Padder, std::chrono::seconds>>(padding));
+        break;
+
+    default: // Unknown flag appears as is
+        auto unknown_flag = details::make_unique<details::aggregate_formatter>();
+
+        if (!padding.truncate_)
+        {
+            unknown_flag->add_ch('%');
+            unknown_flag->add_ch(flag);
+            formatters_.push_back((std::move(unknown_flag)));
+        }
+        // fix issue #1617 (prev char was '!' and should have been treated as funcname flag instead of truncating flag)
+        // spdlog::set_pattern("[%10!] %v") => "[      main] some message"
+        // spdlog::set_pattern("[%3!!] %v") => "[mai] some message"
+        else
+        {
+            padding.truncate_ = false;
+            formatters_.push_back(details::make_unique<details::source_funcname_formatter<Padder>>(padding));
+            unknown_flag->add_ch(flag);
+            formatters_.push_back((std::move(unknown_flag)));
+        }
+
+        break;
+    }
+}
+
+// Extract given pad spec (e.g. %8X, %=8X, %-8!X, %8!X, %=8!X, %-8!X, %+8!X)
+// Advance the given it pass the end of the padding spec found (if any)
+// Return padding.
+SPDLOG_INLINE details::padding_info pattern_formatter::handle_padspec_(std::string::const_iterator &it, std::string::const_iterator end)
+{
+    using details::padding_info;
+    using details::scoped_padder;
+    const size_t max_width = 64;
+    if (it == end)
+    {
+        return padding_info{};
+    }
+
+    padding_info::pad_side side;
+    switch (*it)
+    {
+    case '-':
+        side = padding_info::pad_side::right;
+        ++it;
+        break;
+    case '=':
+        side = padding_info::pad_side::center;
+        ++it;
+        break;
+    default:
+        side = details::padding_info::pad_side::left;
+        break;
+    }
+
+    if (it == end || !std::isdigit(static_cast<unsigned char>(*it)))
+    {
+        return padding_info{}; // no padding if no digit found here
+    }
+
+    auto width = static_cast<size_t>(*it) - '0';
+    for (++it; it != end && std::isdigit(static_cast<unsigned char>(*it)); ++it)
+    {
+        auto digit = static_cast<size_t>(*it) - '0';
+        width = width * 10 + digit;
+    }
+
+    // search for the optional truncate marker '!'
+    bool truncate;
+    if (it != end && *it == '!')
+    {
+        truncate = true;
+        ++it;
+    }
+    else
+    {
+        truncate = false;
+    }
+    return details::padding_info{std::min<size_t>(width, max_width), side, truncate};
+}
+
+SPDLOG_INLINE void pattern_formatter::compile_pattern_(const std::string &pattern)
+{
+    auto end = pattern.end();
+    std::unique_ptr<details::aggregate_formatter> user_chars;
+    formatters_.clear();
+    for (auto it = pattern.begin(); it != end; ++it)
+    {
+        if (*it == '%')
+        {
+            if (user_chars) // append user chars found so far
+            {
+                formatters_.push_back(std::move(user_chars));
+            }
+
+            auto padding = handle_padspec_(++it, end);
+
+            if (it != end)
+            {
+                if (padding.enabled())
+                {
+                    handle_flag_<details::scoped_padder>(*it, padding);
+                }
+                else
+                {
+                    handle_flag_<details::null_scoped_padder>(*it, padding);
+                }
+            }
+            else
+            {
+                break;
+            }
+        }
+        else // chars not following the % sign should be displayed as is
+        {
+            if (!user_chars)
+            {
+                user_chars = details::make_unique<details::aggregate_formatter>();
+            }
+            user_chars->add_ch(*it);
+        }
+    }
+    if (user_chars) // append raw chars found so far
+    {
+        formatters_.push_back(std::move(user_chars));
+    }
+}
+} // namespace spdlog
diff --git a/3rdparty/spdlog/src/include/spdlog/pattern_formatter.h b/3rdparty/spdlog/src/include/spdlog/pattern_formatter.h
new file mode 100644
index 00000000..4c87b21e
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/pattern_formatter.h
@@ -0,0 +1,128 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#include <spdlog/common.h>
+#include <spdlog/details/log_msg.h>
+#include <spdlog/details/os.h>
+#include <spdlog/formatter.h>
+
+#include <chrono>
+#include <ctime>
+#include <memory>
+
+#include <string>
+#include <vector>
+#include <unordered_map>
+
+namespace spdlog {
+namespace details {
+
+// padding information.
+struct padding_info
+{
+    enum class pad_side
+    {
+        left,
+        right,
+        center
+    };
+
+    padding_info() = default;
+    padding_info(size_t width, padding_info::pad_side side, bool truncate)
+        : width_(width)
+        , side_(side)
+        , truncate_(truncate)
+        , enabled_(true)
+    {}
+
+    bool enabled() const
+    {
+        return enabled_;
+    }
+    size_t width_ = 0;
+    pad_side side_ = pad_side::left;
+    bool truncate_ = false;
+    bool enabled_ = false;
+};
+
+class SPDLOG_API flag_formatter
+{
+public:
+    explicit flag_formatter(padding_info padinfo)
+        : padinfo_(padinfo)
+    {}
+    flag_formatter() = default;
+    virtual ~flag_formatter() = default;
+    virtual void format(const details::log_msg &msg, const std::tm &tm_time, memory_buf_t &dest) = 0;
+
+protected:
+    padding_info padinfo_;
+};
+
+} // namespace details
+
+class SPDLOG_API custom_flag_formatter : public details::flag_formatter
+{
+public:
+    virtual std::unique_ptr<custom_flag_formatter> clone() const = 0;
+
+    void set_padding_info(const details::padding_info &padding)
+    {
+        flag_formatter::padinfo_ = padding;
+    }
+};
+
+class SPDLOG_API pattern_formatter final : public formatter
+{
+public:
+    using custom_flags = std::unordered_map<char, std::unique_ptr<custom_flag_formatter>>;
+
+    explicit pattern_formatter(std::string pattern, pattern_time_type time_type = pattern_time_type::local,
+        std::string eol = spdlog::details::os::default_eol, custom_flags custom_user_flags = custom_flags());
+
+    // use default pattern is not given
+    explicit pattern_formatter(pattern_time_type time_type = pattern_time_type::local, std::string eol = spdlog::details::os::default_eol);
+
+    pattern_formatter(const pattern_formatter &other) = delete;
+    pattern_formatter &operator=(const pattern_formatter &other) = delete;
+
+    std::unique_ptr<formatter> clone() const override;
+    void format(const details::log_msg &msg, memory_buf_t &dest) override;
+
+    template<typename T, typename... Args>
+    pattern_formatter &add_flag(char flag, Args &&...args)
+    {
+        custom_handlers_[flag] = details::make_unique<T>(std::forward<Args>(args)...);
+        return *this;
+    }
+    void set_pattern(std::string pattern);
+    void need_localtime(bool need = true);
+
+private:
+    std::string pattern_;
+    std::string eol_;
+    pattern_time_type pattern_time_type_;
+    bool need_localtime_;
+    std::tm cached_tm_;
+    std::chrono::seconds last_log_secs_;
+    std::vector<std::unique_ptr<details::flag_formatter>> formatters_;
+    custom_flags custom_handlers_;
+
+    std::tm get_time_(const details::log_msg &msg);
+    template<typename Padder>
+    void handle_flag_(char flag, details::padding_info padding);
+
+    // Extract given pad spec (e.g. %8X)
+    // Advance the given it pass the end of the padding spec found (if any)
+    // Return padding.
+    static details::padding_info handle_padspec_(std::string::const_iterator &it, std::string::const_iterator end);
+
+    void compile_pattern_(const std::string &pattern);
+};
+} // namespace spdlog
+
+#ifdef SPDLOG_HEADER_ONLY
+#    include "pattern_formatter-inl.h"
+#endif
diff --git a/3rdparty/spdlog/src/include/spdlog/sinks/android_sink.h b/3rdparty/spdlog/src/include/spdlog/sinks/android_sink.h
new file mode 100644
index 00000000..8e79638b
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/sinks/android_sink.h
@@ -0,0 +1,142 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#ifdef __ANDROID__
+
+#    include <spdlog/details/fmt_helper.h>
+#    include <spdlog/details/null_mutex.h>
+#    include <spdlog/details/os.h>
+#    include <spdlog/sinks/base_sink.h>
+#    include <spdlog/details/synchronous_factory.h>
+
+#    include <android/log.h>
+#    include <chrono>
+#    include <mutex>
+#    include <string>
+#    include <thread>
+#    include <type_traits>
+
+#    if !defined(SPDLOG_ANDROID_RETRIES)
+#        define SPDLOG_ANDROID_RETRIES 2
+#    endif
+
+namespace spdlog {
+namespace sinks {
+
+/*
+ * Android sink
+ * (logging using __android_log_write or __android_log_buf_write depending on the specified BufferID)
+ */
+template<typename Mutex, int BufferID = log_id::LOG_ID_MAIN>
+class android_sink final : public base_sink<Mutex>
+{
+public:
+    explicit android_sink(std::string tag = "spdlog", bool use_raw_msg = false)
+        : tag_(std::move(tag))
+        , use_raw_msg_(use_raw_msg)
+    {}
+
+protected:
+    void sink_it_(const details::log_msg &msg) override
+    {
+        const android_LogPriority priority = convert_to_android_(msg.level);
+        memory_buf_t formatted;
+        if (use_raw_msg_)
+        {
+            details::fmt_helper::append_string_view(msg.payload, formatted);
+        }
+        else
+        {
+            base_sink<Mutex>::formatter_->format(msg, formatted);
+        }
+        formatted.push_back('\0');
+        const char *msg_output = formatted.data();
+
+        // See system/core/liblog/logger_write.c for explanation of return value
+        int ret = android_log(priority, tag_.c_str(), msg_output);
+        int retry_count = 0;
+        while ((ret == -11 /*EAGAIN*/) && (retry_count < SPDLOG_ANDROID_RETRIES))
+        {
+            details::os::sleep_for_millis(5);
+            ret = android_log(priority, tag_.c_str(), msg_output);
+            retry_count++;
+        }
+
+        if (ret < 0)
+        {
+            throw_spdlog_ex("logging to Android failed", ret);
+        }
+    }
+
+    void flush_() override {}
+
+private:
+    // There might be liblog versions used, that do not support __android_log_buf_write. So we only compile and link against
+    // __android_log_buf_write, if user explicitly provides a non-default log buffer. Otherwise, when using the default log buffer, always
+    // log via __android_log_write.
+    template<int ID = BufferID>
+    typename std::enable_if<ID == static_cast<int>(log_id::LOG_ID_MAIN), int>::type android_log(int prio, const char *tag, const char *text)
+    {
+        return __android_log_write(prio, tag, text);
+    }
+
+    template<int ID = BufferID>
+    typename std::enable_if<ID != static_cast<int>(log_id::LOG_ID_MAIN), int>::type android_log(int prio, const char *tag, const char *text)
+    {
+        return __android_log_buf_write(ID, prio, tag, text);
+    }
+
+    static android_LogPriority convert_to_android_(spdlog::level::level_enum level)
+    {
+        switch (level)
+        {
+        case spdlog::level::trace:
+            return ANDROID_LOG_VERBOSE;
+        case spdlog::level::debug:
+            return ANDROID_LOG_DEBUG;
+        case spdlog::level::info:
+            return ANDROID_LOG_INFO;
+        case spdlog::level::warn:
+            return ANDROID_LOG_WARN;
+        case spdlog::level::err:
+            return ANDROID_LOG_ERROR;
+        case spdlog::level::critical:
+            return ANDROID_LOG_FATAL;
+        default:
+            return ANDROID_LOG_DEFAULT;
+        }
+    }
+
+    std::string tag_;
+    bool use_raw_msg_;
+};
+
+using android_sink_mt = android_sink<std::mutex>;
+using android_sink_st = android_sink<details::null_mutex>;
+
+template<int BufferId = log_id::LOG_ID_MAIN>
+using android_sink_buf_mt = android_sink<std::mutex, BufferId>;
+template<int BufferId = log_id::LOG_ID_MAIN>
+using android_sink_buf_st = android_sink<details::null_mutex, BufferId>;
+
+} // namespace sinks
+
+// Create and register android syslog logger
+
+template<typename Factory = spdlog::synchronous_factory>
+inline std::shared_ptr<logger> android_logger_mt(const std::string &logger_name, const std::string &tag = "spdlog")
+{
+    return Factory::template create<sinks::android_sink_mt>(logger_name, tag);
+}
+
+template<typename Factory = spdlog::synchronous_factory>
+inline std::shared_ptr<logger> android_logger_st(const std::string &logger_name, const std::string &tag = "spdlog")
+{
+    return Factory::template create<sinks::android_sink_st>(logger_name, tag);
+}
+
+} // namespace spdlog
+
+#endif // __ANDROID__
diff --git a/3rdparty/spdlog/src/include/spdlog/sinks/ansicolor_sink-inl.h b/3rdparty/spdlog/src/include/spdlog/sinks/ansicolor_sink-inl.h
new file mode 100644
index 00000000..b5848f2d
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/sinks/ansicolor_sink-inl.h
@@ -0,0 +1,145 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#ifndef SPDLOG_HEADER_ONLY
+#    include <spdlog/sinks/ansicolor_sink.h>
+#endif
+
+#include <spdlog/pattern_formatter.h>
+#include <spdlog/details/os.h>
+
+namespace spdlog {
+namespace sinks {
+
+template<typename ConsoleMutex>
+SPDLOG_INLINE ansicolor_sink<ConsoleMutex>::ansicolor_sink(FILE *target_file, color_mode mode)
+    : target_file_(target_file)
+    , mutex_(ConsoleMutex::mutex())
+    , formatter_(details::make_unique<spdlog::pattern_formatter>())
+
+{
+    set_color_mode(mode);
+    colors_[level::trace] = to_string_(white);
+    colors_[level::debug] = to_string_(cyan);
+    colors_[level::info] = to_string_(green);
+    colors_[level::warn] = to_string_(yellow_bold);
+    colors_[level::err] = to_string_(red_bold);
+    colors_[level::critical] = to_string_(bold_on_red);
+    colors_[level::off] = to_string_(reset);
+}
+
+template<typename ConsoleMutex>
+SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::set_color(level::level_enum color_level, string_view_t color)
+{
+    std::lock_guard<mutex_t> lock(mutex_);
+    colors_[static_cast<size_t>(color_level)] = to_string_(color);
+}
+
+template<typename ConsoleMutex>
+SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::log(const details::log_msg &msg)
+{
+    // Wrap the originally formatted message in color codes.
+    // If color is not supported in the terminal, log as is instead.
+    std::lock_guard<mutex_t> lock(mutex_);
+    msg.color_range_start = 0;
+    msg.color_range_end = 0;
+    memory_buf_t formatted;
+    formatter_->format(msg, formatted);
+    if (should_do_colors_ && msg.color_range_end > msg.color_range_start)
+    {
+        // before color range
+        print_range_(formatted, 0, msg.color_range_start);
+        // in color range
+        print_ccode_(colors_[static_cast<size_t>(msg.level)]);
+        print_range_(formatted, msg.color_range_start, msg.color_range_end);
+        print_ccode_(reset);
+        // after color range
+        print_range_(formatted, msg.color_range_end, formatted.size());
+    }
+    else // no color
+    {
+        print_range_(formatted, 0, formatted.size());
+    }
+    fflush(target_file_);
+}
+
+template<typename ConsoleMutex>
+SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::flush()
+{
+    std::lock_guard<mutex_t> lock(mutex_);
+    fflush(target_file_);
+}
+
+template<typename ConsoleMutex>
+SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::set_pattern(const std::string &pattern)
+{
+    std::lock_guard<mutex_t> lock(mutex_);
+    formatter_ = std::unique_ptr<spdlog::formatter>(new pattern_formatter(pattern));
+}
+
+template<typename ConsoleMutex>
+SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter)
+{
+    std::lock_guard<mutex_t> lock(mutex_);
+    formatter_ = std::move(sink_formatter);
+}
+
+template<typename ConsoleMutex>
+SPDLOG_INLINE bool ansicolor_sink<ConsoleMutex>::should_color()
+{
+    return should_do_colors_;
+}
+
+template<typename ConsoleMutex>
+SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::set_color_mode(color_mode mode)
+{
+    switch (mode)
+    {
+    case color_mode::always:
+        should_do_colors_ = true;
+        return;
+    case color_mode::automatic:
+        should_do_colors_ = details::os::in_terminal(target_file_) && details::os::is_color_terminal();
+        return;
+    case color_mode::never:
+        should_do_colors_ = false;
+        return;
+    default:
+        should_do_colors_ = false;
+    }
+}
+
+template<typename ConsoleMutex>
+SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::print_ccode_(const string_view_t &color_code)
+{
+    fwrite(color_code.data(), sizeof(char), color_code.size(), target_file_);
+}
+
+template<typename ConsoleMutex>
+SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::print_range_(const memory_buf_t &formatted, size_t start, size_t end)
+{
+    fwrite(formatted.data() + start, sizeof(char), end - start, target_file_);
+}
+
+template<typename ConsoleMutex>
+SPDLOG_INLINE std::string ansicolor_sink<ConsoleMutex>::to_string_(const string_view_t &sv)
+{
+    return std::string(sv.data(), sv.size());
+}
+
+// ansicolor_stdout_sink
+template<typename ConsoleMutex>
+SPDLOG_INLINE ansicolor_stdout_sink<ConsoleMutex>::ansicolor_stdout_sink(color_mode mode)
+    : ansicolor_sink<ConsoleMutex>(stdout, mode)
+{}
+
+// ansicolor_stderr_sink
+template<typename ConsoleMutex>
+SPDLOG_INLINE ansicolor_stderr_sink<ConsoleMutex>::ansicolor_stderr_sink(color_mode mode)
+    : ansicolor_sink<ConsoleMutex>(stderr, mode)
+{}
+
+} // namespace sinks
+} // namespace spdlog
diff --git a/3rdparty/spdlog/src/include/spdlog/sinks/ansicolor_sink.h b/3rdparty/spdlog/src/include/spdlog/sinks/ansicolor_sink.h
new file mode 100644
index 00000000..39d966bc
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/sinks/ansicolor_sink.h
@@ -0,0 +1,118 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#include <spdlog/details/console_globals.h>
+#include <spdlog/details/null_mutex.h>
+#include <spdlog/sinks/sink.h>
+#include <memory>
+#include <mutex>
+#include <string>
+#include <array>
+
+namespace spdlog {
+namespace sinks {
+
+/**
+ * This sink prefixes the output with an ANSI escape sequence color code
+ * depending on the severity
+ * of the message.
+ * If no color terminal detected, omit the escape codes.
+ */
+
+template<typename ConsoleMutex>
+class ansicolor_sink : public sink
+{
+public:
+    using mutex_t = typename ConsoleMutex::mutex_t;
+    ansicolor_sink(FILE *target_file, color_mode mode);
+    ~ansicolor_sink() override = default;
+
+    ansicolor_sink(const ansicolor_sink &other) = delete;
+    ansicolor_sink(ansicolor_sink &&other) = delete;
+
+    ansicolor_sink &operator=(const ansicolor_sink &other) = delete;
+    ansicolor_sink &operator=(ansicolor_sink &&other) = delete;
+
+    void set_color(level::level_enum color_level, string_view_t color);
+    void set_color_mode(color_mode mode);
+    bool should_color();
+
+    void log(const details::log_msg &msg) override;
+    void flush() override;
+    void set_pattern(const std::string &pattern) final;
+    void set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter) override;
+
+    // Formatting codes
+    const string_view_t reset = "\033[m";
+    const string_view_t bold = "\033[1m";
+    const string_view_t dark = "\033[2m";
+    const string_view_t underline = "\033[4m";
+    const string_view_t blink = "\033[5m";
+    const string_view_t reverse = "\033[7m";
+    const string_view_t concealed = "\033[8m";
+    const string_view_t clear_line = "\033[K";
+
+    // Foreground colors
+    const string_view_t black = "\033[30m";
+    const string_view_t red = "\033[31m";
+    const string_view_t green = "\033[32m";
+    const string_view_t yellow = "\033[33m";
+    const string_view_t blue = "\033[34m";
+    const string_view_t magenta = "\033[35m";
+    const string_view_t cyan = "\033[36m";
+    const string_view_t white = "\033[37m";
+
+    /// Background colors
+    const string_view_t on_black = "\033[40m";
+    const string_view_t on_red = "\033[41m";
+    const string_view_t on_green = "\033[42m";
+    const string_view_t on_yellow = "\033[43m";
+    const string_view_t on_blue = "\033[44m";
+    const string_view_t on_magenta = "\033[45m";
+    const string_view_t on_cyan = "\033[46m";
+    const string_view_t on_white = "\033[47m";
+
+    /// Bold colors
+    const string_view_t yellow_bold = "\033[33m\033[1m";
+    const string_view_t red_bold = "\033[31m\033[1m";
+    const string_view_t bold_on_red = "\033[1m\033[41m";
+
+private:
+    FILE *target_file_;
+    mutex_t &mutex_;
+    bool should_do_colors_;
+    std::unique_ptr<spdlog::formatter> formatter_;
+    std::array<std::string, level::n_levels> colors_;
+    void print_ccode_(const string_view_t &color_code);
+    void print_range_(const memory_buf_t &formatted, size_t start, size_t end);
+    static std::string to_string_(const string_view_t &sv);
+};
+
+template<typename ConsoleMutex>
+class ansicolor_stdout_sink : public ansicolor_sink<ConsoleMutex>
+{
+public:
+    explicit ansicolor_stdout_sink(color_mode mode = color_mode::automatic);
+};
+
+template<typename ConsoleMutex>
+class ansicolor_stderr_sink : public ansicolor_sink<ConsoleMutex>
+{
+public:
+    explicit ansicolor_stderr_sink(color_mode mode = color_mode::automatic);
+};
+
+using ansicolor_stdout_sink_mt = ansicolor_stdout_sink<details::console_mutex>;
+using ansicolor_stdout_sink_st = ansicolor_stdout_sink<details::console_nullmutex>;
+
+using ansicolor_stderr_sink_mt = ansicolor_stderr_sink<details::console_mutex>;
+using ansicolor_stderr_sink_st = ansicolor_stderr_sink<details::console_nullmutex>;
+
+} // namespace sinks
+} // namespace spdlog
+
+#ifdef SPDLOG_HEADER_ONLY
+#    include "ansicolor_sink-inl.h"
+#endif
diff --git a/3rdparty/spdlog/src/include/spdlog/sinks/base_sink-inl.h b/3rdparty/spdlog/src/include/spdlog/sinks/base_sink-inl.h
new file mode 100644
index 00000000..421fdf9d
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/sinks/base_sink-inl.h
@@ -0,0 +1,63 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#ifndef SPDLOG_HEADER_ONLY
+#    include <spdlog/sinks/base_sink.h>
+#endif
+
+#include <spdlog/common.h>
+#include <spdlog/pattern_formatter.h>
+
+#include <memory>
+
+template<typename Mutex>
+SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::base_sink()
+    : formatter_{details::make_unique<spdlog::pattern_formatter>()}
+{}
+
+template<typename Mutex>
+SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::base_sink(std::unique_ptr<spdlog::formatter> formatter)
+    : formatter_{std::move(formatter)}
+{}
+
+template<typename Mutex>
+void SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::log(const details::log_msg &msg)
+{
+    std::lock_guard<Mutex> lock(mutex_);
+    sink_it_(msg);
+}
+
+template<typename Mutex>
+void SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::flush()
+{
+    std::lock_guard<Mutex> lock(mutex_);
+    flush_();
+}
+
+template<typename Mutex>
+void SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::set_pattern(const std::string &pattern)
+{
+    std::lock_guard<Mutex> lock(mutex_);
+    set_pattern_(pattern);
+}
+
+template<typename Mutex>
+void SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter)
+{
+    std::lock_guard<Mutex> lock(mutex_);
+    set_formatter_(std::move(sink_formatter));
+}
+
+template<typename Mutex>
+void SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::set_pattern_(const std::string &pattern)
+{
+    set_formatter_(details::make_unique<spdlog::pattern_formatter>(pattern));
+}
+
+template<typename Mutex>
+void SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::set_formatter_(std::unique_ptr<spdlog::formatter> sink_formatter)
+{
+    formatter_ = std::move(sink_formatter);
+}
diff --git a/3rdparty/spdlog/src/include/spdlog/sinks/base_sink.h b/3rdparty/spdlog/src/include/spdlog/sinks/base_sink.h
new file mode 100644
index 00000000..2e795f59
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/sinks/base_sink.h
@@ -0,0 +1,52 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+//
+// base sink templated over a mutex (either dummy or real)
+// concrete implementation should override the sink_it_() and flush_()  methods.
+// locking is taken care of in this class - no locking needed by the
+// implementers..
+//
+
+#include <spdlog/common.h>
+#include <spdlog/details/log_msg.h>
+#include <spdlog/sinks/sink.h>
+
+namespace spdlog {
+namespace sinks {
+template<typename Mutex>
+class SPDLOG_API base_sink : public sink
+{
+public:
+    base_sink();
+    explicit base_sink(std::unique_ptr<spdlog::formatter> formatter);
+    ~base_sink() override = default;
+
+    base_sink(const base_sink &) = delete;
+    base_sink(base_sink &&) = delete;
+
+    base_sink &operator=(const base_sink &) = delete;
+    base_sink &operator=(base_sink &&) = delete;
+
+    void log(const details::log_msg &msg) final;
+    void flush() final;
+    void set_pattern(const std::string &pattern) final;
+    void set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter) final;
+
+protected:
+    // sink formatter
+    std::unique_ptr<spdlog::formatter> formatter_;
+    Mutex mutex_;
+
+    virtual void sink_it_(const details::log_msg &msg) = 0;
+    virtual void flush_() = 0;
+    virtual void set_pattern_(const std::string &pattern);
+    virtual void set_formatter_(std::unique_ptr<spdlog::formatter> sink_formatter);
+};
+} // namespace sinks
+} // namespace spdlog
+
+#ifdef SPDLOG_HEADER_ONLY
+#    include "base_sink-inl.h"
+#endif
diff --git a/3rdparty/spdlog/src/include/spdlog/sinks/basic_file_sink-inl.h b/3rdparty/spdlog/src/include/spdlog/sinks/basic_file_sink-inl.h
new file mode 100644
index 00000000..8d23f96d
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/sinks/basic_file_sink-inl.h
@@ -0,0 +1,44 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#ifndef SPDLOG_HEADER_ONLY
+#    include <spdlog/sinks/basic_file_sink.h>
+#endif
+
+#include <spdlog/common.h>
+#include <spdlog/details/os.h>
+
+namespace spdlog {
+namespace sinks {
+
+template<typename Mutex>
+SPDLOG_INLINE basic_file_sink<Mutex>::basic_file_sink(const filename_t &filename, bool truncate, const file_event_handlers &event_handlers)
+    : file_helper_{event_handlers}
+{
+    file_helper_.open(filename, truncate);
+}
+
+template<typename Mutex>
+SPDLOG_INLINE const filename_t &basic_file_sink<Mutex>::filename() const
+{
+    return file_helper_.filename();
+}
+
+template<typename Mutex>
+SPDLOG_INLINE void basic_file_sink<Mutex>::sink_it_(const details::log_msg &msg)
+{
+    memory_buf_t formatted;
+    base_sink<Mutex>::formatter_->format(msg, formatted);
+    file_helper_.write(formatted);
+}
+
+template<typename Mutex>
+SPDLOG_INLINE void basic_file_sink<Mutex>::flush_()
+{
+    file_helper_.flush();
+}
+
+} // namespace sinks
+} // namespace spdlog
diff --git a/3rdparty/spdlog/src/include/spdlog/sinks/basic_file_sink.h b/3rdparty/spdlog/src/include/spdlog/sinks/basic_file_sink.h
new file mode 100644
index 00000000..aacc993b
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/sinks/basic_file_sink.h
@@ -0,0 +1,60 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#include <spdlog/details/file_helper.h>
+#include <spdlog/details/null_mutex.h>
+#include <spdlog/sinks/base_sink.h>
+#include <spdlog/details/synchronous_factory.h>
+
+#include <mutex>
+#include <string>
+
+namespace spdlog {
+namespace sinks {
+/*
+ * Trivial file sink with single file as target
+ */
+template<typename Mutex>
+class basic_file_sink final : public base_sink<Mutex>
+{
+public:
+    explicit basic_file_sink(const filename_t &filename, bool truncate = false, const file_event_handlers &event_handlers = {});
+    const filename_t &filename() const;
+
+protected:
+    void sink_it_(const details::log_msg &msg) override;
+    void flush_() override;
+
+private:
+    details::file_helper file_helper_;
+};
+
+using basic_file_sink_mt = basic_file_sink<std::mutex>;
+using basic_file_sink_st = basic_file_sink<details::null_mutex>;
+
+} // namespace sinks
+
+//
+// factory functions
+//
+template<typename Factory = spdlog::synchronous_factory>
+inline std::shared_ptr<logger> basic_logger_mt(
+    const std::string &logger_name, const filename_t &filename, bool truncate = false, const file_event_handlers &event_handlers = {})
+{
+    return Factory::template create<sinks::basic_file_sink_mt>(logger_name, filename, truncate, event_handlers);
+}
+
+template<typename Factory = spdlog::synchronous_factory>
+inline std::shared_ptr<logger> basic_logger_st(
+    const std::string &logger_name, const filename_t &filename, bool truncate = false, const file_event_handlers &event_handlers = {})
+{
+    return Factory::template create<sinks::basic_file_sink_st>(logger_name, filename, truncate, event_handlers);
+}
+
+} // namespace spdlog
+
+#ifdef SPDLOG_HEADER_ONLY
+#    include "basic_file_sink-inl.h"
+#endif
diff --git a/3rdparty/spdlog/src/include/spdlog/sinks/callback_sink.h b/3rdparty/spdlog/src/include/spdlog/sinks/callback_sink.h
new file mode 100644
index 00000000..bcd31383
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/sinks/callback_sink.h
@@ -0,0 +1,61 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#include <spdlog/details/null_mutex.h>
+#include <spdlog/sinks/base_sink.h>
+#include <spdlog/details/synchronous_factory.h>
+
+#include <mutex>
+#include <string>
+
+namespace spdlog {
+
+// callbacks type
+typedef std::function<void(const details::log_msg &msg)> custom_log_callback;
+
+namespace sinks {
+/*
+ * Trivial callback sink, gets a callback function and calls it on each log
+ */
+template<typename Mutex>
+class callback_sink final : public base_sink<Mutex>
+{
+public:
+    explicit callback_sink(const custom_log_callback &callback)
+        : callback_{callback}
+    {}
+
+protected:
+    void sink_it_(const details::log_msg &msg) override
+    {
+        callback_(msg);
+    }
+    void flush_() override{};
+
+private:
+    custom_log_callback callback_;
+};
+
+using callback_sink_mt = callback_sink<std::mutex>;
+using callback_sink_st = callback_sink<details::null_mutex>;
+
+} // namespace sinks
+
+//
+// factory functions
+//
+template<typename Factory = spdlog::synchronous_factory>
+inline std::shared_ptr<logger> callback_logger_mt(const std::string &logger_name, const custom_log_callback &callback)
+{
+    return Factory::template create<sinks::callback_sink_mt>(logger_name, callback);
+}
+
+template<typename Factory = spdlog::synchronous_factory>
+inline std::shared_ptr<logger> callback_logger_st(const std::string &logger_name, const custom_log_callback &callback)
+{
+    return Factory::template create<sinks::callback_sink_st>(logger_name, callback);
+}
+
+} // namespace spdlog
diff --git a/3rdparty/spdlog/src/include/spdlog/sinks/daily_file_sink.h b/3rdparty/spdlog/src/include/spdlog/sinks/daily_file_sink.h
new file mode 100644
index 00000000..f6f1bb1d
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/sinks/daily_file_sink.h
@@ -0,0 +1,297 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#include <spdlog/common.h>
+#include <spdlog/details/file_helper.h>
+#include <spdlog/details/null_mutex.h>
+#include <spdlog/fmt/fmt.h>
+#include <spdlog/fmt/chrono.h>
+#include <spdlog/sinks/base_sink.h>
+#include <spdlog/details/os.h>
+#include <spdlog/details/circular_q.h>
+#include <spdlog/details/synchronous_factory.h>
+
+#include <chrono>
+#include <cstdio>
+#include <ctime>
+#include <mutex>
+#include <string>
+
+namespace spdlog {
+namespace sinks {
+
+/*
+ * Generator of daily log file names in format basename.YYYY-MM-DD.ext
+ */
+struct daily_filename_calculator
+{
+    // Create filename for the form basename.YYYY-MM-DD
+    static filename_t calc_filename(const filename_t &filename, const tm &now_tm)
+    {
+        filename_t basename, ext;
+        std::tie(basename, ext) = details::file_helper::split_by_extension(filename);
+        return fmt_lib::format(SPDLOG_FMT_STRING(SPDLOG_FILENAME_T("{}_{:04d}-{:02d}-{:02d}{}")), basename, now_tm.tm_year + 1900,
+            now_tm.tm_mon + 1, now_tm.tm_mday, ext);
+    }
+};
+
+/*
+ * Generator of daily log file names with strftime format.
+ * Usages:
+ *    auto sink =  std::make_shared<spdlog::sinks::daily_file_format_sink_mt>("myapp-%Y-%m-%d:%H:%M:%S.log", hour, minute);"
+ *    auto logger = spdlog::daily_logger_format_mt("loggername, "myapp-%Y-%m-%d:%X.log", hour,  minute)"
+ *
+ */
+struct daily_filename_format_calculator
+{
+    static filename_t calc_filename(const filename_t &filename, const tm &now_tm)
+    {
+#ifdef SPDLOG_USE_STD_FORMAT
+        // adapted from fmtlib: https://github.com/fmtlib/fmt/blob/8.0.1/include/fmt/chrono.h#L522-L546
+
+        filename_t tm_format;
+        tm_format.append(filename);
+        // By appending an extra space we can distinguish an empty result that
+        // indicates insufficient buffer size from a guaranteed non-empty result
+        // https://github.com/fmtlib/fmt/issues/2238
+        tm_format.push_back(' ');
+
+        const size_t MIN_SIZE = 10;
+        filename_t buf;
+        buf.resize(MIN_SIZE);
+        for (;;)
+        {
+            size_t count = strftime(buf.data(), buf.size(), tm_format.c_str(), &now_tm);
+            if (count != 0)
+            {
+                // Remove the extra space.
+                buf.resize(count - 1);
+                break;
+            }
+            buf.resize(buf.size() * 2);
+        }
+
+        return buf;
+#else
+        // generate fmt datetime format string, e.g. {:%Y-%m-%d}.
+        filename_t fmt_filename = fmt::format(SPDLOG_FMT_STRING(SPDLOG_FILENAME_T("{{:{}}}")), filename);
+
+        // MSVC doesn't allow fmt::runtime(..) with wchar, with fmtlib versions < 9.1.x
+#    if defined(_MSC_VER) && defined(SPDLOG_WCHAR_FILENAMES) && FMT_VERSION < 90101
+        return fmt::format(fmt_filename, now_tm);
+#    else
+        return fmt::format(SPDLOG_FMT_RUNTIME(fmt_filename), now_tm);
+#    endif
+
+#endif
+    }
+
+private:
+#if defined __GNUC__
+#    pragma GCC diagnostic push
+#    pragma GCC diagnostic ignored "-Wformat-nonliteral"
+#endif
+
+    static size_t strftime(char *str, size_t count, const char *format, const std::tm *time)
+    {
+        return std::strftime(str, count, format, time);
+    }
+
+    static size_t strftime(wchar_t *str, size_t count, const wchar_t *format, const std::tm *time)
+    {
+        return std::wcsftime(str, count, format, time);
+    }
+
+#if defined(__GNUC__)
+#    pragma GCC diagnostic pop
+#endif
+};
+
+/*
+ * Rotating file sink based on date.
+ * If truncate != false , the created file will be truncated.
+ * If max_files > 0, retain only the last max_files and delete previous.
+ */
+template<typename Mutex, typename FileNameCalc = daily_filename_calculator>
+class daily_file_sink final : public base_sink<Mutex>
+{
+public:
+    // create daily file sink which rotates on given time
+    daily_file_sink(filename_t base_filename, int rotation_hour, int rotation_minute, bool truncate = false, uint16_t max_files = 0,
+        const file_event_handlers &event_handlers = {})
+        : base_filename_(std::move(base_filename))
+        , rotation_h_(rotation_hour)
+        , rotation_m_(rotation_minute)
+        , file_helper_{event_handlers}
+        , truncate_(truncate)
+        , max_files_(max_files)
+        , filenames_q_()
+    {
+        if (rotation_hour < 0 || rotation_hour > 23 || rotation_minute < 0 || rotation_minute > 59)
+        {
+            throw_spdlog_ex("daily_file_sink: Invalid rotation time in ctor");
+        }
+
+        auto now = log_clock::now();
+        auto filename = FileNameCalc::calc_filename(base_filename_, now_tm(now));
+        file_helper_.open(filename, truncate_);
+        rotation_tp_ = next_rotation_tp_();
+
+        if (max_files_ > 0)
+        {
+            init_filenames_q_();
+        }
+    }
+
+    filename_t filename()
+    {
+        std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_);
+        return file_helper_.filename();
+    }
+
+protected:
+    void sink_it_(const details::log_msg &msg) override
+    {
+        auto time = msg.time;
+        bool should_rotate = time >= rotation_tp_;
+        if (should_rotate)
+        {
+            auto filename = FileNameCalc::calc_filename(base_filename_, now_tm(time));
+            file_helper_.open(filename, truncate_);
+            rotation_tp_ = next_rotation_tp_();
+        }
+        memory_buf_t formatted;
+        base_sink<Mutex>::formatter_->format(msg, formatted);
+        file_helper_.write(formatted);
+
+        // Do the cleaning only at the end because it might throw on failure.
+        if (should_rotate && max_files_ > 0)
+        {
+            delete_old_();
+        }
+    }
+
+    void flush_() override
+    {
+        file_helper_.flush();
+    }
+
+private:
+    void init_filenames_q_()
+    {
+        using details::os::path_exists;
+
+        filenames_q_ = details::circular_q<filename_t>(static_cast<size_t>(max_files_));
+        std::vector<filename_t> filenames;
+        auto now = log_clock::now();
+        while (filenames.size() < max_files_)
+        {
+            auto filename = FileNameCalc::calc_filename(base_filename_, now_tm(now));
+            if (!path_exists(filename))
+            {
+                break;
+            }
+            filenames.emplace_back(filename);
+            now -= std::chrono::hours(24);
+        }
+        for (auto iter = filenames.rbegin(); iter != filenames.rend(); ++iter)
+        {
+            filenames_q_.push_back(std::move(*iter));
+        }
+    }
+
+    tm now_tm(log_clock::time_point tp)
+    {
+        time_t tnow = log_clock::to_time_t(tp);
+        return spdlog::details::os::localtime(tnow);
+    }
+
+    log_clock::time_point next_rotation_tp_()
+    {
+        auto now = log_clock::now();
+        tm date = now_tm(now);
+        date.tm_hour = rotation_h_;
+        date.tm_min = rotation_m_;
+        date.tm_sec = 0;
+        auto rotation_time = log_clock::from_time_t(std::mktime(&date));
+        if (rotation_time > now)
+        {
+            return rotation_time;
+        }
+        return {rotation_time + std::chrono::hours(24)};
+    }
+
+    // Delete the file N rotations ago.
+    // Throw spdlog_ex on failure to delete the old file.
+    void delete_old_()
+    {
+        using details::os::filename_to_str;
+        using details::os::remove_if_exists;
+
+        filename_t current_file = file_helper_.filename();
+        if (filenames_q_.full())
+        {
+            auto old_filename = std::move(filenames_q_.front());
+            filenames_q_.pop_front();
+            bool ok = remove_if_exists(old_filename) == 0;
+            if (!ok)
+            {
+                filenames_q_.push_back(std::move(current_file));
+                throw_spdlog_ex("Failed removing daily file " + filename_to_str(old_filename), errno);
+            }
+        }
+        filenames_q_.push_back(std::move(current_file));
+    }
+
+    filename_t base_filename_;
+    int rotation_h_;
+    int rotation_m_;
+    log_clock::time_point rotation_tp_;
+    details::file_helper file_helper_;
+    bool truncate_;
+    uint16_t max_files_;
+    details::circular_q<filename_t> filenames_q_;
+};
+
+using daily_file_sink_mt = daily_file_sink<std::mutex>;
+using daily_file_sink_st = daily_file_sink<details::null_mutex>;
+using daily_file_format_sink_mt = daily_file_sink<std::mutex, daily_filename_format_calculator>;
+using daily_file_format_sink_st = daily_file_sink<details::null_mutex, daily_filename_format_calculator>;
+
+} // namespace sinks
+
+//
+// factory functions
+//
+template<typename Factory = spdlog::synchronous_factory>
+inline std::shared_ptr<logger> daily_logger_mt(const std::string &logger_name, const filename_t &filename, int hour = 0, int minute = 0,
+    bool truncate = false, uint16_t max_files = 0, const file_event_handlers &event_handlers = {})
+{
+    return Factory::template create<sinks::daily_file_sink_mt>(logger_name, filename, hour, minute, truncate, max_files, event_handlers);
+}
+
+template<typename Factory = spdlog::synchronous_factory>
+inline std::shared_ptr<logger> daily_logger_format_mt(const std::string &logger_name, const filename_t &filename, int hour = 0,
+    int minute = 0, bool truncate = false, uint16_t max_files = 0, const file_event_handlers &event_handlers = {})
+{
+    return Factory::template create<sinks::daily_file_format_sink_mt>(
+        logger_name, filename, hour, minute, truncate, max_files, event_handlers);
+}
+
+template<typename Factory = spdlog::synchronous_factory>
+inline std::shared_ptr<logger> daily_logger_st(const std::string &logger_name, const filename_t &filename, int hour = 0, int minute = 0,
+    bool truncate = false, uint16_t max_files = 0, const file_event_handlers &event_handlers = {})
+{
+    return Factory::template create<sinks::daily_file_sink_st>(logger_name, filename, hour, minute, truncate, max_files, event_handlers);
+}
+
+template<typename Factory = spdlog::synchronous_factory>
+inline std::shared_ptr<logger> daily_logger_format_st(const std::string &logger_name, const filename_t &filename, int hour = 0,
+    int minute = 0, bool truncate = false, uint16_t max_files = 0, const file_event_handlers &event_handlers = {})
+{
+    return Factory::template create<sinks::daily_file_format_sink_st>(
+        logger_name, filename, hour, minute, truncate, max_files, event_handlers);
+}
+} // namespace spdlog
diff --git a/3rdparty/spdlog/src/include/spdlog/sinks/dist_sink.h b/3rdparty/spdlog/src/include/spdlog/sinks/dist_sink.h
new file mode 100644
index 00000000..7ec3a2ec
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/sinks/dist_sink.h
@@ -0,0 +1,97 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#include "base_sink.h"
+#include <spdlog/details/log_msg.h>
+#include <spdlog/details/null_mutex.h>
+#include <spdlog/pattern_formatter.h>
+
+#include <algorithm>
+#include <memory>
+#include <mutex>
+#include <vector>
+
+// Distribution sink (mux). Stores a vector of sinks which get called when log
+// is called
+
+namespace spdlog {
+namespace sinks {
+
+template<typename Mutex>
+class dist_sink : public base_sink<Mutex>
+{
+public:
+    dist_sink() = default;
+    explicit dist_sink(std::vector<std::shared_ptr<sink>> sinks)
+        : sinks_(sinks)
+    {}
+
+    dist_sink(const dist_sink &) = delete;
+    dist_sink &operator=(const dist_sink &) = delete;
+
+    void add_sink(std::shared_ptr<sink> sub_sink)
+    {
+        std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_);
+        sinks_.push_back(sub_sink);
+    }
+
+    void remove_sink(std::shared_ptr<sink> sub_sink)
+    {
+        std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_);
+        sinks_.erase(std::remove(sinks_.begin(), sinks_.end(), sub_sink), sinks_.end());
+    }
+
+    void set_sinks(std::vector<std::shared_ptr<sink>> sinks)
+    {
+        std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_);
+        sinks_ = std::move(sinks);
+    }
+
+    std::vector<std::shared_ptr<sink>> &sinks()
+    {
+        return sinks_;
+    }
+
+protected:
+    void sink_it_(const details::log_msg &msg) override
+    {
+        for (auto &sub_sink : sinks_)
+        {
+            if (sub_sink->should_log(msg.level))
+            {
+                sub_sink->log(msg);
+            }
+        }
+    }
+
+    void flush_() override
+    {
+        for (auto &sub_sink : sinks_)
+        {
+            sub_sink->flush();
+        }
+    }
+
+    void set_pattern_(const std::string &pattern) override
+    {
+        set_formatter_(details::make_unique<spdlog::pattern_formatter>(pattern));
+    }
+
+    void set_formatter_(std::unique_ptr<spdlog::formatter> sink_formatter) override
+    {
+        base_sink<Mutex>::formatter_ = std::move(sink_formatter);
+        for (auto &sub_sink : sinks_)
+        {
+            sub_sink->set_formatter(base_sink<Mutex>::formatter_->clone());
+        }
+    }
+    std::vector<std::shared_ptr<sink>> sinks_;
+};
+
+using dist_sink_mt = dist_sink<std::mutex>;
+using dist_sink_st = dist_sink<details::null_mutex>;
+
+} // namespace sinks
+} // namespace spdlog
diff --git a/3rdparty/spdlog/src/include/spdlog/sinks/dup_filter_sink.h b/3rdparty/spdlog/src/include/spdlog/sinks/dup_filter_sink.h
new file mode 100644
index 00000000..3c96549c
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/sinks/dup_filter_sink.h
@@ -0,0 +1,96 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#include "dist_sink.h"
+#include <spdlog/details/null_mutex.h>
+#include <spdlog/details/log_msg.h>
+
+#include <cstdio>
+#include <mutex>
+#include <string>
+#include <chrono>
+
+// Duplicate message removal sink.
+// Skip the message if previous one is identical and less than "max_skip_duration" have passed
+//
+// Example:
+//
+//     #include <spdlog/sinks/dup_filter_sink.h>
+//
+//     int main() {
+//         auto dup_filter = std::make_shared<dup_filter_sink_st>(std::chrono::seconds(5), level::info);
+//         dup_filter->add_sink(std::make_shared<stdout_color_sink_mt>());
+//         spdlog::logger l("logger", dup_filter);
+//         l.info("Hello");
+//         l.info("Hello");
+//         l.info("Hello");
+//         l.info("Different Hello");
+//     }
+//
+// Will produce:
+//       [2019-06-25 17:50:56.511] [logger] [info] Hello
+//       [2019-06-25 17:50:56.512] [logger] [info] Skipped 3 duplicate messages..
+//       [2019-06-25 17:50:56.512] [logger] [info] Different Hello
+
+namespace spdlog {
+namespace sinks {
+template<typename Mutex>
+class dup_filter_sink : public dist_sink<Mutex>
+{
+public:
+    template<class Rep, class Period>
+    explicit dup_filter_sink(std::chrono::duration<Rep, Period> max_skip_duration, level::level_enum notification_level = level::info)
+        : max_skip_duration_{max_skip_duration}
+        , log_level_{notification_level}
+    {}
+
+protected:
+    std::chrono::microseconds max_skip_duration_;
+    log_clock::time_point last_msg_time_;
+    std::string last_msg_payload_;
+    size_t skip_counter_ = 0;
+    level::level_enum log_level_;
+
+    void sink_it_(const details::log_msg &msg) override
+    {
+        bool filtered = filter_(msg);
+        if (!filtered)
+        {
+            skip_counter_ += 1;
+            return;
+        }
+
+        // log the "skipped.." message
+        if (skip_counter_ > 0)
+        {
+            char buf[64];
+            auto msg_size = ::snprintf(buf, sizeof(buf), "Skipped %u duplicate messages..", static_cast<unsigned>(skip_counter_));
+            if (msg_size > 0 && static_cast<size_t>(msg_size) < sizeof(buf))
+            {
+                details::log_msg skipped_msg{msg.source, msg.logger_name, log_level_, string_view_t{buf, static_cast<size_t>(msg_size)}};
+                dist_sink<Mutex>::sink_it_(skipped_msg);
+            }
+        }
+
+        // log current message
+        dist_sink<Mutex>::sink_it_(msg);
+        last_msg_time_ = msg.time;
+        skip_counter_ = 0;
+        last_msg_payload_.assign(msg.payload.data(), msg.payload.data() + msg.payload.size());
+    }
+
+    // return whether the log msg should be displayed (true) or skipped (false)
+    bool filter_(const details::log_msg &msg)
+    {
+        auto filter_duration = msg.time - last_msg_time_;
+        return (filter_duration > max_skip_duration_) || (msg.payload != last_msg_payload_);
+    }
+};
+
+using dup_filter_sink_mt = dup_filter_sink<std::mutex>;
+using dup_filter_sink_st = dup_filter_sink<details::null_mutex>;
+
+} // namespace sinks
+} // namespace spdlog
diff --git a/3rdparty/spdlog/src/include/spdlog/sinks/hourly_file_sink.h b/3rdparty/spdlog/src/include/spdlog/sinks/hourly_file_sink.h
new file mode 100644
index 00000000..33dd8948
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/sinks/hourly_file_sink.h
@@ -0,0 +1,204 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#include <spdlog/common.h>
+#include <spdlog/details/file_helper.h>
+#include <spdlog/details/null_mutex.h>
+#include <spdlog/fmt/fmt.h>
+#include <spdlog/sinks/base_sink.h>
+#include <spdlog/details/os.h>
+#include <spdlog/details/circular_q.h>
+#include <spdlog/details/synchronous_factory.h>
+
+#include <chrono>
+#include <cstdio>
+#include <ctime>
+#include <mutex>
+#include <string>
+
+namespace spdlog {
+namespace sinks {
+
+/*
+ * Generator of Hourly log file names in format basename.YYYY-MM-DD-HH.ext
+ */
+struct hourly_filename_calculator
+{
+    // Create filename for the form basename.YYYY-MM-DD-H
+    static filename_t calc_filename(const filename_t &filename, const tm &now_tm)
+    {
+        filename_t basename, ext;
+        std::tie(basename, ext) = details::file_helper::split_by_extension(filename);
+        return fmt_lib::format(SPDLOG_FILENAME_T("{}_{:04d}-{:02d}-{:02d}_{:02d}{}"), basename, now_tm.tm_year + 1900, now_tm.tm_mon + 1,
+            now_tm.tm_mday, now_tm.tm_hour, ext);
+    }
+};
+
+/*
+ * Rotating file sink based on time.
+ * If truncate != false , the created file will be truncated.
+ * If max_files > 0, retain only the last max_files and delete previous.
+ */
+template<typename Mutex, typename FileNameCalc = hourly_filename_calculator>
+class hourly_file_sink final : public base_sink<Mutex>
+{
+public:
+    // create hourly file sink which rotates on given time
+    hourly_file_sink(
+        filename_t base_filename, bool truncate = false, uint16_t max_files = 0, const file_event_handlers &event_handlers = {})
+        : base_filename_(std::move(base_filename))
+        , file_helper_{event_handlers}
+        , truncate_(truncate)
+        , max_files_(max_files)
+        , filenames_q_()
+    {
+        auto now = log_clock::now();
+        auto filename = FileNameCalc::calc_filename(base_filename_, now_tm(now));
+        file_helper_.open(filename, truncate_);
+        remove_init_file_ = file_helper_.size() == 0;
+        rotation_tp_ = next_rotation_tp_();
+
+        if (max_files_ > 0)
+        {
+            init_filenames_q_();
+        }
+    }
+
+    filename_t filename()
+    {
+        std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_);
+        return file_helper_.filename();
+    }
+
+protected:
+    void sink_it_(const details::log_msg &msg) override
+    {
+        auto time = msg.time;
+        bool should_rotate = time >= rotation_tp_;
+        if (should_rotate)
+        {
+            if (remove_init_file_)
+            {
+                file_helper_.close();
+                details::os::remove(file_helper_.filename());
+            }
+            auto filename = FileNameCalc::calc_filename(base_filename_, now_tm(time));
+            file_helper_.open(filename, truncate_);
+            rotation_tp_ = next_rotation_tp_();
+        }
+        remove_init_file_ = false;
+        memory_buf_t formatted;
+        base_sink<Mutex>::formatter_->format(msg, formatted);
+        file_helper_.write(formatted);
+
+        // Do the cleaning only at the end because it might throw on failure.
+        if (should_rotate && max_files_ > 0)
+        {
+            delete_old_();
+        }
+    }
+
+    void flush_() override
+    {
+        file_helper_.flush();
+    }
+
+private:
+    void init_filenames_q_()
+    {
+        using details::os::path_exists;
+
+        filenames_q_ = details::circular_q<filename_t>(static_cast<size_t>(max_files_));
+        std::vector<filename_t> filenames;
+        auto now = log_clock::now();
+        while (filenames.size() < max_files_)
+        {
+            auto filename = FileNameCalc::calc_filename(base_filename_, now_tm(now));
+            if (!path_exists(filename))
+            {
+                break;
+            }
+            filenames.emplace_back(filename);
+            now -= std::chrono::hours(1);
+        }
+        for (auto iter = filenames.rbegin(); iter != filenames.rend(); ++iter)
+        {
+            filenames_q_.push_back(std::move(*iter));
+        }
+    }
+
+    tm now_tm(log_clock::time_point tp)
+    {
+        time_t tnow = log_clock::to_time_t(tp);
+        return spdlog::details::os::localtime(tnow);
+    }
+
+    log_clock::time_point next_rotation_tp_()
+    {
+        auto now = log_clock::now();
+        tm date = now_tm(now);
+        date.tm_min = 0;
+        date.tm_sec = 0;
+        auto rotation_time = log_clock::from_time_t(std::mktime(&date));
+        if (rotation_time > now)
+        {
+            return rotation_time;
+        }
+        return {rotation_time + std::chrono::hours(1)};
+    }
+
+    // Delete the file N rotations ago.
+    // Throw spdlog_ex on failure to delete the old file.
+    void delete_old_()
+    {
+        using details::os::filename_to_str;
+        using details::os::remove_if_exists;
+
+        filename_t current_file = file_helper_.filename();
+        if (filenames_q_.full())
+        {
+            auto old_filename = std::move(filenames_q_.front());
+            filenames_q_.pop_front();
+            bool ok = remove_if_exists(old_filename) == 0;
+            if (!ok)
+            {
+                filenames_q_.push_back(std::move(current_file));
+                SPDLOG_THROW(spdlog_ex("Failed removing hourly file " + filename_to_str(old_filename), errno));
+            }
+        }
+        filenames_q_.push_back(std::move(current_file));
+    }
+
+    filename_t base_filename_;
+    log_clock::time_point rotation_tp_;
+    details::file_helper file_helper_;
+    bool truncate_;
+    uint16_t max_files_;
+    details::circular_q<filename_t> filenames_q_;
+    bool remove_init_file_;
+};
+
+using hourly_file_sink_mt = hourly_file_sink<std::mutex>;
+using hourly_file_sink_st = hourly_file_sink<details::null_mutex>;
+
+} // namespace sinks
+
+//
+// factory functions
+//
+template<typename Factory = spdlog::synchronous_factory>
+inline std::shared_ptr<logger> hourly_logger_mt(const std::string &logger_name, const filename_t &filename, bool truncate = false,
+    uint16_t max_files = 0, const file_event_handlers &event_handlers = {})
+{
+    return Factory::template create<sinks::hourly_file_sink_mt>(logger_name, filename, truncate, max_files, event_handlers);
+}
+
+template<typename Factory = spdlog::synchronous_factory>
+inline std::shared_ptr<logger> hourly_logger_st(const std::string &logger_name, const filename_t &filename, bool truncate = false,
+    uint16_t max_files = 0, const file_event_handlers &event_handlers = {})
+{
+    return Factory::template create<sinks::hourly_file_sink_st>(logger_name, filename, truncate, max_files, event_handlers);
+}
+} // namespace spdlog
diff --git a/3rdparty/spdlog/src/include/spdlog/sinks/kafka_sink.h b/3rdparty/spdlog/src/include/spdlog/sinks/kafka_sink.h
new file mode 100644
index 00000000..ce740efc
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/sinks/kafka_sink.h
@@ -0,0 +1,133 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+//
+// Custom sink for kafka
+// Building and using requires librdkafka library.
+// For building librdkafka library check the url below
+// https://github.com/confluentinc/librdkafka
+//
+
+#include <spdlog/common.h>
+#include "spdlog/details/log_msg.h"
+#include "spdlog/sinks/base_sink.h"
+#include "spdlog/details/synchronous_factory.h"
+#include "spdlog/details/null_mutex.h"
+#include "spdlog/async.h"
+#include <mutex>
+
+// kafka header
+#include <librdkafka/rdkafkacpp.h>
+
+namespace spdlog {
+namespace sinks {
+
+struct kafka_sink_config
+{
+    std::string server_addr;
+    std::string produce_topic;
+    int32_t flush_timeout_ms = 1000;
+
+    kafka_sink_config(std::string addr, std::string topic, int flush_timeout_ms = 1000)
+        : server_addr{std::move(addr)}
+        , produce_topic{std::move(topic)}
+        , flush_timeout_ms(flush_timeout_ms)
+    {}
+};
+
+template<typename Mutex>
+class kafka_sink : public base_sink<Mutex>
+{
+public:
+    kafka_sink(kafka_sink_config config)
+        : config_{std::move(config)}
+    {
+        try
+        {
+            std::string errstr;
+            conf_.reset(RdKafka::Conf::create(RdKafka::Conf::CONF_GLOBAL));
+            RdKafka::Conf::ConfResult confRes = conf_->set("bootstrap.servers", config_.server_addr, errstr);
+            if (confRes != RdKafka::Conf::CONF_OK)
+            {
+                throw_spdlog_ex(fmt_lib::format("conf set bootstrap.servers failed err:{}", errstr));
+            }
+
+            tconf_.reset(RdKafka::Conf::create(RdKafka::Conf::CONF_TOPIC));
+            if (tconf_ == nullptr)
+            {
+                throw_spdlog_ex(fmt_lib::format("create topic config failed"));
+            }
+
+            producer_.reset(RdKafka::Producer::create(conf_.get(), errstr));
+            if (producer_ == nullptr)
+            {
+                throw_spdlog_ex(fmt_lib::format("create producer failed err:{}", errstr));
+            }
+            topic_.reset(RdKafka::Topic::create(producer_.get(), config_.produce_topic, tconf_.get(), errstr));
+            if (topic_ == nullptr)
+            {
+                throw_spdlog_ex(fmt_lib::format("create topic failed err:{}", errstr));
+            }
+        }
+        catch (const std::exception &e)
+        {
+            throw_spdlog_ex(fmt_lib::format("error create kafka instance: {}", e.what()));
+        }
+    }
+
+    ~kafka_sink()
+    {
+        producer_->flush(config_.flush_timeout_ms);
+    }
+
+protected:
+    void sink_it_(const details::log_msg &msg) override
+    {
+        producer_->produce(topic_.get(), 0, RdKafka::Producer::RK_MSG_COPY, (void *)msg.payload.data(), msg.payload.size(), NULL, NULL);
+    }
+
+    void flush_() override
+    {
+        producer_->flush(config_.flush_timeout_ms);
+    }
+
+private:
+    kafka_sink_config config_;
+    std::unique_ptr<RdKafka::Producer> producer_ = nullptr;
+    std::unique_ptr<RdKafka::Conf> conf_ = nullptr;
+    std::unique_ptr<RdKafka::Conf> tconf_ = nullptr;
+    std::unique_ptr<RdKafka::Topic> topic_ = nullptr;
+};
+
+using kafka_sink_mt = kafka_sink<std::mutex>;
+using kafka_sink_st = kafka_sink<spdlog::details::null_mutex>;
+
+} // namespace sinks
+
+template<typename Factory = spdlog::synchronous_factory>
+inline std::shared_ptr<logger> kafka_logger_mt(const std::string &logger_name, spdlog::sinks::kafka_sink_config config)
+{
+    return Factory::template create<sinks::kafka_sink_mt>(logger_name, config);
+}
+
+template<typename Factory = spdlog::synchronous_factory>
+inline std::shared_ptr<logger> kafka_logger_st(const std::string &logger_name, spdlog::sinks::kafka_sink_config config)
+{
+    return Factory::template create<sinks::kafka_sink_st>(logger_name, config);
+}
+
+template<typename Factory = spdlog::async_factory>
+inline std::shared_ptr<spdlog::logger> kafka_logger_async_mt(std::string logger_name, spdlog::sinks::kafka_sink_config config)
+{
+    return Factory::template create<sinks::kafka_sink_mt>(logger_name, config);
+}
+
+template<typename Factory = spdlog::async_factory>
+inline std::shared_ptr<spdlog::logger> kafka_logger_async_st(std::string logger_name, spdlog::sinks::kafka_sink_config config)
+{
+    return Factory::template create<sinks::kafka_sink_st>(logger_name, config);
+}
+
+} // namespace spdlog
diff --git a/3rdparty/spdlog/src/include/spdlog/sinks/mongo_sink.h b/3rdparty/spdlog/src/include/spdlog/sinks/mongo_sink.h
new file mode 100644
index 00000000..6a8927f5
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/sinks/mongo_sink.h
@@ -0,0 +1,107 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+//
+// Custom sink for mongodb
+// Building and using requires mongocxx library.
+// For building mongocxx library check the url below
+// http://mongocxx.org/mongocxx-v3/installation/
+//
+
+#include "spdlog/common.h"
+#include "spdlog/details/log_msg.h"
+#include "spdlog/sinks/base_sink.h"
+#include <spdlog/details/synchronous_factory.h>
+
+#include <bsoncxx/builder/stream/document.hpp>
+#include <bsoncxx/types.hpp>
+#include <bsoncxx/view_or_value.hpp>
+
+#include <mongocxx/client.hpp>
+#include <mongocxx/instance.hpp>
+#include <mongocxx/uri.hpp>
+
+namespace spdlog {
+namespace sinks {
+template<typename Mutex>
+class mongo_sink : public base_sink<Mutex>
+{
+public:
+    mongo_sink(const std::string &db_name, const std::string &collection_name, const std::string &uri = "mongodb://localhost:27017")
+    try : mongo_sink(std::make_shared<mongocxx::instance>(), db_name, collection_name, uri)
+    {}
+    catch (const std::exception &e)
+    {
+        throw_spdlog_ex(fmt_lib::format("Error opening database: {}", e.what()));
+    }
+
+    mongo_sink(std::shared_ptr<mongocxx::instance> instance, const std::string &db_name, const std::string &collection_name,
+        const std::string &uri = "mongodb://localhost:27017")
+        : instance_(std::move(instance))
+        , db_name_(db_name)
+        , coll_name_(collection_name)
+    {
+        try
+        {
+            client_ = spdlog::details::make_unique<mongocxx::client>(mongocxx::uri{uri});
+        }
+        catch (const std::exception &e)
+        {
+            throw_spdlog_ex(fmt_lib::format("Error opening database: {}", e.what()));
+        }
+    }
+
+    ~mongo_sink()
+    {
+        flush_();
+    }
+
+protected:
+    void sink_it_(const details::log_msg &msg) override
+    {
+        using bsoncxx::builder::stream::document;
+        using bsoncxx::builder::stream::finalize;
+
+        if (client_ != nullptr)
+        {
+            auto doc = document{} << "timestamp" << bsoncxx::types::b_date(msg.time) << "level" << level::to_string_view(msg.level).data()
+                                  << "level_num" << msg.level << "message" << std::string(msg.payload.begin(), msg.payload.end())
+                                  << "logger_name" << std::string(msg.logger_name.begin(), msg.logger_name.end()) << "thread_id"
+                                  << static_cast<int>(msg.thread_id) << finalize;
+            client_->database(db_name_).collection(coll_name_).insert_one(doc.view());
+        }
+    }
+
+    void flush_() override {}
+
+private:
+    std::shared_ptr<mongocxx::instance> instance_;
+    std::string db_name_;
+    std::string coll_name_;
+    std::unique_ptr<mongocxx::client> client_ = nullptr;
+};
+
+#include "spdlog/details/null_mutex.h"
+#include <mutex>
+using mongo_sink_mt = mongo_sink<std::mutex>;
+using mongo_sink_st = mongo_sink<spdlog::details::null_mutex>;
+
+} // namespace sinks
+
+template<typename Factory = spdlog::synchronous_factory>
+inline std::shared_ptr<logger> mongo_logger_mt(const std::string &logger_name, const std::string &db_name,
+    const std::string &collection_name, const std::string &uri = "mongodb://localhost:27017")
+{
+    return Factory::template create<sinks::mongo_sink_mt>(logger_name, db_name, collection_name, uri);
+}
+
+template<typename Factory = spdlog::synchronous_factory>
+inline std::shared_ptr<logger> mongo_logger_st(const std::string &logger_name, const std::string &db_name,
+    const std::string &collection_name, const std::string &uri = "mongodb://localhost:27017")
+{
+    return Factory::template create<sinks::mongo_sink_st>(logger_name, db_name, collection_name, uri);
+}
+
+} // namespace spdlog
diff --git a/3rdparty/spdlog/src/include/spdlog/sinks/msvc_sink.h b/3rdparty/spdlog/src/include/spdlog/sinks/msvc_sink.h
new file mode 100644
index 00000000..bf68ae88
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/sinks/msvc_sink.h
@@ -0,0 +1,71 @@
+// Copyright(c) 2016 Alexander Dalshov & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#if defined(_WIN32)
+
+#    include <spdlog/details/null_mutex.h>
+#    if defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT)
+#        include <spdlog/details/os.h>
+#    endif
+#    include <spdlog/sinks/base_sink.h>
+
+#    include <mutex>
+#    include <string>
+
+// Avoid including windows.h (https://stackoverflow.com/a/30741042)
+#    if defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT)
+extern "C" __declspec(dllimport) void __stdcall OutputDebugStringW(const wchar_t *lpOutputString);
+#    else
+extern "C" __declspec(dllimport) void __stdcall OutputDebugStringA(const char *lpOutputString);
+#    endif
+extern "C" __declspec(dllimport) int __stdcall IsDebuggerPresent();
+
+namespace spdlog {
+namespace sinks {
+/*
+ * MSVC sink (logging using OutputDebugStringA)
+ */
+template<typename Mutex>
+class msvc_sink : public base_sink<Mutex>
+{
+public:
+    msvc_sink() = default;
+    msvc_sink(bool check_debugger_present)
+        : check_debugger_present_{check_debugger_present} {};
+
+protected:
+    void sink_it_(const details::log_msg &msg) override
+    {
+        if (check_debugger_present_ && !IsDebuggerPresent())
+        {
+            return;
+        }
+        memory_buf_t formatted;
+        base_sink<Mutex>::formatter_->format(msg, formatted);
+        formatted.push_back('\0'); // add a null terminator for OutputDebugString
+#    if defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT)
+        wmemory_buf_t wformatted;
+        details::os::utf8_to_wstrbuf(string_view_t(formatted.data(), formatted.size()), wformatted);
+        OutputDebugStringW(wformatted.data());
+#    else
+        OutputDebugStringA(formatted.data());
+#    endif
+    }
+
+    void flush_() override {}
+
+    bool check_debugger_present_ = true;
+};
+
+using msvc_sink_mt = msvc_sink<std::mutex>;
+using msvc_sink_st = msvc_sink<details::null_mutex>;
+
+using windebug_sink_mt = msvc_sink_mt;
+using windebug_sink_st = msvc_sink_st;
+
+} // namespace sinks
+} // namespace spdlog
+
+#endif
diff --git a/3rdparty/spdlog/src/include/spdlog/sinks/null_sink.h b/3rdparty/spdlog/src/include/spdlog/sinks/null_sink.h
new file mode 100644
index 00000000..eb832801
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/sinks/null_sink.h
@@ -0,0 +1,44 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#include <spdlog/details/null_mutex.h>
+#include <spdlog/sinks/base_sink.h>
+#include <spdlog/details/synchronous_factory.h>
+
+#include <mutex>
+
+namespace spdlog {
+namespace sinks {
+
+template<typename Mutex>
+class null_sink : public base_sink<Mutex>
+{
+protected:
+    void sink_it_(const details::log_msg &) override {}
+    void flush_() override {}
+};
+
+using null_sink_mt = null_sink<details::null_mutex>;
+using null_sink_st = null_sink<details::null_mutex>;
+
+} // namespace sinks
+
+template<typename Factory = spdlog::synchronous_factory>
+inline std::shared_ptr<logger> null_logger_mt(const std::string &logger_name)
+{
+    auto null_logger = Factory::template create<sinks::null_sink_mt>(logger_name);
+    null_logger->set_level(level::off);
+    return null_logger;
+}
+
+template<typename Factory = spdlog::synchronous_factory>
+inline std::shared_ptr<logger> null_logger_st(const std::string &logger_name)
+{
+    auto null_logger = Factory::template create<sinks::null_sink_st>(logger_name);
+    null_logger->set_level(level::off);
+    return null_logger;
+}
+
+} // namespace spdlog
diff --git a/3rdparty/spdlog/src/include/spdlog/sinks/ostream_sink.h b/3rdparty/spdlog/src/include/spdlog/sinks/ostream_sink.h
new file mode 100644
index 00000000..95c1e962
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/sinks/ostream_sink.h
@@ -0,0 +1,50 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#include <spdlog/details/null_mutex.h>
+#include <spdlog/sinks/base_sink.h>
+
+#include <mutex>
+#include <ostream>
+
+namespace spdlog {
+namespace sinks {
+template<typename Mutex>
+class ostream_sink final : public base_sink<Mutex>
+{
+public:
+    explicit ostream_sink(std::ostream &os, bool force_flush = false)
+        : ostream_(os)
+        , force_flush_(force_flush)
+    {}
+    ostream_sink(const ostream_sink &) = delete;
+    ostream_sink &operator=(const ostream_sink &) = delete;
+
+protected:
+    void sink_it_(const details::log_msg &msg) override
+    {
+        memory_buf_t formatted;
+        base_sink<Mutex>::formatter_->format(msg, formatted);
+        ostream_.write(formatted.data(), static_cast<std::streamsize>(formatted.size()));
+        if (force_flush_)
+        {
+            ostream_.flush();
+        }
+    }
+
+    void flush_() override
+    {
+        ostream_.flush();
+    }
+
+    std::ostream &ostream_;
+    bool force_flush_;
+};
+
+using ostream_sink_mt = ostream_sink<std::mutex>;
+using ostream_sink_st = ostream_sink<details::null_mutex>;
+
+} // namespace sinks
+} // namespace spdlog
diff --git a/3rdparty/spdlog/src/include/spdlog/sinks/qt_sinks.h b/3rdparty/spdlog/src/include/spdlog/sinks/qt_sinks.h
new file mode 100644
index 00000000..31b49c60
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/sinks/qt_sinks.h
@@ -0,0 +1,102 @@
+// Copyright(c) 2015-present, Gabi Melman, mguludag and spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+//
+// Custom sink for QPlainTextEdit or QTextEdit and its childs(QTextBrowser...
+// etc) Building and using requires Qt library.
+//
+
+#include "spdlog/common.h"
+#include "spdlog/details/log_msg.h"
+#include "spdlog/details/synchronous_factory.h"
+#include "spdlog/sinks/base_sink.h"
+
+#include <QTextEdit>
+#include <QPlainTextEdit>
+
+//
+// qt_sink class
+//
+namespace spdlog {
+namespace sinks {
+template<typename Mutex>
+class qt_sink : public base_sink<Mutex>
+{
+public:
+    qt_sink(QObject *qt_object, const std::string &meta_method)
+    {
+        qt_object_ = qt_object;
+        meta_method_ = meta_method;
+    }
+
+    ~qt_sink()
+    {
+        flush_();
+    }
+
+protected:
+    void sink_it_(const details::log_msg &msg) override
+    {
+        memory_buf_t formatted;
+        base_sink<Mutex>::formatter_->format(msg, formatted);
+        string_view_t str = string_view_t(formatted.data(), formatted.size());
+        QMetaObject::invokeMethod(qt_object_, meta_method_.c_str(), Qt::AutoConnection,
+            Q_ARG(QString, QString::fromUtf8(str.data(), static_cast<int>(str.size())).trimmed()));
+    }
+
+    void flush_() override {}
+
+private:
+    QObject *qt_object_ = nullptr;
+    std::string meta_method_;
+};
+
+#include "spdlog/details/null_mutex.h"
+#include <mutex>
+using qt_sink_mt = qt_sink<std::mutex>;
+using qt_sink_st = qt_sink<spdlog::details::null_mutex>;
+} // namespace sinks
+
+//
+// Factory functions
+//
+template<typename Factory = spdlog::synchronous_factory>
+inline std::shared_ptr<logger> qt_logger_mt(const std::string &logger_name, QTextEdit *qt_object, const std::string &meta_method = "append")
+{
+    return Factory::template create<sinks::qt_sink_mt>(logger_name, qt_object, meta_method);
+}
+
+template<typename Factory = spdlog::synchronous_factory>
+inline std::shared_ptr<logger> qt_logger_st(const std::string &logger_name, QTextEdit *qt_object, const std::string &meta_method = "append")
+{
+    return Factory::template create<sinks::qt_sink_st>(logger_name, qt_object, meta_method);
+}
+
+template<typename Factory = spdlog::synchronous_factory>
+inline std::shared_ptr<logger> qt_logger_mt(
+    const std::string &logger_name, QPlainTextEdit *qt_object, const std::string &meta_method = "appendPlainText")
+{
+    return Factory::template create<sinks::qt_sink_mt>(logger_name, qt_object, meta_method);
+}
+
+template<typename Factory = spdlog::synchronous_factory>
+inline std::shared_ptr<logger> qt_logger_st(
+    const std::string &logger_name, QPlainTextEdit *qt_object, const std::string &meta_method = "appendPlainText")
+{
+    return Factory::template create<sinks::qt_sink_st>(logger_name, qt_object, meta_method);
+}
+
+template<typename Factory = spdlog::synchronous_factory>
+inline std::shared_ptr<logger> qt_logger_mt(const std::string &logger_name, QObject *qt_object, const std::string &meta_method)
+{
+    return Factory::template create<sinks::qt_sink_mt>(logger_name, qt_object, meta_method);
+}
+
+template<typename Factory = spdlog::synchronous_factory>
+inline std::shared_ptr<logger> qt_logger_st(const std::string &logger_name, QObject *qt_object, const std::string &meta_method)
+{
+    return Factory::template create<sinks::qt_sink_st>(logger_name, qt_object, meta_method);
+}
+} // namespace spdlog
diff --git a/3rdparty/spdlog/src/include/spdlog/sinks/ringbuffer_sink.h b/3rdparty/spdlog/src/include/spdlog/sinks/ringbuffer_sink.h
new file mode 100644
index 00000000..3ca47c6f
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/sinks/ringbuffer_sink.h
@@ -0,0 +1,74 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#include "spdlog/sinks/base_sink.h"
+#include "spdlog/details/circular_q.h"
+#include "spdlog/details/log_msg_buffer.h"
+#include "spdlog/details/null_mutex.h"
+
+#include <mutex>
+#include <string>
+#include <vector>
+
+namespace spdlog {
+namespace sinks {
+/*
+ * Ring buffer sink
+ */
+template<typename Mutex>
+class ringbuffer_sink final : public base_sink<Mutex>
+{
+public:
+    explicit ringbuffer_sink(size_t n_items)
+        : q_{n_items}
+    {}
+
+    std::vector<details::log_msg_buffer> last_raw(size_t lim = 0)
+    {
+        std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_);
+        auto items_available = q_.size();
+        auto n_items = lim > 0 ? (std::min)(lim, items_available) : items_available;
+        std::vector<details::log_msg_buffer> ret;
+        ret.reserve(n_items);
+        for (size_t i = (items_available - n_items); i < items_available; i++)
+        {
+            ret.push_back(q_.at(i));
+        }
+        return ret;
+    }
+
+    std::vector<std::string> last_formatted(size_t lim = 0)
+    {
+        std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_);
+        auto items_available = q_.size();
+        auto n_items = lim > 0 ? (std::min)(lim, items_available) : items_available;
+        std::vector<std::string> ret;
+        ret.reserve(n_items);
+        for (size_t i = (items_available - n_items); i < items_available; i++)
+        {
+            memory_buf_t formatted;
+            base_sink<Mutex>::formatter_->format(q_.at(i), formatted);
+            ret.push_back(SPDLOG_BUF_TO_STRING(formatted));
+        }
+        return ret;
+    }
+
+protected:
+    void sink_it_(const details::log_msg &msg) override
+    {
+        q_.push_back(details::log_msg_buffer{msg});
+    }
+    void flush_() override {}
+
+private:
+    details::circular_q<details::log_msg_buffer> q_;
+};
+
+using ringbuffer_sink_mt = ringbuffer_sink<std::mutex>;
+using ringbuffer_sink_st = ringbuffer_sink<details::null_mutex>;
+
+} // namespace sinks
+
+} // namespace spdlog
diff --git a/3rdparty/spdlog/src/include/spdlog/sinks/rotating_file_sink-inl.h b/3rdparty/spdlog/src/include/spdlog/sinks/rotating_file_sink-inl.h
new file mode 100644
index 00000000..cf8b9d5c
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/sinks/rotating_file_sink-inl.h
@@ -0,0 +1,152 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#ifndef SPDLOG_HEADER_ONLY
+#    include <spdlog/sinks/rotating_file_sink.h>
+#endif
+
+#include <spdlog/common.h>
+
+#include <spdlog/details/file_helper.h>
+#include <spdlog/details/null_mutex.h>
+#include <spdlog/fmt/fmt.h>
+
+#include <cerrno>
+#include <chrono>
+#include <ctime>
+#include <mutex>
+#include <string>
+#include <tuple>
+
+namespace spdlog {
+namespace sinks {
+
+template<typename Mutex>
+SPDLOG_INLINE rotating_file_sink<Mutex>::rotating_file_sink(
+    filename_t base_filename, std::size_t max_size, std::size_t max_files, bool rotate_on_open, const file_event_handlers &event_handlers)
+    : base_filename_(std::move(base_filename))
+    , max_size_(max_size)
+    , max_files_(max_files)
+    , file_helper_{event_handlers}
+{
+    if (max_size == 0)
+    {
+        throw_spdlog_ex("rotating sink constructor: max_size arg cannot be zero");
+    }
+
+    if (max_files > 200000)
+    {
+        throw_spdlog_ex("rotating sink constructor: max_files arg cannot exceed 200000");
+    }
+    file_helper_.open(calc_filename(base_filename_, 0));
+    current_size_ = file_helper_.size(); // expensive. called only once
+    if (rotate_on_open && current_size_ > 0)
+    {
+        rotate_();
+        current_size_ = 0;
+    }
+}
+
+// calc filename according to index and file extension if exists.
+// e.g. calc_filename("logs/mylog.txt, 3) => "logs/mylog.3.txt".
+template<typename Mutex>
+SPDLOG_INLINE filename_t rotating_file_sink<Mutex>::calc_filename(const filename_t &filename, std::size_t index)
+{
+    if (index == 0u)
+    {
+        return filename;
+    }
+
+    filename_t basename, ext;
+    std::tie(basename, ext) = details::file_helper::split_by_extension(filename);
+    return fmt_lib::format(SPDLOG_FILENAME_T("{}.{}{}"), basename, index, ext);
+}
+
+template<typename Mutex>
+SPDLOG_INLINE filename_t rotating_file_sink<Mutex>::filename()
+{
+    std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_);
+    return file_helper_.filename();
+}
+
+template<typename Mutex>
+SPDLOG_INLINE void rotating_file_sink<Mutex>::sink_it_(const details::log_msg &msg)
+{
+    memory_buf_t formatted;
+    base_sink<Mutex>::formatter_->format(msg, formatted);
+    auto new_size = current_size_ + formatted.size();
+
+    // rotate if the new estimated file size exceeds max size.
+    // rotate only if the real size > 0 to better deal with full disk (see issue #2261).
+    // we only check the real size when new_size > max_size_ because it is relatively expensive.
+    if (new_size > max_size_)
+    {
+        file_helper_.flush();
+        if (file_helper_.size() > 0)
+        {
+            rotate_();
+            new_size = formatted.size();
+        }
+    }
+    file_helper_.write(formatted);
+    current_size_ = new_size;
+}
+
+template<typename Mutex>
+SPDLOG_INLINE void rotating_file_sink<Mutex>::flush_()
+{
+    file_helper_.flush();
+}
+
+// Rotate files:
+// log.txt -> log.1.txt
+// log.1.txt -> log.2.txt
+// log.2.txt -> log.3.txt
+// log.3.txt -> delete
+template<typename Mutex>
+SPDLOG_INLINE void rotating_file_sink<Mutex>::rotate_()
+{
+    using details::os::filename_to_str;
+    using details::os::path_exists;
+
+    file_helper_.close();
+    for (auto i = max_files_; i > 0; --i)
+    {
+        filename_t src = calc_filename(base_filename_, i - 1);
+        if (!path_exists(src))
+        {
+            continue;
+        }
+        filename_t target = calc_filename(base_filename_, i);
+
+        if (!rename_file_(src, target))
+        {
+            // if failed try again after a small delay.
+            // this is a workaround to a windows issue, where very high rotation
+            // rates can cause the rename to fail with permission denied (because of antivirus?).
+            details::os::sleep_for_millis(100);
+            if (!rename_file_(src, target))
+            {
+                file_helper_.reopen(true); // truncate the log file anyway to prevent it to grow beyond its limit!
+                current_size_ = 0;
+                throw_spdlog_ex("rotating_file_sink: failed renaming " + filename_to_str(src) + " to " + filename_to_str(target), errno);
+            }
+        }
+    }
+    file_helper_.reopen(true);
+}
+
+// delete the target if exists, and rename the src file  to target
+// return true on success, false otherwise.
+template<typename Mutex>
+SPDLOG_INLINE bool rotating_file_sink<Mutex>::rename_file_(const filename_t &src_filename, const filename_t &target_filename)
+{
+    // try to delete the target file in case it already exists.
+    (void)details::os::remove(target_filename);
+    return details::os::rename(src_filename, target_filename) == 0;
+}
+
+} // namespace sinks
+} // namespace spdlog
diff --git a/3rdparty/spdlog/src/include/spdlog/sinks/rotating_file_sink.h b/3rdparty/spdlog/src/include/spdlog/sinks/rotating_file_sink.h
new file mode 100644
index 00000000..ce0d7b1e
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/sinks/rotating_file_sink.h
@@ -0,0 +1,81 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#include <spdlog/sinks/base_sink.h>
+#include <spdlog/details/file_helper.h>
+#include <spdlog/details/null_mutex.h>
+#include <spdlog/details/synchronous_factory.h>
+
+#include <chrono>
+#include <mutex>
+#include <string>
+
+namespace spdlog {
+namespace sinks {
+
+//
+// Rotating file sink based on size
+//
+template<typename Mutex>
+class rotating_file_sink final : public base_sink<Mutex>
+{
+public:
+    rotating_file_sink(filename_t base_filename, std::size_t max_size, std::size_t max_files, bool rotate_on_open = false,
+        const file_event_handlers &event_handlers = {});
+    static filename_t calc_filename(const filename_t &filename, std::size_t index);
+    filename_t filename();
+
+protected:
+    void sink_it_(const details::log_msg &msg) override;
+    void flush_() override;
+
+private:
+    // Rotate files:
+    // log.txt -> log.1.txt
+    // log.1.txt -> log.2.txt
+    // log.2.txt -> log.3.txt
+    // log.3.txt -> delete
+    void rotate_();
+
+    // delete the target if exists, and rename the src file  to target
+    // return true on success, false otherwise.
+    bool rename_file_(const filename_t &src_filename, const filename_t &target_filename);
+
+    filename_t base_filename_;
+    std::size_t max_size_;
+    std::size_t max_files_;
+    std::size_t current_size_;
+    details::file_helper file_helper_;
+};
+
+using rotating_file_sink_mt = rotating_file_sink<std::mutex>;
+using rotating_file_sink_st = rotating_file_sink<details::null_mutex>;
+
+} // namespace sinks
+
+//
+// factory functions
+//
+
+template<typename Factory = spdlog::synchronous_factory>
+inline std::shared_ptr<logger> rotating_logger_mt(const std::string &logger_name, const filename_t &filename, size_t max_file_size,
+    size_t max_files, bool rotate_on_open = false, const file_event_handlers &event_handlers = {})
+{
+    return Factory::template create<sinks::rotating_file_sink_mt>(
+        logger_name, filename, max_file_size, max_files, rotate_on_open, event_handlers);
+}
+
+template<typename Factory = spdlog::synchronous_factory>
+inline std::shared_ptr<logger> rotating_logger_st(const std::string &logger_name, const filename_t &filename, size_t max_file_size,
+    size_t max_files, bool rotate_on_open = false, const file_event_handlers &event_handlers = {})
+{
+    return Factory::template create<sinks::rotating_file_sink_st>(
+        logger_name, filename, max_file_size, max_files, rotate_on_open, event_handlers);
+}
+} // namespace spdlog
+
+#ifdef SPDLOG_HEADER_ONLY
+#    include "rotating_file_sink-inl.h"
+#endif
diff --git a/3rdparty/spdlog/src/include/spdlog/sinks/sink-inl.h b/3rdparty/spdlog/src/include/spdlog/sinks/sink-inl.h
new file mode 100644
index 00000000..df07adda
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/sinks/sink-inl.h
@@ -0,0 +1,25 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#ifndef SPDLOG_HEADER_ONLY
+#    include <spdlog/sinks/sink.h>
+#endif
+
+#include <spdlog/common.h>
+
+SPDLOG_INLINE bool spdlog::sinks::sink::should_log(spdlog::level::level_enum msg_level) const
+{
+    return msg_level >= level_.load(std::memory_order_relaxed);
+}
+
+SPDLOG_INLINE void spdlog::sinks::sink::set_level(level::level_enum log_level)
+{
+    level_.store(log_level, std::memory_order_relaxed);
+}
+
+SPDLOG_INLINE spdlog::level::level_enum spdlog::sinks::sink::level() const
+{
+    return static_cast<spdlog::level::level_enum>(level_.load(std::memory_order_relaxed));
+}
diff --git a/3rdparty/spdlog/src/include/spdlog/sinks/sink.h b/3rdparty/spdlog/src/include/spdlog/sinks/sink.h
new file mode 100644
index 00000000..0a28cccc
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/sinks/sink.h
@@ -0,0 +1,35 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#include <spdlog/details/log_msg.h>
+#include <spdlog/formatter.h>
+
+namespace spdlog {
+
+namespace sinks {
+class SPDLOG_API sink
+{
+public:
+    virtual ~sink() = default;
+    virtual void log(const details::log_msg &msg) = 0;
+    virtual void flush() = 0;
+    virtual void set_pattern(const std::string &pattern) = 0;
+    virtual void set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter) = 0;
+
+    void set_level(level::level_enum log_level);
+    level::level_enum level() const;
+    bool should_log(level::level_enum msg_level) const;
+
+protected:
+    // sink log level - default is all
+    level_t level_{level::trace};
+};
+
+} // namespace sinks
+} // namespace spdlog
+
+#ifdef SPDLOG_HEADER_ONLY
+#    include "sink-inl.h"
+#endif
diff --git a/3rdparty/spdlog/src/include/spdlog/sinks/stdout_color_sinks-inl.h b/3rdparty/spdlog/src/include/spdlog/sinks/stdout_color_sinks-inl.h
new file mode 100644
index 00000000..066df182
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/sinks/stdout_color_sinks-inl.h
@@ -0,0 +1,38 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#ifndef SPDLOG_HEADER_ONLY
+#    include <spdlog/sinks/stdout_color_sinks.h>
+#endif
+
+#include <spdlog/logger.h>
+#include <spdlog/common.h>
+
+namespace spdlog {
+
+template<typename Factory>
+SPDLOG_INLINE std::shared_ptr<logger> stdout_color_mt(const std::string &logger_name, color_mode mode)
+{
+    return Factory::template create<sinks::stdout_color_sink_mt>(logger_name, mode);
+}
+
+template<typename Factory>
+SPDLOG_INLINE std::shared_ptr<logger> stdout_color_st(const std::string &logger_name, color_mode mode)
+{
+    return Factory::template create<sinks::stdout_color_sink_st>(logger_name, mode);
+}
+
+template<typename Factory>
+SPDLOG_INLINE std::shared_ptr<logger> stderr_color_mt(const std::string &logger_name, color_mode mode)
+{
+    return Factory::template create<sinks::stderr_color_sink_mt>(logger_name, mode);
+}
+
+template<typename Factory>
+SPDLOG_INLINE std::shared_ptr<logger> stderr_color_st(const std::string &logger_name, color_mode mode)
+{
+    return Factory::template create<sinks::stderr_color_sink_st>(logger_name, mode);
+}
+} // namespace spdlog
diff --git a/3rdparty/spdlog/src/include/spdlog/sinks/stdout_color_sinks.h b/3rdparty/spdlog/src/include/spdlog/sinks/stdout_color_sinks.h
new file mode 100644
index 00000000..420b13ab
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/sinks/stdout_color_sinks.h
@@ -0,0 +1,45 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#ifdef _WIN32
+#    include <spdlog/sinks/wincolor_sink.h>
+#else
+#    include <spdlog/sinks/ansicolor_sink.h>
+#endif
+
+#include <spdlog/details/synchronous_factory.h>
+
+namespace spdlog {
+namespace sinks {
+#ifdef _WIN32
+using stdout_color_sink_mt = wincolor_stdout_sink_mt;
+using stdout_color_sink_st = wincolor_stdout_sink_st;
+using stderr_color_sink_mt = wincolor_stderr_sink_mt;
+using stderr_color_sink_st = wincolor_stderr_sink_st;
+#else
+using stdout_color_sink_mt = ansicolor_stdout_sink_mt;
+using stdout_color_sink_st = ansicolor_stdout_sink_st;
+using stderr_color_sink_mt = ansicolor_stderr_sink_mt;
+using stderr_color_sink_st = ansicolor_stderr_sink_st;
+#endif
+} // namespace sinks
+
+template<typename Factory = spdlog::synchronous_factory>
+std::shared_ptr<logger> stdout_color_mt(const std::string &logger_name, color_mode mode = color_mode::automatic);
+
+template<typename Factory = spdlog::synchronous_factory>
+std::shared_ptr<logger> stdout_color_st(const std::string &logger_name, color_mode mode = color_mode::automatic);
+
+template<typename Factory = spdlog::synchronous_factory>
+std::shared_ptr<logger> stderr_color_mt(const std::string &logger_name, color_mode mode = color_mode::automatic);
+
+template<typename Factory = spdlog::synchronous_factory>
+std::shared_ptr<logger> stderr_color_st(const std::string &logger_name, color_mode mode = color_mode::automatic);
+
+} // namespace spdlog
+
+#ifdef SPDLOG_HEADER_ONLY
+#    include "stdout_color_sinks-inl.h"
+#endif
diff --git a/3rdparty/spdlog/src/include/spdlog/sinks/stdout_sinks-inl.h b/3rdparty/spdlog/src/include/spdlog/sinks/stdout_sinks-inl.h
new file mode 100644
index 00000000..c1754370
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/sinks/stdout_sinks-inl.h
@@ -0,0 +1,138 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#ifndef SPDLOG_HEADER_ONLY
+#    include <spdlog/sinks/stdout_sinks.h>
+#endif
+
+#include <spdlog/details/console_globals.h>
+#include <spdlog/pattern_formatter.h>
+#include <memory>
+
+#ifdef _WIN32
+// under windows using fwrite to non-binary stream results in \r\r\n (see issue #1675)
+// so instead we use ::FileWrite
+#    include <spdlog/details/windows_include.h>
+
+#    ifndef _USING_V110_SDK71_ // fileapi.h doesn't exist in winxp
+#        include <fileapi.h>   // WriteFile (..)
+#    endif
+
+#    include <io.h>    // _get_osfhandle(..)
+#    include <stdio.h> // _fileno(..)
+#endif                 // WIN32
+
+namespace spdlog {
+
+namespace sinks {
+
+template<typename ConsoleMutex>
+SPDLOG_INLINE stdout_sink_base<ConsoleMutex>::stdout_sink_base(FILE *file)
+    : mutex_(ConsoleMutex::mutex())
+    , file_(file)
+    , formatter_(details::make_unique<spdlog::pattern_formatter>())
+{
+#ifdef _WIN32
+    // get windows handle from the FILE* object
+
+    handle_ = reinterpret_cast<HANDLE>(::_get_osfhandle(::_fileno(file_)));
+
+    // don't throw to support cases where no console is attached,
+    // and let the log method to do nothing if (handle_ == INVALID_HANDLE_VALUE).
+    // throw only if non stdout/stderr target is requested (probably regular file and not console).
+    if (handle_ == INVALID_HANDLE_VALUE && file != stdout && file != stderr)
+    {
+        throw_spdlog_ex("spdlog::stdout_sink_base: _get_osfhandle() failed", errno);
+    }
+#endif // WIN32
+}
+
+template<typename ConsoleMutex>
+SPDLOG_INLINE void stdout_sink_base<ConsoleMutex>::log(const details::log_msg &msg)
+{
+#ifdef _WIN32
+    if (handle_ == INVALID_HANDLE_VALUE)
+    {
+        return;
+    }
+    std::lock_guard<mutex_t> lock(mutex_);
+    memory_buf_t formatted;
+    formatter_->format(msg, formatted);
+    auto size = static_cast<DWORD>(formatted.size());
+    DWORD bytes_written = 0;
+    bool ok = ::WriteFile(handle_, formatted.data(), size, &bytes_written, nullptr) != 0;
+    if (!ok)
+    {
+        throw_spdlog_ex("stdout_sink_base: WriteFile() failed. GetLastError(): " + std::to_string(::GetLastError()));
+    }
+#else
+    std::lock_guard<mutex_t> lock(mutex_);
+    memory_buf_t formatted;
+    formatter_->format(msg, formatted);
+    ::fwrite(formatted.data(), sizeof(char), formatted.size(), file_);
+#endif               // WIN32
+    ::fflush(file_); // flush every line to terminal
+}
+
+template<typename ConsoleMutex>
+SPDLOG_INLINE void stdout_sink_base<ConsoleMutex>::flush()
+{
+    std::lock_guard<mutex_t> lock(mutex_);
+    fflush(file_);
+}
+
+template<typename ConsoleMutex>
+SPDLOG_INLINE void stdout_sink_base<ConsoleMutex>::set_pattern(const std::string &pattern)
+{
+    std::lock_guard<mutex_t> lock(mutex_);
+    formatter_ = std::unique_ptr<spdlog::formatter>(new pattern_formatter(pattern));
+}
+
+template<typename ConsoleMutex>
+SPDLOG_INLINE void stdout_sink_base<ConsoleMutex>::set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter)
+{
+    std::lock_guard<mutex_t> lock(mutex_);
+    formatter_ = std::move(sink_formatter);
+}
+
+// stdout sink
+template<typename ConsoleMutex>
+SPDLOG_INLINE stdout_sink<ConsoleMutex>::stdout_sink()
+    : stdout_sink_base<ConsoleMutex>(stdout)
+{}
+
+// stderr sink
+template<typename ConsoleMutex>
+SPDLOG_INLINE stderr_sink<ConsoleMutex>::stderr_sink()
+    : stdout_sink_base<ConsoleMutex>(stderr)
+{}
+
+} // namespace sinks
+
+// factory methods
+template<typename Factory>
+SPDLOG_INLINE std::shared_ptr<logger> stdout_logger_mt(const std::string &logger_name)
+{
+    return Factory::template create<sinks::stdout_sink_mt>(logger_name);
+}
+
+template<typename Factory>
+SPDLOG_INLINE std::shared_ptr<logger> stdout_logger_st(const std::string &logger_name)
+{
+    return Factory::template create<sinks::stdout_sink_st>(logger_name);
+}
+
+template<typename Factory>
+SPDLOG_INLINE std::shared_ptr<logger> stderr_logger_mt(const std::string &logger_name)
+{
+    return Factory::template create<sinks::stderr_sink_mt>(logger_name);
+}
+
+template<typename Factory>
+SPDLOG_INLINE std::shared_ptr<logger> stderr_logger_st(const std::string &logger_name)
+{
+    return Factory::template create<sinks::stderr_sink_st>(logger_name);
+}
+} // namespace spdlog
diff --git a/3rdparty/spdlog/src/include/spdlog/sinks/stdout_sinks.h b/3rdparty/spdlog/src/include/spdlog/sinks/stdout_sinks.h
new file mode 100644
index 00000000..6fdc0de3
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/sinks/stdout_sinks.h
@@ -0,0 +1,87 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#include <spdlog/details/console_globals.h>
+#include <spdlog/details/synchronous_factory.h>
+#include <spdlog/sinks/sink.h>
+#include <cstdio>
+
+#ifdef _WIN32
+#    include <spdlog/details/windows_include.h>
+#endif
+
+namespace spdlog {
+
+namespace sinks {
+
+template<typename ConsoleMutex>
+class stdout_sink_base : public sink
+{
+public:
+    using mutex_t = typename ConsoleMutex::mutex_t;
+    explicit stdout_sink_base(FILE *file);
+    ~stdout_sink_base() override = default;
+
+    stdout_sink_base(const stdout_sink_base &other) = delete;
+    stdout_sink_base(stdout_sink_base &&other) = delete;
+
+    stdout_sink_base &operator=(const stdout_sink_base &other) = delete;
+    stdout_sink_base &operator=(stdout_sink_base &&other) = delete;
+
+    void log(const details::log_msg &msg) override;
+    void flush() override;
+    void set_pattern(const std::string &pattern) override;
+
+    void set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter) override;
+
+protected:
+    mutex_t &mutex_;
+    FILE *file_;
+    std::unique_ptr<spdlog::formatter> formatter_;
+#ifdef _WIN32
+    HANDLE handle_;
+#endif // WIN32
+};
+
+template<typename ConsoleMutex>
+class stdout_sink : public stdout_sink_base<ConsoleMutex>
+{
+public:
+    stdout_sink();
+};
+
+template<typename ConsoleMutex>
+class stderr_sink : public stdout_sink_base<ConsoleMutex>
+{
+public:
+    stderr_sink();
+};
+
+using stdout_sink_mt = stdout_sink<details::console_mutex>;
+using stdout_sink_st = stdout_sink<details::console_nullmutex>;
+
+using stderr_sink_mt = stderr_sink<details::console_mutex>;
+using stderr_sink_st = stderr_sink<details::console_nullmutex>;
+
+} // namespace sinks
+
+// factory methods
+template<typename Factory = spdlog::synchronous_factory>
+std::shared_ptr<logger> stdout_logger_mt(const std::string &logger_name);
+
+template<typename Factory = spdlog::synchronous_factory>
+std::shared_ptr<logger> stdout_logger_st(const std::string &logger_name);
+
+template<typename Factory = spdlog::synchronous_factory>
+std::shared_ptr<logger> stderr_logger_mt(const std::string &logger_name);
+
+template<typename Factory = spdlog::synchronous_factory>
+std::shared_ptr<logger> stderr_logger_st(const std::string &logger_name);
+
+} // namespace spdlog
+
+#ifdef SPDLOG_HEADER_ONLY
+#    include "stdout_sinks-inl.h"
+#endif
diff --git a/3rdparty/spdlog/src/include/spdlog/sinks/syslog_sink.h b/3rdparty/spdlog/src/include/spdlog/sinks/syslog_sink.h
new file mode 100644
index 00000000..7c38fcb5
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/sinks/syslog_sink.h
@@ -0,0 +1,109 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#include <spdlog/sinks/base_sink.h>
+#include <spdlog/details/null_mutex.h>
+#include <spdlog/details/synchronous_factory.h>
+
+#include <array>
+#include <string>
+#include <syslog.h>
+
+namespace spdlog {
+namespace sinks {
+/**
+ * Sink that write to syslog using the `syscall()` library call.
+ */
+template<typename Mutex>
+class syslog_sink : public base_sink<Mutex>
+{
+
+public:
+    syslog_sink(std::string ident, int syslog_option, int syslog_facility, bool enable_formatting)
+        : enable_formatting_{enable_formatting}
+        , syslog_levels_{{/* spdlog::level::trace      */ LOG_DEBUG,
+              /* spdlog::level::debug      */ LOG_DEBUG,
+              /* spdlog::level::info       */ LOG_INFO,
+              /* spdlog::level::warn       */ LOG_WARNING,
+              /* spdlog::level::err        */ LOG_ERR,
+              /* spdlog::level::critical   */ LOG_CRIT,
+              /* spdlog::level::off        */ LOG_INFO}}
+        , ident_{std::move(ident)}
+    {
+        // set ident to be program name if empty
+        ::openlog(ident_.empty() ? nullptr : ident_.c_str(), syslog_option, syslog_facility);
+    }
+
+    ~syslog_sink() override
+    {
+        ::closelog();
+    }
+
+    syslog_sink(const syslog_sink &) = delete;
+    syslog_sink &operator=(const syslog_sink &) = delete;
+
+protected:
+    void sink_it_(const details::log_msg &msg) override
+    {
+        string_view_t payload;
+        memory_buf_t formatted;
+        if (enable_formatting_)
+        {
+            base_sink<Mutex>::formatter_->format(msg, formatted);
+            payload = string_view_t(formatted.data(), formatted.size());
+        }
+        else
+        {
+            payload = msg.payload;
+        }
+
+        size_t length = payload.size();
+        // limit to max int
+        if (length > static_cast<size_t>(std::numeric_limits<int>::max()))
+        {
+            length = static_cast<size_t>(std::numeric_limits<int>::max());
+        }
+
+        ::syslog(syslog_prio_from_level(msg), "%.*s", static_cast<int>(length), payload.data());
+    }
+
+    void flush_() override {}
+    bool enable_formatting_ = false;
+
+private:
+    using levels_array = std::array<int, 7>;
+    levels_array syslog_levels_;
+    // must store the ident because the man says openlog might use the pointer as
+    // is and not a string copy
+    const std::string ident_;
+
+    //
+    // Simply maps spdlog's log level to syslog priority level.
+    //
+    int syslog_prio_from_level(const details::log_msg &msg) const
+    {
+        return syslog_levels_.at(static_cast<levels_array::size_type>(msg.level));
+    }
+};
+
+using syslog_sink_mt = syslog_sink<std::mutex>;
+using syslog_sink_st = syslog_sink<details::null_mutex>;
+} // namespace sinks
+
+// Create and register a syslog logger
+template<typename Factory = spdlog::synchronous_factory>
+inline std::shared_ptr<logger> syslog_logger_mt(const std::string &logger_name, const std::string &syslog_ident = "", int syslog_option = 0,
+    int syslog_facility = LOG_USER, bool enable_formatting = false)
+{
+    return Factory::template create<sinks::syslog_sink_mt>(logger_name, syslog_ident, syslog_option, syslog_facility, enable_formatting);
+}
+
+template<typename Factory = spdlog::synchronous_factory>
+inline std::shared_ptr<logger> syslog_logger_st(const std::string &logger_name, const std::string &syslog_ident = "", int syslog_option = 0,
+    int syslog_facility = LOG_USER, bool enable_formatting = false)
+{
+    return Factory::template create<sinks::syslog_sink_st>(logger_name, syslog_ident, syslog_option, syslog_facility, enable_formatting);
+}
+} // namespace spdlog
diff --git a/3rdparty/spdlog/src/include/spdlog/sinks/systemd_sink.h b/3rdparty/spdlog/src/include/spdlog/sinks/systemd_sink.h
new file mode 100644
index 00000000..b00a95f2
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/sinks/systemd_sink.h
@@ -0,0 +1,126 @@
+// Copyright(c) 2019 ZVYAGIN.Alexander@gmail.com
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#include <spdlog/sinks/base_sink.h>
+#include <spdlog/details/os.h>
+#include <spdlog/details/null_mutex.h>
+#include <spdlog/details/synchronous_factory.h>
+
+#include <array>
+#ifndef SD_JOURNAL_SUPPRESS_LOCATION
+#    define SD_JOURNAL_SUPPRESS_LOCATION
+#endif
+#include <systemd/sd-journal.h>
+
+namespace spdlog {
+namespace sinks {
+
+/**
+ * Sink that write to systemd journal using the `sd_journal_send()` library call.
+ */
+template<typename Mutex>
+class systemd_sink : public base_sink<Mutex>
+{
+public:
+    systemd_sink(std::string ident = "", bool enable_formatting = false)
+        : ident_{std::move(ident)}
+        , enable_formatting_{enable_formatting}
+        , syslog_levels_{{/* spdlog::level::trace      */ LOG_DEBUG,
+              /* spdlog::level::debug      */ LOG_DEBUG,
+              /* spdlog::level::info       */ LOG_INFO,
+              /* spdlog::level::warn       */ LOG_WARNING,
+              /* spdlog::level::err        */ LOG_ERR,
+              /* spdlog::level::critical   */ LOG_CRIT,
+              /* spdlog::level::off        */ LOG_INFO}}
+    {}
+
+    ~systemd_sink() override {}
+
+    systemd_sink(const systemd_sink &) = delete;
+    systemd_sink &operator=(const systemd_sink &) = delete;
+
+protected:
+    const std::string ident_;
+    bool enable_formatting_ = false;
+    using levels_array = std::array<int, 7>;
+    levels_array syslog_levels_;
+
+    void sink_it_(const details::log_msg &msg) override
+    {
+        int err;
+        string_view_t payload;
+        memory_buf_t formatted;
+        if (enable_formatting_)
+        {
+            base_sink<Mutex>::formatter_->format(msg, formatted);
+            payload = string_view_t(formatted.data(), formatted.size());
+        }
+        else
+        {
+            payload = msg.payload;
+        }
+
+        size_t length = payload.size();
+        // limit to max int
+        if (length > static_cast<size_t>(std::numeric_limits<int>::max()))
+        {
+            length = static_cast<size_t>(std::numeric_limits<int>::max());
+        }
+
+        const string_view_t syslog_identifier = ident_.empty() ? msg.logger_name : ident_;
+
+        // Do not send source location if not available
+        if (msg.source.empty())
+        {
+            // Note: function call inside '()' to avoid macro expansion
+            err = (sd_journal_send)("MESSAGE=%.*s", static_cast<int>(length), payload.data(), "PRIORITY=%d", syslog_level(msg.level),
+#ifndef SPDLOG_NO_THREAD_ID
+                "TID=%zu", details::os::thread_id(),
+#endif
+                "SYSLOG_IDENTIFIER=%.*s", static_cast<int>(syslog_identifier.size()), syslog_identifier.data(), nullptr);
+        }
+        else
+        {
+            err = (sd_journal_send)("MESSAGE=%.*s", static_cast<int>(length), payload.data(), "PRIORITY=%d", syslog_level(msg.level),
+#ifndef SPDLOG_NO_THREAD_ID
+                "TID=%zu", details::os::thread_id(),
+#endif
+                "SYSLOG_IDENTIFIER=%.*s", static_cast<int>(syslog_identifier.size()), syslog_identifier.data(), "CODE_FILE=%s",
+                msg.source.filename, "CODE_LINE=%d", msg.source.line, "CODE_FUNC=%s", msg.source.funcname, nullptr);
+        }
+
+        if (err)
+        {
+            throw_spdlog_ex("Failed writing to systemd", errno);
+        }
+    }
+
+    int syslog_level(level::level_enum l)
+    {
+        return syslog_levels_.at(static_cast<levels_array::size_type>(l));
+    }
+
+    void flush_() override {}
+};
+
+using systemd_sink_mt = systemd_sink<std::mutex>;
+using systemd_sink_st = systemd_sink<details::null_mutex>;
+} // namespace sinks
+
+// Create and register a syslog logger
+template<typename Factory = spdlog::synchronous_factory>
+inline std::shared_ptr<logger> systemd_logger_mt(
+    const std::string &logger_name, const std::string &ident = "", bool enable_formatting = false)
+{
+    return Factory::template create<sinks::systemd_sink_mt>(logger_name, ident, enable_formatting);
+}
+
+template<typename Factory = spdlog::synchronous_factory>
+inline std::shared_ptr<logger> systemd_logger_st(
+    const std::string &logger_name, const std::string &ident = "", bool enable_formatting = false)
+{
+    return Factory::template create<sinks::systemd_sink_st>(logger_name, ident, enable_formatting);
+}
+} // namespace spdlog
diff --git a/3rdparty/spdlog/src/include/spdlog/sinks/tcp_sink.h b/3rdparty/spdlog/src/include/spdlog/sinks/tcp_sink.h
new file mode 100644
index 00000000..e0efb31d
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/sinks/tcp_sink.h
@@ -0,0 +1,81 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#include <spdlog/common.h>
+#include <spdlog/sinks/base_sink.h>
+#include <spdlog/details/null_mutex.h>
+#ifdef _WIN32
+#    include <spdlog/details/tcp_client-windows.h>
+#else
+#    include <spdlog/details/tcp_client.h>
+#endif
+
+#include <mutex>
+#include <string>
+#include <chrono>
+#include <functional>
+
+#pragma once
+
+// Simple tcp client sink
+// Connects to remote address and send the formatted log.
+// Will attempt to reconnect if connection drops.
+// If more complicated behaviour is needed (i.e get responses), you can inherit it and override the sink_it_ method.
+
+namespace spdlog {
+namespace sinks {
+
+struct tcp_sink_config
+{
+    std::string server_host;
+    int server_port;
+    bool lazy_connect = false; // if true connect on first log call instead of on construction
+
+    tcp_sink_config(std::string host, int port)
+        : server_host{std::move(host)}
+        , server_port{port}
+    {}
+};
+
+template<typename Mutex>
+class tcp_sink : public spdlog::sinks::base_sink<Mutex>
+{
+public:
+    // connect to tcp host/port or throw if failed
+    // host can be hostname or ip address
+
+    explicit tcp_sink(tcp_sink_config sink_config)
+        : config_{std::move(sink_config)}
+    {
+        if (!config_.lazy_connect)
+        {
+            this->client_.connect(config_.server_host, config_.server_port);
+        }
+    }
+
+    ~tcp_sink() override = default;
+
+protected:
+    void sink_it_(const spdlog::details::log_msg &msg) override
+    {
+        spdlog::memory_buf_t formatted;
+        spdlog::sinks::base_sink<Mutex>::formatter_->format(msg, formatted);
+        if (!client_.is_connected())
+        {
+            client_.connect(config_.server_host, config_.server_port);
+        }
+        client_.send(formatted.data(), formatted.size());
+    }
+
+    void flush_() override {}
+    tcp_sink_config config_;
+    details::tcp_client client_;
+};
+
+using tcp_sink_mt = tcp_sink<std::mutex>;
+using tcp_sink_st = tcp_sink<spdlog::details::null_mutex>;
+
+} // namespace sinks
+} // namespace spdlog
diff --git a/3rdparty/spdlog/src/include/spdlog/sinks/udp_sink.h b/3rdparty/spdlog/src/include/spdlog/sinks/udp_sink.h
new file mode 100644
index 00000000..ccbce2be
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/sinks/udp_sink.h
@@ -0,0 +1,74 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#include <spdlog/common.h>
+#include <spdlog/sinks/base_sink.h>
+#include <spdlog/details/null_mutex.h>
+#ifdef _WIN32
+#    include <spdlog/details/udp_client-windows.h>
+#else
+#    include <spdlog/details/udp_client.h>
+#endif
+
+#include <mutex>
+#include <string>
+#include <chrono>
+#include <functional>
+
+// Simple udp client sink
+// Sends formatted log via udp
+
+namespace spdlog {
+namespace sinks {
+
+struct udp_sink_config
+{
+    std::string server_host;
+    uint16_t server_port;
+
+    udp_sink_config(std::string host, uint16_t port)
+        : server_host{std::move(host)}
+        , server_port{port}
+    {}
+};
+
+template<typename Mutex>
+class udp_sink : public spdlog::sinks::base_sink<Mutex>
+{
+public:
+    // host can be hostname or ip address
+    explicit udp_sink(udp_sink_config sink_config)
+        : client_{sink_config.server_host, sink_config.server_port}
+    {}
+
+    ~udp_sink() override = default;
+
+protected:
+    void sink_it_(const spdlog::details::log_msg &msg) override
+    {
+        spdlog::memory_buf_t formatted;
+        spdlog::sinks::base_sink<Mutex>::formatter_->format(msg, formatted);
+        client_.send(formatted.data(), formatted.size());
+    }
+
+    void flush_() override {}
+    details::udp_client client_;
+};
+
+using udp_sink_mt = udp_sink<std::mutex>;
+using udp_sink_st = udp_sink<spdlog::details::null_mutex>;
+
+} // namespace sinks
+
+//
+// factory functions
+//
+template<typename Factory = spdlog::synchronous_factory>
+inline std::shared_ptr<logger> udp_logger_mt(const std::string &logger_name, sinks::udp_sink_config skin_config)
+{
+    return Factory::template create<sinks::udp_sink_mt>(logger_name, skin_config);
+}
+
+} // namespace spdlog
diff --git a/3rdparty/spdlog/src/include/spdlog/sinks/win_eventlog_sink.h b/3rdparty/spdlog/src/include/spdlog/sinks/win_eventlog_sink.h
new file mode 100644
index 00000000..d23d00a8
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/sinks/win_eventlog_sink.h
@@ -0,0 +1,289 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+// Writing to Windows Event Log requires the registry entries below to be present, with the following modifications:
+// 1. <log_name>    should be replaced with your log name (e.g. your application name)
+// 2. <source_name> should be replaced with the specific source name and the key should be duplicated for
+//                  each source used in the application
+//
+// Since typically modifications of this kind require elevation, it's better to do it as a part of setup procedure.
+// The snippet below uses mscoree.dll as the message file as it exists on most of the Windows systems anyway and
+// happens to contain the needed resource.
+//
+// You can also specify a custom message file if needed.
+// Please refer to Event Log functions descriptions in MSDN for more details on custom message files.
+
+/*---------------------------------------------------------------------------------------
+
+Windows Registry Editor Version 5.00
+
+[HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\EventLog\<log_name>]
+
+[HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\EventLog\<log_name>\<source_name>]
+"TypesSupported"=dword:00000007
+"EventMessageFile"=hex(2):25,00,73,00,79,00,73,00,74,00,65,00,6d,00,72,00,6f,\
+  00,6f,00,74,00,25,00,5c,00,53,00,79,00,73,00,74,00,65,00,6d,00,33,00,32,00,\
+  5c,00,6d,00,73,00,63,00,6f,00,72,00,65,00,65,00,2e,00,64,00,6c,00,6c,00,00,\
+  00
+
+-----------------------------------------------------------------------------------------*/
+
+#pragma once
+
+#include <spdlog/details/null_mutex.h>
+#include <spdlog/sinks/base_sink.h>
+
+#include <spdlog/details/windows_include.h>
+#include <winbase.h>
+
+#include <mutex>
+#include <string>
+#include <vector>
+
+namespace spdlog {
+namespace sinks {
+
+namespace win_eventlog {
+
+namespace internal {
+
+struct local_alloc_t
+{
+    HLOCAL hlocal_;
+
+    SPDLOG_CONSTEXPR local_alloc_t() SPDLOG_NOEXCEPT : hlocal_(nullptr) {}
+
+    local_alloc_t(local_alloc_t const &) = delete;
+    local_alloc_t &operator=(local_alloc_t const &) = delete;
+
+    ~local_alloc_t() SPDLOG_NOEXCEPT
+    {
+        if (hlocal_)
+        {
+            LocalFree(hlocal_);
+        }
+    }
+};
+
+/** Windows error */
+struct win32_error : public spdlog_ex
+{
+    /** Formats an error report line: "user-message: error-code (system message)" */
+    static std::string format(std::string const &user_message, DWORD error_code = GetLastError())
+    {
+        std::string system_message;
+
+        local_alloc_t format_message_result{};
+        auto format_message_succeeded =
+            ::FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, nullptr,
+                error_code, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPSTR)&format_message_result.hlocal_, 0, nullptr);
+
+        if (format_message_succeeded && format_message_result.hlocal_)
+        {
+            system_message = fmt_lib::format(" ({})", (LPSTR)format_message_result.hlocal_);
+        }
+
+        return fmt_lib::format("{}: {}{}", user_message, error_code, system_message);
+    }
+
+    explicit win32_error(std::string const &func_name, DWORD error = GetLastError())
+        : spdlog_ex(format(func_name, error))
+    {}
+};
+
+/** Wrapper for security identifiers (SID) on Windows */
+struct sid_t
+{
+    std::vector<char> buffer_;
+
+public:
+    sid_t() {}
+
+    /** creates a wrapped SID copy */
+    static sid_t duplicate_sid(PSID psid)
+    {
+        if (!::IsValidSid(psid))
+        {
+            throw_spdlog_ex("sid_t::sid_t(): invalid SID received");
+        }
+
+        auto const sid_length{::GetLengthSid(psid)};
+
+        sid_t result;
+        result.buffer_.resize(sid_length);
+        if (!::CopySid(sid_length, (PSID)result.as_sid(), psid))
+        {
+            SPDLOG_THROW(win32_error("CopySid"));
+        }
+
+        return result;
+    }
+
+    /** Retrieves pointer to the internal buffer contents as SID* */
+    SID *as_sid() const
+    {
+        return buffer_.empty() ? nullptr : (SID *)buffer_.data();
+    }
+
+    /** Get SID for the current user */
+    static sid_t get_current_user_sid()
+    {
+        /* create and init RAII holder for process token */
+        struct process_token_t
+        {
+            HANDLE token_handle_ = INVALID_HANDLE_VALUE;
+            explicit process_token_t(HANDLE process)
+            {
+                if (!::OpenProcessToken(process, TOKEN_QUERY, &token_handle_))
+                {
+                    SPDLOG_THROW(win32_error("OpenProcessToken"));
+                }
+            }
+
+            ~process_token_t()
+            {
+                ::CloseHandle(token_handle_);
+            }
+
+        } current_process_token(::GetCurrentProcess()); // GetCurrentProcess returns pseudohandle, no leak here!
+
+        // Get the required size, this is expected to fail with ERROR_INSUFFICIENT_BUFFER and return the token size
+        DWORD tusize = 0;
+        if (::GetTokenInformation(current_process_token.token_handle_, TokenUser, NULL, 0, &tusize))
+        {
+            SPDLOG_THROW(win32_error("GetTokenInformation should fail"));
+        }
+
+        // get user token
+        std::vector<unsigned char> buffer(static_cast<size_t>(tusize));
+        if (!::GetTokenInformation(current_process_token.token_handle_, TokenUser, (LPVOID)buffer.data(), tusize, &tusize))
+        {
+            SPDLOG_THROW(win32_error("GetTokenInformation"));
+        }
+
+        // create a wrapper of the SID data as stored in the user token
+        return sid_t::duplicate_sid(((TOKEN_USER *)buffer.data())->User.Sid);
+    }
+};
+
+struct eventlog
+{
+    static WORD get_event_type(details::log_msg const &msg)
+    {
+        switch (msg.level)
+        {
+        case level::trace:
+        case level::debug:
+            return EVENTLOG_SUCCESS;
+
+        case level::info:
+            return EVENTLOG_INFORMATION_TYPE;
+
+        case level::warn:
+            return EVENTLOG_WARNING_TYPE;
+
+        case level::err:
+        case level::critical:
+        case level::off:
+            return EVENTLOG_ERROR_TYPE;
+
+        default:
+            return EVENTLOG_INFORMATION_TYPE;
+        }
+    }
+
+    static WORD get_event_category(details::log_msg const &msg)
+    {
+        return (WORD)msg.level;
+    }
+};
+
+} // namespace internal
+
+/*
+ * Windows Event Log sink
+ */
+template<typename Mutex>
+class win_eventlog_sink : public base_sink<Mutex>
+{
+private:
+    HANDLE hEventLog_{NULL};
+    internal::sid_t current_user_sid_;
+    std::string source_;
+    DWORD event_id_;
+
+    HANDLE event_log_handle()
+    {
+        if (!hEventLog_)
+        {
+            hEventLog_ = ::RegisterEventSourceA(nullptr, source_.c_str());
+            if (!hEventLog_ || hEventLog_ == (HANDLE)ERROR_ACCESS_DENIED)
+            {
+                SPDLOG_THROW(internal::win32_error("RegisterEventSource"));
+            }
+        }
+
+        return hEventLog_;
+    }
+
+protected:
+    void sink_it_(const details::log_msg &msg) override
+    {
+        using namespace internal;
+
+        bool succeeded;
+        memory_buf_t formatted;
+        base_sink<Mutex>::formatter_->format(msg, formatted);
+        formatted.push_back('\0');
+
+#ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT
+        wmemory_buf_t buf;
+        details::os::utf8_to_wstrbuf(string_view_t(formatted.data(), formatted.size()), buf);
+
+        LPCWSTR lp_wstr = buf.data();
+        succeeded = static_cast<bool>(::ReportEventW(event_log_handle(), eventlog::get_event_type(msg), eventlog::get_event_category(msg),
+            event_id_, current_user_sid_.as_sid(), 1, 0, &lp_wstr, nullptr));
+#else
+        LPCSTR lp_str = formatted.data();
+        succeeded = static_cast<bool>(::ReportEventA(event_log_handle(), eventlog::get_event_type(msg), eventlog::get_event_category(msg),
+            event_id_, current_user_sid_.as_sid(), 1, 0, &lp_str, nullptr));
+#endif
+
+        if (!succeeded)
+        {
+            SPDLOG_THROW(win32_error("ReportEvent"));
+        }
+    }
+
+    void flush_() override {}
+
+public:
+    win_eventlog_sink(std::string const &source, DWORD event_id = 1000 /* according to mscoree.dll */)
+        : source_(source)
+        , event_id_(event_id)
+    {
+        try
+        {
+            current_user_sid_ = internal::sid_t::get_current_user_sid();
+        }
+        catch (...)
+        {
+            // get_current_user_sid() is unlikely to fail and if it does, we can still proceed without
+            // current_user_sid but in the event log the record will have no user name
+        }
+    }
+
+    ~win_eventlog_sink()
+    {
+        if (hEventLog_)
+            DeregisterEventSource(hEventLog_);
+    }
+};
+
+} // namespace win_eventlog
+
+using win_eventlog_sink_mt = win_eventlog::win_eventlog_sink<std::mutex>;
+using win_eventlog_sink_st = win_eventlog::win_eventlog_sink<details::null_mutex>;
+
+} // namespace sinks
+} // namespace spdlog
diff --git a/3rdparty/spdlog/src/include/spdlog/sinks/wincolor_sink-inl.h b/3rdparty/spdlog/src/include/spdlog/sinks/wincolor_sink-inl.h
new file mode 100644
index 00000000..8311929e
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/sinks/wincolor_sink-inl.h
@@ -0,0 +1,175 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#ifndef SPDLOG_HEADER_ONLY
+#    include <spdlog/sinks/wincolor_sink.h>
+#endif
+
+#include <spdlog/details/windows_include.h>
+#include <wincon.h>
+
+#include <spdlog/common.h>
+#include <spdlog/pattern_formatter.h>
+
+namespace spdlog {
+namespace sinks {
+template<typename ConsoleMutex>
+SPDLOG_INLINE wincolor_sink<ConsoleMutex>::wincolor_sink(void *out_handle, color_mode mode)
+    : out_handle_(out_handle)
+    , mutex_(ConsoleMutex::mutex())
+    , formatter_(details::make_unique<spdlog::pattern_formatter>())
+{
+
+    set_color_mode_impl(mode);
+    // set level colors
+    colors_[level::trace] = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE;     // white
+    colors_[level::debug] = FOREGROUND_GREEN | FOREGROUND_BLUE;                      // cyan
+    colors_[level::info] = FOREGROUND_GREEN;                                         // green
+    colors_[level::warn] = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_INTENSITY; // intense yellow
+    colors_[level::err] = FOREGROUND_RED | FOREGROUND_INTENSITY;                     // intense red
+    colors_[level::critical] =
+        BACKGROUND_RED | FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE | FOREGROUND_INTENSITY; // intense white on red background
+    colors_[level::off] = 0;
+}
+
+template<typename ConsoleMutex>
+SPDLOG_INLINE wincolor_sink<ConsoleMutex>::~wincolor_sink()
+{
+    this->flush();
+}
+
+// change the color for the given level
+template<typename ConsoleMutex>
+void SPDLOG_INLINE wincolor_sink<ConsoleMutex>::set_color(level::level_enum level, std::uint16_t color)
+{
+    std::lock_guard<mutex_t> lock(mutex_);
+    colors_[static_cast<size_t>(level)] = color;
+}
+
+template<typename ConsoleMutex>
+void SPDLOG_INLINE wincolor_sink<ConsoleMutex>::log(const details::log_msg &msg)
+{
+    if (out_handle_ == nullptr || out_handle_ == INVALID_HANDLE_VALUE)
+    {
+        return;
+    }
+
+    std::lock_guard<mutex_t> lock(mutex_);
+    msg.color_range_start = 0;
+    msg.color_range_end = 0;
+    memory_buf_t formatted;
+    formatter_->format(msg, formatted);
+    if (should_do_colors_ && msg.color_range_end > msg.color_range_start)
+    {
+        // before color range
+        print_range_(formatted, 0, msg.color_range_start);
+        // in color range
+        auto orig_attribs = static_cast<WORD>(set_foreground_color_(colors_[static_cast<size_t>(msg.level)]));
+        print_range_(formatted, msg.color_range_start, msg.color_range_end);
+        // reset to orig colors
+        ::SetConsoleTextAttribute(static_cast<HANDLE>(out_handle_), orig_attribs);
+        print_range_(formatted, msg.color_range_end, formatted.size());
+    }
+    else // print without colors if color range is invalid (or color is disabled)
+    {
+        write_to_file_(formatted);
+    }
+}
+
+template<typename ConsoleMutex>
+void SPDLOG_INLINE wincolor_sink<ConsoleMutex>::flush()
+{
+    // windows console always flushed?
+}
+
+template<typename ConsoleMutex>
+void SPDLOG_INLINE wincolor_sink<ConsoleMutex>::set_pattern(const std::string &pattern)
+{
+    std::lock_guard<mutex_t> lock(mutex_);
+    formatter_ = std::unique_ptr<spdlog::formatter>(new pattern_formatter(pattern));
+}
+
+template<typename ConsoleMutex>
+void SPDLOG_INLINE wincolor_sink<ConsoleMutex>::set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter)
+{
+    std::lock_guard<mutex_t> lock(mutex_);
+    formatter_ = std::move(sink_formatter);
+}
+
+template<typename ConsoleMutex>
+void SPDLOG_INLINE wincolor_sink<ConsoleMutex>::set_color_mode(color_mode mode)
+{
+    std::lock_guard<mutex_t> lock(mutex_);
+    set_color_mode_impl(mode);
+}
+
+template<typename ConsoleMutex>
+void SPDLOG_INLINE wincolor_sink<ConsoleMutex>::set_color_mode_impl(color_mode mode)
+{
+    if (mode == color_mode::automatic)
+    {
+        // should do colors only if out_handle_  points to actual console.
+        DWORD console_mode;
+        bool in_console = ::GetConsoleMode(static_cast<HANDLE>(out_handle_), &console_mode) != 0;
+        should_do_colors_ = in_console;
+    }
+    else
+    {
+        should_do_colors_ = mode == color_mode::always ? true : false;
+    }
+}
+
+// set foreground color and return the orig console attributes (for resetting later)
+template<typename ConsoleMutex>
+std::uint16_t SPDLOG_INLINE wincolor_sink<ConsoleMutex>::set_foreground_color_(std::uint16_t attribs)
+{
+    CONSOLE_SCREEN_BUFFER_INFO orig_buffer_info;
+    if (!::GetConsoleScreenBufferInfo(static_cast<HANDLE>(out_handle_), &orig_buffer_info))
+    {
+        // just return white if failed getting console info
+        return FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE;
+    }
+
+    // change only the foreground bits (lowest 4 bits)
+    auto new_attribs = static_cast<WORD>(attribs) | (orig_buffer_info.wAttributes & 0xfff0);
+    auto ignored = ::SetConsoleTextAttribute(static_cast<HANDLE>(out_handle_), static_cast<WORD>(new_attribs));
+    (void)(ignored);
+    return static_cast<std::uint16_t>(orig_buffer_info.wAttributes); // return orig attribs
+}
+
+// print a range of formatted message to console
+template<typename ConsoleMutex>
+void SPDLOG_INLINE wincolor_sink<ConsoleMutex>::print_range_(const memory_buf_t &formatted, size_t start, size_t end)
+{
+    if (end > start)
+    {
+        auto size = static_cast<DWORD>(end - start);
+        auto ignored = ::WriteConsoleA(static_cast<HANDLE>(out_handle_), formatted.data() + start, size, nullptr, nullptr);
+        (void)(ignored);
+    }
+}
+
+template<typename ConsoleMutex>
+void SPDLOG_INLINE wincolor_sink<ConsoleMutex>::write_to_file_(const memory_buf_t &formatted)
+{
+    auto size = static_cast<DWORD>(formatted.size());
+    DWORD bytes_written = 0;
+    auto ignored = ::WriteFile(static_cast<HANDLE>(out_handle_), formatted.data(), size, &bytes_written, nullptr);
+    (void)(ignored);
+}
+
+// wincolor_stdout_sink
+template<typename ConsoleMutex>
+SPDLOG_INLINE wincolor_stdout_sink<ConsoleMutex>::wincolor_stdout_sink(color_mode mode)
+    : wincolor_sink<ConsoleMutex>(::GetStdHandle(STD_OUTPUT_HANDLE), mode)
+{}
+
+// wincolor_stderr_sink
+template<typename ConsoleMutex>
+SPDLOG_INLINE wincolor_stderr_sink<ConsoleMutex>::wincolor_stderr_sink(color_mode mode)
+    : wincolor_sink<ConsoleMutex>(::GetStdHandle(STD_ERROR_HANDLE), mode)
+{}
+} // namespace sinks
+} // namespace spdlog
diff --git a/3rdparty/spdlog/src/include/spdlog/sinks/wincolor_sink.h b/3rdparty/spdlog/src/include/spdlog/sinks/wincolor_sink.h
new file mode 100644
index 00000000..9b030fc1
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/sinks/wincolor_sink.h
@@ -0,0 +1,85 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#include <spdlog/common.h>
+#include <spdlog/details/console_globals.h>
+#include <spdlog/details/null_mutex.h>
+#include <spdlog/sinks/sink.h>
+
+#include <memory>
+#include <mutex>
+#include <string>
+#include <array>
+#include <cstdint>
+
+namespace spdlog {
+namespace sinks {
+/*
+ * Windows color console sink. Uses WriteConsoleA to write to the console with
+ * colors
+ */
+template<typename ConsoleMutex>
+class wincolor_sink : public sink
+{
+public:
+    wincolor_sink(void *out_handle, color_mode mode);
+    ~wincolor_sink() override;
+
+    wincolor_sink(const wincolor_sink &other) = delete;
+    wincolor_sink &operator=(const wincolor_sink &other) = delete;
+
+    // change the color for the given level
+    void set_color(level::level_enum level, std::uint16_t color);
+    void log(const details::log_msg &msg) final override;
+    void flush() final override;
+    void set_pattern(const std::string &pattern) override final;
+    void set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter) override final;
+    void set_color_mode(color_mode mode);
+
+protected:
+    using mutex_t = typename ConsoleMutex::mutex_t;
+    void *out_handle_;
+    mutex_t &mutex_;
+    bool should_do_colors_;
+    std::unique_ptr<spdlog::formatter> formatter_;
+    std::array<std::uint16_t, level::n_levels> colors_;
+
+    // set foreground color and return the orig console attributes (for resetting later)
+    std::uint16_t set_foreground_color_(std::uint16_t attribs);
+
+    // print a range of formatted message to console
+    void print_range_(const memory_buf_t &formatted, size_t start, size_t end);
+
+    // in case we are redirected to file (not in console mode)
+    void write_to_file_(const memory_buf_t &formatted);
+
+    void set_color_mode_impl(color_mode mode);
+};
+
+template<typename ConsoleMutex>
+class wincolor_stdout_sink : public wincolor_sink<ConsoleMutex>
+{
+public:
+    explicit wincolor_stdout_sink(color_mode mode = color_mode::automatic);
+};
+
+template<typename ConsoleMutex>
+class wincolor_stderr_sink : public wincolor_sink<ConsoleMutex>
+{
+public:
+    explicit wincolor_stderr_sink(color_mode mode = color_mode::automatic);
+};
+
+using wincolor_stdout_sink_mt = wincolor_stdout_sink<details::console_mutex>;
+using wincolor_stdout_sink_st = wincolor_stdout_sink<details::console_nullmutex>;
+
+using wincolor_stderr_sink_mt = wincolor_stderr_sink<details::console_mutex>;
+using wincolor_stderr_sink_st = wincolor_stderr_sink<details::console_nullmutex>;
+} // namespace sinks
+} // namespace spdlog
+
+#ifdef SPDLOG_HEADER_ONLY
+#    include "wincolor_sink-inl.h"
+#endif
diff --git a/3rdparty/spdlog/src/include/spdlog/spdlog-inl.h b/3rdparty/spdlog/src/include/spdlog/spdlog-inl.h
new file mode 100644
index 00000000..22ea22bb
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/spdlog-inl.h
@@ -0,0 +1,125 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#ifndef SPDLOG_HEADER_ONLY
+#    include <spdlog/spdlog.h>
+#endif
+
+#include <spdlog/common.h>
+#include <spdlog/pattern_formatter.h>
+
+namespace spdlog {
+
+SPDLOG_INLINE void initialize_logger(std::shared_ptr<logger> logger)
+{
+    details::registry::instance().initialize_logger(std::move(logger));
+}
+
+SPDLOG_INLINE std::shared_ptr<logger> get(const std::string &name)
+{
+    return details::registry::instance().get(name);
+}
+
+SPDLOG_INLINE void set_formatter(std::unique_ptr<spdlog::formatter> formatter)
+{
+    details::registry::instance().set_formatter(std::move(formatter));
+}
+
+SPDLOG_INLINE void set_pattern(std::string pattern, pattern_time_type time_type)
+{
+    set_formatter(std::unique_ptr<spdlog::formatter>(new pattern_formatter(std::move(pattern), time_type)));
+}
+
+SPDLOG_INLINE void enable_backtrace(size_t n_messages)
+{
+    details::registry::instance().enable_backtrace(n_messages);
+}
+
+SPDLOG_INLINE void disable_backtrace()
+{
+    details::registry::instance().disable_backtrace();
+}
+
+SPDLOG_INLINE void dump_backtrace()
+{
+    default_logger_raw()->dump_backtrace();
+}
+
+SPDLOG_INLINE level::level_enum get_level()
+{
+    return default_logger_raw()->level();
+}
+
+SPDLOG_INLINE bool should_log(level::level_enum log_level)
+{
+    return default_logger_raw()->should_log(log_level);
+}
+
+SPDLOG_INLINE void set_level(level::level_enum log_level)
+{
+    details::registry::instance().set_level(log_level);
+}
+
+SPDLOG_INLINE void flush_on(level::level_enum log_level)
+{
+    details::registry::instance().flush_on(log_level);
+}
+
+SPDLOG_INLINE void set_error_handler(void (*handler)(const std::string &msg))
+{
+    details::registry::instance().set_error_handler(handler);
+}
+
+SPDLOG_INLINE void register_logger(std::shared_ptr<logger> logger)
+{
+    details::registry::instance().register_logger(std::move(logger));
+}
+
+SPDLOG_INLINE void apply_all(const std::function<void(std::shared_ptr<logger>)> &fun)
+{
+    details::registry::instance().apply_all(fun);
+}
+
+SPDLOG_INLINE void drop(const std::string &name)
+{
+    details::registry::instance().drop(name);
+}
+
+SPDLOG_INLINE void drop_all()
+{
+    details::registry::instance().drop_all();
+}
+
+SPDLOG_INLINE void shutdown()
+{
+    details::registry::instance().shutdown();
+}
+
+SPDLOG_INLINE void set_automatic_registration(bool automatic_registration)
+{
+    details::registry::instance().set_automatic_registration(automatic_registration);
+}
+
+SPDLOG_INLINE std::shared_ptr<spdlog::logger> default_logger()
+{
+    return details::registry::instance().default_logger();
+}
+
+SPDLOG_INLINE spdlog::logger *default_logger_raw()
+{
+    return details::registry::instance().get_default_raw();
+}
+
+SPDLOG_INLINE void set_default_logger(std::shared_ptr<spdlog::logger> default_logger)
+{
+    details::registry::instance().set_default_logger(std::move(default_logger));
+}
+
+SPDLOG_INLINE void apply_logger_env_levels(std::shared_ptr<logger> logger)
+{
+    details::registry::instance().apply_logger_env_levels(std::move(logger));
+}
+
+} // namespace spdlog
diff --git a/3rdparty/spdlog/src/include/spdlog/spdlog.h b/3rdparty/spdlog/src/include/spdlog/spdlog.h
new file mode 100644
index 00000000..fbfe5fb8
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/spdlog.h
@@ -0,0 +1,363 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+// spdlog main header file.
+// see example.cpp for usage example
+
+#ifndef SPDLOG_H
+#define SPDLOG_H
+
+#pragma once
+
+#include <spdlog/common.h>
+#include <spdlog/details/registry.h>
+#include <spdlog/logger.h>
+#include <spdlog/version.h>
+#include <spdlog/details/synchronous_factory.h>
+
+#include <chrono>
+#include <functional>
+#include <memory>
+#include <string>
+
+namespace spdlog {
+
+using default_factory = synchronous_factory;
+
+// Create and register a logger with a templated sink type
+// The logger's level, formatter and flush level will be set according the
+// global settings.
+//
+// Example:
+//   spdlog::create<daily_file_sink_st>("logger_name", "dailylog_filename", 11, 59);
+template<typename Sink, typename... SinkArgs>
+inline std::shared_ptr<spdlog::logger> create(std::string logger_name, SinkArgs &&...sink_args)
+{
+    return default_factory::create<Sink>(std::move(logger_name), std::forward<SinkArgs>(sink_args)...);
+}
+
+// Initialize and register a logger,
+// formatter and flush level will be set according the global settings.
+//
+// Useful for initializing manually created loggers with the global settings.
+//
+// Example:
+//   auto mylogger = std::make_shared<spdlog::logger>("mylogger", ...);
+//   spdlog::initialize_logger(mylogger);
+SPDLOG_API void initialize_logger(std::shared_ptr<logger> logger);
+
+// Return an existing logger or nullptr if a logger with such name doesn't
+// exist.
+// example: spdlog::get("my_logger")->info("hello {}", "world");
+SPDLOG_API std::shared_ptr<logger> get(const std::string &name);
+
+// Set global formatter. Each sink in each logger will get a clone of this object
+SPDLOG_API void set_formatter(std::unique_ptr<spdlog::formatter> formatter);
+
+// Set global format string.
+// example: spdlog::set_pattern("%Y-%m-%d %H:%M:%S.%e %l : %v");
+SPDLOG_API void set_pattern(std::string pattern, pattern_time_type time_type = pattern_time_type::local);
+
+// enable global backtrace support
+SPDLOG_API void enable_backtrace(size_t n_messages);
+
+// disable global backtrace support
+SPDLOG_API void disable_backtrace();
+
+// call dump backtrace on default logger
+SPDLOG_API void dump_backtrace();
+
+// Get global logging level
+SPDLOG_API level::level_enum get_level();
+
+// Set global logging level
+SPDLOG_API void set_level(level::level_enum log_level);
+
+// Determine whether the default logger should log messages with a certain level
+SPDLOG_API bool should_log(level::level_enum lvl);
+
+// Set global flush level
+SPDLOG_API void flush_on(level::level_enum log_level);
+
+// Start/Restart a periodic flusher thread
+// Warning: Use only if all your loggers are thread safe!
+template<typename Rep, typename Period>
+inline void flush_every(std::chrono::duration<Rep, Period> interval)
+{
+    details::registry::instance().flush_every(interval);
+}
+
+// Set global error handler
+SPDLOG_API void set_error_handler(void (*handler)(const std::string &msg));
+
+// Register the given logger with the given name
+SPDLOG_API void register_logger(std::shared_ptr<logger> logger);
+
+// Apply a user defined function on all registered loggers
+// Example:
+// spdlog::apply_all([&](std::shared_ptr<spdlog::logger> l) {l->flush();});
+SPDLOG_API void apply_all(const std::function<void(std::shared_ptr<logger>)> &fun);
+
+// Drop the reference to the given logger
+SPDLOG_API void drop(const std::string &name);
+
+// Drop all references from the registry
+SPDLOG_API void drop_all();
+
+// stop any running threads started by spdlog and clean registry loggers
+SPDLOG_API void shutdown();
+
+// Automatic registration of loggers when using spdlog::create() or spdlog::create_async
+SPDLOG_API void set_automatic_registration(bool automatic_registration);
+
+// API for using default logger (stdout_color_mt),
+// e.g: spdlog::info("Message {}", 1);
+//
+// The default logger object can be accessed using the spdlog::default_logger():
+// For example, to add another sink to it:
+// spdlog::default_logger()->sinks().push_back(some_sink);
+//
+// The default logger can replaced using spdlog::set_default_logger(new_logger).
+// For example, to replace it with a file logger.
+//
+// IMPORTANT:
+// The default API is thread safe (for _mt loggers), but:
+// set_default_logger() *should not* be used concurrently with the default API.
+// e.g do not call set_default_logger() from one thread while calling spdlog::info() from another.
+
+SPDLOG_API std::shared_ptr<spdlog::logger> default_logger();
+
+SPDLOG_API spdlog::logger *default_logger_raw();
+
+SPDLOG_API void set_default_logger(std::shared_ptr<spdlog::logger> default_logger);
+
+// Initialize logger level based on environment configs.
+//
+// Useful for applying SPDLOG_LEVEL to manually created loggers.
+//
+// Example:
+//   auto mylogger = std::make_shared<spdlog::logger>("mylogger", ...);
+//   spdlog::apply_logger_env_levels(mylogger);
+SPDLOG_API void apply_logger_env_levels(std::shared_ptr<logger> logger);
+
+template<typename... Args>
+inline void log(source_loc source, level::level_enum lvl, format_string_t<Args...> fmt, Args &&...args)
+{
+    default_logger_raw()->log(source, lvl, fmt, std::forward<Args>(args)...);
+}
+
+template<typename... Args>
+inline void log(level::level_enum lvl, format_string_t<Args...> fmt, Args &&...args)
+{
+    default_logger_raw()->log(source_loc{}, lvl, fmt, std::forward<Args>(args)...);
+}
+
+template<typename... Args>
+inline void trace(format_string_t<Args...> fmt, Args &&...args)
+{
+    default_logger_raw()->trace(fmt, std::forward<Args>(args)...);
+}
+
+template<typename... Args>
+inline void debug(format_string_t<Args...> fmt, Args &&...args)
+{
+    default_logger_raw()->debug(fmt, std::forward<Args>(args)...);
+}
+
+template<typename... Args>
+inline void info(format_string_t<Args...> fmt, Args &&...args)
+{
+    default_logger_raw()->info(fmt, std::forward<Args>(args)...);
+}
+
+template<typename... Args>
+inline void warn(format_string_t<Args...> fmt, Args &&...args)
+{
+    default_logger_raw()->warn(fmt, std::forward<Args>(args)...);
+}
+
+template<typename... Args>
+inline void error(format_string_t<Args...> fmt, Args &&...args)
+{
+    default_logger_raw()->error(fmt, std::forward<Args>(args)...);
+}
+
+template<typename... Args>
+inline void critical(format_string_t<Args...> fmt, Args &&...args)
+{
+    default_logger_raw()->critical(fmt, std::forward<Args>(args)...);
+}
+
+template<typename T>
+inline void log(source_loc source, level::level_enum lvl, const T &msg)
+{
+    default_logger_raw()->log(source, lvl, msg);
+}
+
+template<typename T>
+inline void log(level::level_enum lvl, const T &msg)
+{
+    default_logger_raw()->log(lvl, msg);
+}
+
+#ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT
+template<typename... Args>
+inline void log(source_loc source, level::level_enum lvl, wformat_string_t<Args...> fmt, Args &&...args)
+{
+    default_logger_raw()->log(source, lvl, fmt, std::forward<Args>(args)...);
+}
+
+template<typename... Args>
+inline void log(level::level_enum lvl, wformat_string_t<Args...> fmt, Args &&...args)
+{
+    default_logger_raw()->log(source_loc{}, lvl, fmt, std::forward<Args>(args)...);
+}
+
+template<typename... Args>
+inline void trace(wformat_string_t<Args...> fmt, Args &&...args)
+{
+    default_logger_raw()->trace(fmt, std::forward<Args>(args)...);
+}
+
+template<typename... Args>
+inline void debug(wformat_string_t<Args...> fmt, Args &&...args)
+{
+    default_logger_raw()->debug(fmt, std::forward<Args>(args)...);
+}
+
+template<typename... Args>
+inline void info(wformat_string_t<Args...> fmt, Args &&...args)
+{
+    default_logger_raw()->info(fmt, std::forward<Args>(args)...);
+}
+
+template<typename... Args>
+inline void warn(wformat_string_t<Args...> fmt, Args &&...args)
+{
+    default_logger_raw()->warn(fmt, std::forward<Args>(args)...);
+}
+
+template<typename... Args>
+inline void error(wformat_string_t<Args...> fmt, Args &&...args)
+{
+    default_logger_raw()->error(fmt, std::forward<Args>(args)...);
+}
+
+template<typename... Args>
+inline void critical(wformat_string_t<Args...> fmt, Args &&...args)
+{
+    default_logger_raw()->critical(fmt, std::forward<Args>(args)...);
+}
+#endif
+
+template<typename T>
+inline void trace(const T &msg)
+{
+    default_logger_raw()->trace(msg);
+}
+
+template<typename T>
+inline void debug(const T &msg)
+{
+    default_logger_raw()->debug(msg);
+}
+
+template<typename T>
+inline void info(const T &msg)
+{
+    default_logger_raw()->info(msg);
+}
+
+template<typename T>
+inline void warn(const T &msg)
+{
+    default_logger_raw()->warn(msg);
+}
+
+template<typename T>
+inline void error(const T &msg)
+{
+    default_logger_raw()->error(msg);
+}
+
+template<typename T>
+inline void critical(const T &msg)
+{
+    default_logger_raw()->critical(msg);
+}
+
+} // namespace spdlog
+
+//
+// enable/disable log calls at compile time according to global level.
+//
+// define SPDLOG_ACTIVE_LEVEL to one of those (before including spdlog.h):
+// SPDLOG_LEVEL_TRACE,
+// SPDLOG_LEVEL_DEBUG,
+// SPDLOG_LEVEL_INFO,
+// SPDLOG_LEVEL_WARN,
+// SPDLOG_LEVEL_ERROR,
+// SPDLOG_LEVEL_CRITICAL,
+// SPDLOG_LEVEL_OFF
+//
+
+#ifndef SPDLOG_NO_SOURCE_LOC
+#    define SPDLOG_LOGGER_CALL(logger, level, ...)                                                                                         \
+        (logger)->log(spdlog::source_loc{__FILE__, __LINE__, SPDLOG_FUNCTION}, level, __VA_ARGS__)
+#else
+#    define SPDLOG_LOGGER_CALL(logger, level, ...) (logger)->log(spdlog::source_loc{}, level, __VA_ARGS__)
+#endif
+
+#if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_TRACE
+#    define SPDLOG_LOGGER_TRACE(logger, ...) SPDLOG_LOGGER_CALL(logger, spdlog::level::trace, __VA_ARGS__)
+#    define SPDLOG_TRACE(...) SPDLOG_LOGGER_TRACE(spdlog::default_logger_raw(), __VA_ARGS__)
+#else
+#    define SPDLOG_LOGGER_TRACE(logger, ...) (void)0
+#    define SPDLOG_TRACE(...) (void)0
+#endif
+
+#if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_DEBUG
+#    define SPDLOG_LOGGER_DEBUG(logger, ...) SPDLOG_LOGGER_CALL(logger, spdlog::level::debug, __VA_ARGS__)
+#    define SPDLOG_DEBUG(...) SPDLOG_LOGGER_DEBUG(spdlog::default_logger_raw(), __VA_ARGS__)
+#else
+#    define SPDLOG_LOGGER_DEBUG(logger, ...) (void)0
+#    define SPDLOG_DEBUG(...) (void)0
+#endif
+
+#if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_INFO
+#    define SPDLOG_LOGGER_INFO(logger, ...) SPDLOG_LOGGER_CALL(logger, spdlog::level::info, __VA_ARGS__)
+#    define SPDLOG_INFO(...) SPDLOG_LOGGER_INFO(spdlog::default_logger_raw(), __VA_ARGS__)
+#else
+#    define SPDLOG_LOGGER_INFO(logger, ...) (void)0
+#    define SPDLOG_INFO(...) (void)0
+#endif
+
+#if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_WARN
+#    define SPDLOG_LOGGER_WARN(logger, ...) SPDLOG_LOGGER_CALL(logger, spdlog::level::warn, __VA_ARGS__)
+#    define SPDLOG_WARN(...) SPDLOG_LOGGER_WARN(spdlog::default_logger_raw(), __VA_ARGS__)
+#else
+#    define SPDLOG_LOGGER_WARN(logger, ...) (void)0
+#    define SPDLOG_WARN(...) (void)0
+#endif
+
+#if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_ERROR
+#    define SPDLOG_LOGGER_ERROR(logger, ...) SPDLOG_LOGGER_CALL(logger, spdlog::level::err, __VA_ARGS__)
+#    define SPDLOG_ERROR(...) SPDLOG_LOGGER_ERROR(spdlog::default_logger_raw(), __VA_ARGS__)
+#else
+#    define SPDLOG_LOGGER_ERROR(logger, ...) (void)0
+#    define SPDLOG_ERROR(...) (void)0
+#endif
+
+#if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_CRITICAL
+#    define SPDLOG_LOGGER_CRITICAL(logger, ...) SPDLOG_LOGGER_CALL(logger, spdlog::level::critical, __VA_ARGS__)
+#    define SPDLOG_CRITICAL(...) SPDLOG_LOGGER_CRITICAL(spdlog::default_logger_raw(), __VA_ARGS__)
+#else
+#    define SPDLOG_LOGGER_CRITICAL(logger, ...) (void)0
+#    define SPDLOG_CRITICAL(...) (void)0
+#endif
+
+#ifdef SPDLOG_HEADER_ONLY
+#    include "spdlog-inl.h"
+#endif
+
+#endif // SPDLOG_H
diff --git a/3rdparty/spdlog/src/include/spdlog/stopwatch.h b/3rdparty/spdlog/src/include/spdlog/stopwatch.h
new file mode 100644
index 00000000..5d1f2dc5
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/stopwatch.h
@@ -0,0 +1,69 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#include <spdlog/fmt/fmt.h>
+#include <chrono>
+
+// Stopwatch support for spdlog  (using std::chrono::steady_clock).
+// Displays elapsed seconds since construction as double.
+//
+// Usage:
+//
+// spdlog::stopwatch sw;
+// ...
+// spdlog::debug("Elapsed: {} seconds", sw);    =>  "Elapsed 0.005116733 seconds"
+// spdlog::info("Elapsed: {:.6} seconds", sw);  =>  "Elapsed 0.005163 seconds"
+//
+//
+// If other units are needed (e.g. millis instead of double), include "fmt/chrono.h" and use "duration_cast<..>(sw.elapsed())":
+//
+// #include <spdlog/fmt/chrono.h>
+//..
+// using std::chrono::duration_cast;
+// using std::chrono::milliseconds;
+// spdlog::info("Elapsed {}", duration_cast<milliseconds>(sw.elapsed())); => "Elapsed 5ms"
+
+namespace spdlog {
+class stopwatch
+{
+    using clock = std::chrono::steady_clock;
+    std::chrono::time_point<clock> start_tp_;
+
+public:
+    stopwatch()
+        : start_tp_{clock::now()}
+    {}
+
+    std::chrono::duration<double> elapsed() const
+    {
+        return std::chrono::duration<double>(clock::now() - start_tp_);
+    }
+
+    void reset()
+    {
+        start_tp_ = clock::now();
+    }
+};
+} // namespace spdlog
+
+// Support for fmt formatting  (e.g. "{:012.9}" or just "{}")
+namespace
+#ifdef SPDLOG_USE_STD_FORMAT
+    std
+#else
+    fmt
+#endif
+{
+
+template<>
+struct formatter<spdlog::stopwatch> : formatter<double>
+{
+    template<typename FormatContext>
+    auto format(const spdlog::stopwatch &sw, FormatContext &ctx) -> decltype(ctx.out())
+    {
+        return formatter<double>::format(sw.elapsed().count(), ctx);
+    }
+};
+} // namespace std
diff --git a/3rdparty/spdlog/src/include/spdlog/tweakme.h b/3rdparty/spdlog/src/include/spdlog/tweakme.h
new file mode 100644
index 00000000..5bcb5ff4
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/tweakme.h
@@ -0,0 +1,140 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// Edit this file to squeeze more performance, and to customize supported
+// features
+//
+///////////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////////////////////////
+// Under Linux, the much faster CLOCK_REALTIME_COARSE clock can be used.
+// This clock is less accurate - can be off by dozens of millis - depending on
+// the kernel HZ.
+// Uncomment to use it instead of the regular clock.
+//
+// #define SPDLOG_CLOCK_COARSE
+///////////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////////////////////////
+// Uncomment if source location logging is not needed.
+// This will prevent spdlog from using __FILE__, __LINE__ and SPDLOG_FUNCTION
+//
+// #define SPDLOG_NO_SOURCE_LOC
+///////////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////////////////////////
+// Uncomment if thread id logging is not needed (i.e. no %t in the log pattern).
+// This will prevent spdlog from querying the thread id on each log call.
+//
+// WARNING: If the log pattern contains thread id (i.e, %t) while this flag is
+// on, zero will be logged as thread id.
+//
+// #define SPDLOG_NO_THREAD_ID
+///////////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////////////////////////
+// Uncomment to prevent spdlog from using thread local storage.
+//
+// WARNING: if your program forks, UNCOMMENT this flag to prevent undefined
+// thread ids in the children logs.
+//
+// #define SPDLOG_NO_TLS
+///////////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////////////////////////
+// Uncomment to avoid spdlog's usage of atomic log levels
+// Use only if your code never modifies a logger's log levels concurrently by
+// different threads.
+//
+// #define SPDLOG_NO_ATOMIC_LEVELS
+///////////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////////////////////////
+// Uncomment to enable usage of wchar_t for file names on Windows.
+//
+// #define SPDLOG_WCHAR_FILENAMES
+///////////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////////////////////////
+// Uncomment to override default eol ("\n" or "\r\n" under Linux/Windows)
+//
+// #define SPDLOG_EOL ";-)\n"
+///////////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////////////////////////
+// Uncomment to override default folder separators ("/" or "\\/" under
+// Linux/Windows). Each character in the string is treated as a different
+// separator.
+//
+// #define SPDLOG_FOLDER_SEPS "\\"
+///////////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////////////////////////
+// Uncomment to use your own copy of the fmt library instead of spdlog's copy.
+// In this case spdlog will try to include <fmt/format.h> so set your -I flag
+// accordingly.
+//
+// #define SPDLOG_FMT_EXTERNAL
+///////////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////////////////////////
+// Uncomment to use C++20 std::format instead of fmt.
+//
+// #define SPDLOG_USE_STD_FORMAT
+///////////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////////////////////////
+// Uncomment to enable wchar_t support (convert to utf8)
+//
+// #define SPDLOG_WCHAR_TO_UTF8_SUPPORT
+///////////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////////////////////////
+// Uncomment to prevent child processes from inheriting log file descriptors
+//
+// #define SPDLOG_PREVENT_CHILD_FD
+///////////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////////////////////////
+// Uncomment to customize level names (e.g. "MY TRACE")
+//
+// #define SPDLOG_LEVEL_NAMES { "MY TRACE", "MY DEBUG", "MY INFO", "MY WARNING", "MY ERROR", "MY CRITICAL", "OFF" }
+///////////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////////////////////////
+// Uncomment to customize short level names (e.g. "MT")
+// These can be longer than one character.
+//
+// #define SPDLOG_SHORT_LEVEL_NAMES { "T", "D", "I", "W", "E", "C", "O" }
+///////////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////////////////////////
+// Uncomment to disable default logger creation.
+// This might save some (very) small initialization time if no default logger is needed.
+//
+// #define SPDLOG_DISABLE_DEFAULT_LOGGER
+///////////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////////////////////////
+// Uncomment and set to compile time level with zero cost (default is INFO).
+// Macros like SPDLOG_DEBUG(..), SPDLOG_INFO(..)  will expand to empty statements if not enabled
+//
+// #define SPDLOG_ACTIVE_LEVEL SPDLOG_LEVEL_INFO
+///////////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////////////////////////
+// Uncomment (and change if desired) macro to use for function names.
+// This is compiler dependent.
+// __PRETTY_FUNCTION__ might be nicer in clang/gcc, and __FUNCTION__ in msvc.
+// Defaults to __FUNCTION__ (should work on all compilers) if not defined.
+//
+// #ifdef __PRETTY_FUNCTION__
+// # define SPDLOG_FUNCTION __PRETTY_FUNCTION__
+// #else
+// # define SPDLOG_FUNCTION __FUNCTION__
+// #endif
+///////////////////////////////////////////////////////////////////////////////
diff --git a/3rdparty/spdlog/src/include/spdlog/version.h b/3rdparty/spdlog/src/include/spdlog/version.h
new file mode 100644
index 00000000..5717bead
--- /dev/null
+++ b/3rdparty/spdlog/src/include/spdlog/version.h
@@ -0,0 +1,10 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#define SPDLOG_VER_MAJOR 1
+#define SPDLOG_VER_MINOR 11
+#define SPDLOG_VER_PATCH 0
+
+#define SPDLOG_VERSION (SPDLOG_VER_MAJOR * 10000 + SPDLOG_VER_MINOR * 100 + SPDLOG_VER_PATCH)
diff --git a/3rdparty/spdlog/src/logos/jetbrains-variant-4.svg b/3rdparty/spdlog/src/logos/jetbrains-variant-4.svg
new file mode 100644
index 00000000..e02b5595
--- /dev/null
+++ b/3rdparty/spdlog/src/logos/jetbrains-variant-4.svg
@@ -0,0 +1,43 @@
+<svg id="Layer_1" data-name="Layer 1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="263" height="147" viewBox="0 0 263 147">
+  <defs>
+    <linearGradient id="linear-gradient" x1="54.4568" y1="122.5936" x2="251.779" y2="10.2057" gradientUnits="userSpaceOnUse">
+      <stop offset="0" stop-color="#00adee"/>
+      <stop offset="1" stop-color="#9f76a6"/>
+    </linearGradient>
+    <linearGradient id="linear-gradient-2" x1="80.247" y1="38.7607" x2="241.2622" y2="10.9511" gradientUnits="userSpaceOnUse">
+      <stop offset="0" stop-color="#ec037c"/>
+      <stop offset="1" stop-color="#9f76a6"/>
+    </linearGradient>
+    <linearGradient id="linear-gradient-3" x1="75.7205" y1="33.5582" x2="127.8253" y2="123.9392" gradientUnits="userSpaceOnUse">
+      <stop offset="0" stop-color="#ec037c"/>
+      <stop offset="1" stop-color="#5c2d90"/>
+    </linearGradient>
+    <linearGradient id="linear-gradient-4" x1="7.4647" y1="44.578" x2="129.4543" y2="125.0813" gradientUnits="userSpaceOnUse">
+      <stop offset="0" stop-color="#44c7f4"/>
+      <stop offset="1" stop-color="#5c2d90"/>
+    </linearGradient>
+  </defs>
+  <g>
+    <path d="M261.1839,10.3622a9.6784,9.6784,0,0,0-14.7448-8.2463l0-.0006L20.6942,136.0746h0a4.6974,4.6974,0,1,0,4.1326,8.4348h0q0.09-.0467.1784-0.097l230.5273-125.25a9.653,9.653,0,0,0,1.1508-.6253l0.0332-.018-0.0014-.0023A9.6682,9.6682,0,0,0,261.1839,10.3622Z" fill="url(#linear-gradient)"/>
+    <path d="M261.1839,10.3622A9.6782,9.6782,0,0,0,251.5057.684q-0.2747,0-.5456.0157-0.25.0143-.4975,0.041L76.7981,25.4187A13.7347,13.7347,0,1,0,83.5355,51.983L252.8044,19.9512a9.6363,9.6363,0,0,0,1.0358-.196l0.02-.0039,0-.0008A9.6811,9.6811,0,0,0,261.1839,10.3622Z" fill="url(#linear-gradient-2)"/>
+    <path d="M145.2028,123.63a17.2372,17.2372,0,0,0-3.0637-9.4254L91.3045,32.3521A13.7366,13.7366,0,0,0,66.1132,42.9507h0a13.6332,13.6332,0,0,0,1.043,2.4984s45.2334,86.37,45.5824,86.9979q0.3089,0.556.6567,1.0861h0A17.32,17.32,0,0,0,145.2028,123.63Z" fill="url(#linear-gradient-3)"/>
+    <path d="M145.2028,123.63a17.2979,17.2979,0,0,0-7.63-13.9419h0a17.3061,17.3061,0,0,0-2.6994-1.4911L9.5484,38.9679a6.064,6.064,0,0,0-6.5074,10.187l114.3963,88.704A17.3191,17.3191,0,0,0,145.2028,123.63Z" fill="url(#linear-gradient-4)"/>
+    <g>
+      <rect x="69" y="51" width="70" height="70"/>
+      <g>
+        <rect x="75.038" y="107.8746" width="26.2498" height="4.375" fill="#fff"/>
+        <g>
+          <path d="M74.7429,69.4315L76.78,67.5082a2.31,2.31,0,0,0,1.7929,1.0594A1.33,1.33,0,0,0,79.8607,66.97V59.75h3.1456v7.2366a4.2386,4.2386,0,0,1-1.1246,3.2108,4.2989,4.2989,0,0,1-3.1293,1.1572A4.6592,4.6592,0,0,1,74.7429,69.4315Z" fill="#fff"/>
+          <path d="M83.7394,59.75h9.1761v2.673H86.8688v1.744H92.345v2.4937H86.8688V68.47H92.997v2.6893H83.7394V59.75Z" fill="#fff"/>
+          <path d="M97.049,62.5208H93.6426V59.75h9.9911v2.7708h-3.4227v8.6383H97.049V62.5208Z" fill="#fff"/>
+          <path d="M75.0363,73.8257h5.8511A4.2728,4.2728,0,0,1,84,74.8363a2.5675,2.5675,0,0,1,.7335,1.858v0.0326a2.6407,2.6407,0,0,1-1.76,2.5425,2.7686,2.7686,0,0,1,2.2655,2.7871v0.0326c0,1.9558-1.5973,3.1456-4.3191,3.1456H75.0363V73.8257Zm6.5846,3.5206c0-.6357-0.5052-0.9779-1.4343-0.9779h-2.07v2.0047h1.9884c0.9616,0,1.5158-.326,1.5158-0.9942V77.3463ZM80.5289,80.59H78.1166v2.1025h2.4448c0.9779,0,1.5158-.3749,1.5158-1.0431V81.6165C82.0773,80.9972,81.5883,80.59,80.5289,80.59Z" fill="#fff"/>
+          <path d="M85.7116,73.8257h5.3949a5.0512,5.0512,0,0,1,3.7161,1.2224,3.5623,3.5623,0,0,1,1.01,2.6567v0.0326a3.6146,3.6146,0,0,1-2.3469,3.5205l2.7218,3.9769H92.5733l-2.2981-3.4553H88.8735v3.4553H85.7116V73.8257Zm5.2644,5.4764a1.433,1.433,0,0,0,1.6951-1.3528V77.9167c0-.9128-0.6682-1.3691-1.7114-1.3691H88.8735v2.7545H90.976Z" fill="#fff"/>
+          <path d="M99.5324,73.7443H102.58l4.8571,11.4905h-3.39l-0.815-2.0536H98.8153L98,85.2348H94.6917Zm2.7707,6.9758-1.2712-3.2271L99.7443,80.72h2.5589Z" fill="#fff"/>
+          <path d="M107.8117,73.8257h3.1619V85.2348h-3.1619V73.8257Z" fill="#fff"/>
+          <path d="M111.7558,73.8257h2.95l4.694,6.0306V73.8257h3.1294V85.2348h-2.7545l-4.89-6.2587v6.2587h-3.1293V73.8257Z" fill="#fff"/>
+          <path d="M122.7274,83.54l1.76-2.1025a5.9106,5.9106,0,0,0,3.7,1.3691c0.8638,0,1.32-.2934,1.32-0.7824V81.9914c0-.489-0.3749-0.7335-1.9395-1.1084-2.4285-.5541-4.3029-1.2387-4.3029-3.5694V77.2811c0-2.1188,1.6788-3.6509,4.417-3.6509a7.1807,7.1807,0,0,1,4.694,1.5158l-1.5809,2.2329a5.6006,5.6006,0,0,0-3.1946-1.1246c-0.766,0-1.1409.31-1.1409,0.7334V77.02c0,0.5216.3912,0.75,1.9884,1.1083,2.6077,0.57,4.2377,1.418,4.2377,3.5531v0.0326c0,2.3307-1.8418,3.7161-4.6126,3.7161A7.9992,7.9992,0,0,1,122.7274,83.54Z" fill="#fff"/>
+        </g>
+      </g>
+    </g>
+  </g>
+</svg>
diff --git a/3rdparty/spdlog/src/scripts/ci_setup_clang.sh b/3rdparty/spdlog/src/scripts/ci_setup_clang.sh
new file mode 100644
index 00000000..140f9f9d
--- /dev/null
+++ b/3rdparty/spdlog/src/scripts/ci_setup_clang.sh
@@ -0,0 +1,12 @@
+#!/bin/bash
+
+set -ex
+
+VERSION=$1
+
+apt-get update
+apt-get install -y libc++-${VERSION}-dev libc++abi-${VERSION}-dev
+
+if [[ "${VERSION}" -ge 12 ]]; then
+    apt-get install -y --no-install-recommends libunwind-${VERSION}-dev
+fi
diff --git a/3rdparty/spdlog/src/scripts/extract_version.py b/3rdparty/spdlog/src/scripts/extract_version.py
new file mode 100644
index 00000000..79b5728a
--- /dev/null
+++ b/3rdparty/spdlog/src/scripts/extract_version.py
@@ -0,0 +1,17 @@
+#!/usr/bin/env python3
+
+import os
+import re
+
+base_path = os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))
+config_h = os.path.join(base_path, 'include', 'spdlog', 'version.h')
+data = {'MAJOR': 0, 'MINOR': 0, 'PATCH': 0}
+reg = re.compile(r'^\s*#define\s+SPDLOG_VER_([A-Z]+)\s+([0-9]+).*$')
+
+with open(config_h, 'r') as fp:
+    for l in fp:
+        m = reg.match(l)
+        if m:
+            data[m.group(1)] = int(m.group(2))
+
+print(f"{data['MAJOR']}.{data['MINOR']}.{data['PATCH']}")
diff --git a/3rdparty/spdlog/src/scripts/format.sh b/3rdparty/spdlog/src/scripts/format.sh
new file mode 100644
index 00000000..bd5868eb
--- /dev/null
+++ b/3rdparty/spdlog/src/scripts/format.sh
@@ -0,0 +1,16 @@
+#!/bin/bash
+
+cd "$(dirname "$0")"/..
+pwd
+echo -n "Running dos2unix     "
+find . -name "*\.h" -o -name "*\.cpp"|grep -v bundled|xargs -I {} sh -c "dos2unix '{}' 2>/dev/null; echo -n '.'"
+echo
+echo -n "Running clang-format "
+find . -name "*\.h" -o -name "*\.cpp"|grep -v bundled|xargs -I {} sh -c "clang-format -i {}; echo -n '.'"
+echo
+echo -n "Running cmake-format "
+find . -name "CMakeLists.txt" -o -name "*\.cmake"|grep -v bundled|xargs -I {} sh -c "cmake-format --line-width 120 --tab-size 4 --max-subgroups-hwrap 4 -i {}; echo -n '.'"
+echo
+
+
+
diff --git a/3rdparty/spdlog/src/src/async.cpp b/3rdparty/spdlog/src/src/async.cpp
new file mode 100644
index 00000000..5ea8d8f4
--- /dev/null
+++ b/3rdparty/spdlog/src/src/async.cpp
@@ -0,0 +1,11 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#ifndef SPDLOG_COMPILED_LIB
+#    error Please define SPDLOG_COMPILED_LIB to compile this file.
+#endif
+
+#include <spdlog/async.h>
+#include <spdlog/async_logger-inl.h>
+#include <spdlog/details/periodic_worker-inl.h>
+#include <spdlog/details/thread_pool-inl.h>
diff --git a/3rdparty/spdlog/src/src/bundled_fmtlib_format.cpp b/3rdparty/spdlog/src/src/bundled_fmtlib_format.cpp
new file mode 100644
index 00000000..f39e15e1
--- /dev/null
+++ b/3rdparty/spdlog/src/src/bundled_fmtlib_format.cpp
@@ -0,0 +1,46 @@
+// Slightly modified version of fmt lib's format.cc (version 1.9.1) source file.
+// Copyright (c) 2012 - 2016, Victor Zverovich
+// All rights reserved.
+
+#ifndef SPDLOG_COMPILED_LIB
+#    error Please define SPDLOG_COMPILED_LIB to compile this file.
+#endif
+
+#if !defined(SPDLOG_FMT_EXTERNAL) && !defined(SPDLOG_USE_STD_FORMAT)
+
+#    include <spdlog/fmt/bundled/format-inl.h>
+
+FMT_BEGIN_NAMESPACE
+namespace detail {
+
+template FMT_API auto dragonbox::to_decimal(float x) noexcept -> dragonbox::decimal_fp<float>;
+template FMT_API auto dragonbox::to_decimal(double x) noexcept -> dragonbox::decimal_fp<double>;
+
+#    ifndef FMT_STATIC_THOUSANDS_SEPARATOR
+template FMT_API locale_ref::locale_ref(const std::locale &loc);
+template FMT_API auto locale_ref::get<std::locale>() const -> std::locale;
+#    endif
+
+// Explicit instantiations for char.
+
+template FMT_API auto thousands_sep_impl(locale_ref) -> thousands_sep_result<char>;
+template FMT_API auto decimal_point_impl(locale_ref) -> char;
+
+template FMT_API void buffer<char>::append(const char *, const char *);
+
+// DEPRECATED!
+// There is no correspondent extern template in format.h because of
+// incompatibility between clang and gcc (#2377).
+template FMT_API void vformat_to(buffer<char> &, string_view, basic_format_args<FMT_BUFFER_CONTEXT(char)>, locale_ref);
+
+// Explicit instantiations for wchar_t.
+
+template FMT_API auto thousands_sep_impl(locale_ref) -> thousands_sep_result<wchar_t>;
+template FMT_API auto decimal_point_impl(locale_ref) -> wchar_t;
+
+template FMT_API void buffer<wchar_t>::append(const wchar_t *, const wchar_t *);
+
+} // namespace detail
+FMT_END_NAMESPACE
+
+#endif // !SPDLOG_FMT_EXTERNAL
diff --git a/3rdparty/spdlog/src/src/cfg.cpp b/3rdparty/spdlog/src/src/cfg.cpp
new file mode 100644
index 00000000..e5713cca
--- /dev/null
+++ b/3rdparty/spdlog/src/src/cfg.cpp
@@ -0,0 +1,8 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#ifndef SPDLOG_COMPILED_LIB
+#    error Please define SPDLOG_COMPILED_LIB to compile this file.
+#endif
+
+#include <spdlog/cfg/helpers-inl.h>
diff --git a/3rdparty/spdlog/src/src/color_sinks.cpp b/3rdparty/spdlog/src/src/color_sinks.cpp
new file mode 100644
index 00000000..38fa308c
--- /dev/null
+++ b/3rdparty/spdlog/src/src/color_sinks.cpp
@@ -0,0 +1,51 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#ifndef SPDLOG_COMPILED_LIB
+#    error Please define SPDLOG_COMPILED_LIB to compile this file.
+#endif
+
+#include <mutex>
+
+#include <spdlog/details/null_mutex.h>
+#include <spdlog/async.h>
+//
+// color sinks
+//
+#ifdef _WIN32
+#    include <spdlog/sinks/wincolor_sink-inl.h>
+template class SPDLOG_API spdlog::sinks::wincolor_sink<spdlog::details::console_mutex>;
+template class SPDLOG_API spdlog::sinks::wincolor_sink<spdlog::details::console_nullmutex>;
+template class SPDLOG_API spdlog::sinks::wincolor_stdout_sink<spdlog::details::console_mutex>;
+template class SPDLOG_API spdlog::sinks::wincolor_stdout_sink<spdlog::details::console_nullmutex>;
+template class SPDLOG_API spdlog::sinks::wincolor_stderr_sink<spdlog::details::console_mutex>;
+template class SPDLOG_API spdlog::sinks::wincolor_stderr_sink<spdlog::details::console_nullmutex>;
+#else
+#    include "spdlog/sinks/ansicolor_sink-inl.h"
+template class SPDLOG_API spdlog::sinks::ansicolor_sink<spdlog::details::console_mutex>;
+template class SPDLOG_API spdlog::sinks::ansicolor_sink<spdlog::details::console_nullmutex>;
+template class SPDLOG_API spdlog::sinks::ansicolor_stdout_sink<spdlog::details::console_mutex>;
+template class SPDLOG_API spdlog::sinks::ansicolor_stdout_sink<spdlog::details::console_nullmutex>;
+template class SPDLOG_API spdlog::sinks::ansicolor_stderr_sink<spdlog::details::console_mutex>;
+template class SPDLOG_API spdlog::sinks::ansicolor_stderr_sink<spdlog::details::console_nullmutex>;
+#endif
+
+// factory methods for color loggers
+#include "spdlog/sinks/stdout_color_sinks-inl.h"
+template SPDLOG_API std::shared_ptr<spdlog::logger> spdlog::stdout_color_mt<spdlog::synchronous_factory>(
+    const std::string &logger_name, color_mode mode);
+template SPDLOG_API std::shared_ptr<spdlog::logger> spdlog::stdout_color_st<spdlog::synchronous_factory>(
+    const std::string &logger_name, color_mode mode);
+template SPDLOG_API std::shared_ptr<spdlog::logger> spdlog::stderr_color_mt<spdlog::synchronous_factory>(
+    const std::string &logger_name, color_mode mode);
+template SPDLOG_API std::shared_ptr<spdlog::logger> spdlog::stderr_color_st<spdlog::synchronous_factory>(
+    const std::string &logger_name, color_mode mode);
+
+template SPDLOG_API std::shared_ptr<spdlog::logger> spdlog::stdout_color_mt<spdlog::async_factory>(
+    const std::string &logger_name, color_mode mode);
+template SPDLOG_API std::shared_ptr<spdlog::logger> spdlog::stdout_color_st<spdlog::async_factory>(
+    const std::string &logger_name, color_mode mode);
+template SPDLOG_API std::shared_ptr<spdlog::logger> spdlog::stderr_color_mt<spdlog::async_factory>(
+    const std::string &logger_name, color_mode mode);
+template SPDLOG_API std::shared_ptr<spdlog::logger> spdlog::stderr_color_st<spdlog::async_factory>(
+    const std::string &logger_name, color_mode mode);
diff --git a/3rdparty/spdlog/src/src/file_sinks.cpp b/3rdparty/spdlog/src/src/file_sinks.cpp
new file mode 100644
index 00000000..10ffba60
--- /dev/null
+++ b/3rdparty/spdlog/src/src/file_sinks.cpp
@@ -0,0 +1,20 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#ifndef SPDLOG_COMPILED_LIB
+#    error Please define SPDLOG_COMPILED_LIB to compile this file.
+#endif
+
+#include <spdlog/details/null_mutex.h>
+#include <spdlog/details/file_helper-inl.h>
+#include <spdlog/sinks/basic_file_sink-inl.h>
+#include <spdlog/sinks/base_sink-inl.h>
+
+#include <mutex>
+
+template class SPDLOG_API spdlog::sinks::basic_file_sink<std::mutex>;
+template class SPDLOG_API spdlog::sinks::basic_file_sink<spdlog::details::null_mutex>;
+
+#include <spdlog/sinks/rotating_file_sink-inl.h>
+template class SPDLOG_API spdlog::sinks::rotating_file_sink<std::mutex>;
+template class SPDLOG_API spdlog::sinks::rotating_file_sink<spdlog::details::null_mutex>;
diff --git a/3rdparty/spdlog/src/src/spdlog.cpp b/3rdparty/spdlog/src/src/spdlog.cpp
new file mode 100644
index 00000000..c86d8fff
--- /dev/null
+++ b/3rdparty/spdlog/src/src/spdlog.cpp
@@ -0,0 +1,26 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#ifndef SPDLOG_COMPILED_LIB
+#    error Please define SPDLOG_COMPILED_LIB to compile this file.
+#endif
+
+#include <spdlog/spdlog-inl.h>
+#include <spdlog/common-inl.h>
+#include <spdlog/details/backtracer-inl.h>
+#include <spdlog/details/registry-inl.h>
+#include <spdlog/details/os-inl.h>
+#include <spdlog/pattern_formatter-inl.h>
+#include <spdlog/details/log_msg-inl.h>
+#include <spdlog/details/log_msg_buffer-inl.h>
+#include <spdlog/logger-inl.h>
+#include <spdlog/sinks/sink-inl.h>
+#include <spdlog/sinks/base_sink-inl.h>
+#include <spdlog/details/null_mutex.h>
+
+#include <mutex>
+
+// template instantiate logger constructor with sinks init list
+template SPDLOG_API spdlog::logger::logger(std::string name, sinks_init_list::iterator begin, sinks_init_list::iterator end);
+template class SPDLOG_API spdlog::sinks::base_sink<std::mutex>;
+template class SPDLOG_API spdlog::sinks::base_sink<spdlog::details::null_mutex>;
diff --git a/3rdparty/spdlog/src/src/stdout_sinks.cpp b/3rdparty/spdlog/src/src/stdout_sinks.cpp
new file mode 100644
index 00000000..2d5256a4
--- /dev/null
+++ b/3rdparty/spdlog/src/src/stdout_sinks.cpp
@@ -0,0 +1,29 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#ifndef SPDLOG_COMPILED_LIB
+#    error Please define SPDLOG_COMPILED_LIB to compile this file.
+#endif
+
+#include <mutex>
+
+#include <spdlog/details/null_mutex.h>
+#include <spdlog/async.h>
+#include <spdlog/sinks/stdout_sinks-inl.h>
+
+template class SPDLOG_API spdlog::sinks::stdout_sink_base<spdlog::details::console_mutex>;
+template class SPDLOG_API spdlog::sinks::stdout_sink_base<spdlog::details::console_nullmutex>;
+template class SPDLOG_API spdlog::sinks::stdout_sink<spdlog::details::console_mutex>;
+template class SPDLOG_API spdlog::sinks::stdout_sink<spdlog::details::console_nullmutex>;
+template class SPDLOG_API spdlog::sinks::stderr_sink<spdlog::details::console_mutex>;
+template class SPDLOG_API spdlog::sinks::stderr_sink<spdlog::details::console_nullmutex>;
+
+template SPDLOG_API std::shared_ptr<spdlog::logger> spdlog::stdout_logger_mt<spdlog::synchronous_factory>(const std::string &logger_name);
+template SPDLOG_API std::shared_ptr<spdlog::logger> spdlog::stdout_logger_st<spdlog::synchronous_factory>(const std::string &logger_name);
+template SPDLOG_API std::shared_ptr<spdlog::logger> spdlog::stderr_logger_mt<spdlog::synchronous_factory>(const std::string &logger_name);
+template SPDLOG_API std::shared_ptr<spdlog::logger> spdlog::stderr_logger_st<spdlog::synchronous_factory>(const std::string &logger_name);
+
+template SPDLOG_API std::shared_ptr<spdlog::logger> spdlog::stdout_logger_mt<spdlog::async_factory>(const std::string &logger_name);
+template SPDLOG_API std::shared_ptr<spdlog::logger> spdlog::stdout_logger_st<spdlog::async_factory>(const std::string &logger_name);
+template SPDLOG_API std::shared_ptr<spdlog::logger> spdlog::stderr_logger_mt<spdlog::async_factory>(const std::string &logger_name);
+template SPDLOG_API std::shared_ptr<spdlog::logger> spdlog::stderr_logger_st<spdlog::async_factory>(const std::string &logger_name);
diff --git a/3rdparty/spdlog/src/tests/CMakeLists.txt b/3rdparty/spdlog/src/tests/CMakeLists.txt
new file mode 100644
index 00000000..131b22f8
--- /dev/null
+++ b/3rdparty/spdlog/src/tests/CMakeLists.txt
@@ -0,0 +1,86 @@
+cmake_minimum_required(VERSION 3.10)
+project(spdlog_utests CXX)
+
+if(NOT TARGET spdlog)
+    # Stand-alone build
+    find_package(spdlog REQUIRED)
+endif()
+
+include(../cmake/utils.cmake)
+
+find_package(PkgConfig)
+if(PkgConfig_FOUND)
+    pkg_check_modules(systemd libsystemd)
+endif()
+
+find_package(Catch2 3 QUIET)
+if (Catch2_FOUND)
+    message(STATUS "Packaged version of Catch will be used.")
+else()
+    message(STATUS "Bundled version of Catch will be downloaded and used.")
+    include(FetchContent)
+    FetchContent_Declare(
+        Catch2
+        GIT_REPOSITORY https://github.com/catchorg/Catch2.git
+        GIT_TAG v3.3.2
+    )
+    FetchContent_MakeAvailable(Catch2)
+endif()
+
+set(SPDLOG_UTESTS_SOURCES
+    test_file_helper.cpp
+    test_file_logging.cpp
+    test_daily_logger.cpp
+    test_misc.cpp
+    test_eventlog.cpp
+    test_pattern_formatter.cpp
+    test_async.cpp
+    test_registry.cpp
+    test_macros.cpp
+    utils.cpp
+    main.cpp
+    test_mpmc_q.cpp
+    test_dup_filter.cpp
+    test_fmt_helper.cpp
+    test_stdout_api.cpp
+    test_backtrace.cpp
+    test_create_dir.cpp
+    test_custom_callbacks.cpp
+    test_cfg.cpp
+    test_time_point.cpp
+    test_stopwatch.cpp)
+
+if(NOT SPDLOG_NO_EXCEPTIONS)
+    list(APPEND SPDLOG_UTESTS_SOURCES test_errors.cpp)
+endif()
+
+if(systemd_FOUND)
+    list(APPEND SPDLOG_UTESTS_SOURCES test_systemd.cpp)
+endif()
+
+enable_testing()
+
+function(spdlog_prepare_test test_target spdlog_lib)
+    add_executable(${test_target} ${SPDLOG_UTESTS_SOURCES})
+    spdlog_enable_warnings(${test_target})
+    target_link_libraries(${test_target} PRIVATE ${spdlog_lib})
+    if(systemd_FOUND)
+        target_link_libraries(${test_target} PRIVATE ${systemd_LIBRARIES})
+    endif()
+    target_link_libraries(${test_target} PRIVATE Catch2::Catch2WithMain)
+    if(SPDLOG_SANITIZE_ADDRESS)
+        spdlog_enable_sanitizer(${test_target})
+    endif()
+    add_test(NAME ${test_target} COMMAND ${test_target})
+    set_tests_properties(${test_target} PROPERTIES RUN_SERIAL ON)
+endfunction()
+
+# The compiled library tests
+if(SPDLOG_BUILD_TESTS OR SPDLOG_BUILD_ALL)
+    spdlog_prepare_test(spdlog-utests spdlog::spdlog)
+endif()
+
+# The header-only library version tests
+if(SPDLOG_BUILD_TESTS_HO OR SPDLOG_BUILD_ALL)
+    spdlog_prepare_test(spdlog-utests-ho spdlog::spdlog_header_only)
+endif()
diff --git a/3rdparty/spdlog/src/tests/includes.h b/3rdparty/spdlog/src/tests/includes.h
new file mode 100644
index 00000000..6e46992b
--- /dev/null
+++ b/3rdparty/spdlog/src/tests/includes.h
@@ -0,0 +1,36 @@
+#pragma once
+
+#if defined(__GNUC__) && __GNUC__ == 12
+#    pragma GCC diagnostic push
+#    pragma GCC diagnostic ignored "-Wmaybe-uninitialized" // Workaround for GCC 12
+#endif
+#include <catch2/catch_all.hpp>
+#if defined(__GNUC__) && __GNUC__ == 12
+#    pragma GCC diagnostic pop
+#endif
+
+#include "utils.h"
+#include <chrono>
+#include <cstdio>
+#include <exception>
+#include <fstream>
+#include <iostream>
+#include <ostream>
+#include <sstream>
+#include <string>
+#include <iomanip>
+#include <stdlib.h>
+
+#define SPDLOG_ACTIVE_LEVEL SPDLOG_LEVEL_DEBUG
+
+#include "spdlog/spdlog.h"
+#include "spdlog/async.h"
+#include "spdlog/details/fmt_helper.h"
+#include "spdlog/sinks/basic_file_sink.h"
+#include "spdlog/sinks/daily_file_sink.h"
+#include "spdlog/sinks/null_sink.h"
+#include "spdlog/sinks/ostream_sink.h"
+#include "spdlog/sinks/rotating_file_sink.h"
+#include "spdlog/sinks/stdout_color_sinks.h"
+#include "spdlog/sinks/msvc_sink.h"
+#include "spdlog/pattern_formatter.h"
diff --git a/3rdparty/spdlog/src/tests/main.cpp b/3rdparty/spdlog/src/tests/main.cpp
new file mode 100644
index 00000000..c8dca193
--- /dev/null
+++ b/3rdparty/spdlog/src/tests/main.cpp
@@ -0,0 +1,10 @@
+#if defined(__GNUC__) && __GNUC__ == 12
+#    pragma GCC diagnostic push
+#    pragma GCC diagnostic ignored "-Wmaybe-uninitialized" // Workaround for GCC 12
+#endif
+
+#include <catch2/catch_all.hpp>
+
+#if defined(__GNUC__) && __GNUC__ == 12
+#    pragma GCC diagnostic pop
+#endif
diff --git a/3rdparty/spdlog/src/tests/test_async.cpp b/3rdparty/spdlog/src/tests/test_async.cpp
new file mode 100644
index 00000000..5265bca4
--- /dev/null
+++ b/3rdparty/spdlog/src/tests/test_async.cpp
@@ -0,0 +1,190 @@
+#include "includes.h"
+#include "spdlog/async.h"
+#include "spdlog/sinks/basic_file_sink.h"
+#include "test_sink.h"
+
+#define TEST_FILENAME "test_logs/async_test.log"
+
+TEST_CASE("basic async test ", "[async]")
+{
+    auto test_sink = std::make_shared<spdlog::sinks::test_sink_mt>();
+    size_t overrun_counter = 0;
+    size_t queue_size = 128;
+    size_t messages = 256;
+    {
+        auto tp = std::make_shared<spdlog::details::thread_pool>(queue_size, 1);
+        auto logger = std::make_shared<spdlog::async_logger>("as", test_sink, tp, spdlog::async_overflow_policy::block);
+        for (size_t i = 0; i < messages; i++)
+        {
+            logger->info("Hello message #{}", i);
+        }
+        logger->flush();
+        overrun_counter = tp->overrun_counter();
+    }
+    REQUIRE(test_sink->msg_counter() == messages);
+    REQUIRE(test_sink->flush_counter() == 1);
+    REQUIRE(overrun_counter == 0);
+}
+
+TEST_CASE("discard policy ", "[async]")
+{
+    auto test_sink = std::make_shared<spdlog::sinks::test_sink_mt>();
+    test_sink->set_delay(std::chrono::milliseconds(1));
+    size_t queue_size = 4;
+    size_t messages = 1024;
+
+    auto tp = std::make_shared<spdlog::details::thread_pool>(queue_size, 1);
+    auto logger = std::make_shared<spdlog::async_logger>("as", test_sink, tp, spdlog::async_overflow_policy::overrun_oldest);
+    for (size_t i = 0; i < messages; i++)
+    {
+        logger->info("Hello message");
+    }
+    REQUIRE(test_sink->msg_counter() < messages);
+    REQUIRE(tp->overrun_counter() > 0);
+}
+
+TEST_CASE("discard policy using factory ", "[async]")
+{
+    size_t queue_size = 4;
+    size_t messages = 1024;
+    spdlog::init_thread_pool(queue_size, 1);
+
+    auto logger = spdlog::create_async_nb<spdlog::sinks::test_sink_mt>("as2");
+    auto test_sink = std::static_pointer_cast<spdlog::sinks::test_sink_mt>(logger->sinks()[0]);
+    test_sink->set_delay(std::chrono::milliseconds(3));
+
+    for (size_t i = 0; i < messages; i++)
+    {
+        logger->info("Hello message");
+    }
+
+    REQUIRE(test_sink->msg_counter() < messages);
+    spdlog::drop_all();
+}
+
+TEST_CASE("flush", "[async]")
+{
+    auto test_sink = std::make_shared<spdlog::sinks::test_sink_mt>();
+    size_t queue_size = 256;
+    size_t messages = 256;
+    {
+        auto tp = std::make_shared<spdlog::details::thread_pool>(queue_size, 1);
+        auto logger = std::make_shared<spdlog::async_logger>("as", test_sink, tp, spdlog::async_overflow_policy::block);
+        for (size_t i = 0; i < messages; i++)
+        {
+            logger->info("Hello message #{}", i);
+        }
+
+        logger->flush();
+    }
+    // std::this_thread::sleep_for(std::chrono::milliseconds(250));
+    REQUIRE(test_sink->msg_counter() == messages);
+    REQUIRE(test_sink->flush_counter() == 1);
+}
+
+TEST_CASE("async periodic flush", "[async]")
+{
+
+    auto logger = spdlog::create_async<spdlog::sinks::test_sink_mt>("as");
+    auto test_sink = std::static_pointer_cast<spdlog::sinks::test_sink_mt>(logger->sinks()[0]);
+
+    spdlog::flush_every(std::chrono::seconds(1));
+    std::this_thread::sleep_for(std::chrono::milliseconds(1700));
+    REQUIRE(test_sink->flush_counter() == 1);
+    spdlog::flush_every(std::chrono::seconds(0));
+    spdlog::drop_all();
+}
+
+TEST_CASE("tp->wait_empty() ", "[async]")
+{
+    auto test_sink = std::make_shared<spdlog::sinks::test_sink_mt>();
+    test_sink->set_delay(std::chrono::milliseconds(5));
+    size_t messages = 100;
+
+    auto tp = std::make_shared<spdlog::details::thread_pool>(messages, 2);
+    auto logger = std::make_shared<spdlog::async_logger>("as", test_sink, tp, spdlog::async_overflow_policy::block);
+    for (size_t i = 0; i < messages; i++)
+    {
+        logger->info("Hello message #{}", i);
+    }
+    logger->flush();
+    tp.reset();
+
+    REQUIRE(test_sink->msg_counter() == messages);
+    REQUIRE(test_sink->flush_counter() == 1);
+}
+
+TEST_CASE("multi threads", "[async]")
+{
+    auto test_sink = std::make_shared<spdlog::sinks::test_sink_mt>();
+    size_t queue_size = 128;
+    size_t messages = 256;
+    size_t n_threads = 10;
+    {
+        auto tp = std::make_shared<spdlog::details::thread_pool>(queue_size, 1);
+        auto logger = std::make_shared<spdlog::async_logger>("as", test_sink, tp, spdlog::async_overflow_policy::block);
+
+        std::vector<std::thread> threads;
+        for (size_t i = 0; i < n_threads; i++)
+        {
+            threads.emplace_back([logger, messages] {
+                for (size_t j = 0; j < messages; j++)
+                {
+                    logger->info("Hello message #{}", j);
+                }
+            });
+            logger->flush();
+        }
+
+        for (auto &t : threads)
+        {
+            t.join();
+        }
+    }
+
+    REQUIRE(test_sink->msg_counter() == messages * n_threads);
+    REQUIRE(test_sink->flush_counter() == n_threads);
+}
+
+TEST_CASE("to_file", "[async]")
+{
+    prepare_logdir();
+    size_t messages = 1024;
+    size_t tp_threads = 1;
+    spdlog::filename_t filename = SPDLOG_FILENAME_T(TEST_FILENAME);
+    {
+        auto file_sink = std::make_shared<spdlog::sinks::basic_file_sink_mt>(filename, true);
+        auto tp = std::make_shared<spdlog::details::thread_pool>(messages, tp_threads);
+        auto logger = std::make_shared<spdlog::async_logger>("as", std::move(file_sink), std::move(tp));
+
+        for (size_t j = 0; j < messages; j++)
+        {
+            logger->info("Hello message #{}", j);
+        }
+    }
+
+    require_message_count(TEST_FILENAME, messages);
+    auto contents = file_contents(TEST_FILENAME);
+    using spdlog::details::os::default_eol;
+    REQUIRE(ends_with(contents, spdlog::fmt_lib::format("Hello message #1023{}", default_eol)));
+}
+
+TEST_CASE("to_file multi-workers", "[async]")
+{
+    prepare_logdir();
+    size_t messages = 1024 * 10;
+    size_t tp_threads = 10;
+    spdlog::filename_t filename = SPDLOG_FILENAME_T(TEST_FILENAME);
+    {
+        auto file_sink = std::make_shared<spdlog::sinks::basic_file_sink_mt>(filename, true);
+        auto tp = std::make_shared<spdlog::details::thread_pool>(messages, tp_threads);
+        auto logger = std::make_shared<spdlog::async_logger>("as", std::move(file_sink), std::move(tp));
+
+        for (size_t j = 0; j < messages; j++)
+        {
+            logger->info("Hello message #{}", j);
+        }
+    }
+
+    require_message_count(TEST_FILENAME, messages);
+}
diff --git a/3rdparty/spdlog/src/tests/test_backtrace.cpp b/3rdparty/spdlog/src/tests/test_backtrace.cpp
new file mode 100644
index 00000000..6cf9ec55
--- /dev/null
+++ b/3rdparty/spdlog/src/tests/test_backtrace.cpp
@@ -0,0 +1,78 @@
+#include "includes.h"
+#include "test_sink.h"
+#include "spdlog/async.h"
+
+TEST_CASE("bactrace1", "[bactrace]")
+{
+
+    using spdlog::sinks::test_sink_st;
+    auto test_sink = std::make_shared<test_sink_st>();
+    size_t backtrace_size = 5;
+
+    spdlog::logger logger("test-backtrace", test_sink);
+    logger.set_pattern("%v");
+    logger.enable_backtrace(backtrace_size);
+
+    logger.info("info message");
+    for (int i = 0; i < 100; i++)
+        logger.debug("debug message {}", i);
+
+    REQUIRE(test_sink->lines().size() == 1);
+    REQUIRE(test_sink->lines()[0] == "info message");
+
+    logger.dump_backtrace();
+    REQUIRE(test_sink->lines().size() == backtrace_size + 3);
+    REQUIRE(test_sink->lines()[1] == "****************** Backtrace Start ******************");
+    REQUIRE(test_sink->lines()[2] == "debug message 95");
+    REQUIRE(test_sink->lines()[3] == "debug message 96");
+    REQUIRE(test_sink->lines()[4] == "debug message 97");
+    REQUIRE(test_sink->lines()[5] == "debug message 98");
+    REQUIRE(test_sink->lines()[6] == "debug message 99");
+    REQUIRE(test_sink->lines()[7] == "****************** Backtrace End ********************");
+}
+
+TEST_CASE("bactrace-empty", "[bactrace]")
+{
+    using spdlog::sinks::test_sink_st;
+    auto test_sink = std::make_shared<test_sink_st>();
+    size_t backtrace_size = 5;
+
+    spdlog::logger logger("test-backtrace", test_sink);
+    logger.set_pattern("%v");
+    logger.enable_backtrace(backtrace_size);
+    logger.dump_backtrace();
+    REQUIRE(test_sink->lines().size() == 0);
+}
+
+TEST_CASE("bactrace-async", "[bactrace]")
+{
+    using spdlog::sinks::test_sink_mt;
+    auto test_sink = std::make_shared<test_sink_mt>();
+    using spdlog::details::os::sleep_for_millis;
+
+    size_t backtrace_size = 5;
+
+    spdlog::init_thread_pool(120, 1);
+    auto logger = std::make_shared<spdlog::async_logger>("test-bactrace-async", test_sink, spdlog::thread_pool());
+    logger->set_pattern("%v");
+    logger->enable_backtrace(backtrace_size);
+
+    logger->info("info message");
+    for (int i = 0; i < 100; i++)
+        logger->debug("debug message {}", i);
+
+    sleep_for_millis(100);
+    REQUIRE(test_sink->lines().size() == 1);
+    REQUIRE(test_sink->lines()[0] == "info message");
+
+    logger->dump_backtrace();
+    sleep_for_millis(100); //  give time for the async dump to complete
+    REQUIRE(test_sink->lines().size() == backtrace_size + 3);
+    REQUIRE(test_sink->lines()[1] == "****************** Backtrace Start ******************");
+    REQUIRE(test_sink->lines()[2] == "debug message 95");
+    REQUIRE(test_sink->lines()[3] == "debug message 96");
+    REQUIRE(test_sink->lines()[4] == "debug message 97");
+    REQUIRE(test_sink->lines()[5] == "debug message 98");
+    REQUIRE(test_sink->lines()[6] == "debug message 99");
+    REQUIRE(test_sink->lines()[7] == "****************** Backtrace End ********************");
+}
diff --git a/3rdparty/spdlog/src/tests/test_cfg.cpp b/3rdparty/spdlog/src/tests/test_cfg.cpp
new file mode 100644
index 00000000..11aefa20
--- /dev/null
+++ b/3rdparty/spdlog/src/tests/test_cfg.cpp
@@ -0,0 +1,183 @@
+
+#include "includes.h"
+#include "test_sink.h"
+
+#include <spdlog/cfg/env.h>
+#include <spdlog/cfg/argv.h>
+
+using spdlog::cfg::load_argv_levels;
+using spdlog::cfg::load_env_levels;
+using spdlog::sinks::test_sink_st;
+
+TEST_CASE("env", "[cfg]")
+{
+    spdlog::drop("l1");
+    auto l1 = spdlog::create<test_sink_st>("l1");
+#ifdef CATCH_PLATFORM_WINDOWS
+    _putenv_s("SPDLOG_LEVEL", "l1=warn");
+#else
+    setenv("SPDLOG_LEVEL", "l1=warn", 1);
+#endif
+    load_env_levels();
+    REQUIRE(l1->level() == spdlog::level::warn);
+    spdlog::set_default_logger(spdlog::create<test_sink_st>("cfg-default"));
+    REQUIRE(spdlog::default_logger()->level() == spdlog::level::info);
+}
+
+TEST_CASE("argv1", "[cfg]")
+{
+    spdlog::drop("l1");
+    const char *argv[] = {"ignore", "SPDLOG_LEVEL=l1=warn"};
+    load_argv_levels(2, argv);
+    auto l1 = spdlog::create<spdlog::sinks::test_sink_st>("l1");
+    REQUIRE(l1->level() == spdlog::level::warn);
+    REQUIRE(spdlog::default_logger()->level() == spdlog::level::info);
+}
+
+TEST_CASE("argv2", "[cfg]")
+{
+    spdlog::drop("l1");
+    const char *argv[] = {"ignore", "SPDLOG_LEVEL=l1=warn,trace"};
+    load_argv_levels(2, argv);
+    auto l1 = spdlog::create<test_sink_st>("l1");
+    REQUIRE(l1->level() == spdlog::level::warn);
+    REQUIRE(spdlog::default_logger()->level() == spdlog::level::trace);
+}
+
+TEST_CASE("argv3", "[cfg]")
+{
+    spdlog::set_level(spdlog::level::trace);
+
+    spdlog::drop("l1");
+    const char *argv[] = {"ignore", "SPDLOG_LEVEL=junk_name=warn"};
+    load_argv_levels(2, argv);
+    auto l1 = spdlog::create<test_sink_st>("l1");
+    REQUIRE(l1->level() == spdlog::level::trace);
+    REQUIRE(spdlog::default_logger()->level() == spdlog::level::trace);
+}
+
+TEST_CASE("argv4", "[cfg]")
+{
+    spdlog::set_level(spdlog::level::info);
+    spdlog::drop("l1");
+    const char *argv[] = {"ignore", "SPDLOG_LEVEL=junk"};
+    load_argv_levels(2, argv);
+    auto l1 = spdlog::create<test_sink_st>("l1");
+    REQUIRE(l1->level() == spdlog::level::info);
+}
+
+TEST_CASE("argv5", "[cfg]")
+{
+    spdlog::set_level(spdlog::level::info);
+    spdlog::drop("l1");
+    const char *argv[] = {"ignore", "ignore", "SPDLOG_LEVEL=l1=warn,trace"};
+    load_argv_levels(3, argv);
+    auto l1 = spdlog::create<test_sink_st>("l1");
+    REQUIRE(l1->level() == spdlog::level::warn);
+    REQUIRE(spdlog::default_logger()->level() == spdlog::level::trace);
+    spdlog::set_level(spdlog::level::info);
+}
+
+TEST_CASE("argv6", "[cfg]")
+{
+    spdlog::set_level(spdlog::level::err);
+    const char *argv[] = {""};
+    load_argv_levels(1, argv);
+    REQUIRE(spdlog::default_logger()->level() == spdlog::level::err);
+    spdlog::set_level(spdlog::level::info);
+}
+
+TEST_CASE("argv7", "[cfg]")
+{
+    spdlog::set_level(spdlog::level::err);
+    const char *argv[] = {""};
+    load_argv_levels(0, argv);
+    REQUIRE(spdlog::default_logger()->level() == spdlog::level::err);
+    spdlog::set_level(spdlog::level::info);
+}
+
+TEST_CASE("level-not-set-test1", "[cfg]")
+{
+    spdlog::drop("l1");
+    const char *argv[] = {"ignore", ""};
+    load_argv_levels(2, argv);
+    auto l1 = spdlog::create<spdlog::sinks::test_sink_st>("l1");
+    l1->set_level(spdlog::level::trace);
+    REQUIRE(l1->level() == spdlog::level::trace);
+    REQUIRE(spdlog::default_logger()->level() == spdlog::level::info);
+}
+
+TEST_CASE("level-not-set-test2", "[cfg]")
+{
+    spdlog::drop("l1");
+    spdlog::drop("l2");
+    const char *argv[] = {"ignore", "SPDLOG_LEVEL=l1=trace"};
+
+    auto l1 = spdlog::create<spdlog::sinks::test_sink_st>("l1");
+    l1->set_level(spdlog::level::warn);
+    auto l2 = spdlog::create<spdlog::sinks::test_sink_st>("l2");
+    l2->set_level(spdlog::level::warn);
+
+    load_argv_levels(2, argv);
+
+    REQUIRE(l1->level() == spdlog::level::trace);
+    REQUIRE(l2->level() == spdlog::level::warn);
+    REQUIRE(spdlog::default_logger()->level() == spdlog::level::info);
+}
+
+TEST_CASE("level-not-set-test3", "[cfg]")
+{
+    spdlog::drop("l1");
+    spdlog::drop("l2");
+    const char *argv[] = {"ignore", "SPDLOG_LEVEL=l1=trace"};
+
+    load_argv_levels(2, argv);
+
+    auto l1 = spdlog::create<spdlog::sinks::test_sink_st>("l1");
+    auto l2 = spdlog::create<spdlog::sinks::test_sink_st>("l2");
+
+    REQUIRE(l1->level() == spdlog::level::trace);
+    REQUIRE(l2->level() == spdlog::level::info);
+    REQUIRE(spdlog::default_logger()->level() == spdlog::level::info);
+}
+
+TEST_CASE("level-not-set-test4", "[cfg]")
+{
+    spdlog::drop("l1");
+    spdlog::drop("l2");
+    const char *argv[] = {"ignore", "SPDLOG_LEVEL=l1=trace,warn"};
+
+    load_argv_levels(2, argv);
+
+    auto l1 = spdlog::create<spdlog::sinks::test_sink_st>("l1");
+    auto l2 = spdlog::create<spdlog::sinks::test_sink_st>("l2");
+
+    REQUIRE(l1->level() == spdlog::level::trace);
+    REQUIRE(l2->level() == spdlog::level::warn);
+    REQUIRE(spdlog::default_logger()->level() == spdlog::level::warn);
+}
+
+TEST_CASE("level-not-set-test5", "[cfg]")
+{
+    spdlog::drop("l1");
+    spdlog::drop("l2");
+    const char *argv[] = {"ignore", "SPDLOG_LEVEL=l1=junk,warn"};
+
+    load_argv_levels(2, argv);
+
+    auto l1 = spdlog::create<spdlog::sinks::test_sink_st>("l1");
+    auto l2 = spdlog::create<spdlog::sinks::test_sink_st>("l2");
+
+    REQUIRE(l1->level() == spdlog::level::warn);
+    REQUIRE(l2->level() == spdlog::level::warn);
+    REQUIRE(spdlog::default_logger()->level() == spdlog::level::warn);
+}
+
+TEST_CASE("restore-to-default", "[cfg]")
+{
+    spdlog::drop("l1");
+    spdlog::drop("l2");
+    const char *argv[] = {"ignore", "SPDLOG_LEVEL=info"};
+    load_argv_levels(2, argv);
+    REQUIRE(spdlog::default_logger()->level() == spdlog::level::info);
+}
diff --git a/3rdparty/spdlog/src/tests/test_create_dir.cpp b/3rdparty/spdlog/src/tests/test_create_dir.cpp
new file mode 100644
index 00000000..f17126bc
--- /dev/null
+++ b/3rdparty/spdlog/src/tests/test_create_dir.cpp
@@ -0,0 +1,75 @@
+/*
+ * This content is released under the MIT License as specified in https://raw.githubusercontent.com/gabime/spdlog/master/LICENSE
+ */
+#include "includes.h"
+
+using spdlog::details::os::create_dir;
+using spdlog::details::os::path_exists;
+
+bool try_create_dir(const spdlog::filename_t &path, const spdlog::filename_t &normalized_path)
+{
+    auto rv = create_dir(path);
+    REQUIRE(rv == true);
+    return path_exists(normalized_path);
+}
+
+TEST_CASE("create_dir", "[create_dir]")
+{
+    prepare_logdir();
+
+    REQUIRE(try_create_dir(SPDLOG_FILENAME_T("test_logs/dir1/dir1"), SPDLOG_FILENAME_T("test_logs/dir1/dir1")));
+    REQUIRE(try_create_dir(SPDLOG_FILENAME_T("test_logs/dir1/dir1"), SPDLOG_FILENAME_T("test_logs/dir1/dir1"))); // test existing
+    REQUIRE(try_create_dir(SPDLOG_FILENAME_T("test_logs/dir1///dir2//"), SPDLOG_FILENAME_T("test_logs/dir1/dir2")));
+    REQUIRE(try_create_dir(SPDLOG_FILENAME_T("./test_logs/dir1/dir3"), SPDLOG_FILENAME_T("test_logs/dir1/dir3")));
+    REQUIRE(try_create_dir(SPDLOG_FILENAME_T("test_logs/../test_logs/dir1/dir4"), SPDLOG_FILENAME_T("test_logs/dir1/dir4")));
+
+#ifdef WIN32
+    // test backslash folder separator
+    REQUIRE(try_create_dir(SPDLOG_FILENAME_T("test_logs\\dir1\\dir222"), SPDLOG_FILENAME_T("test_logs\\dir1\\dir222")));
+    REQUIRE(try_create_dir(SPDLOG_FILENAME_T("test_logs\\dir1\\dir223\\"), SPDLOG_FILENAME_T("test_logs\\dir1\\dir223\\")));
+    REQUIRE(
+        try_create_dir(SPDLOG_FILENAME_T(".\\test_logs\\dir1\\dir2\\dir99\\..\\dir23"), SPDLOG_FILENAME_T("test_logs\\dir1\\dir2\\dir23")));
+    REQUIRE(try_create_dir(SPDLOG_FILENAME_T("test_logs\\..\\test_logs\\dir1\\dir5"), SPDLOG_FILENAME_T("test_logs\\dir1\\dir5")));
+#endif
+}
+
+TEST_CASE("create_invalid_dir", "[create_dir]")
+{
+    REQUIRE(create_dir(SPDLOG_FILENAME_T("")) == false);
+    REQUIRE(create_dir(spdlog::filename_t{}) == false);
+#ifdef __linux__
+    REQUIRE(create_dir("/proc/spdlog-utest") == false);
+#endif
+}
+
+TEST_CASE("dir_name", "[create_dir]")
+{
+    using spdlog::details::os::dir_name;
+    REQUIRE(dir_name(SPDLOG_FILENAME_T("")).empty());
+    REQUIRE(dir_name(SPDLOG_FILENAME_T("dir")).empty());
+
+#ifdef WIN32
+    REQUIRE(dir_name(SPDLOG_FILENAME_T(R"(dir\)")) == SPDLOG_FILENAME_T("dir"));
+    REQUIRE(dir_name(SPDLOG_FILENAME_T(R"(dir\\\)")) == SPDLOG_FILENAME_T(R"(dir\\)"));
+    REQUIRE(dir_name(SPDLOG_FILENAME_T(R"(dir\file)")) == SPDLOG_FILENAME_T("dir"));
+    REQUIRE(dir_name(SPDLOG_FILENAME_T(R"(dir/file)")) == SPDLOG_FILENAME_T("dir"));
+    REQUIRE(dir_name(SPDLOG_FILENAME_T(R"(dir\file.txt)")) == SPDLOG_FILENAME_T("dir"));
+    REQUIRE(dir_name(SPDLOG_FILENAME_T(R"(dir/file)")) == SPDLOG_FILENAME_T("dir"));
+    REQUIRE(dir_name(SPDLOG_FILENAME_T(R"(dir\file.txt\)")) == SPDLOG_FILENAME_T(R"(dir\file.txt)"));
+    REQUIRE(dir_name(SPDLOG_FILENAME_T(R"(\dir\file.txt)")) == SPDLOG_FILENAME_T(R"(\dir)"));
+    REQUIRE(dir_name(SPDLOG_FILENAME_T(R"(\\dir\file.txt)")) == SPDLOG_FILENAME_T(R"(\\dir)"));
+    REQUIRE(dir_name(SPDLOG_FILENAME_T(R"(..\file.txt)")) == SPDLOG_FILENAME_T(".."));
+    REQUIRE(dir_name(SPDLOG_FILENAME_T(R"(.\file.txt)")) == SPDLOG_FILENAME_T("."));
+    REQUIRE(dir_name(SPDLOG_FILENAME_T(R"(c:\\a\b\c\d\file.txt)")) == SPDLOG_FILENAME_T(R"(c:\\a\b\c\d)"));
+    REQUIRE(dir_name(SPDLOG_FILENAME_T(R"(c://a/b/c/d/file.txt)")) == SPDLOG_FILENAME_T(R"(c://a/b/c/d)"));
+#endif
+    REQUIRE(dir_name(SPDLOG_FILENAME_T("dir/")) == SPDLOG_FILENAME_T("dir"));
+    REQUIRE(dir_name(SPDLOG_FILENAME_T("dir///")) == SPDLOG_FILENAME_T("dir//"));
+    REQUIRE(dir_name(SPDLOG_FILENAME_T("dir/file")) == SPDLOG_FILENAME_T("dir"));
+    REQUIRE(dir_name(SPDLOG_FILENAME_T("dir/file.txt")) == SPDLOG_FILENAME_T("dir"));
+    REQUIRE(dir_name(SPDLOG_FILENAME_T("dir/file.txt/")) == SPDLOG_FILENAME_T("dir/file.txt"));
+    REQUIRE(dir_name(SPDLOG_FILENAME_T("/dir/file.txt")) == SPDLOG_FILENAME_T("/dir"));
+    REQUIRE(dir_name(SPDLOG_FILENAME_T("//dir/file.txt")) == SPDLOG_FILENAME_T("//dir"));
+    REQUIRE(dir_name(SPDLOG_FILENAME_T("../file.txt")) == SPDLOG_FILENAME_T(".."));
+    REQUIRE(dir_name(SPDLOG_FILENAME_T("./file.txt")) == SPDLOG_FILENAME_T("."));
+}
diff --git a/3rdparty/spdlog/src/tests/test_custom_callbacks.cpp b/3rdparty/spdlog/src/tests/test_custom_callbacks.cpp
new file mode 100644
index 00000000..78babd79
--- /dev/null
+++ b/3rdparty/spdlog/src/tests/test_custom_callbacks.cpp
@@ -0,0 +1,34 @@
+/*
+ * This content is released under the MIT License as specified in https://raw.githubusercontent.com/gabime/spdlog/master/LICENSE
+ */
+#include "includes.h"
+#include "test_sink.h"
+#include "spdlog/sinks/callback_sink.h"
+#include "spdlog/async.h"
+#include "spdlog/common.h"
+
+TEST_CASE("custom_callback_logger", "[custom_callback_logger]")
+{
+    std::vector<std::string> lines;
+    spdlog::pattern_formatter formatter;
+    auto callback_logger = std::make_shared<spdlog::sinks::callback_sink_st>([&](const spdlog::details::log_msg &msg) {
+        spdlog::memory_buf_t formatted;
+        formatter.format(msg, formatted);
+        auto eol_len = strlen(spdlog::details::os::default_eol);
+        lines.emplace_back(formatted.begin(), formatted.end() - eol_len);
+    });
+    std::shared_ptr<spdlog::sinks::test_sink_st> test_sink(new spdlog::sinks::test_sink_st);
+
+    spdlog::logger logger("test-callback", {callback_logger, test_sink});
+
+    logger.info("test message 1");
+    logger.info("test message 2");
+    logger.info("test message 3");
+
+    std::vector<std::string> ref_lines = test_sink->lines();
+
+    REQUIRE(lines[0] == ref_lines[0]);
+    REQUIRE(lines[1] == ref_lines[1]);
+    REQUIRE(lines[2] == ref_lines[2]);
+    spdlog::drop_all();
+}
diff --git a/3rdparty/spdlog/src/tests/test_daily_logger.cpp b/3rdparty/spdlog/src/tests/test_daily_logger.cpp
new file mode 100644
index 00000000..82f28941
--- /dev/null
+++ b/3rdparty/spdlog/src/tests/test_daily_logger.cpp
@@ -0,0 +1,183 @@
+/*
+ * This content is released under the MIT License as specified in https://raw.githubusercontent.com/gabime/spdlog/master/LICENSE
+ */
+#include "includes.h"
+
+#ifdef SPDLOG_USE_STD_FORMAT
+using filename_memory_buf_t = std::basic_string<spdlog::filename_t::value_type>;
+#else
+using filename_memory_buf_t = fmt::basic_memory_buffer<spdlog::filename_t::value_type, 250>;
+#endif
+
+#ifdef SPDLOG_WCHAR_FILENAMES
+std::string filename_buf_to_utf8string(const filename_memory_buf_t &w)
+{
+    spdlog::memory_buf_t buf;
+    spdlog::details::os::wstr_to_utf8buf(spdlog::wstring_view_t(w.data(), w.size()), buf);
+    return SPDLOG_BUF_TO_STRING(buf);
+}
+#else
+std::string filename_buf_to_utf8string(const filename_memory_buf_t &w)
+{
+    return SPDLOG_BUF_TO_STRING(w);
+}
+#endif
+
+TEST_CASE("daily_logger with dateonly calculator", "[daily_logger]")
+{
+    using sink_type = spdlog::sinks::daily_file_sink<std::mutex, spdlog::sinks::daily_filename_calculator>;
+
+    prepare_logdir();
+
+    // calculate filename (time based)
+    spdlog::filename_t basename = SPDLOG_FILENAME_T("test_logs/daily_dateonly");
+    std::tm tm = spdlog::details::os::localtime();
+    filename_memory_buf_t w;
+    spdlog::fmt_lib::format_to(
+        std::back_inserter(w), SPDLOG_FILENAME_T("{}_{:04d}-{:02d}-{:02d}"), basename, tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday);
+
+    auto logger = spdlog::create<sink_type>("logger", basename, 0, 0);
+    for (int i = 0; i < 10; ++i)
+    {
+
+        logger->info("Test message {}", i);
+    }
+    logger->flush();
+
+    require_message_count(filename_buf_to_utf8string(w), 10);
+}
+
+struct custom_daily_file_name_calculator
+{
+    static spdlog::filename_t calc_filename(const spdlog::filename_t &basename, const tm &now_tm)
+    {
+        filename_memory_buf_t w;
+        spdlog::fmt_lib::format_to(std::back_inserter(w), SPDLOG_FILENAME_T("{}{:04d}{:02d}{:02d}"), basename, now_tm.tm_year + 1900,
+            now_tm.tm_mon + 1, now_tm.tm_mday);
+
+        return SPDLOG_BUF_TO_STRING(w);
+    }
+};
+
+TEST_CASE("daily_logger with custom calculator", "[daily_logger]")
+{
+    using sink_type = spdlog::sinks::daily_file_sink<std::mutex, custom_daily_file_name_calculator>;
+
+    prepare_logdir();
+
+    // calculate filename (time based)
+    spdlog::filename_t basename = SPDLOG_FILENAME_T("test_logs/daily_dateonly");
+    std::tm tm = spdlog::details::os::localtime();
+    filename_memory_buf_t w;
+    spdlog::fmt_lib::format_to(
+        std::back_inserter(w), SPDLOG_FILENAME_T("{}{:04d}{:02d}{:02d}"), basename, tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday);
+
+    auto logger = spdlog::create<sink_type>("logger", basename, 0, 0);
+    for (int i = 0; i < 10; ++i)
+    {
+        logger->info("Test message {}", i);
+    }
+
+    logger->flush();
+
+    require_message_count(filename_buf_to_utf8string(w), 10);
+}
+
+/*
+ * File name calculations
+ */
+
+TEST_CASE("rotating_file_sink::calc_filename1", "[rotating_file_sink]")
+{
+    auto filename = spdlog::sinks::rotating_file_sink_st::calc_filename(SPDLOG_FILENAME_T("rotated.txt"), 3);
+    REQUIRE(filename == SPDLOG_FILENAME_T("rotated.3.txt"));
+}
+
+TEST_CASE("rotating_file_sink::calc_filename2", "[rotating_file_sink]")
+{
+    auto filename = spdlog::sinks::rotating_file_sink_st::calc_filename(SPDLOG_FILENAME_T("rotated"), 3);
+    REQUIRE(filename == SPDLOG_FILENAME_T("rotated.3"));
+}
+
+TEST_CASE("rotating_file_sink::calc_filename3", "[rotating_file_sink]")
+{
+    auto filename = spdlog::sinks::rotating_file_sink_st::calc_filename(SPDLOG_FILENAME_T("rotated.txt"), 0);
+    REQUIRE(filename == SPDLOG_FILENAME_T("rotated.txt"));
+}
+
+// regex supported only from gcc 4.9 and above
+#if defined(_MSC_VER) || !(__GNUC__ <= 4 && __GNUC_MINOR__ < 9)
+
+#    include <regex>
+
+TEST_CASE("daily_file_sink::daily_filename_calculator", "[daily_file_sink]")
+{
+    // daily_YYYY-MM-DD_hh-mm.txt
+    auto filename =
+        spdlog::sinks::daily_filename_calculator::calc_filename(SPDLOG_FILENAME_T("daily.txt"), spdlog::details::os::localtime());
+    // date regex based on https://www.regular-expressions.info/dates.html
+    std::basic_regex<spdlog::filename_t::value_type> re(
+        SPDLOG_FILENAME_T(R"(^daily_(19|20)\d\d-(0[1-9]|1[012])-(0[1-9]|[12][0-9]|3[01])\.txt$)"));
+    std::match_results<spdlog::filename_t::const_iterator> match;
+    REQUIRE(std::regex_match(filename, match, re));
+}
+#endif
+
+TEST_CASE("daily_file_sink::daily_filename_format_calculator", "[daily_file_sink]")
+{
+    std::tm tm = spdlog::details::os::localtime();
+    // example-YYYY-MM-DD.log
+    auto filename = spdlog::sinks::daily_filename_format_calculator::calc_filename(SPDLOG_FILENAME_T("example-%Y-%m-%d.log"), tm);
+
+    REQUIRE(filename ==
+            spdlog::fmt_lib::format(SPDLOG_FILENAME_T("example-{:04d}-{:02d}-{:02d}.log"), tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday));
+}
+
+/* Test removal of old files */
+static spdlog::details::log_msg create_msg(std::chrono::seconds offset)
+{
+    using spdlog::log_clock;
+    spdlog::details::log_msg msg{"test", spdlog::level::info, "Hello Message"};
+    msg.time = log_clock::now() + offset;
+    return msg;
+}
+
+static void test_rotate(int days_to_run, uint16_t max_days, uint16_t expected_n_files)
+{
+    using spdlog::log_clock;
+    using spdlog::details::log_msg;
+    using spdlog::sinks::daily_file_sink_st;
+
+    prepare_logdir();
+
+    spdlog::filename_t basename = SPDLOG_FILENAME_T("test_logs/daily_rotate.txt");
+    daily_file_sink_st sink{basename, 2, 30, true, max_days};
+
+    // simulate messages with 24 intervals
+
+    for (int i = 0; i < days_to_run; i++)
+    {
+        auto offset = std::chrono::seconds{24 * 3600 * i};
+        sink.log(create_msg(offset));
+    }
+
+    REQUIRE(count_files("test_logs") == static_cast<size_t>(expected_n_files));
+}
+
+TEST_CASE("daily_logger rotate", "[daily_file_sink]")
+{
+    int days_to_run = 1;
+    test_rotate(days_to_run, 0, 1);
+    test_rotate(days_to_run, 1, 1);
+    test_rotate(days_to_run, 3, 1);
+    test_rotate(days_to_run, 10, 1);
+
+    days_to_run = 10;
+    test_rotate(days_to_run, 0, 10);
+    test_rotate(days_to_run, 1, 1);
+    test_rotate(days_to_run, 3, 3);
+    test_rotate(days_to_run, 9, 9);
+    test_rotate(days_to_run, 10, 10);
+    test_rotate(days_to_run, 11, 10);
+    test_rotate(days_to_run, 20, 10);
+}
diff --git a/3rdparty/spdlog/src/tests/test_dup_filter.cpp b/3rdparty/spdlog/src/tests/test_dup_filter.cpp
new file mode 100644
index 00000000..8ae2ee60
--- /dev/null
+++ b/3rdparty/spdlog/src/tests/test_dup_filter.cpp
@@ -0,0 +1,90 @@
+#include "includes.h"
+#include "spdlog/sinks/dup_filter_sink.h"
+#include "test_sink.h"
+
+TEST_CASE("dup_filter_test1", "[dup_filter_sink]")
+{
+    using spdlog::sinks::dup_filter_sink_st;
+    using spdlog::sinks::test_sink_mt;
+
+    dup_filter_sink_st dup_sink{std::chrono::seconds{5}};
+    auto test_sink = std::make_shared<test_sink_mt>();
+    dup_sink.add_sink(test_sink);
+
+    for (int i = 0; i < 10; i++)
+    {
+        dup_sink.log(spdlog::details::log_msg{"test", spdlog::level::info, "message1"});
+    }
+
+    REQUIRE(test_sink->msg_counter() == 1);
+}
+
+TEST_CASE("dup_filter_test2", "[dup_filter_sink]")
+{
+    using spdlog::sinks::dup_filter_sink_st;
+    using spdlog::sinks::test_sink_mt;
+
+    dup_filter_sink_st dup_sink{std::chrono::seconds{0}};
+    auto test_sink = std::make_shared<test_sink_mt>();
+    dup_sink.add_sink(test_sink);
+
+    for (int i = 0; i < 10; i++)
+    {
+        dup_sink.log(spdlog::details::log_msg{"test", spdlog::level::info, "message1"});
+        std::this_thread::sleep_for(std::chrono::milliseconds(5));
+    }
+
+    REQUIRE(test_sink->msg_counter() == 10);
+}
+
+TEST_CASE("dup_filter_test3", "[dup_filter_sink]")
+{
+    using spdlog::sinks::dup_filter_sink_st;
+    using spdlog::sinks::test_sink_mt;
+
+    dup_filter_sink_st dup_sink{std::chrono::seconds{1}};
+    auto test_sink = std::make_shared<test_sink_mt>();
+    dup_sink.add_sink(test_sink);
+
+    for (int i = 0; i < 10; i++)
+    {
+        dup_sink.log(spdlog::details::log_msg{"test", spdlog::level::info, "message1"});
+        dup_sink.log(spdlog::details::log_msg{"test", spdlog::level::info, "message2"});
+    }
+
+    REQUIRE(test_sink->msg_counter() == 20);
+}
+
+TEST_CASE("dup_filter_test4", "[dup_filter_sink]")
+{
+    using spdlog::sinks::dup_filter_sink_mt;
+    using spdlog::sinks::test_sink_mt;
+
+    dup_filter_sink_mt dup_sink{std::chrono::milliseconds{10}};
+    auto test_sink = std::make_shared<test_sink_mt>();
+    dup_sink.add_sink(test_sink);
+
+    dup_sink.log(spdlog::details::log_msg{"test", spdlog::level::info, "message"});
+    std::this_thread::sleep_for(std::chrono::milliseconds(50));
+    dup_sink.log(spdlog::details::log_msg{"test", spdlog::level::info, "message"});
+    REQUIRE(test_sink->msg_counter() == 2);
+}
+
+TEST_CASE("dup_filter_test5", "[dup_filter_sink]")
+{
+    using spdlog::sinks::dup_filter_sink_mt;
+    using spdlog::sinks::test_sink_mt;
+
+    dup_filter_sink_mt dup_sink{std::chrono::seconds{5}};
+    auto test_sink = std::make_shared<test_sink_mt>();
+    test_sink->set_pattern("%v");
+    dup_sink.add_sink(test_sink);
+
+    dup_sink.log(spdlog::details::log_msg{"test", spdlog::level::info, "message1"});
+    dup_sink.log(spdlog::details::log_msg{"test", spdlog::level::info, "message1"});
+    dup_sink.log(spdlog::details::log_msg{"test", spdlog::level::info, "message1"});
+    dup_sink.log(spdlog::details::log_msg{"test", spdlog::level::info, "message2"});
+
+    REQUIRE(test_sink->msg_counter() == 3); // skip 2 messages but log the "skipped.." message before message2
+    REQUIRE(test_sink->lines()[1] == "Skipped 2 duplicate messages..");
+}
diff --git a/3rdparty/spdlog/src/tests/test_errors.cpp b/3rdparty/spdlog/src/tests/test_errors.cpp
new file mode 100644
index 00000000..78032482
--- /dev/null
+++ b/3rdparty/spdlog/src/tests/test_errors.cpp
@@ -0,0 +1,124 @@
+/*
+ * This content is released under the MIT License as specified in https://raw.githubusercontent.com/gabime/spdlog/master/LICENSE
+ */
+#include "includes.h"
+
+#include <iostream>
+
+#define SIMPLE_LOG "test_logs/simple_log.txt"
+#define SIMPLE_ASYNC_LOG "test_logs/simple_async_log.txt"
+
+class failing_sink : public spdlog::sinks::base_sink<std::mutex>
+{
+protected:
+    void sink_it_(const spdlog::details::log_msg &) final
+    {
+        throw std::runtime_error("some error happened during log");
+    }
+
+    void flush_() final
+    {
+        throw std::runtime_error("some error happened during flush");
+    }
+};
+struct custom_ex
+{};
+
+#if !defined(SPDLOG_USE_STD_FORMAT) // std formt doesn't fully support tuntime strings
+TEST_CASE("default_error_handler", "[errors]")
+{
+    prepare_logdir();
+    spdlog::filename_t filename = SPDLOG_FILENAME_T(SIMPLE_LOG);
+
+    auto logger = spdlog::create<spdlog::sinks::basic_file_sink_mt>("test-error", filename, true);
+    logger->set_pattern("%v");
+    logger->info(SPDLOG_FMT_RUNTIME("Test message {} {}"), 1);
+    logger->info("Test message {}", 2);
+    logger->flush();
+    using spdlog::details::os::default_eol;
+    REQUIRE(file_contents(SIMPLE_LOG) == spdlog::fmt_lib::format("Test message 2{}", default_eol));
+    REQUIRE(count_lines(SIMPLE_LOG) == 1);
+}
+
+TEST_CASE("custom_error_handler", "[errors]")
+{
+    prepare_logdir();
+    spdlog::filename_t filename = SPDLOG_FILENAME_T(SIMPLE_LOG);
+    auto logger = spdlog::create<spdlog::sinks::basic_file_sink_mt>("logger", filename, true);
+    logger->flush_on(spdlog::level::info);
+    logger->set_error_handler([=](const std::string &) { throw custom_ex(); });
+    logger->info("Good message #1");
+
+    REQUIRE_THROWS_AS(logger->info(SPDLOG_FMT_RUNTIME("Bad format msg {} {}"), "xxx"), custom_ex);
+    logger->info("Good message #2");
+    require_message_count(SIMPLE_LOG, 2);
+}
+#endif
+
+TEST_CASE("default_error_handler2", "[errors]")
+{
+    spdlog::drop_all();
+    auto logger = spdlog::create<failing_sink>("failed_logger");
+    logger->set_error_handler([=](const std::string &) { throw custom_ex(); });
+    REQUIRE_THROWS_AS(logger->info("Some message"), custom_ex);
+}
+
+TEST_CASE("flush_error_handler", "[errors]")
+{
+    spdlog::drop_all();
+    auto logger = spdlog::create<failing_sink>("failed_logger");
+    logger->set_error_handler([=](const std::string &) { throw custom_ex(); });
+    REQUIRE_THROWS_AS(logger->flush(), custom_ex);
+}
+
+#if !defined(SPDLOG_USE_STD_FORMAT)
+TEST_CASE("async_error_handler", "[errors]")
+{
+    prepare_logdir();
+    std::string err_msg("log failed with some msg");
+
+    spdlog::filename_t filename = SPDLOG_FILENAME_T(SIMPLE_ASYNC_LOG);
+    {
+        spdlog::init_thread_pool(128, 1);
+        auto logger = spdlog::create_async<spdlog::sinks::basic_file_sink_mt>("logger", filename, true);
+        logger->set_error_handler([=](const std::string &) {
+            std::ofstream ofs("test_logs/custom_err.txt");
+            if (!ofs)
+            {
+                throw std::runtime_error("Failed open test_logs/custom_err.txt");
+            }
+            ofs << err_msg;
+        });
+        logger->info("Good message #1");
+        logger->info(SPDLOG_FMT_RUNTIME("Bad format msg {} {}"), "xxx");
+        logger->info("Good message #2");
+        spdlog::drop("logger"); // force logger to drain the queue and shutdown
+    }
+    spdlog::init_thread_pool(128, 1);
+    require_message_count(SIMPLE_ASYNC_LOG, 2);
+    REQUIRE(file_contents("test_logs/custom_err.txt") == err_msg);
+}
+#endif
+
+// Make sure async error handler is executed
+TEST_CASE("async_error_handler2", "[errors]")
+{
+    prepare_logdir();
+    std::string err_msg("This is async handler error message");
+    {
+        spdlog::details::os::create_dir(SPDLOG_FILENAME_T("test_logs"));
+        spdlog::init_thread_pool(128, 1);
+        auto logger = spdlog::create_async<failing_sink>("failed_logger");
+        logger->set_error_handler([=](const std::string &) {
+            std::ofstream ofs("test_logs/custom_err2.txt");
+            if (!ofs)
+                throw std::runtime_error("Failed open test_logs/custom_err2.txt");
+            ofs << err_msg;
+        });
+        logger->info("Hello failure");
+        spdlog::drop("failed_logger"); // force logger to drain the queue and shutdown
+    }
+
+    spdlog::init_thread_pool(128, 1);
+    REQUIRE(file_contents("test_logs/custom_err2.txt") == err_msg);
+}
diff --git a/3rdparty/spdlog/src/tests/test_eventlog.cpp b/3rdparty/spdlog/src/tests/test_eventlog.cpp
new file mode 100644
index 00000000..5253c5a7
--- /dev/null
+++ b/3rdparty/spdlog/src/tests/test_eventlog.cpp
@@ -0,0 +1,71 @@
+#if _WIN32
+
+#    include "includes.h"
+#    include "test_sink.h"
+
+#    include "spdlog/sinks/win_eventlog_sink.h"
+
+static const LPCSTR TEST_SOURCE = "spdlog_test";
+
+static void test_single_print(std::function<void(std::string const &)> do_log, std::string const &expected_contents, WORD expected_ev_type)
+{
+    using namespace std::chrono;
+    do_log(expected_contents);
+    const auto expected_time_generated = duration_cast<seconds>(system_clock::now().time_since_epoch()).count();
+
+    struct handle_t
+    {
+        HANDLE handle_;
+
+        ~handle_t()
+        {
+            if (handle_)
+            {
+                REQUIRE(CloseEventLog(handle_));
+            }
+        }
+    } event_log{::OpenEventLogA(nullptr, TEST_SOURCE)};
+
+    REQUIRE(event_log.handle_);
+
+    DWORD read_bytes{}, size_needed{};
+    auto ok = ::ReadEventLogA(
+        event_log.handle_, EVENTLOG_SEQUENTIAL_READ | EVENTLOG_BACKWARDS_READ, 0, &read_bytes, 0, &read_bytes, &size_needed);
+    REQUIRE(!ok);
+    REQUIRE(::GetLastError() == ERROR_INSUFFICIENT_BUFFER);
+
+    std::vector<char> record_buffer(size_needed);
+    PEVENTLOGRECORD record = (PEVENTLOGRECORD)record_buffer.data();
+
+    ok = ::ReadEventLogA(
+        event_log.handle_, EVENTLOG_SEQUENTIAL_READ | EVENTLOG_BACKWARDS_READ, 0, record, size_needed, &read_bytes, &size_needed);
+    REQUIRE(ok);
+
+    REQUIRE(record->NumStrings == 1);
+    REQUIRE(record->EventType == expected_ev_type);
+    REQUIRE((expected_time_generated - record->TimeGenerated) <= 3u);
+
+    std::string message_in_log(((char *)record + record->StringOffset));
+    REQUIRE(message_in_log == expected_contents + spdlog::details::os::default_eol);
+}
+
+TEST_CASE("eventlog", "[eventlog]")
+{
+    using namespace spdlog;
+
+    auto test_sink = std::make_shared<sinks::win_eventlog_sink_mt>(TEST_SOURCE);
+
+    spdlog::logger test_logger("eventlog", test_sink);
+    test_logger.set_level(level::trace);
+
+    test_sink->set_pattern("%v");
+
+    test_single_print([&test_logger](std::string const &msg) { test_logger.trace(msg); }, "my trace message", EVENTLOG_SUCCESS);
+    test_single_print([&test_logger](std::string const &msg) { test_logger.debug(msg); }, "my debug message", EVENTLOG_SUCCESS);
+    test_single_print([&test_logger](std::string const &msg) { test_logger.info(msg); }, "my info message", EVENTLOG_INFORMATION_TYPE);
+    test_single_print([&test_logger](std::string const &msg) { test_logger.warn(msg); }, "my warn message", EVENTLOG_WARNING_TYPE);
+    test_single_print([&test_logger](std::string const &msg) { test_logger.error(msg); }, "my error message", EVENTLOG_ERROR_TYPE);
+    test_single_print([&test_logger](std::string const &msg) { test_logger.critical(msg); }, "my critical message", EVENTLOG_ERROR_TYPE);
+}
+
+#endif //_WIN32
diff --git a/3rdparty/spdlog/src/tests/test_file_helper.cpp b/3rdparty/spdlog/src/tests/test_file_helper.cpp
new file mode 100644
index 00000000..dd3ca4f8
--- /dev/null
+++ b/3rdparty/spdlog/src/tests/test_file_helper.cpp
@@ -0,0 +1,168 @@
+/*
+ * This content is released under the MIT License as specified in https://raw.githubusercontent.com/gabime/spdlog/master/LICENSE
+ */
+#include "includes.h"
+
+#define TEST_FILENAME "test_logs/file_helper_test.txt"
+
+using spdlog::details::file_helper;
+
+static void write_with_helper(file_helper &helper, size_t howmany)
+{
+    spdlog::memory_buf_t formatted;
+    spdlog::fmt_lib::format_to(std::back_inserter(formatted), "{}", std::string(howmany, '1'));
+    helper.write(formatted);
+    helper.flush();
+}
+
+TEST_CASE("file_helper_filename", "[file_helper::filename()]")
+{
+    prepare_logdir();
+
+    file_helper helper;
+    spdlog::filename_t target_filename = SPDLOG_FILENAME_T(TEST_FILENAME);
+    helper.open(target_filename);
+    REQUIRE(helper.filename() == target_filename);
+}
+
+TEST_CASE("file_helper_size", "[file_helper::size()]")
+{
+    prepare_logdir();
+    spdlog::filename_t target_filename = SPDLOG_FILENAME_T(TEST_FILENAME);
+    size_t expected_size = 123;
+    {
+        file_helper helper;
+        helper.open(target_filename);
+        write_with_helper(helper, expected_size);
+        REQUIRE(static_cast<size_t>(helper.size()) == expected_size);
+    }
+    REQUIRE(get_filesize(TEST_FILENAME) == expected_size);
+}
+
+TEST_CASE("file_helper_reopen", "[file_helper::reopen()]")
+{
+    prepare_logdir();
+    spdlog::filename_t target_filename = SPDLOG_FILENAME_T(TEST_FILENAME);
+    file_helper helper;
+    helper.open(target_filename);
+    write_with_helper(helper, 12);
+    REQUIRE(helper.size() == 12);
+    helper.reopen(true);
+    REQUIRE(helper.size() == 0);
+}
+
+TEST_CASE("file_helper_reopen2", "[file_helper::reopen(false)]")
+{
+    prepare_logdir();
+    spdlog::filename_t target_filename = SPDLOG_FILENAME_T(TEST_FILENAME);
+    size_t expected_size = 14;
+    file_helper helper;
+    helper.open(target_filename);
+    write_with_helper(helper, expected_size);
+    REQUIRE(helper.size() == expected_size);
+    helper.reopen(false);
+    REQUIRE(helper.size() == expected_size);
+}
+
+static void test_split_ext(const spdlog::filename_t::value_type *fname, const spdlog::filename_t::value_type *expect_base,
+    const spdlog::filename_t::value_type *expect_ext)
+{
+    spdlog::filename_t filename(fname);
+    spdlog::filename_t expected_base(expect_base);
+    spdlog::filename_t expected_ext(expect_ext);
+
+    spdlog::filename_t basename;
+    spdlog::filename_t ext;
+    std::tie(basename, ext) = file_helper::split_by_extension(filename);
+    REQUIRE(basename == expected_base);
+    REQUIRE(ext == expected_ext);
+}
+
+TEST_CASE("file_helper_split_by_extension", "[file_helper::split_by_extension()]")
+{
+    test_split_ext(SPDLOG_FILENAME_T("mylog.txt"), SPDLOG_FILENAME_T("mylog"), SPDLOG_FILENAME_T(".txt"));
+    test_split_ext(SPDLOG_FILENAME_T(".mylog.txt"), SPDLOG_FILENAME_T(".mylog"), SPDLOG_FILENAME_T(".txt"));
+    test_split_ext(SPDLOG_FILENAME_T(".mylog"), SPDLOG_FILENAME_T(".mylog"), SPDLOG_FILENAME_T(""));
+    test_split_ext(SPDLOG_FILENAME_T("/aaa/bb.d/mylog"), SPDLOG_FILENAME_T("/aaa/bb.d/mylog"), SPDLOG_FILENAME_T(""));
+    test_split_ext(SPDLOG_FILENAME_T("/aaa/bb.d/mylog.txt"), SPDLOG_FILENAME_T("/aaa/bb.d/mylog"), SPDLOG_FILENAME_T(".txt"));
+    test_split_ext(SPDLOG_FILENAME_T("aaa/bbb/ccc/mylog.txt"), SPDLOG_FILENAME_T("aaa/bbb/ccc/mylog"), SPDLOG_FILENAME_T(".txt"));
+    test_split_ext(SPDLOG_FILENAME_T("aaa/bbb/ccc/mylog."), SPDLOG_FILENAME_T("aaa/bbb/ccc/mylog."), SPDLOG_FILENAME_T(""));
+    test_split_ext(SPDLOG_FILENAME_T("aaa/bbb/ccc/.mylog.txt"), SPDLOG_FILENAME_T("aaa/bbb/ccc/.mylog"), SPDLOG_FILENAME_T(".txt"));
+    test_split_ext(SPDLOG_FILENAME_T("/aaa/bbb/ccc/mylog.txt"), SPDLOG_FILENAME_T("/aaa/bbb/ccc/mylog"), SPDLOG_FILENAME_T(".txt"));
+    test_split_ext(SPDLOG_FILENAME_T("/aaa/bbb/ccc/.mylog"), SPDLOG_FILENAME_T("/aaa/bbb/ccc/.mylog"), SPDLOG_FILENAME_T(""));
+    test_split_ext(SPDLOG_FILENAME_T("../mylog.txt"), SPDLOG_FILENAME_T("../mylog"), SPDLOG_FILENAME_T(".txt"));
+    test_split_ext(SPDLOG_FILENAME_T(".././mylog.txt"), SPDLOG_FILENAME_T(".././mylog"), SPDLOG_FILENAME_T(".txt"));
+    test_split_ext(SPDLOG_FILENAME_T(".././mylog.txt/xxx"), SPDLOG_FILENAME_T(".././mylog.txt/xxx"), SPDLOG_FILENAME_T(""));
+    test_split_ext(SPDLOG_FILENAME_T("/mylog.txt"), SPDLOG_FILENAME_T("/mylog"), SPDLOG_FILENAME_T(".txt"));
+    test_split_ext(SPDLOG_FILENAME_T("//mylog.txt"), SPDLOG_FILENAME_T("//mylog"), SPDLOG_FILENAME_T(".txt"));
+    test_split_ext(SPDLOG_FILENAME_T(""), SPDLOG_FILENAME_T(""), SPDLOG_FILENAME_T(""));
+    test_split_ext(SPDLOG_FILENAME_T("."), SPDLOG_FILENAME_T("."), SPDLOG_FILENAME_T(""));
+    test_split_ext(SPDLOG_FILENAME_T("..txt"), SPDLOG_FILENAME_T("."), SPDLOG_FILENAME_T(".txt"));
+}
+
+TEST_CASE("file_event_handlers", "[file_helper]")
+{
+    enum class flags
+    {
+        before_open,
+        after_open,
+        before_close,
+        after_close
+    };
+    prepare_logdir();
+
+    spdlog::filename_t test_filename = SPDLOG_FILENAME_T(TEST_FILENAME);
+    // define event handles that update vector of flags when called
+    std::vector<flags> events;
+    spdlog::file_event_handlers handlers;
+    handlers.before_open = [&](spdlog::filename_t filename) {
+        REQUIRE(filename == test_filename);
+        events.push_back(flags::before_open);
+    };
+    handlers.after_open = [&](spdlog::filename_t filename, std::FILE *fstream) {
+        REQUIRE(filename == test_filename);
+        REQUIRE(fstream);
+        fputs("after_open\n", fstream);
+        events.push_back(flags::after_open);
+    };
+    handlers.before_close = [&](spdlog::filename_t filename, std::FILE *fstream) {
+        REQUIRE(filename == test_filename);
+        REQUIRE(fstream);
+        fputs("before_close\n", fstream);
+        events.push_back(flags::before_close);
+    };
+    handlers.after_close = [&](spdlog::filename_t filename) {
+        REQUIRE(filename == test_filename);
+        events.push_back(flags::after_close);
+    };
+    {
+        spdlog::details::file_helper helper{handlers};
+        REQUIRE(events.empty());
+
+        helper.open(test_filename);
+        REQUIRE(events == std::vector<flags>{flags::before_open, flags::after_open});
+
+        events.clear();
+        helper.close();
+        REQUIRE(events == std::vector<flags>{flags::before_close, flags::after_close});
+        REQUIRE(file_contents(TEST_FILENAME) == "after_open\nbefore_close\n");
+
+        helper.reopen(true);
+        events.clear();
+    }
+    // make sure that the file_helper destrcutor calls the close callbacks if needed
+    REQUIRE(events == std::vector<flags>{flags::before_close, flags::after_close});
+    REQUIRE(file_contents(TEST_FILENAME) == "after_open\nbefore_close\n");
+}
+
+TEST_CASE("file_helper_open", "[file_helper]")
+{
+    prepare_logdir();
+    spdlog::filename_t target_filename = SPDLOG_FILENAME_T(TEST_FILENAME);
+    file_helper helper;
+    helper.open(target_filename);
+    helper.close();
+
+    target_filename += SPDLOG_FILENAME_T("/invalid");
+    REQUIRE_THROWS_AS(helper.open(target_filename), spdlog::spdlog_ex);
+}
diff --git a/3rdparty/spdlog/src/tests/test_file_logging.cpp b/3rdparty/spdlog/src/tests/test_file_logging.cpp
new file mode 100644
index 00000000..7a7119ad
--- /dev/null
+++ b/3rdparty/spdlog/src/tests/test_file_logging.cpp
@@ -0,0 +1,109 @@
+/*
+ * This content is released under the MIT License as specified in https://raw.githubusercontent.com/gabime/spdlog/master/LICENSE
+ */
+#include "includes.h"
+
+#define SIMPLE_LOG "test_logs/simple_log"
+#define ROTATING_LOG "test_logs/rotating_log"
+
+TEST_CASE("simple_file_logger", "[simple_logger]")
+{
+    prepare_logdir();
+    spdlog::filename_t filename = SPDLOG_FILENAME_T(SIMPLE_LOG);
+
+    auto logger = spdlog::create<spdlog::sinks::basic_file_sink_mt>("logger", filename);
+    logger->set_pattern("%v");
+
+    logger->info("Test message {}", 1);
+    logger->info("Test message {}", 2);
+
+    logger->flush();
+    require_message_count(SIMPLE_LOG, 2);
+    using spdlog::details::os::default_eol;
+    REQUIRE(file_contents(SIMPLE_LOG) == spdlog::fmt_lib::format("Test message 1{}Test message 2{}", default_eol, default_eol));
+}
+
+TEST_CASE("flush_on", "[flush_on]")
+{
+    prepare_logdir();
+    spdlog::filename_t filename = SPDLOG_FILENAME_T(SIMPLE_LOG);
+
+    auto logger = spdlog::create<spdlog::sinks::basic_file_sink_mt>("logger", filename);
+    logger->set_pattern("%v");
+    logger->set_level(spdlog::level::trace);
+    logger->flush_on(spdlog::level::info);
+    logger->trace("Should not be flushed");
+    REQUIRE(count_lines(SIMPLE_LOG) == 0);
+
+    logger->info("Test message {}", 1);
+    logger->info("Test message {}", 2);
+
+    require_message_count(SIMPLE_LOG, 3);
+    using spdlog::details::os::default_eol;
+    REQUIRE(file_contents(SIMPLE_LOG) ==
+            spdlog::fmt_lib::format("Should not be flushed{}Test message 1{}Test message 2{}", default_eol, default_eol, default_eol));
+}
+
+TEST_CASE("rotating_file_logger1", "[rotating_logger]")
+{
+    prepare_logdir();
+    size_t max_size = 1024 * 10;
+    spdlog::filename_t basename = SPDLOG_FILENAME_T(ROTATING_LOG);
+    auto logger = spdlog::rotating_logger_mt("logger", basename, max_size, 0);
+
+    for (int i = 0; i < 10; ++i)
+    {
+        logger->info("Test message {}", i);
+    }
+
+    logger->flush();
+    require_message_count(ROTATING_LOG, 10);
+}
+
+TEST_CASE("rotating_file_logger2", "[rotating_logger]")
+{
+    prepare_logdir();
+    size_t max_size = 1024 * 10;
+    spdlog::filename_t basename = SPDLOG_FILENAME_T(ROTATING_LOG);
+
+    {
+        // make an initial logger to create the first output file
+        auto logger = spdlog::rotating_logger_mt("logger", basename, max_size, 2, true);
+        for (int i = 0; i < 10; ++i)
+        {
+            logger->info("Test message {}", i);
+        }
+        // drop causes the logger destructor to be called, which is required so the
+        // next logger can rename the first output file.
+        spdlog::drop(logger->name());
+    }
+
+    auto logger = spdlog::rotating_logger_mt("logger", basename, max_size, 2, true);
+    for (int i = 0; i < 10; ++i)
+    {
+        logger->info("Test message {}", i);
+    }
+
+    logger->flush();
+
+    require_message_count(ROTATING_LOG, 10);
+
+    for (int i = 0; i < 1000; i++)
+    {
+
+        logger->info("Test message {}", i);
+    }
+
+    logger->flush();
+    REQUIRE(get_filesize(ROTATING_LOG) <= max_size);
+    REQUIRE(get_filesize(ROTATING_LOG ".1") <= max_size);
+}
+
+// test that passing max_size=0 throws
+TEST_CASE("rotating_file_logger3", "[rotating_logger]")
+{
+    prepare_logdir();
+    size_t max_size = 0;
+    spdlog::filename_t basename = SPDLOG_FILENAME_T(ROTATING_LOG);
+    REQUIRE_THROWS_AS(spdlog::rotating_logger_mt("logger", basename, max_size, 0), spdlog::spdlog_ex);
+}
diff --git a/3rdparty/spdlog/src/tests/test_fmt_helper.cpp b/3rdparty/spdlog/src/tests/test_fmt_helper.cpp
new file mode 100644
index 00000000..52141902
--- /dev/null
+++ b/3rdparty/spdlog/src/tests/test_fmt_helper.cpp
@@ -0,0 +1,90 @@
+
+#include "includes.h"
+
+using spdlog::memory_buf_t;
+using spdlog::details::to_string_view;
+
+void test_pad2(int n, const char *expected)
+{
+    memory_buf_t buf;
+    spdlog::details::fmt_helper::pad2(n, buf);
+
+    REQUIRE(to_string_view(buf) == expected);
+}
+
+void test_pad3(uint32_t n, const char *expected)
+{
+    memory_buf_t buf;
+    spdlog::details::fmt_helper::pad3(n, buf);
+
+    REQUIRE(to_string_view(buf) == expected);
+}
+
+void test_pad6(std::size_t n, const char *expected)
+{
+    memory_buf_t buf;
+    spdlog::details::fmt_helper::pad6(n, buf);
+
+    REQUIRE(to_string_view(buf) == expected);
+}
+
+void test_pad9(std::size_t n, const char *expected)
+{
+    memory_buf_t buf;
+    spdlog::details::fmt_helper::pad9(n, buf);
+
+    REQUIRE(to_string_view(buf) == expected);
+}
+
+TEST_CASE("pad2", "[fmt_helper]")
+{
+    test_pad2(0, "00");
+    test_pad2(3, "03");
+    test_pad2(10, "10");
+    test_pad2(23, "23");
+    test_pad2(99, "99");
+    test_pad2(100, "100");
+    test_pad2(123, "123");
+    test_pad2(1234, "1234");
+    test_pad2(-5, "-5");
+}
+
+TEST_CASE("pad3", "[fmt_helper]")
+{
+    test_pad3(0, "000");
+    test_pad3(3, "003");
+    test_pad3(10, "010");
+    test_pad3(23, "023");
+    test_pad3(99, "099");
+    test_pad3(100, "100");
+    test_pad3(123, "123");
+    test_pad3(999, "999");
+    test_pad3(1000, "1000");
+    test_pad3(1234, "1234");
+}
+
+TEST_CASE("pad6", "[fmt_helper]")
+{
+    test_pad6(0, "000000");
+    test_pad6(3, "000003");
+    test_pad6(23, "000023");
+    test_pad6(123, "000123");
+    test_pad6(1234, "001234");
+    test_pad6(12345, "012345");
+    test_pad6(123456, "123456");
+}
+
+TEST_CASE("pad9", "[fmt_helper]")
+{
+    test_pad9(0, "000000000");
+    test_pad9(3, "000000003");
+    test_pad9(23, "000000023");
+    test_pad9(123, "000000123");
+    test_pad9(1234, "000001234");
+    test_pad9(12345, "000012345");
+    test_pad9(123456, "000123456");
+    test_pad9(1234567, "001234567");
+    test_pad9(12345678, "012345678");
+    test_pad9(123456789, "123456789");
+    test_pad9(1234567891, "1234567891");
+}
diff --git a/3rdparty/spdlog/src/tests/test_macros.cpp b/3rdparty/spdlog/src/tests/test_macros.cpp
new file mode 100644
index 00000000..36537958
--- /dev/null
+++ b/3rdparty/spdlog/src/tests/test_macros.cpp
@@ -0,0 +1,54 @@
+/*
+ * This content is released under the MIT License as specified in https://raw.githubusercontent.com/gabime/spdlog/master/LICENSE
+ */
+
+#include "includes.h"
+
+#if SPDLOG_ACTIVE_LEVEL != SPDLOG_LEVEL_DEBUG
+#    error "Invalid SPDLOG_ACTIVE_LEVEL in test. Should be SPDLOG_LEVEL_DEBUG"
+#endif
+
+#define TEST_FILENAME "test_logs/simple_log"
+
+TEST_CASE("debug and trace w/o format string", "[macros]")
+{
+
+    prepare_logdir();
+    spdlog::filename_t filename = SPDLOG_FILENAME_T(TEST_FILENAME);
+
+    auto logger = spdlog::create<spdlog::sinks::basic_file_sink_mt>("logger", filename);
+    logger->set_pattern("%v");
+    logger->set_level(spdlog::level::trace);
+
+    SPDLOG_LOGGER_TRACE(logger, "Test message 1");
+    SPDLOG_LOGGER_DEBUG(logger, "Test message 2");
+    logger->flush();
+
+    using spdlog::details::os::default_eol;
+    REQUIRE(ends_with(file_contents(TEST_FILENAME), spdlog::fmt_lib::format("Test message 2{}", default_eol)));
+    REQUIRE(count_lines(TEST_FILENAME) == 1);
+
+    auto orig_default_logger = spdlog::default_logger();
+    spdlog::set_default_logger(logger);
+
+    SPDLOG_TRACE("Test message 3");
+    SPDLOG_DEBUG("Test message {}", 4);
+    logger->flush();
+
+    require_message_count(TEST_FILENAME, 2);
+    REQUIRE(ends_with(file_contents(TEST_FILENAME), spdlog::fmt_lib::format("Test message 4{}", default_eol)));
+    spdlog::set_default_logger(std::move(orig_default_logger));
+}
+
+TEST_CASE("disable param evaluation", "[macros]")
+{
+    SPDLOG_TRACE("Test message {}", throw std::runtime_error("Should not be evaluated"));
+}
+
+TEST_CASE("pass logger pointer", "[macros]")
+{
+    auto logger = spdlog::create<spdlog::sinks::null_sink_mt>("refmacro");
+    auto &ref = *logger;
+    SPDLOG_LOGGER_TRACE(&ref, "Test message 1");
+    SPDLOG_LOGGER_DEBUG(&ref, "Test message 2");
+}
diff --git a/3rdparty/spdlog/src/tests/test_misc.cpp b/3rdparty/spdlog/src/tests/test_misc.cpp
new file mode 100644
index 00000000..b6807154
--- /dev/null
+++ b/3rdparty/spdlog/src/tests/test_misc.cpp
@@ -0,0 +1,271 @@
+#include "includes.h"
+#include "test_sink.h"
+#include "spdlog/fmt/bin_to_hex.h"
+
+template<class T>
+std::string log_info(const T &what, spdlog::level::level_enum logger_level = spdlog::level::info)
+{
+
+    std::ostringstream oss;
+    auto oss_sink = std::make_shared<spdlog::sinks::ostream_sink_mt>(oss);
+
+    spdlog::logger oss_logger("oss", oss_sink);
+    oss_logger.set_level(logger_level);
+    oss_logger.set_pattern("%v");
+    oss_logger.info(what);
+
+    return oss.str().substr(0, oss.str().length() - strlen(spdlog::details::os::default_eol));
+}
+
+TEST_CASE("basic_logging ", "[basic_logging]")
+{
+    // const char
+    REQUIRE(log_info("Hello") == "Hello");
+    REQUIRE(log_info("").empty());
+
+    // std::string
+    REQUIRE(log_info(std::string("Hello")) == "Hello");
+    REQUIRE(log_info(std::string()).empty());
+
+    // Numbers
+    REQUIRE(log_info(5) == "5");
+    REQUIRE(log_info(5.6) == "5.6");
+
+    // User defined class
+    // REQUIRE(log_info(some_logged_class("some_val")) == "some_val");
+}
+
+TEST_CASE("log_levels", "[log_levels]")
+{
+    REQUIRE(log_info("Hello", spdlog::level::err).empty());
+    REQUIRE(log_info("Hello", spdlog::level::critical).empty());
+    REQUIRE(log_info("Hello", spdlog::level::info) == "Hello");
+    REQUIRE(log_info("Hello", spdlog::level::debug) == "Hello");
+    REQUIRE(log_info("Hello", spdlog::level::trace) == "Hello");
+}
+
+TEST_CASE("level_to_string_view", "[convert_to_string_view")
+{
+    REQUIRE(spdlog::level::to_string_view(spdlog::level::trace) == "trace");
+    REQUIRE(spdlog::level::to_string_view(spdlog::level::debug) == "debug");
+    REQUIRE(spdlog::level::to_string_view(spdlog::level::info) == "info");
+    REQUIRE(spdlog::level::to_string_view(spdlog::level::warn) == "warning");
+    REQUIRE(spdlog::level::to_string_view(spdlog::level::err) == "error");
+    REQUIRE(spdlog::level::to_string_view(spdlog::level::critical) == "critical");
+    REQUIRE(spdlog::level::to_string_view(spdlog::level::off) == "off");
+}
+
+TEST_CASE("to_short_c_str", "[convert_to_short_c_str]")
+{
+    REQUIRE(std::string(spdlog::level::to_short_c_str(spdlog::level::trace)) == "T");
+    REQUIRE(std::string(spdlog::level::to_short_c_str(spdlog::level::debug)) == "D");
+    REQUIRE(std::string(spdlog::level::to_short_c_str(spdlog::level::info)) == "I");
+    REQUIRE(std::string(spdlog::level::to_short_c_str(spdlog::level::warn)) == "W");
+    REQUIRE(std::string(spdlog::level::to_short_c_str(spdlog::level::err)) == "E");
+    REQUIRE(std::string(spdlog::level::to_short_c_str(spdlog::level::critical)) == "C");
+    REQUIRE(std::string(spdlog::level::to_short_c_str(spdlog::level::off)) == "O");
+}
+
+TEST_CASE("to_level_enum", "[convert_to_level_enum]")
+{
+    REQUIRE(spdlog::level::from_str("trace") == spdlog::level::trace);
+    REQUIRE(spdlog::level::from_str("debug") == spdlog::level::debug);
+    REQUIRE(spdlog::level::from_str("info") == spdlog::level::info);
+    REQUIRE(spdlog::level::from_str("warning") == spdlog::level::warn);
+    REQUIRE(spdlog::level::from_str("warn") == spdlog::level::warn);
+    REQUIRE(spdlog::level::from_str("error") == spdlog::level::err);
+    REQUIRE(spdlog::level::from_str("critical") == spdlog::level::critical);
+    REQUIRE(spdlog::level::from_str("off") == spdlog::level::off);
+    REQUIRE(spdlog::level::from_str("null") == spdlog::level::off);
+}
+
+TEST_CASE("periodic flush", "[periodic_flush]")
+{
+    using spdlog::sinks::test_sink_mt;
+    auto logger = spdlog::create<test_sink_mt>("periodic_flush");
+    auto test_sink = std::static_pointer_cast<test_sink_mt>(logger->sinks()[0]);
+
+    spdlog::flush_every(std::chrono::seconds(1));
+    std::this_thread::sleep_for(std::chrono::milliseconds(1250));
+    REQUIRE(test_sink->flush_counter() == 1);
+    spdlog::flush_every(std::chrono::seconds(0));
+    spdlog::drop_all();
+}
+
+TEST_CASE("clone-logger", "[clone]")
+{
+    using spdlog::sinks::test_sink_mt;
+    auto test_sink = std::make_shared<test_sink_mt>();
+    auto logger = std::make_shared<spdlog::logger>("orig", test_sink);
+    logger->set_pattern("%v");
+    auto cloned = logger->clone("clone");
+
+    REQUIRE(cloned->name() == "clone");
+    REQUIRE(logger->sinks() == cloned->sinks());
+    REQUIRE(logger->level() == cloned->level());
+    REQUIRE(logger->flush_level() == cloned->flush_level());
+    logger->info("Some message 1");
+    cloned->info("Some message 2");
+
+    REQUIRE(test_sink->lines().size() == 2);
+    REQUIRE(test_sink->lines()[0] == "Some message 1");
+    REQUIRE(test_sink->lines()[1] == "Some message 2");
+
+    spdlog::drop_all();
+}
+
+TEST_CASE("clone async", "[clone]")
+{
+    using spdlog::sinks::test_sink_st;
+    spdlog::init_thread_pool(4, 1);
+    auto test_sink = std::make_shared<test_sink_st>();
+    auto logger = std::make_shared<spdlog::async_logger>("orig", test_sink, spdlog::thread_pool());
+    logger->set_pattern("%v");
+    auto cloned = logger->clone("clone");
+
+    REQUIRE(cloned->name() == "clone");
+    REQUIRE(logger->sinks() == cloned->sinks());
+    REQUIRE(logger->level() == cloned->level());
+    REQUIRE(logger->flush_level() == cloned->flush_level());
+
+    logger->info("Some message 1");
+    cloned->info("Some message 2");
+
+    spdlog::details::os::sleep_for_millis(100);
+
+    REQUIRE(test_sink->lines().size() == 2);
+    REQUIRE(test_sink->lines()[0] == "Some message 1");
+    REQUIRE(test_sink->lines()[1] == "Some message 2");
+
+    spdlog::drop_all();
+}
+
+TEST_CASE("to_hex", "[to_hex]")
+{
+    std::ostringstream oss;
+    auto oss_sink = std::make_shared<spdlog::sinks::ostream_sink_mt>(oss);
+    spdlog::logger oss_logger("oss", oss_sink);
+
+    std::vector<unsigned char> v{9, 0xa, 0xb, 0xc, 0xff, 0xff};
+    oss_logger.info("{}", spdlog::to_hex(v));
+
+    auto output = oss.str();
+    REQUIRE(ends_with(output, "0000: 09 0a 0b 0c ff ff" + std::string(spdlog::details::os::default_eol)));
+}
+
+TEST_CASE("to_hex_upper", "[to_hex]")
+{
+    std::ostringstream oss;
+    auto oss_sink = std::make_shared<spdlog::sinks::ostream_sink_mt>(oss);
+    spdlog::logger oss_logger("oss", oss_sink);
+
+    std::vector<unsigned char> v{9, 0xa, 0xb, 0xc, 0xff, 0xff};
+    oss_logger.info("{:X}", spdlog::to_hex(v));
+
+    auto output = oss.str();
+    REQUIRE(ends_with(output, "0000: 09 0A 0B 0C FF FF" + std::string(spdlog::details::os::default_eol)));
+}
+
+TEST_CASE("to_hex_no_delimiter", "[to_hex]")
+{
+    std::ostringstream oss;
+    auto oss_sink = std::make_shared<spdlog::sinks::ostream_sink_mt>(oss);
+    spdlog::logger oss_logger("oss", oss_sink);
+
+    std::vector<unsigned char> v{9, 0xa, 0xb, 0xc, 0xff, 0xff};
+    oss_logger.info("{:sX}", spdlog::to_hex(v));
+
+    auto output = oss.str();
+    REQUIRE(ends_with(output, "0000: 090A0B0CFFFF" + std::string(spdlog::details::os::default_eol)));
+}
+
+TEST_CASE("to_hex_show_ascii", "[to_hex]")
+{
+    std::ostringstream oss;
+    auto oss_sink = std::make_shared<spdlog::sinks::ostream_sink_mt>(oss);
+    spdlog::logger oss_logger("oss", oss_sink);
+
+    std::vector<unsigned char> v{9, 0xa, 0xb, 0x41, 0xc, 0x4b, 0xff, 0xff};
+    oss_logger.info("{:Xsa}", spdlog::to_hex(v, 8));
+
+    REQUIRE(ends_with(oss.str(), "0000: 090A0B410C4BFFFF  ...A.K.." + std::string(spdlog::details::os::default_eol)));
+}
+
+TEST_CASE("to_hex_different_size_per_line", "[to_hex]")
+{
+    std::ostringstream oss;
+    auto oss_sink = std::make_shared<spdlog::sinks::ostream_sink_mt>(oss);
+    spdlog::logger oss_logger("oss", oss_sink);
+
+    std::vector<unsigned char> v{9, 0xa, 0xb, 0x41, 0xc, 0x4b, 0xff, 0xff};
+
+    oss_logger.info("{:Xsa}", spdlog::to_hex(v, 10));
+    REQUIRE(ends_with(oss.str(), "0000: 090A0B410C4BFFFF  ...A.K.." + std::string(spdlog::details::os::default_eol)));
+
+    oss_logger.info("{:Xs}", spdlog::to_hex(v, 10));
+    REQUIRE(ends_with(oss.str(), "0000: 090A0B410C4BFFFF" + std::string(spdlog::details::os::default_eol)));
+
+    oss_logger.info("{:Xsa}", spdlog::to_hex(v, 6));
+    REQUIRE(ends_with(oss.str(), "0000: 090A0B410C4B  ...A.K" + std::string(spdlog::details::os::default_eol) + "0006: FFFF          .." +
+                                     std::string(spdlog::details::os::default_eol)));
+
+    oss_logger.info("{:Xs}", spdlog::to_hex(v, 6));
+    REQUIRE(ends_with(oss.str(), "0000: 090A0B410C4B" + std::string(spdlog::details::os::default_eol) + "0006: FFFF" +
+                                     std::string(spdlog::details::os::default_eol)));
+}
+
+TEST_CASE("to_hex_no_ascii", "[to_hex]")
+{
+    std::ostringstream oss;
+    auto oss_sink = std::make_shared<spdlog::sinks::ostream_sink_mt>(oss);
+    spdlog::logger oss_logger("oss", oss_sink);
+
+    std::vector<unsigned char> v{9, 0xa, 0xb, 0x41, 0xc, 0x4b, 0xff, 0xff};
+    oss_logger.info("{:Xs}", spdlog::to_hex(v, 8));
+
+    REQUIRE(ends_with(oss.str(), "0000: 090A0B410C4BFFFF" + std::string(spdlog::details::os::default_eol)));
+
+    oss_logger.info("{:Xsna}", spdlog::to_hex(v, 8));
+
+    REQUIRE(ends_with(oss.str(), "090A0B410C4BFFFF" + std::string(spdlog::details::os::default_eol)));
+}
+
+TEST_CASE("default logger API", "[default logger]")
+{
+    std::ostringstream oss;
+    auto oss_sink = std::make_shared<spdlog::sinks::ostream_sink_mt>(oss);
+
+    spdlog::set_default_logger(std::make_shared<spdlog::logger>("oss", oss_sink));
+    spdlog::set_pattern("*** %v");
+
+    spdlog::default_logger()->set_level(spdlog::level::trace);
+    spdlog::trace("hello trace");
+    REQUIRE(oss.str() == "*** hello trace" + std::string(spdlog::details::os::default_eol));
+
+    oss.str("");
+    spdlog::debug("hello debug");
+    REQUIRE(oss.str() == "*** hello debug" + std::string(spdlog::details::os::default_eol));
+
+    oss.str("");
+    spdlog::info("Hello");
+    REQUIRE(oss.str() == "*** Hello" + std::string(spdlog::details::os::default_eol));
+
+    oss.str("");
+    spdlog::warn("Hello again {}", 2);
+    REQUIRE(oss.str() == "*** Hello again 2" + std::string(spdlog::details::os::default_eol));
+
+    oss.str("");
+    spdlog::error(123);
+    REQUIRE(oss.str() == "*** 123" + std::string(spdlog::details::os::default_eol));
+
+    oss.str("");
+    spdlog::critical(std::string("some string"));
+    REQUIRE(oss.str() == "*** some string" + std::string(spdlog::details::os::default_eol));
+
+    oss.str("");
+    spdlog::set_level(spdlog::level::info);
+    spdlog::debug("should not be logged");
+    REQUIRE(oss.str().empty());
+    spdlog::drop_all();
+    spdlog::set_pattern("%v");
+}
diff --git a/3rdparty/spdlog/src/tests/test_mpmc_q.cpp b/3rdparty/spdlog/src/tests/test_mpmc_q.cpp
new file mode 100644
index 00000000..1540dcc8
--- /dev/null
+++ b/3rdparty/spdlog/src/tests/test_mpmc_q.cpp
@@ -0,0 +1,126 @@
+#include "includes.h"
+
+using std::chrono::milliseconds;
+using test_clock = std::chrono::high_resolution_clock;
+
+static milliseconds millis_from(const test_clock::time_point &tp0)
+{
+    return std::chrono::duration_cast<milliseconds>(test_clock::now() - tp0);
+}
+TEST_CASE("dequeue-empty-nowait", "[mpmc_blocking_q]")
+{
+    size_t q_size = 100;
+    milliseconds tolerance_wait(20);
+    spdlog::details::mpmc_blocking_queue<int> q(q_size);
+    int popped_item = 0;
+
+    auto start = test_clock::now();
+    auto rv = q.dequeue_for(popped_item, milliseconds::zero());
+    auto delta_ms = millis_from(start);
+
+    REQUIRE(rv == false);
+    INFO("Delta " << delta_ms.count() << " millis");
+    REQUIRE(delta_ms <= tolerance_wait);
+}
+
+TEST_CASE("dequeue-empty-wait", "[mpmc_blocking_q]")
+{
+
+    size_t q_size = 100;
+    milliseconds wait_ms(250);
+    milliseconds tolerance_wait(250);
+
+    spdlog::details::mpmc_blocking_queue<int> q(q_size);
+    int popped_item = 0;
+    auto start = test_clock::now();
+    auto rv = q.dequeue_for(popped_item, wait_ms);
+    auto delta_ms = millis_from(start);
+
+    REQUIRE(rv == false);
+
+    INFO("Delta " << delta_ms.count() << " millis");
+    REQUIRE(delta_ms >= wait_ms - tolerance_wait);
+    REQUIRE(delta_ms <= wait_ms + tolerance_wait);
+}
+
+TEST_CASE("dequeue-full-nowait", "[mpmc_blocking_q]")
+{
+    spdlog::details::mpmc_blocking_queue<int> q(1);
+    q.enqueue(42);
+
+    int item = 0;
+    q.dequeue_for(item, milliseconds::zero());
+    REQUIRE(item == 42);
+}
+
+TEST_CASE("dequeue-full-wait", "[mpmc_blocking_q]")
+{
+    spdlog::details::mpmc_blocking_queue<int> q(1);
+    q.enqueue(42);
+
+    int item = 0;
+    q.dequeue(item);
+    REQUIRE(item == 42);
+}
+
+TEST_CASE("enqueue_nowait", "[mpmc_blocking_q]")
+{
+
+    size_t q_size = 1;
+    spdlog::details::mpmc_blocking_queue<int> q(q_size);
+    milliseconds tolerance_wait(10);
+
+    q.enqueue(1);
+    REQUIRE(q.overrun_counter() == 0);
+
+    auto start = test_clock::now();
+    q.enqueue_nowait(2);
+    auto delta_ms = millis_from(start);
+
+    INFO("Delta " << delta_ms.count() << " millis");
+    REQUIRE(delta_ms <= tolerance_wait);
+    REQUIRE(q.overrun_counter() == 1);
+}
+
+TEST_CASE("bad_queue", "[mpmc_blocking_q]")
+{
+    size_t q_size = 0;
+    spdlog::details::mpmc_blocking_queue<int> q(q_size);
+    q.enqueue_nowait(1);
+    REQUIRE(q.overrun_counter() == 1);
+    int i = 0;
+    REQUIRE(q.dequeue_for(i, milliseconds(0)) == false);
+}
+
+TEST_CASE("empty_queue", "[mpmc_blocking_q]")
+{
+    size_t q_size = 10;
+    spdlog::details::mpmc_blocking_queue<int> q(q_size);
+    int i = 0;
+    REQUIRE(q.dequeue_for(i, milliseconds(10)) == false);
+}
+
+TEST_CASE("full_queue", "[mpmc_blocking_q]")
+{
+    size_t q_size = 100;
+    spdlog::details::mpmc_blocking_queue<int> q(q_size);
+    for (int i = 0; i < static_cast<int>(q_size); i++)
+    {
+        q.enqueue(i + 0); // i+0 to force rvalue and avoid tidy warnings on the same time if we std::move(i) instead
+    }
+
+    q.enqueue_nowait(123456);
+    REQUIRE(q.overrun_counter() == 1);
+
+    for (int i = 1; i < static_cast<int>(q_size); i++)
+    {
+        int item = -1;
+        q.dequeue(item);
+        REQUIRE(item == i);
+    }
+
+    // last item pushed has overridden the oldest.
+    int item = -1;
+    q.dequeue(item);
+    REQUIRE(item == 123456);
+}
diff --git a/3rdparty/spdlog/src/tests/test_pattern_formatter.cpp b/3rdparty/spdlog/src/tests/test_pattern_formatter.cpp
new file mode 100644
index 00000000..bafea884
--- /dev/null
+++ b/3rdparty/spdlog/src/tests/test_pattern_formatter.cpp
@@ -0,0 +1,501 @@
+#include "includes.h"
+#include "test_sink.h"
+
+using spdlog::memory_buf_t;
+using spdlog::details::to_string_view;
+
+// log to str and return it
+template<typename... Args>
+static std::string log_to_str(const std::string &msg, const Args &...args)
+{
+    std::ostringstream oss;
+    auto oss_sink = std::make_shared<spdlog::sinks::ostream_sink_mt>(oss);
+    spdlog::logger oss_logger("pattern_tester", oss_sink);
+    oss_logger.set_level(spdlog::level::info);
+
+    oss_logger.set_formatter(std::unique_ptr<spdlog::formatter>(new spdlog::pattern_formatter(args...)));
+
+    oss_logger.info(msg);
+    return oss.str();
+}
+
+TEST_CASE("custom eol", "[pattern_formatter]")
+{
+    std::string msg = "Hello custom eol test";
+    std::string eol = ";)";
+    REQUIRE(log_to_str(msg, "%v", spdlog::pattern_time_type::local, ";)") == msg + eol);
+}
+
+TEST_CASE("empty format", "[pattern_formatter]")
+{
+    REQUIRE(log_to_str("Some message", "", spdlog::pattern_time_type::local, "").empty());
+}
+
+TEST_CASE("empty format2", "[pattern_formatter]")
+{
+    REQUIRE(log_to_str("Some message", "", spdlog::pattern_time_type::local, "\n") == "\n");
+}
+
+TEST_CASE("level", "[pattern_formatter]")
+{
+    REQUIRE(log_to_str("Some message", "[%l] %v", spdlog::pattern_time_type::local, "\n") == "[info] Some message\n");
+}
+
+TEST_CASE("short level", "[pattern_formatter]")
+{
+    REQUIRE(log_to_str("Some message", "[%L] %v", spdlog::pattern_time_type::local, "\n") == "[I] Some message\n");
+}
+
+TEST_CASE("name", "[pattern_formatter]")
+{
+    REQUIRE(log_to_str("Some message", "[%n] %v", spdlog::pattern_time_type::local, "\n") == "[pattern_tester] Some message\n");
+}
+
+TEST_CASE("date MM/DD/YY ", "[pattern_formatter]")
+{
+    auto now_tm = spdlog::details::os::localtime();
+    std::stringstream oss;
+    oss << std::setfill('0') << std::setw(2) << now_tm.tm_mon + 1 << "/" << std::setw(2) << now_tm.tm_mday << "/" << std::setw(2)
+        << (now_tm.tm_year + 1900) % 1000 << " Some message\n";
+    REQUIRE(log_to_str("Some message", "%D %v", spdlog::pattern_time_type::local, "\n") == oss.str());
+}
+
+TEST_CASE("color range test1", "[pattern_formatter]")
+{
+    auto formatter = std::make_shared<spdlog::pattern_formatter>("%^%v%$", spdlog::pattern_time_type::local, "\n");
+
+    memory_buf_t buf;
+    spdlog::fmt_lib::format_to(std::back_inserter(buf), "Hello");
+    memory_buf_t formatted;
+    std::string logger_name = "test";
+    spdlog::details::log_msg msg(logger_name, spdlog::level::info, spdlog::string_view_t(buf.data(), buf.size()));
+    formatter->format(msg, formatted);
+    REQUIRE(msg.color_range_start == 0);
+    REQUIRE(msg.color_range_end == 5);
+    REQUIRE(log_to_str("hello", "%^%v%$", spdlog::pattern_time_type::local, "\n") == "hello\n");
+}
+
+TEST_CASE("color range test2", "[pattern_formatter]")
+{
+    auto formatter = std::make_shared<spdlog::pattern_formatter>("%^%$", spdlog::pattern_time_type::local, "\n");
+    std::string logger_name = "test";
+    spdlog::details::log_msg msg(logger_name, spdlog::level::info, "");
+    memory_buf_t formatted;
+    formatter->format(msg, formatted);
+    REQUIRE(msg.color_range_start == 0);
+    REQUIRE(msg.color_range_end == 0);
+    REQUIRE(log_to_str("", "%^%$", spdlog::pattern_time_type::local, "\n") == "\n");
+}
+
+TEST_CASE("color range test3", "[pattern_formatter]")
+{
+    auto formatter = std::make_shared<spdlog::pattern_formatter>("%^***%$");
+    std::string logger_name = "test";
+    spdlog::details::log_msg msg(logger_name, spdlog::level::info, "ignored");
+    memory_buf_t formatted;
+    formatter->format(msg, formatted);
+    REQUIRE(msg.color_range_start == 0);
+    REQUIRE(msg.color_range_end == 3);
+}
+
+TEST_CASE("color range test4", "[pattern_formatter]")
+{
+    auto formatter = std::make_shared<spdlog::pattern_formatter>("XX%^YYY%$", spdlog::pattern_time_type::local, "\n");
+    std::string logger_name = "test";
+    spdlog::details::log_msg msg(logger_name, spdlog::level::info, "ignored");
+
+    memory_buf_t formatted;
+    formatter->format(msg, formatted);
+    REQUIRE(msg.color_range_start == 2);
+    REQUIRE(msg.color_range_end == 5);
+    REQUIRE(log_to_str("ignored", "XX%^YYY%$", spdlog::pattern_time_type::local, "\n") == "XXYYY\n");
+}
+
+TEST_CASE("color range test5", "[pattern_formatter]")
+{
+    auto formatter = std::make_shared<spdlog::pattern_formatter>("**%^");
+    std::string logger_name = "test";
+    spdlog::details::log_msg msg(logger_name, spdlog::level::info, "ignored");
+    memory_buf_t formatted;
+    formatter->format(msg, formatted);
+    REQUIRE(msg.color_range_start == 2);
+    REQUIRE(msg.color_range_end == 0);
+}
+
+TEST_CASE("color range test6", "[pattern_formatter]")
+{
+    auto formatter = std::make_shared<spdlog::pattern_formatter>("**%$");
+    std::string logger_name = "test";
+    spdlog::details::log_msg msg(logger_name, spdlog::level::info, "ignored");
+    memory_buf_t formatted;
+    formatter->format(msg, formatted);
+    REQUIRE(msg.color_range_start == 0);
+    REQUIRE(msg.color_range_end == 2);
+}
+
+//
+// Test padding
+//
+
+TEST_CASE("level_left_padded", "[pattern_formatter]")
+{
+    REQUIRE(log_to_str("Some message", "[%8l] %v", spdlog::pattern_time_type::local, "\n") == "[    info] Some message\n");
+    REQUIRE(log_to_str("Some message", "[%8!l] %v", spdlog::pattern_time_type::local, "\n") == "[    info] Some message\n");
+}
+
+TEST_CASE("level_right_padded", "[pattern_formatter]")
+{
+    REQUIRE(log_to_str("Some message", "[%-8l] %v", spdlog::pattern_time_type::local, "\n") == "[info    ] Some message\n");
+    REQUIRE(log_to_str("Some message", "[%-8!l] %v", spdlog::pattern_time_type::local, "\n") == "[info    ] Some message\n");
+}
+
+TEST_CASE("level_center_padded", "[pattern_formatter]")
+{
+    REQUIRE(log_to_str("Some message", "[%=8l] %v", spdlog::pattern_time_type::local, "\n") == "[  info  ] Some message\n");
+    REQUIRE(log_to_str("Some message", "[%=8!l] %v", spdlog::pattern_time_type::local, "\n") == "[  info  ] Some message\n");
+}
+
+TEST_CASE("short level_left_padded", "[pattern_formatter]")
+{
+    REQUIRE(log_to_str("Some message", "[%3L] %v", spdlog::pattern_time_type::local, "\n") == "[  I] Some message\n");
+    REQUIRE(log_to_str("Some message", "[%3!L] %v", spdlog::pattern_time_type::local, "\n") == "[  I] Some message\n");
+}
+
+TEST_CASE("short level_right_padded", "[pattern_formatter]")
+{
+    REQUIRE(log_to_str("Some message", "[%-3L] %v", spdlog::pattern_time_type::local, "\n") == "[I  ] Some message\n");
+    REQUIRE(log_to_str("Some message", "[%-3!L] %v", spdlog::pattern_time_type::local, "\n") == "[I  ] Some message\n");
+}
+
+TEST_CASE("short level_center_padded", "[pattern_formatter]")
+{
+    REQUIRE(log_to_str("Some message", "[%=3L] %v", spdlog::pattern_time_type::local, "\n") == "[ I ] Some message\n");
+    REQUIRE(log_to_str("Some message", "[%=3!L] %v", spdlog::pattern_time_type::local, "\n") == "[ I ] Some message\n");
+}
+
+TEST_CASE("left_padded_short", "[pattern_formatter]")
+{
+    REQUIRE(log_to_str("Some message", "[%3n] %v", spdlog::pattern_time_type::local, "\n") == "[pattern_tester] Some message\n");
+    REQUIRE(log_to_str("Some message", "[%3!n] %v", spdlog::pattern_time_type::local, "\n") == "[pat] Some message\n");
+}
+
+TEST_CASE("right_padded_short", "[pattern_formatter]")
+{
+    REQUIRE(log_to_str("Some message", "[%-3n] %v", spdlog::pattern_time_type::local, "\n") == "[pattern_tester] Some message\n");
+    REQUIRE(log_to_str("Some message", "[%-3!n] %v", spdlog::pattern_time_type::local, "\n") == "[pat] Some message\n");
+}
+
+TEST_CASE("center_padded_short", "[pattern_formatter]")
+{
+    REQUIRE(log_to_str("Some message", "[%=3n] %v", spdlog::pattern_time_type::local, "\n") == "[pattern_tester] Some message\n");
+    REQUIRE(log_to_str("Some message", "[%=3!n] %v", spdlog::pattern_time_type::local, "\n") == "[pat] Some message\n");
+}
+
+TEST_CASE("left_padded_huge", "[pattern_formatter]")
+{
+    REQUIRE(log_to_str("Some message", "[%-300n] %v", spdlog::pattern_time_type::local, "\n") ==
+            "[pattern_tester                                                  ] Some message\n");
+
+    REQUIRE(log_to_str("Some message", "[%-300!n] %v", spdlog::pattern_time_type::local, "\n") ==
+            "[pattern_tester                                                  ] Some message\n");
+}
+
+TEST_CASE("left_padded_max", "[pattern_formatter]")
+{
+    REQUIRE(log_to_str("Some message", "[%-64n] %v", spdlog::pattern_time_type::local, "\n") ==
+            "[pattern_tester                                                  ] Some message\n");
+
+    REQUIRE(log_to_str("Some message", "[%-64!n] %v", spdlog::pattern_time_type::local, "\n") ==
+            "[pattern_tester                                                  ] Some message\n");
+}
+
+// Test padding + truncate flag
+
+TEST_CASE("paddinng_truncate", "[pattern_formatter]")
+{
+    REQUIRE(log_to_str("123456", "%6!v", spdlog::pattern_time_type::local, "\n") == "123456\n");
+    REQUIRE(log_to_str("123456", "%5!v", spdlog::pattern_time_type::local, "\n") == "12345\n");
+    REQUIRE(log_to_str("123456", "%7!v", spdlog::pattern_time_type::local, "\n") == " 123456\n");
+
+    REQUIRE(log_to_str("123456", "%-6!v", spdlog::pattern_time_type::local, "\n") == "123456\n");
+    REQUIRE(log_to_str("123456", "%-5!v", spdlog::pattern_time_type::local, "\n") == "12345\n");
+    REQUIRE(log_to_str("123456", "%-7!v", spdlog::pattern_time_type::local, "\n") == "123456 \n");
+
+    REQUIRE(log_to_str("123456", "%=6!v", spdlog::pattern_time_type::local, "\n") == "123456\n");
+    REQUIRE(log_to_str("123456", "%=5!v", spdlog::pattern_time_type::local, "\n") == "12345\n");
+    REQUIRE(log_to_str("123456", "%=7!v", spdlog::pattern_time_type::local, "\n") == "123456 \n");
+
+    REQUIRE(log_to_str("123456", "%0!v", spdlog::pattern_time_type::local, "\n") == "\n");
+}
+
+TEST_CASE("padding_truncate_funcname", "[pattern_formatter]")
+{
+    spdlog::sinks::test_sink_st test_sink;
+
+    const char *pattern = "%v [%5!!]";
+    auto formatter = std::unique_ptr<spdlog::formatter>(new spdlog::pattern_formatter(pattern));
+    test_sink.set_formatter(std::move(formatter));
+
+    spdlog::details::log_msg msg1{spdlog::source_loc{"ignored", 1, "func"}, "test_logger", spdlog::level::info, "message"};
+    test_sink.log(msg1);
+    REQUIRE(test_sink.lines()[0] == "message [ func]");
+
+    spdlog::details::log_msg msg2{spdlog::source_loc{"ignored", 1, "function"}, "test_logger", spdlog::level::info, "message"};
+    test_sink.log(msg2);
+    REQUIRE(test_sink.lines()[1] == "message [funct]");
+}
+
+TEST_CASE("padding_funcname", "[pattern_formatter]")
+{
+    spdlog::sinks::test_sink_st test_sink;
+
+    const char *pattern = "%v [%10!]";
+    auto formatter = std::unique_ptr<spdlog::formatter>(new spdlog::pattern_formatter(pattern));
+    test_sink.set_formatter(std::move(formatter));
+
+    spdlog::details::log_msg msg1{spdlog::source_loc{"ignored", 1, "func"}, "test_logger", spdlog::level::info, "message"};
+    test_sink.log(msg1);
+    REQUIRE(test_sink.lines()[0] == "message [      func]");
+
+    spdlog::details::log_msg msg2{spdlog::source_loc{"ignored", 1, "func567890123"}, "test_logger", spdlog::level::info, "message"};
+    test_sink.log(msg2);
+    REQUIRE(test_sink.lines()[1] == "message [func567890123]");
+}
+
+TEST_CASE("clone-default-formatter", "[pattern_formatter]")
+{
+    auto formatter_1 = std::make_shared<spdlog::pattern_formatter>();
+    auto formatter_2 = formatter_1->clone();
+    std::string logger_name = "test";
+    spdlog::details::log_msg msg(logger_name, spdlog::level::info, "some message");
+
+    memory_buf_t formatted_1;
+    memory_buf_t formatted_2;
+    formatter_1->format(msg, formatted_1);
+    formatter_2->format(msg, formatted_2);
+
+    REQUIRE(to_string_view(formatted_1) == to_string_view(formatted_2));
+}
+
+TEST_CASE("clone-default-formatter2", "[pattern_formatter]")
+{
+    auto formatter_1 = std::make_shared<spdlog::pattern_formatter>("%+");
+    auto formatter_2 = formatter_1->clone();
+    std::string logger_name = "test";
+    spdlog::details::log_msg msg(logger_name, spdlog::level::info, "some message");
+
+    memory_buf_t formatted_1;
+    memory_buf_t formatted_2;
+    formatter_1->format(msg, formatted_1);
+    formatter_2->format(msg, formatted_2);
+
+    REQUIRE(to_string_view(formatted_1) == to_string_view(formatted_2));
+}
+
+TEST_CASE("clone-formatter", "[pattern_formatter]")
+{
+    auto formatter_1 = std::make_shared<spdlog::pattern_formatter>("%D %X [%] [%n] %v");
+    auto formatter_2 = formatter_1->clone();
+    std::string logger_name = "test";
+    spdlog::details::log_msg msg(logger_name, spdlog::level::info, "some message");
+
+    memory_buf_t formatted_1;
+    memory_buf_t formatted_2;
+    formatter_1->format(msg, formatted_1);
+    formatter_2->format(msg, formatted_2);
+
+    REQUIRE(to_string_view(formatted_1) == to_string_view(formatted_2));
+}
+
+TEST_CASE("clone-formatter-2", "[pattern_formatter]")
+{
+    using spdlog::pattern_time_type;
+    auto formatter_1 = std::make_shared<spdlog::pattern_formatter>("%D %X [%] [%n] %v", pattern_time_type::utc, "xxxxxx\n");
+    auto formatter_2 = formatter_1->clone();
+    std::string logger_name = "test2";
+    spdlog::details::log_msg msg(logger_name, spdlog::level::info, "some message");
+
+    memory_buf_t formatted_1;
+    memory_buf_t formatted_2;
+    formatter_1->format(msg, formatted_1);
+    formatter_2->format(msg, formatted_2);
+
+    REQUIRE(to_string_view(formatted_1) == to_string_view(formatted_2));
+}
+
+class custom_test_flag : public spdlog::custom_flag_formatter
+{
+public:
+    explicit custom_test_flag(std::string txt)
+        : some_txt{std::move(txt)}
+    {}
+
+    void format(const spdlog::details::log_msg &, const std::tm &tm, spdlog::memory_buf_t &dest) override
+    {
+        if (some_txt == "throw_me")
+        {
+            throw spdlog::spdlog_ex("custom_flag_exception_test");
+        }
+        else if (some_txt == "time")
+        {
+            auto formatted = spdlog::fmt_lib::format("{:d}:{:02d}{:s}", tm.tm_hour % 12, tm.tm_min, tm.tm_hour / 12 ? "PM" : "AM");
+            dest.append(formatted.data(), formatted.data() + formatted.size());
+            return;
+        }
+        some_txt = std::string(padinfo_.width_, ' ') + some_txt;
+        dest.append(some_txt.data(), some_txt.data() + some_txt.size());
+    }
+    spdlog::details::padding_info get_padding_info()
+    {
+        return padinfo_;
+    }
+
+    std::string some_txt;
+
+    std::unique_ptr<custom_flag_formatter> clone() const override
+    {
+        return spdlog::details::make_unique<custom_test_flag>(some_txt);
+    }
+};
+// test clone with custom flag formatters
+TEST_CASE("clone-custom_formatter", "[pattern_formatter]")
+{
+    auto formatter_1 = std::make_shared<spdlog::pattern_formatter>();
+    formatter_1->add_flag<custom_test_flag>('t', "custom_output").set_pattern("[%n] [%t] %v");
+    auto formatter_2 = formatter_1->clone();
+    std::string logger_name = "logger-name";
+    spdlog::details::log_msg msg(logger_name, spdlog::level::info, "some message");
+
+    memory_buf_t formatted_1;
+    memory_buf_t formatted_2;
+    formatter_1->format(msg, formatted_1);
+    formatter_2->format(msg, formatted_2);
+
+    auto expected = spdlog::fmt_lib::format("[logger-name] [custom_output] some message{}", spdlog::details::os::default_eol);
+
+    REQUIRE(to_string_view(formatted_1) == expected);
+    REQUIRE(to_string_view(formatted_2) == expected);
+}
+
+//
+// Test source location formatting
+//
+
+#ifdef _WIN32
+static const char *const test_path = "\\a\\b\\c/myfile.cpp";
+#else
+static const char *const test_path = "/a/b//myfile.cpp";
+#endif
+
+TEST_CASE("short filename formatter-1", "[pattern_formatter]")
+{
+    spdlog::pattern_formatter formatter("%s", spdlog::pattern_time_type::local, "");
+    memory_buf_t formatted;
+    std::string logger_name = "logger-name";
+    spdlog::source_loc source_loc{test_path, 123, "some_func()"};
+    spdlog::details::log_msg msg(source_loc, "logger-name", spdlog::level::info, "Hello");
+    formatter.format(msg, formatted);
+
+    REQUIRE(to_string_view(formatted) == "myfile.cpp");
+}
+
+TEST_CASE("short filename formatter-2", "[pattern_formatter]")
+{
+    spdlog::pattern_formatter formatter("%s:%#", spdlog::pattern_time_type::local, "");
+    memory_buf_t formatted;
+    std::string logger_name = "logger-name";
+    spdlog::source_loc source_loc{"myfile.cpp", 123, "some_func()"};
+    spdlog::details::log_msg msg(source_loc, "logger-name", spdlog::level::info, "Hello");
+    formatter.format(msg, formatted);
+
+    REQUIRE(to_string_view(formatted) == "myfile.cpp:123");
+}
+
+TEST_CASE("short filename formatter-3", "[pattern_formatter]")
+{
+    spdlog::pattern_formatter formatter("%s %v", spdlog::pattern_time_type::local, "");
+    memory_buf_t formatted;
+    std::string logger_name = "logger-name";
+    spdlog::source_loc source_loc{"", 123, "some_func()"};
+    spdlog::details::log_msg msg(source_loc, "logger-name", spdlog::level::info, "Hello");
+    formatter.format(msg, formatted);
+
+    REQUIRE(to_string_view(formatted) == " Hello");
+}
+
+TEST_CASE("full filename formatter", "[pattern_formatter]")
+{
+    spdlog::pattern_formatter formatter("%g", spdlog::pattern_time_type::local, "");
+    memory_buf_t formatted;
+    std::string logger_name = "logger-name";
+    spdlog::source_loc source_loc{test_path, 123, "some_func()"};
+    spdlog::details::log_msg msg(source_loc, "logger-name", spdlog::level::info, "Hello");
+    formatter.format(msg, formatted);
+
+    REQUIRE(to_string_view(formatted) == test_path);
+}
+
+TEST_CASE("custom flags", "[pattern_formatter]")
+{
+    auto formatter = std::make_shared<spdlog::pattern_formatter>();
+    formatter->add_flag<custom_test_flag>('t', "custom1").add_flag<custom_test_flag>('u', "custom2").set_pattern("[%n] [%t] [%u] %v");
+
+    memory_buf_t formatted;
+
+    spdlog::details::log_msg msg(spdlog::source_loc{}, "logger-name", spdlog::level::info, "some message");
+    formatter->format(msg, formatted);
+    auto expected = spdlog::fmt_lib::format("[logger-name] [custom1] [custom2] some message{}", spdlog::details::os::default_eol);
+
+    REQUIRE(to_string_view(formatted) == expected);
+}
+
+TEST_CASE("custom flags-padding", "[pattern_formatter]")
+{
+    auto formatter = std::make_shared<spdlog::pattern_formatter>();
+    formatter->add_flag<custom_test_flag>('t', "custom1").add_flag<custom_test_flag>('u', "custom2").set_pattern("[%n] [%t] [%5u] %v");
+
+    memory_buf_t formatted;
+
+    spdlog::details::log_msg msg(spdlog::source_loc{}, "logger-name", spdlog::level::info, "some message");
+    formatter->format(msg, formatted);
+    auto expected = spdlog::fmt_lib::format("[logger-name] [custom1] [     custom2] some message{}", spdlog::details::os::default_eol);
+
+    REQUIRE(to_string_view(formatted) == expected);
+}
+
+TEST_CASE("custom flags-exception", "[pattern_formatter]")
+{
+    auto formatter = std::make_shared<spdlog::pattern_formatter>();
+    formatter->add_flag<custom_test_flag>('t', "throw_me").add_flag<custom_test_flag>('u', "custom2").set_pattern("[%n] [%t] [%u] %v");
+
+    memory_buf_t formatted;
+    spdlog::details::log_msg msg(spdlog::source_loc{}, "logger-name", spdlog::level::info, "some message");
+    CHECK_THROWS_AS(formatter->format(msg, formatted), spdlog::spdlog_ex);
+}
+
+TEST_CASE("override need_localtime", "[pattern_formatter]")
+{
+    auto formatter = std::make_shared<spdlog::pattern_formatter>(spdlog::pattern_time_type::local, "\n");
+    formatter->add_flag<custom_test_flag>('t', "time").set_pattern("%t> %v");
+
+    {
+        memory_buf_t formatted;
+        spdlog::details::log_msg msg(spdlog::source_loc{}, "logger-name", spdlog::level::info, "some message");
+        formatter->format(msg, formatted);
+        REQUIRE(to_string_view(formatted) == "0:00AM> some message\n");
+    }
+
+    {
+        formatter->need_localtime();
+
+        auto now_tm = spdlog::details::os::localtime();
+        std::stringstream oss;
+        oss << (now_tm.tm_hour % 12) << ":" << std::setfill('0') << std::setw(2) << now_tm.tm_min << (now_tm.tm_hour / 12 ? "PM" : "AM")
+            << "> some message\n";
+
+        memory_buf_t formatted;
+        spdlog::details::log_msg msg(spdlog::source_loc{}, "logger-name", spdlog::level::info, "some message");
+        formatter->format(msg, formatted);
+        REQUIRE(to_string_view(formatted) == oss.str());
+    }
+}
diff --git a/3rdparty/spdlog/src/tests/test_registry.cpp b/3rdparty/spdlog/src/tests/test_registry.cpp
new file mode 100644
index 00000000..8e632cc6
--- /dev/null
+++ b/3rdparty/spdlog/src/tests/test_registry.cpp
@@ -0,0 +1,116 @@
+#include "includes.h"
+
+static const char *const tested_logger_name = "null_logger";
+static const char *const tested_logger_name2 = "null_logger2";
+
+#ifndef SPDLOG_NO_EXCEPTIONS
+TEST_CASE("register_drop", "[registry]")
+{
+    spdlog::drop_all();
+    spdlog::create<spdlog::sinks::null_sink_mt>(tested_logger_name);
+    REQUIRE(spdlog::get(tested_logger_name) != nullptr);
+    // Throw if registering existing name
+    REQUIRE_THROWS_AS(spdlog::create<spdlog::sinks::null_sink_mt>(tested_logger_name), spdlog::spdlog_ex);
+}
+
+TEST_CASE("explicit register", "[registry]")
+{
+    spdlog::drop_all();
+    auto logger = std::make_shared<spdlog::logger>(tested_logger_name, std::make_shared<spdlog::sinks::null_sink_st>());
+    spdlog::register_logger(logger);
+    REQUIRE(spdlog::get(tested_logger_name) != nullptr);
+    // Throw if registering existing name
+    REQUIRE_THROWS_AS(spdlog::create<spdlog::sinks::null_sink_mt>(tested_logger_name), spdlog::spdlog_ex);
+}
+#endif
+
+TEST_CASE("apply_all", "[registry]")
+{
+    spdlog::drop_all();
+    auto logger = std::make_shared<spdlog::logger>(tested_logger_name, std::make_shared<spdlog::sinks::null_sink_st>());
+    spdlog::register_logger(logger);
+    auto logger2 = std::make_shared<spdlog::logger>(tested_logger_name2, std::make_shared<spdlog::sinks::null_sink_st>());
+    spdlog::register_logger(logger2);
+
+    int counter = 0;
+    spdlog::apply_all([&counter](std::shared_ptr<spdlog::logger>) { counter++; });
+    REQUIRE(counter == 2);
+
+    counter = 0;
+    spdlog::drop(tested_logger_name2);
+    spdlog::apply_all([&counter](std::shared_ptr<spdlog::logger> l) {
+        REQUIRE(l->name() == tested_logger_name);
+        counter++;
+    });
+    REQUIRE(counter == 1);
+}
+
+TEST_CASE("drop", "[registry]")
+{
+    spdlog::drop_all();
+    spdlog::create<spdlog::sinks::null_sink_mt>(tested_logger_name);
+    spdlog::drop(tested_logger_name);
+    REQUIRE_FALSE(spdlog::get(tested_logger_name));
+}
+
+TEST_CASE("drop-default", "[registry]")
+{
+    spdlog::set_default_logger(spdlog::null_logger_st(tested_logger_name));
+    spdlog::drop(tested_logger_name);
+    REQUIRE_FALSE(spdlog::default_logger());
+    REQUIRE_FALSE(spdlog::get(tested_logger_name));
+}
+
+TEST_CASE("drop_all", "[registry]")
+{
+    spdlog::drop_all();
+    spdlog::create<spdlog::sinks::null_sink_mt>(tested_logger_name);
+    spdlog::create<spdlog::sinks::null_sink_mt>(tested_logger_name2);
+    spdlog::drop_all();
+    REQUIRE_FALSE(spdlog::get(tested_logger_name));
+    REQUIRE_FALSE(spdlog::get(tested_logger_name2));
+    REQUIRE_FALSE(spdlog::default_logger());
+}
+
+TEST_CASE("drop non existing", "[registry]")
+{
+    spdlog::drop_all();
+    spdlog::create<spdlog::sinks::null_sink_mt>(tested_logger_name);
+    spdlog::drop("some_name");
+    REQUIRE_FALSE(spdlog::get("some_name"));
+    REQUIRE(spdlog::get(tested_logger_name));
+    spdlog::drop_all();
+}
+
+TEST_CASE("default logger", "[registry]")
+{
+    spdlog::drop_all();
+    spdlog::set_default_logger(spdlog::null_logger_st(tested_logger_name));
+    REQUIRE(spdlog::get(tested_logger_name) == spdlog::default_logger());
+    spdlog::drop_all();
+}
+
+TEST_CASE("set_default_logger(nullptr)", "[registry]")
+{
+    spdlog::set_default_logger(nullptr);
+    REQUIRE_FALSE(spdlog::default_logger());
+}
+
+TEST_CASE("disable automatic registration", "[registry]")
+{
+    // set some global parameters
+    spdlog::level::level_enum log_level = spdlog::level::level_enum::warn;
+    spdlog::set_level(log_level);
+    // but disable automatic registration
+    spdlog::set_automatic_registration(false);
+    auto logger1 = spdlog::create<spdlog::sinks::daily_file_sink_st>(tested_logger_name, SPDLOG_FILENAME_T("filename"), 11, 59);
+    auto logger2 = spdlog::create_async<spdlog::sinks::stdout_color_sink_mt>(tested_logger_name2);
+    // loggers should not be part of the registry
+    REQUIRE_FALSE(spdlog::get(tested_logger_name));
+    REQUIRE_FALSE(spdlog::get(tested_logger_name2));
+    // but make sure they are still initialized according to global defaults
+    REQUIRE(logger1->level() == log_level);
+    REQUIRE(logger2->level() == log_level);
+    spdlog::set_level(spdlog::level::info);
+    spdlog::set_automatic_registration(true);
+}
diff --git a/3rdparty/spdlog/src/tests/test_sink.h b/3rdparty/spdlog/src/tests/test_sink.h
new file mode 100644
index 00000000..57db65c1
--- /dev/null
+++ b/3rdparty/spdlog/src/tests/test_sink.h
@@ -0,0 +1,79 @@
+//
+// Copyright(c) 2018 Gabi Melman.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+//
+
+#pragma once
+
+#include "spdlog/details/null_mutex.h"
+#include "spdlog/sinks/base_sink.h"
+#include "spdlog/fmt/fmt.h"
+#include <chrono>
+#include <mutex>
+#include <thread>
+
+namespace spdlog {
+namespace sinks {
+
+template<class Mutex>
+class test_sink : public base_sink<Mutex>
+{
+    const size_t lines_to_save = 100;
+
+public:
+    size_t msg_counter()
+    {
+        std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_);
+        return msg_counter_;
+    }
+
+    size_t flush_counter()
+    {
+        std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_);
+        return flush_counter_;
+    }
+
+    void set_delay(std::chrono::milliseconds delay)
+    {
+        std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_);
+        delay_ = delay;
+    }
+
+    // return last output without the eol
+    std::vector<std::string> lines()
+    {
+        std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_);
+        return lines_;
+    }
+
+protected:
+    void sink_it_(const details::log_msg &msg) override
+    {
+        memory_buf_t formatted;
+        base_sink<Mutex>::formatter_->format(msg, formatted);
+        // save the line without the eol
+        auto eol_len = strlen(details::os::default_eol);
+        if (lines_.size() < lines_to_save)
+        {
+            lines_.emplace_back(formatted.begin(), formatted.end() - eol_len);
+        }
+        msg_counter_++;
+        std::this_thread::sleep_for(delay_);
+    }
+
+    void flush_() override
+    {
+        flush_counter_++;
+    }
+
+    size_t msg_counter_{0};
+    size_t flush_counter_{0};
+    std::chrono::milliseconds delay_{std::chrono::milliseconds::zero()};
+    std::vector<std::string> lines_;
+};
+
+using test_sink_mt = test_sink<std::mutex>;
+using test_sink_st = test_sink<details::null_mutex>;
+
+} // namespace sinks
+} // namespace spdlog
diff --git a/3rdparty/spdlog/src/tests/test_stdout_api.cpp b/3rdparty/spdlog/src/tests/test_stdout_api.cpp
new file mode 100644
index 00000000..d55223ff
--- /dev/null
+++ b/3rdparty/spdlog/src/tests/test_stdout_api.cpp
@@ -0,0 +1,98 @@
+/*
+ * This content is released under the MIT License as specified in https://raw.githubusercontent.com/gabime/spdlog/master/LICENSE
+ */
+#include "includes.h"
+#include "spdlog/sinks/stdout_sinks.h"
+#include "spdlog/sinks/stdout_color_sinks.h"
+TEST_CASE("stdout_st", "[stdout]")
+{
+    auto l = spdlog::stdout_logger_st("test");
+    l->set_pattern("%+");
+    l->set_level(spdlog::level::trace);
+    l->trace("Test stdout_st");
+    spdlog::drop_all();
+}
+
+TEST_CASE("stdout_mt", "[stdout]")
+{
+    auto l = spdlog::stdout_logger_mt("test");
+    l->set_pattern("%+");
+    l->set_level(spdlog::level::debug);
+    l->debug("Test stdout_mt");
+    spdlog::drop_all();
+}
+
+TEST_CASE("stderr_st", "[stderr]")
+{
+    auto l = spdlog::stderr_logger_st("test");
+    l->set_pattern("%+");
+    l->info("Test stderr_st");
+    spdlog::drop_all();
+}
+
+TEST_CASE("stderr_mt", "[stderr]")
+{
+    auto l = spdlog::stderr_logger_mt("test");
+    l->set_pattern("%+");
+    l->info("Test stderr_mt");
+    l->warn("Test stderr_mt");
+    l->error("Test stderr_mt");
+    l->critical("Test stderr_mt");
+    spdlog::drop_all();
+}
+
+// color loggers
+TEST_CASE("stdout_color_st", "[stdout]")
+{
+    auto l = spdlog::stdout_color_st("test");
+    l->set_pattern("%+");
+    l->info("Test stdout_color_st");
+    spdlog::drop_all();
+}
+
+TEST_CASE("stdout_color_mt", "[stdout]")
+{
+    auto l = spdlog::stdout_color_mt("test");
+    l->set_pattern("%+");
+    l->set_level(spdlog::level::trace);
+    l->trace("Test stdout_color_mt");
+    spdlog::drop_all();
+}
+
+TEST_CASE("stderr_color_st", "[stderr]")
+{
+    auto l = spdlog::stderr_color_st("test");
+    l->set_pattern("%+");
+    l->set_level(spdlog::level::debug);
+    l->debug("Test stderr_color_st");
+    spdlog::drop_all();
+}
+
+TEST_CASE("stderr_color_mt", "[stderr]")
+{
+    auto l = spdlog::stderr_color_mt("test");
+    l->set_pattern("%+");
+    l->info("Test stderr_color_mt");
+    l->warn("Test stderr_color_mt");
+    l->error("Test stderr_color_mt");
+    l->critical("Test stderr_color_mt");
+    spdlog::drop_all();
+}
+
+#ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT
+
+TEST_CASE("wchar_api", "[stdout]")
+{
+    auto l = spdlog::stdout_logger_st("wchar_logger");
+    l->set_pattern("%+");
+    l->set_level(spdlog::level::trace);
+    l->trace(L"Test wchar_api");
+    l->trace(L"Test wchar_api {}", L"param");
+    l->trace(L"Test wchar_api {}", 1);
+    l->trace(L"Test wchar_api {}", std::wstring{L"wstring param"});
+    l->trace(std::wstring{L"Test wchar_api wstring"});
+    SPDLOG_LOGGER_DEBUG(l, L"Test SPDLOG_LOGGER_DEBUG {}", L"param");
+    spdlog::drop_all();
+}
+
+#endif
diff --git a/3rdparty/spdlog/src/tests/test_stopwatch.cpp b/3rdparty/spdlog/src/tests/test_stopwatch.cpp
new file mode 100644
index 00000000..61e37698
--- /dev/null
+++ b/3rdparty/spdlog/src/tests/test_stopwatch.cpp
@@ -0,0 +1,44 @@
+#include "includes.h"
+#include "test_sink.h"
+#include "spdlog/stopwatch.h"
+
+TEST_CASE("stopwatch1", "[stopwatch]")
+{
+    using std::chrono::milliseconds;
+    using clock = std::chrono::steady_clock;
+    milliseconds wait_ms(200);
+    milliseconds tolerance_ms(250);
+    auto start = clock::now();
+    spdlog::stopwatch sw;
+    std::this_thread::sleep_for(wait_ms);
+    auto stop = clock::now();
+    auto diff_ms = std::chrono::duration_cast<milliseconds>(stop - start);
+    REQUIRE(sw.elapsed() >= diff_ms);
+    REQUIRE(sw.elapsed() <= diff_ms + tolerance_ms);
+}
+
+TEST_CASE("stopwatch2", "[stopwatch]")
+{
+    using spdlog::sinks::test_sink_st;
+    using std::chrono::duration_cast;
+    using std::chrono::milliseconds;
+    using clock = std::chrono::steady_clock;
+
+    clock::duration wait_duration(milliseconds(200));
+    clock::duration tolerance_duration(milliseconds(250));
+
+    auto test_sink = std::make_shared<test_sink_st>();
+
+    auto start = clock::now();
+    spdlog::stopwatch sw;
+    spdlog::logger logger("test-stopwatch", test_sink);
+    logger.set_pattern("%v");
+    std::this_thread::sleep_for(wait_duration);
+    auto stop = clock::now();
+    logger.info("{}", sw);
+    auto val = std::stod(test_sink->lines()[0]);
+    auto diff_duration = duration_cast<std::chrono::duration<double>>(stop - start);
+
+    REQUIRE(val >= diff_duration.count());
+    REQUIRE(val <= (diff_duration + tolerance_duration).count());
+}
diff --git a/3rdparty/spdlog/src/tests/test_systemd.cpp b/3rdparty/spdlog/src/tests/test_systemd.cpp
new file mode 100644
index 00000000..8688f41d
--- /dev/null
+++ b/3rdparty/spdlog/src/tests/test_systemd.cpp
@@ -0,0 +1,15 @@
+#include "includes.h"
+#include "spdlog/sinks/systemd_sink.h"
+
+TEST_CASE("systemd", "[all]")
+{
+    auto systemd_sink = std::make_shared<spdlog::sinks::systemd_sink_st>();
+    spdlog::logger logger("spdlog_systemd_test", systemd_sink);
+    logger.set_level(spdlog::level::trace);
+    logger.trace("test spdlog trace");
+    logger.debug("test spdlog debug");
+    SPDLOG_LOGGER_INFO((&logger), "test spdlog info");
+    SPDLOG_LOGGER_WARN((&logger), "test spdlog warn");
+    SPDLOG_LOGGER_ERROR((&logger), "test spdlog error");
+    SPDLOG_LOGGER_CRITICAL((&logger), "test spdlog critical");
+}
diff --git a/3rdparty/spdlog/src/tests/test_time_point.cpp b/3rdparty/spdlog/src/tests/test_time_point.cpp
new file mode 100644
index 00000000..bacff69a
--- /dev/null
+++ b/3rdparty/spdlog/src/tests/test_time_point.cpp
@@ -0,0 +1,36 @@
+#include "includes.h"
+#include "test_sink.h"
+#include "spdlog/async.h"
+
+TEST_CASE("time_point1", "[time_point log_msg]")
+{
+    std::shared_ptr<spdlog::sinks::test_sink_st> test_sink(new spdlog::sinks::test_sink_st);
+    spdlog::logger logger("test-time_point", test_sink);
+
+    spdlog::source_loc source{};
+    std::chrono::system_clock::time_point tp{std::chrono::system_clock::now()};
+    test_sink->set_pattern("%T.%F"); // interested in the time_point
+
+    // all the following should have the same time
+    test_sink->set_delay(std::chrono::milliseconds(10));
+    for (int i = 0; i < 5; i++)
+    {
+        spdlog::details::log_msg msg{tp, source, "test_logger", spdlog::level::info, "message"};
+        test_sink->log(msg);
+    }
+
+    logger.log(tp, source, spdlog::level::info, "formatted message");
+    logger.log(tp, source, spdlog::level::info, "formatted message");
+    logger.log(tp, source, spdlog::level::info, "formatted message");
+    logger.log(tp, source, spdlog::level::info, "formatted message");
+    logger.log(source, spdlog::level::info, "formatted message"); // last line has different time_point
+
+    // now the real test... that the times are the same.
+    std::vector<std::string> lines = test_sink->lines();
+    REQUIRE(lines[0] == lines[1]);
+    REQUIRE(lines[2] == lines[3]);
+    REQUIRE(lines[4] == lines[5]);
+    REQUIRE(lines[6] == lines[7]);
+    REQUIRE(lines[8] != lines[9]);
+    spdlog::drop_all();
+}
diff --git a/3rdparty/spdlog/src/tests/utils.cpp b/3rdparty/spdlog/src/tests/utils.cpp
new file mode 100644
index 00000000..6d027797
--- /dev/null
+++ b/3rdparty/spdlog/src/tests/utils.cpp
@@ -0,0 +1,127 @@
+#include "includes.h"
+
+#ifdef _WIN32
+#    include <windows.h>
+#else
+#    include <sys/types.h>
+#    include <dirent.h>
+#endif
+
+void prepare_logdir()
+{
+    spdlog::drop_all();
+#ifdef _WIN32
+    system("rmdir /S /Q test_logs");
+#else
+    auto rv = system("rm -rf test_logs");
+    if (rv != 0)
+    {
+        throw std::runtime_error("Failed to rm -rf test_logs");
+    }
+#endif
+}
+
+std::string file_contents(const std::string &filename)
+{
+    std::ifstream ifs(filename, std::ios_base::binary);
+    if (!ifs)
+    {
+        throw std::runtime_error("Failed open file ");
+    }
+    return std::string((std::istreambuf_iterator<char>(ifs)), (std::istreambuf_iterator<char>()));
+}
+
+std::size_t count_lines(const std::string &filename)
+{
+    std::ifstream ifs(filename);
+    if (!ifs)
+    {
+        throw std::runtime_error("Failed open file ");
+    }
+
+    std::string line;
+    size_t counter = 0;
+    while (std::getline(ifs, line))
+        counter++;
+    return counter;
+}
+
+void require_message_count(const std::string &filename, const std::size_t messages)
+{
+    if (strlen(spdlog::details::os::default_eol) == 0)
+    {
+        REQUIRE(count_lines(filename) == 1);
+    }
+    else
+    {
+        REQUIRE(count_lines(filename) == messages);
+    }
+}
+
+std::size_t get_filesize(const std::string &filename)
+{
+    std::ifstream ifs(filename, std::ifstream::ate | std::ifstream::binary);
+    if (!ifs)
+    {
+        throw std::runtime_error("Failed open file ");
+    }
+
+    return static_cast<std::size_t>(ifs.tellg());
+}
+
+// source: https://stackoverflow.com/a/2072890/192001
+bool ends_with(std::string const &value, std::string const &ending)
+{
+    if (ending.size() > value.size())
+    {
+        return false;
+    }
+    return std::equal(ending.rbegin(), ending.rend(), value.rbegin());
+}
+
+#ifdef _WIN32
+// Based on: https://stackoverflow.com/a/37416569/192001
+std::size_t count_files(const std::string &folder)
+{
+    size_t counter = 0;
+    WIN32_FIND_DATAA ffd;
+
+    // Start iterating over the files in the folder directory.
+    HANDLE hFind = ::FindFirstFileA((folder + "\\*").c_str(), &ffd);
+    if (hFind != INVALID_HANDLE_VALUE)
+    {
+        do // Managed to locate and create an handle to that folder.
+        {
+            if (ffd.cFileName[0] != '.')
+                counter++;
+        } while (::FindNextFileA(hFind, &ffd) != 0);
+        ::FindClose(hFind);
+    }
+    else
+    {
+        throw std::runtime_error("Failed open folder " + folder);
+    }
+
+    return counter;
+}
+#else
+// Based on: https://stackoverflow.com/a/2802255/192001
+std::size_t count_files(const std::string &folder)
+{
+    size_t counter = 0;
+    DIR *dp = opendir(folder.c_str());
+    if (dp == nullptr)
+    {
+        throw std::runtime_error("Failed open folder " + folder);
+    }
+
+    struct dirent *ep = nullptr;
+    while ((ep = readdir(dp)) != nullptr)
+    {
+        if (ep->d_name[0] != '.')
+            counter++;
+    }
+    (void)closedir(dp);
+    return counter;
+}
+#endif
diff --git a/3rdparty/spdlog/src/tests/utils.h b/3rdparty/spdlog/src/tests/utils.h
new file mode 100644
index 00000000..53c09b46
--- /dev/null
+++ b/3rdparty/spdlog/src/tests/utils.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include <cstddef>
+#include <string>
+
+std::size_t count_files(const std::string &folder);
+
+void prepare_logdir();
+
+std::string file_contents(const std::string &filename);
+
+std::size_t count_lines(const std::string &filename);
+
+void require_message_count(const std::string &filename, const std::size_t messages);
+
+std::size_t get_filesize(const std::string &filename);
+
+bool ends_with(std::string const &value, std::string const &ending);
\ No newline at end of file
diff --git a/3rdparty/tinyxml2/CMakeLists.txt b/3rdparty/tinyxml2/CMakeLists.txt
new file mode 100644
index 00000000..00d41f47
--- /dev/null
+++ b/3rdparty/tinyxml2/CMakeLists.txt
@@ -0,0 +1,9 @@
+cmake_minimum_required(VERSION 3.5)
+
+add_library(tinyxml2 STATIC src/tinyxml2.cpp)
+target_include_directories(tinyxml2 INTERFACE ${CMAKE_CURRENT_LIST_DIR}/src)
+
+add_library(tinyxml2::tinyxml2 ALIAS tinyxml2)
+ob_source_group(tinyxml2::tinyxml2)
+
+set_target_properties(tinyxml2 PROPERTIES FOLDER "dependencies")
diff --git a/3rdparty/tinyxml2/src/tinyxml2.cpp b/3rdparty/tinyxml2/src/tinyxml2.cpp
new file mode 100644
index 00000000..dbab48cf
--- /dev/null
+++ b/3rdparty/tinyxml2/src/tinyxml2.cpp
@@ -0,0 +1,2604 @@
+/*
+Original code by Lee Thomason (www.grinninglizard.com)
+
+This software is provided 'as-is', without any express or implied
+warranty. In no event will the authors be held liable for any
+damages arising from the use of this software.
+
+Permission is granted to anyone to use this software for any
+purpose, including commercial applications, and to alter it and
+redistribute it freely, subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must
+not claim that you wrote the original software. If you use this
+software in a product, an acknowledgment in the product documentation
+would be appreciated but is not required.
+
+2. Altered source versions must be plainly marked as such, and
+must not be misrepresented as being the original software.
+
+3. This notice may not be removed or altered from any source
+distribution.
+*/
+
+#include "tinyxml2.hpp"
+
+#include <new>  // yes, this one new style header, is in the Android SDK.
+#if defined(ANDROID_NDK) || defined(__BORLANDC__) || defined(__QNXNTO__)
+#include <stdarg.h>
+#include <stddef.h>
+#else
+#include <cstdarg>
+#include <cstddef>
+#endif
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1400) && (!defined WINCE)
+// Microsoft Visual Studio, version 2005 and higher. Not WinCE.
+/*int _snprintf_s(
+   char *buffer,
+   size_t sizeOfBuffer,
+   size_t count,
+   const char *format [,
+      argument] ...
+);*/
+static inline int TIXML_SNPRINTF(char *buffer, size_t size, const char *format, ...) {
+    va_list va;
+    va_start(va, format);
+    const int result = vsnprintf_s(buffer, size, _TRUNCATE, format, va);
+    va_end(va);
+    return result;
+}
+
+static inline int TIXML_VSNPRINTF(char *buffer, size_t size, const char *format, va_list va) {
+    const int result = vsnprintf_s(buffer, size, _TRUNCATE, format, va);
+    return result;
+}
+
+#define TIXML_VSCPRINTF _vscprintf
+#define TIXML_SSCANF sscanf_s
+#elif defined _MSC_VER
+// Microsoft Visual Studio 2003 and earlier or WinCE
+#define TIXML_SNPRINTF _snprintf
+#define TIXML_VSNPRINTF _vsnprintf
+#define TIXML_SSCANF sscanf
+#if(_MSC_VER < 1400) && (!defined WINCE)
+// Microsoft Visual Studio 2003 and not WinCE.
+#define TIXML_VSCPRINTF _vscprintf  // VS2003's C runtime has this, but VC6 C runtime or WinCE SDK doesn't have.
+#else
+// Microsoft Visual Studio 2003 and earlier or WinCE.
+static inline int TIXML_VSCPRINTF(const char *format, va_list va) {
+    int len = 512;
+    for(;;) {
+        len                = len * 2;
+        char     *str      = new char[len]();
+        const int required = _vsnprintf(str, len, format, va);
+        delete[] str;
+        if(required != -1) {
+            TIXMLASSERT(required >= 0);
+            len = required;
+            break;
+        }
+    }
+    TIXMLASSERT(len >= 0);
+    return len;
+}
+#endif
+#else
+// GCC version 3 and higher
+// #warning( "Using sn* functions." )
+#define TIXML_SNPRINTF snprintf
+#define TIXML_VSNPRINTF vsnprintf
+static inline int TIXML_VSCPRINTF(const char *format, va_list va) {
+    int len = vsnprintf(0, 0, format, va);
+    TIXMLASSERT(len >= 0);
+    return len;
+}
+#define TIXML_SSCANF sscanf
+#endif
+
+static const char LINE_FEED       = static_cast<char>(0x0a);  // all line endings are normalized to LF
+static const char LF              = LINE_FEED;
+static const char CARRIAGE_RETURN = static_cast<char>(0x0d);  // CR gets filtered out
+static const char CR              = CARRIAGE_RETURN;
+static const char SINGLE_QUOTE    = '\'';
+static const char DOUBLE_QUOTE    = '\"';
+
+// Bunch of unicode info at:
+//		http://www.unicode.org/faq/utf_bom.html
+//	ef bb bf (Microsoft "lead bytes") - designates UTF-8
+
+static const unsigned char TIXML_UTF_LEAD_0 = 0xefU;
+static const unsigned char TIXML_UTF_LEAD_1 = 0xbbU;
+static const unsigned char TIXML_UTF_LEAD_2 = 0xbfU;
+
+namespace libobsensor {
+
+struct Entity {
+    const char *pattern;
+    int         length;
+    char        value;
+};
+
+static const int    NUM_ENTITIES           = 5;
+static const Entity entities[NUM_ENTITIES] = {
+    { "quot", 4, DOUBLE_QUOTE }, { "amp", 3, '&' }, { "apos", 4, SINGLE_QUOTE }, { "lt", 2, '<' }, { "gt", 2, '>' }
+};
+
+// --------- StrPair ----------- //
+
+StrPair::~StrPair() {
+    Reset();
+}
+
+void StrPair::TransferTo(StrPair *other) {
+    if(this == other) {
+        return;
+    }
+    // This in effect implements the assignment operator by "moving"
+    // ownership (as in auto_ptr).
+
+    TIXMLASSERT(other != 0);
+    TIXMLASSERT(other->_flags == 0);
+    TIXMLASSERT(other->_start == 0);
+    TIXMLASSERT(other->_end == 0);
+
+    other->Reset();
+
+    other->_flags = _flags;
+    other->_start = _start;
+    other->_end   = _end;
+
+    _flags = 0;
+    _start = 0;
+    _end   = 0;
+}
+
+void StrPair::Reset() {
+    if(_flags & NEEDS_DELETE) {
+        delete[] _start;
+    }
+    _flags = 0;
+    _start = 0;
+    _end   = 0;
+}
+
+void StrPair::SetStr(const char *str, int flags) {
+    TIXMLASSERT(str);
+    Reset();
+    size_t len = strlen(str);
+    TIXMLASSERT(_start == 0);
+    _start = new char[len + 1];
+    memcpy(_start, str, len + 1);
+    _end   = _start + len;
+    _flags = flags | NEEDS_DELETE;
+}
+
+char *StrPair::ParseText(char *p, const char *endTag, int strFlags, int *curLineNumPtr) {
+    TIXMLASSERT(p);
+    TIXMLASSERT(endTag && *endTag);
+    TIXMLASSERT(curLineNumPtr);
+
+    char      *start   = p;
+    const char endChar = *endTag;
+    size_t     length  = strlen(endTag);
+
+    // Inner loop of text parsing.
+    while(*p) {
+        if(*p == endChar && strncmp(p, endTag, length) == 0) {
+            Set(start, p, strFlags);
+            return p + length;
+        }
+        else if(*p == '\n') {
+            ++(*curLineNumPtr);
+        }
+        ++p;
+        TIXMLASSERT(p);
+    }
+    return 0;
+}
+
+char *StrPair::ParseName(char *p) {
+    if(!p || !(*p)) {
+        return 0;
+    }
+    if(!XMLUtil::IsNameStartChar(*p)) {
+        return 0;
+    }
+
+    char *const start = p;
+    ++p;
+    while(*p && XMLUtil::IsNameChar(*p)) {
+        ++p;
+    }
+
+    Set(start, p, 0);
+    return p;
+}
+
+void StrPair::CollapseWhitespace() {
+    // Adjusting _start would cause undefined behavior on delete[]
+    TIXMLASSERT((_flags & NEEDS_DELETE) == 0);
+    // Trim leading space.
+    _start = XMLUtil::SkipWhiteSpace(_start, 0);
+
+    if(*_start) {
+        const char *p = _start;  // the read pointer
+        char       *q = _start;  // the write pointer
+
+        while(*p) {
+            if(XMLUtil::IsWhiteSpace(*p)) {
+                p = XMLUtil::SkipWhiteSpace(p, 0);
+                if(*p == 0) {
+                    break;  // don't write to q; this trims the trailing space.
+                }
+                *q = ' ';
+                ++q;
+            }
+            *q = *p;
+            ++q;
+            ++p;
+        }
+        *q = 0;
+    }
+}
+
+const char *StrPair::GetStr() {
+    TIXMLASSERT(_start);
+    TIXMLASSERT(_end);
+    if(_flags & NEEDS_FLUSH) {
+        *_end = 0;
+        _flags ^= NEEDS_FLUSH;
+
+        if(_flags) {
+            const char *p = _start;  // the read pointer
+            char       *q = _start;  // the write pointer
+
+            while(p < _end) {
+                if((_flags & NEEDS_NEWLINE_NORMALIZATION) && *p == CR) {
+                    // CR-LF pair becomes LF
+                    // CR alone becomes LF
+                    // LF-CR becomes LF
+                    if(*(p + 1) == LF) {
+                        p += 2;
+                    }
+                    else {
+                        ++p;
+                    }
+                    *q = LF;
+                    ++q;
+                }
+                else if((_flags & NEEDS_NEWLINE_NORMALIZATION) && *p == LF) {
+                    if(*(p + 1) == CR) {
+                        p += 2;
+                    }
+                    else {
+                        ++p;
+                    }
+                    *q = LF;
+                    ++q;
+                }
+                else if((_flags & NEEDS_ENTITY_PROCESSING) && *p == '&') {
+                    // Entities handled by tinyXML2:
+                    // - special entities in the entity table [in/out]
+                    // - numeric character reference [in]
+                    //   &#20013; or &#x4e2d;
+
+                    if(*(p + 1) == '#') {
+                        const int   buflen      = 10;
+                        char        buf[buflen] = { 0 };
+                        int         len         = 0;
+                        const char *adjusted    = const_cast<char *>(XMLUtil::GetCharacterRef(p, buf, &len));
+                        if(adjusted == 0) {
+                            *q = *p;
+                            ++p;
+                            ++q;
+                        }
+                        else {
+                            TIXMLASSERT(0 <= len && len <= buflen);
+                            TIXMLASSERT(q + len <= adjusted);
+                            p = adjusted;
+                            memcpy(q, buf, len);
+                            q += len;
+                        }
+                    }
+                    else {
+                        bool entityFound = false;
+                        for(int i = 0; i < NUM_ENTITIES; ++i) {
+                            const Entity &entity = entities[i];
+                            if(strncmp(p + 1, entity.pattern, entity.length) == 0 && *(p + entity.length + 1) == ';') {
+                                // Found an entity - convert.
+                                *q = entity.value;
+                                ++q;
+                                p += entity.length + 2;
+                                entityFound = true;
+                                break;
+                            }
+                        }
+                        if(!entityFound) {
+                            // fixme: treat as error?
+                            ++p;
+                            ++q;
+                        }
+                    }
+                }
+                else {
+                    *q = *p;
+                    ++p;
+                    ++q;
+                }
+            }
+            *q = 0;
+        }
+        // The loop below has plenty going on, and this
+        // is a less useful mode. Break it out.
+        if(_flags & NEEDS_WHITESPACE_COLLAPSING) {
+            CollapseWhitespace();
+        }
+        _flags = (_flags & NEEDS_DELETE);
+    }
+    TIXMLASSERT(_start);
+    return _start;
+}
+
+// --------- XMLUtil ----------- //
+
+const char *XMLUtil::writeBoolTrue  = "true";
+const char *XMLUtil::writeBoolFalse = "false";
+
+void XMLUtil::SetBoolSerialization(const char *writeTrue, const char *writeFalse) {
+    static const char *defTrue  = "true";
+    static const char *defFalse = "false";
+
+    writeBoolTrue  = (writeTrue) ? writeTrue : defTrue;
+    writeBoolFalse = (writeFalse) ? writeFalse : defFalse;
+}
+
+const char *XMLUtil::ReadBOM(const char *p, bool *bom) {
+    TIXMLASSERT(p);
+    TIXMLASSERT(bom);
+    *bom                    = false;
+    const unsigned char *pu = reinterpret_cast<const unsigned char *>(p);
+    // Check for BOM:
+    if(*(pu + 0) == TIXML_UTF_LEAD_0 && *(pu + 1) == TIXML_UTF_LEAD_1 && *(pu + 2) == TIXML_UTF_LEAD_2) {
+        *bom = true;
+        p += 3;
+    }
+    TIXMLASSERT(p);
+    return p;
+}
+
+void XMLUtil::ConvertUTF32ToUTF8(unsigned long input, char *output, int *length) {
+    const unsigned long BYTE_MASK          = 0xBF;
+    const unsigned long BYTE_MARK          = 0x80;
+    const unsigned long FIRST_BYTE_MARK[7] = { 0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC };
+
+    if(input < 0x80) {
+        *length = 1;
+    }
+    else if(input < 0x800) {
+        *length = 2;
+    }
+    else if(input < 0x10000) {
+        *length = 3;
+    }
+    else if(input < 0x200000) {
+        *length = 4;
+    }
+    else {
+        *length = 0;  // This code won't convert this correctly anyway.
+        return;
+    }
+
+    output += *length;
+
+    // Scary scary fall throughs are annotated with carefully designed comments
+    // to suppress compiler warnings such as -Wimplicit-fallthrough in gcc
+    switch(*length) {
+    case 4:
+        --output;
+        *output = static_cast<char>((input | BYTE_MARK) & BYTE_MASK);
+        input >>= 6;
+        // fall through
+    case 3:
+        --output;
+        *output = static_cast<char>((input | BYTE_MARK) & BYTE_MASK);
+        input >>= 6;
+        // fall through
+    case 2:
+        --output;
+        *output = static_cast<char>((input | BYTE_MARK) & BYTE_MASK);
+        input >>= 6;
+        // fall through
+    case 1:
+        --output;
+        *output = static_cast<char>(input | FIRST_BYTE_MARK[*length]);
+        break;
+    default:
+        TIXMLASSERT(false);
+    }
+}
+
+const char *XMLUtil::GetCharacterRef(const char *p, char *value, int *length) {
+    // Presume an entity, and pull it out.
+    *length = 0;
+
+    if(*(p + 1) == '#' && *(p + 2)) {
+        unsigned long ucs = 0;
+        TIXMLASSERT(sizeof(ucs) >= 4);
+        ptrdiff_t         delta     = 0;
+        unsigned          mult      = 1;
+        static const char SEMICOLON = ';';
+
+        if(*(p + 2) == 'x') {
+            // Hexadecimal.
+            const char *q = p + 3;
+            if(!(*q)) {
+                return 0;
+            }
+
+            q = strchr(q, SEMICOLON);
+
+            if(!q) {
+                return 0;
+            }
+            TIXMLASSERT(*q == SEMICOLON);
+
+            delta = q - p;
+            --q;
+
+            while(*q != 'x') {
+                unsigned int digit = 0;
+
+                if(*q >= '0' && *q <= '9') {
+                    digit = *q - '0';
+                }
+                else if(*q >= 'a' && *q <= 'f') {
+                    digit = *q - 'a' + 10;
+                }
+                else if(*q >= 'A' && *q <= 'F') {
+                    digit = *q - 'A' + 10;
+                }
+                else {
+                    return 0;
+                }
+                TIXMLASSERT(digit < 16);
+                TIXMLASSERT(digit == 0 || mult <= UINT_MAX / digit);
+                const unsigned int digitScaled = mult * digit;
+                TIXMLASSERT(ucs <= ULONG_MAX - digitScaled);
+                ucs += digitScaled;
+                TIXMLASSERT(mult <= UINT_MAX / 16);
+                mult *= 16;
+                --q;
+            }
+        }
+        else {
+            // Decimal.
+            const char *q = p + 2;
+            if(!(*q)) {
+                return 0;
+            }
+
+            q = strchr(q, SEMICOLON);
+
+            if(!q) {
+                return 0;
+            }
+            TIXMLASSERT(*q == SEMICOLON);
+
+            delta = q - p;
+            --q;
+
+            while(*q != '#') {
+                if(*q >= '0' && *q <= '9') {
+                    const unsigned int digit = *q - '0';
+                    TIXMLASSERT(digit < 10);
+                    TIXMLASSERT(digit == 0 || mult <= UINT_MAX / digit);
+                    const unsigned int digitScaled = mult * digit;
+                    TIXMLASSERT(ucs <= ULONG_MAX - digitScaled);
+                    ucs += digitScaled;
+                }
+                else {
+                    return 0;
+                }
+                TIXMLASSERT(mult <= UINT_MAX / 10);
+                mult *= 10;
+                --q;
+            }
+        }
+        // convert the UCS to UTF-8
+        ConvertUTF32ToUTF8(ucs, value, length);
+        return p + delta + 1;
+    }
+    return p + 1;
+}
+
+void XMLUtil::ToStr(int v, char *buffer, int bufferSize) {
+    TIXML_SNPRINTF(buffer, bufferSize, "%d", v);
+}
+
+void XMLUtil::ToStr(unsigned v, char *buffer, int bufferSize) {
+    TIXML_SNPRINTF(buffer, bufferSize, "%u", v);
+}
+
+void XMLUtil::ToStr(bool v, char *buffer, int bufferSize) {
+    TIXML_SNPRINTF(buffer, bufferSize, "%s", v ? writeBoolTrue : writeBoolFalse);
+}
+/*
+    ToStr() of a number is a very tricky topic.
+    https://github.com/leethomason/tinyxml2/issues/106
+*/
+void XMLUtil::ToStr(float v, char *buffer, int bufferSize) {
+    TIXML_SNPRINTF(buffer, bufferSize, "%.8g", v);
+}
+
+void XMLUtil::ToStr(double v, char *buffer, int bufferSize) {
+    TIXML_SNPRINTF(buffer, bufferSize, "%.17g", v);
+}
+
+void XMLUtil::ToStr(int64_t v, char *buffer, int bufferSize) {
+    // horrible syntax trick to make the compiler happy about %lld
+    TIXML_SNPRINTF(buffer, bufferSize, "%lld", static_cast<long long>(v));
+}
+
+void XMLUtil::ToStr(uint64_t v, char *buffer, int bufferSize) {
+    // horrible syntax trick to make the compiler happy about %llu
+    TIXML_SNPRINTF(buffer, bufferSize, "%llu", (long long)v);
+}
+
+bool XMLUtil::ToInt(const char *str, int *value) {
+    if(TIXML_SSCANF(str, "%d", value) == 1) {
+        return true;
+    }
+    return false;
+}
+
+bool XMLUtil::ToUnsigned(const char *str, unsigned *value) {
+    if(TIXML_SSCANF(str, "%u", value) == 1) {
+        return true;
+    }
+    return false;
+}
+
+bool XMLUtil::ToBool(const char *str, bool *value) {
+    int ival = 0;
+    if(ToInt(str, &ival)) {
+        *value = (ival == 0) ? false : true;
+        return true;
+    }
+    static const char *TRUE[]  = { "true", "True", "TRUE", 0 };
+    static const char *FALSE[] = { "false", "False", "FALSE", 0 };
+
+    for(int i = 0; TRUE[i]; ++i) {
+        if(StringEqual(str, TRUE[i])) {
+            *value = true;
+            return true;
+        }
+    }
+    for(int i = 0; FALSE[i]; ++i) {
+        if(StringEqual(str, FALSE[i])) {
+            *value = false;
+            return true;
+        }
+    }
+    return false;
+}
+
+bool XMLUtil::ToFloat(const char *str, float *value) {
+    if(TIXML_SSCANF(str, "%f", value) == 1) {
+        return true;
+    }
+    return false;
+}
+
+bool XMLUtil::ToDouble(const char *str, double *value) {
+    if(TIXML_SSCANF(str, "%lf", value) == 1) {
+        return true;
+    }
+    return false;
+}
+
+bool XMLUtil::ToInt64(const char *str, int64_t *value) {
+    long long v = 0;  // horrible syntax trick to make the compiler happy about %lld
+    if(TIXML_SSCANF(str, "%lld", &v) == 1) {
+        *value = static_cast<int64_t>(v);
+        return true;
+    }
+    return false;
+}
+
+bool XMLUtil::ToUnsigned64(const char *str, uint64_t *value) {
+    unsigned long long v = 0;  // horrible syntax trick to make the compiler happy about %llu
+    if(TIXML_SSCANF(str, "%llu", &v) == 1) {
+        *value = (uint64_t)v;
+        return true;
+    }
+    return false;
+}
+
+char *XMLDocument::Identify(char *p, XMLNode **node) {
+    TIXMLASSERT(node);
+    TIXMLASSERT(p);
+    char *const start     = p;
+    int const   startLine = _parseCurLineNum;
+    p                     = XMLUtil::SkipWhiteSpace(p, &_parseCurLineNum);
+    if(!*p) {
+        *node = 0;
+        TIXMLASSERT(p);
+        return p;
+    }
+
+    // These strings define the matching patterns:
+    static const char *xmlHeader     = { "<?" };
+    static const char *commentHeader = { "<!--" };
+    static const char *cdataHeader   = { "<![CDATA[" };
+    static const char *dtdHeader     = { "<!" };
+    static const char *elementHeader = { "<" };  // and a header for everything else; check last.
+
+    static const int xmlHeaderLen     = 2;
+    static const int commentHeaderLen = 4;
+    static const int cdataHeaderLen   = 9;
+    static const int dtdHeaderLen     = 2;
+    static const int elementHeaderLen = 1;
+
+    TIXMLASSERT(sizeof(XMLComment) == sizeof(XMLUnknown));      // use same memory pool
+    TIXMLASSERT(sizeof(XMLComment) == sizeof(XMLDeclaration));  // use same memory pool
+    XMLNode *returnNode = 0;
+    if(XMLUtil::StringEqual(p, xmlHeader, xmlHeaderLen)) {
+        returnNode                = CreateUnlinkedNode<XMLDeclaration>(_commentPool);
+        returnNode->_parseLineNum = _parseCurLineNum;
+        p += xmlHeaderLen;
+    }
+    else if(XMLUtil::StringEqual(p, commentHeader, commentHeaderLen)) {
+        returnNode                = CreateUnlinkedNode<XMLComment>(_commentPool);
+        returnNode->_parseLineNum = _parseCurLineNum;
+        p += commentHeaderLen;
+    }
+    else if(XMLUtil::StringEqual(p, cdataHeader, cdataHeaderLen)) {
+        XMLText *text             = CreateUnlinkedNode<XMLText>(_textPool);
+        returnNode                = text;
+        returnNode->_parseLineNum = _parseCurLineNum;
+        p += cdataHeaderLen;
+        text->SetCData(true);
+    }
+    else if(XMLUtil::StringEqual(p, dtdHeader, dtdHeaderLen)) {
+        returnNode                = CreateUnlinkedNode<XMLUnknown>(_commentPool);
+        returnNode->_parseLineNum = _parseCurLineNum;
+        p += dtdHeaderLen;
+    }
+    else if(XMLUtil::StringEqual(p, elementHeader, elementHeaderLen)) {
+        returnNode                = CreateUnlinkedNode<XMLElement>(_elementPool);
+        returnNode->_parseLineNum = _parseCurLineNum;
+        p += elementHeaderLen;
+    }
+    else {
+        returnNode                = CreateUnlinkedNode<XMLText>(_textPool);
+        returnNode->_parseLineNum = _parseCurLineNum;  // Report line of first non-whitespace character
+        p                         = start;             // Back it up, all the text counts.
+        _parseCurLineNum          = startLine;
+    }
+
+    TIXMLASSERT(returnNode);
+    TIXMLASSERT(p);
+    *node = returnNode;
+    return p;
+}
+
+bool XMLDocument::Accept(XMLVisitor *visitor) const {
+    TIXMLASSERT(visitor);
+    if(visitor->VisitEnter(*this)) {
+        for(const XMLNode *node = FirstChild(); node; node = node->NextSibling()) {
+            if(!node->Accept(visitor)) {
+                break;
+            }
+        }
+    }
+    return visitor->VisitExit(*this);
+}
+
+// --------- XMLNode ----------- //
+
+XMLNode::XMLNode(XMLDocument *doc)
+    : _document(doc), _parent(0), _value(), _parseLineNum(0), _firstChild(0), _lastChild(0), _prev(0), _next(0), _userData(0), _memPool(0) {}
+
+XMLNode::~XMLNode() {
+    DeleteChildren();
+    if(_parent) {
+        _parent->Unlink(this);
+    }
+}
+
+const char *XMLNode::Value() const {
+    // Edge case: XMLDocuments don't have a Value. Return null.
+    if(this->ToDocument())
+        return 0;
+    return _value.GetStr();
+}
+
+void XMLNode::SetValue(const char *str, bool staticMem) {
+    if(staticMem) {
+        _value.SetInternedStr(str);
+    }
+    else {
+        _value.SetStr(str);
+    }
+}
+
+XMLNode *XMLNode::DeepClone(XMLDocument *target) const {
+    XMLNode *clone = this->ShallowClone(target);
+    if(!clone)
+        return 0;
+
+    for(const XMLNode *child = this->FirstChild(); child; child = child->NextSibling()) {
+        XMLNode *childClone = child->DeepClone(target);
+        TIXMLASSERT(childClone);
+        clone->InsertEndChild(childClone);
+    }
+    return clone;
+}
+
+void XMLNode::DeleteChildren() {
+    while(_firstChild) {
+        TIXMLASSERT(_lastChild);
+        DeleteChild(_firstChild);
+    }
+    _firstChild = _lastChild = 0;
+}
+
+void XMLNode::Unlink(XMLNode *child) {
+    TIXMLASSERT(child);
+    TIXMLASSERT(child->_document == _document);
+    TIXMLASSERT(child->_parent == this);
+    if(child == _firstChild) {
+        _firstChild = _firstChild->_next;
+    }
+    if(child == _lastChild) {
+        _lastChild = _lastChild->_prev;
+    }
+
+    if(child->_prev) {
+        child->_prev->_next = child->_next;
+    }
+    if(child->_next) {
+        child->_next->_prev = child->_prev;
+    }
+    child->_next   = 0;
+    child->_prev   = 0;
+    child->_parent = 0;
+}
+
+void XMLNode::DeleteChild(XMLNode *node) {
+    TIXMLASSERT(node);
+    TIXMLASSERT(node->_document == _document);
+    TIXMLASSERT(node->_parent == this);
+    Unlink(node);
+    TIXMLASSERT(node->_prev == 0);
+    TIXMLASSERT(node->_next == 0);
+    TIXMLASSERT(node->_parent == 0);
+    DeleteNode(node);
+}
+
+XMLNode *XMLNode::InsertEndChild(XMLNode *addThis) {
+    TIXMLASSERT(addThis);
+    if(addThis->_document != _document) {
+        TIXMLASSERT(false);
+        return 0;
+    }
+    InsertChildPreamble(addThis);
+
+    if(_lastChild) {
+        TIXMLASSERT(_firstChild);
+        TIXMLASSERT(_lastChild->_next == 0);
+        _lastChild->_next = addThis;
+        addThis->_prev    = _lastChild;
+        _lastChild        = addThis;
+
+        addThis->_next = 0;
+    }
+    else {
+        TIXMLASSERT(_firstChild == 0);
+        _firstChild = _lastChild = addThis;
+
+        addThis->_prev = 0;
+        addThis->_next = 0;
+    }
+    addThis->_parent = this;
+    return addThis;
+}
+
+XMLNode *XMLNode::InsertFirstChild(XMLNode *addThis) {
+    TIXMLASSERT(addThis);
+    if(addThis->_document != _document) {
+        TIXMLASSERT(false);
+        return 0;
+    }
+    InsertChildPreamble(addThis);
+
+    if(_firstChild) {
+        TIXMLASSERT(_lastChild);
+        TIXMLASSERT(_firstChild->_prev == 0);
+
+        _firstChild->_prev = addThis;
+        addThis->_next     = _firstChild;
+        _firstChild        = addThis;
+
+        addThis->_prev = 0;
+    }
+    else {
+        TIXMLASSERT(_lastChild == 0);
+        _firstChild = _lastChild = addThis;
+
+        addThis->_prev = 0;
+        addThis->_next = 0;
+    }
+    addThis->_parent = this;
+    return addThis;
+}
+
+XMLNode *XMLNode::InsertAfterChild(XMLNode *afterThis, XMLNode *addThis) {
+    TIXMLASSERT(addThis);
+    if(addThis->_document != _document) {
+        TIXMLASSERT(false);
+        return 0;
+    }
+
+    TIXMLASSERT(afterThis);
+
+    if(afterThis->_parent != this) {
+        TIXMLASSERT(false);
+        return 0;
+    }
+    if(afterThis == addThis) {
+        // Current state: BeforeThis -> AddThis -> OneAfterAddThis
+        // Now AddThis must disappear from it's location and then
+        // reappear between BeforeThis and OneAfterAddThis.
+        // So just leave it where it is.
+        return addThis;
+    }
+
+    if(afterThis->_next == 0) {
+        // The last node or the only node.
+        return InsertEndChild(addThis);
+    }
+    InsertChildPreamble(addThis);
+    addThis->_prev          = afterThis;
+    addThis->_next          = afterThis->_next;
+    afterThis->_next->_prev = addThis;
+    afterThis->_next        = addThis;
+    addThis->_parent        = this;
+    return addThis;
+}
+
+const XMLElement *XMLNode::FirstChildElement(const char *name) const {
+    for(const XMLNode *node = _firstChild; node; node = node->_next) {
+        const XMLElement *element = node->ToElementWithName(name);
+        if(element) {
+            return element;
+        }
+    }
+    return 0;
+}
+
+const XMLElement *XMLNode::LastChildElement(const char *name) const {
+    for(const XMLNode *node = _lastChild; node; node = node->_prev) {
+        const XMLElement *element = node->ToElementWithName(name);
+        if(element) {
+            return element;
+        }
+    }
+    return 0;
+}
+
+const XMLElement *XMLNode::NextSiblingElement(const char *name) const {
+    for(const XMLNode *node = _next; node; node = node->_next) {
+        const XMLElement *element = node->ToElementWithName(name);
+        if(element) {
+            return element;
+        }
+    }
+    return 0;
+}
+
+const XMLElement *XMLNode::PreviousSiblingElement(const char *name) const {
+    for(const XMLNode *node = _prev; node; node = node->_prev) {
+        const XMLElement *element = node->ToElementWithName(name);
+        if(element) {
+            return element;
+        }
+    }
+    return 0;
+}
+
+char *XMLNode::ParseDeep(char *p, StrPair *parentEndTag, int *curLineNumPtr) {
+    // This is a recursive method, but thinking about it "at the current level"
+    // it is a pretty simple flat list:
+    //		<foo/>
+    //		<!-- comment -->
+    //
+    // With a special case:
+    //		<foo>
+    //		</foo>
+    //		<!-- comment -->
+    //
+    // Where the closing element (/foo) *must* be the next thing after the opening
+    // element, and the names must match. BUT the tricky bit is that the closing
+    // element will be read by the child.
+    //
+    // 'endTag' is the end tag for this node, it is returned by a call to a child.
+    // 'parentEnd' is the end tag for the parent, which is filled in and returned.
+
+    XMLDocument::DepthTracker tracker(_document);
+    if(_document->Error())
+        return 0;
+
+    while(p && *p) {
+        XMLNode *node = 0;
+
+        p = _document->Identify(p, &node);
+        TIXMLASSERT(p);
+        if(node == 0) {
+            break;
+        }
+
+        const int initialLineNum = node->_parseLineNum;
+
+        StrPair endTag;
+        p = node->ParseDeep(p, &endTag, curLineNumPtr);
+        if(!p) {
+            DeleteNode(node);
+            if(!_document->Error()) {
+                _document->SetError(XML_ERROR_PARSING, initialLineNum, 0);
+            }
+            break;
+        }
+
+        const XMLDeclaration *const decl = node->ToDeclaration();
+        if(decl) {
+            // Declarations are only allowed at document level
+            //
+            // Multiple declarations are allowed but all declarations
+            // must occur before anything else.
+            //
+            // Optimized due to a security test case. If the first node is
+            // a declaration, and the last node is a declaration, then only
+            // declarations have so far been added.
+            bool wellLocated = false;
+
+            if(ToDocument()) {
+                if(FirstChild()) {
+                    wellLocated = FirstChild() && FirstChild()->ToDeclaration() && LastChild() && LastChild()->ToDeclaration();
+                }
+                else {
+                    wellLocated = true;
+                }
+            }
+            if(!wellLocated) {
+                _document->SetError(XML_ERROR_PARSING_DECLARATION, initialLineNum, "XMLDeclaration value=%s", decl->Value());
+                DeleteNode(node);
+                break;
+            }
+        }
+
+        XMLElement *ele = node->ToElement();
+        if(ele) {
+            // We read the end tag. Return it to the parent.
+            if(ele->ClosingType() == XMLElement::CLOSING) {
+                if(parentEndTag) {
+                    ele->_value.TransferTo(parentEndTag);
+                }
+                node->_memPool->SetTracked();  // created and then immediately deleted.
+                DeleteNode(node);
+                return p;
+            }
+
+            // Handle an end tag returned to this level.
+            // And handle a bunch of annoying errors.
+            bool mismatch = false;
+            if(endTag.Empty()) {
+                if(ele->ClosingType() == XMLElement::OPEN) {
+                    mismatch = true;
+                }
+            }
+            else {
+                if(ele->ClosingType() != XMLElement::OPEN) {
+                    mismatch = true;
+                }
+                else if(!XMLUtil::StringEqual(endTag.GetStr(), ele->Name())) {
+                    mismatch = true;
+                }
+            }
+            if(mismatch) {
+                _document->SetError(XML_ERROR_MISMATCHED_ELEMENT, initialLineNum, "XMLElement name=%s", ele->Name());
+                DeleteNode(node);
+                break;
+            }
+        }
+        InsertEndChild(node);
+    }
+    return 0;
+}
+
+/*static*/ void XMLNode::DeleteNode(XMLNode *node) {
+    if(node == 0) {
+        return;
+    }
+    TIXMLASSERT(node->_document);
+    if(!node->ToDocument()) {
+        node->_document->MarkInUse(node);
+    }
+
+    MemPool *pool = node->_memPool;
+    node->~XMLNode();
+    pool->Free(node);
+}
+
+void XMLNode::InsertChildPreamble(XMLNode *insertThis) const {
+    TIXMLASSERT(insertThis);
+    TIXMLASSERT(insertThis->_document == _document);
+
+    if(insertThis->_parent) {
+        insertThis->_parent->Unlink(insertThis);
+    }
+    else {
+        insertThis->_document->MarkInUse(insertThis);
+        insertThis->_memPool->SetTracked();
+    }
+}
+
+const XMLElement *XMLNode::ToElementWithName(const char *name) const {
+    const XMLElement *element = this->ToElement();
+    if(element == 0) {
+        return 0;
+    }
+    if(name == 0) {
+        return element;
+    }
+    if(XMLUtil::StringEqual(element->Name(), name)) {
+        return element;
+    }
+    return 0;
+}
+
+// --------- XMLText ---------- //
+char *XMLText::ParseDeep(char *p, StrPair *, int *curLineNumPtr) {
+    if(this->CData()) {
+        p = _value.ParseText(p, "]]>", StrPair::NEEDS_NEWLINE_NORMALIZATION, curLineNumPtr);
+        if(!p) {
+            _document->SetError(XML_ERROR_PARSING_CDATA, _parseLineNum, 0);
+        }
+        return p;
+    }
+    else {
+        int flags = _document->ProcessEntities() ? StrPair::TEXT_ELEMENT : StrPair::TEXT_ELEMENT_LEAVE_ENTITIES;
+        if(_document->WhitespaceMode() == COLLAPSE_WHITESPACE) {
+            flags |= StrPair::NEEDS_WHITESPACE_COLLAPSING;
+        }
+
+        p = _value.ParseText(p, "<", flags, curLineNumPtr);
+        if(p && *p) {
+            return p - 1;
+        }
+        if(!p) {
+            _document->SetError(XML_ERROR_PARSING_TEXT, _parseLineNum, 0);
+        }
+    }
+    return 0;
+}
+
+XMLNode *XMLText::ShallowClone(XMLDocument *doc) const {
+    if(!doc) {
+        doc = _document;
+    }
+    XMLText *text = doc->NewText(Value());  // fixme: this will always allocate memory. Intern?
+    text->SetCData(this->CData());
+    return text;
+}
+
+bool XMLText::ShallowEqual(const XMLNode *compare) const {
+    TIXMLASSERT(compare);
+    const XMLText *text = compare->ToText();
+    return (text && XMLUtil::StringEqual(text->Value(), Value()));
+}
+
+bool XMLText::Accept(XMLVisitor *visitor) const {
+    TIXMLASSERT(visitor);
+    return visitor->Visit(*this);
+}
+
+// --------- XMLComment ---------- //
+
+XMLComment::XMLComment(XMLDocument *doc) : XMLNode(doc) {}
+
+XMLComment::~XMLComment() {}
+
+char *XMLComment::ParseDeep(char *p, StrPair *, int *curLineNumPtr) {
+    // Comment parses as text.
+    p = _value.ParseText(p, "-->", StrPair::COMMENT, curLineNumPtr);
+    if(p == 0) {
+        _document->SetError(XML_ERROR_PARSING_COMMENT, _parseLineNum, 0);
+    }
+    return p;
+}
+
+XMLNode *XMLComment::ShallowClone(XMLDocument *doc) const {
+    if(!doc) {
+        doc = _document;
+    }
+    XMLComment *comment = doc->NewComment(Value());  // fixme: this will always allocate memory. Intern?
+    return comment;
+}
+
+bool XMLComment::ShallowEqual(const XMLNode *compare) const {
+    TIXMLASSERT(compare);
+    const XMLComment *comment = compare->ToComment();
+    return (comment && XMLUtil::StringEqual(comment->Value(), Value()));
+}
+
+bool XMLComment::Accept(XMLVisitor *visitor) const {
+    TIXMLASSERT(visitor);
+    return visitor->Visit(*this);
+}
+
+// --------- XMLDeclaration ---------- //
+
+XMLDeclaration::XMLDeclaration(XMLDocument *doc) : XMLNode(doc) {}
+
+XMLDeclaration::~XMLDeclaration() {
+    // printf( "~XMLDeclaration\n" );
+}
+
+char *XMLDeclaration::ParseDeep(char *p, StrPair *, int *curLineNumPtr) {
+    // Declaration parses as text.
+    p = _value.ParseText(p, "?>", StrPair::NEEDS_NEWLINE_NORMALIZATION, curLineNumPtr);
+    if(p == 0) {
+        _document->SetError(XML_ERROR_PARSING_DECLARATION, _parseLineNum, 0);
+    }
+    return p;
+}
+
+XMLNode *XMLDeclaration::ShallowClone(XMLDocument *doc) const {
+    if(!doc) {
+        doc = _document;
+    }
+    XMLDeclaration *dec = doc->NewDeclaration(Value());  // fixme: this will always allocate memory. Intern?
+    return dec;
+}
+
+bool XMLDeclaration::ShallowEqual(const XMLNode *compare) const {
+    TIXMLASSERT(compare);
+    const XMLDeclaration *declaration = compare->ToDeclaration();
+    return (declaration && XMLUtil::StringEqual(declaration->Value(), Value()));
+}
+
+bool XMLDeclaration::Accept(XMLVisitor *visitor) const {
+    TIXMLASSERT(visitor);
+    return visitor->Visit(*this);
+}
+
+// --------- XMLUnknown ---------- //
+
+XMLUnknown::XMLUnknown(XMLDocument *doc) : XMLNode(doc) {}
+
+XMLUnknown::~XMLUnknown() {}
+
+char *XMLUnknown::ParseDeep(char *p, StrPair *, int *curLineNumPtr) {
+    // Unknown parses as text.
+    p = _value.ParseText(p, ">", StrPair::NEEDS_NEWLINE_NORMALIZATION, curLineNumPtr);
+    if(!p) {
+        _document->SetError(XML_ERROR_PARSING_UNKNOWN, _parseLineNum, 0);
+    }
+    return p;
+}
+
+XMLNode *XMLUnknown::ShallowClone(XMLDocument *doc) const {
+    if(!doc) {
+        doc = _document;
+    }
+    XMLUnknown *text = doc->NewUnknown(Value());  // fixme: this will always allocate memory. Intern?
+    return text;
+}
+
+bool XMLUnknown::ShallowEqual(const XMLNode *compare) const {
+    TIXMLASSERT(compare);
+    const XMLUnknown *unknown = compare->ToUnknown();
+    return (unknown && XMLUtil::StringEqual(unknown->Value(), Value()));
+}
+
+bool XMLUnknown::Accept(XMLVisitor *visitor) const {
+    TIXMLASSERT(visitor);
+    return visitor->Visit(*this);
+}
+
+// --------- XMLAttribute ---------- //
+
+const char *XMLAttribute::Name() const {
+    return _name.GetStr();
+}
+
+const char *XMLAttribute::Value() const {
+    return _value.GetStr();
+}
+
+char *XMLAttribute::ParseDeep(char *p, bool processEntities, int *curLineNumPtr) {
+    // Parse using the name rules: bug fix, was using ParseText before
+    p = _name.ParseName(p);
+    if(!p || !*p) {
+        return 0;
+    }
+
+    // Skip white space before =
+    p = XMLUtil::SkipWhiteSpace(p, curLineNumPtr);
+    if(*p != '=') {
+        return 0;
+    }
+
+    ++p;  // move up to opening quote
+    p = XMLUtil::SkipWhiteSpace(p, curLineNumPtr);
+    if(*p != '\"' && *p != '\'') {
+        return 0;
+    }
+
+    const char endTag[2] = { *p, 0 };
+    ++p;  // move past opening quote
+
+    p = _value.ParseText(p, endTag, processEntities ? StrPair::ATTRIBUTE_VALUE : StrPair::ATTRIBUTE_VALUE_LEAVE_ENTITIES, curLineNumPtr);
+    return p;
+}
+
+void XMLAttribute::SetName(const char *n) {
+    _name.SetStr(n);
+}
+
+XMLError XMLAttribute::QueryIntValue(int *value) const {
+    if(XMLUtil::ToInt(Value(), value)) {
+        return XML_SUCCESS;
+    }
+    return XML_WRONG_ATTRIBUTE_TYPE;
+}
+
+XMLError XMLAttribute::QueryUnsignedValue(unsigned int *value) const {
+    if(XMLUtil::ToUnsigned(Value(), value)) {
+        return XML_SUCCESS;
+    }
+    return XML_WRONG_ATTRIBUTE_TYPE;
+}
+
+XMLError XMLAttribute::QueryInt64Value(int64_t *value) const {
+    if(XMLUtil::ToInt64(Value(), value)) {
+        return XML_SUCCESS;
+    }
+    return XML_WRONG_ATTRIBUTE_TYPE;
+}
+
+XMLError XMLAttribute::QueryUnsigned64Value(uint64_t *value) const {
+    if(XMLUtil::ToUnsigned64(Value(), value)) {
+        return XML_SUCCESS;
+    }
+    return XML_WRONG_ATTRIBUTE_TYPE;
+}
+
+XMLError XMLAttribute::QueryBoolValue(bool *value) const {
+    if(XMLUtil::ToBool(Value(), value)) {
+        return XML_SUCCESS;
+    }
+    return XML_WRONG_ATTRIBUTE_TYPE;
+}
+
+XMLError XMLAttribute::QueryFloatValue(float *value) const {
+    if(XMLUtil::ToFloat(Value(), value)) {
+        return XML_SUCCESS;
+    }
+    return XML_WRONG_ATTRIBUTE_TYPE;
+}
+
+XMLError XMLAttribute::QueryDoubleValue(double *value) const {
+    if(XMLUtil::ToDouble(Value(), value)) {
+        return XML_SUCCESS;
+    }
+    return XML_WRONG_ATTRIBUTE_TYPE;
+}
+
+void XMLAttribute::SetAttribute(const char *v) {
+    _value.SetStr(v);
+}
+
+void XMLAttribute::SetAttribute(int v) {
+    char buf[BUF_SIZE];
+    XMLUtil::ToStr(v, buf, BUF_SIZE);
+    _value.SetStr(buf);
+}
+
+void XMLAttribute::SetAttribute(unsigned v) {
+    char buf[BUF_SIZE];
+    XMLUtil::ToStr(v, buf, BUF_SIZE);
+    _value.SetStr(buf);
+}
+
+void XMLAttribute::SetAttribute(int64_t v) {
+    char buf[BUF_SIZE];
+    XMLUtil::ToStr(v, buf, BUF_SIZE);
+    _value.SetStr(buf);
+}
+
+void XMLAttribute::SetAttribute(uint64_t v) {
+    char buf[BUF_SIZE];
+    XMLUtil::ToStr(v, buf, BUF_SIZE);
+    _value.SetStr(buf);
+}
+
+void XMLAttribute::SetAttribute(bool v) {
+    char buf[BUF_SIZE];
+    XMLUtil::ToStr(v, buf, BUF_SIZE);
+    _value.SetStr(buf);
+}
+
+void XMLAttribute::SetAttribute(double v) {
+    char buf[BUF_SIZE];
+    XMLUtil::ToStr(v, buf, BUF_SIZE);
+    _value.SetStr(buf);
+}
+
+void XMLAttribute::SetAttribute(float v) {
+    char buf[BUF_SIZE];
+    XMLUtil::ToStr(v, buf, BUF_SIZE);
+    _value.SetStr(buf);
+}
+
+// --------- XMLElement ---------- //
+XMLElement::XMLElement(XMLDocument *doc) : XMLNode(doc), _closingType(OPEN), _rootAttribute(0) {}
+
+XMLElement::~XMLElement() {
+    while(_rootAttribute) {
+        XMLAttribute *next = _rootAttribute->_next;
+        DeleteAttribute(_rootAttribute);
+        _rootAttribute = next;
+    }
+}
+
+const XMLAttribute *XMLElement::FindAttribute(const char *name) const {
+    for(XMLAttribute *a = _rootAttribute; a; a = a->_next) {
+        if(XMLUtil::StringEqual(a->Name(), name)) {
+            return a;
+        }
+    }
+    return 0;
+}
+
+const char *XMLElement::Attribute(const char *name, const char *value) const {
+    const XMLAttribute *a = FindAttribute(name);
+    if(!a) {
+        return 0;
+    }
+    if(!value || XMLUtil::StringEqual(a->Value(), value)) {
+        return a->Value();
+    }
+    return 0;
+}
+
+int XMLElement::IntAttribute(const char *name, int defaultValue) const {
+    int i = defaultValue;
+    QueryIntAttribute(name, &i);
+    return i;
+}
+
+unsigned XMLElement::UnsignedAttribute(const char *name, unsigned defaultValue) const {
+    unsigned i = defaultValue;
+    QueryUnsignedAttribute(name, &i);
+    return i;
+}
+
+int64_t XMLElement::Int64Attribute(const char *name, int64_t defaultValue) const {
+    int64_t i = defaultValue;
+    QueryInt64Attribute(name, &i);
+    return i;
+}
+
+uint64_t XMLElement::Unsigned64Attribute(const char *name, uint64_t defaultValue) const {
+    uint64_t i = defaultValue;
+    QueryUnsigned64Attribute(name, &i);
+    return i;
+}
+
+bool XMLElement::BoolAttribute(const char *name, bool defaultValue) const {
+    bool b = defaultValue;
+    QueryBoolAttribute(name, &b);
+    return b;
+}
+
+double XMLElement::DoubleAttribute(const char *name, double defaultValue) const {
+    double d = defaultValue;
+    QueryDoubleAttribute(name, &d);
+    return d;
+}
+
+float XMLElement::FloatAttribute(const char *name, float defaultValue) const {
+    float f = defaultValue;
+    QueryFloatAttribute(name, &f);
+    return f;
+}
+
+const char *XMLElement::GetText() const {
+    if(FirstChild() && FirstChild()->ToText()) {
+        return FirstChild()->Value();
+    }
+    return 0;
+}
+
+void XMLElement::SetText(const char *inText) {
+    if(FirstChild() && FirstChild()->ToText())
+        FirstChild()->SetValue(inText);
+    else {
+        XMLText *theText = GetDocument()->NewText(inText);
+        InsertFirstChild(theText);
+    }
+}
+
+void XMLElement::SetText(int v) {
+    char buf[BUF_SIZE];
+    XMLUtil::ToStr(v, buf, BUF_SIZE);
+    SetText(buf);
+}
+
+void XMLElement::SetText(unsigned v) {
+    char buf[BUF_SIZE];
+    XMLUtil::ToStr(v, buf, BUF_SIZE);
+    SetText(buf);
+}
+
+void XMLElement::SetText(int64_t v) {
+    char buf[BUF_SIZE];
+    XMLUtil::ToStr(v, buf, BUF_SIZE);
+    SetText(buf);
+}
+
+void XMLElement::SetText(uint64_t v) {
+    char buf[BUF_SIZE];
+    XMLUtil::ToStr(v, buf, BUF_SIZE);
+    SetText(buf);
+}
+
+void XMLElement::SetText(bool v) {
+    char buf[BUF_SIZE];
+    XMLUtil::ToStr(v, buf, BUF_SIZE);
+    SetText(buf);
+}
+
+void XMLElement::SetText(float v) {
+    char buf[BUF_SIZE];
+    XMLUtil::ToStr(v, buf, BUF_SIZE);
+    SetText(buf);
+}
+
+void XMLElement::SetText(double v) {
+    char buf[BUF_SIZE];
+    XMLUtil::ToStr(v, buf, BUF_SIZE);
+    SetText(buf);
+}
+
+XMLError XMLElement::QueryIntText(int *ival) const {
+    if(FirstChild() && FirstChild()->ToText()) {
+        const char *t = FirstChild()->Value();
+        if(XMLUtil::ToInt(t, ival)) {
+            return XML_SUCCESS;
+        }
+        return XML_CAN_NOT_CONVERT_TEXT;
+    }
+    return XML_NO_TEXT_NODE;
+}
+
+XMLError XMLElement::QueryUnsignedText(unsigned *uval) const {
+    if(FirstChild() && FirstChild()->ToText()) {
+        const char *t = FirstChild()->Value();
+        if(XMLUtil::ToUnsigned(t, uval)) {
+            return XML_SUCCESS;
+        }
+        return XML_CAN_NOT_CONVERT_TEXT;
+    }
+    return XML_NO_TEXT_NODE;
+}
+
+XMLError XMLElement::QueryInt64Text(int64_t *ival) const {
+    if(FirstChild() && FirstChild()->ToText()) {
+        const char *t = FirstChild()->Value();
+        if(XMLUtil::ToInt64(t, ival)) {
+            return XML_SUCCESS;
+        }
+        return XML_CAN_NOT_CONVERT_TEXT;
+    }
+    return XML_NO_TEXT_NODE;
+}
+
+XMLError XMLElement::QueryUnsigned64Text(uint64_t *ival) const {
+    if(FirstChild() && FirstChild()->ToText()) {
+        const char *t = FirstChild()->Value();
+        if(XMLUtil::ToUnsigned64(t, ival)) {
+            return XML_SUCCESS;
+        }
+        return XML_CAN_NOT_CONVERT_TEXT;
+    }
+    return XML_NO_TEXT_NODE;
+}
+
+XMLError XMLElement::QueryBoolText(bool *bval) const {
+    if(FirstChild() && FirstChild()->ToText()) {
+        const char *t = FirstChild()->Value();
+        if(XMLUtil::ToBool(t, bval)) {
+            return XML_SUCCESS;
+        }
+        return XML_CAN_NOT_CONVERT_TEXT;
+    }
+    return XML_NO_TEXT_NODE;
+}
+
+XMLError XMLElement::QueryDoubleText(double *dval) const {
+    if(FirstChild() && FirstChild()->ToText()) {
+        const char *t = FirstChild()->Value();
+        if(XMLUtil::ToDouble(t, dval)) {
+            return XML_SUCCESS;
+        }
+        return XML_CAN_NOT_CONVERT_TEXT;
+    }
+    return XML_NO_TEXT_NODE;
+}
+
+XMLError XMLElement::QueryFloatText(float *fval) const {
+    if(FirstChild() && FirstChild()->ToText()) {
+        const char *t = FirstChild()->Value();
+        if(XMLUtil::ToFloat(t, fval)) {
+            return XML_SUCCESS;
+        }
+        return XML_CAN_NOT_CONVERT_TEXT;
+    }
+    return XML_NO_TEXT_NODE;
+}
+
+int XMLElement::IntText(int defaultValue) const {
+    int i = defaultValue;
+    QueryIntText(&i);
+    return i;
+}
+
+unsigned XMLElement::UnsignedText(unsigned defaultValue) const {
+    unsigned i = defaultValue;
+    QueryUnsignedText(&i);
+    return i;
+}
+
+int64_t XMLElement::Int64Text(int64_t defaultValue) const {
+    int64_t i = defaultValue;
+    QueryInt64Text(&i);
+    return i;
+}
+
+uint64_t XMLElement::Unsigned64Text(uint64_t defaultValue) const {
+    uint64_t i = defaultValue;
+    QueryUnsigned64Text(&i);
+    return i;
+}
+
+bool XMLElement::BoolText(bool defaultValue) const {
+    bool b = defaultValue;
+    QueryBoolText(&b);
+    return b;
+}
+
+double XMLElement::DoubleText(double defaultValue) const {
+    double d = defaultValue;
+    QueryDoubleText(&d);
+    return d;
+}
+
+float XMLElement::FloatText(float defaultValue) const {
+    float f = defaultValue;
+    QueryFloatText(&f);
+    return f;
+}
+
+XMLAttribute *XMLElement::FindOrCreateAttribute(const char *name) {
+    XMLAttribute *last   = 0;
+    XMLAttribute *attrib = 0;
+    for(attrib = _rootAttribute; attrib; last = attrib, attrib = attrib->_next) {
+        if(XMLUtil::StringEqual(attrib->Name(), name)) {
+            break;
+        }
+    }
+    if(!attrib) {
+        attrib = CreateAttribute();
+        TIXMLASSERT(attrib);
+        if(last) {
+            TIXMLASSERT(last->_next == 0);
+            last->_next = attrib;
+        }
+        else {
+            TIXMLASSERT(_rootAttribute == 0);
+            _rootAttribute = attrib;
+        }
+        attrib->SetName(name);
+    }
+    return attrib;
+}
+
+void XMLElement::DeleteAttribute(const char *name) {
+    XMLAttribute *prev = 0;
+    for(XMLAttribute *a = _rootAttribute; a; a = a->_next) {
+        if(XMLUtil::StringEqual(name, a->Name())) {
+            if(prev) {
+                prev->_next = a->_next;
+            }
+            else {
+                _rootAttribute = a->_next;
+            }
+            DeleteAttribute(a);
+            break;
+        }
+        prev = a;
+    }
+}
+
+char *XMLElement::ParseAttributes(char *p, int *curLineNumPtr) {
+    XMLAttribute *prevAttribute = 0;
+
+    // Read the attributes.
+    while(p) {
+        p = XMLUtil::SkipWhiteSpace(p, curLineNumPtr);
+        if(!(*p)) {
+            _document->SetError(XML_ERROR_PARSING_ELEMENT, _parseLineNum, "XMLElement name=%s", Name());
+            return 0;
+        }
+
+        // attribute.
+        if(XMLUtil::IsNameStartChar(*p)) {
+            XMLAttribute *attrib = CreateAttribute();
+            TIXMLASSERT(attrib);
+            attrib->_parseLineNum = _document->_parseCurLineNum;
+
+            const int attrLineNum = attrib->_parseLineNum;
+
+            p = attrib->ParseDeep(p, _document->ProcessEntities(), curLineNumPtr);
+            if(!p || Attribute(attrib->Name())) {
+                DeleteAttribute(attrib);
+                _document->SetError(XML_ERROR_PARSING_ATTRIBUTE, attrLineNum, "XMLElement name=%s", Name());
+                return 0;
+            }
+            // There is a minor bug here: if the attribute in the source xml
+            // document is duplicated, it will not be detected and the
+            // attribute will be doubly added. However, tracking the 'prevAttribute'
+            // avoids re-scanning the attribute list. Preferring performance for
+            // now, may reconsider in the future.
+            if(prevAttribute) {
+                TIXMLASSERT(prevAttribute->_next == 0);
+                prevAttribute->_next = attrib;
+            }
+            else {
+                TIXMLASSERT(_rootAttribute == 0);
+                _rootAttribute = attrib;
+            }
+            prevAttribute = attrib;
+        }
+        // end of the tag
+        else if(*p == '>') {
+            ++p;
+            break;
+        }
+        // end of the tag
+        else if(*p == '/' && *(p + 1) == '>') {
+            _closingType = CLOSED;
+            return p + 2;  // done; sealed element.
+        }
+        else {
+            _document->SetError(XML_ERROR_PARSING_ELEMENT, _parseLineNum, 0);
+            return 0;
+        }
+    }
+    return p;
+}
+
+void XMLElement::DeleteAttribute(XMLAttribute *attribute) {
+    if(attribute == 0) {
+        return;
+    }
+    MemPool *pool = attribute->_memPool;
+    attribute->~XMLAttribute();
+    pool->Free(attribute);
+}
+
+XMLAttribute *XMLElement::CreateAttribute() {
+    TIXMLASSERT(sizeof(XMLAttribute) == _document->_attributePool.ItemSize());
+    XMLAttribute *attrib = new(_document->_attributePool.Alloc()) XMLAttribute();
+    TIXMLASSERT(attrib);
+    attrib->_memPool = &_document->_attributePool;
+    attrib->_memPool->SetTracked();
+    return attrib;
+}
+
+//
+//	<ele></ele>
+//	<ele>foo<b>bar</b></ele>
+//
+char *XMLElement::ParseDeep(char *p, StrPair *parentEndTag, int *curLineNumPtr) {
+    // Read the element name.
+    p = XMLUtil::SkipWhiteSpace(p, curLineNumPtr);
+
+    // The closing element is the </element> form. It is
+    // parsed just like a regular element then deleted from
+    // the DOM.
+    if(*p == '/') {
+        _closingType = CLOSING;
+        ++p;
+    }
+
+    p = _value.ParseName(p);
+    if(_value.Empty()) {
+        return 0;
+    }
+
+    p = ParseAttributes(p, curLineNumPtr);
+    if(!p || !*p || _closingType != OPEN) {
+        return p;
+    }
+
+    p = XMLNode::ParseDeep(p, parentEndTag, curLineNumPtr);
+    return p;
+}
+
+XMLNode *XMLElement::ShallowClone(XMLDocument *doc) const {
+    if(!doc) {
+        doc = _document;
+    }
+    XMLElement *element = doc->NewElement(Value());  // fixme: this will always allocate memory. Intern?
+    for(const XMLAttribute *a = FirstAttribute(); a; a = a->Next()) {
+        element->SetAttribute(a->Name(), a->Value());  // fixme: this will always allocate memory. Intern?
+    }
+    return element;
+}
+
+bool XMLElement::ShallowEqual(const XMLNode *compare) const {
+    TIXMLASSERT(compare);
+    const XMLElement *other = compare->ToElement();
+    if(other && XMLUtil::StringEqual(other->Name(), Name())) {
+
+        const XMLAttribute *a = FirstAttribute();
+        const XMLAttribute *b = other->FirstAttribute();
+
+        while(a && b) {
+            if(!XMLUtil::StringEqual(a->Value(), b->Value())) {
+                return false;
+            }
+            a = a->Next();
+            b = b->Next();
+        }
+        if(a || b) {
+            // different count
+            return false;
+        }
+        return true;
+    }
+    return false;
+}
+
+bool XMLElement::Accept(XMLVisitor *visitor) const {
+    TIXMLASSERT(visitor);
+    if(visitor->VisitEnter(*this, _rootAttribute)) {
+        for(const XMLNode *node = FirstChild(); node; node = node->NextSibling()) {
+            if(!node->Accept(visitor)) {
+                break;
+            }
+        }
+    }
+    return visitor->VisitExit(*this);
+}
+
+// --------- XMLDocument ----------- //
+
+// Warning: List must match 'enum XMLError'
+const char *XMLDocument::_errorNames[XML_ERROR_COUNT] = { "XML_SUCCESS",
+                                                          "XML_NO_ATTRIBUTE",
+                                                          "XML_WRONG_ATTRIBUTE_TYPE",
+                                                          "XML_ERROR_FILE_NOT_FOUND",
+                                                          "XML_ERROR_FILE_COULD_NOT_BE_OPENED",
+                                                          "XML_ERROR_FILE_READ_ERROR",
+                                                          "XML_ERROR_PARSING_ELEMENT",
+                                                          "XML_ERROR_PARSING_ATTRIBUTE",
+                                                          "XML_ERROR_PARSING_TEXT",
+                                                          "XML_ERROR_PARSING_CDATA",
+                                                          "XML_ERROR_PARSING_COMMENT",
+                                                          "XML_ERROR_PARSING_DECLARATION",
+                                                          "XML_ERROR_PARSING_UNKNOWN",
+                                                          "XML_ERROR_EMPTY_DOCUMENT",
+                                                          "XML_ERROR_MISMATCHED_ELEMENT",
+                                                          "XML_ERROR_PARSING",
+                                                          "XML_CAN_NOT_CONVERT_TEXT",
+                                                          "XML_NO_TEXT_NODE",
+                                                          "XML_ELEMENT_DEPTH_EXCEEDED" };
+
+XMLDocument::XMLDocument(bool processEntities, Whitespace whitespaceMode)
+    : XMLNode(0),
+      _writeBOM(false),
+      _processEntities(processEntities),
+      _errorID(XML_SUCCESS),
+      _whitespaceMode(whitespaceMode),
+      _errorStr(),
+      _errorLineNum(0),
+      _charBuffer(0),
+      _parseCurLineNum(0),
+      _parsingDepth(0),
+      _unlinked(),
+      _elementPool(),
+      _attributePool(),
+      _textPool(),
+      _commentPool() {
+    // avoid VC++ C4355 warning about 'this' in initializer list (C4355 is off by default in VS2012+)
+    _document = this;
+}
+
+XMLDocument::~XMLDocument() {
+    Clear();
+}
+
+void XMLDocument::MarkInUse(XMLNode *node) {
+    TIXMLASSERT(node);
+    TIXMLASSERT(node->_parent == 0);
+
+    for(int i = 0; i < _unlinked.Size(); ++i) {
+        if(node == _unlinked[i]) {
+            _unlinked.SwapRemove(i);
+            break;
+        }
+    }
+}
+
+void XMLDocument::Clear() {
+    DeleteChildren();
+    while(_unlinked.Size()) {
+        DeleteNode(_unlinked[0]);  // Will remove from _unlinked as part of delete.
+    }
+
+#ifdef TINYXML2_DEBUG
+    const bool hadError = Error();
+#endif
+    ClearError();
+
+    delete[] _charBuffer;
+    _charBuffer   = 0;
+    _parsingDepth = 0;
+
+#if 0
+    _textPool.Trace( "text" );
+    _elementPool.Trace( "element" );
+    _commentPool.Trace( "comment" );
+    _attributePool.Trace( "attribute" );
+#endif
+
+#ifdef TINYXML2_DEBUG
+    if(!hadError) {
+        TIXMLASSERT(_elementPool.CurrentAllocs() == _elementPool.Untracked());
+        TIXMLASSERT(_attributePool.CurrentAllocs() == _attributePool.Untracked());
+        TIXMLASSERT(_textPool.CurrentAllocs() == _textPool.Untracked());
+        TIXMLASSERT(_commentPool.CurrentAllocs() == _commentPool.Untracked());
+    }
+#endif
+}
+
+void XMLDocument::DeepCopy(XMLDocument *target) const {
+    TIXMLASSERT(target);
+    if(target == this) {
+        return;  // technically success - a no-op.
+    }
+
+    target->Clear();
+    for(const XMLNode *node = this->FirstChild(); node; node = node->NextSibling()) {
+        target->InsertEndChild(node->DeepClone(target));
+    }
+}
+
+XMLElement *XMLDocument::NewElement(const char *name) {
+    XMLElement *ele = CreateUnlinkedNode<XMLElement>(_elementPool);
+    ele->SetName(name);
+    return ele;
+}
+
+XMLComment *XMLDocument::NewComment(const char *str) {
+    XMLComment *comment = CreateUnlinkedNode<XMLComment>(_commentPool);
+    comment->SetValue(str);
+    return comment;
+}
+
+XMLText *XMLDocument::NewText(const char *str) {
+    XMLText *text = CreateUnlinkedNode<XMLText>(_textPool);
+    text->SetValue(str);
+    return text;
+}
+
+XMLDeclaration *XMLDocument::NewDeclaration(const char *str) {
+    XMLDeclaration *dec = CreateUnlinkedNode<XMLDeclaration>(_commentPool);
+    dec->SetValue(str ? str : "xml version=\"1.0\" encoding=\"UTF-8\"");
+    return dec;
+}
+
+XMLUnknown *XMLDocument::NewUnknown(const char *str) {
+    XMLUnknown *unk = CreateUnlinkedNode<XMLUnknown>(_commentPool);
+    unk->SetValue(str);
+    return unk;
+}
+
+FILE *callfopen(const char *filepath, const char *mode) {
+    TIXMLASSERT(filepath);
+    TIXMLASSERT(mode);
+#if defined(_MSC_VER) && (_MSC_VER >= 1400) && (!defined WINCE)
+    FILE         *fp  = 0;
+    const errno_t err = fopen_s(&fp, filepath, mode);
+    if(err) {
+        return 0;
+    }
+#else
+    FILE *fp = fopen(filepath, mode);
+#endif
+    return fp;
+}
+/**
+ * support chinese!
+ */
+#if defined(_WIN32)
+static FILE *callfopen(const wchar_t *filepath, const wchar_t *mode) {
+    TIXMLASSERT(filepath);
+    TIXMLASSERT(mode);
+    FILE *fp = _wfopen(filepath, mode);
+    return fp;
+}
+#endif
+
+void XMLDocument::DeleteNode(XMLNode *node) {
+    TIXMLASSERT(node);
+    TIXMLASSERT(node->_document == this);
+    if(node->_parent) {
+        node->_parent->DeleteChild(node);
+    }
+    else {
+        // Isn't in the tree.
+        // Use the parent delete.
+        // Also, we need to mark it tracked: we 'know'
+        // it was never used.
+        node->_memPool->SetTracked();
+        // Call the static XMLNode version:
+        XMLNode::DeleteNode(node);
+    }
+}
+#if defined(_WIN32)
+XMLError XMLDocument::LoadFile(const wchar_t *filename) {
+    if(!filename) {
+        TIXMLASSERT(false);
+        SetError(XML_ERROR_FILE_COULD_NOT_BE_OPENED, 0, "filename=<null>");
+        return _errorID;
+    }
+    Clear();
+    FILE *fp = callfopen(filename, L"rb");
+    if(!fp) {
+        SetError(XML_ERROR_FILE_NOT_FOUND, 0, "filename=%s", filename);
+        return _errorID;
+    }
+    LoadFile(fp);
+    fclose(fp);
+    return _errorID;
+}
+#endif
+XMLError XMLDocument::LoadFile(const char *filename) {
+    if(!filename) {
+        TIXMLASSERT(false);
+        SetError(XML_ERROR_FILE_COULD_NOT_BE_OPENED, 0, "filename=<null>");
+        return _errorID;
+    }
+
+    Clear();
+    FILE *fp = callfopen(filename, "rb");
+    if(!fp) {
+        SetError(XML_ERROR_FILE_NOT_FOUND, 0, "filename=%s", filename);
+        return _errorID;
+    }
+    LoadFile(fp);
+    fclose(fp);
+    return _errorID;
+}
+
+// This is likely overengineered template art to have a check that unsigned long value incremented
+// by one still fits into size_t. If size_t type is larger than unsigned long type
+// (x86_64-w64-mingw32 target) then the check is redundant and gcc and clang emit
+// -Wtype-limits warning. This piece makes the compiler select code with a check when a check
+// is useful and code with no check when a check is redundant depending on how size_t and unsigned long
+// types sizes relate to each other.
+template <bool = (sizeof(unsigned long) >= sizeof(size_t))> struct LongFitsIntoSizeTMinusOne {
+    static bool Fits(unsigned long value) {
+        return value < static_cast<size_t>(-1);
+    }
+};
+
+template <> struct LongFitsIntoSizeTMinusOne<false> {
+    static bool Fits(unsigned long) {
+        return true;
+    }
+};
+
+XMLError XMLDocument::LoadFile(FILE *fp) {
+    Clear();
+
+    fseek(fp, 0, SEEK_SET);
+    if(fgetc(fp) == EOF && ferror(fp) != 0) {
+        SetError(XML_ERROR_FILE_READ_ERROR, 0, 0);
+        return _errorID;
+    }
+
+    fseek(fp, 0, SEEK_END);
+    const long filelength = ftell(fp);
+    fseek(fp, 0, SEEK_SET);
+    if(filelength == -1L) {
+        SetError(XML_ERROR_FILE_READ_ERROR, 0, 0);
+        return _errorID;
+    }
+    TIXMLASSERT(filelength >= 0);
+
+    if(!LongFitsIntoSizeTMinusOne<>::Fits(filelength)) {
+        // Cannot handle files which won't fit in buffer together with null terminator
+        SetError(XML_ERROR_FILE_READ_ERROR, 0, 0);
+        return _errorID;
+    }
+
+    if(filelength == 0) {
+        SetError(XML_ERROR_EMPTY_DOCUMENT, 0, 0);
+        return _errorID;
+    }
+
+    const size_t size = filelength;
+    TIXMLASSERT(_charBuffer == 0);
+    _charBuffer       = new char[size + 1];
+    const size_t read = fread(_charBuffer, 1, size, fp);
+    if(read != size) {
+        SetError(XML_ERROR_FILE_READ_ERROR, 0, 0);
+        return _errorID;
+    }
+
+    _charBuffer[size] = 0;
+
+    Parse();
+    return _errorID;
+}
+
+XMLError XMLDocument::LoadFromByteBuffer(uint8_t *buffer, uint32_t size) {
+    Clear();
+    _charBuffer = new char[size + 1];
+    memcpy(_charBuffer, buffer, size);
+    _charBuffer[size] = 0;
+    Parse();
+    return _errorID;
+}
+
+#if defined(_WIN32)
+XMLError XMLDocument::SaveFile(const wchar_t *filename, bool compact) {
+    if(!filename) {
+        TIXMLASSERT(false);
+        SetError(XML_ERROR_FILE_COULD_NOT_BE_OPENED, 0, "filename=<null>");
+        return _errorID;
+    }
+
+    FILE *fp = callfopen(filename, L"w");
+    if(!fp) {
+        SetError(XML_ERROR_FILE_COULD_NOT_BE_OPENED, 0, "filename=%s", filename);
+        return _errorID;
+    }
+    SaveFile(fp, compact);
+    fclose(fp);
+    return _errorID;
+}
+#endif
+XMLError XMLDocument::SaveFile(const char *filename, bool compact) {
+    if(!filename) {
+        TIXMLASSERT(false);
+        SetError(XML_ERROR_FILE_COULD_NOT_BE_OPENED, 0, "filename=<null>");
+        return _errorID;
+    }
+
+    FILE *fp = callfopen(filename, "w");
+    if(!fp) {
+        SetError(XML_ERROR_FILE_COULD_NOT_BE_OPENED, 0, "filename=%s", filename);
+        return _errorID;
+    }
+    SaveFile(fp, compact);
+    fclose(fp);
+    return _errorID;
+}
+
+XMLError XMLDocument::SaveFile(FILE *fp, bool compact) {
+    // Clear any error from the last save, otherwise it will get reported
+    // for *this* call.
+    ClearError();
+    XMLPrinter stream(fp, compact);
+    Print(&stream);
+    return _errorID;
+}
+
+XMLError XMLDocument::Parse(const char *p, size_t len) {
+    Clear();
+
+    if(len == 0 || !p || !*p) {
+        SetError(XML_ERROR_EMPTY_DOCUMENT, 0, 0);
+        return _errorID;
+    }
+    if(len == static_cast<size_t>(-1)) {
+        len = strlen(p);
+    }
+    TIXMLASSERT(_charBuffer == 0);
+    _charBuffer = new char[len + 1];
+    memcpy(_charBuffer, p, len);
+    _charBuffer[len] = 0;
+
+    Parse();
+    if(Error()) {
+        // clean up now essentially dangling memory.
+        // and the parse fail can put objects in the
+        // pools that are dead and inaccessible.
+        DeleteChildren();
+        _elementPool.Clear();
+        _attributePool.Clear();
+        _textPool.Clear();
+        _commentPool.Clear();
+    }
+    return _errorID;
+}
+
+void XMLDocument::Print(XMLPrinter *streamer) const {
+    if(streamer) {
+        Accept(streamer);
+    }
+    else {
+        XMLPrinter stdoutStreamer(stdout);
+        Accept(&stdoutStreamer);
+    }
+}
+
+void XMLDocument::SetError(XMLError error, int lineNum, const char *format, ...) {
+    TIXMLASSERT(error >= 0 && error < XML_ERROR_COUNT);
+    _errorID      = error;
+    _errorLineNum = lineNum;
+    _errorStr.Reset();
+
+    const size_t BUFFER_SIZE = 1000;
+    char        *buffer      = new char[BUFFER_SIZE];
+
+    TIXMLASSERT(sizeof(error) <= sizeof(int));
+    TIXML_SNPRINTF(buffer, BUFFER_SIZE, "Error=%s ErrorID=%d (0x%x) Line number=%d", ErrorIDToName(error), int(error), int(error), lineNum);
+
+    if(format) {
+        size_t len = strlen(buffer);
+        TIXML_SNPRINTF(buffer + len, BUFFER_SIZE - len, ": ");
+        len = strlen(buffer);
+
+        va_list va;
+        va_start(va, format);
+        TIXML_VSNPRINTF(buffer + len, BUFFER_SIZE - len, format, va);
+        va_end(va);
+    }
+    _errorStr.SetStr(buffer);
+    delete[] buffer;
+}
+
+/*static*/ const char *XMLDocument::ErrorIDToName(XMLError errorID) {
+    TIXMLASSERT(errorID >= 0 && errorID < XML_ERROR_COUNT);
+    const char *errorName = _errorNames[errorID];
+    TIXMLASSERT(errorName && errorName[0]);
+    return errorName;
+}
+
+const char *XMLDocument::ErrorStr() const {
+    return _errorStr.Empty() ? "" : _errorStr.GetStr();
+}
+
+void XMLDocument::PrintError() const {
+    printf("%s\n", ErrorStr());
+}
+
+const char *XMLDocument::ErrorName() const {
+    return ErrorIDToName(_errorID);
+}
+
+void XMLDocument::Parse() {
+    TIXMLASSERT(NoChildren());  // Clear() must have been called previously
+    TIXMLASSERT(_charBuffer);
+    _parseCurLineNum = 1;
+    _parseLineNum    = 1;
+    char *p          = _charBuffer;
+    p                = XMLUtil::SkipWhiteSpace(p, &_parseCurLineNum);
+    p                = const_cast<char *>(XMLUtil::ReadBOM(p, &_writeBOM));
+    if(!*p) {
+        SetError(XML_ERROR_EMPTY_DOCUMENT, 0, 0);
+        return;
+    }
+    ParseDeep(p, 0, &_parseCurLineNum);
+}
+
+void XMLDocument::PushDepth() {
+    _parsingDepth++;
+    if(_parsingDepth == TINYXML2_MAX_ELEMENT_DEPTH) {
+        SetError(XML_ELEMENT_DEPTH_EXCEEDED, _parseCurLineNum, "Element nesting is too deep.");
+    }
+}
+
+void XMLDocument::PopDepth() {
+    TIXMLASSERT(_parsingDepth > 0);
+    --_parsingDepth;
+}
+
+XMLPrinter::XMLPrinter(FILE *file, bool compact, int depth)
+    : _elementJustOpened(false),
+      _stack(),
+      _firstElement(true),
+      _fp(file),
+      _depth(depth),
+      _textDepth(-1),
+      _processEntities(true),
+      _compactMode(compact),
+      _buffer() {
+    for(int i = 0; i < ENTITY_RANGE; ++i) {
+        _entityFlag[i]           = false;
+        _restrictedEntityFlag[i] = false;
+    }
+    for(int i = 0; i < NUM_ENTITIES; ++i) {
+        const char          entityValue = entities[i].value;
+        const unsigned char flagIndex   = static_cast<unsigned char>(entityValue);
+        TIXMLASSERT(flagIndex < ENTITY_RANGE);
+        _entityFlag[flagIndex] = true;
+    }
+    _restrictedEntityFlag[static_cast<unsigned char>('&')] = true;
+    _restrictedEntityFlag[static_cast<unsigned char>('<')] = true;
+    _restrictedEntityFlag[static_cast<unsigned char>('>')] = true;  // not required, but consistency is nice
+    _buffer.Push(0);
+}
+
+void XMLPrinter::Print(const char *format, ...) {
+    va_list va;
+    va_start(va, format);
+
+    if(_fp) {
+        vfprintf(_fp, format, va);
+    }
+    else {
+        const int len = TIXML_VSCPRINTF(format, va);
+        // Close out and re-start the va-args
+        va_end(va);
+        TIXMLASSERT(len >= 0);
+        va_start(va, format);
+        TIXMLASSERT(_buffer.Size() > 0 && _buffer[_buffer.Size() - 1] == 0);
+        char *p = _buffer.PushArr(len) - 1;  // back up over the null terminator.
+        TIXML_VSNPRINTF(p, len + 1, format, va);
+    }
+    va_end(va);
+}
+
+void XMLPrinter::Write(const char *data, size_t size) {
+    if(_fp) {
+        fwrite(data, sizeof(char), size, _fp);
+    }
+    else {
+        char *p = _buffer.PushArr(static_cast<int>(size)) - 1;  // back up over the null terminator.
+        memcpy(p, data, size);
+        p[size] = 0;
+    }
+}
+
+void XMLPrinter::Putc(char ch) {
+    if(_fp) {
+        fputc(ch, _fp);
+    }
+    else {
+        char *p = _buffer.PushArr(sizeof(char)) - 1;  // back up over the null terminator.
+        p[0]    = ch;
+        p[1]    = 0;
+    }
+}
+
+void XMLPrinter::PrintSpace(int depth) {
+    for(int i = 0; i < depth; ++i) {
+        Write("    ");
+    }
+}
+
+void XMLPrinter::PrintString(const char *p, bool restricted) {
+    // Look for runs of bytes between entities to print.
+    const char *q = p;
+
+    if(_processEntities) {
+        const bool *flag = restricted ? _restrictedEntityFlag : _entityFlag;
+        while(*q) {
+            TIXMLASSERT(p <= q);
+            // Remember, char is sometimes signed. (How many times has that bitten me?)
+            if(*q > 0 && *q < ENTITY_RANGE) {
+                // Check for entities. If one is found, flush
+                // the stream up until the entity, write the
+                // entity, and keep looking.
+                if(flag[static_cast<unsigned char>(*q)]) {
+                    while(p < q) {
+                        const size_t delta   = q - p;
+                        const int    toPrint = (INT_MAX < delta) ? INT_MAX : static_cast<int>(delta);
+                        Write(p, toPrint);
+                        p += toPrint;
+                    }
+                    bool entityPatternPrinted = false;
+                    for(int i = 0; i < NUM_ENTITIES; ++i) {
+                        if(entities[i].value == *q) {
+                            Putc('&');
+                            Write(entities[i].pattern, entities[i].length);
+                            Putc(';');
+                            entityPatternPrinted = true;
+                            break;
+                        }
+                    }
+                    if(!entityPatternPrinted) {
+                        // TIXMLASSERT( entityPatternPrinted ) causes gcc -Wunused-but-set-variable in release
+                        TIXMLASSERT(false);
+                    }
+                    ++p;
+                }
+            }
+            ++q;
+            TIXMLASSERT(p <= q);
+        }
+        // Flush the remaining string. This will be the entire
+        // string if an entity wasn't found.
+        if(p < q) {
+            const size_t delta   = q - p;
+            const int    toPrint = (INT_MAX < delta) ? INT_MAX : static_cast<int>(delta);
+            Write(p, toPrint);
+        }
+    }
+    else {
+        Write(p);
+    }
+}
+
+void XMLPrinter::PushHeader(bool writeBOM, bool writeDec) {
+    if(writeBOM) {
+        static const unsigned char bom[] = { TIXML_UTF_LEAD_0, TIXML_UTF_LEAD_1, TIXML_UTF_LEAD_2, 0 };
+        Write(reinterpret_cast<const char *>(bom));
+    }
+    if(writeDec) {
+        PushDeclaration("xml version=\"1.0\"");
+    }
+}
+
+void XMLPrinter::OpenElement(const char *name, bool compactMode) {
+    SealElementIfJustOpened();
+    _stack.Push(name);
+
+    if(_textDepth < 0 && !_firstElement && !compactMode) {
+        Putc('\n');
+    }
+    if(!compactMode) {
+        PrintSpace(_depth);
+    }
+
+    Write("<");
+    Write(name);
+
+    _elementJustOpened = true;
+    _firstElement      = false;
+    ++_depth;
+}
+
+void XMLPrinter::PushAttribute(const char *name, const char *value) {
+    TIXMLASSERT(_elementJustOpened);
+    Putc(' ');
+    Write(name);
+    Write("=\"");
+    PrintString(value, false);
+    Putc('\"');
+}
+
+void XMLPrinter::PushAttribute(const char *name, int v) {
+    char buf[BUF_SIZE];
+    XMLUtil::ToStr(v, buf, BUF_SIZE);
+    PushAttribute(name, buf);
+}
+
+void XMLPrinter::PushAttribute(const char *name, unsigned v) {
+    char buf[BUF_SIZE];
+    XMLUtil::ToStr(v, buf, BUF_SIZE);
+    PushAttribute(name, buf);
+}
+
+void XMLPrinter::PushAttribute(const char *name, int64_t v) {
+    char buf[BUF_SIZE];
+    XMLUtil::ToStr(v, buf, BUF_SIZE);
+    PushAttribute(name, buf);
+}
+
+void XMLPrinter::PushAttribute(const char *name, uint64_t v) {
+    char buf[BUF_SIZE];
+    XMLUtil::ToStr(v, buf, BUF_SIZE);
+    PushAttribute(name, buf);
+}
+
+void XMLPrinter::PushAttribute(const char *name, bool v) {
+    char buf[BUF_SIZE];
+    XMLUtil::ToStr(v, buf, BUF_SIZE);
+    PushAttribute(name, buf);
+}
+
+void XMLPrinter::PushAttribute(const char *name, double v) {
+    char buf[BUF_SIZE];
+    XMLUtil::ToStr(v, buf, BUF_SIZE);
+    PushAttribute(name, buf);
+}
+
+void XMLPrinter::CloseElement(bool compactMode) {
+    --_depth;
+    const char *name = _stack.Pop();
+
+    if(_elementJustOpened) {
+        Write("/>");
+    }
+    else {
+        if(_textDepth < 0 && !compactMode) {
+            Putc('\n');
+            PrintSpace(_depth);
+        }
+        Write("</");
+        Write(name);
+        Write(">");
+    }
+
+    if(_textDepth == _depth) {
+        _textDepth = -1;
+    }
+    if(_depth == 0 && !compactMode) {
+        Putc('\n');
+    }
+    _elementJustOpened = false;
+}
+
+void XMLPrinter::SealElementIfJustOpened() {
+    if(!_elementJustOpened) {
+        return;
+    }
+    _elementJustOpened = false;
+    Putc('>');
+}
+
+void XMLPrinter::PushText(const char *text, bool cdata) {
+    _textDepth = _depth - 1;
+
+    SealElementIfJustOpened();
+    if(cdata) {
+        Write("<![CDATA[");
+        Write(text);
+        Write("]]>");
+    }
+    else {
+        PrintString(text, true);
+    }
+}
+
+void XMLPrinter::PushText(int64_t value) {
+    char buf[BUF_SIZE];
+    XMLUtil::ToStr(value, buf, BUF_SIZE);
+    PushText(buf, false);
+}
+
+void XMLPrinter::PushText(uint64_t value) {
+    char buf[BUF_SIZE];
+    XMLUtil::ToStr(value, buf, BUF_SIZE);
+    PushText(buf, false);
+}
+
+void XMLPrinter::PushText(int value) {
+    char buf[BUF_SIZE];
+    XMLUtil::ToStr(value, buf, BUF_SIZE);
+    PushText(buf, false);
+}
+
+void XMLPrinter::PushText(unsigned value) {
+    char buf[BUF_SIZE];
+    XMLUtil::ToStr(value, buf, BUF_SIZE);
+    PushText(buf, false);
+}
+
+void XMLPrinter::PushText(bool value) {
+    char buf[BUF_SIZE];
+    XMLUtil::ToStr(value, buf, BUF_SIZE);
+    PushText(buf, false);
+}
+
+void XMLPrinter::PushText(float value) {
+    char buf[BUF_SIZE];
+    XMLUtil::ToStr(value, buf, BUF_SIZE);
+    PushText(buf, false);
+}
+
+void XMLPrinter::PushText(double value) {
+    char buf[BUF_SIZE];
+    XMLUtil::ToStr(value, buf, BUF_SIZE);
+    PushText(buf, false);
+}
+
+void XMLPrinter::PushComment(const char *comment) {
+    SealElementIfJustOpened();
+    if(_textDepth < 0 && !_firstElement && !_compactMode) {
+        Putc('\n');
+        PrintSpace(_depth);
+    }
+    _firstElement = false;
+
+    Write("<!--");
+    Write(comment);
+    Write("-->");
+}
+
+void XMLPrinter::PushDeclaration(const char *value) {
+    SealElementIfJustOpened();
+    if(_textDepth < 0 && !_firstElement && !_compactMode) {
+        Putc('\n');
+        PrintSpace(_depth);
+    }
+    _firstElement = false;
+
+    Write("<?");
+    Write(value);
+    Write("?>");
+}
+
+void XMLPrinter::PushUnknown(const char *value) {
+    SealElementIfJustOpened();
+    if(_textDepth < 0 && !_firstElement && !_compactMode) {
+        Putc('\n');
+        PrintSpace(_depth);
+    }
+    _firstElement = false;
+
+    Write("<!");
+    Write(value);
+    Putc('>');
+}
+
+bool XMLPrinter::VisitEnter(const XMLDocument &doc) {
+    _processEntities = doc.ProcessEntities();
+    if(doc.HasBOM()) {
+        PushHeader(true, false);
+    }
+    return true;
+}
+
+bool XMLPrinter::VisitEnter(const XMLElement &element, const XMLAttribute *attribute) {
+    const XMLElement *parentElem = 0;
+    if(element.Parent()) {
+        parentElem = element.Parent()->ToElement();
+    }
+    const bool compactMode = parentElem ? CompactMode(*parentElem) : _compactMode;
+    OpenElement(element.Name(), compactMode);
+    while(attribute) {
+        PushAttribute(attribute->Name(), attribute->Value());
+        attribute = attribute->Next();
+    }
+    return true;
+}
+
+bool XMLPrinter::VisitExit(const XMLElement &element) {
+    CloseElement(CompactMode(element));
+    return true;
+}
+
+bool XMLPrinter::Visit(const XMLText &text) {
+    PushText(text.Value(), text.CData());
+    return true;
+}
+
+bool XMLPrinter::Visit(const XMLComment &comment) {
+    PushComment(comment.Value());
+    return true;
+}
+
+bool XMLPrinter::Visit(const XMLDeclaration &declaration) {
+    PushDeclaration(declaration.Value());
+    return true;
+}
+
+bool XMLPrinter::Visit(const XMLUnknown &unknown) {
+    PushUnknown(unknown.Value());
+    return true;
+}
+
+}  // namespace libobsensor
diff --git a/3rdparty/tinyxml2/src/tinyxml2.hpp b/3rdparty/tinyxml2/src/tinyxml2.hpp
new file mode 100644
index 00000000..7d18ba0d
--- /dev/null
+++ b/3rdparty/tinyxml2/src/tinyxml2.hpp
@@ -0,0 +1,2322 @@
+/*
+Original code by Lee Thomason (www.grinninglizard.com)
+
+This software is provided 'as-is', without any express or implied
+warranty. In no event will the authors be held liable for any
+damages arising from the use of this software.
+
+Permission is granted to anyone to use this software for any
+purpose, including commercial applications, and to alter it and
+redistribute it freely, subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must
+not claim that you wrote the original software. If you use this
+software in a product, an acknowledgment in the product documentation
+would be appreciated but is not required.
+
+2. Altered source versions must be plainly marked as such, and
+must not be misrepresented as being the original software.
+
+3. This notice may not be removed or altered from any source
+distribution.
+*/
+/**=======================================================================================================
+ Date                   Name                           Description of Change
+ 28-Sep-2020            ZYB                     add wide-string load/save function and
+                                     replace _DEBUG of Macro-keyWord with NDEBUG in gcc compiler
+=======================================================================================================**/
+#ifndef TINYXML2_INCLUDED
+#define TINYXML2_INCLUDED
+
+#if defined(ANDROID_NDK) || defined(__BORLANDC__) || defined(__QNXNTO__)
+#include <ctype.h>
+#include <limits.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#if defined(__PS3__)
+#include <stddef.h>
+#endif
+#else
+#include <cassert>
+#include <cctype>
+#include <climits>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#endif
+#include <stdint.h>
+
+/*
+   TODO: intern strings instead of allocation.
+*/
+/*
+    gcc:
+        g++ -Wall -DTINYXML2_DEBUG tinyxml2.cpp xmltest.cpp -o gccxmltest.exe
+
+    Formatting, Artistic Style:
+        AStyle.exe --style=1tbs --indent-switches --break-closing-brackets --indent-preprocessor tinyxml2.cpp tinyxml2.h
+*/
+
+// #if defined( _DEBUG ) || defined (__DEBUG__)
+#ifndef NDEBUG
+#ifndef TINYXML2_DEBUG
+#define TINYXML2_DEBUG
+#endif
+#endif
+
+// #define TINYXML2_DEBUG
+
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4251)
+#endif
+
+#ifdef _WIN32
+#ifdef TINYXML2_EXPORT
+#define TINYXML2_LIB __declspec(dllexport)
+#elif defined(TINYXML2_IMPORT)
+#define TINYXML2_LIB __declspec(dllimport)
+#else
+#define TINYXML2_LIB
+#endif
+#elif __GNUC__ >= 4
+#define TINYXML2_LIB __attribute__((visibility("default")))
+#else
+#define TINYXML2_LIB
+#endif
+
+#if defined(TINYXML2_DEBUG)
+#if defined(_MSC_VER)
+#// "(void)0," is for suppressing C4127 warning in "assert(false)", "assert(true)" and the like
+#define TIXMLASSERT(x)    \
+    if(!((void)0, (x))) { \
+        __debugbreak();   \
+    }
+#elif defined(ANDROID_NDK)
+#include <android/log.h>
+#define TIXMLASSERT(x)                                                                          \
+    if(!(x)) {                                                                                  \
+        __android_log_assert("assert", "grinliz", "ASSERT in '%s' at %d.", __FILE__, __LINE__); \
+    }
+#else
+#include <assert.h>
+#define TIXMLASSERT assert
+#endif
+#else
+#define TIXMLASSERT(x) \
+    {}
+#endif
+
+/* Versioning, past 1.0.14:
+    http://semver.org/
+*/
+static const int TIXML2_MAJOR_VERSION = 7;
+static const int TIXML2_MINOR_VERSION = 1;
+static const int TIXML2_PATCH_VERSION = 0;
+
+#define TINYXML2_MAJOR_VERSION 7
+#define TINYXML2_MINOR_VERSION 1
+#define TINYXML2_PATCH_VERSION 0
+
+// A fixed element depth limit is problematic. There needs to be a
+// limit to avoid a stack overflow. However, that limit varies per
+// system, and the capacity of the stack. On the other hand, it's a trivial
+// attack that can result from ill, malicious, or even correctly formed XML,
+// so there needs to be a limit in place.
+static const int TINYXML2_MAX_ELEMENT_DEPTH = 100;
+
+namespace libobsensor {
+class XMLDocument;
+class XMLElement;
+class XMLAttribute;
+class XMLComment;
+class XMLText;
+class XMLDeclaration;
+class XMLUnknown;
+class XMLPrinter;
+
+FILE *callfopen(const char *filepath, const char *mode);
+
+/*
+    A class that wraps strings. Normally stores the start and end
+    pointers into the XML file itself, and will apply normalization
+    and entity translation if actually read. Can also store (and memory
+    manage) a traditional char[]
+
+    Isn't clear why TINYXML2_LIB is needed; but seems to fix #719
+*/
+class TINYXML2_LIB StrPair {
+public:
+    enum {
+        NEEDS_ENTITY_PROCESSING     = 0x01,
+        NEEDS_NEWLINE_NORMALIZATION = 0x02,
+        NEEDS_WHITESPACE_COLLAPSING = 0x04,
+
+        TEXT_ELEMENT                   = NEEDS_ENTITY_PROCESSING | NEEDS_NEWLINE_NORMALIZATION,
+        TEXT_ELEMENT_LEAVE_ENTITIES    = NEEDS_NEWLINE_NORMALIZATION,
+        ATTRIBUTE_NAME                 = 0,
+        ATTRIBUTE_VALUE                = NEEDS_ENTITY_PROCESSING | NEEDS_NEWLINE_NORMALIZATION,
+        ATTRIBUTE_VALUE_LEAVE_ENTITIES = NEEDS_NEWLINE_NORMALIZATION,
+        COMMENT                        = NEEDS_NEWLINE_NORMALIZATION
+    };
+
+    StrPair() : _flags(0), _start(0), _end(0) {}
+    ~StrPair();
+
+    void Set(char *start, char *end, int flags) {
+        TIXMLASSERT(start);
+        TIXMLASSERT(end);
+        Reset();
+        _start = start;
+        _end   = end;
+        _flags = flags | NEEDS_FLUSH;
+    }
+
+    const char *GetStr();
+
+    bool Empty() const {
+        return _start == _end;
+    }
+
+    void SetInternedStr(const char *str) {
+        Reset();
+        _start = const_cast<char *>(str);
+    }
+
+    void SetStr(const char *str, int flags = 0);
+
+    char *ParseText(char *in, const char *endTag, int strFlags, int *curLineNumPtr);
+    char *ParseName(char *in);
+
+    void TransferTo(StrPair *other);
+    void Reset();
+
+private:
+    void CollapseWhitespace();
+
+    enum { NEEDS_FLUSH = 0x100, NEEDS_DELETE = 0x200 };
+
+    int   _flags;
+    char *_start;
+    char *_end;
+
+    StrPair(const StrPair &other);         // not supported
+    void operator=(const StrPair &other);  // not supported, use TransferTo()
+};
+
+/*
+    A dynamic array of Plain Old Data. Doesn't support constructors, etc.
+    Has a small initial memory pool, so that low or no usage will not
+    cause a call to new/delete
+*/
+template <class T, int INITIAL_SIZE> class DynArray {
+public:
+    DynArray() : _mem(_pool), _allocated(INITIAL_SIZE), _size(0) {}
+
+    ~DynArray() {
+        if(_mem != _pool) {
+            delete[] _mem;
+        }
+    }
+
+    void Clear() {
+        _size = 0;
+    }
+
+    void Push(T t) {
+        TIXMLASSERT(_size < INT_MAX);
+        EnsureCapacity(_size + 1);
+        _mem[_size] = t;
+        ++_size;
+    }
+
+    T *PushArr(int count) {
+        TIXMLASSERT(count >= 0);
+        TIXMLASSERT(_size <= INT_MAX - count);
+        EnsureCapacity(_size + count);
+        T *ret = &_mem[_size];
+        _size += count;
+        return ret;
+    }
+
+    T Pop() {
+        TIXMLASSERT(_size > 0);
+        --_size;
+        return _mem[_size];
+    }
+
+    void PopArr(int count) {
+        TIXMLASSERT(_size >= count);
+        _size -= count;
+    }
+
+    bool Empty() const {
+        return _size == 0;
+    }
+
+    T &operator[](int i) {
+        TIXMLASSERT(i >= 0 && i < _size);
+        return _mem[i];
+    }
+
+    const T &operator[](int i) const {
+        TIXMLASSERT(i >= 0 && i < _size);
+        return _mem[i];
+    }
+
+    const T &PeekTop() const {
+        TIXMLASSERT(_size > 0);
+        return _mem[_size - 1];
+    }
+
+    int Size() const {
+        TIXMLASSERT(_size >= 0);
+        return _size;
+    }
+
+    int Capacity() const {
+        TIXMLASSERT(_allocated >= INITIAL_SIZE);
+        return _allocated;
+    }
+
+    void SwapRemove(int i) {
+        TIXMLASSERT(i >= 0 && i < _size);
+        TIXMLASSERT(_size > 0);
+        _mem[i] = _mem[_size - 1];
+        --_size;
+    }
+
+    const T *Mem() const {
+        TIXMLASSERT(_mem);
+        return _mem;
+    }
+
+    T *Mem() {
+        TIXMLASSERT(_mem);
+        return _mem;
+    }
+
+private:
+    DynArray(const DynArray &);        // not supported
+    void operator=(const DynArray &);  // not supported
+
+    void EnsureCapacity(int cap) {
+        TIXMLASSERT(cap > 0);
+        if(cap > _allocated) {
+            TIXMLASSERT(cap <= INT_MAX / 2);
+            const int newAllocated = cap * 2;
+            T        *newMem       = new T[newAllocated];
+            TIXMLASSERT(newAllocated >= _size);
+            memcpy(newMem, _mem, sizeof(T) * _size);  // warning: not using constructors, only works for PODs
+            if(_mem != _pool) {
+                delete[] _mem;
+            }
+            _mem       = newMem;
+            _allocated = newAllocated;
+        }
+    }
+
+    T  *_mem;
+    T   _pool[INITIAL_SIZE];
+    int _allocated;  // objects allocated
+    int _size;       // number objects in use
+};
+
+/*
+    Parent virtual class of a pool for fast allocation
+    and deallocation of objects.
+*/
+class MemPool {
+public:
+    MemPool() {}
+    virtual ~MemPool() {}
+
+    virtual int   ItemSize() const = 0;
+    virtual void *Alloc()          = 0;
+    virtual void  Free(void *)     = 0;
+    virtual void  SetTracked()     = 0;
+};
+
+/*
+    Template child class to create pools of the correct type.
+*/
+template <int ITEM_SIZE> class MemPoolT : public MemPool {
+public:
+    MemPoolT() : _blockPtrs(), _root(0), _currentAllocs(0), _nAllocs(0), _maxAllocs(0), _nUntracked(0) {}
+    ~MemPoolT() {
+        MemPoolT<ITEM_SIZE>::Clear();
+    }
+
+    void Clear() {
+        // Delete the blocks.
+        while(!_blockPtrs.Empty()) {
+            Block *lastBlock = _blockPtrs.Pop();
+            delete lastBlock;
+        }
+        _root          = 0;
+        _currentAllocs = 0;
+        _nAllocs       = 0;
+        _maxAllocs     = 0;
+        _nUntracked    = 0;
+    }
+
+    virtual int ItemSize() const {
+        return ITEM_SIZE;
+    }
+    int CurrentAllocs() const {
+        return _currentAllocs;
+    }
+
+    virtual void *Alloc() {
+        if(!_root) {
+            // Need a new block.
+            Block *block = new Block();
+            _blockPtrs.Push(block);
+
+            Item *blockItems = block->items;
+            for(int i = 0; i < ITEMS_PER_BLOCK - 1; ++i) {
+                blockItems[i].next = &(blockItems[i + 1]);
+            }
+            blockItems[ITEMS_PER_BLOCK - 1].next = 0;
+            _root                                = blockItems;
+        }
+        Item *const result = _root;
+        TIXMLASSERT(result != 0);
+        _root = _root->next;
+
+        ++_currentAllocs;
+        if(_currentAllocs > _maxAllocs) {
+            _maxAllocs = _currentAllocs;
+        }
+        ++_nAllocs;
+        ++_nUntracked;
+        return result;
+    }
+
+    virtual void Free(void *mem) {
+        if(!mem) {
+            return;
+        }
+        --_currentAllocs;
+        Item *item = static_cast<Item *>(mem);
+#ifdef TINYXML2_DEBUG
+        memset(item, 0xfe, sizeof(*item));
+#endif
+        item->next = _root;
+        _root      = item;
+    }
+    void Trace(const char *name) {
+        printf("Mempool %s watermark=%d [%dk] current=%d size=%d nAlloc=%d blocks=%d\n", name, _maxAllocs, _maxAllocs * ITEM_SIZE / 1024, _currentAllocs,
+               ITEM_SIZE, _nAllocs, _blockPtrs.Size());
+    }
+
+    void SetTracked() {
+        --_nUntracked;
+    }
+
+    int Untracked() const {
+        return _nUntracked;
+    }
+
+    // This number is perf sensitive. 4k seems like a good tradeoff on my machine.
+    // The test file is large, 170k.
+    // Release:		VS2010 gcc(no opt)
+    //		1k:		4000
+    //		2k:		4000
+    //		4k:		3900	21000
+    //		16k:	5200
+    //		32k:	4300
+    //		64k:	4000	21000
+    // Declared public because some compilers do not accept to use ITEMS_PER_BLOCK
+    // in private part if ITEMS_PER_BLOCK is private
+    enum { ITEMS_PER_BLOCK = (4 * 1024) / ITEM_SIZE };
+
+private:
+    MemPoolT(const MemPoolT &);        // not supported
+    void operator=(const MemPoolT &);  // not supported
+
+    union Item {
+        Item *next;
+        char  itemData[ITEM_SIZE];
+    };
+    struct Block {
+        Item items[ITEMS_PER_BLOCK];
+    };
+    DynArray<Block *, 10> _blockPtrs;
+    Item                 *_root;
+
+    int _currentAllocs;
+    int _nAllocs;
+    int _maxAllocs;
+    int _nUntracked;
+};
+
+/**
+    Implements the interface to the "Visitor pattern" (see the Accept() method.)
+    If you call the Accept() method, it requires being passed a XMLVisitor
+    class to handle callbacks. For nodes that contain other nodes (Document, Element)
+    you will get called with a VisitEnter/VisitExit pair. Nodes that are always leafs
+    are simply called with Visit().
+
+    If you return 'true' from a Visit method, recursive parsing will continue. If you return
+    false, <b>no children of this node or its siblings</b> will be visited.
+
+    All flavors of Visit methods have a default implementation that returns 'true' (continue
+    visiting). You need to only override methods that are interesting to you.
+
+    Generally Accept() is called on the XMLDocument, although all nodes support visiting.
+
+    You should never change the document from a callback.
+
+    @sa XMLNode::Accept()
+*/
+class TINYXML2_LIB XMLVisitor {
+public:
+    virtual ~XMLVisitor() {}
+
+    /// Visit a document.
+    virtual bool VisitEnter(const XMLDocument & /*doc*/) {
+        return true;
+    }
+    /// Visit a document.
+    virtual bool VisitExit(const XMLDocument & /*doc*/) {
+        return true;
+    }
+
+    /// Visit an element.
+    virtual bool VisitEnter(const XMLElement & /*element*/, const XMLAttribute * /*firstAttribute*/) {
+        return true;
+    }
+    /// Visit an element.
+    virtual bool VisitExit(const XMLElement & /*element*/) {
+        return true;
+    }
+
+    /// Visit a declaration.
+    virtual bool Visit(const XMLDeclaration & /*declaration*/) {
+        return true;
+    }
+    /// Visit a text node.
+    virtual bool Visit(const XMLText & /*text*/) {
+        return true;
+    }
+    /// Visit a comment node.
+    virtual bool Visit(const XMLComment & /*comment*/) {
+        return true;
+    }
+    /// Visit an unknown node.
+    virtual bool Visit(const XMLUnknown & /*unknown*/) {
+        return true;
+    }
+};
+
+// WARNING: must match XMLDocument::_errorNames[]
+enum XMLError {
+    XML_SUCCESS = 0,
+    XML_NO_ATTRIBUTE,
+    XML_WRONG_ATTRIBUTE_TYPE,
+    XML_ERROR_FILE_NOT_FOUND,
+    XML_ERROR_FILE_COULD_NOT_BE_OPENED,
+    XML_ERROR_FILE_READ_ERROR,
+    XML_ERROR_PARSING_ELEMENT,
+    XML_ERROR_PARSING_ATTRIBUTE,
+    XML_ERROR_PARSING_TEXT,
+    XML_ERROR_PARSING_CDATA,
+    XML_ERROR_PARSING_COMMENT,
+    XML_ERROR_PARSING_DECLARATION,
+    XML_ERROR_PARSING_UNKNOWN,
+    XML_ERROR_EMPTY_DOCUMENT,
+    XML_ERROR_MISMATCHED_ELEMENT,
+    XML_ERROR_PARSING,
+    XML_CAN_NOT_CONVERT_TEXT,
+    XML_NO_TEXT_NODE,
+    XML_ELEMENT_DEPTH_EXCEEDED,
+
+    XML_ERROR_COUNT
+};
+
+/*
+    Utility functionality.
+*/
+class TINYXML2_LIB XMLUtil {
+public:
+    static const char *SkipWhiteSpace(const char *p, int *curLineNumPtr) {
+        TIXMLASSERT(p);
+
+        while(IsWhiteSpace(*p)) {
+            if(curLineNumPtr && *p == '\n') {
+                ++(*curLineNumPtr);
+            }
+            ++p;
+        }
+        TIXMLASSERT(p);
+        return p;
+    }
+    static char *SkipWhiteSpace(char *p, int *curLineNumPtr) {
+        return const_cast<char *>(SkipWhiteSpace(const_cast<const char *>(p), curLineNumPtr));
+    }
+
+    // Anything in the high order range of UTF-8 is assumed to not be whitespace. This isn't
+    // correct, but simple, and usually works.
+    static bool IsWhiteSpace(char p) {
+        return !IsUTF8Continuation(p) && isspace(static_cast<unsigned char>(p));
+    }
+
+    inline static bool IsNameStartChar(unsigned char ch) {
+        if(ch >= 128) {
+            // This is a heuristic guess in attempt to not implement Unicode-aware isalpha()
+            return true;
+        }
+        if(isalpha(ch)) {
+            return true;
+        }
+        return ch == ':' || ch == '_';
+    }
+
+    inline static bool IsNameChar(unsigned char ch) {
+        return IsNameStartChar(ch) || isdigit(ch) || ch == '.' || ch == '-';
+    }
+
+    inline static bool StringEqual(const char *p, const char *q, int nChar = INT_MAX) {
+        if(p == q) {
+            return true;
+        }
+        TIXMLASSERT(p);
+        TIXMLASSERT(q);
+        TIXMLASSERT(nChar >= 0);
+        return strncmp(p, q, nChar) == 0;
+    }
+
+    inline static bool IsUTF8Continuation(char p) {
+        return (p & 0x80) != 0;
+    }
+
+    static const char *ReadBOM(const char *p, bool *hasBOM);
+    // p is the starting location,
+    // the UTF-8 value of the entity will be placed in value, and length filled in.
+    static const char *GetCharacterRef(const char *p, char *value, int *length);
+    static void        ConvertUTF32ToUTF8(unsigned long input, char *output, int *length);
+
+    // converts primitive types to strings
+    static void ToStr(int v, char *buffer, int bufferSize);
+    static void ToStr(unsigned v, char *buffer, int bufferSize);
+    static void ToStr(bool v, char *buffer, int bufferSize);
+    static void ToStr(float v, char *buffer, int bufferSize);
+    static void ToStr(double v, char *buffer, int bufferSize);
+    static void ToStr(int64_t v, char *buffer, int bufferSize);
+    static void ToStr(uint64_t v, char *buffer, int bufferSize);
+
+    // converts strings to primitive types
+    static bool ToInt(const char *str, int *value);
+    static bool ToUnsigned(const char *str, unsigned *value);
+    static bool ToBool(const char *str, bool *value);
+    static bool ToFloat(const char *str, float *value);
+    static bool ToDouble(const char *str, double *value);
+    static bool ToInt64(const char *str, int64_t *value);
+    static bool ToUnsigned64(const char *str, uint64_t *value);
+    // Changes what is serialized for a boolean value.
+    // Default to "true" and "false". Shouldn't be changed
+    // unless you have a special testing or compatibility need.
+    // Be careful: static, global, & not thread safe.
+    // Be sure to set static const memory as parameters.
+    static void SetBoolSerialization(const char *writeTrue, const char *writeFalse);
+
+private:
+    static const char *writeBoolTrue;
+    static const char *writeBoolFalse;
+};
+
+/** XMLNode is a base class for every object that is in the
+    XML Document Object Model (DOM), except XMLAttributes.
+    Nodes have siblings, a parent, and children which can
+    be navigated. A node is always in a XMLDocument.
+    The type of a XMLNode can be queried, and it can
+    be cast to its more defined type.
+
+    A XMLDocument allocates memory for all its Nodes.
+    When the XMLDocument gets deleted, all its Nodes
+    will also be deleted.
+
+    @verbatim
+    A Document can contain:	Element	(container or leaf)
+                            Comment (leaf)
+                            Unknown (leaf)
+                            Declaration( leaf )
+
+    An Element can contain:	Element (container or leaf)
+                            Text	(leaf)
+                            Attributes (not on tree)
+                            Comment (leaf)
+                            Unknown (leaf)
+
+    @endverbatim
+*/
+class TINYXML2_LIB XMLNode {
+    friend class XMLDocument;
+    friend class XMLElement;
+
+public:
+    /// Get the XMLDocument that owns this XMLNode.
+    const XMLDocument *GetDocument() const {
+        TIXMLASSERT(_document);
+        return _document;
+    }
+    /// Get the XMLDocument that owns this XMLNode.
+    XMLDocument *GetDocument() {
+        TIXMLASSERT(_document);
+        return _document;
+    }
+
+    /// Safely cast to an Element, or null.
+    virtual XMLElement *ToElement() {
+        return 0;
+    }
+    /// Safely cast to Text, or null.
+    virtual XMLText *ToText() {
+        return 0;
+    }
+    /// Safely cast to a Comment, or null.
+    virtual XMLComment *ToComment() {
+        return 0;
+    }
+    /// Safely cast to a Document, or null.
+    virtual XMLDocument *ToDocument() {
+        return 0;
+    }
+    /// Safely cast to a Declaration, or null.
+    virtual XMLDeclaration *ToDeclaration() {
+        return 0;
+    }
+    /// Safely cast to an Unknown, or null.
+    virtual XMLUnknown *ToUnknown() {
+        return 0;
+    }
+
+    virtual const XMLElement *ToElement() const {
+        return 0;
+    }
+    virtual const XMLText *ToText() const {
+        return 0;
+    }
+    virtual const XMLComment *ToComment() const {
+        return 0;
+    }
+    virtual const XMLDocument *ToDocument() const {
+        return 0;
+    }
+    virtual const XMLDeclaration *ToDeclaration() const {
+        return 0;
+    }
+    virtual const XMLUnknown *ToUnknown() const {
+        return 0;
+    }
+
+    /** The meaning of 'value' changes for the specific type.
+        @verbatim
+        Document:	empty (NULL is returned, not an empty string)
+        Element:	name of the element
+        Comment:	the comment text
+        Unknown:	the tag contents
+        Text:		the text string
+        @endverbatim
+    */
+    const char *Value() const;
+
+    /** Set the Value of an XML node.
+        @sa Value()
+    */
+    void SetValue(const char *val, bool staticMem = false);
+
+    /// Gets the line number the node is in, if the document was parsed from a file.
+    int GetLineNum() const {
+        return _parseLineNum;
+    }
+
+    /// Get the parent of this node on the DOM.
+    const XMLNode *Parent() const {
+        return _parent;
+    }
+
+    XMLNode *Parent() {
+        return _parent;
+    }
+
+    /// Returns true if this node has no children.
+    bool NoChildren() const {
+        return !_firstChild;
+    }
+
+    /// Get the first child node, or null if none exists.
+    const XMLNode *FirstChild() const {
+        return _firstChild;
+    }
+
+    XMLNode *FirstChild() {
+        return _firstChild;
+    }
+
+    /** Get the first child element, or optionally the first child
+        element with the specified name.
+    */
+    const XMLElement *FirstChildElement(const char *name = 0) const;
+
+    XMLElement *FirstChildElement(const char *name = 0) {
+        return const_cast<XMLElement *>(const_cast<const XMLNode *>(this)->FirstChildElement(name));
+    }
+
+    /// Get the last child node, or null if none exists.
+    const XMLNode *LastChild() const {
+        return _lastChild;
+    }
+
+    XMLNode *LastChild() {
+        return _lastChild;
+    }
+    /** Get the last child element or optionally the last child
+        element with the specified name.
+    */
+    const XMLElement *LastChildElement(const char *name = 0) const;
+
+    XMLElement *LastChildElement(const char *name = 0) {
+        return const_cast<XMLElement *>(const_cast<const XMLNode *>(this)->LastChildElement(name));
+    }
+
+    /// Get the previous (left) sibling node of this node.
+    const XMLNode *PreviousSibling() const {
+        return _prev;
+    }
+
+    XMLNode *PreviousSibling() {
+        return _prev;
+    }
+
+    /// Get the previous (left) sibling element of this node, with an optionally supplied name.
+    const XMLElement *PreviousSiblingElement(const char *name = 0) const;
+
+    XMLElement *PreviousSiblingElement(const char *name = 0) {
+        return const_cast<XMLElement *>(const_cast<const XMLNode *>(this)->PreviousSiblingElement(name));
+    }
+
+    /// Get the next (right) sibling node of this node.
+    const XMLNode *NextSibling() const {
+        return _next;
+    }
+
+    XMLNode *NextSibling() {
+        return _next;
+    }
+
+    /// Get the next (right) sibling element of this node, with an optionally supplied name.
+    const XMLElement *NextSiblingElement(const char *name = 0) const;
+
+    XMLElement *NextSiblingElement(const char *name = 0) {
+        return const_cast<XMLElement *>(const_cast<const XMLNode *>(this)->NextSiblingElement(name));
+    }
+
+    /**
+        Add a child node as the last (right) child.
+        If the child node is already part of the document,
+        it is moved from its old location to the new location.
+        Returns the addThis argument or 0 if the node does not
+        belong to the same document.
+    */
+    XMLNode *InsertEndChild(XMLNode *addThis);
+
+    XMLNode *LinkEndChild(XMLNode *addThis) {
+        return InsertEndChild(addThis);
+    }
+    /**
+        Add a child node as the first (left) child.
+        If the child node is already part of the document,
+        it is moved from its old location to the new location.
+        Returns the addThis argument or 0 if the node does not
+        belong to the same document.
+    */
+    XMLNode *InsertFirstChild(XMLNode *addThis);
+    /**
+        Add a node after the specified child node.
+        If the child node is already part of the document,
+        it is moved from its old location to the new location.
+        Returns the addThis argument or 0 if the afterThis node
+        is not a child of this node, or if the node does not
+        belong to the same document.
+    */
+    XMLNode *InsertAfterChild(XMLNode *afterThis, XMLNode *addThis);
+
+    /**
+        Delete all the children of this node.
+    */
+    void DeleteChildren();
+
+    /**
+        Delete a child of this node.
+    */
+    void DeleteChild(XMLNode *node);
+
+    /**
+        Make a copy of this node, but not its children.
+        You may pass in a Document pointer that will be
+        the owner of the new Node. If the 'document' is
+        null, then the node returned will be allocated
+        from the current Document. (this->GetDocument())
+
+        Note: if called on a XMLDocument, this will return null.
+    */
+    virtual XMLNode *ShallowClone(XMLDocument *document) const = 0;
+
+    /**
+        Make a copy of this node and all its children.
+
+        If the 'target' is null, then the nodes will
+        be allocated in the current document. If 'target'
+        is specified, the memory will be allocated is the
+        specified XMLDocument.
+
+        NOTE: This is probably not the correct tool to
+        copy a document, since XMLDocuments can have multiple
+        top level XMLNodes. You probably want to use
+        XMLDocument::DeepCopy()
+    */
+    XMLNode *DeepClone(XMLDocument *target) const;
+
+    /**
+        Test if 2 nodes are the same, but don't test children.
+        The 2 nodes do not need to be in the same Document.
+
+        Note: if called on a XMLDocument, this will return false.
+    */
+    virtual bool ShallowEqual(const XMLNode *compare) const = 0;
+
+    /** Accept a hierarchical visit of the nodes in the TinyXML-2 DOM. Every node in the
+        XML tree will be conditionally visited and the host will be called back
+        via the XMLVisitor interface.
+
+        This is essentially a SAX interface for TinyXML-2. (Note however it doesn't re-parse
+        the XML for the callbacks, so the performance of TinyXML-2 is unchanged by using this
+        interface versus any other.)
+
+        The interface has been based on ideas from:
+
+        - http://www.saxproject.org/
+        - http://c2.com/cgi/wiki?HierarchicalVisitorPattern
+
+        Which are both good references for "visiting".
+
+        An example of using Accept():
+        @verbatim
+        XMLPrinter printer;
+        tinyxmlDoc.Accept( &printer );
+        const char* xmlcstr = printer.CStr();
+        @endverbatim
+    */
+    virtual bool Accept(XMLVisitor *visitor) const = 0;
+
+    /**
+        Set user data into the XMLNode. TinyXML-2 in
+        no way processes or interprets user data.
+        It is initially 0.
+    */
+    void SetUserData(void *userData) {
+        _userData = userData;
+    }
+
+    /**
+        Get user data set into the XMLNode. TinyXML-2 in
+        no way processes or interprets user data.
+        It is initially 0.
+    */
+    void *GetUserData() const {
+        return _userData;
+    }
+
+protected:
+    explicit XMLNode(XMLDocument *);
+    virtual ~XMLNode();
+
+    virtual char *ParseDeep(char *p, StrPair *parentEndTag, int *curLineNumPtr);
+
+    XMLDocument    *_document;
+    XMLNode        *_parent;
+    mutable StrPair _value;
+    int             _parseLineNum;
+
+    XMLNode *_firstChild;
+    XMLNode *_lastChild;
+
+    XMLNode *_prev;
+    XMLNode *_next;
+
+    void *_userData;
+
+private:
+    MemPool          *_memPool;
+    void              Unlink(XMLNode *child);
+    static void       DeleteNode(XMLNode *node);
+    void              InsertChildPreamble(XMLNode *insertThis) const;
+    const XMLElement *ToElementWithName(const char *name) const;
+
+    XMLNode(const XMLNode &);             // not supported
+    XMLNode &operator=(const XMLNode &);  // not supported
+};
+
+/** XML text.
+
+    Note that a text node can have child element nodes, for example:
+    @verbatim
+    <root>This is <b>bold</b></root>
+    @endverbatim
+
+    A text node can have 2 ways to output the next. "normal" output
+    and CDATA. It will default to the mode it was parsed from the XML file and
+    you generally want to leave it alone, but you can change the output mode with
+    SetCData() and query it with CData().
+*/
+class TINYXML2_LIB XMLText : public XMLNode {
+    friend class XMLDocument;
+
+public:
+    virtual bool Accept(XMLVisitor *visitor) const;
+
+    virtual XMLText *ToText() {
+        return this;
+    }
+    virtual const XMLText *ToText() const {
+        return this;
+    }
+
+    /// Declare whether this should be CDATA or standard text.
+    void SetCData(bool isCData) {
+        _isCData = isCData;
+    }
+    /// Returns true if this is a CDATA text element.
+    bool CData() const {
+        return _isCData;
+    }
+
+    virtual XMLNode *ShallowClone(XMLDocument *document) const;
+    virtual bool     ShallowEqual(const XMLNode *compare) const;
+
+protected:
+    explicit XMLText(XMLDocument *doc) : XMLNode(doc), _isCData(false) {}
+    virtual ~XMLText() {}
+
+    char *ParseDeep(char *p, StrPair *parentEndTag, int *curLineNumPtr);
+
+private:
+    bool _isCData;
+
+    XMLText(const XMLText &);             // not supported
+    XMLText &operator=(const XMLText &);  // not supported
+};
+
+/** An XML Comment. */
+class TINYXML2_LIB XMLComment : public XMLNode {
+    friend class XMLDocument;
+
+public:
+    virtual XMLComment *ToComment() {
+        return this;
+    }
+    virtual const XMLComment *ToComment() const {
+        return this;
+    }
+
+    virtual bool Accept(XMLVisitor *visitor) const;
+
+    virtual XMLNode *ShallowClone(XMLDocument *document) const;
+    virtual bool     ShallowEqual(const XMLNode *compare) const;
+
+protected:
+    explicit XMLComment(XMLDocument *doc);
+    virtual ~XMLComment();
+
+    char *ParseDeep(char *p, StrPair *parentEndTag, int *curLineNumPtr);
+
+private:
+    XMLComment(const XMLComment &);             // not supported
+    XMLComment &operator=(const XMLComment &);  // not supported
+};
+
+/** In correct XML the declaration is the first entry in the file.
+    @verbatim
+        <?xml version="1.0" standalone="yes"?>
+    @endverbatim
+
+    TinyXML-2 will happily read or write files without a declaration,
+    however.
+
+    The text of the declaration isn't interpreted. It is parsed
+    and written as a string.
+*/
+class TINYXML2_LIB XMLDeclaration : public XMLNode {
+    friend class XMLDocument;
+
+public:
+    virtual XMLDeclaration *ToDeclaration() {
+        return this;
+    }
+    virtual const XMLDeclaration *ToDeclaration() const {
+        return this;
+    }
+
+    virtual bool Accept(XMLVisitor *visitor) const;
+
+    virtual XMLNode *ShallowClone(XMLDocument *document) const;
+    virtual bool     ShallowEqual(const XMLNode *compare) const;
+
+protected:
+    explicit XMLDeclaration(XMLDocument *doc);
+    virtual ~XMLDeclaration();
+
+    char *ParseDeep(char *p, StrPair *parentEndTag, int *curLineNumPtr);
+
+private:
+    XMLDeclaration(const XMLDeclaration &);             // not supported
+    XMLDeclaration &operator=(const XMLDeclaration &);  // not supported
+};
+
+/** Any tag that TinyXML-2 doesn't recognize is saved as an
+    unknown. It is a tag of text, but should not be modified.
+    It will be written back to the XML, unchanged, when the file
+    is saved.
+
+    DTD tags get thrown into XMLUnknowns.
+*/
+class TINYXML2_LIB XMLUnknown : public XMLNode {
+    friend class XMLDocument;
+
+public:
+    virtual XMLUnknown *ToUnknown() {
+        return this;
+    }
+    virtual const XMLUnknown *ToUnknown() const {
+        return this;
+    }
+
+    virtual bool Accept(XMLVisitor *visitor) const;
+
+    virtual XMLNode *ShallowClone(XMLDocument *document) const;
+    virtual bool     ShallowEqual(const XMLNode *compare) const;
+
+protected:
+    explicit XMLUnknown(XMLDocument *doc);
+    virtual ~XMLUnknown();
+
+    char *ParseDeep(char *p, StrPair *parentEndTag, int *curLineNumPtr);
+
+private:
+    XMLUnknown(const XMLUnknown &);             // not supported
+    XMLUnknown &operator=(const XMLUnknown &);  // not supported
+};
+
+/** An attribute is a name-value pair. Elements have an arbitrary
+    number of attributes, each with a unique name.
+
+    @note The attributes are not XMLNodes. You may only query the
+    Next() attribute in a list.
+*/
+class TINYXML2_LIB XMLAttribute {
+    friend class XMLElement;
+
+public:
+    /// The name of the attribute.
+    const char *Name() const;
+
+    /// The value of the attribute.
+    const char *Value() const;
+
+    /// Gets the line number the attribute is in, if the document was parsed from a file.
+    int GetLineNum() const {
+        return _parseLineNum;
+    }
+
+    /// The next attribute in the list.
+    const XMLAttribute *Next() const {
+        return _next;
+    }
+
+    /** IntValue interprets the attribute as an integer, and returns the value.
+        If the value isn't an integer, 0 will be returned. There is no error checking;
+        use QueryIntValue() if you need error checking.
+    */
+    int IntValue() const {
+        int i = 0;
+        QueryIntValue(&i);
+        return i;
+    }
+
+    int64_t Int64Value() const {
+        int64_t i = 0;
+        QueryInt64Value(&i);
+        return i;
+    }
+
+    uint64_t Unsigned64Value() const {
+        uint64_t i = 0;
+        QueryUnsigned64Value(&i);
+        return i;
+    }
+
+    /// Query as an unsigned integer. See IntValue()
+    unsigned UnsignedValue() const {
+        unsigned i = 0;
+        QueryUnsignedValue(&i);
+        return i;
+    }
+    /// Query as a boolean. See IntValue()
+    bool BoolValue() const {
+        bool b = false;
+        QueryBoolValue(&b);
+        return b;
+    }
+    /// Query as a double. See IntValue()
+    double DoubleValue() const {
+        double d = 0;
+        QueryDoubleValue(&d);
+        return d;
+    }
+    /// Query as a float. See IntValue()
+    float FloatValue() const {
+        float f = 0;
+        QueryFloatValue(&f);
+        return f;
+    }
+
+    /** QueryIntValue interprets the attribute as an integer, and returns the value
+        in the provided parameter. The function will return XML_SUCCESS on success,
+        and XML_WRONG_ATTRIBUTE_TYPE if the conversion is not successful.
+    */
+    XMLError QueryIntValue(int *value) const;
+    /// See QueryIntValue
+    XMLError QueryUnsignedValue(unsigned int *value) const;
+    /// See QueryIntValue
+    XMLError QueryInt64Value(int64_t *value) const;
+    /// See QueryIntValue
+    XMLError QueryUnsigned64Value(uint64_t *value) const;
+    /// See QueryIntValue
+    XMLError QueryBoolValue(bool *value) const;
+    /// See QueryIntValue
+    XMLError QueryDoubleValue(double *value) const;
+    /// See QueryIntValue
+    XMLError QueryFloatValue(float *value) const;
+
+    /// Set the attribute to a string value.
+    void SetAttribute(const char *value);
+    /// Set the attribute to value.
+    void SetAttribute(int value);
+    /// Set the attribute to value.
+    void SetAttribute(unsigned value);
+    /// Set the attribute to value.
+    void SetAttribute(int64_t value);
+    /// Set the attribute to value.
+    void SetAttribute(uint64_t value);
+    /// Set the attribute to value.
+    void SetAttribute(bool value);
+    /// Set the attribute to value.
+    void SetAttribute(double value);
+    /// Set the attribute to value.
+    void SetAttribute(float value);
+
+private:
+    enum { BUF_SIZE = 200 };
+
+    XMLAttribute() : _name(), _value(), _parseLineNum(0), _next(0), _memPool(0) {}
+    virtual ~XMLAttribute() {}
+
+    XMLAttribute(const XMLAttribute &);    // not supported
+    void operator=(const XMLAttribute &);  // not supported
+    void SetName(const char *name);
+
+    char *ParseDeep(char *p, bool processEntities, int *curLineNumPtr);
+
+    mutable StrPair _name;
+    mutable StrPair _value;
+    int             _parseLineNum;
+    XMLAttribute   *_next;
+    MemPool        *_memPool;
+};
+
+/** The element is a container class. It has a value, the element name,
+    and can contain other elements, text, comments, and unknowns.
+    Elements also contain an arbitrary number of attributes.
+*/
+class TINYXML2_LIB XMLElement : public XMLNode {
+    friend class XMLDocument;
+
+public:
+    /// Get the name of an element (which is the Value() of the node.)
+    const char *Name() const {
+        return Value();
+    }
+    /// Set the name of the element.
+    void SetName(const char *str, bool staticMem = false) {
+        SetValue(str, staticMem);
+    }
+
+    virtual XMLElement *ToElement() {
+        return this;
+    }
+    virtual const XMLElement *ToElement() const {
+        return this;
+    }
+    virtual bool Accept(XMLVisitor *visitor) const;
+
+    /** Given an attribute name, Attribute() returns the value
+        for the attribute of that name, or null if none
+        exists. For example:
+
+        @verbatim
+        const char* value = ele->Attribute( "foo" );
+        @endverbatim
+
+        The 'value' parameter is normally null. However, if specified,
+        the attribute will only be returned if the 'name' and 'value'
+        match. This allow you to write code:
+
+        @verbatim
+        if ( ele->Attribute( "foo", "bar" ) ) callFooIsBar();
+        @endverbatim
+
+        rather than:
+        @verbatim
+        if ( ele->Attribute( "foo" ) ) {
+            if ( strcmp( ele->Attribute( "foo" ), "bar" ) == 0 ) callFooIsBar();
+        }
+        @endverbatim
+    */
+    const char *Attribute(const char *name, const char *value = 0) const;
+
+    /** Given an attribute name, IntAttribute() returns the value
+        of the attribute interpreted as an integer. The default
+        value will be returned if the attribute isn't present,
+        or if there is an error. (For a method with error
+        checking, see QueryIntAttribute()).
+    */
+    int IntAttribute(const char *name, int defaultValue = 0) const;
+    /// See IntAttribute()
+    unsigned UnsignedAttribute(const char *name, unsigned defaultValue = 0) const;
+    /// See IntAttribute()
+    int64_t Int64Attribute(const char *name, int64_t defaultValue = 0) const;
+    /// See IntAttribute()
+    uint64_t Unsigned64Attribute(const char *name, uint64_t defaultValue = 0) const;
+    /// See IntAttribute()
+    bool BoolAttribute(const char *name, bool defaultValue = false) const;
+    /// See IntAttribute()
+    double DoubleAttribute(const char *name, double defaultValue = 0) const;
+    /// See IntAttribute()
+    float FloatAttribute(const char *name, float defaultValue = 0) const;
+
+    /** Given an attribute name, QueryIntAttribute() returns
+        XML_SUCCESS, XML_WRONG_ATTRIBUTE_TYPE if the conversion
+        can't be performed, or XML_NO_ATTRIBUTE if the attribute
+        doesn't exist. If successful, the result of the conversion
+        will be written to 'value'. If not successful, nothing will
+        be written to 'value'. This allows you to provide default
+        value:
+
+        @verbatim
+        int value = 10;
+        QueryIntAttribute( "foo", &value );		// if "foo" isn't found, value will still be 10
+        @endverbatim
+    */
+    XMLError QueryIntAttribute(const char *name, int *value) const {
+        const XMLAttribute *a = FindAttribute(name);
+        if(!a) {
+            return XML_NO_ATTRIBUTE;
+        }
+        return a->QueryIntValue(value);
+    }
+
+    /// See QueryIntAttribute()
+    XMLError QueryUnsignedAttribute(const char *name, unsigned int *value) const {
+        const XMLAttribute *a = FindAttribute(name);
+        if(!a) {
+            return XML_NO_ATTRIBUTE;
+        }
+        return a->QueryUnsignedValue(value);
+    }
+
+    /// See QueryIntAttribute()
+    XMLError QueryInt64Attribute(const char *name, int64_t *value) const {
+        const XMLAttribute *a = FindAttribute(name);
+        if(!a) {
+            return XML_NO_ATTRIBUTE;
+        }
+        return a->QueryInt64Value(value);
+    }
+
+    /// See QueryIntAttribute()
+    XMLError QueryUnsigned64Attribute(const char *name, uint64_t *value) const {
+        const XMLAttribute *a = FindAttribute(name);
+        if(!a) {
+            return XML_NO_ATTRIBUTE;
+        }
+        return a->QueryUnsigned64Value(value);
+    }
+
+    /// See QueryIntAttribute()
+    XMLError QueryBoolAttribute(const char *name, bool *value) const {
+        const XMLAttribute *a = FindAttribute(name);
+        if(!a) {
+            return XML_NO_ATTRIBUTE;
+        }
+        return a->QueryBoolValue(value);
+    }
+    /// See QueryIntAttribute()
+    XMLError QueryDoubleAttribute(const char *name, double *value) const {
+        const XMLAttribute *a = FindAttribute(name);
+        if(!a) {
+            return XML_NO_ATTRIBUTE;
+        }
+        return a->QueryDoubleValue(value);
+    }
+    /// See QueryIntAttribute()
+    XMLError QueryFloatAttribute(const char *name, float *value) const {
+        const XMLAttribute *a = FindAttribute(name);
+        if(!a) {
+            return XML_NO_ATTRIBUTE;
+        }
+        return a->QueryFloatValue(value);
+    }
+
+    /// See QueryIntAttribute()
+    XMLError QueryStringAttribute(const char *name, const char **value) const {
+        const XMLAttribute *a = FindAttribute(name);
+        if(!a) {
+            return XML_NO_ATTRIBUTE;
+        }
+        *value = a->Value();
+        return XML_SUCCESS;
+    }
+
+    /** Given an attribute name, QueryAttribute() returns
+        XML_SUCCESS, XML_WRONG_ATTRIBUTE_TYPE if the conversion
+        can't be performed, or XML_NO_ATTRIBUTE if the attribute
+        doesn't exist. It is overloaded for the primitive types,
+        and is a generally more convenient replacement of
+        QueryIntAttribute() and related functions.
+
+        If successful, the result of the conversion
+        will be written to 'value'. If not successful, nothing will
+        be written to 'value'. This allows you to provide default
+        value:
+
+        @verbatim
+        int value = 10;
+        QueryAttribute( "foo", &value );		// if "foo" isn't found, value will still be 10
+        @endverbatim
+    */
+    XMLError QueryAttribute(const char *name, int *value) const {
+        return QueryIntAttribute(name, value);
+    }
+
+    XMLError QueryAttribute(const char *name, unsigned int *value) const {
+        return QueryUnsignedAttribute(name, value);
+    }
+
+    XMLError QueryAttribute(const char *name, int64_t *value) const {
+        return QueryInt64Attribute(name, value);
+    }
+
+    XMLError QueryAttribute(const char *name, uint64_t *value) const {
+        return QueryUnsigned64Attribute(name, value);
+    }
+
+    XMLError QueryAttribute(const char *name, bool *value) const {
+        return QueryBoolAttribute(name, value);
+    }
+
+    XMLError QueryAttribute(const char *name, double *value) const {
+        return QueryDoubleAttribute(name, value);
+    }
+
+    XMLError QueryAttribute(const char *name, float *value) const {
+        return QueryFloatAttribute(name, value);
+    }
+
+    /// Sets the named attribute to value.
+    void SetAttribute(const char *name, const char *value) {
+        XMLAttribute *a = FindOrCreateAttribute(name);
+        a->SetAttribute(value);
+    }
+    /// Sets the named attribute to value.
+    void SetAttribute(const char *name, int value) {
+        XMLAttribute *a = FindOrCreateAttribute(name);
+        a->SetAttribute(value);
+    }
+    /// Sets the named attribute to value.
+    void SetAttribute(const char *name, unsigned value) {
+        XMLAttribute *a = FindOrCreateAttribute(name);
+        a->SetAttribute(value);
+    }
+
+    /// Sets the named attribute to value.
+    void SetAttribute(const char *name, int64_t value) {
+        XMLAttribute *a = FindOrCreateAttribute(name);
+        a->SetAttribute(value);
+    }
+
+    /// Sets the named attribute to value.
+    void SetAttribute(const char *name, uint64_t value) {
+        XMLAttribute *a = FindOrCreateAttribute(name);
+        a->SetAttribute(value);
+    }
+
+    /// Sets the named attribute to value.
+    void SetAttribute(const char *name, bool value) {
+        XMLAttribute *a = FindOrCreateAttribute(name);
+        a->SetAttribute(value);
+    }
+    /// Sets the named attribute to value.
+    void SetAttribute(const char *name, double value) {
+        XMLAttribute *a = FindOrCreateAttribute(name);
+        a->SetAttribute(value);
+    }
+    /// Sets the named attribute to value.
+    void SetAttribute(const char *name, float value) {
+        XMLAttribute *a = FindOrCreateAttribute(name);
+        a->SetAttribute(value);
+    }
+
+    /**
+        Delete an attribute.
+    */
+    void DeleteAttribute(const char *name);
+
+    /// Return the first attribute in the list.
+    const XMLAttribute *FirstAttribute() const {
+        return _rootAttribute;
+    }
+    /// Query a specific attribute in the list.
+    const XMLAttribute *FindAttribute(const char *name) const;
+
+    /** Convenience function for easy access to the text inside an element. Although easy
+        and concise, GetText() is limited compared to getting the XMLText child
+        and accessing it directly.
+
+        If the first child of 'this' is a XMLText, the GetText()
+        returns the character string of the Text node, else null is returned.
+
+        This is a convenient method for getting the text of simple contained text:
+        @verbatim
+        <foo>This is text</foo>
+            const char* str = fooElement->GetText();
+        @endverbatim
+
+        'str' will be a pointer to "This is text".
+
+        Note that this function can be misleading. If the element foo was created from
+        this XML:
+        @verbatim
+            <foo><b>This is text</b></foo>
+        @endverbatim
+
+        then the value of str would be null. The first child node isn't a text node, it is
+        another element. From this XML:
+        @verbatim
+            <foo>This is <b>text</b></foo>
+        @endverbatim
+        GetText() will return "This is ".
+    */
+    const char *GetText() const;
+
+    /** Convenience function for easy access to the text inside an element. Although easy
+        and concise, SetText() is limited compared to creating an XMLText child
+        and mutating it directly.
+
+        If the first child of 'this' is a XMLText, SetText() sets its value to
+        the given string, otherwise it will create a first child that is an XMLText.
+
+        This is a convenient method for setting the text of simple contained text:
+        @verbatim
+        <foo>This is text</foo>
+            fooElement->SetText( "Hullaballoo!" );
+        <foo>Hullaballoo!</foo>
+        @endverbatim
+
+        Note that this function can be misleading. If the element foo was created from
+        this XML:
+        @verbatim
+            <foo><b>This is text</b></foo>
+        @endverbatim
+
+        then it will not change "This is text", but rather prefix it with a text element:
+        @verbatim
+            <foo>Hullaballoo!<b>This is text</b></foo>
+        @endverbatim
+
+        For this XML:
+        @verbatim
+            <foo />
+        @endverbatim
+        SetText() will generate
+        @verbatim
+            <foo>Hullaballoo!</foo>
+        @endverbatim
+    */
+    void SetText(const char *inText);
+    /// Convenience method for setting text inside an element. See SetText() for important limitations.
+    void SetText(int value);
+    /// Convenience method for setting text inside an element. See SetText() for important limitations.
+    void SetText(unsigned value);
+    /// Convenience method for setting text inside an element. See SetText() for important limitations.
+    void SetText(int64_t value);
+    /// Convenience method for setting text inside an element. See SetText() for important limitations.
+    void SetText(uint64_t value);
+    /// Convenience method for setting text inside an element. See SetText() for important limitations.
+    void SetText(bool value);
+    /// Convenience method for setting text inside an element. See SetText() for important limitations.
+    void SetText(double value);
+    /// Convenience method for setting text inside an element. See SetText() for important limitations.
+    void SetText(float value);
+
+    /**
+        Convenience method to query the value of a child text node. This is probably best
+        shown by example. Given you have a document is this form:
+        @verbatim
+            <point>
+                <x>1</x>
+                <y>1.4</y>
+            </point>
+        @endverbatim
+
+        The QueryIntText() and similar functions provide a safe and easier way to get to the
+        "value" of x and y.
+
+        @verbatim
+            int x = 0;
+            float y = 0;	// types of x and y are contrived for example
+            const XMLElement* xElement = pointElement->FirstChildElement( "x" );
+            const XMLElement* yElement = pointElement->FirstChildElement( "y" );
+            xElement->QueryIntText( &x );
+            yElement->QueryFloatText( &y );
+        @endverbatim
+
+        @returns XML_SUCCESS (0) on success, XML_CAN_NOT_CONVERT_TEXT if the text cannot be converted
+                 to the requested type, and XML_NO_TEXT_NODE if there is no child text to query.
+
+    */
+    XMLError QueryIntText(int *ival) const;
+    /// See QueryIntText()
+    XMLError QueryUnsignedText(unsigned *uval) const;
+    /// See QueryIntText()
+    XMLError QueryInt64Text(int64_t *uval) const;
+    /// See QueryIntText()
+    XMLError QueryUnsigned64Text(uint64_t *uval) const;
+    /// See QueryIntText()
+    XMLError QueryBoolText(bool *bval) const;
+    /// See QueryIntText()
+    XMLError QueryDoubleText(double *dval) const;
+    /// See QueryIntText()
+    XMLError QueryFloatText(float *fval) const;
+
+    int IntText(int defaultValue = 0) const;
+
+    /// See QueryIntText()
+    unsigned UnsignedText(unsigned defaultValue = 0) const;
+    /// See QueryIntText()
+    int64_t Int64Text(int64_t defaultValue = 0) const;
+    /// See QueryIntText()
+    uint64_t Unsigned64Text(uint64_t defaultValue = 0) const;
+    /// See QueryIntText()
+    bool BoolText(bool defaultValue = false) const;
+    /// See QueryIntText()
+    double DoubleText(double defaultValue = 0) const;
+    /// See QueryIntText()
+    float FloatText(float defaultValue = 0) const;
+
+    // internal:
+    enum ElementClosingType {
+        OPEN,    // <foo>
+        CLOSED,  // <foo/>
+        CLOSING  // </foo>
+    };
+    ElementClosingType ClosingType() const {
+        return _closingType;
+    }
+    virtual XMLNode *ShallowClone(XMLDocument *document) const;
+    virtual bool     ShallowEqual(const XMLNode *compare) const;
+
+protected:
+    char *ParseDeep(char *p, StrPair *parentEndTag, int *curLineNumPtr);
+
+private:
+    XMLElement(XMLDocument *doc);
+    virtual ~XMLElement();
+    XMLElement(const XMLElement &);      // not supported
+    void operator=(const XMLElement &);  // not supported
+
+    XMLAttribute *FindOrCreateAttribute(const char *name);
+    char         *ParseAttributes(char *p, int *curLineNumPtr);
+    static void   DeleteAttribute(XMLAttribute *attribute);
+    XMLAttribute *CreateAttribute();
+
+    enum { BUF_SIZE = 200 };
+    ElementClosingType _closingType;
+    // The attribute list is ordered; there is no 'lastAttribute'
+    // because the list needs to be scanned for dupes before adding
+    // a new attribute.
+    XMLAttribute *_rootAttribute;
+};
+
+enum Whitespace { PRESERVE_WHITESPACE, COLLAPSE_WHITESPACE };
+
+/** A Document binds together all the functionality.
+    It can be saved, loaded, and printed to the screen.
+    All Nodes are connected and allocated to a Document.
+    If the Document is deleted, all its Nodes are also deleted.
+*/
+class TINYXML2_LIB XMLDocument : public XMLNode {
+    friend class XMLElement;
+    // Gives access to SetError and Push/PopDepth, but over-access for everything else.
+    // Wishing C++ had "internal" scope.
+    friend class XMLNode;
+    friend class XMLText;
+    friend class XMLComment;
+    friend class XMLDeclaration;
+    friend class XMLUnknown;
+
+public:
+    /// constructor
+    XMLDocument(bool processEntities = true, Whitespace whitespaceMode = PRESERVE_WHITESPACE);
+    ~XMLDocument();
+
+    virtual XMLDocument *ToDocument() {
+        TIXMLASSERT(this == _document);
+        return this;
+    }
+    virtual const XMLDocument *ToDocument() const {
+        TIXMLASSERT(this == _document);
+        return this;
+    }
+
+    /**
+        Parse an XML file from a character string.
+        Returns XML_SUCCESS (0) on success, or
+        an errorID.
+
+        You may optionally pass in the 'nBytes', which is
+        the number of bytes which will be parsed. If not
+        specified, TinyXML-2 will assume 'xml' points to a
+        null terminated string.
+    */
+    XMLError Parse(const char *xml, size_t nBytes = static_cast<size_t>(-1));
+
+    /**
+        Load an XML file from disk.
+        Returns XML_SUCCESS (0) on success, or
+        an errorID.
+    */
+
+#if defined(_WIN32)
+    XMLError LoadFile(const wchar_t *filename);
+#endif
+    XMLError LoadFile(const char *filename);
+
+    /**
+        Load an XML file from disk. You are responsible
+        for providing and closing the FILE*.
+
+        NOTE: The file should be opened as binary ("rb")
+        not text in order for TinyXML-2 to correctly
+        do newline normalization.
+
+        Returns XML_SUCCESS (0) on success, or
+        an errorID.
+    */
+    XMLError LoadFile(FILE *);
+    XMLError LoadFromByteBuffer(uint8_t *buffer, uint32_t size);
+
+    /**
+        Save the XML file to disk.
+        Returns XML_SUCCESS (0) on success, or
+        an errorID.
+    */
+    XMLError SaveFile(const char *filename, bool compact = false);
+#if defined(_WIN32)
+    XMLError SaveFile(const wchar_t *filename, bool compact = false);
+#endif
+
+    /**
+        Save the XML file to disk. You are responsible
+        for providing and closing the FILE*.
+
+        Returns XML_SUCCESS (0) on success, or
+        an errorID.
+    */
+    XMLError SaveFile(FILE *fp, bool compact = false);
+
+    bool ProcessEntities() const {
+        return _processEntities;
+    }
+    Whitespace WhitespaceMode() const {
+        return _whitespaceMode;
+    }
+
+    /**
+        Returns true if this document has a leading Byte Order Mark of UTF8.
+    */
+    bool HasBOM() const {
+        return _writeBOM;
+    }
+    /** Sets whether to write the BOM when writing the file.
+     */
+    void SetBOM(bool useBOM) {
+        _writeBOM = useBOM;
+    }
+
+    /** Return the root element of DOM. Equivalent to FirstChildElement().
+        To get the first node, use FirstChild().
+    */
+    XMLElement *RootElement() {
+        return FirstChildElement();
+    }
+    const XMLElement *RootElement() const {
+        return FirstChildElement();
+    }
+
+    /** Print the Document. If the Printer is not provided, it will
+        print to stdout. If you provide Printer, this can print to a file:
+        @verbatim
+        XMLPrinter printer( fp );
+        doc.Print( &printer );
+        @endverbatim
+
+        Or you can use a printer to print to memory:
+        @verbatim
+        XMLPrinter printer;
+        doc.Print( &printer );
+        // printer.CStr() has a const char* to the XML
+        @endverbatim
+    */
+    void         Print(XMLPrinter *streamer = 0) const;
+    virtual bool Accept(XMLVisitor *visitor) const;
+
+    /**
+        Create a new Element associated with
+        this Document. The memory for the Element
+        is managed by the Document.
+    */
+    XMLElement *NewElement(const char *name);
+    /**
+        Create a new Comment associated with
+        this Document. The memory for the Comment
+        is managed by the Document.
+    */
+    XMLComment *NewComment(const char *comment);
+    /**
+        Create a new Text associated with
+        this Document. The memory for the Text
+        is managed by the Document.
+    */
+    XMLText *NewText(const char *text);
+    /**
+        Create a new Declaration associated with
+        this Document. The memory for the object
+        is managed by the Document.
+
+        If the 'text' param is null, the standard
+        declaration is used.:
+        @verbatim
+            <?xml version="1.0" encoding="UTF-8"?>
+        @endverbatim
+    */
+    XMLDeclaration *NewDeclaration(const char *text = 0);
+    /**
+        Create a new Unknown associated with
+        this Document. The memory for the object
+        is managed by the Document.
+    */
+    XMLUnknown *NewUnknown(const char *text);
+
+    /**
+        Delete a node associated with this document.
+        It will be unlinked from the DOM.
+    */
+    void DeleteNode(XMLNode *node);
+
+    void ClearError() {
+        SetError(XML_SUCCESS, 0, 0);
+    }
+
+    /// Return true if there was an error parsing the document.
+    bool Error() const {
+        return _errorID != XML_SUCCESS;
+    }
+    /// Return the errorID.
+    XMLError ErrorID() const {
+        return _errorID;
+    }
+    const char        *ErrorName() const;
+    static const char *ErrorIDToName(XMLError errorID);
+
+    /** Returns a "long form" error description. A hopefully helpful
+        diagnostic with location, line number, and/or additional info.
+    */
+    const char *ErrorStr() const;
+
+    /// A (trivial) utility function that prints the ErrorStr() to stdout.
+    void PrintError() const;
+
+    /// Return the line where the error occurred, or zero if unknown.
+    int ErrorLineNum() const {
+        return _errorLineNum;
+    }
+
+    /// Clear the document, resetting it to the initial state.
+    void Clear();
+
+    /**
+        Copies this document to a target document.
+        The target will be completely cleared before the copy.
+        If you want to copy a sub-tree, see XMLNode::DeepClone().
+
+        NOTE: that the 'target' must be non-null.
+    */
+    void DeepCopy(XMLDocument *target) const;
+
+    // internal
+    char *Identify(char *p, XMLNode **node);
+
+    // internal
+    void MarkInUse(XMLNode *);
+
+    virtual XMLNode *ShallowClone(XMLDocument * /*document*/) const {
+        return 0;
+    }
+    virtual bool ShallowEqual(const XMLNode * /*compare*/) const {
+        return false;
+    }
+
+private:
+    XMLDocument(const XMLDocument &);     // not supported
+    void operator=(const XMLDocument &);  // not supported
+
+    bool            _writeBOM;
+    bool            _processEntities;
+    XMLError        _errorID;
+    Whitespace      _whitespaceMode;
+    mutable StrPair _errorStr;
+    int             _errorLineNum;
+    char           *_charBuffer;
+    int             _parseCurLineNum;
+    int             _parsingDepth;
+    // Memory tracking does add some overhead.
+    // However, the code assumes that you don't
+    // have a bunch of unlinked nodes around.
+    // Therefore it takes less memory to track
+    // in the document vs. a linked list in the XMLNode,
+    // and the performance is the same.
+    DynArray<XMLNode *, 10> _unlinked;
+
+    MemPoolT<sizeof(XMLElement)>   _elementPool;
+    MemPoolT<sizeof(XMLAttribute)> _attributePool;
+    MemPoolT<sizeof(XMLText)>      _textPool;
+    MemPoolT<sizeof(XMLComment)>   _commentPool;
+
+    static const char *_errorNames[XML_ERROR_COUNT];
+
+    void Parse();
+
+    void SetError(XMLError error, int lineNum, const char *format, ...);
+
+    // Something of an obvious security hole, once it was discovered.
+    // Either an ill-formed XML or an excessively deep one can overflow
+    // the stack. Track stack depth, and error out if needed.
+    class DepthTracker {
+    public:
+        explicit DepthTracker(XMLDocument *document) {
+            this->_document = document;
+            document->PushDepth();
+        }
+        ~DepthTracker() {
+            _document->PopDepth();
+        }
+
+    private:
+        XMLDocument *_document;
+    };
+    void PushDepth();
+    void PopDepth();
+
+    template <class NodeType, int PoolElementSize> NodeType *CreateUnlinkedNode(MemPoolT<PoolElementSize> &pool);
+};
+
+template <class NodeType, int PoolElementSize> inline NodeType *XMLDocument::CreateUnlinkedNode(MemPoolT<PoolElementSize> &pool) {
+    TIXMLASSERT(sizeof(NodeType) == PoolElementSize);
+    TIXMLASSERT(sizeof(NodeType) == pool.ItemSize());
+    NodeType *returnNode = new(pool.Alloc()) NodeType(this);
+    TIXMLASSERT(returnNode);
+    returnNode->_memPool = &pool;
+
+    _unlinked.Push(returnNode);
+    return returnNode;
+}
+
+/**
+    A XMLHandle is a class that wraps a node pointer with null checks; this is
+    an incredibly useful thing. Note that XMLHandle is not part of the TinyXML-2
+    DOM structure. It is a separate utility class.
+
+    Take an example:
+    @verbatim
+    <Document>
+        <Element attributeA = "valueA">
+            <Child attributeB = "value1" />
+            <Child attributeB = "value2" />
+        </Element>
+    </Document>
+    @endverbatim
+
+    Assuming you want the value of "attributeB" in the 2nd "Child" element, it's very
+    easy to write a *lot* of code that looks like:
+
+    @verbatim
+    XMLElement* root = document.FirstChildElement( "Document" );
+    if ( root )
+    {
+        XMLElement* element = root->FirstChildElement( "Element" );
+        if ( element )
+        {
+            XMLElement* child = element->FirstChildElement( "Child" );
+            if ( child )
+            {
+                XMLElement* child2 = child->NextSiblingElement( "Child" );
+                if ( child2 )
+                {
+                    // Finally do something useful.
+    @endverbatim
+
+    And that doesn't even cover "else" cases. XMLHandle addresses the verbosity
+    of such code. A XMLHandle checks for null pointers so it is perfectly safe
+    and correct to use:
+
+    @verbatim
+    XMLHandle docHandle( &document );
+    XMLElement* child2 = docHandle.FirstChildElement( "Document" ).FirstChildElement( "Element" ).FirstChildElement().NextSiblingElement();
+    if ( child2 )
+    {
+        // do something useful
+    @endverbatim
+
+    Which is MUCH more concise and useful.
+
+    It is also safe to copy handles - internally they are nothing more than node pointers.
+    @verbatim
+    XMLHandle handleCopy = handle;
+    @endverbatim
+
+    See also XMLConstHandle, which is the same as XMLHandle, but operates on const objects.
+*/
+class TINYXML2_LIB XMLHandle {
+public:
+    /// Create a handle from any node (at any depth of the tree.) This can be a null pointer.
+    explicit XMLHandle(XMLNode *node) : _node(node) {}
+    /// Create a handle from a node.
+    explicit XMLHandle(XMLNode &node) : _node(&node) {}
+    /// Copy constructor
+    XMLHandle(const XMLHandle &ref) : _node(ref._node) {}
+    /// Assignment
+    XMLHandle &operator=(const XMLHandle &ref) {
+        _node = ref._node;
+        return *this;
+    }
+
+    /// Get the first child of this handle.
+    XMLHandle FirstChild() {
+        return XMLHandle(_node ? _node->FirstChild() : 0);
+    }
+    /// Get the first child element of this handle.
+    XMLHandle FirstChildElement(const char *name = 0) {
+        return XMLHandle(_node ? _node->FirstChildElement(name) : 0);
+    }
+    /// Get the last child of this handle.
+    XMLHandle LastChild() {
+        return XMLHandle(_node ? _node->LastChild() : 0);
+    }
+    /// Get the last child element of this handle.
+    XMLHandle LastChildElement(const char *name = 0) {
+        return XMLHandle(_node ? _node->LastChildElement(name) : 0);
+    }
+    /// Get the previous sibling of this handle.
+    XMLHandle PreviousSibling() {
+        return XMLHandle(_node ? _node->PreviousSibling() : 0);
+    }
+    /// Get the previous sibling element of this handle.
+    XMLHandle PreviousSiblingElement(const char *name = 0) {
+        return XMLHandle(_node ? _node->PreviousSiblingElement(name) : 0);
+    }
+    /// Get the next sibling of this handle.
+    XMLHandle NextSibling() {
+        return XMLHandle(_node ? _node->NextSibling() : 0);
+    }
+    /// Get the next sibling element of this handle.
+    XMLHandle NextSiblingElement(const char *name = 0) {
+        return XMLHandle(_node ? _node->NextSiblingElement(name) : 0);
+    }
+
+    /// Safe cast to XMLNode. This can return null.
+    XMLNode *ToNode() {
+        return _node;
+    }
+    /// Safe cast to XMLElement. This can return null.
+    XMLElement *ToElement() {
+        return (_node ? _node->ToElement() : 0);
+    }
+    /// Safe cast to XMLText. This can return null.
+    XMLText *ToText() {
+        return (_node ? _node->ToText() : 0);
+    }
+    /// Safe cast to XMLUnknown. This can return null.
+    XMLUnknown *ToUnknown() {
+        return (_node ? _node->ToUnknown() : 0);
+    }
+    /// Safe cast to XMLDeclaration. This can return null.
+    XMLDeclaration *ToDeclaration() {
+        return (_node ? _node->ToDeclaration() : 0);
+    }
+
+private:
+    XMLNode *_node;
+};
+
+/**
+    A variant of the XMLHandle class for working with const XMLNodes and Documents. It is the
+    same in all regards, except for the 'const' qualifiers. See XMLHandle for API.
+*/
+class TINYXML2_LIB XMLConstHandle {
+public:
+    explicit XMLConstHandle(const XMLNode *node) : _node(node) {}
+    explicit XMLConstHandle(const XMLNode &node) : _node(&node) {}
+    XMLConstHandle(const XMLConstHandle &ref) : _node(ref._node) {}
+
+    XMLConstHandle &operator=(const XMLConstHandle &ref) {
+        _node = ref._node;
+        return *this;
+    }
+
+    const XMLConstHandle FirstChild() const {
+        return XMLConstHandle(_node ? _node->FirstChild() : 0);
+    }
+    const XMLConstHandle FirstChildElement(const char *name = 0) const {
+        return XMLConstHandle(_node ? _node->FirstChildElement(name) : 0);
+    }
+    const XMLConstHandle LastChild() const {
+        return XMLConstHandle(_node ? _node->LastChild() : 0);
+    }
+    const XMLConstHandle LastChildElement(const char *name = 0) const {
+        return XMLConstHandle(_node ? _node->LastChildElement(name) : 0);
+    }
+    const XMLConstHandle PreviousSibling() const {
+        return XMLConstHandle(_node ? _node->PreviousSibling() : 0);
+    }
+    const XMLConstHandle PreviousSiblingElement(const char *name = 0) const {
+        return XMLConstHandle(_node ? _node->PreviousSiblingElement(name) : 0);
+    }
+    const XMLConstHandle NextSibling() const {
+        return XMLConstHandle(_node ? _node->NextSibling() : 0);
+    }
+    const XMLConstHandle NextSiblingElement(const char *name = 0) const {
+        return XMLConstHandle(_node ? _node->NextSiblingElement(name) : 0);
+    }
+
+    const XMLNode *ToNode() const {
+        return _node;
+    }
+    const XMLElement *ToElement() const {
+        return (_node ? _node->ToElement() : 0);
+    }
+    const XMLText *ToText() const {
+        return (_node ? _node->ToText() : 0);
+    }
+    const XMLUnknown *ToUnknown() const {
+        return (_node ? _node->ToUnknown() : 0);
+    }
+    const XMLDeclaration *ToDeclaration() const {
+        return (_node ? _node->ToDeclaration() : 0);
+    }
+
+private:
+    const XMLNode *_node;
+};
+
+/**
+    Printing functionality. The XMLPrinter gives you more
+    options than the XMLDocument::Print() method.
+
+    It can:
+    -# Print to memory.
+    -# Print to a file you provide.
+    -# Print XML without a XMLDocument.
+
+    Print to Memory
+
+    @verbatim
+    XMLPrinter printer;
+    doc.Print( &printer );
+    SomeFunction( printer.CStr() );
+    @endverbatim
+
+    Print to a File
+
+    You provide the file pointer.
+    @verbatim
+    XMLPrinter printer( fp );
+    doc.Print( &printer );
+    @endverbatim
+
+    Print without a XMLDocument
+
+    When loading, an XML parser is very useful. However, sometimes
+    when saving, it just gets in the way. The code is often set up
+    for streaming, and constructing the DOM is just overhead.
+
+    The Printer supports the streaming case. The following code
+    prints out a trivially simple XML file without ever creating
+    an XML document.
+
+    @verbatim
+    XMLPrinter printer( fp );
+    printer.OpenElement( "foo" );
+    printer.PushAttribute( "foo", "bar" );
+    printer.CloseElement();
+    @endverbatim
+*/
+class TINYXML2_LIB XMLPrinter : public XMLVisitor {
+public:
+    /** Construct the printer. If the FILE* is specified,
+        this will print to the FILE. Else it will print
+        to memory, and the result is available in CStr().
+        If 'compact' is set to true, then output is created
+        with only required whitespace and newlines.
+    */
+    XMLPrinter(FILE *file = 0, bool compact = false, int depth = 0);
+    virtual ~XMLPrinter() {}
+
+    /** If streaming, write the BOM and declaration. */
+    void PushHeader(bool writeBOM, bool writeDeclaration);
+    /** If streaming, start writing an element.
+        The element must be closed with CloseElement()
+    */
+    void OpenElement(const char *name, bool compactMode = false);
+    /// If streaming, add an attribute to an open element.
+    void PushAttribute(const char *name, const char *value);
+    void PushAttribute(const char *name, int value);
+    void PushAttribute(const char *name, unsigned value);
+    void PushAttribute(const char *name, int64_t value);
+    void PushAttribute(const char *name, uint64_t value);
+    void PushAttribute(const char *name, bool value);
+    void PushAttribute(const char *name, double value);
+    /// If streaming, close the Element.
+    virtual void CloseElement(bool compactMode = false);
+
+    /// Add a text node.
+    void PushText(const char *text, bool cdata = false);
+    /// Add a text node from an integer.
+    void PushText(int value);
+    /// Add a text node from an unsigned.
+    void PushText(unsigned value);
+    /// Add a text node from a signed 64bit integer.
+    void PushText(int64_t value);
+    /// Add a text node from an unsigned 64bit integer.
+    void PushText(uint64_t value);
+    /// Add a text node from a bool.
+    void PushText(bool value);
+    /// Add a text node from a float.
+    void PushText(float value);
+    /// Add a text node from a double.
+    void PushText(double value);
+
+    /// Add a comment
+    void PushComment(const char *comment);
+
+    void PushDeclaration(const char *value);
+    void PushUnknown(const char *value);
+
+    virtual bool VisitEnter(const XMLDocument & /*doc*/);
+    virtual bool VisitExit(const XMLDocument & /*doc*/) {
+        return true;
+    }
+
+    virtual bool VisitEnter(const XMLElement &element, const XMLAttribute *attribute);
+    virtual bool VisitExit(const XMLElement &element);
+
+    virtual bool Visit(const XMLText &text);
+    virtual bool Visit(const XMLComment &comment);
+    virtual bool Visit(const XMLDeclaration &declaration);
+    virtual bool Visit(const XMLUnknown &unknown);
+
+    /**
+        If in print to memory mode, return a pointer to
+        the XML file in memory.
+    */
+    const char *CStr() const {
+        return _buffer.Mem();
+    }
+    /**
+        If in print to memory mode, return the size
+        of the XML file in memory. (Note the size returned
+        includes the terminating null.)
+    */
+    int CStrSize() const {
+        return _buffer.Size();
+    }
+    /**
+        If in print to memory mode, reset the buffer to the
+        beginning.
+    */
+    void ClearBuffer(bool resetToFirstElement = true) {
+        _buffer.Clear();
+        _buffer.Push(0);
+        _firstElement = resetToFirstElement;
+    }
+
+protected:
+    virtual bool CompactMode(const XMLElement &) {
+        return _compactMode;
+    }
+
+    /** Prints out the space before an element. You may override to change
+        the space and tabs used. A PrintSpace() override should call Print().
+    */
+    virtual void PrintSpace(int depth);
+    void         Print(const char *format, ...);
+    void         Write(const char *data, size_t size);
+    inline void  Write(const char *data) {
+        Write(data, strlen(data));
+    }
+    void Putc(char ch);
+
+    void                       SealElementIfJustOpened();
+    bool                       _elementJustOpened;
+    DynArray<const char *, 10> _stack;
+
+private:
+    void PrintString(const char *, bool restrictedEntitySet);  // prints out, after detecting entities.
+
+    bool  _firstElement;
+    FILE *_fp;
+    int   _depth;
+    int   _textDepth;
+    bool  _processEntities;
+    bool  _compactMode;
+
+    enum { ENTITY_RANGE = 64, BUF_SIZE = 200 };
+    bool _entityFlag[ENTITY_RANGE];
+    bool _restrictedEntityFlag[ENTITY_RANGE];
+
+    DynArray<char, 20> _buffer;
+
+    // Prohibit cloning, intentionally not implemented
+    XMLPrinter(const XMLPrinter &);
+    XMLPrinter &operator=(const XMLPrinter &);
+};
+
+}  // namespace libobsensor
+
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif
+
+#endif  // TINYXML2_INCLUDED
diff --git a/CMakeLists.txt b/CMakeLists.txt
new file mode 100644
index 00000000..af4580d2
--- /dev/null
+++ b/CMakeLists.txt
@@ -0,0 +1,81 @@
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+cmake_minimum_required(VERSION 3.5)
+
+project(OrbbecSDK VERSION 2.0.18 LANGUAGES CXX C)
+
+set(CMAKE_CXX_STANDARD 11)
+set(CMAKE_CXX_STANDARD_REQUIRED True)
+
+# check if current project is a sub project of other project
+if(CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR)
+    set(OB_IS_MAIN_PROJECT TRUE)
+else()
+    set(OB_IS_MAIN_PROJECT FALSE)
+endif()
+
+# load project options
+include(cmake/options.cmake)
+
+# load macros
+include(cmake/macro.cmake)
+
+# set compiler flags
+include(cmake/compiler_flags.cmake)
+
+# configure platform-specific settings（contains platform-specific compiler flags）
+if(ANDROID_NDK_TOOLCHAIN_INCLUDED)
+    include(cmake/android_config.cmake)
+elseif(WIN32)
+    include(cmake/windows_config.cmake)
+elseif(APPLE)
+    include(cmake/macos_config.cmake)
+elseif(UNIX)
+    include(cmake/linux_config.cmake)
+endif()
+
+# configure global settings: install rules, output directories, global variables, clang-tidy, etc.
+include(cmake/global_config.cmake)
+
+# configure global directories variables
+set(OB_PUBLIC_HEADERS_DIR ${CMAKE_CURRENT_LIST_DIR}/include/)
+set(OB_3RDPARTY_DIR ${CMAKE_CURRENT_LIST_DIR}/3rdparty)
+set(OB_PROJECT_ROOT_DIR ${CMAKE_CURRENT_LIST_DIR})
+
+add_subdirectory(extensions)
+add_subdirectory(src)
+
+if(OB_BUILD_EXAMPLES)
+    add_subdirectory(examples)
+endif()
+
+if(OB_INSTALL_EXAMPLES_SOURCE AND OB_IS_MAIN_PROJECT)
+    install(DIRECTORY ${CMAKE_CURRENT_LIST_DIR}/examples/ DESTINATION examples/src PATTERN "*publish_files*" EXCLUDE )
+    if(EXISTS ${CMAKE_CURRENT_LIST_DIR}/examples/publish_files)
+        install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/examples/publish_files/CMakeLists.txt DESTINATION examples)
+        if(APPLE)
+            install(TARGETS OrbbecSDK DESTINATION ./bin)
+        endif()
+        if(UNIX)
+            install(PROGRAMS ${CMAKE_CURRENT_SOURCE_DIR}/examples/publish_files/build_examples.sh DESTINATION ./)
+        endif()
+    endif()
+endif()
+
+if(OB_BUILD_TESTS)
+    add_subdirectory(tests)
+endif()
+
+if(OB_BUILD_DOCS)
+    add_subdirectory(docs)
+endif()
+
+if(OB_BUILD_TOOLS)
+    add_subdirectory(tools)
+endif()
+
+add_subdirectory(scripts)
+
+ob_print_summary()
+
diff --git a/LICENSE.txt b/LICENSE.txt
new file mode 100644
index 00000000..603911d4
--- /dev/null
+++ b/LICENSE.txt
@@ -0,0 +1,706 @@
+## License for this repository
+
+This repository is licensed under the MIT license.
+
+```
+Copyright (c) 2023 OrbbecDeveloper
+
+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.
+```
+
+## License for the third party dependencies
+
+The Orbbec SDK library uses third party libraries that may have their own licenses.
+
+### Third party libraries under the MIT license
+
+1. spdlog
+
+   * By: Gabi Melman
+   * Version: v1.11.0
+   * Repository: https://github.com/gabime/spdlog
+
+2. dylib
+
+   * By: Martin Olivier
+   * Version: v2.2.1
+   * Repository: https://github.com/martin-olivier/dylib
+
+3. cmrc
+
+    * By: vectorofbool@gmail.com
+    * Version: v2.0.1
+    * Repository: https://github.com/vector-of-bool/cmrc
+
+4. jsoncpp
+
+   * By: chenguopingdota@163.com
+   * Version: v1.9.5
+   * Repository: https://github.com/open-source-parsers/jsoncpp
+
+Terms of the MIT License:
+
+```
+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.
+```
+
+### Third party libraries under the BSD license
+
+1. libuvc
+
+   * By: libuvc organization
+   * Version: v0.0.7
+   * Repository: https://github.com/libuvc/libuvc
+
+2. libjpeg-turbo
+
+    * By: libjpeg-turbo organization (libjpeg-turbo.org)
+    * Version: v2.0.90
+    * Repository: https://github.com/libjpeg-turbo/libjpeg-turbo
+
+Terms of the BSD License:
+
+```
+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.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE 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, 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.
+```
+
+### Third party libraries under the LGPL license
+
+1. libusb
+
+    * By: libusb organization (libusb.info)
+    * Version: v1.0.26
+    * Repository: https://github.com/libusb/libusb
+
+2. live555
+
+    * By: http://www.live555.com/
+    * Version: v2019.08.13
+    * Repository: https://github.com/rgl/live555
+
+Terms of the LGPL license:
+
+```
+GNU LESSER GENERAL PUBLIC LICENSE
+		       Version 2.1, February 1999
+
+ Copyright (C) 1991, 1999 Free Software Foundation, Inc.
+ 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+[This is the first released version of the Lesser GPL.  It also counts
+ as the successor of the GNU Library Public License, version 2, hence
+ the version number 2.1.]
+
+			    Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+Licenses are intended to guarantee your freedom to share and change
+free software--to make sure the software is free for all its users.
+
+  This license, the Lesser General Public License, applies to some
+specially designated software packages--typically libraries--of the
+Free Software Foundation and other authors who decide to use it.  You
+can use it too, but we suggest you first think carefully about whether
+this license or the ordinary General Public License is the better
+strategy to use in any particular case, based on the explanations below.
+
+  When we speak of free software, we are referring to freedom of use,
+not price.  Our General Public Licenses are designed to make sure that
+you have the freedom to distribute copies of free software (and charge
+for this service if you wish); that you receive source code or can get
+it if you want it; that you can change the software and use pieces of
+it in new free programs; and that you are informed that you can do
+these things.
+
+  To protect your rights, we need to make restrictions that forbid
+distributors to deny you these rights or to ask you to surrender these
+rights.  These restrictions translate to certain responsibilities for
+you if you distribute copies of the library or if you modify it.
+
+  For example, if you distribute copies of the library, whether gratis
+or for a fee, you must give the recipients all the rights that we gave
+you.  You must make sure that they, too, receive or can get the source
+code.  If you link other code with the library, you must provide
+complete object files to the recipients, so that they can relink them
+with the library after making changes to the library and recompiling
+it.  And you must show them these terms so they know their rights.
+
+  We protect your rights with a two-step method: (1) we copyright the
+library, and (2) we offer you this license, which gives you legal
+permission to copy, distribute and/or modify the library.
+
+  To protect each distributor, we want to make it very clear that
+there is no warranty for the free library.  Also, if the library is
+modified by someone else and passed on, the recipients should know
+that what they have is not the original version, so that the original
+author's reputation will not be affected by problems that might be
+introduced by others.
+
+  Finally, software patents pose a constant threat to the existence of
+any free program.  We wish to make sure that a company cannot
+effectively restrict the users of a free program by obtaining a
+restrictive license from a patent holder.  Therefore, we insist that
+any patent license obtained for a version of the library must be
+consistent with the full freedom of use specified in this license.
+
+  Most GNU software, including some libraries, is covered by the
+ordinary GNU General Public License.  This license, the GNU Lesser
+General Public License, applies to certain designated libraries, and
+is quite different from the ordinary General Public License.  We use
+this license for certain libraries in order to permit linking those
+libraries into non-free programs.
+
+  When a program is linked with a library, whether statically or using
+a shared library, the combination of the two is legally speaking a
+combined work, a derivative of the original library.  The ordinary
+General Public License therefore permits such linking only if the
+entire combination fits its criteria of freedom.  The Lesser General
+Public License permits more lax criteria for linking other code with
+the library.
+
+  We call this license the "Lesser" General Public License because it
+does Less to protect the user's freedom than the ordinary General
+Public License.  It also provides other free software developers Less
+of an advantage over competing non-free programs.  These disadvantages
+are the reason we use the ordinary General Public License for many
+libraries.  However, the Lesser license provides advantages in certain
+special circumstances.
+
+  For example, on rare occasions, there may be a special need to
+encourage the widest possible use of a certain library, so that it becomes
+a de-facto standard.  To achieve this, non-free programs must be
+allowed to use the library.  A more frequent case is that a free
+library does the same job as widely used non-free libraries.  In this
+case, there is little to gain by limiting the free library to free
+software only, so we use the Lesser General Public License.
+
+  In other cases, permission to use a particular library in non-free
+programs enables a greater number of people to use a large body of
+free software.  For example, permission to use the GNU C Library in
+non-free programs enables many more people to use the whole GNU
+operating system, as well as its variant, the GNU/Linux operating
+system.
+
+  Although the Lesser General Public License is Less protective of the
+users' freedom, it does ensure that the user of a program that is
+linked with the Library has the freedom and the wherewithal to run
+that program using a modified version of the Library.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.  Pay close attention to the difference between a
+"work based on the library" and a "work that uses the library".  The
+former contains code derived from the library, whereas the latter must
+be combined with the library in order to run.
+
+		  GNU LESSER GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  1. This License Agreement applies to any software library or other
+program which contains a notice placed by the copyright holder or
+other authorized party saying it may be distributed under the terms of
+this Lesser General Public License (also called "this License").
+Each licensee is addressed as "you".
+
+  A "library" means a collection of software functions and/or data
+prepared so as to be conveniently linked with application programs
+(which use some of those functions and data) to form executables.
+
+  The "Library", below, refers to any such software library or work
+which has been distributed under these terms.  A "work based on the
+Library" means either the Library or any derivative work under
+copyright law: that is to say, a work containing the Library or a
+portion of it, either verbatim or with modifications and/or translated
+straightforwardly into another language.  (Hereinafter, translation is
+included without limitation in the term "modification".)
+
+  "Source code" for a work means the preferred form of the work for
+making modifications to it.  For a library, complete source code means
+all the source code for all modules it contains, plus any associated
+interface definition files, plus the scripts used to control compilation
+and installation of the library.
+
+  Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running a program using the Library is not restricted, and output from
+such a program is covered only if its contents constitute a work based
+on the Library (independent of the use of the Library in a tool for
+writing it).  Whether that is true depends on what the Library does
+and what the program that uses the Library does.
+
+  1. You may copy and distribute verbatim copies of the Library's
+complete source code as you receive it, in any medium, provided that
+you conspicuously and appropriately publish on each copy an
+appropriate copyright notice and disclaimer of warranty; keep intact
+all the notices that refer to this License and to the absence of any
+warranty; and distribute a copy of this License along with the
+Library.
+
+  You may charge a fee for the physical act of transferring a copy,
+and you may at your option offer warranty protection in exchange for a
+fee.
+
+  2. You may modify your copy or copies of the Library or any portion
+of it, thus forming a work based on the Library, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) The modified work must itself be a software library.
+
+    b) You must cause the files modified to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    c) You must cause the whole of the work to be licensed at no
+    charge to all third parties under the terms of this License.
+
+    d) If a facility in the modified Library refers to a function or a
+    table of data to be supplied by an application program that uses
+    the facility, other than as an argument passed when the facility
+    is invoked, then you must make a good faith effort to ensure that,
+    in the event an application does not supply such function or
+    table, the facility still operates, and performs whatever part of
+    its purpose remains meaningful.
+
+    (For example, a function in a library to compute square roots has
+    a purpose that is entirely well-defined independent of the
+    application.  Therefore, Subsection 2d requires that any
+    application-supplied function or table used by this function must
+    be optional: if the application does not supply it, the square
+    root function must still compute square roots.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Library,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Library, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote
+it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Library.
+
+In addition, mere aggregation of another work not based on the Library
+with the Library (or with a work based on the Library) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may opt to apply the terms of the ordinary GNU General Public
+License instead of this License to a given copy of the Library.  To do
+this, you must alter all the notices that refer to this License, so
+that they refer to the ordinary GNU General Public License, version 2,
+instead of to this License.  (If a newer version than version 2 of the
+ordinary GNU General Public License has appeared, then you can specify
+that version instead if you wish.)  Do not make any other change in
+these notices.
+
+  Once this change is made in a given copy, it is irreversible for
+that copy, so the ordinary GNU General Public License applies to all
+subsequent copies and derivative works made from that copy.
+
+  This option is useful when you wish to copy part of the code of
+the Library into a program that is not a library.
+
+  4. You may copy and distribute the Library (or a portion or
+derivative of it, under Section 2) in object code or executable form
+under the terms of Sections 1 and 2 above provided that you accompany
+it with the complete corresponding machine-readable source code, which
+must be distributed under the terms of Sections 1 and 2 above on a
+medium customarily used for software interchange.
+
+  If distribution of object code is made by offering access to copy
+from a designated place, then offering equivalent access to copy the
+source code from the same place satisfies the requirement to
+distribute the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  5. A program that contains no derivative of any portion of the
+Library, but is designed to work with the Library by being compiled or
+linked with it, is called a "work that uses the Library".  Such a
+work, in isolation, is not a derivative work of the Library, and
+therefore falls outside the scope of this License.
+
+  However, linking a "work that uses the Library" with the Library
+creates an executable that is a derivative of the Library (because it
+contains portions of the Library), rather than a "work that uses the
+library".  The executable is therefore covered by this License.
+Section 6 states terms for distribution of such executables.
+
+  When a "work that uses the Library" uses material from a header file
+that is part of the Library, the object code for the work may be a
+derivative work of the Library even though the source code is not.
+Whether this is true is especially significant if the work can be
+linked without the Library, or if the work is itself a library.  The
+threshold for this to be true is not precisely defined by law.
+
+  If such an object file uses only numerical parameters, data
+structure layouts and accessors, and small macros and small inline
+functions (ten lines or less in length), then the use of the object
+file is unrestricted, regardless of whether it is legally a derivative
+work.  (Executables containing this object code plus portions of the
+Library will still fall under Section 6.)
+
+  Otherwise, if the work is a derivative of the Library, you may
+distribute the object code for the work under the terms of Section 6.
+Any executables containing that work also fall under Section 6,
+whether or not they are linked directly with the Library itself.
+
+  6. As an exception to the Sections above, you may also combine or
+link a "work that uses the Library" with the Library to produce a
+work containing portions of the Library, and distribute that work
+under terms of your choice, provided that the terms permit
+modification of the work for the customer's own use and reverse
+engineering for debugging such modifications.
+
+  You must give prominent notice with each copy of the work that the
+Library is used in it and that the Library and its use are covered by
+this License.  You must supply a copy of this License.  If the work
+during execution displays copyright notices, you must include the
+copyright notice for the Library among them, as well as a reference
+directing the user to the copy of this License.  Also, you must do one
+of these things:
+
+    a) Accompany the work with the complete corresponding
+    machine-readable source code for the Library including whatever
+    changes were used in the work (which must be distributed under
+    Sections 1 and 2 above); and, if the work is an executable linked
+    with the Library, with the complete machine-readable "work that
+    uses the Library", as object code and/or source code, so that the
+    user can modify the Library and then relink to produce a modified
+    executable containing the modified Library.  (It is understood
+    that the user who changes the contents of definitions files in the
+    Library will not necessarily be able to recompile the application
+    to use the modified definitions.)
+
+    b) Use a suitable shared library mechanism for linking with the
+    Library.  A suitable mechanism is one that (1) uses at run time a
+    copy of the library already present on the user's computer system,
+    rather than copying library functions into the executable, and (2)
+    will operate properly with a modified version of the library, if
+    the user installs one, as long as the modified version is
+    interface-compatible with the version that the work was made with.
+
+    c) Accompany the work with a written offer, valid for at
+    least three years, to give the same user the materials
+    specified in Subsection 6a, above, for a charge no more
+    than the cost of performing this distribution.
+
+    d) If distribution of the work is made by offering access to copy
+    from a designated place, offer equivalent access to copy the above
+    specified materials from the same place.
+
+    e) Verify that the user has already received a copy of these
+    materials or that you have already sent this user a copy.
+
+  For an executable, the required form of the "work that uses the
+Library" must include any data and utility programs needed for
+reproducing the executable from it.  However, as a special exception,
+the materials to be distributed need not include anything that is
+normally distributed (in either source or binary form) with the major
+components (compiler, kernel, and so on) of the operating system on
+which the executable runs, unless that component itself accompanies
+the executable.
+
+  It may happen that this requirement contradicts the license
+restrictions of other proprietary libraries that do not normally
+accompany the operating system.  Such a contradiction means you cannot
+use both them and the Library together in an executable that you
+distribute.
+
+  7. You may place library facilities that are a work based on the
+Library side-by-side in a single library together with other library
+facilities not covered by this License, and distribute such a combined
+library, provided that the separate distribution of the work based on
+the Library and of the other library facilities is otherwise
+permitted, and provided that you do these two things:
+
+    a) Accompany the combined library with a copy of the same work
+    based on the Library, uncombined with any other library
+    facilities.  This must be distributed under the terms of the
+    Sections above.
+
+    b) Give prominent notice with the combined library of the fact
+    that part of it is a work based on the Library, and explaining
+    where to find the accompanying uncombined form of the same work.
+
+  8. You may not copy, modify, sublicense, link with, or distribute
+the Library except as expressly provided under this License.  Any
+attempt otherwise to copy, modify, sublicense, link with, or
+distribute the Library is void, and will automatically terminate your
+rights under this License.  However, parties who have received copies,
+or rights, from you under this License will not have their licenses
+terminated so long as such parties remain in full compliance.
+
+  9. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Library or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Library (or any work based on the
+Library), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Library or works based on it.
+
+  10. Each time you redistribute the Library (or any work based on the
+Library), the recipient automatically receives a license from the
+original licensor to copy, distribute, link with or modify the Library
+subject to these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties with
+this License.
+
+  11. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Library at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Library by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Library.
+
+If any portion of this section is held invalid or unenforceable under any
+particular circumstance, the balance of the section is intended to apply,
+and the section as a whole is intended to apply in other circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  12. If the distribution and/or use of the Library is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Library under this License may add
+an explicit geographical distribution limitation excluding those countries,
+so that distribution is permitted only in or among countries not thus
+excluded.  In such case, this License incorporates the limitation as if
+written in the body of this License.
+
+  13. The Free Software Foundation may publish revised and/or new
+versions of the Lesser General Public License from time to time.
+Such new versions will be similar in spirit to the present version,
+but may differ in detail to address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Library
+specifies a version number of this License which applies to it and
+"any later version", you have the option of following the terms and
+conditions either of that version or of any later version published by
+the Free Software Foundation.  If the Library does not specify a
+license version number, you may choose any version ever published by
+the Free Software Foundation.
+
+  14. If you wish to incorporate parts of the Library into other free
+programs whose distribution conditions are incompatible with these,
+write to the author to ask for permission.  For software which is
+copyrighted by the Free Software Foundation, write to the Free
+Software Foundation; we sometimes make exceptions for this.  Our
+decision will be guided by the two goals of preserving the free status
+of all derivatives of our free software and of promoting the sharing
+and reuse of software generally.
+
+			    NO WARRANTY
+
+  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
+OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
+KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
+LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
+AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
+FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
+CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
+LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
+RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
+FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES.
+
+		     END OF TERMS AND CONDITIONS
+
+           How to Apply These Terms to Your New Libraries
+
+  If you develop a new library, and you want it to be of the greatest
+possible use to the public, we recommend making it free software that
+everyone can redistribute and change.  You can do so by permitting
+redistribution under these terms (or, alternatively, under the terms of the
+ordinary General Public License).
+
+  To apply these terms, attach the following notices to the library.  It is
+safest to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least the
+"copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the library's name and a brief idea of what it does.
+    Copyright (C) <year <name of author
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+Also add information on how to contact you by electronic and paper mail.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the library, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the
+  library `Frob' (a library for tweaking knobs) written by James Random Hacker.
+
+  <signature of Ty Coon, 1 April 1990
+  Ty Coon, President of Vice
+
+That's all there is to it!
+```
+
+### Third party libraries under other licenses
+
+#### libyuv
+
+* By: Frank Barchard <fbarchard@google.com
+* Repository: https://chromium.googlesource.com/libyuv/libyuv
+
+Terms of the its own license:
+
+```
+Copyright 2011 The LibYuv Project Authors. All rights reserved.
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+  * Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+  * Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in
+    the documentation and/or other materials provided with the
+    distribution.
+  * Neither the name of Google nor the names of its contributors may
+    be used to endorse or promote products derived from this software
+    without specific prior written permission.
+THIS SOFTWARE IS PROVIDED BY THE 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.
+```
+
+### tinyxml2
+
+* By: Lee Thomason
+* Vesion: 9.0.0
+* Repository: https://github.com/leethomason/tinyxml2
+
+Terms of the its own license (Zlib license):
+
+```
+This software is provided 'as-is', without any express or implied
+warranty. In no event will the authors be held liable for any
+damages arising from the use of this software.
+
+Permission is granted to anyone to use this software for any
+purpose, including commercial applications, and to alter it and
+redistribute it freely, subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must
+not claim that you wrote the original software. If you use this
+software in a product, an acknowledgment in the product documentation
+would be appreciated but is not required.
+
+2. Altered source versions must be plainly marked as such, and
+must not be misrepresented as being the original software.
+
+3. This notice may not be removed or altered from any source
+distribution.
+```
\ No newline at end of file
diff --git a/README.md b/README.md
index d0c3a1ea..8ccaee53 100644
--- a/README.md
+++ b/README.md
@@ -1,2 +1,129 @@
-# OpenOrbbecSDK
-Orbbec SDK Open Source Version.
+# Orbbec SDK dev
+
+## 1. Introduction
+
+This is the open source library of the Orbbec SDK v2.x. The Orbbec SDK is a cross-platform library for interfacing with the Orbbec RGB-D cameras. It provides C/C++ APIs and many other languages or frameworks [wrappers](wrappers/README.md).
+
+<div align=center>
+<img src="docs/resource/Overview.jpg" width="400" align="center" />
+</div>
+
+To enhance performance and accommodate the diverse needs of our customers, the Orbbec SDK has been open source since version 2.0.0. For projects currently utilizing version 1.x of the Orbbec SDK that are considering an upgrade to Orbbec SDK v2.x, we advise using the pre-compiled binaries available in the [Release](https://github.com/orbbec/OrbbecSDK-dev/releases) page. This ensures a seamless transition and maintains consistency with your existing setup.
+
+We have made every effort to maintain backward compatibility with our APIs. However, in pursuit of enhanced performance and an improved user experience, we have made necessary updates. Some interfaces have been removed or altered due to infrequent use or design imperfections. These changes are intended to be minimally disruptive and should not interfere with the standard functionality of the SDK.
+
+For a detailed list of features not available in the current version, please refer to our documentation: [features_not_available_at_v2.x.x](docs/api/features_not_available_at_v2.x.x.md).
+
+Additionally, a comprehensive overview of the API changes from Orbbec SDK v1.x to v2.x.x can be found here: [api_changes_at_v2.x.x](docs/api/api_changes_at_v2.x.x.md).
+
+If you prefer to continue with Orbbec SDK v1.x, you can still access the pre-compiled binaries on our [Orbbec SDK](https://github.com/orbbec/OrbbecSDK) repository. Nonetheless, we encourage you to consider transitioning to Orbbec SDK v2.x. This move will allow you to take advantage of  improved and new features and ensure ongoing support. Our dedication to v2.x is part of a broader strategy aimed at delivering robust long-term support, fostering an open-source community, and driving innovation.
+
+### 1.1 Supported Platforms
+
+- Windows 10 or later: x86 and x64 architectures
+- Linux x64: tested on Ubuntu 20.04, 22.04 and 24.04
+- Linux ARM64: tested on AGX Orin and AGX Xavier
+- Android: coming soon
+- macOS: coming soon
+- Linux ARM32: coming soon
+
+### 1.2 Supported Devices
+
+| **Products List** | **Firmware Version**        |
+|-------------------|-----------------------------|
+| Gemini 335        | 1.2.20                      |
+| Gemini 335L       | 1.2.20                      |
+| Gemini 336        | 1.2.20                      |
+| Gemini 336L       | 1.2.20                      |
+| Gemini 335Lg      | 1.3.46                      |
+| Femto Bolt        | 1.0.6/1.0.9                 |
+| Femto Mega        | 1.1.7/1.2.7                 |
+| Astra 2           | 2.8.20                      |
+| Gemini 2 L        | 1.4.32                      |
+| Gemini 2          | 1.4.60 /1.4.76              |
+
+More devices support will be added in the near future. If you can not find your device in the table above currently, try the version v1.x.y at [Orbbec SDK](https://github.com/orbbec/OrbbecSDK)
+
+## 2. Documentation
+
+*The Orbbec SDK documentation is available on [GitHub Pages](https://orbbec.github.io/OrbbecSDK-dev/).*
+
+### 2.1 Quick Start
+
+If you do not intend to modify the SDK itself, it is recommended to use a pre-compiled distribution. For a comprehensive guide on installing the SDK, setting up your development environment, and developing applications, please consult the [Tutorial](docs/tutorial/installation_and_development_guide.md) section for detailed information.
+
+To explore practical examples and gain insights on utilizing the SDK, please navigate to [Examples](examples/README.md) section for more information.
+
+Orbbec Viewer is an all-in-one graphical user interface (GUI) built on the Orbbec SDK, offering a suite of features including data stream preview, camera configuration, post-processing, and more. To learn how to effectively use the Orbbec Viewer, please refer to the  [Orbbec Viewer User Guide](docs/tutorial/orbbecviewer.md).
+
+### 2.2 API Reference
+
+API Reference: [Orbbec_SDK_API_Reference.html](https://orbbec.github.io/docs/OrbbecSDKv2/index.html)
+
+<!--
+Remove the following as it is not updatded to v2.x.x yet.
+OrbbecSDK C++ API user guide：[orbbecsdk_c++_api_user_guide-v1.0.pdf](docs/api/orbbecsdk_c++_api_user_guide-v1.0.pdf)
+-->
+
+### 2.3 Performance tuning
+
+For different use cases, the SDK can be tuned to achieve optimal performance. Please refer to the [performance tuning guide](docs/tutorial/performance_tuning.md) for more information.
+
+### 2.4 Building from Source
+
+If you would like to modify the SDK itself, you can build the SDK from source. Please refer to the [build guide](docs/tutorial/building_orbbec_sdk.md) for more information.
+
+### 2.5 FAQ
+
+Most frequently asked questions can be found in the [FAQ](docs/FAQ.md) file.
+
+More asked and answered questions can be found in the [issues](https://github.com/orbbec/OrbbecSDK-dev/issues) channel. Use key words for searching may help you find the answer you are looking for.
+
+## 3. Gallery
+
+### 3.1 The QuickStart Example
+
+```c++
+// Create a pipeline.
+ob::Pipeline pipe;
+
+// Start the pipeline with default config.
+pipe.start();
+
+// Create a window for showing the frames, and set the size of the window.
+ob_smpl::CVWindow win("QuickStart", 1280, 720, ob_smpl::ARRANGE_ONE_ROW);
+
+while(win.run()) {
+    // Wait for frameSet from the pipeline, the default timeout is 1000ms.
+    auto frameSet = pipe.waitForFrameset();
+
+    // Push the frames to the window for showing.
+    win.pushFramesToView(frameSet);
+}
+
+// Stop the Pipeline, no frame data will be generated
+pipe.stop();
+```
+
+![QuickStart Example](docs/resource/QuickStart.jpg)
+
+### 3.2 The Orbbec Viewer
+
+![Orbbec Viewer](docs/resource/OrbbecViewer.jpg)
+
+## 4. Contributing
+
+At present, we are focusing our efforts on the internal development of the SDK and are not accepting external contributions for functionality expansion. However, we value your input and are open to reviewing any pull requests or suggestions you might have.
+
+Should you have any questions or concerns, please feel free to reach out to us through the [issues](https://github.com/orbbec/OrbbecSDK-dev/issues) channel.
+
+## 5. License
+
+This project is licensed under the MIT License with some other licenses for third-party libraries and extensions - see the [LICENSE](LICENSE.txt) file for details.
+
+## 6. Links
+
+- [Orbbec SDK V2.x Open Source Library](https://github.com/orbbec/OrbbecSDK-dev)
+- [Orbbec SDK V1.x Pre-Compiled Library](https://github.com/orbbec/OrbbecSDK)
+- [Orbbec Company Main Page](https://www.orbbec.com/)
+- [Orbbec 3D Club](https://3dclub.orbbec3d.com)
diff --git a/cmake/android_config.cmake b/cmake/android_config.cmake
new file mode 100644
index 00000000..bb21078a
--- /dev/null
+++ b/cmake/android_config.cmake
@@ -0,0 +1,21 @@
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+message(STATUS "Setting Android configurations")
+message(STATUS "Prepare ObSensor SDK for Android OS (${ANDROID_NDK_ABI_NAME})")
+
+unset(WIN32)
+unset(UNIX)
+set(OB_BUILD_EXAMPLES OFF)
+set(OB_BUILD_TESTS OFF)
+set(ANDROID_STL "c++_static")
+
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS}   -fPIC -pedantic -g -D_DEFAULT_SOURCE -fpermissive")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fPIC -pedantic -g -Wno-missing-field-initializers")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-switch -Wno-multichar  -Wno-narrowing -fpermissive")
+set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fPIE -pie")
+
+set(OB_BUILD_ANDROID ON)
+set(OB_CURRENT_OS "android")
+add_definitions(-DBUILD_ANDROID)
+
diff --git a/cmake/compiler_flags.cmake b/cmake/compiler_flags.cmake
new file mode 100644
index 00000000..2764b091
--- /dev/null
+++ b/cmake/compiler_flags.cmake
@@ -0,0 +1,63 @@
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+if (NOT ("${CMAKE_C_COMPILER_ID}" STREQUAL "${CMAKE_CXX_COMPILER_ID}"))
+    message(FATAL_ERROR "C compiler (${CMAKE_C_COMPILER_ID}) does not match C++ compiler (${CMAKE_CXX_COMPILER_ID})")
+endif()
+
+if ("${CMAKE_C_COMPILER_ID}" STREQUAL "Clang" OR "${CMAKE_C_COMPILER_ID}" STREQUAL "AppleClang")
+    set(CLANG_ALL_WARNINGS "-Weverything")
+    list(APPEND CLANG_ALL_WARNINGS "-Wno-missing-field-initializers") # Allow c structs without all fields initialized
+    list(APPEND CLANG_ALL_WARNINGS "-Wno-reserved-id-macro") # Needed for azure-c-shared-utility which defines new macros that start with "_"
+    list(APPEND CLANG_ALL_WARNINGS "-Wno-gnu-zero-variadic-macro-arguments") # Needed too allow variadic macros with zero args
+    list(APPEND CLANG_ALL_WARNINGS "-Wno-extra-semi") # Allow for multiple semi-colons in a row
+    list(APPEND CLANG_ALL_WARNINGS "-Wno-c++98-compat-pedantic") # Allow commas on the last enum value
+    list(APPEND CLANG_ALL_WARNINGS "-Wno-padded") # Do not warn about inserted padding to structs
+    list(APPEND CLANG_ALL_WARNINGS "-Wno-switch-enum") # Do not warn about missing case statements in enums
+    list(APPEND CLANG_ALL_WARNINGS "-Wno-old-style-cast") # Allow old style c casts
+    list(APPEND CLANG_ALL_WARNINGS "-Wno-global-constructors") # Allow global constructors. Needed for gtest
+    list(APPEND CLANG_ALL_WARNINGS "-Wno-newline-eof") # Allow no newline at eof. Needed for azure-c-utility
+    list(APPEND CLANG_ALL_WARNINGS "-Wno-exit-time-destructors") # Allow exit time destructors. Needed for spdlog
+    list(APPEND CLANG_ALL_WARNINGS "-Wno-weak-vtables") # Allow weak vtables. Needed for spdlog
+    list(APPEND CLANG_ALL_WARNINGS "-Wno-undef") # Allow undefined macros. Needed for azure-c-shared-utility
+    list(APPEND CLANG_ALL_WARNINGS "-Wno-disabled-macro-expansion") # Allow recursive macro expansion
+    list(APPEND CLANG_ALL_WARNINGS "-Wno-documentation-unknown-command") # Allow undocumented documentation commands used by doxygen
+    list(APPEND CLANG_ALL_WARNINGS "-Wno-covered-switch-default") # Allow default: in switch statements that cover all enum values
+    list(APPEND CLANG_ALL_WARNINGS "-Wno-unreachable-code-break") # Allow break even if it is unreachable
+    list(APPEND CLANG_ALL_WARNINGS "-Wno-double-promotion") # Allow floats to be promoted to doubles. Needed for isnan() on some systems
+    if (NOT (${CMAKE_CXX_COMPILER_VERSION} VERSION_LESS "5.0.0"))
+        # Added in clang 5
+        list(APPEND CLANG_ALL_WARNINGS "-Wno-zero-as-null-pointer-constant") # Allow zero as nullptr
+    endif()
+    if (NOT (${CMAKE_CXX_COMPILER_VERSION} VERSION_LESS "8.0.0"))
+        # Added in clang 8
+        list(APPEND CLANG_ALL_WARNINGS "-Wno-extra-semi-stmt") # Allow semi-colons to be used after #define's
+        list(APPEND CLANG_ALL_WARNINGS "-Wno-atomic-implicit-seq-cst") # Allow use of __sync_add_and_fetch() atomic
+    endif()
+    if(NOT "${CMAKE_C_COMPILER_ID}" STREQUAL "AppleClang")
+        set(CLANG_WARNINGS_AS_ERRORS "-Werror")
+    endif()
+    add_compile_options(${CLANG_ALL_WARNINGS})
+    add_compile_options(${CLANG_WARNINGS_AS_ERRORS})
+elseif ("${CMAKE_C_COMPILER_ID}" STREQUAL "GNU")
+    set(GNU_ALL_WARNINGS "-Wall" "-Wextra")
+    list(APPEND GNU_ALL_WARNINGS "-Wno-missing-field-initializers") # Allow c structs without all fields initialized
+    set(GNU_WARNINGS_AS_ERRORS "-Werror")
+    add_compile_options(${GNU_ALL_WARNINGS})
+    add_compile_options(${GNU_WARNINGS_AS_ERRORS})
+elseif ("${CMAKE_C_COMPILER_ID}" STREQUAL "MSVC")
+    set(MSVC_ALL_WARNINGS "/W4" "/wd4200") #Note: allow zero length arrays
+    set(MSVC_WARNINGS_AS_ERRORS "/WX")
+    string(REGEX REPLACE " /W[0-4]" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+    string(REGEX REPLACE " /W[0-4]" "" CMAKE_C_FLAGS "${CMAKE_C_FLAGS}")
+    add_compile_options(${MSVC_ALL_WARNINGS})
+    add_compile_options(${MSVC_WARNINGS_AS_ERRORS})
+else()
+    message(FATAL_ERROR "Unknown C++ compiler: ${CMAKE_CXX_COMPILER_ID}")
+endif()
+
+if(CMAKE_BUILD_TYPE STREQUAL "Debug")
+    add_definitions(-DOB_DEBUG)
+else()
+    add_definitions(-DOB_RELEASE)
+endif()
diff --git a/cmake/global_config.cmake b/cmake/global_config.cmake
new file mode 100644
index 00000000..865f9aae
--- /dev/null
+++ b/cmake/global_config.cmake
@@ -0,0 +1,39 @@
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+set_property(GLOBAL PROPERTY USE_FOLDERS ON)
+
+# set default build type to Release if not specified
+if(NOT CMAKE_BUILD_TYPE)
+    set(CMAKE_BUILD_TYPE "Release")
+endif()
+
+if(OB_IS_MAIN_PROJECT)
+    # output directories
+    string(TOLOWER ${CMAKE_BUILD_TYPE} OB_BUILD_TYPE)
+    set(OB_OUTPUT_DIRECTORY_ROOT ${CMAKE_BINARY_DIR}/${OB_CURRENT_OS})
+    set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${OB_OUTPUT_DIRECTORY_ROOT}/lib)
+    set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${OB_OUTPUT_DIRECTORY_ROOT}/lib)
+    set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${OB_OUTPUT_DIRECTORY_ROOT}/bin)
+    if(MSVC)
+        set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_DEBUG "${CMAKE_BINARY_DIR}/${OB_CURRENT_OS}/bin")
+        set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_RELEASE "${CMAKE_BINARY_DIR}/${OB_CURRENT_OS}/bin")
+        set(CMAKE_LIBRARY_OUTPUT_DIRECTORY_DEBUG "${CMAKE_BINARY_DIR}/${OB_CURRENT_OS}/lib")
+        set(CMAKE_LIBRARY_OUTPUT_DIRECTORY_RELEASE "${CMAKE_BINARY_DIR}/${OB_CURRENT_OS}/lib")
+        set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY_DEBUG "${CMAKE_BINARY_DIR}/${OB_CURRENT_OS}/lib")
+        set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY_RELEASE "${CMAKE_BINARY_DIR}/${OB_CURRENT_OS}/lib")
+    endif()
+
+    # set install prefix to binary directory if not specified
+    if(CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT)
+        set(CMAKE_INSTALL_PREFIX
+            ${CMAKE_BINARY_DIR}/install
+            CACHE PATH "default install path" FORCE)
+    endif()
+    if(OB_ENABLE_CLANG_TIDY)
+        find_program(CLANG_TIDY_EXE NAMES "clang-tidy" QUIET)
+        if(CLANG_TIDY_EXE)
+            set(CMAKE_CXX_CLANG_TIDY "${CLANG_TIDY_EXE}")
+        endif()
+    endif()
+endif()
diff --git a/cmake/linux_config.cmake b/cmake/linux_config.cmake
new file mode 100644
index 00000000..521a339b
--- /dev/null
+++ b/cmake/linux_config.cmake
@@ -0,0 +1,94 @@
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+message(STATUS "Setting Linux configurations")
+
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS}   -Wl,-Bsymbolic -fPIC -pedantic -D_DEFAULT_SOURCE -fvisibility=hidden")
+set(CMAKE_CXX_FLAGS
+    "${CMAKE_CXX_FLAGS}  -Wl,-Bsymbolic -fPIC -pedantic -Wno-missing-field-initializers -fpermissive -fvisibility=hidden"
+)
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}  -Wno-switch -Wno-multichar -Wsequence-point -Wformat -Wformat-security")
+set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,--disable-new-dtags")
+
+set(CMAKE_C_VISIBILITY_PRESET hidden)
+set(CMAKE_CXX_VISIBILITY_PRESET hidden)
+set(CMAKE_VISIBILITY_INLINES_HIDDEN 1)
+
+if(OB_ENABLE_SANITIZER)
+    set(SANITIZER_FLAGS "-fsanitize=address -static-libasan ")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${SANITIZER_FLAGS}")
+
+    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${SANITIZER_FLAGS}")
+    set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} ${SANITIZER_FLAGS}")
+endif()
+
+execute_process(COMMAND uname -r OUTPUT_VARIABLE UNAME_RESULT OUTPUT_STRIP_TRAILING_WHITESPACE)
+message(-- " Kernel version: " ${UNAME_RESULT})
+string(REGEX MATCH "[0-9]+.[0-9]+" LINUX_KERNEL_VERSION ${UNAME_RESULT})
+message(STATUS "linux version ${LINUX_KERNEL_VERSION}")
+
+set(OB_CURRENT_OS "linux_x86_64")
+
+execute_process(COMMAND uname -m OUTPUT_VARIABLE MACHINES)
+execute_process(COMMAND getconf LONG_BIT OUTPUT_VARIABLE MACHINES_BIT)
+if((${MACHINES} MATCHES "x86_64") AND (${MACHINES_BIT} MATCHES "64"))
+    set(OB_CURRENT_OS "linux_x86_64")
+elseif(${MACHINES} MATCHES "arm")
+    set(OB_BUILD_LINUX_ARM32 ON)
+elseif((${MACHINES} MATCHES "aarch64") AND (${MACHINES_BIT} MATCHES "64"))
+    set(OB_BUILD_LINUX_ARM64 ON)
+elseif((${MACHINES} MATCHES "aarch64") AND (${MACHINES_BIT} MATCHES "32"))
+    set(OB_BUILD_LINUX_ARM32 ON)
+endif()
+
+execute_process(COMMAND ${CMAKE_C_COMPILER} -dumpmachine OUTPUT_VARIABLE MACHINE)
+
+if(OB_BUILD_LINUX_ARM64)
+    if(${MACHINE} MATCHES "aarch64-linux-gnu")
+        add_definitions(-DOS_ARM)
+        add_definitions(-DOS_ARM64)
+        set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS}  -Wl,--allow-shlib-undefined -mstrict-align -ftree-vectorize")
+
+        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wl,--allow-shlib-undefined -mstrict-align -ftree-vectorize")
+
+        set(OB_CURRENT_OS "linux_arm64")
+    else()
+        message(SEND_ERROR "Obsensor: check aarch64-linux-gnu not found!!!")
+    endif(${MACHINE} MATCHES "aarch64-linux-gnu")
+endif()
+
+if(OB_BUILD_LINUX_ARM32)
+    if(${MACHINE} MATCHES "arm-linux-gnueabihf")
+        add_definitions(-DOS_ARM)
+        add_definitions(-DOS_ARM32)
+        set(CMAKE_C_FLAGS
+            "${CMAKE_C_FLAGS}  -Wl,--allow-shlib-undefined -mfpu=neon -mfloat-abi=hard -ftree-vectorize -latomic -std=c99"
+        )
+        set(CMAKE_CXX_FLAGS
+            "${CMAKE_CXX_FLAGS} -Wl,--allow-shlib-undefined -mfpu=neon -mfloat-abi=hard -ftree-vectorize -latomic"
+        )
+        set(OB_CURRENT_OS "linux_arm32")
+    else()
+        message(SEND_ERROR "Obsensor: check arm-linux-gnueabihf not found!!!")
+    endif()
+endif()
+
+if(OB_BUILD_LINUX_ARM64 OR OB_BUILD_LINUX_ARM32)
+    message("linux set neon")
+    add_definitions(-D__NEON__)
+else()
+    message("linux set sse3")
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -msse3")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -msse3")
+endif()
+
+add_definitions(-DOS_LINUX)
+set(OB_BUILD_LINUX ON)
+
+# target rpath settings
+set(CMAKE_SKIP_BUILD_RPATH FALSE)
+set(CMAKE_BUILD_WITH_INSTALL_RPATH FALSE)
+set(CMAKE_SKIP_INSTALL_RPATH FALSE)
+set(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE)
+set(CMAKE_INSTALL_RPATH "$ORIGIN:../lib:${CMAKE_INSTALL_RPATH}")
+
diff --git a/cmake/macos_config.cmake b/cmake/macos_config.cmake
new file mode 100644
index 00000000..fe1506cc
--- /dev/null
+++ b/cmake/macos_config.cmake
@@ -0,0 +1,48 @@
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+message(STATUS "Setting Apple configurations")
+
+# set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}  -Wl,-pedantic -g
+# -Wno-missing-field-initializers -fpermissive -fvisibility=hidden")
+
+# string(REPLACE "-O3" "-O0" CMAKE_CXX_FLAGS_RELEASE
+# "${CMAKE_CXX_FLAGS_RELEASE}")
+set(CMAKE_C_VISIBILITY_PRESET hidden)
+set(CMAKE_CXX_VISIBILITY_PRESET hidden)
+set(CMAKE_VISIBILITY_INLINES_HIDDEN 1)
+execute_process(
+  COMMAND uname -r
+  OUTPUT_VARIABLE UNAME_RESULT
+  OUTPUT_STRIP_TRAILING_WHITESPACE)
+message(-- " Kernel version: " ${UNAME_RESULT})
+string(REGEX MATCH "[0-9]+.[0-9]+" LINUX_KERNEL_VERSION ${UNAME_RESULT})
+message(STATUS "linux version ${LINUX_KERNEL_VERSION}")
+
+add_definitions(-DOS_MACOS)
+
+if(NOT IOS)
+  if(CMAKE_OSX_ARCHITECTURES STREQUAL "x86_64" OR CMAKE_SYSTEM_PROCESSOR STREQUAL "x86_64")
+    set(CMAKE_OSX_DEPLOYMENT_TARGET 10.15)
+    add_definitions(-DOS_MACOS_X64)
+    set(OB_CURRENT_OS "macos_x64")
+  elseif(CMAKE_OSX_ARCHITECTURES STREQUAL "arm64" OR CMAKE_SYSTEM_PROCESSOR STREQUAL "arm64")
+    set(CMAKE_OSX_DEPLOYMENT_TARGET 11.0)
+    add_definitions(-DOS_MACOS_ARM64)
+    set(OB_CURRENT_OS "macos_arm64")
+  endif()
+else()
+  add_definitions(-DOS_IOS)
+  set(OB_CURRENT_OS "ios")
+endif()
+
+if(${OB_CURRENT_OS} STREQUAL "macos_arm64" )
+  add_definitions(-D__NEON__)
+endif()
+
+execute_process(COMMAND ${CMAKE_C_COMPILER} -dumpmachine
+                OUTPUT_VARIABLE MACHINE)
+
+set(OB_BUILD_MACOS ON)
+set(CMAKE_INSTALL_NAME_DIR "@loader_path")
+
diff --git a/cmake/macro.cmake b/cmake/macro.cmake
new file mode 100644
index 00000000..abb89ec8
--- /dev/null
+++ b/cmake/macro.cmake
@@ -0,0 +1,100 @@
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+macro(ob_print_summary)
+    message(STATUS "")
+    message(STATUS "=================================================================================================")
+    message(STATUS "Build Infomation:")
+    message(STATUS "    Rove Package Version: ${PROJECT_VERSION}")
+    message(STATUS "    CMake ${CMAKE_VERSION} successfully configured using ${CMAKE_GENERATOR} generator")
+    message(STATUS "    Installation target path: ${CMAKE_INSTALL_PREFIX}")
+    message(STATUS "    Building Dynamic Libraries")
+    message(STATUS "    Building Type: ${CMAKE_BUILD_TYPE}")
+    message(STATUS "        - Debug Library Postfix: ${CMAKE_DEBUG_POSTFIX}")
+    message(STATUS "        - Release Library Postfix: ${CMAKE_RELEASE_POSTFIX}")
+    message(STATUS "        - MinSizeRel Library Postfix: ${CMAKE_MINSIZEREL_POSTFIX}")
+    message(STATUS "        - RelWithDebInfo Library Postfix: ${CMAKE_RELWITHDEBINFO_POSTFIX}")
+    message(STATUS "C Complier Flags:")
+    message(STATUS "    C_FLAGS:  =${CMAKE_C_FLAGS}")
+    message(STATUS "    C_FLAGS_DEBUG:=${CMAKE_C_FLAGS_DEBUG}")
+    message(STATUS "    C_FLAGS_RELEASE:=${CMAKE_C_FLAGS_RELEASE}")
+    message(STATUS "    C_FLAGS_MINSIZEREL:=${CMAKE_C_FLAGS_MINSIZEREL}")
+    message(STATUS "    C_FLAGS_RELWITHDEBINFO:=${CMAKE_C_FLAGS_RELWITHDEBINFO}")
+    message(STATUS "C++ Complier Flags:")
+    message(STATUS "    CXX_FLAGS:=${CMAKE_CXX_FLAGS}")
+    message(STATUS "    CXX_FLAGS_DEBUG:=${CMAKE_CXX_FLAGS_DEBUG}")
+    message(STATUS "    CXX_FLAGS_RELEASE:=${CMAKE_CXX_FLAGS_RELEASE}")
+    message(STATUS "    CMAKE_EXE_LINKER_FLAGS_RELEASE:=${CMAKE_EXE_LINKER_FLAGS_RELEASE}")
+    message(STATUS "    CXX_FLAGS_MINSIZEREL:=${CMAKE_CXX_FLAGS_MINSIZEREL}")
+    message(STATUS "    CXX_FLAGS_RELWITHDEBINFO:=${CMAKE_CXX_FLAGS_RELWITHDEBINFO}")
+endmacro()
+
+macro(generate_useful_info BRANCH_NAME COMMIT_HASH CURRENT_TIME PLATFORM PROGRAMMING_LANGUAGE)
+    set(GIT_NAME git)
+    find_program(GIT_COMMAND ${GIT_NAME})
+
+    if(EXISTS ${GIT_COMMAND})
+        execute_process(
+            COMMAND ${GIT_COMMAND} --version
+            WORKING_DIRECTORY ${ORBBEC_SDK_ROOT_DIR}
+            OUTPUT_VARIABLE GIT_VERSION
+            OUTPUT_STRIP_TRAILING_WHITESPACE)
+        message("Found ${GIT_NAME}: ${GIT_COMMAND} (${GIT_VERSION})")
+        execute_process(
+            COMMAND ${GIT_COMMAND} rev-parse --short HEAD
+            WORKING_DIRECTORY ${ORBBEC_SDK_ROOT_DIR}
+            OUTPUT_VARIABLE GIT_COMMIT_HASH
+            OUTPUT_STRIP_TRAILING_WHITESPACE)
+        execute_process(
+            COMMAND ${GIT_COMMAND} rev-parse --abbrev-ref HEAD
+            WORKING_DIRECTORY ${ORBBEC_SDK_ROOT_DIR}
+            OUTPUT_VARIABLE GIT_BRANCH
+            OUTPUT_STRIP_TRAILING_WHITESPACE)
+    else()
+        message(FATAL_ERROR "Command ${GIT_NAME} cannot be found, so could not obtain GIT_BRANCH and GIT_COMMIT_HASH informations.")
+    endif()
+
+    string(TIMESTAMP TIME "%Y%m%d")
+    set(${BRANCH_NAME} "alpha")
+
+    if(${GIT_BRANCH} MATCHES "beta" OR ${GIT_BRANCH} MATCHES "Beta")
+        set(${BRANCH_NAME} "beta")
+    elseif(${GIT_BRANCH} MATCHES "master" OR ${GIT_BRANCH} MATCHES "Master")
+        set(${BRANCH_NAME} "release")
+    endif()
+
+    set(${COMMIT_HASH} ${GIT_COMMIT_HASH})
+    set(${CURRENT_TIME} ${TIME})
+
+    set(${PLATFORM} ${OB_CURRENT_OS})
+    set(${PROGRAMMING_LANGUAGE} "C_C++")
+
+    if(${OB_CURRENT_OS} STREQUAL "linux")
+        set(${PLATFORM} "${OB_CURRENT_OS}_x64")
+    endif()
+endmacro()
+
+macro(ob_source_group target)
+    get_target_property(LBS_FILES ${target} SOURCES)
+
+    list(APPEND LBS_HEADERS ${LBS_FILES})
+    list(APPEND LBS_SOURCES ${LBS_FILES})
+    list(FILTER LBS_HEADERS INCLUDE REGEX ".\\.h$|.\\.hpp$|.\\.def$|.\\.cuh$")
+    list(FILTER LBS_SOURCES INCLUDE REGEX ".\\.c$|.\\.cpp$|.\\.cc$|.\\.cu$")
+
+    foreach(_file IN ITEMS ${LBS_HEADERS})
+        string(REPLACE ${CMAKE_CURRENT_SOURCE_DIR}/ "" _relative_file ${_file})
+        get_filename_component(_file_path "${_relative_file}" PATH)
+        string(REPLACE "/" "\\" _file_path_msvc "${_file_path}")
+        source_group("${_file_path_msvc}" FILES "${_relative_file}")
+    endforeach()
+
+    foreach(_file IN ITEMS ${LBS_SOURCES})
+        string(REPLACE ${CMAKE_CURRENT_SOURCE_DIR}/ "" _relative_file ${_file})
+        get_filename_component(_file_path "${_relative_file}" PATH)
+        message(STATUS "file path: ${_file_path}:${_relative_file}")
+        string(REPLACE "/" "\\" _file_path_msvc "${_file_path}")
+        source_group("${_file_path_msvc}" FILES "${_relative_file}")
+    endforeach()
+endmacro()
+
diff --git a/cmake/options.cmake b/cmake/options.cmake
new file mode 100644
index 00000000..6a656d9f
--- /dev/null
+++ b/cmake/options.cmake
@@ -0,0 +1,39 @@
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+# target options
+option(OB_BUILD_EXAMPLES "Build SDK examples" ON)
+option(OB_BUILD_TESTS "Build tests" OFF)
+option(OB_BUILD_TOOLS "Build tools" OFF)
+option(OB_BUILD_DOCS "Build api document and install doc" ON)
+
+# platform options
+option(OB_BUILD_ANDROID "Build Android " OFF)
+
+# platform abstract layer options
+option(OB_BUILD_USB_PAL "Enable this to support USB/UVC/HID communication" ON)
+option(OB_BUILD_NET_PAL "Enable this to support network/GVCP/RTSP communication" ON)
+option(OB_BUILD_GMSL_PAL "Enable this to support GMSL communication" ON)
+
+# install options
+option(OB_INSTALL_EXAMPLES_SOURCE "Install SDK examples source files" ON)
+option(OB_INSTALL_FILTER_DEV_HEADERS "Install HEADER files for filter development" OFF)
+
+option(OB_ENABLE_SANITIZER "Enable sanitizer options" OFF)
+option(OB_ENABLE_CLANG_TIDY "Enable clang-tidy" OFF)
+
+if(OB_BUILD_USB_PAL)
+    add_definitions(-DBUILD_USB_PAL)
+endif()
+
+if(OB_BUILD_NET_PAL)
+    add_definitions(-DBUILD_NET_PAL)
+endif()
+
+if(OB_BUILD_GMSL_PAL)
+    if(NOT OB_BUILD_USB_PAL)
+        message(FATAL_ERROR "GMSL PAL requires USB PAL to be enabled")
+    endif()
+    add_definitions(-DBUILD_GMSL_PAL)
+endif()
+
diff --git a/cmake/windows_config.cmake b/cmake/windows_config.cmake
new file mode 100644
index 00000000..b169af37
--- /dev/null
+++ b/cmake/windows_config.cmake
@@ -0,0 +1,34 @@
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+message(STATUS "Setting Windows configurations")
+
+if(CMAKE_SIZEOF_VOID_P EQUAL 8)
+    set(OB_CURRENT_OS "win_x64")
+elseif(CMAKE_SIZEOF_VOID_P EQUAL 4)
+    set(OB_CURRENT_OS "win_x86")
+endif()
+
+message(${CMAKE_SYSTEM_VERSION})
+
+# Check for Windows Version ##
+if(${CMAKE_SYSTEM_VERSION} EQUAL 6.1) # Windows 7
+    message(FATAL_ERROR "CMAKE_SYSTEM_VERSION=${CMAKE_SYSTEM_VERSION} too lower!")
+endif()
+
+if(MSVC)
+    # build with multiple cores
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /MP /bigobj /wd4819")
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /MP")
+    # set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /NODEFAULTLIB:LIBCMTD")
+    set(LBS_TRY_USE_AVX true)
+
+    SET(OBSENSOR_DEPENTENCIES_INCLUDE_DIR
+    ${DepthEngine_INCLUDE_DIRS}
+       )
+    add_definitions(-D_UNICODE -DUNICODE -D_CRT_SECURE_NO_WARNINGS)
+endif()
+set(OB_BUILD_WIN32 ON)
+
+
+
diff --git a/docs/CMakeLists.txt b/docs/CMakeLists.txt
new file mode 100644
index 00000000..e78f2036
--- /dev/null
+++ b/docs/CMakeLists.txt
@@ -0,0 +1,9 @@
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+#  minimum required cmake version: 3.1.15 support vs2019
+
+cmake_minimum_required(VERSION 3.1.15)
+project(docs)
+
+add_subdirectory(api)
diff --git a/docs/FAQ.md b/docs/FAQ.md
new file mode 100644
index 00000000..f62734d5
--- /dev/null
+++ b/docs/FAQ.md
@@ -0,0 +1,22 @@
+# Frequently Asked Questions
+
+## 1. No Data Stream from Multiple Cameras
+
+**Insufficient Power Supply**:
+
+- Ensure that all cameras are not connected to the same hub.
+- Use a powered hub to provide sufficient power to each camera.
+
+**High Resolution**:
+
+- Try lowering the resolution to resolve data stream issues.
+
+**Increase usbfs_memory_mb Value**:
+
+- Increase the `usbfs_memory_mb` value to 128MB by running the following command:
+
+    ```bash
+    echo 128 | sudo tee /sys/module/usbcore/parameters/usbfs_memory_mb
+    ```
+
+- For making this change permanent, check [this link](https://github.com/OpenKinect/libfreenect2/issues/807).
diff --git a/docs/api/.gitignore b/docs/api/.gitignore
new file mode 100644
index 00000000..f229f069
--- /dev/null
+++ b/docs/api/.gitignore
@@ -0,0 +1,2 @@
+Doxyfile
+Doxyfile_CN
diff --git a/docs/api/CMakeLists.txt b/docs/api/CMakeLists.txt
new file mode 100644
index 00000000..56d9d825
--- /dev/null
+++ b/docs/api/CMakeLists.txt
@@ -0,0 +1,47 @@
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+#[[ minimum required cmake version: 3.1.15 support vs2019
+    This file is for building html.
+    Requirements for win10:
+        Python3 Doxygen graphviz Sphinx breathe
+        download Doxygen at https://sourceforge.net/projects/doxygen/files/latest/download
+        download graphviz at http://www.graphviz.org/download/
+        pip3 install Sphinx breathe
+]]
+
+cmake_minimum_required(VERSION 3.1.15)
+
+project(ObsensorApi)
+
+set(OB_VERSION_STRING ${CMAKE_PROJECT_VERSION})
+option(BUILD_SPHINX_DOC "build Sphinx documentation" OFF)
+find_package(Doxygen)
+message("Doxygen_FOUND: ${Doxygen_FOUND}")
+
+if(Doxygen_FOUND)
+    configure_file(${CMAKE_CURRENT_SOURCE_DIR}/Doxyfile.in ${CMAKE_CURRENT_SOURCE_DIR}/Doxyfile)
+    #configure_file(${CMAKE_CURRENT_SOURCE_DIR}/Doxyfile_CN.in ${CMAKE_CURRENT_SOURCE_DIR}/Doxyfile_CN)
+	file(MAKE_DIRECTORY  ${CMAKE_BINARY_DIR}/doc/)
+	set(OB_SDK_VERSION ${OB_VERSION_STRING})
+	add_custom_target(api_reference_en ALL
+	COMMAND ${DOXYGEN_EXECUTABLE} Doxyfile
+	WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+	COMMENT "Generating English version API Reference documentation with Doxygen"
+	VERBATIM)
+
+	# add_custom_target(api_reference_cn ALL
+	# COMMAND ${DOXYGEN_EXECUTABLE} Doxyfile_CN
+	# WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+	# COMMENT "Generating Chinese version API Reference documentation with Doxygen"
+	# VERBATIM)
+
+	IF(USE_PROJECT_FOLDERS)
+		set_target_properties (api_reference_en PROPERTIES FOLDER "${CMAKE_BINARY_DIR}/Doc")
+		#set_target_properties (api_reference_cn PROPERTIES FOLDER "Doc")
+	ENDIF()
+
+	#INSTALL(DIRECTORY ${CMAKE_BINARY_DIR}/api DESTINATION "${CMAKE_BINARY_DIR}/Doc")
+	INSTALL(DIRECTORY ${CMAKE_BINARY_DIR}/doc DESTINATION shared)
+endif()
+
diff --git a/docs/api/Doxyfile.in b/docs/api/Doxyfile.in
new file mode 100644
index 00000000..4b3c49e7
--- /dev/null
+++ b/docs/api/Doxyfile.in
@@ -0,0 +1,2769 @@
+# Doxyfile 1.9.5
+
+# 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 (\" \").
+#
+# Note:
+#
+# Use doxygen to compare the used configuration file with the template
+# configuration file:
+# doxygen -x [configFile]
+# Use doxygen to compare the used configuration file with the template
+# configuration file without replacing the environment variables or CMake type
+# replacement variables:
+# doxygen -x_noenv [configFile]
+
+#---------------------------------------------------------------------------
+# 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           = OrbbecSDK
+
+# 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         = @OB_VERSION_STRING@
+
+# 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          = "OrbbecSDK: Software-Development-Kit for Orbbec 3D Cameras"
+
+# 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           = ./orbbec_icon.png
+
+# 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_BINARY_DIR@/doc
+
+# If the CREATE_SUBDIRS tag is set to YES then doxygen will create up to 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. Adapt CREATE_SUBDIRS_LEVEL to
+# control the number of sub-directories.
+# The default value is: NO.
+
+CREATE_SUBDIRS         = NO
+
+# Controls the number of sub-directories that will be created when
+# CREATE_SUBDIRS tag is set to YES. Level 0 represents 16 directories, and every
+# level increment doubles the number of directories, resulting in 4096
+# directories at level 8 which is the default and also the maximum value. The
+# sub-directories are organized in 2 levels, the first level always has a fixed
+# numer of 16 directories.
+# Minimum value: 0, maximum value: 8, default value: 8.
+# This tag requires that the tag CREATE_SUBDIRS is set to YES.
+
+CREATE_SUBDIRS_LEVEL   = 8
+
+# 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, Bulgarian,
+# Catalan, Chinese, Chinese-Traditional, Croatian, Czech, Danish, Dutch, English
+# (United States), Esperanto, Farsi (Persian), Finnish, French, German, Greek,
+# Hindi, 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        =
+
+# 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      = NO
+
+# 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:^^"
+# 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:". Note that you cannot 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  = NO
+
+# 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++, Lex, 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 of 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 effectively 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 = NO
+
+# 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 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.
+# Possible values are: SYSTEM, NO and YES.
+# The default value is: SYSTEM.
+
+CASE_SENSE_NAMES       = SYSTEM
+
+# 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_HEADERFILE tag is set to YES then the documentation for a class
+# will show which file needs to be included to use the class.
+# The default value is: YES.
+
+SHOW_HEADERFILE        = YES
+
+# 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       = NO
+
+# 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      = NO
+
+# 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      = NO
+
+# 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       = NO
+
+# 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. See also section "Changing the
+# layout of pages" for information.
+#
+# 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                  = NO
+
+# 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 documenting some parameters in
+# a documented function twice, or documenting parameters that don't exist or
+# using markup commands wrongly.
+# The default value is: YES.
+
+WARN_IF_DOC_ERROR      = YES
+
+# If WARN_IF_INCOMPLETE_DOC is set to YES, doxygen will warn about incomplete
+# function parameter documentation. If set to NO, doxygen will accept that some
+# parameters have no documentation without warning.
+# The default value is: YES.
+
+WARN_IF_INCOMPLETE_DOC = 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 parameter
+# documentation, but not about the absence of documentation. If EXTRACT_ALL is
+# set to YES then this flag will automatically be disabled. See also
+# WARN_IF_INCOMPLETE_DOC
+# 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)
+# See also: WARN_LINE_FORMAT
+# The default value is: $file:$line: $text.
+
+WARN_FORMAT            = "$file:$line: $text"
+
+# In the $text part of the WARN_FORMAT command it is possible that a reference
+# to a more specific place is given. To make it easier to jump to this place
+# (outside of doxygen) the user can define a custom "cut" / "paste" string.
+# Example:
+# WARN_LINE_FORMAT = "'vi $file +$line'"
+# See also: WARN_FORMAT
+# The default value is: at line $line of file $file.
+
+WARN_LINE_FORMAT       = "at line $line of file $file"
+
+# 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). In case the file specified cannot be opened for writing the
+# warning and error messages are written to standard error. When as file - is
+# specified the warning and error messages are written to standard output
+# (stdout).
+
+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                  = ../../include
+
+# 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.
+# See also: INPUT_FILE_ENCODING
+# The default value is: UTF-8.
+
+INPUT_ENCODING         = UTF-8
+
+# This tag can be used to specify the character encoding of the source files
+# that doxygen parses The INPUT_FILE_ENCODING tag can be used to specify
+# character encoding on a per file pattern basis. Doxygen will compare the file
+# name with each pattern and apply the encoding instead of the default
+# INPUT_ENCODING) if there is a match. The character encodings are a list of the
+# form: pattern=encoding (like *.php=ISO-8859-1). See cfg_input_encoding
+# "INPUT_ENCODING" for further information on supported encodings.
+
+INPUT_FILE_ENCODING    =
+
+# 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++, *.l, *.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++ \
+                         *.l \
+                         *.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              = YES
+
+# 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                = ../../include/libobsensor/internal
+
+# 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,
+# ANamespace::AClass, 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 doxygen will use the data processed and written to standard output
+# for further processing, therefore nothing else, like debug statements or used
+# commands (so in case of a Windows batch file always use @echo OFF), should be
+# written to standard output.
+#
+# 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 =
+
+# The Fortran standard specifies that for fixed formatted Fortran code all
+# characters from position 72 are to be considered as comment. A common
+# extension is to allow longer lines before the automatic comment starts. The
+# setting FORTRAN_COMMENT_AFTER will also make it possible that longer lines can
+# be processed before the automatic comment starts.
+# Minimum value: 7, maximum value: 10000, default value: 72.
+
+FORTRAN_COMMENT_AFTER  = 72
+
+#---------------------------------------------------------------------------
+# 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         = YES
+
+# 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 = YES
+
+# 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 the CLANG_ASSISTED_PARSING tag is set to YES 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.
+# This tag requires that the tag CLANG_ASSISTED_PARSING is set to 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            = api
+
+# 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 tag can be used to specify if the generated HTML output
+# should be rendered with a dark or light theme. Default setting AUTO_LIGHT
+# enables light output unless the user preference is dark output. Other options
+# are DARK to always use dark mode, LIGHT to always use light mode, AUTO_DARK to
+# default to dark mode unless the user prefers light mode, and TOGGLE to let the
+# user toggle between dark and light mode via a button.
+# Possible values are: LIGHT Always generate light output., DARK Always generate
+# dark output., AUTO_LIGHT Automatically set the mode according to the user
+# preference, use light mode if no preference is set (the default)., AUTO_DARK
+# Automatically set the mode according to the user preference, use dark mode if
+# no preference is set. and TOGGLE Allow to user to switch between light and
+# dark mode via a button..
+# The default value is: AUTO_LIGHT.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_COLORSTYLE        = AUTO_LIGHT
+
+# 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 color-wheel, 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 gray-scales 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_TIMESTAMP tag is set to YES then the footer of each generated HTML
+# page will contain the date and time when the page was generated. Setting this
+# to YES can help to show when doxygen was last run and thus if the
+# documentation is up to date.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_TIMESTAMP         = YES
+
+# 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  = YES
+
+# 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 determines the URL 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.
+# This tag requires that the tag GENERATE_DOCSET is set to YES.
+
+DOCSET_FEEDURL         =
+
+# 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
+# on Windows. In the beginning of 2021 Microsoft took the original page, with
+# a.o. the download links, offline the HTML help workshop was already many years
+# in maintenance mode). You can download the HTML help workshop from the web
+# archives at Installation executable (see:
+# http://web.archive.org/web/20160201063255/http://download.microsoft.com/downlo
+# ad/0/A/9/0A939EF6-E31C-430F-A3DF-DFAE7960D564/htmlhelp.exe).
+#
+# 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 (see "Fine-tuning the output"). 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
+
+# When both GENERATE_TREEVIEW and DISABLE_INDEX are set to YES, then the
+# FULL_SIDEBAR option determines if the side bar is limited to only the treeview
+# area (value NO) or if it should extend to the full height of the window (value
+# YES). Setting this to YES gives a layout similar to
+# https://docs.readthedocs.io with more room for contents, but less room for the
+# project logo, title, and description. If either GENERATE_TREEVIEW or
+# DISABLE_INDEX is set to NO, this option has no effect.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+FULL_SIDEBAR           = 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 OBFUSCATE_EMAILS tag is set to YES, doxygen will obfuscate email
+# addresses.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+OBFUSCATE_EMAILS       = YES
+
+# 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
+
+# With MATHJAX_VERSION it is possible to specify the MathJax version to be used.
+# Note that the different versions of MathJax have different requirements with
+# regards to the different settings, so it is possible that also other MathJax
+# settings have to be changed when switching between the different MathJax
+# versions.
+# Possible values are: MathJax_2 and MathJax_3.
+# The default value is: MathJax_2.
+# This tag requires that the tag USE_MATHJAX is set to YES.
+
+MATHJAX_VERSION        = MathJax_2
+
+# When MathJax is enabled you can set the default output format to be used for
+# the MathJax output. For more details about the output format see MathJax
+# version 2 (see:
+# http://docs.mathjax.org/en/v2.7-latest/output.html) and MathJax version 3
+# (see:
+# http://docs.mathjax.org/en/latest/web/components/output.html).
+# Possible values are: HTML-CSS (which is slower, but has the best
+# compatibility. This is the name for Mathjax version 2, for MathJax version 3
+# this will be translated into chtml), NativeMML (i.e. MathML. Only supported
+# for NathJax 2. For MathJax version 3 chtml will be used instead.), chtml (This
+# is the name for Mathjax version 3, for MathJax version 2 this will be
+# translated into HTML-CSS) 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:
+# - in case of MathJax version 2: https://cdn.jsdelivr.net/npm/mathjax@2
+# - in case of MathJax version 3: https://cdn.jsdelivr.net/npm/mathjax@3
+# This tag requires that the tag USE_MATHJAX is set to YES.
+
+MATHJAX_RELPATH        =
+
+# The MATHJAX_EXTENSIONS tag can be used to specify one or more MathJax
+# extension names that should be enabled during MathJax rendering. For example
+# for MathJax version 2 (see
+# https://docs.mathjax.org/en/v2.7-latest/tex.html#tex-and-latex-extensions):
+# MATHJAX_EXTENSIONS = TeX/AMSmath TeX/AMSsymbols
+# For example for MathJax version 3 (see
+# http://docs.mathjax.org/en/latest/input/tex/extensions/index.html):
+# MATHJAX_EXTENSIONS = ams
+# 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 user-defined 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. It
+# is highly recommended to start with a default header using
+# doxygen -w latex new_header.tex new_footer.tex new_stylesheet.sty
+# and then modify the file new_header.tex. See also section "Doxygen usage" for
+# information on how to generate the default header that doxygen normally uses.
+#
+# Note: Only use a user-defined header if you know what you are doing!
+# Note: The header is subject to change so you typically have to regenerate the
+# default header when upgrading to a newer version of doxygen. The following
+# commands have a special meaning inside the header (and footer): For a
+# description of the possible markers and block names see the documentation.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_HEADER           =
+
+# The LATEX_FOOTER tag can be used to specify a user-defined 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. See also section "Doxygen
+# usage" for information on how to generate the default footer that doxygen
+# normally uses. 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.
+# 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
+
+# If the LATEX_TIMESTAMP tag is set to YES then the footer of each generated
+# page will contain the date and time when the page was generated. Setting this
+# to NO can help when comparing the output of multiple runs.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_TIMESTAMP        = NO
+
+# 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           = NO
+
+# 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 Sqlite3 output
+#---------------------------------------------------------------------------
+
+#---------------------------------------------------------------------------
+# 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        = NO
+
+# 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     = NO
+
+# 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. Note that the INCLUDE_PATH is not recursive, so the setting of
+# RECURSIVE has no effect here.
+# 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             =
+
+# 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: NO.
+
+HAVE_DOT               = NO
+
+# 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
+
+# DOT_COMMON_ATTR is common attributes for nodes, edges and labels of
+# subgraphs. When you want a differently looking font in the dot files that
+# doxygen generates you can specify fontname, fontcolor and fontsize attributes.
+# For details please see <a href=https://graphviz.org/doc/info/attrs.html>Node,
+# Edge and Graph Attributes specification</a> You need to make sure dot is able
+# to find the font, which can be done by putting it in a standard location or by
+# setting the DOTFONTPATH environment variable or by setting DOT_FONTPATH to the
+# directory containing the font. Default graphviz fontsize is 14.
+# The default value is: fontname=Helvetica,fontsize=10.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_COMMON_ATTR        = "fontname=Helvetica,fontsize=10"
+
+# DOT_EDGE_ATTR is concatenated with DOT_COMMON_ATTR. For elegant style you can
+# add 'arrowhead=open, arrowtail=open, arrowsize=0.5'. <a
+# href=https://graphviz.org/doc/info/arrows.html>Complete documentation about
+# arrows shapes.</a>
+# The default value is: labelfontname=Helvetica,labelfontsize=10.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_EDGE_ATTR          = "labelfontname=Helvetica,labelfontsize=10"
+
+# DOT_NODE_ATTR is concatenated with DOT_COMMON_ATTR. For view without boxes
+# around nodes set 'shape=plain' or 'shape=plaintext' <a
+# href=https://www.graphviz.org/doc/info/shapes.html>Shapes specification</a>
+# The default value is: shape=box,height=0.2,width=0.4.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_NODE_ATTR          = "shape=box,height=0.2,width=0.4"
+
+# You can set the path where dot can find font specified with fontname in
+# DOT_COMMON_ATTR and others dot attributes.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_FONTPATH           =
+
+# If the CLASS_GRAPH tag is set to YES (or GRAPH) then doxygen will generate a
+# graph for each documented class showing the direct and indirect inheritance
+# relations. In case HAVE_DOT is set as well dot will be used to draw the graph,
+# otherwise the built-in generator will be used. If the CLASS_GRAPH tag is set
+# to TEXT the direct and indirect inheritance relations will be shown as texts /
+# links.
+# Possible values are: NO, YES, TEXT and GRAPH.
+# The default value is: 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. See also the chapter Grouping
+# in the manual.
+# 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 DIR_GRAPH_MAX_DEPTH tag can be used to limit the maximum number of levels
+# of child directories generated in directory dependency graphs by dot.
+# Minimum value: 1, maximum value: 25, default value: 1.
+# This tag requires that the tag DIRECTORY_GRAPH is set to YES.
+
+DIR_GRAPH_MAX_DEPTH    = 1
+
+# 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, jpg, gif, 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 or to the filename of jar file
+# to be used. 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.
+# Note: This tag requires that UML_LOOK isn't set, i.e. the doxygen internal
+# graphical representation for inheritance and collaboration diagrams is used.
+# 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 temporary
+# files.
+# The default value is: YES.
+
+DOT_CLEANUP            = YES
diff --git a/docs/api/api_changes_at_v2.x.x.md b/docs/api/api_changes_at_v2.x.x.md
new file mode 100644
index 00000000..d8f0a8f8
--- /dev/null
+++ b/docs/api/api_changes_at_v2.x.x.md
@@ -0,0 +1,74 @@
+# API Changes at v2.x.x
+
+This document outlines the key differences in APIs between OrbbecSDK v2.x and the previous version [OrbbecSDK v1.x](https://github.com/orbbec/OrbbecSDK). The primary areas of change are concentrated within the **device** and **pipeline** modules. We have deprecated or modified certain C and C++ interfaces to accommodate internal enhancements, improved functionality, and to reflect the discontinuation of support for certain devices.
+
+## Device Module
+
+The updates to the **device** module in our APIs primarily involve adjustments to interfaces that were either reserved for internal use or were not commonly utilized by developers.
+
+### Removed C Interfaces
+- ob_device_set_structured_data_ext
+- ob_device_get_structured_data_ext
+- ob_device_set_raw_data
+- ob_device_get_raw_data
+- ob_device_get_protocol_version
+- ob_device_get_cmd_version
+- ob_device_write_ahb
+- ob_device_read_ahb
+- ob_device_write_i2c
+- ob_device_read_i2c
+- ob_device_write_flash
+- ob_device_read_flash
+- ob_device_set_sync_config
+- ob_device_info_usb_type
+- ob_device_send_file_to_destination
+- ob_device_activate_authorization
+- ob_device_write_authorization_code
+- ob_device_load_depth_filter_config
+- ob_device_reset_default_depth_filter_config
+
+### Removed C++ Interfaces
+- writeAHB
+- readAHB
+- writeI2C
+- readI2C
+- writeFlash
+- readFlash
+- writeCustomerData
+- readCustomerData
+- setRawData
+- getRawData
+- setStructuredDataExt
+- getStructuredDataExt
+- getProtocolVersion
+- getCmdVersion
+- sendFile
+- activateAuthorization
+- loadLicense
+- loadLicenseFromData
+- getSyncConfig
+- setSyncConfig
+- sendFile
+- activateAuthorization
+- writeAuthorizationCode
+- loadDepthFilterConfig
+- resetDefaultDepthFilterConfig
+
+## Pipeline Module
+
+The updates to the **pipeline** module in our APIs are primarily focused on the recording and playback functionality, which will be redesigned in upcoming releases. Additionally, other updates to the **pipeline** module are targeted at APIs that were either reserved for internal use or were not commonly utilized by developers.
+
+### Removed C Interfaces
+- ob_create_pipeline_with_playback_file
+- ob_pipeline_get_playback
+- ob_pipeline_start_record
+- ob_pipeline_stop_record
+- ob_get_d2c_valid_area
+- ob_get_d2c_range_valid_area
+
+### Removed C++ Interfaces
+- Pipeline(const char \*filename)
+- getPlayback
+- startRecord
+- stopRecord
+- getD2CValidArea
diff --git a/docs/api/cmake/FindSphinx.cmake b/docs/api/cmake/FindSphinx.cmake
new file mode 100644
index 00000000..78e08aa4
--- /dev/null
+++ b/docs/api/cmake/FindSphinx.cmake
@@ -0,0 +1,14 @@
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+#Look for an executable called sphinx-build
+find_program(SPHINX_EXECUTABLE
+             NAMES sphinx-build
+             DOC "Path to sphinx-build executable")
+
+include(FindPackageHandleStandardArgs)
+
+#Handle standard arguments to find_package like REQUIRED and QUIET
+find_package_handle_standard_args(Sphinx
+                                  "Failed to find sphinx-build executable"
+                                  SPHINX_EXECUTABLE)
diff --git a/docs/api/features_not_available_at_v2.x.x.md b/docs/api/features_not_available_at_v2.x.x.md
new file mode 100644
index 00000000..ee2c1a06
--- /dev/null
+++ b/docs/api/features_not_available_at_v2.x.x.md
@@ -0,0 +1,15 @@
+# Features not available in the current version
+
+## Mirror/Flip/Rotate frames inside SDK or device
+
+In order to reduce coupling and improve performance, OrbbecSDK v2.x will no longer support outputting data frames after mirror/flip/rotate processing, but users can freely handle mirror/flip/rotate in their application by explicitly calling the frame processing filters.
+
+## Recording and playback function
+
+The recording and playback function is temporarily unavaiable and will soon be redesigned and released in a future version of OrbbecSDK v2.x. 
+
+## Firmware upgrade and OrbbecViewer OTA function
+
+The firmware upgrade function is temporarily unavaiable and will soon be redesigned and released in a future version of OrbbecSDK v2.x. Current users need to use OrbbecSDK v1.x and tools based on OrbbecSDK v1.x to upgrade the firmware.
+
+
diff --git a/docs/api/orbbec_icon.png b/docs/api/orbbec_icon.png
new file mode 100644
index 00000000..e392317e
Binary files /dev/null and b/docs/api/orbbec_icon.png differ
diff --git a/docs/api/orbbecsdk_c++_api_user_guide-v1.0.pdf b/docs/api/orbbecsdk_c++_api_user_guide-v1.0.pdf
new file mode 100644
index 00000000..760c7222
Binary files /dev/null and b/docs/api/orbbecsdk_c++_api_user_guide-v1.0.pdf differ
diff --git a/docs/api/sphinx/conf.py b/docs/api/sphinx/conf.py
new file mode 100644
index 00000000..d7dbe42e
--- /dev/null
+++ b/docs/api/sphinx/conf.py
@@ -0,0 +1,68 @@
+# Configuration file for the Sphinx documentation builder.
+#
+# This file only contains a selection of the most common options. For a full
+# list see the documentation:
+# https://www.sphinx-doc.org/en/master/usage/configuration.html
+
+# -- Path setup --------------------------------------------------------------
+
+# If extensions (or modules to document with autodoc) are in another directory,
+# add these directories to sys.path here. If the directory is relative to the
+# documentation root, use os.path.abspath to make it absolute, like shown here.
+#
+# import os
+# import sys
+# sys.path.insert(0, os.path.abspath('.'))
+
+import os
+import sys
+from datetime import date
+sys.path.insert(0, os.path.abspath('.'))
+from furo import *
+
+# -- Project information -----------------------------------------------------
+
+project = 'OrbbecSdk'
+copyright = f"{date.today().year}, Orbbec"
+author = 'Orbbec'
+
+# The full version, including alpha/beta/rc tags
+#release = 'v1.2.6'
+
+
+# -- General configuration ---------------------------------------------------
+
+# Add any Sphinx extension module names here, as strings. They can be
+# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
+# ones.
+extensions = ['sphinx.ext.todo', 'breathe']
+
+# Add any paths that contain templates here, relative to this directory.
+templates_path = ['_templates']
+
+# The language for content autogenerated by Sphinx. Refer to documentation
+# for a list of supported languages.
+#
+# This is also used if you do content translation via gettext catalogs.
+# Usually you set "language" from the command line for these cases.
+#language = 'zh_CN'
+
+# List of patterns, relative to source directory, that match files and
+# directories to ignore when looking for source files.
+# This pattern also affects html_static_path and html_extra_path.
+exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store']
+
+
+# -- Options for HTML output -------------------------------------------------
+
+# The theme to use for HTML and HTML Help pages.  See the documentation for
+# a list of builtin themes.
+#
+html_theme = 'furo'
+html_theme_path = ['furo/theme']
+
+# Add any paths that contain custom static files (such as style sheets) here,
+# relative to this directory. They are copied after the builtin static files,
+# so a file named "default.css" will overwrite the builtin "default.css".
+html_static_path = ['_static']
+breathe_default_project = "OrbbecSdk"
\ No newline at end of file
diff --git a/docs/api/sphinx/furo/__init__.py b/docs/api/sphinx/furo/__init__.py
new file mode 100644
index 00000000..1f93f49d
--- /dev/null
+++ b/docs/api/sphinx/furo/__init__.py
@@ -0,0 +1,273 @@
+"""A clean customisable Sphinx documentation theme."""
+
+__version__ = "2021.03.20.beta31"
+
+import hashlib
+import logging
+from functools import lru_cache
+from pathlib import Path
+from typing import Any, Dict
+
+import pygments
+import sphinx
+from bs4 import BeautifulSoup
+from sphinx.highlighting import PygmentsBridge
+
+from .navigation import get_navigation_tree
+
+THEME_PATH = (Path(__file__).parent / "theme" / "furo").resolve()
+
+logger = logging.getLogger(__name__)
+
+
+@lru_cache(maxsize=None)
+def has_exactly_one_list_item(toc: str) -> bool:
+    """Check if the toc has exactly one list item."""
+    assert toc
+
+    soup = BeautifulSoup(toc, "html.parser")
+    if len(soup.find_all("li")) == 1:
+        return True
+
+    return False
+
+
+def wrap_elements_that_can_get_too_wide(content: str) -> str:
+    """Wrap the elements that could get too wide, with a div to allow controlling width.
+
+    - <table>
+    - [class=math]
+
+    """
+    soup = BeautifulSoup(content, "html.parser")
+
+    for table in soup.find_all("table"):
+        table_wrapper = soup.new_tag("div", attrs={"class": "table-wrapper"})
+        table.replace_with(table_wrapper)
+        table_wrapper.append(table)
+
+    for math in soup.find_all("div", class_="math"):
+        wrapper = soup.new_tag("div", attrs={"class": "math-wrapper"})
+        math.replace_with(wrapper)
+        wrapper.append(math)
+
+    return str(soup)
+
+
+def get_pygments_style_colors(
+    style: pygments.style.Style, *, fallbacks: Dict[str, str]
+) -> Dict[str, str]:
+    """Get background/foreground colors for given pygments style."""
+    background = style.background_color
+    text_colors = style.style_for_token(pygments.token.Text)
+    foreground = text_colors["color"]
+
+    if not background:
+        background = fallbacks["background"]
+
+    if not foreground:
+        foreground = fallbacks["foreground"]
+    else:
+        foreground = f"#{foreground}"
+
+    return {"background": background, "foreground": foreground}
+
+
+@lru_cache(maxsize=2)
+def get_colors_for_codeblocks(
+    highlighter: PygmentsBridge, *, fg: str, bg: str
+) -> Dict[str, str]:
+    """Get background/foreground colors for given pygments style."""
+    return get_pygments_style_colors(
+        highlighter.formatter_args["style"],
+        fallbacks={
+            "foreground": fg,
+            "background": bg,
+        },
+    )
+
+
+def _compute_navigation_tree(context: Dict[str, Any]) -> str:
+    # The navigation tree, generated from the sphinx-provided ToC tree.
+    if "toctree" in context:
+        toctree = context["toctree"]
+        toctree_html = toctree(
+            collapse=False,
+            titles_only=True,
+            maxdepth=-1,
+            includehidden=True,
+        )
+    else:
+        toctree_html = ""
+
+    return get_navigation_tree(toctree_html)
+
+
+def _compute_hide_toc(context: Dict[str, Any]) -> bool:
+    # Should the table of contents be hidden?
+    file_meta = context.get("meta", None) or {}
+    if "hide-toc" in file_meta:
+        return True
+    elif "toc" not in context:
+        return True
+    elif not context["toc"]:
+        return True
+
+    return has_exactly_one_list_item(context["toc"])
+
+
+@lru_cache(maxsize=None)
+def furo_asset_hash(path: str) -> str:
+    """Append a `?digest=` to an url based on the file content."""
+    full_path = THEME_PATH / "static" / path
+    digest = hashlib.sha1(full_path.read_bytes()).hexdigest()
+
+    return f"_static/{path}?digest={digest}"
+
+
+def _html_page_context(
+    app: sphinx.application.Sphinx,
+    pagename: str,
+    templatename: str,
+    context: Dict[str, Any],
+    doctree: Any,
+) -> None:
+    if app.config.html_theme != "furo":
+        return
+
+    # Basic constants
+    context["furo_version"] = __version__
+
+    # Assets
+    context["furo_assets"] = {
+        "furo-extensions.css": furo_asset_hash("styles/furo-extensions.css"),
+        "main.js": furo_asset_hash("scripts/main.js"),
+    }
+
+    # Values computed from page-level context.
+    context["furo_navigation_tree"] = _compute_navigation_tree(context)
+    context["furo_hide_toc"] = _compute_hide_toc(context)
+
+    # Inject information about styles
+    context["furo_pygments"] = {
+        "light": get_colors_for_codeblocks(
+            app.builder.highlighter,
+            fg="black",
+            bg="white",
+        ),
+        "dark": get_colors_for_codeblocks(
+            app.builder.dark_highlighter,
+            fg="white",
+            bg="black",
+        ),
+    }
+
+    # Patch the content
+    if "body" in context:
+        context["body"] = wrap_elements_that_can_get_too_wide(context["body"])
+
+    should_use_own_styles = (
+        # Not using the HTML builders with Furo for some reason?
+        "style" not in context
+        # Did not override Furo's default CSS
+        or context["style"] == "styles/furo.css"
+    )
+    if should_use_own_styles:
+        context["furo_assets"]["style"] = furo_asset_hash("styles/furo.css")
+    else:
+        context["furo_assets"]["style"] = "_static/" + context["style"]
+
+
+def _builder_inited(app: sphinx.application.Sphinx) -> None:
+    if app.config.html_theme != "furo":
+        return
+
+    builder = app.builder
+    assert builder.dark_highlighter is None, "this shouldn't happen."
+
+    # number_of_hours_spent_figuring_this_out = 4
+    #
+    # Hello human in the future! This next block of code needs a bit of a story, and
+    # if you're going to touch it, remember to update the number above (or remove this
+    # comment entirely).
+    #
+    # Hopefully, you know that Sphinx allows extensions and themes to add configuration
+    # values via `app.add_config_value`. This usually lets users set those values from
+    # `conf.py` while allowing the extension to read from it and utilise that information.
+    # As any reasonable person who's written a Sphinx extension before, you would
+    # expect the following to work:
+    #
+    #     dark_style = app.config.pygments_dark_style
+    #
+    # Turns out, no. How dare you expect things to just work!? That stuff just returns
+    # the default value provided when calling `app.add_config_value`. Yes, even if you
+    # set it in `conf.py`. Why? Good question. :)
+    #
+    # The logic in Sphinx literally looks it up in the same mapping as what was
+    # manipulated by `add_config_value`, and there's no other spot where that value
+    # gets manipulated. I spent a bunch of time debugging how that class works, and...
+    # yea, I can't figure it out. There's multiple mappings floating around and bunch
+    # of manipulation being done for all kinds of things.
+    #
+    # The only place on the config object where I was able to find the user-provided
+    # value from `conf.py` is a private variable `self._raw_config`. Those values are
+    # supposed to get added to self.__dict__[...], and generally be accessible through
+    # the object's custom `__getattr__`.
+    #
+    # Anyway, after giving up on figuring out how to file a PR to fix this upstream, I
+    # started looking for hacky ways to get this without reaching into private
+    # variables. That quest led to a very simple conclusion: no, you can't do that.
+    #
+    # So, here we are: with the only option being to reach into the guts of the beast,
+    # and pull out the specific thing that's needed. This is obviously fragile though,
+    # so this is written with the assumption that any changes to Sphinx's config
+    # object's internals would correspond to the originally expected behaviour working.
+    # This is so that when any of Sphinx's internals change, this logic would basically
+    # fall back to the original behaviour and also print a warning, so that hopefully
+    # someone will report this. Maybe it'll all be fixed, and I can remove this whole
+    # hack and this giant comment.
+
+    # HACK: begins here
+    dark_style = None
+    try:
+        if (
+            hasattr(app.config, "_raw_config")
+            and isinstance(app.config._raw_config, dict)
+            and "pygments_dark_style" in app.config._raw_config
+        ):
+            dark_style = app.config._raw_config["pygments_dark_style"]
+    except (AttributeError, KeyError) as e:
+        logger.warn(
+            (
+                "Furo could not determine the value of `pygments_dark_style`. "
+                "Falling back to using the value provided by Sphinx.\n"
+                "Caused by %s"
+            ),
+            e,
+        )
+
+    if dark_style is None:
+        dark_style = app.config.pygments_dark_style
+    # HACK: ends here
+
+    builder.dark_highlighter = PygmentsBridge("html", dark_style)
+
+
+def setup(app: sphinx.application.Sphinx) -> Dict[str, Any]:
+    """Entry point for sphinx theming."""
+    app.require_sphinx("3.0")
+
+    app.add_config_value(
+        "pygments_dark_style", default="native", rebuild="env", types=[str]
+    )
+
+    app.add_html_theme("furo", str(THEME_PATH))
+
+    app.connect("html-page-context", _html_page_context)
+    app.connect("builder-inited", _builder_inited)
+
+    return {
+        "parallel_read_safe": True,
+        "parallel_write_safe": True,
+        "version": __version__,
+    }
diff --git a/docs/api/sphinx/furo/navigation.py b/docs/api/sphinx/furo/navigation.py
new file mode 100644
index 00000000..db330e49
--- /dev/null
+++ b/docs/api/sphinx/furo/navigation.py
@@ -0,0 +1,74 @@
+"""Generate the navigation tree from Sphinx's toctree function's output."""
+
+import functools
+
+from bs4 import BeautifulSoup, Tag
+
+
+def _get_navigation_expand_image(soup: BeautifulSoup) -> Tag:
+    retval = soup.new_tag("i", attrs={"class": "icon"})
+
+    svg_element = soup.new_tag("svg")
+    svg_use_element = soup.new_tag("use", href="#svg-arrow-right")
+    svg_element.append(svg_use_element)
+
+    retval.append(svg_element)
+    return retval
+
+
+@functools.lru_cache(maxsize=None)
+def get_navigation_tree(toctree_html: str) -> str:
+    """Modify the given navigation tree, with furo-specific elements.
+
+    Adds a checkbox + corresponding label to <li>s that contain a <ul> tag, to enable
+    the I-spent-too-much-time-making-this-CSS-only collapsing sidebar tree.
+    """
+    if not toctree_html:
+        return toctree_html
+
+    soup = BeautifulSoup(toctree_html, "html.parser")
+
+    toctree_checkbox_count = 0
+    last_element_with_current = None
+    for element in soup.find_all("li", recursive=True):
+        # We check all "li" elements, to add a "current-page" to the correct li.
+        classes = element.get("class", [])
+        if "current" in classes:
+            last_element_with_current = element
+
+        # Nothing more to do, unless this has "children"
+        if not element.find("ul"):
+            continue
+
+        # Add a class to indicate that this has children.
+        element["class"] = classes + ["has-children"]
+
+        # We're gonna add a checkbox.
+        toctree_checkbox_count += 1
+        checkbox_name = f"toctree-checkbox-{toctree_checkbox_count}"
+
+        # Add the "label" for the checkbox which will get filled.
+        label = soup.new_tag("label", attrs={"for": checkbox_name})
+        label.append(_get_navigation_expand_image(soup))
+        element.insert(1, label)
+
+        # Add the checkbox that's used to store expanded/collapsed state.
+        checkbox = soup.new_tag(
+            "input",
+            attrs={
+                "type": "checkbox",
+                "class": ["toctree-checkbox"],
+                "id": checkbox_name,
+                "name": checkbox_name,
+            },
+        )
+        # if this has a "current" class, be expanded by default (by checking the checkbox)
+        if "current" in classes:
+            checkbox.attrs["checked"] = ""
+
+        element.insert(1, checkbox)
+
+    if last_element_with_current is not None:
+        last_element_with_current["class"].append("current-page")
+
+    return str(soup)
diff --git a/docs/api/sphinx/furo/sphinxext.py b/docs/api/sphinx/furo/sphinxext.py
new file mode 100644
index 00000000..713cee32
--- /dev/null
+++ b/docs/api/sphinx/furo/sphinxext.py
@@ -0,0 +1,95 @@
+"""Sphinx Extensions to simplify writing Furo's Reference documentation.
+
+This provides a single `furo-demo` directive, which:
+
+- Only works when used in a MyST document.
+- Requires sphinx-inline-tabs' tab directive.
+- Requires contents to be of the following format:
+
+    {lines-of-markdown}
+
+    +++
+
+    {lines-of-reStructuredText}
+
+"""
+
+from textwrap import indent
+from typing import Any, Tuple
+
+from docutils import nodes
+from docutils.statemachine import StringList
+from sphinx.application import Sphinx
+from sphinx.directives import SphinxDirective
+
+
+def _split_by_language(block_text: str) -> Tuple[str, str]:
+    try:
+        a, b = block_text.split("+++\n")
+    except ValueError:
+        if block_text.endswith("+++"):
+            return block_text[:-3], ""
+        raise RuntimeError("Expected separator line containing only '+++'.")
+    else:
+        return a, b
+
+
+def _md_demo(block: str) -> StringList:
+    lines = []
+    if not block.strip("\n"):
+        return StringList()
+
+    lines.append("````````{tab} Markdown (MyST)")
+    lines.append("```````md")
+    lines.extend(block.splitlines())
+    lines.append("```````")
+    lines.extend(block.splitlines())
+    lines.append("````````")
+
+    return StringList(lines)
+
+
+def _rst_demo(block: str) -> StringList:
+    lines = []
+    if not block.strip():
+        return StringList()
+
+    lines.append("````````{tab} reStructuredText")
+    lines.append("```````{eval-rst}")
+    lines.append(".. code-block:: rest")
+    lines.append("")
+    lines.extend(indent(block, "    ").splitlines())
+    lines.append("")
+    lines.extend(block.splitlines())
+    lines.append("```````")
+    lines.append("````````")
+
+    return StringList(lines)
+
+
+def _translate_into_tab_demo(block_text: str) -> StringList:
+    md, rst = _split_by_language(block_text)
+
+    string_list = StringList()
+
+    string_list.extend(_rst_demo(rst))
+    string_list.extend(_md_demo(md))
+
+    return string_list
+
+
+class _FuroDemoDirective(SphinxDirective):
+    has_content = True
+
+    def run(self) -> Any:
+        self.assert_has_content()
+
+        container = nodes.container()
+        transated_content = _translate_into_tab_demo(self.block_text)
+        self.state.nested_parse(transated_content, 0, container)
+        return [container]
+
+
+def setup(app: Sphinx) -> None:
+    """For setting up the directive."""
+    app.add_directive("furo-demo", _FuroDemoDirective)
diff --git a/docs/api/sphinx/furo/theme/furo/base.html b/docs/api/sphinx/furo/theme/furo/base.html
new file mode 100644
index 00000000..75ef9240
--- /dev/null
+++ b/docs/api/sphinx/furo/theme/furo/base.html
@@ -0,0 +1,100 @@
+<!doctype html>
+<html class="no-js">
+  <head>
+    {%- block site_meta -%}
+    <meta charset="utf-8"/>
+    <meta name="viewport" content="width=device-width,initial-scale=1"/>
+    <meta name="color-scheme" content="light dark">
+
+    {%- if metatags %}{{ metatags }}{% endif -%}
+
+    {%- block linktags %}
+        {%- if hasdoc('about') -%}
+          <link rel="author" title="{{ _('About these documents') }}" href="{{ pathto('about') }}" />
+        {%- endif -%}
+        {%- if hasdoc('genindex') -%}
+          <link rel="index" title="{{ _('Index') }}" href="{{ pathto('genindex') }}" />
+        {%- endif -%}
+        {%- if hasdoc('search') -%}
+          <link rel="search" title="{{ _('Search') }}" href="{{ pathto('search') }}" />
+        {%- endif -%}
+        {%- if hasdoc('copyright') -%}
+          <link rel="copyright" title="{{ _('Copyright') }}" href="{{ pathto('copyright') }}" />
+        {%- endif -%}
+        {%- if next -%}
+          <link rel="next" title="{{ next.title|striptags|e }}" href="{{ next.link|e }}" />
+        {%- endif -%}
+        {%- if prev -%}
+          <link rel="prev" title="{{ prev.title|striptags|e }}" href="{{ prev.link|e }}" />
+        {%- endif -%}
+    {%- endblock linktags %}
+
+    {# Favicon #}
+    {%- if favicon -%}
+      <link rel="shortcut icon" href="{{ pathto('_static/' + favicon, 1) }}"/>
+    {%- endif -%}
+
+    {#- Generator banner -#}
+    <meta name="generator" content="sphinx-{{ sphinx_version }}, furo {{ furo_version }}"/>
+
+    {%- endblock site_meta -%}
+
+    {#- Site title -#}
+    {%- block htmltitle -%}
+      {% if pagename == master_doc %}
+        <title>{{ _("Home") }} - {{ docstitle|striptags|e }}</title>
+      {% else %}
+        <title>{{ title|striptags|e }} - {{ docstitle|striptags|e }}</title>
+      {% endif %}
+    {%- endblock -%}
+
+    {%- block styles -%}
+
+    {#- Theme-related stylesheets -#}
+    {%- block theme_styles -%}
+    <link rel="stylesheet" href="{{ pathto(furo_assets['style'], 1) }}">
+    <link rel="stylesheet" href="{{ pathto('_static/pygments.css', 1) }}">
+    <link media="(prefers-color-scheme: dark)" rel="stylesheet" href="{{ pathto('_static/pygments_dark.css', 1) }}">
+    {% include "partials/_head_css_variables.html" with context %}
+    {%- endblock -%}
+
+    {# Custom stylesheets #}
+    {%- block regular_styles -%}
+    {%- for path in css_files -%}
+    {% if not path.filename.startswith("pygments_dark") -%}
+      {{ css_tag(path) }}
+    {%- endif %}
+    {% endfor -%}
+    {%- endblock regular_styles -%}
+
+    {%- block extra_styles -%}
+    <link rel="stylesheet" href="{{ pathto(furo_assets['furo-extensions.css'], 1) }}">
+    {%- endblock -%}
+
+    {%- endblock styles -%}
+
+    {#- Custom front matter #}
+    {%- block extrahead -%}{%- endblock -%}
+  </head>
+  <body dir="{{ direction }}">
+    {% block body %}{% endblock %}
+
+    {%- block scripts -%}
+
+    {# Custom JS #}
+    {%- block regular_scripts -%}
+    {# This is *exactly* how `basic` handles this file. #}
+    <script id="documentation_options" data-url_root="{{ pathto('', 1) }}" src="{{ pathto('_static/documentation_options.js', 1) }}"></script>
+    {% for path in script_files -%}
+      {{ js_tag(path) }}
+    {% endfor -%}
+    {%- endblock regular_scripts -%}
+
+    {# Theme-related JavaScript code #}
+    {%- block theme_scripts -%}
+    <script src="{{ pathto(furo_assets['main.js'], 1) }}"></script>
+    {%- endblock -%}
+
+    {%- endblock scripts -%}
+  </body>
+</html>
diff --git a/docs/api/sphinx/furo/theme/furo/domainindex.html b/docs/api/sphinx/furo/theme/furo/domainindex.html
new file mode 100644
index 00000000..f1b7d435
--- /dev/null
+++ b/docs/api/sphinx/furo/theme/furo/domainindex.html
@@ -0,0 +1,10 @@
+{% extends "page.html" %}
+
+{% block content %}
+Hiya!
+
+This page is not currently supported by the Sphinx theme being used by
+this documentation. If you're seeing this, please drop a comment on
+<a href="https://github.com/pradyunsg/furo/issues/50">this issue</a>
+with a link to this page. :)
+{% endblock content %}
diff --git a/docs/api/sphinx/furo/theme/furo/genindex.html b/docs/api/sphinx/furo/theme/furo/genindex.html
new file mode 100644
index 00000000..aba1d9f7
--- /dev/null
+++ b/docs/api/sphinx/furo/theme/furo/genindex.html
@@ -0,0 +1,58 @@
+{% extends "page.html" %}
+
+{% block htmltitle -%}
+  <title>{{ _("Index") }} - {{ docstitle|striptags|e }}</title>
+{% endblock htmltitle -%}
+
+{% macro indexentries(firstname, links) %}
+  {%- if links -%}
+    <a href="{{ links[0][1] }}">
+    {%- if links[0][0] %}<strong>{% endif -%}
+    {{ firstname|e }}
+    {%- if links[0][0] %}</strong>{% endif -%}
+    </a>
+
+    {%- for ismain, link in links[1:] -%}
+      , <a href="{{ link }}">{% if ismain %}<strong>{% endif -%}
+      [{{ loop.index }}]
+      {%- if ismain %}</strong>{% endif -%}
+      </a>
+    {%- endfor %}
+  {%- else %}
+    {{ firstname|e }}
+  {%- endif %}
+{% endmacro %}
+
+{% block content %}
+<section class="genindex-section">
+  <h1 id="index">{{ _('Index') }}</h1>
+  <div class="genindex-jumpbox">
+  {% for key, dummy in genindexentries -%}
+  <a href="#{{ key }}"><strong>{{ key }}</strong></a>
+  {%- if not loop.last %} | {% endif -%}
+  {%- endfor %}
+  </div>
+</section>
+
+{%- for key, entries in genindexentries %}
+<section id="{{ key }}" class="genindex-section">
+  <h2>{{ key }}</h2>
+  <table style="width: 100%" class="indextable genindextable"><tr>
+    {%- for column in entries|slice_index(2) if column %}
+    <td style="width: 33%; vertical-align: top;"><ul>
+      {%- for entryname, (links, subitems, _) in column %}
+        <li>{{ indexentries(entryname, links) }}
+        {%- if subitems %}
+        <ul>
+        {%- for subentryname, subentrylinks in subitems %}
+          <li>{{ indexentries(subentryname, subentrylinks) }}</li>
+        {%- endfor %}
+        </ul>
+        {%- endif -%}</li>
+      {%- endfor %}
+    </ul></td>
+    {%- endfor %}
+  </tr></table>
+</section>
+{% endfor %}
+{% endblock %}
diff --git a/docs/api/sphinx/furo/theme/furo/globaltoc.html b/docs/api/sphinx/furo/theme/furo/globaltoc.html
new file mode 100644
index 00000000..67eda73b
--- /dev/null
+++ b/docs/api/sphinx/furo/theme/furo/globaltoc.html
@@ -0,0 +1,4 @@
+You are using <code>globaltoc.html</code> in <code>html_sidebars</code>. This
+configuration does not work with Furo, which is why you're seeing this message.
+Please see <a href="https://pradyunsg.me/furo/customisation/sidebar/">
+documentation on sidebar customisation in Furo</a> for more details.
diff --git a/docs/api/sphinx/furo/theme/furo/layout.html b/docs/api/sphinx/furo/theme/furo/layout.html
new file mode 100644
index 00000000..b6ba5454
--- /dev/null
+++ b/docs/api/sphinx/furo/theme/furo/layout.html
@@ -0,0 +1,16 @@
+<p>ERROR: This page was generated by inheriting from "layout.html".</p>
+
+<p>
+Furo (the documentation theme that this site is generated with) does not support
+this, and has generated this page. If you are the author of this documentation,
+please look into why this page was generated using the "layout.html" template and
+fix the root cause.
+</p>
+
+Debugging information, if you need to report this error somewhere:
+<pre>
+Sphinx: {{ sphinx_version }}
+Furo: {{ furo_version }}
+
+pagename: {{ pagename }}
+</pre>
diff --git a/docs/api/sphinx/furo/theme/furo/localtoc.html b/docs/api/sphinx/furo/theme/furo/localtoc.html
new file mode 100644
index 00000000..098d5aa0
--- /dev/null
+++ b/docs/api/sphinx/furo/theme/furo/localtoc.html
@@ -0,0 +1,4 @@
+You are using <code>localtoc.html</code> in <code>html_sidebars</code>. This
+configuration does not work with Furo, which is why you're seeing this message.
+Please see <a href="https://pradyunsg.me/furo/customisation/sidebar/">
+documentation on sidebar customisation in Furo</a> for more details.
diff --git a/docs/api/sphinx/furo/theme/furo/page.html b/docs/api/sphinx/furo/theme/furo/page.html
new file mode 100644
index 00000000..714c5604
--- /dev/null
+++ b/docs/api/sphinx/furo/theme/furo/page.html
@@ -0,0 +1,143 @@
+{% extends "base.html" %}
+
+{% block body -%}
+{% include "partials/icons.html" %}
+
+<input type="checkbox" class="sidebar-toggle" name="__navigation" id="__navigation">
+<input type="checkbox" class="sidebar-toggle" name="__toc" id="__toc">
+<label class="overlay sidebar-overlay" for="__navigation"></label>
+<label class="overlay toc-overlay" for="__toc"></label>
+
+{% if theme_announcement -%}
+<div class="announcement">
+  <aside class="announcement-content">
+    {% block announcement %} {{ theme_announcement }} {% endblock announcement %}
+  </aside>
+</div>
+{%- endif %}
+
+<div class="page">
+  <header class="mobile-header">
+    <div class="header-left">
+      <label class="nav-overlay-icon" for="__navigation">
+        <i class="icon"><svg><use href="#svg-menu"></use></svg></i>
+      </label>
+    </div>
+    <div class="header-center">
+      <a href="{{ pathto(master_doc) }}"><div class="brand">{{ docstitle }}</div></a>
+    </div>
+    <div class="header-right">
+      <label class="toc-overlay-icon toc-header-icon{% if furo_hide_toc %} no-toc{% endif %}" for="__toc">
+        <i class="icon"><svg><use href="#svg-toc"></use></svg></i>
+      </label>
+    </div>
+  </header>
+  <aside class="sidebar-drawer">
+    <div class="sidebar-container">
+      {% block left_sidebar %}
+      <div class="sidebar-sticky">
+        {%- for sidebar_section in sidebars %}
+          {%- include sidebar_section %}
+        {%- endfor %}
+      </div>
+      {% endblock left_sidebar %}
+    </div>
+  </aside>
+  <main class="main">
+    <div class="content">
+      <article role="main">
+        <label class="toc-overlay-icon toc-content-icon{% if furo_hide_toc %} no-toc{% endif %}" for="__toc">
+          <i class="icon"><svg><use href="#svg-toc"></use></svg></i>
+        </label>
+        {% block content %}{{ body }}{% endblock %}
+      </article>
+      <footer>
+        {% block footer %}
+        <div class="related-pages">
+          {% if next -%}
+            <a class="next-page" href="{{ next.link }}">
+              <div class="page-info">
+                <div class="context">
+                  <span>{{ _("Next") }}</span>
+                </div>
+                <div class="title">{{ next.title }}</div>
+              </div>
+              <svg><use href="#svg-arrow-right"></use></svg>
+            </a>
+          {%- endif %}
+          {% if prev -%}
+            <a class="prev-page" href="{{ prev.link }}">
+              <svg><use href="#svg-arrow-right"></use></svg>
+              <div class="page-info">
+                <div class="context">
+                  <span>{{ _("Previous") }}</span>
+                </div>
+                {% if prev.link == pathto(master_doc) %}
+                <div class="title">{{ _("Home") }}</div>
+                {% else %}
+                <div class="title">{{ prev.title }}</div>
+                {% endif %}
+              </div>
+            </a>
+          {%- endif %}
+        </div>
+
+        <!-- <div class="related-information">
+          {%- if show_copyright %}
+            {%- if hasdoc('copyright') %}
+              {% trans path=pathto('copyright'), copyright=copyright|e -%}
+                <a href="{{ path }}">Copyright</a> &#169; {{ copyright }}.
+              {%- endtrans %}
+            {%- else %}
+              {% trans copyright=copyright|e -%}
+                Copyright &#169; {{ copyright }}
+              {%- endtrans %}
+            {%- endif %}
+          {%- endif %}
+          {%- if last_updated %}
+            |
+            {% trans last_updated=last_updated|e -%}
+              Last updated on {{ last_updated }}.
+            {%- endtrans %}
+          {%- endif %}
+          {%- if show_sphinx %}
+            |
+            {% trans -%}
+              Built with <a href="https://www.sphinx-doc.org/">Sphinx</a>
+              and
+              <a class="muted-link" href="https://pradyunsg.me">@pradyunsg</a>'s
+              <a href="https://github.com/pradyunsg/furo">Furo theme</a>.
+            {%- endtrans %}
+          {%- endif %}
+          {%- if show_source and has_source and sourcename %}
+            |
+            <a class="muted-link" href="{{ pathto('_sources/' + sourcename, true)|e }}"
+               rel="nofollow">
+              {{ _('Show Source') }}
+            </a>
+          {%- endif %}
+        </div> -->
+        {% endblock footer %}
+      </footer>
+    </div>
+    <aside class="toc-drawer{% if furo_hide_toc %} no-toc{% endif %}">
+      {% block right_sidebar %}
+      {% if not furo_hide_toc %}
+      <div class="toc-sticky toc-scroll">
+        <div class="toc-title-container">
+          <span class="toc-title">
+            {{ _("Contents") }}
+          </span>
+        </div>
+        <div class="toc-tree-container">
+          <div class="toc-tree">
+            {{ toc }}
+          </div>
+        </div>
+      </div>
+      {% endif %}
+      {% endblock right_sidebar %}
+    </aside>
+  </main>
+</div>
+{%- endblock %}
diff --git a/docs/api/sphinx/furo/theme/furo/partials/_head_css_variables.html b/docs/api/sphinx/furo/theme/furo/partials/_head_css_variables.html
new file mode 100644
index 00000000..f409f394
--- /dev/null
+++ b/docs/api/sphinx/furo/theme/furo/partials/_head_css_variables.html
@@ -0,0 +1,31 @@
+{#
+  This is where user-provided CSS variables get converted into actual values.
+#}
+{% macro declare_css_variables(user_customisations, pygments_theme) -%}
+  --color-code-background: {{ pygments_theme.background }};
+  --color-code-foreground: {{ pygments_theme.foreground }};
+  {% if user_customisations -%}
+  {% for name, value in user_customisations.items() -%}
+    --{{ name }}: {{ value }};
+  {% endfor %}
+  {%- endif %}
+{%- endmacro %}
+
+<style>
+  :root {
+    {{ declare_css_variables(theme_light_css_variables, furo_pygments.light) }}
+  }
+  @media (prefers-color-scheme: dark) {
+    :root {
+      {{ declare_css_variables(theme_dark_css_variables, furo_pygments.dark) }}
+    }
+  }
+
+  /* For allowing end-user-specific overrides */
+  .override-light {
+    {{ declare_css_variables(theme_light_css_variables, furo_pygments.light) }}
+  }
+  .override-dark {
+    {{ declare_css_variables(theme_dark_css_variables, furo_pygments.dark) }}
+  }
+</style>
diff --git a/docs/api/sphinx/furo/theme/furo/partials/icons.html b/docs/api/sphinx/furo/theme/furo/partials/icons.html
new file mode 100644
index 00000000..ddf0aef8
--- /dev/null
+++ b/docs/api/sphinx/furo/theme/furo/partials/icons.html
@@ -0,0 +1,31 @@
+{# Adapted from Just the Docs #}
+<svg xmlns="http://www.w3.org/2000/svg" style="display: none;">
+  <symbol id="svg-toc" viewBox="0 0 24 24">
+    <title>Contents</title>
+    <svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none"
+      stroke-width="1.5" stroke="currentColor" stroke-linecap="round" stroke-linejoin="round">
+      <path stroke="none" d="M0 0h24v24H0z"/>
+      <line x1="4" y1="6" x2="20" y2="6" />
+      <line x1="10" y1="12" x2="20" y2="12" />
+      <line x1="6" y1="18" x2="20" y2="18" />
+    </svg>
+  </symbol>
+  <symbol id="svg-menu" viewBox="0 0 24 24">
+    <title>Menu</title>
+    <svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none"
+      stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"
+      class="feather feather-menu">
+      <line x1="3" y1="12" x2="21" y2="12"></line>
+      <line x1="3" y1="6" x2="21" y2="6"></line>
+      <line x1="3" y1="18" x2="21" y2="18"></line>
+    </svg>
+  </symbol>
+  <symbol id="svg-arrow-right" viewBox="0 0 24 24">
+    <title>Expand</title>
+    <svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none"
+      stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"
+      class="feather feather-chevron-right">
+      <polyline points="9 18 15 12 9 6"></polyline>
+    </svg>
+  </symbol>
+</svg>
diff --git a/docs/api/sphinx/furo/theme/furo/search.html b/docs/api/sphinx/furo/theme/furo/search.html
new file mode 100644
index 00000000..38b7eba4
--- /dev/null
+++ b/docs/api/sphinx/furo/theme/furo/search.html
@@ -0,0 +1,28 @@
+{% extends "page.html" %}
+
+{%- block regular_scripts -%}
+{{ super() }}
+<script src="{{ pathto('_static/searchtools.js', 1) }}"></script>
+<script src="{{ pathto('_static/language_data.js', 1) }}"></script>
+{%- endblock regular_scripts-%}
+
+{%- block htmltitle -%}
+<title>{{ _("Search") }} - {{ docstitle }}</title>
+{%- endblock htmltitle -%}
+
+{% block content %}
+<div id="fallback" class="admonition error">
+  <p class="admonition-title">{% trans %}Error{% endtrans %}</p>
+  <p>
+    {% trans %}Please activate JavaScript to enable the search functionality.{% endtrans %}
+  </p>
+</div>
+<script>document.getElementById('fallback').hidden = true;</script>
+
+<div id="search-results"></div>
+{% endblock %}
+
+{% block scripts -%}
+{{ super() }}
+<script src="{{ pathto('searchindex.js', 1) }}"></script>
+{%- endblock scripts %}
diff --git a/docs/api/sphinx/furo/theme/furo/sidebar/brand.html b/docs/api/sphinx/furo/theme/furo/sidebar/brand.html
new file mode 100644
index 00000000..24770331
--- /dev/null
+++ b/docs/api/sphinx/furo/theme/furo/sidebar/brand.html
@@ -0,0 +1,31 @@
+{#-
+
+Hi there!
+
+You might be interested in https://pradyunsg.me/furo/customisation/sidebar/
+
+Although if you're reading this, chances are that you're either familiar
+enough with Sphinx that you know what you're doing, or landed here from that
+documentation page.
+
+Hope your day's going well. :)
+
+-#}
+<a class="sidebar-brand{% if logo %} centered{% endif %}" href="{{ pathto(master_doc) }}">
+  {% block brand_content %}
+  {%- if logo %}
+  <div class="sidebar-logo-container">
+    <img class="sidebar-logo" src="{{ pathto('_static/' + logo, 1) }}" alt="Logo"/>
+  </div>
+  {%- endif %}
+  {%- if theme_light_logo and theme_dark_logo %}
+  <div class="sidebar-logo-container">
+    <img class="sidebar-logo only-light" src="{{ pathto('_static/' + theme_light_logo, 1) }}" alt="Light Logo"/>
+    <img class="sidebar-logo only-dark" src="{{ pathto('_static/' + theme_dark_logo, 1) }}" alt="Dark Logo"/>
+  </div>
+  {%- endif %}
+  {% if not theme_sidebar_hide_name %}
+  <span class="sidebar-brand-text">{{ docstitle }}</span>
+  {%- endif %}
+  {% endblock brand_content %}
+</a>
diff --git a/docs/api/sphinx/furo/theme/furo/sidebar/ethical-ads.html b/docs/api/sphinx/furo/theme/furo/sidebar/ethical-ads.html
new file mode 100644
index 00000000..56aeab84
--- /dev/null
+++ b/docs/api/sphinx/furo/theme/furo/sidebar/ethical-ads.html
@@ -0,0 +1,10 @@
+{# Add the ethical ads div, when generating documentation on ReadTheDocs #}
+{% if READTHEDOCS %}
+<div
+  id="furo-sidebar-ad-placement"
+  class="flat"
+  data-ea-publisher="readthedocs"
+  data-ea-type="readthedocs-sidebar"
+  data-ea-manual="true"
+></div>
+{% endif %}
diff --git a/docs/api/sphinx/furo/theme/furo/sidebar/navigation.html b/docs/api/sphinx/furo/theme/furo/sidebar/navigation.html
new file mode 100644
index 00000000..eda51760
--- /dev/null
+++ b/docs/api/sphinx/furo/theme/furo/sidebar/navigation.html
@@ -0,0 +1,3 @@
+<div class="sidebar-tree">
+  {{ furo_navigation_tree }}
+</div>
diff --git a/docs/api/sphinx/furo/theme/furo/sidebar/rtd-versions.html b/docs/api/sphinx/furo/theme/furo/sidebar/rtd-versions.html
new file mode 100644
index 00000000..4b75680e
--- /dev/null
+++ b/docs/api/sphinx/furo/theme/furo/sidebar/rtd-versions.html
@@ -0,0 +1,34 @@
+{# Add rst-badge after rst-versions for small badge style. #}
+{% if READTHEDOCS %}
+<div class="rst-versions" data-toggle="rst-versions" role="note" aria-label="versions">
+  <span class="rst-current-version" data-toggle="rst-current-version">
+    <span class="fa fa-book"> Read the Docs</span>
+    v: {{ current_version }}
+    <span class="fa fa-caret-down"></span>
+  </span>
+  <div class="rst-other-versions">
+    <dl>
+      <dt>{{ _('Versions') }}</dt>
+      {% for slug, url in versions %}
+        <dd><a href="{{ url }}">{{ slug }}</a></dd>
+      {% endfor %}
+    </dl>
+    <dl>
+      <dt>{{ _('Downloads') }}</dt>
+      {% for type, url in downloads %}
+        <dd><a href="{{ url }}">{{ type }}</a></dd>
+      {% endfor %}
+    </dl>
+    <dl>
+      {# Translators: The phrase "Read the Docs" is not translated #}
+      <dt>{{ _('On Read the Docs') }}</dt>
+        <dd>
+          <a href="//{{ PRODUCTION_DOMAIN }}/projects/{{ slug }}/?fromdocs={{ slug }}">{{ _('Project Home') }}</a>
+        </dd>
+        <dd>
+          <a href="//{{ PRODUCTION_DOMAIN }}/builds/{{ slug }}/?fromdocs={{ slug }}">{{ _('Builds') }}</a>
+        </dd>
+    </dl>
+  </div>
+</div>
+{% endif %}
diff --git a/docs/api/sphinx/furo/theme/furo/sidebar/scroll-end.html b/docs/api/sphinx/furo/theme/furo/sidebar/scroll-end.html
new file mode 100644
index 00000000..04f5b844
--- /dev/null
+++ b/docs/api/sphinx/furo/theme/furo/sidebar/scroll-end.html
@@ -0,0 +1 @@
+</div>
diff --git a/docs/api/sphinx/furo/theme/furo/sidebar/scroll-start.html b/docs/api/sphinx/furo/theme/furo/sidebar/scroll-start.html
new file mode 100644
index 00000000..d003e58d
--- /dev/null
+++ b/docs/api/sphinx/furo/theme/furo/sidebar/scroll-start.html
@@ -0,0 +1 @@
+<div class="sidebar-scroll">
diff --git a/docs/api/sphinx/furo/theme/furo/sidebar/search.html b/docs/api/sphinx/furo/theme/furo/sidebar/search.html
new file mode 100644
index 00000000..f0633e60
--- /dev/null
+++ b/docs/api/sphinx/furo/theme/furo/sidebar/search.html
@@ -0,0 +1,5 @@
+<form class="sidebar-search-container" method="get" action="{{ pathto('search') }}">
+  <input class="sidebar-search" placeholder={{ _("Search") }} name="q">
+  <input type="hidden" name="check_keywords" value="yes">
+  <input type="hidden" name="area" value="default">
+</form>
diff --git a/docs/api/sphinx/furo/theme/furo/static/scripts/main.js b/docs/api/sphinx/furo/theme/furo/static/scripts/main.js
new file mode 100644
index 00000000..79383cce
--- /dev/null
+++ b/docs/api/sphinx/furo/theme/furo/static/scripts/main.js
@@ -0,0 +1,2 @@
+!function(e,t){"function"==typeof define&&define.amd?define([],function(){return t(e)}):"object"==typeof exports?module.exports=t(e):e.Gumshoe=t(e)}("undefined"!=typeof global?global:"undefined"!=typeof window?window:this,function(u){"use strict";function d(e,t,n){n.settings.events&&(n=new CustomEvent(e,{bubbles:!0,cancelable:!0,detail:n}),t.dispatchEvent(n))}function n(e){var t=0;if(e.offsetParent)for(;e;)t+=e.offsetTop,e=e.offsetParent;return 0<=t?t:0}function f(e){e&&e.sort(function(e,t){return n(e.content)<n(t.content)?-1:1})}function l(e,t,n){return e=e.getBoundingClientRect(),t="function"==typeof(t=t).offset?parseFloat(t.offset()):parseFloat(t.offset),n?parseInt(e.bottom,10)<(u.innerHeight||document.documentElement.clientHeight):parseInt(e.top,10)<=t}function s(){return Math.ceil(u.innerHeight+u.pageYOffset)>=Math.max(document.body.scrollHeight,document.documentElement.scrollHeight,document.body.offsetHeight,document.documentElement.offsetHeight,document.body.clientHeight,document.documentElement.clientHeight)}function m(e,t){var n,o,r=e[e.length-1];if(n=r,o=t,!(!s()||!l(n.content,o,!0)))return r;for(var c=e.length-1;0<=c;c--)if(l(e[c].content,t))return e[c]}function v(e,t){var n;!e||(n=e.nav.closest("li"))&&(n.classList.remove(t.navClass),e.content.classList.remove(t.contentClass),o(n,t),d("gumshoeDeactivate",n,{link:e.nav,content:e.content,settings:t}))}var h={navClass:"active",contentClass:"active",nested:!1,nestedClass:"active",offset:0,reflow:!1,events:!0},o=function(e,t){t.nested&&e.parentNode&&((e=e.parentNode.closest("li"))&&(e.classList.remove(t.nestedClass),o(e,t)))},p=function(e,t){!t.nested||(e=e.parentNode.closest("li"))&&(e.classList.add(t.nestedClass),p(e,t))};return function(e,t){var n,r,c,o,l,s={setup:function(){n=document.querySelectorAll(e),r=[],Array.prototype.forEach.call(n,function(e){var t=document.getElementById(decodeURIComponent(e.hash.substr(1)));t&&r.push({nav:e,content:t})}),f(r)}};s.detect=function(){var e,t,n,o=m(r,l);o?c&&o.content===c.content||(v(c,l),t=l,!(e=o)||(n=e.nav.closest("li"))&&(n.classList.add(t.navClass),e.content.classList.add(t.contentClass),p(n,t),d("gumshoeActivate",n,{link:e.nav,content:e.content,settings:t})),c=o):c&&(v(c,l),c=null)};function i(e){o&&u.cancelAnimationFrame(o),o=u.requestAnimationFrame(s.detect)}function a(e){o&&u.cancelAnimationFrame(o),o=u.requestAnimationFrame(function(){f(r),s.detect()})}s.destroy=function(){c&&v(c,l),u.removeEventListener("scroll",i,!1),l.reflow&&u.removeEventListener("resize",a,!1),l=o=c=n=r=null};return l=function(){var n={};return Array.prototype.forEach.call(arguments,function(e){for(var t in e){if(!e.hasOwnProperty(t))return;n[t]=e[t]}}),n}(h,t||{}),s.setup(),s.detect(),u.addEventListener("scroll",i,!1),l.reflow&&u.addEventListener("resize",a,!1),s}});var tocScroll=null,header=null;function scrollHandlerForHeader(){0==Math.floor(header.getBoundingClientRect().top)?header.classList.add("scrolled"):header.classList.remove("scrolled")}function scrollHandlerForTOC(e){null!==tocScroll&&(0==e?tocScroll.scrollTo(0,0):Math.ceil(e)>=Math.floor(document.documentElement.scrollHeight-window.innerHeight)?tocScroll.scrollTo(0,tocScroll.scrollHeight):document.querySelector(".scroll-current"))}function scrollHandler(e){scrollHandlerForHeader(),scrollHandlerForTOC(e)}function setupScrollHandler(){var t,n=!1;window.addEventListener("scroll",function(e){t=window.scrollY,n||(window.requestAnimationFrame(function(){scrollHandler(t),n=!1}),n=!0)}),window.scroll()}function setupScrollSpy(){null!==tocScroll&&new Gumshoe(".toc-tree a",{reflow:!0,recursive:!0,navClass:"scroll-current"})}function setup(){setupScrollHandler(),setupScrollSpy()}function main(){document.body.parentNode.classList.remove("no-js"),header=document.querySelector("header"),tocScroll=document.querySelector(".toc-scroll"),setup()}document.addEventListener("DOMContentLoaded",main);
+//# sourceMappingURL=main.js.map
diff --git a/docs/api/sphinx/furo/theme/furo/static/scripts/main.js.map b/docs/api/sphinx/furo/theme/furo/static/scripts/main.js.map
new file mode 100644
index 00000000..5d70f82f
--- /dev/null
+++ b/docs/api/sphinx/furo/theme/furo/static/scripts/main.js.map
@@ -0,0 +1 @@
+{"version":3,"sources":["gumshoe-5.1.2-patched.js","main.js"],"names":["root","factory","define","amd","exports","module","Gumshoe","global","window","this","emitEvent","type","elem","detail","settings","events","event","CustomEvent","bubbles","cancelable","dispatchEvent","getOffsetTop","location","offsetParent","offsetTop","sortContents","contents","sort","item1","item2","content","isInView","bottom","bounds","getBoundingClientRect","offset","parseFloat","parseInt","innerHeight","document","documentElement","clientHeight","top","isAtBottom","Math","ceil","pageYOffset","max","body","scrollHeight","offsetHeight","getActive","item","last","length","i","deactivate","items","li","nav","closest","classList","remove","navClass","contentClass","deactivateNested","link","defaults","nested","nestedClass","reflow","parentNode","activateNested","add","selector","options","navItems","current","timeout","publicAPIs","setup","querySelectorAll","Array","prototype","forEach","call","getElementById","decodeURIComponent","hash","substr","push","detect","active","scrollHandler","cancelAnimationFrame","requestAnimationFrame","resizeHandler","destroy","removeEventListener","merged","arguments","obj","key","hasOwnProperty","extend","addEventListener","tocScroll","header","scrollHandlerForHeader","floor","scrollHandlerForTOC","positionY","scrollTo","querySelector","setupScrollHandler","last_known_scroll_position","ticking","e","scrollY","scroll","setupScrollSpy","recursive","main"],"mappings":"CAQA,SAAAA,EAAAC,GACA,mBAAAC,QAAAA,OAAAC,IACAD,OAAA,GAAA,WACA,OAAAD,EAAAD,KAEA,iBAAAI,QACAC,OAAAD,QAAAH,EAAAD,GAEAA,EAAAM,QAAAL,EAAAD,GARA,CAWA,oBAAAO,OACAA,OACA,oBAAAC,OACAA,OACAC,KACA,SAAAD,gBAkDA,SAAAE,EAAAC,EAAAC,EAAAC,GAEAA,EAAAC,SAAAC,SAGAC,EAAA,IAAAC,YAAAN,EAAA,CACAO,SAAA,EACAC,YAAA,EACAN,OAAAA,IAIAD,EAAAQ,cAAAJ,IAQA,SAAAK,EAAAT,GACA,IAAAU,EAAA,EACA,GAAAV,EAAAW,aACA,KAAAX,GACAU,GAAAV,EAAAY,UACAZ,EAAAA,EAAAW,aAGA,OAAA,GAAAD,EAAAA,EAAA,EAOA,SAAAG,EAAAC,GACAA,GACAA,EAAAC,KAAA,SAAAC,EAAAC,GAGA,OAFAR,EAAAO,EAAAE,SACAT,EAAAQ,EAAAC,UACA,EACA,IA2CA,SAAAC,EAAAnB,EAAAE,EAAAkB,GAGA,OAFAC,EAAArB,EAAAsB,wBACAC,EAjCA,mBAFArB,EAmCAA,GAjCAqB,OACAC,WAAAtB,EAAAqB,UAIAC,WAAAtB,EAAAqB,QA6BAH,EAEAK,SAAAJ,EAAAD,OAAA,KACAxB,EAAA8B,aAAAC,SAAAC,gBAAAC,cAGAJ,SAAAJ,EAAAS,IAAA,KAAAP,EAOA,SAAAQ,IACA,OACAC,KAAAC,KAAArC,EAAA8B,YAAA9B,EAAAsC,cAnCAF,KAAAG,IACAR,SAAAS,KAAAC,aACAV,SAAAC,gBAAAS,aACAV,SAAAS,KAAAE,aACAX,SAAAC,gBAAAU,aACAX,SAAAS,KAAAP,aACAF,SAAAC,gBAAAC,cAqDA,SAAAU,EAAAzB,EAAAZ,GACA,IAZAsC,EAAAtC,EAYAuC,EAAA3B,EAAAA,EAAA4B,OAAA,GACA,GAbAF,EAaAC,EAbAvC,EAaAA,KAZA6B,MAAAZ,EAAAqB,EAAAtB,QAAAhB,GAAA,IAYA,OAAAuC,EACA,IAAA,IAAAE,EAAA7B,EAAA4B,OAAA,EAAA,GAAAC,EAAAA,IACA,GAAAxB,EAAAL,EAAA6B,GAAAzB,QAAAhB,GAAA,OAAAY,EAAA6B,GA6BA,SAAAC,EAAAC,EAAA3C,GAEA,IAGA4C,GAHAD,IAGAC,EAAAD,EAAAE,IAAAC,QAAA,SAIAF,EAAAG,UAAAC,OAAAhD,EAAAiD,UACAN,EAAA3B,QAAA+B,UAAAC,OAAAhD,EAAAkD,cAGAC,EAAAP,EAAA5C,GAGAJ,EAAA,oBAAAgD,EAAA,CACAQ,KAAAT,EAAAE,IACA7B,QAAA2B,EAAA3B,QACAhB,SAAAA,KA7NA,IAAAqD,EAAA,CAEAJ,SAAA,SACAC,aAAA,SAGAI,QAAA,EACAC,YAAA,SAGAlC,OAAA,EACAmC,QAAA,EAGAvD,QAAA,GAwKAkD,EAAA,SAAAN,EAAA7C,GAEAA,EAAAsD,QAAAT,EAAAY,cAGAb,EAAAC,EAAAY,WAAAX,QAAA,SAIAF,EAAAG,UAAAC,OAAAhD,EAAAuD,aAGAJ,EAAAP,EAAA5C,MAoCA0D,EAAA,SAAAb,EAAA7C,IAEAA,EAAAsD,SAGAV,EAAAC,EAAAY,WAAAX,QAAA,SAIAF,EAAAG,UAAAY,IAAA3D,EAAAuD,aAGAG,EAAAd,EAAA5C,KA8LA,OA1JA,SAAA4D,EAAAC,GAKA,IACAC,EAAAlD,EAAAmD,EAAAC,EAAAhE,EADAiE,EAAA,CAUAC,MAAA,WAEAJ,EAAArC,SAAA0C,iBAAAP,GAGAhD,EAAA,GAGAwD,MAAAC,UAAAC,QAAAC,KAAAT,EAAA,SAAAxB,GAEA,IAAAtB,EAAAS,SAAA+C,eACAC,mBAAAnC,EAAAoC,KAAAC,OAAA,KAEA3D,GAGAJ,EAAAgE,KAAA,CACA/B,IAAAP,EACAtB,QAAAA,MAKAL,EAAAC,KAMAqD,EAAAY,OAAA,WAEA,IA1EAlC,EAAA3C,EAKA4C,EAqEAkC,EAAAzC,EAAAzB,EAAAZ,GAGA8E,EASAf,GAAAe,EAAA9D,UAAA+C,EAAA/C,UAGA0B,EAAAqB,EAAA/D,GAzFAA,EA0FAA,IA1FA2C,EA0FAmC,KArFAlC,EAAAD,EAAAE,IAAAC,QAAA,SAIAF,EAAAG,UAAAY,IAAA3D,EAAAiD,UACAN,EAAA3B,QAAA+B,UAAAY,IAAA3D,EAAAkD,cAGAQ,EAAAd,EAAA5C,GAGAJ,EAAA,kBAAAgD,EAAA,CACAQ,KAAAT,EAAAE,IACA7B,QAAA2B,EAAA3B,QACAhB,SAAAA,KA0EA+D,EAAAe,GAfAf,IACArB,EAAAqB,EAAA/D,GACA+D,EAAA,OAoBA,SAAAgB,EAAA7E,GAEA8D,GACAtE,EAAAsF,qBAAAhB,GAIAA,EAAAtE,EAAAuF,sBAAAhB,EAAAY,QAOA,SAAAK,EAAAhF,GAEA8D,GACAtE,EAAAsF,qBAAAhB,GAIAA,EAAAtE,EAAAuF,sBAAA,WACAtE,EAAAC,GACAqD,EAAAY,WAOAZ,EAAAkB,QAAA,WAEApB,GACArB,EAAAqB,EAAA/D,GAIAN,EAAA0F,oBAAA,SAAAL,GAAA,GACA/E,EAAAwD,QACA9D,EAAA0F,oBAAA,SAAAF,GAAA,GAQAlF,EADAgE,EADAD,EADAD,EADAlD,EAAA,MAgCA,OApBAZ,EA3XA,WACA,IAAAqF,EAAA,GAOA,OANAjB,MAAAC,UAAAC,QAAAC,KAAAe,UAAA,SAAAC,GACA,IAAA,IAAAC,KAAAD,EAAA,CACA,IAAAA,EAAAE,eAAAD,GAAA,OACAH,EAAAG,GAAAD,EAAAC,MAGAH,EAmXAK,CAAArC,EAAAQ,GAAA,IAGAI,EAAAC,QAGAD,EAAAY,SAGAnF,EAAAiG,iBAAA,SAAAZ,GAAA,GACA/E,EAAAwD,QACA9D,EAAAiG,iBAAA,SAAAT,GAAA,GASAjB,KCrcA,IAAA2B,UAAA,KACAC,OAAA,KAEA,SAAAC,yBACA,GAAAhE,KAAAiE,MAAAF,OAAAzE,wBAAAQ,KACAiE,OAAA9C,UAAAY,IAAA,YAEAkC,OAAA9C,UAAAC,OAAA,YAIA,SAAAgD,oBAAAC,GACA,OAAAL,YAKA,GAAAK,EACAL,UAAAM,SAAA,EAAA,GAGApE,KAAAC,KAAAkE,IACAnE,KAAAiE,MAAAtE,SAAAC,gBAAAS,aAAAzC,OAAA8B,aAEAoE,UAAAM,SAAA,EAAAN,UAAAzD,cAGAV,SAAA0E,cAAA,oBAgBA,SAAApB,cAAAkB,GACAH,yBACAE,oBAAAC,GAMA,SAAAG,qBAEA,IAAAC,EACAC,GAAA,EAEA5G,OAAAiG,iBAAA,SAAA,SAAAY,GACAF,EAAA3G,OAAA8G,QAEAF,IACA5G,OAAAuF,sBAAA,WACAF,cAAAsB,GACAC,GAAA,IAGAA,GAAA,KAGA5G,OAAA+G,SAGA,SAAAC,iBACA,OAAAd,WAKA,IAAApG,QAAA,cAAA,CACAgE,QAAA,EACAmD,WAAA,EACA1D,SAAA,mBAIA,SAAAiB,QACAkC,qBACAM,iBAGA,SAAAE,OACAnF,SAAAS,KAAAuB,WAAAV,UAAAC,OAAA,SAEA6C,OAAApE,SAAA0E,cAAA,UACAP,UAAAnE,SAAA0E,cAAA,eAEAjC,QAGAzC,SAAAkE,iBAAA,mBAAAiB","file":"main.js","sourcesContent":["/*!\n * gumshoejs v5.1.2 (patched by @pradyunsg)\n * A simple, framework-agnostic scrollspy script.\n * (c) 2019 Chris Ferdinandi\n * MIT License\n * http://github.com/cferdinandi/gumshoe\n */\n\n(function (root, factory) {\n  if (typeof define === \"function\" && define.amd) {\n    define([], function () {\n      return factory(root);\n    });\n  } else if (typeof exports === \"object\") {\n    module.exports = factory(root);\n  } else {\n    root.Gumshoe = factory(root);\n  }\n})(\n  typeof global !== \"undefined\"\n    ? global\n    : typeof window !== \"undefined\"\n    ? window\n    : this,\n  function (window) {\n    \"use strict\";\n\n    //\n    // Defaults\n    //\n\n    var defaults = {\n      // Active classes\n      navClass: \"active\",\n      contentClass: \"active\",\n\n      // Nested navigation\n      nested: false,\n      nestedClass: \"active\",\n\n      // Offset & reflow\n      offset: 0,\n      reflow: false,\n\n      // Event support\n      events: true,\n    };\n\n    //\n    // Methods\n    //\n\n    /**\n     * Merge two or more objects together.\n     * @param   {Object}   objects  The objects to merge together\n     * @returns {Object}            Merged values of defaults and options\n     */\n    var extend = function () {\n      var merged = {};\n      Array.prototype.forEach.call(arguments, function (obj) {\n        for (var key in obj) {\n          if (!obj.hasOwnProperty(key)) return;\n          merged[key] = obj[key];\n        }\n      });\n      return merged;\n    };\n\n    /**\n     * Emit a custom event\n     * @param  {String} type   The event type\n     * @param  {Node}   elem   The element to attach the event to\n     * @param  {Object} detail Any details to pass along with the event\n     */\n    var emitEvent = function (type, elem, detail) {\n      // Make sure events are enabled\n      if (!detail.settings.events) return;\n\n      // Create a new event\n      var event = new CustomEvent(type, {\n        bubbles: true,\n        cancelable: true,\n        detail: detail,\n      });\n\n      // Dispatch the event\n      elem.dispatchEvent(event);\n    };\n\n    /**\n     * Get an element's distance from the top of the Document.\n     * @param  {Node} elem The element\n     * @return {Number}    Distance from the top in pixels\n     */\n    var getOffsetTop = function (elem) {\n      var location = 0;\n      if (elem.offsetParent) {\n        while (elem) {\n          location += elem.offsetTop;\n          elem = elem.offsetParent;\n        }\n      }\n      return location >= 0 ? location : 0;\n    };\n\n    /**\n     * Sort content from first to last in the DOM\n     * @param  {Array} contents The content areas\n     */\n    var sortContents = function (contents) {\n      if (contents) {\n        contents.sort(function (item1, item2) {\n          var offset1 = getOffsetTop(item1.content);\n          var offset2 = getOffsetTop(item2.content);\n          if (offset1 < offset2) return -1;\n          return 1;\n        });\n      }\n    };\n\n    /**\n     * Get the offset to use for calculating position\n     * @param  {Object} settings The settings for this instantiation\n     * @return {Float}           The number of pixels to offset the calculations\n     */\n    var getOffset = function (settings) {\n      // if the offset is a function run it\n      if (typeof settings.offset === \"function\") {\n        return parseFloat(settings.offset());\n      }\n\n      // Otherwise, return it as-is\n      return parseFloat(settings.offset);\n    };\n\n    /**\n     * Get the document element's height\n     * @private\n     * @returns {Number}\n     */\n    var getDocumentHeight = function () {\n      return Math.max(\n        document.body.scrollHeight,\n        document.documentElement.scrollHeight,\n        document.body.offsetHeight,\n        document.documentElement.offsetHeight,\n        document.body.clientHeight,\n        document.documentElement.clientHeight\n      );\n    };\n\n    /**\n     * Determine if an element is in view\n     * @param  {Node}    elem     The element\n     * @param  {Object}  settings The settings for this instantiation\n     * @param  {Boolean} bottom   If true, check if element is above bottom of viewport instead\n     * @return {Boolean}          Returns true if element is in the viewport\n     */\n    var isInView = function (elem, settings, bottom) {\n      var bounds = elem.getBoundingClientRect();\n      var offset = getOffset(settings);\n      if (bottom) {\n        return (\n          parseInt(bounds.bottom, 10) <\n          (window.innerHeight || document.documentElement.clientHeight)\n        );\n      }\n      return parseInt(bounds.top, 10) <= offset;\n    };\n\n    /**\n     * Check if at the bottom of the viewport\n     * @return {Boolean} If true, page is at the bottom of the viewport\n     */\n    var isAtBottom = function () {\n      if (\n        Math.ceil(window.innerHeight + window.pageYOffset) >=\n        getDocumentHeight()\n      )\n        return true;\n      return false;\n    };\n\n    /**\n     * Check if the last item should be used (even if not at the top of the page)\n     * @param  {Object} item     The last item\n     * @param  {Object} settings The settings for this instantiation\n     * @return {Boolean}         If true, use the last item\n     */\n    var useLastItem = function (item, settings) {\n      if (isAtBottom() && isInView(item.content, settings, true)) return true;\n      return false;\n    };\n\n    /**\n     * Get the active content\n     * @param  {Array}  contents The content areas\n     * @param  {Object} settings The settings for this instantiation\n     * @return {Object}          The content area and matching navigation link\n     */\n    var getActive = function (contents, settings) {\n      var last = contents[contents.length - 1];\n      if (useLastItem(last, settings)) return last;\n      for (var i = contents.length - 1; i >= 0; i--) {\n        if (isInView(contents[i].content, settings)) return contents[i];\n      }\n    };\n\n    /**\n     * Deactivate parent navs in a nested navigation\n     * @param  {Node}   nav      The starting navigation element\n     * @param  {Object} settings The settings for this instantiation\n     */\n    var deactivateNested = function (nav, settings) {\n      // If nesting isn't activated, bail\n      if (!settings.nested || !nav.parentNode) return;\n\n      // Get the parent navigation\n      var li = nav.parentNode.closest(\"li\");\n      if (!li) return;\n\n      // Remove the active class\n      li.classList.remove(settings.nestedClass);\n\n      // Apply recursively to any parent navigation elements\n      deactivateNested(li, settings);\n    };\n\n    /**\n     * Deactivate a nav and content area\n     * @param  {Object} items    The nav item and content to deactivate\n     * @param  {Object} settings The settings for this instantiation\n     */\n    var deactivate = function (items, settings) {\n      // Make sure there are items to deactivate\n      if (!items) return;\n\n      // Get the parent list item\n      var li = items.nav.closest(\"li\");\n      if (!li) return;\n\n      // Remove the active class from the nav and content\n      li.classList.remove(settings.navClass);\n      items.content.classList.remove(settings.contentClass);\n\n      // Deactivate any parent navs in a nested navigation\n      deactivateNested(li, settings);\n\n      // Emit a custom event\n      emitEvent(\"gumshoeDeactivate\", li, {\n        link: items.nav,\n        content: items.content,\n        settings: settings,\n      });\n    };\n\n    /**\n     * Activate parent navs in a nested navigation\n     * @param  {Node}   nav      The starting navigation element\n     * @param  {Object} settings The settings for this instantiation\n     */\n    var activateNested = function (nav, settings) {\n      // If nesting isn't activated, bail\n      if (!settings.nested) return;\n\n      // Get the parent navigation\n      var li = nav.parentNode.closest(\"li\");\n      if (!li) return;\n\n      // Add the active class\n      li.classList.add(settings.nestedClass);\n\n      // Apply recursively to any parent navigation elements\n      activateNested(li, settings);\n    };\n\n    /**\n     * Activate a nav and content area\n     * @param  {Object} items    The nav item and content to activate\n     * @param  {Object} settings The settings for this instantiation\n     */\n    var activate = function (items, settings) {\n      // Make sure there are items to activate\n      if (!items) return;\n\n      // Get the parent list item\n      var li = items.nav.closest(\"li\");\n      if (!li) return;\n\n      // Add the active class to the nav and content\n      li.classList.add(settings.navClass);\n      items.content.classList.add(settings.contentClass);\n\n      // Activate any parent navs in a nested navigation\n      activateNested(li, settings);\n\n      // Emit a custom event\n      emitEvent(\"gumshoeActivate\", li, {\n        link: items.nav,\n        content: items.content,\n        settings: settings,\n      });\n    };\n\n    /**\n     * Create the Constructor object\n     * @param {String} selector The selector to use for navigation items\n     * @param {Object} options  User options and settings\n     */\n    var Constructor = function (selector, options) {\n      //\n      // Variables\n      //\n\n      var publicAPIs = {};\n      var navItems, contents, current, timeout, settings;\n\n      //\n      // Methods\n      //\n\n      /**\n       * Set variables from DOM elements\n       */\n      publicAPIs.setup = function () {\n        // Get all nav items\n        navItems = document.querySelectorAll(selector);\n\n        // Create contents array\n        contents = [];\n\n        // Loop through each item, get it's matching content, and push to the array\n        Array.prototype.forEach.call(navItems, function (item) {\n          // Get the content for the nav item\n          var content = document.getElementById(\n            decodeURIComponent(item.hash.substr(1))\n          );\n          if (!content) return;\n\n          // Push to the contents array\n          contents.push({\n            nav: item,\n            content: content,\n          });\n        });\n\n        // Sort contents by the order they appear in the DOM\n        sortContents(contents);\n      };\n\n      /**\n       * Detect which content is currently active\n       */\n      publicAPIs.detect = function () {\n        // Get the active content\n        var active = getActive(contents, settings);\n\n        // if there's no active content, deactivate and bail\n        if (!active) {\n          if (current) {\n            deactivate(current, settings);\n            current = null;\n          }\n          return;\n        }\n\n        // If the active content is the one currently active, do nothing\n        if (current && active.content === current.content) return;\n\n        // Deactivate the current content and activate the new content\n        deactivate(current, settings);\n        activate(active, settings);\n\n        // Update the currently active content\n        current = active;\n      };\n\n      /**\n       * Detect the active content on scroll\n       * Debounced for performance\n       */\n      var scrollHandler = function (event) {\n        // If there's a timer, cancel it\n        if (timeout) {\n          window.cancelAnimationFrame(timeout);\n        }\n\n        // Setup debounce callback\n        timeout = window.requestAnimationFrame(publicAPIs.detect);\n      };\n\n      /**\n       * Update content sorting on resize\n       * Debounced for performance\n       */\n      var resizeHandler = function (event) {\n        // If there's a timer, cancel it\n        if (timeout) {\n          window.cancelAnimationFrame(timeout);\n        }\n\n        // Setup debounce callback\n        timeout = window.requestAnimationFrame(function () {\n          sortContents(contents);\n          publicAPIs.detect();\n        });\n      };\n\n      /**\n       * Destroy the current instantiation\n       */\n      publicAPIs.destroy = function () {\n        // Undo DOM changes\n        if (current) {\n          deactivate(current, settings);\n        }\n\n        // Remove event listeners\n        window.removeEventListener(\"scroll\", scrollHandler, false);\n        if (settings.reflow) {\n          window.removeEventListener(\"resize\", resizeHandler, false);\n        }\n\n        // Reset variables\n        contents = null;\n        navItems = null;\n        current = null;\n        timeout = null;\n        settings = null;\n      };\n\n      /**\n       * Initialize the current instantiation\n       */\n      var init = function () {\n        // Merge user options into defaults\n        settings = extend(defaults, options || {});\n\n        // Setup variables based on the current DOM\n        publicAPIs.setup();\n\n        // Find the currently active content\n        publicAPIs.detect();\n\n        // Setup event listeners\n        window.addEventListener(\"scroll\", scrollHandler, false);\n        if (settings.reflow) {\n          window.addEventListener(\"resize\", resizeHandler, false);\n        }\n      };\n\n      //\n      // Initialize and return the public APIs\n      //\n\n      init();\n      return publicAPIs;\n    };\n\n    //\n    // Return the Constructor\n    //\n\n    return Constructor;\n  }\n);\n","////////////////////////////////////////////////////////////////////////////////\n// Scroll Handling\n////////////////////////////////////////////////////////////////////////////////\nvar tocScroll = null;\nvar header = null;\n\nfunction scrollHandlerForHeader() {\n  if (Math.floor(header.getBoundingClientRect().top) == 0) {\n    header.classList.add(\"scrolled\");\n  } else {\n    header.classList.remove(\"scrolled\");\n  }\n}\n\nfunction scrollHandlerForTOC(positionY) {\n  if (tocScroll === null) {\n    return;\n  }\n\n  // top of page.\n  if (positionY == 0) {\n    tocScroll.scrollTo(0, 0);\n  } else if (\n    // bottom of page.\n    Math.ceil(positionY) >=\n    Math.floor(document.documentElement.scrollHeight - window.innerHeight)\n  ) {\n    tocScroll.scrollTo(0, tocScroll.scrollHeight);\n  } else {\n    // somewhere in the middle.\n    const current = document.querySelector(\".scroll-current\");\n    if (current == null) {\n      return;\n    }\n\n    // https://github.com/pypa/pip/issues/9159 This breaks scroll behaviours.\n    // // scroll the currently \"active\" heading in toc, into view.\n    // const rect = current.getBoundingClientRect();\n    // if (0 > rect.top) {\n    //   current.scrollIntoView(true); // the argument is \"alignTop\"\n    // } else if (rect.bottom > window.innerHeight) {\n    //   current.scrollIntoView(false);\n    // }\n  }\n}\n\nfunction scrollHandler(positionY) {\n  scrollHandlerForHeader();\n  scrollHandlerForTOC(positionY);\n}\n\n////////////////////////////////////////////////////////////////////////////////\n// Setup\n////////////////////////////////////////////////////////////////////////////////\nfunction setupScrollHandler() {\n  // Taken from https://developer.mozilla.org/en-US/docs/Web/API/Document/scroll_event\n  var last_known_scroll_position = 0;\n  var ticking = false;\n\n  window.addEventListener(\"scroll\", function (e) {\n    last_known_scroll_position = window.scrollY;\n\n    if (!ticking) {\n      window.requestAnimationFrame(function () {\n        scrollHandler(last_known_scroll_position);\n        ticking = false;\n      });\n\n      ticking = true;\n    }\n  });\n  window.scroll();\n}\n\nfunction setupScrollSpy() {\n  if (tocScroll === null) {\n    return;\n  }\n\n  // Scrollspy -- highlight table on contents, based on scroll\n  var spy = new Gumshoe(\".toc-tree a\", {\n    reflow: true,\n    recursive: true,\n    navClass: \"scroll-current\",\n  });\n}\n\nfunction setup() {\n  setupScrollHandler();\n  setupScrollSpy();\n}\n\nfunction main() {\n  document.body.parentNode.classList.remove(\"no-js\");\n\n  header = document.querySelector(\"header\");\n  tocScroll = document.querySelector(\".toc-scroll\");\n\n  setup();\n}\n\ndocument.addEventListener(\"DOMContentLoaded\", main);\n"]}
\ No newline at end of file
diff --git a/docs/api/sphinx/furo/theme/furo/static/styles/furo-extensions.css b/docs/api/sphinx/furo/theme/furo/static/styles/furo-extensions.css
new file mode 100644
index 00000000..2c5aee50
--- /dev/null
+++ b/docs/api/sphinx/furo/theme/furo/static/styles/furo-extensions.css
@@ -0,0 +1,2 @@
+#furo-sidebar-ad-placement{padding:var(--sidebar-item-spacing-vertical) var(--sidebar-item-spacing-horizontal)}#furo-sidebar-ad-placement .ethical-sidebar{border:none;box-shadow:none;background:var(--color-background-secondary)}#furo-sidebar-ad-placement .ethical-sidebar:hover{background:var(--color-background-hover)}#furo-sidebar-ad-placement .ethical-sidebar a{color:var(--color-foreground-primary)}#furo-sidebar-ad-placement .ethical-callout a{color:var(--color-foreground-secondary)!important}:root{--tabs--label-text:var(--color-foreground-muted);--tabs--label-text--active:var(--color-brand-content);--tabs--label-text--hover:var(--color-brand-content);--tabs--label-background--active:transparent;--tabs--label-background--hover:var(--color-background-secondary);--tabs--border:var(--color-background-border)}[role=main] .container{max-width:none;padding-left:0;padding-right:0}.shadow.docutils{border:none;box-shadow:0 .2rem .5rem rgba(0,0,0,.05),0 0 .0625rem rgba(0,0,0,.1)!important}.sphinx-bs .card{background-color:var(--color-background-secondary);color:var(--color-foreground)}
+/*# sourceMappingURL=furo-extensions.css.map */
diff --git a/docs/api/sphinx/furo/theme/furo/static/styles/furo-extensions.css.map b/docs/api/sphinx/furo/theme/furo/static/styles/furo-extensions.css.map
new file mode 100644
index 00000000..1f98ed24
--- /dev/null
+++ b/docs/api/sphinx/furo/theme/furo/static/styles/furo-extensions.css.map
@@ -0,0 +1 @@
+{"version":3,"sources":["extensions/_readthedocs.sass","furo-extensions.css","extensions/_sphinx-inline-tabs.sass","extensions/_sphinx-panels.sass"],"names":[],"mappings":"AAGA,2BACE,mFCFF,CDGE,4CAEE,WAAA,CACA,eAAA,CAEA,4CCHJ,CDII,kDACE,wCCFN,CDII,8CACE,qCCFN,CDGE,8CACI,iDCDN,CCdA,MACE,gDAAA,CACA,qDAAA,CACA,oDAAA,CACA,4CAAA,CACA,iEAAA,CACA,6CDiBF,CErBA,uBACE,cAAA,CACA,cAAA,CACA,eFwBF,CErBA,iBACE,WAAA,CACA,8EFwBF,CErBA,iBACE,kDAAA,CACA,6BFwBF","file":"furo-extensions.css","sourcesContent":["// This file contains the styles used for tweaking how ReadTheDoc's embedded\n// contents would show up inside the theme.\n\n#furo-sidebar-ad-placement\n  padding: var(--sidebar-item-spacing-vertical) var(--sidebar-item-spacing-horizontal)\n  .ethical-sidebar\n    // Remove the border and box-shadow.\n    border: none\n    box-shadow: none\n    // Manage the background colors.\n    background: var(--color-background-secondary)\n    &:hover\n      background: var(--color-background-hover)\n    // Ensure the text is legible.\n    a\n      color: var(--color-foreground-primary)\n  .ethical-callout a\n      color: var(--color-foreground-secondary) !important\n","#furo-sidebar-ad-placement {\n  padding: var(--sidebar-item-spacing-vertical) var(--sidebar-item-spacing-horizontal);\n}\n#furo-sidebar-ad-placement .ethical-sidebar {\n  border: none;\n  box-shadow: none;\n  background: var(--color-background-secondary);\n}\n#furo-sidebar-ad-placement .ethical-sidebar:hover {\n  background: var(--color-background-hover);\n}\n#furo-sidebar-ad-placement .ethical-sidebar a {\n  color: var(--color-foreground-primary);\n}\n#furo-sidebar-ad-placement .ethical-callout a {\n  color: var(--color-foreground-secondary) !important;\n}\n\n:root {\n  --tabs--label-text: var(--color-foreground-muted);\n  --tabs--label-text--active: var(--color-brand-content);\n  --tabs--label-text--hover: var(--color-brand-content);\n  --tabs--label-background--active: transparent;\n  --tabs--label-background--hover: var(--color-background-secondary);\n  --tabs--border: var(--color-background-border);\n}\n\n[role=main] .container {\n  max-width: initial;\n  padding-left: initial;\n  padding-right: initial;\n}\n\n.shadow.docutils {\n  border: none;\n  box-shadow: 0 0.2rem 0.5rem rgba(0, 0, 0, 0.05), 0 0 0.0625rem rgba(0, 0, 0, 0.1) !important;\n}\n\n.sphinx-bs .card {\n  background-color: var(--color-background-secondary);\n  color: var(--color-foreground);\n}","// This file contains styles to tweak sphinx-inline-tabs to work well with Furo.\n\n:root\n  --tabs--label-text: var(--color-foreground-muted)\n  --tabs--label-text--active: var(--color-brand-content)\n  --tabs--label-text--hover: var(--color-brand-content)\n  --tabs--label-background--active: transparent\n  --tabs--label-background--hover: var(--color-background-secondary)\n  --tabs--border: var(--color-background-border)\n","// This file contains styles to tweak sphinx-panels to work well with Furo.\n\n// sphinx-panels includes Bootstrap 4, which uses .container which can conflict\n// with docutils' `.. container::` directive.\n[role=\"main\"] .container\n  max-width: initial\n  padding-left: initial\n  padding-right: initial\n\n// Make the panels look nicer!\n.shadow.docutils\n  border: none\n  box-shadow: 0 0.2rem 0.5rem rgba(0, 0, 0, 0.05), 0 0 0.0625rem rgba(0, 0, 0, 0.1) !important\n\n// Make panel colors respond to dark mode\n.sphinx-bs .card\n  background-color: var(--color-background-secondary)\n  color: var(--color-foreground)\n"]}
\ No newline at end of file
diff --git a/docs/api/sphinx/furo/theme/furo/static/styles/furo.css b/docs/api/sphinx/furo/theme/furo/static/styles/furo.css
new file mode 100644
index 00000000..a2bd8d18
--- /dev/null
+++ b/docs/api/sphinx/furo/theme/furo/static/styles/furo.css
@@ -0,0 +1,2 @@
+/*! normalize.css v8.0.1 | MIT License | github.com/necolas/normalize.css */html{line-height:1.15;-webkit-text-size-adjust:100%}body{margin:0}main{display:block}h1{font-size:2em;margin:.67em 0}hr{box-sizing:content-box;height:0;overflow:visible}pre{font-family:monospace,monospace;font-size:1em}a{background-color:transparent}abbr[title]{border-bottom:none;text-decoration:underline;-webkit-text-decoration:underline dotted;text-decoration:underline dotted}b,strong{font-weight:bolder}code,kbd,samp{font-family:monospace,monospace;font-size:1em}small{font-size:80%}sub,sup{font-size:75%;line-height:0;position:relative;vertical-align:baseline}sub{bottom:-.25em}sup{top:-.5em}img{border-style:none}button,input,optgroup,select,textarea{font-family:inherit;font-size:100%;line-height:1.15;margin:0}button,input{overflow:visible}button,select{text-transform:none}[type=button],[type=reset],[type=submit],button{-webkit-appearance:button}[type=button]::-moz-focus-inner,[type=reset]::-moz-focus-inner,[type=submit]::-moz-focus-inner,button::-moz-focus-inner{border-style:none;padding:0}[type=button]:-moz-focusring,[type=reset]:-moz-focusring,[type=submit]:-moz-focusring,button:-moz-focusring{outline:1px dotted ButtonText}fieldset{padding:.35em .75em .625em}legend{box-sizing:border-box;color:inherit;display:table;max-width:100%;padding:0;white-space:normal}progress{vertical-align:baseline}textarea{overflow:auto}[type=checkbox],[type=radio]{box-sizing:border-box;padding:0}[type=number]::-webkit-inner-spin-button,[type=number]::-webkit-outer-spin-button{height:auto}[type=search]{-webkit-appearance:textfield;outline-offset:-2px}[type=search]::-webkit-search-decoration{-webkit-appearance:none}::-webkit-file-upload-button{-webkit-appearance:button;font:inherit}details{display:block}summary{display:list-item}[hidden],template{display:none}body{color:var(--color-foreground-primary);background:var(--color-background-primary)}.mobile-header .header-center a{color:var(--color-header-text);text-decoration:none}.announcement{background-color:var(--color-announcement-background);color:var(--color-announcement-text)}.sidebar-drawer{border-right:1px solid var(--color-sidebar-background-border);background:var(--color-sidebar-background)}.sidebar-brand{color:var(--color-sidebar-brand-text)}.sidebar-search-container{background:var(--color-sidebar-search-background)}.sidebar-search-container:focus-within,.sidebar-search-container:hover{background:var(--color-sidebar-search-background--focus)}.sidebar-search-container:before{background-color:var(--color-sidebar-search-icon);-webkit-mask-image:var(--icon-search);mask-image:var(--icon-search)}.sidebar-search{border:none;border-top:1px solid var(--color-sidebar-search-border);border-bottom:1px solid var(--color-sidebar-search-border)}.sidebar-tree .icon,.sidebar-tree .reference{color:var(--color-sidebar-link-text)}.sidebar-tree .reference{text-decoration:none}.sidebar-tree .reference:hover{background:var(--color-sidebar-item-background--hover)}.sidebar-tree .reference.external:after{color:var(--color-sidebar-link-text)}.sidebar-tree .caption{color:var(--color-sidebar-caption-text)}.sidebar-tree .toctree-l1>.reference,.sidebar-tree .toctree-l1>label .icon{color:var(--color-sidebar-link-text--top-level)}.sidebar-tree label{background:var(--color-sidebar-item-expander-background)}.sidebar-tree label:hover{background:var(--color-sidebar-item-expander-background--hover)}.sidebar-tree .current>.reference{background:var(--color-sidebar-item-background--current)}.sidebar-tree .current>.reference:hover{background:var(--color-sidebar-item-background--hover)}.toc-drawer{background:var(--color-toc-background)}.toc-title{color:var(--color-toc-title-text)}.toc-tree{border-left:1px solid var(--color-background-border)}.toc-tree .reference{text-decoration:none;color:var(--color-toc-item-text)}.toc-tree .scroll-current>.reference{color:var(--color-toc-item-text--active)}article{color:var(--color-content-foreground);background:var(--color-content-background)}a{text-decoration:underline;color:var(--color-link);-webkit-text-decoration-color:var(--color-link-underline);text-decoration-color:var(--color-link-underline)}a:hover{color:var(--color-link--hover);-webkit-text-decoration-color:var(--color-link-underline--hover);text-decoration-color:var(--color-link-underline--hover)}a.muted-link{text-decoration:none}a.muted-link:hover{text-decoration:underline;color:var(--color-link);-webkit-text-decoration-color:var(--color-link-underline);text-decoration-color:var(--color-link-underline)}.problematic{color:var(--color-problematic)}.only-light{display:block!important}.only-dark{display:none!important}@media (prefers-color-scheme:dark){.only-light{display:none!important}.only-dark{display:block!important}}html{font-family:var(--font-stack)}code,kbd,pre,samp{font-family:var(--font-stack--monospace)}body{-webkit-font-smoothing:antialiased;-moz-osx-font-smoothing:grayscale}article{line-height:1.5}h1{font-size:2.25rem}h2{font-size:1.75rem}h3{font-size:1.25rem}h4{font-size:1rem}h5{font-size:.875rem}h6{font-size:.75rem}h1,h2{margin-bottom:1rem;font-weight:300}h1,h2,h3{margin-top:1.5rem}h3{margin-bottom:.75rem;font-weight:400}h4,h5,h6{text-transform:uppercase;margin-top:1rem;margin-bottom:.5rem;font-weight:700}p{margin-top:.75rem;margin-bottom:.75rem}hr.docutils{height:1px;padding:0;margin:2rem 0;background-color:var(--color-background-border);border:0}.centered{text-align:center}:root{--font-stack:-apple-system,BlinkMacSystemFont,Segoe UI,Helvetica,Arial,sans-serif,Apple Color Emoji,Segoe UI Emoji;--font-stack--monospace:"SFMono-Regular",Menlo,Consolas,Monaco,Liberation Mono,Lucida Console,monospace;--font-size--normal:100%;--font-size--small:87.5%;--font-size--small--2:81.25%;--font-size--small--3:75%;--font-size--small--4:62.5%;--sidebar-caption-font-size:var(--font-size--small--2);--sidebar-item-font-size:var(--font-size--small);--sidebar-search-input-font-size:var(--font-size--small);--toc-font-size:var(--font-size--small--3);--toc-font-size--mobile:var(--font-size--normal);--toc-title-font-size:var(--font-size--small--4);--admonition-font-size:0.8125rem;--admonition-title-font-size:0.8125rem;--code-font-size:var(--font-size--small--2);--header-height:calc(var(--sidebar-item-line-height) + var(--sidebar-item-spacing-vertical)*4);--sidebar-tree-space-above:1.5rem;--sidebar-caption-space-above:1rem;--sidebar-item-line-height:1rem;--sidebar-item-spacing-vertical:0.5rem;--sidebar-item-spacing-horizontal:1rem;--sidebar-item-height:calc(var(--sidebar-item-line-height) + var(--sidebar-item-spacing-vertical)*2);--sidebar-expander-width:var(--sidebar-item-height);--sidebar-search-space-above:0.5rem;--sidebar-search-input-spacing-vertical:0.5rem;--sidebar-search-input-spacing-horizontal:0.5rem;--sidebar-search-input-height:1rem;--sidebar-search-icon-size:var(--sidebar-search-input-height);--toc-title-padding:0.25rem 0;--toc-spacing-vertical:1.5rem;--toc-spacing-horizontal:1.5rem;--toc-item-spacing-vertical:0.4rem;--toc-item-spacing-horizontal:1rem;--icon-search:url('data:image/svg+xml;charset=utf-8,<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" stroke-width="1.5" stroke="currentColor" fill="none" stroke-linecap="round" stroke-linejoin="round"><path d="M0 0h24v24H0z" stroke="none"/><circle cx="10" cy="10" r="7"/><path d="M21 21l-6-6"/></svg>');--icon-pencil:url('data:image/svg+xml;charset=utf-8,<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><path d="M20.71 7.04c.39-.39.39-1.04 0-1.41l-2.34-2.34c-.37-.39-1.02-.39-1.41 0l-1.84 1.83 3.75 3.75M3 17.25V21h3.75L17.81 9.93l-3.75-3.75L3 17.25z"/></svg>');--icon-abstract:url('data:image/svg+xml;charset=utf-8,<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><path d="M4 5h16v2H4V5m0 4h16v2H4V9m0 4h16v2H4v-2m0 4h10v2H4v-2z"/></svg>');--icon-info:url('data:image/svg+xml;charset=utf-8,<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><path d="M13 9h-2V7h2m0 10h-2v-6h2m-1-9A10 10 0 002 12a10 10 0 0010 10 10 10 0 0010-10A10 10 0 0012 2z"/></svg>');--icon-flame:url('data:image/svg+xml;charset=utf-8,<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><path d="M17.55 11.2c-.23-.3-.5-.56-.76-.82-.65-.6-1.4-1.03-2.03-1.66C13.3 7.26 13 4.85 13.91 3c-.91.23-1.75.75-2.45 1.32-2.54 2.08-3.54 5.75-2.34 8.9.04.1.08.2.08.33 0 .22-.15.42-.35.5-.22.1-.46.04-.64-.12a.83.83 0 01-.15-.17c-1.1-1.43-1.28-3.48-.53-5.12C5.89 10 5 12.3 5.14 14.47c.04.5.1 1 .27 1.5.14.6.4 1.2.72 1.73 1.04 1.73 2.87 2.97 4.84 3.22 2.1.27 4.35-.12 5.96-1.6 1.8-1.66 2.45-4.32 1.5-6.6l-.13-.26c-.2-.46-.47-.87-.8-1.25l.05-.01m-3.1 6.3c-.28.24-.73.5-1.08.6-1.1.4-2.2-.16-2.87-.82 1.19-.28 1.89-1.16 2.09-2.05.17-.8-.14-1.46-.27-2.23-.12-.74-.1-1.37.18-2.06.17.38.37.76.6 1.06.76 1 1.95 1.44 2.2 2.8.04.14.06.28.06.43.03.82-.32 1.72-.92 2.27h.01z"/></svg>');--icon-question:url('data:image/svg+xml;charset=utf-8,<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><path d="M15.07 11.25l-.9.92C13.45 12.89 13 13.5 13 15h-2v-.5c0-1.11.45-2.11 1.17-2.83l1.24-1.26c.37-.36.59-.86.59-1.41a2 2 0 00-2-2 2 2 0 00-2 2H8a4 4 0 014-4 4 4 0 014 4 3.2 3.2 0 01-.93 2.25M13 19h-2v-2h2M12 2A10 10 0 002 12a10 10 0 0010 10 10 10 0 0010-10c0-5.53-4.5-10-10-10z"/></svg>');--icon-warning:url('data:image/svg+xml;charset=utf-8,<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><path d="M13 14h-2v-4h2m0 8h-2v-2h2M1 21h22L12 2 1 21z"/></svg>');--icon-failure:url('data:image/svg+xml;charset=utf-8,<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><path d="M12 2c5.53 0 10 4.47 10 10s-4.47 10-10 10S2 17.53 2 12 6.47 2 12 2m3.59 5L12 10.59 8.41 7 7 8.41 10.59 12 7 15.59 8.41 17 12 13.41 15.59 17 17 15.59 13.41 12 17 8.41 15.59 7z"/></svg>');--icon-spark:url('data:image/svg+xml;charset=utf-8,<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><path d="M11.5 20l4.86-9.73H13V4l-5 9.73h3.5V20M12 2c2.75 0 5.1 1 7.05 2.95C21 6.9 22 9.25 22 12s-1 5.1-2.95 7.05C17.1 21 14.75 22 12 22s-5.1-1-7.05-2.95C3 17.1 2 14.75 2 12s1-5.1 2.95-7.05C6.9 3 9.25 2 12 2z"/></svg>');--icon-admonition-default:var(--icon-abstract);--color-problematic:#b30000;--color-foreground-primary:#000;--color-foreground-secondary:#5a5c63;--color-foreground-muted:#72747e;--color-foreground-border:#878787;--color-background-primary:#fff;--color-background-secondary:#f8f9fb;--color-background-hover:#efeff4;--color-background-hover--transparent:rgba(239,239,244,0);--color-background-border:#eeebee;--color-announcement-background:rgba(0,0,0,0.8666666666666667);--color-announcement-text:#eeebee;--color-brand-primary:#2962ff;--color-brand-content:#2a5adf;--color-api-overall:var(--color-foreground-muted);--color-api-name:var(--color-brand-content);--color-api-pre-name:var(--color-brand-content);--color-api-paren:var(--color-foreground-secondary);--color-api-keyword:var(--color-problematic);--color-api-highlight-on-target:#ffc;--color-inline-code-background:var(--color-background-secondary);--color-highlighted-background:#def;--color-highlighted-text:var(--color-foreground-primary);--color-guilabel-background:rgba(221,238,255,0.5019607843137255);--color-guilabel-border:rgba(190,218,245,0.5019607843137255);--color-guilabel-text:var(--color-foreground-primary);--color-admonition-background:transparent;--color-admonition-title:#651fff;--color-admonition-title-background:rgba(101,31,255,0.1);--color-admonition-title--caution:#ff9100;--color-admonition-title-background--caution:rgba(255,145,0,0.1);--color-admonition-title--warning:#ff9100;--color-admonition-title-background--warning:rgba(255,145,0,0.1);--color-admonition-title--danger:#ff5252;--color-admonition-title-background--danger:rgba(255,82,82,0.1);--color-admonition-title--attention:#ff5252;--color-admonition-title-background--attention:rgba(255,82,82,0.1);--color-admonition-title--error:#ff5252;--color-admonition-title-background--error:rgba(255,82,82,0.1);--color-admonition-title--hint:#00c852;--color-admonition-title-background--hint:rgba(0,200,82,0.1);--color-admonition-title--important:#00bfa5;--color-admonition-title-background--important:rgba(0,191,165,0.1);--color-admonition-title--note:#00b0ff;--color-admonition-title-background--note:rgba(0,176,255,0.1);--color-admonition-title--seealso:#448aff;--color-admonition-title-background--seealso:rgba(68,138,255,0.1);--color-admonition-title--tip:#00c852;--color-admonition-title-background--tip:rgba(0,200,82,0.1);--color-admonition-title--admonition-todo:grey;--color-admonition-title-background--admonition-todo:hsla(0,0%,50.2%,0.1);--color-header-background:var(--color-background-primary);--color-header-border:var(--color-background-border);--color-header-text:var(--color-foreground-primary);--color-sidebar-background:var(--color-background-secondary);--color-sidebar-background-border:var(--color-background-border);--color-sidebar-brand-text:var(--color-foreground-primary);--color-sidebar-caption-text:var(--color-foreground-muted);--color-sidebar-link-text:var(--color-foreground-secondary);--color-sidebar-link-text--top-level:var(--color-brand-primary);--color-sidebar-item-background:var(--color-sidebar-background);--color-sidebar-item-background--current:var(--color-sidebar-item-background);--color-sidebar-item-background--hover:linear-gradient(90deg,var(--color-background-hover--transparent),var(--color-background-hover) var(--sidebar-item-spacing-horizontal),var(--color-background-hover));--color-sidebar-item-expander-background:transparent;--color-sidebar-item-expander-background--hover:var(--color-background-hover);--color-sidebar-search-text:var(--color-foreground-primary);--color-sidebar-search-background:var(--color-background-secondary);--color-sidebar-search-background--focus:var(--color-background-primary);--color-sidebar-search-border:var(--color-background-border);--color-sidebar-search-icon:var(--color-foreground-muted);--color-toc-background:var(--color-background-primary);--color-toc-title-text:var(--color-foreground-muted);--color-toc-item-text:var(--color-foreground-secondary);--color-toc-item-text--hover:var(--color-foreground-primary);--color-toc-item-text--active:var(--color-brand-primary);--color-content-foreground:var(--color-foreground-primary);--color-content-background:transparent;--color-link:var(--color-brand-content);--color-link--hover:var(--color-brand-content);--color-link-underline:var(--color-background-border);--color-link-underline--hover:var(--color-foreground-border)}@media (prefers-color-scheme:dark){:root{--color-problematic:#e25050;--color-foreground-primary:hsla(0,0%,100%,0.8509803921568627);--color-foreground-secondary:#9ca0a5;--color-foreground-muted:#81868d;--color-foreground-border:#666;--color-background-primary:#131416;--color-background-secondary:#1a1c1e;--color-background-hover:#1e2124;--color-background-hover--transparent:rgba(30,33,36,0);--color-background-border:#303335;--color-announcement-background:rgba(0,0,0,0.8666666666666667);--color-announcement-text:#eeebee;--color-brand-primary:#2b8cee;--color-brand-content:#368ce2;--color-highlighted-background:#083563;--color-guilabel-background:rgba(8,53,99,0.5019607843137255);--color-guilabel-border:rgba(19,57,95,0.5019607843137255);--color-api-highlight-on-target:#330;--color-admonition-background:#18181a}}html{overflow-x:hidden;overflow-y:scroll}:not(html):not(body){scrollbar-width:thin;scrollbar-color:var(--color-foreground-border) transparent}:not(html):not(body)::-webkit-scrollbar{width:.25rem;height:.25rem}:not(html):not(body)::-webkit-scrollbar-thumb{background-color:var(--color-foreground-border);border-radius:.125rem}body,html{height:100%}.page{display:flex;min-height:100%}.mobile-header{width:100%;height:var(--header-height);background-color:var(--color-header-background);color:var(--color-header-text);border-bottom:1px solid var(--color-header-border);z-index:10;display:none}.mobile-header.scrolled{border-bottom:none;box-shadow:0 0 .2rem rgba(0,0,0,.1),0 .2rem .4rem rgba(0,0,0,.2)}.main{display:flex;flex:1}.sidebar-drawer{box-sizing:border-box;display:flex;justify-content:flex-end;width:calc(50% - 26em);min-width:15em}.sidebar-container,.toc-drawer{box-sizing:border-box;width:15em}.toc-drawer{padding-right:1rem}.sidebar-sticky,.toc-sticky{position:-webkit-sticky;position:sticky;top:0;height:min(100%,100vh);height:100vh;display:flex;flex-direction:column}.sidebar-scroll,.toc-scroll{flex-shrink:1;overflow:auto;scroll-behavior:smooth}.content{padding:0 3em;width:46em;display:flex;flex-direction:column;justify-content:space-between}.icon{display:inline-block;height:1rem;width:1rem}.icon svg{width:100%;height:100%}.announcement{height:var(--header-height);display:flex;align-items:center;overflow-x:auto}.announcement+.page{min-height:calc(100% - var(--header-height))}.announcement-content{box-sizing:border-box;padding:.5rem;min-width:100%;white-space:nowrap;text-align:center}.nav-overlay-icon,.toc-overlay-icon{display:none;cursor:pointer}.nav-overlay-icon .icon,.toc-overlay-icon .icon{color:var(--color-foreground-secondary);height:1.25rem;width:1.25rem}.nav-overlay-icon,.toc-header-icon{justify-content:center;align-items:center}.toc-content-icon{height:1.5rem;width:1.5rem;margin-top:1.5rem;float:right}.sidebar-toggle{position:absolute;display:none}.sidebar-toggle[name=__toc]{left:20px}.sidebar-toggle:checked{left:40px}.overlay{position:fixed;top:0;width:0;height:0;transition:width 0ms,height 0ms,opacity .25s ease-out;opacity:0;background-color:rgba(0,0,0,.54)}.sidebar-overlay{z-index:20}.toc-overlay{z-index:40}.sidebar-drawer{z-index:30;transition:left .25s ease-in-out}.toc-drawer{z-index:50;transition:right .25s ease-in-out}#__navigation:checked~.sidebar-overlay{width:100%;height:100%;opacity:1}#__navigation:checked~.page .sidebar-drawer{top:0;left:0}#__toc:checked~.toc-overlay{width:100%;height:100%;opacity:1}#__toc:checked~.page .toc-drawer{top:0;right:0}@media (min-width:97em){html{font-size:110%}}@media (max-width:82em){.toc-content-icon{display:flex}.toc-drawer{position:fixed;height:100vh;top:0;right:-15em;border-left:1px solid var(--color-background-muted)}.toc-tree{border-left:none;font-size:var(--toc-font-size--mobile)}.sidebar-drawer{width:calc(50% - 18.5em)}}@media (max-width:67em){.nav-overlay-icon{display:flex}.sidebar-drawer{position:fixed;height:100vh;width:15em;top:0;left:-15em}.toc-header-icon{display:flex}.toc-content-icon{display:none}.mobile-header{position:-webkit-sticky;position:sticky;top:0;display:flex;justify-content:space-between;align-items:center}.mobile-header .header-left,.mobile-header .header-right{display:flex;height:var(--header-height);width:var(--header-height)}.mobile-header .header-left label,.mobile-header .header-right label{height:100%;width:100%}:target{scroll-margin-top:var(--header-height)}.page{flex-direction:column;justify-content:center}.content{margin-left:auto;margin-right:auto}}@media (max-width:52em){.content{width:100%;overflow-x:auto}}@media (max-width:46em){.content{padding:0 1em}article div.sidebar{float:none;width:100%;margin:1rem 0}}.admonition{margin:1rem auto;padding:0 .5rem .5rem;background:var(--color-admonition-background);border-radius:.2rem;border-left:.2rem solid var(--color-admonition-title);box-shadow:0 .2rem .5rem rgba(0,0,0,.05),0 0 .0625rem rgba(0,0,0,.1);font-size:var(--admonition-font-size);overflow:hidden;page-break-inside:avoid}.admonition>:nth-child(2){margin-top:0}.admonition>:last-child{margin-bottom:0}.admonition p.admonition-title{position:relative;margin:0 -.5rem .5rem;padding:.5rem .5rem .5rem 2rem;font-weight:500;font-size:var(--admonition-title-font-size);background-color:var(--color-admonition-title-background);line-height:1.3}.admonition p.admonition-title:before{content:"";position:absolute;left:.5rem;width:1rem;height:1rem;background-color:var(--color-admonition-title);-webkit-mask-image:var(--icon-admonition-default);mask-image:var(--icon-admonition-default);-webkit-mask-repeat:no-repeat;mask-repeat:no-repeat}.admonition.caution{border-left-color:var(--color-admonition-title--caution)}.admonition.caution>.admonition-title{background-color:var(--color-admonition-title-background--caution)}.admonition.caution>.admonition-title:before{background-color:var(--color-admonition-title--caution);-webkit-mask-image:var(--icon-spark);mask-image:var(--icon-spark)}.admonition.warning{border-left-color:var(--color-admonition-title--warning)}.admonition.warning>.admonition-title{background-color:var(--color-admonition-title-background--warning)}.admonition.warning>.admonition-title:before{background-color:var(--color-admonition-title--warning);-webkit-mask-image:var(--icon-warning);mask-image:var(--icon-warning)}.admonition.danger{border-left-color:var(--color-admonition-title--danger)}.admonition.danger>.admonition-title{background-color:var(--color-admonition-title-background--danger)}.admonition.danger>.admonition-title:before{background-color:var(--color-admonition-title--danger);-webkit-mask-image:var(--icon-spark);mask-image:var(--icon-spark)}.admonition.attention{border-left-color:var(--color-admonition-title--attention)}.admonition.attention>.admonition-title{background-color:var(--color-admonition-title-background--attention)}.admonition.attention>.admonition-title:before{background-color:var(--color-admonition-title--attention);-webkit-mask-image:var(--icon-warning);mask-image:var(--icon-warning)}.admonition.error{border-left-color:var(--color-admonition-title--error)}.admonition.error>.admonition-title{background-color:var(--color-admonition-title-background--error)}.admonition.error>.admonition-title:before{background-color:var(--color-admonition-title--error);-webkit-mask-image:var(--icon-failure);mask-image:var(--icon-failure)}.admonition.hint{border-left-color:var(--color-admonition-title--hint)}.admonition.hint>.admonition-title{background-color:var(--color-admonition-title-background--hint)}.admonition.hint>.admonition-title:before{background-color:var(--color-admonition-title--hint);-webkit-mask-image:var(--icon-question);mask-image:var(--icon-question)}.admonition.important{border-left-color:var(--color-admonition-title--important)}.admonition.important>.admonition-title{background-color:var(--color-admonition-title-background--important)}.admonition.important>.admonition-title:before{background-color:var(--color-admonition-title--important);-webkit-mask-image:var(--icon-flame);mask-image:var(--icon-flame)}.admonition.note{border-left-color:var(--color-admonition-title--note)}.admonition.note>.admonition-title{background-color:var(--color-admonition-title-background--note)}.admonition.note>.admonition-title:before{background-color:var(--color-admonition-title--note);-webkit-mask-image:var(--icon-pencil);mask-image:var(--icon-pencil)}.admonition.seealso{border-left-color:var(--color-admonition-title--seealso)}.admonition.seealso>.admonition-title{background-color:var(--color-admonition-title-background--seealso)}.admonition.seealso>.admonition-title:before{background-color:var(--color-admonition-title--seealso);-webkit-mask-image:var(--icon-info);mask-image:var(--icon-info)}.admonition.tip{border-left-color:var(--color-admonition-title--tip)}.admonition.tip>.admonition-title{background-color:var(--color-admonition-title-background--tip)}.admonition.tip>.admonition-title:before{background-color:var(--color-admonition-title--tip);-webkit-mask-image:var(--icon-info);mask-image:var(--icon-info)}.admonition.admonition-todo{border-left-color:var(--color-admonition-title--admonition-todo)}.admonition.admonition-todo>.admonition-title{background-color:var(--color-admonition-title-background--admonition-todo)}.admonition.admonition-todo>.admonition-title:before{background-color:var(--color-admonition-title--admonition-todo);-webkit-mask-image:var(--icon-pencil);mask-image:var(--icon-pencil)}.admonition-todo>.admonition-title{text-transform:uppercase}dl.c dd,dl.cpp dd,dl.js dd,dl.py dd{margin-left:2rem}dl.c dd>:first-child,dl.cpp dd>:first-child,dl.js dd>:first-child,dl.py dd>:first-child{margin-top:.125rem}dl.c dd>:last-child,dl.cpp dd>:last-child,dl.js dd>:last-child,dl.py dd>:last-child{margin-bottom:1.25rem}dl.c .field-list,dl.cpp .field-list,dl.js .field-list,dl.py .field-list{margin-bottom:.75rem}dl.c .field-list dt,dl.cpp .field-list dt,dl.js .field-list dt,dl.py .field-list dt{text-transform:uppercase;font-size:var(--font-size--small)}dl.c .field-list dd:empty,dl.cpp .field-list dd:empty,dl.js .field-list dd:empty,dl.py .field-list dd:empty{margin-bottom:.5rem}dl.c .field-list dd>ul,dl.cpp .field-list dd>ul,dl.js .field-list dd>ul,dl.py .field-list dd>ul{margin-left:-1.2rem}dl.c .field-list dd>ul>li>p:nth-child(2),dl.cpp .field-list dd>ul>li>p:nth-child(2),dl.js .field-list dd>ul>li>p:nth-child(2),dl.py .field-list dd>ul>li>p:nth-child(2){margin-top:0}dl.c .field-list dd>ul>li>p+p:last-child:empty,dl.cpp .field-list dd>ul>li>p+p:last-child:empty,dl.js .field-list dd>ul>li>p+p:last-child:empty,dl.py .field-list dd>ul>li>p+p:last-child:empty{margin-top:0;margin-bottom:0}dl.c>dt,dl.cpp>dt,dl.js>dt,dl.py>dt{color:var(--color-api-overall)}dl.c>dt:target,dl.cpp>dt:target,dl.js>dt:target,dl.py>dt:target{background-color:var(--color-api-highlight-on-target)}dl.class>dt,dl.enum-class>dt,dl.enum-struct>dt,dl.enum>dt,dl.exception>dt,dl.function>dt,dl.method>dt,dl.type>dt{padding-left:3em;text-indent:-3em}dl.class>dt .property,dl.enum-class>dt .property,dl.enum-struct>dt .property,dl.enum>dt .property,dl.exception>dt .property,dl.function>dt .property,dl.method>dt .property,dl.type>dt .property{color:var(--color-api-keyword);padding-right:.25rem}.sig-name{font-weight:700;color:var(--color-api-name)}.sig-prename{color:var(--color-api-pre-name)}.sig-paren{color:var(--color-api-paren)}.sig-param{font-style:normal}.versionmodified{font-style:italic}div.deprecated p,div.versionadded p,div.versionchanged p{margin-top:.125rem;margin-bottom:.125rem}.viewcode-back,.viewcode-link{float:right;font-size:var(--font-size--small)}.code-block-caption,article p.caption,table>caption{font-size:var(--font-size--small);text-align:center}.toctree-wrapper.compound .caption{font-size:var(--font-size--small);text-transform:uppercase;text-align:initial;margin-bottom:0}.toctree-wrapper.compound>ul{margin-top:0;margin-bottom:0}code.literal{background:var(--color-inline-code-background);border-radius:.2em;font-size:var(--font-size--small--2);padding:.1em .2em}article div[class*=" highlight-"],article div[class^=highlight-]{margin:1em 0;display:flex}pre{margin:0;padding:0}article pre{line-height:1.5}.highlight pre,pre.literal-block{font-size:var(--code-font-size);padding:.625rem .875rem;overflow:auto}pre.literal-block{margin-top:1rem;margin-bottom:1rem;border-radius:.2rem;background-color:var(--color-code-background);color:var(--color-code-foreground)}.highlight{width:100%;border-radius:.2rem}.highlighttable{width:100%;display:block}.highlighttable tbody{display:block}.highlighttable tr{display:flex}.highlighttable td.linenos{background-color:var(--color-code-background);color:var(--color-code-foreground);padding:.625rem 0 .625rem .875rem;border-top-left-radius:.2rem;border-bottom-left-radius:.2rem}.highlighttable .linenodiv{font-size:var(--code-font-size);padding-right:.5rem;box-shadow:-.0625rem 0 var(--color-code-foreground) inset;opacity:.5}.highlighttable td.code{padding:0;display:block;flex:1;overflow:hidden}.highlighttable td.code .highlight{border-top-left-radius:0;border-bottom-left-radius:0}.footnote-reference{font-size:var(--font-size--small--4);vertical-align:super}dl.footnote{font-size:var(--font-size--small);color:var(--color-foreground-secondary);display:grid;grid-template-columns:-webkit-max-content auto;grid-template-columns:max-content auto}dl.footnote dt{margin:0}dl.footnote dt>.fn-backref{margin-left:.25rem}dl.footnote dt:after{content:":"}dl.footnote dt .brackets:before{content:"["}dl.footnote dt .brackets:after{content:"]"}img{box-sizing:border-box;max-width:100%;height:auto}article .figure{border-radius:.2rem;padding:.5rem}article .figure :last-child{margin-bottom:0}article .align-left{float:left;clear:left;margin:0 1rem 1rem}article .align-right{float:right;clear:right;margin:0 1rem 1rem}article .align-center,article .figure.align-default,article .legend .align-default{text-align:center;margin-left:auto;margin-right:auto}article .figure.align-default,article .legend .align-default{display:block}.genindex-jumpbox{border-top:1px solid var(--color-background-border);border-bottom:1px solid var(--color-background-border);padding:.25rem}.genindex-section h2{margin-top:.75rem;margin-bottom:.5rem}.genindex-section ul{margin-top:0;margin-bottom:0}ol,ul{padding-left:1.2rem;margin-top:1rem;margin-bottom:1rem}ol li>p:first-child,ul li>p:first-child{margin-top:.25rem;margin-bottom:.25rem}ol li>p:last-child,ul li>p:last-child{margin-top:.25rem}ol li>ol,ol li>ul,ul li>ol,ul li>ul{margin-top:.5rem;margin-bottom:.5rem}.simple li>ol,.simple li>ul,.toctree-wrapper li>ol,.toctree-wrapper li>ul{margin-top:0;margin-bottom:0}.field-list dt,.option-list dt,dl.footnote dt,dl.glossary dt,dl.simple dt,dl:not([class]) dt{font-weight:500;margin-top:.25rem}.field-list dt+dt,.option-list dt+dt,dl.footnote dt+dt,dl.glossary dt+dt,dl.simple dt+dt,dl:not([class]) dt+dt{margin-top:0}.field-list dt .classifier:before,.option-list dt .classifier:before,dl.footnote dt .classifier:before,dl.glossary dt .classifier:before,dl.simple dt .classifier:before,dl:not([class]) dt .classifier:before{content:":";margin-left:.2rem;margin-right:.2rem}.field-list dd>p:first-child,.field-list dd ul,.option-list dd>p:first-child,.option-list dd ul,dl.footnote dd>p:first-child,dl.footnote dd ul,dl.glossary dd>p:first-child,dl.glossary dd ul,dl.simple dd>p:first-child,dl.simple dd ul,dl:not([class]) dd>p:first-child,dl:not([class]) dd ul{margin-top:.125rem}.field-list dd ul,.option-list dd ul,dl.footnote dd ul,dl.glossary dd ul,dl.simple dd ul,dl:not([class]) dd ul{margin-bottom:.125rem}.math-wrapper{width:100%;overflow-x:auto}abbr[title]{cursor:help}kbd:not(.compound){margin:0 .2rem;padding:0 .2rem;border-radius:.2rem;border:1px solid var(--color-foreground-border);color:var(--color-foreground-primary);vertical-align:text-bottom;font-size:var(--font-size--small--3);display:inline-block;box-shadow:0 .0625rem 0 rgba(0,0,0,.2),inset 0 0 0 .125rem var(--color-background-primary);background-color:var(--color-background-secondary)}blockquote{border-left:1px solid var(--color-foreground-border);font-style:italic;margin-left:.5rem;margin-right:.5rem;padding:.5rem 1rem}.reference img{vertical-align:middle}.code-block-caption>.headerlink,dl dt>.headerlink,h1>.headerlink,h2>.headerlink,h3>.headerlink,h4>.headerlink,h5>.headerlink,h6>.headerlink,p.caption>.headerlink,table>caption>.headerlink{font-weight:100;margin-left:.5rem;visibility:hidden;text-decoration:none}.code-block-caption:hover>.headerlink,:target>h1:first-child>.headerlink,:target>h2:first-child>.headerlink,:target>h3:first-child>.headerlink,:target>h4:first-child>.headerlink,:target>h5:first-child>.headerlink,:target>h6:first-child>.headerlink,dl dt:hover>.headerlink,h1:hover>.headerlink,h2:hover>.headerlink,h3:hover>.headerlink,h4:hover>.headerlink,h5:hover>.headerlink,h6:hover>.headerlink,p.caption:hover>.headerlink,table>caption:hover>.headerlink{visibility:visible}p.rubric{text-transform:uppercase;font-size:var(--font-size--small)}article .sidebar{float:right;clear:right;width:30%;margin-left:1rem;margin-right:0;border-radius:.2rem;background-color:var(--color-background-secondary);border:1px solid var(--color-background-border)}article .sidebar>*{padding-left:1rem;padding-right:1rem}article .sidebar .sidebar-title{margin:0;padding:.5rem 1rem;border-bottom:1px solid var(--color-background-border);font-weight:500}.table-wrapper{width:100%;overflow-x:auto;margin-top:1rem;margin-bottom:.5rem;padding:.2rem .2rem .75rem}table.docutils{border-radius:.2rem;border-spacing:0;border-collapse:collapse;box-shadow:0 .2rem .5rem rgba(0,0,0,.05),0 0 .0625rem rgba(0,0,0,.1)}table.docutils th{background:var(--color-background-secondary)}table.docutils td,table.docutils th{padding:0 .25rem;border-left:1px solid var(--color-background-border);border-right:1px solid var(--color-background-border);border-bottom:1px solid var(--color-background-border)}table.docutils td p,table.docutils th p{margin:.25rem}table.docutils td:first-child,table.docutils th:first-child{border-left:none}table.docutils td:last-child,table.docutils th:last-child{border-right:none}.guilabel{background-color:var(--color-guilabel-background);border:1px solid var(--color-guilabel-border);color:var(--color-guilabel-text);padding:0 .3em;border-radius:.5em;font-size:.9em}footer{font-size:var(--font-size--small);display:flex;flex-direction:column;margin-top:2rem}.related-information{margin-top:1rem;padding:.75rem .75rem 1rem;border-top:1px solid var(--color-background-border);line-height:1.5;color:var(--color-foreground-secondary)}.related-pages a{display:flex;align-items:center;text-decoration:none}.related-pages a:hover .page-info .title{text-decoration:underline;color:var(--color-link);-webkit-text-decoration-color:var(--color-link-underline);text-decoration-color:var(--color-link-underline)}.related-pages a svg,.related-pages a svg>use{flex-shrink:0;color:var(--color-foreground-border);width:.75rem;height:.75rem;margin:0 .5rem}.related-pages a.next-page{max-width:50%;float:right;clear:right;text-align:right}.related-pages a.prev-page{max-width:50%;float:left;clear:left}.related-pages a.prev-page svg{transform:rotate(180deg)}.page-info{display:flex;flex-direction:column}.next-page .page-info{align-items:flex-end}.page-info .context{display:flex;align-items:center;padding-bottom:.1rem;color:var(--color-foreground-muted);font-size:var(--font-size--small);text-decoration:none}ul.search{padding-left:0;list-style:none}ul.search li{padding:1rem 0;border-bottom:1px solid var(--color-background-border)}.highlighted{background-color:var(--color-highlighted-background);color:var(--color-highlighted-text)}.sidebar-brand{display:flex;flex-direction:column;flex-shrink:0;padding:var(--sidebar-item-spacing-vertical) var(--sidebar-item-spacing-horizontal);text-decoration:none}.sidebar-brand-text{overflow-wrap:break-word;font-size:1.5rem}.sidebar-brand-text,.sidebar-logo-container{margin:var(--sidebar-item-spacing-vertical) 0}.sidebar-logo{margin:0 auto;display:block;max-width:100%}.sidebar-search-container{display:flex;align-items:center;margin-top:var(--sidebar-search-space-above);position:relative}.sidebar-search-container:before{content:"";position:absolute;left:var(--sidebar-item-spacing-horizontal);width:var(--sidebar-search-icon-size);height:var(--sidebar-search-icon-size)}.sidebar-search{box-sizing:border-box;padding:var(--sidebar-search-input-spacing-vertical) var(--sidebar-search-input-spacing-horizontal) var(--sidebar-search-input-spacing-vertical) calc(var(--sidebar-item-spacing-horizontal) + var(--sidebar-search-input-spacing-horizontal) + var(--sidebar-search-icon-size));width:100%;color:var(--color-sidebar-search-foreground);background:transparent;z-index:10}.sidebar-search:focus{outline:none}.sidebar-search::-moz-placeholder{font-size:var(--sidebar-search-input-font-size)}.sidebar-search:-ms-input-placeholder{font-size:var(--sidebar-search-input-font-size)}.sidebar-search::placeholder{font-size:var(--sidebar-search-input-font-size)}.sidebar-tree{font-size:var(--sidebar-item-font-size);margin-top:var(--sidebar-tree-space-above);margin-bottom:var(--sidebar-item-spacing-vertical)}.sidebar-tree ul{padding:0;margin-top:0;margin-bottom:0;display:flex;flex-direction:column;list-style:none}.sidebar-tree li{position:relative;margin:0}.sidebar-tree li>ul{margin-left:var(--sidebar-item-spacing-horizontal)}.sidebar-tree .reference{box-sizing:border-box;display:inline-block;line-height:var(--sidebar-item-line-height);height:100%;width:100%;padding:var(--sidebar-item-spacing-vertical) var(--sidebar-item-spacing-horizontal)}.sidebar-tree .reference.external:after{content:url("data:image/svg+xml;charset=utf-8,%3Csvg width='12' height='12' xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24' stroke-width='1.5' stroke='%23607D8B' fill='none' stroke-linecap='round' stroke-linejoin='round'%3E%3Cpath d='M0 0h24v24H0z' stroke='none'/%3E%3Cpath d='M11 7H6a2 2 0 00-2 2v9a2 2 0 002 2h9a2 2 0 002-2v-5M10 14L20 4M15 4h5v5'/%3E%3C/svg%3E");margin:0 .25rem;vertical-align:middle}.sidebar-tree .current-page>.reference{font-weight:700}.sidebar-tree label{position:absolute;top:0;right:0;height:var(--sidebar-item-height);width:var(--sidebar-expander-width);cursor:pointer;display:flex;justify-content:center;align-items:center}.sidebar-tree .caption{font-size:var(--sidebar-caption-font-size);font-weight:700;text-transform:uppercase;margin:var(--sidebar-caption-space-above) 0 0 0;padding:var(--sidebar-item-spacing-vertical) var(--sidebar-item-spacing-horizontal)}.sidebar-tree li.has-children>.reference{padding-right:var(--sidebar-expander-width)}.toctree-checkbox{position:absolute;display:none}.toctree-checkbox~ul{display:none}.toctree-checkbox~label .icon svg{transform:rotate(90deg)}.toctree-checkbox:checked~ul{display:block}.toctree-checkbox:checked~label .icon svg{transform:rotate(-90deg)}.toc-title-container{padding:var(--toc-title-padding);padding-top:var(--toc-spacing-vertical)}.toc-title{font-size:var(--toc-title-font-size);padding-left:var(--toc-spacing-horizontal);text-transform:uppercase}.no-toc{display:none}.toc-tree-container{padding-bottom:var(--toc-spacing-vertical)}.toc-tree{font-size:var(--toc-font-size);line-height:1.3;padding-left:calc(var(--toc-spacing-horizontal) - var(--toc-item-spacing-horizontal))}.toc-tree>ul>li:first-child{padding-top:0}.toc-tree>ul>li:first-child>ul{padding-left:0}.toc-tree>ul>li:first-child>a{display:none}.toc-tree ul{list-style-type:none;margin-top:0;margin-bottom:0;padding-left:var(--toc-item-spacing-horizontal)}.toc-tree li{padding-top:var(--toc-item-spacing-vertical)}.toc-tree li .reference{word-break:break-word;text-decoration:none}.toc-tree li.scroll-current>.reference{font-weight:700}.toc-scroll{max-height:100vh;overflow-y:scroll}.contents:not(.this-will-duplicate-information-and-it-is-still-useful-here){color:var(--color-problematic);background:rgba(255,0,0,.25)}.contents:not(.this-will-duplicate-information-and-it-is-still-useful-here):before{content:"ERROR: Adding a table of contents in Furo-based documentation is unnecessary, and does not work well with existing styling. Add a 'this-will-duplicate-information-and-it-is-still-useful-here' class, if you want an escape hatch."}
+/*# sourceMappingURL=furo.css.map */
diff --git a/docs/api/sphinx/furo/theme/furo/static/styles/furo.css.map b/docs/api/sphinx/furo/theme/furo/static/styles/furo.css.map
new file mode 100644
index 00000000..dc54e623
--- /dev/null
+++ b/docs/api/sphinx/furo/theme/furo/static/styles/furo.css.map
@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../node_modules/normalize.css/normalize.css","base/_theme.sass","furo.css","base/_typography.sass","variables/_index.scss","_scaffold.sass","content/_admonitions.sass","content/_api.sass","content/_captions.sass","content/_code.sass","content/_footnotes.sass","content/_images.sass","content/_indexes.sass","content/_lists.sass","content/_math.sass","content/_misc.sass","content/_permalinks.sass","content/_rubrics.sass","content/_sidebar.sass","content/_tables.sass","content/_gui-labels.sass","components/_footer.sass","components/_search.sass","components/_sidebar.sass","components/_table_of_contents.sass"],"names":[],"mappings":"AAAA,2EAA2E,CAU3E,KACE,gBAAiB,CACjB,6BACF,CASA,KACE,QACF,CAMA,KACE,aACF,CAOA,GACE,aAAc,CACd,cACF,CAUA,GACE,sBAAuB,CACvB,QAAS,CACT,gBACF,CAOA,IACE,+BAAiC,CACjC,aACF,CASA,EACE,4BACF,CAOA,YACE,kBAAmB,CACnB,yBAA0B,CAC1B,wCAAiC,CAAjC,gCACF,CAMA,SAEE,kBACF,CAOA,cAGE,+BAAiC,CACjC,aACF,CAMA,MACE,aACF,CAOA,QAEE,aAAc,CACd,aAAc,CACd,iBAAkB,CAClB,uBACF,CAEA,IACE,aACF,CAEA,IACE,SACF,CASA,IACE,iBACF,CAUA,sCAKE,mBAAoB,CACpB,cAAe,CACf,gBAAiB,CACjB,QACF,CAOA,aAEE,gBACF,CAOA,cAEE,mBACF,CAMA,gDAIE,yBACF,CAMA,wHAIE,iBAAkB,CAClB,SACF,CAMA,4GAIE,6BACF,CAMA,SACE,0BACF,CASA,OACE,qBAAsB,CACtB,aAAc,CACd,aAAc,CACd,cAAe,CACf,SAAU,CACV,kBACF,CAMA,SACE,uBACF,CAMA,SACE,aACF,CAOA,6BAEE,qBAAsB,CACtB,SACF,CAMA,kFAEE,WACF,CAOA,cACE,4BAA6B,CAC7B,mBACF,CAMA,yCACE,uBACF,CAOA,6BACE,yBAA0B,CAC1B,YACF,CASA,QACE,aACF,CAMA,QACE,iBACF,CAiBA,kBACE,YACF,CCtVA,KACE,qCAAA,CACA,0CCJF,CDWI,gCACE,8BAAA,CACA,oBCRN,CDaA,cACE,qDAAA,CACA,oCCVF,CDeA,gBACE,6DAAA,CACA,0CCZF,CDcA,eACE,qCCXF,CDaA,0BACE,iDCVF,CDWE,uEAEE,wDCVJ,CDYE,iCACE,iDAAA,CACA,qCAAA,CAAA,6BCVJ,CDYA,gBACE,WAAA,CACA,uDAAA,CACA,0DCTF,CDcE,6CADE,oCCLJ,CDME,yBACE,oBCPJ,CDSI,+BACE,sDCPN,CDSI,wCAEE,oCCRN,CDSE,uBACE,uCCPJ,CDWI,2EAEE,+CCVN,CDaE,oBACE,wDCXJ,CDYI,0BACE,+DCVN,CDYE,kCACE,wDCVJ,CDWI,wCACE,sDCTN,CDeA,YACE,sCCZF,CDcA,WACE,iCCXF,CDaA,UACE,oDCVF,CDYE,qBACE,oBAAA,CACA,gCCVJ,CDYE,qCACE,wCCVJ,CDeA,QACE,qCAAA,CACA,0CCZF,CDcA,EACE,yBAAA,CAEA,uBAAA,CACA,yDAAA,CAAA,iDCZF,CDcE,QACE,8BAAA,CACA,gEAAA,CAAA,wDCZJ,CDaE,aACE,oBCXJ,CDYI,mBACE,yBAAA,CACA,uBAAA,CACA,yDAAA,CAAA,iDCVN,CDYA,aACE,8BCTF,CDYA,YACE,uBCTF,CDUA,WACE,sBCPF,CDSA,mCACE,YACE,sBCNF,CDOA,WACE,uBCJF,CACF,CCrIA,KACE,6BDuIF,CCtIA,kBAIE,wCDyIF,CCtIA,KACE,kCAAA,CACA,iCDyIF,CCtIA,QACE,eDyIF,CCpIA,GACE,iBDuIF,CCtIA,GACE,iBDyIF,CCxIA,GACE,iBD2IF,CC1IA,GACE,cD6IF,CC5IA,GACE,iBD+IF,CC9IA,GACE,gBDiJF,CC9IA,MAGE,kBAAA,CACA,eDiJF,CC/IA,SAJE,iBDyJF,CCrJA,GAEE,oBAAA,CACA,eDkJF,CC/IA,SAGE,wBAAA,CACA,eAAA,CACA,mBAAA,CACA,eDkJF,CC/IA,EACE,iBAAA,CACA,oBDkJF,CC/IA,YACE,UAAA,CACA,SAAA,CACA,aAAA,CACA,+CAAA,CACA,QDkJF,CChJA,UACE,iBDmJF,CEzLA,MAKE,kHAAA,CAEA,uGAAA,CAGA,wBAAA,CACA,wBAAA,CACA,4BAAA,CACA,yBAAA,CACA,2BAAA,CAGA,sDAAA,CACA,gDAAA,CACA,wDAAA,CAGA,0CAAA,CACA,gDAAA,CACA,gDAAA,CAGA,gCAAA,CACA,sCAAA,CAGA,2CAAA,CAKA,8FAAA,CAKA,iCAAA,CACA,kCAAA,CAEA,+BAAA,CACA,sCAAA,CACA,sCAAA,CACA,oGAAA,CAIA,mDAAA,CAEA,mCAAA,CACA,8CAAA,CACA,gDAAA,CACA,kCAAA,CACA,6DAAA,CAGA,6BAAA,CACA,6BAAA,CACA,+BAAA,CACA,kCAAA,CACA,kCAAA,CAME,yTAAA,CAAA,8QAAA,CAAA,6LAAA,CAAA,+NAAA,CAAA,8wBAAA,CAAA,qZAAA,CAAA,kLAAA,CAAA,mTAAA,CAAA,0UAAA,CAEF,8CAAA,CAQA,2BAAA,CAGA,+BAAA,CACA,oCAAA,CACA,gCAAA,CACA,iCAAA,CAEA,+BAAA,CACA,oCAAA,CACA,gCAAA,CACA,yDAAA,CACA,iCAAA,CAGA,8DAAA,CACA,iCAAA,CAGA,6BAAA,CACA,6BAAA,CAGA,iDAAA,CACA,2CAAA,CACA,+CAAA,CACA,mDAAA,CACA,4CAAA,CACA,oCAAA,CAGA,gEAAA,CAGA,mCAAA,CACA,wDAAA,CAGA,gEAAA,CACA,4DAAA,CACA,qDAAA,CAGA,yCAAA,CACA,gCAAA,CACA,wDAAA,CAGE,yCAAA,CACA,gEAAA,CADA,yCAAA,CACA,gEAAA,CADA,wCAAA,CACA,+DAAA,CADA,2CAAA,CACA,kEAAA,CADA,uCAAA,CACA,8DAAA,CADA,sCAAA,CACA,4DAAA,CADA,2CAAA,CACA,kEAAA,CADA,sCAAA,CACA,6DAAA,CADA,yCAAA,CACA,iEAAA,CADA,qCAAA,CACA,2DAAA,CADA,8CAAA,CACA,yEAAA,CAcF,yDAAA,CACA,oDAAA,CACA,mDAAA,CAGA,4DAAA,CACA,gEAAA,CAEA,0DAAA,CACA,0DAAA,CACA,2DAAA,CACA,+DAAA,CAEA,+DAAA,CACA,6EAAA,CAGA,2MAAA,CAOA,oDAAA,CACA,6EAAA,CAIA,2DAAA,CACA,mEAAA,CACA,wEAAA,CACA,4DAAA,CACA,yDAAA,CAGA,sDAAA,CACA,oDAAA,CACA,uDAAA,CACA,4DAAA,CACA,wDAAA,CAGA,0DAAA,CACA,sCAAA,CAEA,uCAAA,CACA,8CAAA,CACA,qDAAA,CACA,4DFwIF,CErIA,mCACE,MACE,2BAAA,CAGA,6DAAA,CACA,oCAAA,CACA,gCAAA,CACA,8BAAA,CAEA,kCAAA,CACA,oCAAA,CACA,gCAAA,CACA,sDAAA,CACA,iCAAA,CAGA,8DAAA,CACA,iCAAA,CAGA,6BAAA,CACA,6BAAA,CAGA,sCAAA,CAGA,4DAAA,CACA,yDAAA,CAGA,oCAAA,CAGA,qCFyHF,CACF,CGhXA,KACE,iBAAA,CACA,iBHkXF,CGhXA,qBAEE,oBAAA,CACA,0DHkXF,CG/WE,wCACE,YAAA,CACA,aHiXJ,CGhXE,8CACE,+CAAA,CACA,qBHkXJ,CG7WA,UAEE,WHgXF,CG9WA,MACE,YAAA,CAEA,eHgXF,CG9WA,eACE,UAAA,CACA,2BAAA,CACA,+CAAA,CACA,8BAAA,CACA,kDAAA,CAIA,UAAA,CAQA,YHuWF,CG5WE,wBACE,kBAAA,CACA,gEH8WJ,CGzWA,MACE,YAAA,CACA,MH4WF,CGzWA,gBACE,qBAAA,CAEA,YAAA,CACA,wBAAA,CAEA,sBAAA,CACA,cH0WF,CGvWA,+BAEE,qBAAA,CACA,UH0WF,CGxWA,YAEE,kBH0WF,CGxWA,4BAEE,uBAAA,CAAA,eAAA,CACA,KAAA,CACA,sBAAA,CACA,YAAA,CAEA,YAAA,CACA,qBH0WF,CGxWA,4BAEE,aAAA,CAEA,aAAA,CACA,sBH0WF,CGvWA,SACE,aAAA,CACA,UDrGc,CCuGd,YAAA,CACA,qBAAA,CACA,6BHyWF,CGvWA,MACE,oBAAA,CACA,WAAA,CACA,UH0WF,CGzWE,UACE,UAAA,CACA,WH2WJ,CGtWA,cACE,2BAAA,CACA,YAAA,CACA,kBAAA,CACA,eHyWF,CGxWE,oBACE,4CH0WJ,CGxWA,sBACE,qBAAA,CACA,aAAA,CACA,cAAA,CACA,kBAAA,CACA,iBH2WF,CGtWA,oCACE,YAAA,CACA,cHyWF,CGvWE,gDACE,uCAAA,CACA,cAAA,CACA,aHyWJ,CGvWA,mCAEE,sBAAA,CACA,kBHyWF,CGvWA,kBACE,aAAA,CACA,YAAA,CACA,iBAAA,CACA,WH0WF,CGxWA,gBACE,iBAAA,CACA,YH2WF,CGzWA,4BACE,SH4WF,CG3WA,wBACE,SH8WF,CG3WA,SACE,cAAA,CACA,KAAA,CACA,OAAA,CACA,QAAA,CAEA,qDAAA,CAEA,SAAA,CACA,gCH4WF,CG3WA,iBACE,UH8WF,CG7WA,aACE,UHgXF,CG7WA,gBACE,UAAA,CACA,gCHgXF,CG/WA,YACE,UAAA,CACA,iCHkXF,CG9WE,uCACE,UAAA,CACA,WAAA,CACA,SHiXJ,CG/WI,4CACE,KAAA,CACA,MHiXN,CG9WE,4BACE,UAAA,CACA,WAAA,CACA,SHiXJ,CG/WI,iCACE,KAAA,CACA,OHiXN,CG3WA,wBACE,KACE,cH8WF,CACF,CG7WA,wBAEE,kBACE,YH8WF,CG7WA,YACE,cAAA,CACA,YAAA,CACA,KAAA,CACA,WAAA,CACA,mDHgXF,CG/WA,UACE,gBAAA,CACA,sCHkXF,CG/WA,gBACE,wBHkXF,CACF,CGjXA,wBAEE,kBACE,YHkXF,CGjXA,gBACE,cAAA,CACA,YAAA,CACA,UDlPY,CCoPZ,KAAA,CACA,UHmXF,CGhXA,iBACE,YHmXF,CGlXA,kBACE,YHqXF,CGlXA,eACE,uBAAA,CAAA,eAAA,CACA,KAAA,CACA,YAAA,CACA,6BAAA,CACA,kBHqXF,CGnXE,yDAEE,YAAA,CACA,2BAAA,CACA,0BHqXJ,CGpXI,qEACE,WAAA,CACA,UHuXN,CGpXA,QACE,sCHuXF,CGpXA,MACE,qBAAA,CACA,sBHuXF,CGtXA,SACE,gBAAA,CACA,iBHyXF,CACF,CGxXA,wBAEE,SACE,UAAA,CACA,eHyXF,CACF,CGxXA,wBACE,SACE,aH0XF,CGxXA,oBACE,UAAA,CACA,UAAA,CACA,aH2XF,CACF,CI3qBA,YACE,gBAAA,CACA,qBAAA,CAEA,6CAAA,CAEA,mBAAA,CACA,qDAAA,CACA,oEAAA,CAEA,qCAAA,CAEA,eAAA,CACA,uBJyqBF,CItqBE,0BACE,YJwqBJ,CIrqBE,wBACE,eJuqBJ,CInqBE,+BACE,iBAAA,CACA,qBAAA,CACA,8BAAA,CAEA,eAAA,CACA,2CAAA,CACA,yDAAA,CAEA,eJmqBJ,CIhqBI,sCACE,UAAA,CACA,iBAAA,CACA,UAAA,CACA,UAAA,CACA,WAAA,CAEA,8CAAA,CAEA,iDAAA,CAAA,yCAAA,CACA,6BAAA,CAAA,qBJgqBN,CI1pBI,oBACE,wDJ4pBN,CI3pBM,sCACE,kEJ6pBR,CI5pBQ,6CACE,uDAAA,CACA,oCAAA,CAAA,4BJ8pBV,CIpqBI,oBACE,wDJsqBN,CIrqBM,sCACE,kEJuqBR,CItqBQ,6CACE,uDAAA,CACA,sCAAA,CAAA,8BJwqBV,CI9qBI,mBACE,uDJgrBN,CI/qBM,qCACE,iEJirBR,CIhrBQ,4CACE,sDAAA,CACA,oCAAA,CAAA,4BJkrBV,CIxrBI,sBACE,0DJ0rBN,CIzrBM,wCACE,oEJ2rBR,CI1rBQ,+CACE,yDAAA,CACA,sCAAA,CAAA,8BJ4rBV,CIlsBI,kBACE,sDJosBN,CInsBM,oCACE,gEJqsBR,CIpsBQ,2CACE,qDAAA,CACA,sCAAA,CAAA,8BJssBV,CI5sBI,iBACE,qDJ8sBN,CI7sBM,mCACE,+DJ+sBR,CI9sBQ,0CACE,oDAAA,CACA,uCAAA,CAAA,+BJgtBV,CIttBI,sBACE,0DJwtBN,CIvtBM,wCACE,oEJytBR,CIxtBQ,+CACE,yDAAA,CACA,oCAAA,CAAA,4BJ0tBV,CIhuBI,iBACE,qDJkuBN,CIjuBM,mCACE,+DJmuBR,CIluBQ,0CACE,oDAAA,CACA,qCAAA,CAAA,6BJouBV,CI1uBI,oBACE,wDJ4uBN,CI3uBM,sCACE,kEJ6uBR,CI5uBQ,6CACE,uDAAA,CACA,mCAAA,CAAA,2BJ8uBV,CIpvBI,gBACE,oDJsvBN,CIrvBM,kCACE,8DJuvBR,CItvBQ,yCACE,mDAAA,CACA,mCAAA,CAAA,2BJwvBV,CI9vBI,4BACE,gEJgwBN,CI/vBM,8CACE,0EJiwBR,CIhwBQ,qDACE,+DAAA,CACA,qCAAA,CAAA,6BJkwBV,CIhwBA,mCACE,wBJmwBF,CK3zBE,oCACE,gBL8zBJ,CK7zBI,wFACE,kBL+zBN,CK9zBI,oFACE,qBLg0BN,CK7zBE,wEACE,oBL+zBJ,CK5zBI,oFACE,wBAAA,CACA,iCL8zBN,CK5zBI,4GACE,mBL8zBN,CK7zBI,gGACE,mBL+zBN,CK7zBQ,wKACE,YL+zBV,CK5zBQ,gMACE,YAAA,CACA,eL8zBV,CK3zBE,oCACE,8BL6zBJ,CK5zBI,gEACE,qDL8zBN,CKpzBE,iHACE,gBAAA,CACA,gBL8zBJ,CK7zBI,iMACE,8BAAA,CACA,oBLs0BN,CKp0BA,UACE,eAAA,CACA,2BLu0BF,CKt0BA,aACE,+BLy0BF,CKx0BA,WACE,4BL20BF,CK10BA,WACE,iBL60BF,CK30BA,iBACE,iBL80BF,CK50BE,yDACE,kBAAA,CACA,qBL+0BJ,CK70BA,8BACE,WAAA,CACA,iCLg1BF,CM35BA,oDAGE,iCAAA,CACA,iBN85BF,CM15BE,mCACE,iCAAA,CACA,wBAAA,CAEA,kBAAA,CACA,eN45BJ,CM15BE,6BACE,YAAA,CACA,eN45BJ,CO76BA,aACE,8CAAA,CACA,kBAAA,CAEA,oCAAA,CACA,iBP+6BF,COv6BE,iEAEE,YAAA,CACA,YP06BJ,COx6BA,IACE,QAAA,CACA,SP26BF,COx6BE,YACE,eP06BJ,COx6BE,iCAEE,+BAAA,CACA,uBAAA,CACA,aPy6BJ,COt6BE,kBACE,eAAA,CACA,kBAAA,CAEA,mBAAA,CACA,6CAAA,CACA,kCPu6BJ,COp6BA,WACE,UAAA,CACA,mBPu6BF,COp6BA,gBACE,UAAA,CACA,aPu6BF,COt6BE,sBACE,aPw6BJ,COt6BE,mBACE,YPw6BJ,COr6BE,2BACE,6CAAA,CACA,kCAAA,CAEA,iCAAA,CACA,4BAAA,CACA,+BPu6BJ,COr6BE,2BACE,+BAAA,CAEA,mBAAA,CACA,yDAAA,CACA,UPs6BJ,COn6BE,wBACE,SAAA,CACA,aAAA,CACA,MAAA,CACA,ePq6BJ,COn6BI,mCACE,wBAAA,CACA,2BPq6BN,CQt/BA,oBACE,oCAAA,CACA,oBRy/BF,CQt/BA,YACE,iCAAA,CACA,uCAAA,CAEA,YAAA,CACA,8CAAA,CAAA,sCRw/BF,CQv/BE,eACE,QRy/BJ,CQx/BI,2BACE,kBR0/BN,CQx/BI,qBACE,WR0/BN,CQv/BM,gCACE,WRy/BR,CQx/BM,+BACE,WR0/BR,CS/gCA,IACE,qBAAA,CACA,cAAA,CACA,WTkhCF,CS/gCE,gBACE,mBAAA,CAEA,aTihCJ,CShhCI,4BACE,eTkhCN,CShhCE,oBACE,UAAA,CACA,UAAA,CACA,kBTkhCJ,CShhCE,qBACE,WAAA,CACA,WAAA,CACA,kBTkhCJ,CShhCE,mFACE,iBAAA,CACA,gBAAA,CACA,iBTmhCJ,CSjhCE,6DAEE,aTmhCJ,CUpjCA,kBACE,mDAAA,CACA,sDAAA,CACA,cVujCF,CUpjCE,qBACE,iBAAA,CACA,mBVujCJ,CUtjCE,qBACE,YAAA,CACA,eVwjCJ,CWnkCA,MAEE,mBAAA,CAGA,eAAA,CACA,kBXokCF,CWjkCI,wCACE,iBAAA,CACA,oBXokCN,CWlkCI,sCACE,iBXqkCN,CWnkCI,oCAEE,gBAAA,CACA,mBXukCN,CWjkCI,0EAEE,YAAA,CACA,eXskCN,CW7jCE,6FACE,eAAA,CACA,iBXqkCJ,CWpkCI,+GACE,YX2kCN,CWzkCI,+MACE,WAAA,CACA,iBAAA,CACA,kBXglCN,CW7kCI,gSAEE,kBXylCN,CWvlCI,+GACE,qBX8lCN,CYppCA,cACE,UAAA,CACA,eZupCF,CaxpCA,YACE,Wb2pCF,CaxpCA,mBACE,cAAA,CACA,eAAA,CACA,mBAAA,CACA,+CAAA,CACA,qCAAA,CACA,0BAAA,CAEA,oCAAA,CACA,oBAAA,CAEA,0FAAA,CAEA,kDbwpCF,CarpCA,WACE,oDAAA,CACA,iBAAA,CACA,iBAAA,CACA,kBAAA,CACA,kBbwpCF,CarpCA,eACE,qBbwpCF,Cc1qCE,4LACE,eAAA,CACA,iBAAA,CACA,iBAAA,CACA,oBdsrCJ,Cc3qCE,0cACE,kBd+rCJ,Ce3tCA,SACE,wBAAA,CACA,iCf8tCF,CgBhuCA,iBACE,WAAA,CACA,WAAA,CACA,SAAA,CAEA,gBAAA,CACA,cAAA,CAEA,mBAAA,CACA,kDAAA,CACA,+ChBiuCF,CgB/tCE,mBACE,iBAAA,CACA,kBhBiuCJ,CgB/tCE,gCACE,QAAA,CACA,kBAAA,CACA,sDAAA,CAEA,ehBguCJ,CiBrvCA,eACE,UAAA,CACA,eAAA,CACA,eAAA,CACA,mBAAA,CACA,0BjBwvCF,CiBtvCA,eACE,mBAAA,CACA,gBAAA,CACA,wBAAA,CAEA,oEjBwvCF,CiBtvCE,kBACE,4CjBwvCJ,CiBtvCE,oCAGE,gBAAA,CAKA,oDAAA,CACA,qDAAA,CACA,sDjBmvCJ,CiBzvCI,wCACE,ajB4vCN,CiBrvCI,4DACE,gBjBwvCN,CiBvvCI,0DACE,iBjB0vCN,CkB1xCA,UACE,iDAAA,CACA,6CAAA,CACA,gCAAA,CAEA,cAAA,CACA,kBAAA,CACA,clB4xCF,CmBhyCA,OACE,iCAAA,CACA,YAAA,CACA,qBAAA,CAEA,enBkyCF,CmB/xCA,qBACE,eAAA,CAGA,0BAAA,CAEA,mDAAA,CAEA,eAAA,CACA,uCnB+xCF,CmB3xCE,iBACE,YAAA,CACA,kBAAA,CAEA,oBnB6xCJ,CmB5xCI,yCACE,yBAAA,CACA,uBAAA,CACA,yDAAA,CAAA,iDnB8xCN,CmB5xCI,8CAEE,aAAA,CAEA,oCAAA,CAEA,YAAA,CACA,aAAA,CACA,cnB4xCN,CmB1xCI,2BACE,aAAA,CAEA,WAAA,CACA,WAAA,CACA,gBnB2xCN,CmBzxCI,2BACE,aAAA,CAEA,UAAA,CACA,UnB0xCN,CmBxxCM,+BACE,wBnB0xCR,CmBxxCA,WACE,YAAA,CACA,qBnB2xCF,CmBzxCE,sBACE,oBnB2xCJ,CmBzxCE,oBACE,YAAA,CACA,kBAAA,CAEA,oBAAA,CAEA,mCAAA,CACA,iCAAA,CACA,oBnByxCJ,CoBj2CA,UACE,cAAA,CACA,epBo2CF,CoBl2CE,aACE,cAAA,CACA,sDpBo2CJ,CoB/1CA,aACE,oDAAA,CACA,mCpBk2CF,CqB52CA,eACE,YAAA,CACA,qBAAA,CACA,aAAA,CAEA,mFAAA,CACA,oBrB82CF,CqB52CA,oBACE,wBAAA,CAEA,gBrB+2CF,CqB72CA,4CAHE,6CrBo3CF,CqB92CA,cACE,aAAA,CACA,aAAA,CACA,crBi3CF,CqB52CA,0BACE,YAAA,CACA,kBAAA,CACA,4CAAA,CAEA,iBrB82CF,CqB72CE,iCACE,UAAA,CACA,iBAAA,CACA,2CAAA,CACA,qCAAA,CACA,sCrB+2CJ,CqB72CA,gBACE,qBAAA,CAKA,gRAAA,CAEA,UAAA,CAEA,4CAAA,CACA,sBAAA,CACA,UrB62CF,CqB32CE,sBACE,YrB62CJ,CqB32CE,kCACE,+CrB62CJ,CqB92CE,sCACE,+CrB62CJ,CqB92CE,6BACE,+CrB62CJ,CqBx2CA,cACE,uCAAA,CACA,0CAAA,CACA,kDrB22CF,CqBz2CE,iBACE,SAAA,CACA,YAAA,CACA,eAAA,CAEA,YAAA,CACA,qBAAA,CAEA,erBy2CJ,CqBv2CE,iBACE,iBAAA,CACA,QrBy2CJ,CqBv2CI,oBACE,kDrBy2CN,CqBv2CE,yBACE,qBAAA,CAEA,oBAAA,CACA,2CAAA,CAEA,WAAA,CACA,UAAA,CAEA,mFrBs2CJ,CqBn2CI,wCACE,oXAAA,CACA,eAAA,CACA,qBrBq2CN,CqBl2CE,uCACE,erBo2CJ,CqBl2CE,oBACE,iBAAA,CACA,KAAA,CACA,OAAA,CACA,iCAAA,CACA,mCAAA,CAEA,cAAA,CAEA,YAAA,CACA,sBAAA,CACA,kBrBk2CJ,CqBh2CE,uBACE,0CAAA,CAEA,eAAA,CACA,wBAAA,CAEA,+CAAA,CAEA,mFrB+1CJ,CqB11CI,yCACE,2CrB41CN,CqB11CA,kBACE,iBAAA,CACA,YrB61CF,CqBv1CE,qBACE,YrB01CJ,CqBx1CE,kCACE,uBrB01CJ,CqBv1CE,6BACE,arB01CJ,CqBx1CE,0CACE,wBrB01CJ,CsBr/CA,qBACE,gCAAA,CACA,uCtBw/CF,CsBt/CA,WACE,oCAAA,CACA,0CAAA,CACA,wBtBy/CF,CsBt/CA,QACE,YtBy/CF,CsBv/CA,oBACE,0CtB0/CF,CsBx/CA,UACE,8BAAA,CACA,eAAA,CAEA,qFtB0/CF,CsBv/CE,4BACE,atBy/CJ,CsBx/CI,+BACE,ctB0/CN,CsBz/CI,8BACE,YtB2/CN,CsBz/CE,aACE,oBAAA,CACA,YAAA,CACA,eAAA,CACA,+CtB2/CJ,CsB1/CE,aACE,4CtB4/CJ,CsB1/CI,wBACE,qBAAA,CACA,oBtB4/CN,CsB1/CI,uCACE,etB4/CN,CsB1/CA,YACE,gBAAA,CACA,iBtB6/CF,CsB1/CA,4EACE,8BAAA,CACA,4BtB6/CF,CsB5/CE,mFACE,6OtB8/CJ","file":"furo.css","sourcesContent":["/*! normalize.css v8.0.1 | MIT License | github.com/necolas/normalize.css */\n\n/* Document\n   ========================================================================== */\n\n/**\n * 1. Correct the line height in all browsers.\n * 2. Prevent adjustments of font size after orientation changes in iOS.\n */\n\nhtml {\n  line-height: 1.15; /* 1 */\n  -webkit-text-size-adjust: 100%; /* 2 */\n}\n\n/* Sections\n   ========================================================================== */\n\n/**\n * Remove the margin in all browsers.\n */\n\nbody {\n  margin: 0;\n}\n\n/**\n * Render the `main` element consistently in IE.\n */\n\nmain {\n  display: block;\n}\n\n/**\n * Correct the font size and margin on `h1` elements within `section` and\n * `article` contexts in Chrome, Firefox, and Safari.\n */\n\nh1 {\n  font-size: 2em;\n  margin: 0.67em 0;\n}\n\n/* Grouping content\n   ========================================================================== */\n\n/**\n * 1. Add the correct box sizing in Firefox.\n * 2. Show the overflow in Edge and IE.\n */\n\nhr {\n  box-sizing: content-box; /* 1 */\n  height: 0; /* 1 */\n  overflow: visible; /* 2 */\n}\n\n/**\n * 1. Correct the inheritance and scaling of font size in all browsers.\n * 2. Correct the odd `em` font sizing in all browsers.\n */\n\npre {\n  font-family: monospace, monospace; /* 1 */\n  font-size: 1em; /* 2 */\n}\n\n/* Text-level semantics\n   ========================================================================== */\n\n/**\n * Remove the gray background on active links in IE 10.\n */\n\na {\n  background-color: transparent;\n}\n\n/**\n * 1. Remove the bottom border in Chrome 57-\n * 2. Add the correct text decoration in Chrome, Edge, IE, Opera, and Safari.\n */\n\nabbr[title] {\n  border-bottom: none; /* 1 */\n  text-decoration: underline; /* 2 */\n  text-decoration: underline dotted; /* 2 */\n}\n\n/**\n * Add the correct font weight in Chrome, Edge, and Safari.\n */\n\nb,\nstrong {\n  font-weight: bolder;\n}\n\n/**\n * 1. Correct the inheritance and scaling of font size in all browsers.\n * 2. Correct the odd `em` font sizing in all browsers.\n */\n\ncode,\nkbd,\nsamp {\n  font-family: monospace, monospace; /* 1 */\n  font-size: 1em; /* 2 */\n}\n\n/**\n * Add the correct font size in all browsers.\n */\n\nsmall {\n  font-size: 80%;\n}\n\n/**\n * Prevent `sub` and `sup` elements from affecting the line height in\n * all browsers.\n */\n\nsub,\nsup {\n  font-size: 75%;\n  line-height: 0;\n  position: relative;\n  vertical-align: baseline;\n}\n\nsub {\n  bottom: -0.25em;\n}\n\nsup {\n  top: -0.5em;\n}\n\n/* Embedded content\n   ========================================================================== */\n\n/**\n * Remove the border on images inside links in IE 10.\n */\n\nimg {\n  border-style: none;\n}\n\n/* Forms\n   ========================================================================== */\n\n/**\n * 1. Change the font styles in all browsers.\n * 2. Remove the margin in Firefox and Safari.\n */\n\nbutton,\ninput,\noptgroup,\nselect,\ntextarea {\n  font-family: inherit; /* 1 */\n  font-size: 100%; /* 1 */\n  line-height: 1.15; /* 1 */\n  margin: 0; /* 2 */\n}\n\n/**\n * Show the overflow in IE.\n * 1. Show the overflow in Edge.\n */\n\nbutton,\ninput { /* 1 */\n  overflow: visible;\n}\n\n/**\n * Remove the inheritance of text transform in Edge, Firefox, and IE.\n * 1. Remove the inheritance of text transform in Firefox.\n */\n\nbutton,\nselect { /* 1 */\n  text-transform: none;\n}\n\n/**\n * Correct the inability to style clickable types in iOS and Safari.\n */\n\nbutton,\n[type=\"button\"],\n[type=\"reset\"],\n[type=\"submit\"] {\n  -webkit-appearance: button;\n}\n\n/**\n * Remove the inner border and padding in Firefox.\n */\n\nbutton::-moz-focus-inner,\n[type=\"button\"]::-moz-focus-inner,\n[type=\"reset\"]::-moz-focus-inner,\n[type=\"submit\"]::-moz-focus-inner {\n  border-style: none;\n  padding: 0;\n}\n\n/**\n * Restore the focus styles unset by the previous rule.\n */\n\nbutton:-moz-focusring,\n[type=\"button\"]:-moz-focusring,\n[type=\"reset\"]:-moz-focusring,\n[type=\"submit\"]:-moz-focusring {\n  outline: 1px dotted ButtonText;\n}\n\n/**\n * Correct the padding in Firefox.\n */\n\nfieldset {\n  padding: 0.35em 0.75em 0.625em;\n}\n\n/**\n * 1. Correct the text wrapping in Edge and IE.\n * 2. Correct the color inheritance from `fieldset` elements in IE.\n * 3. Remove the padding so developers are not caught out when they zero out\n *    `fieldset` elements in all browsers.\n */\n\nlegend {\n  box-sizing: border-box; /* 1 */\n  color: inherit; /* 2 */\n  display: table; /* 1 */\n  max-width: 100%; /* 1 */\n  padding: 0; /* 3 */\n  white-space: normal; /* 1 */\n}\n\n/**\n * Add the correct vertical alignment in Chrome, Firefox, and Opera.\n */\n\nprogress {\n  vertical-align: baseline;\n}\n\n/**\n * Remove the default vertical scrollbar in IE 10+.\n */\n\ntextarea {\n  overflow: auto;\n}\n\n/**\n * 1. Add the correct box sizing in IE 10.\n * 2. Remove the padding in IE 10.\n */\n\n[type=\"checkbox\"],\n[type=\"radio\"] {\n  box-sizing: border-box; /* 1 */\n  padding: 0; /* 2 */\n}\n\n/**\n * Correct the cursor style of increment and decrement buttons in Chrome.\n */\n\n[type=\"number\"]::-webkit-inner-spin-button,\n[type=\"number\"]::-webkit-outer-spin-button {\n  height: auto;\n}\n\n/**\n * 1. Correct the odd appearance in Chrome and Safari.\n * 2. Correct the outline style in Safari.\n */\n\n[type=\"search\"] {\n  -webkit-appearance: textfield; /* 1 */\n  outline-offset: -2px; /* 2 */\n}\n\n/**\n * Remove the inner padding in Chrome and Safari on macOS.\n */\n\n[type=\"search\"]::-webkit-search-decoration {\n  -webkit-appearance: none;\n}\n\n/**\n * 1. Correct the inability to style clickable types in iOS and Safari.\n * 2. Change font properties to `inherit` in Safari.\n */\n\n::-webkit-file-upload-button {\n  -webkit-appearance: button; /* 1 */\n  font: inherit; /* 2 */\n}\n\n/* Interactive\n   ========================================================================== */\n\n/*\n * Add the correct display in Edge, IE 10+, and Firefox.\n */\n\ndetails {\n  display: block;\n}\n\n/*\n * Add the correct display in all browsers.\n */\n\nsummary {\n  display: list-item;\n}\n\n/* Misc\n   ========================================================================== */\n\n/**\n * Add the correct display in IE 10+.\n */\n\ntemplate {\n  display: none;\n}\n\n/**\n * Add the correct display in IE 10.\n */\n\n[hidden] {\n  display: none;\n}\n","// TODO: break this out into relevant files.\n\n// This is where the theming and coloring of all the elements is done. This file\n// needs to be broken out to let all the styles for each of the components live\n// with the rest of the component's styling.\n\nbody\n  color: var(--color-foreground-primary)\n  background: var(--color-background-primary)\n\n  ////////////////////////////////////////////////////////////////////////////////\n// Header\n////////////////////////////////////////////////////////////////////////////////\n.mobile-header\n  .header-center\n    a\n      color: var(--color-header-text)\n      text-decoration: none\n\n////////////////////////////////////////////////////////////////////////////////\n// Announcements\n////////////////////////////////////////////////////////////////////////////////\n.announcement\n  background-color: var(--color-announcement-background)\n  color: var(--color-announcement-text)\n\n  ////////////////////////////////////////////////////////////////////////////////\n// Sidebar\n////////////////////////////////////////////////////////////////////////////////\n.sidebar-drawer\n  border-right: 1px solid var(--color-sidebar-background-border)\n  background: var(--color-sidebar-background)\n\n.sidebar-brand\n  color: var(--color-sidebar-brand-text)\n\n.sidebar-search-container\n  background: var(--color-sidebar-search-background)\n  &:hover,\n  &:focus-within\n    background: var(--color-sidebar-search-background--focus)\n\n  &::before\n    background-color: var(--color-sidebar-search-icon)\n    mask-image: var(--icon-search)\n\n.sidebar-search\n  border: none\n  border-top: 1px solid var(--color-sidebar-search-border)\n  border-bottom: 1px solid var(--color-sidebar-search-border)\n\n.sidebar-tree\n  .icon\n    color: var(--color-sidebar-link-text)\n  .reference\n    text-decoration: none // No need for underlines here.\n    color: var(--color-sidebar-link-text)\n    &:hover\n      background: var(--color-sidebar-item-background--hover)\n\n    &.external::after\n      // make sure the icon looks like other boring links\n      color: var(--color-sidebar-link-text)\n  .caption\n    color: var(--color-sidebar-caption-text)\n\n  // Colorize the top-level list items and icon.\n  .toctree-l1\n    & > .reference,\n    & > label .icon\n      color: var(--color-sidebar-link-text--top-level)\n\n  // Color changes on hover\n  label\n    background: var(--color-sidebar-item-expander-background)\n    &:hover\n      background: var(--color-sidebar-item-expander-background--hover)\n\n  .current > .reference\n    background: var(--color-sidebar-item-background--current)\n    &:hover\n      background: var(--color-sidebar-item-background--hover)\n\n\n////////////////////////////////////////////////////////////////////////////////\n// Table of contents\n////////////////////////////////////////////////////////////////////////////////\n.toc-drawer\n  background: var(--color-toc-background)\n\n.toc-title\n  color: var(--color-toc-title-text)\n\n.toc-tree\n  border-left: 1px solid var(--color-background-border)\n\n  .reference\n    text-decoration: none // No need for underlines here.\n    color: var(--color-toc-item-text)\n\n  .scroll-current > .reference\n    color: var(--color-toc-item-text--active)\n\n////////////////////////////////////////////////////////////////////////////////\n// Contents\n////////////////////////////////////////////////////////////////////////////////\narticle\n  color: var(--color-content-foreground)\n  background: var(--color-content-background)\n\na\n  text-decoration: underline\n\n  color: var(--color-link)\n  text-decoration-color: var(--color-link-underline)\n\n  &:hover\n    color: var(--color-link--hover)\n    text-decoration-color: var(--color-link-underline--hover)\n  &.muted-link\n    text-decoration: none\n    &:hover\n      text-decoration: underline\n      color: var(--color-link)\n      text-decoration-color: var(--color-link-underline)\n\n.problematic\n  color: var(--color-problematic)\n\n// For items that need to be hidden based on the active theme.\n.only-light\n  display: block !important\n.only-dark\n  display: none !important\n\n@media (prefers-color-scheme: dark)\n  .only-light\n    display: none !important\n  .only-dark\n    display: block !important\n","@import \"normalize.css\";\nbody {\n  color: var(--color-foreground-primary);\n  background: var(--color-background-primary);\n}\n\n.mobile-header .header-center a {\n  color: var(--color-header-text);\n  text-decoration: none;\n}\n\n.announcement {\n  background-color: var(--color-announcement-background);\n  color: var(--color-announcement-text);\n}\n\n.sidebar-drawer {\n  border-right: 1px solid var(--color-sidebar-background-border);\n  background: var(--color-sidebar-background);\n}\n\n.sidebar-brand {\n  color: var(--color-sidebar-brand-text);\n}\n\n.sidebar-search-container {\n  background: var(--color-sidebar-search-background);\n}\n.sidebar-search-container:hover, .sidebar-search-container:focus-within {\n  background: var(--color-sidebar-search-background--focus);\n}\n.sidebar-search-container::before {\n  background-color: var(--color-sidebar-search-icon);\n  mask-image: var(--icon-search);\n}\n\n.sidebar-search {\n  border: none;\n  border-top: 1px solid var(--color-sidebar-search-border);\n  border-bottom: 1px solid var(--color-sidebar-search-border);\n}\n\n.sidebar-tree .icon {\n  color: var(--color-sidebar-link-text);\n}\n.sidebar-tree .reference {\n  text-decoration: none;\n  color: var(--color-sidebar-link-text);\n}\n.sidebar-tree .reference:hover {\n  background: var(--color-sidebar-item-background--hover);\n}\n.sidebar-tree .reference.external::after {\n  color: var(--color-sidebar-link-text);\n}\n.sidebar-tree .caption {\n  color: var(--color-sidebar-caption-text);\n}\n.sidebar-tree .toctree-l1 > .reference, .sidebar-tree .toctree-l1 > label .icon {\n  color: var(--color-sidebar-link-text--top-level);\n}\n.sidebar-tree label {\n  background: var(--color-sidebar-item-expander-background);\n}\n.sidebar-tree label:hover {\n  background: var(--color-sidebar-item-expander-background--hover);\n}\n.sidebar-tree .current > .reference {\n  background: var(--color-sidebar-item-background--current);\n}\n.sidebar-tree .current > .reference:hover {\n  background: var(--color-sidebar-item-background--hover);\n}\n\n.toc-drawer {\n  background: var(--color-toc-background);\n}\n\n.toc-title {\n  color: var(--color-toc-title-text);\n}\n\n.toc-tree {\n  border-left: 1px solid var(--color-background-border);\n}\n.toc-tree .reference {\n  text-decoration: none;\n  color: var(--color-toc-item-text);\n}\n.toc-tree .scroll-current > .reference {\n  color: var(--color-toc-item-text--active);\n}\n\narticle {\n  color: var(--color-content-foreground);\n  background: var(--color-content-background);\n}\n\na {\n  text-decoration: underline;\n  color: var(--color-link);\n  text-decoration-color: var(--color-link-underline);\n}\na:hover {\n  color: var(--color-link--hover);\n  text-decoration-color: var(--color-link-underline--hover);\n}\na.muted-link {\n  text-decoration: none;\n}\na.muted-link:hover {\n  text-decoration: underline;\n  color: var(--color-link);\n  text-decoration-color: var(--color-link-underline);\n}\n\n.problematic {\n  color: var(--color-problematic);\n}\n\n.only-light {\n  display: block !important;\n}\n\n.only-dark {\n  display: none !important;\n}\n\n@media (prefers-color-scheme: dark) {\n  .only-light {\n    display: none !important;\n  }\n\n  .only-dark {\n    display: block !important;\n  }\n}\nhtml {\n  font-family: var(--font-stack);\n}\n\npre,\ncode,\nkbd,\nsamp {\n  font-family: var(--font-stack--monospace);\n}\n\nbody {\n  -webkit-font-smoothing: antialiased;\n  -moz-osx-font-smoothing: grayscale;\n}\n\narticle {\n  line-height: 1.5;\n}\n\nh1 {\n  font-size: 2.25rem;\n}\n\nh2 {\n  font-size: 1.75rem;\n}\n\nh3 {\n  font-size: 1.25rem;\n}\n\nh4 {\n  font-size: 1rem;\n}\n\nh5 {\n  font-size: 0.875rem;\n}\n\nh6 {\n  font-size: 0.75rem;\n}\n\nh1,\nh2 {\n  margin-top: 1.5rem;\n  margin-bottom: 1rem;\n  font-weight: 300;\n}\n\nh3 {\n  margin-top: 1.5rem;\n  margin-bottom: 0.75rem;\n  font-weight: 400;\n}\n\nh4,\nh5,\nh6 {\n  text-transform: uppercase;\n  margin-top: 1rem;\n  margin-bottom: 0.5rem;\n  font-weight: 700;\n}\n\np {\n  margin-top: 0.75rem;\n  margin-bottom: 0.75rem;\n}\n\nhr.docutils {\n  height: 1px;\n  padding: 0;\n  margin: 2rem 0;\n  background-color: var(--color-background-border);\n  border: 0;\n}\n\n.centered {\n  text-align: center;\n}\n\n:root {\n  --font-stack: -apple-system, BlinkMacSystemFont, Segoe UI, Helvetica, Arial,\n    sans-serif, Apple Color Emoji, Segoe UI Emoji;\n  --font-stack--monospace: \"SFMono-Regular\", Menlo, Consolas, Monaco,\n    Liberation Mono, Lucida Console, monospace;\n  --font-size--normal: 100%;\n  --font-size--small: 87.5%;\n  --font-size--small--2: 81.25%;\n  --font-size--small--3: 75%;\n  --font-size--small--4: 62.5%;\n  --sidebar-caption-font-size: var(--font-size--small--2);\n  --sidebar-item-font-size: var(--font-size--small);\n  --sidebar-search-input-font-size: var(--font-size--small);\n  --toc-font-size: var(--font-size--small--3);\n  --toc-font-size--mobile: var(--font-size--normal);\n  --toc-title-font-size: var(--font-size--small--4);\n  --admonition-font-size: 0.8125rem;\n  --admonition-title-font-size: 0.8125rem;\n  --code-font-size: var(--font-size--small--2);\n  --header-height: calc(\n    var(--sidebar-item-line-height) + 4 * var(--sidebar-item-spacing-vertical)\n  );\n  --sidebar-tree-space-above: 1.5rem;\n  --sidebar-caption-space-above: 1rem;\n  --sidebar-item-line-height: 1rem;\n  --sidebar-item-spacing-vertical: 0.5rem;\n  --sidebar-item-spacing-horizontal: 1rem;\n  --sidebar-item-height: calc(\n    var(--sidebar-item-line-height) + 2 *var(--sidebar-item-spacing-vertical)\n  );\n  --sidebar-expander-width: var(--sidebar-item-height);\n  --sidebar-search-space-above: 0.5rem;\n  --sidebar-search-input-spacing-vertical: 0.5rem;\n  --sidebar-search-input-spacing-horizontal: 0.5rem;\n  --sidebar-search-input-height: 1rem;\n  --sidebar-search-icon-size: var(--sidebar-search-input-height);\n  --toc-title-padding: 0.25rem 0;\n  --toc-spacing-vertical: 1.5rem;\n  --toc-spacing-horizontal: 1.5rem;\n  --toc-item-spacing-vertical: 0.4rem;\n  --toc-item-spacing-horizontal: 1rem;\n  --icon-search: url('data:image/svg+xml;charset=utf-8,<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 24 24\" stroke-width=\"1.5\" stroke=\"currentColor\" fill=\"none\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><path stroke=\"none\" d=\"M0 0h24v24H0z\"/><circle cx=\"10\" cy=\"10\" r=\"7\" /><line x1=\"21\" y1=\"21\" x2=\"15\" y2=\"15\" /></svg>');\n  --icon-pencil: url('data:image/svg+xml;charset=utf-8,<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 24 24\"><path d=\"M20.71 7.04c.39-.39.39-1.04 0-1.41l-2.34-2.34c-.37-.39-1.02-.39-1.41 0l-1.84 1.83 3.75 3.75M3 17.25V21h3.75L17.81 9.93l-3.75-3.75L3 17.25z\"/></svg>');\n  --icon-abstract: url('data:image/svg+xml;charset=utf-8,<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 24 24\"><path d=\"M4 5h16v2H4V5m0 4h16v2H4V9m0 4h16v2H4v-2m0 4h10v2H4v-2z\"/></svg>');\n  --icon-info: url('data:image/svg+xml;charset=utf-8,<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 24 24\"><path d=\"M13 9h-2V7h2m0 10h-2v-6h2m-1-9A10 10 0 002 12a10 10 0 0010 10 10 10 0 0010-10A10 10 0 0012 2z\"/></svg>');\n  --icon-flame: url('data:image/svg+xml;charset=utf-8,<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 24 24\"><path d=\"M17.55 11.2c-.23-.3-.5-.56-.76-.82-.65-.6-1.4-1.03-2.03-1.66C13.3 7.26 13 4.85 13.91 3c-.91.23-1.75.75-2.45 1.32-2.54 2.08-3.54 5.75-2.34 8.9.04.1.08.2.08.33 0 .22-.15.42-.35.5-.22.1-.46.04-.64-.12a.83.83 0 01-.15-.17c-1.1-1.43-1.28-3.48-.53-5.12C5.89 10 5 12.3 5.14 14.47c.04.5.1 1 .27 1.5.14.6.4 1.2.72 1.73 1.04 1.73 2.87 2.97 4.84 3.22 2.1.27 4.35-.12 5.96-1.6 1.8-1.66 2.45-4.32 1.5-6.6l-.13-.26c-.2-.46-.47-.87-.8-1.25l.05-.01m-3.1 6.3c-.28.24-.73.5-1.08.6-1.1.4-2.2-.16-2.87-.82 1.19-.28 1.89-1.16 2.09-2.05.17-.8-.14-1.46-.27-2.23-.12-.74-.1-1.37.18-2.06.17.38.37.76.6 1.06.76 1 1.95 1.44 2.2 2.8.04.14.06.28.06.43.03.82-.32 1.72-.92 2.27h.01z\"/></svg>');\n  --icon-question: url('data:image/svg+xml;charset=utf-8,<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 24 24\"><path d=\"M15.07 11.25l-.9.92C13.45 12.89 13 13.5 13 15h-2v-.5c0-1.11.45-2.11 1.17-2.83l1.24-1.26c.37-.36.59-.86.59-1.41a2 2 0 00-2-2 2 2 0 00-2 2H8a4 4 0 014-4 4 4 0 014 4 3.2 3.2 0 01-.93 2.25M13 19h-2v-2h2M12 2A10 10 0 002 12a10 10 0 0010 10 10 10 0 0010-10c0-5.53-4.5-10-10-10z\"/></svg>');\n  --icon-warning: url('data:image/svg+xml;charset=utf-8,<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 24 24\"><path d=\"M13 14h-2v-4h2m0 8h-2v-2h2M1 21h22L12 2 1 21z\"/></svg>');\n  --icon-failure: url('data:image/svg+xml;charset=utf-8,<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 24 24\"><path d=\"M12 2c5.53 0 10 4.47 10 10s-4.47 10-10 10S2 17.53 2 12 6.47 2 12 2m3.59 5L12 10.59 8.41 7 7 8.41 10.59 12 7 15.59 8.41 17 12 13.41 15.59 17 17 15.59 13.41 12 17 8.41 15.59 7z\"/></svg>');\n  --icon-spark: url('data:image/svg+xml;charset=utf-8,<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 24 24\"><path d=\"M11.5 20l4.86-9.73H13V4l-5 9.73h3.5V20M12 2c2.75 0 5.1 1 7.05 2.95C21 6.9 22 9.25 22 12s-1 5.1-2.95 7.05C17.1 21 14.75 22 12 22s-5.1-1-7.05-2.95C3 17.1 2 14.75 2 12s1-5.1 2.95-7.05C6.9 3 9.25 2 12 2z\"/></svg>');\n  --icon-admonition-default: var(--icon-abstract);\n  --color-problematic: #b30000;\n  --color-foreground-primary: black;\n  --color-foreground-secondary: #5a5c63;\n  --color-foreground-muted: #72747e;\n  --color-foreground-border: #878787;\n  --color-background-primary: white;\n  --color-background-secondary: #f8f9fb;\n  --color-background-hover: #efeff4ff;\n  --color-background-hover--transparent: #efeff400;\n  --color-background-border: #eeebee;\n  --color-announcement-background: #000000dd;\n  --color-announcement-text: #eeebee;\n  --color-brand-primary: #2962ff;\n  --color-brand-content: #2a5adf;\n  --color-api-overall: var(--color-foreground-muted);\n  --color-api-name: var(--color-brand-content);\n  --color-api-pre-name: var(--color-brand-content);\n  --color-api-paren: var(--color-foreground-secondary);\n  --color-api-keyword: var(--color-problematic);\n  --color-api-highlight-on-target: #ffffcc;\n  --color-inline-code-background: var(--color-background-secondary);\n  --color-highlighted-background: #ddeeff;\n  --color-highlighted-text: var(--color-foreground-primary);\n  --color-guilabel-background: #ddeeff80;\n  --color-guilabel-border: #bedaf580;\n  --color-guilabel-text: var(--color-foreground-primary);\n  --color-admonition-background: transparent;\n  --color-admonition-title: #651fff;\n  --color-admonition-title-background: rgba(101, 31, 255, 0.1);\n  --color-admonition-title--caution: #ff9100;\n  --color-admonition-title-background--caution: rgba(255, 145, 0, 0.1);\n  --color-admonition-title--warning: #ff9100;\n  --color-admonition-title-background--warning: rgba(255, 145, 0, 0.1);\n  --color-admonition-title--danger: #ff5252;\n  --color-admonition-title-background--danger: rgba(255, 82, 82, 0.1);\n  --color-admonition-title--attention: #ff5252;\n  --color-admonition-title-background--attention: rgba(255, 82, 82, 0.1);\n  --color-admonition-title--error: #ff5252;\n  --color-admonition-title-background--error: rgba(255, 82, 82, 0.1);\n  --color-admonition-title--hint: #00c852;\n  --color-admonition-title-background--hint: rgba(0, 200, 82, 0.1);\n  --color-admonition-title--important: #00bfa5;\n  --color-admonition-title-background--important: rgba(0, 191, 165, 0.1);\n  --color-admonition-title--note: #00b0ff;\n  --color-admonition-title-background--note: rgba(0, 176, 255, 0.1);\n  --color-admonition-title--seealso: #448aff;\n  --color-admonition-title-background--seealso: rgba(68, 138, 255, 0.1);\n  --color-admonition-title--tip: #00c852;\n  --color-admonition-title-background--tip: rgba(0, 200, 82, 0.1);\n  --color-admonition-title--admonition-todo: #808080;\n  --color-admonition-title-background--admonition-todo: rgba(128, 128, 128, 0.1);\n  --color-header-background: var(--color-background-primary);\n  --color-header-border: var(--color-background-border);\n  --color-header-text: var(--color-foreground-primary);\n  --color-sidebar-background: var(--color-background-secondary);\n  --color-sidebar-background-border: var(--color-background-border);\n  --color-sidebar-brand-text: var(--color-foreground-primary);\n  --color-sidebar-caption-text: var(--color-foreground-muted);\n  --color-sidebar-link-text: var(--color-foreground-secondary);\n  --color-sidebar-link-text--top-level: var(--color-brand-primary);\n  --color-sidebar-item-background: var(--color-sidebar-background);\n  --color-sidebar-item-background--current: var(\n    --color-sidebar-item-background\n  );\n  --color-sidebar-item-background--hover: linear-gradient(\n    90deg,\n    var(--color-background-hover--transparent) 0%,\n    var(--color-background-hover) var(--sidebar-item-spacing-horizontal),\n    var(--color-background-hover) 100%\n  );\n  --color-sidebar-item-expander-background: transparent;\n  --color-sidebar-item-expander-background--hover: var(\n    --color-background-hover\n  );\n  --color-sidebar-search-text: var(--color-foreground-primary);\n  --color-sidebar-search-background: var(--color-background-secondary);\n  --color-sidebar-search-background--focus: var(--color-background-primary);\n  --color-sidebar-search-border: var(--color-background-border);\n  --color-sidebar-search-icon: var(--color-foreground-muted);\n  --color-toc-background: var(--color-background-primary);\n  --color-toc-title-text: var(--color-foreground-muted);\n  --color-toc-item-text: var(--color-foreground-secondary);\n  --color-toc-item-text--hover: var(--color-foreground-primary);\n  --color-toc-item-text--active: var(--color-brand-primary);\n  --color-content-foreground: var(--color-foreground-primary);\n  --color-content-background: transparent;\n  --color-link: var(--color-brand-content);\n  --color-link--hover: var(--color-brand-content);\n  --color-link-underline: var(--color-background-border);\n  --color-link-underline--hover: var(--color-foreground-border);\n}\n\n@media (prefers-color-scheme: dark) {\n  :root {\n    --color-problematic: #e25050;\n    --color-foreground-primary: #ffffffd9;\n    --color-foreground-secondary: #9ca0a5;\n    --color-foreground-muted: #81868d;\n    --color-foreground-border: #666666;\n    --color-background-primary: #131416;\n    --color-background-secondary: #1a1c1e;\n    --color-background-hover: #1e2124ff;\n    --color-background-hover--transparent: #1e212400;\n    --color-background-border: #303335;\n    --color-announcement-background: #000000dd;\n    --color-announcement-text: #eeebee;\n    --color-brand-primary: #2b8cee;\n    --color-brand-content: #368ce2;\n    --color-highlighted-background: #083563;\n    --color-guilabel-background: #08356380;\n    --color-guilabel-border: #13395f80;\n    --color-api-highlight-on-target: #333300;\n    --color-admonition-background: #18181a;\n  }\n}\nhtml {\n  overflow-x: hidden;\n  overflow-y: scroll;\n}\n\n:not(html):not(body) {\n  scrollbar-width: thin;\n  scrollbar-color: var(--color-foreground-border) transparent;\n}\n:not(html):not(body)::-webkit-scrollbar {\n  width: 0.25rem;\n  height: 0.25rem;\n}\n:not(html):not(body)::-webkit-scrollbar-thumb {\n  background-color: var(--color-foreground-border);\n  border-radius: 0.125rem;\n}\n\nhtml,\nbody {\n  height: 100%;\n}\n\n.page {\n  display: flex;\n  min-height: 100%;\n}\n\n.mobile-header {\n  width: 100%;\n  height: var(--header-height);\n  background-color: var(--color-header-background);\n  color: var(--color-header-text);\n  border-bottom: 1px solid var(--color-header-border);\n  z-index: 10;\n  display: none;\n}\n.mobile-header.scrolled {\n  border-bottom: none;\n  box-shadow: 0 0 0.2rem rgba(0, 0, 0, 0.1), 0 0.2rem 0.4rem rgba(0, 0, 0, 0.2);\n}\n\n.main {\n  display: flex;\n  flex: 1;\n}\n\n.sidebar-drawer {\n  box-sizing: border-box;\n  display: flex;\n  justify-content: flex-end;\n  width: calc((100% - 82em) / 2 + 15em);\n  min-width: 15em;\n}\n\n.sidebar-container,\n.toc-drawer {\n  box-sizing: border-box;\n  width: 15em;\n}\n\n.toc-drawer {\n  padding-right: 1rem;\n}\n\n.sidebar-sticky,\n.toc-sticky {\n  position: sticky;\n  top: 0;\n  height: min(100%, 100vh);\n  height: 100vh;\n  display: flex;\n  flex-direction: column;\n}\n\n.sidebar-scroll,\n.toc-scroll {\n  flex-shrink: 1;\n  overflow: auto;\n  scroll-behavior: smooth;\n}\n\n.content {\n  padding: 0 3em;\n  width: 46em;\n  display: flex;\n  flex-direction: column;\n  justify-content: space-between;\n}\n\n.icon {\n  display: inline-block;\n  height: 1rem;\n  width: 1rem;\n}\n.icon svg {\n  width: 100%;\n  height: 100%;\n}\n\n.announcement {\n  height: var(--header-height);\n  display: flex;\n  align-items: center;\n  overflow-x: auto;\n}\n.announcement + .page {\n  min-height: calc(100% - var(--header-height));\n}\n\n.announcement-content {\n  box-sizing: border-box;\n  padding: 0.5rem;\n  min-width: 100%;\n  white-space: nowrap;\n  text-align: center;\n}\n\n.toc-overlay-icon, .nav-overlay-icon {\n  display: none;\n  cursor: pointer;\n}\n.toc-overlay-icon .icon, .nav-overlay-icon .icon {\n  color: var(--color-foreground-secondary);\n  height: 1.25rem;\n  width: 1.25rem;\n}\n\n.toc-header-icon, .nav-overlay-icon {\n  justify-content: center;\n  align-items: center;\n}\n\n.toc-content-icon {\n  height: 1.5rem;\n  width: 1.5rem;\n  margin-top: 1.5rem;\n  float: right;\n}\n\n.sidebar-toggle {\n  position: absolute;\n  display: none;\n}\n\n.sidebar-toggle[name=__toc] {\n  left: 20px;\n}\n\n.sidebar-toggle:checked {\n  left: 40px;\n}\n\n.overlay {\n  position: fixed;\n  top: 0;\n  width: 0;\n  height: 0;\n  transition: width 0ms, height 0ms, opacity 250ms ease-out;\n  opacity: 0;\n  background-color: rgba(0, 0, 0, 0.54);\n}\n\n.sidebar-overlay {\n  z-index: 20;\n}\n\n.toc-overlay {\n  z-index: 40;\n}\n\n.sidebar-drawer {\n  z-index: 30;\n  transition: left 250ms ease-in-out;\n}\n\n.toc-drawer {\n  z-index: 50;\n  transition: right 250ms ease-in-out;\n}\n\n#__navigation:checked ~ .sidebar-overlay {\n  width: 100%;\n  height: 100%;\n  opacity: 1;\n}\n#__navigation:checked ~ .page .sidebar-drawer {\n  top: 0;\n  left: 0;\n}\n\n#__toc:checked ~ .toc-overlay {\n  width: 100%;\n  height: 100%;\n  opacity: 1;\n}\n#__toc:checked ~ .page .toc-drawer {\n  top: 0;\n  right: 0;\n}\n\n@media (min-width: 97em) {\n  html {\n    font-size: 110%;\n  }\n}\n@media (max-width: 82em) {\n  .toc-content-icon {\n    display: flex;\n  }\n\n  .toc-drawer {\n    position: fixed;\n    height: 100vh;\n    top: 0;\n    right: -15em;\n    border-left: 1px solid var(--color-background-muted);\n  }\n\n  .toc-tree {\n    border-left: none;\n    font-size: var(--toc-font-size--mobile);\n  }\n\n  .sidebar-drawer {\n    width: calc((100% - 67em) / 2 + 15em);\n  }\n}\n@media (max-width: 67em) {\n  .nav-overlay-icon {\n    display: flex;\n  }\n\n  .sidebar-drawer {\n    position: fixed;\n    height: 100vh;\n    width: 15em;\n    top: 0;\n    left: -15em;\n  }\n\n  .toc-header-icon {\n    display: flex;\n  }\n\n  .toc-content-icon {\n    display: none;\n  }\n\n  .mobile-header {\n    position: sticky;\n    top: 0;\n    display: flex;\n    justify-content: space-between;\n    align-items: center;\n  }\n  .mobile-header .header-left,\n.mobile-header .header-right {\n    display: flex;\n    height: var(--header-height);\n    width: var(--header-height);\n  }\n  .mobile-header .header-left label,\n.mobile-header .header-right label {\n    height: 100%;\n    width: 100%;\n  }\n\n  :target {\n    scroll-margin-top: var(--header-height);\n  }\n\n  .page {\n    flex-direction: column;\n    justify-content: center;\n  }\n\n  .content {\n    margin-left: auto;\n    margin-right: auto;\n  }\n}\n@media (max-width: 52em) {\n  .content {\n    width: 100%;\n    overflow-x: auto;\n  }\n}\n@media (max-width: 46em) {\n  .content {\n    padding: 0 1em;\n  }\n\n  article div.sidebar {\n    float: none;\n    width: 100%;\n    margin: 1rem 0;\n  }\n}\n.admonition {\n  margin: 1rem auto;\n  padding: 0 0.5rem 0.5rem 0.5rem;\n  background: var(--color-admonition-background);\n  border-radius: 0.2rem;\n  border-left: 0.2rem solid var(--color-admonition-title);\n  box-shadow: 0 0.2rem 0.5rem rgba(0, 0, 0, 0.05), 0 0 0.0625rem rgba(0, 0, 0, 0.1);\n  font-size: var(--admonition-font-size);\n  overflow: hidden;\n  page-break-inside: avoid;\n}\n.admonition > :nth-child(2) {\n  margin-top: 0;\n}\n.admonition > :last-child {\n  margin-bottom: 0;\n}\n.admonition p.admonition-title {\n  position: relative;\n  margin: 0 -0.5rem 0.5rem;\n  padding: 0.5rem 0.5rem 0.5rem 2rem;\n  font-weight: 500;\n  font-size: var(--admonition-title-font-size);\n  background-color: var(--color-admonition-title-background);\n  line-height: 1.3;\n}\n.admonition p.admonition-title::before {\n  content: \"\";\n  position: absolute;\n  left: 0.5rem;\n  width: 1rem;\n  height: 1rem;\n  background-color: var(--color-admonition-title);\n  mask-image: var(--icon-admonition-default);\n  mask-repeat: no-repeat;\n}\n.admonition.caution {\n  border-left-color: var(--color-admonition-title--caution);\n}\n.admonition.caution > .admonition-title {\n  background-color: var(--color-admonition-title-background--caution);\n}\n.admonition.caution > .admonition-title::before {\n  background-color: var(--color-admonition-title--caution);\n  mask-image: var(--icon-spark);\n}\n.admonition.warning {\n  border-left-color: var(--color-admonition-title--warning);\n}\n.admonition.warning > .admonition-title {\n  background-color: var(--color-admonition-title-background--warning);\n}\n.admonition.warning > .admonition-title::before {\n  background-color: var(--color-admonition-title--warning);\n  mask-image: var(--icon-warning);\n}\n.admonition.danger {\n  border-left-color: var(--color-admonition-title--danger);\n}\n.admonition.danger > .admonition-title {\n  background-color: var(--color-admonition-title-background--danger);\n}\n.admonition.danger > .admonition-title::before {\n  background-color: var(--color-admonition-title--danger);\n  mask-image: var(--icon-spark);\n}\n.admonition.attention {\n  border-left-color: var(--color-admonition-title--attention);\n}\n.admonition.attention > .admonition-title {\n  background-color: var(--color-admonition-title-background--attention);\n}\n.admonition.attention > .admonition-title::before {\n  background-color: var(--color-admonition-title--attention);\n  mask-image: var(--icon-warning);\n}\n.admonition.error {\n  border-left-color: var(--color-admonition-title--error);\n}\n.admonition.error > .admonition-title {\n  background-color: var(--color-admonition-title-background--error);\n}\n.admonition.error > .admonition-title::before {\n  background-color: var(--color-admonition-title--error);\n  mask-image: var(--icon-failure);\n}\n.admonition.hint {\n  border-left-color: var(--color-admonition-title--hint);\n}\n.admonition.hint > .admonition-title {\n  background-color: var(--color-admonition-title-background--hint);\n}\n.admonition.hint > .admonition-title::before {\n  background-color: var(--color-admonition-title--hint);\n  mask-image: var(--icon-question);\n}\n.admonition.important {\n  border-left-color: var(--color-admonition-title--important);\n}\n.admonition.important > .admonition-title {\n  background-color: var(--color-admonition-title-background--important);\n}\n.admonition.important > .admonition-title::before {\n  background-color: var(--color-admonition-title--important);\n  mask-image: var(--icon-flame);\n}\n.admonition.note {\n  border-left-color: var(--color-admonition-title--note);\n}\n.admonition.note > .admonition-title {\n  background-color: var(--color-admonition-title-background--note);\n}\n.admonition.note > .admonition-title::before {\n  background-color: var(--color-admonition-title--note);\n  mask-image: var(--icon-pencil);\n}\n.admonition.seealso {\n  border-left-color: var(--color-admonition-title--seealso);\n}\n.admonition.seealso > .admonition-title {\n  background-color: var(--color-admonition-title-background--seealso);\n}\n.admonition.seealso > .admonition-title::before {\n  background-color: var(--color-admonition-title--seealso);\n  mask-image: var(--icon-info);\n}\n.admonition.tip {\n  border-left-color: var(--color-admonition-title--tip);\n}\n.admonition.tip > .admonition-title {\n  background-color: var(--color-admonition-title-background--tip);\n}\n.admonition.tip > .admonition-title::before {\n  background-color: var(--color-admonition-title--tip);\n  mask-image: var(--icon-info);\n}\n.admonition.admonition-todo {\n  border-left-color: var(--color-admonition-title--admonition-todo);\n}\n.admonition.admonition-todo > .admonition-title {\n  background-color: var(--color-admonition-title-background--admonition-todo);\n}\n.admonition.admonition-todo > .admonition-title::before {\n  background-color: var(--color-admonition-title--admonition-todo);\n  mask-image: var(--icon-pencil);\n}\n\n.admonition-todo > .admonition-title {\n  text-transform: uppercase;\n}\n\ndl.py dd, dl.cpp dd, dl.c dd, dl.js dd {\n  margin-left: 2rem;\n}\ndl.py dd > :first-child, dl.cpp dd > :first-child, dl.c dd > :first-child, dl.js dd > :first-child {\n  margin-top: 0.125rem;\n}\ndl.py dd > :last-child, dl.cpp dd > :last-child, dl.c dd > :last-child, dl.js dd > :last-child {\n  margin-bottom: 1.25rem;\n}\ndl.py .field-list, dl.cpp .field-list, dl.c .field-list, dl.js .field-list {\n  margin-bottom: 0.75rem;\n}\ndl.py .field-list dt, dl.cpp .field-list dt, dl.c .field-list dt, dl.js .field-list dt {\n  text-transform: uppercase;\n  font-size: var(--font-size--small);\n}\ndl.py .field-list dd:empty, dl.cpp .field-list dd:empty, dl.c .field-list dd:empty, dl.js .field-list dd:empty {\n  margin-bottom: 0.5rem;\n}\ndl.py .field-list dd > ul, dl.cpp .field-list dd > ul, dl.c .field-list dd > ul, dl.js .field-list dd > ul {\n  margin-left: -1.2rem;\n}\ndl.py .field-list dd > ul > li > p:nth-child(2), dl.cpp .field-list dd > ul > li > p:nth-child(2), dl.c .field-list dd > ul > li > p:nth-child(2), dl.js .field-list dd > ul > li > p:nth-child(2) {\n  margin-top: 0;\n}\ndl.py .field-list dd > ul > li > p + p:last-child:empty, dl.cpp .field-list dd > ul > li > p + p:last-child:empty, dl.c .field-list dd > ul > li > p + p:last-child:empty, dl.js .field-list dd > ul > li > p + p:last-child:empty {\n  margin-top: 0;\n  margin-bottom: 0;\n}\ndl.py > dt, dl.cpp > dt, dl.c > dt, dl.js > dt {\n  color: var(--color-api-overall);\n}\ndl.py > dt:target, dl.cpp > dt:target, dl.c > dt:target, dl.js > dt:target {\n  background-color: var(--color-api-highlight-on-target);\n}\n\ndl.class > dt,\ndl.function > dt,\ndl.method > dt,\ndl.enum > dt,\ndl.enum-class > dt,\ndl.enum-struct > dt,\ndl.type > dt,\ndl.exception > dt {\n  padding-left: 3em;\n  text-indent: -3em;\n}\ndl.class > dt .property,\ndl.function > dt .property,\ndl.method > dt .property,\ndl.enum > dt .property,\ndl.enum-class > dt .property,\ndl.enum-struct > dt .property,\ndl.type > dt .property,\ndl.exception > dt .property {\n  color: var(--color-api-keyword);\n  padding-right: 0.25rem;\n}\n\n.sig-name {\n  font-weight: bold;\n  color: var(--color-api-name);\n}\n\n.sig-prename {\n  color: var(--color-api-pre-name);\n}\n\n.sig-paren {\n  color: var(--color-api-paren);\n}\n\n.sig-param {\n  font-style: normal;\n}\n\n.versionmodified {\n  font-style: italic;\n}\n\ndiv.versionadded p, div.versionchanged p, div.deprecated p {\n  margin-top: 0.125rem;\n  margin-bottom: 0.125rem;\n}\n\n.viewcode-link, .viewcode-back {\n  float: right;\n  font-size: var(--font-size--small);\n}\n\narticle p.caption,\ntable > caption,\n.code-block-caption {\n  font-size: var(--font-size--small);\n  text-align: center;\n}\n\n.toctree-wrapper.compound .caption {\n  font-size: var(--font-size--small);\n  text-transform: uppercase;\n  text-align: initial;\n  margin-bottom: 0;\n}\n.toctree-wrapper.compound > ul {\n  margin-top: 0;\n  margin-bottom: 0;\n}\n\ncode.literal {\n  background: var(--color-inline-code-background);\n  border-radius: 0.2em;\n  font-size: var(--font-size--small--2);\n  padding: 0.1em 0.2em;\n}\n\narticle div[class*=\" highlight-\"],\narticle div[class^=highlight-] {\n  margin: 1em 0;\n  display: flex;\n}\n\npre {\n  margin: 0;\n  padding: 0;\n}\narticle pre {\n  line-height: 1.5;\n}\npre.literal-block, .highlight pre {\n  font-size: var(--code-font-size);\n  padding: 0.625rem 0.875rem;\n  overflow: auto;\n}\npre.literal-block {\n  margin-top: 1rem;\n  margin-bottom: 1rem;\n  border-radius: 0.2rem;\n  background-color: var(--color-code-background);\n  color: var(--color-code-foreground);\n}\n\n.highlight {\n  width: 100%;\n  border-radius: 0.2rem;\n}\n\n.highlighttable {\n  width: 100%;\n  display: block;\n}\n.highlighttable tbody {\n  display: block;\n}\n.highlighttable tr {\n  display: flex;\n}\n.highlighttable td.linenos {\n  background-color: var(--color-code-background);\n  color: var(--color-code-foreground);\n  padding: 0.625rem 0.875rem;\n  padding-right: 0;\n  border-top-left-radius: 0.2rem;\n  border-bottom-left-radius: 0.2rem;\n}\n.highlighttable .linenodiv {\n  font-size: var(--code-font-size);\n  padding-right: 0.5rem;\n  box-shadow: -0.0625rem 0 var(--color-code-foreground) inset;\n  opacity: 0.5;\n}\n.highlighttable td.code {\n  padding: 0;\n  display: block;\n  flex: 1;\n  overflow: hidden;\n}\n.highlighttable td.code .highlight {\n  border-top-left-radius: 0;\n  border-bottom-left-radius: 0;\n}\n\n.footnote-reference {\n  font-size: var(--font-size--small--4);\n  vertical-align: super;\n}\n\ndl.footnote {\n  font-size: var(--font-size--small);\n  color: var(--color-foreground-secondary);\n  display: grid;\n  grid-template-columns: max-content auto;\n}\ndl.footnote dt {\n  margin: 0;\n}\ndl.footnote dt > .fn-backref {\n  margin-left: 0.25rem;\n}\ndl.footnote dt:after {\n  content: \":\";\n}\ndl.footnote dt .brackets:before {\n  content: \"[\";\n}\ndl.footnote dt .brackets:after {\n  content: \"]\";\n}\n\nimg {\n  box-sizing: border-box;\n  max-width: 100%;\n  height: auto;\n}\n\narticle .figure {\n  border-radius: 0.2rem;\n  padding: 0.5rem;\n}\narticle .figure :last-child {\n  margin-bottom: 0;\n}\narticle .align-left {\n  float: left;\n  clear: left;\n  margin: 0 1rem 1rem;\n}\narticle .align-right {\n  float: right;\n  clear: right;\n  margin: 0 1rem 1rem;\n}\narticle .align-center, article .figure.align-default,\narticle .legend .align-default {\n  text-align: center;\n  margin-left: auto;\n  margin-right: auto;\n}\narticle .figure.align-default,\narticle .legend .align-default {\n  display: block;\n}\n\n.genindex-jumpbox {\n  border-top: 1px solid var(--color-background-border);\n  border-bottom: 1px solid var(--color-background-border);\n  padding: 0.25rem;\n}\n\n.genindex-section h2 {\n  margin-top: 0.75rem;\n  margin-bottom: 0.5rem;\n}\n.genindex-section ul {\n  margin-top: 0;\n  margin-bottom: 0;\n}\n\nul,\nol {\n  padding-left: 1.2rem;\n  margin-top: 1rem;\n  margin-bottom: 1rem;\n}\nul li > p:first-child,\nol li > p:first-child {\n  margin-top: 0.25rem;\n  margin-bottom: 0.25rem;\n}\nul li > p:last-child,\nol li > p:last-child {\n  margin-top: 0.25rem;\n}\nul li > ul,\nul li > ol,\nol li > ul,\nol li > ol {\n  margin-top: 0.5rem;\n  margin-bottom: 0.5rem;\n}\n\n.simple li > ul,\n.simple li > ol,\n.toctree-wrapper li > ul,\n.toctree-wrapper li > ol {\n  margin-top: 0;\n  margin-bottom: 0;\n}\n\n.field-list dt,\n.option-list dt,\ndl:not([class]) dt,\ndl.simple dt,\ndl.footnote dt,\ndl.glossary dt {\n  font-weight: 500;\n  margin-top: 0.25rem;\n}\n.field-list dt + dt,\n.option-list dt + dt,\ndl:not([class]) dt + dt,\ndl.simple dt + dt,\ndl.footnote dt + dt,\ndl.glossary dt + dt {\n  margin-top: 0;\n}\n.field-list dt .classifier::before,\n.option-list dt .classifier::before,\ndl:not([class]) dt .classifier::before,\ndl.simple dt .classifier::before,\ndl.footnote dt .classifier::before,\ndl.glossary dt .classifier::before {\n  content: \":\";\n  margin-left: 0.2rem;\n  margin-right: 0.2rem;\n}\n.field-list dd > p:first-child,\n.field-list dd ul,\n.option-list dd > p:first-child,\n.option-list dd ul,\ndl:not([class]) dd > p:first-child,\ndl:not([class]) dd ul,\ndl.simple dd > p:first-child,\ndl.simple dd ul,\ndl.footnote dd > p:first-child,\ndl.footnote dd ul,\ndl.glossary dd > p:first-child,\ndl.glossary dd ul {\n  margin-top: 0.125rem;\n}\n.field-list dd ul,\n.option-list dd ul,\ndl:not([class]) dd ul,\ndl.simple dd ul,\ndl.footnote dd ul,\ndl.glossary dd ul {\n  margin-bottom: 0.125rem;\n}\n\n.math-wrapper {\n  width: 100%;\n  overflow-x: auto;\n}\n\nabbr[title] {\n  cursor: help;\n}\n\nkbd:not(.compound) {\n  margin: 0 0.2rem;\n  padding: 0 0.2rem;\n  border-radius: 0.2rem;\n  border: 1px solid var(--color-foreground-border);\n  color: var(--color-foreground-primary);\n  vertical-align: text-bottom;\n  font-size: var(--font-size--small--3);\n  display: inline-block;\n  box-shadow: 0 0.0625rem 0 rgba(0, 0, 0, 0.2), inset 0 0 0 0.125rem var(--color-background-primary);\n  background-color: var(--color-background-secondary);\n}\n\nblockquote {\n  border-left: 1px solid var(--color-foreground-border);\n  font-style: italic;\n  margin-left: 0.5rem;\n  margin-right: 0.5rem;\n  padding: 0.5rem 1rem;\n}\n\n.reference img {\n  vertical-align: middle;\n}\n\nh1 > .headerlink,\nh2 > .headerlink,\nh3 > .headerlink,\nh4 > .headerlink,\nh5 > .headerlink,\nh6 > .headerlink,\ndl dt > .headerlink,\np.caption > .headerlink,\ntable > caption > .headerlink,\n.code-block-caption > .headerlink {\n  font-weight: 100;\n  margin-left: 0.5rem;\n  visibility: hidden;\n  text-decoration: none;\n}\nh1:hover > .headerlink,\nh2:hover > .headerlink,\nh3:hover > .headerlink,\nh4:hover > .headerlink,\nh5:hover > .headerlink,\nh6:hover > .headerlink,\ndl dt:hover > .headerlink,\np.caption:hover > .headerlink,\ntable > caption:hover > .headerlink,\n.code-block-caption:hover > .headerlink {\n  visibility: visible;\n}\n\n:target > h1:first-child > .headerlink,\n:target > h2:first-child > .headerlink,\n:target > h3:first-child > .headerlink,\n:target > h4:first-child > .headerlink,\n:target > h5:first-child > .headerlink,\n:target > h6:first-child > .headerlink {\n  visibility: visible;\n}\n\np.rubric {\n  text-transform: uppercase;\n  font-size: var(--font-size--small);\n}\n\narticle .sidebar {\n  float: right;\n  clear: right;\n  width: 30%;\n  margin-left: 1rem;\n  margin-right: 0;\n  border-radius: 0.2rem;\n  background-color: var(--color-background-secondary);\n  border: var(--color-background-border) 1px solid;\n}\narticle .sidebar > * {\n  padding-left: 1rem;\n  padding-right: 1rem;\n}\narticle .sidebar .sidebar-title {\n  margin: 0;\n  padding: 0.5rem 1rem;\n  border-bottom: var(--color-background-border) 1px solid;\n  font-weight: 500;\n}\n\n.table-wrapper {\n  width: 100%;\n  overflow-x: auto;\n  margin-top: 1rem;\n  margin-bottom: 0.5rem;\n  padding: 0.2rem 0.2rem 0.75rem;\n}\n\ntable.docutils {\n  border-radius: 0.2rem;\n  border-spacing: 0;\n  border-collapse: collapse;\n  box-shadow: 0 0.2rem 0.5rem rgba(0, 0, 0, 0.05), 0 0 0.0625rem rgba(0, 0, 0, 0.1);\n}\ntable.docutils th {\n  background: var(--color-background-secondary);\n}\ntable.docutils td,\ntable.docutils th {\n  padding: 0 0.25rem;\n  border-left: 1px solid var(--color-background-border);\n  border-right: 1px solid var(--color-background-border);\n  border-bottom: 1px solid var(--color-background-border);\n}\ntable.docutils td p,\ntable.docutils th p {\n  margin: 0.25rem;\n}\ntable.docutils td:first-child,\ntable.docutils th:first-child {\n  border-left: none;\n}\ntable.docutils td:last-child,\ntable.docutils th:last-child {\n  border-right: none;\n}\n\n.guilabel {\n  background-color: var(--color-guilabel-background);\n  border: 1px solid var(--color-guilabel-border);\n  color: var(--color-guilabel-text);\n  padding: 0 0.3em;\n  border-radius: 0.5em;\n  font-size: 0.9em;\n}\n\nfooter {\n  font-size: var(--font-size--small);\n  display: flex;\n  flex-direction: column;\n  margin-top: 2rem;\n}\n\n.related-information {\n  margin-top: 1rem;\n  padding: 0.75rem;\n  padding-bottom: 1rem;\n  border-top: 1px solid var(--color-background-border);\n  line-height: 1.5;\n  color: var(--color-foreground-secondary);\n}\n\n.related-pages a {\n  display: flex;\n  align-items: center;\n  text-decoration: none;\n}\n.related-pages a:hover .page-info .title {\n  text-decoration: underline;\n  color: var(--color-link);\n  text-decoration-color: var(--color-link-underline);\n}\n.related-pages a svg,\n.related-pages a svg > use {\n  flex-shrink: 0;\n  color: var(--color-foreground-border);\n  width: 0.75rem;\n  height: 0.75rem;\n  margin: 0 0.5rem;\n}\n.related-pages a.next-page {\n  max-width: 50%;\n  float: right;\n  clear: right;\n  text-align: right;\n}\n.related-pages a.prev-page {\n  max-width: 50%;\n  float: left;\n  clear: left;\n}\n.related-pages a.prev-page svg {\n  transform: rotate(180deg);\n}\n\n.page-info {\n  display: flex;\n  flex-direction: column;\n}\n.next-page .page-info {\n  align-items: flex-end;\n}\n.page-info .context {\n  display: flex;\n  align-items: center;\n  padding-bottom: 0.1rem;\n  color: var(--color-foreground-muted);\n  font-size: var(--font-size--small);\n  text-decoration: none;\n}\n\nul.search {\n  padding-left: 0;\n  list-style: none;\n}\nul.search li {\n  padding: 1rem 0;\n  border-bottom: 1px solid var(--color-background-border);\n}\n\n.highlighted {\n  background-color: var(--color-highlighted-background);\n  color: var(--color-highlighted-text);\n}\n\n.sidebar-brand {\n  display: flex;\n  flex-direction: column;\n  flex-shrink: 0;\n  padding: var(--sidebar-item-spacing-vertical) var(--sidebar-item-spacing-horizontal);\n  text-decoration: none;\n}\n\n.sidebar-brand-text {\n  overflow-wrap: break-word;\n  margin: var(--sidebar-item-spacing-vertical) 0;\n  font-size: 1.5rem;\n}\n\n.sidebar-logo-container {\n  margin: var(--sidebar-item-spacing-vertical) 0;\n}\n\n.sidebar-logo {\n  margin: 0 auto;\n  display: block;\n  max-width: 100%;\n}\n\n.sidebar-search-container {\n  display: flex;\n  align-items: center;\n  margin-top: var(--sidebar-search-space-above);\n  position: relative;\n}\n.sidebar-search-container::before {\n  content: \"\";\n  position: absolute;\n  left: var(--sidebar-item-spacing-horizontal);\n  width: var(--sidebar-search-icon-size);\n  height: var(--sidebar-search-icon-size);\n}\n\n.sidebar-search {\n  box-sizing: border-box;\n  padding-top: var(--sidebar-search-input-spacing-vertical);\n  padding-bottom: var(--sidebar-search-input-spacing-vertical);\n  padding-right: var(--sidebar-search-input-spacing-horizontal);\n  padding-left: calc(var(--sidebar-item-spacing-horizontal) + var(--sidebar-search-input-spacing-horizontal) + var(--sidebar-search-icon-size));\n  width: 100%;\n  color: var(--color-sidebar-search-foreground);\n  background: transparent;\n  z-index: 10;\n}\n.sidebar-search:focus {\n  outline: none;\n}\n.sidebar-search::placeholder {\n  font-size: var(--sidebar-search-input-font-size);\n}\n\n.sidebar-tree {\n  font-size: var(--sidebar-item-font-size);\n  margin-top: var(--sidebar-tree-space-above);\n  margin-bottom: var(--sidebar-item-spacing-vertical);\n}\n.sidebar-tree ul {\n  padding: 0;\n  margin-top: 0;\n  margin-bottom: 0;\n  display: flex;\n  flex-direction: column;\n  list-style: none;\n}\n.sidebar-tree li {\n  position: relative;\n  margin: 0;\n}\n.sidebar-tree li > ul {\n  margin-left: var(--sidebar-item-spacing-horizontal);\n}\n.sidebar-tree .reference {\n  box-sizing: border-box;\n  display: inline-block;\n  line-height: var(--sidebar-item-line-height);\n  height: 100%;\n  width: 100%;\n  padding: var(--sidebar-item-spacing-vertical) var(--sidebar-item-spacing-horizontal);\n}\n.sidebar-tree .reference.external::after {\n  content: url('data:image/svg+xml,<svg width=\"12\" height=\"12\" xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 24 24\" stroke-width=\"1.5\" stroke=\"%23607D8B\" fill=\"none\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><path stroke=\"none\" d=\"M0 0h24v24H0z\"/><path d=\"M11 7h-5a2 2 0 0 0 -2 2v9a2 2 0 0 0 2 2h9a2 2 0 0 0 2 -2v-5\" /><line x1=\"10\" y1=\"14\" x2=\"20\" y2=\"4\" /><polyline points=\"15 4 20 4 20 9\" /></svg>');\n  margin: 0 0.25rem;\n  vertical-align: middle;\n}\n.sidebar-tree .current-page > .reference {\n  font-weight: bold;\n}\n.sidebar-tree label {\n  position: absolute;\n  top: 0;\n  right: 0;\n  height: var(--sidebar-item-height);\n  width: var(--sidebar-expander-width);\n  cursor: pointer;\n  display: flex;\n  justify-content: center;\n  align-items: center;\n}\n.sidebar-tree .caption {\n  font-size: var(--sidebar-caption-font-size);\n  font-weight: bold;\n  text-transform: uppercase;\n  margin: var(--sidebar-caption-space-above) 0 0 0;\n  padding: var(--sidebar-item-spacing-vertical) var(--sidebar-item-spacing-horizontal);\n}\n.sidebar-tree li.has-children > .reference {\n  padding-right: var(--sidebar-expander-width);\n}\n\n.toctree-checkbox {\n  position: absolute;\n  display: none;\n}\n\n.toctree-checkbox ~ ul {\n  display: none;\n}\n.toctree-checkbox ~ label .icon svg {\n  transform: rotate(90deg);\n}\n\n.toctree-checkbox:checked ~ ul {\n  display: block;\n}\n.toctree-checkbox:checked ~ label .icon svg {\n  transform: rotate(-90deg);\n}\n\n.toc-title-container {\n  padding: var(--toc-title-padding);\n  padding-top: var(--toc-spacing-vertical);\n}\n\n.toc-title {\n  font-size: var(--toc-title-font-size);\n  padding-left: var(--toc-spacing-horizontal);\n  text-transform: uppercase;\n}\n\n.no-toc {\n  display: none;\n}\n\n.toc-tree-container {\n  padding-bottom: var(--toc-spacing-vertical);\n}\n\n.toc-tree {\n  font-size: var(--toc-font-size);\n  line-height: 1.3;\n  padding-left: calc(var(--toc-spacing-horizontal) - var(--toc-item-spacing-horizontal));\n}\n.toc-tree > ul > li:first-child {\n  padding-top: 0;\n}\n.toc-tree > ul > li:first-child > ul {\n  padding-left: 0;\n}\n.toc-tree > ul > li:first-child > a {\n  display: none;\n}\n.toc-tree ul {\n  list-style-type: none;\n  margin-top: 0;\n  margin-bottom: 0;\n  padding-left: var(--toc-item-spacing-horizontal);\n}\n.toc-tree li {\n  padding-top: var(--toc-item-spacing-vertical);\n}\n.toc-tree li .reference {\n  word-break: break-word;\n  text-decoration: none;\n}\n.toc-tree li.scroll-current > .reference {\n  font-weight: bold;\n}\n\n.toc-scroll {\n  max-height: 100vh;\n  overflow-y: scroll;\n}\n\n.contents:not(.this-will-duplicate-information-and-it-is-still-useful-here) {\n  color: var(--color-problematic);\n  background: rgba(255, 0, 0, 0.25);\n}\n.contents:not(.this-will-duplicate-information-and-it-is-still-useful-here)::before {\n  content: \"ERROR: Adding a table of contents in Furo-based documentation is unnecessary, and does not work well with existing styling. Add a 'this-will-duplicate-information-and-it-is-still-useful-here' class, if you want an escape hatch.\";\n}","// This file contains the styling for making the content throughout the page,\n// including fonts, paragraphs, headings and spacing among these elements.\n\nhtml\n  font-family: var(--font-stack)\npre,\ncode,\nkbd,\nsamp\n  font-family: var(--font-stack--monospace)\n\n// Make fonts look slightly nicer.\nbody\n  -webkit-font-smoothing: antialiased\n  -moz-osx-font-smoothing: grayscale\n\n// Line height from Bootstrap 4.1\narticle\n  line-height: 1.5\n\n//\n// Headings\n//\nh1\n  font-size: 2.25rem\nh2\n  font-size: 1.75rem\nh3\n  font-size: 1.25rem\nh4\n  font-size: 1rem\nh5\n  font-size: 0.875rem\nh6\n  font-size: 0.75rem\n\n// Main headings\nh1,\nh2\n  margin-top: 1.5rem\n  margin-bottom: 1rem\n  font-weight: 300\n\nh3\n  margin-top: 1.5rem\n  margin-bottom: 0.75rem\n  font-weight: 400\n\n// You're in-too-deep headings\nh4,\nh5,\nh6\n  text-transform: uppercase\n  margin-top: 1rem\n  margin-bottom: 0.5rem\n  font-weight: 700\n\n// Paragraph\np\n  margin-top: 0.75rem\n  margin-bottom: 0.75rem\n\n// Horizontal rules\nhr.docutils\n  height: 1px\n  padding: 0\n  margin: 2rem 0\n  background-color: var(--color-background-border)\n  border: 0\n\n.centered\n  text-align: center\n","// This file defines all the knobs that can be tweaked by end users.\n\n// Overall Layout Variables\n//\n// These are set here, since CSS variables can't be used in media queries,\n// which is where these would be used.\n$content-padding: 3em;\n$content-padding--small: 1em;\n$content-width: 46em;\n$sidebar-width: 15em;\n$full-width: $content-width + 2 * ($content-padding + $sidebar-width);\n\n// Admonitions\n//\n// Structure of these: (color, key-in-$icons).\n// The colors are translated into CSS variables below, and icons are used for\n// the declarations.\n$admonition-default: #651fff \"abstract\";\n$admonitions: (\n  // Each of these has an reST directives for it.\n  \"caution\": #ff9100 \"spark\",\n  \"warning\": #ff9100 \"warning\",\n  \"danger\": #ff5252 \"spark\",\n  \"attention\": #ff5252 \"warning\",\n  \"error\": #ff5252 \"failure\",\n  \"hint\": #00c852 \"question\",\n  \"important\": #00bfa5 \"flame\",\n  \"note\": #00b0ff \"pencil\",\n  \"seealso\": #448aff \"info\",\n  \"tip\": #00c852 \"info\",\n  \"admonition-todo\": #808080 \"pencil\"\n);\n\n:root {\n  //////////////////////////////////////////////////////////////////////////////\n  // Fonts\n  //////////////////////////////////////////////////////////////////////////////\n  // These are adapted from https://systemfontstack.com/\n  --font-stack: -apple-system, BlinkMacSystemFont, Segoe UI, Helvetica, Arial,\n    sans-serif, Apple Color Emoji, Segoe UI Emoji;\n  --font-stack--monospace: \"SFMono-Regular\", Menlo, Consolas, Monaco,\n    Liberation Mono, Lucida Console, monospace;\n\n  --font-size--normal: 100%;\n  --font-size--small: 87.5%;\n  --font-size--small--2: 81.25%;\n  --font-size--small--3: 75%;\n  --font-size--small--4: 62.5%;\n\n  // Sidebar\n  --sidebar-caption-font-size: var(--font-size--small--2);\n  --sidebar-item-font-size: var(--font-size--small);\n  --sidebar-search-input-font-size: var(--font-size--small);\n\n  // Table of Contents\n  --toc-font-size: var(--font-size--small--3);\n  --toc-font-size--mobile: var(--font-size--normal);\n  --toc-title-font-size: var(--font-size--small--4);\n\n  // Admonitions\n  --admonition-font-size: 0.8125rem;\n  --admonition-title-font-size: 0.8125rem;\n\n  // Code\n  --code-font-size: var(--font-size--small--2);\n\n  //////////////////////////////////////////////////////////////////////////////\n  // Spacing\n  //////////////////////////////////////////////////////////////////////////////\n  --header-height: calc(\n    var(--sidebar-item-line-height) + 4 * #{var(--sidebar-item-spacing-vertical)}\n  );\n\n  // Sidebar\n  --sidebar-tree-space-above: 1.5rem;\n  --sidebar-caption-space-above: 1rem;\n\n  --sidebar-item-line-height: 1rem;\n  --sidebar-item-spacing-vertical: 0.5rem;\n  --sidebar-item-spacing-horizontal: 1rem;\n  --sidebar-item-height: calc(\n    var(--sidebar-item-line-height) + 2 *#{var(--sidebar-item-spacing-vertical)}\n  );\n\n  --sidebar-expander-width: var(--sidebar-item-height); // be square\n\n  --sidebar-search-space-above: 0.5rem;\n  --sidebar-search-input-spacing-vertical: 0.5rem;\n  --sidebar-search-input-spacing-horizontal: 0.5rem;\n  --sidebar-search-input-height: 1rem;\n  --sidebar-search-icon-size: var(--sidebar-search-input-height);\n\n  // Table of Contents\n  --toc-title-padding: 0.25rem 0;\n  --toc-spacing-vertical: 1.5rem;\n  --toc-spacing-horizontal: 1.5rem;\n  --toc-item-spacing-vertical: 0.4rem;\n  --toc-item-spacing-horizontal: 1rem;\n\n  //////////////////////////////////////////////////////////////////////////////\n  // Icons\n  //////////////////////////////////////////////////////////////////////////////\n  @each $name, $glyph in $icons {\n    --icon-#{$name}: #{$glyph};\n  }\n  --icon-admonition-default: var(--icon-#{nth($admonition-default, 2)});\n\n  //////////////////////////////////////////////////////////////////////////////\n  // Overall Colors\n  //     To give the user more control, avoid using these colors directly\n  //     outside of this file. Instead, try to define more variables here that\n  //     based on these, and use them in the actual stylesheets.\n  //////////////////////////////////////////////////////////////////////////////\n  --color-problematic: #b30000;\n\n  // Base Colors\n  --color-foreground-primary: black; // for main text and headings\n  --color-foreground-secondary: #5a5c63; // for secondary text\n  --color-foreground-muted: #72747e; // for muted text\n  --color-foreground-border: #878787; // for content borders\n\n  --color-background-primary: white; // for content\n  --color-background-secondary: #f8f9fb; // for navigation + ToC\n  --color-background-hover: #efeff4ff; // for navigation-item hover\n  --color-background-hover--transparent: #efeff400;\n  --color-background-border: #eeebee; // for UI borders\n\n  // Announcements\n  --color-announcement-background: #000000dd;\n  --color-announcement-text: #eeebee;\n\n  // Brand colors\n  --color-brand-primary: #2962ff;\n  --color-brand-content: #2a5adf;\n\n  // API documentation\n  --color-api-overall: var(--color-foreground-muted);\n  --color-api-name: var(--color-brand-content);\n  --color-api-pre-name: var(--color-brand-content);\n  --color-api-paren: var(--color-foreground-secondary);\n  --color-api-keyword: var(--color-problematic);\n  --color-api-highlight-on-target: #ffffcc;\n\n  // Inline code background\n  --color-inline-code-background: var(--color-background-secondary);\n\n  // Highlighted text (search)\n  --color-highlighted-background: #ddeeff;\n  --color-highlighted-text: var(--color-foreground-primary);\n\n  // GUI Labels\n  --color-guilabel-background: #ddeeff80;\n  --color-guilabel-border: #bedaf580;\n  --color-guilabel-text: var(--color-foreground-primary);\n\n  // Admonitions!\n  --color-admonition-background: transparent;\n  --color-admonition-title: #{nth($admonition-default, 1)};\n  --color-admonition-title-background: #{rgba(nth($admonition-default, 1), 0.1)};\n\n  @each $name, $values in $admonitions {\n    --color-admonition-title--#{$name}: #{nth($values, 1)};\n    --color-admonition-title-background--#{$name}: #{rgba(\n        nth($values, 1),\n        0.1\n      )};\n  }\n\n  //////////////////////////////////////////////////////////////////////////////\n  // Everything below this should be one of:\n  // - var(...)\n  // - *-gradient(...)\n  // - special literal values (eg: transparent, none)\n  //////////////////////////////////////////////////////////////////////////////\n\n  // Header\n  --color-header-background: var(--color-background-primary);\n  --color-header-border: var(--color-background-border);\n  --color-header-text: var(--color-foreground-primary);\n\n  // Sidebar (left)\n  --color-sidebar-background: var(--color-background-secondary);\n  --color-sidebar-background-border: var(--color-background-border);\n\n  --color-sidebar-brand-text: var(--color-foreground-primary);\n  --color-sidebar-caption-text: var(--color-foreground-muted);\n  --color-sidebar-link-text: var(--color-foreground-secondary);\n  --color-sidebar-link-text--top-level: var(--color-brand-primary);\n\n  --color-sidebar-item-background: var(--color-sidebar-background);\n  --color-sidebar-item-background--current: var(\n    --color-sidebar-item-background\n  );\n  --color-sidebar-item-background--hover: linear-gradient(\n    90deg,\n    var(--color-background-hover--transparent) 0%,\n    var(--color-background-hover) var(--sidebar-item-spacing-horizontal),\n    var(--color-background-hover) 100%\n  );\n\n  --color-sidebar-item-expander-background: transparent;\n  --color-sidebar-item-expander-background--hover: var(\n    --color-background-hover\n  );\n\n  --color-sidebar-search-text: var(--color-foreground-primary);\n  --color-sidebar-search-background: var(--color-background-secondary);\n  --color-sidebar-search-background--focus: var(--color-background-primary);\n  --color-sidebar-search-border: var(--color-background-border);\n  --color-sidebar-search-icon: var(--color-foreground-muted);\n\n  // Table of Contents\n  --color-toc-background: var(--color-background-primary);\n  --color-toc-title-text: var(--color-foreground-muted);\n  --color-toc-item-text: var(--color-foreground-secondary);\n  --color-toc-item-text--hover: var(--color-foreground-primary);\n  --color-toc-item-text--active: var(--color-brand-primary);\n\n  // Actual page contents\n  --color-content-foreground: var(--color-foreground-primary);\n  --color-content-background: transparent;\n\n  --color-link: var(--color-brand-content);\n  --color-link--hover: var(--color-brand-content);\n  --color-link-underline: var(--color-background-border);\n  --color-link-underline--hover: var(--color-foreground-border);\n}\n\n@media (prefers-color-scheme: dark) {\n  :root {\n    --color-problematic: #e25050;\n\n    // Base Colors\n    --color-foreground-primary: #ffffffd9; // for main text and headings\n    --color-foreground-secondary: #9ca0a5; // for secondary text\n    --color-foreground-muted: #81868d; // for muted text\n    --color-foreground-border: #666666; // for content borders\n\n    --color-background-primary: #131416; // for content\n    --color-background-secondary: #1a1c1e; // for navigation + ToC\n    --color-background-hover: #1e2124ff; // for navigation-item hover\n    --color-background-hover--transparent: #1e212400;\n    --color-background-border: #303335; // for UI borders\n\n    // Announcements\n    --color-announcement-background: #000000dd;\n    --color-announcement-text: #eeebee;\n\n    // Brand colors\n    --color-brand-primary: #2b8cee;\n    --color-brand-content: #368ce2;\n\n    // Highlighted text (search)\n    --color-highlighted-background: #083563;\n\n    // GUI Labels\n    --color-guilabel-background: #08356380;\n    --color-guilabel-border: #13395f80;\n\n    // API documentation\n    --color-api-highlight-on-target: #333300;\n\n    // Admonitions\n    --color-admonition-background: #18181a;\n  }\n}\n","// This file contains the styles for the overall layouting of the documentation\n// skeleton, including the responsive changes as well as sidebar toggles.\n//\n// This is implemented as a mobile-last design, which isn't ideal, but it is\n// reasonably good-enough and I got pretty tired by the time I'd finished this\n// to move the rules around to fix this. Shouldn't take more than 3-4 hours,\n// if you know what you're doing tho.\n\n// HACK: Not all browsers account for the scrollbar width in media queries.\n// This results in horizontal scrollbars in the breakpoint where we go\n// from displaying everything to hiding the ToC. We accomodate for this by\n// adding a bit of padding to the TOC drawer, disabling the horizontal\n// scrollbar and allowing the scrollbars to cover the padding.\n// https://www.456bereastreet.com/archive/201301/media_query_width_and_vertical_scrollbars/\n// HACK: Always having the scrollbar visible, prevents certain browsers from\n// causing the content to stutter horizontally between taller-than-viewport and\n// not-taller-than-viewport pages.\nhtml\n  overflow-x: hidden\n  overflow-y: scroll\n\n:not(html):not(body)\n  // Override Firefox scrollbar style\n  scrollbar-width: thin\n  scrollbar-color: var(--color-foreground-border) transparent\n\n  // Override Chrome scrollbar styles\n  &::-webkit-scrollbar\n    width: 0.25rem\n    height: 0.25rem\n  &::-webkit-scrollbar-thumb\n    background-color: var(--color-foreground-border)\n    border-radius: 0.125rem\n\n//\n// Overalls\n//\nhtml,\nbody\n  height: 100%\n\n.page\n  display: flex\n  // fill the viewport for pages with little content.\n  min-height: 100%\n\n.mobile-header\n  width: 100%\n  height: var(--header-height)\n  background-color: var(--color-header-background)\n  color: var(--color-header-text)\n  border-bottom: 1px solid var(--color-header-border)\n\n  // Looks like sub-script/super-script have this, and we need this to\n  // be \"on top\" of those.\n  z-index: 10\n\n  // Add shadow when scrolled\n  &.scrolled\n    border-bottom: none\n    box-shadow: 0 0 0.2rem rgba(0, 0, 0, 0.1), 0 0.2rem 0.4rem rgba(0, 0, 0, 0.2)\n\n  // We don't show the header on large screens.\n  display: none\n\n.main\n  display: flex\n  flex: 1\n\n// Sidebar (left) also covers the entire left portion of screen.\n.sidebar-drawer\n  box-sizing: border-box\n\n  display: flex\n  justify-content: flex-end\n  // These next two lines took me two days to figure out.\n  width: calc((100% - #{$full-width}) / 2 + #{$sidebar-width})\n  min-width: $sidebar-width\n\n// Scroll-along sidebars\n.sidebar-container,\n.toc-drawer\n  box-sizing: border-box\n  width: $sidebar-width\n\n.toc-drawer\n  // See HACK described on top of this document\n  padding-right: 1rem\n\n.sidebar-sticky,\n.toc-sticky\n  position: sticky\n  top: 0\n  height: min(100%, 100vh)\n  height: 100vh\n\n  display: flex\n  flex-direction: column\n\n.sidebar-scroll,\n.toc-scroll\n  flex-shrink: 1\n\n  overflow: auto\n  scroll-behavior: smooth\n\n// Central items.\n.content\n  padding: 0 $content-padding\n  width: $content-width\n\n  display: flex\n  flex-direction: column\n  justify-content: space-between\n\n.icon\n  display: inline-block\n  height: 1rem\n  width: 1rem\n  svg\n    width: 100%\n    height: 100%\n\n//\n// Accommodate announcement banner\n//\n.announcement\n  height: var(--header-height)\n  display: flex\n  align-items: center\n  overflow-x: auto\n  & + .page\n    min-height: calc(100% - var(--header-height))\n\n.announcement-content\n  box-sizing: border-box\n  padding: 0.5rem\n  min-width: 100%\n  white-space: nowrap\n  text-align: center\n\n////////////////////////////////////////////////////////////////////////////////\n// Toggles for elements\n////////////////////////////////////////////////////////////////////////////////\n.toc-overlay-icon, .nav-overlay-icon\n  display: none\n  cursor: pointer\n\n  .icon\n    color: var(--color-foreground-secondary)\n    height: 1.25rem\n    width: 1.25rem\n\n.toc-header-icon, .nav-overlay-icon\n  // for when we set display: flex\n  justify-content: center\n  align-items: center\n\n.toc-content-icon\n  height: 1.5rem\n  width: 1.5rem\n  margin-top: 1.5rem\n  float: right\n\n.sidebar-toggle\n  position: absolute\n  display: none\n// <debugging things>\n.sidebar-toggle[name=\"__toc\"]\n  left: 20px\n.sidebar-toggle:checked\n  left: 40px\n// </debugging things>\n\n.overlay\n  position: fixed\n  top: 0\n  width: 0\n  height: 0\n\n  transition: width 0ms, height 0ms, opacity 250ms ease-out\n\n  opacity: 0\n  background-color: rgba(0, 0, 0, 0.54)\n.sidebar-overlay\n  z-index: 20\n.toc-overlay\n  z-index: 40\n\n// Keep things on top and smooth.\n.sidebar-drawer\n  z-index: 30\n  transition: left 250ms ease-in-out\n.toc-drawer\n  z-index: 50\n  transition: right 250ms ease-in-out\n\n// Show the Sidebar\n#__navigation:checked\n  & ~ .sidebar-overlay\n    width: 100%\n    height: 100%\n    opacity: 1\n  & ~ .page\n    .sidebar-drawer\n      top: 0\n      left: 0\n      // Show the toc sidebar\n#__toc:checked\n  & ~ .toc-overlay\n    width: 100%\n    height: 100%\n    opacity: 1\n  & ~ .page\n    .toc-drawer\n      top: 0\n      right: 0\n\n////////////////////////////////////////////////////////////////////////////////\n// Responsive layouting\n////////////////////////////////////////////////////////////////////////////////\n// Make things a bit bigger on bigger screens.\n@media (min-width: $full-width + $sidebar-width)\n  html\n    font-size: 110%\n\n@media (max-width: $full-width)\n  // Collapse \"toc\" into the icon.\n  .toc-content-icon\n    display: flex\n  .toc-drawer\n    position: fixed\n    height: 100vh\n    top: 0\n    right: -$sidebar-width\n    border-left: 1px solid var(--color-background-muted)\n  .toc-tree\n    border-left: none\n    font-size: var(--toc-font-size--mobile)\n\n  // Accomodate for a changed content width.\n  .sidebar-drawer\n    width: calc((100% - #{$full-width - $sidebar-width}) / 2 + #{$sidebar-width})\n\n@media (max-width: $full-width - $sidebar-width)\n  // Collapse \"navigation\".\n  .nav-overlay-icon\n    display: flex\n  .sidebar-drawer\n    position: fixed\n    height: 100vh\n    width: $sidebar-width\n\n    top: 0\n    left: -$sidebar-width\n\n  // Swap which toc icon is used.\n  .toc-header-icon\n    display: flex\n  .toc-content-icon\n    display: none\n\n  // Show the header.\n  .mobile-header\n    position: sticky\n    top: 0\n    display: flex\n    justify-content: space-between\n    align-items: center\n\n    .header-left,\n    .header-right\n      display: flex\n      height: var(--header-height)\n      width: var(--header-height)\n      label\n        height: 100%\n        width: 100%\n\n  // Add a scroll margin for the content\n  :target\n    scroll-margin-top: var(--header-height)\n\n  // Center the page, and accommodate for the header.\n  .page\n    flex-direction: column\n    justify-content: center\n  .content\n    margin-left: auto\n    margin-right: auto\n\n@media (max-width: $content-width + 2* $content-padding)\n  // Content should respect window limits.\n  .content\n    width: 100%\n    overflow-x: auto\n\n@media (max-width: $content-width)\n  .content\n    padding: 0 $content-padding--small\n    // Don't float sidebars to the right.\n  article div.sidebar\n    float: none\n    width: 100%\n    margin: 1rem 0\n","// Definitely inspired by mkdocs-material.\n.admonition\n  margin: 1rem auto\n  padding: 0 0.5rem 0.5rem 0.5rem\n\n  background: var(--color-admonition-background)\n\n  border-radius: 0.2rem\n  border-left: 0.2rem solid var(--color-admonition-title)\n  box-shadow: 0 0.2rem 0.5rem rgba(0, 0, 0, 0.05), 0 0 0.0625rem rgba(0, 0, 0, 0.1)\n\n  font-size: var(--admonition-font-size)\n\n  overflow: hidden\n  page-break-inside: avoid\n\n  // First element should have no margin, since the title has it.\n  > :nth-child(2)\n    margin-top: 0\n\n  // Last item should have no margin, since we'll control that w/ padding\n  > :last-child\n    margin-bottom: 0\n\n\n  // Defaults for all admonitions\n  p.admonition-title\n    position: relative\n    margin: 0 -0.5rem 0.5rem\n    padding: 0.5rem 0.5rem 0.5rem 2rem\n\n    font-weight: 500\n    font-size: var(--admonition-title-font-size)\n    background-color: var(--color-admonition-title-background)\n\n    line-height: 1.3\n\n    // Our fancy icon\n    &::before\n      content: \"\"\n      position: absolute\n      left: 0.5rem\n      width: 1rem\n      height: 1rem\n      // color: var(--color-admonition-title)\n      background-color: var(--color-admonition-title)\n\n      mask-image: var(--icon-admonition-default)\n      mask-repeat: no-repeat\n\n  //\n  // Variants\n  //\n  @each $type, $value in $admonitions\n    &.#{$type}\n      border-left-color: var(--color-admonition-title--#{$type})\n      > .admonition-title\n        background-color: var(--color-admonition-title-background--#{$type})\n        &::before\n          background-color: var(--color-admonition-title--#{$type})\n          mask-image: var(--icon-#{nth($value, 2)})\n\n.admonition-todo > .admonition-title\n  text-transform: uppercase\n","// This file stylizes the API documentation (stuff generated by autodoc). It's\n// deeply nested due to how autodoc structures the HTML without enough classes\n// to select the relevant items.\n\n// API docs!\ndl.py, dl.cpp, dl.c, dl.js\n  // Tweak the spacing of all the things!\n  dd\n    margin-left: 2rem\n    > :first-child\n      margin-top: 0.125rem\n    > :last-child\n      margin-bottom: 1.25rem\n\n  // This is used for the arguments\n  .field-list\n    margin-bottom: 0.75rem\n\n    // \"Headings\" (like \"Parameters\" and \"Return\")\n    dt\n      text-transform: uppercase\n      font-size: var(--font-size--small)\n\n    dd:empty\n      margin-bottom: 0.5rem\n    dd > ul\n      margin-left: -1.2rem\n      > li\n        > p:nth-child(2)\n          margin-top: 0\n        // When the last-empty-paragraph follows a paragraph, it doesn't need\n        // to augument the existing spacing.\n        > p + p:last-child:empty\n          margin-top: 0\n          margin-bottom: 0\n\n  // Colorize the elements\n  > dt\n    color: var(--color-api-overall)\n    &:target\n      background-color: var(--color-api-highlight-on-target)\n\ndl.class,\ndl.function,\ndl.method,\ndl.enum,\ndl.enum-class,\ndl.enum-struct,\ndl.type,\ndl.exception\n  > dt\n    padding-left: 3em\n    text-indent: -3em\n    .property\n      color: var(--color-api-keyword)\n      padding-right: 0.25rem\n\n.sig-name\n  font-weight: bold\n  color: var(--color-api-name)\n.sig-prename\n  color: var(--color-api-pre-name)\n.sig-paren\n  color: var(--color-api-paren)\n.sig-param\n  font-style: normal\n\n.versionmodified\n  font-style: italic\ndiv.versionadded, div.versionchanged, div.deprecated\n  p\n    margin-top: 0.125rem\n    margin-bottom: 0.125rem\n\n.viewcode-link, .viewcode-back\n  float: right\n  font-size: var(--font-size--small)\n","// Captions\narticle p.caption,\ntable > caption,\n.code-block-caption\n  font-size: var(--font-size--small)\n  text-align: center\n\n// Caption above a TOCTree\n.toctree-wrapper.compound\n  .caption\n    font-size: var(--font-size--small)\n    text-transform: uppercase\n\n    text-align: initial\n    margin-bottom: 0\n\n  > ul\n    margin-top: 0\n    margin-bottom: 0\n","// Inline code\ncode.literal\n  background: var(--color-inline-code-background)\n  border-radius: 0.2em\n  // Make the font smaller, and use padding to recover.\n  font-size: var(--font-size--small--2)\n  padding: 0.1em 0.2em\n\n// Code and Literal Blocks\n$code-spacing-vertical: 0.625rem\n$code-spacing-horizontal: 0.875rem\n\narticle\n  // Wraps every literal block + line numbers.\n  div[class*=\" highlight-\"],\n  div[class^=\"highlight-\"]\n    margin: 1em 0\n    display: flex\n\npre\n  margin: 0\n  padding: 0\n\n  // Needed to have more specificity than pygments' \"pre\" selector. :(\n  article &\n    line-height: 1.5\n\n  &.literal-block,\n  .highlight &\n    font-size: var(--code-font-size)\n    padding: $code-spacing-vertical $code-spacing-horizontal\n    overflow: auto\n\n  // Make it look like all the other blocks.\n  &.literal-block\n    margin-top: 1rem\n    margin-bottom: 1rem\n\n    border-radius: 0.2rem\n    background-color: var(--color-code-background)\n    color: var(--color-code-foreground)\n\n// All code is always contained in a pre\n.highlight\n  width: 100%\n  border-radius: 0.2rem\n\n// Added when there's line numbers associated with a literal block.\n.highlighttable\n  width: 100%\n  display: block\n  tbody\n    display: block\n\n  tr\n    display: flex\n\n  // Line numbers\n  td.linenos\n    background-color: var(--color-code-background)\n    color: var(--color-code-foreground)\n    padding: $code-spacing-vertical $code-spacing-horizontal\n    padding-right: 0\n    border-top-left-radius: 0.2rem\n    border-bottom-left-radius: 0.2rem\n\n  .linenodiv\n    font-size: var(--code-font-size)\n\n    padding-right: 0.5rem\n    box-shadow: -0.0625rem 0 var(--color-code-foreground) inset\n    opacity: 0.5 // I hate myself.\n\n  // Actual code\n  td.code\n    padding: 0\n    display: block\n    flex: 1\n    overflow: hidden\n\n    .highlight\n      border-top-left-radius: 0\n      border-bottom-left-radius: 0\n","// Inline Footnote Reference\n.footnote-reference\n  font-size: var(--font-size--small--4)\n  vertical-align: super\n\n// Definition list, listing the content of each note.\ndl.footnote\n  font-size: var(--font-size--small)\n  color: var(--color-foreground-secondary)\n\n  display: grid\n  grid-template-columns: max-content auto\n  dt\n    margin: 0\n    > .fn-backref\n      margin-left: 0.25rem\n\n    &:after\n      content: \":\"\n\n    .brackets\n      &:before\n        content: \"[\"\n      &:after\n        content: \"]\"\n","//\n// Figures\n//\nimg\n  box-sizing: border-box\n  max-width: 100%\n  height: auto\n\narticle\n  .figure\n    border-radius: 0.2rem\n\n    padding: 0.5rem\n    :last-child\n      margin-bottom: 0\n\n  .align-left\n    float: left\n    clear: left\n    margin: 0 1rem 1rem\n\n  .align-right\n    float: right\n    clear: right\n    margin: 0 1rem 1rem\n\n  .align-center\n    text-align: center\n    margin-left: auto\n    margin-right: auto\n\n  .figure.align-default,\n  .legend .align-default\n    display: block\n    @extend .align-center\n",".genindex-jumpbox\n  border-top: 1px solid var(--color-background-border)\n  border-bottom: 1px solid var(--color-background-border)\n  padding: 0.25rem\n\n.genindex-section\n  h2\n    margin-top: 0.75rem\n    margin-bottom: 0.5rem\n  ul\n    margin-top: 0\n    margin-bottom: 0\n","ul,\nol\n  padding-left: 1.2rem\n\n  // Space lists out like paragraphs\n  margin-top: 1rem\n  margin-bottom: 1rem\n  // reduce margins within li.\n  li\n    > p:first-child\n      margin-top: 0.25rem\n      margin-bottom: 0.25rem\n\n    > p:last-child\n      margin-top: 0.25rem\n\n    > ul,\n    > ol\n      margin-top: 0.5rem\n      margin-bottom: 0.5rem\n\n// Don't space lists out when they're \"simple\" or in a `.. toctree::`\n.simple,\n.toctree-wrapper\n  li\n    > ul,\n    > ol\n      margin-top: 0\n      margin-bottom: 0\n\n// Definition Lists\n.field-list,\n.option-list,\ndl:not([class]),\ndl.simple,\ndl.footnote,\ndl.glossary\n  dt\n    font-weight: 500\n    margin-top: 0.25rem\n    + dt\n      margin-top: 0\n\n    .classifier::before\n      content: \":\"\n      margin-left: 0.2rem\n      margin-right: 0.2rem\n\n  dd\n    > p:first-child,\n    ul\n      margin-top: 0.125rem\n\n    ul\n      margin-bottom: 0.125rem\n",".math-wrapper\n  width: 100%\n  overflow-x: auto\n","// Abbreviations\nabbr[title]\n  cursor: help\n\n// Keyboard / Mouse \"instructions\"\nkbd:not(.compound)\n  margin: 0 0.2rem\n  padding: 0 0.2rem\n  border-radius: 0.2rem\n  border: 1px solid var(--color-foreground-border)\n  color: var(--color-foreground-primary)\n  vertical-align: text-bottom\n\n  font-size: var(--font-size--small--3)\n  display: inline-block\n\n  box-shadow: 0 0.0625rem 0 rgba(0, 0, 0, 0.2), inset 0 0 0 0.125rem var(--color-background-primary)\n\n  background-color: var(--color-background-secondary)\n\n// Blockquote\nblockquote\n  border-left: 1px solid var(--color-foreground-border)\n  font-style: italic\n  margin-left: 0.5rem\n  margin-right: 0.5rem\n  padding: 0.5rem 1rem\n\n// Center align embedded-in-text images\n.reference img\n  vertical-align: middle\n","// Adapted from Sphinx-RTD-theme's corresponding CSS\n// https://github.com/readthedocs/sphinx_rtd_theme/blob/1a32899b/src/sass/_theme_rst.sass#L201\nh1,\nh2,\nh3,\nh4,\nh5,\nh6,\ndl dt,\np.caption,\ntable > caption,\n.code-block-caption\n  > .headerlink\n    font-weight: 100\n    margin-left: 0.5rem\n    visibility: hidden\n    text-decoration: none\n\n  &:hover > .headerlink\n    visibility: visible\n\nh1,\nh2,\nh3,\nh4,\nh5,\nh6\n  :target > &:first-child > .headerlink\n    visibility: visible\n","p.rubric\n  text-transform: uppercase\n  font-size: var(--font-size--small)\n","article .sidebar\n  float: right\n  clear: right\n  width: 30%\n\n  margin-left: 1rem\n  margin-right: 0\n\n  border-radius: 0.2rem\n  background-color: var(--color-background-secondary)\n  border: var(--color-background-border) 1px solid\n\n  > *\n    padding-left: 1rem\n    padding-right: 1rem\n\n  .sidebar-title\n    margin: 0\n    padding: 0.5rem 1rem\n    border-bottom: var(--color-background-border) 1px solid\n\n    font-weight: 500\n\n// TODO: subtitle\n// TODO: dedicated variables?\n",".table-wrapper\n  width: 100%\n  overflow-x: auto\n  margin-top: 1rem\n  margin-bottom: 0.5rem\n  padding: 0.2rem 0.2rem 0.75rem\n\ntable.docutils\n  border-radius: 0.2rem\n  border-spacing: 0\n  border-collapse: collapse\n\n  box-shadow: 0 0.2rem 0.5rem rgba(0, 0, 0, 0.05), 0 0 0.0625rem rgba(0, 0, 0, 0.1)\n\n  th\n    background: var(--color-background-secondary)\n\n  td,\n  th\n    // Space things out properly\n    padding: 0 0.25rem\n    p\n      margin: 0.25rem\n\n    // Get the borders looking just-right.\n    border-left: 1px solid var(--color-background-border)\n    border-right: 1px solid var(--color-background-border)\n    border-bottom: 1px solid var(--color-background-border)\n\n    &:first-child\n      border-left: none\n    &:last-child\n      border-right: none\n",".guilabel\n  background-color: var(--color-guilabel-background)\n  border: 1px solid var(--color-guilabel-border)\n  color: var(--color-guilabel-text)\n\n  padding: 0 0.3em\n  border-radius: 0.5em\n  font-size: 0.9em\n","// This file contains the styles used for stylizing the footer that's shown\n// below the content.\n\nfooter\n  font-size: var(--font-size--small)\n  display: flex\n  flex-direction: column\n\n  margin-top: 2rem\n\n// Bottom of page information\n.related-information\n  margin-top: 1rem\n\n  padding: 0.75rem\n  padding-bottom: 1rem\n\n  border-top: 1px solid var(--color-background-border)\n\n  line-height: 1.5\n  color: var(--color-foreground-secondary)\n\n// Next/Prev page information\n.related-pages\n  a\n    display: flex\n    align-items: center\n\n    text-decoration: none\n    &:hover .page-info .title\n      text-decoration: underline\n      color: var(--color-link)\n      text-decoration-color: var(--color-link-underline)\n\n    svg,\n    svg > use\n      flex-shrink: 0\n\n      color: var(--color-foreground-border)\n\n      width: 0.75rem\n      height: 0.75rem\n      margin: 0 0.5rem\n\n    &.next-page\n      max-width: 50%\n\n      float: right\n      clear: right\n      text-align: right\n\n    &.prev-page\n      max-width: 50%\n\n      float: left\n      clear: left\n\n      svg\n        transform: rotate(180deg)\n\n.page-info\n  display: flex\n  flex-direction: column\n\n  .next-page &\n    align-items: flex-end\n\n  .context\n    display: flex\n    align-items: center\n\n    padding-bottom: 0.1rem\n\n    color: var(--color-foreground-muted)\n    font-size: var(--font-size--small)\n    text-decoration: none\n","//\n// Search Page Listing\n//\nul.search\n  padding-left: 0\n  list-style: none\n\n  li\n    padding: 1rem 0\n    border-bottom: 1px solid var(--color-background-border)\n\n//\n// Highlighted by links in search page\n//\n.highlighted\n  background-color: var(--color-highlighted-background)\n  color: var(--color-highlighted-text)\n","// This file contains the styles for the contents of the left sidebar, which\n// contains the navigation tree, logo, search etc.\n\n////////////////////////////////////////////////////////////////////////////////\n// Brand on top of the scrollable tree.\n////////////////////////////////////////////////////////////////////////////////\n.sidebar-brand\n  display: flex\n  flex-direction: column\n  flex-shrink: 0\n\n  padding: var(--sidebar-item-spacing-vertical) var(--sidebar-item-spacing-horizontal)\n  text-decoration: none\n\n.sidebar-brand-text\n  overflow-wrap: break-word\n  margin: var(--sidebar-item-spacing-vertical) 0\n  font-size: 1.5rem\n\n.sidebar-logo-container\n  margin: var(--sidebar-item-spacing-vertical) 0\n\n.sidebar-logo\n  margin: 0 auto\n  display: block\n  max-width: 100%\n\n////////////////////////////////////////////////////////////////////////////////\n// Search\n////////////////////////////////////////////////////////////////////////////////\n.sidebar-search-container\n  display: flex\n  align-items: center\n  margin-top: var(--sidebar-search-space-above)\n\n  position: relative\n  &::before\n    content: \"\"\n    position: absolute\n    left: var(--sidebar-item-spacing-horizontal)\n    width: var(--sidebar-search-icon-size)\n    height: var(--sidebar-search-icon-size)\n\n.sidebar-search\n  box-sizing: border-box\n\n  padding-top: var(--sidebar-search-input-spacing-vertical)\n  padding-bottom: var(--sidebar-search-input-spacing-vertical)\n  padding-right: var(--sidebar-search-input-spacing-horizontal)\n  padding-left: calc(var(--sidebar-item-spacing-horizontal) + var(--sidebar-search-input-spacing-horizontal) + var(--sidebar-search-icon-size))\n\n  width: 100%\n\n  color: var(--color-sidebar-search-foreground)\n  background: transparent\n  z-index: 10\n\n  &:focus\n    outline: none\n\n  &::placeholder\n    font-size: var(--sidebar-search-input-font-size)\n\n////////////////////////////////////////////////////////////////////////////////\n// Structure/Skeleton of the navigation tree (left)\n////////////////////////////////////////////////////////////////////////////////\n.sidebar-tree\n  font-size: var(--sidebar-item-font-size)\n  margin-top: var(--sidebar-tree-space-above)\n  margin-bottom: var(--sidebar-item-spacing-vertical)\n\n  ul\n    padding: 0\n    margin-top: 0\n    margin-bottom: 0\n\n    display: flex\n    flex-direction: column\n\n    list-style: none\n\n  li\n    position: relative\n    margin: 0\n\n    > ul\n      margin-left: var(--sidebar-item-spacing-horizontal)\n\n  .reference\n    box-sizing: border-box\n    // Fill the parent.\n    display: inline-block\n    line-height: var(--sidebar-item-line-height)\n\n    height: 100%\n    width: 100%\n\n    padding: var(--sidebar-item-spacing-vertical) var(--sidebar-item-spacing-horizontal)\n\n    // Add a nice little \"external-link\" arrow here.\n    &.external::after\n      content: url('data:image/svg+xml,<svg width=\"12\" height=\"12\" xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 24 24\" stroke-width=\"1.5\" stroke=\"%23607D8B\" fill=\"none\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><path stroke=\"none\" d=\"M0 0h24v24H0z\"/><path d=\"M11 7h-5a2 2 0 0 0 -2 2v9a2 2 0 0 0 2 2h9a2 2 0 0 0 2 -2v-5\" /><line x1=\"10\" y1=\"14\" x2=\"20\" y2=\"4\" /><polyline points=\"15 4 20 4 20 9\" /></svg>')\n      margin: 0 0.25rem\n      vertical-align: middle\n\n  // Make the current page reference bold.\n  .current-page > .reference\n    font-weight: bold\n\n  label\n    position: absolute\n    top: 0\n    right: 0\n    height: var(--sidebar-item-height)\n    width: var(--sidebar-expander-width)\n\n    cursor: pointer\n\n    display: flex\n    justify-content: center\n    align-items: center\n\n  .caption\n    font-size: var(--sidebar-caption-font-size)\n\n    font-weight: bold\n    text-transform: uppercase\n\n    margin: var(--sidebar-caption-space-above) 0 0 0\n\n    padding: var(--sidebar-item-spacing-vertical) var(--sidebar-item-spacing-horizontal)\n\n  // If it has children, add a bit more padding to wrap the content to avoid\n  // overlapping with the <label>\n  li.has-children\n    > .reference\n      padding-right: var(--sidebar-expander-width)\n\n.toctree-checkbox\n  position: absolute\n  display: none\n\n////////////////////////////////////////////////////////////////////////////////\n// Togglable expand/collapse\n////////////////////////////////////////////////////////////////////////////////\n.toctree-checkbox\n  ~ ul\n    display: none\n\n  ~ label .icon svg\n    transform: rotate(90deg)\n\n.toctree-checkbox:checked\n  ~ ul\n    display: block\n\n  ~ label .icon svg\n    transform: rotate(-90deg)\n","// This file contains the styles for the contents of the right sidebar, which\n// contains the table of contents for the current page.\n.toc-title-container\n  padding: var(--toc-title-padding)\n  padding-top: var(--toc-spacing-vertical)\n\n.toc-title\n  font-size: var(--toc-title-font-size)\n  padding-left: var(--toc-spacing-horizontal)\n  text-transform: uppercase\n\n// If the ToC is not present, hide these elements coz they're not relevant.\n.no-toc\n  display: none\n\n.toc-tree-container\n  padding-bottom: var(--toc-spacing-vertical)\n\n.toc-tree\n  font-size: var(--toc-font-size)\n  line-height: 1.3\n\n  padding-left: calc(var(--toc-spacing-horizontal) - var(--toc-item-spacing-horizontal))\n\n  // Hide the first \"top level\" bullet.\n  > ul > li:first-child\n    padding-top: 0\n    & > ul\n      padding-left: 0\n    & > a\n      display: none\n\n  ul\n    list-style-type: none\n    margin-top: 0\n    margin-bottom: 0\n    padding-left: var(--toc-item-spacing-horizontal)\n  li\n    padding-top: var(--toc-item-spacing-vertical)\n\n    .reference\n      word-break: break-word\n      text-decoration: none\n\n    &.scroll-current >.reference\n      font-weight: bold\n\n.toc-scroll\n  max-height: 100vh\n  overflow-y: scroll\n\n// Be very annoying when someone includes the table of contents\n.contents:not(.this-will-duplicate-information-and-it-is-still-useful-here)\n  color: var(--color-problematic)\n  background: rgba(255, 0, 0, 0.25)\n  &::before\n    content: \"ERROR: Adding a table of contents in Furo-based documentation is unnecessary, and does not work well with existing styling. Add a 'this-will-duplicate-information-and-it-is-still-useful-here' class, if you want an escape hatch.\"\n"]}
\ No newline at end of file
diff --git a/docs/api/sphinx/furo/theme/furo/theme.conf b/docs/api/sphinx/furo/theme/furo/theme.conf
new file mode 100644
index 00000000..d34d587c
--- /dev/null
+++ b/docs/api/sphinx/furo/theme/furo/theme.conf
@@ -0,0 +1,21 @@
+[theme]
+inherit = basic
+stylesheet = styles/furo.css
+pygments_style = default
+# sidebar-start
+sidebars =
+  sidebar/brand.html,
+  #sidebar/search.html,
+  sidebar/scroll-start.html,
+  sidebar/navigation.html,
+  sidebar/ethical-ads.html,
+  sidebar/scroll-end.html
+# sidebar-end
+
+[options]
+announcement =
+dark_css_variables =
+dark_logo =
+light_css_variables =
+light_logo =
+sidebar_hide_name =
diff --git a/docs/api/sphinx/index.rst b/docs/api/sphinx/index.rst
new file mode 100644
index 00000000..6939f561
--- /dev/null
+++ b/docs/api/sphinx/index.rst
@@ -0,0 +1,13 @@
+OrbbecSdk v1.2.8
+================
+
+.. toctree::
+   :maxdepth: 3
+
+   summary/index
+   env/index
+   sample/index
+   knowledge/index
+   support/index
+   reference/index
+   orbbecviewer/index
diff --git a/docs/api/sphinx/knowledge/OrbbecSDK_Concept.rst b/docs/api/sphinx/knowledge/OrbbecSDK_Concept.rst
new file mode 100644
index 00000000..6373132e
--- /dev/null
+++ b/docs/api/sphinx/knowledge/OrbbecSDK_Concept.rst
@@ -0,0 +1,76 @@
+基础概念
+========
+
+.. _3d传感摄像头深度相机:
+
+3D传感摄像头/深度相机
+---------------------
+
+通过不同原理（主流：结构光、iToF、双目）进行测量，通过处理这些测量值可以生成深度图。 深度图是图像每个像素的一组
+Z 坐标值，单位为毫米。
+
+陀螺仪和加速度传感器（IMU）
+---------------------------
+
+测量物体三轴姿态角及加速度的装置，一般包括三轴陀螺仪及三轴加速度计。
+
+坐标系
+------
+
+.. _2d坐标系:
+
+2D坐标系
+~~~~~~~~
+
+深度相机和彩色相机与单独的 2D 坐标系相关联。 [x,y]
+坐标以像素为单位，其中，\ *x* 的范围为 0 到宽度-1，\ *y* 的范围为 0
+到高度-1。 宽度和高度取决于所选的深度相机和彩色相机工作模式。像素坐标
+``[0,0]`` 对应于图像的左上角像素。  \ |image.png|
+
+相机内参
+~~~~~~~~
+
+相机的数据流的二维和三维坐标系之间的关系是由其内在的相机参数描述的。每种设备的都不同，图像可以是任意大小的--宽度和高度字段描述图像中行和列的数目。基本描述如下：
+
+1.图像的视场分别可以改变fx和fy字段描述图像的焦距，是像素宽度和高度的倍数，图像的像素不一定是正方形的，fx和fy允许不同(虽然它们通常是相近的)。
+
+2.描述了主点(投影中心)的像素坐标\ |image1|\ 。
+
+相机外参
+~~~~~~~~
+
+在一般情况下，不同相机的数据流的三维坐标系是不同的。例如，由一个或多个红外相机产生的深度数据流，而彩色流则由单独的彩色相机提供。不同数据流的三维坐标系之间的关系用它们的外部参数来描述。基本的
+描述如下：
+
+1.相机可能位于不同的位置，但固定在同一物理装置上。位移字段描述相机物理位置之间的三维位移转换 [x,y,z]，以米为单位。
+
+2.相机可能有不同的方向，但固定在同一物理装置上。旋转字段包含一个3x3正交旋转矩阵，描述相机之间的物理方向。
+
+畸变模型
+~~~~~~~~
+
+透镜的畸变主要分为径向畸变和切向畸变。
+
+径向畸变：是由于透镜形状的制造工艺导致，且越向透镜边缘移动径向畸变越严重，实际情况中我们常用r=0处的泰勒级数展开的前几项来近似描述径向畸变.
+
+切向畸变：是由于透镜和CMOS或者CCD的安装位置误差导致，切向畸变需要两个额外的畸变参数来描述。径向畸变后和切向畸变后的归一化坐标，整理后共需要5个畸变参数\ |image2|\ 。
+
+点云
+----
+
+从深度图像生成的点云是深度流的三维坐标系中的一组点。也可以从深度和彩色创建点云和相应的纹理映射点云。
+
+帧对齐
+------
+
+通常在处理彩色和深度图像时，需要将每个像素从一个图像映射到另一个图像。要做到图像对齐，就生成一组具有相同分辨率的帧，并且经过处理达到可以简单地映射像素。
+我们的对齐方式分为硬件对齐和软件对齐，一般而言，硬件对齐性能上会高于软件对齐。
+
+帧同步
+------
+
+不同的数据流，因为数据采集不同步、系统处理等原因，会造成数据帧不同步。通过帧数据的时间戳及相应的数据处理，可以尽可能保证两类不同的数据之间的时间差值在一定可控范围，这就是帧同步功能。但需要注意的是，系统往往无法保证严格的帧同步，即两帧之间的时间差值为0。
+
+.. |image.png| image:: https://cdn.nlark.com/yuque/0/2020/png/897878/1591952635956-a473e062-bfff-430c-93e3-2d723efcf639.png#crop=0&crop=0&crop=1&crop=1&height=358&id=ywgOp&margin=%5Bobject%20Object%5D&name=image.png&originHeight=715&originWidth=861&originalType=binary&ratio=1&rotation=0&showTitle=false&size=19687&status=done&style=none&title=&width=430.5
+.. |image1| image:: https://cdn.nlark.com/yuque/__latex/3f7a41a219060c8919c2ba0c99baa649.svg#card=math&code=u_0%2Cv_0&height=14&id=HeNYC
+.. |image2| image:: https://cdn.nlark.com/yuque/__latex/aeefaabbf1a8624469e2afe62eae068c.svg#card=math&code=%EF%BC%88k_1%2C%20k_2%2C%20k_3%2C%20p_1%2C%20p_2%EF%BC%89&height=24&id=ro1VU
diff --git a/docs/api/sphinx/knowledge/OrbbecSDK_ExamplesCMakeEnv.rst b/docs/api/sphinx/knowledge/OrbbecSDK_ExamplesCMakeEnv.rst
new file mode 100644
index 00000000..d9e98e47
--- /dev/null
+++ b/docs/api/sphinx/knowledge/OrbbecSDK_ExamplesCMakeEnv.rst
@@ -0,0 +1,200 @@
+CMake配置说明
+=============
+
+Examples CMake工程结构
+----------------------
+
+::
+
+   Examples
+   │
+   ├─c
+   │  ├─CMakeLists.txt
+   │  ├─Sample-ColorViewer
+   │  │     └── CMakeLists.txt
+   │  ├─Sample-DepthViewer
+   │  │     └── CMakeLists.txt
+   │  ├─Sample-HelloOrbbec
+   │  │     └── CMakeLists.txt
+   │  ├─Sample-HotPlugin
+   │  │     └── CMakeLists.txt
+   │  ├─Sample-InfraredViewer
+   │  │     └── CMakeLists.txt
+   │  ├─Sample-PointCloud
+   │  │     └── CMakeLists.txt
+   │  └─Sample-SensorControl
+   │        └── CMakeLists.txt
+   └─cpp
+       ├─CMakeLists.txt
+       ├─Sample-ColorViewer
+       │     └── CMakeLists.txt
+       ├─Sample-DepthViewer
+       │     └── CMakeLists.txt
+       ├─Sample-HelloOrbbec
+       │     └── CMakeLists.txt
+       ├─Sample-HotPlugin
+       │     └── CMakeLists.txt
+       ├─Sample-ImuReader
+       │     └── CMakeLists.txt
+       ├─Sample-InfraredViewer
+       │     └── CMakeLists.txt
+       ├─Sample-MultiDevice
+       │     └── CMakeLists.txt
+       ├─Sample-PointCloud
+       │     └── CMakeLists.txt
+       ├─Sample-SaveToDisk
+       │     └── CMakeLists.txt
+       ├─Sample-SensorControl
+       │     └── CMakeLists.txt
+       ├─Sample-SyncAlignViewer
+       |     └── CMakeLists.txt 
+       ├─Sample-Recorder
+       |     └── CMakeLists.txt 
+       └─Sample-Playback
+             └── CMakeLists.txt 
+             
+
+如上树型结构，整个CMake工程结构可分为三层，与程序目录结构相同。每一层都会有一个CMakeLists.txt文件，第一层根目录中CMakeLists.txt是主CMakeLists.txt。第二层的CMakeLists.txt被放在两个不同的目录下，分别对应C版本和C++版本的Example。第三层的CMakeLists.txt是放在各自Example目录下。
+
+.. _主cmakeliststxt说明:
+
+主CMakeLists.txt说明
+--------------------
+
+下面从根目录的CMakeLists.txt开始介绍：
+
+1. 设置需要使用CMake的最低版本为3.1.15
+
+::
+
+   cmake_minimum_required(VERSION 3.1.15)
+
+2. 生成一个名为OrbbecSDK-Examples工程，使用C++和C语言
+
+::
+
+   project(OrbbecSDK-Examples LANGUAGES CXX C)
+
+3. 使用标准的C++ 11进行编译
+
+::
+
+   set(CMAKE_CXX_STANDARD 11)
+   set(CMAKE_CXX_STANDARD_REQUIRED True)
+
+4. 设置SDK的头文件及库路径
+
+::
+
+   set(OBSensor_DIR ${CMAKE_SOURCE_DIR}/../SDK)
+   set(OBSensor_LIBRARY_DIRS ${OBSensor_ROOT_DIR}/lib/${CMAKE_BUILD_TYPE})
+   set(OBSensor_INCLUDE_DIR ${OBSensor_ROOT_DIR}/include)
+   include_directories(${OBSensor_INCLUDE_DIR})
+   link_directories(${OBSensor_LIBRARY_DIRS})
+
+5. 查找opencv库
+
+::
+
+   # set(OpenCV_DIR "your/path/to/opencv")  # 可通过该命令指定OpenCV_DIR模块查找路径
+   find_package(OpenCV QUIET)
+   if(${OpenCV_FOUND})
+       include_directories(${OpenCV_INCLUDE_DIRS})
+           link_directories(${OpenCV_LIBRARY_DIRS})
+   ENDIF(${OpenCV_FOUND})
+
+6. 设置ARCHIVE、LIBRARY、RUNTIME的输出目录，
+
+::
+
+   set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
+   set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
+   set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
+
+关于这三个变量的说明参考：
+
+======= ========== ==========
+\       Windows    Unix
+======= ========== ==========
+RUNTIME .exe、.dll 可执行程序
+LIBRARY            .so
+ARCHIVE .a、.lib   .a
+======= ========== ==========
+
+7. 添加子工程目录
+
+::
+
+   add_subdirectory(c)
+   add_subdirectory(cpp)
+
+C语言版本Examples 主CMakeLists说明
+----------------------------------
+
+::
+
+   cmake_minimum_required(VERSION 3.1.15)
+
+   add_subdirectory(Sample-HelloOrbbec)
+   add_subdirectory(Sample-SensorControl)
+   add_subdirectory(Sample-HotPlugin)
+
+   # opencv required
+   IF(${OpenCV_FOUND})
+       add_subdirectory(Sample-ColorViewer)
+       add_subdirectory(Sample-DepthViewer)
+       add_subdirectory(Sample-InfraredViewer)
+       add_subdirectory(Sample-PointCloud)
+   ENDIF(${OpenCV_FOUND})
+
+这个文件比较简单，这里做一个简要说明。主要是根据是否有查找到opencv库及各example属性是否依赖opencv库决定是否将该example添加到工程。
+
+C语言版本Examples 子CMakeLists说明
+----------------------------------
+
+在各Example子目录下包含各自的CMakeLists.txt, 以Sample-HelloOrbbec为例:
+
+::
+
+   cmake_minimum_required(VERSION 3.1.15)
+   set(CMAKE_CXX_STANDARD 11)
+
+   project(Sample-HelloOrbbec)
+
+   add_executable(hello_orbbec HelloOrbbec.c)
+   target_link_libraries(hello_orbbec obsensor)
+
+内容比较简单，主要是指定将源文件HelloOrbbec.c生产可执行文件hello_orbbec（windows平台生成文件待.exe后缀），并指定连接obsensor库。
+
+C++版本Examples 主CMakeLists说明
+--------------------------------
+
+::
+
+   cmake_minimum_required(VERSION 3.1.15)
+
+   add_subdirectory(Sample-HelloOrbbec)
+   add_subdirectory(Sample-SensorControl)
+   add_subdirectory(Sample-ImuReader)
+
+   # opencv required
+   IF(${OpenCV_FOUND})
+       add_subdirectory(Sample-ColorViewer)
+       add_subdirectory(Sample-DepthViewer)
+       add_subdirectory(Sample-InfraredViewer)
+       add_subdirectory(Sample-SyncAlignViewer)
+       add_subdirectory(Sample-HotPlugin)
+       add_subdirectory(Sample-PointCloud)
+       add_subdirectory(Sample-MultiDevice)
+       add_subdirectory(Sample-SaveToDisk)
+       add_subdirectory(Sample-Recorder)
+       add_subdirectory(Sample-Playback)
+   ENDIF(${OpenCV_FOUND})
+
+C++版本Examples
+主CMakeLists.txt目标和内容和C语言版本基本一致，这里不再赘述。不同的是C++版本提供了更为丰富的例程。
+
+C++版本Examples 子CMakeLists说明
+--------------------------------
+
+与C语言版本基本一致，这里不再复述。
diff --git a/docs/api/sphinx/knowledge/index.rst b/docs/api/sphinx/knowledge/index.rst
new file mode 100644
index 00000000..2a93baf1
--- /dev/null
+++ b/docs/api/sphinx/knowledge/index.rst
@@ -0,0 +1,7 @@
+知识库
+=============
+
+.. toctree::
+
+   OrbbecSDK_Concept
+   OrbbecSDK_ExamplesCMakeEnv
diff --git a/docs/api/sphinx/orbbecviewer/OrbbecViewer_Usage.rst b/docs/api/sphinx/orbbecviewer/OrbbecViewer_Usage.rst
new file mode 100644
index 00000000..c4569412
--- /dev/null
+++ b/docs/api/sphinx/orbbecviewer/OrbbecViewer_Usage.rst
@@ -0,0 +1,659 @@
+介绍
+====
+
+OrbbecViewer是基于Orbbec
+SDK开发的示例工具，帮助开发者快速使用Orbbec的3D传感器产品。实现了 Orbbec
+3D传感器产品的特性功能，包括读取序列号、获取设备类型、相机参数、控制等功能。
+
+本文档对这些功能进行了描述并演示了基本使用的过程。
+
+OrbbecViewer工具概述
+====================
+
+目标用户
+--------
+
+OrbbecViewer工具专为最终用户/开发人员设计，用于使用Orbbec SDK 3D相机。
+
+支持设备及平台
+--------------
+
+=========== ============ =============
+**SDK版本** **产品列表** **固件版本**
+=========== ============ =============
+v1.0.2      Astra+       1.0.19
+v1.1.6      Astra+       1.0.19/1.0.20
+\           Femto        1.5.1
+v1.2.8      Astra+       1.0.20
+\           Femto        1.6.7
+=========== ============ =============
+
++--------------+--------------------------+--------------------------+
+| **操作系统** | **要求**                 | **描述**                 |
++==============+==========================+==========================+
+| Windows      | - Windows 10 的 2018 年  | vs的工程的生成依赖       |
+|              | 4 月（版本               | 安装vs版本和cmake版本，  |
+|              | 1803，操作系统内部版本   | 支持vs2015/vs2017/vs2019 |
+|              | 17134）发行版 (x64)      |                          |
+|              | 或更高版本- 4 GB 内存-   |                          |
+|              | USB2.0 及以上端口        |                          |
++--------------+--------------------------+--------------------------+
+| Android      | - Android 6/7/8/9/10     |                          |
++--------------+--------------------------+--------------------------+
+| Linux        | - Linux Ubuntu           | 支持GCC 7.5              |
+|              | 16.04/18.04/20.04 (x64)- |                          |
+|              | 4 GB 内存-               |                          |
+|              | USB2.0 及以上端口        |                          |
++--------------+--------------------------+--------------------------+
+
+OrbbecViewer工具的使用
+======================
+
+.. _31-软件主界面:
+
+3.1 软件主界面
+--------------
+
+如图所示，主界面用红框分隔标注了3个区域，作用分别是：
+
+======== ========== ===================================================
+**区域** **名称**   **功能**
+======== ========== ===================================================
+区域一   设备管理区 传感器列表、设备固件更新
+区域二   控制面板区 数据流开关及参数配置、图像采集功能控制、D2C功能控制
+区域三   图像预览区 传感器图像预览，帧率、时间戳等信息查看
+======== ========== ===================================================
+
+|image1.png|\ 其中，控制面板区左侧有六个按钮，最下方按钮\ |image2.png|\ 用于切换中英文；\ |3|\ 用于打开软件详情页面。\ |image4.png|\ 用于查看设备信息和固件升级；剩下两个按钮用于切换不同功能的控制面板TAB页，从上往下一次为“单相机模式”、“高级模式”。点击区域三下方Log信息处，会展示具体的日志信息。
+
+.. _32-数据流:
+
+3.2 数据流
+----------
+
+OrbbecViewer
+允许用户选择和配置深度、红外和彩色数据流。本节概述了用户可在工具中自定义的参数。用户完成配置后，必须单击顶部\ |image5.png|\ 按钮开始数据流传输（Astra+无惯性测试单元)。
+
+OrbbecViewer工具允许用户选择深度、红外和彩色数据流组合。用户可以通过从可用流列表中选中/取消选中以启用/禁用该流。查看器支持
+USB2.0 和 USB3.0，因此可用的配置参数会因 USB2.0/USB3.0
+功能而异。\ |image6.png|
+
+分辨率与帧率
+~~~~~~~~~~~~
+
+摄像机为用户提供了多种分辨率可供选择，以满足他们的解决方案需求。各路数据流都提供了多种可选的帧格式，已供用户自由选择合适的图像尺寸、图像格式和帧率组合。
+
+例如，深度流可以支持320x240和640x480两种分辨率，FPS帧率的区间范围为5到30。
+\ |image7.png|\ 
+
+彩色流可以支持640x480~1920x1080多种分辨率，FPS帧率的区间范围5到30不等，支持MJPG、RGB、I420、H265。对于彩色流的预览，MJPG、H264、H265是编码格式，需要先进行解码，解码通常耗时会比较大，会导致掉帧或渲染出“花屏”画面。在某些型号PC上，可通过硬件加速解码。
+\ |image8.png|\ 
+
+红外流可以支持320x240和640x480两种分辨率，FPS帧率5到30不等。
+\ |image9.png|\ 
+
+用户可根据实际情况选择最适合使用的分辨率。请注意，分辨率越高，精确度越高，但会增加计算强度。
+
+.. _33-设备信息:
+
+3.3 设备信息
+------------
+
+点击按钮“\ |image10.png|\ ”查看设备信息OrbbecViewer工具包含简单的设备信息，如固件版本、产品识别码、相机参数、温度等。\ |image11.png|
+
+.. _34-图像预览区:
+
+3.4 图像预览区
+--------------
+
+开流会默认显示平均帧率、时间搓、图像帧号等信息，点击右上角\ |image12.png|\ 来切换信息显示\关闭。点击\ |image13.png|\ 可以关闭流，但不从预览区中移除。点击\ |image14.png|\ 可以重新打开已经暂停且未从预览区移除的流。数据流关闭后，图像预览窗并不会随之关闭，需要用户点击图像预览窗右上角\ |image15.png|\ 。\ |Snipaste_2022-04-21_14-45-09.png|
+
+.. _35-控制面板区:
+
+3.5 控制面板区
+--------------
+
+.. _351-传感器和数据流:
+
+3.5.1 传感器和数据流
+~~~~~~~~~~~~~~~~~~~~
+
+获取相机名称、序列号及USB协议
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+设备上电并将USB与PC主机连接后，打开OrbbecViewer工具软件，软件会自动连接设备。某些设备可能初始化较长时间，请耐心等待设备连接成功。
+
+各流的参数配置项默认隐藏，可点击设备管理区四个按钮展开查看和设置具体配置项。\ |16|\ 
+
+连接成功后，控制面板区自动显示设备具体信息。\ |image17.png|
+
+深度流模块
+^^^^^^^^^^
+
+包括：镜像、软件滤波（范围模式：关闭、中等、长距离）、深度有效范围获取（MinDepthValue/MaxDepthValue）、曝光等功能。
+
+\ |image18.png|
+
+彩色流模块
+^^^^^^^^^^
+
+包括：镜像、翻转、对齐、曝光、白平衡、增益、亮度、锐度、饱和度、对比度、色调等功能。
+
+\ |image19.png|
+
+红外流板块
+^^^^^^^^^^
+
+包括镜像、曝光功能。
+
+\ |image20.png|
+
+设备数据管理
+^^^^^^^^^^^^^^^^^^^^
+
+用户可选择对应图像和捕获帧来进行录制，采集的帧默认保存在“OrbbecViewer/output”目录中。
+
+\ |image21.png|
+
+.. _36-d2c功能支持硬件d2c和软件d2c:
+
+3.6 D2C功能（支持硬件D2C和软件D2C）
+-----------------------------------
+
+在高级模式下的“D2C”功能，可控制实现深度流和彩色流同步功能：
+
+1.点击按钮\ |image22.png|\ 即可默认同步打开深度流和彩色流；
+
+2.可通过切换按钮\ |image23.png|\ 实现打开或关闭帧同步功能；
+
+3.点击按钮\ |image24.png|\ 可预览深度叠加到彩色的渲染显示效果；
+
+4.点击按钮\ |image25.png|\ 可打开或关闭深度和彩色帧同步采集（Femto特有）；
+
+5.录制的图片默认保存在“OrbbecViewer/output/RecordFile”目录中。
+
+\ |image26|
+
+.. _37-点云:
+
+3.7 点云
+--------
+
+点击\ |image26.png|\ 即可开启点云。
+
+可通过鼠标的滑轮控制点云的缩放，鼠标的移动来控制点云的移动。
+
+可选择导出深度点云（xyz）或RGBD点云（xyzrgb）并保存成ply格式文件，默认保存在“OrbbecViewer/output/PointCloud”目录中。
+
+\ |image27.png|
+
+.. _38-固件更新:
+
+3.8 固件更新
+------------
+
+在设备已连接状态，点击\ |28|\ 可进入固件更新页面。
+
+1. Femto设备固件包含系统固件和板载MCU固件，可在“类型”下拉框选择升级固件类型。
+2. 选择好固件类型后，在“固件”输入框输入现有更新的固件镜像文件（“.img”后缀），点击“升级”按钮开始更新。
+3. 设备固件更新采用A/B双分区方案，如更新意外失败，不会影响原固件运行，重新连接设备进行更新即可。设备更新时间比较长，且设备会自动重启一次，请留意提示信息并耐心等待。
+
+Astra+界面：
+
+\ |1650524827127_47E08781-CEC2-4d18-BC50-F8984C3F87C4.png|\ 
+
+Femto界面：
+
+\ |image29.png|
+
+.. _39-日志信息:
+
+3.9 日志信息
+------------
+
+默认情况下，日志信息区是折叠单条显示状态，可通过点击最右边按钮\ |image30.png|\ 展开查看完整log信息。展开后可通过点击按钮\ |image31.png|\ 清空log，通过点击按钮\ |image32.png|\ 恢复折叠单条显示状态。\ |Snipaste_2022-04-21_14-45-27.png|
+
+功能介绍
+========
+
+演示了主要API的使用。
+
+.. _41-获取序列号:
+
+4.1 获取序列号
+--------------
+
+|33|
+
+C++代码
+~~~~~~~
+
+.. code:: cpp
+
+   DeviceInfo deviceInfo = device->getDeviceInfo();
+   std::string serialNumber = deviceInfo.serialNumber();
+
+Android代码
+~~~~~~~~~~~
+
+.. code:: java
+
+   DeviceInfo deviceInfo = device.getInfo();
+   String serialNumber = deviceInfo.getSerialNumber();
+
+.. _42-获取设备名称:
+
+4.2 获取设备名称
+----------------
+
+|34|
+
+.. _c代码-1:
+
+C++代码
+~~~~~~~
+
+.. code:: cpp
+
+   std::shared_ptr< DeviceInfo > deviceInfo = device->getDeviceInfo();
+   std::string deviceName = deviceInfo->name();
+
+.. _android代码-1:
+
+Android代码
+~~~~~~~~~~~
+
+.. code:: java
+
+   DeviceInfo deviceInfo = device.getInfo();
+   String name = deviceInfo.getName();
+
+.. _43-获取相机参数:
+
+4.3 获取相机参数
+----------------
+
+|image38|
+
+.. _c代码-2:
+
+C++代码
+~~~~~~~
+
+.. code:: cpp
+
+   //获取深度相机内参
+   OBCameraIntrinsic colorCameraIntrinsic = device->getCameraIntrinsic(OB_SENSOR_DEPTH);
+   //获取彩色相机内参
+   OBCameraIntrinsic depthCameraIntrinsic = device->getCameraIntrinsic(OB_SENSOR_COLOR);
+   //获取深度相机畸变参数
+   OBCameraDistortion depthCameraDistortion = device->getCameraDistortion(OB_SENSOR_DEPTH);
+   //获取彩色相机畸变参数
+   OBCameraDistortion colorCameraDistortion = device->getCameraDistortion(OB_SENSOR_color);
+   //获取旋转矩阵
+   OBD2CTransform d2cTransform = device->getD2CTransform();
+
+.. _android代码-2:
+
+Android代码
+~~~~~~~~~~~
+
+.. code:: java
+
+   CameraParams object = new CameraParams();
+   boolean isSupport = device.isPropertySupported(DeviceProperty.CAMERA_PARA);
+   if (!isSupport) {
+       return;
+   }
+   device.getPropertyValueDataType(DeviceProperty.CAMERA_PARA, object);
+   //获取深度相机内参
+   float[] depthParams = object.getDepthInternalParams();
+   //获取彩色相机内参
+   float[] colorParams = object.getColorInternalParams();
+   //获取深度相机畸变参数
+   float[] depthCoeffs = object.getDepthCoeffs();
+   //获取彩色相机畸变参数
+   float[] colorCoeffs = object.getColorCoeffs();
+
+.. _44-获取和设置红外相机曝光值:
+
+4.4 获取和设置红外相机曝光值
+----------------------------
+
+|image39|
+
+.. _c代码-3:
+
+C++代码
+~~~~~~~
+
+.. code:: cpp
+
+   std::shared_ptr<ob::Sensor> irSensor = device->getSensorList()->getSensor(OB_SENSOR_IR);
+   if(!irSensor->isPropertySupported(OB_SENSOR_PROPERTY_EXPOSURE_INT))
+       return;
+   //获取红外相机曝光值
+   int32_t exposure = irSensor->getIntProperty(OB_SENSOR_PROPERTY_EXPOSURE_INT);
+   //设置红外相机曝光值
+   irSensor->setIntProperty(OB_SENSOR_PROPERTY_EXPOSURE_INT, exposure / 2);
+
+.. _android代码-3:
+
+Android代码
+~~~~~~~~~~~
+
+.. code:: java
+
+   Sensor irSensor = device.getSensor(SensorType.IR);
+   boolean isSupport = irSensor.isPropertySupported(SensorProperty.EXPOSURE_INT);
+   if (!isSupport) {
+       return;
+   }
+   //获取红外相机曝光值
+   int exposure = irSensor.getPropertyValueI(SensorProperty.EXPOSURE_INT);
+   //设置红外相机曝光值
+   irSensor.setPropertyValueI(SensorProperty.EXPOSURE_INT, exposure / 2);
+
+.. _45-彩色相机自动曝光:
+
+4.5 彩色相机自动曝光
+--------------------
+
+|image40|
+
+.. _c代码-4:
+
+C++代码
+~~~~~~~
+
+.. code:: cpp
+
+   bool isOpen;
+   std::shared_ptr<ob::Sensor> colorSensor = device->getSensorList()->getSensor(OB_SENSOR_COLOR);
+   if(!colorSensor->isPropertySupported(OB_SENSOR_PROPERTY_ENABLE_AUTO_EXPOSURE_BOOL))
+       return;
+
+   colorSensor->setBoolProperty(OB_SENSOR_PROPERTY_ENABLE_AUTO_EXPOSURE_BOOL, isOpen);
+
+.. _android代码-4:
+
+Android代码
+~~~~~~~~~~~
+
+.. code:: java
+
+   boolean isOpen;
+   Sensor colorSensor = device.getSensor(SensorType.COLOR);
+   boolean isSupport = colorSensor.isPropertySupported(SensorProperty.ENABLE_AUTO_EXPOSURE_BOOL);
+   if (!isSupport) {
+       return;
+   }
+   colorSensor.setPropertyValueB(SensorProperty.ENABLE_AUTO_EXPOSURE_BOOL, isOpen);
+
+.. _46-获取和设置彩色相机曝光值:
+
+4.6 获取和设置彩色相机曝光值
+----------------------------
+
+|image41|
+
+.. _c代码-5:
+
+C++代码
+~~~~~~~
+
+.. code:: cpp
+
+   std::shared_ptr<ob::Sensor> colorSensor = device->getSensorList()->getSensor(OB_SENSOR_COLOR);
+   if(!colorSensor->isPropertySupported(OB_SENSOR_PROPERTY_EXPOSURE_INT))
+       return;
+   //获取彩色相机曝光值
+   int32_t exposure = colorSensor->getIntProperty(OB_SENSOR_PROPERTY_EXPOSURE_INT);
+   //设置彩色相机曝光值
+   colorSensor->setIntProperty(OB_SENSOR_PROPERTY_EXPOSURE_INT, exposure / 2);
+
+.. _android代码-5:
+
+Android代码
+~~~~~~~~~~~
+
+.. code:: java
+
+   Sensor colorSensor = device.getSensor(SensorType.COLOR);
+   boolean isSupport = colorSensor.isPropertySupported(SensorProperty.EXPOSURE_INT);
+   if (!isSupport) {
+       return;
+   }
+   //获取彩色相机曝光值
+   int exposure = colorSensor.getPropertyValueI(SensorProperty.EXPOSURE_INT);
+   //设置彩色相机曝光值
+   colorSensor.setPropertyValueI(SensorProperty.EXPOSURE_INT, exposure / 2);
+
+.. _47-彩色相机自动白平衡:
+
+4.7 彩色相机自动白平衡
+----------------------
+
+|image42|
+
+.. _c代码-6:
+
+C++代码
+~~~~~~~
+
+.. code:: cpp
+
+   bool isOpen;
+   std::shared_ptr<ob::Sensor> colorSensor = device->getSensorList()->getSensor(OB_SENSOR_COLOR);
+   if(!colorSensor->isPropertySupported(OB_SENSOR_PROPERTY_ENABLE_AUTO_WHITE_BALANCE_BOOL))
+       return;
+
+   colorSensor->setBoolProperty(OB_SENSOR_PROPERTY_ENABLE_AUTO_WHITE_BALANCE_BOOL, isOpen);
+
+.. _android代码-6:
+
+Android代码
+~~~~~~~~~~~
+
+.. code:: java
+
+   boolean isOpen;
+   Sensor colorSensor = device.getSensor(SensorType.COLOR);
+   boolean isSupport = colorSensor.isPropertySupported(SensorProperty.ENABLE_AUTO_WHITE_BALANCE_BOOL);
+   if (!isSupport) {
+       return;
+   }
+   colorSensor.setPropertyValueB(SensorProperty.ENABLE_AUTO_WHITE_BALANCE_BOOL, isOpen);
+
+.. _48-获取和设置彩色相机增益:
+
+4.8 获取和设置彩色相机增益
+--------------------------
+
+|image43|
+
+.. _c代码-7:
+
+C++代码
+~~~~~~~
+
+.. code:: cpp
+
+   std::shared_ptr<ob::Sensor> colorSensor = device->getSensorList()->getSensor(OB_SENSOR_COLOR);
+   if(!colorSensor->isPropertySupported(OB_SENSOR_PROPERTY_GAIN_INT))
+       return;
+   //获取彩色相机增益值
+   int32_t gain = colorSensor->getIntProperty(OB_SENSOR_PROPERTY_GAIN_INT);
+   //设置彩色相机增益值
+   colorSensor->setIntProperty(OB_SENSOR_PROPERTY_GAIN_INT, gain / 2);
+
+.. _android代码-7:
+
+Android代码
+~~~~~~~~~~~
+
+.. code:: java
+
+   boolean isExposure;
+   Sensor colorSensor = device.getSensor(SensorType.COLOR);
+   boolean isSupport = colorSensor.isPropertySupported(SensorProperty.GAIN_INT);
+   if (!isSupport) {
+       return;
+   }
+   //获取彩色相机增益
+   int gain = colorSensor.getPropertyValueI(SensorProperty.GAIN_INT);
+   //设置彩色相机增益
+   colorSensor.setPropertyValueI(SensorProperty.GAIN_INT, gain / 2);
+
+.. _49-彩色相机数据流镜像:
+
+4.9 彩色相机数据流镜像
+----------------------
+
+|image44|
+
+.. _c代码-8:
+
+C++代码
+~~~~~~~
+
+.. code:: cpp
+
+   std::shared_ptr<ob::Sensor> colorSensor = device->getSensorList()->getSensor(OB_SENSOR_COLOR);
+   if(!colorSensor->isPropertySupported(OB_SENSOR_PROPERTY_ROLL_INT))
+       return;
+   //1 - 设置镜像； 0 - 不设置镜像
+   colorSensor->setBoolProperty(OB_SENSOR_PROPERTY_ROLL_INT, 1);
+
+.. _android代码-8:
+
+Android代码
+~~~~~~~~~~~
+
+.. code:: java
+
+   Sensor colorSensor = device.getSensor(SensorType.COLOR);
+   boolean isSupport = colorSensor.isPropertySupported(SensorProperty.ROLL_INT);
+   if (!isSupport) {
+       return;
+   }
+   //1 - 设置镜像； 0 - 不设置镜像
+   colorSensor.setPropertyValueI(SensorProperty.ROLL_INT, 1);
+
+.. _410-深度相机数据流镜像:
+
+4.10 深度相机数据流镜像
+-----------------------
+
+|image45|
+
+.. _c代码-9:
+
+C++代码
+~~~~~~~
+
+.. code:: cpp
+
+   bool isMirror;
+   std::shared_ptr<ob::Sensor> depthSensor = device->getSensorList()->getSensor(OB_SENSOR_COLOR);
+   if(!depthSensor->isPropertySupported(OB_DEVICE_PROPERTY_DEPTH_MIRROR_BOOL))
+       return;
+
+   depthSensor->setBoolProperty(OB_DEVICE_PROPERTY_DEPTH_MIRROR_BOOL, isMirror);
+
+.. _android代码-9:
+
+Android代码
+~~~~~~~~~~~
+
+.. code:: java
+
+   boolean isMirror;
+   boolean isSupport = device.isPropertySupported(DeviceProperty.DEPTH_MIRROR_BOOL);
+   if (!isSupport) {
+       return;
+   }
+   device.setPropertyValueB(DeviceProperty.DEPTH_MIRROR_BOOL, isMirror);
+
+.. _411-红外相机数据流镜像:
+
+4.11 红外相机数据流镜像
+-----------------------
+
+|image46|
+
+.. _c代码-10:
+
+C++代码
+~~~~~~~
+
+.. code:: cpp
+
+   bool isMirror;
+   std::shared_ptr<ob::Sensor> irSensor = device->getSensorList()->getSensor(OB_SENSOR_IR);
+   if(!irSensor->isPropertySupported(OB_SDK_PROPERTY_IR_MIRROR_BOOL))
+       return;
+
+   irSensor->setBoolProperty(OB_SDK_PROPERTY_IR_MIRROR_BOOL, isMirror);
+
+.. _android代码-10:
+
+Android代码
+~~~~~~~~~~~
+
+.. code:: java
+
+   boolean isMirror;
+   boolean isSupport = device.isPropertySupported(DeviceProperty.IR_MIRROR_BOOL);
+   if (!isSupport) {
+       return;
+   }
+   device.setPropertyValueB(DeviceProperty.IR_MIRROR_BOOL, isMirror);
+
+.. |image1.png| image:: https://cdn.nlark.com/yuque/0/2022/png/25457865/1650529831703-89abdcec-93b1-48e3-a0db-8a1fc1770bf0.png#clientId=udcd67ee1-6fad-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=1015&id=u455ba7e9&margin=%5Bobject%20Object%5D&name=image.png&originHeight=1015&originWidth=1915&originalType=binary&ratio=1&rotation=0&showTitle=false&size=569548&status=done&style=none&taskId=ud67471c9-f7ed-4fe3-9a0a-32881c80a74&title=&width=1915
+.. |image2.png| image:: https://cdn.nlark.com/yuque/0/2022/png/25457865/1648178647906-90083d0a-3986-4f8c-9405-ad9fc1c8da91.png#clientId=u5e660bfe-7179-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=21&id=u4b760b1e&margin=%5Bobject%20Object%5D&name=image.png&originHeight=21&originWidth=53&originalType=binary&ratio=1&rotation=0&showTitle=false&size=1060&status=done&style=none&taskId=u91d67062-7ba2-4bfd-9c29-c56e4b0751a&title=&width=53
+.. |3| image:: https://cdn.nlark.com/yuque/0/2022/png/25457865/1648189264304-bbb1914a-33b2-4ca9-9025-6bbb18ade1f4.png#crop=0&crop=0&crop=1&crop=1&from=url&height=30&id=EFhtA&margin=%5Bobject%20Object%5D&originHeight=35&originWidth=41&originalType=binary&ratio=1&rotation=0&showTitle=false&status=done&style=none&title=&width=35
+.. |image4.png| image:: https://cdn.nlark.com/yuque/0/2022/png/25457865/1648178706807-9aa991b7-1b9a-4e5a-b9c3-37cf5f5824fe.png#clientId=u5e660bfe-7179-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=28&id=u5638a2e4&margin=%5Bobject%20Object%5D&name=image.png&originHeight=42&originWidth=46&originalType=binary&ratio=1&rotation=0&showTitle=false&size=296&status=done&style=none&taskId=u81d4f17a-31c4-456e-959f-03c56005d2f&title=&width=31
+.. |image5.png| image:: https://cdn.nlark.com/yuque/0/2022/png/25457865/1648108931520-6ae90374-6134-4450-9c3b-eb3ce58d118e.png#clientId=u601826ea-9d84-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=30&id=u3d7c78ea&margin=%5Bobject%20Object%5D&name=image.png&originHeight=40&originWidth=474&originalType=binary&ratio=1&rotation=0&showTitle=false&size=4424&status=done&style=none&taskId=ufb3300ee-ea56-45f7-a3f3-4f4564252f6&title=&width=354
+.. |image6.png| image:: https://cdn.nlark.com/yuque/0/2022/png/25457865/1650530397142-bcd91fdf-a102-4a1e-8300-fa3dea236aa9.png#clientId=ua3abc564-fea4-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=1015&id=u029ec269&margin=%5Bobject%20Object%5D&name=image.png&originHeight=1015&originWidth=1916&originalType=binary&ratio=1&rotation=0&showTitle=false&size=620470&status=done&style=none&taskId=u20dd4230-8883-472d-a3a4-2112c2ee718&title=&width=1916
+.. |image7.png| image:: https://cdn.nlark.com/yuque/0/2022/png/25457865/1648109849447-e7b61e94-25d6-41af-bdcf-7c62b1172694.png#clientId=u601826ea-9d84-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=215&id=u6bccac68&margin=%5Bobject%20Object%5D&name=image.png&originHeight=215&originWidth=275&originalType=binary&ratio=1&rotation=0&showTitle=false&size=21596&status=done&style=none&taskId=u2f10449f-1522-46d6-b4bf-9a4a7c6b7b8&title=&width=275
+.. |image8.png| image:: https://cdn.nlark.com/yuque/0/2022/png/25457865/1648110409212-94740f94-3119-4a10-8842-e256687e85cb.png#clientId=u601826ea-9d84-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=212&id=uf20b9a8b&margin=%5Bobject%20Object%5D&name=image.png&originHeight=212&originWidth=290&originalType=binary&ratio=1&rotation=0&showTitle=false&size=21733&status=done&style=none&taskId=u9a12c10f-737a-4044-bb70-780c8e7c721&title=&width=290
+.. |image9.png| image:: https://cdn.nlark.com/yuque/0/2022/png/25457865/1648110478875-e7f50d30-1bd6-4f4e-9f19-7f4f2d08384e.png#clientId=u601826ea-9d84-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=213&id=ucf7b3d75&margin=%5Bobject%20Object%5D&name=image.png&originHeight=213&originWidth=274&originalType=binary&ratio=1&rotation=0&showTitle=false&size=20096&status=done&style=none&taskId=u39398300-3fb7-41e6-965b-5579f9e56c2&title=&width=274
+.. |image10.png| image:: https://cdn.nlark.com/yuque/0/2022/png/25457865/1648113681441-740ad3ed-3400-464d-8555-41531e3fb0ba.png#clientId=u601826ea-9d84-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=25&id=u8e0ac9b9&margin=%5Bobject%20Object%5D&name=image.png&originHeight=45&originWidth=48&originalType=binary&ratio=1&rotation=0&showTitle=false&size=307&status=done&style=none&taskId=ud9ed30dd-0136-4d6c-b364-1c80ad490a3&title=&width=27
+.. |image11.png| image:: https://cdn.nlark.com/yuque/0/2022/png/25457865/1648112431902-9d6d6b40-514c-4a47-8198-dfac8fb5fce1.png#clientId=u601826ea-9d84-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=723&id=ufa888028&margin=%5Bobject%20Object%5D&name=image.png&originHeight=723&originWidth=1365&originalType=binary&ratio=1&rotation=0&showTitle=false&size=190921&status=done&style=none&taskId=ud8f6fa22-6986-4a9b-8000-aaebb452997&title=&width=1365
+.. |image12.png| image:: https://cdn.nlark.com/yuque/0/2022/png/25457865/1648190245362-2a1f0154-cbed-443a-b7ef-cfa2592cb771.png#clientId=u5e660bfe-7179-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=21&id=ue83562d7&margin=%5Bobject%20Object%5D&name=image.png&originHeight=21&originWidth=22&originalType=binary&ratio=1&rotation=0&showTitle=false&size=335&status=done&style=none&taskId=ud54a877a-c68b-4522-ab27-150d5506dcd&title=&width=22
+.. |image13.png| image:: https://cdn.nlark.com/yuque/0/2022/png/25457865/1648190351836-2f8aded6-b17d-4feb-90fd-88612874bab4.png#clientId=u5e660bfe-7179-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=15&id=u87630091&margin=%5Bobject%20Object%5D&name=image.png&originHeight=15&originWidth=22&originalType=binary&ratio=1&rotation=0&showTitle=false&size=165&status=done&style=none&taskId=u7e56d43f-a686-4d39-8225-c056bd4d47a&title=&width=22
+.. |image14.png| image:: https://cdn.nlark.com/yuque/0/2022/png/25457865/1648190386660-828cbb60-595b-4810-8f9c-56605eb3e6c0.png#clientId=u5e660bfe-7179-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=21&id=u2995be4e&margin=%5Bobject%20Object%5D&name=image.png&originHeight=21&originWidth=21&originalType=binary&ratio=1&rotation=0&showTitle=false&size=334&status=done&style=none&taskId=ubd664e72-f449-41ee-bffb-71cd194fe29&title=&width=21
+.. |image15.png| image:: https://cdn.nlark.com/yuque/0/2022/png/25457865/1648190510639-199d8e60-34cf-4227-b422-c0d1bf227b91.png#clientId=u5e660bfe-7179-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=18&id=ubb05a3cc&margin=%5Bobject%20Object%5D&name=image.png&originHeight=18&originWidth=22&originalType=binary&ratio=1&rotation=0&showTitle=false&size=437&status=done&style=none&taskId=u6ced94a0-924b-4429-b77e-4e625dca5b6&title=&width=22
+.. |Snipaste_2022-04-21_14-45-09.png| image:: https://cdn.nlark.com/yuque/0/2022/png/25457865/1650529063373-5a0d9fd1-03eb-401d-89e0-5554a4c27dfb.png#clientId=ub2a59962-d9fb-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=1018&id=u1756b4b4&margin=%5Bobject%20Object%5D&name=Snipaste_2022-04-21_14-45-09.png&originHeight=1018&originWidth=1920&originalType=binary&ratio=1&rotation=0&showTitle=false&size=5874293&status=done&style=none&taskId=ua7e26dc4-3572-446f-ad9e-bb31fdf0799&title=&width=1920
+.. |16| image:: https://cdn.nlark.com/yuque/0/2022/png/25457865/1648193922814-b9bf475c-ea05-4f9a-9211-63cdfe7069c9.png?x-oss-process=image%2Fresize%2Cw_750%2Climit_0#crop=0&crop=0&crop=1&crop=1&from=url&id=avz7e&margin=%5Bobject%20Object%5D&originHeight=395&originWidth=750&originalType=binary&ratio=1&rotation=0&showTitle=false&status=done&style=none&title=
+.. |image17.png| image:: https://cdn.nlark.com/yuque/0/2022/png/25457865/1648193828014-fe829127-8a93-43f2-94b2-3bd7349b6928.png#clientId=u5e660bfe-7179-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=723&id=uf0df08f4&margin=%5Bobject%20Object%5D&name=image.png&originHeight=723&originWidth=1365&originalType=binary&ratio=1&rotation=0&showTitle=false&size=216456&status=done&style=none&taskId=ucefc34e3-a08d-42a5-a05f-999721ba440&title=&width=1365
+.. |image18.png| image:: https://cdn.nlark.com/yuque/0/2022/png/25457865/1648194253076-b2193c01-b1d6-4195-8a93-294556809bb1.png#clientId=u5e660bfe-7179-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=320&id=u45a00cc0&margin=%5Bobject%20Object%5D&name=image.png&originHeight=320&originWidth=291&originalType=binary&ratio=1&rotation=0&showTitle=false&size=29940&status=done&style=none&taskId=udbee5558-d00d-4dbf-84df-5ad44e8fc9c&title=&width=291
+.. |image19.png| image:: https://cdn.nlark.com/yuque/0/2022/png/25457865/1648196474053-2ede75f7-1212-401e-ac5d-017cddf9095d.png#clientId=u5e660bfe-7179-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=655&id=u771507d8&margin=%5Bobject%20Object%5D&name=image.png&originHeight=655&originWidth=286&originalType=binary&ratio=1&rotation=0&showTitle=false&size=40466&status=done&style=none&taskId=u6066ed62-8028-45c0-9946-9d2572e94ad&title=&width=286
+.. |image20.png| image:: https://cdn.nlark.com/yuque/0/2022/png/25457865/1648196726206-8e8a269e-b6b7-4324-a88e-8b3c1dee56de.png#clientId=u5e660bfe-7179-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=188&id=u58745c50&margin=%5Bobject%20Object%5D&name=image.png&originHeight=188&originWidth=288&originalType=binary&ratio=1&rotation=0&showTitle=false&size=12860&status=done&style=none&taskId=uc2641b52-d193-40bf-b041-54659492c02&title=&width=288
+.. |image21.png| image:: https://cdn.nlark.com/yuque/0/2022/png/25457865/1648201290774-0ef8a066-b934-4870-8f7d-ba9c88cc4f0a.png#clientId=ua2ab74ba-4f33-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=114&id=ue5f910ef&margin=%5Bobject%20Object%5D&name=image.png&originHeight=114&originWidth=289&originalType=binary&ratio=1&rotation=0&showTitle=false&size=9754&status=done&style=none&taskId=u7affa078-45a1-4837-b37d-f030850889e&title=&width=289
+.. |image22.png| image:: https://cdn.nlark.com/yuque/0/2022/png/25457865/1648537831215-51a4bf19-c347-4f91-ad6f-59f53a5a936c.png#clientId=uef6b8d0d-eb1c-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=22&id=u7feabba6&margin=%5Bobject%20Object%5D&name=image.png&originHeight=22&originWidth=121&originalType=binary&ratio=1&rotation=0&showTitle=false&size=2233&status=done&style=none&taskId=u19d96ea0-b777-4809-bed2-0337c42f077&title=&width=121
+.. |image23.png| image:: https://cdn.nlark.com/yuque/0/2022/png/25457865/1648537851887-47e51c96-9e33-40ef-9b27-b322575d9e50.png#clientId=uef6b8d0d-eb1c-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=21&id=u2c7a6cb9&margin=%5Bobject%20Object%5D&name=image.png&originHeight=21&originWidth=123&originalType=binary&ratio=1&rotation=0&showTitle=false&size=1774&status=done&style=none&taskId=u3c6832ce-180a-4d59-82e5-58551ce8e7a&title=&width=123
+.. |image24.png| image:: https://cdn.nlark.com/yuque/0/2022/png/25457865/1648537888729-045234a1-fe61-4ca2-acd1-f28bbc475e25.png#clientId=uef6b8d0d-eb1c-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=21&id=u181c72d5&margin=%5Bobject%20Object%5D&name=image.png&originHeight=21&originWidth=137&originalType=binary&ratio=1&rotation=0&showTitle=false&size=2430&status=done&style=none&taskId=u42e5a199-dcd8-44e8-a445-b8f5688466b&title=&width=137
+.. |image25.png| image:: https://cdn.nlark.com/yuque/0/2022/png/25457865/1648537967163-1f3dc227-ff5b-49ff-b670-1ea24d3dafbf.png#clientId=uef6b8d0d-eb1c-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=30&id=u149017b8&margin=%5Bobject%20Object%5D&name=image.png&originHeight=30&originWidth=255&originalType=binary&ratio=1&rotation=0&showTitle=false&size=4577&status=done&style=none&taskId=ub6329e0b-57fe-476b-bfb9-7eec8807ec4&title=&width=255
+.. |image26| image:: https://cdn.nlark.com/yuque/0/2022/png/25457865/1650527511641-4df3f94d-7d51-432a-95e3-82e1949448d1.png?x-oss-process=image%2Fwatermark%2Ctype_d3F5LW1pY3JvaGVp%2Csize_13%2Ctext_T3JiYmVj%2Ccolor_FFFFFF%2Cshadow_50%2Ct_80%2Cg_se%2Cx_10%2Cy_10#crop=0&crop=0&crop=1&crop=1&from=url&id=z4UGW&margin=%5Bobject%20Object%5D&originHeight=443&originWidth=294&originalType=binary&ratio=1&rotation=0&showTitle=false&status=done&style=none&title=
+.. |image26.png| image:: https://cdn.nlark.com/yuque/0/2022/png/25457865/1648537611246-d479b980-bce9-40dd-910d-bae6fdd75d65.png#clientId=uef6b8d0d-eb1c-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=36&id=ubd23b188&margin=%5Bobject%20Object%5D&name=image.png&originHeight=36&originWidth=106&originalType=binary&ratio=1&rotation=0&showTitle=false&size=1058&status=done&style=none&taskId=uda3bb580-5d1a-463c-b53e-8b29907db8f&title=&width=106
+.. |image27.png| image:: https://cdn.nlark.com/yuque/0/2022/png/25457865/1648537481182-e94bb95d-819b-4544-b0ea-463904705bf0.png#clientId=uef6b8d0d-eb1c-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=1038&id=u6c95bcbe&margin=%5Bobject%20Object%5D&name=image.png&originHeight=1038&originWidth=1919&originalType=binary&ratio=1&rotation=0&showTitle=false&size=208043&status=done&style=none&taskId=u8bd423fe-4bc3-4f7b-9501-bc5528e4ffb&title=&width=1919
+.. |28| image:: https://cdn.nlark.com/yuque/0/2022/png/25457865/1648113681441-740ad3ed-3400-464d-8555-41531e3fb0ba.png?x-oss-process=image%2Fresize%2Cw_24%2Climit_0#crop=0&crop=0&crop=1&crop=1&from=url&id=KcJfI&margin=%5Bobject%20Object%5D&originHeight=23&originWidth=24&originalType=binary&ratio=1&rotation=0&showTitle=false&status=done&style=none&title=
+.. |1650524827127_47E08781-CEC2-4d18-BC50-F8984C3F87C4.png| image:: https://cdn.nlark.com/yuque/0/2022/png/25457865/1650527852473-ace0065f-f18c-41e3-a340-aeee9a2feebd.png#clientId=u2f82a3fc-3972-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=591&id=uf6488c2b&margin=%5Bobject%20Object%5D&name=1650524827127_47E08781-CEC2-4d18-BC50-F8984C3F87C4.png&originHeight=591&originWidth=601&originalType=binary&ratio=1&rotation=0&showTitle=false&size=14615&status=done&style=none&taskId=ue0413d1b-9aed-4599-a66b-8518037158b&title=&width=601
+.. |image29.png| image:: https://cdn.nlark.com/yuque/0/2022/png/25457865/1648201389847-593c48f1-6916-4240-9c49-ffb806f3c3bb.png#clientId=ua2ab74ba-4f33-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=586&id=u11e5bee2&margin=%5Bobject%20Object%5D&name=image.png&originHeight=586&originWidth=598&originalType=binary&ratio=1&rotation=0&showTitle=false&size=19272&status=done&style=none&taskId=u9083052a-102a-4165-9b80-d1ff7a692c8&title=&width=598
+.. |image30.png| image:: https://cdn.nlark.com/yuque/0/2022/png/25457865/1648537675935-cb8f82c6-7b05-4ef5-9cbd-06c8d06137e6.png#clientId=uef6b8d0d-eb1c-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=15&id=ue81c5c89&margin=%5Bobject%20Object%5D&name=image.png&originHeight=15&originWidth=23&originalType=binary&ratio=1&rotation=0&showTitle=false&size=402&status=done&style=none&taskId=u152ae45c-ec0a-4f86-8c19-61e53b72ddd&title=&width=23
+.. |image31.png| image:: https://cdn.nlark.com/yuque/0/2022/png/25457865/1648537742263-b78992c0-69c2-4ec3-9743-fb9e2766dd9d.png#clientId=uef6b8d0d-eb1c-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=18&id=u92ac4152&margin=%5Bobject%20Object%5D&name=image.png&originHeight=18&originWidth=23&originalType=binary&ratio=1&rotation=0&showTitle=false&size=436&status=done&style=none&taskId=ua740cc90-787e-4189-b958-f33926d6b49&title=&width=23
+.. |image32.png| image:: https://cdn.nlark.com/yuque/0/2022/png/25457865/1648537760887-cd7b8e8a-3a28-491f-8cdf-87c726377bd8.png#clientId=uef6b8d0d-eb1c-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=19&id=u2449ada5&margin=%5Bobject%20Object%5D&name=image.png&originHeight=19&originWidth=20&originalType=binary&ratio=1&rotation=0&showTitle=false&size=399&status=done&style=none&taskId=ued2c6d61-1b64-4cef-9900-0bac1193afe&title=&width=20
+.. |Snipaste_2022-04-21_14-45-27.png| image:: https://cdn.nlark.com/yuque/0/2022/png/25457865/1650530106635-5e4f42e3-66e0-43be-9bac-83c257f554dd.png#clientId=udcd67ee1-6fad-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=1014&id=u4f661c7e&margin=%5Bobject%20Object%5D&name=Snipaste_2022-04-21_14-45-27.png&originHeight=1014&originWidth=1920&originalType=binary&ratio=1&rotation=0&showTitle=false&size=5851213&status=done&style=none&taskId=u055ce2b0-6eb5-4d59-87a6-3782bf4fb91&title=&width=1920
+.. |33| image:: https://cdn.nlark.com/yuque/0/2021/png/25457865/1639382292960-231341f8-fb2a-4fbd-bc69-566a7740eac9.png#crop=0&crop=0&crop=1&crop=1&from=url&id=AOezl&margin=%5Bobject%20Object%5D&originHeight=33&originWidth=294&originalType=binary&ratio=1&rotation=0&showTitle=false&status=done&style=none&title=
+.. |34| image:: https://cdn.nlark.com/yuque/0/2021/png/25457865/1639382254638-12a76403-1467-4eb2-a07d-1f50cc227428.png#crop=0&crop=0&crop=1&crop=1&from=url&id=lWU7p&margin=%5Bobject%20Object%5D&originHeight=36&originWidth=294&originalType=binary&ratio=1&rotation=0&showTitle=false&status=done&style=none&title=
+.. |image38| image:: https://cdn.nlark.com/yuque/0/2021/png/25457865/1639386018191-457ff14b-6485-4bbb-89e1-0e43368fe7e0.png#crop=0&crop=0&crop=1&crop=1&from=url&id=xQR8F&margin=%5Bobject%20Object%5D&originHeight=586&originWidth=586&originalType=binary&ratio=1&rotation=0&showTitle=false&status=done&style=none&title=
+.. |image39| image:: https://cdn.nlark.com/yuque/0/2021/png/25457865/1639383736038-0817fe8c-29ef-4efe-aa5c-146cd342d25c.png#crop=0&crop=0&crop=1&crop=1&from=url&id=iyBmh&margin=%5Bobject%20Object%5D&originHeight=185&originWidth=294&originalType=binary&ratio=1&rotation=0&showTitle=false&status=done&style=none&title=
+.. |image40| image:: https://cdn.nlark.com/yuque/0/2021/png/25457865/1639380531623-f0daa0d1-726b-422b-af85-253394861176.png?x-oss-process=image%2Fwatermark%2Ctype_d3F5LW1pY3JvaGVp%2Csize_13%2Ctext_T3JiYmVj%2Ccolor_FFFFFF%2Cshadow_50%2Ct_80%2Cg_se%2Cx_10%2Cy_10%2Fresize%2Cw_281%2Climit_0#crop=0&crop=0&crop=1&crop=1&from=url&id=yjzLs&margin=%5Bobject%20Object%5D&originHeight=215&originWidth=281&originalType=binary&ratio=1&rotation=0&showTitle=false&status=done&style=none&title=
+.. |image41| image:: https://cdn.nlark.com/yuque/0/2021/png/25457865/1639379927390-9eebc82d-6298-4276-9f89-8dc99331e9bb.png?x-oss-process=image%2Fwatermark%2Ctype_d3F5LW1pY3JvaGVp%2Csize_13%2Ctext_T3JiYmVj%2Ccolor_FFFFFF%2Cshadow_50%2Ct_80%2Cg_se%2Cx_10%2Cy_10%2Fresize%2Cw_284%2Climit_0#crop=0&crop=0&crop=1&crop=1&from=url&id=yS14w&margin=%5Bobject%20Object%5D&originHeight=209&originWidth=284&originalType=binary&ratio=1&rotation=0&showTitle=false&status=done&style=none&title=
+.. |image42| image:: https://cdn.nlark.com/yuque/0/2021/png/25457865/1639380563812-f091c743-71a3-4be6-9cbf-6930ebe7e695.png?x-oss-process=image%2Fwatermark%2Ctype_d3F5LW1pY3JvaGVp%2Csize_13%2Ctext_T3JiYmVj%2Ccolor_FFFFFF%2Cshadow_50%2Ct_80%2Cg_se%2Cx_10%2Cy_10%2Fresize%2Cw_290%2Climit_0#crop=0&crop=0&crop=1&crop=1&from=url&id=eCKZy&margin=%5Bobject%20Object%5D&originHeight=294&originWidth=290&originalType=binary&ratio=1&rotation=0&showTitle=false&status=done&style=none&title=
+.. |image43| image:: https://cdn.nlark.com/yuque/0/2021/png/25457865/1639380066566-230e5e9b-c0af-4093-b97d-6eb094eaa568.png?x-oss-process=image%2Fwatermark%2Ctype_d3F5LW1pY3JvaGVp%2Csize_13%2Ctext_T3JiYmVj%2Ccolor_FFFFFF%2Cshadow_50%2Ct_80%2Cg_se%2Cx_10%2Cy_10%2Fresize%2Cw_290%2Climit_0#crop=0&crop=0&crop=1&crop=1&from=url&id=XGTCF&margin=%5Bobject%20Object%5D&originHeight=352&originWidth=290&originalType=binary&ratio=1&rotation=0&showTitle=false&status=done&style=none&title=
+.. |image44| image:: https://cdn.nlark.com/yuque/0/2021/png/25457865/1639380253712-c2b4bcde-823e-4180-9157-2707db4f3cb0.png?x-oss-process=image%2Fwatermark%2Ctype_d3F5LW1pY3JvaGVp%2Csize_13%2Ctext_T3JiYmVj%2Ccolor_FFFFFF%2Cshadow_50%2Ct_80%2Cg_se%2Cx_10%2Cy_10%2Fresize%2Cw_292%2Climit_0#crop=0&crop=0&crop=1&crop=1&from=url&id=CNHbp&margin=%5Bobject%20Object%5D&originHeight=296&originWidth=292&originalType=binary&ratio=1&rotation=0&showTitle=false&status=done&style=none&title=
+.. |image45| image:: https://cdn.nlark.com/yuque/0/2021/png/25457865/1639380620773-ce0b4211-1837-40a2-9b24-0dc57c73fceb.png?x-oss-process=image%2Fwatermark%2Ctype_d3F5LW1pY3JvaGVp%2Csize_13%2Ctext_T3JiYmVj%2Ccolor_FFFFFF%2Cshadow_50%2Ct_80%2Cg_se%2Cx_10%2Cy_10%2Fresize%2Cw_281%2Climit_0#crop=0&crop=0&crop=1&crop=1&from=url&id=GjkZ5&margin=%5Bobject%20Object%5D&originHeight=255&originWidth=281&originalType=binary&ratio=1&rotation=0&showTitle=false&status=done&style=none&title=
+.. |image46| image:: https://cdn.nlark.com/yuque/0/2021/png/25457865/1639380651007-b54e8b8f-a75f-4351-9780-e473ad5d1f0e.png?x-oss-process=image%2Fwatermark%2Ctype_d3F5LW1pY3JvaGVp%2Csize_13%2Ctext_T3JiYmVj%2Ccolor_FFFFFF%2Cshadow_50%2Ct_80%2Cg_se%2Cx_10%2Cy_10%2Fresize%2Cw_285%2Climit_0#crop=0&crop=0&crop=1&crop=1&from=url&id=Px9Ww&margin=%5Bobject%20Object%5D&originHeight=183&originWidth=285&originalType=binary&ratio=1&rotation=0&showTitle=false&status=done&style=none&title=
diff --git a/docs/api/sphinx/orbbecviewer/index.rst b/docs/api/sphinx/orbbecviewer/index.rst
new file mode 100644
index 00000000..f6f2f8ae
--- /dev/null
+++ b/docs/api/sphinx/orbbecviewer/index.rst
@@ -0,0 +1,6 @@
+OrbbecViewer手册
+=============
+
+.. toctree::
+
+   OrbbecViewer_Usage
diff --git a/docs/api/sphinx/reference/c_ref.rst b/docs/api/sphinx/reference/c_ref.rst
new file mode 100644
index 00000000..8dd99fec
--- /dev/null
+++ b/docs/api/sphinx/reference/c_ref.rst
@@ -0,0 +1,960 @@
+C API参考
+============================================
+宏定义
+--------------------------------------------
+.. doxygendefine:: OB_EXTENSION_API
+   :project: OrbbecSdk
+
+.. doxygendefine:: DEPRECATED
+   :project: OrbbecSdk
+
+.. doxygendefine:: ob_filter_callback
+   :project: OrbbecSdk
+
+.. doxygendefine:: ob_playback_callback
+   :project: OrbbecSdk
+
+结构体
+--------------------------------------------
+.. doxygenstruct:: ob_error
+   :project: OrbbecSdk
+
+.. doxygenstruct:: OBAccelValue
+   :project: OrbbecSdk
+
+.. doxygenstruct:: OBBoolPropertyRange
+   :project: OrbbecSdk
+
+.. doxygenstruct:: OBCameraDistortion
+   :project: OrbbecSdk
+
+.. doxygenstruct:: OBCameraIntrinsic
+   :project: OrbbecSdk
+
+.. doxygenstruct:: OBCameraParam
+   :project: OrbbecSdk
+
+.. doxygenstruct:: OBColorPoint
+   :project: OrbbecSdk
+
+.. doxygenstruct:: OBD2CTransform
+   :project: OrbbecSdk
+
+.. doxygenstruct:: OBDataChunk
+   :project: OrbbecSdk
+
+.. doxygenstruct:: OBDeviceTemperature
+   :project: OrbbecSdk
+
+.. doxygenstruct:: OBFloatPropertyRange
+   :project: OrbbecSdk
+
+.. doxygenstruct:: OBIntPropertyRange
+   :project: OrbbecSdk
+
+.. doxygenstruct:: OBMultiDeviceSyncConfig
+   :project: OrbbecSdk
+
+.. doxygenstruct:: OBPoint
+   :project: OrbbecSdk
+
+.. doxygenstruct:: OBPropertyItem
+   :project: OrbbecSdk
+
+.. doxygenstruct:: OBRect
+   :project: OrbbecSdk
+
+.. doxygenstruct:: OBTofExposureThresholdControl
+   :project: OrbbecSdk
+
+枚举
+--------------------------------------------
+.. doxygenenum:: OBPermissionType
+   :project: OrbbecSdk
+
+.. doxygenenum:: OBStatus
+   :project: OrbbecSdk
+
+.. doxygenenum:: OBLogSeverity
+   :project: OrbbecSdk
+
+.. doxygenenum:: OBExceptionType
+   :project: OrbbecSdk
+
+.. doxygenenum:: OBSensorType
+   :project: OrbbecSdk
+
+.. doxygenenum:: OBStreamType
+   :project: OrbbecSdk
+
+.. doxygenenum:: OBFrameType
+   :project: OrbbecSdk
+
+.. doxygenenum:: OBFormat
+   :project: OrbbecSdk
+
+.. doxygenenum:: OBUpgradeState
+   :project: OrbbecSdk
+
+.. doxygenenum:: OBFileTranState
+   :project: OrbbecSdk
+
+.. doxygenenum:: OBDataTranState
+   :project: OrbbecSdk
+
+.. doxygenenum:: OBAlignMode
+   :project: OrbbecSdk
+
+.. doxygenenum:: OBConvertFormat
+   :project: OrbbecSdk
+
+.. doxygenenum:: OBGyroSampleRate
+   :project: OrbbecSdk
+
+.. doxygenenum:: OBGyroFullScaleRange
+   :project: OrbbecSdk
+
+.. doxygenenum:: OBAccelFullScaleRange
+   :project: OrbbecSdk
+
+.. doxygenenum:: OBDeviceState
+   :project: OrbbecSdk
+
+.. doxygenenum:: OBDepthCroppingMode
+   :project: OrbbecSdk
+
+.. doxygenenum:: OBDeviceType
+   :project: OrbbecSdk
+
+.. doxygenenum:: OBMediaType
+   :project: OrbbecSdk
+
+.. doxygenenum:: OBMediaState
+   :project: OrbbecSdk
+
+.. doxygenenum:: OBDepthPrecisionLevel
+   :project: OrbbecSdk
+
+.. doxygenenum:: OBTofFilterRange
+   :project: OrbbecSdk
+
+.. doxygenenum:: OBSyncMode
+   :project: OrbbecSdk
+
+.. doxygenenum:: OBPropertyID
+   :project: OrbbecSdk
+
+.. doxygenenum:: OBPropertyType
+   :project: OrbbecSdk
+
+类型定义
+--------------------------------------------
+.. doxygentypedef:: ob_context
+   :project: OrbbecSdk
+
+.. doxygentypedef:: ob_device
+   :project: OrbbecSdk
+
+.. doxygentypedef:: ob_device_info
+   :project: OrbbecSdk
+
+.. doxygentypedef:: ob_device_list
+   :project: OrbbecSdk
+
+.. doxygentypedef:: ob_camera_param_list
+   :project: OrbbecSdk
+
+.. doxygentypedef:: ob_sensor
+   :project: OrbbecSdk
+
+.. doxygentypedef:: ob_sensor_list
+   :project: OrbbecSdk
+
+.. doxygentypedef:: ob_stream_profile
+   :project: OrbbecSdk
+
+.. doxygentypedef:: ob_stream_profile_list
+   :project: OrbbecSdk
+
+.. doxygentypedef:: ob_frame
+   :project: OrbbecSdk
+
+.. doxygentypedef:: ob_filter
+   :project: OrbbecSdk
+
+.. doxygentypedef:: ob_pipeline
+   :project: OrbbecSdk
+
+.. doxygentypedef:: ob_config
+   :project: OrbbecSdk
+
+.. doxygentypedef:: ob_recorder
+   :project: OrbbecSdk
+
+.. doxygentypedef:: ob_playback
+   :project: OrbbecSdk
+
+.. doxygentypedef:: ob_permission_type
+   :project: OrbbecSdk
+
+.. doxygentypedef:: ob_status
+   :project: OrbbecSdk
+
+.. doxygentypedef:: ob_log_severity
+   :project: OrbbecSdk
+
+.. doxygentypedef:: DEVICE_LOG_SEVERITY_LEVEL
+   :project: OrbbecSdk
+
+.. doxygentypedef:: OBDeviceLogSeverityLevel
+   :project: OrbbecSdk
+
+.. doxygentypedef:: ob_device_log_severity_level
+   :project: OrbbecSdk
+
+.. doxygentypedef:: ob_exception_type
+   :project: OrbbecSdk
+
+.. doxygentypedef:: ob_error
+   :project: OrbbecSdk
+
+.. doxygentypedef:: ob_sensor_type
+   :project: OrbbecSdk
+
+.. doxygentypedef:: ob_stream_type
+   :project: OrbbecSdk
+
+.. doxygentypedef:: ob_frame_type
+   :project: OrbbecSdk
+
+.. doxygentypedef:: ob_format
+   :project: OrbbecSdk
+
+.. doxygentypedef:: ob_upgrade_state
+   :project: OrbbecSdk
+
+.. doxygentypedef:: ob_file_tran_state
+   :project: OrbbecSdk
+
+.. doxygentypedef:: ob_data_tran_state
+   :project: OrbbecSdk
+
+.. doxygentypedef:: ob_data_chunk
+   :project: OrbbecSdk
+
+.. doxygentypedef:: ob_int_property_range
+   :project: OrbbecSdk
+
+.. doxygentypedef:: ob_float_property_range
+   :project: OrbbecSdk
+
+.. doxygentypedef:: ob_bool_property_range
+   :project: OrbbecSdk
+
+.. doxygentypedef:: ob_camera_intrinsic
+   :project: OrbbecSdk
+
+.. doxygentypedef:: ob_camera_distortion
+   :project: OrbbecSdk
+
+.. doxygentypedef:: ob_d2c_transform
+   :project: OrbbecSdk
+
+.. doxygentypedef:: ob_camera_param
+   :project: OrbbecSdk
+
+.. doxygentypedef:: ob_align_mode
+   :project: OrbbecSdk
+
+.. doxygentypedef:: ob_rect
+   :project: OrbbecSdk
+
+.. doxygentypedef:: ob_convert_format
+   :project: OrbbecSdk
+
+.. doxygentypedef:: ob_gyro_sample_rate
+   :project: OrbbecSdk
+
+.. doxygentypedef:: OBAccelSampleRate
+   :project: OrbbecSdk
+
+.. doxygentypedef:: ob_accel_sample_rate
+   :project: OrbbecSdk
+
+.. doxygentypedef:: OB_SAMPLE_RATE
+   :project: OrbbecSdk
+
+.. doxygentypedef:: ob_gyro_full_scale_range
+   :project: OrbbecSdk
+
+.. doxygentypedef:: OB_GYRO_FULL_SCALE_RANGE
+   :project: OrbbecSdk
+
+.. doxygentypedef:: ob_accel_full_scale_range
+   :project: OrbbecSdk
+
+.. doxygentypedef:: OB_ACCEL_FULL_SCALE_RANGE
+   :project: OrbbecSdk
+
+.. doxygentypedef:: OBGyroValue
+   :project: OrbbecSdk
+
+.. doxygentypedef:: ob_accel_value
+   :project: OrbbecSdk
+
+.. doxygentypedef:: ob_gyro_value
+   :project: OrbbecSdk
+
+.. doxygentypedef:: ob_device_state
+   :project: OrbbecSdk
+
+.. doxygentypedef:: ob_device_temperature
+   :project: OrbbecSdk
+
+.. doxygentypedef:: DEVICE_TEMPERATURE
+   :project: OrbbecSdk
+
+.. doxygentypedef:: ob_depth_cropping_mode
+   :project: OrbbecSdk
+
+.. doxygentypedef:: OB_DEPTH_CROPPING_MODE
+   :project: OrbbecSdk
+
+.. doxygentypedef:: ob_device_type
+   :project: OrbbecSdk
+
+.. doxygentypedef:: OB_DEVICE_TYPE
+   :project: OrbbecSdk
+
+.. doxygentypedef:: ob_media_type
+   :project: OrbbecSdk
+
+.. doxygentypedef:: OB_MEDIA_TYPE
+   :project: OrbbecSdk
+
+.. doxygentypedef:: ob_media_state
+   :project: OrbbecSdk
+
+.. doxygentypedef:: OB_MEDIA_STATE_EM
+   :project: OrbbecSdk
+
+.. doxygentypedef:: ob_depth_precision_level
+   :project: OrbbecSdk
+
+.. doxygentypedef:: OB_DEPTH_PRECISION_LEVEL
+   :project: OrbbecSdk
+
+.. doxygentypedef:: ob_tof_filter_range
+   :project: OrbbecSdk
+
+.. doxygentypedef:: TOF_FILTER_RANGE
+   :project: OrbbecSdk
+
+.. doxygentypedef:: ob_point
+   :project: OrbbecSdk
+
+.. doxygentypedef:: ob_color_point
+   :project: OrbbecSdk
+
+.. doxygentypedef:: ob_sync_mode
+   :project: OrbbecSdk
+
+.. doxygentypedef:: OB_SYNC_MODE
+   :project: OrbbecSdk
+
+.. doxygentypedef:: ob_tof_exposure_threshold_control
+   :project: OrbbecSdk
+
+.. doxygentypedef:: TOF_EXPOSURE_THRESHOLD_CONTROL
+   :project: OrbbecSdk
+
+.. doxygentypedef:: ob_multi_device_sync_config
+   :project: OrbbecSdk
+
+.. doxygentypedef:: OB_MULTI_DEVICE_SYNC_CONFIG
+   :project: OrbbecSdk
+
+.. doxygentypedef:: ob_file_send_callback
+   :project: OrbbecSdk
+
+.. doxygentypedef:: ob_device_upgrade_callback
+   :project: OrbbecSdk
+
+.. doxygentypedef:: ob_device_state_callback
+   :project: OrbbecSdk
+
+.. doxygentypedef:: ob_set_data_callback
+   :project: OrbbecSdk
+
+.. doxygentypedef:: ob_get_data_callback
+   :project: OrbbecSdk
+
+.. doxygentypedef:: ob_media_state_callback
+   :project: OrbbecSdk
+
+.. doxygentypedef:: ob_device_changed_callback
+   :project: OrbbecSdk
+
+.. doxygentypedef:: ob_frame_callback
+   :project: OrbbecSdk
+
+.. doxygentypedef:: ob_frameset_callback
+   :project: OrbbecSdk
+
+.. doxygentypedef:: ob_property_id
+   :project: OrbbecSdk
+
+.. doxygentypedef:: OBPropertyType
+   :project: OrbbecSdk
+
+.. doxygentypedef:: ob_property_type
+   :project: OrbbecSdk
+
+.. doxygentypedef:: OBPropertyItem
+   :project: OrbbecSdk
+
+.. doxygentypedef:: ob_property_item
+   :project: OrbbecSdk
+
+函数
+--------------------------------------------
+.. doxygenfunction:: ob_create_context
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_create_context_with_config
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_delete_context
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_query_device_list
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_set_device_changed_callback
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_enable_device_clock_sync
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_set_logger_severity
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_set_logger_to_file
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_set_logger_to_console
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_device_list_device_count
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_device_list_get_device_name
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_device_list_get_device_pid
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_device_list_get_device_vid
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_device_list_get_device_uid
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_device_list_get_device_serial_number
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_device_list_get_device
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_device_list_get_device_by_serial_number
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_device_list_get_device_by_uid
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_delete_device
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_delete_device_info
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_delete_device_list
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_device_get_device_info
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_device_get_sensor_list
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_device_get_sensor
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_device_set_int_property
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_device_get_int_property
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_device_set_float_property
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_device_get_float_property
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_device_set_bool_property
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_device_get_bool_property
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_device_set_structured_data
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_device_get_structured_data
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_device_set_raw_data
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_device_get_raw_data
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_device_get_supported_property_count
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_device_get_supported_property
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_device_is_property_supported
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_device_get_int_property_range
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_device_get_float_property_range
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_device_get_bool_property_range
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_device_write_ahb
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_device_read_ahb
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_device_write_i2c
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_device_read_i2c
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_device_write_flash
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_device_read_flash
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_device_sync_device_time
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_device_upgrade
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_device_get_device_state
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_device_state_changed
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_device_send_file_to_destination
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_device_activate_authorization
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_device_write_authorization_code
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_device_get_calibration_camera_param_list
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_device_reboot
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_device_info_name
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_device_info_pid
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_device_info_vid
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_device_info_uid
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_device_info_serial_number
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_device_info_firmware_version
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_device_info_usb_type
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_device_info_hardware_version
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_device_info_supported_min_sdk_version
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_device_info_asicName
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_device_info_device_type
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_camera_param_list_count
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_camera_param_list_get_param
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_delete_camera_param_list
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_error_status
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_error_message
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_error_function
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_error_args
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_error_exception_type
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_delete_error
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_create_pointcloud_filter
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_pointcloud_filter_set_camera_param
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_pointcloud_filter_set_point_format
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_pointcloud_filter_set_frame_align_state
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_create_format_convert_filter
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_format_convert_filter_set_format
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_filter_reset
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_filter_process
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_filter_set_callback
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_filter_push_frame
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_delete_filter
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_frame_index
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_frame_format
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_frame_get_type
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_frame_time_stamp
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_frame_time_stamp_us
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_frame_system_time_stamp
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_frame_data
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_frame_data_size
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_video_frame_width
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_video_frame_height
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_video_frame_metadata
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_video_frame_metadata_size
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_video_frame_pixel_available_bit_size
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_depth_frame_get_value_scale
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_delete_frame
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_frameset_frame_count
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_frameset_depth_frame
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_frameset_color_frame
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_frameset_ir_frame
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_frameset_points_frame
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_accel_frame_value
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_accel_frame_temperature
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_gyro_frame_value
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_gyro_frame_temperature
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_create_pipeline
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_create_pipeline_with_device
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_create_pipeline_with_playback_file
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_delete_pipeline
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_pipeline_start
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_pipeline_start_with_config
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_pipeline_start_with_callback
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_pipeline_stop
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_pipeline_get_config
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_pipeline_wait_for_frameset
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_pipeline_get_device
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_pipeline_get_playback
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_pipeline_get_stream_profile_list
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_pipeline_enable_frame_sync
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_pipeline_disable_frame_sync
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_pipeline_switch_config
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_pipeline_get_camera_param
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_get_d2c_depth_profile_list
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_get_d2c_valid_area
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_pipeline_start_record
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_pipeline_stop_record
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_create_config
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_delete_config
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_config_enable_stream
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_config_enable_all_stream
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_config_disable_stream
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_config_disable_all_stream
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_config_set_align_mode
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_create_recorder
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_create_recorder_with_device
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_delete_recorder
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_recorder_start
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_recorder_stop
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_recorder_write_frame
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_create_playback
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_delete_playback
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_playback_start
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_playback_stop
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_set_playback_state_callback
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_playback_get_device_info
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_playback_get_camera_param
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_sensor_get_type
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_sensor_get_stream_profile_list
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_sensor_start
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_sensor_stop
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_sensor_switch_profile
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_delete_sensor_list
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_sensor_list_get_sensor_count
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_sensor_list_get_sensor_type
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_sensor_list_get_sensor_by_type
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_sensor_list_get_sensor
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_delete_sensor
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_stream_profile_format
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_stream_profile_type
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_video_stream_profile_fps
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_video_stream_profile_width
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_video_stream_profile_height
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_accel_stream_profile_full_scale_range
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_accel_stream_profile_sample_rate
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_gyro_stream_profile_full_scale_range
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_gyro_stream_profile_sample_rate
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_stream_profile_list_get_video_stream_profile
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_stream_profile_list_get_profile
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_stream_profile_list_count
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_delete_stream_profile_list
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_delete_stream_profile
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_get_version
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_get_major_version
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_get_minor_version
+   :project: OrbbecSdk
+
+.. doxygenfunction:: ob_get_patch_version
+   :project: OrbbecSdk
+
diff --git a/docs/api/sphinx/reference/cxx_ref.rst b/docs/api/sphinx/reference/cxx_ref.rst
new file mode 100644
index 00000000..de400da0
--- /dev/null
+++ b/docs/api/sphinx/reference/cxx_ref.rst
@@ -0,0 +1,20 @@
+C++ API参考
+============================================
+.. doxygentypedef:: SendFileCallback
+   :project: OrbbecSdk
+
+.. doxygentypedef:: DeviceUpgradeCallback
+   :project: OrbbecSdk
+
+.. doxygentypedef:: DeviceStateChangedCallback
+   :project: OrbbecSdk
+
+.. doxygentypedef:: GetDataCallback
+   :project: OrbbecSdk
+
+.. doxygentypedef:: SetDataCallback
+   :project: OrbbecSdk
+
+.. doxygennamespace:: ob
+   :project: OrbbecSdk
+   :members:
\ No newline at end of file
diff --git a/docs/api/sphinx/reference/index.rst b/docs/api/sphinx/reference/index.rst
new file mode 100644
index 00000000..17de6138
--- /dev/null
+++ b/docs/api/sphinx/reference/index.rst
@@ -0,0 +1,9 @@
+API参考
+=============
+本文档是描述OrbbecSDK的API使用参考.
+
+.. toctree::
+
+   c_ref
+   cxx_ref
+   java_ref
\ No newline at end of file
diff --git a/docs/api/sphinx/reference/java_ref.rst b/docs/api/sphinx/reference/java_ref.rst
new file mode 100644
index 00000000..6cbbf94f
--- /dev/null
+++ b/docs/api/sphinx/reference/java_ref.rst
@@ -0,0 +1,5 @@
+Java API参考
+============================================
+.. doxygennamespace:: com::orbbec::obsensor
+   :project: OrbbecSdk
+   :members:
\ No newline at end of file
diff --git a/docs/api/sphinx/sample/OrbbecSDK_Sample_Android.rst b/docs/api/sphinx/sample/OrbbecSDK_Sample_Android.rst
new file mode 100644
index 00000000..3baed8de
--- /dev/null
+++ b/docs/api/sphinx/sample/OrbbecSDK_Sample_Android.rst
@@ -0,0 +1,3595 @@
+获取所有示例都可以在工程的OrbbecSdkExamples目录中找到
+
++----------------+----------+----------------------------------------+
+| **名称**       | **语言** | **描述**                               |
++================+==========+========================================+
+| HelloOrbbec    | Java     | 演示连接到设备获取SDK版本和设备信息    |
++----------------+----------+----------------------------------------+
+| 深度示例       | Java     | 通过Pipeline开启指定配置彩色流并渲染   |
++----------------+----------+----------------------------------------+
+| 彩色示例       | Java     | 通过Pipeline开启指定配置深度流并渲染   |
++----------------+----------+----------------------------------------+
+| 红外示例       | Java     | 通过Pipeline开启指定配置红外流并渲染   |
++----------------+----------+----------------------------------------+
+| 流对齐示例     | Java     | 演示对传感器数据流对齐的操作           |
++----------------+----------+----------------------------------------+
+| 热拔插示例     | Java     | 演示设备                               |
+|                |          | 拔插回调的设置，并获取到插拔后处理的流 |
++----------------+----------+----------------------------------------+
+| IMU示例        | Java     | 获取IMU数据并输出显示                  |
++----------------+----------+----------------------------------------+
+| 多设备示例     | Java     | 演示对多设备进行操作                   |
++----------------+----------+----------------------------------------+
+| 点云示例       | Java     | 演示生成                               |
+|                |          | 深度点云或RGBD点云并保存成ply格式文件  |
++----------------+----------+----------------------------------------+
+| 存储示例       | Java     | 获取彩色存储为png格式，深度存          |
+|                |          | 储为raw格式以及通过filter进行格式转换  |
++----------------+----------+----------------------------------------+
+| 传感器控制示例 | Java     | 演示对设备和传感器控制命令的操作       |
++----------------+----------+----------------------------------------+
+| 录制与回放示例 | Java     | :连接设备开流 ,                        |
+|                |          | 录制当                                 |
+|                |          | 前视频流到文件，载入视频文件进行回放。 |
++----------------+----------+----------------------------------------+
+
+Android
+=======
+
+HelloOrbbec
+-----------
+
+功能描述：用于演示SDK初始化、获取SDK版本、获取设备型号、获取设备序列号、获取固件版本号、SDK释放资源。
+
+首先需要创建一个Context，用于获取设备信息列表和创建设备
+
+.. code:: java
+
+   private OBContext mOBContext;
+
+初始化SDK，并监听设备变化
+
+.. code:: java
+
+   // 1.初始化SDK, 并监听设备变化
+   mOBContext = new OBContext(getApplicationContext(), new DeviceChangedCallback() {
+       @Override
+       public void onDeviceAttach(DeviceList deviceList) {
+           try {
+               StringBuilder builder = new StringBuilder();
+               // 2.查看SDK版本
+               builder.append("SDK Version = " + OBContext.getVersionName() + "\n");
+
+               // 3.获取设备个数
+               int deviceCount = deviceList.getDeviceCount();
+
+               for (int i = 0; i < deviceCount; ++i) {
+                   // 4.根据设备索引创建设备
+                   Device device = deviceList.getDevice(i);
+
+                   // 5.获取设备信息
+                   DeviceInfo info = device.getInfo();
+
+                   // 6.获取设备版本信息
+                   builder.append("Name: " + info.getName() + "\n");
+                   builder.append("Vid: " + LocalUtils.formatHex04(info.getVid()) + "\n");
+                   builder.append("Pid: " + LocalUtils.formatHex04(info.getPid()) + "\n");
+                   builder.append("Uid: " + info.getUid() + "\n");
+                   builder.append("SN: " + info.getSerialNumber() + "\n");
+                   String firmwareVersion = info.getFirmwareVersion();
+                   builder.append("FirmwareVersion: " + firmwareVersion + "\n");
+                   String hardwareVersion = info.getHardwareVersion();
+                   builder.append("HardwareVersion: " + hardwareVersion + "\n");
+
+                   // 7.遍历当前设备的传感器
+                   for (Sensor sensor : device.querySensors()) {
+                       // 8.查询传感器类型
+                       builder.append("Sensor : type = " + sensor.getType() + "\n");
+                   }
+                   runOnUiThread(() -> txtInfo.setText(builder.toString()));
+
+                   // 9.释放设备信息
+                   info.close();
+
+                   // 10.释放设备资源
+                   device.close();
+               }
+               // 11.释放设备列表资源
+               deviceList.close();
+           } catch (Exception e) {
+               e.printStackTrace();
+           }
+       }
+
+       @Override
+       public void onDeviceDetach(DeviceList deviceList) {
+           try {
+               deviceList.close();
+           } catch (Exception e) {
+               e.printStackTrace();
+           }
+       }
+   });
+
+查看SDK版本号
+
+.. code:: java
+
+   // 获取SDK版本名称
+   String version = OBContext.getVersionName();
+   // 获取SDK内核版本名称(Orbbec SDK so的版本)
+   String coreVersion = OBContext.getCoreVersionName();
+
+通过回调可得到设备索引，根据设备索引创建设备，此处以创建第一个设备为例
+
+.. code:: java
+
+   Device device = deviceList.getDevice(0);
+
+接下来就可以获取和这个设备相关的信息了，下面这些信息都可以通过DeviceInfo来获取
+
+.. code:: java
+
+   // 5.获取设备信息
+   DeviceInfo info = device.getInfo();
+
+   // 6.获取设备版本信息
+   builder.append("Name: " + info.getName() + "\n");
+   builder.append("Vid: " + LocalUtils.formatHex04(info.getVid()) + "\n");
+   builder.append("Pid: " + LocalUtils.formatHex04(info.getPid()) + "\n");
+   builder.append("Uid: " + info.getUid() + "\n");
+   builder.append("SN: " + info.getSerialNumber() + "\n");
+   String firmwareVersion = info.getFirmwareVersion();
+   builder.append("FirmwareVersion: " + firmwareVersion + "\n");
+   String hardwareVersion = info.getHardwareVersion();
+   builder.append("HardwareVersion: " + hardwareVersion + "\n");
+
+   // 7.遍历当前设备的传感器
+   for (Sensor sensor : device.querySensors()) {
+       // 8.查询传感器类型
+       builder.append("Sensor : type = " + sensor.getType() + "\n");
+   }
+   runOnUiThread(() -> txtInfo.setText(builder.toString()));
+
+   // 9.释放设备信息
+   info.close();
+
+遍历传感器类型
+
+.. code:: java
+
+   for (Sensor sensor : device.querySensors()) {
+       // 查询传感器类型
+       Log.d(TAG,"Sensor : type = " + sensor.getType() + "\n");
+   }
+
+资源释放
+
+.. code:: java
+
+   // 关闭设备
+   device.close();
+
+   // 释放SDK
+   if (null != mOBContext) {
+       mOBContext.close();
+       mOBContext = null;
+   }
+
+彩色示例-ColorViewer
+--------------------
+
+功能描述：本示例主要演示了SDK的初始化、设备创建、Pipeline的初始化及配置以及通过Pipeline开启指定配置彩色流并渲染。
+
+首先需要创建一个Context，用于获取设备信息列表和创建设备
+
+.. code:: java
+
+   private OBContext mOBContext;
+
+初始化SDK，并监听设备变化
+
+.. code:: java
+
+   // 1.初始化SDK, 并监听设备变化
+   mOBContext = new OBContext(getApplicationContext(), new DeviceChangedCallback() {
+       @Override
+       public void onDeviceAttach(DeviceList deviceList) {
+           try {
+               if (null == mPipeline) {
+                   // 2.创建Device，并通过Device初始化Pipeline
+                   mDevice = deviceList.getDevice(0);
+                   mPipeline = new Pipeline(mDevice);
+
+                   // 3.创建Pipeline配置
+                   Config config = new Config();
+
+                   // 4.获取彩色流配置，并配置到Config，这里配置为640x480 YUYV格式或者是640x480 I420格式
+                   StreamProfileList colorProfileList = mPipeline.getStreamProfileList(SensorType.COLOR);
+                   StreamProfile streamProfile = null;
+                   if (null != colorProfileList) {
+                       streamProfile = colorProfileList.getVideoStreamProfile(640, 480, Format.YUYV, 0);
+
+                       if (null == streamProfile) {
+                           streamProfile = colorProfileList.getVideoStreamProfile(640, 480, Format.I420, 0);
+                       }
+
+                       colorProfileList.close();
+                   }
+
+                   if (streamProfile == null) {
+                       return;
+                   }
+
+                   // 5.如果配置格式为I420,则创建格式转换filter，用于将I420格式转换为RGB888格式来进行渲染
+                   if (streamProfile.getFormat() == Format.I420) {
+                       mFormatConvertFilter = new FormatConvertFilter();
+                       mFormatConvertFilter.setFormatType(FormatConvertType.FORMAT_I420_TO_RGB888);
+                   }
+
+                   // 6.使能彩色配置
+                   config.enableStream(streamProfile);
+
+                   // 7.设置镜像
+                   if (mDevice.isPropertySupported(DeviceProperty.OB_PROP_COLOR_MIRROR_BOOL, PermissionType.OB_PERMISSION_WRITE)) {
+                       mDevice.setPropertyValueB(DeviceProperty.OB_PROP_COLOR_MIRROR_BOOL, true);
+                   }
+
+                   // 8.开流
+                   mPipeline.start(config);
+
+                   // 9.释放config
+                   config.close();
+
+                   // 10.释放streamProfile
+                   streamProfile.close();
+
+                   // 11.创建获取Pipeline数据线程
+                   start();
+               }
+
+               // 12.释放设备列表资源
+               deviceList.close();
+           } catch (Exception e) {
+               e.printStackTrace();
+           }
+       }
+
+       @Override
+       public void onDeviceDetach(DeviceList deviceList) {
+           try {
+               deviceList.close();
+           } catch (Exception e) {
+               e.printStackTrace();
+           }
+       }
+   });
+
+创建设备并通过设备创建Pipeline
+
+.. code:: java
+
+   // 2.创建Device，并通过Device初始化Pipeline
+   mDevice = deviceList.getDevice(0);
+   mPipeline = new Pipeline(mDevice);
+
+创建Pipeline配置
+
+.. code:: java
+
+   // 3.创建Pipeline配置
+   Config config = new Config();
+
+获取彩色流配置，并配置到Config，这里配置为640x480 YUYV格式或者是640x480
+I420格式
+
+.. code:: java
+
+   // 4.获取彩色流配置，并配置到Config，这里配置为640x480 YUYV格式或者是640x480 I420格式
+   StreamProfileList colorProfileList = mPipeline.getStreamProfileList(SensorType.COLOR);
+   StreamProfile streamProfile = null;
+   if (null != colorProfileList) {
+       streamProfile = colorProfileList.getVideoStreamProfile(640, 480, Format.YUYV, 0);
+
+       if (null == streamProfile) {
+           streamProfile = colorProfileList.getVideoStreamProfile(640, 480, Format.I420, 0);
+       }
+
+       colorProfileList.close();
+   }
+
+   if (streamProfile == null) {
+       return;
+   }
+
+   // 5.如果配置格式为I420,则创建格式转换filter，用于将I420格式转换为RGB888格式来进行渲染
+   if (streamProfile.getFormat() == Format.I420) {
+       mFormatConvertFilter = new FormatConvertFilter();
+       mFormatConvertFilter.setFormatType(FormatConvertType.FORMAT_I420_TO_RGB888);
+   }
+
+   // 6.使能彩色配置
+   config.enableStream(streamProfile);
+
+通过Device属性接口设置镜像
+
+.. code:: java
+
+   // 7.设置镜像
+   if (mDevice.isPropertySupported(DeviceProperty.OB_PROP_COLOR_MIRROR_BOOL, PermissionType.OB_PERMISSION_WRITE)) {
+       mDevice.setPropertyValueB(DeviceProperty.OB_PROP_COLOR_MIRROR_BOOL, true);
+   }
+
+使用Config配置通过Pipeline开流，并释放局部资源
+
+.. code:: java
+
+   // 8.开流
+   mPipeline.start(config);
+
+   // 9.释放config
+   config.close();
+
+   // 10.释放streamProfile
+   streamProfile.close();
+
+创建获取Pipeline数据线程
+
+.. code:: java
+
+   private void start() {
+       mIsStreamRunning = true;
+       if (null == mStreamThread) {
+           mStreamThread = new Thread(mStreamRunnable);
+           mStreamThread.start();
+       }
+   }
+
+阻塞方式获取数据集，等待100ms后如果获取不到，则超时
+
+.. code:: java
+
+   FrameSet frameSet = mPipeline.waitForFrameSet(100);
+
+数据处理及渲染
+
+.. code:: java
+
+   // 获取彩色流数据
+   ColorFrame colorFrame = frameSet.getColorFrame();
+
+   // 数据处理及渲染
+   if (null != colorFrame) {
+       if (colorFrame.getFormat() == Format.I420) {
+           // 通过filter将I420格式的彩色数据帧转换为RGB888格式的数据帧
+           Frame frame = mFormatConvertFilter.process(colorFrame);
+           if (null != frame) {
+               // 获取数据并进行渲染
+               byte[] frameData = new byte[colorFrame.getWidth() * colorFrame.getHeight() * 3];
+               frame.getData(frameData);
+               mColorView.update(frameData, colorFrame.getWidth(), colorFrame.getHeight(), StreamType.COLOR, Format.RGB888);
+               frame.close();
+           }
+       } else {
+           // 获取数据并进行渲染
+           byte[] frameData = new byte[colorFrame.getDataSize()];
+           colorFrame.getData(frameData);
+           mColorView.update(frameData, colorFrame.getWidth(), colorFrame.getHeight(), StreamType.COLOR, colorFrame.getFormat());
+       }
+
+       // 释放彩色数据帧
+       colorFrame.close();
+   }
+   // 释放数据集
+   frameSet.close();
+
+停止获取Pipeline数据
+
+.. code:: java
+
+   private void stop() {
+       mIsStreamRunning = false;
+       if (null != mStreamThread) {
+           try {
+               mStreamThread.join(300);
+           } catch (InterruptedException e) {
+           }
+           mStreamThread = null;
+       }
+   }
+
+资源释放
+
+.. code:: java
+
+   // 释放filter资源
+   if (null != mFormatConvertFilter) {
+       try {
+           mFormatConvertFilter.close();
+       } catch (Exception e) {
+           e.printStackTrace();
+       }
+
+   }
+
+   // 停止Pipeline，并释放
+   if (null != mPipeline) {
+       mPipeline.stop();
+       mPipeline.close();
+   }
+
+   // 释放Device
+   if (mDevice != null) {
+       mDevice.close();
+   }
+
+   // 释放SDK
+   if (null != mOBContext) {
+       mOBContext.close();
+   }
+
+   // 释放渲染窗口资源
+   if (mColorView != null) {
+       mColorView.release();
+   }
+
+深度示例-DepthViewer
+--------------------
+
+功能描述：本示例主要演示了SDK的初始化、设备创建、Pipeline的初始化及配置以及通过Pipeline开启指定配置深度流并渲染。
+
+首先需要创建一个Context，用于获取设备信息列表和创建设备
+
+.. code:: java
+
+   private OBContext mOBContext;
+
+初始化SDK，并监听设备变化
+
+.. code:: java
+
+   // 1.初始化SDK, 并监听设备变化
+   mOBContext = new OBContext(getApplicationContext(), new DeviceChangedCallback() {
+       @Override
+       public void onDeviceAttach(DeviceList deviceList) {
+           try {
+               if (null == mPipeline) {
+                   // 2.创建Device, 并通过Device初始化Pipeline
+                   mDevice = deviceList.getDevice(0);
+                   mPipeline = new Pipeline(mDevice);
+
+                   // 3.创建Pipeline配置
+                   Config config = new Config();
+
+                   // 4.获取深度流配置，并配置到Config,这里配置的为640x480 Y16格式
+                   StreamProfileList depthProfileList = mPipeline.getStreamProfileList(SensorType.DEPTH);
+                   StreamProfile streamProfile = null;
+
+                   if (null != depthProfileList) {
+                       streamProfile = depthProfileList.getVideoStreamProfile(640, 480, Format.Y16, 30);
+                       depthProfileList.close();
+                   }
+
+                   if (streamProfile == null) {
+                       return;
+                   }
+
+                   // 5.使能深度流配置
+                   config.enableStream(streamProfile);
+
+                   // 6.设置镜像
+                   if (mDevice.isPropertySupported(DeviceProperty.OB_PROP_DEPTH_MIRROR_BOOL, PermissionType.OB_PERMISSION_WRITE)) {
+                       mDevice.setPropertyValueB(DeviceProperty.OB_PROP_DEPTH_MIRROR_BOOL, true);
+                   }
+
+                   // 7.开流
+                   mPipeline.start(config);
+
+                   // 8.释放config
+                   config.close();
+
+                   // 9.释放streamProfile
+                   streamProfile.close();
+
+                   // 10.创建获取Pipeline数据线程
+                   start();
+               }
+               // 11.释放设备列表资源
+               deviceList.close();
+           } catch (Exception e) {
+               e.printStackTrace();
+           }
+       }
+
+       @Override
+       public void onDeviceDetach(DeviceList deviceList) {
+           try {
+               deviceList.close();
+           } catch (Exception e) {
+               e.printStackTrace();
+           }
+       }
+   });
+
+创建设备并通过设备创建Pipeline
+
+.. code:: java
+
+   // 2.创建Device, 并通过Device初始化Pipeline
+   mDevice = deviceList.getDevice(0);
+   mPipeline = new Pipeline(mDevice);
+
+创建Pipeline配置
+
+.. code:: java
+
+   Config config = new Config();
+
+获取深度流配置，并配置到Config，这里配置的为640x480 Y16格式
+
+.. code:: java
+
+   // 4.获取深度流配置，并配置到Config,这里配置的为640x480 Y16格式
+   StreamProfileList depthProfileList = mPipeline.getStreamProfileList(SensorType.DEPTH);
+   StreamProfile streamProfile = null;
+
+   if (null != depthProfileList) {
+       streamProfile = depthProfileList.getVideoStreamProfile(640, 480, Format.Y16, 30);
+       depthProfileList.close();
+   }
+
+   if (streamProfile == null) {
+       return;
+   }
+
+   // 5.使能深度流配置
+   config.enableStream(streamProfile);
+
+通过Device属性接口设置镜像
+
+.. code:: java
+
+   // 6.设置镜像
+   if (mDevice.isPropertySupported(DeviceProperty.OB_PROP_DEPTH_MIRROR_BOOL, PermissionType.OB_PERMISSION_WRITE)) {
+       mDevice.setPropertyValueB(DeviceProperty.OB_PROP_DEPTH_MIRROR_BOOL, true);
+   }
+
+使用Config配置通过Pipeline开流，并释放局部资源
+
+.. code:: java
+
+   mPipeline.start(config);
+
+   // 8.释放config
+   config.close();
+
+   // 9.释放streamProfile
+   streamProfile.close();
+
+创建获取Pipeline数据线程
+
+.. code:: java
+
+   private void start() {
+       mIsStreamRunning = true;
+       if (null == mStreamThread) {
+           mStreamThread = new Thread(mStreamRunnable);
+           mStreamThread.start();
+       }
+   }
+
+阻塞方式获取数据集，等待100ms后如果获取不到，则超时
+
+.. code:: java
+
+   // 等待100ms后如果获取不到，则超时
+   FrameSet frameSet = mPipeline.waitForFrameSet(100);
+
+数据处理及渲染
+
+.. code:: java
+
+   // 获取深度流数据
+   DepthFrame frame = frameSet.getDepthFrame();
+
+   if (frame != null) {
+       // 获取深度数据并进行渲染
+       byte[] frameData = new byte[frame.getDataSize()];
+       frame.getData(frameData);
+       mDepthView.update(frameData, frame.getWidth(), frame.getHeight(), StreamType.DEPTH, frame.getFormat());
+
+       // 释放深度数据帧
+       frame.close();
+   }
+
+   // 释放数据集
+   frameSet.close();
+
+停止获取Pipeline数据
+
+.. code:: java
+
+   private void stop() {
+       mIsStreamRunning = false;
+       if (null != mStreamThread) {
+           try {
+               mStreamThread.join(300);
+           } catch (InterruptedException e) {
+           }
+           mStreamThread = null;
+       }
+   }
+
+资源释放
+
+.. code:: java
+
+   // 停止Pipeline，并释放
+   if (null != mPipeline) {
+       mPipeline.stop();
+       mPipeline.close();
+   }
+
+   // 释放Device
+   if (mDevice != null) {
+       mDevice.close();
+   }
+
+   // 释放SDK
+   if (null != mOBContext) {
+       mOBContext.close();
+   }
+
+   // 释放渲染窗口资源
+   if (mDepthView != null) {
+       mDepthView.release();
+   }
+
+红外示例-InfraredViewer
+-----------------------
+
+功能描述：本示例主要演示了SDK的初始化、设备创建、Pipeline的初始化及配置以及通过Pipeline开启指定配置红外流并渲染。
+
+首先需要创建一个Context，用于获取设备信息列表和创建设备
+
+.. code:: java
+
+   private OBContext mOBContext;
+
+初始化SDK，并监听设备变化
+
+.. code:: java
+
+   // 1.初始化SDK, 并监听设备变化
+   mOBContext = new OBContext(getApplicationContext(), new DeviceChangedCallback() {
+       @Override
+       public void onDeviceAttach(DeviceList deviceList) {
+           try {
+               if (null == mPipeline) {
+                   // 2.创建Device, 并通过Device初始化Pipeline
+                   mDevice = deviceList.getDevice(0);
+                   mPipeline = new Pipeline(mDevice);
+
+                   // 3.创建Pipeline配置
+                   Config config = new Config();
+
+                   // 4.获取流配置，并配置到Config
+                   StreamProfileList irProfileList = mPipeline.getStreamProfileList(SensorType.IR);
+                   StreamProfile streamProfile = null;
+                   if (null != irProfileList) {
+                       streamProfile = irProfileList.getVideoStreamProfile(640, 480, Format.Y16, 30);
+                       irProfileList.close();
+                   }
+
+                   if (streamProfile == null) {
+                       return;
+                   }
+
+                   // 5.使能红外流配置
+                   config.enableStream(streamProfile);
+
+                   // 6.设置镜像
+                   if (mDevice.isPropertySupported(DeviceProperty.OB_PROP_IR_MIRROR_BOOL, PermissionType.OB_PERMISSION_READ)) {
+                       mDevice.setPropertyValueB(DeviceProperty.OB_PROP_IR_MIRROR_BOOL, true);
+                   }
+
+                   // 7.开流
+                   mPipeline.start(config);
+
+                   // 8.释放config
+                   config.close();
+
+                   // 9.释放streamProfile
+                   streamProfile.close();
+
+                   // 10.创建获取Pipeline数据线程
+                   start();
+               }
+               // 11.释放设备列表资源
+               deviceList.close();
+           } catch (Exception e) {
+               e.printStackTrace();
+           }
+       }
+
+       @Override
+       public void onDeviceDetach(DeviceList deviceList) {
+           try {
+               deviceList.close();
+           } catch (Exception e) {
+               e.printStackTrace();
+           }
+       }
+   });
+
+创建设备并通过设备创建Pipeline
+
+.. code:: java
+
+   // 2.创建Device, 并通过Device初始化Pipeline
+   mDevice = deviceList.getDevice(0);
+   mPipeline = new Pipeline(mDevice);
+
+创建Pipeline配置
+
+.. code:: java
+
+   // 3.创建Pipeline配置
+   Config config = new Config();
+
+获取红外流配置，并配置到Config，这里配置的为640x480 Y16格式
+
+.. code:: java
+
+   // 4.获取流配置，并配置到Config
+   StreamProfileList irProfileList = mPipeline.getStreamProfileList(SensorType.IR);
+   StreamProfile streamProfile = null;
+   if (null != irProfileList) {
+       streamProfile = irProfileList.getVideoStreamProfile(640, 480, Format.Y16, 30);
+       irProfileList.close();
+   }
+
+   if (streamProfile == null) {
+       return;
+   }
+
+   // 5.使能红外流配置
+   config.enableStream(streamProfile);
+
+通过Device属性接口设置镜像
+
+.. code:: java
+
+   // 6.设置镜像
+   if (mDevice.isPropertySupported(DeviceProperty.OB_PROP_IR_MIRROR_BOOL, PermissionType.OB_PERMISSION_READ)) {
+       mDevice.setPropertyValueB(DeviceProperty.OB_PROP_IR_MIRROR_BOOL, true);
+   }
+
+使用Config配置通过Pipeline开流，并释放局部资源
+
+.. code:: java
+
+   // 7.开流
+   mPipeline.start(config);
+
+   // 8.释放config
+   config.close();
+
+   // 9.释放streamProfile
+   streamProfile.close();
+
+创建获取Pipeline数据线程
+
+.. code:: java
+
+   private void start() {
+       mIsStreamRunning = true;
+       if (null == mStreamThread) {
+           mStreamThread = new Thread(mStreamRunnable);
+           mStreamThread.start();
+       }
+   }
+
+阻塞方式获取数据集，等待100ms后如果获取不到，则超时
+
+.. code:: java
+
+   // 等待100ms后如果获取不到，则超时
+   FrameSet frameSet = mPipeline.waitForFrameSet(100);
+
+数据处理及渲染
+
+.. code:: java
+
+   // 获取红外流数据
+   IRFrame frame = frameSet.getIrFrame();
+
+   if (frame != null) {
+       // 获取红外数据并进行渲染
+       byte[] frameData = new byte[frame.getDataSize()];
+       frame.getData(frameData);
+       mIrView.update(frameData, frame.getWidth(), frame.getHeight(), StreamType.IR, frame.getFormat());
+
+       // 释放红外数据帧
+       frame.close();
+   }
+
+   // 释放数据集
+   frameSet.close();
+
+停止获取Pipeline数据
+
+.. code:: java
+
+   private void stop() {
+       mIsStreamRunning = false;
+       if (null != mStreamThread) {
+           try {
+               mStreamThread.join(300);
+           } catch (InterruptedException e) {
+           }
+           mStreamThread = null;
+       }
+   }
+
+资源释放
+
+.. code:: java
+
+   // 停止Pipeline，并释放
+   if (null != mPipeline) {
+       mPipeline.stop();
+       mPipeline.close();
+   }
+
+   if (null != mDevice) {
+       mDevice.close();
+   }
+
+   // 释放SDK
+   if (null != mOBContext) {
+       mOBContext.close();
+   }
+
+   // 释放渲染窗口资源
+   if (null != mIrView) {
+       mIrView.release();
+   }
+
+流对齐示例-SyncAlignViewer
+--------------------------
+
+功能描述：本示例主要演示了对数据流控制对齐的操作。
+
+首先需要创建一个Context，用于获取设备信息列表和创建设备
+
+.. code:: java
+
+   private OBContext mOBContext;
+
+初始化SDK，并监听设备变化
+
+.. code:: java
+
+   // 1.初始化SDK, 并监听设备变化
+   mOBContext = new OBContext(this, new DeviceChangedCallback() {
+       @Override
+       public void onDeviceAttach(DeviceList deviceList) {
+           try {
+               if (null == mPipeline) {
+                   // 2.获取Device并通过Device创建Pipeline
+                   mDevice = deviceList.getDevice(0);
+                   mPipeline = new Pipeline(mDevice);
+
+                   // 3.创建格式转换filter，用于将I420格式的数据转换为RGB888格式
+                   mFormatConvertFilter = new FormatConvertFilter();
+                   mFormatConvertFilter.setFormatType(FormatConvertType.FORMAT_I420_TO_RGB888);
+
+                   // 4.创建Pipeline配置
+                   mConfig = new Config();
+
+                   // 5.默认关闭D2C
+                   mConfig.setAlignMode(AlignMode.ALIGN_D2C_DISABLE);
+
+                   // 6.获取指定格式的彩色流配置
+                   StreamProfileList colorProfileList = mPipeline.getStreamProfileList(SensorType.COLOR);
+                   StreamProfile colorStreamProfile = null;
+                   if (null != colorProfileList) {
+                       colorStreamProfile = colorProfileList.getVideoStreamProfile(640, 480, Format.YUYV, 0);
+                       if (null == colorStreamProfile) {
+                           colorStreamProfile = colorProfileList.getVideoStreamProfile(640, 480, Format.I420, 0);
+                       }
+                       colorProfileList.close();
+                   }
+
+                   if (colorStreamProfile == null) {
+                       return;
+                   }
+
+                   // 7.使能彩色流配置
+                   mConfig.enableStream(colorStreamProfile);
+
+                   // 8.获取深度流配置
+                   StreamProfileList depthProfileList = mPipeline.getStreamProfileList(SensorType.DEPTH);
+                   StreamProfile depthStreamProfile = null;
+                   if (null != depthProfileList) {
+                       depthStreamProfile = depthProfileList.getVideoStreamProfile(640, 480, Format.Y16, 30);
+                       depthProfileList.close();
+                   }
+
+                   if (depthStreamProfile == null) {
+                       return;
+                   }
+
+                   // 9.使能深度流配置
+                   mConfig.enableStream(depthStreamProfile);
+
+                   // 10.通过config开流
+                   mPipeline.start(mConfig);
+
+                   // 11.释放colorStreamProfile
+                   colorStreamProfile.close();
+
+                   // 12.释放depthStreamProfile
+                   depthStreamProfile.close();
+
+                   // 13.创建获取Pipeline数据线程
+                   start();
+               }
+
+               // 14.释放设备列表资源
+               deviceList.close();
+           } catch (Exception e) {
+               e.printStackTrace();
+           }
+       }
+
+       @Override
+       public void onDeviceDetach(DeviceList deviceList) {
+           try {
+               deviceList.close();
+           } catch (Exception e) {
+               e.printStackTrace();
+           }
+       }
+   });
+
+创建设备并通过设备创建Pipeline
+
+.. code:: java
+
+   // 2.获取Device并通过Device创建Pipeline
+   mDevice = deviceList.getDevice(0);
+   mPipeline = new Pipeline(mDevice);
+
+创建Pipeline配置
+
+.. code:: java
+
+   mConfig = new Config();
+
+创建格式转换filter，用于将I420格式的数据转换为RGB888格式
+
+.. code:: java
+
+   // 3.创建格式转换filter，用于将I420格式的数据转换为RGB888格式
+   mFormatConvertFilter = new FormatConvertFilter();
+   mFormatConvertFilter.setFormatType(FormatConvertType.FORMAT_I420_TO_RGB888);
+
+创建Pipeline配置
+
+.. code:: java
+
+   // 4.创建Pipeline配置
+   mConfig = new Config();
+
+默认关闭D2C
+
+.. code:: java
+
+   // 5.默认关闭D2C
+   mConfig.setAlignMode(AlignMode.ALIGN_D2C_DISABLE);
+
+获取彩色流配置，并配置到Config，这里配置为640x480 YUYV格式或者是640x480
+I420格式
+
+.. code:: java
+
+   // 6.获取指定格式的彩色流配置
+   StreamProfileList colorProfileList = mPipeline.getStreamProfileList(SensorType.COLOR);
+   StreamProfile colorStreamProfile = null;
+   if (null != colorProfileList) {
+       colorStreamProfile = colorProfileList.getVideoStreamProfile(640, 480, Format.YUYV, 0);
+       if (null == colorStreamProfile) {
+           colorStreamProfile = colorProfileList.getVideoStreamProfile(640, 480, Format.I420, 0);
+       }
+       colorProfileList.close();
+   }
+
+   if (colorStreamProfile == null) {
+       return;
+   }
+
+   // 7.使能彩色流配置
+   mConfig.enableStream(colorStreamProfile);
+
+获取深度流配置，并配置到Config，这里配置为640x480 Y16格式
+
+.. code:: java
+
+   // 8.获取深度流配置
+   StreamProfileList depthProfileList = mPipeline.getStreamProfileList(SensorType.DEPTH);
+   StreamProfile depthStreamProfile = null;
+   if (null != depthProfileList) {
+       depthStreamProfile = depthProfileList.getVideoStreamProfile(640, 480, Format.Y16, 30);
+       depthProfileList.close();
+   }
+
+   if (depthStreamProfile == null) {
+       return;
+   }
+
+   // 9.使能深度流配置
+   mConfig.enableStream(depthStreamProfile);
+
+使用Config配置通过Pipeline开流，并释放局部资源
+
+.. code:: java
+
+   // 10.通过config开流
+   mPipeline.start(mConfig);
+
+   // 11.释放colorStreamProfile
+   colorStreamProfile.close();
+
+   // 12.释放depthStreamProfile
+   depthStreamProfile.close();
+
+创建获取Pipeline数据线程
+
+.. code:: java
+
+   private void start() {
+       mIsStreamRunning = true;
+       if (null == mStreamThread) {
+           mStreamThread = new Thread(mStreamRunnable);
+           mStreamThread.start();
+       }
+   }
+
+阻塞方式获取数据集，等待100ms后如果获取不到，则超时
+
+.. code:: java
+
+   // 等待100ms后如果获取不到，则超时
+   FrameSet frameSet = mPipeline.waitForFrameSet(100);
+
+获取彩色数据及深度数据
+
+.. code:: java
+
+   // 获取深度流数据
+   DepthFrame depthFrame = frameSet.getDepthFrame();
+
+   // 获取彩色流数据
+   ColorFrame colorFrame = frameSet.getColorFrame();
+
+数据处理及渲染，并释放局部资源
+
+.. code:: java
+
+   if (null != depthFrame && null != colorFrame) {
+       //深度转RGB888
+       ByteBuffer depthSrcBytebuffer = ByteBuffer.allocateDirect(depthFrame.getDataSize());
+       depthSrcBytebuffer.rewind();
+       byte[] depthSrcBytes = new byte[depthFrame.getDataSize()];
+       depthFrame.getData(depthSrcBytes);
+       depthSrcBytebuffer.put(depthSrcBytes);
+
+       ByteBuffer depthDstBytebuffer = ByteBuffer.allocateDirect(depthFrame.getWidth() * depthFrame.getHeight() * 3);
+       YuvUtil.depth2RGB888(depthSrcBytebuffer, depthDstBytebuffer, depthFrame.getWidth(), depthFrame.getHeight(), 1);
+       depthData = new byte[depthFrame.getWidth() * depthFrame.getHeight() * 3];
+       depthDstBytebuffer.get(depthData, 0, depthData.length);
+
+       if (colorFrame.getFormat() == Format.I420) {
+           // I420格式数据转RGB888
+           Frame frame = mFormatConvertFilter.process(colorFrame);
+           if (null != frame) {
+               colorData = new byte[colorFrame.getWidth() * colorFrame.getHeight() * 3];
+               frame.getData(colorData);
+
+               // 释放数据帧
+               frame.close();
+           }
+       } else {
+           // YUYV格式数据转RGB888
+           ByteBuffer colorSrcBytebuffer = ByteBuffer.allocateDirect(colorFrame.getDataSize());
+           colorSrcBytebuffer.rewind();
+           byte[] colorSrcBytes = new byte[colorFrame.getDataSize()];
+           colorFrame.getData(colorSrcBytes);
+           colorSrcBytebuffer.put(colorSrcBytes);
+
+           ByteBuffer colorDstBytebuffer = ByteBuffer.allocateDirect(colorFrame.getWidth() * colorFrame.getHeight() * 3);
+           YuvUtil.yuyv2Rgb888(colorSrcBytebuffer, colorDstBytebuffer, colorFrame.getWidth() * colorFrame.getHeight() * 3);
+           colorData = new byte[colorFrame.getWidth() * colorFrame.getHeight() * 3];
+           colorDstBytebuffer.get(colorData, 0, colorData.length);
+       }
+   }
+
+   if (depthData != null && colorData != null) {
+       byte[] depthColorData = depthToColor(depthData, colorData, 640, 480, mAlpha);
+       mColorView.update(depthColorData, 640, 480, StreamType.COLOR, Format.RGB888);
+   }
+
+   // 释放深度帧
+   if (null != depthFrame) {
+       depthFrame.close();
+   }
+
+   // 释放彩色帧
+   if (null != colorFrame) {
+       colorFrame.close();
+   }
+
+   // 释放数据集
+   frameSet.close();
+
+设置帧同步
+
+.. code:: java
+
+   // 设置帧同步
+   private void setSync(boolean isChecked) {
+       try {
+           if (isChecked) {
+               mPipeline.enableFrameSync();
+           } else {
+               mPipeline.disableFrameSync();
+           }
+       } catch (Exception e) {
+           e.printStackTrace();
+       }
+   }
+
+设置D2C
+
+.. code:: java
+
+   // 设置D2C
+   private void setAlignToColor(boolean isChecked, boolean isHardware) {
+       try {
+           if (mPipeline == null || mDevice == null) {
+               return;
+           }
+           try {
+               if (isChecked) {
+                   mConfig.setAlignMode((isHardware ? AlignMode.ALIGN_D2C_HW_ENABLE : AlignMode.ALIGN_D2C_SW_ENABLE));
+               } else {
+                   mConfig.setAlignMode(AlignMode.ALIGN_D2C_DISABLE);
+               }
+               mPipeline.switchConfig(mConfig);
+           } catch (Exception e) {
+               Log.w(TAG, "setAlignToColor: " + e.getMessage());
+           }
+       } catch (Exception e) {
+           e.printStackTrace();
+       }
+   }
+
+停止获取Pipeline数据
+
+.. code:: java
+
+   private void stop() {
+       mIsStreamRunning = false;
+       if (null != mStreamThread) {
+           try {
+               mStreamThread.join(300);
+           } catch (InterruptedException e) {
+           }
+       }
+   }
+
+资源释放
+
+.. code:: java
+
+   // 停止Pipeline，并关闭
+   if (null != mPipeline) {
+       mPipeline.stop();
+       mPipeline.close();
+   }
+
+   // 释放格式转换filter
+   if (null != mFormatConvertFilter) {
+       try {
+           mFormatConvertFilter.close();
+       } catch (Exception e) {
+       }
+       mFormatConvertFilter = null;
+   }
+
+   // 释放Config
+   if (null != mConfig) {
+       mConfig.close();
+   }
+
+   // 释放Device
+   if (null != mDevice) {
+       mDevice.close();
+   }
+
+   // 释放SDK
+   if (null != mOBContext) {
+       mOBContext.close();
+   }
+
+   // 释放渲染窗口资源
+   if (null != mColorView) {
+       mColorView.release();
+   }
+
+热拔插示例-HotPlugin
+--------------------
+
+功能描述：本示例主要演示设备拔插回调的设置，以及拔插之后处理获取到的流
+
+首先需要创建一个Context，用于获取设备信息列表和创建设备
+
+.. code:: java
+
+   private OBContext mOBContext;
+
+定义Color的FrameCallback
+
+.. code:: java
+
+   private FrameCallback mColorFrameCallback = frame -> {
+       printFrameInfo(frame.as(FrameType.COLOR), mColorFps);
+
+       // 释放frame资源
+       frame.close();
+   };
+
+定义Depth的FrameCallback
+
+.. code:: java
+
+   private FrameCallback mColorFrameCallback = frame -> {
+       printFrameInfo(frame.as(FrameType.COLOR), mColorFps);
+
+       // 释放frame资源
+       frame.close();
+   };
+
+定义IR的FrameCallback
+
+.. code:: java
+
+   private FrameCallback mIrFrameCallback = frame -> {
+       printFrameInfo(frame.as(FrameType.IR), mIrFps);
+
+       // 释放frame资源
+       frame.close();
+   };
+
+打印数据帧信息
+
+.. code:: java
+
+   private void printFrameInfo(VideoFrame frame, int fps) {
+       try {
+           String frameInfo = "FrameType:" + frame.getStreamType()
+                   + ", index:" + frame.getFrameIndex()
+                   + ", width:" + frame.getWidth()
+                   + ", height:" + frame.getHeight()
+                   + ", format:" + frame.getFormat()
+                   + ", fps:" + fps
+                   + ", timeStampUs:" + frame.getTimeStampUs();
+           if (frame.getStreamType() == FrameType.DEPTH) {
+               frameInfo += ", middlePixelValue:" + getMiddlePixelValue(frame);
+           }
+           Log.i(TAG, frameInfo);
+       } catch (Exception e) {
+           e.printStackTrace();
+       }
+   }
+
+初始化SDK，并监听设备变化
+
+.. code:: java
+
+   // 1.初始化SDK, 并监听设备变化
+   mOBContext = new OBContext(getApplicationContext(), new DeviceChangedCallback() {
+       @Override
+       public void onDeviceAttach(DeviceList deviceList) {
+           try {
+               if (deviceList == null || deviceList.getDeviceCount() <= 0) {
+                   setText(mNameTv, "No device connected !");
+               }
+
+               // 2.创建设备，并获取设备名称
+               mDevice = deviceList.getDevice(0);
+               DeviceInfo devInfo = mDevice.getInfo();
+               String deviceName = devInfo.getName();
+               setText(mNameTv, deviceName);
+               devInfo.close();
+
+               // 3.获取深度传感器
+               mDepthSensor = mDevice.getSensor(SensorType.DEPTH);
+
+               // 4.打开深度流，profile传入null，表示使用配置文件中配置的参数开流，
+               // 如果设备中没有该配置，或不存在配置文件，则表示使用Profile列表中的第一个配置
+               if (null != mDepthSensor) {
+                   mDepthSensor.start(null, mDepthFrameCallback);
+               }
+
+               // 5.获取彩色传感器
+               mColorSensor = mDevice.getSensor(SensorType.COLOR);
+
+               // 6.打开彩色流，profile传入null，表示使用配置文件中配置的参数开流，
+               // 如果设备中没有该配置，或不存在配置文件，则表示使用Profile列表中的第一个配置
+               if (null != mColorSensor) {
+                   mColorSensor.start(null, mColorFrameCallback);
+               }
+
+               // 7.获取红外传感器
+               mIrSensor = mDevice.getSensor(SensorType.IR);
+
+               // 8.打开红外流，profile传入null，表示使用配置文件中配置的参数开流，
+               // 如果设备中没有该配置，或不存在配置文件，则表示使用Profile列表中的第一个配置
+               if (null != mIrSensor) {
+                   mIrSensor.start(null, mIrFrameCallback);
+               }
+
+               // 9.更新开流配置信息
+               setText(mProfileInfoTv, formatProfileInfo());
+
+               // 10.释放deviceList资源
+               deviceList.close();
+           } catch (Exception e) {
+               e.printStackTrace();
+           }
+       }
+
+       @Override
+       public void onDeviceDetach(DeviceList deviceList) {
+           try {
+               setText(mNameTv, "No device connected !");
+               setText(mProfileInfoTv, "");
+
+               mDepthFps = 0;
+               mColorFps = 0;
+               mIrFps = 0;
+
+               // 停止深度流
+               if (null != mDepthSensor) {
+                   mDepthSensor.stop();
+               }
+
+               // 停止彩色流
+               if (null != mColorSensor) {
+                   mColorSensor.stop();
+               }
+
+               // 停止红外流
+               if (null != mIrSensor) {
+                   mIrSensor.stop();
+               }
+
+               // 释放Device
+               if (null != mDevice) {
+                   mDevice.close();
+                   mDevice = null;
+               }
+
+               // 释放deviceList
+               deviceList.close();
+           } catch (Exception e) {
+               e.printStackTrace();
+           }
+       }
+   });
+
+设备连接回调（onDeviceAttach）中的处理
+
+.. code:: java
+
+   try {
+       if (deviceList == null || deviceList.getDeviceCount() <= 0) {
+           setText(mNameTv, "No device connected !");
+       }
+
+       // 2.创建设备，并获取设备名称
+       mDevice = deviceList.getDevice(0);
+       DeviceInfo devInfo = mDevice.getInfo();
+       String deviceName = devInfo.getName();
+       setText(mNameTv, deviceName);
+       devInfo.close();
+
+       // 3.获取深度传感器
+       mDepthSensor = mDevice.getSensor(SensorType.DEPTH);
+
+       // 4.打开深度流，profile传入null，表示使用配置文件中配置的参数开流，
+       // 如果设备中没有该配置，或不存在配置文件，则表示使用Profile列表中的第一个配置
+       if (null != mDepthSensor) {
+           mDepthSensor.start(null, mDepthFrameCallback);
+       }
+
+       // 5.获取彩色传感器
+       mColorSensor = mDevice.getSensor(SensorType.COLOR);
+
+       // 6.打开彩色流，profile传入null，表示使用配置文件中配置的参数开流，
+       // 如果设备中没有该配置，或不存在配置文件，则表示使用Profile列表中的第一个配置
+       if (null != mColorSensor) {
+           mColorSensor.start(null, mColorFrameCallback);
+       }
+
+       // 7.获取红外传感器
+       mIrSensor = mDevice.getSensor(SensorType.IR);
+
+       // 8.打开红外流，profile传入null，表示使用配置文件中配置的参数开流，
+       // 如果设备中没有该配置，或不存在配置文件，则表示使用Profile列表中的第一个配置
+       if (null != mIrSensor) {
+           mIrSensor.start(null, mIrFrameCallback);
+       }
+
+       // 9.更新开流配置信息
+       setText(mProfileInfoTv, formatProfileInfo());
+
+       // 10.释放deviceList资源
+       deviceList.close();
+   } catch (Exception e) {
+       e.printStackTrace();
+   }
+
+设备断开连接回调（onDeviceDetach）中的处理
+
+.. code:: java
+
+   try {
+       setText(mNameTv, "No device connected !");
+       setText(mProfileInfoTv, "");
+
+       mDepthFps = 0;
+       mColorFps = 0;
+       mIrFps = 0;
+
+       // 停止深度流
+       if (null != mDepthSensor) {
+           mDepthSensor.stop();
+       }
+
+       // 停止彩色流
+       if (null != mColorSensor) {
+           mColorSensor.stop();
+       }
+
+       // 停止红外流
+       if (null != mIrSensor) {
+           mIrSensor.stop();
+       }
+
+       // 释放Device
+       if (null != mDevice) {
+           mDevice.close();
+           mDevice = null;
+       }
+
+       // 释放deviceList
+       deviceList.close();
+   } catch (Exception e) {
+       e.printStackTrace();
+   }
+
+资源释放
+
+.. code:: java
+
+   try {
+       // 停止深度流
+       if (null != mDepthSensor) {
+           mDepthSensor.stop();
+       }
+
+       // 停止彩色流
+       if (null != mColorSensor) {
+           mColorSensor.stop();
+       }
+
+       // 停止红外流
+       if (null != mIrSensor) {
+           mIrSensor.stop();
+       }
+
+       // 释放Device
+       if (null != mDevice) {
+           mDevice.close();
+       }
+
+       // 释放SDK
+       if (null != mOBContext) {
+           mOBContext.close();
+       }
+   } catch (Exception e) {
+       e.printStackTrace();
+   }
+
+IMU示例-IMU
+-----------
+
+功能描述：本示例主要演示了使用SDK获取IMU数据并输出显示。
+
+首先需要创建一个Context，用于获取设备信息列表和创建设备
+
+.. code:: java
+
+   private OBContext mOBContext;
+
+定义IMU相关的sensor
+
+.. code:: java
+
+   // 加速度计传感器
+   private AccelFrame mAccelFrame;
+   // 陀螺仪传感器
+   private GyroFrame mGyroFrame;
+
+初始化SDK，并监听设备变化
+
+.. code:: java
+
+   // 1.初始化SDK, 并监听设备变化
+   mOBContext = new OBContext(getApplicationContext(), new DeviceChangedCallback() {
+       @Override
+       public void onDeviceAttach(DeviceList deviceList) {
+           try {
+               if (deviceList == null || deviceList.getDeviceCount() == 0) {
+                   showToast("请接入设备");
+               } else {
+                   // 2.创建Device
+                   mDevice = deviceList.getDevice(0);
+
+                   // 3.通过Device获取加速度Sensor
+                   mSensorAccel = mDevice.getSensor(SensorType.ACCEL);
+
+                   // 4.通过Device获取陀螺仪Sensor
+                   mSensorGyro = mDevice.getSensor(SensorType.GYRO);
+
+                   if (mSensorAccel == null || mSensorGyro == null) {
+                       showToast("本设备不支持IMU");
+                       deviceList.close();
+                       return;
+                   } else {
+                       runOnUiThread(() -> {
+                           mSurfaceViewImu.setVisibility(View.VISIBLE);
+                       });
+                   }
+
+                   if (mSensorAccel != null && mSensorGyro != null) {
+                       // 5.获取加速度计配置
+                       StreamProfileList accelProfileList = mSensorAccel.getStreamProfileList();
+                       if (null != accelProfileList) {
+                           mAccelStreamProfile = accelProfileList.getStreamProfile(0).as(StreamType.ACCEL);
+                           accelProfileList.close();
+                       }
+
+                       // 6.获取陀螺仪配置
+                       StreamProfileList gyroProfileList = mSensorGyro.getStreamProfileList();
+                       if (null != gyroProfileList) {
+                           mGyroStreamProfile = gyroProfileList.getStreamProfile(0).as(StreamType.GYRO);
+                           gyroProfileList.close();
+                       }
+                   }
+               }
+               // 8.释放设备列表资源
+               deviceList.close();
+           } catch (Exception e) {
+               e.printStackTrace();
+           }
+       }
+
+       @Override
+       public void onDeviceDetach(DeviceList deviceList) {
+           try {
+               showToast("请接入设备");
+               deviceList.close();
+           } catch (Exception e) {
+               e.printStackTrace();
+           }
+       }
+   });
+
+创建设备，并通过设备获取加速度计传感器和陀螺仪传感器
+
+.. code:: java
+
+   // 2.创建Device
+   mDevice = deviceList.getDevice(0);
+
+   // 3.通过Device获取加速度Sensor
+   mSensorAccel = mDevice.getSensor(SensorType.ACCEL);
+
+   // 4.通过Device获取陀螺仪Sensor
+   mSensorGyro = mDevice.getSensor(SensorType.GYRO);
+
+   if (mSensorAccel == null || mSensorGyro == null) {
+       showToast("本设备不支持IMU");
+       deviceList.close();
+       return;
+   } else {
+       runOnUiThread(() -> {
+           mSurfaceViewImu.setVisibility(View.VISIBLE);
+       });
+   }
+
+获取加速度计开流配置以及陀螺仪开流配置
+
+.. code:: java
+
+   if (mSensorAccel != null && mSensorGyro != null) {
+       // 5.获取加速度计配置
+       StreamProfileList accelProfileList = mSensorAccel.getStreamProfileList();
+       if (null != accelProfileList) {
+           mAccelStreamProfile = accelProfileList.getStreamProfile(0).as(StreamType.ACCEL);
+           accelProfileList.close();
+       }
+
+       // 6.获取陀螺仪配置
+       StreamProfileList gyroProfileList = mSensorGyro.getStreamProfileList();
+       if (null != gyroProfileList) {
+           mGyroStreamProfile = gyroProfileList.getStreamProfile(0).as(StreamType.GYRO);
+           gyroProfileList.close();
+       }
+   }
+
+通过指定配置开流
+
+.. code:: java
+
+
+   private void startIMU() {
+       // 7.1.初始化IMU数据刷新线程
+       mIsRefreshIMUDataRunning = true;
+       mRefreshIMUDataThread = new Thread(mRefreshIMUDataRunnable);
+       mRefreshIMUDataThread.setName("RefreshIMUDataThread");
+
+       // 7.2.开启IMU数据刷新线程
+       mRefreshIMUDataThread.start();
+
+       // 7.3.开始陀螺仪采样
+       startGyroStream();
+
+       // 7.4.开始加速度计采样
+       startAccelStream();
+   }
+
+开启加速度计采样
+
+.. code:: java
+
+   private void startAccelStream() {
+       try {
+           // 开启加速度计采样
+           if (null != mAccelStreamProfile) {
+               mSensorAccel.start(mAccelStreamProfile, new FrameCallback() {
+                   @Override
+                   public void onFrame(Frame frame) {
+                       AccelFrame accelFrame = frame.as(FrameType.ACCEL);
+
+                       if (null == mAccelFrame) {
+                           mAccelFrame = accelFrame;
+                           return;
+                       }
+
+                       frame.close();
+                   }
+               });
+           }
+       } catch (Exception e) {
+           e.printStackTrace();
+       }
+   }
+
+开启陀螺仪采样
+
+.. code:: java
+
+   private void startGyroStream() {
+       try {
+           // 开启陀螺仪采样
+           if (null != mGyroStreamProfile) {
+               mSensorGyro.start(mGyroStreamProfile, new FrameCallback() {
+                   @Override
+                   public void onFrame(Frame frame) {
+                       GyroFrame gyroFrame = frame.as(FrameType.GYRO);
+
+                       if (null == mGyroFrame) {
+                           mGyroFrame = gyroFrame;
+                           return;
+                       }
+
+                       frame.close();
+                   }
+               });
+           }
+       } catch (Exception e) {
+           e.printStackTrace();
+       }
+   }
+
+创建AccelFrame和GyroFrame数据绘制方法，并在数据刷新线程实时绘制
+
+.. code:: java
+
+   private void drawImuInfo() {
+       try {
+           Canvas canvas = mSurfaceViewImu.getHolder().lockCanvas();
+           if (null != canvas) {
+               mPaintIMU.setTextSize(25.0f);
+               Paint.FontMetrics fm = mPaintIMU.getFontMetrics();
+               float offsetY = fm.descent - fm.ascent;
+               float x = canvas.getWidth() / 8;
+               float y = canvas.getHeight() / 8;
+               canvas.drawColor(Color.WHITE);
+               if (mAccelFrame != null) {
+                   canvas.drawText("AccelTimestamp:" + mAccelFrame.getTimeStamp(), x, y, mPaintIMU);
+                   canvas.drawText("AccelTemperature:" + mAccelFrame.getTemperature() + "dC", x, (y += offsetY), mPaintIMU);
+
+                   canvas.drawText("Accel.x:" + mAccelFrame.getAccelData()[0] + "g", x, (y += 2 * offsetY), mPaintIMU);
+                   canvas.drawText("Accel.y:" + mAccelFrame.getAccelData()[1] + "g", x, (y += offsetY), mPaintIMU);
+                   canvas.drawText("Accel.z:" + mAccelFrame.getAccelData()[2] + "g", x, (y += offsetY), mPaintIMU);
+
+                   // 释放AccelFrame资源
+                   mAccelFrame.close();
+                   mAccelFrame = null;
+               }
+
+               if (mGyroFrame != null) {
+                   canvas.drawText("GyroTimestamp:" + mGyroFrame.getTimeStamp(), x, (y += 2 * offsetY), mPaintIMU);
+                   canvas.drawText("GyroTemperature:" + mGyroFrame.getTemperature() + "dC", x, (y += offsetY), mPaintIMU);
+
+                   canvas.drawText("Gyro.x:" + mGyroFrame.getGyroData()[0] + "dps", x, (y += 2 * offsetY), mPaintIMU);
+                   canvas.drawText("Gyro.y:" + mGyroFrame.getGyroData()[1] + "dps", x, (y += offsetY), mPaintIMU);
+                   canvas.drawText("Gyro.z:" + mGyroFrame.getGyroData()[2] + "dps", x, (y += offsetY), mPaintIMU);
+
+                   // 释放GyroFrame资源
+                   mGyroFrame.close();
+                   mGyroFrame = null;
+               }
+               mSurfaceViewImu.getHolder().unlockCanvasAndPost(canvas);
+           }
+       } catch (Exception e) {
+           e.printStackTrace();
+       }
+   }
+
+停止数据采样
+
+.. code:: java
+
+   private void stopIMU() {
+       try {
+           // 停止加速度计采样
+           if (null != mSensorAccel) {
+               mSensorAccel.stop();
+           }
+
+           // 停止陀螺仪采样
+           if (null != mSensorGyro) {
+               mSensorGyro.stop();
+           }
+
+           // 停止IMU数据刷新线程并释放
+           mIsRefreshIMUDataRunning = false;
+           if (null != mRefreshIMUDataThread) {
+               try {
+                   mRefreshIMUDataThread.join(300);
+               } catch (InterruptedException e) {
+                   e.printStackTrace();
+               }
+               mRefreshIMUDataThread = null;
+           }
+       } catch (Exception e) {
+           e.printStackTrace();
+       }
+   }
+
+资源释放
+
+::
+
+   try {
+       // 释放加速度计配置
+       if (null != mAccelStreamProfile) {
+           mAccelStreamProfile.close();
+           mAccelStreamProfile = null;
+       }
+
+       // 释放陀螺仪配置
+       if (null != mGyroStreamProfile) {
+           mGyroStreamProfile.close();
+           mGyroStreamProfile = null;
+       }
+
+       // 释放Device
+       if (null != mDevice) {
+           mDevice.close();
+           mDevice = null;
+       }
+
+       // 释放SDK
+       if (null != mOBContext) {
+           mOBContext.close();
+           mOBContext = null;
+       }
+   } catch (Exception e) {
+       e.printStackTrace();
+   }
+
+多设备示例-MultiDevice
+----------------------
+
+功能描述：本示例主要演示了对多设备进行操作。
+首先需要创建一个Context，用于获取设备信息列表和创建设备
+
+.. code:: java
+
+   private OBContext mOBContext;
+
+初始化SDK，并监听设备变化
+
+.. code:: java
+
+   // 初始化SDK
+   mOBContext = new OBContext(getApplicationContext(), new DeviceChangedCallback() {
+       @Override
+       public void onDeviceAttach(DeviceList deviceList) {
+           try {
+               int count = deviceList.getDeviceCount();
+               for (int i = 0; i < count; i++) {
+                   // 创建设备
+                   Device device = deviceList.getDevice(i);
+                   // 获取DeviceInfo
+                   DeviceInfo devInfo = device.getInfo();
+                   // 获取设备名称
+                   String name = devInfo.getName();
+                   // 获取设备uid
+                   String uid = devInfo.getUid();
+                   // 获取设备usb接口类型
+                   String usbType = devInfo.getUsbType();
+                   // 释放DeviceInfo资源
+                   devInfo.close();
+                   runOnUiThread(() -> {
+                       mDeviceControllerAdapter.addItem(new DeviceBean(name, uid, usbType, device));
+                   });
+
+               }
+
+               // 释放设备列表资源
+               deviceList.close();
+           } catch (Exception e) {
+               e.printStackTrace();
+           }
+       }
+
+       @Override
+       public void onDeviceDetach(DeviceList deviceList) {
+           try {
+               for (DeviceBean deviceBean : mDeviceBeanList) {
+                   // 通过uid判断下线设备
+                   if (deviceBean.getDeviceUid().equals(deviceList.getUid(0))) {
+                       // 释放下线设备资源
+                       deviceBean.getDevice().close();
+                       runOnUiThread(() -> {
+                           mDeviceControllerAdapter.deleteItem(deviceBean);
+                       });
+                   }
+               }
+
+               // 释放设备列表资源
+               deviceList.close();
+           } catch (Exception e) {
+               Log.w(TAG, "onDeviceDetach: " + e.getMessage());
+           }
+       }
+   });
+
+在设备连接回调方法中创建设备列表
+
+.. code:: java
+
+   int count = deviceList.getDeviceCount();
+   for (int i = 0; i < count; i++) {
+       // 创建设备
+       Device device = deviceList.getDevice(i);
+       // 获取DeviceInfo
+       DeviceInfo devInfo = device.getInfo();
+       // 获取设备名称
+       String name = devInfo.getName();
+       // 获取设备uid
+       String uid = devInfo.getUid();
+       // 获取设备usb接口类型
+       String usbType = devInfo.getUsbType();
+       // 释放DeviceInfo资源
+       devInfo.close();
+       runOnUiThread(() -> {
+           mDeviceControllerAdapter.addItem(new DeviceBean(name, uid, usbType, device));
+       });
+   }
+
+选择对应的设备开流
+
+.. code:: java
+
+   private void startStream(Sensor sensor, GLView glView) {
+       try {
+           // 获取传感器的流配置列表
+           StreamProfileList profileList = sensor.getStreamProfileList();
+           if (null == profileList) {
+               Log.w(TAG, "start stream failed, profileList is null !");
+               return;
+           }
+           switch (sensor.getType()) {
+               case DEPTH:
+                   GLView depthGLView = glView;
+                   // 通过StreamProfileList获取开流配置
+                   StreamProfile depthProfile = profileList.getVideoStreamProfile(640, 480, Format.Y16, 0);
+                   if (null != depthProfile) {
+                       // 通过指定配置开流
+                       sensor.start(depthProfile, frame -> {
+                           DepthFrame depthFrame = frame.as(FrameType.DEPTH);
+                           byte[] bytes = new byte[depthFrame.getDataSize()];
+                           depthFrame.getData(bytes);
+                           // 渲染数据
+                           depthGLView.update(bytes, depthFrame.getWidth(), depthFrame.getHeight(),
+                                   StreamType.DEPTH, depthFrame.getFormat());
+                           // 释放frame资源
+                           frame.close();
+                       });
+                       // 释放profile资源
+                       depthProfile.close();
+                   } else {
+                       Log.w(TAG, "start depth stream failed, depthProfile is null!");
+                   }
+                   break;
+               case COLOR:
+                   GLView colorGLView = glView;
+                   // 通过StreamProfileList获取开流配置
+                   StreamProfile colorProfile = profileList.getVideoStreamProfile(640, 480, Format.RGB888, 0);
+
+                   if (null != colorProfile) {
+                       // 通过指定配置开流
+                       sensor.start(colorProfile, frame -> {
+                           ColorFrame colorFrame = frame.as(FrameType.COLOR);
+                           byte[] bytes = new byte[colorFrame.getDataSize()];
+                           // 获取frame数据
+                           colorFrame.getData(bytes);
+                           // 渲染数据
+                           colorGLView.update(bytes, colorFrame.getWidth(), colorFrame.getHeight(), StreamType.COLOR, Format.RGB888);
+                           // 释放frame资源
+                           frame.close();
+                       });
+                       // 释放profile资源
+                       colorProfile.close();
+                   } else {
+                       Log.w(TAG, "start color stream failed, colorProfile is null!");
+                   }
+                   break;
+               case IR:
+                   GLView irGLView = glView;
+                   // 通过StreamProfileList获取开流配置
+                   StreamProfile irProfile = profileList.getVideoStreamProfile(640, 480, Format.Y16, 0);
+                   if (null != irProfile) {
+                       // 通过指定配置开流
+                       sensor.start(irProfile, frame -> {
+                           IRFrame irFrame = frame.as(FrameType.IR);
+                           byte[] bytes = new byte[irFrame.getDataSize()];
+                           // 获取frame数据
+                           irFrame.getData(bytes);
+                           // 渲染数据
+                           irGLView.update(bytes, irFrame.getWidth(), irFrame.getHeight(),
+                                   StreamType.IR, irFrame.getFormat());
+                           // frame资源
+                           frame.close();
+                       });
+                       // 释放profile资源
+                       irProfile.close();
+                   } else {
+                       Log.w(TAG, "start ir stream failed, irProfile is null!");
+                   }
+                   break;
+           }
+
+           // 释放profileList资源
+           profileList.close();
+       } catch (Exception e) {
+           Log.w(TAG, "startStream: " + e.getMessage());
+       }
+   }
+
+对指定的设备关流指定sensor流
+
+.. code:: java
+
+   private void stopStream(Sensor sensor) {
+       try {
+           sensor.stop();
+       } catch (Exception e) {
+           e.printStackTrace();
+       }
+   }
+
+在设备断开连接回调中做对应的资源释放并刷新设备列表
+
+.. code:: java
+
+   try {
+       for (DeviceBean deviceBean : mDeviceBeanList) {
+           // 通过uid判断下线设备
+           if (deviceBean.getDeviceUid().equals(deviceList.getUid(0))) {
+               // 释放下线设备资源
+               deviceBean.getDevice().close();
+               runOnUiThread(() -> {
+                   mDeviceControllerAdapter.deleteItem(deviceBean);
+               });
+           }
+       }
+   } catch (Exception e) {
+       Log.w(TAG, "onDeviceDetach: " + e.getMessage());
+   }
+
+资源释放
+
+.. code:: java
+
+   try {
+       // 释放资源
+       for (DeviceBean deviceBean : mDeviceBeanList) {
+           try {
+               // 释放设备资源
+               deviceBean.getDevice().close();
+           } catch (Exception e) {
+               Log.w(TAG, "onDestroy: " + e.getMessage());
+           }
+       }
+       mDeviceBeanList.clear();
+
+       // 释放SDK
+       if (null != mOBContext) {
+           mOBContext.close();
+       }
+   } catch (Exception e) {
+       e.printStackTrace();
+     }
+
+点云示例-PointCloud
+-------------------
+
+功能描述：本示例主要演示了连接设备开流
+,生成深度点云或RGBD点云并保存成ply格式文件。
+
+首先需要创建一个Context，用于获取设备信息列表和创建设备
+
+.. code:: java
+
+   private OBContext mOBContext;
+
+初始化SDK，并监听设备变化
+
+.. code:: java
+
+   // 1.初始化SDK
+   mOBContext = new OBContext(getApplicationContext(), new DeviceChangedCallback() {
+       @Override
+       public void onDeviceAttach(DeviceList deviceList) {
+           try {
+               if (null == mPipeline) {
+                   // 2.通过deviceList获取Device
+                   mDevice = deviceList.getDevice(0);
+
+                   // 3.通过Device创建Pipeline
+                   mPipeline = new Pipeline(mDevice);
+
+                   // 4.创建Config，用于配置pipeline开流
+                   Config config = new Config();
+
+                   // 5.获取彩色配置列表，并获取640x480 YUYV或者I420格式配置开流
+                   StreamProfileList colorProfileList = mPipeline.getStreamProfileList(SensorType.COLOR);
+                   VideoStreamProfile colorProfileTarget = null;
+                   if (null != colorProfileList) {
+                       colorProfileTarget = colorProfileList.getVideoStreamProfile(640, 480, Format.YUYV, 0);
+                       if (null == colorProfileTarget) {
+                           colorProfileTarget = colorProfileList.getVideoStreamProfile(640, 480, Format.I420, 0);
+                       }
+                       colorProfileList.close();
+                   }
+
+                   // 6.获取到指定彩色配置后使能配置
+                   if (null != colorProfileTarget) {
+                       config.enableStream(colorProfileTarget);
+                       colorProfileTarget.close();
+                   }
+
+                   // 7.获取深度配置列表，并获取640x480 YUYV或者Y16格式配置开流
+                   VideoStreamProfile depthProfileTarget = null;
+                   StreamProfileList depthProfileList = mPipeline.getStreamProfileList(SensorType.DEPTH);
+                   if (null != depthProfileList) {
+                       depthProfileTarget = depthProfileList.getVideoStreamProfile(640, 480, Format.Y16, 0);
+                       depthProfileList.close();
+                   }
+
+                   // 8.获取到指定深度配置后使能配置
+                   if (null != depthProfileTarget) {
+                       config.enableStream(depthProfileTarget);
+                       depthProfileTarget.close();
+                   }
+
+
+                   // 9.开启硬件D2C
+                   config.setAlignMode(AlignMode.ALIGN_D2C_HW_ENABLE);
+
+                   // 10.使用回调方式开流
+                   mPipeline.start(config, mPointCloudFrameSetCallback);
+
+                   // 11.启动点云异步处理线程
+                   start();
+
+                   // 12.通过Pipeline创建点云filter
+                   mPointCloudFilter = new PointCloudFilter();
+
+                   // 13.设置点云filter的格式
+                   mPointCloudFilter.setPointFormat(mPointFormat);
+
+                   // 14.获取相机内参并且将参数设置到点云filter中
+                   CameraParamList cameraParamList = mDevice.getCalibrationCameraParamList();
+                   CameraParam cameraParam = null;
+                   if (null != cameraParamList) {
+                       int count = cameraParamList.getCameraParamCount();
+                       for (int i = 0; i < count; i++) {
+                           cameraParam = cameraParamList.getCameraParam(i);
+                           int depthW = cameraParam.getDepthIntrinsic().getWidth();
+                           int depthH = cameraParam.getDepthIntrinsic().getHeight();
+                           int colorW = cameraParam.getColorIntrinsic().getWidth();
+                           int colorH = cameraParam.getColorIntrinsic().getHeight();
+                           // 14.1.需要获取标定的分辨率比例与开流分辨率比例一致的内参
+                           if ((depthW / depthH == 640 / 480) && (colorW / colorH == 640 / 480)) {
+                               break;
+                           }
+                       }
+                       cameraParamList.close();
+                   }
+                   mPointCloudFilter.setCameraParam(cameraParam);
+
+                   // 15.释放config资源
+                   config.close();
+               }
+
+               // 16.释放设备列表资源
+               deviceList.close();
+           } catch (Exception e) {
+               e.printStackTrace();
+           }
+       }
+
+       @Override
+       public void onDeviceDetach(DeviceList deviceList) {
+           try {
+               deviceList.close();
+           } catch (Exception e) {
+               e.printStackTrace();
+           }
+       }
+   });
+
+创建设备并通过设备创建Pipeline
+
+.. code:: java
+
+   // 2.通过deviceList获取Device
+   mDevice = deviceList.getDevice(0);
+
+   // 3.通过Device创建Pipeline
+   mPipeline = new Pipeline(mDevice);
+
+创建Pipeline配置
+
+.. code:: java
+
+   // 4.创建Config，用于配置pipeline开流
+   Config config = new Config();
+
+获取彩色流配置，并配置到Config，这里配置为640x480 YUYV格式或者是640x480
+I420格式
+
+.. code:: java
+
+   // 5.获取彩色配置列表，并获取640x480 YUYV或者I420格式配置开流
+   StreamProfileList colorProfileList = mPipeline.getStreamProfileList(SensorType.COLOR);
+   VideoStreamProfile colorProfileTarget = null;
+   if (null != colorProfileList) {
+       colorProfileTarget = colorProfileList.getVideoStreamProfile(640, 480, Format.YUYV, 0);
+       if (null == colorProfileTarget) {
+           colorProfileTarget = colorProfileList.getVideoStreamProfile(640, 480, Format.I420, 0);
+       }
+       colorProfileList.close();
+   }
+
+   // 6.获取到指定彩色配置后使能配置
+   if (null != colorProfileTarget) {
+       config.enableStream(colorProfileTarget);
+       colorProfileTarget.close();
+   }
+
+获取深度流配置，并配置到Config，这里配置为640x480 YUYV格式或者是Y16格式
+
+.. code:: java
+
+   // 7.获取深度配置列表，并获取640x480 YUYV或者Y16格式配置开流
+   VideoStreamProfile depthProfileTarget = null;
+   StreamProfileList depthProfileList = mPipeline.getStreamProfileList(SensorType.DEPTH);
+   if (null != depthProfileList) {
+       depthProfileTarget = depthProfileList.getVideoStreamProfile(640, 480, Format.Y16, 0);
+       depthProfileList.close();
+   }
+
+   // 8.获取到指定深度配置后使能配置
+   if (null != depthProfileTarget) {
+       config.enableStream(depthProfileTarget);
+       depthProfileTarget.close();
+   }
+
+判断设备是否支持硬件D2C并开启
+
+::
+
+   // 9.开启硬件D2C
+   config.setAlignMode(AlignMode.ALIGN_D2C_HW_ENABLE);
+
+创建Pipeline开流的回调方法
+
+.. code:: java
+
+   // Pipeline开流的回调
+   private FrameSetCallback mPointCloudFrameSetCallback = frameSet -> {
+       if (null != frameSet) {
+           if (mIsPointCloudRunning) {
+               if (null == mPointFrameSet) {
+                   mPointFrameSet = frameSet;
+                   return;
+               }
+           }
+
+           frameSet.close();
+       }
+   };
+
+使用Config配置通过Pipeline回调方式开流
+
+.. code:: java
+
+   // 10.使用回调方式开流
+   mPipeline.start(config, mPointCloudFrameSetCallback);
+
+启动点云异步处理线程
+
+.. code:: java
+
+   private void start() {
+       mIsPointCloudRunning = true;
+       if (null == mPointFilterThread) {
+           mPointFilterThread = new Thread(mPointFilterRunnable);
+           mPointFilterThread.start();
+       }
+   }
+
+通过Pipeline创建点云filter，并设置点云filter的格式（如果需要保存深度点云，则需要将格式设置为Format.\ *POINT*\ ，如果需要保存RGBD点云则需要将格式设置为Format.\ *RGB_POINT*\ ）
+
+.. code:: java
+
+   // 12.通过Pipeline创建点云filter
+   mPointCloudFilter = new PointCloudFilter();
+
+   // 13.设置点云filter的格式
+   mPointCloudFilter.setPointFormat(mPointFormat);
+
+获取相机内参并将参数设置到点云filter中
+
+.. code:: java
+
+   // 14.获取相机内参并且将参数设置到点云filter中
+   CameraParamList cameraParamList = mDevice.getCalibrationCameraParamList();
+   CameraParam cameraParam = null;
+   if (null != cameraParamList) {
+       int count = cameraParamList.getCameraParamCount();
+       for (int i = 0; i < count; i++) {
+           cameraParam = cameraParamList.getCameraParam(i);
+           int depthW = cameraParam.getDepthIntrinsic().getWidth();
+           int depthH = cameraParam.getDepthIntrinsic().getHeight();
+           int colorW = cameraParam.getColorIntrinsic().getWidth();
+           int colorH = cameraParam.getColorIntrinsic().getHeight();
+           // 14.1.需要获取标定的分辨率比例与开流分辨率比例一致的内参
+           if ((depthW / depthH == 640 / 480) && (colorW / colorH == 640 / 480)) {
+               break;
+           }
+       }
+       cameraParamList.close();
+   }
+   mPointCloudFilter.setCameraParam(cameraParam);
+
+点云filter线程数据处理
+
+.. code:: java
+
+   while (mIsPointCloudRunning) {
+       try {
+           if (null != mPointFrameSet) {
+               Frame frame = null;
+               if (mPointFormat == Format.POINT) {
+                   // 设置保存格式为深度点云
+                   mPointCloudFilter.setPointFormat(Format.POINT);
+               } else {
+                   // 设置保存格式为彩色点云
+                   mPointCloudFilter.setPointFormat(Format.RGB_POINT);
+               }
+               // 点云filter处理生成对应的点云数据
+               frame = mPointCloudFilter.process(mPointFrameSet);
+
+               if (null != frame) {
+                   // 获取点云帧
+                   PointFrame pointFrame = frame.as(FrameType.POINTS);
+
+                   if (mIsSavePoints) {
+                       if (mPointFormat == Format.POINT) {
+                           // 获取深度点云数据并保存，深度点云的数据大小为w * h * 3
+                           float[] depthPoints = new float[pointFrame.getDataSize() / Float.BYTES];
+                           pointFrame.getPointCloudData(depthPoints);
+                           String depthPointsPath = mSdcardDir.toString() + "/points.ply";
+                           FileUtils.savePointCloud(depthPointsPath, depthPoints);
+                           runOnUiThread(new Runnable() {
+                               @Override
+                               public void run() {
+                                   mInfoTv.append("Save Path:" + depthPointsPath + "\n");
+                               }
+                           });
+                       } else {
+                           // 获取彩色点云数据并保存，彩色点云的数据大小为w * h * 6
+                           float[] colorPoints = new float[pointFrame.getDataSize() / Float.BYTES];
+                           pointFrame.getPointCloudData(colorPoints);
+                           String colorPointsPath = mSdcardDir.toString() + "/rgb_points.ply";
+                           FileUtils.saveRGBPointCloud(colorPointsPath, colorPoints);
+                           runOnUiThread(new Runnable() {
+                               @Override
+                               public void run() {
+                                   mInfoTv.append("Save Path:" + colorPointsPath + "\n");
+                               }
+                           });
+                       }
+
+                       mIsSavePoints = false;
+                   }
+
+                   // 释放新生成的frame
+                   frame.close();
+               }
+
+               // 释放原始数据frameSet
+               mPointFrameSet.close();
+               mPointFrameSet = null;
+           }
+       } catch (Exception e) {
+           e.printStackTrace();
+       }
+   }
+
+保存深度点云数据
+
+.. code:: java
+
+   public static void savePointCloud(String fileName, float[] data) {
+       try {
+           File file = new File(fileName);
+           FileOutputStream fos = new FileOutputStream(file);
+           PrintWriter writer = new PrintWriter(fos);
+           writer.write("ply\n");
+           writer.write("format ascii 1.0\n");
+           writer.write("element vertex 307200\n");
+           writer.write("property float x\n");
+           writer.write("property float y\n");
+           writer.write("property float z\n");
+           writer.write("end_header\n");
+           writer.flush();
+
+           for (int i = 0; i < data.length; i += 3) {
+               writer.print(data[i]);
+               writer.print(" ");
+               writer.print(data[i + 1]);
+               writer.print(" ");
+               writer.print(data[i + 2]);
+               writer.print("\n");
+           }
+           writer.close();
+           fos.close();
+       } catch (Exception e) {
+           Log.e(TAG, "exception: " + e.getMessage());
+       }
+   }
+
+保存彩色点云数据
+
+.. code:: java
+
+   public static void saveRGBPointCloud(String fileName, float[] data) {
+       try {
+           File file = new File(fileName);
+           FileOutputStream fos = new FileOutputStream(file);
+           PrintWriter writer = new PrintWriter(fos);
+           writer.write("ply\n");
+           writer.write("format ascii 1.0\n");
+           writer.write("element vertex 307200\n");
+           writer.write("property float x\n");
+           writer.write("property float y\n");
+           writer.write("property float z\n");
+           writer.write("property uchar red\n");
+           writer.write("property uchar green\n");
+           writer.write("property uchar blue\n");
+           writer.write("end_header\n");
+           writer.flush();
+
+           for (int i = 0; i < data.length; i += 6) {
+               writer.print(data[i]);
+               writer.print(" ");
+               writer.print(data[i + 1]);
+               writer.print(" ");
+               writer.print(data[i + 2]);
+               writer.print(" ");
+               writer.print((int) data[i + 3]);
+               writer.print(" ");
+               writer.print((int) data[i + 4]);
+               writer.print(" ");
+               writer.print((int) data[i + 5]);
+               writer.print("\n");
+           }
+           writer.close();
+           fos.close();
+       } catch (Exception e) {
+           Log.e(TAG, "exception: " + e.getMessage());
+       }
+   }
+
+退出点云filter处理线程
+
+.. code:: java
+
+   private void stop() {
+       mIsPointCloudRunning = false;
+       if (null != mPointFilterThread) {
+           try {
+               mPointFilterThread.join(300);
+           } catch (InterruptedException e) {
+           }
+           mPointFilterThread = null;
+       }
+   }
+
+资源释放
+
+.. code:: java
+
+   try {
+       // 停止Pipeline，并关闭
+       if (null != mPipeline) {
+           mPipeline.stop();
+           mPipeline.close();
+           mPipeline = null;
+       }
+
+       // 释放点云filter
+       if (null != mPointCloudFilter) {
+           try {
+               mPointCloudFilter.close();
+           } catch (Exception e) {
+           }
+           mPointCloudFilter = null;
+       }
+
+       // 释放Device
+       if (mDevice != null) {
+           mDevice.close();
+           mDevice = null;
+       }
+
+       // 释放SDK
+       if (null != mOBContext) {
+           mOBContext.close();
+           mOBContext = null;
+       }
+   } catch (Exception e) {
+       e.printStackTrace();
+   }
+
+存储示例-SaveToDisk
+-------------------
+
+功能描述：本示例用于演示连接设备开流 ,
+获取彩色存储为png格式，深度存储为raw格式以及通过filter进行格式转换。
+
+首先需要创建一个Context，用于获取设备信息列表和创建设备
+
+.. code:: java
+
+   private OBContext mOBContext;
+
+初始化SDK，并监听设备变化
+
+.. code:: java
+
+   // 1.初始化SDK, 并监听设备变化
+   mOBContext = new OBContext(getApplicationContext(), new DeviceChangedCallback() {
+       @Override
+       public void onDeviceAttach(DeviceList deviceList) {
+           try {
+               if (null == mPipeline) {
+                   // 2.创建Device, 并通过Device初始化Pipeline
+                   mDevice = deviceList.getDevice(0);
+                   mPipeline = new Pipeline(mDevice);
+
+                   // 3.初始化格式转换filter
+                   mFormatConvertFilter = new FormatConvertFilter();
+
+                   // 4.创建Pipeline配置
+                   Config config = new Config();
+
+                   // 5.获取彩色流配置，并配置到Config
+                   StreamProfileList colorProfileList = mPipeline.getStreamProfileList(SensorType.COLOR);
+                   StreamProfile colorStreamProfile = null;
+                   if (null != colorProfileList) {
+                       colorStreamProfile = colorProfileList.getVideoStreamProfile(640, 480, Format.MJPG, 0);
+                       colorProfileList.close();
+                   }
+
+                   if (null == colorStreamProfile) {
+                       Log.e(TAG, "onDeviceAttach: get color stream profile failed !");
+                       deviceList.close();
+                       return;
+                   }
+
+                   // 6.通过获取到的彩色流配置使能彩色流
+                   config.enableStream(colorStreamProfile);
+
+                   // 7.获取深度流配置，并配置到Config
+                   StreamProfileList depthProfileList = mPipeline.getStreamProfileList(SensorType.DEPTH);
+                   StreamProfile depthStreamProfile = null;
+                   if (null != depthProfileList) {
+                       depthStreamProfile = depthProfileList.getVideoStreamProfile(640, 480, Format.Y16, 0);
+                       depthProfileList.close();
+                   }
+
+                   if (null == depthStreamProfile) {
+                       Log.e(TAG, "onDeviceAttach: get depth stream profile failed !");
+                       deviceList.close();
+                       return;
+                   }
+
+                   // 8.通过获取到的深度流配置使能深度流
+                   config.enableStream(depthStreamProfile);
+
+                   // 9.使用Config开启Pipeline
+                   mPipeline.start(config);
+
+                   // 10.释放colorStreamProfile
+                   colorStreamProfile.close();
+
+                   // 11.释放depthStreamProfile
+                   depthStreamProfile.close();
+
+                   // 12.释放config资源
+                   config.close();
+
+                   // 13.创建获取Pipeline数据线程以及图片保存线程
+                   start();
+               }
+
+               // 14.释放设备列表资源
+               deviceList.close();
+           } catch (Exception e) {
+               e.printStackTrace();
+           }
+       }
+
+       @Override
+       public void onDeviceDetach(DeviceList deviceList) {
+           try {
+               deviceList.close();
+           } catch (Exception e) {
+               e.printStackTrace();
+           }
+       }
+   });
+
+创建设备并通过设备创建Pipeline
+
+.. code:: java
+
+   // 2.创建Device, 并通过Device初始化Pipeline
+   mDevice = deviceList.getDevice(0);
+   mPipeline = new Pipeline(mDevice);
+
+通过Pipeline初始化格式转换filter
+
+.. code:: java
+
+   // 3.初始化格式转换filter
+   mFormatConvertFilter = new FormatConvertFilter();
+
+创建Pipeline配置
+
+.. code:: java
+
+   // 4.创建Pipeline配置
+   Config config = new Config();
+
+获取彩色流配置，并配置到Config，这里配置为640x480 MJPG格式
+
+.. code:: java
+
+   // 5.获取彩色流配置，并配置到Config
+   StreamProfileList colorProfileList = mPipeline.getStreamProfileList(SensorType.COLOR);
+   StreamProfile colorStreamProfile = null;
+   if (null != colorProfileList) {
+       colorStreamProfile = colorProfileList.getVideoStreamProfile(640, 480, Format.MJPG, 0);
+       colorProfileList.close();
+   }
+
+   if (null == colorStreamProfile) {
+       Log.e(TAG, "onDeviceAttach: get color stream profile failed !");
+       deviceList.close();
+       return;
+   }
+
+   // 6.通过获取到的彩色流配置使能彩色流
+   config.enableStream(colorStreamProfile);
+
+获取深度流配置，并配置到Config，这里配置为640x480 Y16格式
+
+.. code:: java
+
+   // 7.获取深度流配置，并配置到Config
+   StreamProfileList depthProfileList = mPipeline.getStreamProfileList(SensorType.DEPTH);
+   StreamProfile depthStreamProfile = null;
+   if (null != depthProfileList) {
+       depthStreamProfile = depthProfileList.getVideoStreamProfile(640, 480, Format.Y16, 0);
+       depthProfileList.close();
+   }
+
+   if (null == depthStreamProfile) {
+       Log.e(TAG, "onDeviceAttach: get depth stream profile failed !");
+       deviceList.close();
+       return;
+   }
+
+   // 8.通过获取到的深度流配置使能深度流
+   config.enableStream(depthStreamProfile);
+
+使用Config配置通过Pipeline开流
+
+.. code:: java
+
+   // 9.使用Config开启Pipeline
+   mPipeline.start(config);
+
+创建获取Pipeline数据线程以及图片保存线程
+
+.. code:: java
+
+   private void start() {
+       colorCount = 0;
+       depthCount = 0;
+       mIsStreamRunning = true;
+       mIsPicSavingRunning = true;
+       if (null == mStreamThread) {
+           mStreamThread = new Thread(mStreamRunnable);
+           mStreamThread.start();
+       }
+
+       if (null == mPicSavingThread) {
+           mPicSavingThread = new Thread(mPicSavingRunnable);
+           mPicSavingThread.start();
+       }
+   }
+
+数据流处理
+
+.. code:: java
+
+   int count = 0;
+   while (mIsStreamRunning) {
+       try {
+           // 等待100ms后如果获取不到，则超时
+           FrameSet frameSet = mPipeline.waitForFrameSet(100);
+           if (null == frameSet) {
+               continue;
+           }
+           if (count < 5) {
+               frameSet.close();
+               count++;
+               continue;
+           }
+
+           // 获取彩色流数据
+           ColorFrame colorFrame = frameSet.getColorFrame();
+           if (null != colorFrame) {
+               mFormatConvertFilter.setFormatType(FormatConvertType.FORMAT_MJPG_TO_RGB888);
+               Frame rgbFrame = mFormatConvertFilter.process(colorFrame);
+
+               FrameCopy frameT = copyToFrameT(rgbFrame.as(FrameType.VIDEO));
+
+               mFrameSaveQueue.offer(frameT);
+               colorFrame.close();
+               rgbFrame.close();
+           }
+
+           // 获取深度流数据
+           DepthFrame depthFrame = frameSet.getDepthFrame();
+           if (null != depthFrame) {
+               FrameCopy frameT = copyToFrameT(depthFrame);
+               mFrameSaveQueue.offer(frameT);
+               depthFrame.close();
+           }
+
+           // 释放数据集
+           frameSet.close();
+       } catch (Exception e) {
+           e.printStackTrace();
+       }
+   }
+
+数据保存
+
+.. code:: java
+
+   while (mIsPicSavingRunning) {
+       try {
+           FrameCopy frameT = mFrameSaveQueue.poll(300, TimeUnit.MILLISECONDS);
+           if (null != frameT) {
+               Log.d(TAG, "colorCount :" + colorCount);
+               if (frameT.getStreamType() == FrameType.COLOR && colorCount < 5) {
+                   FileUtils.saveImage(frameT);
+                   colorCount++;
+               }
+
+               Log.d(TAG, "depthCount :" + depthCount);
+               if (frameT.getStreamType() == FrameType.DEPTH && depthCount < 5) {
+                   FileUtils.saveImage(frameT);
+                   depthCount++;
+               }
+           }
+       } catch (Exception e) {
+       }
+
+       if (colorCount == 5 && depthCount == 5) {
+           mIsPicSavingRunning = false;
+           break;
+       }
+   }
+
+   mFrameSaveQueue.clear();
+
+退出数据处理线程和存图线程
+
+.. code:: java
+
+   private void stop() {
+       mIsStreamRunning = false;
+       mIsPicSavingRunning = false;
+       if (null != mStreamThread) {
+           try {
+               mStreamThread.join(1000);
+           } catch (InterruptedException e) {
+           }
+           mStreamThread = null;
+       }
+
+       if (null != mPicSavingThread) {
+           try {
+               mPicSavingThread.join(1000);
+           } catch (InterruptedException e) {
+           }
+           mPicSavingThread = null;
+       }
+   }
+
+资源释放
+
+::
+
+   // 释放filter资源
+   if (null != mFormatConvertFilter) {
+       try {
+           mFormatConvertFilter.close();
+       } catch (Exception e) {
+           e.printStackTrace();
+       }
+   }
+   // 停止Pipeline，并关闭
+   if (null != mPipeline) {
+       mPipeline.close();
+       mPipeline = null;
+   }
+   // 释放Device资源
+   if (null != mDevice) {
+       mDevice.close();
+       mDevice = null;
+   }
+   // 释放SDK
+   if (null != mOBContext) {
+       mOBContext.close();
+       mOBContext = null;
+   }
+
+传感器控制示例-SensorControl
+----------------------------
+
+功能描述：本示例主要演示了对device控制命令的操作、对Sensor控制命令的操作。
+
+首先需要创建一个Context，用于获取设备信息列表和创建设备
+
+.. code:: java
+
+   private OBContext mOBContext;
+
+初始化SDK，并监听设备变化
+
+.. code:: java
+
+   // 2.初始化SDK
+   mOBContext = new OBContext(getApplicationContext(), new DeviceChangedCallback() {
+       @Override
+       public void onDeviceAttach(DeviceList deviceList) {
+           try {
+               // 3.将获取到的设备添加到设备列表
+               mDeviceList.add(deviceList.getDevice(0));
+
+               // 4.更新设备列表
+               updateDeviceSpinnerList();
+
+               // 5.释放设备列表资源
+               deviceList.close();
+           } catch (Exception e) {
+               e.printStackTrace();
+           }
+       }
+
+       @Override
+       public void onDeviceDetach(DeviceList deviceList) {
+           try {
+               // 有设备断开连接，释放设备列表资源
+               for (Device device : mDeviceList) {
+                   device.close();
+               }
+               mDeviceList.clear();
+
+               // 重新获取设备并更新设备列表
+               DeviceList curDeviceList = mOBContext.queryDevices();
+               for (int i = 0; i < curDeviceList.getDeviceCount(); i++) {
+                   mDeviceList.add(curDeviceList.getDevice(i));
+               }
+               curDeviceList.close();
+               updateDeviceSpinnerList();
+
+               // 没有设备连接，清空传感器列表和属性列表
+               if (mDeviceList.size() <= 0) {
+                   clearPropertySpinnerList();
+               }
+
+               deviceList.close();
+           } catch (Exception e) {
+               e.printStackTrace();
+           }
+       }
+   });
+
+设备连接回调方法（onDeviceAttach）处理
+
+.. code:: java
+
+   try {
+       // 3.将获取到的设备添加到设备列表
+       mDeviceList.add(deviceList.getDevice(0));
+
+       // 4.更新设备列表
+       updateDeviceSpinnerList();
+
+       // 5.释放设备列表资源
+       deviceList.close();
+   } catch (Exception e) {
+       e.printStackTrace();
+   }
+
+设备断开连接回调方法（onDeviceDetach）处理
+
+.. code:: java
+
+   try {
+       // 有设备断开连接，释放设备列表资源
+       for (Device device : mDeviceList) {
+           device.close();
+       }
+       mDeviceList.clear();
+
+       // 重新获取设备并更新设备列表
+       DeviceList curDeviceList = mOBContext.queryDevices();
+       for (int i = 0; i < curDeviceList.getDeviceCount(); i++) {
+           mDeviceList.add(curDeviceList.getDevice(i));
+       }
+       curDeviceList.close();
+       updateDeviceSpinnerList();
+
+       // 没有设备连接，清空传感器列表和属性列表
+       if (mDeviceList.size() <= 0) {
+           clearPropertySpinnerList();
+       }
+
+       deviceList.close();
+   } catch (Exception e) {
+       e.printStackTrace();
+   }
+
+根据选择的设备更新属性列表
+
+.. code:: java
+
+   @Override
+   public void onItemSelected(AdapterView<?> parent, View view, int position, long id) {
+       switch (parent.getId()) {
+           case R.id.spi_device:
+               // 设备切换，更新传属性列表
+               mSelectDevice = mDeviceList.get(position);
+               updatePropertySpinnerList();
+
+               String deviceName = mDeviceSp.getSelectedItem().toString();
+               addNewMessage("选择设备名：" + deviceName);
+               addNewMessage(getVersionInfo(mDeviceList.get(position)));
+               // 其他case
+       }
+   }
+
+   // 更新属性列表
+   private void updatePropertySpinnerList() {
+       runOnUiThread(new Runnable() {
+           @Override
+           public void run() {
+               mDevicePropertyMap.clear();
+               mPropertyNameList.clear();
+               try {
+                   List<DevicePropertyInfo> devicePropertyList = mSelectDevice.getSupportedPropertyList();
+                   for (DevicePropertyInfo deviceProperty : devicePropertyList) {
+                       if (deviceProperty.getPropertyType() != PropertyType.STRUCT_PROPERTY
+                           && deviceProperty.getPermissionType() != PermissionType.OB_PERMISSION_DENY) {
+                           mPropertyNameList.add(deviceProperty.getPropertyName());
+                           mDevicePropertyMap.put(deviceProperty.getPropertyName(), deviceProperty);
+                       }
+                   }
+                   addNewMessage("选择设备指令");
+                   mPropertyAdapter.clear();
+                   mPropertyAdapter.addAll(mPropertyNameList);
+                   mPropertyAdapter.notifyDataSetChanged();
+
+                   mPropertySp.setSelection(0, true);
+               } catch (Exception e) {
+                   e.printStackTrace();
+               }
+           }
+       });
+   }
+
+根据选择的属性更新设置范围提示
+
+.. code:: java
+
+   @Override
+   public void onItemSelected(AdapterView<?> parent, View view, int position, long id) {
+       switch (parent.getId()) {
+           case R.id.spi_instructions:
+               // 指令切换
+               String instructionTypeName = mPropertySp.getSelectedItem().toString();
+               PermissionType permissionType = mDevicePropertyMap.get(instructionTypeName).getPermissionType();
+               addNewMessage("选择操作指令：" + instructionTypeName + " 读写权限：" + permissionType);
+               updateControlPanel(permissionType);
+               updateSetEditTextHint(instructionTypeName);
+               break;
+               // 其他case
+       }
+   }
+
+根据选择的设备更新属性列表的方法
+
+.. code:: java
+
+   private void updatePropertySpinnerList() {
+       runOnUiThread(new Runnable() {
+           @Override
+           public void run() {
+               mDevicePropertyMap.clear();
+               mPropertyNameList.clear();
+               try {
+                   List<DevicePropertyInfo> devicePropertyList = mSelectDevice.getSupportedPropertyList();
+                   for (DevicePropertyInfo deviceProperty : devicePropertyList) {
+                       if (deviceProperty.getPropertyType() != PropertyType.STRUCT_PROPERTY
+                           && deviceProperty.getPermissionType() != PermissionType.OB_PERMISSION_DENY) {
+                           mPropertyNameList.add(deviceProperty.getPropertyName());
+                           mDevicePropertyMap.put(deviceProperty.getPropertyName(), deviceProperty);
+                       }
+                   }
+                   addNewMessage("选择设备指令");
+                   mPropertyAdapter.clear();
+                   mPropertyAdapter.addAll(mPropertyNameList);
+                   mPropertyAdapter.notifyDataSetChanged();
+
+                   mPropertySp.setSelection(0, true);
+               } catch (Exception e) {
+                   e.printStackTrace();
+               }
+           }
+       });
+   }
+
+根据选择的属性更新属性的设置范围提示
+
+.. code:: java
+
+   private void updateSetEditTextHint(String instructionTypeName) {
+       mSetEt.setText("");
+       mGetTv.setText("");
+       try {
+           switch (mDevicePropertyMap.get(instructionTypeName).getPropertyType()) {
+               case INT_PROPERTY:
+                   int minI = mSelectDevice.getMinRangeI(mDevicePropertyMap.get(instructionTypeName).getProperty());
+                   int maxI = mSelectDevice.getMaxRangeI(mDevicePropertyMap.get(instructionTypeName).getProperty());
+                   mSetEt.setHint("[" + minI + "-" + maxI + "]");
+                   break;
+               case BOOL_PROPERTY:
+                   mSetEt.setHint("[" + 0 + "-" + 1 + "]");
+                   break;
+               case FLOAT_PROPERTY:
+                   float minF = mSelectDevice.getMinRangeF(mDevicePropertyMap.get(instructionTypeName).getProperty());
+                   float maxF = mSelectDevice.getMaxRangeF(mDevicePropertyMap.get(instructionTypeName).getProperty());
+                   mSetEt.setHint("[" + minF + "-" + maxF + "]");
+                   break;
+           }
+       } catch (Exception e) {
+           e.printStackTrace();
+       }
+   }
+
+设置属性
+
+.. code:: java
+
+   try {
+       String setValue = mSetEt.getText().toString();
+       // 设置设备指令
+       DevicePropertyInfo devProperty = mDevicePropertyMap.get(mPropertySp.getSelectedItem().toString());
+       switch (devProperty.getPropertyType()) {
+           case INT_PROPERTY:
+               //曝光和增益需要关闭AE才能调节， 亮度需要打开AE才能调节， 白平衡（色温）需要关闭自动白平衡才能调节
+               if (devProperty.getProperty() == DeviceProperty.OB_PROP_COLOR_EXPOSURE_INT
+                   || devProperty.getProperty() == DeviceProperty.OB_PROP_COLOR_GAIN_INT) { //曝光或增益
+                   //获取自动曝光状态
+                   boolean propertyExposureBool = false;
+                   try {
+                       propertyExposureBool = mSelectDevice.getPropertyValueB(DeviceProperty.OB_PROP_COLOR_AUTO_EXPOSURE_BOOL);
+                   } catch (Exception e) {
+
+                   }
+                   Log.d(TAG, "propertyExposureBool:" + propertyExposureBool);
+                   if (propertyExposureBool) {
+                       showToast("自动曝光未关闭，不能设置曝光或增益");
+                       return;
+                   }
+               }
+
+               if (devProperty.getProperty() == DeviceProperty.OB_PROP_COLOR_BRIGHTNESS_INT) { //亮度
+                   //获取自动曝光状态
+                   boolean propertyExposureBool = mSelectDevice.getPropertyValueB(DeviceProperty.OB_PROP_COLOR_AUTO_EXPOSURE_BOOL);
+                   Log.d(TAG, "propertyExposureBool:" + propertyExposureBool);
+                   if (!propertyExposureBool) {
+                       showToast("自动曝光未开启，不能设置亮度");
+                       return;
+                   }
+               }
+
+               if (devProperty.getProperty() == DeviceProperty.OB_PROP_COLOR_WHITE_BALANCE_INT) { //白平衡
+                   //获取自动白平衡状态
+                   boolean propertyWhiteBool = mSelectDevice.getPropertyValueB(DeviceProperty.OB_PROP_COLOR_AUTO_WHITE_BALANCE_BOOL);
+                   Log.d(TAG, "propertyWhiteBool:" + propertyWhiteBool);
+                   if (propertyWhiteBool) {
+                       showToast("自动白平衡未关闭，不能设置白平衡");
+                       return;
+                   }
+               }
+               mSelectDevice.setPropertyValueI(devProperty.getProperty(), Integer.parseInt(setValue));
+               break;
+           case BOOL_PROPERTY:
+               // 0:false 1:true
+               mSelectDevice.setPropertyValueB(devProperty.getProperty(), ("1".equals(setValue) ? true : false));
+               break;
+           case FLOAT_PROPERTY:
+               mSelectDevice.setPropertyValueF(devProperty.getProperty(), Float.parseFloat(setValue));
+               break;
+       }
+   } catch (Exception e) {
+       e.printStackTrace();
+   }
+
+获取属性
+
+.. code:: java
+
+   try {
+       // 获取设备指令
+       DevicePropertyInfo devProperty = mDevicePropertyMap.get(mPropertySp.getSelectedItem().toString());
+       switch (devProperty.getPropertyType()) {
+           case INT_PROPERTY:
+               int valueI = mSelectDevice.getPropertyValueI(devProperty.getProperty());
+               mGetTv.setText(Integer.toString(valueI));
+               break;
+           case BOOL_PROPERTY:
+               boolean valueB = mSelectDevice.getPropertyValueB(devProperty.getProperty());
+               mGetTv.setText(Boolean.toString(valueB));
+               break;
+           case FLOAT_PROPERTY:
+               float valueF = mSelectDevice.getPropertyValueF(devProperty.getProperty());
+               mGetTv.setText(Float.toString(valueF));
+               break;
+       }
+   } catch (Exception e) {
+       e.printStackTrace();
+   }
+
+资源释放
+
+.. code:: java
+
+   private void release() {
+       try {
+           // 设备列表资源释放
+           for (Device device : mDeviceList) {
+               device.close();
+           }
+           mDeviceList.clear();
+
+           // OBContext资源释放
+           if (null != mOBContext) {
+               mOBContext.close();
+               mOBContext = null;
+           }
+       } catch (Exception e) {
+           e.printStackTrace();
+       }
+   }
+
+
+录制与回放示例-Recorder & Playback
+----------------------------------
+
+功能描述: :连接设备开流 , 录制当前视频流到文件，载入视频文件进行回放。
+
+首先需要创建一个Context，用于获取设备信息列表和创建设备
+
+.. code:: java
+
+   private OBContext mOBContext;
+
+初始化SDK，并监听设备变化
+
+.. code:: java
+
+   // 1.初始化SDK, 并监听设备变化
+   mOBContext = new OBContext(getApplicationContext(), new DeviceChangedCallback() {
+       @Override
+       public void onDeviceAttach(DeviceList deviceList) {
+           try {
+               if (null == mPipeline) {
+                   // 2.创建Device, 并通过Device初始化Pipeline
+                   mDevice = deviceList.getDevice(0);
+                   mPipeline = new Pipeline(mDevice);
+
+                   // 3.更新设备信息ui
+                   updateDeviceInfoView(false);
+
+                   // 4.创建Pipeline配置
+                   mConfig = new Config();
+
+                   // 5.获取深度流配置，并配置到Config,这里配置的为640x480 Y16格式
+                   StreamProfileList depthProfileList = mPipeline.getStreamProfileList(SensorType.DEPTH);
+                   StreamProfile streamProfile = null;
+
+                   if (null != depthProfileList) {
+                       streamProfile = depthProfileList.getVideoStreamProfile(640, 480, Format.Y16, 30);
+                       depthProfileList.close();
+                   }
+
+                   if (streamProfile == null) {
+                       return;
+                   }
+
+                   // 6.使能深度流配置
+                   mConfig.enableStream(streamProfile);
+
+                   // 7.设置镜像
+                   if (mDevice.isPropertySupported(DeviceProperty.OB_PROP_DEPTH_MIRROR_BOOL, PermissionType.OB_PERMISSION_WRITE)) {
+                       mDevice.setPropertyValueB(DeviceProperty.OB_PROP_DEPTH_MIRROR_BOOL, true);
+                   }
+
+                   // 8.开流
+                   mPipeline.start(mConfig);
+
+                   // 9.释放streamProfile
+                   streamProfile.close();
+
+                   // 10.创建获取Pipeline数据线程
+                   start();
+               }
+
+               // 11.释放deviceList
+               deviceList.close();
+           } catch (Exception e) {
+               e.printStackTrace();
+           }
+       }
+
+       @Override
+       public void onDeviceDetach(DeviceList deviceList) {
+           try {
+               release();
+               updateCtlPanel(mRecordCtlPanelLL, View.VISIBLE);
+               updateCtlPanel(mPlaybackCtlPanelLL, View.VISIBLE);
+               deviceList.close();
+           } catch (Exception e) {
+               e.printStackTrace();
+           }
+       }
+   });
+
+创建设备并通过设备创建Pipeline
+
+.. code:: java
+
+   // 2.创建Device, 并通过Device初始化Pipeline
+   mDevice = deviceList.getDevice(0);
+   mPipeline = new Pipeline(mDevice);
+
+创建Pipeline配置
+
+.. code:: java
+
+   // 4.创建Pipeline配置
+   mConfig = new Config();
+
+获取深度流配置，并配置到Config，这里配置的为640x480 Y16格式
+
+.. code:: java
+
+   // 5.获取深度流配置，并配置到Config,这里配置的为640x480 Y16格式
+   StreamProfileList depthProfileList = mPipeline.getStreamProfileList(SensorType.DEPTH);
+   StreamProfile streamProfile = null;
+
+   if (null != depthProfileList) {
+       streamProfile = depthProfileList.getVideoStreamProfile(640, 480, Format.Y16, 30);
+       depthProfileList.close();
+   }
+
+   if (streamProfile == null) {
+       return;
+   }
+
+   // 6.使能深度流配置
+   mConfig.enableStream(streamProfile);
+
+通过Device属性接口设置镜像
+
+.. code:: java
+
+   // 7.设置镜像
+   if (mDevice.isPropertySupported(DeviceProperty.OB_PROP_DEPTH_MIRROR_BOOL, PermissionType.OB_PERMISSION_WRITE)) {
+       mDevice.setPropertyValueB(DeviceProperty.OB_PROP_DEPTH_MIRROR_BOOL, true);
+   }
+
+使用Config配置通过Pipeline开流，并释放局部资源
+
+.. code:: java
+
+   // 8.开流
+   mPipeline.start(mConfig);
+
+   // 9.释放streamProfile
+   streamProfile.close();
+
+开启数据流预览线程
+
+.. code:: java
+
+   private void start() {
+       mIsStreamRunning = true;
+       if (null == mStreamThread) {
+           mStreamThread = new Thread(mStreamPrevRunnable);
+           mStreamThread.start();
+       }
+   }
+
+预览线程
+
+.. code:: java
+
+   // 预览线程
+   private Runnable mStreamPrevRunnable = () -> {
+       while (mIsStreamRunning) {
+           try {
+               // 等待100ms后如果获取不到，则超时
+               FrameSet frameSet = mPipeline.waitForFrameSet(100);
+
+               if (null == frameSet) {
+                   continue;
+               }
+
+               // 获取深度流数据
+               if (!mIsPlaying) {
+                   DepthFrame frame = frameSet.getDepthFrame();
+
+                   if (frame != null) {
+                       // 获取深度数据并进行渲染
+                       byte[] frameData = new byte[frame.getDataSize()];
+                       frame.getData(frameData);
+                       synchronized (mSync) {
+                           mDepthGLView.update(frameData, frame.getWidth(), frame.getHeight(), StreamType.DEPTH, frame.getFormat());
+                       }
+
+                       // 释放深度数据帧
+                       frame.close();
+                   }
+               }
+
+               // 释放数据集
+               frameSet.close();
+           } catch (Exception e) {
+               e.printStackTrace();
+           }
+       }
+   };
+
+定义录制文件保存路径
+
+.. code:: java
+
+   private static final String BAG_FILE_PATH = "/sdcard/Orbbec/recorder.bag";
+
+开始录制
+
+.. code:: java
+
+   private void startRecord() {
+       try {
+           if (!mIsRecording) {
+               if (null != mPipeline) {
+                   // 开始录制
+                   mPipeline.startRecord(BAG_FILE_PATH);
+                   mIsRecording = true;
+                   updateCtlPanel(mPlaybackCtlPanelLL, View.INVISIBLE);
+               } else {
+                   Log.w(TAG, "mPipeline is null !");
+               }
+           }
+       } catch (Exception e) {
+           e.printStackTrace();
+       }
+   }
+
+停止录制
+
+.. code:: java
+
+   private void stopRecord() {
+       try {
+           if (mIsRecording) {
+               mIsRecording = false;
+               if (null != mPipeline) {
+                   // 停止录制
+                   mPipeline.stopRecord();
+               }
+               updateCtlPanel(mPlaybackCtlPanelLL, View.VISIBLE);
+           }
+       } catch (Exception e) {
+           e.printStackTrace();
+       }
+   }
+
+停止数据流预览线程
+
+.. code:: java
+
+   private void stop() {
+       mIsStreamRunning = false;
+       if (null != mStreamThread) {
+           try {
+               mStreamThread.join(300);
+           } catch (InterruptedException e) {
+           }
+           mStreamThread = null;
+       }
+   }
+
+定义回放状态回调
+
+.. code:: java
+
+   private MediaStateCallback mMediaStateCallback = new MediaStateCallback() {
+       @Override
+       public void onState(MediaState state) {
+           if (state == MediaState.OB_MEDIA_END) {
+               stopPlayback();
+           }
+       }
+   };
+
+定义回放线程的Runnable
+
+.. code:: java
+
+   while (mIsPlaying) {
+       try {
+           // 等待100ms后如果获取不到，则超时
+           FrameSet frameSet = mPlaybackPipe.waitForFrameSet(100);
+           if (null == frameSet) {
+               continue;
+           }
+
+           // 获取深度流数据
+           DepthFrame depthFrame = frameSet.getDepthFrame();
+           if (null != depthFrame) {
+               // 获取深度数据并进行渲染
+               byte[] frameData = new byte[depthFrame.getDataSize()];
+               depthFrame.getData(frameData);
+               synchronized (mSync) {
+                   mDepthGLView.update(frameData, depthFrame.getWidth(), depthFrame.getHeight(), StreamType.DEPTH, depthFrame.getFormat());
+               }
+
+               // 释放深度数据帧
+               depthFrame.close();
+           }
+
+           // 释放数据集
+           frameSet.close();
+       } catch (Exception e) {
+           e.printStackTrace();
+       }
+   }
+
+开始回放
+
+.. code:: java
+
+   private void startPlayback() {
+       try {
+           if (!FileUtils.isFileExists(BAG_FILE_PATH)) {
+               Toast.makeText(RecordPlaybackActivity.this, "File not found!", Toast.LENGTH_LONG).show();
+               return;
+           }
+           if (!mIsPlaying) {
+               mIsPlaying = true;
+
+               // 释放Playback资源
+               if (null != mPlayback) {
+                   mPlayback.close();
+                   mPlayback = null;
+               }
+
+               // 创建回放pipeline
+               if (null != mPlaybackPipe) {
+                   mPlaybackPipe.close();
+                   mPlaybackPipe = null;
+               }
+               mPlaybackPipe = new Pipeline(BAG_FILE_PATH);
+
+               // 通过回放Pipeline获取回放器
+               mPlayback = mPlaybackPipe.getPlayback();
+
+               // 设置回放状态回调
+               mPlayback.setMediaStateCallback(mMediaStateCallback);
+
+               // 开始回放
+               mPlaybackPipe.start(null);
+
+               // 创建回放线程
+               if (null == mPlaybackThread) {
+                   mPlaybackThread = new Thread(mPlaybackRunnable);
+                   mPlaybackThread.start();
+               }
+
+               // 更新UI
+               updateDeviceInfoView(true);
+               updateCtlPanel(mRecordCtlPanelLL, View.INVISIBLE);
+           }
+       } catch (Exception e) {
+           e.printStackTrace();
+       }
+   }
+
+停止回放
+
+.. code:: java
+
+   private void stopPlayback() {
+       try {
+           if (mIsPlaying) {
+               mIsPlaying = false;
+               // 停止回放线程
+               if (null != mPlaybackThread) {
+                   try {
+                       mPlaybackThread.join(300);
+                   } catch (InterruptedException e) {
+                   }
+                   mPlaybackThread = null;
+               }
+
+               // 停止回放
+               if (null != mPlaybackPipe) {
+                   mPlaybackPipe.stop();
+               }
+
+               // 更新UI
+               updateDeviceInfoView(false);
+               updateCtlPanel(mRecordCtlPanelLL, View.VISIBLE);
+           }
+       } catch (Exception e) {
+           e.printStackTrace();
+       }
+   }
+
+释放资源
+
+.. code:: java
+
+   try {
+       // 释放回放器
+       if (null != mPlayback) {
+           mPlayback.close();
+           mPlayback = null;
+       }
+
+       // 释放回放pipeline
+       if (null != mPlaybackPipe) {
+           mPlaybackPipe.close();
+           mPlaybackPipe = null;
+       }
+
+       // 释放config
+       if (null != mConfig) {
+           mConfig.close();
+           mConfig = null;
+       }
+
+       // 释放预览pipeline
+       if (null != mPipeline) {
+           mPipeline.close();
+           mPipeline = null;
+       }
+
+       // 释放Device
+       if (null != mDevice) {
+           mDevice.close();
+           mDevice = null;
+       }
+
+       // 释放SDK
+       if (null != mOBContext) {
+           mOBContext.close();
+       }
+
+       // 释放渲染窗口资源
+       if (mDepthGLView != null) {
+           mDepthGLView.release();
+       }
+   } catch (Exception e) {
+       e.printStackTrace();
+   }
diff --git a/docs/api/sphinx/sample/OrbbecSDK_Sample_C++.rst b/docs/api/sphinx/sample/OrbbecSDK_Sample_C++.rst
new file mode 100644
index 00000000..7f6dd101
--- /dev/null
+++ b/docs/api/sphinx/sample/OrbbecSDK_Sample_C++.rst
@@ -0,0 +1,1647 @@
+获取所有示例都可以在工程的Examples目录中找到
+
++----------------+----------+----------------------------------------+
+| **名称**       | **语言** | **描述**                               |
++================+==========+========================================+
+| HelloOrbbec    | C        | 演示连接到设备获取SDK版本和设备信息    |
++----------------+----------+----------------------------------------+
+| 传感器控制示例 | C        | 演示对设备、传感器控制命令的操作       |
++----------------+----------+----------------------------------------+
+| 彩色和深度示例 | C        | 演示使用Pipeline高级接口来             |
+|                |          | 操作设备，获取分辨率列表并选择进行设置 |
++----------------+----------+----------------------------------------+
+| 热拔插示例     | C        | 演示设备热拔                           |
+|                |          | 插监控，检测到设备上线自动连接设备打开 |
+|                |          | 深度流，检测到设备掉线自动断开设备连接 |
++----------------+----------+----------------------------------------+
+| 点云示例       | C        | 演示生成                               |
+|                |          | 深度点云或RGBD点云并保存成ply格式文件  |
++----------------+----------+----------------------------------------+
+| HelloOrbbec    | C++      | 演示连接到设备获取SDK版本和设备信息    |
++----------------+----------+----------------------------------------+
+| 深度示例       | C++      | 演示使用SDK获取深度数据并绘制显        |
+|                |          | 示、获取分辨率并进行设置、显示深度图像 |
++----------------+----------+----------------------------------------+
+| 彩色示例       | C++      | 演示使用SDK获取彩色数据并绘制显        |
+|                |          | 示、获取分辨率并进行设置、显示彩色图像 |
++----------------+----------+----------------------------------------+
+| 红外示例       | C++      | 演示使用SDK获取红外数据并绘制显        |
+|                |          | 示、获取分辨率并进行设置、显示红外图像 |
++----------------+----------+----------------------------------------+
+| 流对齐示例     | C++      | 演示对传感器数据流对齐的操作           |
++----------------+----------+----------------------------------------+
+| 传感器控制示例 | C++      | 演示对设备和传感器控制命令的操作       |
++----------------+----------+----------------------------------------+
+| 多设备示例     | C++      | 演示对多设备进行操作                   |
++----------------+----------+----------------------------------------+
+| 热拔插示例     | C++      | 演示设备                               |
+|                |          | 拔插回调的设置，并获取到插拔后处理的流 |
++----------------+----------+----------------------------------------+
+| IMU示例        | C++      | 获取IMU数据并输出显示                  |
++----------------+----------+----------------------------------------+
+| 点云示例       | C++      | 演示生成                               |
+|                |          | 深度点云或RGBD点云并保存成ply格式文件  |
++----------------+----------+----------------------------------------+
+| 存储示例       | C++      | 获取彩色和深度图并存储为png格式        |
++----------------+----------+----------------------------------------+
+| 录制示例       | C++      | 录制当前视频流到文件                   |
++----------------+----------+----------------------------------------+
+| 回放示例       | C++      | 载入视频文件进行回放                   |
++----------------+----------+----------------------------------------+
+
+C
+=
+
+HelloOrbbec
+-----------
+
+功能描述：用于演示SDK初始化、获取SDK版本、获取设备型号、获取设备序列号、获取固件版本号、SDK释放资源。
+
+   本示例基于C Low Level API进行演示
+
+首先获取并打印当前SDK版本
+
+.. code:: c
+
+   printf("SDK version: %d.%d.%d\n", ob_get_major_version(), ob_get_minor_version(), ob_get_patch_version());
+
+创建一个Context，用于获取设备信息列表和创建设备
+
+.. code:: c
+
+   ob_error*   error = NULL;
+   ob_context* ctx   = ob_create_context( &error );
+
+查询已经接入设备的列表，从而获取列表内设备数量，并通过索引号0创建获取列表内第一个设备
+
+.. code:: c
+
+   ob_device_list* dev_list = ob_query_device_list( ctx, &error );
+   int count = ob_device_list_device_count(dev_list, &error);
+   ob_device* dev = ob_get_device(dev_list, 0, &error);
+
+接下来就可以获取和这个设备相关的信息了
+
+.. code:: c
+
+   //获取设备信息
+   ob_device_info* dev_info = ob_device_get_device_info(dev, &error);
+
+   //获取设备名称
+   const char* name = ob_device_info_name(dev_info, &error);
+
+   //获取设备的pid, vid, uid
+   int pid = ob_device_info_pid(dev_info, &error);
+   int vid = ob_device_info_vid(dev_info, &error);
+   int uid = ob_device_info_uid(dev_info, &error);
+
+   //通过获取设备的固件版本号
+   const char* fw_ver = ob_device_info_firmware_version(dev_info, &error);
+
+   //通过获取设备的序列号
+   const char* sn = ob_device_info_serial_number(dev_info, &error);
+
+   //获取支持的传感器列表
+   ob_sensor_list* sensor_list = ob_device_get_sensor_list(dev, &count, &error);
+   for(int i = 0; i < count; i++)
+   {
+       ob_sensor_type sensor_type = ob_sensor_list_get_sensor_type(sensor_list， i, &error);
+       switch (sensor_type)
+       {
+         case OB_SENSOR_COLOR:
+               break;
+           case OB_SENSOR_DEPTH:
+               break;
+           case OB_SENSOR_IR:
+               break;
+       }
+   }
+
+释放资源，退出程序。
+
+.. code:: c
+
+   ob_delete_sensor_list(sensor_list, &error); //销毁sensor list
+   ob_delete_device_info(dev_info, &error); //销毁device info
+   ob_delete_device(dev, &error); //销毁device
+   ob_delete_device_list(dev_list, &error); //销毁device list
+   ob_delete_context(ctx, &error); //销毁context
+
+传感器控制示例-SensorControl
+----------------------------
+
+功能描述：本示例主要演示了对device控制命令的操作、对Sensor控制命令的操作、对Sensor进行流操作。
+
+   本示例基于C Low Level API进行演示
+
+创建一个Context，并查询已经接入设备的列表
+
+.. code:: c
+
+   ob_error*   error = NULL;
+   ob_context* ctx   = ob_create_context( &error );
+   ob_device_list* dev_list = ob_query_device_list( ctx, &error );
+
+通过索引号打印列表内设备信息
+
+.. code:: c
+
+   const char *name = ob_device_list_get_device_name(device_list, i, &g_error);
+   int pid = ob_device_list_get_device_pid(device_list, i, &g_error);
+   int vid = ob_device_list_get_device_vid(device_list, i, &g_error);
+   const char *uid = ob_device_list_get_device_uid(device_list, i, &g_error);
+   const char *sn = ob_device_list_get_device_serial_number(device_list, i, &g_error);
+   printf("%d. name: %s, pid: %d, vid: %d, uid: %s, sn: %s\n", i, name, pid, vid, uid, sn);
+
+创建一个设备
+
+.. code:: c
+
+   if(devCount <= 1) {
+       // 如果插入单个设备，默认选择第一个
+        device = ob_device_list_get_device(dev_list, 0, &g_error);
+   }
+   else {
+       // 如果有多个设备，者有用户输入选择
+       device = select_device(dev_list);  // select_device 代码请参考实例源码
+   }
+
+获取并打印当前创建的设备信息
+
+.. code:: c
+
+    ob_device_info *deviceInfo = ob_device_get_device_info(device, &g_error);
+    const char *name = ob_device_info_name(deviceInfo, &g_error);
+    int pid = ob_device_info_pid(deviceInfo, &g_error);
+    int vid = ob_device_info_vid(deviceInfo, &g_error);
+    const char *uid = ob_device_info_uid(deviceInfo, &g_error);
+    printf("Current Device: name: %s, pid: %d, vid: %d, uid: %s\n", name, pid, vid, uid);
+
+获取支持的控制命令属性
+
+.. code:: c
+
+   // 获取支持控制命令属性个数
+   uint32_t propertySize = ob_device_get_supported_property_count(device, &g_error);
+   // 通过索引号i获取控制命令属性项
+   ob_property_item property_item = ob_device_get_supported_property(device, i, &g_error);
+
+读/写控制命令
+
+.. code:: c
+
+   // 读取
+   bool_ret = ob_device_get_bool_property(device, property_item.id, &g_error);// bool型参数
+   int_ret = ob_device_get_int_property(device, property_item.id, &g_error);/ int 型参数
+   float_ret = ob_device_get_float_property(device, property_item.id, &g_error);// float型参数
+
+   // 读取命令的值范围、默认值、步进值等信息
+   ob_int_property_range   int_range;
+   ob_float_property_range float_range;
+   ob_bool_property_range  bool_range;
+   sprintf(str, "Bool value(min:0, max:1, step:1)"); // bool 型
+   int_range = ob_device_get_int_property_range(device, property_item.id, &g_error); // int 型
+   float_range = ob_device_get_float_property_range(device, property_item.id, &g_error); // float型
+
+   // 写入
+   ob_device_set_bool_property(device, property_item.id, bool_value, &g_error); // bool型参数
+   ob_device_set_int_property(device, property_item.id, int_value, &g_error); // int 型参数
+   ob_device_set_float_property(device, property_item.id, float_value, &g_error); // float型参数
+
+最后程序退出时需要释放相应的已创建资源。
+
+.. code:: c
+
+   //销毁context
+   ob_delete_context(ctx, &g_error);
+   //销毁device list
+   ob_delete_device_list(dev_list, &g_error);
+   //销毁device
+   ob_delete_device(device, &g_error);
+
+彩色和深度示例-ColorDepthViewer
+-------------------------------
+
+功能描述：本示例主要演示了使用Pipeline高级接口来操作设备，获取分辨率列表并选择进行设置。
+
+   本示例基于C High Level API进行演示
+
+首先需要创建Pipeline，用于连接设备后打开彩色和深度流
+
+.. code:: c
+
+   pipe = ob_create_pipeline( &error );
+
+创建Config，用于配置彩色和深度流的分辨率、帧率、格式
+
+.. code:: c
+
+   ob_config* config = ob_create_config( &error );
+
+配置流
+
+.. code:: c
+
+   // 2.1 配置Depth流
+   ob_stream_profile *     depth_profile = NULL;
+   ob_stream_profile_list *profiles      = ob_pipeline_get_stream_profile_list(pipe, OB_SENSOR_DEPTH, &error);
+   //根据指定的格式查找对应的Profile
+   depth_profile = ob_stream_profile_list_get_video_stream_profile(profiles, 640, 480, OB_FORMAT_Y16, 30, &error);
+   if(!depth_profile) {  // 如果没找到指定格式profile，使用profile列表中第一个profile
+        depth_profile = ob_stream_profile_list_get_profile(profiles, 0, &error);
+   }
+   ob_config_enable_stream(config, depth_profile, &error);  // 使能配置
+
+   // 2.2 配置Color流
+   ob_stream_profile *color_profile = NULL;
+   profiles                         = ob_pipeline_get_stream_profile_list(pipe, OB_SENSOR_COLOR, &error);
+   //根据指定的格式查找对应的Profile
+   color_profile = ob_stream_profile_list_get_video_stream_profile(profiles, 640, 480, OB_FORMAT_MJPG, 30, &error);
+   if(!color_profile) {  // 如果没找到指定格式profile，使用profile列表中第一个profile
+       color_profile = ob_stream_profile_list_get_profile(profiles, 0, &error);
+   }
+   ob_config_enable_stream(config, color_profile, &error);  // 使能配置
+
+帧通过功能设置
+
+.. code:: c
+
+   ob_pipeline_disable_frame_sync(pipe, &error); // 关闭帧同步功能
+
+通过Config，启动Pipeline
+
+.. code:: c
+
+   ob_pipeline_start_with_config(pipe, config, &error);
+
+Pipeline停止与销毁
+
+.. code:: c
+
+   // 停止 pipeline
+   ob_pipeline_stop(pipe, &error);
+
+   // 销毁 pipeline
+   ob_delete_pipeline(pipe, &error);
+
+热拔插示例-HotPlugin
+--------------------
+
+功能描述：
+设备热拔插监控，检测到设备上线自动连接设备打开深度流，检测到设备掉线自动断开设备连接。
+
+   本示例基于C Low Level API进行注册设备上下线回调，基于High Level
+   API进行开流取帧演示
+
+创建设备连接处理函数，函数内创建pipeline并调用create_and_start_with_config开启彩色流和深度流。
+
+.. code:: c
+
+   //设备连接处理
+   void device_connect_callback( ob_device_list* connectList ) {
+       uint32_t count = ob_device_list_device_count( connectList, &error );
+       check_error( error );
+       printf( "Device connect: %d\n", count );
+       if ( count > 0 ) {
+           if ( pipeline == NULL ) {
+               pipeline = ob_create_pipeline( &error );
+               check_error( error );
+               create_and_start_with_config();
+           }
+       }
+   }
+
+创建设备断开处理函数，函数内将pipeline停止，并将退出pipeline标记isExit设为true
+
+.. code:: c
+
+   //设备断开处理
+   void device_disconnect_callback( ob_device_list* disconnectList ) {
+       uint32_t count = ob_device_list_device_count( disconnectList, &error );
+       check_error( error );
+       printf( "Device disconnect: %d\n", count );
+       if ( count > 0 ) {
+           ob_pipeline_stop( pipeline, &error );
+           check_error( error );
+           isExit = true;
+       }
+   }
+
+设备连接、断开处理函数将会在设备上下线回调函数内被调用
+
+.. code:: c
+
+   //设备状态改变回调
+   void on_device_changed_callback( ob_device_list* removed, ob_device_list* added, void* pCallback ) {
+       device_disconnect_callback( removed );
+       device_connect_callback( added );
+   }
+
+主函数main内，首先需要创建一个Context并注册设备上下线回调
+
+.. code:: c
+
+    //创建上下文
+   ob_context* ctx = ob_create_context( &error );
+
+   //注册设备回调
+   ob_set_device_changed_callback( ctx, on_device_changed_callback, NULL, &error );
+
+主循环主要任务是，当pipeline在设备上线后已创建启动，从pipeline获取数据帧集合，并将数据帧集合内的Color和Depth相关信息打印输出。
+
+.. code:: c
+
+   //等待一帧数据，超时时间为100ms
+   ob_frame* frameset = ob_pipeline_wait_for_frameset( pipeline, 100, &error );
+   if ( frameset ) {
+       //获取深度数据帧
+       ob_frame* depth_frame = ob_frameset_depth_frame( frameset, &error );
+       if ( depth_frame ) {
+           printf( "=====Depth Frame Info======Index: %lld TimeStamp: %lld\n", ob_frame_index( depth_frame, &error ), ob_frame_time_stamp( depth_frame, &error ) );
+           //释放深度数据帧
+           ob_delete_frame( depth_frame, &error );
+       }
+       //获取Color数据帧
+       ob_frame* color_frame = ob_frameset_color_frame( frameset, &error );
+       if ( color_frame ) {
+           printf( "=====Color Frame Info======Index: %lld TimeStamp: %lld\n", ob_frame_index( color_frame, &error ), ob_frame_time_stamp( color_frame, &error ) );
+           //释放Color数据帧
+           ob_delete_frame( color_frame, &error );
+       }
+       //释放frameSet
+       ob_delete_frame( frameset, &error );
+   }
+
+退出主循环后，需要将相关资源释放
+
+.. code:: c
+
+   if ( pipeline ) {
+       //停止pipeline
+       ob_pipeline_stop( pipeline, &error );
+       // 销毁pipeline
+       ob_delete_pipeline( pipeline, &error );
+   }
+   // 销毁dev_list
+   if ( dev_list ) {
+       ob_delete_device_list( dev_list, &error );
+   }
+   // 销毁ctx
+   if ( ctx ) {
+       ob_delete_context( ctx, &error );
+   }
+
+点云实例-PointCloud
+-------------------
+
+功能描述：连接设备开流，生成深度点云或RGBD点云并保存成ply格式文件。
+
+   本示例基于C++ High Level API进行演示
+
+创建点云保存成ply格式文件函数，ply文件格式详细描述可在网络上查看
+
+.. code:: c
+
+   //保存点云数据到ply
+   void save_points_to_ply( ob_frame* frame, const char* fileName ) {
+       int pointsSize = ob_frame_data_size( frame, &error ) / sizeof( ob_point );
+       check_error( error );
+
+       FILE* fp = fopen( fileName, "wb+" );
+       fprintf( fp, "ply\n" );
+       fprintf( fp, "format ascii 1.0\n" );
+       fprintf( fp, "element vertex %d\n", pointsSize );
+       fprintf( fp, "property float x\n" );
+       fprintf( fp, "property float y\n" );
+       fprintf( fp, "property float z\n" );
+       fprintf( fp, "end_header\n" );
+
+       ob_point* point = ( ob_point* )ob_frame_data( frame, &error );
+       check_error( error );
+       for ( int i = 0; i < pointsSize; i++ ) {
+           fprintf( fp, "%.3f %.3f %.3f\n", point->x, point->y, point->z );
+           point++;
+       }
+
+       fflush( fp );
+       fclose( fp );
+   }
+
+   //保存彩色点云数据到ply
+   void save_rgb_points_to_ply( ob_frame* frame, const char* fileName ) {
+       int pointsSize = ob_frame_data_size( frame, &error ) / sizeof( ob_color_point );
+       check_error( error );
+
+       FILE* fp = fopen( fileName, "wb+" );
+       fprintf( fp, "ply\n" );
+       fprintf( fp, "format ascii 1.0\n" );
+       fprintf( fp, "element vertex %d\n", pointsSize );
+       fprintf( fp, "property float x\n" );
+       fprintf( fp, "property float y\n" );
+       fprintf( fp, "property float z\n" );
+       fprintf( fp, "property uchar red\n" );
+       fprintf( fp, "property uchar green\n" );
+       fprintf( fp, "property uchar blue\n" );
+       fprintf( fp, "end_header\n" );
+
+       ob_color_point* point = ( ob_color_point* )ob_frame_data( frame, &error );
+       check_error( error );
+
+       for ( int i = 0; i < pointsSize; i++ ) {
+           fprintf( fp, "%.3f %.3f %.3f %d %d %d\n", point->x, point->y, point->z, ( int )point->r, ( int )point->g, ( int )point->b );
+           point++;
+       }
+
+       fflush( fp );
+       fclose( fp );
+   }
+
+创建Pipeline及流配置
+
+.. code:: c
+
+       //创建pipeline 用于连接设备后打开Color和Depth流
+       pipeline = ob_create_pipeline( &error );
+       //创建config，用于配置 Color 和 Depth 流的 分辨率、帧率、格式
+       ob_config* config = ob_create_config( &error );
+
+        //配置Depth流
+       ob_stream_profile *     depth_profile = NULL;
+       ob_stream_profile_list *profiles      = ob_pipeline_get_stream_profile_list(pipeline, OB_SENSOR_DEPTH, &error);
+       //根据指定的格式查找对应的Profile
+       depth_profile = ob_stream_profile_list_get_video_stream_profile(profiles, 640, 480, OB_FORMAT_Y16, 30, &error);
+       ob_config_enable_stream(config, depth_profile, &error);  // 使能配置
+
+       //配置Color流
+       ob_stream_profile *color_profile = NULL;
+       profiles                         = ob_pipeline_get_stream_profile_list(pipeline, OB_SENSOR_COLOR, &error);
+       //根据指定的格式查找对应的Profile
+       color_profile = ob_stream_profile_list_get_video_stream_profile(profiles, 640, 480, OB_FORMAT_YUYV, 0, &error);
+       //如果没找到YUYV，查找I420格式
+       if(!color_profile) {
+           color_profile = ob_stream_profile_list_get_video_stream_profile(profiles, 640, 480, OB_FORMAT_I420, 0, &error);
+           check_error(error);
+       }
+       ob_config_enable_stream( config, color_profile, &error );  // 使能配置
+
+从Pipeline上获取当前打开的设备，用以打开设备D2C功能
+
+.. code:: c
+
+       //获取device句柄
+       ob_device *device = ob_pipeline_get_device(pipeline, &error);
+       //判断设备是否支持硬件D2C对齐功能，如果支持则开启
+       if(device && ob_device_is_property_supported(device, OB_PROP_DEPTH_ALIGN_HARDWARE_BOOL, OB_PERMISSION_WRITE, &error)) {
+           // 开启硬件D2C对齐
+           ob_device_set_bool_property(device, OB_PROP_DEPTH_ALIGN_HARDWARE_BOOL, true, &error);
+       }
+
+开流，并在开流后创建点云filter。点云filter用于将depth和color帧数据转换成点云数据。点云filter在开流后创建目的是让SDK内部自动根据当前开流配置设置好相机参数。当然也可以自行设置。
+
+.. code:: c
+
+       // 创建点云Filter对象（点云Filter创建时会在Pipeline内部获取设备参数, 所以尽量在Filter创建前配置好设备）
+       ob_filter* point_cloud = ob_pipeline_create_pointcloud_filter( pipeline, &error );
+       // 自行设置filter参数
+       if ( device && ob_device_is_property_supported( device, OB_DATA_TYPE_CAMERA_PARA, &error ) ) {
+           CAMERA_PARA cameraParam = {0};
+           uint32_t    len;
+           ob_device_get_structured_data( device, OB_DATA_TYPE_CAMERA_PARA, &cameraParam,&len, &error );
+           ob_pointcloud_filter_set_camera_parameter(point_cloud,cameraParam,error);
+       }
+
+启动主循环，循环内根据用户按键调用点云filter生成深度点云或RGBD点云数据，并保存成ply文件。
+
+.. code:: c
+
+   //等待一帧数据，超时时间为100ms
+   ob_frame* frameset = ob_pipeline_wait_for_frames( pipeline, 100, &error );
+   if ( frameset != NULL )
+   {
+       //按R键保存ply数据
+       if ( ( key == 'R' || key == 'r' ) && frameset != NULL ) {
+           ob_pointcloud_filter_set_point_format( point_cloud, OB_FORMAT_RGB_POINT, &error );
+           ob_frame *pointsFrame = ob_filter_process(point_cloud, frameset, &error);
+           save_rgb_points_to_ply( pointsFrame, "rgb_points.ply" );
+           ob_delete_frame( pointsFrame, &error );
+       }
+       else if ( ( key == 'D' || key == 'd' ) && frameset != NULL ) {
+           //生成点云并保存
+           ob_pointcloud_filter_set_point_format( point_cloud, OB_FORMAT_POINT, &error );
+           ob_frame *pointsFrame = ob_filter_process(point_cloud, frameset, &error);
+           save_points_to_ply( pointsFrame, "points.ply" );
+           ob_delete_frame( pointsFrame, &error );
+       }
+       ob_delete_frame( frameset, &error );  // 销毁frameSet 回收内存
+   }
+
+主循环退出后，停流并销毁回收资源
+
+.. code:: c
+
+       // 停止pipeline
+       ob_pipeline_stop( pipeline, &error );
+
+       // 销毁pipeline
+       ob_delete_pipeline( pipeline, &error );
+
+       ob_delete_context( ctx, &error );
+
+.. _c-1:
+
+C++
+===
+
+.. _helloorbbec-1:
+
+HelloOrbbec
+-----------
+
+功能描述：用于演示SDK初始化、获取SDK版本、获取设备型号、获取设备序列号、获取固件版本号、SDK释放资源。
+
+   本示例基于C++ Low Level API进行演示
+
+打印SDK的版本号，SDK版本号分为主版本号，副版本号和修订版本号
+
+.. code:: cpp
+
+   std::cout << "SDK version: " << ob::Version::getMajor() << "." << ob::Version::getMinor() << "." << ob::Version::getPatch() << std::endl;
+
+首先需要创建一个Context，用于获取设备信息列表和创建设备
+
+.. code:: cpp
+
+   ob::Context ctx;
+
+查询已经接入设备的列表
+
+.. code:: cpp
+
+   auto devList = ctx.queryDeviceList();
+
+   //获取接入设备的数量
+   devList->deviceCount()
+
+创建设备
+
+.. code:: cpp
+
+   //创建设备，0表示第一个设备的索引
+   auto dev = devList->getDevice(0);
+
+接下来就可以获取和这个设备相关的信息：设备信息、设备的名称、获取设备的pid,
+vid, uid、设备的固件版本号、设备的序列号
+
+.. code:: cpp
+
+   //获取设备信息
+   auto devInfo = dev->getDeviceInfo();
+
+   //获取设备的名称
+   std::cout << "Device name: " << devInfo->name() << std::endl;
+
+   //获取设备的pid, vid, uid
+   std::cout << "Device pid: " << devInfo->pid() << " vid: " << devInfo->vid() << " uid: " << devInfo->uid() << std::endl;
+
+   //获取设备的固件版本号
+   auto fwVer = devInfo->firmwareVersion();
+   std::cout << "Firmware version: " << fwVer << std::endl;
+
+   //获取设备的序列号
+   auto sn = devInfo->serialNumber();
+   std::cout << "Serial number: " << sn << std::endl;
+
+获取支持的传感器列表
+
+::
+
+   //获取支持的传感器列表
+   std::cout << "Sensor types: " << std::endl;
+   auto sensorList = dev->getSensorList();
+   for(uint32_t i = 0; i < sensorList->count(); i++) {
+       auto sensor = sensorList->getSensor(i);
+       switch(sensor->type()) {
+       case OB_SENSOR_COLOR:
+           std::cout << "\tColor sensor" << std::endl;
+           break;
+       case OB_SENSOR_DEPTH:
+           std::cout << "\tDepth sensor" << std::endl;
+           break;
+       case OB_SENSOR_IR:
+           std::cout << "\tIR sensor" << std::endl;
+           break;
+       case OB_SENSOR_GYRO:
+           std::cout << "\tGyro sensor" << std::endl;
+           break;
+       case OB_SENSOR_ACCEL:
+           std::cout << "\tAccel sensor" << std::endl;
+           break;
+       default:
+           break;
+       }
+   }
+
+控制台结果输出如下：\ |image.png|
+
+深度示例-DepthViewer
+--------------------
+
+功能描述：本示例主要演示了使用SDK获取深度数据并绘制显示、获取分辨率并选择进行设置、显示深度图像，并通过ESC键退出。
+
+   本示例基于C++ High Level API进行演示
+
+首先需要创建一个Pipeline，通过Pipeline可以很容易的打开和关闭多种类型的流并获取一组帧数据
+
+.. code:: cpp
+
+   ob::Pipeline pipe;
+
+获取深度相机的所有流配置，包括流的分辨率，帧率，以及帧的格式
+
+.. code:: cpp
+
+   auto profiles = pipe.getStreamProfileList(OB_SENSOR_DEPTH);
+
+   //通过遍历深度流的配置来获取要使用的帧格式，这里将使用Y16格式来打开流
+   std::shared_ptr<ob::StreamProfile> depthProfile;
+       for (int i = 0; i < profiles->count(); i++)
+       {
+           auto profile = profiles->getProfile(i);
+           if(profile->format() == OB_FORMAT_Y16){
+               depthProfile = profile;
+               break;
+           }
+       }
+
+   //也可以通过设置感兴趣项，返回对应Profile列表的首个Profile
+   // auto depthProfile = profiles->getVideoStreamProfile(640, 480, OB_FORMAT_Y16);
+
+   //如果没找到合适的流配置，打开列表中的首个配置
+   if(!depthProfile) {
+       depthProfile = profiles->getProfile(0)->as<ob::VideoStreamProfile>();
+   }
+
+通过创建Config来配置Pipeline要启用或者禁用哪些流，这里将启用深度流
+
+.. code:: cpp
+
+   std::shared_ptr<ob::Config> config = std::make_shared<ob::Config>();
+   config->enableStream(depthProfile);
+
+启动在Config中配置的流，如果不传参数，将启动默认配置启动流
+
+.. code:: cpp
+
+   pipe.start(config);
+
+设置镜像模式，先判断设备是否有可读可写的权限，再进行设置
+
+.. code:: cpp
+
+   //获取镜像属性是否有可写的权限
+   if(pipe.getDevice()->isPropertySupported(OB_PROP_DEPTH_MIRROR_BOOL, OB_PERMISSION_WRITE)) {
+       //设置镜像
+       pipe.getDevice()->setBoolProperty(OB_PROP_DEPTH_MIRROR_BOOL, true);
+   }
+
+以阻塞的方式等待一帧数据，该帧是一个复合帧，里面包含配置里启用的所有流的帧数据，并设置帧的等待超时时间
+
+.. code:: cpp
+
+   auto frameSet = pipe.waitForFrames(100);    //设置等待时间为100ms
+
+停止Pipeline，将不再产生帧数据
+
+.. code:: cpp
+
+   pipe.stop();
+
+最终的深度图显示如下\ |image.png|\ 程序正常退出之后资源将会自动释放
+
+彩色示例-ColorViewer
+--------------------
+
+功能描述：本示例主要演示了使用SDK获取彩色数据并绘制显示、获取分辨率并选择进行设置、显示彩色图像，并通过ESC键退出。
+
+   本示例基于C++ High Level API进行演示
+
+首先需要创建一个Pipeline，通过Pipeline可以很容易的打开和关闭多种类型的流并获取一组帧数据
+
+.. code:: cpp
+
+   ob::Pipeline pipe;
+
+获取彩色相机的所有流配置，包括流的分辨率，帧率，以及帧的格式
+
+.. code:: cpp
+
+   auto profiles = pipe.getStreamProfiles(OB_SENSOR_COLOR);
+
+   //通过遍历彩色流的配置来获取要使用的帧格式，这里将使用MJPG格式来打开流
+   std::shared_ptr< ob::StreamProfile > colorProfile;
+   for (int i = 0; i < profiles->count(); i++) {
+       auto profile = profiles->getProfile(i);
+       if (profile->format() == OB_FORMAT_MJPG) {
+           colorProfile = profile;
+           break;
+       }
+   }
+
+   //也可以通过接口设置感兴趣项，返回对应Profile列表的首个Profile
+   // auto colorProfile = profiles->getVideoStreamProfile(640, 480, OB_FORMAT_MJPG);
+
+   //如果没找到合适的流配置，打开列表中的首个配置
+   if(!colorProfile) {
+       colorProfile = profiles->getProfile(0)->as<ob::VideoStreamProfile>();
+   }
+
+通过创建Config来配置Pipeline要启用或者禁用哪些流，这里将启用彩色流
+
+.. code:: cpp
+
+   std::shared_ptr<ob::Config> config = std::make_shared<ob::Config>();
+   config->enableStream(colorProfile);
+
+启动在Config中配置的流
+
+.. code:: cpp
+
+   pipe.start(config);
+
+设置镜像模式，先判断设备是否有可读可写的权限，再进行设置
+
+.. code:: cpp
+
+   //获取镜像属性是否有可写的权限
+   if(pipe.getDevice()->isPropertySupported(OB_PROP_COLOR_MIRROR_BOOL, OB_PERMISSION_WRITE)) {
+       //设置镜像
+       pipe.getDevice()->setBoolProperty(OB_PROP_COLOR_MIRROR_BOOL, true);
+   }
+
+以阻塞的方式等待一帧数据，该帧是一个复合帧，里面包含配置里启用的所有流的帧数据，并设置帧的等待超时时间
+
+.. code:: cpp
+
+   auto frameSet = pipe.waitForFrames(100);    //设置等待时间为100ms
+
+停止Pipeline，将不再产生帧数据
+
+.. code:: cpp
+
+   pipe.stop();
+
+最终的彩色图显示如下\ |1640769142832_A167CC70-8856-4af1-978F-FC28D9CAB32F.png|\ 程序正常退出之后资源将会自动释放
+
+红外示例-InfraredViewer
+-----------------------
+
+功能描述：本示例主要演示了使用SDK获取红外数据并绘制显示、获取分辨率并选择进行设置、显示红外图像，并通过ESC键退出。
+
+   本示例基于C++ High Level API进行演示
+
+首先需要创建一个Pipeline，通过Pipeline可以很容易的打开和关闭多种类型的流并获取一组帧数据
+
+.. code:: cpp
+
+   ob::Pipeline pipe;
+
+通过输入的分辨率，格式，帧率等感兴趣项来获取红外相机的流配置
+
+.. code:: cpp
+
+   //通过接口设置感兴趣项，返回对应Profile列表的首个Profile
+   auto irProfile = profiles->getVideoStreamProfile(640, 480, OB_FORMAT_Y16);
+   if(!irProfile) {
+       irProfile = profiles->getProfile(0)->as<ob::VideoStreamProfile>();
+   }
+
+通过创建Config来配置Pipeline要启用或者禁用哪些流，这里将启用红外流
+
+.. code:: cpp
+
+   std::shared_ptr<ob::Config> config = std::make_shared<ob::Config>();
+   config->enableStream(irProfile);
+
+启动在Config中配置的流，如果不传参数，将启动默认配置启动流
+
+.. code:: cpp
+
+   pipe.start(config);
+
+设置镜像模式，先判断设备是否有可读可写的权限，再进行设置
+
+.. code:: cpp
+
+   //获取镜像属性是否有可写的权限
+   if(pipe.getDevice()->isPropertySupported(OB_PROP_COLOR_MIRROR_BOOL, OB_PERMISSION_WRITE)) {
+       //设置镜像
+       pipe.getDevice()->setBoolProperty(OB_PROP_COLOR_MIRROR_BOOL, true);
+   }
+
+以阻塞的方式等待一帧数据，该帧是一个复合帧，里面包含配置里启用的所有流的帧数据，并设置帧的等待超时时间
+
+::
+
+   auto frameSet = pipe.waitForFrames(100);    //设置等待时间为100ms
+
+停止Pipeline，将不再产生帧数据
+
+.. code:: cpp
+
+   pipe.stop();
+
+程序正常退出之后资源将会自动释放
+
+流对齐示例-SyncAlignViewer
+--------------------------
+
+功能描述：本示例主要演示了对Sensor数据流控制对齐的操作。
+
+   本示例基于C++ High Level API进行演示
+
+首先需要创建一个Pipeline，通过Pipeline可以很容易的打开和关闭多种类型的流并获取一组帧数据
+
+.. code:: cpp
+
+   ob::Pipeline pipe;
+
+获取彩色相机和深度相机的所有流配置，包括流的分辨率，帧率，以及帧的格式
+
+.. code:: cpp
+
+   //获取彩色相机的所有流配置，包括流的分辨率，帧率，以及帧的格式
+   auto colorProfiles = pipe.getStreamProfileList(OB_SENSOR_COLOR);
+
+   //通过接口设置感兴趣项，返回对应Profile列表的首个Profile
+   auto colorProfile = colorProfiles->getVideoStreamProfile(colorWidth, colorHeight, OB_FORMAT_MJPG, 30);
+   if(!colorProfile) {
+       colorProfile = colorProfiles->getProfile(0)->as<ob::VideoStreamProfile>();
+   }
+
+   //获取深度相机的所有流配置，包括流的分辨率，帧率，以及帧的格式
+   auto depthProfiles = pipe.getStreamProfileList(OB_SENSOR_DEPTH);
+
+   //通过接口设置感兴趣项，返回对应Profile列表的首个Profile
+   auto depthProfile = depthProfiles->getVideoStreamProfile(depthWidth, depthHeight, OB_FORMAT_Y16, 30);
+   if(!depthProfile) {
+       depthProfile = depthProfiles->getProfile(0)->as<ob::VideoStreamProfile>();
+   }
+
+通过创建Config来配置Pipeline要启用或者禁用哪些流，这里将启用彩色流和深度流
+
+::
+
+   std::shared_ptr<ob::Config> config = std::make_shared<ob::Config>();
+   config->enableStream(colorProfile);
+   config->enableStream(depthProfile);
+
+控制流对齐，此处开启软件对齐
+
+::
+
+   // 配置对齐模式为软件D2C对齐
+   config->setAlignMode(ALIGN_D2C_SW_MODE);
+
+启动在Config中配置的流，如果不传参数，将启动默认配置启动流
+
+::
+
+   pipe.start(config);
+
+停止Pipeline，将不再产生帧数据
+
+::
+
+   pipe.stop();
+
+程序正常退出之后资源将会自动释放
+
+.. _传感器控制示例-sensorcontrol-1:
+
+传感器控制示例-SensorControl
+----------------------------
+
+功能描述：本示例主要演示了对device控制命令的操作、对Sensor控制命令的操作、对Sensor进行流操作。
+
+   本示例基于C++ Low Level API进行演示
+
+首先需要创建一个Context，用于获取设备信息列表和创建设备
+
+::
+
+   ob::Context ctx;
+
+查询设备信息列表
+
+::
+
+   auto devList = ctx.queryDeviceList();
+
+选择一个设备进行操作，如果插入单个设备默认选择并打开，如果存在多个设备提供选择
+
+::
+
+   //选择一个设备进行操作
+   std::shared_ptr<ob::Device> device = nullptr;
+   if(deviceList->deviceCount() > 0) {
+       if(deviceList->deviceCount() <= 1) {
+       //如果插入单个设备，默认选择第一个
+           device = deviceList->getDevice(0);
+       }
+       else {
+           device = selectDevice(deviceList);
+       }
+   }
+
+控制命令控制，获取Property的范围，设置属性，获取属性
+
+::
+
+   //获取Property的范围
+   OBBoolPropertyRange  bool_range = device->getBoolPropertyRange(property_item.id)
+   OBIntPropertyRange   int_range = device->getIntPropertyRange(property_item.id)
+   OBFloatPropertyRange float_range = device->getFloatPropertyRange(property_item.id)
+
+   //设置属性
+   device->setBoolProperty(propertyItem.id, bool_value);
+   device->setIntProperty(propertyItem.id, int_value);
+   device->setFloatProperty(propertyItem.id, float_value);
+
+   //获取属性
+   bool bool_ret = device->getBoolProperty(propertyItem.id);
+   int int_ret = device->getIntProperty(propertyItem.id);
+   float float_ret = device->getFloatProperty(propertyItem.id);
+
+程序正常退出之后资源将会自动释放
+
+多设备示例-MultiDevice
+----------------------
+
+功能描述：本示例主要演示了对多设备进行操作。
+
+   本示例基于C++ High Level API进行演示
+
+首先需要创建一个Context，获取设备信息列表用于创建设备及Pipeline
+
+::
+
+   ob::Context ctx;
+   //查询已经接入设备的列表
+   auto devList = ctx.queryDeviceList();
+   //获取接入设备的数量
+   int devCount = devList->deviceCount();
+
+创建设备，并通过设备创建Pipeline
+
+.. code:: cpp
+
+   //遍历设备列表并创建设备
+   std::vector<std::shared_ptr<ob::Device>> devices;
+   for (int i = 0; i < devCount; i++)
+   {
+       //获取设备并创建pipeline
+       auto dev  = devList->getDevice( i );
+       auto pipe = std::make_shared< ob::Pipeline >( dev );
+       pipes.push_back( pipe );
+   }
+
+打开多个设备的深度和彩色流
+
+.. code:: cpp
+
+   for(auto &&pipe: pipes) {
+       //获取深度相机配置列表
+       auto depthProfileList = pipe->getStreamProfileList(OB_SENSOR_DEPTH);
+
+       //通过接口设置感兴趣项，返回对应Profile列表的首个Profile
+       auto depthProfile = depthProfileList->getVideoStreamProfile(640, 480, OB_FORMAT_Y16)->as<ob::VideoStreamProfile>();
+       if(!depthProfile) {
+           depthProfile = depthProfileList->getProfile(0)->as<ob::VideoStreamProfile>();
+       }
+       config->enableStream(depthProfile);
+
+       //获取彩色相机配置列表
+       auto colorProfileList = pipe->getStreamProfileList(OB_SENSOR_COLOR);
+
+       //通过接口设置感兴趣项，返回对应Profile列表的首个Profile
+       auto colorProfile = colorProfileList->getVideoStreamProfile(640, 480, OB_FORMAT_MJPG)->as<ob::VideoStreamProfile>();
+       if(!colorProfile) {
+          colorProfile = colorProfileList->getProfile(0)->as<ob::VideoStreamProfile>();
+       }
+       config->enableStream(colorProfile);
+
+       //启动pipeline，并传入配置
+       pipe->start(config, [i](std::shared_ptr<ob::FrameSet> frameSet) {
+           std::lock_guard<std::mutex> lock(frameMutex);
+           if(frameSet->colorFrame() && frameSet->depthFrame()) {
+               colorFrames[i] = frameSet->colorFrame();
+               depthFrames[i] = frameSet->depthFrame();
+           }
+       });
+       i++;
+   }
+
+停止所有设备已打开的流
+
+.. code:: cpp
+
+
+   void StopStream( std::vector< std::shared_ptr< ob::Pipeline > > pipes) {
+       int i = 0;
+       for ( auto&& pipe : pipes ) {
+           if(colorFrames[i])
+               colorFrames->reset();
+           if(depthFrames[i])
+               depthFrames->reset();
+           if(irFrames[i])
+               irFrames->reset();
+           //停止pipeline
+           pipe->stop();
+           i++;
+       }
+   }
+
+程序正常退出之后资源将会自动释放
+
+.. _热拔插示例-hotplugin-1:
+
+热拔插示例-HotPlugin
+--------------------
+
+功能描述：本示例主要演示设备拔插回调的设置，以及拔插之后处理获取到的流
+
+   本示例基于C++ High Level API进行演示
+
+首先需要创建一个Context，用于获取设备信息列表和创建设备
+
+::
+
+   ob::Context ctx;
+
+注册设备回调，分别在设备拔插的时候执行相关函数
+
+::
+
+   ctx.setDeviceChangedCallback( []( std::shared_ptr< ob::DeviceList > removedList, std::shared_ptr< ob::DeviceList > addedList ) {
+           DeviceDisconnectCallback( removedList );
+           DeviceConnectCallback( addedList );
+       } );
+
+按照配置文件中配置的分辨率和格式进行开流
+
+::
+
+   //按配置文件的流配置启动流，如果没有配置文件，将使用第0个流配置启动流
+   try{
+     pipeline->start(nullptr);
+   }catch(...){
+     std::cout<<"Pipeline start failed!"<<std::endl;
+   }
+   //获取深度相机的所有流配置，包括流的分辨率，帧率，以及帧的格式
+   auto depthProfiles = pipeline->getStreamProfileList(OB_SENSOR_DEPTH);
+   //获取对应流配置列表的第0个Profile，如果有配置文件，配置文件里面流配置是流配置列表的第0个
+   auto depthProfile = depthProfiles->getProfile(0)->as<ob::VideoStreamProfile>();
+   //获取彩色相机的所有流配置，包括流的分辨率，帧率，以及帧的格式
+   auto colorProfiles = pipeline->getStreamProfileList(OB_SENSOR_COLOR);
+   //获取对应流配置列表的第0个Profile，如果有配置文件，配置文件里面流配置是流配置列表的第0个
+   auto colorProfile = colorProfiles->getProfile(0)->as<ob::VideoStreamProfile>();
+   //获取帧率
+   colorFps = colorProfile->fps();
+   depthFps = depthProfile->fps();
+
+以阻塞的方式等待一帧数据，该帧是一个复合帧，里面包含配置里启用的所有流的帧数据，并设置帧的等待超时时间
+
+::
+
+   auto frameSet = pipe.waitForFrames(100);    //设置等待时间为100ms
+
+停止Pipeline，将不再产生帧数据
+
+::
+
+   pipe.stop();
+
+程序正常退出之后资源将会自动释放
+
+IMU示例-ImuReader
+-----------------
+
+功能描述：本示例主要演示了使用SDK获取IMU数据并输出显示，并通过ESC键退出。
+
+   本示例基于C++ Low Level API进行演示
+
+打印SDK的版本号，SDK版本号分为主版本号，副版本号和修订版本号
+
+.. code:: cpp
+
+   //打印SDK的版本号，SDK版本号分为主版本号，副版本号和修订版本号
+   std::cout << "SDK version: " << ob::Version::getMajor() << "." << ob::Version::getMinor() << "." << ob::Version::getPatch() << std::endl;
+
+首先需要创建一个Context，用于获取设备信息列表和创建设备
+
+.. code:: cpp
+
+   ob::Context ctx;
+
+查询已经接入设备的列表
+
+.. code:: cpp
+
+   auto devList = ctx.queryDeviceList();
+
+   //获取接入设备的数量
+   devList->deviceCount()
+
+创建设备
+
+.. code:: cpp
+
+   //创建设备，0表示第一个设备的索引
+   auto dev = devList->getDevice(0);
+
+获取陀螺仪传感器和加速度传感器
+
+.. code:: cpp
+
+   auto gyroSensor = dev->getSensorList()->getSensor( OB_SENSOR_GYRO );
+
+   auto accelSensor = dev->getSensorList()->getSensor( OB_SENSOR_ACCEL );
+
+获取陀螺仪传感器的配置列表并选择第一个配置开流，在开流的回调里获取帧的数据，加速度传感器同理
+
+.. code:: cpp
+
+   auto profiles = gyroSensor->getStreamProfileList();
+   auto profile = profiles->getProfile( 0 );
+   gyroSensor->start( profile, []( std::shared_ptr< ob::Frame > frame ) {
+           auto timeStamp = frame->timeStamp();
+       auto gyroFrame = frame->as< ob::GyroFrame >();
+       if ( gyroFrame != nullptr && ( timeStamp % 500 ) < 2 ) {  //  ( timeStamp % 500 ) < 2: 目的时减少打印频率
+               std::cout << "Gyro Frame: \n{\n";
+           std::cout << "  tsp = " << timeStamp << std::endl;
+           std::cout << "  temperature = " << gyroFrame->temperature() << std::endl;
+           auto value = gyroFrame->value();
+           std::cout << "  gyro.x = " << value.x << " dps" << std::endl;
+           std::cout << "  gyro.y = " << value.y << " dps" << std::endl;
+           std::cout << "  gyro.z = " << value.z << " dps" << std::endl;
+           std::cout << "}" << std::endl << std::endl;
+       }
+    } );
+
+关流
+
+.. code:: cpp
+
+   gyroSensor->stop();
+   accelSensor->stop();
+
+程序正常退出之后资源将会自动释放
+
+点云示例-PointCloud
+-------------------
+
+功能描述：连接设备开流 ,生成深度点云或RGBD点云并保存成ply格式文件
+
+   本示例基于C++ High Level API进行演示
+
+创建点云保存成ply格式文件函数，ply文件格式详细描述可在网络上查看首先创建两个函数来保存从流里面获取到的点云数据，这是保存普通点云数据的函数
+
+.. code:: cpp
+
+   //保存点云数据到ply
+   void savePointsToPly(std::shared_ptr<ob::Frame> frame, std::string fileName) {
+       int   pointsSize = frame->dataSize() / sizeof(OBPoint);
+       FILE *fp         = fopen(fileName.c_str(), "wb+");
+       fprintf(fp, "ply\n");
+       fprintf(fp, "format ascii 1.0\n");
+       fprintf(fp, "element vertex %d\n", pointsSize);
+       fprintf(fp, "property float x\n");
+       fprintf(fp, "property float y\n");
+       fprintf(fp, "property float z\n");
+       fprintf(fp, "end_header\n");
+
+       OBPoint *point = (OBPoint *)frame->data();
+       for(int i = 0; i < pointsSize; i++) {
+           fprintf(fp, "%.3f %.3f %.3f\n", point->x, point->y, point->z);
+           point++;
+       }
+
+       fflush(fp);
+       fclose(fp);
+   }
+
+再创建一个保存彩色点云数据的函数用于存储彩色点云数据
+
+.. code:: cpp
+
+   //保存彩色点云数据到ply
+   void saveRGBPointsToPly(std::shared_ptr<ob::Frame> frame, std::string fileName) {
+       int   pointsSize = frame->dataSize() / sizeof(OBColorPoint);
+       FILE *fp         = fopen(fileName.c_str(), "wb+");
+       fprintf(fp, "ply\n");
+       fprintf(fp, "format ascii 1.0\n");
+       fprintf(fp, "element vertex %d\n", pointsSize);
+       fprintf(fp, "property float x\n");
+       fprintf(fp, "property float y\n");
+       fprintf(fp, "property float z\n");
+       fprintf(fp, "property uchar red\n");
+       fprintf(fp, "property uchar green\n");
+       fprintf(fp, "property uchar blue\n");
+       fprintf(fp, "end_header\n");
+
+       OBColorPoint *point = (OBColorPoint *)frame->data();
+       for(int i = 0; i < pointsSize; i++) {
+           fprintf(fp, "%.3f %.3f %.3f %d %d %d\n", point->x, point->y, point->z, (int)point->r, (int)point->g, (int)point->b);
+           point++;
+       }
+
+       fflush(fp);
+       fclose(fp);
+   }
+
+设置Log等级，避免过多Info等级的Log影响点云输出的结果
+
+.. code:: cpp
+
+   ob::Context::setLoggerSeverity(OB_LOG_SEVERITY_ERROR);
+
+创建一个Pipeline，通过Pipeline可以很容易的打开和关闭多种类型的流并获取一组帧数据
+
+.. code:: cpp
+
+   ob::Pipeline pipeline;
+
+然后可以通过Pipeline来获取彩色流的所有配置, 包括流的分辨率 ,帧率
+,以及流的格式
+
+.. code:: cpp
+
+   auto colorProfiles = pipeline.getStreamProfileList( OB_SENSOR_COLOR );
+
+之后根据上面获取的彩色流的配置列表来选取需要的流的配置
+
+.. code:: cpp
+
+   //通过接口设置感兴趣项，返回对应Profile列表的首个Profile
+   auto colorProfile = colorProfiles->getVideoStreamProfile(640, 480, OB_FORMAT_YUYV);
+   if(!colorProfile) {
+     colorProfile = colorProfiles->getVideoStreamProfile(640, 480, OB_FORMAT_I420);
+     if(!colorProfile)
+         colorProfile = colorProfiles->getProfile(0)->as<ob::VideoStreamProfile>();
+   }
+
+根据上面设置彩色流的配置的方法 ,同理来设置深度流的配置
+
+::
+
+   //获取深度相机的所有流配置，包括流的分辨率，帧率，以及帧的格式
+   auto depthProfiles = pipeline.getStreamProfileList(OB_SENSOR_DEPTH);
+   //通过接口设置感兴趣项，返回对应Profile列表的首个Profile
+   auto depthProfile = depthProfiles->getVideoStreamProfile(640, 480, OB_FORMAT_Y16);
+   if(!depthProfile) {
+       depthProfile = depthProfiles->getProfile(0)->as<ob::VideoStreamProfile>();
+   }
+
+通过创建Config来配置Pipeline要启用或者禁用哪些流，这里将启用彩色流和深度流
+
+.. code:: cpp
+
+   std::shared_ptr< ob::Config > config = std::make_shared< ob::Config >();
+   config->enableStream( colorProfile );
+   config->enableStream( depthProfile );
+
+开启D2C对齐, 生成RGBD点云时需要开启
+
+.. code:: cpp
+
+   // 开启D2C对齐, 生成RGBD点云时需要开启
+   config->setAlignMode(ALIGN_D2C_HW_MODE);
+
+创建点云Filter对象，并且设置相机内参
+
+.. code:: cpp
+
+   // 创建点云Filter对象（点云Filter创建时会在Pipeline内部获取设备参数, 所以尽量在Filter创建前配置好设备）
+   ob::PointCloudFilter pointCloud;
+
+   //获取相机内参传入点云Filter中
+   auto cameraParam = pipeline.getCameraParam();
+   pointCloud.setCameraParam(cameraParam);
+
+启动Pipeline
+
+.. code:: cpp
+
+   pipeline.start( config );
+
+设置些操作提示
+
+.. code:: cpp
+
+    std::cout << "Press R to create rgbd pointCloud and save to ply file! " << std::endl;
+    std::cout << "Press d to create depth pointCloud and save to ply file! " << std::endl;
+    std::cout << "Press ESC to exit! " << std::endl;
+
+设置主流程通过上面创建的点云Filter对象获取并保存点云数据
+
+.. code:: cpp
+
+   if(key == 'R' || key == 'r') {
+     count = 0;
+     //限制最多重复10次
+     while(count++ < 10) {
+       //等待一帧数据，超时时间为100ms
+       auto frameset = pipeline.waitForFrames(100);
+       if(frameset != nullptr && frameset->depthFrame() != nullptr && frameset->colorFrame() != nullptr) {
+         try {
+           //生成彩色点云并保存
+           std::cout << "Save RGBD PointCloud ply file..." << std::endl;
+           pointCloud.setCreatePointFormat(OB_FORMAT_RGB_POINT);
+           std::shared_ptr<ob::Frame> frame = pointCloud.process(frameset);
+           saveRGBPointsToPly(frame, "RGBPoints.ply");
+           std::cout << "RGBPoints.ply Saved" << std::endl;
+         }
+         catch(std::exception &e) {
+           std::cout << "Get point cloud failed" << std::endl;
+         }
+         break;
+       }
+     }
+   }
+   else if(key == 'D' || key == 'd') {
+     count = 0;
+     //限制最多重复10次
+     while(count++ < 10) {
+       //等待一帧数据，超时时间为100ms
+       auto frameset = pipeline.waitForFrames(100);
+       if(frameset != nullptr && frameset->depthFrame() != nullptr) {
+         try {
+           //生成点云并保存
+           std::cout << "Save Depth PointCloud to ply file..." << std::endl;
+           pointCloud.setCreatePointFormat(OB_FORMAT_POINT);
+           std::shared_ptr<ob::Frame> frame = pointCloud.process(frameset);
+           savePointsToPly(frame, "DepthPoints.ply");
+           std::cout << "DepthPoints.ply Saved" << std::endl;
+         }
+         catch(std::exception &e) {
+           std::cout << "Get point cloud failed" << std::endl;
+         }
+         break;
+       }
+     }
+   }
+
+
+最后通过Pipeline来停止流
+
+.. code:: cpp
+
+    pipeline.stop();
+
+程序正常退出后会释放资源
+
+存储示例-SaveToDisk
+-------------------
+
+功能描述：连接设备开流 , 获取彩色和深度图并存储为png格式
+
+   本示例基于C++ High Level API进行演示
+
+创建两个函数来用于将获取的图片保存到文件中
+
+.. code:: cpp
+
+   //保存深度图为png格式
+   void saveDepth( std::shared_ptr< ob::DepthFrame > depthFrame ) {
+       std::vector< int > compression_params;
+       compression_params.push_back( cv::IMWRITE_PNG_COMPRESSION );
+       compression_params.push_back( 0 );
+       compression_params.push_back( cv::IMWRITE_PNG_STRATEGY );
+       compression_params.push_back( cv::IMWRITE_PNG_STRATEGY_DEFAULT );
+       std::string depthName = "Depth_" + std::to_string( depthFrame->timeStamp() ) + ".png";
+       cv::Mat     depthMat( depthFrame->height(), depthFrame->width(), CV_16UC1, depthFrame->data() );
+       cv::imwrite( depthName, depthMat, compression_params );
+       std::cout << "Depth saved:" << depthName << std::endl;
+   }
+
+   //保存彩色图为png格式
+   void saveColor( std::shared_ptr< ob::ColorFrame > colorFrame ) {
+       std::vector< int > compression_params;
+       compression_params.push_back( cv::IMWRITE_PNG_COMPRESSION );
+       compression_params.push_back( 0 );
+       compression_params.push_back( cv::IMWRITE_PNG_STRATEGY );
+       compression_params.push_back( cv::IMWRITE_PNG_STRATEGY_DEFAULT );
+       std::string colorName = "Color_" + std::to_string( colorFrame->timeStamp() ) + ".png";
+       cv::Mat     colorRawMat( 1, colorFrame->dataSize(), CV_8UC1, colorFrame->data() );
+       cv::Mat     colorMat = cv::imdecode( colorRawMat, 1 );
+       cv::imwrite( colorName, colorMat, compression_params );
+       std::cout << "Color saved:" << colorName << std::endl;
+   }
+
+创建一个Pipeline，通过Pipeline可以很容易的打开和关闭多种类型的流并获取一组帧数据
+
+::
+
+   ob::Pipeline pipeline;
+
+然后可以通过Pipeline来获取彩色流的所有配置, 包括流的分辨率 ,帧率
+,以及流的格式
+
+.. code:: cpp
+
+   auto colorProfiles = pipeline.getStreamProfileList( OB_SENSOR_COLOR );
+
+之后根据上面获取的彩色流的配置列表来选取需要的流的配置
+
+.. code:: cpp
+
+   //通过接口设置感兴趣项，返回对应Profile列表的首个Profile
+   auto colorProfile = colorProfiles->getVideoStreamProfile(640, 480, OB_FORMAT_MJPG, 30);
+   if(!colorProfile){
+     colorProfile = colorProfiles->getProfile(0)->as<ob::VideoStreamProfile>();
+   }
+
+使用和获取彩色流配置相同的方法来配置深度流
+
+.. code:: cpp
+
+   //获取深度相机的所有流配置，包括流的分辨率，帧率，以及帧的格式
+   auto depthProfiles = pipeline.getStreamProfileList(OB_SENSOR_DEPTH);
+
+   //通过接口设置感兴趣项，返回对应Profile列表的首个Profile
+   auto depthProfile = depthProfiles->getVideoStreamProfile(640, 480, OB_FORMAT_Y16, 30);
+   if(!depthProfile){
+       depthProfile = depthProfiles->getProfile(0)->as<ob::VideoStreamProfile>();
+   }
+
+通过创建Config来配置想要开启的流
+
+::
+
+   std::shared_ptr< ob::Config > config = std::make_shared< ob::Config >();
+   config->enableStream( colorProfile );
+   config->enableStream( depthProfile )
+
+启动流
+
+.. code:: cpp
+
+   pipeline.start( config );
+
+通过等待的方式来获取帧的数据
+
+.. code:: cpp
+
+   auto frameset = pipeline.waitForFrames( 100 );
+
+获取单种类型的帧的数据
+
+.. code:: cpp
+
+   auto colorFrame = frameset->colorFrame();
+   auto depthFrame = frameset->depthFrame();
+
+创建格式转换Filter对彩色图像进行转换成RGB格式后保存
+
+.. code:: cpp
+
+   //创建格式转换Filter
+   ob::FormatConvertFilter formatConverFilter;
+
+   formatConverFilter.setFormatConvertType(FORMAT_MJPG_TO_RGB888);
+   colorFrame = formatConverFilter.process(colorFrame)->as<ob::ColorFrame>();
+   formatConverFilter.setFormatConvertType(FORMAT_RGB888_TO_BGR);
+   colorFrame = formatConverFilter.process(colorFrame)->as<ob::ColorFrame>();
+
+通过开头的编辑的存储函数来存储获得的数据
+
+.. code:: cpp
+
+   saveColor( colorFrame );
+   saveDepth( depthFrame );
+
+停止Pipeline
+
+.. code:: cpp
+
+   pipeline.stop();
+
+程序正常退出后会释放资源
+
+录制示例-Recorder
+-----------------
+
+功能描述：连接设备开流 , 录制当前视频流到文件
+
+   本示例基于C++ High Level API进行演示
+
+首先需要创建一个Pipeline，通过Pipeline可以很容易的打开和关闭多种类型的流并获取一组帧数据
+
+.. code:: cpp
+
+   ob::Pipeline pipe;
+
+通过输入的分辨率，格式，帧率等感兴趣项来获取深度相机的流配置
+
+.. code:: cpp
+
+   //获取深度流配置
+   auto profiles     = pipe.getStreamProfileList(OB_SENSOR_DEPTH);
+   auto depthProfile = profiles->getVideoStreamProfile(640, 480, OB_FORMAT_Y16);
+
+通过创建Config来配置Pipeline要启用或者禁用哪些流，这里将启用深度流
+
+.. code:: cpp
+
+   //配置Pipeline打开的流类型
+   std::shared_ptr<ob::Config> config = std::make_shared<ob::Config>();
+   config->enableStream(depthProfile);
+
+启动在Config中配置的流，如果不传参数，将启动默认配置启动流，启动录制开关
+
+.. code:: cpp
+
+   pipe.start(config);
+   pipe.startRecord("./OrbbecPipeline.bag");
+
+以阻塞的方式等待一帧数据，该帧是一个复合帧，里面包含配置里启用的所有流的帧数据，并设置帧的等待超时时间
+
+::
+
+   auto frameSet = pipe.waitForFrames(100);    //设置等待时间为100ms
+
+停止Pipeline，将不再产生帧数据
+
+.. code:: cpp
+
+   pipe.stop();
+
+程序正常退出后会释放资源
+
+回放示例-Playback
+-----------------
+
+功能描述：连接设备开流 , 载入视频文件进行回放。
+
+   本示例基于C++ High Level API进行演示
+
+首先需要创建一个用于回放文件的Pipeline
+
+.. code:: cpp
+
+   //创建用于回放的pipeline对象
+   ob::Pipeline pipe("./OrbbecPipeline.bag");
+
+获取回放对象的回放状态回调
+
+.. code:: cpp
+
+   //获取回放对象设置回放状态回调
+   auto playback = pipe.getPlayback();
+   playback->setPlaybackStateCallback([&](OBMediaState state) {
+       if(state == OB_MEDIA_BEGIN) {
+           std::cout << "Playback file begin." << std::endl;
+       }
+       else if(state == OB_MEDIA_END) {
+           std::cout << "Playback file end." << std::endl;
+       }
+   });
+
+从回放文件中读取设备信息与内参信息
+
+.. code:: cpp
+
+   //从回放文件中读取设备信息
+   auto deviceInfo = playback->getDeviceInfo();
+   std::cout << "======================DeviceInfo: name : " << deviceInfo->name() << " sn: " << deviceInfo->serialNumber()
+     << " firmware: " << deviceInfo->firmwareVersion() << " vid: " << deviceInfo->vid() << " pid: " << deviceInfo->pid() << std::endl;
+
+   //从回放文件中读取内参信息
+   auto cameraParam = pipe.getCameraParam();
+   std::cout << "======================Camera params : rgb width:" << cameraParam.rgbIntrinsic.width << " rgb height: " << cameraParam.rgbIntrinsic.height
+                 << " depth width: " << cameraParam.depthIntrinsic.width << " depth height: " << cameraParam.rgbIntrinsic.height << std::endl;
+
+开启回放
+
+.. code:: cpp
+
+   //开启回放
+   pipe.start(NULL);
+
+以阻塞的方式等待一帧数据，该帧是一个复合帧，里面包含配置里启用的所有流的帧数据，并设置帧的等待超时时间
+
+::
+
+   auto frameSet = pipe.waitForFrames(100);    //设置等待时间为100ms
+
+停止Pipeline，将不再产生帧数据
+
+.. code:: cpp
+
+   pipe.stop();
+
+程序正常退出后会释放资源
+
+.. |image.png| image:: https://cdn.nlark.com/yuque/0/2021/png/12768372/1622789513593-6b35c059-f983-4646-959a-d9d5a36c0bcc.png#clientId=uc2495e87-ebf6-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=512&id=ube24af63&margin=%5Bobject%20Object%5D&name=image.png&originHeight=512&originWidth=979&originalType=binary&ratio=1&rotation=0&showTitle=false&size=138109&status=done&style=none&taskId=uf0abb55c-bc30-4fd7-a2eb-02c09dd85af&title=&width=979
+.. |image.png| image:: https://cdn.nlark.com/yuque/0/2021/png/12768372/1622789760730-818706d5-02e2-41ad-848e-8d3cfb9512c6.png#clientId=uc2495e87-ebf6-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=513&id=uba259650&margin=%5Bobject%20Object%5D&name=image.png&originHeight=513&originWidth=642&originalType=binary&ratio=1&rotation=0&showTitle=false&size=38473&status=done&style=none&taskId=u8806e674-94b6-46b6-ba5e-bf2a9f0acc3&title=&width=642
+.. |1640769142832_A167CC70-8856-4af1-978F-FC28D9CAB32F.png| image:: https://cdn.nlark.com/yuque/0/2021/png/25457865/1640769409815-c53c88f9-70bf-4c33-9110-6a5317d29c81.png#clientId=u9c8a15cf-1c3a-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=511&id=ufb689f30&margin=%5Bobject%20Object%5D&name=1640769142832_A167CC70-8856-4af1-978F-FC28D9CAB32F.png&originHeight=511&originWidth=642&originalType=binary&ratio=1&rotation=0&showTitle=false&size=357675&status=done&style=none&taskId=udadfafbb-754b-41f7-884a-b0cc54aef8b&title=&width=642
diff --git a/docs/api/sphinx/sample/index.rst b/docs/api/sphinx/sample/index.rst
new file mode 100644
index 00000000..e9a6b949
--- /dev/null
+++ b/docs/api/sphinx/sample/index.rst
@@ -0,0 +1,7 @@
+代码示例
+=============
+
+.. toctree::
+
+   OrbbecSDK_Sample_C++
+   OrbbecSDK_Sample_Android
diff --git a/docs/api/sphinx/summary/OrbbecSDK_Summary.rst b/docs/api/sphinx/summary/OrbbecSDK_Summary.rst
new file mode 100644
index 00000000..0034725b
--- /dev/null
+++ b/docs/api/sphinx/summary/OrbbecSDK_Summary.rst
@@ -0,0 +1,106 @@
+概述
+====
+
+欢迎阅读Orbbec SDK（以下简称“SDK”）的使用教程！SDK
+不仅提供了简洁的高阶API，又提供全面、灵活的低阶API，能够让您更快速的了解和使用奥比中光3D传感摄像头。
+
+功能介绍
+========
+
+Orbbec
+SDK是针对奥比中光结构光、双目、iToF等3D传感摄像头，提供设备参数配置、数据流读取和流处理的，跨平台（Windows、Android、Linux）的软件开发包。
+
+**核心功能：**
+
+-  深度相机的访问及相关参数设置
+-  RGB相机的访问及相关参数设置（例如：曝光和白平衡）
+-  传感器的访问及相关参数设置（例如：陀螺仪和加速度计）
+-  帧同步及对齐的控制
+-  点云数据
+-  滤波等算法能力
+-  多操作系统及Wrapper的支持。
+
+**亮点：**
+
+-  “薄”：提供最少层级、高性能获取设备数据的能力
+-  “灵活”：模块化传感器功能，灵活组合不同设备
+-  “高可扩展”：支持日益多样化形态的设备及系统，以及插件化算法适用于不同场景
+
+SDK 中包含的内容：
+
++----------+----------------------------------------------------------+
+| **内容** | **描述**                                                 |
++==========+==========================================================+
+| 代码示例 | 这些简单的示例演示了如何轻松使用 SDK                     |
+|          | 将访问相机的代码片段包含到                               |
+|          | 您的应用程序中。包括彩色流、深度流、点云、对齐、录制等。 |
++----------+----------------------------------------------------------+
+| 工具     | OrbbecViewer：                                           |
+|          | 演示使用SDK控制3D传感摄像头的主要基础功能和参数配置的工  |
+|          | 具，旨在帮助开发者快速了解、验证SDK和3D传感摄像头的能力  |
+|          | 。借助此应用程序，您可以快速访问您的深度摄像头，以查看深 |
+|          | 度流、可视化点云、录制和回放数据流、配置您的摄像头设置。 |
++----------+----------------------------------------------------------+
+
+SDK支持的硬件产品
+=================
+
+=========== ============ =============
+**SDK版本** **产品列表** **固件版本**
+=========== ============ =============
+v1.0.2      Astra+       1.0.19
+v1.1.6      Astra+       1.0.19/1.0.20
+\             Femto      1.5.1
+v1.2.8      Astra+       1.0.20
+\           Femto        1.6.7
+=========== ============ =============
+
+SDK系统要求
+===========
+
++--------------+--------------------------+--------------------------+
+| **操作系统** | **要求**                 | **描述**                 |
++==============+==========================+==========================+
+| Windows      | - Windows 10 的 2018 年  | vs的工程的生成依赖       |
+|              | 4 月（版本               | 安装vs版本和cmake版本，  |
+|              | 1803，操作系统内部版本   | 支持vs2015/vs2017/vs2019 |
+|              | 17134）发行版 (x64)      |                          |
+|              | 或更高版本- 4 GB 内存-   |                          |
+|              | USB2.0 及以上端口        |                          |
++--------------+--------------------------+--------------------------+
+| Android      | - Android 6/7/8/9/10     |                          |
++--------------+--------------------------+--------------------------+
+| Linux        | - Linux Ubuntu           | 支持GCC 7.5              |
+|              | 16.04/18.04/20.04 (x64)- |                          |
+|              | 4 GB 内存-               |                          |
+|              | USB2.0 及以上端口        |                          |
++--------------+--------------------------+--------------------------+
+
+支持的开发语言Wrapper
+=====================
+
+|image.png|
+
+SDK架构
+=======
+
+|image1|\ 
+
+\ **基础API/高级API/Wrappers**\ 
+
+API层，对核心业务组件进行封装，提供不同Wrapper的API。
+
+\ **基础业务层**\ 
+
+核心业务逻辑数据帧的实现，实现Low Level和High Level的功能。
+
+\ **平台抽象层**\ 
+
+跨平台组件屏蔽各个操作系统差异实现，提供统一访问方式。
+
+\ **平台实现层**\ 
+
+各个平台的的驱动实现。
+
+.. |image.png| image:: https://cdn.nlark.com/yuque/0/2022/png/25457865/1650424663984-68738755-be5f-4bed-9ad9-80fa3a3eefcc.png#clientId=ubfd5113d-32fa-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=271&id=ub20a965f&margin=%5Bobject%20Object%5D&name=image.png&originHeight=271&originWidth=1041&originalType=binary&ratio=1&rotation=0&showTitle=false&size=29582&status=done&style=none&taskId=u7bcdf481-fbb3-4db0-b8fd-bfa999e344d&title=&width=1041
+.. |image1| image:: https://cdn.nlark.com/yuque/0/2021/png/897878/1625211895560-cd6bf79c-b16d-4d2d-94d9-f3df7b3bf8c1.png?x-oss-process=image%2Fwatermark%2Ctype_d3F5LW1pY3JvaGVp%2Csize_15%2Ctext_T3JiYmVj%2Ccolor_FFFFFF%2Cshadow_50%2Ct_80%2Cg_se%2Cx_10%2Cy_10#crop=0&crop=0&crop=1&crop=1&from=url&id=zsrCB&margin=%5Bobject%20Object%5D&originHeight=725&originWidth=534&originalType=binary&ratio=1&rotation=0&showTitle=false&status=done&style=none&title=
diff --git a/docs/api/sphinx/summary/index.rst b/docs/api/sphinx/summary/index.rst
new file mode 100644
index 00000000..fd86e7a1
--- /dev/null
+++ b/docs/api/sphinx/summary/index.rst
@@ -0,0 +1,6 @@
+概述文档
+=============
+
+.. toctree::
+
+   OrbbecSDK_Summary
diff --git a/docs/api/sphinx/support/OrbbecSDK_Support.rst b/docs/api/sphinx/support/OrbbecSDK_Support.rst
new file mode 100644
index 00000000..c6e4560f
--- /dev/null
+++ b/docs/api/sphinx/support/OrbbecSDK_Support.rst
@@ -0,0 +1,87 @@
+常见问题
+========
+
+1. **在Windows下编译C/C++ Example，运行时找不到dll库。**
+
+运行所需要的dll都在Examples的bin目录下，将目录下的dll文件拷贝至执行文件处。
+
+2. **在Linux下编译C/C++时，提示缺少libudev?**
+
+udev在支持系统中是默认集成，如果缺失可以通过apt-get install
+libudev0安装后再重新编译。
+
+3. **Cmake编译C++程序报错 Found OpenCV Windows Pack but it has no
+   binaries compatible with your configuration. You should manually
+   point CMake variable OpenCV_DIR to your build of OpenCV library？**
+
+配置OpenCV_DIR为OpenCVConfig.cmake文件所在位置，不同版本有差异，常见于opencv\build目录，配置后依然报错"but
+it set OpenCV_FOUND to FALSE so package "OpenCV" is considered to beNOT
+FOUND."可以尝试设置到opencv/build/x64/vc15/lib目录。
+
+4. **Astra+设备切换D2C开关后深度图不再刷新。**
+
+在当前版本中，
+D2C开关需要在深度流关闭时进行控制，遇到此情景重启深度流即可恢复正常。后续版本更新中会对D2C的使用场景进行拓宽，使D2C在开流状态时也可使用。
+
+5. **Femto设备的深度图像和红外图像不再刷新。**
+
+为确保使用体验，Femto只有在深度、红外图像分辨率一致时（即均为640\ *480或320*\ 240）才可运行。
+
+6. **在Windows下编译C/C++
+   Example，运行时报错，提示“由于找不到opencv_world.dll，无法继续执行代码，重新安装程序可能会解决问题”。**
+
+该问题是由于运行环境中的opencv版本与示例版本（opencv_world430.dll）不一致，需手动将opencv/build下bin目录中对应版本的dll（如opencv_world435.dll）拷贝到Examples/build/bin/Release文件夹中，再次运行即可解决。
+
+7. **在Ubuntu下热插拔，设备无法正常使用，提示“failed to open usb device:
+   error: OB_USB_STATUS_ACCESS”。**
+
+如在使用时遇到此情景，可以尝试以下方法：1）使用终端：热插拔后需要重新对USB设备进行授权（sudo
+chmod 777
+/dev/bus/usb/00x/*）。2）使用OrbbecViewer工具：热插拔后对工具进行授权（sudo
+./OrbbecViewer）即可恢复正常。
+
+8. **Linux下点云显示异常。**
+
+请检查您的显卡驱动是否安装或处于正常状态。点云渲染依赖OpenGL，而OpenGL需要调用GPU进行渲染，重新安装显卡驱动即可解决。
+
+9. **PC正常连接设备后，打开设备失败。**
+
+可以尝试以下方法：1）尝试在设备管理器里边将DataChannel卸载后重新拔插设备以解决该问题
+2）尝试在SDK工作目录下放置该文件，然后重启SDK，以规避该问题
+
+更新记录
+========
+
+.. _12版本更新说明:
+
+1.2版本更新说明
+---------------
+
+1、新增支持Femto产品
+
+2、新增数据录制及播放
+
+3、新增RGB888格式数据流
+
+4、新增获取彩色和深度共视FOV
+
+5、新增时间戳单位支持us
+
+6、新增固件升级
+
+7、新增英文注释
+
+8、优化控制指令
+
+9、优化D2C功能及接口
+
+10、优化稳定性及接口，修复bug
+
+版权声明和许可链接
+==================
+
+`OpenCV <https://github.com/opencv/opencv/blob/master/LICENSE>`__\ \
+
+`OpenGL <https://www.khronos.org/legal/>`__\ \ 
+
+`ImGui <https://github.com/ocornut/imgui/blob/master/LICENSE.txt>`__
diff --git a/docs/api/sphinx/support/index.rst b/docs/api/sphinx/support/index.rst
new file mode 100644
index 00000000..ab7d67df
--- /dev/null
+++ b/docs/api/sphinx/support/index.rst
@@ -0,0 +1,6 @@
+产品支持
+=============
+
+.. toctree::
+
+   OrbbecSDK_Support
diff --git a/docs/api/sphinx/xml2Rst.py b/docs/api/sphinx/xml2Rst.py
new file mode 100644
index 00000000..906a0137
--- /dev/null
+++ b/docs/api/sphinx/xml2Rst.py
@@ -0,0 +1,119 @@
+#!/usr/bin/python
+# -*- coding: UTF-8 -*-
+
+# This script is used to automatically generate the C API XML file as ./reference/c_ref.rst when the C API header files are updated, and update the version number in ./index.rst.
+# The C++ RST file is manually written. If the C++ header files are updated, please modify ./reference/cxx_ref.rst.
+# First, build the project with Doxygen, which will generate XML files in the build path.
+# Execute python.exe xml2Rst.py in the current directory with the XML absolute path to generate index.rst in the current directory and c_ref.rst in the reference directory.
+# Example: python.exe xml2Rst.py D:\obcode\SensorSDK_202111ref\build\Win_X64\release\xmlCN\
+# If there are HTML files in the build directory, delete them first and then execute the build Doc command.
+
+import os
+import sys
+from fileinput import filename
+from xml.dom.minidom import parse
+import xml.dom.minidom
+
+keyWordsList = []
+functionList = []
+typedefList = []
+enumList = []
+defineList = []
+structList = []
+
+# C header files
+fileNameList = ["Context.h","Device.h","Error.h","Filter.h","Frame.h","ObTypes.h","Pipeline.h","Property.h",
+    "RecordPlayback.h","Sensor.h","StreamProfile.h","Version.h"]
+
+# Interface deprecated
+excludeFunctions =["ob_frame_width","ob_frame_height","ob_delete_frame_set",
+    "ob_stream_profile_fps","ob_stream_profile_width","ob_stream_profile_height"]
+
+# Get information about the index.xml node
+def getInfoFromXml(dirName):
+    fileName= dirName + "\index.xml"
+    domTree = xml.dom.minidom.parse(fileName)
+    collection = domTree.documentElement
+    keyWords = collection.getElementsByTagName("compound")     
+    for keyWord in keyWords:
+        if keyWord.getAttribute('kind')=="file":
+            fileName = keyWord.getElementsByTagName('name')[0].childNodes[0].data
+            if fileName in fileNameList:
+                members = keyWord.getElementsByTagName('member')
+                for member in members:
+                    kind = member.getAttribute('kind')
+                    if kind == "function":
+                        name = member.getElementsByTagName('name')[0].childNodes[0].data
+                        functionList.append(name)
+                    elif kind == "typedef":
+                        name = member.getElementsByTagName('name')[0].childNodes[0].data
+                        typedefList.append(name)
+                    elif kind == "enum":
+                        name = member.getElementsByTagName('name')[0].childNodes[0].data
+                        enumList.append(name)
+                    elif kind == "define":
+                        name = member.getElementsByTagName('name')[0].childNodes[0].data
+                        defineList.append(name)
+        elif keyWord.getAttribute('kind')=="struct":
+            name = keyWord.getElementsByTagName('name')[0].childNodes[0].data
+            structList.append(name)
+
+# Doxyfile.xml node information
+def getVersionFromXml(dirName):
+    fileName= dirName + "\Doxyfile.xml"
+    domTree = xml.dom.minidom.parse(fileName)
+    collection = domTree.documentElement
+    keyWords = collection.getElementsByTagName("option")    
+    for keyWord in keyWords:
+        if keyWord.getAttribute('id')=="PROJECT_NUMBER":
+            global version
+            version = keyWord.getElementsByTagName('value')[0].childNodes[0].data
+            
+            
+# Generate rst file from xml information
+def writeToRst():
+    indexRst = open("./index.rst", "w")
+    indexRst.write("OrbbecSdk v%s\n================\n\n" %version)
+    indexRst.write(".. toctree::\n")
+    indexRst.write("   :maxdepth: 3\n\n")
+    indexRst.write("   summary/index\n")
+    indexRst.write("   env/index\n")
+    indexRst.write("   sample/index\n")    
+    indexRst.write("   knowledge/index\n")    
+    indexRst.write("   support/index\n")    
+    indexRst.write("   reference/index\n")    
+    indexRst.write("   orbbecviewer/index\n")    
+    indexRst.close()
+
+    crefRst = open("./reference/c_ref.rst", "w")
+    crefRst.write("C Reference                                \n============================================\n")
+    crefRst.write("Macros                                     \n--------------------------------------------\n")
+    for item in defineList:
+        crefRst.write(".. doxygendefine:: %s\n   :project: OrbbecSdk\n\n" %(item))
+    crefRst.write("Structures                                 \n--------------------------------------------\n")
+    for item in structList:
+        crefRst.write(".. doxygenstruct:: %s\n   :project: OrbbecSdk\n\n" %(item))
+    crefRst.write("Enumerations                               \n--------------------------------------------\n")
+    for item in enumList:
+        crefRst.write(".. doxygenenum:: %s\n   :project: OrbbecSdk\n\n" %(item))
+    crefRst.write("Typedefs                                   \n--------------------------------------------\n")
+    for item in typedefList:
+        crefRst.write(".. doxygentypedef:: %s\n   :project: OrbbecSdk\n\n" %(item))
+    crefRst.write("Functions                                  \n--------------------------------------------\n")
+    for item in functionList:
+        if item not in excludeFunctions:
+            crefRst.write(".. doxygenfunction:: %s\n   :project: OrbbecSdk\n\n" %(item))
+    crefRst.close()
+
+try:
+    xmlDir = sys.argv[1]
+except:
+    print("Please pass the path to the xml, e.g. python.exe xml2Rst.py path")
+else:
+    getInfoFromXml(xmlDir)
+    getVersionFromXml(xmlDir)
+    writeToRst()
+    print("Generate . /index.rst and . /reference/c_ref.rst files")
+
+
+
diff --git a/docs/developer/contributing_to_orbbec_sdk.md b/docs/developer/contributing_to_orbbec_sdk.md
new file mode 100644
index 00000000..f529a4a9
--- /dev/null
+++ b/docs/developer/contributing_to_orbbec_sdk.md
@@ -0,0 +1,62 @@
+# Contributing to Orbbec SDK
+
+If you would like to contribute to this source project, please follow these steps:
+
+**Step1:Fork the repository**
+
+- This step is to ensure that make a copy of this project and place it in your own GitHub account.
+- Repository is Github's way of raising usage items, and fork is its copy
+- Make sure you are on the Orbbec SDK repository's [main page](https://github.com/orbbec/OrbbecSDK-dev).
+![Click](../resource/developer_fork.jpg)
+![Fork](../resource/developer_fork2.jpg)
+
+- Now, you have a copy of the repository in your own GitHub account.
+Please switch to the fork in your own account.
+
+![switch](../resource/developer_fork3.jpg)
+
+**Step2:Clone the repository**
+- You can use HTTPS or SSH to clone the repository.Copy the URL of the repository you want to clone.
+![clone](../resource/developer_clone.jpg)
+
+- Go back to your local folder and open git bash.
+
+```bash
+git clone https://github.com/orbbec/OrbbecSDK-dev.git
+```
+
+**Step3:Create a new branch**
+
+- After clone the repository, switch to the repository folder.
+
+```bash
+cd OrbbecSDK-dev
+```
+
+- Create a new branch to work on. `your_branch_name` is a custom name
+
+```bash
+git checkout -b your_branch_name
+```
+
+**Step4:Commit your changes**
+
+- If you have changed something, you can use `git status` to check the status of your repository.
+- Your changes to the file need to be uploaded to the branch `your_branch_name` , use `git add <filename>` or `git add .` to add all the changes to the branch.
+-Then use `git commit -m "your commit message"` to commit your changes.
+
+**Step5:Push your changes to GitHub**
+
+- Now you can use `git push origin your_branch_name` to push your changes to GitHub.
+
+**Step6:Submit a PR(Pull Request)**
+
+- After successfully pushing the change file into your fork repository, back to you fork in Github, then you can submit the PR to the main repository.
+![PR](../resource/developer_PR.jpg)
+
+- After filling in the title and description, you can click `Create pull request`
+![PR2](../resource/developer_PR2.jpg)
+
+- Finally, you've done all the steps, and we will approve your PR after the reviewers have checked it.
+
+## **Thank you for your contributions！**
diff --git a/docs/resource/OrbbecViewer.jpg b/docs/resource/OrbbecViewer.jpg
new file mode 100644
index 00000000..c2ae31d1
Binary files /dev/null and b/docs/resource/OrbbecViewer.jpg differ
diff --git a/docs/resource/Overview.jpg b/docs/resource/Overview.jpg
new file mode 100644
index 00000000..9d37a99a
Binary files /dev/null and b/docs/resource/Overview.jpg differ
diff --git a/docs/resource/QuickStart.jpg b/docs/resource/QuickStart.jpg
new file mode 100644
index 00000000..2957b476
Binary files /dev/null and b/docs/resource/QuickStart.jpg differ
diff --git a/docs/resource/SyncAlign.jpg b/docs/resource/SyncAlign.jpg
new file mode 100644
index 00000000..738f7573
Binary files /dev/null and b/docs/resource/SyncAlign.jpg differ
diff --git a/docs/resource/System Architecture Design.jpg b/docs/resource/System Architecture Design.jpg
new file mode 100644
index 00000000..2212d5ef
Binary files /dev/null and b/docs/resource/System Architecture Design.jpg differ
diff --git a/docs/resource/c2d.jpg b/docs/resource/c2d.jpg
new file mode 100644
index 00000000..e07441ac
Binary files /dev/null and b/docs/resource/c2d.jpg differ
diff --git a/docs/resource/callback.jpg b/docs/resource/callback.jpg
new file mode 100644
index 00000000..abd8397f
Binary files /dev/null and b/docs/resource/callback.jpg differ
diff --git a/docs/resource/color.jpg b/docs/resource/color.jpg
new file mode 100644
index 00000000..d749f082
Binary files /dev/null and b/docs/resource/color.jpg differ
diff --git a/docs/resource/common1.jpg b/docs/resource/common1.jpg
new file mode 100644
index 00000000..dcfa2524
Binary files /dev/null and b/docs/resource/common1.jpg differ
diff --git a/docs/resource/common2.jpg b/docs/resource/common2.jpg
new file mode 100644
index 00000000..15773037
Binary files /dev/null and b/docs/resource/common2.jpg differ
diff --git a/docs/resource/control1.jpg b/docs/resource/control1.jpg
new file mode 100644
index 00000000..09cc160e
Binary files /dev/null and b/docs/resource/control1.jpg differ
diff --git a/docs/resource/control2.jpg b/docs/resource/control2.jpg
new file mode 100644
index 00000000..4b6dc546
Binary files /dev/null and b/docs/resource/control2.jpg differ
diff --git a/docs/resource/coordinate_transform.jpg b/docs/resource/coordinate_transform.jpg
new file mode 100644
index 00000000..676d9e56
Binary files /dev/null and b/docs/resource/coordinate_transform.jpg differ
diff --git a/docs/resource/d2c.jpg b/docs/resource/d2c.jpg
new file mode 100644
index 00000000..1ff1157f
Binary files /dev/null and b/docs/resource/d2c.jpg differ
diff --git a/docs/resource/depth.jpg b/docs/resource/depth.jpg
new file mode 100644
index 00000000..12b3a190
Binary files /dev/null and b/docs/resource/depth.jpg differ
diff --git a/docs/resource/developer_PR.jpg b/docs/resource/developer_PR.jpg
new file mode 100644
index 00000000..0203a183
Binary files /dev/null and b/docs/resource/developer_PR.jpg differ
diff --git a/docs/resource/developer_PR2.jpg b/docs/resource/developer_PR2.jpg
new file mode 100644
index 00000000..32699a81
Binary files /dev/null and b/docs/resource/developer_PR2.jpg differ
diff --git a/docs/resource/developer_clone.jpg b/docs/resource/developer_clone.jpg
new file mode 100644
index 00000000..69990867
Binary files /dev/null and b/docs/resource/developer_clone.jpg differ
diff --git a/docs/resource/developer_fork.jpg b/docs/resource/developer_fork.jpg
new file mode 100644
index 00000000..819194d4
Binary files /dev/null and b/docs/resource/developer_fork.jpg differ
diff --git a/docs/resource/developer_fork2.jpg b/docs/resource/developer_fork2.jpg
new file mode 100644
index 00000000..e27f1693
Binary files /dev/null and b/docs/resource/developer_fork2.jpg differ
diff --git a/docs/resource/developer_fork3.jpg b/docs/resource/developer_fork3.jpg
new file mode 100644
index 00000000..bc29e668
Binary files /dev/null and b/docs/resource/developer_fork3.jpg differ
diff --git a/docs/resource/enumerate.jpg b/docs/resource/enumerate.jpg
new file mode 100644
index 00000000..f7120cd4
Binary files /dev/null and b/docs/resource/enumerate.jpg differ
diff --git a/docs/resource/hdr.jpg b/docs/resource/hdr.jpg
new file mode 100644
index 00000000..55139488
Binary files /dev/null and b/docs/resource/hdr.jpg differ
diff --git a/docs/resource/hotplugin.jpg b/docs/resource/hotplugin.jpg
new file mode 100644
index 00000000..89d1592f
Binary files /dev/null and b/docs/resource/hotplugin.jpg differ
diff --git a/docs/resource/imu.jpg b/docs/resource/imu.jpg
new file mode 100644
index 00000000..48cdfae8
Binary files /dev/null and b/docs/resource/imu.jpg differ
diff --git a/docs/resource/infrared.jpg b/docs/resource/infrared.jpg
new file mode 100644
index 00000000..95b39ae0
Binary files /dev/null and b/docs/resource/infrared.jpg differ
diff --git a/docs/resource/multi_devices.jpg b/docs/resource/multi_devices.jpg
new file mode 100644
index 00000000..4ee2660f
Binary files /dev/null and b/docs/resource/multi_devices.jpg differ
diff --git a/docs/resource/multistream.jpg b/docs/resource/multistream.jpg
new file mode 100644
index 00000000..0f072f34
Binary files /dev/null and b/docs/resource/multistream.jpg differ
diff --git a/docs/resource/point_cloud.jpg b/docs/resource/point_cloud.jpg
new file mode 100644
index 00000000..c926514b
Binary files /dev/null and b/docs/resource/point_cloud.jpg differ
diff --git a/docs/resource/post_processing.jpg b/docs/resource/post_processing.jpg
new file mode 100644
index 00000000..8e884d5a
Binary files /dev/null and b/docs/resource/post_processing.jpg differ
diff --git a/docs/resource/preset.jpg b/docs/resource/preset.jpg
new file mode 100644
index 00000000..4cb9adbe
Binary files /dev/null and b/docs/resource/preset.jpg differ
diff --git a/docs/resource/quick_start.jpg b/docs/resource/quick_start.jpg
new file mode 100644
index 00000000..c9160388
Binary files /dev/null and b/docs/resource/quick_start.jpg differ
diff --git a/docs/resource/quick_start_c.jpg b/docs/resource/quick_start_c.jpg
new file mode 100644
index 00000000..bdcac255
Binary files /dev/null and b/docs/resource/quick_start_c.jpg differ
diff --git a/docs/resource/sync.jpg b/docs/resource/sync.jpg
new file mode 100644
index 00000000..7b865868
Binary files /dev/null and b/docs/resource/sync.jpg differ
diff --git a/docs/tutorial/building_orbbec_sdk.md b/docs/tutorial/building_orbbec_sdk.md
new file mode 100644
index 00000000..838336dc
--- /dev/null
+++ b/docs/tutorial/building_orbbec_sdk.md
@@ -0,0 +1,96 @@
+# Building Orbbec SDK
+
+## Requirements
+
+For windows, you need:
+
+- Windows 10 or later
+- Visual Studio 2017 or later with MSVC v141 toolset
+- CMake v3.15 or later
+- Git
+- OpenCV v3.4 is recommended
+
+For Linux, it is recommended to use Docker to build the Orbbec SDK, therefor, you only need:
+
+- Docker
+
+For linux, if you want to build Orbbec SDK by using native toolchain, you need:
+
+- Ubuntu 18.04 or later
+- GCC 7.4
+- CMake v3.15 or later
+- Git
+- OpenCV v3.4 is recommended
+
+## Clone Orbbec SDK
+
+The Orbbec SDK souce code are available on GitHub. You can clone the Orbbec SDK by using the following commands:
+
+```shell
+git clone https://github.com/Orbbec/OrbbecSDK-dev.git
+```
+
+## Build Orbbec SDK
+
+You can build Orbbec SDK by using the following commands:
+
+- Windows: Use PowerShell to execute the build commands.
+
+- Linux: Use a terminal emulator to execute the build commands
+
+```shell
+cd OrbbecSDK-dev
+mkdir build
+cd build
+cmake ..
+cmake --build . --config Release
+```
+
+If you are using Docker, you can using the script we provide to build Orbbec SDK.
+
+```shell
+cd OrbbecSDK-dev/scripts/build
+./build_linux_docker.sh
+# `./build_linux_docker.sh  aarch64` for arm64
+```
+
+> More information about how to use Docker, please refer to [README.md](../../scripts/docker/README.md).
+
+## Run the Sample
+
+After you build the Orbbec SDK, you can find the executable file in the directory `OrbbecSDK-dev/build/win_XX/bin` or `OrbbecSDK-dev/build/linux_XX/bin`.
+
+### Environment Setup
+
+#### Windows
+
+##### Metadata registration
+
+For windows,you need to register the metadata associated with frames (this includes things like timestamps and other information about the video frame).
+
+- Metadata registration follow this:[/scripts/env_setup/obsensor_metadata_win10.md](../../scripts/env_setup/obsensor_metadata_win10.md)
+
+#### Linux
+
+ Please install it using the following commands:[/scripts/env_setup/install_udev_rules.sh](../../scripts/env_setup/install_udev_rules.sh)
+
+```shell
+cd OrbbecSDK-dev/scripts/env_setup
+sudo chmod +x ./install_udev_rules.sh
+sudo ./install_udev_rules.sh
+sudo udevadm control --reload-rules && udevadm trigger
+```
+
+### Connect to the camera
+
+If the camera needs to be powered on, plug in the power cable and connect the camera to the host using USB.
+
+### Running the sample
+
+- Enter the bin directory , open the terminal (power shell for windows), and run the example
+
+```shell
+cd bin
+.\ob_XXX  #  .\ob_XXX.exe for windows
+```
+> More information about the examples of Orbbec SDK, please refer to [examples](../../examples/README.md).
diff --git a/docs/tutorial/images/OrbbecViewer.jpg b/docs/tutorial/images/OrbbecViewer.jpg
new file mode 100644
index 00000000..ee51ac2d
Binary files /dev/null and b/docs/tutorial/images/OrbbecViewer.jpg differ
diff --git a/docs/tutorial/images/image1.jpg b/docs/tutorial/images/image1.jpg
new file mode 100644
index 00000000..d02521cd
Binary files /dev/null and b/docs/tutorial/images/image1.jpg differ
diff --git a/docs/tutorial/images/image10.jpg b/docs/tutorial/images/image10.jpg
new file mode 100644
index 00000000..eb5d1b9c
Binary files /dev/null and b/docs/tutorial/images/image10.jpg differ
diff --git a/docs/tutorial/images/image11.jpg b/docs/tutorial/images/image11.jpg
new file mode 100644
index 00000000..bd686d9a
Binary files /dev/null and b/docs/tutorial/images/image11.jpg differ
diff --git a/docs/tutorial/images/image12.jpg b/docs/tutorial/images/image12.jpg
new file mode 100644
index 00000000..ba8fd1d7
Binary files /dev/null and b/docs/tutorial/images/image12.jpg differ
diff --git a/docs/tutorial/images/image13.jpg b/docs/tutorial/images/image13.jpg
new file mode 100644
index 00000000..2a067f34
Binary files /dev/null and b/docs/tutorial/images/image13.jpg differ
diff --git a/docs/tutorial/images/image14.jpg b/docs/tutorial/images/image14.jpg
new file mode 100644
index 00000000..597dd089
Binary files /dev/null and b/docs/tutorial/images/image14.jpg differ
diff --git a/docs/tutorial/images/image15.jpg b/docs/tutorial/images/image15.jpg
new file mode 100644
index 00000000..84ea0f8d
Binary files /dev/null and b/docs/tutorial/images/image15.jpg differ
diff --git a/docs/tutorial/images/image16.jpg b/docs/tutorial/images/image16.jpg
new file mode 100644
index 00000000..7abd86e4
Binary files /dev/null and b/docs/tutorial/images/image16.jpg differ
diff --git a/docs/tutorial/images/image17.jpg b/docs/tutorial/images/image17.jpg
new file mode 100644
index 00000000..50a84a0e
Binary files /dev/null and b/docs/tutorial/images/image17.jpg differ
diff --git a/docs/tutorial/images/image18.jpg b/docs/tutorial/images/image18.jpg
new file mode 100644
index 00000000..4e1dd74c
Binary files /dev/null and b/docs/tutorial/images/image18.jpg differ
diff --git a/docs/tutorial/images/image19.jpg b/docs/tutorial/images/image19.jpg
new file mode 100644
index 00000000..4747b015
Binary files /dev/null and b/docs/tutorial/images/image19.jpg differ
diff --git a/docs/tutorial/images/image2.jpg b/docs/tutorial/images/image2.jpg
new file mode 100644
index 00000000..4040e7b6
Binary files /dev/null and b/docs/tutorial/images/image2.jpg differ
diff --git a/docs/tutorial/images/image20.jpg b/docs/tutorial/images/image20.jpg
new file mode 100644
index 00000000..dc8034a9
Binary files /dev/null and b/docs/tutorial/images/image20.jpg differ
diff --git a/docs/tutorial/images/image21.jpg b/docs/tutorial/images/image21.jpg
new file mode 100644
index 00000000..1eb3db7e
Binary files /dev/null and b/docs/tutorial/images/image21.jpg differ
diff --git a/docs/tutorial/images/image211.jpg b/docs/tutorial/images/image211.jpg
new file mode 100644
index 00000000..bc78d737
Binary files /dev/null and b/docs/tutorial/images/image211.jpg differ
diff --git a/docs/tutorial/images/image22.jpg b/docs/tutorial/images/image22.jpg
new file mode 100644
index 00000000..5dc39d2c
Binary files /dev/null and b/docs/tutorial/images/image22.jpg differ
diff --git a/docs/tutorial/images/image23.jpg b/docs/tutorial/images/image23.jpg
new file mode 100644
index 00000000..8d48096c
Binary files /dev/null and b/docs/tutorial/images/image23.jpg differ
diff --git a/docs/tutorial/images/image24.jpg b/docs/tutorial/images/image24.jpg
new file mode 100644
index 00000000..16f3787e
Binary files /dev/null and b/docs/tutorial/images/image24.jpg differ
diff --git a/docs/tutorial/images/image25.jpg b/docs/tutorial/images/image25.jpg
new file mode 100644
index 00000000..3753d617
Binary files /dev/null and b/docs/tutorial/images/image25.jpg differ
diff --git a/docs/tutorial/images/image26.jpg b/docs/tutorial/images/image26.jpg
new file mode 100644
index 00000000..b9df0c25
Binary files /dev/null and b/docs/tutorial/images/image26.jpg differ
diff --git a/docs/tutorial/images/image27.jpg b/docs/tutorial/images/image27.jpg
new file mode 100644
index 00000000..973fd5bb
Binary files /dev/null and b/docs/tutorial/images/image27.jpg differ
diff --git a/docs/tutorial/images/image28.jpg b/docs/tutorial/images/image28.jpg
new file mode 100644
index 00000000..28611289
Binary files /dev/null and b/docs/tutorial/images/image28.jpg differ
diff --git a/docs/tutorial/images/image29.jpg b/docs/tutorial/images/image29.jpg
new file mode 100644
index 00000000..ea48e063
Binary files /dev/null and b/docs/tutorial/images/image29.jpg differ
diff --git a/docs/tutorial/images/image3.jpg b/docs/tutorial/images/image3.jpg
new file mode 100644
index 00000000..301153da
Binary files /dev/null and b/docs/tutorial/images/image3.jpg differ
diff --git a/docs/tutorial/images/image30.jpg b/docs/tutorial/images/image30.jpg
new file mode 100644
index 00000000..eb5d1b9c
Binary files /dev/null and b/docs/tutorial/images/image30.jpg differ
diff --git a/docs/tutorial/images/image31.jpg b/docs/tutorial/images/image31.jpg
new file mode 100644
index 00000000..89446663
Binary files /dev/null and b/docs/tutorial/images/image31.jpg differ
diff --git a/docs/tutorial/images/image32.jpg b/docs/tutorial/images/image32.jpg
new file mode 100644
index 00000000..f582e04f
Binary files /dev/null and b/docs/tutorial/images/image32.jpg differ
diff --git a/docs/tutorial/images/image33.jpg b/docs/tutorial/images/image33.jpg
new file mode 100644
index 00000000..941363b6
Binary files /dev/null and b/docs/tutorial/images/image33.jpg differ
diff --git a/docs/tutorial/images/image34.jpg b/docs/tutorial/images/image34.jpg
new file mode 100644
index 00000000..fec255d8
Binary files /dev/null and b/docs/tutorial/images/image34.jpg differ
diff --git a/docs/tutorial/images/image35.jpg b/docs/tutorial/images/image35.jpg
new file mode 100644
index 00000000..8055877e
Binary files /dev/null and b/docs/tutorial/images/image35.jpg differ
diff --git a/docs/tutorial/images/image36.jpg b/docs/tutorial/images/image36.jpg
new file mode 100644
index 00000000..cefabc29
Binary files /dev/null and b/docs/tutorial/images/image36.jpg differ
diff --git a/docs/tutorial/images/image4.jpg b/docs/tutorial/images/image4.jpg
new file mode 100644
index 00000000..eb5d1b9c
Binary files /dev/null and b/docs/tutorial/images/image4.jpg differ
diff --git a/docs/tutorial/images/image5.jpg b/docs/tutorial/images/image5.jpg
new file mode 100644
index 00000000..ba761f46
Binary files /dev/null and b/docs/tutorial/images/image5.jpg differ
diff --git a/docs/tutorial/images/image6.jpg b/docs/tutorial/images/image6.jpg
new file mode 100644
index 00000000..bd9c0af5
Binary files /dev/null and b/docs/tutorial/images/image6.jpg differ
diff --git a/docs/tutorial/images/image7.jpg b/docs/tutorial/images/image7.jpg
new file mode 100644
index 00000000..0be08504
Binary files /dev/null and b/docs/tutorial/images/image7.jpg differ
diff --git a/docs/tutorial/images/image8.jpg b/docs/tutorial/images/image8.jpg
new file mode 100644
index 00000000..6e199074
Binary files /dev/null and b/docs/tutorial/images/image8.jpg differ
diff --git a/docs/tutorial/images/image9.jpg b/docs/tutorial/images/image9.jpg
new file mode 100644
index 00000000..31111597
Binary files /dev/null and b/docs/tutorial/images/image9.jpg differ
diff --git a/docs/tutorial/installation_and_development_guide.md b/docs/tutorial/installation_and_development_guide.md
new file mode 100644
index 00000000..922ba6b4
--- /dev/null
+++ b/docs/tutorial/installation_and_development_guide.md
@@ -0,0 +1,128 @@
+# Installation and Development Guide
+
+This is a comprehensive guide on installing the SDK, setting up the development environment, running the sample programs and developing the application.
+
+## 1. Step-by-Step Guide
+
+### 1.1 Download the precompiled SDK package
+
+- Download the zip package "OrbbecSDK_v2.x.x_xxx.zip" from [https://github.com/orbbec/OrbbecSDK-dev/releases](https://github.com/orbbec/OrbbecSDK-dev/releases).
+- Unzip the OrbbecSDK to the directory you want
+
+### 1.2 Environment Setup
+
+#### 1.2.1 windows
+
+For windows, you need to register the metadata associated with frames (this includes things like timestamps and other information about the video frame).
+
+- Metadata registration follow this:[/scripts/env_setup/obsensor_metadata_win10.md](../../scripts/env_setup/obsensor_metadata_win10.md)
+
+#### 1.2.2 Linux
+
+For Linux, we have provided a script to help you set up the environment. You can run the script as follows:
+
+```bash
+cd scripts/env_setup
+./setup.sh
+```
+
+**Purpose**:
+
+1. Install compilation tools and dependencies (e.g., OpenCV).
+2. Compile the sample program.
+3. Install libusb rules file.
+
+> It's not necessary. If you don't, there will be no sample executable, and you'll need to run install libusb rules file manually
+
+**`setup.sh` Script Requirements**:
+
+1. **Internet Connection**: The script may need to download compilation tools and dependencies from the internet.
+2. **sudo Permissions**: The installation process may require system-level permissions to install software packages or modify system files.
+
+**Expected Outcome**:
+
+When the script executes successfully, it will generate the sample executable in the project's bin directory. This file is the result of compiling the sample program and can be used to demonstrate the functionality.
+
+### 1.3 Run example
+
+Connect the device to the computer and run the sample program at your unzip directory.
+
+```shell
+cd bin
+./ob_color  #  ./ob_color for linux
+```
+
+> More information about the examples of Orbbec SDK, please refer to [examples](../../examples/README.md).
+
+## 2. Develop a New Application with the SDK
+
+### 2.1 Create a new CMake Project
+
+First, create a new folder for your project root directory and set up the basic CMake files and source code files within it.
+
+Example Project Folder Structure:
+
+```plaintext
+MyOrbbecApp/
+├── CMakeLists.txt
+├── src/
+│   └── main.cpp
+└── include/
+    └── (optional custom header files)
+```
+
+### 2.2 Add the OrbbecSDK to the Project
+
+Create a lib directory in the project and unpack the Orbbec SDK library files into this lib directory.
+
+Example Project Folder Structure:
+
+```plaintext
+MyOrbbecApp/
+├── CMakeLists.txt
+├── src/
+│   └── main.cpp
+├── include/
+│   └── (optional custom header files)
+└── lib/
+    └── orbbecsdk
+        └── (Orbbec SDK library files)
+```
+
+### 2.3 Config the CMakeLists.txt to Link the OrbbecSDK
+
+Add the following lines to the CMakeLists.txt file:
+
+```cmake
+add_executable(MyOrbbecApp src/main.cpp)
+
+set(OrbbecSDK_DIR lib/orbbecsdk/lib)
+find_package(OrbbecSDK REQUIRED)
+
+target_link_libraries(MyOrbbecApp ob::OrbbecSDK)
+```
+
+### 2.4 Develop the Application
+
+Now you can develop your application using the Orbbec SDK. You can refer to the sample programs in the Orbbec SDK to get started.
+
+### 2.5 Compile and place the library files
+
+As a cmake project, you can compile the project as the cmake way, depends on your build system and habit. Here is an example of using the command line to compile the project:
+
+```shell
+mkdir build
+cd build
+cmake ..
+cmake --build . --config Release
+cd ..
+```
+
+After compiling, **it is important to copy the Orbbec SDK library and its extentions files to the target directory**.
+
+```shell
+cp -r lib/orbbecsdk/lib/extensions build/bin/
+cp -r lib/orbbecsdk/lib/libOrbbecSDK.so build/bin/
+```
+
+After all these steps, you can run the application by executing the binary file in the build/bin directory.
diff --git a/docs/tutorial/orbbecviewer.md b/docs/tutorial/orbbecviewer.md
new file mode 100644
index 00000000..3c672fef
--- /dev/null
+++ b/docs/tutorial/orbbecviewer.md
@@ -0,0 +1,168 @@
+# Introduction
+
+Orbbec Viewer is a tool developed based on Orbbec SDK to help developers quickly use Orbbec's 3D sensor products. The functional features of Orbbec 3D sensor products are realized, including functions such as reading serial numbers, obtaining device types, acquiring camera parameters, controlling cameras,etc.
+
+This document describes these functions and demonstrates the basic usage process.
+
+# Overview
+
+## Target users
+
+The OrbbecViewer tool is designed for end users/developers to use Orbbec SDK 3D cameras.
+
+## Supported Platforms
+
+| **Operating system** | **Requirement** | **Description** |
+| --- | --- | --- |
+| Windows | - Windows 10 April 2018 (version 1803, operating system build 17134) release (x64) or higher<br />- 4 GB RAM<br />- USB2.0 and above ports<br /> | The generation of the VS project depends on the installation of the VS version and the cmake version, and supports VS2015/vs2017/vs2019 |
+| Android | - Android 6/7/8/9/10<br /> |  |
+| Linux | - Linux Ubuntu 16.04/18.04/20.04 (x64)<br />- 4 GB RAM<br />- USB2.0 and above ports<br /> |Support GCC 7.5|
+| Arm64 | <br />- Linux Ubuntu 18.04/20.04/22.04<br />- 4 GB RAM<br />- USB2.0 and above ports<br /> |  Support GCC 7.5 |
+
+# OrbbecViewer Usage
+
+## 3.1 Main interface of the software
+
+As shown in the figure, the main interface is marked with three areas separated by red boxes. The functions are:
+
+| **Area** | **Name** | **Function** |
+| --- | --- | --- |
+| Area 1 | Equipment management area | Sensor list,|
+| Area 2 | Control panel area | Data stream switch and parameter configuration, image acquisition function control, D2C function control |
+| Area 3 | Image preview area | Sensor image preview, frame rate, timestamp and other information viewing |
+
+![1](images/image1.jpg)
+
+Among them, there are six buttons on the left side of the control panel area, the bottom button.
+
+
+![2](images/image2.jpg) Used to switch between Chinese and English;![3](images/image3.jpg) Used to open the software details page.
+
+![4](images/image4.jpg) Used to view device information and firmware upgrade; the remaining two buttons are used to switch the control panel TAB pages of different functions, from top to bottom, it is "Single Camera Mode" and "Advanced Mode".
+
+Click the Log information at the bottom of area 3, and the specific log information will be displayed.
+
+## 3.2 Data stream
+
+OrbbecViewer allows the user to select and configure depth, infrared and color data streams. This section outlines the parameters that the user can customize in the tool. After the user completes the configuration, they must click the top ![5](images/image5.jpg)button to start data streaming.
+
+The OrbbecViewer tool allows the user to select a combination of depth, infrared and color data streams. User can enable/disable the stream by checking/unchecking from the list of available streams. The viewer supports both USB2.0 and USB3.0, so the available configuration parameters will vary depending on the USB2.0/USB3.0 capabilities.
+
+###  Resolution and Frame Rate
+
+The cameras provide users with a choice of resolutions to suit their solution needs. Each data stream provides a variety of optional frame formats for users to freely choose the appropriate combination of image size, image format and frame rate.
+
+For example, depth stream  can support 320x240, 640x480, 640x400, 1280x800, 320x288, 640x576, 1024x1024, 512x512 and other resolutions,
+and the range of FPS frame rate is 5 to 30, different devices support different resolutions, image formats, and frame rates, please refer to the product manual.
+
+![8](images/image8.jpg)
+
+The color stream can support multiple resolutions from 640x480 to 3840x2160, the range of FPS frame rate ranges from 5 to 30, and supports MJPG, RGB, I420, and H265.
+
+For the preview of the color stream, MJPG, H264, and H265 are the encoding formats, which need to be decoded first. The decoding usually takes a lot of time, resulting in dropped frames or rendering a "corrupted" picture. On some models of PC, hardware-accelerated decoding is available.
+
+![7](images/image7.jpg)
+
+The infrared stream can support 320x240、640x480、640x400、1280x800、640x576、512x512、1024x1024 and other resolutions, and the FPS frame rate ranges from 5 to 30. different devices support different resolutions, image formats, and frame rates, please refer to the product manual<br />
+![9](images/image9.jpg)
+
+Users can choose the most suitable resolution according to the actual situation. Note that higher resolutions are more accurate, but increase computational intensity.
+
+## 3.3 Device Information
+
+Click the button“ ![10](images/image10.jpg) ”to view device information.
+The OrbbecViewer tool contains simple device information such as firmware version, product identification code, camera parameters, temperature, etc.
+
+![11](images/image11.jpg)
+
+## 3.4 Image preview area
+
+Open stream will display the average frame rate, time frame, image frame number and other information by default, click on the upper right corner ![12](images/image12.jpg) to toggle information display\close.
+Click ![13](images/image13.jpg) , the stream can be paused without being removed from the preview area.
+Click ![14](images/image14.jpg) , streams that have been paused and not removed from the preview area can be reopened.
+
+After the data stream is closed, the image preview window will not be closed, and the user needs to click ![15](images/image15.jpg) the upper right corner of the image preview window.
+
+![16](images/image16.jpg)
+
+## 3.5 Control Panel Area
+
+### Sensors and Data Stream
+
+#### Get camera name, serial number and USB protocol
+
+After the device is powered on and the USB is connected to the PC host, open the OrbbecViewer tool software, and the software will automatically connect the device. Some devices may take a long time to initialize, please wait patiently for the device to connect successfully.
+
+After the connection is successful, the control panel area automatically displays the specific information of the device.
+
+![18](images/image18.jpg)
+
+#### Depth stream module
+
+Including: mirroring, software filtering , depth effective range acquisition (MinDepthValue/MaxDepthValue), exposure and other functions.
+
+![19](images/image19.jpg)
+
+#### Color stream module
+
+Including: Mirror, Flip, Align, Exposure, White Balance, Gain, Brightness, Sharpness, Saturation, Contrast, Hue and other functions.
+
+![20](images/image20.jpg)
+
+#### Infrared stream module
+
+Including mirroring and exposure functions.
+
+![21](images/image21.jpg)
+
+#### IMU
+
+Including Imu param.
+
+![21-1](images/image211.jpg)
+
+
+#### **Device data management**
+
+Users can select corresponding images and captured frames for recording, and the captured frames are saved in the "OrbbecViewer/output" directory by default.
+
+![22](images/image22.jpg)
+
+## 3.6 D2C and Point Cloud (support hardware D2C and software D2C)
+
+In advanced mode, both D2C and point clouds are supported.
+
+* Control depth and color alignment, and the alignment mode supports hardware D2C and software D2C.
+* frame synchronization： Enables or disables the frame synchronization function. When frame synchronization is enabled, the SDK will combine Depth and Color into a FrameSet based on the device hardware timestamp, which can only be supported by devices that support frame synchronization, such as: Gemini2、Gemini2 L、Astra2、Femoto、Femto W、Femto Mega。
+* 2D Control： Display and save 2D images。
+* 3D Control： Display and save 3D PointCloud data.
+
+1. The zoom of the point cloud can be controlled by the mouse wheel, and the movement of the point cloud can be controlled by the movement of the mouse.
+
+2. You can choose to export the depth point cloud (xyz) or RGBD point cloud (xyzrgb) and save it as a ply format file, which is saved in the "OrbbecViewer/output/PointCloud" directory by default.
+
+* Record and Playback: The recording file is saved in the "OrbbecViewer/output/RecordFile" directory by default.
+
+![image23](images/image23.jpg)
+
+## 3.7 **Firmware update**
+
+When the device is connected, click![30](images/image30.jpg)Access the firmware update page.
+
+* Femto device firmware includes system firmware and onboard MCU firmware. You can select the upgrade firmware type in the "Type" drop-down box.
+* After selecting the firmware type, enter the existing updated firmware image file in the “Firmware” input box, and click the “Upgrade” button to start the update.
+* The device firmware update adopts the A/B dual partition scheme. If the update fails unexpectedly, it will not affect the operation of the original firmware, just reconnect the device to update. The device update time is relatively long, and the device will automatically restart once, please pay attention to the prompt information and wait patiently.
+* Astra+、gemini2、Gemini2 L、Astra2、Dabai、Dabai DCW、Dabai DW、Astra Mini Pro、Astra Pro Plus、Gemini、GeminiE、GeminiE Lite Upgrade interface:
+
+![31](images/image31.jpg)
+
+* Femto、Femto W interface：
+
+![32](images/image32.jpg)
+
+* Femto Mega firmware upgrade does not support Windows upgrade, you need to call OrbbecViewer with administrator privileges under linux.
+
+## 3.8 **Log Information**
+
+By default, the log information area is displayed in a single-folded state. By clicking the button on the far right.![33](images/image33.jpg)Expand to view full log information.  By clicking the button![34](images/image34.jpg)will empty the log. By clicking the button![35](images/image35.jpg)restores the collapsed single bar display state.
+![36](images/image36.jpg)
diff --git a/docs/tutorial/performance_tuning.md b/docs/tutorial/performance_tuning.md
new file mode 100644
index 00000000..ef8e3e5f
--- /dev/null
+++ b/docs/tutorial/performance_tuning.md
@@ -0,0 +1,49 @@
+# Performance Tuning
+
+## 1. Enhancing Performance by Switching UVC Backend (Linux Only)
+
+For cameras connected via USB, the Orbbec SDK supports both LibUVC and V4L2 as backends, with the V4L2 backend generally offering better performance and lower resource consumption. However, the V4L2 backend may have compatibility issues with different Linux versions, which is why the Orbbec SDK defaults to using the LibUVC backend. If you encounter frame dropping or latency issues, you can try switching to the V4L2 backend.
+
+**Note**: The V4L2 backend requires a kernel version of at least 4.16 (Ubuntu version 20.04 or higher) to function properly. Otherwise, there may be issues with obtaining the correct data frame timestamps and metadata.
+
+If you face performance issues, you can attempt to switch to the V4L2 backend by following these steps:
+
+1. Locate the `OrbbecSDKConfig.xml` file within the SDK package (usually found in the `./lib` or `./bin` directory, which can be located through a file search), and copy it to your application's working directory.
+
+2. In the `OrbbecSDKConfig.xml` file, find the `<LinuxUVCBackend>` tag and change `LibUVC` to `V4L2`:
+
+    ```xml
+    <LinuxUVCBackend>V4L2</LinuxUVCBackend>
+    ```
+
+3. For G330 series devices, you need to upgrade the firmware to version v1.0.60 or higher and in the `OrbbecSDKConfig.xml` file, change the `FrameMetadataParsingPath` tag from `ExtensionHeader` to `PayloadHeader`. Otherwise, metadata will not be retrieved correctly.
+
+   ```xml
+   <FrameMetadataParsingPath>PayloadHeader</FrameMetadataParsingPath>
+   ```
+
+4. After configuration, you will need to re-plug the device and restart your application.
+
+## 2. Improving usbfs Buffer Sizes (Linux Only)
+
+The `usbfs` kernel module is responsible for handling USB communication, and it has several parameters that can be tuned to improve performance. One of the most important parameters is the `usbfs_buffer_size` parameter, which determines the size of the kernel buffer used to store USB data.
+
+**Note**: It is strongly recommended to increase the `usbfs_buffer_size` parameter when using multiple usb devices or when streaming large amounts of data, as the default value may not be sufficient to handle the data rate.
+
+To increase the `usbfs_buffer_size`, follow these steps:
+
+1. execute the following command on terminal:
+
+    ``` shell
+    echo 128 | sudo tee /sys/module/usbcore/parameters/usbfs_memory_mb
+    ```
+
+2. Reboot the system.
+
+After the system reboots, you should see the `usbfs_buffer_size` parameter in the output of the `dmesg` command. You can verify that the `usbfs_buffer_size` has been set correctly by running the following command:
+
+``` shell
+cat /sys/module/usbcore/parameters/usbfs_memory_mb
+```
+
+The output should be `128`.
diff --git a/examples/0.basic.enumerate/CMakeLists.txt b/examples/0.basic.enumerate/CMakeLists.txt
new file mode 100644
index 00000000..c4b591ad
--- /dev/null
+++ b/examples/0.basic.enumerate/CMakeLists.txt
@@ -0,0 +1,14 @@
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+cmake_minimum_required(VERSION 3.5)
+project(ob_enumerate)
+
+add_executable(ob_enumerate enumerate.cpp)
+
+set_property(TARGET ob_enumerate PROPERTY CXX_STANDARD 11)
+target_link_libraries(ob_enumerate ob::OrbbecSDK ob::examples::utils)
+set_target_properties(ob_enumerate PROPERTIES FOLDER "examples")
+
+install(TARGETS ob_enumerate RUNTIME DESTINATION bin)
+
diff --git a/examples/0.basic.enumerate/README.md b/examples/0.basic.enumerate/README.md
new file mode 100644
index 00000000..c767df7e
--- /dev/null
+++ b/examples/0.basic.enumerate/README.md
@@ -0,0 +1,127 @@
+# C++ Sample: 0.basic.enumerate
+
+## Overview
+
+Use the SDK interface to obtain camera-related information, including model, various sensors, and sensor-related configurations.
+
+### Knowledge
+
+Context is the environment context, the first object created during initialization, which can be used to perform some settings, including but not limited to device status change callbacks, log level settings, etc. Context can access multiple Devices.
+
+Device is the device object, which can be used to obtain the device information, such as the model, serial number, and various sensors.One actual hardware device corresponds to one Device object.
+
+## Code overview
+
+1. Create a context
+
+    ```cpp
+        // Create a context.
+        ob::Context context;
+    ```
+
+2. Check if there is a camera connected
+
+    ```cpp
+        // Query the list of connected devices.
+        auto deviceList = context.queryDeviceList();
+        if(deviceList->getCount() < 1) {
+            std::cout << "No device found! Please connect a supported device and retry this program." << std::endl;
+            return -1;
+        }
+    ```
+
+3. Obtain and output relevant information of the access device
+
+    ```cpp
+        std::cout << "enumerated devices: " << std::endl;
+
+        std::shared_ptr<ob::Device>     device     = nullptr;
+        std::shared_ptr<ob::DeviceInfo> deviceInfo = nullptr;
+        for(uint32_t index = 0; index < deviceList->getCount(); index++) {
+            // Get device from deviceList.
+            device = deviceList->getDevice(index);
+            // Get device information from device
+            deviceInfo = device->getDeviceInfo();
+            std::cout << " - " << index << ". name: " << deviceInfo->getName() << " pid: " << deviceInfo->getPid() << " SN: " << deviceInfo->getSerialNumber()
+                        << std::endl;
+        }
+    ```
+
+4. Wait for keyboard input to select device
+
+    ```cpp
+        // select a device.
+        int deviceSelected = ob_smpl::getInputOption();
+        if(deviceSelected == -1) {
+            break;
+        }
+    ```
+
+5. Output device sensors and wait for keyboard input
+
+     ```cpp
+        // Enumerate sensors.
+        void enumerateSensors(std::shared_ptr<ob::Device> device) {
+            while(true) {
+                std::cout << "Sensor list: " << std::endl;
+                // Get the list of sensors.
+                auto sensorList = device->getSensorList();
+                for(uint32_t index = 0; index < sensorList->getCount(); index++) {
+                    // Get the sensor type.
+                    auto sensorType = sensorList->getSensorType(index);
+                    std::cout << " - " << index << "."
+                            << "sensor type: " << ob::TypeHelper::convertOBSensorTypeToString(sensorType) << std::endl;
+                }
+
+                std::cout << "Select a sensor to enumerate its streams(input sensor index or \'ESC\' to enumerate device): " << std::endl;
+
+                // Select a sensor.
+                int sensorSelected = ob_smpl::getInputOption();
+                if(sensorSelected == -1) {
+                    break;
+                }
+
+                // Get sensor from sensorList.
+                auto sensor = sensorList->getSensor(sensorSelected);
+                enumerateStreamProfiles(sensor);
+            }
+        }
+    ```
+
+6. Output information about the selected sensor
+
+    ```cpp
+    // Enumerate stream profiles.
+    void enumerateStreamProfiles(std::shared_ptr<ob::Sensor> sensor) {
+        // Get the list of stream profiles.
+        auto streamProfileList = sensor->getStreamProfileList();
+        // Get the sensor type.
+        auto sensorType = sensor->getType();
+        for(uint32_t index = 0; index < streamProfileList->getCount(); index++) {
+            // Get the stream profile.
+            auto profile = streamProfileList->getProfile(index);
+            if(sensorType == OB_SENSOR_IR || sensorType == OB_SENSOR_COLOR || sensorType == OB_SENSOR_DEPTH || sensorType == OB_SENSOR_IR_LEFT
+            || sensorType == OB_SENSOR_IR_RIGHT) {
+                printStreamProfile(profile, index);
+            }
+            else if(sensorType == OB_SENSOR_ACCEL) {
+                printAccelProfile(profile, index);
+            }
+            else if(sensorType == OB_SENSOR_GYRO) {
+                printGyroProfile(profile, index);
+            }
+            else {
+                break;
+            }
+        }
+    }
+    ```
+
+## Run Sample
+
+In the window, enter the relevant information of the device sensor you want to view according to the prompts.
+Press the Esc key in the window to exit the program.
+
+### Result
+
+![image](../../docs/resource/enumerate.jpg)
diff --git a/examples/0.basic.enumerate/enumerate.cpp b/examples/0.basic.enumerate/enumerate.cpp
new file mode 100644
index 00000000..a7f89b08
--- /dev/null
+++ b/examples/0.basic.enumerate/enumerate.cpp
@@ -0,0 +1,170 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include <libobsensor/ObSensor.hpp>
+
+#include "utils.hpp"
+
+#include <iostream>
+
+// get input option
+int getInputOption() {
+    char inputOption = ob_smpl::waitForKeyPressed();
+    if(inputOption == ESC_KEY) {
+        return -1;
+    }
+    return inputOption - '0';
+}
+
+// Print stream profile information.
+void printStreamProfile(std::shared_ptr<ob::StreamProfile> profile, uint32_t index) {
+    // Get the video profile.
+    auto videoProfile = profile->as<ob::VideoStreamProfile>();
+    // Get the format.
+    auto formatName = profile->getFormat();
+    // Get the width.
+    auto width = videoProfile->getWidth();
+    // Get the height.
+    auto height = videoProfile->getHeight();
+    // Get the fps.
+    auto fps = videoProfile->getFps();
+    std::cout << index << "."
+              << "format: " << ob::TypeHelper::convertOBFormatTypeToString(formatName) << ", "
+              << "revolution: " << width << "*" << height << ", "
+              << "fps: " << fps << std::endl;
+}
+
+// Print accel profile information.
+void printAccelProfile(std::shared_ptr<ob::StreamProfile> profile, uint32_t index) {
+    // Get the profile of accel.
+    auto accProfile = profile->as<ob::AccelStreamProfile>();
+    // Get the rate of accel.
+    auto accRate = accProfile->getSampleRate();
+    std::cout << index << "."
+              << "acc rate: " << ob::TypeHelper::convertOBIMUSampleRateTypeToString(accRate) << std::endl;
+}
+
+// Print gyro profile information.
+void printGyroProfile(std::shared_ptr<ob::StreamProfile> profile, uint32_t index) {
+    // Get the profile of gyro.
+    auto gyroProfile = profile->as<ob::GyroStreamProfile>();
+    // Get the rate of gyro.
+    auto gyroRate = gyroProfile->getSampleRate();
+    std::cout << index << "."
+              << "gyro rate: " << gyroRate << std::endl;
+}
+
+// Enumerate stream profiles.
+void enumerateStreamProfiles(std::shared_ptr<ob::Sensor> sensor) {
+    // Get the list of stream profiles.
+    auto streamProfileList = sensor->getStreamProfileList();
+    // Get the sensor type.
+    auto sensorType = sensor->getType();
+    for(uint32_t index = 0; index < streamProfileList->getCount(); index++) {
+        // Get the stream profile.
+        auto profile = streamProfileList->getProfile(index);
+        if(sensorType == OB_SENSOR_IR || sensorType == OB_SENSOR_COLOR || sensorType == OB_SENSOR_DEPTH || sensorType == OB_SENSOR_IR_LEFT
+           || sensorType == OB_SENSOR_IR_RIGHT) {
+            printStreamProfile(profile, index);
+        }
+        else if(sensorType == OB_SENSOR_ACCEL) {
+            printAccelProfile(profile, index);
+        }
+        else if(sensorType == OB_SENSOR_GYRO) {
+            printGyroProfile(profile, index);
+        }
+        else {
+            break;
+        }
+    }
+}
+
+// Enumerate sensors.
+void enumerateSensors(std::shared_ptr<ob::Device> device) {
+    while(true) {
+        std::cout << "Sensor list: " << std::endl;
+        // Get the list of sensors.
+        auto sensorList = device->getSensorList();
+        for(uint32_t index = 0; index < sensorList->getCount(); index++) {
+            // Get the sensor type.
+            auto sensorType = sensorList->getSensorType(index);
+            std::cout << " - " << index << "."
+                      << "sensor type: " << ob::TypeHelper::convertOBSensorTypeToString(sensorType) << std::endl;
+        }
+
+        std::cout << "Select a sensor to enumerate its streams(input sensor index or \'ESC\' to enumerate device): " << std::endl;
+
+        // Select a sensor.
+        int sensorSelected = ob_smpl::getInputOption();
+        if(sensorSelected >= static_cast<int>(sensorList->getCount()) || sensorSelected < 0) {
+            if (sensorSelected == -1) {
+                break;
+            }
+            else {
+                std::cout << "\nInvalid input, please reselect the sensor!\n";
+                continue;
+            }
+        }
+
+        // Get sensor from sensorList.
+        auto sensor = sensorList->getSensor(sensorSelected);
+        enumerateStreamProfiles(sensor);
+    }
+}
+
+int main(void) try {
+
+    // Create a context.
+    ob::Context context;
+
+    while(true) {
+        // Query the list of connected devices.
+        auto deviceList = context.queryDeviceList();
+        if(deviceList->getCount() < 1) {
+            std::cout << "No device found! Please connect a supported device and retry this program." << std::endl;
+            std::cout << "\nPress any key to exit.";
+            ob_smpl::waitForKeyPressed();
+            return -1;
+        }
+
+        std::cout << "enumerated devices: " << std::endl;
+
+        std::shared_ptr<ob::Device>     device     = nullptr;
+        std::shared_ptr<ob::DeviceInfo> deviceInfo = nullptr;
+        for(uint32_t index = 0; index < deviceList->getCount(); index++) {
+            // Get device from deviceList.
+            device = deviceList->getDevice(index);
+            // Get device information from device
+            deviceInfo = device->getDeviceInfo();
+            std::cout << " - " << index << ". name: " << deviceInfo->getName() << " pid: " << deviceInfo->getPid() << " SN: " << deviceInfo->getSerialNumber()
+                      << std::endl;
+        }
+
+        std::cout << "enumerate sensors of device (input device index or \'ESC\' to exit program):" <<std::endl;
+
+        // select a device.
+        int deviceSelected = ob_smpl::getInputOption();
+        if(deviceSelected >= static_cast<int>(deviceList->getCount()) || deviceSelected < 0) {
+            if (deviceSelected == -1) {
+                break;
+            }
+            else {
+                std::cout << "\nInvalid input, please reselect the device!\n";
+                continue;
+            }
+        }
+
+        //  Get the device.
+        auto selectedDevice = deviceList->getDevice(deviceSelected);
+        enumerateSensors(selectedDevice);
+    }
+
+    return 0;
+}
+catch(ob::Error &e) {
+    std::cerr << "function:" << e.getFunction() << "\nargs:" << e.getArgs() << "\nmessage:" << e.what() << "\ntype:" << e.getExceptionType() << std::endl;
+    std::cout << "\nPress any key to exit.";
+    ob_smpl::waitForKeyPressed();
+    exit(EXIT_FAILURE);
+}
+
diff --git a/examples/0.basic.quick_start/CMakeLists.txt b/examples/0.basic.quick_start/CMakeLists.txt
new file mode 100644
index 00000000..7f137a96
--- /dev/null
+++ b/examples/0.basic.quick_start/CMakeLists.txt
@@ -0,0 +1,14 @@
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+cmake_minimum_required(VERSION 3.5)
+project(ob_quick_start)
+
+add_executable(ob_quick_start quick_start.cpp)
+
+set_property(TARGET ob_quick_start PROPERTY CXX_STANDARD 11)
+target_link_libraries(ob_quick_start ob::OrbbecSDK ob::examples::utils)
+set_target_properties (ob_quick_start PROPERTIES FOLDER "examples")
+
+install(TARGETS ob_quick_start RUNTIME DESTINATION bin)
+
diff --git a/examples/0.basic.quick_start/README.md b/examples/0.basic.quick_start/README.md
new file mode 100644
index 00000000..ad782065
--- /dev/null
+++ b/examples/0.basic.quick_start/README.md
@@ -0,0 +1,60 @@
+# C++ Sample: 0.basic.quick_start
+
+## Overview
+
+Use the SDK interface to quickly obtain the camera video stream and display it in the window.
+
+### Knowledge
+
+Pipeline is a pipeline for processing data streams, providing multi-channel stream configuration, switching, frame aggregation, and frame synchronization functions
+
+Frameset is a combination of different types of Frames
+
+win is used to display the frame data.
+
+## Code overview
+
+1. Instantiate the pipeline using the default configuration file and quickly open the video stream
+
+    ```cpp
+        // Create a pipeline.
+        ob::Pipeline pipe;
+
+        // Start the pipeline with default config.
+        // Modify the default configuration by the configuration file: "OrbbecSDKConfig.xml"
+        pipe.start();
+    ```
+
+2. Create a window for showing the frames, and set the size of the window
+
+    ```cpp
+        // Create a window for showing the frames, and set the size of the window.
+        ob_smpl::CVWindow win("QuickStart", 1280, 720, ob_smpl::ARRANGE_ONE_ROW);
+    ```
+
+3. Open the window and display the video stream. The video stream waits for a frame of data in a blocking manner. The frame is a composite frame containing the frame data of all streams enabled in the configuration, and the waiting timeout of the frame is set
+
+    ```cpp
+        while(win.run()) {
+            // Wait for frameSet from the pipeline, the default timeout is 1000ms.
+            auto frameSet = pipe.waitForFrameset();
+
+            // Push the frames to the window for showing.
+            win.pushFramesToView(frameSet);
+        }
+    ```
+
+4. Use pipeline to close the video stream
+
+    ```cpp
+        // Stop the Pipeline, no frame data will be generated
+        pipe.stop();
+    ```
+
+## Run Sample
+
+Press the Esc key in the window to exit the program.
+
+### Result
+
+![image](../../docs/resource/quick_start.jpg)
diff --git a/examples/0.basic.quick_start/quick_start.cpp b/examples/0.basic.quick_start/quick_start.cpp
new file mode 100644
index 00000000..2ff452b5
--- /dev/null
+++ b/examples/0.basic.quick_start/quick_start.cpp
@@ -0,0 +1,39 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include <libobsensor/ObSensor.hpp>
+
+#include "utils.hpp"
+#include "utils_opencv.hpp"
+
+int main(void) try {
+    // Create a pipeline.
+    ob::Pipeline pipe;
+
+    // Start the pipeline with default config.
+    // Modify the default configuration by the configuration file: "OrbbecSDKConfig.xml"
+    pipe.start();
+
+    // Create a window for showing the frames, and set the size of the window.
+    ob_smpl::CVWindow win("QuickStart", 1280, 720, ob_smpl::ARRANGE_ONE_ROW);
+
+    while(win.run()) {
+        // Wait for frameSet from the pipeline, the default timeout is 1000ms.
+        auto frameSet = pipe.waitForFrameset();
+
+        // Push the frames to the window for showing.
+        win.pushFramesToView(frameSet);
+    }
+
+    // Stop the Pipeline, no frame data will be generated
+    pipe.stop();
+
+    return 0;
+}
+catch(ob::Error &e) {
+    std::cerr << "function:" << e.getFunction() << "\nargs:" << e.getArgs() << "\nmessage:" << e.what() << "\ntype:" << e.getExceptionType() << std::endl;
+    std::cout << "\nPress any key to exit.";
+    ob_smpl::waitForKeyPressed();
+    exit(EXIT_FAILURE);
+}
+
diff --git a/examples/1.stream.callback/CMakeLists.txt b/examples/1.stream.callback/CMakeLists.txt
new file mode 100644
index 00000000..e07f5c52
--- /dev/null
+++ b/examples/1.stream.callback/CMakeLists.txt
@@ -0,0 +1,14 @@
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+cmake_minimum_required(VERSION 3.5)
+project(ob_callback)
+
+add_executable(${PROJECT_NAME} callback.cpp)
+
+set_property(TARGET ${PROJECT_NAME} PROPERTY CXX_STANDARD 11)
+target_link_libraries(${PROJECT_NAME} ob::OrbbecSDK ob::examples::utils)
+set_target_properties (${PROJECT_NAME} PROPERTIES FOLDER "examples")
+
+install(TARGETS ob_callback RUNTIME DESTINATION bin)
+
diff --git a/examples/1.stream.callback/README.md b/examples/1.stream.callback/README.md
new file mode 100644
index 00000000..d05c1594
--- /dev/null
+++ b/examples/1.stream.callback/README.md
@@ -0,0 +1,96 @@
+# C++ Sample: 1.stream.callback
+
+## Overview
+
+In this sample,user can get the depth、RGB、IR image.This sample also support users can perform user-defined operations such as data acquisition, data processing, and data modification within the callback function.
+
+### Knowledge
+
+Pipeline is a pipeline for processing data streams, providing multi-channel stream configuration, switching, frame aggregation, and frame synchronization functions.
+
+Device is a class that can be used to get device information, parameters, and a list of contained sensors.
+
+Sensor can be used to obtain different components of the camera and the stream of the component, for example, RGB, IR, Depth stream can be obtained through the RGB, IR, Depth sensor.
+
+## code overview
+
+1. Create the pipeline instance using the default configuration and create a config instance to enable or disable the streams.Get the device instance from pipeline,and then get the sensor instance from device.
+
+    ```c++
+        // Create a pipeline.
+        ob::Pipeline pipe;
+
+        // Configure which streams to enable or disable for the Pipeline by creating a Config.
+        std::shared_ptr<ob::Config> config = std::make_shared<ob::Config>();
+
+        // Get device from pipeline.
+        auto device = pipe.getDevice();
+
+        // Get sensorList from device.
+        auto sensorList = device->getSensorList();
+    ```
+
+2. Get only the sensor for the VideoStream,enable the stream from these sensor.
+
+    ```c++
+        for(uint32_t index = 0; index < sensorList->getCount(); index++) {
+                // Query all supported infrared sensor type and enable the infrared stream.
+                // For dual infrared device, enable the left and right infrared streams.
+                // For single infrared device, enable the infrared stream.
+                OBSensorType sensorType = sensorList->getSensorType(index);
+
+                // exclude non-video sensor type
+                if(!ob::TypeHelper::isVideoSensorType(sensorType)) {
+                    continue;
+                }
+
+                // Enable the stream for the sensor type.
+                config->enableStream(sensorType);
+            }
+    ```
+
+3. In this callback function, you can add what you want to do with the data.Avoid performing complex computational operations within callback functions; prolonged operations can lead to data frame drops. It is recommended to use a queue for processing.
+
+    ```c++
+        // Start the pipeline with callback.
+        pipe.start(config, [&](std::shared_ptr<ob::FrameSet> output) {
+            std::lock_guard<std::mutex> lock(framesetMutex);
+            frameset = output;
+        });
+    ```
+
+4. Render window
+
+    ```c++
+        while(win.run()) {
+            std::lock_guard<std::mutex> lock(framesetMutex);
+
+            if(frameset == nullptr) {
+                continue;
+            }
+
+            // Rendering display
+            win.pushFramesToView(frameset);
+        }
+    ```
+
+5. stop pipeline
+
+    ```c++
+        // Stop the Pipeline, no frame data will be generated
+        pipe.stop();
+    ```
+
+## Run Sample
+
+If you are on Windows, you can switch to the directory `OrbbecSDK-dev/build/win_XX/bin` to find the `ob_callback.exe`.
+
+If you are on linux, you can switch to the directory `OrbbecSDK-dev/build/linux_XX/bin` to find the `ob_callback`.
+
+### Key introduction
+
+Press the Esc key in the window to exit the program.
+
+### Result
+
+![result](../../docs/resource/callback.jpg)
diff --git a/examples/1.stream.callback/callback.cpp b/examples/1.stream.callback/callback.cpp
new file mode 100644
index 00000000..1fbd0ca2
--- /dev/null
+++ b/examples/1.stream.callback/callback.cpp
@@ -0,0 +1,72 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include <libobsensor/ObSensor.hpp>
+
+#include "utils.hpp"
+#include "utils_opencv.hpp"
+
+int main(void) try {
+
+    // Create a pipeline.
+    ob::Pipeline pipe;
+
+    // Configure which streams to enable or disable for the Pipeline by creating a Config.
+    std::shared_ptr<ob::Config> config = std::make_shared<ob::Config>();
+
+    // Get device from pipeline.
+    auto device = pipe.getDevice();
+
+    // Get sensorList from device.
+    auto sensorList = device->getSensorList();
+
+    for(uint32_t index = 0; index < sensorList->getCount(); index++) {
+        // Query all supported infrared sensor type and enable the infrared stream.
+        // For dual infrared device, enable the left and right infrared streams.
+        // For single infrared device, enable the infrared stream.
+        OBSensorType sensorType = sensorList->getSensorType(index);
+
+        // exclude non-video sensor type
+        if(!ob::TypeHelper::isVideoSensorType(sensorType)) {
+            continue;
+        }
+
+        // Enable the stream for the sensor type.
+        config->enableStream(sensorType);
+    }
+
+    std::mutex                    framesetMutex;
+    std::shared_ptr<ob::FrameSet> frameset = nullptr;
+
+    // Start the pipeline with callback.
+    pipe.start(config, [&](std::shared_ptr<ob::FrameSet> output) {
+        std::lock_guard<std::mutex> lock(framesetMutex);
+        frameset = output;
+    });
+
+    // Create a window for rendering, and set the size of the window.
+    ob_smpl::CVWindow win("Callback", 1280, 720, ob_smpl::ARRANGE_GRID);
+
+    while(win.run()) {
+        std::lock_guard<std::mutex> lock(framesetMutex);
+
+        if(frameset == nullptr) {
+            continue;
+        }
+
+        // Rendering display
+        win.pushFramesToView(frameset);
+    }
+
+    // Stop the Pipeline, no frame data will be generated
+    pipe.stop();
+
+    return 0;
+}
+catch(ob::Error &e) {
+    std::cerr << "function:" << e.getFunction() << "\nargs:" << e.getArgs() << "\nmessage:" << e.what() << "\ntype:" << e.getExceptionType() << std::endl;
+    std::cout << "\nPress any key to exit.";
+    ob_smpl::waitForKeyPressed();
+    exit(EXIT_FAILURE);
+}
+
diff --git a/examples/1.stream.color/CMakeLists.txt b/examples/1.stream.color/CMakeLists.txt
new file mode 100644
index 00000000..249b878b
--- /dev/null
+++ b/examples/1.stream.color/CMakeLists.txt
@@ -0,0 +1,14 @@
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+cmake_minimum_required(VERSION 3.5)
+project(ob_color)
+
+add_executable(ob_color color.cpp)
+
+set_property(TARGET ob_color PROPERTY CXX_STANDARD 11)
+target_link_libraries(ob_color ob::OrbbecSDK ob::examples::utils)
+set_target_properties (ob_color PROPERTIES FOLDER "examples")
+
+install(TARGETS ob_color RUNTIME DESTINATION bin)
+
diff --git a/examples/1.stream.color/README.md b/examples/1.stream.color/README.md
new file mode 100644
index 00000000..573a64d1
--- /dev/null
+++ b/examples/1.stream.color/README.md
@@ -0,0 +1,47 @@
+# C++ Sample: 1.stream.color
+
+## Overview
+
+Use the SDK interface to obtain the camera's color stream and display it in the window.
+
+### Knowledge
+
+config is the configuration of the camera
+Frameset is a combination of different types of Frames
+
+## Code overview
+
+1. Configure the output color stream and open the video stream.You must configure this before calling pipe.start().
+
+    ```cpp
+        // Configure which streams to enable or disable for the Pipeline by creating a Config.
+        std::shared_ptr<ob::Config> config = std::make_shared<ob::Config>();
+
+        // Enable color video stream.
+        config->enableVideoStream(OB_STREAM_COLOR);
+    ```
+
+2. After waiting for a while, get the color stream in the frameset and display it in the window
+
+    ```cpp
+        while(win.run()) {
+        // Wait for up to 100ms for a frameset in blocking mode.
+        auto frameSet = pipe.waitForFrameset();
+        if(frameSet == nullptr) {
+            continue;
+        }
+
+        // get color frame from frameset.
+        auto colorFrame = frameSet->getFrame(OB_FRAME_COLOR);
+        // Render colorFrame.
+        win.pushFramesToView(colorFrame);
+    }
+    ```
+
+## Run Sample
+
+Press the Esc key in the window to exit the program.
+
+### Result
+
+![result](../../docs/resource/color.jpg)
diff --git a/examples/1.stream.color/color.cpp b/examples/1.stream.color/color.cpp
new file mode 100644
index 00000000..e0e6f851
--- /dev/null
+++ b/examples/1.stream.color/color.cpp
@@ -0,0 +1,50 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include <libobsensor/ObSensor.hpp>
+
+#include "utils.hpp"
+#include "utils_opencv.hpp"
+
+int main(void) try {
+
+    // Create a pipeline with default device.
+    ob::Pipeline pipe;
+
+    // Configure which streams to enable or disable for the Pipeline by creating a Config.
+    std::shared_ptr<ob::Config> config = std::make_shared<ob::Config>();
+
+    // Enable color video stream.
+    config->enableVideoStream(OB_STREAM_COLOR);
+
+    // Start the pipeline with config.
+    pipe.start(config);
+
+    // Create a window for rendering and set the resolution of the window.
+    ob_smpl::CVWindow win("Color");
+
+    while(win.run()) {
+        // Wait for up to 100ms for a frameset in blocking mode.
+        auto frameSet = pipe.waitForFrameset();
+        if(frameSet == nullptr) {
+            continue;
+        }
+
+        // get color frame from frameset.
+        auto colorFrame = frameSet->getFrame(OB_FRAME_COLOR);
+        // Render colorFrame.
+        win.pushFramesToView(colorFrame);
+    }
+
+    // Stop the Pipeline, no frame data will be generated
+    pipe.stop();
+
+    return 0;
+}
+catch(ob::Error &e) {
+    std::cerr << "function:" << e.getFunction() << "\nargs:" << e.getArgs() << "\nmessage:" << e.what() << "\ntype:" << e.getExceptionType() << std::endl;
+    std::cout << "\nPress any key to exit.";
+    ob_smpl::waitForKeyPressed();
+    exit(EXIT_FAILURE);
+}
+
diff --git a/examples/1.stream.depth/CMakeLists.txt b/examples/1.stream.depth/CMakeLists.txt
new file mode 100644
index 00000000..0cb860f5
--- /dev/null
+++ b/examples/1.stream.depth/CMakeLists.txt
@@ -0,0 +1,20 @@
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+cmake_minimum_required(VERSION 3.5)
+project(ob_depth)
+
+add_executable(${PROJECT_NAME} depth.cpp)
+
+set_property(TARGET ${PROJECT_NAME} PROPERTY CXX_STANDARD 11)
+
+target_link_libraries(${PROJECT_NAME} ob::OrbbecSDK ob::examples::utils)
+
+set_target_properties(${PROJECT_NAME} PROPERTIES FOLDER "examples")
+
+install(TARGETS ob_depth RUNTIME DESTINATION bin)
+
+
+
+
+
diff --git a/examples/1.stream.depth/README.md b/examples/1.stream.depth/README.md
new file mode 100644
index 00000000..14e08e03
--- /dev/null
+++ b/examples/1.stream.depth/README.md
@@ -0,0 +1,51 @@
+# C++ Sample: 1.stream.depth
+
+## Overview
+
+Use the SDK interface to obtain the depth stream of the camera and display it in the window
+
+### Knowledge
+
+DepthFrame can obtain relevant information about the depth
+
+## code overview
+
+1. Configure the output color stream and open the video stream.You must configure this before calling pipe.start().
+
+    ```cpp
+        // By creating config to configure which streams to enable or disable for the pipeline, here the depth stream will be enabled.
+        std::shared_ptr<ob::Config> config = std::make_shared<ob::Config>();
+
+        //This is the default depth streamprofile that is enabled. If you want to modify it, you can do so in the configuration file.
+        config->enableVideoStream(OB_STREAM_DEPTH);
+
+    ```
+
+2. Calculate the distance from the center pixel to the opposite side from the acquired Y16 depth stream format and display it in the window. The distance is refreshed every 30 frames.The default depth unit for the SDK is millimeters.
+
+    ```cpp
+        // Get the depth Frame form depthFrameRaw.
+        auto depthFrame = depthFrameRaw->as<ob::DepthFrame>();
+        // for Y16 format depth frame, print the distance of the center pixel every 30 frames.
+        if(depthFrame->getIndex() % 30 == 0 && depthFrame->getFormat() == OB_FORMAT_Y16) {
+            uint32_t        width  = depthFrame->getWidth();
+            uint32_t        height = depthFrame->getHeight();
+            float           scale  = depthFrame->getValueScale();
+            const uint16_t *data   = reinterpret_cast<const uint16_t *>(depthFrame->getData());
+
+            // pixel value multiplied by scale is the actual distance value in millimeters.
+            float centerDistance = data[width * height / 2 + width / 2] * scale;
+
+            // // attention: if the distance is 0, it means that the depth camera cannot detect the object (may be out of detection range).
+            win.addLog("Facing an object at a distance of " + ob_smpl::toString(centerDistance, 3) + " mm. ");
+        }
+    ```
+
+## Run Sample
+
+Moving the camera can obtain the change in the distance across the center pixel
+Press the Esc key in the window to exit the program.
+
+### Result
+
+![image](../../docs/resource/depth.jpg)
diff --git a/examples/1.stream.depth/depth.cpp b/examples/1.stream.depth/depth.cpp
new file mode 100644
index 00000000..19113254
--- /dev/null
+++ b/examples/1.stream.depth/depth.cpp
@@ -0,0 +1,71 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include <libobsensor/ObSensor.hpp>
+
+#include "utils.hpp"
+#include "utils_opencv.hpp"
+
+#include <thread>
+
+int main(void) try {
+
+    // Create a pipeline with default device.
+    ob::Pipeline pipe;
+
+    // By creating config to configure which streams to enable or disable for the pipeline, here the depth stream will be enabled.
+    std::shared_ptr<ob::Config> config = std::make_shared<ob::Config>();
+
+    // This is the default depth streamprofile that is enabled. If you want to modify it, you can do so in the configuration file.
+    config->enableVideoStream(OB_STREAM_DEPTH);
+
+    // Start the pipeline with config.
+    pipe.start(config);
+
+    // Create a window for rendering, and set the resolution of the window.
+    ob_smpl::CVWindow win("Depth");
+
+    while(win.run()) {
+        // Wait for up to 100ms for a frameset in blocking mode.
+        auto frameSet = pipe.waitForFrameset(100);
+        if(frameSet == nullptr) {
+            continue;
+        }
+
+        // Get the depth frame raw from frameset.
+        auto depthFrameRaw = frameSet->getFrame(OB_FRAME_DEPTH);
+        if(!depthFrameRaw) {
+            continue;
+        }
+
+        // Get the depth Frame form depthFrameRaw.
+        auto depthFrame = depthFrameRaw->as<ob::DepthFrame>();
+        // for Y16 format depth frame, print the distance of the center pixel every 30 frames.
+        if(depthFrame->getIndex() % 30 == 0 && depthFrame->getFormat() == OB_FORMAT_Y16) {
+            uint32_t        width  = depthFrame->getWidth();
+            uint32_t        height = depthFrame->getHeight();
+            float           scale  = depthFrame->getValueScale();
+            const uint16_t *data   = reinterpret_cast<const uint16_t *>(depthFrame->getData());
+
+            // pixel value multiplied by scale is the actual distance value in millimeters.
+            float centerDistance = data[width * height / 2 + width / 2] * scale;
+
+            // // attention: if the distance is 0, it means that the depth camera cannot detect the object (may be out of detection range).
+            win.addLog("Facing an object at a distance of " + ob_smpl::toString(centerDistance, 3) + " mm. ");
+        }
+
+        // Render frame in the window.
+        win.pushFramesToView(depthFrame);
+    }
+
+    // Stop the pipeline
+    pipe.stop();
+
+    return 0;
+}
+catch(ob::Error &e) {
+    std::cerr << "function:" << e.getFunction() << "\nargs:" << e.getArgs() << "\nmessage:" << e.what() << "\ntype:" << e.getExceptionType() << std::endl;
+    std::cout << "\nPress any key to exit.";
+    ob_smpl::waitForKeyPressed();
+    exit(EXIT_FAILURE);
+}
diff --git a/examples/1.stream.imu/CMakeLists.txt b/examples/1.stream.imu/CMakeLists.txt
new file mode 100644
index 00000000..81bd13a1
--- /dev/null
+++ b/examples/1.stream.imu/CMakeLists.txt
@@ -0,0 +1,15 @@
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+cmake_minimum_required(VERSION 3.5)
+project(ob_imu)
+
+add_executable(ob_imu imu.cpp)
+
+set_property(TARGET ob_imu PROPERTY CXX_STANDARD 11)
+target_link_libraries(ob_imu ob::OrbbecSDK ob::examples::utils)
+
+set_target_properties(ob_imu PROPERTIES FOLDER "examples")
+
+install(TARGETS ob_imu RUNTIME DESTINATION bin)
+
diff --git a/examples/1.stream.imu/README.md b/examples/1.stream.imu/README.md
new file mode 100644
index 00000000..0d27e238
--- /dev/null
+++ b/examples/1.stream.imu/README.md
@@ -0,0 +1,66 @@
+# C++ Sample: 1.stream.imu
+
+## Overview
+
+Use the SDK interface to obtain the camera's internal imu data and output it
+
+### Knowledge
+
+AccelFrame measures the acceleration of x, y, and z in m/s^2
+GyroFrame measures the angular velocity of x, y, and z in rad/s
+
+Frameset is a combination of different types of Frames.imu data stream can be obtained through frameset
+
+## code overview
+
+1. Configure output imu related information and open stream.You must configure this before calling pipe.start().
+
+    ```cpp
+
+        // Configure which streams to enable or disable for the Pipeline by creating a Config.
+        std::shared_ptr<ob::Config> config = std::make_shared<ob::Config>();
+
+        // Enable Accel stream.
+        config->enableAccelStream();
+
+        // Enable Gyro stream.
+        config->enableGyroStream();
+
+        // Only FrameSet that contains all types of data frames will be output.
+        config->setFrameAggregateOutputMode(OB_FRAME_AGGREGATE_OUTPUT_ALL_TYPE_FRAME_REQUIRE);
+
+    ```
+
+2. Instantiate pipeline, configure output imu related information and open stream
+
+    ```cpp
+        auto accelFrameRaw    = frameSet->getFrame(OB_FRAME_ACCEL);
+        auto accelFrame       = accelFrameRaw->as<ob::AccelFrame>();
+        auto accelIndex       = accelFrame->getIndex();
+        auto accelTimeStampUs = accelFrame->getTimeStampUs();
+        auto accelTemperature = accelFrame->getTemperature();
+        auto accelType        = accelFrame->getType();
+        if(accelIndex % 50 == 0) {  // print information every 50 frames.
+            auto accelValue = accelFrame->getValue();
+            printImuValue(accelValue, accelIndex, accelTimeStampUs, accelTemperature, accelType, "m/s^2");
+        }
+
+        auto gyroFrameRaw    = frameSet->getFrame(OB_FRAME_GYRO);
+        auto gyroFrame       = gyroFrameRaw->as<ob::GyroFrame>();
+        auto gyroIndex       = gyroFrame->getIndex();
+        auto gyroTimeStampUs = gyroFrame->getTimeStampUs();
+        auto gyroTemperature = gyroFrame->getTemperature();
+        auto gyroType        = gyroFrame->getType();
+        if(gyroIndex % 50 == 0) {  // print information every 50 frames.
+            auto gyroValue = gyroFrame->getValue();
+            printImuValue(gyroValue, gyroIndex, gyroTimeStampUs, gyroTemperature, gyroType, "rad/s");
+        }
+    ```
+
+## Run Sample
+
+Press the Esc key in the window to exit the program.
+
+### Result
+
+![image](../../docs/resource/imu.jpg)
diff --git a/examples/1.stream.imu/imu.cpp b/examples/1.stream.imu/imu.cpp
new file mode 100644
index 00000000..0199875c
--- /dev/null
+++ b/examples/1.stream.imu/imu.cpp
@@ -0,0 +1,86 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include <libobsensor/ObSensor.hpp>
+
+#include "utils.hpp"
+#include "utils_types.h"
+
+#include <mutex>
+#include <iostream>
+
+void printImuValue(OBFloat3D obFloat3d, uint64_t index, uint64_t timeStampUs, float temperature, OBFrameType type, const std::string &unitStr) {
+    std::cout << "frame index: " <<index << std::endl;
+    auto typeStr = ob::TypeHelper::convertOBFrameTypeToString(type);
+    std::cout << type << " Frame: \n\r{\n\r"
+              << "  tsp = " << timeStampUs << "\n\r"
+              << "  temperature = " << temperature << "\n\r"
+              << "  " << type << ".x = " << obFloat3d.x << unitStr << "\n\r"
+              << "  " << type << ".y = " << obFloat3d.y << unitStr << "\n\r"
+              << "  " << type << ".z = " << obFloat3d.z << unitStr << "\n\r"
+              << "}\n\r" << std::endl;
+}
+
+int main() try {
+
+    // Create a pipeline with default device.
+    ob::Pipeline pipe;
+
+    // Configure which streams to enable or disable for the Pipeline by creating a Config.
+    std::shared_ptr<ob::Config> config = std::make_shared<ob::Config>();
+
+    // Enable Accel stream.
+    config->enableAccelStream();
+
+    // Enable Gyro stream.
+    config->enableGyroStream();
+
+    // Only FrameSet that contains all types of data frames will be output.
+    config->setFrameAggregateOutputMode(OB_FRAME_AGGREGATE_OUTPUT_ALL_TYPE_FRAME_REQUIRE);
+
+    // Start the pipeline with config.
+    pipe.start(config);
+
+    while(true) {
+        auto key = ob_smpl::waitForKeyPressed(1);
+        if(key == ESC_KEY) {  // Esc key to exit.
+            break;
+        }
+        auto frameSet = pipe.waitForFrameset();
+        if(frameSet == nullptr) {
+            continue;
+        }
+
+        auto accelFrameRaw    = frameSet->getFrame(OB_FRAME_ACCEL);
+        auto accelFrame       = accelFrameRaw->as<ob::AccelFrame>();
+        auto accelIndex       = accelFrame->getIndex();
+        auto accelTimeStampUs = accelFrame->getTimeStampUs();
+        auto accelTemperature = accelFrame->getTemperature();
+        auto accelType        = accelFrame->getType();
+        if(accelIndex % 50 == 0) {  // print information every 50 frames.
+            auto accelValue = accelFrame->getValue();
+            printImuValue(accelValue, accelIndex, accelTimeStampUs, accelTemperature, accelType, "m/s^2");
+        }
+
+        auto gyroFrameRaw    = frameSet->getFrame(OB_FRAME_GYRO);
+        auto gyroFrame       = gyroFrameRaw->as<ob::GyroFrame>();
+        auto gyroIndex       = gyroFrame->getIndex();
+        auto gyroTimeStampUs = gyroFrame->getTimeStampUs();
+        auto gyroTemperature = gyroFrame->getTemperature();
+        auto gyroType        = gyroFrame->getType();
+        if(gyroIndex % 50 == 0) {  // print information every 50 frames.
+            auto gyroValue = gyroFrame->getValue();
+            printImuValue(gyroValue, gyroIndex, gyroTimeStampUs, gyroTemperature, gyroType, "rad/s");
+        }
+    }
+
+    pipe.stop();
+
+    return 0;
+}
+catch(ob::Error &e) {
+    std::cerr << "function:" << e.getFunction() << "\nargs:" << e.getArgs() << "\nmessage:" << e.what() << "\ntype:" << e.getExceptionType() << std::endl;
+    std::cout << "\nPress any key to exit.";
+    ob_smpl::waitForKeyPressed();
+    exit(EXIT_FAILURE);
+}
diff --git a/examples/1.stream.infrared/CMakeLists.txt b/examples/1.stream.infrared/CMakeLists.txt
new file mode 100644
index 00000000..4cfd555a
--- /dev/null
+++ b/examples/1.stream.infrared/CMakeLists.txt
@@ -0,0 +1,15 @@
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+cmake_minimum_required(VERSION 3.5)
+project(ob_infrared)
+
+add_executable(ob_infrared infrared.cpp)
+
+set_property(TARGET ob_infrared PROPERTY CXX_STANDARD 11)
+target_link_libraries(ob_infrared ob::OrbbecSDK ob::examples::utils)
+
+set_target_properties (ob_infrared PROPERTIES FOLDER "examples")
+
+install(TARGETS ob_infrared RUNTIME DESTINATION bin)
+
diff --git a/examples/1.stream.infrared/README.md b/examples/1.stream.infrared/README.md
new file mode 100644
index 00000000..6ab51d50
--- /dev/null
+++ b/examples/1.stream.infrared/README.md
@@ -0,0 +1,59 @@
+# C++ Sample: 1.stream.infrared
+
+## Overview
+
+Use the SDK interface to obtain the camera IR stream and display it in the window
+
+### Knowledge
+
+Pipeline is a pipeline for processing data streams, providing multi-channel stream configuration, switching, frame aggregation, and frame synchronization functions.
+
+## code overview
+
+1. Configure IR sensor related information and enable the IR stream.You must configure this before calling pipe.start().
+
+    ```cpp
+        // Get the device from pipeline.
+        std::shared_ptr<ob::Device> device = pipe.getDevice();
+
+        // Get the sensor list from device.
+        std::shared_ptr<ob::SensorList> sensorList = device->getSensorList();
+
+        // Create a config for pipeline.
+        std::shared_ptr<ob::Config> config = std::make_shared<ob::Config>();
+
+        for(uint32_t index = 0; index < sensorList->getCount(); index++) {
+            // Query all supported infrared sensor type and enable the infrared stream.
+            // For dual infrared device, enable the left and right infrared streams.
+            // For single infrared device, enable the infrared stream.
+            OBSensorType sensorType = sensorList->getSensorType(index);
+            if(sensorType == OB_SENSOR_IR || sensorType == OB_SENSOR_IR_LEFT || sensorType == OB_SENSOR_IR_RIGHT) {
+                // Enable the stream with specified profile;
+                config->enableVideoStream(sensorType, OB_WIDTH_ANY, OB_HEIGHT_ANY, 30, OB_FORMAT_ANY);
+            }
+        }
+    ```
+
+2. Open the window and output the IR stream
+
+    ```cpp
+        ob_smpl::CVWindow win("Infrared", 1280, 720, ob_smpl::ARRANGE_ONE_ROW);
+        while(win.run()) {
+        // Wait for up to 100ms for a frameset in blocking mode.
+            auto frameSet = pipe.waitForFrameset(100);
+            if(frameSet == nullptr) {
+                continue;
+        }
+
+        // Render a set of frame in the window.
+        win.pushFramesToView(frameSet);
+        }
+    ```
+
+## Run Sample
+
+Press the Esc key in the window to exit the program.
+
+### Result
+
+![image](../../docs/resource/infrared.jpg)
diff --git a/examples/1.stream.infrared/infrared.cpp b/examples/1.stream.infrared/infrared.cpp
new file mode 100644
index 00000000..3110c00b
--- /dev/null
+++ b/examples/1.stream.infrared/infrared.cpp
@@ -0,0 +1,65 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include <libobsensor/ObSensor.hpp>
+
+#include "utils.hpp"
+#include "utils_opencv.hpp"
+
+std::map<OBSensorType, ob_stream_type> sensorStreamMap = {
+    {OB_SENSOR_IR, OB_STREAM_IR},
+    {OB_SENSOR_IR_LEFT, OB_STREAM_IR_LEFT},
+    {OB_SENSOR_IR_RIGHT, OB_STREAM_IR_RIGHT}
+};
+
+int main() try {
+    // Create a pipeline with default device.
+    ob::Pipeline pipe;
+
+    // Get the device from pipeline.
+    std::shared_ptr<ob::Device> device = pipe.getDevice();
+
+    // Get the sensor list from device.
+    std::shared_ptr<ob::SensorList> sensorList = device->getSensorList();
+
+    // Create a config for pipeline.
+    std::shared_ptr<ob::Config> config = std::make_shared<ob::Config>();
+
+    for(uint32_t index = 0; index < sensorList->getCount(); index++) {
+        // Query all supported infrared sensor type and enable the infrared stream.
+        // For dual infrared device, enable the left and right infrared streams.
+        // For single infrared device, enable the infrared stream.
+        OBSensorType sensorType = sensorList->getSensorType(index);
+        if(sensorType == OB_SENSOR_IR || sensorType == OB_SENSOR_IR_LEFT || sensorType == OB_SENSOR_IR_RIGHT) {
+            // Enable the stream with specified profile;
+            config->enableVideoStream(sensorType, OB_WIDTH_ANY, OB_HEIGHT_ANY, 30, OB_FORMAT_ANY);
+        }
+    }
+
+    pipe.start(config);
+
+    // Create a window for rendering and set the resolution of the window
+    ob_smpl::CVWindow win("Infrared", 1280, 720, ob_smpl::ARRANGE_ONE_ROW);
+    while(win.run()) {
+        // Wait for up to 100ms for a frameset in blocking mode.
+        auto frameSet = pipe.waitForFrameset(100);
+        if(frameSet == nullptr) {
+            continue;
+        }
+
+        // Render a set of frame in the window.
+        win.pushFramesToView(frameSet);
+    }
+
+    // Stop the pipeline, no frame data will be generated
+    pipe.stop();
+
+    return 0;
+}
+catch(ob::Error &e) {
+    std::cerr << "function:" << e.getFunction() << "\nargs:" << e.getArgs() << "\nmessage:" << e.what() << "\ntype:" << e.getExceptionType() << std::endl;
+    std::cout << "\nPress any key to exit.";
+    ob_smpl::waitForKeyPressed();
+    exit(EXIT_FAILURE);
+}
+
diff --git a/examples/1.stream.multi_streams/CMakeLists.txt b/examples/1.stream.multi_streams/CMakeLists.txt
new file mode 100644
index 00000000..1418e81c
--- /dev/null
+++ b/examples/1.stream.multi_streams/CMakeLists.txt
@@ -0,0 +1,14 @@
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+cmake_minimum_required(VERSION 3.5)
+project(ob_multi_streams)
+
+add_executable(ob_multi_streams multi_streams.cpp)
+
+set_property(TARGET ob_multi_streams PROPERTY CXX_STANDARD 11)
+target_link_libraries(ob_multi_streams ob::OrbbecSDK ob::examples::utils)
+set_target_properties(ob_multi_streams PROPERTIES FOLDER "examples")
+
+install(TARGETS ob_multi_streams RUNTIME DESTINATION bin)
+
diff --git a/examples/1.stream.multi_streams/README.md b/examples/1.stream.multi_streams/README.md
new file mode 100644
index 00000000..0024ece4
--- /dev/null
+++ b/examples/1.stream.multi_streams/README.md
@@ -0,0 +1,74 @@
+# C++ Sample: 1.stream.multi_streams
+
+## Overview
+
+Use SDK to obtain multiple camera data streams and output them
+
+### Knowledge
+
+Pipeline is a pipeline for processing data streams, providing multi-channel stream configuration, switching, frame aggregation, and frame synchronization functions.
+
+Device is a class that can be used to get device information, parameters, and a list of contained sensors.
+
+Sensor can be used to obtain different components of the camera and the stream of the component, for example, RGB, IR, Depth stream can be obtained through the RGB, IR, Depth sensor.
+
+Frameset is a combination of different types of Frames.
+
+## code overview
+
+1. Configure the output video stream in addition to imu data, such as depth, color, etc.
+
+    ```cpp
+        // Get sensor list from device.
+        auto sensorList = device->getSensorList();
+
+        for(uint32_t i = 0; i < sensorList->getCount(); i++) {
+            // Get sensor type.
+            auto sensorType = sensorList->getSensorType(i);
+
+            // exclude gyro and accel sensors.
+            if(sensorType == OB_SENSOR_GYRO || sensorType == OB_SENSOR_ACCEL) {
+                continue;
+            }
+
+            // enable the stream.
+            config->enableStream(sensorType);
+        }
+
+        // Start the pipeline with config
+        std::mutex                          frameMutex;
+        std::shared_ptr<const ob::FrameSet> renderFrameSet;
+        pipe.start(config, [&](std::shared_ptr<ob::FrameSet> frameSet) {
+            std::lock_guard<std::mutex> lock(frameMutex);
+            renderFrameSet = frameSet;
+        });
+    ```
+
+2. Instantiate the pipeline, configure IMU related information and start streaming
+
+    ```cpp
+        // The IMU frame rate is much faster than the video, so it is advisable to use a separate pipeline to obtain IMU data.
+        auto                                dev         = pipe.getDevice();
+        auto                                imuPipeline = std::make_shared<ob::Pipeline>(dev);
+        std::mutex                          imuFrameMutex;
+        std::shared_ptr<const ob::FrameSet> renderImuFrameSet;
+
+        std::shared_ptr<ob::Config> imuConfig = std::make_shared<ob::Config>();
+        // enable gyro stream.
+        imuConfig->enableGyroStream();
+        // enable accel stream.
+        imuConfig->enableAccelStream();
+        // start the imu pipeline.
+        imuPipeline->start(imuConfig, [&](std::shared_ptr<ob::FrameSet> frameSet) {
+            std::lock_guard<std::mutex> lockImu(imuFrameMutex);
+            renderImuFrameSet = frameSet;
+        });
+    ```
+
+## Run Sample
+
+Press the Esc key in the window to exit the program.
+
+### Result
+
+![image](../../docs/resource/multistream.jpg)
diff --git a/examples/1.stream.multi_streams/multi_streams.cpp b/examples/1.stream.multi_streams/multi_streams.cpp
new file mode 100644
index 00000000..4ef20a1a
--- /dev/null
+++ b/examples/1.stream.multi_streams/multi_streams.cpp
@@ -0,0 +1,91 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include <libobsensor/ObSensor.h>
+
+#include "utils.hpp"
+#include "utils_opencv.hpp"
+
+#include <mutex>
+#include <thread>
+
+int main(void) try {
+
+    // Create a pipeline with default device.
+    ob::Pipeline pipe;
+
+    // Configure which streams to enable or disable for the Pipeline by creating a Config.
+    std::shared_ptr<ob::Config> config = std::make_shared<ob::Config>();
+
+    // Enumerate and config all sensors.
+    auto device = pipe.getDevice();
+
+    // Get sensor list from device.
+    auto sensorList = device->getSensorList();
+
+    for(uint32_t i = 0; i < sensorList->getCount(); i++) {
+        // Get sensor type.
+        auto sensorType = sensorList->getSensorType(i);
+
+        // exclude gyro and accel sensors.
+        if(sensorType == OB_SENSOR_GYRO || sensorType == OB_SENSOR_ACCEL) {
+            continue;
+        }
+
+        // enable the stream.
+        config->enableStream(sensorType);
+    }
+
+    // Start the pipeline with config
+    std::mutex                          frameMutex;
+    std::shared_ptr<const ob::FrameSet> renderFrameSet;
+    pipe.start(config, [&](std::shared_ptr<ob::FrameSet> frameSet) {
+        std::lock_guard<std::mutex> lock(frameMutex);
+        renderFrameSet = frameSet;
+    });
+
+    // The IMU frame rate is much faster than the video, so it is advisable to use a separate pipeline to obtain IMU data.
+    auto                                dev         = pipe.getDevice();
+    auto                                imuPipeline = std::make_shared<ob::Pipeline>(dev);
+    std::mutex                          imuFrameMutex;
+    std::shared_ptr<const ob::FrameSet> renderImuFrameSet;
+
+    std::shared_ptr<ob::Config> imuConfig = std::make_shared<ob::Config>();
+    // enable gyro stream.
+    imuConfig->enableGyroStream();
+    // enable accel stream.
+    imuConfig->enableAccelStream();
+    // start the imu pipeline.
+    imuPipeline->start(imuConfig, [&](std::shared_ptr<ob::FrameSet> frameSet) {
+        std::lock_guard<std::mutex> lockImu(imuFrameMutex);
+        renderImuFrameSet = frameSet;
+    });
+
+    // Create a window for rendering and set the resolution of the window
+    ob_smpl::CVWindow win("MultiStream", 1280, 720, ob_smpl::ARRANGE_GRID);
+    while(win.run()) {
+        std::lock_guard<std::mutex> lockImu(imuFrameMutex);
+        std::lock_guard<std::mutex> lock(frameMutex);
+
+        if(renderFrameSet == nullptr || renderImuFrameSet == nullptr) {
+            continue;
+        }
+        // Render camera and imu frameset.
+        win.pushFramesToView({ renderFrameSet, renderImuFrameSet });
+    }
+
+    // Stop the Pipeline, no frame data will be generated.
+    pipe.stop();
+
+    // Stop the IMU Pipeline, no frame data will be generated.
+    imuPipeline->stop();
+
+    return 0;
+}
+catch(ob::Error &e) {
+    std::cerr << "function:" << e.getFunction() << "\nargs:" << e.getArgs() << "\nmessage:" << e.what() << "\ntype:" << e.getExceptionType() << std::endl;
+    std::cout << "\nPress any key to exit.";
+    ob_smpl::waitForKeyPressed();
+    exit(EXIT_FAILURE);
+}
+
diff --git a/examples/2.device.control/CMakeLists.txt b/examples/2.device.control/CMakeLists.txt
new file mode 100644
index 00000000..9720bd1d
--- /dev/null
+++ b/examples/2.device.control/CMakeLists.txt
@@ -0,0 +1,15 @@
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+cmake_minimum_required(VERSION 3.5)
+project(ob_device_control)
+
+add_executable(${PROJECT_NAME} device_control.cpp)
+
+set_property(TARGET ${PROJECT_NAME} PROPERTY CXX_STANDARD 11)
+target_link_libraries(${PROJECT_NAME} ob::OrbbecSDK ob::examples::utils )
+
+set_target_properties (${PROJECT_NAME} PROPERTIES FOLDER "examples")
+
+install(TARGETS ob_device_control RUNTIME DESTINATION bin)
+
diff --git a/examples/2.device.control/README.md b/examples/2.device.control/README.md
new file mode 100644
index 00000000..d457ba66
--- /dev/null
+++ b/examples/2.device.control/README.md
@@ -0,0 +1,176 @@
+# C++ Sample：2.device.control
+
+## Overview
+
+The SDK can be used to modify camera-related parameters, including laser switch, laser level intensity, white balance switch, etc.
+
+### Knowledge
+
+Pipeline is a pipeline for processing data streams, providing multi-channel stream configuration, switching, frame aggregation, and frame synchronization functions.
+
+Device is a class that can be used to get device information, parameters, and a list of contained sensors.
+
+Sensor can be used to obtain different components of the camera and the stream of the component, for example, RGB, IR, Depth stream can be obtained through the RGB, IR, Depth sensor.
+
+## code overview
+
+1. Get camera related information and output
+
+    ```cpp
+        // select a device to operate
+        std::shared_ptr<ob::Device> device = nullptr;
+        if(deviceList->getCount() > 0) {
+            if(deviceList->getCount() <= 1) {
+                // If a single device is plugged in, the first one is selected by default
+                device = deviceList->getDevice(0);
+            }
+            else {
+                device = selectDevice(deviceList);
+            }
+            auto deviceInfo = device->getDeviceInfo();
+            std::cout << "\n------------------------------------------------------------------------\n";
+            std::cout << "Current Device: "
+                    << " name: " << deviceInfo->getName() << ", vid: 0x" << std::hex << deviceInfo->getVid() << ", pid: 0x" << std::setw(4)
+                    << std::setfill('0') << deviceInfo->getPid() << ", uid: 0x" << deviceInfo->getUid() << std::dec << std::endl;
+        }
+        else {
+            std::cout << "Device Not Found" << std::endl;
+            isSelectDevice = false;
+            break;
+        }
+    ```
+
+2. Get the relevant parameters stored in the container and reorder them by id
+
+    ```cpp
+        // Get property list
+        std::vector<OBPropertyItem> getPropertyList(std::shared_ptr<ob::Device> device) {
+        std::vector<OBPropertyItem> propertyVec;
+        propertyVec.clear();
+        uint32_t size = device->getSupportedPropertyCount();
+        for(uint32_t i = 0; i < size; i++) {
+            OBPropertyItem property_item = device->getSupportedProperty(i);
+            if(isPrimaryTypeProperty(property_item) && property_item.permission != OB_PERMISSION_DENY) {
+                propertyVec.push_back(property_item);
+            }
+        }
+        return propertyVec;
+        }
+    ```
+
+    ```cpp
+        std::vector<OBPropertyItem> propertyList = getPropertyList(device);
+        std::sort(propertyList.begin(), propertyList.end(), [](const OBPropertyItem &a, const OBPropertyItem &b) { return a.id < b.id; });
+    ```
+
+3. Use the get command to obtain camera-related property values
+
+    ```cpp
+       // get property value
+        void getPropertyValue(std::shared_ptr<ob::Device> device, OBPropertyItem propertyItem) {
+            try {
+                bool  bool_ret  = false;
+                int   int_ret   = 0;
+                float float_ret = 0.0f;
+
+                switch(propertyItem.type) {
+                case OB_BOOL_PROPERTY:
+                    try {
+                        bool_ret = device->getBoolProperty(propertyItem.id);
+                    }
+                    catch(...) {
+                        std::cout << "get bool property failed." << std::endl;
+                    }
+                    std::cout << "property name:" << propertyItem.name << ",get bool value:" << bool_ret << std::endl;
+                    break;
+                case OB_INT_PROPERTY:
+                    try {
+                        int_ret = device->getIntProperty(propertyItem.id);
+                    }
+                    catch(...) {
+                        std::cout << "get int property failed." << std::endl;
+                    }
+                    std::cout << "property name:" << propertyItem.name << ",get int value:" << int_ret << std::endl;
+                    break;
+                case OB_FLOAT_PROPERTY:
+                    try {
+                        float_ret = device->getFloatProperty(propertyItem.id);
+                    }
+                    catch(...) {
+                        std::cout << "get float property failed." << std::endl;
+                    }
+                    std::cout << "property name:" << propertyItem.name << ",get float value:" << float_ret << std::endl;
+                    break;
+                default:
+                    break;
+                }
+            }
+            catch(...) {
+                std::cout << "get property failed: " << propertyItem.name << std::endl;
+            }
+        }
+    ```
+
+4. Use the set command to set camera-related property values
+
+    ```cpp
+        // set properties
+        void setPropertyValue(std::shared_ptr<ob::Device> device, OBPropertyItem propertyItem, std::string strValue) {
+            try {
+                int   int_value   = 0;
+                float float_value = 0.0f;
+                int   bool_value  = 0;
+                switch(propertyItem.type) {
+                case OB_BOOL_PROPERTY:
+                    bool_value = std::atoi(strValue.c_str());
+                    try {
+                        device->setBoolProperty(propertyItem.id, bool_value);
+                    }
+                    catch(...) {
+                        std::cout << "set bool property fail." << std::endl;
+                    }
+                    std::cout << "property name:" << propertyItem.name << ",set bool value:" << bool_value << std::endl;
+                    break;
+                case OB_INT_PROPERTY:
+                    int_value = std::atoi(strValue.c_str());
+                    try {
+                        device->setIntProperty(propertyItem.id, int_value);
+                    }
+                    catch(...) {
+                        std::cout << "set int property fail." << std::endl;
+                    }
+                    std::cout << "property name:" << propertyItem.name << ",set int value:" << int_value << std::endl;
+                    break;
+                case OB_FLOAT_PROPERTY:
+                    float_value = static_cast<float>(std::atof(strValue.c_str())) ;
+                    try {
+                        device->setFloatProperty(propertyItem.id, float_value);
+                    }
+                    catch(...) {
+                        std::cout << "set float property fail." << std::endl;
+                    }
+                    std::cout << "property name:" << propertyItem.name << ",set float value:" << float_value << std::endl;
+                    break;
+                default:
+                    break;
+                }
+            }
+            catch(...) {
+                std::cout << "set property failed: " << propertyItem.name << std::endl;
+            }
+        }
+    ```
+
+## Run Sample
+
+Select the camera you want to operate. If it is a single device, skip the selection.
+You can enter the command ? to get all the properties of the camera, including setting the maximum and minimum values, etc.
+You can enter set to set command to setto set parameters, for example 6 set 0 (note the space)
+You can enter the get command to set parameters, for example, 6 get (note the space)
+Press the Esc key in the window to exit the program.
+
+### Result
+
+![image](../../docs/resource/control1.jpg)
+
+![image](../../docs/resource/control2.jpg)
diff --git a/examples/2.device.control/device_control.cpp b/examples/2.device.control/device_control.cpp
new file mode 100644
index 00000000..78fc8f5f
--- /dev/null
+++ b/examples/2.device.control/device_control.cpp
@@ -0,0 +1,320 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include <libobsensor/ObSensor.hpp>
+
+#include "utils.hpp"
+
+#include <thread>
+#include <string>
+#include <vector>
+#include <cstring>
+#include <iomanip>
+#include <sstream>
+#include <iostream>
+#include <algorithm>
+
+std::shared_ptr<ob::Device> selectDevice(std::shared_ptr<ob::DeviceList> deviceList);
+std::vector<OBPropertyItem> getPropertyList(std::shared_ptr<ob::Device> device);
+bool                        isPrimaryTypeProperty(OBPropertyItem propertyItem);
+void                        printfPropertyList(std::shared_ptr<ob::Device> device, const std::vector<OBPropertyItem> &propertyList);
+void                        setPropertyValue(std::shared_ptr<ob::Device> device, OBPropertyItem item, std::string strValue);
+void                        getPropertyValue(std::shared_ptr<ob::Device> device, OBPropertyItem item);
+std::string                 permissionTypeToString(OBPermissionType permission);
+
+int main(void) try {
+    // Create a Context.
+    ob::Context context;
+
+    // Query the list of connected devices
+    auto deviceList = context.queryDeviceList();
+
+    bool isSelectDevice = true;
+    while(isSelectDevice) {
+        // select a device to operate
+        std::shared_ptr<ob::Device> device = nullptr;
+        if(deviceList->getCount() > 0) {
+            if(deviceList->getCount() <= 1) {
+                // If a single device is plugged in, the first one is selected by default
+                device = deviceList->getDevice(0);
+            }
+            else {
+                device = selectDevice(deviceList);
+            }
+            auto deviceInfo = device->getDeviceInfo();
+            std::cout << "\n------------------------------------------------------------------------\n";
+            std::cout << "Current Device: "
+                      << " name: " << deviceInfo->getName() << ", vid: 0x" << std::hex << deviceInfo->getVid() << ", pid: 0x" << std::setw(4)
+                      << std::setfill('0') << deviceInfo->getPid() << ", uid: 0x" << deviceInfo->getUid() << std::dec << std::endl;
+        }
+        else {
+            std::cout << "Device Not Found" << std::endl;
+            isSelectDevice = false;
+            break;
+        }
+
+        std::cout << "Input \"?\" to get all properties." << std::endl;
+
+        std::vector<OBPropertyItem> propertyList = getPropertyList(device);
+        std::sort(propertyList.begin(), propertyList.end(), [](const OBPropertyItem &a, const OBPropertyItem &b) { return a.id < b.id; });
+
+        bool isSelectProperty = true;
+        while(isSelectProperty) {
+            std::string choice;
+            std::getline(std::cin, choice);
+
+            if(choice != "?") {
+                std::istringstream       ss(choice);
+                std::string              tmp;
+                std::vector<std::string> controlVec;
+                while(ss >> tmp) {
+                    controlVec.push_back(tmp);
+                }
+
+                if(controlVec.size() <= 0)
+                    continue;
+
+                // exit the program
+                if(controlVec.at(0) == "exit") {
+                    isSelectProperty = false;
+                    isSelectDevice   = false;
+                    break;
+                }
+
+                // Check if it matches the input format
+                if(controlVec.size() <= 1 || (controlVec.at(1) != "get" && controlVec.at(1) != "set") || controlVec.size() > 3
+                   || (controlVec.at(1) == "set" && controlVec.size() < 3)) {
+                    std::cout << "Property control usage: [property index] [set] [property value] or [property index] [get]" << std::endl;
+                    continue;
+                }
+                size_t size     = propertyList.size();
+                size_t selectId = std::atoi(controlVec.at(0).c_str());
+                if(selectId >= size) {
+                    std::cout << "Your selection is out of range, please reselect: " << std::endl;
+                    continue;
+                }
+
+                bool isGetValue   = controlVec.at(1) == "get" ? true : false;
+                auto propertyItem = propertyList.at(selectId);
+
+                if(isGetValue) {
+                    // get property value
+                    getPropertyValue(device, propertyItem);
+                }
+                else {
+                    // set property value
+                    setPropertyValue(device, propertyItem, controlVec.at(2));
+                }
+            }
+            else {
+                printfPropertyList(device, propertyList);
+                std::cout << "Please select property.(Property control usage: [property number] [set/get] [property value])" << std::endl;
+            }
+        }
+    }
+
+    return 0;
+}
+catch(ob::Error &e) {
+    std::cerr << "function:" << e.getFunction() << "\nargs:" << e.getArgs() << "\nmessage:" << e.what() << "\ntype:" << e.getExceptionType() << std::endl;
+    std::cout << "\nPress any key to exit.";
+    ob_smpl::waitForKeyPressed();
+    exit(EXIT_FAILURE);
+}
+
+// Select a device, the name, pid, vid, uid of the device will be printed here, and the corresponding device object will be created after selection
+std::shared_ptr<ob::Device> selectDevice(std::shared_ptr<ob::DeviceList> deviceList) {
+    int devCount = deviceList->getCount();
+    std::cout << "Device list: " << std::endl;
+    for(int i = 0; i < devCount; i++) {
+        std::cout << i << ". name: " << deviceList->getName(i) << ", vid: 0x" << std::hex << deviceList->getVid(i) << ", pid: 0x" << std::setw(4)
+                  << std::setfill('0') << deviceList->getPid(i) << ", uid: 0x" << deviceList->getUid(i) << ", sn: " << deviceList->getSerialNumber(i)
+                  << std::dec << std::endl;
+    }
+    std::cout << "Select a device: ";
+
+    int devIndex;
+    std::cin >> devIndex;
+    while(devIndex < 0 || devIndex >= devCount || std::cin.fail()) {
+        std::cin.clear();
+        std::cin.ignore();
+        std::cout << "Your select is out of range, please reselect: " << std::endl;
+        std::cin >> devIndex;
+    }
+
+    return deviceList->getDevice(devIndex);
+}
+
+// Print a list of supported properties
+void printfPropertyList(std::shared_ptr<ob::Device> device, const std::vector<OBPropertyItem> &propertyList) {
+    std::cout << "size: " << propertyList.size() << std::endl;
+    if(propertyList.empty()) {
+        std::cout << "No supported property!" << std::endl;
+    }
+    std::cout << "\n------------------------------------------------------------------------\n";
+    for(size_t i = 0; i < propertyList.size(); i++) {
+        auto        property_item = propertyList[i];
+        std::string strRange      = "";
+
+        OBIntPropertyRange   int_range;
+        OBFloatPropertyRange float_range;
+        switch(property_item.type) {
+        case OB_BOOL_PROPERTY:
+            strRange = "Bool value(min:0, max:1, step:1)";
+            break;
+        case OB_INT_PROPERTY: {
+            try {
+                int_range = device->getIntPropertyRange(property_item.id);
+                strRange  = "Int value(min:" + std::to_string(int_range.min) + ", max:" + std::to_string(int_range.max)
+                           + ", step:" + std::to_string(int_range.step) + ")";
+            }
+            catch(...) {
+                std::cout << "get int property range failed." << std::endl;
+            }
+        } break;
+        case OB_FLOAT_PROPERTY:
+            try {
+                float_range = device->getFloatPropertyRange(property_item.id);
+                strRange    = "Float value(min:" + std::to_string(float_range.min) + ", max:" + std::to_string(float_range.max)
+                           + ", step:" + std::to_string(float_range.step) + ")";
+            }
+            catch(...) {
+                std::cout << "get float property range failed." << std::endl;
+            }
+            break;
+        default:
+            break;
+        }
+
+        std::cout.setf(std::ios::right);
+        std::cout.fill('0');
+        std::cout.width(2);
+        std::cout << i << ". ";
+        std::cout << property_item.name << "(" << (int)property_item.id << ")";
+        std::cout << ", permission=" << permissionTypeToString(property_item.permission) << ", range=" << strRange << std::endl;
+    }
+    std::cout << "------------------------------------------------------------------------\n";
+}
+
+bool isPrimaryTypeProperty(OBPropertyItem propertyItem) {
+    return propertyItem.type == OB_INT_PROPERTY || propertyItem.type == OB_FLOAT_PROPERTY || propertyItem.type == OB_BOOL_PROPERTY;
+}
+
+// Get property list
+std::vector<OBPropertyItem> getPropertyList(std::shared_ptr<ob::Device> device) {
+    std::vector<OBPropertyItem> propertyVec;
+    propertyVec.clear();
+    uint32_t size = device->getSupportedPropertyCount();
+    for(uint32_t i = 0; i < size; i++) {
+        OBPropertyItem property_item = device->getSupportedProperty(i);
+        if(isPrimaryTypeProperty(property_item) && property_item.permission != OB_PERMISSION_DENY) {
+            propertyVec.push_back(property_item);
+        }
+    }
+    return propertyVec;
+}
+
+// set properties
+void setPropertyValue(std::shared_ptr<ob::Device> device, OBPropertyItem propertyItem, std::string strValue) {
+    try {
+        int   int_value   = 0;
+        float float_value = 0.0f;
+        int   bool_value  = 0;
+        switch(propertyItem.type) {
+        case OB_BOOL_PROPERTY:
+            bool_value = std::atoi(strValue.c_str());
+            try {
+                device->setBoolProperty(propertyItem.id, bool_value);
+            }
+            catch(ob::Error &e) {
+                std::cout << "set bool property fail: " << e.what() << std::endl;
+            }
+            std::cout << "property name:" << propertyItem.name << ",set bool value:" << bool_value << std::endl;
+            break;
+        case OB_INT_PROPERTY:
+            int_value = std::atoi(strValue.c_str());
+            try {
+                device->setIntProperty(propertyItem.id, int_value);
+            }
+            catch(ob::Error &e) {
+                std::cout << "set int property fail: " << e.what() << std::endl;
+            }
+            std::cout << "property name:" << propertyItem.name << ",set int value:" << int_value << std::endl;
+            break;
+        case OB_FLOAT_PROPERTY:
+            float_value = static_cast<float>(std::atof(strValue.c_str()));
+            try {
+                device->setFloatProperty(propertyItem.id, float_value);
+            }
+            catch(ob::Error &e) {
+                std::cout << "set floar property fail: " << e.what() << std::endl;
+            }
+            std::cout << "property name:" << propertyItem.name << ",set float value:" << float_value << std::endl;
+            break;
+        default:
+            break;
+        }
+    }
+    catch(...) {
+        std::cout << "set property failed: " << propertyItem.name << std::endl;
+    }
+}
+
+// get property value
+void getPropertyValue(std::shared_ptr<ob::Device> device, OBPropertyItem propertyItem) {
+    try {
+        bool  bool_ret  = false;
+        int   int_ret   = 0;
+        float float_ret = 0.0f;
+
+        switch(propertyItem.type) {
+        case OB_BOOL_PROPERTY:
+            try {
+                bool_ret = device->getBoolProperty(propertyItem.id);
+            }
+            catch(ob::Error &e) {
+                std::cout << "get bool property failed: " << e.what() << std::endl;
+            }
+            std::cout << "property name:" << propertyItem.name << ",get bool value:" << bool_ret << std::endl;
+            break;
+        case OB_INT_PROPERTY:
+            try {
+                int_ret = device->getIntProperty(propertyItem.id);
+            }
+            catch(ob::Error &e) {
+                std::cout << "get int property failed: " << e.what() << std::endl;
+            }
+            std::cout << "property name:" << propertyItem.name << ",get int value:" << int_ret << std::endl;
+            break;
+        case OB_FLOAT_PROPERTY:
+            try {
+                float_ret = device->getFloatProperty(propertyItem.id);
+            }
+            catch(ob::Error &e) {
+                std::cout << "get float property failed: " << e.what() << std::endl;
+            }
+            std::cout << "property name:" << propertyItem.name << ",get float value:" << float_ret << std::endl;
+            break;
+        default:
+            break;
+        }
+    }
+    catch(...) {
+        std::cout << "get property failed: " << propertyItem.name << std::endl;
+    }
+}
+
+std::string permissionTypeToString(OBPermissionType permission) {
+    switch(permission) {
+    case OB_PERMISSION_READ:
+        return "R/_";
+    case OB_PERMISSION_WRITE:
+        return "_/W";
+    case OB_PERMISSION_READ_WRITE:
+        return "R/W";
+
+    default:
+        break;
+    }
+    return "_/_";
+}
diff --git a/examples/2.device.hot_plugin/CMakeLists.txt b/examples/2.device.hot_plugin/CMakeLists.txt
new file mode 100644
index 00000000..29bd8496
--- /dev/null
+++ b/examples/2.device.hot_plugin/CMakeLists.txt
@@ -0,0 +1,14 @@
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+cmake_minimum_required(VERSION 3.5)
+project(ob_hot_plugin)
+
+add_executable(${PROJECT_NAME} hot_plugin.cpp)
+
+set_property(TARGET ${PROJECT_NAME} PROPERTY CXX_STANDARD 11)
+target_link_libraries(${PROJECT_NAME} ob::OrbbecSDK ob::examples::utils)
+set_target_properties (${PROJECT_NAME} PROPERTIES FOLDER "examples")
+
+install(TARGETS ob_hot_plugin RUNTIME DESTINATION bin)
+
diff --git a/examples/2.device.hot_plugin/README.md b/examples/2.device.hot_plugin/README.md
new file mode 100644
index 00000000..c5546a43
--- /dev/null
+++ b/examples/2.device.hot_plugin/README.md
@@ -0,0 +1,74 @@
+# C++ Sample：2.device.hot_plugin
+
+## Overview
+
+Use SDK to handle the settings of device unplug callback and process the acquired code stream after unplugging
+
+### Knowledge
+
+Pipeline is a pipeline for processing data streams, providing multi-channel stream configuration, switching, frame aggregation, and frame synchronization functions.
+
+Device is a class that can be used to get device information, parameters, and a list of contained sensors.
+
+Sensor can be used to obtain different components of the camera and the stream of the component, for example, RGB, IR, Depth stream can be obtained through the RGB, IR, Depth sensor.
+
+### Attention
+
+*The GMSL devices (such as Gemini335Lg) do not support hot plugging.*
+
+## code overview
+
+1. Register device callback and execute relevant functions during device unplugging and unplugging
+
+    ```cpp
+        ctx.setDeviceChangedCallback( []( std::shared_ptr< ob::DeviceList > removedList, std::shared_ptr< ob::DeviceList > addedList ) {
+                DeviceDisconnectCallback( removedList );
+                DeviceConnectCallback( addedList );
+            } );
+    ```
+
+2. Trigger the callback function to print relevant information
+
+    ```cpp
+        void printDeviceList(const std::string &prompt, std::shared_ptr<ob::DeviceList> deviceList) {
+            auto count = deviceList->getCount();
+            if(count == 0) {
+                return;
+            }
+            std::cout << count << " device(s) " << prompt << ": " << std::endl;
+            for(uint32_t i = 0; i < count; i++) {
+                auto uid          = deviceList->getUid(i);
+                auto vid          = deviceList->getVid(i);
+                auto pid          = deviceList->getPid(i);
+                auto serialNumber = deviceList->getSerialNumber(i);
+                auto connection   = deviceList->getConnectionType(i);
+                std::cout << " - uid: " << uid << ", vid: 0x" << std::hex << std::setfill('0') << std::setw(4) << vid << ", pid: 0x" << pid
+                            << ", serial number: " << serialNumber << ", connection: " << connection << std::endl;
+            }
+            std::cout << std::endl;
+        }
+    ```
+
+3. Restart your device
+
+```cpp
+    void rebootDevices(std::shared_ptr<ob::DeviceList> deviceList) {
+        for(uint32_t i = 0; i < deviceList->getCount(); i++) {
+            // get device from device list
+            auto device = deviceList->getDevice(i);
+
+            // reboot device
+            device->reboot();
+        }
+    }
+```
+
+## Run Sample
+
+Press R to reboot the device
+You can try to manually unplug and plug the device
+Press the Esc key in the window to exit the program
+
+### Result
+
+![image](../../docs/resource/hotplugin.jpg)
diff --git a/examples/2.device.hot_plugin/hot_plugin.cpp b/examples/2.device.hot_plugin/hot_plugin.cpp
new file mode 100644
index 00000000..a40a88c8
--- /dev/null
+++ b/examples/2.device.hot_plugin/hot_plugin.cpp
@@ -0,0 +1,80 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include <libobsensor/ObSensor.hpp>
+
+#include "utils.hpp"
+
+#include <iomanip>
+#include <iostream>
+
+void printDeviceList(const std::string &prompt, std::shared_ptr<ob::DeviceList> deviceList) {
+    auto count = deviceList->getCount();
+    if(count == 0) {
+        return;
+    }
+    std::cout << count << " device(s) " << prompt << ": " << std::endl;
+    for(uint32_t i = 0; i < count; i++) {
+        auto uid          = deviceList->getUid(i);
+        auto vid          = deviceList->getVid(i);
+        auto pid          = deviceList->getPid(i);
+        auto serialNumber = deviceList->getSerialNumber(i);
+        auto connection   = deviceList->getConnectionType(i);
+        std::cout << " - uid: " << uid << ", vid: 0x" << std::hex << std::setfill('0') << std::setw(4) << vid << ", pid: 0x" << pid
+                  << ", serial number: " << serialNumber << ", connection: " << connection << std::endl;
+    }
+    std::cout << std::endl;
+}
+
+void rebootDevices(std::shared_ptr<ob::DeviceList> deviceList) {
+    for(uint32_t i = 0; i < deviceList->getCount(); i++) {
+        // get device from device list
+        auto device = deviceList->getDevice(i);
+
+        // reboot device
+        device->reboot();
+    }
+}
+
+int main(void) try {
+    // create context
+    ob::Context ctx;
+
+    // register device callback
+    ctx.setDeviceChangedCallback([](std::shared_ptr<ob::DeviceList> removedList, std::shared_ptr<ob::DeviceList> deviceList) {
+        printDeviceList("added", deviceList);
+        printDeviceList("removed", removedList);
+    });
+
+    // query current device list
+    auto currentList = ctx.queryDeviceList();
+    printDeviceList("connected", currentList);
+
+    std::cout << "Press 'r' to reboot the connected devices to trigger the device disconnect and reconnect event, or manually unplug and plugin the device."
+              << std::endl;
+    std::cout << "Press 'Esc' to exit." << std::endl << std::endl;
+
+    // main loop, wait for key press
+    while(true) {
+        auto key = ob_smpl::waitForKeyPressed(100);
+        // Press the esc key to exit
+        if(key == 27) {
+            break;
+        }
+        else if(key == 'r' || key == 'R') {
+            // update device list
+            currentList = ctx.queryDeviceList();
+
+            std::cout << "Rebooting devices..." << std::endl;
+            rebootDevices(currentList);
+        }
+    }
+
+    return 0;
+}
+catch(ob::Error &e) {
+    std::cerr << "function:" << e.getFunction() << "\nargs:" << e.getArgs() << "\nmessage:" << e.what() << "\ntype:" << e.getExceptionType() << std::endl;
+    std::cout << "\nPress any key to exit.";
+    ob_smpl::waitForKeyPressed();
+    exit(EXIT_FAILURE);
+}
diff --git a/examples/3.advanced.common_usages/CMakeLists.txt b/examples/3.advanced.common_usages/CMakeLists.txt
new file mode 100644
index 00000000..2b2e642a
--- /dev/null
+++ b/examples/3.advanced.common_usages/CMakeLists.txt
@@ -0,0 +1,14 @@
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+cmake_minimum_required(VERSION 3.5)
+project(ob_common_usages)
+
+add_executable(${PROJECT_NAME} common_usages.cpp)
+
+set_property(TARGET ${PROJECT_NAME} PROPERTY CXX_STANDARD 11)
+target_link_libraries(${PROJECT_NAME} ob::OrbbecSDK ob::examples::utils)
+
+set_target_properties (${PROJECT_NAME} PROPERTIES FOLDER "examples")
+install(TARGETS ob_common_usages RUNTIME DESTINATION bin)
+
diff --git a/examples/3.advanced.common_usages/README.md b/examples/3.advanced.common_usages/README.md
new file mode 100644
index 00000000..69374abd
--- /dev/null
+++ b/examples/3.advanced.common_usages/README.md
@@ -0,0 +1,77 @@
+# C++ Sample：3.advanced.common_usages
+
+## Overview
+
+Use the SDK interface to view camera related information, set related parameters, and display the video stream
+
+### Knowledge
+
+Context is the environment context, the first object created during initialization, which can be used to perform some settings, including but not limited to device status change callbacks, log level settings, etc. Context can access multiple Devices.
+
+Device is the device object, which can be used to obtain the device information, such as the model, serial number, and various sensors.One actual hardware device corresponds to one Device object.
+
+## code overview
+
+1. Register device callback
+
+    ```cpp
+        // Create ob:Context.
+        ctx = std::make_shared<ob::Context>();
+        ctx.setDeviceChangedCallback( []( std::shared_ptr< ob::DeviceList > removedList, std::shared_ptr< ob::DeviceList > addedList ) {
+                DeviceDisconnectCallback( removedList );
+                DeviceConnectCallback( addedList );
+            } );
+    ```
+
+2. Get the device list and print out the information, then use pipeline to start the video stream.
+
+    ```cpp
+        // Query the list of connected devices.
+        std::shared_ptr<ob::DeviceList> devices = ctx->queryDeviceList();
+
+        // Handle connected devices（and open one device）
+        handleDeviceConnected(devices);
+    ```
+
+3. Block thread waiting for device connection
+
+    ```cpp
+        while(!device) {
+            std::this_thread::sleep_for(std::chrono::milliseconds(100));
+        }
+    ```
+
+4. Execute corresponding settings according to the commands entered by the user. The following is an introduction to some setting functions
+
+    ```cpp
+        //Get the basic parameters of the camera, including connection type, device model, etc.
+        void getDeviceInformation()
+        //Get camera sensor intrinsics, distortion and pixels
+        void getCameraParams()
+        //Laser switch function
+        void switchLaser()
+        //Laser safety protection and ranging function switch
+        void switchLDP()
+        //Get the laser safety protection and ranging function status
+        void getLDPStatus()
+        //Color auto-exposure switch
+        void switchColorAE()
+        //Color exposure value adjustment
+        void setColorExposureValue(bool increase)
+        //Color gain value adjustment
+        void setColorGainValue(bool increase)
+        //Depth auto-exposure switch
+        void setDepthExposureValue(bool increase)
+        //Depth exposure value adjustment
+        void setDepthGainValue(bool increase)
+    ‵‵‵
+
+## Run Sample
+
+Press the button according to the interface prompts
+
+### Result
+
+![image](../../docs/resource/common1.jpg)
+
+![image](../../docs/resource/common2.jpg)
diff --git a/examples/3.advanced.common_usages/common_usages.cpp b/examples/3.advanced.common_usages/common_usages.cpp
new file mode 100644
index 00000000..5b16b74d
--- /dev/null
+++ b/examples/3.advanced.common_usages/common_usages.cpp
@@ -0,0 +1,855 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include <libobsensor/ObSensor.hpp>
+
+#include "utils.hpp"
+#include "utils_opencv.hpp"
+
+#include <mutex>
+#include <string>
+
+const std::map<std::string, int> gemini_330_list = { { "gemini335", 0x0800 },  { "gemini335L", 0x0804 }, { "gemini336", 0x0803 },
+                                                     { "gemini336L", 0x0807 }, { "gemini330", 0x0801 },  { "gemini330L", 0x0805 } };
+
+bool isGemini330Series(int pid) {
+    bool find = false;
+    for(auto it = gemini_330_list.begin(); it != gemini_330_list.end(); ++it) {
+        if(it->second == pid) {
+            find = true;
+            break;
+        }
+    }
+    return find;
+}
+
+std::shared_ptr<ob_smpl::CVWindow> win;
+std::shared_ptr<ob::Context>       ctx;
+
+std::shared_ptr<ob::Device>   device;
+std::shared_ptr<ob::Pipeline> pipeline;
+std::recursive_mutex          deviceMutex;
+
+std::thread inputWatchThread;
+
+bool streamStarted = false;
+
+std::map<OBSensorType, std::shared_ptr<ob::VideoStreamProfile>> profilesMap;
+std::shared_ptr<ob::VideoStreamProfile>                         depthProfile = nullptr;
+std::shared_ptr<ob::VideoStreamProfile>                         irProfile    = nullptr;
+
+auto align = ob::FilterFactory::createFilter("Align");
+
+void handleDeviceConnected(std::shared_ptr<ob::DeviceList> connectList);
+void handleDeviceDisconnected(std::shared_ptr<ob::DeviceList> disconnectList);
+void switchDepthWorkMode();
+void turnOffHwD2d();
+void setDepthUnit();
+void setDepthSoftFilter();
+
+void printUsage();
+void commandProcess(std::string cmd);
+
+void handleFrameset(std::shared_ptr<ob::FrameSet> frameset);
+void startStream();
+
+void inputWatcher();
+
+int main(void) try {
+
+    // create window for render
+    win = std::make_shared<ob_smpl::CVWindow>("CommonUsages", 1280, 720, ob_smpl::ARRANGE_GRID);
+
+    // Set log severity. disable log, please set OB_LOG_SEVERITY_OFF.
+    ob::Context::setLoggerSeverity(OB_LOG_SEVERITY_ERROR);
+
+    // Create ob:Context.
+    ctx = std::make_shared<ob::Context>();
+
+    // Register device callback
+    ctx->setDeviceChangedCallback([](std::shared_ptr<ob::DeviceList> removedList, std::shared_ptr<ob::DeviceList> addedList) {
+        handleDeviceDisconnected(removedList);
+        handleDeviceConnected(addedList);
+    });
+
+    // Query the list of connected devices.
+    std::shared_ptr<ob::DeviceList> devices = ctx->queryDeviceList();
+
+    // Handle connected devices（and open one device）
+    handleDeviceConnected(devices);
+
+    if(!device) {
+        std::cout << "Waiting for connect device...";
+        while(!device) {
+            std::this_thread::sleep_for(std::chrono::milliseconds(100));
+        }
+    }
+
+    printUsage();
+
+    inputWatchThread = std::thread(inputWatcher);
+    inputWatchThread.detach();
+
+    while(win->run()) {
+        std::this_thread::sleep_for(std::chrono::milliseconds(1));
+    }
+
+    if(pipeline) {
+        pipeline->stop();
+    }
+    return 0;
+}
+
+catch(ob::Error &e) {
+    std::cerr << "function:" << e.getFunction() << "\nargs:" << e.getArgs() << "\nmessage:" << e.what() << "\ntype:" << e.getExceptionType() << std::endl;
+    std::cout << "\nPress any key to exit.";
+    ob_smpl::waitForKeyPressed();
+    exit(EXIT_FAILURE);
+}
+
+// Device connection callback
+void handleDeviceConnected(std::shared_ptr<ob::DeviceList> devices) {
+    // Get the number of connected devices
+    if(devices->getCount() == 0) {
+        return;
+    }
+
+    const auto deviceCount = devices->getCount();
+    for(uint32_t i = 0; i < deviceCount; i++) {
+        std::string deviceSN = devices->getSerialNumber(i);
+        std::cout << "Found device connected, SN: " << deviceSN << std::endl;
+    }
+
+    std::unique_lock<std::recursive_mutex> lk(deviceMutex);
+    if(!device) {
+        // open default device (device index=0)
+        device   = devices->getDevice(0);
+        pipeline = std::make_shared<ob::Pipeline>(device);
+        std::cout << "Open device success, SN: " << devices->getSerialNumber(0) << std::endl;
+
+        startStream();
+    }
+}
+
+// Device disconnect callback
+void handleDeviceDisconnected(std::shared_ptr<ob::DeviceList> disconnectList) {
+    std::string currentDevSn = "";
+    {
+        std::unique_lock<std::recursive_mutex> lk(deviceMutex);
+        if(device) {
+            std::shared_ptr<ob::DeviceInfo> devInfo = device->getDeviceInfo();
+            currentDevSn                            = devInfo->getSerialNumber();
+        }
+    }
+    const auto deviceCount = disconnectList->getCount();
+    for(uint32_t i = 0; i < deviceCount; i++) {
+        std::string deviceSN = disconnectList->getSerialNumber(i);
+        std::cout << "Device disconnected, SN: " << deviceSN << std::endl;
+        if(currentDevSn == deviceSN) {
+            device.reset();    // release device
+            pipeline.reset();  // release pipeline
+            std::cout << "Current device disconnected" << std::endl;
+        }
+    }
+}
+
+void switchDepthWorkMode() {
+    std::unique_lock<std::recursive_mutex> lk(deviceMutex);
+    // Check whether the camera depth working mode is supported
+    if(!device->isPropertySupported(OB_STRUCT_CURRENT_DEPTH_ALG_MODE, OB_PERMISSION_READ_WRITE)) {
+        return;
+    }
+
+    // Query the current camera depth mode
+    auto curDepthMode = device->getCurrentDepthWorkMode();
+    std::cout << "current depth work mode: " << curDepthMode.name << std::endl;
+
+    // Get the list of camera depth modes
+    auto depthModeList = device->getDepthWorkModeList();
+    std::cout << "depthModeList size: " << depthModeList->getCount() << std::endl;
+    for(uint32_t i = 0; i < depthModeList->getCount(); i++) {
+        std::cout << "depthModeList[" << i << "]: " << (*depthModeList)[i].name << std::endl;
+    }
+
+    // switch depth work mode to default (index=0) mode, user can switch to ohter mode like this.
+    device->switchDepthWorkMode((*depthModeList)[0].name);
+    std::cout << "switch depth work mode to:" << (*depthModeList)[0].name << std::endl;
+
+    // It is require to reopen the device and pipeline after switch depth work mode
+    auto deviceInfo = device->getDeviceInfo();
+    device.reset();
+    pipeline.reset();
+    auto deviceList = ctx->queryDeviceList();
+    device          = deviceList->getDeviceBySN(deviceInfo->getSerialNumber());  // using serial number to create device
+    pipeline        = std::make_shared<ob::Pipeline>(device);
+}
+
+void turnOffHwD2d() {
+    try {
+        // Some models dose not support this feature
+        if(device->isPropertySupported(OB_PROP_DISPARITY_TO_DEPTH_BOOL, OB_PERMISSION_WRITE)) {
+            device->setBoolProperty(OB_PROP_DISPARITY_TO_DEPTH_BOOL, false);
+            std::cout << "turn off hardware disparity to depth converter (Turn on Software D2D)" << std::endl;
+        }
+    }
+    catch(ob::Error &e) {
+        std::cerr << "function:" << e.getFunction() << "\nargs:" << e.getArgs() << "\nmessage:" << e.what() << "\ntype:" << e.getExceptionType() << std::endl;
+        exit(EXIT_FAILURE);
+    }
+}
+
+void setDepthUnit() {
+    try {
+        if(device->isPropertySupported(OB_PROP_DEPTH_PRECISION_LEVEL_INT, OB_PERMISSION_WRITE)) {
+            device->setIntProperty(OB_PROP_DEPTH_PRECISION_LEVEL_INT, OB_PRECISION_1MM);
+            std::cout << "set depth unit to 1mm" << std::endl;
+        }
+        else {
+            std::cerr << "Depth precision level switch is not supported." << std::endl;
+        }
+    }
+    catch(ob::Error &e) {
+        std::cerr << "function:" << e.getFunction() << "\nargs:" << e.getArgs() << "\nmessage:" << e.what() << "\ntype:" << e.getExceptionType() << std::endl;
+        exit(EXIT_FAILURE);
+    }
+}
+
+void setDepthSoftFilter() {
+    try {
+        if(device->isPropertySupported(OB_PROP_DEPTH_SOFT_FILTER_BOOL, OB_PERMISSION_WRITE)) {
+            device->setBoolProperty(OB_PROP_DEPTH_SOFT_FILTER_BOOL, true);
+            std::cout << "turn on depth soft filter" << std::endl;
+        }
+    }
+    catch(ob::Error &e) {
+        std::cerr << "function:" << e.getFunction() << "\nargs:" << e.getArgs() << "\nmessage:" << e.what() << "\ntype:" << e.getExceptionType() << std::endl;
+        exit(EXIT_FAILURE);
+    }
+}
+
+void startStream() {
+    std::unique_lock<std::recursive_mutex> lk(deviceMutex);
+
+    device          = pipeline->getDevice();
+    auto sensorList = device->getSensorList();
+
+    // Configure which streams to enable or disable for the Pipeline by creating a Config.
+    std::shared_ptr<ob::Config> config = std::make_shared<ob::Config>();
+
+    for(uint32_t index = 0; index < sensorList->getCount(); index++) {
+        // Query all supported infrared sensor type and enable the infrared stream.
+        // For dual infrared device, enable the left and right infrared streams.
+        // For single infrared device, enable the infrared stream.
+        OBSensorType sensorType = sensorList->getSensorType(index);
+        if(sensorType == OB_SENSOR_IR || sensorType == OB_SENSOR_IR_LEFT || sensorType == OB_SENSOR_IR_RIGHT || sensorType == OB_SENSOR_COLOR
+           || sensorType == OB_SENSOR_DEPTH) {
+            try {
+                auto sensor           = sensorList->getSensor(sensorType);
+                auto colorProfileList = sensor->getStreamProfileList();
+                if(colorProfileList->getCount() > 0) {
+                    // get default (index=0) stream profile
+                    auto profile = colorProfileList->getProfile(OB_PROFILE_DEFAULT);
+
+                    auto colorProfile = profile->as<ob::VideoStreamProfile>();
+                    profilesMap.insert(std::make_pair(sensorType, colorProfile));
+                    std::cout << "color profile: " << colorProfile->getWidth() << "x" << colorProfile->getHeight() << " @ " << colorProfile->getFps() << "fps"
+                              << std::endl;
+
+                    // enable color stream.
+                    config->enableStream(colorProfile);
+                }
+            }
+            catch(ob::Error &e) {
+                std::cerr << "function:" << e.getFunction() << "\nargs:" << e.getArgs() << "\nmessage:" << e.what() << "\ntype:" << e.getExceptionType()
+                          << std::endl;
+                exit(EXIT_FAILURE);
+            }
+        }
+    }
+
+    // start pipeline
+    pipeline->start(config, handleFrameset);
+    streamStarted = true;
+    std::cout << "Stream started!" << std::endl;
+}
+std::shared_ptr<ob::FrameSet> fileterAlign(std::shared_ptr<ob::FrameSet> frameset) {
+    auto newFrame    = align->process(frameset);
+    auto newFrameSet = newFrame->as<ob::FrameSet>();
+    return newFrameSet;
+}
+void handleFrameset(std::shared_ptr<ob::FrameSet> frameset) {
+    auto alignFrameSet = fileterAlign(frameset);
+    //If no depthframe is present, it is discarded
+    if(frameset->getCount() < 3) {
+        return;
+    }
+    win->pushFramesToView(alignFrameSet);
+}
+
+void getDeviceInformation() {
+    std::unique_lock<std::recursive_mutex> lk(deviceMutex);
+    if(device) {
+        auto info = device->getDeviceInfo();
+        // Get the name of the device
+        std::cout << "-Device name: " << info->getName() << std::endl;
+        // Get the pid, vid, uid of the device
+        std::cout << "-Device pid: " << info->getPid() << " vid: " << info->getVid() << " uid: " << info->getUid() << std::endl;
+        // By getting the firmware version number of the device
+        auto fwVer = info->getFirmwareVersion();
+        std::cout << "-Firmware version: " << fwVer << std::endl;
+        // By getting the serial number of the device
+        auto sn = info->getSerialNumber();
+        std::cout << "-Serial number: " << sn << std::endl;
+        // By getting the connection type of the device
+        auto connectType = info->getConnectionType();
+        std::cout << "-ConnectionType: " << connectType << std::endl;
+    }
+}
+
+void getCameraParams() {
+    std::unique_lock<std::recursive_mutex> lk(deviceMutex);
+    if(pipeline) {
+        try {
+            for(const auto &item: profilesMap) {
+                auto profile    = item.second;
+                auto type       = item.first;
+                auto intrinsics = profile->getIntrinsic();
+                auto distortion = profile->getDistortion();
+                std::cout << type << " intrinsics - " << "fx:" << intrinsics.fx << ", fy: " << intrinsics.fy << ", cx: " << intrinsics.cx
+                          << ", cy: " << intrinsics.cy << " ,width: " << intrinsics.width << ", height: " << intrinsics.height << std::endl;
+
+                std::cout << "rgbDistortion k1:" << distortion.k1 << ", k2:" << distortion.k2 << ", k3:" << distortion.k3 << ", k4:" << distortion.k4
+                          << ", k5:" << distortion.k5 << ", k6:" << distortion.k6 << ", p1:" << distortion.p1 << ", p2:" << distortion.p2 << std::endl;
+            }
+        }
+        catch(ob::Error &e) {
+            std::cerr << "function:" << e.getFunction() << "\nargs:" << e.getArgs() << "\nmessage:" << e.what() << "\ntype:" << e.getExceptionType()
+                      << std::endl;
+            exit(EXIT_FAILURE);
+        }
+    }
+}
+
+void switchLaser() {
+    std::unique_lock<std::recursive_mutex> lk(deviceMutex);
+    if(device) {
+        try {
+            auto         pid        = device->getDeviceInfo()->getPid();
+            OBPropertyID propertyId = OB_PROP_LASER_BOOL;
+            if(isGemini330Series(pid)) {
+                propertyId = OB_PROP_LASER_CONTROL_INT;
+            }
+
+            if(device->isPropertySupported(propertyId, OB_PERMISSION_READ)) {
+                bool value = device->getBoolProperty(propertyId);
+                if(device->isPropertySupported(propertyId, OB_PERMISSION_WRITE)) {
+                    device->setBoolProperty(propertyId, !value);
+                    if(!value) {
+                        std::cout << "laser turn on!" << std::endl;
+                    }
+                    else {
+                        std::cout << "laser turn off!" << std::endl;
+                    }
+                }
+            }
+            else {
+                std::cerr << "Laser switch property is not supported." << std::endl;
+            }
+        }
+        catch(ob::Error &e) {
+            std::cerr << "function:" << e.getFunction() << "\nargs:" << e.getArgs() << "\nmessage:" << e.what() << "\ntype:" << e.getExceptionType()
+                      << std::endl;
+            exit(EXIT_FAILURE);
+        }
+    }
+}
+
+void switchLDP() {
+    std::unique_lock<std::recursive_mutex> lk(deviceMutex);
+    if(device) {
+        try {
+            if(device->isPropertySupported(OB_PROP_LDP_BOOL, OB_PERMISSION_READ)) {
+                bool value = device->getBoolProperty(OB_PROP_LDP_BOOL);
+                if(device->isPropertySupported(OB_PROP_LDP_BOOL, OB_PERMISSION_WRITE)) {
+                    device->setBoolProperty(OB_PROP_LDP_BOOL, !value);
+                    if(!value) {
+                        std::cout << "LDP turn on!" << std::endl;
+                    }
+                    else {
+                        std::cout << "LDP turn off!" << std::endl;
+                    }
+                    std::cout << "Attention: For some models, it is require to restart depth stream after turn on/of LDP. Input \"stream\" command "
+                                 "to restart stream!"
+                              << std::endl;
+                }
+            }
+            else {
+                std::cerr << "LDP switch property is not supported." << std::endl;
+            }
+        }
+        catch(ob::Error &e) {
+            std::cerr << "function:" << e.getFunction() << "\nargs:" << e.getArgs() << "\nmessage:" << e.what() << "\ntype:" << e.getExceptionType()
+                      << std::endl;
+            exit(EXIT_FAILURE);
+        }
+    }
+}
+
+void getLDPStatus() {
+    std::unique_lock<std::recursive_mutex> lk(deviceMutex);
+    if(device) {
+        try {
+            if(device->isPropertySupported(OB_PROP_LDP_STATUS_BOOL, OB_PERMISSION_READ)) {
+                bool value = device->getBoolProperty(OB_PROP_LDP_STATUS_BOOL);
+                std::cout << "LDP status:" << value << std::endl;
+            }
+            else {
+                std::cerr << "LDP status property is not supported." << std::endl;
+            }
+        }
+        catch(ob::Error &e) {
+            std::cerr << "function:" << e.getFunction() << "\nargs:" << e.getArgs() << "\nmessage:" << e.what() << "\ntype:" << e.getExceptionType()
+                      << std::endl;
+            exit(EXIT_FAILURE);
+        }
+    }
+}
+
+void switchDepthAE() {
+    std::unique_lock<std::recursive_mutex> lk(deviceMutex);
+    if(device) {
+        try {
+            if(device->isPropertySupported(OB_PROP_DEPTH_AUTO_EXPOSURE_BOOL, OB_PERMISSION_READ)) {
+                bool value = device->getBoolProperty(OB_PROP_DEPTH_AUTO_EXPOSURE_BOOL);
+                if(device->isPropertySupported(OB_PROP_DEPTH_AUTO_EXPOSURE_BOOL, OB_PERMISSION_WRITE)) {
+                    device->setBoolProperty(OB_PROP_DEPTH_AUTO_EXPOSURE_BOOL, !value);
+                    if(!value) {
+                        std::cout << "Depth Auto-Exposure on!" << std::endl;
+                    }
+                    else {
+                        std::cout << "Depth Auto-Exposure off!" << std::endl;
+                    }
+                }
+            }
+            else {
+                std::cerr << "Depth Auto-Exposure switch property is not supported." << std::endl;
+            }
+        }
+        catch(ob::Error &e) {
+            std::cerr << "function:" << e.getFunction() << "\nargs:" << e.getArgs() << "\nmessage:" << e.what() << "\ntype:" << e.getExceptionType()
+                      << std::endl;
+            exit(EXIT_FAILURE);
+        }
+    }
+}
+void switchColorAE() {
+    std::unique_lock<std::recursive_mutex> lk(deviceMutex);
+    if(device) {
+        try {
+            if(device->isPropertySupported(OB_PROP_COLOR_AUTO_EXPOSURE_BOOL, OB_PERMISSION_READ)) {
+                bool value = device->getBoolProperty(OB_PROP_COLOR_AUTO_EXPOSURE_BOOL);
+                if(device->isPropertySupported(OB_PROP_COLOR_AUTO_EXPOSURE_BOOL, OB_PERMISSION_WRITE)) {
+                    device->setBoolProperty(OB_PROP_COLOR_AUTO_EXPOSURE_BOOL, !value);
+                    if(!value) {
+                        std::cout << "Color Auto-Exposure on!" << std::endl;
+                    }
+                    else {
+                        std::cout << "Color Auto-Exposure off!" << std::endl;
+                    }
+                }
+            }
+            else {
+                std::cerr << "Color Auto-Exposure switch property is not supported." << std::endl;
+            }
+        }
+        catch(ob::Error &e) {
+            std::cerr << "function:" << e.getFunction() << "\nargs:" << e.getArgs() << "\nmessage:" << e.what() << "\ntype:" << e.getExceptionType()
+                      << std::endl;
+            exit(EXIT_FAILURE);
+        }
+    }
+}
+
+void switchDepthMirror() {
+    std::unique_lock<std::recursive_mutex> lk(deviceMutex);
+    if(device) {
+        try {
+            if(device->isPropertySupported(OB_PROP_DEPTH_MIRROR_BOOL, OB_PERMISSION_READ)) {
+                bool value = device->getBoolProperty(OB_PROP_DEPTH_MIRROR_BOOL);
+                if(device->isPropertySupported(OB_PROP_DEPTH_MIRROR_BOOL, OB_PERMISSION_WRITE)) {
+                    device->setBoolProperty(OB_PROP_DEPTH_MIRROR_BOOL, !value);
+                    if(!value) {
+                        std::cout << "Depth mirror on!" << std::endl;
+                    }
+                    else {
+                        std::cout << "Depth mirror off!" << std::endl;
+                    }
+                }
+            }
+            else {
+                std::cerr << "Depth mirror switch property is not supported." << std::endl;
+            }
+        }
+        catch(ob::Error &e) {
+            std::cerr << "function:" << e.getFunction() << "\nargs:" << e.getArgs() << "\nmessage:" << e.what() << "\ntype:" << e.getExceptionType()
+                      << std::endl;
+            exit(EXIT_FAILURE);
+        }
+    }
+}
+
+void switchIRMirror() {
+    std::unique_lock<std::recursive_mutex> lk(deviceMutex);
+    if(device) {
+        try {
+            if(device->isPropertySupported(OB_PROP_IR_MIRROR_BOOL, OB_PERMISSION_READ)) {
+                bool value = device->getBoolProperty(OB_PROP_IR_MIRROR_BOOL);
+                if(device->isPropertySupported(OB_PROP_IR_MIRROR_BOOL, OB_PERMISSION_WRITE)) {
+                    device->setBoolProperty(OB_PROP_IR_MIRROR_BOOL, !value);
+                    if(!value) {
+                        std::cout << "IR mirror on!" << std::endl;
+                    }
+                    else {
+                        std::cout << "IR  mirror off!" << std::endl;
+                    }
+                }
+            }
+            else {
+                std::cerr << "IR  mirror switch property is not supported." << std::endl;
+            }
+        }
+        catch(ob::Error &e) {
+            std::cerr << "function:" << e.getFunction() << "\nargs:" << e.getArgs() << "\nmessage:" << e.what() << "\ntype:" << e.getExceptionType()
+                      << std::endl;
+            exit(EXIT_FAILURE);
+        }
+    }
+}
+
+void switchColorMirror() {
+    std::unique_lock<std::recursive_mutex> lk(deviceMutex);
+    if(device) {
+        try {
+            if(device->isPropertySupported(OB_PROP_COLOR_MIRROR_BOOL, OB_PERMISSION_READ)) {
+                bool value = device->getBoolProperty(OB_PROP_COLOR_MIRROR_BOOL);
+                if(device->isPropertySupported(OB_PROP_COLOR_MIRROR_BOOL, OB_PERMISSION_WRITE)) {
+                    device->setBoolProperty(OB_PROP_COLOR_MIRROR_BOOL, !value);
+                    if(!value) {
+                        std::cout << "Color mirror on!" << std::endl;
+                    }
+                    else {
+                        std::cout << "Color mirror off!" << std::endl;
+                    }
+                }
+            }
+            else {
+                std::cerr << "Color mirror switch property is not supported." << std::endl;
+            }
+        }
+        catch(ob::Error &e) {
+            std::cerr << "function:" << e.getFunction() << "\nargs:" << e.getArgs() << "\nmessage:" << e.what() << "\ntype:" << e.getExceptionType()
+                      << std::endl;
+            exit(EXIT_FAILURE);
+        }
+    }
+}
+
+void setDepthExposureValue(bool increase) {
+    if(device) {
+        try {
+            if(device->isPropertySupported(OB_PROP_DEPTH_AUTO_EXPOSURE_BOOL, OB_PERMISSION_READ_WRITE)) {
+                bool value = device->getBoolProperty(OB_PROP_DEPTH_AUTO_EXPOSURE_BOOL);
+                if(value) {
+                    device->setBoolProperty(OB_PROP_DEPTH_AUTO_EXPOSURE_BOOL, false);
+                    std::cout << "Depth AE close." << std::endl;
+                }
+            }
+            if(device->isPropertySupported(OB_PROP_DEPTH_EXPOSURE_INT, OB_PERMISSION_READ)) {
+                // get the value range
+                OBIntPropertyRange valueRange = device->getIntPropertyRange(OB_PROP_DEPTH_EXPOSURE_INT);
+                std::cout << "Depth current exposure max:" << valueRange.max << ", min:" << valueRange.min << std::endl;
+
+                int value = device->getIntProperty(OB_PROP_DEPTH_EXPOSURE_INT);
+                std::cout << "Depth current exposure:" << value << std::endl;
+                if(device->isPropertySupported(OB_PROP_DEPTH_EXPOSURE_INT, OB_PERMISSION_WRITE)) {
+                    if(increase) {
+                        value += (valueRange.max - valueRange.min) / 10;
+                        if(value > valueRange.max) {
+                            value = valueRange.max;
+                        }
+                    }
+                    else {
+                        value -= (valueRange.max - valueRange.min) / 10;
+                        if(value < valueRange.min) {
+                            value = valueRange.min;
+                        }
+                    }
+
+                    // Ensure that the value meet the step value requirements
+                    value = valueRange.min + (value - valueRange.min) / valueRange.step * valueRange.step;
+
+                    std::cout << "Set depth exposure:" << value << std::endl;
+                    device->setIntProperty(OB_PROP_DEPTH_EXPOSURE_INT, value);
+                }
+                else {
+                    std::cerr << "Depth exposure set property is not supported." << std::endl;
+                }
+            }
+            else {
+                std::cerr << "Depth exposure get property is not supported." << std::endl;
+            }
+        }
+        catch(ob::Error &e) {
+            std::cerr << "function:" << e.getFunction() << "\nargs:" << e.getArgs() << "\nmessage:" << e.what() << "\ntype:" << e.getExceptionType()
+                      << std::endl;
+            exit(EXIT_FAILURE);
+        }
+    }
+}
+
+void setColorExposureValue(bool increase) {
+    if(device) {
+        try {
+            if(device->isPropertySupported(OB_PROP_COLOR_AUTO_EXPOSURE_BOOL, OB_PERMISSION_READ_WRITE)) {
+                bool value = device->getBoolProperty(OB_PROP_COLOR_AUTO_EXPOSURE_BOOL);
+                if(value) {
+                    device->setBoolProperty(OB_PROP_COLOR_AUTO_EXPOSURE_BOOL, false);
+                    std::cout << "Color AE close." << std::endl;
+                }
+            }
+
+            if(device->isPropertySupported(OB_PROP_COLOR_EXPOSURE_INT, OB_PERMISSION_READ)) {
+                // get the value range
+                OBIntPropertyRange valueRange = device->getIntPropertyRange(OB_PROP_COLOR_EXPOSURE_INT);
+                std::cout << "Color current exposure max:" << valueRange.max << ", min:" << valueRange.min << std::endl;
+
+                int value = device->getIntProperty(OB_PROP_COLOR_EXPOSURE_INT);
+                std::cout << "Color current exposure:" << value << std::endl;
+
+                if(device->isPropertySupported(OB_PROP_COLOR_EXPOSURE_INT, OB_PERMISSION_WRITE)) {
+                    if(increase) {
+                        value += (valueRange.max - valueRange.min) / 10;
+                        if(value > valueRange.max) {
+                            value = valueRange.max;
+                        }
+                    }
+                    else {
+                        value -= (valueRange.max - valueRange.min) / 10;
+                        if(value < valueRange.min) {
+                            value = valueRange.min;
+                        }
+                    }
+
+                    // Ensure that the value meet the step value requirements
+                    value = valueRange.min + (value - valueRange.min) / valueRange.step * valueRange.step;
+
+                    std::cout << "Set color exposure:" << value << std::endl;
+                    device->setIntProperty(OB_PROP_COLOR_EXPOSURE_INT, value);
+                }
+                else {
+                    std::cerr << "Color exposure set property is not supported." << std::endl;
+                }
+            }
+            else {
+                std::cerr << "Color exposure get property is not supported." << std::endl;
+            }
+        }
+        catch(ob::Error &e) {
+            std::cerr << "function:" << e.getFunction() << "\nargs:" << e.getArgs() << "\nmessage:" << e.what() << "\ntype:" << e.getExceptionType()
+                      << std::endl;
+            exit(EXIT_FAILURE);
+        }
+    }
+}
+
+void setDepthGainValue(bool increase) {
+    if(device) {
+        try {
+            if(device->isPropertySupported(OB_PROP_DEPTH_GAIN_INT, OB_PERMISSION_READ)) {
+                OBIntPropertyRange valueRange = device->getIntPropertyRange(OB_PROP_DEPTH_GAIN_INT);
+                std::cout << "Depth current gain max:" << valueRange.max << ", min:" << valueRange.min << std::endl;
+                int value = device->getIntProperty(OB_PROP_DEPTH_GAIN_INT);
+                std::cout << "Depth current gain:" << value << std::endl;
+                if(device->isPropertySupported(OB_PROP_DEPTH_GAIN_INT, OB_PERMISSION_WRITE)) {
+                    if(increase) {
+                        value += (valueRange.max - valueRange.min) / 10;
+                        if(value > valueRange.max) {
+                            value = valueRange.max;
+                        }
+                    }
+                    else {
+                        value -= (valueRange.max - valueRange.min) / 10;
+                        if(value < valueRange.min) {
+                            value = valueRange.min;
+                        }
+                    }
+                    // Ensure that the value meet the step value requirements
+                    value = valueRange.min + (value - valueRange.min) / valueRange.step * valueRange.step;
+
+                    std::cout << "Set depth gain:" << value << std::endl;
+                    device->setIntProperty(OB_PROP_DEPTH_GAIN_INT, value);
+                }
+                else {
+                    std::cerr << "Depth gain set property is not supported." << std::endl;
+                }
+            }
+            else {
+                std::cerr << "Depth gain get property is not supported." << std::endl;
+            }
+        }
+        catch(ob::Error &e) {
+            std::cerr << "function:" << e.getFunction() << "\nargs:" << e.getArgs() << "\nmessage:" << e.what() << "\ntype:" << e.getExceptionType()
+                      << std::endl;
+            exit(EXIT_FAILURE);
+        }
+    }
+}
+
+void setColorGainValue(bool increase) {
+    if(device) {
+        try {
+            if(device->isPropertySupported(OB_PROP_COLOR_GAIN_INT, OB_PERMISSION_READ)) {
+                OBIntPropertyRange valueRange = device->getIntPropertyRange(OB_PROP_COLOR_GAIN_INT);
+                std::cout << "Color current gain max:" << valueRange.max << ", min:" << valueRange.min << std::endl;
+                int value = device->getIntProperty(OB_PROP_COLOR_GAIN_INT);
+                std::cout << "Color current gain:" << value << std::endl;
+                if(device->isPropertySupported(OB_PROP_COLOR_GAIN_INT, OB_PERMISSION_WRITE)) {
+                    if(increase) {
+                        value += (valueRange.max - valueRange.min) / 10;
+                        if(value > valueRange.max) {
+                            value = valueRange.max;
+                        }
+                    }
+                    else {
+                        value -= (valueRange.max - valueRange.min) / 10;
+                        if(value < valueRange.min) {
+                            value = valueRange.min;
+                        }
+                    }
+
+                    // Ensure that the value meet the step value requirements
+                    value = valueRange.min + (value - valueRange.min) / valueRange.step * valueRange.step;
+
+                    std::cout << "Set color gain:" << value << std::endl;
+                    device->setIntProperty(OB_PROP_COLOR_GAIN_INT, value);
+                }
+                else {
+                    std::cerr << "Color gain set property is not supported." << std::endl;
+                }
+            }
+            else {
+                std::cerr << "Color gain get property is not supported." << std::endl;
+            }
+        }
+        catch(ob::Error &e) {
+            std::cerr << "function:" << e.getFunction() << "\nargs:" << e.getArgs() << "\nmessage:" << e.what() << "\ntype:" << e.getExceptionType()
+                      << std::endl;
+            exit(EXIT_FAILURE);
+        }
+    }
+}
+
+void printUsage() {
+    std::cout << "Support commands:" << std::endl;
+    std::cout << "    info / i - get device information" << std::endl;
+    std::cout << "    param / p - get camera parameter" << std::endl;
+    std::cout << "    laser / l - on/off laser" << std::endl;
+    std::cout << "    ldp / d - on/off LDP" << std::endl;
+    std::cout << "    ldp status / ds - get LDP status" << std::endl;
+    std::cout << "    color ae / ca - on/off Color auto exposure" << std::endl;
+    std::cout << "    inc color value / cei - increase Color exposure value" << std::endl;
+    std::cout << "    dec color value / ced - decrease Color exposure value" << std::endl;
+    std::cout << "    inc color gain / cgi - increase Color gain value" << std::endl;
+    std::cout << "    dec color gain / cgd - decrease Color gain value" << std::endl;
+    std::cout << "    color mirror / cm - on/off color mirror" << std::endl;
+    std::cout << "    depth ae / da - on/off Depth/IR auto exposure" << std::endl;
+    std::cout << "    depth mirror / dm - on/off Depth mirror" << std::endl;
+    std::cout << "    inc depth value / dei - increase Depth/IR exposure value" << std::endl;
+    std::cout << "    dec depth value / ded - decrease Depth/IR exposure value" << std::endl;
+    std::cout << "    inc depth gain / dgi - increase Depth/IR gain value" << std::endl;
+    std::cout << "    dec depth gain / dgd - decrease Depth/IR gain value" << std::endl;
+    std::cout << "    ir mirror / im - on/off Ir mirror" << std::endl;
+
+    std::cout << "--------------------------------" << std::endl;
+    std::cout << "    help / ? - print usage" << std::endl;
+    std::cout << "    quit / q- quit application" << std::endl;
+}
+
+void commandProcess(std::string cmd) {
+    if(cmd == "info" || cmd == "i") {
+        getDeviceInformation();
+    }
+    else if(cmd == "param" || cmd == "p") {
+        getCameraParams();
+    }
+    else if(cmd == "laser" || cmd == "l") {
+        switchLaser();
+    }
+    else if(cmd == "ldp" || cmd == "d") {
+        switchLDP();
+    }
+    else if(cmd == "ldp status" || cmd == "ds") {
+        getLDPStatus();
+    }
+    else if(cmd == "color ae" || cmd == "ca") {
+        switchColorAE();
+    }
+    else if(cmd == "inc color value" || cmd == "cei") {
+        setColorExposureValue(true);
+    }
+    else if(cmd == "dec color value" || cmd == "ced") {
+        setColorExposureValue(false);
+    }
+    else if(cmd == "inc color gain" || cmd == "cgi") {
+        setColorGainValue(true);
+    }
+    else if(cmd == "dec color gain" || cmd == "cgd") {
+        setColorGainValue(false);
+    }
+    else if(cmd == "inc depth value" || cmd == "dei") {
+        setDepthExposureValue(true);
+    }
+    else if(cmd == "dec depth value" || cmd == "ded") {
+        setDepthExposureValue(false);
+    }
+    else if(cmd == "inc depth gain" || cmd == "dgi") {
+        setDepthGainValue(true);
+    }
+    else if(cmd == "dec depth gain" || cmd == "dgd") {
+        setDepthGainValue(false);
+    }
+    else if(cmd == "depth ae" || cmd == "da") {
+        switchDepthAE();
+    }
+    else if(cmd == "color mirror" || cmd == "cm") {
+        switchColorMirror();
+    }
+    else if(cmd == "depth mirror" || cmd == "dm") {
+        switchDepthMirror();
+    }
+    else if(cmd == "ir mirror" || cmd == "im") {
+        switchIRMirror();
+    }
+    else if(cmd == "help" || cmd == "?") {
+        printUsage();
+    }
+    else {
+        std::cerr << "Unsupported command received! Input \"help\" to get usage" << std::endl;
+    }
+}
+
+void inputWatcher() {
+    while(true) {
+        std::string cmd;
+        std::cout << "\nInput command:  ";
+        std::getline(std::cin, cmd);
+        if(cmd == "quit" || cmd == "q") {
+            win->close();
+            break;
+        }
+        else {
+            commandProcess(cmd);
+        }
+    }
+}
+
diff --git a/examples/3.advanced.coordinate_transform/CMakeLists.txt b/examples/3.advanced.coordinate_transform/CMakeLists.txt
new file mode 100644
index 00000000..64c19c26
--- /dev/null
+++ b/examples/3.advanced.coordinate_transform/CMakeLists.txt
@@ -0,0 +1,15 @@
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+cmake_minimum_required(VERSION 3.5)
+project(ob_coordinate_transform)
+
+add_executable(${PROJECT_NAME} coordinate_transform.cpp)
+
+set_property(TARGET ${PROJECT_NAME} PROPERTY CXX_STANDARD 11)
+target_link_libraries(${PROJECT_NAME} ob::OrbbecSDK ob::examples::utils)
+
+set_target_properties(${PROJECT_NAME} PROPERTIES FOLDER "examples")
+
+install(TARGETS ob_coordinate_transform RUNTIME DESTINATION bin)
+
diff --git a/examples/3.advanced.coordinate_transform/README.md b/examples/3.advanced.coordinate_transform/README.md
new file mode 100644
index 00000000..46b3b5ca
--- /dev/null
+++ b/examples/3.advanced.coordinate_transform/README.md
@@ -0,0 +1,98 @@
+# C++ Sample: 3.advanced.coordinate_transform
+
+## Overview
+
+Use the SDK interface to  transform different coordinate systems.
+
+### Knowledge
+
+Pipeline is a pipeline for processing data streams, providing multi-channel stream configuration, switching, frame aggregation, and frame synchronization functions
+
+Frameset is a combination of different types of Frames
+
+## Code overview
+
+1. Enable color stream
+
+    ```cpp
+        auto colorProfiles = pipe.getStreamProfileList(OB_SENSOR_COLOR);
+        if(colorProfiles) {
+            colorProfile = colorProfiles->getVideoStreamProfile(1280, OB_HEIGHT_ANY, OB_FORMAT_RGB, 30);
+        }
+        config->enableStream(colorProfile);
+    ```
+
+2. Enable depth stream
+
+    ```cpp
+        auto                                    depthProfiles = pipe.getStreamProfileList(OB_SENSOR_DEPTH);
+        std::shared_ptr<ob::VideoStreamProfile> depthProfile  = nullptr;
+        if(depthProfiles) {
+        depthProfile = depthProfiles->getVideoStreamProfile(640, OB_HEIGHT_ANY, OB_FORMAT_Y16, 30);
+
+        }
+        config->enableStream(depthProfile);
+    ```
+
+3. Get frame data
+
+    ```cpp
+        auto colorFrame = frameSet->colorFrame();
+        auto depthFrame = frameSet->depthFrame();
+    ```
+
+4. Get get stream profile
+
+    ```cpp
+        auto colorProfile =  colorFrame->getStreamProfile();
+        auto depthProfile = depthFrame->getStreamProfile();
+    ```
+
+5. Get the extrinsic parameters
+
+    ```cpp
+        auto extrinsicD2C = depthProfile->getExtrinsicTo(colorProfile);
+        auto extrinsicC2D = colorProfile->getExtrinsicTo(depthProfile);
+    ```
+
+6. Get the intrinsic parameters
+
+    ```cpp
+        auto colorIntrinsic = colorProfile->as<ob::VideoStreamProfile>()->getIntrinsic();
+        auto colorDistortion = colorProfile->as<ob::VideoStreamProfile>()->getDistortion();
+    ```
+
+7. Get the distortion parameters
+
+    ```cpp
+        auto depthIntrinsic = depthProfile->as<ob::VideoStreamProfile>()->getIntrinsic();
+        auto depthDistortion = depthProfile->as<ob::VideoStreamProfile>()->getDistortion();
+    ```
+
+8. Processing
+
+    ```cpp
+        if(testType == "1") {
+                transformation2dto2d(colorFrame, depthFrame);
+            } else if (testType == "2") {
+                transformation2dto3d(colorFrame, depthFrame);
+            } else if (testType == "3") {
+                transformation3dto3d(colorFrame, depthFrame);
+            } else if (testType == "4") {
+                transformation3dto2d(colorFrame, depthFrame);
+            } else {
+                std::cout << "Invalid command" << std::endl;
+            }
+    ```
+
+## Run Sample
+
+Press the Esc key to exit the program.
+Press the 1 key - transformation 2d to 2d
+Press the 2 key - transformation 2d to 3d
+Press the 3 key - transformation 3d to 3d
+Press the 4 key - transformation 3d to 2d
+
+### Result
+
+![image](../../docs/resource/coordinate_transform.jpg)
diff --git a/examples/3.advanced.coordinate_transform/coordinate_transform.cpp b/examples/3.advanced.coordinate_transform/coordinate_transform.cpp
new file mode 100644
index 00000000..f950a46b
--- /dev/null
+++ b/examples/3.advanced.coordinate_transform/coordinate_transform.cpp
@@ -0,0 +1,304 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include <libobsensor/ObSensor.hpp>
+#include "libobsensor/hpp/Utils.hpp"
+#include "libobsensor/hpp/Frame.hpp"
+
+void printUsage();
+std::string inputWatcher() ;
+void transformation2dto2d(std::shared_ptr<ob::Frame> colorFrame, std::shared_ptr<ob::Frame> depthFrame);
+void transformation2dto3d(std::shared_ptr<ob::Frame> colorFrame, std::shared_ptr<ob::Frame> depthFrame);
+void transformation3dto2d(std::shared_ptr<ob::Frame> colorFrame, std::shared_ptr<ob::Frame> depthFrame);
+void transformation3dto3d(std::shared_ptr<ob::Frame> colorFrame, std::shared_ptr<ob::Frame> depthFrame);
+
+int main(void) try {
+    // Configure which streams to enable or disable for the Pipeline by creating a Config
+    auto config = std::make_shared<ob::Config>();
+
+    // enable depth and color streams with specified format
+    config->enableVideoStream(OB_STREAM_DEPTH, OB_WIDTH_ANY, OB_HEIGHT_ANY, OB_FPS_ANY, OB_FORMAT_Y16);
+    config->enableVideoStream(OB_STREAM_COLOR, OB_WIDTH_ANY, OB_HEIGHT_ANY, OB_FPS_ANY, OB_FORMAT_RGB);
+
+    // set the frame aggregate output mode to ensure all types of frames are included in the output frameset
+    config->setFrameAggregateOutputMode(OB_FRAME_AGGREGATE_OUTPUT_ALL_TYPE_FRAME_REQUIRE);
+
+    // Create a pipeline with default device to manage stream
+    auto pipe = std::make_shared<ob::Pipeline>();
+
+    std::string testType = "1";   
+
+    // Start the pipeline with config
+    pipe->start(config);
+    while(1) {
+        printUsage();
+        testType = inputWatcher();
+
+        // Wait for a frameset from the pipeline
+        auto frameSet = pipe->waitForFrameset(100);  
+        if(frameSet == nullptr) {
+            continue;
+        }        
+
+        // Get the color frame and check its validity
+        auto colorFrame = frameSet->getFrame(OB_FRAME_COLOR);
+        
+        // Get the depth frame and check its validity
+        auto depthFrame = frameSet->getFrame(OB_FRAME_DEPTH);
+        
+        if(testType == "1") {
+            transformation2dto2d(colorFrame, depthFrame);
+        } else if (testType == "2") {
+            transformation2dto3d(colorFrame, depthFrame);
+        } else if (testType == "3") {
+            transformation3dto3d(colorFrame, depthFrame);
+        } else if (testType == "4") {
+            transformation3dto2d(colorFrame, depthFrame);
+        } else {
+            std::cout << "Invalid command" << std::endl;
+        }  
+     }
+     
+    pipe->stop();
+    return 0;
+}
+catch(ob::Error &e) {
+    std::cerr << "function:" << e.getFunction() << "\nargs:" << e.getArgs() << "\nmessage:" << e.what() << "\ntype:" << e.getExceptionType() << std::endl;
+    exit(EXIT_FAILURE);
+}
+
+std::string inputWatcher() {
+    while(true) {
+        std::string cmd;
+        std::cout << "\nInput command:  ";
+        std::getline(std::cin, cmd);
+        if(cmd == "quit" || cmd == "q") {
+            exit(EXIT_SUCCESS);
+        }
+        return cmd;
+    }
+}
+void printUsage() {
+    std::cout << "Support commands:" << std::endl;
+    std::cout << "    1 - transformation 2d to 2d" << std::endl;
+    std::cout << "    2 - transformation 2d to 3d" << std::endl;
+    std::cout << "    3 - transformation 3d to 3d" << std::endl;
+    std::cout << "    4 - transformation 3d to 2d" << std::endl;
+
+    std::cout << "--------------------------------" << std::endl;
+    std::cout << "    quit / q- quit application" << std::endl;
+}
+
+void printRuslt(std::string msg, OBPoint2f sourcePixel, OBPoint2f targetPixel) {
+    std::cout << msg << ":" << "(" << sourcePixel.x << ", " << sourcePixel.y << ") -> (" << targetPixel.x << ", " << targetPixel.y << ")" << std::endl;
+}
+
+void printRuslt(std::string msg, OBPoint2f sourcePixel, OBPoint3f targetPixel, float depthValue) {
+    std::cout << msg << ":" << "depth " << depthValue <<  " (" << sourcePixel.x << ", " << sourcePixel.y << ") -> (" << targetPixel.x << ", " << targetPixel.y << ", " << targetPixel.z << ")" << std::endl;
+}
+
+void printRuslt(std::string msg, OBPoint3f sourcePixel, OBPoint2f targetPixel) {
+    std::cout << msg << ":" << "(" << sourcePixel.x << ", " << sourcePixel.y << ", " << sourcePixel.z << ") -> (" << targetPixel.x << ", " << targetPixel.y << ")" << std::endl;
+}
+
+void printRuslt(std::string msg, OBPoint3f sourcePixel, OBPoint3f targetPixel) {
+    std::cout << msg << ":" << "(" << sourcePixel.x << ", " << sourcePixel.y << ", " << sourcePixel.z << ") -> (" << targetPixel.x << ", " << targetPixel.y << ", " << targetPixel.z << ")" << std::endl;
+}
+
+// test the transformation from one 2D coordinate system to another
+void transformation2dto2d(std::shared_ptr<ob::Frame> colorFrame, std::shared_ptr<ob::Frame> depthFrame) {
+    // Get the width and height of the color and depth frames
+    auto colorFrameWidth = colorFrame->as<ob::VideoFrame>()->getWidth();
+    auto depthFrameWidth = depthFrame->as<ob::VideoFrame>()->getWidth();    
+    auto colorFrameHeight = colorFrame->as<ob::VideoFrame>()->getHeight(); 
+    auto depthFrameHeight = depthFrame->as<ob::VideoFrame>()->getHeight();
+
+    // Get the stream profiles for the color and depth frames
+    auto colorProfile =  colorFrame->getStreamProfile();
+    auto depthProfile = depthFrame->getStreamProfile();
+    auto extrinsicD2C = depthProfile->getExtrinsicTo(colorProfile);
+
+    // Get the intrinsic and distortion parameters for the color and depth streams
+    auto colorIntrinsic = colorProfile->as<ob::VideoStreamProfile>()->getIntrinsic();
+    auto colorDistortion = colorProfile->as<ob::VideoStreamProfile>()->getDistortion();
+    auto depthIntrinsic = depthProfile->as<ob::VideoStreamProfile>()->getIntrinsic();
+    auto depthDistortion = depthProfile->as<ob::VideoStreamProfile>()->getDistortion();
+     // Access the depth data from the frame
+    uint16_t *pDepthData = (uint16_t *)depthFrame->getData();
+    uint16_t convertAreaWidth = 3;
+    uint16_t convertAreaHeight = 3;
+
+    // Transform depth values to the color frame's coordinate system
+    for(uint32_t i = depthFrameHeight / 2; i < (depthFrameHeight / 2 + convertAreaHeight); i++) {
+        for(uint32_t j = depthFrameWidth / 2; j < (depthFrameWidth / 2 + convertAreaWidth); j++) {
+            OBPoint2f sourcePixel = { static_cast<float>(j), static_cast<float>(i) };
+            OBPoint2f targetPixel = {};
+            float     depthValue  = (float)pDepthData[i * depthFrameWidth + j];
+            if(depthValue == 0) {
+                std::cout << "The depth value is 0, so it's recommended to point the camera at a flat surface" << std::endl;
+                continue;
+            }
+            
+            // Demonstrate Depth 2D converted to Color 2D
+            bool result = ob::CoordinateTransformHelper::transformation2dto2d(sourcePixel, depthValue, depthIntrinsic, depthDistortion, colorIntrinsic,
+                                                                              colorDistortion, extrinsicD2C, &targetPixel);
+            
+            // Check transformation result and whether the target pixel is within the color frame
+            if(!result || targetPixel.y < 0 || targetPixel.x < 0 || targetPixel.y > colorFrameWidth || targetPixel.x > colorFrameWidth) {
+                continue;
+            }
+
+            // Calculate the index position of the target pixel in the transformation data buffer
+            auto index = (((uint32_t)targetPixel.y * colorFrameWidth) + (uint32_t)targetPixel.x);
+            if(index > colorFrameWidth * colorFrameHeight) {
+                continue;
+            }
+
+            printRuslt("depth to color: depth image coordinate transform to color image coordinate", sourcePixel, targetPixel);            
+        }
+    }
+}
+
+// test the transformation from 2D to 3D coordinates
+void transformation2dto3d(std::shared_ptr<ob::Frame> colorFrame, std::shared_ptr<ob::Frame> depthFrame) {
+     // Get the width and height of the color and depth frames
+    auto depthFrameWidth = depthFrame->as<ob::VideoFrame>()->getWidth();    
+    auto depthFrameHeight = depthFrame->as<ob::VideoFrame>()->getHeight();
+
+    // Get the stream profiles for the color and depth frames
+    auto colorProfile =  colorFrame->getStreamProfile();
+    auto depthProfile = depthFrame->getStreamProfile();
+    auto extrinsicD2C = depthProfile->getExtrinsicTo(colorProfile);
+
+    // Get the intrinsic and distortion parameters for the color and depth streams
+    auto depthIntrinsic = depthProfile->as<ob::VideoStreamProfile>()->getIntrinsic();
+    // Access the depth data from the frame
+    uint16_t *pDepthData = (uint16_t *)depthFrame->getData();
+    uint16_t convertAreaWidth = 3;
+    uint16_t convertAreaHeight = 3;
+    
+    // Transform depth values to the color frame's coordinate system
+    for(uint32_t i = depthFrameHeight / 2; i < (depthFrameHeight / 2 + convertAreaHeight); i++) {
+        for(uint32_t j = depthFrameWidth / 2; j < (depthFrameWidth / 2 + convertAreaWidth); j++) {
+            // Get the coordinates of the current pixel
+            OBPoint2f sourcePixel = { static_cast<float>(j), static_cast<float>(i) };
+            OBPoint3f targetPixel = {};
+            // Get the depth value of the current pixel
+            float     depthValue  = (float)pDepthData[i * depthFrameWidth + j];
+            if(depthValue == 0) {
+                std::cout << "The depth value is 0, so it's recommended to point the camera at a flat surface" << std::endl;
+                continue;
+            }
+
+            // Perform the 2D to 3D transformation
+            bool result = ob::CoordinateTransformHelper::transformation2dto3d(sourcePixel, depthValue, depthIntrinsic,  extrinsicD2C, &targetPixel);
+            if(!result ) {
+                continue;
+            }
+            
+            printRuslt("2d to 3D: pixel coordinates and depth transform to point in 3D space", sourcePixel, targetPixel, depthValue);
+        }
+    }
+}
+
+// test the transformation from 3D coordinates to 3D coordinates
+void transformation3dto3d(std::shared_ptr<ob::Frame> colorFrame, std::shared_ptr<ob::Frame> depthFrame) {
+     // Get the width and height of the color and depth frames
+    auto depthFrameWidth = depthFrame->as<ob::VideoFrame>()->getWidth();   
+    auto depthFrameHeight = depthFrame->as<ob::VideoFrame>()->getHeight();
+
+    // Get the stream profiles for the color and depth frames
+    auto colorProfile =  colorFrame->getStreamProfile();
+    auto depthProfile = depthFrame->getStreamProfile();
+    auto extrinsicD2C = depthProfile->getExtrinsicTo(colorProfile);
+    auto extrinsicC2D = colorProfile->getExtrinsicTo(depthProfile);
+
+    // Get the intrinsic and distortion parameters for the color and depth streams
+    auto depthIntrinsic = depthProfile->as<ob::VideoStreamProfile>()->getIntrinsic();
+    // Access the depth data from the frame
+    uint16_t *pDepthData = (uint16_t *)depthFrame->getData();
+    uint16_t convertAreaWidth = 3;
+    uint16_t convertAreaHeight = 3;
+    
+    // Transform depth values to the color frame's coordinate system
+    for(uint32_t i = depthFrameHeight / 2; i < (depthFrameHeight / 2 + convertAreaHeight); i++) {
+        for(uint32_t j = depthFrameWidth / 2; j < (depthFrameWidth / 2 + convertAreaWidth); j++) {
+            // Get the coordinates of the current pixel
+            OBPoint2f sourcePixel = { static_cast<float>(j), static_cast<float>(i) };
+            OBPoint3f tmpTargetPixel = {};
+            OBPoint3f targetPixel = {};
+            // Get the depth value of the current pixel
+            float     depthValue  = (float)pDepthData[i * depthFrameWidth + j];
+            if(depthValue == 0) {
+                std::cout << "The depth value is 0, so it's recommended to point the camera at a flat surface" << std::endl;
+                continue;
+            }
+            
+            // Perform the 2D to 3D transformation
+            bool result = ob::CoordinateTransformHelper::transformation2dto3d(sourcePixel, depthValue, depthIntrinsic, extrinsicD2C, &tmpTargetPixel);
+            if(!result ) {
+                continue;
+            }
+            printRuslt("2d to 3D: pixel coordinates and depth transform to point in 3D space", sourcePixel, tmpTargetPixel, depthValue);
+            
+            // Perform the 3D to 3D transformation
+            result = ob::CoordinateTransformHelper::transformation3dto3d(tmpTargetPixel, extrinsicC2D, &targetPixel);
+            if(!result ) {
+                continue;
+            }
+            printRuslt("3d to 3D: transform 3D coordinates relative to one sensor to 3D coordinates relative to another viewpoint", tmpTargetPixel, targetPixel);
+        }
+    }
+}
+
+// test the transformation from 3D coordinates back to 2D coordinates
+void transformation3dto2d(std::shared_ptr<ob::Frame> colorFrame, std::shared_ptr<ob::Frame> depthFrame) {
+     // Get the width and height of the color and depth frames
+    auto depthFrameWidth = depthFrame->as<ob::VideoFrame>()->getWidth();   
+    auto depthFrameHeight = depthFrame->as<ob::VideoFrame>()->getHeight();
+
+    // Get the stream profiles for the color and depth frames
+    auto colorProfile =  colorFrame->getStreamProfile();
+    auto depthProfile = depthFrame->getStreamProfile();
+    auto extrinsicD2C = depthProfile->getExtrinsicTo(colorProfile);
+    auto extrinsicC2D = colorProfile->getExtrinsicTo(depthProfile);
+
+    // Get the intrinsic and distortion parameters for the color and depth streams
+    auto depthIntrinsic = depthProfile->as<ob::VideoStreamProfile>()->getIntrinsic();
+    auto depthDistortion = depthProfile->as<ob::VideoStreamProfile>()->getDistortion();
+    // Access the depth data from the frame
+    uint16_t *pDepthData = (uint16_t *)depthFrame->getData();
+    uint16_t convertAreaWidth = 3;
+    uint16_t convertAreaHeight = 3;
+    
+    // Transform depth values to the color frame's coordinate system
+    for(uint32_t i = depthFrameHeight / 2; i < (depthFrameHeight / 2 + convertAreaHeight); i++) {
+        for(uint32_t j = depthFrameWidth / 2; j < (depthFrameWidth / 2 + convertAreaWidth); j++) {
+            // Get the coordinates of the current pixel
+            OBPoint2f sourcePixel = { static_cast<float>(j), static_cast<float>(i) };
+            OBPoint3f tmpTargetPixel = {};
+            OBPoint2f targetPixel = {};
+            // Get the depth value of the current pixel
+            float     depthValue  = (float)pDepthData[i * depthFrameWidth + j];
+            if(depthValue == 0) {
+                std::cout << "The depth value is 0, so it's recommended to point the camera at a flat surface" << std::endl;
+                continue;
+            }
+            
+            // Perform the 2D to 3D transformation
+            bool result = ob::CoordinateTransformHelper::transformation2dto3d(sourcePixel, depthValue, depthIntrinsic, 
+                                            extrinsicD2C, &tmpTargetPixel);
+            if(!result ) {
+                continue;
+            }
+            printRuslt("depth 2d to 3D: pixel coordinates and depth transform to point in 3D space", sourcePixel, tmpTargetPixel, depthValue);
+            
+            // Perform the 3D to 2D transformation
+            result = ob::CoordinateTransformHelper::transformation3dto2d(tmpTargetPixel, depthIntrinsic, depthDistortion, extrinsicC2D, &targetPixel);
+            if(!result ) {
+                continue;
+            }
+            printRuslt("3d to depth 2d : point in 3D space transform to the corresponding pixel coordinates in an image", tmpTargetPixel, targetPixel);
+        }
+    }
+}
diff --git a/examples/3.advanced.hdr/CMakeLists.txt b/examples/3.advanced.hdr/CMakeLists.txt
new file mode 100644
index 00000000..bd490090
--- /dev/null
+++ b/examples/3.advanced.hdr/CMakeLists.txt
@@ -0,0 +1,14 @@
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+cmake_minimum_required(VERSION 3.5)
+project(ob_hdr)
+
+add_executable(ob_hdr hdr.cpp)
+
+set_property(TARGET ob_hdr PROPERTY CXX_STANDARD 11)
+target_link_libraries(ob_hdr ob::OrbbecSDK ob::examples::utils)
+set_target_properties(ob_hdr PROPERTIES FOLDER "examples")
+
+install(TARGETS ob_hdr RUNTIME DESTINATION bin)
+
diff --git a/examples/3.advanced.hdr/README.md b/examples/3.advanced.hdr/README.md
new file mode 100644
index 00000000..e6a62a7c
--- /dev/null
+++ b/examples/3.advanced.hdr/README.md
@@ -0,0 +1,83 @@
+# C++ Sample: 3.advanced.hdr
+
+## Overview
+
+In this sample, user can get the HDR merge image. Also Allows the user to control the on-off of the HDR synthesis and whether the original image is displayed through the keyboard.
+
+### Knowledge
+
+Pipeline is a pipeline for processing data streams, providing multi-channel stream configuration, switching, frame aggregation, and frame synchronization functions
+
+Frameset is a combination of different types of Frames
+
+### Attentions
+
+> This Sample only supports Gemini330 series devices.
+
+## Code overview
+
+### 1. Check if the device supports HDR merge
+
+```c++
+if(!device->isPropertySupported(OB_STRUCT_DEPTH_HDR_CONFIG, OB_PERMISSION_READ_WRITE)) {
+    std::cerr << "Current default device does not support HDR merge" << std::endl;
+    std::cout << "Press any key to exit...";
+    ob_smpl::waitForKeyPressed();
+    return -1;
+}
+```
+
+### 2. Get depth stream profile
+
+Get all stream profiles of the depth camera, including stream resolution, frame rate, and frame format
+
+```c++
+auto depthProfiles = pipe.getStreamProfileList(OB_SENSOR_DEPTH);
+auto depthProfile  = depthProfiles->getProfile(OB_PROFILE_DEFAULT);
+config->enableStream(depthProfile);
+```
+
+### 3. Create HDRMerge
+
+Create HDRMerge post processor to merge depth frames betweens different hdr sequence ids.
+The HDRMerge also supports processing of infrared frames.
+
+```c++
+auto hdrMerge = ob::FilterFactory::createFilter("HDRMerge");
+```
+
+### 5. Configure and enable Hdr stream
+
+```c++
+    OBHdrConfig obHdrConfig;
+    obHdrConfig.enable     = true;  // enable HDR merge
+    obHdrConfig.exposure_1 = 7500;
+    obHdrConfig.gain_1     = 24;
+    obHdrConfig.exposure_2 = 100;
+    obHdrConfig.gain_2     = 16;
+    device->setStructuredData(OB_STRUCT_DEPTH_HDR_CONFIG, reinterpret_cast<uint8_t *>(&obHdrConfig), sizeof(OBHdrConfig));
+```
+
+### 7. Stop the pipeline and close hdr merge
+
+```c++
+// Stop the Pipeline, no frame data will be generated
+pipe.stop();
+
+// close hdr merge
+obHdrConfig.enable = false;
+device->setStructuredData(OB_STRUCT_DEPTH_HDR_CONFIG, reinterpret_cast<uint8_t *>(&obHdrConfig), sizeof(OBHdrConfig));
+```
+
+## Run Sample
+
+### Key introduction
+
+Press the 'Esc' key in the window to exit the program.
+Press the '?' key in the window to show key map.
+Press the 'M' key in the window to Toggle HDR merge.
+Press the 'N' key in the window to Toggle alternate show origin frame.
+
+### Result
+
+![hdr](../../docs/resource/hdr.jpg)
diff --git a/examples/3.advanced.hdr/hdr.cpp b/examples/3.advanced.hdr/hdr.cpp
new file mode 100644
index 00000000..a7118d37
--- /dev/null
+++ b/examples/3.advanced.hdr/hdr.cpp
@@ -0,0 +1,99 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include <libobsensor/ObSensor.hpp>
+
+#include "utils.hpp"
+#include "utils_opencv.hpp"
+
+int main(void) try {
+    // Create a pipeline with default device
+    ob::Pipeline pipe;
+
+    // Get the device from the pipeline
+    auto device = pipe.getDevice();
+
+    // Check if the device supports HDR merge
+    if(!device->isPropertySupported(OB_STRUCT_DEPTH_HDR_CONFIG, OB_PERMISSION_READ_WRITE)) {
+        std::cerr << "Current default device does not support HDR merge" << std::endl;
+        std::cout << "Press any key to exit...";
+        ob_smpl::waitForKeyPressed();
+        return -1;
+    }
+
+    // Configure which streams to enable or disable for the Pipeline by creating a Config
+    std::shared_ptr<ob::Config> config = std::make_shared<ob::Config>();
+
+    // enable depth stream with default profile
+    config->enableVideoStream(OB_STREAM_DEPTH);
+    config->enableVideoStream(OB_STREAM_IR_LEFT);
+    config->enableVideoStream(OB_STREAM_IR_RIGHT);
+    config->setFrameAggregateOutputMode(OB_FRAME_AGGREGATE_OUTPUT_ALL_TYPE_FRAME_REQUIRE);
+
+    // Create HDRMerge post processor to merge depth frames betweens different hdr sequence ids.
+    // The HDRMerge also supports processing of infrared frames.
+    auto hdrMerge = ob::FilterFactory::createFilter("HDRMerge");
+
+    // configure and enable Hdr stream
+    OBHdrConfig obHdrConfig;
+    obHdrConfig.enable     = true;  // enable HDR merge
+    obHdrConfig.exposure_1 = 7500;
+    obHdrConfig.gain_1     = 24;
+    obHdrConfig.exposure_2 = 100;
+    obHdrConfig.gain_2     = 16;
+    device->setStructuredData(OB_STRUCT_DEPTH_HDR_CONFIG, reinterpret_cast<uint8_t *>(&obHdrConfig), sizeof(OBHdrConfig));
+
+    // Start the pipeline with config
+    pipe.start(config);
+
+    // Create a window for rendering and set the resolution of the window
+    ob_smpl::CVWindow win("HDR-Merge", 1280, 720, ob_smpl::ARRANGE_GRID);
+    win.addLog("The HDR-Merged depth frames are displayed in the last row of the window.");
+    while(win.run()) {
+        auto frameSet = pipe.waitForFrameset(100);
+        if(frameSet == nullptr) {
+            continue;
+        }
+
+        // Get the depth and infrared frames from the frameset
+        auto depthFrame   = frameSet->getFrame(OB_FRAME_DEPTH)->as<ob::DepthFrame>();
+        auto leftIRFrame  = frameSet->getFrame(OB_FRAME_IR_LEFT)->as<ob::IRFrame>();
+        auto rightIRFrame = frameSet->getFrame(OB_FRAME_IR_RIGHT)->as<ob::IRFrame>();
+
+        // Get the HDR sequence id from the depth frame metadata
+        int groupId = static_cast<int>(depthFrame->getMetadataValue(OB_FRAME_METADATA_TYPE_HDR_SEQUENCE_INDEX));
+        win.pushFramesToView({ depthFrame, leftIRFrame, rightIRFrame }, groupId);
+
+        try {
+            // Using HDRMerge filter to merge hdr frames
+            auto result = hdrMerge->process(frameSet);
+            if(result == nullptr) {
+                continue;
+            }
+            auto resultFrameSet   = result->as<ob::FrameSet>();
+            auto resultDepthFrame = resultFrameSet->getFrame(OB_FRAME_DEPTH)->as<ob::DepthFrame>();
+
+            // add merged depth frame to render queue
+            win.pushFramesToView(resultDepthFrame, 10);  // set the group id to 10 to avoid same group id with original depth frame
+        }
+        catch(ob::Error &e) {
+            std::cerr << "HDRMerge error: " << e.what() << std::endl;
+        }
+    }
+
+    // Stop the Pipeline, no frame data will be generated
+    pipe.stop();
+
+    // close hdr merge
+    obHdrConfig.enable = false;
+    device->setStructuredData(OB_STRUCT_DEPTH_HDR_CONFIG, reinterpret_cast<uint8_t *>(&obHdrConfig), sizeof(OBHdrConfig));
+
+    return 0;
+}
+catch(ob::Error &e) {
+    std::cerr << "function:" << e.getFunction() << "\nargs:" << e.getArgs() << "\nmessage:" << e.what() << "\ntype:" << e.getExceptionType() << std::endl;
+    std::cout << "\nPress any key to exit...";
+    ob_smpl::waitForKeyPressed();
+    exit(EXIT_FAILURE);
+}
+
diff --git a/examples/3.advanced.hw_d2c_align/CMakeLists.txt b/examples/3.advanced.hw_d2c_align/CMakeLists.txt
new file mode 100644
index 00000000..59468184
--- /dev/null
+++ b/examples/3.advanced.hw_d2c_align/CMakeLists.txt
@@ -0,0 +1,15 @@
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+cmake_minimum_required(VERSION 3.5)
+project(ob_hw_d2c_align)
+
+add_executable(${PROJECT_NAME} hw_d2c_align.cpp)
+
+set_property(TARGET ${PROJECT_NAME} PROPERTY CXX_STANDARD 11)
+target_link_libraries(${PROJECT_NAME} ob::OrbbecSDK ob::examples::utils)
+
+set_target_properties(${PROJECT_NAME} PROPERTIES FOLDER "examples")
+
+install(TARGETS ob_hw_d2c_align RUNTIME DESTINATION bin)
+
diff --git a/examples/3.advanced.hw_d2c_align/README.md b/examples/3.advanced.hw_d2c_align/README.md
new file mode 100644
index 00000000..309079ca
--- /dev/null
+++ b/examples/3.advanced.hw_d2c_align/README.md
@@ -0,0 +1,14 @@
+# C++ Sample: 3.advanced.hw_d2c_align
+
+## Overview
+
+This sample demonstrates how to use the SDK to enable depth-to-color alignment on hardware devices (alse known as hardware D2C or HwD2C).
+
+### Knowledge
+
+- The HwD2C feature allows you to align the depth image to the color image captured by the device. This is useful for applications that require depth frame to be aligned with color frame and do want to use increase the resource usage of the host.
+
+### Attention
+
+- The HwD2C feature is only available on devices that support it. Please check the documentation of your device to see if it supports HwD2C.
+- Is not all profile of depth stream are supported the HwD2C feature. Please call the `getD2CDepthProfileList` function of `ob::Pipeline` class to check the supported depth profile.
\ No newline at end of file
diff --git a/examples/3.advanced.hw_d2c_align/hw_d2c_align.cpp b/examples/3.advanced.hw_d2c_align/hw_d2c_align.cpp
new file mode 100644
index 00000000..2c37bd82
--- /dev/null
+++ b/examples/3.advanced.hw_d2c_align/hw_d2c_align.cpp
@@ -0,0 +1,137 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include <libobsensor/ObSensor.hpp>
+
+#include "utils.hpp"
+#include "utils_opencv.hpp"
+
+#include <mutex>
+#include <thread>
+
+bool enable_align_mode = 1;
+
+// key press event processing
+void handleKeyPress(ob_smpl::CVWindow &win, std::shared_ptr<ob::Pipeline> pipe, int key, std::shared_ptr<ob::Config> config) {
+    if(key == 't' || key == 'T') {
+        // Press the T key to switch align mode
+        enable_align_mode = !enable_align_mode;
+
+        // update the align mode in the config
+        if(enable_align_mode) {
+            config->setAlignMode(ALIGN_D2C_HW_MODE);
+            win.addLog("Haeware Depth to Color Align: Enabled");
+        }
+        else {
+            config->setAlignMode(ALIGN_DISABLE);
+            win.addLog("Haeware Depth to Color Align: Disabled");
+        }
+
+        // restart the pipeline with the new config
+        pipe->stop();
+        pipe->start(config);
+    }
+}
+
+// check if the given stream profiles support hardware depth-to-color alignment
+bool checkIfSupportHWD2CAlign(std::shared_ptr<ob::Pipeline> pipe, std::shared_ptr<ob::StreamProfile> colorStreamProfile,
+                              std::shared_ptr<ob::StreamProfile> depthStreamProfile) {
+    auto hwD2CSupportedDepthStreamProfiles = pipe->getD2CDepthProfileList(colorStreamProfile, ALIGN_D2C_HW_MODE);
+    if(hwD2CSupportedDepthStreamProfiles->count() == 0) {
+        return false;
+    }
+
+    // Iterate through the supported depth stream profiles and check if there is a match with the given depth stream profile
+    auto depthVsp = depthStreamProfile->as<ob::VideoStreamProfile>();
+    auto count    = hwD2CSupportedDepthStreamProfiles->getCount();
+    for(uint32_t i = 0; i < count; i++) {
+        auto sp  = hwD2CSupportedDepthStreamProfiles->getProfile(i);
+        auto vsp = sp->as<ob::VideoStreamProfile>();
+        if(vsp->getWidth() == depthVsp->getWidth() && vsp->getHeight() == depthVsp->getHeight() && vsp->getFormat() == depthVsp->getFormat()
+           && vsp->getFps() == depthVsp->getFps()) {
+            // Found a matching depth stream profile, it is means the given stream profiles support hardware depth-to-color alignment
+            return true;
+        }
+    }
+    return false;
+}
+
+// create a config for hardware depth-to-color alignment
+std::shared_ptr<ob::Config> createHwD2CAlignConfig(std::shared_ptr<ob::Pipeline> pipe) {
+    auto coloStreamProfiles  = pipe->getStreamProfileList(OB_SENSOR_COLOR);
+    auto depthStreamProfiles = pipe->getStreamProfileList(OB_SENSOR_DEPTH);
+
+    // Iterate through all color and depth stream profiles to find a match for hardware depth-to-color alignment
+    auto colorSpCount = coloStreamProfiles->getCount();
+    auto depthSpCount = depthStreamProfiles->getCount();
+    for(uint32_t i = 0; i < colorSpCount; i++) {
+        auto colorProfile = coloStreamProfiles->getProfile(i);
+        auto colorVsp     = colorProfile->as<ob::VideoStreamProfile>();
+        for(uint32_t j = 0; j < depthSpCount; j++) {
+            auto depthProfile = depthStreamProfiles->getProfile(j);
+            auto depthVsp     = depthProfile->as<ob::VideoStreamProfile>();
+
+            // make sure the color and depth stream have the same fps, due to some models may not support different fps
+            if(colorVsp->getFps() != depthVsp->getFps()) {
+                continue;
+            }
+
+            // Check if the given stream profiles support hardware depth-to-color alignment
+            if(checkIfSupportHWD2CAlign(pipe, colorProfile, depthProfile)) {
+                // If support, create a config for hardware depth-to-color alignment
+                auto hwD2CAlignConfig = std::make_shared<ob::Config>();
+                hwD2CAlignConfig->enableStream(colorProfile);                                                     // enable color stream
+                hwD2CAlignConfig->enableStream(depthProfile);                                                     // enable depth stream
+                hwD2CAlignConfig->setAlignMode(ALIGN_D2C_HW_MODE);                                                // enable hardware depth-to-color alignment
+                hwD2CAlignConfig->setFrameAggregateOutputMode(OB_FRAME_AGGREGATE_OUTPUT_ALL_TYPE_FRAME_REQUIRE);  // output frameset with all types of frames
+                return hwD2CAlignConfig;
+            }
+        }
+    }
+    return nullptr;
+}
+
+int main(void) try {
+    // Create a pipeline with default device to manage stream
+    auto pipe = std::make_shared<ob::Pipeline>();
+
+    // enable frame sync inside the pipeline, which is synchronized by frame timestamp
+    pipe->enableFrameSync();
+
+    // Create a config for hardware depth-to-color alignment
+    auto config = createHwD2CAlignConfig(pipe);
+    if(config == nullptr) {
+        std::cerr << "Current device does not support hardware depth-to-color alignment." << std::endl;
+        return 1;
+    }
+
+    // Start the pipeline with config
+    pipe->start(config);
+
+    // Create a window for rendering and set the resolution of the window
+    ob_smpl::CVWindow win("Hardware Depth to Color Align", 1280, 720, ob_smpl::ARRANGE_OVERLAY);
+    // set key prompt
+    win.setKeyPrompt("'T': Enable/Disable HwD2C, '+/-': Adjust Transparency");
+    // set the callback function for the window to handle key press events
+    win.setKeyPressedCallback([&](int key) { handleKeyPress(win, pipe, key, config); });
+
+    while(win.run()) {
+        // Wait for a frameset from the pipeline
+        auto frameSet = pipe->waitForFrameset(100);
+        if(frameSet == nullptr) {
+            continue;
+        }
+        win.pushFramesToView(frameSet);
+    }
+
+    // Stop the Pipeline, no frame data will be generated
+    pipe->stop();
+
+    return 0;
+}
+catch(ob::Error &e) {
+    std::cerr << "function:" << e.getFunction() << "\nargs:" << e.getArgs() << "\nmessage:" << e.what() << "\ntype:" << e.getExceptionType() << std::endl;
+    std::cout << "\nPress any key to exit.";
+    ob_smpl::waitForKeyPressed();
+    exit(EXIT_FAILURE);
+}
diff --git a/examples/3.advanced.multi_devices/CMakeLists.txt b/examples/3.advanced.multi_devices/CMakeLists.txt
new file mode 100644
index 00000000..9d390a70
--- /dev/null
+++ b/examples/3.advanced.multi_devices/CMakeLists.txt
@@ -0,0 +1,14 @@
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+cmake_minimum_required(VERSION 3.5)
+project(ob_multi_device)
+
+add_executable(${PROJECT_NAME} multi_device.cpp)
+
+set_property(TARGET ${PROJECT_NAME} PROPERTY CXX_STANDARD 11)
+target_link_libraries(${PROJECT_NAME} ob::OrbbecSDK ob::examples::utils)
+set_target_properties(${PROJECT_NAME} PROPERTIES FOLDER "examples")
+
+install(TARGETS ob_multi_device RUNTIME DESTINATION bin)
+
diff --git a/examples/3.advanced.multi_devices/README.md b/examples/3.advanced.multi_devices/README.md
new file mode 100644
index 00000000..29b1cbf1
--- /dev/null
+++ b/examples/3.advanced.multi_devices/README.md
@@ -0,0 +1,92 @@
+# C++ Sample：3.advanced.multi_devices
+
+## Overview
+
+In this sample, users can connect multiple camera devices and get color and depth images of different cameras.
+
+### Knowledge
+
+Context is the environment context, the first object created during initialization, which can be used to perform some settings, including but not limited to device status change callbacks, log level settings, etc. Context can access multiple Devices.
+
+FrameSet is a combination of different types of Frames.
+
+## code overview
+
+1. StartStream DeviceIndex is used to identify different devices, and map is used to store the color and depth stream of different devices.
+
+    ```cpp
+    void StartStream(std::map<int, std::shared_ptr<ob::Pipeline>> &pipes) {
+
+    for(auto &item: pipes) {
+        int   deviceIndex = item.first;
+        auto &pipe        = item.second;
+
+        // config to enable depth and color streams
+        std::shared_ptr<ob::Config> config = std::make_shared<ob::Config>();
+        config->enableVideoStream(OB_STREAM_COLOR);
+        config->enableVideoStream(OB_STREAM_DEPTH);
+
+        // start pipeline and pass the callback function to receive the frames
+        pipe->start(config, [deviceIndex](std::shared_ptr<ob::FrameSet> frameSet) {
+            std::lock_guard<std::mutex> lock(framesetMutex);
+            framesets[deviceIndex] = frameSet;
+        });
+    }
+    }
+    ```
+
+2. StopStream Obtain pipelines corresponding to different devices and stop the pipelines.
+
+    ```cpp
+    void StopStream(std::map<int, std::shared_ptr<ob::Pipeline>> &pipes) {
+        for(auto &item: pipes) {
+            auto &pipe = item.second;
+            // stop the pipeline
+            pipe->stop();
+        }
+
+        std::lock_guard<std::mutex> lock(framesetMutex);
+        framesets.clear();
+    }
+    ```
+
+3. Obtain the currently connected devices through context, and obtain the list and number of devices.
+
+    ```cpp
+    // Create a Context
+    ob::Context ctx;
+
+    // Query the list of connected devices
+    auto devList = ctx.queryDeviceList();
+
+    // Get the number of connected devices
+    int devCount = devList->getCount();
+    ```
+
+4. Use map to bind deviceIndex to the device's pipeline to distinguish video streams obtained by different devices.
+
+    ```cpp
+    // Create a pipeline for each device
+    std::map<int, std::shared_ptr<ob::Pipeline>> pipes;
+    for(int i = 0; i < devCount; i++) {
+        // Get the device from device list
+        auto dev  = devList->getDevice(i);
+
+        // Create a pipeline for the device
+        auto pipe = std::make_shared<ob::Pipeline>(dev);
+
+        // Add the pipeline to the map of pipelines
+        pipes.insert({ i, pipe });
+    }
+    ```
+
+## Run Sample
+
+### Key introduction
+
+Press the 'Esc' key in the window to exit the program.
+Press the '?' key in the window to show key map.
+
+### Result
+
+![multi_devices](../../docs/resource/multi_devices.jpg)
diff --git a/examples/3.advanced.multi_devices/multi_device.cpp b/examples/3.advanced.multi_devices/multi_device.cpp
new file mode 100644
index 00000000..1e05c4b4
--- /dev/null
+++ b/examples/3.advanced.multi_devices/multi_device.cpp
@@ -0,0 +1,97 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include <libobsensor/ObSensor.hpp>
+
+#include "utils.hpp"
+#include "utils_opencv.hpp"
+
+#include <mutex>
+
+std::map<int, std::shared_ptr<const ob::Frame>> framesets;
+std::mutex                                      framesetMutex;
+
+void startStream(std::map<int, std::shared_ptr<ob::Pipeline>> &pipes) {
+
+    for(auto &item: pipes) {
+        int   deviceIndex = item.first;
+        auto &pipe        = item.second;
+
+        // config to enable depth and color streams
+        std::shared_ptr<ob::Config> config = std::make_shared<ob::Config>();
+        config->enableVideoStream(OB_STREAM_COLOR);
+        config->enableVideoStream(OB_STREAM_DEPTH);
+
+        // start pipeline and pass the callback function to receive the frames
+        pipe->start(config, [deviceIndex](std::shared_ptr<ob::FrameSet> frameSet) {
+            std::lock_guard<std::mutex> lock(framesetMutex);
+            framesets[deviceIndex] = frameSet;
+        });
+    }
+}
+
+void stopStream(std::map<int, std::shared_ptr<ob::Pipeline>> &pipes) {
+    for(auto &item: pipes) {
+        auto &pipe = item.second;
+        // stop the pipeline
+        pipe->stop();
+    }
+
+    std::lock_guard<std::mutex> lock(framesetMutex);
+    framesets.clear();
+}
+
+int main() try {
+    // Create a Context
+    ob::Context ctx;
+
+    // Query the list of connected devices
+    auto devList = ctx.queryDeviceList();
+
+    // Get the number of connected devices
+    int devCount = devList->getCount();
+
+    // Create a pipeline for each device
+    std::map<int, std::shared_ptr<ob::Pipeline>> pipes;
+    for(int i = 0; i < devCount; i++) {
+        // Get the device from device list
+        auto dev  = devList->getDevice(i);
+
+        // Create a pipeline for the device
+        auto pipe = std::make_shared<ob::Pipeline>(dev);
+
+        // Add the pipeline to the map of pipelines
+        pipes.insert({ i, pipe });
+    }
+
+    // Start the depth and color streams for all devices
+    startStream(pipes);
+
+    // Create a window for rendering and set the resolution of the window
+    ob_smpl::CVWindow win("MultiDevice", 1280, 720, ob_smpl::ARRANGE_GRID);
+
+    // Main loop to show the frames, press `ESC` to exit
+    while(win.run()) {
+        // Get the latest frames from all devices
+        for(auto &item: framesets) {
+            std::lock_guard<std::mutex> lock(framesetMutex);
+            auto                        deviceIndex = item.first;
+            auto                       &frameset    = item.second;
+
+            // push the frames to the window for show
+            win.pushFramesToView(frameset, deviceIndex);
+        }
+    }
+
+    // Stop all streams and clear the framesets
+    stopStream(pipes);
+
+    return 0;
+}
+catch(ob::Error &e) {
+    std::cerr << "function:" << e.getFunction() << "\nargs:" << e.getArgs() << "\nmessage:" << e.what() << "\ntype:" << e.getExceptionType() << std::endl;
+    std::cout << "\nPress any key to exit.";
+    ob_smpl::waitForKeyPressed();
+    exit(EXIT_FAILURE);
+}
+
diff --git a/examples/3.advanced.multi_devices_sync_gmsl/CMakeLists.txt b/examples/3.advanced.multi_devices_sync_gmsl/CMakeLists.txt
new file mode 100644
index 00000000..bdc3ffe2
--- /dev/null
+++ b/examples/3.advanced.multi_devices_sync_gmsl/CMakeLists.txt
@@ -0,0 +1,15 @@
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+cmake_minimum_required(VERSION 3.5)
+project(ob_multi_devices_sync_gmsl)
+
+add_executable(${PROJECT_NAME} ob_multi_devices_sync_gmsl.cpp utils/cJSON.c)
+
+set_property(TARGET ${PROJECT_NAME} PROPERTY CXX_STANDARD 11)
+target_link_libraries(${PROJECT_NAME} ob::OrbbecSDK ob::examples::utils)
+
+set_target_properties(${PROJECT_NAME} PROPERTIES FOLDER "examples")
+
+install(FILES ${CMAKE_CURRENT_LIST_DIR}/ob_multi_devices_sync_gmsl_config.json DESTINATION bin)
+install(TARGETS ${PROJECT_NAME} RUNTIME DESTINATION bin)
diff --git a/examples/3.advanced.multi_devices_sync_gmsl/README.md b/examples/3.advanced.multi_devices_sync_gmsl/README.md
new file mode 100644
index 00000000..c7b2e0f7
--- /dev/null
+++ b/examples/3.advanced.multi_devices_sync_gmsl/README.md
@@ -0,0 +1,252 @@
+# C++ Sample: 3.advanced.multi_devices_sync_gmsl
+
+## Overview
+
+Function description: Demonstrate multi GMSL devices synchronization operation on nvidia platform
+
+This example is based on the C++ low level API for demonstration
+
+**Note:**
+
+1.support nvidia xavier/orin platform config hardware_trigger_source
+
+2.Currently, only G335Lg GMSL devices are supported, and other GMSL devices will be supported in the near future.
+
+## Knowledge
+
+Multi-machine GMSL devices  perform frame synchronization of multi-machine depth/color/ir streams through software synchronization or hardware syncronization signal methods.
+
+## Code overview
+
+### 1.Configure multi device synchronization
+
+```cpp
+    configMultiDeviceSync();
+```
+
+### 2.Distinguishing secondary devices
+
+```cpp
+    streamDevList.clear();
+    // Query the list of connected devices
+    auto devList = context.queryDeviceList();
+  
+    // Get the number of connected devices
+    int devCount = devList->deviceCount();
+    for(int i = 0; i < devCount; i++) {
+        streamDevList.push_back(devList->getDevice(i));
+    }
+  
+    if(streamDevList.empty()) {
+        std::cerr << "Device list is empty. please check device connection state" << std::endl;
+        return -1;
+    }
+  
+    // traverse the device list and create the device
+    std::vector<std::shared_ptr<ob::Device>> primary_devices;
+    std::vector<std::shared_ptr<ob::Device>> secondary_devices;
+    for(auto dev: streamDevList) {
+        auto config = dev->getMultiDeviceSyncConfig();
+        if(config.syncMode == OB_MULTI_DEVICE_SYNC_MODE_PRIMARY) {
+            primary_devices.push_back(dev);
+        }
+        else {
+            secondary_devices.push_back(dev);
+        }
+    }
+```
+
+### 3.Enable secondary devices
+
+```cpp
+    std::cout << "Secondary devices start..." << std::endl;
+    int deviceIndex = 0;  // Sencondary device display first
+    for(auto itr = secondary_devices.begin(); itr != secondary_devices.end(); itr++) {
+        auto depthHolder = createPipelineHolder(*itr, OB_SENSOR_DEPTH, deviceIndex);
+        pipelineHolderList.push_back(depthHolder);
+        startStream(depthHolder);
+  
+        auto colorHolder = createPipelineHolder(*itr, OB_SENSOR_COLOR, deviceIndex);
+        pipelineHolderList.push_back(colorHolder);
+        startStream(colorHolder);
+  
+        deviceIndex++;
+    }
+```
+
+### 4.Enable Primary device
+
+note: G335Lg GMSL device current don`t  support primary.
+
+```cpp
+    std::cout << "Primary device start..." << std::endl;
+    deviceIndex = secondary_devices.size();  // Primary device display after primary devices.
+    for(auto itr = primary_devices.begin(); itr != primary_devices.end(); itr++) {
+        auto depthHolder = createPipelineHolder(*itr, OB_SENSOR_DEPTH, deviceIndex);
+        startStream(depthHolder);
+        pipelineHolderList.push_back(depthHolder);
+  
+        auto colorHolder = createPipelineHolder(*itr, OB_SENSOR_COLOR, deviceIndex);
+        startStream(colorHolder);
+        pipelineHolderList.push_back(colorHolder);
+  
+        deviceIndex++;
+    }
+```
+
+### 5.Set software synchronization interval time
+
+```cpp
+    // Start the multi-device time synchronization function
+    context.enableDeviceClockSync(3600000);  // update and sync every hour
+```
+
+### 6.Conduct multi device testing
+
+```cpp
+    testMultiDeviceSync();
+```
+
+### 7.Close data stream
+
+```cpp
+    // close data stream
+    for(auto itr = pipelineHolderList.begin(); itr != pipelineHolderList.end(); itr++) {
+        stopStream(*itr);
+    }
+```
+
+### 8.Triggering Mode
+
+#### Software Triggering Mode
+
+Set the device synchronization mode to `OB_MULTI_DEVICE_SYNC_MODE_SOFTWARE_TRIGGERING` after opening the stream, and the device will wait for the trigger signal (command) sent by the upper layer after opening the stream. The number of frames to be triggered for triggering mode can be configured through `framesPerTrigger`. The method for triggering images:
+
+```c++
+auto multiDeviceSyncConfig = dev->getMultiDeviceSyncConfig();
+if(multiDeviceSyncConfig.syncMode == OB_MULTI_DEVICE_SYNC_MODE_SOFTWARE_TRIGGERING)
+{
+    dev->triggerCapture();
+}
+```
+
+*Press `t` in the render window to trigger a capture once.*
+
+#### Hardware Triggering Mode
+
+Set the device synchronization mode to `OB_MULTI_DEVICE_SYNC_MODE_HARDWARE_TRIGGERING` after opening the stream, and the device will wait for the external hardware trigger signal input after opening the stream. The number of frames to be triggered for triggering mode can be configured through `framesPerTrigger`.
+
+```
+openSocSyncPwmTrigger(uint16_tfps)
+```
+
+**support nvidia xavier/orin platform config hardware_trigger_source**
+
+```
+--------------------------------------------------
+Please select options: 
+ 0 --> config devices sync mode. 
+ 1 --> start stream 
+ 2 --> start hardwareTrigger (Dependent on soc trigger source) 
+ 3 --> close hardwareTrigger & Exit program 
+--------------------------------------------------
+Please select input: 2
+```
+
+start soc pwm hardware_triggering by config HZ.
+
+config soc hardware_trigger_source hz refefence  MultiDeviceSyncConfigGmsl.json
+
+for example: "hardwareTriggerFps":3000
+
+## Run Sample
+
+```cpp
+$ ./ob_multi_devices_sync_gmsl
+
+--------------------------------------------------
+Please select options: 
+ 0 --> config devices sync mode. 
+ 1 --> start stream 
+ 2 --> start hardwareTrigger (Dependent on soc trigger source) 
+ 3 --> close hardwareTrigger & Exit program 
+--------------------------------------------------
+Please select input: 0
+
+config[0]: SN=CP4H74D0003D, mode=OB_MULTI_DEVICE_SYNC_MODE_SECONDARY
+Line:576get HardwareTriggerFps:3000 from json
+config[1]: SN=GMSL00000005, mode=OB_MULTI_DEVICE_SYNC_MODE_SECONDARY
+Line:576get HardwareTriggerFps:3000 from json
+1-Config Device syncMode:8, syncModeStr:OB_MULTI_DEVICE_SYNC_MODE_SECONDARY
+Config MultiDeviceSync Success. 
+
+
+--------------------------------------------------
+Please select options: 
+ 0 --> config devices sync mode. 
+ 1 --> start stream 
+ 2 --> start hardwareTrigger (Dependent on soc trigger source) 
+ 3 --> close hardwareTrigger & Exit program 
+--------------------------------------------------
+Please select input:
+```
+
+0:Configure program
+
+1:Start multi-machine frame synchronization and synchronization frame preview
+
+2:Start hardware trigger  frame synchronization
+
+3.Close hardware trigger and exit program.
+
+## Configuration file parameter description
+
+config file :  ob_multi_devices_sync_gmsl_config.json
+
+```
+{    "version": "1.0.0",
+    "configTime": "2023/01/01",
+    "devices": [
+        {
+            "sn": "CP4H74D0003D",
+            "syncConfig": {
+                "syncMode": "OB_MULTI_DEVICE_SYNC_MODE_SECONDARY",
+                "depthDelayUs": 0,
+                "colorDelayUs": 0,
+                "trigger2ImageDelayUs": 0,
+                "triggerOutEnable": false,
+                "triggerOutDelayUs": 0,
+                "framesPerTrigger": 30
+            }
+        },
+        {
+            "sn": "GMSL00000005",
+            "syncConfig": {
+                "syncMode": "OB_MULTI_DEVICE_SYNC_MODE_SECONDARY",
+                "depthDelayUs": 0,
+                "colorDelayUs": 0,
+                "trigger2ImageDelayUs": 0,
+                "triggerOutEnable": false,
+                "triggerOutDelayUs": 0,
+                "framesPerTrigger": 30
+            }
+        }
+    ],
+    "hardwareTriggerFps": 3000
+}
+```
+
+
+**Key parameter description**
+
+"syncConfig": {
+                "syncMode": "OB_MULTI_DEVICE_SYNC_MODE_SECONDARY",   //set multi gmsl devices sync mode
+                "depthDelayUs": 0,
+                "colorDelayUs": 0,
+                "trigger2ImageDelayUs": 0,
+                "triggerOutEnable": false,	//current gmsl device don`t support.
+                "triggerOutDelayUs": 0,
+                "framesPerTrigger": 30	//set default software trigger 30 frames per  softwaretrigger.
+            }
+
+"hardwareTriggerFps": 3000  //set default hardware soc trigger source 30FPS
diff --git a/examples/3.advanced.multi_devices_sync_gmsl/ob_multi_devices_sync_gmsl.cpp b/examples/3.advanced.multi_devices_sync_gmsl/ob_multi_devices_sync_gmsl.cpp
new file mode 100644
index 00000000..b7c39093
--- /dev/null
+++ b/examples/3.advanced.multi_devices_sync_gmsl/ob_multi_devices_sync_gmsl.cpp
@@ -0,0 +1,707 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+/*
+Notes: ob_multi_devices_sync_gmsl.cpp for GMSL device
+on the nvidia arm64 xavier/orin platform ,this example demo sync multi gmsl devices.
+*/
+#include <libobsensor/ObSensor.hpp>
+
+#include "utils.hpp"
+#include "utils_opencv.hpp"
+#include "utils/cJSON.h"
+
+#include <string>
+#include <vector>
+#include <map>
+#include <algorithm>
+#include <fstream>
+#include <thread>
+#include <mutex>
+#include <condition_variable>
+#include <functional>
+#include <iostream>
+#include <chrono>
+
+#ifdef __linux__
+#include <unistd.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <sstream>
+#include <cstdlib>
+#include <strings.h>
+#endif
+
+#define MAX_DEVICE_COUNT 9
+#define CONFIG_FILE "./ob_multi_devices_sync_gmsl_config.json"
+#define DEVICE_PATH "/dev/camsync"
+#define KEY_ESC 27
+
+static bool quitStreamPreview = false;
+
+const std::string GMSL2_DEVICE_TAG= "GMSL2";
+
+const std::map<std::string, uint16_t> gemini_330_list = {
+    { "gemini335", 0x0800 }, { "gemini335L", 0x0804 }, { "gemini336", 0x0803 }, { "gemini336L", 0x0807 }, { "gemini335Lg", 0x080B }
+};
+
+typedef struct DeviceConfigInfo_t {
+    std::string             deviceSN;
+    OBMultiDeviceSyncConfig syncConfig;
+} DeviceConfigInfo;
+
+typedef struct PipelineHolder_t {
+    std::shared_ptr<ob::Pipeline> pipeline;
+    OBSensorType                  sensorType;
+    int                           deviceIndex;
+    std::string                   deviceSN;
+} PipelineHolder;
+std::ostream &operator<<(std::ostream &os, const PipelineHolder &holder);
+std::ostream &operator<<(std::ostream &os, std::shared_ptr<PipelineHolder> holder) {
+    return os << *holder;
+}
+
+std::mutex                                    frameMutex;
+std::map<uint8_t, std::shared_ptr<ob::Frame>> colorFrames;
+std::map<uint8_t, std::shared_ptr<ob::Frame>> depthFrames;
+
+std::vector<std::shared_ptr<ob::Device>>       streamDevList;
+std::vector<std::shared_ptr<ob::Device>>       configDevList;
+std::vector<std::shared_ptr<DeviceConfigInfo>> deviceConfigList;
+
+std::condition_variable                      waitRebootCompleteCondition;
+std::mutex                                   rebootingDevInfoListMutex;
+std::vector<std::shared_ptr<ob::DeviceInfo>> rebootingDevInfoList;
+std::vector<std::shared_ptr<PipelineHolder>> pipelineHolderList;
+
+bool loadConfigFile();
+int  configMultiDeviceSync();
+int  testMultiDeviceSync();
+
+void startStream(std::shared_ptr<PipelineHolder> pipelineHolder);
+void stopStream(std::shared_ptr<PipelineHolder> pipelineHolder);
+
+void handleColorStream(int devIndex, std::shared_ptr<ob::Frame> frame);
+void handleDepthStream(int devIndex, std::shared_ptr<ob::Frame> frame);
+
+std::string           OBSyncModeToString(const OBMultiDeviceSyncMode syncMode);
+OBMultiDeviceSyncMode stringToOBSyncMode(const std::string &modeString);
+
+OBFrameType mapFrameType(OBSensorType sensorType);
+std::string readFileContent(const char *filePath);
+
+int  strcmp_nocase(const char *str0, const char *str1);
+bool checkDevicesWithDeviceConfigs(const std::vector<std::shared_ptr<ob::Device>> &deviceList);
+
+std::shared_ptr<PipelineHolder> createPipelineHolder(std::shared_ptr<ob::Device> device, OBSensorType sensorType, int deviceIndex);
+
+ob::Context context;
+
+bool IsGemini330Series(uint16_t pid) {
+    bool find = false;
+    for(auto it = gemini_330_list.begin(); it != gemini_330_list.end(); ++it) {
+        if(it->second == pid) {
+            // std::cout << "find gemini 330 series : " << it->first << std::endl;
+            find = true;
+            break;
+        }
+    }
+    return find;
+}
+
+
+int triggerFd = -1;
+int hardwareTriggerFps = 0;  // 0 means hardware trigger is disabled
+typedef struct {
+    uint8_t  mode;
+    uint16_t fps;
+} cs_param_t;
+
+// cs_param_t rd_par = {0, 0}, param = {1, 3000}; //30
+int openSocSyncPwmTrigger(uint16_t fps) {
+    const char *devicePath           = DEVICE_PATH;
+    const int   TRIGGER_MODE_ENABLE  = 1;
+    const int   TRIGGER_MODE_DISABLE = 0;
+
+    int        ret    = -1;
+    cs_param_t param  = { TRIGGER_MODE_ENABLE, fps };
+    cs_param_t rd_par = { TRIGGER_MODE_DISABLE, 0 };
+
+    if(access(devicePath, F_OK) != 0) {
+        std::cerr << "Device node " << devicePath << " does not exist." << std::endl;
+        return ret;
+    }
+    triggerFd = open(DEVICE_PATH, O_RDWR);
+    if(triggerFd < 0) {
+        perror("open device failed\n");
+        return triggerFd;
+    }
+
+    std::cout << "Written param mode=" << param.mode << ", fps=" << param.fps << std::endl;
+    ret = write(triggerFd, &param, sizeof(param));
+    if(ret < 0) {
+        perror("write device failed\n");
+        close(triggerFd);
+        return ret;
+    }
+
+    ret = read(triggerFd, &rd_par, sizeof(rd_par));
+    if(ret < 0) {
+        perror("read device failed\n");
+        close(triggerFd);
+        return ret;
+    }
+    std::cout << "Read param mode=" << rd_par.mode << ", fps=" << rd_par.fps << std::endl;
+
+    std::cout << "Start hardware triggering..." << std::endl;
+
+    return 0;
+}
+int closeSocSyncPwmTrigger() {
+    if(triggerFd >= 0) {
+        close(triggerFd);
+        triggerFd = -1;  // Reset file descriptors
+        std::cout << "close camSync success" << std::endl;
+        return 0;
+    }
+    return -1;
+}
+
+int main(void) try {
+    int                       choice;
+    int                       exitValue      = 0;
+    constexpr std::streamsize maxInputIgnore = 10000;
+
+    while(true) {
+        std::cout << "\n--------------------------------------------------\n";
+        std::cout << "Please select options: \n";
+        std::cout << " 0 --> config devices sync mode. \n";
+        std::cout << " 1 --> start stream \n";
+        std::cout << " 2 --> start hardwareTrigger (Dependent on soc trigger source) \n";
+        std::cout << " 3 --> close hardwareTrigger & Exit program \n";
+        std::cout << "--------------------------------------------------\n";
+        std::cout << "Please select input: ";
+        // std::cin >> choice;
+        if(!(std::cin >> choice)) {
+            std::cin.clear();
+            std::cin.ignore(maxInputIgnore, '\n');
+            std::cout << "Invalid input. Please enter a number [0~3]." << std::endl;
+            continue;
+        }
+        std::cout << std::endl;
+
+        switch(choice) {
+        case 0:
+            exitValue = configMultiDeviceSync();
+            if(exitValue == 0) {
+                std::cout << "Config MultiDeviceSync Success. \n" << std::endl;
+            }
+            break;
+        case 1:
+            std::cout << "\nStart Slave Devices video stream." << std::endl;
+            testMultiDeviceSync();
+            break;
+        case 2:
+            if(!loadConfigFile()) {
+                std::cout << "load config failed" << std::endl;
+                return -1;
+            }
+            if(hardwareTriggerFps > 0) {
+                std::cout << "\nStart HardwareTrigger by soc-trigger-source. triggerFps:" << hardwareTriggerFps << std::endl;
+                openSocSyncPwmTrigger(hardwareTriggerFps);
+            }
+            else {
+                std::cout << "Please repeat set hardwareTriggerFps (0 to disable): ";
+                std::cin >> hardwareTriggerFps;
+                std::cout << "You has set hardwareTriggerFps: " << hardwareTriggerFps << std::endl;
+            }
+            break;
+        case 3:
+            closeSocSyncPwmTrigger();
+            std::cout << "Program exit & close device! " << std::endl;
+            exit(0);
+            return 0;
+
+        default:
+            std::cout << "-input Invalid index. \n"
+                      << "-Please re-select and input valid param. \n";
+        }
+    }
+    return exitValue;
+}
+catch(ob::Error &e) {
+    std::cerr << "function:" << e.getFunction() << "\nargs:" << e.getArgs() << "\nmessage:" << e.what() << "\ntype:" << e.getExceptionType() << std::endl;
+    std::cout << "\nPress any key to exit.";
+    ob_smpl::waitForKeyPressed();
+    exit(EXIT_FAILURE);
+}
+
+int configMultiDeviceSync() {
+    try {
+        if(!loadConfigFile()) {
+            std::cout << "load config failed" << std::endl;
+            return -1;
+        }
+
+        if(deviceConfigList.empty()) {
+            std::cout << "DeviceConfigList is empty. please check config file: " << CONFIG_FILE << std::endl;
+            return -1;
+        }
+
+        // Query the list of connected devices
+        auto devList  = context.queryDeviceList();
+        int  devCount = devList->deviceCount();
+        for(int i = 0; i < devCount; i++) {
+            std::shared_ptr<ob::Device> device = devList->getDevice(i);
+            auto pid = device->getDeviceInfo()->getPid();
+            if(!IsGemini330Series(pid)){
+                std::cout << "Device pid: " << pid << " is not Gemini 330 series, skip" << std::endl;
+                continue;
+            }
+            auto ConnectionType = device->getDeviceInfo()->getConnectionType();
+            std::cout << "Device ConnectionType: " << ConnectionType << std::endl;
+            if( ConnectionType != GMSL2_DEVICE_TAG) {
+                std::cout << "Device ConnectionType: " << ConnectionType << " is not GMSL2 devices, skip" << std::endl;
+                continue;
+            }
+
+            configDevList.push_back(devList->getDevice(i));
+        }
+
+        if(configDevList.empty()) {
+            std::cerr << "Device list is empty. please check device connection state" << std::endl;
+            return -1;
+        }
+
+        // write configuration to device
+        for(auto config: deviceConfigList) {
+            auto findItr = std::find_if(configDevList.begin(), configDevList.end(), [config](std::shared_ptr<ob::Device> device) {
+                auto serialNumber = device->getDeviceInfo()->serialNumber();
+                return strcmp_nocase(serialNumber, config->deviceSN.c_str()) == 0;
+            });
+            if(findItr != configDevList.end()) {
+                auto device    = (*findItr);
+                auto curConfig = device->getMultiDeviceSyncConfig();
+                // Update the configuration items of the configuration file, and keep the original configuration for other items
+                curConfig.syncMode             = config->syncConfig.syncMode;
+                curConfig.depthDelayUs         = config->syncConfig.depthDelayUs;
+                curConfig.colorDelayUs         = config->syncConfig.colorDelayUs;
+                curConfig.trigger2ImageDelayUs = config->syncConfig.trigger2ImageDelayUs;
+                curConfig.triggerOutEnable     = config->syncConfig.triggerOutEnable;
+                curConfig.triggerOutDelayUs    = config->syncConfig.triggerOutDelayUs;
+                curConfig.framesPerTrigger     = config->syncConfig.framesPerTrigger;
+                std::cout << "-Config Device syncMode:" << curConfig.syncMode << ", syncModeStr:" << OBSyncModeToString(curConfig.syncMode) << std::endl;
+                device->setMultiDeviceSyncConfig(curConfig);
+            }
+            std::this_thread::sleep_for(std::chrono::milliseconds(10));
+        }
+        return 0;
+    }
+    catch(ob::Error &e) {
+        std::cerr << "configMultiDeviceSync failed! \n";
+        std::cerr << "function:" << e.getName() << "\nargs:" << e.getArgs() << "\nmessage:" << e.getMessage() << "\ntype:" << e.getExceptionType() << std::endl;
+        return -1;
+    }
+}
+
+void startDeviceStreams(const std::vector<std::shared_ptr<ob::Device>> &devices, int startIndex) {
+    std::vector<OBSensorType> sensorTypes = { OB_SENSOR_DEPTH, OB_SENSOR_COLOR };
+    for(auto &dev: devices) {
+        for(auto sensorType: sensorTypes) {
+            auto holder = createPipelineHolder(dev, sensorType, startIndex);
+            pipelineHolderList.push_back(holder);
+            startStream(holder);
+        }
+        startIndex++;
+    }
+    quitStreamPreview = false;
+}
+
+// key press event processing
+void handleKeyPress(ob_smpl::CVWindow &win, int key) {
+    //Get the key value
+    if(key == KEY_ESC) {
+        if(!quitStreamPreview){
+            win.setShowInfo(false);
+            win.setShowSyncTimeInfo(false);
+            quitStreamPreview = true;
+            win.close();
+            win.destroyWindow();
+            std::cout << "press ESC quitStreamPreview" << std::endl;
+        }
+    }
+    else if(key == 'S' || key == 's') {
+        std::cout << "syncDevicesTime..." << std::endl;
+        context.enableDeviceClockSync(3600000);  // Manual update synchronization
+    }
+    else if(key == 'T' || key == 't') {
+        // software trigger
+        std::cout << "check software trigger mode" << std::endl;
+        for(auto &dev: streamDevList) {
+            auto multiDeviceSyncConfig = dev->getMultiDeviceSyncConfig();
+            if(multiDeviceSyncConfig.syncMode == OB_MULTI_DEVICE_SYNC_MODE_SOFTWARE_TRIGGERING) {
+                std::cout << "software trigger..." << std::endl;
+                dev->triggerCapture();
+            }
+        }
+    }
+}
+
+int testMultiDeviceSync() {
+    try {
+        streamDevList.clear();
+        // Query the list of connected devices
+        auto devList  = context.queryDeviceList();
+        int  devCount = devList->deviceCount();
+        for(int i = 0; i < devCount; i++) {
+            streamDevList.push_back(devList->getDevice(i));
+        }
+
+        if(streamDevList.empty()) {
+            std::cerr << "Device list is empty. please check device connection state" << std::endl;
+            return -1;
+        }
+
+        // traverse the device list and create the device
+        std::vector<std::shared_ptr<ob::Device>> primary_devices;
+        std::vector<std::shared_ptr<ob::Device>> secondary_devices;
+        for(auto dev: streamDevList) {
+            auto config = dev->getMultiDeviceSyncConfig();
+            if(config.syncMode == OB_MULTI_DEVICE_SYNC_MODE_PRIMARY) {
+                primary_devices.push_back(dev);
+            }
+            else {
+                secondary_devices.push_back(dev);
+            }
+        }
+
+        std::cout << "Secondary devices start..." << std::endl;
+        startDeviceStreams(secondary_devices, 0);
+
+        // Delay and wait for 5s to ensure that the initialization of the slave device is completed
+        //std::this_thread::sleep_for(std::chrono::milliseconds(5000));
+
+        if(primary_devices.empty()) {
+            std::cerr << "WARNING primary_devices is empty!!!" << std::endl;
+        } else {
+            std::cout << "Primary device start..." << std::endl;
+            startDeviceStreams(primary_devices, secondary_devices.size());
+        }
+
+        // Start the multi-device time synchronization function
+        context.enableDeviceClockSync(60000);  // update and sync every minitor
+
+        // Create a window for rendering and set the resolution of the window
+        ob_smpl::CVWindow win("MultiDeviceSyncViewer", 1600, 900, ob_smpl::ARRANGE_GRID);
+
+        // set key prompt
+        win.setKeyPrompt("'S': syncDevicesTime, 'T': software triiger");
+        // set the callback function for the window to handle key press events
+        win.setKeyPressedCallback([&](int key){ handleKeyPress(win, key); });
+
+        win.setShowInfo(true);
+        win.setShowSyncTimeInfo(true);
+        while(win.run() && !quitStreamPreview) {
+            if(quitStreamPreview){
+                break;
+            }
+            std::vector<std::pair<std::shared_ptr<ob::Frame>, std::shared_ptr<ob::Frame>>> framePairs;
+            {
+                std::lock_guard<std::mutex> lock(frameMutex);
+                for(int i = 0; i < std::min(MAX_DEVICE_COUNT, (int)depthFrames.size()); i++) {
+                    if(depthFrames[i] != nullptr && colorFrames[i] != nullptr) {
+                        framePairs.emplace_back(depthFrames[i], colorFrames[i]);
+                    }
+                }
+            }
+            auto groudID = 0;
+            for(const auto &pair: framePairs) {
+                groudID++;
+                win.pushFramesToView({ pair.first, pair.second }, groudID);
+            }
+        }
+
+        // Stop streams and clear resources
+        for(auto &holder: pipelineHolderList) {
+            stopStream(holder);
+        }
+        pipelineHolderList.clear();
+        depthFrames.clear();
+        colorFrames.clear();      
+
+        // Release resource
+        streamDevList.clear();
+        configDevList.clear();
+        deviceConfigList.clear();
+        return 0;
+    }
+    catch(ob::Error &e) {
+        std::cerr << "function:" << e.getName() << "\nargs:" << e.getArgs() << "\nmessage:" << e.getMessage() << "\ntype:" << e.getExceptionType() << std::endl;
+        std::cout << "\nPress any key to exit.";
+        ob_smpl::waitForKeyPressed();
+        exit(EXIT_FAILURE);
+        return -1;
+    }
+}
+
+std::shared_ptr<PipelineHolder> createPipelineHolder(std::shared_ptr<ob::Device> device, OBSensorType sensorType, int deviceIndex) {
+    auto holder         = std::make_shared<PipelineHolder>();
+    holder->pipeline    = std::make_shared<ob::Pipeline>(device);
+    holder->sensorType  = sensorType;
+    holder->deviceIndex = deviceIndex;
+    holder->deviceSN    = device->getDeviceInfo()->serialNumber();
+    return holder;
+}
+
+void processFrame(std::shared_ptr<ob::FrameSet> frameSet, OBFrameType frameType, int deviceIndex) {
+    if(!frameSet) {
+        std::cerr << "Invalid frameSet received." << std::endl;
+        return;
+    }
+
+    if(quitStreamPreview){
+        //std::cerr << "press ESC quit Stream ProcessFrame." << std::endl;
+        return;
+    }
+
+    auto frame = frameSet->getFrame(frameType);
+    if(frame) {
+        if(frameType == OB_FRAME_COLOR) {
+            handleColorStream(deviceIndex, frame);
+        }
+        else if(frameType == OB_FRAME_DEPTH) {
+            handleDepthStream(deviceIndex, frame);
+        }
+    }
+}
+
+void handleStreamError(const ob::Error &e) {
+    // Separate error handling logic
+    std::cerr << "Function: " << e.getName() << "\nArgs: " << e.getArgs() << "\nMessage: " << e.getMessage() << "\nType: " << e.getExceptionType() << std::endl;
+}
+
+void startStream(std::shared_ptr<PipelineHolder> holder) {
+    std::cout << "startStream. " << holder << std::endl;
+    try {
+        auto pipeline      = holder->pipeline;
+        auto profileList   = pipeline->getStreamProfileList(holder->sensorType);
+        auto streamProfile = profileList->getProfile(OB_PROFILE_DEFAULT)->as<ob::VideoStreamProfile>();
+        auto frameType     = mapFrameType(holder->sensorType);
+        auto deviceIndex   = holder->deviceIndex;
+
+        std::shared_ptr<ob::Config> config = std::make_shared<ob::Config>();
+        config->enableStream(streamProfile);
+
+        pipeline->start(config, [frameType, deviceIndex](std::shared_ptr<ob::FrameSet> frameSet) { processFrame(frameSet, frameType, deviceIndex); });
+    }
+    catch(ob::Error &e) {
+        std::cerr << "starting stream failed: " << holder << std::endl;
+        handleStreamError(e);
+    }
+}
+
+void stopStream(std::shared_ptr<PipelineHolder> holder) {
+    try {
+        std::cout << "stopStream " << holder << std::endl;
+        holder->pipeline->stop();
+    }
+    catch(ob::Error &e) {
+        std::cerr << "stopping stream failed: " << holder << std::endl;
+        std::cerr << "function:" << e.getName() << "\nargs:" << e.getArgs() << "\nmessage:" << e.getMessage() << "\ntype:" << e.getExceptionType() << std::endl;
+    }
+}
+
+void handleStream(int devIndex, std::shared_ptr<ob::Frame> frame, const char *frameType) {
+    std::lock_guard<std::mutex> lock(frameMutex);
+    std::cout << "Device#" << devIndex << ", " << frameType << " frame "
+              << ", frame timestamp=" << frame->timeStamp() << ", system timestamp=" << frame->systemTimeStamp() << std::endl;
+
+    if(strcmp(frameType, "color") == 0) {
+        colorFrames[devIndex] = frame;
+    }
+    else if(strcmp(frameType, "depth") == 0) {
+        depthFrames[devIndex] = frame;
+    }
+}
+
+void handleColorStream(int devIndex, std::shared_ptr<ob::Frame> frame) {
+    handleStream(devIndex, frame, "color");
+}
+
+void handleDepthStream(int devIndex, std::shared_ptr<ob::Frame> frame) {
+    handleStream(devIndex, frame, "depth");
+}
+std::string readFileContent(const char *filePath) {
+    std::ostringstream oss;
+    std::ifstream      file(filePath, std::fstream::in);
+    if(!file.is_open()) {
+        std::cerr << "Failed to open file: " << filePath << std::endl;
+        return "";
+    }
+    oss << file.rdbuf();
+    file.close();
+    return oss.str();
+}
+
+bool loadConfigFile() {
+    int                               deviceCount   = 0;
+    std::shared_ptr<DeviceConfigInfo> devConfigInfo = nullptr;
+    cJSON *                           deviceElem    = nullptr;
+
+    auto content = readFileContent(CONFIG_FILE);
+    if(content.empty()) {
+        std::cerr << "load config file failed." << std::endl;
+        return false;
+    }
+
+    cJSON *rootElem = cJSON_Parse(content.c_str());
+    if(rootElem == nullptr) {
+        const char *errMsg = cJSON_GetErrorPtr();
+        std::cout << std::string(errMsg) << std::endl;
+        cJSON_Delete(rootElem);
+        return true;
+    }
+
+    cJSON *devicesElem = cJSON_GetObjectItem(rootElem, "devices");
+    cJSON_ArrayForEach(deviceElem, devicesElem) {
+        devConfigInfo = std::make_shared<DeviceConfigInfo>();
+        memset(&devConfigInfo->syncConfig, 0, sizeof(devConfigInfo->syncConfig));
+        devConfigInfo->syncConfig.syncMode = OB_MULTI_DEVICE_SYNC_MODE_FREE_RUN;
+
+        cJSON *snElem = cJSON_GetObjectItem(deviceElem, "sn");
+        if(cJSON_IsString(snElem) && snElem->valuestring != nullptr) {
+            devConfigInfo->deviceSN = std::string(snElem->valuestring);
+        }
+        cJSON *deviceConfigElem = cJSON_GetObjectItem(deviceElem, "syncConfig");
+        if(cJSON_IsObject(deviceConfigElem)) {
+            cJSON *numberElem = nullptr;
+            cJSON *strElem    = nullptr;
+            cJSON *bElem      = nullptr;
+            strElem           = cJSON_GetObjectItemCaseSensitive(deviceConfigElem, "syncMode");
+            if(cJSON_IsString(strElem) && strElem->valuestring != nullptr) {
+                devConfigInfo->syncConfig.syncMode = stringToOBSyncMode(strElem->valuestring);
+                std::cout << "config[" << (deviceCount++) << "]: SN=" << std::string(devConfigInfo->deviceSN) << ", mode=" << strElem->valuestring << std::endl;
+            }
+            numberElem = cJSON_GetObjectItemCaseSensitive(deviceConfigElem, "depthDelayUs");
+            if(cJSON_IsNumber(numberElem)) {
+                devConfigInfo->syncConfig.depthDelayUs = numberElem->valueint;
+            }
+            numberElem = cJSON_GetObjectItemCaseSensitive(deviceConfigElem, "colorDelayUs");
+            if(cJSON_IsNumber(numberElem)) {
+                devConfigInfo->syncConfig.colorDelayUs = numberElem->valueint;
+            }
+            numberElem = cJSON_GetObjectItemCaseSensitive(deviceConfigElem, "trigger2ImageDelayUs");
+            if(cJSON_IsNumber(numberElem)) {
+                devConfigInfo->syncConfig.trigger2ImageDelayUs = numberElem->valueint;
+            }
+            numberElem = cJSON_GetObjectItemCaseSensitive(deviceConfigElem, "triggerOutDelayUs");
+            if(cJSON_IsNumber(numberElem)) {
+                devConfigInfo->syncConfig.triggerOutDelayUs = numberElem->valueint;
+            }
+            bElem = cJSON_GetObjectItemCaseSensitive(deviceConfigElem, "triggerOutEnable");
+            if(cJSON_IsBool(bElem)) {
+                devConfigInfo->syncConfig.triggerOutEnable = (bool)bElem->valueint;
+            }
+            bElem = cJSON_GetObjectItemCaseSensitive(deviceConfigElem, "framesPerTrigger");
+            if(cJSON_IsNumber(bElem)) {
+                devConfigInfo->syncConfig.framesPerTrigger = bElem->valueint;
+            }
+        }
+        cJSON *hardwareTriggerFpsElem = nullptr;
+        hardwareTriggerFpsElem        = cJSON_GetObjectItemCaseSensitive(rootElem, "hardwareTriggerFps");
+        if(cJSON_IsNumber(hardwareTriggerFpsElem)) {
+            hardwareTriggerFps = hardwareTriggerFpsElem->valueint;
+            std::cout << "From json get HardwareTriggerFps=" << hardwareTriggerFps << std::endl;
+        }
+
+        if(OB_MULTI_DEVICE_SYNC_MODE_FREE_RUN != devConfigInfo->syncConfig.syncMode) {
+            deviceConfigList.push_back(devConfigInfo);
+        }
+        else {
+            std::cerr << "Invalid sync mode of deviceSN: " << devConfigInfo->deviceSN << std::endl;
+        }
+        devConfigInfo = nullptr;
+    }
+    cJSON_Delete(rootElem);
+    return true;
+}
+
+OBMultiDeviceSyncMode stringToOBSyncMode(const std::string &modeString) {
+    static const std::unordered_map<std::string, OBMultiDeviceSyncMode> syncModeMap = {
+        { "OB_MULTI_DEVICE_SYNC_MODE_FREE_RUN", OB_MULTI_DEVICE_SYNC_MODE_FREE_RUN },
+        { "OB_MULTI_DEVICE_SYNC_MODE_STANDALONE", OB_MULTI_DEVICE_SYNC_MODE_STANDALONE },
+        { "OB_MULTI_DEVICE_SYNC_MODE_PRIMARY", OB_MULTI_DEVICE_SYNC_MODE_PRIMARY },
+        { "OB_MULTI_DEVICE_SYNC_MODE_SECONDARY", OB_MULTI_DEVICE_SYNC_MODE_SECONDARY },
+        { "OB_MULTI_DEVICE_SYNC_MODE_SECONDARY_SYNCED", OB_MULTI_DEVICE_SYNC_MODE_SECONDARY_SYNCED },
+        { "OB_MULTI_DEVICE_SYNC_MODE_SOFTWARE_TRIGGERING", OB_MULTI_DEVICE_SYNC_MODE_SOFTWARE_TRIGGERING },
+        { "OB_MULTI_DEVICE_SYNC_MODE_HARDWARE_TRIGGERING", OB_MULTI_DEVICE_SYNC_MODE_HARDWARE_TRIGGERING }
+    };
+    auto it = syncModeMap.find(modeString);
+    if(it != syncModeMap.end()) {
+        return it->second;
+    }
+    // Constructing exception messages with stringstream
+    std::stringstream ss;
+    ss << "Unrecognized sync mode: " << modeString;
+    throw std::invalid_argument(ss.str());
+}
+
+std::string OBSyncModeToString(const OBMultiDeviceSyncMode syncMode) {
+    static const std::unordered_map<OBMultiDeviceSyncMode, std::string> modeToStringMap = {
+        { OB_MULTI_DEVICE_SYNC_MODE_FREE_RUN, "OB_MULTI_DEVICE_SYNC_MODE_FREE_RUN" },
+        { OB_MULTI_DEVICE_SYNC_MODE_STANDALONE, "OB_MULTI_DEVICE_SYNC_MODE_STANDALONE" },
+        { OB_MULTI_DEVICE_SYNC_MODE_PRIMARY, "OB_MULTI_DEVICE_SYNC_MODE_PRIMARY" },
+        { OB_MULTI_DEVICE_SYNC_MODE_SECONDARY, "OB_MULTI_DEVICE_SYNC_MODE_SECONDARY" },
+        { OB_MULTI_DEVICE_SYNC_MODE_SECONDARY_SYNCED, "OB_MULTI_DEVICE_SYNC_MODE_SECONDARY_SYNCED" },
+        { OB_MULTI_DEVICE_SYNC_MODE_SOFTWARE_TRIGGERING, "OB_MULTI_DEVICE_SYNC_MODE_SOFTWARE_TRIGGERING" },
+        { OB_MULTI_DEVICE_SYNC_MODE_HARDWARE_TRIGGERING, "OB_MULTI_DEVICE_SYNC_MODE_HARDWARE_TRIGGERING" }
+    };
+
+    auto it = modeToStringMap.find(syncMode);
+    if(it != modeToStringMap.end()) {
+        return it->second;
+    }
+    std::stringstream ss;
+    ss << "Unmapped sync mode value: " << static_cast<int>(syncMode) << ". Please check the sync mode value.";
+    throw std::invalid_argument(ss.str());
+}
+
+int strcmp_nocase(const char *str0, const char *str1) {
+    return strcasecmp(str0, str1);
+}
+
+OBFrameType mapFrameType(OBSensorType sensorType) {
+    switch(sensorType) {
+    case OB_SENSOR_COLOR:
+        return OB_FRAME_COLOR;
+    case OB_SENSOR_IR:
+        return OB_FRAME_IR;
+    case OB_SENSOR_IR_LEFT:
+        return OB_FRAME_IR_LEFT;
+    case OB_SENSOR_IR_RIGHT:
+        return OB_FRAME_IR_RIGHT;
+    case OB_SENSOR_DEPTH:
+        return OB_FRAME_DEPTH;
+    default:
+        return OBFrameType::OB_FRAME_UNKNOWN;
+    }
+}
+
+std::ostream &operator<<(std::ostream &os, const PipelineHolder &holder) {
+    if(os.good()) {
+        os << "deviceSN: " << holder.deviceSN << ", sensorType: ";
+        switch(holder.sensorType) {
+        case OB_SENSOR_COLOR:
+            os << "OB_SENSOR_COLOR";
+            break;
+        case OB_SENSOR_DEPTH:
+            os << "OB_SENSOR_DEPTH";
+            break;
+        default:
+            os << static_cast<int>(holder.sensorType);
+            break;
+        }
+        os << ", deviceIndex: " << holder.deviceIndex;
+    }
+    return os;
+}
diff --git a/examples/3.advanced.multi_devices_sync_gmsl/ob_multi_devices_sync_gmsl_config.json b/examples/3.advanced.multi_devices_sync_gmsl/ob_multi_devices_sync_gmsl_config.json
new file mode 100644
index 00000000..fe6c01b5
--- /dev/null
+++ b/examples/3.advanced.multi_devices_sync_gmsl/ob_multi_devices_sync_gmsl_config.json
@@ -0,0 +1,31 @@
+{
+    "version": "1.0.0",
+    "configTime": "2023/01/01",
+    "devices": [
+        {
+            "sn": "CP4H74D0003D",
+            "syncConfig": {
+                "syncMode": "OB_MULTI_DEVICE_SYNC_MODE_SECONDARY",
+                "depthDelayUs": 0,
+                "colorDelayUs": 0,
+                "trigger2ImageDelayUs": 0,
+                "triggerOutEnable": false,
+                "triggerOutDelayUs": 0,
+                "framesPerTrigger": 30
+            }
+        },
+        {
+            "sn": "GMSL00000005",
+            "syncConfig": {
+                "syncMode": "OB_MULTI_DEVICE_SYNC_MODE_SECONDARY",
+                "depthDelayUs": 0,
+                "colorDelayUs": 0,
+                "trigger2ImageDelayUs": 0,
+                "triggerOutEnable": false,
+                "triggerOutDelayUs": 0,
+                "framesPerTrigger": 30
+            }
+        }
+    ],
+    "hardwareTriggerFps": 3000
+}
\ No newline at end of file
diff --git a/examples/3.advanced.multi_devices_sync_gmsl/utils/cJSON.c b/examples/3.advanced.multi_devices_sync_gmsl/utils/cJSON.c
new file mode 100644
index 00000000..4a338dbe
--- /dev/null
+++ b/examples/3.advanced.multi_devices_sync_gmsl/utils/cJSON.c
@@ -0,0 +1,2667 @@
+/*
+  Copyright (c) 2009-2017 Dave Gamble and cJSON contributors
+
+  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.
+*/
+
+/* cJSON */
+/* JSON parser in C. */
+
+/* disable warnings about old C89 functions in MSVC */
+#if !defined(_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
+#define _CRT_SECURE_NO_DEPRECATE
+#endif
+
+#ifdef __GNUC__
+#pragma GCC visibility push(default)
+#endif
+#if defined(_MSC_VER)
+#pragma warning(push)
+/* disable warning about single line comments in system headers */
+#pragma warning(disable : 4001)
+#endif
+
+#include <string.h>
+#include <stdio.h>
+#include <math.h>
+#include <stdlib.h>
+#include <limits.h>
+#include <ctype.h>
+#include <float.h>
+
+#ifdef ENABLE_LOCALES
+#include <locale.h>
+#endif
+
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif
+#ifdef __GNUC__
+#pragma GCC visibility pop
+#endif
+
+#include "cJSON.h"
+
+/* define our own boolean type */
+#ifdef true
+#undef true
+#endif
+#define true ((cJSON_bool)1)
+
+#ifdef false
+#undef false
+#endif
+#define false ((cJSON_bool)0)
+
+/* define isnan and isinf for ANSI C, if in C99 or above, isnan and isinf has been defined in math.h */
+#ifndef isinf
+#define isinf(d) (isnan((d - d)) && !isnan(d))
+#endif
+#ifndef isnan
+#define isnan(d) (d != d)
+#endif
+
+#ifndef NAN
+#ifdef _WIN32
+#define NAN sqrt(-1.0)
+#else
+#define NAN 0.0 / 0.0
+#endif
+#endif
+
+typedef struct {
+    const unsigned char *json;
+    size_t               position;
+} error;
+static error global_error = { NULL, 0 };
+
+CJSON_PUBLIC(const char *) cJSON_GetErrorPtr(void) {
+    return (const char *)(global_error.json + global_error.position);
+}
+
+CJSON_PUBLIC(char *) cJSON_GetStringValue(const cJSON *const item) {
+    if(!cJSON_IsString(item)) {
+        return NULL;
+    }
+
+    return item->valuestring;
+}
+
+CJSON_PUBLIC(double) cJSON_GetNumberValue(const cJSON *const item) {
+    if(!cJSON_IsNumber(item)) {
+        return (double)NAN;
+    }
+
+    return item->valuedouble;
+}
+
+/* This is a safeguard to prevent copy-pasters from using incompatible C and header files */
+#if(CJSON_VERSION_MAJOR != 1) || (CJSON_VERSION_MINOR != 7) || (CJSON_VERSION_PATCH != 15)
+#error cJSON.h and cJSON.c have different versions. Make sure that both have the same.
+#endif
+
+CJSON_PUBLIC(const char *) cJSON_Version(void) {
+    static char version[15];
+    sprintf(version, "%i.%i.%i", CJSON_VERSION_MAJOR, CJSON_VERSION_MINOR, CJSON_VERSION_PATCH);
+
+    return version;
+}
+
+/* Case insensitive string comparison, doesn't consider two NULL pointers equal though */
+static int case_insensitive_strcmp(const unsigned char *string1, const unsigned char *string2) {
+    if((string1 == NULL) || (string2 == NULL)) {
+        return 1;
+    }
+
+    if(string1 == string2) {
+        return 0;
+    }
+
+    for(; tolower(*string1) == tolower(*string2); (void)string1++, string2++) {
+        if(*string1 == '\0') {
+            return 0;
+        }
+    }
+
+    return tolower(*string1) - tolower(*string2);
+}
+
+typedef struct internal_hooks {
+    void *(CJSON_CDECL *allocate)(size_t size);
+    void(CJSON_CDECL *deallocate)(void *pointer);
+    void *(CJSON_CDECL *reallocate)(void *pointer, size_t size);
+} internal_hooks;
+
+#if defined(_MSC_VER)
+/* work around MSVC error C2322: '...' address of dllimport '...' is not static */
+static void *CJSON_CDECL internal_malloc(size_t size) {
+    return malloc(size);
+}
+static void CJSON_CDECL internal_free(void *pointer) {
+    free(pointer);
+}
+static void *CJSON_CDECL internal_realloc(void *pointer, size_t size) {
+    return realloc(pointer, size);
+}
+#else
+#define internal_malloc malloc
+#define internal_free free
+#define internal_realloc realloc
+#endif
+
+/* strlen of character literals resolved at compile time */
+#define static_strlen(string_literal) (sizeof(string_literal) - sizeof(""))
+
+static internal_hooks global_hooks = { internal_malloc, internal_free, internal_realloc };
+
+static unsigned char *cJSON_strdup(const unsigned char *string, const internal_hooks *const hooks) {
+    size_t         length = 0;
+    unsigned char *copy   = NULL;
+
+    if(string == NULL) {
+        return NULL;
+    }
+
+    length = strlen((const char *)string) + sizeof("");
+    copy   = (unsigned char *)hooks->allocate(length);
+    if(copy == NULL) {
+        return NULL;
+    }
+    memcpy(copy, string, length);
+
+    return copy;
+}
+
+CJSON_PUBLIC(void) cJSON_InitHooks(cJSON_Hooks *hooks) {
+    if(hooks == NULL) {
+        /* Reset hooks */
+        global_hooks.allocate   = malloc;
+        global_hooks.deallocate = free;
+        global_hooks.reallocate = realloc;
+        return;
+    }
+
+    global_hooks.allocate = malloc;
+    if(hooks->malloc_fn != NULL) {
+        global_hooks.allocate = hooks->malloc_fn;
+    }
+
+    global_hooks.deallocate = free;
+    if(hooks->free_fn != NULL) {
+        global_hooks.deallocate = hooks->free_fn;
+    }
+
+    /* use realloc only if both free and malloc are used */
+    global_hooks.reallocate = NULL;
+    if((global_hooks.allocate == malloc) && (global_hooks.deallocate == free)) {
+        global_hooks.reallocate = realloc;
+    }
+}
+
+/* Internal constructor. */
+static cJSON *cJSON_New_Item(const internal_hooks *const hooks) {
+    cJSON *node = (cJSON *)hooks->allocate(sizeof(cJSON));
+    if(node) {
+        memset(node, '\0', sizeof(cJSON));
+    }
+
+    return node;
+}
+
+/* Delete a cJSON structure. */
+CJSON_PUBLIC(void) cJSON_Delete(cJSON *item) {
+    cJSON *next = NULL;
+    while(item != NULL) {
+        next = item->next;
+        if(!(item->type & cJSON_IsReference) && (item->child != NULL)) {
+            cJSON_Delete(item->child);
+        }
+        if(!(item->type & cJSON_IsReference) && (item->valuestring != NULL)) {
+            global_hooks.deallocate(item->valuestring);
+        }
+        if(!(item->type & cJSON_StringIsConst) && (item->string != NULL)) {
+            global_hooks.deallocate(item->string);
+        }
+        global_hooks.deallocate(item);
+        item = next;
+    }
+}
+
+/* get the decimal point character of the current locale */
+static unsigned char get_decimal_point(void) {
+#ifdef ENABLE_LOCALES
+    struct lconv *lconv = localeconv();
+    return (unsigned char)lconv->decimal_point[0];
+#else
+    return '.';
+#endif
+}
+
+typedef struct {
+    const unsigned char *content;
+    size_t               length;
+    size_t               offset;
+    size_t               depth; /* How deeply nested (in arrays/objects) is the input at the current offset. */
+    internal_hooks       hooks;
+} parse_buffer;
+
+/* check if the given size is left to read in a given parse buffer (starting with 1) */
+#define can_read(buffer, size) ((buffer != NULL) && (((buffer)->offset + size) <= (buffer)->length))
+/* check if the buffer can be accessed at the given index (starting with 0) */
+#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length))
+#define cannot_access_at_index(buffer, index) (!can_access_at_index(buffer, index))
+/* get a pointer to the buffer at the position */
+#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset)
+
+/* Parse the input text to generate a number, and populate the result into item. */
+static cJSON_bool parse_number(cJSON *const item, parse_buffer *const input_buffer) {
+    double         number    = 0;
+    unsigned char *after_end = NULL;
+    unsigned char  number_c_string[64];
+    unsigned char  decimal_point = get_decimal_point();
+    size_t         i             = 0;
+
+    if((input_buffer == NULL) || (input_buffer->content == NULL)) {
+        return false;
+    }
+
+    /* copy the number into a temporary buffer and replace '.' with the decimal point
+     * of the current locale (for strtod)
+     * This also takes care of '\0' not necessarily being available for marking the end of the input */
+    for(i = 0; (i < (sizeof(number_c_string) - 1)) && can_access_at_index(input_buffer, i); i++) {
+        switch(buffer_at_offset(input_buffer)[i]) {
+        case '0':
+        case '1':
+        case '2':
+        case '3':
+        case '4':
+        case '5':
+        case '6':
+        case '7':
+        case '8':
+        case '9':
+        case '+':
+        case '-':
+        case 'e':
+        case 'E':
+            number_c_string[i] = buffer_at_offset(input_buffer)[i];
+            break;
+
+        case '.':
+            number_c_string[i] = decimal_point;
+            break;
+
+        default:
+            goto loop_end;
+        }
+    }
+loop_end:
+    number_c_string[i] = '\0';
+
+    number = strtod((const char *)number_c_string, (char **)&after_end);
+    if(number_c_string == after_end) {
+        return false; /* parse_error */
+    }
+
+    item->valuedouble = number;
+
+    /* use saturation in case of overflow */
+    if(number >= INT_MAX) {
+        item->valueint = INT_MAX;
+    }
+    else if(number <= (double)INT_MIN) {
+        item->valueint = INT_MIN;
+    }
+    else {
+        item->valueint = (int)number;
+    }
+
+    item->type = cJSON_Number;
+
+    input_buffer->offset += (size_t)(after_end - number_c_string);
+    return true;
+}
+
+/* don't ask me, but the original cJSON_SetNumberValue returns an integer or double */
+CJSON_PUBLIC(double) cJSON_SetNumberHelper(cJSON *object, double number) {
+    if(number >= INT_MAX) {
+        object->valueint = INT_MAX;
+    }
+    else if(number <= (double)INT_MIN) {
+        object->valueint = INT_MIN;
+    }
+    else {
+        object->valueint = (int)number;
+    }
+
+    return object->valuedouble = number;
+}
+
+CJSON_PUBLIC(char *) cJSON_SetValuestring(cJSON *object, const char *valuestring) {
+    char *copy = NULL;
+    /* if object's type is not cJSON_String or is cJSON_IsReference, it should not set valuestring */
+    if(!(object->type & cJSON_String) || (object->type & cJSON_IsReference)) {
+        return NULL;
+    }
+    if(strlen(valuestring) <= strlen(object->valuestring)) {
+        strcpy(object->valuestring, valuestring);
+        return object->valuestring;
+    }
+    copy = (char *)cJSON_strdup((const unsigned char *)valuestring, &global_hooks);
+    if(copy == NULL) {
+        return NULL;
+    }
+    if(object->valuestring != NULL) {
+        cJSON_free(object->valuestring);
+    }
+    object->valuestring = copy;
+
+    return copy;
+}
+
+typedef struct {
+    unsigned char *buffer;
+    size_t         length;
+    size_t         offset;
+    size_t         depth; /* current nesting depth (for formatted printing) */
+    cJSON_bool     noalloc;
+    cJSON_bool     format; /* is this print a formatted print */
+    internal_hooks hooks;
+} printbuffer;
+
+/* realloc printbuffer if necessary to have at least "needed" bytes more */
+static unsigned char *ensure(printbuffer *const p, size_t needed) {
+    unsigned char *newbuffer = NULL;
+    size_t         newsize   = 0;
+
+    if((p == NULL) || (p->buffer == NULL)) {
+        return NULL;
+    }
+
+    if((p->length > 0) && (p->offset >= p->length)) {
+        /* make sure that offset is valid */
+        return NULL;
+    }
+
+    if(needed > INT_MAX) {
+        /* sizes bigger than INT_MAX are currently not supported */
+        return NULL;
+    }
+
+    needed += p->offset + 1;
+    if(needed <= p->length) {
+        return p->buffer + p->offset;
+    }
+
+    if(p->noalloc) {
+        return NULL;
+    }
+
+    /* calculate new buffer size */
+    if(needed > (INT_MAX / 2)) {
+        /* overflow of int, use INT_MAX if possible */
+        if(needed <= INT_MAX) {
+            newsize = INT_MAX;
+        }
+        else {
+            return NULL;
+        }
+    }
+    else {
+        newsize = needed * 2;
+    }
+
+    if(p->hooks.reallocate != NULL) {
+        /* reallocate with realloc if available */
+        newbuffer = (unsigned char *)p->hooks.reallocate(p->buffer, newsize);
+        if(newbuffer == NULL) {
+            p->hooks.deallocate(p->buffer);
+            p->length = 0;
+            p->buffer = NULL;
+
+            return NULL;
+        }
+    }
+    else {
+        /* otherwise reallocate manually */
+        newbuffer = (unsigned char *)p->hooks.allocate(newsize);
+        if(!newbuffer) {
+            p->hooks.deallocate(p->buffer);
+            p->length = 0;
+            p->buffer = NULL;
+
+            return NULL;
+        }
+
+        memcpy(newbuffer, p->buffer, p->offset + 1);
+        p->hooks.deallocate(p->buffer);
+    }
+    p->length = newsize;
+    p->buffer = newbuffer;
+
+    return newbuffer + p->offset;
+}
+
+/* calculate the new length of the string in a printbuffer and update the offset */
+static void update_offset(printbuffer *const buffer) {
+    const unsigned char *buffer_pointer = NULL;
+    if((buffer == NULL) || (buffer->buffer == NULL)) {
+        return;
+    }
+    buffer_pointer = buffer->buffer + buffer->offset;
+
+    buffer->offset += strlen((const char *)buffer_pointer);
+}
+
+/* securely comparison of floating-point variables */
+static cJSON_bool compare_double(double a, double b) {
+    double maxVal = fabs(a) > fabs(b) ? fabs(a) : fabs(b);
+    return (fabs(a - b) <= maxVal * DBL_EPSILON);
+}
+
+/* Render the number nicely from the given item into a string. */
+static cJSON_bool print_number(const cJSON *const item, printbuffer *const output_buffer) {
+    unsigned char *output_pointer    = NULL;
+    double         d                 = item->valuedouble;
+    int            length            = 0;
+    size_t         i                 = 0;
+    unsigned char  number_buffer[26] = { 0 }; /* temporary buffer to print the number into */
+    unsigned char  decimal_point     = get_decimal_point();
+    double         test              = 0.0;
+
+    if(output_buffer == NULL) {
+        return false;
+    }
+
+    /* This checks for NaN and Infinity */
+    if(isnan(d) || isinf(d)) {
+        length = sprintf((char *)number_buffer, "null");
+    }
+    else {
+        /* Try 15 decimal places of precision to avoid nonsignificant nonzero digits */
+        length = sprintf((char *)number_buffer, "%1.15g", d);
+
+        /* Check whether the original double can be recovered */
+        if((sscanf((char *)number_buffer, "%lg", &test) != 1) || !compare_double((double)test, d)) {
+            /* If not, print with 17 decimal places of precision */
+            length = sprintf((char *)number_buffer, "%1.17g", d);
+        }
+    }
+
+    /* sprintf failed or buffer overrun occurred */
+    if((length < 0) || (length > (int)(sizeof(number_buffer) - 1))) {
+        return false;
+    }
+
+    /* reserve appropriate space in the output */
+    output_pointer = ensure(output_buffer, (size_t)length + sizeof(""));
+    if(output_pointer == NULL) {
+        return false;
+    }
+
+    /* copy the printed number to the output and replace locale
+     * dependent decimal point with '.' */
+    for(i = 0; i < ((size_t)length); i++) {
+        if(number_buffer[i] == decimal_point) {
+            output_pointer[i] = '.';
+            continue;
+        }
+
+        output_pointer[i] = number_buffer[i];
+    }
+    output_pointer[i] = '\0';
+
+    output_buffer->offset += (size_t)length;
+
+    return true;
+}
+
+/* parse 4 digit hexadecimal number */
+static unsigned parse_hex4(const unsigned char *const input) {
+    unsigned int h = 0;
+    size_t       i = 0;
+
+    for(i = 0; i < 4; i++) {
+        /* parse digit */
+        if((input[i] >= '0') && (input[i] <= '9')) {
+            h += (unsigned int)input[i] - '0';
+        }
+        else if((input[i] >= 'A') && (input[i] <= 'F')) {
+            h += (unsigned int)10 + input[i] - 'A';
+        }
+        else if((input[i] >= 'a') && (input[i] <= 'f')) {
+            h += (unsigned int)10 + input[i] - 'a';
+        }
+        else /* invalid */
+        {
+            return 0;
+        }
+
+        if(i < 3) {
+            /* shift left to make place for the next nibble */
+            h = h << 4;
+        }
+    }
+
+    return h;
+}
+
+/* converts a UTF-16 literal to UTF-8
+ * A literal can be one or two sequences of the form \uXXXX */
+static unsigned char utf16_literal_to_utf8(const unsigned char *const input_pointer, const unsigned char *const input_end, unsigned char **output_pointer) {
+    long unsigned int    codepoint       = 0;
+    unsigned int         first_code      = 0;
+    const unsigned char *first_sequence  = input_pointer;
+    unsigned char        utf8_length     = 0;
+    unsigned char        utf8_position   = 0;
+    unsigned char        sequence_length = 0;
+    unsigned char        first_byte_mark = 0;
+
+    if((input_end - first_sequence) < 6) {
+        /* input ends unexpectedly */
+        goto fail;
+    }
+
+    /* get the first utf16 sequence */
+    first_code = parse_hex4(first_sequence + 2);
+
+    /* check that the code is valid */
+    if(((first_code >= 0xDC00) && (first_code <= 0xDFFF))) {
+        goto fail;
+    }
+
+    /* UTF16 surrogate pair */
+    if((first_code >= 0xD800) && (first_code <= 0xDBFF)) {
+        const unsigned char *second_sequence = first_sequence + 6;
+        unsigned int         second_code     = 0;
+        sequence_length                      = 12; /* \uXXXX\uXXXX */
+
+        if((input_end - second_sequence) < 6) {
+            /* input ends unexpectedly */
+            goto fail;
+        }
+
+        if((second_sequence[0] != '\\') || (second_sequence[1] != 'u')) {
+            /* missing second half of the surrogate pair */
+            goto fail;
+        }
+
+        /* get the second utf16 sequence */
+        second_code = parse_hex4(second_sequence + 2);
+        /* check that the code is valid */
+        if((second_code < 0xDC00) || (second_code > 0xDFFF)) {
+            /* invalid second half of the surrogate pair */
+            goto fail;
+        }
+
+        /* calculate the unicode codepoint from the surrogate pair */
+        codepoint = 0x10000 + (((first_code & 0x3FF) << 10) | (second_code & 0x3FF));
+    }
+    else {
+        sequence_length = 6; /* \uXXXX */
+        codepoint       = first_code;
+    }
+
+    /* encode as UTF-8
+     * takes at maximum 4 bytes to encode:
+     * 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx */
+    if(codepoint < 0x80) {
+        /* normal ascii, encoding 0xxxxxxx */
+        utf8_length = 1;
+    }
+    else if(codepoint < 0x800) {
+        /* two bytes, encoding 110xxxxx 10xxxxxx */
+        utf8_length     = 2;
+        first_byte_mark = 0xC0; /* 11000000 */
+    }
+    else if(codepoint < 0x10000) {
+        /* three bytes, encoding 1110xxxx 10xxxxxx 10xxxxxx */
+        utf8_length     = 3;
+        first_byte_mark = 0xE0; /* 11100000 */
+    }
+    else if(codepoint <= 0x10FFFF) {
+        /* four bytes, encoding 1110xxxx 10xxxxxx 10xxxxxx 10xxxxxx */
+        utf8_length     = 4;
+        first_byte_mark = 0xF0; /* 11110000 */
+    }
+    else {
+        /* invalid unicode codepoint */
+        goto fail;
+    }
+
+    /* encode as utf8 */
+    for(utf8_position = (unsigned char)(utf8_length - 1); utf8_position > 0; utf8_position--) {
+        /* 10xxxxxx */
+        (*output_pointer)[utf8_position] = (unsigned char)((codepoint | 0x80) & 0xBF);
+        codepoint >>= 6;
+    }
+    /* encode first byte */
+    if(utf8_length > 1) {
+        (*output_pointer)[0] = (unsigned char)((codepoint | first_byte_mark) & 0xFF);
+    }
+    else {
+        (*output_pointer)[0] = (unsigned char)(codepoint & 0x7F);
+    }
+
+    *output_pointer += utf8_length;
+
+    return sequence_length;
+
+fail:
+    return 0;
+}
+
+/* Parse the input text into an unescaped cinput, and populate item. */
+static cJSON_bool parse_string(cJSON *const item, parse_buffer *const input_buffer) {
+    const unsigned char *input_pointer  = buffer_at_offset(input_buffer) + 1;
+    const unsigned char *input_end      = buffer_at_offset(input_buffer) + 1;
+    unsigned char       *output_pointer = NULL;
+    unsigned char       *output         = NULL;
+
+    /* not a string */
+    if(buffer_at_offset(input_buffer)[0] != '\"') {
+        goto fail;
+    }
+
+    {
+        /* calculate approximate size of the output (overestimate) */
+        size_t allocation_length = 0;
+        size_t skipped_bytes     = 0;
+        while(((size_t)(input_end - input_buffer->content) < input_buffer->length) && (*input_end != '\"')) {
+            /* is escape sequence */
+            if(input_end[0] == '\\') {
+                if((size_t)(input_end + 1 - input_buffer->content) >= input_buffer->length) {
+                    /* prevent buffer overflow when last input character is a backslash */
+                    goto fail;
+                }
+                skipped_bytes++;
+                input_end++;
+            }
+            input_end++;
+        }
+        if(((size_t)(input_end - input_buffer->content) >= input_buffer->length) || (*input_end != '\"')) {
+            goto fail; /* string ended unexpectedly */
+        }
+
+        /* This is at most how much we need for the output */
+        allocation_length = (size_t)(input_end - buffer_at_offset(input_buffer)) - skipped_bytes;
+        output            = (unsigned char *)input_buffer->hooks.allocate(allocation_length + sizeof(""));
+        if(output == NULL) {
+            goto fail; /* allocation failure */
+        }
+    }
+
+    output_pointer = output;
+    /* loop through the string literal */
+    while(input_pointer < input_end) {
+        if(*input_pointer != '\\') {
+            *output_pointer++ = *input_pointer++;
+        }
+        /* escape sequence */
+        else {
+            unsigned char sequence_length = 2;
+            if((input_end - input_pointer) < 1) {
+                goto fail;
+            }
+
+            switch(input_pointer[1]) {
+            case 'b':
+                *output_pointer++ = '\b';
+                break;
+            case 'f':
+                *output_pointer++ = '\f';
+                break;
+            case 'n':
+                *output_pointer++ = '\n';
+                break;
+            case 'r':
+                *output_pointer++ = '\r';
+                break;
+            case 't':
+                *output_pointer++ = '\t';
+                break;
+            case '\"':
+            case '\\':
+            case '/':
+                *output_pointer++ = input_pointer[1];
+                break;
+
+            /* UTF-16 literal */
+            case 'u':
+                sequence_length = utf16_literal_to_utf8(input_pointer, input_end, &output_pointer);
+                if(sequence_length == 0) {
+                    /* failed to convert UTF16-literal to UTF-8 */
+                    goto fail;
+                }
+                break;
+
+            default:
+                goto fail;
+            }
+            input_pointer += sequence_length;
+        }
+    }
+
+    /* zero terminate the output */
+    *output_pointer = '\0';
+
+    item->type        = cJSON_String;
+    item->valuestring = (char *)output;
+
+    input_buffer->offset = (size_t)(input_end - input_buffer->content);
+    input_buffer->offset++;
+
+    return true;
+
+fail:
+    if(output != NULL) {
+        input_buffer->hooks.deallocate(output);
+    }
+
+    if(input_pointer != NULL) {
+        input_buffer->offset = (size_t)(input_pointer - input_buffer->content);
+    }
+
+    return false;
+}
+
+/* Render the cstring provided to an escaped version that can be printed. */
+static cJSON_bool print_string_ptr(const unsigned char *const input, printbuffer *const output_buffer) {
+    const unsigned char *input_pointer  = NULL;
+    unsigned char       *output         = NULL;
+    unsigned char       *output_pointer = NULL;
+    size_t               output_length  = 0;
+    /* numbers of additional characters needed for escaping */
+    size_t escape_characters = 0;
+
+    if(output_buffer == NULL) {
+        return false;
+    }
+
+    /* empty string */
+    if(input == NULL) {
+        output = ensure(output_buffer, sizeof("\"\""));
+        if(output == NULL) {
+            return false;
+        }
+        strcpy((char *)output, "\"\"");
+
+        return true;
+    }
+
+    /* set "flag" to 1 if something needs to be escaped */
+    for(input_pointer = input; *input_pointer; input_pointer++) {
+        switch(*input_pointer) {
+        case '\"':
+        case '\\':
+        case '\b':
+        case '\f':
+        case '\n':
+        case '\r':
+        case '\t':
+            /* one character escape sequence */
+            escape_characters++;
+            break;
+        default:
+            if(*input_pointer < 32) {
+                /* UTF-16 escape sequence uXXXX */
+                escape_characters += 5;
+            }
+            break;
+        }
+    }
+    output_length = (size_t)(input_pointer - input) + escape_characters;
+
+    output = ensure(output_buffer, output_length + sizeof("\"\""));
+    if(output == NULL) {
+        return false;
+    }
+
+    /* no characters have to be escaped */
+    if(escape_characters == 0) {
+        output[0] = '\"';
+        memcpy(output + 1, input, output_length);
+        output[output_length + 1] = '\"';
+        output[output_length + 2] = '\0';
+
+        return true;
+    }
+
+    output[0]      = '\"';
+    output_pointer = output + 1;
+    /* copy the string */
+    for(input_pointer = input; *input_pointer != '\0'; (void)input_pointer++, output_pointer++) {
+        if((*input_pointer > 31) && (*input_pointer != '\"') && (*input_pointer != '\\')) {
+            /* normal character, copy */
+            *output_pointer = *input_pointer;
+        }
+        else {
+            /* character needs to be escaped */
+            *output_pointer++ = '\\';
+            switch(*input_pointer) {
+            case '\\':
+                *output_pointer = '\\';
+                break;
+            case '\"':
+                *output_pointer = '\"';
+                break;
+            case '\b':
+                *output_pointer = 'b';
+                break;
+            case '\f':
+                *output_pointer = 'f';
+                break;
+            case '\n':
+                *output_pointer = 'n';
+                break;
+            case '\r':
+                *output_pointer = 'r';
+                break;
+            case '\t':
+                *output_pointer = 't';
+                break;
+            default:
+                /* escape and print as unicode codepoint */
+                sprintf((char *)output_pointer, "u%04x", *input_pointer);
+                output_pointer += 4;
+                break;
+            }
+        }
+    }
+    output[output_length + 1] = '\"';
+    output[output_length + 2] = '\0';
+
+    return true;
+}
+
+/* Invoke print_string_ptr (which is useful) on an item. */
+static cJSON_bool print_string(const cJSON *const item, printbuffer *const p) {
+    return print_string_ptr((unsigned char *)item->valuestring, p);
+}
+
+/* Predeclare these prototypes. */
+static cJSON_bool parse_value(cJSON *const item, parse_buffer *const input_buffer);
+static cJSON_bool print_value(const cJSON *const item, printbuffer *const output_buffer);
+static cJSON_bool parse_array(cJSON *const item, parse_buffer *const input_buffer);
+static cJSON_bool print_array(const cJSON *const item, printbuffer *const output_buffer);
+static cJSON_bool parse_object(cJSON *const item, parse_buffer *const input_buffer);
+static cJSON_bool print_object(const cJSON *const item, printbuffer *const output_buffer);
+
+/* Utility to jump whitespace and cr/lf */
+static parse_buffer *buffer_skip_whitespace(parse_buffer *const buffer) {
+    if((buffer == NULL) || (buffer->content == NULL)) {
+        return NULL;
+    }
+
+    if(cannot_access_at_index(buffer, 0)) {
+        return buffer;
+    }
+
+    while(can_access_at_index(buffer, 0) && (buffer_at_offset(buffer)[0] <= 32)) {
+        buffer->offset++;
+    }
+
+    if(buffer->offset == buffer->length) {
+        buffer->offset--;
+    }
+
+    return buffer;
+}
+
+/* skip the UTF-8 BOM (byte order mark) if it is at the beginning of a buffer */
+static parse_buffer *skip_utf8_bom(parse_buffer *const buffer) {
+    if((buffer == NULL) || (buffer->content == NULL) || (buffer->offset != 0)) {
+        return NULL;
+    }
+
+    if(can_access_at_index(buffer, 4) && (strncmp((const char *)buffer_at_offset(buffer), "\xEF\xBB\xBF", 3) == 0)) {
+        buffer->offset += 3;
+    }
+
+    return buffer;
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_ParseWithOpts(const char *value, const char **return_parse_end, cJSON_bool require_null_terminated) {
+    size_t buffer_length;
+
+    if(NULL == value) {
+        return NULL;
+    }
+
+    /* Adding null character size due to require_null_terminated. */
+    buffer_length = strlen(value) + sizeof("");
+
+    return cJSON_ParseWithLengthOpts(value, buffer_length, return_parse_end, require_null_terminated);
+}
+
+/* Parse an object - create a new root, and populate. */
+CJSON_PUBLIC(cJSON *) cJSON_ParseWithLengthOpts(const char *value, size_t buffer_length, const char **return_parse_end, cJSON_bool require_null_terminated) {
+    parse_buffer buffer = { 0, 0, 0, 0, { 0, 0, 0 } };
+    cJSON       *item   = NULL;
+
+    /* reset error position */
+    global_error.json     = NULL;
+    global_error.position = 0;
+
+    if(value == NULL || 0 == buffer_length) {
+        goto fail;
+    }
+
+    buffer.content = (const unsigned char *)value;
+    buffer.length  = buffer_length;
+    buffer.offset  = 0;
+    buffer.hooks   = global_hooks;
+
+    item = cJSON_New_Item(&global_hooks);
+    if(item == NULL) /* memory fail */
+    {
+        goto fail;
+    }
+
+    if(!parse_value(item, buffer_skip_whitespace(skip_utf8_bom(&buffer)))) {
+        /* parse failure. ep is set. */
+        goto fail;
+    }
+
+    /* if we require null-terminated JSON without appended garbage, skip and then check for a null terminator */
+    if(require_null_terminated) {
+        buffer_skip_whitespace(&buffer);
+        if((buffer.offset >= buffer.length) || buffer_at_offset(&buffer)[0] != '\0') {
+            goto fail;
+        }
+    }
+    if(return_parse_end) {
+        *return_parse_end = (const char *)buffer_at_offset(&buffer);
+    }
+
+    return item;
+
+fail:
+    if(item != NULL) {
+        cJSON_Delete(item);
+    }
+
+    if(value != NULL) {
+        error local_error;
+        local_error.json     = (const unsigned char *)value;
+        local_error.position = 0;
+
+        if(buffer.offset < buffer.length) {
+            local_error.position = buffer.offset;
+        }
+        else if(buffer.length > 0) {
+            local_error.position = buffer.length - 1;
+        }
+
+        if(return_parse_end != NULL) {
+            *return_parse_end = (const char *)local_error.json + local_error.position;
+        }
+
+        global_error = local_error;
+    }
+
+    return NULL;
+}
+
+/* Default options for cJSON_Parse */
+CJSON_PUBLIC(cJSON *) cJSON_Parse(const char *value) {
+    return cJSON_ParseWithOpts(value, 0, 0);
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_ParseWithLength(const char *value, size_t buffer_length) {
+    return cJSON_ParseWithLengthOpts(value, buffer_length, 0, 0);
+}
+
+#define cjson_min(a, b) (((a) < (b)) ? (a) : (b))
+
+static unsigned char *print(const cJSON *const item, cJSON_bool format, const internal_hooks *const hooks) {
+    static const size_t default_buffer_size = 256;
+    printbuffer         buffer[1];
+    unsigned char      *printed = NULL;
+
+    memset(buffer, 0, sizeof(buffer));
+
+    /* create buffer */
+    buffer->buffer = (unsigned char *)hooks->allocate(default_buffer_size);
+    buffer->length = default_buffer_size;
+    buffer->format = format;
+    buffer->hooks  = *hooks;
+    if(buffer->buffer == NULL) {
+        goto fail;
+    }
+
+    /* print the value */
+    if(!print_value(item, buffer)) {
+        goto fail;
+    }
+    update_offset(buffer);
+
+    /* check if reallocate is available */
+    if(hooks->reallocate != NULL) {
+        printed = (unsigned char *)hooks->reallocate(buffer->buffer, buffer->offset + 1);
+        if(printed == NULL) {
+            goto fail;
+        }
+        buffer->buffer = NULL;
+    }
+    else /* otherwise copy the JSON over to a new buffer */
+    {
+        printed = (unsigned char *)hooks->allocate(buffer->offset + 1);
+        if(printed == NULL) {
+            goto fail;
+        }
+        memcpy(printed, buffer->buffer, cjson_min(buffer->length, buffer->offset + 1));
+        printed[buffer->offset] = '\0'; /* just to be sure */
+
+        /* free the buffer */
+        hooks->deallocate(buffer->buffer);
+    }
+
+    return printed;
+
+fail:
+    if(buffer->buffer != NULL) {
+        hooks->deallocate(buffer->buffer);
+    }
+
+    if(printed != NULL) {
+        hooks->deallocate(printed);
+    }
+
+    return NULL;
+}
+
+/* Render a cJSON item/entity/structure to text. */
+CJSON_PUBLIC(char *) cJSON_Print(const cJSON *item) {
+    return (char *)print(item, true, &global_hooks);
+}
+
+CJSON_PUBLIC(char *) cJSON_PrintUnformatted(const cJSON *item) {
+    return (char *)print(item, false, &global_hooks);
+}
+
+CJSON_PUBLIC(char *) cJSON_PrintBuffered(const cJSON *item, int prebuffer, cJSON_bool fmt) {
+    printbuffer p = { 0, 0, 0, 0, 0, 0, { 0, 0, 0 } };
+
+    if(prebuffer < 0) {
+        return NULL;
+    }
+
+    p.buffer = (unsigned char *)global_hooks.allocate((size_t)prebuffer);
+    if(!p.buffer) {
+        return NULL;
+    }
+
+    p.length  = (size_t)prebuffer;
+    p.offset  = 0;
+    p.noalloc = false;
+    p.format  = fmt;
+    p.hooks   = global_hooks;
+
+    if(!print_value(item, &p)) {
+        global_hooks.deallocate(p.buffer);
+        return NULL;
+    }
+
+    return (char *)p.buffer;
+}
+
+CJSON_PUBLIC(cJSON_bool) cJSON_PrintPreallocated(cJSON *item, char *buffer, const int length, const cJSON_bool format) {
+    printbuffer p = { 0, 0, 0, 0, 0, 0, { 0, 0, 0 } };
+
+    if((length < 0) || (buffer == NULL)) {
+        return false;
+    }
+
+    p.buffer  = (unsigned char *)buffer;
+    p.length  = (size_t)length;
+    p.offset  = 0;
+    p.noalloc = true;
+    p.format  = format;
+    p.hooks   = global_hooks;
+
+    return print_value(item, &p);
+}
+
+/* Parser core - when encountering text, process appropriately. */
+static cJSON_bool parse_value(cJSON *const item, parse_buffer *const input_buffer) {
+    if((input_buffer == NULL) || (input_buffer->content == NULL)) {
+        return false; /* no input */
+    }
+
+    /* parse the different types of values */
+    /* null */
+    if(can_read(input_buffer, 4) && (strncmp((const char *)buffer_at_offset(input_buffer), "null", 4) == 0)) {
+        item->type = cJSON_NULL;
+        input_buffer->offset += 4;
+        return true;
+    }
+    /* false */
+    if(can_read(input_buffer, 5) && (strncmp((const char *)buffer_at_offset(input_buffer), "false", 5) == 0)) {
+        item->type = cJSON_False;
+        input_buffer->offset += 5;
+        return true;
+    }
+    /* true */
+    if(can_read(input_buffer, 4) && (strncmp((const char *)buffer_at_offset(input_buffer), "true", 4) == 0)) {
+        item->type     = cJSON_True;
+        item->valueint = 1;
+        input_buffer->offset += 4;
+        return true;
+    }
+    /* string */
+    if(can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '\"')) {
+        return parse_string(item, input_buffer);
+    }
+    /* number */
+    if(can_access_at_index(input_buffer, 0)
+       && ((buffer_at_offset(input_buffer)[0] == '-') || ((buffer_at_offset(input_buffer)[0] >= '0') && (buffer_at_offset(input_buffer)[0] <= '9')))) {
+        return parse_number(item, input_buffer);
+    }
+    /* array */
+    if(can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '[')) {
+        return parse_array(item, input_buffer);
+    }
+    /* object */
+    if(can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '{')) {
+        return parse_object(item, input_buffer);
+    }
+
+    return false;
+}
+
+/* Render a value to text. */
+static cJSON_bool print_value(const cJSON *const item, printbuffer *const output_buffer) {
+    unsigned char *output = NULL;
+
+    if((item == NULL) || (output_buffer == NULL)) {
+        return false;
+    }
+
+    switch((item->type) & 0xFF) {
+    case cJSON_NULL:
+        output = ensure(output_buffer, 5);
+        if(output == NULL) {
+            return false;
+        }
+        strcpy((char *)output, "null");
+        return true;
+
+    case cJSON_False:
+        output = ensure(output_buffer, 6);
+        if(output == NULL) {
+            return false;
+        }
+        strcpy((char *)output, "false");
+        return true;
+
+    case cJSON_True:
+        output = ensure(output_buffer, 5);
+        if(output == NULL) {
+            return false;
+        }
+        strcpy((char *)output, "true");
+        return true;
+
+    case cJSON_Number:
+        return print_number(item, output_buffer);
+
+    case cJSON_Raw: {
+        size_t raw_length = 0;
+        if(item->valuestring == NULL) {
+            return false;
+        }
+
+        raw_length = strlen(item->valuestring) + sizeof("");
+        output     = ensure(output_buffer, raw_length);
+        if(output == NULL) {
+            return false;
+        }
+        memcpy(output, item->valuestring, raw_length);
+        return true;
+    }
+
+    case cJSON_String:
+        return print_string(item, output_buffer);
+
+    case cJSON_Array:
+        return print_array(item, output_buffer);
+
+    case cJSON_Object:
+        return print_object(item, output_buffer);
+
+    default:
+        return false;
+    }
+}
+
+/* Build an array from input text. */
+static cJSON_bool parse_array(cJSON *const item, parse_buffer *const input_buffer) {
+    cJSON *head         = NULL; /* head of the linked list */
+    cJSON *current_item = NULL;
+
+    if(input_buffer->depth >= CJSON_NESTING_LIMIT) {
+        return false; /* to deeply nested */
+    }
+    input_buffer->depth++;
+
+    if(buffer_at_offset(input_buffer)[0] != '[') {
+        /* not an array */
+        goto fail;
+    }
+
+    input_buffer->offset++;
+    buffer_skip_whitespace(input_buffer);
+    if(can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == ']')) {
+        /* empty array */
+        goto success;
+    }
+
+    /* check if we skipped to the end of the buffer */
+    if(cannot_access_at_index(input_buffer, 0)) {
+        input_buffer->offset--;
+        goto fail;
+    }
+
+    /* step back to character in front of the first element */
+    input_buffer->offset--;
+    /* loop through the comma separated array elements */
+    do {
+        /* allocate next item */
+        cJSON *new_item = cJSON_New_Item(&(input_buffer->hooks));
+        if(new_item == NULL) {
+            goto fail; /* allocation failure */
+        }
+
+        /* attach next item to list */
+        if(head == NULL) {
+            /* start the linked list */
+            current_item = head = new_item;
+        }
+        else {
+            /* add to the end and advance */
+            current_item->next = new_item;
+            new_item->prev     = current_item;
+            current_item       = new_item;
+        }
+
+        /* parse next value */
+        input_buffer->offset++;
+        buffer_skip_whitespace(input_buffer);
+        if(!parse_value(current_item, input_buffer)) {
+            goto fail; /* failed to parse value */
+        }
+        buffer_skip_whitespace(input_buffer);
+    } while(can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == ','));
+
+    if(cannot_access_at_index(input_buffer, 0) || buffer_at_offset(input_buffer)[0] != ']') {
+        goto fail; /* expected end of array */
+    }
+
+success:
+    input_buffer->depth--;
+
+    if(head != NULL) {
+        head->prev = current_item;
+    }
+
+    item->type  = cJSON_Array;
+    item->child = head;
+
+    input_buffer->offset++;
+
+    return true;
+
+fail:
+    if(head != NULL) {
+        cJSON_Delete(head);
+    }
+
+    return false;
+}
+
+/* Render an array to text */
+static cJSON_bool print_array(const cJSON *const item, printbuffer *const output_buffer) {
+    unsigned char *output_pointer  = NULL;
+    size_t         length          = 0;
+    cJSON         *current_element = item->child;
+
+    if(output_buffer == NULL) {
+        return false;
+    }
+
+    /* Compose the output array. */
+    /* opening square bracket */
+    output_pointer = ensure(output_buffer, 1);
+    if(output_pointer == NULL) {
+        return false;
+    }
+
+    *output_pointer = '[';
+    output_buffer->offset++;
+    output_buffer->depth++;
+
+    while(current_element != NULL) {
+        if(!print_value(current_element, output_buffer)) {
+            return false;
+        }
+        update_offset(output_buffer);
+        if(current_element->next) {
+            length         = (size_t)(output_buffer->format ? 2 : 1);
+            output_pointer = ensure(output_buffer, length + 1);
+            if(output_pointer == NULL) {
+                return false;
+            }
+            *output_pointer++ = ',';
+            if(output_buffer->format) {
+                *output_pointer++ = ' ';
+            }
+            *output_pointer = '\0';
+            output_buffer->offset += length;
+        }
+        current_element = current_element->next;
+    }
+
+    output_pointer = ensure(output_buffer, 2);
+    if(output_pointer == NULL) {
+        return false;
+    }
+    *output_pointer++ = ']';
+    *output_pointer   = '\0';
+    output_buffer->depth--;
+
+    return true;
+}
+
+/* Build an object from the text. */
+static cJSON_bool parse_object(cJSON *const item, parse_buffer *const input_buffer) {
+    cJSON *head         = NULL; /* linked list head */
+    cJSON *current_item = NULL;
+
+    if(input_buffer->depth >= CJSON_NESTING_LIMIT) {
+        return false; /* to deeply nested */
+    }
+    input_buffer->depth++;
+
+    if(cannot_access_at_index(input_buffer, 0) || (buffer_at_offset(input_buffer)[0] != '{')) {
+        goto fail; /* not an object */
+    }
+
+    input_buffer->offset++;
+    buffer_skip_whitespace(input_buffer);
+    if(can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '}')) {
+        goto success; /* empty object */
+    }
+
+    /* check if we skipped to the end of the buffer */
+    if(cannot_access_at_index(input_buffer, 0)) {
+        input_buffer->offset--;
+        goto fail;
+    }
+
+    /* step back to character in front of the first element */
+    input_buffer->offset--;
+    /* loop through the comma separated array elements */
+    do {
+        /* allocate next item */
+        cJSON *new_item = cJSON_New_Item(&(input_buffer->hooks));
+        if(new_item == NULL) {
+            goto fail; /* allocation failure */
+        }
+
+        /* attach next item to list */
+        if(head == NULL) {
+            /* start the linked list */
+            current_item = head = new_item;
+        }
+        else {
+            /* add to the end and advance */
+            current_item->next = new_item;
+            new_item->prev     = current_item;
+            current_item       = new_item;
+        }
+
+        /* parse the name of the child */
+        input_buffer->offset++;
+        buffer_skip_whitespace(input_buffer);
+        if(!parse_string(current_item, input_buffer)) {
+            goto fail; /* failed to parse name */
+        }
+        buffer_skip_whitespace(input_buffer);
+
+        /* swap valuestring and string, because we parsed the name */
+        current_item->string      = current_item->valuestring;
+        current_item->valuestring = NULL;
+
+        if(cannot_access_at_index(input_buffer, 0) || (buffer_at_offset(input_buffer)[0] != ':')) {
+            goto fail; /* invalid object */
+        }
+
+        /* parse the value */
+        input_buffer->offset++;
+        buffer_skip_whitespace(input_buffer);
+        if(!parse_value(current_item, input_buffer)) {
+            goto fail; /* failed to parse value */
+        }
+        buffer_skip_whitespace(input_buffer);
+    } while(can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == ','));
+
+    if(cannot_access_at_index(input_buffer, 0) || (buffer_at_offset(input_buffer)[0] != '}')) {
+        goto fail; /* expected end of object */
+    }
+
+success:
+    input_buffer->depth--;
+
+    if(head != NULL) {
+        head->prev = current_item;
+    }
+
+    item->type  = cJSON_Object;
+    item->child = head;
+
+    input_buffer->offset++;
+    return true;
+
+fail:
+    if(head != NULL) {
+        cJSON_Delete(head);
+    }
+
+    return false;
+}
+
+/* Render an object to text. */
+static cJSON_bool print_object(const cJSON *const item, printbuffer *const output_buffer) {
+    unsigned char *output_pointer = NULL;
+    size_t         length         = 0;
+    cJSON         *current_item   = item->child;
+
+    if(output_buffer == NULL) {
+        return false;
+    }
+
+    /* Compose the output: */
+    length         = (size_t)(output_buffer->format ? 2 : 1); /* fmt: {\n */
+    output_pointer = ensure(output_buffer, length + 1);
+    if(output_pointer == NULL) {
+        return false;
+    }
+
+    *output_pointer++ = '{';
+    output_buffer->depth++;
+    if(output_buffer->format) {
+        *output_pointer++ = '\n';
+    }
+    output_buffer->offset += length;
+
+    while(current_item) {
+        if(output_buffer->format) {
+            size_t i;
+            output_pointer = ensure(output_buffer, output_buffer->depth);
+            if(output_pointer == NULL) {
+                return false;
+            }
+            for(i = 0; i < output_buffer->depth; i++) {
+                *output_pointer++ = '\t';
+            }
+            output_buffer->offset += output_buffer->depth;
+        }
+
+        /* print key */
+        if(!print_string_ptr((unsigned char *)current_item->string, output_buffer)) {
+            return false;
+        }
+        update_offset(output_buffer);
+
+        length         = (size_t)(output_buffer->format ? 2 : 1);
+        output_pointer = ensure(output_buffer, length);
+        if(output_pointer == NULL) {
+            return false;
+        }
+        *output_pointer++ = ':';
+        if(output_buffer->format) {
+            *output_pointer++ = '\t';
+        }
+        output_buffer->offset += length;
+
+        /* print value */
+        if(!print_value(current_item, output_buffer)) {
+            return false;
+        }
+        update_offset(output_buffer);
+
+        /* print comma if not last */
+        length         = ((size_t)(output_buffer->format ? 1 : 0) + (size_t)(current_item->next ? 1 : 0));
+        output_pointer = ensure(output_buffer, length + 1);
+        if(output_pointer == NULL) {
+            return false;
+        }
+        if(current_item->next) {
+            *output_pointer++ = ',';
+        }
+
+        if(output_buffer->format) {
+            *output_pointer++ = '\n';
+        }
+        *output_pointer = '\0';
+        output_buffer->offset += length;
+
+        current_item = current_item->next;
+    }
+
+    output_pointer = ensure(output_buffer, output_buffer->format ? (output_buffer->depth + 1) : 2);
+    if(output_pointer == NULL) {
+        return false;
+    }
+    if(output_buffer->format) {
+        size_t i;
+        for(i = 0; i < (output_buffer->depth - 1); i++) {
+            *output_pointer++ = '\t';
+        }
+    }
+    *output_pointer++ = '}';
+    *output_pointer   = '\0';
+    output_buffer->depth--;
+
+    return true;
+}
+
+/* Get Array size/item / object item. */
+CJSON_PUBLIC(int) cJSON_GetArraySize(const cJSON *array) {
+    cJSON *child = NULL;
+    size_t size  = 0;
+
+    if(array == NULL) {
+        return 0;
+    }
+
+    child = array->child;
+
+    while(child != NULL) {
+        size++;
+        child = child->next;
+    }
+
+    /* FIXME: Can overflow here. Cannot be fixed without breaking the API */
+
+    return (int)size;
+}
+
+static cJSON *get_array_item(const cJSON *array, size_t index) {
+    cJSON *current_child = NULL;
+
+    if(array == NULL) {
+        return NULL;
+    }
+
+    current_child = array->child;
+    while((current_child != NULL) && (index > 0)) {
+        index--;
+        current_child = current_child->next;
+    }
+
+    return current_child;
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_GetArrayItem(const cJSON *array, int index) {
+    if(index < 0) {
+        return NULL;
+    }
+
+    return get_array_item(array, (size_t)index);
+}
+
+static cJSON *get_object_item(const cJSON *const object, const char *const name, const cJSON_bool case_sensitive) {
+    cJSON *current_element = NULL;
+
+    if((object == NULL) || (name == NULL)) {
+        return NULL;
+    }
+
+    current_element = object->child;
+    if(case_sensitive) {
+        while((current_element != NULL) && (current_element->string != NULL) && (strcmp(name, current_element->string) != 0)) {
+            current_element = current_element->next;
+        }
+    }
+    else {
+        while((current_element != NULL) && (case_insensitive_strcmp((const unsigned char *)name, (const unsigned char *)(current_element->string)) != 0)) {
+            current_element = current_element->next;
+        }
+    }
+
+    if((current_element == NULL) || (current_element->string == NULL)) {
+        return NULL;
+    }
+
+    return current_element;
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_GetObjectItem(const cJSON *const object, const char *const string) {
+    return get_object_item(object, string, false);
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_GetObjectItemCaseSensitive(const cJSON *const object, const char *const string) {
+    return get_object_item(object, string, true);
+}
+
+CJSON_PUBLIC(cJSON_bool) cJSON_HasObjectItem(const cJSON *object, const char *string) {
+    return cJSON_GetObjectItem(object, string) ? 1 : 0;
+}
+
+/* Utility for array list handling. */
+static void suffix_object(cJSON *prev, cJSON *item) {
+    prev->next = item;
+    item->prev = prev;
+}
+
+/* Utility for handling references. */
+static cJSON *create_reference(const cJSON *item, const internal_hooks *const hooks) {
+    cJSON *reference = NULL;
+    if(item == NULL) {
+        return NULL;
+    }
+
+    reference = cJSON_New_Item(hooks);
+    if(reference == NULL) {
+        return NULL;
+    }
+
+    memcpy(reference, item, sizeof(cJSON));
+    reference->string = NULL;
+    reference->type |= cJSON_IsReference;
+    reference->next = reference->prev = NULL;
+    return reference;
+}
+
+static cJSON_bool add_item_to_array(cJSON *array, cJSON *item) {
+    cJSON *child = NULL;
+
+    if((item == NULL) || (array == NULL) || (array == item)) {
+        return false;
+    }
+
+    child = array->child;
+    /*
+     * To find the last item in array quickly, we use prev in array
+     */
+    if(child == NULL) {
+        /* list is empty, start new one */
+        array->child = item;
+        item->prev   = item;
+        item->next   = NULL;
+    }
+    else {
+        /* append to the end */
+        if(child->prev) {
+            suffix_object(child->prev, item);
+            array->child->prev = item;
+        }
+    }
+
+    return true;
+}
+
+/* Add item to array/object. */
+CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToArray(cJSON *array, cJSON *item) {
+    return add_item_to_array(array, item);
+}
+
+#if defined(__clang__) || (defined(__GNUC__) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 5))))
+#pragma GCC diagnostic push
+#endif
+#ifdef __GNUC__
+#pragma GCC diagnostic ignored "-Wcast-qual"
+#endif
+/* helper function to cast away const */
+static void *cast_away_const(const void *string) {
+    return (void *)string;
+}
+#if defined(__clang__) || (defined(__GNUC__) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 5))))
+#pragma GCC diagnostic pop
+#endif
+
+static cJSON_bool add_item_to_object(cJSON *const object, const char *const string, cJSON *const item, const internal_hooks *const hooks,
+                                     const cJSON_bool constant_key) {
+    char *new_key  = NULL;
+    int   new_type = cJSON_Invalid;
+
+    if((object == NULL) || (string == NULL) || (item == NULL) || (object == item)) {
+        return false;
+    }
+
+    if(constant_key) {
+        new_key  = (char *)cast_away_const(string);
+        new_type = item->type | cJSON_StringIsConst;
+    }
+    else {
+        new_key = (char *)cJSON_strdup((const unsigned char *)string, hooks);
+        if(new_key == NULL) {
+            return false;
+        }
+
+        new_type = item->type & ~cJSON_StringIsConst;
+    }
+
+    if(!(item->type & cJSON_StringIsConst) && (item->string != NULL)) {
+        hooks->deallocate(item->string);
+    }
+
+    item->string = new_key;
+    item->type   = new_type;
+
+    return add_item_to_array(object, item);
+}
+
+CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToObject(cJSON *object, const char *string, cJSON *item) {
+    return add_item_to_object(object, string, item, &global_hooks, false);
+}
+
+/* Add an item to an object with constant string as key */
+CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToObjectCS(cJSON *object, const char *string, cJSON *item) {
+    return add_item_to_object(object, string, item, &global_hooks, true);
+}
+
+CJSON_PUBLIC(cJSON_bool) cJSON_AddItemReferenceToArray(cJSON *array, cJSON *item) {
+    if(array == NULL) {
+        return false;
+    }
+
+    return add_item_to_array(array, create_reference(item, &global_hooks));
+}
+
+CJSON_PUBLIC(cJSON_bool) cJSON_AddItemReferenceToObject(cJSON *object, const char *string, cJSON *item) {
+    if((object == NULL) || (string == NULL)) {
+        return false;
+    }
+
+    return add_item_to_object(object, string, create_reference(item, &global_hooks), &global_hooks, false);
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_AddNullToObject(cJSON *const object, const char *const name) {
+    cJSON *null = cJSON_CreateNull();
+    if(add_item_to_object(object, name, null, &global_hooks, false)) {
+        return null;
+    }
+
+    cJSON_Delete(null);
+    return NULL;
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_AddTrueToObject(cJSON *const object, const char *const name) {
+    cJSON *true_item = cJSON_CreateTrue();
+    if(add_item_to_object(object, name, true_item, &global_hooks, false)) {
+        return true_item;
+    }
+
+    cJSON_Delete(true_item);
+    return NULL;
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_AddFalseToObject(cJSON *const object, const char *const name) {
+    cJSON *false_item = cJSON_CreateFalse();
+    if(add_item_to_object(object, name, false_item, &global_hooks, false)) {
+        return false_item;
+    }
+
+    cJSON_Delete(false_item);
+    return NULL;
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_AddBoolToObject(cJSON *const object, const char *const name, const cJSON_bool boolean) {
+    cJSON *bool_item = cJSON_CreateBool(boolean);
+    if(add_item_to_object(object, name, bool_item, &global_hooks, false)) {
+        return bool_item;
+    }
+
+    cJSON_Delete(bool_item);
+    return NULL;
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_AddNumberToObject(cJSON *const object, const char *const name, const double number) {
+    cJSON *number_item = cJSON_CreateNumber(number);
+    if(add_item_to_object(object, name, number_item, &global_hooks, false)) {
+        return number_item;
+    }
+
+    cJSON_Delete(number_item);
+    return NULL;
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_AddStringToObject(cJSON *const object, const char *const name, const char *const string) {
+    cJSON *string_item = cJSON_CreateString(string);
+    if(add_item_to_object(object, name, string_item, &global_hooks, false)) {
+        return string_item;
+    }
+
+    cJSON_Delete(string_item);
+    return NULL;
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_AddRawToObject(cJSON *const object, const char *const name, const char *const raw) {
+    cJSON *raw_item = cJSON_CreateRaw(raw);
+    if(add_item_to_object(object, name, raw_item, &global_hooks, false)) {
+        return raw_item;
+    }
+
+    cJSON_Delete(raw_item);
+    return NULL;
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_AddObjectToObject(cJSON *const object, const char *const name) {
+    cJSON *object_item = cJSON_CreateObject();
+    if(add_item_to_object(object, name, object_item, &global_hooks, false)) {
+        return object_item;
+    }
+
+    cJSON_Delete(object_item);
+    return NULL;
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_AddArrayToObject(cJSON *const object, const char *const name) {
+    cJSON *array = cJSON_CreateArray();
+    if(add_item_to_object(object, name, array, &global_hooks, false)) {
+        return array;
+    }
+
+    cJSON_Delete(array);
+    return NULL;
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_DetachItemViaPointer(cJSON *parent, cJSON *const item) {
+    if((parent == NULL) || (item == NULL)) {
+        return NULL;
+    }
+
+    if(item != parent->child) {
+        /* not the first element */
+        item->prev->next = item->next;
+    }
+    if(item->next != NULL) {
+        /* not the last element */
+        item->next->prev = item->prev;
+    }
+
+    if(item == parent->child) {
+        /* first element */
+        parent->child = item->next;
+    }
+    else if(item->next == NULL) {
+        /* last element */
+        parent->child->prev = item->prev;
+    }
+
+    /* make sure the detached item doesn't point anywhere anymore */
+    item->prev = NULL;
+    item->next = NULL;
+
+    return item;
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromArray(cJSON *array, int which) {
+    if(which < 0) {
+        return NULL;
+    }
+
+    return cJSON_DetachItemViaPointer(array, get_array_item(array, (size_t)which));
+}
+
+CJSON_PUBLIC(void) cJSON_DeleteItemFromArray(cJSON *array, int which) {
+    cJSON_Delete(cJSON_DetachItemFromArray(array, which));
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObject(cJSON *object, const char *string) {
+    cJSON *to_detach = cJSON_GetObjectItem(object, string);
+
+    return cJSON_DetachItemViaPointer(object, to_detach);
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObjectCaseSensitive(cJSON *object, const char *string) {
+    cJSON *to_detach = cJSON_GetObjectItemCaseSensitive(object, string);
+
+    return cJSON_DetachItemViaPointer(object, to_detach);
+}
+
+CJSON_PUBLIC(void) cJSON_DeleteItemFromObject(cJSON *object, const char *string) {
+    cJSON_Delete(cJSON_DetachItemFromObject(object, string));
+}
+
+CJSON_PUBLIC(void) cJSON_DeleteItemFromObjectCaseSensitive(cJSON *object, const char *string) {
+    cJSON_Delete(cJSON_DetachItemFromObjectCaseSensitive(object, string));
+}
+
+/* Replace array/object items with new ones. */
+CJSON_PUBLIC(cJSON_bool) cJSON_InsertItemInArray(cJSON *array, int which, cJSON *newitem) {
+    cJSON *after_inserted = NULL;
+
+    if(which < 0) {
+        return false;
+    }
+
+    after_inserted = get_array_item(array, (size_t)which);
+    if(after_inserted == NULL) {
+        return add_item_to_array(array, newitem);
+    }
+
+    newitem->next        = after_inserted;
+    newitem->prev        = after_inserted->prev;
+    after_inserted->prev = newitem;
+    if(after_inserted == array->child) {
+        array->child = newitem;
+    }
+    else {
+        newitem->prev->next = newitem;
+    }
+    return true;
+}
+
+CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemViaPointer(cJSON *const parent, cJSON *const item, cJSON *replacement) {
+    if((parent == NULL) || (replacement == NULL) || (item == NULL)) {
+        return false;
+    }
+
+    if(replacement == item) {
+        return true;
+    }
+
+    replacement->next = item->next;
+    replacement->prev = item->prev;
+
+    if(replacement->next != NULL) {
+        replacement->next->prev = replacement;
+    }
+    if(parent->child == item) {
+        if(parent->child->prev == parent->child) {
+            replacement->prev = replacement;
+        }
+        parent->child = replacement;
+    }
+    else { /*
+            * To find the last item in array quickly, we use prev in array.
+            * We can't modify the last item's next pointer where this item was the parent's child
+            */
+        if(replacement->prev != NULL) {
+            replacement->prev->next = replacement;
+        }
+        if(replacement->next == NULL) {
+            parent->child->prev = replacement;
+        }
+    }
+
+    item->next = NULL;
+    item->prev = NULL;
+    cJSON_Delete(item);
+
+    return true;
+}
+
+CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInArray(cJSON *array, int which, cJSON *newitem) {
+    if(which < 0) {
+        return false;
+    }
+
+    return cJSON_ReplaceItemViaPointer(array, get_array_item(array, (size_t)which), newitem);
+}
+
+static cJSON_bool replace_item_in_object(cJSON *object, const char *string, cJSON *replacement, cJSON_bool case_sensitive) {
+    if((replacement == NULL) || (string == NULL)) {
+        return false;
+    }
+
+    /* replace the name in the replacement */
+    if(!(replacement->type & cJSON_StringIsConst) && (replacement->string != NULL)) {
+        cJSON_free(replacement->string);
+    }
+    replacement->string = (char *)cJSON_strdup((const unsigned char *)string, &global_hooks);
+    replacement->type &= ~cJSON_StringIsConst;
+
+    return cJSON_ReplaceItemViaPointer(object, get_object_item(object, string, case_sensitive), replacement);
+}
+
+CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInObject(cJSON *object, const char *string, cJSON *newitem) {
+    return replace_item_in_object(object, string, newitem, false);
+}
+
+CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInObjectCaseSensitive(cJSON *object, const char *string, cJSON *newitem) {
+    return replace_item_in_object(object, string, newitem, true);
+}
+
+/* Create basic types: */
+CJSON_PUBLIC(cJSON *) cJSON_CreateNull(void) {
+    cJSON *item = cJSON_New_Item(&global_hooks);
+    if(item) {
+        item->type = cJSON_NULL;
+    }
+
+    return item;
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_CreateTrue(void) {
+    cJSON *item = cJSON_New_Item(&global_hooks);
+    if(item) {
+        item->type = cJSON_True;
+    }
+
+    return item;
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_CreateFalse(void) {
+    cJSON *item = cJSON_New_Item(&global_hooks);
+    if(item) {
+        item->type = cJSON_False;
+    }
+
+    return item;
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_CreateBool(cJSON_bool boolean) {
+    cJSON *item = cJSON_New_Item(&global_hooks);
+    if(item) {
+        item->type = boolean ? cJSON_True : cJSON_False;
+    }
+
+    return item;
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_CreateNumber(double num) {
+    cJSON *item = cJSON_New_Item(&global_hooks);
+    if(item) {
+        item->type        = cJSON_Number;
+        item->valuedouble = num;
+
+        /* use saturation in case of overflow */
+        if(num >= INT_MAX) {
+            item->valueint = INT_MAX;
+        }
+        else if(num <= (double)INT_MIN) {
+            item->valueint = INT_MIN;
+        }
+        else {
+            item->valueint = (int)num;
+        }
+    }
+
+    return item;
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_CreateString(const char *string) {
+    cJSON *item = cJSON_New_Item(&global_hooks);
+    if(item) {
+        item->type        = cJSON_String;
+        item->valuestring = (char *)cJSON_strdup((const unsigned char *)string, &global_hooks);
+        if(!item->valuestring) {
+            cJSON_Delete(item);
+            return NULL;
+        }
+    }
+
+    return item;
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_CreateStringReference(const char *string) {
+    cJSON *item = cJSON_New_Item(&global_hooks);
+    if(item != NULL) {
+        item->type        = cJSON_String | cJSON_IsReference;
+        item->valuestring = (char *)cast_away_const(string);
+    }
+
+    return item;
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_CreateObjectReference(const cJSON *child) {
+    cJSON *item = cJSON_New_Item(&global_hooks);
+    if(item != NULL) {
+        item->type  = cJSON_Object | cJSON_IsReference;
+        item->child = (cJSON *)cast_away_const(child);
+    }
+
+    return item;
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_CreateArrayReference(const cJSON *child) {
+    cJSON *item = cJSON_New_Item(&global_hooks);
+    if(item != NULL) {
+        item->type  = cJSON_Array | cJSON_IsReference;
+        item->child = (cJSON *)cast_away_const(child);
+    }
+
+    return item;
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_CreateRaw(const char *raw) {
+    cJSON *item = cJSON_New_Item(&global_hooks);
+    if(item) {
+        item->type        = cJSON_Raw;
+        item->valuestring = (char *)cJSON_strdup((const unsigned char *)raw, &global_hooks);
+        if(!item->valuestring) {
+            cJSON_Delete(item);
+            return NULL;
+        }
+    }
+
+    return item;
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_CreateArray(void) {
+    cJSON *item = cJSON_New_Item(&global_hooks);
+    if(item) {
+        item->type = cJSON_Array;
+    }
+
+    return item;
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_CreateObject(void) {
+    cJSON *item = cJSON_New_Item(&global_hooks);
+    if(item) {
+        item->type = cJSON_Object;
+    }
+
+    return item;
+}
+
+/* Create Arrays: */
+CJSON_PUBLIC(cJSON *) cJSON_CreateIntArray(const int *numbers, int count) {
+    size_t i = 0;
+    cJSON *n = NULL;
+    cJSON *p = NULL;
+    cJSON *a = NULL;
+
+    if((count < 0) || (numbers == NULL)) {
+        return NULL;
+    }
+
+    a = cJSON_CreateArray();
+
+    for(i = 0; a && (i < (size_t)count); i++) {
+        n = cJSON_CreateNumber(numbers[i]);
+        if(!n) {
+            cJSON_Delete(a);
+            return NULL;
+        }
+        if(!i) {
+            a->child = n;
+        }
+        else {
+            suffix_object(p, n);
+        }
+        p = n;
+    }
+
+    if(a && a->child) {
+        a->child->prev = n;
+    }
+
+    return a;
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_CreateFloatArray(const float *numbers, int count) {
+    size_t i = 0;
+    cJSON *n = NULL;
+    cJSON *p = NULL;
+    cJSON *a = NULL;
+
+    if((count < 0) || (numbers == NULL)) {
+        return NULL;
+    }
+
+    a = cJSON_CreateArray();
+
+    for(i = 0; a && (i < (size_t)count); i++) {
+        n = cJSON_CreateNumber((double)numbers[i]);
+        if(!n) {
+            cJSON_Delete(a);
+            return NULL;
+        }
+        if(!i) {
+            a->child = n;
+        }
+        else {
+            suffix_object(p, n);
+        }
+        p = n;
+    }
+
+    if(a && a->child) {
+        a->child->prev = n;
+    }
+
+    return a;
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_CreateDoubleArray(const double *numbers, int count) {
+    size_t i = 0;
+    cJSON *n = NULL;
+    cJSON *p = NULL;
+    cJSON *a = NULL;
+
+    if((count < 0) || (numbers == NULL)) {
+        return NULL;
+    }
+
+    a = cJSON_CreateArray();
+
+    for(i = 0; a && (i < (size_t)count); i++) {
+        n = cJSON_CreateNumber(numbers[i]);
+        if(!n) {
+            cJSON_Delete(a);
+            return NULL;
+        }
+        if(!i) {
+            a->child = n;
+        }
+        else {
+            suffix_object(p, n);
+        }
+        p = n;
+    }
+
+    if(a && a->child) {
+        a->child->prev = n;
+    }
+
+    return a;
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_CreateStringArray(const char *const *strings, int count) {
+    size_t i = 0;
+    cJSON *n = NULL;
+    cJSON *p = NULL;
+    cJSON *a = NULL;
+
+    if((count < 0) || (strings == NULL)) {
+        return NULL;
+    }
+
+    a = cJSON_CreateArray();
+
+    for(i = 0; a && (i < (size_t)count); i++) {
+        n = cJSON_CreateString(strings[i]);
+        if(!n) {
+            cJSON_Delete(a);
+            return NULL;
+        }
+        if(!i) {
+            a->child = n;
+        }
+        else {
+            suffix_object(p, n);
+        }
+        p = n;
+    }
+
+    if(a && a->child) {
+        a->child->prev = n;
+    }
+
+    return a;
+}
+
+/* Duplication */
+CJSON_PUBLIC(cJSON *) cJSON_Duplicate(const cJSON *item, cJSON_bool recurse) {
+    cJSON *newitem  = NULL;
+    cJSON *child    = NULL;
+    cJSON *next     = NULL;
+    cJSON *newchild = NULL;
+
+    /* Bail on bad ptr */
+    if(!item) {
+        goto fail;
+    }
+    /* Create new item */
+    newitem = cJSON_New_Item(&global_hooks);
+    if(!newitem) {
+        goto fail;
+    }
+    /* Copy over all vars */
+    newitem->type        = item->type & (~cJSON_IsReference);
+    newitem->valueint    = item->valueint;
+    newitem->valuedouble = item->valuedouble;
+    if(item->valuestring) {
+        newitem->valuestring = (char *)cJSON_strdup((unsigned char *)item->valuestring, &global_hooks);
+        if(!newitem->valuestring) {
+            goto fail;
+        }
+    }
+    if(item->string) {
+        newitem->string = (item->type & cJSON_StringIsConst) ? item->string : (char *)cJSON_strdup((unsigned char *)item->string, &global_hooks);
+        if(!newitem->string) {
+            goto fail;
+        }
+    }
+    /* If non-recursive, then we're done! */
+    if(!recurse) {
+        return newitem;
+    }
+    /* Walk the ->next chain for the child. */
+    child = item->child;
+    while(child != NULL) {
+        newchild = cJSON_Duplicate(child, true); /* Duplicate (with recurse) each item in the ->next chain */
+        if(!newchild) {
+            goto fail;
+        }
+        if(next != NULL) {
+            /* If newitem->child already set, then crosswire ->prev and ->next and move on */
+            next->next     = newchild;
+            newchild->prev = next;
+            next           = newchild;
+        }
+        else {
+            /* Set newitem->child and move to it */
+            newitem->child = newchild;
+            next           = newchild;
+        }
+        child = child->next;
+    }
+    if(newitem && newitem->child) {
+        newitem->child->prev = newchild;
+    }
+
+    return newitem;
+
+fail:
+    if(newitem != NULL) {
+        cJSON_Delete(newitem);
+    }
+
+    return NULL;
+}
+
+static void skip_oneline_comment(char **input) {
+    *input += static_strlen("//");
+
+    for(; (*input)[0] != '\0'; ++(*input)) {
+        if((*input)[0] == '\n') {
+            *input += static_strlen("\n");
+            return;
+        }
+    }
+}
+
+static void skip_multiline_comment(char **input) {
+    *input += static_strlen("/*");
+
+    for(; (*input)[0] != '\0'; ++(*input)) {
+        if(((*input)[0] == '*') && ((*input)[1] == '/')) {
+            *input += static_strlen("*/");
+            return;
+        }
+    }
+}
+
+static void minify_string(char **input, char **output) {
+    (*output)[0] = (*input)[0];
+    *input += static_strlen("\"");
+    *output += static_strlen("\"");
+
+    for(; (*input)[0] != '\0'; (void)++(*input), ++(*output)) {
+        (*output)[0] = (*input)[0];
+
+        if((*input)[0] == '\"') {
+            (*output)[0] = '\"';
+            *input += static_strlen("\"");
+            *output += static_strlen("\"");
+            return;
+        }
+        else if(((*input)[0] == '\\') && ((*input)[1] == '\"')) {
+            (*output)[1] = (*input)[1];
+            *input += static_strlen("\"");
+            *output += static_strlen("\"");
+        }
+    }
+}
+
+CJSON_PUBLIC(void) cJSON_Minify(char *json) {
+    char *into = json;
+
+    if(json == NULL) {
+        return;
+    }
+
+    while(json[0] != '\0') {
+        switch(json[0]) {
+        case ' ':
+        case '\t':
+        case '\r':
+        case '\n':
+            json++;
+            break;
+
+        case '/':
+            if(json[1] == '/') {
+                skip_oneline_comment(&json);
+            }
+            else if(json[1] == '*') {
+                skip_multiline_comment(&json);
+            }
+            else {
+                json++;
+            }
+            break;
+
+        case '\"':
+            minify_string(&json, (char **)&into);
+            break;
+
+        default:
+            into[0] = json[0];
+            json++;
+            into++;
+        }
+    }
+
+    /* and null-terminate. */
+    *into = '\0';
+}
+
+CJSON_PUBLIC(cJSON_bool) cJSON_IsInvalid(const cJSON *const item) {
+    if(item == NULL) {
+        return false;
+    }
+
+    return (item->type & 0xFF) == cJSON_Invalid;
+}
+
+CJSON_PUBLIC(cJSON_bool) cJSON_IsFalse(const cJSON *const item) {
+    if(item == NULL) {
+        return false;
+    }
+
+    return (item->type & 0xFF) == cJSON_False;
+}
+
+CJSON_PUBLIC(cJSON_bool) cJSON_IsTrue(const cJSON *const item) {
+    if(item == NULL) {
+        return false;
+    }
+
+    return (item->type & 0xff) == cJSON_True;
+}
+
+CJSON_PUBLIC(cJSON_bool) cJSON_IsBool(const cJSON *const item) {
+    if(item == NULL) {
+        return false;
+    }
+
+    return (item->type & (cJSON_True | cJSON_False)) != 0;
+}
+CJSON_PUBLIC(cJSON_bool) cJSON_IsNull(const cJSON *const item) {
+    if(item == NULL) {
+        return false;
+    }
+
+    return (item->type & 0xFF) == cJSON_NULL;
+}
+
+CJSON_PUBLIC(cJSON_bool) cJSON_IsNumber(const cJSON *const item) {
+    if(item == NULL) {
+        return false;
+    }
+
+    return (item->type & 0xFF) == cJSON_Number;
+}
+
+CJSON_PUBLIC(cJSON_bool) cJSON_IsString(const cJSON *const item) {
+    if(item == NULL) {
+        return false;
+    }
+
+    return (item->type & 0xFF) == cJSON_String;
+}
+
+CJSON_PUBLIC(cJSON_bool) cJSON_IsArray(const cJSON *const item) {
+    if(item == NULL) {
+        return false;
+    }
+
+    return (item->type & 0xFF) == cJSON_Array;
+}
+
+CJSON_PUBLIC(cJSON_bool) cJSON_IsObject(const cJSON *const item) {
+    if(item == NULL) {
+        return false;
+    }
+
+    return (item->type & 0xFF) == cJSON_Object;
+}
+
+CJSON_PUBLIC(cJSON_bool) cJSON_IsRaw(const cJSON *const item) {
+    if(item == NULL) {
+        return false;
+    }
+
+    return (item->type & 0xFF) == cJSON_Raw;
+}
+
+CJSON_PUBLIC(cJSON_bool) cJSON_Compare(const cJSON *const a, const cJSON *const b, const cJSON_bool case_sensitive) {
+    if((a == NULL) || (b == NULL) || ((a->type & 0xFF) != (b->type & 0xFF))) {
+        return false;
+    }
+
+    /* check if type is valid */
+    switch(a->type & 0xFF) {
+    case cJSON_False:
+    case cJSON_True:
+    case cJSON_NULL:
+    case cJSON_Number:
+    case cJSON_String:
+    case cJSON_Raw:
+    case cJSON_Array:
+    case cJSON_Object:
+        break;
+
+    default:
+        return false;
+    }
+
+    /* identical objects are equal */
+    if(a == b) {
+        return true;
+    }
+
+    switch(a->type & 0xFF) {
+    /* in these cases and equal type is enough */
+    case cJSON_False:
+    case cJSON_True:
+    case cJSON_NULL:
+        return true;
+
+    case cJSON_Number:
+        if(compare_double(a->valuedouble, b->valuedouble)) {
+            return true;
+        }
+        return false;
+
+    case cJSON_String:
+    case cJSON_Raw:
+        if((a->valuestring == NULL) || (b->valuestring == NULL)) {
+            return false;
+        }
+        if(strcmp(a->valuestring, b->valuestring) == 0) {
+            return true;
+        }
+
+        return false;
+
+    case cJSON_Array: {
+        cJSON *a_element = a->child;
+        cJSON *b_element = b->child;
+
+        for(; (a_element != NULL) && (b_element != NULL);) {
+            if(!cJSON_Compare(a_element, b_element, case_sensitive)) {
+                return false;
+            }
+
+            a_element = a_element->next;
+            b_element = b_element->next;
+        }
+
+        /* one of the arrays is longer than the other */
+        if(a_element != b_element) {
+            return false;
+        }
+
+        return true;
+    }
+
+    case cJSON_Object: {
+        cJSON *a_element = NULL;
+        cJSON *b_element = NULL;
+        cJSON_ArrayForEach(a_element, a) {
+            /* TODO This has O(n^2) runtime, which is horrible! */
+            b_element = get_object_item(b, a_element->string, case_sensitive);
+            if(b_element == NULL) {
+                return false;
+            }
+
+            if(!cJSON_Compare(a_element, b_element, case_sensitive)) {
+                return false;
+            }
+        }
+
+        /* doing this twice, once on a and b to prevent true comparison if a subset of b
+         * TODO: Do this the proper way, this is just a fix for now */
+        cJSON_ArrayForEach(b_element, b) {
+            a_element = get_object_item(a, b_element->string, case_sensitive);
+            if(a_element == NULL) {
+                return false;
+            }
+
+            if(!cJSON_Compare(b_element, a_element, case_sensitive)) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    default:
+        return false;
+    }
+}
+
+CJSON_PUBLIC(void *) cJSON_malloc(size_t size) {
+    return global_hooks.allocate(size);
+}
+
+CJSON_PUBLIC(void) cJSON_free(void *object) {
+    global_hooks.deallocate(object);
+}
+
diff --git a/examples/3.advanced.multi_devices_sync_gmsl/utils/cJSON.h b/examples/3.advanced.multi_devices_sync_gmsl/utils/cJSON.h
new file mode 100644
index 00000000..f4a6db5a
--- /dev/null
+++ b/examples/3.advanced.multi_devices_sync_gmsl/utils/cJSON.h
@@ -0,0 +1,298 @@
+/*
+  Copyright (c) 2009-2017 Dave Gamble and cJSON contributors
+
+  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 cJSON__h
+#define cJSON__h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if !defined(__WINDOWS__) && (defined(WIN32) || defined(WIN64) || defined(_MSC_VER) || defined(_WIN32))
+#define __WINDOWS__
+#endif
+
+#ifdef __WINDOWS__
+
+/* When compiling for windows, we specify a specific calling convention to avoid issues where we are being called from a project with a different default
+calling convention.  For windows you have 3 define options:
+
+CJSON_HIDE_SYMBOLS - Define this in the case where you don't want to ever dllexport symbols
+CJSON_EXPORT_SYMBOLS - Define this on library build when you want to dllexport symbols (default)
+CJSON_IMPORT_SYMBOLS - Define this if you want to dllimport symbol
+
+For *nix builds that support visibility attribute, you can define similar behavior by
+
+setting default visibility to hidden by adding
+-fvisibility=hidden (for gcc)
+or
+-xldscope=hidden (for sun cc)
+to CFLAGS
+
+then using the CJSON_API_VISIBILITY flag to "export" the same symbols the way CJSON_EXPORT_SYMBOLS does
+
+*/
+
+#define CJSON_CDECL __cdecl
+#define CJSON_STDCALL __stdcall
+
+/* export symbols by default, this is necessary for copy pasting the C and header file */
+#if !defined(CJSON_HIDE_SYMBOLS) && !defined(CJSON_IMPORT_SYMBOLS) && !defined(CJSON_EXPORT_SYMBOLS)
+#define CJSON_EXPORT_SYMBOLS
+#endif
+
+#if defined(CJSON_HIDE_SYMBOLS)
+#define CJSON_PUBLIC(type) type CJSON_STDCALL
+#elif defined(CJSON_EXPORT_SYMBOLS)
+#define CJSON_PUBLIC(type) __declspec(dllexport) type CJSON_STDCALL
+#elif defined(CJSON_IMPORT_SYMBOLS)
+#define CJSON_PUBLIC(type) __declspec(dllimport) type CJSON_STDCALL
+#endif
+#else /* !__WINDOWS__ */
+#define CJSON_CDECL
+#define CJSON_STDCALL
+
+#if(defined(__GNUC__) || defined(__SUNPRO_CC) || defined(__SUNPRO_C)) && defined(CJSON_API_VISIBILITY)
+#define CJSON_PUBLIC(type) __attribute__((visibility("default"))) type
+#else
+#define CJSON_PUBLIC(type) type
+#endif
+#endif
+
+/* project version */
+#define CJSON_VERSION_MAJOR 1
+#define CJSON_VERSION_MINOR 7
+#define CJSON_VERSION_PATCH 15
+
+#include <stddef.h>
+
+/* cJSON Types: */
+#define cJSON_Invalid (0)
+#define cJSON_False (1 << 0)
+#define cJSON_True (1 << 1)
+#define cJSON_NULL (1 << 2)
+#define cJSON_Number (1 << 3)
+#define cJSON_String (1 << 4)
+#define cJSON_Array (1 << 5)
+#define cJSON_Object (1 << 6)
+#define cJSON_Raw (1 << 7) /* raw json */
+
+#define cJSON_IsReference 256
+#define cJSON_StringIsConst 512
+
+/* The cJSON structure: */
+typedef struct cJSON {
+    /* next/prev allow you to walk array/object chains. Alternatively, use GetArraySize/GetArrayItem/GetObjectItem */
+    struct cJSON *next;
+    struct cJSON *prev;
+    /* An array or object item will have a child pointer pointing to a chain of the items in the array/object. */
+    struct cJSON *child;
+
+    /* The type of the item, as above. */
+    int type;
+
+    /* The item's string, if type==cJSON_String  and type == cJSON_Raw */
+    char *valuestring;
+    /* writing to valueint is DEPRECATED, use cJSON_SetNumberValue instead */
+    int valueint;
+    /* The item's number, if type==cJSON_Number */
+    double valuedouble;
+
+    /* The item's name string, if this item is the child of, or is in the list of subitems of an object. */
+    char *string;
+} cJSON;
+
+typedef struct cJSON_Hooks {
+    /* malloc/free are CDECL on Windows regardless of the default calling convention of the compiler, so ensure the hooks allow passing those functions
+     * directly. */
+    void *(CJSON_CDECL *malloc_fn)(size_t sz);
+    void(CJSON_CDECL *free_fn)(void *ptr);
+} cJSON_Hooks;
+
+typedef int cJSON_bool;
+
+/* Limits how deeply nested arrays/objects can be before cJSON rejects to parse them.
+ * This is to prevent stack overflows. */
+#ifndef CJSON_NESTING_LIMIT
+#define CJSON_NESTING_LIMIT 1000
+#endif
+
+/* returns the version of cJSON as a string */
+CJSON_PUBLIC(const char *) cJSON_Version(void);
+
+/* Supply malloc, realloc and free functions to cJSON */
+CJSON_PUBLIC(void) cJSON_InitHooks(cJSON_Hooks *hooks);
+
+/* Memory Management: the caller is always responsible to free the results from all variants of cJSON_Parse (with cJSON_Delete) and cJSON_Print (with stdlib
+ * free, cJSON_Hooks.free_fn, or cJSON_free as appropriate). The exception is cJSON_PrintPreallocated, where the caller has full responsibility of the buffer.
+ */
+/* Supply a block of JSON, and this returns a cJSON object you can interrogate. */
+CJSON_PUBLIC(cJSON *) cJSON_Parse(const char *value);
+CJSON_PUBLIC(cJSON *) cJSON_ParseWithLength(const char *value, size_t buffer_length);
+/* ParseWithOpts allows you to require (and check) that the JSON is null terminated, and to retrieve the pointer to the final byte parsed. */
+/* If you supply a ptr in return_parse_end and parsing fails, then return_parse_end will contain a pointer to the error so will match cJSON_GetErrorPtr(). */
+CJSON_PUBLIC(cJSON *) cJSON_ParseWithOpts(const char *value, const char **return_parse_end, cJSON_bool require_null_terminated);
+CJSON_PUBLIC(cJSON *) cJSON_ParseWithLengthOpts(const char *value, size_t buffer_length, const char **return_parse_end, cJSON_bool require_null_terminated);
+
+/* Render a cJSON entity to text for transfer/storage. */
+CJSON_PUBLIC(char *) cJSON_Print(const cJSON *item);
+/* Render a cJSON entity to text for transfer/storage without any formatting. */
+CJSON_PUBLIC(char *) cJSON_PrintUnformatted(const cJSON *item);
+/* Render a cJSON entity to text using a buffered strategy. prebuffer is a guess at the final size. guessing well reduces reallocation. fmt=0 gives unformatted,
+ * =1 gives formatted */
+CJSON_PUBLIC(char *) cJSON_PrintBuffered(const cJSON *item, int prebuffer, cJSON_bool fmt);
+/* Render a cJSON entity to text using a buffer already allocated in memory with given length. Returns 1 on success and 0 on failure. */
+/* NOTE: cJSON is not always 100% accurate in estimating how much memory it will use, so to be safe allocate 5 bytes more than you actually need */
+CJSON_PUBLIC(cJSON_bool) cJSON_PrintPreallocated(cJSON *item, char *buffer, const int length, const cJSON_bool format);
+/* Delete a cJSON entity and all subentities. */
+CJSON_PUBLIC(void) cJSON_Delete(cJSON *item);
+
+/* Returns the number of items in an array (or object). */
+CJSON_PUBLIC(int) cJSON_GetArraySize(const cJSON *array);
+/* Retrieve item number "index" from array "array". Returns NULL if unsuccessful. */
+CJSON_PUBLIC(cJSON *) cJSON_GetArrayItem(const cJSON *array, int index);
+/* Get item "string" from object. Case insensitive. */
+CJSON_PUBLIC(cJSON *) cJSON_GetObjectItem(const cJSON *const object, const char *const string);
+CJSON_PUBLIC(cJSON *) cJSON_GetObjectItemCaseSensitive(const cJSON *const object, const char *const string);
+CJSON_PUBLIC(cJSON_bool) cJSON_HasObjectItem(const cJSON *object, const char *string);
+/* For analysing failed parses. This returns a pointer to the parse error. You'll probably need to look a few chars back to make sense of it. Defined when
+ * cJSON_Parse() returns 0. 0 when cJSON_Parse() succeeds. */
+CJSON_PUBLIC(const char *) cJSON_GetErrorPtr(void);
+
+/* Check item type and return its value */
+CJSON_PUBLIC(char *) cJSON_GetStringValue(const cJSON *const item);
+CJSON_PUBLIC(double) cJSON_GetNumberValue(const cJSON *const item);
+
+/* These functions check the type of an item */
+CJSON_PUBLIC(cJSON_bool) cJSON_IsInvalid(const cJSON *const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsFalse(const cJSON *const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsTrue(const cJSON *const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsBool(const cJSON *const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsNull(const cJSON *const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsNumber(const cJSON *const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsString(const cJSON *const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsArray(const cJSON *const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsObject(const cJSON *const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsRaw(const cJSON *const item);
+
+/* These calls create a cJSON item of the appropriate type. */
+CJSON_PUBLIC(cJSON *) cJSON_CreateNull(void);
+CJSON_PUBLIC(cJSON *) cJSON_CreateTrue(void);
+CJSON_PUBLIC(cJSON *) cJSON_CreateFalse(void);
+CJSON_PUBLIC(cJSON *) cJSON_CreateBool(cJSON_bool boolean);
+CJSON_PUBLIC(cJSON *) cJSON_CreateNumber(double num);
+CJSON_PUBLIC(cJSON *) cJSON_CreateString(const char *string);
+/* raw json */
+CJSON_PUBLIC(cJSON *) cJSON_CreateRaw(const char *raw);
+CJSON_PUBLIC(cJSON *) cJSON_CreateArray(void);
+CJSON_PUBLIC(cJSON *) cJSON_CreateObject(void);
+
+/* Create a string where valuestring references a string so
+ * it will not be freed by cJSON_Delete */
+CJSON_PUBLIC(cJSON *) cJSON_CreateStringReference(const char *string);
+/* Create an object/array that only references it's elements so
+ * they will not be freed by cJSON_Delete */
+CJSON_PUBLIC(cJSON *) cJSON_CreateObjectReference(const cJSON *child);
+CJSON_PUBLIC(cJSON *) cJSON_CreateArrayReference(const cJSON *child);
+
+/* These utilities create an Array of count items.
+ * The parameter count cannot be greater than the number of elements in the number array, otherwise array access will be out of bounds.*/
+CJSON_PUBLIC(cJSON *) cJSON_CreateIntArray(const int *numbers, int count);
+CJSON_PUBLIC(cJSON *) cJSON_CreateFloatArray(const float *numbers, int count);
+CJSON_PUBLIC(cJSON *) cJSON_CreateDoubleArray(const double *numbers, int count);
+CJSON_PUBLIC(cJSON *) cJSON_CreateStringArray(const char *const *strings, int count);
+
+/* Append item to the specified array/object. */
+CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToArray(cJSON *array, cJSON *item);
+CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToObject(cJSON *object, const char *string, cJSON *item);
+/* Use this when string is definitely const (i.e. a literal, or as good as), and will definitely survive the cJSON object.
+ * WARNING: When this function was used, make sure to always check that (item->type & cJSON_StringIsConst) is zero before
+ * writing to `item->string` */
+CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToObjectCS(cJSON *object, const char *string, cJSON *item);
+/* Append reference to item to the specified array/object. Use this when you want to add an existing cJSON to a new cJSON, but don't want to corrupt your
+ * existing cJSON. */
+CJSON_PUBLIC(cJSON_bool) cJSON_AddItemReferenceToArray(cJSON *array, cJSON *item);
+CJSON_PUBLIC(cJSON_bool) cJSON_AddItemReferenceToObject(cJSON *object, const char *string, cJSON *item);
+
+/* Remove/Detach items from Arrays/Objects. */
+CJSON_PUBLIC(cJSON *) cJSON_DetachItemViaPointer(cJSON *parent, cJSON *const item);
+CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromArray(cJSON *array, int which);
+CJSON_PUBLIC(void) cJSON_DeleteItemFromArray(cJSON *array, int which);
+CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObject(cJSON *object, const char *string);
+CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObjectCaseSensitive(cJSON *object, const char *string);
+CJSON_PUBLIC(void) cJSON_DeleteItemFromObject(cJSON *object, const char *string);
+CJSON_PUBLIC(void) cJSON_DeleteItemFromObjectCaseSensitive(cJSON *object, const char *string);
+
+/* Update array items. */
+CJSON_PUBLIC(cJSON_bool) cJSON_InsertItemInArray(cJSON *array, int which, cJSON *newitem); /* Shifts pre-existing items to the right. */
+CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemViaPointer(cJSON *const parent, cJSON *const item, cJSON *replacement);
+CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInArray(cJSON *array, int which, cJSON *newitem);
+CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInObject(cJSON *object, const char *string, cJSON *newitem);
+CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInObjectCaseSensitive(cJSON *object, const char *string, cJSON *newitem);
+
+/* Duplicate a cJSON item */
+CJSON_PUBLIC(cJSON *) cJSON_Duplicate(const cJSON *item, cJSON_bool recurse);
+/* Duplicate will create a new, identical cJSON item to the one you pass, in new memory that will
+ * need to be released. With recurse!=0, it will duplicate any children connected to the item.
+ * The item->next and ->prev pointers are always zero on return from Duplicate. */
+/* Recursively compare two cJSON items for equality. If either a or b is NULL or invalid, they will be considered unequal.
+ * case_sensitive determines if object keys are treated case sensitive (1) or case insensitive (0) */
+CJSON_PUBLIC(cJSON_bool) cJSON_Compare(const cJSON *const a, const cJSON *const b, const cJSON_bool case_sensitive);
+
+/* Minify a strings, remove blank characters(such as ' ', '\t', '\r', '\n') from strings.
+ * The input pointer json cannot point to a read-only address area, such as a string constant,
+ * but should point to a readable and writable address area. */
+CJSON_PUBLIC(void) cJSON_Minify(char *json);
+
+/* Helper functions for creating and adding items to an object at the same time.
+ * They return the added item or NULL on failure. */
+CJSON_PUBLIC(cJSON *) cJSON_AddNullToObject(cJSON *const object, const char *const name);
+CJSON_PUBLIC(cJSON *) cJSON_AddTrueToObject(cJSON *const object, const char *const name);
+CJSON_PUBLIC(cJSON *) cJSON_AddFalseToObject(cJSON *const object, const char *const name);
+CJSON_PUBLIC(cJSON *) cJSON_AddBoolToObject(cJSON *const object, const char *const name, const cJSON_bool boolean);
+CJSON_PUBLIC(cJSON *) cJSON_AddNumberToObject(cJSON *const object, const char *const name, const double number);
+CJSON_PUBLIC(cJSON *) cJSON_AddStringToObject(cJSON *const object, const char *const name, const char *const string);
+CJSON_PUBLIC(cJSON *) cJSON_AddRawToObject(cJSON *const object, const char *const name, const char *const raw);
+CJSON_PUBLIC(cJSON *) cJSON_AddObjectToObject(cJSON *const object, const char *const name);
+CJSON_PUBLIC(cJSON *) cJSON_AddArrayToObject(cJSON *const object, const char *const name);
+
+/* When assigning an integer value, it needs to be propagated to valuedouble too. */
+#define cJSON_SetIntValue(object, number) ((object) ? (object)->valueint = (object)->valuedouble = (number) : (number))
+/* helper for the cJSON_SetNumberValue macro */
+CJSON_PUBLIC(double) cJSON_SetNumberHelper(cJSON *object, double number);
+#define cJSON_SetNumberValue(object, number) ((object != NULL) ? cJSON_SetNumberHelper(object, (double)number) : (number))
+/* Change the valuestring of a cJSON_String object, only takes effect when type of object is cJSON_String */
+CJSON_PUBLIC(char *) cJSON_SetValuestring(cJSON *object, const char *valuestring);
+
+/* Macro for iterating over an array or object */
+#define cJSON_ArrayForEach(element, array) for(element = (array != NULL) ? (array)->child : NULL; element != NULL; element = element->next)
+
+/* malloc/free objects using the malloc/free functions that have been set with cJSON_InitHooks */
+CJSON_PUBLIC(void *) cJSON_malloc(size_t size);
+CJSON_PUBLIC(void) cJSON_free(void *object);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
diff --git a/examples/3.advanced.multi_devices_sync_gmsltrigger/CMakeLists.txt b/examples/3.advanced.multi_devices_sync_gmsltrigger/CMakeLists.txt
new file mode 100644
index 00000000..f628d22f
--- /dev/null
+++ b/examples/3.advanced.multi_devices_sync_gmsltrigger/CMakeLists.txt
@@ -0,0 +1,15 @@
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+cmake_minimum_required(VERSION 3.5)
+project(ob_multi_devices_sync_gmsltrigger)
+
+add_executable(${PROJECT_NAME} ob_multi_devices_sync_gmsltrigger.cpp)
+
+set_property(TARGET ${PROJECT_NAME} PROPERTY CXX_STANDARD 11)
+target_link_libraries(${PROJECT_NAME} ob::OrbbecSDK ob::examples::utils)
+
+set_target_properties(${PROJECT_NAME} PROPERTIES FOLDER "examples")
+
+install(TARGETS ${PROJECT_NAME} RUNTIME DESTINATION bin)
+
diff --git a/examples/3.advanced.multi_devices_sync_gmsltrigger/README.md b/examples/3.advanced.multi_devices_sync_gmsltrigger/README.md
new file mode 100644
index 00000000..5728886f
--- /dev/null
+++ b/examples/3.advanced.multi_devices_sync_gmsltrigger/README.md
@@ -0,0 +1,114 @@
+# C++ Sample: 3.advanced.multi_devices_sync_gmsltrigger
+
+## Overview
+
+GMSL Multi-device Hardware Trigger Configuration
+
+support Connection of GMSL device (Nvidia Xavier/Orin platform)
+
+### Knowledge
+
+Send a hardware synchronization signal with a set frequency to all connected GMSL devices for multi-machine hardware synchronization through the /dev/camsync device node.
+
+## Code overview
+
+1.open /dev/camsync device.
+
+2.set trigger frequency
+
+```cpp
+         int startTrigger(uint16_t triggerFps) {
+           if(!isDeviceOpen) {
+               if(openDevice() < 0) {
+                   error("open device Failed!");
+                   return -1;
+               }
+           }
+           cs_param_t wt_param = { WRITE_MODE, triggerFps };
+           int        ret      = writeTriggerParam(wt_param);
+           if(ret < 0) {
+               error("write trigger parameter Failed!");
+               return ret;
+           }
+           info("write param: ", wt_param);
+
+           cs_param_t rd_param = { READ_MODE, 0 };
+           ret                 = readTriggerParam(rd_param);
+           if(ret < 0) {
+               error("read trigger parameter Failed!");
+           }
+           info("read param: ", rd_param);
+
+           return ret;
+       }
+```
+
+## Run Sample
+
+### 1.**Setup of Trigger Source and Device Node Permissions**
+
+```
+sudo  chmod  777  /dev/camsync
+```
+
+### 2.**Running Configuration and Triggering Program**
+
+The program is located in the Example/bin directory of the orbbecsdk.
+
+Sample Configuration: 30FPS and Trigger Source Frequency of 3000
+
+```
+orbbec@agx:~/SensorSDK/build/install/Example/bin$   ./MultiDeviceSyncGmslTrigger
+Please select options: 
+------------------------------------------------------------
+ 0 --> config GMSL SOC hardware trigger Source. Set trigger fps: 
+ 1 --> start Trigger 
+ 2 --> stop Trigger 
+ 3 --> exit 
+------------------------------------------------------------
+input select item: 0
+
+Enter FPS (frames per second) (for example: 3000): 3000
+Setting FPS to 3000...
+Please select options: 
+------------------------------------------------------------
+ 0 --> config GMSL SOC hardware trigger Source. Set trigger fps: 
+ 1 --> start Trigger 
+ 2 --> stop Trigger 
+ 3 --> exit 
+------------------------------------------------------------
+input select item: 1
+
+write param:  mode=1, fps=3000
+read param:  mode=1, fps=3000
+start pwm source TriggerSync... 
+
+Please select options: 
+------------------------------------------------------------
+ 0 --> config GMSL SOC hardware trigger Source. Set trigger fps: 
+ 1 --> start Trigger 
+ 2 --> stop Trigger 
+ 3 --> exit 
+------------------------------------------------------------
+input select item: 
+
+```
+
+**Brief description of configuring the trigger program**
+
+Please select options:
+
+ 0 --> config GMSL SOC hardware trigger Source. Set trigger fps:
+ 1 --> start Trigger
+ 2 --> stop Trigger
+ 3 --> exit
+
+0: Configure the frequency of the SOC hardware trigger source.
+
+(config trigger frequency as 3000 (Note: It is recommended to configure the trigger frequency to be equal to or less than the set video frame frequency. For example, if the set video frame frequency is 30FPS, the trigger frequency should be 3000 or less.)
+
+1: Start hardware tigger.  (start send hardware signal triggering at the configured trigger frequency)
+
+2: Stop triggering
+
+3: Exit the program
diff --git a/examples/3.advanced.multi_devices_sync_gmsltrigger/ob_multi_devices_sync_gmsltrigger.cpp b/examples/3.advanced.multi_devices_sync_gmsltrigger/ob_multi_devices_sync_gmsltrigger.cpp
new file mode 100644
index 00000000..4d32812f
--- /dev/null
+++ b/examples/3.advanced.multi_devices_sync_gmsltrigger/ob_multi_devices_sync_gmsltrigger.cpp
@@ -0,0 +1,167 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+/*
+Notes: MultiDeviceSyncGmslSocTrigger for GMSL device
+on the nvidia arm64 xavier/orin platform ,this sample use nvidia platform soc pwm trigger to sync multi device.
+*/
+#ifdef __linux__
+#include <libobsensor/ObSensor.hpp>
+#include <unistd.h>
+#include <fcntl.h>
+#include <iostream>
+#include <string>
+
+static const char *  DEVICE_PATH = "/dev/camsync";
+static const uint8_t WRITE_MODE  = 1;
+static const uint8_t READ_MODE   = 0;
+
+typedef struct {
+    uint8_t  mode;
+    uint16_t fps;
+} cs_param_t;
+
+class PwmTrigger {
+public:
+    PwmTrigger() : fd(-1), isDeviceOpen(false) {}
+    ~PwmTrigger() {
+        closeDevice();
+    }
+    int startTrigger(uint16_t triggerFps) {
+        if(!isDeviceOpen) {
+            if(openDevice() < 0) {
+                error("open device Failed!");
+                return -1;
+            }
+        }
+        cs_param_t wt_param = { WRITE_MODE, triggerFps };
+        int        ret      = writeTriggerParam(wt_param);
+        if(ret < 0) {
+            error("write trigger parameter Failed!");
+            return ret;
+        }
+        info("write param: ", wt_param);
+
+        cs_param_t rd_param = { READ_MODE, 0 };
+        ret                 = readTriggerParam(rd_param);
+        if(ret < 0) {
+            error("read trigger parameter Failed!");
+        }
+        info("read param: ", rd_param);
+
+        return ret;
+    }
+
+    int stopTrigger() {
+        int ret = 0;
+        if(isDeviceOpen) {
+            ret = closeDevice();
+        }
+        return ret;
+    }
+
+    void info(const std::string &msg, const cs_param_t &param) {
+        std::cout << msg << " mode=" << static_cast<int>(param.mode) << ", fps=" << param.fps << std::endl;
+    }
+    void error(const std::string &msg) {
+        std::cerr << "Error: " << msg << std::endl;
+    }
+
+private:
+    int openDevice() {
+        fd = open(DEVICE_PATH, O_RDWR);
+        if(fd < 0) {
+            error("open /dev/camsync failed");
+            return fd;
+        }
+        isDeviceOpen = true;
+        return fd;
+    }
+    int closeDevice() {
+        if(isDeviceOpen) {
+            isDeviceOpen = false;
+            int ret      = close(fd);
+            fd           = -1;
+            if(ret < 0) {
+                error("close /dev/camsync failed: " + std::to_string(errno));
+                return ret;
+            }
+        }
+        return 0;
+    }
+    int writeTriggerParam(const cs_param_t &param) {
+        int ret = write(fd, &param, sizeof(param));
+        if(ret < 0) {
+            error("write /dev/camsync failed: " + std::to_string(errno));
+        }
+        return ret;
+    }
+    int readTriggerParam(cs_param_t &param) {
+        int ret = read(fd, &param, sizeof(param));
+        if(ret < 0) {
+            error("read /dev/camsync failed: " + std::to_string(errno));
+        }
+        return ret;
+    }
+
+private:
+    int  fd;
+    bool isDeviceOpen;
+};
+
+int main(void) try {
+    PwmTrigger                pwmTrigger;
+    uint16_t                  fps            = 0;
+    constexpr std::streamsize maxInputIgnore = 10000;
+    while(true) {
+        std::cout << "Please select options: \n"
+                  << "------------------------------------------------------------\n"
+                  << " 0 --> config GMSL SOC PWM trigger Source. Set trigger fps: \n"
+                  << " 1 --> start Trigger \n"
+                  << " 2 --> stop Trigger \n"
+                  << " 3 --> exit \n"
+                  << "------------------------------------------------------------\n"
+                  << "input select item: ";
+        int index = -1;
+        // std::cin >> index;
+        if(!(std::cin >> index)) {
+            std::cin.clear();
+            std::cin.ignore(maxInputIgnore, '\n');
+            std::cout << "Invalid input. Please enter a number." << std::endl;
+            continue;
+        }
+        std::cout << std::endl;
+
+        switch(index) {
+        case 0:
+            std::cout << "Enter FPS (frames per second) (for example: 3000): ";
+            std::cin >> fps;  // set the FPS here
+            std::cout << "Setting FPS to " << fps << "..." << std::endl;
+            break;
+        case 1:
+            if(pwmTrigger.startTrigger(fps) < 0) {
+                std::cerr << "Failed to start trigger." << std::endl;
+            }
+            std::cout << "start pwm source TriggerSync... \n" << std::endl;
+            break;
+        case 2:
+            pwmTrigger.stopTrigger();
+            std::cout << "stop pwm source TriggerSync... \n" << std::endl;
+            break;
+        case 3:
+            pwmTrigger.stopTrigger();
+            std::cout << "Program exit & clse device! \n" << std::endl;
+            return 0;
+        default:
+            std::cout << "-input Invalid index. \n"
+                      << "-Please re-select and input valid param. \n";
+        }
+    }
+    return 0;
+}
+catch(ob::Error &e) {
+    std::cerr << "function:" << e.getFunction() << "\nargs:" << e.getArgs() << "\nmessage:" << e.what() << "\ntype:" << e.getExceptionType() << std::endl;
+    exit(EXIT_FAILURE);
+}
+
+#endif
diff --git a/examples/3.advanced.point_cloud/CMakeLists.txt b/examples/3.advanced.point_cloud/CMakeLists.txt
new file mode 100644
index 00000000..a68ceb3e
--- /dev/null
+++ b/examples/3.advanced.point_cloud/CMakeLists.txt
@@ -0,0 +1,14 @@
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+cmake_minimum_required(VERSION 3.5)
+project(ob_point_cloud)
+
+add_executable(ob_point_cloud point_cloud.cpp)
+
+set_property(TARGET ob_point_cloud PROPERTY CXX_STANDARD 11)
+target_link_libraries(ob_point_cloud ob::OrbbecSDK ob::examples::utils)
+
+set_target_properties(ob_point_cloud PROPERTIES FOLDER "examples")
+
+install(TARGETS ob_point_cloud RUNTIME DESTINATION bin)
diff --git a/examples/3.advanced.point_cloud/README.md b/examples/3.advanced.point_cloud/README.md
new file mode 100644
index 00000000..ad2df1b2
--- /dev/null
+++ b/examples/3.advanced.point_cloud/README.md
@@ -0,0 +1,56 @@
+# C++ Sample: 3.advanced.point_clout
+
+## Overview
+
+Connect the device to open the stream, generate a depth point cloud or RGBD point cloud and save it as a ply format file, and exit the program through the ESC\_KEY key
+
+### Knowledge
+
+Pipeline is a pipeline for processing data streams, providing multi-channel stream configuration, switching, frame aggregation, and frame synchronization functions
+
+## Code overview
+
+1. Create Align Filter and point cloud Filter.
+
+    ```cpp
+        // Create a point cloud Filter, which will be used to generate pointcloud frame from depth and color frames.
+        auto pointCloud = std::make_shared<ob::PointCloudFilter>();
+        auto align = std::make_shared<ob::Align>(OB_STREAM_COLOR); // align depth frame to color frame
+    ```
+
+2. Create RGBD Point Cloud.Note that the AlignFilter processing is needed before the PointCloud processing.
+
+    ```cpp
+        // align depth frame to color frame
+        auto alignedFrameset = align->process(frameset);
+
+        // set to create RGBD point cloud format (will be effective only if color frame and depth frame are contained in the frameset)
+        pointCloud->setCreatePointFormat(OB_FORMAT_RGB_POINT);
+
+        // process the frameset to generate point cloud frame
+        std::shared_ptr<ob::Frame> frame = pointCloud->process(alignedFrameset);
+    ```
+
+3. create Depth PointCloud
+
+    ```cpp
+            // set to create depth point cloud format
+        auto alignedFrameset = align->process(frameset);
+
+        // set to create point cloud format
+        pointCloud->setCreatePointFormat(OB_FORMAT_POINT);
+
+        // process the frameset to generate point cloud frame (pass into a single depth frame to process is also valid)
+        std::shared_ptr<ob::Frame> frame = pointCloud->process(alignedFrameset);
+    ```
+
+## Run Sample
+
+Press R or r to create RGBD PointCloud and save to ply file!
+Press D or d to create Depth PointCloud and save to ply file!
+
+Press ESC to exit!
+
+### Result
+
+![image](../../docs/resource/point_cloud.jpg)
diff --git a/examples/3.advanced.point_cloud/point_cloud.cpp b/examples/3.advanced.point_cloud/point_cloud.cpp
new file mode 100644
index 00000000..4a9ad2a3
--- /dev/null
+++ b/examples/3.advanced.point_cloud/point_cloud.cpp
@@ -0,0 +1,183 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include <libobsensor/ObSensor.hpp>
+
+#include "utils.hpp"
+
+#include <fstream>
+#include <iostream>
+
+#define KEY_ESC 27
+#define KEY_R 82
+#define KEY_r 114
+
+// Save point cloud data to ply
+void savePointsToPly(std::shared_ptr<ob::Frame> frame, std::string fileName) {
+    // get point cloud size (number of points)
+    uint32_t pointsSize = frame->getDataSize() / sizeof(OBPoint);
+
+    // open file for writing, ply format
+    FILE *fp         = fopen(fileName.c_str(), "wb+");
+    fprintf(fp, "ply\n");
+    fprintf(fp, "format ascii 1.0\n");
+    fprintf(fp, "element vertex %d\n", pointsSize);
+    fprintf(fp, "property float x\n");
+    fprintf(fp, "property float y\n");
+    fprintf(fp, "property float z\n");
+    fprintf(fp, "end_header\n");
+
+    // get point cloud data
+    auto data = frame->getData();
+
+    // cast data to OBPoint pointer
+    auto point = reinterpret_cast<OBPoint *>(data);
+
+    // iterate through all points and save to file
+    for(uint32_t i = 0; i < pointsSize; i++) {
+        fprintf(fp, "%.3f %.3f %.3f\n", point->x, point->y, point->z);
+        point++;
+    }
+
+    // flush and close file
+    fflush(fp);
+    fclose(fp);
+}
+
+// Save colored point cloud data to ply
+void saveRGBPointsToPly(std::shared_ptr<ob::Frame> frame, std::string fileName) {
+    // get point cloud size (number of points)
+    uint32_t pointsSize = frame->getDataSize() / sizeof(OBColorPoint);
+
+    // open file for writing, ply format
+    FILE *fp         = fopen(fileName.c_str(), "wb+");
+    fprintf(fp, "ply\n");
+    fprintf(fp, "format ascii 1.0\n");
+    fprintf(fp, "element vertex %d\n", pointsSize);
+    fprintf(fp, "property float x\n");
+    fprintf(fp, "property float y\n");
+    fprintf(fp, "property float z\n");
+    fprintf(fp, "property uchar red\n");
+    fprintf(fp, "property uchar green\n");
+    fprintf(fp, "property uchar blue\n");
+    fprintf(fp, "end_header\n");
+
+    // get point cloud data
+    auto data = frame->getData();
+
+    // cast data to OBColorPoint pointer
+    auto point = reinterpret_cast<OBColorPoint *>(data);
+
+    // iterate through all points and save to file
+    for(uint32_t i = 0; i < pointsSize; i++) {
+        fprintf(fp, "%.3f %.3f %.3f %d %d %d\n", point->x, point->y, point->z, (int)point->r, (int)point->g, (int)point->b);
+        point++;
+    }
+
+    // flush and close file
+    fflush(fp);
+    fclose(fp);
+}
+
+int main(void) try {
+
+    // create config to configure the pipeline streams
+    auto config = std::make_shared<ob::Config>();
+
+    // enable depth and color streams with specified format
+    config->enableVideoStream(OB_STREAM_DEPTH, OB_WIDTH_ANY, OB_HEIGHT_ANY, OB_FPS_ANY, OB_FORMAT_Y16);
+    config->enableVideoStream(OB_STREAM_COLOR, OB_WIDTH_ANY, OB_HEIGHT_ANY, OB_FPS_ANY, OB_FORMAT_RGB);
+
+    // set frame aggregate output mode to all type frame require. therefor, the output frameset will contain all type of frames
+    config->setFrameAggregateOutputMode(OB_FRAME_AGGREGATE_OUTPUT_ALL_TYPE_FRAME_REQUIRE);
+
+    // create pipeline to manage the streams
+    auto pipeline = std::make_shared<ob::Pipeline>();
+
+    // Enable frame synchronization to ensure depth frame and color frame on output frameset are synchronized.
+    pipeline->enableFrameSync();
+
+    // Start pipeline with config
+    pipeline->start(config);
+
+    // Create a point cloud Filter, which will be used to generate pointcloud frame from depth and color frames.
+    auto pointCloud = std::make_shared<ob::PointCloudFilter>();
+
+    // Create a Align Filter, which will be used to align depth frame and color frame.
+    auto align = std::make_shared<ob::Align>(OB_STREAM_COLOR);  // align depth frame to color frame
+
+    // operation prompt
+    std::cout << "Depth and Color stream are started!" << std::endl;
+    std::cout << "Press R or r to create RGBD PointCloud and save to ply file! " << std::endl;
+    std::cout << "Press D or d to create Depth PointCloud and save to ply file! " << std::endl;
+    std::cout << "Press ESC to exit! " << std::endl;
+
+    while(true) {
+        auto key = ob_smpl::waitForKeyPressed();
+        if(key == 27) {
+            break;
+        }
+
+        if(key == 'r' || key == 'R') {
+            std::cout << "Save RGBD PointCloud to ply file, this will take some time..." << std::endl;
+
+            std::shared_ptr<ob::FrameSet> frameset = nullptr;
+            while(true) {
+                frameset = pipeline->waitForFrameset(1000);
+                if (frameset) {
+                    break;
+                }
+            }
+
+            // align depth frame to color frame
+            auto alignedFrameset = align->process(frameset);
+
+            // set to create RGBD point cloud format (will be effective only if color frame and depth frame are contained in the frameset)
+            pointCloud->setCreatePointFormat(OB_FORMAT_RGB_POINT);
+
+            // process the frameset to generate point cloud frame
+            std::shared_ptr<ob::Frame> frame = pointCloud->process(alignedFrameset);
+
+            // save point cloud data to ply file
+            saveRGBPointsToPly(frame, "RGBPoints.ply");
+
+            std::cout << "RGBPoints.ply Saved" << std::endl;
+        }
+        else if(key == 'd' || key == 'D') {
+            std::cout << "Save Depth PointCloud to ply file, this will take some time..." << std::endl;
+
+            std::shared_ptr<ob::FrameSet> frameset = nullptr;
+            while(true) {
+                frameset = pipeline->waitForFrameset(1000);
+                if (frameset) {
+                    break;
+                }
+            }
+
+            // set to create depth point cloud format
+            auto alignedFrameset = align->process(frameset);
+
+            // set to create point cloud format
+            pointCloud->setCreatePointFormat(OB_FORMAT_POINT);
+
+            // process the frameset to generate point cloud frame (pass into a single depth frame to process is also valid)
+            std::shared_ptr<ob::Frame> frame = pointCloud->process(alignedFrameset);
+
+            // save point cloud data to ply file
+            savePointsToPly(frame, "DepthPoints.ply");
+
+            std::cout << "DepthPoints.ply Saved" << std::endl;
+        }
+    }
+    // stop the pipeline
+    pipeline->stop();
+
+    return 0;
+}
+catch(ob::Error &e) {
+    std::cerr << "function:" << e.getFunction() << "\nargs:" << e.getArgs() << "\nmessage:" << e.what() << "\ntype:" << e.getExceptionType() << std::endl;
+    std::cout << "\nPress any key to exit.";
+    ob_smpl::waitForKeyPressed();
+    exit(EXIT_FAILURE);
+}
+
diff --git a/examples/3.advanced.post_processing/CMakeLists.txt b/examples/3.advanced.post_processing/CMakeLists.txt
new file mode 100644
index 00000000..482ca4fe
--- /dev/null
+++ b/examples/3.advanced.post_processing/CMakeLists.txt
@@ -0,0 +1,14 @@
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+cmake_minimum_required(VERSION 3.5)
+project(ob_post_processing)
+
+add_executable(ob_post_processing post_processing.cpp)
+
+set_property(TARGET ob_post_processing PROPERTY CXX_STANDARD 11)
+target_link_libraries(ob_post_processing ob::OrbbecSDK ob::examples::utils)
+set_target_properties(ob_post_processing PROPERTIES FOLDER "examples")
+
+install(TARGETS ob_post_processing RUNTIME DESTINATION bin)
+
diff --git a/examples/3.advanced.post_processing/README.md b/examples/3.advanced.post_processing/README.md
new file mode 100644
index 00000000..b7e6960e
--- /dev/null
+++ b/examples/3.advanced.post_processing/README.md
@@ -0,0 +1,81 @@
+# C++ Sample: 3.advanced.post_processing
+
+## Overview
+
+Use the SDK interface to  demonstrate post-processing operations, display post-processed images, and exit the program using the ESC_KEY key
+
+### Knowledge
+
+Pipeline is a pipeline for processing data streams, providing multi-channel stream configuration, switching, frame aggregation, and frame synchronization functions
+
+Frameset is a combination of different types of Frames
+
+win is used to display the frame data.
+
+## Code overview
+
+1. Get the device and sensor, and create the list of recommended filters for the sensor
+
+    ```cpp
+        auto device     = pipe.getDevice();
+        auto sensor     = device->getSensor(OB_SENSOR_DEPTH);
+        auto filterList = sensor->createRecommendedFilters();
+    ```
+
+2. The filter operation.
+
+    - Get the type of filter
+
+    ```cpp
+    filter->getName()
+    ```
+
+    - Get the Config Schema Vec object
+
+    ```cpp
+    filter->getConfigSchemaVec()
+    ```
+
+    - Enable the filter
+
+    ```cpp
+    filter->enable(tokens[1] == "on");
+    ```
+
+    - Get the Config Value object by name.
+
+    ```cpp
+    filter->getConfigValue(configSchema.name)
+    ```
+
+    - Get the Enable State of the filter.
+
+    ```cpp
+    filter->isEnabled()
+    ```
+
+    - Set the filter config value by name.
+
+    ```cpp
+    filter->setConfigValue(tokens[1], value);
+    ```
+
+3. Apply the recommended filters to the depth frame
+
+    ```cpp
+        auto processedFrame = depthFrame;
+        // Apply the recommended filters to the depth frame
+        for(auto &filter: filterList) {
+            if(filter->isEnabled()) {  // Only apply enabled filters
+                processedFrame = filter->process(processedFrame);
+            }
+        }
+    ````
+
+## Run Sample
+
+Press the button according to the interface prompts
+
+### Result
+
+![image](../../docs/resource/post_processing.jpg)
diff --git a/examples/3.advanced.post_processing/post_processing.cpp b/examples/3.advanced.post_processing/post_processing.cpp
new file mode 100644
index 00000000..4bac8461
--- /dev/null
+++ b/examples/3.advanced.post_processing/post_processing.cpp
@@ -0,0 +1,195 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include <libobsensor/ObSensor.h>
+
+#include "utils.hpp"
+#include "utils_opencv.hpp"
+
+#include <thread>
+
+bool quit_program = false;  // Flag to signal the program to quit
+
+void printFiltersInfo(const std::vector<std::shared_ptr<ob::Filter>> &filterList) {
+    std::cout << filterList.size() << " post processing filters recommended:" << std::endl;
+    for(auto &filter: filterList) {
+        std::cout << " - " << filter->getName() << ": " << (filter->isEnabled() ? "enabled" : "disabled") << std::endl;
+        auto configSchemaVec = filter->getConfigSchemaVec();
+
+        // Print the config schema for each filter
+        for(auto &configSchema: configSchemaVec) {
+            std::cout << "    - {" << configSchema.name << ", " << configSchema.type << ", " << configSchema.min << ", " << configSchema.max << ", "
+                      << configSchema.step << ", " << configSchema.def << ", " << configSchema.desc << "}" << std::endl;
+        }
+        filter->enable(false);  // Disable the filter
+    }
+}
+
+void filterControl(const std::vector<std::shared_ptr<ob::Filter>> &filterList) {
+    auto printHelp = [&]() {
+        std::cout << "Available commands:" << std::endl;
+        std::cout << "- Enter `[Filter]` to list the config values for the filter" << std::endl;
+        std::cout << "- Enter `[Filter] on` or `[Filter] off` to enable/disable the filter" << std::endl;
+        std::cout << "- Enter `[Filter] list` to list the config schema for the filter" << std::endl;
+        std::cout << "- Enter `[Filter] [Config]` to show the config values for the filter" << std::endl;
+        std::cout << "- Enter `[Filter] [Config] [Value]` to set a config value" << std::endl;
+        std::cout << "- Enter `L`or `l` to list all available filters" << std::endl;
+        std::cout << "- Enter `H` or `h` to print this help message" << std::endl;
+        std::cout << "- Enter `Q` or `q` to quit" << std::endl;
+    };
+    printHelp();
+    while(!quit_program) {
+        std::cout << "---------------------------" << std::endl;
+        std::cout << "Enter your input (h for help): ";
+
+        std::string input;
+        std::getline(std::cin, input);
+        if(input == "q" || input == "Q") {
+            quit_program = true;
+            break;
+        }
+        else if(input == "l" || input == "L") {
+            printFiltersInfo(filterList);
+            continue;
+        }
+        else if(input == "h" || input == "H") {
+            printHelp();
+            continue;
+        }
+
+        // Parse the input
+        std::vector<std::string> tokens;
+        std::istringstream       iss(input);
+        for(std::string token; iss >> token;) {
+            tokens.push_back(token);
+        }
+        if(tokens.empty()) {
+            continue;
+        }
+
+        bool foundFilter = false;
+        for(auto &filter: filterList) {
+            if(filter->getName() == tokens[0]) {
+                foundFilter = true;
+                if(tokens.size() == 1) {  // print list of configs for the filter
+                    auto configSchemaVec = filter->getConfigSchemaVec();
+                    std::cout << "Config values for " << filter->getName() << ":" << std::endl;
+                    for(auto &configSchema: configSchemaVec) {
+                        std::cout << " - " << configSchema.name << ": " << filter->getConfigValue(configSchema.name) << std::endl;
+                    }
+                }
+                else if(tokens.size() == 2 && (tokens[1] == "on" || tokens[1] == "off")) {  // Enable/disable the filter
+                    filter->enable(tokens[1] == "on");
+                    std::cout << "Success: Filter " << filter->getName() << " is now " << (filter->isEnabled() ? "enabled" : "disabled") << std::endl;
+                }
+                else if(tokens.size() == 2 && tokens[1] == "list") {  // List the config values for the filter
+                    auto configSchemaVec = filter->getConfigSchemaVec();
+                    std::cout << "Config schema for " << filter->getName() << ":" << std::endl;
+                    for(auto &configSchema: configSchemaVec) {
+                        std::cout << " - {" << configSchema.name << ", " << configSchema.type << ", " << configSchema.min << ", " << configSchema.max << ", "
+                                  << configSchema.step << ", " << configSchema.def << ", " << configSchema.desc << "}" << std::endl;
+                    }
+                }
+                else if(tokens.size() == 2) {  // Print the config schema for the filter
+                    auto configSchemaVec = filter->getConfigSchemaVec();
+                    bool foundConfig     = false;
+                    for(auto &configSchema: configSchemaVec) {
+                        if(configSchema.name == tokens[1]) {
+                            foundConfig = true;
+                            std::cout << "Config values for " << filter->getName() << "@" << configSchema.name << ":"
+                                      << filter->getConfigValue(configSchema.name) << std::endl;
+                            break;
+                        }
+                    }
+                    if(!foundConfig) {
+                        std::cerr << "Error: Config " << tokens[1] << " not found for filter " << filter->getName() << std::endl;
+                    }
+                }
+                else if(tokens.size() == 3) {  // Set a config value
+                    try {
+                        double value = std::stod(tokens[2]);
+                        filter->setConfigValue(tokens[1], value);
+                    }
+                    catch(const std::exception &e) {
+                        std::cerr << "Error: " << e.what() << std::endl;
+                        continue;
+                    }
+                    std::cout << "Success: Config value of " << tokens[1] << " for filter " << filter->getName() << " is set to " << tokens[2] << std::endl;
+                }
+                break;
+            }
+        }
+        if(!foundFilter) {
+            std::cerr << "Error: Filter " << tokens[0] << " not found" << std::endl;
+        }
+        std::this_thread::sleep_for(std::chrono::milliseconds(500));
+    }
+}
+
+int main() try {
+    // Create a pipeline with default device
+    ob::Pipeline pipe;
+
+    // Get the device and sensor, and get the list of recommended filters for the sensor
+    auto device     = pipe.getDevice();
+    auto sensor     = device->getSensor(OB_SENSOR_DEPTH);
+    auto filterList = sensor->createRecommendedFilters();
+
+    // Print the recommended filters
+    printFiltersInfo(filterList);
+
+    // Create a config with depth stream enabled
+    std::shared_ptr<ob::Config> config = std::make_shared<ob::Config>();
+    config->enableStream(OB_STREAM_DEPTH);
+
+    // Start the pipeline with config
+    pipe.start(config);
+
+    // Start the filter control loop on sub thread
+    std::thread filterControlThread(filterControl, filterList);
+    filterControlThread.detach();
+
+    // Create a window for rendering, and set the resolution of the window
+    ob_smpl::CVWindow win("PostProcessing", 1280, 720, ob_smpl::ARRANGE_ONE_ROW);
+
+    while(win.run() && !quit_program) {
+        // Wait for up to 1000ms for a frameset in blocking mode.
+        auto frameSet = pipe.waitForFrameset(1000);
+        if(frameSet == nullptr) {
+            continue;
+        }
+
+        // Get the depth frame from the frameset
+        auto depthFrame = frameSet->getFrame(OB_FRAME_DEPTH);
+        if(!depthFrame) {
+            continue;
+        }
+
+        auto processedFrame = depthFrame;
+        // Apply the recommended filters to the depth frame
+        for(auto &filter: filterList) {
+            if(filter->isEnabled()) {  // Only apply enabled filters
+                processedFrame = filter->process(processedFrame);
+            }
+        }
+
+        // Push the frames to the window for showing
+        // Due to processedFrame type is same as the depthFrame, we should push it with different group id.
+        win.pushFramesToView(depthFrame, 0);
+        win.pushFramesToView(processedFrame, 1);
+    }
+
+    // Stop the pipeline
+    pipe.stop();
+
+    quit_program = true;
+
+    return 0;
+}
+catch(ob::Error &e) {
+    std::cerr << "function:" << e.getFunction() << "\nargs:" << e.getArgs() << "\nmessage:" << e.what() << "\ntype:" << e.getExceptionType() << std::endl;
+    std::cout << "\nPress any key to exit.";
+    ob_smpl::waitForKeyPressed();
+    exit(EXIT_FAILURE);
+}
+
diff --git a/examples/3.advanced.preset/CMakeLists.txt b/examples/3.advanced.preset/CMakeLists.txt
new file mode 100644
index 00000000..4084a3cc
--- /dev/null
+++ b/examples/3.advanced.preset/CMakeLists.txt
@@ -0,0 +1,14 @@
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+cmake_minimum_required(VERSION 3.5)
+project(ob_preset)
+
+add_executable(ob_preset preset.cpp)
+
+set_property(TARGET ob_preset PROPERTY CXX_STANDARD 11)
+target_link_libraries(ob_preset ob::OrbbecSDK ob::examples::utils)
+set_target_properties(ob_preset PROPERTIES FOLDER "examples")
+
+install(TARGETS ob_preset RUNTIME DESTINATION bin)
+
diff --git a/examples/3.advanced.preset/README.md b/examples/3.advanced.preset/README.md
new file mode 100644
index 00000000..b16fca83
--- /dev/null
+++ b/examples/3.advanced.preset/README.md
@@ -0,0 +1,39 @@
+# C++ Sample: 3.advanced.preset
+
+## Overview
+
+Use the SDK interface to set and get the preset value.
+
+### Knowledge
+
+Pipeline is a pipeline for processing data streams, providing multi-channel stream configuration, switching, frame aggregation, and frame synchronization functions
+
+## Code overview
+
+1. Get preset list from device.
+
+    ```cpp
+    std::shared_ptr<ob::DevicePresetList> presetLists = device->getAvailablePresetList();
+    ```
+
+2. Get preset value from device.
+
+    ```cpp
+        // Print current preset name.
+        std::cout << "Current PresetName: " << device->getCurrentPresetName() << std::endl;
+    ```
+
+3. Set preset value to device.
+
+    ```cpp
+        // Load preset.
+        device->loadPreset(presetName);
+    ```
+
+## Run Sample
+
+Press the button according to the interface prompts
+
+### Result
+
+![image](../../docs/resource/preset.jpg)
diff --git a/examples/3.advanced.preset/preset.cpp b/examples/3.advanced.preset/preset.cpp
new file mode 100644
index 00000000..89b1d27a
--- /dev/null
+++ b/examples/3.advanced.preset/preset.cpp
@@ -0,0 +1,64 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include <libobsensor/ObSensor.hpp>
+
+#include "utils.hpp"
+
+#include <iostream>
+
+int main() try {
+    // Create a pipeline with default device.
+    ob::Pipeline pipe;
+
+    // Get the device from the pipeline.
+    std::shared_ptr<ob::Device> device = pipe.getDevice();
+
+    while(true){
+
+        // Get preset list from device.
+        std::shared_ptr<ob::DevicePresetList> presetLists = device->getAvailablePresetList();
+        if (presetLists && presetLists->getCount() == 0) {
+            std::cout << "The current device does not support preset mode" << std::endl;
+            std::cout << "\nPress any key to exit.";
+            ob_smpl::waitForKeyPressed();
+            return 0;
+        }
+
+        std::cout << "Available Presets:" << std::endl;
+        for(uint32_t index = 0; index < presetLists->getCount(); index++) {
+            // Print available preset name.
+            std::cout << " - " << index << "." << presetLists->getName(index) << std::endl;
+        }
+
+        // Print current preset name.
+        std::cout << "Current PresetName: " << device->getCurrentPresetName() << std::endl;
+
+        std::cout << "Enter index of preset to load: ";
+
+        // Select preset to load.
+        int  inputOption = ob_smpl::getInputOption();
+        auto presetName = presetLists->getName(inputOption);
+
+        // Load preset.
+        device->loadPreset(presetName);
+
+        // Print current preset name.
+        std::cout << "Current PresetName: " << device->getCurrentPresetName() << std::endl;
+    }
+
+    // Stop Pipeline.
+    pipe.stop();
+
+    printf("\nProgram ended successfully. Press any key to exit.");
+    ob_smpl::getInputOption();
+
+    return 0;
+}
+catch(ob::Error &e) {
+    std::cerr << "function:" << e.getFunction() << "\nargs:" << e.getArgs() << "\nmessage:" << e.what() << "\ntype:" << e.getExceptionType() << std::endl;
+    std::cout << "\nPress any key to exit.";
+    ob_smpl::waitForKeyPressed();
+    exit(EXIT_FAILURE);
+}
+
diff --git a/examples/3.advanced.sync_align/CMakeLists.txt b/examples/3.advanced.sync_align/CMakeLists.txt
new file mode 100644
index 00000000..3f7974bb
--- /dev/null
+++ b/examples/3.advanced.sync_align/CMakeLists.txt
@@ -0,0 +1,15 @@
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+cmake_minimum_required(VERSION 3.5)
+project(ob_sync_align)
+
+add_executable(${PROJECT_NAME} sync_align.cpp)
+
+set_property(TARGET ${PROJECT_NAME} PROPERTY CXX_STANDARD 11)
+target_link_libraries(${PROJECT_NAME} ob::OrbbecSDK ob::examples::utils)
+
+set_target_properties(${PROJECT_NAME} PROPERTIES FOLDER "examples")
+
+install(TARGETS ob_sync_align RUNTIME DESTINATION bin)
+
diff --git a/examples/3.advanced.sync_align/README.md b/examples/3.advanced.sync_align/README.md
new file mode 100644
index 00000000..95212794
--- /dev/null
+++ b/examples/3.advanced.sync_align/README.md
@@ -0,0 +1,66 @@
+# C++ Sample: 3.advanced.sync_align
+
+## Overview
+
+Use the SDK interface to demonstrate the synchronization and alignment of sensor data streams,display the aligned image,and exit the program using the ESC_KEY key.
+
+### Knowledge
+
+Pipeline is a pipeline for processing data streams, providing multi-channel stream configuration, switching, frame aggregation, and frame synchronization functions
+
+Frameset is a combination of different types of Frames
+
+win is used to display the frame data.
+
+C2D（Color to Depth）is the transformation from the color image coordinate system to the depth image coordinate system.To map the pixel positions in the color image to the corresponding positions in the depth image. This is commonly used to align color and depth images so that both types of information can be used in the same coordinate system.
+
+D2C（Depth to Color）is the transformation from the depth image coordinate system to the color image coordinate system.To map the pixel positions in the depth image to the corresponding positions in the color image. This transformation allows depth data to be applied to the color image, facilitating the annotation or analysis of depth information within the color image.
+
+## Code overview
+
+1. Set alignment mode
+
+    ```cpp
+    // Create a filter to align depth frame to color frame
+    auto depth2colorAlign = std::make_shared<ob::Align>(OB_STREAM_COLOR);
+
+    // create a filter to align color frame to depth frame
+    auto color2depthAlign = std::make_shared<ob::Align>(OB_STREAM_DEPTH);
+    ```
+
+2. Set the callback function for the Align Filter to display the aligned frames in the window
+
+    ```cpp
+    depth2colorAlign->setCallBack([&win](std::shared_ptr<ob::Frame> frame) { win.pushFramesToView(frame); });
+    color2depthAlign->setCallBack([&win](std::shared_ptr<ob::Frame> frame) { win.pushFramesToView(frame); });
+   ```
+
+3. Perform alignment processing
+
+    ```cpp
+     // Get filter according to the align mode
+        std::shared_ptr<ob::Filter> alignFilter = depth2colorAlign;
+        if(align_mode % 2 == 1) {
+            alignFilter = color2depthAlign;
+        }
+
+        // push the frameset to the Align Filter to align the frames.
+        // The frameset will be processed in an internal thread, and the resulting frames will be asynchronously output via the callback function.
+        alignFilter->pushFrame(frameSet);
+    ```
+
+## Run Sample
+
+Press the Esc key in the window to exit the program.
+'T': Switch Align Mode.
+'F': Toggle Synchronization.
+'+/-': Adjust Transparency
+
+### Result
+
+Sync
+![image](../../docs/resource/sync.jpg)
+D2C
+![image](../../docs/resource/d2c.jpg)
+C2D
+![image](../../docs/resource/c2d.jpg)
diff --git a/examples/3.advanced.sync_align/sync_align.cpp b/examples/3.advanced.sync_align/sync_align.cpp
new file mode 100644
index 00000000..ac259eae
--- /dev/null
+++ b/examples/3.advanced.sync_align/sync_align.cpp
@@ -0,0 +1,101 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include <libobsensor/ObSensor.hpp>
+
+#include "utils.hpp"
+#include "utils_opencv.hpp"
+
+#include <mutex>
+#include <thread>
+
+bool    sync       = false;
+uint8_t align_mode = 0;
+
+// key press event processing
+void handleKeyPress(ob_smpl::CVWindow &win, std::shared_ptr<ob::Pipeline> pipe, int key) {
+    ////Get the key value
+    if(key == 'F' || key == 'f') {
+        // Press the F key to switch synchronization
+        sync = !sync;
+        if(sync) {
+            // enable frame sync inside the pipeline, which is synchronized by frame timestamp
+            pipe->enableFrameSync();
+        }
+        else {
+            // turn off sync
+            pipe->disableFrameSync();
+        }
+        win.addLog("Sync: " + std::string(sync ? "On" : "Off"));
+    }
+    else if(key == 't' || key == 'T') {
+        // Press the T key to switch align mode
+        align_mode = (align_mode + 1) % 2;
+        win.addLog("Align Mode: " + std::string(align_mode == 0 ? "Depth to Color" : "Color to Depth"));
+    }
+}
+
+int main(void) try {
+    // Configure which streams to enable or disable for the Pipeline by creating a Config
+    auto config = std::make_shared<ob::Config>();
+
+    // enable depth and color streams with specified format
+    config->enableVideoStream(OB_STREAM_DEPTH, OB_WIDTH_ANY, OB_HEIGHT_ANY, OB_FPS_ANY, OB_FORMAT_Y16);
+    config->enableVideoStream(OB_STREAM_COLOR, OB_WIDTH_ANY, OB_HEIGHT_ANY, OB_FPS_ANY, OB_FORMAT_RGB);
+
+    // set the frame aggregate output mode to ensure all types of frames are included in the output frameset
+    config->setFrameAggregateOutputMode(OB_FRAME_AGGREGATE_OUTPUT_ALL_TYPE_FRAME_REQUIRE);
+
+    // Create a pipeline with default device to manage stream
+    auto pipe = std::make_shared<ob::Pipeline>();
+
+    // Start the pipeline with config
+    pipe->start(config);
+
+    // Create a window for rendering and set the resolution of the window
+    ob_smpl::CVWindow win("Sync&Align", 1280, 720, ob_smpl::ARRANGE_OVERLAY);
+    // set key prompt
+    win.setKeyPrompt("'T': Switch Align Mode, 'F': Toggle Synchronization, '+/-': Adjust Transparency");
+    // set the callback function for the window to handle key press events
+    win.setKeyPressedCallback([&win, pipe](int key) { handleKeyPress(win, pipe, key); });
+
+    // Create a filter to align depth frame to color frame
+    auto depth2colorAlign = std::make_shared<ob::Align>(OB_STREAM_COLOR);
+
+    // create a filter to align color frame to depth frame
+    auto color2depthAlign = std::make_shared<ob::Align>(OB_STREAM_DEPTH);
+
+    // Set the callback function for the Align Filter to display the aligned frames in the window
+    depth2colorAlign->setCallBack([&win](std::shared_ptr<ob::Frame> frame) { win.pushFramesToView(frame); });
+    color2depthAlign->setCallBack([&win](std::shared_ptr<ob::Frame> frame) { win.pushFramesToView(frame); });
+
+    while(win.run()) {
+        // Wait for a frameset from the pipeline
+        auto frameSet = pipe->waitForFrameset(100);
+        if(frameSet == nullptr) {
+            continue;
+        }
+
+        // Get filter according to the align mode
+        std::shared_ptr<ob::Filter> alignFilter = depth2colorAlign;
+        if(align_mode % 2 == 1) {
+            alignFilter = color2depthAlign;
+        }
+
+        // push the frameset to the Align Filter to align the frames.
+        // The frameset will be processed in an internal thread, and the resulting frames will be asynchronously output via the callback function.
+        alignFilter->pushFrame(frameSet);
+    }
+
+    // Stop the Pipeline, no frame data will be generated
+    pipe->stop();
+
+    return 0;
+}
+catch(ob::Error &e) {
+    std::cerr << "function:" << e.getFunction() << "\nargs:" << e.getArgs() << "\nmessage:" << e.what() << "\ntype:" << e.getExceptionType() << std::endl;
+    std::cout << "\nPress any key to exit.";
+    ob_smpl::waitForKeyPressed();
+    exit(EXIT_FAILURE);
+}
+
diff --git a/examples/CMakeLists.txt b/examples/CMakeLists.txt
new file mode 100644
index 00000000..05a8a15d
--- /dev/null
+++ b/examples/CMakeLists.txt
@@ -0,0 +1,53 @@
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+cmake_minimum_required(VERSION 3.5)
+
+file(GLOB subdirectories RELATIVE ${CMAKE_CURRENT_LIST_DIR} "*")
+
+# dependecies
+# set(OpenCV_DIR /Users/lesley/Downloads/opencv-4.7.0/build)
+find_package(OpenCV QUIET)
+if(NOT ${OpenCV_FOUND})
+    message(WARNING "OpenCV not found, some examples may not be built. Please install OpenCV or set OpenCV_DIR to the directory of your OpenCV installation.")
+endif()
+
+# utils
+add_subdirectory(utils)
+
+# c examples
+add_subdirectory(c_examples)
+
+# cpp examples
+add_subdirectory(0.basic.enumerate)
+add_subdirectory(1.stream.imu)
+add_subdirectory(2.device.control)
+add_subdirectory(3.advanced.point_cloud)
+add_subdirectory(3.advanced.preset)
+
+# cpp examples with OpenCV Requirements
+if(${OpenCV_FOUND})
+    add_subdirectory(0.basic.quick_start)
+    add_subdirectory(1.stream.depth)
+    add_subdirectory(1.stream.color)
+    add_subdirectory(1.stream.infrared)
+    add_subdirectory(1.stream.callback)
+    add_subdirectory(1.stream.multi_streams)
+    add_subdirectory(2.device.hot_plugin)
+    add_subdirectory(3.advanced.common_usages)
+    add_subdirectory(3.advanced.sync_align)
+    add_subdirectory(3.advanced.hw_d2c_align)
+    add_subdirectory(3.advanced.post_processing)
+    add_subdirectory(3.advanced.coordinate_transform)
+    add_subdirectory(3.advanced.hdr)
+    add_subdirectory(3.advanced.multi_devices)
+
+    if(OB_BUILD_LINUX)
+        add_subdirectory(3.advanced.multi_devices_sync_gmsl)
+        add_subdirectory(3.advanced.multi_devices_sync_gmsltrigger)
+    endif()
+
+endif()
+
+# InstallRequiredSystemLibraries
+include(InstallRequiredSystemLibraries)
diff --git a/examples/README.md b/examples/README.md
new file mode 100644
index 00000000..b1e21301
--- /dev/null
+++ b/examples/README.md
@@ -0,0 +1,111 @@
+# Examples Code for Orbbec cameras
+
+## Introduction
+
+There are several examples codes for users learn how to use Orbbec cameras. Here is a brief introduction to each sample code:
+
+| Level    | Sample                                                  | Description                                                                                                                                                                                                             |
+| -------- | ------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| basic    | [quick_start](0.basic.quick_start)                      | Quick show how to use the SDK to get frames from the Orbbec RGB-D camera device.                                                                                                                                        |
+| basic    | [enumerate](0.basic.enumerate)                          | Use the SDK interface to obtain camera-related information, including model, various sensors, and sensor-related configurations.                                                                                        |
+| stream   | [depth](1.stream.depth)                                 | Use the SDK interface to obtain the depth stream of the camera and display it in the window.                                                                                                                            |
+| stream   | [color](1.stream.color)                                 | Use the SDK interface to obtain the camera's color stream and display it in the window.                                                                                                                                 |
+| stream   | [infrared](1.stream.infrared)                           | Use the SDK interface to obtain the camera IR stream and display it in the window.                                                                                                                                      |
+| stream   | [imu](1.stream.imu)                                     | Use the SDK interface to obtain the camera's internal imu data and output it                                                                                                                                            |
+| stream   | [multi_streams](1.stream.multi_streams)                 | Use SDK to obtain multiple camera data streams and output them.                                                                                                                                                         |
+| stream   | [callback](1.stream.callback)                           | In this sample, users can obtain depth, RGB, and IR images. This sample also supports performing user-defined operations such as data acquisition, data processing, and data modification within the callback function. |
+| device   | [control](2.device.control)                             | The SDK can be used to modify camera-related parameters, including laser switch, laser level intensity, white balance switch, etc.                                                                                      |
+| device   | [hot_plugin](2.device.hot_plugin)                       | Use SDK to handle the settings of device unplug callback and process the acquired code stream after unplugging.                                                                                                         |
+| advanced | [sync_align](3.advanced.sync_align)                     | Use the SDK interface to demonstrate the synchronization and alignment of sensor data streams, display the aligned image.                                                                                               |
+| advanced | [hw_d2c_align](3.advanced.hw_d2c_align)                 | Use the SDK interface to demonstrate the application of hardware depth-to-color alignment.                                                                                                                              |
+| advanced | [post_processing](3.advanced.post_processing)           | Use the SDK interface to  demonstrate post-processing operations, display post-processed images.                                                                                                                        |
+| advanced | [point_cloud](3.advanced.point_cloud)                   | Connect the device to open the stream, generate a depth point cloud or RGBD point cloud and save it as a ply format file.                                                                                               |
+| advanced | [preset](3.advanced.preset)                             | Use the SDK interface to set and get the preset value.                                                                                                                                                                  |
+| advanced | [coordinate_transform](3.advanced.coordinate_transform) | Use the SDK interface to  transform different coordinate systems.                                                                                                                                                       |
+| advanced | [hdr](3.advanced.hdr)                                   | In this sample, user can get the HDR merge image. Also supports user to toggle HDR merge and toggle alternate show origin frame.                                                                                        |
+| advanced | [multi_devices](3.advanced.multi_devices)               | In this sample, users can connect multiple camera devices and get color and depth images of different cameras.                                                                                                          |
+| advanced | [common_usages](3.advanced.common_usages)               | Use SDK to handle the settings of device unplug callback and process the acquired code stream after unplugging.                                                                                                         |
+
+### C language examples
+
+The listed examples at previous section are written in C++ language. Here is a brief introduction to c language examples:
+
+| Level  | Sample                                      | Description                                                                                     |
+| ------ | ------------------------------------------- | ----------------------------------------------------------------------------------------------- |
+| basic  | [c_quick_start](c_examples/0.c_quick_start) | This is a quick start guide to start device streams using the Orbbec SDK C API.                 |
+| stream | [c_enumerate](c_examples/1.c_enumerate)     | This is a enumerate guide to get device streams profile information using the Orbbec SDK C API. |
+| stream | [c_depth](c_examples/2.c_depth)             | This is a depth guide to get depth stream and depth image by using the Orbbec SDK C API.        |
+
+## Append
+
+### The utils functions and classes used in the examples code
+
+***utils***
+
+It contains functions to wait for a key press with an optional timeout, get the current time in milliseconds, and parse the input option from a key press event.This is done with C++.
+
+***utils_c***
+
+It contains functions to get the current system timestamp and wait for keystrokes from the user, as well as a macro to check for and handle errors. These capabilities can be used in scenarios such as time measurement, user interaction, and error handling.This is done with C.
+
+***utils_opencv***
+
+The CVWindow class includes the following main functionalities:
+
+The CVWindow class leverages OpenCV to create a flexible and customizable graphical interface for displaying and managing camera frames.
+
+ *Window Creation:*
+
+- The constructor accepts the window name, width, and height as parameters, along with an optional - arrangement mode (ArrangeMode).
+- The arrangement modes include single frame display, displaying multiple frames in a row, displaying multiple frames in a column, grid display, and overlay display.
+
+ *Image Frame Display and Processing:*
+
+- The pushFramesToView method is used to push a set or multiple sets of image frames to the window.
+- There is an internal thread processThread_ for processing image frames.
+- The arrangeFrames method arranges the image frames based on the selected arrangement mode.
+- The visualize and drawInfo methods are used to draw additional information on the images.
+
+ *User Interaction:*
+
+- The setKeyPressedCallback method sets a key press callback function.
+- The setKeyPrompt method sets a prompt message.
+- The addLog method adds a log message.
+
+ *Configuration and State Management:*
+
+- The setShowInfo method controls whether frame information should be displayed.
+- The setAlpha set alpha for OVERLAY render mode
+- The resize method adjusts the window size.
+- The close method closes the window.
+- The reset method clears the cached frames and image matrices.
+
+### The Error Handling in the examples code
+
+When using the Orbbec SDK, if an error occurs, the SDK reports the error by throwing an exception of type ob::Error. The ob::Error exception class typically contains detailed information about the error, which can help developers diagnose the problem.
+The example uses a 'try' block to wrap the entire main function.If an exception of type ob::Error is thrown, the program will catch it and print the error message to the console.
+Here is the information that can be obtained from an ob::Error:
+
+**Function Name (getFunction()):**
+Indicates the name of the function where the exception was thrown. This helps pinpoint the location of the error within the code.
+
+**Arguments (getArgs()):**
+Provides information about the arguments passed to the function when the exception occurred. This context can be useful for understanding the specific conditions under which the error happened.
+
+**Error Message (what()):**
+Returns a string describing the nature of the error. This is often the most important piece of information, as it directly explains what went wrong.
+
+**Exception Type (getExceptionType()):**
+Specifies the type of the exception. This can help categorize the error and determine appropriate handling strategies.Read the comments of the OBExceptionType enum in the libobsensor/h/ObTypes.h file for more information.
+
+**Example Code** in C++
+
+```cpp
+catch(ob::Error &e) {
+    std::cerr << "function: " << e.getFunction() << std::endl;
+    std::cerr << "args: " << e.getArgs() << std::endl;
+    std::cerr << "message: " << e.what() << std::endl;
+    std::cerr << "type: " << e.getExceptionType() << std::endl;
+    exit(EXIT_FAILURE);
+}
+```
diff --git a/examples/c_examples/0.c_quick_start/CMakeLists.txt b/examples/c_examples/0.c_quick_start/CMakeLists.txt
new file mode 100644
index 00000000..d64e9848
--- /dev/null
+++ b/examples/c_examples/0.c_quick_start/CMakeLists.txt
@@ -0,0 +1,16 @@
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+cmake_minimum_required(VERSION 3.5)
+
+set(CMAKE_CXX_STANDARD 11)
+project(ob_quick_start_c)
+add_executable(ob_quick_start_c quick_start.c)
+
+target_link_libraries(ob_quick_start_c PRIVATE ob::OrbbecSDK ob::examples::utils)
+
+set_target_properties(ob_quick_start_c PROPERTIES FOLDER "examples_c")
+set_target_properties(ob_quick_start_c PROPERTIES VS_DEBUGGER_WORKING_DIRECTORY "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}")
+
+install(TARGETS ob_quick_start_c RUNTIME DESTINATION bin)
+
diff --git a/examples/c_examples/0.c_quick_start/quick_start.c b/examples/c_examples/0.c_quick_start/quick_start.c
new file mode 100644
index 00000000..82230e05
--- /dev/null
+++ b/examples/c_examples/0.c_quick_start/quick_start.c
@@ -0,0 +1,139 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <libobsensor/ObSensor.h>
+#include <libobsensor/ObSensor.h>
+
+#include "utils_c.h"
+#include "utils_types.h"
+
+void calculate_and_print_frame_rate(const ob_frame *frameset) {
+    // Initialize variables
+    static float    color_count          = 0;
+    static float    depth_count          = 0;
+    static uint64_t color_timestamp_last = 0;
+    static uint64_t depth_timestamp_last = 0;
+    if(color_timestamp_last == 0) {
+        color_timestamp_last = ob_smpl_get_current_timestamp_ms();
+    }
+    if(depth_timestamp_last == 0) {
+        depth_timestamp_last = ob_smpl_get_current_timestamp_ms();
+    }
+
+    ob_error *error = NULL;
+
+    // Get color frame from frameset.
+    const ob_frame *color_frame = ob_frameset_get_frame(frameset, OB_FRAME_COLOR, &error);
+    CHECK_OB_ERROR_EXIT(&error);
+
+    // calculate and print color frame rate
+    if(color_frame != NULL) {
+        color_count++;
+        // Get timestamp from color frame.
+        uint64_t color_timestamp_current = ob_smpl_get_current_timestamp_ms();
+        uint64_t duration                = color_timestamp_current - color_timestamp_last;
+        if(duration > 1000) {  // calculate frame rate every second
+
+            uint64_t index = ob_frame_get_index(color_frame, &error);
+            CHECK_OB_ERROR_EXIT(&error);
+
+            uint32_t width = ob_video_frame_get_width(color_frame, &error);
+            CHECK_OB_ERROR_EXIT(&error);
+
+            uint32_t height = ob_video_frame_get_height(color_frame, &error);
+            CHECK_OB_ERROR_EXIT(&error);
+
+            double frame_rate = color_count / (duration / 1000.0);
+
+            printf("Color frame index: %d, width: %d, height: %d, frame rate: %.2f\n", (uint32_t)index, width, height, frame_rate);
+
+            color_count          = 0;
+            color_timestamp_last = color_timestamp_current;
+        }
+
+        // delete color frame
+        ob_delete_frame(color_frame, &error);
+        CHECK_OB_ERROR_EXIT(&error);
+    }
+
+    // Get depth frame from frameset.
+    const ob_frame *depth_frame = ob_frameset_get_frame(frameset, OB_FRAME_DEPTH, &error);
+    CHECK_OB_ERROR_EXIT(&error);
+
+    // calculate and print depth frame rate
+    if(depth_frame != NULL) {
+        depth_count++;
+        // Get timestamp from depth frame.
+        uint64_t depth_timestamp_current = ob_smpl_get_current_timestamp_ms();
+        uint64_t duration                = depth_timestamp_current - depth_timestamp_last;
+        if(duration > 1000) {  // 1 seconds
+            uint64_t index = ob_frame_get_index(depth_frame, &error);
+            CHECK_OB_ERROR_EXIT(&error);
+
+            uint32_t width = ob_video_frame_get_width(depth_frame, &error);
+            CHECK_OB_ERROR_EXIT(&error);
+
+            uint32_t height = ob_video_frame_get_height(depth_frame, &error);
+            CHECK_OB_ERROR_EXIT(&error);
+
+            double frame_rate = depth_count / (duration / 1000.0);
+
+            printf("Depth frame index: %d, width: %d, height: %d, frame rate: %.2f\n", (uint32_t)index, width, height, frame_rate);
+
+            depth_count          = 0;
+            depth_timestamp_last = depth_timestamp_current;
+        }
+
+        // delete depth frame
+        ob_delete_frame(depth_frame, &error);
+        CHECK_OB_ERROR_EXIT(&error);
+    }
+}
+
+int main(void) {
+    // Used to return SDK interface error information.
+    ob_error *error = NULL;
+
+    // Create a pipeline to manage the streams
+    ob_pipeline *pipe = ob_create_pipeline(&error);
+    CHECK_OB_ERROR_EXIT(&error);
+
+    // Start Pipeline with default configuration (At default, the pipeline will start with the color and depth streams)
+    ob_pipeline_start(pipe, &error);
+    CHECK_OB_ERROR_EXIT(&error);
+
+    printf("Streams have been started. Press 'ESC' key to stop the pipeline and exit the program.\n");
+
+    // Main loop, continuously wait for frames and print their index and rate.
+    while(true) {
+        char key = ob_smpl_wait_for_key_press(1);
+        if(key == ESC_KEY) {
+            break;
+        }
+
+        // Wait for frameset from pipeline, with a timeout of 1000 milliseconds.
+        ob_frame *frameset = ob_pipeline_wait_for_frameset(pipe, 1000, &error);
+        CHECK_OB_ERROR_EXIT(&error);
+
+        // If frameset is NULL, timeout occurred, continue to next iteration.
+        if(frameset == NULL) {
+            continue;
+        }
+
+        // Get the color and depth frames from the frameset and calculate their frame rate.
+        calculate_and_print_frame_rate(frameset);
+
+        // delete frameset
+        ob_delete_frame(frameset, &error);
+        CHECK_OB_ERROR_EXIT(&error);
+    }
+
+    // Stop Pipeline
+    ob_delete_pipeline(pipe, &error);
+    CHECK_OB_ERROR_EXIT(&error);
+
+    return 0;
+}
+
diff --git a/examples/c_examples/0.c_quick_start/readme.md b/examples/c_examples/0.c_quick_start/readme.md
new file mode 100644
index 00000000..d1f3e1ec
--- /dev/null
+++ b/examples/c_examples/0.c_quick_start/readme.md
@@ -0,0 +1,64 @@
+# Quick Start with C
+
+This is a quick start guide to start device streams using the Orbbec SDK C API.
+
+## Overview
+
+### Knowledge
+
+**Pipeline** is a pipeline for processing data streams, providing multi-channel stream configuration, switching, frame aggregation, and frame synchronization functions.
+
+**Frameset** is a combination of different types of Frames
+
+## Code Overview
+
+### 1. Create pipeline
+
+```c
+// Used to return SDK interface error information.
+ob_error *error = NULL;
+
+// Create a pipeline to manage the streams
+ob_pipeline *pipe = ob_create_pipeline(&error);
+```
+
+### 2. Start pipeline
+
+```c
+// Start Pipeline with default configuration (At default, the pipeline will start with the color and depth streams)
+ob_pipeline_start(pipe, &error);
+```
+
+### 3. Get frameset from pipeline
+
+```c
+// Wait for frameset from pipeline, with a timeout of 1000 milliseconds.
+ob_frame *frameset = ob_pipeline_wait_for_frameset(pipe, 1000, &error);
+CHECK_OB_ERROR_EXIT(&error);
+
+// If frameset is NULL, timeout occurred, continue to next iteration.
+if(frameset == NULL) {
+    continue;
+}
+
+// Get the color and depth frames from the frameset and calculate their frame rate.
+calculate_and_print_frame_rate(frameset);
+
+// delete frameset
+ob_delete_frame(frameset, &error);
+CHECK_OB_ERROR_EXIT(&error);
+```
+
+## Run Sample
+
+If you are on Windows, you can switch to the directory `OrbbecSDK-dev/build/win_XX/bin` to find the `ob_quick_start_c.exe`.
+
+If you are on linux, you can switch to the directory `OrbbecSDK-dev/build/linux_XX/bin` to find the `ob_quick_start_c`.
+
+### Key introduction
+
+Press 'ESC' key to stop the pipeline and exit the program.
+
+### Result
+
+![Quick_Start_C](../../../docs/resource/quick_start_c.jpg)
diff --git a/examples/c_examples/1.c_enumerate/CMakeLists.txt b/examples/c_examples/1.c_enumerate/CMakeLists.txt
new file mode 100644
index 00000000..21fd3e4c
--- /dev/null
+++ b/examples/c_examples/1.c_enumerate/CMakeLists.txt
@@ -0,0 +1,15 @@
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+cmake_minimum_required(VERSION 3.5)
+
+project(ob_enumerate_c)
+add_executable(ob_enumerate_c enumerate.c)
+
+target_link_libraries(ob_enumerate_c PRIVATE ob::OrbbecSDK ob::examples::utils)
+
+set_target_properties(ob_enumerate_c PROPERTIES FOLDER "examples_c")
+set_target_properties(ob_enumerate_c PROPERTIES VS_DEBUGGER_WORKING_DIRECTORY "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}")
+
+install(TARGETS ob_enumerate_c RUNTIME DESTINATION bin)
+
diff --git a/examples/c_examples/1.c_enumerate/README.md b/examples/c_examples/1.c_enumerate/README.md
new file mode 100644
index 00000000..c159fcdc
--- /dev/null
+++ b/examples/c_examples/1.c_enumerate/README.md
@@ -0,0 +1,83 @@
+# Enumerate with C
+
+This is a enumerate guide to get device streams profile information using the Orbbec SDK C API.
+
+## Overview
+
+### Knowledge
+
+Context is the environment context, the first object created during initialization, which can be used to perform some settings, including but not limited to device status change callbacks, log level settings, etc. Context can access multiple Devices.
+
+## Code Overview
+
+### 1.Get inuput value
+
+```c
+if(input == 'q' || input == 'Q') {
+    value = -1;
+    break;
+}
+if(input >= '0' && input <= '9' && input - '0' >= min_value && input - '0' <= max_value) {
+    value = input - '0';
+    break;
+}
+printf("Invalid input, please input a number between %d and %d or \'q\' to exit program: ", min_value, max_value);
+```
+
+### 2.Enumerates stream information
+
+Get stream profile list, then different output formats are formulated according to sensor type. For example, if sensor type = 'OB_SENSOR_COLOR', need to print stream type、stream format、stream resolution、stream fps、stream index.
+
+```c
+// Get sensor type.
+ob_sensor_type sensor_type = ob_sensor_get_type(sensor, &error);
+check_ob_error(&error);
+
+// Get stream profile list.
+ob_stream_profile_list *stream_profile_list = ob_sensor_get_stream_profile_list(sensor, &error);
+check_ob_error(&error);
+
+// Get stream profile count.
+uint32_t stream_profile_count = ob_stream_profile_list_get_count(stream_profile_list, &error);
+check_ob_error(&error);
+```
+
+### 3.Enumerate sensor list
+
+Get sensor list, then print sensor type.
+
+```c
+// Get sensor list.
+ob_sensor_list *sensor_list = ob_device_get_sensor_list(device, &error);
+check_ob_error(&error);
+
+// Get sensor count.
+uint32_t sensor_count = ob_sensor_list_get_count(sensor_list, &error);
+check_ob_error(&error);
+```
+
+### 4.Enumerates device information
+
+Get device information. And then print device name、pid、SN、connect type.
+
+```c
+// Get device information.
+ob_device_info *dev_inf = ob_device_get_device_info(device, &error);
+check_ob_error(&error);
+```
+
+## Run Sample
+
+If you are on Windows, you can switch to the directory `OrbbecSDK-dev/build/win_XX/bin` to find the `ob_enumerate_c.exe`.
+
+If you are on linux, you can switch to the directory `OrbbecSDK-dev/build/linux_XX/bin` to find the `ob_enumerate_c`.
+
+### Key introduction
+
+ Input the devices index to get the sensor list.
+ Input 'q' to exit the program.
+ Input the sensor index to get the stream profile list.
+
+### Result
+
+![Enumerate_C](../../../docs/resource/enumerate.jpg)
diff --git a/examples/c_examples/1.c_enumerate/enumerate.c b/examples/c_examples/1.c_enumerate/enumerate.c
new file mode 100644
index 00000000..cc17f340
--- /dev/null
+++ b/examples/c_examples/1.c_enumerate/enumerate.c
@@ -0,0 +1,287 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include <libobsensor/ObSensor.h>
+
+#include "utils_c.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+
+// helper function to check for errors and exit if there is one
+void check_ob_error(ob_error **err) {
+    if(*err) {
+        const char *error_message = ob_error_get_message(*err);
+        fprintf(stderr, "Error: %s\n", error_message);
+        ob_delete_error(*err);
+        exit(-1);
+    }
+    *err = NULL;
+}
+
+int select_index(const char *prompt, int min_value, int max_value) {  // todo: to support select index > 9
+    int value = 0;
+    printf("\n%s (Input a number between %d and %d or \'q\' to exit program): ", prompt, min_value, max_value);
+    while(true) {
+        char input;
+        int  ret = scanf("%c", &input);
+        (void)ret;
+        getchar();
+
+        if(input == 'q' || input == 'Q') {
+            value = -1;
+            break;
+        }
+        if(input >= '0' && input <= '9' && input - '0' >= min_value && input - '0' <= max_value) {
+            value = input - '0';
+            break;
+        }
+        printf("Invalid input, please input a number between %d and %d or \'q\' to exit program: ", min_value, max_value);
+    }
+    return value;
+}
+
+// Enumerates stream information.
+void enumerate_stream_info(ob_sensor *sensor) {
+    ob_error *error = NULL;
+
+    // Get sensor type.
+    ob_sensor_type sensor_type = ob_sensor_get_type(sensor, &error);
+    check_ob_error(&error);
+
+    // Get stream profile list.
+    ob_stream_profile_list *stream_profile_list = ob_sensor_get_stream_profile_list(sensor, &error);
+    check_ob_error(&error);
+
+    // Get stream profile count.
+    uint32_t stream_profile_count = ob_stream_profile_list_get_count(stream_profile_list, &error);
+    check_ob_error(&error);
+
+    printf("Available stream profiles: \n");
+    for(uint32_t index = 0; index < stream_profile_count; index++) {
+        // Get stream profile.
+        const ob_stream_profile *stream_profile = ob_stream_profile_list_get_profile(stream_profile_list, index, &error);
+        check_ob_error(&error);
+
+        // Print video stream profile information.
+        if(sensor_type == OB_SENSOR_IR || sensor_type == OB_SENSOR_COLOR || sensor_type == OB_SENSOR_DEPTH || sensor_type == OB_SENSOR_IR_LEFT
+           || sensor_type == OB_SENSOR_IR_RIGHT) {
+            ob_stream_type stream_type = ob_stream_profile_get_type(stream_profile, &error);
+            check_ob_error(&error);
+            const char *stream_type_str = ob_stream_type_to_string(stream_type);
+
+            ob_format stream_format = ob_stream_profile_get_format(stream_profile, &error);
+            check_ob_error(&error);
+            const char *stream_format_str = ob_format_to_string(stream_format);
+
+            uint32_t stream_width = ob_video_stream_profile_get_width(stream_profile, &error);
+            check_ob_error(&error);
+
+            uint32_t stream_height = ob_video_stream_profile_get_height(stream_profile, &error);
+            check_ob_error(&error);
+
+            uint32_t stream_fps = ob_video_stream_profile_get_fps(stream_profile, &error);
+            check_ob_error(&error);
+
+            printf("  %d - type: %4s, format: %4s, width: %4d, height: %4d, fps: %4d\n", index, stream_type_str, stream_format_str, stream_width, stream_height,
+                   stream_fps);
+        }
+        else if(sensor_type == OB_SENSOR_ACCEL) {
+            // Print acc stream profile information.
+            ob_format stream_format = ob_stream_profile_get_format(stream_profile, &error);
+            check_ob_error(&error);
+
+            ob_accel_sample_rate acc_fps = ob_accel_stream_profile_get_sample_rate(stream_profile, &error);
+            check_ob_error(&error);
+
+            printf("  %d - type: %s, fps: %s\n", index, ob_format_to_string(stream_format), ob_imu_rate_type_to_string(acc_fps));
+        }
+        else if(sensor_type == OB_SENSOR_GYRO) {
+            // Print gyro stream profile information.
+            ob_format stream_format = ob_stream_profile_get_format(stream_profile, &error);
+            check_ob_error(&error);
+
+            ob_gyro_sample_rate gyro_fps = ob_gyro_stream_profile_get_sample_rate(stream_profile, &error);
+            check_ob_error(&error);
+
+            printf("  %d - type: %s, fps: %s\n", index, ob_format_to_string(stream_format), ob_imu_rate_type_to_string(gyro_fps));
+        }
+
+        // destroy stream profile
+        ob_delete_stream_profile(stream_profile, &error);
+        check_ob_error(&error);
+    }
+
+    // destroy stream profile list
+    ob_delete_stream_profile_list(stream_profile_list, &error);
+    check_ob_error(&error);
+}
+
+// enumerate sensor list.
+void enumerate_sensor_info(ob_device *device) {
+    ob_error *error = NULL;
+
+    // Get sensor list.
+    ob_sensor_list *sensor_list = ob_device_get_sensor_list(device, &error);
+    check_ob_error(&error);
+
+    // Get sensor count.
+    uint32_t sensor_count = ob_sensor_list_get_count(sensor_list, &error);
+    check_ob_error(&error);
+
+    while(true){
+        // Print sensor information.
+        printf("Available sensors: \n");
+        for(uint32_t index = 0; index < sensor_count; index++) {
+            // Get device sensor.
+            ob_sensor *sensor = ob_sensor_list_get_sensor(sensor_list, index, &error);
+            check_ob_error(&error);
+
+            // Get sensor type.
+            ob_sensor_type sensor_type = ob_sensor_get_type(sensor, &error);
+            check_ob_error(&error);
+            const char *sensor_name = ob_sensor_type_to_string(sensor_type);
+
+            // Print sensor information.
+            printf("  %d - sensor name: %s\n", index, sensor_name);
+
+            // destroy sensor
+            ob_delete_sensor(sensor, &error);
+            check_ob_error(&error);
+        }
+
+        int index = select_index("Select a sensor to enumerate its stream profiles", 0, sensor_count - 1);
+        if(index >= 0) {
+            // Get the selected sensor.
+            ob_sensor *sensor = ob_sensor_list_get_sensor(sensor_list, index, &error);
+            check_ob_error(&error);
+
+            // Enumerate stream information of selected sensor.
+            enumerate_stream_info(sensor);
+
+            // destroy sensor
+            ob_delete_sensor(sensor, &error);
+            check_ob_error(&error);
+        }else{
+            break;
+        }
+
+    }
+    // destroy sensor list
+    ob_delete_sensor_list(sensor_list, &error);
+    check_ob_error(&error);
+}
+
+// Enumerates device information.
+void print_device_info(ob_device *device, int index) {
+    ob_error *error = NULL;
+
+    // Get device information.
+    ob_device_info *dev_inf = ob_device_get_device_info(device, &error);
+    check_ob_error(&error);
+
+    // Get device name.
+    const char *dev_name = ob_device_info_get_name(dev_inf, &error);
+    check_ob_error(&error);
+
+    // Get device pid.
+    int dev_pid = ob_device_info_get_pid(dev_inf, &error);
+    check_ob_error(&error);
+
+    // Get device serial number.
+    const char *dev_sn = ob_device_info_get_serial_number(dev_inf, &error);
+    check_ob_error(&error);
+
+    // Get connection type.
+    const char *conn_type = ob_device_info_get_connection_type(dev_inf, &error);
+    check_ob_error(&error);
+
+    printf("  %d - device name: %s, device pid: %d, device sn: %s, connection type: %s\n", index, dev_name, dev_pid, dev_sn, conn_type);
+}
+
+int main(void) {
+
+    // Used to return SDK interface error information.
+    ob_error *error = NULL;
+
+    // Get OrbbecSDK version.
+    int major_version = ob_get_major_version();
+    int minor_version = ob_get_minor_version();
+    int patch_version = ob_get_patch_version();
+    printf("Orbbec SDK version: %d.%d.%d\n", major_version, minor_version, patch_version);
+
+    // Create context.
+    ob_context *ctx = ob_create_context(&error);
+    check_ob_error(&error);
+
+    // Get device list from context.
+    ob_device_list *dev_list = ob_query_device_list(ctx, &error);
+    check_ob_error(&error);
+
+    // Get device count from device list.
+    uint32_t dev_count = ob_device_list_get_count(dev_list, &error);
+    check_ob_error(&error);
+
+    // Check if any device is connected.
+    if(dev_count == 0) {
+        printf("No device found! Please connect a supported device and retry this program.\n");
+
+        ob_delete_device_list(dev_list, &error);
+        check_ob_error(&error);
+
+        ob_delete_context(ctx, &error);
+        check_ob_error(&error);
+
+        printf("\nPress any key to exit.");
+        ob_smpl_wait_for_key_press(0);
+
+        return -1;
+    }
+
+    while(true) {
+        printf("Connected devices: \n");
+        for(uint32_t index = 0; index < dev_count; index++) {
+            // Get device from device list.
+            ob_device *dev = ob_device_list_get_device(dev_list, index, &error);
+            check_ob_error(&error);
+
+            // print device information
+            print_device_info(dev, index);
+
+            // destroy device
+            ob_delete_device(dev, &error);
+            check_ob_error(&error);
+        }
+
+        // Select a device.
+        int device_index = select_index("Select a device to enumerate its sensors", 0, dev_count - 1);
+        if(device_index >= 0) {
+            // get device from device list
+            ob_device *device = ob_device_list_get_device(dev_list, device_index, &error);
+            check_ob_error(&error);
+
+            // enumerate sensors of device
+            enumerate_sensor_info(device);
+
+            // destroy device
+            ob_delete_device(device, &error);
+            check_ob_error(&error);
+        }else{
+            break;
+        }
+    }
+
+    // destroy sensor list
+    ob_delete_device_list(dev_list, &error);
+    check_ob_error(&error);
+
+    // destroy context
+    ob_delete_context(ctx, &error);
+    check_ob_error(&error);
+
+    printf("\nProgram ended successfully. Press any key to exit.");
+    ob_smpl_wait_for_key_press(0);
+
+    return 0;
+}
+
diff --git a/examples/c_examples/2.c_depth/CMakeLists.txt b/examples/c_examples/2.c_depth/CMakeLists.txt
new file mode 100644
index 00000000..7e390ddc
--- /dev/null
+++ b/examples/c_examples/2.c_depth/CMakeLists.txt
@@ -0,0 +1,15 @@
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+cmake_minimum_required(VERSION 3.5)
+
+project(ob_depth_c)
+add_executable(ob_depth_c depth.c)
+
+target_link_libraries(ob_depth_c PRIVATE ob::OrbbecSDK ob::examples::utils)
+
+set_target_properties(ob_depth_c PROPERTIES FOLDER "examples_c")
+set_target_properties(ob_depth_c PROPERTIES VS_DEBUGGER_WORKING_DIRECTORY "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}")
+
+install(TARGETS ob_depth_c RUNTIME DESTINATION bin)
+
diff --git a/examples/c_examples/2.c_depth/README.md b/examples/c_examples/2.c_depth/README.md
new file mode 100644
index 00000000..ef8beeae
--- /dev/null
+++ b/examples/c_examples/2.c_depth/README.md
@@ -0,0 +1,115 @@
+# Depth with C
+
+This is a depth guide to get depth stream and depth image by using the Orbbec SDK C API.
+
+## Overview
+
+### Knowledge
+
+**Pipeline** is a pipeline for processing data streams, providing multi-channel stream configuration, switching, frame aggregation, and frame synchronization functions.
+
+**Frameset** is a combination of different types of Frames.
+
+**Depth_frame** is one of the frames in frameset, it contains the frames's  esolution information and depth data.
+
+## Code Overview
+
+### 1. Create instances
+
+Create the pipeline instance using the default configuration and create a config instance to enable or disable the streams.
+
+```c
+// Used to return SDK interface error information.
+ob_error *error = NULL;
+
+// Create a pipeline object to manage the streams.
+ob_pipeline *pipeline = ob_create_pipeline(&error);
+check_ob_error(&error);
+
+// Crete a config object to configure the pipeline streams.
+ob_config *config = ob_create_config(&error);
+check_ob_error(&error);
+```
+
+### 2. Start pipeline
+
+enable the depth stream, and then start the pipeline.
+
+```c
+// enable depth stream with default stream profile.
+ob_config_enable_stream(config, OB_STREAM_DEPTH, &error);
+check_ob_error(&error);
+
+// Start Pipeline with the configured streams.
+ob_pipeline_start_with_config(pipeline, config, &error);
+check_ob_error(&error);
+```
+
+### 3. Get  depth stream
+
+Get the frameset from pipeline, and get the depth frame from frameset.
+
+```c
+// Wait for a frameset, timeout after 1000 milliseconds.
+const ob_frame *frameset = ob_pipeline_wait_for_frameset(pipeline, 1000, &error);
+check_ob_error(&error);
+
+// If no frameset is available with in the timeout, continue waiting.
+if(frameset == NULL) {
+    continue;
+}
+
+// Get the depth frame from frameset。
+const ob_frame *depth_frame = ob_frameset_get_depth_frame(frameset, &error);
+check_ob_error(&error);
+```
+
+### 4. Print the distance of the center pixel
+
+Print the distance of the center pixel every 30 frames to reduce output.
+
+```c
+if(index % 30 == 0) {
+    // Get the width of the depth frame.
+    uint32_t width = ob_video_frame_get_width(depth_frame, &error);
+    check_ob_error(&error);
+
+    // Get the height of the depth frame.
+    uint32_t height = ob_video_frame_get_height(depth_frame, &error);
+    check_ob_error(&error);
+
+    // Get the scale of the depth frame.
+    float scale = ob_depth_frame_get_value_scale(depth_frame, &error);
+    check_ob_error(&error);
+
+    // Get the data of the depth frame, cast to uint16_t* to access the pixels directly for Y16 format.
+    uint16_t *data = (uint16_t *)ob_frame_get_data(depth_frame, &error);
+    check_ob_error(&error);
+
+    // pixel value multiplied by scale is the actual distance value in millimeters
+    float center_distance = data[width * height / 2 + width / 2] * scale;
+
+    // attention: if the distance is 0, it means that the depth camera cannot detect the object（may be out of detection range）
+    printf("Facing an object at a distance of %.3f mm away.\n", center_distance);
+}
+```
+
+### 5. Stop pipeline
+
+```c
+ob_pipeline_stop(pipeline, &error);
+```
+
+## Run Sample
+
+If you are on Windows, you can switch to the directory `OrbbecSDK-dev/build/win_XX/bin` to find the `ob_depth_c.exe`.
+
+If you are on linux, you can switch to the directory `OrbbecSDK-dev/build/linux_XX/bin` to find the `ob_depth_c`.
+
+### Key introduction
+
+Press 'ESC' key to stop the pipeline and exit the program.
+
+### Result
+
+![Quick_Start_C](../../../docs/resource/quick_start_c.jpg)
diff --git a/examples/c_examples/2.c_depth/depth.c b/examples/c_examples/2.c_depth/depth.c
new file mode 100644
index 00000000..7193039d
--- /dev/null
+++ b/examples/c_examples/2.c_depth/depth.c
@@ -0,0 +1,111 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include <libobsensor/ObSensor.h>
+
+#include "utils_c.h"
+#include "utils_types.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+
+// helper function to check for errors and exit if there is one
+void check_ob_error(ob_error **err) {
+    if(*err) {
+        const char *error_message = ob_error_get_message(*err);
+        fprintf(stderr, "Error: %s\n", error_message);
+        ob_delete_error(*err);
+        exit(-1);
+    }
+    *err = NULL;
+}
+
+int main(void) {
+    // Used to return SDK interface error information.
+    ob_error *error = NULL;
+
+    // Create a pipeline object to manage the streams.
+    ob_pipeline *pipeline = ob_create_pipeline(&error);
+    check_ob_error(&error);
+
+    // Crete a config object to configure the pipeline streams.
+    ob_config *config = ob_create_config(&error);
+    check_ob_error(&error);
+
+    // enable depth stream with default stream profile.
+    ob_config_enable_stream(config, OB_STREAM_DEPTH, &error);
+    check_ob_error(&error);
+
+    // Start Pipeline with the configured streams.
+    ob_pipeline_start_with_config(pipeline, config, &error);
+    check_ob_error(&error);
+
+    printf("Depth Stream Started. Press 'ESC' key to exit the program.\n");
+
+    // Wait frameset in a loop, exit when ESC is pressed.
+    while(true) {
+        // Wait for a key press
+        char key = ob_smpl_wait_for_key_press(10);
+        if(key == ESC_KEY) {  // ESC key
+            printf("Exiting...\n");
+            break;
+        }
+
+        // Wait for a frameset, timeout after 1000 milliseconds.
+        const ob_frame *frameset = ob_pipeline_wait_for_frameset(pipeline, 1000, &error);
+        check_ob_error(&error);
+
+        // If no frameset is available with in the timeout, continue waiting.
+        if(frameset == NULL) {
+            continue;
+        }
+
+        // Get the depth frame from frameset。
+        const ob_frame *depth_frame = ob_frameset_get_depth_frame(frameset, &error);
+        check_ob_error(&error);
+
+        // Get index from depth frame.
+        uint64_t index = ob_frame_get_index(depth_frame, &error);
+        check_ob_error(&error);
+
+        // print the distance of the center pixel every 30 frames to reduce output
+        if(index % 30 == 0) {
+            // Get the width and height of the depth frame.
+            uint32_t width = ob_video_frame_get_width(depth_frame, &error);
+            check_ob_error(&error);
+
+            // Get the height of the depth frame.
+            uint32_t height = ob_video_frame_get_height(depth_frame, &error);
+            check_ob_error(&error);
+
+            // Get the scale of the depth frame.
+            float scale = ob_depth_frame_get_value_scale(depth_frame, &error);
+            check_ob_error(&error);
+
+            // Get the data of the depth frame, cast to uint16_t* to access the pixels directly for Y16 format.
+            uint16_t *data = (uint16_t *)ob_frame_get_data(depth_frame, &error);
+            check_ob_error(&error);
+
+            // pixel value multiplied by scale is the actual distance value in millimeters
+            float center_distance = data[width * height / 2 + width / 2] * scale;
+
+            // attention: if the distance is 0, it means that the depth camera cannot detect the object（may be out of detection range）
+            printf("Facing an object at a distance of %.3f mm away.\n", center_distance);
+        }
+
+        // delete the depth frame
+        ob_delete_frame(depth_frame, &error);
+        check_ob_error(&error);
+
+        // delete the frameset
+        ob_delete_frame(frameset, &error);
+        check_ob_error(&error);
+    };
+
+    // stop the pipeline
+    ob_pipeline_stop(pipeline, &error);
+    check_ob_error(&error);
+
+    return 0;
+}
+
diff --git a/examples/c_examples/CMakeLists.txt b/examples/c_examples/CMakeLists.txt
new file mode 100644
index 00000000..5d9d5a74
--- /dev/null
+++ b/examples/c_examples/CMakeLists.txt
@@ -0,0 +1,13 @@
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+cmake_minimum_required(VERSION 3.5)
+
+file(GLOB subdirectories RELATIVE ${CMAKE_CURRENT_LIST_DIR} "*")
+
+foreach(subdir ${subdirectories})
+    if(IS_DIRECTORY ${CMAKE_CURRENT_LIST_DIR}/${subdir})
+        add_subdirectory(${subdir})
+    endif()
+endforeach()
+
diff --git a/examples/publish_files/CMakeLists.txt b/examples/publish_files/CMakeLists.txt
new file mode 100644
index 00000000..719c9968
--- /dev/null
+++ b/examples/publish_files/CMakeLists.txt
@@ -0,0 +1,33 @@
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+cmake_minimum_required(VERSION 3.5)
+
+project(orbbec_sdk_exampes)
+
+set(CMAKE_CXX_STANDARD 11)
+
+set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
+set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
+if(MSVC)
+    set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_DEBUG "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}")
+    set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_RELEASE "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}")
+    set(CMAKE_LIBRARY_OUTPUT_DIRECTORY_DEBUG "${CMAKE_LIBRARY_OUTPUT_DIRECTORY}")
+    set(CMAKE_LIBRARY_OUTPUT_DIRECTORY_RELEASE "${CMAKE_LIBRARY_OUTPUT_DIRECTORY}")
+    set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY_DEBUG "${CMAKE_ARCHIVE_OUTPUT_DIRECTORY}")
+    set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY_RELEASE "${CMAKE_ARCHIVE_OUTPUT_DIRECTORY}")
+endif()
+
+
+set(OrbbecSDK_DIR ${CMAKE_CURRENT_LIST_DIR}/../lib)
+find_package(OrbbecSDK REQUIRED)
+
+if(UNIX)
+    set(CMAKE_INSTALL_RPATH ${OrbbecSDK_DIR})
+    set(CMAKE_BUILD_WITH_INSTALL_RPATH TRUE)
+    set(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE)
+endif()
+
+add_subdirectory(src)
+
diff --git a/examples/publish_files/build_examples.sh b/examples/publish_files/build_examples.sh
new file mode 100755
index 00000000..8e010191
--- /dev/null
+++ b/examples/publish_files/build_examples.sh
@@ -0,0 +1,103 @@
+#!/bin/bash
+
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+echo "Checking if apt-get is workable ..."
+apt_workable=1
+#  Check if apt-get is installed
+if ! command -v apt-get &> /dev/null
+then
+    echo "apt-get could not be found."
+    apt_workable=0
+fi
+
+# check if apt-get is working
+if ! command -v sudo apt-get update &> /dev/null
+then
+    echo "apt-get update failed. apt-get may not be working properly."
+    apt_workable=0
+fi
+
+if [ $apt_workable -eq 1 ]
+then
+    #install compiler and tools
+    if ! g++ --version &> /dev/null || ! make --version &> /dev/null
+    then
+        echo "C++ Compiler and tools could not be found. It is required to build the examples."
+        echo "Do you want to install it via install build-essential? (y/n)"
+        read answer
+        if [ "$answer" == "y" ]
+        then
+            sudo apt-get install -y build-essential
+        fi
+    else
+        echo "C++ Compiler and tools is installed."
+    fi
+
+    # install cmake
+    if ! cmake --version &> /dev/null
+    then
+        echo "Cmake could not be found. It is required to build the examples."
+        echo "Do you want to install cmake? (y/n)"
+        read answer
+        if [ "$answer" == "y" ]
+        then
+            sudo apt-get install -y cmake
+        fi
+    else
+        echo "cmake is installed."
+    fi
+
+    # install libopencv-dev
+    if ! dpkg -l | grep libopencv-dev &> /dev/null ||  ! dpkg -l | grep libopencv &> /dev/null
+    then
+        echo "libopencv-dev or libopencv could not be found. Without opencv, part of the examples may not be built successfully."
+        echo "Do you want to install libopencv-dev and libopencv? (y/n)"
+        read answer
+        if [ "$answer" == "y" ]
+        then
+            sudo apt-get install -y libopencv
+            sudo apt-get install -y libopencv-dev
+        fi
+    else
+        echo "libopencv-dev is installed."
+    fi
+else
+    echo "apt-get is not workable, network connection may be down or the system may not have internet access. Build examples may not be successful."
+fi
+
+# restore current directory
+current_dir=$(pwd)
+
+# cd to the directory where this script is located
+cd "$(dirname "$0")"
+project_dir=$(pwd)
+examples_dir=$project_dir/examples
+
+#detect cpu core count
+cpu_count=$(grep -c ^processor /proc/cpuinfo)
+half_cpu_count=$((cpu_count/2))
+if [ $half_cpu_count -eq 0 ]
+then
+    half_cpu_count=1
+fi
+
+#cmake
+echo "Building examples..."
+mkdir build
+cd build
+cmake -DCMAKE_BUILD_TYPE=Release -DOB_BUILD_LINUX=ON -DCMAKE_INSTALL_PREFIX=$project_dir $examples_dir
+ehco "Building examples with $half_cpu_count threads..."
+cmake --build . -j$half_cpu_count # build with thread count equal to half of cpu count
+# install the executable files to the project directory
+cmake --install .
+
+# clean up
+cd $project_dir
+rm -rf build
+
+echo "OrbbecSDK examples built successfully!"
+echo "The executable files located in: $project_dir/bin"
+
+cd $current_dir
diff --git a/examples/utils/CMakeLists.txt b/examples/utils/CMakeLists.txt
new file mode 100644
index 00000000..67791ce7
--- /dev/null
+++ b/examples/utils/CMakeLists.txt
@@ -0,0 +1,29 @@
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+cmake_minimum_required(VERSION 3.5)
+project(ob_examples_utils)
+
+add_library(ob_examples_utils STATIC
+    ${CMAKE_CURRENT_LIST_DIR}/utils_c.c
+    ${CMAKE_CURRENT_LIST_DIR}/utils_c.h
+    ${CMAKE_CURRENT_LIST_DIR}/utils.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/utils.hpp
+)
+
+if(${OpenCV_FOUND})
+    target_sources(ob_examples_utils PRIVATE
+        ${CMAKE_CURRENT_LIST_DIR}/utils_opencv.cpp
+        ${CMAKE_CURRENT_LIST_DIR}/utils_opencv.hpp
+    )
+    target_link_libraries(ob_examples_utils PUBLIC ${OpenCV_LIBS} ob::OrbbecSDK)
+    target_include_directories(ob_examples_utils PUBLIC ${OpenCV_INCLUDE_DIRS})
+endif()
+
+find_package(Threads REQUIRED)
+target_link_libraries(ob_examples_utils PUBLIC Threads::Threads)
+
+target_include_directories(ob_examples_utils PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
+
+add_library(ob::examples::utils ALIAS ob_examples_utils)
+set_target_properties(ob_examples_utils PROPERTIES FOLDER "examples")
diff --git a/examples/utils/utils.cpp b/examples/utils/utils.cpp
new file mode 100644
index 00000000..b1a4a050
--- /dev/null
+++ b/examples/utils/utils.cpp
@@ -0,0 +1,26 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "utils.hpp"
+#include "utils_c.h"
+
+#include <chrono>
+
+namespace ob_smpl {
+char waitForKeyPressed(uint32_t timeout_ms) {
+    return ob_smpl_wait_for_key_press(timeout_ms);
+}
+
+uint64_t getNowTimesMs() {
+    return std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count();
+}
+
+int getInputOption() {
+    char inputOption = ob_smpl::waitForKeyPressed();
+    if(inputOption == ESC_KEY) {
+        return -1;
+    }
+    return inputOption - '0';
+}
+
+}  // namespace ob_smpl
diff --git a/examples/utils/utils.hpp b/examples/utils/utils.hpp
new file mode 100644
index 00000000..b8059a20
--- /dev/null
+++ b/examples/utils/utils.hpp
@@ -0,0 +1,23 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include <stdint.h>
+#include "utils_types.h"
+
+#include <sstream>
+
+namespace ob_smpl {
+char waitForKeyPressed(uint32_t timeout_ms = 0);
+
+uint64_t getNowTimesMs();
+
+int getInputOption();
+
+template <typename T> std::string toString(const T a_value, const int n = 6) {
+    std::ostringstream out;
+    out.precision(n);
+    out << std::fixed << a_value;
+    return std::move(out).str();
+}
+}  // namespace ob_smpl
diff --git a/examples/utils/utils_c.c b/examples/utils/utils_c.c
new file mode 100644
index 00000000..fcfec6f7
--- /dev/null
+++ b/examples/utils/utils_c.c
@@ -0,0 +1,138 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "utils_c.h"
+#include <stdbool.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if defined(__linux__) || defined(__APPLE__)
+#ifdef __linux__
+#include <termio.h>
+#else
+#include <termios.h>
+#endif
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+#include <fcntl.h>
+
+#define gets_s gets
+
+int getch(void) {
+    struct termios tm, tm_old;
+    int            fd = 0, ch;
+
+    if(tcgetattr(fd, &tm) < 0) {  // Save the current terminal settings
+        return -1;
+    }
+
+    tm_old = tm;
+    cfmakeraw(&tm);                        // Change the terminal settings to raw mode, in which all input data is processed in bytes
+    if(tcsetattr(fd, TCSANOW, &tm) < 0) {  // Settings after changes on settings
+        return -1;
+    }
+
+    ch = getchar();
+    if(tcsetattr(fd, TCSANOW, &tm_old) < 0) {  // Change the settings to what they were originally
+        return -1;
+    }
+
+    return ch;
+}
+
+int kbhit(void) {
+    struct termios oldt, newt;
+    int            ch;
+    int            oldf;
+    tcgetattr(STDIN_FILENO, &oldt);
+    newt = oldt;
+    newt.c_lflag &= ~(ICANON | ECHO);
+    tcsetattr(STDIN_FILENO, TCSANOW, &newt);
+    oldf = fcntl(STDIN_FILENO, F_GETFL, 0);
+    fcntl(STDIN_FILENO, F_SETFL, oldf | O_NONBLOCK);
+    ch = getchar();
+    tcsetattr(STDIN_FILENO, TCSANOW, &oldt);
+    fcntl(STDIN_FILENO, F_SETFL, oldf);
+    if(ch != EOF) {
+        ungetc(ch, stdin);
+        return 1;
+    }
+    return 0;
+}
+
+#include <sys/time.h>
+uint64_t ob_smpl_get_current_timestamp_ms() {
+    struct timeval te;
+    gettimeofday(&te, NULL);                                          // Get the current time
+    long long milliseconds = te.tv_sec * 1000LL + te.tv_usec / 1000;  // Calculate milliseconds
+    return milliseconds;
+}
+
+char ob_smpl_wait_for_key_press(uint32_t timeout_ms) {  // Get the current time
+    struct timeval te;
+    gettimeofday(&te, NULL);
+    long long start_time = te.tv_sec * 1000LL + te.tv_usec / 1000;
+
+    while(true) {
+        if(kbhit()) {
+            return getch();
+        }
+        gettimeofday(&te, NULL);
+        long long current_time = te.tv_sec * 1000LL + te.tv_usec / 1000;
+        if(timeout_ms > 0 && current_time - start_time > timeout_ms) {
+            return 0;
+        }
+        usleep(100);
+    }
+}
+
+#else  // Windows
+#include <conio.h>
+#include <windows.h>
+
+uint64_t ob_smpl_get_current_timestamp_ms() {
+    FILETIME      ft;
+    LARGE_INTEGER li;
+    GetSystemTimeAsFileTime(&ft);
+    li.LowPart             = ft.dwLowDateTime;
+    li.HighPart            = ft.dwHighDateTime;
+    long long milliseconds = li.QuadPart / 10000LL;
+    return milliseconds;
+}
+
+char ob_smpl_wait_for_key_press(uint32_t timeout_ms) {
+    HANDLE hStdin = GetStdHandle(STD_INPUT_HANDLE);
+    if(hStdin == INVALID_HANDLE_VALUE) {
+        return 0;
+    }
+    DWORD mode = 0;
+    if(!GetConsoleMode(hStdin, &mode)) {
+        return 0;
+    }
+    mode &= ~ENABLE_ECHO_INPUT;
+    if(!SetConsoleMode(hStdin, mode)) {
+        return 0;
+    }
+    DWORD start_time = GetTickCount();
+    while(true) {
+        if(_kbhit()) {
+            char ch = (char)_getch();
+            SetConsoleMode(hStdin, mode);
+            return ch;
+        }
+        if(timeout_ms > 0 && GetTickCount() - start_time > timeout_ms) {
+            SetConsoleMode(hStdin, mode);
+            return 0;
+        }
+        Sleep(1);
+    }
+}
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
diff --git a/examples/utils/utils_c.h b/examples/utils/utils_c.h
new file mode 100644
index 00000000..5c6aac24
--- /dev/null
+++ b/examples/utils/utils_c.h
@@ -0,0 +1,40 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @brief Get the current system timestamp in milliseconds.
+ *
+ */
+uint64_t ob_smpl_get_current_timestamp_ms();
+
+/**
+ * @brief Wait for key press.
+ *
+ * @param[in] timeout_ms The maximum time to wait for a key press in milliseconds. Set to 0 to wait indefinitely.
+ *
+ * @return char The key that was pressed.
+ */
+char ob_smpl_wait_for_key_press(uint32_t timeout_ms);
+
+// Macro to check for error and exit program if there is one.
+#define CHECK_OB_ERROR_EXIT(error)                                \
+    if(*error) {                                                  \
+        const char *error_message = ob_error_get_message(*error); \
+        fprintf(stderr, "Error: %s\n", error_message);            \
+        ob_delete_error(*error);                                  \
+        *error = NULL;                                            \
+        exit(-1);                                                 \
+    }                                                             \
+    *error = NULL;
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/examples/utils/utils_opencv.cpp b/examples/utils/utils_opencv.cpp
new file mode 100644
index 00000000..76791c0f
--- /dev/null
+++ b/examples/utils/utils_opencv.cpp
@@ -0,0 +1,570 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "utils_opencv.hpp"
+#include "utils.hpp"
+#include "utils_types.h"
+
+#if defined(__has_include)
+#if __has_include(<opencv2/core/utils/logger.hpp>)
+#include <opencv2/core/utils/logger.hpp>
+#define TO_DISABLE_OPENCV_LOG
+#endif
+#endif
+
+namespace ob_smpl {
+
+const std::string defaultKeyMapPrompt = "'Esc': Exit Window, '?': Show Key Map";
+CVWindow::CVWindow(std::string name, uint32_t width, uint32_t height, ArrangeMode arrangeMode)
+    : name_(std::move(name)),
+      arrangeMode_(arrangeMode),
+      width_(width),
+      height_(height),
+      closed_(false),
+      showInfo_(true),
+      showSyncTimeInfo_(false),
+      isWindowDestroyed_(false),
+      alpha_(0.6f),
+      showPrompt_(false) {
+
+#if defined(TO_DISABLE_OPENCV_LOG)
+    cv::utils::logging::setLogLevel(cv::utils::logging::LogLevel::LOG_LEVEL_SILENT);
+#endif
+
+    prompt_ = defaultKeyMapPrompt;
+
+    cv::namedWindow(name_, cv::WINDOW_NORMAL);
+    cv::resizeWindow(name_, width_, height_);
+
+    renderMat_ = cv::Mat::zeros(height_, width_, CV_8UC3);
+    cv::putText(renderMat_, "Waiting for streams...", cv::Point(8, 16), cv::FONT_HERSHEY_DUPLEX, 0.5, cv::Scalar(255, 255, 255), 1, cv::LINE_AA);
+    cv::imshow(name_, renderMat_);
+
+    // start processing thread
+    processThread_ = std::thread(&CVWindow::processFrames, this);
+
+    winCreatedTime_ = getNowTimesMs();
+}
+
+CVWindow::~CVWindow() noexcept {
+    close();
+    destroyWindow();
+}
+
+void CVWindow::setKeyPressedCallback(std::function<void(int)> callback) {
+    keyPressedCallback_ = callback;
+}
+
+// if window is closed
+bool CVWindow::run() {
+
+    {
+        // show render mat
+        std::lock_guard<std::mutex> lock(renderMatsMtx_);
+        cv::imshow(name_, renderMat_);
+    }
+
+    int key = cv::waitKey(1);
+    if(key != -1) {
+        if(key == ESC_KEY) {
+            closed_ = true;
+            srcFrameGroupsCv_.notify_all();
+        }
+        else if(key == '1') {
+            arrangeMode_ = ARRANGE_SINGLE;
+            addLog("Switch to SINGLE arrange mode");
+        }
+        else if(key == '2') {
+            arrangeMode_ = ARRANGE_ONE_ROW;
+            addLog("Switch to ONE_ROW arrange mode");
+        }
+        else if(key == '3') {
+            arrangeMode_ = ARRANGE_ONE_COLUMN;
+            addLog("Switch to ONE_COLUMN arrange mode");
+        }
+        else if(key == '4') {
+            arrangeMode_ = ARRANGE_GRID;
+            addLog("Switch to GRID arrange mode");
+        }
+        else if(key == '5') {
+            arrangeMode_ = ARRANGE_OVERLAY;
+            addLog("Switch to OVERLAY arrange mode");
+        }
+        else if(key == '?' || key == '/') {
+            showPrompt_ = !showPrompt_;
+        }
+        else if(key == '+' || key == '=') {
+            alpha_ += 0.1f;
+            if(alpha_ > 1) {
+                alpha_ = 1;
+            }
+            addLog("Adjust alpha to " + ob_smpl::toString(alpha_, 1) + " (Only valid in OVERLAY arrange mode)");
+        }
+        else if(key == '-' || key == '_') {
+            alpha_ -= 0.1f;
+            if(alpha_ < 0) {
+                alpha_ = 0;
+            }
+            addLog("Adjust alpha to " + ob_smpl::toString(alpha_, 1) + " (Only valid in OVERLAY arrange mode)");
+        }
+        if(keyPressedCallback_) {
+            keyPressedCallback_(key);
+        }
+    }
+    return !closed_;
+}
+
+// close window
+void CVWindow::close() {
+    {
+        std::lock_guard<std::mutex> lock(renderMatsMtx_);
+        closed_ = true;
+        srcFrameGroupsCv_.notify_all();
+    }
+
+    if(processThread_.joinable()) {
+        processThread_.join();
+    }
+
+    matGroups_.clear();
+    srcFrameGroups_.clear();
+}
+
+void CVWindow::destroyWindow() {
+    if(!isWindowDestroyed_){
+        cv::destroyWindow(name_);
+        cv::waitKey(1);
+        isWindowDestroyed_ = true;
+    }else{
+        std::cout << "CVWindows has been destroyed!" << std::endl;
+    }
+}
+
+void CVWindow::reset() {
+    // close thread and clear cache
+    close();
+
+    // restart thread
+    closed_        = false;
+    processThread_ = std::thread(&CVWindow::processFrames, this);
+}
+
+// set the window size
+void CVWindow::resize(int width, int height) {
+    width_  = width;
+    height_ = height;
+    cv::resizeWindow(name_, width_, height_);
+}
+
+void CVWindow::setKeyPrompt(const std::string &prompt) {
+    prompt_ = defaultKeyMapPrompt + ", " + prompt;
+}
+
+void CVWindow::addLog(const std::string &log) {
+    log_            = log;
+    logCreatedTime_ = getNowTimesMs();
+}
+
+// add frames to the show
+void CVWindow::pushFramesToView(std::vector<std::shared_ptr<const ob::Frame>> frames, int groupId) {
+    if(frames.empty()) {
+        return;
+    }
+
+    std::vector<std::shared_ptr<const ob::Frame>> singleFrames;
+    for(auto &frame: frames) {
+        if(frame == nullptr) {
+            continue;
+        }
+
+        if(!frame->is<ob::FrameSet>()) {
+            // single frame, add to the list
+            singleFrames.push_back(frame);
+            continue;
+        }
+
+        // FrameSet contains multiple frames
+        auto frameSet = frame->as<ob::FrameSet>();
+        for(uint32_t index = 0; index < frameSet->getCount(); index++) {
+            auto subFrame = frameSet->getFrameByIndex(index);
+            singleFrames.push_back(subFrame);
+        }
+    }
+
+    std::lock_guard<std::mutex> lk(srcFrameGroupsMtx_);
+    srcFrameGroups_[groupId] = singleFrames;
+    srcFrameGroupsCv_.notify_one();
+}
+
+void CVWindow::pushFramesToView(std::shared_ptr<const ob::Frame> currentFrame, int groupId) {
+    pushFramesToView(std::vector<std::shared_ptr<const ob::Frame>>{ currentFrame }, groupId);
+}
+
+// set show frame info
+void CVWindow::setShowInfo(bool show) {
+    showInfo_ = show;
+}
+
+// set show frame synctime info
+void CVWindow::setShowSyncTimeInfo(bool show) {
+    showSyncTimeInfo_ = show;
+}
+// set alpha for OVERLAY render mode
+void CVWindow::setAlpha(float alpha) {
+    alpha_ = alpha;
+    if(alpha_ < 0) {
+        alpha_ = 0;
+    }
+    else if(alpha_ > 1) {
+        alpha_ = 1;
+    }
+}
+
+// frames processing thread
+void CVWindow::processFrames() {
+    std::map<int, std::vector<std::shared_ptr<const ob::Frame>>> frameGroups;
+    while(!closed_) {
+        if(closed_) {
+            break;
+        }
+        {
+            std::unique_lock<std::mutex> lk(srcFrameGroupsMtx_);
+            srcFrameGroupsCv_.wait(lk);
+            frameGroups = srcFrameGroups_;
+        }
+
+        if(frameGroups.empty()) {
+            continue;
+        }
+
+        for(const auto &framesItem: frameGroups) {
+            int         groupId = framesItem.first;
+            const auto &frames  = framesItem.second;
+            for(const auto &frame: frames) {
+                auto rstMat = visualize(frame);
+                if(!rstMat.empty()) {
+                    int uid         = groupId * OB_FRAME_TYPE_COUNT + static_cast<int>(frame->getType());
+                    matGroups_[uid] = { frame, rstMat };
+                }
+            }
+        }
+
+        if(matGroups_.empty()) {
+            continue;
+        }
+
+        arrangeFrames();
+    }
+}
+
+void CVWindow::arrangeFrames() {
+    cv::Mat renderMat;
+    try {
+        if(arrangeMode_ == ARRANGE_SINGLE || matGroups_.size() == 1) {
+            auto &mat = matGroups_.begin()->second.second;
+            renderMat = resizeMatKeepAspectRatio(mat, width_, height_);
+        }
+        else if(arrangeMode_ == ARRANGE_ONE_ROW) {
+            for(auto &item: matGroups_) {
+                auto &  mat       = item.second.second;
+                cv::Mat resizeMat = resizeMatKeepAspectRatio(mat, static_cast<int>(width_ / matGroups_.size()), height_);
+                if(renderMat.dims > 0 && renderMat.cols > 0 && renderMat.rows > 0) {
+                    cv::hconcat(renderMat, resizeMat, renderMat);
+                }
+                else {
+                    renderMat = resizeMat;
+                }
+            }
+        }
+        else if(arrangeMode_ == ARRANGE_ONE_COLUMN) {
+            for(auto &item: matGroups_) {
+                auto &  mat       = item.second.second;
+                cv::Mat resizeMat = resizeMatKeepAspectRatio(mat, width_, static_cast<int>(height_ / matGroups_.size()));
+                if(renderMat.dims > 0 && renderMat.cols > 0 && renderMat.rows > 0) {
+                    cv::vconcat(renderMat, resizeMat, renderMat);
+                }
+                else {
+                    renderMat = resizeMat;
+                }
+            }
+        }
+        else if(arrangeMode_ == ARRANGE_GRID) {
+            int count     = static_cast<int>(matGroups_.size());
+            int idealSide = static_cast<int>(std::sqrt(count));
+            int rows      = idealSide;
+            int cols      = idealSide;
+            while(rows * cols < count) {  // find the best row and column count
+                cols++;
+                if(rows * cols < count) {
+                    rows++;
+                }
+            }
+
+            std::vector<cv::Mat> gridImages;  // store all images in grid
+            auto                 it = matGroups_.begin();
+            for(int i = 0; i < rows; i++) {
+                std::vector<cv::Mat> rowImages;  // store images in the same row
+                for(int j = 0; j < cols; j++) {
+                    int     index = i * cols + j;
+                    cv::Mat resizeMat;
+                    if(index < count) {
+                        auto mat  = it->second.second;
+                        resizeMat = resizeMatKeepAspectRatio(mat, width_ / cols, height_ / rows);
+                        it++;
+                    }
+                    else {
+                        resizeMat = cv::Mat::zeros(height_ / rows, width_ / cols, CV_8UC3);  // fill with black
+                    }
+                    rowImages.push_back(resizeMat);
+                }
+                cv::Mat lineMat;
+                cv::hconcat(rowImages, lineMat);  // horizontal concat all images in the same row
+                gridImages.push_back(lineMat);
+            }
+
+            cv::vconcat(gridImages, renderMat);  // vertical concat all images in the grid
+        }
+        else if(arrangeMode_ == ARRANGE_OVERLAY && matGroups_.size() >= 2) {
+            cv::Mat     overlayMat;
+            const auto &mat1 = matGroups_.begin()->second.second;
+            const auto &mat2 = matGroups_.rbegin()->second.second;
+            renderMat        = resizeMatKeepAspectRatio(mat1, width_, height_);
+            overlayMat       = resizeMatKeepAspectRatio(mat2, width_, height_);
+
+            float alpha = alpha_;
+            for(int i = 0; i < renderMat.rows; i++) {
+                for(int j = 0; j < renderMat.cols; j++) {
+                    cv::Vec3b &outRgb     = renderMat.at<cv::Vec3b>(i, j);
+                    cv::Vec3b &overlayRgb = overlayMat.at<cv::Vec3b>(i, j);
+
+                    outRgb[0] = (uint8_t)(outRgb[0] * (1.0f - alpha) + overlayRgb[0] * alpha);
+                    outRgb[1] = (uint8_t)(outRgb[1] * (1.0f - alpha) + overlayRgb[1] * alpha);
+                    outRgb[2] = (uint8_t)(outRgb[2] * (1.0f - alpha) + overlayRgb[2] * alpha);
+                }
+            }
+        }
+    }
+    catch(std::exception &e) {
+        std::cerr << e.what() << std::endl;
+    }
+
+    if(renderMat.empty()) {
+        return;
+    }
+
+    if(showPrompt_ || getNowTimesMs() - winCreatedTime_ < 5000) {
+        cv::putText(renderMat, prompt_, cv::Point(8, 16), cv::FONT_HERSHEY_DUPLEX, 0.5, cv::Scalar(255, 255, 255), 1, cv::LINE_AA);
+    }
+
+    if(!log_.empty() && getNowTimesMs() - logCreatedTime_ < 3000) {
+        cv::putText(renderMat, log_, cv::Point(8, height_ - 16), cv::FONT_HERSHEY_DUPLEX, 0.5, cv::Scalar(255, 255, 255), 1, cv::LINE_AA);
+    }
+
+    std::lock_guard<std::mutex> lock(renderMatsMtx_);
+    renderMat_ = renderMat;
+}
+
+cv::Mat CVWindow::visualize(std::shared_ptr<const ob::Frame> frame) {
+    if(frame == nullptr) {
+        return cv::Mat();
+    }
+
+    cv::Mat rstMat;
+    if(frame->getType() == OB_FRAME_COLOR) {
+        auto videoFrame = frame->as<const ob::VideoFrame>();
+        switch(videoFrame->getFormat()) {
+        case OB_FORMAT_MJPG: {
+            cv::Mat rawMat(1, videoFrame->getDataSize(), CV_8UC1, videoFrame->getData());
+            rstMat = cv::imdecode(rawMat, 1);
+        } break;
+        case OB_FORMAT_NV21: {
+            cv::Mat rawMat(videoFrame->getHeight() * 3 / 2, videoFrame->getWidth(), CV_8UC1, videoFrame->getData());
+            cv::cvtColor(rawMat, rstMat, cv::COLOR_YUV2BGR_NV21);
+        } break;
+        case OB_FORMAT_YUYV:
+        case OB_FORMAT_YUY2: {
+            cv::Mat rawMat(videoFrame->getHeight(), videoFrame->getWidth(), CV_8UC2, videoFrame->getData());
+            cv::cvtColor(rawMat, rstMat, cv::COLOR_YUV2BGR_YUY2);
+        } break;
+        case OB_FORMAT_RGB: {
+            cv::Mat rawMat(videoFrame->getHeight(), videoFrame->getWidth(), CV_8UC3, videoFrame->getData());
+            cv::cvtColor(rawMat, rstMat, cv::COLOR_RGB2BGR);
+        } break;
+        case OB_FORMAT_RGBA: {
+            cv::Mat rawMat(videoFrame->getHeight(), videoFrame->getWidth(), CV_8UC4, videoFrame->getData());
+            cv::cvtColor(rawMat, rstMat, cv::COLOR_RGBA2BGR);
+        } break;
+        case OB_FORMAT_BGRA: {
+            cv::Mat rawMat(videoFrame->getHeight(), videoFrame->getWidth(), CV_8UC4, videoFrame->getData());
+            cv::cvtColor(rawMat, rstMat, cv::COLOR_BGRA2BGR);
+        } break;
+        case OB_FORMAT_UYVY: {
+            cv::Mat rawMat(videoFrame->getHeight(), videoFrame->getWidth(), CV_8UC2, videoFrame->getData());
+            cv::cvtColor(rawMat, rstMat, cv::COLOR_YUV2BGR_UYVY);
+        } break;
+        case OB_FORMAT_I420: {
+            cv::Mat rawMat(videoFrame->getHeight() * 3 / 2, videoFrame->getWidth(), CV_8UC1, videoFrame->getData());
+            cv::cvtColor(rawMat, rstMat, cv::COLOR_YUV2BGR_I420);
+        } break;
+        default:
+            break;
+        }
+        if(showSyncTimeInfo_ && !rstMat.empty()) {
+            drawInfo(rstMat, videoFrame);
+        }
+    }
+    else if(frame->getType() == OB_FRAME_DEPTH) {
+        auto videoFrame = frame->as<const ob::VideoFrame>();
+        if(videoFrame->getFormat() == OB_FORMAT_Y16 || videoFrame->getFormat() == OB_FORMAT_Z16) {
+            cv::Mat rawMat = cv::Mat(videoFrame->getHeight(), videoFrame->getWidth(), CV_16UC1, videoFrame->getData());
+            // depth frame pixel value multiply scale to get distance in millimeter
+            float scale = videoFrame->as<ob::DepthFrame>()->getValueScale();
+
+            cv::Mat cvtMat;
+            // normalization to 0-255. 0.032f is 256/8000, to limit the range of depth to 8000mm
+            rawMat.convertTo(cvtMat, CV_32F, scale * 0.032f);
+
+            // apply gamma correction to enhance the contrast for near objects
+            cv::pow(cvtMat, 0.6f, cvtMat);
+
+            //  convert to 8-bit
+            cvtMat.convertTo(cvtMat, CV_8UC1, 10);  // multiplier 10 is to normalize to 0-255 (nearly) after applying gamma correction
+
+            // apply colormap
+            cv::applyColorMap(cvtMat, rstMat, cv::COLORMAP_JET);
+        }
+        if(showSyncTimeInfo_ && !rstMat.empty()) {
+            drawInfo(rstMat, videoFrame);
+        }
+    }
+    else if(frame->getType() == OB_FRAME_IR || frame->getType() == OB_FRAME_IR_LEFT || frame->getType() == OB_FRAME_IR_RIGHT) {
+        auto videoFrame = frame->as<const ob::VideoFrame>();
+        if(videoFrame->getFormat() == OB_FORMAT_Y16) {
+            cv::Mat cvtMat;
+            cv::Mat rawMat = cv::Mat(videoFrame->getHeight(), videoFrame->getWidth(), CV_16UC1, videoFrame->getData());
+            rawMat.convertTo(cvtMat, CV_8UC1, 1.0 / 16.0f);
+            cv::cvtColor(cvtMat, rstMat, cv::COLOR_GRAY2RGB);
+        }
+        else if(videoFrame->getFormat() == OB_FORMAT_Y8) {
+            cv::Mat rawMat = cv::Mat(videoFrame->getHeight(), videoFrame->getWidth(), CV_8UC1, videoFrame->getData());
+            cv::cvtColor(rawMat, rstMat, cv::COLOR_GRAY2RGB);
+        }
+        else if(videoFrame->getFormat() == OB_FORMAT_MJPG) {
+            cv::Mat rawMat(1, videoFrame->getDataSize(), CV_8UC1, videoFrame->getData());
+            rstMat = cv::imdecode(rawMat, 1);
+            cv::cvtColor(rstMat, rstMat, cv::COLOR_GRAY2RGB);
+        }
+        if(showSyncTimeInfo_ && !rstMat.empty()) {
+            drawInfo(rstMat, videoFrame);
+        }
+    }
+    else if(frame->getType() == OB_FRAME_ACCEL) {
+        rstMat                 = cv::Mat::zeros(320, 240, CV_8UC3);
+        auto        accelFrame = frame->as<ob::AccelFrame>();
+        auto        value      = accelFrame->getValue();
+        std::string str        = "Accel:";
+        cv::putText(rstMat, str.c_str(), cv::Point(8, 60), cv::FONT_HERSHEY_DUPLEX, 0.6, cv::Scalar(255, 255, 255), 1, cv::LINE_AA);
+        str = std::string(" timestamp=") + std::to_string(accelFrame->getTimeStampUs()) + "us";
+        cv::putText(rstMat, str.c_str(), cv::Point(8, 100), cv::FONT_HERSHEY_DUPLEX, 0.6, cv::Scalar(255, 255, 255), 1, cv::LINE_AA);
+        str = std::string(" x=") + std::to_string(value.x) + "m/s^2";
+        cv::putText(rstMat, str.c_str(), cv::Point(8, 140), cv::FONT_HERSHEY_DUPLEX, 0.6, cv::Scalar(255, 255, 255), 1, cv::LINE_AA);
+        str = std::string(" y=") + std::to_string(value.y) + "m/s^2";
+        cv::putText(rstMat, str.c_str(), cv::Point(8, 180), cv::FONT_HERSHEY_DUPLEX, 0.6, cv::Scalar(255, 255, 255), 1, cv::LINE_AA);
+        str = std::string(" z=") + std::to_string(value.z) + "m/s^2";
+        cv::putText(rstMat, str.c_str(), cv::Point(8, 220), cv::FONT_HERSHEY_DUPLEX, 0.6, cv::Scalar(255, 255, 255), 1, cv::LINE_AA);
+    }
+    else if(frame->getType() == OB_FRAME_GYRO) {
+        rstMat                = cv::Mat::zeros(320, 240, CV_8UC3);
+        auto        gyroFrame = frame->as<ob::GyroFrame>();
+        auto        value     = gyroFrame->getValue();
+        std::string str       = "Gyro:";
+        cv::putText(rstMat, str.c_str(), cv::Point(8, 60), cv::FONT_HERSHEY_DUPLEX, 0.6, cv::Scalar(255, 255, 255), 1, cv::LINE_AA);
+        str = std::string(" timestamp=") + std::to_string(gyroFrame->getTimeStampUs()) + "us";
+        cv::putText(rstMat, str.c_str(), cv::Point(8, 100), cv::FONT_HERSHEY_DUPLEX, 0.6, cv::Scalar(255, 255, 255), 1, cv::LINE_AA);
+        str = std::string(" x=") + std::to_string(value.x) + "rad/s";
+        cv::putText(rstMat, str.c_str(), cv::Point(8, 140), cv::FONT_HERSHEY_DUPLEX, 0.6, cv::Scalar(255, 255, 255), 1, cv::LINE_AA);
+        str = std::string(" y=") + std::to_string(value.y) + "rad/s";
+        cv::putText(rstMat, str.c_str(), cv::Point(8, 180), cv::FONT_HERSHEY_DUPLEX, 0.6, cv::Scalar(255, 255, 255), 1, cv::LINE_AA);
+        str = std::string(" z=") + std::to_string(value.z) + "rad/s";
+        cv::putText(rstMat, str.c_str(), cv::Point(8, 220), cv::FONT_HERSHEY_DUPLEX, 0.6, cv::Scalar(255, 255, 255), 1, cv::LINE_AA);
+    }
+    return rstMat;
+}
+
+// add frame info to mat
+void CVWindow::drawInfo(cv::Mat &imageMat, std::shared_ptr<const ob::VideoFrame> &frame) {
+    int      baseline = 0;  // Used to calculate text size and baseline
+    cv::Size textSize;      // Size of the text to be drawn
+    int      padding = 5;   // Padding around the text for the background
+
+    // Helper lambda function to draw text with background
+    auto putTextWithBackground = [&](const std::string &text, cv::Point origin) {
+        // Getting text size for background
+        textSize = cv::getTextSize(text, cv::FONT_HERSHEY_SIMPLEX, 0.6, 1, &baseline);
+
+        // Drawing the white background
+        cv::rectangle(imageMat, origin + cv::Point(0, baseline), origin + cv::Point(textSize.width, -textSize.height) - cv::Point(0, padding),
+                      cv::Scalar(255, 255, 255), cv::FILLED);
+
+        // Putting black text on the white background
+        cv::putText(imageMat, text, origin, cv::FONT_HERSHEY_SIMPLEX, 0.6, cv::Scalar(0, 0, 0), 1);
+    };
+
+    // Drawing text with background based on frame type
+    if(frame->getType() == OB_FRAME_COLOR && frame->getFormat() == OB_FORMAT_NV21) {
+        putTextWithBackground("Color-NV21", cv::Point(8, 16));
+    }
+    else if(frame->getType() == OB_FRAME_COLOR && frame->getFormat() == OB_FORMAT_MJPG) {
+        putTextWithBackground("Color-MJPG", cv::Point(8, 16));
+    }
+    else if(frame->getType() == OB_FRAME_COLOR && ((frame->getFormat() == OB_FORMAT_YUYV) || (frame->getFormat() == OB_FORMAT_YUY2))) {
+        putTextWithBackground("Color-YUYV", cv::Point(8, 16));
+    }
+    else if(frame->getType() == OB_FRAME_DEPTH) {
+        putTextWithBackground("Depth", cv::Point(8, 16));
+    }
+    else if(frame->getType() == OB_FRAME_IR) {
+        putTextWithBackground("IR", cv::Point(8, 16));
+    }
+    else if(frame->getType() == OB_FRAME_IR_LEFT) {
+        putTextWithBackground("LeftIR", cv::Point(8, 16));
+    }
+    else if(frame->getType() == OB_FRAME_IR_RIGHT) {
+        putTextWithBackground("RightIR", cv::Point(8, 16));
+    }
+
+    // Timestamp information with background
+    putTextWithBackground("frame timestamp(ms):  " + std::to_string(frame->getTimeStampUs()), cv::Point(8, 40));
+    putTextWithBackground("system timestamp(ms): " + std::to_string(frame->getSystemTimeStampUs()), cv::Point(8, 64));
+}
+
+cv::Mat CVWindow::resizeMatKeepAspectRatio(const cv::Mat &mat, int width, int height) {
+    auto    hScale    = static_cast<double>(width) / mat.cols;
+    auto    vScale    = static_cast<double>(height) / mat.rows;
+    auto    scale     = std::min(hScale, vScale);
+    auto    newWidth  = static_cast<int>(mat.cols * scale);
+    auto    newHeight = static_cast<int>(mat.rows * scale);
+    cv::Mat resizeMat;
+    cv::resize(mat, resizeMat, cv::Size(newWidth, newHeight));
+
+    if(newWidth == width && newHeight == height) {
+        return resizeMat;
+    }
+
+    // padding the resized mat to target width and height
+    cv::Mat paddedMat;
+    if(newWidth < width) {
+        auto paddingLeft  = (width - newWidth) / 2;
+        auto paddingRight = width - newWidth - paddingLeft;
+        cv::copyMakeBorder(resizeMat, paddedMat, 0, 0, paddingLeft, paddingRight, cv::BORDER_CONSTANT, cv::Scalar(0, 0, 0));
+    }
+
+    if(newHeight < height) {
+        auto paddingTop    = (height - newHeight) / 2;
+        auto paddingBottom = height - newHeight - paddingTop;
+        cv::copyMakeBorder(resizeMat, paddedMat, paddingTop, paddingBottom, 0, 0, cv::BORDER_CONSTANT, cv::Scalar(0, 0, 0));
+    }
+    return paddedMat;
+}
+
+}  // namespace ob_smpl
diff --git a/examples/utils/utils_opencv.hpp b/examples/utils/utils_opencv.hpp
new file mode 100644
index 00000000..ea207875
--- /dev/null
+++ b/examples/utils/utils_opencv.hpp
@@ -0,0 +1,117 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include <libobsensor/ObSensor.hpp>
+#include <opencv2/opencv.hpp>
+#include <string>
+#include <thread>
+#include <mutex>
+#include <condition_variable>
+#include <cmath>
+#include <map>
+
+#include "utils_types.h"
+#include "utils.hpp"
+
+namespace ob_smpl {
+
+// arrange type
+typedef enum {
+    ARRANGE_SINGLE,      // Only show the first frame
+    ARRANGE_ONE_ROW,     // Arrange the frames in the array as a row
+    ARRANGE_ONE_COLUMN,  // Arrange the frames in the array as a column
+    ARRANGE_GRID,        // Arrange the frames in the array as a grid
+    ARRANGE_OVERLAY      // Overlay the first two frames in the array
+} ArrangeMode;
+
+class CVWindow {
+public:
+    // create a window with the specified name, width and height
+    CVWindow(std::string name, uint32_t width = 1280, uint32_t height = 720, ArrangeMode arrangeMode = ARRANGE_SINGLE);
+    ~CVWindow() noexcept;
+
+    // run the window loop
+    bool run();
+
+    // close window
+    void close();
+
+    // clear cached frames and mats
+    void reset();
+
+    // add frames to view
+    void pushFramesToView(std::vector<std::shared_ptr<const ob::Frame>> frames, int groupId = 0);
+    void pushFramesToView(std::shared_ptr<const ob::Frame> currentFrame, int groupId = 0);
+
+    // set show frame info
+    void setShowInfo(bool show);
+
+    // set show frame syncTime info
+    void setShowSyncTimeInfo(bool show);
+
+    // set alpha, only valid when arrangeMode_ is ARRANGE_OVERLAY
+    void setAlpha(float alpha);
+
+    // set the window size
+    void resize(int width, int height);
+
+    // set the key pressed callback
+    void setKeyPressedCallback(std::function<void(int)> callback);
+
+    // set the key prompt
+    void setKeyPrompt(const std::string &prompt);
+
+    // set the log message
+    void addLog(const std::string &log);
+
+    // destroyWindow
+    void destroyWindow();
+
+private:
+    // frames processing thread function
+    void processFrames();
+
+    // arrange frames in the renderMat_ according to the arrangeMode_
+    void arrangeFrames();
+
+    // add info to mat
+    cv::Mat visualize(std::shared_ptr<const ob::Frame> frame);
+
+    // draw info to mat
+    void drawInfo(cv::Mat &imageMat, std::shared_ptr<const ob::VideoFrame> &frame);
+
+    cv::Mat resizeMatKeepAspectRatio(const cv::Mat &mat, int width, int height);
+
+private:
+    std::string name_;
+    ArrangeMode arrangeMode_;
+    uint32_t    width_;
+    uint32_t    height_;
+    bool        closed_;
+    bool        showInfo_;
+    bool        showSyncTimeInfo_;
+    bool        isWindowDestroyed_;
+    float       alpha_;
+
+    std::thread                                                  processThread_;
+    std::map<int, std::vector<std::shared_ptr<const ob::Frame>>> srcFrameGroups_;
+    std::mutex                                                   srcFrameGroupsMtx_;
+    std::condition_variable                                      srcFrameGroupsCv_;
+
+    using StreamsMatMap = std::map<int, std::pair<std::shared_ptr<const ob::Frame>, cv::Mat>>;
+    StreamsMatMap matGroups_;
+    std::mutex    renderMatsMtx_;
+    cv::Mat       renderMat_;
+
+    std::string prompt_;
+    bool        showPrompt_;
+    uint64      winCreatedTime_;
+
+    std::string log_;
+    uint64      logCreatedTime_;
+
+    std::function<void(int)> keyPressedCallback_;
+};
+
+}  // namespace ob_smpl
diff --git a/examples/utils/utils_types.h b/examples/utils/utils_types.h
new file mode 100644
index 00000000..cd1e09d4
--- /dev/null
+++ b/examples/utils/utils_types.h
@@ -0,0 +1,12 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define ESC_KEY 27
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/extensions/CMakeLists.txt b/extensions/CMakeLists.txt
new file mode 100644
index 00000000..98594f62
--- /dev/null
+++ b/extensions/CMakeLists.txt
@@ -0,0 +1,46 @@
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+cmake_minimum_required(VERSION 3.5)
+
+add_custom_target(extensions ALL)
+
+add_custom_command(
+    TARGET extensions
+    POST_BUILD
+    COMMAND ${CMAKE_COMMAND} -E copy_directory "${CMAKE_CURRENT_LIST_DIR}/filters/${OB_CURRENT_OS}" "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/extensions/filters")
+
+add_custom_command(
+    TARGET extensions
+    POST_BUILD
+    COMMAND ${CMAKE_COMMAND} -E copy_directory "${CMAKE_CURRENT_LIST_DIR}/frameprocessor/${OB_CURRENT_OS}" "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/extensions/frameprocessor")
+
+if(NOT APPLE)
+    add_custom_command(
+        TARGET extensions
+        POST_BUILD
+        COMMAND ${CMAKE_COMMAND} -E copy_directory "${CMAKE_CURRENT_LIST_DIR}/depthengine/${OB_CURRENT_OS}" "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/extensions/depthengine")
+endif()
+
+add_custom_command(
+    TARGET extensions
+    POST_BUILD
+    COMMAND ${CMAKE_COMMAND} -E copy_directory "${CMAKE_CURRENT_LIST_DIR}/firmwareupdater/${OB_CURRENT_OS}" "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/extensions/firmwareupdater")
+
+set_target_properties(extensions PROPERTIES FOLDER "modules")
+
+if(OB_IS_MAIN_PROJECT)
+    install(DIRECTORY "${CMAKE_CURRENT_LIST_DIR}/filters/${OB_CURRENT_OS}/" DESTINATION "bin/extensions/filters")
+    install(DIRECTORY "${CMAKE_CURRENT_LIST_DIR}/filters/${OB_CURRENT_OS}/" DESTINATION "lib/extensions/filters")
+
+    install(DIRECTORY "${CMAKE_CURRENT_LIST_DIR}/frameprocessor/${OB_CURRENT_OS}/" DESTINATION "bin/extensions/frameprocessor")
+    install(DIRECTORY "${CMAKE_CURRENT_LIST_DIR}/frameprocessor/${OB_CURRENT_OS}/" DESTINATION "lib/extensions/frameprocessor")
+
+if(NOT APPLE)
+    install(DIRECTORY "${CMAKE_CURRENT_LIST_DIR}/depthengine/${OB_CURRENT_OS}/" DESTINATION "bin/extensions/depthengine")
+    install(DIRECTORY "${CMAKE_CURRENT_LIST_DIR}/depthengine/${OB_CURRENT_OS}/" DESTINATION "lib/extensions/depthengine")
+endif()
+
+    install(DIRECTORY "${CMAKE_CURRENT_LIST_DIR}/firmwareupdater/${OB_CURRENT_OS}/" DESTINATION "bin/extensions/firmwareupdater")
+    install(DIRECTORY "${CMAKE_CURRENT_LIST_DIR}/firmwareupdater/${OB_CURRENT_OS}/" DESTINATION "lib/extensions/firmwareupdater")
+endif()
diff --git a/extensions/README.md b/extensions/README.md
new file mode 100644
index 00000000..9ffbd336
--- /dev/null
+++ b/extensions/README.md
@@ -0,0 +1,9 @@
+
+# Orbbec SDK Extensions
+
+This directory contains the binaries file for the Orbbec SDK extensions. The extensions are developed by the Orbbec SDK team or partners and are not open source. The extensions are under the MIT license, feel free to use them in your projects.
+
+- filters： Contains the private filters library for the Orbbec SDK.
+- frameprocessor： Contains the private frame processor library for the Orbbec SDK.
+- firmwareupdater： Contains the private firmware updater library for the Orbbec SDK.
+- depthengine： Contains the private depth engine library for the Orbbec SDK of the Femto Bolt device.
diff --git a/extensions/depthengine/linux_arm32/.gitkeep b/extensions/depthengine/linux_arm32/.gitkeep
new file mode 100644
index 00000000..e69de29b
diff --git a/extensions/depthengine/linux_arm64/libdepthengine.so b/extensions/depthengine/linux_arm64/libdepthengine.so
new file mode 120000
index 00000000..745a98a5
--- /dev/null
+++ b/extensions/depthengine/linux_arm64/libdepthengine.so
@@ -0,0 +1 @@
+libdepthengine.so.2.0
\ No newline at end of file
diff --git a/extensions/depthengine/linux_arm64/libdepthengine.so.2.0 b/extensions/depthengine/linux_arm64/libdepthengine.so.2.0
new file mode 100644
index 00000000..61c3e389
Binary files /dev/null and b/extensions/depthengine/linux_arm64/libdepthengine.so.2.0 differ
diff --git a/extensions/depthengine/linux_x86_64/libdepthengine.so b/extensions/depthengine/linux_x86_64/libdepthengine.so
new file mode 120000
index 00000000..745a98a5
--- /dev/null
+++ b/extensions/depthengine/linux_x86_64/libdepthengine.so
@@ -0,0 +1 @@
+libdepthengine.so.2.0
\ No newline at end of file
diff --git a/extensions/depthengine/linux_x86_64/libdepthengine.so.2.0 b/extensions/depthengine/linux_x86_64/libdepthengine.so.2.0
new file mode 100644
index 00000000..dd818fae
Binary files /dev/null and b/extensions/depthengine/linux_x86_64/libdepthengine.so.2.0 differ
diff --git a/extensions/depthengine/mac/.gitkeep b/extensions/depthengine/mac/.gitkeep
new file mode 100644
index 00000000..e69de29b
diff --git a/extensions/depthengine/win_x64/depthengine.dll b/extensions/depthengine/win_x64/depthengine.dll
new file mode 100644
index 00000000..223672f4
Binary files /dev/null and b/extensions/depthengine/win_x64/depthengine.dll differ
diff --git a/extensions/depthengine/win_x64/depthengine.lib b/extensions/depthengine/win_x64/depthengine.lib
new file mode 100644
index 00000000..bd6987dd
Binary files /dev/null and b/extensions/depthengine/win_x64/depthengine.lib differ
diff --git a/extensions/depthengine/win_x86/depthengine.dll b/extensions/depthengine/win_x86/depthengine.dll
new file mode 100644
index 00000000..076eb4f3
Binary files /dev/null and b/extensions/depthengine/win_x86/depthengine.dll differ
diff --git a/extensions/depthengine/win_x86/depthengine.lib b/extensions/depthengine/win_x86/depthengine.lib
new file mode 100644
index 00000000..ebbf8b8e
Binary files /dev/null and b/extensions/depthengine/win_x86/depthengine.lib differ
diff --git a/extensions/filters/linux_arm32/.gitkeep b/extensions/filters/linux_arm32/.gitkeep
new file mode 100644
index 00000000..e69de29b
diff --git a/extensions/filters/linux_arm64/libFilterProcessor.so b/extensions/filters/linux_arm64/libFilterProcessor.so
new file mode 100755
index 00000000..a89a8a44
Binary files /dev/null and b/extensions/filters/linux_arm64/libFilterProcessor.so differ
diff --git a/extensions/filters/linux_arm64/libob_priv_filter.so b/extensions/filters/linux_arm64/libob_priv_filter.so
new file mode 100755
index 00000000..db1a5f09
Binary files /dev/null and b/extensions/filters/linux_arm64/libob_priv_filter.so differ
diff --git a/extensions/filters/linux_x86_64/libFilterProcessor.so b/extensions/filters/linux_x86_64/libFilterProcessor.so
new file mode 100755
index 00000000..5e4e43cf
Binary files /dev/null and b/extensions/filters/linux_x86_64/libFilterProcessor.so differ
diff --git a/extensions/filters/linux_x86_64/libob_priv_filter.so b/extensions/filters/linux_x86_64/libob_priv_filter.so
new file mode 100755
index 00000000..e95c15cd
Binary files /dev/null and b/extensions/filters/linux_x86_64/libob_priv_filter.so differ
diff --git a/extensions/filters/macos_arm64/libFilterProcessor.dylib b/extensions/filters/macos_arm64/libFilterProcessor.dylib
new file mode 100755
index 00000000..132c7f35
Binary files /dev/null and b/extensions/filters/macos_arm64/libFilterProcessor.dylib differ
diff --git a/extensions/filters/macos_arm64/libob_priv_filter.dylib b/extensions/filters/macos_arm64/libob_priv_filter.dylib
new file mode 100755
index 00000000..2b99c2b1
Binary files /dev/null and b/extensions/filters/macos_arm64/libob_priv_filter.dylib differ
diff --git a/extensions/filters/win_x64/FilterProcessor.dll b/extensions/filters/win_x64/FilterProcessor.dll
new file mode 100644
index 00000000..f4d4649d
Binary files /dev/null and b/extensions/filters/win_x64/FilterProcessor.dll differ
diff --git a/extensions/filters/win_x64/ob_priv_filter.dll b/extensions/filters/win_x64/ob_priv_filter.dll
new file mode 100644
index 00000000..e4efc734
Binary files /dev/null and b/extensions/filters/win_x64/ob_priv_filter.dll differ
diff --git a/extensions/filters/win_x86/.gitkeep b/extensions/filters/win_x86/.gitkeep
new file mode 100644
index 00000000..e69de29b
diff --git a/extensions/firmwareupdater/linux_arm64/libfirmwareupdater.so b/extensions/firmwareupdater/linux_arm64/libfirmwareupdater.so
new file mode 100755
index 00000000..fb630bd2
Binary files /dev/null and b/extensions/firmwareupdater/linux_arm64/libfirmwareupdater.so differ
diff --git a/extensions/firmwareupdater/linux_x86_64/libfirmwareupdater.so b/extensions/firmwareupdater/linux_x86_64/libfirmwareupdater.so
new file mode 100644
index 00000000..c9ac3c38
Binary files /dev/null and b/extensions/firmwareupdater/linux_x86_64/libfirmwareupdater.so differ
diff --git a/extensions/firmwareupdater/macos_arm64/libfirmwareupdater.dylib b/extensions/firmwareupdater/macos_arm64/libfirmwareupdater.dylib
new file mode 100755
index 00000000..fcfdae18
Binary files /dev/null and b/extensions/firmwareupdater/macos_arm64/libfirmwareupdater.dylib differ
diff --git a/extensions/firmwareupdater/win_x64/firmwareupdater.dll b/extensions/firmwareupdater/win_x64/firmwareupdater.dll
new file mode 100644
index 00000000..675381e2
Binary files /dev/null and b/extensions/firmwareupdater/win_x64/firmwareupdater.dll differ
diff --git a/extensions/frameprocessor/linux_arm32/.gitkeep b/extensions/frameprocessor/linux_arm32/.gitkeep
new file mode 100644
index 00000000..e69de29b
diff --git a/extensions/frameprocessor/linux_arm64/libob_frame_processor.so b/extensions/frameprocessor/linux_arm64/libob_frame_processor.so
new file mode 100755
index 00000000..8a147895
Binary files /dev/null and b/extensions/frameprocessor/linux_arm64/libob_frame_processor.so differ
diff --git a/extensions/frameprocessor/linux_x86_64/libob_frame_processor.so b/extensions/frameprocessor/linux_x86_64/libob_frame_processor.so
new file mode 100644
index 00000000..5e70474b
Binary files /dev/null and b/extensions/frameprocessor/linux_x86_64/libob_frame_processor.so differ
diff --git a/extensions/frameprocessor/macos_arm64/libob_frame_processor.dylib b/extensions/frameprocessor/macos_arm64/libob_frame_processor.dylib
new file mode 100755
index 00000000..7c5bbccc
Binary files /dev/null and b/extensions/frameprocessor/macos_arm64/libob_frame_processor.dylib differ
diff --git a/extensions/frameprocessor/win_x64/ob_frame_processor.dll b/extensions/frameprocessor/win_x64/ob_frame_processor.dll
new file mode 100644
index 00000000..44048758
Binary files /dev/null and b/extensions/frameprocessor/win_x64/ob_frame_processor.dll differ
diff --git a/extensions/frameprocessor/win_x86/.gitkeep b/extensions/frameprocessor/win_x86/.gitkeep
new file mode 100644
index 00000000..e69de29b
diff --git a/include/libobsensor/ObSensor.h b/include/libobsensor/ObSensor.h
new file mode 100644
index 00000000..cd05372e
--- /dev/null
+++ b/include/libobsensor/ObSensor.h
@@ -0,0 +1,23 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+/**
+ * \file ObSensor.h
+ * \brief This file serves as the C entrance for the OrbbecSDK library.
+ *        It includes all necessary header files for OrbbecSDK usage.
+ */
+#pragma once
+
+#include <libobsensor/h/Context.h>
+#include <libobsensor/h/Device.h>
+#include <libobsensor/h/Error.h>
+#include <libobsensor/h/Filter.h>
+#include <libobsensor/h/Frame.h>
+#include <libobsensor/h/ObTypes.h>
+#include <libobsensor/h/Pipeline.h>
+#include <libobsensor/h/Property.h>
+#include <libobsensor/h/Sensor.h>
+#include <libobsensor/h/StreamProfile.h>
+#include <libobsensor/h/Version.h>
+#include <libobsensor/h/TypeHelper.h>
+
diff --git a/include/libobsensor/ObSensor.hpp b/include/libobsensor/ObSensor.hpp
new file mode 100644
index 00000000..8f148a6a
--- /dev/null
+++ b/include/libobsensor/ObSensor.hpp
@@ -0,0 +1,22 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+/**
+ * \file ObSensor.hpp
+ * \brief This is the main entry point for the OrbbecSDK C++ library.
+ *        It includes all necessary header files for using the library.
+ */
+#pragma once
+
+#include <libobsensor/hpp/Context.hpp>
+#include <libobsensor/hpp/Device.hpp>
+#include <libobsensor/hpp/Error.hpp>
+#include <libobsensor/hpp/Filter.hpp>
+#include <libobsensor/hpp/Frame.hpp>
+#include <libobsensor/hpp/Pipeline.hpp>
+// #include <libobsensor/hpp/RecordPlayback.hpp>
+#include <libobsensor/hpp/Sensor.hpp>
+#include <libobsensor/hpp/StreamProfile.hpp>
+#include <libobsensor/hpp/Version.hpp>
+#include <libobsensor/hpp/TypeHelper.hpp>
+
diff --git a/include/libobsensor/h/Advanced.h b/include/libobsensor/h/Advanced.h
new file mode 100644
index 00000000..846abedc
--- /dev/null
+++ b/include/libobsensor/h/Advanced.h
@@ -0,0 +1,212 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "ObTypes.h"
+
+/**
+ * @brief Get the current depth work mode.
+ *
+ * @param[in] device The device object.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ *
+ * @return ob_depth_work_mode The current depth work mode.
+ */
+OB_EXPORT ob_depth_work_mode ob_device_get_current_depth_work_mode(const ob_device *device, ob_error **error);
+
+/**
+ * @brief Get current depth mode name
+ * @brief According the current preset name to return current depth mode name
+ * @return const char* return the current depth mode name.
+ */
+OB_EXPORT const char *ob_device_get_current_depth_work_mode_name(const ob_device *device, ob_error **error);
+
+/**
+ * @brief Switch the depth work mode by ob_depth_work_mode.
+ *        Prefer to use ob_device_switch_depth_work_mode_by_name to switch depth mode when the complete name of the depth work mode is known.
+ *
+ * @param[in] device The device object.
+ * @param[in] work_mode The depth work mode from ob_depth_work_mode_list which is returned by ob_device_get_depth_work_mode_list.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ *
+ * @return ob_status The switch result. OB_STATUS_OK: success, other failed.
+ */
+OB_EXPORT ob_status ob_device_switch_depth_work_mode(ob_device *device, const ob_depth_work_mode *work_mode, ob_error **error);
+
+/**
+ * @brief Switch the depth work mode by work mode name.
+ *
+ * @param[in] device The device object.
+ * @param[in] mode_name The depth work mode name which is equal to ob_depth_work_mode.name.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ *
+ * @return ob_status The switch result. OB_STATUS_OK: success, other failed.
+ */
+OB_EXPORT ob_status ob_device_switch_depth_work_mode_by_name(ob_device *device, const char *mode_name, ob_error **error);
+
+/**
+ * @brief Request the list of supported depth work modes.
+ *
+ * @param[in] device The device object.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ *
+ * @return ob_depth_work_mode_list The list of ob_depth_work_mode.
+ */
+OB_EXPORT ob_depth_work_mode_list *ob_device_get_depth_work_mode_list(const ob_device *device, ob_error **error);
+
+/**
+ * \if English
+ * @brief Get the depth work mode count that ob_depth_work_mode_list hold
+ * @param[in] work_mode_list data struct contain list of ob_depth_work_mode
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return The total number contained in ob_depth_work_mode_list
+ *
+ */
+OB_EXPORT uint32_t ob_depth_work_mode_list_get_count(const ob_depth_work_mode_list *work_mode_list, ob_error **error);
+
+/**
+ * @brief Get the index target of ob_depth_work_mode from work_mode_list
+ *
+ * @param[in] work_mode_list Data structure containing a list of ob_depth_work_mode
+ * @param[in] index Index of the target ob_depth_work_mode
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return ob_depth_work_mode
+ *
+ */
+OB_EXPORT ob_depth_work_mode ob_depth_work_mode_list_get_item(const ob_depth_work_mode_list *work_mode_list, uint32_t index, ob_error **error);
+
+/**
+ * @brief Free the resources of ob_depth_work_mode_list
+ *
+ * @param[in] work_mode_list Data structure containing a list of ob_depth_work_mode
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ *
+ */
+OB_EXPORT void ob_delete_depth_work_mode_list(ob_depth_work_mode_list *work_mode_list, ob_error **error);
+
+/**
+ * @breif Get the current preset name.
+ * @brief The preset mean a set of parameters or configurations that can be applied to the device to achieve a specific effect or function.
+ *
+ * @param device The device object.
+ * @param error  Pointer to an error object that will be set if an error occurs.
+ * @return  The current preset name, it should be one of the preset names returned by @ref ob_device_get_available_preset_list.
+ */
+OB_EXPORT const char *ob_device_get_current_preset_name(const ob_device *device, ob_error **error);
+
+/**
+ * @brief Get the available preset list.
+ * @attention After loading the preset, the settings in the preset will set to the device immediately. Therefore, it is recommended to re-read the device
+ * settings to update the user program temporarily.
+ *
+ * @param device The device object.
+ * @param preset_name  Pointer to an error object that will be set if an error occurs. The name should be one of the preset names returned by @ref
+ * ob_device_get_available_preset_list.
+ * @param error  Pointer to an error object that will be set if an error occurs.
+ */
+OB_EXPORT void ob_device_load_preset(ob_device *device, const char *preset_name, ob_error **error);
+
+/**
+ * @brief Load preset from json string.
+ * @brief After loading the custom preset, the settings in the custom preset will set to the device immediately.
+ * @brief After loading the custom preset, the available preset list will be appended with the custom preset and named as the file name.
+ *
+ * @param device   The device object.
+ * @param json_file_path  The json file path.
+ * @param error   Pointer to an error object that will be set if an error occurs.
+ */
+OB_EXPORT void ob_device_load_preset_from_json_file(ob_device *device, const char *json_file_path, ob_error **error);
+
+/**
+ * @brief Load custom preset from data.
+ * @brief After loading the custom preset, the settings in the custom preset will set to the device immediately.
+ * @brief After loading the custom preset, the available preset list will be appended with the custom preset and named as the @ref presetName.
+ *
+ * @attention The user should ensure that the custom preset data is adapted to the device and the settings in the data are valid.
+ * @attention It is recommended to re-read the device settings to update the user program temporarily after successfully loading the custom preset.
+ *
+ * @param data The custom preset data.
+ * @param size The size of the custom preset data.
+ */
+OB_EXPORT void ob_device_load_preset_from_json_data(ob_device *device, const char *presetName, const uint8_t *data, uint32_t size, ob_error **error);
+
+/**
+ * @brief Export current settings as a preset json file.
+ * @brief After exporting the custom preset, the available preset list will be appended with the custom preset and named as the file name.
+ *
+ * @param device   The device object.
+ * @param json_file_path  The json file path.
+ * @param error   Pointer to an error object that will be set if an error occurs.
+ */
+OB_EXPORT void ob_device_export_current_settings_as_preset_json_file(ob_device *device, const char *json_file_path, ob_error **error);
+
+/**
+ * @brief Export current device settings as a preset json data.
+ * @brief After exporting the preset, a new preset named as the @ref presetName will be added to the available preset list.
+ *
+ * @attention The memory of the data is allocated by the SDK, and will automatically be released by the SDK.
+ * @attention The memory of the data will be reused by the SDK on the next call, so the user should copy the data to a new buffer if it needs to be
+ * preserved.
+ *
+ * @param[out] data return the preset json data.
+ * @param[out] dataSize return the size of the preset json data.
+ */
+OB_EXPORT void ob_device_export_current_settings_as_preset_json_data(ob_device *device, const char *presetName, const uint8_t **data, uint32_t *dataSize,
+                                                                     ob_error **error);
+
+/**
+ * @brief Get the available preset list.
+ *
+ * @param device The device object.
+ * @param error  Pointer to an error object that will be set if an error occurs.
+ * @return  The available preset list.
+ */
+OB_EXPORT ob_device_preset_list *ob_device_get_available_preset_list(const ob_device *device, ob_error **error);
+
+/**
+ * @brief Delete the available preset list.
+ *
+ * @param preset_list The available preset list.
+ * @param error  Pointer to an error object that will be set if an error occurs.
+ */
+OB_EXPORT void ob_delete_preset_list(ob_device_preset_list *preset_list, ob_error **error);
+
+/**
+ * @brief Get the number of preset in the preset list.
+ *
+ * @param preset_list The available preset list.
+ * @param error  Pointer to an error object that will be set if an error occurs.
+ * @return  The number of preset in the preset list.
+ */
+OB_EXPORT uint32_t ob_device_preset_list_get_count(const ob_device_preset_list *preset_list, ob_error **error);
+
+/**
+ * @brief Get the name of the preset in the preset list.
+ *
+ * @param preset_list The available preset list.
+ * @param index  The index of the preset in the preset list.
+ * @param error  Pointer to an error object that will be set if an error occurs.
+ * @return  The name of the preset in the preset list.
+ */
+OB_EXPORT const char *ob_device_preset_list_get_name(const ob_device_preset_list *preset_list, uint32_t index, ob_error **error);
+
+/**
+ * @brief Check if the preset list has the preset.
+ *
+ * @param preset_list The available preset list.
+ * @param preset_name  The name of the preset.
+ * @param error  Pointer to an error object that will be set if an error occurs.
+ * @return  Whether the preset list has the preset. If true, the preset list has the preset. If false, the preset list does not have the preset.
+ */
+OB_EXPORT bool ob_device_preset_list_has_preset(const ob_device_preset_list *preset_list, const char *preset_name, ob_error **error);
+
+// The following interfaces are deprecated and are retained here for compatibility purposes.
+#define ob_depth_work_mode_list_count ob_depth_work_mode_list_get_count
+#define ob_device_preset_list_count ob_device_preset_list_get_count
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/include/libobsensor/h/Context.h b/include/libobsensor/h/Context.h
new file mode 100644
index 00000000..3ca5a56b
--- /dev/null
+++ b/include/libobsensor/h/Context.h
@@ -0,0 +1,160 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+/**
+ * @file Context.h
+ * @brief Context is a management class that describes the runtime of the SDK and is responsible for resource allocation and release of the SDK.
+ * Context has the ability to manage multiple devices. It is responsible for enumerating devices, monitoring device callbacks, and enabling multi-device
+ * synchronization.
+ */
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "ObTypes.h"
+
+/**
+ * @brief Create a context object with the default configuration file
+ *
+ * @param[out] error Pointer to an error object that will be populated if an error occurs during context creation
+ * @return Pointer to the created context object
+ */
+OB_EXPORT ob_context *ob_create_context(ob_error **error);
+
+/**
+ * @brief Create a context object with a specified configuration file
+ *
+ * @param[in] config_file_path Path to the configuration file. If NULL, the default configuration file will be used.
+ * @param[out] error Pointer to an error object that will be populated if an error occurs during context creation
+ * @return Pointer to the created context object
+ */
+OB_EXPORT ob_context *ob_create_context_with_config(const char *config_file_path, ob_error **error);
+
+/**
+ * @brief Delete a context object
+ *
+ * @param[in] context Pointer to the context object to be deleted
+ * @param[out] error Pointer to an error object that will be populated if an error occurs during context deletion
+ */
+OB_EXPORT void ob_delete_context(ob_context *context, ob_error **error);
+
+/**
+ * @brief Get a list of enumerated devices
+ *
+ * @param[in] context Pointer to the context object
+ * @param[out] error Pointer to an error object that will be populated if an error occurs during device enumeration
+ * @return Pointer to the device list object
+ */
+OB_EXPORT ob_device_list *ob_query_device_list(ob_context *context, ob_error **error);
+
+/**
+ * @brief Enable or disable network device enumeration
+ * @brief After enabling, the network device will be automatically discovered and can be retrieved through @ref ob_query_device_list. The default state can be
+ * set in the configuration file.
+ *
+ * @attention Network device enumeration is performed through the GVCP protocol. If the device is not in the same subnet as the host, it will be discovered but
+ * cannot be connected.
+ *
+ * @param[in] context Pointer to the context object
+ * @param[in] enable true to enable, false to disable
+ * @param[out] error Pointer to an error object that will be populated if an error occurs.
+ */
+OB_EXPORT void ob_enable_net_device_enumeration(ob_context *context, bool enable, ob_error **error);
+
+/**
+ * @brief Create a network device object
+ *
+ * @param[in] context Pointer to the context object
+ * @param[in] address IP address of the device
+ * @param[in] port Port number of the device
+ * @param[out] error Pointer to an error object that will be populated if an error occurs during device creation
+ * @return Pointer to the created device object
+ */
+OB_EXPORT ob_device *ob_create_net_device(ob_context *context, const char *address, uint16_t port, ob_error **error);
+
+/**
+ * @brief Set a device plug-in callback function
+ * @attention The added and removed device lists returned through the callback interface need to be released manually
+ *
+ * @param[in] context Pointer to the context object
+ * @param[in] callback Pointer to the callback function triggered when a device is plugged or unplugged
+ * @param[in] user_data Pointer to user data that can be passed to and retrieved from the callback function
+ * @param[out] error Pointer to an error object that will be populated if an error occurs during callback function setting
+ */
+OB_EXPORT void ob_set_device_changed_callback(ob_context *context, ob_device_changed_callback callback, void *user_data, ob_error **error);
+
+/**
+ * @brief Activates device clock synchronization to synchronize the clock of the host and all created devices (if supported).
+ *
+ * @param[in] context Pointer to the context object
+ * @param[in] repeat_interval_msec The interval for auto-repeated synchronization, in milliseconds. If the value is 0, synchronization is performed only once.
+ * @param[out] error Pointer to an error object that will be populated if an error occurs during execution
+ */
+OB_EXPORT void ob_enable_device_clock_sync(ob_context *context, uint64_t repeat_interval_msec, ob_error **error);
+
+/**
+ * @brief Free idle memory from the internal frame memory pool
+ *
+ * @param[in] context Pointer to the context object
+ * @param[out] error Pointer to an error object that will be populated if an error occurs during memory freeing
+ */
+OB_EXPORT void ob_free_idle_memory(ob_context *context, ob_error **error);
+
+/**
+ * @brief Set the global log level
+ *
+ * @attention This interface setting will affect the output level of all logs (terminal, file, callback)
+ *
+ * @param[in] severity Log level to set
+ * @param[out] error Pointer to an error object that will be populated if an error occurs during log level setting
+ */
+OB_EXPORT void ob_set_logger_severity(ob_log_severity severity, ob_error **error);
+
+/**
+ * @brief Set the log output to a file
+ *
+ * @param[in] severity Log level to output to file
+ * @param[in] directory Path to the log file output directory. If the path is empty, the existing settings will continue to be used (if the existing
+ * configuration is also empty, the log will not be output to the file)
+ * @param[out] error Pointer to an error object that will be populated if an error occurs during log output setting
+ */
+OB_EXPORT void ob_set_logger_to_file(ob_log_severity severity, const char *directory, ob_error **error);
+
+/**
+ * @brief Set the log callback function
+ *
+ * @param[in] severity Log level to set for the callback function
+ * @param[in] callback Pointer to the callback function
+ * @param[in] user_data Pointer to user data that can be passed to and retrieved from the callback function
+ * @param[out] error Pointer to an error object that will be populated if an error occurs during log callback function setting
+ */
+OB_EXPORT void ob_set_logger_to_callback(ob_log_severity severity, ob_log_callback callback, void *user_data, ob_error **error);
+
+/**
+ * @brief Set the log output to the console
+ *
+ * @param[in] severity Log level to output to the console
+ * @param[out] error Pointer to an error object that will be populated if an error occurs during log output setting
+ */
+OB_EXPORT void ob_set_logger_to_console(ob_log_severity severity, ob_error **error);
+
+/**
+ * @brief Set the extensions directory
+ * @brief The extensions directory is used to search for dynamic libraries that provide additional functionality to the SDK， such as the Frame filters.
+ *
+ * @attention Should be called before creating the context and pipeline, otherwise the default extensions directory (./extensions) will be used.
+ *
+ * @param directory Path to the extensions directory. If the path is empty, the existing settings will continue to be used (if the existing
+ * @param error Pointer to an error object that will be populated if an error occurs during extensions directory setting
+ */
+OB_EXPORT void ob_set_extensions_directory(const char *directory, ob_error **error);
+
+// The following interfaces are deprecated and are retained here for compatibility purposes.
+#define ob_enable_multi_device_sync ob_enable_device_clock_sync
+#define ob_set_logger_callback ob_set_logger_to_callback
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/include/libobsensor/h/Device.h b/include/libobsensor/h/Device.h
new file mode 100644
index 00000000..da876346
--- /dev/null
+++ b/include/libobsensor/h/Device.h
@@ -0,0 +1,647 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+/**
+ * @file Device.h
+ * @brief Device-related functions, including operations such as obtaining and creating a device, setting and obtaining device property, and obtaining sensors
+ */
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "ObTypes.h"
+#include "Property.h"
+#include "MultipleDevices.h"
+#include "Advanced.h"
+
+/**
+ * @brief Delete a device.
+ *
+ * @param[in] device The device to be deleted.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ */
+OB_EXPORT void ob_delete_device(ob_device *device, ob_error **error);
+
+/**
+ * @brief List all sensors.
+ *
+ * @param[in] device The device object.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return ob_sensor_list* The list of all sensors.
+ */
+OB_EXPORT ob_sensor_list *ob_device_get_sensor_list(const ob_device *device, ob_error **error);
+
+/**
+ * @brief Get a device's sensor.
+ *
+ * @param[in] device The device object.
+ * @param[in] type The type of sensor to get.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return ob_sensor* The acquired sensor.
+ */
+OB_EXPORT ob_sensor *ob_device_get_sensor(ob_device *device, ob_sensor_type type, ob_error **error);
+
+/**
+ * @brief Set an integer type of device property.
+ *
+ * @param[in] device The device object.
+ * @param[in] property_id The ID of the property to be set.
+ * @param[in] value The property value to be set.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ */
+OB_EXPORT void ob_device_set_int_property(ob_device *device, ob_property_id property_id, int32_t value, ob_error **error);
+
+/**
+ * @brief Get an integer type of device property.
+ *
+ * @param[in] device The device object.
+ * @param[in] property_id The property ID.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return int32_t The property value.
+ */
+OB_EXPORT int32_t ob_device_get_int_property(ob_device *device, ob_property_id property_id, ob_error **error);
+
+/**
+ * @brief Get the integer type of device property range.
+ *
+ * @param[in] device The device object.
+ * @param[in] property_id The property id.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return The property range.
+ */
+OB_EXPORT ob_int_property_range ob_device_get_int_property_range(ob_device *device, ob_property_id property_id, ob_error **error);
+
+/**
+ * @brief Set a float type of device property.
+ *
+ * @param[in] device The device object.
+ * @param[in] property_id The ID of the property to be set.
+ * @param[in] value The property value to be set.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ */
+OB_EXPORT void ob_device_set_float_property(ob_device *device, ob_property_id property_id, float value, ob_error **error);
+
+/**
+ * @brief Get a float type of device property.
+ *
+ * @param[in] device The device object.
+ * @param[in] property_id The property ID.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return float The property value.
+ */
+OB_EXPORT float ob_device_get_float_property(ob_device *device, ob_property_id property_id, ob_error **error);
+
+/**
+ * @brief Get the float type of device property range.
+ *
+ * @param[in] device The device object.
+ * @param[in] property_id The property id.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return The property range.
+ */
+OB_EXPORT ob_float_property_range ob_device_get_float_property_range(ob_device *device, ob_property_id property_id, ob_error **error);
+
+/**
+ * @brief Set a boolean type of device property.
+ *
+ * @param[in] device The device object.
+ * @param[in] property_id The ID of the property to be set.
+ * @param[in] value The property value to be set.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ */
+OB_EXPORT void ob_device_set_bool_property(ob_device *device, ob_property_id property_id, bool value, ob_error **error);
+
+/**
+ * @brief Get a boolean type of device property.
+ *
+ * @param[in] device The device object.
+ * @param[in] property_id The property ID.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return bool The property value.
+ */
+OB_EXPORT bool ob_device_get_bool_property(ob_device *device, ob_property_id property_id, ob_error **error);
+
+/**
+ * @brief Get the boolean type of device property range.
+ *
+ * @param[in] device The device object.
+ * @param[in] property_id The property id.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return The property range.
+ */
+OB_EXPORT ob_bool_property_range ob_device_get_bool_property_range(ob_device *device, ob_property_id property_id, ob_error **error);
+
+/**
+ * @brief Set structured data.
+ *
+ * @param[in] device The device object.
+ * @param[in] property_id The ID of the property to be set.
+ * @param[in] data The property data to be set.
+ * @param[in] data_size The size of the property to be set.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ */
+OB_EXPORT void ob_device_set_structured_data(ob_device *device, ob_property_id property_id, const uint8_t *data, uint32_t data_size, ob_error **error);
+
+/**
+ * @brief Get structured data of a device property.
+ *
+ * @param[in] device The device object.
+ * @param[in] property_id The ID of the property.
+ * @param[out] data The obtained property data.
+ * @param[out] data_size The size of the obtained property data.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ */
+OB_EXPORT void ob_device_get_structured_data(ob_device *device, ob_property_id property_id, uint8_t *data, uint32_t *data_size, ob_error **error);
+
+/**
+ * @brief Get raw data of a device property.
+ *
+ * @param[in] device The device object.
+ * @param[in] property_id The ID of the property.
+ * @param[out] cb The get data callback.
+ * @param[out] user_data User-defined data that will be returned in the callback.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ */
+OB_EXPORT void ob_device_get_raw_data(ob_device *device, ob_property_id property_id, ob_get_data_callback cb, void *user_data, ob_error **error);
+
+/**
+ * @brief Get the number of properties supported by the device.
+ *
+ * @param[in] device The device object.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return The number of properties supported by the device.
+ */
+OB_EXPORT uint32_t ob_device_get_supported_property_count(const ob_device *device, ob_error **error);
+
+/**
+ * @brief Get the type of property supported by the device.
+ *
+ * @param[in] device The device object.
+ * @param[in] index The property index.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return The type of property supported by the device.
+ */
+OB_EXPORT ob_property_item ob_device_get_supported_property_item(const ob_device *device, uint32_t index, ob_error **error);
+
+/**
+ * @brief Check if a device property permission is supported.
+ *
+ * @param[in] device The device object.
+ * @param[in] property_id The property id.
+ * @param[in] permission The type of permission that needs to be interpreted.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return Whether the property permission is supported.
+ */
+OB_EXPORT bool ob_device_is_property_supported(const ob_device *device, ob_property_id property_id, ob_permission_type permission, ob_error **error);
+
+/**
+ * @brief Check if the device supports global timestamp.
+ *
+ * @param[in] device The device object.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return bool Whether the device supports global timestamp.
+ */
+OB_EXPORT bool ob_device_is_global_timestamp_supported(const ob_device *device, ob_error **error);
+
+/**
+ * @brief Enable or disable global timestamp.
+ *
+ * @param device The device object.
+ * @param enable Whether to enable global timestamp.
+ * @param error Pointer to an error object that will be set if an error occurs.
+ */
+OB_EXPORT void ob_device_enable_global_timestamp(ob_device *device, bool enable, ob_error **error);
+
+/**
+ * @brief Update the device firmware.
+ *
+ * @param[in] device The device object.
+ * @param[in] path The firmware path.
+ * @param[in] callback The firmware upgrade progress callback.
+ * @param[in] async Whether to execute asynchronously.
+ * @param[in] user_data User-defined data that will be returned in the callback.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ */
+OB_EXPORT void ob_device_update_firmware(ob_device *device, const char *path, ob_device_fw_update_callback callback, bool async, void *user_data,
+                                         ob_error **error);
+
+/**
+ * @brief Update the device firmware from data.
+ *
+ * @param[in] device The device object.
+ * @param[in] data The firmware file data.
+ * @param[in] data_size The firmware file size.
+ * @param[in] callback The firmware upgrade progress callback.
+ * @param[in] async Whether to execute asynchronously.
+ * @param[in] user_data User-defined data that will be returned in the callback.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ */
+OB_EXPORT void ob_device_update_firmware_from_data(ob_device *device, const uint8_t *data, uint32_t data_size, ob_device_fw_update_callback callback,
+                                                   bool async, void *user_data, ob_error **error);
+
+/**
+ * @brief Device reboot
+ * @attention The device will be disconnected and reconnected. After the device is disconnected, the interface access to the device handle may be abnormal.
+ * Please use the ob_delete_device interface to delete the handle directly. After the device is reconnected, it can be obtained again.
+ *
+ * @param[in] device Device object
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ */
+OB_EXPORT void ob_device_reboot(ob_device *device, ob_error **error);
+
+/**
+ * @brief Get the current device status.
+ *
+ * @param[in] device The device object.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ *
+ * @return ob_device_state The device state information.
+ */
+OB_EXPORT ob_device_state ob_device_get_device_state(const ob_device *device, ob_error **error);
+
+/**
+ * @brief Set the device state changed callback.
+ *
+ * @param[in] device The device object.
+ * @param[in] callback The callback function to be called when the device status changes.
+ * @param[in] user_data User-defined data that will be returned in the callback.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ */
+OB_EXPORT void ob_device_set_state_changed_callback(ob_device *device, ob_device_state_callback callback, void *user_data, ob_error **error);
+
+/**
+ * @brief Enable or disable the device heartbeat.
+ * @brief After enable the device heartbeat, the sdk will start a thread to send heartbeat signal to the device error every 3 seconds.
+
+ * @attention If the device does not receive the heartbeat signal for a long time, it will be disconnected and rebooted.
+ *
+ * @param[in] device The device object.
+ * @param[in] enable Whether to enable the device heartbeat.
+ * @param error Pointer to an error object that will be set if an error occurs.
+ */
+OB_EXPORT void ob_device_enable_heartbeat(ob_device *device, bool enable, ob_error **error);
+
+/**
+ * @brief Send data to the device and receive data from the device.
+ * @brief This is a factory and debug function, which can be used to send and receive data from the device. The data format is secret and belongs to the device
+ * vendor.
+ *
+ * @param[in] device The device object.
+ * @param[in] send_data The data to be sent to the device.
+ * @param[in] send_data_size The size of the data to be sent to the device.
+ * @param[out] receive_data The data received from the device.
+ * @param[in, out] receive_data_size Pass in the expected size of the receive data, and return the actual size of the received data.
+ * @param error Pointer to an error object that will be set if an error occurs.
+ * @return OB_EXPORT
+ */
+OB_EXPORT void ob_device_send_and_receive_data(ob_device *device, const uint8_t *send_data, uint32_t send_data_size, uint8_t *receive_data,
+                                               uint32_t *receive_data_size, ob_error **error);
+
+/**
+ * @brief Get device information.
+ *
+ * @param[in] device The device to obtain information from.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return ob_device_info* The device information.
+ */
+OB_EXPORT ob_device_info *ob_device_get_device_info(const ob_device *device, ob_error **error);
+
+/**
+ * @brief Delete device information.
+ *
+ * @param[in] info The device information to be deleted.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ */
+OB_EXPORT void ob_delete_device_info(ob_device_info *info, ob_error **error);
+
+/**
+ * @brief Get device name
+ *
+ * @param[in] info Device Information
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return const char* return the device name
+ */
+OB_EXPORT const char *ob_device_info_get_name(const ob_device_info *info, ob_error **error);
+
+/**
+* @brief Get device pid
+
+ * @param[in] info Device Information
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return int return the device pid
+*/
+OB_EXPORT int ob_device_info_get_pid(const ob_device_info *info, ob_error **error);
+
+/**
+ * @brief Get device vid
+ *
+ * @param[in] info Device Information
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return int return device vid
+ */
+OB_EXPORT int ob_device_info_get_vid(const ob_device_info *info, ob_error **error);
+
+/**
+ * @brief Get device uid
+ *
+ * @param[in] info Device Information
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return const char* return device uid
+ */
+OB_EXPORT const char *ob_device_info_get_uid(const ob_device_info *info, ob_error **error);
+
+/**
+ * @brief Get device serial number
+ *
+ * @param[in] info Device Information
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return const char* return device serial number
+ */
+OB_EXPORT const char *ob_device_info_get_serial_number(const ob_device_info *info, ob_error **error);
+
+/**
+ * @brief Get the firmware version number
+ *
+ * @param[in] info Device Information
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return int return the firmware version number
+ */
+OB_EXPORT const char *ob_device_info_get_firmware_version(const ob_device_info *info, ob_error **error);
+
+/**
+ * @brief Get the device connection type
+ *
+ * @param[in] info Device Information
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return const char* The connection type，currently supports："USB", "USB1.0", "USB1.1", "USB2.0", "USB2.1", "USB3.0", "USB3.1", "USB3.2", "Ethernet"
+ */
+OB_EXPORT const char *ob_device_info_get_connection_type(const ob_device_info *info, ob_error **error);
+
+/**
+ * @brief Get the device IP address
+ *
+ * @attention Only valid for network devices, otherwise it will return "0.0.0.0"
+ *
+ * @param info Device Information
+ * @param error Pointer to an error object that will be set if an error occurs.
+ * @return const char* The IP address，such as "192.168.1.10"
+ */
+OB_EXPORT const char *ob_device_info_get_ip_address(const ob_device_info *info, ob_error **error);
+
+/**
+ * @brief Get the hardware version number
+ *
+ * @param[in] info Device Information
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return const char* The hardware version number
+ */
+OB_EXPORT const char *ob_device_info_get_hardware_version(const ob_device_info *info, ob_error **error);
+
+/**
+ * @brief Check if the device extension information exists.
+ *
+ * @param device The device object.
+ * @param info_key The key of the device extension information.
+ * @param error Pointer to an error object that will be set if an error occurs.
+ * @return bool Whether the device extension information exists.
+ */
+OB_EXPORT bool ob_device_is_extension_info_exist(const ob_device *device, const char *info_key, ob_error **error);
+
+/**
+ * @brief Get the device extension information.
+ * @brief Extension information is a set of key-value pair of string, user cat get the information by the key.
+ *
+ * @param[in] device The device object.
+ * @param[in] info_key The key of the device extension information.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return const char* The device extension information
+ */
+OB_EXPORT const char *ob_device_get_extension_info(const ob_device *device, const char *info_key, ob_error **error);
+
+/**
+ * @brief Get the minimum SDK version number supported by the device
+ *
+ * @param[in] info Device Information
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return const char* The minimum SDK version number supported by the device
+ */
+OB_EXPORT const char *ob_device_info_get_supported_min_sdk_version(const ob_device_info *info, ob_error **error);
+
+/**
+ * @brief Get the chip name
+ *
+ * @param[in] info Device Information
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return const char* The ASIC name
+ */
+OB_EXPORT const char *ob_device_info_get_asicName(const ob_device_info *info, ob_error **error);
+
+/**
+ * @brief Get the device type
+ *
+ * @param[in] info Device Information
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return ob_device_type The device type
+ */
+OB_EXPORT ob_device_type ob_device_info_get_device_type(const ob_device_info *info, ob_error **error);
+
+/**
+ * @brief Delete a device list.
+ *
+ * @param[in] list The device list object to be deleted.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ */
+OB_EXPORT void ob_delete_device_list(ob_device_list *list, ob_error **error);
+
+/**
+ * @brief Get the number of devices
+ *
+ * @param[in] list Device list object
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return uint32_t return the number of devices
+ */
+OB_EXPORT uint32_t ob_device_list_get_count(const ob_device_list *list, ob_error **error);
+
+/**
+ * @brief Get device name
+ *
+ * @param[in] list Device list object
+ * @param[in] index Device index
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return const char* return device name
+ */
+OB_EXPORT const char *ob_device_list_get_device_name(const ob_device_list *list, uint32_t index, ob_error **error);
+
+/**
+ * @brief Get the pid of the specified device
+ *
+ * @param[in] list Device list object
+ * @param[in] index Device index
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return int return the device pid
+ */
+OB_EXPORT int ob_device_list_get_device_pid(const ob_device_list *list, uint32_t index, ob_error **error);
+
+/**
+ * @brief Get the vid of the specified device
+ *
+ * @param[in] list Device list object
+ * @param[in] index Device index
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return int return device vid
+ */
+OB_EXPORT int ob_device_list_get_device_vid(const ob_device_list *list, uint32_t index, ob_error **error);
+
+/**
+ * @brief Get the uid of the specified device
+ *
+ * @param[in] list Device list object
+ * @param[in] index Device index
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return const char* return the device uid
+ */
+OB_EXPORT const char *ob_device_list_get_device_uid(const ob_device_list *list, uint32_t index, ob_error **error);
+
+/**
+ * @brief Get the serial number of the specified device.
+ *
+ * @param[in] list Device list object.
+ * @param[in] index Device index.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return const char* The device UID.
+ */
+OB_EXPORT const char *ob_device_list_get_device_serial_number(const ob_device_list *list, uint32_t index, ob_error **error);
+
+/**
+ * @brief Get device connection type
+ *
+ * @param[in] list Device list object
+ * @param[in] index Device index
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return const char* returns the device connection type，currently supports："USB", "USB1.0", "USB1.1", "USB2.0", "USB2.1", "USB3.0", "USB3.1", "USB3.2",
+ * "Ethernet"
+ */
+OB_EXPORT const char *ob_device_list_get_device_connection_type(const ob_device_list *list, uint32_t index, ob_error **error);
+
+/**
+ * @brief Get device ip address
+ *
+ * @attention Only valid for network devices, otherwise it will return "0.0.0.0".
+ *
+ * @param list Device list object
+ * @param index Device index
+ * @param error Pointer to an error object that will be set if an error occurs.
+ * @return const char* returns the device ip address，such as "192.168.1.10"
+ */
+OB_EXPORT const char *ob_device_list_get_device_ip_address(const ob_device_list *list, uint32_t index, ob_error **error);
+
+/**
+ * @brief Create a device.
+ *
+ * @attention If the device has already been acquired and created elsewhere, repeated acquisitions will return an error.
+ *
+ * @param[in] list Device list object.
+ * @param[in] index The index of the device to create.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return ob_device* The created device.
+ *
+ */
+OB_EXPORT ob_device *ob_device_list_get_device(const ob_device_list *list, uint32_t index, ob_error **error);
+
+/**
+ * @brief Create a device.
+ *
+ * @attention If the device has already been acquired and created elsewhere, repeated acquisitions will return an error.
+ *
+ * @param[in] list Device list object.
+ * @param[in] serial_number The serial number of the device to create.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return ob_device* The created device.
+ */
+OB_EXPORT ob_device *ob_device_list_get_device_by_serial_number(const ob_device_list *list, const char *serial_number, ob_error **error);
+
+/**
+ * @brief Create device by uid
+ * @brief On Linux platform, for usb device, the uid of the device is composed of bus-port-dev, for example 1-1.2-1. But the SDK will remove the dev number and
+ * only keep the bus-port as the uid to create the device, for example 1-1.2, so that we can create a device connected to the specified USB port. Similarly,
+ * users can also directly pass in bus-port as uid to create device.
+ * @brief For GMSL device，the uid is GMSL port with “gmsl2-” prefix, for example gmsl2-1.
+ *
+ * @attention If the device has already been acquired and created elsewhere, repeated acquisitions will return an error.
+ *
+ * @param[in] list Device list object.
+ * @param[in] uid The UID of the device to create.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return ob_device* The created device.
+ */
+OB_EXPORT ob_device *ob_device_list_get_device_by_uid(const ob_device_list *list, const char *uid, ob_error **error);
+
+/**
+ * @brief Get the original parameter list of camera calibration saved on the device.
+ *
+ * @attention The parameters in the list do not correspond to the current open-stream configuration.You need to select the parameters according to the actual
+ * situation, and may need to do scaling, mirroring and other processing. Non-professional users are recommended to use the ob_pipeline_get_camera_param()
+ * interface.
+ *
+ * @param[in] device The device object.
+ * @param[out] error Log error messages.
+ *
+ * @return ob_camera_param_list The camera parameter list.
+ */
+OB_EXPORT ob_camera_param_list *ob_device_get_calibration_camera_param_list(ob_device *device, ob_error **error);
+
+/**
+ * @brief Get the number of camera parameter lists
+ *
+ * @param[in] param_list Camera parameter list
+ * @param[out] error Log error messages
+ * @return uint32_t The number of lists
+ */
+OB_EXPORT uint32_t ob_camera_param_list_get_count(ob_camera_param_list *param_list, ob_error **error);
+
+/**
+ * @brief Get camera parameters from the camera parameter list
+ *
+ * @param[in] param_list Camera parameter list
+ * @param[in] index Parameter index
+ * @param[out] error Log error messages
+ * @return ob_camera_param The camera parameters. Since it returns the structure object directly, there is no need to provide a delete interface.
+ */
+OB_EXPORT ob_camera_param ob_camera_param_list_get_param(ob_camera_param_list *param_list, uint32_t index, ob_error **error);
+
+/**
+ * @brief Delete the camera parameter list
+ *
+ * @param[in] param_list Camera parameter list
+ * @param[out] error Log error messages
+ */
+OB_EXPORT void ob_delete_camera_param_list(ob_camera_param_list *param_list, ob_error **error);
+
+// The following interfaces are deprecated and are retained here for compatibility purposes.
+#define ob_device_list_device_count ob_device_list_get_count
+#define ob_device_list_get_extension_info ob_device_info_get_extension_info
+#define ob_device_upgrade ob_device_update_firmware
+#define ob_device_upgrade_from_data ob_device_update_firmware_from_data
+#define ob_device_get_supported_property ob_device_get_supported_property_item
+#define ob_device_state_changed ob_device_set_state_changed_callback
+#define ob_device_info_name ob_device_info_get_name
+#define ob_device_info_pid ob_device_info_get_pid
+#define ob_device_info_vid ob_device_info_get_vid
+#define ob_device_info_uid ob_device_info_get_uid
+#define ob_device_info_serial_number ob_device_info_get_serial_number
+#define ob_device_info_firmware_version ob_device_info_get_firmware_version
+#define ob_device_info_connection_type ob_device_info_get_connection_type
+#define ob_device_info_ip_address ob_device_info_get_ip_address
+#define ob_device_info_hardware_version ob_device_info_get_hardware_version
+#define ob_device_info_supported_min_sdk_version ob_device_info_get_supported_min_sdk_version
+#define ob_device_info_asicName ob_device_info_get_asicName
+#define ob_device_info_device_type ob_device_info_get_device_type
+#define ob_device_list_get_device_count ob_device_list_get_count
+#define ob_camera_param_list_count ob_camera_param_list_get_count
+
+#ifdef __cplusplus
+}
+#endif
+
diff --git a/include/libobsensor/h/Error.h b/include/libobsensor/h/Error.h
new file mode 100644
index 00000000..06ed8cdd
--- /dev/null
+++ b/include/libobsensor/h/Error.h
@@ -0,0 +1,84 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+/**
+ * @file Error.h
+ * @brief Functions for handling errors, mainly used for obtaining error messages.
+ */
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "ObTypes.h"
+
+/**
+ * @brief Create a new error object.
+ *
+ * @param status The error status.
+ * @param message The error message.
+ * @param function The name of the API function that caused the error.
+ * @param args The error parameters.
+ * @param exception_type The type of exception that caused the error.
+ * @return ob_error* The new error object.
+ */
+OB_EXPORT ob_error *ob_create_error(ob_status status, const char *message, const char *function, const char *args, ob_exception_type exception_type);
+
+/**
+ * @brief Get the error status.
+ *
+ * @param[in] error The error object.
+ * @return The error status.
+ */
+OB_EXPORT ob_status ob_error_get_status(const ob_error *error);
+
+/**
+ * @brief Get the error message.
+ *
+ * @param[in] error The error object.
+ * @return The error message.
+ */
+OB_EXPORT const char *ob_error_get_message(const ob_error *error);
+
+/**
+ * @brief Get the name of the API function that caused the error.
+ *
+ * @param[in] error The error object.
+ * @return The name of the API function.
+ */
+OB_EXPORT const char *ob_error_get_function(const ob_error *error);
+
+/**
+ * @brief Get the error parameters.
+ *
+ * @param[in] error The error object.
+ * @return The error parameters.
+ */
+OB_EXPORT const char *ob_error_get_args(const ob_error *error);
+
+/**
+ * @brief Get the type of exception that caused the error.
+ *
+ * @param[in] error The error object.
+ * @return The type of exception.
+ */
+OB_EXPORT ob_exception_type ob_error_get_exception_type(const ob_error *error);
+
+/**
+ * @brief Delete the error object.
+ *
+ * @param[in] error The error object to delete.
+ */
+OB_EXPORT void ob_delete_error(ob_error *error);
+
+// The following interfaces are deprecated and are retained here for compatibility purposes.
+#define ob_error_status ob_error_get_status
+#define ob_error_message ob_error_get_message
+#define ob_error_function ob_error_get_function
+#define ob_error_args ob_error_get_args
+#define ob_error_exception_type ob_error_get_exception_type
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/include/libobsensor/h/Filter.h b/include/libobsensor/h/Filter.h
new file mode 100644
index 00000000..475745a1
--- /dev/null
+++ b/include/libobsensor/h/Filter.h
@@ -0,0 +1,255 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+/**
+ * @file Filter.h
+ * @brief The processing unit of the SDK can perform point cloud generation, format conversion and other functions.
+ */
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "ObTypes.h"
+
+/**
+ * @brief Create a Filter object.
+ *
+ * @attention If the filter of the specified name is a private filter, and the creator of the filter have not been activated, the function will return NULL.
+ *
+ * @param name The name of the filter.
+ * @param error Pointer to an error object that will be set if an error occurs.
+ */
+OB_EXPORT ob_filter *ob_create_filter(const char *name, ob_error **error);
+
+/**
+ * @brief Get the name of ob_filter
+ *
+ * @param filter ob_filter object
+ * @param error Pointer to an error object that will be set if an error occurs.
+ * @return char The filter of name
+ */
+OB_EXPORT const char *ob_filter_get_name(const ob_filter *filter, ob_error **error);
+
+/**
+ * @brief Get the vendor specific code of a filter by filter name.
+ * @brief A private filter can define its own vendor specific code for specific purposes.
+ *
+ * @param name The name of the filter.
+ * @param error Pointer to an error object that will be set if an error occurs.
+ * @return const char* Return the vendor specific code of the filter.
+ */
+OB_EXPORT const char *ob_filter_get_vendor_specific_code(const char *name, ob_error **error);
+
+/**
+ * @brief Create a private Filter object with activation key.
+ * @brief Some private filters require an activation key to be activated, its depends on the vendor of the filter.
+ *
+ * @param name The name of the filter.
+ * @param activation_key The activation key of the filter.
+ * @param error Pointer to an error object that will be set if an error occurs.
+ *
+ * @return ob_filter* Return the private filter object.
+ */
+OB_EXPORT ob_filter *ob_create_private_filter(const char *name, const char *activation_key, ob_error **error);
+
+/**
+ * @brief Delete the filter.
+ *
+ * @param[in] filter The filter object to be deleted.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ */
+OB_EXPORT void ob_delete_filter(ob_filter *filter, ob_error **error);
+
+/**
+ * @brief Get config schema of the filter
+ * @brief The returned string is a csv format string representing the configuration schema of the filter. The format of the string is:
+ *  <parameter_name>, <parameter_type: "int", "float", "bool">, <minimum_value>, <maximum_value>, <value_step>, <default_value>, <parameter_description>
+ *
+ * @param[in] filter The filter object to get the configuration schema for
+ * @param[out] error Pointer to an error object that will be set if an error occurs
+ *
+ * @return A csv format string representing the configuration schema of the filter
+ */
+OB_EXPORT const char *ob_filter_get_config_schema(const ob_filter *filter, ob_error **error);
+
+/**
+ * @brief Get the filter config schema list of the filter
+ * @brief The returned string is a list of ob_config_schema_item representing the configuration schema of the filter.
+ *
+ * @attention The returned list should be deleted by calling @ref ob_delete_filter_config_schema_list when it is no longer needed.
+ *
+ * @param filter The filter object to get the configuration schema for
+ * @param error Pointer to an error object that will be set if an error occurs
+ * @return ob_filter_config_schema_list* Return the filter config schema list of the filter
+ */
+OB_EXPORT ob_filter_config_schema_list *ob_filter_get_config_schema_list(const ob_filter *filter, ob_error **error);
+
+/**
+ * @brief Delete a list of filter config schema items.
+ *
+ * @param config_schema_list The list of filter config schema items to delete.
+ * @param error Pointer to an error object that will be set if an error occurs.
+ */
+OB_EXPORT void ob_delete_filter_config_schema_list(ob_filter_config_schema_list *config_schema_list, ob_error **error);
+
+/**
+ * @brief Update config of the filter
+ *
+ * @attention The passed in argc and argv must match the configuration schema returned by the @ref ob_filter_get_config_schema function.
+ *
+ * @param[in] filter The filter object to update the configuration for
+ * @param[in] argc The number of arguments in the argv array
+ * @param[in] argv An array of strings representing the configuration values
+ * @param[out] error Pointer to an error object that will be set if an error occurs
+ */
+OB_EXPORT void ob_filter_update_config(ob_filter *filter, uint8_t argc, const char **argv, ob_error **error);
+
+/**
+ * @brief Get the filter config value by name and cast to double.
+ *
+ * @attention The returned value is cast to double, the actual type of the value depends on the filter config schema returned by @ref
+ * ob_filter_get_config_schema.
+ *
+ * @param[in] filter A filter object.
+ * @param[in] config_name config name
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return double The value of the config.
+ */
+OB_EXPORT double ob_filter_get_config_value(const ob_filter *filter, const char *config_name, ob_error **error);
+
+/**
+ * @brief Set the filter config value by name.
+ *
+ * @attention The pass into value type is double, witch will be cast to the actual type inside the filter. The actual type can be queried by the filter config
+ * schema returned by @ref ob_filter_get_config_schema.
+ *
+ * @param[in] filter A filter object.
+ * @param[in] config_name config name
+ * @param[in] value The value to set.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ */
+OB_EXPORT void ob_filter_set_config_value(ob_filter *filter, const char *config_name, double value, ob_error **error);
+
+/**
+ * @brief Reset the filter, clears the cache, and resets the state. If the asynchronous interface is used, the processing thread will also be stopped and the
+ * pending cache frames will be cleared.
+ *
+ * @param[in] filter A filter object.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ */
+OB_EXPORT void ob_filter_reset(ob_filter *filter, ob_error **error);
+
+/**
+ * @brief Enable the frame post processing
+ * @brief The filter default is enable.
+ *
+ * @attention If the filter has been disabled by calling this function, processing will directly output a clone of the input frame.
+ *
+ * @param[in] filter A filter object.
+ * @param[in] enable enable status, true: enable; false: disable.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ */
+OB_EXPORT void ob_filter_enable(ob_filter *filter, bool enable, ob_error **error);
+
+/**
+ * @brief Get the enable status of the frame post processing
+ *
+ * @attention If the filter is disabled, the processing will directly output a clone of the input frame.
+ *
+ * @param[in] filter A filter object.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ *
+ * @return The post processing filter status. True: enable; False: disable.
+ */
+OB_EXPORT bool ob_filter_is_enabled(const ob_filter *filter, ob_error **error);
+
+/**
+ * @brief Process the frame (synchronous interface).
+ *
+ * @param[in] filter A filter object.
+ * @param[in] frame Pointer to the frame object to be processed.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ *
+ * @return The frame object processed by the filter.
+ */
+OB_EXPORT ob_frame *ob_filter_process(ob_filter *filter, const ob_frame *frame, ob_error **error);
+
+/**
+ * @brief Set the processing result callback function for the filter (asynchronous callback interface).
+ *
+ * @param[in] filter A filter object.
+ * @param[in] callback Callback function.
+ * @param[in] user_data Arbitrary user data pointer can be passed in and returned from the callback.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ */
+OB_EXPORT void ob_filter_set_callback(ob_filter *filter, ob_filter_callback callback, void *user_data, ob_error **error);
+
+/**
+ * @brief Push the frame into the pending cache for the filter (asynchronous callback interface).
+ * @brief The frame will be processed by the filter when the processing thread is available and return a new processed frame to the callback function.
+ *
+ * @attention The frame object will be add reference count, so the user still need call @ref ob_delete_frame to release the frame after calling this function.
+ *
+ * @param[in] filter A filter object.
+ * @param[in] frame Pointer to the frame object to be processed.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ */
+OB_EXPORT void ob_filter_push_frame(ob_filter *filter, const ob_frame *frame, ob_error **error);
+
+/**
+ * @brief Get the number of filter in the list
+ *
+ * @param[in] filter_list  filter list
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return uint32_t The number of list
+ */
+OB_EXPORT uint32_t ob_filter_list_get_count(const ob_filter_list *filter_list, ob_error **error);
+
+/**
+ * @brief Get the filter by index
+ *
+ * @param[in] filter_list Filter list
+ * @param[in] index  Filter index
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return ob_filter The index of ob_filter
+ */
+OB_EXPORT ob_filter *ob_filter_list_get_filter(const ob_filter_list *filter_list, uint32_t index, ob_error **error);
+
+/**
+ * @brief Delete a list of ob_filter objects.
+ *
+ * @param[in] filter_list The list of ob_filter objects to delete.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ */
+OB_EXPORT void ob_delete_filter_list(ob_filter_list *filter_list, ob_error **error);
+
+/**
+ * @brief Get the number of config schema items in the config schema list
+ *
+ * @param config_schema_list Filter config schema list
+ * @param error Pointer to an error object that will be set if an error occurs.
+ * @return uint32_t The number of config schema items in the filter list
+ */
+OB_EXPORT uint32_t ob_filter_config_schema_list_get_count(const ob_filter_config_schema_list *config_schema_list, ob_error **error);
+
+/**
+ * @brief Get the config schema item by index
+ *
+ * @param config_schema_list Filter config schema list
+ * @param index  Config schema item index
+ * @param error Pointer to an error object that will be set if an error occurs.
+ * @return ob_filter_config_schema_item* The config schema item by index
+ */
+OB_EXPORT ob_filter_config_schema_item ob_filter_config_schema_list_get_item(const ob_filter_config_schema_list *config_schema_list, uint32_t index,
+                                                                             ob_error **error);
+
+// The following interfaces are deprecated and are retained here for compatibility purposes.
+#define ob_get_filter ob_filter_list_get_filter
+#define ob_get_filter_name ob_filter_get_name
+
+#ifdef __cplusplus
+}
+#endif
+
diff --git a/include/libobsensor/h/Frame.h b/include/libobsensor/h/Frame.h
new file mode 100644
index 00000000..04f19b70
--- /dev/null
+++ b/include/libobsensor/h/Frame.h
@@ -0,0 +1,640 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+/**
+ * @file Frame.h
+ * @brief Frame related function is mainly used to obtain frame data and frame information
+ *
+ */
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "ObTypes.h"
+
+/**
+ * @brief Crate a frame object based on the specified parameters.
+ *
+ * @attention The frame object is created with a reference count of 1, and the reference count should be decreased by calling @ref ob_delete_frame() when it is
+ * no longer needed.
+ *
+ * @param frame_type The frame object type.
+ * @param format The frame object format.
+ * @param data_size The size of the frame object data.
+ * @param error Pointer to an error object that will be set if an error occurs.
+ * @return ob_frame* Return the frame object.
+ */
+OB_EXPORT ob_frame *ob_create_frame(ob_frame_type frame_type, ob_format format, uint32_t data_size, ob_error **error);
+
+/**
+ * @brief Create (clone) a frame object based on the specified other frame object.
+ * @brief The new frame object will have the same properties as the other frame object, but the data buffer is newly allocated.
+ *
+ * @attention The frame object is created with a reference count of 1, and the reference count should be decreased by calling @ref ob_delete_frame() when it is
+ * no longer needed.
+ *
+ * @param[in] other_frame The frame object to create the new frame object according to.
+ * @param[in] should_copy_data If true, the data of the source frame object will be copied to the new frame object. If false, the new frame object will
+ * have a data buffer with random data.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return ob_frame* Return the new frame object.
+ */
+OB_EXPORT ob_frame *ob_create_frame_from_other_frame(const ob_frame *other_frame, bool should_copy_data, ob_error **error);
+
+/**
+ * @brief Create a frame object according to the specified stream profile.
+ *
+ * @attention The frame object is created with a reference count of 1, and the reference count should be decreased by calling @ref ob_delete_frame() when it is
+ * no logger needed.
+ *
+ * @param stream_profile The stream profile to create the new frame object according to.
+ * @param error Pointer to an error object that will be set if an error occurs.
+ * @return ob_frame* Return the new frame object.
+ */
+OB_EXPORT ob_frame *ob_create_frame_from_stream_profile(const ob_stream_profile *stream_profile, ob_error **error);
+
+/**
+ * @brief Create an video frame object based on the specified parameters.
+ *
+ * @attention The frame object is created with a reference count of 1, and the reference count should be decreased by calling @ref ob_delete_frame() when it is
+ * no longer needed.
+ *
+ * @param[in] frame_type Frame object type.
+ * @param[in] frame_format Frame object format.
+ * @param[in] width Frame object width.
+ * @param[in] height Frame object height.
+ * @param[in] stride_bytes Row span in bytes. If 0, the stride is calculated based on the width and format.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return ob_frame* Return an empty frame object.
+ */
+OB_EXPORT ob_frame *ob_create_video_frame(ob_frame_type frame_type, ob_format format, uint32_t width, uint32_t height, uint32_t stride_bytes, ob_error **error);
+
+/**
+ * @brief Create a frame object based on an externally created buffer.
+ *
+ * @attention The buffer is owned by the user and will not be destroyed by the frame object. The user should ensure that the buffer is valid and not modified.
+ * @attention The frame object is created with a reference count of 1, and the reference count should be decreased by calling @ref ob_delete_frame() when it is
+ * no longer needed.
+ *
+ * @param[in] frame_type Frame object type.
+ * @param[in] format Frame object format.
+ * @param[in] buffer Frame object buffer.
+ * @param[in] buffer_size Frame object buffer size.
+ * @param[in] buffer_destroy_cb Destroy callback, will be called when the frame object is destroyed.
+ * @param[in] buffer_destroy_context Destroy context, user-defined context to be passed to the destroy callback.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return ob_frame* Return the frame object.
+ */
+OB_EXPORT ob_frame *ob_create_frame_from_buffer(ob_frame_type frame_type, ob_format format, uint8_t *buffer, uint32_t buffer_size,
+                                                ob_frame_destroy_callback *buffer_destroy_cb, void *buffer_destroy_context, ob_error **error);
+
+/**
+ * @brief Create a video frame object based on an externally created buffer.
+ *
+ * @attention The buffer is owned by the user and will not be destroyed by the frame object. The user should ensure that the buffer is valid and not modified.
+ * @attention The frame object is created with a reference count of 1, and the reference count should be decreased by calling @ref ob_delete_frame() when it is
+ * no longer needed.
+ *
+ * @param[in] frame_type Frame object type.
+ * @param[in] format Frame object format.
+ * @param[in] width Frame object width.
+ * @param[in] height Frame object height.
+ * @param[in] stride_bytes Row span in bytes. If 0, the stride is calculated based on the width and format.
+ * @param[in] buffer Frame object buffer.
+ * @param[in] buffer_size Frame object buffer size.
+ * @param[in] buffer_destroy_cb Destroy callback, user-defined function to destroy the buffer.
+ * @param[in] buffer_destroy_context Destroy context, user-defined context to be passed to the destroy callback.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return ob_frame* Return the frame object.
+ */
+OB_EXPORT ob_frame *ob_create_video_frame_from_buffer(ob_frame_type frame_type, ob_format format, uint32_t width, uint32_t height, uint32_t stride_bytes,
+                                                      uint8_t *buffer, uint32_t buffer_size, ob_frame_destroy_callback *buffer_destroy_cb,
+                                                      void *buffer_destroy_context, ob_error **error);
+
+/**
+ * @brief Create an empty frameset object.
+ * @brief A frameset object is a special type of frame object that can be used to store multiple frames.
+ *
+ * @attention The frameset object is created with a reference count of 1, and the reference count should be decreased by calling @ref ob_delete_frame() when it
+ * is no longer needed.
+ *
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return ob_frame* Return the frameset object.
+ */
+OB_EXPORT ob_frame *ob_create_frameset(ob_error **error);
+
+/**
+ * @brief Increase the reference count of a frame object.
+ * @brief The reference count is used to manage the lifetime of the frame object.
+ *
+ * @attention When calling this function, the reference count of the frame object is
+ * increased and requires to be decreased by calling @ref ob_delete_frame().
+ *
+ * @param[in] frame Frame object to increase the reference count.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ */
+OB_EXPORT void ob_frame_add_ref(const ob_frame *frame, ob_error **error);
+
+/**
+ * @brief Delete a frame object
+ * @brief This function will decrease the reference count of the frame object and release the memory if the reference count becomes 0.
+ *
+ * @param[in] frame The frame object to delete.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ */
+OB_EXPORT void ob_delete_frame(const ob_frame *frame, ob_error **error);
+
+/**
+ * @brief Copy the information of the source frame object to the destination frame object.
+ * @brief Including the index，timestamp，system timestamp，global timestamp and metadata will be copied.
+ *
+ * @param[in] src_frame Source frame object to copy the information from.
+ * @param[in] dst_frame Destination frame object to copy the information to.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ */
+OB_EXPORT void ob_frame_copy_info(const ob_frame *src_frame, ob_frame *dst_frame, ob_error **error);
+
+/**
+ * @brief Get the frame index
+ *
+ * @param[in] frame Frame object
+ * @param[out] error Log wrong message
+ * @return uint64_t return the frame index
+ */
+OB_EXPORT uint64_t ob_frame_get_index(const ob_frame *frame, ob_error **error);
+
+/**
+ * @brief Get the frame format
+ *
+ * @param[in] frame Frame object
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return ob_format return the frame format
+ */
+OB_EXPORT ob_format ob_frame_get_format(const ob_frame *frame, ob_error **error);
+
+/**
+ * @brief Get the frame type
+ *
+ * @param[in] frame Frame object
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return ob_frame_type return the frame type
+ */
+OB_EXPORT ob_frame_type ob_frame_get_type(const ob_frame *frame, ob_error **error);
+
+/**
+ * @brief Get the frame timestamp (also known as device timestamp, hardware timestamp) of the frame in microseconds.
+ * @brief The hardware timestamp is the time point when the frame was captured by the device (Typically in the mid-exposure, unless otherwise stated), on device
+ * clock domain.
+ *
+ * @param[in] frame Frame object
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return uint64_t return the frame hardware timestamp in microseconds
+ */
+OB_EXPORT uint64_t ob_frame_get_timestamp_us(const ob_frame *frame, ob_error **error);
+
+/**
+ * @brief Set the frame timestamp (also known as the device timestamp, hardware timestamp) of a frame object.
+ *
+ * @param[in] frame Frame object to set the timestamp.
+ * @param[in] timestamp_us frame timestamp to set in microseconds.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ */
+OB_EXPORT void ob_frame_set_timestamp_us(ob_frame *frame, uint64_t timestamp_us, ob_error **error);
+
+/**
+ * @brief Get the system timestamp of the frame in microseconds.
+ * @brief The system timestamp is the time point when the frame was received by the host, on host clock domain.
+ *
+ * @param[in] frame Frame object
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return uint64_t return the frame system timestamp in microseconds
+ */
+OB_EXPORT uint64_t ob_frame_get_system_timestamp_us(const ob_frame *frame, ob_error **error);
+
+/**
+ * @brief Set the system timestamp of the frame in microseconds.
+ *
+ * @param frame Frame object
+ * @param system_timestamp_us frame system timestamp to set in microseconds.
+ * @param error Pointer to an error object that will be set if an error occurs.
+ */
+OB_EXPORT void ob_frame_set_system_timestamp_us(ob_frame *frame, uint64_t system_timestamp_us, ob_error **error);
+
+/**
+ * @brief Get the global timestamp of the frame in microseconds.
+ * @brief The global timestamp is the time point when the frame was was captured by the device, and has been converted to the host clock domain. The
+ * conversion process base on the frame timestamp and can eliminate the timer drift of the device
+ *
+ * @attention The global timestamp is disabled by default. If global timestamp is not enabled, the function will return 0. To enable it, call @ref
+ * ob_device_enable_global_timestamp() function.
+ * @attention Only some models of device support getting the global timestamp.  Check the device support status by @ref
+ * ob_device_is_global_timestamp_supported() function.
+ *
+ * @param[in] frame Frame object
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return uint64_t The global timestamp of the frame in microseconds.
+ */
+OB_EXPORT uint64_t ob_frame_get_global_timestamp_us(const ob_frame *frame, ob_error **error);
+
+/**
+ * @brief Get the data buffer of a frame.
+ *
+ * @attention The returned data buffer is mutable, but it is not recommended to modify it directly. Modifying the data directly may cause issues if the frame is
+ * being used in other threads  or future use. If you need to modify the data, it is recommended to create a new frame object.
+ *
+ * @param[in] frame The frame object from which to retrieve the data.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return uint8_t* Pointer to the frame data buffer.
+ */
+OB_EXPORT uint8_t *ob_frame_get_data(const ob_frame *frame, ob_error **error);
+
+/**
+ * @brief Update the data of a frame.
+ * @brief The data will be memcpy to the frame data buffer.
+ * @brief The frame data size will be also updated as the input data size.
+ *
+ * @attention It is not recommended to update the frame data if the frame was not created by the user. If you must update it, ensure that the frame is not being
+ * used in other threads.
+ * @attention The size of the new data should be equal to or less than the current data size of the frame. Exceeding the original size may cause memory
+ * exceptions.
+ *
+ * @param[in] frame The frame object to update.
+ * @param[in] data The new data to update the frame with.
+ * @param[in] data_size The size of the new data.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ */
+OB_EXPORT void ob_frame_update_data(ob_frame *frame, const uint8_t *data, uint32_t data_size, ob_error **error);
+
+/**
+ * @brief Get the frame data size
+ *
+ * @param[in] frame Frame object
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return uint32_t return the frame data size
+ * If it is point cloud data, it return the number of bytes occupied by all point sets. If you need to find the number of points, you need to divide dataSize
+ * by the structure size of the corresponding point type.
+ */
+OB_EXPORT uint32_t ob_frame_get_data_size(const ob_frame *frame, ob_error **error);
+
+/**
+ * @brief Get the metadata of the frame
+ *
+ * @attention The returned metadata is mutable, but it is not recommended to modify it directly. Modifying the metadata directly may cause issues if the frame
+ * is being used in other threads or future use. If you need to modify the metadata, it is recommended to create a new frame object.
+ *
+ * @param[in] frame frame object
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return const uint8_t * return the metadata pointer of the frame
+ */
+OB_EXPORT uint8_t *ob_frame_get_metadata(const ob_frame *frame, ob_error **error);
+#define ob_video_frame_metadata ob_frame_get_metadata  // for compatibility
+
+/**
+ * @brief Get the metadata size of the frame
+ *
+ * @param[in] frame frame object
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return uint32_t return the metadata size of the frame
+ */
+OB_EXPORT uint32_t ob_frame_get_metadata_size(const ob_frame *frame, ob_error **error);
+#define ob_video_frame_metadata_size ob_frame_get_metadata_size  // for compatibility
+
+/**
+ * @brief Update the metadata of the frame
+ * @brief The metadata will be memcpy to the frame metadata buffer.
+ * @brief The frame metadata size will be also updated as the input metadata size.
+ *
+ * @attention It is not recommended to update the frame metadata if the frame was not created by the user. If you must update it, ensure that the frame is not
+ * being used in other threads or future use.
+ * @attention The metadata size should be equal to or less than 256 bytes, otherwise it will cause memory exception.
+ *
+ * @param[in] frame frame object
+ * @param[in] metadata The new metadata to update.
+ * @param[in] metadata_size The size of the new metadata.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ */
+OB_EXPORT void ob_frame_update_metadata(ob_frame *frame, const uint8_t *metadata, uint32_t metadata_size, ob_error **error);
+
+/**
+ * @brief check if the frame contains the specified metadata
+ *
+ * @param[in] frame frame object
+ * @param[in] type metadata type, refer to @ref ob_frame_metadata_type
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ */
+OB_EXPORT bool ob_frame_has_metadata(const ob_frame *frame, ob_frame_metadata_type type, ob_error **error);
+
+/**
+ * @brief Get the metadata value of the frame
+ *
+ * @param[in] frame frame object
+ * @param[in] type metadata type, refer to @ref ob_frame_metadata_type
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return int64_t return the metadata value of the frame
+ */
+OB_EXPORT int64_t ob_frame_get_metadata_value(const ob_frame *frame, ob_frame_metadata_type type, ob_error **error);
+
+/**
+ * @brief Get the stream profile of the frame
+ *
+ * @attention Require @ref ob_delete_stream_profile() to release the return stream profile.
+ *
+ * @param frame frame object
+ * @param error Pointer to an error object that will be set if an error occurs.
+ * @return ob_stream_profile* Return the stream profile of the frame, if the frame is not captured by a sensor stream, it will return NULL
+ */
+OB_EXPORT ob_stream_profile *ob_frame_get_stream_profile(const ob_frame *frame, ob_error **error);
+
+/**
+ * @brief Set (override) the stream profile of the frame
+ *
+ * @param frame frame object
+ * @param stream_profile The stream profile to set for the frame.
+ * @param error Pointer to an error object that will be set if an error occurs.
+ */
+OB_EXPORT void ob_frame_set_stream_profile(ob_frame *frame, const ob_stream_profile *stream_profile, ob_error **error);
+
+/**
+ * @brief Get the sensor of the frame
+ *
+ * @attention Require @ref ob_delete_sensor() to release the return sensor.
+ *
+ * @param[in] frame frame object
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return ob_sensor* return the sensor of the frame, if the frame is not captured by a sensor or the sensor stream has been destroyed, it will return NULL
+ */
+OB_EXPORT ob_sensor *ob_frame_get_sensor(const ob_frame *frame, ob_error **error);
+
+/**
+ * @brief Get the device of the frame
+ *
+ * @attention Require @ref ob_delete_device() to release the return device.
+ *
+ * @param frame frame object
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return ob_device* return the device of the frame, if the frame is not captured by a sensor stream or the device has been destroyed, it will return NULL
+ */
+OB_EXPORT ob_device *ob_frame_get_device(const ob_frame *frame, ob_error **error);
+
+/**
+ * @brief Get video frame width
+ *
+ * @param[in] frame Frame object
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return uint32_t return the frame width
+ */
+OB_EXPORT uint32_t ob_video_frame_get_width(const ob_frame *frame, ob_error **error);
+
+/**
+ * @brief Get video frame height
+ *
+ * @param[in] frame Frame object
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return uint32_t return the frame height
+ */
+OB_EXPORT uint32_t ob_video_frame_get_height(const ob_frame *frame, ob_error **error);
+
+/**
+ * @brief Get video frame pixel format
+ * @brief Usually used to determine the pixel type of depth frame (depth, disparity, raw phase, etc.)
+ *
+ * @attention Always return OB_PIXEL_UNKNOWN for non-depth frame currently if user has not set the pixel type by @ref ob_video_frame_set_pixel_type()
+ *
+ * @param frame Frame object
+ * @param error Pointer to an error object that will be set if an error occurs.
+ * @return ob_pixel_type return the pixel format of the frame.
+ */
+OB_EXPORT ob_pixel_type ob_video_frame_get_pixel_type(const ob_frame *frame, ob_error **error);
+
+/**
+ * @brief Set video frame pixel format
+ *
+ * @param frame Frame object
+ * @param pixel_type the pixel format of the frame
+ * @param error Pointer to an error object that will be set if an error occurs.
+ */
+OB_EXPORT void ob_video_frame_set_pixel_type(ob_frame *frame, ob_pixel_type pixel_type, ob_error **error);
+
+/**
+ * @brief Get the effective number of pixels (such as Y16 format frame, but only the lower 10 bits are effective bits, and the upper 6 bits are filled with 0)
+ * @attention Only valid for Y8/Y10/Y11/Y12/Y14/Y16 format
+ *
+ * @param[in] frame video frame object
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return uint8_t return the effective number of pixels in the pixel, or 0 if it is an unsupported format
+ */
+OB_EXPORT uint8_t ob_video_frame_get_pixel_available_bit_size(const ob_frame *frame, ob_error **error);
+
+/**
+ * @brief Set the effective number of pixels (such as Y16 format frame, but only the lower 10 bits are effective bits, and the upper 6 bits are filled with 0)
+ * @attention Only valid for Y8/Y10/Y11/Y12/Y14/Y16 format
+ *
+ * @param[in] frame video frame object
+ * @param[in] bit_size the effective number of pixels in the pixel, or 0 if it is an unsupported format
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ */
+OB_EXPORT void ob_video_frame_set_pixel_available_bit_size(ob_frame *frame, uint8_t bit_size, ob_error **error);
+
+/**
+ * @brief Get the source sensor type of the ir frame (left or right for dual camera)
+ *
+ * @param frame Frame object
+ * @param ob_error Pointer to an error object that will be set if an error occurs.
+ * @return ob_sensor_type return the source sensor type of the ir frame
+ */
+OB_EXPORT ob_sensor_type ob_ir_frame_get_source_sensor_type(const ob_frame *frame, ob_error **ob_error);
+
+/**
+ * @brief Get the value scale of the depth frame. The pixel value of the depth frame is multiplied by the scale to give a depth value in millimeters.
+ * For example, if valueScale=0.1 and a certain coordinate pixel value is pixelValue=10000, then the depth value = pixelValue*valueScale = 10000*0.1=1000mm.
+ *
+ * @param[in] frame Frame object
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return float The value scale of the depth frame
+ */
+OB_EXPORT float ob_depth_frame_get_value_scale(const ob_frame *frame, ob_error **error);
+
+/**
+ * @brief Set the value scale of the depth frame. The pixel value of the depth frame is multiplied by the scale to give a depth value in millimeters.
+ * For example, if valueScale=0.1 and a certain coordinate pixel value is pixelValue=10000, then the depth value = pixelValue*valueScale = 10000*0.1=1000mm.
+ *
+ * @param[in] frame Frame object
+ * @param[in] value_scale The value scale of the depth frame
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ */
+OB_EXPORT void ob_depth_frame_set_value_scale(ob_frame *frame, float value_scale, ob_error **error);
+
+/**
+ * @brief Get the point coordinate value scale of the points frame. The point position value of the points frame is multiplied by the scale to give a position
+ * value in millimeters. For example, if scale=0.1, the x-coordinate value of a point is x = 10000, which means that the actual x-coordinate value = x*scale =
+ * 10000*0.1 = 1000mm.
+ *
+ * @param[in] frame Frame object
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return float The coordinate value scale of the points frame
+ */
+OB_EXPORT float ob_points_frame_get_coordinate_value_scale(const ob_frame *frame, ob_error **error);
+
+/**
+ * @brief Get accelerometer frame data.
+ *
+ * @param[in] frame Accelerometer frame.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return ob_accel_value Return the accelerometer data.
+ */
+OB_EXPORT ob_accel_value ob_accel_frame_get_value(const ob_frame *frame, ob_error **error);
+
+/**
+ * @brief Get the temperature when acquiring the accelerometer frame.
+ *
+ * @param[in] frame Accelerometer frame.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return float Return the temperature value.
+ */
+OB_EXPORT float ob_accel_frame_get_temperature(const ob_frame *frame, ob_error **error);
+
+/**
+ * @brief Get gyroscope frame data.
+ *
+ * @param[in] frame Gyroscope frame.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return ob_gyro_value Return the gyroscope data.
+ */
+OB_EXPORT ob_gyro_value ob_gyro_frame_get_value(const ob_frame *frame, ob_error **error);
+
+/**
+ * @brief Get the temperature when acquiring the gyroscope frame.
+ *
+ * @param[in] frame Gyroscope frame.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return float Return the temperature value.
+ */
+OB_EXPORT float ob_gyro_frame_get_temperature(const ob_frame *frame, ob_error **error);
+
+/**
+ * @brief Get the number of frames contained in the frameset
+ *
+ * @attention The frame returned by this function should call @ref ob_delete_frame() to decrease the reference count when it is no longer needed.
+ *
+ * @param[in] frameset frameset object
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return uint32_t return the number of frames
+ */
+OB_EXPORT uint32_t ob_frameset_get_count(const ob_frame *frameset, ob_error **error);
+
+/**
+ * @brief Get the depth frame from the frameset.
+ *
+ * @attention The frame returned by this function should call @ref ob_delete_frame() to decrease the reference count when it is no longer needed.
+ *
+ * @param[in] frameset Frameset object.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return ob_frame* Return the depth frame.
+ */
+OB_EXPORT ob_frame *ob_frameset_get_depth_frame(const ob_frame *frameset, ob_error **error);
+
+/**
+ * @brief Get the color frame from the frameset.
+ *
+ * @attention The frame returned by this function should call @ref ob_delete_frame() to decrease the reference count when it is no longer needed.
+ *
+ * @param[in] frameset Frameset object.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return ob_frame* Return the color frame.
+ */
+OB_EXPORT ob_frame *ob_frameset_get_color_frame(const ob_frame *frameset, ob_error **error);
+
+/**
+ * @brief Get the infrared frame from the frameset.
+ *
+ * @attention The frame returned by this function should call @ref ob_delete_frame() to decrease the reference count when it is no longer needed.
+ *
+ * @param[in] frameset Frameset object.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return ob_frame* Return the infrared frame.
+ */
+OB_EXPORT ob_frame *ob_frameset_get_ir_frame(const ob_frame *frameset, ob_error **error);
+
+/**
+ * @brief Get point cloud frame from the frameset.
+ *
+ * @attention The frame returned by this function should call @ref ob_delete_frame() to decrease the reference count when it is no longer needed.
+ *
+ * @param[in] frameset Frameset object.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return ob_frame* Return the point cloud frame.
+ */
+OB_EXPORT ob_frame *ob_frameset_get_points_frame(const ob_frame *frameset, ob_error **error);
+
+/**
+ * @brief Get a frame of a specific type from the frameset.
+ *
+ * @attention The frame returned by this function should call @ref ob_delete_frame() to decrease the reference count when it is no longer needed.
+ *
+ * @param[in] frameset Frameset object.
+ * @param[in] frame_type Frame type.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return ob_frame* Return the frame of the specified type, or nullptr if it does not exist.
+ */
+OB_EXPORT ob_frame *ob_frameset_get_frame(const ob_frame *frameset, ob_frame_type frame_type, ob_error **error);
+
+/**
+ * @brief Get a frame at a specific index from the FrameSet
+ *
+ * @param[in] frameset Frameset object.
+ * @param[in] index The index of the frame.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return ob_frame* Return the frame at the specified index, or nullptr if it does not exist.
+ */
+OB_EXPORT ob_frame *ob_frameset_get_frame_by_index(const ob_frame *frameset, uint32_t index, ob_error **error);
+
+/**
+ * @brief Push a frame to the frameset
+ *
+ * @attention If a frame with same type already exists in the frameset, it will be replaced by the new frame.
+ * @attention The frame push to the frameset will be add reference count, so you still need to call @ref ob_delete_frame() to decrease the reference count when
+ * it is no longer needed.
+ *
+ * @param[in] frameset Frameset object.
+ * @param[in] frame Frame object to push.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ */
+OB_EXPORT void ob_frameset_push_frame(ob_frame *frameset, const ob_frame *frame, ob_error **error);
+
+// The following interfaces are deprecated and are retained here for compatibility purposes.
+#define ob_frame_index ob_frame_get_index
+#define ob_frame_format ob_frame_get_format
+#define ob_frame_time_stamp_us ob_frame_get_timestamp_us
+#define ob_frame_set_device_time_stamp_us ob_frame_set_timestamp_us
+#define ob_frame_system_time_stamp_us ob_frame_get_system_timestamp_us
+#define ob_frame_global_time_stamp_us ob_frame_get_global_timestamp_us
+#define ob_frame_data ob_frame_get_data
+#define ob_frame_data_size ob_frame_get_data_size
+#define ob_frame_metadata ob_frame_get_metadata
+#define ob_frame_metadata_size ob_frame_get_metadata_size
+#define ob_video_frame_width ob_video_frame_get_width
+#define ob_video_frame_height ob_video_frame_get_height
+#define ob_video_frame_pixel_available_bit_size ob_video_frame_get_pixel_available_bit_size
+#define ob_points_frame_get_position_value_scale ob_points_frame_get_coordinate_value_scale
+#define ob_frameset_frame_count ob_frameset_get_count
+#define ob_frameset_depth_frame ob_frameset_get_depth_frame
+#define ob_frameset_color_frame ob_frameset_get_color_frame
+#define ob_frameset_ir_frame ob_frameset_get_ir_frame
+#define ob_frameset_points_frame ob_frameset_get_points_frame
+#define ob_accel_frame_value ob_accel_frame_get_value
+#define ob_accel_frame_temperature ob_accel_frame_get_temperature
+#define ob_gyro_frame_value ob_gyro_frame_get_value
+#define ob_gyro_frame_temperature ob_gyro_frame_get_temperature
+#define ob_frameset_get_frame_count ob_frameset_get_count
+
+#define ob_frame_time_stamp(frame, err) (ob_frame_get_timestamp_us(frame, err))
+#define ob_frame_system_time_stamp(frame, err) (ob_frame_get_system_timestamp_us(frame, err))
+#define ob_frame_set_system_time_stamp(frame, system_timestamp, err) (ob_frame_set_system_timestamp_us(frame, system_timestamp * 1000, err))
+#define ob_frame_set_device_time_stamp(frame, device_timestamp, err) (ob_frame_set_timestamp_us(frame, device_timestamp * 1000, err))
+
+#ifdef __cplusplus
+}
+#endif
+
diff --git a/include/libobsensor/h/MultipleDevices.h b/include/libobsensor/h/MultipleDevices.h
new file mode 100644
index 00000000..a2e77935
--- /dev/null
+++ b/include/libobsensor/h/MultipleDevices.h
@@ -0,0 +1,128 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+/**
+ * @file MultipleDevices.h
+ * @brief This file contains the multiple devices related API witch is used to control the synchronization between multiple devices and the synchronization
+ * between different sensor within single device.
+ * @brief The synchronization between multiple devices is complex, and different models have different synchronization modes and limitations. please refer to
+ * the product manual for details.
+ * @brief As the Depth and Infrared are the same sensor physically, the behavior of the Infrared is same as the Depth in the synchronization mode.
+ */
+
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "ObTypes.h"
+#include "Device.h"
+
+/**
+ * @brief Get the supported multi device sync mode bitmap of the device.
+ * @brief For example, if the return value is 0b00001100, it means the device supports @ref OB_MULTI_DEVICE_SYNC_MODE_PRIMARY and @ref
+ * OB_MULTI_DEVICE_SYNC_MODE_SECONDARY. User can check the supported mode by the code:
+ * ```c
+ *   if(supported_mode_bitmap & OB_MULTI_DEVICE_SYNC_MODE_FREE_RUN){
+ *      //support OB_MULTI_DEVICE_SYNC_MODE_FREE_RUN
+ *   }
+ *   if(supported_mode_bitmap & OB_MULTI_DEVICE_SYNC_MODE_STANDALONE){
+ *     //support OB_MULTI_DEVICE_SYNC_MODE_STANDALONE
+ *   }
+ *   // and so on
+ * ```
+ * @param[in] device The device handle.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return uint16_t return the supported multi device sync mode bitmap of the device.
+ */
+OB_EXPORT uint16_t ob_device_get_supported_multi_device_sync_mode_bitmap(const ob_device *device, ob_error **error);
+
+/**
+ * @brief set the multi device sync configuration of the device.
+ *
+ * @param[in] device The device handle.
+ * @param[in] config The multi device sync configuration.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ */
+OB_EXPORT void ob_device_set_multi_device_sync_config(ob_device *device, const ob_multi_device_sync_config *config, ob_error **error);
+
+/**
+ * @brief get the current multi device sync configuration of the device.
+ *
+ * @param[in] device The device handle.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return ob_multi_device_sync_config return the multi device sync configuration of the device.
+ */
+OB_EXPORT ob_multi_device_sync_config ob_device_get_multi_device_sync_config(const ob_device *device, ob_error **error);
+
+/**
+ * @brief send the capture command to the device to trigger the capture.
+ * @brief The device will start one time capture after receiving the capture command when it is in the @ref OB_MULTI_DEVICE_SYNC_MODE_SOFTWARE_TRIGGERING
+ *
+ * @attention The frequency of the user call this function multiplied by the number of frames per trigger should be less than the frame rate of the stream. The
+ * number of frames per trigger can be set by @ref framesPerTrigger.
+ * @attention For some models，receive and execute the capture command will have a certain delay and performance consumption, so the frequency of calling this
+ * function should not be too high, please refer to the product manual for the specific supported frequency.
+ * @attention If the device is not in the @ref OB_MULTI_DEVICE_SYNC_MODE_HARDWARE_TRIGGERING mode, device will ignore the capture command.
+ *
+ * @param[in] device The device handle.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ */
+OB_EXPORT void ob_device_trigger_capture(ob_device *device, ob_error **error);
+
+/**
+ * @brief set the timestamp reset configuration of the device.
+ *
+ * @param[in] device The device handle.
+ * @param[in] config The timestamp reset configuration.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ */
+OB_EXPORT void ob_device_set_timestamp_reset_config(ob_device *device, const ob_device_timestamp_reset_config *config, ob_error **error);
+
+/**
+ * @brief get the timestamp reset configuration of the device.
+ *
+ * @param[in] device The device handle.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return ob_device_timestamp_reset_config return the timestamp reset configuration of the device.
+ */
+OB_EXPORT ob_device_timestamp_reset_config ob_device_get_timestamp_reset_config(ob_device *device, ob_error **error);
+
+/**
+ * @brief send the timestamp reset command to the device.
+ * @brief The device will reset the timer for calculating the timestamp for output frames to 0 after receiving the timestamp reset command when the timestamp
+ * reset function is enabled. The timestamp reset function can be enabled by call @ref ob_device_set_timestamp_reset_config.
+ *
+ * @attention If the stream of the device is started, the timestamp of the continuous frames output by the stream will jump once after the timestamp reset.
+ * @attention Due to the timer of device is not high-accuracy, the timestamp of the continuous frames output by the stream will drift after a long time. User
+ * can call this function periodically to reset the timer to avoid the timestamp drift, the recommended interval time is 60 minutes.
+ *
+ * @param[in] device The device handle.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ */
+OB_EXPORT void ob_device_timestamp_reset(ob_device *device, ob_error **error);
+
+/**
+ * @brief Alias for @ref ob_device_timestamp_reset since it is more accurate.
+ */
+#define ob_device_timer_reset ob_device_timestamp_reset
+
+/**
+ * @brief synchronize the timer of the device with the host.
+ * @brief After calling this function, the timer of the device will be synchronized with the host. User can call this function to multiple devices to
+ * synchronize all timers of the devices.
+ *
+ * @attention If the stream of the device is started, the timestamp of the continuous frames output by the stream will may jump once after the timer sync.
+ * @attention Due to the timer of device is not high-accuracy, the timestamp of the continuous frames output by the stream will drift after a long time. User
+ * can call this function periodically to synchronize the timer to avoid the timestamp drift, the recommended interval time is 60 minutes.
+ *
+ * @param[in] device The device handle.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ */
+OB_EXPORT void ob_device_timer_sync_with_host(ob_device *device, ob_error **error);
+
+#ifdef __cplusplus
+}  // extern "C"
+#endif
+
diff --git a/include/libobsensor/h/ObTypes.h b/include/libobsensor/h/ObTypes.h
new file mode 100644
index 00000000..65ee26cf
--- /dev/null
+++ b/include/libobsensor/h/ObTypes.h
@@ -0,0 +1,1756 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+// License: Apache 2.0. See LICENSE file in root directory.
+// Copyright(c) 2020 Orbbec  Corporation. All Rights Reserved.
+
+/**
+ * @file ObTypes.h
+ * @brief Provide structs commonly used in the SDK, enumerating constant definitions.
+ */
+
+#pragma once
+
+#include "Export.h"
+
+#pragma pack(push, 1)  // struct 1-byte align
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdbool.h>
+#include <stdint.h>
+
+typedef struct ob_context_t                   ob_context;
+typedef struct ob_device_t                    ob_device;
+typedef struct ob_device_info_t               ob_device_info;
+typedef struct ob_device_list_t               ob_device_list;
+typedef struct ob_camera_param_list_t         ob_camera_param_list;
+typedef struct ob_sensor_t                    ob_sensor;
+typedef struct ob_sensor_list_t               ob_sensor_list;
+typedef struct ob_stream_profile_t            ob_stream_profile;
+typedef struct ob_stream_profile_list_t       ob_stream_profile_list;
+typedef struct ob_frame_t                     ob_frame;
+typedef struct ob_filter_t                    ob_filter;
+typedef struct ob_filter_list_t               ob_filter_list;
+typedef struct ob_pipeline_t                  ob_pipeline;
+typedef struct ob_config_t                    ob_config;
+typedef struct ob_depth_work_mode_list_t      ob_depth_work_mode_list;
+typedef struct ob_device_preset_list_t        ob_device_preset_list;
+typedef struct ob_filter_config_schema_list_t ob_filter_config_schema_list;
+
+#define OB_WIDTH_ANY 0
+#define OB_HEIGHT_ANY 0
+#define OB_FPS_ANY 0
+#define OB_FORMAT_ANY OB_FORMAT_UNKNOWN
+#define OB_PROFILE_DEFAULT 0
+#define OB_DEFAULT_STRIDE_BYTES 0
+#define OB_ACCEL_FULL_SCALE_RANGE_ANY OB_ACCEL_FS_UNKNOWN
+#define OB_ACCEL_SAMPLE_RATE_ANY OB_SAMPLE_RATE_UNKNOWN
+#define OB_GYRO_FULL_SCALE_RANGE_ANY OB_GYRO_FS_UNKNOWN
+#define OB_GYRO_SAMPLE_RATE_ANY OB_SAMPLE_RATE_UNKNOWN
+
+/**
+ * @brief the permission type of api or property
+ */
+typedef enum {
+    OB_PERMISSION_DENY       = 0,   /**< no permission */
+    OB_PERMISSION_READ       = 1,   /**< can read */
+    OB_PERMISSION_WRITE      = 2,   /**< can write */
+    OB_PERMISSION_READ_WRITE = 3,   /**< can read and write */
+    OB_PERMISSION_ANY        = 255, /**< any situation above */
+} OBPermissionType,
+    ob_permission_type;
+
+/**
+ * @brief error code
+ */
+typedef enum {
+    OB_STATUS_OK    = 0, /**< status ok */
+    OB_STATUS_ERROR = 1, /**< status error */
+} OBStatus,
+    ob_status;
+
+/**
+ * @brief log level, the higher the level, the stronger the log filter
+ */
+typedef enum {
+    OB_LOG_SEVERITY_DEBUG, /**< debug */
+    OB_LOG_SEVERITY_INFO,  /**< information */
+    OB_LOG_SEVERITY_WARN,  /**< warning */
+    OB_LOG_SEVERITY_ERROR, /**< error */
+    OB_LOG_SEVERITY_FATAL, /**< fatal error */
+    OB_LOG_SEVERITY_OFF    /**< off (close LOG) */
+} OBLogSeverity,
+    ob_log_severity, DEVICE_LOG_SEVERITY_LEVEL, OBDeviceLogSeverityLevel, ob_device_log_severity_level;
+#define OB_LOG_SEVERITY_NONE OB_LOG_SEVERITY_OFF
+
+/**
+ * @brief The exception types in the SDK, through the exception type, you can easily determine the specific type of error.
+ * For detailed error API interface functions and error logs, please refer to the information of ob_error
+ */
+typedef enum {
+    OB_EXCEPTION_TYPE_UNKNOWN,             /**< Unknown error, an error not clearly defined by the SDK */
+    OB_EXCEPTION_STD_EXCEPTION,            /** < Standard exception, an error caused by the standard library */
+    OB_EXCEPTION_TYPE_CAMERA_DISCONNECTED, /**< Camera/Device has been disconnected, the camera/device is not available */
+    OB_EXCEPTION_TYPE_PLATFORM,            /**< An error in the SDK adaptation platform layer, which means an error in the implementation of a specific system
+                                              platform */
+    OB_EXCEPTION_TYPE_INVALID_VALUE,       /**< Invalid parameter type exception, need to check input parameter */
+    OB_EXCEPTION_TYPE_WRONG_API_CALL_SEQUENCE, /**< Wrong API call sequence, the API is called in the wrong order or the wrong parameter is passed */
+    OB_EXCEPTION_TYPE_NOT_IMPLEMENTED,         /**< SDK and firmware have not yet implemented this function or feature */
+    OB_EXCEPTION_TYPE_IO,                      /**< SDK access IO exception error */
+    OB_EXCEPTION_TYPE_MEMORY,                  /**< SDK access and use memory errors. For example, the frame fails to allocate memory */
+    OB_EXCEPTION_TYPE_UNSUPPORTED_OPERATION,   /**< Unsupported operation type error by SDK or device */
+} OBExceptionType,
+    ob_exception_type;
+
+/**
+ * @brief The error class exposed by the SDK, users can get detailed error information according to the error
+ */
+typedef struct ob_error {
+    ob_status         status;          ///< Describe the status code of the error, as compatible with previous customer status code requirements
+    char              message[256];    ///< Describe the detailed error log
+    char              function[256];   ///< Describe the name of the function where the error occurred
+    char              args[256];       ///< Describes the parameters passed to the function when an error occurs. Used to check whether the parameter is wrong
+    ob_exception_type exception_type;  ///< The description is the specific error type of the SDK
+} ob_error;
+
+/**
+ * @brief Enumeration value describing the sensor type
+ */
+typedef enum {
+    OB_SENSOR_UNKNOWN   = 0, /**< Unknown type sensor */
+    OB_SENSOR_IR        = 1, /**< IR */
+    OB_SENSOR_COLOR     = 2, /**< Color */
+    OB_SENSOR_DEPTH     = 3, /**< Depth */
+    OB_SENSOR_ACCEL     = 4, /**< Accel */
+    OB_SENSOR_GYRO      = 5, /**< Gyro */
+    OB_SENSOR_IR_LEFT   = 6, /**< left IR for stereo camera*/
+    OB_SENSOR_IR_RIGHT  = 7, /**< Right IR for stereo camera*/
+    OB_SENSOR_RAW_PHASE = 8, /**< Raw Phase */
+    OB_SENSOR_TYPE_COUNT,    /**The total number of sensor types, is not a valid sensor type */
+} OBSensorType,
+    ob_sensor_type;
+
+/**
+ * @brief Enumeration value describing the type of data stream
+ */
+typedef enum {
+    OB_STREAM_UNKNOWN   = -1, /**< Unknown type stream */
+    OB_STREAM_VIDEO     = 0,  /**< Video stream (infrared, color, depth streams are all video streams) */
+    OB_STREAM_IR        = 1,  /**< IR stream */
+    OB_STREAM_COLOR     = 2,  /**< color stream */
+    OB_STREAM_DEPTH     = 3,  /**< depth stream */
+    OB_STREAM_ACCEL     = 4,  /**< Accelerometer data stream */
+    OB_STREAM_GYRO      = 5,  /**< Gyroscope data stream */
+    OB_STREAM_IR_LEFT   = 6,  /**< Left IR stream for stereo camera */
+    OB_STREAM_IR_RIGHT  = 7,  /**< Right IR stream for stereo camera */
+    OB_STREAM_RAW_PHASE = 8,  /**< RawPhase Stream */
+    OB_STREAM_TYPE_COUNT,     /**< The total number of stream type,is not a valid stream type */
+} OBStreamType,
+    ob_stream_type;
+
+/**
+ * @brief Enumeration value describing the type of frame
+ */
+typedef enum {
+    OB_FRAME_UNKNOWN   = -1, /**< Unknown frame type */
+    OB_FRAME_VIDEO     = 0,  /**< Video frame */
+    OB_FRAME_IR        = 1,  /**< IR frame */
+    OB_FRAME_COLOR     = 2,  /**< Color frame */
+    OB_FRAME_DEPTH     = 3,  /**< Depth frame */
+    OB_FRAME_ACCEL     = 4,  /**< Accelerometer data frame */
+    OB_FRAME_SET       = 5,  /**< Frame collection (internally contains a variety of data frames) */
+    OB_FRAME_POINTS    = 6,  /**< Point cloud frame */
+    OB_FRAME_GYRO      = 7,  /**< Gyroscope data frame */
+    OB_FRAME_IR_LEFT   = 8,  /**< Left IR frame for stereo camera */
+    OB_FRAME_IR_RIGHT  = 9,  /**< Right IR frame for stereo camera */
+    OB_FRAME_RAW_PHASE = 10, /**< Raw Phase frame*/
+    OB_FRAME_TYPE_COUNT,     /**< The total number of frame types, is not a valid frame type */
+} OBFrameType,
+    ob_frame_type;
+
+/**
+ * @brief Enumeration value describing the pixel type of frame (usually used for depth frame)
+ *
+ */
+typedef enum {
+    OB_PIXEL_UNKNOWN   = -1,  // Unknown pixel type, or undefined pixel type for current frame
+    OB_PIXEL_DEPTH     = 0,   // Depth pixel type, the value of the pixel is the distance from the camera to the object
+    OB_PIXEL_DISPARITY = 2,   // Disparity for structured light camera
+    OB_PIXEL_RAW_PHASE = 3,   // Raw phase for tof camera
+} OBPixelType,
+    ob_pixel_type;
+
+/**
+ * @brief Enumeration value describing the pixel format
+ */
+typedef enum {
+    OB_FORMAT_UNKNOWN    = -1, /*< unknown format */
+    OB_FORMAT_YUYV       = 0,  /**< YUYV format */
+    OB_FORMAT_YUY2       = 1,  /**< YUY2 format (the actual format is the same as YUYV) */
+    OB_FORMAT_UYVY       = 2,  /**< UYVY format */
+    OB_FORMAT_NV12       = 3,  /**< NV12 format */
+    OB_FORMAT_NV21       = 4,  /**< NV21 format */
+    OB_FORMAT_MJPG       = 5,  /**< MJPEG encoding format */
+    OB_FORMAT_H264       = 6,  /**< H.264 encoding format */
+    OB_FORMAT_H265       = 7,  /**< H.265 encoding format */
+    OB_FORMAT_Y16        = 8,  /**< Y16 format, 16-bit per pixel, single-channel*/
+    OB_FORMAT_Y8         = 9,  /**< Y8 format, 8-bit per pixel, single-channel */
+    OB_FORMAT_Y10        = 10, /**< Y10 format, 10-bit per pixel, single-channel(SDK will unpack into Y16 by default) */
+    OB_FORMAT_Y11        = 11, /**< Y11 format, 11-bit per pixel, single-channel (SDK will unpack into Y16 by default) */
+    OB_FORMAT_Y12        = 12, /**< Y12 format, 12-bit per pixel, single-channel(SDK will unpack into Y16 by default) */
+    OB_FORMAT_GRAY       = 13, /**< GRAY (the actual format is the same as YUYV) */
+    OB_FORMAT_HEVC       = 14, /**< HEVC encoding format (the actual format is the same as H265) */
+    OB_FORMAT_I420       = 15, /**< I420 format */
+    OB_FORMAT_ACCEL      = 16, /**< Acceleration data format */
+    OB_FORMAT_GYRO       = 17, /**< Gyroscope data format */
+    OB_FORMAT_POINT      = 19, /**< XYZ 3D coordinate point format, @ref OBPoint */
+    OB_FORMAT_RGB_POINT  = 20, /**< XYZ 3D coordinate point format with RGB information, @ref OBColorPoint */
+    OB_FORMAT_RLE        = 21, /**< RLE pressure test format (SDK will be unpacked into Y16 by default) */
+    OB_FORMAT_RGB        = 22, /**< RGB format (actual RGB888)  */
+    OB_FORMAT_BGR        = 23, /**< BGR format (actual BGR888) */
+    OB_FORMAT_Y14        = 24, /**< Y14 format, 14-bit per pixel, single-channel (SDK will unpack into Y16 by default) */
+    OB_FORMAT_BGRA       = 25, /**< BGRA format */
+    OB_FORMAT_COMPRESSED = 26, /**< Compression format */
+    OB_FORMAT_RVL        = 27, /**< RVL pressure test format (SDK will be unpacked into Y16 by default) */
+    OB_FORMAT_Z16        = 28, /**< Is same as Y16*/
+    OB_FORMAT_YV12       = 29, /**< Is same as Y12, using for right ir stream*/
+    OB_FORMAT_BA81       = 30, /**< Is same as Y8, using for right ir stream*/
+    OB_FORMAT_RGBA       = 31, /**< RGBA format */
+    OB_FORMAT_BYR2       = 32, /**< byr2 format */
+    OB_FORMAT_RW16       = 33, /**< RAW16 format */
+} OBFormat,
+    ob_format;
+
+#define OB_FORMAT_RGB888 OB_FORMAT_RGB  // Alias of OB_FORMAT_RGB for compatibility
+#define OB_FORMAT_MJPEG OB_FORMAT_MJPG  // Alias of OB_FORMAT_MJPG for compatibility
+
+// Check if the format is a fixed data size format
+#define IS_FIXED_SIZE_FORMAT(format)                                                                                                         \
+    (format != OB_FORMAT_MJPG && format != OB_FORMAT_H264 && format != OB_FORMAT_H265 && format != OB_FORMAT_HEVC && format != OB_FORMAT_RLE \
+     && format != OB_FORMAT_RVL)
+
+// Check if the format is a packed format, which means the data of pixels is not continuous or bytes aligned in memory
+#define IS_PACKED_FORMAT(format) \
+    (format == OB_FORMAT_Y10 || format == OB_FORMAT_Y11 || format == OB_FORMAT_Y12 || format == OB_FORMAT_Y14 || format == OB_FORMAT_RLE)
+
+/**
+ * @brief Enumeration value describing the firmware upgrade status
+ */
+typedef enum {
+    STAT_VERIFY_SUCCESS = 5,  /**< Image file verifify success */
+    STAT_FILE_TRANSFER  = 4,  /**< file transfer */
+    STAT_DONE           = 3,  /**< update completed */
+    STAT_IN_PROGRESS    = 2,  /**< upgrade in process */
+    STAT_START          = 1,  /**< start the upgrade */
+    STAT_VERIFY_IMAGE   = 0,  /**< Image file verification */
+    ERR_VERIFY          = -1, /**< Verification failed */
+    ERR_PROGRAM         = -2, /**< Program execution failed */
+    ERR_ERASE           = -3, /**< Flash parameter failed */
+    ERR_FLASH_TYPE      = -4, /**< Flash type error */
+    ERR_IMAGE_SIZE      = -5, /**< Image file size error */
+    ERR_OTHER           = -6, /**< other errors */
+    ERR_DDR             = -7, /**< DDR access error */
+    ERR_TIMEOUT         = -8  /**< timeout error */
+} OBUpgradeState,
+    OBFwUpdateState, ob_upgrade_state, ob_fw_update_state;
+
+/**
+ * @brief Enumeration value describing the file transfer status
+ */
+typedef enum {
+    FILE_TRAN_STAT_TRANSFER         = 2,  /**< File transfer */
+    FILE_TRAN_STAT_DONE             = 1,  /**< File transfer succeeded */
+    FILE_TRAN_STAT_PREPAR           = 0,  /**< Preparing */
+    FILE_TRAN_ERR_DDR               = -1, /**< DDR access failed */
+    FILE_TRAN_ERR_NOT_ENOUGH_SPACE  = -2, /**< Insufficient target space error */
+    FILE_TRAN_ERR_PATH_NOT_WRITABLE = -3, /**< Destination path is not writable */
+    FILE_TRAN_ERR_MD5_ERROR         = -4, /**< MD5 checksum error */
+    FILE_TRAN_ERR_WRITE_FLASH_ERROR = -5, /**< Write flash error */
+    FILE_TRAN_ERR_TIMEOUT           = -6  /**< Timeout error */
+} OBFileTranState,
+    ob_file_tran_state;
+
+/**
+ * @brief Enumeration value describing the data transfer status
+ */
+typedef enum {
+    DATA_TRAN_STAT_VERIFY_DONE  = 4,  /**< data verify done */
+    DATA_TRAN_STAT_STOPPED      = 3,  /**< data transfer stoped */
+    DATA_TRAN_STAT_DONE         = 2,  /**< data transfer completed */
+    DATA_TRAN_STAT_VERIFYING    = 1,  /**< data verifying */
+    DATA_TRAN_STAT_TRANSFERRING = 0,  /**< data transferring */
+    DATA_TRAN_ERR_BUSY          = -1, /**< Transmission is busy */
+    DATA_TRAN_ERR_UNSUPPORTED   = -2, /**< Not supported */
+    DATA_TRAN_ERR_TRAN_FAILED   = -3, /**< Transfer failed */
+    DATA_TRAN_ERR_VERIFY_FAILED = -4, /**< Test failed */
+    DATA_TRAN_ERR_OTHER         = -5  /**< Other errors */
+} OBDataTranState,
+    ob_data_tran_state;
+
+/**
+ * @brief Structure for transmitting data blocks
+ */
+typedef struct {
+    uint8_t *data;          ///< Pointer to current block data
+    uint32_t size;          ///< Length of current block data
+    uint32_t offset;        ///< Offset of current data block relative to complete data
+    uint32_t fullDataSize;  ///< Size of full data
+} OBDataChunk, ob_data_chunk;
+
+/**
+ * @brief Structure for integer range
+ */
+typedef struct {
+    int32_t cur;   ///< Current value
+    int32_t max;   ///< Maximum value
+    int32_t min;   ///< Minimum value
+    int32_t step;  ///< Step value
+    int32_t def;   ///< Default value
+} OBIntPropertyRange, ob_int_property_range;
+
+/**
+ * @brief Structure for float range
+ */
+typedef struct {
+    float cur;   ///< Current value
+    float max;   ///< Maximum value
+    float min;   ///< Minimum value
+    float step;  ///< Step value
+    float def;   ///< Default value
+} OBFloatPropertyRange, ob_float_property_range;
+
+/**
+ * @brief Structure for float range
+ */
+typedef struct {
+    uint16_t cur;   ///< Current value
+    uint16_t max;   ///< Maximum value
+    uint16_t min;   ///< Minimum value
+    uint16_t step;  ///< Step value
+    uint16_t def;   ///< Default value
+} OBUint16PropertyRange, ob_uint16_property_range;
+
+/**
+ * @brief Structure for float range
+ */
+typedef struct {
+    uint8_t cur;   ///< Current value
+    uint8_t max;   ///< Maximum value
+    uint8_t min;   ///< Minimum value
+    uint8_t step;  ///< Step value
+    uint8_t def;   ///< Default value
+} OBUint8PropertyRange, ob_uint8_property_range;
+
+/**
+ * @brief Structure for boolean range
+ */
+typedef struct {
+    bool cur;   ///< Current value
+    bool max;   ///< Maximum value
+    bool min;   ///< Minimum value
+    bool step;  ///< Step value
+    bool def;   ///< Default value
+} OBBoolPropertyRange, ob_bool_property_range;
+
+/** \brief Distortion model: defines how pixel coordinates should be mapped to sensor coordinates. */
+typedef enum {
+    OB_DISTORTION_NONE,                   /**< Rectilinear images. No distortion compensation required. */
+    OB_DISTORTION_MODIFIED_BROWN_CONRADY, /**< Equivalent to Brown-Conrady distortion, except that tangential distortion is applied to radially distorted points
+                                           */
+    OB_DISTORTION_INVERSE_BROWN_CONRADY,  /**< Equivalent to Brown-Conrady distortion, except undistorts image instead of distorting it */
+    OB_DISTORTION_BROWN_CONRADY,          /**< Unmodified Brown-Conrady distortion model */
+    OB_DISTORTION_BROWN_CONRADY_K6,       /**< Unmodified Brown-Conrady distortion model with k6 supported */
+    OB_DISTORTION_KANNALA_BRANDT4,        /**< Kannala-Brandt distortion model */
+} OBCameraDistortionModel,
+    ob_camera_distortion_model;
+
+/**
+ * @brief Structure for camera intrinsic parameters
+ */
+typedef struct {
+    float   fx;      ///< Focal length in x direction
+    float   fy;      ///< Focal length in y direction
+    float   cx;      ///< Optical center abscissa
+    float   cy;      ///< Optical center ordinate
+    int16_t width;   ///< Image width
+    int16_t height;  ///< Image height
+} OBCameraIntrinsic, ob_camera_intrinsic;
+
+/**
+ * @brief Structure for accelerometer intrinsic parameters
+ */
+typedef struct {
+    double noiseDensity;          ///< In-run bias instability
+    double randomWalk;            ///< random walk
+    double referenceTemp;         ///< reference temperature
+    double bias[3];               ///< bias for x, y, z axis
+    double gravity[3];            ///< gravity direction for x, y, z axis
+    double scaleMisalignment[9];  ///< scale factor and three-axis non-orthogonal error
+    double tempSlope[9];          ///< linear temperature drift coefficient
+} OBAccelIntrinsic, ob_accel_intrinsic;
+
+/**
+ * @brief Structure for gyroscope intrinsic parameters
+ */
+typedef struct {
+    double noiseDensity;          ///< In-run bias instability
+    double randomWalk;            ///< random walk
+    double referenceTemp;         ///< reference temperature
+    double bias[3];               ///< bias for x, y, z axis
+    double scaleMisalignment[9];  ///< scale factor and three-axis non-orthogonal error
+    double tempSlope[9];          ///< linear temperature drift coefficient
+} OBGyroIntrinsic, ob_gyro_intrinsic;
+
+/**
+ * @brief Structure for distortion parameters
+ */
+typedef struct {
+    float                   k1;  ///< Radial distortion factor 1
+    float                   k2;  ///< Radial distortion factor 2
+    float                   k3;  ///< Radial distortion factor 3
+    float                   k4;  ///< Radial distortion factor 4
+    float                   k5;  ///< Radial distortion factor 5
+    float                   k6;  ///< Radial distortion factor 6
+    float                   p1;  ///< Tangential distortion factor 1
+    float                   p2;  ///< Tangential distortion factor 2
+    OBCameraDistortionModel model;
+} OBCameraDistortion, ob_camera_distortion;
+
+/**
+ * @brief Structure for rotation/transformation
+ */
+typedef struct {
+    float rot[9];    ///< Rotation matrix
+    float trans[3];  ///< Transformation matrix in millimeters
+} OBD2CTransform, ob_d2c_transform, OBTransform, ob_transform, OBExtrinsic, ob_extrinsic;
+
+/**
+ * @brief Structure for camera parameters
+ */
+typedef struct {
+    OBCameraIntrinsic  depthIntrinsic;   ///< Depth camera internal parameters
+    OBCameraIntrinsic  rgbIntrinsic;     ///< Color camera internal parameters
+    OBCameraDistortion depthDistortion;  ///< Depth camera distortion parameters
+    OBCameraDistortion rgbDistortion;    ///< Color camera distortion parameters
+    OBD2CTransform     transform;        ///< Rotation/transformation matrix
+    bool               isMirrored;       ///< Whether the image frame corresponding to this group of parameters is mirrored
+} OBCameraParam, ob_camera_param;
+
+/**
+ * @brief calibration parameters
+ */
+typedef struct {
+    OBCameraIntrinsic  intrinsics[OB_SENSOR_TYPE_COUNT];  ///< Sensor internal parameters
+    OBCameraDistortion distortion[OB_SENSOR_TYPE_COUNT];  ///< Sensor distortion
+    OBExtrinsic        extrinsics[OB_SENSOR_TYPE_COUNT]
+                          [OB_SENSOR_TYPE_COUNT];  ///< The extrinsic parameters allow 3D coordinate conversions between sensor.To transform from a
+                                                   ///< source to a target 3D coordinate system,under extrinsics[source][target].
+} OBCalibrationParam, ob_calibration_param;
+
+/**
+ * @brief Configuration for depth margin filter
+ */
+typedef struct {
+    int      margin_x_th;       ///< Horizontal threshold settings
+    int      margin_y_th;       ///< Vertical threshold settings
+    int      limit_x_th;        ///< Maximum horizontal threshold
+    int      limit_y_th;        ///< Maximum vertical threshold
+    uint32_t width;             ///< Image width
+    uint32_t height;            ///< Image height
+    bool     enable_direction;  ///< Set to true for horizontal and vertical, false for horizontal only
+} ob_margin_filter_config, OBMarginFilterConfig;
+
+/**
+ * @brief Configuration for mgc filter
+ */
+typedef struct {
+    uint32_t width;
+    uint32_t height;
+    int      max_width_left;
+    int      max_width_right;
+    int      max_radius;
+    int      margin_x_th;
+    int      margin_y_th;
+    int      limit_x_th;
+    int      limit_y_th;
+} OBMGCFilterConfig, ob_mgc_filter_config;
+
+/**
+ * @brief Alignment mode
+ */
+typedef enum {
+    ALIGN_DISABLE,     /**< Turn off alignment */
+    ALIGN_D2C_HW_MODE, /**< Hardware D2C alignment mode */
+    ALIGN_D2C_SW_MODE, /**< Software D2C alignment mode */
+} OBAlignMode,
+    ob_align_mode;
+
+/**
+ * @brief Rectangle
+ */
+typedef struct {
+    uint32_t x;       ///< Origin coordinate x
+    uint32_t y;       ///< Origin coordinate y
+    uint32_t width;   ///< Rectangle width
+    uint32_t height;  ///< Rectangle height
+} OBRect, ob_rect;
+
+/**
+ * @brief Enumeration of format conversion types
+ */
+typedef enum {
+    FORMAT_YUYV_TO_RGB = 0, /**< YUYV to RGB */
+    FORMAT_I420_TO_RGB,     /**< I420 to RGB */
+    FORMAT_NV21_TO_RGB,     /**< NV21 to RGB */
+    FORMAT_NV12_TO_RGB,     /**< NV12 to RGB */
+    FORMAT_MJPG_TO_I420,    /**< MJPG to I420 */
+    FORMAT_RGB_TO_BGR,      /**< RGB888 to BGR */
+    FORMAT_MJPG_TO_NV21,    /**< MJPG to NV21 */
+    FORMAT_MJPG_TO_RGB,     /**< MJPG to RGB */
+    FORMAT_MJPG_TO_BGR,     /**< MJPG to BGR */
+    FORMAT_MJPG_TO_BGRA,    /**< MJPG to BGRA */
+    FORMAT_UYVY_TO_RGB,     /**< UYVY to RGB */
+    FORMAT_BGR_TO_RGB,      /**< BGR to RGB */
+    FORMAT_MJPG_TO_NV12,    /**< MJPG to NV12 */
+    FORMAT_YUYV_TO_BGR,     /**< YUYV to BGR */
+    FORMAT_YUYV_TO_RGBA,    /**< YUYV to RGBA */
+    FORMAT_YUYV_TO_BGRA,    /**< YUYV to BGRA */
+    FORMAT_YUYV_TO_Y16,     /**< YUYV to Y16 */
+    FORMAT_YUYV_TO_Y8,      /**< YUYV to Y8 */
+} OBConvertFormat,
+    ob_convert_format;
+
+// DEPRECATED: Only used for old version program compatibility, will be completely deleted in subsequent iterative versions
+#define FORMAT_MJPEG_TO_I420 FORMAT_MJPG_TO_I420
+#define FORMAT_MJPEG_TO_NV21 FORMAT_MJPG_TO_NV21
+#define FORMAT_MJPEG_TO_BGRA FORMAT_MJPG_TO_BGRA
+#define FORMAT_YUYV_TO_RGB888 FORMAT_YUYV_TO_RGB
+#define FORMAT_I420_TO_RGB888 FORMAT_I420_TO_RGB
+#define FORMAT_NV21_TO_RGB888 FORMAT_NV21_TO_RGB
+#define FORMAT_NV12_TO_RGB888 FORMAT_NV12_TO_RGB
+#define FORMAT_UYVY_TO_RGB888 FORMAT_UYVY_TO_RGB
+#define FORMAT_MJPG_TO_RGB888 FORMAT_MJPG_TO_RGB
+#define FORMAT_MJPG_TO_BGR888 FORMAT_MJPG_TO_BGR
+#define FORMAT_MJPEG_TO_RGB888 FORMAT_MJPG_TO_RGB
+#define FORMAT_MJPEG_TO_BGR888 FORMAT_MJPG_TO_BGR
+#define FORMAT_RGB888_TO_BGR FORMAT_RGB_TO_BGR
+
+/**
+ * @brief Enumeration of IMU sample rate values (gyroscope or accelerometer)
+ */
+typedef enum {
+    OB_SAMPLE_RATE_UNKNOWN   = 0,
+    OB_SAMPLE_RATE_1_5625_HZ = 1, /**< 1.5625Hz */
+    OB_SAMPLE_RATE_3_125_HZ,      /**< 3.125Hz */
+    OB_SAMPLE_RATE_6_25_HZ,       /**< 6.25Hz */
+    OB_SAMPLE_RATE_12_5_HZ,       /**< 12.5Hz */
+    OB_SAMPLE_RATE_25_HZ,         /**< 25Hz */
+    OB_SAMPLE_RATE_50_HZ,         /**< 50Hz */
+    OB_SAMPLE_RATE_100_HZ,        /**< 100Hz */
+    OB_SAMPLE_RATE_200_HZ,        /**< 200Hz */
+    OB_SAMPLE_RATE_500_HZ,        /**< 500Hz */
+    OB_SAMPLE_RATE_1_KHZ,         /**< 1KHz */
+    OB_SAMPLE_RATE_2_KHZ,         /**< 2KHz */
+    OB_SAMPLE_RATE_4_KHZ,         /**< 4KHz */
+    OB_SAMPLE_RATE_8_KHZ,         /**< 8KHz */
+    OB_SAMPLE_RATE_16_KHZ,        /**< 16KHz */
+    OB_SAMPLE_RATE_32_KHZ,        /**< 32Hz */
+} OBIMUSampleRate,
+    OBGyroSampleRate, ob_gyro_sample_rate, OBAccelSampleRate, ob_accel_sample_rate, OB_SAMPLE_RATE;
+
+/**
+ * @brief Enumeration of gyroscope ranges
+ */
+typedef enum {
+    OB_GYRO_FS_UNKNOWN = -1,
+    OB_GYRO_FS_16dps   = 1, /**< 16 degrees per second */
+    OB_GYRO_FS_31dps,       /**< 31 degrees per second */
+    OB_GYRO_FS_62dps,       /**< 62 degrees per second */
+    OB_GYRO_FS_125dps,      /**< 125 degrees per second */
+    OB_GYRO_FS_250dps,      /**< 250 degrees per second */
+    OB_GYRO_FS_500dps,      /**< 500 degrees per second */
+    OB_GYRO_FS_1000dps,     /**< 1000 degrees per second */
+    OB_GYRO_FS_2000dps,     /**< 2000 degrees per second */
+} OBGyroFullScaleRange,
+    ob_gyro_full_scale_range, OB_GYRO_FULL_SCALE_RANGE;
+
+/**
+ * @brief Enumeration of accelerometer ranges
+ */
+typedef enum {
+    OB_ACCEL_FS_UNKNOWN = -1,
+    OB_ACCEL_FS_2g      = 1, /**< 1x the acceleration of gravity */
+    OB_ACCEL_FS_4g,          /**< 4x the acceleration of gravity */
+    OB_ACCEL_FS_8g,          /**< 8x the acceleration of gravity */
+    OB_ACCEL_FS_16g,         /**< 16x the acceleration of gravity */
+} OBAccelFullScaleRange,
+    ob_accel_full_scale_range, OB_ACCEL_FULL_SCALE_RANGE;
+
+/**
+ * @brief Data structures for accelerometers and gyroscopes
+ */
+typedef struct {
+    float x;  ///< X-direction component
+    float y;  ///< Y-direction component
+    float z;  ///< Z-direction component
+} OBAccelValue, OBGyroValue, OBFloat3D, ob_accel_value, ob_gyro_value, ob_float_3d;
+
+/**
+ * @brief Device state
+ */
+typedef uint64_t OBDeviceState, ob_device_state;
+
+/**
+ * @brief Temperature parameters of the device (unit: Celsius)
+ */
+typedef struct {
+    float cpuTemp;         ///< CPU temperature
+    float irTemp;          ///< IR temperature
+    float ldmTemp;         ///< Laser temperature
+    float mainBoardTemp;   ///< Motherboard temperature
+    float tecTemp;         ///< TEC temperature
+    float imuTemp;         ///< IMU temperature
+    float rgbTemp;         ///< RGB temperature
+    float irLeftTemp;      ///< Left IR temperature
+    float irRightTemp;     ///< Right IR temperature
+    float chipTopTemp;     ///< MX6600 top temperature
+    float chipBottomTemp;  ///< MX6600 bottom temperature
+} OBDeviceTemperature, ob_device_temperature, DEVICE_TEMPERATURE;
+
+/**
+ * @brief Enumeration for depth crop modes
+ */
+typedef enum {
+    DEPTH_CROPPING_MODE_AUTO  = 0, /**< Automatic mode */
+    DEPTH_CROPPING_MODE_CLOSE = 1, /**< Close crop */
+    DEPTH_CROPPING_MODE_OPEN  = 2, /**< Open crop */
+} OBDepthCroppingMode,
+    ob_depth_cropping_mode, OB_DEPTH_CROPPING_MODE;
+
+/**
+ * @brief Enumeration for device types
+ */
+typedef enum {
+    OB_DEVICE_TYPE_UNKNOWN               = -1, /**< Unknown device type */
+    OB_STRUCTURED_LIGHT_MONOCULAR_CAMERA = 0,  /**< Monocular structured light camera */
+    OB_STRUCTURED_LIGHT_BINOCULAR_CAMERA = 1,  /**< Binocular structured light camera */
+    OB_TOF_CAMERA                        = 2,  /**< Time-of-flight camera */
+} OBDeviceType,
+    ob_device_type, OB_DEVICE_TYPE;
+
+/**
+ * @brief Enumeration for types of media to record or playback
+ */
+typedef enum {
+    OB_MEDIA_COLOR_STREAM    = 1,   /**< Color stream */
+    OB_MEDIA_DEPTH_STREAM    = 2,   /**< Depth stream */
+    OB_MEDIA_IR_STREAM       = 4,   /**< Infrared stream */
+    OB_MEDIA_GYRO_STREAM     = 8,   /**< Gyroscope stream */
+    OB_MEDIA_ACCEL_STREAM    = 16,  /**< Accelerometer stream */
+    OB_MEDIA_CAMERA_PARAM    = 32,  /**< Camera parameter */
+    OB_MEDIA_DEVICE_INFO     = 64,  /**< Device information */
+    OB_MEDIA_STREAM_INFO     = 128, /**< Stream information */
+    OB_MEDIA_IR_LEFT_STREAM  = 256, /**< Left infrared stream */
+    OB_MEDIA_IR_RIGHT_STREAM = 512, /**< Right infrared stream */
+
+    OB_MEDIA_ALL = OB_MEDIA_COLOR_STREAM | OB_MEDIA_DEPTH_STREAM | OB_MEDIA_IR_STREAM | OB_MEDIA_GYRO_STREAM | OB_MEDIA_ACCEL_STREAM | OB_MEDIA_CAMERA_PARAM
+                   | OB_MEDIA_DEVICE_INFO | OB_MEDIA_STREAM_INFO | OB_MEDIA_IR_LEFT_STREAM | OB_MEDIA_IR_RIGHT_STREAM, /**< All media data types */
+} OBMediaType,
+    ob_media_type, OB_MEDIA_TYPE;
+
+/**
+ * @brief Enumeration for record playback status
+ */
+typedef enum {
+    OB_MEDIA_BEGIN = 0, /**< Begin */
+    OB_MEDIA_PAUSE,     /**< Pause */
+    OB_MEDIA_RESUME,    /**< Resume */
+    OB_MEDIA_END,       /**< End */
+} OBMediaState,
+    ob_media_state, OB_MEDIA_STATE_EM;
+
+/**
+ * @brief Enumeration for depth precision levels
+ * @attention The depth precision level does not completely determine the depth unit and real precision, and the influence of the data packaging format needs to
+ * be considered. The specific unit can be obtained through getValueScale() of DepthFrame
+ */
+typedef enum {
+    OB_PRECISION_1MM,   /**< 1mm */
+    OB_PRECISION_0MM8,  /**< 0.8mm */
+    OB_PRECISION_0MM4,  /**< 0.4mm */
+    OB_PRECISION_0MM1,  /**< 0.1mm */
+    OB_PRECISION_0MM2,  /**< 0.2mm */
+    OB_PRECISION_0MM5,  /**< 0.5mm */
+    OB_PRECISION_0MM05, /**< 0.05mm */
+    OB_PRECISION_UNKNOWN,
+    OB_PRECISION_COUNT,
+} OBDepthPrecisionLevel,
+    ob_depth_precision_level, OB_DEPTH_PRECISION_LEVEL, OBDepthUnit, ob_depth_unit;
+
+/**
+ * @brief disparity parameters for disparity based camera
+ *
+ */
+typedef struct {
+    double  zpd;           // the distance to calib plane
+    double  zpps;          // zpps=z0/fx
+    float   baseline;      // baseline length, for monocular camera,it means the distance of laser to the center of IR-CMOS
+    double  fx;            // focus
+    uint8_t bitSize;       // disparity bit size（raw disp bit size，for example: MX6000 is 12, MX6600 is 14）
+    float   unit;          // reference units：unit=10 denote 1cm; unit=1 denote 1mm; unit=0.5 denote 0.5mm; and so on
+    float   minDisparity;  // dual disparity coefficient
+    uint8_t packMode;      // data pack mode
+    float   dispOffset;    // disparity offset，actual disp=chip disp + disp_offset
+    int32_t invalidDisp;   // invalid disparity，usually is 0，dual IR add a auxiliary value.
+    int32_t dispIntPlace;  // disp integer digits，default is 8，Gemini2 XL is 10
+    uint8_t isDualCamera;  // 0 monocular camera，1 dual camera
+} OBDisparityParam, ob_disparity_param;
+
+/**
+ * @brief Enumeration for TOF filter scene ranges
+ */
+typedef enum {
+    OB_TOF_FILTER_RANGE_CLOSE  = 0,   /**< Close range */
+    OB_TOF_FILTER_RANGE_MIDDLE = 1,   /**< Middle range */
+    OB_TOF_FILTER_RANGE_LONG   = 2,   /**< Long range */
+    OB_TOF_FILTER_RANGE_DEBUG  = 100, /**< Debug range */
+} OBTofFilterRange,
+    ob_tof_filter_range, TOF_FILTER_RANGE;
+/**
+ * @brief 3D point structure in the SDK
+ */
+typedef struct {
+    float x;  ///< X coordinate
+    float y;  ///< Y coordinate
+    float z;  ///< Z coordinate
+} OBPoint, ob_point, OBPoint3f, ob_point3f;
+
+/**
+ * @brief 2D point structure in the SDK
+ */
+typedef struct {
+    float x;  ///< X coordinate
+    float y;  ///< Y coordinate
+} OBPoint2f, ob_point2f;
+
+typedef struct {
+    float *xTable;  ///< table used to compute X coordinate
+    float *yTable;  ///< table used to compute Y coordinate
+    int    width;   ///< width of x and y tables
+    int    height;  ///< height of x and y tables
+} OBXYTables, ob_xy_tables;
+
+/**
+ * @brief 3D point structure with color information
+ */
+typedef struct {
+    float x;  ///< X coordinate
+    float y;  ///< Y coordinate
+    float z;  ///< Z coordinate
+    float r;  ///< Red channel component
+    float g;  ///< Green channel component
+    float b;  ///< Blue channel component
+} OBColorPoint, ob_color_point;
+
+/**
+ * @brief Compression mode
+ */
+typedef enum {
+    OB_COMPRESSION_LOSSLESS = 0, /**< Lossless compression mode */
+    OB_COMPRESSION_LOSSY    = 1, /**< Lossy compression mode */
+} OBCompressionMode,
+    ob_compression_mode, OB_COMPRESSION_MODE;
+
+/**
+ * Compression Params
+ */
+typedef struct {
+    /**
+     * Lossy compression threshold, range [0~255], recommended value is 9, the higher the threshold, the higher the compression ratio.
+     */
+    int threshold;
+} OBCompressionParams, ob_compression_params, OB_COMPRESSION_PARAMS;
+
+/**
+ * @brief TOF Exposure Threshold
+ */
+typedef struct {
+    int32_t upper;  ///< Upper threshold, unit: ms
+    int32_t lower;  ///< Lower threshold, unit: ms
+} OBTofExposureThresholdControl, ob_tof_exposure_threshold_control, TOF_EXPOSURE_THRESHOLD_CONTROL;
+
+/**
+ * @brief Sync mode
+ * @deprecated This define is deprecated, please use @ref ob_multi_device_sync_mode instead
+ */
+typedef enum {
+    /**
+     * @brief Close synchronize mode
+     * @brief Single device, neither process input trigger signal nor output trigger signal
+     * @brief Each Sensor in a single device automatically triggers
+     */
+    OB_SYNC_MODE_CLOSE = 0x00,
+
+    /**
+     * @brief Standalone synchronize mode
+     * @brief Single device, neither process input trigger signal nor output trigger signal
+     * @brief Inside single device, RGB as Major sensor: RGB -> IR/Depth/TOF
+     */
+    OB_SYNC_MODE_STANDALONE = 0x01,
+
+    /**
+     * @brief Primary synchronize mode
+     * @brief Primary device. Ignore process input trigger signal, only output trigger signal to secondary devices.
+     * @brief Inside single device, RGB as Major sensor: RGB -> IR/Depth/TOF
+     */
+    OB_SYNC_MODE_PRIMARY = 0x02,
+
+    /**
+     * @brief Secondary synchronize mode
+     * @brief Secondary device. Both process input trigger signal and output trigger signal to other devices.
+     * @brief Different sensors in a single devices receive trigger signals respectively：ext trigger -> RGB && ext trigger -> IR/Depth/TOF
+     *
+     * @attention With the current Gemini 2 device set to this mode, each Sensor receives the first external trigger signal
+     *     after the stream is turned on and starts timing self-triggering at the set frame rate until the stream is turned off
+     */
+    OB_SYNC_MODE_SECONDARY = 0x03,
+
+    /**
+     * @brief MCU Primary synchronize mode
+     * @brief Primary device. Ignore process input trigger signal, only output trigger signal to secondary devices.
+     * @brief Inside device, MCU is the primary signal source:  MCU -> RGB && MCU -> IR/Depth/TOF
+     */
+    OB_SYNC_MODE_PRIMARY_MCU_TRIGGER = 0x04,
+
+    /**
+     * @brief IR Primary synchronize mode
+     * @brief Primary device. Ignore process input trigger signal, only output trigger signal to secondary devices.
+     * @brief Inside device, IR is the primary signal source: IR/Depth/TOF -> RGB
+     */
+    OB_SYNC_MODE_PRIMARY_IR_TRIGGER = 0x05,
+
+    /**
+     * @brief Software trigger synchronize mode
+     * @brief Host, triggered by software control (receive the upper computer command trigger), at the same time to the trunk output trigger signal
+     * @brief Different sensors in a single machine receive trigger signals respectively: soft trigger -> RGB && soft trigger -> IR/Depth/TOF
+     *
+     * @attention Support product: Gemini2
+     */
+    OB_SYNC_MODE_PRIMARY_SOFT_TRIGGER = 0x06,
+
+    /**
+     * @brief Software trigger synchronize mode as secondary device
+     * @brief The slave receives the external trigger signal (the external trigger signal comes from the soft trigger host) and outputs the trigger signal to
+     * the external relay.
+     * @brief Different sensors in a single machine receive trigger signals respectively：ext trigger -> RGB && ext  trigger -> IR/Depth/TOF
+     */
+    OB_SYNC_MODE_SECONDARY_SOFT_TRIGGER = 0x07,
+
+    /**
+     * @brief Unknown type
+     */
+    OB_SYNC_MODE_UNKNOWN = 0xff,
+
+} OBSyncMode,
+    ob_sync_mode, OB_SYNC_MODE;
+
+/**
+ * @brief Device synchronization configuration
+ * @deprecated This structure is deprecated, please use @ref ob_multi_device_sync_config instead
+ */
+typedef struct {
+    /**
+     * @brief Device synchronize mode
+     */
+    OBSyncMode syncMode;
+
+    /**
+     * @brief IR Trigger signal input delay: Used to configure the delay between the IR/Depth/TOF Sensor receiving the trigger signal and starting exposure,
+     * Unit: microsecond
+     *
+     * @attention This parameter is invalid when the synchronization MODE is set to @ref OB_SYNC_MODE_PRIMARY_IR_TRIGGER
+     */
+    uint16_t irTriggerSignalInDelay;
+
+    /**
+     * @brief RGB trigger signal input delay is used to configure the delay from the time when an RGB Sensor receives the trigger signal to the time when the
+     * exposure starts. Unit: microsecond
+     *
+     * @attention This parameter is invalid when the synchronization MODE is set to @ref OB_SYNC_MODE_PRIMARY
+     */
+    uint16_t rgbTriggerSignalInDelay;
+
+    /**
+     * @brief Device trigger signal output delay, used to control the delay configuration of the host device to output trigger signals or the slave device to
+     * output trigger signals. Unit: microsecond
+     *
+     * @attention This parameter is invalid when the synchronization MODE is set to @ref OB_SYNC_MODE_CLOSE or @ref OB_SYNC_MODE_STANDALONE
+     */
+    uint16_t deviceTriggerSignalOutDelay;
+
+    /**
+     * @brief The device trigger signal output polarity is used to control the polarity configuration of the trigger signal output from the host device or the
+     * trigger signal output from the slave device
+     * @brief 0: forward pulse; 1: negative pulse
+     *
+     * @attention This parameter is invalid when the synchronization MODE is set to @ref OB_SYNC_MODE_CLOSE or @ref OB_SYNC_MODE_STANDALONE
+     */
+    uint16_t deviceTriggerSignalOutPolarity;
+
+    /**
+     * @brief MCU trigger frequency, used to configure the output frequency of MCU trigger signal in MCU master mode, unit: Hz
+     * @brief This configuration will directly affect the image output frame rate of the Sensor. Unit: FPS (frames per second)
+     *
+     * @attention This parameter is invalid only when the synchronization MODE is set to @ref OB_SYNC_MODE_PRIMARY_MCU_TRIGGER
+     */
+    uint16_t mcuTriggerFrequency;
+
+    /**
+     * @brief Device number. Users can mark the device with this number
+     */
+    uint16_t deviceId;
+
+} OBDeviceSyncConfig, ob_device_sync_config, OB_DEVICE_SYNC_CONFIG;
+/**
+ * @brief Depth work mode
+ */
+typedef struct {
+    /**
+     * @brief Checksum of work mode
+     */
+    uint8_t checksum[16];
+
+    /**
+     * @brief Name of work mode
+     */
+    char name[32];
+} OBDepthWorkMode, ob_depth_work_mode;
+
+/**
+ * @brief SequenceId fliter list item
+ */
+typedef struct {
+    int  sequenceSelectId;
+    char name[8];
+} OBSequenceIdItem, ob_sequence_id_item;
+
+/**
+ * @brief Hole fillig mode
+ */
+typedef enum {
+    OB_HOLE_FILL_TOP     = 0,
+    OB_HOLE_FILL_NEAREST = 1,  // "max" means farest for depth, and nearest for disparity; FILL_NEAREST
+    OB_HOLE_FILL_FAREST  = 2,  // FILL_FAREST
+} OBHoleFillingMode,
+    ob_hole_filling_mode;
+
+typedef struct {
+    uint8_t  magnitude;  // magnitude
+    float    alpha;      // smooth_alpha
+    uint16_t disp_diff;  // smooth_delta
+    uint16_t radius;     // hole_fill
+} OBSpatialAdvancedFilterParams, ob_spatial_advanced_filter_params;
+
+typedef enum OB_EDGE_NOISE_REMOVAL_TYPE {
+    OB_MG_FILTER  = 0,
+    OB_MGH_FILTER = 1,  // horizontal MG
+    OB_MGA_FILTER = 2,  // asym MG
+    OB_MGC_FILTER = 3,
+} OBEdgeNoiseRemovalType,
+    ob_edge_noise_removal_type;
+
+typedef struct {
+    OBEdgeNoiseRemovalType type;
+    uint16_t               marginLeftTh;
+    uint16_t               marginRightTh;
+    uint16_t               marginTopTh;
+    uint16_t               marginBottomTh;
+} OBEdgeNoiseRemovalFilterParams, ob_edge_noise_removal_filter_params;
+
+/**
+ * @brief Denoising method
+ */
+typedef enum OB_DDO_NOISE_REMOVAL_TYPE {
+    OB_NR_LUT     = 0,  // SPLIT
+    OB_NR_OVERALL = 1,  // NON_SPLIT
+} OBDDONoiseRemovalType,
+    ob_ddo_noise_removal_type;
+
+typedef struct {
+    uint16_t              max_size;
+    uint16_t              disp_diff;
+    OBDDONoiseRemovalType type;
+} OBNoiseRemovalFilterParams, ob_noise_removal_filter_params;
+
+/**
+ * @brief Control command protocol version number
+ */
+typedef struct {
+    /**
+     * @brief Major version number
+     */
+    uint8_t major;
+
+    /**
+     * @brief Minor version number
+     */
+    uint8_t minor;
+
+    /**
+     * @brief Patch version number
+     */
+    uint8_t patch;
+} OBProtocolVersion, ob_protocol_version;
+
+/**
+ * @brief Command version associated with property id
+ */
+typedef enum {
+    OB_CMD_VERSION_V0 = (uint16_t)0,  ///< Version 1.0
+    OB_CMD_VERSION_V1 = (uint16_t)1,  ///< Version 2.0
+    OB_CMD_VERSION_V2 = (uint16_t)2,  ///< Version 3.0
+    OB_CMD_VERSION_V3 = (uint16_t)3,  ///< Version 4.0
+
+    OB_CMD_VERSION_NOVERSION = (uint16_t)0xfffe,
+    OB_CMD_VERSION_INVALID   = (uint16_t)0xffff,  ///< Invalid version
+} OB_CMD_VERSION,
+    OBCmdVersion, ob_cmd_version;
+
+/**
+ * @brief IP address configuration for network devices (IPv4)
+ */
+typedef struct {
+    /**
+     * @brief DHCP status
+     *
+     * @note 0: static IP; 1: DHCP
+     */
+    uint16_t dhcp;
+
+    /**
+     * @brief IP address (IPv4, big endian: 192.168.1.10, address[0] = 192, address[1] = 168, address[2] = 1, address[3] = 10)
+     */
+    uint8_t address[4];
+
+    /**
+     * @brief Subnet mask (big endian)
+     */
+    uint8_t mask[4];
+
+    /**
+     * @brief Gateway (big endian)
+     */
+    uint8_t gateway[4];
+} OBNetIpConfig, ob_net_ip_config, DEVICE_IP_ADDR_CONFIG;
+
+#define OBDeviceIpAddrConfig OBNetIpConfig
+#define ob_device_ip_addr_config OBNetIpConfig
+
+/**
+ * @brief Device communication mode
+ */
+typedef enum {
+    OB_COMM_USB = 0x00,  ///< USB
+    OB_COMM_NET = 0x01,  ///< Ethernet
+} OBCommunicationType,
+    ob_communication_type, OB_COMMUNICATION_TYPE;
+
+/**
+ * @brief USB power status
+ */
+typedef enum {
+    OB_USB_POWER_NO_PLUGIN = 0,  ///< No plugin
+    OB_USB_POWER_5V_0A9    = 1,  ///< 5V/0.9A
+    OB_USB_POWER_5V_1A5    = 2,  ///< 5V/1.5A
+    OB_USB_POWER_5V_3A0    = 3,  ///< 5V/3.0A
+} OBUSBPowerState,
+    ob_usb_power_state;
+
+/**
+ * @brief DC power status
+ */
+typedef enum {
+    OB_DC_POWER_NO_PLUGIN = 0,  ///< No plugin
+    OB_DC_POWER_PLUGIN    = 1,  ///< Plugin
+} OBDCPowerState,
+    ob_dc_power_state;
+
+/**
+ * @brief Rotate degree
+ */
+typedef enum {
+    OB_ROTATE_DEGREE_0   = 0,    ///< Rotate 0
+    OB_ROTATE_DEGREE_90  = 90,   ///< Rotate 90
+    OB_ROTATE_DEGREE_180 = 180,  ///< Rotate 180
+    OB_ROTATE_DEGREE_270 = 270,  ///< Rotate 270
+} ob_rotate_degree_type,
+    OBRotateDegreeType;
+
+/**
+ * @brief Power line frequency mode, for color camera anti-flicker configuration
+ */
+typedef enum {
+    OB_POWER_LINE_FREQ_MODE_CLOSE = 0,  ///< Close
+    OB_POWER_LINE_FREQ_MODE_50HZ  = 1,  ///< 50Hz
+    OB_POWER_LINE_FREQ_MODE_60HZ  = 2,  ///< 60Hz
+} ob_power_line_freq_mode,
+    OBPowerLineFreqMode;
+
+/**
+ * @brief Frame aggregate output mode
+ */
+typedef enum {
+    /**
+     * @brief Only FrameSet that contains all types of data frames will be output
+     */
+    OB_FRAME_AGGREGATE_OUTPUT_ALL_TYPE_FRAME_REQUIRE = 0,
+
+    /**
+     * @brief Color Frame Require output mode
+     * @brief Suitable for Color using H264, H265 and other inter-frame encoding format open stream
+     *
+     * @attention In this mode, the user may return null when getting a non-Color type data frame from the acquired FrameSet
+     */
+    OB_FRAME_AGGREGATE_OUTPUT_COLOR_FRAME_REQUIRE,
+
+    /**
+     * @brief FrameSet for any case will be output
+     *
+     * @attention In this mode, the user may return null when getting the specified type of data frame from the acquired FrameSet
+     */
+    OB_FRAME_AGGREGATE_OUTPUT_ANY_SITUATION,
+} OB_FRAME_AGGREGATE_OUTPUT_MODE,
+    OBFrameAggregateOutputMode, ob_frame_aggregate_output_mode;
+#define OB_FRAME_AGGREGATE_OUTPUT_FULL_FRAME_REQUIRE OB_FRAME_AGGREGATE_OUTPUT_ALL_TYPE_FRAME_REQUIRE
+
+/**
+ * @brief Enumeration of point cloud coordinate system types
+ */
+typedef enum {
+    OB_LEFT_HAND_COORDINATE_SYSTEM  = 0,
+    OB_RIGHT_HAND_COORDINATE_SYSTEM = 1,
+} OB_COORDINATE_SYSTEM_TYPE,
+    OBCoordinateSystemType, ob_coordinate_system_type;
+
+/**
+ * @brief Enumeration of device development modes
+ */
+typedef enum {
+    /**
+     * @brief User mode (default mode), which provides full camera device functionality
+     */
+    OB_USER_MODE = 0,
+
+    /**
+     * @brief Developer mode, which allows developers to access the operating system and software/hardware resources on the device directly
+     */
+    OB_DEVELOPER_MODE = 1,
+} OB_DEVICE_DEVELOPMENT_MODE,
+    OBDeviceDevelopmentMode, ob_device_development_mode;
+
+/**
+ * @brief The synchronization mode of the device.
+ */
+typedef enum {
+
+    /**
+     * @brief free run mode
+     * @brief The device does not synchronize with other devices,
+     * @brief The Color and Depth can be set to different frame rates.
+     */
+    OB_MULTI_DEVICE_SYNC_MODE_FREE_RUN = 1 << 0,
+
+    /**
+     * @brief standalone mode
+     * @brief The device does not synchronize with other devices.
+     * @brief The Color and Depth should be set to same frame rates, the Color and Depth will be synchronized.
+     */
+    OB_MULTI_DEVICE_SYNC_MODE_STANDALONE = 1 << 1,
+
+    /**
+     * @brief primary mode
+     * @brief The device is the primary device in the multi-device system, it will output the trigger signal via VSYNC_OUT pin on synchronization port by
+     * default.
+     * @brief The Color and Depth should be set to same frame rates, the Color and Depth will be synchronized and can be adjusted by @ref colorDelayUs, @ref
+     * depthDelayUs or @ref trigger2ImageDelayUs.
+     */
+    OB_MULTI_DEVICE_SYNC_MODE_PRIMARY = 1 << 2,
+
+    /**
+     * @brief secondary mode
+     * @brief The device is the secondary device in the multi-device system, it will receive the trigger signal via VSYNC_IN pin on synchronization port. It
+     * will out the trigger signal via VSYNC_OUT pin on synchronization port by default.
+     * @brief The Color and Depth should be set to same frame rates, the Color and Depth will be synchronized and can be adjusted by @ref colorDelayUs, @ref
+     * depthDelayUs or @ref trigger2ImageDelayUs.
+     * @brief After starting the stream, the device will wait for the trigger signal to start capturing images, and will stop capturing images when the trigger
+     * signal is stopped.
+     *
+     * @attention The frequency of the trigger signal should be same as the frame rate of the stream profile which is set when starting the stream.
+     */
+    OB_MULTI_DEVICE_SYNC_MODE_SECONDARY = 1 << 3,
+
+    /**
+     * @brief secondary synced mode
+     * @brief The device is the secondary device in the multi-device system, it will receive the trigger signal via VSYNC_IN pin on synchronization port. It
+     * will out the trigger signal via VSYNC_OUT pin on synchronization port by default.
+     * @brief The Color and Depth should be set to same frame rates, the Color and Depth will be synchronized and can be adjusted by @ref colorDelayUs, @ref
+     * depthDelayUs or @ref trigger2ImageDelayUs.
+     * @brief After starting the stream, the device will be immediately start capturing images, and will adjust the capture time when the trigger signal is
+     * received to synchronize with the primary device. If the trigger signal is stopped, the device will still capture images.
+     *
+     * @attention The frequency of the trigger signal should be same as the frame rate of the stream profile which is set when starting the stream.
+     */
+    OB_MULTI_DEVICE_SYNC_MODE_SECONDARY_SYNCED = 1 << 4,
+
+    /**
+     * @brief software triggering mode
+     * @brief The device will start one time image capture after receiving the capture command and will output the trigger signal via VSYNC_OUT pin by default.
+     * The capture command can be sent form host by call @ref ob_device_trigger_capture. The number of images captured each time can be set by @ref
+     * framesPerTrigger.
+     * @brief The Color and Depth should be set to same frame rates, the Color and Depth will be synchronized and can be adjusted by @ref colorDelayUs, @ref
+     * depthDelayUs or @ref trigger2ImageDelayUs.
+     *
+     * @brief The frequency of the user call @ref ob_device_trigger_capture to send the capture command multiplied by the number of frames per trigger should be
+     * less than the frame rate of the stream profile which is set when starting the stream.
+     */
+    OB_MULTI_DEVICE_SYNC_MODE_SOFTWARE_TRIGGERING = 1 << 5,
+
+    /**
+     * @brief hardware triggering mode
+     * @brief The device will start one time image capture after receiving the trigger signal via VSYNC_IN pin on synchronization port and will output the
+     * trigger signal via VSYNC_OUT pin by default. The number of images captured each time can be set by @ref framesPerTrigger.
+     * @brief The Color and Depth should be set to same frame rates, the Color and Depth will be synchronized and can be adjusted by @ref colorDelayUs, @ref
+     * depthDelayUs or @ref trigger2ImageDelayUs.
+     *
+     * @attention The frequency of the trigger signal multiplied by the number of frames per trigger should be less than the frame rate of the stream profile
+     * which is set when starting the stream.
+     * @attention The trigger signal input via VSYNC_IN pin on synchronization port should be ouput by other device via VSYNC_OUT pin in hardware triggering
+     * mode or software triggering mode.
+     * @attention Due to different models may have different signal input requirements, please do not use different models to output trigger
+     * signal as input-trigger signal.
+     */
+    OB_MULTI_DEVICE_SYNC_MODE_HARDWARE_TRIGGERING = 1 << 6,
+
+} ob_multi_device_sync_mode,
+    OBMultiDeviceSyncMode;
+
+/**
+ * @brief The synchronization configuration of the device.
+ */
+typedef struct {
+    /**
+     * @brief The sync mode of the device.
+     */
+    OBMultiDeviceSyncMode syncMode;
+
+    /**
+     * @brief The delay time of the depth image capture after receiving the capture command or trigger signal in microseconds.
+     *
+     * @attention This parameter is only valid for some models， please refer to the product manual for details.
+     */
+    int depthDelayUs;
+
+    /**
+     * @brief The delay time of the color image capture after receiving the capture command or trigger signal in microseconds.
+     *
+     * @attention This parameter is only valid for some models， please refer to the product manual for details.
+     */
+    int colorDelayUs;
+
+    /**
+     * @brief The delay time of the image capture after receiving the capture command or trigger signal in microseconds.
+     * @brief The depth and color images are captured synchronously as the product design and can not change the delay between the depth and color images.
+     *
+     * @attention For Orbbec Astra 2 device, this parameter is valid only when the @ref triggerOutDelayUs is set to 0.
+     * @attention This parameter is only valid for some models to replace @ref depthDelayUs and @ref colorDelayUs, please refer to the product manual for
+     * details.
+     */
+    int trigger2ImageDelayUs;
+
+    /**
+     * @brief Trigger signal output enable flag.
+     * @brief After the trigger signal output is enabled, the trigger signal will be output when the capture command or trigger signal is received. User can
+     * adjust the delay time of the trigger signal output by @ref triggerOutDelayUs.
+     *
+     * @attention For some models, the trigger signal output is always enabled and cannot be disabled.
+     * @attention If device is in the @ref OB_MULTI_DEVICE_SYNC_MODE_FREE_RUN or @ref OB_MULTI_DEVICE_SYNC_MODE_STANDALONE mode, the trigger signal output is
+     * always disabled. Set this parameter to true will not take effect.
+     */
+    bool triggerOutEnable;
+
+    /**
+     * @brief The delay time of the trigger signal output after receiving the capture command or trigger signal in microseconds.
+     *
+     * @attention For Orbbec Astra 2 device, only supported -1 and 0. -1 means the trigger signal output delay is automatically adjusted by the device, 0 means
+     * the trigger signal output is disabled.
+     */
+    int triggerOutDelayUs;
+
+    /**
+     * @brief The frame number of each stream after each trigger in triggering mode.
+     *
+     * @attention This parameter is only valid when the triggering mode is set to @ref OB_MULTI_DEVICE_SYNC_MODE_HARDWARE_TRIGGERING or @ref
+     * OB_MULTI_DEVICE_SYNC_MODE_SOFTWARE_TRIGGERING.
+     * @attention The trigger frequency multiplied by the number of frames per trigger cannot exceed the maximum frame rate of the stream profile which is set
+     * when starting the stream.
+     */
+    int framesPerTrigger;
+} ob_multi_device_sync_config, OBMultiDeviceSyncConfig;
+
+/**
+ * @brief The timestamp reset configuration of the device.
+ *
+ */
+typedef struct {
+    /**
+     * @brief Whether to enable the timestamp reset function.
+     * @brief If the timestamp reset function is enabled, the timer for calculating the timestamp for output frames will be reset to 0 when the timestamp reset
+     * command or timestamp reset signal is received, and one timestamp reset signal will be output via TIMER_SYNC_OUT pin on synchronization port by default.
+     * The timestamp reset signal is input via TIMER_SYNC_IN pin on the synchronization port.
+     *
+     * @attention For some models, the timestamp reset function is always enabled and cannot be disabled.
+     */
+    bool enable;
+
+    /**
+     * @brief The delay time of executing the timestamp reset function after receiving the command or signal in microseconds.
+     */
+    int timestamp_reset_delay_us;
+
+    /**
+     * @brief the timestamp reset signal output enable flag.
+     *
+     * @attention For some models, the timestamp reset signal output is always enabled and cannot be disabled.
+     */
+    bool timestamp_reset_signal_output_enable;
+} ob_device_timestamp_reset_config, OBDeviceTimestampResetConfig;
+
+/**
+ * @brief Baseline calibration parameters
+ */
+typedef struct {
+    /**
+     * @brief Baseline length
+     */
+    float baseline;
+    /**
+     * @brief Calibration distance
+     */
+    float zpd;
+} BASELINE_CALIBRATION_PARAM, ob_baseline_calibration_param, OBBaselineCalibrationParam;
+
+/**
+ * @brief HDR Configuration
+ */
+typedef struct {
+
+    /**
+     * @brief Enable/disable HDR, after enabling HDR, the exposure_1 and gain_1 will be used as the first exposure and gain, and the exposure_2 and gain_2 will
+     * be used as the second exposure and gain. The output image will be alternately exposed and gain between the first and second
+     * exposure and gain.
+     *
+     * @attention After enabling HDR, the auto exposure will be disabled.
+     */
+    uint8_t  enable;
+    uint8_t  sequence_name;  ///< Sequence name
+    uint32_t exposure_1;     ///< Exposure time 1
+    uint32_t gain_1;         ///< Gain 1
+    uint32_t exposure_2;     ///< Exposure time 2
+    uint32_t gain_2;         ///< Gain 2
+} HDR_CONFIG, ob_hdr_config, OBHdrConfig;
+
+/**
+ * @brief The rect of the region of interest
+ */
+typedef struct {
+    int16_t x0_left;
+    int16_t y0_top;
+    int16_t x1_right;
+    int16_t y1_bottom;
+} AE_ROI, ob_region_of_interest, OBRegionOfInterest;
+
+typedef enum {
+    OB_FILTER_CONFIG_VALUE_TYPE_INVALID = -1,
+    OB_FILTER_CONFIG_VALUE_TYPE_INT     = 0,
+    OB_FILTER_CONFIG_VALUE_TYPE_FLOAT   = 1,
+    OB_FILTER_CONFIG_VALUE_TYPE_BOOLEAN = 2,
+} OBFilterConfigValueType,
+    ob_filter_config_value_type;
+/**
+ * @brief  Configuration Item for the filter
+ */
+typedef struct {
+    const char             *name;  ///< Name of the configuration item
+    OBFilterConfigValueType type;  ///< Value type of the configuration item
+    double                  min;   ///< Minimum value casted to double
+    double                  max;   ///< Maximum value casted to double
+    double                  step;  ///< Step value casted to double
+    double                  def;   ///< Default value casted to double
+    const char             *desc;  ///< Description of the configuration item
+} OBFilterConfigSchemaItem, ob_filter_config_schema_item;
+
+/**
+ * @brief struct of serial number
+ */
+typedef struct {
+    char numberStr[16];
+} OBDeviceSerialNumber, ob_device_serial_number, OBSerialNumber, ob_serial_number;
+
+/**
+ * @brief Frame metadata types
+ * @brief The frame metadata is a set of meta info generated by the device for current individual frame.
+ */
+typedef enum {
+    /**
+     * @brief Timestamp when the frame is captured.
+     * @attention Different device models may have different units. It is recommended to use the timestamp related functions to get the timestamp in the
+     * correct units.
+     */
+    OB_FRAME_METADATA_TYPE_TIMESTAMP = 0,
+
+    /**
+     * @brief Timestamp in the middle of the capture.
+     * @brief Usually is the middle of the exposure time.
+     *
+     * @attention Different device models may have different units.
+     */
+    OB_FRAME_METADATA_TYPE_SENSOR_TIMESTAMP = 1,
+
+    /**
+     * @brief The number of current frame.
+     */
+    OB_FRAME_METADATA_TYPE_FRAME_NUMBER = 2,
+
+    /**
+     * @brief Auto exposure status
+     * @brief If the value is 0, it means the auto exposure is disabled. Otherwise, it means the auto exposure is enabled.
+     */
+    OB_FRAME_METADATA_TYPE_AUTO_EXPOSURE = 3,
+
+    /**
+     * @brief Exposure time
+     *
+     * @attention Different sensor may have different units. Usually, it is 100us for color sensor and 1us for depth/infrared sensor.
+     */
+    OB_FRAME_METADATA_TYPE_EXPOSURE = 4,
+
+    /**
+     * @brief Gain
+     *
+     * @attention For some device models, the gain value represents the gain level, not the multiplier.
+     */
+    OB_FRAME_METADATA_TYPE_GAIN = 5,
+
+    /**
+     * @brief Auto white balance status
+     * @brief If the value is 0, it means the auto white balance is disabled. Otherwise, it means the auto white balance is enabled.
+     */
+    OB_FRAME_METADATA_TYPE_AUTO_WHITE_BALANCE = 6,
+
+    /**
+     * @brief White balance
+     */
+    OB_FRAME_METADATA_TYPE_WHITE_BALANCE = 7,
+
+    /**
+     * @brief Brightness
+     */
+    OB_FRAME_METADATA_TYPE_BRIGHTNESS = 8,
+
+    /**
+     * @brief Contrast
+     */
+    OB_FRAME_METADATA_TYPE_CONTRAST = 9,
+
+    /**
+     * @brief Saturation
+     */
+    OB_FRAME_METADATA_TYPE_SATURATION = 10,
+
+    /**
+     * @brief Sharpness
+     */
+    OB_FRAME_METADATA_TYPE_SHARPNESS = 11,
+
+    /**
+     * @brief Backlight compensation
+     */
+    OB_FRAME_METADATA_TYPE_BACKLIGHT_COMPENSATION = 12,
+
+    /**
+     * @brief Hue
+     */
+    OB_FRAME_METADATA_TYPE_HUE = 13,
+
+    /**
+     * @brief Gamma
+     */
+    OB_FRAME_METADATA_TYPE_GAMMA = 14,
+
+    /**
+     * @brief Power line frequency
+     * @brief For anti-flickering， 0：Close， 1： 50Hz， 2： 60Hz， 3： Auto
+     */
+    OB_FRAME_METADATA_TYPE_POWER_LINE_FREQUENCY = 15,
+
+    /**
+     * @brief Low light compensation
+     *
+     * @attention The low light compensation is a feature inside the device，and can not manually control it.
+     */
+    OB_FRAME_METADATA_TYPE_LOW_LIGHT_COMPENSATION = 16,
+
+    /**
+     * @brief Manual white balance setting
+     */
+    OB_FRAME_METADATA_TYPE_MANUAL_WHITE_BALANCE = 17,
+
+    /**
+     * @brief Actual frame rate
+     * @brief The actual frame rate will be calculated according to the exposure time and other parameters.
+     */
+    OB_FRAME_METADATA_TYPE_ACTUAL_FRAME_RATE = 18,
+
+    /**
+     * @brief Frame rate
+     */
+    OB_FRAME_METADATA_TYPE_FRAME_RATE = 19,
+
+    /**
+     * @brief Left region of interest for the auto exposure Algorithm.
+     */
+    OB_FRAME_METADATA_TYPE_AE_ROI_LEFT = 20,
+
+    /**
+     * @brief Top region of interest for the auto exposure Algorithm.
+     */
+    OB_FRAME_METADATA_TYPE_AE_ROI_TOP = 21,
+
+    /**
+     * @brief Right region of interest for the auto exposure Algorithm.
+     */
+    OB_FRAME_METADATA_TYPE_AE_ROI_RIGHT = 22,
+
+    /**
+     * @brief Bottom region of interest for the auto exposure Algorithm.
+     */
+    OB_FRAME_METADATA_TYPE_AE_ROI_BOTTOM = 23,
+
+    /**
+     * @brief Exposure priority
+     */
+    OB_FRAME_METADATA_TYPE_EXPOSURE_PRIORITY = 24,
+
+    /**
+     * @brief HDR sequence name
+     */
+    OB_FRAME_METADATA_TYPE_HDR_SEQUENCE_NAME = 25,
+
+    /**
+     * @brief HDR sequence size
+     */
+    OB_FRAME_METADATA_TYPE_HDR_SEQUENCE_SIZE = 26,
+
+    /**
+     * @brief HDR sequence index
+     */
+    OB_FRAME_METADATA_TYPE_HDR_SEQUENCE_INDEX = 27,
+
+    /**
+     * @brief Laser power value in mW
+     *
+     * @attention The laser power value is an approximate estimation.
+     */
+    OB_FRAME_METADATA_TYPE_LASER_POWER = 28,
+
+    /**
+     * @brief Laser power level
+     */
+    OB_FRAME_METADATA_TYPE_LASER_POWER_LEVEL = 29,
+
+    /**
+     * @brief Laser status
+     * @brief 0: Laser off, 1: Laser on
+     */
+    OB_FRAME_METADATA_TYPE_LASER_STATUS = 30,
+
+    /**
+     * @brief GPIO input data
+     */
+    OB_FRAME_METADATA_TYPE_GPIO_INPUT_DATA = 31,
+
+    /**
+     * @brief The number of frame metadata types, using for types iterating
+     * @attention It is not a valid frame metadata type
+     */
+    OB_FRAME_METADATA_TYPE_COUNT,
+} ob_frame_metadata_type,
+    OBFrameMetadataType;
+
+// For compatibility
+#define OB_FRAME_METADATA_TYPE_LASER_POWER_MODE OB_FRAME_METADATA_TYPE_LASER_POWER_LEVEL
+#define OB_FRAME_METADATA_TYPE_EMITTER_MODE OB_FRAME_METADATA_TYPE_LASER_STATUS
+
+/**
+ * @brief Callback for file transfer
+ *
+ * @param state Transmission status
+ * @param message Transfer status information
+ * @param percent Transfer progress percentage
+ * @param user_data User-defined data
+ */
+typedef void (*ob_file_send_callback)(ob_file_tran_state state, const char *message, uint8_t percent, void *user_data);
+
+/**
+ * @brief Callback for firmware upgrade
+ *
+ * @param state Upgrade status
+ * @param message Upgrade status information
+ * @param percent Upgrade progress percentage
+ * @param user_data User-defined data
+ */
+typedef void (*ob_device_fw_update_callback)(ob_fw_update_state state, const char *message, uint8_t percent, void *user_data);
+
+/**
+ * @brief Callback for device status
+ *
+ * @param state Device status
+ * @param message Device status information
+ * @param user_data User-defined data
+ */
+typedef void (*ob_device_state_callback)(ob_device_state state, const char *message, void *user_data);
+
+/**
+ * @brief Callback for writing data
+ *
+ * @param state Write data status
+ * @param percent Write data percentage
+ * @param user_data User-defined data
+ */
+typedef void (*ob_set_data_callback)(ob_data_tran_state state, uint8_t percent, void *user_data);
+
+/**
+ * @brief Callback for reading data
+ *
+ * @param state Read data status
+ * @param dataChunk Read the returned data block
+ * @param user_data User-defined data
+ */
+typedef void (*ob_get_data_callback)(ob_data_tran_state state, ob_data_chunk *dataChunk, void *user_data);
+
+/**
+ * @brief Callback for media status (recording and playback)
+ *
+ * @param state Condition
+ * @param user_data User-defined data
+ */
+typedef void (*ob_media_state_callback)(ob_media_state state, void *user_data);
+
+/**
+ * @brief Callback for device change
+ *
+ * @param removed List of deleted (dropped) devices
+ * @param added List of added (online) devices
+ * @param user_data User-defined data
+ */
+typedef void (*ob_device_changed_callback)(ob_device_list *removed, ob_device_list *added, void *user_data);
+
+// typedef void (*ob_net_device_added_callback)(const char *added, void *user_data);
+// typedef void (*ob_net_device_removed_callback)(const char *removed, void *user_data);
+
+/**
+ * @brief Callback for frame
+ *
+ * @param frame Frame object
+ * @param user_data User-defined data
+ */
+typedef void (*ob_frame_callback)(ob_frame *frame, void *user_data);
+#define ob_filter_callback ob_frame_callback
+#define ob_playback_callback ob_frame_callback
+
+/**
+ * @brief Callback for frameset
+ *
+ * @param frameset Frameset object
+ * @param user_data User-defined data
+ */
+typedef void (*ob_frameset_callback)(ob_frame *frameset, void *user_data);
+
+/**
+ * @brief Customize the delete callback
+ *
+ * @param buffer Data that needs to be deleted
+ * @param user_data User-defined data
+ */
+typedef void(ob_frame_destroy_callback)(uint8_t *buffer, void *user_data);
+
+/**
+ * @brief Callback for receiving log
+ *
+ * @param severity Current log level
+ * @param message Log message
+ * @param user_data User-defined data
+ */
+typedef void(ob_log_callback)(ob_log_severity severity, const char *message, void *user_data);
+
+/**
+ * @brief Check if the sensor_type is a video sensor
+ *
+ * @param sensor_type Sensor type to check
+ * @return True if sensor_type is a video sensor, false otherwise
+ */
+#define ob_is_video_sensor_type(sensor_type)                                                                                             \
+    (sensor_type == OB_SENSOR_COLOR || sensor_type == OB_SENSOR_DEPTH || sensor_type == OB_SENSOR_IR || sensor_type == OB_SENSOR_IR_LEFT \
+     || sensor_type == OB_SENSOR_IR_RIGHT)
+
+/**
+ * @brief check if the stream_type is a video stream
+ *
+ * @param stream_type Stream type to check
+ * @return True if stream_type is a video stream, false otherwise
+ */
+#define ob_is_video_stream_type(stream_type)                                                                                             \
+    (stream_type == OB_STREAM_COLOR || stream_type == OB_STREAM_DEPTH || stream_type == OB_STREAM_IR || stream_type == OB_STREAM_IR_LEFT \
+     || stream_type == OB_STREAM_IR_RIGHT || stream_type == OB_STREAM_VIDEO)
+
+/**
+ * @brief Check if sensor_type is an IR sensor
+ *
+ * @param sensor_type Sensor type to check
+ * @return True if sensor_type is an IR sensor, false otherwise
+ */
+#define is_ir_sensor(sensor_type) (sensor_type == OB_SENSOR_IR || sensor_type == OB_SENSOR_IR_LEFT || sensor_type == OB_SENSOR_IR_RIGHT)
+#define isIRSensor is_ir_sensor
+
+/**
+ * @brief Check if stream_type is an IR stream
+ *
+ * @param stream_type Stream type to check
+ * @return True if stream_type is an IR stream, false otherwise
+ */
+#define is_ir_stream(stream_type) (stream_type == OB_STREAM_IR || stream_type == OB_STREAM_IR_LEFT || stream_type == OB_STREAM_IR_RIGHT)
+#define isIRStream is_ir_stream
+
+/**
+ * @brief Check if frame_type is an IR frame
+ *
+ * @param frame_type Frame type to check
+ * @return True if frame_type is an IR frame, false otherwise
+ */
+#define is_ir_frame(frame_type) (frame_type == OB_FRAME_IR || frame_type == OB_FRAME_IR_LEFT || frame_type == OB_FRAME_IR_RIGHT)
+#define isIRFrame is_ir_frame
+
+/**
+ * @brief The default Decrypt Key
+ */
+#define OB_DEFAULT_DECRYPT_KEY (nullptr)
+
+#ifdef __cplusplus
+}
+#endif
+
+#pragma pack(pop)
+
diff --git a/include/libobsensor/h/Pipeline.h b/include/libobsensor/h/Pipeline.h
new file mode 100644
index 00000000..b88f6eac
--- /dev/null
+++ b/include/libobsensor/h/Pipeline.h
@@ -0,0 +1,335 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+/**
+ * @file Pipeline.h
+ * @brief The SDK's advanced API can quickly implement functions such as switching streaming, frame synchronization, software filtering, etc., suitable for
+ * applications, and the algorithm focuses on rgbd data stream scenarios. If you are on real-time or need to handle synchronization separately, align the scene.
+ * Please use the interface of Device's Lower API.
+ */
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "ObTypes.h"
+
+/**
+ * @brief Create a pipeline object
+ *
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return ob_pipeline* return the pipeline object
+ */
+OB_EXPORT ob_pipeline *ob_create_pipeline(ob_error **error);
+
+/**
+ * @brief Using device objects to create pipeline objects
+ *
+ * @param[in] dev Device object used to create pipeline
+ * @param[out] error  Pointer to an error object that will be set if an error occurs.
+ * @return ob_pipeline* return the pipeline object
+ */
+OB_EXPORT ob_pipeline *ob_create_pipeline_with_device(const ob_device *dev, ob_error **error);
+
+/**
+ * @brief Delete pipeline objects
+ *
+ * @param[in] pipeline  The pipeline object to be deleted
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ */
+OB_EXPORT void ob_delete_pipeline(ob_pipeline *pipeline, ob_error **error);
+
+/**
+ * @brief Start the pipeline with default parameters
+ *
+ * @param[in] pipeline  pipeline object
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ */
+OB_EXPORT void ob_pipeline_start(ob_pipeline *pipeline, ob_error **error);
+
+/**
+ * @brief Start the pipeline with configuration parameters
+ *
+ * @param[in] pipeline  pipeline object
+ * @param[in] config Parameters to be configured
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ */
+OB_EXPORT void ob_pipeline_start_with_config(ob_pipeline *pipeline, const ob_config *config, ob_error **error);
+
+/**
+ * @brief Start the pipeline and set the frame collection data callback
+ *
+ * @attention After start the pipeline with this interface, the frames will be output to the callback function and cannot be obtained frames by call
+ * @ob_pipeline_wait_for_frameset
+ *
+ * @param[in] pipeline pipeline object
+ * @param[in] config  Parameters to be configured
+ * @param[in] callback Trigger a callback when all frame data in the frameset arrives
+ * @param[in] user_data  Pass in any user data and get it from the callback
+ * @param[out] error  Pointer to an error object that will be set if an error occurs.
+ */
+OB_EXPORT void ob_pipeline_start_with_callback(ob_pipeline *pipeline, const ob_config *config, ob_frameset_callback callback, void *user_data,
+                                               ob_error **error);
+
+/**
+ * @brief Stop pipeline
+ *
+ * @param[in] pipeline pipeline object
+ * @param[out] error  Pointer to an error object that will be set if an error occurs.
+ */
+OB_EXPORT void ob_pipeline_stop(ob_pipeline *pipeline, ob_error **error);
+
+/**
+ * @brief Get the configuration object associated with the pipeline
+ * @brief Returns default configuration if the user has not configured
+ *
+ * @param[in] pipeline The pipeline object
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return ob_config* The configuration object
+ */
+OB_EXPORT ob_config *ob_pipeline_get_config(const ob_pipeline *pipeline, ob_error **error);
+
+/**
+ * @brief Switch the corresponding configuration
+ *
+ * @param[in] pipeline The pipeline object
+ * @param[in] config The pipeline configuration
+ * @param[out] error Log error messages
+ */
+OB_EXPORT void ob_pipeline_switch_config(ob_pipeline *pipeline, ob_config *config, ob_error **error);
+
+/**
+ * @brief Wait for a set of frames to be returned synchronously
+ *
+ * @param[in] pipeline The pipeline object
+ * @param[in] timeout_ms The timeout for waiting (in milliseconds)
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return ob_frame* The frameset that was waited for. A frameset is a special frame that can be used to obtain independent frames from the set.
+ */
+OB_EXPORT ob_frame *ob_pipeline_wait_for_frameset(ob_pipeline *pipeline, uint32_t timeout_ms, ob_error **error);
+
+/**
+ * @brief Get the device object associated with the pipeline
+ *
+ * @param[in] pipeline The pipeline object
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return ob_device* The device object
+ */
+OB_EXPORT ob_device *ob_pipeline_get_device(const ob_pipeline *pipeline, ob_error **error);
+
+/**
+ * @brief Get the stream profile list associated with the pipeline
+ *
+ * @param[in] pipeline The pipeline object
+ * @param[in] sensorType The sensor type. The supported sensor types can be obtained through the ob_device_get_sensor_list() interface.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return ob_stream_profile_list* The stream profile list
+ */
+OB_EXPORT ob_stream_profile_list *ob_pipeline_get_stream_profile_list(const ob_pipeline *pipeline, ob_sensor_type sensorType, ob_error **error);
+
+/**
+ * @brief Enable frame synchronization
+ * @brief Synchronize the frames of different streams by using the timestamp information of the frames.
+ * @brief Dynamically (when pipeline is started) enable/disable frame synchronization is allowed.
+ *
+ * @param[in] pipeline The pipeline object
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ */
+OB_EXPORT void ob_pipeline_enable_frame_sync(ob_pipeline *pipeline, ob_error **error);
+
+/**
+ * @brief Disable frame synchronization
+ *
+ * @param[in] pipeline The pipeline object
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ */
+OB_EXPORT void ob_pipeline_disable_frame_sync(ob_pipeline *pipeline, ob_error **error);
+
+/**
+ * @brief Return a list of D2C-enabled depth sensor resolutions corresponding to the input color sensor resolution
+ *
+ * @param[in] pipeline The pipeline object
+ * @param[in] color_profile The input profile of the color sensor
+ * @param[in] align_mode The input align mode
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return ob_stream_profile_list* The list of D2C-enabled depth sensor resolutions
+ */
+OB_EXPORT ob_stream_profile_list *ob_get_d2c_depth_profile_list(const ob_pipeline *pipeline, const ob_stream_profile *color_profile, ob_align_mode align_mode,
+                                                                ob_error **error);
+
+/**
+ * @brief Create the pipeline configuration
+ *
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return ob_config* The configuration object
+ */
+OB_EXPORT ob_config *ob_create_config(ob_error **error);
+
+/**
+ * @brief Delete the pipeline configuration
+ *
+ * @param[in] config The configuration to be deleted
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ */
+OB_EXPORT void ob_delete_config(ob_config *config, ob_error **error);
+
+/**
+ * @brief Enable a stream with default profile
+ *
+ * @param[in] config The pipeline configuration object
+ * @param[in] stream_type The type of the stream to be enabled
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ */
+OB_EXPORT void ob_config_enable_stream(ob_config *config, ob_stream_type stream_type, ob_error **error);
+
+/**
+ * @brief Enable all streams in the pipeline configuration
+ *
+ * @param[in] config The pipeline configuration
+ * @param[out] error Log error messages
+ */
+OB_EXPORT void ob_config_enable_all_stream(ob_config *config, ob_error **error);
+
+/**
+ * @brief Enable a stream according to the stream profile
+ *
+ * @param[in] config The pipeline configuration object
+ * @param[in] profile The stream profile to be enabled
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ */
+OB_EXPORT void ob_config_enable_stream_with_stream_profile(ob_config *config, const ob_stream_profile *profile, ob_error **error);
+
+/**
+ * @brief Enable video stream with specified parameters
+ *
+ * @attention The stream_type should be a video stream type, such as OB_STREAM_IR, OB_STREAM_COLOR, OB_STREAM_DEPTH, etc.
+ *
+ * @param config[in] The pipeline configuration object
+ * @param stream_type[in] The type of the stream to be enabled
+ * @param width[in] The width of the video stream
+ * @param height[in] The height of the video stream
+ * @param fps[in] The frame rate of the video stream
+ * @param format[in] The format of the video stream
+ * @param error[out] Pointer to an error object that will be set if an error occurs.
+ */
+OB_EXPORT void ob_config_enable_video_stream(ob_config *config, ob_stream_type stream_type, uint32_t width, uint32_t height, uint32_t fps, ob_format format,
+                                             ob_error **error);
+
+/**
+ * @brief Enable accelerometer stream with specified parameters
+ *
+ * @param config[in] The pipeline configuration object
+ * @param full_scale_range[in] The full scale range of the accelerometer
+ * @param sample_rate[in] The sample rate of the accelerometer
+ * @param error[out] Pointer to an error object that will be set if an error occurs.
+ */
+OB_EXPORT void ob_config_enable_accel_stream(ob_config *config, ob_accel_full_scale_range full_scale_range, ob_accel_sample_rate sample_rate, ob_error **error);
+
+/**
+ * @brief Enable gyroscope stream with specified parameters
+ *
+ * @param config[in] The pipeline configuration object
+ * @param full_scale_range[in] The full scale range of the gyroscope
+ * @param sample_rate[in] The sample rate of the gyroscope
+ * @param error[out] Pointer to an error object that will be set if an error occurs.
+ */
+OB_EXPORT void ob_config_enable_gyro_stream(ob_config *config, ob_gyro_full_scale_range full_scale_range, ob_gyro_sample_rate sample_rate, ob_error **error);
+
+/**
+ * @brief  Get the enabled stream profile list in the pipeline configuration
+ *
+ * @param config The pipeline configuration object
+ * @param error Pointer to an error object that will be set if an error occurs.
+ * @return ob_stream_profile_list* The enabled stream profile list, should be released by @ref ob_delete_stream_profile_list after use
+ */
+OB_EXPORT ob_stream_profile_list *ob_config_get_enabled_stream_profile_list(const ob_config *config, ob_error **error);
+
+/**
+ * @brief Disable a specific stream in the pipeline configuration
+ *
+ * @param[in] config The pipeline configuration object
+ * @param[in] type The type of stream to be disabled
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ */
+OB_EXPORT void ob_config_disable_stream(ob_config *config, ob_stream_type type, ob_error **error);
+
+/**
+ * @brief Disable all streams in the pipeline configuration
+ *
+ * @param[in] config The pipeline configuration object
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ */
+OB_EXPORT void ob_config_disable_all_stream(ob_config *config, ob_error **error);
+
+/**
+ * @brief Set the alignment mode for the pipeline configuration
+ *
+ * @param[in] config The pipeline configuration object
+ * @param[in] mode The alignment mode to be set
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ */
+OB_EXPORT void ob_config_set_align_mode(ob_config *config, ob_align_mode mode, ob_error **error);
+
+/**
+ * @brief Set whether depth scaling is required after enable depth to color alignment
+ * @brief After enabling depth to color alignment, the depth image may need to be scaled to match the color image size.
+ *
+ * @param[in] config The pipeline configuration object
+ * @param[in] enable Whether scaling is required
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ */
+OB_EXPORT void ob_config_set_depth_scale_after_align_require(ob_config *config, bool enable, ob_error **error);
+
+/**
+ * @brief Set the frame aggregation output mode for the pipeline configuration
+ * @brief The processing strategy when the FrameSet generated by the frame aggregation function does not contain the frames of all opened streams (which
+ * can be caused by different frame rates of each stream, or by the loss of frames of one stream): drop directly or output to the user.
+ *
+ * @param[in] config The pipeline configuration object
+ * @param[in] mode The frame aggregation output mode to be set (default mode is @ref OB_FRAME_AGGREGATE_OUTPUT_ANY_SITUATION)
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ */
+OB_EXPORT void ob_config_set_frame_aggregate_output_mode(ob_config *config, ob_frame_aggregate_output_mode mode, ob_error **error);
+
+/**
+ * @brief Get current camera parameters
+ * @attention If D2C is enabled, it will return the camera parameters after D2C, if not, it will return to the default parameters
+ *
+ * @param[in] pipeline pipeline object
+ * @param[out] error Log error messages
+ * @return ob_camera_param The camera internal parameters
+ */
+OB_EXPORT ob_camera_param ob_pipeline_get_camera_param(ob_pipeline *pipeline, ob_error **error);
+
+/**
+ * @brief Get the current camera parameters
+ *
+ * @param[in] pipeline pipeline object
+ * @param[in] colorWidth color width
+ * @param[in] colorHeight color height
+ * @param[in] depthWidth depth width
+ * @param[in] depthHeight depth height
+ * @param[out] error Log error messages
+ * @return ob_camera_param returns camera internal parameters
+ */
+OB_EXPORT ob_camera_param ob_pipeline_get_camera_param_with_profile(ob_pipeline *pipeline, uint32_t colorWidth, uint32_t colorHeight, uint32_t depthWidth,
+                                                                    uint32_t depthHeight, ob_error **error);
+
+/**
+ * @brief Get device calibration parameters with the specified configuration
+ *
+ * @param[in] pipeline pipeline object
+ * @param[in] config The pipeline configuration
+ * @param[out] error Log error messages
+ * @return ob_calibration_param The calibration parameters
+ */
+OB_EXPORT ob_calibration_param ob_pipeline_get_calibration_param(ob_pipeline *pipeline, ob_config *config, ob_error **error);
+
+// The following interfaces are deprecated and are retained here for compatibility purposes.
+#define ob_config_set_depth_scale_require ob_config_set_depth_scale_after_align_require
+
+#ifdef __cplusplus
+}
+#endif
+
diff --git a/include/libobsensor/h/Property.h b/include/libobsensor/h/Property.h
new file mode 100644
index 00000000..fd9b2243
--- /dev/null
+++ b/include/libobsensor/h/Property.h
@@ -0,0 +1,774 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+/**
+ * @file Property.h
+ * @brief Control command property list maintenance
+ */
+
+#pragma once
+
+#include "ObTypes.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @brief Enumeration value describing all attribute control commands of the device
+ */
+typedef enum {
+    /**
+     * @brief LDP switch
+     */
+    OB_PROP_LDP_BOOL = 2,
+
+    /**
+     * @brief Laser switch
+     */
+    OB_PROP_LASER_BOOL = 3,
+
+    /**
+     * @brief laser pulse width
+     */
+    OB_PROP_LASER_PULSE_WIDTH_INT = 4,
+
+    /**
+     * @brief Laser current (uint: mA)
+     */
+    OB_PROP_LASER_CURRENT_FLOAT = 5,
+
+    /**
+     * @brief IR flood switch
+     */
+    OB_PROP_FLOOD_BOOL = 6,
+
+    /**
+     * @brief IR flood level
+     */
+    OB_PROP_FLOOD_LEVEL_INT = 7,
+
+    /**
+     * @brief Enable/disable temperature compensation
+     *
+     */
+    OB_PROP_TEMPERATURE_COMPENSATION_BOOL = 8,
+
+    /**
+     * @brief Depth mirror
+     */
+    OB_PROP_DEPTH_MIRROR_BOOL = 14,
+
+    /**
+     * @brief Depth flip
+     */
+    OB_PROP_DEPTH_FLIP_BOOL = 15,
+
+    /**
+     * @brief Depth Postfilter
+     */
+    OB_PROP_DEPTH_POSTFILTER_BOOL = 16,
+
+    /**
+     * @brief Depth Holefilter
+     */
+    OB_PROP_DEPTH_HOLEFILTER_BOOL = 17,
+
+    /**
+     * @brief IR mirror
+     */
+    OB_PROP_IR_MIRROR_BOOL = 18,
+
+    /**
+     * @brief IR flip
+     */
+    OB_PROP_IR_FLIP_BOOL = 19,
+
+    /**
+     * @brief Minimum depth threshold
+     */
+    OB_PROP_MIN_DEPTH_INT = 22,
+
+    /**
+     * @brief Maximum depth threshold
+     */
+    OB_PROP_MAX_DEPTH_INT = 23,
+
+    /**
+     * @brief Software filter switch
+     */
+    OB_PROP_DEPTH_SOFT_FILTER_BOOL = 24,
+
+    /**
+     * @brief LDP status
+     */
+    OB_PROP_LDP_STATUS_BOOL = 32,
+
+    /**
+     * @brief soft filter maxdiff param
+     */
+    OB_PROP_DEPTH_MAX_DIFF_INT = 40,
+
+    /**
+     * @brief soft filter maxSpeckleSize
+     */
+    OB_PROP_DEPTH_MAX_SPECKLE_SIZE_INT = 41,
+
+    /**
+     * @brief Hardware d2c is on
+     */
+    OB_PROP_DEPTH_ALIGN_HARDWARE_BOOL = 42,
+
+    /**
+     * @brief Timestamp adjustment
+     */
+    OB_PROP_TIMESTAMP_OFFSET_INT = 43,
+
+    /**
+     * @brief Hardware distortion switch Rectify
+     */
+    OB_PROP_HARDWARE_DISTORTION_SWITCH_BOOL = 61,
+
+    /**
+     * @brief Fan mode switch
+     */
+    OB_PROP_FAN_WORK_MODE_INT = 62,
+
+    /**
+     * @brief Multi-resolution D2C mode
+     */
+    OB_PROP_DEPTH_ALIGN_HARDWARE_MODE_INT = 63,
+
+    /**
+     * @brief Anti_collusion activation status
+     */
+    OB_PROP_ANTI_COLLUSION_ACTIVATION_STATUS_BOOL = 64,
+
+    /**
+     * @brief the depth precision level, which may change the depth frame data unit, needs to be confirmed through the ValueScale interface of
+     * DepthFrame
+     */
+    OB_PROP_DEPTH_PRECISION_LEVEL_INT = 75,
+
+    /**
+     * @brief tof filter range configuration
+     */
+    OB_PROP_TOF_FILTER_RANGE_INT = 76,
+
+    /**
+     * @brief laser mode, the firmware terminal currently only return 1: IR Drive, 2: Torch
+     */
+    OB_PROP_LASER_MODE_INT = 79,
+
+    /**
+     * @brief brt2r-rectify function switch (brt2r is a special module on mx6600), 0: Disable, 1: Rectify Enable
+     */
+    OB_PROP_RECTIFY2_BOOL = 80,
+
+    /**
+     * @brief Color mirror
+     */
+    OB_PROP_COLOR_MIRROR_BOOL = 81,
+
+    /**
+     * @brief Color flip
+     */
+    OB_PROP_COLOR_FLIP_BOOL = 82,
+
+    /**
+     * @brief Indicator switch, 0: Disable, 1: Enable
+     */
+    OB_PROP_INDICATOR_LIGHT_BOOL = 83,
+
+    /**
+     * @brief Disparity to depth switch, false: switch to software disparity convert to depth, true: switch to hardware disparity convert to depth
+     */
+    OB_PROP_DISPARITY_TO_DEPTH_BOOL = 85,
+
+    /**
+     * @brief BRT function switch (anti-background interference), 0: Disable, 1: Enable
+     */
+    OB_PROP_BRT_BOOL = 86,
+
+    /**
+     * @brief Watchdog function switch, 0: Disable, 1: Enable
+     */
+    OB_PROP_WATCHDOG_BOOL = 87,
+
+    /**
+     * @brief External signal trigger restart function switch, 0: Disable, 1: Enable
+     */
+    OB_PROP_EXTERNAL_SIGNAL_RESET_BOOL = 88,
+
+    /**
+     * @brief Heartbeat monitoring function switch, 0: Disable, 1: Enable
+     */
+    OB_PROP_HEARTBEAT_BOOL = 89,
+
+    /**
+     * @brief Depth cropping mode device: OB_DEPTH_CROPPING_MODE
+     */
+    OB_PROP_DEPTH_CROPPING_MODE_INT = 90,
+
+    /**
+     * @brief D2C preprocessing switch (such as RGB cropping), 0: off, 1: on
+     */
+    OB_PROP_D2C_PREPROCESS_BOOL = 91,
+
+    /**
+     * @brief Enable/disable GPM function
+     */
+    OB_PROP_GPM_BOOL = 93,
+
+    /**
+     * @brief Custom RGB cropping switch, 0 is off, 1 is on custom cropping, and the ROI cropping area is issued
+     */
+    OB_PROP_RGB_CUSTOM_CROP_BOOL = 94,
+
+    /**
+     * @brief Device operating mode (power consumption)
+     */
+    OB_PROP_DEVICE_WORK_MODE_INT = 95,
+
+    /**
+     * @brief Device communication type, 0: USB; 1: Ethernet(RTSP)
+     */
+    OB_PROP_DEVICE_COMMUNICATION_TYPE_INT = 97,
+
+    /**
+     * @brief Switch infrared imaging mode, 0: active IR mode, 1: passive IR mode
+     */
+    OB_PROP_SWITCH_IR_MODE_INT = 98,
+
+    /**
+     * @brief Laser power level
+     */
+    OB_PROP_LASER_POWER_LEVEL_CONTROL_INT = 99,
+
+    /**
+     * @brief LDP's measure distance, unit: mm
+     */
+    OB_PROP_LDP_MEASURE_DISTANCE_INT = 100,
+
+    /**
+     * @brief Reset device time to zero
+     */
+    OB_PROP_TIMER_RESET_SIGNAL_BOOL = 104,
+
+    /**
+     * @brief Enable send reset device time signal to other device. true: enable, false: disable
+     */
+    OB_PROP_TIMER_RESET_TRIGGER_OUT_ENABLE_BOOL = 105,
+
+    /**
+     * @brief Delay to reset device time, unit: us
+     */
+    OB_PROP_TIMER_RESET_DELAY_US_INT = 106,
+
+    /**
+     * @brief Signal to capture image
+     */
+    OB_PROP_CAPTURE_IMAGE_SIGNAL_BOOL = 107,
+
+    /**
+     * @brief Right IR sensor mirror state
+     */
+    OB_PROP_IR_RIGHT_MIRROR_BOOL = 112,
+
+    /**
+     * @brief Number frame to capture once a 'OB_PROP_CAPTURE_IMAGE_SIGNAL_BOOL' effect. range: [1, 255]
+     */
+    OB_PROP_CAPTURE_IMAGE_FRAME_NUMBER_INT = 113,
+
+    /**
+     * @brief Right IR sensor flip state. true: flip image, false: origin, default: false
+     */
+    OB_PROP_IR_RIGHT_FLIP_BOOL = 114,
+
+    /**
+     * @brief Color sensor rotation, angle{0, 90, 180, 270}
+     */
+    OB_PROP_COLOR_ROTATE_INT = 115,
+
+    /**
+     * @brief IR/Left-IR sensor rotation, angle{0, 90, 180, 270}
+     */
+    OB_PROP_IR_ROTATE_INT = 116,
+
+    /**
+     * @brief Right IR sensor rotation, angle{0, 90, 180, 270}
+     */
+    OB_PROP_IR_RIGHT_ROTATE_INT = 117,
+
+    /**
+     * @brief Depth sensor rotation, angle{0, 90, 180, 270}
+     */
+    OB_PROP_DEPTH_ROTATE_INT = 118,
+
+    /**
+     * @brief Get hardware laser power actual level which real state of laser element. OB_PROP_LASER_POWER_LEVEL_CONTROL_INT99）will effect this command
+     * which it setting and changed the hardware laser energy level.
+     */
+    OB_PROP_LASER_POWER_ACTUAL_LEVEL_INT = 119,
+
+    /**
+     * @brief USB's power state, enum type: OBUSBPowerState
+     */
+    OB_PROP_USB_POWER_STATE_INT = 121,
+
+    /**
+     * @brief DC's power state, enum type: OBDCPowerState
+     */
+    OB_PROP_DC_POWER_STATE_INT = 122,
+
+    /**
+     * @brief Device development mode switch, optional modes can refer to the definition in @ref OBDeviceDevelopmentMode,the default mode is
+     * @ref OB_USER_MODE
+     * @attention The device takes effect after rebooting when switching modes.
+     */
+    OB_PROP_DEVICE_DEVELOPMENT_MODE_INT = 129,
+
+    /**
+     * @brief Multi-DeviceSync synchronized signal trigger out is enable state. true: enable, false: disable
+     */
+    OB_PROP_SYNC_SIGNAL_TRIGGER_OUT_BOOL = 130,
+
+    /**
+     * @brief Restore factory settings and factory parameters
+     * @attention This command can only be written, and the parameter value must be true. The command takes effect after restarting the device.
+     */
+    OB_PROP_RESTORE_FACTORY_SETTINGS_BOOL = 131,
+
+    /**
+     * @brief Enter recovery mode (flashing mode) when boot the device
+     * @attention The device will take effect after rebooting with the enable option. After entering recovery mode, you can upgrade the device system. Upgrading
+     * the system may cause system damage, please use it with caution.
+     */
+    OB_PROP_BOOT_INTO_RECOVERY_MODE_BOOL = 132,
+
+    /**
+     * @brief Query whether the current device is running in recovery mode (read-only)
+     */
+    OB_PROP_DEVICE_IN_RECOVERY_MODE_BOOL = 133,
+
+    /**
+     * @brief Capture interval mode, 0:time interval, 1:number interval
+     */
+    OB_PROP_CAPTURE_INTERVAL_MODE_INT = 134,
+
+    /**
+     * @brief Capture time interval
+     */
+    OB_PROP_CAPTURE_IMAGE_TIME_INTERVAL_INT = 135,
+
+    /**
+     * @brief Capture number interval
+     */
+    OB_PROP_CAPTURE_IMAGE_NUMBER_INTERVAL_INT = 136,
+
+    /*
+     * @brief Timer reset function enable
+     */
+    OB_PROP_TIMER_RESET_ENABLE_BOOL = 140,
+
+    /**
+     * @brief Enable or disable the device to retry USB2.0 re-identification when the device is connected to a USB2.0 port.
+     * @brief This feature ensures that the device is not mistakenly identified as a USB 2.0 device when connected to a USB 3.0 port.
+     */
+    OB_PROP_DEVICE_USB2_REPEAT_IDENTIFY_BOOL = 141,
+
+    /**
+     * @brief Reboot device delay mode. Delay time unit: ms, range: [0, 8000).
+     */
+    OB_PROP_DEVICE_REBOOT_DELAY_INT = 142,
+
+    /**
+     * @brief Query the status of laser overcurrent protection (read-only)
+     */
+    OB_PROP_LASER_OVERCURRENT_PROTECTION_STATUS_BOOL = 148,
+
+    /**
+     * @brief Query the status of laser pulse width protection (read-only)
+     */
+    OB_PROP_LASER_PULSE_WIDTH_PROTECTION_STATUS_BOOL = 149,
+
+    /**
+     * @brief Laser always on, true: always on, false: off, laser will be turned off when out of exposure time
+     */
+    OB_PROP_LASER_ALWAYS_ON_BOOL = 174,
+
+    /**
+     * @brief Laser on/off alternate mode, 0: off, 1: on-off alternate, 2: off-on alternate
+     * @attention When turn on this mode, the laser will turn on and turn off alternately each frame.
+     */
+    OB_PROP_LASER_ON_OFF_PATTERN_INT = 175,
+
+    /**
+     * @brief Depth unit flexible adjustment\
+     * @brief This property allows continuous adjustment of the depth unit, unlike @ref OB_PROP_DEPTH_PRECISION_LEVEL_INT must be set to some fixed value.
+     */
+    OB_PROP_DEPTH_UNIT_FLEXIBLE_ADJUSTMENT_FLOAT = 176,
+
+    /**
+     * @brief Laser control, 0: off, 1: on, 2: auto
+     *
+     */
+    OB_PROP_LASER_CONTROL_INT = 182,
+
+    /**
+     * @brief IR brightness
+     */
+    OB_PROP_IR_BRIGHTNESS_INT = 184,
+
+    /**
+     * @brief Slave/secondary device synchronization status (read-only)
+     */
+    OB_PROP_SLAVE_DEVICE_SYNC_STATUS_BOOL = 188,
+
+    /**
+     * @brief Color AE max exposure
+     */
+    OB_PROP_COLOR_AE_MAX_EXPOSURE_INT = 189,
+
+    /**
+     * @brief Max exposure time of IR auto exposure
+     */
+    OB_PROP_IR_AE_MAX_EXPOSURE_INT = 190,
+
+    /**
+     * @brief Disparity search range mode, 1: 128, 2: 256
+     */
+    OB_PROP_DISP_SEARCH_RANGE_MODE_INT = 191,
+
+    /**
+     * @brief Repower device (cut off power and power on again)
+     *
+     * @brief Currently using for GMSL device, cut off power and power on again by GMSL host driver.
+     */
+    OB_PROP_DEVICE_REPOWER_BOOL = 202,
+
+    /**
+     * @brief Baseline calibration parameters
+     */
+    OB_STRUCT_BASELINE_CALIBRATION_PARAM = 1002,
+
+    /**
+     * @brief Device temperature information
+     */
+    OB_STRUCT_DEVICE_TEMPERATURE = 1003,
+
+    /**
+     * @brief TOF exposure threshold range
+     */
+    OB_STRUCT_TOF_EXPOSURE_THRESHOLD_CONTROL = 1024,
+
+    /**
+     * @brief get/set serial number
+     */
+    OB_STRUCT_DEVICE_SERIAL_NUMBER = 1035,
+
+    /**
+     * @brief get/set device time
+     */
+    OB_STRUCT_DEVICE_TIME = 1037,
+
+    /**
+     * @brief Multi-device synchronization mode and parameter configuration
+     */
+    OB_STRUCT_MULTI_DEVICE_SYNC_CONFIG = 1038,
+
+    /**
+     * @brief RGB cropping ROI
+     */
+    OB_STRUCT_RGB_CROP_ROI = 1040,
+
+    /**
+     * @brief Device IP address configuration
+     */
+    OB_STRUCT_DEVICE_IP_ADDR_CONFIG = 1041,
+
+    /**
+     * @brief The current camera depth mode
+     */
+    OB_STRUCT_CURRENT_DEPTH_ALG_MODE = 1043,
+
+    /**
+     * @brief A list of depth accuracy levels, returning an array of uin16_t, corresponding to the enumeration
+     */
+    OB_STRUCT_DEPTH_PRECISION_SUPPORT_LIST = 1045,
+
+    /**
+     * @brief Device network static ip config record
+     * @brief Using for get last static ip config，witch is record in device flash when user set static ip config
+     *
+     * @attention read only
+     */
+    OB_STRUCT_DEVICE_STATIC_IP_CONFIG_RECORD = 1053,
+
+    /**
+     * @brief Using to configure the depth sensor's HDR mode
+     * @brief The Value type is @ref OBHdrConfig
+     *
+     * @attention After enable HDR mode, the depth sensor auto exposure will be disabled.
+     */
+    OB_STRUCT_DEPTH_HDR_CONFIG = 1059,
+
+    /**
+     * @brief Color Sensor AE ROI configuration
+     * @brief The Value type is @ref OBRegionOfInterest
+     */
+    OB_STRUCT_COLOR_AE_ROI = 1060,
+
+    /**
+     * @brief Depth Sensor AE ROI configuration
+     * @brief The Value type is @ref OBRegionOfInterest
+     * @brief Since the ir sensor is the same physical sensor as the depth sensor, this property will also effect the ir sensor.
+     */
+    OB_STRUCT_DEPTH_AE_ROI = 1061,
+
+    /**
+     * @brief ASIC serial number
+     */
+    OB_STRUCT_ASIC_SERIAL_NUMBER = 1063,
+
+    /**
+     * @brief Color camera auto exposure
+     */
+    OB_PROP_COLOR_AUTO_EXPOSURE_BOOL = 2000,
+
+    /**
+     * @brief Color camera exposure adjustment
+     */
+    OB_PROP_COLOR_EXPOSURE_INT = 2001,
+
+    /**
+     * @brief Color camera gain adjustment
+     */
+    OB_PROP_COLOR_GAIN_INT = 2002,
+
+    /**
+     * @brief Color camera automatic white balance
+     */
+    OB_PROP_COLOR_AUTO_WHITE_BALANCE_BOOL = 2003,
+
+    /**
+     * @brief Color camera white balance adjustment
+     */
+    OB_PROP_COLOR_WHITE_BALANCE_INT = 2004,
+
+    /**
+     * @brief Color camera brightness adjustment
+     */
+    OB_PROP_COLOR_BRIGHTNESS_INT = 2005,
+
+    /**
+     * @brief Color camera sharpness adjustment
+     */
+    OB_PROP_COLOR_SHARPNESS_INT = 2006,
+
+    /**
+     * @brief Color camera shutter adjustment
+     */
+    OB_PROP_COLOR_SHUTTER_INT = 2007,
+
+    /**
+     * @brief Color camera saturation adjustment
+     */
+    OB_PROP_COLOR_SATURATION_INT = 2008,
+
+    /**
+     * @brief Color camera contrast adjustment
+     */
+    OB_PROP_COLOR_CONTRAST_INT = 2009,
+
+    /**
+     * @brief Color camera gamma adjustment
+     */
+    OB_PROP_COLOR_GAMMA_INT = 2010,
+
+    /**
+     * @brief Color camera image rotation
+     */
+    OB_PROP_COLOR_ROLL_INT = 2011,
+
+    /**
+     * @brief Color camera auto exposure priority
+     */
+    OB_PROP_COLOR_AUTO_EXPOSURE_PRIORITY_INT = 2012,
+
+    /**
+     * @brief Color camera brightness compensation
+     */
+    OB_PROP_COLOR_BACKLIGHT_COMPENSATION_INT = 2013,
+
+    /**
+     * @brief Color camera color tint
+     */
+    OB_PROP_COLOR_HUE_INT = 2014,
+
+    /**
+     * @brief Color Camera Power Line Frequency
+     */
+    OB_PROP_COLOR_POWER_LINE_FREQUENCY_INT = 2015,
+
+    /**
+     * @brief Automatic exposure of depth camera (infrared camera will be set synchronously under some models of devices)
+     */
+    OB_PROP_DEPTH_AUTO_EXPOSURE_BOOL = 2016,
+
+    /**
+     * @brief Depth camera exposure adjustment (infrared cameras will be set synchronously under some models of devices)
+     */
+    OB_PROP_DEPTH_EXPOSURE_INT = 2017,
+
+    /**
+     * @brief Depth camera gain adjustment (infrared cameras will be set synchronously under some models of devices)
+     */
+    OB_PROP_DEPTH_GAIN_INT = 2018,
+
+    /**
+     * @brief Infrared camera auto exposure (depth camera will be set synchronously under some models of devices)
+     */
+    OB_PROP_IR_AUTO_EXPOSURE_BOOL = 2025,
+
+    /**
+     * @brief Infrared camera exposure adjustment (some models of devices will set the depth camera synchronously)
+     */
+    OB_PROP_IR_EXPOSURE_INT = 2026,
+
+    /**
+     * @brief Infrared camera gain adjustment (the depth camera will be set synchronously under some models of devices)
+     */
+    OB_PROP_IR_GAIN_INT = 2027,
+
+    /**
+     * @brief Select Infrared camera data source channel. If not support throw exception. 0 : IR stream from IR Left sensor; 1 : IR stream from IR Right sensor;
+     */
+    OB_PROP_IR_CHANNEL_DATA_SOURCE_INT = 2028,
+
+    /**
+     * @brief Depth effect dedistortion, true: on, false: off. mutually exclusive with D2C function, RM_Filter disable When hardware or software D2C is enabled.
+     */
+    OB_PROP_DEPTH_RM_FILTER_BOOL = 2029,
+
+    /**
+     * @brief Color camera maximal gain
+     */
+    OB_PROP_COLOR_MAXIMAL_GAIN_INT = 2030,
+
+    /**
+     * @brief Color camera shutter gain
+     */
+    OB_PROP_COLOR_MAXIMAL_SHUTTER_INT = 2031,
+
+    /**
+     * @brief The enable/disable switch for IR short exposure function, supported only by a few devices.
+     */
+    OB_PROP_IR_SHORT_EXPOSURE_BOOL = 2032,
+
+    /**
+     * @brief Color camera HDR
+     */
+    OB_PROP_COLOR_HDR_BOOL = 2034,
+
+    /**
+     * @brief IR long exposure mode switch read and write.
+     */
+    OB_PROP_IR_LONG_EXPOSURE_BOOL = 2035,
+
+    /**
+     * @brief Setting and getting the USB device frame skipping mode status, true: frame skipping mode, false: non-frame skipping mode.
+     */
+    OB_PROP_SKIP_FRAME_BOOL = 2036,
+
+    /**
+     * @brief Depth HDR merge, true: on, false: off.
+     */
+    OB_PROP_HDR_MERGE_BOOL = 2037,
+
+    /**
+     * @brief Color camera FOCUS
+     */
+    OB_PROP_COLOR_FOCUS_INT = 2038,
+
+    /**
+     * @brief Depth camera priority
+     *
+     */
+    OB_PROP_DEPTH_AUTO_EXPOSURE_PRIORITY_INT = 2052,
+
+    /**
+     * @brief Software disparity to depth
+     */
+    OB_PROP_SDK_DISPARITY_TO_DEPTH_BOOL = 3004,
+
+    /**
+     * @brief Depth data unpacking function switch (each open stream will be turned on by default, support RLE/Y10/Y11/Y12/Y14 format)
+     */
+    OB_PROP_SDK_DEPTH_FRAME_UNPACK_BOOL = 3007,
+
+    /**
+     * @brief IR data unpacking function switch (each current will be turned on by default, support RLE/Y10/Y11/Y12/Y14 format)
+     */
+    OB_PROP_SDK_IR_FRAME_UNPACK_BOOL = 3008,
+
+    /**
+     * @brief Accel data conversion function switch (on by default)
+     */
+    OB_PROP_SDK_ACCEL_FRAME_TRANSFORMED_BOOL = 3009,
+
+    /**
+     * @brief Gyro data conversion function switch (on by default)
+     */
+    OB_PROP_SDK_GYRO_FRAME_TRANSFORMED_BOOL = 3010,
+
+    /**
+     * @brief Left IR frame data unpacking function switch (each current will be turned on by default, support RLE/Y10/Y11/Y12/Y14 format)
+     */
+    OB_PROP_SDK_IR_LEFT_FRAME_UNPACK_BOOL = 3011,
+
+    /**
+     * @brief Right IR frame data unpacking function switch (each current will be turned on by default, support RLE/Y10/Y11/Y12/Y14 format)
+     */
+    OB_PROP_SDK_IR_RIGHT_FRAME_UNPACK_BOOL = 3012,
+
+    /**
+     * @brief Calibration JSON file read from device (Femto Mega, read only)
+     */
+    OB_RAW_DATA_CAMERA_CALIB_JSON_FILE = 4029,
+} OBPropertyID,
+    ob_property_id;
+
+// For backward compatibility
+#define OB_PROP_TIMER_RESET_TRIGGLE_OUT_ENABLE_BOOL OB_PROP_TIMER_RESET_TRIGGER_OUT_ENABLE_BOOL
+#define OB_PROP_LASER_ON_OFF_MODE_INT OB_PROP_LASER_ON_OFF_PATTERN_INT
+#define OB_PROP_LASER_ENERGY_LEVEL_INT OB_PROP_LASER_POWER_LEVEL_CONTROL_INT
+#define OB_PROP_LASER_HW_ENERGY_LEVEL_INT OB_PROP_LASER_POWER_ACTUAL_LEVEL_INT
+#define OB_PROP_DEVICE_USB3_REPEAT_IDENTIFY_BOOL OB_PROP_DEVICE_USB2_REPEAT_IDENTIFY_BOOL
+#define OB_PROP_DEPTH_NOISE_REMOVAL_FILTER_BOOL OB_PROP_DEPTH_SOFT_FILTER_BOOL
+
+/**
+ * @brief The data type used to describe all property settings
+ */
+typedef enum OBPropertyType {
+    OB_BOOL_PROPERTY   = 0, /**< Boolean property */
+    OB_INT_PROPERTY    = 1, /**< Integer property */
+    OB_FLOAT_PROPERTY  = 2, /**< Floating-point property */
+    OB_STRUCT_PROPERTY = 3, /**< Struct property */
+} OBPropertyType,
+    ob_property_type;
+
+/**
+ * @brief Used to describe the characteristics of each property
+ */
+typedef struct OBPropertyItem {
+    OBPropertyID     id;         /**< Property ID */
+    const char      *name;       /**< Property name */
+    OBPropertyType   type;       /**< Property type */
+    OBPermissionType permission; /**< Property read and write permission */
+} OBPropertyItem, ob_property_item;
+
+#ifdef __cplusplus
+}
+#endif
+
diff --git a/include/libobsensor/h/Sensor.h b/include/libobsensor/h/Sensor.h
new file mode 100644
index 00000000..b758779a
--- /dev/null
+++ b/include/libobsensor/h/Sensor.h
@@ -0,0 +1,132 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+/**
+ * @file Sensor.h
+ * @brief Defines types related to sensors, used for obtaining stream configurations, opening and closing streams, and setting and getting sensor properties.
+ */
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "ObTypes.h"
+
+/**
+ * @brief Get the type of the sensor.
+ *
+ * @param[in] sensor The sensor object.
+ * @param[out] error Logs error messages.
+ * @return The sensor type.
+ */
+OB_EXPORT ob_sensor_type ob_sensor_get_type(const ob_sensor *sensor, ob_error **error);
+
+/**
+ * @brief Get a list of all supported stream profiles.
+ *
+ * @param[in] sensor The sensor object.
+ * @param[out] error Logs error messages.
+ * @return A list of stream profiles.
+ */
+OB_EXPORT ob_stream_profile_list *ob_sensor_get_stream_profile_list(const ob_sensor *sensor, ob_error **error);
+
+/**
+ * @brief Open the current sensor and set the callback data frame.
+ *
+ * @param[in] sensor The sensor object.
+ * @param[in] profile The stream configuration information.
+ * @param[in] callback The callback function triggered when frame data arrives.
+ * @param[in] user_data Any user data to pass in and get from the callback.
+ * @param[out] error Logs error messages.
+ */
+OB_EXPORT void ob_sensor_start(ob_sensor *sensor, const ob_stream_profile *profile, ob_frame_callback callback, void *user_data, ob_error **error);
+
+/**
+ * @brief Stop the sensor stream.
+ *
+ * @param[in] sensor The sensor object.
+ * @param[out] error Logs error messages.
+ */
+OB_EXPORT void ob_sensor_stop(ob_sensor *sensor, ob_error **error);
+
+/**
+ * @brief Switch resolutions.
+ *
+ * @param[in] sensor The sensor object.
+ * @param[in] profile The stream configuration information.
+ * @param[out] error Logs error messages.
+ */
+OB_EXPORT void ob_sensor_switch_profile(ob_sensor *sensor, ob_stream_profile *profile, ob_error **error);
+
+/**
+ * @brief Delete a sensor object.
+ *
+ * @param[in] sensor The sensor object to delete.
+ * @param[out] error Logs error messages.
+ */
+OB_EXPORT void ob_delete_sensor(ob_sensor *sensor, ob_error **error);
+
+/**
+ * @brief  Create a list of recommended filters for the specified sensor.
+ *
+ * @param[in] sensor The ob_sensor object.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ *
+ * @return ob_filter_list
+ */
+OB_EXPORT ob_filter_list *ob_sensor_create_recommended_filter_list(const ob_sensor *sensor, ob_error **error);
+
+/**
+ * @brief Get the number of sensors in the sensor list.
+ *
+ * @param[in] sensor_list The list of sensor objects.
+ * @param[out] error Logs error messages.
+ * @return The number of sensors in the list.
+ */
+OB_EXPORT uint32_t ob_sensor_list_get_count(const ob_sensor_list *sensor_list, ob_error **error);
+
+/**
+ * @brief Get the sensor type.
+ *
+ * @param[in] sensor_list The list of sensor objects.
+ * @param[in] index The index of the sensor on the list.
+ * @param[out] error Logs error messages.
+ * @return The sensor type.
+ */
+OB_EXPORT ob_sensor_type ob_sensor_list_get_sensor_type(const ob_sensor_list *sensor_list, uint32_t index, ob_error **error);
+
+/**
+ * @brief Get a sensor by sensor type.
+ *
+ * @param[in] sensor_list The list of sensor objects.
+ * @param[in] sensorType The sensor type to be obtained.
+ * @param[out] error Logs error messages.
+ * @return The sensor pointer. If the specified type of sensor does not exist, it will return null.
+ */
+OB_EXPORT ob_sensor *ob_sensor_list_get_sensor_by_type(const ob_sensor_list *sensor_list, ob_sensor_type sensorType, ob_error **error);
+
+/**
+ * @brief Get a sensor by index number.
+ *
+ * @param[in] sensor_list The list of sensor objects.
+ * @param[in] index The index of the sensor on the list.
+ * @param[out] error Logs error messages.
+ * @return The sensor object.
+ */
+OB_EXPORT ob_sensor *ob_sensor_list_get_sensor(const ob_sensor_list *sensor_list, uint32_t index, ob_error **error);
+
+/**
+ * @brief Delete a list of sensor objects.
+ *
+ * @param[in] sensor_list The list of sensor objects to delete.
+ * @param[out] error Logs error messages.
+ */
+OB_EXPORT void ob_delete_sensor_list(ob_sensor_list *sensor_list, ob_error **error);
+
+#define ob_sensor_list_get_sensor_count ob_sensor_list_get_count
+#define ob_sensor_get_recommended_filter_list ob_sensor_create_recommended_filter_list
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/include/libobsensor/h/StreamProfile.h b/include/libobsensor/h/StreamProfile.h
new file mode 100644
index 00000000..dfb72037
--- /dev/null
+++ b/include/libobsensor/h/StreamProfile.h
@@ -0,0 +1,407 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+/**
+ * @file StreamProfile.h
+ * @brief The stream profile related type is used to get information such as the width, height, frame rate, and format of the stream.
+ *
+ */
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "ObTypes.h"
+
+/**
+ * @brief Create a stream profile object
+ *
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return ob_stream_profile* return the stream profile object
+ */
+OB_EXPORT ob_stream_profile *ob_create_stream_profile(ob_stream_type type, ob_format format, ob_error **error);
+
+/**
+ * @brief Create a video stream profile object
+ *
+ * @param[in] type Stream type
+ * @param[in] format Stream format
+ * @param[in] width Stream width
+ * @param[in] height Stream height
+ * @param[in] fps Stream frame rate
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return ob_stream_profile* return the video stream profile object
+ */
+OB_EXPORT ob_stream_profile *ob_create_video_stream_profile(ob_stream_type type, ob_format format, uint32_t width, uint32_t height, uint32_t fps,
+                                                            ob_error **error);
+
+/**
+ * @brief Create a accel stream profile object
+ *
+ * @param[in] full_scale_range Accel full scale range
+ * @param[in] sample_rate Accel sample rate
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return ob_stream_profile* return the accel stream profile object
+ */
+OB_EXPORT ob_stream_profile *ob_create_accel_stream_profile(ob_accel_full_scale_range full_scale_range, ob_accel_sample_rate sample_rate, ob_error **error);
+
+/**
+ * @brief Create a gyro stream profile object
+ *
+ * @param[in] full_scale_range Gyro full scale range
+ * @param[in] sample_rate Gyro sample rate
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return ob_stream_profile* return the accel stream profile object
+ */
+OB_EXPORT ob_stream_profile *ob_create_gyro_stream_profile(ob_gyro_full_scale_range full_scale_range, ob_gyro_sample_rate sample_rate, ob_error **error);
+
+/**
+ * @brief Copy the stream profile object from an other stream profile object
+ *
+ * @param[in] srcProfile Source stream profile object
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ *
+ * @return ob_stream_profile* return the new stream profile object
+ */
+OB_EXPORT ob_stream_profile *ob_create_stream_profile_from_other_stream_profile(const ob_stream_profile *srcProfile, ob_error **error);
+
+/**
+ * @brief Copy the stream profile object with a new format object
+ *
+ * @param[in] profile Stream profile object
+ * @param[in] new_format New format
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ *
+ * @return ob_stream_profile* return the new stream profile object with the new format
+ */
+OB_EXPORT ob_stream_profile *ob_create_stream_profile_with_new_format(const ob_stream_profile *profile, ob_format new_format, ob_error **error);
+
+/**
+ * @brief Delete the stream configuration.
+ *
+ * @param[in] profile Stream profile object .
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ */
+OB_EXPORT void ob_delete_stream_profile(const ob_stream_profile *profile, ob_error **error);
+
+/**
+ * @brief Get stream profile format
+ *
+ * @param[in] profile Stream profile object
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return ob_format return the format of the stream
+ */
+OB_EXPORT ob_format ob_stream_profile_get_format(const ob_stream_profile *profile, ob_error **error);
+
+/**
+ * @brief Set stream profile format
+ *
+ * @param[in] profile Stream profile object
+ * @param[in] format The format of the stream
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ */
+OB_EXPORT void ob_stream_profile_set_format(ob_stream_profile *profile, ob_format format, ob_error **error);
+
+/**
+ * @brief Get stream profile type
+ *
+ * @param[in] profile Stream profile object
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return ob_stream_type stream type
+ */
+OB_EXPORT ob_stream_type ob_stream_profile_get_type(const ob_stream_profile *profile, ob_error **error);
+
+/**
+ * @brief Set stream profile type
+ *
+ * @param[in] profile Stream profile object
+ * @param[in] type The type of the stream
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ */
+OB_EXPORT void ob_stream_profile_set_type(const ob_stream_profile *profile, ob_stream_type type, ob_error **error);
+
+/**
+ * @brief Get the extrinsic for source stream to target stream
+ *
+ * @param[in] source Source stream profile
+ * @param[in]  target Target stream profile
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return ob_extrinsic The extrinsic
+ */
+OB_EXPORT ob_extrinsic ob_stream_profile_get_extrinsic_to(const ob_stream_profile *source, ob_stream_profile *target, ob_error **error);
+
+/**
+ * @brief Set the extrinsic for source stream to target stream
+ *
+ * @param[in] profile Stream profile object
+ * @param[in] target  Target stream type
+ * @param[in] extrinsic The extrinsic
+ * @param[out] error   Pointer to an error object that will be set if an error occurs.
+ */
+OB_EXPORT void ob_stream_profile_set_extrinsic_to(ob_stream_profile *source, const ob_stream_profile *target, ob_extrinsic extrinsic, ob_error **error);
+
+/**
+ * @brief Get the frame rate of the video stream
+ *
+ * @param[in] profile Stream profile object
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return uint32_t return the frame rate of the stream
+ */
+OB_EXPORT uint32_t ob_video_stream_profile_get_fps(const ob_stream_profile *profile, ob_error **error);
+
+/**
+ * @brief Get the width of the video stream
+ *
+ * @param[in] profile Stream profile object , If the profile is not a video stream configuration, an error will be returned
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return uint32_t return the width of the stream
+ */
+OB_EXPORT uint32_t ob_video_stream_profile_get_width(const ob_stream_profile *profile, ob_error **error);
+
+/**
+ * @brief Set the width of the video stream
+ *
+ * @param[in] profile Stream profile object , If the profile is not a video stream configuration, an error will be returned
+ * @param[in] width The width of the stream
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ */
+OB_EXPORT void ob_video_stream_profile_set_width(ob_stream_profile *profile, uint32_t width, ob_error **error);
+
+/**
+ * @brief Get the height of the video stream
+ *
+ * @param[in] profile Stream profile object , If the profile is not a video stream configuration, an error will be returned
+ * @param[out] error  Pointer to an error object that will be set if an error occurs.
+ * @return uint32_t return the height of the stream
+ */
+OB_EXPORT uint32_t ob_video_stream_profile_get_height(const ob_stream_profile *profile, ob_error **error);
+
+/**
+ * @brief Set the height of the video stream
+ *
+ * @param[in] profile Stream profile object , If the profile is not a video stream configuration, an error will be returned
+ * @param[in] height The height of the stream
+ * @param[out] error  Pointer to an error object that will be set if an error occurs.
+ */
+OB_EXPORT void ob_video_stream_profile_set_height(ob_stream_profile *profile, uint32_t height, ob_error **error);
+
+/**
+ * @brief Get the intrinsic of the video stream profile
+ *
+ * @param[in]  profile Stream profile object
+ * @param[out] error   Pointer to an error object that will be set if an error occurs.
+ * @return ob_camera_intrinsic Return the intrinsic of the stream
+ */
+OB_EXPORT ob_camera_intrinsic ob_video_stream_profile_get_intrinsic(const ob_stream_profile *profile, ob_error **error);
+
+/**
+ * @brief Set the intrinsic of the video stream profile
+ *
+ * @param[in] profile Stream profile object
+ * @param[in]  intrinsic The intrinsic of the stream
+ * @param[out] error   Pointer to an error object that will be set if an error occurs.
+ */
+OB_EXPORT void ob_video_stream_profile_set_intrinsic(ob_stream_profile *profile, ob_camera_intrinsic intrinsic, ob_error **error);
+
+/**
+ * @brief Get the distortion of the video stream profile
+ *
+ * @param[in]  profile Stream profile object
+ * @param[out] error   Pointer to an error object that will be set if an error occurs.
+ * @return ob_camera_distortion Return the distortion of the stream
+ */
+OB_EXPORT ob_camera_distortion ob_video_stream_profile_get_distortion(const ob_stream_profile *profile, ob_error **error);
+
+/**
+ * @brief Set the distortion of the video stream profile
+ *
+ * @param[in] profile Stream profile object
+ * @param[in]  distortion The distortion of the stream
+ * @param[out] error   Pointer to an error object that will be set if an error occurs.
+ */
+OB_EXPORT void ob_video_stream_profile_set_distortion(ob_stream_profile *profile, ob_camera_distortion distortion, ob_error **error);
+
+/**
+ * @brief Get the process param of the disparity stream
+ *
+ * @param[in]  profile Stream profile object
+ * @param[out] error   Pointer to an error object that will be set if an error occurs.
+ * @return ob_disparity_param Return the disparity process param of the stream
+ */
+OB_EXPORT ob_disparity_param ob_disparity_based_stream_profile_get_disparity_param(const ob_stream_profile *profile, ob_error **error);
+
+/**
+ * @brief Set the disparity process param of the disparity stream.
+ *
+ * @param[in] profile Stream profile object. If the profile is not for the disparity stream, an error will be returned.
+ * @param[in]  intrinsic The disparity process param of the disparity stream.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ */
+OB_EXPORT void ob_disparity_based_stream_profile_set_disparity_param(ob_stream_profile *profile, ob_disparity_param param, ob_error **error);
+
+/**
+ * @brief Get the full-scale range of the accelerometer stream.
+ *
+ * @param[in] profile Stream profile object. If the profile is not for the accelerometer stream, an error will be returned.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return The full-scale range of the accelerometer stream.
+ */
+OB_EXPORT ob_accel_full_scale_range ob_accel_stream_profile_get_full_scale_range(const ob_stream_profile *profile, ob_error **error);
+
+/**
+ * @brief Get the sampling frequency of the accelerometer frame.
+ *
+ * @param[in] profile Stream profile object. If the profile is not for the accelerometer stream, an error will be returned.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return The sampling frequency of the accelerometer frame.
+ */
+OB_EXPORT ob_accel_sample_rate ob_accel_stream_profile_get_sample_rate(const ob_stream_profile *profile, ob_error **error);
+
+/**
+ * @brief Get the intrinsic of the accelerometer stream.
+ *
+ * @param[in]  profile Stream profile object. If the profile is not for the accelerometer stream, an error will be returned.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return ob_accel_intrinsic Return the intrinsic of the accelerometer stream.
+ */
+OB_EXPORT ob_accel_intrinsic ob_accel_stream_profile_get_intrinsic(const ob_stream_profile *profile, ob_error **error);
+
+/**
+ * @brief Set the intrinsic of the accelerometer stream.
+ *
+ * @param[in] profile Stream profile object. If the profile is not for the accelerometer stream, an error will be returned.
+ * @param[in]  intrinsic The intrinsic of the accelerometer stream.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ */
+OB_EXPORT void ob_accel_stream_profile_set_intrinsic(ob_stream_profile *profile, ob_accel_intrinsic intrinsic, ob_error **error);
+
+/**
+ * @brief Get the full-scale range of the gyroscope stream.
+ *
+ * @param[in] profile Stream profile object. If the profile is not for the gyroscope stream, an error will be returned.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return The full-scale range of the gyroscope stream.
+ */
+OB_EXPORT ob_gyro_full_scale_range ob_gyro_stream_profile_get_full_scale_range(const ob_stream_profile *profile, ob_error **error);
+
+/**
+ * @brief Get the sampling frequency of the gyroscope stream.
+ *
+ * @param[in] profile Stream profile object. If the profile is not for the gyroscope stream, an error will be returned.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return The sampling frequency of the gyroscope stream.
+ */
+OB_EXPORT ob_gyro_sample_rate ob_gyro_stream_profile_get_sample_rate(const ob_stream_profile *profile, ob_error **error);
+
+/**
+ * @brief Get the intrinsic of the gyroscope stream.
+ *
+ * @param[in]  profile Stream profile object. If the profile is not for the gyroscope stream, an error will be returned.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return ob_gyro_intrinsic Return the intrinsic of the gyroscope stream.
+ */
+OB_EXPORT ob_gyro_intrinsic ob_gyro_stream_get_intrinsic(const ob_stream_profile *profile, ob_error **error);
+
+/**
+ * @brief Set the intrinsic of the gyroscope stream.
+ *
+ * @param[in] profile Stream profile object. If the profile is not for the gyroscope stream, an error will be returned.
+ * @param[in]  intrinsic The intrinsic of the gyroscope stream.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ */
+OB_EXPORT void ob_gyro_stream_set_intrinsic(ob_stream_profile *profile, ob_gyro_intrinsic intrinsic, ob_error **error);
+
+/**
+ * @brief Get the number of StreamProfile lists.
+ *
+ * @param[in] profile_list StreamProfile list.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return The number of StreamProfile lists.
+ */
+OB_EXPORT uint32_t ob_stream_profile_list_get_count(const ob_stream_profile_list *profile_list, ob_error **error);
+
+/**
+ * @brief Get the corresponding StreamProfile by subscripting.
+ *
+ * @attention The stream profile returned by this function should be deleted by calling @ref ob_delete_stream_profile() when it is no longer needed.
+ *
+ * @param[in] profile_list StreamProfile lists.
+ * @param[in] index Index.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return The matching profile.
+ */
+OB_EXPORT ob_stream_profile *ob_stream_profile_list_get_profile(const ob_stream_profile_list *profile_list, int index, ob_error **error);
+
+/**
+ * @brief Match the corresponding ob_stream_profile through the passed parameters. If there are multiple matches,
+ * the first one in the list will be returned by default. If no matched profile is found, an error will be returned.
+ *
+ * @attention The stream profile returned by this function should be deleted by calling @ref ob_delete_stream_profile() when it is no longer needed.
+ *
+ * @param[in] profile_list Resolution list.
+ * @param[in] width Width. If you don't need to add matching conditions, you can pass OB_WIDTH_ANY.
+ * @param[in] height Height. If you don't need to add matching conditions, you can pass OB_HEIGHT_ANY.
+ * @param[in] format Format. If you don't need to add matching conditions, you can pass OB_FORMAT_ANY.
+ * @param[in] fps Frame rate. If you don't need to add matching conditions, you can pass OB_FPS_ANY.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return The matching profile.
+ */
+OB_EXPORT ob_stream_profile *ob_stream_profile_list_get_video_stream_profile(const ob_stream_profile_list *profile_list, int width, int height,
+                                                                             ob_format format, int fps, ob_error **error);
+
+/**
+ * @brief Match the corresponding ob_stream_profile through the passed parameters. If there are multiple matches,
+ * the first one in the list will be returned by default. If no matched profile is found, an error will be returned.
+ *
+ * @attention The stream profile returned by this function should be deleted by calling @ref ob_delete_stream_profile() when it is no longer needed.
+ *
+ * @param[in] profile_list Resolution list.
+ * @param[in] full_scale_range Full-scale range. If you don't need to add matching conditions, you can pass 0.
+ * @param[in] sample_rate Sample rate. If you don't need to add matching conditions, you can pass 0.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return The matching profile.
+ */
+OB_EXPORT ob_stream_profile *ob_stream_profile_list_get_accel_stream_profile(const ob_stream_profile_list *profile_list,
+                                                                             ob_accel_full_scale_range full_scale_range, ob_accel_sample_rate sample_rate,
+                                                                             ob_error **error);
+
+/**
+ * @brief Match the corresponding ob_stream_profile through the passed parameters. If there are multiple matches,
+ * the first one in the list will be returned by default. If no matched profile is found, an error will be returned.
+ *
+ * @attention The stream profile returned by this function should be deleted by calling @ref ob_delete_stream_profile() when it is no longer needed.
+ *
+ * @param[in] profile_list Resolution list.
+ * @param[in] full_scale_range Full-scale range. If you don't need to add matching conditions, you can pass 0.
+ * @param[in] sample_rate Sample rate. If you don't need to add matching conditions, you can pass 0.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ * @return The matching profile.
+ */
+OB_EXPORT ob_stream_profile *ob_stream_profile_list_get_gyro_stream_profile(const ob_stream_profile_list *profile_list,
+                                                                            ob_gyro_full_scale_range full_scale_range, ob_gyro_sample_rate sample_rate,
+                                                                            ob_error **error);
+
+/**
+ * @brief Delete the stream profile list.
+ *
+ * @param[in] profile_list Stream configuration list.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ */
+OB_EXPORT void ob_delete_stream_profile_list(const ob_stream_profile_list *profile_list, ob_error **error);
+
+// The following interfaces are deprecated and are retained here for compatibility purposes.
+#define ob_stream_profile_format ob_stream_profile_get_format
+#define ob_stream_profile_type ob_stream_profile_get_type
+#define ob_video_stream_profile_fps ob_video_stream_profile_get_fps
+#define ob_video_stream_profile_width ob_video_stream_profile_get_width
+#define ob_video_stream_profile_height ob_video_stream_profile_get_height
+#define ob_accel_stream_profile_full_scale_range ob_accel_stream_profile_get_full_scale_range
+#define ob_accel_stream_profile_sample_rate ob_accel_stream_profile_get_sample_rate
+#define ob_gyro_stream_profile_full_scale_range ob_gyro_stream_profile_get_full_scale_range
+#define ob_gyro_stream_profile_sample_rate ob_gyro_stream_profile_get_sample_rate
+#define ob_stream_profile_list_count ob_stream_profile_list_get_count
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/include/libobsensor/h/TypeHelper.h b/include/libobsensor/h/TypeHelper.h
new file mode 100644
index 00000000..c71328f1
--- /dev/null
+++ b/include/libobsensor/h/TypeHelper.h
@@ -0,0 +1,93 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "ObTypes.h"
+
+/**
+ * @brief Convert OBFormat to " char* " type and then return.
+ *
+ * @param[in] type OBFormat type.
+ * @return OBFormat of "char*" type.
+ */
+OB_EXPORT const char* ob_format_type_to_string(OBFormat type);
+
+/**
+ * @brief Convert OBFrameType to " char* " type and then return.
+ *
+ * @param[in] type OBFrameType type.
+ * @return OBFrameType of "char*" type.
+ */
+OB_EXPORT const char* ob_frame_type_to_string(OBFrameType type);
+
+/**
+ * @brief Convert OBStreamType to " char* " type and then return.
+ *
+ * @param[in] type OBStreamType type.
+ * @return OBStreamType of "char*" type.
+ */
+OB_EXPORT const char* ob_stream_type_to_string(OBStreamType type);
+
+/**
+ * @brief Convert OBSensorType to " char* " type and then return.
+ *
+ * @param[in] type OBSensorType type.
+ * @return OBSensorType of "char*" type.
+ */
+OB_EXPORT const char* ob_sensor_type_to_string(OBSensorType type);
+
+/**
+ * @brief Convert OBIMUSampleRate to " char* " type and then return.
+ *
+ * @param[in] type OBIMUSampleRate type.
+ * @return OBIMUSampleRate of "char*" type.
+ */
+OB_EXPORT const char* ob_imu_rate_type_to_string(OBIMUSampleRate type);
+
+/**
+ * @brief Convert OBGyroFullScaleRange to " char* " type and then return.
+ *
+ * @param[in] type OBGyroFullScaleRange type.
+ * @return OBGyroFullScaleRange of "char*" type.
+ */
+OB_EXPORT const char* ob_gyro_range_type_to_string(OBGyroFullScaleRange type);
+
+/**
+ * @brief Convert OBAccelFullScaleRange to " char* " type and then return.
+ *
+ * @param[in] type OBAccelFullScaleRange type.
+ * @return OBAccelFullScaleRange of "char*" type.
+ */
+OB_EXPORT const char* ob_accel_range_type_to_string(OBAccelFullScaleRange type);
+
+/**
+ * @brief Convert OBFrameMetadataType to " char* " type and then return.
+ *
+ * @param[in] type OBFrameMetadataType type.
+ * @return OBFrameMetadataType of "char*" type.
+ */
+OB_EXPORT const char* ob_meta_data_type_to_string(OBFrameMetadataType type);
+
+/**
+ * @brief Convert OBStreamType to OBSensorType.
+ *
+ * @param[in] type The sensor type to convert.
+ * @return OBStreamType The corresponding stream type.
+ */
+OB_EXPORT OBStreamType ob_sensor_type_to_stream_type(OBSensorType type);
+
+/**
+ * @brief Convert OBFormat to " char* " type and then return.
+ *
+ * @param format The OBFormat to convert.
+ * @return The string.
+ */
+OB_EXPORT const char *ob_format_to_string(OBFormat format);
+#ifdef __cplusplus
+}
+#endif
diff --git a/include/libobsensor/h/Utils.h b/include/libobsensor/h/Utils.h
new file mode 100644
index 00000000..043c084a
--- /dev/null
+++ b/include/libobsensor/h/Utils.h
@@ -0,0 +1,114 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "ObTypes.h"
+
+/**
+ * @brief Transform a 3d point of a source coordinate system into a 3d point of the target coordinate system.
+ *
+ * @param[in] source_point3f Source 3d point value
+ * @param[in] extrinsic Transformation matrix from source to target
+ * @param[out] target_point3f Target 3d point value
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ *
+ * @return bool Transform result
+ */
+OB_EXPORT bool ob_transformation_3d_to_3d(const OBPoint3f source_point3f, OBExtrinsic extrinsic, OBPoint3f *target_point3f, ob_error **error) ;
+
+
+/**
+ * @brief Transform a 2d pixel coordinate with an associated depth value of the source camera into a 3d point of the target coordinate system.
+ *
+ * @param[in] source_intrinsic Source intrinsic parameters
+ * @param[in] source_distortion Source distortion parameters
+ * @param[in] source_point2f Source 2d point value
+ * @param[in] source_depth_pixel_value The depth of sourcePoint2f in millimeters
+ * @param[in] extrinsic Transformation matrix from source to target
+ * @param[out] target_point3f Target 3d point value
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ *
+ * @return bool Transform result
+ */
+OB_EXPORT bool ob_transformation_2d_to_3d(const OBPoint2f source_point2f, const float source_depth_pixel_value, const OBCameraIntrinsic source_intrinsic, 
+                                         OBExtrinsic extrinsic, OBPoint3f *target_point3f, ob_error **error); 
+
+
+/**
+ * @brief Transform a 3d point of a source coordinate system into a 2d pixel coordinate of the target camera.
+ *
+ * @param[in] source_point3f Source 3d point value
+ * @param[in] target_intrinsic Target intrinsic parameters
+ * @param[in] target_distortion Target distortion parameters
+ * @param[in] extrinsic Transformation matrix from source to target
+ * @param[out] target_point2f Target 2d point value
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ *
+ * @return bool Transform result
+ */
+OB_EXPORT bool ob_transformation_3d_to_2d(const OBPoint3f source_point3f, const OBCameraIntrinsic target_intrinsic, const OBCameraDistortion target_distortion,
+                                          OBExtrinsic extrinsic, OBPoint2f *target_point2f, ob_error **error);
+
+/**
+ * @brief Transform a 2d pixel coordinate with an associated depth value of the source camera into a 2d pixel coordinate of the target camera
+ *
+ * @param[in] source_intrinsic Source intrinsic parameters
+ * @param[in] source_distortion Source distortion parameters
+ * @param[in] source_point2f Source 2d point value
+ * @param[in] source_depth_pixel_value The depth of sourcePoint2f in millimeters
+ * @param[in] target_intrinsic Target intrinsic parameters
+ * @param[in] target_distortion Target distortion parameters
+ * @param[in] extrinsic Transformation matrix from source to target
+ * @param[out] target_point2f Target 2d point value
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ *
+ * @return bool Transform result
+ */
+OB_EXPORT bool ob_transformation_2d_to_2d(const OBPoint2f source_point2f, const float source_depth_pixel_value, const OBCameraIntrinsic source_intrinsic, 
+                                        const OBCameraDistortion source_distortion, const OBCameraIntrinsic target_intrinsic, const OBCameraDistortion target_distortion,
+                                        OBExtrinsic extrinsic, OBPoint2f *target_point2f, ob_error **error);
+
+// \deprecated This function is deprecated and will be removed in a future version.  
+OB_EXPORT ob_frame *transformation_depth_frame_to_color_camera(ob_device *device, ob_frame *depth_frame, uint32_t target_color_camera_width,
+                                                     uint32_t target_color_camera_height, ob_error **error);
+
+// \deprecated This function is deprecated and will be removed in a future version.  
+OB_EXPORT bool transformation_init_xy_tables(const ob_calibration_param calibration_param, const ob_sensor_type sensor_type, float *data, uint32_t *data_size,
+                                   ob_xy_tables *xy_tables, ob_error **error);
+
+// \deprecated This function is deprecated and will be removed in a future version.  
+OB_EXPORT void transformation_depth_to_pointcloud(ob_xy_tables *xy_tables, const void *depth_image_data, void *pointcloud_data, ob_error **error);
+
+// \deprecated This function is deprecated and will be removed in a future version.  
+OB_EXPORT void transformation_depth_to_rgbd_pointcloud(ob_xy_tables *xy_tables, const void *depth_image_data, const void *color_image_data, void *pointcloud_data,
+                                             ob_error **error);
+
+// \deprecated This function is deprecated and will be removed in a future version.  
+//             Use the ob_transformation_3d_to_3d instead.
+OB_EXPORT bool ob_calibration_3d_to_3d(const ob_calibration_param calibration_param, const ob_point3f source_point3f, const ob_sensor_type source_sensor_type,
+                             const ob_sensor_type target_sensor_type, ob_point3f *target_point3f, ob_error **error);
+
+// \deprecated This function is deprecated and will be removed in a future version.  
+//             Use the ob_transformation_2d_to_3d instead.
+OB_EXPORT bool ob_calibration_2d_to_3d(const ob_calibration_param calibration_param, const ob_point2f source_point2f, const float source_depth_pixel_value,
+                             const ob_sensor_type source_sensor_type, const ob_sensor_type target_sensor_type, ob_point3f *target_point3f, ob_error **error);
+
+// \deprecated This function is deprecated and will be removed in a future version.  
+//             Use the ob_transformation_3d_to_2d instead.
+OB_EXPORT bool ob_calibration_3d_to_2d(const ob_calibration_param calibration_param, const ob_point3f source_point3f, const ob_sensor_type source_sensor_type,
+                             const ob_sensor_type target_sensor_type, ob_point2f *target_point2f, ob_error **error);
+
+// \deprecated This function is deprecated and will be removed in a future version.  
+//             Use the ob_transformation_2d_to_2d instead.
+OB_EXPORT bool ob_calibration_2d_to_2d(const ob_calibration_param calibration_param, const ob_point2f source_point2f, const float source_depth_pixel_value,
+                             const ob_sensor_type source_sensor_type, const ob_sensor_type target_sensor_type, ob_point2f *target_point2f, ob_error **error);
+
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/include/libobsensor/h/Version.h b/include/libobsensor/h/Version.h
new file mode 100644
index 00000000..b117a2f2
--- /dev/null
+++ b/include/libobsensor/h/Version.h
@@ -0,0 +1,55 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+/**
+ * @file Version.h
+ * @brief Functions for retrieving the SDK version number information.
+ *
+ */
+#pragma once
+
+#include "Export.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @brief Get the SDK version number.
+ *
+ * @return int The SDK version number.
+ */
+OB_EXPORT int ob_get_version();
+
+/**
+ * @brief Get the SDK major version number.
+ *
+ * @return int The SDK major version number.
+ */
+OB_EXPORT int ob_get_major_version();
+
+/**
+ * @brief Get the SDK minor version number.
+ *
+ * @return int The SDK minor version number.
+ */
+OB_EXPORT int ob_get_minor_version();
+
+/**
+ * @brief Get the SDK patch version number.
+ *
+ * @return int The SDK patch version number.
+ */
+OB_EXPORT int ob_get_patch_version();
+
+/**
+ * @brief Get the SDK stage version.
+ * @attention The returned char* does not need to be freed.
+ *
+ * @return const char* The SDK stage version.
+ */
+OB_EXPORT const char *ob_get_stage_version();
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/include/libobsensor/hpp/Context.hpp b/include/libobsensor/hpp/Context.hpp
new file mode 100644
index 00000000..b9c99d1e
--- /dev/null
+++ b/include/libobsensor/hpp/Context.hpp
@@ -0,0 +1,230 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+/**
+ * @file Context.hpp
+ * @brief The SDK context class, which serves as the entry point to the underlying SDK. It is used to query device lists, handle device callbacks, and set the
+ * log level.
+ *
+ */
+#pragma once
+
+#include "libobsensor/h/Context.h"
+#include "Types.hpp"
+#include "Error.hpp"
+
+#include <functional>
+#include <memory>
+
+namespace ob {
+
+// forward declarations
+class Device;
+class DeviceInfo;
+class DeviceList;
+
+class Context {
+public:
+    /**
+     * @brief Type definition for the device changed callback function.
+     *
+     * @param removedList The list of removed devices.
+     * @param addedList The list of added devices.
+     */
+    typedef std::function<void(std::shared_ptr<DeviceList> removedList, std::shared_ptr<DeviceList> addedList)> DeviceChangedCallback;
+
+    /**
+     * @brief Type definition for the log output callback function.
+     *
+     * @param severity The current callback log level.
+     * @param logMsg The log message.
+     */
+    typedef std::function<void(OBLogSeverity severity, const char *logMsg)> LogCallback;
+
+private:
+    ob_context           *impl_ = nullptr;
+    DeviceChangedCallback deviceChangedCallback_;
+    static LogCallback    logCallback_;
+
+public:
+    /**
+     * @brief Context constructor.
+     * @brief The Context class is a management class that describes the runtime of the SDK. It is responsible for applying and releasing resources for the SDK.
+     * The context has the ability to manage multiple devices, enumerate devices, monitor device callbacks, and enable functions such as multi-device
+     * synchronization.
+     *
+     * @param[in] configPath The path to the configuration file. If the path is empty, the default configuration will be used.
+     */
+    explicit Context(const char *configPath = "") {
+        ob_error *error = nullptr;
+        impl_           = ob_create_context_with_config(configPath, &error);
+        Error::handle(&error);
+    }
+
+    /**
+     * @brief Context destructor.
+     */
+    ~Context() noexcept {
+        ob_error *error = nullptr;
+        ob_delete_context(impl_, &error);
+        Error::handle(&error, false);
+    }
+
+    /**
+     * @brief Queries the enumerated device list.
+     *
+     * @return std::shared_ptr<DeviceList> A pointer to the device list class.
+     */
+    std::shared_ptr<DeviceList> queryDeviceList() const {
+        ob_error *error = nullptr;
+        auto      list  = ob_query_device_list(impl_, &error);
+        Error::handle(&error);
+        return std::make_shared<DeviceList>(list);
+    }
+
+    /**
+     * @brief enable or disable net device enumeration.
+     * @brief after enable, the net device will be discovered automatically and can be retrieved by @ref queryDeviceList. The default state can be set in the
+     * configuration file.
+     *
+     * @attention Net device enumeration by gvcp protocol, if the device is not in the same subnet as the host, it will be discovered but cannot be connected.
+     *
+     * @param[in] enable true to enable, false to disable
+     */
+    void enableNetDeviceEnumeration(bool enable) const {
+        ob_error *error = nullptr;
+        ob_enable_net_device_enumeration(impl_, enable, &error);
+        Error::handle(&error);
+    }
+
+    /**
+     * @brief Creates a network device with the specified IP address and port.
+     *
+     * @param[in] address The IP address, ipv4 only. such as "192.168.1.10"
+     * @param[in] port The port number， currently only support 8090
+     * @return std::shared_ptr<Device> The created device object.
+     */
+    std::shared_ptr<Device> createNetDevice(const char *address, uint16_t port) const {
+        ob_error *error  = nullptr;
+        auto      device = ob_create_net_device(impl_, address, port, &error);
+        Error::handle(&error);
+        return std::make_shared<Device>(device);
+    }
+
+    /**
+     * @brief Set the device plug-in callback function.
+     *
+     * @param callback The function triggered when the device is plugged and unplugged.
+     */
+    void setDeviceChangedCallback(DeviceChangedCallback callback) {
+        deviceChangedCallback_ = callback;
+        ob_error *error        = nullptr;
+        ob_set_device_changed_callback(impl_, &Context::deviceChangedCallback, this, &error);
+        Error::handle(&error);
+    }
+
+    /**
+     * @brief Activates device clock synchronization to synchronize the clock of the host and all created devices (if supported).
+     *
+     * @param repeatInterval The interval for auto-repeated synchronization, in milliseconds. If the value is 0, synchronization is performed only once.
+     */
+    void enableDeviceClockSync(uint64_t repeatIntervalMsec) const {
+        ob_error *error = nullptr;
+        ob_enable_device_clock_sync(impl_, repeatIntervalMsec, &error);
+        Error::handle(&error);
+    }
+
+    /**
+     * @brief Frees idle memory from the internal frame memory pool.
+     * @brief The SDK includes an internal frame memory pool that caches memory allocated for frames received from devices.
+     */
+    void freeIdleMemory() const {
+        ob_error *error = nullptr;
+        ob_free_idle_memory(impl_, &error);
+        Error::handle(&error);
+    }
+
+    /**
+     * @brief Set the level of the global log, which affects both the log level output to the console, output to the file and output the user defined callback.
+     *
+     * @param severity The log output level.
+     */
+    static void setLoggerSeverity(OBLogSeverity severity) {
+        ob_error *error = nullptr;
+        ob_set_logger_severity(severity, &error);
+        Error::handle(&error);
+    }
+
+    /**
+     * @brief Set log output to a file.
+     *
+     * @param severity The log level output to the file.
+     * @param directory The log file output path. If the path is empty, the existing settings will continue to be used (if the existing configuration is also
+     * empty, the log will not be output to the file).
+     */
+    static void setLoggerToFile(OBLogSeverity severity, const char *directory) {
+        ob_error *error = nullptr;
+        ob_set_logger_to_file(severity, directory, &error);
+        Error::handle(&error);
+    }
+
+    /**
+     * @brief Set log output to the console.
+     *
+     * @param severity The log level output to the console.
+     */
+    static void setLoggerToConsole(OBLogSeverity severity) {
+        ob_error *error = nullptr;
+        ob_set_logger_to_console(severity, &error);
+        Error::handle(&error);
+    }
+
+    /**
+     * @brief Set the logger to callback.
+     *
+     * @param severity The callback log level.
+     * @param callback The callback function.
+     */
+    static void setLoggerToCallback(OBLogSeverity severity, LogCallback callback) {
+        ob_error *error       = nullptr;
+        Context::logCallback_ = callback;
+        ob_set_logger_to_callback(severity, &Context::logCallback, &Context::logCallback_, &error);
+        Error::handle(&error);
+    }
+
+    /**
+     * @brief Set the extensions directory
+     * @brief The extensions directory is used to search for dynamic libraries that provide additional functionality to the SDK， such as the Frame filters.
+     *
+     * @attention Should be called before creating the context and pipeline, otherwise the default extensions directory (./extensions) will be used.
+     *
+     * @param directory Path to the extensions directory. If the path is empty, the existing settings will continue to be used (if the existing
+     */
+    static void setExtensionsDirectory(const char *directory) {
+        ob_error *error = nullptr;
+        ob_set_extensions_directory(directory, &error);
+        Error::handle(&error);
+    }
+
+private:
+    static void deviceChangedCallback(ob_device_list *removedList, ob_device_list *addedList, void *userData) {
+        auto ctx = static_cast<Context *>(userData);
+        if(ctx && ctx->deviceChangedCallback_) {
+            auto removed = std::make_shared<DeviceList>(removedList);
+            auto added   = std::make_shared<DeviceList>(addedList);
+            ctx->deviceChangedCallback_(removed, added);
+        }
+    }
+
+    static void logCallback(OBLogSeverity severity, const char *logMsg, void *userData) {
+        auto cb = static_cast<LogCallback *>(userData);
+        if(cb) {
+            (*cb)(severity, logMsg);
+        }
+    }
+
+// for backward compatibility
+#define enableMultiDeviceSync enableDeviceClockSync
+};
+}  // namespace ob
+
diff --git a/include/libobsensor/hpp/Device.hpp b/include/libobsensor/hpp/Device.hpp
new file mode 100644
index 00000000..54669655
--- /dev/null
+++ b/include/libobsensor/hpp/Device.hpp
@@ -0,0 +1,1364 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+/**
+ * @file Device.hpp
+ * @brief Device related types, including operations such as getting and creating a device, setting and obtaining device attributes, and obtaining sensors
+ *
+ */
+#pragma once
+#include "Types.hpp"
+
+#include "libobsensor/h/Property.h"
+#include "libobsensor/h/Device.h"
+#include "libobsensor/h/Advanced.h"
+#include "libobsensor/hpp/Filter.hpp"
+#include "libobsensor/hpp/Sensor.hpp"
+
+#include "Error.hpp"
+#include <memory>
+#include <string>
+#include <vector>
+#include <thread>
+#include <chrono>
+
+namespace ob {
+
+class DeviceInfo;
+class SensorList;
+class DevicePresetList;
+class OBDepthWorkModeList;
+class CameraParamList;
+
+class Device {
+public:
+    /**
+     * @brief Callback function for device firmware update progress
+     *
+     * @param state The device firmware update status.
+     * @param message Status information.
+     * @param percent The percentage of the update progress.
+     */
+    typedef std::function<void(OBFwUpdateState state, const char *message, uint8_t percent)> DeviceFwUpdateCallback;
+
+    /**
+     * @brief Callback function for device status updates.
+     *
+     * @param state The device status.
+     * @param message Status information.
+     */
+    typedef std::function<void(OBDeviceState state, const char *message)> DeviceStateChangedCallback;
+
+protected:
+    ob_device                 *impl_ = nullptr;
+    DeviceStateChangedCallback deviceStateChangeCallback_;
+    DeviceFwUpdateCallback     fwUpdateCallback_;
+
+public:
+    /**
+     * @brief Describe the entity of the RGBD camera, representing a specific model of RGBD camera
+     */
+    explicit Device(ob_device_t *impl) : impl_(impl) {}
+
+    Device(Device &&other) noexcept : impl_(other.impl_) {
+        other.impl_ = nullptr;
+    }
+
+    Device &operator=(Device &&other) noexcept {
+        if(this != &other) {
+            ob_error *error = nullptr;
+            ob_delete_device(impl_, &error);
+            Error::handle(&error);
+            impl_       = other.impl_;
+            other.impl_ = nullptr;
+        }
+        return *this;
+    }
+
+    Device(const Device &)            = delete;
+    Device &operator=(const Device &) = delete;
+
+    virtual ~Device() noexcept {
+        ob_error *error = nullptr;
+        ob_delete_device(impl_, &error);
+        Error::handle(&error, false);
+    }
+
+    ob_device_t *getImpl() const {
+        return impl_;
+    }
+
+    /**
+     * @brief Get device information
+     *
+     * @return std::shared_ptr<DeviceInfo> return device information
+     */
+    std::shared_ptr<DeviceInfo> getDeviceInfo() const {
+        ob_error *error = nullptr;
+        auto      info  = ob_device_get_device_info(impl_, &error);
+        Error::handle(&error);
+        return std::make_shared<DeviceInfo>(info);
+    }
+
+    /**
+     * @brief Check if the extension information is exist
+     *
+     * @param infoKey The key of the extension information
+     * @return bool Whether the extension information exists
+     */
+    bool isExtensionInfoExist(const std::string &infoKey) const {
+        ob_error *error = nullptr;
+        auto      exist = ob_device_is_extension_info_exist(impl_, infoKey.c_str(), &error);
+        Error::handle(&error);
+        return exist;
+    }
+
+    /**
+     * @brief Get information about extensions obtained from SDK supported by the device
+     *
+     * @param infoKey The key of the extension information
+     * @return const char* Returns extended information about the device
+     */
+    const char *getExtensionInfo(const std::string &infoKey) const {
+        ob_error   *error = nullptr;
+        const char *info  = ob_device_get_extension_info(impl_, infoKey.c_str(), &error);
+        Error::handle(&error);
+        return info;
+    }
+
+    /**
+     * @brief Get device sensor list
+     *
+     * @return std::shared_ptr<SensorList> return the sensor list
+     */
+    std::shared_ptr<SensorList> getSensorList() const {
+        ob_error *error = nullptr;
+        auto      list  = ob_device_get_sensor_list(impl_, &error);
+        Error::handle(&error);
+        return std::make_shared<SensorList>(list);
+    }
+
+    /**
+     * @brief Get specific type of sensor
+     * if device not open, SDK will automatically open the connected device and return to the instance
+     *
+     * @return std::shared_ptr<Sensor> return the sensor example, if the device does not have the device,return nullptr
+     */
+    std::shared_ptr<Sensor> getSensor(OBSensorType type) const {
+        ob_error *error  = nullptr;
+        auto      sensor = ob_device_get_sensor(impl_, type, &error);
+        Error::handle(&error);
+        return std::make_shared<Sensor>(sensor);
+    }
+
+    /**
+     * @brief Set int type of device property
+     *
+     * @param propertyId Property id
+     * @param value Property value to be set
+     */
+    void setIntProperty(OBPropertyID propertyId, int32_t value) const {
+        ob_error *error = nullptr;
+        ob_device_set_int_property(impl_, propertyId, value, &error);
+        Error::handle(&error);
+    }
+
+    /**
+     * @brief Set float type of device property
+     *
+     * @param propertyId Property id
+     * @param value Property value to be set
+     */
+    void setFloatProperty(OBPropertyID propertyId, float value) const {
+        ob_error *error = nullptr;
+        ob_device_set_float_property(impl_, propertyId, value, &error);
+        Error::handle(&error);
+    }
+
+    /**
+     * @brief Set bool type of device property
+     *
+     * @param propertyId Property id
+     * @param value Property value to be set
+     */
+    void setBoolProperty(OBPropertyID propertyId, bool value) const {
+        ob_error *error = nullptr;
+        ob_device_set_bool_property(impl_, propertyId, value, &error);
+        Error::handle(&error);
+    }
+
+    /**
+     * @brief Get int type of device property
+     *
+     * @param propertyId Property id
+     * @return int32_t Property to get
+     */
+    int32_t getIntProperty(OBPropertyID propertyId) const {
+        ob_error *error = nullptr;
+        auto      value = ob_device_get_int_property(impl_, propertyId, &error);
+        Error::handle(&error);
+        return value;
+    }
+
+    /**
+     * @brief Get float type of device property
+     *
+     * @param propertyId Property id
+     * @return float Property to get
+     */
+    float getFloatProperty(OBPropertyID propertyId) const {
+        ob_error *error = nullptr;
+        auto      value = ob_device_get_float_property(impl_, propertyId, &error);
+        Error::handle(&error);
+        return value;
+    }
+
+    /**
+     * @brief Get bool type of device property
+     *
+     * @param propertyId Property id
+     * @return bool Property to get
+     */
+    bool getBoolProperty(OBPropertyID propertyId) const {
+        ob_error *error = nullptr;
+        auto      value = ob_device_get_bool_property(impl_, propertyId, &error);
+        Error::handle(&error);
+        return value;
+    }
+
+    /**
+     * @brief Get int type device property range (including current value and default value)
+     *
+     * @param propertyId Property id
+     * @return OBIntPropertyRange Property range
+     */
+    OBIntPropertyRange getIntPropertyRange(OBPropertyID propertyId) const {
+        ob_error *error = nullptr;
+        auto      range = ob_device_get_int_property_range(impl_, propertyId, &error);
+        Error::handle(&error);
+        return range;
+    }
+
+    /**
+     * @brief Get float type device property range((including current value and default value)
+     *
+     * @param propertyId Property id
+     * @return OBFloatPropertyRange Property range
+     */
+    OBFloatPropertyRange getFloatPropertyRange(OBPropertyID propertyId) const {
+        ob_error *error = nullptr;
+        auto      range = ob_device_get_float_property_range(impl_, propertyId, &error);
+        Error::handle(&error);
+        return range;
+    }
+
+    /**
+     * @brief Get bool type device property range (including current value and default value)
+     *
+     * @param propertyId The ID of the property
+     * @return OBBoolPropertyRange The range of the property
+     */
+    OBBoolPropertyRange getBoolPropertyRange(OBPropertyID propertyId) const {
+        ob_error *error = nullptr;
+        auto      range = ob_device_get_bool_property_range(impl_, propertyId, &error);
+        Error::handle(&error);
+        return range;
+    }
+
+    /**
+     * @brief Set the structured data type of a device property
+     *
+     * @param propertyId The ID of the property
+     * @param data The data to set
+     * @param dataSize The size of the data to set
+     */
+    void setStructuredData(OBPropertyID propertyId, const uint8_t *data, uint32_t dataSize) const {
+        ob_error *error = nullptr;
+        ob_device_set_structured_data(impl_, propertyId, data, dataSize, &error);
+        Error::handle(&error);
+    }
+
+    /**
+     * @brief Get the structured data type of a device property
+     *
+     * @param propertyId The ID of the property
+     * @param data The property data obtained
+     * @param dataSize The size of the data obtained
+     */
+    void getStructuredData(OBPropertyID propertyId, uint8_t *data, uint32_t *dataSize) const {
+        ob_error *error = nullptr;
+        ob_device_get_structured_data(impl_, propertyId, data, dataSize, &error);
+        Error::handle(&error);
+    }
+
+    /**
+     * @brief Get the number of properties supported by the device
+     *
+     * @return The number of supported properties
+     */
+    int getSupportedPropertyCount() const {
+        ob_error *error = nullptr;
+        auto      count = ob_device_get_supported_property_count(impl_, &error);
+        Error::handle(&error);
+        return count;
+    }
+
+    /**
+     * @brief Get the supported properties of the device
+     *
+     * @param index The index of the property
+     * @return The type of supported property
+     */
+    OBPropertyItem getSupportedProperty(uint32_t index) const {
+        ob_error *error = nullptr;
+        auto      item  = ob_device_get_supported_property_item(impl_, index, &error);
+        Error::handle(&error);
+        return item;
+    }
+
+    /**
+     * @brief Check if a property permission is supported
+     *
+     * @param propertyId The ID of the property
+     * @param permission The read and write permissions to check
+     * @return Whether the property permission is supported
+     */
+    bool isPropertySupported(OBPropertyID propertyId, OBPermissionType permission) const {
+        ob_error *error  = nullptr;
+        auto      result = ob_device_is_property_supported(impl_, propertyId, permission, &error);
+        Error::handle(&error);
+        return result;
+    }
+
+    /**
+     * @brief Check if the global timestamp is supported for the device
+     *
+     * @return Whether the global timestamp is supported
+     */
+    bool isGlobalTimestampSupported() const {
+        ob_error *error  = nullptr;
+        auto      result = ob_device_is_global_timestamp_supported(impl_, &error);
+        Error::handle(&error);
+        return result;
+    }
+
+    /**
+     * @brief Enable or disable the global timestamp
+     *
+     * @param enable Whether to enable the global timestamp
+     */
+    void enableGlobalTimestamp(bool enable) {
+        ob_error *error = nullptr;
+        ob_device_enable_global_timestamp(impl_, enable, &error);
+        Error::handle(&error);
+    }
+
+    /**
+     * @brief Update the device firmware
+     *
+     * @param filePath Firmware path
+     * @param callback Firmware Update progress and status callback
+     * @param async Whether to execute asynchronously
+     */
+    void updateFirmware(const char *filePath, DeviceFwUpdateCallback callback, bool async = true) {
+        ob_error *error   = nullptr;
+        fwUpdateCallback_ = callback;
+        ob_device_update_firmware(impl_, filePath, &Device::firmwareUpdateCallback, async, this, &error);
+        Error::handle(&error);
+    }
+
+    /**
+     * @brief Update the device firmware from data
+     *
+     * @param firmwareData Firmware data
+     * @param firmwareDataSize Firmware data size
+     * @param callback Firmware Update progress and status callback
+     * @param async Whether to execute asynchronously
+     */
+    void updateFirmwareFromData(const uint8_t *firmwareData, uint32_t firmwareDataSize, DeviceFwUpdateCallback callback, bool async = true) {
+        ob_error *error   = nullptr;
+        fwUpdateCallback_ = callback;
+        ob_device_update_firmware_from_data(impl_, firmwareData, firmwareDataSize, &Device::firmwareUpdateCallback, async, this, &error);
+        Error::handle(&error);
+    }
+
+    /**
+     * @brief Set the device state changed callbacks
+     *
+     * @param callback The callback function that is triggered when the device status changes (for example, the frame rate is automatically reduced or the
+     * stream is closed due to high temperature, etc.)
+     */
+    void setDeviceStateChangedCallback(DeviceStateChangedCallback callback) {
+        ob_error *error            = nullptr;
+        deviceStateChangeCallback_ = callback;
+        ob_device_set_state_changed_callback(impl_, &Device::deviceStateChangedCallback, this, &error);
+        Error::handle(&error);
+    }
+
+    static void deviceStateChangedCallback(OBDeviceState state, const char *message, void *userData) {
+        auto device = static_cast<Device *>(userData);
+        device->deviceStateChangeCallback_(state, message);
+    }
+
+    /**
+     * @brief Get current depth work mode
+     *
+     * @return ob_depth_work_mode Current depth work mode
+     */
+    OBDepthWorkMode getCurrentDepthWorkMode() const {
+        ob_error *error = nullptr;
+        auto      mode  = ob_device_get_current_depth_work_mode(impl_, &error);
+        Error::handle(&error);
+        return mode;
+    }
+
+    /**
+     * @brief Get current depth mode name
+     * @brief According the current preset name to return current depth mode name
+     * @return const char* return the current depth mode name.
+     */
+    const char *getCurrentDepthModeName() {
+        ob_error *error = nullptr;
+        auto      name  = ob_device_get_current_depth_work_mode_name(impl_, &error);
+        Error::handle(&error);
+        return name;
+    }
+
+    /**
+     * @brief Switch depth work mode by OBDepthWorkMode. Prefer invoke switchDepthWorkMode(const char *modeName) to switch depth mode
+     * when known the complete name of depth work mode.
+     * @param[in] workMode Depth work mode come from ob_depth_work_mode_list which return by ob_device_get_depth_work_mode_list
+     */
+    OBStatus switchDepthWorkMode(const OBDepthWorkMode &workMode) const {
+        ob_error *error  = nullptr;
+        auto      status = ob_device_switch_depth_work_mode(impl_, &workMode, &error);
+        Error::handle(&error);
+        return status;
+    }
+
+    /**
+     * @brief Switch depth work mode by work mode name.
+     *
+     * @param[in] modeName Depth work mode name which equals to OBDepthWorkMode.name
+     */
+    OBStatus switchDepthWorkMode(const char *modeName) const {
+        ob_error *error  = nullptr;
+        auto      status = ob_device_switch_depth_work_mode_by_name(impl_, modeName, &error);
+        Error::handle(&error);
+        return status;
+    }
+
+    /**
+     * @brief Request support depth work mode list
+     * @return OBDepthWorkModeList list of ob_depth_work_mode
+     */
+    std::shared_ptr<OBDepthWorkModeList> getDepthWorkModeList() const {
+        ob_error *error = nullptr;
+        auto      list  = ob_device_get_depth_work_mode_list(impl_, &error);
+        Error::handle(&error);
+        return std::make_shared<OBDepthWorkModeList>(list);
+    }
+
+    /**
+     * @brief Device restart
+     * @attention The device will be disconnected and reconnected. After the device is disconnected, the access to the Device object interface may be abnormal.
+     * Please delete the object directly and obtain it again after the device is reconnected.
+     */
+    void reboot() const {
+        ob_error *error = nullptr;
+        ob_device_reboot(impl_, &error);
+        Error::handle(&error);
+    }
+
+    /**
+     * @brief Device restart delay mode
+     * @attention The device will be disconnected and reconnected. After the device is disconnected, the access to the Device object interface may be abnormal.
+     *   Please delete the object directly and obtain it again after the device is reconnected.
+     * Support devices: Gemini2 L
+     *
+     * @param[in] delayMs Time unit：ms。delayMs == 0：No delay；delayMs > 0, Delay millisecond connect to host device after reboot
+     */
+    void reboot(uint32_t delayMs) const {
+        setIntProperty(OB_PROP_DEVICE_REBOOT_DELAY_INT, delayMs);
+        reboot();
+    }
+
+    /**
+     * @brief Enable or disable the device heartbeat.
+     * @brief After enable the device heartbeat, the sdk will start a thread to send heartbeat signal to the device error every 3 seconds.
+     *
+     * @attention If the device does not receive the heartbeat signal for a long time, it will be disconnected and rebooted.
+     *
+     * @param[in] enable Whether to enable the device heartbeat.
+     */
+    void enableHeartbeat(bool enable) const {
+        ob_error *error = nullptr;
+        ob_device_enable_heartbeat(impl_, enable, &error);
+        Error::handle(&error);
+    }
+
+    /**
+     * @brief Get the supported multi device sync mode bitmap of the device.
+     * @brief For example, if the return value is 0b00001100, it means the device supports @ref OB_MULTI_DEVICE_SYNC_MODE_PRIMARY and @ref
+     * OB_MULTI_DEVICE_SYNC_MODE_SECONDARY. User can check the supported mode by the code:
+     * ```c
+     * if(supported_mode_bitmap & OB_MULTI_DEVICE_SYNC_MODE_FREE_RUN){
+     * //support OB_MULTI_DEVICE_SYNC_MODE_FREE_RUN
+     * }
+     * if(supported_mode_bitmap & OB_MULTI_DEVICE_SYNC_MODE_STANDALONE){
+     * //support OB_MULTI_DEVICE_SYNC_MODE_STANDALONE
+     * }
+     * // and so on
+     * ```
+     * @return uint16_t return the supported multi device sync mode bitmap of the device.
+     */
+    uint16_t getSupportedMultiDeviceSyncModeBitmap() const {
+        ob_error *error = nullptr;
+        auto      mode  = ob_device_get_supported_multi_device_sync_mode_bitmap(impl_, &error);
+        Error::handle(&error);
+        return mode;
+    }
+
+    /**
+     * @brief set the multi device sync configuration of the device.
+     *
+     * @param[in] config The multi device sync configuration.
+     */
+    void setMultiDeviceSyncConfig(const OBMultiDeviceSyncConfig &config) const {
+        ob_error *error = nullptr;
+        ob_device_set_multi_device_sync_config(impl_, &config, &error);
+        Error::handle(&error);
+    }
+
+    /**
+     * @brief get the multi device sync configuration of the device.
+     *
+     * @return OBMultiDeviceSyncConfig return the multi device sync configuration of the device.
+     */
+    OBMultiDeviceSyncConfig getMultiDeviceSyncConfig() const {
+        ob_error *error  = nullptr;
+        auto      config = ob_device_get_multi_device_sync_config(impl_, &error);
+        Error::handle(&error);
+        return config;
+    }
+
+    /**
+     * @brief send the capture command to the device.
+     * @brief The device will start one time image capture after receiving the capture command when it is in the @ref
+     * OB_MULTI_DEVICE_SYNC_MODE_SOFTWARE_TRIGGERING
+     *
+     * @attention The frequency of the user call this function multiplied by the number of frames per trigger should be less than the frame rate of the stream.
+     * The number of frames per trigger can be set by @ref framesPerTrigger.
+     * @attention For some models，receive and execute the capture command will have a certain delay and performance consumption, so the frequency of calling
+     * this function should not be too high, please refer to the product manual for the specific supported frequency.
+     * @attention If the device is not in the @ref OB_MULTI_DEVICE_SYNC_MODE_HARDWARE_TRIGGERING mode, device will ignore the capture command.
+     */
+    void triggerCapture() const {
+        ob_error *error = nullptr;
+        ob_device_trigger_capture(impl_, &error);
+        Error::handle(&error);
+    }
+
+    /**
+     * @brief set the timestamp reset configuration of the device.
+     */
+    void setTimestampResetConfig(const OBDeviceTimestampResetConfig &config) const {
+        ob_error *error = nullptr;
+        ob_device_set_timestamp_reset_config(impl_, &config, &error);
+        Error::handle(&error);
+    }
+
+    /**
+     * @brief get the timestamp reset configuration of the device.
+     *
+     * @return OBDeviceTimestampResetConfig return the timestamp reset configuration of the device.
+     */
+    OBDeviceTimestampResetConfig getTimestampResetConfig() const {
+        ob_error *error  = nullptr;
+        auto      config = ob_device_get_timestamp_reset_config(impl_, &error);
+        Error::handle(&error);
+        return config;
+    }
+
+    /**
+     * @brief send the timestamp reset command to the device.
+     * @brief The device will reset the timer for calculating the timestamp for output frames to 0 after receiving the timestamp reset command when the
+     * timestamp reset function is enabled. The timestamp reset function can be enabled by call @ref ob_device_set_timestamp_reset_config.
+     * @brief Before calling this function, user should call @ref ob_device_set_timestamp_reset_config to disable the timestamp reset function (It is not
+     * required for some models, but it is still recommended to do so for code compatibility).
+     *
+     * @attention If the stream of the device is started, the timestamp of the continuous frames output by the stream will jump once after the timestamp reset.
+     * @attention Due to the timer of device is not high-accuracy, the timestamp of the continuous frames output by the stream will drift after a long time.
+     * User can call this function periodically to reset the timer to avoid the timestamp drift, the recommended interval time is 60 minutes.
+     */
+    void timestampReset() const {
+        ob_error *error = nullptr;
+        ob_device_timestamp_reset(impl_, &error);
+        Error::handle(&error);
+    }
+
+    /**
+     * @brief Alias for @ref timestampReset since it is more accurate.
+     */
+#define timerReset timestampReset
+
+    /**
+     * @brief synchronize the timer of the device with the host.
+     * @brief After calling this function, the timer of the device will be synchronized with the host. User can call this function to multiple devices to
+     * synchronize all timers of the devices.
+     *
+     * @attention If the stream of the device is started, the timestamp of the continuous frames output by the stream will may jump once after the timer
+     * sync.
+     * @attention Due to the timer of device is not high-accuracy, the timestamp of the continuous frames output by the stream will drift after a long time.
+     * User can call this function periodically to synchronize the timer to avoid the timestamp drift, the recommended interval time is 60 minutes.
+     *
+     */
+    void timerSyncWithHost() const {
+        ob_error *error = nullptr;
+        ob_device_timer_sync_with_host(impl_, &error);
+        Error::handle(&error);
+    }
+
+    /**
+     * @brief Get current preset name
+     * @brief The preset mean a set of parameters or configurations that can be applied to the device to achieve a specific effect or function.
+     * @return const char* return the current preset name, it should be one of the preset names returned by @ref getAvailablePresetList.
+     */
+    const char *getCurrentPresetName() const {
+        ob_error   *error = nullptr;
+        const char *name  = ob_device_get_current_preset_name(impl_, &error);
+        Error::handle(&error);
+        return name;
+    }
+
+    /**
+     * @brief load the preset according to the preset name.
+     * @attention After loading the preset, the settings in the preset will set to the device immediately. Therefore, it is recommended to re-read the device
+     * settings to update the user program temporarily.
+     * @param presetName The preset name to set. The name should be one of the preset names returned by @ref getAvailablePresetList.
+     */
+    void loadPreset(const char *presetName) const {
+        ob_error *error = nullptr;
+        ob_device_load_preset(impl_, presetName, &error);
+        Error::handle(&error);
+    }
+
+    /**
+     * @brief Get available preset list
+     * @brief The available preset list usually defined by the device manufacturer and restores on the device.
+     * @brief User can load the custom preset by calling @ref loadPresetFromJsonFile to append the available preset list.
+     *
+     * @return DevicePresetList return the available preset list.
+     */
+    std::shared_ptr<DevicePresetList> getAvailablePresetList() const {
+        ob_error *error = nullptr;
+        auto      list  = ob_device_get_available_preset_list(impl_, &error);
+        Error::handle(&error);
+        return std::make_shared<DevicePresetList>(list);
+    }
+
+    /**
+     * @brief Load custom preset from file.
+     * @brief After loading the custom preset, the settings in the custom preset will set to the device immediately.
+     * @brief After loading the custom preset, the available preset list will be appended with the custom preset and named as the file name.
+     *
+     * @attention The user should ensure that the custom preset file is adapted to the device and the settings in the file are valid.
+     * @attention It is recommended to re-read the device settings to update the user program temporarily after successfully loading the custom preset.
+     *
+     * @param filePath The path of the custom preset file.
+     */
+    void loadPresetFromJsonFile(const char *filePath) const {
+        ob_error *error = nullptr;
+        ob_device_load_preset_from_json_file(impl_, filePath, &error);
+        Error::handle(&error);
+    }
+
+    /**
+     * @brief Load custom preset from data.
+     * @brief After loading the custom preset, the settings in the custom preset will set to the device immediately.
+     * @brief After loading the custom preset, the available preset list will be appended with the custom preset and named as the @ref presetName.
+     *
+     * @attention The user should ensure that the custom preset data is adapted to the device and the settings in the data are valid.
+     * @attention It is recommended to re-read the device settings to update the user program temporarily after successfully loading the custom preset.
+     *
+     * @param data The custom preset data.
+     * @param size The size of the custom preset data.
+     */
+    void loadPresetFromJsonData(const char *presetName, const uint8_t *data, uint32_t size) {
+        ob_error *error = nullptr;
+        ob_device_load_preset_from_json_data(impl_, presetName, data, size, &error);
+    }
+
+    /**
+     * @brief Export current device settings as a preset json data.
+     * @brief After exporting the preset, a new preset named as the @ref presetName will be added to the available preset list.
+     *
+     * @attention The memory of the data is allocated by the SDK, and will automatically be released by the SDK.
+     * @attention The memory of the data will be reused by the SDK on the next call, so the user should copy the data to a new buffer if it needs to be
+     * preserved.
+     *
+     * @param[out] data return the preset json data.
+     * @param[out] dataSize return the size of the preset json data.
+     */
+    void exportSettingsAsPresetJsonData(const char *presetName, const uint8_t **data, uint32_t *dataSize) {
+        ob_error *error = nullptr;
+        ob_device_export_current_settings_as_preset_json_data(impl_, presetName, data, dataSize, &error);
+    }
+
+    /**
+     * @brief Export current device settings as a preset json file.
+     * @brief The exported preset file can be loaded by calling @ref loadPresetFromJsonFile to restore the device setting.
+     * @brief After exporting the preset, a new preset named as the @ref filePath will be added to the available preset list.
+     *
+     * @param filePath The path of the preset file to be exported.
+     */
+    void exportSettingsAsPresetJsonFile(const char *filePath) const {
+        ob_error *error = nullptr;
+        ob_device_export_current_settings_as_preset_json_file(impl_, filePath, &error);
+        Error::handle(&error);
+    }
+
+    /**
+     * @brief Get the current device status.
+     *
+     * @return OBDeviceState The device state information.
+     */
+    OBDeviceState getDeviceState() {
+        OBDeviceState state = {};
+        ob_error     *error = nullptr;
+        state               = ob_device_get_device_state(impl_, &error);
+        return state;
+    }
+
+    /**
+     * @brief Send data to the device and receive data from the device.
+     * @brief This is a factory and debug function, which can be used to send and receive data from the device. The data format is secret and belongs to the
+     * device vendor.
+     *
+     * @attention The send and receive data buffer are managed by the caller, the receive data buffer should be allocated at 1024 bytes or larger.
+     *
+     * @param[in] sendData The data to be sent to the device.
+     * @param[in] sendDataSize The size of the data to be sent to the device.
+     * @param[out] receiveData The data received from the device.
+     * @param[in out] receiveDataSize The requeseted size of the data received from the device, and the actual size of the data received from the device.
+     */
+    void sendAndReceiveData(const uint8_t *sendData, uint32_t sendDataSize, uint8_t *receiveData, uint32_t *receiveDataSize) const {
+        ob_error *error = nullptr;
+        ob_device_send_and_receive_data(impl_, sendData, sendDataSize, receiveData, receiveDataSize, &error);
+        Error::handle(&error);
+    }
+
+private:
+    static void firmwareUpdateCallback(ob_fw_update_state state, const char *message, uint8_t percent, void *userData) {
+        auto device = static_cast<Device *>(userData);
+        if(device && device->fwUpdateCallback_) {
+            device->fwUpdateCallback_(state, message, percent);
+        }
+    }
+
+public:
+    // The following interfaces are deprecated and are retained here for compatibility purposes.
+    void deviceUpgrade(const char *filePath, DeviceFwUpdateCallback callback, bool async = true) {
+        updateFirmware(filePath, callback, async);
+    }
+
+    void deviceUpgradeFromData(const uint8_t *firmwareData, uint32_t firmwareDataSize, DeviceFwUpdateCallback callback, bool async = true) {
+        updateFirmwareFromData(firmwareData, firmwareDataSize, callback, async);
+    }
+
+    std::shared_ptr<CameraParamList> getCalibrationCameraParamList() {
+        ob_error *error = nullptr;
+        auto      impl  = ob_device_get_calibration_camera_param_list(impl_, &error);
+        Error::handle(&error);
+        return std::make_shared<CameraParamList>(impl);
+    }
+
+    void loadDepthFilterConfig(const char *filePath) {
+        // In order to compile, some high-version compilers will warn that the function parameters are not used.
+        (void)filePath;
+    }
+};
+
+/**
+ * @brief A class describing device information, representing the name, id, serial number and other basic information of an RGBD camera.
+ */
+class DeviceInfo {
+private:
+    ob_device_info_t *impl_ = nullptr;
+
+public:
+    explicit DeviceInfo(ob_device_info_t *impl) : impl_(impl) {}
+    ~DeviceInfo() noexcept {
+        ob_error *error = nullptr;
+        ob_delete_device_info(impl_, &error);
+        Error::handle(&error, false);
+    }
+
+    /**
+     * @brief Get device name
+     *
+     * @return const char * return the device name
+     */
+    const char *getName() const {
+        ob_error   *error = nullptr;
+        const char *name  = ob_device_info_get_name(impl_, &error);
+        Error::handle(&error);
+        return name;
+    }
+
+    /**
+     * @brief Get the pid of the device
+     *
+     * @return int return the pid of the device
+     */
+    int getPid() const {
+        ob_error *error = nullptr;
+        int       pid   = ob_device_info_get_pid(impl_, &error);
+        Error::handle(&error);
+        return pid;
+    }
+
+    /**
+     * @brief Get the vid of the device
+     *
+     * @return int return the vid of the device
+     */
+    int getVid() const {
+        ob_error *error = nullptr;
+        int       vid   = ob_device_info_get_vid(impl_, &error);
+        Error::handle(&error);
+        return vid;
+    }
+
+    /**
+     * @brief Get system assigned uid for distinguishing between different devices
+     *
+     * @return const char * return the uid of the device
+     */
+    const char *getUid() const {
+        ob_error   *error = nullptr;
+        const char *uid   = ob_device_info_get_uid(impl_, &error);
+        Error::handle(&error);
+        return uid;
+    }
+
+    /**
+     * @brief Get the serial number of the device
+     *
+     * @return const char * return the serial number of the device
+     */
+    const char *getSerialNumber() const {
+        ob_error   *error = nullptr;
+        const char *sn    = ob_device_info_get_serial_number(impl_, &error);
+        Error::handle(&error);
+        return sn;
+    }
+
+    /**
+     * @brief Get the version number of the firmware
+     *
+     * @return const char* return the version number of the firmware
+     */
+    const char *getFirmwareVersion() const {
+        ob_error   *error   = nullptr;
+        const char *version = ob_device_info_get_firmware_version(impl_, &error);
+        Error::handle(&error);
+        return version;
+    }
+
+    /**
+     * @brief Get the connection type of the device
+     *
+     * @return const char* the connection type of the device，currently supports："USB", "USB1.0", "USB1.1", "USB2.0", "USB2.1", "USB3.0", "USB3.1",
+     * "USB3.2", "Ethernet"
+     */
+    const char *getConnectionType() const {
+        ob_error   *error = nullptr;
+        const char *type  = ob_device_info_get_connection_type(impl_, &error);
+        Error::handle(&error);
+        return type;
+    }
+
+    /**
+     * @brief Get the IP address of the device
+     *
+     * @attention Only valid for network devices, otherwise it will return "0.0.0.0".
+     *
+     * @return const char* the IP address of the device, such as "192.168.1.10"
+     */
+    const char *getIpAddress() const {
+        ob_error   *error = nullptr;
+        const char *ip    = ob_device_info_get_ip_address(impl_, &error);
+        Error::handle(&error);
+        return ip;
+    }
+
+    /**
+     * @brief Get the version number of the hardware
+     *
+     * @return const char* the version number of the hardware
+     */
+    const char *getHardwareVersion() const {
+        ob_error   *error   = nullptr;
+        const char *version = ob_device_info_get_hardware_version(impl_, &error);
+        Error::handle(&error);
+        return version;
+    }
+
+    /**
+     * @brief Get the minimum version number of the SDK supported by the device
+     *
+     * @return const char* the minimum SDK version number supported by the device
+     */
+    const char *getSupportedMinSdkVersion() const {
+        ob_error   *error   = nullptr;
+        const char *version = ob_device_info_get_supported_min_sdk_version(impl_, &error);
+        Error::handle(&error);
+        return version;
+    }
+
+    /**
+     * @brief Get chip type name
+     *
+     * @return const char* the chip type name
+     */
+    const char *getAsicName() const {
+        ob_error   *error = nullptr;
+        const char *name  = ob_device_info_get_asicName(impl_, &error);
+        Error::handle(&error);
+        return name;
+    }
+
+    /**
+     * @brief Get the device type
+     *
+     * @return OBDeviceType the device type
+     */
+    OBDeviceType getDeviceType() const {
+        ob_error    *error = nullptr;
+        OBDeviceType type  = ob_device_info_get_device_type(impl_, &error);
+        Error::handle(&error);
+        return type;
+    }
+
+public:
+    // The following interfaces are deprecated and are retained here for compatibility purposes.
+    const char *name() const {
+        return getName();
+    }
+
+    int pid() const {
+        return getPid();
+    }
+
+    int vid() const {
+        return getVid();
+    }
+
+    const char *uid() const {
+        return getUid();
+    }
+
+    const char *serialNumber() const {
+        return getSerialNumber();
+    }
+
+    const char *firmwareVersion() const {
+        return getFirmwareVersion();
+    }
+
+    const char *connectionType() const {
+        return getConnectionType();
+    }
+
+    const char *ipAddress() const {
+        return getIpAddress();
+    }
+
+    const char *hardwareVersion() const {
+        return getHardwareVersion();
+    }
+
+    const char *supportedMinSdkVersion() const {
+        return getSupportedMinSdkVersion();
+    }
+
+    const char *asicName() const {
+        return getAsicName();
+    }
+
+    OBDeviceType deviceType() const {
+        return getDeviceType();
+    }
+};
+
+/**
+ * @brief Class representing a list of devices
+ */
+class DeviceList {
+private:
+    ob_device_list_t *impl_ = nullptr;
+
+public:
+    explicit DeviceList(ob_device_list_t *impl) : impl_(impl) {}
+    ~DeviceList() noexcept {
+        ob_error *error = nullptr;
+        ob_delete_device_list(impl_, &error);
+        Error::handle(&error, false);
+    }
+
+    /**
+     * @brief Get the number of devices in the list
+     *
+     * @return uint32_t the number of devices in the list
+     */
+    uint32_t getCount() const {
+        ob_error *error = nullptr;
+        auto      count = ob_device_list_get_count(impl_, &error);
+        Error::handle(&error);
+        return count;
+    }
+
+    /**
+     * @brief Get the PID of the device at the specified index
+     *
+     * @param index the index of the device
+     * @return int the PID of the device
+     */
+    int getPid(uint32_t index) const {
+        ob_error *error = nullptr;
+        auto      pid   = ob_device_list_get_device_pid(impl_, index, &error);
+        Error::handle(&error);
+        return pid;
+    }
+
+    /**
+     * @brief Get the VID of the device at the specified index
+     *
+     * @param index the index of the device
+     * @return int the VID of the device
+     */
+    int getVid(uint32_t index) const {
+        ob_error *error = nullptr;
+        auto      vid   = ob_device_list_get_device_vid(impl_, index, &error);
+        Error::handle(&error);
+        return vid;
+    }
+
+    /**
+     * @brief Get the UID of the device at the specified index
+     *
+     * @param index the index of the device
+     * @return const char* the UID of the device
+     */
+    const char *getUid(uint32_t index) const {
+        ob_error *error = nullptr;
+        auto      uid   = ob_device_list_get_device_uid(impl_, index, &error);
+        Error::handle(&error);
+        return uid;
+    }
+
+    /**
+     * @brief Get the serial number of the device at the specified index
+     *
+     * @param index the index of the device
+     * @return const char* the serial number of the device
+     */
+    const char *getSerialNumber(uint32_t index) const {
+        ob_error *error = nullptr;
+        auto      sn    = ob_device_list_get_device_serial_number(impl_, index, &error);
+        Error::handle(&error);
+        return sn;
+    }
+
+    /**
+     * @brief Get the name of the device at the specified index in the device list.
+     *
+     * This function retrieves the name of the device at the given index in the device list.
+     * If an error occurs during the operation, it will be handled by the Error::handle function.
+     *
+     * @param index The index of the device in the device list.
+     * @return const char* The name of the device at the specified index.
+     */
+    const char *getName(uint32_t index) const {
+        ob_error *error = nullptr;
+        auto      name  = ob_device_list_get_device_name(impl_, index, &error);
+        Error::handle(&error);
+        return name;
+    }
+
+    /**
+     * @brief Get device connection type
+     *
+     * @param index device index
+     * @return const char* returns connection type，currently supports："USB", "USB1.0", "USB1.1", "USB2.0", "USB2.1", "USB3.0", "USB3.1", "USB3.2", "Ethernet"
+     */
+    const char *getConnectionType(uint32_t index) const {
+        ob_error *error = nullptr;
+        auto      type  = ob_device_list_get_device_connection_type(impl_, index, &error);
+        Error::handle(&error);
+        return type;
+    }
+
+    /**
+     * @brief get the ip address of the device at the specified index
+     *
+     * @attention Only valid for network devices, otherwise it will return "0.0.0.0".
+     *
+     * @param index the index of the device
+     * @return const char* the ip address of the device
+     */
+    const char *getIpAddress(uint32_t index) const {
+        ob_error *error = nullptr;
+        auto      ip    = ob_device_list_get_device_ip_address(impl_, index, &error);
+        Error::handle(&error);
+        return ip;
+    }
+
+    /**
+     * @brief Get the device object at the specified index
+     *
+     * @attention If the device has already been acquired and created elsewhere, repeated acquisition will throw an exception
+     *
+     * @param index the index of the device to create
+     * @return std::shared_ptr<Device> the device object
+     */
+    std::shared_ptr<Device> getDevice(uint32_t index) const {
+        ob_error *error  = nullptr;
+        auto      device = ob_device_list_get_device(impl_, index, &error);
+        Error::handle(&error);
+        return std::make_shared<Device>(device);
+    }
+
+    /**
+     * @brief Get the device object with the specified serial number
+     *
+     * @attention If the device has already been acquired and created elsewhere, repeated acquisition will throw an exception
+     *
+     * @param serialNumber the serial number of the device to create
+     * @return std::shared_ptr<Device> the device object
+     */
+    std::shared_ptr<Device> getDeviceBySN(const char *serialNumber) const {
+        ob_error *error  = nullptr;
+        auto      device = ob_device_list_get_device_by_serial_number(impl_, serialNumber, &error);
+        Error::handle(&error);
+        return std::make_shared<Device>(device);
+    }
+
+    /**
+     * @brief Get the specified device object from the device list by uid
+     * @brief On Linux platform, for usb device, the uid of the device is composed of bus-port-dev, for example 1-1.2-1. But the SDK will remove the dev number
+     * and only keep the bus-port as the uid to create the device, for example 1-1.2, so that we can create a device connected to the specified USB port.
+     * Similarly, users can also directly pass in bus-port as uid to create device.
+     * @brief For GMSL device，the uid is GMSL port with “gmsl2-” prefix, for example gmsl2-1.
+     *
+     * @attention If the device has been acquired and created elsewhere, repeated acquisition will throw an exception
+     *
+     * @param uid The uid of the device to be created
+     * @return std::shared_ptr<Device> returns the device object
+     */
+    std::shared_ptr<Device> getDeviceByUid(const char *uid) const {
+        ob_error *error  = nullptr;
+        auto      device = ob_device_list_get_device_by_uid(impl_, uid, &error);
+        Error::handle(&error);
+        return std::make_shared<Device>(device);
+    }
+
+public:
+    // The following interfaces are deprecated and are retained here for compatibility purposes.
+    uint32_t deviceCount() const {
+        return getCount();
+    }
+
+    int pid(uint32_t index) const {
+        return getPid(index);
+    }
+
+    int vid(uint32_t index) const {
+        return getVid(index);
+    }
+
+    const char *uid(uint32_t index) const {
+        return getUid(index);
+    }
+
+    const char *serialNumber(uint32_t index) const {
+        return getSerialNumber(index);
+    }
+
+    const char *name(uint32_t index) const {
+        return getName(index);
+    }
+
+    const char *connectionType(uint32_t index) const {
+        return getConnectionType(index);
+    }
+
+    const char *ipAddress(uint32_t index) const {
+        return getIpAddress(index);
+    }
+};
+
+class OBDepthWorkModeList {
+private:
+    ob_depth_work_mode_list_t *impl_ = nullptr;
+
+public:
+    explicit OBDepthWorkModeList(ob_depth_work_mode_list_t *impl) : impl_(impl) {}
+    ~OBDepthWorkModeList() {
+        ob_error *error = nullptr;
+        ob_delete_depth_work_mode_list(impl_, &error);
+        Error::handle(&error, false);
+    }
+
+    /**
+     * @brief Get the number of OBDepthWorkMode objects in the list
+     *
+     * @return uint32_t the number of OBDepthWorkMode objects in the list
+     */
+    uint32_t getCount() {
+        ob_error *error = nullptr;
+        auto      count = ob_depth_work_mode_list_get_count(impl_, &error);
+        Error::handle(&error);
+        return count;
+    }
+
+    /**
+     * @brief Get the OBDepthWorkMode object at the specified index
+     *
+     * @param index the index of the target OBDepthWorkMode object
+     * @return OBDepthWorkMode the OBDepthWorkMode object at the specified index
+     */
+    OBDepthWorkMode getOBDepthWorkMode(uint32_t index) {
+        ob_error *error = nullptr;
+        auto      mode  = ob_depth_work_mode_list_get_item(impl_, index, &error);
+        Error::handle(&error);
+        return mode;
+    }
+
+    /**
+     * @brief Get the OBDepthWorkMode object at the specified index
+     *
+     * @param index the index of the target OBDepthWorkMode object
+     * @return OBDepthWorkMode the OBDepthWorkMode object at the specified index
+     */
+    OBDepthWorkMode operator[](uint32_t index) {
+        return getOBDepthWorkMode(index);
+    }
+
+public:
+    // The following interfaces are deprecated and are retained here for compatibility purposes.
+    uint32_t count() {
+        return getCount();
+    }
+};
+
+/**
+ * @brief Class representing a list of device presets
+ * @brief A device preset is a set of parameters or configurations that can be applied to the device to achieve a specific effect or function.
+ */
+class DevicePresetList {
+private:
+    ob_device_preset_list_t *impl_ = nullptr;
+
+public:
+    explicit DevicePresetList(ob_device_preset_list_t *impl) : impl_(impl) {}
+    ~DevicePresetList() noexcept {
+        ob_error *error = nullptr;
+        ob_delete_preset_list(impl_, &error);
+        Error::handle(&error, false);
+    }
+
+    /**
+     * @brief Get the number of device presets in the list
+     *
+     * @return uint32_t the number of device presets in the list
+     */
+    uint32_t getCount() {
+        ob_error *error = nullptr;
+        auto      count = ob_device_preset_list_get_count(impl_, &error);
+        Error::handle(&error);
+        return count;
+    }
+
+    /**
+     * @brief Get the name of the device preset at the specified index
+     *
+     * @param index the index of the device preset
+     * @return const char* the name of the device preset
+     */
+    const char *getName(uint32_t index) {
+        ob_error   *error = nullptr;
+        const char *name  = ob_device_preset_list_get_name(impl_, index, &error);
+        Error::handle(&error);
+        return name;
+    }
+
+    /**
+     * @brief check if the preset list contains the special name preset.
+     * @param name The name of the preset
+     * @return bool Returns true if the special name is found in the preset list, otherwise returns false.
+     */
+    bool hasPreset(const char *name) {
+        ob_error *error  = nullptr;
+        auto      result = ob_device_preset_list_has_preset(impl_, name, &error);
+        Error::handle(&error);
+        return result;
+    }
+
+public:
+    // The following interfaces are deprecated and are retained here for compatibility purposes.
+    uint32_t count() {
+        return getCount();
+    }
+};
+
+/**
+ * @brief Class representing a list of camera parameters
+ */
+class CameraParamList {
+private:
+    ob_camera_param_list_t *impl_ = nullptr;
+
+public:
+    explicit CameraParamList(ob_camera_param_list_t *impl) : impl_(impl) {}
+    ~CameraParamList() noexcept {
+        ob_error *error = nullptr;
+        ob_delete_camera_param_list(impl_, &error);
+        Error::handle(&error, false);
+    }
+
+    /**
+     * @brief Get the number of device presets in the list
+     *
+     * @return uint32_t the number of device presets in the list
+     */
+    uint32_t getCount() {
+        ob_error *error = nullptr;
+        auto      count = ob_camera_param_list_get_count(impl_, &error);
+        Error::handle(&error);
+        return count;
+    }
+
+    /**
+     * @brief Get the camera parameters for the specified index
+     *
+     * @param index the index of the parameter group
+     * @return OBCameraParam the corresponding group parameters
+     */
+    OBCameraParam getCameraParam(uint32_t index) {
+        ob_error *error = nullptr;
+        auto      param = ob_camera_param_list_get_param(impl_, index, &error);
+        Error::handle(&error);
+        return param;
+    }
+
+public:
+    // The following interfaces are deprecated and are retained here for compatibility purposes.
+    uint32_t count() {
+        return getCount();
+    }
+};
+
+}  // namespace ob
+
diff --git a/include/libobsensor/hpp/Error.hpp b/include/libobsensor/hpp/Error.hpp
new file mode 100644
index 00000000..c284360b
--- /dev/null
+++ b/include/libobsensor/hpp/Error.hpp
@@ -0,0 +1,114 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+/**
+ * @file  Error.hpp
+ * @brief This file defines the Error class, which describes abnormal errors within the SDK.
+ *        Detailed information about the exception can be obtained through this class.
+ */
+#pragma once
+
+#include "Types.hpp"
+#include "libobsensor/h/Error.h"
+#include <memory>
+
+namespace ob {
+class Error : public std::exception {
+private:
+    ob_error *impl_;
+
+    /**
+     * @brief Construct a new Error object
+     *
+     * @attention This constructor should not be called directly, use the handle() function instead.
+     *
+     * @param error
+     */
+    explicit Error(ob_error *error) : impl_(error) {};
+
+public:
+    /**
+     * @brief A static function to handle the ob_error and throw an exception if needed.
+     *
+     * @param error The ob_error pointer to be handled.
+     * @param throw_exception A boolean value to indicate whether to throw an exception or not, the default value is true.
+     */
+    static void handle(ob_error **error, bool throw_exception = true) {
+        if(!error || !*error) {  // no error
+            return;
+        }
+
+        if(throw_exception) {
+            throw Error(*error);
+        }
+        else {
+            ob_delete_error(*error);
+            *error = nullptr;
+        }
+    }
+
+    /**
+     * @brief Destroy the Error object
+     */
+    ~Error() override {
+        if(impl_) {
+            ob_delete_error(impl_);
+            impl_ = nullptr;
+        }
+    }
+
+    /**
+     * @brief Returns the error message of the exception.
+     *
+     * @return const char* The error message.
+     */
+    const char *what() const noexcept override {
+        return impl_->message;
+    }
+
+    /**
+     * @brief Returns the exception type of the exception.
+     * @brief Read the comments of the OBExceptionType enum in the libobsensor/h/ObTypes.h file for more information.
+     *
+     * @return OBExceptionType The exception type.
+     */
+    OBExceptionType getExceptionType() const noexcept {
+        return impl_->exception_type;
+    }
+
+    /**
+     * @brief Returns the name of the function where the exception occurred.
+     *
+     * @return const char* The function name.
+     */
+    const char *getFunction() const noexcept {
+        return impl_->function;
+    }
+
+    /**
+     * @brief Returns the arguments of the function where the exception occurred.
+     *
+     * @return const char*  The arguments.
+     */
+    const char *getArgs() const noexcept {
+        return impl_->args;
+    }
+
+    /**
+     * @brief Returns the error message of the exception.
+     * @brief It is recommended to use the what() function instead.
+     *
+     * @return const char* The error message.
+     */
+    const char *getMessage() const noexcept {
+        return impl_->message;
+    }
+
+public:
+    // The following interfaces are deprecated and are retained here for compatibility purposes.
+    const char *getName() const noexcept {
+        return impl_->function;
+    }
+};
+}  // namespace ob
+
diff --git a/include/libobsensor/hpp/Filter.hpp b/include/libobsensor/hpp/Filter.hpp
new file mode 100644
index 00000000..6444ae8e
--- /dev/null
+++ b/include/libobsensor/hpp/Filter.hpp
@@ -0,0 +1,1013 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+/**
+ * @file  Filter.hpp
+ * @brief This file contains the Filter class, which is the processing unit of the SDK that can perform point cloud generation, format conversion, and other
+ * functions.
+ */
+#pragma once
+
+#include "Types.hpp"
+#include "Error.hpp"
+#include "Frame.hpp"
+#include "libobsensor/h/Filter.h"
+#include "libobsensor/h/Frame.h"
+#include <functional>
+#include <memory>
+#include <map>
+#include <string>
+#include <iostream>
+#include <vector>
+#include <typeinfo>
+#include <typeindex>
+#include <unordered_map>
+#include <cstring>
+
+namespace ob {
+
+/**
+ * @brief A callback function that takes a shared pointer to a Frame object as its argument.
+ */
+typedef std::function<void(std::shared_ptr<Frame>)> FilterCallback;
+
+/**
+ * @brief Get the type of a PropertyRange member
+ */
+template <typename T> struct RangeTraits {
+    using valueType = void;
+};
+
+template <> struct RangeTraits<OBUint8PropertyRange> {
+    using valueType = uint8_t;
+};
+
+template <> struct RangeTraits<OBUint16PropertyRange> {
+    using valueType = uint16_t;
+};
+
+template <> struct RangeTraits<OBIntPropertyRange> {
+    using valueType = uint32_t;
+};
+
+template <> struct RangeTraits<OBFloatPropertyRange> {
+    using valueType = float;
+};
+
+/**
+ * @brief Get T Property Range
+ */
+template <typename T> T getPropertyRange(const OBFilterConfigSchemaItem &item, const double cur) {
+    // If T type is illegal, T will be void
+    using valueType = typename RangeTraits<T>::valueType;
+    T range{};
+    // Compilate error will be reported here if T is void
+    range.cur  = static_cast<valueType>(cur);
+    range.def  = static_cast<valueType>(item.def);
+    range.max  = static_cast<valueType>(item.max);
+    range.min  = static_cast<valueType>(item.min);
+    range.step = static_cast<valueType>(item.step);
+    return range;
+}
+
+/**
+ * @brief The Filter class is the base class for all filters in the SDK.
+ */
+class Filter : public std::enable_shared_from_this<Filter> {
+protected:
+    ob_filter                            *impl_ = nullptr;
+    std::string                           name_;
+    FilterCallback                        callback_;
+    std::vector<OBFilterConfigSchemaItem> configSchemaVec_;
+
+protected:
+    /**
+     * @brief Default constructor with nullptr impl, used for derived classes only.
+     */
+    Filter() = default;
+
+    virtual void init(ob_filter *impl) {
+        impl_           = impl;
+        ob_error *error = nullptr;
+        name_           = ob_filter_get_name(impl_, &error);
+        Error::handle(&error);
+
+        auto configSchemaList = ob_filter_get_config_schema_list(impl_, &error);
+        Error::handle(&error);
+
+        auto count = ob_filter_config_schema_list_get_count(configSchemaList, &error);
+        Error::handle(&error);
+
+        for(uint32_t i = 0; i < count; i++) {
+            auto item = ob_filter_config_schema_list_get_item(configSchemaList, i, &error);
+            Error::handle(&error);
+            configSchemaVec_.emplace_back(item);
+        }
+
+        ob_delete_filter_config_schema_list(configSchemaList, &error);
+        Error::handle(&error);
+    }
+
+public:
+    explicit Filter(ob_filter *impl) {
+        init(impl);
+    }
+
+    virtual ~Filter() noexcept {
+        if(impl_ != nullptr) {
+            ob_error *error = nullptr;
+            ob_delete_filter(impl_, &error);
+            Error::handle(&error, false);
+        }
+    }
+
+    /**
+     * @brief Get the Impl object of the filter.
+     *
+     * @return ob_filter* The Impl object of the filter.
+     */
+    ob_filter *getImpl() const {
+        return impl_;
+    }
+
+    /**
+     * @brief Get the type of filter.
+     *
+     * @return string The type of filte.
+     */
+    virtual const std::string &getName() const {
+        return name_;
+    }
+
+    /**
+     * @brief Reset the filter, freeing the internal cache, stopping the processing thread, and clearing the pending buffer frame when asynchronous processing
+     * is used.
+     */
+    virtual void reset() const {
+        ob_error *error = nullptr;
+        ob_filter_reset(impl_, &error);
+        Error::handle(&error);
+    }
+
+    /**
+     * @brief enable the filter
+     */
+    virtual void enable(bool enable) const {
+        ob_error *error = nullptr;
+        ob_filter_enable(impl_, enable, &error);
+        Error::handle(&error);
+    }
+
+    /**
+     * @brief Return Enable State
+     */
+    virtual bool isEnabled() const {
+        ob_error *error  = nullptr;
+        bool      enable = ob_filter_is_enabled(impl_, &error);
+        Error::handle(&error);
+        return enable;
+    }
+
+    /**
+     * @brief Processes a frame synchronously.
+     *
+     * @param frame The frame to be processed.
+     * @return std::shared_ptr< Frame > The processed frame.
+     */
+    virtual std::shared_ptr<Frame> process(std::shared_ptr<const Frame> frame) const {
+        ob_error *error  = nullptr;
+        auto      result = ob_filter_process(impl_, frame->getImpl(), &error);
+        Error::handle(&error);
+        if(!result) {
+            return nullptr;
+        }
+        return std::make_shared<Frame>(result);
+    }
+
+    /**
+     * @brief Pushes the pending frame into the cache for asynchronous processing.
+     *
+     * @param frame The pending frame. The processing result is returned by the callback function.
+     */
+    virtual void pushFrame(std::shared_ptr<Frame> frame) const {
+        ob_error *error = nullptr;
+        ob_filter_push_frame(impl_, frame->getImpl(), &error);
+        Error::handle(&error);
+    }
+
+    /**
+     * @brief Set the callback function for asynchronous processing.
+     *
+     * @param callback The processing result callback.
+     */
+    virtual void setCallBack(FilterCallback callback) {
+        callback_       = callback;
+        ob_error *error = nullptr;
+        ob_filter_set_callback(impl_, &Filter::filterCallback, this, &error);
+        Error::handle(&error);
+    }
+
+    /**
+     * @brief Get config schema of the filter
+     * @brief The returned string is a csv format string representing the configuration schema of the filter. The format of the string is:
+     *  <parameter_name>, <parameter_type: "int", "float", "bool">, <minimum_value>, <maximum_value>, <value_step>, <default_value>, <parameter_description>
+     *
+     * @return std::string The config schema of the filter.
+     */
+    virtual std::string getConfigSchema() const {
+        ob_error *error  = nullptr;
+        auto      schema = ob_filter_get_config_schema(impl_, &error);
+        Error::handle(&error);
+        return schema;
+    }
+
+    /**
+     * @brief Get the Config Schema Vec object
+     * @brief The returned vector contains the config schema items. Each item in the vector is an @ref OBFilterConfigSchemaItem object.
+     *
+     * @return std::vector<OBFilterConfigSchemaItem> The vector of the filter config schema.
+     */
+    virtual std::vector<OBFilterConfigSchemaItem> getConfigSchemaVec() const {
+        return configSchemaVec_;
+    }
+
+    /**
+     * @brief Set the filter config value by name.
+     *
+     * @attention The pass into value type is double, witch will be cast to the actual type inside the filter. The actual type can be queried by the filter
+     * config schema returned by @ref getConfigSchemaVec.
+     *
+     * @param configName The name of the config.
+     * @param value The value of the config.
+     */
+    virtual void setConfigValue(const std::string &configName, double value) const {
+        ob_error *error = nullptr;
+        ob_filter_set_config_value(impl_, configName.c_str(), value, &error);
+        Error::handle(&error);
+    }
+
+    /**
+     * @brief Get the Config Value object by name.
+     *
+     * @attention The returned value type has been casted to double inside the filter. The actual type can be queried by the filter config schema returned by
+     * @ref getConfigSchemaVec.
+     *
+     * @param configName  The name of the config.
+     * @return double The value of the config.
+     */
+    virtual double getConfigValue(const std::string &configName) const {
+        ob_error *error = nullptr;
+        double    value = ob_filter_get_config_value(impl_, configName.c_str(), &error);
+        Error::handle(&error);
+        return value;
+    }
+
+private:
+    static void filterCallback(ob_frame *frame, void *userData) {
+        auto filter = static_cast<Filter *>(userData);
+        filter->callback_(std::make_shared<Frame>(frame));
+    }
+
+public:
+    // The following interfaces are deprecated and are retained here for compatibility purposes.
+    virtual const char *type() {
+        return getName().c_str();
+    }
+
+    /**
+     * @brief Check if the runtime type of the filter object is compatible with a given type.
+     *
+     * @tparam T The given type.
+     * @return bool The result.
+     */
+    template <typename T> bool is();
+
+    template <typename T> std::shared_ptr<T> as() {
+        if(!is<T>()) {
+            throw std::runtime_error("unsupported operation, object's type is not require type");
+        }
+
+        return std::static_pointer_cast<T>(shared_from_this());
+    }
+};
+
+/**
+ *  @brief A factory class for creating filters.
+ */
+class FilterFactory {
+public:
+    /**
+     * @brief Create a filter by name.
+     */
+    static std::shared_ptr<Filter> createFilter(const std::string &name) {
+        ob_error *error = nullptr;
+        auto      impl  = ob_create_filter(name.c_str(), &error);
+        Error::handle(&error);
+        return std::make_shared<Filter>(impl);
+    }
+
+    /**
+     * @brief Create a private filter by name and activation key.
+     * @brief Some private filters require an activation key to be activated, its depends on the vendor of the filter.
+     *
+     * @param name The name of the filter.
+     * @param activation_key The activation key of the filter.
+     */
+    static std::shared_ptr<Filter> createPrivateFilter(const std::string &name, const std::string &activationKey) {
+        ob_error *error = nullptr;
+        auto      impl  = ob_create_private_filter(name.c_str(), activationKey.c_str(), &error);
+        Error::handle(&error);
+        return std::make_shared<Filter>(impl);
+    }
+
+    /**
+     * @brief Get the vendor specific code of a filter by filter name.
+     * @brief A private filter can define its own vendor specific code for specific purposes.
+     *
+     * @param name The name of the filter.
+     * @return std::string The vendor specific code of the filter.
+     */
+    static std::string getFilterVendorSpecificCode(const std::string &name) {
+        ob_error *error = nullptr;
+        auto      code  = ob_filter_get_vendor_specific_code(name.c_str(), &error);
+        Error::handle(&error);
+        return code;
+    }
+};
+
+/**
+ * @brief The PointCloudFilter class is a subclass of Filter that generates point clouds.
+ */
+class PointCloudFilter : public Filter {
+public:
+    PointCloudFilter() {
+        ob_error *error = nullptr;
+        auto      impl  = ob_create_filter("PointCloudFilter", &error);
+        Error::handle(&error);
+        init(impl);
+    }
+
+    virtual ~PointCloudFilter() noexcept = default;
+
+    /**
+     * @brief Set the output pointcloud frame format.
+     *
+     * @param type The point cloud frame format: OB_FORMAT_POINT or OB_FORMAT_RGB_POINT
+     */
+    void setCreatePointFormat(OBFormat format) {
+        setConfigValue("pointFormat", static_cast<double>(format));
+    }
+
+    /**
+     * @brief Set the point cloud coordinate data zoom factor.
+     *
+     * @brief Calling this function to set the scale will change the point coordinate scaling factor of the output point cloud frame, The point coordinate
+     * scaling factor for the output point cloud frame can be obtained via @ref PointsFrame::getCoordinateValueScale function.
+     *
+     * @param factor The scale factor.
+     */
+    void setCoordinateDataScaled(float factor) {
+        setConfigValue("coordinateDataScale", factor);
+    }
+
+    /**
+     * @brief Set point cloud color data normalization.
+     * @brief If normalization is required, the output point cloud frame's color data will be normalized to the range [0, 1].
+     *
+     * @attention This function only works for when create point format is set to OB_FORMAT_RGB_POINT.
+     *
+     * @param state Whether normalization is required.
+     */
+    void setColorDataNormalization(bool state) {
+        setConfigValue("colorDataNormalization", state);
+    }
+
+    /**
+     * @brief Set the point cloud coordinate system.
+     *
+     * @param type The coordinate system type.
+     */
+    void setCoordinateSystem(OBCoordinateSystemType type) {
+        setConfigValue("coordinateSystemType", static_cast<double>(type));
+    }
+
+public:
+    // The following interfaces are deprecated and are retained here for compatibility purposes.
+    void setPositionDataScaled(float scale) {
+        setCoordinateDataScaled(scale);
+    }
+
+    // The following interfaces are deprecated and are retained here for compatibility purposes.
+    void setFrameAlignState(bool state) {
+        (void)state;  // to complie
+    }
+    // The following interfaces are deprecated and are retained here for compatibility purposes.
+    void setCameraParam(OBCameraParam param) {
+        (void)param;
+    }
+};
+
+/**
+ * @brief Align for depth to other or other to depth.
+ */
+class Align : public Filter {
+public:
+    Align(OBStreamType alignToStreamType) {
+        ob_error *error = nullptr;
+        auto      impl  = ob_create_filter("Align", &error);
+        Error::handle(&error);
+        init(impl);
+
+        setConfigValue("AlignType", static_cast<double>(alignToStreamType));
+    }
+
+    virtual ~Align() noexcept = default;
+
+    OBStreamType getAlignToStreamType() {
+        return static_cast<OBStreamType>(static_cast<int>(getConfigValue("AlignType")));
+    }
+};
+
+/**
+ * @brief The FormatConvertFilter class is a subclass of Filter that performs format conversion.
+ */
+class FormatConvertFilter : public Filter {
+public:
+    FormatConvertFilter() {
+        ob_error *error = nullptr;
+        auto      impl  = ob_create_filter("FormatConverter", &error);
+        Error::handle(&error);
+        init(impl);
+    }
+
+    virtual ~FormatConvertFilter() noexcept = default;
+
+    /**
+     * @brief Set the format conversion type.
+     *
+     * @param type The format conversion type.
+     */
+    void setFormatConvertType(OBConvertFormat type) {
+        setConfigValue("convertType", static_cast<double>(type));
+    }
+};
+
+/**
+ * @brief HdrMerge processing block,
+ * the processing merges between depth frames with
+ * different sub-preset sequence ids.
+ */
+class HdrMerge : public Filter {
+public:
+    HdrMerge() {
+        ob_error *error = nullptr;
+        auto      impl  = ob_create_filter("HDRMerge", &error);
+        Error::handle(&error);
+        init(impl);
+    }
+
+    virtual ~HdrMerge() noexcept = default;
+};
+
+/**
+ * @brief Create SequenceIdFilter processing block.
+ */
+class SequenceIdFilter : public Filter {
+private:
+    std::map<float, std::string> sequenceIdList_{ { 0.f, "all" }, { 1.f, "1" } };
+    OBSequenceIdItem            *outputSequenceIdList_ = nullptr;
+
+    void initSeqenceIdList() {
+        outputSequenceIdList_ = new OBSequenceIdItem[sequenceIdList_.size()];
+
+        int i = 0;
+        for(const auto &pair: sequenceIdList_) {
+            outputSequenceIdList_[i].sequenceSelectId = static_cast<int>(pair.first);
+            strncpy(outputSequenceIdList_[i].name, pair.second.c_str(), sizeof(outputSequenceIdList_[i].name) - 1);
+            outputSequenceIdList_[i].name[sizeof(outputSequenceIdList_[i].name) - 1] = '\0';
+            ++i;
+        }
+    }
+
+public:
+    SequenceIdFilter() {
+        ob_error *error = nullptr;
+        auto      impl  = ob_create_filter("SequenceIdFilter", &error);
+        Error::handle(&error);
+        init(impl);
+        initSeqenceIdList();
+    }
+
+    virtual ~SequenceIdFilter() noexcept {
+        if(outputSequenceIdList_) {
+            delete[] outputSequenceIdList_;
+            outputSequenceIdList_ = nullptr;
+        }
+    }
+
+    /**
+     * @brief Set the sequenceId filter params.
+     *
+     * @param sequence id to pass the filter.
+     */
+    void selectSequenceId(int sequence_id) {
+        setConfigValue("sequenceid", static_cast<double>(sequence_id));
+    }
+
+    /**
+     * @brief Get the current sequence id.
+     *
+     * @return sequence id to pass the filter.
+     */
+    int getSelectSequenceId() {
+        return static_cast<int>(getConfigValue("sequenceid"));
+    }
+
+    OBSequenceIdItem *getSequenceIdList() {
+        return outputSequenceIdList_;
+    }
+
+    /**
+     * @brief Get the sequenceId list size.
+     *
+     * @return the size of sequenceId list.
+     */
+    int getSequenceIdListSize() {
+        return static_cast<int>(sequenceIdList_.size());
+    }
+};
+
+/**
+ * @brief Decimation filter, reducing complexity by subsampling depth maps and losing depth details.
+ */
+class DecimationFilter : public Filter {
+public:
+    DecimationFilter() {
+        ob_error *error = nullptr;
+        auto      impl  = ob_create_filter("DecimationFilter", &error);
+        Error::handle(&error);
+        init(impl);
+    }
+
+    virtual ~DecimationFilter() noexcept = default;
+
+    /**
+     * @brief Set the decimation filter scale value.
+     *
+     * @param type The decimation filter scale value.
+     */
+    void setScaleValue(uint8_t value) {
+        setConfigValue("decimate", static_cast<double>(value));
+    }
+
+    /**
+     * @brief Get the decimation filter scale value.
+     */
+    uint8_t getScaleValue() {
+        return static_cast<uint8_t>(getConfigValue("decimate"));
+    }
+
+    /**
+     * @brief Get the property range of the decimation filter scale value.
+     */
+    OBUint8PropertyRange getScaleRange() {
+        OBUint8PropertyRange scaleRange{};
+        if(configSchemaVec_.size() != 0) {
+            const auto &item = configSchemaVec_[0];
+            scaleRange       = getPropertyRange<OBUint8PropertyRange>(item, getConfigValue("decimate"));
+        }
+        return scaleRange;
+    }
+};
+
+/**
+ * @brief Creates depth Thresholding filter
+ * By controlling min and max options on the block
+ */
+class ThresholdFilter : public Filter {
+public:
+    ThresholdFilter() {
+        ob_error *error = nullptr;
+        auto      impl  = ob_create_filter("ThresholdFilter", &error);
+        Error::handle(&error);
+        init(impl);
+    }
+
+    virtual ~ThresholdFilter() noexcept = default;
+
+    /**
+     * @brief Get the threshold filter min range.
+     *
+     * @return OBIntPropertyRange The range of the threshold filter min.
+     */
+    OBIntPropertyRange getMinRange() {
+        OBIntPropertyRange range{};
+        const auto        &schemaVec = getConfigSchemaVec();
+        for(const auto &item: schemaVec) {
+            if(strcmp(item.name, "min") == 0) {
+                range = getPropertyRange<OBIntPropertyRange>(item, getConfigValue("min"));
+                break;
+            }
+        }
+        return range;
+    }
+
+    /**
+     * @brief Get the threshold filter max range.
+     *
+     * @return OBIntPropertyRange The range of the threshold filter max.
+     */
+    OBIntPropertyRange getMaxRange() {
+        OBIntPropertyRange range{};
+        const auto        &schemaVec = getConfigSchemaVec();
+        for(const auto &item: schemaVec) {
+            if(strcmp(item.name, "max") == 0) {
+                range = getPropertyRange<OBIntPropertyRange>(item, getConfigValue("max"));
+                break;
+            }
+        }
+        return range;
+    }
+
+    /**
+     * @brief Set the threshold filter max and min range.
+     */
+    bool setValueRange(uint16_t min, uint16_t max) {
+        if(min >= max) {
+            return false;
+        }
+        setConfigValue("min", min);
+        setConfigValue("max", max);
+        return true;
+    }
+};
+
+/**
+ * @brief Spatial advanced filte smooths the image by calculating frame with alpha and delta settings
+ * alpha defines the weight of the current pixel for smoothing,
+ * delta defines the depth gradient below which the smoothing will occur as number of depth levels.
+ */
+class SpatialAdvancedFilter : public Filter {
+public:
+    SpatialAdvancedFilter(const std::string &activationKey = "") {
+        ob_error *error = nullptr;
+        auto      impl  = ob_create_private_filter("SpatialAdvancedFilter", activationKey.c_str(), &error);
+        Error::handle(&error);
+        init(impl);
+    }
+
+    virtual ~SpatialAdvancedFilter() noexcept = default;
+
+    /**
+     * @brief Get the spatial advanced filter alpha range.
+     *
+     * @return OBFloatPropertyRange the alpha value of property range.
+     */
+    OBFloatPropertyRange getAlphaRange() {
+        OBFloatPropertyRange range{};
+        const auto          &schemaVec = getConfigSchemaVec();
+        for(const auto &item: schemaVec) {
+            if(strcmp(item.name, "alpha") == 0) {
+                range = getPropertyRange<OBFloatPropertyRange>(item, getConfigValue("alpha"));
+                break;
+            }
+        }
+        return range;
+    }
+
+    /**
+     * @brief Get the spatial advanced filter dispdiff range.
+     *
+     * @return OBFloatPropertyRange the dispdiff value of property range.
+     */
+    OBUint16PropertyRange getDispDiffRange() {
+        OBUint16PropertyRange range{};
+        const auto           &schemaVec = getConfigSchemaVec();
+        for(const auto &item: schemaVec) {
+            if(strcmp(item.name, "disp_diff") == 0) {
+                range = getPropertyRange<OBUint16PropertyRange>(item, getConfigValue("disp_diff"));
+                break;
+            }
+        }
+        return range;
+    }
+
+    /**
+     * @brief Get the spatial advanced filter radius range.
+     *
+     * @return OBFloatPropertyRange the radius value of property range.
+     */
+    OBUint16PropertyRange getRadiusRange() {
+        OBUint16PropertyRange range{};
+        const auto           &schemaVec = getConfigSchemaVec();
+        for(const auto &item: schemaVec) {
+            if(strcmp(item.name, "radius") == 0) {
+                range = getPropertyRange<OBUint16PropertyRange>(item, getConfigValue("radius"));
+                break;
+            }
+        }
+        return range;
+    }
+
+    /**
+     * @brief Get the spatial advanced filter magnitude range.
+     *
+     * @return OBFloatPropertyRange the magnitude value of property range.
+     */
+    OBIntPropertyRange getMagnitudeRange() {
+        OBIntPropertyRange range{};
+        const auto        &schemaVec = getConfigSchemaVec();
+        for(const auto &item: schemaVec) {
+            if(strcmp(item.name, "magnitude") == 0) {
+                range = getPropertyRange<OBIntPropertyRange>(item, getConfigValue("magnitude"));
+                break;
+            }
+        }
+        return range;
+    }
+
+    /**
+     * @brief Get the spatial advanced filter params.
+     *
+     * @return OBSpatialAdvancedFilterParams
+     */
+    OBSpatialAdvancedFilterParams getFilterParams() {
+        OBSpatialAdvancedFilterParams params{};
+        params.alpha     = static_cast<float>(getConfigValue("alpha"));
+        params.disp_diff = static_cast<uint16_t>(getConfigValue("disp_diff"));
+        params.magnitude = static_cast<uint8_t>(getConfigValue("magnitude"));
+        params.radius    = static_cast<uint16_t>(getConfigValue("radius"));
+        return params;
+    }
+
+    /**
+     * @brief Set the spatial advanced filter params.
+     *
+     * @param params OBSpatialAdvancedFilterParams.
+     */
+    void setFilterParams(OBSpatialAdvancedFilterParams params) {
+        setConfigValue("alpha", params.alpha);
+        setConfigValue("disp_diff", params.disp_diff);
+        setConfigValue("magnitude", params.magnitude);
+        setConfigValue("radius", params.radius);
+    }
+};
+
+/**
+ * @brief Hole filling filter,the processing performed depends on the selected hole filling mode.
+ */
+class HoleFillingFilter : public Filter {
+public:
+    HoleFillingFilter(const std::string &activationKey = "") {
+        ob_error *error = nullptr;
+        auto      impl  = ob_create_private_filter("HoleFillingFilter", activationKey.c_str(), &error);
+        Error::handle(&error);
+        init(impl);
+    }
+
+    ~HoleFillingFilter() noexcept = default;
+
+    /**
+     * @brief Set the HoleFillingFilter mode.
+     *
+     * @param[in] filter A holefilling_filter object.
+     * @param mode OBHoleFillingMode, OB_HOLE_FILL_TOP,OB_HOLE_FILL_NEAREST or OB_HOLE_FILL_FAREST.
+     */
+    void setFilterMode(OBHoleFillingMode mode) {
+        setConfigValue("hole_filling_mode", static_cast<double>(mode));
+    }
+
+    /**
+     * @brief Get the HoleFillingFilter mode.
+     *
+     * @return OBHoleFillingMode
+     */
+    OBHoleFillingMode getFilterMode() {
+        return static_cast<OBHoleFillingMode>(static_cast<int>(getConfigValue("hole_filling_mode")));
+    }
+};
+
+/**
+ * @brief The noise removal filter,removing scattering depth pixels.
+ */
+class NoiseRemovalFilter : public Filter {
+public:
+    NoiseRemovalFilter(const std::string &activationKey = "") {
+        ob_error *error = nullptr;
+        auto      impl  = ob_create_private_filter("NoiseRemovalFilter", activationKey.c_str(), &error);
+        Error::handle(&error);
+        init(impl);
+    }
+
+    ~NoiseRemovalFilter() noexcept = default;
+
+    /**
+     * @brief Set the noise removal filter params.
+     *
+     * @param[in] params ob_noise_removal_filter_params.
+     */
+    void setFilterParams(OBNoiseRemovalFilterParams filterParams) {
+        setConfigValue("max_size", static_cast<double>(filterParams.max_size));
+        setConfigValue("min_diff", static_cast<double>(filterParams.disp_diff));
+        // todo:set noise remove type
+    }
+
+    /**
+     * @brief Get the noise removal filter params.
+     *
+     * @return OBNoiseRemovalFilterParams.
+     */
+    OBNoiseRemovalFilterParams getFilterParams() {
+        OBNoiseRemovalFilterParams param{};
+        param.max_size  = static_cast<uint16_t>(getConfigValue("max_size"));
+        param.disp_diff = static_cast<uint16_t>(getConfigValue("min_diff"));
+        // todo: type is not set
+        return param;
+    }
+
+    /**
+     * @brief Get the noise removal filter disp diff range.
+     * @return OBUint16PropertyRange The disp diff of property range.
+     */
+    OBUint16PropertyRange getDispDiffRange() {
+        OBUint16PropertyRange range{};
+        const auto           &schemaVec = getConfigSchemaVec();
+        for(const auto &item: schemaVec) {
+            if(strcmp(item.name, "min_diff") == 0) {
+                range = getPropertyRange<OBUint16PropertyRange>(item, getConfigValue("min_diff"));
+                break;
+            }
+        }
+        return range;
+    }
+
+    /**
+     * @brief Get the noise removal filter max size range.
+     * @return OBUint16PropertyRange The max size of property range.
+     */
+    OBUint16PropertyRange getMaxSizeRange() {
+        OBUint16PropertyRange range{};
+        const auto           &schemaVec = getConfigSchemaVec();
+        for(const auto &item: schemaVec) {
+            if(strcmp(item.name, "max_size") == 0) {
+                range = getPropertyRange<OBUint16PropertyRange>(item, getConfigValue("max_size"));
+                break;
+            }
+        }
+        return range;
+    }
+};
+
+/**
+ * @brief Temporal filter
+ */
+class TemporalFilter : public Filter {
+public:
+    TemporalFilter(const std::string &activationKey = "") {
+        ob_error *error = nullptr;
+        auto      impl  = ob_create_private_filter("TemporalFilter", activationKey.c_str(), &error);
+        Error::handle(&error);
+        init(impl);
+    }
+
+    ~TemporalFilter() noexcept = default;
+
+    /**
+     * @brief Get the TemporalFilter diffscale range.
+     *
+     * @return OBFloatPropertyRange the diffscale value of property range.
+     */
+    OBFloatPropertyRange getDiffScaleRange() {
+        OBFloatPropertyRange range{};
+        const auto          &schemaVec = getConfigSchemaVec();
+        for(const auto &item: schemaVec) {
+            if(strcmp(item.name, "diff_scale") == 0) {
+                range = getPropertyRange<OBFloatPropertyRange>(item, getConfigValue("diff_scale"));
+                break;
+            }
+        }
+        return range;
+    }
+
+    /**
+     * @brief Set the TemporalFilter diffscale value.
+     *
+     * @param value diffscale value.
+     */
+    void setDiffScale(float value) {
+        setConfigValue("diff_scale", static_cast<double>(value));
+    }
+
+    /**
+     * @brief Get the TemporalFilter weight range.
+     *
+     * @return OBFloatPropertyRange the weight value of property range.
+     */
+    OBFloatPropertyRange getWeightRange() {
+        OBFloatPropertyRange range{};
+        const auto          &schemaVec = getConfigSchemaVec();
+        for(const auto &item: schemaVec) {
+            if(strcmp(item.name, "weight") == 0) {
+                range = getPropertyRange<OBFloatPropertyRange>(item, getConfigValue("weight"));
+                break;
+            }
+        }
+        return range;
+    }
+
+    /**
+     * @brief Set the TemporalFilter weight value.
+     *
+     * @param value weight value.
+     */
+    void setWeight(float value) {
+        setConfigValue("weight", static_cast<double>(value));
+    }
+};
+
+/**
+ * @brief Depth to disparity or disparity to depth
+ */
+class DisparityTransform : public Filter {
+public:
+    DisparityTransform(const std::string &activationKey = "") {
+        ob_error *error = nullptr;
+        auto      impl  = ob_create_private_filter("DisparityTransform", activationKey.c_str(), &error);
+        Error::handle(&error);
+        init(impl);
+    }
+
+    ~DisparityTransform() noexcept = default;
+};
+
+class OBFilterList {
+private:
+    ob_filter_list_t* impl_;
+
+public:
+    explicit OBFilterList(ob_filter_list_t *impl) : impl_(impl) {}
+
+    ~OBFilterList() noexcept {
+        ob_error *error = nullptr;
+        ob_delete_filter_list(impl_, &error);
+        Error::handle(&error, false);
+    }
+
+    /**
+     * @brief Get the number of filters
+     *
+     * @return uint32_t The number of filters
+     */
+    uint32_t getCount() const {
+        ob_error *error = nullptr;
+        auto      count = ob_filter_list_get_count(impl_, &error);
+        Error::handle(&error);
+        return count;
+    }
+
+    /**
+     * @brief Get the Filter object at the specified index
+     *
+     * @param index The filter index. The range is [0, count-1]. If the index exceeds the range, an exception will be thrown.
+     * @return std::shared_ptr<Filter> The filter object.
+     */
+    std::shared_ptr<Filter> getFilter(uint32_t index) {
+        ob_error *error  = nullptr;
+        auto      filter = ob_filter_list_get_filter(impl_, index, &error);
+        Error::handle(&error);
+        return std::make_shared<Filter>(filter);
+    }
+
+public:
+    // The following interfaces are deprecated and are retained here for compatibility purposes.
+    uint32_t count() const {
+        return getCount();
+    }
+};
+
+/**
+ * @brief Define the Filter type map
+ */
+static const std::unordered_map<std::string, std::type_index> obFilterTypeMap = {
+    { "PointCloudFilter", typeid(PointCloudFilter) },   { "Align", typeid(Align) },
+    { "FormatConverter", typeid(FormatConvertFilter) }, { "HDRMerge", typeid(HdrMerge) },
+    { "SequenceIdFilter", typeid(SequenceIdFilter) },   { "DecimationFilter", typeid(DecimationFilter) },
+    { "ThresholdFilter", typeid(ThresholdFilter) },     { "SpatialAdvancedFilter", typeid(SpatialAdvancedFilter) },
+    { "HoleFillingFilter", typeid(HoleFillingFilter) }, { "NoiseRemovalFilter", typeid(NoiseRemovalFilter) },
+    { "TemporalFilter", typeid(TemporalFilter) },       { "DisparityTransform", typeid(DisparityTransform) }
+};
+
+/**
+ * @brief Define the is() template function for the Filter class
+ */
+template <typename T> bool Filter::is() {
+    std::string name = type();
+    auto        it   = obFilterTypeMap.find(name);
+    if(it != obFilterTypeMap.end()) {
+        return std::type_index(typeid(T)) == it->second;
+    }
+    return false;
+}
+
+}  // namespace ob
+
diff --git a/include/libobsensor/hpp/Frame.hpp b/include/libobsensor/hpp/Frame.hpp
new file mode 100644
index 00000000..63c61e92
--- /dev/null
+++ b/include/libobsensor/hpp/Frame.hpp
@@ -0,0 +1,1025 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+/**
+ * @file Frame.hpp
+ * @brief Frame related type, which is mainly used to obtain frame data and frame information.
+ *
+ */
+#pragma once
+
+#include "Types.hpp"
+#include "libobsensor/h/Frame.h"
+#include "libobsensor/hpp/Error.hpp"
+#include "libobsensor/hpp/StreamProfile.hpp"
+#include <memory>
+#include <iostream>
+#include <typeinfo>
+#include <functional>
+
+/**
+ *  Frame classis inheritance hierarchy：
+ *         Frame
+ *          |
+ *      +-----------+----------+----------+-----------+
+ *      |           |          |          |           |
+ *   VideoFrame PointsFrame AccelFrame GyroFrame   FrameSet
+ *        |
+ *   +----+----------+-------------------+
+ *   |               |                   |
+ * ColorFrame    DepthFrame           IRFrame
+ *                                       |
+ *                                 +-----+-----+
+ *                                 |           |
+ *                            IRLeftFrame  IRRightFrame
+ */
+
+namespace ob {
+class Device;
+class Sensor;
+
+/**
+ * @brief Define the frame class, which is the base class of all frame types.
+ *
+ */
+class Frame : public std::enable_shared_from_this<Frame> {
+protected:
+    /**
+     * @brief The pointer to the internal (c api level) frame object.
+     */
+    const ob_frame *impl_ = nullptr;
+
+public:
+    /**
+     * @brief Construct a new Frame object with a given pointer to the internal frame object.
+     *
+     * @attention After calling this constructor, the frame object will own the internal frame object, and the internal frame object will be deleted when the
+     * frame object is destroyed.
+     * @attention The internal frame object should not be deleted by the caller.
+     *
+     * @param impl The pointer to the internal frame object.
+     */
+    explicit Frame(const ob_frame *impl) : impl_(impl) {}
+
+    /**
+     * @brief Get the internal (impl) frame object
+     *
+     * @return const ob_frame* the pointer to the internal frame object.
+     */
+    const ob_frame *getImpl() const {
+        return impl_;
+    }
+
+    /**
+     * @brief Destroy the Frame object
+     */
+    virtual ~Frame() noexcept {
+        if(impl_) {
+            ob_error *error = nullptr;
+            ob_delete_frame(impl_, &error);
+            Error::handle(&error, false);
+            impl_ = nullptr;
+        }
+    }
+
+    /**
+     * @brief Get the type of frame.
+     *
+     * @return OBFrameType The type of frame.
+     */
+    virtual OBFrameType getType() const {
+        ob_error *error = nullptr;
+        auto      type  = ob_frame_get_type(impl_, &error);
+        Error::handle(&error);
+
+        return type;
+    }
+
+    /**
+     * @brief Get the format of the frame.
+     *
+     * @return OBFormat The format of the frame.
+     */
+    virtual OBFormat getFormat() const {
+        ob_error *error  = nullptr;
+        auto      format = ob_frame_get_format(impl_, &error);
+        Error::handle(&error);
+
+        return format;
+    }
+
+    /**
+     * @brief Get the sequence number of the frame.
+     *
+     * @note The sequence number for each frame is managed by the SDK. It increments by 1 for each frame on each stream.
+     *
+     * @return uint64_t The sequence number of the frame.
+     */
+    virtual uint64_t getIndex() const {
+        ob_error *error = nullptr;
+        auto      index = ob_frame_get_index(impl_, &error);
+        Error::handle(&error);
+
+        return index;
+    }
+
+    /**
+     * @brief Get frame data
+     *
+     * @return const uint8_t * The frame data pointer.
+     */
+    virtual uint8_t *getData() const {
+        ob_error *error = nullptr;
+        auto      data  = ob_frame_get_data(impl_, &error);
+        Error::handle(&error);
+
+        return data;
+    }
+
+    /**
+     * @brief Get the size of the frame data.
+     *
+     * @return uint32_t The size of the frame data.
+     * For point cloud data, this returns the number of bytes occupied by all point sets. To find the number of points, divide the dataSize by the structure
+     * size of the corresponding point type.
+     */
+    virtual uint32_t getDataSize() const {
+        ob_error *error    = nullptr;
+        auto      dataSize = ob_frame_get_data_size(impl_, &error);
+        Error::handle(&error);
+
+        return dataSize;
+    }
+
+    /**
+     * @brief Get the hardware timestamp of the frame in microseconds.
+     * @brief The hardware timestamp is the time point when the frame was captured by the device, on device clock domain.
+     *
+     * @return uint64_t The hardware timestamp of the frame in microseconds.
+     */
+    uint64_t getTimeStampUs() const {
+        ob_error *error       = nullptr;
+        auto      timeStampUs = ob_frame_get_timestamp_us(impl_, &error);
+        Error::handle(&error);
+
+        return timeStampUs;
+    }
+
+    /**
+     * @brief Get the system timestamp of the frame in microseconds.
+     * @brief The system timestamp is the time point when the frame was received by the host, on host clock domain.
+     *
+     * @return uint64_t The system timestamp of the frame in microseconds.
+     */
+    uint64_t getSystemTimeStampUs() const {
+        ob_error *error             = nullptr;
+        auto      systemTimeStampUs = ob_frame_get_system_timestamp_us(impl_, &error);
+        Error::handle(&error);
+
+        return systemTimeStampUs;
+    }
+
+    /**
+     * @brief Get the global timestamp of the frame in microseconds.
+     * @brief The global timestamp is the time point when the frame was was captured by the device, and has been converted to the host clock domain. The
+     * conversion process base on the device timestamp and can eliminate the timer drift of the device
+     *
+     * @attention The global timestamp disable by default. If global timestamp is not enabled, the function will return 0. To enable the global timestamp,
+     * please call @ref Device::enableGlobalTimestamp() function.
+     * @attention Only some devices support getting the global timestamp. Check the device support status by @ref Device::isGlobalTimestampSupported() function.
+     *
+     * @return uint64_t The global timestamp of the frame in microseconds.
+     */
+    uint64_t getGlobalTimeStampUs() const {
+        ob_error *error             = nullptr;
+        auto      globalTimeStampUs = ob_frame_get_global_timestamp_us(impl_, &error);
+        Error::handle(&error);
+
+        return globalTimeStampUs;
+    }
+
+    /**
+     * @brief Get the metadata pointer of the frame.
+     *
+     * @return const uint8_t * The metadata pointer of the frame.
+     */
+    uint8_t *getMetadata() const {
+        ob_error *error    = nullptr;
+        auto      metadata = ob_frame_get_metadata(impl_, &error);
+        Error::handle(&error);
+
+        return metadata;
+    }
+
+    /**
+     * @brief Get the size of the metadata of the frame.
+     *
+     * @return uint32_t The size of the metadata of the frame.
+     */
+    uint32_t getMetadataSize() const {
+        ob_error *error        = nullptr;
+        auto      metadataSize = ob_frame_get_metadata_size(impl_, &error);
+        Error::handle(&error);
+
+        return metadataSize;
+    }
+
+    /**
+     * @brief Check if the frame object has metadata of a given type.
+     *
+     * @param type The metadata type. refer to @ref OBFrameMetadataType
+     * @return bool The result.
+     */
+    bool hasMetadata(OBFrameMetadataType type) const {
+        ob_error *error  = nullptr;
+        auto      result = ob_frame_has_metadata(impl_, type, &error);
+        Error::handle(&error);
+
+        return result;
+    }
+
+    /**
+     * @brief Get the metadata value
+     *
+     * @param type The metadata type. refer to @ref OBFrameMetadataType
+     * @return int64_t The metadata value.
+     */
+    int64_t getMetadataValue(OBFrameMetadataType type) const {
+        ob_error *error = nullptr;
+        auto      value = ob_frame_get_metadata_value(impl_, type, &error);
+        Error::handle(&error);
+
+        return value;
+    }
+
+    /**
+     * @brief get StreamProfile of the frame
+     *
+     * @return std::shared_ptr<StreamProfile> The StreamProfile of the frame, may return nullptr if the frame is not captured from a stream.
+     */
+    std::shared_ptr<StreamProfile> getStreamProfile() const {
+        ob_error *error   = nullptr;
+        auto      profile = ob_frame_get_stream_profile(impl_, &error);
+        Error::handle(&error);
+        return StreamProfileFactory::create(profile);
+    }
+
+    /**
+     * @brief get owner sensor of the frame
+     *
+     * @return std::shared_ptr<Sensor> The owner sensor of the frame, return nullptr if the frame is not owned by any sensor or the sensor is destroyed
+     */
+    std::shared_ptr<Sensor> getSensor() const {
+        ob_error *error  = nullptr;
+        auto      sensor = ob_frame_get_sensor(impl_, &error);
+        Error::handle(&error);
+
+        return std::make_shared<Sensor>(sensor);
+    }
+
+    /**
+     * @brief get owner device of the frame
+     *
+     * @return std::shared_ptr<Device> The owner device of the frame, return nullptr if the frame is not owned by any device or the device is destroyed
+     */
+    std::shared_ptr<Device> getDevice() const {
+        ob_error *error  = nullptr;
+        auto      device = ob_frame_get_device(impl_, &error);
+        Error::handle(&error);
+
+        return std::make_shared<Device>(device);
+    }
+
+    /**
+     * @brief Check if the runtime type of the frame object is compatible with a given type.
+     *
+     * @tparam T The given type.
+     * @return bool The result.
+     */
+    template <typename T> bool is() const;
+
+    /**
+     * @brief Convert the frame object to a target type.
+     *
+     * @tparam T The target type.
+     * @return std::shared_ptr<T> The result. If it cannot be converted, an exception will be thrown.
+     */
+    template <typename T> std::shared_ptr<T> as() {
+        if(!is<T>()) {
+            throw std::runtime_error("unsupported operation, object's type is not require type");
+        }
+
+        ob_error *error = nullptr;
+        ob_frame_add_ref(impl_, &error);
+        Error::handle(&error);
+
+        return std::make_shared<T>(impl_);
+    }
+
+    /**
+     * @brief Convert the frame object to a target type.
+     *
+     * @tparam T The target type.
+     * @return std::shared_ptr<T> The result. If it cannot be converted, an exception will be thrown.
+     */
+    template <typename T> std::shared_ptr<const T> as() const {
+        if(!is<const T>()) {
+            throw std::runtime_error("unsupported operation, object's type is not require type");
+        }
+
+        ob_error *error = nullptr;
+        ob_frame_add_ref(impl_, &error);
+        Error::handle(&error);
+
+        return std::make_shared<const T>(impl_);
+    }
+
+public:
+    // The following interfaces are deprecated and are retained here for compatibility purposes.
+    OBFrameType type() const {
+        return getType();
+    }
+
+    virtual OBFormat format() const {
+        return getFormat();
+    }
+
+    virtual uint64_t index() const {
+        return getIndex();
+    }
+
+    virtual void *data() const {
+        auto data = getData();
+        return reinterpret_cast<void *>(data);
+    }
+
+    virtual uint32_t dataSize() const {
+        return getDataSize();
+    }
+
+    uint64_t timeStamp() const {
+        return getTimeStampUs() / 1000;
+    }
+
+    uint64_t timeStampUs() const {
+        return getTimeStampUs();
+    }
+
+    uint64_t systemTimeStamp() const {
+        return getSystemTimeStampUs() / 1000;
+    }
+
+    uint64_t systemTimeStampUs() const {
+        return getSystemTimeStampUs();
+    }
+
+    uint64_t globalTimeStampUs() const {
+        return getGlobalTimeStampUs();
+    }
+
+    uint8_t *metadata() const {
+        return getMetadata();
+    }
+
+    uint32_t metadataSize() const {
+        return getMetadataSize();
+    }
+};
+
+/**
+ * @brief Define the VideoFrame class, which inherits from the Frame class
+ */
+class VideoFrame : public Frame {
+public:
+    /**
+     * @brief Construct a new VideoFrame object with a given pointer to the internal frame object.
+     *
+     * @attention After calling this constructor, the frame object will own the internal frame object, and the internal frame object will be deleted when the
+     * frame object is destroyed.
+     * @attention The internal frame object should not be deleted by the caller.
+     *
+     * @param impl The pointer to the internal frame object.
+     */
+    explicit VideoFrame(const ob_frame *impl) : Frame(impl) {};
+
+    ~VideoFrame() noexcept override = default;
+
+    /**
+     * @brief Get the width of the frame.
+     *
+     * @return uint32_t The width of the frame.
+     */
+    uint32_t getWidth() const {
+        ob_error *error = nullptr;
+        auto      width = ob_video_frame_get_width(impl_, &error);
+        Error::handle(&error);
+
+        return width;
+    }
+
+    /**
+     * @brief Get the height of the frame.
+     *
+     * @return uint32_t The height of the frame.
+     */
+    uint32_t getHeight() const {
+        ob_error *error  = nullptr;
+        auto      height = ob_video_frame_get_height(impl_, &error);
+        Error::handle(&error);
+
+        return height;
+    }
+
+    /**
+     * @brief Get the Pixel Type object
+     * @brief Usually used to determine the pixel type of depth frame (depth, disparity, raw phase, etc.)
+     *
+     * @attention Always return OB_PIXEL_UNKNOWN for non-depth frame currently
+     *
+     * @return OBPixelType
+     */
+    OBPixelType getPixelType() const {
+        ob_error *error     = nullptr;
+        auto      pixelType = ob_video_frame_get_pixel_type(impl_, &error);
+        Error::handle(&error);
+
+        return pixelType;
+    }
+
+    /**
+     * @brief Get the effective number of pixels in the frame.
+     * @attention Only valid for Y8/Y10/Y11/Y12/Y14/Y16 format.
+     *
+     * @return uint8_t The effective number of pixels in the frame, or 0 if it is an unsupported format.
+     */
+    uint8_t getPixelAvailableBitSize() const {
+        ob_error *error   = nullptr;
+        auto      bitSize = ob_video_frame_get_pixel_available_bit_size(impl_, &error);
+        Error::handle(&error);
+
+        return bitSize;
+    }
+
+public:
+    // The following interfaces are deprecated and are retained here for compatibility purposes.
+    uint32_t width() const {
+        return getWidth();
+    }
+
+    uint32_t height() const {
+        return getHeight();
+    }
+
+    uint8_t pixelAvailableBitSize() const {
+        return getPixelAvailableBitSize();
+    }
+};
+
+/**
+ * @brief Define the ColorFrame class, which inherits from the VideoFrame classd
+ */
+class ColorFrame : public VideoFrame {
+public:
+    /**
+     * @brief Construct a new ColorFrame object with a given pointer to the internal frame object.
+     *
+     * @attention After calling this constructor, the frame object will own the internal frame object, and the internal frame object will be deleted when the
+     * frame object is destroyed.
+     * @attention The internal frame object should not be deleted by the caller.
+     * @attention Please use the FrameFactory to create a Frame object.
+     *
+     * @param impl The pointer to the internal frame object.
+     */
+    explicit ColorFrame(const ob_frame *impl) : VideoFrame(impl) {};
+
+    ~ColorFrame() noexcept override = default;
+};
+
+/**
+ * @brief Define the DepthFrame class, which inherits from the VideoFrame class
+ */
+class DepthFrame : public VideoFrame {
+
+public:
+    /**
+     * @brief Construct a new DepthFrame object with a given pointer to the internal frame object.
+     *
+     * @attention After calling this constructor, the frame object will own the internal frame object, and the internal frame object will be deleted when the
+     * frame object is destroyed.
+     * @attention The internal frame object should not be deleted by the caller.
+     * @attention Please use the FrameFactory to create a Frame object.
+     *
+     * @param impl The pointer to the internal frame object.
+     */
+    explicit DepthFrame(const ob_frame *impl) : VideoFrame(impl) {};
+
+    ~DepthFrame() noexcept override = default;
+
+    /**
+     * @brief Get the value scale of the depth frame. The pixel value of depth frame is multiplied by the scale to give a depth value in millimeters.
+     *   For example, if valueScale=0.1 and a certain coordinate pixel value is pixelValue=10000, then the depth value = pixelValue*valueScale =
+     *   10000*0.1=1000mm.
+     *
+     * @return float The scale.
+     */
+    float getValueScale() const {
+        ob_error *error = nullptr;
+        auto      scale = ob_depth_frame_get_value_scale(impl_, &error);
+        Error::handle(&error);
+
+        return scale;
+    }
+};
+
+/**
+ * @brief Define the IRFrame class, which inherits from the VideoFrame class
+ *
+ */
+class IRFrame : public VideoFrame {
+
+public:
+    /**
+     * @brief Construct a new IRFrame object with a given pointer to the internal frame object.
+     *
+     * @attention After calling this constructor, the frame object will own the internal frame object, and the internal frame object will be deleted when the
+     * frame object is destroyed.
+     * @attention The internal frame object should not be deleted by the caller.
+     * @attention Please use the FrameFactory to create a Frame object.
+     *
+     * @param impl The pointer to the internal frame object.
+     */
+    explicit IRFrame(const ob_frame *impl) : VideoFrame(impl) {};
+
+    ~IRFrame() noexcept override = default;
+};
+
+/**
+ * @brief Define the PointsFrame class, which inherits from the Frame class
+ * @brief The PointsFrame class is used to obtain pointcloud data and point cloud information.
+ *
+ * @note The pointcloud data format can be obtained from the @ref Frame::getFormat() function. Witch can be one of the following formats:
+ * - @ref OB_FORMAT_POINT: 32-bit float format with 3D point coordinates (x, y, z), @ref OBPoint
+ * - @ref OB_FORMAT_RGB_POINT: 32-bit float format with 3D point coordinates (x, y, z) and point colors (r, g, b) @ref, OBColorPoint
+ */
+class PointsFrame : public Frame {
+
+public:
+    /**
+     * @brief Construct a new PointsFrame object with a given pointer to the internal frame object.
+     *
+     * @attention After calling this constructor, the frame object will own the internal frame object, and the internal frame object will be deleted when the
+     * frame object is destroyed.
+     * @attention The internal frame object should not be deleted by the caller.
+     * @attention Please use the FrameFactory to create a Frame object.
+     *
+     * @param impl The pointer to the internal frame object.
+     */
+    explicit PointsFrame(const ob_frame *impl) : Frame(impl) {};
+
+    ~PointsFrame() noexcept override = default;
+
+    /**
+     * @brief Get the point coordinate value scale of the points frame. The point position value of the points frame is multiplied by the scale to give a
+     * position value in millimeters. For example, if scale=0.1, the x-coordinate value of a point is x = 10000, which means that the actual x-coordinate value
+     * = x*scale = 10000*0.1 = 1000mm.
+     *
+     * @return float The coordinate value scale.
+     */
+    float getCoordinateValueScale() const {
+        ob_error *error = nullptr;
+        auto      scale = ob_points_frame_get_coordinate_value_scale(impl_, &error);
+        Error::handle(&error);
+
+        return scale;
+    }
+
+public:
+    // The following interfaces are deprecated and are retained here for compatibility purposes.
+#define getPositionValueScale getCoordinateValueScale
+};
+
+/**
+ * @brief Define the AccelFrame class, which inherits from the Frame class
+ *
+ */
+class AccelFrame : public Frame {
+
+public:
+    explicit AccelFrame(const ob_frame *impl) : Frame(impl) {};
+
+    ~AccelFrame() noexcept override = default;
+
+    /**
+     * @brief Get the accelerometer frame data
+     *
+     * @return OBAccelValue The accelerometer frame data
+     */
+    OBAccelValue getValue() const {
+        ob_error *error = nullptr;
+        auto      value = ob_accel_frame_get_value(impl_, &error);
+        Error::handle(&error);
+
+        return value;
+    }
+
+    /**
+     * @brief Get the temperature when the frame was sampled
+     *
+     * @return float The temperature value in celsius
+     */
+    float getTemperature() const {
+        ob_error *error = nullptr;
+        auto      temp  = ob_accel_frame_get_temperature(impl_, &error);
+        Error::handle(&error);
+
+        return temp;
+    }
+
+public:
+    // The following interfaces are deprecated and are retained here for compatibility purposes.
+    OBAccelValue value() {
+        return getValue();
+    }
+
+    float temperature() {
+        return getTemperature();
+    }
+};
+
+/**
+ * @brief Define the GyroFrame class, which inherits from the Frame class
+ */
+class GyroFrame : public Frame {
+
+public:
+    explicit GyroFrame(const ob_frame *impl) : Frame(impl) {};
+
+    ~GyroFrame() noexcept override = default;
+
+    /**
+     * @brief Get the gyro frame data
+     *
+     * @return OBAccelValue The gyro frame data
+     */
+    OBGyroValue getValue() const {
+        ob_error *error = nullptr;
+        auto      value = ob_gyro_frame_get_value(impl_, &error);
+        Error::handle(&error);
+
+        return value;
+    }
+
+    /**
+     * @brief Get the temperature when the frame was sampled
+     *
+     * @return float The temperature value in celsius
+     */
+    float getTemperature() const {
+        ob_error *error       = nullptr;
+        auto      temperature = ob_gyro_frame_get_temperature(impl_, &error);
+        Error::handle(&error);
+
+        return temperature;
+    }
+
+public:
+    // The following interfaces are deprecated and are retained here for compatibility purposes.
+    OBGyroValue value() {
+        return getValue();
+    }
+
+    float temperature() {
+        return getTemperature();
+    }
+};
+
+/**
+ * @brief Define the FrameSet class, which inherits from the Frame class
+ * @brief A FrameSet is a container for multiple frames of different types.
+ */
+class FrameSet : public Frame {
+
+public:
+    explicit FrameSet(const ob_frame *impl) : Frame(impl) {};
+
+    ~FrameSet() noexcept override = default;
+
+    /**
+     * @brief Get the number of frames in the FrameSet
+     *
+     * @return uint32_t The number of frames
+     */
+    uint32_t getCount() const {
+        ob_error *error = nullptr;
+        auto      count = ob_frameset_get_count(impl_, &error);
+        Error::handle(&error);
+        return count;
+    }
+
+    /**
+     * @brief Get a frame of a specific type from the FrameSet
+     *
+     * @param frameType The type of sensor
+     * @return std::shared_ptr<Frame> The corresponding type of frame
+     */
+    std::shared_ptr<Frame> getFrame(OBFrameType frameType) const {
+        ob_error *error = nullptr;
+        auto      frame = ob_frameset_get_frame(impl_, frameType, &error);
+        if(!frame) {
+            return nullptr;
+        }
+        Error::handle(&error);
+        return std::make_shared<Frame>(frame);
+    }
+
+    /**
+     * @brief Get a frame at a specific index from the FrameSet
+     *
+     * @param index The index of the frame
+     * @return std::shared_ptr<Frame> The frame at the specified index
+     */
+    std::shared_ptr<Frame> getFrameByIndex(uint32_t index) const {
+        ob_error *error = nullptr;
+        auto      frame = ob_frameset_get_frame_by_index(impl_, index, &error);
+        if(!frame) {
+            return nullptr;
+        }
+        Error::handle(&error);
+        return std::make_shared<Frame>(frame);
+    }
+
+    /**
+     * @brief Push a frame to the FrameSet
+     *
+     * @attention If the FrameSet contains the same type of frame, the new frame will replace the old one.
+     *
+     * @param frame The frame to be pushed
+     */
+    void pushFrame(std::shared_ptr<const Frame> frame) const {
+        ob_error *error = nullptr;
+
+        // unsafe operation, need to cast const to non-const
+        auto unConstImpl = const_cast<ob_frame *>(impl_);
+
+        auto otherImpl = frame->getImpl();
+        ob_frameset_push_frame(unConstImpl, otherImpl, &error);
+
+        Error::handle(&error);
+    }
+
+public:
+    // The following interfaces are deprecated and are retained here for compatibility purposes.
+    uint32_t frameCount() const {
+        return getCount();
+    }
+
+    std::shared_ptr<DepthFrame> depthFrame() const {
+        auto frame = getFrame(OB_FRAME_DEPTH);
+        if(frame == nullptr) {
+            return nullptr;
+        }
+        auto depthFrame = frame->as<ob::DepthFrame>();
+        return depthFrame;
+    }
+
+    std::shared_ptr<ColorFrame> colorFrame() const {
+        auto frame = getFrame(OB_FRAME_COLOR);
+        if(frame == nullptr) {
+            return nullptr;
+        }
+        auto colorFrame = frame->as<ob::ColorFrame>();
+        return colorFrame;
+    }
+
+    std::shared_ptr<IRFrame> irFrame() const {
+        auto frame = getFrame(OB_FRAME_IR);
+        if(frame == nullptr) {
+            return nullptr;
+        }
+        auto irFrame = frame->as<ob::IRFrame>();
+        return irFrame;
+    }
+
+public:
+    // The following interfaces are deprecated and are retained here for compatibility purposes.
+    std::shared_ptr<PointsFrame> pointsFrame() const {
+        auto frame = getFrame(OB_FRAME_POINTS);
+        if(frame == nullptr) {
+            return nullptr;
+        }
+        auto pointsFrame = frame->as<ob::PointsFrame>();
+        return pointsFrame;
+    }
+
+    std::shared_ptr<Frame> getFrame(int index) const {
+        return getFrameByIndex(index);
+    }
+};
+
+/**
+ * @brief FrameFactory class, which provides some static functions to create frame objects
+ */
+class FrameFactory {
+public:
+    /**
+     * @brief Create a Frame object of a specific type with a given format and data size.
+     *
+     * @param frameType The type of the frame.
+     * @param format The format of the frame.
+     * @param dataSize The size of the data in bytes.
+     * @return std::shared_ptr<Frame> The created frame object.
+     */
+    static std::shared_ptr<Frame> createFrame(OBFrameType frameType, OBFormat format, uint32_t dataSize) {
+        ob_error *error = nullptr;
+        auto      impl  = ob_create_frame(frameType, format, dataSize, &error);
+        Error::handle(&error);
+
+        return std::make_shared<Frame>(impl);
+    }
+
+    /**
+     * @brief Create a VideoFrame object of a specific type with a given format, width, height, and stride.
+     * @note If stride is not specified, it will be calculated based on the width and format.
+     *
+     * @param frameType The type of the frame.
+     * @param format The format of the frame.
+     * @param width The width of the frame.
+     * @param height The height of the frame.
+     * @param stride The stride of the frame.
+     *
+     * @return std::shared_ptr<VideoFrame> The created video frame object.
+     */
+    static std::shared_ptr<VideoFrame> createVideoFrame(OBFrameType frameType, OBFormat format, uint32_t width, uint32_t height, uint32_t stride = 0) {
+        ob_error *error = nullptr;
+        auto      impl  = ob_create_video_frame(frameType, format, width, height, stride, &error);
+        Error::handle(&error);
+
+        auto frame = std::make_shared<Frame>(impl);
+        return frame->as<VideoFrame>();
+    }
+
+    /**
+     * @brief Create (clone) a frame object based on the specified other frame object.
+     * @brief The new frame object will have the same properties as the other frame object, but the data buffer is newly allocated.
+     *
+     * @param shouldCopyData If true, the data of the source frame object will be copied to the new frame object. If false, the new frame object will
+     * have a data buffer with random data. The default value is true.
+     *
+     * @return std::shared_ptr<Frame> The new frame object.
+     */
+    static std::shared_ptr<Frame> createFrameFromOtherFrame(std::shared_ptr<const Frame> otherFrame, bool shouldCopyData = true) {
+        ob_error *error     = nullptr;
+        auto      otherImpl = otherFrame->getImpl();
+        auto      impl      = ob_create_frame_from_other_frame(otherImpl, shouldCopyData, &error);
+        Error::handle(&error);
+
+        return std::make_shared<Frame>(impl);
+    }
+
+    /**
+     * @brief Create a Frame From (according to)Stream Profile object
+     *
+     * @param profile The stream profile object to create the frame from.
+     *
+     * @return std::shared_ptr<Frame>  The created frame object.
+     */
+    static std::shared_ptr<Frame> createFrameFromStreamProfile(std::shared_ptr<const StreamProfile> profile) {
+        ob_error *error = nullptr;
+        auto      impl  = ob_create_frame_from_stream_profile(profile->getImpl(), &error);
+        Error::handle(&error);
+
+        return std::make_shared<Frame>(impl);
+    }
+
+    /**
+     * @brief The callback function to destroy the buffer when the frame is destroyed.
+     */
+    typedef std::function<void(uint8_t *)> BufferDestroyCallback;
+
+    /**
+     * @brief Create a frame object based on an externally created buffer.
+     *
+     * @attention The buffer is owned by the caller, and will not be destroyed by the frame object. The user should ensure that the buffer is valid and not
+     * modified.
+     *
+     * @param[in] frame_type Frame object type.
+     * @param[in] format Frame object format.
+     * @param[in] buffer Frame object buffer.
+     * @param[in] buffer_size Frame object buffer size.
+     * @param[in] destroyCallback Destroy callback, will be called when the frame object is destroyed.
+     *
+     * @return std::shared_ptr<Frame> The created frame object.
+     */
+    static std::shared_ptr<Frame> createFrameFromBuffer(OBFrameType frameType, OBFormat format, uint8_t *buffer, BufferDestroyCallback destroyCallback,
+                                                        uint32_t bufferSize) {
+        ob_error *error = nullptr;
+        auto      ctx   = new BufferDestroyContext{ destroyCallback };
+        auto      impl  = ob_create_frame_from_buffer(frameType, format, buffer, bufferSize, &FrameFactory::BufferDestroy, ctx, &error);
+        Error::handle(&error);
+
+        return std::make_shared<Frame>(impl);
+    }
+
+    /**
+     * @brief Create a video frame object based on an externally created buffer.
+     *
+     * @attention The buffer is owned by the user and will not be destroyed by the frame object. The user should ensure that the buffer is valid and not
+     * modified.
+     * @attention The frame object is created with a reference count of 1, and the reference count should be decreased by calling @ref ob_delete_frame() when it
+     * is no longer needed.
+     *
+     * @param[in] frameType Frame object type.
+     * @param[in] format Frame object format.
+     * @param[in] width Frame object width.
+     * @param[in] height Frame object height.
+     * @param[in] buffer Frame object buffer.
+     * @param[in] bufferSize Frame object buffer size.
+     * @param[in] destroyCallback Destroy callback, will be called when the frame object is destroyed.
+     * @param[in] stride Row span in bytes. If 0, the stride is calculated based on the width and format.
+     *
+     * @return std::shared_ptr<VideoFrame> The created video frame object.
+     */
+    static std::shared_ptr<VideoFrame> createVideoFrameFromBuffer(OBFrameType frameType, OBFormat format, uint32_t width, uint32_t height, uint8_t *buffer,
+                                                                  BufferDestroyCallback destroyCallback, uint32_t bufferSize, uint32_t stride = 0) {
+        ob_error *error = nullptr;
+        auto      ctx   = new BufferDestroyContext{ destroyCallback };
+        auto impl = ob_create_video_frame_from_buffer(frameType, format, width, height, stride, buffer, bufferSize, &FrameFactory::BufferDestroy, ctx, &error);
+        Error::handle(&error);
+
+        auto frame = std::make_shared<Frame>(impl);
+        return frame->as<VideoFrame>();
+    }
+
+private:
+    struct BufferDestroyContext {
+        BufferDestroyCallback callback;
+    };
+
+    static void BufferDestroy(uint8_t *buffer, void *context) {
+        auto *ctx = static_cast<BufferDestroyContext *>(context);
+        ctx->callback(buffer);
+        delete ctx;
+    }
+};
+
+/**
+ * @brief FrameHepler class, which provides some static functions to set timestamp for frame objects
+ * FrameHepler inherited from the FrameFactory and the timestamp interface implement here both for compatibility purposes.
+ */
+class FrameHelper : public FrameFactory {
+public:
+    /**
+     * @brief Set the device timestamp of the frame.
+     *
+     * @param frame The frame object.
+     * @param deviceTimestampUs The device timestamp to set in microseconds.
+     */
+    static void setFrameDeviceTimestampUs(std::shared_ptr<Frame> frame, uint64_t deviceTimestampUs) {
+        ob_error *error = nullptr;
+        auto      impl  = const_cast<ob_frame *>(frame->getImpl());
+        ob_frame_set_timestamp_us(impl, deviceTimestampUs, &error);
+        Error::handle(&error);
+    }
+
+public:
+    // The following interfaces are deprecated and are retained here for compatibility purposes.
+    static void setFrameSystemTimestamp(std::shared_ptr<Frame> frame, uint64_t systemTimestamp) {
+        // In order to compile, some high-version compilers will warn that the function parameters are not used.
+        (void)frame;
+        (void)systemTimestamp;
+    }
+
+    static void setFrameDeviceTimestamp(std::shared_ptr<Frame> frame, uint64_t deviceTimestamp) {
+        // In order to compile, some high-version compilers will warn that the function parameters are not used.
+        (void)frame;
+        (void)deviceTimestamp;
+    }
+};
+
+// Define the is() template function for the Frame class
+template <typename T> bool Frame::is() const {
+    switch(this->getType()) {
+    case OB_FRAME_IR_LEFT:   // Follow
+    case OB_FRAME_IR_RIGHT:  // Follow
+    case OB_FRAME_IR:
+        return (typeid(T) == typeid(IRFrame) || typeid(T) == typeid(VideoFrame));
+    case OB_FRAME_DEPTH:
+        return (typeid(T) == typeid(DepthFrame) || typeid(T) == typeid(VideoFrame));
+    case OB_FRAME_COLOR:
+        return (typeid(T) == typeid(ColorFrame) || typeid(T) == typeid(VideoFrame));
+    case OB_FRAME_GYRO:
+        return (typeid(T) == typeid(GyroFrame));
+    case OB_FRAME_ACCEL:
+        return (typeid(T) == typeid(AccelFrame));
+    case OB_FRAME_POINTS:
+        return (typeid(T) == typeid(PointsFrame));
+    case OB_FRAME_SET:
+        return (typeid(T) == typeid(FrameSet));
+    default:
+        std::cout << "ob::Frame::is() did not catch frame type: " << (int)this->getType() << std::endl;
+        break;
+    }
+    return false;
+}
+
+}  // namespace ob
diff --git a/include/libobsensor/hpp/Pipeline.hpp b/include/libobsensor/hpp/Pipeline.hpp
new file mode 100644
index 00000000..7a1f4ebd
--- /dev/null
+++ b/include/libobsensor/hpp/Pipeline.hpp
@@ -0,0 +1,452 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+/**
+ * @file Pipeline.hpp
+ * @brief The SDK's advanced API type can quickly implement switching streaming and frame synchronization
+ * operations.
+ */
+#pragma once
+
+#include "Frame.hpp"
+#include "Device.hpp"
+#include "StreamProfile.hpp"
+
+#include "libobsensor/h/Pipeline.h"
+#include "libobsensor/hpp/Types.hpp"
+#include "libobsensor/hpp/TypeHelper.hpp"
+
+#include <memory>
+#include <functional>
+namespace ob {
+
+/**
+ * @brief Config class for configuring pipeline parameters
+ *
+ * The Config class provides an interface for configuring pipeline parameters.
+ */
+class Config {
+private:
+    ob_config_t *impl_;
+
+public:
+    /**
+     * @brief Construct a new Config object
+     */
+    Config() {
+        ob_error *error = nullptr;
+        impl_           = ob_create_config(&error);
+        Error::handle(&error);
+    }
+
+    explicit Config(ob_config_t *impl) : impl_(impl) {}
+
+    /**
+     * @brief Destroy the Config object
+     */
+    ~Config() noexcept {
+        ob_error *error = nullptr;
+        ob_delete_config(impl_, &error);
+        Error::handle(&error, false);
+    }
+
+    ob_config_t *getImpl() const {
+        return impl_;
+    }
+
+    /**
+     * @brief enable a stream with a specific stream type
+     *
+     * @param streamType The stream type to be enabled
+     */
+    void enableStream(OBStreamType streamType) const {
+        ob_error *error = nullptr;
+        ob_config_enable_stream(impl_, streamType, &error);
+        Error::handle(&error);
+    }
+
+    /**
+     * @brief Enable a stream with a specific sensor type
+     * @brief Will convert sensor type to stream type automatically.
+     *
+     * @param sensorType The sensor type to be enabled
+     */
+    void enableStream(OBSensorType sensorType) const {
+        auto streamType = ob::TypeHelper::convertSensorTypeToStreamType(sensorType);
+        enableStream(streamType);
+    }
+
+    /**
+     * @brief Enable a stream to be used in the pipeline
+     *
+     * @param streamProfile The stream configuration to be enabled
+     */
+    void enableStream(std::shared_ptr<const StreamProfile> streamProfile) const {
+        ob_error *error            = nullptr;
+        auto      c_stream_profile = streamProfile->getImpl();
+        ob_config_enable_stream_with_stream_profile(impl_, c_stream_profile, &error);
+        Error::handle(&error);
+    }
+
+    /**
+     * @brief Enable a video stream to be used in the pipeline.
+     *
+     * This function allows users to enable a video stream with customizable parameters.
+     * If no parameters are specified, the stream will be enabled with default resolution settings.
+     * Users who wish to set custom resolutions should refer to the product manual, as available resolutions vary by camera model.
+     *
+     * @param type The video stream type.
+     * @param width The video stream width (default is OB_WIDTH_ANY, which selects the default resolution).
+     * @param height The video stream height (default is OB_HEIGHT_ANY, which selects the default resolution).
+     * @param fps The video stream frame rate (default is OB_FPS_ANY, which selects the default frame rate).
+     * @param format The video stream format (default is OB_FORMAT_ANY, which selects the default format).
+     */
+    void enableVideoStream(OBStreamType streamType, uint32_t width = OB_WIDTH_ANY, uint32_t height = OB_HEIGHT_ANY, uint32_t fps = OB_FPS_ANY,
+                           OBFormat format = OB_FORMAT_ANY) const {
+        ob_error *error = nullptr;
+        ob_config_enable_video_stream(impl_, streamType, width, height, fps, format, &error);
+        Error::handle(&error);
+    }
+
+    /**
+     * @brief Enable a video stream to be used in the pipeline.
+     * @brief Will convert sensor type to stream type automatically.
+     *
+     * @param sensorType The sensor type to be enabled.
+     * @param width The video stream width (default is OB_WIDTH_ANY, which selects the default resolution).
+     * @param height The video stream height (default is OB_HEIGHT_ANY, which selects the default resolution).
+     * @param fps The video stream frame rate (default is OB_FPS_ANY, which selects the default frame rate).
+     * @param format The video stream format (default is OB_FORMAT_ANY, which selects the default format).
+     */
+    void enableVideoStream(OBSensorType sensorType, uint32_t width = OB_WIDTH_ANY, uint32_t height = OB_HEIGHT_ANY, uint32_t fps = OB_FPS_ANY,
+                           OBFormat format = OB_FORMAT_ANY) const {
+        auto streamType = ob::TypeHelper::convertSensorTypeToStreamType(sensorType);
+        enableVideoStream(streamType, width, height, fps, format);
+    }
+
+    /**
+     * @brief Enable an accelerometer stream to be used in the pipeline.
+     *
+     * This function allows users to enable an accelerometer stream with customizable parameters.
+     * If no parameters are specified, the stream will be enabled with default settings.
+     * Users who wish to set custom full-scale ranges or sample rates should refer to the product manual, as available settings vary by device model.
+     *
+     * @param fullScaleRange The full-scale range of the accelerometer (default is OB_ACCEL_FULL_SCALE_RANGE_ANY, which selects the default range).
+     * @param sampleRate The sample rate of the accelerometer (default is OB_ACCEL_SAMPLE_RATE_ANY, which selects the default rate).
+     */
+    void enableAccelStream(OBAccelFullScaleRange fullScaleRange = OB_ACCEL_FULL_SCALE_RANGE_ANY,
+                           OBAccelSampleRate     sampleRate     = OB_ACCEL_SAMPLE_RATE_ANY) const {
+        ob_error *error = nullptr;
+        ob_config_enable_accel_stream(impl_, fullScaleRange, sampleRate, &error);
+        Error::handle(&error);
+    }
+
+    /**
+     * @brief Enable a gyroscope stream to be used in the pipeline.
+     *
+     * This function allows users to enable a gyroscope stream with customizable parameters.
+     * If no parameters are specified, the stream will be enabled with default settings.
+     * Users who wish to set custom full-scale ranges or sample rates should refer to the product manual, as available settings vary by device model.
+     *
+     * @param fullScaleRange The full-scale range of the gyroscope (default is OB_GYRO_FULL_SCALE_RANGE_ANY, which selects the default range).
+     * @param sampleRate The sample rate of the gyroscope (default is OB_GYRO_SAMPLE_RATE_ANY, which selects the default rate).
+     */
+    void enableGyroStream(OBGyroFullScaleRange fullScaleRange = OB_GYRO_FULL_SCALE_RANGE_ANY, OBGyroSampleRate sampleRate = OB_GYRO_SAMPLE_RATE_ANY) const {
+        ob_error *error = nullptr;
+        ob_config_enable_gyro_stream(impl_, fullScaleRange, sampleRate, &error);
+        Error::handle(&error);
+    }
+
+    /**
+     * @deprecated Use enableStream(std::shared_ptr<StreamProfile> streamProfile) instead
+     * @brief Enable all streams to be used in the pipeline
+     */
+    void enableAllStream() {
+        ob_error *error = nullptr;
+        ob_config_enable_all_stream(impl_, &error);
+        Error::handle(&error);
+    }
+
+    /**
+     * @brief Disable a stream to be used in the pipeline
+     *
+     * @param streamType The stream configuration to be disabled
+     */
+    void disableStream(OBStreamType streamType) const {
+        ob_error *error = nullptr;
+        ob_config_disable_stream(impl_, streamType, &error);
+        Error::handle(&error);
+    }
+
+    /**
+     * @brief Disable a sensor stream to be used in the pipeline.
+     * @brief Will convert sensor type to stream type automatically.
+     *
+     * @param sensorType
+     */
+    void disableStream(OBSensorType sensorType) const {
+        auto streamType = ob::TypeHelper::convertSensorTypeToStreamType(sensorType);
+        disableStream(streamType);
+    }
+
+    /**
+     * @brief Disable all streams to be used in the pipeline
+     */
+    void disableAllStream() const {
+        ob_error *error = nullptr;
+        ob_config_disable_all_stream(impl_, &error);
+        Error::handle(&error);
+    }
+
+    /**
+     * @brief Get the Enabled Stream Profile List
+     *
+     * @return std::shared_ptr<StreamProfileList>
+     */
+    std::shared_ptr<StreamProfileList> getEnabledStreamProfileList() const {
+        ob_error *error = nullptr;
+        auto      list  = ob_config_get_enabled_stream_profile_list(impl_, &error);
+        Error::handle(&error);
+        return std::make_shared<StreamProfileList>(list);
+    }
+
+    /**
+     * @brief Set the alignment mode
+     *
+     * @param mode The alignment mode
+     */
+    void setAlignMode(OBAlignMode mode) const {
+        ob_error *error = nullptr;
+        ob_config_set_align_mode(impl_, mode, &error);
+        Error::handle(&error);
+    }
+
+    /**
+     * @brief Set whether the depth needs to be scaled after setting D2C
+     *
+     * @param enable Whether scaling is required
+     */
+    void setDepthScaleRequire(bool enable) const {
+        ob_error *error = nullptr;
+        ob_config_set_depth_scale_after_align_require(impl_, enable, &error);
+        Error::handle(&error);
+    }
+
+    /**
+     * @brief Set the frame aggregation output mode for the pipeline configuration
+     * @brief The processing strategy when the FrameSet generated by the frame aggregation function does not contain the frames of all opened streams (which
+     * can be caused by different frame rates of each stream, or by the loss of frames of one stream): drop directly or output to the user.
+     *
+     * @param mode The frame aggregation output mode to be set (default mode is @ref OB_FRAME_AGGREGATE_OUTPUT_ANY_SITUATION)
+     */
+    void setFrameAggregateOutputMode(OBFrameAggregateOutputMode mode) const {
+        ob_error *error = nullptr;
+        ob_config_set_frame_aggregate_output_mode(impl_, mode, &error);
+        Error::handle(&error);
+    }
+};
+
+class Pipeline {
+public:
+    /**
+     * @brief FrameSetCallback is a callback function type for frameset data arrival.
+     *
+     * @param frame The returned frameset data
+     */
+    typedef std::function<void(std::shared_ptr<FrameSet> frame)> FrameSetCallback;
+
+private:
+    ob_pipeline_t   *impl_;
+    FrameSetCallback callback_;
+
+public:
+    /**
+     * @brief Pipeline is a high-level interface for applications, algorithms related RGBD data streams. Pipeline can provide alignment inside and synchronized
+     * FrameSet. Pipeline() no parameter version, which opens the first device in the list of devices connected to the OS by default. If the application has
+     * obtained the device through the DeviceList, opening the Pipeline() at this time will throw an exception that the device has been created.
+     */
+    Pipeline() {
+        ob_error *error = nullptr;
+        impl_           = ob_create_pipeline(&error);
+        Error::handle(&error);
+    }
+
+    /**
+     * @brief
+     * Pipeline(std::shared_ptr< Device > device ) Function for multi-device operations. Multiple devices need to be obtained through DeviceList, and the device
+     * and pipeline are bound through this interface.
+     */
+    explicit Pipeline(std::shared_ptr<Device> device) {
+        ob_error *error = nullptr;
+        impl_           = ob_create_pipeline_with_device(device->getImpl(), &error);
+        Error::handle(&error);
+    }
+
+    /**
+     * @brief Destroy the pipeline object
+     */
+    ~Pipeline() noexcept {
+        ob_error *error = nullptr;
+        ob_delete_pipeline(impl_, &error);
+        Error::handle(&error, false);
+    }
+
+    /**
+     * @brief Start the pipeline with configuration parameters
+     *
+     * @param config The parameter configuration of the pipeline
+     */
+    void start(std::shared_ptr<Config> config = nullptr) const {
+        ob_error    *error       = nullptr;
+        ob_config_t *config_impl = config == nullptr ? nullptr : config->getImpl();
+        ob_pipeline_start_with_config(impl_, config_impl, &error);
+        Error::handle(&error);
+    }
+
+    /**
+     * @brief Start the pipeline and set the frameset data callback
+     *
+     * @param config The configuration of the pipeline
+     * @param callback The callback to be triggered when all frame data in the frameset arrives
+     */
+    void start(std::shared_ptr<Config> config, FrameSetCallback callback) {
+        callback_       = callback;
+        ob_error *error = nullptr;
+        ob_pipeline_start_with_callback(impl_, config ? config->getImpl() : nullptr, &Pipeline::frameSetCallback, this, &error);
+        Error::handle(&error);
+    }
+
+    static void frameSetCallback(ob_frame_t *frameSet, void *userData) {
+        auto pipeline = static_cast<Pipeline *>(userData);
+        pipeline->callback_(std::make_shared<FrameSet>(frameSet));
+    }
+
+    /**
+     * @brief Stop the pipeline
+     */
+    void stop() const {
+        ob_error *error = nullptr;
+        ob_pipeline_stop(impl_, &error);
+        Error::handle(&error);
+    }
+
+    /**
+     * @brief Get the pipeline configuration parameters
+     * @brief Returns the default configuration if the user has not configured it
+     *
+     * @return std::shared_ptr<Config> The configured parameters
+     */
+    std::shared_ptr<Config> getConfig() const {
+        ob_error *error  = nullptr;
+        auto      config = ob_pipeline_get_config(impl_, &error);
+        Error::handle(&error);
+        return std::make_shared<Config>(config);
+    }
+
+    /**
+     * @brief Wait for frameset
+     *
+     * @param timeout_ms The waiting timeout in milliseconds
+     * @return std::shared_ptr<FrameSet> The waiting frameset data
+     */
+    std::shared_ptr<FrameSet> waitForFrameset(uint32_t timeoutMs = 1000) const {
+        ob_error *error    = nullptr;
+        auto      frameSet = ob_pipeline_wait_for_frameset(impl_, timeoutMs, &error);
+        if(frameSet == nullptr) {
+            return nullptr;
+        }
+        Error::handle(&error);
+        return std::make_shared<FrameSet>(frameSet);
+    }
+
+    /**
+     * @brief Get the device object
+     *
+     * @return std::shared_ptr<Device> The device object
+     */
+    std::shared_ptr<Device> getDevice() const {
+        ob_error *error  = nullptr;
+        auto      device = ob_pipeline_get_device(impl_, &error);
+        Error::handle(&error);
+        return std::make_shared<Device>(device);
+    }
+
+    /**
+     * @brief Get the stream profile of the specified sensor
+     *
+     * @param sensorType The type of sensor
+     * @return std::shared_ptr<StreamProfileList> The stream profile list
+     */
+    std::shared_ptr<StreamProfileList> getStreamProfileList(OBSensorType sensorType) const {
+        ob_error *error = nullptr;
+        auto      list  = ob_pipeline_get_stream_profile_list(impl_, sensorType, &error);
+        Error::handle(&error);
+        return std::make_shared<StreamProfileList>(list);
+    }
+
+    /**
+     * @brief Get the stream profile list of supported depth-to-color alignments
+     *
+     * @param colorProfile The color stream profile, witch is the target stream profile for the depth-to-color alignment.
+     * @param alignMode The alignment mode.
+     *
+     * @attention Currently, only ALIGN_D2C_HW_MODE supported. For other align modes, please using the AlignFilter interface.
+     *
+     * @return std::shared_ptr<StreamProfileList> The stream profile list of supported depth-to-color alignments.
+     */
+    std::shared_ptr<StreamProfileList> getD2CDepthProfileList(std::shared_ptr<StreamProfile> colorProfile, OBAlignMode alignMode) {
+        ob_error *error = nullptr;
+        auto      list  = ob_get_d2c_depth_profile_list(impl_, colorProfile->getImpl(), alignMode, &error);
+        Error::handle(&error);
+        return std::make_shared<StreamProfileList>(list);
+    }
+
+    /**
+     * @brief Turn on frame synchronization
+     */
+    void enableFrameSync() const {
+        ob_error *error = nullptr;
+        ob_pipeline_enable_frame_sync(impl_, &error);
+        Error::handle(&error);
+    }
+
+    /**
+     * @brief Turn off frame synchronization
+     */
+    void disableFrameSync() const {
+        ob_error *error = nullptr;
+        ob_pipeline_disable_frame_sync(impl_, &error);
+        Error::handle(&error);
+    }
+
+public:
+    // The following interfaces are deprecated and are retained here for compatibility purposes.
+
+    OBCameraParam getCameraParam() {
+        ob_error     *error       = nullptr;
+        OBCameraParam cameraParam = ob_pipeline_get_camera_param(impl_, &error);
+        Error::handle(&error);
+        return cameraParam;
+    }
+
+    OBCameraParam getCameraParamWithProfile(uint32_t colorWidth, uint32_t colorHeight, uint32_t depthWidth, uint32_t depthHeight) {
+        ob_error     *error       = nullptr;
+        OBCameraParam cameraParam = ob_pipeline_get_camera_param_with_profile(impl_, colorWidth, colorHeight, depthWidth, depthHeight, &error);
+        Error::handle(&error);
+        return cameraParam;
+    }
+
+    OBCalibrationParam getCalibrationParam(std::shared_ptr<Config> config) {
+        ob_error          *error            = nullptr;
+        OBCalibrationParam calibrationParam = ob_pipeline_get_calibration_param(impl_, config->getImpl(), &error);
+        Error::handle(&error);
+        return calibrationParam;
+    }
+
+    std::shared_ptr<FrameSet> waitForFrames(uint32_t timeoutMs = 1000) const {
+        return waitForFrameset(timeoutMs);
+    }
+};
+
+}  // namespace ob
+
diff --git a/include/libobsensor/hpp/Sensor.hpp b/include/libobsensor/hpp/Sensor.hpp
new file mode 100644
index 00000000..73345f2b
--- /dev/null
+++ b/include/libobsensor/hpp/Sensor.hpp
@@ -0,0 +1,236 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+/**
+ * @file Sensor.hpp
+ * @brief Defines types related to sensors, which are used to obtain stream configurations, open and close streams, and set and get sensor properties.
+ */
+#pragma once
+
+#include "Types.hpp"
+#include "libobsensor/hpp/Filter.hpp"
+#include "libobsensor/h/Sensor.h"
+#include "libobsensor/h/Filter.h"
+#include "Error.hpp"
+#include "StreamProfile.hpp"
+#include "Device.hpp"
+#include "Frame.hpp"
+#include <functional>
+#include <memory>
+#include <vector>
+
+namespace ob {
+
+class Sensor {
+public:
+    /**
+     * @brief Callback function for frame data.
+     *
+     * @param frame The frame data.
+     */
+    typedef std::function<void(std::shared_ptr<Frame> frame)> FrameCallback;
+
+protected:
+    ob_sensor_t  *impl_;
+    FrameCallback callback_;
+
+public:
+    explicit Sensor(ob_sensor_t *impl) : impl_(impl) {}
+
+    Sensor(Sensor &&sensor) noexcept : impl_(sensor.impl_) {
+        sensor.impl_ = nullptr;
+    }
+
+    Sensor &operator=(Sensor &&sensor) noexcept {
+        if(this != &sensor) {
+            ob_error *error = nullptr;
+            ob_delete_sensor(impl_, &error);
+            Error::handle(&error);
+            impl_        = sensor.impl_;
+            sensor.impl_ = nullptr;
+        }
+        return *this;
+    }
+
+    Sensor(const Sensor &sensor)            = delete;
+    Sensor &operator=(const Sensor &sensor) = delete;
+
+    virtual ~Sensor() noexcept {
+        ob_error *error = nullptr;
+        ob_delete_sensor(impl_, &error);
+        Error::handle(&error, false);
+    }
+
+    /**
+     * @brief Get the sensor type.
+     *
+     * @return OBSensorType The sensor type.
+     */
+    OBSensorType getType() const {
+        ob_error *error = nullptr;
+        auto      type  = ob_sensor_get_type(impl_, &error);
+        Error::handle(&error);
+        return type;
+    }
+
+    /**
+     * @brief Get the list of stream profiles.
+     *
+     * @return std::shared_ptr<StreamProfileList> The stream profile list.
+     */
+    std::shared_ptr<StreamProfileList> getStreamProfileList() const {
+        ob_error *error = nullptr;
+        auto      list  = ob_sensor_get_stream_profile_list(impl_, &error);
+        Error::handle(&error);
+        return std::make_shared<StreamProfileList>(list);
+    }
+
+    /**
+     * @brief Create a list of recommended filters for the sensor.
+     *
+     * @return OBFilterList list of frame processing block
+     */
+    std::vector<std::shared_ptr<Filter>> createRecommendedFilters() const {
+        ob_error *error = nullptr;
+        auto      list  = ob_sensor_create_recommended_filter_list(impl_, &error);
+        Error::handle(&error);
+        auto filter_count = ob_filter_list_get_count(list, &error);
+
+        std::vector<std::shared_ptr<Filter>> filters;
+        for(uint32_t i = 0; i < filter_count; i++) {
+            auto filterImpl = ob_filter_list_get_filter(list, i, &error);
+            Error::handle(&error);
+            filters.push_back(std::make_shared<Filter>(filterImpl));
+        }
+        ob_delete_filter_list(list, &error);
+        Error::handle(&error, false);
+        return filters;
+    }
+
+    /**
+     * @brief Open a frame data stream and set up a callback.
+     *
+     * @param streamProfile The stream configuration.
+     * @param callback The callback to set when frame data arrives.
+     */
+    void start(std::shared_ptr<StreamProfile> streamProfile, FrameCallback callback) {
+        ob_error *error = nullptr;
+        callback_       = std::move(callback);
+        ob_sensor_start(impl_, const_cast<ob_stream_profile_t *>(streamProfile->getImpl()), &Sensor::frameCallback, this, &error);
+        Error::handle(&error);
+    }
+
+    /**
+     * @brief Stop the stream.
+     */
+    void stop() const {
+        ob_error *error = nullptr;
+        ob_sensor_stop(impl_, &error);
+        Error::handle(&error);
+    }
+
+    /**
+     * @brief Dynamically switch resolutions.
+     *
+     * @param streamProfile The resolution to switch to.
+     */
+    void switchProfile(std::shared_ptr<StreamProfile> streamProfile) {
+        ob_error *error = nullptr;
+        ob_sensor_switch_profile(impl_, const_cast<ob_stream_profile_t *>(streamProfile->getImpl()), &error);
+        Error::handle(&error);
+    }
+
+private:
+    static void frameCallback(ob_frame *frame, void *userData) {
+        auto sensor = static_cast<Sensor *>(userData);
+        sensor->callback_(std::make_shared<Frame>(frame));
+    }
+
+public:
+    // The following interfaces are deprecated and are retained here for compatibility purposes.
+    OBSensorType type() const {
+        return getType();
+    }
+
+    std::vector<std::shared_ptr<Filter>> getRecommendedFilters() const {
+        return createRecommendedFilters();
+    }
+};
+
+class SensorList {
+private:
+    ob_sensor_list_t *impl_ = nullptr;
+
+public:
+    explicit SensorList(ob_sensor_list_t *impl) : impl_(impl) {}
+
+    ~SensorList() noexcept {
+        ob_error *error = nullptr;
+        ob_delete_sensor_list(impl_, &error);
+        Error::handle(&error, false);
+    }
+
+    /**
+     * @brief Get the number of sensors.
+     *
+     * @return uint32_t The number of sensors.
+     */
+    uint32_t getCount() const {
+        ob_error *error = nullptr;
+        auto      count = ob_sensor_list_get_count(impl_, &error);
+        Error::handle(&error);
+        return count;
+    }
+
+    /**
+     * @brief Get the type of the specified sensor.
+     *
+     * @param index The sensor index.
+     * @return OBSensorType The sensor type.
+     */
+    OBSensorType getSensorType(uint32_t index) const {
+        ob_error *error = nullptr;
+        auto      type  = ob_sensor_list_get_sensor_type(impl_, index, &error);
+        Error::handle(&error);
+        return type;
+    }
+
+    /**
+     * @brief Get a sensor by index number.
+     *
+     * @param index The sensor index. The range is [0, count-1]. If the index exceeds the range, an exception will be thrown.
+     * @return std::shared_ptr<Sensor> The sensor object.
+     */
+    std::shared_ptr<Sensor> getSensor(uint32_t index) const {
+        ob_error *error  = nullptr;
+        auto      sensor = ob_sensor_list_get_sensor(impl_, index, &error);
+        Error::handle(&error);
+        return std::make_shared<Sensor>(sensor);
+    }
+
+    /**
+     * @brief Get a sensor by sensor type.
+     *
+     * @param sensorType The sensor type to obtain.
+     * @return std::shared_ptr<Sensor> A sensor object. If the specified sensor type does not exist, it will return empty.
+     */
+    std::shared_ptr<Sensor> getSensor(OBSensorType sensorType) const {
+        ob_error *error  = nullptr;
+        auto      sensor = ob_sensor_list_get_sensor_by_type(impl_, sensorType, &error);
+        Error::handle(&error);
+        return std::make_shared<Sensor>(sensor);
+    }
+
+public:
+    // The following interfaces are deprecated and are retained here for compatibility purposes.
+    uint32_t count() const {
+        return getCount();
+    }
+
+    OBSensorType type(uint32_t index) const {
+        return getSensorType(index);
+    }
+};
+
+}  // namespace ob
+
diff --git a/include/libobsensor/hpp/StreamProfile.hpp b/include/libobsensor/hpp/StreamProfile.hpp
new file mode 100644
index 00000000..3c8a1142
--- /dev/null
+++ b/include/libobsensor/hpp/StreamProfile.hpp
@@ -0,0 +1,475 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+/**
+ * @file StreamProfile.hpp
+ * @brief The stream profile related type is used to get information such as the width, height, frame rate, and format of the stream.
+ */
+#pragma once
+
+#include "Types.hpp"
+#include "libobsensor/h/StreamProfile.h"
+#include "libobsensor/h/Error.h"
+#include <iostream>
+#include <memory>
+
+namespace ob {
+
+class StreamProfile : public std::enable_shared_from_this<StreamProfile> {
+protected:
+    const ob_stream_profile_t *impl_ = nullptr;
+
+public:
+    StreamProfile(StreamProfile &streamProfile)            = delete;
+    StreamProfile &operator=(StreamProfile &streamProfile) = delete;
+
+    StreamProfile(StreamProfile &&streamProfile) noexcept : impl_(streamProfile.impl_) {
+        streamProfile.impl_ = nullptr;
+    }
+
+    StreamProfile &operator=(StreamProfile &&streamProfile) noexcept {
+        if(this != &streamProfile) {
+            ob_error *error = nullptr;
+            ob_delete_stream_profile(impl_, &error);
+            Error::handle(&error);
+            impl_               = streamProfile.impl_;
+            streamProfile.impl_ = nullptr;
+        }
+        return *this;
+    }
+
+    virtual ~StreamProfile() noexcept {
+        if(impl_) {
+            ob_error *error = nullptr;
+            ob_delete_stream_profile(impl_, &error);
+            Error::handle(&error);
+        }
+    }
+
+    const ob_stream_profile *getImpl() const {
+        return impl_;
+    }
+
+    /**
+     * @brief Get the format of the stream
+     *
+     * @return OBFormat return the format of the stream
+     */
+    OBFormat getFormat() const {
+        ob_error *error  = nullptr;
+        auto      format = ob_stream_profile_get_format(impl_, &error);
+        Error::handle(&error);
+        return format;
+    }
+
+    /**
+     * @brief Get the type of stream
+     *
+     * @return OBStreamType return the type of the stream
+     */
+    OBStreamType getType() const {
+        ob_error *error = nullptr;
+        auto      type  = ob_stream_profile_get_type(impl_, &error);
+        Error::handle(&error);
+        return type;
+    }
+
+    /**
+     * @brief Get the extrinsic parameters from current stream profile to the given target stream profile
+     *
+     * @return OBExtrinsic Return the extrinsic parameters.
+     */
+    OBExtrinsic getExtrinsicTo(std::shared_ptr<StreamProfile> target) const {
+        ob_error *error     = nullptr;
+        auto      extrinsic = ob_stream_profile_get_extrinsic_to(impl_, const_cast<ob_stream_profile_t *>(target->getImpl()), &error);
+        Error::handle(&error);
+        return extrinsic;
+    }
+
+    /**
+     * @brief Check if frame object is compatible with the given type
+     *
+     * @tparam T  Given type
+     * @return bool return result
+     */
+    template <typename T> bool is() const;
+
+    /**
+     * @brief Converts object type to target type
+     *
+     * @tparam T Target type
+     * @return std::shared_ptr<T> Return the result. Throws an exception if conversion is not possible.
+     */
+    template <typename T> std::shared_ptr<T> as() {
+        if(!is<T>()) {
+            throw std::runtime_error("Unsupported operation. Object's type is not the required type.");
+        }
+
+        return std::dynamic_pointer_cast<T>(shared_from_this());
+    }
+
+    /**
+     * @brief Converts object type to target type (const version)
+     *
+     * @tparam T Target type
+     * @return std::shared_ptr<T> Return the result. Throws an exception if conversion is not possible.
+     */
+    template <typename T> std::shared_ptr<const T> as() const {
+        if(!is<T>()) {
+            throw std::runtime_error("Unsupported operation. Object's type is not the required type.");
+        }
+
+        return std::static_pointer_cast<const T>(shared_from_this());
+    }
+
+    // The following interfaces are deprecated and are retained here for compatibility purposes.
+    OBFormat format() const {
+        return getFormat();
+    }
+
+    OBStreamType type() const {
+        return getType();
+    }
+
+protected:
+    explicit StreamProfile(const ob_stream_profile_t *impl) : impl_(impl) {}
+};
+
+/**
+ * @brief Class representing a video stream profile.
+ */
+class VideoStreamProfile : public StreamProfile {
+public:
+    explicit VideoStreamProfile(const ob_stream_profile_t *impl) : StreamProfile(impl) {}
+
+    ~VideoStreamProfile() noexcept override = default;
+
+    /**
+     * @brief Return the frame rate of the stream.
+     *
+     * @return uint32_t Return the frame rate of the stream.
+     */
+    uint32_t getFps() const {
+        ob_error *error = nullptr;
+        auto      fps   = ob_video_stream_profile_get_fps(impl_, &error);
+        Error::handle(&error);
+        return fps;
+    }
+
+    /**
+     * @brief Return the width of the stream.
+     *
+     * @return uint32_t Return the width of the stream.
+     */
+    uint32_t getWidth() const {
+        ob_error *error = nullptr;
+        auto      width = ob_video_stream_profile_get_width(impl_, &error);
+        Error::handle(&error);
+        return width;
+    }
+
+    /**
+     * @brief Return the height of the stream.
+     *
+     * @return uint32_t Return the height of the stream.
+     */
+    uint32_t getHeight() const {
+        ob_error *error  = nullptr;
+        auto      height = ob_video_stream_profile_get_height(impl_, &error);
+        Error::handle(&error);
+        return height;
+    }
+
+    /**
+     * @brief Get the intrinsic parameters of the stream.
+     *
+     * @return OBCameraIntrinsic Return the intrinsic parameters.
+     */
+    OBCameraIntrinsic getIntrinsic() const {
+        ob_error *error     = nullptr;
+        auto      intrinsic = ob_video_stream_profile_get_intrinsic(impl_, &error);
+        Error::handle(&error);
+        return intrinsic;
+    }
+
+    /**
+     * @brief Get the distortion parameters of the stream.
+     * @brief Brown distortion model
+     *
+     * @return OBCameraDistortion Return the distortion parameters.
+     */
+    OBCameraDistortion getDistortion() const {
+        ob_error *error      = nullptr;
+        auto      distortion = ob_video_stream_profile_get_distortion(impl_, &error);
+        Error::handle(&error);
+        return distortion;
+    }
+
+public:
+    // The following interfaces are deprecated and are retained here for compatibility purposes.
+    uint32_t fps() const {
+        return getFps();
+    }
+
+    uint32_t width() const {
+        return getWidth();
+    }
+
+    uint32_t height() const {
+        return getHeight();
+    }
+};
+
+/**
+ * @brief Class representing an accelerometer stream profile.
+ */
+class AccelStreamProfile : public StreamProfile {
+public:
+    explicit AccelStreamProfile(const ob_stream_profile_t *impl) : StreamProfile(impl) {}
+
+    ~AccelStreamProfile() noexcept override = default;
+
+    /**
+     * @brief Return the full scale range.
+     *
+     * @return OBAccelFullScaleRange Return the scale range value.
+     */
+    OBAccelFullScaleRange getFullScaleRange() const {
+        ob_error *error          = nullptr;
+        auto      fullScaleRange = ob_accel_stream_profile_get_full_scale_range(impl_, &error);
+        Error::handle(&error);
+        return fullScaleRange;
+    }
+
+    /**
+     * @brief Return the sampling frequency.
+     *
+     * @return OBAccelFullScaleRange Return the sampling frequency.
+     */
+    OBAccelSampleRate getSampleRate() const {
+        ob_error *error      = nullptr;
+        auto      sampleRate = ob_accel_stream_profile_get_sample_rate(impl_, &error);
+        Error::handle(&error);
+        return sampleRate;
+    }
+
+    /**
+     * @brief get the intrinsic parameters of the stream.
+     *
+     * @return OBAccelIntrinsic Return the intrinsic parameters.
+     */
+    OBAccelIntrinsic getIntrinsic() const {
+        ob_error *error     = nullptr;
+        auto      intrinsic = ob_accel_stream_profile_get_intrinsic(impl_, &error);
+        Error::handle(&error);
+        return intrinsic;
+    }
+
+public:
+    // The following interfaces are deprecated and are retained here for compatibility purposes.
+    OBAccelFullScaleRange fullScaleRange() const {
+        return getFullScaleRange();
+    }
+
+    OBAccelSampleRate sampleRate() const {
+        return getSampleRate();
+    }
+};
+
+/**
+ * @brief Class representing a gyroscope stream profile.
+ */
+class GyroStreamProfile : public StreamProfile {
+public:
+    explicit GyroStreamProfile(const ob_stream_profile_t *impl) : StreamProfile(impl) {}
+
+    ~GyroStreamProfile() noexcept override = default;
+
+    /**
+     * @brief Return the full scale range.
+     *
+     * @return OBAccelFullScaleRange Return the scale range value.
+     */
+    OBGyroFullScaleRange getFullScaleRange() const {
+        ob_error *error          = nullptr;
+        auto      fullScaleRange = ob_gyro_stream_profile_get_full_scale_range(impl_, &error);
+        Error::handle(&error);
+        return fullScaleRange;
+    }
+
+    /**
+     * @brief Return the sampling frequency.
+     *
+     * @return OBAccelFullScaleRange Return the sampling frequency.
+     */
+    OBGyroSampleRate getSampleRate() const {
+        ob_error *error      = nullptr;
+        auto      sampleRate = ob_gyro_stream_profile_get_sample_rate(impl_, &error);
+        Error::handle(&error);
+        return sampleRate;
+    }
+
+    /**
+     * @brief get the intrinsic parameters of the stream.
+     *
+     * @return OBGyroIntrinsic Return the intrinsic parameters.
+     */
+    OBGyroIntrinsic getIntrinsic() const {
+        ob_error *error     = nullptr;
+        auto      intrinsic = ob_gyro_stream_get_intrinsic(impl_, &error);
+        Error::handle(&error);
+        return intrinsic;
+    }
+
+public:
+    // The following interfaces are deprecated and are retained here for compatibility purposes.
+    OBGyroFullScaleRange fullScaleRange() const {
+        return getFullScaleRange();
+    }
+
+    OBGyroSampleRate sampleRate() const {
+        return getSampleRate();
+    }
+};
+
+template <typename T> bool StreamProfile::is() const {
+    switch(this->getType()) {
+    case OB_STREAM_VIDEO:
+    case OB_STREAM_IR:
+    case OB_STREAM_IR_LEFT:
+    case OB_STREAM_IR_RIGHT:
+    case OB_STREAM_COLOR:
+    case OB_STREAM_DEPTH:
+    case OB_STREAM_RAW_PHASE:
+        return typeid(T) == typeid(VideoStreamProfile);
+    case OB_STREAM_ACCEL:
+        return typeid(T) == typeid(AccelStreamProfile);
+    case OB_STREAM_GYRO:
+        return typeid(T) == typeid(GyroStreamProfile);
+    default:
+        break;
+    }
+    return false;
+}
+
+class StreamProfileFactory {
+public:
+    static std::shared_ptr<StreamProfile> create(const ob_stream_profile_t *impl) {
+        ob_error  *error = nullptr;
+        const auto type  = ob_stream_profile_get_type(impl, &error);
+        Error::handle(&error);
+        switch(type) {
+        case OB_STREAM_IR:
+        case OB_STREAM_IR_LEFT:
+        case OB_STREAM_IR_RIGHT:
+        case OB_STREAM_DEPTH:
+        case OB_STREAM_COLOR:
+        case OB_STREAM_VIDEO:
+            return std::make_shared<VideoStreamProfile>(impl);
+        case OB_STREAM_ACCEL:
+            return std::make_shared<AccelStreamProfile>(impl);
+        case OB_STREAM_GYRO:
+            return std::make_shared<GyroStreamProfile>(impl);
+        default: {
+            ob_error *err = ob_create_error(OB_STATUS_ERROR, "Unsupported stream type.", "StreamProfileFactory::create", "", OB_EXCEPTION_TYPE_INVALID_VALUE);
+            Error::handle(&err);
+            return nullptr;
+        }
+        }
+    }
+};
+
+class StreamProfileList {
+protected:
+    const ob_stream_profile_list_t *impl_;
+
+public:
+    explicit StreamProfileList(ob_stream_profile_list_t *impl) : impl_(impl) {}
+    ~StreamProfileList() noexcept {
+        ob_error *error = nullptr;
+        ob_delete_stream_profile_list(impl_, &error);
+        Error::handle(&error, false);
+    }
+
+    /**
+     * @brief Return the number of StreamProfile objects.
+     *
+     * @return uint32_t Return the number of StreamProfile objects.
+     */
+    uint32_t getCount() const {
+        ob_error *error = nullptr;
+        auto      count = ob_stream_profile_list_get_count(impl_, &error);
+        Error::handle(&error);
+        return count;
+    }
+
+    /**
+     * @brief Return the StreamProfile object at the specified index.
+     *
+     * @param index The index of the StreamProfile object to be retrieved. Must be in the range [0, count-1]. Throws an exception if the index is out of range.
+     * @return std::shared_ptr<StreamProfile> Return the StreamProfile object.
+     */
+    std::shared_ptr<StreamProfile> getProfile(uint32_t index) const {
+        ob_error *error   = nullptr;
+        auto      profile = ob_stream_profile_list_get_profile(impl_, index, &error);
+        Error::handle(&error);
+        return StreamProfileFactory::create(profile);
+    }
+
+    /**
+     * @brief Match the corresponding video stream profile based on the passed-in parameters. If multiple Match are found, the first one in the list is
+     * returned by default. Throws an exception if no matching profile is found.
+     *
+     * @param width The width of the stream. Pass OB_WIDTH_ANY if no matching condition is required.
+     * @param height The height of the stream. Pass OB_HEIGHT_ANY if no matching condition is required.
+     * @param format The type of the stream. Pass OB_FORMAT_ANY if no matching condition is required.
+     * @param fps The frame rate of the stream. Pass OB_FPS_ANY if no matching condition is required.
+     * @return std::shared_ptr<VideoStreamProfile> Return the matching resolution.
+     */
+    std::shared_ptr<VideoStreamProfile> getVideoStreamProfile(int width = OB_WIDTH_ANY, int height = OB_HEIGHT_ANY, OBFormat format = OB_FORMAT_ANY,
+                                                              int fps = OB_FPS_ANY) const {
+        ob_error *error   = nullptr;
+        auto      profile = ob_stream_profile_list_get_video_stream_profile(impl_, width, height, format, fps, &error);
+        Error::handle(&error);
+        auto vsp = StreamProfileFactory::create(profile);
+        return vsp->as<VideoStreamProfile>();
+    }
+
+    /**
+     * @brief Match the corresponding accelerometer stream profile based on the passed-in parameters. If multiple Match are found, the first one in the list
+     * is returned by default. Throws an exception if no matching profile is found.
+     *
+     * @param fullScaleRange The full scale range. Pass 0 if no matching condition is required.
+     * @param sampleRate The sampling frequency. Pass 0 if no matching condition is required.
+     */
+    std::shared_ptr<AccelStreamProfile> getAccelStreamProfile(OBAccelFullScaleRange fullScaleRange, OBAccelSampleRate sampleRate) const {
+        ob_error *error   = nullptr;
+        auto      profile = ob_stream_profile_list_get_accel_stream_profile(impl_, fullScaleRange, sampleRate, &error);
+        Error::handle(&error);
+        auto asp = StreamProfileFactory::create(profile);
+        return asp->as<AccelStreamProfile>();
+    }
+
+    /**
+     * @brief Match the corresponding gyroscope stream profile based on the passed-in parameters. If multiple Match are found, the first one in the list is
+     * returned by default. Throws an exception if no matching profile is found.
+     *
+     * @param fullScaleRange The full scale range. Pass 0 if no matching condition is required.
+     * @param sampleRate The sampling frequency. Pass 0 if no matching condition is required.
+     */
+    std::shared_ptr<GyroStreamProfile> getGyroStreamProfile(OBGyroFullScaleRange fullScaleRange, OBGyroSampleRate sampleRate) const {
+        ob_error *error   = nullptr;
+        auto      profile = ob_stream_profile_list_get_gyro_stream_profile(impl_, fullScaleRange, sampleRate, &error);
+        Error::handle(&error);
+        auto gsp = StreamProfileFactory::create(profile);
+        return gsp->as<GyroStreamProfile>();
+    }
+
+public:
+    // The following interfaces are deprecated and are retained here for compatibility purposes.
+    uint32_t count() const {
+        return getCount();
+    }
+};
+
+}  // namespace ob
diff --git a/include/libobsensor/hpp/TypeHelper.hpp b/include/libobsensor/hpp/TypeHelper.hpp
new file mode 100644
index 00000000..71c63143
--- /dev/null
+++ b/include/libobsensor/hpp/TypeHelper.hpp
@@ -0,0 +1,143 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include <string>
+#include <iostream>
+#include "libobsensor/h/ObTypes.h"
+#include "libobsensor/h/TypeHelper.h"
+
+#include <functional>
+
+namespace ob {
+class TypeHelper {
+public:
+    /**
+     * @brief Convert OBFormat to " string " type and then return.
+     *
+     * @param[in] type OBFormat type.
+     * @return OBFormat of "string" type.
+     */
+    static std::string convertOBFormatTypeToString(const OBFormat &type) {
+        return ob_format_type_to_string(type);
+    }
+
+    /**
+     * @brief Convert OBFrameType to " string " type and then return.
+     *
+     * @param[in] type OBFrameType type.
+     * @return OBFrameType of "string" type.
+     */
+    static std::string convertOBFrameTypeToString(const OBFrameType &type) {
+        return ob_frame_type_to_string(type);
+    }
+
+    /**
+     * @brief Convert OBStreamType to " string " type and then return.
+     *
+     * @param[in] type OBStreamType type.
+     * @return OBStreamType of "string" type.
+     */
+    static std::string convertOBStreamTypeToString(const OBStreamType &type) {
+        return ob_stream_type_to_string(type);
+    }
+
+    /**
+     * @brief Convert OBSensorType to " string " type and then return.
+     *
+     * @param[in] type OBSensorType type.
+     * @return OBSensorType of "string" type.
+     */
+    static std::string convertOBSensorTypeToString(const OBSensorType &type) {
+        return ob_sensor_type_to_string(type);
+    }
+
+    /**
+     * @brief Convert OBIMUSampleRate to " string " type and then return.
+     *
+     * @param[in] type OBIMUSampleRate type.
+     * @return OBIMUSampleRate of "string" type.
+     */
+    static std::string convertOBIMUSampleRateTypeToString(const OBIMUSampleRate &type) {
+        return ob_imu_rate_type_to_string(type);
+    }
+
+    /**
+     * @brief Convert OBGyroFullScaleRange to " string " type and then return.
+     *
+     * @param[in] type OBGyroFullScaleRange type.
+     * @return OBGyroFullScaleRange of "string" type.
+     */
+    static std::string convertOBGyroFullScaleRangeTypeToString(const OBGyroFullScaleRange &type) {
+        return ob_gyro_range_type_to_string(type);
+    }
+
+    /**
+     * @brief Convert OBAccelFullScaleRange to " string " type and then return.
+     *
+     * @param[in] type OBAccelFullScaleRange type.
+     * @return OBAccelFullScaleRange of "string" type.
+     */
+    static std::string convertOBAccelFullScaleRangeTypeToString(const OBAccelFullScaleRange &type) {
+        return ob_accel_range_type_to_string(type);
+    }
+
+    /**
+     * @brief Convert OBFrameMetadataType to " string " type and then return.
+     *
+     * @param[in] type OBFrameMetadataType type.
+     * @return OBFrameMetadataType of "string" type.
+     */
+    static std::string convertOBFrameMetadataTypeToString(const OBFrameMetadataType &type) {
+        return ob_meta_data_type_to_string(type);
+    }
+
+    /**
+     * @brief Convert OBSensorType to OBStreamType type and then return.
+     *
+     * @param[in] type OBSensorType type.
+     * @return OBStreamType type.
+     */
+    static OBStreamType convertSensorTypeToStreamType(OBSensorType type) {
+        return ob_sensor_type_to_stream_type(type);
+    }
+
+    /**
+     * @brief Check if the given sensor type is a video sensor.
+     * @brief Video sensors are sensors that produce video frames.
+     * @brief The following sensor types are considered video sensors:
+     *      OB_SENSOR_COLOR,
+     *      OB_SENSOR_DEPTH,
+     *      OB_SENSOR_IR,
+     *      OB_SENSOR_IR_LEFT,
+     *      OB_SENSOR_IR_RIGHT,
+     *
+     * @param type
+     * @return true
+     * @return false
+     */
+    static bool isVideoSensorType(OBSensorType type) {
+        return ob_is_video_sensor_type(type);
+    }
+
+    /**
+     * @brief Check if the given stream type is a video stream.
+     * @brief Video streams are streams that contain video frames.
+     * @brief The following stream types are considered video streams:
+     *      OB_STREAM_VIDEO,
+     *      OB_STREAM_DEPTH,
+     *      OB_STREAM_COLOR,
+     *      OB_STREAM_IR，
+     *      OB_STREAM_IR_LEFT,
+     *      OB_STREAM_IR_RIGHT,
+     *
+     * @param type The stream type to check.
+     * @return true if the given stream type is a video stream, false otherwise.
+     */
+    static bool isVideoStreamType(OBStreamType type) {
+        return ob_is_video_stream_type(type);
+    }
+};
+}  // namespace ob
+
diff --git a/include/libobsensor/hpp/Types.hpp b/include/libobsensor/hpp/Types.hpp
new file mode 100644
index 00000000..d6d46a1f
--- /dev/null
+++ b/include/libobsensor/hpp/Types.hpp
@@ -0,0 +1,5 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+// empty file, leave here for backwards compatibility
diff --git a/include/libobsensor/hpp/Utils.hpp b/include/libobsensor/hpp/Utils.hpp
new file mode 100644
index 00000000..5b0add2e
--- /dev/null
+++ b/include/libobsensor/hpp/Utils.hpp
@@ -0,0 +1,167 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+/**
+ * @file Utils.hpp
+ * @brief The SDK utils class
+ *
+ */
+#pragma once
+#include "libobsensor/h/Utils.h"
+#include "Device.hpp"
+#include "Types.hpp"
+#include "Frame.hpp"
+
+#include <memory>
+
+namespace ob {
+class Device;
+
+class  CoordinateTransformHelper {
+public:
+    /**
+     * @brief Transform a 3d point of a source coordinate system into a 3d point of the target coordinate system.
+     *
+     * @param[in] source_point3f Source 3d point value
+     * @param[in] extrinsic Transformation matrix from source to target
+     * @param[out] target_point3f Target 3d point value
+     *
+     * @return bool Transform result
+     */
+    static bool transformation3dto3d(const OBPoint3f source_point3f, OBExtrinsic extrinsic, OBPoint3f *target_point3f) {
+        ob_error *error = NULL;
+        bool result =  ob_transformation_3d_to_3d(source_point3f, extrinsic, target_point3f, &error);
+        Error::handle(&error);
+        return result;
+    }
+
+    /**
+     * @brief Transform a 2d pixel coordinate with an associated depth value of the source camera into a 3d point of the target coordinate system.
+     *
+     * @param[in] source_intrinsic Source intrinsic parameters
+     * @param[in] source_point2f Source 2d point value
+     * @param[in] source_depth_pixel_value The depth of sourcePoint2f in millimeters
+     * @param[in] extrinsic Transformation matrix from source to target
+     * @param[out] target_point3f Target 3d point value
+     *
+     * @return bool Transform result
+     */
+    static bool transformation2dto3d(const OBPoint2f source_point2f, const float source_depth_pixel_value, const OBCameraIntrinsic source_intrinsic,
+                                     OBExtrinsic extrinsic, OBPoint3f *target_point3f) {
+        ob_error *error = NULL;
+        bool result = ob_transformation_2d_to_3d(source_point2f, source_depth_pixel_value, source_intrinsic, extrinsic, target_point3f, &error);
+        Error::handle(&error);
+        return result;
+    }
+
+    /**
+     * @brief Transform a 3d point of a source coordinate system into a 2d pixel coordinate of the target camera.
+     *
+     * @param[in] source_point3f Source 3d point value
+     * @param[in] target_intrinsic Target intrinsic parameters
+     * @param[in] target_distortion Target distortion parameters
+     * @param[in] extrinsic Transformation matrix from source to target
+     * @param[out] target_point2f Target 2d point value
+     *
+     * @return bool Transform result
+     */
+    static bool transformation3dto2d(const OBPoint3f source_point3f, const OBCameraIntrinsic target_intrinsic, const OBCameraDistortion target_distortion,
+                                            OBExtrinsic extrinsic, OBPoint2f *target_point2f) {
+        ob_error *error = NULL;
+        bool result = ob_transformation_3d_to_2d(source_point3f, target_intrinsic, target_distortion, extrinsic, target_point2f, &error);
+        Error::handle(&error);
+        return result;
+    }
+
+    /**
+     * @brief Transform a 2d pixel coordinate with an associated depth value of the source camera into a 2d pixel coordinate of the target camera
+     *
+     * @param[in] source_intrinsic Source intrinsic parameters
+     * @param[in] source_distortion Source distortion parameters
+     * @param[in] source_point2f Source 2d point value
+     * @param[in] source_depth_pixel_value The depth of sourcePoint2f in millimeters
+     * @param[in] target_intrinsic Target intrinsic parameters
+     * @param[in] target_distortion Target distortion parameters
+     * @param[in] extrinsic Transformation matrix from source to target
+     * @param[out] target_point2f Target 2d point value
+     *
+     * @return bool Transform result
+     */
+    static bool transformation2dto2d(const OBPoint2f source_point2f, const float source_depth_pixel_value, const OBCameraIntrinsic source_intrinsic,
+                                     const OBCameraDistortion source_distortion, const OBCameraIntrinsic target_intrinsic,
+                                     const OBCameraDistortion target_distortion, OBExtrinsic extrinsic, OBPoint2f *target_point2f) {
+        ob_error *error = NULL;
+        bool      result = ob_transformation_2d_to_2d(source_point2f, source_depth_pixel_value, source_intrinsic, source_distortion, target_intrinsic,
+                                                      target_distortion, extrinsic, target_point2f, &error);
+        Error::handle(&error);
+        return result;
+    }
+
+public:
+    // The following interfaces are deprecated and are retained here for compatibility purposes.
+    static bool calibration3dTo3d(const OBCalibrationParam calibrationParam, const OBPoint3f sourcePoint3f, const OBSensorType sourceSensorType,
+                                  const OBSensorType targetSensorType, OBPoint3f *targetPoint3f) {
+        ob_error *error = NULL;
+        bool result = ob_calibration_3d_to_3d(calibrationParam, sourcePoint3f, sourceSensorType, targetSensorType, targetPoint3f, &error);
+        Error::handle(&error);
+        return result;
+    }
+
+    static bool calibration2dTo3d(const OBCalibrationParam calibrationParam, const OBPoint2f sourcePoint2f, const float sourceDepthPixelValue,
+                                  const OBSensorType sourceSensorType, const OBSensorType targetSensorType, OBPoint3f *targetPoint3f) {
+        ob_error *error = NULL;
+        bool result = ob_calibration_2d_to_3d(calibrationParam, sourcePoint2f, sourceDepthPixelValue, sourceSensorType, targetSensorType, targetPoint3f, &error);
+        Error::handle(&error);
+        return result;
+    }
+
+    static bool calibration3dTo2d(const OBCalibrationParam calibrationParam, const OBPoint3f sourcePoint3f, const OBSensorType sourceSensorType,
+                                  const OBSensorType targetSensorType, OBPoint2f *targetPoint2f) {
+        ob_error *error = NULL;
+        bool result = ob_calibration_3d_to_2d(calibrationParam, sourcePoint3f, sourceSensorType, targetSensorType, targetPoint2f, &error);
+        Error::handle(&error);
+        return result;
+    }
+
+    static bool calibration2dTo2d(const OBCalibrationParam calibrationParam, const OBPoint2f sourcePoint2f, const float sourceDepthPixelValue,
+                                  const OBSensorType sourceSensorType, const OBSensorType targetSensorType, OBPoint2f *targetPoint2f) {
+        ob_error *error = NULL;
+        bool result = ob_calibration_2d_to_2d(calibrationParam, sourcePoint2f, sourceDepthPixelValue, sourceSensorType, targetSensorType, targetPoint2f, &error);
+        Error::handle(&error);
+        return result;
+    }
+
+    static std::shared_ptr<ob::Frame> transformationDepthFrameToColorCamera(std::shared_ptr<ob::Device> device, std::shared_ptr<ob::Frame> depthFrame,
+                                                                            uint32_t targetColorCameraWidth, uint32_t targetColorCameraHeight) {
+        ob_error *error = NULL;
+
+        // unsafe operation, need to cast const to non-const
+        auto unConstImpl = const_cast<ob_frame *>(depthFrame->getImpl());
+
+        auto result = transformation_depth_frame_to_color_camera(device->getImpl() , unConstImpl, targetColorCameraWidth, targetColorCameraHeight, &error);
+        Error::handle(&error);
+        return std::make_shared<ob::Frame>(result);
+    }
+
+    static bool transformationInitXYTables(const OBCalibrationParam calibrationParam, const OBSensorType sensorType, float *data, uint32_t *dataSize,
+                                           OBXYTables *xyTables) {
+        ob_error *error = NULL;
+        bool result = transformation_init_xy_tables(calibrationParam, sensorType, data, dataSize, xyTables, &error);
+        Error::handle(&error);
+        return result;
+    }
+
+    static void transformationDepthToPointCloud(OBXYTables *xyTables, const void *depthImageData, void *pointCloudData) {
+        ob_error *error = NULL;
+        transformation_depth_to_pointcloud(xyTables, depthImageData, pointCloudData, &error);
+        Error::handle(&error, false);
+    }
+
+    static void transformationDepthToRGBDPointCloud(OBXYTables *xyTables, const void *depthImageData, const void *colorImageData, void *pointCloudData){
+        ob_error *error = NULL;
+        transformation_depth_to_rgbd_pointcloud(xyTables, depthImageData, colorImageData, pointCloudData, &error);
+        Error::handle(&error, false);
+    }
+};
+}  // namespace ob
+
diff --git a/include/libobsensor/hpp/Version.hpp b/include/libobsensor/hpp/Version.hpp
new file mode 100644
index 00000000..21b52469
--- /dev/null
+++ b/include/libobsensor/hpp/Version.hpp
@@ -0,0 +1,62 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+/**
+ * @file Version.hpp
+ * @brief Provides functions to retrieve version information of the SDK.
+ */
+#pragma once
+
+#include "libobsensor/h/Version.h"
+
+namespace ob {
+class Version {
+public:
+    /**
+     * @brief Get the full version number of the SDK.
+     * @brief The full version number equals to: major * 10000 + minor * 100 + patch
+     *
+     * @return int The full version number of the SDK.
+     */
+    static int getVersion() {
+        return ob_get_version();
+    }
+    /**
+     * @brief Get the major version number of the SDK.
+     *
+     * @return int The major version number of the SDK.
+     */
+    static int getMajor() {
+        return ob_get_major_version();
+    }
+
+    /**
+     * @brief Get the minor version number of the SDK.
+     *
+     * @return int The minor version number of the SDK.
+     */
+    static int getMinor() {
+        return ob_get_minor_version();
+    }
+
+    /**
+     * @brief Get the patch version number of the SDK.
+     *
+     * @return int The patch version number of the SDK.
+     */
+    static int getPatch() {
+        return ob_get_patch_version();
+    }
+
+    /**
+     * @brief Get the stage version of the SDK.
+     * @brief The stage version string is a vendor defined string for some special releases.
+     *
+     * @return char* The stage version string of the SDK.
+     */
+    static const char *getStageVersion() {
+        return ob_get_stage_version();
+    }
+};
+}  // namespace ob
+
diff --git a/scripts/.gitignore b/scripts/.gitignore
new file mode 100644
index 00000000..121a64f4
--- /dev/null
+++ b/scripts/.gitignore
@@ -0,0 +1,2 @@
+# unset ignore for current directory
+!scripts/build
\ No newline at end of file
diff --git a/scripts/CMakeLists.txt b/scripts/CMakeLists.txt
new file mode 100644
index 00000000..6c5b18c7
--- /dev/null
+++ b/scripts/CMakeLists.txt
@@ -0,0 +1,15 @@
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+cmake_minimum_required(VERSION 3.5)
+
+if(OB_IS_MAIN_PROJECT)
+    if(UNIX)
+        install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/env_setup/99-obsensor-libusb.rules DESTINATION shared)
+        install(PROGRAMS ${CMAKE_CURRENT_SOURCE_DIR}/env_setup/install_udev_rules.sh DESTINATION shared)
+        install(PROGRAMS ${CMAKE_CURRENT_SOURCE_DIR}/env_setup/setup.sh DESTINATION ./)
+    elseif(WIN32)
+        install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/env_setup/obsensor_metadata_win10.md DESTINATION shared)
+        install(PROGRAMS ${CMAKE_CURRENT_SOURCE_DIR}/env_setup/obsensor_metadata_win10.ps1 DESTINATION shared)
+    endif()
+endif()
diff --git a/scripts/build/build_linux_docker.sh b/scripts/build/build_linux_docker.sh
new file mode 100755
index 00000000..1cc7b978
--- /dev/null
+++ b/scripts/build/build_linux_docker.sh
@@ -0,0 +1,77 @@
+#!/bin/bash
+
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+CURRNET_DIR=$(pwd)
+
+SCRIPT_DIR=$(dirname "$0")
+cd $SCRIPT_DIR/../../
+
+PROJECT_ROOT=$(pwd)
+cd $PROJECT_ROOT
+
+FOLDER_NAME=$(basename "$PROJECT_ROOT")
+
+# get arch from arg
+ARCH=$1
+
+if [ "$ARCH" == "" ]; then
+    ARCH=$(uname -m)
+fi
+
+if [ "$ARCH" != "x86_64" ] && [ "$ARCH" != "aarch64" ] && [ "$ARCH" != "arm64" ]  && [ "$ARCH" != "arm" ]; then
+    echo "Invalid architecture: $ARCH, supported architectures are x86_64, aarch64, and arm"
+    exit 1
+fi
+
+platform="linux/$ARCH"
+if [ "$ARCH" == "x86_64" ]; then
+    platform="linux/amd64"
+elif [ "$ARCH" == "aarch64" ]; then
+    platform="linux/arm64"
+fi
+
+echo "Building openorbbecsdk for linux $ARCH via docker"
+
+
+# check if cross compiling
+if [ "$ARCH" != $(uname -m) ]; then
+    echo "Cross compiling, using docker buildx to build $ARCH image"
+
+    # if docker buildx is not installed, install it
+    if [ "$(docker buildx ls | grep default)" == "" ]; then
+        echo "Installing docker buildx"
+        docker buildx install
+    fi
+
+    # if docker buildx plarform does not exist, create it
+    if [ "$(docker buildx ls | grep $platform)" == "" ]; then
+        echo "Creating docker buildx platform $platform"
+        docker run --privileged --rm tonistiigi/binfmt --install all
+    fi
+fi
+
+# build docker image
+cd $PROJECT_ROOT/scripts/docker
+docker buildx build --platform $platform -t openorbbecsdk-env.$ARCH -f $PROJECT_ROOT/scripts/docker/$ARCH.dockerfile . --load || {
+    echo "Failed to build docker image openorbbecsdk-env.$ARCH"
+    exit 1
+}
+cd $CURRNET_DIR
+
+USER_ID=$(id -u)
+GROUP_ID=$(id -g)
+
+# run docker container and build openorbbecsdk
+docker run --rm -u $USER_ID:$GROUP_ID \
+    -v $PROJECT_ROOT/../:/workspace \
+    -w /workspace/$FOLDER_NAME \
+    --name OpenOrbbecSDK_Build_Liunx_$ARCH \
+    -it \
+    --entrypoint /bin/bash \
+    openorbbecsdk-env.$ARCH \
+    -c "cd /workspace/$FOLDER_NAME && bash ./scripts/build/build_linux_macos.sh"
+
+echo "Done building openorbbecsdk for linux $ARCH via docker"
+
diff --git a/scripts/build/build_linux_macos.sh b/scripts/build/build_linux_macos.sh
new file mode 100755
index 00000000..dbf91b3a
--- /dev/null
+++ b/scripts/build/build_linux_macos.sh
@@ -0,0 +1,67 @@
+#!/usr/bin/env bash
+
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+CURRNET_DIR=$(pwd)
+
+SCRIPT_DIR=$(dirname "$0")
+cd $SCRIPT_DIR/../../
+
+PROJECT_ROOT=$(pwd)
+
+# Define the platform
+system=$(uname -o)
+if [ "$system" = "Darwin" ]; then
+    system=macos
+else
+    system=linux
+fi
+
+arch=$(uname -m)
+if [ "$ARCH" = "aarch64" ]; then
+    PLATFORM=${system}_arm64
+elif [ "$ARCH" = "armv7l" ]; then
+    PLATFORM=${system}_arm32
+else
+    PLATFORM=${system}_$arch
+fi
+
+echo "Building OrbbecSDK for $PLATFORM"
+
+# Variables for version and timestamp
+if [ "$system" = "macos" ]; then
+    VERSION=$(grep -o "project(\w* VERSION [0-9]*\.[0-9]*\.[0-9]*" $PROJECT_ROOT/CMakeLists.txt | grep -o "[0-9]*\.[0-9]*\.[0-9]*")
+else
+    VERSION=$(grep -oP 'project\(\w+\s+VERSION\s+\d+\.\d+\.\d+' $PROJECT_ROOT/CMakeLists.txt | grep -oP '\d+\.\d+\.\d+')
+fi
+
+TIMESTAMP=$(date +"%Y%m%d%H%M")
+
+
+COMMIT_HASH=$(git rev-parse --short HEAD)
+PACKAGE_NAME="OrbbecSDK_v${VERSION}_${TIMESTAMP}_${COMMIT_HASH}_${PLATFORM}"
+
+# Create build directory
+rm -rf build_$PLATFORM
+mkdir -p build_$PLATFORM
+cd build_$PLATFORM || exit
+
+# Create target directory for installation
+INSTALL_DIR=$(pwd)/install/$PACKAGE_NAME
+mkdir -p $INSTALL_DIR
+
+# Build and install OrbbecSDK
+cmake .. -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=$INSTALL_DIR -DOB_BUILD_EXAMPLES=OFF || { echo 'Failed to run cmake'; exit 1; }
+make install -j8 || { echo 'Failed to build OrbbecSDK'; exit 1; }
+
+# Compress the installation directory
+cd $INSTALL_DIR
+cd ..
+zip -rpy ${PACKAGE_NAME}.zip ${PACKAGE_NAME} || { echo 'Failed to compress installation directory'; exit 1; }
+
+echo "Done building and compressing OrbbecSDK for $PLATFORM"
+echo "Done building OrbbecSDK for $PLATFORM"
+
+cd $CURRNET_DIR
+
diff --git a/scripts/build/build_win_msvc.ps1 b/scripts/build/build_win_msvc.ps1
new file mode 100644
index 00000000..ee85276c
--- /dev/null
+++ b/scripts/build/build_win_msvc.ps1
@@ -0,0 +1,148 @@
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+# Get current directory for return here later
+$current_dir = Get-Location
+
+# Set platform
+$platform = "x64"
+$targetArch = "x64"
+$fullPlatform = "win_x64"
+
+if ($args.Length -eq 1) {
+    if ($args[0] -eq "x64") {
+        $platform = "x64"
+        $fullPlatform = "win_x64"
+        $targetArch = "x64"
+    }
+    elseif ($args[0] -eq "x86") {
+        $platform = "Win32"
+        $fullPlatform = "win_x86"
+        $targetArch = "x86"
+    }
+    else {
+        Write-Output "Invalid argument, please use x64 or x86"
+        exit 1
+    }
+}
+
+$SCRIPT_DIR = Split-Path -Path $MyInvocation.MyCommand.Definition -Parent
+$PROJECT_ROOT = "$SCRIPT_DIR/../../"
+Set-Location $PROJECT_ROOT
+
+Write-Output  "Building OrbbecSDK for ${fullPlatform}"
+
+# Variables for version from CMakeLists.txt project
+$verPattern = 'project\(.*?VERSION\s+([0-9]+(?:\.[0-9]+)+)\s'
+$content = Get-Content -Path $PROJECT_ROOT\CMakeLists.txt -Raw
+$match = [regex]::Match($content, $verPattern)
+$version = $match.Groups[1].Value
+$timestamp = Get-Date -Format "yyyyMMddHHmm"
+$git_hash = $(git rev-parse --short HEAD)
+$package_name = "OrbbecSDK_v${version}_${timestamp}_${git_hash}_${fullPlatform}"
+
+# check visual studio 2017 or 2019 or 2022 is installed
+$vswhere = "${env:ProgramFiles(x86)}\Microsoft Visual Studio\Installer\vswhere.exe"
+$vsversion = & $vswhere -version "[15.0,)" -property installationVersion
+if ($vsversion.Length -eq 0) {
+    Write-Output  "Visual Studio 2017 or 2019 or 2022 is not installed"
+    exit 1
+}
+$vsversion = ($vsversion | Select-object -First 1).ToString().Trim()
+$vsversion = $vsversion.Substring(0, 2)
+$year = ""
+switch($vsversion){
+  15 {$year = "2017"}
+  16 {$year = "2019"}
+  17 {$year = "2022"}
+  default {
+      Write-Output "Unknown Visual Studio version: $vsversion"
+      exit 1
+ }
+}
+$cmake_generator = "Visual Studio ${vsversion} ${year}"
+Write-Output  "Using $cmake_generator as cmake generator"
+
+# create build directory
+if (Test-Path build_win_x64) {
+    Remove-Item -Recurse -Force build_win_x64
+}
+mkdir build_win_x64
+Set-Location build_win_x64
+
+# create install directory
+$install_dir = Join-Path (Get-Location).Path "install\${package_name}"
+mkdir $install_dir
+mkdir $install_dir/bin
+
+# copy opencv dll to install bin directory (here we use opencv 3.4.0 vc15 build)
+$opencvPath = [System.Environment]::GetEnvironmentVariable("OpenCV_DIR")
+if (-not $opencvPath) {
+    Write-Output "OpenCV path not found in environment variables."
+}
+
+$opencvPath = "$opencvPath\x64"
+# get all available opencv vc version
+$availableVersions = Get-ChildItem -Directory $opencvPath  | Sort-Object Name -Descending
+
+# initialize
+$selectedVersion = $null
+$exactMatch = $false
+
+# matching vc&vs version
+foreach ($version in $availableVersions) {
+    $versionNumber = [int]($version.Name -replace "vc", "")
+
+    # Find the correct version and stop searching
+    if ($versionNumber -eq $vsversion) {
+        $selectedVersion = $version.Name
+        $exactMatch = $true
+        break
+    } elseif ($versionNumber -lt $vsversion) {
+        # If the correct version is not found, select the next available smaller version
+        $selectedVersion = $version.Name
+        break
+    } elseif (-not $selectedVersion) {
+        # If the correct version is not found, select the next larger version available
+        $selectedVersion = $version.Name
+    }
+}
+
+# Check whether the correct version is found
+if (-not $selectedVersion) {
+    Write-Output "No compatible OpenCV version found for Visual Studio $cmake_generator"
+    exit 1
+} else {
+    Write-Output "Using OpenCV version: $selectedVersion"
+
+    # No correct version found. Issue a warning
+    if (-not $exactMatch) {
+        Write-Warning "Warning: Selected OpenCV version ($selectedVersion) may not be fully compatible with Visual Studio toolset $cmake_generator. Proceed with caution."
+    }
+}
+
+$opencvPath = "$opencvPath/${selectedVersion}"
+$opencvDll = Get-ChildItem -Path $opencvPath -Filter "opencv_world*.dll" -Recurse
+$opencv_path = $opencvDll.FullName
+if (-not (Test-Path $opencv_path)) {
+    Write-Output  "OpenCV dll not found at $opencv_path, please change the opecv dll path in build_win_msvc.ps1"
+    exit 1
+}
+Copy-Item $opencv_path $install_dir/bin/
+
+# build and install
+cmake -G "$cmake_generator" -A "$platform" -T "v141,host=${targetArch}" -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX="${install_dir}" ..
+cmake --build . --config Release --target install
+
+# create zip file
+$zip_file = "${package_name}.zip"
+$zip_file_path = Join-Path (Get-Location).Path "install\${zip_file}"
+Add-Type -assembly "system.io.compression.filesystem"
+[io.compression.zipfile]::CreateFromDirectory("${install_dir}", "${zip_file_path}")
+Write-Output  "Package zip file created at ${zip_file_path}"
+
+
+Write-Output  "OrbbecSDK for ${fullPlatform} build and install completed"
+
+# return to current_dir
+Set-Location  $current_dir
diff --git a/scripts/cicd/.gitkeep b/scripts/cicd/.gitkeep
new file mode 100644
index 00000000..e69de29b
diff --git a/scripts/docker/10_nvidia.json b/scripts/docker/10_nvidia.json
new file mode 100755
index 00000000..4b367532
--- /dev/null
+++ b/scripts/docker/10_nvidia.json
@@ -0,0 +1,6 @@
+{
+  "file_format_version": "1.0.0",
+  "ICD": {
+    "library_path": "libEGL_nvidia.so.0"
+  }
+}
diff --git a/scripts/docker/README.md b/scripts/docker/README.md
new file mode 100644
index 00000000..d98c7b6a
--- /dev/null
+++ b/scripts/docker/README.md
@@ -0,0 +1,146 @@
+# OrbbecSDK Docker Environment Setup
+
+## Installing Docker
+
+### For Overseas Users:
+
+Refer to the [official Docker documentation](https://docs.docker.com/engine/install/ubuntu/).
+
+### For Users in China:
+
+Refer to the [Tsinghua University Open Source Software Mirror](https://mirrors.tuna.tsinghua.edu.cn/help/docker-ce/).
+
+### Uninstall Previous Docker Installations:
+
+If you have previously installed Docker, remove it first:
+
+```bash
+sudo apt-get remove docker docker-engine docker.io containerd runc
+```
+
+### Install Dependencies:
+
+```bash
+sudo apt-get install apt-transport-https ca-certificates curl gnupg2 software-properties-common
+```
+
+### Trust Docker’s GPG Key:
+
+```bash
+curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
+```
+
+### Add Docker Repository:
+
+```bash
+echo \
+  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://mirrors.tuna.tsinghua.edu.cn/docker-ce/linux/ubuntu \
+  $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
+```
+
+### Install Docker:
+
+```bash
+sudo apt-get update
+sudo apt-get install docker-ce
+```
+
+### Add Current User to Docker Group:
+
+To avoid using `sudo` for Docker commands, add your user to the Docker group:
+
+```bash
+sudo groupadd docker
+sudo usermod -aG docker $USER
+```
+
+You will need to log out or reboot for this to take effect.
+
+## Installing NVIDIA Docker
+
+Refer to
+the [official NVIDIA documentation](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/install-guide.html#docker).
+
+## Getting Started
+
+### Install ADE CLI
+
+Go to the [ADE CLI releases page](https://gitlab.com/ApexAI/ade-cli/-/releases) and download the latest version for your
+system.
+
+```bash
+mv ade+x86_64 ade
+# or mv ade+aarch64 ade
+chmod +x ade
+sudo mv ade /usr/local/bin
+```
+
+### Shell Completion
+
+Add the following code to your `.zshrc` or `.bashrc`:
+
+```bash
+if [ -n "$ZSH_VERSION" ]; then
+    eval "$(_ADE_COMPLETE=source_zsh ade)"
+else
+    eval "$(_ADE_COMPLETE=source ade)"
+fi
+```
+
+### Build Docker
+
+```bash
+./build_docker.sh
+```
+
+### Usage
+
+#### Choose Directory to Mount (e.g., `~/ws`):
+
+```bash
+cd ~/ws
+touch .adehome
+```
+
+This indicates that Docker will mount `~/ws` as the container's home directory. You can also mount other directories.
+
+#### Set Up `.aderc`:
+
+```bash
+cd ~/ws
+touch .aderc
+```
+
+Add the following to `.aderc`:
+
+```bash
+export ADE_DOCKER_RUN_ARGS="--cap-add=SYS_PTRACE \
+ --privileged \
+ --net=host \
+ --add-host ade:127.0.0.1 \
+ -v ${HOME}/.Xauthority:${HOME}/.Xauthority:ro \
+ -e XAUTHORITY=${HOME}/.Xauthority \
+ -v /dev:/dev \
+"
+
+export ADE_IMAGES=" \
+ orbbecsdk-env:x86_64_20240711 \
+"
+```
+
+#### Start Container:
+
+Navigate to the directory containing `.aderc`:
+
+```bash
+ade start
+ade enter
+```
+
+You should now be inside the Docker container.
+
+### References
+
+1. [Docker Documentation](https://docs.docker.com/engine/install/ubuntu/)
+2. [NVIDIA Container Toolkit Installation Guide](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/latest/install-guide.html)
+3. [ADE CLI Documentation](https://ade-cli.readthedocs.io/en/latest/)
diff --git a/scripts/docker/aarch64.dockerfile b/scripts/docker/aarch64.dockerfile
new file mode 100755
index 00000000..ba197eb4
--- /dev/null
+++ b/scripts/docker/aarch64.dockerfile
@@ -0,0 +1,54 @@
+# Copyright (c)  Orbbec Inc. All Rights Reserved. 
+# Licensed under the MIT License.
+
+FROM nvcr.io/nvidia/l4t-base:r32.7.1
+
+# Replace default repositories with Aliyun mirrors
+RUN sed -i 's|http://ports.ubuntu.com/ubuntu-ports|http://mirrors.aliyun.com/ubuntu-ports|g' /etc/apt/sources.list
+
+ENV TERM=xterm
+ENV DEBIAN_FRONTEND=noninteractive
+ENV APT_KEY_DONT_WARN_ON_DANGEROUS_USAGE=DontWarn
+ARG NVIDIA_VISIBLE_DEVICES=all
+ARG NVIDIA_DRIVER_CAPABILITIES=compute,utility
+
+
+# Builder dependencies installation
+RUN apt-get update -o Acquire::http::proxy=false -o Acquire::https::proxy=false \
+    && apt-get install -qq -y --no-install-recommends -o Acquire::http::proxy=false -o Acquire::https::proxy=false \
+    sudo \
+    build-essential \
+    git \
+    openssl \
+    libssl-dev \
+    libusb-1.0-0-dev \
+    pkg-config \
+    libgtk-3-dev \
+    libglfw3-dev \
+    libgl1-mesa-dev \
+    libglu1-mesa-dev \
+    freeglut3-dev \
+    libnuma1 \
+    curl \
+    python3 \
+    python3-dev \
+    ca-certificates \
+    zip \
+    tzdata \
+    && rm -rf /var/lib/apt/lists/*
+
+# Install CMake 3.30.0
+RUN curl -L https://github.com/Kitware/CMake/releases/download/v3.30.0/cmake-3.30.0-linux-aarch64.tar.gz -o cmake.tar.gz \
+    && tar -xzf cmake.tar.gz --strip-components=1 -C /usr/local \
+    && rm cmake.tar.gz
+
+ADD 10_nvidia.json /etc/glvnd/egl_vendor.d/10_nvidia.json
+RUN chmod 644 /etc/glvnd/egl_vendor.d/10_nvidia.json
+ADD nvidia_icd.json /etc/vulkan/icd.d/nvidia_icd.json
+RUN chmod 644 /etc/vulkan/icd.d/nvidia_icd.json
+ENV NVIDIA_VISIBLE_DEVICES=${NVIDIA_VISIBLE_DEVICES:-all}
+ENV NVIDIA_DRIVER_CAPABILITIES=${NVIDIA_DRIVER_CAPABILITIES:+$NVIDIA_DRIVER_CAPABILITIES,}graphics
+COPY env.sh /etc/profile.d/ade_env.sh
+COPY entrypoint.sh /ade_entrypoint
+ENTRYPOINT ["/ade_entrypoint"]
+CMD ["/bin/bash", "-c", "trap 'exit 147' TERM; tail -f /dev/null & while wait ${!}; test $? -ge 128; do true; done"]
diff --git a/scripts/docker/build_docker.sh b/scripts/docker/build_docker.sh
new file mode 100755
index 00000000..bf40b591
--- /dev/null
+++ b/scripts/docker/build_docker.sh
@@ -0,0 +1,46 @@
+#!/usr/bin/env bash
+
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+# Prompt the user to select architecture
+echo "Please select the architecture:"
+echo "1) x86_64"
+echo "2) aarch64"
+read -p "Enter your choice (1 or 2): " choice
+
+# Set the ARCH variable based on user input
+case $choice in
+    1)
+        ARCH="x86_64"
+        ;;
+    2)
+        ARCH="aarch64"
+        ;;
+    *)
+        echo "Invalid choice"
+        exit 1
+        ;;
+esac
+
+# Set the DATE variable
+DATE=$(date +'%Y%m%d')
+
+# Build the Docker image
+docker build \
+    -f ${ARCH}.dockerfile . -t openorbbecsdk-env:${ARCH}_${DATE} \
+    --label ade_image_commit_sha="$(git rev-parse HEAD)" \
+    --label ade_image_commit_tag="$(date +'%Y%m%d.%H%M%S')"
+
+# Check for dangling images and remove them if present
+dangling_images=$(docker images -f "dangling=true" -q)
+if [ -n "$dangling_images" ]; then
+    docker rmi -f $dangling_images
+fi
+
+if [ $? -eq 0 ]; then
+    echo "Docker image built successfully"
+else
+    echo "Docker image build failed"
+fi
+
diff --git a/scripts/docker/entrypoint.sh b/scripts/docker/entrypoint.sh
new file mode 100755
index 00000000..fe16393f
--- /dev/null
+++ b/scripts/docker/entrypoint.sh
@@ -0,0 +1,80 @@
+#!/usr/bin/env bash
+
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+set -e
+
+if [[ -n "$GITLAB_CI" ]]; then
+    exec "$@"
+fi
+
+if [[ -n "$DEBUG" ]]; then
+    set -x
+fi
+
+if [[ -n "$TIMEZONE" ]]; then
+    echo "$TIMEZONE" >/etc/timezone
+    ln -sf /usr/share/zoneinfo/"$TIMEZONE" /etc/localtime
+    dpkg-reconfigure -f noninteractive tzdata
+fi
+
+# Check if the group already exists
+if getent group "$GROUP" >/dev/null 2>&1; then
+    echo "Group $GROUP exists, skipping group creation..."
+else
+    groupadd -og "$GROUP_ID" "$GROUP"
+fi
+
+# Check if the user already exists
+if getent passwd "$USER" >/dev/null 2>&1; then
+    echo "User $USER exists, skipping user creation..."
+else
+    # Check if UID 1000 is occupied, if so, delete the user
+    if getent passwd 1000 >/dev/null 2>&1; then
+        username=$(getent passwd 1000 | cut -d: -f1)
+        userdel -r $username
+    fi
+
+    # Find an available UID starting from USER_ID
+    while getent passwd "$USER_ID" >/dev/null 2>&1; do
+        USER_ID=$((USER_ID + 1))
+    done
+
+    useradd -M -u "$USER_ID" -g "$GROUP_ID" -d "/home/$USER" -s /bin/bash "$USER"
+fi
+
+# Check if the video group already exists
+if getent group video >/dev/null 2>&1; then
+    echo "Group video exists, skipping video group creation..."
+else
+    groupadd -og "$VIDEO_GROUP_ID" video
+fi
+
+gpasswd -a "$USER" video
+usermod -aG sudo "$USER"
+echo "$USER:0" | chpasswd
+
+shopt -s dotglob
+for x in /etc/skel/*; do
+    target="/home/$USER/$(basename "$x")"
+    if [[ ! -e "$target" ]]; then
+        cp -a "$x" "$target"
+        chown -R "$USER":"$GROUP" "$target"
+    fi
+done
+shopt -u dotglob
+
+if [[ -z "$SKIP_ADEINIT" ]]; then
+    for x in /opt/*; do
+        if [[ -x "$x/.adeinit" ]]; then
+            echo "Initializing $x"
+            sudo -Hu "$USER" -- bash -lc "$x/.adeinit"
+            echo "Initializing $x done"
+        fi
+    done
+fi
+
+echo 'ADE startup completed.'
+exec "$@"
+
diff --git a/scripts/docker/env.sh b/scripts/docker/env.sh
new file mode 100755
index 00000000..1d1a0430
--- /dev/null
+++ b/scripts/docker/env.sh
@@ -0,0 +1,13 @@
+#!/usr/bin/env bash
+
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+# Load environment variables from all .env.sh files in /opt
+for x in /opt/*; do
+    if [[ -e "$x/.env.sh" ]]; then
+	source "$x/.env.sh"
+    fi
+done
+## go home
+cd $HOME
diff --git a/scripts/docker/nvidia_icd.json b/scripts/docker/nvidia_icd.json
new file mode 100755
index 00000000..f3cebd9a
--- /dev/null
+++ b/scripts/docker/nvidia_icd.json
@@ -0,0 +1,7 @@
+{
+  "file_format_version" : "1.0.0",
+  "ICD": {
+    "library_path": "libGLX_nvidia.so.0",
+    "api_version" : "1.1.99"
+  }
+}
diff --git a/scripts/docker/x86_64.dockerfile b/scripts/docker/x86_64.dockerfile
new file mode 100755
index 00000000..0bcbceb5
--- /dev/null
+++ b/scripts/docker/x86_64.dockerfile
@@ -0,0 +1,54 @@
+# Copyright (c)  Orbbec Inc. All Rights Reserved. 
+# Licensed under the MIT License.
+
+FROM ubuntu:18.04
+
+RUN sed -i 's|http://archive.ubuntu.com/ubuntu|http://mirrors.aliyun.com/ubuntu|g' /etc/apt/sources.list
+
+ARG NVIDIA_VISIBLE_DEVICES=all
+ARG NVIDIA_DRIVER_CAPABILITIES=compute,utility
+ENV TERM=xterm
+ENV DEBIAN_FRONTEND=noninteractive
+ENV APT_KEY_DONT_WARN_ON_DANGEROUS_USAGE=DontWarn
+
+# Builder dependencies installation
+RUN apt-get update -o Acquire::http::proxy=false -o Acquire::https::proxy=false \
+    && apt-get install -qq -y --no-install-recommends -o Acquire::http::proxy=false -o Acquire::https::proxy=false \
+    sudo \
+    build-essential \
+    git \
+    openssl \
+    libssl-dev \
+    libusb-1.0-0-dev \
+    pkg-config \
+    libgtk-3-dev \
+    libglfw3-dev \
+    libgl1-mesa-dev \
+    libglu1-mesa-dev \
+    freeglut3-dev \
+    libnuma1 \
+    curl \
+    python3 \
+    python3-dev \
+    ca-certificates \
+    zip \
+    tzdata \
+    && rm -rf /var/lib/apt/lists/*
+
+
+# Install CMake 3.30.0
+RUN curl -L https://github.com/Kitware/CMake/releases/download/v3.30.0/cmake-3.30.0-linux-x86_64.tar.gz -o cmake.tar.gz \
+    && tar -xzf cmake.tar.gz --strip-components=1 -C /usr/local \
+    && rm cmake.tar.gz
+
+
+ADD 10_nvidia.json /etc/glvnd/egl_vendor.d/10_nvidia.json
+RUN chmod 644 /etc/glvnd/egl_vendor.d/10_nvidia.json
+ADD nvidia_icd.json /etc/vulkan/icd.d/nvidia_icd.json
+RUN chmod 644 /etc/vulkan/icd.d/nvidia_icd.json
+ENV NVIDIA_VISIBLE_DEVICES=${NVIDIA_VISIBLE_DEVICES:-all}
+ENV NVIDIA_DRIVER_CAPABILITIES=${NVIDIA_DRIVER_CAPABILITIES:+$NVIDIA_DRIVER_CAPABILITIES,}graphics
+COPY env.sh /etc/profile.d/ade_env.sh
+COPY entrypoint.sh /ade_entrypoint
+ENTRYPOINT ["/ade_entrypoint"]
+CMD ["/bin/bash", "-c", "trap 'exit 147' TERM; tail -f /dev/null & while wait ${!}; test $? -ge 128; do true; done"]
diff --git a/scripts/env_setup/99-obsensor-libusb.rules b/scripts/env_setup/99-obsensor-libusb.rules
new file mode 100644
index 00000000..37ff3947
--- /dev/null
+++ b/scripts/env_setup/99-obsensor-libusb.rules
@@ -0,0 +1,111 @@
+SUBSYSTEMS=="usb", ATTRS{idVendor}=="2bc5", ATTRS{idProduct}=="0501", MODE:="0666",  OWNER:="root", GROUP:="video", SYMLINK+="Bootloader Device"
+
+# UVC Modules
+SUBSYSTEMS=="usb", ATTRS{idVendor}=="2bc5", ATTRS{idProduct}=="0635", MODE:="0666",  OWNER:="root", GROUP:="video", SYMLINK+="Femto"
+SUBSYSTEMS=="usb", ATTRS{idVendor}=="2bc5", ATTRS{idProduct}=="0638", MODE:="0666",  OWNER:="root", GROUP:="video", SYMLINK+="Femto-w"
+SUBSYSTEMS=="usb", ATTRS{idVendor}=="2bc5", ATTRS{idProduct}=="0668", MODE:="0666",  OWNER:="root", GROUP:="video", SYMLINK+="Femto-live"
+SUBSYSTEMS=="usb", ATTRS{idVendor}=="2bc5", ATTRS{idProduct}=="0636", MODE:="0666",  OWNER:="root", GROUP:="video", SYMLINK+="Astra+"
+SUBSYSTEMS=="usb", ATTRS{idVendor}=="2bc5", ATTRS{idProduct}=="0637", MODE:="0666",  OWNER:="root", GROUP:="video", SYMLINK+="Astra+s"
+SUBSYSTEMS=="usb", ATTRS{idVendor}=="2bc5", ATTRS{idProduct}=="0536", MODE:="0666",  OWNER:="root", GROUP:="video", SYMLINK+="Astra+_rgb"
+SUBSYSTEMS=="usb", ATTRS{idVendor}=="2bc5", ATTRS{idProduct}=="0537", MODE:="0666",  OWNER:="root", GROUP:="video", SYMLINK+="Astra+s_rgb"
+SUBSYSTEMS=="usb", ATTRS{idVendor}=="2bc5", ATTRS{idProduct}=="0669", MODE:="0666",  OWNER:="root", GROUP:="video", SYMLINK+="Femto-mega"
+SUBSYSTEMS=="usb", ATTRS{idVendor}=="2bc5", ATTRS{idProduct}=="066b", MODE:="0666",  OWNER:="root", GROUP:="video", SYMLINK+="Femto Bolt"
+SUBSYSTEMS=="usb", ATTRS{idVendor}=="2bc5", ATTRS{idProduct}=="0660", MODE:="0666",  OWNER:="root", GROUP:="video", SYMLINK+="Astra 2"
+SUBSYSTEMS=="usb", ATTRS{idVendor}=="2bc5", ATTRS{idProduct}=="0670", MODE:="0666",  OWNER:="root", GROUP:="video", SYMLINK+="Gemini 2"
+SUBSYSTEMS=="usb", ATTRS{idVendor}=="2bc5", ATTRS{idProduct}=="0671", MODE:="0666",  OWNER:="root", GROUP:="video", SYMLINK+="Gemini 2 XL"
+SUBSYSTEMS=="usb", ATTRS{idVendor}=="2bc5", ATTRS{idProduct}=="0673", MODE:="0666",  OWNER:="root", GROUP:="video", SYMLINK+="Gemini 2 L"
+SUBSYSTEMS=="usb", ATTRS{idVendor}=="2bc5", ATTRS{idProduct}=="0675", MODE:="0666",  OWNER:="root", GROUP:="video", SYMLINK+="Gemini 2 VL"
+SUBSYSTEMS=="usb", ATTRS{idVendor}=="2bc5", ATTRS{idProduct}=="0800", MODE:="0666",  OWNER:="root", GROUP:="video", SYMLINK+="Gemini 335"
+SUBSYSTEMS=="usb", ATTRS{idVendor}=="2bc5", ATTRS{idProduct}=="0801", MODE:="0666",  OWNER:="root", GROUP:="video", SYMLINK+="Gemini 330"
+SUBSYSTEMS=="usb", ATTRS{idVendor}=="2bc5", ATTRS{idProduct}=="0802", MODE:="0666",  OWNER:="root", GROUP:="video", SYMLINK+="Gemini dm330"
+SUBSYSTEMS=="usb", ATTRS{idVendor}=="2bc5", ATTRS{idProduct}=="0803", MODE:="0666",  OWNER:="root", GROUP:="video", SYMLINK+="Gemini 336"
+SUBSYSTEMS=="usb", ATTRS{idVendor}=="2bc5", ATTRS{idProduct}=="0804", MODE:="0666",  OWNER:="root", GROUP:="video", SYMLINK+="Gemini 335L"
+SUBSYSTEMS=="usb", ATTRS{idVendor}=="2bc5", ATTRS{idProduct}=="0805", MODE:="0666",  OWNER:="root", GROUP:="video", SYMLINK+="Gemini 330L"
+SUBSYSTEMS=="usb", ATTRS{idVendor}=="2bc5", ATTRS{idProduct}=="0806", MODE:="0666",  OWNER:="root", GROUP:="video", SYMLINK+="Gemini dm330L"
+SUBSYSTEMS=="usb", ATTRS{idVendor}=="2bc5", ATTRS{idProduct}=="0807", MODE:="0666",  OWNER:="root", GROUP:="video", SYMLINK+="Gemini 336L"
+SUBSYSTEMS=="usb", ATTRS{idVendor}=="2bc5", ATTRS{idProduct}=="080b", MODE:="0666",  OWNER:="root", GROUP:="video", SYMLINK+="Gemini 335Lg"
+SUBSYSTEMS=="usb", ATTRS{idVendor}=="2bc5", ATTRS{idProduct}=="080d", MODE:="0666",  OWNER:="root", GROUP:="video", SYMLINK+="Gemini 336Lg"
+SUBSYSTEMS=="usb", ATTRS{idVendor}=="2bc5", ATTRS{idProduct}=="080e", MODE:="0666",  OWNER:="root", GROUP:="video", SYMLINK+="Gemini 335Le"
+SUBSYSTEMS=="usb", ATTRS{idVendor}=="2bc5", ATTRS{idProduct}=="0810", MODE:="0666",  OWNER:="root", GROUP:="video", SYMLINK+="Gemini 336Le"
+SUBSYSTEMS=="usb", ATTRS{idVendor}=="2bc5", ATTRS{idProduct}=="0674", MODE:="0666",  OWNER:="root", GROUP:="video", SYMLINK+="Gemini 2 I"
+SUBSYSTEMS=="usb", ATTRS{idVendor}=="2bc5", ATTRS{idProduct}=="0701", MODE:="0666",  OWNER:="root", GROUP:="video", SYMLINK+="Dabai DCL"
+SUBSYSTEMS=="usb", ATTRS{idVendor}=="2bc5", ATTRS{idProduct}=="069d", MODE:="0666",  OWNER:="root", GROUP:="video", SYMLINK+="Astra Pro2"
+
+# OpenNI Modules
+SUBSYSTEM=="usb", ATTR{idProduct}=="0401", ATTR{idVendor}=="2bc5", MODE:="0666", OWNER:="root", GROUP:="video", SYMLINK+="astra"
+SUBSYSTEM=="usb", ATTR{idProduct}=="0402", ATTR{idVendor}=="2bc5", MODE:="0666", OWNER:="root", GROUP:="video", SYMLINK+="astra_s"
+SUBSYSTEM=="usb", ATTR{idProduct}=="0403", ATTR{idVendor}=="2bc5", MODE:="0666", OWNER:="root", GROUP:="video", SYMLINK+="astra_pro"
+SUBSYSTEM=="usb", ATTR{idProduct}=="0404", ATTR{idVendor}=="2bc5", MODE:="0666", OWNER:="root", GROUP:="video", SYMLINK+="astra_mini"
+SUBSYSTEM=="usb", ATTR{idProduct}=="0407", ATTR{idVendor}=="2bc5", MODE:="0666", OWNER:="root", GROUP:="video", SYMLINK+="astra_mini_s"
+SUBSYSTEM=="usb", ATTR{idProduct}=="0601", ATTR{idVendor}=="2bc5", MODE:="0666", OWNER:="root", GROUP:="video", SYMLINK+="astra_NH_GLST"
+SUBSYSTEM=="usb", ATTR{idProduct}=="060b", ATTR{idVendor}=="2bc5", MODE:="0666", OWNER:="root", GROUP:="video", SYMLINK+="deeyea"
+SUBSYSTEM=="usb", ATTR{idProduct}=="050b", ATTR{idVendor}=="2bc5", MODE:="0666", OWNER:="root", GROUP:="video", SYMLINK+="deeyea_rgb"
+SUBSYSTEM=="usb", ATTR{idProduct}=="060e", ATTR{idVendor}=="2bc5", MODE:="0666", OWNER:="root", GROUP:="video", SYMLINK+="petrel"
+SUBSYSTEM=="usb", ATTR{idProduct}=="050e", ATTR{idVendor}=="2bc5", MODE:="0666", OWNER:="root", GROUP:="video", SYMLINK+="petrel_rgb"
+SUBSYSTEM=="usb", ATTR{idProduct}=="060f", ATTR{idVendor}=="2bc5", MODE:="0666", OWNER:="root", GROUP:="video", SYMLINK+="astro_pro_plus"
+SUBSYSTEM=="usb", ATTR{idProduct}=="050f", ATTR{idVendor}=="2bc5", MODE:="0666", OWNER:="root", GROUP:="video", SYMLINK+="astro_pro_plus_rgb"
+SUBSYSTEM=="usb", ATTR{idProduct}=="0610", ATTR{idVendor}=="2bc5", MODE:="0666", OWNER:="root", GROUP:="video", SYMLINK+="bus_cl"
+SUBSYSTEM=="usb", ATTR{idProduct}=="0603", ATTR{idVendor}=="2bc5", MODE:="0666", OWNER:="root", GROUP:="video", SYMLINK+="atlas"
+SUBSYSTEM=="usb", ATTR{idProduct}=="0510", ATTR{idVendor}=="2bc5", MODE:="0666", OWNER:="root", GROUP:="video", SYMLINK+="atlas_rgb"
+SUBSYSTEM=="usb", ATTR{idProduct}=="0614", ATTR{idVendor}=="2bc5", MODE:="0666", OWNER:="root", GROUP:="video", SYMLINK+="gemini"
+SUBSYSTEM=="usb", ATTR{idProduct}=="0511", ATTR{idVendor}=="2bc5", MODE:="0666", OWNER:="root", GROUP:="video", SYMLINK+="gemini_rgb"
+SUBSYSTEM=="usb", ATTR{idProduct}=="0616", ATTR{idVendor}=="2bc5", MODE:="0666", OWNER:="root", GROUP:="video", SYMLINK+="u1s"
+SUBSYSTEM=="usb", ATTR{idProduct}=="0516", ATTR{idVendor}=="2bc5", MODE:="0666", OWNER:="root", GROUP:="video", SYMLINK+="u1s_rgb"
+SUBSYSTEM=="usb", ATTR{idProduct}=="0617", ATTR{idVendor}=="2bc5", MODE:="0666", OWNER:="root", GROUP:="video", SYMLINK+="projector"
+SUBSYSTEM=="usb", ATTR{idProduct}=="0517", ATTR{idVendor}=="2bc5", MODE:="0666", OWNER:="root", GROUP:="video", SYMLINK+="projector_rgb"
+SUBSYSTEM=="usb", ATTR{idProduct}=="0618", ATTR{idVendor}=="2bc5", MODE:="0666", OWNER:="root", GROUP:="video", SYMLINK+="butterfly"
+SUBSYSTEM=="usb", ATTR{idProduct}=="0518", ATTR{idVendor}=="2bc5", MODE:="0666", OWNER:="root", GROUP:="video", SYMLINK+="butterfly_rgb"
+SUBSYSTEM=="usb", ATTR{idProduct}=="061b", ATTR{idVendor}=="2bc5", MODE:="0666", OWNER:="root", GROUP:="video", SYMLINK+="pavo"
+SUBSYSTEM=="usb", ATTR{idProduct}=="051b", ATTR{idVendor}=="2bc5", MODE:="0666", OWNER:="root", GROUP:="video", SYMLINK+="pavo_rgb"
+SUBSYSTEM=="usb", ATTR{idProduct}=="062b", ATTR{idVendor}=="2bc5", MODE:="0666", OWNER:="root", GROUP:="video", SYMLINK+="petrel_pro"
+SUBSYSTEM=="usb", ATTR{idProduct}=="052b", ATTR{idVendor}=="2bc5", MODE:="0666", OWNER:="root", GROUP:="video", SYMLINK+="petrel_pro_rgb"
+SUBSYSTEM=="usb", ATTR{idProduct}=="062c", ATTR{idVendor}=="2bc5", MODE:="0666", OWNER:="root", GROUP:="video", SYMLINK+="petrel_plus"
+SUBSYSTEM=="usb", ATTR{idProduct}=="052c", ATTR{idVendor}=="2bc5", MODE:="0666", OWNER:="root", GROUP:="video", SYMLINK+="petrel_plus_rgb"
+SUBSYSTEM=="usb", ATTR{idProduct}=="062d", ATTR{idVendor}=="2bc5", MODE:="0666", OWNER:="root", GROUP:="video", SYMLINK+="pictor"
+SUBSYSTEM=="usb", ATTR{idProduct}=="0632", ATTR{idVendor}=="2bc5", MODE:="0666", OWNER:="root", GROUP:="video", SYMLINK+="astra+"
+SUBSYSTEM=="usb", ATTR{idProduct}=="0532", ATTR{idVendor}=="2bc5", MODE:="0666", OWNER:="root", GROUP:="video", SYMLINK+="astra+rgb"
+SUBSYSTEM=="usb", ATTR{idProduct}=="0633", ATTR{idVendor}=="2bc5", MODE:="0666", OWNER:="root", GROUP:="video", SYMLINK+="astra+s"
+SUBSYSTEM=="usb", ATTR{idProduct}=="0533", ATTR{idVendor}=="2bc5", MODE:="0666", OWNER:="root", GROUP:="video", SYMLINK+="astra+s_rgb"
+SUBSYSTEM=="usb", ATTR{idProduct}=="0634", ATTR{idVendor}=="2bc5", MODE:="0666", OWNER:="root", GROUP:="video", SYMLINK+="dabai_petal_b"
+SUBSYSTEM=="usb", ATTR{idProduct}=="0534", ATTR{idVendor}=="2bc5", MODE:="0666", OWNER:="root", GROUP:="video", SYMLINK+="dabai_petal_b_rgb"
+SUBSYSTEM=="usb", ATTR{idProduct}=="0635", ATTR{idVendor}=="2bc5", MODE:="0666", OWNER:="root", GROUP:="video", SYMLINK+="femto"
+SUBSYSTEM=="usb", ATTR{idProduct}=="0636", ATTR{idVendor}=="2bc5", MODE:="0666", OWNER:="root", GROUP:="video", SYMLINK+="jarvis"
+SUBSYSTEM=="usb", ATTR{idProduct}=="0536", ATTR{idVendor}=="2bc5", MODE:="0666", OWNER:="root", GROUP:="video", SYMLINK+="jarvis_rgb"
+SUBSYSTEM=="usb", ATTR{idProduct}=="0637", ATTR{idVendor}=="2bc5", MODE:="0666", OWNER:="root", GROUP:="video", SYMLINK+="jarvis+s"
+SUBSYSTEM=="usb", ATTR{idProduct}=="0537", ATTR{idVendor}=="2bc5", MODE:="0666", OWNER:="root", GROUP:="video", SYMLINK+="jarvis+s_rgb"
+SUBSYSTEM=="usb", ATTR{idProduct}=="0638", ATTR{idVendor}=="2bc5", MODE:="0666", OWNER:="root", GROUP:="video", SYMLINK+="femto_w"
+SUBSYSTEM=="usb", ATTR{idProduct}=="0639", ATTR{idVendor}=="2bc5", MODE:="0666", OWNER:="root", GROUP:="video", SYMLINK+="argus"
+SUBSYSTEM=="usb", ATTR{idProduct}=="0539", ATTR{idVendor}=="2bc5", MODE:="0666", OWNER:="root", GROUP:="video", SYMLINK+="argus_rgb"
+SUBSYSTEM=="usb", ATTR{idProduct}=="063a", ATTR{idVendor}=="2bc5", MODE:="0666", OWNER:="root", GROUP:="video", SYMLINK+="u2"
+SUBSYSTEM=="usb", ATTR{idProduct}=="0650", ATTR{idVendor}=="2bc5", MODE:="0666", OWNER:="root", GROUP:="video", SYMLINK+="astradepth"
+SUBSYSTEM=="usb", ATTR{idProduct}=="0651", ATTR{idVendor}=="2bc5", MODE:="0666", OWNER:="root", GROUP:="video", SYMLINK+="astradepth"
+SUBSYSTEM=="usb", ATTR{idProduct}=="0654", ATTR{idVendor}=="2bc5", MODE:="0666", OWNER:="root", GROUP:="video", SYMLINK+="qi_long_zhu"
+SUBSYSTEM=="usb", ATTR{idProduct}=="0554", ATTR{idVendor}=="2bc5", MODE:="0666", OWNER:="root", GROUP:="video", SYMLINK+="qi_long_zhu_rgb"
+SUBSYSTEM=="usb", ATTR{idProduct}=="0655", ATTR{idVendor}=="2bc5", MODE:="0666", OWNER:="root", GROUP:="video", SYMLINK+="dabai_plus"
+SUBSYSTEM=="usb", ATTR{idProduct}=="0656", ATTR{idVendor}=="2bc5", MODE:="0666", OWNER:="root", GROUP:="video", SYMLINK+="dabai_mini"
+SUBSYSTEM=="usb", ATTR{idProduct}=="0657", ATTR{idVendor}=="2bc5", MODE:="0666", OWNER:="root", GROUP:="video", SYMLINK+="dabai_dc1"
+SUBSYSTEM=="usb", ATTR{idProduct}=="0557", ATTR{idVendor}=="2bc5", MODE:="0666", OWNER:="root", GROUP:="video", SYMLINK+="dabai_dc1_rgb"
+SUBSYSTEM=="usb", ATTR{idProduct}=="0658", ATTR{idVendor}=="2bc5", MODE:="0666", OWNER:="root", GROUP:="video", SYMLINK+="dabai_d1"
+SUBSYSTEM=="usb", ATTR{idProduct}=="0657", ATTR{idVendor}=="2bc5", MODE:="0666", OWNER:="root", GROUP:="video", SYMLINK+="dabai_dc1"
+SUBSYSTEM=="usb", ATTR{idProduct}=="0557", ATTR{idVendor}=="2bc5", MODE:="0666", OWNER:="root", GROUP:="video", SYMLINK+="dabai_dc1_rgb"
+SUBSYSTEM=="usb", ATTR{idProduct}=="0659", ATTR{idVendor}=="2bc5", MODE:="0666", OWNER:="root", GROUP:="video", SYMLINK+="dabai_dcw"
+SUBSYSTEM=="usb", ATTR{idProduct}=="0559", ATTR{idVendor}=="2bc5", MODE:="0666", OWNER:="root", GROUP:="video", SYMLINK+="dabai_dcw_rgb"
+SUBSYSTEM=="usb", ATTR{idProduct}=="065a", ATTR{idVendor}=="2bc5", MODE:="0666", OWNER:="root", GROUP:="video", SYMLINK+="dabai_dw"
+SUBSYSTEM=="usb", ATTR{idProduct}=="065b", ATTR{idVendor}=="2bc5", MODE:="0666", OWNER:="root", GROUP:="video", SYMLINK+="astra_mini_pro"
+SUBSYSTEM=="usb", ATTR{idProduct}=="065c", ATTR{idVendor}=="2bc5", MODE:="0666", OWNER:="root", GROUP:="video", SYMLINK+="gemini_e"
+SUBSYSTEM=="usb", ATTR{idProduct}=="055c", ATTR{idVendor}=="2bc5", MODE:="0666", OWNER:="root", GROUP:="video", SYMLINK+="gemini_e_rgb"
+SUBSYSTEM=="usb", ATTR{idProduct}=="065d", ATTR{idVendor}=="2bc5", MODE:="0666", OWNER:="root", GROUP:="video", SYMLINK+="gemini_e_lite"
+SUBSYSTEM=="usb", ATTR{idProduct}=="065e", ATTR{idVendor}=="2bc5", MODE:="0666", OWNER:="root", GROUP:="video", SYMLINK+="astra_mini_s_pro"
+SUBSYSTEM=="usb", ATTR{idProduct}=="0698", ATTR{idVendor}=="2bc5", MODE:="0666", OWNER:="root", GROUP:="video", SYMLINK+="j1"
+SUBSYSTEM=="usb", ATTR{idProduct}=="069c", ATTR{idVendor}=="2bc5", MODE:="0666", OWNER:="root", GROUP:="video", SYMLINK+="TB2201"
+SUBSYSTEM=="usb", ATTR{idProduct}=="06a0", ATTR{idVendor}=="2bc5", MODE:="0666", OWNER:="root", GROUP:="video", SYMLINK+="dabai_dcw2"
+SUBSYSTEM=="usb", ATTR{idProduct}=="0561", ATTR{idVendor}=="2bc5", MODE:="0666", OWNER:="root", GROUP:="video", SYMLINK+="dabai_dcw2_rgb"
+SUBSYSTEM=="usb", ATTR{idProduct}=="069f", ATTR{idVendor}=="2bc5", MODE:="0666", OWNER:="root", GROUP:="video", SYMLINK+="dabai_dw2"
+SUBSYSTEM=="usb", ATTR{idProduct}=="069a", ATTR{idVendor}=="2bc5", MODE:="0666", OWNER:="root", GROUP:="video", SYMLINK+="dabai_max"
+SUBSYSTEM=="usb", ATTR{idProduct}=="069e", ATTR{idVendor}=="2bc5", MODE:="0666", OWNER:="root", GROUP:="video", SYMLINK+="dabai_max_pro"
+SUBSYSTEM=="usb", ATTR{idProduct}=="0560", ATTR{idVendor}=="2bc5", MODE:="0666", OWNER:="root", GROUP:="video", SYMLINK+="dabai_max_pro_rgb"
+SUBSYSTEM=="usb", ATTR{idProduct}=="06aa", ATTR{idVendor}=="2bc5", MODE:="0666", OWNER:="root", GROUP:="video", SYMLINK+="dabai_gemini_uw"
+SUBSYSTEM=="usb", ATTR{idProduct}=="05aa", ATTR{idVendor}=="2bc5", MODE:="0666", OWNER:="root", GROUP:="video", SYMLINK+="dabai_gemini_uw_rgb"
+SUBSYSTEM=="usb", ATTR{idProduct}=="06a6", ATTR{idVendor}=="2bc5", MODE:="0666", OWNER:="root", GROUP:="video", SYMLINK+="gemini_ew"
+SUBSYSTEM=="usb", ATTR{idProduct}=="05a6", ATTR{idVendor}=="2bc5", MODE:="0666", OWNER:="root", GROUP:="video", SYMLINK+="gemini_ew_rgb"
+SUBSYSTEM=="usb", ATTR{idProduct}=="06a7", ATTR{idVendor}=="2bc5", MODE:="0666", OWNER:="root", GROUP:="video", SYMLINK+="gemini_ew_lite"
diff --git a/scripts/env_setup/install_udev_rules.sh b/scripts/env_setup/install_udev_rules.sh
new file mode 100755
index 00000000..0c28d83c
--- /dev/null
+++ b/scripts/env_setup/install_udev_rules.sh
@@ -0,0 +1,26 @@
+#!/bin/sh
+
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+# Check if user is root/running with sudo
+if [ `whoami` != root ]; then
+    echo Please run this script with sudo
+    exit
+fi
+
+ORIG_PATH=`pwd`
+cd `dirname $0`
+SCRIPT_PATH=`pwd`
+cd $ORIG_PATH
+
+if [ "`uname -s`" != "Darwin" ]; then
+    # Install udev rules for USB device
+    cp ${SCRIPT_PATH}/99-obsensor-libusb.rules /etc/udev/rules.d/99-obsensor-libusb.rules
+
+    # resload udev rules
+    udevadm control --reload && udevadm trigger
+
+    echo "usb rules file install at /etc/udev/rules.d/99-obsensor-libusb.rules"
+fi
+echo "exit"
diff --git a/scripts/env_setup/obsensor_metadata_win10.md b/scripts/env_setup/obsensor_metadata_win10.md
new file mode 100644
index 00000000..af149264
--- /dev/null
+++ b/scripts/env_setup/obsensor_metadata_win10.md
@@ -0,0 +1,16 @@
+# obsensor_metadata_win10
+
+This document introduces the process for getting metadata from Orbbec cameras with UVC protocal on Windows system. The following process has been verified on Windows 10 and Windows 11.
+
+## Registering Metadata Using a Script
+
+To get device metadata through UVC protocol, users need to modify the registry and complete registration first, because Windows system has default limitations.
+
+1. Connect the device and confirm that the device is online;
+2. Open powershell with administrator privileges, then `cd` command to enter the `shared` directory;
+3. Execute the `Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser` command, and enter `Y` as prompted to confirm;
+   - Try to execute the `Set-ExecutionPolicy -ExecutionPolicy Unrestricted -Scope CurrentUser` command if the previous command fails in some cases;
+4. Execute `.\obsensor_metadata_win10.ps1 -op install_all` to complete the registration.
+
+**Notes**:
+Users need to run this script every time a new device is connected. This process can be cumbersome and easy to forget, leading to an inability to obtain the device's metadata.
diff --git a/scripts/env_setup/obsensor_metadata_win10.ps1 b/scripts/env_setup/obsensor_metadata_win10.ps1
new file mode 100644
index 00000000..cedc026b
--- /dev/null
+++ b/scripts/env_setup/obsensor_metadata_win10.ps1
@@ -0,0 +1,130 @@
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+# Usage:
+#Launch Windows PowerShell, and navigate to the script directory
+#PS> .\obsensor_metadata_win10.ps1                    - Add metadata reg. keys for the connected Orbbec devices
+#PS> .\obsensor_metadata_win10.ps1 -op install        - See above
+#PS> .\obsensor_metadata_win10.ps1 -op install_all    - Add metadata reg. keys for all Orbbec devices that were previously connected
+#PS> .\obsensor_metadata_win10.ps1 -op remove         - Remove metadata reg. keys for the connected Orbbec devices
+#PS> .\obsensor_metadata_win10.ps1 -op remove_all     - Remove metadata reg. keys for all Orbbec devices that were previously connected
+
+
+#Parse command-line argument
+param (
+    [string]$op = "install"
+)
+
+# Elevate to admin - https://stackoverflow.com/questions/7690994/powershell-running-a-command-as-administrator
+If (-NOT ([Security.Principal.WindowsPrincipal][Security.Principal.WindowsIdentity]::GetCurrent()).IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator))
+{
+    # The original script is modified to pass through the command-line parameter
+    $arguments = "& '" + $myinvocation.mycommand.definition + "'" + " -op " + $op
+    Start-Process powershell -Verb runAs -ArgumentList $arguments
+    Break
+}
+
+# Base location for the registry keys we need to add
+$DevConfigRegBase = "HKLM:\SYSTEM\CurrentControlSet\Control\DeviceClasses"
+# The Registry subtrees for the Metadata keys shall be added
+$guid1 = "{e5323777-f976-4f5b-9b55-b94699c46e44}";
+$guid2 = "{65E8773D-8F56-11D0-A3B9-00A0C9223196}";
+
+$SearchTrees = "$DevConfigRegBase\$guid1", "$DevConfigRegBase\$guid2"
+
+# Multipin devices that need additional key MetadataBufferSizeInKB1 & MetadataBufferSizeInKB2 & etc...
+$MultiPinDevices = "USB\VID_2BC5&PID_06D0&MI_00", #  Gemini 2 R  // 3 pin for depth uvc
+                 "USB\VID_2BC5&PID_06D1&MI_00" #  Gemini 2 RL  // 3 pin for depth uvc
+
+#Inhibit system warnings and erros, such as permissions or missing values
+$ErrorActionPreference = "silentlycontinue"
+
+$ConnectedDev = @()
+#Retrieve all connected UVC devices
+$DevInReg = Get-ChildItem hklm:\SYSTEM\CurrentControlSet\Services\usbvideo | ForEach-Object {Get-ItemProperty $_.pspath}
+
+#Transform output into a standard container
+for ($i=0; $i -lt $DevInReg[0].Count; $i++) { $ConnectedDev +=$DevInReg[0].$i}
+
+#Filter Orbbec devices
+#$ConnectedDev = $ConnectedDev -like "*VID_8086*"
+$ConnectedDev = $ConnectedDev -like "*VID_2BC5*"
+
+#Progress notification
+$rs_count = $ConnectedDev.Count
+echo "$rs_count connected Orbbec devices were found:" $ConnectedDev
+
+#Search each subtree for values that correspond to the requested Orbbec devices
+foreach ($subtree in $SearchTrees)
+{
+    "`nProcessing Registry branch $subtree"
+    #Get records for all UVC devices records
+    $Items = Get-ChildItem $subtree | Foreach-Object {Get-ItemProperty $_.PsPath }
+
+    #Filter Orbbec devices
+    "There are " + $Items.Count +" total devices listed"
+   # $Items = $Items | Where { $_.DeviceInstance -like "*VID_8086*" }
+   $Items = $Items | Where { $_.DeviceInstance -like "*VID_2BC5*" }
+    "" + $Items.Count + " of them are Orbbec devices"
+
+    $remove_keys = 0
+    switch ($op)
+    {
+        "install"     { $Items =  $Items | Where { $ConnectedDev -contains $_.DeviceInstance }}
+        "remove"      { $Items =  $Items | Where { $ConnectedDev -contains $_.DeviceInstance }; $remove_keys = 1 }
+        "install_all" { }
+        "remove_all"  { $remove_keys = 1 }
+        default       { "Aborting: unrecognized argument "" + $op + "" provided.`nPossible values are:";
+                        "`t`t -op [install/install_all/remove/remove_all].`nRefer to the installation manual for details"; Sleep 2; Exit }
+    }
+
+    foreach  ($item in $Items)
+    {
+
+        $fullPath = $item.PSPath+'\#global\Device Parameters'
+
+        if ($remove_keys -ge 1)
+        {
+            "Remove keys for device: " + $item.DeviceInstance.ToString()
+            # Non-present value will be ignored as for script execution policy
+            Remove-ItemProperty -path $fullPath -name MetadataBufferSizeInKB0
+            Remove-ItemProperty -path $fullPath -name MetadataBufferSizeInKB1
+			Remove-ItemProperty -path $fullPath -name MetadataBufferSizeInKB2
+        }
+        else
+        {
+            $val = 0,0,0
+            $val[0] = Get-ItemPropertyValue -Path $fullPath -Name MetadataBufferSizeInKB0
+            $val[1] = Get-ItemPropertyValue -Path $fullPath -Name MetadataBufferSizeInKB1
+			$val[2] = Get-ItemPropertyValue -Path $fullPath -Name MetadataBufferSizeInKB2
+
+            if ($val[0] -eq 0)
+            {
+                "Device " +  $item.DeviceInstance.ToString() + ": adding metadata key"
+                Set-ItemProperty -path $fullPath -name MetadataBufferSizeInKB0 -value 5
+            }
+            else
+            {
+                "Device " +  $item.DeviceInstance.ToString() + ": skiping - metadata key already exists"
+            }
+
+            if (($MultiPinDevices -contains $item.DeviceInstance.Substring(0,27)) -and ($val[1] -eq 0))
+            {
+                # Multi-pin interface requires an additional key
+                "Device " +  $item.DeviceInstance.ToString() +": adding extra key for multipin interface, pin 1"
+                Set-ItemProperty -path $fullPath -name MetadataBufferSizeInKB1 -value 5
+            }
+
+            if (($MultiPinDevices -contains $item.DeviceInstance.Substring(0,27)) -and ($val[2] -eq 0))
+            {
+                # Multi-pin interface requires an additional key
+                "Device " +  $item.DeviceInstance.ToString() +": adding extra key for multipin interface, pin 2"
+                Set-ItemProperty -path $fullPath -name MetadataBufferSizeInKB2 -value 5
+            }
+        }
+    }
+}
+
+"`nTask Completed"
+sleep 1
+
diff --git a/scripts/env_setup/setup.sh b/scripts/env_setup/setup.sh
new file mode 100755
index 00000000..f265fcbb
--- /dev/null
+++ b/scripts/env_setup/setup.sh
@@ -0,0 +1,27 @@
+#!/bin/bash
+
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+# restore current directory
+current_dir=$(pwd)
+
+# cd to the directory where this script is located
+cd "$(dirname "$0")"
+project_dir=$(pwd)
+
+# set up environment variables
+shared_dir=$project_dir/scripts
+examples_dir=$project_dir/examples
+
+# build the examples
+if [ -d "$examples_dir" ] && [ -f "$project_dir/build_examples.sh" ]; then
+    $project_dir/build_examples.sh
+fi
+
+# install udev rules
+if [ -d "$shared_dir" ] && [ -f "$shared_dir/install_udev_rules.sh" ]; then
+    $shared_dir/install_udev_rules.sh
+fi
+
+cd $current_dir
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
new file mode 100644
index 00000000..5d66eaab
--- /dev/null
+++ b/src/CMakeLists.txt
@@ -0,0 +1,64 @@
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+cmake_minimum_required(VERSION 3.5)
+
+set(OB_INTERFACE_DIR "${CMAKE_CURRENT_LIST_DIR}/interface")
+
+# modules
+add_subdirectory(shared) # utils, logger, etc.
+add_subdirectory(core) # core library
+add_subdirectory(filter)
+add_subdirectory(platform)
+add_subdirectory(device)
+add_subdirectory(pipeline)
+
+# config version info
+if(MSVC)
+    set(ORBBEC_VERSIONINFO_RC "${CMAKE_BINARY_DIR}/VersionInfo.rc")
+    configure_file(${CMAKE_CURRENT_SOURCE_DIR}/VersionInfo.rc.in "${ORBBEC_VERSIONINFO_RC}")
+endif()
+
+# only support shared library for now
+add_library(OrbbecSDK SHARED "" ${ORBBEC_VERSIONINFO_RC})
+include(GenerateExportHeader)
+generate_export_header(OrbbecSDK BASE_NAME OB EXPORT_FILE_NAME ${OB_PUBLIC_HEADERS_DIR}/libobsensor/h/Export.h)
+
+file(GLOB_RECURSE SOURCE_FILES ${CMAKE_CURRENT_LIST_DIR}/impl/*.cpp ${CMAKE_CURRENT_LIST_DIR}/context/*.cpp)
+file(GLOB_RECURSE HEADER_FILES ${CMAKE_CURRENT_LIST_DIR}/impl/*.hpp ${CMAKE_CURRENT_LIST_DIR}/context/*.hpp)
+
+target_sources(OrbbecSDK PRIVATE ${SOURCE_FILES} ${HEADER_FILES})
+target_link_libraries(OrbbecSDK PRIVATE ob::shared ob::core ob::filter ob::platform ob::device ob::pipeline)
+target_include_directories(OrbbecSDK PRIVATE ${CMAKE_CURRENT_LIST_DIR})
+target_include_directories(
+    OrbbecSDK PUBLIC "$<BUILD_INTERFACE:${OB_PUBLIC_HEADERS_DIR}>" "$<INSTALL_INTERFACE:include>"
+)
+
+if(UNIX)
+    find_package(Threads REQUIRED)
+    target_link_libraries(OrbbecSDK PRIVATE Threads::Threads)
+endif()
+
+add_library(ob::OrbbecSDK ALIAS OrbbecSDK)
+ob_source_group(ob::OrbbecSDK)
+
+if(OB_IS_MAIN_PROJECT)
+    install(
+        TARGETS OrbbecSDK
+        EXPORT OrbbecSDKConfig
+        RUNTIME DESTINATION bin
+        LIBRARY DESTINATION lib
+        ARCHIVE DESTINATION lib
+    )
+
+    install(
+        DIRECTORY ${OB_PUBLIC_HEADERS_DIR}
+        DESTINATION include
+        FILES_MATCHING
+        PATTERN "*.h"
+        PATTERN "*.hpp"
+    )
+
+    install(EXPORT OrbbecSDKConfig NAMESPACE ob:: DESTINATION lib)
+endif()
+
diff --git a/src/VersionInfo.rc.in b/src/VersionInfo.rc.in
new file mode 100644
index 00000000..ef7aadd7
--- /dev/null
+++ b/src/VersionInfo.rc.in
@@ -0,0 +1,31 @@
+1 VERSIONINFO
+ FILEVERSION ${PROJECT_VERSION_MAJOR}, ${PROJECT_VERSION_MINOR}, ${PROJECT_VERSION_PATCH}
+ PRODUCTVERSION ${PROJECT_VERSION_MAJOR}, ${PROJECT_VERSION_MINOR}, ${PROJECT_VERSION_PATCH}
+ FILEFLAGSMASK 0x17L
+#ifdef _DEBUG
+ FILEFLAGS 0x1L
+#else
+ FILEFLAGS 0x0L
+#endif
+ FILEOS 0x4L
+ FILETYPE 0x0L
+ FILESUBTYPE 0x0L
+BEGIN
+    BLOCK "StringFileInfo"
+    BEGIN
+        BLOCK "040904b0"
+        BEGIN
+            VALUE "FileDescription", "Orbbec SDK"
+            VALUE "FileVersion", "${PROJECT_VERSION_MAJOR}, ${PROJECT_VERSION_MINOR}, ${PROJECT_VERSION_PATCH}"
+            VALUE "InternalName", "Orbbec SDK"
+            VALUE "LegalCopyright", "Copyright Orbbec Corporation. All rights reserved."
+            VALUE "OriginalFilename", ""
+            VALUE "ProductName", "Orbbec SDK"
+            VALUE "ProductVersion", "${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH}"
+        END
+    END
+    BLOCK "VarFileInfo"
+    BEGIN
+        VALUE "Translation", 0x409, 1200
+    END
+END
\ No newline at end of file
diff --git a/src/core/CMakeLists.txt b/src/core/CMakeLists.txt
new file mode 100644
index 00000000..f119e0aa
--- /dev/null
+++ b/src/core/CMakeLists.txt
@@ -0,0 +1,21 @@
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+cmake_minimum_required(VERSION 3.5)
+
+# add the core library with version number
+add_library(core STATIC)
+set_target_properties(core PROPERTIES VERSION ${PROJECT_VERSION})
+
+# add the core library sources
+file(GLOB_RECURSE SOURCE_FILES "*.cpp" EXCLUDE unittest)
+file(GLOB_RECURSE HEADERS_FILES "*.hpp" EXCLUDE unittest)
+target_sources(core PRIVATE ${SOURCE_FILES} ${HEADERS_FILES})
+
+target_link_libraries(core PUBLIC ob::shared)
+target_include_directories(core PUBLIC  ${OB_PUBLIC_HEADERS_DIR} ${CMAKE_CURRENT_LIST_DIR})
+
+add_library(ob::core ALIAS core)
+ob_source_group(ob::core)
+set_target_properties(core PROPERTIES FOLDER "modules")
+
diff --git a/src/core/IFrame.hpp b/src/core/IFrame.hpp
new file mode 100644
index 00000000..9450bc02
--- /dev/null
+++ b/src/core/IFrame.hpp
@@ -0,0 +1,57 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include <atomic>
+#include <memory>
+#include <functional>
+
+#include "libobsensor/h/ObTypes.h"
+
+namespace libobsensor
+{
+
+class IFrameMetadataParser {
+public:
+    virtual ~IFrameMetadataParser()                                       = default;
+    virtual int64_t getValue(const uint8_t *metadata, size_t dataSize)    = 0;
+    virtual bool    isSupported(const uint8_t *metadata, size_t dataSize) = 0;
+};
+
+typedef std::function<int64_t(const int64_t &param)> FrameMetadataModifier;
+
+class IFrameMetadataParserContainer {
+public:
+    IFrameMetadataParserContainer() {}
+    virtual ~IFrameMetadataParserContainer()                                                                                             = default;
+    virtual void                                  registerParser(OBFrameMetadataType type, std::shared_ptr<IFrameMetadataParser> phaser) = 0;
+    virtual bool                                  isContained(OBFrameMetadataType type)                                                  = 0;
+    virtual std::shared_ptr<IFrameMetadataParser> get(OBFrameMetadataType type)                                                          = 0;
+};
+
+class Frame;
+
+typedef std::function<void(std::shared_ptr<const Frame>)> FrameCallback;
+typedef std::function<void(std::shared_ptr<Frame>)> MutableFrameCallback;
+
+class IFrameTimestampCalculator {
+public:
+    virtual ~IFrameTimestampCalculator() = default;
+
+    virtual void calculate(std::shared_ptr<Frame> frame) = 0;
+    virtual void clear()                                 = 0;
+};
+
+} // namespace libobsensor
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+struct ob_frame_t {
+    std::shared_ptr<libobsensor::Frame> frame;
+    std::atomic<int>                    refCnt = {1};
+};
+#ifdef __cplusplus
+}
+#endif
diff --git a/src/core/IStreamProfile.hpp b/src/core/IStreamProfile.hpp
new file mode 100644
index 00000000..96c85570
--- /dev/null
+++ b/src/core/IStreamProfile.hpp
@@ -0,0 +1,35 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include <atomic>
+#include <memory>
+#include <vector>
+
+namespace libobsensor {
+class StreamProfile;
+
+typedef std::vector<std::shared_ptr<const StreamProfile>> StreamProfileList;
+
+class IStreamProfileFilter {
+public:
+    virtual ~IStreamProfileFilter() = default;
+
+    virtual StreamProfileList filter(const StreamProfileList &profiles) const = 0;
+};
+
+}  // namespace libobsensor
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+struct ob_stream_profile_t {
+    std::shared_ptr<const libobsensor::StreamProfile> profile;
+};
+
+struct ob_stream_profile_list_t {
+    std::vector<std::shared_ptr<const libobsensor::StreamProfile>> profileList;
+};
+#ifdef __cplusplus
+}
+#endif
diff --git a/src/core/frame/Frame.cpp b/src/core/frame/Frame.cpp
new file mode 100644
index 00000000..69859f46
--- /dev/null
+++ b/src/core/frame/Frame.cpp
@@ -0,0 +1,450 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "Frame.hpp"
+#include "logger/Logger.hpp"
+#include "utils/Utils.hpp"
+#include "stream/StreamProfile.hpp"
+#include "frame/FrameMemoryPool.hpp"
+#include "frame/FrameBufferManager.hpp"
+
+namespace libobsensor {
+
+FrameBackendLifeSpan::FrameBackendLifeSpan()
+    : logger_(Logger::getInstance()), memoryPool_(FrameMemoryPool::getInstance()), memoryAllocator_(FrameMemoryAllocator::getInstance()) {}
+
+FrameBackendLifeSpan::~FrameBackendLifeSpan() {
+    memoryAllocator_.reset();
+    memoryPool_.reset();
+    logger_.reset();
+}
+
+Frame::Frame(uint8_t *data, size_t dataBufSize, OBFrameType type, FrameBufferReclaimFunc bufferReclaimFunc)
+    : dataSize_(dataBufSize),
+      number_(0),
+      timeStampUsec_(0),
+      systemTimeStampUsec_(0),
+      globalTimeStampUsec_(0),
+      metadataSize_(0),
+      metadataPhasers_(nullptr),
+      streamProfile_(nullptr),
+      type_(type),
+      frameData_(data),
+      dataBufSize_(dataBufSize),
+      bufferReclaimFunc_(bufferReclaimFunc) {}
+
+Frame::Frame(uint8_t *data, size_t dataBufSize, FrameBufferReclaimFunc bufferReclaimFunc) : Frame(data, dataBufSize, OB_FRAME_UNKNOWN, bufferReclaimFunc) {}
+
+Frame::~Frame() noexcept {
+    if(bufferReclaimFunc_) {
+        bufferReclaimFunc_();
+    }
+    else {
+        delete[] frameData_;
+    }
+}
+
+OBFrameType Frame::getType() const {
+    return type_;
+}
+
+OBFormat Frame::getFormat() const {
+    if(!streamProfile_) {
+        return OB_FORMAT_UNKNOWN;
+    }
+    return streamProfile_->getFormat();
+}
+
+uint64_t Frame::getNumber() const {
+    return number_;
+}
+
+void Frame::setNumber(const uint64_t number) {
+    number_ = number;
+}
+
+size_t Frame::getDataSize() const {
+    return dataSize_;
+}
+
+void Frame::setDataSize(size_t dataSize) {
+    dataSize_ = dataSize;
+}
+
+const uint8_t *Frame::getData() const {
+    return frameData_;
+}
+
+uint8_t *Frame::getDataMutable() const {
+    return const_cast<uint8_t *>(frameData_);
+}
+
+void Frame::updateData(const uint8_t *data, size_t dataSize) {
+    if(dataSize > dataBufSize_) {
+        throw memory_exception(utils::string::to_string() << "Update data size(" << dataSize << ") > data buffer size! (" << dataBufSize_ << ")");
+    }
+    dataSize_ = dataSize;
+    memcpy(const_cast<uint8_t *>(frameData_), data, dataSize);
+}
+
+uint64_t Frame::getTimeStampUsec() const {
+    return timeStampUsec_;
+}
+
+void Frame::setTimeStampUsec(uint64_t ts) {
+    timeStampUsec_ = ts;
+}
+
+uint64_t Frame::getSystemTimeStampUsec() const {
+    return systemTimeStampUsec_;
+}
+
+void Frame::setSystemTimeStampUsec(uint64_t ts) {
+    systemTimeStampUsec_ = ts;
+}
+
+uint64_t Frame::getGlobalTimeStampUsec() const {
+    return globalTimeStampUsec_;
+}
+
+void Frame::setGlobalTimeStampUsec(uint64_t ts) {
+    globalTimeStampUsec_ = ts;
+}
+
+uint32_t VideoFrame::getFps() const {
+    if(!streamProfile_) {
+        throw invalid_value_exception("Error: This frame dose not have a stream profile!");
+    }
+    if(!streamProfile_->is<VideoStreamProfile>()) {
+        throw invalid_value_exception("Error! A VideoFrame contain a non-video stream profile!");
+    }
+    return streamProfile_->as<VideoStreamProfile>()->getFps();
+}
+
+uint32_t VideoFrame::getWidth() const {
+    if(!streamProfile_) {
+        throw invalid_value_exception("Error: This frame dose not have a stream profile!");
+    }
+    if(!streamProfile_->is<const VideoStreamProfile>()) {
+        throw invalid_value_exception("Error! A VideoFrame contain a non-video stream profile!");
+    }
+    return streamProfile_->as<VideoStreamProfile>()->getWidth();
+}
+
+uint32_t VideoFrame::getHeight() const {
+    if(!streamProfile_) {
+        throw invalid_value_exception("Error: This frame dose not have a stream profile!");
+    }
+    if(!streamProfile_->is<VideoStreamProfile>()) {
+        throw invalid_value_exception("Error! A VideoFrame contain a non-video stream profile!");
+    }
+    return streamProfile_->as<VideoStreamProfile>()->getHeight();
+}
+
+uint32_t VideoFrame::getStride() const {
+    if(stride_ > 0) {
+        return stride_;
+    }
+    auto format = getFormat();
+    auto width  = getWidth();
+    return utils::calcDefaultStrideBytes(format, width);
+}
+
+void VideoFrame::setStride(uint32_t stride) {
+    stride_ = stride;
+}
+
+size_t Frame::getMetadataSize() const {
+    return metadataSize_;
+}
+
+void Frame::setMetadataSize(size_t metadataSize) {
+    metadataSize_ = metadataSize;
+}
+
+void Frame::updateMetadata(const uint8_t *metadata, size_t metadataSize) {
+    if(metadataSize > 0 && metadata == nullptr) {
+        // In the try_read_metadata() function, metadata may be empty.
+        throw memory_exception("Metadata is null!");
+    }
+    if(metadataSize > sizeof(metadata_)) {
+        throw memory_exception("Metadata size is too large!");
+    }
+    memcpy(metadata_, metadata, metadataSize);
+    metadataSize_ = metadataSize;
+}
+
+void Frame::appendMetadata(const uint8_t *metadata, size_t metadataSize) {
+    if(metadataSize > 0 && metadata == nullptr) {
+        // In the try_read_metadata() function, metadata may be empty.
+        throw memory_exception("Metadata is null!");
+    }
+    if(metadataSize_ + metadataSize > sizeof(metadata_)) {
+        throw memory_exception("Metadata size is too large!");
+    }
+    memcpy(metadata_ + metadataSize_, metadata, metadataSize);
+    metadataSize_ += metadataSize;
+}
+
+const uint8_t *Frame::getMetadata() const {
+    return metadata_;
+}
+
+uint8_t *Frame::getMetadataMutable() const {
+    return const_cast<uint8_t *>(metadata_);
+}
+
+void Frame::registerMetadataParsers(std::shared_ptr<IFrameMetadataParserContainer> parsers) {
+    metadataPhasers_ = parsers;
+}
+
+bool Frame::hasMetadata(OBFrameMetadataType type) const {
+    if(!metadataPhasers_) {
+        return false;
+    }
+    if(!metadataPhasers_->isContained(type)) {
+        return false;
+    }
+    auto parser = metadataPhasers_->get(type);
+    return parser->isSupported(metadata_, metadataSize_);
+}
+
+int64_t Frame::getMetadataValue(OBFrameMetadataType type) const {
+    if(!metadataPhasers_) {
+        throw unsupported_operation_exception(utils::string::to_string()
+                                              << "Metadata phasers are not registered! Unsupported to get metadata for type: " << type);
+    }
+    auto parser = metadataPhasers_->get(type);
+    if(!parser->isSupported(metadata_, metadataSize_)) {
+        throw unsupported_operation_exception(utils::string::to_string() << "Current metadata does not contain metadata for type: " << type);
+    }
+    return parser->getValue(metadata_, metadataSize_);
+}
+
+std::shared_ptr<const StreamProfile> Frame::getStreamProfile() const {
+    return streamProfile_;
+}
+
+void Frame::setStreamProfile(std::shared_ptr<const StreamProfile> streamProfile) {
+    streamProfile_ = streamProfile;
+}
+
+void Frame::copyInfoFromOther(const std::shared_ptr<const Frame> otherFrame) {
+    number_              = otherFrame->number_;
+    timeStampUsec_       = otherFrame->timeStampUsec_;
+    systemTimeStampUsec_ = otherFrame->systemTimeStampUsec_;
+    globalTimeStampUsec_ = otherFrame->globalTimeStampUsec_;
+
+    metadataSize_ = otherFrame->metadataSize_;
+    memcpy(metadata_, otherFrame->metadata_, metadataSize_);
+    metadataPhasers_ = otherFrame->metadataPhasers_;
+}
+
+size_t Frame::getDataBufSize() const {
+    return dataBufSize_;
+}
+
+VideoFrame::VideoFrame(uint8_t *data, size_t dataBufSize, OBFrameType type, FrameBufferReclaimFunc bufferReclaimFunc)
+    : Frame(data, dataBufSize, type, bufferReclaimFunc), pixelType_(OB_PIXEL_UNKNOWN), availablePixelBitSize_(0) {}
+
+void VideoFrame::setPixelType(OBPixelType pixelType) {
+    pixelType_ = pixelType;
+}
+
+OBPixelType VideoFrame::getPixelType() const {
+    return pixelType_;
+}
+
+VideoFrame::VideoFrame(uint8_t *data, size_t dataBufSize, FrameBufferReclaimFunc bufferReclaimFunc)
+    : Frame(data, dataBufSize, OB_FRAME_VIDEO, bufferReclaimFunc), pixelType_(OB_PIXEL_UNKNOWN), availablePixelBitSize_(0) {}
+
+uint8_t VideoFrame::getPixelAvailableBitSize() const {
+    if(availablePixelBitSize_ == 0) {
+        auto format = getFormat();
+        return static_cast<uint8_t>(utils::getBytesPerPixel(format) * 8);
+    }
+    return availablePixelBitSize_;
+}
+
+void VideoFrame::setPixelAvailableBitSize(uint8_t bitSize) {
+    availablePixelBitSize_ = bitSize;
+}
+
+void VideoFrame::copyInfoFromOther(std::shared_ptr<const Frame> sourceFrame) {
+    Frame::copyInfoFromOther(sourceFrame);
+    if(sourceFrame->is<VideoFrame>()) {
+        auto vf                = sourceFrame->as<VideoFrame>();
+        pixelType_             = vf->pixelType_;
+        availablePixelBitSize_ = vf->availablePixelBitSize_;
+        stride_                = vf->stride_;
+    }
+}
+
+ColorFrame::ColorFrame(uint8_t *data, size_t dataBufSize, FrameBufferReclaimFunc bufferReclaimFunc)
+    : VideoFrame(data, dataBufSize, OB_FRAME_COLOR, bufferReclaimFunc) {}
+
+DepthFrame::DepthFrame(uint8_t *data, size_t dataBufSize, FrameBufferReclaimFunc bufferReclaimFunc)
+    : VideoFrame(data, dataBufSize, OB_FRAME_DEPTH, bufferReclaimFunc), valueScale_(1.0f) {
+    setPixelType(OB_PIXEL_DEPTH);  // set default pixel type to OB_PIXEL_DEPTH
+}
+
+void DepthFrame::setValueScale(float valueScale) {
+    valueScale_ = valueScale;
+}
+
+float DepthFrame::getValueScale() const {
+    return valueScale_;
+}
+
+void DepthFrame::copyInfoFromOther(std::shared_ptr<const Frame> sourceFrame) {
+    VideoFrame::copyInfoFromOther(sourceFrame);
+    if(sourceFrame->is<DepthFrame>()) {
+        auto df     = sourceFrame->as<DepthFrame>();
+        valueScale_ = df->valueScale_;
+    }
+}
+
+IRFrame::IRFrame(uint8_t *data, size_t dataBufSize, FrameBufferReclaimFunc bufferReclaimFunc, OBFrameType frameType)
+    : VideoFrame(data, dataBufSize, frameType, bufferReclaimFunc) {}
+
+IRLeftFrame::IRLeftFrame(uint8_t *data, size_t dataBufSize, FrameBufferReclaimFunc bufferReclaimFunc)
+    : IRFrame(data, dataBufSize, bufferReclaimFunc, OB_FRAME_IR_LEFT) {}
+
+IRRightFrame::IRRightFrame(uint8_t *data, size_t dataBufSize, FrameBufferReclaimFunc bufferReclaimFunc)
+    : IRFrame(data, dataBufSize, bufferReclaimFunc, OB_FRAME_IR_RIGHT) {}
+
+PointsFrame::PointsFrame(uint8_t *data, size_t dataBufSize, FrameBufferReclaimFunc bufferReclaimFunc)
+    : Frame(data, dataBufSize, OB_FRAME_POINTS, bufferReclaimFunc) {}
+
+void PointsFrame::setCoordinateValueScale(float valueScale) {
+    coordValueScale_ = valueScale;
+}
+
+float PointsFrame::getCoordinateValueScale() const {
+    return coordValueScale_;
+}
+
+AccelFrame::AccelFrame(uint8_t *data, size_t dataBufSize, FrameBufferReclaimFunc bufferReclaimFunc)
+    : Frame(data, dataBufSize, OB_FRAME_ACCEL, bufferReclaimFunc) {}
+
+OBAccelValue AccelFrame::value() {
+    return *(OBAccelValue *)getData();
+}
+
+float AccelFrame::temperature() {
+    return ((AccelFrame::Data *)getData())->temp;
+}
+
+GyroFrame::GyroFrame(uint8_t *data, size_t dataBufSize, FrameBufferReclaimFunc bufferReclaimFunc)
+    : Frame(data, dataBufSize, OB_FRAME_GYRO, bufferReclaimFunc) {}
+
+OBGyroValue GyroFrame ::value() {
+    return *(OBGyroValue *)getData();
+}
+
+float GyroFrame ::temperature() {
+    return ((GyroFrame::Data *)getData())->temp;
+}
+
+FrameSet::FrameSet(uint8_t *data, size_t dataBufSize, FrameBufferReclaimFunc bufferReclaimFunc) : Frame(data, dataBufSize, OB_FRAME_SET, bufferReclaimFunc) {}
+
+FrameSet::~FrameSet() noexcept {
+    clearAllFrame();
+}
+
+uint32_t FrameSet::getCount() const {
+    uint32_t frameCnt = 0;
+    foreachFrame([&](void *item) {
+        auto pFrame = (std::shared_ptr<const Frame> *)item;
+        if(*pFrame) {
+            frameCnt++;
+        }
+        return false;
+    });
+    return frameCnt;
+}
+
+std::shared_ptr<const Frame> FrameSet::getFrame(OBFrameType frameType) const {
+    std::shared_ptr<const Frame> frame;
+    foreachFrame([&](void *item) {
+        auto pFrame = (std::shared_ptr<const Frame> *)item;
+        if(*pFrame && (*pFrame)->getType() == frameType) {
+            frame = *pFrame;
+            return true;
+        }
+        return false;
+    });
+    return frame;
+}
+
+std::shared_ptr<const Frame> FrameSet::getFrame(int index) const {
+    std::shared_ptr<const Frame> frame;
+    uint32_t                     itemSize = sizeof(std::shared_ptr<const Frame>);
+    auto                         itemCnt  = getDataBufSize() / itemSize;
+    if(index >= (int)itemCnt) {
+        throw invalid_value_exception("FrameSet::getFrame() index out of range");
+    }
+    auto pItem = getData();
+    pItem += itemSize * index;
+    auto pFrame = (std::shared_ptr<Frame> *)pItem;
+    frame       = *pFrame;
+    return frame;
+}
+
+std::shared_ptr<Frame> FrameSet::getFrameMutable(OBFrameType frameType) const {
+    auto frame = getFrame(frameType);
+    return std::const_pointer_cast<Frame>(frame);
+}
+
+std::shared_ptr<Frame> FrameSet::getFrameMutable(int index) const {
+    auto frame = getFrame(index);
+    return std::const_pointer_cast<Frame>(frame);
+}
+
+// It is recommended to use the rvalue reference interface. If you have a need, you can uncomment the following
+// void FrameSet::pushFrame(ob_frame_type type, std::shared_ptr<Frame> frame) {
+// pushFrame(std::move(frame));
+// }
+
+void FrameSet::pushFrame(std::shared_ptr<const Frame> &&frame) {
+    OBFrameType type = frame->getType();
+    foreachFrame([&](void *item) {
+        auto pFrame = (std::shared_ptr<const Frame> *)item;
+        if(*pFrame && (*pFrame)->getType() == type) {
+            (*pFrame).reset();
+            *pFrame = nullptr;
+            // LOG( ERROR ) << "The reason for dropping frames is to wait for another frame. Drop Frame type=" << type;
+        }
+        if(!(*pFrame)) {
+            *pFrame = frame;
+            return true;
+        }
+        return false;
+    });
+}
+
+void FrameSet::clearAllFrame() {
+    foreachFrame([](void *item) {
+        auto pFrame = (std::shared_ptr<Frame> *)item;
+        if(*pFrame) {
+            (*pFrame).reset();
+        }
+        *pFrame = nullptr;
+        return false;
+    });
+}
+
+void FrameSet::foreachFrame(ForeachBack foreachBack) const {
+    uint32_t itemSize = sizeof(std::shared_ptr<Frame>);
+    auto     itemCnt  = getDataBufSize() / itemSize;
+    auto     pItem    = const_cast<uint8_t *>(getData());
+    for(uint32_t i = 0; i < itemCnt; i++) {
+        if(foreachBack(pItem)) {
+            break;
+        }
+        pItem += itemSize;
+    }
+}
+
+}  // namespace libobsensor
+
diff --git a/src/core/frame/Frame.hpp b/src/core/frame/Frame.hpp
new file mode 100644
index 00000000..e2a4a998
--- /dev/null
+++ b/src/core/frame/Frame.hpp
@@ -0,0 +1,255 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include "IFrame.hpp"
+#include "IStreamProfile.hpp"
+#include "exception/ObException.hpp"
+
+#include <atomic>
+#include <memory>
+#include <mutex>
+#include <vector>
+#include <typeinfo>
+
+namespace libobsensor {
+
+class logger;
+class FrameMemoryPool;
+class FrameMemoryAllocator;
+class FrameBackendLifeSpan {
+public:
+    FrameBackendLifeSpan();
+    ~FrameBackendLifeSpan();
+
+private:
+    std::shared_ptr<Logger>               logger_;
+    std::shared_ptr<FrameMemoryPool>      memoryPool_;
+    std::shared_ptr<FrameMemoryAllocator> memoryAllocator_;
+};
+
+class FrameSet;
+class PointsFrame;
+class VideoFrame;
+class ColorFrame;
+class DisparityFrame;
+class DepthFrame;
+class IRFrame;
+class AccelFrame;
+class GyroFrame;
+
+using FrameBufferReclaimFunc = std::function<void(void)>;
+
+class Frame : public std::enable_shared_from_this<Frame>, private FrameBackendLifeSpan {
+public:
+    Frame(uint8_t *data, size_t dataBufSize, OBFrameType type, FrameBufferReclaimFunc bufferReclaimFunc = nullptr);
+    Frame(uint8_t *data, size_t dataBufSize, FrameBufferReclaimFunc bufferReclaimFunc = nullptr);
+    virtual ~Frame() noexcept;
+
+    OBFrameType getType() const;
+
+    uint64_t       getNumber() const;
+    void           setNumber(const uint64_t number);
+    size_t         getDataSize() const;
+    void           setDataSize(size_t dataSize);
+    const uint8_t *getData() const;
+    uint8_t       *getDataMutable() const;
+    void           updateData(const uint8_t *data, size_t dataSize);
+    uint64_t       getTimeStampUsec() const;
+    void           setTimeStampUsec(uint64_t ts);
+    uint64_t       getSystemTimeStampUsec() const;
+    void           setSystemTimeStampUsec(uint64_t ts);
+    uint64_t       getGlobalTimeStampUsec() const;
+    void           setGlobalTimeStampUsec(uint64_t ts);
+
+    size_t         getMetadataSize() const;
+    void           updateMetadata(const uint8_t *metadata, size_t metadataSize);
+    void           appendMetadata(const uint8_t *metadata, size_t metadataSize);
+    const uint8_t *getMetadata() const;
+
+    uint8_t *getMetadataMutable() const;  // use with caution, metadata may be changed while other threads are using it
+    void     setMetadataSize(size_t metadataSize);
+
+    void    registerMetadataParsers(std::shared_ptr<IFrameMetadataParserContainer> parsers);
+    bool    hasMetadata(OBFrameMetadataType type) const;
+    int64_t getMetadataValue(OBFrameMetadataType type) const;
+
+    std::shared_ptr<const StreamProfile> getStreamProfile() const;
+    void                                 setStreamProfile(std::shared_ptr<const StreamProfile> streamProfile);
+    OBFormat                             getFormat() const;  // get from stream profile
+
+    virtual void copyInfoFromOther(std::shared_ptr<const Frame> otherFrame);
+
+    template <typename T> bool is() const {
+        return std::dynamic_pointer_cast<const T>(shared_from_this()) != nullptr;
+    }
+
+    // template <typename T> bool               is(){
+    //     return std::dynamic_pointer_cast<T>(shared_from_this()) != nullptr;
+    // }
+
+    template <typename T> std::shared_ptr<T> as() {
+        if(!is<T>()) {
+            throw unsupported_operation_exception("unsupported operation, object's type is not require type");
+        }
+
+        return std::dynamic_pointer_cast<T>(shared_from_this());
+    }
+
+    template <typename T> std::shared_ptr<const T> as() const {
+        if(!is<const T>())
+            throw unsupported_operation_exception("unsupported operation, object's type is not require type");
+
+        return std::dynamic_pointer_cast<const T>(shared_from_this());
+    }
+
+protected:
+    size_t getDataBufSize() const;
+
+protected:
+    size_t                                         dataSize_;
+    uint64_t                                       number_;
+    uint64_t                                       timeStampUsec_;
+    uint64_t                                       systemTimeStampUsec_;
+    uint64_t                                       globalTimeStampUsec_;
+    size_t                                         metadataSize_;
+    uint8_t                                        metadata_[12 + 255];  // standard uvc payload size is 12bytes, add some extra space for metadata
+    std::shared_ptr<IFrameMetadataParserContainer> metadataPhasers_;
+    std::shared_ptr<const StreamProfile>           streamProfile_;
+
+    const OBFrameType type_;  // Determined during construction, it is an inherent property of the object and cannot be changed.
+
+private:
+    uint8_t const         *frameData_;
+    const size_t           dataBufSize_;
+    FrameBufferReclaimFunc bufferReclaimFunc_;
+};
+
+class VideoFrame : public Frame {
+public:
+    VideoFrame(uint8_t *data, size_t dataBufSize, OBFrameType type, FrameBufferReclaimFunc bufferReclaimFunc = nullptr);
+    VideoFrame(uint8_t *data, size_t dataBufSize, FrameBufferReclaimFunc bufferReclaimFunc = nullptr);
+
+    uint32_t getWidth() const;
+    uint32_t getHeight() const;
+    uint32_t getFps() const;
+
+    void     setStride(uint32_t stride);
+    uint32_t getStride() const;
+
+    void        setPixelType(OBPixelType pixelType);
+    OBPixelType getPixelType() const;
+    uint8_t     getPixelAvailableBitSize() const;
+    void        setPixelAvailableBitSize(uint8_t bitSize);
+
+    virtual void copyInfoFromOther(std::shared_ptr<const Frame> sourceFrame) override;
+
+protected:
+    OBPixelType pixelType_;              // 0: depth, 1: disparity for structure light camara， 2： raw phase for tof camara
+    uint8_t     availablePixelBitSize_;  // available bit size of each pixel
+    uint32_t    stride_ = 0;
+};
+
+class ColorFrame : public VideoFrame {
+public:
+    ColorFrame(uint8_t *data, size_t dataBufSize, FrameBufferReclaimFunc bufferReclaimFunc = nullptr);
+};
+
+class DepthFrame : public VideoFrame {
+public:
+    DepthFrame(uint8_t *data, size_t dataBufSize, FrameBufferReclaimFunc bufferReclaimFunc = nullptr);
+
+    void  setValueScale(float valueScale);
+    float getValueScale() const;
+
+    virtual void copyInfoFromOther(std::shared_ptr<const Frame> sourceFrame) override;
+
+private:
+    float valueScale_;
+};
+
+class IRFrame : public VideoFrame {
+public:
+    IRFrame(uint8_t *data, size_t dataBufSize, FrameBufferReclaimFunc bufferReclaimFunc = nullptr, OBFrameType frameType = OB_FRAME_IR);
+};
+
+class IRLeftFrame : public IRFrame {
+public:
+    IRLeftFrame(uint8_t *data, size_t dataBufSize, FrameBufferReclaimFunc bufferReclaimFunc = nullptr);
+};
+
+class IRRightFrame : public IRFrame {
+public:
+    IRRightFrame(uint8_t *data, size_t dataBufSize, FrameBufferReclaimFunc bufferReclaimFunc = nullptr);
+};
+
+class PointsFrame : public Frame {
+public:
+    PointsFrame(uint8_t *data, size_t dataBufSize, FrameBufferReclaimFunc bufferReclaimFunc = nullptr);
+
+    void  setCoordinateValueScale(float valueScale);
+    float getCoordinateValueScale() const;
+
+private:
+    float coordValueScale_;  // coordinate value scale, multiply by this value to get actual coordinate value in mm
+};
+
+class AccelFrame : public Frame {
+public:
+#pragma pack(push, 1)
+    typedef struct {
+        OBAccelValue value;  // Acceleration values in three directions (xyz), unit: g (9.80665 m/s^2)
+        float        temp;   // Temperature in Celsius
+    } Data;
+#pragma pack(pop)
+
+public:
+    AccelFrame(uint8_t *data, size_t dataBufSize, FrameBufferReclaimFunc bufferReclaimFunc = nullptr);
+
+    OBAccelValue value();
+    float        temperature();
+};
+
+class GyroFrame : public Frame {
+public:
+#pragma pack(push, 1)
+    typedef struct {
+        OBGyroValue value;  // Acceleration values ​​in three directions (xyz), unit: dps (degrees per second)
+        float       temp;   // Temperature in Celsius
+    } Data;
+#pragma pack(pop)
+
+public:
+    GyroFrame(uint8_t *data, size_t dataBufSize, FrameBufferReclaimFunc bufferReclaimFunc = nullptr);
+
+    OBGyroValue value();
+    float       temperature();
+};
+
+class FrameSet : public Frame {
+    typedef std::function<bool(void *)> ForeachBack;
+
+public:
+    FrameSet(uint8_t *data, size_t dataBufSize, FrameBufferReclaimFunc bufferReclaimFunc = nullptr);
+    ~FrameSet() noexcept;
+
+    uint32_t getCount() const;
+
+    std::shared_ptr<const Frame> getFrame(OBFrameType frameType) const;
+    std::shared_ptr<const Frame> getFrame(int index) const;
+
+    std::shared_ptr<Frame> getFrameMutable(OBFrameType frameType) const;
+    std::shared_ptr<Frame> getFrameMutable(int index) const;
+
+    // It is recommended to use the rvalue reference interface. If you really need it, you can uncomment the following
+    // void pushFrame(std::shared_ptr<Frame> frame);
+    void pushFrame(std::shared_ptr<const Frame> &&frame);
+    void clearAllFrame();
+
+public:
+    void foreachFrame(ForeachBack foreachBack) const;
+};
+
+}  // namespace libobsensor
+
diff --git a/src/core/frame/FrameBufferManager.cpp b/src/core/frame/FrameBufferManager.cpp
new file mode 100644
index 00000000..7eeb60c9
--- /dev/null
+++ b/src/core/frame/FrameBufferManager.cpp
@@ -0,0 +1,156 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "FrameBufferManager.hpp"
+#include "FrameMemoryPool.hpp"
+
+#include "environment/EnvConfig.hpp"
+#include "exception/ObException.hpp"
+#include "logger/Logger.hpp"
+
+namespace libobsensor {
+
+#define DEFAULT_MAX_FRAME_MEMORY_SIZE ((uint64_t)2 * 1024 * 1024 * 1024)  // 2GB
+
+FrameMemoryAllocator::FrameMemoryAllocator() : maxSizeInByte_(DEFAULT_MAX_FRAME_MEMORY_SIZE), usedSize_(0), logger_(Logger::getInstance()) {
+    auto envConfig = EnvConfig::getInstance();
+
+    if(envConfig->isNodeContained("Memory.MaxFrameBufferSize")) {
+        int frameBufferSize;
+        envConfig->getIntValue("Memory.MaxFrameBufferSize", frameBufferSize);
+        if(frameBufferSize < 100) {
+            LOG_WARN("The frame buffer size you set is too small, will set to 100MB instead");
+            frameBufferSize = 100;
+        }
+        maxSizeInByte_ = static_cast<uint64_t>(frameBufferSize) * 1024 * 1024;  // MB to Byte
+    }
+    LOG_DEBUG("FrameMemoryAllocator created! The max frame memory size has been set to {:.3f}MB", byteToMB(maxSizeInByte_));
+}
+
+FrameMemoryAllocator::~FrameMemoryAllocator() noexcept {
+    if(usedSize_ > 0) {
+        LOG_WARN("FrameMemoryAllocator destroyed while still has memory used! usedSize={0:.3f}MB", byteToMB(usedSize_));
+    }
+}
+
+std::mutex                            FrameMemoryAllocator::instanceMutex_;
+std::weak_ptr<FrameMemoryAllocator>   FrameMemoryAllocator::instanceWeakPtr_;
+std::shared_ptr<FrameMemoryAllocator> FrameMemoryAllocator::getInstance() {
+    std::lock_guard<std::mutex> lock(instanceMutex_);
+    auto                        instance = instanceWeakPtr_.lock();
+    if(!instance) {
+        instance         = std::shared_ptr<FrameMemoryAllocator>(new FrameMemoryAllocator());
+        instanceWeakPtr_ = instance;
+    }
+    return instance;
+}
+
+void FrameMemoryAllocator::setMaxFrameMemorySize(uint64_t sizeInMb) {
+    std::unique_lock<std::mutex> lock(mutex_);
+    maxSizeInByte_ = sizeInMb * 1024 * 1024;
+    if(maxSizeInByte_ < usedSize_) {
+        LOG_WARN("The max frame memory size you set is {:.3f}MB,  less than the current used size, will set to {:.3f}MB instead", byteToMB(maxSizeInByte_),
+                 byteToMB(usedSize_));
+    }
+    if(sizeInMb < 100) {  // 100 MB
+        LOG_WARN("The size you is less than 100MB, size={:.3f}MB, will set to 100MB instead", (double)sizeInMb);
+        maxSizeInByte_ = 100 * 1024 * 1024;
+    }
+    LOG_DEBUG("FrameMemoryAllocator max frame memory size has been set to {:.3f}MB", byteToMB(maxSizeInByte_));
+}
+
+uint8_t *FrameMemoryAllocator::allocate(size_t size) {
+    std::unique_lock<std::mutex> lock(mutex_);
+    if(usedSize_ + size > maxSizeInByte_) {
+        LOG_WARN("FrameMemoryAllocator out of memory! require={0:.3f}MB, total usage: allocated={1:.3f}MB, max limit={2:.3f}MB", byteToMB(size),
+                 byteToMB(usedSize_), byteToMB(maxSizeInByte_));
+        return nullptr;
+    }
+
+    void *ptr = malloc(size);
+    if(ptr == nullptr && reinterpret_cast<uintptr_t>(ptr) == 0xdddddddd) {
+        LOG_ERROR("FrameMemoryAllocator malloc failed! ptr={0:x}", (uintptr_t)ptr);
+    }
+
+    memset(ptr, 0, size);
+    usedSize_ += size;
+    LOG_DEBUG("New frame buffer allocated={0:.3f}MB, total usage: allocated={1:.3f}MB, max limit={2:.3f}MB", byteToMB(size), byteToMB(usedSize_),
+              byteToMB(maxSizeInByte_));
+    return (uint8_t *)ptr;
+}
+
+void FrameMemoryAllocator::deallocate(uint8_t *ptr, size_t size) {
+    std::unique_lock<std::mutex> lock(mutex_);
+    usedSize_ -= size;
+    free(ptr);
+    LOG_DEBUG("Frame buffer released={0:.3f}MB, total usage: allocated={1:.3f}MB, max limit={2:.3f}MB", byteToMB(size), byteToMB(usedSize_),
+              byteToMB(maxSizeInByte_));
+}
+
+FrameBufferManagerBase::FrameBufferManagerBase(size_t frameDataBufferSize, size_t frameObjSize)
+    : frameDataBufferSize_(frameDataBufferSize), frameObjSize_(frameObjSize), frameMemoryAllocator_(FrameMemoryAllocator::getInstance()) {
+    frameTotalSize_ = frameDataBufferSize_ + frameObjSize_ + FRAME_DATA_ALIGN_IN_BYTE
+                      - 1;  // Apply for more FRAME_DATA_ALIGN_IN_BYTE-1 to facilitate offset part of the data address and achieve alignment
+}
+
+FrameBufferManagerBase::~FrameBufferManagerBase() noexcept {
+    std::unique_lock<std::recursive_mutex> lock_(mutex_);
+    while(!availableFrameBuffers_.empty()) {
+        frameMemoryAllocator_->deallocate(availableFrameBuffers_.front(), frameTotalSize_);
+        availableFrameBuffers_.erase(availableFrameBuffers_.begin());
+    }
+    LOG_DEBUG("FrameBufferManagerBase destroyed! manager type:{0},  obj addr:0x{1:x}", typeid(*this).name(), uint64_t(this));
+}
+
+uint8_t *FrameBufferManagerBase::acquireBuffer() {
+    std::unique_lock<std::recursive_mutex> lock_(mutex_);
+    uint8_t                               *bufferPtr = nullptr;
+    if(!availableFrameBuffers_.empty()) {
+        bufferPtr = *availableFrameBuffers_.begin();
+        availableFrameBuffers_.erase(availableFrameBuffers_.begin());
+    }
+    else {
+        bufferPtr = frameMemoryAllocator_->allocate(frameTotalSize_);
+        if(bufferPtr == nullptr) {
+            LOG_WARN("allocBuffer failed! Will retry after release idle memory on FrameMemoryPool");
+            auto memoryPool = FrameMemoryPool::getInstance();
+            memoryPool->freeIdleMemory();
+            bufferPtr = frameMemoryAllocator_->allocate(frameTotalSize_);
+            if(bufferPtr == nullptr) {
+                auto msg = std::string("Alloc frame buffer failed! size=") + std::to_string(frameTotalSize_);
+                LOG_FATAL(msg);
+                throw memory_exception(msg);
+            }
+        }
+    }
+    return bufferPtr;
+}
+
+std::unique_lock<std::recursive_mutex> FrameBufferManagerBase::lockBuffers() {
+    std::unique_lock<std::recursive_mutex> lock_(mutex_);
+    return lock_;
+}
+
+void FrameBufferManagerBase::reclaimBuffer(void *buffer) {
+    std::unique_lock<std::recursive_mutex> lock_(mutex_);
+    availableFrameBuffers_.push_back((uint8_t *)buffer);
+
+    if(availableFrameBuffers_.size() > 100) {
+        // Release the memory in time when there are enough availableFrameBuffers_
+        // The current buffer cannot be deleted directly, which will cause frame destruction and crash.
+        frameMemoryAllocator_->deallocate(availableFrameBuffers_.front(), frameTotalSize_);
+        availableFrameBuffers_.erase(availableFrameBuffers_.begin());
+    }
+}
+
+void FrameBufferManagerBase::releaseIdleBuffer() {
+    std::unique_lock<std::recursive_mutex> lock_(mutex_);
+    while(!availableFrameBuffers_.empty()) {
+        // Release the memory in time when there are enough availableFrameBuffers_
+        // The current buffer cannot be deleted directly, which will cause frame destruction and crash.
+        frameMemoryAllocator_->deallocate(availableFrameBuffers_.front(), frameTotalSize_);
+        availableFrameBuffers_.erase(availableFrameBuffers_.begin());
+    }
+}
+
+}  // namespace libobsensor
diff --git a/src/core/frame/FrameBufferManager.hpp b/src/core/frame/FrameBufferManager.hpp
new file mode 100644
index 00000000..012d396c
--- /dev/null
+++ b/src/core/frame/FrameBufferManager.hpp
@@ -0,0 +1,131 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include <memory>
+#include <mutex>
+#include <vector>
+#include "frame/Frame.hpp"
+#include "logger/Logger.hpp"
+
+#define FRAME_DATA_ALIGN_IN_BYTE 16  // 16-byte alignment
+
+namespace libobsensor {
+
+class FrameMemoryAllocator {
+private:
+    FrameMemoryAllocator();
+    static std::mutex                          instanceMutex_;
+    static std::weak_ptr<FrameMemoryAllocator> instanceWeakPtr_;
+
+public:
+    static std::shared_ptr<FrameMemoryAllocator> getInstance();
+
+    ~FrameMemoryAllocator() noexcept;
+
+    void     setMaxFrameMemorySize(uint64_t sizeInMb);
+    uint8_t *allocate(size_t size);
+    void     deallocate(uint8_t *ptr, size_t size);
+
+private:
+    uint64_t   maxSizeInByte_;
+    uint64_t   usedSize_;
+    std::mutex mutex_;
+
+    std::shared_ptr<Logger> logger_;  // Manages the lifecycle of the logger object.
+};
+
+class IFrameBufferManager {
+public:
+    virtual ~IFrameBufferManager() noexcept {};
+    virtual void   reclaimBuffer(void *buffer) = 0;
+    virtual void   releaseIdleBuffer()         = 0;
+    virtual size_t getFrameDataBufferSize()    = 0;
+
+private:
+    virtual std::shared_ptr<Frame> acquireFrame() = 0;
+    friend class FrameFactory;
+};
+
+inline double byteToMB(uint64_t sizeInByte) {
+    return (double)sizeInByte / 1024.0 / 1024.0;
+}
+
+class FrameBufferManagerBase : public IFrameBufferManager {
+public:
+    FrameBufferManagerBase(size_t frameDataBufferSize, size_t frameObjSize);
+
+    virtual ~FrameBufferManagerBase() noexcept;
+    void   reclaimBuffer(void *buffer) override;
+    void   releaseIdleBuffer() override;
+    size_t getFrameDataBufferSize() override {
+        return frameDataBufferSize_;
+    }
+
+    std::unique_lock<std::recursive_mutex> lockBuffers();
+
+protected:
+    uint8_t *acquireBuffer();
+
+protected:
+    std::recursive_mutex mutex_;
+    size_t               frameDataBufferSize_;
+    size_t               frameObjSize_;
+    size_t               frameTotalSize_;
+
+private:
+    std::vector<uint8_t *>                availableFrameBuffers_;
+    std::shared_ptr<FrameMemoryAllocator> frameMemoryAllocator_;
+};
+
+class FrameMemoryPool;
+template <typename T> class FrameBufferManager : public FrameBufferManagerBase, public std::enable_shared_from_this<FrameBufferManager<T>> {
+private:
+    // Must be created through FrameMemoryPool to ensure that all FrameBufferManager objects are managed by FrameMemoryPool
+    FrameBufferManager(size_t frameDataBufferSize) : FrameBufferManagerBase(frameDataBufferSize, sizeof(T)) {
+        LOG_DEBUG("FrameBufferManager created! frame type:{0}, obj addr:0x{1:x}, frame obj total size:{2:.3f}MB", typeid(T).name(), uint64_t(this),
+                  byteToMB(frameTotalSize_));
+    }
+
+    friend class FrameMemoryPool;
+
+public:
+    virtual ~FrameBufferManager() {
+        LOG_DEBUG("FrameBufferManager destroying...! frame type: {0},  obj addr:0x{1:x}", typeid(T).name(), uint64_t(this));
+    }
+
+private:
+    virtual std::shared_ptr<Frame> acquireFrame() override {
+        uint8_t *bufferPtr = acquireBuffer();
+        if(bufferPtr != nullptr) {
+            static uint16_t align       = FRAME_DATA_ALIGN_IN_BYTE;
+            uint16_t        alignOffset = (align - (uint64_t)(bufferPtr + frameObjSize_) % align) % align;
+
+            // 1. placement new -> new(ptr)Target()
+            // 2. Custom deletion function construction of shared_ptr
+            // 3. You need to pass bufMgr into the smart pointer custom deletion function lambda to add a reference, otherwise bufMgr may be destructed first
+            // when frame->~T(), the memory will be recycled in advance, and the frame destructor will crash.
+            auto bufMgr = this->shared_from_this();
+            return std::shared_ptr<T>(new(bufferPtr) T(bufferPtr + frameObjSize_ + alignOffset, frameDataBufferSize_,
+                                                       [bufMgr, bufferPtr]() {  // Customized frame buffer release function
+                                                           bufMgr->reclaimBuffer(bufferPtr);
+                                                       }),
+                                      [bufMgr](T *frame) mutable {  // Custom shared_pt delete function
+                                          // Purpose of locking: To solve the problem of the buffer being used to create a new frame just after it is returned,
+                                          // causing the subsequent destruction operation of the original frame to modify the new frame and causing the program
+                                          // to crash.
+                                          auto lk = bufMgr->lockBuffers();
+                                          frame->~T();
+                                          lk.unlock();
+                                          bufMgr.reset();
+                                      });
+        }
+        return nullptr;
+    }
+
+    friend class FrameFactory;
+};
+
+}  // namespace libobsensor
+
diff --git a/src/core/frame/FrameFactory.cpp b/src/core/frame/FrameFactory.cpp
new file mode 100644
index 00000000..de4b80af
--- /dev/null
+++ b/src/core/frame/FrameFactory.cpp
@@ -0,0 +1,187 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "FrameFactory.hpp"
+#include "stream/StreamProfile.hpp"
+#include "stream/StreamProfileFactory.hpp"
+#include "FrameMemoryPool.hpp"
+#include "exception/ObException.hpp"
+#include "utils/PublicTypeHelper.hpp"
+
+namespace libobsensor {
+
+std::shared_ptr<Frame> FrameFactory::createFrame(OBFrameType frameType, OBFormat frameFormat, size_t datasize) {
+
+    auto                                 memoryPool    = FrameMemoryPool::getInstance();
+    std::shared_ptr<IFrameBufferManager> bufferManager = memoryPool->createFrameBufferManager(frameType, datasize);
+
+    auto frame = bufferManager->acquireFrame();
+    if(frame == nullptr) {
+        throw libobsensor::memory_exception("Failed to create frame, out of memory or other memory allocation error.");
+    }
+
+    auto streamType = utils::mapFrameTypeToStreamType(frameType);
+    auto sp         = StreamProfileFactory::createStreamProfile(streamType, frameFormat);
+    frame->setStreamProfile(sp);
+    return frame;
+}
+
+std::shared_ptr<Frame> FrameFactory::createFrameFromOtherFrame(std::shared_ptr<const Frame> frame, bool shouldCopyData) {
+    if(frame->is<FrameSet>()) {
+        auto newFrameSet = createFrameSet();
+        auto frameSet    = frame->as<FrameSet>();
+        auto frameCount  = frameSet->getCount();
+        for(uint32_t i = 0; i < frameCount; i++) {
+            std::shared_ptr<const Frame> oldFrame = frameSet->getFrame(i);
+            if(shouldCopyData) {
+                auto newFrame = createFrameFromStreamProfile(oldFrame->getStreamProfile());
+                newFrame->updateData(oldFrame->getData(), oldFrame->getDataSize());
+                newFrame->copyInfoFromOther(oldFrame);
+                newFrameSet->pushFrame(std::move(newFrame));
+            }
+            else {
+                newFrameSet->pushFrame(std::move(oldFrame));
+            }
+        }
+        return newFrameSet;
+    }
+    else {
+        auto newFrame = createFrameFromStreamProfile(frame->getStreamProfile());
+        if(shouldCopyData) {
+            newFrame->updateData(frame->getData(), frame->getDataSize());
+        }
+        newFrame->copyInfoFromOther(frame);
+        return newFrame;
+    }
+}
+
+std::shared_ptr<Frame> FrameFactory::createVideoFrame(OBFrameType frameType, OBFormat frameFormat, uint32_t width, uint32_t height, uint32_t strideBytes) {
+    if(frameType == OB_FRAME_UNKNOWN || frameType == OB_FRAME_ACCEL || frameType == OB_FRAME_GYRO || frameType == OB_FRAME_SET) {
+        throw libobsensor::invalid_value_exception("Invalid frame type for video frame.");
+    }
+
+    std::shared_ptr<IFrameBufferManager> bufferManager;
+    auto                                 memoryPool = FrameMemoryPool::getInstance();
+    size_t                               frameDataSize;
+    if(strideBytes == 0) {
+        strideBytes = utils::calcDefaultStrideBytes(frameFormat, width);
+    }
+    frameDataSize = height * strideBytes;
+    bufferManager = memoryPool->createFrameBufferManager(frameType, frameDataSize);
+
+    auto frame = bufferManager->acquireFrame();
+    if(frame == nullptr) {
+        throw libobsensor::memory_exception("Failed to create frame, out of memory or other memory allocation error.");
+    }
+
+    auto streamType = utils::mapFrameTypeToStreamType(frameType);
+    auto sp         = StreamProfileFactory::createVideoStreamProfile(streamType, frameFormat, width, height, 0);
+    frame->setStreamProfile(sp);
+    frame->as<VideoFrame>()->setStride(strideBytes);
+    return frame;
+}
+
+std::shared_ptr<Frame> FrameFactory::createFrameFromUserBuffer(OBFrameType frameType, OBFormat format, uint8_t *buffer, size_t bufferSize,
+                                                               FrameBufferReclaimFunc bufferReclaimFunc) {
+    std::shared_ptr<Frame>         frame;
+    std::shared_ptr<StreamProfile> sp;
+    switch(frameType) {
+    case OB_FRAME_VIDEO:
+    case OB_FRAME_DEPTH:
+    case OB_FRAME_IR_LEFT:
+    case OB_FRAME_IR_RIGHT:
+    case OB_FRAME_IR:
+    case OB_FRAME_COLOR:
+        return createVideoFrameFromUserBuffer(frameType, format, 0, 0, 0, buffer, bufferSize, bufferReclaimFunc);
+    case OB_FRAME_ACCEL:
+        frame = std::make_shared<AccelFrame>(buffer, bufferSize, bufferReclaimFunc);
+        sp    = StreamProfileFactory::createAccelStreamProfile(OB_ACCEL_FS_2g, OB_SAMPLE_RATE_1_5625_HZ);
+        break;
+    case OB_FRAME_GYRO:
+        frame = std::make_shared<GyroFrame>(buffer, bufferSize, bufferReclaimFunc);
+        sp    = StreamProfileFactory::createGyroStreamProfile(OB_GYRO_FS_16dps, OB_SAMPLE_RATE_1_5625_HZ);
+        break;
+    default:
+        throw libobsensor::invalid_value_exception("Invalid frame type for user frame.");
+        break;
+    }
+
+    frame->setStreamProfile(sp);
+    return frame;
+}
+
+std::shared_ptr<Frame> FrameFactory::createVideoFrameFromUserBuffer(OBFrameType frameType, OBFormat format, uint32_t width, uint32_t height,
+                                                                    uint32_t strideBytes, uint8_t *buffer, size_t bufferSize,
+                                                                    FrameBufferReclaimFunc bufferReclaimFunc) {
+    std::shared_ptr<Frame> frame;
+    switch(frameType) {
+    case OB_FRAME_VIDEO:
+        frame = std::make_shared<VideoFrame>(buffer, bufferSize, frameType, bufferReclaimFunc);
+        break;
+    case OB_FRAME_DEPTH:
+        frame = std::make_shared<DepthFrame>(buffer, bufferSize, bufferReclaimFunc);
+        break;
+    case OB_FRAME_IR_LEFT:
+        frame = std::make_shared<IRLeftFrame>(buffer, bufferSize, bufferReclaimFunc);
+        break;
+    case OB_FRAME_IR_RIGHT:
+        frame = std::make_shared<IRRightFrame>(buffer, bufferSize, bufferReclaimFunc);
+        break;
+    case OB_FRAME_IR:
+        frame = std::make_shared<IRFrame>(buffer, bufferSize, bufferReclaimFunc);
+        break;
+    case OB_FRAME_COLOR:
+        frame = std::make_shared<ColorFrame>(buffer, bufferSize, bufferReclaimFunc);
+        break;
+    default:
+        throw libobsensor::invalid_value_exception("Invalid frame type for video frame.");
+        break;
+    }
+
+    auto streamType = utils::mapFrameTypeToStreamType(frameType);
+    auto sp         = StreamProfileFactory::createVideoStreamProfile(streamType, format, width, height, 0);
+
+    frame->setStreamProfile(sp);
+
+    if(strideBytes == 0) {
+        strideBytes =  utils::calcDefaultStrideBytes(format, width);
+    }
+    frame->as<VideoFrame>()->setStride(strideBytes);
+    if(strideBytes * height > bufferSize) {
+        LOG_WARN("The strideBytes * height is greater than to the bufferSize, it is dangerous to access the buffer!");
+    }
+    return frame;
+}
+
+std::shared_ptr<Frame> FrameFactory::createFrameFromStreamProfile(std::shared_ptr<const StreamProfile> sp) {
+    auto memoryPool    = libobsensor::FrameMemoryPool::getInstance();
+    auto frameType     = utils::mapStreamTypeToFrameType(sp->getType());
+    auto bufferManager = memoryPool->createFrameBufferManager(frameType, sp);
+
+    auto frame = bufferManager->acquireFrame();
+    if(frame == nullptr) {
+        throw libobsensor::memory_exception("Failed to create frame, out of memory or other memory allocation error.");
+    }
+
+    frame->setStreamProfile(sp);
+    return frame;
+}
+
+std::shared_ptr<FrameSet> FrameFactory::createFrameSet() {
+    auto memoryPool            = libobsensor::FrameMemoryPool::getInstance();
+    auto frameSetBufferManager = memoryPool->createFrameBufferManager(OB_FRAME_SET, OB_FRAME_TYPE_COUNT * sizeof(std::shared_ptr<Frame>));
+
+    auto frame = frameSetBufferManager->acquireFrame();
+    if(frame == nullptr) {
+        throw libobsensor::memory_exception("Failed to create frame, out of memory or other memory allocation error.");
+    }
+
+    auto frameSet = std::dynamic_pointer_cast<FrameSet>(frame);
+    if(frameSet == nullptr) {
+        throw libobsensor::invalid_value_exception("Failed to create frame set.");
+    }
+
+    return frameSet;
+}
+
+}  // namespace libobsensor
diff --git a/src/core/frame/FrameFactory.hpp b/src/core/frame/FrameFactory.hpp
new file mode 100644
index 00000000..daf22c1d
--- /dev/null
+++ b/src/core/frame/FrameFactory.hpp
@@ -0,0 +1,27 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include "frame/Frame.hpp"
+
+namespace libobsensor {
+class StreamProfile;
+
+class FrameFactory {
+public:
+    static std::shared_ptr<Frame> createFrame(OBFrameType frameType, OBFormat frameFormat, size_t datasize);
+    static std::shared_ptr<Frame> createVideoFrame(OBFrameType frameType, OBFormat frameFormat, uint32_t width, uint32_t height, uint32_t strideBytes);
+    static std::shared_ptr<Frame> createFrameFromOtherFrame(std::shared_ptr<const Frame> frame, bool shouldCopyData = false);
+
+    static std::shared_ptr<Frame> createFrameFromUserBuffer(OBFrameType frameType, OBFormat format, uint8_t *buffer, size_t bufferSize,
+                                                            FrameBufferReclaimFunc bufferReclaimFunc);
+    static std::shared_ptr<Frame> createVideoFrameFromUserBuffer(OBFrameType frameType, OBFormat format, uint32_t width, uint32_t height, uint32_t strideBytes,
+                                                                 uint8_t *buffer, size_t bufferSize, FrameBufferReclaimFunc bufferReclaimFunc);
+
+    static std::shared_ptr<Frame> createFrameFromStreamProfile(std::shared_ptr<const StreamProfile> sp);
+
+    static std::shared_ptr<FrameSet> createFrameSet();
+};
+}  // namespace libobsensor
+
diff --git a/src/core/frame/FrameMemoryPool.cpp b/src/core/frame/FrameMemoryPool.cpp
new file mode 100644
index 00000000..7351b2fd
--- /dev/null
+++ b/src/core/frame/FrameMemoryPool.cpp
@@ -0,0 +1,152 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "FrameMemoryPool.hpp"
+#include "utils/PublicTypeHelper.hpp"
+#include "stream/StreamProfile.hpp"
+#include <sstream>
+
+namespace libobsensor {
+
+std::mutex                     FrameMemoryPool::instanceMutex_;
+std::weak_ptr<FrameMemoryPool> FrameMemoryPool::instanceWeakPtr_;
+
+std::shared_ptr<FrameMemoryPool> FrameMemoryPool::getInstance() {
+    std::unique_lock<std::mutex> lk(instanceMutex_);
+    auto                         instance = instanceWeakPtr_.lock();
+    if(!instance) {
+        instance         = std::shared_ptr<FrameMemoryPool>(new FrameMemoryPool());
+        instanceWeakPtr_ = instance;
+    }
+    return instance;
+}
+
+void FrameMemoryPool::setMaxFrameMemorySize(uint64_t sizeInMB) {
+    FrameMemoryAllocator::getInstance()->setMaxFrameMemorySize(sizeInMB);
+}
+
+FrameMemoryPool::FrameMemoryPool() : logger_(Logger::getInstance()) {
+    LOG_DEBUG("FrameMemoryPool created!");
+}
+
+FrameMemoryPool::~FrameMemoryPool() noexcept {
+    bufMgrMap_.clear();
+}
+
+std::shared_ptr<IFrameBufferManager> FrameMemoryPool::createFrameBufferManager(OBFrameType type, size_t frameBufferSize) {
+    std::unique_lock<std::mutex> lock(bufMgrMapMutex_);
+    FrameBufferManagerInfo       info = { type, frameBufferSize };
+
+    auto iter = bufMgrMap_.find(info);
+    if(iter != bufMgrMap_.end()) {
+        return iter->second;
+    }
+
+    std::shared_ptr<IFrameBufferManager> frameBufMgr;
+    switch(type) {
+    case OB_FRAME_VIDEO:
+
+        frameBufMgr = std::shared_ptr<FrameBufferManager<VideoFrame>>(new FrameBufferManager<VideoFrame>(frameBufferSize));
+        LOG_DEBUG("VideoFrame bufferManager created!");
+        break;
+    case OB_FRAME_DEPTH:
+        frameBufMgr = std::shared_ptr<FrameBufferManager<DepthFrame>>(new FrameBufferManager<DepthFrame>(frameBufferSize));
+        LOG_DEBUG("DepthFrame bufferManager created!");
+        break;
+    case OB_FRAME_IR_LEFT:
+        frameBufMgr = std::shared_ptr<FrameBufferManager<IRLeftFrame>>(new FrameBufferManager<IRLeftFrame>(frameBufferSize));
+        LOG_DEBUG("IRFrame bufferManager created!");
+        break;
+    case OB_FRAME_IR_RIGHT:
+        frameBufMgr = std::shared_ptr<FrameBufferManager<IRRightFrame>>(new FrameBufferManager<IRRightFrame>(frameBufferSize));
+        LOG_DEBUG("IRFrame bufferManager created!");
+        break;
+    case OB_FRAME_IR:
+        frameBufMgr = std::shared_ptr<FrameBufferManager<IRFrame>>(new FrameBufferManager<IRFrame>(frameBufferSize));
+        LOG_DEBUG("IRFrame bufferManager created!");
+        break;
+    case OB_FRAME_COLOR:
+        frameBufMgr = std::shared_ptr<FrameBufferManager<ColorFrame>>(new FrameBufferManager<ColorFrame>(frameBufferSize));
+        LOG_DEBUG("ColorFrame bufferManager created!");
+        break;
+    case OB_FRAME_GYRO:
+        frameBufMgr = std::shared_ptr<FrameBufferManager<GyroFrame>>(new FrameBufferManager<GyroFrame>(frameBufferSize));
+        LOG_DEBUG("GyroFrame bufferManager created!");
+        break;
+    case OB_FRAME_ACCEL:
+        frameBufMgr = std::shared_ptr<FrameBufferManager<AccelFrame>>(new FrameBufferManager<AccelFrame>(frameBufferSize));
+        LOG_DEBUG("AccelFrame bufferManager created!");
+        break;
+    case OB_FRAME_POINTS:
+        frameBufMgr = std::shared_ptr<FrameBufferManager<PointsFrame>>(new FrameBufferManager<PointsFrame>(frameBufferSize));
+        LOG_DEBUG("PointsFrame bufferManager created!");
+        break;
+    case OB_FRAME_SET:
+        frameBufMgr = std::shared_ptr<FrameBufferManager<FrameSet>>(new FrameBufferManager<FrameSet>(frameBufferSize));
+        LOG_DEBUG("Frameset bufferManager created!");
+        break;
+    default:
+        if(frameBufferSize != 0) {
+            frameBufMgr = std::shared_ptr<FrameBufferManager<Frame>>(new FrameBufferManager<Frame>(frameBufferSize));
+            LOG_DEBUG("Frame bufferManager created!");
+        }
+        else {
+            std::ostringstream oss_msg;
+            oss_msg << "Unsupported Frame Type to create buffer manager! frameType: " << type;
+            throw unsupported_operation_exception(oss_msg.str());
+        }
+        break;
+    }
+
+    bufMgrMap_.insert({ info, frameBufMgr });
+
+    return frameBufMgr;
+}
+
+std::shared_ptr<IFrameBufferManager> FrameMemoryPool::createFrameBufferManager(OBFrameType type, std::shared_ptr<const StreamProfile> streamProfile) {
+    if(streamProfile->is<VideoStreamProfile>()) {
+        auto sp = streamProfile->as<VideoStreamProfile>();
+        return createFrameBufferManager(type, sp->getFormat(), sp->getWidth(), sp->getHeight());
+    }
+    else if(streamProfile->is<AccelStreamProfile>()) {
+        return createFrameBufferManager(type, sizeof(AccelFrame::Data));
+    }
+    else if(streamProfile->is<GyroStreamProfile>()) {
+        return createFrameBufferManager(type, sizeof(GyroFrame::Data));
+    }
+    LOG_WARN("unsupported streamProfile type");
+    return nullptr;
+}
+
+std::shared_ptr<IFrameBufferManager> FrameMemoryPool::createFrameBufferManager(OBFrameType type, OBFormat format, uint32_t width, uint32_t height) {
+    auto frameBufferSize = utils::calcVideoFrameMaxDataSize(format, width, height);
+    return createFrameBufferManager(type, frameBufferSize);
+}
+
+void FrameMemoryPool::freeIdleMemory() {
+    std::unique_lock<std::mutex> lock(bufMgrMapMutex_);
+    auto                         iter = bufMgrMap_.begin();
+    while(iter != bufMgrMap_.end()) {
+        if(iter->second.use_count() == 1) {
+            iter = bufMgrMap_.erase(iter);
+            continue;
+        }
+        iter->second->releaseIdleBuffer();
+        iter++;
+    }
+
+    auto vecIter = bufMgrWeakList_.begin();
+    while(vecIter != bufMgrWeakList_.end()) {
+        if(vecIter->expired()) {
+            vecIter = bufMgrWeakList_.erase(vecIter);
+            continue;
+        }
+        auto bufMgr = vecIter->lock();
+        if(bufMgr) {
+            bufMgr->releaseIdleBuffer();
+        }
+        vecIter++;
+    }
+}
+
+}  // namespace libobsensor
diff --git a/src/core/frame/FrameMemoryPool.hpp b/src/core/frame/FrameMemoryPool.hpp
new file mode 100644
index 00000000..23cfd53d
--- /dev/null
+++ b/src/core/frame/FrameMemoryPool.hpp
@@ -0,0 +1,57 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include <memory>
+#include <functional>
+#include <string>
+#include <map>
+
+#include "FrameBufferManager.hpp"
+#include "logger/Logger.hpp"
+
+namespace libobsensor {
+
+struct FrameBufferManagerInfo {
+    OBFrameType frameType;
+    size_t      maxFrameDataSize;
+};
+
+struct FrameBufferManagerInfoCompare {
+    bool operator()(const FrameBufferManagerInfo &l, const FrameBufferManagerInfo &r) const {
+        if(l.frameType == r.frameType) {
+            return l.maxFrameDataSize < r.maxFrameDataSize;
+        }
+        return l.frameType < r.frameType;
+    }
+};
+
+class FrameMemoryPool : public std::enable_shared_from_this<FrameMemoryPool> {
+private:
+    FrameMemoryPool();
+
+    static std::mutex                     instanceMutex_;
+    static std::weak_ptr<FrameMemoryPool> instanceWeakPtr_;
+
+public:
+    ~FrameMemoryPool() noexcept;
+    static std::shared_ptr<FrameMemoryPool> getInstance();
+    static void                             setMaxFrameMemorySize(uint64_t sizeInMB);
+
+    std::shared_ptr<IFrameBufferManager> createFrameBufferManager(OBFrameType type, size_t frameBufferSize);
+    std::shared_ptr<IFrameBufferManager> createFrameBufferManager(OBFrameType type, std::shared_ptr<const StreamProfile> streamProfile);
+    std::shared_ptr<IFrameBufferManager> createFrameBufferManager(OBFrameType type, OBFormat format, uint32_t width, uint32_t height);
+
+    void freeIdleMemory();
+
+private:
+    std::map<FrameBufferManagerInfo, std::shared_ptr<IFrameBufferManager>, FrameBufferManagerInfoCompare> bufMgrMap_;
+    std::mutex                                                                                            bufMgrMapMutex_;
+    std::vector<std::weak_ptr<IFrameBufferManager>>                                                       bufMgrWeakList_;
+
+    std::shared_ptr<Logger> logger_;  // Manages the lifecycle of the logger object.
+};
+
+}  // namespace libobsensor
+
diff --git a/src/core/frame/FrameQueue.hpp b/src/core/frame/FrameQueue.hpp
new file mode 100644
index 00000000..3ab3dace
--- /dev/null
+++ b/src/core/frame/FrameQueue.hpp
@@ -0,0 +1,154 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include "frame/Frame.hpp"
+
+#include <queue>
+
+namespace libobsensor {
+
+template <typename T = Frame> class FrameQueue {
+public:
+    explicit FrameQueue(size_t capacity) : capacity_(capacity), stoped_(true), stopping_(false), callback_(nullptr), flushing_(false) {}
+
+    ~FrameQueue() noexcept {
+        reset();
+    }
+
+    size_t capacity() const {
+        return capacity_;
+    }
+
+    void resize(size_t capacity) {
+        capacity_ = capacity;
+    }
+
+    size_t size() const {
+        return queue_.size();
+    }
+
+    bool empty() const {
+        return queue_.empty();
+    }
+
+    bool fulled() const {
+        return queue_.size() >= capacity_;
+    }
+
+    bool enqueue(std::shared_ptr<T> frame) {  // returns false if queue is full
+        std::unique_lock<std::mutex> lock(mutex_);
+        if(queue_.size() >= capacity_ || flushing_) {
+            return false;
+        }
+        queue_.push(frame);
+        condition_.notify_all();
+        return true;
+    }
+
+    // blocking methods
+    std::shared_ptr<T> dequeue(uint64_t timeoutMsec = 0) {  // returns nullptr if timeout is reached
+        std::unique_lock<std::mutex> lock(mutex_);
+        if(!queue_.empty()) {
+            auto result = queue_.front();
+            queue_.pop();
+            return result;
+        }
+
+        if(timeoutMsec == 0) {
+            return nullptr;
+        }
+
+        condition_.wait_for(lock, std::chrono::milliseconds(timeoutMsec), [this] { return !queue_.empty(); });
+        if(queue_.empty()) {
+            return nullptr;
+        }
+        auto result = queue_.front();
+        queue_.pop();
+        return result;
+    }
+
+    // async methods
+    void start(std::function<void(std::shared_ptr<T>)> callback) {  // start async dequeue
+        if(isStarted()) {
+            throw libobsensor::wrong_api_call_sequence_exception("FrameQueue have already started!");
+        }
+        callback_      = callback;
+        stoped_        = false;
+        stopping_      = false;
+        flushing_      = false;
+        dequeueThread_ = std::thread([&] {
+            std::unique_lock<std::mutex> lock(mutex_);
+            while(true) {
+                condition_.wait(lock, [this] { return !queue_.empty() || stopping_ || flushing_; });
+                if(stopping_) {
+                    break;
+                }
+                if(flushing_ && queue_.empty()) {
+                    break;
+                }
+                std::shared_ptr<T> frame = queue_.front();
+                queue_.pop();
+                if(frame) {
+                    callback_(frame);
+                }
+            }
+            stoped_ = true;
+        });
+    }
+
+    bool isStarted() const {  // returns true if dequeue thread is running
+        return !stoped_;
+    }
+
+    void flush() {  // stop until all frames are called back
+        {
+            std::unique_lock<std::mutex> lock(mutex_);
+            flushing_ = true;
+            condition_.notify_all();
+        }
+        if(dequeueThread_.joinable()) {
+            dequeueThread_.join();
+        }
+    }
+
+    void stop() {  // stop immediately
+        {
+            std::unique_lock<std::mutex> lock(mutex_);
+            stopping_ = true;
+            condition_.notify_all();
+        }
+        if(dequeueThread_.joinable()) {
+            dequeueThread_.join();
+        }
+
+        std::unique_lock<std::mutex> lock(mutex_);
+        while(!queue_.empty()) {
+            queue_.pop();
+        }
+    }
+
+    // clear all frames in queue, flags, and callback. Stop dequeue thread. reset to initial state.
+    void reset() {
+        stop();  // try stop if it's running, clear all frames on queue
+        callback_ = nullptr;
+        stopping_ = false;
+        flushing_ = false;
+        stoped_   = true;
+    }
+
+private:
+    std::mutex                     mutex_;
+    std::condition_variable        condition_;
+    std::queue<std::shared_ptr<T>> queue_;
+    size_t                         capacity_;
+
+    std::thread                             dequeueThread_;
+    std::atomic<bool>                       stoped_;
+    std::atomic<bool>                       stopping_;
+    std::function<void(std::shared_ptr<T>)> callback_;
+    std::atomic<bool>                       flushing_;
+};
+
+}  // namespace libobsensor
diff --git a/src/core/stream/StreamExtrinsicsManager.cpp b/src/core/stream/StreamExtrinsicsManager.cpp
new file mode 100644
index 00000000..94e4b5e9
--- /dev/null
+++ b/src/core/stream/StreamExtrinsicsManager.cpp
@@ -0,0 +1,448 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "StreamExtrinsicsManager.hpp"
+#include "logger/Logger.hpp"
+#include "exception/ObException.hpp"
+#include "utils/Utils.hpp"
+
+namespace libobsensor {
+
+OBExtrinsic multiplyExtrinsics(const OBExtrinsic &a, const OBExtrinsic &b) {
+    OBExtrinsic result;
+    result.rot[0]   = a.rot[0] * b.rot[0] + a.rot[1] * b.rot[3] + a.rot[2] * b.rot[6];
+    result.rot[1]   = a.rot[0] * b.rot[1] + a.rot[1] * b.rot[4] + a.rot[2] * b.rot[7];
+    result.rot[2]   = a.rot[0] * b.rot[2] + a.rot[1] * b.rot[5] + a.rot[2] * b.rot[8];
+    result.rot[3]   = a.rot[3] * b.rot[0] + a.rot[4] * b.rot[3] + a.rot[5] * b.rot[6];
+    result.rot[4]   = a.rot[3] * b.rot[1] + a.rot[4] * b.rot[4] + a.rot[5] * b.rot[7];
+    result.rot[5]   = a.rot[3] * b.rot[2] + a.rot[4] * b.rot[5] + a.rot[5] * b.rot[8];
+    result.rot[6]   = a.rot[6] * b.rot[0] + a.rot[7] * b.rot[3] + a.rot[8] * b.rot[6];
+    result.rot[7]   = a.rot[6] * b.rot[1] + a.rot[7] * b.rot[4] + a.rot[8] * b.rot[7];
+    result.rot[8]   = a.rot[6] * b.rot[2] + a.rot[7] * b.rot[5] + a.rot[8] * b.rot[8];
+    result.trans[0] = a.trans[0] + a.rot[0] * b.trans[0] + a.rot[1] * b.trans[1] + a.rot[2] * b.trans[2];
+    result.trans[1] = a.trans[1] + a.rot[3] * b.trans[0] + a.rot[4] * b.trans[1] + a.rot[5] * b.trans[2];
+    result.trans[2] = a.trans[2] + a.rot[6] * b.trans[0] + a.rot[7] * b.trans[1] + a.rot[8] * b.trans[2];
+    return result;
+}
+
+OBExtrinsic calculateExtrinsics(const std::vector<std::pair<uint64_t, OBExtrinsic>> &path) {
+    OBExtrinsic extrinsics = IdentityExtrinsics;
+    for(auto &pair: path) {
+        const OBExtrinsic &transform = pair.second;
+        extrinsics                   = multiplyExtrinsics(transform, extrinsics);
+    }
+    return extrinsics;
+}
+
+OBExtrinsic inverseExtrinsics(const OBExtrinsic &extrinsics) {
+    OBExtrinsic invExtrinsic;
+    // Transpose the rotation matrix
+    invExtrinsic.rot[0] = extrinsics.rot[0];
+    invExtrinsic.rot[1] = extrinsics.rot[3];
+    invExtrinsic.rot[2] = extrinsics.rot[6];
+    invExtrinsic.rot[3] = extrinsics.rot[1];
+    invExtrinsic.rot[4] = extrinsics.rot[4];
+    invExtrinsic.rot[5] = extrinsics.rot[7];
+    invExtrinsic.rot[6] = extrinsics.rot[2];
+    invExtrinsic.rot[7] = extrinsics.rot[5];
+    invExtrinsic.rot[8] = extrinsics.rot[8];
+
+    // Calculate the inverse translation vector
+    float invRot[9] = { invExtrinsic.rot[0], invExtrinsic.rot[1], invExtrinsic.rot[2], invExtrinsic.rot[3], invExtrinsic.rot[4],
+                        invExtrinsic.rot[5], invExtrinsic.rot[6], invExtrinsic.rot[7], invExtrinsic.rot[8] };
+
+    invExtrinsic.trans[0] = -invRot[0] * extrinsics.trans[0] - invRot[1] * extrinsics.trans[1] - invRot[2] * extrinsics.trans[2];
+    invExtrinsic.trans[1] = -invRot[3] * extrinsics.trans[0] - invRot[4] * extrinsics.trans[1] - invRot[5] * extrinsics.trans[2];
+    invExtrinsic.trans[2] = -invRot[6] * extrinsics.trans[0] - invRot[7] * extrinsics.trans[1] - invRot[8] * extrinsics.trans[2];
+
+    return invExtrinsic;
+}
+
+std::mutex                               StreamExtrinsicsManager::instanceMutex_;
+std::weak_ptr<StreamExtrinsicsManager>   StreamExtrinsicsManager::instanceWeakPtr_;
+std::shared_ptr<StreamExtrinsicsManager> StreamExtrinsicsManager::getInstance() {
+    std::unique_lock<std::mutex> lock(instanceMutex_);
+    auto                         instance = instanceWeakPtr_.lock();
+    if(!instance) {
+        instance         = std::shared_ptr<StreamExtrinsicsManager>(new StreamExtrinsicsManager());
+        instanceWeakPtr_ = instance;
+    }
+    return instance;
+}
+
+StreamExtrinsicsManager::StreamExtrinsicsManager() {}
+
+StreamExtrinsicsManager::~StreamExtrinsicsManager() noexcept = default;
+
+void StreamExtrinsicsManager::registerExtrinsics(const std::shared_ptr<const StreamProfile> &from, const std::shared_ptr<const StreamProfile> &to,
+                                                 const OBExtrinsic &extrinsics) {
+    if(!from || !to) {
+        throw invalid_value_exception("Invalid stream profile, from or to is null");
+    }
+
+    std::unique_lock<std::recursive_mutex> lock(mutex_);
+    cleanExpiredStreamProfiles();  // clean expired stream profiles first
+
+    // judge if already registered and if the extrinsics is the same
+    bool alreadyRegistered   = false;
+    bool differentExtrinsics = false;
+    try {
+        if(hasExtrinsics(from, to)) {
+            auto tryResult    = getExtrinsics(from, to);  // try to get the extrinsics
+            alreadyRegistered = true;
+            if(memcmp(&tryResult, &extrinsics, sizeof(OBExtrinsic)) != 0) {
+                differentExtrinsics = true;
+            }
+        }
+    }
+    catch(...) {
+        alreadyRegistered = false;
+    }
+
+    // if already registered, and the extrinsics is the same, then return
+    if(alreadyRegistered && !differentExtrinsics) {
+        // LOG_TRACE("Extrinsics already registered, {} to {}", (uint64_t)from.get(), (uint64_t)to.get());
+        return;
+    }
+
+    // judge if the extrinsics is identity
+    bool isIdentityExtrinsics = (memcmp(&extrinsics, &IdentityExtrinsics, sizeof(OBExtrinsic)) == 0);
+
+    // register the extrinsics
+    if(alreadyRegistered) {
+        // if already registered, remove the old one, and then register the new one
+        eraseStreamProfile(from);
+        auto toId = getOrRegisterStreamProfileId(to);
+        if(isIdentityExtrinsics) {
+            // if the extrinsics is identity, we can just push the `from` stream profile to the list of `toId`
+            streamProfileMap_[toId].push_back(std::weak_ptr<const StreamProfile>(from));
+        }
+        else {
+            auto fromId = getOrRegisterStreamProfileId(from);                             // get or create the id of `from`
+            extrinsicsGraph_[fromId].push_back({ toId, extrinsics });                     // add the extrinsics to the graph: from -> to
+            extrinsicsGraph_[toId].push_back({ fromId, inverseExtrinsics(extrinsics) });  // add the inverse extrinsics to the graph: to -> from
+        }
+    }
+    else {
+        // if not registered, just register the new one
+        auto fromId = getStreamProfileId(from);
+        auto toId   = getOrRegisterStreamProfileId(to);
+        if(isIdentityExtrinsics) {
+            if(fromId == 0) {
+                // if is identity extrinsics, and the `from` stream profile is not registered, we can just push the `from` stream profile to the list of `toId`
+                streamProfileMap_[toId].push_back(std::weak_ptr<const StreamProfile>(from));
+            }
+            else {
+                // if is identity extrinsics, and the `from` stream profile is registered, we need to move oll the stream profiles from `fromId` to `toId`
+                auto spList = streamProfileMap_[fromId];
+                for(auto it = spList.begin(); it != spList.end(); ++it) {
+                    streamProfileMap_[toId].push_back(*it);
+                }
+                streamProfileMap_.erase(fromId);
+
+                // after moving the stream profiles, we need to update the extrinsics graph with the new id： `toId`
+                auto &extrPairVec = extrinsicsGraph_[fromId];
+                for(auto &extrPair: extrPairVec) {
+                    auto &toExtrPairVec = extrinsicsGraph_[extrPair.first];
+                    for(auto it = toExtrPairVec.begin(); it != toExtrPairVec.end(); ++it) {
+                        if(it->first == fromId) {
+                            it->first = toId;
+                        }
+                    }
+                }
+                extrinsicsGraph_.erase(fromId);
+            }
+        }
+        else {
+            // if not identity extrinsics, we need to register the extrinsics to the graph
+            if(fromId == 0) {
+                // if the `from` stream profile is not registered, we need to register it first
+                fromId = getOrRegisterStreamProfileId(from);
+            }
+            extrinsicsGraph_[fromId].push_back({ toId, extrinsics });                     // add the extrinsics to the graph: from -> to
+            extrinsicsGraph_[toId].push_back({ fromId, inverseExtrinsics(extrinsics) });  // add the inverse extrinsics to the graph: to -> from
+        }
+    }
+}
+
+void StreamExtrinsicsManager::registerSameExtrinsics(const std::shared_ptr<const StreamProfile> &from, const std::shared_ptr<const StreamProfile> &to) {
+    registerExtrinsics(from, to, IdentityExtrinsics);  // register the identity extrinsics
+}
+
+bool StreamExtrinsicsManager::hasExtrinsics(std::shared_ptr<const StreamProfile> from, std::shared_ptr<const StreamProfile> to) {
+    if(!from || !to) {
+        return false;
+    }
+
+    std::unique_lock<std::recursive_mutex> lock(mutex_);
+    auto                                   fromId = getStreamProfileId(from);
+    if(fromId == 0) {
+        return false;
+    }
+    auto toId = getStreamProfileId(to);
+    if(toId == 0) {
+        return false;
+    }
+
+    if(fromId == toId) {
+        return true;
+    }
+
+    std::vector<std::pair<uint64_t, OBExtrinsic>> path = { { fromId, IdentityExtrinsics } };
+    if(!searchPath(path, fromId, toId)) {
+        return false;
+    }
+
+    return true;
+}
+
+OBExtrinsic StreamExtrinsicsManager::getExtrinsics(std::shared_ptr<const StreamProfile> from, std::shared_ptr<const StreamProfile> to) {
+    if(!from || !to) {
+        throw invalid_value_exception("Invalid stream profile");
+    }
+
+    std::unique_lock<std::recursive_mutex> lock(mutex_);
+    auto                                   fromId = getStreamProfileId(from);
+    if(fromId == 0) {
+        throw invalid_value_exception("From Stream profile not registered!");
+    }
+    auto toId = getStreamProfileId(to);
+    if(toId == 0) {
+        throw invalid_value_exception("To Stream profile not registered!");
+    }
+    if(fromId == toId) {
+        return IdentityExtrinsics;
+    }
+
+    std::vector<std::pair<uint64_t, OBExtrinsic>> path = { { fromId, IdentityExtrinsics } };
+    if(!searchPath(path, fromId, toId)) {
+        throw invalid_value_exception(utils::string::to_string() << "Can not find path to calculate the extrinsics from" << fromId << "to" << toId);
+    }
+
+    // LOG_TRACE("Extrinsics path:");
+    // for(auto iter = path.begin(); iter != path.end(); ++iter) {
+    //     auto target = iter + 1;
+    //     if(target == path.end()) {
+    //         break;
+    //     }
+    //     LOG_TRACE(" - {} -> {} ", iter->first, target->first);
+    // }
+    if(path.size() == 2) {
+        return path[1].second;
+    }
+
+    // Calculate the extrinsics according to the path
+    auto extrinsics = calculateExtrinsics(path);
+
+    // register the extrinsics `from`->`to` directly to avoid redundant calculation
+    // registerExtrinsics(from, to, extrinsics);
+    extrinsicsGraph_[fromId].push_back({ toId, extrinsics });                     // add the extrinsics to the graph: from -> to
+    extrinsicsGraph_[toId].push_back({ fromId, inverseExtrinsics(extrinsics) });  // add the inverse extrinsics to the graph: to -> from
+
+    return extrinsics;
+}
+
+bool StreamExtrinsicsManager::searchPath(std::vector<std::pair<uint64_t, OBExtrinsic>> &path, uint64_t fromId, uint64_t toId) const {
+
+    // LOG_TRACE("searchPath: {} -> {}", fromId, toId);
+    // Check if the from node is directly connected to the to node
+    auto extList = extrinsicsGraph_.at(fromId);
+    for(const auto &extPair: extList) {
+        if(extPair.first == toId) {
+            path.push_back(extPair);
+            return true;
+        }
+    }
+
+    // Recursively search for a path in the subgraph
+    for(const auto &extPair: extList) {
+        auto iter = streamProfileMap_.find(extPair.first);
+        if(iter == streamProfileMap_.end()) {
+            continue;
+        }
+        auto subFromId = iter->first;
+
+        // Check if the subgraph has already been searched
+        bool found = false;
+        for(auto &&item: path) {
+            if(item.first == subFromId) {
+                found = true;
+                break;
+            }
+        }
+        if(found) {
+            continue;
+        }
+
+        // recursively search for a path in the subgraph
+        auto tempPath = path;
+        tempPath.push_back(extPair);
+        if(searchPath(tempPath, subFromId, toId)) {
+            path = tempPath;
+            return true;
+        }
+    }
+    return false;
+}
+
+void StreamExtrinsicsManager::eraseStreamProfile(std::shared_ptr<const StreamProfile> sp) {
+    if(!sp) {
+        return;
+    }
+    auto uid = getStreamProfileId(sp);
+    if(uid == 0) {
+        return;
+    }
+
+    auto spListIter = streamProfileMap_.find(uid);
+    if(spListIter == streamProfileMap_.end()) {
+        return;
+    }
+
+    for(auto iter = spListIter->second.begin(); iter != spListIter->second.end();) {
+        if(iter->lock() == sp) {
+            iter = spListIter->second.erase(iter);
+        }
+        else {
+            ++iter;
+        }
+    }
+
+    // If the list is empty, erase the node
+    if(spListIter->second.empty()) {
+        streamProfileMap_.erase(spListIter);
+        eraseNodeFromExtrinsicsGraph(uid);
+    }
+}
+
+void StreamExtrinsicsManager::eraseNodeFromExtrinsicsGraph(uint64_t id) {
+    for(auto extIter = extrinsicsGraph_.begin(); extIter != extrinsicsGraph_.end();) {
+        if(extIter->first == id) {  // erase the node
+            extIter = extrinsicsGraph_.erase(extIter);
+        }
+        else {  // erase the related edges
+            for(auto iter = extIter->second.begin(); iter != extIter->second.end();) {
+                if(iter->first == id) {
+                    iter = extIter->second.erase(iter);
+                }
+                else {
+                    ++iter;
+                }
+            }
+            ++extIter;
+        }
+    }
+}
+
+void StreamExtrinsicsManager::cleanExpiredStreamProfiles() {
+    for(auto profileEntry = streamProfileMap_.begin(); profileEntry != streamProfileMap_.end();) {
+        auto &profileId            = profileEntry->first;
+        auto &profileSharedPtrList = profileEntry->second;
+        for(auto weakProfileIter = profileSharedPtrList.begin(); weakProfileIter != profileSharedPtrList.end();) {
+            if(weakProfileIter->expired()) {
+                weakProfileIter = profileSharedPtrList.erase(weakProfileIter);
+            }
+            else {
+                ++weakProfileIter;
+            }
+        }
+
+        if(profileSharedPtrList.empty()) {
+            eraseNodeFromExtrinsicsGraph(profileId);
+            profileEntry = streamProfileMap_.erase(profileEntry);
+            continue;
+        }
+
+        if(profileSharedPtrList.size() == 1) {
+            auto iter = extrinsicsGraph_.find(profileId);
+            if(iter == extrinsicsGraph_.end() || iter->second.empty()) {
+                eraseNodeFromExtrinsicsGraph(profileId);
+                profileEntry = streamProfileMap_.erase(profileEntry);
+                continue;
+            }
+        }
+
+        ++profileEntry;
+    }
+}
+
+uint64_t StreamExtrinsicsManager::getStreamProfileId(std::shared_ptr<const StreamProfile> profile) const {
+    for(auto spIter = streamProfileMap_.begin(); spIter != streamProfileMap_.end();) {
+        const auto &spList = spIter->second;
+        for(auto weakSp: spList) {
+            if(weakSp.lock() == profile) {
+                return spIter->first;
+            }
+        }
+        ++spIter;
+    }
+    return 0;  // return 0 if the stream profile is not registered
+}
+
+uint64_t StreamExtrinsicsManager::getOrRegisterStreamProfileId(std::shared_ptr<const StreamProfile> profile) {
+    for(auto spIter = streamProfileMap_.begin(); spIter != streamProfileMap_.end();) {
+        for(auto weakSp: spIter->second) {
+            if(weakSp.lock() == profile) {
+                return spIter->first;
+            }
+        }
+        ++spIter;
+    }
+    uint64_t uid = 1;
+    for(uint64_t i = 1; i < 0xFFFFFFFFFFFFFFFF; ++i) {
+        if(streamProfileMap_.find(i) == streamProfileMap_.end()) {
+            uid = i;  // find a unique id
+            break;
+        }
+    }
+    streamProfileMap_[uid].push_back(std::weak_ptr<const StreamProfile>(profile));
+    return uid;
+}
+
+#if 0
+class unit_test_extrinsics_manager {
+public:
+    unit_test_extrinsics_manager() {
+        // auto ctx = Context::getInstance();
+        auto manager = StreamExtrinsicsManager::getInstance();
+
+        // Using the width as the identifier of the stream profile for print purpose
+        auto sp1 = std::make_shared<VideoStreamProfile>(nullptr, OB_STREAM_VIDEO, OB_FORMAT_YUYV, 1, 0, 0);
+        auto sp2 = std::make_shared<VideoStreamProfile>(nullptr, OB_STREAM_VIDEO, OB_FORMAT_YUYV, 2, 0, 0);
+        auto sp3 = std::make_shared<VideoStreamProfile>(nullptr, OB_STREAM_VIDEO, OB_FORMAT_YUYV, 3, 0, 0);
+        auto sp4 = std::make_shared<VideoStreamProfile>(nullptr, OB_STREAM_VIDEO, OB_FORMAT_YUYV, 4, 0, 0);
+        auto sp5 = std::make_shared<VideoStreamProfile>(nullptr, OB_STREAM_VIDEO, OB_FORMAT_YUYV, 5, 0, 0);
+        auto sp6 = std::make_shared<VideoStreamProfile>(nullptr, OB_STREAM_VIDEO, OB_FORMAT_YUYV, 6, 0, 0);
+        auto sp7 = std::make_shared<VideoStreamProfile>(nullptr, OB_STREAM_VIDEO, OB_FORMAT_YUYV, 7, 0, 0);
+
+        manager->registerExtrinsics(sp1, sp2, { 1, 0, 0, 0, 1, 0, 0, 0, 1, 10, 0, 0 });
+        manager->registerExtrinsics(sp1, sp3, { 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 10, 0 });
+        manager->registerExtrinsics(sp2, sp4, { 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 10 });
+        manager->registerExtrinsics(sp3, sp5, { 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, -8, 0 });
+        manager->registerExtrinsics(sp4, sp6, { 1, 0, 0, 0, 1, 0, 0, 0, 1, -2, 0, -4 });
+        manager->registerSameExtrinsics(sp7, sp6);
+
+        // auto extrinsics12 = manager->getExtrinsics(sp1, sp2);
+        // auto extrinsics13 = manager->getExtrinsics(sp1, sp3);
+        // auto extrinsics24 = manager->getExtrinsics(sp2, sp4);
+        // auto extrinsics35 = manager->getExtrinsics(sp3, sp5);
+        // auto extrinsics46 = manager->getExtrinsics(sp4, sp6);
+        // auto extrinsics16 = manager->getExtrinsics(sp1, sp6);
+        // auto extrinsics61 = manager->getExtrinsics(sp6, sp1);
+        auto extrinsics56 = manager->getExtrinsics(sp5, sp6);
+        std::cout << "extrinsics56: " << extrinsics56.trans[0] << "," << extrinsics56.trans[1] << "," << extrinsics56.trans[2] << std::endl;
+        auto extrinsics65 = manager->getExtrinsics(sp6, sp5);
+        std::cout << "extrinsics65: " << extrinsics65.trans[0] << "," << extrinsics65.trans[1] << "," << extrinsics65.trans[2] << std::endl;
+        auto newExtrinsics56 = manager->getExtrinsics(sp5, sp6);
+        std::cout << "new extrinsics56: " << newExtrinsics56.trans[0] << "," << newExtrinsics56.trans[1] << "," << newExtrinsics56.trans[2] << std::endl;
+        auto extrinsics63 = manager->getExtrinsics(sp6, sp3);
+        std::cout << "extrinsics63: " << extrinsics63.trans[0] << "," << extrinsics63.trans[1] << "," << extrinsics63.trans[2] << std::endl;
+        auto extrinsics57 = manager->getExtrinsics(sp5, sp7);
+        std::cout << "extrinsics57: " << extrinsics57.trans[0] << "," << extrinsics57.trans[1] << "," << extrinsics57.trans[2] << std::endl;
+    }
+};
+
+static unit_test_extrinsics_manager ut;
+#endif
+
+}  // namespace libobsensor
diff --git a/src/core/stream/StreamExtrinsicsManager.hpp b/src/core/stream/StreamExtrinsicsManager.hpp
new file mode 100644
index 00000000..0c8c8277
--- /dev/null
+++ b/src/core/stream/StreamExtrinsicsManager.hpp
@@ -0,0 +1,48 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include "libobsensor/h/ObTypes.h"
+#include "StreamProfile.hpp"
+#include <map>
+#include <memory>
+#include <vector>
+
+namespace libobsensor {
+constexpr OBExtrinsic IdentityExtrinsics = { { 1, 0, 0, 0, 1, 0, 0, 0, 1 }, { 0, 0, 0 } };
+class StreamExtrinsicsManager {
+private:
+    StreamExtrinsicsManager();
+
+    static std::mutex                             instanceMutex_;
+    static std::weak_ptr<StreamExtrinsicsManager> instanceWeakPtr_;
+
+public:
+    static std::shared_ptr<StreamExtrinsicsManager> getInstance();
+
+    ~StreamExtrinsicsManager() noexcept;
+
+    void registerExtrinsics(const std::shared_ptr<const StreamProfile> &from, const std::shared_ptr<const StreamProfile> &to, const OBExtrinsic &extrinsics);
+    void registerSameExtrinsics(const std::shared_ptr<const StreamProfile> &from, const std::shared_ptr<const StreamProfile> &to);
+
+    bool        hasExtrinsics(std::shared_ptr<const StreamProfile> from, std::shared_ptr<const StreamProfile> to);
+    OBExtrinsic getExtrinsics(std::shared_ptr<const StreamProfile> from, std::shared_ptr<const StreamProfile> to);
+
+private:
+    void cleanExpiredStreamProfiles();
+    void eraseStreamProfile(std::shared_ptr<const StreamProfile> sp);
+    void eraseNodeFromExtrinsicsGraph(uint64_t id);
+
+    bool searchPath(std::vector<std::pair<uint64_t, OBExtrinsic>> &path, uint64_t fromId, uint64_t toId) const;
+
+    uint64_t getOrRegisterStreamProfileId(std::shared_ptr<const StreamProfile> profile);
+    uint64_t getStreamProfileId(std::shared_ptr<const StreamProfile> profile) const;
+
+private:
+    std::recursive_mutex                                                mutex_;
+    std::map<uint64_t, std::vector<std::weak_ptr<const StreamProfile>>> streamProfileMap_;  // vertices
+    std::map<uint64_t, std::vector<std::pair<uint64_t, OBExtrinsic>>>   extrinsicsGraph_;   // graph adjacency list
+};
+
+}  // namespace libobsensor
diff --git a/src/core/stream/StreamIntrinsicsManager.cpp b/src/core/stream/StreamIntrinsicsManager.cpp
new file mode 100644
index 00000000..04e96860
--- /dev/null
+++ b/src/core/stream/StreamIntrinsicsManager.cpp
@@ -0,0 +1,308 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "StreamIntrinsicsManager.hpp"
+#include "logger/Logger.hpp"
+
+namespace libobsensor {
+
+std::mutex                             StreamIntrinsicsManager::instanceMutex_;
+std::weak_ptr<StreamIntrinsicsManager> StreamIntrinsicsManager::instanceWeakPtr_;
+
+std::shared_ptr<StreamIntrinsicsManager> StreamIntrinsicsManager::getInstance() {
+    std::unique_lock<std::mutex> lock(instanceMutex_);
+    auto                         instance = instanceWeakPtr_.lock();
+    if(!instance) {
+        instance         = std::shared_ptr<StreamIntrinsicsManager>(new StreamIntrinsicsManager());
+        instanceWeakPtr_ = instance;
+    }
+    return instance;
+}
+
+StreamIntrinsicsManager::StreamIntrinsicsManager() {}
+
+StreamIntrinsicsManager::~StreamIntrinsicsManager() noexcept = default;
+
+void StreamIntrinsicsManager::registerVideoStreamIntrinsics(const std::shared_ptr<const StreamProfile> &profile, const OBCameraIntrinsic &intrinsics) {
+    if(!profile) {
+        throw invalid_value_exception("Input stream profile is null.");
+    }
+    if(!profile->is<const VideoStreamProfile>()) {
+        throw invalid_value_exception("Input stream profile is not a video stream profile.");
+    }
+    std::lock_guard<std::mutex> lock(mutex_);
+    // remove expired stream profiles
+    for(auto it = videoStreamIntrinsicsMap_.begin(); it != videoStreamIntrinsicsMap_.end();) {
+        if(it->first.expired()) {
+            it = videoStreamIntrinsicsMap_.erase(it);
+        }
+        else {
+            it++;
+        }
+    }
+
+    for(auto &pair: videoStreamIntrinsicsMap_) {
+        if(pair.first.lock() == profile) {
+            pair.second = intrinsics;
+            return;
+        }
+    }
+
+    videoStreamIntrinsicsMap_[std::weak_ptr<const StreamProfile>(profile)] = intrinsics;
+}
+
+OBCameraIntrinsic StreamIntrinsicsManager::getVideoStreamIntrinsics(const std::shared_ptr<const StreamProfile> &profile) {
+    if(!profile) {
+        throw invalid_value_exception("Input stream profile is null.");
+    }
+    if(!profile->is<const VideoStreamProfile>()) {
+        throw invalid_value_exception("Input stream profile is not a video stream profile.");
+    }
+
+    std::lock_guard<std::mutex> lock(mutex_);
+    for(const auto &pair: videoStreamIntrinsicsMap_) {
+        if(pair.first.lock() == profile) {
+            return pair.second;
+        }
+    }
+    throw invalid_value_exception("Intrinsics for the input stream profile is not found.");
+}
+
+bool StreamIntrinsicsManager::containsVideoStreamIntrinsics(const std::shared_ptr<const StreamProfile> &profile) {
+    if(!profile) {
+        throw invalid_value_exception("Input stream profile is null.");
+    }
+    if(!profile->is<const VideoStreamProfile>()) {
+        throw invalid_value_exception("Input stream profile is not a video stream profile.");
+    }
+
+    std::lock_guard<std::mutex> lock(mutex_);
+    for(const auto &pair: videoStreamIntrinsicsMap_) {
+        if(pair.first.lock() == profile) {
+            return true;
+        }
+    }
+    return false;
+}
+
+void StreamIntrinsicsManager::registerVideoStreamDistortion(const std::shared_ptr<const StreamProfile> &profile, const OBCameraDistortion &distortion) {
+    if(!profile) {
+        throw invalid_value_exception("Input stream profile is null.");
+    }
+    if(!profile->is<const VideoStreamProfile>()) {
+        throw invalid_value_exception("Input stream profile is not a video stream profile.");
+    }
+    std::lock_guard<std::mutex> lock(mutex_);
+    // remove expired stream profiles
+    for(auto it = videoStreamDistortionMap_.begin(); it != videoStreamDistortionMap_.end();) {
+        if(it->first.expired()) {
+            it = videoStreamDistortionMap_.erase(it);
+        }
+        else {
+            it++;
+        }
+    }
+
+    videoStreamDistortionMap_[std::weak_ptr<const StreamProfile>(profile)] = distortion;
+}
+
+OBCameraDistortion StreamIntrinsicsManager::getVideoStreamDistortion(const std::shared_ptr<const StreamProfile> &profile) {
+    if(!profile) {
+        throw invalid_value_exception("Input stream profile is null.");
+    }
+    if(!profile->is<const VideoStreamProfile>()) {
+        throw invalid_value_exception("Input stream profile is not a video stream profile.");
+    }
+
+    std::lock_guard<std::mutex> lock(mutex_);
+    for(const auto &pair: videoStreamDistortionMap_) {
+        if(pair.first.lock() == profile) {
+            return pair.second;
+        }
+    }
+    throw invalid_value_exception("Distortion for the input stream profile is not found.");
+}
+
+bool StreamIntrinsicsManager::containsVideoStreamDistortion(const std::shared_ptr<const StreamProfile> &profile) {
+    if(!profile) {
+        throw invalid_value_exception("Input stream profile is null.");
+    }
+    if(!profile->is<const VideoStreamProfile>()) {
+        throw invalid_value_exception("Input stream profile is not a video stream profile.");
+    }
+
+    std::lock_guard<std::mutex> lock(mutex_);
+    for(const auto &pair: videoStreamDistortionMap_) {
+        if(pair.first.lock() == profile) {
+            return true;
+        }
+    }
+    return false;
+}
+
+void StreamIntrinsicsManager::registerGyroStreamIntrinsics(const std::shared_ptr<const StreamProfile> &profile, const OBGyroIntrinsic &intrinsics) {
+    if(!profile) {
+        throw invalid_value_exception("Input stream profile is null.");
+    }
+    if(!profile->is<const GyroStreamProfile>()) {
+        throw invalid_value_exception("Input stream profile is not a gyro stream profile.");
+    }
+    std::lock_guard<std::mutex> lock(mutex_);
+    // remove expired stream profiles
+    for(auto it = gyroStreamIntrinsicsMap_.begin(); it != gyroStreamIntrinsicsMap_.end();) {
+        if(it->first.expired()) {
+            it = gyroStreamIntrinsicsMap_.erase(it);
+        }
+        else {
+            it++;
+        }
+    }
+
+    gyroStreamIntrinsicsMap_[std::weak_ptr<const StreamProfile>(profile)] = intrinsics;
+}
+
+OBGyroIntrinsic StreamIntrinsicsManager::getGyroStreamIntrinsics(const std::shared_ptr<const StreamProfile> &profile) {
+    if(!profile) {
+        throw invalid_value_exception("Input stream profile is null.");
+    }
+    if(!profile->is<const GyroStreamProfile>()) {
+        throw invalid_value_exception("Input stream profile is not a gyro stream profile.");
+    }
+
+    std::lock_guard<std::mutex> lock(mutex_);
+    for(const auto &pair: gyroStreamIntrinsicsMap_) {
+        if(pair.first.lock() == profile) {
+            return pair.second;
+        }
+    }
+    throw invalid_value_exception("Intrinsics for the input stream profile is not found.");
+}
+
+bool StreamIntrinsicsManager::containsGyroStreamIntrinsics(const std::shared_ptr<const StreamProfile> &profile) {
+    if(!profile) {
+        throw invalid_value_exception("Input stream profile is null.");
+    }
+    if(!profile->is<const GyroStreamProfile>()) {
+        throw invalid_value_exception("Input stream profile is not a gyro stream profile.");
+    }
+
+    std::lock_guard<std::mutex> lock(mutex_);
+    for(const auto &pair: gyroStreamIntrinsicsMap_) {
+        if(pair.first.lock() == profile) {
+            return true;
+        }
+    }
+    return false;
+}
+
+void StreamIntrinsicsManager::registerAccelStreamIntrinsics(const std::shared_ptr<const StreamProfile> &profile, const OBAccelIntrinsic &intrinsics) {
+    if(!profile) {
+        throw invalid_value_exception("Input stream profile is null.");
+    }
+    if(!profile->is<const AccelStreamProfile>()) {
+        throw invalid_value_exception("Input stream profile is not a accel stream profile.");
+    }
+    std::lock_guard<std::mutex> lock(mutex_);
+    // remove expired stream profiles
+    for(auto it = accelStreamIntrinsicsMap_.begin(); it != accelStreamIntrinsicsMap_.end();) {
+        if(it->first.expired()) {
+            it = accelStreamIntrinsicsMap_.erase(it);
+        }
+        else {
+            ++it;
+        }
+    }
+
+    accelStreamIntrinsicsMap_[std::weak_ptr<const StreamProfile>(profile)] = intrinsics;
+}
+
+OBAccelIntrinsic StreamIntrinsicsManager::getAccelStreamIntrinsics(const std::shared_ptr<const StreamProfile> &profile) {
+    if(!profile) {
+        throw invalid_value_exception("Input stream profile is null.");
+    }
+    if(!profile->is<const AccelStreamProfile>()) {
+        throw invalid_value_exception("Input stream profile is not a accel stream profile.");
+    }
+
+    std::lock_guard<std::mutex> lock(mutex_);
+    for(const auto &pair: accelStreamIntrinsicsMap_) {
+        if(pair.first.lock() == profile) {
+            return pair.second;
+        }
+    }
+    throw invalid_value_exception("Intrinsics for the input stream profile is not found.");
+}
+
+bool StreamIntrinsicsManager::containsAccelStreamIntrinsics(const std::shared_ptr<const StreamProfile> &profile) {
+    if(!profile) {
+        throw invalid_value_exception("Input stream profile is null.");
+    }
+    if(!profile->is<const AccelStreamProfile>()) {
+        throw invalid_value_exception("Input stream profile is not a accel stream profile.");
+    }
+
+    std::lock_guard<std::mutex> lock(mutex_);
+    for(const auto &pair: accelStreamIntrinsicsMap_) {
+        if(pair.first.lock() == profile) {
+            return true;
+        }
+    }
+    return false;
+}
+
+void StreamIntrinsicsManager::registerDisparityBasedStreamDisparityParam(const std::shared_ptr<const StreamProfile> &profile,
+                                                                         const OBDisparityParam                     &disparityParam) {
+    if(!profile) {
+        throw invalid_value_exception("Input stream profile is null.");
+    }
+    if(!profile->is<const DisparityBasedStreamProfile>()) {
+        throw invalid_value_exception("Input stream profile is not a disparity based stream profile.");
+    }
+    std::lock_guard<std::mutex> lock(mutex_);
+    // remove expired stream profiles
+    for(auto it = disparityParamMap_.begin(); it != disparityParamMap_.end();) {
+        if(it->first.expired()) {
+            it = disparityParamMap_.erase(it);
+        }
+        else {
+            ++it;
+        }
+    }
+
+    disparityParamMap_[std::weak_ptr<const StreamProfile>(profile)] = disparityParam;
+}
+
+OBDisparityParam StreamIntrinsicsManager::getDisparityBasedStreamDisparityParam(const std::shared_ptr<const StreamProfile> &profile) {
+    if(!profile) {
+        throw invalid_value_exception("Input stream profile is null.");
+    }
+    if(!profile->is<const DisparityBasedStreamProfile>()) {
+        throw invalid_value_exception("Input stream profile is not a disparity based stream profile.");
+    }
+
+    std::lock_guard<std::mutex> lock(mutex_);
+    for(const auto &pair: disparityParamMap_) {
+        if(pair.first.lock() == profile) {
+            return pair.second;
+        }
+    }
+    throw invalid_value_exception("Disparity parameter for the input stream profile is not found.");
+}
+
+bool StreamIntrinsicsManager::containsDisparityBasedStreamDisparityParam(const std::shared_ptr<const StreamProfile> &profile) {
+    if(!profile) {
+        throw invalid_value_exception("Input stream profile is null.");
+    }
+    if(!profile->is<const DisparityBasedStreamProfile>()) {
+        throw invalid_value_exception("Input stream profile is not a disparity based stream profile.");
+    }
+
+    std::lock_guard<std::mutex> lock(mutex_);
+    for(const auto &pair: disparityParamMap_) {
+        if(pair.first.lock() == profile) {
+            return true;
+        }
+    }
+    return false;
+}
+}  // namespace libobsensor
diff --git a/src/core/stream/StreamIntrinsicsManager.hpp b/src/core/stream/StreamIntrinsicsManager.hpp
new file mode 100644
index 00000000..f72394d8
--- /dev/null
+++ b/src/core/stream/StreamIntrinsicsManager.hpp
@@ -0,0 +1,53 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include "libobsensor/h/ObTypes.h"
+#include "StreamProfile.hpp"
+#include <map>
+#include <memory>
+#include <vector>
+#include <mutex>
+
+namespace libobsensor {
+
+class StreamIntrinsicsManager {
+private:
+    StreamIntrinsicsManager();
+
+    static std::mutex                             instanceMutex_;
+    static std::weak_ptr<StreamIntrinsicsManager> instanceWeakPtr_;
+
+public:
+    static std::shared_ptr<StreamIntrinsicsManager> getInstance();
+
+    ~StreamIntrinsicsManager() noexcept;
+
+    void               registerVideoStreamIntrinsics(const std::shared_ptr<const StreamProfile> &profile, const OBCameraIntrinsic &intrinsics);
+    OBCameraIntrinsic  getVideoStreamIntrinsics(const std::shared_ptr<const StreamProfile> &profile);
+    bool               containsVideoStreamIntrinsics(const std::shared_ptr<const StreamProfile> &profile);
+    void               registerVideoStreamDistortion(const std::shared_ptr<const StreamProfile> &profile, const OBCameraDistortion &distortion);
+    OBCameraDistortion getVideoStreamDistortion(const std::shared_ptr<const StreamProfile> &profile);
+    bool               containsVideoStreamDistortion(const std::shared_ptr<const StreamProfile> &profile);
+    void               registerGyroStreamIntrinsics(const std::shared_ptr<const StreamProfile> &profile, const OBGyroIntrinsic &intrinsics);
+    OBGyroIntrinsic    getGyroStreamIntrinsics(const std::shared_ptr<const StreamProfile> &profile);
+    bool               containsGyroStreamIntrinsics(const std::shared_ptr<const StreamProfile> &profile);
+    void               registerAccelStreamIntrinsics(const std::shared_ptr<const StreamProfile> &profile, const OBAccelIntrinsic &intrinsics);
+    OBAccelIntrinsic   getAccelStreamIntrinsics(const std::shared_ptr<const StreamProfile> &profile);
+    bool               containsAccelStreamIntrinsics(const std::shared_ptr<const StreamProfile> &profile);
+    void               registerDisparityBasedStreamDisparityParam(const std::shared_ptr<const StreamProfile> &profile, const OBDisparityParam &disparityParam);
+    OBDisparityParam   getDisparityBasedStreamDisparityParam(const std::shared_ptr<const StreamProfile> &profile);
+    bool               containsDisparityBasedStreamDisparityParam(const std::shared_ptr<const StreamProfile> &profile);
+
+private:
+    std::mutex mutex_;
+
+    std::map<std::weak_ptr<const StreamProfile>, OBCameraIntrinsic, std::owner_less<std::weak_ptr<const StreamProfile>>>  videoStreamIntrinsicsMap_;
+    std::map<std::weak_ptr<const StreamProfile>, OBCameraDistortion, std::owner_less<std::weak_ptr<const StreamProfile>>> videoStreamDistortionMap_;
+    std::map<std::weak_ptr<const StreamProfile>, OBGyroIntrinsic, std::owner_less<std::weak_ptr<const StreamProfile>>>    gyroStreamIntrinsicsMap_;
+    std::map<std::weak_ptr<const StreamProfile>, OBAccelIntrinsic, std::owner_less<std::weak_ptr<const StreamProfile>>>   accelStreamIntrinsicsMap_;
+    std::map<std::weak_ptr<const StreamProfile>, OBDisparityParam, std::owner_less<std::weak_ptr<const StreamProfile>>>   disparityParamMap_;
+};
+
+}  // namespace libobsensor
diff --git a/src/core/stream/StreamProfile.cpp b/src/core/stream/StreamProfile.cpp
new file mode 100644
index 00000000..1acaa054
--- /dev/null
+++ b/src/core/stream/StreamProfile.cpp
@@ -0,0 +1,318 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "StreamProfile.hpp"
+#include "StreamExtrinsicsManager.hpp"
+#include "StreamIntrinsicsManager.hpp"
+#include "utils/PublicTypeHelper.hpp"
+
+#include "frame/Frame.hpp"
+
+namespace libobsensor {
+
+StreamProfileBackendLifeSpan::StreamProfileBackendLifeSpan()
+    : logger_(Logger::getInstance()), intrinsicsManager_(StreamIntrinsicsManager::getInstance()), extrinsicsManager_(StreamExtrinsicsManager::getInstance()) {}
+
+StreamProfileBackendLifeSpan::~StreamProfileBackendLifeSpan() {
+    intrinsicsManager_.reset();
+    extrinsicsManager_.reset();
+    logger_.reset();
+}
+
+StreamProfile::StreamProfile(std::shared_ptr<LazySensor> owner, OBStreamType type, OBFormat format) : owner_(owner), type_(type), format_(format), index_(0) {}
+
+std::shared_ptr<LazySensor> StreamProfile::getOwner() const {
+    return owner_.lock();
+}
+
+void StreamProfile::bindOwner(std::shared_ptr<LazySensor> owner) {
+    owner_ = owner;
+}
+
+void StreamProfile::setType(OBStreamType type) {
+    type_ = type;
+}
+
+OBStreamType StreamProfile::getType() const {
+    return type_;
+}
+
+void StreamProfile::setFormat(OBFormat format) {
+    format_ = format;
+}
+
+OBFormat StreamProfile::getFormat() const {
+    return format_;
+}
+
+void StreamProfile::setIndex(uint8_t index) {
+    index_ = index;
+}
+
+uint8_t StreamProfile::getIndex() const {
+    return index_;
+}
+
+void StreamProfile::bindExtrinsicTo(std::shared_ptr<const StreamProfile> targetStreamProfile, const OBExtrinsic &extrinsic) {
+    auto extrinsicsMgr = StreamExtrinsicsManager::getInstance();
+    extrinsicsMgr->registerExtrinsics(shared_from_this(), targetStreamProfile, extrinsic);
+}
+
+void StreamProfile::bindSameExtrinsicTo(std::shared_ptr<const StreamProfile> targetStreamProfile) {
+    auto extrinsicsMgr = StreamExtrinsicsManager::getInstance();
+    extrinsicsMgr->registerSameExtrinsics(shared_from_this(), targetStreamProfile);
+}
+
+std::shared_ptr<StreamProfile> StreamProfile::clone() const{
+    auto sp = std::make_shared<StreamProfile>(owner_.lock(), type_, format_);
+    sp->bindSameExtrinsicTo(shared_from_this());
+    return sp;
+}
+
+std::shared_ptr<StreamProfile> StreamProfile::clone(OBFormat newFormat) const {
+    auto newSp = clone();
+    newSp->setFormat(newFormat);
+    return newSp;
+}
+
+OBExtrinsic StreamProfile::getExtrinsicTo(std::shared_ptr<const StreamProfile> targetStreamProfile) const {
+    auto extrinsicsMgr = StreamExtrinsicsManager::getInstance();
+    return extrinsicsMgr->getExtrinsics(shared_from_this(), targetStreamProfile);
+}
+
+std::ostream &StreamProfile::operator<<(std::ostream &os) const {
+    os << "{" << "type: " << type_ << ", format: " << format_ << "}";
+    return os;
+}
+
+VideoStreamProfile::VideoStreamProfile(std::shared_ptr<LazySensor> owner, OBStreamType type, OBFormat format, uint32_t width, uint32_t height, uint32_t fps)
+    : StreamProfile(owner, type, format), width_(width), height_(height), fps_(fps) {}
+
+void VideoStreamProfile::setWidth(uint32_t width) {
+    width_ = width;
+}
+
+uint32_t VideoStreamProfile::getWidth() const {
+    return width_;
+}
+
+void VideoStreamProfile::setHeight(uint32_t height) {
+    height_ = height;
+}
+
+uint32_t VideoStreamProfile::getHeight() const {
+    return height_;
+}
+
+uint32_t VideoStreamProfile::getFps() const {
+    return fps_;
+}
+
+OBCameraIntrinsic VideoStreamProfile::getIntrinsic() const {
+    auto intrinsicsMgr = StreamIntrinsicsManager::getInstance();
+    return intrinsicsMgr->getVideoStreamIntrinsics(shared_from_this());
+}
+
+void VideoStreamProfile::bindIntrinsic(const OBCameraIntrinsic &intrinsic) {
+    auto intrinsicsMgr = StreamIntrinsicsManager::getInstance();
+    intrinsicsMgr->registerVideoStreamIntrinsics(shared_from_this(), intrinsic);
+}
+
+OBCameraDistortion VideoStreamProfile::getDistortion() const {
+    auto intrinsicsMgr = StreamIntrinsicsManager::getInstance();
+    return intrinsicsMgr->getVideoStreamDistortion(shared_from_this());
+}
+
+void VideoStreamProfile::bindDistortion(const OBCameraDistortion &distortion) {
+    auto intrinsicsMgr = StreamIntrinsicsManager::getInstance();
+    intrinsicsMgr->registerVideoStreamDistortion(shared_from_this(), distortion);
+}
+
+uint32_t VideoStreamProfile::getMaxFrameDataSize() const {
+    return utils::calcVideoFrameMaxDataSize(format_, width_, height_);
+}
+
+std::shared_ptr<StreamProfile> VideoStreamProfile::clone() const {
+    auto sp = std::make_shared<VideoStreamProfile>(owner_.lock(), type_, format_, width_, height_, fps_);
+    auto intrinsicsMgr = StreamIntrinsicsManager::getInstance();
+    if(intrinsicsMgr->containsVideoStreamIntrinsics(shared_from_this())) {
+        auto intrinsic = intrinsicsMgr->getVideoStreamIntrinsics(shared_from_this());
+        intrinsicsMgr->registerVideoStreamIntrinsics(sp, intrinsic);
+    }
+    if(intrinsicsMgr->containsVideoStreamDistortion(shared_from_this())) {
+        auto distortion = intrinsicsMgr->getVideoStreamDistortion(shared_from_this());
+        intrinsicsMgr->registerVideoStreamDistortion(sp, distortion);
+    }
+    sp->bindSameExtrinsicTo(shared_from_this());
+    return sp;
+}
+
+DisparityBasedStreamProfile::DisparityBasedStreamProfile(std::shared_ptr<LazySensor> owner, OBStreamType type, OBFormat format, uint32_t width, uint32_t height,
+                                                         uint32_t fps)
+    : VideoStreamProfile(owner, type, format, width, height, fps) {}
+
+OBDisparityParam DisparityBasedStreamProfile::getDisparityParam() const {
+    auto intrinsicsMgr = StreamIntrinsicsManager::getInstance();
+    return intrinsicsMgr->getDisparityBasedStreamDisparityParam(shared_from_this());
+}
+
+void DisparityBasedStreamProfile::bindDisparityParam(const OBDisparityParam &param) {
+    auto intrinsicsMgr = StreamIntrinsicsManager::getInstance();
+    intrinsicsMgr->registerDisparityBasedStreamDisparityParam(shared_from_this(), param);
+}
+
+std::shared_ptr<StreamProfile> DisparityBasedStreamProfile::clone() const {
+    auto sp = std::make_shared<DisparityBasedStreamProfile>(owner_.lock(), type_, format_, width_, height_, fps_);
+    auto intrinsicsMgr = StreamIntrinsicsManager::getInstance();
+    if(intrinsicsMgr->containsVideoStreamIntrinsics(shared_from_this())) {
+        auto intrinsic = intrinsicsMgr->getVideoStreamIntrinsics(shared_from_this());
+        intrinsicsMgr->registerVideoStreamIntrinsics(sp, intrinsic);
+    }
+    if(intrinsicsMgr->containsVideoStreamDistortion(shared_from_this())) {
+        auto distortion = intrinsicsMgr->getVideoStreamDistortion(shared_from_this());
+        intrinsicsMgr->registerVideoStreamDistortion(sp, distortion);
+    }
+    if(intrinsicsMgr->containsDisparityBasedStreamDisparityParam(shared_from_this())) {
+        auto disparityParam = intrinsicsMgr->getDisparityBasedStreamDisparityParam(shared_from_this());
+        intrinsicsMgr->registerDisparityBasedStreamDisparityParam(sp, disparityParam);
+    }
+    sp->bindSameExtrinsicTo(shared_from_this());
+    return sp;
+}
+
+AccelStreamProfile::AccelStreamProfile(std::shared_ptr<LazySensor> owner, OBAccelFullScaleRange fullScaleRange, OBAccelSampleRate sampleRate)
+    : StreamProfile{ owner, OB_STREAM_ACCEL, OB_FORMAT_ACCEL }, fullScaleRange_(fullScaleRange), sampleRate_(sampleRate) {}
+bool VideoStreamProfile::operator==(const VideoStreamProfile &other) const {
+    return (type_ == other.type_) && (format_ == other.format_) && (width_ == other.width_) && (height_ == other.height_) && (fps_ == other.fps_);
+}
+
+std::ostream &VideoStreamProfile::operator<<(std::ostream &os) const {
+    os << "{" << "type: " << type_ << ", format: " << format_ << ", width: " << width_ << ", height: " << height_ << ", fps: " << fps_ << "}";
+    return os;
+}
+
+OBAccelFullScaleRange AccelStreamProfile::getFullScaleRange() const {
+    return fullScaleRange_;
+}
+
+OBAccelSampleRate AccelStreamProfile::getSampleRate() const {
+    return sampleRate_;
+}
+
+void AccelStreamProfile::bindIntrinsic(const OBAccelIntrinsic &intrinsic) {
+    StreamIntrinsicsManager::getInstance()->registerAccelStreamIntrinsics(shared_from_this(), intrinsic);
+}
+
+OBAccelIntrinsic AccelStreamProfile::getIntrinsic() const {
+    return StreamIntrinsicsManager::getInstance()->getAccelStreamIntrinsics(shared_from_this());
+}
+
+std::shared_ptr<StreamProfile> AccelStreamProfile::clone() const {
+    auto sp = std::make_shared<AccelStreamProfile>(owner_.lock(), fullScaleRange_, sampleRate_);
+    auto intrinsicsMgr = StreamIntrinsicsManager::getInstance();
+    if(intrinsicsMgr->containsAccelStreamIntrinsics(shared_from_this())) {
+        auto intrinsic = intrinsicsMgr->getAccelStreamIntrinsics(shared_from_this());
+        intrinsicsMgr->registerAccelStreamIntrinsics(sp, intrinsic);
+    }
+    sp->bindSameExtrinsicTo(shared_from_this());
+    return sp;
+}
+
+std::ostream &AccelStreamProfile::operator<<(std::ostream &os) const {
+    os << "{" << "type: " << type_ << ", format: " << format_ << ", fullScaleRange: " << fullScaleRange_ << ", sampleRate: " << sampleRate_ << "}";
+    return os;
+}
+
+GyroStreamProfile::GyroStreamProfile(std::shared_ptr<LazySensor> owner, OBGyroFullScaleRange fullScaleRange, OBGyroSampleRate sampleRate)
+    : StreamProfile{ owner, OB_STREAM_GYRO, OB_FORMAT_GYRO }, fullScaleRange_(fullScaleRange), sampleRate_(sampleRate) {}
+
+OBGyroFullScaleRange GyroStreamProfile::getFullScaleRange() const {
+    return fullScaleRange_;
+}
+
+OBGyroSampleRate GyroStreamProfile::getSampleRate() const {
+    return sampleRate_;
+}
+
+void GyroStreamProfile::bindIntrinsic(const OBGyroIntrinsic &intrinsic) {
+    auto intrinsicsMgr = StreamIntrinsicsManager::getInstance();
+    intrinsicsMgr->registerGyroStreamIntrinsics(shared_from_this(), intrinsic);
+}
+
+OBGyroIntrinsic GyroStreamProfile::getIntrinsic() const {
+    auto intrinsicsMgr = StreamIntrinsicsManager::getInstance();
+    return intrinsicsMgr->getGyroStreamIntrinsics(shared_from_this());
+}
+
+std::shared_ptr<StreamProfile> GyroStreamProfile::clone() const {
+    auto sp = std::make_shared<GyroStreamProfile>(owner_.lock(), fullScaleRange_, sampleRate_);
+    auto intrinsicsMgr = StreamIntrinsicsManager::getInstance();
+    if(intrinsicsMgr->containsGyroStreamIntrinsics(shared_from_this())) {
+        auto intrinsic = intrinsicsMgr->getGyroStreamIntrinsics(shared_from_this());
+        intrinsicsMgr->registerGyroStreamIntrinsics(sp, intrinsic);
+    }
+    sp->bindSameExtrinsicTo(shared_from_this());
+    return sp;
+}
+
+std::ostream &GyroStreamProfile::operator<<(std::ostream &os) const {
+    os << "{" << "type: " << type_ << ", format: " << format_ << ", fullScaleRange: " << fullScaleRange_ << ", sampleRate: " << sampleRate_ << "}";
+    return os;
+}
+
+std::ostream &operator<<(std::ostream &os, const std::shared_ptr<const StreamProfile> &streamProfile) {
+    return streamProfile->operator<<(os);
+}
+
+std::vector<std::shared_ptr<const VideoStreamProfile>> matchVideoStreamProfile(const StreamProfileList &profileList, uint32_t width, uint32_t height,
+                                                                               uint32_t fps, OBFormat format) {
+    std::vector<std::shared_ptr<const VideoStreamProfile>> matchProfileList;
+    for(auto profile: profileList) {
+        if(profile->is<VideoStreamProfile>()) {
+            auto videoProfile = profile->as<VideoStreamProfile>();
+
+            // Get the profile that matches the user's items of interest
+            if((width == OB_WIDTH_ANY || videoProfile->getWidth() == width) && (height == OB_HEIGHT_ANY || videoProfile->getHeight() == height)
+               && (format == OB_FORMAT_ANY || videoProfile->getFormat() == format) && (fps == OB_FPS_ANY || videoProfile->getFps() == fps)) {
+                matchProfileList.push_back(videoProfile);
+            }
+        }
+    }
+    return matchProfileList;
+}
+
+std::vector<std::shared_ptr<const AccelStreamProfile>> matchAccelStreamProfile(const StreamProfileList &profileList, OBAccelFullScaleRange fullScaleRange,
+                                                                               OBAccelSampleRate sampleRate) {
+    std::vector<std::shared_ptr<const AccelStreamProfile>> matchProfileList;
+    for(auto profile: profileList) {
+        if(profile->is<AccelStreamProfile>()) {
+            auto AccelProfile = profile->as<AccelStreamProfile>();
+
+            // Get the profile that matches the user's items of interest
+            if((fullScaleRange == OB_ACCEL_FULL_SCALE_RANGE_ANY || AccelProfile->getFullScaleRange() == fullScaleRange)
+               && (sampleRate == OB_ACCEL_SAMPLE_RATE_ANY || AccelProfile->getSampleRate() == sampleRate)) {
+                matchProfileList.push_back(AccelProfile);
+            }
+        }
+    }
+    return matchProfileList;
+}
+
+std::vector<std::shared_ptr<const GyroStreamProfile>> matchGyroStreamProfile(const StreamProfileList &profileList, OBGyroFullScaleRange fullScaleRange,
+                                                                             OBGyroSampleRate sampleRate) {
+    std::vector<std::shared_ptr<const GyroStreamProfile>> matchProfileList;
+    for(auto profile: profileList) {
+        if(profile->is<GyroStreamProfile>()) {
+            auto GyroProfile = profile->as<GyroStreamProfile>();
+
+            // Get the profile that matches the user's items of interest
+            if((fullScaleRange == OB_GYRO_FULL_SCALE_RANGE_ANY || GyroProfile->getFullScaleRange() == fullScaleRange)
+               && (sampleRate == OB_GYRO_SAMPLE_RATE_ANY || GyroProfile->getSampleRate() == sampleRate)) {
+                matchProfileList.push_back(GyroProfile);
+            }
+        }
+    }
+    return matchProfileList;
+}
+
+}  // namespace libobsensor
diff --git a/src/core/stream/StreamProfile.hpp b/src/core/stream/StreamProfile.hpp
new file mode 100644
index 00000000..efd3318d
--- /dev/null
+++ b/src/core/stream/StreamProfile.hpp
@@ -0,0 +1,170 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include "IStreamProfile.hpp"
+#include "libobsensor/h/ObTypes.h"
+#include "exception/ObException.hpp"
+#include <memory>
+#include <vector>
+
+namespace libobsensor {
+
+class Logger;
+class StreamIntrinsicsManager;
+class StreamExtrinsicsManager;
+struct LazySensor;
+
+class StreamProfileBackendLifeSpan {
+public:
+    StreamProfileBackendLifeSpan();
+    ~StreamProfileBackendLifeSpan();
+
+private:
+    std::shared_ptr<Logger>                      logger_;
+    std::shared_ptr<StreamIntrinsicsManager>     intrinsicsManager_;
+    std::shared_ptr<StreamExtrinsicsManager>     extrinsicsManager_;
+};
+
+class StreamProfile : public std::enable_shared_from_this<StreamProfile>, private StreamProfileBackendLifeSpan {
+public:
+    StreamProfile(std::shared_ptr<LazySensor> owner, OBStreamType type, OBFormat format);
+
+    virtual ~StreamProfile() noexcept = default;
+
+    std::shared_ptr<LazySensor> getOwner() const;
+
+    void         bindOwner(std::shared_ptr<LazySensor> owner);
+    void         setType(OBStreamType type);
+    OBStreamType getType() const;
+    void         setFormat(OBFormat format);
+    OBFormat     getFormat() const;
+    void         setIndex(uint8_t index);
+    uint8_t      getIndex() const;
+
+    OBExtrinsic getExtrinsicTo(std::shared_ptr<const StreamProfile> targetStreamProfile) const;
+    void        bindExtrinsicTo(std::shared_ptr<const StreamProfile> targetStreamProfile, const OBExtrinsic &extrinsic);
+    void        bindSameExtrinsicTo(std::shared_ptr<const StreamProfile> targetStreamProfile);
+
+    virtual std::shared_ptr<StreamProfile> clone() const;
+    virtual std::shared_ptr<StreamProfile> clone(OBFormat newFormat) const;
+
+    template <typename T> bool               is() const {
+        return std::dynamic_pointer_cast<const T>(shared_from_this()) != nullptr;
+    }
+
+    template <typename T> bool               is() {
+        return std::dynamic_pointer_cast<T>(shared_from_this()) != nullptr;
+    }
+
+    template <typename T> std::shared_ptr<T> as() {
+        if(!is<T>()) {
+            throw unsupported_operation_exception("unsupported operation, object's type is not require type");
+        }
+
+        return std::dynamic_pointer_cast<T>(shared_from_this());
+    }
+
+    template <typename T> std::shared_ptr<const T> as() const {
+        if(!is<const T>()) {
+            throw unsupported_operation_exception("unsupported operation, object's type is not require type");
+        }
+
+        return std::dynamic_pointer_cast<const T>(shared_from_this());
+    }
+
+    virtual std::ostream &operator<<(std::ostream &os) const;
+
+protected:
+    std::weak_ptr<LazySensor> owner_;
+    OBStreamType              type_;
+    OBFormat                  format_;
+    uint8_t                   index_;  // for multi-stream sensor (multi pin uvc device)
+};
+
+class VideoStreamProfile : public StreamProfile {
+public:
+    VideoStreamProfile(std::shared_ptr<LazySensor> owner, OBStreamType type, OBFormat format, uint32_t width, uint32_t height, uint32_t fps);
+    VideoStreamProfile(std::shared_ptr<const VideoStreamProfile> other) = delete;
+
+    ~VideoStreamProfile() noexcept override = default;
+
+    void               setWidth(uint32_t width);
+    uint32_t           getWidth() const;
+    void               setHeight(uint32_t height);
+    uint32_t           getHeight() const;
+    uint32_t           getFps() const;
+    OBCameraIntrinsic  getIntrinsic() const;
+    void               bindIntrinsic(const OBCameraIntrinsic &intrinsic);
+    OBCameraDistortion getDistortion() const;
+    void               bindDistortion(const OBCameraDistortion &distortion);
+    uint32_t           getMaxFrameDataSize() const;
+
+    std::shared_ptr<StreamProfile> clone() const override;
+    bool                           operator==(const VideoStreamProfile &other) const;
+    std::ostream                  &operator<<(std::ostream &os) const override;
+
+protected:
+    uint32_t width_;
+    uint32_t height_;
+    uint32_t fps_;
+};
+
+class DisparityBasedStreamProfile : public VideoStreamProfile {
+public:
+    DisparityBasedStreamProfile(std::shared_ptr<LazySensor> owner, OBStreamType type, OBFormat format, uint32_t width, uint32_t height, uint32_t fps);
+    ~DisparityBasedStreamProfile() noexcept override = default;
+
+    OBDisparityParam getDisparityParam() const;
+    void             bindDisparityParam(const OBDisparityParam &param);
+
+    std::shared_ptr<StreamProfile> clone() const override;
+};
+
+class AccelStreamProfile : public StreamProfile {
+public:
+    AccelStreamProfile(std::shared_ptr<LazySensor> owner, OBAccelFullScaleRange fullScaleRange, OBAccelSampleRate sampleRate);
+    ~AccelStreamProfile() noexcept override = default;
+
+    OBAccelFullScaleRange          getFullScaleRange() const;
+    OBAccelSampleRate              getSampleRate() const;
+    void                           bindIntrinsic(const OBAccelIntrinsic &intrinsic);
+    OBAccelIntrinsic               getIntrinsic() const;
+    std::shared_ptr<StreamProfile> clone() const override;
+    std::ostream                  &operator<<(std::ostream &os) const override;
+
+protected:
+    OBAccelFullScaleRange fullScaleRange_;
+    OBAccelSampleRate     sampleRate_;
+};
+
+class GyroStreamProfile : public StreamProfile {
+public:
+    GyroStreamProfile(std::shared_ptr<LazySensor> owner, OBGyroFullScaleRange fullScaleRange, OBGyroSampleRate sampleRate);
+    ~GyroStreamProfile() noexcept override = default;
+
+    OBGyroFullScaleRange           getFullScaleRange() const;
+    OBGyroSampleRate               getSampleRate() const;
+    void                           bindIntrinsic(const OBGyroIntrinsic &intrinsic);
+    OBGyroIntrinsic                getIntrinsic() const;
+    std::shared_ptr<StreamProfile> clone() const override;
+    std::ostream                  &operator<<(std::ostream &os) const override;
+
+protected:
+    OBGyroFullScaleRange fullScaleRange_;
+    OBGyroSampleRate     sampleRate_;
+};
+
+std::ostream &operator<<(std::ostream &os, const std::shared_ptr<const StreamProfile> &streamProfile);
+
+std::vector<std::shared_ptr<const VideoStreamProfile>> matchVideoStreamProfile(const StreamProfileList &profileList, uint32_t width, uint32_t height,
+                                                                               uint32_t fps, OBFormat format);
+
+std::vector<std::shared_ptr<const AccelStreamProfile>> matchAccelStreamProfile(const StreamProfileList &profileList, OBAccelFullScaleRange fullScaleRange,
+                                                                               OBAccelSampleRate sampleRate);
+
+std::vector<std::shared_ptr<const GyroStreamProfile>> matchGyroStreamProfile(const StreamProfileList &profileList, OBGyroFullScaleRange fullScaleRange,
+                                                                             OBGyroSampleRate sampleRate);
+
+}  // namespace libobsensor
+
diff --git a/src/core/stream/StreamProfileFactory.cpp b/src/core/stream/StreamProfileFactory.cpp
new file mode 100644
index 00000000..a028e111
--- /dev/null
+++ b/src/core/stream/StreamProfileFactory.cpp
@@ -0,0 +1,121 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "StreamProfileFactory.hpp"
+#include "StreamIntrinsicsManager.hpp"
+#include "StreamExtrinsicsManager.hpp"
+#include "exception/ObException.hpp"
+#include "environment/EnvConfig.hpp"
+#include "utils/Utils.hpp"
+
+namespace libobsensor {
+namespace StreamProfileFactory {
+
+std::shared_ptr<StreamProfile> createStreamProfile(OBStreamType streamType) {
+    return createStreamProfile(streamType, OB_FORMAT_ANY);
+}
+
+std::shared_ptr<StreamProfile> createStreamProfile(OBStreamType streamType, OBFormat frameFormat) {
+    switch(streamType) {
+    case OB_STREAM_ACCEL:
+        return createAccelStreamProfile(OB_ACCEL_FULL_SCALE_RANGE_ANY, OB_ACCEL_SAMPLE_RATE_ANY);
+    case OB_STREAM_GYRO:
+        return createGyroStreamProfile(OB_GYRO_FULL_SCALE_RANGE_ANY, OB_GYRO_SAMPLE_RATE_ANY);
+    case OB_STREAM_VIDEO:
+    case OB_STREAM_DEPTH:
+    case OB_STREAM_COLOR:
+    case OB_STREAM_IR:
+    case OB_STREAM_IR_LEFT:
+    case OB_STREAM_IR_RIGHT:
+    case OB_STREAM_RAW_PHASE:
+        return createVideoStreamProfile(streamType, frameFormat, OB_WIDTH_ANY, OB_HEIGHT_ANY, OB_FPS_ANY);
+
+    default:
+        return std::make_shared<StreamProfile>(std::shared_ptr<LazySensor>(), streamType, frameFormat);
+    }
+}
+
+std::shared_ptr<VideoStreamProfile> createVideoStreamProfile(OBStreamType type, OBFormat format, uint32_t width, uint32_t height, uint32_t fps) {
+    return createVideoStreamProfile(std::shared_ptr<LazySensor>(), type, format, width, height, fps);
+}
+
+std::shared_ptr<VideoStreamProfile> createVideoStreamProfile(std::shared_ptr<LazySensor> owner, OBStreamType type, OBFormat format, uint32_t width,
+                                                             uint32_t height, uint32_t fps) {
+    return std::make_shared<VideoStreamProfile>(owner, type, format, width, height, fps);
+}
+
+std::shared_ptr<DisparityBasedStreamProfile> createDisparityBasedStreamProfile(std::shared_ptr<const VideoStreamProfile> videoProfile) {
+    auto vsp           = std::make_shared<DisparityBasedStreamProfile>(videoProfile->getOwner(), videoProfile->getType(), videoProfile->getFormat(),
+                                                                       videoProfile->getWidth(), videoProfile->getHeight(), videoProfile->getFps());
+    auto intrinsicsMgr = StreamIntrinsicsManager::getInstance();
+    if(intrinsicsMgr->containsVideoStreamIntrinsics(videoProfile)) {
+        auto intrinsics = intrinsicsMgr->getVideoStreamIntrinsics(videoProfile);
+        vsp->bindIntrinsic(intrinsics);
+    }
+    if(intrinsicsMgr->containsVideoStreamDistortion(videoProfile)) {
+        auto distortion = intrinsicsMgr->getVideoStreamDistortion(videoProfile);
+        vsp->bindDistortion(distortion);
+    }
+    auto extrinsicsMgr = StreamExtrinsicsManager::getInstance();
+    extrinsicsMgr->registerSameExtrinsics(vsp, videoProfile);
+    return vsp;
+}
+
+std::shared_ptr<AccelStreamProfile> createAccelStreamProfile(OBAccelFullScaleRange fullScaleRange, OBAccelSampleRate sampleRate) {
+    return createAccelStreamProfile(std::shared_ptr<LazySensor>(), fullScaleRange, sampleRate);
+}
+
+std::shared_ptr<AccelStreamProfile> createAccelStreamProfile(std::shared_ptr<LazySensor> owner, OBAccelFullScaleRange fullScaleRange,
+                                                             OBAccelSampleRate sampleRate) {
+    auto asp = std::make_shared<AccelStreamProfile>(owner, fullScaleRange, sampleRate);
+    return asp;
+}
+
+std::shared_ptr<GyroStreamProfile> createGyroStreamProfile(OBGyroFullScaleRange fullScaleRange, OBGyroSampleRate sampleRate) {
+    return createGyroStreamProfile(std::shared_ptr<LazySensor>(), fullScaleRange, sampleRate);
+}
+
+std::shared_ptr<GyroStreamProfile> createGyroStreamProfile(std::shared_ptr<LazySensor> owner, OBGyroFullScaleRange fullScaleRange,
+                                                           OBGyroSampleRate sampleRate) {
+    auto gsp = std::make_shared<GyroStreamProfile>(owner, fullScaleRange, sampleRate);
+    return gsp;
+}
+
+std::shared_ptr<const StreamProfile> getStreamProfileFromEnvConfig(const std::string &nodePathName, OBSensorType sensorType) {
+    auto envConfig = EnvConfig::getInstance();
+
+    auto nodePath = nodePathName + utils::obSensorToStr(sensorType);
+    nodePath      = utils::string::removeSpace(nodePath);
+
+    if(sensorType == OB_SENSOR_ACCEL || sensorType == OB_SENSOR_GYRO) {
+        return nullptr;  // todo: implement it
+    }
+
+    // video stream profile
+    int         w = 0, h = 0, fps = 0;
+    std::string fmt;
+    if(envConfig->getIntValue(nodePath + ".Width", w) && envConfig->getIntValue(nodePath + ".Height", h) && envConfig->getIntValue(nodePath + ".FPS", fps)
+       && envConfig->getStringValue(nodePath + ".Format", fmt)) {
+        auto width      = static_cast<uint32_t>(w);
+        auto height     = static_cast<uint32_t>(h);
+        auto frameRate  = static_cast<uint32_t>(fps);
+        auto format     = utils::strToOBFormat(fmt);
+        auto streamType = utils::mapSensorTypeToStreamType(sensorType);
+        return StreamProfileFactory::createVideoStreamProfile(streamType, format, width, height, frameRate);
+    }
+
+    return nullptr;
+}
+
+std::shared_ptr<const StreamProfile> getDefaultStreamProfileFromEnvConfig(const std::string &deviceName, OBSensorType sensorType, const std::string &tag) {
+    auto        envConfig    = EnvConfig::getInstance();
+    std::string nodePathName = "Device." + deviceName + ".";
+    if(!tag.empty()) {
+        nodePathName += tag;
+        nodePathName += ".";
+    }
+    return getStreamProfileFromEnvConfig(nodePathName, sensorType);
+}
+
+}  // namespace StreamProfileFactory
+}  // namespace libobsensor
diff --git a/src/core/stream/StreamProfileFactory.hpp b/src/core/stream/StreamProfileFactory.hpp
new file mode 100644
index 00000000..f05dc03f
--- /dev/null
+++ b/src/core/stream/StreamProfileFactory.hpp
@@ -0,0 +1,31 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include "StreamProfile.hpp"
+
+namespace libobsensor {
+
+namespace StreamProfileFactory {
+
+std::shared_ptr<StreamProfile> createStreamProfile(OBStreamType type);
+std::shared_ptr<StreamProfile> createStreamProfile(OBStreamType type, OBFormat format);
+
+std::shared_ptr<VideoStreamProfile>          createVideoStreamProfile(OBStreamType type, OBFormat format, uint32_t width, uint32_t height, uint32_t fps);
+std::shared_ptr<VideoStreamProfile>          createVideoStreamProfile(std::shared_ptr<LazySensor> owner, OBStreamType type, OBFormat format, uint32_t width,
+                                                                      uint32_t height, uint32_t fps);
+std::shared_ptr<DisparityBasedStreamProfile> createDisparityBasedStreamProfile(std::shared_ptr<const VideoStreamProfile> videoProfile);
+
+std::shared_ptr<AccelStreamProfile> createAccelStreamProfile(OBAccelFullScaleRange fullScaleRange, OBAccelSampleRate sampleRate);
+std::shared_ptr<AccelStreamProfile> createAccelStreamProfile(std::shared_ptr<LazySensor> owner, OBAccelFullScaleRange fullScaleRange,
+                                                             OBAccelSampleRate sampleRate);
+
+std::shared_ptr<GyroStreamProfile> createGyroStreamProfile(OBGyroFullScaleRange fullScaleRange, OBGyroSampleRate sampleRate);
+std::shared_ptr<GyroStreamProfile> createGyroStreamProfile(std::shared_ptr<LazySensor> owner, OBGyroFullScaleRange fullScaleRange, OBGyroSampleRate sampleRate);
+
+std::shared_ptr<const StreamProfile> getStreamProfileFromEnvConfig(const std::string &nodeName, OBSensorType sensorType);
+std::shared_ptr<const StreamProfile> getDefaultStreamProfileFromEnvConfig(const std::string &deviceName, OBSensorType sensorType, const std::string &tag = "");
+
+}  // namespace StreamProfileFactory
+}  // namespace libobsensor
diff --git a/src/device/CMakeLists.txt b/src/device/CMakeLists.txt
new file mode 100644
index 00000000..87002e57
--- /dev/null
+++ b/src/device/CMakeLists.txt
@@ -0,0 +1,38 @@
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+cmake_minimum_required(VERSION 3.5)
+
+set(OB_TARGET_DEVICE device)
+add_library(${OB_TARGET_DEVICE} STATIC)
+set_target_properties(${OB_TARGET_DEVICE} PROPERTIES VERSION ${PROJECT_VERSION})
+
+file(GLOB SOURCE_FILES ${CMAKE_CURRENT_LIST_DIR}/*.cpp)
+file(GLOB HEADER_FILES ${CMAKE_CURRENT_LIST_DIR}/*.hpp)
+target_sources(${OB_TARGET_DEVICE} PRIVATE ${SOURCE_FILES} ${HEADER_FILES})
+
+target_link_libraries(${OB_TARGET_DEVICE} PUBLIC ob::shared ob::core ob::platform ob::filter)
+target_include_directories(${OB_TARGET_DEVICE} PUBLIC ${OB_PUBLIC_HEADERS_DIR} ${CMAKE_CURRENT_LIST_DIR})
+
+# common:
+add_subdirectory(context)
+add_subdirectory(devicemanager)
+add_subdirectory(protocol)
+add_subdirectory(component)
+
+# devices support:
+add_subdirectory(gemini330) # Gemini 330 series
+add_subdirectory(gemini2) # Gemini 2 series
+add_subdirectory(astra2) # Astra 2 series
+add_subdirectory(femtobolt) # FemtoBolt
+add_subdirectory(femtomega) # FemtoMega
+add_subdirectory(bootloader) # Bootloader device
+
+# dependecies:
+add_subdirectory(${OB_3RDPARTY_DIR}/jsoncpp jsoncpp)
+target_link_libraries(${OB_TARGET_DEVICE} PUBLIC jsoncpp::jsoncpp)
+
+add_library(ob::device ALIAS ${OB_TARGET_DEVICE})
+ob_source_group(ob::device)
+set_target_properties(${OB_TARGET_DEVICE} PROPERTIES FOLDER "modules")
+
diff --git a/src/device/DeviceBase.cpp b/src/device/DeviceBase.cpp
new file mode 100644
index 00000000..034785cd
--- /dev/null
+++ b/src/device/DeviceBase.cpp
@@ -0,0 +1,441 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "DeviceBase.hpp"
+
+#include "utils/Utils.hpp"
+#include "context/Context.hpp"
+#include "exception/ObException.hpp"
+#include "property/InternalProperty.hpp"
+#include "firmwareupdater/FirmwareUpdater.hpp"
+#include "InternalTypes.hpp"
+
+#include <json/json.h>
+
+namespace libobsensor {
+
+const std::map<OBSensorType, DeviceComponentId> SensorTypeToComponentIdMap = {
+    { OB_SENSOR_COLOR, OB_DEV_COMPONENT_COLOR_SENSOR },
+    { OB_SENSOR_DEPTH, OB_DEV_COMPONENT_DEPTH_SENSOR },
+    { OB_SENSOR_IR, OB_DEV_COMPONENT_IR_SENSOR },
+    { OB_SENSOR_IR_LEFT, OB_DEV_COMPONENT_LEFT_IR_SENSOR },
+    { OB_SENSOR_IR_RIGHT, OB_DEV_COMPONENT_RIGHT_IR_SENSOR },
+    { OB_SENSOR_GYRO, OB_DEV_COMPONENT_GYRO_SENSOR },
+    { OB_SENSOR_ACCEL, OB_DEV_COMPONENT_ACCEL_SENSOR },
+};
+
+DeviceBase::DeviceBase(const std::shared_ptr<const IDeviceEnumInfo> &info) : enumInfo_(info), ctx_(Context::getInstance()), isDeactivated_(false) {}
+
+void DeviceBase::fetchDeviceInfo() {
+    auto propServer                   = getPropertyServer();
+    auto version                      = propServer->getStructureDataT<OBVersionInfo>(OB_STRUCT_VERSION);
+    deviceInfo_                       = std::make_shared<DeviceInfo>();
+    deviceInfo_->name_                = version.deviceName;
+    deviceInfo_->fwVersion_           = version.firmwareVersion;
+    deviceInfo_->deviceSn_            = version.serialNumber;
+    deviceInfo_->asicName_            = version.depthChip;
+    deviceInfo_->hwVersion_           = version.hardwareVersion;
+    deviceInfo_->type_                = static_cast<uint16_t>(version.deviceType);
+    deviceInfo_->supportedSdkVersion_ = version.sdkVersion;
+    deviceInfo_->pid_                 = enumInfo_->getPid();
+    deviceInfo_->vid_                 = enumInfo_->getVid();
+    deviceInfo_->uid_                 = enumInfo_->getUid();
+    deviceInfo_->connectionType_      = enumInfo_->getConnectionType();
+
+    // remove the prefix "Orbbec " from the device name if contained
+    if(deviceInfo_->name_.find("Orbbec ") == 0) {
+        deviceInfo_->name_ = deviceInfo_->name_.substr(7);
+    }
+    deviceInfo_->fullName_ = "Orbbec " + deviceInfo_->name_;
+
+    // mark the device as a multi-sensor device with same clock at default
+    extensionInfo_["AllSensorsUsingSameClock"] = "true";
+}
+
+std::shared_ptr<const DeviceInfo> DeviceBase::getInfo() const {
+    return deviceInfo_;
+}
+
+void DeviceBase::fetchExtensionInfo() {
+    auto propServer = getPropertyServer();
+    if(propServer->isPropertySupported(OB_RAW_DATA_DEVICE_EXTENSION_INFORMATION, PROP_OP_READ, PROP_ACCESS_INTERNAL)) {
+        uint8_t *data     = nullptr;
+        uint32_t dataSize = 0;
+        propServer->getRawData(
+            OB_RAW_DATA_DEVICE_EXTENSION_INFORMATION,
+            [&](OBDataTranState state, OBDataChunk *dataChunk) {
+                if(state == DATA_TRAN_STAT_TRANSFERRING) {
+                    if(data == nullptr) {
+                        dataSize = dataChunk->fullDataSize;
+                        data     = new uint8_t[dataSize];
+                    }
+                    memcpy(data + dataChunk->offset, dataChunk->data, dataChunk->size);
+                }
+            },
+            PROP_ACCESS_INTERNAL);
+        if(data) {
+            std::string jsonStr((char *)data);
+            extensionInfo_ = DeviceBase::parseExtensionInfo(jsonStr);
+            delete[] data;
+            data = nullptr;
+        }
+        else {
+            LOG_ERROR("Get ExtensionInfo Data is Null!");
+        }
+    }
+
+    extensionInfo_["AllSensorsUsingSameClock"] = "true";
+}
+
+bool DeviceBase::isExtensionInfoExists(const std::string &infoKey) const {
+    return extensionInfo_.find(infoKey) != extensionInfo_.end();
+}
+
+const std::string &DeviceBase::getExtensionInfo(const std::string &infoKey) const {
+    auto it = extensionInfo_.find(infoKey);
+    if(it != extensionInfo_.end()) {
+        return it->second;
+    }
+    throw invalid_value_exception(utils::string::to_string() << "Extension info " << infoKey << " not found!");
+}
+
+DeviceBase::~DeviceBase() noexcept {
+    deactivate();  // deactivate() will clear all components
+}
+
+void DeviceBase::deactivate() {
+    if(hasAnySensorStreamActivated()) {
+        LOG_WARN("Device is deactivated or disconnected while there are still sensors streaming!");
+    }
+
+    isDeactivated_ = true;
+
+    std::vector<ComponentItem> tempComponents;  // using temp to avoid deadlock when deactivating components
+    {
+        std::lock_guard<std::recursive_mutex> lock(componentsMutex_);
+        tempComponents = components_;
+        components_.clear();
+    }
+    while(!tempComponents.empty()) {
+        // The clear order should be reversed as the order of the components are added.
+        // Otherwise, the dependency between components may be broken and cause crash.
+        tempComponents.erase(tempComponents.end() - 1);
+    }
+    sensorPortInfos_.clear();
+}
+
+void DeviceBase::reboot() {
+    auto propServer = getPropertyServer();
+    if(propServer->isPropertySupported(OB_PROP_DEVICE_RESET_BOOL, PROP_OP_WRITE, PROP_ACCESS_INTERNAL)) {
+        propServer->setPropertyValueT(OB_PROP_DEVICE_RESET_BOOL, true);
+    }
+    else if(propServer->isPropertySupported(OB_PROP_REBOOT_DEVICE_BOOL, PROP_OP_WRITE, PROP_ACCESS_INTERNAL)) {
+        propServer->setPropertyValueT(OB_PROP_REBOOT_DEVICE_BOOL, true);
+    }
+    else {
+        throw invalid_value_exception("Device does not support reboot!");
+    }
+    deactivate();
+}
+
+void DeviceBase::reset() {
+    deactivate();
+    isDeactivated_ = false;
+    init();
+}
+
+DeviceComponentLock DeviceBase::tryLockResource() {
+    if(isDeactivated_) {
+        throw libobsensor::wrong_api_call_sequence_exception("Device is deactivated/disconnected!");
+    }
+    DeviceComponentLock resLock(resourceMutex_, std::defer_lock);
+    if(!resLock.try_lock_for(std::chrono::milliseconds(10000))) {
+        throw libobsensor::wrong_api_call_sequence_exception("Resource busy! You can try again later!");
+    }
+    return resLock;
+}
+
+void DeviceBase::registerComponent(DeviceComponentId compId, std::function<std::shared_ptr<IDeviceComponent>()> creator, bool lockRequired) {
+    std::lock_guard<std::recursive_mutex> lock(componentsMutex_);
+    ComponentItem                         item;
+    item.compId       = compId;
+    item.component    = nullptr;
+    item.lockRequired = lockRequired;
+    item.initialized  = false;
+    item.creator      = creator;
+    components_.emplace_back(item);
+}
+
+void DeviceBase::registerComponent(DeviceComponentId compId, std::shared_ptr<IDeviceComponent> component, bool lockRequired) {
+    std::lock_guard<std::recursive_mutex> lock(componentsMutex_);
+    ComponentItem                         item;
+    item.compId       = compId;
+    item.component    = component;
+    item.lockRequired = lockRequired;
+    item.initialized  = true;
+    item.creator      = nullptr;
+    components_.emplace_back(item);
+}
+
+void DeviceBase::deregisterComponent(DeviceComponentId compId) {
+    std::lock_guard<std::recursive_mutex> lock(componentsMutex_);
+    auto it = std::find_if(components_.begin(), components_.end(), [compId](const ComponentItem &item) { return item.compId == compId; });
+    if(it != components_.end()) {
+        components_.erase(it);
+    }
+}
+
+bool DeviceBase::isComponentExists(DeviceComponentId compId) const {
+    std::lock_guard<std::recursive_mutex> lock(componentsMutex_);
+    auto it = std::find_if(components_.begin(), components_.end(), [compId](const ComponentItem &item) { return item.compId == compId; });
+    if(it != components_.end()) {
+        return true;
+    }
+    return false;
+}
+
+bool DeviceBase::isComponentCreated(DeviceComponentId compId) const {
+    std::lock_guard<std::recursive_mutex> lock(componentsMutex_);
+    auto it = std::find_if(components_.begin(), components_.end(), [compId](const ComponentItem &item) { return item.compId == compId; });
+    if(it != components_.end()) {
+        return it->component != nullptr;
+    }
+    return false;
+}
+
+DeviceComponentPtr<IDeviceComponent> DeviceBase::getComponent(DeviceComponentId compId, bool throwExIfNotFound) {
+    if(isDeactivated_) {
+        throw libobsensor::wrong_api_call_sequence_exception("Device is deactivated/disconnected!");
+    }
+
+    ComponentItem item = { OB_DEV_COMPONENT_UNKNOWN };
+    {
+        std::lock_guard<std::recursive_mutex> lock(componentsMutex_);
+        auto it = std::find_if(components_.begin(), components_.end(), [compId](const ComponentItem &item) { return item.compId == compId; });
+
+        do {
+            if(it == components_.end()) {
+                break;
+            }
+
+            if(!it->component && (it->initialized || !it->creator)) {
+                break;
+            }
+
+            if(!it->component) {
+                it->initialized = true;
+                BEGIN_TRY_EXECUTE({ it->component = it->creator(); })
+                CATCH_EXCEPTION_AND_EXECUTE({
+                    if(throwExIfNotFound) {
+                        throw;
+                    }
+                    return DeviceComponentPtr<IDeviceComponent>();
+                })
+            }
+            item = *it;
+
+        } while(false);
+    }
+
+    if(item.compId != OB_DEV_COMPONENT_UNKNOWN) {
+        if(item.lockRequired) {
+            DeviceComponentLock resLock = tryLockResource();
+            return DeviceComponentPtr<IDeviceComponent>(item.component, std::move(resLock));
+        }
+        return DeviceComponentPtr<IDeviceComponent>(item.component);
+    }
+
+    if(throwExIfNotFound) {
+        throw invalid_value_exception(utils::string::to_string() << "Component " << compId << " not found!");
+    }
+    return DeviceComponentPtr<IDeviceComponent>();
+}
+
+DeviceComponentPtr<IPropertyServer> DeviceBase::getPropertyServer() {
+    return getComponentT<IPropertyServer>(OB_DEV_COMPONENT_PROPERTY_SERVER, true);
+}
+
+void DeviceBase::registerSensorPortInfo(OBSensorType type, std::shared_ptr<const SourcePortInfo> sourcePortInfo) {
+    sensorPortInfos_[type] = sourcePortInfo;
+}
+
+void DeviceBase::deregisterSensor(OBSensorType type) {
+    sensorPortInfos_.erase(type);
+    auto componentId = SensorTypeToComponentIdMap.at(type);
+    deregisterComponent(componentId);
+}
+
+const std::shared_ptr<const SourcePortInfo> &DeviceBase::getSensorPortInfo(OBSensorType type) const {
+    auto it = sensorPortInfos_.find(type);
+    if(it != sensorPortInfos_.end()) {
+        return it->second;
+    }
+    throw invalid_value_exception(utils::string::to_string() << "Sensor type " << type << " not found!");
+}
+
+bool DeviceBase::isSensorExists(OBSensorType type) const {
+    auto it = sensorPortInfos_.find(type);
+    if(it != sensorPortInfos_.end()) {
+        return true;
+    }
+    return false;
+}
+
+bool DeviceBase::isSensorCreated(OBSensorType type) const {
+    auto compId = SensorTypeToComponentIdMap.at(type);
+    return isComponentCreated(compId);
+}
+
+DeviceComponentPtr<ISensor> DeviceBase::getSensor(OBSensorType type) {
+    if(type == OB_SENSOR_IR && !isSensorExists(OB_SENSOR_IR) && isSensorExists(OB_SENSOR_IR_LEFT)) {
+        type = OB_SENSOR_IR_LEFT;
+        LOG_WARN("For stereo camera, dose not support IR sensor, use IR left instead here.");
+    }
+    auto compId = SensorTypeToComponentIdMap.at(type);
+    return getComponentT<ISensor>(compId, true);
+}
+
+std::vector<OBSensorType> DeviceBase::getSensorTypeList() const {
+    std::vector<OBSensorType> sensorTypeList;
+    for(auto &item: sensorPortInfos_) {
+        sensorTypeList.push_back(item.first);
+    }
+    return sensorTypeList;
+}
+
+bool DeviceBase::hasAnySensorStreamActivated() {
+    for(auto &item: sensorPortInfos_) {
+        if(isSensorCreated(item.first)) {
+            auto sensor = getSensor(item.first);
+            if(sensor && sensor->isStreamActivated()) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+
+std::vector<std::shared_ptr<IFilter>> DeviceBase::createRecommendedPostProcessingFilters(OBSensorType type) {
+    if(type == OB_SENSOR_DEPTH) {
+        auto                                  filterFactory = FilterFactory::getInstance();
+        std::vector<std::shared_ptr<IFilter>> depthFilterList;
+        if(filterFactory->isFilterCreatorExists("ThresholdFilter")) {
+            auto ThresholdFilter = filterFactory->createFilter("ThresholdFilter");
+            depthFilterList.push_back(ThresholdFilter);
+        }
+        return depthFilterList;
+    }
+    return {};
+}
+
+std::shared_ptr<IFilter> DeviceBase::getSensorFrameFilter(const std::string &name, OBSensorType type, bool throwIfNotFound) {
+    auto filterIter =
+        std::find_if(sensorFrameFilters_.begin(), sensorFrameFilters_.end(), [name, type](const std::pair<OBSensorType, std::shared_ptr<IFilter>> &pair) {
+            if(type == OB_SENSOR_ACCEL || type == OB_SENSOR_GYRO) {
+                return (pair.first == OB_SENSOR_ACCEL || pair.first == OB_SENSOR_GYRO) && (pair.second->getName() == name);
+            }
+            else {
+                return (pair.first == type) && (pair.second->getName() == name);
+            }
+        });
+
+    if(filterIter != sensorFrameFilters_.end()) {
+        return filterIter->second;
+    }
+
+    auto filterFactory = FilterFactory::getInstance();
+    TRY_EXECUTE({
+        auto filter               = filterFactory->createFilter(name);
+        sensorFrameFilters_[type] = filter;
+        return filter;
+    });
+
+    if(throwIfNotFound) {
+        throw invalid_value_exception(utils::string::to_string() << "Filter " << name << " not found!");
+    }
+
+    return nullptr;
+}
+
+int DeviceBase::getFirmwareVersionInt() {
+    int    dotCount     = 0;
+    char   buf[16]      = { 0 };
+    size_t bufIndex     = 0;
+    int    calFwVersion = 0;
+    for(size_t i = 0; i < deviceInfo_->fwVersion_.size(); i++) {
+        const char c = deviceInfo_->fwVersion_[i];
+        if(isdigit(c) && bufIndex < sizeof(buf)) {
+            buf[bufIndex] = c;
+            bufIndex++;
+        }
+        if('.' == c) {
+            buf[sizeof(buf) - 1] = '\0';
+            if(strlen(buf) > 0) {
+                int value = atoi(buf);
+                // The version number has only two digits
+                if(value >= 100) {
+                    LOG_ERROR("bad fwVersion: {}", deviceInfo_->fwVersion_);
+                    return false;
+                }
+
+                if(dotCount == 0) {  // Major version number
+                    calFwVersion += 10000 * value;
+                }
+                else if(dotCount == 1) {  // minor version number
+                    calFwVersion += 100 * value;
+                }
+                else {
+                    LOG_ERROR("bad fwVersion: {}", deviceInfo_->fwVersion_);
+                    return false;
+                }
+
+                dotCount++;
+                bufIndex = 0;
+                memset(buf, 0, sizeof(buf));
+            }
+        }
+    }
+
+    // Test version number
+    buf[sizeof(buf) - 1] = '\0';
+    if(strlen(buf) > 0 && strlen(buf) <= 2 && dotCount == 2) {
+        int value = atoi(buf);
+        calFwVersion += value;
+    }
+
+    // If the version number cannot be determined, then fix logic is given priority
+    if(calFwVersion == 0 || dotCount < 2) {
+        LOG_ERROR("bad fwVersion: {}, parse digital version failed", deviceInfo_->fwVersion_);
+        return 0;
+    }
+    return calFwVersion;
+}
+
+void DeviceBase::updateFirmware(const std::vector<uint8_t> &firmware, DeviceFwUpdateCallback updateCallback, bool async) {
+    if(hasAnySensorStreamActivated()) {
+        throw libobsensor::wrong_api_call_sequence_exception("Device is streaming, please stop all sensors before updating firmware!");
+    }
+
+    auto updater = getComponentT<FirmwareUpdater>(OB_DEV_COMPONENT_FIRMWARE_UPDATER, true);
+    updater->updateFirmwareFromRawDataExt(firmware.data(), static_cast<uint32_t>(firmware.size()), updateCallback, async);
+}
+
+std::map<std::string, std::string> DeviceBase::parseExtensionInfo(std::string extensionInfo) {
+    Json::Value                        root;
+    Json::Reader                       reader;
+    std::map<std::string, std::string> dataMap;
+    bool                               parseResult = reader.parse(extensionInfo, root);
+    if(!parseResult) {
+        LOG_ERROR("parse extensioninfo failed");
+    }
+    else {
+        Json::Value extensionInfos = root["ExtensionInfo"];
+        for(auto const &key: extensionInfos.getMemberNames()) {
+            dataMap[key] = extensionInfos[key].asString();
+            LOG_INFO("key: {},value:{}", key, extensionInfos[key].asString());
+        }
+    }
+    return dataMap;
+}
+
+}  // namespace libobsensor
diff --git a/src/device/DeviceBase.hpp b/src/device/DeviceBase.hpp
new file mode 100644
index 00000000..449fa166
--- /dev/null
+++ b/src/device/DeviceBase.hpp
@@ -0,0 +1,89 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include "IDevice.hpp"
+#include "IDeviceManager.hpp"
+
+#include <memory>
+#include <map>
+
+namespace libobsensor {
+
+class Context;
+
+class DeviceBase : public IDevice {
+private:
+    struct ComponentItem {
+        DeviceComponentId                                  compId;
+        std::shared_ptr<IDeviceComponent>                  component;  // If is nullptr, try to create it
+        std::function<std::shared_ptr<IDeviceComponent>()> creator;    // lazy creation
+        bool                                               initialized;
+        bool                                               lockRequired;
+    };
+
+public:
+    DeviceBase(const std::shared_ptr<const IDeviceEnumInfo> &info);
+    virtual ~DeviceBase() noexcept;
+
+    void reset() override;
+    void reboot() override;
+    void deactivate() override;
+
+    std::shared_ptr<const DeviceInfo> getInfo() const override;
+    const std::string                &getExtensionInfo(const std::string &infoKey) const override;
+    bool                              isExtensionInfoExists(const std::string &infoKey) const override;
+
+    void registerComponent(DeviceComponentId compId, std::function<std::shared_ptr<IDeviceComponent>()> creator, bool lockRequired = false);
+    void registerComponent(DeviceComponentId compId, std::shared_ptr<IDeviceComponent> component, bool lockRequired = false);
+    void deregisterComponent(DeviceComponentId compId);
+    bool isComponentExists(DeviceComponentId compId) const override;
+    bool isComponentCreated(DeviceComponentId compId) const override;  // for lazy creation
+    DeviceComponentPtr<IDeviceComponent> getComponent(DeviceComponentId compId, bool throwExIfNotFound = true) override;
+
+    void                                         registerSensorPortInfo(OBSensorType type, std::shared_ptr<const SourcePortInfo> sourcePortInfo);
+    void                                         deregisterSensor(OBSensorType type);
+    const std::shared_ptr<const SourcePortInfo> &getSensorPortInfo(OBSensorType type) const;
+    bool                                         isSensorExists(OBSensorType type) const override;
+    bool                                         isSensorCreated(OBSensorType type) const override;  // for lazy creation
+    DeviceComponentPtr<ISensor>                  getSensor(OBSensorType type) override;
+    std::vector<OBSensorType>                    getSensorTypeList() const override;
+    bool                                         hasAnySensorStreamActivated() override;
+
+    std::vector<std::shared_ptr<IFilter>> createRecommendedPostProcessingFilters(OBSensorType type) override;
+    std::shared_ptr<IFilter>              getSensorFrameFilter(const std::string &name, OBSensorType type, bool throwIfNotFound = true) override;
+
+    DeviceComponentPtr<IPropertyServer> getPropertyServer() override;
+
+    void                                      updateFirmware(const std::vector<uint8_t> &firmware, DeviceFwUpdateCallback updateCallback, bool async) override;
+    static std::map<std::string, std::string> parseExtensionInfo(std::string extensionInfo);
+
+protected:
+    // implement on subclass, and must be called to initialize the device info on construction
+    virtual void        fetchDeviceInfo();
+    virtual void        fetchExtensionInfo();
+    DeviceComponentLock tryLockResource();
+    int                 getFirmwareVersionInt();
+
+protected:
+    const std::shared_ptr<const IDeviceEnumInfo> enumInfo_;
+    std::shared_ptr<DeviceInfo>                  deviceInfo_;
+    std::shared_ptr<NetDeviceInfo>               netDeviceInfo_;
+    std::map<std::string, std::string>           extensionInfo_;
+
+private:
+    std::shared_ptr<Context> ctx_;  // handle the lifespan of the context
+
+    std::recursive_timed_mutex   resourceMutex_;
+    mutable std::recursive_mutex componentsMutex_;
+    std::vector<ComponentItem>   components_;  // using vector to control destroy order of components
+
+    std::atomic<bool> isDeactivated_;
+
+    std::map<OBSensorType, std::shared_ptr<const SourcePortInfo>> sensorPortInfos_;
+    std::map<OBSensorType, std::shared_ptr<IFilter>>              sensorFrameFilters_;
+};
+
+}  // namespace libobsensor
+
diff --git a/src/device/DevicePids.hpp b/src/device/DevicePids.hpp
new file mode 100644
index 00000000..8cb8abd5
--- /dev/null
+++ b/src/device/DevicePids.hpp
@@ -0,0 +1,67 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include <vector>
+
+namespace libobsensor {
+const std::vector<uint16_t> BootDevPids = {
+    0x0501,  // bootloader
+    0x0300,  // openni bootloader
+    0x0301,  // openni bootloader
+    0x0400,  // openni Mx400/Mx600 bootloader
+};
+
+const std::vector<uint16_t> Astra2DevPids = {
+    0x0660,  // astra2
+};
+
+const std::vector<uint16_t> G330DevPids = {
+    0x06d0,  // Gemini 2R
+    0x06d1,  // Gemini 2RL
+    0x0800,  // Gemini 335 / 335e
+    0x0801,  // Gemini 330
+    0x0802,  // Gemini dm330
+    0x0803,  // Gemini 336 / 336e
+    0x0804,  // Gemini 335L
+    0x0805,  // Gemini 330L
+    0x0806,  // Gemini dm330L
+    0x0807,  // Gemini 336L
+    0x080B,  // Gemini 335Lg
+    0x080C,  // Gemini 330Lg
+    0x080D,  // Gemini 336Lg
+    0x080E,  // Gemini 335Le
+    0x080F,  // Gemini 330Le
+    0x0810,  // Gemini 336Le
+};
+
+const std::vector<uint16_t> G330LDevPids = {
+    0x06d1,  // Gemini 2RL
+    0x0804,  // Gemini 335L
+    0x0805,  // Gemini 330L
+    0x0806,  // Gemini dm330L
+    0x0807,  // Gemini 336L
+    0x080B,  // Gemini 335Lg
+    0x080C,  // Gemini 330Lg
+    0x080D,  // Gemini 336Lg
+    0x080E,  // Gemini 335Le
+    0x080F,  // Gemini 330Le
+    0x0810,  // Gemini 336Le
+};
+
+const std::vector<uint16_t> Gemini2DevPids = {
+    0x0670,  // Gemini2
+    0x0673,  // Gemini2L
+    // 0x0671,  // Gemini2XL // remove g2xl support temporarily as it is currently not fully supported
+};
+
+const std::vector<uint16_t> FemtoMegaDevPids = {
+    0x0669,  // Femto Mega
+    0x06c0,  // Femto Mega i
+};
+#define OB_FEMTO_MEGA_PID 0x0669
+
+const std::vector<uint16_t> FemtoBoltDevPids = {
+    0x066B,  // Femto Bolt
+};
+}  // namespace libobsensor
diff --git a/src/device/IAlgParamManager.hpp b/src/device/IAlgParamManager.hpp
new file mode 100644
index 00000000..94c85508
--- /dev/null
+++ b/src/device/IAlgParamManager.hpp
@@ -0,0 +1,33 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include <string>
+#include <vector>
+#include <memory>
+
+#include "IStreamProfile.hpp"
+#include "libobsensor/h/ObTypes.h"
+#include "InternalTypes.hpp"
+
+namespace libobsensor {
+
+class IAlgParamManager {
+public:
+    virtual ~IAlgParamManager() = default;
+
+    virtual void bindStreamProfileParams(std::vector<std::shared_ptr<const StreamProfile>> streamProfileList) = 0;
+
+    virtual const std::vector<OBD2CProfile>  &getD2CProfileList() const             = 0;
+    virtual const std::vector<OBCameraParam> &getCalibrationCameraParamList() const = 0;
+    virtual const OBIMUCalibrateParams       &getIMUCalibrationParam() const        = 0;
+};
+
+class IDisparityAlgParamManager {
+public:
+    virtual ~IDisparityAlgParamManager() = default;
+
+    virtual const OBDisparityParam &getDisparityParam() const = 0;
+};
+
+}  // namespace libobsensor
diff --git a/src/device/IDepthWorkModeManager.hpp b/src/device/IDepthWorkModeManager.hpp
new file mode 100644
index 00000000..e6e0b35d
--- /dev/null
+++ b/src/device/IDepthWorkModeManager.hpp
@@ -0,0 +1,31 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include <string>
+#include <vector>
+#include "InternalTypes.hpp"
+
+namespace libobsensor {
+
+class IDepthWorkModeManager {
+public:
+    virtual ~IDepthWorkModeManager() = default;
+
+    virtual std::vector<OBDepthWorkMode_Internal> getDepthWorkModeList() const                 = 0;
+    virtual const OBDepthWorkMode_Internal       &getCurrentDepthWorkMode() const              = 0;
+    virtual void                                switchDepthWorkMode(const std::string &name) = 0;
+};
+}  // namespace libobsensor
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct ob_depth_work_mode_list_t {
+    std::vector<OBDepthWorkMode_Internal> workModeList;
+};
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/src/device/IDevice.hpp b/src/device/IDevice.hpp
new file mode 100644
index 00000000..98912f28
--- /dev/null
+++ b/src/device/IDevice.hpp
@@ -0,0 +1,104 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include "libobsensor/h/ObTypes.h"
+#include "IProperty.hpp"
+#include "ISensor.hpp"
+#include "IFilter.hpp"
+#include "IPresetManager.hpp"
+#include "IDeviceComponent.hpp"
+
+namespace libobsensor {
+
+struct DeviceInfo {
+    // identifier of the device
+    int         pid_ = 0;
+    int         vid_ = 0;
+    std::string uid_;  // Unique identifier of the port the device is connected to (platform specific)
+    std::string name_;
+    std::string fullName_;
+
+    std::string connectionType_;  // Device connection type
+    uint16_t    type_ = 0;        // 0: Monocular disparity based; 1: Binocular disparity based; 2: tof
+    std::string fwVersion_;
+    std::string hwVersion_;
+    std::string supportedSdkVersion_;
+    std::string asicName_;
+    std::string deviceSn_;
+};
+
+struct NetDeviceInfo : public DeviceInfo {
+    std::string ipAddress_;
+};
+
+typedef std::function<void(OBFwUpdateState state, const char *message, uint8_t percent)> DeviceFwUpdateCallback;
+
+class IDevice : public std::enable_shared_from_this<IDevice> {
+public:
+    virtual ~IDevice() = default;
+
+    // device life control
+    virtual void reset()      = 0;
+    virtual void reboot()     = 0;
+    virtual void deactivate() = 0;
+
+    // device info
+    virtual std::shared_ptr<const DeviceInfo> getInfo() const                                         = 0;
+    virtual const std::string                &getExtensionInfo(const std::string &infoKey) const      = 0;
+    virtual bool                              isExtensionInfoExists(const std::string &infoKey) const = 0;
+
+    // device components management
+    virtual bool                                 isComponentExists(DeviceComponentId compId) const                     = 0;
+    virtual bool                                 isComponentCreated(DeviceComponentId compId) const                    = 0;  // for lazy creation
+    virtual DeviceComponentPtr<IDeviceComponent> getComponent(DeviceComponentId compId, bool throwExIfNotFound = true) = 0;
+    virtual DeviceComponentPtr<IPropertyServer>  getPropertyServer()                                                   = 0;
+
+    // device sensors (specify components) management
+    virtual bool                        isSensorExists(OBSensorType type) const  = 0;
+    virtual bool                        isSensorCreated(OBSensorType type) const = 0;  // for lazy creation
+    virtual DeviceComponentPtr<ISensor> getSensor(OBSensorType type)             = 0;
+    virtual std::vector<OBSensorType>   getSensorTypeList() const                = 0;
+    virtual bool                        hasAnySensorStreamActivated()            = 0;
+
+    // todo: Add a filter manager as a component and move this function to it
+    virtual std::vector<std::shared_ptr<IFilter>> createRecommendedPostProcessingFilters(OBSensorType type)                                     = 0;
+    virtual std::shared_ptr<IFilter>              getSensorFrameFilter(const std::string &name, OBSensorType type, bool throwIfNotFound = true) = 0;
+
+    // device firmware update
+    virtual void updateFirmware(const std::vector<uint8_t> &firmware, DeviceFwUpdateCallback updateCallback, bool async) = 0;
+
+public:
+    // templated functions
+    template <typename T> DeviceComponentPtr<T> getComponentT(DeviceComponentId compId, bool throwExIfNotFound = true) {
+        auto comp = getComponent(compId, throwExIfNotFound);
+        if(comp) {
+            return comp.as<T>();
+        }
+        return DeviceComponentPtr<T>(nullptr);
+    }
+
+protected:
+    // device initialization, called on constructor and reset()
+    virtual void init() = 0;
+};
+
+}  // namespace libobsensor
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+struct ob_device_t {
+    std::shared_ptr<libobsensor::IDevice> device;
+};
+
+struct ob_device_info_t {
+    std::shared_ptr<const libobsensor::DeviceInfo> info;
+};
+struct ob_camera_param_list_t {
+    std::vector<OBCameraParam> paramList;
+};
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/src/device/IDeviceClockSynchronizer.hpp b/src/device/IDeviceClockSynchronizer.hpp
new file mode 100644
index 00000000..6e5987b8
--- /dev/null
+++ b/src/device/IDeviceClockSynchronizer.hpp
@@ -0,0 +1,21 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include <string>
+#include <vector>
+#include "libobsensor/h/ObTypes.h"
+
+namespace libobsensor {
+
+class IDeviceClockSynchronizer {
+public:
+    virtual ~IDeviceClockSynchronizer()                                                                                    = default;
+    virtual void                         setTimestampResetConfig(const OBDeviceTimestampResetConfig &timestampResetConfig) = 0;
+    virtual OBDeviceTimestampResetConfig getTimestampResetConfig()                                                         = 0;
+    virtual void                         timestampReset()                                                                  = 0;
+    virtual void                         timerSyncWithHost()                                                               = 0;
+};
+
+}  // namespace libobsensor
+
diff --git a/src/device/IDeviceComponent.hpp b/src/device/IDeviceComponent.hpp
new file mode 100644
index 00000000..325b0403
--- /dev/null
+++ b/src/device/IDeviceComponent.hpp
@@ -0,0 +1,110 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include <mutex>
+#include <memory>
+
+#include "utils/Utils.hpp"
+#include "exception/ObException.hpp"
+
+namespace libobsensor {
+class IDevice;
+
+class IDeviceComponent {
+public:
+    virtual ~IDeviceComponent()       = default;
+    virtual IDevice *getOwner() const = 0;
+};
+
+typedef std::unique_lock<std::recursive_timed_mutex> DeviceComponentLock;
+
+template <typename T> class DeviceComponentPtr {
+public:
+    DeviceComponentPtr(std::shared_ptr<T> ptr, DeviceComponentLock &&lock) : ptr_(ptr), lock_(std::move(lock)) {}
+    DeviceComponentPtr(std::shared_ptr<T> ptr) : ptr_(ptr), lock_() {}
+    DeviceComponentPtr() : ptr_(), lock_() {}
+
+    // copy constructor and assignment operator are deleted to avoid accidental copies of the lock
+    DeviceComponentPtr(const DeviceComponentPtr &other)            = delete;
+    DeviceComponentPtr &operator=(const DeviceComponentPtr &other) = delete;
+
+    DeviceComponentPtr(DeviceComponentPtr &&other)            = default;
+    DeviceComponentPtr &operator=(DeviceComponentPtr &&other) = default;
+
+    T *operator->() const {
+        if(ptr_ == nullptr) {
+            throw std::runtime_error("DeviceComponentPtr is nullptr");
+        }
+        return ptr_.get();
+    }
+
+    operator bool() const {
+        return ptr_ != nullptr;
+    }
+
+    void reset() {
+        ptr_.reset();
+        lock_ = DeviceComponentLock();
+    }
+
+    template <typename U> DeviceComponentPtr<U> as() {
+        auto uPtr = std::dynamic_pointer_cast<U>(ptr_);
+        if(uPtr == nullptr) {
+            throw invalid_value_exception(utils::string::to_string() << "DeviceComponentPtr is not of type " << typeid(U).name());
+        }
+        ptr_ = nullptr;
+        return DeviceComponentPtr<U>(uPtr, std::move(lock_));
+    }
+
+    std::shared_ptr<T> get() const {
+        return ptr_;
+    }
+
+private:
+    std::shared_ptr<T>  ptr_;
+    DeviceComponentLock lock_;
+};
+typedef enum {
+    OB_DEV_COMPONENT_UNKNOWN = -1,
+
+    OB_DEV_COMPONENT_PROPERTY_SERVER = 0,
+    OB_DEV_COMPONENT_MAIN_PROPERTY_ACCESSOR,
+
+    OB_DEV_COMPONENT_DEPTH_SENSOR,
+    OB_DEV_COMPONENT_IR_SENSOR,
+    OB_DEV_COMPONENT_LEFT_IR_SENSOR,
+    OB_DEV_COMPONENT_RIGHT_IR_SENSOR,
+    OB_DEV_COMPONENT_COLOR_SENSOR,
+    OB_DEV_COMPONENT_FRAME_PROCESSOR_FACTORY,
+    OB_DEV_COMPONENT_DEPTH_FRAME_PROCESSOR,
+    OB_DEV_COMPONENT_IR_FRAME_PROCESSOR,
+    OB_DEV_COMPONENT_LEFT_IR_FRAME_PROCESSOR,
+    OB_DEV_COMPONENT_RIGHT_IR_FRAME_PROCESSOR,
+    OB_DEV_COMPONENT_COLOR_FRAME_PROCESSOR,
+    OB_DEV_COMPONENT_GYRO_SENSOR,
+    OB_DEV_COMPONENT_ACCEL_SENSOR,
+    OB_DEV_COMPONENT_IMU_STREAMER,
+    OB_DEV_COMPONENT_SENSOR_STREAM_STRATEGY,
+    OB_DEV_COMPONENT_STREAM_PROFILE_FILTER,
+
+    OB_DEV_COMPONENT_COLOR_FRAME_METADATA_CONTAINER,
+    OB_DEV_COMPONENT_DEPTH_FRAME_METADATA_CONTAINER,
+
+    OB_DEV_COMPONENT_PRESET_MANAGER,
+    OB_DEV_COMPONENT_ALG_PARAM_MANAGER,
+    OB_DEV_COMPONENT_DEPTH_WORK_MODE_MANAGER,
+
+    OB_DEV_COMPONENT_GLOBAL_TIMESTAMP_FILTER,
+    OB_DEV_COMPONENT_DEVICE_SYNC_CONFIGURATOR,
+    OB_DEV_COMPONENT_DEVICE_CLOCK_SYNCHRONIZER,
+    OB_DEV_COMPONENT_DEVICE_MONITOR,
+
+    OB_DEV_COMPONENT_RAW_PHASE_STREAMER,
+
+    OB_DEV_COMPONENT_FIRMWARE_UPDATER,
+
+    OB_DEV_COMPONENT_COUNT
+} DeviceComponentId;
+
+}  // namespace libobsensor
diff --git a/src/device/IDeviceManager.hpp b/src/device/IDeviceManager.hpp
new file mode 100644
index 00000000..4fa40bf4
--- /dev/null
+++ b/src/device/IDeviceManager.hpp
@@ -0,0 +1,61 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include "IDevice.hpp"
+#include "ISourcePort.hpp"
+
+namespace libobsensor {
+class IDeviceManager;
+class IDeviceEnumInfo {
+public:
+    virtual int                             getPid() const                = 0;
+    virtual int                             getVid() const                = 0;
+    virtual const std::string              &getUid() const                = 0;
+    virtual const std::string              &getConnectionType() const     = 0;
+    virtual const std::string              &getName() const               = 0;
+    virtual const std::string              &getFullName() const       = 0;
+    virtual const std::string              &getDeviceSn() const           = 0;
+    virtual const SourcePortInfoList       &getSourcePortInfoList() const = 0;
+    virtual std::shared_ptr<IDevice>        createDevice() const          = 0;
+    virtual std::shared_ptr<IDeviceManager> getDeviceManager() const      = 0;
+
+    virtual bool operator==(const IDeviceEnumInfo &other) const = 0;
+};
+
+typedef std::vector<std::shared_ptr<const IDeviceEnumInfo>>                                     DeviceEnumInfoList;
+typedef std::function<void(const DeviceEnumInfoList &removed, const DeviceEnumInfoList &added)> DeviceChangedCallback;
+
+class IDeviceEnumerator {
+public:
+    virtual ~IDeviceEnumerator()                                                        = default;
+    virtual DeviceEnumInfoList getDeviceInfoList()                                      = 0;
+    virtual void               setDeviceChangedCallback(DeviceChangedCallback callback) = 0;
+};
+
+class IDeviceManager {
+public:
+    virtual std::shared_ptr<IDevice> createDevice(const std::shared_ptr<const IDeviceEnumInfo> &info) = 0;
+    virtual std::shared_ptr<IDevice> createNetDevice(std::string address, uint16_t port)              = 0;
+
+    virtual DeviceEnumInfoList getDeviceInfoList()                                      = 0;
+    virtual void               setDeviceChangedCallback(DeviceChangedCallback callback) = 0;
+
+    virtual void enableNetDeviceEnumeration(bool enable) = 0;
+    virtual bool isNetDeviceEnumerationEnable() const    = 0;
+
+    virtual void enableDeviceClockSync(uint64_t repeatInterval) = 0;
+};
+
+}  // namespace libobsensor
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+struct ob_device_list_t {
+    libobsensor::DeviceEnumInfoList              list;
+    std::shared_ptr<libobsensor::IDeviceManager> manager;
+};
+#ifdef __cplusplus
+}
+#endif
diff --git a/src/device/IDeviceMonitor.hpp b/src/device/IDeviceMonitor.hpp
new file mode 100644
index 00000000..4367a1dc
--- /dev/null
+++ b/src/device/IDeviceMonitor.hpp
@@ -0,0 +1,32 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include "libobsensor/h/ObTypes.h"
+
+#include <vector>
+#include <functional>
+#include <string>
+
+namespace libobsensor {
+
+typedef std::function<void(uint64_t stateCode, const std::string &message)> DeviceStateChangedCallback;
+
+class IDeviceMonitor {
+public:
+    virtual ~IDeviceMonitor() = default;
+
+    virtual OBDeviceState getCurrentDeviceState() const                                     = 0;
+    virtual int           registerStateChangedCallback(DeviceStateChangedCallback callback) = 0;
+    virtual void          unregisterStateChangedCallback(int callbackId)                    = 0;
+
+    virtual void enableHeartbeat()  = 0;
+    virtual void disableHeartbeat() = 0;
+    virtual bool isHeartbeatEnabled() const = 0;
+    virtual void pauseHeartbeat()   = 0;
+    virtual void resumeHeartbeat()  = 0;
+
+    // for debug and vendor specific purpose
+    virtual void sendAndReceiveData(const uint8_t *sendData, uint32_t sendDataSize, uint8_t *receiveData, uint32_t *receiveDataSize) = 0;
+};
+}  // namespace libobsensor
diff --git a/src/device/IDeviceSyncConfigurator.hpp b/src/device/IDeviceSyncConfigurator.hpp
new file mode 100644
index 00000000..472c2de1
--- /dev/null
+++ b/src/device/IDeviceSyncConfigurator.hpp
@@ -0,0 +1,22 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include <string>
+#include <vector>
+#include "libobsensor/h/ObTypes.h"
+
+namespace libobsensor {
+
+class IDeviceSyncConfigurator {
+public:
+    virtual ~IDeviceSyncConfigurator() = default;
+
+    virtual OBMultiDeviceSyncConfig getSyncConfig()                                                = 0;
+    virtual void                    setSyncConfig(const OBMultiDeviceSyncConfig &deviceSyncConfig) = 0;
+    virtual uint16_t                getSupportedSyncModeBitmap()                                   = 0;
+    virtual void                    triggerCapture()                                               = 0;
+};
+
+}  // namespace libobsensor
+
diff --git a/src/device/IFrameMetadataParserContainerManager.hpp b/src/device/IFrameMetadataParserContainerManager.hpp
new file mode 100644
index 00000000..13bcf8d0
--- /dev/null
+++ b/src/device/IFrameMetadataParserContainerManager.hpp
@@ -0,0 +1,10 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include "IDeviceComponent.hpp"
+#include "IFrame.hpp"
+
+namespace libobsensor {
+class IFrameMetadataParserContainerManager : virtual public IDeviceComponent, virtual public IFrameMetadataParserContainer {};
+}  // namespace libobsensor
diff --git a/src/device/IPresetManager.hpp b/src/device/IPresetManager.hpp
new file mode 100644
index 00000000..55199e24
--- /dev/null
+++ b/src/device/IPresetManager.hpp
@@ -0,0 +1,34 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+
+namespace libobsensor {
+#include <string>
+#include <vector>
+
+class IPresetManager {
+public:
+    virtual ~IPresetManager() = default;
+
+    virtual void                            loadPreset(const std::string &presetName)                                                   = 0;
+    virtual const std::string              &getCurrentPresetName() const                                                                = 0;
+    virtual const std::vector<std::string> &getAvailablePresetList() const                                                              = 0;
+    virtual void                            loadPresetFromJsonData(const std::string &presetName, const std::vector<uint8_t> &jsonData) = 0;
+    virtual void                            loadPresetFromJsonFile(const std::string &filePath)                                         = 0;
+    virtual const std::vector<uint8_t>     &exportSettingsAsPresetJsonData(const std::string &presetName)                               = 0;
+    virtual void                            exportSettingsAsPresetJsonFile(const std::string &filePath)                                 = 0;
+};
+}  // namespace libobsensor
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct ob_device_preset_list_t {
+    std::vector<std::string> presetList;
+};
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/src/device/IProperty.hpp b/src/device/IProperty.hpp
new file mode 100644
index 00000000..7cc26f23
--- /dev/null
+++ b/src/device/IProperty.hpp
@@ -0,0 +1,229 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include "libobsensor/h/ObTypes.h"
+#include "libobsensor/h/Property.h"
+#include "exception/ObException.hpp"
+
+#include <vector>
+#include <memory>
+
+namespace libobsensor {
+typedef union {
+    int32_t intValue;
+    float   floatValue;
+} OBPropertyValue;
+
+typedef struct {
+    OBPropertyValue cur;
+    OBPropertyValue max;
+    OBPropertyValue min;
+    OBPropertyValue step;
+    OBPropertyValue def;
+} OBPropertyRange;
+
+template <typename T> struct OBPropertyRangeT {
+    T cur;
+    T max;
+    T min;
+    T step;
+    T def;
+};
+
+using GetDataCallback = std::function<void(OBDataTranState state, OBDataChunk *dataChunk)>;
+
+class IPropertyAccessor {
+public:
+    virtual ~IPropertyAccessor() noexcept = default;
+};
+class IBasicPropertyAccessor : virtual public IPropertyAccessor {
+public:
+    virtual ~IBasicPropertyAccessor() noexcept                                       = default;
+    virtual void setPropertyValue(uint32_t propertyId, const OBPropertyValue &value) = 0;
+    virtual void getPropertyValue(uint32_t propertyId, OBPropertyValue *value)       = 0;
+    virtual void getPropertyRange(uint32_t propertyId, OBPropertyRange *range)       = 0;
+};
+
+class IStructureDataAccessor : virtual public IPropertyAccessor {
+public:
+    virtual ~IStructureDataAccessor() noexcept                                                                  = default;
+    virtual void                        setStructureData(uint32_t propertyId, const std::vector<uint8_t> &data) = 0;
+    virtual const std::vector<uint8_t> &getStructureData(uint32_t propertyId)                                   = 0;
+};
+
+class IStructureDataAccessorV1_1 : virtual public IPropertyAccessor {
+public:
+    virtual ~IStructureDataAccessorV1_1() noexcept = default;
+
+    virtual uint16_t                    getCmdVersionProtoV1_1(uint32_t propertyId)                                                           = 0;
+    virtual const std::vector<uint8_t> &getStructureDataProtoV1_1(uint32_t propertyId, uint16_t cmdVersion)                                   = 0;
+    virtual void                        setStructureDataProtoV1_1(uint32_t propertyId, const std::vector<uint8_t> &data, uint16_t cmdVersion) = 0;
+    virtual const std::vector<uint8_t> &getStructureDataListProtoV1_1(uint32_t propertyId, uint16_t cmdVersion)                               = 0;
+};
+
+class IRawDataAccessor : virtual public IPropertyAccessor {
+public:
+    virtual ~IRawDataAccessor() noexcept                                   = default;
+    virtual void getRawData(uint32_t propertyId, GetDataCallback callback) = 0;
+};
+
+enum PropertyAccessType {
+    PROP_ACCESS_USER     = 1,  // User access(by sdk user api)
+    PROP_ACCESS_INTERNAL = 2,  // Internal access (by sdk or other internal modules)
+    // PROP_ACCESS_ANY      = 3,  // Any access (user or internal)
+};
+
+enum PropertyOperationType {
+    PROP_OP_READ       = 1,  // Read operation
+    PROP_OP_WRITE      = 2,  // Write operation
+    PROP_OP_READ_WRITE = 3,  // Read/Write operation
+};
+
+typedef std::function<void(uint32_t propertyId, const uint8_t *data, size_t dataSize, PropertyOperationType operationType)> PropertyAccessCallback;
+class IPropertyServer {
+public:
+    virtual ~IPropertyServer() noexcept = default;
+
+    virtual void registerAccessCallback(uint32_t propertyId, PropertyAccessCallback callback)               = 0;
+    virtual void registerAccessCallback(std::vector<uint32_t> propertyIds, PropertyAccessCallback callback) = 0;
+
+    virtual void registerProperty(uint32_t propertyId, OBPermissionType userPerms, OBPermissionType intPerms, std::shared_ptr<IPropertyAccessor> accessor) = 0;
+    virtual void registerProperty(uint32_t propertyId, const std::string &userPerms, const std::string &intPerms,
+                                  std::shared_ptr<IPropertyAccessor> accessor)                                                                             = 0;
+    virtual void aliasProperty(uint32_t aliasId, uint32_t propertyId)                                                                                      = 0;
+
+    virtual bool isPropertySupported(uint32_t propertyId, PropertyOperationType operationType, PropertyAccessType accessType) const = 0;
+    virtual const std::vector<OBPropertyItem> &getAvailableProperties(PropertyAccessType accessType)                                = 0;
+    virtual OBPropertyItem                     getPropertyItem(uint32_t propertyId, PropertyAccessType accessType)                  = 0;
+
+    virtual void setPropertyValue(uint32_t propertyId, OBPropertyValue value, PropertyAccessType accessType)  = 0;
+    virtual void getPropertyValue(uint32_t propertyId, OBPropertyValue *value, PropertyAccessType accessType) = 0;
+    virtual void getPropertyRange(uint32_t propertyId, OBPropertyRange *range, PropertyAccessType accessType) = 0;
+
+    virtual void                        setStructureData(uint32_t propertyId, const std::vector<uint8_t> &data, PropertyAccessType accessType) = 0;
+    virtual const std::vector<uint8_t> &getStructureData(uint32_t propertyId, PropertyAccessType accessType)                                   = 0;
+
+    virtual void getRawData(uint32_t propertyId, GetDataCallback callback, PropertyAccessType accessType) = 0;
+
+    virtual uint16_t getCmdVersionProtoV1_1(uint32_t propertyId, PropertyAccessType accessType) = 0;
+
+    virtual const std::vector<uint8_t> &getStructureDataProtoV1_1(uint32_t propertyId, uint16_t cmdVersion, PropertyAccessType accessType)            = 0;
+    virtual void setStructureDataProtoV1_1(uint32_t propertyId, const std::vector<uint8_t> &data, uint16_t cmdVersion, PropertyAccessType accessType) = 0;
+
+    virtual const std::vector<uint8_t> &getStructureDataListProtoV1_1(uint32_t propertyId, uint16_t cmdVersion, PropertyAccessType accessType) = 0;
+
+public:  // template functions to simplify the usage of IPropertyServer
+    template <typename T>
+    typename std::enable_if<!std::is_same<T, float>::value, void>::type setPropertyValueT(uint32_t propertyId, const T &value,
+                                                                                          PropertyAccessType accessType = PROP_ACCESS_INTERNAL) {
+        OBPropertyValue obValue;
+        obValue.intValue = static_cast<int32_t>(value);
+        setPropertyValue(propertyId, obValue, accessType);
+    }
+
+    template <typename T>
+    typename std::enable_if<std::is_same<T, float>::value, void>::type setPropertyValueT(uint32_t propertyId, const T &value,
+                                                                                         PropertyAccessType accessType = PROP_ACCESS_INTERNAL) {
+        OBPropertyValue obValue;
+        obValue.floatValue = static_cast<float>(value);
+        setPropertyValue(propertyId, obValue, accessType);
+    }
+
+    template <typename T>
+    typename std::enable_if<!std::is_same<T, float>::value, T>::type getPropertyValueT(uint32_t           propertyId,
+                                                                                       PropertyAccessType accessType = PROP_ACCESS_INTERNAL) {
+        OBPropertyValue obValue;
+        getPropertyValue(propertyId, &obValue, accessType);
+        return static_cast<T>(obValue.intValue);
+    }
+
+    template <typename T>
+    typename std::enable_if<std::is_same<T, float>::value, T>::type getPropertyValueT(uint32_t           propertyId,
+                                                                                      PropertyAccessType accessType = PROP_ACCESS_INTERNAL) {
+        OBPropertyValue obValue;
+        getPropertyValue(propertyId, &obValue, accessType);
+        return static_cast<T>(obValue.floatValue);
+    }
+
+    template <typename T>
+    typename std::enable_if<!std::is_same<T, float>::value, OBPropertyRangeT<T>>::type getPropertyRangeT(uint32_t           propertyId,
+                                                                                                         PropertyAccessType accessType = PROP_ACCESS_INTERNAL) {
+        OBPropertyRangeT<T> rangeT;
+        OBPropertyRange     range;
+        getPropertyRange(propertyId, (OBPropertyRange *)&range, accessType);
+
+        rangeT.cur  = range.cur.intValue;
+        rangeT.max  = range.max.intValue;
+        rangeT.min  = range.min.intValue;
+        rangeT.step = range.step.intValue;
+        rangeT.def  = range.def.intValue;
+
+        return rangeT;
+    }
+
+    template <typename T>
+    typename std::enable_if<std::is_same<T, float>::value, OBPropertyRangeT<T>>::type getPropertyRangeT(uint32_t           propertyId,
+                                                                                                        PropertyAccessType accessType = PROP_ACCESS_INTERNAL) {
+        OBPropertyRangeT<T> rangeT;
+        OBPropertyRange     range;
+        getPropertyRange(propertyId, (OBPropertyRange *)&range, accessType);
+
+        rangeT.cur  = range.cur.floatValue;
+        rangeT.max  = range.max.floatValue;
+        rangeT.min  = range.min.floatValue;
+        rangeT.step = range.step.floatValue;
+        rangeT.def  = range.def.floatValue;
+
+        return rangeT;
+    }
+
+    template <typename T> void setStructureDataT(uint32_t propertyId, const T &data, PropertyAccessType accessType = PROP_ACCESS_INTERNAL) {
+        std::vector<uint8_t> vec(sizeof(T));
+        std::memcpy(vec.data(), &data, sizeof(T));
+        setStructureData(propertyId, vec, accessType);
+    }
+
+    template <typename T> T getStructureDataT(uint32_t propertyId, PropertyAccessType accessType = PROP_ACCESS_INTERNAL) {
+        std::vector<uint8_t> vec = getStructureData(propertyId, accessType);
+        T                    data;
+        if(vec.size() != sizeof(T) && vec.size() + 1 != sizeof(T) && vec.size() - 1 != sizeof(T)) {
+            LOG_WARN("Firmware data size is not match with property type");
+        }
+        std::memcpy(&data, vec.data(), std::min(vec.size(), sizeof(T)));
+        return data;
+    }
+
+    template <typename T, uint32_t CMD_VER> T getStructureDataProtoV1_1_T(uint32_t propertyId, PropertyAccessType accessType = PROP_ACCESS_INTERNAL) {
+        std::vector<uint8_t> vec = getStructureDataProtoV1_1(propertyId, CMD_VER, accessType);
+        T                    data;
+        if(vec.size() != sizeof(T) && vec.size() + 1 != sizeof(T) && vec.size() - 1 != sizeof(T)) {
+            LOG_WARN("Firmware data size is not match with property type");
+        }
+        std::memcpy(&data, vec.data(), std::min(vec.size(), sizeof(T)));
+        return data;
+    }
+
+    template <typename T, uint32_t CMD_VER>
+    void setStructureDataProtoV1_1_T(uint32_t propertyId, const T &structureData, PropertyAccessType accessType = PROP_ACCESS_INTERNAL) {
+        std::vector<uint8_t> vec(sizeof(T));
+        std::memcpy(vec.data(), &structureData, sizeof(T));
+        setStructureDataProtoV1_1(propertyId, vec, CMD_VER, accessType);
+    }
+
+    template <typename T, uint32_t CMD_VER>
+    std::vector<T> getStructureDataListProtoV1_1_T(uint32_t propertyId, PropertyAccessType accessType = PROP_ACCESS_INTERNAL) {
+        auto data     = getStructureDataListProtoV1_1(propertyId, CMD_VER, accessType);
+        auto itemSize = sizeof(T);
+        auto rst      = std::vector<T>();
+        for(size_t i = 0; i < data.size() && i + itemSize <= data.size(); i += itemSize) {
+            T item;
+            std::memcpy(&item, data.data() + i, itemSize);
+            rst.emplace_back(item);
+        }
+
+        return rst;
+    }
+};
+
+}  // namespace libobsensor
diff --git a/src/device/ISensor.hpp b/src/device/ISensor.hpp
new file mode 100644
index 00000000..64b56e88
--- /dev/null
+++ b/src/device/ISensor.hpp
@@ -0,0 +1,82 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include "libobsensor/h/ObTypes.h"
+#include "IStreamProfile.hpp"
+#include "IFrame.hpp"
+#include "ISourcePort.hpp"
+#include "IDeviceComponent.hpp"
+#include <memory>
+
+namespace libobsensor {
+class IDevice;
+
+typedef enum {
+    STREAM_STATE_STARTING,      // starting (change to this state at the beginning of start function)
+    STREAM_STATE_STREAMING,     // streaming (change to this state when recived first frame from backend)
+    STREAM_STATE_STOPPING,      // stopping (change to this state at the beginning of stop function)
+    STREAM_STATE_STOPPED,       // stoped (change to this state after stop function called, it is also the initial state)
+    STREAM_STATE_ERROR,         // error (change to this state when error occurred after start stream)
+    STREAM_STATE_START_FAILED,  // start stream failed
+} OBStreamState;
+
+#define STREAM_STATE_STR(state)                                  \
+    (state == STREAM_STATE_STARTING       ? "STARTING"           \
+     : state == STREAM_STATE_STREAMING    ? "STREAMING"          \
+     : state == STREAM_STATE_STOPPING     ? "STOPPING"           \
+     : state == STREAM_STATE_STOPPED      ? "STOPPED"            \
+     : state == STREAM_STATE_ERROR        ? "STREAM_STATE_ERROR" \
+     : state == STREAM_STATE_START_FAILED ? "START_FAILED"       \
+                                          : "UNKNOWN")
+
+typedef std::function<void(OBStreamState, const std::shared_ptr<const StreamProfile> &)> StreamStateChangedCallback;
+
+class ISensor : virtual public IDeviceComponent {
+public:
+    virtual ~ISensor() noexcept = default;
+
+    virtual OBSensorType getSensorType() const = 0;
+
+    virtual void start(std::shared_ptr<const StreamProfile> sp, FrameCallback callback) = 0;
+    virtual void stop()                                                                 = 0;
+
+    virtual void                                 setStreamProfileList(const StreamProfileList &profileList)                 = 0;
+    virtual StreamProfileList                    getStreamProfileList() const                                               = 0;
+    virtual void                                 setStreamProfileFilter(std::shared_ptr<IStreamProfileFilter> filter)       = 0;
+    virtual void                                 updateDefaultStreamProfile(const std::shared_ptr<const StreamProfile> &sp) = 0;
+    virtual std::shared_ptr<const StreamProfile> getActivatedStreamProfile() const                                          = 0;
+    virtual FrameCallback                        getFrameCallback() const                                                   = 0;
+
+    virtual OBStreamState getStreamState() const                                                  = 0;
+    virtual bool          isStreamActivated() const                                               = 0;
+    virtual uint32_t      registerStreamStateChangedCallback(StreamStateChangedCallback callback) = 0;
+    virtual void          unregisterStreamStateChangedCallback(uint32_t token)                    = 0;
+};
+
+struct LazySensor {
+    explicit LazySensor(IDevice *device, OBSensorType type) : device(device), sensorType(type) {}
+    IDevice     *device;  // sensor is lazy create base on device
+    OBSensorType sensorType;
+};
+
+}  // namespace libobsensor
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct ob_sensor_t {
+    std::shared_ptr<libobsensor::IDevice> device;  // sensor is lazy create base on device
+    OBSensorType                          type;
+};
+
+struct ob_sensor_list_t {
+    std::shared_ptr<libobsensor::IDevice> device;
+    std::vector<OBSensorType>             sensorTypes;
+};
+
+#ifdef __cplusplus
+}
+#endif
+
diff --git a/src/device/ISensorStreamStrategy.hpp b/src/device/ISensorStreamStrategy.hpp
new file mode 100644
index 00000000..fdff34bd
--- /dev/null
+++ b/src/device/ISensorStreamStrategy.hpp
@@ -0,0 +1,23 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include "libobsensor/h/ObTypes.h"
+
+#include "IStreamProfile.hpp"
+
+#include <memory>
+
+namespace libobsensor {
+
+class ISensorStreamStrategy {
+public:
+    virtual ~ISensorStreamStrategy() = default;
+
+    virtual void validateStream(const std::shared_ptr<const StreamProfile> &profile)               = 0;
+    virtual void validateStream(const std::vector<std::shared_ptr<const StreamProfile>> &profiles) = 0;
+    virtual void markStreamActivated(const std::shared_ptr<const StreamProfile> &profile)          = 0;
+    virtual void markStreamDeactivated(const std::shared_ptr<const StreamProfile> &profile)        = 0;
+};
+
+}  // namespace libobsensor
diff --git a/src/device/astra2/Astra2AlgParamManager.cpp b/src/device/astra2/Astra2AlgParamManager.cpp
new file mode 100644
index 00000000..e9a5dfc9
--- /dev/null
+++ b/src/device/astra2/Astra2AlgParamManager.cpp
@@ -0,0 +1,160 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "Astra2AlgParamManager.hpp"
+
+#include "InternalTypes.hpp"
+#include "property/InternalProperty.hpp"
+#include "publicfilters/IMUCorrector.hpp"
+#include "stream/StreamIntrinsicsManager.hpp"
+#include "stream/StreamExtrinsicsManager.hpp"
+#include "stream/StreamProfileFactory.hpp"
+#include "exception/ObException.hpp"
+
+namespace libobsensor {
+Astra2AlgParamManager::Astra2AlgParamManager(IDevice *owner) : DisparityAlgParamManagerBase(owner) {
+    fetchParamFromDevice();
+    registerBasicExtrinsics();
+}
+
+void Astra2AlgParamManager::fetchParamFromDevice() {
+    try {
+        auto owner                   = getOwner();
+        auto propServer              = owner->getPropertyServer();
+        depthCalibParamList_         = propServer->getStructureDataListProtoV1_1_T<OBDepthCalibrationParam, 1>(OB_RAW_DATA_DEPTH_CALIB_PARAM);
+        const auto &depthCalib       = depthCalibParamList_.front();
+        disparityParam_.baseline     = depthCalib.baseline;
+        disparityParam_.zpd          = depthCalib.z0;
+        disparityParam_.fx           = depthCalib.focalPix;
+        disparityParam_.zpps         = depthCalib.z0 / depthCalib.focalPix;
+        disparityParam_.bitSize      = 14;  // low 14 bit
+        disparityParam_.dispIntPlace = 8;
+        disparityParam_.unit         = depthCalib.unit;
+        disparityParam_.dispOffset   = depthCalib.dispOffset;
+        disparityParam_.invalidDisp  = depthCalib.invalidDisp;
+        disparityParam_.packMode     = OB_DISP_PACK_ORIGINAL_NEW;
+        disparityParam_.isDualCamera = false;
+    }
+    catch(const std::exception &e) {
+        LOG_ERROR("Get depth calibration params failed! {}", e.what());
+    }
+
+    try {
+        auto owner           = getOwner();
+        auto propServer      = owner->getPropertyServer();
+        auto cameraParamList = propServer->getStructureDataListProtoV1_1_T<OBCameraParam_Internal_V0, 0>(OB_RAW_DATA_ALIGN_CALIB_PARAM);
+        for(auto &cameraParam: cameraParamList) {
+            OBCameraParam param;
+            param.depthIntrinsic = cameraParam.depthIntrinsic;
+            param.rgbIntrinsic   = cameraParam.rgbIntrinsic;
+            memcpy(&param.depthDistortion, &cameraParam.depthDistortion, sizeof(param.depthDistortion));
+            param.depthDistortion.model = OB_DISTORTION_BROWN_CONRADY_K6;
+            memcpy(&param.rgbDistortion, &cameraParam.rgbDistortion, sizeof(param.rgbDistortion));
+            param.rgbDistortion.model = OB_DISTORTION_BROWN_CONRADY_K6;
+            param.transform           = cameraParam.transform;
+            param.isMirrored          = false;
+            calibrationCameraParamList_.emplace_back(param);
+
+            std::stringstream ss;
+            ss << param;
+            LOG_DEBUG("-{}", ss.str());
+        }
+    }
+    catch(const std::exception &e) {
+        LOG_ERROR("Get depth calibration params failed! {}", e.what());
+    }
+
+    try {
+        auto owner      = getOwner();
+        auto propServer = owner->getPropertyServer();
+        d2cProfileList_ = propServer->getStructureDataListProtoV1_1_T<OBD2CProfile, 0>(OB_RAW_DATA_D2C_ALIGN_SUPPORT_PROFILE_LIST);
+    }
+    catch(const std::exception &e) {
+        LOG_ERROR("Get depth to color profile list failed! {}", e.what());
+    }
+
+    // imu param
+    std::vector<uint8_t> data;
+    try {
+        auto owner      = getOwner();
+        auto propServer = owner->getPropertyServer();
+        propServer->getRawData(
+            OB_RAW_DATA_IMU_CALIB_PARAM,
+            [&](OBDataTranState state, OBDataChunk *dataChunk) {
+                if(state == DATA_TRAN_STAT_TRANSFERRING) {
+                    data.insert(data.end(), dataChunk->data, dataChunk->data + dataChunk->size);
+                }
+            },
+            PROP_ACCESS_INTERNAL);
+    }
+    catch(...) {
+        LOG_ERROR("Get imu calibration params failed!");
+        data.clear();
+    }
+
+    if(data.empty()) {
+        imuCalibParam_ = IMUCorrector::getDefaultImuCalibParam();
+    }
+    else {
+        imuCalibParam_ = IMUCorrector::parserIMUCalibParamRaw(data.data(), static_cast<uint32_t>(data.size()));
+        LOG_DEBUG("Get imu calibration params success!");
+    }
+}
+void Astra2AlgParamManager::registerBasicExtrinsics() {
+    auto extrinsicMgr              = StreamExtrinsicsManager::getInstance();
+    auto depthBasicStreamProfile   = StreamProfileFactory::createVideoStreamProfile(OB_STREAM_DEPTH, OB_FORMAT_ANY, OB_WIDTH_ANY, OB_HEIGHT_ANY, OB_FPS_ANY);
+    auto colorBasicStreamProfile   = StreamProfileFactory::createVideoStreamProfile(OB_STREAM_COLOR, OB_FORMAT_ANY, OB_WIDTH_ANY, OB_HEIGHT_ANY, OB_FPS_ANY);
+    auto irBasicStreamProfile      = StreamProfileFactory::createVideoStreamProfile(OB_STREAM_IR, OB_FORMAT_ANY, OB_WIDTH_ANY, OB_HEIGHT_ANY, OB_FPS_ANY);
+    auto accelBasicStreamProfile   = StreamProfileFactory::createAccelStreamProfile(OB_ACCEL_FS_2g, OB_SAMPLE_RATE_1_5625_HZ);
+    auto gyroBasicStreamProfile    = StreamProfileFactory::createGyroStreamProfile(OB_GYRO_FS_16dps, OB_SAMPLE_RATE_1_5625_HZ);
+
+    if(!calibrationCameraParamList_.empty()) {
+        auto d2cExtrinsic = calibrationCameraParamList_.front().transform;
+        bool mirrored     = false;
+        {
+            auto owner      = getOwner();
+            auto propServer = owner->getPropertyServer();
+            if(propServer->isPropertySupported(OB_PROP_DEPTH_MIRROR_MODULE_STATUS_BOOL, PROP_OP_READ, PROP_ACCESS_INTERNAL)) {
+                mirrored = propServer->getPropertyValueT<bool>(OB_PROP_DEPTH_MIRROR_MODULE_STATUS_BOOL);
+            }
+        }
+        if(mirrored) {
+            (d2cExtrinsic.rot)[1] *= -1.0;
+            (d2cExtrinsic.rot)[2] *= -1.0;
+            (d2cExtrinsic.rot)[3] *= -1.0;
+            (d2cExtrinsic.rot)[6] *= -1.0;
+            (d2cExtrinsic.trans)[0] *= -1.0;
+        }
+        extrinsicMgr->registerExtrinsics(depthBasicStreamProfile, colorBasicStreamProfile, d2cExtrinsic);
+    }
+
+    extrinsicMgr->registerSameExtrinsics(irBasicStreamProfile, depthBasicStreamProfile);
+
+    double imuExtr[16] = { 0 };
+    memcpy(imuExtr, imuCalibParam_.singleIMUParams[0].imu_to_cam_extrinsics, sizeof(imuExtr));
+
+    OBExtrinsic imu_to_depth;
+    imu_to_depth.rot[0] = (float)imuExtr[0];
+    imu_to_depth.rot[1] = (float)imuExtr[1];
+
+    imu_to_depth.rot[2]   = (float)imuExtr[2];
+    imu_to_depth.rot[3]   = (float)imuExtr[4];
+    imu_to_depth.rot[4]   = (float)imuExtr[5];
+    imu_to_depth.rot[5]   = (float)imuExtr[6];
+    imu_to_depth.rot[6]   = (float)imuExtr[8];
+    imu_to_depth.rot[7]   = (float)imuExtr[9];
+    imu_to_depth.rot[8]   = (float)imuExtr[10];
+    imu_to_depth.trans[0] = (float)imuExtr[3];
+    imu_to_depth.trans[1] = (float)imuExtr[7];
+    imu_to_depth.trans[2] = (float)imuExtr[11];
+    extrinsicMgr->registerExtrinsics(accelBasicStreamProfile, depthBasicStreamProfile, imu_to_depth);
+    extrinsicMgr->registerSameExtrinsics(gyroBasicStreamProfile, accelBasicStreamProfile);
+
+    basicStreamProfileList_.emplace_back(depthBasicStreamProfile);
+    basicStreamProfileList_.emplace_back(colorBasicStreamProfile);
+    basicStreamProfileList_.emplace_back(irBasicStreamProfile);
+    basicStreamProfileList_.emplace_back(accelBasicStreamProfile);
+    basicStreamProfileList_.emplace_back(gyroBasicStreamProfile);
+}
+
+}  // namespace libobsensor
diff --git a/src/device/astra2/Astra2AlgParamManager.hpp b/src/device/astra2/Astra2AlgParamManager.hpp
new file mode 100644
index 00000000..e8be7885
--- /dev/null
+++ b/src/device/astra2/Astra2AlgParamManager.hpp
@@ -0,0 +1,20 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include "param/AlgParamManager.hpp"
+
+namespace libobsensor {
+class Astra2AlgParamManager : public DisparityAlgParamManagerBase {
+public:
+    Astra2AlgParamManager(IDevice *owner);
+    virtual ~Astra2AlgParamManager() = default;
+
+    void fetchParamFromDevice() override;
+    void registerBasicExtrinsics() override;
+
+private:
+    std::vector<OBDepthCalibrationParam> depthCalibParamList_;
+};
+}  // namespace libobsensor
diff --git a/src/device/astra2/Astra2DepthWorkModeManager.cpp b/src/device/astra2/Astra2DepthWorkModeManager.cpp
new file mode 100644
index 00000000..17a1b00e
--- /dev/null
+++ b/src/device/astra2/Astra2DepthWorkModeManager.cpp
@@ -0,0 +1,75 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "Astra2DepthWorkModeManager.hpp"
+#include "property/InternalProperty.hpp"
+#include "logger/Logger.hpp"
+
+namespace libobsensor {
+
+Astra2DepthWorkModeManager::Astra2DepthWorkModeManager(IDevice *owner) : DeviceComponentBase(owner) {
+
+    auto propServer = owner->getPropertyServer();
+
+    depthWorkModeList_ = propServer->getStructureDataListProtoV1_1_T<OBDepthWorkMode_Internal, 0>(OB_RAW_DATA_DEPTH_ALG_MODE_LIST);
+    // remove factory Calibration mode
+    depthWorkModeList_.erase(std::remove_if(depthWorkModeList_.begin(), depthWorkModeList_.end(),
+                                            [](const OBDepthWorkMode_Internal &mode) {  //
+                                                return strncmp(mode.name, "Factory Calibration", sizeof(mode.name)) == 0;
+                                            }),
+                             depthWorkModeList_.end());
+
+    currentWorkMode_ = propServer->getStructureDataProtoV1_1_T<OBDepthWorkMode_Internal, 0>(OB_STRUCT_CURRENT_DEPTH_ALG_MODE);
+}
+
+std::vector<OBDepthWorkMode_Internal> Astra2DepthWorkModeManager::getDepthWorkModeList() const {
+    return depthWorkModeList_;
+}
+
+const OBDepthWorkMode_Internal &Astra2DepthWorkModeManager::getCurrentDepthWorkMode() const {
+    return currentWorkMode_;
+}
+
+void Astra2DepthWorkModeManager::switchDepthWorkMode(const std::string &modeName) {
+    auto iter =
+        std::find_if(depthWorkModeList_.begin(), depthWorkModeList_.end(), [&modeName](const OBDepthWorkMode_Internal &mode) { return modeName == mode.name; });
+
+    if(iter == depthWorkModeList_.end()) {
+        std::string totalNames;
+        std::for_each(depthWorkModeList_.begin(), depthWorkModeList_.end(), [&totalNames](const OBDepthWorkMode_Internal &mode) {
+            if(!totalNames.empty()) {
+                totalNames += ",";
+            }
+            totalNames += mode.name;
+        });
+        throw unsupported_operation_exception("Invalid depth mode: " + modeName + ", support depth work mode list: " + totalNames);
+    }
+
+    OBDepthWorkMode_Internal dstMode = *iter;
+    switchDepthWorkMode(dstMode);
+}
+
+void Astra2DepthWorkModeManager::switchDepthWorkMode(const OBDepthWorkMode_Internal &targetDepthMode) {
+    auto owner = getOwner();
+    {
+        auto propServer = owner->getPropertyServer();  // get property server first to lock resource to avoid start stream at the same time
+
+        if(owner->hasAnySensorStreamActivated()) {
+            throw unsupported_operation_exception(utils::string::to_string()
+                                                  << "Cannot switch depth work mode while any stream is started. Please stop all stream first!");
+        }
+
+        if(strncmp(currentWorkMode_.name, targetDepthMode.name, sizeof(targetDepthMode.name)) == 0) {
+            LOG_DEBUG("switchDepthWorkMode done with same mode: {1}", currentWorkMode_.name, targetDepthMode.name);
+            return;
+        }
+
+        propServer->setStructureDataProtoV1_1_T<OBDepthWorkMode_Internal, 0>(OB_STRUCT_CURRENT_DEPTH_ALG_MODE, targetDepthMode);
+        currentWorkMode_ = targetDepthMode;
+    }
+
+    LOG_INFO("Device depth work mode have been switch to: {1}, device will be reinitialize to apply the new mode.", targetDepthMode.name);
+    owner->reset();
+}
+
+}  // namespace libobsensor
diff --git a/src/device/astra2/Astra2DepthWorkModeManager.hpp b/src/device/astra2/Astra2DepthWorkModeManager.hpp
new file mode 100644
index 00000000..e767baca
--- /dev/null
+++ b/src/device/astra2/Astra2DepthWorkModeManager.hpp
@@ -0,0 +1,29 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include "IDevice.hpp"
+#include "InternalTypes.hpp"
+#include "IDepthWorkModeManager.hpp"
+#include "DeviceComponentBase.hpp"
+
+namespace libobsensor {
+
+class Astra2DepthWorkModeManager : public IDepthWorkModeManager, public DeviceComponentBase {
+public:
+    Astra2DepthWorkModeManager(IDevice *owner);
+    virtual ~Astra2DepthWorkModeManager() = default;
+
+    std::vector<OBDepthWorkMode_Internal> getDepthWorkModeList() const override;
+    const OBDepthWorkMode_Internal       &getCurrentDepthWorkMode() const override;
+    void                                  switchDepthWorkMode(const std::string &modeName) override;
+
+private:
+    void switchDepthWorkMode(const OBDepthWorkMode_Internal &targetDepthMode);
+
+private:
+    std::vector<OBDepthWorkMode_Internal> depthWorkModeList_;
+    OBDepthWorkMode_Internal              currentWorkMode_;
+};
+
+}  // namespace libobsensor
diff --git a/src/device/astra2/Astra2Device.cpp b/src/device/astra2/Astra2Device.cpp
new file mode 100644
index 00000000..2778c160
--- /dev/null
+++ b/src/device/astra2/Astra2Device.cpp
@@ -0,0 +1,569 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "Astra2Device.hpp"
+
+#include "DevicePids.hpp"
+#include "InternalTypes.hpp"
+
+#include "Platform.hpp"
+#include "utils/Utils.hpp"
+#include "environment/EnvConfig.hpp"
+#include "usb/uvc/UvcDevicePort.hpp"
+#include "stream/StreamProfileFactory.hpp"
+
+#include "FilterFactory.hpp"
+#include "publicfilters/FormatConverterProcess.hpp"
+#include "publicfilters/IMUCorrector.hpp"
+
+#include "sensor/video/VideoSensor.hpp"
+#include "sensor/video/DisparityBasedSensor.hpp"
+#include "sensor/imu/ImuStreamer.hpp"
+#include "sensor/imu/AccelSensor.hpp"
+#include "sensor/imu/GyroSensor.hpp"
+#include "timestamp/GlobalTimestampFitter.hpp"
+#include "timestamp/DeviceClockSynchronizer.hpp"
+#include "property/VendorPropertyAccessor.hpp"
+#include "property/UvcPropertyAccessor.hpp"
+#include "property/PropertyServer.hpp"
+#include "property/CommonPropertyAccessors.hpp"
+#include "property/FilterPropertyAccessors.hpp"
+#include "property/PrivateFilterPropertyAccessors.hpp"
+#include "monitor/DeviceMonitor.hpp"
+#include "firmwareupdater/FirmwareUpdater.hpp"
+
+#include "Astra2AlgParamManager.hpp"
+#include "Astra2StreamProfileFilter.hpp"
+#include "Astra2PropertyAccessors.hpp"
+#include "Astra2DepthWorkModeManager.hpp"
+#include "Astra2FrameTimestampCalculator.hpp"
+#include "Astra2DeviceSyncConfigurator.hpp"
+
+#include <algorithm>
+
+namespace libobsensor {
+
+constexpr uint8_t INTERFACE_COLOR = 4;
+constexpr uint8_t INTERFACE_IR    = 2;
+constexpr uint8_t INTERFACE_DEPTH = 0;
+
+Astra2Device::Astra2Device(const std::shared_ptr<const IDeviceEnumInfo> &info) : DeviceBase(info) {
+    init();
+}
+
+Astra2Device::~Astra2Device() noexcept {}
+
+void Astra2Device::init() {
+    initSensorList();
+    initProperties();
+
+    fetchDeviceInfo();
+    fetchExtensionInfo();
+
+    videoFrameTimestampCalculatorCreator_ = [this]() { return std::make_shared<Astra2VideoFrameTimestampCalculator>(this, deviceTimeFreq_, frameTimeFreq_); };
+
+    auto globalTimestampFilter = std::make_shared<GlobalTimestampFitter>(this);
+    registerComponent(OB_DEV_COMPONENT_GLOBAL_TIMESTAMP_FILTER, globalTimestampFilter);
+
+    auto algParamManager = std::make_shared<Astra2AlgParamManager>(this);
+    registerComponent(OB_DEV_COMPONENT_ALG_PARAM_MANAGER, algParamManager);
+
+    auto depthWorkModeManager = std::make_shared<Astra2DepthWorkModeManager>(this);
+    registerComponent(OB_DEV_COMPONENT_DEPTH_WORK_MODE_MANAGER, depthWorkModeManager);
+
+    // auto sensorStreamStrategy = std::make_shared<Astra2SensorStreamStrategy>(this);
+    // registerComponent(OB_DEV_COMPONENT_SENSOR_STREAM_STRATEGY, sensorStreamStrategy);
+
+    static const std::vector<OBMultiDeviceSyncMode> supportedSyncModes     = { OB_MULTI_DEVICE_SYNC_MODE_FREE_RUN, OB_MULTI_DEVICE_SYNC_MODE_STANDALONE,
+                                                                               OB_MULTI_DEVICE_SYNC_MODE_PRIMARY, OB_MULTI_DEVICE_SYNC_MODE_SECONDARY_SYNCED };
+    auto                                            deviceSyncConfigurator = std::make_shared<Astra2DeviceSyncConfigurator>(this, supportedSyncModes);
+    registerComponent(OB_DEV_COMPONENT_DEVICE_SYNC_CONFIGURATOR, deviceSyncConfigurator);
+
+    auto deviceClockSynchronizer = std::make_shared<DeviceClockSynchronizer>(this, deviceTimeFreq_, 1000);
+    registerComponent(OB_DEV_COMPONENT_DEVICE_CLOCK_SYNCHRONIZER, deviceClockSynchronizer);
+
+    registerComponent(OB_DEV_COMPONENT_FIRMWARE_UPDATER, [this]() {
+        std::shared_ptr<FirmwareUpdater> firmwareUpdater;
+        TRY_EXECUTE({ firmwareUpdater = std::make_shared<FirmwareUpdater>(this); })
+        return firmwareUpdater;
+    });
+}
+
+void Astra2Device::initSensorStreamProfile(std::shared_ptr<ISensor> sensor) {
+
+    auto streamProfileFilter = getComponentT<IStreamProfileFilter>(OB_DEV_COMPONENT_STREAM_PROFILE_FILTER);
+    sensor->setStreamProfileFilter(streamProfileFilter.get());
+
+    auto        depthWorkModeManager = getComponentT<IDepthWorkModeManager>(OB_DEV_COMPONENT_DEPTH_WORK_MODE_MANAGER);
+    auto        workMode             = depthWorkModeManager->getCurrentDepthWorkMode();
+    std::string workModeName         = workMode.name;
+    auto        sensorType           = sensor->getSensorType();
+    auto        streamProfile        = StreamProfileFactory::getDefaultStreamProfileFromEnvConfig(deviceInfo_->name_, sensorType, workModeName);
+    if(!streamProfile) {
+        // if not found, try to get default stream profile without work mode
+        streamProfile = StreamProfileFactory::getDefaultStreamProfileFromEnvConfig(deviceInfo_->name_, sensorType);
+    }
+    if(streamProfile) {
+        sensor->updateDefaultStreamProfile(streamProfile);
+    }
+
+    // bind params: extrinsics, intrinsics, etc.
+    auto profiles = sensor->getStreamProfileList();
+    {
+        auto algParamManager = getComponentT<IAlgParamManager>(OB_DEV_COMPONENT_ALG_PARAM_MANAGER);
+        algParamManager->bindStreamProfileParams(profiles);
+    }
+
+    LOG_INFO("Sensor {} created! Found {} stream profiles.", sensorType, profiles.size());
+    for(auto &profile: profiles) {
+        LOG_INFO(" - {}", profile);
+    }
+}
+
+void Astra2Device::initSensorList() {
+    registerComponent(OB_DEV_COMPONENT_FRAME_PROCESSOR_FACTORY, [this]() {
+        std::shared_ptr<FrameProcessorFactory> factory;
+        TRY_EXECUTE({ factory = std::make_shared<FrameProcessorFactory>(this); })
+        return factory;
+    });
+
+    registerComponent(OB_DEV_COMPONENT_STREAM_PROFILE_FILTER, [this]() { return std::make_shared<Astra2StreamProfileFilter>(this); });
+
+    auto        pal                = Platform::getInstance();
+    const auto &sourcePortInfoList = enumInfo_->getSourcePortInfoList();
+    auto depthPortInfoIter = std::find_if(sourcePortInfoList.begin(), sourcePortInfoList.end(), [](const std::shared_ptr<const SourcePortInfo> &portInfo) {
+        return portInfo->portType == SOURCE_PORT_USB_UVC && std::dynamic_pointer_cast<const USBSourcePortInfo>(portInfo)->infIndex == INTERFACE_DEPTH;
+    });
+
+    if(depthPortInfoIter != sourcePortInfoList.end()) {
+        auto depthPortInfo = *depthPortInfoIter;
+        registerComponent(
+            OB_DEV_COMPONENT_DEPTH_SENSOR,
+            [this, depthPortInfo]() {
+                auto pal    = Platform::getInstance();
+                auto port   = pal->getSourcePort(depthPortInfo);
+                auto sensor = std::make_shared<DisparityBasedSensor>(this, OB_SENSOR_DEPTH, port);
+
+                std::vector<FormatFilterConfig> formatFilterConfigs = {
+                    { FormatFilterPolicy::REPLACE, OB_FORMAT_MJPG, OB_FORMAT_RLE, nullptr },
+                };
+                auto formatConverter = getSensorFrameFilter("FrameUnpacker", OB_SENSOR_DEPTH, false);
+                if(formatConverter) {
+                    formatFilterConfigs.push_back({ FormatFilterPolicy::ADD, OB_FORMAT_MJPG, OB_FORMAT_Y16, formatConverter });
+                }
+                sensor->updateFormatFilterConfig(formatFilterConfigs);
+
+                auto frameTimestampCalculator = videoFrameTimestampCalculatorCreator_();
+                sensor->setFrameTimestampCalculator(frameTimestampCalculator);
+
+                auto globalFrameTimestampCalculator = std::make_shared<GlobalTimestampCalculator>(this, deviceTimeFreq_, frameTimeFreq_);
+                sensor->setGlobalTimestampCalculator(globalFrameTimestampCalculator);
+
+                auto frameProcessor = getComponentT<FrameProcessor>(OB_DEV_COMPONENT_DEPTH_FRAME_PROCESSOR, false);
+                if(frameProcessor) {
+                    sensor->setFrameProcessor(frameProcessor.get());
+                }
+
+                auto propServer = getPropertyServer();
+
+                propServer->setPropertyValueT<bool>(OB_PROP_DISPARITY_TO_DEPTH_BOOL, false);
+                propServer->setPropertyValueT<bool>(OB_PROP_SDK_DISPARITY_TO_DEPTH_BOOL, true);
+                sensor->markOutputDisparityFrame(true);
+
+                propServer->setPropertyValueT(OB_PROP_DEPTH_PRECISION_LEVEL_INT, OB_PRECISION_1MM);
+                sensor->setDepthUnit(1.0f);
+
+                initSensorStreamProfile(sensor);
+
+                return sensor;
+            },
+            true);
+
+        registerSensorPortInfo(OB_SENSOR_DEPTH, depthPortInfo);
+
+        registerComponent(OB_DEV_COMPONENT_DEPTH_FRAME_PROCESSOR, [this]() {
+            auto factory        = getComponentT<FrameProcessorFactory>(OB_DEV_COMPONENT_FRAME_PROCESSOR_FACTORY);
+            auto frameProcessor = factory->createFrameProcessor(OB_SENSOR_DEPTH);
+            return frameProcessor;
+        });
+
+        // the main property accessor is using the depth port(uvc xu)
+        registerComponent(OB_DEV_COMPONENT_MAIN_PROPERTY_ACCESSOR, [this, depthPortInfo]() {
+            auto pal      = Platform::getInstance();
+            auto port     = pal->getSourcePort(depthPortInfo);
+            auto accessor = std::make_shared<VendorPropertyAccessor>(this, port);
+            return accessor;
+        });
+
+        // The device monitor is using the depth port(uvc xu)
+        registerComponent(OB_DEV_COMPONENT_DEVICE_MONITOR, [this, depthPortInfo]() {
+            auto pal        = Platform::getInstance();
+            auto port       = pal->getSourcePort(depthPortInfo);
+            auto devMonitor = std::make_shared<DeviceMonitor>(this, port);
+            return devMonitor;
+        });
+    }
+
+    auto irPortInfoIter = std::find_if(sourcePortInfoList.begin(), sourcePortInfoList.end(), [](const std::shared_ptr<const SourcePortInfo> &portInfo) {
+        return portInfo->portType == SOURCE_PORT_USB_UVC && std::dynamic_pointer_cast<const USBSourcePortInfo>(portInfo)->infIndex == INTERFACE_IR;
+    });
+
+    if(irPortInfoIter != sourcePortInfoList.end()) {
+        auto irPortInfo = *irPortInfoIter;
+        registerComponent(
+            OB_DEV_COMPONENT_IR_SENSOR,
+            [this, irPortInfo]() {
+                auto pal    = Platform::getInstance();
+                auto port   = pal->getSourcePort(irPortInfo);
+                auto sensor = std::make_shared<VideoSensor>(this, OB_SENSOR_IR, port);
+
+                auto frameTimestampCalculator = videoFrameTimestampCalculatorCreator_();
+                sensor->setFrameTimestampCalculator(frameTimestampCalculator);
+
+                auto globalFrameTimestampCalculator = std::make_shared<GlobalTimestampCalculator>(this, deviceTimeFreq_, frameTimeFreq_);
+                sensor->setGlobalTimestampCalculator(globalFrameTimestampCalculator);
+
+                auto frameProcessor = getComponentT<FrameProcessor>(OB_DEV_COMPONENT_IR_FRAME_PROCESSOR, false);
+                if(frameProcessor) {
+                    sensor->setFrameProcessor(frameProcessor.get());
+                }
+
+                initSensorStreamProfile(sensor);
+
+                return sensor;
+            },
+            true);
+        registerSensorPortInfo(OB_SENSOR_IR, irPortInfo);
+
+        registerComponent(OB_DEV_COMPONENT_IR_FRAME_PROCESSOR, [this]() {
+            auto factory        = getComponentT<FrameProcessorFactory>(OB_DEV_COMPONENT_FRAME_PROCESSOR_FACTORY);
+            auto frameProcessor = factory->createFrameProcessor(OB_SENSOR_IR);
+            return frameProcessor;
+        });
+    }
+
+    auto colorPortInfoIter = std::find_if(sourcePortInfoList.begin(), sourcePortInfoList.end(), [](const std::shared_ptr<const SourcePortInfo> &portInfo) {
+        return portInfo->portType == SOURCE_PORT_USB_UVC && std::dynamic_pointer_cast<const USBSourcePortInfo>(portInfo)->infIndex == INTERFACE_COLOR;
+    });
+
+    if(colorPortInfoIter != sourcePortInfoList.end()) {
+        auto colorPortInfo = *colorPortInfoIter;
+        registerComponent(
+            OB_DEV_COMPONENT_COLOR_SENSOR,
+            [this, colorPortInfo]() {
+                auto pal    = Platform::getInstance();
+                auto port   = pal->getSourcePort(colorPortInfo);
+                auto sensor = std::make_shared<VideoSensor>(this, OB_SENSOR_COLOR, port);
+
+                std::vector<FormatFilterConfig> formatFilterConfigs = {
+                    { FormatFilterPolicy::REMOVE, OB_FORMAT_NV12, OB_FORMAT_ANY, nullptr },
+                    { FormatFilterPolicy::REPLACE, OB_FORMAT_BYR2, OB_FORMAT_RW16, nullptr },
+                };
+
+                auto formatConverter = getSensorFrameFilter("FormatConverter", OB_SENSOR_COLOR, false);
+                if(formatConverter) {
+#ifdef WIN32
+                    formatFilterConfigs.push_back({ FormatFilterPolicy::ADD, OB_FORMAT_BGR, OB_FORMAT_RGB, formatConverter });
+#else
+                    formatFilterConfigs.push_back({ FormatFilterPolicy::ADD, OB_FORMAT_MJPG, OB_FORMAT_RGB, formatConverter });
+                    formatFilterConfigs.push_back({ FormatFilterPolicy::ADD, OB_FORMAT_MJPG, OB_FORMAT_BGR, formatConverter });
+                    formatFilterConfigs.push_back({ FormatFilterPolicy::ADD, OB_FORMAT_MJPG, OB_FORMAT_BGRA, formatConverter });
+#endif
+                }
+                sensor->updateFormatFilterConfig(formatFilterConfigs);
+
+                auto frameTimestampCalculator = videoFrameTimestampCalculatorCreator_();
+                sensor->setFrameTimestampCalculator(frameTimestampCalculator);
+
+                auto globalFrameTimestampCalculator = std::make_shared<GlobalTimestampCalculator>(this, deviceTimeFreq_, frameTimeFreq_);
+                sensor->setGlobalTimestampCalculator(globalFrameTimestampCalculator);
+
+                auto frameProcessor = getComponentT<FrameProcessor>(OB_DEV_COMPONENT_COLOR_FRAME_PROCESSOR, false);
+                if(frameProcessor) {
+                    sensor->setFrameProcessor(frameProcessor.get());
+                }
+
+                initSensorStreamProfile(sensor);
+
+                return sensor;
+            },
+            true);
+        registerSensorPortInfo(OB_SENSOR_COLOR, colorPortInfo);
+
+        registerComponent(OB_DEV_COMPONENT_COLOR_FRAME_PROCESSOR, [this]() {
+            auto factory        = getComponentT<FrameProcessorFactory>(OB_DEV_COMPONENT_FRAME_PROCESSOR_FACTORY);
+            auto frameProcessor = factory->createFrameProcessor(OB_SENSOR_COLOR);
+            return frameProcessor;
+        });
+    }
+
+    auto imuPortInfoIter = std::find_if(sourcePortInfoList.begin(), sourcePortInfoList.end(), [](const std::shared_ptr<const SourcePortInfo> &portInfo) {
+        return portInfo->portType == SOURCE_PORT_USB_HID;  //
+    });
+
+    if(imuPortInfoIter != sourcePortInfoList.end()) {
+        auto imuPortInfo = *imuPortInfoIter;
+
+        registerComponent(OB_DEV_COMPONENT_IMU_STREAMER, [this, imuPortInfo]() {
+            // the gyro and accel are both on the same port and share the same filter
+            auto pal                = Platform::getInstance();
+            auto port               = pal->getSourcePort(imuPortInfo);
+            auto imuCorrectorFilter = getSensorFrameFilter("IMUCorrector", OB_SENSOR_ACCEL, true);
+
+            imuCorrectorFilter->enable(false);
+            auto dataStreamPort = std::dynamic_pointer_cast<IDataStreamPort>(port);
+            auto imuStreamer    = std::make_shared<ImuStreamer>(this, dataStreamPort, imuCorrectorFilter);
+            return imuStreamer;
+        });
+
+        registerComponent(
+            OB_DEV_COMPONENT_ACCEL_SENSOR,
+            [this, imuPortInfo]() {
+                auto pal                  = Platform::getInstance();
+                auto port                 = pal->getSourcePort(imuPortInfo);
+                auto imuStreamer          = getComponentT<ImuStreamer>(OB_DEV_COMPONENT_IMU_STREAMER);
+                auto imuStreamerSharedPtr = imuStreamer.get();
+                auto sensor               = std::make_shared<AccelSensor>(this, port, imuStreamerSharedPtr);
+
+                auto globalFrameTimestampCalculator = std::make_shared<GlobalTimestampCalculator>(this, deviceTimeFreq_, frameTimeFreq_);
+                sensor->setGlobalTimestampCalculator(globalFrameTimestampCalculator);
+
+                initSensorStreamProfile(sensor);
+
+                return sensor;
+            },
+            true);
+        registerSensorPortInfo(OB_SENSOR_ACCEL, imuPortInfo);
+
+        registerComponent(
+            OB_DEV_COMPONENT_GYRO_SENSOR,
+            [this, imuPortInfo]() {
+                auto pal                  = Platform::getInstance();
+                auto port                 = pal->getSourcePort(imuPortInfo);
+                auto imuStreamer          = getComponentT<ImuStreamer>(OB_DEV_COMPONENT_IMU_STREAMER);
+                auto imuStreamerSharedPtr = imuStreamer.get();
+                auto sensor               = std::make_shared<GyroSensor>(this, port, imuStreamerSharedPtr);
+
+                auto globalFrameTimestampCalculator = std::make_shared<GlobalTimestampCalculator>(this, deviceTimeFreq_, frameTimeFreq_);
+                sensor->setGlobalTimestampCalculator(globalFrameTimestampCalculator);
+
+                initSensorStreamProfile(sensor);
+
+                return sensor;
+            },
+            true);
+        registerSensorPortInfo(OB_SENSOR_GYRO, imuPortInfo);
+    }
+}
+
+void Astra2Device::initProperties() {
+    auto propertyServer = std::make_shared<PropertyServer>(this);
+
+    auto d2dPropertyAccessor = std::make_shared<Astra2Disp2DepthPropertyAccessor>(this);
+    propertyServer->registerProperty(OB_PROP_DISPARITY_TO_DEPTH_BOOL, "rw", "rw", d2dPropertyAccessor);      // hw
+    propertyServer->registerProperty(OB_PROP_SDK_DISPARITY_TO_DEPTH_BOOL, "rw", "rw", d2dPropertyAccessor);  // sw
+    propertyServer->registerProperty(OB_PROP_DEPTH_PRECISION_LEVEL_INT, "rw", "rw", d2dPropertyAccessor);
+    propertyServer->registerProperty(OB_STRUCT_DEPTH_PRECISION_SUPPORT_LIST, "r", "r", d2dPropertyAccessor);
+
+    auto privatePropertyAccessor = std::make_shared<PrivateFilterPropertyAccessor>(this);
+    propertyServer->registerProperty(OB_PROP_DEPTH_SOFT_FILTER_BOOL, "rw", "rw", privatePropertyAccessor);
+    propertyServer->registerProperty(OB_PROP_DEPTH_MAX_DIFF_INT, "rw", "rw", privatePropertyAccessor);
+    propertyServer->registerProperty(OB_PROP_DEPTH_MAX_SPECKLE_SIZE_INT, "rw", "rw", privatePropertyAccessor);
+
+    auto tempPropertyAccessor = std::make_shared<Astra2TempPropertyAccessor>(this);
+    propertyServer->registerProperty(OB_STRUCT_DEVICE_TEMPERATURE, "r", "r", tempPropertyAccessor);
+
+    auto sensors = getSensorTypeList();
+    for(auto &sensor: sensors) {
+        auto  pal            = Platform::getInstance();
+        auto &sourcePortInfo = getSensorPortInfo(sensor);
+        if(sensor == OB_SENSOR_COLOR) {
+            auto uvcPropertyAccessor = std::make_shared<LazyPropertyAccessor>([&sourcePortInfo]() {
+                auto pal      = Platform::getInstance();
+                auto port     = pal->getSourcePort(sourcePortInfo);
+                auto accessor = std::make_shared<UvcPropertyAccessor>(port);
+                return accessor;
+            });
+
+            propertyServer->registerProperty(OB_PROP_COLOR_AUTO_EXPOSURE_BOOL, "rw", "rw", uvcPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_COLOR_GAIN_INT, "rw", "rw", uvcPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_COLOR_SATURATION_INT, "rw", "rw", uvcPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_COLOR_AUTO_WHITE_BALANCE_BOOL, "rw", "rw", uvcPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_COLOR_WHITE_BALANCE_INT, "rw", "rw", uvcPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_COLOR_BRIGHTNESS_INT, "rw", "rw", uvcPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_COLOR_SHARPNESS_INT, "rw", "rw", uvcPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_COLOR_CONTRAST_INT, "rw", "rw", uvcPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_COLOR_POWER_LINE_FREQUENCY_INT, "rw", "rw", uvcPropertyAccessor);
+        }
+        else if(sensor == OB_SENSOR_IR) {
+            auto uvcPropertyAccessor = std::make_shared<LazyPropertyAccessor>([sourcePortInfo]() {
+                auto pal      = Platform::getInstance();
+                auto port     = pal->getSourcePort(sourcePortInfo);
+                auto accessor = std::make_shared<UvcPropertyAccessor>(port);
+                return accessor;
+            });
+            propertyServer->registerProperty(OB_PROP_IR_GAIN_INT, "rw", "rw", uvcPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_IR_AUTO_EXPOSURE_BOOL, "rw", "rw", uvcPropertyAccessor);
+        }
+        else if(sensor == OB_SENSOR_DEPTH) {
+            auto uvcPropertyAccessor = std::make_shared<LazyPropertyAccessor>([&sourcePortInfo]() {
+                auto pal      = Platform::getInstance();
+                auto port     = pal->getSourcePort(sourcePortInfo);
+                auto accessor = std::make_shared<UvcPropertyAccessor>(port);
+                return accessor;
+            });
+
+            auto vendorPropertyAccessor = std::make_shared<LazySuperPropertyAccessor>([this, &sourcePortInfo]() {
+                auto pal                    = Platform::getInstance();
+                auto port                   = pal->getSourcePort(sourcePortInfo);
+                auto vendorPropertyAccessor = std::make_shared<VendorPropertyAccessor>(this, port);
+                return vendorPropertyAccessor;
+            });
+
+            propertyServer->registerProperty(OB_PROP_IR_EXPOSURE_INT, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_COLOR_EXPOSURE_INT, "rw", "rw", vendorPropertyAccessor);  // using vendor property accessor
+            propertyServer->registerProperty(OB_PROP_LDP_BOOL, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_LASER_BOOL, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_DEPTH_HOLEFILTER_BOOL, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_LDP_STATUS_BOOL, "r", "r", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_DEPTH_ALIGN_HARDWARE_BOOL, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_DEPTH_ALIGN_HARDWARE_MODE_INT, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_HARDWARE_DISTORTION_SWITCH_BOOL, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_LASER_MODE_INT, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_BRT_BOOL, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_DEVICE_WORK_MODE_INT, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_DEPTH_MIRROR_MODULE_STATUS_BOOL, "", "r", vendorPropertyAccessor);
+
+            propertyServer->registerProperty(OB_STRUCT_VERSION, "", "r", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_RAW_DATA_EFFECTIVE_VIDEO_STREAM_PROFILE_LIST, "", "r", vendorPropertyAccessor);
+            // OB_RAW_DATA_DISPARITY_TO_DEPTH_PROFILE_LIST // todo: implemented it
+
+            propertyServer->registerProperty(OB_PROP_WATCHDOG_BOOL, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_EXTERNAL_SIGNAL_RESET_BOOL, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_STRUCT_DEVICE_TIME, "rw", "rw", vendorPropertyAccessor);
+
+            propertyServer->registerProperty(OB_STRUCT_CURRENT_DEPTH_ALG_MODE, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_STRUCT_DEVICE_SERIAL_NUMBER, "r", "r", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_STRUCT_MULTI_DEVICE_SYNC_CONFIG, "rw", "rw", vendorPropertyAccessor);
+
+            propertyServer->registerProperty(OB_RAW_DATA_DEPTH_ALG_MODE_LIST, "r", "r", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_RAW_DATA_IMU_CALIB_PARAM, "", "r", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_RAW_DATA_DEPTH_CALIB_PARAM, "", "r", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_RAW_DATA_ALIGN_CALIB_PARAM, "", "r", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_RAW_DATA_D2C_ALIGN_SUPPORT_PROFILE_LIST, "", "r", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_SDK_DEPTH_FRAME_UNPACK_BOOL, "", "rw", vendorPropertyAccessor);
+            // propertyServer->registerProperty(OB_PROP_DEPTH_RM_FILTER_BOOL, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_GYRO_ODR_INT, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_ACCEL_ODR_INT, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_ACCEL_SWITCH_BOOL, "", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_GYRO_SWITCH_BOOL, "", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_GYRO_FULL_SCALE_INT, "", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_ACCEL_FULL_SCALE_INT, "", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_STRUCT_GET_ACCEL_PRESETS_ODR_LIST, "", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_STRUCT_GET_ACCEL_PRESETS_FULL_SCALE_LIST, "", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_STRUCT_GET_GYRO_PRESETS_ODR_LIST, "", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_STRUCT_GET_GYRO_PRESETS_FULL_SCALE_LIST, "", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_DEVICE_RESET_BOOL, "", "w", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_STOP_IR_STREAM_BOOL, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_STOP_COLOR_STREAM_BOOL, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_STOP_DEPTH_STREAM_BOOL, "rw", "rw", vendorPropertyAccessor);
+        }
+        else if(sensor == OB_SENSOR_ACCEL) {
+            auto imuCorrectorFilter = getSensorFrameFilter("IMUCorrector", sensor);
+            if(imuCorrectorFilter) {
+                auto filterStateProperty = std::make_shared<FilterStatePropertyAccessor>(imuCorrectorFilter);
+                propertyServer->registerProperty(OB_PROP_SDK_ACCEL_FRAME_TRANSFORMED_BOOL, "rw", "rw", filterStateProperty);
+            }
+        }
+        else if(sensor == OB_SENSOR_GYRO) {
+            auto imuCorrectorFilter = getSensorFrameFilter("IMUCorrector", sensor);
+            if(imuCorrectorFilter) {
+                auto filterStateProperty = std::make_shared<FilterStatePropertyAccessor>(imuCorrectorFilter);
+                propertyServer->registerProperty(OB_PROP_SDK_GYRO_FRAME_TRANSFORMED_BOOL, "rw", "rw", filterStateProperty);
+            }
+        }
+    }
+
+    propertyServer->aliasProperty(OB_PROP_DEPTH_AUTO_EXPOSURE_BOOL, OB_PROP_IR_AUTO_EXPOSURE_BOOL);
+    propertyServer->aliasProperty(OB_PROP_DEPTH_GAIN_INT, OB_PROP_IR_GAIN_INT);
+    propertyServer->aliasProperty(OB_PROP_DEPTH_EXPOSURE_INT, OB_PROP_IR_EXPOSURE_INT);
+
+    auto heartbeatPropertyAccessor = std::make_shared<HeartbeatPropertyAccessor>(this);
+    propertyServer->registerProperty(OB_PROP_HEARTBEAT_BOOL, "rw", "rw", heartbeatPropertyAccessor);
+
+    auto baseLinePropertyAccessor = std::make_shared<BaselinePropertyAccessor>(this);
+    propertyServer->registerProperty(OB_STRUCT_BASELINE_CALIBRATION_PARAM, "r", "r", baseLinePropertyAccessor);
+
+    registerComponent(OB_DEV_COMPONENT_PROPERTY_SERVER, propertyServer, true);
+}
+
+std::vector<std::shared_ptr<IFilter>> Astra2Device::createRecommendedPostProcessingFilters(OBSensorType type) {
+    auto filterFactory = FilterFactory::getInstance();
+    if(type == OB_SENSOR_DEPTH) {
+        // activate depth frame processor library
+        getComponentT<FrameProcessor>(OB_DEV_COMPONENT_DEPTH_FRAME_PROCESSOR, false);
+
+        std::vector<std::shared_ptr<IFilter>> depthFilterList;
+
+        if(filterFactory->isFilterCreatorExists("DecimationFilter")) {
+            auto decimationFilter = filterFactory->createFilter("DecimationFilter");
+            depthFilterList.push_back(decimationFilter);
+        }
+
+        if(filterFactory->isFilterCreatorExists("SpatialAdvancedFilter")) {
+            auto spatFilter = filterFactory->createFilter("SpatialAdvancedFilter");
+            // magnitude, alpha, disp_diff, radius
+            std::vector<std::string> params = { "1", "0.5", "160", "1" };
+            spatFilter->updateConfig(params);
+            depthFilterList.push_back(spatFilter);
+        }
+
+        if(filterFactory->isFilterCreatorExists("TemporalFilter")) {
+            auto tempFilter = filterFactory->createFilter("TemporalFilter");
+            // diff_scale, weight
+            std::vector<std::string> params = { "0.1", "0.4" };
+            tempFilter->updateConfig(params);
+            depthFilterList.push_back(tempFilter);
+        }
+
+        if(filterFactory->isFilterCreatorExists("HoleFillingFilter")) {
+            auto hfFilter = filterFactory->createFilter("HoleFillingFilter");
+            depthFilterList.push_back(hfFilter);
+        }
+
+        if(filterFactory->isFilterCreatorExists("DisparityTransform")) {
+            auto dtFilter = filterFactory->createFilter("DisparityTransform");
+            depthFilterList.push_back(dtFilter);
+        }
+
+        if(filterFactory->isFilterCreatorExists("ThresholdFilter")) {
+            auto thresholdFilter = filterFactory->createFilter("ThresholdFilter");
+            depthFilterList.push_back(thresholdFilter);
+        }
+
+        for(size_t i = 0; i < depthFilterList.size(); i++) {
+            auto filter = depthFilterList[i];
+            if(filter->getName() != "DisparityTransform") {
+                filter->enable(false);
+            }
+        }
+        return depthFilterList;
+    }
+    else if(type == OB_SENSOR_COLOR) {
+        // activate color frame processor library
+        getComponentT<FrameProcessor>(OB_DEV_COMPONENT_COLOR_FRAME_PROCESSOR, false);
+
+        std::vector<std::shared_ptr<IFilter>> colorFilterList;
+        if(filterFactory->isFilterCreatorExists("DecimationFilter")) {
+            auto decimationFilter = filterFactory->createFilter("DecimationFilter");
+            decimationFilter->enable(false);
+            colorFilterList.push_back(decimationFilter);
+        }
+        return colorFilterList;
+    }
+
+    return {};
+}
+
+}  // namespace libobsensor
+
diff --git a/src/device/astra2/Astra2Device.hpp b/src/device/astra2/Astra2Device.hpp
new file mode 100644
index 00000000..17d9c0c5
--- /dev/null
+++ b/src/device/astra2/Astra2Device.hpp
@@ -0,0 +1,34 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include "DeviceBase.hpp"
+#include "IDeviceManager.hpp"
+#include "frameprocessor/FrameProcessor.hpp"
+
+#include <map>
+#include <memory>
+
+namespace libobsensor {
+
+class Astra2Device : public DeviceBase {
+public:
+    Astra2Device(const std::shared_ptr<const IDeviceEnumInfo> &info);
+    virtual ~Astra2Device() noexcept;
+
+    std::vector<std::shared_ptr<IFilter>> createRecommendedPostProcessingFilters(OBSensorType type) override;
+
+private:
+    void init() override;
+    void initSensorList();
+    void initProperties();
+    void initSensorStreamProfile(std::shared_ptr<ISensor> sensor);
+
+private:
+    const uint64_t                                              frameTimeFreq_  = 1000000;
+    uint64_t                                                    deviceTimeFreq_ = 1000000;
+    std::function<std::shared_ptr<IFrameTimestampCalculator>()> videoFrameTimestampCalculatorCreator_;
+};
+
+}  // namespace libobsensor
+
diff --git a/src/device/astra2/Astra2DeviceInfo.cpp b/src/device/astra2/Astra2DeviceInfo.cpp
new file mode 100644
index 00000000..def04e07
--- /dev/null
+++ b/src/device/astra2/Astra2DeviceInfo.cpp
@@ -0,0 +1,59 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "Astra2DeviceInfo.hpp"
+#include "Astra2Device.hpp"
+#include "usb/UsbPortGroup.hpp"
+#include "DevicePids.hpp"
+
+#include <map>
+
+namespace libobsensor {
+
+const std::map<int, std::string> Astra2DeviceNameMap = { { 0x0660, "Astra2" } };
+
+Astra2DeviceInfo::Astra2DeviceInfo(const SourcePortInfoList groupedInfoList) {
+    auto portInfo = std::dynamic_pointer_cast<const USBSourcePortInfo>(groupedInfoList.front());
+
+    auto iter = Astra2DeviceNameMap.find(portInfo->pid);
+    if(iter != Astra2DeviceNameMap.end()) {
+        name_ = iter->second;
+    }
+    else {
+        name_ = "Astra2 series device";
+    }
+
+    fullName_ = "Orbbec " + name_;
+
+    pid_                = portInfo->pid;
+    vid_                = portInfo->vid;
+    uid_                = portInfo->uid;
+    deviceSn_           = portInfo->serial;
+    connectionType_     = portInfo->connSpec;
+    sourcePortInfoList_ = groupedInfoList;
+}
+
+Astra2DeviceInfo::~Astra2DeviceInfo() noexcept {}
+
+std::shared_ptr<IDevice> Astra2DeviceInfo::createDevice() const {
+    return std::make_shared<Astra2Device>(shared_from_this());
+}
+
+std::vector<std::shared_ptr<IDeviceEnumInfo>> Astra2DeviceInfo::pickDevices(const SourcePortInfoList infoList) {
+    std::vector<std::shared_ptr<IDeviceEnumInfo>> Astra2DeviceInfos;
+    auto                                          remainder = FilterUSBPortInfoByPid(infoList, Astra2DevPids);
+    auto                                          groups    = utils::groupVector<std::shared_ptr<const SourcePortInfo>>(remainder, GroupUSBSourcePortByUrl);
+    auto                                          iter      = groups.begin();
+    while(iter != groups.end()) {
+        if(iter->size() >= 4) {
+            auto info = std::make_shared<Astra2DeviceInfo>(*iter);
+            Astra2DeviceInfos.push_back(info);
+        }
+        iter++;
+    }
+
+    return Astra2DeviceInfos;
+}
+
+}  // namespace libobsensor
+
diff --git a/src/device/astra2/Astra2DeviceInfo.hpp b/src/device/astra2/Astra2DeviceInfo.hpp
new file mode 100644
index 00000000..c5f6684e
--- /dev/null
+++ b/src/device/astra2/Astra2DeviceInfo.hpp
@@ -0,0 +1,25 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include "devicemanager/DeviceEnumInfoBase.hpp"
+
+#include <iostream>
+#include <string>
+#include <vector>
+#include <memory>
+
+namespace libobsensor {
+
+class Astra2DeviceInfo : public DeviceEnumInfoBase, public std::enable_shared_from_this<Astra2DeviceInfo> {
+public:
+    Astra2DeviceInfo(const SourcePortInfoList groupedInfoList);
+    ~Astra2DeviceInfo() noexcept;
+
+    std::shared_ptr<IDevice> createDevice() const override;
+
+    static std::vector<std::shared_ptr<IDeviceEnumInfo>> pickDevices(const SourcePortInfoList infoList);
+};
+
+}  // namespace libobsensor
+
diff --git a/src/device/astra2/Astra2DeviceSyncConfigurator.cpp b/src/device/astra2/Astra2DeviceSyncConfigurator.cpp
new file mode 100644
index 00000000..5fe0ced8
--- /dev/null
+++ b/src/device/astra2/Astra2DeviceSyncConfigurator.cpp
@@ -0,0 +1,55 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "Astra2DeviceSyncConfigurator.hpp"
+
+namespace libobsensor {
+
+Astra2DeviceSyncConfigurator::Astra2DeviceSyncConfigurator(IDevice *owner, const std::vector<OBMultiDeviceSyncMode> &supportedSyncModes)
+    : DeviceSyncConfiguratorOldProtocol(owner, supportedSyncModes) {}
+
+OBMultiDeviceSyncConfig Astra2DeviceSyncConfigurator::getSyncConfig() {
+    auto config = DeviceSyncConfiguratorOldProtocol::getSyncConfig();
+    if(config.syncMode == OB_MULTI_DEVICE_SYNC_MODE_SECONDARY) {
+        config.syncMode = OB_MULTI_DEVICE_SYNC_MODE_SECONDARY_SYNCED;
+    }
+    if(config.syncMode != OB_MULTI_DEVICE_SYNC_MODE_FREE_RUN && config.syncMode != OB_MULTI_DEVICE_SYNC_MODE_STANDALONE) {
+        if(config.depthDelayUs == 0) {
+            config.triggerOutDelayUs    = -1;
+            config.trigger2ImageDelayUs = 0;
+        }
+        else {
+            config.trigger2ImageDelayUs = config.depthDelayUs;
+            config.triggerOutDelayUs    = 0;
+        }
+    }
+    return config;
+}
+
+void Astra2DeviceSyncConfigurator::setSyncConfig(const OBMultiDeviceSyncConfig &deviceSyncConfig) {
+    OBMultiDeviceSyncConfig syncConfig = deviceSyncConfig;
+    if(syncConfig.syncMode != OB_MULTI_DEVICE_SYNC_MODE_FREE_RUN && syncConfig.syncMode != OB_MULTI_DEVICE_SYNC_MODE_STANDALONE) {
+        if(syncConfig.triggerOutDelayUs == -1) {
+            if(syncConfig.trigger2ImageDelayUs != 0) {
+                LOG_WARN("For Astra2 device, when triggerOutDelayUs is -1, trigger2ImageDelayUs must be 0, current value is {}, will be set to 0",
+                         syncConfig.trigger2ImageDelayUs);
+            }
+            syncConfig.depthDelayUs = 0;
+        }
+        else {
+            if(syncConfig.triggerOutDelayUs != 0) {
+                LOG_WARN("For Astra2 device, the triggerOutDelayUs only support -1 and 0, current value is {}, will be set to 0", syncConfig.triggerOutDelayUs);
+            }
+            syncConfig.depthDelayUs = syncConfig.trigger2ImageDelayUs;
+            if(syncConfig.depthDelayUs <= 0) {
+                LOG_WARN("For Astra2 device, when triggerOutDelayUs is 0, trigger2ImageDelayUs must be greater than 0, current value is {}, will be "
+                         "set to 1",
+                         syncConfig.depthDelayUs);
+                syncConfig.depthDelayUs = 1;
+            }
+        }
+    }
+    DeviceSyncConfiguratorOldProtocol::setSyncConfig(syncConfig);
+}
+
+}  // namespace libobsensor
diff --git a/src/device/astra2/Astra2DeviceSyncConfigurator.hpp b/src/device/astra2/Astra2DeviceSyncConfigurator.hpp
new file mode 100644
index 00000000..9ca29a57
--- /dev/null
+++ b/src/device/astra2/Astra2DeviceSyncConfigurator.hpp
@@ -0,0 +1,26 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+
+#pragma once
+#include "IDevice.hpp"
+#include "IDeviceSyncConfigurator.hpp"
+#include "DeviceComponentBase.hpp"
+#include "syncconfig/DeviceSyncConfigurator.hpp"
+
+#include <vector>
+#include <memory>
+#include <map>
+
+namespace libobsensor {
+
+class Astra2DeviceSyncConfigurator : public DeviceSyncConfiguratorOldProtocol {
+public:
+    Astra2DeviceSyncConfigurator(IDevice *owner, const std::vector<OBMultiDeviceSyncMode> &supportedSyncModes);
+    virtual ~Astra2DeviceSyncConfigurator() = default;
+
+    OBMultiDeviceSyncConfig getSyncConfig() override;
+    void                    setSyncConfig(const OBMultiDeviceSyncConfig &deviceSyncConfig) override;
+};
+}  // namespace libobsensor
diff --git a/src/device/astra2/Astra2FrameTimestampCalculator.cpp b/src/device/astra2/Astra2FrameTimestampCalculator.cpp
new file mode 100644
index 00000000..f66f25e5
--- /dev/null
+++ b/src/device/astra2/Astra2FrameTimestampCalculator.cpp
@@ -0,0 +1,37 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "Astra2FrameTimestampCalculator.hpp"
+#include "usb/uvc/UvcTypes.hpp"
+#include "frame/Frame.hpp"
+
+namespace libobsensor {
+
+Astra2VideoFrameTimestampCalculator::Astra2VideoFrameTimestampCalculator(IDevice *owner, uint64_t deviceTimeFreq, uint64_t frameTimeFreq)
+    : FrameTimestampCalculatorBaseDeviceTime(owner, deviceTimeFreq, frameTimeFreq) {}
+
+void Astra2VideoFrameTimestampCalculator::calculate(std::shared_ptr<Frame> frame) {
+    auto srcTimestamp = frame->getTimeStampUsec();
+
+    auto metadata   = frame->getMetadata();
+    auto uvcPayload = reinterpret_cast<const StandardUvcFramePayloadHeader *>(metadata);
+    // merge byte1 and byte2 as int16_t as the timestamp offset
+    auto timestampOffsetUs = (static_cast<int16_t>(uvcPayload->scrSourceClock[2] << 8) | uvcPayload->scrSourceClock[1]) * 100;
+    srcTimestamp += timestampOffsetUs;
+
+    auto rstTimestamp = FrameTimestampCalculatorBaseDeviceTime::calculate(srcTimestamp);
+    frame->setTimeStampUsec(rstTimestamp);
+}
+
+Astra2LVideoFrameTimestampCalculator::Astra2LVideoFrameTimestampCalculator(IDevice *owner, uint64_t deviceTimeFreq, uint64_t frameTimeFreq)
+    : FrameTimestampCalculatorBaseDeviceTime(owner, deviceTimeFreq, frameTimeFreq) {}
+
+void Astra2LVideoFrameTimestampCalculator::calculate(std::shared_ptr<Frame> frame) {
+    auto metadata     = frame->getMetadata();
+    auto uvcPayload   = reinterpret_cast<const StandardUvcFramePayloadHeader *>(metadata);
+    auto srcTimestamp = *reinterpret_cast<const uint32_t *>(uvcPayload->scrSourceClock);
+    auto rstTimestamp = FrameTimestampCalculatorBaseDeviceTime::calculate(srcTimestamp);
+    frame->setTimeStampUsec(rstTimestamp);
+}
+
+}  // namespace libobsensor
diff --git a/src/device/astra2/Astra2FrameTimestampCalculator.hpp b/src/device/astra2/Astra2FrameTimestampCalculator.hpp
new file mode 100644
index 00000000..77c8d05e
--- /dev/null
+++ b/src/device/astra2/Astra2FrameTimestampCalculator.hpp
@@ -0,0 +1,24 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include "timestamp/FrameTimestampCalculator.hpp"
+
+namespace libobsensor {
+class Astra2VideoFrameTimestampCalculator : public FrameTimestampCalculatorBaseDeviceTime {
+public:
+    Astra2VideoFrameTimestampCalculator(IDevice *owner, uint64_t deviceTimeFreq, uint64_t frameTimeFreq);
+    ~Astra2VideoFrameTimestampCalculator() = default;
+
+    void calculate(std::shared_ptr<Frame> frame) override;
+};
+
+class Astra2LVideoFrameTimestampCalculator : public FrameTimestampCalculatorBaseDeviceTime {
+public:
+    Astra2LVideoFrameTimestampCalculator(IDevice *owner, uint64_t deviceTimeFreq, uint64_t frameTimeFreq);
+    ~Astra2LVideoFrameTimestampCalculator() = default;
+
+    void calculate(std::shared_ptr<Frame> frame) override;
+};
+}  // namespace libobsensor
diff --git a/src/device/astra2/Astra2PropertyAccessors.cpp b/src/device/astra2/Astra2PropertyAccessors.cpp
new file mode 100644
index 00000000..627a4880
--- /dev/null
+++ b/src/device/astra2/Astra2PropertyAccessors.cpp
@@ -0,0 +1,179 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "Astra2PropertyAccessors.hpp"
+#include "frameprocessor/FrameProcessor.hpp"
+#include "sensor/video/DisparityBasedSensor.hpp"
+#include "IDeviceComponent.hpp"
+
+namespace libobsensor {
+
+Astra2Disp2DepthPropertyAccessor::Astra2Disp2DepthPropertyAccessor(IDevice *owner) : owner_(owner), hwDisparityToDepthEnabled_(true) {}
+
+void Astra2Disp2DepthPropertyAccessor::setPropertyValue(uint32_t propertyId, const OBPropertyValue &value) {
+    switch(propertyId) {
+    case OB_PROP_SDK_DISPARITY_TO_DEPTH_BOOL: {
+        auto processor = owner_->getComponentT<FrameProcessor>(OB_DEV_COMPONENT_DEPTH_FRAME_PROCESSOR);
+        processor->setPropertyValue(propertyId, value);
+    } break;
+    case OB_PROP_DISPARITY_TO_DEPTH_BOOL: {
+        if(value.intValue == 1 && std::find(hwD2DSupportList_.cbegin(), hwD2DSupportList_.cend(), currentDepthUnitLevel_) == hwD2DSupportList_.end()) {
+            OBPropertyValue precisionLevel;
+            precisionLevel.intValue = hwD2DSupportList_.front();
+            setPropertyValue(OB_PROP_DEPTH_PRECISION_LEVEL_INT, precisionLevel);
+        }
+        auto propertyAccessor = owner_->getComponentT<IBasicPropertyAccessor>(OB_DEV_COMPONENT_MAIN_PROPERTY_ACCESSOR);
+        propertyAccessor->setPropertyValue(propertyId, value);
+        hwDisparityToDepthEnabled_ = static_cast<bool>(value.intValue);
+        markOutputDisparityFrame(!hwDisparityToDepthEnabled_);
+    } break;
+    case OB_PROP_DEPTH_PRECISION_LEVEL_INT: {
+        auto            processor = owner_->getComponentT<FrameProcessor>(OB_DEV_COMPONENT_DEPTH_FRAME_PROCESSOR);
+        OBPropertyValue swDisparityEnable;
+        processor->getPropertyValue(OB_PROP_SDK_DISPARITY_TO_DEPTH_BOOL, &swDisparityEnable);
+        if(swDisparityEnable.intValue == 1) {
+            processor->setPropertyValue(propertyId, value);
+        }
+        else {
+            auto commandPort = owner_->getComponentT<IBasicPropertyAccessor>(OB_DEV_COMPONENT_MAIN_PROPERTY_ACCESSOR);
+            commandPort->setPropertyValue(propertyId, value);
+        }
+
+        // update depth unit
+        auto sensor = owner_->getComponentT<DisparityBasedSensor>(OB_DEV_COMPONENT_DEPTH_SENSOR, false);
+        if(sensor) {
+            auto depthUnit = utils::depthPrecisionLevelToUnit(static_cast<OBDepthPrecisionLevel>(value.intValue));
+            sensor->setDepthUnit(depthUnit);
+        }
+
+        currentDepthUnitLevel_ = value.intValue;
+
+    } break;
+    default: {
+        auto commandPort = owner_->getComponentT<IBasicPropertyAccessor>(OB_DEV_COMPONENT_MAIN_PROPERTY_ACCESSOR);
+        commandPort->setPropertyValue(propertyId, value);
+    } break;
+    }
+}
+
+void Astra2Disp2DepthPropertyAccessor::getPropertyValue(uint32_t propertyId, OBPropertyValue *value) {
+    switch(propertyId) {
+    case OB_PROP_SDK_DISPARITY_TO_DEPTH_BOOL: {
+        auto processor = owner_->getComponentT<FrameProcessor>(OB_DEV_COMPONENT_DEPTH_FRAME_PROCESSOR);
+        processor->getPropertyValue(propertyId, value);
+    } break;
+    case OB_PROP_DISPARITY_TO_DEPTH_BOOL: {
+        value->intValue = hwDisparityToDepthEnabled_;
+    } break;
+    case OB_PROP_DEPTH_PRECISION_LEVEL_INT: {
+        auto            processor = owner_->getComponentT<FrameProcessor>(OB_DEV_COMPONENT_DEPTH_FRAME_PROCESSOR);
+        OBPropertyValue swDisparityEnable;
+        processor->getPropertyValue(OB_PROP_SDK_DISPARITY_TO_DEPTH_BOOL, &swDisparityEnable);
+        if(swDisparityEnable.intValue == 1) {
+            processor->getPropertyValue(propertyId, value);
+        }
+        else {
+            auto commandPort = owner_->getComponentT<IBasicPropertyAccessor>(OB_DEV_COMPONENT_MAIN_PROPERTY_ACCESSOR);
+            commandPort->getPropertyValue(propertyId, value);
+        }
+    } break;
+    default: {
+        auto commandPort = owner_->getComponentT<IBasicPropertyAccessor>(OB_DEV_COMPONENT_MAIN_PROPERTY_ACCESSOR);
+        commandPort->getPropertyValue(propertyId, value);
+    } break;
+    }
+}
+
+void Astra2Disp2DepthPropertyAccessor::getPropertyRange(uint32_t propertyId, OBPropertyRange *range) {
+    switch(propertyId) {
+    case OB_PROP_SDK_DISPARITY_TO_DEPTH_BOOL: {
+        auto processor = owner_->getComponentT<FrameProcessor>(OB_DEV_COMPONENT_DEPTH_FRAME_PROCESSOR);
+        processor->getPropertyRange(propertyId, range);
+    } break;
+    case OB_PROP_DISPARITY_TO_DEPTH_BOOL: {
+        range->min.intValue  = 0;
+        range->max.intValue  = 1;
+        range->step.intValue = 1;
+        range->def.intValue  = 1;
+        range->cur.intValue  = static_cast<int32_t>(hwDisparityToDepthEnabled_);
+    } break;
+    case OB_PROP_DEPTH_PRECISION_LEVEL_INT: {
+        auto            processor = owner_->getComponentT<FrameProcessor>(OB_DEV_COMPONENT_DEPTH_FRAME_PROCESSOR);
+        OBPropertyValue swDisparityEnable;
+        processor->getPropertyValue(OB_PROP_SDK_DISPARITY_TO_DEPTH_BOOL, &swDisparityEnable);
+        if(swDisparityEnable.intValue == 1) {
+            processor->getPropertyRange(propertyId, range);
+        }
+        else {
+            auto commandPort = owner_->getComponentT<IBasicPropertyAccessor>(OB_DEV_COMPONENT_MAIN_PROPERTY_ACCESSOR);
+            commandPort->getPropertyRange(propertyId, range);
+        }
+    } break;
+    default: {
+        auto commandPort = owner_->getComponentT<IBasicPropertyAccessor>(OB_DEV_COMPONENT_MAIN_PROPERTY_ACCESSOR);
+        commandPort->getPropertyRange(propertyId, range);
+    } break;
+    }
+}
+
+void Astra2Disp2DepthPropertyAccessor::markOutputDisparityFrame(bool enable) {
+    auto sensor = owner_->getComponentT<DisparityBasedSensor>(OB_DEV_COMPONENT_DEPTH_SENSOR, false);
+    if(sensor) {
+        sensor->markOutputDisparityFrame(enable);
+    }
+}
+
+void Astra2Disp2DepthPropertyAccessor::setStructureData(uint32_t propertyId, const std::vector<uint8_t> &data) {
+    utils::unusedVar(data);
+    if(propertyId == OB_STRUCT_DEPTH_PRECISION_SUPPORT_LIST) {
+        throw invalid_value_exception("OB_STRUCT_DEPTH_PRECISION_SUPPORT_LIST is read-only");
+    }
+    throw invalid_value_exception(utils::string::to_string() << "unsupported property id:" << propertyId);
+}
+
+const std::vector<uint8_t> &Astra2Disp2DepthPropertyAccessor::getStructureData(uint32_t propertyId) {
+    if(propertyId == OB_STRUCT_DEPTH_PRECISION_SUPPORT_LIST) {
+        if(hwDisparityToDepthEnabled_) {
+            static std::vector<uint16_t> hwD2DSupportList = { OB_PRECISION_0MM8, OB_PRECISION_0MM4, OB_PRECISION_0MM1 };
+            static std::vector<uint8_t>  hwD2DSupportListBytes(reinterpret_cast<uint8_t *>(hwD2DSupportList.data()),
+                                                               reinterpret_cast<uint8_t *>(hwD2DSupportList.data()) + hwD2DSupportList.size() * 2);
+            return hwD2DSupportListBytes;
+        }
+        else {
+            static std::vector<uint16_t> swD2DSupportList = { OB_PRECISION_1MM, OB_PRECISION_0MM8, OB_PRECISION_0MM4, OB_PRECISION_0MM2, OB_PRECISION_0MM1 };
+            static std::vector<uint8_t>  swD2DSupportListBytes(reinterpret_cast<uint8_t *>(swD2DSupportList.data()),
+                                                               reinterpret_cast<uint8_t *>(swD2DSupportList.data()) + swD2DSupportList.size() * 2);
+            return swD2DSupportListBytes;
+        }
+    }
+    throw invalid_value_exception(utils::string::to_string() << "unsupported property id:" << propertyId);
+}
+
+Astra2TempPropertyAccessor::Astra2TempPropertyAccessor(IDevice *owner) : owner_(owner) {}
+
+void Astra2TempPropertyAccessor::setStructureData(uint32_t propertyId, const std::vector<uint8_t> &data) {
+    utils::unusedVar(propertyId);
+    utils::unusedVar(data);
+    throw unsupported_operation_exception("Temperature params readonly!");
+}
+
+const std::vector<uint8_t> &Astra2TempPropertyAccessor::getStructureData(uint32_t propertyId) {
+    utils::unusedVar(propertyId);
+    tempData_.resize(sizeof(OBDeviceTemperature));
+
+    auto                       commandPort = owner_->getComponentT<IStructureDataAccessor>(OB_DEV_COMPONENT_MAIN_PROPERTY_ACCESSOR);
+    const std::vector<uint8_t> tempData    = commandPort->getStructureData(OB_STRUCT_DEVICE_TEMPERATURE);
+    OBDeviceTemperature        tempParam;
+    memcpy(&tempParam, tempData.data(), sizeof(OBDeviceTemperature));
+
+    tempParam.irLeftTemp     = 0;
+    tempParam.irRightTemp    = 0;
+    tempParam.chipBottomTemp = 0;
+    tempParam.chipTopTemp    = 0;
+
+    memcpy(tempData_.data(), &tempParam, sizeof(OBDeviceTemperature));
+
+    return tempData_;
+}
+
+}  // namespace libobsensor
diff --git a/src/device/astra2/Astra2PropertyAccessors.hpp b/src/device/astra2/Astra2PropertyAccessors.hpp
new file mode 100644
index 00000000..16180b7f
--- /dev/null
+++ b/src/device/astra2/Astra2PropertyAccessors.hpp
@@ -0,0 +1,47 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include "IProperty.hpp"
+#include "IDevice.hpp"
+
+namespace libobsensor {
+class Astra2Disp2DepthPropertyAccessor : public IBasicPropertyAccessor, public IStructureDataAccessor {
+public:
+    explicit Astra2Disp2DepthPropertyAccessor(IDevice *owner);
+    virtual ~Astra2Disp2DepthPropertyAccessor() noexcept = default;
+
+    virtual void setPropertyValue(uint32_t propertyId, const OBPropertyValue &value) override;
+    virtual void getPropertyValue(uint32_t propertyId, OBPropertyValue *value) override;
+    virtual void getPropertyRange(uint32_t propertyId, OBPropertyRange *range) override;
+
+    void                        setStructureData(uint32_t propertyId, const std::vector<uint8_t> &data) override;
+    const std::vector<uint8_t> &getStructureData(uint32_t propertyId) override;
+
+private:
+    void markOutputDisparityFrame(bool enable);
+
+private:
+    IDevice *owner_;
+
+    bool hwDisparityToDepthEnabled_;
+    bool swDisparityToDepthEnabled_;
+
+    int32_t                     currentDepthUnitLevel_;
+    const std::vector<uint16_t> hwD2DSupportList_ = { OB_PRECISION_0MM8, OB_PRECISION_0MM4, OB_PRECISION_0MM1 };
+    const std::vector<uint16_t> swD2DSupportList_ = { OB_PRECISION_1MM, OB_PRECISION_0MM8, OB_PRECISION_0MM4, OB_PRECISION_0MM2, OB_PRECISION_0MM1 };
+};
+
+class Astra2TempPropertyAccessor : public IStructureDataAccessor {
+public:
+    explicit Astra2TempPropertyAccessor(IDevice *owner);
+    virtual ~Astra2TempPropertyAccessor() noexcept = default;
+
+    virtual void                        setStructureData(uint32_t propertyId, const std::vector<uint8_t> &data) override;
+    virtual const std::vector<uint8_t> &getStructureData(uint32_t propertyId) override;
+
+private:
+    IDevice             *owner_;
+    std::vector<uint8_t> tempData_;
+};
+}  // namespace libobsensor
diff --git a/src/device/astra2/Astra2StreamProfileFilter.cpp b/src/device/astra2/Astra2StreamProfileFilter.cpp
new file mode 100644
index 00000000..9a17f1d2
--- /dev/null
+++ b/src/device/astra2/Astra2StreamProfileFilter.cpp
@@ -0,0 +1,95 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "Astra2StreamProfileFilter.hpp"
+
+#include "utils/Utils.hpp"
+#include "stream/StreamProfile.hpp"
+#include "exception/ObException.hpp"
+#include "property/InternalProperty.hpp"
+
+namespace libobsensor {
+Astra2StreamProfileFilter::Astra2StreamProfileFilter(IDevice *owner) : DeviceComponentBase(owner) {
+    fetchEffectiveStreamProfiles();
+}
+
+static bool isMatch(OBSensorType sensorType, std::shared_ptr<const VideoStreamProfile> videoProfile, OBEffectiveStreamProfile effProfile) {
+    bool isSensorTypeEqual = sensorType == effProfile.sensorType || (sensorType == OB_SENSOR_IR && effProfile.sensorType == OB_SENSOR_IR_LEFT);
+
+    return isSensorTypeEqual && (videoProfile->getFormat() == effProfile.format) && (videoProfile->getFps() <= effProfile.maxFps)
+           && (videoProfile->getWidth() == effProfile.width) && (videoProfile->getHeight() == effProfile.height);
+}
+
+StreamProfileList Astra2StreamProfileFilter::filter(const StreamProfileList &profiles) const {
+    StreamProfileList filteredProfiles;
+
+    for(const auto &profile: profiles) {
+        if(!profile->is<VideoStreamProfile>()) {
+            filteredProfiles.push_back(profile);
+            continue;
+        }
+        auto videoProfile = profile->as<VideoStreamProfile>();
+        auto streamType   = profile->getType();
+        auto sensorType   = utils::mapStreamTypeToSensorType(streamType);
+
+        for(auto &effProfile: effectiveStreamProfiles_) {
+            if(isMatch(sensorType, videoProfile, effProfile)) {
+                filteredProfiles.push_back(profile);
+            }
+        }
+    }
+
+    return filteredProfiles;
+}
+
+static std::vector<OBEffectiveStreamProfile> effectiveStreamProfilesParse(const std::vector<uint8_t> &data) {
+    std::vector<OBEffectiveStreamProfile> output;
+    const uint32_t                        typeSize  = sizeof(OBEffectiveStreamProfile);
+    auto                                  itemCount = data.size() / typeSize;
+    for(uint32_t i = 0; i < itemCount; i++) {
+        auto profile = reinterpret_cast<const OBEffectiveStreamProfile *>(data.data() + i * typeSize);
+        output.push_back(*profile);
+    }
+    return output;
+}
+
+void Astra2StreamProfileFilter::fetchEffectiveStreamProfiles() {
+    auto owner      = getOwner();
+    auto propServer = owner->getPropertyServer();
+
+    std::vector<uint8_t> data;
+    BEGIN_TRY_EXECUTE({
+        propServer->getRawData(
+            OB_RAW_DATA_EFFECTIVE_VIDEO_STREAM_PROFILE_LIST,
+            [&](OBDataTranState state, OBDataChunk *dataChunk) {
+                if(state == DATA_TRAN_STAT_TRANSFERRING) {
+                    data.insert(data.end(), dataChunk->data, dataChunk->data + dataChunk->size);
+                }
+            },
+            PROP_ACCESS_INTERNAL);
+    })
+    CATCH_EXCEPTION_AND_EXECUTE({
+        LOG_ERROR("Get imu calibration params failed!");
+        data.clear();
+    })
+    auto profiles            = effectiveStreamProfilesParse(data);
+    effectiveStreamProfiles_ = profiles;
+    for(auto &profile: profiles) {
+        if(profile.sensorType == OB_SENSOR_DEPTH && profile.format == OB_FORMAT_RLE) {
+            auto nerProfile   = profile;
+            nerProfile.format = OB_FORMAT_Y16;
+            effectiveStreamProfiles_.push_back(nerProfile);
+        }
+        else if(profile.sensorType == OB_SENSOR_COLOR && profile.format == OB_FORMAT_MJPG) {
+            auto nerProfile   = profile;
+            nerProfile.format = OB_FORMAT_RGB;
+            effectiveStreamProfiles_.push_back(nerProfile);
+            nerProfile.format = OB_FORMAT_BGR;
+            effectiveStreamProfiles_.push_back(nerProfile);
+            nerProfile.format = OB_FORMAT_BGRA;
+            effectiveStreamProfiles_.push_back(nerProfile);
+        }
+    }
+}
+
+}  // namespace libobsensor
diff --git a/src/device/astra2/Astra2StreamProfileFilter.hpp b/src/device/astra2/Astra2StreamProfileFilter.hpp
new file mode 100644
index 00000000..1bac0da4
--- /dev/null
+++ b/src/device/astra2/Astra2StreamProfileFilter.hpp
@@ -0,0 +1,24 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include "DeviceComponentBase.hpp"
+#include "IStreamProfile.hpp"
+#include "InternalTypes.hpp"
+
+namespace libobsensor {
+class Astra2StreamProfileFilter : public DeviceComponentBase, public IStreamProfileFilter {
+public:
+    Astra2StreamProfileFilter(IDevice *owner);
+    virtual ~Astra2StreamProfileFilter() noexcept = default;
+
+    StreamProfileList filter(const StreamProfileList &profiles) const override;
+
+private:
+    void fetchEffectiveStreamProfiles();
+
+private:
+    std::vector<OBEffectiveStreamProfile> effectiveStreamProfiles_;
+};
+}  // namespace libobsensor
diff --git a/src/device/astra2/CMakeLists.txt b/src/device/astra2/CMakeLists.txt
new file mode 100644
index 00000000..8b8a099b
--- /dev/null
+++ b/src/device/astra2/CMakeLists.txt
@@ -0,0 +1,26 @@
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+cmake_minimum_required(VERSION 3.5)
+
+
+target_sources(
+    ${OB_TARGET_DEVICE}
+    PRIVATE
+        ${CMAKE_CURRENT_LIST_DIR}/Astra2DeviceInfo.hpp
+        ${CMAKE_CURRENT_LIST_DIR}/Astra2DeviceInfo.cpp
+        ${CMAKE_CURRENT_LIST_DIR}/Astra2Device.hpp
+        ${CMAKE_CURRENT_LIST_DIR}/Astra2Device.cpp
+        ${CMAKE_CURRENT_LIST_DIR}/Astra2PropertyAccessors.hpp
+        ${CMAKE_CURRENT_LIST_DIR}/Astra2PropertyAccessors.cpp
+        ${CMAKE_CURRENT_LIST_DIR}/Astra2FrameTimestampCalculator.hpp
+        ${CMAKE_CURRENT_LIST_DIR}/Astra2FrameTimestampCalculator.cpp
+        ${CMAKE_CURRENT_LIST_DIR}/Astra2AlgParamManager.hpp
+        ${CMAKE_CURRENT_LIST_DIR}/Astra2AlgParamManager.cpp
+        ${CMAKE_CURRENT_LIST_DIR}/Astra2DepthWorkModeManager.hpp
+        ${CMAKE_CURRENT_LIST_DIR}/Astra2DepthWorkModeManager.cpp
+        ${CMAKE_CURRENT_LIST_DIR}/Astra2StreamProfileFilter.hpp
+        ${CMAKE_CURRENT_LIST_DIR}/Astra2StreamProfileFilter.cpp
+        ${CMAKE_CURRENT_LIST_DIR}/Astra2DeviceSyncConfigurator.hpp
+        ${CMAKE_CURRENT_LIST_DIR}/Astra2DeviceSyncConfigurator.cpp
+)
diff --git a/src/device/bootloader/BootDevice.cpp b/src/device/bootloader/BootDevice.cpp
new file mode 100644
index 00000000..de8a4f69
--- /dev/null
+++ b/src/device/bootloader/BootDevice.cpp
@@ -0,0 +1,62 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "BootDevice.hpp"
+
+#include "DevicePids.hpp"
+#include "InternalTypes.hpp"
+
+#include "Platform.hpp"
+#include "utils/Utils.hpp"
+#include "environment/EnvConfig.hpp"
+#include "usb/uvc/UvcDevicePort.hpp"
+#include "monitor/DeviceMonitor.hpp"
+#include "firmwareupdater/FirmwareUpdater.hpp"
+#include "property/PropertyServer.hpp"
+#include "property/VendorPropertyAccessor.hpp"
+#include "property/CommonPropertyAccessors.hpp"
+
+#include <algorithm>
+
+namespace libobsensor {
+
+BootDevice::BootDevice(const std::shared_ptr<const IDeviceEnumInfo> &info) : DeviceBase(info) {
+    init();
+}
+
+BootDevice::~BootDevice() noexcept {}
+
+void BootDevice::init() {
+    auto vendorPropertyAccessor = std::make_shared<LazySuperPropertyAccessor>([this]() {
+        auto pal                    = Platform::getInstance();
+        auto sourcePortInfoList     = enumInfo_->getSourcePortInfoList();
+        auto sourcePortInfo         = sourcePortInfoList.front();  // assume only one source port
+        auto port                   = pal->getSourcePort(sourcePortInfo);
+        auto vendorPropertyAccessor = std::make_shared<VendorPropertyAccessor>(this, port);
+        return vendorPropertyAccessor;
+    });
+
+    auto propertyServer = std::make_shared<PropertyServer>(this);
+    propertyServer->registerProperty(OB_STRUCT_VERSION, "", "r", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_STRUCT_ASIC_SERIAL_NUMBER, "r", "r", vendorPropertyAccessor);
+    registerComponent(OB_DEV_COMPONENT_PROPERTY_SERVER, propertyServer, true);
+
+    fetchDeviceInfo();
+
+    registerComponent(OB_DEV_COMPONENT_DEVICE_MONITOR, [this]() {
+        auto platform           = Platform::getInstance();
+        auto sourcePortInfoList = enumInfo_->getSourcePortInfoList();
+        auto sourcePortInfo     = sourcePortInfoList.front();  // assume only one source port
+        auto port               = platform->getSourcePort(sourcePortInfo);
+        auto devMonitor         = std::make_shared<DeviceMonitor>(this, port);
+        return devMonitor;
+    });
+
+    registerComponent(OB_DEV_COMPONENT_FIRMWARE_UPDATER, [this]() {
+        std::shared_ptr<FirmwareUpdater> firmwareUpdater;
+        TRY_EXECUTE({ firmwareUpdater = std::make_shared<FirmwareUpdater>(this); })
+        return firmwareUpdater;
+    });
+}
+
+}  // namespace libobsensor
diff --git a/src/device/bootloader/BootDevice.hpp b/src/device/bootloader/BootDevice.hpp
new file mode 100644
index 00000000..8fe9026a
--- /dev/null
+++ b/src/device/bootloader/BootDevice.hpp
@@ -0,0 +1,23 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include "DeviceBase.hpp"
+#include "IDeviceManager.hpp"
+#include "frameprocessor/FrameProcessor.hpp"
+
+#include <map>
+#include <memory>
+
+namespace libobsensor {
+
+class BootDevice : public DeviceBase {
+public:
+    BootDevice(const std::shared_ptr<const IDeviceEnumInfo> &info);
+    virtual ~BootDevice() noexcept;
+
+private:
+    void init() override;
+};
+
+}  // namespace libobsensor
diff --git a/src/device/bootloader/BootDeviceInfo.cpp b/src/device/bootloader/BootDeviceInfo.cpp
new file mode 100644
index 00000000..e2341081
--- /dev/null
+++ b/src/device/bootloader/BootDeviceInfo.cpp
@@ -0,0 +1,50 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "BootDeviceInfo.hpp"
+#include "BootDevice.hpp"
+#include "usb/UsbPortGroup.hpp"
+#include "DevicePids.hpp"
+
+#include <map>
+
+namespace libobsensor {
+
+BootDeviceInfo::BootDeviceInfo(const SourcePortInfoList groupedInfoList) {
+    auto portInfo = std::dynamic_pointer_cast<const USBSourcePortInfo>(groupedInfoList.front());
+
+    name_ = "Bootloader device";
+
+    fullName_ = "Orbbec " + name_;
+
+    pid_                = portInfo->pid;
+    vid_                = portInfo->vid;
+    uid_                = portInfo->uid;
+    deviceSn_           = portInfo->serial;
+    connectionType_     = portInfo->connSpec;
+    sourcePortInfoList_ = groupedInfoList;
+}
+
+BootDeviceInfo::~BootDeviceInfo() noexcept {}
+
+std::shared_ptr<IDevice> BootDeviceInfo::createDevice() const {
+    return std::make_shared<BootDevice>(shared_from_this());
+}
+
+std::vector<std::shared_ptr<IDeviceEnumInfo>> BootDeviceInfo::pickDevices(const SourcePortInfoList infoList) {
+    std::vector<std::shared_ptr<IDeviceEnumInfo>> BootDeviceInfos;
+    auto                                          remainder = FilterUSBPortInfoByPid(infoList, BootDevPids);
+    auto                                          groups    = utils::groupVector<std::shared_ptr<const SourcePortInfo>>(remainder, GroupUSBSourcePortByUrl);
+    auto                                          iter      = groups.begin();
+    while(iter != groups.end()) {
+        if(iter->size() >= 1) {
+            auto info = std::make_shared<BootDeviceInfo>(*iter);
+            BootDeviceInfos.push_back(info);
+        }
+        iter++;
+    }
+
+    return BootDeviceInfos;
+}
+
+}  // namespace libobsensor
diff --git a/src/device/bootloader/BootDeviceInfo.hpp b/src/device/bootloader/BootDeviceInfo.hpp
new file mode 100644
index 00000000..54eb5b1f
--- /dev/null
+++ b/src/device/bootloader/BootDeviceInfo.hpp
@@ -0,0 +1,24 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include "devicemanager/DeviceEnumInfoBase.hpp"
+
+#include <iostream>
+#include <string>
+#include <vector>
+#include <memory>
+
+namespace libobsensor {
+
+class BootDeviceInfo : public DeviceEnumInfoBase, public std::enable_shared_from_this<BootDeviceInfo> {
+public:
+    BootDeviceInfo(const SourcePortInfoList groupedInfoList);
+    ~BootDeviceInfo() noexcept;
+
+    std::shared_ptr<IDevice> createDevice() const override;
+
+    static std::vector<std::shared_ptr<IDeviceEnumInfo>> pickDevices(const SourcePortInfoList infoList);
+};
+
+}  // namespace libobsensor
diff --git a/src/device/bootloader/CMakeLists.txt b/src/device/bootloader/CMakeLists.txt
new file mode 100644
index 00000000..d8e51417
--- /dev/null
+++ b/src/device/bootloader/CMakeLists.txt
@@ -0,0 +1,14 @@
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+cmake_minimum_required(VERSION 3.5)
+
+
+target_sources(
+    ${OB_TARGET_DEVICE}
+    PRIVATE
+        ${CMAKE_CURRENT_LIST_DIR}/BootDeviceInfo.hpp
+        ${CMAKE_CURRENT_LIST_DIR}/BootDeviceInfo.cpp
+        ${CMAKE_CURRENT_LIST_DIR}/BootDevice.hpp
+        ${CMAKE_CURRENT_LIST_DIR}/BootDevice.cpp
+)
diff --git a/src/device/component/CMakeLists.txt b/src/device/component/CMakeLists.txt
new file mode 100644
index 00000000..86921302
--- /dev/null
+++ b/src/device/component/CMakeLists.txt
@@ -0,0 +1,10 @@
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+cmake_minimum_required(VERSION 3.5)
+
+file(GLOB_RECURSE SOURCE_FILES "*.cpp" EXCLUDE unittest)
+file(GLOB_RECURSE HEADERS_FILES "*.hpp" EXCLUDE unittest)
+target_sources( ${OB_TARGET_DEVICE} PRIVATE ${SOURCE_FILES} ${HEADERS_FILES})
+
+target_include_directories(${OB_TARGET_DEVICE} PUBLIC ${CMAKE_CURRENT_LIST_DIR})
diff --git a/src/device/component/DeviceComponentBase.hpp b/src/device/component/DeviceComponentBase.hpp
new file mode 100644
index 00000000..d16c8abf
--- /dev/null
+++ b/src/device/component/DeviceComponentBase.hpp
@@ -0,0 +1,26 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include "IDeviceComponent.hpp"
+#include "IDevice.hpp"
+#include "exception/ObException.hpp"
+
+#include <memory>
+
+namespace libobsensor {
+
+class DeviceComponentBase : virtual public IDeviceComponent {
+public:
+    DeviceComponentBase(IDevice *owner) : owner_(owner) {}
+
+    IDevice *getOwner() const override {
+        return owner_;
+    }
+
+private:
+    IDevice *owner_;
+};
+
+}  // namespace libobsensor
diff --git a/src/device/component/firmwareupdater/FirmwareUpdater.cpp b/src/device/component/firmwareupdater/FirmwareUpdater.cpp
new file mode 100644
index 00000000..7fc55ced
--- /dev/null
+++ b/src/device/component/firmwareupdater/FirmwareUpdater.cpp
@@ -0,0 +1,92 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "FirmwareUpdater.hpp"
+#include "environment/EnvConfig.hpp"
+#include "exception/ObException.hpp"
+#include "logger/Logger.hpp"
+
+namespace libobsensor {
+FirmwareUpdater::FirmwareUpdater(IDevice *owner) : DeviceComponentBase(owner) {
+    std::string moduleLoadPath = EnvConfig::getExtensionsDirectory() + "/firmwareupdater/";
+    try {
+        ctx_                      = std::make_shared<FirmwareUpdateContext>();
+        ctx_->dylib_              = std::make_shared<dylib>(moduleLoadPath.c_str(), "firmwareupdater");
+        ctx_->update_firmware_ext = ctx_->dylib_->get_function<void(ob_device *, const char *, ob_device_fw_update_callback, bool, void *, ob_error **)>(
+            "ob_device_update_firmware_ext");
+        ctx_->update_firmware_from_raw_data_ext =
+            ctx_->dylib_->get_function<void(ob_device *, const uint8_t *, uint32_t, ob_device_fw_update_callback, bool, void *, ob_error **)>(
+                "ob_device_update_firmware_from_raw_data_ext");
+    }
+    catch(const std::exception &e) {
+        LOG_DEBUG("Failed to load firmwareupdater library: {}", e.what());
+    }
+}
+
+FirmwareUpdater::~FirmwareUpdater() noexcept {}
+
+void FirmwareUpdater::onDeviceFwUpdateCallback(ob_fw_update_state state, const char *message, uint8_t percent, void *userData) {
+    FirmwareUpdater *updater = reinterpret_cast<FirmwareUpdater *>(userData);
+    if(updater && updater->deviceFwUpdateCallback_) {
+        LOG_DEBUG("Firmware update callback: state={}, message={}, percent={}", state, message, percent);
+        updater->deviceFwUpdateCallback_(state, message, percent);
+    }
+}
+
+void FirmwareUpdater::updateFirmwareExt(const std::string &path, DeviceFwUpdateCallback callback, bool async) {
+    deviceFwUpdateCallback_ = callback;
+    auto func               = [this, path, async]() {
+        ob_error *error  = nullptr;
+        auto      device = std::make_shared<ob_device>();
+        device->device   = getOwner()->shared_from_this();
+        ctx_->update_firmware_ext(device.get(), path.c_str(), onDeviceFwUpdateCallback, async, this, &error);
+        if(error) {
+            throw libobsensor_exception(std::string(error->message), error->exception_type);
+        }
+    };
+    if(async) {
+        std::thread([func]() {
+            try {
+                func();
+            }
+            catch(const std::exception &e) {
+                LOG_ERROR("Failed to update firmware: {}", e.what());
+            }
+        }).detach();
+    }
+    else {
+        func();
+    }
+}
+
+void FirmwareUpdater::updateFirmwareFromRawDataExt(const uint8_t *firmwareData, uint32_t firmwareSize, DeviceFwUpdateCallback callback, bool async) {
+    deviceFwUpdateCallback_ = callback;
+    deviceFwUpdateCallback_(STAT_FILE_TRANSFER, "Ready to update firmware...", 0);
+
+    // Prevent asynchronous call data from being destroyed
+    std::vector<uint8_t> data(firmwareData, firmwareData + firmwareSize);
+    auto func               = [this, data, firmwareSize, async]() {
+        ob_error *error  = nullptr;
+        auto      device = std::make_shared<ob_device>();
+        device->device   = getOwner()->shared_from_this();
+        ctx_->update_firmware_from_raw_data_ext(device.get(), data.data(), firmwareSize, onDeviceFwUpdateCallback, async, this, &error);
+        if(error) {
+            throw libobsensor_exception(std::string(error->message), error->exception_type);
+        }
+    };
+    if(async) {
+        std::thread([func]() {
+            try {
+                func();
+            }
+            catch(const std::exception &e) {
+                LOG_ERROR("Failed to update firmware: {}", e.what());
+            }
+        }).detach();
+    }
+    else {
+        func();
+    }
+}
+
+}  // namespace libobsensor
diff --git a/src/device/component/firmwareupdater/FirmwareUpdater.hpp b/src/device/component/firmwareupdater/FirmwareUpdater.hpp
new file mode 100644
index 00000000..4e711ae9
--- /dev/null
+++ b/src/device/component/firmwareupdater/FirmwareUpdater.hpp
@@ -0,0 +1,38 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include "IDevice.hpp"
+#include "DeviceComponentBase.hpp"
+#include "FirmwareUpdaterTypes.h"
+
+#include <dylib.hpp>
+
+#include <string>
+
+namespace libobsensor {
+
+class FirmwareUpdater;
+struct FirmwareUpdateContext {
+    std::shared_ptr<dylib>                            dylib_                            = nullptr;
+    pfunc_ob_device_update_firmware_ext               update_firmware_ext               = nullptr;
+    pfunc_ob_device_update_firmware_from_raw_data_ext update_firmware_from_raw_data_ext = nullptr;
+};
+
+class FirmwareUpdater : public DeviceComponentBase {
+public:
+    FirmwareUpdater(IDevice *owner);
+    virtual ~FirmwareUpdater();
+
+    static void onDeviceFwUpdateCallback(ob_fw_update_state state, const char *message, uint8_t percent, void *user_data);
+
+    void updateFirmwareExt(const std::string &path, DeviceFwUpdateCallback callback, bool async);
+    void updateFirmwareFromRawDataExt(const uint8_t *firmwareData, uint32_t firmwareSize, DeviceFwUpdateCallback callback, bool async);
+
+private:
+    std::shared_ptr<FirmwareUpdateContext> ctx_;
+    DeviceFwUpdateCallback deviceFwUpdateCallback_;
+};
+
+}  // namespace libobsensor
+
diff --git a/src/device/component/firmwareupdater/FirmwareUpdaterTypes.h b/src/device/component/firmwareupdater/FirmwareUpdaterTypes.h
new file mode 100644
index 00000000..1bac8cf2
--- /dev/null
+++ b/src/device/component/firmwareupdater/FirmwareUpdaterTypes.h
@@ -0,0 +1,20 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include "libobsensor/h/Device.h"
+#include "libobsensor/h/Error.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef void (*pfunc_ob_device_update_firmware_ext)(ob_device *device, const char *path, ob_device_fw_update_callback callback, bool async, void *user_data,
+                                                    ob_error **error);
+
+typedef void (*pfunc_ob_device_update_firmware_from_raw_data_ext)(ob_device *device, const uint8_t *firmware_data, uint32_t firmware_size,
+                                                                  ob_device_fw_update_callback callback, bool async, void *user_data, ob_error **error);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/src/device/component/frameprocessor/FrameProcessor.cpp b/src/device/component/frameprocessor/FrameProcessor.cpp
new file mode 100644
index 00000000..4c7d15b9
--- /dev/null
+++ b/src/device/component/frameprocessor/FrameProcessor.cpp
@@ -0,0 +1,312 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "FrameProcessor.hpp"
+#include "frame/FrameFactory.hpp"
+#include "utils/Utils.hpp"
+#include "environment/EnvConfig.hpp"
+
+namespace libobsensor {
+FrameProcessorFactory::FrameProcessorFactory(IDevice *owner) : DeviceComponentBase(owner) {
+    std::string moduleLoadPath = EnvConfig::getExtensionsDirectory() + "/frameprocessor/";
+    dylib_                     = std::make_shared<dylib>(moduleLoadPath.c_str(), "ob_frame_processor");
+
+    auto dylib = dylib_;
+    context_   = std::shared_ptr<FrameProcessorContext>(new FrameProcessorContext(), [dylib](FrameProcessorContext *context) {
+        if(context && context->destroy_context) {
+            ob_error *error = nullptr;
+            context->destroy_context(context->context, &error);
+            delete error;
+        }
+    });
+
+    if(dylib_) {
+        context_->create_context = dylib_->get_function<ob_frame_processor_context *(ob_device *, ob_error **)>("ob_create_frame_processor_context");
+        context_->create_processor =
+            dylib_->get_function<ob_frame_processor *(ob_frame_processor_context *, ob_sensor_type type, ob_error **)>("ob_create_frame_processor");
+        context_->get_config_schema = dylib_->get_function<const char *(ob_frame_processor *, ob_error **)>("ob_frame_processor_get_config_schema");
+        context_->update_config     = dylib_->get_function<void(ob_frame_processor *, size_t, const char **, ob_error **)>("ob_frame_processor_update_config");
+        context_->process_frame     = dylib_->get_function<ob_frame *(ob_frame_processor *, ob_frame *, ob_error **)>("ob_frame_processor_process_frame");
+        context_->destroy_processor = dylib_->get_function<void(ob_frame_processor *, ob_error **)>("ob_destroy_frame_processor");
+        context_->destroy_context   = dylib_->get_function<void(ob_frame_processor_context *, ob_error **)>("ob_destroy_frame_processor_context");
+        context_->set_hardware_d2c_params =
+            dylib->get_function<void(ob_frame_processor *, ob_camera_param, uint8_t, float, int16_t, int16_t, int16_t, int16_t, ob_error **error)>(
+                "ob_frame_processor_set_hardware_d2c_params");
+    }
+
+    if(context_->create_context && !context_->context) {
+        auto cDevice      = new ob_device;
+        cDevice->device   = owner->shared_from_this();
+        ob_error *error   = nullptr;
+        context_->context = context_->create_context(cDevice, &error);
+        if(error) {
+            // TODO
+            throw std::runtime_error("create frame processor context failed");
+        }
+
+        if(cDevice) {
+            delete cDevice;
+            cDevice = nullptr;
+        }
+    }
+}
+
+FrameProcessorFactory::~FrameProcessorFactory() noexcept {}
+
+std::shared_ptr<FrameProcessor> FrameProcessorFactory::createFrameProcessor(OBSensorType sensorType) {
+    if(context_ && (!context_->context || context_->create_processor == nullptr)) {
+        return nullptr;
+    }
+
+    auto iter = frameProcessors_.find(sensorType);
+    if(iter != frameProcessors_.end()) {
+        return iter->second;
+    }
+
+    auto                            owner = getOwner();
+    std::shared_ptr<FrameProcessor> processor;
+    TRY_EXECUTE({
+        switch(sensorType) {
+        case OB_SENSOR_DEPTH: {
+            processor = std::make_shared<DepthFrameProcessor>(owner, context_);
+        } break;
+
+        default:
+            processor = std::make_shared<FrameProcessor>(owner, context_, sensorType);
+            break;
+        }
+    })
+    frameProcessors_.insert({ sensorType, processor });
+    return processor;
+}
+
+FrameProcessor::FrameProcessor(IDevice *owner, std::shared_ptr<FrameProcessorContext> context, OBSensorType sensorType)
+    : FilterExtension("FrameProcessor"), DeviceComponentBase(owner), context_(context), sensorType_(sensorType) {
+    if(context_->context && context_->create_processor) {
+        ob_error *error   = nullptr;
+        privateProcessor_ = context_->create_processor(context_->context, sensorType, &error);
+        if(error) {
+            auto msg = std::string(error->message);
+            delete error;
+            throw std::runtime_error(msg);
+        }
+    }
+
+    if(context_->context && context_->get_config_schema) {
+        ob_error   *error  = nullptr;
+        const char *schema = context_->get_config_schema(privateProcessor_, &error);
+        if(error) {
+            delete error;
+        }
+        if(schema) {
+            configSchema_ = std::string(schema);
+        }
+    }
+}
+
+FrameProcessor::~FrameProcessor() noexcept {
+    if(context_->destroy_processor) {
+        ob_error *error = nullptr;
+        context_->destroy_processor(privateProcessor_, &error);
+        if(error) {
+            delete error;
+        }
+    }
+}
+
+std::shared_ptr<Frame> FrameProcessor::process(std::shared_ptr<const Frame> frame) {
+    if(!context_->process_frame || !privateProcessor_) {
+        return FrameFactory::createFrameFromOtherFrame(frame, true);
+    }
+
+    checkAndUpdateConfig();
+
+    ob_frame              *c_frame = new ob_frame();
+    ob_error              *error   = nullptr;
+    std::shared_ptr<Frame> resultFrame;
+    c_frame->frame = std::const_pointer_cast<Frame>(frame);
+
+    auto rst_frame = context_->process_frame(privateProcessor_, c_frame, &error);
+    if(rst_frame) {
+        resultFrame = rst_frame->frame;
+        delete rst_frame;
+    }
+    delete c_frame;
+
+    if(error) {
+        delete error;
+        return FrameFactory::createFrameFromOtherFrame(frame, true);
+    }
+
+    return resultFrame;
+}
+
+const std::string &FrameProcessor::getConfigSchema() const {
+    return configSchema_;
+}
+
+void FrameProcessor::updateConfig(std::vector<std::string> &params) {
+    ob_error                 *error = nullptr;
+    std::vector<const char *> c_params;
+    for(auto &p: params) {
+        c_params.push_back(p.c_str());
+    }
+    context_->update_config(privateProcessor_, params.size(), c_params.data(), &error);
+    if(error) {
+        delete error;
+    }
+}
+
+void FrameProcessor::setPropertyValue(uint32_t propertyId, const OBPropertyValue &value) {
+    switch(propertyId) {
+    case OB_PROP_SDK_DISPARITY_TO_DEPTH_BOOL: {
+        setConfigValue("DisparityTransform#255", static_cast<double>(value.intValue));
+    } break;
+    case OB_PROP_DEPTH_PRECISION_LEVEL_INT: {
+        auto level     = static_cast<OBDepthPrecisionLevel>(value.intValue);
+        auto depthUnit = utils::depthPrecisionLevelToUnit(level);
+        setConfigValue("DisparityTransform#2", static_cast<double>(depthUnit));
+    } break;
+    case OB_PROP_DEPTH_UNIT_FLEXIBLE_ADJUSTMENT_FLOAT: {
+        setConfigValue("DisparityTransform#2", static_cast<double>(value.floatValue));
+    } break;
+    case OB_PROP_DEPTH_SOFT_FILTER_BOOL: {
+        setConfigValueSync("NoiseRemovalFilter#255", static_cast<double>(value.intValue));
+    } break;
+    case OB_PROP_DEPTH_MAX_SPECKLE_SIZE_INT: {
+        setConfigValueSync("NoiseRemovalFilter#0", static_cast<double>(value.intValue));
+    } break;
+    case OB_PROP_DEPTH_MAX_DIFF_INT: {
+        setConfigValueSync("NoiseRemovalFilter#1", static_cast<double>(value.intValue));
+    } break;
+    default:
+        throw invalid_value_exception("Invalid property id");
+    }
+}
+
+void FrameProcessor::getPropertyValue(uint32_t propertyId, OBPropertyValue *value) {
+    switch(propertyId) {
+    case OB_PROP_SDK_DISPARITY_TO_DEPTH_BOOL: {
+        auto getValue   = getConfigValue("DisparityTransform#255");
+        value->intValue = static_cast<int32_t>(getValue);
+    } break;
+    case OB_PROP_DEPTH_PRECISION_LEVEL_INT: {
+        auto getValue       = getConfigValue("DisparityTransform#2");
+        auto precisionLevel = utils::depthUnitToPrecisionLevel(static_cast<float>(getValue));
+        value->intValue     = static_cast<int32_t>(precisionLevel);
+    } break;
+    case OB_PROP_DEPTH_UNIT_FLEXIBLE_ADJUSTMENT_FLOAT: {
+        auto getValue     = getConfigValue("DisparityTransform#2");
+        value->floatValue = static_cast<float>(getValue);
+    } break;
+    case OB_PROP_DEPTH_SOFT_FILTER_BOOL: {
+        auto getValue   = getConfigValue("NoiseRemovalFilter#255");
+        value->intValue = static_cast<int32_t>(getValue);
+    } break;
+    case OB_PROP_DEPTH_MAX_SPECKLE_SIZE_INT: {
+        auto getValue   = getConfigValue("NoiseRemovalFilter#0");
+        value->intValue = static_cast<int32_t>(getValue);
+    } break;
+    case OB_PROP_DEPTH_MAX_DIFF_INT: {
+        auto getValue   = getConfigValue("NoiseRemovalFilter#1");
+        value->intValue = static_cast<int32_t>(getValue);
+    } break;
+    default:
+        throw invalid_value_exception("Invalid property id");
+    }
+}
+
+void FrameProcessor::getPropertyRange(uint32_t propertyId, OBPropertyRange *range) {
+    std::string configName = "";
+
+    switch(propertyId) {
+    case OB_PROP_SDK_DISPARITY_TO_DEPTH_BOOL:
+        configName = "DisparityTransform#255";
+        break;
+    case OB_PROP_DEPTH_UNIT_FLEXIBLE_ADJUSTMENT_FLOAT:
+        configName = "DisparityTransform#2";
+        break;
+    case OB_PROP_DEPTH_SOFT_FILTER_BOOL:
+        configName = "NoiseRemovalFilter#255";
+        break;
+    case OB_PROP_DEPTH_MAX_SPECKLE_SIZE_INT:
+        configName = "NoiseRemovalFilter#0";
+        break;
+    case OB_PROP_DEPTH_MAX_DIFF_INT:
+        configName = "NoiseRemovalFilter#1";
+        break;
+    case OB_PROP_DEPTH_PRECISION_LEVEL_INT:
+        OBPropertyValue cur;
+        getPropertyValue(OB_PROP_DEPTH_PRECISION_LEVEL_INT, &cur);
+
+        range->cur.intValue  = cur.intValue;
+        range->def.intValue  = static_cast<int32_t>(OB_PRECISION_1MM);
+        range->max.intValue  = static_cast<int32_t>(OB_PRECISION_1MM);
+        range->min.intValue  = static_cast<int32_t>(OB_PRECISION_0MM05);
+        range->step.intValue = 1;
+        return;
+    default:
+        throw invalid_value_exception("Invalid property id");
+    }
+
+    double                   value = getConfigValue(configName);
+    OBFilterConfigSchemaItem item  = getConfigSchemaItem(configName);
+
+    if(item.type == OB_FILTER_CONFIG_VALUE_TYPE_FLOAT) {
+        range->cur.floatValue  = static_cast<float>(value);
+        range->def.floatValue  = static_cast<float>(item.def);
+        range->max.floatValue  = static_cast<float>(item.max);
+        range->min.floatValue  = static_cast<float>(item.min);
+        range->step.floatValue = static_cast<float>(item.step);
+    }
+    else {
+        range->cur.intValue  = static_cast<int32_t>(value);
+        range->def.intValue  = static_cast<int32_t>(item.def);
+        range->max.intValue  = static_cast<int32_t>(item.max);
+        range->min.intValue  = static_cast<int32_t>(item.min);
+        range->step.intValue = static_cast<int32_t>(item.step);
+    }
+}
+// Depth frame processor
+DepthFrameProcessor::DepthFrameProcessor(IDevice *owner, std::shared_ptr<FrameProcessorContext> context) : FrameProcessor(owner, context, OB_SENSOR_DEPTH) {}
+
+DepthFrameProcessor::~DepthFrameProcessor() noexcept {}
+
+void DepthFrameProcessor::setHardwareD2CProcessParams(uint32_t colorWidth, uint32_t colorHeight, uint32_t depthWidth, uint32_t depthHeight,
+                                                      std::vector<OBCameraParam> calibrationCameraParams, std::vector<OBD2CProfile> d2cProfiles) {
+    OBCameraParam currentCameraParam = {};
+    OBD2CProfile  currentD2CProfile  = {};
+    for(const auto &d2cProfile: d2cProfiles) {
+        if(d2cProfile.colorWidth == colorWidth && d2cProfile.colorHeight == colorHeight && d2cProfile.depthWidth == depthWidth
+           && d2cProfile.depthHeight == depthHeight && (d2cProfile.alignType & ALIGN_D2C_HW)) {
+            currentD2CProfile = d2cProfile;
+            break;
+        }
+    }
+
+    bool valid =
+        currentD2CProfile.colorWidth != 0 && currentD2CProfile.colorHeight != 0 && currentD2CProfile.depthWidth != 0 && currentD2CProfile.depthHeight != 0;
+    if(!valid || static_cast<size_t>(currentD2CProfile.paramIndex) + 1 > calibrationCameraParams.size()) {
+        throw invalid_value_exception("Current stream profile is not support hardware d2c process");
+        return;
+    }
+
+    currentCameraParam = calibrationCameraParams.at(currentD2CProfile.paramIndex);
+
+    if(context_->set_hardware_d2c_params) {
+        ob_error *error = nullptr;
+        context_->set_hardware_d2c_params(privateProcessor_, currentCameraParam, currentD2CProfile.paramIndex, currentD2CProfile.postProcessParam.depthScale,
+                                          currentD2CProfile.postProcessParam.alignLeft, currentD2CProfile.postProcessParam.alignTop,
+                                          currentD2CProfile.postProcessParam.alignRight, currentD2CProfile.postProcessParam.alignBottom, &error);
+        if(error) {
+            LOG_ERROR("set hardware d2c params failed");
+            delete error;
+        }
+    }
+}
+
+void DepthFrameProcessor::enableHardwareD2CProcess(bool enable) {
+    TRY_EXECUTE(setConfigValueSync("HardwareD2CProcessor#255", static_cast<double>(enable)));
+}
+
+}  // namespace libobsensor
diff --git a/src/device/component/frameprocessor/FrameProcessor.hpp b/src/device/component/frameprocessor/FrameProcessor.hpp
new file mode 100644
index 00000000..3e20a111
--- /dev/null
+++ b/src/device/component/frameprocessor/FrameProcessor.hpp
@@ -0,0 +1,87 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include "IDevice.hpp"
+#include "FilterDecorator.hpp"
+#include "PrivFrameProcessorTypes.h"
+#include "DeviceComponentBase.hpp"
+#include "InternalTypes.hpp"
+#include <dylib.hpp>
+#include <map>
+
+namespace libobsensor {
+class FrameProcessor;
+struct FrameProcessorContext {
+    ob_frame_processor_context *context = nullptr;
+
+    pfunc_ob_create_frame_processor_context          create_context          = nullptr;
+    pfunc_ob_create_frame_processor                  create_processor        = nullptr;
+    pfunc_ob_frame_processor_get_config_schema       get_config_schema       = nullptr;
+    pfunc_ob_frame_processor_update_config           update_config           = nullptr;
+    pfunc_ob_frame_processor_process_frame           process_frame           = nullptr;
+    pfunc_ob_destroy_frame_processor                 destroy_processor       = nullptr;
+    pfunc_ob_destroy_frame_processor_context         destroy_context         = nullptr;
+    pfunc_ob_frame_processor_set_hardware_d2c_params set_hardware_d2c_params = nullptr;
+};
+
+class FrameProcessorFactory : public DeviceComponentBase {
+public:
+    explicit FrameProcessorFactory(IDevice *owner);
+    ~FrameProcessorFactory() noexcept;
+
+    std::shared_ptr<FrameProcessor> createFrameProcessor(OBSensorType sensorType);
+
+private:
+    std::shared_ptr<dylib> dylib_;
+
+    std::shared_ptr<FrameProcessorContext> context_;
+
+    std::map<OBSensorType, std::shared_ptr<FrameProcessor>> frameProcessors_;
+};
+
+class FrameProcessor : public FilterExtension, public IBasicPropertyAccessor, public DeviceComponentBase {
+public:
+    FrameProcessor(IDevice *owner, std::shared_ptr<FrameProcessorContext> context, OBSensorType sensorType);
+
+    virtual ~FrameProcessor() noexcept;
+
+    const std::string &getConfigSchema() const override;
+
+    void updateConfig(std::vector<std::string> &params) override;
+
+    OBSensorType getSensorType() {
+        return sensorType_;
+    }
+
+    void setPropertyValue(uint32_t propertyId, const OBPropertyValue &value) override;
+
+    void getPropertyValue(uint32_t propertyId, OBPropertyValue *value) override;
+
+    void getPropertyRange(uint32_t propertyId, OBPropertyRange *range) override;
+
+    std::shared_ptr<Frame> process(std::shared_ptr<const Frame> frame) override;
+
+protected:
+    std::shared_ptr<FrameProcessorContext> context_;
+
+    ob_frame_processor *privateProcessor_;
+
+private:
+    OBSensorType sensorType_;
+
+    std::string configSchema_;
+};
+
+class DepthFrameProcessor : public FrameProcessor {
+public:
+    DepthFrameProcessor(IDevice *owner, std::shared_ptr<FrameProcessorContext> context);
+    virtual ~DepthFrameProcessor() noexcept;
+
+    void setHardwareD2CProcessParams(uint32_t colorWidth, uint32_t colorHeight, uint32_t depthWidth, uint32_t depthHeight,
+                                     std::vector<OBCameraParam> calibrationCameraParams, std::vector<OBD2CProfile> d2cProfiles);
+
+    void enableHardwareD2CProcess(bool enable);
+};
+
+}  // namespace libobsensor
diff --git a/src/device/component/frameprocessor/PrivFrameProcessorTypes.h b/src/device/component/frameprocessor/PrivFrameProcessorTypes.h
new file mode 100644
index 00000000..b7e042a5
--- /dev/null
+++ b/src/device/component/frameprocessor/PrivFrameProcessorTypes.h
@@ -0,0 +1,35 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include "libobsensor/h/Device.h"
+#include "libobsensor/h/Error.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct ob_frame_processor_context_t ob_frame_processor_context;
+typedef struct ob_frame_processor_t         ob_frame_processor;
+
+typedef ob_frame_processor_context *(*pfunc_ob_create_frame_processor_context)(ob_device *device, ob_error **error);
+
+typedef ob_frame_processor *(*pfunc_ob_create_frame_processor)(ob_frame_processor_context *context, ob_sensor_type type, ob_error **error);
+
+typedef const char *(*pfunc_ob_frame_processor_get_config_schema)(ob_frame_processor *processor, ob_error **error);
+
+typedef void (*pfunc_ob_frame_processor_update_config)(ob_frame_processor *processor, size_t argc, const char **argv, ob_error **error);
+
+typedef ob_frame *(*pfunc_ob_frame_processor_process_frame)(ob_frame_processor *processor, ob_frame *frame, ob_error **error);
+
+typedef void (*pfunc_ob_destroy_frame_processor)(ob_frame_processor *processor, ob_error **error);
+
+typedef void (*pfunc_ob_destroy_frame_processor_context)(ob_frame_processor_context *context, ob_error **error);
+
+typedef void (*pfunc_ob_frame_processor_set_hardware_d2c_params)(ob_frame_processor *processor, ob_camera_param camera_param, uint8_t param_index,
+                                                                 float depth_scale, int16_t align_left, int16_t align_top, int16_t align_right,
+                                                                 int16_t align_bottom, ob_error **error);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/src/device/component/metadata/FrameMetadataParserContainer.hpp b/src/device/component/metadata/FrameMetadataParserContainer.hpp
new file mode 100644
index 00000000..cfb83b59
--- /dev/null
+++ b/src/device/component/metadata/FrameMetadataParserContainer.hpp
@@ -0,0 +1,46 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include "IFrame.hpp"
+#include "IFrameMetadataParserContainerManager.hpp"
+#include "exception/ObException.hpp"
+#include "utils/Utils.hpp"
+
+#include <map>
+
+namespace libobsensor {
+
+class FrameMetadataParserContainer : public IFrameMetadataParserContainerManager {
+public:
+    FrameMetadataParserContainer(IDevice *owner) : owner_(owner) {}
+    virtual ~FrameMetadataParserContainer() = default;
+
+    virtual IDevice *getOwner() const override {
+        return owner_;
+    }
+
+    virtual void registerParser(OBFrameMetadataType type, std::shared_ptr<IFrameMetadataParser> phaser) {
+        parsers[type] = phaser;
+    }
+
+    virtual bool isContained(OBFrameMetadataType type) {
+        return parsers.find(type) != parsers.end();
+    }
+
+    virtual std::shared_ptr<IFrameMetadataParser> get(OBFrameMetadataType type) {
+        if(!isContained(type)) {
+            throw unsupported_operation_exception(utils::string::to_string() << "Not registered metadata parser for type: " << type);
+        }
+        return parsers[type];
+    }
+
+protected:
+    std::map<OBFrameMetadataType, std::shared_ptr<IFrameMetadataParser>> parsers;
+
+private:
+    IDevice *owner_ = nullptr;
+};
+
+}  // namespace libobsensor
diff --git a/src/device/component/metadata/UvcStandardTimestampParser.hpp b/src/device/component/metadata/UvcStandardTimestampParser.hpp
new file mode 100644
index 00000000..2888a3e7
--- /dev/null
+++ b/src/device/component/metadata/UvcStandardTimestampParser.hpp
@@ -0,0 +1,65 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include "usb/uvc/UvcTypes.hpp"
+#include "IFrameMetadataParser.hpp"
+#include "utils/Utils.hpp"
+
+namespace libobsensor {
+class UvcStandardTimestampParser : public IFrameMetadataParser {
+public:
+    UvcStandardTimestampParser(uint64_t clockFrequency) : clockFrequency_(clockFrequency) {}
+    ~UvcStandardTimestampParser() override = default;
+
+    int64_t getValue(const uint8_t *metadata, size_t dataSize) override {
+        if(!isSupported(metadata, dataSize)) {
+            return 0;
+        }
+        auto header = reinterpret_cast<const StandardUvcFramePayloadHeader *>(metadata);
+        return static_cast<int64_t>(static_cast<double>(header->dwPresentationTime) / clockFrequency_ * 1000000.0);  // microseconds
+    }
+
+    bool isSupported(const uint8_t *metadata, size_t dataSize) override {
+        utils::unusedVar(metadata);
+        return dataSize >= sizeof(StandardUvcFramePayloadHeader);
+    }
+
+private:
+    uint64_t clockFrequency_;
+};
+
+// Borrow source clock reference (SCR) as timestamp highest 32 bits
+class UvcTimestampParserBorrowScr : public IFrameMetadataParser {
+public:
+    UvcTimestampParserBorrowScr(uint64_t clockFrequency) : clockFrequency_(clockFrequency) {}
+    ~UvcTimestampParserBorrowScr() override = default;
+
+    int64_t getValue(const uint8_t *metadata, size_t dataSize) override {
+        if(!isSupported(metadata, dataSize)) {
+            return 0;
+        }
+        auto     header    = reinterpret_cast<const StandardUvcFramePayloadHeader *>(metadata);
+        uint64_t timestamp = header->dwPresentationTime;
+
+        // the low 4 bytes of scr as the highest 4 bytes of timestamp
+        auto scr = header->scrSourceClock;
+        timestamp |= static_cast<uint64_t>(scr[0]) << 32;
+        timestamp |= static_cast<uint64_t>(scr[1]) << 40;
+        timestamp |= static_cast<uint64_t>(scr[2]) << 48;
+        timestamp |= static_cast<uint64_t>(scr[3]) << 56;
+
+        return static_cast<int64_t>(static_cast<double>(timestamp) / clockFrequency_ * 1000000.0);  // microseconds
+    }
+
+    bool isSupported(const uint8_t *metadata, size_t dataSize) override {
+        utils::unusedVar(metadata);
+        return dataSize >= sizeof(StandardUvcFramePayloadHeader);
+    }
+
+private:
+    uint64_t clockFrequency_;
+};
+
+}  // namespace libobsensor
diff --git a/src/device/component/monitor/DeviceMonitor.cpp b/src/device/component/monitor/DeviceMonitor.cpp
new file mode 100644
index 00000000..1a696b52
--- /dev/null
+++ b/src/device/component/monitor/DeviceMonitor.cpp
@@ -0,0 +1,225 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "DeviceMonitor.hpp"
+#include "protocol/Protocol.hpp"
+
+namespace libobsensor {
+
+const uint16_t MAX_RECV_DATA_SIZE = 1024;
+
+DeviceMonitor::DeviceMonitor(IDevice *owner, std::shared_ptr<ISourcePort> dataPort)
+    : DeviceComponentBase(owner),
+      cbIdCounter_(0),
+      heartbeatEnabled_(false),
+      heartbeatPaused_(false),
+      heartbeatAndFetchStateThreadStarted_(false),
+      hbRecvData_(MAX_RECV_DATA_SIZE),
+      hbSendData_(MAX_RECV_DATA_SIZE) {
+    vendorDataPort_ = std::dynamic_pointer_cast<IVendorDataPort>(dataPort);
+    if(!vendorDataPort_) {
+        throw std::runtime_error("DeviceMonitor: data port must be a vendor data port!");
+    }
+}
+
+DeviceMonitor::~DeviceMonitor() noexcept {
+    if(heartbeatEnabled_ && !heartbeatPaused_) {
+        TRY_EXECUTE(disableHeartbeat());
+    }
+
+    if(heartbeatAndFetchStateThreadStarted_) {
+        TRY_EXECUTE(stop());
+    }
+}
+
+void DeviceMonitor::start() {
+    if(heartbeatAndFetchStateThreadStarted_) {
+        LOG_DEBUG("Heartbeat and fetch state thread already started!");
+    }
+    heartbeatAndFetchStateThreadStarted_ = true;
+    heartbeatAndFetchStateThread_        = std::thread([this]() {
+        const uint32_t HEARTBEAT_INTERVAL_MS = 3000;
+        while(heartbeatAndFetchStateThreadStarted_) {
+            std::unique_lock<std::mutex> lock(commMutex_);
+            heartbeatAndFetchStateThreadCv_.wait_for(lock, std::chrono::milliseconds(HEARTBEAT_INTERVAL_MS),
+                                                            [this]() { return !heartbeatAndFetchStateThreadStarted_; });
+            if(!heartbeatAndFetchStateThreadStarted_) {
+                break;
+            }
+            heartbeatAndFetchState();
+        }
+    });
+}
+
+void DeviceMonitor::stop() {
+    if(!heartbeatAndFetchStateThreadStarted_) {
+        LOG_DEBUG("Heartbeat and fetch state thread not started!");
+        return;
+    }
+    heartbeatAndFetchStateThreadStarted_ = false;
+    heartbeatAndFetchStateThreadCv_.notify_one();
+    heartbeatAndFetchStateThread_.join();
+    LOG_DEBUG("Heartbeat and fetch state thread stopped!");
+}
+
+void DeviceMonitor::heartbeatAndFetchState() {
+    bool emitNextHeartBeatImmediately = false;
+    do {
+        auto     req          = protocol::initHeartbeatAndStateReq(hbSendData_.data());
+        uint16_t respDataSize = 1024;  // excepted size
+        auto     res          = protocol::execute(vendorDataPort_, hbSendData_.data(), sizeof(req), hbRecvData_.data(), &respDataSize);
+        if(!protocol::checkStatus(res, false)) {
+            utils::sleepMs(50);
+            continue;
+        }
+
+        protocol::HeartbeatAndStateResp *resp;
+        BEGIN_TRY_EXECUTE({ resp = protocol::parseHeartbeatAndStateResp(hbRecvData_.data(), respDataSize); })
+        CATCH_EXCEPTION_AND_EXECUTE({ continue; })
+
+        // Heartbeat state value
+        // ==================================================
+        // |--[0, 31]bit --|--[32, 62]bit --|-- [63]bit ---|
+        // |---------------|----------------|-------------|
+        // |--ERROR msg  --|--WARNING msg --| CACHE flag  |
+        // ==================================================
+
+        // The highest bit is the device status information cache flag bit. If the device also caches other status information, the next heartbeat should be
+        // executed immediately.
+        emitNextHeartBeatImmediately = (bool)(resp->state >> 63);
+
+        // Get status code (excluding cache flag 1 bit)
+        devState_ = (OBDeviceState)(resp->state & 0x7FFFFFFFFFFFFFFF);
+
+        // The remaining information is msg
+        auto msgSize = resp->header.sizeInHalfWords * 2 - 10;  // Remove header.error and state, the remaining is msg
+
+        // Callback when firmware returns non-0 status code
+        if(0 != devState_ || msgSize) {
+            auto msg = std::string(resp->message, msgSize);
+
+            LOG_INFO("Firmware State/Log ({0}):\n{1}", devState_, msg);
+            std::lock_guard<std::mutex> lock(stateChangedCallbacksMutex_);
+            for(auto &callback: stateChangedCallbacks_) {
+                callback.second(devState_, msg);
+            }
+        }
+    } while(emitNextHeartBeatImmediately);
+}
+
+OBDeviceState DeviceMonitor::getCurrentDeviceState() const {
+    if(!heartbeatAndFetchStateThreadStarted_) {
+        LOG_WARN("Heartbeat and fetch state thread not started, the state may expired!");
+    }
+    return devState_;
+}
+
+int DeviceMonitor::registerStateChangedCallback(DeviceStateChangedCallback callback) {
+    std::lock_guard<std::mutex> lock(stateChangedCallbacksMutex_);
+    auto                        callbackId = cbIdCounter_++;
+    stateChangedCallbacks_[callbackId]     = callback;
+    if(!heartbeatAndFetchStateThreadStarted_) {
+        start();
+    }
+    return callbackId;
+}
+
+void DeviceMonitor::unregisterStateChangedCallback(int callbackId) {
+    std::lock_guard<std::mutex> lock(stateChangedCallbacksMutex_);
+    stateChangedCallbacks_.erase(callbackId);
+    if(stateChangedCallbacks_.empty() && !heartbeatPaused_ && heartbeatAndFetchStateThreadStarted_) {
+        stop();
+    }
+}
+
+void DeviceMonitor::enableHeartbeat() {
+    if(heartbeatEnabled_) {
+        LOG_DEBUG("Heartbeat already enabled!");
+        return;
+    }
+
+    auto            owner = getOwner();
+    OBPropertyValue value;
+    value.intValue    = 1;
+    auto propAccessor = owner->getComponentT<IBasicPropertyAccessor>(OB_DEV_COMPONENT_MAIN_PROPERTY_ACCESSOR);
+    propAccessor->setPropertyValue(OB_PROP_HEARTBEAT_BOOL, value);
+
+    heartbeatEnabled_ = true;
+    heartbeatPaused_  = false;
+    if(!heartbeatAndFetchStateThreadStarted_) {
+        start();
+    }
+    LOG_DEBUG("Heartbeat enabled!");
+}
+
+void DeviceMonitor::disableHeartbeat() {
+    if(!heartbeatEnabled_) {
+        LOG_DEBUG("Heartbeat already disabled!");
+        return;
+    }
+    auto owner = getOwner();
+
+    OBPropertyValue value;
+    value.intValue    = 0;
+    auto propAccessor = owner->getComponentT<IBasicPropertyAccessor>(OB_DEV_COMPONENT_MAIN_PROPERTY_ACCESSOR);
+    propAccessor->setPropertyValue(OB_PROP_HEARTBEAT_BOOL, value);
+
+    heartbeatEnabled_ = false;
+    heartbeatPaused_  = false;
+    if(heartbeatAndFetchStateThreadStarted_) {
+        stop();
+    }
+    LOG_DEBUG("Heartbeat disabled!");
+}
+
+bool DeviceMonitor::isHeartbeatEnabled() const {
+    return heartbeatEnabled_;
+}
+
+void DeviceMonitor::pauseHeartbeat() {
+    if(heartbeatPaused_) {
+        LOG_DEBUG("Heartbeat already paused!");
+        return;
+    }
+    auto            owner = getOwner();
+    OBPropertyValue value;
+    value.intValue    = 0;
+    auto propAccessor = owner->getComponentT<IBasicPropertyAccessor>(OB_DEV_COMPONENT_MAIN_PROPERTY_ACCESSOR);
+    propAccessor->setPropertyValue(OB_PROP_HEARTBEAT_BOOL, value);
+    if(heartbeatAndFetchStateThreadStarted_) {
+        stop();
+    }
+    heartbeatPaused_ = true;
+    LOG_DEBUG("Heartbeat paused!");
+}
+
+void DeviceMonitor::resumeHeartbeat() {
+    if(!heartbeatPaused_) {
+        LOG_DEBUG("Heartbeat already resumed!");
+        return;
+    }
+
+    if(heartbeatEnabled_) {
+        // resume heartbeat enable state if it was enabled before
+        auto            owner = getOwner();
+        OBPropertyValue value;
+        value.intValue    = 1;
+        auto propAccessor = owner->getComponentT<IBasicPropertyAccessor>(OB_DEV_COMPONENT_MAIN_PROPERTY_ACCESSOR);
+        propAccessor->setPropertyValue(OB_PROP_HEARTBEAT_BOOL, value);
+    }
+
+    if(heartbeatEnabled_ || !stateChangedCallbacks_.empty()) {
+        // resuming heartbeat thread if heartbeat is enabled or if there are state changed callbacks
+        start();
+    }
+    heartbeatPaused_ = false;
+    LOG_DEBUG("Heartbeat resumed!");
+}
+
+void DeviceMonitor::sendAndReceiveData(const uint8_t *sendData, uint32_t sendDataSize, uint8_t *receiveData, uint32_t *receiveDataSize) {
+    std::lock_guard<std::mutex> lock(commMutex_);
+    auto                        recvLen = vendorDataPort_->sendAndReceive(sendData, sendDataSize, receiveData, *receiveDataSize);
+    *receiveDataSize                    = recvLen;
+}
+
+}  // namespace libobsensor
diff --git a/src/device/component/monitor/DeviceMonitor.hpp b/src/device/component/monitor/DeviceMonitor.hpp
new file mode 100644
index 00000000..39f7237f
--- /dev/null
+++ b/src/device/component/monitor/DeviceMonitor.hpp
@@ -0,0 +1,52 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "IDeviceMonitor.hpp"
+#include "ISourcePort.hpp"
+#include "DeviceComponentBase.hpp"
+
+#include <map>
+
+namespace libobsensor {
+class DeviceMonitor : public IDeviceMonitor, public DeviceComponentBase {
+public:
+    DeviceMonitor(IDevice *owner, std::shared_ptr<ISourcePort> sourcePort);
+    virtual ~DeviceMonitor() noexcept;
+
+    OBDeviceState getCurrentDeviceState() const override;
+    int           registerStateChangedCallback(DeviceStateChangedCallback callback) override;
+    void          unregisterStateChangedCallback(int callbackId) override;
+    void          enableHeartbeat() override;
+    void          disableHeartbeat() override;
+    bool          isHeartbeatEnabled() const override;
+    void          pauseHeartbeat() override;
+    void          resumeHeartbeat() override;
+
+    void sendAndReceiveData(const uint8_t *sendData, uint32_t sendDataSize, uint8_t *receiveData, uint32_t *receiveDataSize) override;
+
+private:
+    void start();
+    void stop();
+    void heartbeatAndFetchState();
+
+private:
+    std::mutex                       commMutex_;
+    std::shared_ptr<IVendorDataPort> vendorDataPort_;
+
+    uint32_t                                       cbIdCounter_;
+    std::mutex                                     stateChangedCallbacksMutex_;
+    std::map<uint32_t, DeviceStateChangedCallback> stateChangedCallbacks_;
+
+    std::atomic<bool> heartbeatEnabled_;
+    std::atomic<bool> heartbeatPaused_;
+
+    std::thread             heartbeatAndFetchStateThread_;
+    std::atomic<bool>       heartbeatAndFetchStateThreadStarted_;
+    std::condition_variable heartbeatAndFetchStateThreadCv_;
+
+    std::vector<uint8_t> hbRecvData_;
+    std::vector<uint8_t> hbSendData_;
+
+    OBDeviceState devState_;
+};
+}  // namespace libobsensor
diff --git a/src/device/component/param/AlgParamManager.cpp b/src/device/component/param/AlgParamManager.cpp
new file mode 100644
index 00000000..be5669fb
--- /dev/null
+++ b/src/device/component/param/AlgParamManager.cpp
@@ -0,0 +1,369 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "AlgParamManager.hpp"
+#include "AlgParseHelper.hpp"
+#include "property/InternalProperty.hpp"
+#include "stream/StreamIntrinsicsManager.hpp"
+#include "stream/StreamExtrinsicsManager.hpp"
+#include "stream/StreamProfileFactory.hpp"
+#include "exception/ObException.hpp"
+#include "publicfilters/IMUCorrector.hpp"
+
+#include <vector>
+#include <sstream>
+#include <utility>
+
+namespace libobsensor {
+
+bool findBestMatchedD2CProfile(const std::vector<OBD2CProfile> &d2cProfileList, const std::shared_ptr<const VideoStreamProfile> &profile,
+                               OBD2CProfile &result) {
+    bool found = false;
+    // match same resolution
+    for(auto &d2cProfile: d2cProfileList) {
+        // using software align profile
+        if(d2cProfile.alignType != ALIGN_D2C_SW && d2cProfile.alignType != ALIGN_D2C_HW_SW_BOTH) {
+            continue;
+        }
+
+        auto streamType = profile->getType();
+        if((streamType == OB_STREAM_DEPTH || streamType == OB_STREAM_IR || streamType == OB_STREAM_IR_LEFT || streamType == OB_STREAM_IR_RIGHT)
+           && static_cast<uint32_t>(d2cProfile.depthWidth) == profile->getWidth() && static_cast<uint32_t>(d2cProfile.depthHeight) == profile->getHeight()) {
+            found  = true;
+            result = d2cProfile;
+            break;
+        }
+        else if(streamType == OB_STREAM_COLOR && static_cast<uint32_t>(d2cProfile.colorWidth) == profile->getWidth()
+                && static_cast<uint32_t>(d2cProfile.colorHeight) == profile->getHeight()) {
+            found  = true;
+            result = d2cProfile;
+            break;
+        }
+    }
+
+    if(!found) {
+        // match same ratio
+        float ratio = (float)profile->getWidth() / profile->getHeight();
+        for(auto &d2cProfile: d2cProfileList) {
+            // using software align profile
+            if(d2cProfile.alignType != ALIGN_D2C_SW && d2cProfile.alignType != ALIGN_D2C_HW_SW_BOTH) {
+                continue;
+            }
+
+            auto streamType = profile->getType();
+            if((streamType == OB_STREAM_DEPTH || streamType == OB_STREAM_IR || streamType == OB_STREAM_IR_LEFT || streamType == OB_STREAM_IR_RIGHT)
+               && (float)d2cProfile.depthWidth / d2cProfile.depthHeight == ratio) {
+                found  = true;
+                result = d2cProfile;
+                break;
+            }
+            else if(streamType == OB_STREAM_COLOR && (float)d2cProfile.colorWidth / d2cProfile.colorHeight == ratio) {
+                found  = true;
+                result = d2cProfile;
+                break;
+            }
+        }
+    }
+
+    return found;
+}
+
+AlgParamManagerBase::AlgParamManagerBase(IDevice *owner) : DeviceComponentBase(owner) {}
+
+void AlgParamManagerBase::bindStreamProfileParams(std::vector<std::shared_ptr<const StreamProfile>> streamProfileList) {
+    bindExtrinsic(streamProfileList);
+    bindIntrinsic(streamProfileList);
+}
+
+const std::vector<OBD2CProfile> &AlgParamManagerBase::getD2CProfileList() const {
+    return d2cProfileList_;
+}
+
+const std::vector<OBCameraParam> &AlgParamManagerBase::getCalibrationCameraParamList() const {
+    return calibrationCameraParamList_;
+}
+
+const OBIMUCalibrateParams &AlgParamManagerBase::getIMUCalibrationParam() const {
+    return imuCalibParam_;
+}
+
+void AlgParamManagerBase::bindExtrinsic(std::vector<std::shared_ptr<const StreamProfile>> streamProfileList) {
+    auto extrinsicMgr = StreamExtrinsicsManager::getInstance();
+    for(auto &sp: streamProfileList) {
+        auto basicSpIter =
+            std::find_if(basicStreamProfileList_.begin(), basicStreamProfileList_.end(), [&](const std::shared_ptr<const StreamProfile> &basicSp) {  //
+                return basicSp->getType() == sp->getType();
+            });
+        if(basicSpIter == basicStreamProfileList_.end()) {
+            throw libobsensor::unsupported_operation_exception("Can not find basic stream profile to bind extrinsic!");
+        }
+        extrinsicMgr->registerSameExtrinsics(sp, *basicSpIter);
+    }
+}
+
+void AlgParamManagerBase::bindIntrinsic(std::vector<std::shared_ptr<const StreamProfile>> streamProfileList) {
+    auto intrinsicMgr = StreamIntrinsicsManager::getInstance();
+    bool mirrored     = false;
+
+    {
+        auto owner      = getOwner();
+        auto propServer = owner->getPropertyServer();
+        if(propServer->isPropertySupported(OB_PROP_DEPTH_MIRROR_MODULE_STATUS_BOOL, PROP_OP_READ, PROP_ACCESS_INTERNAL)) {
+            mirrored = propServer->getPropertyValueT<bool>(OB_PROP_DEPTH_MIRROR_MODULE_STATUS_BOOL);
+        }
+    }
+
+    for(const auto &sp: streamProfileList) {
+        if(sp->is<AccelStreamProfile>()) {
+            const auto &imuCalibParam = getIMUCalibrationParam();
+            intrinsicMgr->registerAccelStreamIntrinsics(sp, imuCalibParam.singleIMUParams[0].acc);
+        }
+        else if(sp->is<GyroStreamProfile>()) {
+            const auto &imuCalibParam = getIMUCalibrationParam();
+            intrinsicMgr->registerGyroStreamIntrinsics(sp, imuCalibParam.singleIMUParams[0].gyro);
+        }
+        else {
+            OBCameraIntrinsic  intrinsic  = { 0 };
+            OBCameraDistortion distortion = { 0 };
+            OBD2CProfile       d2cProfile{};
+            auto               vsp = sp->as<VideoStreamProfile>();
+
+            if(!findBestMatchedD2CProfile(d2cProfileList_, vsp, d2cProfile)) {
+                throw libobsensor::unsupported_operation_exception("Can not find matched camera param!");
+            }
+
+            auto        param                      = calibrationCameraParamList_.at(d2cProfile.paramIndex);
+            auto        postProcessParam           = d2cProfile.postProcessParam;
+
+            // Fix intrinsic from calibration to d2c profile according to the ratio of resolution
+            auto ratio = static_cast<float>(d2cProfile.depthWidth) / param.depthIntrinsic.width;
+            {
+                param.rgbIntrinsic.fx *= ratio;
+                param.rgbIntrinsic.fy *= ratio;
+                param.rgbIntrinsic.cx *= ratio;
+                param.rgbIntrinsic.cy *= ratio;
+                param.rgbIntrinsic.width  = static_cast<int16_t>(static_cast<float>(param.rgbIntrinsic.width) * ratio);
+                param.rgbIntrinsic.height = static_cast<int16_t>(static_cast<float>(param.rgbIntrinsic.height) * ratio);
+
+                param.depthIntrinsic.fx *= ratio;
+                param.depthIntrinsic.fy *= ratio;
+                param.depthIntrinsic.cx *= ratio;
+                param.depthIntrinsic.cy *= ratio;
+                param.depthIntrinsic.width  = static_cast<int16_t>(static_cast<float>(param.depthIntrinsic.width) * ratio);
+                param.depthIntrinsic.height = static_cast<int16_t>(static_cast<float>(param.depthIntrinsic.height) * ratio);
+            }
+
+            auto streamType = sp->getType();
+            if(streamType == OB_STREAM_COLOR) {
+                intrinsic  = param.rgbIntrinsic;
+                distortion = param.rgbDistortion;
+            }
+            else {
+                intrinsic  = param.depthIntrinsic;
+                distortion = param.depthDistortion;
+            }
+
+            if(mirrored) {
+                // mirror intrinsic
+                intrinsic.cx  = (float)1.0 * intrinsic.width - intrinsic.cx - 1;
+                distortion.p2 = -distortion.p2;
+            }
+
+            if(streamType == OB_STREAM_COLOR) {
+                intrinsic.fx = postProcessParam.depthScale * intrinsic.fx;
+                intrinsic.fy = postProcessParam.depthScale * intrinsic.fy;
+                intrinsic.cx = postProcessParam.depthScale * intrinsic.cx + postProcessParam.alignLeft;
+                intrinsic.cy = postProcessParam.depthScale * intrinsic.cy + postProcessParam.alignTop;
+                intrinsic.width =
+                    static_cast<int16_t>(postProcessParam.depthScale * intrinsic.width + postProcessParam.alignLeft + postProcessParam.alignRight);
+                intrinsic.height =
+                    static_cast<int16_t>(postProcessParam.depthScale * intrinsic.height + postProcessParam.alignTop + postProcessParam.alignBottom);
+            }
+
+            // Fix intrinsic from calculation to actual according to the ratio of resolution
+            ratio = (float)vsp->getWidth() / (float)intrinsic.width;
+            intrinsic.fx *= ratio;
+            intrinsic.fy *= ratio;
+            intrinsic.cx *= ratio;
+            intrinsic.cy *= ratio;
+            intrinsic.width  = static_cast<int16_t>(vsp->getWidth());
+            intrinsic.height = static_cast<int16_t>((float)intrinsic.height * ratio);
+
+            intrinsicMgr->registerVideoStreamIntrinsics(sp, intrinsic);
+            intrinsicMgr->registerVideoStreamDistortion(sp, distortion);
+        }
+    }
+}
+
+DisparityAlgParamManagerBase::DisparityAlgParamManagerBase(IDevice *device) : AlgParamManagerBase(device) {}
+
+void DisparityAlgParamManagerBase::bindStreamProfileParams(std::vector<std::shared_ptr<const StreamProfile>> streamProfileList) {
+    AlgParamManagerBase::bindStreamProfileParams(streamProfileList);
+    bindDisparityParam(streamProfileList);
+}
+
+const OBDisparityParam &DisparityAlgParamManagerBase::getDisparityParam() const {
+    return disparityParam_;
+}
+
+void DisparityAlgParamManagerBase::bindDisparityParam(std::vector<std::shared_ptr<const StreamProfile>> streamProfileList) {
+    auto dispParam    = getDisparityParam();
+    auto intrinsicMgr = StreamIntrinsicsManager::getInstance();
+    for(const auto &sp: streamProfileList) {
+        if(!sp->is<DisparityBasedStreamProfile>()) {
+            continue;
+        }
+        intrinsicMgr->registerDisparityBasedStreamDisparityParam(sp, dispParam);
+    }
+}
+
+TOFDeviceCommonAlgParamManager::TOFDeviceCommonAlgParamManager(IDevice *owner) : AlgParamManagerBase(owner) {
+    fetchParamFromDevice();
+    registerBasicExtrinsics();
+}
+
+void TOFDeviceCommonAlgParamManager::fetchParamFromDevice() {
+    std::vector<uint8_t> data;
+    BEGIN_TRY_EXECUTE({
+        auto owner      = getOwner();
+        auto propServer = owner->getPropertyServer();
+        propServer->getRawData(
+            OB_RAW_DATA_ALIGN_CALIB_PARAM,
+            [&](OBDataTranState state, OBDataChunk *dataChunk) {
+                if(state == DATA_TRAN_STAT_TRANSFERRING) {
+                    data.insert(data.end(), dataChunk->data, dataChunk->data + dataChunk->size);
+                }
+            },
+            PROP_ACCESS_INTERNAL);
+    })
+    CATCH_EXCEPTION_AND_EXECUTE({
+        LOG_ERROR("Get align calibration params failed!");
+        data.clear();
+    })
+
+    if(!data.empty()) {
+        auto cameraParamList = AlgParseHelper::alignCalibParamParse(data.data(), static_cast<uint32_t>(data.size()));
+        for(auto &cameraParam: cameraParamList) {
+            OBCameraParam param;
+            param.depthIntrinsic = cameraParam.depthIntrinsic;
+            param.rgbIntrinsic   = cameraParam.rgbIntrinsic;
+            memcpy(&param.depthDistortion, &cameraParam.depthDistortion, sizeof(param.depthDistortion));
+            param.depthDistortion.model = OB_DISTORTION_BROWN_CONRADY_K6;
+            memcpy(&param.rgbDistortion, &cameraParam.rgbDistortion, sizeof(param.rgbDistortion));
+            param.rgbDistortion.model = OB_DISTORTION_BROWN_CONRADY_K6;
+            param.transform           = cameraParam.transform;
+            param.isMirrored          = false;
+            calibrationCameraParamList_.emplace_back(param);
+
+            std::stringstream ss;
+            ss << param;
+            LOG_DEBUG("-{}", ss.str());
+        }
+    }
+
+    // d2c align profile
+    data.clear();
+    BEGIN_TRY_EXECUTE({
+        auto owner      = getOwner();
+        auto propServer = owner->getPropertyServer();
+        propServer->getRawData(
+            OB_RAW_DATA_D2C_ALIGN_SUPPORT_PROFILE_LIST,
+            [&](OBDataTranState state, OBDataChunk *dataChunk) {
+                if(state == DATA_TRAN_STAT_TRANSFERRING) {
+                    data.insert(data.end(), dataChunk->data, dataChunk->data + dataChunk->size);
+                }
+            },
+            PROP_ACCESS_INTERNAL);
+    })
+    CATCH_EXCEPTION_AND_EXECUTE({
+        LOG_ERROR("Get depth to color profile list failed!");
+        data.clear();
+    })
+
+    if(!data.empty()) {
+        d2cProfileList_ = AlgParseHelper::d2cProfileInfoParse(data.data(), static_cast<uint32_t>(data.size()));
+        // auto iter       = d2cProfileList_.begin();
+        // while(iter != d2cProfileList_.end()) {
+        //     if((*iter).alignType == ALIGN_D2C_HW_MODE) {
+        //         iter = d2cProfileList_.erase(iter);
+        //         continue;
+        //     }
+        //     iter++;
+        // }
+        LOG_DEBUG("Get depth to color profile list success! num={}", d2cProfileList_.size());
+    }
+
+    // imu param
+    data.clear();
+    BEGIN_TRY_EXECUTE({
+        auto owner      = getOwner();
+        auto propServer = owner->getPropertyServer();
+        propServer->getRawData(
+            OB_RAW_DATA_IMU_CALIB_PARAM,
+            [&](OBDataTranState state, OBDataChunk *dataChunk) {
+                if(state == DATA_TRAN_STAT_TRANSFERRING) {
+                    data.insert(data.end(), dataChunk->data, dataChunk->data + dataChunk->size);
+                }
+            },
+            PROP_ACCESS_INTERNAL);
+    })
+    CATCH_EXCEPTION_AND_EXECUTE({
+        LOG_DEBUG("Get IMU calibration params failed!");  // set log level to debug as it is not an error
+        data.clear();
+    })
+
+    if(!data.empty()) {
+        auto realData  = data.data() + IMU_CALIBRATION_FILE_OFFSET;
+        auto realSize  = static_cast<uint32_t>(data.size()) - IMU_CALIBRATION_FILE_OFFSET;
+        imuCalibParam_ = IMUCorrector::parserIMUCalibParamRaw(realData, realSize);
+        LOG_DEBUG("Get imu calibration params success!");
+    }
+    else {
+        LOG_DEBUG("Get imu calibration param failed! load default param.");
+        imuCalibParam_ = IMUCorrector::getDefaultImuCalibParam();
+    }
+}
+
+void TOFDeviceCommonAlgParamManager::registerBasicExtrinsics() {
+    auto extrinsicMgr            = StreamExtrinsicsManager::getInstance();
+    auto depthBasicStreamProfile = StreamProfileFactory::createVideoStreamProfile(OB_STREAM_DEPTH, OB_FORMAT_ANY, OB_WIDTH_ANY, OB_HEIGHT_ANY, OB_FPS_ANY);
+    auto colorBasicStreamProfile = StreamProfileFactory::createVideoStreamProfile(OB_STREAM_COLOR, OB_FORMAT_ANY, OB_WIDTH_ANY, OB_HEIGHT_ANY, OB_FPS_ANY);
+    auto irBasicStreamProfile    = StreamProfileFactory::createVideoStreamProfile(OB_STREAM_IR, OB_FORMAT_ANY, OB_WIDTH_ANY, OB_HEIGHT_ANY, OB_FPS_ANY);
+    auto accelBasicStreamProfile = StreamProfileFactory::createAccelStreamProfile(OB_ACCEL_FS_2g, OB_SAMPLE_RATE_1_5625_HZ);
+    auto gyroBasicStreamProfile  = StreamProfileFactory::createGyroStreamProfile(OB_GYRO_FS_16dps, OB_SAMPLE_RATE_1_5625_HZ);
+
+    extrinsicMgr->registerSameExtrinsics(depthBasicStreamProfile, irBasicStreamProfile);
+
+    if(!calibrationCameraParamList_.empty()) {
+        const auto &d2cExtrinsic = calibrationCameraParamList_.front().transform;
+        extrinsicMgr->registerExtrinsics(depthBasicStreamProfile, colorBasicStreamProfile, d2cExtrinsic);
+    }
+
+    double imuExtr[16] = { 0 };
+    memcpy(imuExtr, imuCalibParam_.singleIMUParams[0].imu_to_cam_extrinsics, sizeof(imuExtr));
+
+    OBExtrinsic imu_to_depth;
+    imu_to_depth.rot[0] = (float)imuExtr[0];
+    imu_to_depth.rot[1] = (float)imuExtr[1];
+
+    imu_to_depth.rot[2]   = (float)imuExtr[2];
+    imu_to_depth.rot[3]   = (float)imuExtr[4];
+    imu_to_depth.rot[4]   = (float)imuExtr[5];
+    imu_to_depth.rot[5]   = (float)imuExtr[6];
+    imu_to_depth.rot[6]   = (float)imuExtr[8];
+    imu_to_depth.rot[7]   = (float)imuExtr[9];
+    imu_to_depth.rot[8]   = (float)imuExtr[10];
+    imu_to_depth.trans[0] = (float)imuExtr[3];
+    imu_to_depth.trans[1] = (float)imuExtr[7];
+    imu_to_depth.trans[2] = (float)imuExtr[11];
+    extrinsicMgr->registerExtrinsics(accelBasicStreamProfile, depthBasicStreamProfile, imu_to_depth);
+    extrinsicMgr->registerSameExtrinsics(gyroBasicStreamProfile, accelBasicStreamProfile);
+
+    basicStreamProfileList_.emplace_back(depthBasicStreamProfile);
+    basicStreamProfileList_.emplace_back(colorBasicStreamProfile);
+    basicStreamProfileList_.emplace_back(irBasicStreamProfile);
+    basicStreamProfileList_.emplace_back(accelBasicStreamProfile);
+    basicStreamProfileList_.emplace_back(gyroBasicStreamProfile);
+}
+
+}  // namespace libobsensor
diff --git a/src/device/component/param/AlgParamManager.hpp b/src/device/component/param/AlgParamManager.hpp
new file mode 100644
index 00000000..c1363b06
--- /dev/null
+++ b/src/device/component/param/AlgParamManager.hpp
@@ -0,0 +1,70 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include "libobsensor/h/ObTypes.h"
+
+#include "IDevice.hpp"
+#include "IProperty.hpp"
+#include "InternalTypes.hpp"
+#include "IAlgParamManager.hpp"
+
+#include "DeviceComponentBase.hpp"
+
+#include <vector>
+#include <memory>
+
+namespace libobsensor {
+class AlgParamManagerBase : public DeviceComponentBase, public IAlgParamManager {
+public:
+    AlgParamManagerBase(IDevice *owner);
+    virtual ~AlgParamManagerBase() = default;
+
+    void bindStreamProfileParams(std::vector<std::shared_ptr<const StreamProfile>> streamProfileList) override;
+
+    const std::vector<OBD2CProfile>  &getD2CProfileList() const override;
+    const std::vector<OBCameraParam> &getCalibrationCameraParamList() const override;
+    const OBIMUCalibrateParams       &getIMUCalibrationParam() const override;
+
+    virtual void fetchParamFromDevice()    = 0;
+    virtual void registerBasicExtrinsics() = 0;
+
+    virtual void bindExtrinsic(std::vector<std::shared_ptr<const StreamProfile>> streamProfileList);
+    virtual void bindIntrinsic(std::vector<std::shared_ptr<const StreamProfile>> streamProfileList);
+
+protected:
+    // using empty stream profile to initialize and register extrinsic params
+    std::vector<std::shared_ptr<const StreamProfile>> basicStreamProfileList_;
+
+    OBIMUCalibrateParams       imuCalibParam_;
+    std::vector<OBCameraParam> calibrationCameraParamList_;
+    std::vector<OBD2CProfile>  d2cProfileList_;
+};
+
+class DisparityAlgParamManagerBase : public AlgParamManagerBase, public IDisparityAlgParamManager {
+public:
+    DisparityAlgParamManagerBase(IDevice *owner);
+
+    virtual ~DisparityAlgParamManagerBase() = default;
+
+    void                    bindStreamProfileParams(std::vector<std::shared_ptr<const StreamProfile>> streamProfileList) override;
+    const OBDisparityParam &getDisparityParam() const override;
+
+    virtual void bindDisparityParam(std::vector<std::shared_ptr<const StreamProfile>> streamProfileList);
+
+protected:
+    OBDisparityParam disparityParam_;
+};
+
+class TOFDeviceCommonAlgParamManager : public AlgParamManagerBase {
+public:
+    TOFDeviceCommonAlgParamManager(IDevice *owner);
+    virtual ~TOFDeviceCommonAlgParamManager() noexcept = default;
+
+private:
+    void fetchParamFromDevice() override;
+    void registerBasicExtrinsics() override;
+};
+
+}  // namespace libobsensor
diff --git a/src/device/component/param/AlgParseHelper.cpp b/src/device/component/param/AlgParseHelper.cpp
new file mode 100644
index 00000000..ea8a0740
--- /dev/null
+++ b/src/device/component/param/AlgParseHelper.cpp
@@ -0,0 +1,21 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "AlgParseHelper.hpp"
+namespace libobsensor {
+std::vector<OBCameraParam_Internal_V0> AlgParseHelper::alignCalibParamParse(uint8_t *data, uint32_t size) {
+    std::vector<OBCameraParam_Internal_V0> output;
+    for(int i = 0; i < static_cast<int>(size / D2C_PARAMS_ITEM_SIZE); i++) {
+        output.push_back(*(OBCameraParam_Internal_V0 *)(data + i * D2C_PARAMS_ITEM_SIZE));
+    }
+    return output;
+}
+
+std::vector<OBD2CProfile> AlgParseHelper::d2cProfileInfoParse(uint8_t *data, uint32_t size) {
+    std::vector<OBD2CProfile> output;
+    for(int i = 0; i < static_cast<int>(size / sizeof(OBD2CProfile)); i++) {
+        output.push_back(*(OBD2CProfile *)(data + i * sizeof(OBD2CProfile)));
+    }
+    return output;
+}
+}  // namespace libobsensor
diff --git a/src/device/component/param/AlgParseHelper.hpp b/src/device/component/param/AlgParseHelper.hpp
new file mode 100644
index 00000000..830ca40b
--- /dev/null
+++ b/src/device/component/param/AlgParseHelper.hpp
@@ -0,0 +1,19 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include "libobsensor/h/ObTypes.h"
+#include "InternalTypes.hpp"
+#include <vector>
+
+#define D2C_PARAMS_ITEM_SIZE 0xB0
+#define IMU_CALIBRATION_FILE_OFFSET 60
+
+namespace libobsensor {
+
+class AlgParseHelper {
+public:
+    static std::vector<OBCameraParam_Internal_V0> alignCalibParamParse(uint8_t *data, uint32_t size);
+    static std::vector<OBD2CProfile>  d2cProfileInfoParse(uint8_t *data, uint32_t size);
+};
+}  // namespace libobsensor
diff --git a/src/device/component/property/CMakeLists.txt b/src/device/component/property/CMakeLists.txt
new file mode 100644
index 00000000..e4f6eda0
--- /dev/null
+++ b/src/device/component/property/CMakeLists.txt
@@ -0,0 +1,26 @@
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+cmake_minimum_required(VERSION 3.5)
+
+target_sources(
+    ${OB_TARGET_DEVICE}
+    PRIVATE ${CMAKE_CURRENT_LIST_DIR}/VendorPropertyAccessor.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/VendorPropertyAccessor.hpp
+    ${CMAKE_CURRENT_LIST_DIR}/PropertyServer.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/PropertyServer.hpp
+    ${CMAKE_CURRENT_LIST_DIR}/CommonPropertyAccessors.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/CommonPropertyAccessors.hpp
+    ${CMAKE_CURRENT_LIST_DIR}/FilterPropertyAccessors.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/FilterPropertyAccessors.hpp
+    ${CMAKE_CURRENT_LIST_DIR}/InternalProperty.hpp
+    ${CMAKE_CURRENT_LIST_DIR}/PrivateFilterPropertyAccessors.hpp
+    ${CMAKE_CURRENT_LIST_DIR}/PrivateFilterPropertyAccessors.cpp
+)
+
+if(OB_BUILD_USB_PAL)
+    target_sources(
+        ${OB_TARGET_DEVICE} PRIVATE ${CMAKE_CURRENT_LIST_DIR}/UvcPropertyAccessor.cpp
+        ${CMAKE_CURRENT_LIST_DIR}/UvcPropertyAccessor.hpp
+    )
+endif()
diff --git a/src/device/component/property/CommonPropertyAccessors.cpp b/src/device/component/property/CommonPropertyAccessors.cpp
new file mode 100644
index 00000000..55402836
--- /dev/null
+++ b/src/device/component/property/CommonPropertyAccessors.cpp
@@ -0,0 +1,200 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "CommonPropertyAccessors.hpp"
+
+#include "IDeviceMonitor.hpp"
+#include "IAlgParamManager.hpp"
+
+#include "libobsensor/h/ObTypes.h"
+#include "utils/Utils.hpp"
+namespace libobsensor {
+
+DeviceComponentPropertyAccessor::DeviceComponentPropertyAccessor(IDevice *device, DeviceComponentId compId) : device_(device), compId_(compId) {}
+
+void DeviceComponentPropertyAccessor::setPropertyValue(uint32_t propertyId, const OBPropertyValue &value) {
+    auto propertyAccessor = device_->getComponentT<IBasicPropertyAccessor>(compId_);
+    propertyAccessor->setPropertyValue(propertyId, value);
+}
+
+void DeviceComponentPropertyAccessor::getPropertyValue(uint32_t propertyId, OBPropertyValue *value) {
+    auto propertyAccessor = device_->getComponentT<IBasicPropertyAccessor>(compId_);
+    propertyAccessor->getPropertyValue(propertyId, value);
+}
+
+void DeviceComponentPropertyAccessor::getPropertyRange(uint32_t propertyId, OBPropertyRange *range) {
+    auto propertyAccessor = device_->getComponentT<IBasicPropertyAccessor>(compId_);
+    propertyAccessor->getPropertyRange(propertyId, range);
+}
+
+FunctionPropertyAccessor::FunctionPropertyAccessor(std::function<OBPropertyValue(uint32_t)> getter, std::function<void(uint32_t, OBPropertyValue)> setter,
+                                                   std::function<OBPropertyRange(uint32_t)> rangeGetter)
+    : getter_(getter), setter_(setter), rangeGetter_(rangeGetter) {}
+
+void FunctionPropertyAccessor::setPropertyValue(uint32_t propertyId, const OBPropertyValue &value) {
+    setter_(propertyId, value);
+}
+
+void FunctionPropertyAccessor::getPropertyValue(uint32_t propertyId, OBPropertyValue *value) {
+    *value = getter_(propertyId);
+}
+
+void FunctionPropertyAccessor::getPropertyRange(uint32_t propertyId, OBPropertyRange *range) {
+    *range = rangeGetter_(propertyId);
+}
+
+LazyPropertyAccessor::LazyPropertyAccessor(std::function<std::shared_ptr<IPropertyAccessor>()> accessorCreator) : accessorCreator_(accessorCreator) {}
+
+void LazyPropertyAccessor::setPropertyValue(uint32_t propertyId, const OBPropertyValue &value) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    if(!accessor_) {
+        accessor_ = accessorCreator_();
+    }
+    auto basicAccessor = std::dynamic_pointer_cast<IBasicPropertyAccessor>(accessor_);
+    basicAccessor->setPropertyValue(propertyId, value);
+}
+
+void LazyPropertyAccessor::getPropertyValue(uint32_t propertyId, OBPropertyValue *value) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    if(!accessor_) {
+        accessor_ = accessorCreator_();
+    }
+    auto basicAccessor = std::dynamic_pointer_cast<IBasicPropertyAccessor>(accessor_);
+    basicAccessor->getPropertyValue(propertyId, value);
+}
+
+void LazyPropertyAccessor::getPropertyRange(uint32_t propertyId, OBPropertyRange *range) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    if(!accessor_) {
+        accessor_ = accessorCreator_();
+    }
+    auto basicAccessor = std::dynamic_pointer_cast<IBasicPropertyAccessor>(accessor_);
+    basicAccessor->getPropertyRange(propertyId, range);
+}
+
+LazySuperPropertyAccessor::LazySuperPropertyAccessor(std::function<std::shared_ptr<IPropertyAccessor>()> accessorCreator)
+    : LazyPropertyAccessor(accessorCreator) {}
+
+void LazySuperPropertyAccessor::setStructureData(uint32_t propertyId, const std::vector<uint8_t> &data) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    if(!accessor_) {
+        accessor_ = accessorCreator_();
+    }
+    auto superAccessor = std::dynamic_pointer_cast<IStructureDataAccessor>(accessor_);
+    superAccessor->setStructureData(propertyId, data);
+}
+
+const std::vector<uint8_t> &LazySuperPropertyAccessor::getStructureData(uint32_t propertyId) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    if(!accessor_) {
+        accessor_ = accessorCreator_();
+    }
+    auto superAccessor = std::dynamic_pointer_cast<IStructureDataAccessor>(accessor_);
+    return superAccessor->getStructureData(propertyId);
+}
+
+void LazySuperPropertyAccessor::getRawData(uint32_t propertyId, GetDataCallback callback) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    if(!accessor_) {
+        accessor_ = accessorCreator_();
+    }
+    auto superAccessor = std::dynamic_pointer_cast<IRawDataAccessor>(accessor_);
+    superAccessor->getRawData(propertyId, callback);
+}
+
+uint16_t LazySuperPropertyAccessor::getCmdVersionProtoV1_1(uint32_t propertyId) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    if(!accessor_) {
+        accessor_ = accessorCreator_();
+    }
+    auto superAccessor = std::dynamic_pointer_cast<IStructureDataAccessorV1_1>(accessor_);
+    return superAccessor->getCmdVersionProtoV1_1(propertyId);
+}
+
+const std::vector<uint8_t> &LazySuperPropertyAccessor::getStructureDataProtoV1_1(uint32_t propertyId, uint16_t cmdVersion) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    if(!accessor_) {
+        accessor_ = accessorCreator_();
+    }
+    auto superAccessor = std::dynamic_pointer_cast<IStructureDataAccessorV1_1>(accessor_);
+    return superAccessor->getStructureDataProtoV1_1(propertyId, cmdVersion);
+}
+
+void LazySuperPropertyAccessor::setStructureDataProtoV1_1(uint32_t propertyId, const std::vector<uint8_t> &data, uint16_t cmdVersion) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    if(!accessor_) {
+        accessor_ = accessorCreator_();
+    }
+    auto superAccessor = std::dynamic_pointer_cast<IStructureDataAccessorV1_1>(accessor_);
+    superAccessor->setStructureDataProtoV1_1(propertyId, data, cmdVersion);
+}
+
+const std::vector<uint8_t> &LazySuperPropertyAccessor::getStructureDataListProtoV1_1(uint32_t propertyId, uint16_t cmdVersion) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    if(!accessor_) {
+        accessor_ = accessorCreator_();
+    }
+    auto superAccessor = std::dynamic_pointer_cast<IStructureDataAccessorV1_1>(accessor_);
+    return superAccessor->getStructureDataListProtoV1_1(propertyId, cmdVersion);
+}
+
+StructureDataOverV1_1Accessor::StructureDataOverV1_1Accessor(std::shared_ptr<IStructureDataAccessorV1_1> accessor, uint16_t cmdVersion)
+    : structureDataV1_1Accessor_(accessor), cmdVersion_(cmdVersion) {}
+
+void StructureDataOverV1_1Accessor::setStructureData(uint32_t propertyId, const std::vector<uint8_t> &data) {
+    structureDataV1_1Accessor_->setStructureDataProtoV1_1(propertyId, data, cmdVersion_);
+}
+
+const std::vector<uint8_t> &StructureDataOverV1_1Accessor::getStructureData(uint32_t propertyId) {
+    return structureDataV1_1Accessor_->getStructureDataProtoV1_1(propertyId, cmdVersion_);
+}
+
+HeartbeatPropertyAccessor::HeartbeatPropertyAccessor(IDevice *owner) : owner_(owner) {}
+
+void HeartbeatPropertyAccessor::setPropertyValue(uint32_t propertyId, const OBPropertyValue &value) {
+    utils::unusedVar(propertyId);
+    auto deviceMonitor = owner_->getComponentT<IDeviceMonitor>(OB_DEV_COMPONENT_DEVICE_MONITOR);
+    if(value.intValue == 1) {
+        deviceMonitor->enableHeartbeat();
+    }
+    else {
+        deviceMonitor->disableHeartbeat();
+    }
+}
+
+void HeartbeatPropertyAccessor::getPropertyValue(uint32_t propertyId, OBPropertyValue *value) {
+    utils::unusedVar(propertyId);
+    auto deviceMonitor = owner_->getComponentT<IDeviceMonitor>(OB_DEV_COMPONENT_DEVICE_MONITOR);
+    value->intValue    = deviceMonitor->isHeartbeatEnabled() ? 1 : 0;
+}
+
+void HeartbeatPropertyAccessor::getPropertyRange(uint32_t propertyId, OBPropertyRange *range) {
+    OBPropertyValue cur;
+    getPropertyValue(propertyId, &cur);
+    range->cur           = cur;
+    range->min.intValue  = 0;
+    range->max.intValue  = 1;
+    range->step.intValue = 1;
+    range->def.intValue  = 0;
+}
+
+BaselinePropertyAccessor::BaselinePropertyAccessor(IDevice *owner) : owner_(owner) {}
+
+void BaselinePropertyAccessor::setStructureData(uint32_t propertyId, const std::vector<uint8_t> &data) {
+    utils::unusedVar(propertyId);
+    utils::unusedVar(data);
+    throw unsupported_operation_exception("Baseline params readonly!");
+}
+
+const std::vector<uint8_t> &BaselinePropertyAccessor::getStructureData(uint32_t propertyId) {
+    utils::unusedVar(propertyId);
+    baselineData_.resize(sizeof(OBBaselineCalibrationParam));
+    OBBaselineCalibrationParam *param = (OBBaselineCalibrationParam *)baselineData_.data();
+
+    auto algParamManager = owner_->getComponentT<IDisparityAlgParamManager>(OB_DEV_COMPONENT_ALG_PARAM_MANAGER);
+    auto disparityParam  = algParamManager->getDisparityParam();
+    param->baseline      = disparityParam.baseline;
+    param->zpd           = static_cast<float>(disparityParam.zpd);
+    return baselineData_;
+}
+}  // namespace libobsensor
diff --git a/src/device/component/property/CommonPropertyAccessors.hpp b/src/device/component/property/CommonPropertyAccessors.hpp
new file mode 100644
index 00000000..50391f32
--- /dev/null
+++ b/src/device/component/property/CommonPropertyAccessors.hpp
@@ -0,0 +1,117 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include "IProperty.hpp"
+#include "IDevice.hpp"
+
+#include <mutex>
+#include <functional>
+
+namespace libobsensor {
+class DeviceComponentPropertyAccessor : public IBasicPropertyAccessor {
+public:
+    DeviceComponentPropertyAccessor(IDevice *device, DeviceComponentId compId);
+    virtual ~DeviceComponentPropertyAccessor() noexcept = default;
+
+    void setPropertyValue(uint32_t propertyId, const OBPropertyValue &value) override;
+    void getPropertyValue(uint32_t propertyId, OBPropertyValue *value) override;
+    void getPropertyRange(uint32_t propertyId, OBPropertyRange *range) override;
+
+private:
+    IDevice          *device_;
+    DeviceComponentId compId_;
+};
+
+class FunctionPropertyAccessor : public IBasicPropertyAccessor {
+public:
+    FunctionPropertyAccessor(std::function<OBPropertyValue(uint32_t)> getter, std::function<void(uint32_t, OBPropertyValue)> setter,
+                             std::function<OBPropertyRange(uint32_t)> rangeGetter);
+
+    virtual ~FunctionPropertyAccessor() noexcept = default;
+
+    void setPropertyValue(uint32_t propertyId, const OBPropertyValue &value) override;
+    void getPropertyValue(uint32_t propertyId, OBPropertyValue *value) override;
+    void getPropertyRange(uint32_t propertyId, OBPropertyRange *range) override;
+
+private:
+    std::function<OBPropertyValue(uint32_t)>       getter_;
+    std::function<void(uint32_t, OBPropertyValue)> setter_;
+    std::function<OBPropertyRange(uint32_t)>       rangeGetter_;
+};
+
+class LazyPropertyAccessor : public virtual IBasicPropertyAccessor {
+public:
+    LazyPropertyAccessor(std::function<std::shared_ptr<IPropertyAccessor>()> accessorCreator);
+
+    virtual ~LazyPropertyAccessor() noexcept = default;
+
+    void setPropertyValue(uint32_t propertyId, const OBPropertyValue &value) override;
+    void getPropertyValue(uint32_t propertyId, OBPropertyValue *value) override;
+    void getPropertyRange(uint32_t propertyId, OBPropertyRange *range) override;
+
+protected:
+    std::function<std::shared_ptr<IPropertyAccessor>()> accessorCreator_;
+    std::shared_ptr<IPropertyAccessor>                  accessor_;
+    std::mutex                                          mutex_;
+};
+
+class LazySuperPropertyAccessor : public LazyPropertyAccessor, public IStructureDataAccessor, public IStructureDataAccessorV1_1, public IRawDataAccessor {
+public:
+    LazySuperPropertyAccessor(std::function<std::shared_ptr<IPropertyAccessor>()> accessorCreator);
+    virtual ~LazySuperPropertyAccessor() noexcept = default;
+
+    void                        setStructureData(uint32_t propertyId, const std::vector<uint8_t> &data) override;
+    const std::vector<uint8_t> &getStructureData(uint32_t propertyId) override;
+    void                        getRawData(uint32_t propertyId, GetDataCallback callback) override;
+
+    uint16_t                    getCmdVersionProtoV1_1(uint32_t propertyId) override;
+    const std::vector<uint8_t> &getStructureDataProtoV1_1(uint32_t propertyId, uint16_t cmdVersion) override;
+    void                        setStructureDataProtoV1_1(uint32_t propertyId, const std::vector<uint8_t> &data, uint16_t cmdVersion) override;
+    const std::vector<uint8_t> &getStructureDataListProtoV1_1(uint32_t propertyId, uint16_t cmdVersion) override;
+};
+
+class StructureDataOverV1_1Accessor : public IStructureDataAccessor {
+public:
+    StructureDataOverV1_1Accessor(std::shared_ptr<IStructureDataAccessorV1_1> structureDataV1_1Accessor, uint16_t cmdVersion);
+
+    virtual ~StructureDataOverV1_1Accessor() noexcept = default;
+
+    void                        setStructureData(uint32_t propertyId, const std::vector<uint8_t> &data) override;
+    const std::vector<uint8_t> &getStructureData(uint32_t propertyId) override;
+
+private:
+    std::shared_ptr<IStructureDataAccessorV1_1> structureDataV1_1Accessor_;
+    uint16_t                                    cmdVersion_;
+};
+
+class HeartbeatPropertyAccessor : public IBasicPropertyAccessor {
+public:
+    HeartbeatPropertyAccessor(IDevice *owner);
+
+    virtual ~HeartbeatPropertyAccessor() noexcept = default;
+
+    void setPropertyValue(uint32_t propertyId, const OBPropertyValue &value) override;
+    void getPropertyValue(uint32_t propertyId, OBPropertyValue *value) override;
+    void getPropertyRange(uint32_t propertyId, OBPropertyRange *range) override;
+
+private:
+    IDevice *owner_;
+};
+
+class BaselinePropertyAccessor : public IStructureDataAccessor {
+public:
+    BaselinePropertyAccessor(IDevice *owner);
+
+    virtual ~BaselinePropertyAccessor() noexcept = default;
+
+    void                        setStructureData(uint32_t propertyId, const std::vector<uint8_t> &data) override;
+    const std::vector<uint8_t> &getStructureData(uint32_t propertyId) override;
+
+private:
+    IDevice             *owner_;
+    std::vector<uint8_t> baselineData_;
+};
+
+}  // namespace libobsensor
diff --git a/src/device/component/property/FilterPropertyAccessors.cpp b/src/device/component/property/FilterPropertyAccessors.cpp
new file mode 100644
index 00000000..c592ba62
--- /dev/null
+++ b/src/device/component/property/FilterPropertyAccessors.cpp
@@ -0,0 +1,29 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "FilterPropertyAccessors.hpp"
+#include "utils/Utils.hpp"
+
+namespace libobsensor {
+FilterStatePropertyAccessor::FilterStatePropertyAccessor(std::shared_ptr<IFilter> filter) : filter_(filter) {}
+
+void FilterStatePropertyAccessor::setPropertyValue(uint32_t propertyId, const OBPropertyValue &value) {
+    utils::unusedVar(propertyId);
+    bool enable = static_cast<bool>(value.intValue);
+    filter_->enable(enable);
+}
+
+void FilterStatePropertyAccessor::getPropertyValue(uint32_t propertyId, OBPropertyValue *value) {
+    utils::unusedVar(propertyId);
+    value->intValue = static_cast<int>(filter_->isEnabled());
+}
+
+void FilterStatePropertyAccessor::getPropertyRange(uint32_t propertyId, OBPropertyRange *range) {
+    utils::unusedVar(propertyId);
+    range->cur.intValue  = static_cast<int>(filter_->isEnabled());
+    range->min.intValue  = 0;
+    range->max.intValue  = 1;
+    range->step.intValue = 1;
+    range->def.intValue  = 1;
+}
+}  // namespace libobsensor
diff --git a/src/device/component/property/FilterPropertyAccessors.hpp b/src/device/component/property/FilterPropertyAccessors.hpp
new file mode 100644
index 00000000..258d99d1
--- /dev/null
+++ b/src/device/component/property/FilterPropertyAccessors.hpp
@@ -0,0 +1,24 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include "IProperty.hpp"
+#include "IFilter.hpp"
+
+namespace libobsensor {
+
+class FilterStatePropertyAccessor : public IBasicPropertyAccessor {
+public:
+    FilterStatePropertyAccessor(std::shared_ptr<IFilter> filter);
+    virtual ~FilterStatePropertyAccessor() noexcept = default;
+
+    void setPropertyValue(uint32_t propertyId, const OBPropertyValue &value) override;
+    void getPropertyValue(uint32_t propertyId, OBPropertyValue *value) override;
+    void getPropertyRange(uint32_t propertyId, OBPropertyRange *range) override;
+
+private:
+    std::shared_ptr<IFilter> filter_;
+};
+}  // namespace libobsensor
+
diff --git a/src/device/component/property/InternalProperty.hpp b/src/device/component/property/InternalProperty.hpp
new file mode 100644
index 00000000..8fee4d39
--- /dev/null
+++ b/src/device/component/property/InternalProperty.hpp
@@ -0,0 +1,52 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include "libobsensor/h/Property.h"
+
+namespace libobsensor {
+
+typedef enum {
+    OB_PROP_FEMTO_MEGA_HARDWARE_D2C_BOOL    = 13,  /**< FemtoMega hardware d2c switch*/
+    OB_PROP_DEVICE_RESET_BOOL               = 29,  /**< Reset/reboot the device*/
+    OB_PROP_STOP_DEPTH_STREAM_BOOL          = 38,  /**<Disable the depth stream*/
+    OB_PROP_STOP_IR_STREAM_BOOL             = 39,  /**<Disable the IR stream*/
+    OB_PROP_TOF_EXPOSURE_TIME_INT           = 47,  /**<TOF exposure time //only sdk-firmware internal use*/
+    OB_PROP_TOF_GAIN_INT                    = 48,  /**<TOF gain value //only sdk-firmware internal use*/
+    OB_PROP_REBOOT_DEVICE_BOOL              = 57,  /**< Reboot the device*/
+    OB_PROP_STOP_COLOR_STREAM_BOOL          = 77,  /**< Disable the Color stream*/
+    OB_PROP_DEVICE_COMMUNICATION_TYPE_INT   = 97,  // Device communication type, 0: USB; 1: Ethernet(RTSP)
+    OB_PROP_FAN_WORK_LEVEL_INT              = 110, /**< Fan speed settings*/
+    OB_PROP_DEVICE_PID_INT                  = 111, /**< Device product id*/
+    OB_PROP_DEPTH_MIRROR_MODULE_STATUS_BOOL = 108, /**< Depth mirror module status*/
+    OB_PROP_FAN_WORK_SPEED_INT              = 120, /**< Fan speed*/
+
+    OB_STRUCT_DEVICE_UPGRADE_STATUS = 1006, /**< Firmware upgrade status, read only*/
+
+    OB_PROP_GYRO_SWITCH_BOOL     = 2019, /**< Gyroscope switch*/
+    OB_PROP_ACCEL_SWITCH_BOOL    = 2020, /**< Accelerometer switch*/
+    OB_PROP_GYRO_ODR_INT         = 2021, /**< get/set current gyroscope sampling rate*/
+    OB_PROP_ACCEL_ODR_INT        = 2022, /**< get/set the current sampling rate of the accelerometer*/
+    OB_PROP_GYRO_FULL_SCALE_INT  = 2023, /**< get/set current gyroscope range*/
+    OB_PROP_ACCEL_FULL_SCALE_INT = 2024, /**< get/set current accelerometer range*/
+
+    OB_STRUCT_VERSION                           = 1000, /**< version information*/
+    OB_STRUCT_GET_GYRO_PRESETS_ODR_LIST         = 1031, /**< Get the list of sampling rates supported by the gyroscope*/
+    OB_STRUCT_GET_ACCEL_PRESETS_ODR_LIST        = 1032, /**< Get the list of sampling rates supported by the accelerometer*/
+    OB_STRUCT_GET_GYRO_PRESETS_FULL_SCALE_LIST  = 1033, /**< Get the range list supported by the gyroscope*/
+    OB_STRUCT_GET_ACCEL_PRESETS_FULL_SCALE_LIST = 1034, /**< Get the range list supported by the accelerometer*/
+
+    OB_RAW_DATA_D2C_ALIGN_SUPPORT_PROFILE_LIST      = 4024, /**< D2C Alignment Resolution List*/
+    OB_RAW_DATA_DEPTH_CALIB_PARAM                   = 4026, /**< Depth calibration parameters*/
+    OB_RAW_DATA_ALIGN_CALIB_PARAM                   = 4027,
+    OB_RAW_DATA_DEPTH_ALG_MODE_LIST                 = 4034, /**< Depth algorithm mode list*/
+    OB_RAW_DATA_EFFECTIVE_VIDEO_STREAM_PROFILE_LIST = 4035, /**< Current effective video stream profile list*/
+    OB_RAW_DATA_STREAM_PROFILE_LIST                 = 4033, /**< Stream configuration list*/
+    OB_RAW_DATA_IMU_CALIB_PARAM                     = 4036, /**< IMU calibration parameters*/
+    OB_RAW_DATA_DEVICE_UPGRADE                      = 4039, /**< Device firmware upgrade*/
+    OB_RAW_DATA_DEVICE_EXTENSION_INFORMATION        = 4041, /**< Device extension information*/
+
+} OBInternalPropertyID;
+
+}  // namespace libobsensor
+
diff --git a/src/device/component/property/PrivateFilterPropertyAccessors.cpp b/src/device/component/property/PrivateFilterPropertyAccessors.cpp
new file mode 100644
index 00000000..a973a8f0
--- /dev/null
+++ b/src/device/component/property/PrivateFilterPropertyAccessors.cpp
@@ -0,0 +1,24 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "PrivateFilterPropertyAccessors.hpp"
+#include "frameprocessor/FrameProcessor.hpp"
+
+namespace libobsensor {
+PrivateFilterPropertyAccessor::PrivateFilterPropertyAccessor(IDevice *device) : device_(device) {}
+
+void PrivateFilterPropertyAccessor::setPropertyValue(uint32_t propertyId, const OBPropertyValue &value) {
+    auto processor = device_->getComponentT<FrameProcessor>(OB_DEV_COMPONENT_DEPTH_FRAME_PROCESSOR);
+    processor->setPropertyValue(propertyId, value);
+}
+
+void PrivateFilterPropertyAccessor::getPropertyValue(uint32_t propertyId, OBPropertyValue *value) {
+    auto processor = device_->getComponentT<FrameProcessor>(OB_DEV_COMPONENT_DEPTH_FRAME_PROCESSOR);
+    processor->getPropertyValue(propertyId, value);
+}
+
+void PrivateFilterPropertyAccessor::getPropertyRange(uint32_t propertyId, OBPropertyRange *range) {
+    auto processor = device_->getComponentT<FrameProcessor>(OB_DEV_COMPONENT_DEPTH_FRAME_PROCESSOR);
+    processor->getPropertyRange(propertyId, range);
+}
+}  // namespace libobsensor
diff --git a/src/device/component/property/PrivateFilterPropertyAccessors.hpp b/src/device/component/property/PrivateFilterPropertyAccessors.hpp
new file mode 100644
index 00000000..22942681
--- /dev/null
+++ b/src/device/component/property/PrivateFilterPropertyAccessors.hpp
@@ -0,0 +1,23 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include "IProperty.hpp"
+#include "IDevice.hpp"
+
+namespace libobsensor {
+
+class PrivateFilterPropertyAccessor : public IBasicPropertyAccessor {
+public:
+    PrivateFilterPropertyAccessor(IDevice *device);
+    virtual ~PrivateFilterPropertyAccessor() noexcept = default;
+
+    void setPropertyValue(uint32_t propertyId, const OBPropertyValue &value) override;
+    void getPropertyValue(uint32_t propertyId, OBPropertyValue *value) override;
+    void getPropertyRange(uint32_t propertyId, OBPropertyRange *range) override;
+
+private:
+    IDevice *device_;
+};
+}  // namespace libobsensor
diff --git a/src/device/component/property/PropertyHelper.cpp b/src/device/component/property/PropertyHelper.cpp
new file mode 100644
index 00000000..b3e7a273
--- /dev/null
+++ b/src/device/component/property/PropertyHelper.cpp
@@ -0,0 +1,279 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "PropertyHelper.hpp"
+#include "InternalProperty.hpp"
+namespace libobsensor {
+
+#define PROP_INFO_PAIR(property, type) \
+    {                                  \
+        property, {                    \
+            type, #property            \
+        }                              \
+    }
+
+const std::map<uint32_t, OBPropertyBaseInfo> OBPropertyBaseInfoMap = {
+    PROP_INFO_PAIR(OB_PROP_LDP_BOOL, OB_BOOL_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_LASER_BOOL, OB_BOOL_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_LASER_PULSE_WIDTH_INT, OB_INT_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_LASER_CURRENT_FLOAT, OB_FLOAT_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_FLOOD_BOOL, OB_BOOL_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_FLOOD_LEVEL_INT, OB_INT_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_TEMPERATURE_COMPENSATION_BOOL, OB_BOOL_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_DEPTH_MIRROR_BOOL, OB_BOOL_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_DEPTH_FLIP_BOOL, OB_BOOL_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_DEPTH_POSTFILTER_BOOL, OB_BOOL_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_DEPTH_HOLEFILTER_BOOL, OB_BOOL_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_IR_MIRROR_BOOL, OB_BOOL_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_IR_FLIP_BOOL, OB_BOOL_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_MIN_DEPTH_INT, OB_INT_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_MAX_DEPTH_INT, OB_INT_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_DEPTH_SOFT_FILTER_BOOL, OB_BOOL_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_LDP_STATUS_BOOL, OB_BOOL_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_DEPTH_MAX_DIFF_INT, OB_INT_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_DEPTH_MAX_SPECKLE_SIZE_INT, OB_INT_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_DEPTH_ALIGN_HARDWARE_BOOL, OB_BOOL_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_TIMESTAMP_OFFSET_INT, OB_INT_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_HARDWARE_DISTORTION_SWITCH_BOOL, OB_BOOL_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_FAN_WORK_MODE_INT, OB_INT_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_DEPTH_ALIGN_HARDWARE_MODE_INT, OB_INT_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_ANTI_COLLUSION_ACTIVATION_STATUS_BOOL, OB_BOOL_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_DEPTH_PRECISION_LEVEL_INT, OB_INT_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_TOF_FILTER_RANGE_INT, OB_INT_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_LASER_MODE_INT, OB_INT_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_RECTIFY2_BOOL, OB_BOOL_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_COLOR_MIRROR_BOOL, OB_BOOL_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_COLOR_FLIP_BOOL, OB_BOOL_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_INDICATOR_LIGHT_BOOL, OB_BOOL_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_DISPARITY_TO_DEPTH_BOOL, OB_BOOL_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_BRT_BOOL, OB_BOOL_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_WATCHDOG_BOOL, OB_BOOL_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_EXTERNAL_SIGNAL_RESET_BOOL, OB_BOOL_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_HEARTBEAT_BOOL, OB_BOOL_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_DEPTH_CROPPING_MODE_INT, OB_INT_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_D2C_PREPROCESS_BOOL, OB_BOOL_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_GPM_BOOL, OB_BOOL_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_RGB_CUSTOM_CROP_BOOL, OB_BOOL_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_DEVICE_WORK_MODE_INT, OB_INT_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_DEVICE_COMMUNICATION_TYPE_INT, OB_INT_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_SWITCH_IR_MODE_INT, OB_INT_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_LASER_POWER_LEVEL_CONTROL_INT, OB_INT_PROPERTY),
+    //   PROP_INFO_PAIR(OB_PROP_LDP_CALIBRATION_BOOL, OB_BOOL_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_LDP_MEASURE_DISTANCE_INT, OB_INT_PROPERTY),
+    //  PROP_INFO_PAIR(OB_PROP_POWER_VOLTAGE_FLOAT, OB_FLOAT_PROPERTY),
+    //  PROP_INFO_PAIR(OB_PROP_LDP_STATUS_LEVEL_INT, OB_INT_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_TIMER_RESET_SIGNAL_BOOL, OB_BOOL_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_TIMER_RESET_TRIGGER_OUT_ENABLE_BOOL, OB_BOOL_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_TIMER_RESET_DELAY_US_INT, OB_INT_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_CAPTURE_IMAGE_SIGNAL_BOOL, OB_BOOL_PROPERTY),
+    // PROP_INFO_PAIR(OB_PROP_DEPTH_MIRROR_MODULE_STATUS_BOOL, OB_BOOL_PROPERTY),
+    // PROP_INFO_PAIR(OB_PROP_DEPTH_DUAL_MIN_DISPARITY_INT, OB_FLOAT_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_IR_RIGHT_MIRROR_BOOL, OB_BOOL_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_CAPTURE_IMAGE_FRAME_NUMBER_INT, OB_INT_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_IR_RIGHT_FLIP_BOOL, OB_BOOL_PROPERTY),
+    //   PROP_INFO_PAIR(OB_PROP_USB_STATUS_CHECK_BOOL, OB_BOOL_PROPERTY),
+    //  PROP_INFO_PAIR(OB_PROP_OBOX_STATUS_CHECK_BOOL, OB_BOOL_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_COLOR_ROTATE_INT, OB_INT_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_IR_ROTATE_INT, OB_INT_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_IR_RIGHT_ROTATE_INT, OB_INT_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_DEPTH_ROTATE_INT, OB_INT_PROPERTY),
+    // PROP_INFO_PAIR(OB_PROP_FAN_WORK_LEVEL_INT, OB_INT_PROPERTY),
+    //  PROP_INFO_PAIR(OB_PROP_PID_INT, OB_INT_PROPERTY),
+    //  PROP_INFO_PAIR(OB_PROP_FAN_WORK_SPEED_INT, OB_INT_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_USB_POWER_STATE_INT, OB_INT_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_DC_POWER_STATE_INT, OB_INT_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_LASER_POWER_ACTUAL_LEVEL_INT, OB_INT_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_DEVICE_REBOOT_DELAY_INT, OB_INT_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_LASER_OVERCURRENT_PROTECTION_STATUS_BOOL, OB_BOOL_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_LASER_PULSE_WIDTH_PROTECTION_STATUS_BOOL, OB_BOOL_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_SYNC_SIGNAL_TRIGGER_OUT_BOOL, OB_BOOL_PROPERTY),
+    // PROP_INFO_PAIR(OB_PROP_START_COLOR_STREAM_BOOL, OB_BOOL_PROPERTY),
+    // PROP_INFO_PAIR(OB_PROP_START_DEPTH_STREAM_BOOL, OB_BOOL_PROPERTY),
+    // PROP_INFO_PAIR(OB_PROP_START_IR_STREAM_BOOL, OB_BOOL_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_DEVICE_DEVELOPMENT_MODE_INT, OB_INT_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_RESTORE_FACTORY_SETTINGS_BOOL, OB_BOOL_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_BOOT_INTO_RECOVERY_MODE_BOOL, OB_BOOL_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_DEVICE_IN_RECOVERY_MODE_BOOL, OB_BOOL_PROPERTY),
+    // PROP_INFO_PAIR(OB_PROP_DEVICE_IQ_DEBUG_BOOL, OB_BOOL_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_TIMER_RESET_ENABLE_BOOL, OB_BOOL_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_DEVICE_USB2_REPEAT_IDENTIFY_BOOL, OB_BOOL_PROPERTY),
+    // PROP_INFO_PAIR(OB_PROP_DEPTH_NOISE_REMOVAL_FILTER_BOOL, OB_BOOL_PROPERTY),
+    // PROP_INFO_PAIR(OB_PROP_DEPTH_EDGE_NOISE_REMOVAL_FILTER_BOOL, OB_BOOL_PROPERTY),
+    // PROP_INFO_PAIR(OB_PROP_DEPTH_SPATIAL_FAST_FILTER_BOOL, OB_BOOL_PROPERTY),
+    // PROP_INFO_PAIR(OB_PROP_DEPTH_SPATIAL_MODERATE_FILTER_BOOL, OB_BOOL_PROPERTY),
+    // PROP_INFO_PAIR(OB_PROP_DEPTH_SPATIAL_ADVANCED_FILTER_BOOL, OB_BOOL_PROPERTY),
+    // PROP_INFO_PAIR(OB_PROP_DEPTH_HOLE_FILLING_FILTER_BOOL, OB_BOOL_PROPERTY),
+    // PROP_INFO_PAIR(OB_PROP_DEPTH_FILTER_DUMP_DIFF_LUT_INT, OB_INT_PROPERTY),
+    // PROP_INFO_PAIR(OB_PROP_DEPTH_TEMPORAL_FILTER_BOOL, OB_BOOL_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_LASER_ALWAYS_ON_BOOL, OB_BOOL_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_LASER_ON_OFF_PATTERN_INT, OB_INT_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_DEPTH_UNIT_FLEXIBLE_ADJUSTMENT_FLOAT, OB_FLOAT_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_LASER_CONTROL_INT, OB_INT_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_IR_BRIGHTNESS_INT, OB_INT_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_COLOR_AE_MAX_EXPOSURE_INT, OB_INT_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_IR_AE_MAX_EXPOSURE_INT, OB_INT_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_DISP_SEARCH_RANGE_MODE_INT, OB_INT_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_SLAVE_DEVICE_SYNC_STATUS_BOOL, OB_BOOL_PROPERTY),
+    //  PROP_INFO_PAIR(OB_STRUCT_VERSION, OB_STRUCT_PROPERTY),
+    PROP_INFO_PAIR(OB_STRUCT_BASELINE_CALIBRATION_PARAM, OB_STRUCT_PROPERTY),
+    PROP_INFO_PAIR(OB_STRUCT_DEVICE_TEMPERATURE, OB_STRUCT_PROPERTY),
+    // PROP_INFO_PAIR(OB_STRUCT_IR_AE_PARAM, OB_STRUCT_PROPERTY),
+    // PROP_INFO_PAIR(OB_STRUCT_DEVICE_UPGRADE_STATUS, OB_STRUCT_PROPERTY),
+    // PROP_INFO_PAIR(OB_STRUCT_DEVICE_FILE_TRAN_STATUS, OB_STRUCT_PROPERTY),
+    // PROP_INFO_PAIR(OB_STRUCT_TOF_MODULATION_FREQ, OB_STRUCT_PROPERTY),
+    // PROP_INFO_PAIR(OB_STRUCT_TOF_DUTY_CYCLE, OB_STRUCT_PROPERTY),
+    PROP_INFO_PAIR(OB_STRUCT_TOF_EXPOSURE_THRESHOLD_CONTROL, OB_STRUCT_PROPERTY),
+    // PROP_INFO_PAIR(OB_STRUCT_TEC_DATA, OB_STRUCT_PROPERTY),
+    // PROP_INFO_PAIR(OB_STRUCT_ANTI_COLLUSION_ACTIVATION_CONTENT, OB_STRUCT_PROPERTY),
+    // PROP_INFO_PAIR(OB_STRUCT_ANTI_COLLUSION_ACTIVATION_VERIFY, OB_STRUCT_PROPERTY),
+    // PROP_INFO_PAIR(OB_STRUCT_GET_GYRO_PRESETS_ODR_LIST, OB_STRUCT_PROPERTY),
+    // PROP_INFO_PAIR(OB_STRUCT_GET_ACCEL_PRESETS_ODR_LIST, OB_STRUCT_PROPERTY),
+    // PROP_INFO_PAIR(OB_STRUCT_GET_GYRO_PRESETS_FULL_SCALE_LIST, OB_STRUCT_PROPERTY),
+    // PROP_INFO_PAIR(OB_STRUCT_GET_ACCEL_PRESETS_FULL_SCALE_LIST, OB_STRUCT_PROPERTY),
+    PROP_INFO_PAIR(OB_STRUCT_DEVICE_SERIAL_NUMBER, OB_STRUCT_PROPERTY),
+    PROP_INFO_PAIR(OB_STRUCT_ASIC_SERIAL_NUMBER, OB_STRUCT_PROPERTY),
+    PROP_INFO_PAIR(OB_STRUCT_DEVICE_TIME, OB_STRUCT_PROPERTY),
+    PROP_INFO_PAIR(OB_STRUCT_MULTI_DEVICE_SYNC_CONFIG, OB_STRUCT_PROPERTY),
+    PROP_INFO_PAIR(OB_STRUCT_RGB_CROP_ROI, OB_STRUCT_PROPERTY),
+    PROP_INFO_PAIR(OB_STRUCT_DEVICE_IP_ADDR_CONFIG, OB_STRUCT_PROPERTY),
+    PROP_INFO_PAIR(OB_STRUCT_CURRENT_DEPTH_ALG_MODE, OB_STRUCT_PROPERTY),
+    PROP_INFO_PAIR(OB_STRUCT_DEPTH_PRECISION_SUPPORT_LIST, OB_STRUCT_PROPERTY),
+    //  PROP_INFO_PAIR(OB_PROP_DEPTH_RECTIFY_MASK_FILTER_CONFIG, OB_STRUCT_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_COLOR_AUTO_EXPOSURE_BOOL, OB_BOOL_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_COLOR_EXPOSURE_INT, OB_INT_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_COLOR_GAIN_INT, OB_INT_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_COLOR_AUTO_WHITE_BALANCE_BOOL, OB_BOOL_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_COLOR_WHITE_BALANCE_INT, OB_INT_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_COLOR_BRIGHTNESS_INT, OB_INT_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_COLOR_SHARPNESS_INT, OB_INT_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_COLOR_SATURATION_INT, OB_INT_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_COLOR_CONTRAST_INT, OB_INT_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_COLOR_GAMMA_INT, OB_INT_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_COLOR_ROLL_INT, OB_INT_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_COLOR_AUTO_EXPOSURE_PRIORITY_INT, OB_INT_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_COLOR_BACKLIGHT_COMPENSATION_INT, OB_INT_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_COLOR_HUE_INT, OB_INT_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_COLOR_POWER_LINE_FREQUENCY_INT, OB_INT_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_DEPTH_AUTO_EXPOSURE_BOOL, OB_BOOL_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_DEPTH_EXPOSURE_INT, OB_INT_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_DEPTH_GAIN_INT, OB_INT_PROPERTY),
+    // PROP_INFO_PAIR(OB_PROP_GYRO_SWITCH_BOOL, OB_BOOL_PROPERTY),
+    // PROP_INFO_PAIR(OB_PROP_ACCEL_SWITCH_BOOL, OB_BOOL_PROPERTY),
+    // PROP_INFO_PAIR(OB_PROP_GYRO_ODR_INT, OB_INT_PROPERTY),
+    // PROP_INFO_PAIR(OB_PROP_ACCEL_ODR_INT, OB_INT_PROPERTY),
+    // PROP_INFO_PAIR(OB_PROP_GYRO_FULL_SCALE_INT, OB_INT_PROPERTY),
+    // PROP_INFO_PAIR(OB_PROP_ACCEL_FULL_SCALE_INT, OB_INT_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_IR_AUTO_EXPOSURE_BOOL, OB_BOOL_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_IR_EXPOSURE_INT, OB_INT_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_IR_GAIN_INT, OB_INT_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_IR_CHANNEL_DATA_SOURCE_INT, OB_INT_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_DEPTH_RM_FILTER_BOOL, OB_BOOL_PROPERTY),
+    //  PROP_INFO_PAIR(OB_PROP_DEPTH_ALG_MODE_TYPE_INT, OB_INT_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_COLOR_HDR_BOOL, OB_BOOL_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_COLOR_FOCUS_INT, OB_INT_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_IR_LONG_EXPOSURE_BOOL, OB_BOOL_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_SKIP_FRAME_BOOL, OB_BOOL_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_IR_SHORT_EXPOSURE_BOOL, OB_BOOL_PROPERTY),
+    // PROP_INFO_PAIR(OB_PROP_IR_SHORT_EXPOSURE_INT, OB_INT_PROPERTY),
+    // PROP_INFO_PAIR(OB_PROP_SDK_DEPTH_RECTIFY_MG_FILTER_BOOL, OB_BOOL_PROPERTY),
+    // PROP_INFO_PAIR(OB_PROP_SDK_DEPTH_RECTIFY_MG_FILTER_X_INT, OB_INT_PROPERTY),
+    // PROP_INFO_PAIR(OB_PROP_SDK_DEPTH_RECTIFY_MG_FILTER_Y_INT, OB_INT_PROPERTY),
+    // PROP_INFO_PAIR(OB_PROP_SDK_DEPTH_RECTIFY_MG_FILTER_MODE_BOOL, OB_BOOL_PROPERTY),
+    // PROP_INFO_PAIR(OB_STRUCT_DEPTH_DDO_CONFIG, OB_STRUCT_PROPERTY),
+    // PROP_INFO_PAIR(OB_STRUCT_DEPTH_DDO_CONFIG_DEFAULT, OB_STRUCT_PROPERTY),
+    PROP_INFO_PAIR(OB_STRUCT_DEPTH_HDR_CONFIG, OB_STRUCT_PROPERTY),
+    PROP_INFO_PAIR(OB_STRUCT_COLOR_AE_ROI, OB_STRUCT_PROPERTY),
+    PROP_INFO_PAIR(OB_STRUCT_DEPTH_AE_ROI, OB_STRUCT_PROPERTY),
+    // PROP_INFO_PAIR(OB_STRUCT_DEPTH_NOISE_REMOVAL_FILTER_PARAMS, OB_STRUCT_PROPERTY),
+    // PROP_INFO_PAIR(OB_STRUCT_DEPTH_EDGE_NOISE_REMOVAL_FILTER_PARAMS, OB_STRUCT_PROPERTY),
+    // PROP_INFO_PAIR(OB_STRUCT_DEPTH_SPATIAL_FAST_FILTER_PARAMS, OB_STRUCT_PROPERTY),
+    // PROP_INFO_PAIR(OB_STRUCT_DEPTH_SPATIAL_MODERATE_FILTER_PARAMS, OB_STRUCT_PROPERTY),
+    // PROP_INFO_PAIR(OB_STRUCT_DEPTH_SPATIAL_ADVANCED_FILTER_PARAMS, OB_STRUCT_PROPERTY),
+    // PROP_INFO_PAIR(OB_STRUCT_DEPTH_HOLE_FILLING_FILTER_PARAMS, OB_STRUCT_PROPERTY),
+    // PROP_INFO_PAIR(OB_STRUCT_DEPTH_TEMPORAL_FILTER_PARAMS, OB_STRUCT_PROPERTY),
+    // PROP_INFO_PAIR(OB_PROP_UPDATE_BASE_TIME_BOOL, OB_BOOL_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_SDK_DISPARITY_TO_DEPTH_BOOL, OB_BOOL_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_SDK_DEPTH_FRAME_UNPACK_BOOL, OB_BOOL_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_SDK_IR_FRAME_UNPACK_BOOL, OB_BOOL_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_SDK_ACCEL_FRAME_TRANSFORMED_BOOL, OB_BOOL_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_SDK_GYRO_FRAME_TRANSFORMED_BOOL, OB_BOOL_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_SDK_IR_LEFT_FRAME_UNPACK_BOOL, OB_BOOL_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_SDK_IR_RIGHT_FRAME_UNPACK_BOOL, OB_BOOL_PROPERTY),
+    // PROP_INFO_PAIR(OB_RAW_DATA_MULTIPLE_DISTANCE_CALIBRATION_PARAM, OB_RAW_DATA_PROPERTY),
+    // PROP_INFO_PAIR(OB_RAW_DATA_REFERENCE_IMAGE, OB_RAW_DATA_PROPERTY),
+    // PROP_INFO_PAIR(OB_RAW_DATA_HARDWARE_ALIGN_PARAM, OB_RAW_DATA_PROPERTY),
+    // PROP_INFO_PAIR(OB_RAW_DATA_SOFTWARE_ALIGN_PARAM, OB_RAW_DATA_PROPERTY),
+    // PROP_INFO_PAIR(OB_RAW_DATA_HARDWARE_DISTORTION_PARAM, OB_RAW_DATA_PROPERTY),
+    // PROP_INFO_PAIR(OB_RAW_DATA_HARDWARE_ALIGN_PARAM_0, OB_RAW_DATA_PROPERTY),
+    // PROP_INFO_PAIR(OB_RAW_DATA_HARDWARE_ALIGN_PARAM_1, OB_RAW_DATA_PROPERTY),
+    // PROP_INFO_PAIR(OB_RAW_DATA_TEMP_COMPENSATE_PARAM, OB_RAW_DATA_PROPERTY),
+    // PROP_INFO_PAIR(OB_RAW_DATA_SOFTWARE_ALIGN_PARAM_0, OB_RAW_DATA_PROPERTY),
+    // PROP_INFO_PAIR(OB_RAW_DATA_SOFTWARE_ALIGN_PARAM_1, OB_RAW_DATA_PROPERTY),
+    // PROP_INFO_PAIR(OB_RAW_DATA_DEPTH_CALIB_FLASH_FILE, OB_RAW_DATA_PROPERTY),
+    // PROP_INFO_PAIR(OB_RAW_DATA_ALIGN_CALIB_FLASH_FILE, OB_RAW_DATA_PROPERTY),
+    // PROP_INFO_PAIR(OB_RAW_DATA_DEPTH_CALIB_PARAM, OB_RAW_DATA_PROPERTY),
+    // PROP_INFO_PAIR(OB_RAW_DATA_D2C_ALIGN_SUPPORT_PROFILE_LIST, OB_RAW_DATA_PROPERTY),
+    // PROP_INFO_PAIR(OB_RAW_DATA_ALIGN_CALIB_PARAM, OB_RAW_DATA_PROPERTY),
+    // PROP_INFO_PAIR(OB_RAW_DATA_DISPARITY_TO_DEPTH_PROFILE_LIST, OB_RAW_DATA_PROPERTY),
+    // PROP_INFO_PAIR(OB_RAW_DATA_CAMERA_CALIB_JSON_FILE, OB_RAW_DATA_PROPERTY),
+    // PROP_INFO_PAIR(OB_RAW_DATA_D2C_ROT_LUT_FILE, OB_RAW_DATA_PROPERTY),
+    // PROP_INFO_PAIR(OB_RAW_DATA_MCU_UPGRADE_FILE, OB_RAW_DATA_PROPERTY),
+    // PROP_INFO_PAIR(OB_RAW_DATA_DEFAULT_STREAM_PROFILE_LIST, OB_RAW_DATA_PROPERTY),
+    // PROP_INFO_PAIR(OB_RAW_DATA_STREAM_PROFILE_LIST, OB_RAW_DATA_PROPERTY),
+    // PROP_INFO_PAIR(OB_RAW_DATA_IMU_CALIB_PARAM, OB_RAW_DATA_PROPERTY),
+    // PROP_INFO_PAIR(OB_RAW_DATA_DEPTH_ALG_MODE_LIST, OB_RAW_DATA_PROPERTY),
+    // PROP_INFO_PAIR(OB_RAW_DATA_EFFECTIVE_VIDEO_STREAM_PROFILE_LIST, OB_RAW_DATA_PROPERTY),
+    // PROP_INFO_PAIR(OB_RAW_DATA_DE_IR_RECTIFY_PARAMS, OB_RAW_DATA_PROPERTY),
+    // PROP_INFO_PAIR(OB_RAW_DATA_DEVICE_UPGRADE, OB_RAW_DATA_PROPERTY),
+    // PROP_INFO_PAIR(OB_RAW_DATA_DEVICE_EXTENSION_INFORMATION, OB_RAW_DATA_PROPERTY),
+    // PROP_INFO_PAIR(OB_RAW_DATA_DEVICE_MAC, OB_RAW_DATA_PROPERTY),
+    // PROP_INFO_PAIR(OB_RAW_DATA_IR_AE_PARAMS, OB_RAW_DATA_PROPERTY),
+    // PROP_INFO_PAIR(OB_RAW_DATA_NET_PORT_INFO_LIST, OB_RAW_DATA_PROPERTY),
+    // PROP_INFO_PAIR(OB_PROP_DEBUG_ADB_FUNCTION_CONTROL_BOOL, OB_BOOL_PROPERTY),
+    // PROP_INFO_PAIR(OB_PROP_DEBUG_SET_FORCE_UPGRADE_BOOL, OB_BOOL_PROPERTY),
+    // PROP_INFO_PAIR(OB_PROP_DEBUG_LOG_SEVERITY_LEVEL_INT, OB_BOOL_PROPERTY),
+    // PROP_INFO_PAIR(OB_STRUCT_DEBUG_RECORD_RGB_DATA, OB_STRUCT_PROPERTY),
+    // PROP_INFO_PAIR(OB_STRUCT_DEBUG_RECORD_PHASE_DATA, OB_STRUCT_PROPERTY),
+    // PROP_INFO_PAIR(OB_STRUCT_DEBUG_RECORD_IR_DATA, OB_STRUCT_PROPERTY),
+    // PROP_INFO_PAIR(OB_STRUCT_DEBUG_RECORD_DEPTH_DATA, OB_STRUCT_PROPERTY),
+    // PROP_INFO_PAIR(OB_STRUCT_DEBUG_SENSOR_EXPOSURE_TIME, OB_STRUCT_PROPERTY),
+    // PROP_INFO_PAIR(OB_STRUCT_PERIPHERAL_ID_INFO, OB_STRUCT_PROPERTY),
+    // PROP_INFO_PAIR(OB_STRUCT_LED_CONTROL, OB_STRUCT_PROPERTY),
+    // PROP_INFO_PAIR(OB_RAW_DATA_FLASH_DATA_TYPE_SECTION_REF_PARAM, OB_RAW_DATA_PROPERTY),
+    // PROP_INFO_PAIR(OB_RAW_DATA_FLASH_DATA_TYPE_SECTION_RECTIFY_KK_PARAM, OB_RAW_DATA_PROPERTY),
+    // PROP_INFO_PAIR(OB_RAW_DATA_FLASH_DATA_TYPE_SECTION_IR_RGB_PRE_PARAM, OB_RAW_DATA_PROPERTY),
+    // PROP_INFO_PAIR(OB_RAW_DATA_FLASH_DATA_TYPE_SECTION_RECTIFY_LUT_PARAM, OB_RAW_DATA_PROPERTY),
+    // PROP_INFO_PAIR(OB_RAW_DATA_FLASH_DATA_TYPE_SECTION_D2D_PARAM, OB_RAW_DATA_PROPERTY),
+    // PROP_INFO_PAIR(OB_RAW_DATA_FLASH_DATA_TYPE_SECTION_IMU_PARAM, OB_RAW_DATA_PROPERTY),
+    // PROP_INFO_PAIR(OB_RAW_DATA_UPDATE_MX6600_FLASH_DATA, OB_RAW_DATA_PROPERTY),
+    // PROP_INFO_PAIR(OB_PROP_DEPTH_ENGINE_RESET_BOOL, OB_BOOL_PROPERTY),
+    // PROP_INFO_PAIR(OB_PROP_DEBUG_DEVICELOG_SAVE_BOOL, OB_BOOL_PROPERTY),
+    // PROP_INFO_PAIR(OB_RAW_DATA_DEVICE_LOG_BAG, OB_STRUCT_PROPERTY),
+    // PROP_INFO_PAIR(OB_PROP_FAN_MAX_SPEED_TEST_MODE_BOOL, OB_BOOL_PROPERTY),
+    // PROP_INFO_PAIR(OB_STRUCT_COLOR_STREAM_PROFILE, OB_STRUCT_PROPERTY),
+    // PROP_INFO_PAIR(OB_STRUCT_DEPTH_STREAM_PROFILE, OB_STRUCT_PROPERTY),
+    // PROP_INFO_PAIR(OB_STRUCT_IR_STREAM_PROFILE, OB_STRUCT_PROPERTY),
+    // PROP_INFO_PAIR(OB_STRUCT_CUSTOMER_DATA, OB_STRUCT_PROPERTY),
+    PROP_INFO_PAIR(OB_STRUCT_DEVICE_STATIC_IP_CONFIG_RECORD, OB_STRUCT_PROPERTY),
+    // PROP_INFO_PAIR(OB_STRUCT_LDP_MEASURE_EXTENSION_INFO, OB_STRUCT_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_CAPTURE_INTERVAL_MODE_INT, OB_INT_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_CAPTURE_IMAGE_TIME_INTERVAL_INT, OB_INT_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_CAPTURE_IMAGE_NUMBER_INTERVAL_INT, OB_INT_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_COLOR_SHUTTER_INT, OB_INT_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_COLOR_MAXIMAL_GAIN_INT, OB_INT_PROPERTY),
+    PROP_INFO_PAIR(OB_PROP_COLOR_MAXIMAL_SHUTTER_INT, OB_INT_PROPERTY),
+};
+
+// bool isDataListProperty(OBPropertyID propertyId) {
+//     switch(propertyId) {
+//     case OB_RAW_DATA_DEPTH_CALIB_PARAM:  // follow
+//         return true;
+//     // case OB_RAW_DATA_D2C_ALIGN_SUPPORT_PROFILE_LIST:
+//     //     return true;
+//     default:
+//         break;
+//     }
+//     return false;
+// }
+
+}  // namespace libobsensor
diff --git a/src/device/component/property/PropertyHelper.hpp b/src/device/component/property/PropertyHelper.hpp
new file mode 100644
index 00000000..c18a2a2d
--- /dev/null
+++ b/src/device/component/property/PropertyHelper.hpp
@@ -0,0 +1,17 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include "libobsensor/h/Property.h"
+#include <map>
+#include <string>
+
+namespace libobsensor {
+struct OBPropertyBaseInfo {
+    OBPropertyType type;
+    const char    *name;
+};
+
+extern const std::map<uint32_t, OBPropertyBaseInfo> OBPropertyBaseInfoMap;
+
+}  // namespace libobsensor
diff --git a/src/device/component/property/PropertyServer.cpp b/src/device/component/property/PropertyServer.cpp
new file mode 100644
index 00000000..cacfaefd
--- /dev/null
+++ b/src/device/component/property/PropertyServer.cpp
@@ -0,0 +1,399 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "PropertyServer.hpp"
+#include "exception/ObException.hpp"
+#include "logger/Logger.hpp"
+#include "utils/Utils.hpp"
+#include <memory>
+
+namespace libobsensor {
+
+PropertyServer::PropertyServer(IDevice *owner) : DeviceComponentBase(owner) {}
+
+void PropertyServer::registerProperty(uint32_t propertyId, OBPermissionType userPerms, OBPermissionType intPerms, std::shared_ptr<IPropertyAccessor> accessor) {
+    properties_[propertyId] = { propertyId, userPerms, intPerms, accessor };
+
+    appendToPropertyMap(propertyId, userPerms, intPerms);
+}
+
+void PropertyServer::registerAccessCallback(uint32_t propertyId, PropertyAccessCallback callback) {
+    auto it = properties_.find(propertyId);
+    if(it == properties_.end()) {
+        throw invalid_value_exception("Property not found to register callback, propertyId: " + std::to_string(propertyId));
+    }
+    it->second.accessCallbacks.push_back(callback);
+}
+
+void PropertyServer::registerAccessCallback(std::vector<uint32_t> propertyIds, PropertyAccessCallback callback) {
+    for(auto propertyId: propertyIds) {
+        registerAccessCallback(propertyId, callback);
+    }
+}
+
+void PropertyServer::registerProperty(uint32_t propertyId, const std::string &userPermsStr, const std::string &intPermsStr,
+                                      std::shared_ptr<IPropertyAccessor> accessor) {
+    auto strToPermission = [](const std::string &str) {
+        if(str == "r") {
+            return OB_PERMISSION_READ;
+        }
+        else if(str == "w") {
+            return OB_PERMISSION_WRITE;
+        }
+        else if(str == "rw") {
+            return OB_PERMISSION_READ_WRITE;
+        }
+        else {
+            return OB_PERMISSION_DENY;
+        }
+    };
+    auto userPerms = strToPermission(userPermsStr);
+    auto intPerms  = strToPermission(intPermsStr);
+    registerProperty(propertyId, userPerms, intPerms, accessor);
+}
+
+void addProperty(std::vector<OBPropertyItem> &vec, int propertyId, const char *propName, OBPropertyType propType, OBPermissionType perms) {
+    OBPropertyItem propertyItem;
+    propertyItem.id         = static_cast<OBPropertyID>(propertyId);
+    propertyItem.name       = propName;
+    propertyItem.type       = propType;
+    propertyItem.permission = perms;
+    vec.push_back(propertyItem);
+}
+
+void PropertyServer::appendToPropertyMap(uint32_t propertyId, OBPermissionType userPerms, OBPermissionType intPerms) {
+    for(auto &item: OBPropertyBaseInfoMap) {
+        auto infoIter = OBPropertyBaseInfoMap.find(item.first);
+        if(infoIter == OBPropertyBaseInfoMap.end()) {
+            std::string msg = ", id=";
+            msg += std::to_string(item.first);
+            throw not_implemented_exception(msg);
+        }
+        if(propertyId == item.first) {
+            if(userPerms & 0x3) {
+                addProperty(userPropertiesVec_, propertyId, infoIter->second.name, infoIter->second.type, userPerms);
+            }
+
+            if(intPerms & 0x3) {
+                addProperty(innerPropertiesVec_, propertyId, infoIter->second.name, infoIter->second.type, intPerms);
+            }
+            break;
+        }
+    }
+}
+
+void PropertyServer::aliasProperty(uint32_t aliasId, uint32_t propertyId) {
+    auto it = properties_.find(propertyId);
+    if(it == properties_.end()) {
+        throw invalid_value_exception("Property not found for aliasing");
+    }
+
+    auto propertyItem = it->second;
+    propertyItem.accessCallbacks.clear();
+    properties_[aliasId] = propertyItem;
+
+    auto infoIter = OBPropertyBaseInfoMap.find(aliasId);
+    if(infoIter == OBPropertyBaseInfoMap.end()) {
+        std::string msg = ", id=";
+        msg += std::to_string(aliasId);
+        throw not_implemented_exception(msg);
+    }
+
+    if(it->second.userPermission & 0x3) {
+        addProperty(userPropertiesVec_, aliasId, infoIter->second.name, infoIter->second.type, it->second.userPermission);
+    }
+    if(it->second.InternalPermission & 0x3) {
+        addProperty(innerPropertiesVec_, aliasId, infoIter->second.name, infoIter->second.type, it->second.InternalPermission);
+    }
+}
+
+bool PropertyServer::isPropertySupported(uint32_t propertyId, PropertyOperationType operationType, PropertyAccessType accessType) const {
+    auto it = properties_.find(propertyId);
+    if(it == properties_.end()) {
+        return false;
+    }
+
+    OBPermissionType permission = OB_PERMISSION_DENY;
+    if(accessType == PROP_ACCESS_USER) {
+        permission = it->second.userPermission;
+    }
+    else if(accessType == PROP_ACCESS_INTERNAL) {
+        permission = it->second.InternalPermission;
+    }
+
+    if(operationType == PROP_OP_READ) {
+        return permission & OB_PERMISSION_READ;
+    }
+    else if(operationType == PROP_OP_WRITE) {
+        return permission & OB_PERMISSION_WRITE;
+    }
+    else if(operationType == PROP_OP_READ_WRITE) {
+        return permission == OB_PERMISSION_READ_WRITE;
+    }
+
+    return false;
+}
+
+void PropertyServer::setPropertyValue(uint32_t propertyId, OBPropertyValue value, PropertyAccessType accessType) {
+    std::lock_guard<std::recursive_mutex> lock(mutex_);
+    if(!isPropertySupported(propertyId, PROP_OP_WRITE, accessType)) {
+        throw invalid_value_exception("Property not writable");
+    }
+
+    auto  it       = properties_.find(propertyId);
+    auto &accessor = it->second.accessor;
+    auto &propId   = it->second.propertyId;
+    if(propId != propertyId) {
+        LOG_DEBUG("Property {} alias to {}", propId, propertyId);
+    }
+
+    auto basicAccessor = std::dynamic_pointer_cast<IBasicPropertyAccessor>(accessor);
+    basicAccessor->setPropertyValue(propId, value);
+
+    for(auto &callback: it->second.accessCallbacks) {
+        auto data = reinterpret_cast<uint8_t *>(&value);
+        callback(propertyId, data, sizeof(OBPropertyValue), PROP_OP_WRITE);
+    }
+
+    LOG_DEBUG("Property {} set to {}|{}", propId, value.intValue, value.floatValue);
+}
+
+void PropertyServer::getPropertyValue(uint32_t propertyId, OBPropertyValue *value, PropertyAccessType accessType) {
+    std::lock_guard<std::recursive_mutex> lock(mutex_);
+    if(!isPropertySupported(propertyId, PROP_OP_READ, accessType)) {
+        throw invalid_value_exception(utils::string::to_string() << "Property not readable: " << propertyId);
+    }
+
+    auto  it       = properties_.find(propertyId);
+    auto &accessor = it->second.accessor;
+    auto &propId   = it->second.propertyId;
+    if(propId != propertyId) {
+        LOG_DEBUG("Property {} alias to {}", propId, propertyId);
+    }
+
+    auto basicAccessor = std::dynamic_pointer_cast<IBasicPropertyAccessor>(accessor);
+    basicAccessor->getPropertyValue(propId, value);
+
+    for(auto &callback: it->second.accessCallbacks) {
+        auto data = reinterpret_cast<uint8_t *>(value);
+        callback(propertyId, data, sizeof(OBPropertyValue), PROP_OP_READ);
+    }
+
+    LOG_DEBUG("Property {} get as {}|{}", propId, value->intValue, value->floatValue);
+}
+
+// std::vector<OBPropertyItem> PropertyServer::getProperties(PropertyAccessType accessType) const{
+//     std::lock_guard<std::recursive_mutex> lock(mutex_);
+//     return properties_;
+// }
+
+void PropertyServer::getPropertyRange(uint32_t propertyId, OBPropertyRange *range, PropertyAccessType accessType) {
+    std::lock_guard<std::recursive_mutex> lock(mutex_);
+    if(!isPropertySupported(propertyId, PROP_OP_READ, accessType)) {
+        throw invalid_value_exception(utils::string::to_string() << "Property not readable: " << propertyId);
+    }
+
+    auto  it       = properties_.find(propertyId);
+    auto &accessor = it->second.accessor;
+    auto &propId   = it->second.propertyId;
+    if(propId != propertyId) {
+        LOG_DEBUG("Property {} alias to {}", propId, propertyId);
+    }
+
+    auto basicAccessor = std::dynamic_pointer_cast<IBasicPropertyAccessor>(accessor);
+    basicAccessor->getPropertyRange(propId, range);
+    LOG_DEBUG("Property {} range as {}-{} step {} def {}|{}-{} step {} def {}", propId, range->min.intValue, range->max.intValue, range->step.intValue,
+              range->def.intValue, range->min.floatValue, range->max.floatValue, range->step.floatValue, range->def.floatValue);
+}
+
+void PropertyServer::setStructureData(uint32_t propertyId, const std::vector<uint8_t> &data, PropertyAccessType accessType) {
+    std::lock_guard<std::recursive_mutex> lock(mutex_);
+    if(!isPropertySupported(propertyId, PROP_OP_WRITE, accessType)) {
+        throw invalid_value_exception("Property not writable");
+    }
+
+    auto  it       = properties_.find(propertyId);
+    auto &accessor = it->second.accessor;
+    auto &propId   = it->second.propertyId;
+    if(propId != propertyId) {
+        LOG_DEBUG("Property {} alias to {}", propId, propertyId);
+    }
+    auto structAccessor = std::dynamic_pointer_cast<IStructureDataAccessor>(accessor);
+    if(structAccessor == nullptr) {
+        throw invalid_value_exception(utils::string::to_string() << "Property" << propId << " does not support structure data setting");
+    }
+    structAccessor->setStructureData(propId, data);
+
+    for(auto &callback: it->second.accessCallbacks) {
+        callback(propertyId, data.data(), data.size(), PROP_OP_WRITE);
+    }
+    LOG_DEBUG("Property {} set structure data successfully", propId);
+}
+
+const std::vector<uint8_t> &PropertyServer::getStructureData(uint32_t propertyId, PropertyAccessType accessType) {
+    std::lock_guard<std::recursive_mutex> lock(mutex_);
+    if(!isPropertySupported(propertyId, PROP_OP_READ, accessType)) {
+        throw invalid_value_exception(utils::string::to_string() << "Property not readable: " << propertyId);
+    }
+
+    auto  it       = properties_.find(propertyId);
+    auto &accessor = it->second.accessor;
+    auto &propId   = it->second.propertyId;
+    if(propId != propertyId) {
+        LOG_DEBUG("Property {} alias to {}", propId, propertyId);
+    }
+
+    auto structAccessor = std::dynamic_pointer_cast<IStructureDataAccessor>(accessor);
+    if(structAccessor == nullptr) {
+        throw invalid_value_exception(utils::string::to_string() << "Property " << propId << " does not support structure data getting");
+    }
+    const auto &data = structAccessor->getStructureData(propId);
+    for(auto &callback: it->second.accessCallbacks) {
+        callback(propertyId, data.data(), data.size(), PROP_OP_READ);
+    }
+    LOG_DEBUG("Property {} get structure data successfully, size {}", propId, data.size());
+    return data;
+}
+
+void PropertyServer::getRawData(uint32_t propertyId, GetDataCallback callback, PropertyAccessType accessType) {
+    std::lock_guard<std::recursive_mutex> lock(mutex_);
+    if(!isPropertySupported(propertyId, PROP_OP_READ, accessType)) {
+        throw invalid_value_exception(utils::string::to_string() << "Property not readable: " << propertyId);
+    }
+
+    auto  it       = properties_.find(propertyId);
+    auto &accessor = it->second.accessor;
+    auto &propId   = it->second.propertyId;
+    if(propId != propertyId) {
+        LOG_DEBUG("Property {} alias to {}", propId, propertyId);
+    }
+    auto rawDataAccessor = std::dynamic_pointer_cast<IRawDataAccessor>(accessor);
+    if(rawDataAccessor == nullptr) {
+        throw invalid_value_exception(utils::string::to_string() << "Property" << propId << " does not support raw data getting");
+    }
+
+    rawDataAccessor->getRawData(propId, callback);  // todo: add async support
+    for(auto &accessCallback: it->second.accessCallbacks) {
+        accessCallback(propertyId, nullptr, 0, PROP_OP_READ);
+    }
+    LOG_DEBUG("Property {} get raw data successfully", propId);
+}
+
+uint16_t PropertyServer::getCmdVersionProtoV1_1(uint32_t propertyId, PropertyAccessType accessType) {
+    std::lock_guard<std::recursive_mutex> lock(mutex_);
+    if(!isPropertySupported(propertyId, PROP_OP_READ, accessType)) {
+        throw invalid_value_exception(utils::string::to_string() << "Property not readable: " << propertyId);
+    }
+
+    auto  it       = properties_.find(propertyId);
+    auto &accessor = it->second.accessor;
+    auto &propId   = it->second.propertyId;
+    if(propId != propertyId) {
+        LOG_DEBUG("Property {} alias to {}", propId, propertyId);
+    }
+    auto structAccessor = std::dynamic_pointer_cast<IStructureDataAccessorV1_1>(accessor);
+    if(structAccessor == nullptr) {
+        throw invalid_value_exception(utils::string::to_string() << "Property" << propId << " does not support cmd version getting");
+    }
+
+    auto ver = structAccessor->getCmdVersionProtoV1_1(propId);
+    LOG_DEBUG("Property {} get cmd version successfully, version {}", propId, ver);
+    return ver;
+}
+
+const std::vector<uint8_t> &PropertyServer::getStructureDataProtoV1_1(uint32_t propertyId, uint16_t cmdVersion, PropertyAccessType accessType) {
+    std::lock_guard<std::recursive_mutex> lock(mutex_);
+    if(!isPropertySupported(propertyId, PROP_OP_READ, accessType)) {
+        throw invalid_value_exception(utils::string::to_string() << "Property not readable: " << propertyId);
+    }
+
+    auto  it       = properties_.find(propertyId);
+    auto &accessor = it->second.accessor;
+    auto &propId   = it->second.propertyId;
+    if(propId != propertyId) {
+        LOG_DEBUG("Property {} alias to {}", propId, propertyId);
+    }
+    auto structAccessor = std::dynamic_pointer_cast<IStructureDataAccessorV1_1>(accessor);
+    if(structAccessor == nullptr) {
+        throw invalid_value_exception(utils::string::to_string() << "Property" << propId << " does not support structure data getting over proto v1.1");
+    }
+    const auto &data = structAccessor->getStructureDataProtoV1_1(propId, cmdVersion);
+    for(auto callback: it->second.accessCallbacks) {
+        callback(propertyId, data.data(), data.size(), PROP_OP_READ);
+    }
+    LOG_DEBUG("Property {} get structure data successfully over proto v1.1, size {}", propId, data.size());
+    return data;
+}
+
+void PropertyServer::setStructureDataProtoV1_1(uint32_t propertyId, const std::vector<uint8_t> &data, uint16_t cmdVersion, PropertyAccessType accessType) {
+    std::lock_guard<std::recursive_mutex> lock(mutex_);
+    if(!isPropertySupported(propertyId, PROP_OP_WRITE, accessType)) {
+        throw invalid_value_exception("Property not writable");
+    }
+
+    auto  it       = properties_.find(propertyId);
+    auto &accessor = it->second.accessor;
+    auto &propId   = it->second.propertyId;
+    if(propId != propertyId) {
+        LOG_DEBUG("Property {} alias to {}", propId, propertyId);
+    }
+    auto structAccessor = std::dynamic_pointer_cast<IStructureDataAccessorV1_1>(accessor);
+    if(structAccessor == nullptr) {
+        throw invalid_value_exception(utils::string::to_string() << "Property" << propId << " does not support structure data setting over proto v1.1");
+    }
+    structAccessor->setStructureDataProtoV1_1(propId, data, cmdVersion);
+    for(auto callback: it->second.accessCallbacks) {
+        callback(propertyId, data.data(), data.size(), PROP_OP_WRITE);
+    }
+    LOG_DEBUG("Property {} set structure data successfully over proto v1.1", propId);
+}
+
+const std::vector<uint8_t> &PropertyServer::getStructureDataListProtoV1_1(uint32_t propertyId, uint16_t cmdVersion, PropertyAccessType accessType) {
+    std::lock_guard<std::recursive_mutex> lock(mutex_);
+    if(!isPropertySupported(propertyId, PROP_OP_READ, accessType)) {
+        throw invalid_value_exception(utils::string::to_string() << "Property not readable: " << propertyId);
+    }
+
+    auto  it       = properties_.find(propertyId);
+    auto &accessor = it->second.accessor;
+    auto &propId   = it->second.propertyId;
+    if(propId != propertyId) {
+        LOG_DEBUG("Property {} alias to {}", propId, propertyId);
+    }
+    auto structAccessor = std::dynamic_pointer_cast<IStructureDataAccessorV1_1>(accessor);
+    if(structAccessor == nullptr) {
+        throw invalid_value_exception(utils::string::to_string() << "Property" << propId << " does not support structure data list getting over proto v1.1");
+    }
+    const auto &data = structAccessor->getStructureDataListProtoV1_1(propId, cmdVersion);
+    for(auto callback: it->second.accessCallbacks) {
+        callback(propertyId, data.data(), data.size(), PROP_OP_READ);
+    }
+    LOG_DEBUG("Property {} get structure data list successfully over proto v1.1, size {}", propId, data.size());
+    return data;
+}
+
+const std::vector<OBPropertyItem> &PropertyServer::getAvailableProperties(PropertyAccessType accessType) {
+    if(accessType == PROP_ACCESS_USER) {
+        return userPropertiesVec_;
+    }
+    else if(accessType == PROP_ACCESS_INTERNAL) {
+        return innerPropertiesVec_;
+    }
+
+    static const std::vector<OBPropertyItem> emptyVec;
+    return emptyVec;
+}
+
+OBPropertyItem PropertyServer::getPropertyItem(uint32_t propertyId, PropertyAccessType accessType) {
+    OBPropertyItem retItem       = {};
+    auto           propertiesVec = getAvailableProperties(accessType);
+    for(const auto &item: propertiesVec) {
+        if(static_cast<uint32_t>(item.id) == propertyId) {
+            retItem = item;
+            break;
+        }
+    }
+    return retItem;
+}
+
+}  // namespace libobsensor
diff --git a/src/device/component/property/PropertyServer.hpp b/src/device/component/property/PropertyServer.hpp
new file mode 100644
index 00000000..26017198
--- /dev/null
+++ b/src/device/component/property/PropertyServer.hpp
@@ -0,0 +1,64 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include "IProperty.hpp"
+#include "InternalProperty.hpp"
+#include "libobsensor/h/Property.h"
+#include "PropertyHelper.hpp"
+#include "DeviceComponentBase.hpp"
+
+namespace libobsensor {
+
+class PropertyServer : public IPropertyServer, public DeviceComponentBase {
+
+    struct PropertyItem {
+        uint32_t                            propertyId;
+        OBPermissionType                    userPermission;
+        OBPermissionType                    InternalPermission;
+        std::shared_ptr<IPropertyAccessor>  accessor;
+        std::vector<PropertyAccessCallback> accessCallbacks;
+    };
+
+public:
+    PropertyServer(IDevice *owner);
+    ~PropertyServer() noexcept = default;
+
+    virtual void registerAccessCallback(uint32_t propertyId, PropertyAccessCallback callback) override;
+    virtual void registerAccessCallback(std::vector<uint32_t> propertyIds, PropertyAccessCallback callback) override;
+
+    void registerProperty(uint32_t propertyId, OBPermissionType userPerms, OBPermissionType intPerms, std::shared_ptr<IPropertyAccessor> accessor) override;
+    void registerProperty(uint32_t propertyId, const std::string &userPermsStr, const std::string &intPermsStr,
+                          std::shared_ptr<IPropertyAccessor> accessor) override;
+    void aliasProperty(uint32_t aliasId, uint32_t propertyId) override;
+
+    bool isPropertySupported(uint32_t propertyId, PropertyOperationType operationType, PropertyAccessType accessType) const override;
+    const std::vector<OBPropertyItem> &getAvailableProperties(PropertyAccessType accessType) override;
+    virtual OBPropertyItem             getPropertyItem(uint32_t propertyId, PropertyAccessType accessType) override;
+
+    void setPropertyValue(uint32_t propertyId, OBPropertyValue value, PropertyAccessType accessType) override;
+    void getPropertyValue(uint32_t propertyId, OBPropertyValue *value, PropertyAccessType accessType) override;
+    void getPropertyRange(uint32_t propertyId, OBPropertyRange *range, PropertyAccessType accessType) override;
+
+    void                        setStructureData(uint32_t propertyId, const std::vector<uint8_t> &data, PropertyAccessType accessType) override;
+    const std::vector<uint8_t> &getStructureData(uint32_t propertyId, PropertyAccessType accessType) override;
+
+    void getRawData(uint32_t propertyId, GetDataCallback callback, PropertyAccessType accessType) override;
+
+    uint16_t                    getCmdVersionProtoV1_1(uint32_t propertyId, PropertyAccessType accessType) override;
+    const std::vector<uint8_t> &getStructureDataProtoV1_1(uint32_t propertyId, uint16_t cmdVersion, PropertyAccessType accessType) override;
+    void setStructureDataProtoV1_1(uint32_t propertyId, const std::vector<uint8_t> &data, uint16_t cmdVersion, PropertyAccessType accessType) override;
+    const std::vector<uint8_t> &getStructureDataListProtoV1_1(uint32_t propertyId, uint16_t cmdVersion, PropertyAccessType accessType) override;
+
+private:
+    void appendToPropertyMap(uint32_t propertyId, OBPermissionType userPerms, OBPermissionType intPerms);
+
+private:
+    std::recursive_mutex             mutex_;
+    std::map<uint32_t, PropertyItem> properties_;
+    std::vector<OBPropertyItem>      userPropertiesVec_;
+    std::vector<OBPropertyItem>      innerPropertiesVec_;
+};
+
+}  // namespace libobsensor
diff --git a/src/device/component/property/UvcPropertyAccessor.cpp b/src/device/component/property/UvcPropertyAccessor.cpp
new file mode 100644
index 00000000..9aa22804
--- /dev/null
+++ b/src/device/component/property/UvcPropertyAccessor.cpp
@@ -0,0 +1,173 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "UvcPropertyAccessor.hpp"
+#include "usb/uvc/UvcDevicePort.hpp"
+
+namespace libobsensor {
+
+OBPropertyRange UvcCtrlRangeToPropRange(const UvcControlRange &ran) {
+    OBPropertyRange range;
+    range.max.intValue  = *(int32_t *)ran.max.data();
+    range.min.intValue  = *(int32_t *)ran.min.data();
+    range.def.intValue  = *(int32_t *)ran.def.data();
+    range.step.intValue = *(int32_t *)ran.step.data();
+    return range;
+}
+
+uint32_t convertToUvcCompatibleID(uint32_t propertyId) {
+    switch(propertyId) {
+    case OB_PROP_COLOR_AUTO_EXPOSURE_BOOL:
+    case OB_PROP_DEPTH_AUTO_EXPOSURE_BOOL:
+    case OB_PROP_IR_AUTO_EXPOSURE_BOOL:
+        return OB_PROP_COLOR_AUTO_EXPOSURE_BOOL;
+    case OB_PROP_COLOR_EXPOSURE_INT:
+    case OB_PROP_DEPTH_EXPOSURE_INT:
+    case OB_PROP_IR_EXPOSURE_INT:
+        return OB_PROP_COLOR_EXPOSURE_INT;
+    case OB_PROP_COLOR_GAIN_INT:
+    case OB_PROP_DEPTH_GAIN_INT:
+    case OB_PROP_IR_GAIN_INT:
+        return OB_PROP_COLOR_GAIN_INT;
+    case OB_PROP_COLOR_AUTO_WHITE_BALANCE_BOOL:
+    case OB_PROP_COLOR_WHITE_BALANCE_INT:
+    case OB_PROP_COLOR_BRIGHTNESS_INT:
+    case OB_PROP_COLOR_SHARPNESS_INT:
+    case OB_PROP_COLOR_SATURATION_INT:
+    case OB_PROP_COLOR_CONTRAST_INT:
+    case OB_PROP_COLOR_GAMMA_INT:
+    case OB_PROP_COLOR_ROLL_INT:
+    case OB_PROP_COLOR_AUTO_EXPOSURE_PRIORITY_INT:
+    case OB_PROP_COLOR_FOCUS_INT:
+    case OB_PROP_COLOR_BACKLIGHT_COMPENSATION_INT:
+    case OB_PROP_COLOR_HUE_INT:
+    case OB_PROP_COLOR_POWER_LINE_FREQUENCY_INT:
+    case OB_PROP_IR_BRIGHTNESS_INT:
+    case OB_PROP_COLOR_AE_MAX_EXPOSURE_INT:  // todo：not supported yet
+    case OB_PROP_IR_AE_MAX_EXPOSURE_INT:
+    case OB_PROP_COLOR_HDR_BOOL:
+        return propertyId;
+
+    default:
+        throw unsupported_operation_exception("Unsupported property requestId!");
+    }
+}
+
+UvcPropertyAccessor::UvcPropertyAccessor(const std::shared_ptr<ISourcePort> &backend) : backend_(backend) {
+    auto uvcPort = std::dynamic_pointer_cast<UvcDevicePort>(backend_);
+    if(!uvcPort) {
+        throw invalid_value_exception("UvcPropertyAccessor backend must be UvcDevicePort");
+    }
+}
+
+void UvcPropertyAccessor::setPropertyValue(uint32_t propertyId, const OBPropertyValue &value) {
+    auto    uvcDevicePort = std::dynamic_pointer_cast<UvcDevicePort>(backend_);
+    int32_t val;
+    OBPropertyValue fixValue;
+
+    switch(propertyId) {
+    case OB_PROP_COLOR_MIRROR_BOOL: {
+        uvcDevicePort->getPu(OB_PROP_COLOR_ROLL_INT, val);
+        // OB_PROP_COLOR_ROLL_INT：0->none 1->mirror 2->flip 3->mirror with flip
+        fixValue.intValue = (val & 0xFFFFFFFE) | (value.intValue & 0x01);
+        if(val != fixValue.intValue) {
+            uvcDevicePort->setPu(OB_PROP_COLOR_ROLL_INT, fixValue.intValue);
+        }
+        break;
+    }
+    case OB_PROP_COLOR_FLIP_BOOL: {
+        uvcDevicePort->getPu(OB_PROP_COLOR_ROLL_INT, val);
+        // OB_PROP_COLOR_ROLL_INT：0->none 1->mirror 2->flip 3->mirror with flip
+        fixValue.intValue = (val & 0xFFFFFFFD) | ((value.intValue & 0x01) << 1);
+        if(val != fixValue.intValue) {
+            uvcDevicePort->setPu(OB_PROP_COLOR_ROLL_INT, fixValue.intValue);
+        }
+        break;
+    }
+    case OB_PROP_COLOR_FOCUS_INT: {
+        // OB_PROP_COLOR_FOCUS_INT default:1, custom may be set 0 for astra+
+        fixValue.intValue = value.intValue & 0x01;
+        if((0 == fixValue.intValue) || (1 == fixValue.intValue)) {
+            LOG_DEBUG("-OB_PROP_COLOR_FOCUS_INT setPu value:{}", fixValue.intValue);
+            propertyId = convertToUvcCompatibleID(propertyId);
+            uvcDevicePort->setPu(propertyId, value.intValue);
+        }
+        break;
+    }
+    default:
+        propertyId = convertToUvcCompatibleID(propertyId);
+        uvcDevicePort->setPu(propertyId, value.intValue);
+        break;
+    }
+}
+
+void UvcPropertyAccessor::getPropertyValue(uint32_t propertyId, OBPropertyValue *value) {
+    auto    uvcDevicePort = std::dynamic_pointer_cast<UvcDevicePort>(backend_);
+    int32_t val;
+
+    switch(propertyId) {
+    case OB_PROP_COLOR_MIRROR_BOOL: {
+        uvcDevicePort->getPu(OB_PROP_COLOR_ROLL_INT, val);
+        // OB_PROP_COLOR_ROLL_INT：0->none 1->mirror 2->flip 3->mirror with flip
+        value->intValue = val & 0x01;
+        break;
+    }
+    case OB_PROP_COLOR_FLIP_BOOL: {
+        uvcDevicePort->getPu(OB_PROP_COLOR_ROLL_INT, val);
+        // OB_PROP_COLOR_ROLL_INT：0->none 1->mirror 2->flip 3->mirror with flip
+        value->intValue = val & (0x01 << 1);
+        break;
+    }
+    case OB_PROP_COLOR_FOCUS_INT: {
+        // OB_PROP_COLOR_FOCUS_INT default:1, custom may be set 0 for astra+
+        propertyId = convertToUvcCompatibleID(propertyId);
+        uvcDevicePort->getPu(propertyId, val);
+        value->intValue = val & 0x01;
+        LOG_DEBUG("-OB_PROP_COLOR_FOCUS_INT getPu value:{}", value->intValue);
+        break;
+    }
+    default:
+        propertyId = convertToUvcCompatibleID(propertyId);
+        uvcDevicePort->getPu(propertyId, val);
+        value->intValue = val;
+        break;
+    }
+}
+
+void UvcPropertyAccessor::getPropertyRange(uint32_t propertyId, OBPropertyRange *range) {
+    auto            uvcDevicePort = std::dynamic_pointer_cast<UvcDevicePort>(backend_);
+    int32_t         val;
+    UvcControlRange rangeControl;
+
+    switch(propertyId) {
+    case OB_PROP_COLOR_MIRROR_BOOL: {
+        // OB_PROP_COLOR_ROLL_INT：0->none 1->mirror 2->flip 3->mirror with flip
+        rangeControl        = uvcDevicePort->getPuRange(OB_PROP_COLOR_ROLL_INT);
+        *range              = UvcCtrlRangeToPropRange(rangeControl);
+        range->def.intValue = range->def.intValue & 0x01;
+        uvcDevicePort->getPu(OB_PROP_COLOR_ROLL_INT, val);
+        range->cur.intValue = val & 0x01;
+
+        break;
+    }
+    case OB_PROP_COLOR_FLIP_BOOL: {
+        // OB_PROP_COLOR_ROLL_INT：0->none 1->mirror 2->flip 3->mirror with flip
+        rangeControl        = uvcDevicePort->getPuRange(OB_PROP_COLOR_ROLL_INT);
+        *range              = UvcCtrlRangeToPropRange(rangeControl);
+        range->def.intValue = range->def.intValue & (0x01 << 1);
+        uvcDevicePort->getPu(OB_PROP_COLOR_ROLL_INT, val);
+        range->cur.intValue = val & (0x01 << 1);
+        break;
+    }
+    default: {
+        propertyId   = convertToUvcCompatibleID(propertyId);
+        rangeControl = uvcDevicePort->getPuRange(propertyId);
+        *range       = UvcCtrlRangeToPropRange(rangeControl);
+        uvcDevicePort->getPu(propertyId, val);
+        range->cur.intValue = val;
+        break;
+    }
+    }
+}
+
+}  // namespace libobsensor
diff --git a/src/device/component/property/UvcPropertyAccessor.hpp b/src/device/component/property/UvcPropertyAccessor.hpp
new file mode 100644
index 00000000..ff95f697
--- /dev/null
+++ b/src/device/component/property/UvcPropertyAccessor.hpp
@@ -0,0 +1,24 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include "IProperty.hpp"
+#include "ISourcePort.hpp"
+
+namespace libobsensor {
+
+class UvcPropertyAccessor : public IBasicPropertyAccessor {
+public:
+    UvcPropertyAccessor(const std::shared_ptr<ISourcePort> &backend);
+    ~UvcPropertyAccessor() noexcept override = default;
+
+    void setPropertyValue(uint32_t propertyId, const OBPropertyValue &value) override;
+    void getPropertyValue(uint32_t propertyId, OBPropertyValue *value) override;
+    void getPropertyRange(uint32_t propertyId, OBPropertyRange *range) override;
+
+private:
+    std::shared_ptr<ISourcePort> backend_;
+};
+
+}  // namespace libobsensor
+
diff --git a/src/device/component/property/VendorPropertyAccessor.cpp b/src/device/component/property/VendorPropertyAccessor.cpp
new file mode 100644
index 00000000..3e9fa4b2
--- /dev/null
+++ b/src/device/component/property/VendorPropertyAccessor.cpp
@@ -0,0 +1,273 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "VendorPropertyAccessor.hpp"
+#include "exception/ObException.hpp"
+#include "protocol/Protocol.hpp"
+
+namespace libobsensor {
+
+const uint32_t DEFAULT_CMD_MAX_DATA_SIZE = 768;
+
+VendorPropertyAccessor::VendorPropertyAccessor(IDevice *owner, const std::shared_ptr<ISourcePort> &backend)
+    : owner_(owner),
+      backend_(backend),
+      recvData_(1024),
+      sendData_(1024),
+      rawdataTransferPacketSize_(DEFAULT_CMD_MAX_DATA_SIZE),
+      structListDataTransferPacketSize_(DEFAULT_CMD_MAX_DATA_SIZE) {
+    auto port = std::dynamic_pointer_cast<IVendorDataPort>(backend_);
+    if(!port) {
+        throw invalid_value_exception("VendorPropertyAccessor backend must be IVendorDataPort");
+    }
+}
+
+void VendorPropertyAccessor::setRawdataTransferPacketSize(uint32_t size) {
+    rawdataTransferPacketSize_ = size;
+}
+
+void VendorPropertyAccessor::setStructListDataTransferPacketSize(uint32_t size) {
+    structListDataTransferPacketSize_ = size;
+}
+
+void VendorPropertyAccessor::setPropertyValue(uint32_t propertyId, const OBPropertyValue &value) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    clearBuffers();
+    auto req = protocol::initSetPropertyReq(sendData_.data(), propertyId, value.intValue);
+
+    auto     port         = std::dynamic_pointer_cast<IVendorDataPort>(backend_);
+    uint16_t respDataSize = 0;
+    auto     res = protocol::execute(port, sendData_.data(), sizeof(*req), recvData_.data(), &respDataSize);  // todo: check respDataSize, here and below
+    protocol::checkStatus(res);
+}
+
+void VendorPropertyAccessor::getPropertyValue(uint32_t propertyId, OBPropertyValue *value) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    clearBuffers();
+    auto req = protocol::initGetPropertyReq(sendData_.data(), propertyId);
+
+    uint16_t respDataSize = 0;
+    auto     port         = std::dynamic_pointer_cast<IVendorDataPort>(backend_);
+    auto     res          = protocol::execute(port, sendData_.data(), sizeof(*req), recvData_.data(), &respDataSize);
+
+    protocol::checkStatus(res);
+
+    auto resp       = protocol::parseGetPropertyResp(recvData_.data(), respDataSize);
+    value->intValue = resp->data.cur;
+}
+
+void VendorPropertyAccessor::getPropertyRange(uint32_t propertyId, OBPropertyRange *range) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    clearBuffers();
+    auto req = protocol::initGetPropertyReq(sendData_.data(), propertyId);
+
+    uint16_t respDataSize = 0;
+    auto     port         = std::dynamic_pointer_cast<IVendorDataPort>(backend_);
+    auto     res          = protocol::execute(port, sendData_.data(), sizeof(*req), recvData_.data(), &respDataSize);
+    protocol::checkStatus(res);
+
+    auto resp            = protocol::parseGetPropertyResp(recvData_.data(), respDataSize);
+    range->cur.intValue  = resp->data.cur;
+    range->max.intValue  = resp->data.max;
+    range->min.intValue  = resp->data.min;
+    range->step.intValue = resp->data.step;
+    range->def.intValue  = resp->data.def;
+}
+
+void VendorPropertyAccessor::setStructureData(uint32_t propertyId, const std::vector<uint8_t> &data) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    clearBuffers();
+    auto req = protocol::initSetStructureDataReq(sendData_.data(), propertyId, data.data(), static_cast<uint16_t>(data.size()));
+
+    uint16_t respDataSize = 0;
+    auto     port         = std::dynamic_pointer_cast<IVendorDataPort>(backend_);
+    uint16_t reqDataSize  = static_cast<uint16_t>(sizeof(*req) + data.size() - 1);
+    auto     res          = protocol::execute(port, sendData_.data(), reqDataSize, recvData_.data(), &respDataSize);
+    protocol::checkStatus(res);
+}
+
+const std::vector<uint8_t> &VendorPropertyAccessor::getStructureData(uint32_t propertyId) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    clearBuffers();
+    auto req = protocol::initGetStructureDataReq(sendData_.data(), propertyId);
+
+    uint16_t respDataSize = 0;
+    auto     port         = std::dynamic_pointer_cast<IVendorDataPort>(backend_);
+    auto     res          = protocol::execute(port, sendData_.data(), sizeof(*req), recvData_.data(), &respDataSize);
+    protocol::checkStatus(res);
+
+    auto resp              = protocol::parseGetStructureDataResp(recvData_.data(), respDataSize);
+    auto structureDataSize = protocol::getStructureDataSize(resp);
+    if(structureDataSize <= 0) {
+        res.statusCode    = protocol::HP_STATUS_DEVICE_RESPONSE_DATA_SIZE_ERROR;
+        res.respErrorCode = protocol::HP_RESP_ERROR_UNKNOWN;
+        res.msg           = "get structure data return data size invalid";
+        protocol::checkStatus(res);
+    }
+    outputData_.resize(structureDataSize);
+    memcpy(outputData_.data(), resp->data, structureDataSize);
+    return outputData_;
+}
+
+void VendorPropertyAccessor::getRawData(uint32_t propertyId, GetDataCallback callback) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    clearBuffers();
+    OBDataTranState tranState = DATA_TRAN_STAT_TRANSFERRING;
+    OBDataChunk     dataChunk = { sendData_.data(), 0, 0, 0 };
+    uint32_t        dataSize;
+
+    // init
+    {
+        clearBuffers();
+        auto     req          = protocol::initGetRawDataLengthReq(sendData_.data(), propertyId, 0);
+        uint16_t respDataSize = 64;
+        auto     port         = std::dynamic_pointer_cast<IVendorDataPort>(backend_);
+        auto     res          = protocol::execute(port, sendData_.data(), sizeof(*req), recvData_.data(), &respDataSize);
+        protocol::checkStatus(res);
+        auto resp = protocol::parseGetRawDataLengthResp(recvData_.data(), respDataSize);
+        dataSize  = resp->dataSize;
+    }
+
+    // get raw data in packet size
+    for(uint32_t packetOffset = 0; packetOffset < dataSize; packetOffset += rawdataTransferPacketSize_) {
+        uint32_t packetLen = std::min(rawdataTransferPacketSize_, dataSize - packetOffset);
+        clearBuffers();
+        auto     req          = protocol::initReadRawDataReq(sendData_.data(), propertyId, packetOffset, packetLen);
+        uint16_t respDataSize = 1024;
+        auto     port         = std::dynamic_pointer_cast<IVendorDataPort>(backend_);
+        auto     res          = protocol::execute(port, sendData_.data(), sizeof(*req), recvData_.data(), &respDataSize);
+        protocol::checkStatus(res);
+
+        if(callback) {
+            dataChunk.data         = recvData_.data() + sizeof(protocol::RespHeader);
+            dataChunk.size         = packetLen;
+            dataChunk.offset       = packetOffset;
+            dataChunk.fullDataSize = dataSize;
+            callback(tranState, &dataChunk);
+        }
+    }
+
+    // finish
+    {
+        clearBuffers();
+        auto     req          = protocol::initGetRawDataLengthReq(sendData_.data(), propertyId, 1);
+        uint16_t respDataSize = 64;
+        auto     port         = std::dynamic_pointer_cast<IVendorDataPort>(backend_);
+        auto     res          = protocol::execute(port, sendData_.data(), sizeof(*req), recvData_.data(), &respDataSize);
+        protocol::checkStatus(res);
+    }
+    dataChunk.data         = nullptr;
+    dataChunk.size         = 0;
+    dataChunk.offset       = dataSize;
+    dataChunk.fullDataSize = dataSize;
+    callback(DATA_TRAN_STAT_DONE, &dataChunk);
+}
+
+uint16_t VendorPropertyAccessor::getCmdVersionProtoV1_1(uint32_t propertyId) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    clearBuffers();
+    auto     req          = protocol::initGetCmdVersionReq(sendData_.data(), propertyId);
+    uint16_t respDataSize = 64;
+    auto     port         = std::dynamic_pointer_cast<IVendorDataPort>(backend_);
+    auto     res          = protocol::execute(port, sendData_.data(), sizeof(*req), recvData_.data(), &respDataSize);
+    protocol::checkStatus(res);
+
+    auto resp = protocol::parseGetCmdVerDataResp(recvData_.data(), respDataSize);
+    return *(uint16_t *)(resp->data);
+}
+
+const std::vector<uint8_t> &VendorPropertyAccessor::getStructureDataProtoV1_1(uint32_t propertyId, uint16_t cmdVersion) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    clearBuffers();
+
+    auto     req          = protocol::initGetStructureDataReqV1_1(sendData_.data(), propertyId);
+    uint16_t respDataSize = 0;
+    auto     port         = std::dynamic_pointer_cast<IVendorDataPort>(backend_);
+    auto     res          = protocol::execute(port, sendData_.data(), sizeof(*req), recvData_.data(), &respDataSize);
+    protocol::checkStatus(res);
+
+    auto resp = protocol::parseGetStructureDataRespV1_1(recvData_.data(), respDataSize);
+    if(resp->cmdVer != cmdVersion) {
+        res.statusCode    = protocol::HP_STATUS_DEVICE_RESPONSE_CMD_VERSION_UNMATCHED;
+        res.respErrorCode = protocol::HP_RESP_ERROR_UNKNOWN;
+        res.msg           = "get structure data return cmd version unmatched: " + std::to_string(resp->cmdVer) + ", expect: " + std::to_string(cmdVersion);
+        protocol::checkStatus(res);
+    }
+
+    int16_t dataSize = protocol::getStructureDataSizeV1_1(resp);
+    if(dataSize <= 0) {
+        res.statusCode    = protocol::HP_STATUS_DEVICE_RESPONSE_DATA_SIZE_ERROR;
+        res.respErrorCode = protocol::HP_RESP_ERROR_UNKNOWN;
+        res.msg           = "get structure data over protocol version 1.1 return data size invalid";
+        protocol::checkStatus(res);
+    }
+    outputData_.resize(dataSize);
+    memcpy(outputData_.data(), resp->data, dataSize);
+    return outputData_;
+}
+
+void VendorPropertyAccessor::setStructureDataProtoV1_1(uint32_t propertyId, const std::vector<uint8_t> &data, uint16_t cmdVersion) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    clearBuffers();
+    auto     req          = protocol::initSetStructureDataReqV1_1(sendData_.data(), propertyId, cmdVersion, data.data(), static_cast<uint16_t>(data.size()));
+    uint16_t respDataSize = 64;
+    auto     port         = std::dynamic_pointer_cast<IVendorDataPort>(backend_);
+    uint16_t reqDataSize  = static_cast<uint16_t>(sizeof(*req) + data.size() - 1);
+    auto     res          = protocol::execute(port, sendData_.data(), reqDataSize, recvData_.data(), &respDataSize);
+    protocol::checkStatus(res);
+}
+
+const std::vector<uint8_t> &VendorPropertyAccessor::getStructureDataListProtoV1_1(uint32_t propertyId, uint16_t cmdVersion) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    uint32_t                    dataSize = 0;
+    clearBuffers();
+    auto     req          = protocol::initStartGetStructureDataListReq(sendData_.data(), propertyId);
+    uint16_t respDataSize = 64;
+    auto     port         = std::dynamic_pointer_cast<IVendorDataPort>(backend_);
+    auto     res          = protocol::execute(port, sendData_.data(), sizeof(*req), recvData_.data(), &respDataSize);
+    protocol::checkStatus(res);
+
+    auto resp = protocol::parseStartStructureDataListResp(recvData_.data(), respDataSize);
+    if(resp->cmdVer != cmdVersion) {
+        res.statusCode    = protocol::HP_STATUS_DEVICE_RESPONSE_CMD_VERSION_UNMATCHED;
+        res.respErrorCode = protocol::HP_RESP_ERROR_UNKNOWN;
+        res.msg           = "init get structure data list return cmd version unmatched";
+        protocol::checkStatus(res);
+    }
+    dataSize = resp->dataSize;
+    outputData_.resize(dataSize);
+    {
+        for(uint32_t packetOffset = 0; packetOffset < dataSize; packetOffset += structListDataTransferPacketSize_) {
+            clearBuffers();  // reset request and response buffer cache
+            uint32_t packetSize = std::min(structListDataTransferPacketSize_, dataSize - packetOffset);
+
+            auto req1    = protocol::initGetStructureDataListReq(sendData_.data(), propertyId, packetOffset, packetSize);
+            respDataSize = 1024;
+            port         = std::dynamic_pointer_cast<IVendorDataPort>(backend_);
+            res          = protocol::execute(port, sendData_.data(), sizeof(*req1), recvData_.data(), &respDataSize);
+            protocol::checkStatus(res);
+            memcpy(outputData_.data() + packetOffset, recvData_.data() + sizeof(protocol::RespHeader), packetSize);
+        }
+    }
+
+    {
+        clearBuffers();
+        auto req2 = protocol::initFinishGetStructureDataListReq(sendData_.data(), propertyId);
+        res       = protocol::execute(port, sendData_.data(), sizeof(*req2), recvData_.data(), &respDataSize);
+        protocol::checkStatus(res);
+    }
+
+    protocol::checkStatus(res);
+    return outputData_;
+}
+
+void VendorPropertyAccessor::clearBuffers() {
+    memset(recvData_.data(), 0, recvData_.size());
+    memset(sendData_.data(), 0, sendData_.size());
+}
+
+IDevice *VendorPropertyAccessor::getOwner() const {
+    return owner_;
+}
+
+}  // namespace libobsensor
diff --git a/src/device/component/property/VendorPropertyAccessor.hpp b/src/device/component/property/VendorPropertyAccessor.hpp
new file mode 100644
index 00000000..e6e2075b
--- /dev/null
+++ b/src/device/component/property/VendorPropertyAccessor.hpp
@@ -0,0 +1,55 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include "IProperty.hpp"
+#include "ISourcePort.hpp"
+#include "IDevice.hpp"
+#include "IDeviceComponent.hpp"
+#include <mutex>
+
+namespace libobsensor {
+class VendorPropertyAccessor : public IDeviceComponent,
+                               public IBasicPropertyAccessor,
+                               public IStructureDataAccessor,
+                               public IStructureDataAccessorV1_1,
+                               public IRawDataAccessor {
+public:
+    explicit VendorPropertyAccessor(IDevice *owner, const std::shared_ptr<ISourcePort> &backend);
+    ~VendorPropertyAccessor() noexcept override = default;
+
+    IDevice *getOwner() const override;
+
+    void setPropertyValue(uint32_t propertyId, const OBPropertyValue &value) override;
+    void getPropertyValue(uint32_t propertyId, OBPropertyValue *value) override;
+    void getPropertyRange(uint32_t propertyId, OBPropertyRange *range) override;
+
+    void                        setStructureData(uint32_t propertyId, const std::vector<uint8_t> &data) override;
+    const std::vector<uint8_t> &getStructureData(uint32_t propertyId) override;
+
+    void getRawData(uint32_t propertyId, GetDataCallback callback) override;
+
+    uint16_t                    getCmdVersionProtoV1_1(uint32_t propertyId) override;
+    const std::vector<uint8_t> &getStructureDataProtoV1_1(uint32_t propertyId, uint16_t cmdVersion) override;
+    void                        setStructureDataProtoV1_1(uint32_t propertyId, const std::vector<uint8_t> &data, uint16_t cmdVersion) override;
+    const std::vector<uint8_t> &getStructureDataListProtoV1_1(uint32_t propertyId, uint16_t cmdVersion) override;
+
+    void setRawdataTransferPacketSize(uint32_t size);
+    void setStructListDataTransferPacketSize(uint32_t size);
+
+private:
+    void clearBuffers();
+
+private:
+    IDevice                          *owner_;
+    std::shared_ptr<ISourcePort>      backend_;
+    std::mutex                        mutex_;
+    std::vector<uint8_t>              recvData_;
+    std::vector<uint8_t>              sendData_;
+    std::vector<uint8_t>              outputData_;
+    std::vector<std::vector<uint8_t>> structureDataList_;  // for cmd version 1.1
+    uint32_t                          rawdataTransferPacketSize_;
+    uint32_t                          structListDataTransferPacketSize_;
+};
+}  // namespace libobsensor
+
diff --git a/src/device/component/sensor/CMakeLists.txt b/src/device/component/sensor/CMakeLists.txt
new file mode 100644
index 00000000..3cd63aa3
--- /dev/null
+++ b/src/device/component/sensor/CMakeLists.txt
@@ -0,0 +1,9 @@
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+#cmake_minimum_required(VERSION 3.5)
+
+target_sources(${OB_TARGET_DEVICE} PRIVATE ${CMAKE_CURRENT_LIST_DIR}/SensorBase.cpp ${CMAKE_CURRENT_LIST_DIR}/SensorBase.hpp)
+
+add_subdirectory(imu)
+add_subdirectory(video)
diff --git a/src/device/component/sensor/SensorBase.cpp b/src/device/component/sensor/SensorBase.cpp
new file mode 100644
index 00000000..b24763b8
--- /dev/null
+++ b/src/device/component/sensor/SensorBase.cpp
@@ -0,0 +1,266 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "SensorBase.hpp"
+#include "utils/PublicTypeHelper.hpp"
+#include "frame/Frame.hpp"
+#include "stream/StreamProfile.hpp"
+#include "logger/LoggerHelper.hpp"
+
+namespace libobsensor {
+SensorBase::SensorBase(IDevice *owner, OBSensorType sensorType, const std::shared_ptr<ISourcePort> &backend)
+    : owner_(owner),
+      sensorType_(sensorType),
+      backend_(backend),
+      streamState_(STREAM_STATE_STOPPED),
+      onRecovering_(false),
+      recoveryEnabled_(false),
+      maxRecoveryCount_(DefaultMaxRecoveryCount),
+      recoveryCount_(0),
+      noStreamTimeoutMs_(DefaultNoStreamTimeoutMs),
+      streamInterruptTimeoutMs_(DefaultStreamInterruptTimeoutMs) {}
+
+SensorBase::~SensorBase() noexcept {
+    if(streamStateWatcherThread_.joinable()) {
+        recoveryEnabled_ = false;
+        streamStateCv_.notify_all();
+        streamStateWatcherThread_.join();
+    }
+    LOG_INFO("SensorBase is destroyed");
+}
+
+OBSensorType SensorBase::getSensorType() const {
+    return sensorType_;
+}
+
+IDevice *SensorBase::getOwner() const {
+    return owner_;
+}
+
+std::shared_ptr<ISourcePort> SensorBase::getBackend() const {
+    return backend_;
+}
+
+OBStreamState SensorBase::getStreamState() const {
+    return streamState_.load();
+}
+
+bool SensorBase::isStreamActivated() const {
+    return streamState_ == STREAM_STATE_STARTING || streamState_ == STREAM_STATE_STREAMING || streamState_ == STREAM_STATE_ERROR
+           || streamState_ == STREAM_STATE_STOPPING;
+}
+
+uint32_t SensorBase::registerStreamStateChangedCallback(StreamStateChangedCallback callback) {
+    std::unique_lock<std::mutex> lock(streamStateCallbackMutex_);
+    uint32_t                     token  = StreamStateChangedCallbackTokenCounter_++;
+    streamStateChangedCallbacks_[token] = callback;
+    return token;
+}
+
+void SensorBase::unregisterStreamStateChangedCallback(uint32_t token) {
+    std::unique_lock<std::mutex> lock(streamStateCallbackMutex_);
+    streamStateChangedCallbacks_.erase(token);
+}
+
+StreamProfileList SensorBase::getStreamProfileList() const {
+    auto spList = streamProfileList_;
+    if(streamProfileFilter_) {
+        spList = streamProfileFilter_->filter(spList);
+    }
+    return spList;
+}
+
+void SensorBase::setStreamProfileFilter(std::shared_ptr<IStreamProfileFilter> filter) {
+    streamProfileFilter_ = filter;
+}
+
+void SensorBase::setStreamProfileList(const StreamProfileList &profileList) {
+    streamProfileList_ = profileList;
+}
+
+void SensorBase::updateDefaultStreamProfile(const std::shared_ptr<const StreamProfile> &profile) {
+    std::shared_ptr<const StreamProfile> defaultProfile;
+    auto                                 aa = profile->as<VideoStreamProfile>();
+    LOG_DEBUG("Set default stream profile to: {}", profile);
+    for(auto iter = streamProfileList_.begin(); iter != streamProfileList_.end(); ++iter) {
+        if((*iter)->is<VideoStreamProfile>() && profile->is<VideoStreamProfile>()) {
+            auto vsp    = (*iter)->as<VideoStreamProfile>();
+            auto vspCmp = profile->as<VideoStreamProfile>();
+            if(vsp->getFormat() == vspCmp->getFormat() && vsp->getWidth() == vspCmp->getWidth() && vsp->getHeight() == vspCmp->getHeight()
+               && vsp->getFps() == vspCmp->getFps()) {
+                defaultProfile = *iter;
+                streamProfileList_.erase(iter);
+                break;
+            }
+        }
+        else if((*iter)->is<AccelStreamProfile>() && profile->is<AccelStreamProfile>()) {
+            auto asp    = (*iter)->as<AccelStreamProfile>();
+            auto aspCmp = profile->as<AccelStreamProfile>();
+            if(asp->getFullScaleRange() == aspCmp->getFullScaleRange() && asp->getSampleRate() == aspCmp->getSampleRate()) {
+                defaultProfile = *iter;
+                streamProfileList_.erase(iter);
+                break;
+            }
+        }
+        else if((*iter)->is<GyroStreamProfile>() && profile->is<GyroStreamProfile>()) {
+            auto gsp    = (*iter)->as<GyroStreamProfile>();
+            auto gspCmp = profile->as<GyroStreamProfile>();
+            if(gsp->getFullScaleRange() == gspCmp->getFullScaleRange() && gsp->getSampleRate() == gspCmp->getSampleRate()) {
+                defaultProfile = *iter;
+                streamProfileList_.erase(iter);
+                break;
+            }
+        }
+    }
+
+    if(defaultProfile) {
+        // insert the default profile at the beginning of the list
+        streamProfileList_.insert(streamProfileList_.begin(), defaultProfile);
+    }
+    else {
+        LOG_WARN("Failed to update default stream profile for sensor due to no matching stream profile found");
+    }
+}
+
+std::shared_ptr<const StreamProfile> SensorBase::getActivatedStreamProfile() const {
+    return activatedStreamProfile_;
+}
+
+FrameCallback SensorBase::getFrameCallback() const {
+    return frameCallback_;
+}
+
+void SensorBase::restartStream() {
+    auto curSp    = activatedStreamProfile_;
+    auto callback = frameCallback_;
+    stop();
+    start(curSp, callback);
+}
+
+void SensorBase::updateStreamState(OBStreamState state) {
+    std::unique_lock<std::mutex> lock(streamStateMutex_);
+    if(onRecovering_) {
+        return;
+    }
+    auto oldState = streamState_.load();
+    streamState_.store(state);
+    if(oldState != state && !streamStateChangedCallbacks_.empty()) {
+        for(auto &callback: streamStateChangedCallbacks_) {
+            callback.second(state, activatedStreamProfile_);  // call the callback function
+        }
+        if(state == STREAM_STATE_STARTING) {
+            if(frameTimestampCalculator_) {
+                frameTimestampCalculator_->clear();
+            }
+            if(globalTimestampCalculator_) {
+                globalTimestampCalculator_->clear();
+            }
+        }
+    }
+    if(oldState != state) {
+        LOG_DEBUG("Stream state changed to {}@{}", STREAM_STATE_STR(state), sensorType_);
+    }
+    streamStateCv_.notify_all();
+}
+
+void SensorBase::enableStreamRecovery(uint32_t maxRecoveryCount, int noStreamTimeoutMs, int streamInterruptTimeoutMs) {
+    {
+        std::unique_lock<std::mutex> lock(streamStateMutex_);
+        recoveryCount_            = 0;
+        recoveryEnabled_          = true;
+        maxRecoveryCount_         = maxRecoveryCount == 0 ? maxRecoveryCount_ : maxRecoveryCount;
+        noStreamTimeoutMs_        = noStreamTimeoutMs == 0 ? noStreamTimeoutMs_ : noStreamTimeoutMs;
+        streamInterruptTimeoutMs_ = streamInterruptTimeoutMs == 0 ? streamInterruptTimeoutMs_ : streamInterruptTimeoutMs;
+    }
+    if(streamStateWatcherThread_.joinable()) {
+        return;
+    }
+    streamStateWatcherThread_ = std::thread([this]() { watchStreamState(); });
+}
+
+void SensorBase::disableStreamRecovery() {
+    recoveryEnabled_ = false;
+    streamStateCv_.notify_all();
+    if(streamStateWatcherThread_.joinable()) {
+        streamStateWatcherThread_.join();
+    }
+}
+
+void SensorBase::watchStreamState() {
+    recoveryCount_ = 0;
+    while(recoveryEnabled_) {
+        if(streamState_ == STREAM_STATE_STOPPED || streamState_ == STREAM_STATE_STOPPING || streamState_ == STREAM_STATE_ERROR) {
+            std::unique_lock<std::mutex> lock(streamStateMutex_);
+            streamStateCv_.wait(lock);
+            recoveryCount_ = 0;
+        }
+        else if(streamState_ == STREAM_STATE_STARTING && noStreamTimeoutMs_ > 0) {
+            {
+                std::unique_lock<std::mutex> lock(streamStateMutex_);
+                streamStateCv_.wait_for(lock, std::chrono::milliseconds(noStreamTimeoutMs_));
+                if(streamState_ != STREAM_STATE_STARTING || recoveryEnabled_ == false) {
+                    recoveryCount_ = 0;
+                    continue;
+                }
+            }
+            if(recoveryCount_ < maxRecoveryCount_) {
+                onRecovering_ = true;
+                TRY_EXECUTE(restartStream());
+                recoveryCount_++;
+                onRecovering_ = false;
+                continue;
+            }
+            updateStreamState(STREAM_STATE_ERROR);
+            LOG_ERROR("Failed to start stream for sensor after {} retries", maxRecoveryCount_);
+        }
+        else if(streamState_ == STREAM_STATE_STREAMING && streamInterruptTimeoutMs_ > 0) {
+            {
+                std::unique_lock<std::mutex> lock(streamStateMutex_);
+                auto                         sts = streamStateCv_.wait_for(lock, std::chrono::milliseconds(streamInterruptTimeoutMs_));
+                if(sts != std::cv_status::timeout || streamState_ != STREAM_STATE_STREAMING || recoveryEnabled_ == false) {
+                    recoveryCount_ = 0;
+                    continue;
+                }
+            }
+            if(recoveryCount_ < maxRecoveryCount_) {
+                onRecovering_ = true;
+                TRY_EXECUTE(restartStream());
+                recoveryCount_++;
+                onRecovering_ = false;
+                continue;
+            }
+            updateStreamState(STREAM_STATE_ERROR);
+            LOG_ERROR("Failed to recover stream for sensor after {} retries", maxRecoveryCount_);
+        }
+    }
+}
+
+void SensorBase::setFrameMetadataParserContainer(std::shared_ptr<IFrameMetadataParserContainer> container) {
+    frameMetadataParserContainer_ = container;
+}
+
+void SensorBase::setFrameTimestampCalculator(std::shared_ptr<IFrameTimestampCalculator> calculator) {
+    frameTimestampCalculator_ = calculator;
+}
+
+void SensorBase::setGlobalTimestampCalculator(std::shared_ptr<IFrameTimestampCalculator> calculator) {
+    globalTimestampCalculator_ = calculator;
+}
+
+void SensorBase::outputFrame(std::shared_ptr<Frame> frame) {
+    if(frameMetadataParserContainer_) {
+        TRY_EXECUTE(frame->registerMetadataParsers(frameMetadataParserContainer_));
+    }
+
+    if(frameTimestampCalculator_) {
+        TRY_EXECUTE(frameTimestampCalculator_->calculate(frame));
+    }
+    if(globalTimestampCalculator_) {
+        TRY_EXECUTE(globalTimestampCalculator_->calculate(frame));
+    }
+
+    frameCallback_(frame);
+    LOG_FREQ_CALC(INFO, 5000, "{} Streaming... frameRate={freq}fps", utils::obSensorToStr(sensorType_));
+}
+
+}  // namespace libobsensor
diff --git a/src/device/component/sensor/SensorBase.hpp b/src/device/component/sensor/SensorBase.hpp
new file mode 100644
index 00000000..53b9cd70
--- /dev/null
+++ b/src/device/component/sensor/SensorBase.hpp
@@ -0,0 +1,92 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include "ISensor.hpp"
+#include "ISourcePort.hpp"
+
+#include <map>
+#include <mutex>
+#include <thread>
+#include <condition_variable>
+
+namespace libobsensor {
+
+class SensorBase : public ISensor, public std::enable_shared_from_this<SensorBase> {
+    static constexpr int DefaultNoStreamTimeoutMs        = 3000;
+    static constexpr int DefaultStreamInterruptTimeoutMs = 3000;
+    static constexpr int DefaultMaxRecoveryCount         = 3;
+
+public:
+    SensorBase(IDevice *owner, OBSensorType sensorType, const std::shared_ptr<ISourcePort> &backend);
+    ~SensorBase() noexcept override;
+
+    OBSensorType                 getSensorType() const override;
+    IDevice                     *getOwner() const override;
+    std::shared_ptr<ISourcePort> getBackend() const;
+
+    OBStreamState getStreamState() const override;
+    bool          isStreamActivated() const override;
+    uint32_t      registerStreamStateChangedCallback(StreamStateChangedCallback callback) override;
+    void          unregisterStreamStateChangedCallback(uint32_t token) override;
+
+    StreamProfileList                    getStreamProfileList() const override;
+    void                                 setStreamProfileFilter(std::shared_ptr<IStreamProfileFilter> filter) override;
+    void                                 setStreamProfileList(const StreamProfileList &profileList) override;
+    void                                 updateDefaultStreamProfile(const std::shared_ptr<const StreamProfile> &profile) override;
+    std::shared_ptr<const StreamProfile> getActivatedStreamProfile() const override;
+
+    FrameCallback getFrameCallback() const override;
+
+    // when start Stream fails or interrupts, try to recover by restarting the stream; If Timeout<0, never timeout. if Timeout=0, use default timeout.
+    void enableStreamRecovery(uint32_t maxRecoveryCount = DefaultMaxRecoveryCount, int noStreamTimeoutMs = DefaultNoStreamTimeoutMs,
+                              int streamInterruptTimeoutMs = DefaultStreamInterruptTimeoutMs);
+    // stop trying to recover the stream
+    void disableStreamRecovery();
+
+    void setFrameMetadataParserContainer(std::shared_ptr<IFrameMetadataParserContainer> container);
+    void setFrameTimestampCalculator(std::shared_ptr<IFrameTimestampCalculator> calculator);
+    void setGlobalTimestampCalculator(std::shared_ptr<IFrameTimestampCalculator> calculator);
+
+protected:
+    virtual void restartStream();
+    virtual void updateStreamState(OBStreamState state);
+    virtual void watchStreamState();
+
+    virtual void outputFrame(std::shared_ptr<Frame> frame);
+
+protected:
+    IDevice                     *owner_;
+    const OBSensorType           sensorType_;
+    std::shared_ptr<ISourcePort> backend_;
+
+    StreamProfileList streamProfileList_;
+    std::shared_ptr<IStreamProfileFilter> streamProfileFilter_;
+
+    std::shared_ptr<const StreamProfile> activatedStreamProfile_;
+    FrameCallback                        frameCallback_;
+
+    std::mutex                                     streamStateCallbackMutex_;
+    std::map<uint32_t, StreamStateChangedCallback> streamStateChangedCallbacks_;
+    uint32_t                                       StreamStateChangedCallbackTokenCounter_ = 0;
+
+    std::mutex                 streamStateMutex_;
+    std::condition_variable    streamStateCv_;
+    std::atomic<OBStreamState> streamState_;
+    std::thread                streamStateWatcherThread_;
+
+    bool     onRecovering_;
+    bool     recoveryEnabled_;
+    uint32_t maxRecoveryCount_;
+    uint32_t recoveryCount_;
+    uint32_t noStreamTimeoutMs_;
+    uint32_t streamInterruptTimeoutMs_;
+
+    std::shared_ptr<IFrameMetadataParserContainer> frameMetadataParserContainer_;
+    std::shared_ptr<IFrameTimestampCalculator>     frameTimestampCalculator_;
+    std::shared_ptr<IFrameTimestampCalculator>     globalTimestampCalculator_;
+};
+
+}  // namespace libobsensor
+
diff --git a/src/device/component/sensor/imu/AccelSensor.cpp b/src/device/component/sensor/imu/AccelSensor.cpp
new file mode 100644
index 00000000..af39238c
--- /dev/null
+++ b/src/device/component/sensor/imu/AccelSensor.cpp
@@ -0,0 +1,89 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "AccelSensor.hpp"
+#include "IDevice.hpp"
+#include "property/InternalProperty.hpp"
+#include "stream/StreamProfileFactory.hpp"
+
+namespace libobsensor {
+
+#pragma pack(1)
+typedef struct {
+    uint32_t          num;
+    OBAccelSampleRate odr[16];
+} AccelSampleRateList;
+
+typedef struct {
+    uint32_t              num;
+    OBAccelFullScaleRange fs[16];
+} AccelFullScaleRangeList;
+#pragma pack()
+
+AccelSensor::AccelSensor(IDevice *owner, const std::shared_ptr<ISourcePort> &backend, const std::shared_ptr<ImuStreamer> &streamer)
+    : SensorBase(owner, OB_SENSOR_ACCEL, backend), streamer_(streamer) {
+    auto propServer = owner->getPropertyServer();
+
+    auto accelSampleRateList     = propServer->getStructureDataT<AccelSampleRateList>(OB_STRUCT_GET_ACCEL_PRESETS_ODR_LIST);
+    auto accelFullScaleRangeList = propServer->getStructureDataT<AccelFullScaleRangeList>(OB_STRUCT_GET_ACCEL_PRESETS_FULL_SCALE_LIST);
+
+    auto lazySensor = std::make_shared<LazySensor>(owner, OB_SENSOR_ACCEL);
+    for(uint32_t i = 0; i < accelSampleRateList.num; i++) {
+        for(uint32_t j = 0; j < accelFullScaleRangeList.num; j++) {
+            auto accel_odr = accelSampleRateList.odr[i];
+            auto accel_fs  = accelFullScaleRangeList.fs[j];
+            if(accel_odr == 0 || accel_fs == 0) {
+                continue;
+            }
+
+            auto profile = StreamProfileFactory::createAccelStreamProfile(lazySensor, accel_fs, accel_odr);
+            streamProfileList_.emplace_back(profile);
+        }
+    }
+    LOG_DEBUG("AccelSensor is created!");
+}
+
+AccelSensor::~AccelSensor() noexcept {
+    if(isStreamActivated()) {
+        TRY_EXECUTE(stop());
+    }
+    LOG_DEBUG("AccelSensor is destroyed");
+}
+
+void AccelSensor::start(std::shared_ptr<const StreamProfile> sp, FrameCallback callback) {
+    activatedStreamProfile_ = sp;
+    frameCallback_          = callback;
+    updateStreamState(STREAM_STATE_STARTING);
+
+    auto owner      = getOwner();
+    auto propServer = owner->getPropertyServer();
+
+    auto accelSp = sp->as<AccelStreamProfile>();
+    propServer->setPropertyValueT(OB_PROP_ACCEL_ODR_INT, static_cast<int>(accelSp->getSampleRate()));
+    propServer->setPropertyValueT(OB_PROP_ACCEL_FULL_SCALE_INT, static_cast<int>(accelSp->getFullScaleRange()));
+    propServer->setPropertyValueT(OB_PROP_ACCEL_SWITCH_BOOL, true);
+
+    BEGIN_TRY_EXECUTE({
+        streamer_->start(sp, [this](std::shared_ptr<Frame> frame) {
+            updateStreamState(STREAM_STATE_STREAMING);
+            outputFrame(frame);
+        });
+    })
+    CATCH_EXCEPTION_AND_EXECUTE({
+        activatedStreamProfile_.reset();
+        frameCallback_ = nullptr;
+        updateStreamState(STREAM_STATE_START_FAILED);
+        throw;
+    })
+}
+
+void AccelSensor::stop() {
+    updateStreamState(STREAM_STATE_STOPPING);
+    streamer_->stop(activatedStreamProfile_);
+    auto owner      = getOwner();
+    auto propServer = owner->getPropertyServer();
+    propServer->setPropertyValueT(OB_PROP_ACCEL_SWITCH_BOOL, false);
+    updateStreamState(STREAM_STATE_STOPPED);
+}
+
+}  // namespace libobsensor
diff --git a/src/device/component/sensor/imu/AccelSensor.hpp b/src/device/component/sensor/imu/AccelSensor.hpp
new file mode 100644
index 00000000..2d788884
--- /dev/null
+++ b/src/device/component/sensor/imu/AccelSensor.hpp
@@ -0,0 +1,21 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include "sensor/SensorBase.hpp"
+#include "ImuStreamer.hpp"
+
+namespace libobsensor {
+class AccelSensor : public SensorBase {
+public:
+    AccelSensor(IDevice *owner, const std::shared_ptr<ISourcePort> &backend, const std::shared_ptr<ImuStreamer> &streamer);
+    ~AccelSensor() noexcept override;
+
+    void start(std::shared_ptr<const StreamProfile> sp, FrameCallback callback) override;
+    void stop() override;
+
+private:
+    std::shared_ptr<ImuStreamer> streamer_;
+};
+}  // namespace libobsensor
diff --git a/src/device/component/sensor/imu/CMakeLists.txt b/src/device/component/sensor/imu/CMakeLists.txt
new file mode 100644
index 00000000..e6c35f2f
--- /dev/null
+++ b/src/device/component/sensor/imu/CMakeLists.txt
@@ -0,0 +1,15 @@
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+cmake_minimum_required(VERSION 3.5)
+
+file (GLOB _cpp_files "${CMAKE_CURRENT_LIST_DIR}/*.cpp")
+file (GLOB _head_files "${CMAKE_CURRENT_LIST_DIR}/*.hpp")
+
+foreach(_file IN ITEMS ${_cpp_files})
+        target_sources(${OB_TARGET_DEVICE} PRIVATE "${_file}")
+endforeach()
+
+foreach(_file IN ITEMS ${_head_files})
+        target_sources(${OB_TARGET_DEVICE} PRIVATE "${_file}")
+endforeach()
diff --git a/src/device/component/sensor/imu/GyroSensor.cpp b/src/device/component/sensor/imu/GyroSensor.cpp
new file mode 100644
index 00000000..c8a69bc4
--- /dev/null
+++ b/src/device/component/sensor/imu/GyroSensor.cpp
@@ -0,0 +1,89 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "GyroSensor.hpp"
+#include "IDevice.hpp"
+#include "property/InternalProperty.hpp"
+#include "stream/StreamProfileFactory.hpp"
+
+namespace libobsensor {
+
+#pragma pack(1)
+typedef struct {
+    uint32_t         num;
+    OBGyroSampleRate odr[16];
+} GyroSampleRateList;
+
+typedef struct {
+    uint32_t             num;
+    OBGyroFullScaleRange fs[16];
+} GyroFullScaleRangeList;
+#pragma pack()
+
+GyroSensor::GyroSensor(IDevice *owner, const std::shared_ptr<ISourcePort> &backend, const std::shared_ptr<ImuStreamer> &streamer)
+    : SensorBase(owner, OB_SENSOR_GYRO, backend), streamer_(streamer) {
+    auto propServer = owner->getPropertyServer();
+
+    auto gyroSampleRateList     = propServer->getStructureDataT<GyroSampleRateList>(OB_STRUCT_GET_GYRO_PRESETS_ODR_LIST);
+    auto gyroFullScaleRangeList = propServer->getStructureDataT<GyroFullScaleRangeList>(OB_STRUCT_GET_GYRO_PRESETS_FULL_SCALE_LIST);
+
+    auto lazySensor = std::make_shared<LazySensor>(owner, OB_SENSOR_GYRO);
+    for(uint32_t i = 0; i < gyroSampleRateList.num; i++) {
+        for(uint32_t j = 0; j < gyroFullScaleRangeList.num; j++) {
+            auto gyro_odr = gyroSampleRateList.odr[i];
+            auto gyro_fs  = gyroFullScaleRangeList.fs[j];
+            if(gyro_odr == 0 || gyro_fs == 0) {
+                continue;
+            }
+
+            auto profile = StreamProfileFactory::createGyroStreamProfile(lazySensor, gyro_fs, gyro_odr);
+            streamProfileList_.emplace_back(profile);
+        }
+    }
+    LOG_DEBUG("GyroSensor is created!");
+}
+
+GyroSensor::~GyroSensor() noexcept {
+    if(isStreamActivated()) {
+        TRY_EXECUTE(stop());
+    }
+    LOG_DEBUG("GyroSensor is destroyed");
+}
+
+void GyroSensor::start(std::shared_ptr<const StreamProfile> sp, FrameCallback callback) {
+    activatedStreamProfile_ = sp;
+    frameCallback_          = callback;
+    updateStreamState(STREAM_STATE_STARTING);
+
+    auto owner      = getOwner();
+    auto propServer = owner->getPropertyServer();
+
+    auto gyroSp = sp->as<GyroStreamProfile>();
+    propServer->setPropertyValueT(OB_PROP_GYRO_ODR_INT, static_cast<int>(gyroSp->getSampleRate()));
+    propServer->setPropertyValueT(OB_PROP_GYRO_FULL_SCALE_INT, static_cast<int>(gyroSp->getFullScaleRange()));
+    propServer->setPropertyValueT(OB_PROP_GYRO_SWITCH_BOOL, true);
+
+    BEGIN_TRY_EXECUTE({
+        streamer_->start(sp, [this](std::shared_ptr<Frame> frame) {
+            updateStreamState(STREAM_STATE_STREAMING);
+            outputFrame(frame);
+        });
+    })
+    CATCH_EXCEPTION_AND_EXECUTE({
+        activatedStreamProfile_.reset();
+        frameCallback_ = nullptr;
+        updateStreamState(STREAM_STATE_START_FAILED);
+        throw;
+    })
+}
+
+void GyroSensor::stop() {
+    updateStreamState(STREAM_STATE_STOPPING);
+    streamer_->stop(activatedStreamProfile_);
+    auto owner      = getOwner();
+    auto propServer = owner->getPropertyServer();
+    propServer->setPropertyValueT(OB_PROP_GYRO_SWITCH_BOOL, false);
+    updateStreamState(STREAM_STATE_STOPPED);
+}
+
+}  // namespace libobsensor
diff --git a/src/device/component/sensor/imu/GyroSensor.hpp b/src/device/component/sensor/imu/GyroSensor.hpp
new file mode 100644
index 00000000..e92a8f58
--- /dev/null
+++ b/src/device/component/sensor/imu/GyroSensor.hpp
@@ -0,0 +1,21 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include "sensor/SensorBase.hpp"
+#include "ImuStreamer.hpp"
+
+namespace libobsensor {
+class GyroSensor : public SensorBase {
+public:
+    GyroSensor(IDevice *owner, const std::shared_ptr<ISourcePort> &backend, const std::shared_ptr<ImuStreamer> &streamer);
+    ~GyroSensor() noexcept override;
+
+    void start(std::shared_ptr<const StreamProfile> sp, FrameCallback callback) override;
+    void stop() override;
+
+private:
+    std::shared_ptr<ImuStreamer> streamer_;
+};
+}  // namespace libobsensor
diff --git a/src/device/component/sensor/imu/ImuStreamer.cpp b/src/device/component/sensor/imu/ImuStreamer.cpp
new file mode 100644
index 00000000..dbcb855a
--- /dev/null
+++ b/src/device/component/sensor/imu/ImuStreamer.cpp
@@ -0,0 +1,205 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "ImuStreamer.hpp"
+
+#include "frame/Frame.hpp"
+#include "frame/FrameFactory.hpp"
+#include "stream/StreamProfile.hpp"
+#include "logger/LoggerInterval.hpp"
+#include "utils/Utils.hpp"
+#include "publicfilters/IMUCorrector.hpp"
+
+namespace libobsensor {
+
+const size_t IMU_FILTER_FRAME_QUEUE_SIZE = 100;
+
+ImuStreamer::ImuStreamer(IDevice *owner, const std::shared_ptr<IDataStreamPort> &backend, const std::shared_ptr<IFilter> &filter)
+    : ImuStreamer(owner, backend, std::vector<std::shared_ptr<IFilter>>({ filter })) {}
+
+ImuStreamer::ImuStreamer(IDevice *owner, const std::shared_ptr<IDataStreamPort> &backend, std::vector<std::shared_ptr<IFilter>> filters)
+    : owner_(owner), backend_(backend), filters_(std::move(filters)), running_(false) {
+    auto iter = filters_.begin();
+    while(iter != filters_.end()) {
+        (*iter)->resizeFrameQueue(IMU_FILTER_FRAME_QUEUE_SIZE);
+        auto nextIter = iter + 1;
+        if(nextIter == filters_.end()) {
+            (*iter)->setCallback([this](std::shared_ptr<Frame> frame) { outputFrame(frame); });
+        }
+        else {
+            (*iter)->setCallback([nextIter](std::shared_ptr<Frame> frame) { (*nextIter)->pushFrame(frame); });
+        }
+
+        iter++;
+    }
+
+    LOG_DEBUG("ImuStreamer created");
+}
+
+ImuStreamer::~ImuStreamer() noexcept {
+    {
+        std::lock_guard<std::mutex> lock(cbMtx_);
+        callbacks_.clear();
+    }
+
+    if(running_) {
+        backend_->stopStream();
+        for(auto &filter: filters_) {
+            filter->reset();
+        }
+        running_ = false;
+    }
+}
+
+void ImuStreamer::start(std::shared_ptr<const StreamProfile> sp, MutableFrameCallback callback) {
+    {
+        std::lock_guard<std::mutex> lock(cbMtx_);
+        callbacks_[sp] = callback;
+        if(running_) {
+            return;
+        }
+    }
+    running_ = true;
+
+    backend_->startStream([this](std::shared_ptr<Frame> frame) { ImuStreamer::parseIMUData(frame); });
+}
+
+void ImuStreamer::stop(std::shared_ptr<const StreamProfile> sp) {
+    LOG_DEBUG("ImuStreamer stop....");
+    {
+        std::lock_guard<std::mutex> lock(cbMtx_);
+        auto                        iter = callbacks_.find(sp);
+        if(iter == callbacks_.end()) {
+            throw invalid_value_exception("Stop stream failed, stream profile not found.");
+        }
+
+        callbacks_.erase(iter);
+        if(!callbacks_.empty()) {
+            return;
+        }
+    }
+    LOG_DEBUG("ImuStreamer stop backend....");
+    backend_->stopStream();
+
+    LOG_DEBUG("ImuStreamer reset filters....");
+    for(auto &filter: filters_) {
+        filter->reset();
+    }
+    running_ = false;
+    LOG_DEBUG("ImuStreamer stop finished.");
+}
+
+void ImuStreamer::parseIMUData(std::shared_ptr<Frame> frame) {
+    auto         data     = frame->getData();
+    OBImuHeader *header   = (OBImuHeader *)data;
+    auto         dataSize = frame->getDataSize();
+
+    if(header->reportId != 1) {
+        LOG_WARN_INTVL("Imu header is invalid,drop imu package!");
+        return;
+    }
+
+    const auto computeDataSize = sizeof(OBImuHeader) + sizeof(OBImuOriginData) * header->groupCount;
+    if(dataSize < computeDataSize) {
+        LOG_WARN_INTVL("Imu header is invalid, drop imu package!, invalid data size. dataSize={}, computeDataSize={}, groupCount={}", dataSize, computeDataSize,
+                       header->groupCount);
+        return;
+    }
+
+    const auto computeDataSizeP = sizeof(OBImuHeader) + header->groupLen * header->groupCount;
+    if(dataSize < computeDataSizeP) {
+        LOG_WARN_INTVL("Imu header is invalid, drop imu package!, invalid data size. dataSize={}, computeDataSizeP={}, groupCount={}", dataSize,
+                       computeDataSizeP, header->groupCount);
+        return;
+    }
+
+    std::shared_ptr<const AccelStreamProfile> accelStreamProfile;
+    std::shared_ptr<const GyroStreamProfile>  gyroStreamProfile;
+    {
+        std::lock_guard<std::mutex> lock(cbMtx_);
+        for(const auto &iter: callbacks_) {
+            if(iter.first->is<libobsensor::AccelStreamProfile>()) {
+                accelStreamProfile = iter.first->as<libobsensor::AccelStreamProfile>();
+            }
+            else if(iter.first->is<libobsensor::GyroStreamProfile>()) {
+                gyroStreamProfile = iter.first->as<libobsensor::GyroStreamProfile>();
+            }
+        }
+    }
+
+    uint8_t *imuOrgData = (uint8_t *)data + sizeof(OBImuHeader);
+    for(int groupIndex = 0; groupIndex < header->groupCount; groupIndex++) {
+        auto frameSet = FrameFactory::createFrameSet();
+
+        OBImuOriginData *imuData    = (OBImuOriginData *)((uint8_t *)imuOrgData + groupIndex * sizeof(OBImuOriginData));
+        uint64_t         timestamp  = ((uint64_t)imuData->timestamp[0] | ((uint64_t)imuData->timestamp[1] << 32));
+        auto             sysTspUs   = frame->getSystemTimeStampUsec();
+        auto             frameIndex = frameIndex_++;
+
+        if(accelStreamProfile) {
+            auto accelFrame     = FrameFactory::createFrameFromStreamProfile(accelStreamProfile);
+            auto accelFrameData = (AccelFrame::Data *)accelFrame->getData();
+            auto fs             = static_cast<uint8_t>(accelStreamProfile->getFullScaleRange());
+
+            accelFrameData->value.x = IMUCorrector::calculateAccelGravity(static_cast<int16_t>(imuData->accelX), fs);
+            accelFrameData->value.y = IMUCorrector::calculateAccelGravity(static_cast<int16_t>(imuData->accelY), fs);
+            accelFrameData->value.z = IMUCorrector::calculateAccelGravity(static_cast<int16_t>(imuData->accelZ), fs);
+            accelFrameData->temp    = IMUCorrector::calculateRegisterTemperature(imuData->temperature);
+
+            accelFrame->setNumber(frameIndex);
+            accelFrame->setTimeStampUsec(timestamp);
+            accelFrame->setSystemTimeStampUsec(sysTspUs);
+            frameSet->pushFrame(accelFrame);
+        }
+
+        if(gyroStreamProfile) {
+            auto gyroFrame         = FrameFactory::createFrameFromStreamProfile(gyroStreamProfile);
+            auto gyroFrameData     = (GyroFrame::Data *)gyroFrame->getData();
+            auto fs                = static_cast<uint8_t>(gyroStreamProfile->getFullScaleRange());
+            gyroFrameData->value.x = IMUCorrector::calculateGyroDPS(static_cast<int16_t>(imuData->gyroX), fs);
+            gyroFrameData->value.y = IMUCorrector::calculateGyroDPS(static_cast<int16_t>(imuData->gyroY), fs);
+            gyroFrameData->value.z = IMUCorrector::calculateGyroDPS(static_cast<int16_t>(imuData->gyroZ), fs);
+            gyroFrameData->temp    = IMUCorrector::calculateRegisterTemperature(imuData->temperature);
+
+            gyroFrame->setNumber(frameIndex);
+            gyroFrame->setTimeStampUsec(timestamp);
+            gyroFrame->setSystemTimeStampUsec(sysTspUs);
+            frameSet->pushFrame(gyroFrame);
+        }
+        if(!filters_.empty()) {
+            filters_.front()->pushFrame(frameSet);
+        }
+        else {
+            outputFrame(frameSet);
+        }
+    }
+}
+
+void ImuStreamer::outputFrame(std::shared_ptr<Frame> frame) {
+    if(!frame) {
+        return;
+    }
+
+    std::lock_guard<std::mutex> lock(cbMtx_);
+    for(auto &callback: callbacks_) {
+        std::shared_ptr<Frame> callbackFrame = frame;
+        if(frame->is<FrameSet>()) {
+            auto frameSet  = frame->as<FrameSet>();
+            auto frameType = utils::mapStreamTypeToFrameType(callback.first->getType());
+            callbackFrame  = frameSet->getFrameMutable(frameType);
+            if(!callbackFrame) {
+                continue;
+            }
+        }
+        if(callbackFrame->getFormat() != callback.first->getFormat()) {
+            continue;
+        }
+        callback.second(callbackFrame);
+    }
+}
+
+IDevice *ImuStreamer::getOwner() const {
+    return owner_;
+}
+
+}  // namespace libobsensor
\ No newline at end of file
diff --git a/src/device/component/sensor/imu/ImuStreamer.hpp b/src/device/component/sensor/imu/ImuStreamer.hpp
new file mode 100644
index 00000000..14fa5756
--- /dev/null
+++ b/src/device/component/sensor/imu/ImuStreamer.hpp
@@ -0,0 +1,64 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include "IFilter.hpp"
+#include "ISourcePort.hpp"
+#include "IDeviceComponent.hpp"
+
+#include <atomic>
+#include <map>
+#include <mutex>
+
+namespace libobsensor {
+
+// Original imu data, software packaging method, needs to be calculated on the sdk side
+typedef struct {
+    uint8_t  reportId;    // Firmware fixed transmission 1
+    uint8_t  sampleRate;  // OB_SAMPLE_RATE
+    uint8_t  groupLen;    // sizeof(OBImuOriginData)
+    uint8_t  groupCount;  // How many frames of data are in a packet.
+    uint32_t reserved;    // reserve
+} OBImuHeader;
+
+typedef struct {
+    int16_t  groupId;  // The number of groups in a pack
+    int16_t  accelX;
+    int16_t  accelY;
+    int16_t  accelZ;
+    int16_t  gyroX;
+    int16_t  gyroY;
+    int16_t  gyroZ;
+    int16_t  temperature;
+    uint32_t timestamp[2];
+} OBImuOriginData;
+
+class ImuStreamer : public IDeviceComponent {
+public:
+    ImuStreamer(IDevice *owner, const std::shared_ptr<IDataStreamPort> &backend, const std::shared_ptr<IFilter> &filter);
+    ImuStreamer(IDevice *owner, const std::shared_ptr<IDataStreamPort> &backend, std::vector<std::shared_ptr<IFilter>> filters);
+    virtual ~ImuStreamer() noexcept;
+
+    void start(std::shared_ptr<const StreamProfile> sp, MutableFrameCallback callback);
+    void stop(std::shared_ptr<const StreamProfile> sp);
+
+    IDevice *getOwner() const override;
+
+private:
+    virtual void parseIMUData(std::shared_ptr<Frame> frame);
+    virtual void outputFrame(std::shared_ptr<Frame> frame);
+
+private:
+    IDevice                         *owner_;
+    std::shared_ptr<IDataStreamPort> backend_;
+    std::vector<std::shared_ptr<IFilter>> filters_;
+
+    std::mutex                                                          cbMtx_;
+    std::map<std::shared_ptr<const StreamProfile>, MutableFrameCallback> callbacks_;
+
+    std::atomic_bool running_;
+
+    uint64_t frameIndex_;
+};
+}  // namespace libobsensor
diff --git a/src/device/component/sensor/video/CMakeLists.txt b/src/device/component/sensor/video/CMakeLists.txt
new file mode 100644
index 00000000..dc1979c4
--- /dev/null
+++ b/src/device/component/sensor/video/CMakeLists.txt
@@ -0,0 +1,7 @@
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+cmake_minimum_required(VERSION 3.5)
+
+target_sources(${OB_TARGET_DEVICE} PRIVATE ${CMAKE_CURRENT_LIST_DIR}/VideoSensor.cpp ${CMAKE_CURRENT_LIST_DIR}/VideoSensor.hpp)
+
diff --git a/src/device/component/sensor/video/DisparityBasedSensor.cpp b/src/device/component/sensor/video/DisparityBasedSensor.cpp
new file mode 100644
index 00000000..79c62980
--- /dev/null
+++ b/src/device/component/sensor/video/DisparityBasedSensor.cpp
@@ -0,0 +1,53 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "DisparityBasedSensor.hpp"
+#include "stream/StreamProfileFactory.hpp"
+#include "frame/Frame.hpp"
+#include "IProperty.hpp"
+
+namespace libobsensor {
+DisparityBasedSensor::DisparityBasedSensor(IDevice *owner, OBSensorType sensorType, const std::shared_ptr<ISourcePort> &backend)
+    : VideoSensor(owner, sensorType, backend) {
+    convertProfileAsDisparityBasedProfile();
+}
+
+void DisparityBasedSensor::updateFormatFilterConfig(const std::vector<FormatFilterConfig> &configs) {
+    VideoSensor::updateFormatFilterConfig(configs);
+    convertProfileAsDisparityBasedProfile();
+}
+
+void DisparityBasedSensor::convertProfileAsDisparityBasedProfile() {
+    auto oldSpList = streamProfileList_;
+    streamProfileList_.clear();
+    for(auto &sp: oldSpList) {
+        auto vsp   = sp->as<const VideoStreamProfile>();
+        auto newSp = StreamProfileFactory::createDisparityBasedStreamProfile(vsp);
+        auto iter = streamProfileBackendMap_.find(sp);
+        streamProfileBackendMap_.insert({newSp,{iter->second.first, iter->second.second}});
+        streamProfileList_.push_back(newSp);
+    }
+}
+
+void DisparityBasedSensor::markOutputDisparityFrame(bool enable) {
+    outputDisparityFrame_ = enable;
+}
+
+void DisparityBasedSensor::setDepthUnit(float unit){
+    depthUnit_ = unit;
+}
+
+void DisparityBasedSensor::outputFrame(std::shared_ptr<Frame> frame) {
+    if(outputDisparityFrame_) {
+        auto vsp = frame->as<VideoFrame>();
+        vsp->setPixelType(OB_PIXEL_DISPARITY);
+    }
+
+    auto depthFrame = frame->as<DepthFrame>();
+    if(depthFrame) {
+        depthFrame->setValueScale(depthUnit_);
+    }
+
+    VideoSensor::outputFrame(frame);
+}
+}  // namespace libobsensor
diff --git a/src/device/component/sensor/video/DisparityBasedSensor.hpp b/src/device/component/sensor/video/DisparityBasedSensor.hpp
new file mode 100644
index 00000000..812043d0
--- /dev/null
+++ b/src/device/component/sensor/video/DisparityBasedSensor.hpp
@@ -0,0 +1,31 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include "VideoSensor.hpp"
+
+namespace libobsensor {
+class DisparityBasedSensor : public VideoSensor {
+public:
+    DisparityBasedSensor(IDevice *owner, OBSensorType sensorType, const std::shared_ptr<ISourcePort> &backend);
+    ~DisparityBasedSensor() override = default;
+
+    void updateFormatFilterConfig(const std::vector<FormatFilterConfig> &configs) override;
+
+    void markOutputDisparityFrame(bool enable);
+
+    void setDepthUnit(float unit);
+private:
+    void outputFrame(std::shared_ptr<Frame> frame) override;
+
+    void convertProfileAsDisparityBasedProfile();
+
+    void syncDisparityToDepthModeStatus();
+
+private:
+    bool outputDisparityFrame_ = false;
+
+    float depthUnit_ = 1.0f;
+};
+}  // namespace libobsensor
diff --git a/src/device/component/sensor/video/VideoSensor.cpp b/src/device/component/sensor/video/VideoSensor.cpp
new file mode 100644
index 00000000..e35a961c
--- /dev/null
+++ b/src/device/component/sensor/video/VideoSensor.cpp
@@ -0,0 +1,325 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "VideoSensor.hpp"
+#include "exception/ObException.hpp"
+#include "logger/LoggerInterval.hpp"
+#include "logger/LoggerHelper.hpp"
+#include "utils/Utils.hpp"
+#include "stream/StreamProfile.hpp"
+#include "frame/Frame.hpp"
+#include "FilterDecorator.hpp"
+#include "publicfilters/FormatConverterProcess.hpp"
+#include "ISensorStreamStrategy.hpp"
+#include "IDevice.hpp"
+#include "component/property/InternalProperty.hpp"
+
+namespace libobsensor {
+
+VideoSensor::VideoSensor(IDevice *owner, OBSensorType sensorType, const std::shared_ptr<ISourcePort> &backend) : SensorBase(owner, sensorType, backend) {
+    auto vsPort = std::dynamic_pointer_cast<IVideoStreamPort>(backend_);
+    if(!vsPort) {
+        throw invalid_value_exception("Backend is not a valid IVideoStreamPort");
+    }
+
+    try {
+        // try to stop stream to avoid that the device is in streaming state due to some reason such as a previous crash
+        trySendStopStreamVendorCmd();
+    }
+    catch(const std::exception &e) {
+        LOG_WARN("Failed to stop stream: {}", e.what());
+    }
+
+    auto backendSpList = vsPort->getStreamProfileList();
+    setStreamProfileList(backendSpList);
+
+    LOG_DEBUG("VideoSensor created @{}", sensorType_);
+}
+
+VideoSensor::~VideoSensor() noexcept {
+    try {
+        stop();
+    }
+    catch(const std::exception &e) {
+        LOG_ERROR("Exception occurred while destroying VideoSensor: {}", e.what());
+    }
+    LOG_DEBUG("VideoSensor destroyed @{}", sensorType_);
+}
+
+#define MIN_VIDEO_FRAME_DATA_SIZE 1024
+void VideoSensor::start(std::shared_ptr<const StreamProfile> sp, FrameCallback callback) {
+    LOG_INFO("Try to start stream: {}", sp);
+    // validate stream profile
+    {
+        auto owner    = getOwner();
+        auto strategy = owner->getComponentT<ISensorStreamStrategy>(OB_DEV_COMPONENT_SENSOR_STREAM_STRATEGY, false);
+        if(strategy) {
+            strategy->validateStream(sp);
+            strategy->markStreamActivated(sp);
+        }
+    }
+
+    activatedStreamProfile_ = sp;
+    frameCallback_          = callback;
+    updateStreamState(STREAM_STATE_STARTING);
+
+    auto backendIter = streamProfileBackendMap_.find(sp);
+    if(backendIter == streamProfileBackendMap_.end()) {
+        throw invalid_value_exception("Can not find backend stream profile for activated stream profile");
+    }
+    currentBackendStreamProfile_ = backendIter->second.first;
+    currentFormatFilterConfig_   = backendIter->second.second;
+
+    if(currentFormatFilterConfig_ && currentFormatFilterConfig_->converter) {
+        auto filter          = std::dynamic_pointer_cast<FilterDecorator>(currentFormatFilterConfig_->converter);
+        auto baseFilter      = filter->getBaseFilter();
+        auto formatConverter = std::dynamic_pointer_cast<FormatConverter>(baseFilter);
+        if(formatConverter) {
+            formatConverter->setConversion(currentFormatFilterConfig_->srcFormat, currentFormatFilterConfig_->dstFormat);
+        }
+        currentFormatFilterConfig_->converter->setCallback([this](std::shared_ptr<Frame> frame) { outputFrame(frame); });
+    }
+
+    auto vsPort = std::dynamic_pointer_cast<IVideoStreamPort>(backend_);
+    LOG_INFO("Start backend stream: {}", currentBackendStreamProfile_);
+    BEGIN_TRY_EXECUTE({
+        vsPort->startStream(currentBackendStreamProfile_, [this](std::shared_ptr<Frame> frame) {  //
+            onBackendFrameCallback(frame);
+        });
+    })
+    CATCH_EXCEPTION_AND_EXECUTE({
+        {
+            auto owner    = getOwner();
+            auto strategy = owner->getComponentT<ISensorStreamStrategy>(OB_DEV_COMPONENT_SENSOR_STREAM_STRATEGY, false);
+            if(strategy) {
+                strategy->markStreamDeactivated(activatedStreamProfile_);
+            }
+        }
+        activatedStreamProfile_.reset();
+        frameCallback_ = nullptr;
+        updateStreamState(STREAM_STATE_START_FAILED);
+        throw;
+    })
+}
+
+void VideoSensor::onBackendFrameCallback(std::shared_ptr<Frame> frame) {
+    auto vsp              = currentBackendStreamProfile_->as<VideoStreamProfile>();
+    auto maxFrameDataSize = vsp->getMaxFrameDataSize();
+
+    auto dataSize = frame->getDataSize();
+    auto format   = frame->getFormat();
+
+#ifdef OB_DEBUG
+    // auto fsp   = frame->getStreamProfile();
+    // auto owner = fsp->getOwner();
+    // if(fsp.get() != currentBackendStreamProfile_.get()) {
+    //     throw invalid_value_exception("Frame's stream profile is not the same as activated stream profile");
+    // }
+    // if(owner.get() != static_cast<void *>(this)) {
+    //     throw invalid_value_exception("Frame's owner is not this VideoSensor");
+    // }
+#endif
+
+    if(format == OB_FORMAT_MJPG && frame->getDataSize() < MIN_VIDEO_FRAME_DATA_SIZE) {
+        LOG_WARN_INTVL("This frame will be dropped because data size less than mini size (1024 byte)! size={} @{}", dataSize, sensorType_);
+        return;
+    }
+    else if(format == OB_FORMAT_MJPG && sensorType_ != OB_SENSOR_DEPTH && !utils::checkJpgImageData(frame->getData(), dataSize)) {
+        LOG_WARN_INTVL("This frame will be dropped because jpg format verification failure! @{}", sensorType_);
+        return;
+    }
+    else if(maxFrameDataSize < dataSize) {
+        LOG_WARN_INTVL("This frame will be dropped because because the data size is larger than expected! size={}, expected={} @{}", dataSize, maxFrameDataSize,
+                       sensorType_);
+        return;
+    }
+    else if(IS_FIXED_SIZE_FORMAT(format) && maxFrameDataSize != dataSize) {
+        LOG_WARN_INTVL("This frame will be dropped because the data size does not match the expectation! size={}, expected={} @{}", dataSize, maxFrameDataSize,
+                       sensorType_);
+        return;
+    }
+
+    updateStreamState(STREAM_STATE_STREAMING);
+
+    if(currentFormatFilterConfig_ && currentFormatFilterConfig_->converter) {
+        currentFormatFilterConfig_->converter->pushFrame(frame);
+    }
+    else {
+        outputFrame(frame);
+    }
+}
+
+void VideoSensor::outputFrame(std::shared_ptr<Frame> frame) {
+    frame->setStreamProfile(activatedStreamProfile_);
+    if(frameProcessor_) {
+        frameProcessor_->pushFrame(frame);
+    }
+    else {
+        SensorBase::outputFrame(frame);
+    }
+}
+
+void VideoSensor::stop() {
+    if(!isStreamActivated()) {
+        return;
+    }
+
+    {
+        auto owner    = getOwner();
+        auto strategy = owner->getComponentT<ISensorStreamStrategy>(OB_DEV_COMPONENT_SENSOR_STREAM_STRATEGY, false);
+        if(strategy) {
+            strategy->markStreamDeactivated(activatedStreamProfile_);
+        }
+    }
+    updateStreamState(STREAM_STATE_STOPPING);
+
+    auto vsPort = std::dynamic_pointer_cast<IVideoStreamPort>(backend_);
+    vsPort->stopStream(currentBackendStreamProfile_);
+
+    trySendStopStreamVendorCmd();
+
+    updateStreamState(STREAM_STATE_STOPPED);
+
+    if(currentFormatFilterConfig_ && currentFormatFilterConfig_->converter) {
+        currentFormatFilterConfig_->converter->reset();
+    }
+
+    if(frameProcessor_) {
+        frameProcessor_->reset();
+    }
+
+    activatedStreamProfile_.reset();
+    frameCallback_ = nullptr;
+}
+
+void VideoSensor::trySendStopStreamVendorCmd() {
+    auto owner      = getOwner();
+    auto propServer = owner->getPropertyServer();
+    auto propertyId = -1;
+    if(propertyId == -1) {
+        switch(sensorType_) {
+        case OB_SENSOR_IR:
+        case OB_SENSOR_IR_LEFT:
+            propertyId = OB_PROP_STOP_IR_STREAM_BOOL;
+            break;
+        case OB_SENSOR_COLOR:
+            propertyId = OB_PROP_STOP_COLOR_STREAM_BOOL;
+            break;
+        case OB_SENSOR_IR_RIGHT:
+        case OB_SENSOR_DEPTH:
+            propertyId = OB_PROP_STOP_DEPTH_STREAM_BOOL;
+            break;
+        default:
+            return;
+        }
+    }
+    if(propServer->isPropertySupported(propertyId, PROP_OP_WRITE, PROP_ACCESS_INTERNAL)) {
+        propServer->setPropertyValueT<bool>(propertyId, true);
+    }
+}
+
+void VideoSensor::updateFormatFilterConfig(const std::vector<FormatFilterConfig> &configs) {
+    if(isStreamActivated()) {
+        throw wrong_api_call_sequence_exception("Can not update format filter config while streaming");
+    }
+    formatFilterConfigs_ = configs;
+    streamProfileList_.clear();
+
+    auto owner      = getOwner();
+    auto lazySelf   = std::make_shared<LazySensor>(owner, sensorType_);
+    auto streamType = utils::mapSensorTypeToStreamType(sensorType_);
+    for(const auto &backendSp: backendStreamProfileList_) {
+        auto format   = backendSp->getFormat();
+        bool filtered = false;
+        std::for_each(formatFilterConfigs_.begin(), formatFilterConfigs_.end(), [&](const FormatFilterConfig &config) {
+            if(config.srcFormat != format) {
+                return;
+            }
+
+            if(config.policy == FormatFilterPolicy::REMOVE) {
+                filtered = true;
+                return;
+            }
+
+            // FormatFilterPolicy is ADD or REPLACE, add a new stream profile with the new format
+            auto sp = backendSp->clone();
+            sp->setFormat(config.dstFormat);
+            sp->bindOwner(lazySelf);
+            sp->setType(streamType);
+            streamProfileList_.push_back(sp);
+            streamProfileBackendMap_[sp] = { backendSp, &config };
+
+            filtered |= (config.policy != FormatFilterPolicy::ADD);  // if policy is REPLACE, filter out the original stream profile
+        });
+
+        if(!filtered) {  // if no filter applied, add the original stream profile
+            auto sp = backendSp->clone();
+            sp->bindOwner(lazySelf);
+            sp->setType(streamType);
+            streamProfileList_.push_back(sp);
+            streamProfileBackendMap_[sp] = { backendSp, nullptr };
+            continue;
+        }
+    }
+
+#ifdef _DEBUG
+    LOG_TRACE(" filtered stream profile list size={} @{}", streamProfileList_.size(), sensorType_);
+    for(auto &sp: streamProfileList_) {
+        LOG_TRACE(" - {}", sp);
+    }
+#endif
+}
+
+void VideoSensor::setStreamProfileList(const StreamProfileList &profileList) {
+    auto              lazySelf      = std::make_shared<LazySensor>(owner_, sensorType_);
+    auto              streamType    = utils::mapSensorTypeToStreamType(sensorType_);
+    StreamProfileList backendSpList = profileList;
+    for(auto &backendSp: backendSpList) {
+        auto sp = backendSp->clone();
+        sp->bindOwner(lazySelf);
+        sp->setType(streamType);
+        backendStreamProfileList_.push_back(sp);
+        LOG_DEBUG("Backend stream profile {}", backendSp);
+    }
+
+    std::sort(backendStreamProfileList_.begin(), backendStreamProfileList_.end(),
+              [](const std::shared_ptr<const StreamProfile> &a, const std::shared_ptr<const StreamProfile> &b) {
+                  auto aVsp = a->as<VideoStreamProfile>();
+                  auto bVsp = b->as<VideoStreamProfile>();
+                  auto aRes = aVsp->getWidth() * aVsp->getHeight();
+                  auto bRes = bVsp->getWidth() * bVsp->getHeight();
+                  if(aRes != bRes) {
+                      return aRes > bRes;
+                  }
+                  else if(aVsp->getHeight() != bVsp->getHeight()) {
+                      return aVsp->getHeight() > bVsp->getHeight();
+                  }
+                  else if(aVsp->getFps() != bVsp->getFps()) {
+                      return aVsp->getFps() > bVsp->getFps();
+                  }
+                  return aVsp->getFormat() > bVsp->getFormat();
+              });
+
+    // The stream profile list is same as the backend stream profile list at default.
+    for(auto &backendSp: backendStreamProfileList_) {
+        auto sp = backendSp->clone();
+        sp->bindOwner(lazySelf);
+        sp->setType(streamType);
+        streamProfileList_.push_back(sp);
+        streamProfileBackendMap_[sp] = { backendSp, nullptr };
+    }
+
+    if(!formatFilterConfigs_.empty()) {
+        updateFormatFilterConfig(formatFilterConfigs_);
+    }
+}
+
+void VideoSensor::setFrameProcessor(std::shared_ptr<FrameProcessor> frameProcessor) {
+    if(isStreamActivated()) {
+        throw wrong_api_call_sequence_exception("Can not update frame processor while streaming");
+    }
+    frameProcessor_ = frameProcessor;
+    frameProcessor_->setCallback([this](std::shared_ptr<Frame> frame) { SensorBase::outputFrame(frame); });
+}
+
+}  // namespace libobsensor
diff --git a/src/device/component/sensor/video/VideoSensor.hpp b/src/device/component/sensor/video/VideoSensor.hpp
new file mode 100644
index 00000000..614f2295
--- /dev/null
+++ b/src/device/component/sensor/video/VideoSensor.hpp
@@ -0,0 +1,59 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include "sensor/SensorBase.hpp"
+#include "IFrame.hpp"
+#include "IFilter.hpp"
+#include "frameprocessor/FrameProcessor.hpp"
+
+#include <map>
+
+namespace libobsensor {
+
+enum class FormatFilterPolicy {
+    REMOVE,   // Directly remove the stream profile if the format matches the src format
+    REPLACE,  // Replace the stream profile with a new format stream profile. If there is a frame format converter available, use it to convert the frame to the
+              // new format
+    ADD,      // Use the frame format converter to convert the frame to the new format and add a new format stream profile to the list
+};
+
+struct FormatFilterConfig {
+    FormatFilterPolicy       policy;
+    OBFormat                 srcFormat;
+    OBFormat                 dstFormat;
+    std::shared_ptr<IFilter> converter;
+};
+
+class VideoSensor : public SensorBase {
+public:
+    VideoSensor(IDevice *owner, OBSensorType sensorType, const std::shared_ptr<ISourcePort> &backend);
+
+    virtual ~VideoSensor() noexcept;
+
+    void start(std::shared_ptr<const StreamProfile> sp, FrameCallback callback) override;
+    void stop() override;
+
+    virtual void updateFormatFilterConfig(const std::vector<FormatFilterConfig> &configs);
+    void         setStreamProfileList(const StreamProfileList &profileList) override;
+    void         setFrameProcessor(std::shared_ptr<FrameProcessor> frameProcessor);
+
+protected:
+    virtual void trySendStopStreamVendorCmd();
+    void         onBackendFrameCallback(std::shared_ptr<Frame> frame);
+    void         outputFrame(std::shared_ptr<Frame> frame) override;
+
+protected:
+    typedef std::pair<std::shared_ptr<const StreamProfile>, const FormatFilterConfig *> StreamProfileBackendMapValue;
+    std::map<std::shared_ptr<const StreamProfile>, StreamProfileBackendMapValue>        streamProfileBackendMap_;
+
+    std::vector<FormatFilterConfig>      formatFilterConfigs_;
+    const FormatFilterConfig            *currentFormatFilterConfig_;
+    std::shared_ptr<const StreamProfile> currentBackendStreamProfile_;
+    StreamProfileList                    backendStreamProfileList_;
+
+    std::shared_ptr<FrameProcessor> frameProcessor_;
+};
+
+}  // namespace libobsensor
+
diff --git a/src/device/component/syncconfig/DeviceSyncConfigurator.cpp b/src/device/component/syncconfig/DeviceSyncConfigurator.cpp
new file mode 100644
index 00000000..5a6d65b3
--- /dev/null
+++ b/src/device/component/syncconfig/DeviceSyncConfigurator.cpp
@@ -0,0 +1,221 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "DeviceSyncConfigurator.hpp"
+#include "exception/ObException.hpp"
+#include "InternalTypes.hpp"
+#include <map>
+
+namespace libobsensor {
+
+#pragma pack(1)
+typedef struct {
+    uint32_t syncMode;  // ob_multi_device_sync_mode
+    int      depthDelayUs;
+    int      colorDelayUs;
+    int      trigger2ImageDelayUs;
+    bool     triggerOutEnable;
+    int      triggerOutDelayUs;
+    int      framesPerTrigger;
+} OBMultiDeviceSyncConfigInternal;
+#pragma pack()
+
+DeviceSyncConfigurator::DeviceSyncConfigurator(IDevice *owner, const std::vector<OBMultiDeviceSyncMode> &supportedSyncModes)
+    : DeviceComponentBase(owner), supportedSyncModes_(supportedSyncModes), isSyncConfigInit_(false) {}
+
+OBMultiDeviceSyncConfig DeviceSyncConfigurator::getSyncConfig() {
+    if(isSyncConfigInit_) {
+        return currentMultiDevSyncConfig_;
+    }
+    auto owner          = getOwner();
+    auto propertyServer = owner->getPropertyServer();
+    auto configInternal = propertyServer->getStructureDataProtoV1_1_T<OBMultiDeviceSyncConfigInternal, 1>(OB_STRUCT_MULTI_DEVICE_SYNC_CONFIG);
+
+    currentMultiDevSyncConfig_.syncMode = (OBMultiDeviceSyncMode)configInternal.syncMode;
+    if(currentMultiDevSyncConfig_.syncMode == 0) {
+        currentMultiDevSyncConfig_.syncMode = OB_MULTI_DEVICE_SYNC_MODE_FREE_RUN;
+    }
+    else if(currentMultiDevSyncConfig_.syncMode == OB_MULTI_DEVICE_SYNC_MODE_SECONDARY_SYNCED
+            && std::find(supportedSyncModes_.begin(), supportedSyncModes_.end(), OB_MULTI_DEVICE_SYNC_MODE_SECONDARY_SYNCED) == supportedSyncModes_.end()
+            && std::find(supportedSyncModes_.begin(), supportedSyncModes_.end(), OB_MULTI_DEVICE_SYNC_MODE_SECONDARY) == supportedSyncModes_.end()) {
+        currentMultiDevSyncConfig_.syncMode = OB_MULTI_DEVICE_SYNC_MODE_SECONDARY;
+    }
+    currentMultiDevSyncConfig_.depthDelayUs         = configInternal.depthDelayUs;
+    currentMultiDevSyncConfig_.colorDelayUs         = configInternal.colorDelayUs;
+    currentMultiDevSyncConfig_.trigger2ImageDelayUs = configInternal.trigger2ImageDelayUs;
+    currentMultiDevSyncConfig_.triggerOutEnable     = configInternal.triggerOutEnable;
+    currentMultiDevSyncConfig_.triggerOutDelayUs    = configInternal.triggerOutDelayUs;
+    currentMultiDevSyncConfig_.framesPerTrigger     = 1;  // configInternal.framesPerTrigger; set to 1 at default
+
+    isSyncConfigInit_ = true;
+    return currentMultiDevSyncConfig_;
+}
+
+void DeviceSyncConfigurator::setSyncConfig(const OBMultiDeviceSyncConfig &deviceSyncConfig) {
+    if(isSyncConfigInit_ && 0 == memcmp(&currentMultiDevSyncConfig_, &deviceSyncConfig, sizeof(OBMultiDeviceSyncConfig))) {
+        LOG_DEBUG("New sync config is same as current device sync config, the upgrade process would not execute!");
+        return;
+    }
+
+    OBMultiDeviceSyncConfigInternal internalConfig;
+    internalConfig.syncMode = deviceSyncConfig.syncMode;
+    if(deviceSyncConfig.syncMode == 0) {
+        internalConfig.syncMode = OB_MULTI_DEVICE_SYNC_MODE_FREE_RUN;
+    }
+    else if(deviceSyncConfig.syncMode == OB_MULTI_DEVICE_SYNC_MODE_SECONDARY_SYNCED
+            && std::find(supportedSyncModes_.begin(), supportedSyncModes_.end(), OB_MULTI_DEVICE_SYNC_MODE_SECONDARY_SYNCED) == supportedSyncModes_.end()
+            && std::find(supportedSyncModes_.begin(), supportedSyncModes_.end(), OB_MULTI_DEVICE_SYNC_MODE_SECONDARY) == supportedSyncModes_.end()) {
+        internalConfig.syncMode = OB_MULTI_DEVICE_SYNC_MODE_SECONDARY;
+    }
+    internalConfig.depthDelayUs         = deviceSyncConfig.depthDelayUs;
+    internalConfig.colorDelayUs         = deviceSyncConfig.colorDelayUs;
+    internalConfig.trigger2ImageDelayUs = deviceSyncConfig.trigger2ImageDelayUs;
+    internalConfig.triggerOutEnable     = deviceSyncConfig.triggerOutEnable;
+    internalConfig.triggerOutDelayUs    = deviceSyncConfig.triggerOutDelayUs;
+    internalConfig.framesPerTrigger     = deviceSyncConfig.framesPerTrigger;
+
+    auto owner          = getOwner();
+    auto propertyServer = owner->getPropertyServer();
+    propertyServer->setStructureDataProtoV1_1_T<OBMultiDeviceSyncConfigInternal, 1>(OB_STRUCT_MULTI_DEVICE_SYNC_CONFIG, internalConfig);
+
+    currentMultiDevSyncConfig_ = deviceSyncConfig;
+    isSyncConfigInit_          = true;
+}
+
+uint16_t DeviceSyncConfigurator::getSupportedSyncModeBitmap() {
+    uint16_t supportedSyncModeBitmap = 0;
+    for(auto &mode: supportedSyncModes_) {
+        supportedSyncModeBitmap |= mode;
+    }
+    return supportedSyncModeBitmap;
+}
+
+void DeviceSyncConfigurator::triggerCapture() {
+    auto owner          = getOwner();
+    auto propertyServer = owner->getPropertyServer();
+    propertyServer->setPropertyValueT(OB_PROP_CAPTURE_IMAGE_SIGNAL_BOOL, true);
+}
+
+const std::map<OBMultiDeviceSyncMode, OBSyncMode> DefaultSyncModeMapV2ToV1 = {
+    { OB_MULTI_DEVICE_SYNC_MODE_FREE_RUN, OB_SYNC_MODE_CLOSE },  //
+    { OB_MULTI_DEVICE_SYNC_MODE_STANDALONE, OB_SYNC_MODE_STANDALONE },
+    { OB_MULTI_DEVICE_SYNC_MODE_PRIMARY, OB_SYNC_MODE_PRIMARY },
+    { OB_MULTI_DEVICE_SYNC_MODE_SECONDARY, OB_SYNC_MODE_SECONDARY },
+    { OB_MULTI_DEVICE_SYNC_MODE_SECONDARY_SYNCED, OB_SYNC_MODE_SECONDARY },
+    { OB_MULTI_DEVICE_SYNC_MODE_SOFTWARE_TRIGGERING, OB_SYNC_MODE_PRIMARY_SOFT_TRIGGER },
+    { OB_MULTI_DEVICE_SYNC_MODE_HARDWARE_TRIGGERING, OB_SYNC_MODE_SECONDARY_SOFT_TRIGGER },
+};
+
+const std::map<OBSyncMode, OBMultiDeviceSyncMode> DefaultSyncModeMapV1ToV2 = {
+    { OB_SYNC_MODE_CLOSE, OB_MULTI_DEVICE_SYNC_MODE_FREE_RUN },  //
+    { OB_SYNC_MODE_STANDALONE, OB_MULTI_DEVICE_SYNC_MODE_STANDALONE },
+    { OB_SYNC_MODE_PRIMARY, OB_MULTI_DEVICE_SYNC_MODE_PRIMARY },
+    { OB_SYNC_MODE_PRIMARY_MCU_TRIGGER, OB_MULTI_DEVICE_SYNC_MODE_PRIMARY },
+    { OB_SYNC_MODE_PRIMARY_IR_TRIGGER, OB_MULTI_DEVICE_SYNC_MODE_PRIMARY },
+    { OB_SYNC_MODE_PRIMARY_SOFT_TRIGGER, OB_MULTI_DEVICE_SYNC_MODE_SOFTWARE_TRIGGERING },
+    { OB_SYNC_MODE_SECONDARY, OB_MULTI_DEVICE_SYNC_MODE_SECONDARY },
+    { OB_SYNC_MODE_SECONDARY_SOFT_TRIGGER, OB_MULTI_DEVICE_SYNC_MODE_HARDWARE_TRIGGERING },
+};
+
+DeviceSyncConfiguratorOldProtocol::DeviceSyncConfiguratorOldProtocol(IDevice *owner, const std::vector<OBMultiDeviceSyncMode> &supportedSyncModes)
+    : DeviceComponentBase(owner),
+      supportedSyncModes_(supportedSyncModes),
+      isSyncConfigInit_(false),
+      syncModeOldToNewMap_(DefaultSyncModeMapV1ToV2),
+      syncModeNewToOldMap_(DefaultSyncModeMapV2ToV1),
+      isDepthDelaySupported_(false) {}
+
+OBMultiDeviceSyncConfig DeviceSyncConfiguratorOldProtocol::getSyncConfig() {
+    if(isSyncConfigInit_) {
+        return currentMultiDevSyncConfig_;
+    }
+    auto owner          = getOwner();
+    auto propertyServer = owner->getPropertyServer();
+    auto configInternal = propertyServer->getStructureDataT<OBDeviceSyncConfig>(OB_STRUCT_MULTI_DEVICE_SYNC_CONFIG);
+
+    bool triggerSignalOutEnable = true;
+    if(propertyServer->isPropertySupported(OB_PROP_SYNC_SIGNAL_TRIGGER_OUT_BOOL, PROP_OP_READ, PROP_ACCESS_INTERNAL)) {
+        triggerSignalOutEnable = propertyServer->getPropertyValueT<bool>(OB_PROP_SYNC_SIGNAL_TRIGGER_OUT_BOOL);
+    }
+    int framePerTriggering = 0;
+    if(propertyServer->isPropertySupported(OB_PROP_CAPTURE_IMAGE_FRAME_NUMBER_INT, PROP_OP_READ, PROP_ACCESS_INTERNAL)) {
+        framePerTriggering = propertyServer->getPropertyValueT<int>(OB_PROP_CAPTURE_IMAGE_FRAME_NUMBER_INT);
+    }
+
+    currentMultiDevSyncConfig_.syncMode             = syncModeOldToNewMap_.at(configInternal.syncMode);
+    currentMultiDevSyncConfig_.colorDelayUs         = configInternal.rgbTriggerSignalInDelay;
+    currentMultiDevSyncConfig_.depthDelayUs         = configInternal.irTriggerSignalInDelay;
+    currentMultiDevSyncConfig_.trigger2ImageDelayUs = configInternal.irTriggerSignalInDelay;
+    currentMultiDevSyncConfig_.triggerOutEnable     = triggerSignalOutEnable;
+    currentMultiDevSyncConfig_.triggerOutDelayUs    = configInternal.deviceTriggerSignalOutDelay;
+    currentMultiDevSyncConfig_.framesPerTrigger     = framePerTriggering;
+
+    if(currentMultiDevSyncConfig_.syncMode == OB_MULTI_DEVICE_SYNC_MODE_SECONDARY) {
+        currentMultiDevSyncConfig_.syncMode = OB_MULTI_DEVICE_SYNC_MODE_SECONDARY_SYNCED;
+    }
+
+    isSyncConfigInit_ = true;
+    return currentMultiDevSyncConfig_;
+}
+
+void DeviceSyncConfiguratorOldProtocol::setSyncConfig(const OBMultiDeviceSyncConfig &deviceSyncConfig) {
+    if(isSyncConfigInit_ && memcmp(&deviceSyncConfig, &currentMultiDevSyncConfig_, sizeof(OBMultiDeviceSyncConfig)) == 0) {
+        LOG_DEBUG("Sync config is the same as current config, no need to set!");
+        return;
+    }
+    OBMultiDeviceSyncConfig v2SyncConfig = deviceSyncConfig;
+    if(!isDepthDelaySupported_) {
+        v2SyncConfig.depthDelayUs = v2SyncConfig.trigger2ImageDelayUs;
+    }
+    if(deviceSyncConfig.syncMode == OB_MULTI_DEVICE_SYNC_MODE_PRIMARY) {
+        v2SyncConfig.triggerOutEnable  = true;
+        v2SyncConfig.triggerOutDelayUs = 0;
+    }
+    OBDeviceSyncConfig v1SyncConfig;
+    v1SyncConfig.syncMode                       = syncModeNewToOldMap_.at(v2SyncConfig.syncMode);
+    v1SyncConfig.rgbTriggerSignalInDelay        = static_cast<uint16_t>(v2SyncConfig.colorDelayUs);
+    v1SyncConfig.irTriggerSignalInDelay         = static_cast<uint16_t>(v2SyncConfig.depthDelayUs);
+    v1SyncConfig.deviceTriggerSignalOutDelay    = static_cast<uint16_t>(v2SyncConfig.triggerOutDelayUs);
+    v1SyncConfig.deviceTriggerSignalOutPolarity = 0;
+    v1SyncConfig.deviceId                       = 0;
+    v1SyncConfig.mcuTriggerFrequency            = 0;
+
+    auto owner          = getOwner();
+    auto propertyServer = owner->getPropertyServer();
+    propertyServer->setStructureDataT<OBDeviceSyncConfig>(OB_STRUCT_MULTI_DEVICE_SYNC_CONFIG, v1SyncConfig);
+    if(propertyServer->isPropertySupported(OB_PROP_SYNC_SIGNAL_TRIGGER_OUT_BOOL, PROP_OP_WRITE, PROP_ACCESS_INTERNAL)) {
+        propertyServer->setPropertyValueT<bool>(OB_PROP_SYNC_SIGNAL_TRIGGER_OUT_BOOL, v2SyncConfig.triggerOutEnable);
+    }
+    if(propertyServer->isPropertySupported(OB_PROP_CAPTURE_IMAGE_FRAME_NUMBER_INT, PROP_OP_WRITE, PROP_ACCESS_INTERNAL)) {
+        propertyServer->setPropertyValueT<int>(OB_PROP_CAPTURE_IMAGE_FRAME_NUMBER_INT, v2SyncConfig.framesPerTrigger);
+    }
+
+    currentMultiDevSyncConfig_ = v2SyncConfig;
+    isSyncConfigInit_          = true;
+}
+
+uint16_t DeviceSyncConfiguratorOldProtocol::getSupportedSyncModeBitmap() {
+    uint16_t supportedSyncModeBitmap = 0;
+    for(auto &mode: supportedSyncModes_) {
+        supportedSyncModeBitmap |= mode;
+    }
+    return supportedSyncModeBitmap;
+}
+
+void DeviceSyncConfiguratorOldProtocol::triggerCapture() {
+    auto owner          = getOwner();
+    auto propertyServer = owner->getPropertyServer();
+    propertyServer->setPropertyValueT(OB_PROP_CAPTURE_IMAGE_SIGNAL_BOOL, true);
+}
+
+void DeviceSyncConfiguratorOldProtocol::updateModeAliasMap(const std::map<OBSyncMode, OBMultiDeviceSyncMode> &oldToNewMap,
+                                                           const std::map<OBMultiDeviceSyncMode, OBSyncMode> &newToOldMap) {
+    syncModeOldToNewMap_ = oldToNewMap;
+    syncModeNewToOldMap_ = newToOldMap;
+}
+
+void DeviceSyncConfiguratorOldProtocol::enableDepthDelaySupport(bool enable) {
+    isDepthDelaySupported_ = enable;
+}
+
+}  // namespace libobsensor
diff --git a/src/device/component/syncconfig/DeviceSyncConfigurator.hpp b/src/device/component/syncconfig/DeviceSyncConfigurator.hpp
new file mode 100644
index 00000000..ce4a3826
--- /dev/null
+++ b/src/device/component/syncconfig/DeviceSyncConfigurator.hpp
@@ -0,0 +1,60 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+
+#pragma once
+#include "IDevice.hpp"
+#include "IDeviceSyncConfigurator.hpp"
+#include "DeviceComponentBase.hpp"
+
+#include <vector>
+#include <memory>
+#include <map>
+
+namespace libobsensor {
+
+class DeviceSyncConfigurator : public IDeviceSyncConfigurator, public DeviceComponentBase {
+public:
+    DeviceSyncConfigurator(IDevice *owner, const std::vector<OBMultiDeviceSyncMode> &supportedSyncModes);
+    virtual ~DeviceSyncConfigurator() = default;
+
+    OBMultiDeviceSyncConfig getSyncConfig() override;
+    void                    setSyncConfig(const OBMultiDeviceSyncConfig &deviceSyncConfig) override;
+    uint16_t                getSupportedSyncModeBitmap() override;
+    void                    triggerCapture() override;
+
+private:
+    const std::vector<OBMultiDeviceSyncMode> supportedSyncModes_;
+
+    std::atomic<bool>       isSyncConfigInit_;
+    OBMultiDeviceSyncConfig currentMultiDevSyncConfig_;
+};
+
+class DeviceSyncConfiguratorOldProtocol : public IDeviceSyncConfigurator, public DeviceComponentBase {
+public:
+    DeviceSyncConfiguratorOldProtocol(IDevice *owner, const std::vector<OBMultiDeviceSyncMode> &supportedSyncModes);
+    virtual ~DeviceSyncConfiguratorOldProtocol() = default;
+
+    OBMultiDeviceSyncConfig getSyncConfig() override;
+    void                    setSyncConfig(const OBMultiDeviceSyncConfig &deviceSyncConfig) override;
+    uint16_t                getSupportedSyncModeBitmap() override;
+    void                    triggerCapture() override;
+
+    void updateModeAliasMap(const std::map<OBSyncMode, OBMultiDeviceSyncMode> &oldToNewMap, const std::map<OBMultiDeviceSyncMode, OBSyncMode> &newToOldMap);
+
+    void enableDepthDelaySupport(bool enable);
+
+private:
+    const std::vector<OBMultiDeviceSyncMode> supportedSyncModes_;
+
+    std::atomic<bool>       isSyncConfigInit_;
+    OBMultiDeviceSyncConfig currentMultiDevSyncConfig_;
+
+    std::map<OBSyncMode, OBMultiDeviceSyncMode> syncModeOldToNewMap_;
+    std::map<OBMultiDeviceSyncMode, OBSyncMode> syncModeNewToOldMap_;
+
+    bool isDepthDelaySupported_;
+};
+
+}  // namespace libobsensor
diff --git a/src/device/component/timestamp/DeviceClockSynchronizer.cpp b/src/device/component/timestamp/DeviceClockSynchronizer.cpp
new file mode 100644
index 00000000..6481ffc0
--- /dev/null
+++ b/src/device/component/timestamp/DeviceClockSynchronizer.cpp
@@ -0,0 +1,121 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "DeviceClockSynchronizer.hpp"
+#include "InternalTypes.hpp"
+
+namespace libobsensor {
+
+DeviceClockSynchronizer::DeviceClockSynchronizer(IDevice *owner, uint64_t deviceClockFreqIn, uint64_t deviceClockFreqOut)
+    : DeviceComponentBase(owner), deviceClockFreqIn_(deviceClockFreqIn), deviceClockFreqOut_(deviceClockFreqOut), isTimestampResetConfigInit_(false) {}
+
+void DeviceClockSynchronizer::setTimestampResetConfig(const OBDeviceTimestampResetConfig &timestampResetConfig) {
+    if(isTimestampResetConfigInit_ && 0 == memcmp(&currentTimestampResetConfig_, &timestampResetConfig, sizeof(OBDeviceTimestampResetConfig))) {
+        LOG_DEBUG("New timestamp reset config is same as current device timestamp reset config, the upgrade process would not execute!");
+        return;
+    }
+
+    auto owner          = getOwner();
+    auto propertyServer = owner->getPropertyServer();
+    if(propertyServer->isPropertySupported(OB_PROP_TIMER_RESET_ENABLE_BOOL, PROP_OP_WRITE, PROP_ACCESS_INTERNAL)) {
+        propertyServer->setPropertyValueT(OB_PROP_TIMER_RESET_ENABLE_BOOL, timestampResetConfig.enable);
+    }
+    if(propertyServer->isPropertySupported(OB_PROP_TIMER_RESET_TRIGGER_OUT_ENABLE_BOOL, PROP_OP_WRITE, PROP_ACCESS_INTERNAL)) {
+        propertyServer->setPropertyValueT(OB_PROP_TIMER_RESET_TRIGGER_OUT_ENABLE_BOOL, timestampResetConfig.timestamp_reset_signal_output_enable);
+    }
+    if(propertyServer->isPropertySupported(OB_PROP_TIMER_RESET_DELAY_US_INT, PROP_OP_WRITE, PROP_ACCESS_INTERNAL)) {
+        propertyServer->setPropertyValueT(OB_PROP_TIMER_RESET_DELAY_US_INT, timestampResetConfig.timestamp_reset_delay_us);
+    }
+
+    currentTimestampResetConfig_ = timestampResetConfig;
+    isTimestampResetConfigInit_  = true;
+}
+
+OBDeviceTimestampResetConfig DeviceClockSynchronizer::getTimestampResetConfig() {
+    if(isTimestampResetConfigInit_) {
+        return currentTimestampResetConfig_;
+    }
+
+    auto owner          = getOwner();
+    auto propertyServer = owner->getPropertyServer();
+
+    if(propertyServer->isPropertySupported(OB_PROP_TIMER_RESET_ENABLE_BOOL, PROP_OP_READ, PROP_ACCESS_INTERNAL)) {
+        currentTimestampResetConfig_.enable = propertyServer->getPropertyValueT<bool>(OB_PROP_TIMER_RESET_ENABLE_BOOL);
+    }
+    else {
+        currentTimestampResetConfig_.enable = true;
+    }
+
+    if(propertyServer->isPropertySupported(OB_PROP_TIMER_RESET_TRIGGER_OUT_ENABLE_BOOL, PROP_OP_READ, PROP_ACCESS_INTERNAL)) {
+        currentTimestampResetConfig_.timestamp_reset_signal_output_enable =
+            propertyServer->getPropertyValueT<bool>(OB_PROP_TIMER_RESET_TRIGGER_OUT_ENABLE_BOOL);
+    }
+    else {
+        currentTimestampResetConfig_.timestamp_reset_signal_output_enable = true;
+    }
+
+    if(propertyServer->isPropertySupported(OB_PROP_TIMER_RESET_DELAY_US_INT, PROP_OP_READ, PROP_ACCESS_INTERNAL)) {
+        currentTimestampResetConfig_.timestamp_reset_delay_us = propertyServer->getPropertyValueT<int>(OB_PROP_TIMER_RESET_DELAY_US_INT);
+    }
+
+    isTimestampResetConfigInit_ = true;
+    return currentTimestampResetConfig_;
+}
+
+void DeviceClockSynchronizer::timestampReset() {
+    auto owner          = getOwner();
+    auto propertyServer = owner->getPropertyServer();
+    propertyServer->setPropertyValueT(OB_PROP_TIMER_RESET_ENABLE_BOOL, true);
+}
+
+void DeviceClockSynchronizer::timerSyncWithHost() {
+    const uint32_t MINI_HOST_DEVICE_TIME_DIFF = 10000;  // us
+    const uint32_t MAX_REPEAT_TIME            = 10;
+    uint8_t        repeated                   = 0;
+    uint64_t       rtt                        = 0;
+
+    while(repeated < MAX_REPEAT_TIME) {
+        {
+            auto owner          = getOwner();
+            auto propertyServer = owner->getPropertyServer();
+
+            auto now = utils::getNowTimesUs();
+            OBDeviceTime devTsp;
+            devTsp.time = static_cast<uint64_t>(static_cast<double>(now) / 1000000 * deviceClockFreqOut_);
+            devTsp.rtt  = static_cast<uint64_t>(static_cast<double>(rtt) / 1000000 * deviceClockFreqOut_);
+            propertyServer->setStructureDataT<OBDeviceTime>(OB_STRUCT_DEVICE_TIME, devTsp);
+            uint64_t after = utils::getNowTimesUs();
+            rtt            = after - now;
+        }
+        if(repeated == 0){
+            std::this_thread::sleep_for(std::chrono::milliseconds(50));
+            repeated++;
+            continue;
+        }
+        {
+            auto     owner          = getOwner();
+            auto     propertyServer = owner->getPropertyServer();
+            uint64_t now            = utils::getNowTimesUs();
+            auto     devTsp         = propertyServer->getStructureDataT<OBDeviceTime>(OB_STRUCT_DEVICE_TIME);
+            uint64_t after          = utils::getNowTimesUs();
+            uint64_t nowDev         = static_cast<uint64_t>(static_cast<double>(devTsp.time) / deviceClockFreqIn_ * 1000000);
+            double   diff           = std::fabs(static_cast<double>(nowDev) - (after + now) / 2);
+            if(diff > 0xFFFFFFFF) {
+                diff = std::fabs(static_cast<double>(nowDev & 0xFFFFFFFF) - ((after & 0xFFFFFFFF) + (now & 0xFFFFFFFF)) / 2);
+            }
+            if(diff <= static_cast<double>(MINI_HOST_DEVICE_TIME_DIFF)) {
+                break;
+            }
+            LOG_DEBUG("Device/Host time diff: {} us, rtt: {} us, repeated: {}", diff, rtt, repeated);
+        }
+        std::this_thread::sleep_for(std::chrono::milliseconds(50));
+        repeated++;
+    }
+
+    if(repeated >= MAX_REPEAT_TIME) {
+        throw io_exception(utils::string::to_string() << "syncDeviceTime failed after retry " << repeated << " times, rtt=" << rtt);
+    }
+}
+
+}  // namespace libobsensor
+
diff --git a/src/device/component/timestamp/DeviceClockSynchronizer.hpp b/src/device/component/timestamp/DeviceClockSynchronizer.hpp
new file mode 100644
index 00000000..dbd83366
--- /dev/null
+++ b/src/device/component/timestamp/DeviceClockSynchronizer.hpp
@@ -0,0 +1,29 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include "IDeviceClockSynchronizer.hpp"
+#include "DeviceComponentBase.hpp"
+
+namespace libobsensor {
+class DeviceClockSynchronizer : public IDeviceClockSynchronizer, public DeviceComponentBase {
+public:
+    DeviceClockSynchronizer(IDevice *owner, uint64_t deviceClockFreqIn = 1000, uint64_t deviceClockFreqOut = 1000);
+    virtual ~DeviceClockSynchronizer() = default;
+
+    void                         setTimestampResetConfig(const OBDeviceTimestampResetConfig &timestampResetConfig) override;
+    OBDeviceTimestampResetConfig getTimestampResetConfig() override;
+    void                         timestampReset() override;
+    void                         timerSyncWithHost() override;
+
+private:
+    uint64_t deviceClockFreqIn_;
+    uint64_t deviceClockFreqOut_;
+
+    std::atomic<bool>            isTimestampResetConfigInit_;
+    OBDeviceTimestampResetConfig currentTimestampResetConfig_;
+};
+
+}  // namespace libobsensor
+
diff --git a/src/device/component/timestamp/FrameTimestampCalculator.cpp b/src/device/component/timestamp/FrameTimestampCalculator.cpp
new file mode 100644
index 00000000..84d09852
--- /dev/null
+++ b/src/device/component/timestamp/FrameTimestampCalculator.cpp
@@ -0,0 +1,170 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "FrameTimestampCalculator.hpp"
+#include "frame/Frame.hpp"
+#include "usb/uvc/UvcTypes.hpp"
+#include "utils/Utils.hpp"
+#include "logger/LoggerInterval.hpp"
+#include "InternalTypes.hpp"
+
+namespace libobsensor {
+
+#define BASE_DEV_TIME_MASK 0xffffffff00000000
+#define TSP_OVERFLOW_32BIT 0x100000000
+
+GlobalTimestampCalculator::GlobalTimestampCalculator(IDevice *owner, uint64_t deviceTimeFreq, uint64_t frameTimeFreq)
+    : DeviceComponentBase(owner), deviceTimeFreq_(deviceTimeFreq), frameTimeFreq_(frameTimeFreq) {
+    (void)frameTimeFreq_;
+    globalTimestampFitter_ = owner->getComponentT<GlobalTimestampFitter>(OB_DEV_COMPONENT_GLOBAL_TIMESTAMP_FILTER).get();
+}
+
+void GlobalTimestampCalculator::calculate(std::shared_ptr<Frame> frame) {
+    auto srcTimestamp    = static_cast<uint32_t>(frame->getTimeStampUsec());  // get timestamp from frame and keep low 32 bits
+    auto linearFuncParam = globalTimestampFitter_->getLinearFuncParam();
+
+    // Convert to a timestamp with the same frequency as the device clock frequency
+    double   transformedTsp              = static_cast<double>(srcTimestamp) * deviceTimeFreq_ / 1000000.0;
+    uint64_t transformedTspOverflowValue = static_cast<uint64_t>(static_cast<double>(TSP_OVERFLOW_32BIT) * deviceTimeFreq_ / 1000000.0);
+
+    // Calculate the approximate number of overflows based on the check data. The number of overflows of the current data frame should be within the range of
+    // this number plus or minus 1.
+    uint32_t numOfOverflows = static_cast<uint32_t>(linearFuncParam.checkDataX / transformedTspOverflowValue);
+    if(numOfOverflows > 0) {
+        numOfOverflows--;
+    }
+    while(true) {
+        double value1 = (double)numOfOverflows * transformedTspOverflowValue + transformedTsp;
+        double value2 = (double)(numOfOverflows + 1) * transformedTspOverflowValue + transformedTsp;
+        if(value1 >= linearFuncParam.checkDataX) {
+            break;
+        }
+        if(value1 <= linearFuncParam.checkDataX && value2 >= linearFuncParam.checkDataX) {
+            if(linearFuncParam.checkDataX - value1 > value2 - linearFuncParam.checkDataX) {
+                numOfOverflows++;
+            }
+            break;
+        }
+        numOfOverflows++;
+    }
+    transformedTsp = (static_cast<double>(TSP_OVERFLOW_32BIT) * numOfOverflows + srcTimestamp) * deviceTimeFreq_ / 1000000;
+    auto globalTsp = static_cast<uint64_t>(linearFuncParam.coefficientA * transformedTsp + linearFuncParam.constantB);
+    frame->setGlobalTimeStampUsec(globalTsp);
+}
+
+void GlobalTimestampCalculator::clear() {}
+
+FrameTimestampCalculatorDirectly::FrameTimestampCalculatorDirectly(IDevice *device, uint64_t clockFreq) : DeviceComponentBase(device), clockFreq_(clockFreq) {}
+
+void FrameTimestampCalculatorDirectly::calculate(std::shared_ptr<Frame> frame) {
+    auto srcTimestamp    = frame->getTimeStampUsec();
+    auto outputTimestamp = static_cast<double>(srcTimestamp) * 1000000 / clockFreq_;
+    frame->setTimeStampUsec(static_cast<uint64_t>(outputTimestamp));
+}
+
+FrameTimestampCalculatorBaseDeviceTime::FrameTimestampCalculatorBaseDeviceTime(IDevice *device, uint64_t deviceTimeFreq, uint64_t frameTimeFreq)
+    : DeviceComponentBase(device), deviceTimeFreq_(deviceTimeFreq), frameTimeFreq_(frameTimeFreq) {
+    auto                  propServer = device->getPropertyServer();
+    std::vector<uint32_t> supportedProps;
+    if(propServer->isPropertySupported(OB_PROP_TIMER_RESET_SIGNAL_BOOL, PROP_OP_WRITE, PROP_ACCESS_INTERNAL)) {
+        supportedProps.push_back(OB_PROP_TIMER_RESET_SIGNAL_BOOL);
+    }
+    if(propServer->isPropertySupported(OB_STRUCT_DEVICE_TIME, PROP_OP_WRITE, PROP_ACCESS_INTERNAL)) {
+        supportedProps.push_back(OB_STRUCT_DEVICE_TIME);
+    }
+    if(!supportedProps.empty()) {
+        propServer->registerAccessCallback(supportedProps, [&](uint32_t, const uint8_t *, size_t, PropertyOperationType operationType) {
+            if(operationType == PROP_OP_WRITE) {
+                clear();
+            }
+        });
+    }
+}
+
+void FrameTimestampCalculatorBaseDeviceTime::calculate(std::shared_ptr<Frame> frame) {
+    auto srcTimestamp = frame->getTimeStampUsec();
+    auto rstTsp       = calculate(srcTimestamp);
+    frame->setTimeStampUsec(rstTsp);
+}
+
+uint64_t FrameTimestampCalculatorBaseDeviceTime::calculate(uint64_t srcTimestamp) {
+    // Conditions that need to update baseDevTime_:
+    // 1. The first frame after opening the stream
+    // 2. The timestamp becomes smaller (the size of the timestamps of the previous and later data frames is reversed), indicating that a timestamp overflow has
+    // occurred or the device clock has been cleared (a small probability may also be caused by abnormal data transmission)
+    // 3. The difference in system time between the arrival of two frames of data is greater than the difference in device timestamps between two frames of
+    // data, indicating that an overflow or clearing occurred during the triggering interval of the previous frame. However, the timestamps of the preceding and
+    // following data frames The size is not reversed, Try to actively update and obtain the device timestamp (but in order to avoid frequent acquisition of
+    // device timestamps due to misjudgments caused by data transmission fluctuations, we set the difference to be greater than prevSrcTspMs /2)
+    // 4. When the last timestamp is less than 50ms, avoid missing judgments
+    // LOG(INFO) << " >>> srcTimeStamp: " << srcTimestamp << " <<< ";
+    // Determine whether the timestamp becomes smaller
+    bool tspDecrease = (srcTimestamp < prevSrcTsp_);
+
+    // Determine whether the data frame timestamp difference is similar to the system timestamp difference
+    uint64_t curHostTsp      = utils::getNowTimesMs();
+    int64_t  srcTspDiffMs    = static_cast<int64_t>((static_cast<double>(srcTimestamp) - prevSrcTsp_) / frameTimeFreq_ * 1000);  // Convert unit to milliseconds
+    int64_t  hostTspDiffMs   = curHostTsp - prevHostTsp_;
+    uint64_t prevSrcTspMs    = static_cast<uint64_t>(static_cast<double>(prevSrcTsp_) / frameTimeFreq_ * 1000);
+    bool     tspDiffAbnormal = ((static_cast<double>(hostTspDiffMs) - srcTspDiffMs) >= prevSrcTspMs / 2);
+
+    if(baseDevTime_ == 0 || ((tspDecrease || tspDiffAbnormal) && (srcTimestamp != 0 || prevSrcTsp_ != 0)) || prevSrcTspMs <= 50) {
+        LOG_DEBUG_INTVL_MS(1000, "updateBaseTimeStamp:");
+        LOG_DEBUG_INTVL_MS(1000, "\tsrcTimestamp={0}, prevSrcTsp_={1}, tspDecrease={2}", srcTimestamp, prevSrcTsp_, tspDecrease);
+        LOG_DEBUG_INTVL_MS(1000, "\tsrcTspDiffMs={0}, hostTspDiffMs={1}, tspDiffAbnormal={2}", srcTspDiffMs, hostTspDiffMs, tspDiffAbnormal);
+
+        {
+            auto owner          = getOwner();
+            auto propertyServer = owner->getPropertyServer();
+            auto devTime        = propertyServer->getStructureDataT<OBDeviceTime>(OB_STRUCT_DEVICE_TIME);
+            baseDevTime_        = static_cast<uint64_t>((static_cast<double>(devTime.time) + devTime.rtt / 2) / deviceTimeFreq_ * frameTimeFreq_);
+        }
+
+        if((baseDevTime_ & ~BASE_DEV_TIME_MASK) <= srcTimestamp && baseDevTime_ > TSP_OVERFLOW_32BIT) {
+            // An overflow occurred between the timestamp of the data frame and updateBaseTimeStamp.
+            baseDevTime_ -= TSP_OVERFLOW_32BIT;
+        }
+    }
+
+    prevHostTsp_       = curHostTsp;
+    prevSrcTsp_        = srcTimestamp;
+    auto outputTsp     = (baseDevTime_ & BASE_DEV_TIME_MASK) + (srcTimestamp & (~BASE_DEV_TIME_MASK));
+    auto timestampUsec = static_cast<double>(outputTsp) / frameTimeFreq_ * 1000000;
+    return static_cast<uint64_t>(timestampUsec);
+}
+
+void FrameTimestampCalculatorBaseDeviceTime::clear() {
+    prevSrcTsp_  = 0;
+    prevHostTsp_ = 0;
+    baseDevTime_ = 0;
+}
+
+FrameTimestampCalculatorOverMetadata::FrameTimestampCalculatorOverMetadata(IDevice *owner, OBFrameMetadataType metadataType, uint64_t clockFreq)
+    : DeviceComponentBase(owner), metadataType_(metadataType), clockFreq_(clockFreq) {}
+
+void FrameTimestampCalculatorOverMetadata::calculate(std::shared_ptr<Frame> frame) {
+    auto timestamp     = frame->getMetadataValue(metadataType_);
+    auto timestampUsec = static_cast<double>(timestamp) / clockFreq_ * 1000000;
+    frame->setTimeStampUsec(static_cast<uint64_t>(timestampUsec));
+}
+
+void FrameTimestampCalculatorOverMetadata::clear() {}
+
+FrameTimestampCalculatorOverUvcSCR::FrameTimestampCalculatorOverUvcSCR(IDevice *owner, uint64_t clockFreq)
+    : DeviceComponentBase(owner), clockFreq_(clockFreq) {}
+
+void FrameTimestampCalculatorOverUvcSCR::calculate(std::shared_ptr<Frame> frame) {
+    auto     metadata         = frame->getMetadata();
+    auto     uvcPayloadHeader = reinterpret_cast<const StandardUvcFramePayloadHeader *>(metadata);
+    uint32_t low4Bytes        = uvcPayloadHeader->dwPresentationTime;
+    // using the low 4 bytes of scrSourceClock as high 4 bytes of timestamp
+    uint32_t high4Bytes    = *reinterpret_cast<const uint32_t *>(uvcPayloadHeader->scrSourceClock);
+    uint64_t timestamp     = static_cast<uint64_t>(high4Bytes) << 32 | low4Bytes;
+    auto     timestampUsec = static_cast<double>(timestamp) / clockFreq_ * 1000000;
+    frame->setTimeStampUsec(static_cast<uint64_t>(timestampUsec));
+}
+
+void FrameTimestampCalculatorOverUvcSCR::clear() {}
+
+}  // namespace libobsensor
+
diff --git a/src/device/component/timestamp/FrameTimestampCalculator.hpp b/src/device/component/timestamp/FrameTimestampCalculator.hpp
new file mode 100644
index 00000000..2e08a581
--- /dev/null
+++ b/src/device/component/timestamp/FrameTimestampCalculator.hpp
@@ -0,0 +1,87 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include "IFrame.hpp"
+#include "DeviceComponentBase.hpp"
+#include "GlobalTimestampFitter.hpp"
+
+namespace libobsensor {
+class GlobalTimestampCalculator : public IFrameTimestampCalculator, public DeviceComponentBase {
+public:
+    GlobalTimestampCalculator(IDevice *device, uint64_t deviceTimeFreq, uint64_t frameTimeFreq);
+
+    virtual ~GlobalTimestampCalculator() = default;
+
+    void calculate(std::shared_ptr<Frame> frame) override;
+    void clear() override;
+
+private:
+    uint64_t                               deviceTimeFreq_;
+    uint64_t                               frameTimeFreq_;
+    std::shared_ptr<GlobalTimestampFitter> globalTimestampFitter_;
+};
+
+class FrameTimestampCalculatorDirectly : public IFrameTimestampCalculator, public DeviceComponentBase {
+public:
+    FrameTimestampCalculatorDirectly(IDevice *device, uint64_t clockFreq);
+
+    virtual ~FrameTimestampCalculatorDirectly() = default;
+
+    void calculate(std::shared_ptr<Frame> frame) override;
+    void clear() override {}
+
+private:
+    uint64_t clockFreq_;
+};
+
+class FrameTimestampCalculatorBaseDeviceTime : public IFrameTimestampCalculator, public DeviceComponentBase {
+public:
+    FrameTimestampCalculatorBaseDeviceTime(IDevice *device, uint64_t deviceTimeFreq, uint64_t frameTimeFreq);
+
+    virtual ~FrameTimestampCalculatorBaseDeviceTime() = default;
+
+    void calculate(std::shared_ptr<Frame> frame) override;
+    void clear() override;
+
+    uint64_t calculate(uint64_t srcTimestamp);
+
+private:
+    uint64_t deviceTimeFreq_;
+    uint64_t frameTimeFreq_;
+
+    uint64_t prevSrcTsp_;
+    uint64_t prevHostTsp_;
+    uint64_t baseDevTime_;
+};
+
+class FrameTimestampCalculatorOverMetadata : public IFrameTimestampCalculator, public DeviceComponentBase {
+public:
+    FrameTimestampCalculatorOverMetadata(IDevice *device, OBFrameMetadataType metadataType, uint64_t clockFreq);
+
+    virtual ~FrameTimestampCalculatorOverMetadata() = default;
+
+    void calculate(std::shared_ptr<Frame> frame) override;
+    void clear() override;
+
+private:
+    OBFrameMetadataType metadataType_;
+    uint64_t            clockFreq_;
+};
+
+class FrameTimestampCalculatorOverUvcSCR : public IFrameTimestampCalculator, public DeviceComponentBase {
+public:
+    FrameTimestampCalculatorOverUvcSCR(IDevice *device, uint64_t clockFreq);
+
+    virtual ~FrameTimestampCalculatorOverUvcSCR() = default;
+
+    void calculate(std::shared_ptr<Frame> frame) override;
+    void clear() override;
+
+private:
+    uint64_t clockFreq_;
+};
+
+}  // namespace libobsensor
+
diff --git a/src/device/component/timestamp/GlobalTimestampFitter.cpp b/src/device/component/timestamp/GlobalTimestampFitter.cpp
new file mode 100644
index 00000000..6e0a74d1
--- /dev/null
+++ b/src/device/component/timestamp/GlobalTimestampFitter.cpp
@@ -0,0 +1,213 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "GlobalTimestampFitter.hpp"
+#include "utils/Utils.hpp"
+#include "logger/Logger.hpp"
+#include "logger/LoggerInterval.hpp"
+#include "InternalTypes.hpp"
+#include "property/InternalProperty.hpp"
+#include "environment/EnvConfig.hpp"
+
+namespace libobsensor {
+GlobalTimestampFitter::GlobalTimestampFitter(IDevice *owner)
+    : DeviceComponentBase(owner), enable_(false), sampleLoopExit_(false), linearFuncParam_({ 0, 0, 0, 0 }) {
+    auto envConfig = EnvConfig::getInstance();
+    int  value     = 0;
+    if(envConfig->getIntValue("Misc.GlobalTimestampFitterQueueSize", value) && value >= 4) {
+        maxQueueSize_ = value;
+    }
+    value = 0;
+    if(envConfig->getIntValue("Misc.GlobalTimestampFitterInterval", value) && value >= 100) {
+        refreshIntervalMsec_ = value;
+    }
+
+    bool en = false;
+    if(envConfig->getBooleanValue("Misc.GlobalTimestampFitterEnable", en)){
+        enable(en);
+    }
+
+    auto                  propServer = owner->getPropertyServer();
+    std::vector<uint32_t> supportedProps;
+    if(propServer->isPropertySupported(OB_PROP_TIMER_RESET_SIGNAL_BOOL, PROP_OP_WRITE, PROP_ACCESS_INTERNAL)) {
+        supportedProps.push_back(OB_PROP_TIMER_RESET_SIGNAL_BOOL);
+    }
+    if(propServer->isPropertySupported(OB_STRUCT_DEVICE_TIME, PROP_OP_WRITE, PROP_ACCESS_INTERNAL)) {
+        supportedProps.push_back(OB_STRUCT_DEVICE_TIME);
+    }
+    if(!supportedProps.empty()) {
+        propServer->registerAccessCallback(supportedProps, [&](uint32_t, const uint8_t *, size_t, PropertyOperationType operationType) {
+            if(operationType == PROP_OP_WRITE) {
+                reFitting();
+            }
+        });
+    }
+
+    LOG_DEBUG("GlobalTimestampFitter created: maxQueueSize_={}, refreshIntervalMsec_={}", maxQueueSize_, refreshIntervalMsec_);
+}
+
+GlobalTimestampFitter::~GlobalTimestampFitter() {
+    sampleLoopExit_ = true;
+    sampleCondVar_.notify_one();
+    if(sampleThread_.joinable()) {
+        sampleThread_.join();
+    }
+}
+
+LinearFuncParam GlobalTimestampFitter::getLinearFuncParam() {
+    std::unique_lock<std::mutex> lock(linearFuncParamMutex_);
+    return linearFuncParam_;
+}
+
+void GlobalTimestampFitter::reFitting() {
+    std::unique_lock<std::mutex> lock(sampleMutex_);
+    samplingQueue_.clear();
+    sampleCondVar_.notify_one();
+}
+
+void GlobalTimestampFitter::pause() {
+    sampleLoopExit_ = true;
+    sampleCondVar_.notify_one();
+    if(sampleThread_.joinable()) {
+        sampleThread_.join();
+    }
+}
+
+void GlobalTimestampFitter::resume() {
+    if(enable_) {
+        sampleLoopExit_ = false;
+        sampleThread_   = std::thread(&GlobalTimestampFitter::fittingLoop, this);
+    }
+}
+
+void GlobalTimestampFitter::enable(bool en) {
+    if(en == enable_) {
+        return;
+    }
+    enable_ = en;
+    if(enable_) {
+        sampleThread_ = std::thread(&GlobalTimestampFitter::fittingLoop, this);
+        std::unique_lock<std::mutex> lock(linearFuncParamMutex_);
+        linearFuncParamCondVar_.wait_for(lock, std::chrono::milliseconds(1000));
+    }
+    else {
+        sampleLoopExit_ = true;
+        sampleCondVar_.notify_one();
+        if(sampleThread_.joinable()) {
+            sampleThread_.join();
+        }
+        std::unique_lock<std::mutex> lock(sampleMutex_);
+        samplingQueue_.clear();
+    }
+    LOG_DEBUG("GlobalTimestampFitter@{} enable state changed: {}", reinterpret_cast<uint64_t>(this), enable_);
+}
+
+bool GlobalTimestampFitter::isEnabled() const {
+    return enable_;
+}
+
+void GlobalTimestampFitter::fittingLoop() {
+    const int MAX_RETRY_COUNT = 5;
+    const uint64_t MAX_VALID_RTT   = 20000;  // 10ms
+
+    int retryCount = 0;
+    do {
+
+        uint64_t     sysTspUsec = 0;
+        OBDeviceTime devTime;
+
+        try {
+            auto owner          = getOwner();
+            auto propertyServer = owner->getPropertyServer();
+
+            auto sysTsp1Usec = utils::getNowTimesUs();
+            devTime          = propertyServer->getStructureDataT<OBDeviceTime>(OB_STRUCT_DEVICE_TIME);
+            auto sysTsp2Usec = utils::getNowTimesUs();
+            sysTspUsec       = (sysTsp2Usec + sysTsp1Usec) / 2;
+            devTime.rtt      = sysTsp2Usec - sysTsp1Usec;
+            if(devTime.rtt > MAX_VALID_RTT) {
+                LOG_DEBUG("Get device time rtt is too large! rtt={}", devTime.rtt);
+                throw std::runtime_error("RTT too large");
+            }
+            LOG_TRACE("sys={}, dev={}, rtt={}", sysTspUsec, devTime.time, devTime.rtt);
+        }
+        catch(...) {
+            std::this_thread::sleep_for(std::chrono::milliseconds(50));
+            retryCount++;
+            continue;
+        }
+
+        // Successfully obtain timestamp, the number of retries is reset to zero
+        retryCount = 0;
+        {
+            std::unique_lock<std::mutex> lock(sampleMutex_);
+            if(samplingQueue_.size() > maxQueueSize_) {
+                samplingQueue_.pop_front();
+            }
+
+            // Clearing and refitting when the timestamp is out of order
+            if(!samplingQueue_.empty() && (devTime.time < samplingQueue_.back().deviceTimestamp)) {
+                samplingQueue_.clear();
+            }
+
+            samplingQueue_.push_back({ sysTspUsec, devTime.time });
+
+            if(samplingQueue_.size() < 4) {
+                std::this_thread::sleep_for(std::chrono::milliseconds(50));
+                continue;
+            }
+        }
+
+        // Use the first set of data as offset to prevent overflow during calculation
+        uint64_t offset_x = samplingQueue_.front().deviceTimestamp;
+        uint64_t offset_y = samplingQueue_.front().systemTimestamp;
+        double   Ex       = 0;
+        double   Exx      = 0;
+        double   Ey       = 0;
+        double   Exy      = 0;
+        auto     it       = samplingQueue_.begin();
+        while(it != samplingQueue_.end()) {
+            auto systemTimestamp = it->systemTimestamp - offset_y;
+            auto deviceTimestamp = it->deviceTimestamp - offset_x;
+            Ex += deviceTimestamp;
+            Exx += deviceTimestamp * deviceTimestamp;
+            Ey += systemTimestamp;
+            Exy += deviceTimestamp * systemTimestamp;
+            it++;
+        }
+
+        {
+            std::unique_lock<std::mutex> linearFuncParamLock(linearFuncParamMutex_);
+            // Linear regression to find a and b: y=ax+b
+            linearFuncParam_.coefficientA = (Exy * samplingQueue_.size() - Ex * Ey) / (samplingQueue_.size() * Exx - Ex * Ex);
+            linearFuncParam_.constantB  = (Exx * Ey - Exy * Ex) / (samplingQueue_.size() * Exx - Ex * Ex) + offset_y - linearFuncParam_.coefficientA * offset_x;
+            linearFuncParam_.checkDataX = devTime.time;
+            linearFuncParam_.checkDataY = sysTspUsec;
+
+            // auto fixDevTsp = (double)devTime *linearFuncParam_.coefficientA + linearFuncParam_.constantB;
+            // auto fixDiff   = fixDevTsp -sysTspUsec;
+            // LOG_TRACE("a = {}, b = {}, fix={}, diff={}", linearFuncParam_.coefficientA, linearFuncParam_.constantB, fixDevTsp, fixDiff);
+
+            LOG_DEBUG_INTVL("GlobalTimestampFitter update: coefficientA = {}, constantB = {}", linearFuncParam_.coefficientA, linearFuncParam_.constantB);
+            linearFuncParamCondVar_.notify_all();
+        }
+
+        {
+            std::unique_lock<std::mutex> lock(sampleMutex_);
+            auto                         interval = refreshIntervalMsec_;
+            if(samplingQueue_.size() >= 15) {
+                interval *= 10;
+            }
+            sampleCondVar_.wait_for(lock, std::chrono::milliseconds(interval));
+        }
+
+    } while(!sampleLoopExit_ && retryCount <= MAX_RETRY_COUNT);
+
+    if(retryCount > MAX_RETRY_COUNT) {
+        LOG_ERROR("GlobalTimestampFitter fittingLoop retry count exceed max retry count!");
+    }
+
+    LOG_DEBUG("GlobalTimestampFitter fittingLoop exit");
+}
+
+}  // namespace libobsensor
diff --git a/src/device/component/timestamp/GlobalTimestampFitter.hpp b/src/device/component/timestamp/GlobalTimestampFitter.hpp
new file mode 100644
index 00000000..266b6ef5
--- /dev/null
+++ b/src/device/component/timestamp/GlobalTimestampFitter.hpp
@@ -0,0 +1,60 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include "IDevice.hpp"
+#include "DeviceComponentBase.hpp"
+
+#include <thread>
+#include <queue>
+#include <mutex>
+#include <condition_variable>
+
+namespace libobsensor {
+
+// First degree function coefficient y=ax+b
+typedef struct {
+    double   coefficientA;
+    double   constantB;
+    uint64_t checkDataX;
+    uint64_t checkDataY;
+} LinearFuncParam;
+
+class GlobalTimestampFitter : public DeviceComponentBase {
+public:
+    GlobalTimestampFitter(IDevice *owner);
+    ~GlobalTimestampFitter();
+    LinearFuncParam getLinearFuncParam();
+    void            reFitting();
+    void            pause();
+    void            resume();
+
+    void enable(bool en);
+    bool isEnabled() const;
+
+private:
+    void fittingLoop();
+
+private:
+    bool enable_;
+    std::thread             sampleThread_;
+    std::mutex              sampleMutex_;
+    std::condition_variable sampleCondVar_;
+    bool                    sampleLoopExit_;
+
+    typedef struct {
+        uint64_t systemTimestamp;
+        uint64_t deviceTimestamp;
+    } TimestampPair;
+
+    std::deque<TimestampPair> samplingQueue_;
+    uint32_t                  maxQueueSize_ = 100;
+
+    // The refresh interval needs to be less than half the interval of the data frame, that is, it needs to be sampled at least twice within an overflow period.
+    uint32_t refreshIntervalMsec_ = 1000;
+
+    std::mutex              linearFuncParamMutex_;
+    std::condition_variable linearFuncParamCondVar_;
+    LinearFuncParam         linearFuncParam_;
+};
+}  // namespace libobsensor
diff --git a/src/device/context/CMakeLists.txt b/src/device/context/CMakeLists.txt
new file mode 100644
index 00000000..4b19f623
--- /dev/null
+++ b/src/device/context/CMakeLists.txt
@@ -0,0 +1,10 @@
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+cmake_minimum_required(VERSION 3.5)
+
+target_sources(
+    ${OB_TARGET_DEVICE}
+    PRIVATE ${CMAKE_CURRENT_LIST_DIR}/Context.cpp
+            ${CMAKE_CURRENT_LIST_DIR}/Context.hpp
+)
diff --git a/src/device/context/Context.cpp b/src/device/context/Context.cpp
new file mode 100644
index 00000000..c88736d0
--- /dev/null
+++ b/src/device/context/Context.cpp
@@ -0,0 +1,60 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "Context.hpp"
+#include "utils/Utils.hpp"
+#include "devicemanager/DeviceManager.hpp"
+#include "environment/Version.hpp"
+
+#include <mutex>
+
+namespace libobsensor {
+
+std::mutex             Context::instanceMutex_;
+std::weak_ptr<Context> Context::instanceWeakPtr_;
+
+std::shared_ptr<Context> Context::getInstance(const std::string &configPath) {
+    std::unique_lock<std::mutex> lock(instanceMutex_);
+    auto                         ctxInstance = instanceWeakPtr_.lock();
+    if(!ctxInstance) {
+        ctxInstance      = std::shared_ptr<Context>(new Context(configPath));
+        instanceWeakPtr_ = ctxInstance;
+    }
+    return ctxInstance;
+}
+
+Context::Context(const std::string &configFilePath) {
+    envConfig_               = EnvConfig::getInstance(configFilePath);
+    logger_                  = Logger::getInstance();
+    frameMemoryPool_         = FrameMemoryPool::getInstance();
+    streamIntrinsicsManager_ = StreamIntrinsicsManager::getInstance();
+    streamExtrinsicsManager_ = StreamExtrinsicsManager::getInstance();
+    filterFactory_           = FilterFactory::getInstance();
+
+    if(configFilePath.empty()) {
+        LOG_DEBUG("Context created! Library version: v{}", OB_LIB_VERSION_STR);
+    }
+    else {
+        LOG_DEBUG("Context created! Library version: v{}, config file path: {}", OB_LIB_VERSION_STR, configFilePath);
+    }
+}
+
+Context::~Context() noexcept {}
+
+std::shared_ptr<IDeviceManager> Context::getDeviceManager() {
+    if(deviceManager_ == nullptr) {
+        deviceManager_ = DeviceManager::getInstance();
+    }
+    return deviceManager_;
+}
+
+std::shared_ptr<Logger> Context::getLogger() const {
+    return logger_;
+}
+
+std::shared_ptr<FrameMemoryPool> Context::getFrameMemoryPool() const {
+    return frameMemoryPool_;
+}
+
+}  // namespace libobsensor
+
diff --git a/src/device/context/Context.hpp b/src/device/context/Context.hpp
new file mode 100644
index 00000000..cfc00543
--- /dev/null
+++ b/src/device/context/Context.hpp
@@ -0,0 +1,54 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include <memory>
+#include <string>
+#include <mutex>
+#include <memory>
+
+#include "IDeviceManager.hpp"
+#include "logger/Logger.hpp"
+#include "environment/EnvConfig.hpp"
+#include "frame/FrameMemoryPool.hpp"
+#include "stream/StreamIntrinsicsManager.hpp"
+#include "stream/StreamExtrinsicsManager.hpp"
+#include "FilterFactory.hpp"
+
+namespace libobsensor {
+class Context {
+private:
+    explicit Context(const std::string &configFilePath = "");
+
+    static std::mutex             instanceMutex_;
+    static std::weak_ptr<Context> instanceWeakPtr_;
+
+public:
+    ~Context() noexcept;
+
+    static std::shared_ptr<Context> getInstance(const std::string &configPath = "");
+
+    std::shared_ptr<IDeviceManager>  getDeviceManager();
+    std::shared_ptr<Logger>          getLogger() const;
+    std::shared_ptr<FrameMemoryPool> getFrameMemoryPool() const;
+
+private:
+    std::shared_ptr<EnvConfig>               envConfig_;
+    std::shared_ptr<Logger>                  logger_;
+    std::shared_ptr<IDeviceManager>          deviceManager_;
+    std::shared_ptr<FrameMemoryPool>         frameMemoryPool_;
+    std::shared_ptr<StreamIntrinsicsManager> streamIntrinsicsManager_;
+    std::shared_ptr<StreamExtrinsicsManager> streamExtrinsicsManager_;
+    std::shared_ptr<FilterFactory>           filterFactory_;
+};
+}  // namespace libobsensor
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+struct ob_context_t {
+    std::shared_ptr<libobsensor::Context> context;
+};
+#ifdef __cplusplus
+}
+#endif
diff --git a/src/device/devicemanager/CMakeLists.txt b/src/device/devicemanager/CMakeLists.txt
new file mode 100644
index 00000000..a13ab16f
--- /dev/null
+++ b/src/device/devicemanager/CMakeLists.txt
@@ -0,0 +1,25 @@
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+# minimum required cmake version: 3.5 support vs2019
+cmake_minimum_required(VERSION 3.5)
+
+target_sources(
+    ${OB_TARGET_DEVICE} PRIVATE ${CMAKE_CURRENT_LIST_DIR}/DeviceManager.cpp ${CMAKE_CURRENT_LIST_DIR}/DeviceManager.hpp
+                                ${CMAKE_CURRENT_LIST_DIR}/DeviceEnumInfoBase.hpp
+)
+
+if(OB_BUILD_USB_PAL)
+    target_sources(
+        ${OB_TARGET_DEVICE} PRIVATE ${CMAKE_CURRENT_LIST_DIR}/UsbDeviceEnumerator.cpp
+                                    ${CMAKE_CURRENT_LIST_DIR}/UsbDeviceEnumerator.hpp
+    )
+endif()
+
+if(OB_BUILD_NET_PAL)
+    target_sources(
+        ${OB_TARGET_DEVICE} PRIVATE ${CMAKE_CURRENT_LIST_DIR}/NetDeviceEnumerator.cpp
+                                    ${CMAKE_CURRENT_LIST_DIR}/NetDeviceEnumerator.hpp
+    )
+endif()
+
diff --git a/src/device/devicemanager/DeviceEnumInfoBase.hpp b/src/device/devicemanager/DeviceEnumInfoBase.hpp
new file mode 100644
index 00000000..e9550c63
--- /dev/null
+++ b/src/device/devicemanager/DeviceEnumInfoBase.hpp
@@ -0,0 +1,99 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include "IDeviceManager.hpp"
+#include "context/Context.hpp"
+
+#include <string>
+#include <vector>
+#include <memory>
+
+namespace libobsensor {
+
+class DeviceEnumInfoBase : public IDeviceEnumInfo {
+public:
+    DeviceEnumInfoBase(int pid, int vid, const std::string &uid, const std::string &connectionType, const std::string &name, const std::string &deviceSn,
+                       const SourcePortInfoList &sourcePortInfoList)
+        : pid_(pid),
+          vid_(vid),
+          uid_(uid),
+          connectionType_(connectionType),
+          name_(name),
+          deviceSn_(deviceSn),
+          sourcePortInfoList_(sourcePortInfoList),
+          context_(Context::getInstance()) {
+        fullName_ = "Orbbec " + name_;
+    }
+
+    DeviceEnumInfoBase() : pid_(0), vid_(0), context_(Context::getInstance()) {}
+
+    virtual ~DeviceEnumInfoBase() = default;
+
+    int getPid() const override {
+        return pid_;
+    }
+
+    int getVid() const override {
+        return vid_;
+    }
+
+    const std::string &getUid() const override {
+        return uid_;
+    }
+
+    const std::string &getConnectionType() const override {
+        return connectionType_;
+    }
+
+    const std::string &getName() const override {
+        return name_;
+    }
+
+    const std::string &getFullName() const override {
+        return fullName_;
+    }
+
+    const std::string &getDeviceSn() const override {
+        return deviceSn_;
+    }
+
+    const SourcePortInfoList &getSourcePortInfoList() const override {
+        return sourcePortInfoList_;
+    }
+
+    std::shared_ptr<IDeviceManager> getDeviceManager() const override {
+        return context_->getDeviceManager();
+    }
+
+    bool operator==(const IDeviceEnumInfo &other) const override {
+        const auto &otherSourcePortInfoList = other.getSourcePortInfoList();
+
+        bool rst = (other.getUid() == uid_ && otherSourcePortInfoList.size() == sourcePortInfoList_.size());
+        if(rst && connectionType_ == "Ethernet") {
+            auto netPort      = std::dynamic_pointer_cast<const NetSourcePortInfo>(sourcePortInfoList_.front());
+            auto otherNetPort = std::dynamic_pointer_cast<const NetSourcePortInfo>(otherSourcePortInfoList.front());
+            rst &= (otherNetPort->address == netPort->address);
+        }
+        return rst;
+    }
+
+protected:
+    // device identification info
+    int         pid_;
+    int         vid_;
+    std::string uid_;  // Unique identifier of the port the device is connected to (platform specific)
+
+    std::string connectionType_;  // "Ethernet", "USB2.0", "USB3.0", etc.
+
+    // device info
+    std::string name_;
+    std::string fullName_;
+    std::string deviceSn_;
+
+    // source port info list
+    SourcePortInfoList sourcePortInfoList_;
+
+    std::shared_ptr<Context> context_;  // to handle lifespan of the context
+};
+}  // namespace libobsensor
diff --git a/src/device/devicemanager/DeviceManager.cpp b/src/device/devicemanager/DeviceManager.cpp
new file mode 100644
index 00000000..1a990c70
--- /dev/null
+++ b/src/device/devicemanager/DeviceManager.cpp
@@ -0,0 +1,267 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "DeviceManager.hpp"
+#include "utils/Utils.hpp"
+#include "IDeviceClockSynchronizer.hpp"
+
+#if defined(BUILD_USB_PAL)
+#include "UsbDeviceEnumerator.hpp"
+#endif
+
+#if defined(BUILD_NET_PAL)
+#include "NetDeviceEnumerator.hpp"
+#endif
+
+namespace libobsensor {
+
+void printDeviceList(std::string title, const DeviceEnumInfoList &deviceList) {
+    LOG_INFO(title + ": ({})", deviceList.size());
+    for(auto &deviceInfo: deviceList) {
+        if(deviceInfo->getConnectionType() == "Ethernet") {
+            auto netPortInfo = std::dynamic_pointer_cast<const NetSourcePortInfo>(deviceInfo->getSourcePortInfoList().front());
+            LOG_INFO("\t- Name: {0}, PID: 0x{1:04x}, SN/ID: {2}, Connection: {3}, MAC:{4}, ip:{5}", deviceInfo->getName(), deviceInfo->getPid(),
+                     deviceInfo->getDeviceSn(), deviceInfo->getConnectionType(), netPortInfo->mac, netPortInfo->address);
+        }
+        else {
+            LOG_INFO("\t- Name: {0}, PID: 0x{1:04x}, SN/ID: {2}, Connection: {3}", deviceInfo->getName(), deviceInfo->getPid(), deviceInfo->getDeviceSn(),
+                     deviceInfo->getConnectionType());
+        }
+    }
+}
+
+std::weak_ptr<DeviceManager>   DeviceManager::instanceWeakPtr_;
+std::mutex                     DeviceManager::instanceMutex_;
+std::shared_ptr<DeviceManager> DeviceManager::getInstance() {
+    std::unique_lock<std::mutex> lock(instanceMutex_);
+    auto                         instance = instanceWeakPtr_.lock();
+    if(!instance) {
+        instance         = std::shared_ptr<DeviceManager>(new DeviceManager());
+        instanceWeakPtr_ = instance;
+    }
+    return instance;
+}
+
+DeviceManager::DeviceManager() : destroy_(false), multiDeviceSyncIntervalMs_(0) {
+    LOG_DEBUG("DeviceManager init ...");
+
+#if defined(BUILD_USB_PAL)
+    LOG_DEBUG("Enable USB Device Enumerator ...");
+    auto usbDeviceEnumerator =
+        std::make_shared<UsbDeviceEnumerator>([&](const DeviceEnumInfoList &removed, const DeviceEnumInfoList &added) { onDeviceChanged(removed, added); });
+
+    deviceEnumerators_.emplace_back(usbDeviceEnumerator);
+#endif
+
+#if defined(BUILD_NET_PAL)
+    LOG_DEBUG("Enable Net Device Enumerator ...");
+    auto netDeviceEnumerator =
+        std::make_shared<NetDeviceEnumerator>([&](const DeviceEnumInfoList &removed, const DeviceEnumInfoList &added) { onDeviceChanged(removed, added); });
+    deviceEnumerators_.emplace_back(netDeviceEnumerator);
+#endif
+
+    auto deviceInfoList = getDeviceInfoList();
+    printDeviceList("Current found device(s)", deviceInfoList);
+    LOG_DEBUG("DeviceManager construct done!");
+}
+
+DeviceManager::~DeviceManager() noexcept {
+    LOG_DEBUG("DeviceManager destroy ...");
+    destroy_ = true;
+
+    multiDeviceSyncIntervalMs_ = 0;
+    multiDeviceSyncCv_.notify_all();
+    if(multiDeviceSyncThread_.joinable()) {
+        multiDeviceSyncThread_.join();
+    }
+
+    LOG_DEBUG("DeviceManager Destructors done");
+}
+
+std::shared_ptr<IDevice> DeviceManager::createNetDevice(std::string address, uint16_t port) {
+#if defined(BUILD_NET_PAL)
+    LOG_DEBUG("DeviceManager createNetDevice.... address={0}, port={1}", address, port);
+    auto deviceInfo = NetDeviceEnumerator::queryNetDevice(address, port);
+    if(!deviceInfo) {
+        throw libobsensor::invalid_value_exception("Failed to query Net Device, address=" + address + ", port=" + std::to_string(port));
+    }
+    auto device     = createDevice(deviceInfo);
+
+    {
+        std::unique_lock<std::mutex> lock(customConnectedDevicesMutex_);
+        auto                         iter = customConnectedDevices_.find(deviceInfo->getUid());
+        if(iter == customConnectedDevices_.end()) {
+            customConnectedDevices_.insert({ deviceInfo->getUid(), deviceInfo });
+        }
+    }
+
+    return device;
+#else
+    utils::unusedVar(address);
+    utils::unusedVar(port);
+    throw libobsensor::unsupported_operation_exception("The OrbbecSDK library currently compiled does not support network functions."
+                                                       "Please turn on the CMAKE \"BUILD_NET_PAL\" option and recompile.");
+#endif
+}
+
+std::shared_ptr<IDevice> DeviceManager::createDevice(const std::shared_ptr<const IDeviceEnumInfo> &info) {
+    LOG_DEBUG("DeviceManager createDevice...");
+
+    // check if the device has been created
+    {
+        std::unique_lock<std::mutex> lock(createdDevicesMutex_);
+        auto                         iter = createdDevices_.begin();
+        for(; iter != createdDevices_.end(); ++iter) {
+            if(iter->first == info->getUid()) {
+                auto dev = iter->second.lock();
+                if(!dev) {
+                    createdDevices_.erase(iter);
+                    break;
+                }
+                auto devInfo = dev->getInfo();
+                LOG_DEBUG("Device has already been created, return existing device! Name: {0}, PID: 0x{1:04x}, SN/ID: {2}, FW: {3}", devInfo->name_,
+                          devInfo->pid_, devInfo->deviceSn_, devInfo->fwVersion_);
+                return dev;
+            }
+        }
+    }
+
+    // create device
+    auto device = info->createDevice();
+
+    // add to createdDevices_
+    {
+        std::unique_lock<std::mutex> lock(createdDevicesMutex_);
+        createdDevices_.insert({ info->getUid(), device });
+    }
+    auto devInfo = device->getInfo();
+    LOG_INFO("Device created successfully! Name: {0}, PID: 0x{1:04x}, SN/ID: {2} FW: {3}", devInfo->name_, devInfo->pid_, devInfo->deviceSn_,
+             devInfo->fwVersion_);
+    return device;
+}
+
+DeviceEnumInfoList DeviceManager::getDeviceInfoList() {
+    DeviceEnumInfoList deviceInfoList;
+    for(auto &enumerator_: deviceEnumerators_) {
+        auto infos = enumerator_->getDeviceInfoList();
+        deviceInfoList.insert(deviceInfoList.end(), infos.begin(), infos.end());
+    }
+
+    {
+        std::unique_lock<std::mutex> lock(customConnectedDevicesMutex_);
+        std::unique_lock<std::mutex> lock2(createdDevicesMutex_);
+        auto                         customIter = customConnectedDevices_.begin();
+        while(customIter != customConnectedDevices_.end()) {
+            auto createdIter = createdDevices_.find(customIter->first);
+            if(createdIter == createdDevices_.end()) {
+                customIter = customConnectedDevices_.erase(customIter);
+                continue;
+            }
+
+            if(createdIter->second.expired()) {
+                createdDevices_.erase(createdIter);
+                customIter = customConnectedDevices_.erase(customIter);
+                continue;
+            }
+
+            deviceInfoList.push_back(customIter->second);
+            ++customIter;
+        }
+    }
+
+    return deviceInfoList;
+}
+
+void DeviceManager::setDeviceChangedCallback(DeviceChangedCallback callback) {
+    std::unique_lock<std::mutex> lock(callbackMutex_);
+    devChangedCallback_ = callback;
+}
+
+void DeviceManager::onDeviceChanged(const DeviceEnumInfoList &removed, const DeviceEnumInfoList &added) {
+    std::unique_lock<std::mutex> lock(callbackMutex_);
+
+    LOG_INFO("Device changed! removed: {0}, added: {1}", removed.size(), added.size());
+    if(!removed.empty()) {
+        for(const auto &info: removed) {
+            auto iter = createdDevices_.find(info->getUid());
+            if(iter != createdDevices_.end()) {
+                auto dev = iter->second.lock();
+                if(dev) {
+                    dev->deactivate();
+                }
+                createdDevices_.erase(iter);
+            }
+        }
+        printDeviceList("Removed device(s) list", removed);
+    }
+    auto deviceInfoList = getDeviceInfoList();
+    printDeviceList("Current device(s) list", deviceInfoList);
+
+    if(devChangedCallback_) {
+        devChangedCallback_(removed, added);
+    }
+}
+
+void DeviceManager::enableDeviceClockSync(uint64_t repeatInterval) {
+    LOG_DEBUG("Enable multi-device clock sync, repeatInterval={0}ms", repeatInterval);
+
+    // stop previous thread
+    multiDeviceSyncIntervalMs_ = 0;
+    multiDeviceSyncCv_.notify_all();
+    if(multiDeviceSyncThread_.joinable()) {
+        multiDeviceSyncThread_.join();
+    }
+
+    // create new thread
+    multiDeviceSyncIntervalMs_ = repeatInterval;
+    multiDeviceSyncThread_     = std::thread([this]() {
+        do {
+            std::unique_lock<std::mutex> lock(createdDevicesMutex_);
+            if(!destroy_) {
+                for(auto &item: createdDevices_) {
+                    auto dev = item.second.lock();
+                    if(!dev || !dev->isComponentExists(OB_DEV_COMPONENT_DEVICE_CLOCK_SYNCHRONIZER)) {
+                        continue;
+                    }
+                    auto synchronizer = dev->getComponentT<IDeviceClockSynchronizer>(OB_DEV_COMPONENT_DEVICE_CLOCK_SYNCHRONIZER);
+                    TRY_EXECUTE(synchronizer->timerSyncWithHost());
+                }
+            }
+            multiDeviceSyncCv_.wait_for(lock, std::chrono::milliseconds(multiDeviceSyncIntervalMs_));
+        } while(multiDeviceSyncIntervalMs_ > 0 && !destroy_);
+    });
+}
+
+void DeviceManager::enableNetDeviceEnumeration(bool enable) {
+#if defined(BUILD_NET_PAL)
+    LOG_INFO("Enable net device enumeration: {0}", enable);
+    auto iter = std::find_if(deviceEnumerators_.begin(), deviceEnumerators_.end(), [](const std::shared_ptr<IDeviceEnumerator> &enumerator) {  //
+        return std::dynamic_pointer_cast<NetDeviceEnumerator>(enumerator) != nullptr;
+    });
+    if(enable && iter == deviceEnumerators_.end()) {
+        auto netDeviceEnumerator =
+            std::make_shared<NetDeviceEnumerator>([&](DeviceEnumInfoList removed, DeviceEnumInfoList added) { onDeviceChanged(removed, added); });
+        deviceEnumerators_.emplace_back(netDeviceEnumerator);
+        auto deviceInfoList = getDeviceInfoList();
+        printDeviceList("Current device(s) list", deviceInfoList);
+    }
+    else if(!enable && iter != deviceEnumerators_.end()) {
+        deviceEnumerators_.erase(iter);
+    }
+#else
+    utils::unusedVar(enable);
+#endif
+}
+
+bool DeviceManager::isNetDeviceEnumerationEnable() const {
+#if defined(BUILD_NET_PAL)
+
+    auto iter = std::find_if(deviceEnumerators_.begin(), deviceEnumerators_.end(), [](const std::shared_ptr<IDeviceEnumerator> &enumerator) {  //
+        return std::dynamic_pointer_cast<NetDeviceEnumerator>(enumerator) != nullptr;
+    });
+    return iter != deviceEnumerators_.end();
+#endif
+    return false;
+}
+
+}  // namespace libobsensor
diff --git a/src/device/devicemanager/DeviceManager.hpp b/src/device/devicemanager/DeviceManager.hpp
new file mode 100644
index 00000000..3d764712
--- /dev/null
+++ b/src/device/devicemanager/DeviceManager.hpp
@@ -0,0 +1,60 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include "IDeviceManager.hpp"
+
+#include <string>
+#include <vector>
+#include <map>
+#include <mutex>
+#include <thread>
+#include <condition_variable>
+
+namespace libobsensor {
+
+class DeviceManager : public IDeviceManager {
+private:
+    DeviceManager();
+
+    static std::weak_ptr<DeviceManager> instanceWeakPtr_;
+    static std::mutex                   instanceMutex_;
+
+public:
+    static std::shared_ptr<DeviceManager> getInstance();
+    ~DeviceManager() noexcept;
+
+    std::shared_ptr<IDevice> createDevice(const std::shared_ptr<const IDeviceEnumInfo> &info) override;
+    std::shared_ptr<IDevice> createNetDevice(std::string address, uint16_t port) override;
+
+    DeviceEnumInfoList getDeviceInfoList() override;
+    void               setDeviceChangedCallback(DeviceChangedCallback callback) override;
+
+    void enableNetDeviceEnumeration(bool enable) override;
+    bool isNetDeviceEnumerationEnable() const override;
+
+    void enableDeviceClockSync(uint64_t repeatInterval) override;
+
+private:
+    void onDeviceChanged(const DeviceEnumInfoList &removed, const DeviceEnumInfoList &added);
+
+private:
+    bool destroy_;
+
+    std::mutex            callbackMutex_;
+    DeviceChangedCallback devChangedCallback_ = nullptr;
+
+    std::map<std::string, std::weak_ptr<IDevice>> createdDevices_;
+    std::mutex                                    createdDevicesMutex_;
+
+    std::thread             multiDeviceSyncThread_;
+    std::condition_variable multiDeviceSyncCv_;
+    uint64_t                multiDeviceSyncIntervalMs_;  // unit: ms
+
+    std::vector<std::shared_ptr<IDeviceEnumerator>> deviceEnumerators_;
+
+    std::map<std::string, std::shared_ptr<const IDeviceEnumInfo>> customConnectedDevices_;
+    std::mutex                                                    customConnectedDevicesMutex_;
+};
+}  // namespace libobsensor
+
diff --git a/src/device/devicemanager/NetDeviceEnumerator.cpp b/src/device/devicemanager/NetDeviceEnumerator.cpp
new file mode 100644
index 00000000..bcd6ad73
--- /dev/null
+++ b/src/device/devicemanager/NetDeviceEnumerator.cpp
@@ -0,0 +1,182 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "NetDeviceEnumerator.hpp"
+#include "femtomega/FemtoMegaDeviceInfo.hpp"
+#include "gemini2/G2DeviceInfo.hpp"
+#include "ethernet/RTSPStreamPort.hpp"
+#include "ethernet/NetDataStreamPort.hpp"
+#include "property/VendorPropertyAccessor.hpp"
+#include "property/InternalProperty.hpp"
+#include "DevicePids.hpp"
+
+#include "utils/Utils.hpp"
+
+#include <map>
+#include <string>
+
+namespace libobsensor {
+
+NetDeviceEnumerator::NetDeviceEnumerator(DeviceChangedCallback callback) : platform_(Platform::getInstance()), deviceChangedCallback_(callback) {
+    deviceInfoList_ = queryDeviceList();
+    if(!deviceInfoList_.empty()) {
+        LOG_DEBUG("Current net device list: ({})", deviceInfoList_.size());
+        for(auto &&item: deviceInfoList_) {
+            auto firstPortInfo = item->getSourcePortInfoList().front();
+            auto info          = std::dynamic_pointer_cast<const NetSourcePortInfo>(firstPortInfo);
+            LOG_DEBUG("  - Name: {}, PID: 0x{:04X}, SN/ID: {}, MAC:{}, IP:{}", item->getName(), item->getPid(), item->getDeviceSn(), info->mac, info->address);
+        }
+    }
+    else {
+        LOG_DEBUG("No net device found!");
+    }
+
+    deviceWatcher_ = platform_->createNetDeviceWatcher();
+    deviceWatcher_->start([this](OBDeviceChangedType changedType, std::string url) { onPlatformDeviceChanged(changedType, url); });
+}
+
+NetDeviceEnumerator::~NetDeviceEnumerator() noexcept {
+    deviceWatcher_->stop();
+}
+
+DeviceEnumInfoList NetDeviceEnumerator::queryDeviceList() {
+    std::unique_lock<std::recursive_mutex> lock(deviceInfoListMutex_);
+    sourcePortInfoList_.clear();
+    auto portInfoList = platform_->queryNetSourcePort();
+
+    if(portInfoList.empty()) {
+        LOG_DEBUG("No net source port found!");
+        return {};
+    }
+
+    for(const auto &portInfo: portInfoList) {
+        auto info = std::dynamic_pointer_cast<const NetSourcePortInfo>(portInfo);
+        if(info->pid != 0) {
+            sourcePortInfoList_.push_back(info);
+            continue;
+        }
+
+        // try fetch pid from device via vendor property
+        BEGIN_TRY_EXECUTE({
+            auto            port               = platform_->getSourcePort(info);
+            auto            vendorPropAccessor = std::make_shared<VendorPropertyAccessor>(nullptr, port);
+            OBPropertyValue value;
+            value.intValue = 0;
+            vendorPropAccessor->getPropertyValue(OB_PROP_DEVICE_PID_INT, &value);
+            auto newInfo = std::make_shared<NetSourcePortInfo>(info->portType, info->address, info->port, info->mac, info->serialNumber, value.intValue);
+            sourcePortInfoList_.push_back(newInfo);
+        })
+        CATCH_EXCEPTION_AND_LOG(DEBUG, "Get device pid failed! address:{}, port:{}", info->address, info->port);
+    }
+
+    LOG_DEBUG("Current net source port list:");
+    for(const auto &item: sourcePortInfoList_) {
+        auto info = std::dynamic_pointer_cast<const NetSourcePortInfo>(item);
+        LOG_DEBUG(" - mac:{}, ip:{}, port:{}", info->mac, info->address, info->port);
+    }
+    return deviceInfoMatch(sourcePortInfoList_);
+}
+
+DeviceEnumInfoList NetDeviceEnumerator::getDeviceInfoList() {
+    std::unique_lock<std::recursive_mutex> lock(deviceInfoListMutex_);
+    return deviceInfoList_;
+}
+
+DeviceEnumInfoList NetDeviceEnumerator::deviceInfoMatch(const SourcePortInfoList infoList) {
+    DeviceEnumInfoList deviceInfoList;
+    auto               megaDevices = FemtoMegaDeviceInfo::pickNetDevices(infoList);
+    deviceInfoList.insert(deviceInfoList.end(), megaDevices.begin(), megaDevices.end());
+
+    auto g2Devices = G2DeviceInfo::pickNetDevices(infoList);
+    deviceInfoList.insert(deviceInfoList.end(), g2Devices.begin(), g2Devices.end());
+
+    return deviceInfoList;
+}
+
+void NetDeviceEnumerator::setDeviceChangedCallback(DeviceChangedCallback callback) {
+    std::unique_lock<std::mutex> lock(deviceChangedCallbackMutex_);
+    deviceChangedCallback_ = [callback, this](DeviceEnumInfoList removed, DeviceEnumInfoList added) {
+        if(devEnumChangedCallbackThread_.joinable()) {
+            devEnumChangedCallbackThread_.join();
+        }
+        devEnumChangedCallbackThread_ = std::thread(callback, removed, added);
+    };
+}
+
+void NetDeviceEnumerator::onPlatformDeviceChanged(OBDeviceChangedType changeType, std::string devUid) {
+    utils::unusedVar(changeType);
+    utils::unusedVar(devUid);
+
+    DeviceEnumInfoList addDevs;
+    DeviceEnumInfoList rmDevs;
+
+    {
+        auto                                   devices = queryDeviceList();
+        std::unique_lock<std::recursive_mutex> lock(deviceInfoListMutex_);
+        addDevs         = utils ::subtract_sets(devices, deviceInfoList_);
+        rmDevs          = utils ::subtract_sets(deviceInfoList_, devices);
+        deviceInfoList_ = devices;
+    }
+
+    // callback
+    std::unique_lock<std::mutex> lock(deviceChangedCallbackMutex_);
+    if(deviceChangedCallback_ && (!addDevs.empty() || !rmDevs.empty())) {
+        LOG_DEBUG("Net device list changed!");
+        if(!addDevs.empty()) {
+            LOG_DEBUG("{} net device(s) found:", addDevs.size());
+            for(auto &&item: addDevs) {
+                auto firstPortInfo = item->getSourcePortInfoList().front();
+                auto info          = std::dynamic_pointer_cast<const NetSourcePortInfo>(firstPortInfo);
+                LOG_DEBUG("  - Name: {}, PID: 0x{:04X}, SN/ID: {}, MAC:{}, IP:{}", item->getName(), item->getPid(), item->getDeviceSn(), info->mac,
+                          info->address);
+            }
+        }
+
+        if(!rmDevs.empty()) {
+            LOG_DEBUG("{} net device(s) removed:", rmDevs.size());
+            for(auto &&item: rmDevs) {
+                auto firstPortInfo = item->getSourcePortInfoList().front();
+                auto info          = std::dynamic_pointer_cast<const NetSourcePortInfo>(firstPortInfo);
+                LOG_DEBUG("  - Name: {}, PID: 0x{:04X}, SN/ID: {}, MAC:{}, IP:{}", item->getName(), item->getPid(), item->getDeviceSn(), info->mac,
+                          info->address);
+            }
+        }
+
+        LOG_DEBUG("Current net device list: ({})", deviceInfoList_.size());
+        for(auto &&item: deviceInfoList_) {
+            auto firstPortInfo = item->getSourcePortInfoList().front();
+            auto info          = std::dynamic_pointer_cast<const NetSourcePortInfo>(firstPortInfo);
+            LOG_DEBUG("  - Name: {}, PID: 0x{:04X}, SN/ID: {}, MAC:{}, IP:{}", item->getName(), item->getPid(), item->getDeviceSn(), info->mac, info->address);
+        }
+
+        deviceChangedCallback_(rmDevs, addDevs);
+    }
+}
+
+std::shared_ptr<const IDeviceEnumInfo> NetDeviceEnumerator::queryNetDevice(std::string address, uint16_t port) {
+    auto info = std::make_shared<NetSourcePortInfo>(SOURCE_PORT_NET_VENDOR,  //
+                                                    address, static_cast<uint16_t>(8090), address + ":" + std::to_string(port), "Unknown", 0);
+
+    auto sourcePort         = Platform::getInstance()->getNetSourcePort(info);
+    auto vendorPropAccessor = std::make_shared<VendorPropertyAccessor>(nullptr, sourcePort);
+
+    BEGIN_TRY_EXECUTE({
+        OBPropertyValue value;
+        value.intValue = 0;
+        vendorPropAccessor->getPropertyValue(OB_PROP_DEVICE_PID_INT, &value);
+        info->pid = static_cast<uint16_t>(value.intValue);
+    })
+    CATCH_EXCEPTION_AND_EXECUTE({
+        LOG_WARN("Get device pid failed, use default pid as Femto Mega Device! address:{}, port:{}", address, port);
+        info->pid = OB_FEMTO_MEGA_PID;
+    });
+
+    auto deviceEnumInfoList = deviceInfoMatch({ info });
+    if(deviceEnumInfoList.empty()) {
+        throw invalid_value_exception("No supported device found for address: " + address + ":" + std::to_string(port));
+    }
+
+    return deviceEnumInfoList.front();
+}
+
+}  // namespace libobsensor
diff --git a/src/device/devicemanager/NetDeviceEnumerator.hpp b/src/device/devicemanager/NetDeviceEnumerator.hpp
new file mode 100644
index 00000000..9eb59f24
--- /dev/null
+++ b/src/device/devicemanager/NetDeviceEnumerator.hpp
@@ -0,0 +1,39 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include "IDeviceManager.hpp"
+#include "IDeviceWatcher.hpp"
+#include "Platform.hpp"
+
+namespace libobsensor {
+class NetDeviceEnumerator : public IDeviceEnumerator {
+public:
+    NetDeviceEnumerator(DeviceChangedCallback callback);
+    virtual ~NetDeviceEnumerator() noexcept;
+    virtual DeviceEnumInfoList getDeviceInfoList() override;
+    virtual void               setDeviceChangedCallback(DeviceChangedCallback callback) override;
+
+    static std::shared_ptr<const IDeviceEnumInfo> queryNetDevice(std::string address, uint16_t port);
+
+private:
+    static DeviceEnumInfoList deviceInfoMatch(const SourcePortInfoList infoList);
+
+    void               onPlatformDeviceChanged(OBDeviceChangedType changeType, std::string devUid);
+    DeviceEnumInfoList queryDeviceList();
+
+private:
+    std::shared_ptr<Platform> platform_;
+
+    std::mutex            deviceChangedCallbackMutex_;
+    DeviceChangedCallback deviceChangedCallback_;
+    std::thread           devEnumChangedCallbackThread_;
+
+    std::recursive_mutex deviceInfoListMutex_;
+    DeviceEnumInfoList   deviceInfoList_;
+    SourcePortInfoList   sourcePortInfoList_;
+
+    std::shared_ptr<IDeviceWatcher> deviceWatcher_;
+};
+}  // namespace libobsensor
diff --git a/src/device/devicemanager/UsbDeviceEnumerator.cpp b/src/device/devicemanager/UsbDeviceEnumerator.cpp
new file mode 100644
index 00000000..4cff8dc8
--- /dev/null
+++ b/src/device/devicemanager/UsbDeviceEnumerator.cpp
@@ -0,0 +1,264 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "UsbDeviceEnumerator.hpp"
+#include "utils/Utils.hpp"
+
+#include "gemini330/G330DeviceInfo.hpp"
+#include "gemini2/G2DeviceInfo.hpp"
+#include "astra2/Astra2DeviceInfo.hpp"
+#include "femtobolt/FemtoBoltDeviceInfo.hpp"
+#include "femtomega/FemtoMegaDeviceInfo.hpp"
+#include "bootloader/BootDeviceInfo.hpp"
+
+namespace libobsensor {
+UsbDeviceEnumerator::UsbDeviceEnumerator(DeviceChangedCallback callback) : platform_(Platform::getInstance()) {
+    devChangedCallback_ = [callback, this](const DeviceEnumInfoList &removedList, const DeviceEnumInfoList &addedList) {
+        (void)this;
+#ifdef __ANDROID__
+        // On the Android platform, it is necessary to call back to Java in the same thread, and complete the release of relevant resources in the callback
+        // function.
+        callback(removedList, addedList);
+#elif defined(__linux__)
+        // Solve the problem of deadlock caused by multiple callbacks in a short period of time in Linux, and the related interfaces that access libusb are
+        // called in the user callback function.
+        auto cbThread = std::thread(callback, removedList, addedList);
+        cbThread.detach();
+#else
+        // On the WIN platform, since the callback is called by MF-related threads, if the callback is directly made to the user program without switching
+        // threads, the user program needs to update the MFC interface, which will cause the program to crash;
+        if(devChangedCallbackThread_.joinable()) {
+            devChangedCallbackThread_.join();
+        }
+        devChangedCallbackThread_ = std::thread(callback, removedList, addedList);
+#endif
+    };
+
+    deviceInfoList_ = queryArrivalDevice();
+
+    deviceArrivalHandleThread_ = std::thread(&UsbDeviceEnumerator::deviceArrivalHandleThreadFunc, this);
+
+    deviceWatcher_ = platform_->createUsbDeviceWatcher();
+    deviceWatcher_->start([this](OBDeviceChangedType changedType, std::string url) { onPlatformDeviceChanged(changedType, url); });
+
+    std::unique_lock<std::recursive_mutex> lock(deviceInfoListMutex_);
+    if(!deviceInfoList_.empty()) {
+        LOG_DEBUG("Found {} device(s):", deviceInfoList_.size());
+        for(auto &deviceInfo: deviceInfoList_) {
+            LOG_DEBUG("  - Name: {}, PID: 0x{:04X}, SN/ID: {}, connection: {}", deviceInfo->getName(), deviceInfo->getPid(), deviceInfo->getDeviceSn(),
+                      deviceInfo->getConnectionType());
+        }
+    }
+    else {
+        LOG_DEBUG("No matched usb device found!");
+    }
+}
+
+UsbDeviceEnumerator::~UsbDeviceEnumerator() noexcept {
+    destroy_ = true;
+
+    newUsbPortArrivalCV_.notify_all();
+    if(deviceArrivalHandleThread_.joinable()) {
+        deviceArrivalHandleThread_.join();
+    }
+
+    if(devChangedCallbackThread_.joinable()) {
+        devChangedCallbackThread_.join();
+    }
+    deviceWatcher_.reset();  // deviceWatcher should be released before platform_
+    platform_.reset();
+}
+
+void UsbDeviceEnumerator::onPlatformDeviceChanged(OBDeviceChangedType changeType, std::string devUid) {
+    if(changeType == OB_DEVICE_REMOVED) {
+        std::vector<std::shared_ptr<const IDeviceEnumInfo>> removedDevList;
+        {
+            std::unique_lock<std::recursive_mutex> lock(deviceInfoListMutex_);
+            removedDevList = queryRemovedDevice(devUid);
+            for(auto iter = deviceInfoList_.begin(); iter != deviceInfoList_.end();) {
+                if((*iter)->getUid() == devUid) {
+                    iter = deviceInfoList_.erase(iter);
+                }
+                else {
+                    iter++;
+                }
+            }
+        }
+        if(removedDevList.size()) {
+            LOG_DEBUG("device list changed: removed={0}, current={1}", removedDevList.size(), deviceInfoList_.size());
+            if(!removedDevList.empty()) {
+                LOG_DEBUG("Removed device list:");
+                for(auto &deviceInfo: removedDevList) {
+                    LOG_DEBUG("  - Name: {}, PID: 0x{:04X}, SN/ID: {}", deviceInfo->getName(), deviceInfo->getPid(), deviceInfo->getDeviceSn());
+                }
+            }
+            if(!deviceInfoList_.empty()) {
+                LOG_DEBUG("Remained device list:");
+                for(auto &deviceInfo: deviceInfoList_) {
+                    LOG_DEBUG("  - Name: {}, PID: 0x{:04X}, SN/ID: {}", deviceInfo->getName(), deviceInfo->getPid(), deviceInfo->getDeviceSn());
+                }
+            }
+            std::unique_lock<std::mutex> lock(callbackMutex_);
+            if(!destroy_ && devChangedCallback_) {
+                devChangedCallback_(removedDevList, {});
+            }
+        }
+    }
+    else {  // OB_DEVICE_ARRIVAL
+        newUsbPortArrival_ = true;
+        newUsbPortArrivalCV_.notify_all();
+    }
+}
+
+DeviceEnumInfoList UsbDeviceEnumerator::queryRemovedDevice(std::string rmDevUid) {
+    auto portInfoList = currentUsbPortInfoList_;
+    auto iter         = portInfoList.begin();
+    while(iter != portInfoList.end()) {
+        auto portInfo = std::dynamic_pointer_cast<const USBSourcePortInfo>(*iter);
+        if(portInfo->url == rmDevUid || portInfo->infUrl == rmDevUid) {
+            iter = portInfoList.erase(iter);
+            LOG_DEBUG("usb device removed: {}", rmDevUid);
+            continue;
+        }
+        iter++;
+    }
+    LOG_DEBUG("Current usb device port list:");
+    for(const auto &item: portInfoList) {
+        auto portInfo = std::dynamic_pointer_cast<const USBSourcePortInfo>(item);
+        LOG_DEBUG(" - {0} | {1}", portInfo->infUrl, portInfo->infName);
+    }
+
+    std::unique_lock<std::recursive_mutex> lock(deviceInfoListMutex_);
+    if(portInfoList != currentUsbPortInfoList_) {
+        currentUsbPortInfoList_           = portInfoList;
+        DeviceEnumInfoList curList        = usbDeviceInfoMatch(portInfoList);
+        auto               removedDevList = utils::subtract_sets(deviceInfoList_, curList);
+        deviceInfoList_                   = curList;
+        return removedDevList;
+    }
+    return {};
+}
+
+DeviceEnumInfoList UsbDeviceEnumerator::queryArrivalDevice() {
+    std::unique_lock<std::recursive_mutex> lock(deviceInfoListMutex_);
+    auto                                   portInfoList = platform_->queryUsbSourcePortInfos();
+    if(portInfoList != currentUsbPortInfoList_) {
+        currentUsbPortInfoList_ = portInfoList;
+        LOG_DEBUG("Current usb device port list:");
+        for(const auto &item: currentUsbPortInfoList_) {
+            auto portInfo = std::dynamic_pointer_cast<const USBSourcePortInfo>(item);
+            LOG_DEBUG(" - {0} | {1}", portInfo->infUrl, portInfo->infName);
+        }
+        DeviceEnumInfoList curList = usbDeviceInfoMatch(portInfoList);
+        return utils::subtract_sets(curList, deviceInfoList_);
+    }
+    return {};
+}
+
+DeviceEnumInfoList UsbDeviceEnumerator::usbDeviceInfoMatch(const SourcePortInfoList portInfoList) {
+    DeviceEnumInfoList deviceInfoList;
+    auto               g330Devs = G330DeviceInfo::pickDevices(portInfoList);
+    std::copy(g330Devs.begin(), g330Devs.end(), std::back_inserter(deviceInfoList));
+
+    auto g2Devs = G2DeviceInfo::pickDevices(portInfoList);
+    std::copy(g2Devs.begin(), g2Devs.end(), std::back_inserter(deviceInfoList));
+
+    auto a2Devs = Astra2DeviceInfo::pickDevices(portInfoList);
+    std::copy(a2Devs.begin(), a2Devs.end(), std::back_inserter(deviceInfoList));
+
+    auto femtoBoltDevs = FemtoBoltDeviceInfo::pickDevices(portInfoList);
+    std::copy(femtoBoltDevs.begin(), femtoBoltDevs.end(), std::back_inserter(deviceInfoList));
+
+    auto femtoMegaDevs = FemtoMegaDeviceInfo::pickDevices(portInfoList);
+    std::copy(femtoMegaDevs.begin(), femtoMegaDevs.end(), std::back_inserter(deviceInfoList));
+
+    auto bootDevs = BootDeviceInfo::pickDevices(portInfoList);
+    std::copy(bootDevs.begin(), bootDevs.end(), std::back_inserter(deviceInfoList));
+
+    return deviceInfoList;
+}
+
+void UsbDeviceEnumerator::deviceArrivalHandleThreadFunc() {
+    std::mutex                   mtx;
+    std::unique_lock<std::mutex> lk(mtx);
+    while(!destroy_) {
+        newUsbPortArrivalCV_.wait(lk, [&]() { return newUsbPortArrival_ || destroy_; });
+        if(destroy_) {
+            break;
+        }
+        uint16_t delayTime = 1000;
+#ifdef OS_MACOS
+        delayTime = 3000;
+#endif
+        do {
+            newUsbPortArrival_ = false;
+            newUsbPortArrivalCV_.wait_for(lk, std::chrono::milliseconds(delayTime));
+        } while(!destroy_ && newUsbPortArrival_);
+
+        if(destroy_) {
+            break;
+        }
+        DeviceEnumInfoList addedDevList;
+        {
+            std::unique_lock<std::recursive_mutex> lock(deviceInfoListMutex_);
+
+            addedDevList = queryArrivalDevice();
+            for(auto &item: addedDevList) {
+                deviceInfoList_.emplace_back(item);
+            }
+        }
+
+        if(!addedDevList.empty()) {
+            LOG_DEBUG("device list changed: added={0}, current={1}", addedDevList.size(), deviceInfoList_.size());
+            if(!deviceInfoList_.empty()) {
+                LOG_DEBUG("Current device list: ");
+                for(auto &deviceInfo: deviceInfoList_) {
+                    LOG_DEBUG("  - Name: {}, PID: 0x{:04X}, SN/ID: {}", deviceInfo->getName(), deviceInfo->getPid(), deviceInfo->getDeviceSn());
+                }
+            }
+            std::unique_lock<std::mutex> lock(callbackMutex_);
+            if(!destroy_ && devChangedCallback_) {
+                devChangedCallback_({}, addedDevList);
+            }
+        }
+    }
+}
+
+DeviceEnumInfoList UsbDeviceEnumerator::getDeviceInfoList() {
+    std::unique_lock<std::recursive_mutex> lock(deviceInfoListMutex_);
+    return deviceInfoList_;
+}
+
+void UsbDeviceEnumerator::setDeviceChangedCallback(DeviceChangedCallback callback) {
+    std::unique_lock<std::mutex> lock(callbackMutex_);
+    devChangedCallback_ = [callback, this](const DeviceEnumInfoList &removedList, const DeviceEnumInfoList &addedList) {
+        (void)this;
+#ifdef __ANDROID__
+        // On the Android platform, it is necessary to call back to Java in the same thread, and complete the release of relevant resources in the callback
+        // function.
+        callback(removedList, addedList);
+#elif defined(__linux__)
+        // Solve the problem of deadlock caused by multiple callbacks in a short period of time in Linux, and the related interfaces that access libusb are
+        // called in the user callback function.
+        auto cbThread = std::thread(callback, removedList, addedList);
+        cbThread.detach();
+#else
+        // On the WIN platform, since the callback is called by MF-related threads, if the callback is directly made to the user program without switching
+        // threads, the user program needs to update the MFC interface, which will cause the program to crash;
+
+        if(devChangedCallbackThread_.joinable()) {
+            devChangedCallbackThread_.join();
+        }
+        // auto cb = [this, removedList, addedList](){
+        //     LOG_ERROR("device changed callback begin";
+        //     callback(removedList, addedList);
+        //     LOG_ERROR("device changed callback end";
+        // };
+        // devChangedCallbackThread_ = std::thread(cb);
+        devChangedCallbackThread_ = std::thread(callback, removedList, addedList);
+#endif
+    };
+}
+
+}  // namespace libobsensor
+
diff --git a/src/device/devicemanager/UsbDeviceEnumerator.hpp b/src/device/devicemanager/UsbDeviceEnumerator.hpp
new file mode 100644
index 00000000..c7e507b8
--- /dev/null
+++ b/src/device/devicemanager/UsbDeviceEnumerator.hpp
@@ -0,0 +1,47 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include "IDeviceManager.hpp"
+#include "IDeviceWatcher.hpp"
+#include "Platform.hpp"
+
+#include <memory>
+
+namespace libobsensor {
+class UsbDeviceEnumerator : public IDeviceEnumerator, public std::enable_shared_from_this<IDeviceEnumerator> {
+public:
+    UsbDeviceEnumerator(DeviceChangedCallback callback);
+    ~UsbDeviceEnumerator() noexcept override;
+    DeviceEnumInfoList       getDeviceInfoList() override;
+    void                     setDeviceChangedCallback(DeviceChangedCallback callback) override;
+
+private:
+    void               onPlatformDeviceChanged(OBDeviceChangedType changeType, std::string devUid);
+    DeviceEnumInfoList queryRemovedDevice(std::string rmDevUid);
+    DeviceEnumInfoList queryArrivalDevice();
+
+    void deviceArrivalHandleThreadFunc();
+
+    static DeviceEnumInfoList usbDeviceInfoMatch(const SourcePortInfoList infoList);
+
+private:
+    std::shared_ptr<Platform> platform_;
+    bool                   destroy_ = false;
+
+    std::shared_ptr<IDeviceWatcher> deviceWatcher_;
+
+    DeviceChangedCallback devChangedCallback_ = nullptr;
+    std::thread           devChangedCallbackThread_;
+
+    SourcePortInfoList      currentUsbPortInfoList_;
+    bool                    newUsbPortArrival_ = false;
+    std::condition_variable newUsbPortArrivalCV_;
+    std::thread             deviceArrivalHandleThread_;
+
+    DeviceEnumInfoList   deviceInfoList_;
+    std::recursive_mutex deviceInfoListMutex_;
+
+    std::mutex callbackMutex_;
+};
+}  // namespace libobsensor
diff --git a/src/device/femtobolt/CMakeLists.txt b/src/device/femtobolt/CMakeLists.txt
new file mode 100644
index 00000000..879f9482
--- /dev/null
+++ b/src/device/femtobolt/CMakeLists.txt
@@ -0,0 +1,18 @@
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+cmake_minimum_required(VERSION 3.5)
+
+target_sources(
+    ${OB_TARGET_DEVICE}
+    PRIVATE  ${CMAKE_CURRENT_LIST_DIR}/FemtoBoltDevice.hpp
+             ${CMAKE_CURRENT_LIST_DIR}/FemtoBoltDevice.cpp
+             ${CMAKE_CURRENT_LIST_DIR}/FemtoBoltDeviceInfo.hpp
+             ${CMAKE_CURRENT_LIST_DIR}/FemtoBoltDeviceInfo.cpp
+             ${CMAKE_CURRENT_LIST_DIR}/FemtoBoltPropertyAccessor.hpp
+             ${CMAKE_CURRENT_LIST_DIR}/FemtoBoltPropertyAccessor.cpp
+             ${CMAKE_CURRENT_LIST_DIR}/FemtoBoltAlgParamManager.hpp
+             ${CMAKE_CURRENT_LIST_DIR}/FemtoBoltAlgParamManager.cpp
+        )
+
+add_subdirectory(rawphase)
diff --git a/src/device/femtobolt/FemtoBoltAlgParamManager.cpp b/src/device/femtobolt/FemtoBoltAlgParamManager.cpp
new file mode 100644
index 00000000..7750968b
--- /dev/null
+++ b/src/device/femtobolt/FemtoBoltAlgParamManager.cpp
@@ -0,0 +1,25 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "FemtoBoltAlgParamManager.hpp"
+
+namespace libobsensor {
+
+FemtoBoltAlgParamManager::FemtoBoltAlgParamManager(IDevice *owner) : TOFDeviceCommonAlgParamManager(owner) {
+    fixD2CProfile();
+}
+
+void FemtoBoltAlgParamManager::fixD2CProfile() {
+    for(auto item: d2cProfileList_) {
+        if(item.alignType == ALIGN_D2C_SW) {
+            fixedD2CProfile_.emplace_back(item);
+        }
+    }
+}
+
+const std::vector<OBD2CProfile> &FemtoBoltAlgParamManager::getD2CProfileList() const {
+    return fixedD2CProfile_;
+}
+
+}  // namespace libobsensor
+
diff --git a/src/device/femtobolt/FemtoBoltAlgParamManager.hpp b/src/device/femtobolt/FemtoBoltAlgParamManager.hpp
new file mode 100644
index 00000000..d0744f19
--- /dev/null
+++ b/src/device/femtobolt/FemtoBoltAlgParamManager.hpp
@@ -0,0 +1,22 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "param/AlgParamManager.hpp"
+
+namespace libobsensor {
+
+class FemtoBoltAlgParamManager : public TOFDeviceCommonAlgParamManager {
+public:
+    FemtoBoltAlgParamManager(IDevice *owner);
+    ~FemtoBoltAlgParamManager() = default;
+
+    const std::vector<OBD2CProfile> &getD2CProfileList() const override;
+
+private:
+    void fixD2CProfile();
+
+private:
+    std::vector<OBD2CProfile> fixedD2CProfile_;
+};
+
+}  // namespace libobsensor
diff --git a/src/device/femtobolt/FemtoBoltDevice.cpp b/src/device/femtobolt/FemtoBoltDevice.cpp
new file mode 100644
index 00000000..760e708e
--- /dev/null
+++ b/src/device/femtobolt/FemtoBoltDevice.cpp
@@ -0,0 +1,424 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "FemtoBoltDevice.hpp"
+#include "Platform.hpp"
+#include "FemtoBoltPropertyAccessor.hpp"
+#include "environment/EnvConfig.hpp"
+#include "stream/StreamProfileFactory.hpp"
+#include "sensor/video/VideoSensor.hpp"
+#include "sensor/video/DisparityBasedSensor.hpp"
+#include "sensor/imu/ImuStreamer.hpp"
+#include "sensor/imu/AccelSensor.hpp"
+#include "sensor/imu/GyroSensor.hpp"
+#include "usb/uvc/UvcDevicePort.hpp"
+#include "FilterFactory.hpp"
+
+#include "metadata/FrameMetadataParserContainer.hpp"
+#include "timestamp/GlobalTimestampFitter.hpp"
+#include "timestamp/FrameTimestampCalculator.hpp"
+#include "timestamp/DeviceClockSynchronizer.hpp"
+#include "property/VendorPropertyAccessor.hpp"
+#include "property/UvcPropertyAccessor.hpp"
+#include "property/PropertyServer.hpp"
+#include "property/CommonPropertyAccessors.hpp"
+#include "property/FilterPropertyAccessors.hpp"
+#include "property/PrivateFilterPropertyAccessors.hpp"
+#include "monitor/DeviceMonitor.hpp"
+#include "FemtoBoltAlgParamManager.hpp"
+#include "syncconfig/DeviceSyncConfigurator.hpp"
+
+#include "rawphase/RawPhaseStreamer.hpp"
+#include "rawphase/RawPhaseBasedSensor.hpp"
+
+#include "publicfilters/FormatConverterProcess.hpp"
+#include "publicfilters/IMUCorrector.hpp"
+
+namespace libobsensor {
+
+FemtoBoltDevice::FemtoBoltDevice(const std::shared_ptr<const IDeviceEnumInfo> &info) : DeviceBase(info) {
+    init();
+}
+
+FemtoBoltDevice::~FemtoBoltDevice() noexcept {}
+
+void FemtoBoltDevice::init() {
+    initSensorList();
+    initProperties();
+
+    fetchDeviceInfo();
+    fetchExtensionInfo();
+
+    if(getFirmwareVersionInt() >= 10101) {
+        deviceTimeFreq_ = 1000000;
+        frameTimeFreq_  = 1000000;
+    }
+
+    auto globalTimestampFilter = std::make_shared<GlobalTimestampFitter>(this);
+    registerComponent(OB_DEV_COMPONENT_GLOBAL_TIMESTAMP_FILTER, globalTimestampFilter);
+
+    auto algParamManager = std::make_shared<FemtoBoltAlgParamManager>(this);
+    registerComponent(OB_DEV_COMPONENT_ALG_PARAM_MANAGER, algParamManager);
+
+    static const std::vector<OBMultiDeviceSyncMode>          supportedSyncModes  = { OB_MULTI_DEVICE_SYNC_MODE_FREE_RUN, OB_MULTI_DEVICE_SYNC_MODE_STANDALONE,
+                                                                                     OB_MULTI_DEVICE_SYNC_MODE_PRIMARY, OB_MULTI_DEVICE_SYNC_MODE_SECONDARY };
+    static const std::map<OBMultiDeviceSyncMode, OBSyncMode> syncModeNewToOldMap = { { OB_MULTI_DEVICE_SYNC_MODE_FREE_RUN, OB_SYNC_MODE_CLOSE },
+                                                                                     { OB_MULTI_DEVICE_SYNC_MODE_STANDALONE, OB_SYNC_MODE_STANDALONE },
+                                                                                     { OB_MULTI_DEVICE_SYNC_MODE_PRIMARY, OB_SYNC_MODE_PRIMARY_MCU_TRIGGER },
+                                                                                     { OB_MULTI_DEVICE_SYNC_MODE_SECONDARY, OB_SYNC_MODE_SECONDARY },
+                                                                                     { OB_MULTI_DEVICE_SYNC_MODE_SECONDARY_SYNCED, OB_SYNC_MODE_SECONDARY } };
+    static const std::map<OBSyncMode, OBMultiDeviceSyncMode> syncModeOldToNewMap = { { OB_SYNC_MODE_CLOSE, OB_MULTI_DEVICE_SYNC_MODE_FREE_RUN },
+                                                                                     { OB_SYNC_MODE_STANDALONE, OB_MULTI_DEVICE_SYNC_MODE_STANDALONE },
+                                                                                     { OB_SYNC_MODE_PRIMARY_MCU_TRIGGER, OB_MULTI_DEVICE_SYNC_MODE_PRIMARY },
+                                                                                     { OB_SYNC_MODE_SECONDARY, OB_MULTI_DEVICE_SYNC_MODE_SECONDARY } };
+    auto deviceSyncConfigurator = std::make_shared<DeviceSyncConfiguratorOldProtocol>(this, supportedSyncModes);
+    deviceSyncConfigurator->updateModeAliasMap(syncModeOldToNewMap, syncModeNewToOldMap);
+    registerComponent(OB_DEV_COMPONENT_DEVICE_SYNC_CONFIGURATOR, deviceSyncConfigurator);
+
+    auto deviceClockSynchronizer = std::make_shared<DeviceClockSynchronizer>(this, deviceTimeFreq_, deviceTimeFreq_);
+    registerComponent(OB_DEV_COMPONENT_DEVICE_CLOCK_SYNCHRONIZER, deviceClockSynchronizer);
+}
+
+void FemtoBoltDevice::initSensorStreamProfile(std::shared_ptr<ISensor> sensor) {
+    auto sensorType    = sensor->getSensorType();
+    auto streamProfile = StreamProfileFactory::getDefaultStreamProfileFromEnvConfig(deviceInfo_->name_, sensorType);
+    if(streamProfile) {
+        sensor->updateDefaultStreamProfile(streamProfile);
+    }
+
+    // // bind params: extrinsics, intrinsics, etc.
+    auto profiles = sensor->getStreamProfileList();
+    {
+        auto algParamManager = getComponentT<FemtoBoltAlgParamManager>(OB_DEV_COMPONENT_ALG_PARAM_MANAGER);
+        algParamManager->bindStreamProfileParams(profiles);
+    }
+
+    LOG_INFO("Sensor {} created! Found {} stream profiles.", sensorType, profiles.size());
+    for(auto &profile: profiles) {
+        LOG_INFO(" - {}", profile);
+    }
+}
+
+void FemtoBoltDevice::initSensorList() {
+    registerComponent(OB_DEV_COMPONENT_FRAME_PROCESSOR_FACTORY, [this]() {
+        std::shared_ptr<FrameProcessorFactory> factory;
+        TRY_EXECUTE({ factory = std::make_shared<FrameProcessorFactory>(this); })
+        return factory;
+    });
+    auto        platform           = Platform::getInstance();
+    const auto &sourcePortInfoList = enumInfo_->getSourcePortInfoList();
+    auto depthPortInfoIter = std::find_if(sourcePortInfoList.begin(), sourcePortInfoList.end(), [](const std::shared_ptr<const SourcePortInfo> &portInfo) {
+        return portInfo->portType == SOURCE_PORT_USB_UVC && std::dynamic_pointer_cast<const USBSourcePortInfo>(portInfo)->infIndex == 2;
+    });
+
+    if(depthPortInfoIter != sourcePortInfoList.end()) {
+        auto depthPortInfo = *depthPortInfoIter;
+        registerComponent(OB_DEV_COMPONENT_RAW_PHASE_STREAMER, [this, depthPortInfo]() {
+            auto platform = Platform::getInstance();
+            auto port     = platform->getSourcePort(depthPortInfo);
+
+            auto                              dataStreamPort = std::dynamic_pointer_cast<IVideoStreamPort>(port);
+            std::shared_ptr<RawPhaseStreamer> rawPhaseStreamer;
+            BEGIN_TRY_EXECUTE({ rawPhaseStreamer = std::make_shared<RawPhaseStreamer>(this, dataStreamPort); })
+            CATCH_EXCEPTION_AND_LOG(WARN, "create RawPhaseStreamer failed.")
+
+            return rawPhaseStreamer;
+        });
+        registerComponent(
+            OB_DEV_COMPONENT_DEPTH_SENSOR,
+            [this, depthPortInfo]() {
+                auto rawPhaseStreamer = getComponentT<RawPhaseStreamer>(OB_DEV_COMPONENT_RAW_PHASE_STREAMER);
+                rawPhaseStreamer->waitNvramDataReady();
+                auto sensor = std::make_shared<RawPhaseBasedSensor>(this, OB_SENSOR_DEPTH, rawPhaseStreamer.get());
+
+                auto videoFrameTimestampCalculator = std::make_shared<FrameTimestampCalculatorOverUvcSCR>(this, frameTimeFreq_);
+                sensor->setFrameTimestampCalculator(videoFrameTimestampCalculator);
+
+                auto globalFrameTimestampCalculator = std::make_shared<GlobalTimestampCalculator>(this, deviceTimeFreq_, frameTimeFreq_);
+                sensor->setGlobalTimestampCalculator(globalFrameTimestampCalculator);
+
+                // auto frameProcessor = getComponentT<FrameProcessor>(OB_DEV_COMPONENT_DEPTH_FRAME_PROCESSOR, false);
+                // if(frameProcessor) {
+                //     sensor->setFrameProcessor(frameProcessor.get());
+                // }
+
+                auto propServer     = getPropertyServer();
+                auto passiveIrValue = propServer->getPropertyValueT<int>(OB_PROP_SWITCH_IR_MODE_INT);
+                rawPhaseStreamer->enablePassiveIRMode(static_cast<bool>(passiveIrValue));
+
+                initSensorStreamProfile(sensor);
+                return sensor;
+            },
+            true);
+
+        registerSensorPortInfo(OB_SENSOR_DEPTH, depthPortInfo);
+
+        registerComponent(OB_DEV_COMPONENT_DEPTH_FRAME_PROCESSOR, [this]() {
+            auto factory = getComponentT<FrameProcessorFactory>(OB_DEV_COMPONENT_FRAME_PROCESSOR_FACTORY);
+
+            auto frameProcessor = factory->createFrameProcessor(OB_SENSOR_DEPTH);
+            return frameProcessor;
+        });
+
+        registerComponent(
+            OB_DEV_COMPONENT_IR_SENSOR,
+            [this, depthPortInfo]() {
+                auto rawPhaseStreamer = getComponentT<RawPhaseStreamer>(OB_DEV_COMPONENT_RAW_PHASE_STREAMER);
+                rawPhaseStreamer->waitNvramDataReady();
+                auto sensor = std::make_shared<RawPhaseBasedSensor>(this, OB_SENSOR_IR, rawPhaseStreamer.get());
+
+                auto videoFrameTimestampCalculator = std::make_shared<FrameTimestampCalculatorOverUvcSCR>(this, frameTimeFreq_);
+                sensor->setFrameTimestampCalculator(videoFrameTimestampCalculator);
+
+                auto globalFrameTimestampCalculator = std::make_shared<GlobalTimestampCalculator>(this, deviceTimeFreq_, frameTimeFreq_);
+                sensor->setGlobalTimestampCalculator(globalFrameTimestampCalculator);
+
+                // auto frameProcessor = getComponentT<FrameProcessor>(OB_DEV_COMPONENT_DEPTH_FRAME_PROCESSOR, false);
+                // if(frameProcessor) {
+                //     sensor->setFrameProcessor(frameProcessor.get());
+                // }
+
+                initSensorStreamProfile(sensor);
+                return sensor;
+            },
+            true);
+        registerSensorPortInfo(OB_SENSOR_IR, depthPortInfo);
+
+        registerComponent(OB_DEV_COMPONENT_IR_FRAME_PROCESSOR, [this]() {
+            auto factory = getComponentT<FrameProcessorFactory>(OB_DEV_COMPONENT_FRAME_PROCESSOR_FACTORY);
+
+            auto frameProcessor = factory->createFrameProcessor(OB_SENSOR_IR);
+            return frameProcessor;
+        });
+
+        // the main property accessor is using the depth port(uvc xu)
+        registerComponent(OB_DEV_COMPONENT_MAIN_PROPERTY_ACCESSOR, [this, depthPortInfo]() {
+            auto platform = Platform::getInstance();
+            auto port     = platform->getSourcePort(depthPortInfo);
+            auto accessor = std::make_shared<VendorPropertyAccessor>(this, port);
+            return accessor;
+        });
+
+        // The device monitor is using the depth port(uvc xu)
+        registerComponent(OB_DEV_COMPONENT_DEVICE_MONITOR, [this, depthPortInfo]() {
+            auto platform      = Platform::getInstance();
+            auto port          = platform->getSourcePort(depthPortInfo);
+            auto uvcDevicePort = std::dynamic_pointer_cast<UvcDevicePort>(port);
+            auto devMonitor    = std::make_shared<DeviceMonitor>(this, port);
+            return devMonitor;
+        });
+    }
+
+    auto colorPortInfoIter = std::find_if(sourcePortInfoList.begin(), sourcePortInfoList.end(), [](const std::shared_ptr<const SourcePortInfo> &portInfo) {
+        return portInfo->portType == SOURCE_PORT_USB_UVC && std::dynamic_pointer_cast<const USBSourcePortInfo>(portInfo)->infIndex == 0;
+    });
+
+    if(colorPortInfoIter != sourcePortInfoList.end()) {
+        auto colorPortInfo = *colorPortInfoIter;
+        registerComponent(
+            OB_DEV_COMPONENT_COLOR_SENSOR,
+            [this, colorPortInfo]() {
+                auto platform = Platform::getInstance();
+                auto port     = platform->getSourcePort(colorPortInfo);
+                auto sensor   = std::make_shared<VideoSensor>(this, OB_SENSOR_COLOR, port);
+
+                std::vector<FormatFilterConfig> formatFilterConfigs = {};
+                auto                            formatConverter     = getSensorFrameFilter("FormatConverter", OB_SENSOR_COLOR, false);
+                if(formatConverter) {
+#ifdef WIN32
+                    formatFilterConfigs.push_back({ FormatFilterPolicy::ADD, OB_FORMAT_BGR, OB_FORMAT_RGB, formatConverter });
+#else
+                    formatFilterConfigs.push_back({ FormatFilterPolicy::ADD, OB_FORMAT_MJPG, OB_FORMAT_RGB, formatConverter });
+                    formatFilterConfigs.push_back({ FormatFilterPolicy::ADD, OB_FORMAT_MJPG, OB_FORMAT_BGR, formatConverter });
+                    formatFilterConfigs.push_back({ FormatFilterPolicy::ADD, OB_FORMAT_MJPG, OB_FORMAT_BGRA, formatConverter });
+                    formatFilterConfigs.push_back({ FormatFilterPolicy::ADD, OB_FORMAT_MJPG, OB_FORMAT_NV12, formatConverter });
+#endif
+                }
+                sensor->updateFormatFilterConfig(formatFilterConfigs);
+
+                auto videoFrameTimestampCalculator = std::make_shared<FrameTimestampCalculatorOverUvcSCR>(this, frameTimeFreq_);
+                sensor->setFrameTimestampCalculator(videoFrameTimestampCalculator);
+
+                auto globalFrameTimestampCalculator = std::make_shared<GlobalTimestampCalculator>(this, deviceTimeFreq_, frameTimeFreq_);
+                sensor->setGlobalTimestampCalculator(globalFrameTimestampCalculator);
+
+                auto frameProcessor = getComponentT<FrameProcessor>(OB_DEV_COMPONENT_COLOR_FRAME_PROCESSOR, false);
+                if(frameProcessor) {
+                    sensor->setFrameProcessor(frameProcessor.get());
+                }
+
+                initSensorStreamProfile(sensor);
+
+                return sensor;
+            },
+            true);
+        registerSensorPortInfo(OB_SENSOR_COLOR, colorPortInfo);
+
+        registerComponent(OB_DEV_COMPONENT_COLOR_FRAME_PROCESSOR, [this]() {
+            auto factory        = getComponentT<FrameProcessorFactory>(OB_DEV_COMPONENT_FRAME_PROCESSOR_FACTORY);
+            auto frameProcessor = factory->createFrameProcessor(OB_SENSOR_COLOR);
+            return frameProcessor;
+        });
+    }
+
+    auto imuPortInfoIter = std::find_if(sourcePortInfoList.begin(), sourcePortInfoList.end(),
+                                        [](const std::shared_ptr<const SourcePortInfo> &portInfo) { return portInfo->portType == SOURCE_PORT_USB_HID; });
+
+    if(imuPortInfoIter != sourcePortInfoList.end()) {
+        auto imuPortInfo = *imuPortInfoIter;
+        registerComponent(OB_DEV_COMPONENT_IMU_STREAMER, [this, imuPortInfo]() {
+            // the gyro and accel are both on the same port and share the same filter
+            auto                                  platform           = Platform::getInstance();
+            auto                                  port               = platform->getSourcePort(imuPortInfo);
+            auto                                  imuReversionFilter = getSensorFrameFilter("IMUFrameReversion", OB_SENSOR_ACCEL, true);
+            auto                                  imuCorrectorFilter = getSensorFrameFilter("IMUCorrector", OB_SENSOR_ACCEL, true);
+            std::vector<std::shared_ptr<IFilter>> imuFilters         = { imuReversionFilter, imuCorrectorFilter };
+            auto                                  dataStreamPort     = std::dynamic_pointer_cast<IDataStreamPort>(port);
+            auto                                  imuStreamer        = std::make_shared<ImuStreamer>(this, dataStreamPort, imuFilters);
+            return imuStreamer;
+        });
+
+        registerComponent(
+            OB_DEV_COMPONENT_ACCEL_SENSOR,
+            [this, imuPortInfo]() {
+                auto platform             = Platform::getInstance();
+                auto port                 = platform->getSourcePort(imuPortInfo);
+                auto imuStreamer          = getComponentT<ImuStreamer>(OB_DEV_COMPONENT_IMU_STREAMER);
+                auto imuStreamerSharedPtr = imuStreamer.get();
+                auto sensor               = std::make_shared<AccelSensor>(this, port, imuStreamerSharedPtr);
+
+                auto globalFrameTimestampCalculator = std::make_shared<GlobalTimestampCalculator>(this, deviceTimeFreq_, frameTimeFreq_);
+                sensor->setGlobalTimestampCalculator(globalFrameTimestampCalculator);
+
+                initSensorStreamProfile(sensor);
+
+                return sensor;
+            },
+            true);
+        registerSensorPortInfo(OB_SENSOR_ACCEL, imuPortInfo);
+
+        registerComponent(
+            OB_DEV_COMPONENT_GYRO_SENSOR,
+            [this, imuPortInfo]() {
+                auto platform             = Platform::getInstance();
+                auto port                 = platform->getSourcePort(imuPortInfo);
+                auto imuStreamer          = getComponentT<ImuStreamer>(OB_DEV_COMPONENT_IMU_STREAMER);
+                auto imuStreamerSharedPtr = imuStreamer.get();
+                auto sensor               = std::make_shared<GyroSensor>(this, port, imuStreamerSharedPtr);
+
+                auto globalFrameTimestampCalculator = std::make_shared<GlobalTimestampCalculator>(this, deviceTimeFreq_, frameTimeFreq_);
+                sensor->setGlobalTimestampCalculator(globalFrameTimestampCalculator);
+
+                initSensorStreamProfile(sensor);
+
+                return sensor;
+            },
+            true);
+        registerSensorPortInfo(OB_SENSOR_GYRO, imuPortInfo);
+    }
+}
+
+void FemtoBoltDevice::initProperties() {
+    auto propertyServer = std::make_shared<PropertyServer>(this);
+
+    auto irModePropertyAccessor = std::make_shared<FemtoBoltIrModePropertyAccessor>(this);
+    propertyServer->registerProperty(OB_PROP_SWITCH_IR_MODE_INT, "rw", "rw", irModePropertyAccessor);
+
+    auto tempPropertyAccessor = std::make_shared<FemtoBoltTempPropertyAccessor>(this);
+    propertyServer->registerProperty(OB_STRUCT_DEVICE_TEMPERATURE, "r", "r", tempPropertyAccessor);
+
+    auto sensors = getSensorTypeList();
+    for(auto &sensor: sensors) {
+        auto  platform       = Platform::getInstance();
+        auto &sourcePortInfo = getSensorPortInfo(sensor);
+        if(sensor == OB_SENSOR_COLOR) {
+            auto uvcPropertyAccessor = std::make_shared<LazyPropertyAccessor>([&sourcePortInfo]() {
+                auto platform = Platform::getInstance();
+                auto port     = platform->getSourcePort(sourcePortInfo);
+                auto accessor = std::make_shared<UvcPropertyAccessor>(port);
+                return accessor;
+            });
+
+            propertyServer->registerProperty(OB_PROP_COLOR_AUTO_EXPOSURE_BOOL, "rw", "rw", uvcPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_COLOR_GAIN_INT, "rw", "rw", uvcPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_COLOR_SATURATION_INT, "rw", "rw", uvcPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_COLOR_AUTO_WHITE_BALANCE_BOOL, "rw", "rw", uvcPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_COLOR_WHITE_BALANCE_INT, "rw", "rw", uvcPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_COLOR_BRIGHTNESS_INT, "rw", "rw", uvcPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_COLOR_SHARPNESS_INT, "rw", "rw", uvcPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_COLOR_CONTRAST_INT, "rw", "rw", uvcPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_COLOR_POWER_LINE_FREQUENCY_INT, "rw", "rw", uvcPropertyAccessor);
+        }
+        else if(sensor == OB_SENSOR_DEPTH) {
+            auto vendorPropertyAccessor = std::make_shared<LazySuperPropertyAccessor>([this, &sourcePortInfo]() {
+                auto platform = Platform::getInstance();
+                auto port     = platform->getSourcePort(sourcePortInfo);
+                auto accessor = std::make_shared<VendorPropertyAccessor>(this, port);
+                return accessor;
+            });
+
+            propertyServer->registerProperty(OB_PROP_TIMESTAMP_OFFSET_INT, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_INDICATOR_LIGHT_BOOL, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_USB_POWER_STATE_INT, "r", "r", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_DC_POWER_STATE_INT, "r", "r", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_BOOT_INTO_RECOVERY_MODE_BOOL, "w", "w", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_REBOOT_DEVICE_BOOL, "w", "w", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_TIMER_RESET_ENABLE_BOOL, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_TIMER_RESET_SIGNAL_BOOL, "w", "w", vendorPropertyAccessor);
+            //  propertyServer->registerProperty(OB_PROP_DEVICE_IQ_DEBUG_BOOL, "", "rw", vendorPropertyPort);
+            propertyServer->registerProperty(OB_STRUCT_DEVICE_TIME, "rw", "rw", vendorPropertyAccessor);
+            //  propertyServer->registerProperty(OB_STRUCT_LED_CONTROL, "", "w", vendorPropertyPort);
+            propertyServer->registerProperty(OB_RAW_DATA_CAMERA_CALIB_JSON_FILE, "r", "r", vendorPropertyAccessor);
+            //  propertyServer->registerProperty(OB_RAW_DATA_MCU_UPGRADE_FILE, "rw", "rw", vendorPropertyPort);
+            //  propertyServer->registerProperty(OB_RAW_DATA_HARDWARE_ALIGN_PARAM, "rw", "rw", vendorPropertyPort);
+
+            //   propertyServer->registerProperty(OB_PROP_DEPTH_EXPOSURE_INT, "r", "r", vendorPropertyAccessor);
+            // propertyServer->registerProperty(OB_PROP_SWITCH_IR_MODE_INT, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_RAW_DATA_ALIGN_CALIB_PARAM, "", "r", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_RAW_DATA_D2C_ALIGN_SUPPORT_PROFILE_LIST, "", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_RAW_DATA_IMU_CALIB_PARAM, "", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_STRUCT_VERSION, "", "r", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_GYRO_ODR_INT, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_ACCEL_ODR_INT, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_GYRO_FULL_SCALE_INT, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_ACCEL_FULL_SCALE_INT, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_STRUCT_GET_ACCEL_PRESETS_ODR_LIST, "", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_STRUCT_GET_ACCEL_PRESETS_FULL_SCALE_LIST, "", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_STRUCT_GET_GYRO_PRESETS_ODR_LIST, "", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_STRUCT_GET_GYRO_PRESETS_FULL_SCALE_LIST, "", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_ACCEL_SWITCH_BOOL, "", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_GYRO_SWITCH_BOOL, "", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_TOF_EXPOSURE_TIME_INT, "r", "r", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_STOP_IR_STREAM_BOOL, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_STOP_COLOR_STREAM_BOOL, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_STOP_DEPTH_STREAM_BOOL, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_STRUCT_MULTI_DEVICE_SYNC_CONFIG, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_COLOR_HDR_BOOL, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_COLOR_EXPOSURE_INT, "rw", "rw", vendorPropertyAccessor);
+        }
+        else if(sensor == OB_SENSOR_ACCEL) {
+            auto imuCorrectorFilter = getSensorFrameFilter("IMUCorrector", sensor);
+            if(imuCorrectorFilter) {
+                auto filterStateProperty = std::make_shared<FilterStatePropertyAccessor>(imuCorrectorFilter);
+                propertyServer->registerProperty(OB_PROP_SDK_ACCEL_FRAME_TRANSFORMED_BOOL, "rw", "rw", filterStateProperty);
+            }
+        }
+        else if(sensor == OB_SENSOR_GYRO) {
+            auto imuCorrectorFilter = getSensorFrameFilter("IMUCorrector", sensor);
+            if(imuCorrectorFilter) {
+                auto filterStateProperty = std::make_shared<FilterStatePropertyAccessor>(imuCorrectorFilter);
+                propertyServer->registerProperty(OB_PROP_SDK_GYRO_FRAME_TRANSFORMED_BOOL, "rw", "rw", filterStateProperty);
+            }
+        }
+    }
+
+    propertyServer->aliasProperty(OB_PROP_IR_EXPOSURE_INT, OB_PROP_TOF_EXPOSURE_TIME_INT);
+    propertyServer->aliasProperty(OB_PROP_DEPTH_EXPOSURE_INT, OB_PROP_TOF_EXPOSURE_TIME_INT);
+
+    auto heartbeatPropertyAccessor = std::make_shared<HeartbeatPropertyAccessor>(this);
+    propertyServer->registerProperty(OB_PROP_HEARTBEAT_BOOL, "rw", "rw", heartbeatPropertyAccessor);
+
+    registerComponent(OB_DEV_COMPONENT_PROPERTY_SERVER, propertyServer, true);
+}
+}  // namespace libobsensor
+
diff --git a/src/device/femtobolt/FemtoBoltDevice.hpp b/src/device/femtobolt/FemtoBoltDevice.hpp
new file mode 100644
index 00000000..542249c6
--- /dev/null
+++ b/src/device/femtobolt/FemtoBoltDevice.hpp
@@ -0,0 +1,28 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include "DeviceBase.hpp"
+#include "IDeviceManager.hpp"
+#include "frameprocessor/FrameProcessor.hpp"
+
+#include <map>
+#include <memory>
+
+namespace libobsensor {
+class FemtoBoltDevice : public DeviceBase {
+public:
+    FemtoBoltDevice(const std::shared_ptr<const IDeviceEnumInfo> &info);
+    virtual ~FemtoBoltDevice() noexcept;
+
+private:
+    void init() override;
+    void initSensorList();
+    void initProperties();
+    void initSensorStreamProfile(std::shared_ptr<ISensor> sensor);
+
+private:
+    uint64_t deviceTimeFreq_ = 1000;
+    uint64_t frameTimeFreq_  = 1000;
+};
+}  // namespace libobsensor
diff --git a/src/device/femtobolt/FemtoBoltDeviceInfo.cpp b/src/device/femtobolt/FemtoBoltDeviceInfo.cpp
new file mode 100644
index 00000000..63aca9b0
--- /dev/null
+++ b/src/device/femtobolt/FemtoBoltDeviceInfo.cpp
@@ -0,0 +1,43 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "FemtoBoltDeviceInfo.hpp"
+#include "FemtoBoltDevice.hpp"
+#include "DevicePids.hpp"
+#include "usb/UsbPortGroup.hpp"
+#include "utils/Utils.hpp"
+namespace libobsensor {
+FemtoBoltDeviceInfo::FemtoBoltDeviceInfo(const SourcePortInfoList groupedInfoList) {
+    auto portInfo = std::dynamic_pointer_cast<const USBSourcePortInfo>(groupedInfoList.front());
+
+    name_               = "FemtoBolt";
+    fullName_           = "Orbbec " + name_;
+    pid_                = portInfo->pid;
+    vid_                = portInfo->vid;
+    uid_                = portInfo->uid;
+    deviceSn_           = portInfo->serial;
+    connectionType_     = portInfo->connSpec;
+    sourcePortInfoList_ = groupedInfoList;
+}
+
+FemtoBoltDeviceInfo::~FemtoBoltDeviceInfo() noexcept {}
+
+std::shared_ptr<IDevice> FemtoBoltDeviceInfo::createDevice() const {
+    return std::make_shared<FemtoBoltDevice>(shared_from_this());
+}
+
+std::vector<std::shared_ptr<IDeviceEnumInfo>> FemtoBoltDeviceInfo::pickDevices(const SourcePortInfoList infoList) {
+    std::vector<std::shared_ptr<IDeviceEnumInfo>> femtoBoltDeviceInfos;
+    auto                                          remainder = FilterUSBPortInfoByPid(infoList, FemtoBoltDevPids);
+    auto                                          groups    = utils::groupVector<std::shared_ptr<const SourcePortInfo>>(remainder, GroupUSBSourcePortByUrl);
+    auto                                          iter      = groups.begin();
+    while(iter != groups.end()) {
+        if(iter->size() >= 2) {
+            auto info = std::make_shared<FemtoBoltDeviceInfo>(*iter);
+            femtoBoltDeviceInfos.push_back(info);
+        }
+        iter++;
+    }
+    return femtoBoltDeviceInfos;
+}
+}  // namespace libobsensor
diff --git a/src/device/femtobolt/FemtoBoltDeviceInfo.hpp b/src/device/femtobolt/FemtoBoltDeviceInfo.hpp
new file mode 100644
index 00000000..823f096c
--- /dev/null
+++ b/src/device/femtobolt/FemtoBoltDeviceInfo.hpp
@@ -0,0 +1,22 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include "devicemanager/DeviceEnumInfoBase.hpp"
+
+#include <iostream>
+#include <string>
+#include <vector>
+#include <memory>
+
+namespace libobsensor {
+class FemtoBoltDeviceInfo : public DeviceEnumInfoBase, public std::enable_shared_from_this<FemtoBoltDeviceInfo> {
+public:
+    FemtoBoltDeviceInfo(const SourcePortInfoList groupedInfoList);
+    ~FemtoBoltDeviceInfo() noexcept;
+
+    std::shared_ptr<IDevice>                             createDevice() const override;
+    static std::vector<std::shared_ptr<IDeviceEnumInfo>> pickDevices(const SourcePortInfoList infoList);
+};
+
+}  // namespace libobsensor
diff --git a/src/device/femtobolt/FemtoBoltPropertyAccessor.cpp b/src/device/femtobolt/FemtoBoltPropertyAccessor.cpp
new file mode 100644
index 00000000..267d7d14
--- /dev/null
+++ b/src/device/femtobolt/FemtoBoltPropertyAccessor.cpp
@@ -0,0 +1,76 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "FemtoBoltPropertyAccessor.hpp"
+#include "frameprocessor/FrameProcessor.hpp"
+#include "sensor/video/DisparityBasedSensor.hpp"
+#include "IDeviceComponent.hpp"
+#include "property/InternalProperty.hpp"
+#include "rawphase/RawPhaseStreamer.hpp"
+#include "rawphase/RawPhaseBasedSensor.hpp"
+
+namespace libobsensor {
+FemtoBoltIrModePropertyAccessor::FemtoBoltIrModePropertyAccessor(IDevice *owner) : owner_(owner) {
+    // OBPropertyValue value;
+    // value.intValue = 0;
+    // setPropertyValue(OB_PROP_SWITCH_IR_MODE_INT, value);
+}
+
+void FemtoBoltIrModePropertyAccessor::setPropertyValue(uint32_t propertyId, const OBPropertyValue &value) {
+    auto commandPort = owner_->getComponentT<IBasicPropertyAccessor>(OB_DEV_COMPONENT_MAIN_PROPERTY_ACCESSOR);
+    commandPort->setPropertyValue(propertyId, value);
+
+    if(propertyId == OB_PROP_SWITCH_IR_MODE_INT) {
+        auto rawPhaseStreamer = owner_->getComponentT<RawPhaseStreamer>(OB_DEV_COMPONENT_RAW_PHASE_STREAMER);
+        rawPhaseStreamer->enablePassiveIRMode((bool)value.intValue);
+
+        auto depthSensor = owner_->getComponentT<RawPhaseBasedSensor>(OB_DEV_COMPONENT_DEPTH_SENSOR);
+        depthSensor->refreshStreamProfiles();
+
+        auto irSensor = owner_->getComponentT<RawPhaseBasedSensor>(OB_DEV_COMPONENT_IR_SENSOR);
+        irSensor->refreshStreamProfiles();
+    }
+}
+
+void FemtoBoltIrModePropertyAccessor::getPropertyValue(uint32_t propertyId, OBPropertyValue *value) {
+    auto commandPort = owner_->getComponentT<IBasicPropertyAccessor>(OB_DEV_COMPONENT_MAIN_PROPERTY_ACCESSOR);
+    commandPort->getPropertyValue(propertyId, value);
+}
+
+void FemtoBoltIrModePropertyAccessor::getPropertyRange(uint32_t propertyId, OBPropertyRange *range) {
+    auto commandPort = owner_->getComponentT<IBasicPropertyAccessor>(OB_DEV_COMPONENT_MAIN_PROPERTY_ACCESSOR);
+    commandPort->getPropertyRange(propertyId, range);
+}
+
+FemtoBoltTempPropertyAccessor::FemtoBoltTempPropertyAccessor(IDevice *owner) : owner_(owner) {}
+
+void FemtoBoltTempPropertyAccessor::setStructureData(uint32_t propertyId, const std::vector<uint8_t> &data) {
+    utils::unusedVar(propertyId);
+    utils::unusedVar(data);
+    throw unsupported_operation_exception("Temperature params readonly!");
+}
+
+const std::vector<uint8_t> &FemtoBoltTempPropertyAccessor::getStructureData(uint32_t propertyId) {
+    utils::unusedVar(propertyId);
+    tempData_.resize(sizeof(OBDeviceTemperature));
+
+    auto                       commandPort = owner_->getComponentT<IStructureDataAccessor>(OB_DEV_COMPONENT_MAIN_PROPERTY_ACCESSOR);
+    const std::vector<uint8_t> tempData    = commandPort->getStructureData(OB_STRUCT_DEVICE_TEMPERATURE);
+    OBDeviceTemperature        tempParam;
+    memset(&tempParam, 0, sizeof(OBDeviceTemperature));
+    memcpy(&tempParam, tempData.data(), sizeof(OBDeviceTemperature));
+
+    tempParam.irLeftTemp     = 0;
+    tempParam.irRightTemp    = 0;
+    tempParam.chipBottomTemp = 0;
+    tempParam.chipTopTemp    = 0;
+    tempParam.mainBoardTemp  = 0;
+    tempParam.rgbTemp        = 0;
+    tempParam.tecTemp        = 0;
+
+    memcpy(tempData_.data(), &tempParam, sizeof(OBDeviceTemperature));
+
+    return tempData_;
+}
+
+}  // namespace libobsensor
diff --git a/src/device/femtobolt/FemtoBoltPropertyAccessor.hpp b/src/device/femtobolt/FemtoBoltPropertyAccessor.hpp
new file mode 100644
index 00000000..292ea892
--- /dev/null
+++ b/src/device/femtobolt/FemtoBoltPropertyAccessor.hpp
@@ -0,0 +1,35 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include "IProperty.hpp"
+#include "IDevice.hpp"
+
+namespace libobsensor {
+class FemtoBoltIrModePropertyAccessor : public IBasicPropertyAccessor {
+public:
+    explicit FemtoBoltIrModePropertyAccessor(IDevice *owner);
+    virtual ~FemtoBoltIrModePropertyAccessor() noexcept = default;
+
+    virtual void setPropertyValue(uint32_t propertyId, const OBPropertyValue &value) override;
+    virtual void getPropertyValue(uint32_t propertyId, OBPropertyValue *value) override;
+    virtual void getPropertyRange(uint32_t propertyId, OBPropertyRange *range) override;
+
+private:
+    IDevice *owner_;
+};
+
+class FemtoBoltTempPropertyAccessor : public IStructureDataAccessor {
+public:
+    explicit FemtoBoltTempPropertyAccessor(IDevice *owner);
+    virtual ~FemtoBoltTempPropertyAccessor() noexcept = default;
+
+    virtual void                        setStructureData(uint32_t propertyId, const std::vector<uint8_t> &data) override;
+    virtual const std::vector<uint8_t> &getStructureData(uint32_t propertyId) override;
+
+private:
+    IDevice             *owner_;
+    std::vector<uint8_t> tempData_;
+};
+
+}  // namespace libobsensor
diff --git a/src/device/femtobolt/rawphase/CMakeLists.txt b/src/device/femtobolt/rawphase/CMakeLists.txt
new file mode 100644
index 00000000..391ede3d
--- /dev/null
+++ b/src/device/femtobolt/rawphase/CMakeLists.txt
@@ -0,0 +1,18 @@
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+cmake_minimum_required(VERSION 3.5)
+
+file (GLOB _cpp_files "${CMAKE_CURRENT_LIST_DIR}/*.cpp")
+file (GLOB _head_files "${CMAKE_CURRENT_LIST_DIR}/*.hpp")
+
+foreach(_file IN ITEMS ${_cpp_files})
+        target_sources(${OB_TARGET_DEVICE} PRIVATE "${_file}")
+endforeach()
+
+foreach(_file IN ITEMS ${_head_files})
+        target_sources(${OB_TARGET_DEVICE} PRIVATE "${_file}")
+endforeach()
+
+#add_subdirectory(dynlib)
+add_subdirectory(depthengine)
diff --git a/src/device/femtobolt/rawphase/RawPhaseBasedSensor.cpp b/src/device/femtobolt/rawphase/RawPhaseBasedSensor.cpp
new file mode 100644
index 00000000..cc78ea17
--- /dev/null
+++ b/src/device/femtobolt/rawphase/RawPhaseBasedSensor.cpp
@@ -0,0 +1,73 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "RawPhaseBasedSensor.hpp"
+#include "RawPhaseStreamer.hpp"
+#include "property/InternalProperty.hpp"
+namespace libobsensor {
+RawPhaseBasedSensor::RawPhaseBasedSensor(IDevice *owner, OBSensorType sensorType, const std::shared_ptr<ISourcePort> &backend)
+    : VideoSensor(owner, sensorType, backend) {}
+
+RawPhaseBasedSensor::~RawPhaseBasedSensor() {}
+
+void RawPhaseBasedSensor::trySendStopStreamVendorCmd() {
+    auto rawPhaseStreamer = std::dynamic_pointer_cast<RawPhaseStreamer>(backend_);
+    if(rawPhaseStreamer->isRunning()) {
+        return;
+    }
+    auto owner      = getOwner();
+    auto propServer = owner->getPropertyServer();
+    if(propServer->isPropertySupported(OB_PROP_STOP_DEPTH_STREAM_BOOL, PROP_OP_WRITE, PROP_ACCESS_INTERNAL)) {
+        propServer->setPropertyValueT<bool>(OB_PROP_STOP_DEPTH_STREAM_BOOL, true);
+    }
+}
+
+void RawPhaseBasedSensor::refreshStreamProfiles() {
+    auto streamProfileList = getStreamProfileList();
+    auto defaultSp         = streamProfileList.front();
+
+    auto owner         = getOwner();
+    auto vsPort        = std::dynamic_pointer_cast<IVideoStreamPort>(backend_);
+    auto lazySelf      = std::make_shared<LazySensor>(owner, sensorType_);
+    auto streamType    = utils::mapSensorTypeToStreamType(sensorType_);
+    auto backendSpList = vsPort->getStreamProfileList();
+    for(auto &backendSp: backendSpList) {
+        auto sp = backendSp->clone();
+        sp->bindOwner(lazySelf);
+        sp->setType(streamType);
+        backendStreamProfileList_.push_back(sp);
+        LOG_DEBUG("Backend stream profile {}", backendSp);
+    }
+
+    std::sort(backendStreamProfileList_.begin(), backendStreamProfileList_.end(),
+              [](const std::shared_ptr<const StreamProfile> &a, const std::shared_ptr<const StreamProfile> &b) {
+                  auto aVsp = a->as<VideoStreamProfile>();
+                  auto bVsp = b->as<VideoStreamProfile>();
+                  auto aRes = aVsp->getWidth() * aVsp->getHeight();
+                  auto bRes = bVsp->getWidth() * bVsp->getHeight();
+                  if(aRes != bRes) {
+                      return aRes > bRes;
+                  }
+                  else if(aVsp->getHeight() != bVsp->getHeight()) {
+                      return aVsp->getHeight() > bVsp->getHeight();
+                  }
+                  else if(aVsp->getFps() != bVsp->getFps()) {
+                      return aVsp->getFps() > bVsp->getFps();
+                  }
+                  return aVsp->getFormat() > bVsp->getFormat();
+              });
+
+    // The stream profile list is same as the backend stream profile list at default.
+    for(auto &backendSp: backendStreamProfileList_) {
+        auto sp = backendSp->clone();
+        sp->bindOwner(lazySelf);
+        sp->setType(streamType);
+        streamProfileList_.push_back(sp);
+        streamProfileBackendMap_[sp] = { backendSp, nullptr };
+    }
+
+    updateFormatFilterConfig(formatFilterConfigs_);
+    updateDefaultStreamProfile(defaultSp);
+}
+
+}  // namespace libobsensor
diff --git a/src/device/femtobolt/rawphase/RawPhaseBasedSensor.hpp b/src/device/femtobolt/rawphase/RawPhaseBasedSensor.hpp
new file mode 100644
index 00000000..0b92caa5
--- /dev/null
+++ b/src/device/femtobolt/rawphase/RawPhaseBasedSensor.hpp
@@ -0,0 +1,20 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include "sensor/video/VideoSensor.hpp"
+
+namespace libobsensor {
+class RawPhaseBasedSensor : public VideoSensor {
+public:
+    RawPhaseBasedSensor(IDevice *owner, OBSensorType sensorType, const std::shared_ptr<ISourcePort> &backend);
+    virtual ~RawPhaseBasedSensor() noexcept;
+
+    void refreshStreamProfiles();
+
+protected:
+    void trySendStopStreamVendorCmd() override;
+};
+
+}  // namespace libobsensor
diff --git a/src/device/femtobolt/rawphase/RawPhaseStreamer.cpp b/src/device/femtobolt/rawphase/RawPhaseStreamer.cpp
new file mode 100644
index 00000000..9d5401e1
--- /dev/null
+++ b/src/device/femtobolt/rawphase/RawPhaseStreamer.cpp
@@ -0,0 +1,500 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "RawPhaseStreamer.hpp"
+#include "IDevice.hpp"
+#include "frame/Frame.hpp"
+#include "frame/FrameFactory.hpp"
+#include "stream/StreamProfile.hpp"
+#include "logger/LoggerInterval.hpp"
+#include "stream/StreamProfileFactory.hpp"
+#include "property/InternalProperty.hpp"
+namespace libobsensor {
+
+// Chip defintions
+// Since we don't actually have direct access to the chip here, we will need to hardcode a few parameters
+const float    CHIP_ADC_UNITS_PER_DEG_C   = 5.45f;  // This is a hardcoded paramter
+const uint32_t CHIP_EFUSE_REG_TEMP_CAL_TJ = 20739;  // Read from EFUSE address 0x0B. LSB: Temp Cal Version, MSB: Forced Tj
+const uint32_t CHIP_EFUSE_REG_TJ_ADC_VAL  = 1927;   // Read from EFUSE address 0x0C. Temp Sensor ADC value at Tj
+
+#pragma pack(push, 1)
+struct InputInfo {
+    uint16_t systemId;
+    uint16_t nRows;
+    uint16_t nCols;
+    uint16_t nStreams;
+    uint16_t nBitsPerSample;
+    uint16_t mode;
+};
+
+typedef struct obcTransferHeader {
+    uint64_t frameCounter;
+    uint16_t extendtionLen;
+} ObcTransferHeader;
+
+typedef struct obcMetadataHeader {
+    uint64_t timestamp;  // us
+    uint16_t width;
+    uint16_t height;
+    uint32_t size;
+} ObcMetadataHeader;
+
+/****aligned 2 bytes****/
+typedef struct obcFrameHeader {
+    ObcTransferHeader transferHeader;
+    ObcMetadataHeader metadataHeader;
+} ObcFrameHeader;
+#pragma pack(pop)
+
+RawPhaseStreamer::RawPhaseStreamer(IDevice *owner, const std::shared_ptr<IVideoStreamPort> &backend)
+    : owner_(owner), backend_(backend), running_(false), depthEngineLoader_(std::make_shared<DepthEngineLoadFactory>()) {
+    auto global = depthEngineLoader_->getGlobalContext();
+    if(global == nullptr || global->loaded == false) {
+        throw io_exception("Failed to load depth engine");
+    }
+    backendProfileMap_.insert({ { 320, 288 }, { 7680, 434 } });
+    backendProfileMap_.insert({ { 640, 576 }, { 7680, 434 } });
+    backendProfileMap_.insert({ { 1024, 1024 }, { 8192, 130 } });
+    backendProfileMap_.insert({ { 512, 512 }, { 8192, 290 } });
+
+    backendStreamProfileList_ = backend_->getStreamProfileList();
+    setStreamProfileList();
+
+    // try to stop stream to avoid that the device is in streaming state due to some reason such as a previous crash
+    auto propServer = owner->getPropertyServer();
+    if(propServer->isPropertySupported(OB_PROP_STOP_DEPTH_STREAM_BOOL, PROP_OP_WRITE, PROP_ACCESS_INTERNAL)) {
+        propServer->setPropertyValueT<bool>(OB_PROP_STOP_DEPTH_STREAM_BOOL, true);
+    }
+    initNvramData();
+    LOG_DEBUG("RawPhaseStreamer created");
+}
+
+RawPhaseStreamer::~RawPhaseStreamer() noexcept {
+    {
+        std::lock_guard<std::mutex> lock(cbMtx_);
+        callbacks_.clear();
+    }
+    TRY_EXECUTE(stopDepthEngineThread());
+    TRY_EXECUTE(stopAllStream());
+
+    if(running_) {
+        TRY_EXECUTE(backend_->stopAllStream());
+    }
+    running_ = false;
+}
+
+IDevice *RawPhaseStreamer::getOwner() const {
+    return owner_;
+}
+
+std::shared_ptr<const SourcePortInfo> RawPhaseStreamer::getSourcePortInfo() const {
+    return backend_->getSourcePortInfo();
+}
+
+void RawPhaseStreamer::setStreamProfileList() {
+    streamProfileList_.clear();
+    for(auto &profile: backendStreamProfileList_) {
+        auto sp     = profile->as<VideoStreamProfile>();
+        auto format = sp->getFormat();
+        auto width  = sp->getWidth();
+        auto height = sp->getHeight();
+        auto fps    = sp->getFps();
+        for(auto &item: backendProfileMap_) {
+            if(item.second.first != width || item.second.second != height) {
+                continue;
+            }
+
+            if(!passiveIRModeEnabled_ && item.first.first == 1024 && item.first.second == 1024 && (fps == 30 || fps == 25)) {
+                continue;
+            }
+
+            auto newSp = StreamProfileFactory::createVideoStreamProfile(OB_STREAM_VIDEO, format, item.first.first, item.first.second, fps);
+            streamProfileList_.push_back(newSp);
+        }
+    }
+}
+
+StreamProfileList RawPhaseStreamer::getStreamProfileList() {
+    return streamProfileList_;
+}
+
+void RawPhaseStreamer::startStream(std::shared_ptr<const StreamProfile> sp, MutableFrameCallback callback) {
+    std::unique_lock<std::mutex> streamLock(streamMutex_);
+
+    {
+        std::lock_guard<std::mutex> lock(cbMtx_);
+        for(auto &cb: callbacks_) {
+            auto cbVsp = cb.first->as<VideoStreamProfile>();
+            auto spVsp = sp->as<VideoStreamProfile>();
+            if(cbVsp->getWidth() != spVsp->getWidth() || cbVsp->getHeight() != spVsp->getHeight() || cbVsp->getFps() != spVsp->getFps()) {
+                throw invalid_value_exception("Start stream failed, the stream profile is different from the previous stream profile");
+            }
+        }
+        callbacks_[sp] = callback;
+    }
+
+    if(running_) {
+        return;
+    }
+
+    startDepthEngineThread(sp);
+
+    auto profile    = std::dynamic_pointer_cast<const VideoStreamProfile>(sp);
+    auto resolution = std::make_pair(profile->getWidth(), profile->getHeight());
+    auto iter =
+        std::find_if(backendProfileMap_.begin(), backendProfileMap_.end(),
+                     [resolution](const std::pair<std::pair<uint32_t, uint32_t>, std::pair<uint32_t, uint32_t>> &pair) { return pair.first == resolution; });
+
+    if(iter == backendProfileMap_.end()) {
+        throw invalid_value_exception("Start stream failed, stream profile not found");
+    }
+    auto &pair   = iter->second;
+    auto  realSp = StreamProfileFactory::createVideoStreamProfile(profile->getType(), profile->getFormat(), pair.first, pair.second, profile->getFps());
+    backend_->startStream(realSp, [this](std::shared_ptr<Frame> frame) {
+        std::unique_lock<std::mutex> lock(frameQueueMutex_);
+        frameQueue_.push(frame);
+        frameQueueCV_.notify_one();
+    });
+    running_ = true;
+}
+
+void RawPhaseStreamer::stopStream(std::shared_ptr<const StreamProfile> sp) {
+    if(!running_) {
+        return;
+    }
+
+    std::unique_lock<std::mutex> streamLock(streamMutex_);
+
+    {
+        std::lock_guard<std::mutex> lock(cbMtx_);
+        auto                        iter = callbacks_.find(sp);
+        if(iter == callbacks_.end()) {
+            throw invalid_value_exception("Stop stream failed, stream profile not found");
+        }
+
+        callbacks_.erase(iter);
+        if(!callbacks_.empty()) {
+            return;
+        }
+    }
+
+    backend_->stopAllStream();
+    running_ = false;
+}
+
+void RawPhaseStreamer::stopAllStream() {
+    std::unique_lock<std::mutex> streamLock(streamMutex_);
+    if(!running_) {
+        return;
+    }
+
+    {
+        std::lock_guard<std::mutex> lock(cbMtx_);
+        callbacks_.clear();
+    }
+
+    backend_->stopAllStream();
+    running_ = false;
+}
+
+bool RawPhaseStreamer::isRunning() const {
+    return running_;
+}
+
+void RawPhaseStreamer::parseAndOutputFrame(std::shared_ptr<Frame> frame) {
+    InputInfo inputInfo   = { 0 };
+    size_t    captureSize = 0, rawFrameSize = 0; /** headerSize = 0*/
+
+    // Parse the metadata from the MIPI header
+    YEATS_MIPI_HDR mipiHdr      = { 0 };
+    int            mipiHeadSize = sizeof(YEATS_MIPI_HDR) * 2;
+    // passive ir
+    if(frame->getDataSize() == 4096 * 1154 * 2) {
+        mipiHeadSize = sizeof(YEATS_MIPI_HDR);
+    }
+
+    auto data = frame->getData();
+    // Try reading chip ID to determine if there is padding in header or not
+    uint16_t chipId = *(uint16_t *)data;
+    if(chipId == 0x5931) {
+        // For mode 5, we can read directly into the mipi header
+        mipiHdr = *(YEATS_MIPI_HDR *)data;
+    }
+    else {
+        //  int size = sizeof(YEATS_MIPI_HDR) * 2;
+        // For mode 4/7, we need to skip every other byte because of padding from Jetson Nano
+        std::vector<uint8_t> headerData(sizeof(YEATS_MIPI_HDR) * 2);
+        // inFile.read(reinterpret_cast<char *>(headerData.data()), sizeof(YEATS_MIPI_HDR) * 2);
+        memcpy(headerData.data(), data, sizeof(YEATS_MIPI_HDR) * 2);
+        for(size_t i = 0; i < sizeof(YEATS_MIPI_HDR); ++i) {
+            uint8_t *mipiHdrArray = reinterpret_cast<uint8_t *>(&mipiHdr);
+            mipiHdrArray[i]       = headerData[i * 2];
+        }
+    }
+
+    // Note: if you want to use NFOV_2x2BINNED, capture data using NFOV_UNBINNED and then set the inputInfo.mode = 2
+    // Read the relevant info from the mipi header
+    inputInfo.mode           = mipiHdr.mode_info.bits.mode;
+    inputInfo.nRows          = mipiHdr.frameHeight;
+    inputInfo.nCols          = mipiHdr.frameWidth;
+    inputInfo.nStreams       = mipiHdr.capture_info.bits.nCaptures + 1;  // zero indexed
+    inputInfo.nBitsPerSample = (inputInfo.mode == 5) ? 8 : 16;           // mode 5 uses 8 bit compressed, others use 16 bit float
+
+    captureSize = inputInfo.nRows * inputInfo.nCols * inputInfo.nBitsPerSample / 8;
+
+    rawFrameSize = captureSize * inputInfo.nStreams;
+
+    uint8_t *dstData = (uint8_t *)data + rawFrameSize;
+    uint8_t *srcData = (uint8_t *)data + rawFrameSize - (inputInfo.nRows * 2);
+    memcpy(dstData, srcData, mipiHeadSize);
+
+    auto   global      = depthEngineLoader_->getGlobalContext();
+    size_t outputBytes = global->plugin.depth_engine_get_output_frame_size(depthEngineContext_);
+
+    std::vector<uint8_t> outputBuffer(outputBytes, 0);
+
+    // For every frame, read the RAW data and process it.
+    k4a_depth_engine_input_frame_info_t  inputFrameInfo  = { 0 };
+    k4a_depth_engine_output_frame_info_t outputFrameInfo = { 0 };
+
+    {
+
+        // Need to add in the laser and sensor temperature info.
+        // Read this from the chip EFUSE in combination with header.
+        uint32_t Tj               = (CHIP_EFUSE_REG_TEMP_CAL_TJ >> 8);
+        float    sensorTempOffset = CHIP_EFUSE_REG_TJ_ADC_VAL - Tj * CHIP_ADC_UNITS_PER_DEG_C;
+
+        {
+
+            int32_t resvValue      = ((int32_t)mipiHdr.resv[0]) | ((int32_t)mipiHdr.resv[1] << 16);
+            int16_t integerPart    = static_cast<uint16_t>(resvValue / 1000);
+            int16_t fractionalPart = static_cast<uint16_t>(resvValue % 1000);
+
+            float tmpValue               = static_cast<float>(integerPart) + static_cast<float>(fractionalPart) / 1000.0f;
+            inputFrameInfo.laser_temp[0] = tmpValue;
+            // LOG_INFO("get temp from ebd:{}", tmpValue);
+            // LOG_INFO("origin data:{:x},{:x},{:x},{:x}", mipiHdr.resv[0], mipiHdr.resv[1], mipiHdr.resv[2], mipiHdr.resv[3]);
+        }
+
+        inputFrameInfo.laser_temp[1]               = 0;  // This can just be populated with 0
+        inputFrameInfo.sensor_temp                 = (((float)mipiHdr.tempSensorADC.bits.adcVal) - sensorTempOffset) / CHIP_ADC_UNITS_PER_DEG_C;
+        inputFrameInfo.center_of_exposure_in_ticks = 0;  // This isn't used within the depth engine
+
+        k4a_depth_engine_output_type_t outputType = k4a_depth_engine_output_type_t::K4A_DEPTH_ENGINE_OUTPUT_TYPE_Z_DEPTH;
+        if(passiveIRModeEnabled_) {
+            outputType = k4a_depth_engine_output_type_t::K4A_DEPTH_ENGINE_OUTPUT_TYPE_PCM;
+        }
+
+        auto retCode = global->plugin.depth_engine_process_frame(depthEngineContext_, (uint8_t *)data + mipiHeadSize, rawFrameSize, outputType,
+                                                                 outputBuffer.data(), outputBytes, &outputFrameInfo, &inputFrameInfo);
+
+        if(K4A_DEPTH_ENGINE_RESULT_SUCCEEDED != retCode) {
+            LOG_ERROR("Process frame failed! Error code:{}", retCode);
+            return;
+        }
+
+        // Now we have the output data. They are uint16_t type and AB frame immediately follows Z frame.
+        size_t    nPixels     = static_cast<size_t>(outputFrameInfo.output_height) * static_cast<size_t>(outputFrameInfo.output_width);
+        uint16_t *outputFrame = reinterpret_cast<uint16_t *>(outputBuffer.data());
+        uint16_t *zFrame      = outputFrame;
+        uint16_t *abFrame     = outputFrame + nPixels;
+
+        if(outputType == k4a_depth_engine_output_type_t::K4A_DEPTH_ENGINE_OUTPUT_TYPE_PCM) {
+            abFrame = zFrame;
+        }
+
+        std::lock_guard<std::mutex> lock(cbMtx_);
+        for(const auto &iter: callbacks_) {
+            if(iter.first->getType() == OB_STREAM_DEPTH && outputType != k4a_depth_engine_output_type_t::K4A_DEPTH_ENGINE_OUTPUT_TYPE_PCM) {
+                auto depthStreamProfile = iter.first->as<libobsensor::VideoStreamProfile>();
+                auto depthFrame         = FrameFactory::createFrameFromStreamProfile(depthStreamProfile);
+                depthFrame->updateData((const uint8_t *)zFrame, nPixels * 2);
+                depthFrame->setDataSize(nPixels * 2);
+                depthFrame->copyInfoFromOther(frame);
+                iter.second(depthFrame);
+            }
+            else if(iter.first->getType() == OB_STREAM_IR) {
+                auto irStreamProfile = iter.first->as<libobsensor::VideoStreamProfile>();
+                auto irFrame         = FrameFactory::createFrameFromStreamProfile(irStreamProfile);
+                irFrame->updateData((const uint8_t *)abFrame, nPixels * 2);
+                irFrame->setDataSize(nPixels * 2);
+                irFrame->copyInfoFromOther(frame);
+                iter.second(irFrame);
+            }
+        }
+    }
+}
+
+k4a_depth_engine_mode_t RawPhaseStreamer::getDepthEngineMode(std::shared_ptr<const StreamProfile> profile) {
+    auto                    videoProfile = std::dynamic_pointer_cast<const VideoStreamProfile>(profile);
+    k4a_depth_engine_mode_t mode         = K4A_DEPTH_ENGINE_MODE_UNKNOWN;
+    if((videoProfile->getWidth() == 1024 && videoProfile->getHeight() == 1024) || ((videoProfile->getWidth() == 8192) && videoProfile->getHeight() == 130)
+       || (videoProfile->getWidth() == 4096 && videoProfile->getHeight() == 1154)) {
+        if(passiveIRModeEnabled_) {
+            mode = K4A_DEPTH_ENGINE_MODE_PCM;
+        }
+        else {
+            mode = K4A_DEPTH_ENGINE_MODE_MEGA_PIXEL;
+        }
+    }
+    else if((videoProfile->getWidth() == 512 && videoProfile->getHeight() == 512) || (videoProfile->getWidth() == 8192 && videoProfile->getHeight() == 290)) {
+        mode = K4A_DEPTH_ENGINE_MODE_QUARTER_MEGA_PIXEL;
+    }
+    else if((videoProfile->getWidth() == 640 && videoProfile->getHeight() == 576) || (videoProfile->getWidth() == 7680 && videoProfile->getHeight() == 434)) {
+        mode = K4A_DEPTH_ENGINE_MODE_LT_NATIVE;
+    }
+    else if((videoProfile->getWidth() == 320 && videoProfile->getHeight() == 288) || (videoProfile->getWidth() == 7680 && videoProfile->getHeight() == 434)) {
+        mode = K4A_DEPTH_ENGINE_MODE_LT_SW_BINNING;
+    }
+
+    return mode;
+}
+
+void RawPhaseStreamer::stopDepthEngineThread() {
+    if(!depthEngineThread_.joinable()) {
+        return;
+    }
+    depthEngineThreadExit_ = true;
+    {
+        std::unique_lock<std::mutex> lock(frameQueueMutex_);
+        frameQueueCV_.notify_one();
+    }
+    depthEngineThread_.join();
+}
+
+void RawPhaseStreamer::startDepthEngineThread(std::shared_ptr<const StreamProfile> profile) {
+    if(depthEngineThread_.joinable()) {
+        auto lastVsp = lastStreamProfile_->as<VideoStreamProfile>();
+        auto vsp     = profile->as<VideoStreamProfile>();
+        if(lastVsp->getWidth() == vsp->getWidth() && lastVsp->getHeight() == vsp->getHeight()) {
+            return;
+        }
+        stopDepthEngineThread();
+    }
+
+    lastStreamProfile_     = profile;
+    depthEngineThreadExit_ = false;
+    depthEngineThread_     = std::thread([profile, this] {
+        // depth engine must be initialize, using and deinitialize in the same thread
+        // todo: catch exceptions
+        initDepthEngine(profile);  // init depth engine
+        std::shared_ptr<Frame> frame;
+        while(!depthEngineThreadExit_) {
+            {
+                std::unique_lock<std::mutex> lock(frameQueueMutex_);
+                frameQueueCV_.wait(lock, [&]() { return !frameQueue_.empty() || depthEngineThreadExit_; });
+                if(depthEngineThreadExit_) {
+                    break;
+                }
+
+                frame = frameQueue_.front();
+                frameQueue_.pop();
+            }
+            parseAndOutputFrame(frame);
+        }
+        deinitDepthEngine();
+    });
+}
+
+void RawPhaseStreamer::initDepthEngine(std::shared_ptr<const StreamProfile> profile) {
+    LOG_DEBUG("Depth engine create and initialize...");
+
+    waitNvramDataReady();
+
+    k4a_depth_engine_input_type_t deInputType = k4a_depth_engine_input_type_t::K4A_DEPTH_ENGINE_INPUT_TYPE_UNKNOWN;
+    k4a_depth_engine_mode_t       mode        = K4A_DEPTH_ENGINE_MODE_UNKNOWN;
+
+    auto videoProfile = std::dynamic_pointer_cast<const VideoStreamProfile>(profile);
+    mode              = getDepthEngineMode(videoProfile);
+
+    deInputType = (mode == K4A_DEPTH_ENGINE_MODE_MEGA_PIXEL) ? k4a_depth_engine_input_type_t::K4A_DEPTH_ENGINE_INPUT_TYPE_8BIT_COMPRESSED_RAW
+                                                             : k4a_depth_engine_input_type_t::K4A_DEPTH_ENGINE_INPUT_TYPE_16BIT_RAW;
+
+    curDepthEngineMode_                    = mode;
+    auto                           global  = depthEngineLoader_->getGlobalContext();
+    k4a_depth_engine_result_code_t retCode = global->plugin.depth_engine_create_and_initialize(&depthEngineContext_, nvramData_.size(), nvramData_.data(), mode,
+                                                                                               deInputType, nullptr, nullptr, nullptr);
+
+    if(K4A_DEPTH_ENGINE_RESULT_SUCCEEDED != retCode) {
+        throw io_exception(utils::string::to_string() << "Depth engine create and initialize failed,retCode" << retCode);
+    }
+
+    LOG_DEBUG("Depth engine init succeed!");
+}
+
+void RawPhaseStreamer::deinitDepthEngine() {
+    auto global = depthEngineLoader_->getGlobalContext();
+    global->plugin.depth_engine_destroy(&depthEngineContext_);
+    depthEngineContext_ = nullptr;
+}
+
+void RawPhaseStreamer::initNvramData() {
+    auto global = depthEngineLoader_->getGlobalContext();
+    if(!global->loaded) {
+        throw io_exception("Failed to load depth engine plugin");
+    }
+    LOG_INFO("Succeed to load depth engine plugin");
+
+    std::shared_ptr<const StreamProfile> firmwareDataProfile;
+    for(auto &sp: backendStreamProfileList_) {
+        auto profile = sp->as<VideoStreamProfile>();
+        if(profile->getWidth() == 1024 && profile->getHeight() == 512 && profile->getFps() == 5) {
+            firmwareDataProfile = sp;
+            break;
+        }
+    }
+    if(!firmwareDataProfile) {
+        throw io_exception("Can not find firmware data profile.");
+    }
+
+    {
+        std::unique_lock<std::mutex> streamLock(streamMutex_);
+
+        backend_->startStream(firmwareDataProfile, [&](std::shared_ptr<const Frame> frame) {
+            ObcFrameHeader *frameHeader = (ObcFrameHeader *)frame->getData();
+            nvramData_.resize(frameHeader->metadataHeader.size);
+            {
+                std::unique_lock<std::mutex> lk(nvramMutex_);
+                memcpy(nvramData_.data(), (uint8_t *)frame->getData() + sizeof(ObcFrameHeader), frameHeader->metadataHeader.size);
+            }
+            nvramCV_.notify_all();
+        });
+    }
+
+    auto wait_thread = std::thread([this]() {
+        std::unique_lock<std::mutex> streamLock(streamMutex_);
+        waitNvramDataReady();
+        backend_->stopAllStream();
+    });
+    wait_thread.detach();
+}
+
+void RawPhaseStreamer::waitNvramDataReady() {
+    std::unique_lock<std::mutex> lk(nvramMutex_);
+    auto                         state = nvramCV_.wait_for(lk, std::chrono::seconds(10), [this] { return !nvramData_.empty(); });
+    if(!state) {
+        throw io_exception("Failed to get NVRAM data, timeout!");
+    }
+    LOG_DEBUG("NVRAM data is ready!");
+}
+
+void RawPhaseStreamer::enablePassiveIRMode(bool enable) {
+    passiveIRModeEnabled_ = enable;
+
+    for(auto &item: backendProfileMap_) {
+        if(item.first.first != 1024 || item.first.second != 1024) {
+            continue;
+        }
+        if(passiveIRModeEnabled_) {
+            item.second = { 8192, 130 };
+        }
+        else {
+            item.second = { 4096, 1154 };
+        }
+        break;
+    }
+
+    setStreamProfileList();
+}
+
+}  // namespace libobsensor
diff --git a/src/device/femtobolt/rawphase/RawPhaseStreamer.hpp b/src/device/femtobolt/rawphase/RawPhaseStreamer.hpp
new file mode 100644
index 00000000..ce631b44
--- /dev/null
+++ b/src/device/femtobolt/rawphase/RawPhaseStreamer.hpp
@@ -0,0 +1,81 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include <condition_variable>
+#include <atomic>
+#include <map>
+#include <mutex>
+#include <queue>
+
+#include "ISourcePort.hpp"
+#include "IDeviceComponent.hpp"
+#include "depthengine/DepthEngineLoader.hpp"
+#include "depthengine/YeatsFrameHdr.h"
+
+namespace libobsensor {
+class RawPhaseStreamer : public IDeviceComponent, public IVideoStreamPort {
+public:
+    RawPhaseStreamer(IDevice *owner, const std::shared_ptr<IVideoStreamPort> &backend);
+    virtual ~RawPhaseStreamer() noexcept;
+
+    IDevice *getOwner() const override;
+
+    std::shared_ptr<const SourcePortInfo> getSourcePortInfo() const override;
+    StreamProfileList                     getStreamProfileList() override;
+    void                                  startStream(std::shared_ptr<const StreamProfile> profile, MutableFrameCallback callback) override;
+    void                                  stopStream(std::shared_ptr<const StreamProfile> profile) override;
+    void                                  stopAllStream() override;
+
+    void enablePassiveIRMode(bool enable);
+    bool isRunning() const;
+    void waitNvramDataReady();
+
+private:
+    void parseAndOutputFrame(std::shared_ptr<Frame> frame);
+
+    // depth engine
+    void                    initNvramData();
+    void                    startDepthEngineThread(std::shared_ptr<const StreamProfile> profile);
+    void                    stopDepthEngineThread();
+    void                    initDepthEngine(std::shared_ptr<const StreamProfile> profile);
+    void                    deinitDepthEngine();
+    k4a_depth_engine_mode_t getDepthEngineMode(std::shared_ptr<const StreamProfile> profile);
+
+    void setStreamProfileList();
+
+private:
+    IDevice                          *owner_;
+    std::shared_ptr<IVideoStreamPort> backend_;
+
+    std::mutex                                                           cbMtx_;
+    std::map<std::shared_ptr<const StreamProfile>, MutableFrameCallback> callbacks_;
+
+    std::mutex                                                             streamMutex_;
+    std::atomic_bool                                                       running_;
+    std::map<std::pair<uint32_t, uint32_t>, std::pair<uint32_t, uint32_t>> backendProfileMap_;
+    StreamProfileList                                                      backendStreamProfileList_;
+    StreamProfileList                                                      streamProfileList_;
+    bool                                                                   passiveIRModeEnabled_ = false;
+
+    // nvram
+    std::mutex              nvramMutex_;
+    std::condition_variable nvramCV_;
+    std::vector<uint8_t>    nvramData_;
+
+    //  Depth Engine
+    k4a_depth_engine_context_t *depthEngineContext_ = nullptr;
+    k4a_depth_engine_mode_t     curDepthEngineMode_ = K4A_DEPTH_ENGINE_MODE_UNKNOWN;
+
+    std::shared_ptr<DepthEngineLoadFactory> depthEngineLoader_;
+    bool                                    depthEngineThreadExit_ = false;
+    std::thread                             depthEngineThread_;
+    std::shared_ptr<const StreamProfile>    lastStreamProfile_;
+
+    std::mutex                         frameQueueMutex_;
+    std::condition_variable            frameQueueCV_;
+    std::queue<std::shared_ptr<Frame>> frameQueue_;
+};
+
+}  // namespace libobsensor
diff --git a/src/device/femtobolt/rawphase/depthengine/CMakeLists.txt b/src/device/femtobolt/rawphase/depthengine/CMakeLists.txt
new file mode 100644
index 00000000..aaca0f18
--- /dev/null
+++ b/src/device/femtobolt/rawphase/depthengine/CMakeLists.txt
@@ -0,0 +1,16 @@
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+cmake_minimum_required(VERSION 3.5)
+
+file (GLOB _cpp_files "${CMAKE_CURRENT_LIST_DIR}/*.cpp")
+file (GLOB _head_files "${CMAKE_CURRENT_LIST_DIR}/*.hpp")
+
+foreach(_file IN ITEMS ${_cpp_files})
+        target_sources(${OB_TARGET_DEVICE} PRIVATE "${_file}")
+endforeach()
+
+foreach(_file IN ITEMS ${_head_files})
+        target_sources(${OB_TARGET_DEVICE} PRIVATE "${_file}")
+endforeach()
+
diff --git a/src/device/femtobolt/rawphase/depthengine/DepthEngineLoader.cpp b/src/device/femtobolt/rawphase/depthengine/DepthEngineLoader.cpp
new file mode 100644
index 00000000..92d781a6
--- /dev/null
+++ b/src/device/femtobolt/rawphase/depthengine/DepthEngineLoader.cpp
@@ -0,0 +1,35 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "DepthEngineLoader.hpp"
+#include "environment/EnvConfig.hpp"
+namespace libobsensor {
+
+DepthEngineLoadFactory::DepthEngineLoadFactory() {
+    std::string depthEngineLoadPath_ = EnvConfig::getExtensionsDirectory() + "/depthengine/";
+
+    dylib_ = std::make_shared<dylib>(depthEngineLoadPath_, "depthengine");
+
+    context_ = std::make_shared<deloader_global_context_t>();
+
+    if(dylib_) {
+        if(!dylib_->has_symbol(K4A_PLUGIN_EXPORTED_FUNCTION)) {
+            context_->loaded = false;
+            return;
+        }
+
+        void *symbol = dylib_->get_symbol(K4A_PLUGIN_EXPORTED_FUNCTION);
+        if(symbol) {
+            k4a_register_plugin_fn register_plugin = reinterpret_cast<k4a_register_plugin_fn>(symbol);
+            k4a_plugin_t           plugin;
+            bool                   result = register_plugin(&plugin);
+            if(result) {
+                context_->registerFn = register_plugin;
+                context_->plugin     = plugin;
+                context_->loaded     = true;
+            }
+        }
+    }
+}
+
+}  // namespace libobsensor
diff --git a/src/device/femtobolt/rawphase/depthengine/DepthEngineLoader.hpp b/src/device/femtobolt/rawphase/depthengine/DepthEngineLoader.hpp
new file mode 100644
index 00000000..3ac12ab4
--- /dev/null
+++ b/src/device/femtobolt/rawphase/depthengine/DepthEngineLoader.hpp
@@ -0,0 +1,38 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include <dylib.hpp>
+#include <memory>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+#include "k4aplugin.h"
+#ifdef __cplusplus
+}  // extern "C"
+#endif
+namespace libobsensor {
+
+typedef struct {
+    k4a_plugin_t           plugin;
+    k4a_register_plugin_fn registerFn;
+    volatile bool          loaded;
+} deloader_global_context_t;
+
+class DepthEngineLoadFactory {
+public:
+    DepthEngineLoadFactory();
+    ~DepthEngineLoadFactory() noexcept = default;
+
+    std::shared_ptr<deloader_global_context_t> getGlobalContext() {
+        return context_;
+    }
+
+private:
+    std::shared_ptr<dylib>                     dylib_;
+    std::shared_ptr<deloader_global_context_t> context_;
+};
+
+}  // namespace libobsensor
diff --git a/src/device/femtobolt/rawphase/depthengine/YeatsFrameHdr.h b/src/device/femtobolt/rawphase/depthengine/YeatsFrameHdr.h
new file mode 100644
index 00000000..ee26a473
--- /dev/null
+++ b/src/device/femtobolt/rawphase/depthengine/YeatsFrameHdr.h
@@ -0,0 +1,425 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+//
+// YeatsFrameHdr.h
+//
+// Copyright (C) Microsoft Corporation. All rights reserved.
+//
+// Defines types for Yeats chip headers.
+//
+
+#pragma once
+#ifndef _YEATSFRAMEHDR_H_
+#define _YEATSFRAMEHDR_H_
+
+#include <cstdint>
+#include <cstddef>
+
+const int YEATS_MIPI_HDR_SIZE_V1        = 128;
+const int YEATS_MIPI_HDR_SIZE_V2        = 160;
+const int YEATS_APP_FRAME_HDR_SIZE      = 512;
+const int YEATS_APP_FRAME_HDR_SIZE_V2   = 512;
+const int YEATS_MAX_NUM_CAPTURE_HEADERS = 16;
+
+union CLKGEN_TYPE {
+    uint16_t val;
+    struct {
+        uint8_t rise : 7;
+        uint8_t resv0 : 1;
+        uint8_t fall : 7;
+        uint8_t resv1 : 1;
+    } bits;
+};
+
+struct YEATS_MIPI_HDR {
+    uint16_t chipId;
+    uint16_t mipiHdrRev;
+
+    union {
+        uint32_t val;
+        struct {
+            uint16_t low;
+            uint16_t high;
+        } bits;
+
+    } lx5FwRev;
+
+    uint16_t frameNum;
+    uint16_t roiNum;
+    uint16_t frameWidth;   // One based value
+    uint16_t frameHeight;  // One based value
+    uint16_t startRow;     // Zero based value
+    uint16_t startCol;     // Zero based value
+    uint16_t dumpStyle;    // Not unpacking bit fields within this offset
+
+    union {
+        uint16_t val;
+        struct {
+            uint8_t outWidth : 5;
+            uint8_t resv0 : 3;
+            uint8_t raw : 2;
+            uint8_t compressed : 2;
+            uint8_t resv1 : 3;
+            uint8_t linear : 1;
+        } bits;
+
+    } outFormat;
+
+    uint16_t dynCal;
+    uint16_t rowsPerPkt;
+
+    union {
+        uint32_t val;
+        struct {
+            uint16_t low;
+            uint16_t high;
+        } bits;
+
+    } useqFWRev;
+
+    uint16_t ts_cal_ver;
+    uint16_t adc_cal_ver;
+    uint16_t gain_cal_ver;
+
+    uint16_t LX5_0;
+    uint16_t LX5_1;
+    uint16_t LX5_2;
+    uint16_t LX5_3;
+
+    uint16_t tie_pc_bypass;
+    uint32_t capTimerStart;
+    uint32_t capTimerEnd;
+
+    union {
+        uint16_t val;
+        struct {
+            uint16_t adcVal : 12;
+            uint16_t adcOver : 1;
+            uint16_t resv0 : 3;
+        } bits;
+
+    } tempSensorADC;
+
+    CLKGEN_TYPE clkgen_CK1;
+    CLKGEN_TYPE clkgen_CK2;
+    CLKGEN_TYPE clkgen_CK1ref;
+    CLKGEN_TYPE clkgen_CK2ref;
+    CLKGEN_TYPE clkgen_L1;
+    CLKGEN_TYPE clkgen_L2;
+
+    union {
+        uint16_t val;
+        struct {
+            uint8_t clkgen1_rise : 2;
+            uint8_t clkgen1_fall : 2;
+            uint8_t clkgen2_rise : 2;
+            uint8_t clkgen2_fall : 2;
+            uint8_t clkgen1Ref_rise : 2;
+            uint8_t clkgen1Ref_fall : 2;
+            uint8_t clkgen2Ref_rise : 2;
+            uint8_t clkgen2Ref_fall : 2;
+        } bits;
+
+    } clkgen_CKX;
+
+    uint16_t clkgen_Cycle;
+    uint16_t clkgen_offset;
+    uint16_t clkgen_ltoffset;
+    uint16_t clkgen_burst_period;
+
+    uint16_t reg_0;
+    uint16_t reg_1;
+    uint16_t reg_2;
+    uint16_t reg_3;
+    uint16_t reg_4;
+    uint16_t reg_5;
+    uint16_t reg_6;
+    uint16_t reg_7;
+
+    // Scratch Pad Regs
+    union {
+        uint16_t val;  // uSeq0
+        struct {
+            uint16_t mode : 4;
+            uint16_t resv0 : 12;
+        } bits;
+
+    } mode_info;
+
+    union {
+        uint16_t val;
+        struct {
+            uint16_t id : 6;
+            uint16_t nCaptures : 6;
+            uint16_t nFreqs : 4;
+        } bits;
+
+    } capture_info;
+
+    union {
+        uint16_t val;  // uSeq2
+        struct {
+            uint8_t phaseStep : 4;
+            uint8_t nPhaseSteps : 4;
+            uint8_t freqId : 4;
+            uint8_t rsvd0 : 4;
+        } bits;
+    } phase_info;
+
+    uint16_t capture_clkgen;
+    union {
+        uint16_t val;
+        struct {
+            uint16_t ClkgenNumerator : 9;  // Bits 0-8
+            uint16_t ClkgenDenom : 7;      // Bits 9-15
+        } bits;
+    } capture_phaseShift;
+
+    uint16_t modFreqVal;  // units of 10KHz
+
+    union {
+        uint16_t val;  // uSeq6
+        struct {
+            uint16_t Dump_type : 4;  // Pixel Data Type : 0 - diff, 1 - PCM, 2 - CM, 3 - Single A, 4 - Single B, 5 - Other
+            uint16_t resv0 : 12;
+        } bits;
+    } dump_info;
+
+    uint16_t integrationTime;
+    uint16_t intercaptureDelay;
+
+    union {
+        uint16_t val;
+        struct {
+            uint8_t LSDAC_Star;  // Starboard - Right
+            uint8_t LSDAC_Port;  // Left
+        } bits;
+    } LSDAC;
+
+    union {
+        uint16_t val;  // uSeq10
+        struct {
+            uint16_t LaserEn : 3;  //[0:2] - Enable Laser, 0 - Starboard, 1 - Port, 2 - LT / ST
+            uint16_t resv0 : 13;
+        } bits;
+    } LSFlags;
+
+    uint16_t uSeq_11;
+    uint16_t uSeq_12;
+    uint16_t uSeq_13;
+    uint16_t uSeq_14;
+    uint16_t uSeq_15;
+
+    // Bytes available in v2 of MIPI Header
+    uint16_t resv[16];
+};
+
+// static_assert(sizeof(YEATS_MIPI_HDR) == YEATS_MIPI_HDR_SIZE_V2, "Check type definition of YEATS_MIPI_HDR");
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wpedantic"
+#endif
+struct YEATS_APP_FRAME_HDR {
+    union {
+
+        uint8_t rawBytes[YEATS_APP_FRAME_HDR_SIZE];
+
+        struct {
+            uint16_t chipId;
+            uint16_t mipiHdrRev;
+            uint32_t lx5FwRev;
+            uint16_t frameNum;
+            uint16_t roiNum;
+            uint16_t frameWidth;   // One based value
+            uint16_t frameHeight;  // One based value
+            uint16_t startRow;     // Zero based value
+            uint16_t startCol;     // Zero based value
+            uint16_t dumpStyle;    // Not unpacking bit fields within this offset
+            uint16_t outFormat;
+            uint16_t dynCal;
+            uint16_t rowsPerPkt;
+            uint32_t useqFWRev;
+            uint16_t ts_cal_ver;
+            uint16_t adc_cal_ver;
+            uint16_t gain_cal_ver;
+            uint16_t LX5_0;
+            uint16_t LX5_1;
+            uint16_t LX5_2;
+            uint16_t LX5_3;
+            uint16_t tie_pc_bypass;
+            uint32_t capTimerStart;
+            uint32_t capTimerEnd;
+            uint16_t tempSensorADC;
+            uint16_t clkgen_CK1;
+            uint16_t clkgen_CK2;
+            uint16_t clkgen_CK1ref;
+            uint16_t clkgen_CK2ref;
+            uint16_t clkgen_L1;
+            uint16_t clkgen_L2;
+            uint16_t clkgen_CKX;
+            uint16_t clkgen_Cycle;
+            uint16_t clkgen_offset;
+            uint16_t clkgen_ltoffset;
+            uint16_t clkgen_burst_period;
+            uint16_t reg_0;
+            uint16_t reg_1;
+            uint16_t reg_2;
+            uint16_t reg_3;
+            uint16_t reg_4;
+            uint16_t reg_5;
+            uint16_t reg_6;
+            uint16_t reg_7;
+
+            uint16_t mode;  // Extracted field from REG_MODE_ID_CURR(uSeq0)
+            uint16_t uSeq_0;
+
+            uint16_t captureId;  // Extracted field from REG_CAPTURE_ID
+            uint16_t nCaptures;  // Extracted field from REG_CAPTURE_ID
+            uint16_t nFreqs;     // Extracted field from REG_CAPTURE_ID
+
+            uint16_t phaseStep;    // Extracted field from REG_CAPTURE_PHASESHIFT_ID(uSeq2)
+            uint16_t nPhaseSteps;  // Extracted field from REG_CAPTURE_PHASESHIFT_ID(uSeq2)
+            uint16_t freqId;       // Extracted field from REG_CAPTURE_PHASESHIFT_ID(uSeq2)
+            uint16_t uSeq_2;
+
+            uint16_t capture_clkgen;
+            uint16_t ClkgenNumerator;
+            uint16_t ClkgenDenom;
+            uint16_t modFreqVal;  // units of 10KHz
+
+            uint16_t dumpType;  // Pixel Data Type : 0 - diff, 1 - PCM, 2 - CM, 3 - Single A, 4 - Single B, 5 - Other
+            uint16_t uSeq_6;
+
+            uint16_t integrationTime;
+            uint16_t intercaptureDelay;
+
+            // Expanded fields from LSDAC field of YEATS_MIPI_HDR
+            uint8_t LSDAC_Star;
+            uint8_t LSDAC_Port;
+
+            uint16_t LSFlags;  //[0:2] - Enable Laser, 0 - Starboard, 1 - Port, 2 - LT/ST
+            uint16_t uSeq_10;
+
+            uint16_t uSeq_11;
+            uint16_t uSeq_12;
+            uint16_t uSeq_13;
+            uint16_t uSeq_14;
+            uint16_t uSeq_15;
+            uint16_t rsvd;  // Complier alignment
+
+            // App layer inserted fields
+            float    Temp_sensor_DegC;
+            float    Temp_sensor_slope;
+            float    Temp_sensor_offset;
+            float    Laser_Temp0;
+            uint32_t AppTimeStamp;
+            uint64_t FWTimeStamp;
+            float    SoCTemp;
+        } bits;
+    };
+};
+
+// static_assert(sizeof(YEATS_APP_FRAME_HDR) == YEATS_APP_FRAME_HDR_SIZE, "Check type definition of YEATS_APP_FRAME_HDR");
+
+// Appended at the end of YEATS_APP_FRAME_HDR_V2 nCaptureHeaders field.
+struct YEATS_APP_CAPTURE_HEADER {
+    uint8_t  appCaptureHdrVer;  // Version of this struct.
+    uint8_t  captureId;         // Extracted field from REG_CAPTURE_ID
+    uint8_t  phaseStep;         // Extracted field from REG_CAPTURE_PHASESHIFT_ID(uSeq2)
+    uint8_t  freqId;            // Extracted field from REG_CAPTURE_PHASESHIFT_ID(uSeq2)
+    uint32_t capTimerStart;
+    uint32_t capTimerEnd;
+    uint16_t ClkgenNumerator;
+    uint16_t ClkgenDenom;
+    uint16_t modFreqVal;  // units of 10KHz
+    uint16_t integrationTime;
+    uint16_t intercaptureDelay;
+    uint16_t resv;
+};
+
+// static_assert(sizeof(YEATS_APP_CAPTURE_HEADER) == 24, "Check type definition of YEATS_APP_FRAME_HDR");
+
+struct YEATS_APP_FRAME_HDR_V2 {
+    union {
+        uint8_t rawBytes[YEATS_APP_FRAME_HDR_SIZE_V2];
+
+        struct {
+            uint16_t appFrameHdrVer;  // Start off with the version of this struct.
+            uint16_t chipId;
+            uint32_t lx5FwRev;
+            uint32_t useqFWRev;
+            uint32_t appFrameNum;  // This refers to the processed frame number.
+            uint16_t rawFrameNum;  // This refers to the captured frame number.
+            uint16_t roiNum;
+            uint16_t appFrameWidth;   // One based value OUTPUT image width.
+            uint16_t appFrameHeight;  // ONE based value OUTPUT image height.
+            uint16_t rawFrameWidth;   // One based value INPUT image width.
+            uint16_t rawFrameHeight;  // One based value INPUT image height.
+            uint16_t rawStartRow;     // Zero based value of the raw image offset row relative to sensor array.
+            uint16_t rawStartCol;     // Zero based value of the raw image offset column relative to sensor array.
+            uint16_t dumpStyle;       // Not unpacking bit fields within this offset
+            uint16_t outFormat;
+            uint16_t dynCal;
+            uint16_t rowsPerPkt;
+            uint16_t ts_cal_ver;
+            uint16_t adc_cal_ver;
+            uint16_t gain_cal_ver;
+            uint16_t LX5_0;
+            uint16_t LX5_1;
+            uint16_t LX5_2;
+            uint16_t LX5_3;
+            uint16_t tie_pc_bypass;
+            uint16_t mode;         // Extracted field from REG_MODE_ID_CURR(uSeq0)
+            uint16_t nCaptures;    // Extracted field from REG_CAPTURE_ID
+            uint16_t nFreqs;       // Extracted field from REG_CAPTURE_ID
+            uint16_t nPhaseSteps;  // Extracted field from REG_CAPTURE_PHASESHIFT_ID(uSeq2)
+            uint16_t capture_clkgen;
+            uint16_t dumpType;  // Pixel Data Type : 0 - diff, 1 - PCM, 2 - CM, 3 - Single A, 4 - Single B, 5 - Other
+
+            float ModuleTemp;
+            float SoCTemp;
+            float sensorTemp;  // The sensor temperature that is used by depth engine for temperature correction.
+
+            uint64_t mipiRxNanoseconds;        // The time stamp when the last MIPI capture was received, in nanoseconds.
+            uint64_t appStartNanoseconds;      // The time stamp when the app (eR2D) starts, in nanoseconds.
+            uint64_t appEndNanoseconds;        // The time stamp when the app (eR2D) ends, in nanoseconds.
+            uint64_t usbTxRequestNanoseconds;  // The time stamp when a USB transfer request is made, in nanoseconds.
+
+            // Expanded fields from LSDAC field of YEATS_MIPI_HDR
+            uint16_t LSDAC_Star;
+            uint16_t LSDAC_Port;
+            uint16_t LSFlags;  //[0:2] - Enable Laser, 0 - Starboard, 1 - Port, 2 - LT/ST
+
+            // Depth engine app inserted fields
+            uint8_t SensorId;
+            uint8_t CaptureMode;  // 0 - Streaming, 1 - Offline/Playback
+            uint8_t ProcMode;     // 0 - Raw Mode, 1 - Processed Z/AB
+            uint8_t depthEngineType;
+
+            uint16_t resv;  // Reserved for alignment.
+
+            // ---------------------------------------------------------------
+            // The following is metadata that varies per capture.
+            YEATS_APP_CAPTURE_HEADER captureHeaders[YEATS_MAX_NUM_CAPTURE_HEADERS];
+        } bits;
+    };
+};
+
+// static_assert(offsetof(YEATS_APP_FRAME_HDR_V2, mipiRxNanoseconds) == 20 * 4, "Check type definition of YEATS_APP_FRAME_HDR_V2");
+// static_assert(offsetof(YEATS_APP_FRAME_HDR_V2, captureHeaders) == 31 * 4, "Check type definition of YEATS_APP_FRAME_HDR_V2");
+// static_assert(sizeof(YEATS_APP_FRAME_HDR_V2) == YEATS_APP_FRAME_HDR_SIZE_V2, "Check type definition of YEATS_APP_FRAME_HDR_V2");
+
+struct FRAME_FOOTER {
+    uint32_t Signature;
+    uint16_t BlockSize;
+    uint16_t BlockVer;
+    uint64_t TimeStamp;  // The time stamp when the frame arrives over MIPI, in nanoseconds.
+    float    SoCTemp;    // Same as SoCTemp in YEATS_APP_FRAME_HDR.
+    float    ModuleTemp;
+};
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
+#endif  // end of #ifndef _YEATSFRAMEHDR_H_
+
diff --git a/src/device/femtobolt/rawphase/depthengine/k4aplugin.h b/src/device/femtobolt/rawphase/depthengine/k4aplugin.h
new file mode 100644
index 00000000..80496104
--- /dev/null
+++ b/src/device/femtobolt/rawphase/depthengine/k4aplugin.h
@@ -0,0 +1,532 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+/** \file k4aplugin.h
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ * Kinect For Azure Depth Engine Plugin API.
+ * Defines the API which must be defined by the depth engine plugin to be used
+ * by the Azure Kinect SDK.
+ */
+
+#ifndef K4A_PLUGIN_H
+#define K4A_PLUGIN_H
+
+#include <stddef.h>
+#include <stdint.h>
+#include <stdbool.h>
+
+#ifndef _WIN32
+#define __stdcall /**< __stdcall not defined in Linux */
+#define __cdecl   /**< __cdecl not defined in Linux */
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * Current Version of the Azure Kinect Depth Engine Plugin Interface
+ *
+ * \remarks
+ * When the depth engine plugin interface (k4a_plugin_t) is updated, this version should be increased.
+ *
+ * \remarks
+ * The depth version binary name has the plugin version appended to it to signify the compatibility between the plugin
+ * and the depth engine.
+ */
+#define K4A_PLUGIN_VERSION 2 /**< Azure Kinect plugin version */
+
+/**
+ * Expected name of plugin's dynamic library
+ *
+ * \remarks When the Azure Kinect SDK tried to load the depth engine, it will attempt to
+ * load a dynamic library with name contains "depthengine". The name contains a
+ * version number to bind with the matching depth engine plugin interface.
+ */
+#define K4A_PLUGIN_DYNAMIC_LIBRARY_NAME "depthengine"
+
+/**
+ * Name of the function all plugins must export in a dynamic library
+ *
+ * \remarks Upon finding a dynamic library named "depthengine", the k4aplugin
+ * loader will attempt to find a symbol named k4a_register_plugin. Please see
+ * \ref k4a_register_plugin_fn for the signature of that function.
+ */
+#define K4A_PLUGIN_EXPORTED_FUNCTION "k4a_register_plugin"
+
+/** Supported Depth Engine modes
+ *
+ * \xmlonly
+ * <requirements>
+ *   <requirement name="Header">k4aplugin.h (include k4a/k4aplugin.h)</requirement>
+ * </requirements>
+ * \endxmlonly
+ */
+typedef enum {
+    K4A_DEPTH_ENGINE_MODE_UNKNOWN            = -1, /**< Unknown Depth Engine mode */
+    K4A_DEPTH_ENGINE_MODE_ST                 = 0,  /**< Internal use only */
+    K4A_DEPTH_ENGINE_MODE_LT_HW_BINNING      = 1,  /**< Internal use only */
+    K4A_DEPTH_ENGINE_MODE_LT_SW_BINNING      = 2,  /**< Translates to K4A_DEPTH_MODE_NFOV_2X2BINNED */
+    K4A_DEPTH_ENGINE_MODE_PCM                = 3,  /**< Translates to K4A_DEPTH_MODE_PASSIVE_IR */
+    K4A_DEPTH_ENGINE_MODE_LT_NATIVE          = 4,  /**< Translates to K4A_DEPTH_MODE_NFOV_UNBINNED */
+    K4A_DEPTH_ENGINE_MODE_MEGA_PIXEL         = 5,  /**< Translates to K4A_DEPTH_MODE_WFOV_UNBINNED */
+    K4A_DEPTH_ENGINE_MODE_QUARTER_LT_NATIVE  = 6,  /**< Translates to K4A_DEPTH_MODE_NFOV_2X2BINNED */
+    K4A_DEPTH_ENGINE_MODE_QUARTER_MEGA_PIXEL = 7,  /**< Translates to K4A_DEPTH_MODE_WFOV_2X2BINNED */
+} k4a_depth_engine_mode_t;
+
+/** Depth Engine output types
+ *
+ * \xmlonly
+ * <requirements>
+ *   <requirement name="Header">k4aplugin.h (include k4a/k4aplugin.h)</requirement>
+ * </requirements>
+ * \endxmlonly
+ */
+typedef enum {
+    K4A_DEPTH_ENGINE_OUTPUT_TYPE_Z_DEPTH = 0,  /**< Output z depth */
+    K4A_DEPTH_ENGINE_OUTPUT_TYPE_RADIAL_DEPTH, /**< Output radial depth */
+    K4A_DEPTH_ENGINE_OUTPUT_TYPE_PCM,          /**< Output passive ir */
+} k4a_depth_engine_output_type_t;
+
+/** Depth Engine supported input formats
+ *
+ * \xmlonly
+ * <requirements>
+ *   <requirement name="Header">k4aplugin.h (include k4a/k4aplugin.h)</requirement>
+ * </requirements>
+ * \endxmlonly
+ */
+typedef enum {
+    K4A_DEPTH_ENGINE_INPUT_TYPE_UNKNOWN             = 0, /**< Unknown Depth Engine input type */
+    K4A_DEPTH_ENGINE_INPUT_TYPE_16BIT_LINEAR        = 1, /**< Internal use only */
+    K4A_DEPTH_ENGINE_INPUT_TYPE_12BIT_RAW           = 2, /**< Internal use only */
+    K4A_DEPTH_ENGINE_INPUT_TYPE_12BIT_COMPRESSED    = 3, /**< 12bit compressed */
+    K4A_DEPTH_ENGINE_INPUT_TYPE_8BIT_COMPRESSED     = 4, /**< 8bit compressed */
+    K4A_DEPTH_ENGINE_INPUT_TYPE_12BIT_RAW_MIPI      = 5, /**< 12bit Raw MIPI Packed*/
+    K4A_DEPTH_ENGINE_INPUT_TYPE_8BIT_COMPRESSED_RAW = 6, /**< 8bit compressed Raw. 8BIT_COMPRESSED_RAW is exact same as
+                                                            8BIT_COMPRESSED just without the headers */
+    K4A_DEPTH_ENGINE_INPUT_TYPE_16BIT_RAW = 7            /**< 16bit Raw. 16BIT_RAW is 12BIT_RAW_MIPI with the MIPI unpack already
+                                                            complete */
+} k4a_depth_engine_input_type_t;
+
+/** Transform Engine types
+ *
+ * \xmlonly
+ * <requirements>
+ *   <requirement name="Header">k4aplugin.h (include k4a/k4aplugin.h)</requirement>
+ * </requirements>
+ * \endxmlonly
+ */
+typedef enum {
+    K4A_TRANSFORM_ENGINE_TYPE_COLOR_TO_DEPTH = 0,      /**< Transforms color image into the geometry of depth camera */
+    K4A_TRANSFORM_ENGINE_TYPE_DEPTH_TO_COLOR,          /**< Transforms depth image into the geometry of color camera */
+    K4A_TRANSFORM_ENGINE_TYPE_DEPTH_CUSTOM8_TO_COLOR,  /**< Transforms depth + 8 bit custom data into color camera */
+    K4A_TRANSFORM_ENGINE_TYPE_DEPTH_CUSTOM16_TO_COLOR, /**< Transforms depth + 16 bit custom data into color camera */
+} k4a_transform_engine_type_t;
+
+/** Transform Engine interpolation type
+ *
+ * \xmlonly
+ * <requirements>
+ *   <requirement name="Header">k4aplugin.h (include k4a/k4aplugin.h)</requirement>
+ * </requirements>
+ * \endxmlonly
+ */
+typedef enum {
+    K4A_TRANSFORM_ENGINE_INTERPOLATION_NEAREST = 0, /**< Nearest neighbor interpolation */
+    K4A_TRANSFORM_ENGINE_INTERPOLATION_LINEAR       /**< Linear interpolation */
+} k4a_transform_engine_interpolation_t;
+
+/** Depth Engine output frame information
+ *
+ * \xmlonly
+ * <requirements>
+ *   <requirement name="Header">k4aplugin.h (include k4a/k4aplugin.h)</requirement>
+ * </requirements>
+ * \endxmlonly
+ */
+typedef struct _k4a_depth_engine_output_frame_info_t {
+    uint16_t output_width;                /**< Output frame width */
+    uint16_t output_height;               /**< Output frame height */
+    float    sensor_temp;                 /**< Sensor temperature degrees in C */
+    float    laser_temp[2];               /**< Laser temperature degrees in C */
+    uint64_t center_of_exposure_in_ticks; /**< Tick timestamp with the center of exposure */
+    uint64_t usb_sof_tick;                /**< Tick timestamp with the USB SoF was seen */
+} k4a_depth_engine_output_frame_info_t;
+
+/** Depth Engine input frame information
+ *
+ * /remarks At Runtime, please set to null, we parse these information from a
+ * raw compressed input. Some internal testing may use this to pass in temperature info.
+ *
+ * \xmlonly
+ * <requirements>
+ *   <requirement name="Header">k4aplugin.h (include k4a/k4aplugin.h)</requirement>
+ * </requirements>
+ * \endxmlonly
+ */
+typedef struct _k4a_depth_engine_input_frame_info_t {
+    float    sensor_temp;                 /**< Sensor Temperature in Deg C */
+    float    laser_temp[2];               /**< Laser Temperature in Deg C */
+    uint64_t center_of_exposure_in_ticks; /**< Tick timestamp with the center of exposure */
+    uint64_t usb_sof_tick;                /**< Tick timestamp with the USB SoF was seen */
+} k4a_depth_engine_input_frame_info_t;
+
+/** Depth Engine settings
+ *
+ * /remarks Depth engine settings such as thresholds and filter sizes that can be changed
+ * at runtime.
+ *
+ * \xmlonly
+ * <requirements>
+ *   <requirement name="Header">k4aplugin.h (include k4a/k4aplugin.h)</requirement>
+ * </requirements>
+ * \endxmlonly
+ */
+typedef struct _k4a_depth_engine_settings_t {
+    float MaxConfidence;               /**< Maximum depth error confidence above which depth pixel is invalidated. */
+    float ABMinFreqThreshold;          /**< Minimum active brightness frequency threshold below which depth pixel is invalidated.
+                                        */
+    float    ABSumThreshold;           /**< Minimum active brightness sum threshold below which depth pixel is invalidated. */
+    float    ABRatioThreshold;         /**< Minimum active brightness ratio threshold below which depth pixel is invalidated. */
+    uint16_t RadialDepthMaxThreshold;  /**< Maximum radial depth threshold above which depth pixel is invalidated. */
+    uint16_t RadialDepthMinThreshold;  /**< Minimum radial depth threshold below which depth pixel is invalidated. */
+    uint8_t  ReflectivityMinThreshold; /**< Minimum reflectivity threshold below which reflectivity pixel is invalidated.
+                                        */
+    float ReflectivityFactor;          /**< Reflectivity factor. */
+    int   JBLFWindowSize;              /**< Joint bilateral filter window size, must be odd. */
+    float JBLFGaussianSigma;           /**< Joint bilateral filter sigma parameter for gaussian distribution. */
+    float JBLExpTerm;                  /**< Joint bilateral filter exponential term parameter. */
+    float JBLEdgeThreshold;            /**< Joint bilateral filter edge threshold. */
+    float JBLCenterLowABThreshold;     /**< Joint bilateral filter center low AB threshold. */
+    float JBLNeighborLowABThreshold;   /**< Joint bilateral filter neighbor low AB threshold. */
+} k4a_depth_engine_settings_t;
+
+/** Depth Engine return codes
+ *
+ * \xmlonly
+ * <requirements>
+ *   <requirement name="Header">k4aplugin.h (include k4a/k4aplugin.h)</requirement>
+ * </requirements>
+ * \endxmlonly
+ */
+typedef enum {
+    K4A_DEPTH_ENGINE_RESULT_SUCCEEDED = 0, /**< Result succeeded */
+
+    // Frame data error, require caller to retry with expected frame data
+    K4A_DEPTH_ENGINE_RESULT_DATA_ERROR_INVALID_INPUT_BUFFER_SIZE  = 1, /**< Invalid input buffer size */
+    K4A_DEPTH_ENGINE_RESULT_DATA_ERROR_INVALID_OUTPUT_BUFFER_SIZE = 2, /**< Invalid output buffer size */
+    K4A_DEPTH_ENGINE_RESULT_DATA_ERROR_INVALID_CAPTURE_SEQUENCE   = 3, /**< Invalid input capture data */
+    K4A_DEPTH_ENGINE_RESULT_DATA_ERROR_NULL_INPUT_BUFFER          = 4, /**< Invalid input buffer pointer */
+    K4A_DEPTH_ENGINE_RESULT_DATA_ERROR_NULL_OUTPUT_BUFFER         = 5, /**< Invalid output buffer pointer */
+
+    // System fatal error, require caller to restart depth engine
+    K4A_DEPTH_ENGINE_RESULT_FATAL_ERROR_NULL_ENGINE_POINTER             = 101, /**< Depth Engine was not initialized */
+    K4A_DEPTH_ENGINE_RESULT_FATAL_ERROR_INITIALIZE_ENGINE_FAILED        = 102, /**< Failed to initialize Depth Engine */
+    K4A_DEPTH_ENGINE_RESULT_FATAL_ERROR_UPDATE_CALIBRATION_FAILED       = 103, /**< Failed to create depth calibration */
+    K4A_DEPTH_ENGINE_RESULT_FATAL_ERROR_PROCESS_PCM_FAILED              = 104, /**< Failed to process passive ir */
+    K4A_DEPTH_ENGINE_RESULT_FATAL_ERROR_BIN_INPUT_FAILED                = 105, /**< Failed to bin the input pixels */
+    K4A_DEPTH_ENGINE_RESULT_FATAL_ERROR_WAIT_PROCESSING_COMPLETE_FAILED = 106, /**< Failed to wait for processing
+                                                                                  complete */
+    K4A_DEPTH_ENGINE_RESULT_FATAL_ERROR_NULL_CAMERA_CALIBRATION_POINTER = 107, /**< Camera calibration was null */
+    K4A_DEPTH_ENGINE_RESULT_FATAL_ERROR_ENGINE_NOT_LOADED               = 108, /**< Depth Engine plugin was not loaded */
+    K4A_DEPTH_ENGINE_RESULT_ERROR_UPDATE_SETTINGS_FAILED                = 109, /**< Failed to update threshold settings. */
+    K4A_DEPTH_ENGINE_RESULT_FATAL_ERROR_GPU_OUT_OF_MEMORY               = 201, /**< Failed to allocate memory */
+    K4A_DEPTH_ENGINE_RESULT_FATAL_ERROR_GPU_INVALID_PARAMETER           = 202, /**< Invalid input parameter */
+    K4A_DEPTH_ENGINE_RESULT_FATAL_ERROR_GPU_INVALID_CALIBRATION         = 203, /**< Invalid depth calibration */
+    K4A_DEPTH_ENGINE_RESULT_FATAL_ERROR_GPU_FROM_API                    = 204, /**< GPU API returns failure */
+    K4A_DEPTH_ENGINE_RESULT_FATAL_ERROR_GPU_INTERNAL                    = 205, /**< GPU processing internal error */
+    K4A_DEPTH_ENGINE_RESULT_FATAL_ERROR_GPU_SHADER_COMPILATION          = 206, /**< GPU shader compilation error */
+    K4A_DEPTH_ENGINE_RESULT_FATAL_ERROR_GPU_OPENGL_CONTEXT              = 207, /**< OpenGL context creation error */
+    K4A_DEPTH_ENGINE_RESULT_FATAL_ERROR_GPU_TIMEOUT                     = 208, /**< GPU processing timed out */
+
+    // Frame dropped during asynchronous call, only be sent to async caller with event listener
+    K4A_DEPTH_ENGINE_RESULT_FRAME_DROPPED_ASYNC = 301, /**< Frame dropped during asynchronous call */
+
+} k4a_depth_engine_result_code_t;
+/** Depth Engine plugin version
+ *
+ * /remarks On load, Azure Kinect will validate that major versions match between the SDK
+ * and the plugin.
+ *
+ * \xmlonly
+ * <requirements>k4a_depth
+ *   <requirement name="Header">k4aplugin.h (include k4a/k4aplugin.h)</requirement>
+ * </requirements>
+ * \endxmlonly
+ */
+typedef struct {
+    uint32_t major; /**< Plugin Major Version */
+    uint32_t minor; /**< Plugin Minor Version */
+    uint32_t patch; /**< Plugin Patch Version */
+} k4a_plugin_version_t;
+
+/** Depth Engine context handle to be implemented by plugin
+ *
+ * \xmlonly
+ * <requirements>
+ *   <requirement name="Header">k4aplugin.h (include k4a/k4aplugin.h)</requirement>
+ * </requirements>
+ * \endxmlonly
+ */
+typedef struct k4a_depth_engine_context_t k4a_depth_engine_context_t;
+
+/** Transform Engine context handle to be implemented by plugin
+ *
+ * \xmlonly
+ * <requirements>
+ *   <requirement name="Header">k4aplugin.h (include k4a/k4aplugin.h)</requirement>
+ * </requirements>
+ * \endxmlonly
+ */
+typedef struct k4a_transform_engine_context_t k4a_transform_engine_context_t;
+
+/** Callback function for depth engine finishing processing.
+ *
+ * \param context
+ * The context passed into k4a_de_process_frame_fn_t
+ *
+ * \param status
+ * The result of the processing. 0 is a success
+ *
+ * \param output_frame
+ * The final processed buffer passed back out to the user
+ *
+ * \param output_frame2
+ * Second output buffer passed back out to the user or null
+ */
+typedef void(__stdcall k4a_processing_complete_cb_t)(void *context, int status, void *output_frame, void *output_frame2);
+
+/** Function for creating and initializing the depth engine.
+ *
+ * \param context
+ * An opaque pointer to be passed around to the rest of the depth engine calls.
+ *
+ * \param cal_block_size_in_bytes
+ * Size of the depth calibration blob being passed in, in bytes
+ *
+ * \param cal_block
+ * The depth calibration blob
+ *
+ * \param mode
+ * The \ref k4a_depth_engine_mode_t to initialize the depth engine
+ *
+ * \param input_format
+ * The \ref k4a_depth_engine_input_type_t being passed in
+ *
+ * \param camera_calibration
+ * The depth camera calibration blob
+ *
+ * \param callback
+ * Callback to call when processing is complete
+ *
+ * \param callback_context
+ * An optional context to be passed back to the callback
+ *
+ * \returns
+ * K4A_DEPTH_ENGINE_RESULT_SUCCEEDED on success, or the proper failure code on
+ * failure
+ */
+typedef k4a_depth_engine_result_code_t(__stdcall *k4a_de_create_and_initialize_fn_t)(k4a_depth_engine_context_t **context, size_t cal_block_size_in_bytes,
+                                                                                     void *cal_block, k4a_depth_engine_mode_t mode,
+                                                                                     k4a_depth_engine_input_type_t input_format,
+                                                                                     void *camera_calibration,  // Fallback to use ccb intrinsics if it is null
+                                                                                     k4a_processing_complete_cb_t *callback, void *callback_context);
+
+/** Function to process depth frame.
+ *
+ * \param context
+ * context created by \ref k4a_de_create_and_initialize_fn_t
+ *
+ * \param input_frame
+ * Input frame buffer containing depth raw captured data
+ *
+ * \param input_frame_size
+ * Size of the input_frame buffer in bytes
+ *
+ * \param output_type
+ * The type of frame the depth engine should output
+ *
+ * \param output_frame
+ * The buffer of the output frame
+ *
+ * \param output_frame_size in bytes
+ * The size of the output_frame buffer
+ *
+ * \param output_frame_info
+ * The depth frame output information
+ *
+ * \param input_frame_info
+ * The input frame information (internal use only), should pass in null at runtime
+ *
+ * \returns
+ * K4A_DEPTH_ENGINE_RESULT_SUCCEEDED on success, or the proper failure code on
+ * failure
+ */
+typedef k4a_depth_engine_result_code_t(__stdcall *k4a_de_process_frame_fn_t)(k4a_depth_engine_context_t *context, void *input_frame, size_t input_frame_size,
+                                                                             k4a_depth_engine_output_type_t output_type, void *output_frame,
+                                                                             size_t output_frame_size, k4a_depth_engine_output_frame_info_t *output_frame_info,
+                                                                             k4a_depth_engine_input_frame_info_t *input_frame_info);
+
+/** Get the size of the output frame in bytes.
+ *
+ * \param context
+ * context created by \ref k4a_de_create_and_initialize_fn_t
+ *
+ * \returns
+ * The size of the output frame in bytes (or 0 if passed a null context)
+ */
+typedef size_t(__stdcall *k4a_de_get_output_frame_size_fn_t)(k4a_depth_engine_context_t *context);
+
+/** Destroys the depth engine context.
+ *
+ * \param context
+ * context created by \ref k4a_de_create_and_initialize_fn_t
+ */
+typedef void(__stdcall *k4a_de_destroy_fn_t)(k4a_depth_engine_context_t **context);
+
+/** Function for creating and initializing the transform engine.
+ *
+ * \param context
+ * An opaque pointer to be passed around to the rest of the transform engine calls
+ *
+ * \param camera_calibration
+ * The transform engine calibration blob
+ *
+ * \param callback
+ * Callback to call when processing is complete
+ *
+ * \param callback_context
+ * An optional context to be passed back to the callback
+ *
+ * \returns
+ * K4A_DEPTH_ENGINE_RESULT_SUCCEEDED on success, or the proper failure code on
+ * failure
+ */
+typedef k4a_depth_engine_result_code_t(__stdcall *k4a_te_create_and_initialize_fn_t)(k4a_transform_engine_context_t **context, void *camera_calibration,
+                                                                                     k4a_processing_complete_cb_t *callback, void *callback_context);
+
+/** Function to transform between depth and color frame.
+ *
+ * \param context
+ * context created by \ref k4a_te_create_and_initialize_fn_t
+ *
+ * \param type
+ * The type of transform engine
+ *
+ * \param interpolation
+ * The interpolation type for aux frame data
+ *
+ * \param invalid_value
+ * The desired value for invalid pixel data
+ *
+ * \param depth_frame
+ * Frame buffer containing depth frame data
+ *
+ * \param depth_frame_size
+ * Size of the depth_frame buffer in bytes
+ *
+ * \param frame2
+ * Frame buffer containing color or aux frame data
+ *
+ * \param frame2_size
+ * Size of the frame2 buffer in bytes
+ *
+ * \param output_frame
+ * The buffer of the output frame
+ *
+ * \param output_frame_size
+ * Size of the output_frame buffer in bytes
+ *
+ * \param output_frame2
+ * Second output buffer or null if there is none
+ *
+ * \param output_frame2_size
+ * Size of the output_frame2 buffer in bytes
+ *
+ * \returns
+ * K4A_DEPTH_ENGINE_RESULT_SUCCEEDED on success, or the proper failure code on
+ * failure
+ */
+typedef k4a_depth_engine_result_code_t(__stdcall *k4a_te_process_frame_fn_t)(k4a_transform_engine_context_t *context, k4a_transform_engine_type_t type,
+                                                                             k4a_transform_engine_interpolation_t interpolation, uint32_t invalid_value,
+                                                                             const void *depth_frame, size_t depth_frame_size, const void *frame2,
+                                                                             size_t frame2_size, void *output_frame, size_t output_frame_size,
+                                                                             void *output_frame2, size_t output_frame2_size);
+
+/** Get the size of the output frame in bytes.
+ *
+ * \param context
+ * context created by \ref k4a_te_create_and_initialize_fn_t
+ *
+ * \param type
+ * The type of transform engine
+ *
+ * \returns
+ * The size of the output frame in bytes (or 0 if passed a null context)
+ */
+typedef size_t(__stdcall *k4a_te_get_output_frame_size_fn_t)(k4a_transform_engine_context_t *context, k4a_transform_engine_type_t type);
+
+/** Destroys the transform engine context.
+ *
+ * \param context
+ * context created by \ref k4a_te_create_and_initialize_fn_t
+ */
+typedef void(__stdcall *k4a_te_destroy_fn_t)(k4a_transform_engine_context_t **context);
+
+/** Plugin API which must be populated on plugin registration.
+ *
+ * \remarks
+ * The Azure Kinect SDK will call k4a_register_plugin, and pass in a pointer to a \ref
+ * k4a_plugin_t. The plugin must properly fill out all fields of the plugin for
+ * the Azure Kinect SDK to accept the plugin.
+ *
+ * \xmlonly
+ * <requirements>
+ *   <requirement name="Header">k4aplugin.h (include k4a/k4aplugin.h)</requirement>
+ * </requirements>
+ * \endxmlonly
+ */
+typedef struct _k4a_plugin_t {
+    k4a_plugin_version_t              version;                                /**< Depth Engine Version */
+    k4a_de_create_and_initialize_fn_t depth_engine_create_and_initialize;     /**< Function pointer to a
+                                                                                 depth_engine_create_and_initialize function
+                                                                               */
+    k4a_de_process_frame_fn_t depth_engine_process_frame;                     /**< Function pointer to a depth_engine_process_frame function
+                                                                               */
+    k4a_de_get_output_frame_size_fn_t depth_engine_get_output_frame_size;     /**< Function pointer to a
+                                                                                 depth_engine_get_output_frame_size function
+                                                                               */
+    k4a_de_destroy_fn_t               depth_engine_destroy;                   /**< Function pointer to a depth_engine_destroy function */
+    k4a_te_create_and_initialize_fn_t transform_engine_create_and_initialize; /**< Function pointer to a
+                                                                                 transform_engine_create_and_initialize
+                                                                                 function */
+    k4a_te_process_frame_fn_t transform_engine_process_frame;                 /**< Function pointer to a transform_engine_process_frame
+                                                                                 function */
+    k4a_te_get_output_frame_size_fn_t transform_engine_get_output_frame_size; /**< Function pointer to a
+                                                                                 transform_engine_get_output_frame_size
+                                                                                 function */
+    k4a_te_destroy_fn_t transform_engine_destroy;                             /**< Function pointer to a transform_engine_destroy function */
+} k4a_plugin_t;
+
+/** Function signature for \ref K4A_PLUGIN_EXPORTED_FUNCTION.
+ *
+ * \remarks
+ * Plugins must implement a function named "k4a_register_plugin" which will
+ * fill out all fields in the passed in \ref k4a_plugin_t.
+ *
+ * \param plugin
+ * function pointers and version of the plugin to filled out
+ *
+ * \returns
+ * True if the plugin believes it successfully registered, false otherwise.
+ */
+typedef bool(__cdecl *k4a_register_plugin_fn)(k4a_plugin_t *plugin);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* K4A_PLUGIN_H */
+
diff --git a/src/device/femtomega/CMakeLists.txt b/src/device/femtomega/CMakeLists.txt
new file mode 100644
index 00000000..9a302ece
--- /dev/null
+++ b/src/device/femtomega/CMakeLists.txt
@@ -0,0 +1,17 @@
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+cmake_minimum_required(VERSION 3.5)
+
+target_sources(
+    ${OB_TARGET_DEVICE}
+    PRIVATE  ${CMAKE_CURRENT_LIST_DIR}/FemtoMegaDevice.hpp
+             ${CMAKE_CURRENT_LIST_DIR}/FemtoMegaDevice.cpp
+             ${CMAKE_CURRENT_LIST_DIR}/FemtoMegaDeviceInfo.hpp
+             ${CMAKE_CURRENT_LIST_DIR}/FemtoMegaDeviceInfo.cpp
+             ${CMAKE_CURRENT_LIST_DIR}/FemtoMegaPropertyAccessor.hpp
+             ${CMAKE_CURRENT_LIST_DIR}/FemtoMegaPropertyAccessor.cpp
+             ${CMAKE_CURRENT_LIST_DIR}/FemtoMegaFrameTimestampCalculator.hpp
+             ${CMAKE_CURRENT_LIST_DIR}/FemtoMegaFrameTimestampCalculator.cpp
+        )
+
diff --git a/src/device/femtomega/FemtoMegaDevice.cpp b/src/device/femtomega/FemtoMegaDevice.cpp
new file mode 100644
index 00000000..9c1d0012
--- /dev/null
+++ b/src/device/femtomega/FemtoMegaDevice.cpp
@@ -0,0 +1,882 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "FemtoMegaDevice.hpp"
+#include "Platform.hpp"
+#include "environment/EnvConfig.hpp"
+#include "stream/StreamProfileFactory.hpp"
+#include "sensor/video/VideoSensor.hpp"
+#include "sensor/video/DisparityBasedSensor.hpp"
+#include "sensor/imu/ImuStreamer.hpp"
+#include "sensor/imu/AccelSensor.hpp"
+#include "sensor/imu/GyroSensor.hpp"
+#include "usb/uvc/UvcDevicePort.hpp"
+
+#include "metadata/FrameMetadataParserContainer.hpp"
+#include "timestamp/GlobalTimestampFitter.hpp"
+#include "timestamp/FrameTimestampCalculator.hpp"
+#include "timestamp/DeviceClockSynchronizer.hpp"
+#include "property/VendorPropertyAccessor.hpp"
+#include "property/UvcPropertyAccessor.hpp"
+#include "property/PropertyServer.hpp"
+#include "property/CommonPropertyAccessors.hpp"
+#include "property/FilterPropertyAccessors.hpp"
+#include "property/PrivateFilterPropertyAccessors.hpp"
+#include "param/AlgParamManager.hpp"
+#include "syncconfig/DeviceSyncConfigurator.hpp"
+
+#include "FilterFactory.hpp"
+#include "publicfilters/FormatConverterProcess.hpp"
+#include "publicfilters/IMUCorrector.hpp"
+
+#include "utils/BufferParser.hpp"
+#include "utils/PublicTypeHelper.hpp"
+
+#include "FemtoMegaPropertyAccessor.hpp"
+#include "FemtoMegaFrameTimestampCalculator.hpp"
+
+#if defined(BUILD_NET_PAL)
+#include "ethernet/RTSPStreamPort.hpp"
+#endif
+
+namespace libobsensor {
+FemtoMegaUsbDevice::FemtoMegaUsbDevice(const std::shared_ptr<const IDeviceEnumInfo> &info) : DeviceBase(info) {
+    init();
+}
+
+FemtoMegaUsbDevice::~FemtoMegaUsbDevice() noexcept {}
+
+void FemtoMegaUsbDevice::init() {
+    initSensorList();
+    initProperties();
+
+    fetchDeviceInfo();
+    fetchExtensionInfo();
+    if(getFirmwareVersionInt() >= 10209) {
+        deviceTimeFreq_ = 1000000;
+        frameTimeFreq_  = 1000000;
+    }
+
+    auto globalTimestampFilter = std::make_shared<GlobalTimestampFitter>(this);
+    registerComponent(OB_DEV_COMPONENT_GLOBAL_TIMESTAMP_FILTER, globalTimestampFilter);
+
+    auto algParamManager = std::make_shared<TOFDeviceCommonAlgParamManager>(this);
+    registerComponent(OB_DEV_COMPONENT_ALG_PARAM_MANAGER, algParamManager);
+
+    static const std::vector<OBMultiDeviceSyncMode>          supportedSyncModes  = { OB_MULTI_DEVICE_SYNC_MODE_FREE_RUN, OB_MULTI_DEVICE_SYNC_MODE_STANDALONE,
+                                                                                     OB_MULTI_DEVICE_SYNC_MODE_PRIMARY, OB_MULTI_DEVICE_SYNC_MODE_SECONDARY };
+    static const std::map<OBMultiDeviceSyncMode, OBSyncMode> syncModeNewToOldMap = { { OB_MULTI_DEVICE_SYNC_MODE_FREE_RUN, OB_SYNC_MODE_CLOSE },
+                                                                                     { OB_MULTI_DEVICE_SYNC_MODE_STANDALONE, OB_SYNC_MODE_STANDALONE },
+                                                                                     { OB_MULTI_DEVICE_SYNC_MODE_PRIMARY, OB_SYNC_MODE_PRIMARY_MCU_TRIGGER },
+                                                                                     { OB_MULTI_DEVICE_SYNC_MODE_SECONDARY, OB_SYNC_MODE_SECONDARY },
+                                                                                     { OB_MULTI_DEVICE_SYNC_MODE_SECONDARY_SYNCED, OB_SYNC_MODE_SECONDARY } };
+    static const std::map<OBSyncMode, OBMultiDeviceSyncMode> syncModeOldToNewMap = { { OB_SYNC_MODE_CLOSE, OB_MULTI_DEVICE_SYNC_MODE_FREE_RUN },
+                                                                                     { OB_SYNC_MODE_STANDALONE, OB_MULTI_DEVICE_SYNC_MODE_STANDALONE },
+                                                                                     { OB_SYNC_MODE_PRIMARY_MCU_TRIGGER, OB_MULTI_DEVICE_SYNC_MODE_PRIMARY },
+                                                                                     { OB_SYNC_MODE_SECONDARY, OB_MULTI_DEVICE_SYNC_MODE_SECONDARY } };
+    auto deviceSyncConfigurator = std::make_shared<DeviceSyncConfiguratorOldProtocol>(this, supportedSyncModes);
+    deviceSyncConfigurator->updateModeAliasMap(syncModeOldToNewMap, syncModeNewToOldMap);
+    deviceSyncConfigurator->enableDepthDelaySupport(true);
+    registerComponent(OB_DEV_COMPONENT_DEVICE_SYNC_CONFIGURATOR, deviceSyncConfigurator);
+
+    auto deviceClockSynchronizer = std::make_shared<DeviceClockSynchronizer>(this);
+    registerComponent(OB_DEV_COMPONENT_DEVICE_CLOCK_SYNCHRONIZER, deviceClockSynchronizer);
+}
+
+void FemtoMegaUsbDevice::initSensorStreamProfile(std::shared_ptr<ISensor> sensor) {
+    auto sensorType    = sensor->getSensorType();
+    auto streamProfile = StreamProfileFactory::getDefaultStreamProfileFromEnvConfig(deviceInfo_->name_, sensorType);
+    if(streamProfile) {
+        sensor->updateDefaultStreamProfile(streamProfile);
+    }
+
+    // // bind params: extrinsics, intrinsics, etc.
+    auto profiles = sensor->getStreamProfileList();
+    {
+        auto algParamManager = getComponentT<TOFDeviceCommonAlgParamManager>(OB_DEV_COMPONENT_ALG_PARAM_MANAGER);
+        algParamManager->bindStreamProfileParams(profiles);
+    }
+
+    LOG_INFO("Sensor {} created! Found {} stream profiles.", sensorType, profiles.size());
+    for(auto &profile: profiles) {
+        LOG_INFO(" - {}", profile);
+    }
+}
+
+void FemtoMegaUsbDevice::initSensorList() {
+    registerComponent(OB_DEV_COMPONENT_FRAME_PROCESSOR_FACTORY, [this]() {
+        std::shared_ptr<FrameProcessorFactory> factory;
+        TRY_EXECUTE({ factory = std::make_shared<FrameProcessorFactory>(this); })
+        return factory;
+    });
+    auto        platform           = Platform::getInstance();
+    const auto &sourcePortInfoList = enumInfo_->getSourcePortInfoList();
+    auto depthPortInfoIter = std::find_if(sourcePortInfoList.begin(), sourcePortInfoList.end(), [](const std::shared_ptr<const SourcePortInfo> &portInfo) {
+        return portInfo->portType == SOURCE_PORT_USB_UVC && std::dynamic_pointer_cast<const USBSourcePortInfo>(portInfo)->infIndex == 2;
+    });
+
+    if(depthPortInfoIter != sourcePortInfoList.end()) {
+        auto depthPortInfo = *depthPortInfoIter;
+
+        registerComponent(
+            OB_DEV_COMPONENT_DEPTH_SENSOR,
+            [this, depthPortInfo]() {
+                auto platform = Platform::getInstance();
+                auto port     = platform->getSourcePort(depthPortInfo);
+
+                auto sensor = std::make_shared<VideoSensor>(this, OB_SENSOR_DEPTH, port);
+
+                auto videoFrameTimestampCalculator = std::make_shared<FrameTimestampCalculatorOverUvcSCR>(this, frameTimeFreq_);
+                sensor->setFrameTimestampCalculator(videoFrameTimestampCalculator);
+
+                auto globalFrameTimestampCalculator = std::make_shared<GlobalTimestampCalculator>(this, deviceTimeFreq_, frameTimeFreq_);
+                sensor->setGlobalTimestampCalculator(globalFrameTimestampCalculator);
+
+                auto frameProcessor = getComponentT<FrameProcessor>(OB_DEV_COMPONENT_DEPTH_FRAME_PROCESSOR, false);
+                if(frameProcessor) {
+                    sensor->setFrameProcessor(frameProcessor.get());
+                }
+
+                initSensorStreamProfile(sensor);
+                return sensor;
+            },
+            true);
+
+        registerSensorPortInfo(OB_SENSOR_DEPTH, depthPortInfo);
+
+        registerComponent(OB_DEV_COMPONENT_DEPTH_FRAME_PROCESSOR, [this]() {
+            auto factory = getComponentT<FrameProcessorFactory>(OB_DEV_COMPONENT_FRAME_PROCESSOR_FACTORY);
+
+            auto frameProcessor = factory->createFrameProcessor(OB_SENSOR_DEPTH);
+            return frameProcessor;
+        });
+
+        // the main property accessor is using the depth port(uvc xu)
+        registerComponent(OB_DEV_COMPONENT_MAIN_PROPERTY_ACCESSOR, [this, depthPortInfo]() {
+            auto platform = Platform::getInstance();
+            auto port     = platform->getSourcePort(depthPortInfo);
+            auto accessor = std::make_shared<VendorPropertyAccessor>(this, port);
+            return accessor;
+        });
+    }
+
+    auto irPortInfoIter = std::find_if(sourcePortInfoList.begin(), sourcePortInfoList.end(), [](const std::shared_ptr<const SourcePortInfo> &portInfo) {
+        return portInfo->portType == SOURCE_PORT_USB_UVC && std::dynamic_pointer_cast<const USBSourcePortInfo>(portInfo)->infIndex == 4;
+    });
+
+    if(irPortInfoIter != sourcePortInfoList.end()) {
+        auto irPortInfo = *irPortInfoIter;
+
+        registerComponent(
+            OB_DEV_COMPONENT_IR_SENSOR,
+            [this, irPortInfo]() {
+                auto platform = Platform::getInstance();
+                auto port     = platform->getSourcePort(irPortInfo);
+
+                auto sensor = std::make_shared<VideoSensor>(this, OB_SENSOR_IR, port);
+
+                auto videoFrameTimestampCalculator = std::make_shared<FrameTimestampCalculatorOverUvcSCR>(this, frameTimeFreq_);
+                sensor->setFrameTimestampCalculator(videoFrameTimestampCalculator);
+
+                auto globalFrameTimestampCalculator = std::make_shared<GlobalTimestampCalculator>(this, deviceTimeFreq_, frameTimeFreq_);
+                sensor->setGlobalTimestampCalculator(globalFrameTimestampCalculator);
+
+                initSensorStreamProfile(sensor);
+                return sensor;
+            },
+            true);
+
+        registerSensorPortInfo(OB_SENSOR_IR, irPortInfo);
+
+        registerComponent(OB_DEV_COMPONENT_IR_FRAME_PROCESSOR, [this]() {
+            auto factory = getComponentT<FrameProcessorFactory>(OB_DEV_COMPONENT_FRAME_PROCESSOR_FACTORY);
+
+            auto frameProcessor = factory->createFrameProcessor(OB_SENSOR_IR);
+            return frameProcessor;
+        });
+    }
+
+    auto colorPortInfoIter = std::find_if(sourcePortInfoList.begin(), sourcePortInfoList.end(), [](const std::shared_ptr<const SourcePortInfo> &portInfo) {
+        return portInfo->portType == SOURCE_PORT_USB_UVC && std::dynamic_pointer_cast<const USBSourcePortInfo>(portInfo)->infIndex == 0;
+    });
+
+    if(colorPortInfoIter != sourcePortInfoList.end()) {
+        auto colorPortInfo = *colorPortInfoIter;
+        registerComponent(
+            OB_DEV_COMPONENT_COLOR_SENSOR,
+            [this, colorPortInfo]() {
+                auto platform = Platform::getInstance();
+                auto port     = platform->getSourcePort(colorPortInfo);
+                auto sensor   = std::make_shared<VideoSensor>(this, OB_SENSOR_COLOR, port);
+
+                std::vector<FormatFilterConfig> formatFilterConfigs = {
+                    { FormatFilterPolicy::REMOVE, OB_FORMAT_NV12, OB_FORMAT_ANY, nullptr },
+                };
+
+                auto formatConverter = getSensorFrameFilter("FormatConverter", OB_SENSOR_COLOR, false);
+                if(formatConverter) {
+#ifdef WIN32
+                    formatFilterConfigs.push_back({ FormatFilterPolicy::ADD, OB_FORMAT_BGR, OB_FORMAT_RGB, formatConverter });
+#else
+                    formatFilterConfigs.push_back({ FormatFilterPolicy::ADD, OB_FORMAT_MJPG, OB_FORMAT_RGB, formatConverter });
+                    formatFilterConfigs.push_back({ FormatFilterPolicy::ADD, OB_FORMAT_MJPG, OB_FORMAT_BGR, formatConverter });
+                    formatFilterConfigs.push_back({ FormatFilterPolicy::ADD, OB_FORMAT_MJPG, OB_FORMAT_BGRA, formatConverter });
+#endif
+                }
+
+                sensor->updateFormatFilterConfig(formatFilterConfigs);
+
+                auto videoFrameTimestampCalculator = std::make_shared<FrameTimestampCalculatorOverUvcSCR>(this, frameTimeFreq_);
+                sensor->setFrameTimestampCalculator(videoFrameTimestampCalculator);
+
+                auto globalFrameTimestampCalculator = std::make_shared<GlobalTimestampCalculator>(this, deviceTimeFreq_, frameTimeFreq_);
+                sensor->setGlobalTimestampCalculator(globalFrameTimestampCalculator);
+
+                auto frameProcessor = getComponentT<FrameProcessor>(OB_DEV_COMPONENT_COLOR_FRAME_PROCESSOR, false);
+                if(frameProcessor) {
+                    sensor->setFrameProcessor(frameProcessor.get());
+                }
+
+                initSensorStreamProfile(sensor);
+
+                return sensor;
+            },
+            true);
+        registerSensorPortInfo(OB_SENSOR_COLOR, colorPortInfo);
+
+        registerComponent(OB_DEV_COMPONENT_COLOR_FRAME_PROCESSOR, [this]() {
+            auto factory        = getComponentT<FrameProcessorFactory>(OB_DEV_COMPONENT_FRAME_PROCESSOR_FACTORY);
+            auto frameProcessor = factory->createFrameProcessor(OB_SENSOR_COLOR);
+            return frameProcessor;
+        });
+    }
+
+    auto imuPortInfoIter = std::find_if(sourcePortInfoList.begin(), sourcePortInfoList.end(),
+                                        [](const std::shared_ptr<const SourcePortInfo> &portInfo) { return portInfo->portType == SOURCE_PORT_USB_HID; });
+
+    if(imuPortInfoIter != sourcePortInfoList.end()) {
+        auto imuPortInfo = *imuPortInfoIter;
+        registerComponent(OB_DEV_COMPONENT_IMU_STREAMER, [this, imuPortInfo]() {
+            // the gyro and accel are both on the same port and share the same filter
+            auto                                  platform           = Platform::getInstance();
+            auto                                  port               = platform->getSourcePort(imuPortInfo);
+            auto                                  imuReversionFilter = getSensorFrameFilter("IMUFrameReversion", OB_SENSOR_ACCEL, true);
+            auto                                  imuCorrectorFilter = getSensorFrameFilter("IMUCorrector", OB_SENSOR_ACCEL, true);
+            std::vector<std::shared_ptr<IFilter>> imuFilters         = { imuReversionFilter, imuCorrectorFilter };
+            auto                                  dataStreamPort     = std::dynamic_pointer_cast<IDataStreamPort>(port);
+            auto                                  imuStreamer        = std::make_shared<ImuStreamer>(this, dataStreamPort, imuFilters);
+            return imuStreamer;
+        });
+
+        registerComponent(
+            OB_DEV_COMPONENT_ACCEL_SENSOR,
+            [this, imuPortInfo]() {
+                auto platform             = Platform::getInstance();
+                auto port                 = platform->getSourcePort(imuPortInfo);
+                auto imuStreamer          = getComponentT<ImuStreamer>(OB_DEV_COMPONENT_IMU_STREAMER);
+                auto imuStreamerSharedPtr = imuStreamer.get();
+                auto sensor               = std::make_shared<AccelSensor>(this, port, imuStreamerSharedPtr);
+
+                auto globalFrameTimestampCalculator = std::make_shared<GlobalTimestampCalculator>(this, deviceTimeFreq_, frameTimeFreq_);
+                sensor->setGlobalTimestampCalculator(globalFrameTimestampCalculator);
+
+                initSensorStreamProfile(sensor);
+
+                return sensor;
+            },
+            true);
+        registerSensorPortInfo(OB_SENSOR_ACCEL, imuPortInfo);
+
+        registerComponent(
+            OB_DEV_COMPONENT_GYRO_SENSOR,
+            [this, imuPortInfo]() {
+                auto platform             = Platform::getInstance();
+                auto port                 = platform->getSourcePort(imuPortInfo);
+                auto imuStreamer          = getComponentT<ImuStreamer>(OB_DEV_COMPONENT_IMU_STREAMER);
+                auto imuStreamerSharedPtr = imuStreamer.get();
+                auto sensor               = std::make_shared<GyroSensor>(this, port, imuStreamerSharedPtr);
+
+                auto globalFrameTimestampCalculator = std::make_shared<GlobalTimestampCalculator>(this, deviceTimeFreq_, frameTimeFreq_);
+                sensor->setGlobalTimestampCalculator(globalFrameTimestampCalculator);
+
+                initSensorStreamProfile(sensor);
+
+                return sensor;
+            },
+            true);
+        registerSensorPortInfo(OB_SENSOR_GYRO, imuPortInfo);
+    }
+}
+
+void FemtoMegaUsbDevice::initProperties() {
+    auto propertyServer = std::make_shared<PropertyServer>(this);
+
+    auto femtoMegaTempPropertyAccessor = std::make_shared<FemtoMegaTempPropertyAccessor>(this);
+    propertyServer->registerProperty(OB_STRUCT_DEVICE_TEMPERATURE, "r", "r", femtoMegaTempPropertyAccessor);
+
+    auto sensors = getSensorTypeList();
+    for(auto &sensor: sensors) {
+        auto  platform       = Platform::getInstance();
+        auto &sourcePortInfo = getSensorPortInfo(sensor);
+        if(sensor == OB_SENSOR_COLOR) {
+            auto uvcPropertyAccessor = std::make_shared<LazyPropertyAccessor>([&sourcePortInfo]() {
+                auto platform = Platform::getInstance();
+                auto port     = platform->getSourcePort(sourcePortInfo);
+                auto accessor = std::make_shared<UvcPropertyAccessor>(port);
+                return accessor;
+            });
+
+            propertyServer->registerProperty(OB_PROP_COLOR_AUTO_EXPOSURE_BOOL, "rw", "rw", uvcPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_COLOR_GAIN_INT, "rw", "rw", uvcPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_COLOR_SATURATION_INT, "rw", "rw", uvcPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_COLOR_AUTO_WHITE_BALANCE_BOOL, "rw", "rw", uvcPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_COLOR_WHITE_BALANCE_INT, "rw", "rw", uvcPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_COLOR_BRIGHTNESS_INT, "rw", "rw", uvcPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_COLOR_SHARPNESS_INT, "rw", "rw", uvcPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_COLOR_CONTRAST_INT, "rw", "rw", uvcPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_COLOR_POWER_LINE_FREQUENCY_INT, "rw", "rw", uvcPropertyAccessor);
+        }
+        else if(sensor == OB_SENSOR_DEPTH) {
+            auto vendorPropertyAccessor = std::make_shared<LazySuperPropertyAccessor>([this, &sourcePortInfo]() {
+                auto platform = Platform::getInstance();
+                auto port     = platform->getSourcePort(sourcePortInfo);
+                auto accessor = std::make_shared<VendorPropertyAccessor>(this, port);
+                return accessor;
+            });
+
+            propertyServer->registerProperty(OB_PROP_FEMTO_MEGA_HARDWARE_D2C_BOOL, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_DEPTH_ALIGN_HARDWARE_MODE_INT, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_TIMESTAMP_OFFSET_INT, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_FAN_WORK_MODE_INT, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_COLOR_EXPOSURE_INT, "rw", "rw", vendorPropertyAccessor);  // using vendor property accessor
+            propertyServer->registerProperty(OB_PROP_EXTERNAL_SIGNAL_RESET_BOOL, "", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_HEARTBEAT_BOOL, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_DEVICE_COMMUNICATION_TYPE_INT, "", "w", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_SWITCH_IR_MODE_INT, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_FAN_WORK_LEVEL_INT, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_FAN_WORK_SPEED_INT, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_USB_POWER_STATE_INT, "r", "r", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_DC_POWER_STATE_INT, "r", "r", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_STRUCT_VERSION, "", "r", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_STRUCT_DEVICE_SERIAL_NUMBER, "r", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_STRUCT_MULTI_DEVICE_SYNC_CONFIG, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_STRUCT_DEVICE_IP_ADDR_CONFIG, "rw", "rw", vendorPropertyAccessor);
+            //  propertyServer->registerProperty(OB_STRUCT_PERIPHERAL_ID_INFO, "", "r", vendorPropertyAccessor);
+            //  propertyServer->registerProperty(OB_STRUCT_LED_CONTROL, "", "w", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_RAW_DATA_CAMERA_CALIB_JSON_FILE, "r", "r", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_STRUCT_DEVICE_TIME, "rw", "rw", vendorPropertyAccessor);
+            // propertyServer->registerProperty(OB_RAW_DATA_MCU_UPGRADE_FILE, "rw", "rw", vendorPropertyPort);
+            // propertyServer->registerProperty(OB_RAW_DATA_HARDWARE_ALIGN_PARAM, "rw", "rw", vendorPropertyPort);
+            propertyServer->registerProperty(OB_PROP_INDICATOR_LIGHT_BOOL, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_BOOT_INTO_RECOVERY_MODE_BOOL, "w", "w", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_TIMER_RESET_ENABLE_BOOL, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_TIMER_RESET_SIGNAL_BOOL, "w", "w", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_RAW_DATA_IMU_CALIB_PARAM, "", "rw", vendorPropertyAccessor);
+            // propertyServer->registerProperty(OB_STRUCT_LED_CONTROL, "", "w", vendorPropertyPort);
+
+            propertyServer->registerProperty(OB_RAW_DATA_ALIGN_CALIB_PARAM, "", "r", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_RAW_DATA_D2C_ALIGN_SUPPORT_PROFILE_LIST, "", "rw", vendorPropertyAccessor);
+            // propertyServer->registerProperty(OB_PROP_FAN_MAX_SPEED_TEST_MODE_BOOL, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_GYRO_ODR_INT, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_ACCEL_ODR_INT, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_GYRO_FULL_SCALE_INT, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_ACCEL_FULL_SCALE_INT, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_STRUCT_GET_ACCEL_PRESETS_ODR_LIST, "", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_STRUCT_GET_ACCEL_PRESETS_FULL_SCALE_LIST, "", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_STRUCT_GET_GYRO_PRESETS_ODR_LIST, "", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_STRUCT_GET_GYRO_PRESETS_FULL_SCALE_LIST, "", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_ACCEL_SWITCH_BOOL, "", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_GYRO_SWITCH_BOOL, "", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_TOF_EXPOSURE_TIME_INT, "r", "r", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_STOP_IR_STREAM_BOOL, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_STOP_COLOR_STREAM_BOOL, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_STOP_DEPTH_STREAM_BOOL, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_REBOOT_DEVICE_BOOL, "w", "w", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_COLOR_EXPOSURE_INT, "rw", "rw", vendorPropertyAccessor);
+        }
+        else if(sensor == OB_SENSOR_ACCEL) {
+            auto imuCorrectorFilter = getSensorFrameFilter("IMUCorrector", sensor);
+            if(imuCorrectorFilter) {
+                auto filterStateProperty = std::make_shared<FilterStatePropertyAccessor>(imuCorrectorFilter);
+                propertyServer->registerProperty(OB_PROP_SDK_ACCEL_FRAME_TRANSFORMED_BOOL, "rw", "rw", filterStateProperty);
+            }
+        }
+        else if(sensor == OB_SENSOR_GYRO) {
+            auto imuCorrectorFilter = getSensorFrameFilter("IMUCorrector", sensor);
+            if(imuCorrectorFilter) {
+                auto filterStateProperty = std::make_shared<FilterStatePropertyAccessor>(imuCorrectorFilter);
+                propertyServer->registerProperty(OB_PROP_SDK_GYRO_FRAME_TRANSFORMED_BOOL, "rw", "rw", filterStateProperty);
+            }
+        }
+    }
+
+    propertyServer->aliasProperty(OB_PROP_IR_EXPOSURE_INT, OB_PROP_TOF_EXPOSURE_TIME_INT);
+    propertyServer->aliasProperty(OB_PROP_DEPTH_EXPOSURE_INT, OB_PROP_TOF_EXPOSURE_TIME_INT);
+    propertyServer->aliasProperty(OB_PROP_DEPTH_ALIGN_HARDWARE_BOOL, OB_PROP_FEMTO_MEGA_HARDWARE_D2C_BOOL);
+
+    registerComponent(OB_DEV_COMPONENT_PROPERTY_SERVER, propertyServer, true);
+
+    BEGIN_TRY_EXECUTE({ propertyServer->setPropertyValueT(OB_PROP_DEVICE_COMMUNICATION_TYPE_INT, OB_COMM_USB); })
+    CATCH_EXCEPTION_AND_EXECUTE({ LOG_ERROR("Set device communication type to usb mode failed!"); })
+}
+
+FemtoMegaNetDevice::FemtoMegaNetDevice(const std::shared_ptr<const IDeviceEnumInfo> &info) : DeviceBase(info) {
+    init();
+}
+
+FemtoMegaNetDevice::~FemtoMegaNetDevice() noexcept {}
+
+void FemtoMegaNetDevice::init() {
+    initSensorList();
+    initProperties();
+
+    fetchDeviceInfo();
+    fetchExtensionInfo();
+    fetchAllVideoStreamProfileList();
+
+    if(getFirmwareVersionInt() >= 10209) {
+        deviceTimeFreq_     = 1000000;
+        depthFrameTimeFreq_ = 1000000;
+    }
+
+    auto globalTimestampFilter = std::make_shared<GlobalTimestampFitter>(this);
+    registerComponent(OB_DEV_COMPONENT_GLOBAL_TIMESTAMP_FILTER, globalTimestampFilter);
+
+    auto algParamManager = std::make_shared<TOFDeviceCommonAlgParamManager>(this);
+    registerComponent(OB_DEV_COMPONENT_ALG_PARAM_MANAGER, algParamManager);
+
+    static const std::vector<OBMultiDeviceSyncMode>          supportedSyncModes  = { OB_MULTI_DEVICE_SYNC_MODE_FREE_RUN, OB_MULTI_DEVICE_SYNC_MODE_STANDALONE,
+                                                                                     OB_MULTI_DEVICE_SYNC_MODE_PRIMARY, OB_MULTI_DEVICE_SYNC_MODE_SECONDARY };
+    static const std::map<OBMultiDeviceSyncMode, OBSyncMode> syncModeNewToOldMap = { { OB_MULTI_DEVICE_SYNC_MODE_FREE_RUN, OB_SYNC_MODE_CLOSE },
+                                                                                     { OB_MULTI_DEVICE_SYNC_MODE_STANDALONE, OB_SYNC_MODE_STANDALONE },
+                                                                                     { OB_MULTI_DEVICE_SYNC_MODE_PRIMARY, OB_SYNC_MODE_PRIMARY_MCU_TRIGGER },
+                                                                                     { OB_MULTI_DEVICE_SYNC_MODE_SECONDARY, OB_SYNC_MODE_SECONDARY },
+                                                                                     { OB_MULTI_DEVICE_SYNC_MODE_SECONDARY_SYNCED, OB_SYNC_MODE_SECONDARY } };
+    static const std::map<OBSyncMode, OBMultiDeviceSyncMode> syncModeOldToNewMap = { { OB_SYNC_MODE_CLOSE, OB_MULTI_DEVICE_SYNC_MODE_FREE_RUN },
+                                                                                     { OB_SYNC_MODE_STANDALONE, OB_MULTI_DEVICE_SYNC_MODE_STANDALONE },
+                                                                                     { OB_SYNC_MODE_PRIMARY_MCU_TRIGGER, OB_MULTI_DEVICE_SYNC_MODE_PRIMARY },
+                                                                                     { OB_SYNC_MODE_SECONDARY, OB_MULTI_DEVICE_SYNC_MODE_SECONDARY } };
+    auto deviceSyncConfigurator = std::make_shared<DeviceSyncConfiguratorOldProtocol>(this, supportedSyncModes);
+    deviceSyncConfigurator->updateModeAliasMap(syncModeOldToNewMap, syncModeNewToOldMap);
+    deviceSyncConfigurator->enableDepthDelaySupport(true);
+    registerComponent(OB_DEV_COMPONENT_DEVICE_SYNC_CONFIGURATOR, deviceSyncConfigurator);
+
+    auto deviceClockSynchronizer = std::make_shared<DeviceClockSynchronizer>(this, deviceTimeFreq_, deviceTimeFreq_);
+    registerComponent(OB_DEV_COMPONENT_DEVICE_CLOCK_SYNCHRONIZER, deviceClockSynchronizer);
+}
+
+void FemtoMegaNetDevice::fetchDeviceInfo() {
+    auto propServer                   = getPropertyServer();
+    auto version                      = propServer->getStructureDataT<OBVersionInfo>(OB_STRUCT_VERSION);
+    auto deviceInfo                   = std::make_shared<NetDeviceInfo>();
+    auto portInfo                     = enumInfo_->getSourcePortInfoList().front();
+    auto netPortInfo                  = std::dynamic_pointer_cast<const NetSourcePortInfo>(portInfo);
+    deviceInfo->ipAddress_            = netPortInfo->address;
+    deviceInfo_                       = deviceInfo;
+    deviceInfo_->name_                = enumInfo_->getName();
+    deviceInfo_->fwVersion_           = version.firmwareVersion;
+    deviceInfo_->deviceSn_            = version.serialNumber;
+    deviceInfo_->asicName_            = version.depthChip;
+    deviceInfo_->hwVersion_           = version.hardwareVersion;
+    deviceInfo_->type_                = static_cast<uint16_t>(version.deviceType);
+    deviceInfo_->supportedSdkVersion_ = version.sdkVersion;
+    deviceInfo_->pid_                 = enumInfo_->getPid();
+    deviceInfo_->vid_                 = enumInfo_->getVid();
+    deviceInfo_->uid_                 = enumInfo_->getUid();
+    deviceInfo_->connectionType_      = enumInfo_->getConnectionType();
+
+    // remove the prefix "Orbbec " from the device name if contained
+    if(deviceInfo_->name_.find("Orbbec ") == 0) {
+        deviceInfo_->name_ = deviceInfo_->name_.substr(7);
+    }
+    deviceInfo_->fullName_ = "Orbbec " + deviceInfo_->name_;
+
+    // mark the device as a multi-sensor device with same clock at default
+    extensionInfo_["AllSensorsUsingSameClock"] = "true";
+}
+
+void FemtoMegaNetDevice::initSensorList() {
+    registerComponent(OB_DEV_COMPONENT_FRAME_PROCESSOR_FACTORY, [this]() {
+        std::shared_ptr<FrameProcessorFactory> factory;
+        TRY_EXECUTE({ factory = std::make_shared<FrameProcessorFactory>(this); })
+        return factory;
+    });
+
+    auto        platform           = Platform::getInstance();
+    const auto &sourcePortInfoList = enumInfo_->getSourcePortInfoList();
+    auto depthPortInfoIter = std::find_if(sourcePortInfoList.begin(), sourcePortInfoList.end(), [](const std::shared_ptr<const SourcePortInfo> &portInfo) {
+        return portInfo->portType == SOURCE_PORT_NET_RTSP && std::dynamic_pointer_cast<const RTSPStreamPortInfo>(portInfo)->streamType == OB_STREAM_DEPTH;
+    });
+
+    if(depthPortInfoIter != sourcePortInfoList.end()) {
+        auto depthPortInfo = *depthPortInfoIter;
+        registerComponent(
+            OB_DEV_COMPONENT_DEPTH_SENSOR,
+            [this, depthPortInfo]() {
+                auto platform = Platform::getInstance();
+                auto port     = platform->getSourcePort(depthPortInfo);
+
+                auto sensor = std::make_shared<VideoSensor>(this, OB_SENSOR_DEPTH, port);
+
+                auto videoFrameTimestampCalculator_ = std::make_shared<FrameTimestampCalculatorDirectly>(this, depthFrameTimeFreq_);
+                sensor->setFrameTimestampCalculator(videoFrameTimestampCalculator_);
+
+                auto globalFrameTimestampCalculator = std::make_shared<GlobalTimestampCalculator>(this, deviceTimeFreq_, depthFrameTimeFreq_);
+                sensor->setGlobalTimestampCalculator(globalFrameTimestampCalculator);
+
+                auto frameProcessor = getComponentT<FrameProcessor>(OB_DEV_COMPONENT_DEPTH_FRAME_PROCESSOR, false);
+                if(frameProcessor) {
+                    sensor->setFrameProcessor(frameProcessor.get());
+                }
+
+                initSensorStreamProfile(sensor);
+                return sensor;
+            },
+            true);
+
+        registerSensorPortInfo(OB_SENSOR_DEPTH, depthPortInfo);
+
+        registerComponent(OB_DEV_COMPONENT_DEPTH_FRAME_PROCESSOR, [this]() {
+            auto factory = getComponentT<FrameProcessorFactory>(OB_DEV_COMPONENT_FRAME_PROCESSOR_FACTORY);
+
+            auto frameProcessor = factory->createFrameProcessor(OB_SENSOR_DEPTH);
+            return frameProcessor;
+        });
+    }
+
+    auto irPortInfoIter = std::find_if(sourcePortInfoList.begin(), sourcePortInfoList.end(), [](const std::shared_ptr<const SourcePortInfo> &portInfo) {
+        return portInfo->portType == SOURCE_PORT_NET_RTSP && std::dynamic_pointer_cast<const RTSPStreamPortInfo>(portInfo)->streamType == OB_STREAM_IR;
+    });
+
+    if(irPortInfoIter != sourcePortInfoList.end()) {
+        auto irPortInfo = *irPortInfoIter;
+
+        registerComponent(
+            OB_DEV_COMPONENT_IR_SENSOR,
+            [this, irPortInfo]() {
+                auto platform = Platform::getInstance();
+                auto port     = platform->getSourcePort(irPortInfo);
+
+                auto sensor = std::make_shared<VideoSensor>(this, OB_SENSOR_IR, port);
+
+                auto videoFrameTimestampCalculator_ = std::make_shared<FrameTimestampCalculatorDirectly>(this, depthFrameTimeFreq_);
+                sensor->setFrameTimestampCalculator(videoFrameTimestampCalculator_);
+
+                auto globalFrameTimestampCalculator = std::make_shared<GlobalTimestampCalculator>(this, deviceTimeFreq_, depthFrameTimeFreq_);
+                sensor->setGlobalTimestampCalculator(globalFrameTimestampCalculator);
+
+                initSensorStreamProfile(sensor);
+                return sensor;
+            },
+            true);
+        registerSensorPortInfo(OB_SENSOR_IR, irPortInfo);
+        registerComponent(OB_DEV_COMPONENT_IR_FRAME_PROCESSOR, [this]() {
+            auto factory = getComponentT<FrameProcessorFactory>(OB_DEV_COMPONENT_FRAME_PROCESSOR_FACTORY);
+
+            auto frameProcessor = factory->createFrameProcessor(OB_SENSOR_IR);
+            return frameProcessor;
+        });
+    }
+
+    auto colorPortInfoIter = std::find_if(sourcePortInfoList.begin(), sourcePortInfoList.end(), [](const std::shared_ptr<const SourcePortInfo> &portInfo) {
+        return portInfo->portType == SOURCE_PORT_NET_RTSP && std::dynamic_pointer_cast<const RTSPStreamPortInfo>(portInfo)->streamType == OB_STREAM_COLOR;
+    });
+
+    if(colorPortInfoIter != sourcePortInfoList.end()) {
+        auto colorPortInfo = *colorPortInfoIter;
+        registerComponent(
+            OB_DEV_COMPONENT_COLOR_SENSOR,
+            [this, colorPortInfo]() {
+                auto platform = Platform::getInstance();
+                auto port     = platform->getSourcePort(colorPortInfo);
+                auto sensor   = std::make_shared<VideoSensor>(this, OB_SENSOR_COLOR, port);
+
+                std::vector<FormatFilterConfig> formatFilterConfigs = {
+                    { FormatFilterPolicy::REMOVE, OB_FORMAT_NV12, OB_FORMAT_ANY, nullptr },
+                };
+                auto formatConverter = getSensorFrameFilter("FormatConverter", OB_SENSOR_COLOR, false);
+                if(formatConverter) {
+                    formatFilterConfigs.push_back({ FormatFilterPolicy::ADD, OB_FORMAT_MJPG, OB_FORMAT_RGB, formatConverter });
+                    formatFilterConfigs.push_back({ FormatFilterPolicy::ADD, OB_FORMAT_MJPG, OB_FORMAT_BGR, formatConverter });
+                    formatFilterConfigs.push_back({ FormatFilterPolicy::ADD, OB_FORMAT_MJPG, OB_FORMAT_BGRA, formatConverter });
+                }
+                sensor->updateFormatFilterConfig(formatFilterConfigs);
+
+                if(getFirmwareVersionInt() >= 10300) {
+                    auto videoFrameTimestampCalculator_ =
+                        std::make_shared<FemtoMegaColorFrameTimestampCalculatorV10300>(this, deviceTimeFreq_, colorFrameTimeFreq_);
+                    sensor->setFrameTimestampCalculator(videoFrameTimestampCalculator_);
+                }
+                else {
+                    auto videoFrameTimestampCalculator_ = std::make_shared<FrameTimestampCalculatorBaseDeviceTime>(this, deviceTimeFreq_, colorFrameTimeFreq_);
+                    sensor->setFrameTimestampCalculator(videoFrameTimestampCalculator_);
+                }
+
+                auto globalFrameTimestampCalculator = std::make_shared<GlobalTimestampCalculator>(this, deviceTimeFreq_, colorFrameTimeFreq_);
+                sensor->setGlobalTimestampCalculator(globalFrameTimestampCalculator);
+
+                auto frameProcessor = getComponentT<FrameProcessor>(OB_DEV_COMPONENT_COLOR_FRAME_PROCESSOR, false);
+                if(frameProcessor) {
+                    sensor->setFrameProcessor(frameProcessor.get());
+                }
+
+                initSensorStreamProfile(sensor);
+
+                return sensor;
+            },
+            true);
+        registerSensorPortInfo(OB_SENSOR_COLOR, colorPortInfo);
+        registerComponent(OB_DEV_COMPONENT_COLOR_FRAME_PROCESSOR, [this]() {
+            auto factory        = getComponentT<FrameProcessorFactory>(OB_DEV_COMPONENT_FRAME_PROCESSOR_FACTORY);
+            auto frameProcessor = factory->createFrameProcessor(OB_SENSOR_COLOR);
+            return frameProcessor;
+        });
+    }
+
+    auto imuPortInfoIter = std::find_if(sourcePortInfoList.begin(), sourcePortInfoList.end(), [](const std::shared_ptr<const SourcePortInfo> &portInfo) {
+        return portInfo->portType == SOURCE_PORT_NET_VENDOR_STREAM;
+    });
+
+    if(imuPortInfoIter != sourcePortInfoList.end()) {
+        auto imuPortInfo = *imuPortInfoIter;
+        registerComponent(OB_DEV_COMPONENT_IMU_STREAMER, [this, imuPortInfo]() {
+            // the gyro and accel are both on the same port and share the same filter
+            auto                                  platform           = Platform::getInstance();
+            auto                                  port               = platform->getSourcePort(imuPortInfo);
+            auto                                  imuReversionFilter = getSensorFrameFilter("IMUFrameReversion", OB_SENSOR_ACCEL, true);
+            auto                                  imuCorrectorFilter = getSensorFrameFilter("IMUCorrector", OB_SENSOR_ACCEL, true);
+            std::vector<std::shared_ptr<IFilter>> imuFilters         = { imuReversionFilter, imuCorrectorFilter };
+            auto                                  dataStreamPort     = std::dynamic_pointer_cast<IDataStreamPort>(port);
+            auto                                  imuStreamer        = std::make_shared<ImuStreamer>(this, dataStreamPort, imuFilters);
+            return imuStreamer;
+        });
+
+        registerComponent(
+            OB_DEV_COMPONENT_ACCEL_SENSOR,
+            [this, imuPortInfo]() {
+                auto platform             = Platform::getInstance();
+                auto port                 = platform->getSourcePort(imuPortInfo);
+                auto imuStreamer          = getComponentT<ImuStreamer>(OB_DEV_COMPONENT_IMU_STREAMER);
+                auto imuStreamerSharedPtr = imuStreamer.get();
+                auto sensor               = std::make_shared<AccelSensor>(this, port, imuStreamerSharedPtr);
+
+                auto globalFrameTimestampCalculator = std::make_shared<GlobalTimestampCalculator>(this, deviceTimeFreq_, depthFrameTimeFreq_);
+                sensor->setGlobalTimestampCalculator(globalFrameTimestampCalculator);
+
+                initSensorStreamProfile(sensor);
+                return sensor;
+            },
+            true);
+        registerSensorPortInfo(OB_SENSOR_ACCEL, imuPortInfo);
+
+        registerComponent(
+            OB_DEV_COMPONENT_GYRO_SENSOR,
+            [this, imuPortInfo]() {
+                auto platform             = Platform::getInstance();
+                auto port                 = platform->getSourcePort(imuPortInfo);
+                auto imuStreamer          = getComponentT<ImuStreamer>(OB_DEV_COMPONENT_IMU_STREAMER);
+                auto imuStreamerSharedPtr = imuStreamer.get();
+                auto sensor               = std::make_shared<GyroSensor>(this, port, imuStreamerSharedPtr);
+
+                auto globalFrameTimestampCalculator = std::make_shared<GlobalTimestampCalculator>(this, deviceTimeFreq_, depthFrameTimeFreq_);
+                sensor->setGlobalTimestampCalculator(globalFrameTimestampCalculator);
+
+                initSensorStreamProfile(sensor);
+
+                return sensor;
+            },
+            true);
+        registerSensorPortInfo(OB_SENSOR_GYRO, imuPortInfo);
+    }
+}
+
+void FemtoMegaNetDevice::initProperties() {
+    const auto &sourcePortInfoList = enumInfo_->getSourcePortInfoList();
+    auto        vendorPortInfoIter = std::find_if(sourcePortInfoList.begin(), sourcePortInfoList.end(),
+                                                  [](const std::shared_ptr<const SourcePortInfo> &portInfo) { return portInfo->portType == SOURCE_PORT_NET_VENDOR; });
+
+    if(vendorPortInfoIter == sourcePortInfoList.end()) {
+        return;
+    }
+
+    auto propertyServer = std::make_shared<PropertyServer>(this);
+
+    auto vendorPortInfo         = *vendorPortInfoIter;
+    auto vendorPropertyAccessor = std::make_shared<LazySuperPropertyAccessor>([this, vendorPortInfo]() {
+        auto platform = Platform::getInstance();
+        auto port     = platform->getSourcePort(vendorPortInfo);
+        auto accessor = std::make_shared<VendorPropertyAccessor>(this, port);
+        return accessor;
+    });
+
+    // the main property accessor
+    registerComponent(OB_DEV_COMPONENT_MAIN_PROPERTY_ACCESSOR, [this, vendorPortInfo]() {
+        auto platform = Platform::getInstance();
+        auto port     = platform->getSourcePort(vendorPortInfo);
+        auto accessor = std::make_shared<VendorPropertyAccessor>(this, port);
+        return accessor;
+    });
+
+    propertyServer->registerProperty(OB_PROP_COLOR_AUTO_EXPOSURE_BOOL, "rw", "rw", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_PROP_COLOR_EXPOSURE_INT, "rw", "rw", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_PROP_COLOR_GAIN_INT, "rw", "rw", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_PROP_COLOR_SATURATION_INT, "rw", "rw", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_PROP_COLOR_AUTO_WHITE_BALANCE_BOOL, "rw", "rw", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_PROP_COLOR_WHITE_BALANCE_INT, "rw", "rw", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_PROP_COLOR_BRIGHTNESS_INT, "rw", "rw", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_PROP_COLOR_SHARPNESS_INT, "rw", "rw", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_PROP_COLOR_CONTRAST_INT, "rw", "rw", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_PROP_COLOR_POWER_LINE_FREQUENCY_INT, "rw", "rw", vendorPropertyAccessor);
+
+    propertyServer->registerProperty(OB_PROP_DEPTH_ALIGN_HARDWARE_BOOL, "rw", "rw", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_PROP_DEPTH_ALIGN_HARDWARE_MODE_INT, "rw", "rw", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_PROP_TIMESTAMP_OFFSET_INT, "rw", "rw", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_PROP_FAN_WORK_MODE_INT, "rw", "rw", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_PROP_EXTERNAL_SIGNAL_RESET_BOOL, "", "rw", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_PROP_HEARTBEAT_BOOL, "rw", "rw", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_PROP_DEVICE_COMMUNICATION_TYPE_INT, "", "w", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_PROP_SWITCH_IR_MODE_INT, "rw", "rw", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_PROP_FAN_WORK_LEVEL_INT, "rw", "rw", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_PROP_FAN_WORK_SPEED_INT, "rw", "rw", vendorPropertyAccessor);
+    // propertyServer->registerProperty(OB_PROP_USB_POWER_STATE_INT, "r", "r", vendorPropertyAccessor);
+    // propertyServer->registerProperty(OB_PROP_DC_POWER_STATE_INT, "r", "r", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_STRUCT_VERSION, "", "r", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_STRUCT_DEVICE_SERIAL_NUMBER, "r", "rw", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_STRUCT_MULTI_DEVICE_SYNC_CONFIG, "rw", "rw", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_STRUCT_DEVICE_IP_ADDR_CONFIG, "rw", "rw", vendorPropertyAccessor);
+    //  propertyServer->registerProperty(OB_STRUCT_LED_CONTROL, "", "w", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_RAW_DATA_CAMERA_CALIB_JSON_FILE, "r", "r", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_STRUCT_DEVICE_TIME, "rw", "rw", vendorPropertyAccessor);
+    // propertyServer->registerProperty(OB_RAW_DATA_MCU_UPGRADE_FILE, "rw", "rw", vendorPropertyPort);
+    // propertyServer->registerProperty(OB_RAW_DATA_HARDWARE_ALIGN_PARAM, "rw", "rw", vendorPropertyPort);
+    propertyServer->registerProperty(OB_PROP_INDICATOR_LIGHT_BOOL, "rw", "rw", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_PROP_BOOT_INTO_RECOVERY_MODE_BOOL, "w", "w", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_PROP_TIMER_RESET_ENABLE_BOOL, "rw", "rw", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_PROP_TIMER_RESET_SIGNAL_BOOL, "w", "w", vendorPropertyAccessor);
+
+    propertyServer->registerProperty(OB_RAW_DATA_IMU_CALIB_PARAM, "", "rw", vendorPropertyAccessor);
+    // propertyServer->registerProperty(OB_STRUCT_LED_CONTROL, "", "w", vendorPropertyPort);
+
+    propertyServer->registerProperty(OB_PROP_GYRO_ODR_INT, "rw", "rw", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_PROP_ACCEL_ODR_INT, "rw", "rw", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_PROP_GYRO_FULL_SCALE_INT, "rw", "rw", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_PROP_ACCEL_FULL_SCALE_INT, "rw", "rw", vendorPropertyAccessor);
+
+    propertyServer->registerProperty(OB_STRUCT_GET_ACCEL_PRESETS_ODR_LIST, "", "rw", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_STRUCT_GET_ACCEL_PRESETS_FULL_SCALE_LIST, "", "rw", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_STRUCT_GET_GYRO_PRESETS_ODR_LIST, "", "rw", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_STRUCT_GET_GYRO_PRESETS_FULL_SCALE_LIST, "", "rw", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_PROP_ACCEL_SWITCH_BOOL, "", "rw", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_PROP_GYRO_SWITCH_BOOL, "", "rw", vendorPropertyAccessor);
+
+    propertyServer->registerProperty(OB_RAW_DATA_STREAM_PROFILE_LIST, "r", "r", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_RAW_DATA_ALIGN_CALIB_PARAM, "", "r", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_RAW_DATA_D2C_ALIGN_SUPPORT_PROFILE_LIST, "", "r", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_PROP_TOF_EXPOSURE_TIME_INT, "r", "r", vendorPropertyAccessor);
+
+    propertyServer->registerProperty(OB_PROP_STOP_IR_STREAM_BOOL, "rw", "rw", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_PROP_STOP_COLOR_STREAM_BOOL, "rw", "rw", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_PROP_STOP_DEPTH_STREAM_BOOL, "rw", "rw", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_PROP_REBOOT_DEVICE_BOOL, "w", "w", vendorPropertyAccessor);
+
+    propertyServer->registerProperty(OB_RAW_DATA_DEVICE_UPGRADE, "", "rw", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_STRUCT_DEVICE_UPGRADE_STATUS, "", "rw", vendorPropertyAccessor);
+
+    propertyServer->registerProperty(OB_PROP_DEVICE_IN_RECOVERY_MODE_BOOL, "rw", "rw", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_PROP_DEVICE_DEVELOPMENT_MODE_INT, "rw", "rw", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_STRUCT_DEVICE_STATIC_IP_CONFIG_RECORD, "rw", "rw", vendorPropertyAccessor);
+
+    propertyServer->aliasProperty(OB_PROP_IR_EXPOSURE_INT, OB_PROP_TOF_EXPOSURE_TIME_INT);
+    propertyServer->aliasProperty(OB_PROP_DEPTH_EXPOSURE_INT, OB_PROP_TOF_EXPOSURE_TIME_INT);
+
+    BEGIN_TRY_EXECUTE({
+        auto inRecoveryMode = propertyServer->getPropertyValueT<bool>(OB_PROP_DEVICE_IN_RECOVERY_MODE_BOOL);
+        if(!inRecoveryMode) {
+            propertyServer->registerProperty(OB_PROP_RESTORE_FACTORY_SETTINGS_BOOL, "w", "w", vendorPropertyAccessor);
+        }
+    })
+    CATCH_EXCEPTION_AND_EXECUTE({ LOG_ERROR("Get device in recovery mode failed!"); })
+
+    auto imuCorrectorFilter = getSensorFrameFilter("IMUCorrector", OB_SENSOR_ACCEL);
+    if(imuCorrectorFilter) {
+        auto filterStateProperty = std::make_shared<FilterStatePropertyAccessor>(imuCorrectorFilter);
+        propertyServer->registerProperty(OB_PROP_SDK_ACCEL_FRAME_TRANSFORMED_BOOL, "rw", "rw", filterStateProperty);
+        propertyServer->registerProperty(OB_PROP_SDK_GYRO_FRAME_TRANSFORMED_BOOL, "rw", "rw", filterStateProperty);
+    }
+
+    auto femtoMegaTempPropertyAccessor = std::make_shared<FemtoMegaTempPropertyAccessor>(this);
+    propertyServer->registerProperty(OB_STRUCT_DEVICE_TEMPERATURE, "r", "r", femtoMegaTempPropertyAccessor);
+    registerComponent(OB_DEV_COMPONENT_PROPERTY_SERVER, propertyServer, true);
+
+    BEGIN_TRY_EXECUTE({ propertyServer->setPropertyValueT(OB_PROP_DEVICE_COMMUNICATION_TYPE_INT, OB_COMM_NET); })
+    CATCH_EXCEPTION_AND_EXECUTE({ LOG_ERROR("Set device communication type to ethernet mode failed!"); })
+}
+
+void FemtoMegaNetDevice::initSensorStreamProfile(std::shared_ptr<ISensor> sensor) {
+    auto              sensorType = sensor->getSensorType();
+    OBStreamType      streamType = utils::mapSensorTypeToStreamType(sensorType);
+    StreamProfileList ProfileList;
+    for(const auto &profile: allVideoStreamProfileList_) {
+        if(streamType == profile->getType()) {
+            ProfileList.push_back(profile);
+        }
+    }
+
+    if(ProfileList.size() != 0) {
+        sensor->setStreamProfileList(ProfileList);
+    }
+
+    auto streamProfile = StreamProfileFactory::getDefaultStreamProfileFromEnvConfig(deviceInfo_->name_, sensorType);
+    if(streamProfile) {
+        sensor->updateDefaultStreamProfile(streamProfile);
+    }
+
+    // bind params: extrinsics, intrinsics, etc.
+    auto profiles = sensor->getStreamProfileList();
+    {
+        auto algParamManager = getComponentT<TOFDeviceCommonAlgParamManager>(OB_DEV_COMPONENT_ALG_PARAM_MANAGER);
+        algParamManager->bindStreamProfileParams(profiles);
+    }
+
+    LOG_INFO("Sensor {} created! Found {} stream profiles.", sensorType, profiles.size());
+    for(auto &profile: profiles) {
+        LOG_INFO(" - {}", profile);
+    }
+}
+
+void FemtoMegaNetDevice::fetchAllVideoStreamProfileList() {
+    auto propServer = getPropertyServer();
+
+    std::vector<uint8_t> data;
+    BEGIN_TRY_EXECUTE({
+        propServer->getRawData(
+            OB_RAW_DATA_STREAM_PROFILE_LIST,
+            [&](OBDataTranState state, OBDataChunk *dataChunk) {
+                if(state == DATA_TRAN_STAT_TRANSFERRING) {
+                    data.insert(data.end(), dataChunk->data, dataChunk->data + dataChunk->size);
+                }
+            },
+            PROP_ACCESS_INTERNAL);
+    })
+    CATCH_EXCEPTION_AND_EXECUTE({
+        LOG_ERROR("Get profile list params failed!");
+        data.clear();
+    })
+
+    if(!data.empty()) {
+        std::vector<OBInternalStreamProfile> outputProfiles;
+        uint16_t                             dataSize = static_cast<uint16_t>(data.size());
+        outputProfiles                                = parseBuffer<OBInternalStreamProfile>(data.data(), dataSize);
+        allVideoStreamProfileList_.clear();
+        for(auto item: outputProfiles) {
+            OBStreamType streamType = utils::mapSensorTypeToStreamType((OBSensorType)item.sensorType);
+            OBFormat     format     = utils::uvcFourccToOBFormat(item.profile.video.formatFourcc);
+            allVideoStreamProfileList_.push_back(StreamProfileFactory::createVideoStreamProfile(streamType, format, item.profile.video.width,
+                                                                                                item.profile.video.height, item.profile.video.fps));
+        }
+    }
+    else {
+        LOG_WARN("Get stream profile list failed!");
+    }
+}
+}  // namespace libobsensor
diff --git a/src/device/femtomega/FemtoMegaDevice.hpp b/src/device/femtomega/FemtoMegaDevice.hpp
new file mode 100644
index 00000000..e45ead5e
--- /dev/null
+++ b/src/device/femtomega/FemtoMegaDevice.hpp
@@ -0,0 +1,51 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include "DeviceBase.hpp"
+#include "IDeviceManager.hpp"
+#include "frameprocessor/FrameProcessor.hpp"
+
+#include <map>
+#include <memory>
+
+namespace libobsensor {
+class FemtoMegaUsbDevice : public DeviceBase {
+public:
+    FemtoMegaUsbDevice(const std::shared_ptr<const IDeviceEnumInfo> &info);
+    virtual ~FemtoMegaUsbDevice() noexcept;
+
+private:
+    void init() override;
+    void initSensorList();
+    void initProperties();
+    void initSensorStreamProfile(std::shared_ptr<ISensor> sensor);
+
+private:
+    uint64_t deviceTimeFreq_ = 1000;
+    uint64_t frameTimeFreq_  = 1000;
+};
+
+class FemtoMegaNetDevice : public DeviceBase {
+public:
+    FemtoMegaNetDevice(const std::shared_ptr<const IDeviceEnumInfo> &info);
+    virtual ~FemtoMegaNetDevice() noexcept;
+
+private:
+    void init() override;
+    void initSensorList();
+    void initProperties();
+    void initSensorStreamProfile(std::shared_ptr<ISensor> sensor);
+    void fetchAllVideoStreamProfileList();
+
+    void fetchDeviceInfo() override;
+
+private:
+    uint64_t deviceTimeFreq_     = 1000;
+    uint64_t depthFrameTimeFreq_ = 1000;
+    uint64_t colorFrameTimeFreq_ = 90000;
+
+    StreamProfileList allVideoStreamProfileList_;  // fetch from device via vendor-specific protocol for all types of video stream
+};
+
+}  // namespace libobsensor
diff --git a/src/device/femtomega/FemtoMegaDeviceInfo.cpp b/src/device/femtomega/FemtoMegaDeviceInfo.cpp
new file mode 100644
index 00000000..3d922e51
--- /dev/null
+++ b/src/device/femtomega/FemtoMegaDeviceInfo.cpp
@@ -0,0 +1,118 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "FemtoMegaDeviceInfo.hpp"
+#include "FemtoMegaDevice.hpp"
+#include "DevicePids.hpp"
+#include "usb/UsbPortGroup.hpp"
+#include "ethernet/NetPortGroup.hpp"
+#include "utils/Utils.hpp"
+#include "exception/ObException.hpp"
+#include "ethernet/RTSPStreamPort.hpp"
+#include "ethernet/NetDataStreamPort.hpp"
+namespace libobsensor {
+const std::map<int, std::string> FemtoMegaDeviceNameMap = {
+    { 0x06c0, "Femto Mega i" },
+    { 0x0669, "Femto Mega" },
+};
+
+FemtoMegaDeviceInfo::FemtoMegaDeviceInfo(const SourcePortInfoList groupedInfoList) {
+    auto firstPortInfo = groupedInfoList.front();
+    if(IS_USB_PORT(firstPortInfo->portType)) {
+        auto portInfo = std::dynamic_pointer_cast<const USBSourcePortInfo>(groupedInfoList.front());
+
+        auto iter = FemtoMegaDeviceNameMap.find(portInfo->pid);
+        if(iter != FemtoMegaDeviceNameMap.end()) {
+            name_ = iter->second;
+        }
+        else {
+            name_ = "Femto Mega series device";
+        }
+        fullName_           = "Orbbec " + name_;
+        pid_                = portInfo->pid;
+        vid_                = portInfo->vid;
+        uid_                = portInfo->uid;
+        deviceSn_           = portInfo->serial;
+        connectionType_     = portInfo->connSpec;
+        sourcePortInfoList_ = groupedInfoList;
+    }
+    else if(IS_NET_PORT(firstPortInfo->portType)) {
+        auto portInfo = std::dynamic_pointer_cast<const NetSourcePortInfo>(groupedInfoList.front());
+
+        auto iter = FemtoMegaDeviceNameMap.find(portInfo->pid);
+        if(iter != FemtoMegaDeviceNameMap.end()) {
+            name_ = iter->second;
+        }
+        else {
+            name_ = "Femto Mega series device";
+        }
+        fullName_           = "Orbbec " + name_;
+        pid_                = portInfo->pid;
+        vid_                = 0x2BC5;
+        uid_                = portInfo->mac;
+        deviceSn_           = portInfo->serialNumber;
+        connectionType_     = "Ethernet";
+        sourcePortInfoList_ = groupedInfoList;
+    }
+    else {
+        throw invalid_value_exception("Invalid port type");
+    }
+}
+
+FemtoMegaDeviceInfo::~FemtoMegaDeviceInfo() noexcept {}
+
+std::shared_ptr<IDevice> FemtoMegaDeviceInfo::createDevice() const {
+    std::shared_ptr<IDevice> device;
+    if(connectionType_ == "Ethernet") {
+        device = std::make_shared<FemtoMegaNetDevice>(shared_from_this());
+    }
+    else {
+        device = std::make_shared<FemtoMegaUsbDevice>(shared_from_this());
+    }
+    return device;
+}
+
+std::vector<std::shared_ptr<IDeviceEnumInfo>> FemtoMegaDeviceInfo::pickDevices(const SourcePortInfoList infoList) {
+    std::vector<std::shared_ptr<IDeviceEnumInfo>> femtoMegaDeviceInfos;
+    auto                                          remainder = FilterUSBPortInfoByPid(infoList, FemtoMegaDevPids);
+    auto                                          groups    = utils::groupVector<std::shared_ptr<const SourcePortInfo>>(remainder, GroupUSBSourcePortByUrl);
+    auto                                          iter      = groups.begin();
+    while(iter != groups.end()) {
+        if(iter->size() >= 2) {
+            auto info = std::make_shared<FemtoMegaDeviceInfo>(*iter);
+            femtoMegaDeviceInfos.push_back(info);
+        }
+        iter++;
+    }
+
+    return femtoMegaDeviceInfos;
+}
+
+std::vector<std::shared_ptr<IDeviceEnumInfo>> FemtoMegaDeviceInfo::pickNetDevices(const SourcePortInfoList infoList) {
+    std::vector<std::shared_ptr<IDeviceEnumInfo>> femtoMegaDeviceInfos;
+    auto                                          remainder = FilterNetPortInfoByPid(infoList, FemtoMegaDevPids);
+    auto                                          groups    = utils::groupVector<std::shared_ptr<const SourcePortInfo>>(remainder, GroupNetSourcePortByMac);
+    auto                                          iter      = groups.begin();
+    while(iter != groups.end()) {
+        if(iter->size() >= 1) {
+
+            auto portInfo = std::dynamic_pointer_cast<const NetSourcePortInfo>(iter->front());
+            iter->emplace_back(std::make_shared<RTSPStreamPortInfo>(portInfo->address, static_cast<uint16_t>(8888), portInfo->port, OB_STREAM_COLOR,
+                                                                    portInfo->mac, portInfo->serialNumber, portInfo->pid));
+            iter->emplace_back(std::make_shared<RTSPStreamPortInfo>(portInfo->address, static_cast<uint16_t>(8554), portInfo->port, OB_STREAM_DEPTH,
+                                                                    portInfo->mac, portInfo->serialNumber, portInfo->pid));
+            iter->emplace_back(std::make_shared<RTSPStreamPortInfo>(portInfo->address, static_cast<uint16_t>(8554), portInfo->port, OB_STREAM_IR, portInfo->mac,
+                                                                    portInfo->serialNumber, portInfo->pid));
+            iter->emplace_back(std::make_shared<NetDataStreamPortInfo>(portInfo->address, static_cast<uint16_t>(8900), portInfo->port, portInfo->mac,
+                                                                       portInfo->serialNumber, portInfo->pid));  // imu data stream
+
+            auto deviceEnumInfo = std::make_shared<FemtoMegaDeviceInfo>(*iter);
+            femtoMegaDeviceInfos.push_back(deviceEnumInfo);
+        }
+        iter++;
+    }
+
+    return femtoMegaDeviceInfos;
+}
+
+}  // namespace libobsensor
diff --git a/src/device/femtomega/FemtoMegaDeviceInfo.hpp b/src/device/femtomega/FemtoMegaDeviceInfo.hpp
new file mode 100644
index 00000000..7832f775
--- /dev/null
+++ b/src/device/femtomega/FemtoMegaDeviceInfo.hpp
@@ -0,0 +1,23 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include "devicemanager/DeviceEnumInfoBase.hpp"
+
+#include <iostream>
+#include <string>
+#include <vector>
+#include <memory>
+
+namespace libobsensor {
+class FemtoMegaDeviceInfo : public DeviceEnumInfoBase, public std::enable_shared_from_this<FemtoMegaDeviceInfo> {
+public:
+    FemtoMegaDeviceInfo(const SourcePortInfoList groupedInfoList);
+    ~FemtoMegaDeviceInfo() noexcept;
+
+    std::shared_ptr<IDevice>                             createDevice() const override;
+    static std::vector<std::shared_ptr<IDeviceEnumInfo>> pickDevices(const SourcePortInfoList infoList);
+    static std::vector<std::shared_ptr<IDeviceEnumInfo>> pickNetDevices(const SourcePortInfoList infoList);
+};
+
+}  // namespace libobsensor
diff --git a/src/device/femtomega/FemtoMegaFrameTimestampCalculator.cpp b/src/device/femtomega/FemtoMegaFrameTimestampCalculator.cpp
new file mode 100644
index 00000000..1d6f2674
--- /dev/null
+++ b/src/device/femtomega/FemtoMegaFrameTimestampCalculator.cpp
@@ -0,0 +1,16 @@
+#include "FemtoMegaFrameTimestampCalculator.hpp"
+#include "frame/Frame.hpp"
+
+namespace libobsensor {
+FemtoMegaColorFrameTimestampCalculatorV10300::FemtoMegaColorFrameTimestampCalculatorV10300(IDevice *device, uint64_t deviceTimeFreq, uint64_t frameTimeFreq)
+    : FrameTimestampCalculatorBaseDeviceTime(device, deviceTimeFreq, frameTimeFreq) {}
+
+void FemtoMegaColorFrameTimestampCalculatorV10300::calculate(std::shared_ptr<Frame> frame) {
+    auto format = frame->getFormat();
+    if(format == OB_FORMAT_MJPEG) {
+        return;
+    }
+    FrameTimestampCalculatorBaseDeviceTime::calculate(frame);
+}
+
+}  // namespace libobsensor
\ No newline at end of file
diff --git a/src/device/femtomega/FemtoMegaFrameTimestampCalculator.hpp b/src/device/femtomega/FemtoMegaFrameTimestampCalculator.hpp
new file mode 100644
index 00000000..9522b2ef
--- /dev/null
+++ b/src/device/femtomega/FemtoMegaFrameTimestampCalculator.hpp
@@ -0,0 +1,14 @@
+#pragma once
+
+#include "timestamp/FrameTimestampCalculator.hpp"
+
+namespace libobsensor {
+class FemtoMegaColorFrameTimestampCalculatorV10300 : public FrameTimestampCalculatorBaseDeviceTime {
+public:
+    FemtoMegaColorFrameTimestampCalculatorV10300(IDevice *device, uint64_t deviceTimeFreq, uint64_t frameTimeFreq);
+
+    virtual ~FemtoMegaColorFrameTimestampCalculatorV10300() = default;
+
+    void calculate(std::shared_ptr<Frame> frame) override;
+};
+}  // namespace libobsensor
\ No newline at end of file
diff --git a/src/device/femtomega/FemtoMegaPropertyAccessor.cpp b/src/device/femtomega/FemtoMegaPropertyAccessor.cpp
new file mode 100644
index 00000000..f4df07e9
--- /dev/null
+++ b/src/device/femtomega/FemtoMegaPropertyAccessor.cpp
@@ -0,0 +1,42 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "FemtoMegaPropertyAccessor.hpp"
+#include "frameprocessor/FrameProcessor.hpp"
+#include "sensor/video/DisparityBasedSensor.hpp"
+#include "IDeviceComponent.hpp"
+#include "property/InternalProperty.hpp"
+
+namespace libobsensor {
+FemtoMegaTempPropertyAccessor::FemtoMegaTempPropertyAccessor(IDevice *owner) : owner_(owner) {}
+
+void FemtoMegaTempPropertyAccessor::setStructureData(uint32_t propertyId, const std::vector<uint8_t> &data) {
+    utils::unusedVar(propertyId);
+    utils::unusedVar(data);
+    throw unsupported_operation_exception("Temperature params readonly!");
+}
+
+const std::vector<uint8_t> &FemtoMegaTempPropertyAccessor::getStructureData(uint32_t propertyId) {
+    utils::unusedVar(propertyId);
+    tempData_.resize(sizeof(OBDeviceTemperature));
+
+    auto                       commandPort = owner_->getComponentT<IStructureDataAccessor>(OB_DEV_COMPONENT_MAIN_PROPERTY_ACCESSOR);
+    const std::vector<uint8_t> tempData    = commandPort->getStructureData(OB_STRUCT_DEVICE_TEMPERATURE);
+    OBDeviceTemperature        tempParam;
+    memset(&tempParam, 0, sizeof(OBDeviceTemperature));
+    memcpy(&tempParam, tempData.data(), sizeof(OBDeviceTemperature));
+
+    tempParam.irLeftTemp     = 0;
+    tempParam.irRightTemp    = 0;
+    tempParam.chipBottomTemp = 0;
+    tempParam.chipTopTemp    = 0;
+    tempParam.mainBoardTemp  = 0;
+    tempParam.rgbTemp        = 0;
+    tempParam.tecTemp        = 0;
+
+    memcpy(tempData_.data(), &tempParam, sizeof(OBDeviceTemperature));
+
+    return tempData_;
+}
+
+}  // namespace libobsensor
diff --git a/src/device/femtomega/FemtoMegaPropertyAccessor.hpp b/src/device/femtomega/FemtoMegaPropertyAccessor.hpp
new file mode 100644
index 00000000..02c01f1b
--- /dev/null
+++ b/src/device/femtomega/FemtoMegaPropertyAccessor.hpp
@@ -0,0 +1,21 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include "IProperty.hpp"
+#include "IDevice.hpp"
+
+namespace libobsensor {
+class FemtoMegaTempPropertyAccessor : public IStructureDataAccessor {
+public:
+    explicit FemtoMegaTempPropertyAccessor(IDevice *owner);
+    virtual ~FemtoMegaTempPropertyAccessor() noexcept = default;
+
+    virtual void                        setStructureData(uint32_t propertyId, const std::vector<uint8_t> &data) override;
+    virtual const std::vector<uint8_t> &getStructureData(uint32_t propertyId) override;
+
+private:
+    IDevice             *owner_;
+    std::vector<uint8_t> tempData_;
+};
+}  // namespace libobsensor
diff --git a/src/device/gemini2/CMakeLists.txt b/src/device/gemini2/CMakeLists.txt
new file mode 100644
index 00000000..3d221cce
--- /dev/null
+++ b/src/device/gemini2/CMakeLists.txt
@@ -0,0 +1,26 @@
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+cmake_minimum_required(VERSION 3.5)
+
+
+target_sources(
+    ${OB_TARGET_DEVICE}
+    PRIVATE
+        ${CMAKE_CURRENT_LIST_DIR}/G2DeviceInfo.hpp
+        ${CMAKE_CURRENT_LIST_DIR}/G2DeviceInfo.cpp
+        ${CMAKE_CURRENT_LIST_DIR}/G2Device.hpp
+        ${CMAKE_CURRENT_LIST_DIR}/G2Device.cpp
+        ${CMAKE_CURRENT_LIST_DIR}/G2XLDevice.cpp
+        ${CMAKE_CURRENT_LIST_DIR}/G2XLDevice.cpp
+        ${CMAKE_CURRENT_LIST_DIR}/G2StreamProfileFilter.hpp
+        ${CMAKE_CURRENT_LIST_DIR}/G2StreamProfileFilter.cpp
+        ${CMAKE_CURRENT_LIST_DIR}/G2PropertyAccessors.hpp
+        ${CMAKE_CURRENT_LIST_DIR}/G2PropertyAccessors.cpp
+        ${CMAKE_CURRENT_LIST_DIR}/G2DepthWorkModeManager.hpp
+        ${CMAKE_CURRENT_LIST_DIR}/G2DepthWorkModeManager.cpp
+        ${CMAKE_CURRENT_LIST_DIR}/G2FrameTimestampCalculator.hpp
+        ${CMAKE_CURRENT_LIST_DIR}/G2FrameTimestampCalculator.cpp
+        ${CMAKE_CURRENT_LIST_DIR}/G2AlgParamManager.hpp
+        ${CMAKE_CURRENT_LIST_DIR}/G2AlgParamManager.cpp
+)
diff --git a/src/device/gemini2/G2AlgParamManager.cpp b/src/device/gemini2/G2AlgParamManager.cpp
new file mode 100644
index 00000000..006e31f9
--- /dev/null
+++ b/src/device/gemini2/G2AlgParamManager.cpp
@@ -0,0 +1,172 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "G2AlgParamManager.hpp"
+
+#include "InternalTypes.hpp"
+#include "property/InternalProperty.hpp"
+#include "publicfilters/IMUCorrector.hpp"
+#include "stream/StreamIntrinsicsManager.hpp"
+#include "stream/StreamExtrinsicsManager.hpp"
+#include "stream/StreamProfileFactory.hpp"
+#include "exception/ObException.hpp"
+
+namespace libobsensor {
+G2AlgParamManager::G2AlgParamManager(IDevice *owner) : DisparityAlgParamManagerBase(owner) {
+    fetchParamFromDevice();
+    registerBasicExtrinsics();
+}
+
+void G2AlgParamManager::fetchParamFromDevice() {
+    try {
+        auto owner                   = getOwner();
+        auto propServer              = owner->getPropertyServer();
+        depthCalibParamList_         = propServer->getStructureDataListProtoV1_1_T<OBDepthCalibrationParam, 1>(OB_RAW_DATA_DEPTH_CALIB_PARAM);
+        const auto &depthCalib       = depthCalibParamList_.front();
+        disparityParam_.baseline     = depthCalib.baseline;
+        disparityParam_.zpd          = depthCalib.z0;
+        disparityParam_.fx           = depthCalib.focalPix;
+        disparityParam_.zpps         = depthCalib.z0 / depthCalib.focalPix;
+        disparityParam_.bitSize      = 14;  // low 14 bit
+        disparityParam_.dispIntPlace = 8;
+        disparityParam_.unit         = depthCalib.unit;
+        disparityParam_.dispOffset   = depthCalib.dispOffset;
+        disparityParam_.invalidDisp  = depthCalib.invalidDisp;
+        disparityParam_.packMode     = OB_DISP_PACK_ORIGINAL_NEW;
+        disparityParam_.isDualCamera = true;
+    }
+    catch(const std::exception &e) {
+        LOG_ERROR("Get depth calibration params failed! {}", e.what());
+    }
+
+    try {
+        auto owner           = getOwner();
+        auto propServer      = owner->getPropertyServer();
+        auto cameraParamList = propServer->getStructureDataListProtoV1_1_T<OBCameraParam_Internal_V0, 0>(OB_RAW_DATA_ALIGN_CALIB_PARAM);
+        for(auto &cameraParam: cameraParamList) {
+            OBCameraParam param;
+            param.depthIntrinsic = cameraParam.depthIntrinsic;
+            param.rgbIntrinsic   = cameraParam.rgbIntrinsic;
+            memcpy(&param.depthDistortion, &cameraParam.depthDistortion, sizeof(param.depthDistortion));
+            param.depthDistortion.model = OB_DISTORTION_BROWN_CONRADY_K6;
+            memcpy(&param.rgbDistortion, &cameraParam.rgbDistortion, sizeof(param.rgbDistortion));
+            param.rgbDistortion.model = OB_DISTORTION_BROWN_CONRADY_K6;
+            param.transform           = cameraParam.transform;
+            param.isMirrored          = false;
+            calibrationCameraParamList_.emplace_back(param);
+
+            std::stringstream ss;
+            ss << param;
+            LOG_DEBUG("-{}", ss.str());
+        }
+    }
+    catch(const std::exception &e) {
+        LOG_ERROR("Get depth calibration params failed! {}", e.what());
+    }
+
+    try {
+        auto owner      = getOwner();
+        auto propServer = owner->getPropertyServer();
+        d2cProfileList_ = propServer->getStructureDataListProtoV1_1_T<OBD2CProfile, 0>(OB_RAW_DATA_D2C_ALIGN_SUPPORT_PROFILE_LIST);
+    }
+    catch(const std::exception &e) {
+        LOG_ERROR("Get depth to color profile list failed! {}", e.what());
+    }
+
+    // imu param
+    std::vector<uint8_t> data;
+    try {
+        auto owner      = getOwner();
+        auto propServer = owner->getPropertyServer();
+        propServer->getRawData(
+            OB_RAW_DATA_IMU_CALIB_PARAM,
+            [&](OBDataTranState state, OBDataChunk *dataChunk) {
+                if(state == DATA_TRAN_STAT_TRANSFERRING) {
+                    data.insert(data.end(), dataChunk->data, dataChunk->data + dataChunk->size);
+                }
+            },
+            PROP_ACCESS_INTERNAL);
+    }
+    catch(...) {
+        LOG_ERROR("Get imu calibration params failed!");
+        data.clear();
+    }
+
+    if(data.empty()) {
+        imuCalibParam_ = IMUCorrector::getDefaultImuCalibParam();
+    }
+    else {
+        imuCalibParam_ = IMUCorrector::parserIMUCalibParamRaw(data.data(), static_cast<uint32_t>(data.size()));
+        LOG_DEBUG("Get imu calibration params success!");
+    }
+}
+
+void G2AlgParamManager::registerBasicExtrinsics() {
+    auto extrinsicMgr              = StreamExtrinsicsManager::getInstance();
+    auto depthBasicStreamProfile   = StreamProfileFactory::createVideoStreamProfile(OB_STREAM_DEPTH, OB_FORMAT_ANY, OB_WIDTH_ANY, OB_HEIGHT_ANY, OB_FPS_ANY);
+    auto colorBasicStreamProfile   = StreamProfileFactory::createVideoStreamProfile(OB_STREAM_COLOR, OB_FORMAT_ANY, OB_WIDTH_ANY, OB_HEIGHT_ANY, OB_FPS_ANY);
+    auto irBasicStreamProfile      = StreamProfileFactory::createVideoStreamProfile(OB_STREAM_IR, OB_FORMAT_ANY, OB_WIDTH_ANY, OB_HEIGHT_ANY, OB_FPS_ANY);
+    auto leftIrBasicStreamProfile  = StreamProfileFactory::createVideoStreamProfile(OB_STREAM_IR_LEFT, OB_FORMAT_ANY, OB_WIDTH_ANY, OB_HEIGHT_ANY, OB_FPS_ANY);
+    auto rightIrBasicStreamProfile = StreamProfileFactory::createVideoStreamProfile(OB_STREAM_IR_RIGHT, OB_FORMAT_ANY, OB_WIDTH_ANY, OB_HEIGHT_ANY, OB_FPS_ANY);
+    auto accelBasicStreamProfile   = StreamProfileFactory::createAccelStreamProfile(OB_ACCEL_FS_2g, OB_SAMPLE_RATE_1_5625_HZ);
+    auto gyroBasicStreamProfile    = StreamProfileFactory::createGyroStreamProfile(OB_GYRO_FS_16dps, OB_SAMPLE_RATE_1_5625_HZ);
+
+    if(!calibrationCameraParamList_.empty()) {
+        auto d2cExtrinsic = calibrationCameraParamList_.front().transform;
+        bool mirrored     = false;
+        {
+            auto owner      = getOwner();
+            auto propServer = owner->getPropertyServer();
+            if(propServer->isPropertySupported(OB_PROP_DEPTH_MIRROR_MODULE_STATUS_BOOL, PROP_OP_READ, PROP_ACCESS_INTERNAL)) {
+                mirrored = propServer->getPropertyValueT<bool>(OB_PROP_DEPTH_MIRROR_MODULE_STATUS_BOOL);
+            }
+        }
+        if(mirrored) {
+            (d2cExtrinsic.rot)[1] *= -1.0;
+            (d2cExtrinsic.rot)[2] *= -1.0;
+            (d2cExtrinsic.rot)[3] *= -1.0;
+            (d2cExtrinsic.rot)[6] *= -1.0;
+            (d2cExtrinsic.trans)[0] *= -1.0;
+        }
+        extrinsicMgr->registerExtrinsics(depthBasicStreamProfile, colorBasicStreamProfile, d2cExtrinsic);
+    }
+
+    extrinsicMgr->registerSameExtrinsics(irBasicStreamProfile, depthBasicStreamProfile);
+    extrinsicMgr->registerSameExtrinsics(leftIrBasicStreamProfile, depthBasicStreamProfile);
+
+    if(!depthCalibParamList_.empty()) {
+        auto left_to_right     = IdentityExtrinsics;
+        left_to_right.trans[0] = -1.0f * depthCalibParamList_.front().baseline * depthCalibParamList_.front().unit;
+        extrinsicMgr->registerExtrinsics(leftIrBasicStreamProfile, rightIrBasicStreamProfile, left_to_right);
+    }
+
+    double imuExtr[16] = { 0 };
+    memcpy(imuExtr, imuCalibParam_.singleIMUParams[0].imu_to_cam_extrinsics, sizeof(imuExtr));
+
+    OBExtrinsic imu_to_depth;
+    imu_to_depth.rot[0] = (float)imuExtr[0];
+    imu_to_depth.rot[1] = (float)imuExtr[1];
+
+    imu_to_depth.rot[2]   = (float)imuExtr[2];
+    imu_to_depth.rot[3]   = (float)imuExtr[4];
+    imu_to_depth.rot[4]   = (float)imuExtr[5];
+    imu_to_depth.rot[5]   = (float)imuExtr[6];
+    imu_to_depth.rot[6]   = (float)imuExtr[8];
+    imu_to_depth.rot[7]   = (float)imuExtr[9];
+    imu_to_depth.rot[8]   = (float)imuExtr[10];
+    imu_to_depth.trans[0] = (float)imuExtr[3];
+    imu_to_depth.trans[1] = (float)imuExtr[7];
+    imu_to_depth.trans[2] = (float)imuExtr[11];
+    extrinsicMgr->registerExtrinsics(accelBasicStreamProfile, depthBasicStreamProfile, imu_to_depth);
+    extrinsicMgr->registerSameExtrinsics(gyroBasicStreamProfile, accelBasicStreamProfile);
+
+    basicStreamProfileList_.emplace_back(depthBasicStreamProfile);
+    basicStreamProfileList_.emplace_back(colorBasicStreamProfile);
+    basicStreamProfileList_.emplace_back(irBasicStreamProfile);
+    basicStreamProfileList_.emplace_back(leftIrBasicStreamProfile);
+    basicStreamProfileList_.emplace_back(rightIrBasicStreamProfile);
+    basicStreamProfileList_.emplace_back(accelBasicStreamProfile);
+    basicStreamProfileList_.emplace_back(gyroBasicStreamProfile);
+}
+
+}  // namespace libobsensor
diff --git a/src/device/gemini2/G2AlgParamManager.hpp b/src/device/gemini2/G2AlgParamManager.hpp
new file mode 100644
index 00000000..fbc4d49a
--- /dev/null
+++ b/src/device/gemini2/G2AlgParamManager.hpp
@@ -0,0 +1,20 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include "param/AlgParamManager.hpp"
+
+namespace libobsensor {
+class G2AlgParamManager : public DisparityAlgParamManagerBase {
+public:
+    G2AlgParamManager(IDevice *owner);
+    virtual ~G2AlgParamManager() = default;
+
+    void fetchParamFromDevice() override;
+    void registerBasicExtrinsics() override;
+
+private:
+    std::vector<OBDepthCalibrationParam> depthCalibParamList_;
+};
+}  // namespace libobsensor
diff --git a/src/device/gemini2/G2DepthWorkModeManager.cpp b/src/device/gemini2/G2DepthWorkModeManager.cpp
new file mode 100644
index 00000000..f715f08f
--- /dev/null
+++ b/src/device/gemini2/G2DepthWorkModeManager.cpp
@@ -0,0 +1,74 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "G2DepthWorkModeManager.hpp"
+#include "property/InternalProperty.hpp"
+#include "logger/Logger.hpp"
+
+namespace libobsensor {
+
+G2DepthWorkModeManager::G2DepthWorkModeManager(IDevice *owner) : DeviceComponentBase(owner) {
+
+    auto propServer = owner->getPropertyServer();
+
+    depthWorkModeList_ = propServer->getStructureDataListProtoV1_1_T<OBDepthWorkMode_Internal, 0>(OB_RAW_DATA_DEPTH_ALG_MODE_LIST);
+    // remove factory Calibration mode
+    depthWorkModeList_.erase(std::remove_if(depthWorkModeList_.begin(), depthWorkModeList_.end(),
+                                            [](const OBDepthWorkMode_Internal &mode) {  //
+                                                return strncmp(mode.name, "Factory Calibration", sizeof(mode.name)) == 0;
+                                            }),
+                             depthWorkModeList_.end());
+    currentWorkMode_ = propServer->getStructureDataProtoV1_1_T<OBDepthWorkMode_Internal, 0>(OB_STRUCT_CURRENT_DEPTH_ALG_MODE);
+}
+
+std::vector<OBDepthWorkMode_Internal> G2DepthWorkModeManager::getDepthWorkModeList() const {
+    return depthWorkModeList_;
+}
+
+const OBDepthWorkMode_Internal &G2DepthWorkModeManager::getCurrentDepthWorkMode() const {
+    return currentWorkMode_;
+}
+
+void G2DepthWorkModeManager::switchDepthWorkMode(const std::string &modeName) {
+    auto iter =
+        std::find_if(depthWorkModeList_.begin(), depthWorkModeList_.end(), [&modeName](const OBDepthWorkMode_Internal &mode) { return modeName == mode.name; });
+
+    if(iter == depthWorkModeList_.end()) {
+        std::string totalNames;
+        std::for_each(depthWorkModeList_.begin(), depthWorkModeList_.end(), [&totalNames](const OBDepthWorkMode_Internal &mode) {
+            if(!totalNames.empty()) {
+                totalNames += ",";
+            }
+            totalNames += mode.name;
+        });
+        throw unsupported_operation_exception("Invalid depth mode: " + modeName + ", support depth work mode list: " + totalNames);
+    }
+
+    OBDepthWorkMode_Internal dstMode = *iter;
+    switchDepthWorkMode(dstMode);
+}
+
+void G2DepthWorkModeManager::switchDepthWorkMode(const OBDepthWorkMode_Internal &targetDepthMode) {
+    auto owner = getOwner();
+    {
+        auto propServer = owner->getPropertyServer();  // get property server first to lock resource to avoid start stream at the same time
+
+        if(owner->hasAnySensorStreamActivated()) {
+            throw unsupported_operation_exception(utils::string::to_string()
+                                                  << "Cannot switch depth work mode while any stream is started. Please stop all stream first!");
+        }
+
+        if(strncmp(currentWorkMode_.name, targetDepthMode.name, sizeof(targetDepthMode.name)) == 0) {
+            LOG_DEBUG("switchDepthWorkMode done with same mode: {1}", currentWorkMode_.name, targetDepthMode.name);
+            return;
+        }
+
+        propServer->setStructureDataProtoV1_1_T<OBDepthWorkMode_Internal, 0>(OB_STRUCT_CURRENT_DEPTH_ALG_MODE, targetDepthMode);
+        currentWorkMode_ = targetDepthMode;
+    }
+
+    LOG_INFO("Device depth work mode have been switch to: {1}, device will be reinitialize to apply the new mode.", targetDepthMode.name);
+    owner->reset();
+}
+
+}  // namespace libobsensor
diff --git a/src/device/gemini2/G2DepthWorkModeManager.hpp b/src/device/gemini2/G2DepthWorkModeManager.hpp
new file mode 100644
index 00000000..d2722877
--- /dev/null
+++ b/src/device/gemini2/G2DepthWorkModeManager.hpp
@@ -0,0 +1,29 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include "IDevice.hpp"
+#include "InternalTypes.hpp"
+#include "IDepthWorkModeManager.hpp"
+#include "DeviceComponentBase.hpp"
+
+namespace libobsensor {
+
+class G2DepthWorkModeManager : public IDepthWorkModeManager, public DeviceComponentBase {
+public:
+    G2DepthWorkModeManager(IDevice *owner);
+    virtual ~G2DepthWorkModeManager() = default;
+
+    std::vector<OBDepthWorkMode_Internal> getDepthWorkModeList() const override;
+    const OBDepthWorkMode_Internal       &getCurrentDepthWorkMode() const override;
+    void                                 switchDepthWorkMode(const std::string &modeName) override;
+
+private:
+    void switchDepthWorkMode(const OBDepthWorkMode_Internal &targetDepthMode);
+
+private:
+    std::vector<OBDepthWorkMode_Internal> depthWorkModeList_;
+    OBDepthWorkMode_Internal              currentWorkMode_;
+};
+
+}  // namespace libobsensor
diff --git a/src/device/gemini2/G2Device.cpp b/src/device/gemini2/G2Device.cpp
new file mode 100644
index 00000000..c3778bc7
--- /dev/null
+++ b/src/device/gemini2/G2Device.cpp
@@ -0,0 +1,679 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "G2Device.hpp"
+
+#include "DevicePids.hpp"
+#include "InternalTypes.hpp"
+
+#include "Platform.hpp"
+#include "utils/Utils.hpp"
+#include "environment/EnvConfig.hpp"
+#include "usb/uvc/UvcDevicePort.hpp"
+#include "stream/StreamProfileFactory.hpp"
+
+#include "FilterFactory.hpp"
+#include "publicfilters/FormatConverterProcess.hpp"
+#include "publicfilters/IMUCorrector.hpp"
+
+#include "sensor/video/VideoSensor.hpp"
+#include "sensor/video/DisparityBasedSensor.hpp"
+#include "sensor/imu/ImuStreamer.hpp"
+#include "sensor/imu/AccelSensor.hpp"
+#include "sensor/imu/GyroSensor.hpp"
+#include "timestamp/GlobalTimestampFitter.hpp"
+#include "timestamp/DeviceClockSynchronizer.hpp"
+#include "property/VendorPropertyAccessor.hpp"
+#include "property/UvcPropertyAccessor.hpp"
+#include "property/PropertyServer.hpp"
+#include "property/CommonPropertyAccessors.hpp"
+#include "property/FilterPropertyAccessors.hpp"
+#include "property/PrivateFilterPropertyAccessors.hpp"
+#include "monitor/DeviceMonitor.hpp"
+#include "syncconfig/DeviceSyncConfigurator.hpp"
+#include "firmwareupdater/FirmwareUpdater.hpp"
+
+#include "G2AlgParamManager.hpp"
+#include "G2StreamProfileFilter.hpp"
+#include "G2PropertyAccessors.hpp"
+#include "G2DepthWorkModeManager.hpp"
+#include "G2FrameTimestampCalculator.hpp"
+
+#include <algorithm>
+
+namespace libobsensor {
+
+constexpr uint8_t INTERFACE_COLOR = 4;
+constexpr uint8_t INTERFACE_IR    = 2;
+constexpr uint8_t INTERFACE_DEPTH = 0;
+
+constexpr uint16_t GEMINI2L_PID = 0x0673;
+
+G2Device::G2Device(const std::shared_ptr<const IDeviceEnumInfo> &info) : DeviceBase(info) {
+    init();
+}
+
+G2Device::~G2Device() noexcept {}
+
+void G2Device::init() {
+    initSensorList();
+    initProperties();
+
+    fetchDeviceInfo();
+    fetchExtensionInfo();
+
+    videoFrameTimestampCalculatorCreator_ = [this]() {
+        std::shared_ptr<IFrameTimestampCalculator> calculator;
+        if(deviceInfo_->pid_ == GEMINI2L_PID) {
+            deviceTimeFreq_ = 1000;
+            calculator      = std::make_shared<G2LVideoFrameTimestampCalculator>(this, deviceTimeFreq_, frameTimeFreq_);
+        }
+        else {
+            calculator = std::make_shared<G2VideoFrameTimestampCalculator>(this, deviceTimeFreq_, frameTimeFreq_);
+        }
+        return calculator;
+    };
+
+    auto globalTimestampFilter = std::make_shared<GlobalTimestampFitter>(this);
+    registerComponent(OB_DEV_COMPONENT_GLOBAL_TIMESTAMP_FILTER, globalTimestampFilter);
+
+    auto algParamManager = std::make_shared<G2AlgParamManager>(this);
+    registerComponent(OB_DEV_COMPONENT_ALG_PARAM_MANAGER, algParamManager);
+
+    auto depthWorkModeManager = std::make_shared<G2DepthWorkModeManager>(this);
+    registerComponent(OB_DEV_COMPONENT_DEPTH_WORK_MODE_MANAGER, depthWorkModeManager);
+
+    static const std::vector<OBMultiDeviceSyncMode> supportedSyncModes = {
+        OB_MULTI_DEVICE_SYNC_MODE_FREE_RUN,         OB_MULTI_DEVICE_SYNC_MODE_STANDALONE,          OB_MULTI_DEVICE_SYNC_MODE_PRIMARY,
+        OB_MULTI_DEVICE_SYNC_MODE_SECONDARY_SYNCED, OB_MULTI_DEVICE_SYNC_MODE_SOFTWARE_TRIGGERING, OB_MULTI_DEVICE_SYNC_MODE_HARDWARE_TRIGGERING
+    };
+    auto deviceSyncConfigurator = std::make_shared<DeviceSyncConfiguratorOldProtocol>(this, supportedSyncModes);
+    registerComponent(OB_DEV_COMPONENT_DEVICE_SYNC_CONFIGURATOR, deviceSyncConfigurator);
+    static const std::map<OBMultiDeviceSyncMode, OBSyncMode> syncModeNewToOldMap = {
+        { OB_MULTI_DEVICE_SYNC_MODE_FREE_RUN, OB_SYNC_MODE_CLOSE },  //
+        { OB_MULTI_DEVICE_SYNC_MODE_STANDALONE, OB_SYNC_MODE_STANDALONE },
+        { OB_MULTI_DEVICE_SYNC_MODE_PRIMARY, OB_SYNC_MODE_PRIMARY_MCU_TRIGGER },
+        { OB_MULTI_DEVICE_SYNC_MODE_SECONDARY, OB_SYNC_MODE_PRIMARY_IR_TRIGGER },
+        { OB_MULTI_DEVICE_SYNC_MODE_SECONDARY_SYNCED, OB_SYNC_MODE_PRIMARY_IR_TRIGGER },
+        { OB_MULTI_DEVICE_SYNC_MODE_SOFTWARE_TRIGGERING, OB_SYNC_MODE_PRIMARY },
+        { OB_MULTI_DEVICE_SYNC_MODE_HARDWARE_TRIGGERING, OB_SYNC_MODE_SECONDARY },
+    };
+    static const std::map<OBSyncMode, OBMultiDeviceSyncMode> syncModeOldToNewMap = {
+        { OB_SYNC_MODE_CLOSE, OB_MULTI_DEVICE_SYNC_MODE_FREE_RUN },  //
+        { OB_SYNC_MODE_STANDALONE, OB_MULTI_DEVICE_SYNC_MODE_STANDALONE },
+        { OB_SYNC_MODE_PRIMARY_MCU_TRIGGER, OB_MULTI_DEVICE_SYNC_MODE_PRIMARY },
+        { OB_SYNC_MODE_PRIMARY_IR_TRIGGER, OB_MULTI_DEVICE_SYNC_MODE_SECONDARY_SYNCED },
+        { OB_SYNC_MODE_PRIMARY, OB_MULTI_DEVICE_SYNC_MODE_SOFTWARE_TRIGGERING },
+        { OB_SYNC_MODE_SECONDARY, OB_MULTI_DEVICE_SYNC_MODE_HARDWARE_TRIGGERING },
+    };
+    deviceSyncConfigurator->updateModeAliasMap(syncModeOldToNewMap, syncModeNewToOldMap);
+
+    registerComponent(OB_DEV_COMPONENT_DEVICE_CLOCK_SYNCHRONIZER, [this] {
+        std::shared_ptr<DeviceClockSynchronizer> deviceClockSynchronizer;
+        if(deviceInfo_->pid_ == GEMINI2L_PID) {
+            deviceTimeFreq_         = 1000;
+            deviceClockSynchronizer = std::make_shared<DeviceClockSynchronizer>(this, deviceTimeFreq_, deviceTimeFreq_);
+        }
+        else {
+            deviceTimeFreq_         = 1000000;
+            deviceClockSynchronizer = std::make_shared<DeviceClockSynchronizer>(this, deviceTimeFreq_, 1000);
+        }
+        return deviceClockSynchronizer;
+    });
+
+    registerComponent(OB_DEV_COMPONENT_FIRMWARE_UPDATER, [this]() {
+        std::shared_ptr<FirmwareUpdater> firmwareUpdater;
+        TRY_EXECUTE({ firmwareUpdater = std::make_shared<FirmwareUpdater>(this); })
+        return firmwareUpdater;
+    });
+
+    fixSensorList();  // fix sensor list according to depth alg work mode
+}
+
+void G2Device::initSensorStreamProfile(std::shared_ptr<ISensor> sensor) {
+
+    auto streamProfileFilter = getComponentT<IStreamProfileFilter>(OB_DEV_COMPONENT_STREAM_PROFILE_FILTER);
+    sensor->setStreamProfileFilter(streamProfileFilter.get());
+
+    auto        depthWorkModeManager = getComponentT<IDepthWorkModeManager>(OB_DEV_COMPONENT_DEPTH_WORK_MODE_MANAGER);
+    auto        workMode             = depthWorkModeManager->getCurrentDepthWorkMode();
+    std::string workModeName         = workMode.name;
+    auto        sensorType           = sensor->getSensorType();
+    auto        streamProfile        = StreamProfileFactory::getDefaultStreamProfileFromEnvConfig(deviceInfo_->name_, sensorType, workModeName);
+    if(!streamProfile) {
+        // if not found, try to get default stream profile without work mode
+        streamProfile = StreamProfileFactory::getDefaultStreamProfileFromEnvConfig(deviceInfo_->name_, sensorType);
+    }
+    if(streamProfile) {
+        sensor->updateDefaultStreamProfile(streamProfile);
+    }
+
+    // bind params: extrinsics, intrinsics, etc.
+    auto profiles = sensor->getStreamProfileList();
+    {
+        auto algParamManager = getComponentT<IAlgParamManager>(OB_DEV_COMPONENT_ALG_PARAM_MANAGER);
+        algParamManager->bindStreamProfileParams(profiles);
+    }
+
+    LOG_INFO("Sensor {} created! Found {} stream profiles.", sensorType, profiles.size());
+    for(auto &profile: profiles) {
+        LOG_INFO(" - {}", profile);
+    }
+}
+
+void G2Device::initSensorList() {
+    registerComponent(OB_DEV_COMPONENT_FRAME_PROCESSOR_FACTORY, [this]() {
+        std::shared_ptr<FrameProcessorFactory> factory;
+        TRY_EXECUTE({ factory = std::make_shared<FrameProcessorFactory>(this); })
+        return factory;
+    });
+
+    registerComponent(OB_DEV_COMPONENT_STREAM_PROFILE_FILTER, [this]() { return std::make_shared<G2StreamProfileFilter>(this); });
+
+    auto        platform           = Platform::getInstance();
+    const auto &sourcePortInfoList = enumInfo_->getSourcePortInfoList();
+    auto depthPortInfoIter = std::find_if(sourcePortInfoList.begin(), sourcePortInfoList.end(), [](const std::shared_ptr<const SourcePortInfo> &portInfo) {
+        return portInfo->portType == SOURCE_PORT_USB_UVC && std::dynamic_pointer_cast<const USBSourcePortInfo>(portInfo)->infIndex == INTERFACE_DEPTH;
+    });
+
+    if(depthPortInfoIter != sourcePortInfoList.end()) {
+        auto depthPortInfo = *depthPortInfoIter;
+        registerComponent(
+            OB_DEV_COMPONENT_DEPTH_SENSOR,
+            [this, depthPortInfo]() {
+                auto platform = Platform::getInstance();
+                auto port     = platform->getSourcePort(depthPortInfo);
+                auto sensor   = std::make_shared<DisparityBasedSensor>(this, OB_SENSOR_DEPTH, port);
+
+                std::vector<FormatFilterConfig> formatFilterConfigs = {
+                    { FormatFilterPolicy::REPLACE, OB_FORMAT_MJPG, OB_FORMAT_RLE, nullptr },
+                };
+                // auto formatConverter = getSensorFrameFilter("FrameUnpacker", OB_SENSOR_DEPTH, false);
+                // if(formatConverter) {
+                //     formatFilterConfigs.push_back({ FormatFilterPolicy::ADD, OB_FORMAT_MJPG, OB_FORMAT_Y16, formatConverter });
+                // }
+                sensor->updateFormatFilterConfig(formatFilterConfigs);
+
+                auto frameTimestampCalculator = videoFrameTimestampCalculatorCreator_();
+                sensor->setFrameTimestampCalculator(frameTimestampCalculator);
+
+                auto globalFrameTimestampCalculator = std::make_shared<GlobalTimestampCalculator>(this, deviceTimeFreq_, frameTimeFreq_);
+                sensor->setGlobalTimestampCalculator(globalFrameTimestampCalculator);
+
+                auto frameProcessor = getComponentT<FrameProcessor>(OB_DEV_COMPONENT_DEPTH_FRAME_PROCESSOR, false);
+                if(frameProcessor) {
+                    sensor->setFrameProcessor(frameProcessor.get());
+                }
+
+                auto propServer = getPropertyServer();
+
+                propServer->setPropertyValueT<bool>(OB_PROP_DISPARITY_TO_DEPTH_BOOL, false);
+                propServer->setPropertyValueT<bool>(OB_PROP_SDK_DISPARITY_TO_DEPTH_BOOL, true);
+                sensor->markOutputDisparityFrame(true);
+
+                propServer->setPropertyValueT(OB_PROP_DEPTH_PRECISION_LEVEL_INT, OB_PRECISION_1MM);
+                sensor->setDepthUnit(1.0f);
+
+                initSensorStreamProfile(sensor);
+
+                return sensor;
+            },
+            true);
+
+        registerSensorPortInfo(OB_SENSOR_DEPTH, depthPortInfo);
+
+        registerComponent(OB_DEV_COMPONENT_DEPTH_FRAME_PROCESSOR, [this]() {
+            auto factory        = getComponentT<FrameProcessorFactory>(OB_DEV_COMPONENT_FRAME_PROCESSOR_FACTORY);
+            auto frameProcessor = factory->createFrameProcessor(OB_SENSOR_DEPTH);
+            return frameProcessor;
+        });
+
+        // right ir stream is using depth stream port when depth work mode optionCode is MX6600_RIGHT_IR_FROM_DEPTH_CHANNEL
+        registerComponent(
+            OB_DEV_COMPONENT_RIGHT_IR_SENSOR,
+            [this, depthPortInfo]() {
+                auto platform = Platform::getInstance();
+                auto port     = platform->getSourcePort(depthPortInfo);
+                auto sensor   = std::make_shared<VideoSensor>(this, OB_SENSOR_IR_RIGHT, port);
+
+                auto frameTimestampCalculator = videoFrameTimestampCalculatorCreator_();
+                sensor->setFrameTimestampCalculator(frameTimestampCalculator);
+
+                auto globalFrameTimestampCalculator = std::make_shared<GlobalTimestampCalculator>(this, deviceTimeFreq_, frameTimeFreq_);
+                sensor->setGlobalTimestampCalculator(globalFrameTimestampCalculator);
+
+                auto frameProcessor = getComponentT<FrameProcessor>(OB_DEV_COMPONENT_RIGHT_IR_FRAME_PROCESSOR, false);
+                if(frameProcessor) {
+                    sensor->setFrameProcessor(frameProcessor.get());
+                }
+
+                initSensorStreamProfile(sensor);
+
+                return sensor;
+            },
+            true);
+
+        registerSensorPortInfo(OB_SENSOR_IR_RIGHT, depthPortInfo);
+
+        registerComponent(OB_DEV_COMPONENT_RIGHT_IR_FRAME_PROCESSOR, [this]() {
+            auto factory        = getComponentT<FrameProcessorFactory>(OB_DEV_COMPONENT_FRAME_PROCESSOR_FACTORY);
+            auto frameProcessor = factory->createFrameProcessor(OB_SENSOR_IR_RIGHT);
+            return frameProcessor;
+        });
+
+        // the main property accessor is using the depth port(uvc xu)
+        registerComponent(OB_DEV_COMPONENT_MAIN_PROPERTY_ACCESSOR, [this, depthPortInfo]() {
+            auto platform = Platform::getInstance();
+            auto port     = platform->getSourcePort(depthPortInfo);
+            auto accessor = std::make_shared<VendorPropertyAccessor>(this, port);
+            return accessor;
+        });
+
+        // The device monitor is using the depth port(uvc xu)
+        registerComponent(OB_DEV_COMPONENT_DEVICE_MONITOR, [this, depthPortInfo]() {
+            auto platform   = Platform::getInstance();
+            auto port       = platform->getSourcePort(depthPortInfo);
+            auto devMonitor = std::make_shared<DeviceMonitor>(this, port);
+            return devMonitor;
+        });
+    }
+
+    auto irPortInfoIter = std::find_if(sourcePortInfoList.begin(), sourcePortInfoList.end(), [](const std::shared_ptr<const SourcePortInfo> &portInfo) {
+        return portInfo->portType == SOURCE_PORT_USB_UVC && std::dynamic_pointer_cast<const USBSourcePortInfo>(portInfo)->infIndex == INTERFACE_IR;
+    });
+
+    if(irPortInfoIter != sourcePortInfoList.end()) {
+        auto irPortInfo = *irPortInfoIter;
+        registerComponent(
+            OB_DEV_COMPONENT_IR_SENSOR,
+            [this, irPortInfo]() {
+                auto platform = Platform::getInstance();
+                auto port     = platform->getSourcePort(irPortInfo);
+                auto sensor   = std::make_shared<VideoSensor>(this, OB_SENSOR_IR, port);
+
+                auto frameTimestampCalculator = videoFrameTimestampCalculatorCreator_();
+                sensor->setFrameTimestampCalculator(frameTimestampCalculator);
+
+                auto globalFrameTimestampCalculator = std::make_shared<GlobalTimestampCalculator>(this, deviceTimeFreq_, frameTimeFreq_);
+                sensor->setGlobalTimestampCalculator(globalFrameTimestampCalculator);
+
+                auto frameProcessor = getComponentT<FrameProcessor>(OB_DEV_COMPONENT_IR_FRAME_PROCESSOR, false);
+                if(frameProcessor) {
+                    sensor->setFrameProcessor(frameProcessor.get());
+                }
+
+                initSensorStreamProfile(sensor);
+
+                return sensor;
+            },
+            true);
+        registerSensorPortInfo(OB_SENSOR_IR, irPortInfo);
+
+        registerComponent(OB_DEV_COMPONENT_IR_FRAME_PROCESSOR, [this]() {
+            auto factory        = getComponentT<FrameProcessorFactory>(OB_DEV_COMPONENT_FRAME_PROCESSOR_FACTORY);
+            auto frameProcessor = factory->createFrameProcessor(OB_SENSOR_IR);
+            return frameProcessor;
+        });
+
+        // left ir stream is using the same port as the ir stream when depth work mode optionCode is MX6600_RIGHT_IR_FROM_DEPTH_CHANNEL
+        registerComponent(
+            OB_DEV_COMPONENT_LEFT_IR_SENSOR,
+            [this, irPortInfo]() {
+                auto platform = Platform::getInstance();
+                auto port     = platform->getSourcePort(irPortInfo);
+                auto sensor   = std::make_shared<VideoSensor>(this, OB_SENSOR_IR_LEFT, port);
+
+                auto frameTimestampCalculator = videoFrameTimestampCalculatorCreator_();
+                sensor->setFrameTimestampCalculator(frameTimestampCalculator);
+
+                auto globalFrameTimestampCalculator = std::make_shared<GlobalTimestampCalculator>(this, deviceTimeFreq_, frameTimeFreq_);
+                sensor->setGlobalTimestampCalculator(globalFrameTimestampCalculator);
+
+                auto frameProcessor = getComponentT<FrameProcessor>(OB_DEV_COMPONENT_LEFT_IR_FRAME_PROCESSOR, false);
+                if(frameProcessor) {
+                    sensor->setFrameProcessor(frameProcessor.get());
+                }
+
+                initSensorStreamProfile(sensor);
+
+                return sensor;
+            },
+            true);
+        registerSensorPortInfo(OB_SENSOR_IR_LEFT, irPortInfo);
+
+        registerComponent(OB_DEV_COMPONENT_LEFT_IR_FRAME_PROCESSOR, [this]() {
+            auto factory        = getComponentT<FrameProcessorFactory>(OB_DEV_COMPONENT_FRAME_PROCESSOR_FACTORY);
+            auto frameProcessor = factory->createFrameProcessor(OB_SENSOR_IR_LEFT);
+            return frameProcessor;
+        });
+    }
+
+    auto colorPortInfoIter = std::find_if(sourcePortInfoList.begin(), sourcePortInfoList.end(), [](const std::shared_ptr<const SourcePortInfo> &portInfo) {
+        return portInfo->portType == SOURCE_PORT_USB_UVC && std::dynamic_pointer_cast<const USBSourcePortInfo>(portInfo)->infIndex == INTERFACE_COLOR;
+    });
+
+    if(colorPortInfoIter != sourcePortInfoList.end()) {
+        auto colorPortInfo = *colorPortInfoIter;
+        registerComponent(
+            OB_DEV_COMPONENT_COLOR_SENSOR,
+            [this, colorPortInfo]() {
+                auto platform = Platform::getInstance();
+                auto port     = platform->getSourcePort(colorPortInfo);
+                auto sensor   = std::make_shared<VideoSensor>(this, OB_SENSOR_COLOR, port);
+
+                std::vector<FormatFilterConfig> formatFilterConfigs = {
+                    { FormatFilterPolicy::REMOVE, OB_FORMAT_NV12, OB_FORMAT_ANY, nullptr },
+                };
+
+                auto formatConverter = getSensorFrameFilter("FormatConverter", OB_SENSOR_COLOR, false);
+                if(formatConverter) {
+#ifdef WIN32
+                    formatFilterConfigs.push_back({ FormatFilterPolicy::ADD, OB_FORMAT_BGR, OB_FORMAT_RGB, formatConverter });
+#else
+                    formatFilterConfigs.push_back({ FormatFilterPolicy::ADD, OB_FORMAT_MJPG, OB_FORMAT_RGB, formatConverter });
+                    formatFilterConfigs.push_back({ FormatFilterPolicy::ADD, OB_FORMAT_MJPG, OB_FORMAT_BGR, formatConverter });
+                    formatFilterConfigs.push_back({ FormatFilterPolicy::ADD, OB_FORMAT_MJPG, OB_FORMAT_BGRA, formatConverter });
+#endif
+                }
+                sensor->updateFormatFilterConfig(formatFilterConfigs);
+
+                auto frameTimestampCalculator = videoFrameTimestampCalculatorCreator_();
+                sensor->setFrameTimestampCalculator(frameTimestampCalculator);
+
+                auto globalFrameTimestampCalculator = std::make_shared<GlobalTimestampCalculator>(this, deviceTimeFreq_, frameTimeFreq_);
+                sensor->setGlobalTimestampCalculator(globalFrameTimestampCalculator);
+
+                auto frameProcessor = getComponentT<FrameProcessor>(OB_DEV_COMPONENT_COLOR_FRAME_PROCESSOR, false);
+                if(frameProcessor) {
+                    sensor->setFrameProcessor(frameProcessor.get());
+                }
+
+                initSensorStreamProfile(sensor);
+
+                return sensor;
+            },
+            true);
+        registerSensorPortInfo(OB_SENSOR_COLOR, colorPortInfo);
+
+        registerComponent(OB_DEV_COMPONENT_COLOR_FRAME_PROCESSOR, [this]() {
+            auto factory        = getComponentT<FrameProcessorFactory>(OB_DEV_COMPONENT_FRAME_PROCESSOR_FACTORY);
+            auto frameProcessor = factory->createFrameProcessor(OB_SENSOR_COLOR);
+            return frameProcessor;
+        });
+    }
+
+    auto imuPortInfoIter = std::find_if(sourcePortInfoList.begin(), sourcePortInfoList.end(), [](const std::shared_ptr<const SourcePortInfo> &portInfo) {
+        return portInfo->portType == SOURCE_PORT_USB_HID;  //
+    });
+
+    if(imuPortInfoIter != sourcePortInfoList.end()) {
+        auto imuPortInfo = *imuPortInfoIter;
+
+        registerComponent(OB_DEV_COMPONENT_IMU_STREAMER, [this, imuPortInfo]() {
+            // the gyro and accel are both on the same port and share the same filter
+            auto platform           = Platform::getInstance();
+            auto port               = platform->getSourcePort(imuPortInfo);
+            auto imuCorrectorFilter = getSensorFrameFilter("IMUCorrector", OB_SENSOR_ACCEL, true);
+
+            imuCorrectorFilter->enable(false);
+            auto dataStreamPort = std::dynamic_pointer_cast<IDataStreamPort>(port);
+            auto imuStreamer    = std::make_shared<ImuStreamer>(this, dataStreamPort, imuCorrectorFilter);
+            return imuStreamer;
+        });
+
+        registerComponent(
+            OB_DEV_COMPONENT_ACCEL_SENSOR,
+            [this, imuPortInfo]() {
+                auto platform             = Platform::getInstance();
+                auto port                 = platform->getSourcePort(imuPortInfo);
+                auto imuStreamer          = getComponentT<ImuStreamer>(OB_DEV_COMPONENT_IMU_STREAMER);
+                auto imuStreamerSharedPtr = imuStreamer.get();
+                auto sensor               = std::make_shared<AccelSensor>(this, port, imuStreamerSharedPtr);
+
+                auto globalFrameTimestampCalculator = std::make_shared<GlobalTimestampCalculator>(this, deviceTimeFreq_, frameTimeFreq_);
+                sensor->setGlobalTimestampCalculator(globalFrameTimestampCalculator);
+
+                initSensorStreamProfile(sensor);
+
+                return sensor;
+            },
+            true);
+        registerSensorPortInfo(OB_SENSOR_ACCEL, imuPortInfo);
+
+        registerComponent(
+            OB_DEV_COMPONENT_GYRO_SENSOR,
+            [this, imuPortInfo]() {
+                auto platform             = Platform::getInstance();
+                auto port                 = platform->getSourcePort(imuPortInfo);
+                auto imuStreamer          = getComponentT<ImuStreamer>(OB_DEV_COMPONENT_IMU_STREAMER);
+                auto imuStreamerSharedPtr = imuStreamer.get();
+                auto sensor               = std::make_shared<GyroSensor>(this, port, imuStreamerSharedPtr);
+
+                auto globalFrameTimestampCalculator = std::make_shared<GlobalTimestampCalculator>(this, deviceTimeFreq_, frameTimeFreq_);
+                sensor->setGlobalTimestampCalculator(globalFrameTimestampCalculator);
+
+                initSensorStreamProfile(sensor);
+
+                return sensor;
+            },
+            true);
+        registerSensorPortInfo(OB_SENSOR_GYRO, imuPortInfo);
+    }
+}
+
+void G2Device::fixSensorList() {
+    auto depthWorkModeManager = getComponentT<G2DepthWorkModeManager>(OB_DEV_COMPONENT_DEPTH_WORK_MODE_MANAGER);
+    auto currentMode          = depthWorkModeManager->getCurrentDepthWorkMode();
+
+    // deregister unsupported sensors according to depth work mode option code
+    if(currentMode.optionCode == OBDepthModeOptionCode::MX6600_RIGHT_IR_FROM_DEPTH_CHANNEL) {
+        deregisterSensor(OB_SENSOR_IR);
+        deregisterSensor(OB_SENSOR_DEPTH);
+    }
+    else {
+        deregisterSensor(OB_SENSOR_IR_LEFT);
+        deregisterSensor(OB_SENSOR_IR_RIGHT);
+    }
+}
+
+void G2Device::initProperties() {
+    auto propertyServer = std::make_shared<PropertyServer>(this);
+
+    auto d2dPropertyAccessor = std::make_shared<G2Disp2DepthPropertyAccessor>(this);
+    propertyServer->registerProperty(OB_PROP_DISPARITY_TO_DEPTH_BOOL, "rw", "rw", d2dPropertyAccessor);      // hw
+    propertyServer->registerProperty(OB_PROP_SDK_DISPARITY_TO_DEPTH_BOOL, "rw", "rw", d2dPropertyAccessor);  // sw
+    propertyServer->registerProperty(OB_PROP_DEPTH_PRECISION_LEVEL_INT, "rw", "rw", d2dPropertyAccessor);
+    propertyServer->registerProperty(OB_STRUCT_DEPTH_PRECISION_SUPPORT_LIST, "r", "r", d2dPropertyAccessor);
+
+    auto privatePropertyAccessor = std::make_shared<PrivateFilterPropertyAccessor>(this);
+    propertyServer->registerProperty(OB_PROP_DEPTH_SOFT_FILTER_BOOL, "rw", "rw", privatePropertyAccessor);
+    propertyServer->registerProperty(OB_PROP_DEPTH_MAX_DIFF_INT, "rw", "rw", privatePropertyAccessor);
+    propertyServer->registerProperty(OB_PROP_DEPTH_MAX_SPECKLE_SIZE_INT, "rw", "rw", privatePropertyAccessor);
+
+    auto sensors = getSensorTypeList();
+    for(auto &sensor: sensors) {
+        auto  platform       = Platform::getInstance();
+        auto &sourcePortInfo = getSensorPortInfo(sensor);
+        if(sensor == OB_SENSOR_COLOR) {
+            auto uvcPropertyAccessor = std::make_shared<LazyPropertyAccessor>([&sourcePortInfo]() {
+                auto platform = Platform::getInstance();
+                auto port     = platform->getSourcePort(sourcePortInfo);
+                auto accessor = std::make_shared<UvcPropertyAccessor>(port);
+                return accessor;
+            });
+
+            propertyServer->registerProperty(OB_PROP_COLOR_AUTO_EXPOSURE_BOOL, "rw", "rw", uvcPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_COLOR_GAIN_INT, "rw", "rw", uvcPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_COLOR_SATURATION_INT, "rw", "rw", uvcPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_COLOR_AUTO_WHITE_BALANCE_BOOL, "rw", "rw", uvcPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_COLOR_WHITE_BALANCE_INT, "rw", "rw", uvcPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_COLOR_BRIGHTNESS_INT, "rw", "rw", uvcPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_COLOR_SHARPNESS_INT, "rw", "rw", uvcPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_COLOR_CONTRAST_INT, "rw", "rw", uvcPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_COLOR_POWER_LINE_FREQUENCY_INT, "rw", "rw", uvcPropertyAccessor);
+        }
+        else if(sensor == OB_SENSOR_IR) {
+            auto uvcPropertyAccessor = std::make_shared<LazyPropertyAccessor>([sourcePortInfo]() {
+                auto platform = Platform::getInstance();
+                auto port     = platform->getSourcePort(sourcePortInfo);
+                auto accessor = std::make_shared<UvcPropertyAccessor>(port);
+                return accessor;
+            });
+            propertyServer->registerProperty(OB_PROP_IR_GAIN_INT, "rw", "rw", uvcPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_IR_AUTO_EXPOSURE_BOOL, "rw", "rw", uvcPropertyAccessor);
+        }
+        else if(sensor == OB_SENSOR_DEPTH) {
+            auto uvcPropertyAccessor = std::make_shared<LazyPropertyAccessor>([&sourcePortInfo]() {
+                auto platform = Platform::getInstance();
+                auto port     = platform->getSourcePort(sourcePortInfo);
+                auto accessor = std::make_shared<UvcPropertyAccessor>(port);
+                return accessor;
+            });
+
+            auto vendorPropertyAccessor = std::make_shared<LazySuperPropertyAccessor>([this, &sourcePortInfo]() {
+                auto platform               = Platform::getInstance();
+                auto port                   = platform->getSourcePort(sourcePortInfo);
+                auto vendorPropertyAccessor = std::make_shared<VendorPropertyAccessor>(this, port);
+                return vendorPropertyAccessor;
+            });
+
+            propertyServer->registerProperty(OB_PROP_IR_EXPOSURE_INT, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_COLOR_EXPOSURE_INT, "rw", "rw", vendorPropertyAccessor);  // using vendor property accessor
+            propertyServer->registerProperty(OB_PROP_LDP_BOOL, "rw", "rw", vendorPropertyAccessor);
+
+            propertyServer->registerProperty(OB_PROP_LASER_BOOL, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_DEPTH_HOLEFILTER_BOOL, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_LDP_STATUS_BOOL, "r", "r", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_DEPTH_ALIGN_HARDWARE_BOOL, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_LASER_POWER_LEVEL_CONTROL_INT, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_LDP_MEASURE_DISTANCE_INT, "r", "r", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_DEPTH_ALIGN_HARDWARE_MODE_INT, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_TIMER_RESET_SIGNAL_BOOL, "w", "w", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_TIMER_RESET_TRIGGER_OUT_ENABLE_BOOL, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->aliasProperty(OB_PROP_SYNC_SIGNAL_TRIGGER_OUT_BOOL, OB_PROP_TIMER_RESET_TRIGGER_OUT_ENABLE_BOOL);
+            propertyServer->registerProperty(OB_PROP_TIMER_RESET_DELAY_US_INT, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_CAPTURE_IMAGE_SIGNAL_BOOL, "w", "w", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_DEPTH_MIRROR_MODULE_STATUS_BOOL, "", "r", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_CAPTURE_IMAGE_FRAME_NUMBER_INT, "rw", "rw", vendorPropertyAccessor);
+
+            propertyServer->registerProperty(OB_STRUCT_VERSION, "", "r", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_STRUCT_DEVICE_TEMPERATURE, "r", "r", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_STRUCT_CURRENT_DEPTH_ALG_MODE, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_STRUCT_DEVICE_SERIAL_NUMBER, "r", "r", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_STRUCT_MULTI_DEVICE_SYNC_CONFIG, "rw", "rw", vendorPropertyAccessor);
+
+            propertyServer->registerProperty(OB_RAW_DATA_EFFECTIVE_VIDEO_STREAM_PROFILE_LIST, "", "r", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_RAW_DATA_DEPTH_ALG_MODE_LIST, "r", "r", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_RAW_DATA_IMU_CALIB_PARAM, "", "r", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_RAW_DATA_DEPTH_CALIB_PARAM, "", "r", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_RAW_DATA_ALIGN_CALIB_PARAM, "", "r", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_RAW_DATA_D2C_ALIGN_SUPPORT_PROFILE_LIST, "", "r", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_SDK_DEPTH_FRAME_UNPACK_BOOL, "", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_IR_CHANNEL_DATA_SOURCE_INT, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_DEPTH_RM_FILTER_BOOL, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_WATCHDOG_BOOL, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_EXTERNAL_SIGNAL_RESET_BOOL, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_LASER_POWER_ACTUAL_LEVEL_INT, "r", "r", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_STRUCT_DEVICE_TIME, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_GYRO_ODR_INT, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_ACCEL_ODR_INT, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_ACCEL_SWITCH_BOOL, "", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_GYRO_SWITCH_BOOL, "", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_GYRO_FULL_SCALE_INT, "", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_ACCEL_FULL_SCALE_INT, "", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_STRUCT_GET_ACCEL_PRESETS_ODR_LIST, "", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_STRUCT_GET_ACCEL_PRESETS_FULL_SCALE_LIST, "", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_STRUCT_GET_GYRO_PRESETS_ODR_LIST, "", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_STRUCT_GET_GYRO_PRESETS_FULL_SCALE_LIST, "", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_DEVICE_USB2_REPEAT_IDENTIFY_BOOL, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_DEVICE_RESET_BOOL, "", "w", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_STOP_DEPTH_STREAM_BOOL, "", "w", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_STOP_IR_STREAM_BOOL, "", "w", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_STOP_COLOR_STREAM_BOOL, "", "w", vendorPropertyAccessor);
+        }
+        else if(sensor == OB_SENSOR_ACCEL) {
+            auto imuCorrectorFilter = getSensorFrameFilter("IMUCorrector", sensor);
+            if(imuCorrectorFilter) {
+                auto filterStateProperty = std::make_shared<FilterStatePropertyAccessor>(imuCorrectorFilter);
+                propertyServer->registerProperty(OB_PROP_SDK_ACCEL_FRAME_TRANSFORMED_BOOL, "rw", "rw", filterStateProperty);
+            }
+        }
+        else if(sensor == OB_SENSOR_GYRO) {
+            auto imuCorrectorFilter = getSensorFrameFilter("IMUCorrector", sensor);
+            if(imuCorrectorFilter) {
+                auto filterStateProperty = std::make_shared<FilterStatePropertyAccessor>(imuCorrectorFilter);
+                propertyServer->registerProperty(OB_PROP_SDK_GYRO_FRAME_TRANSFORMED_BOOL, "rw", "rw", filterStateProperty);
+            }
+        }
+    }
+
+    propertyServer->aliasProperty(OB_PROP_DEPTH_AUTO_EXPOSURE_BOOL, OB_PROP_IR_AUTO_EXPOSURE_BOOL);
+    propertyServer->aliasProperty(OB_PROP_DEPTH_GAIN_INT, OB_PROP_IR_GAIN_INT);
+    propertyServer->aliasProperty(OB_PROP_DEPTH_EXPOSURE_INT, OB_PROP_IR_EXPOSURE_INT);
+
+    auto heartbeatPropertyAccessor = std::make_shared<HeartbeatPropertyAccessor>(this);
+    propertyServer->registerProperty(OB_PROP_HEARTBEAT_BOOL, "rw", "rw", heartbeatPropertyAccessor);
+
+    auto baseLinePropertyAccessor = std::make_shared<BaselinePropertyAccessor>(this);
+    propertyServer->registerProperty(OB_STRUCT_BASELINE_CALIBRATION_PARAM, "r", "r", baseLinePropertyAccessor);
+
+    registerComponent(OB_DEV_COMPONENT_PROPERTY_SERVER, propertyServer, true);
+}
+
+std::vector<std::shared_ptr<IFilter>> G2Device::createRecommendedPostProcessingFilters(OBSensorType type) {
+    if(type != OB_SENSOR_DEPTH) {
+        return {};
+    }
+    // activate depth frame processor library
+    getComponentT<FrameProcessor>(OB_DEV_COMPONENT_DEPTH_FRAME_PROCESSOR, false);
+
+    auto                                  filterFactory = FilterFactory::getInstance();
+    std::vector<std::shared_ptr<IFilter>> depthFilterList;
+
+    if(filterFactory->isFilterCreatorExists("EdgeNoiseRemovalFilter")) {
+        auto enrFilter = filterFactory->createFilter("EdgeNoiseRemovalFilter");
+        enrFilter->enable(false);
+        // todo: set default values
+        depthFilterList.push_back(enrFilter);
+    }
+
+    if(filterFactory->isFilterCreatorExists("SpatialAdvancedFilter")) {
+        auto spatFilter = filterFactory->createFilter("SpatialAdvancedFilter");
+        spatFilter->enable(false);
+        // magnitude, alpha, disp_diff, radius
+        std::vector<std::string> params = { "1", "0.5", "64", "1" };
+        spatFilter->updateConfig(params);
+        depthFilterList.push_back(spatFilter);
+    }
+
+    if(filterFactory->isFilterCreatorExists("TemporalFilter")) {
+        auto tempFilter = filterFactory->createFilter("TemporalFilter");
+        tempFilter->enable(false);
+        // diff_scale, weight
+        std::vector<std::string> params = { "0.1", "0.4" };
+        tempFilter->updateConfig(params);
+        depthFilterList.push_back(tempFilter);
+    }
+
+    if(filterFactory->isFilterCreatorExists("HoleFillingFilter")) {
+        auto hfFilter = filterFactory->createFilter("HoleFillingFilter");
+        hfFilter->enable(false);
+        depthFilterList.push_back(hfFilter);
+    }
+
+    if(filterFactory->isFilterCreatorExists("DisparityTransform")) {
+        auto dtFilter = filterFactory->createFilter("DisparityTransform");
+        dtFilter->enable(true);
+        depthFilterList.push_back(dtFilter);
+    }
+
+    if(filterFactory->isFilterCreatorExists("ThresholdFilter")) {
+        auto ThresholdFilter = filterFactory->createFilter("ThresholdFilter");
+        depthFilterList.push_back(ThresholdFilter);
+    }
+
+    return depthFilterList;
+}
+
+}  // namespace libobsensor
+
diff --git a/src/device/gemini2/G2Device.hpp b/src/device/gemini2/G2Device.hpp
new file mode 100644
index 00000000..c53bad87
--- /dev/null
+++ b/src/device/gemini2/G2Device.hpp
@@ -0,0 +1,35 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include "DeviceBase.hpp"
+#include "IDeviceManager.hpp"
+#include "frameprocessor/FrameProcessor.hpp"
+
+#include <map>
+#include <memory>
+
+namespace libobsensor {
+
+class G2Device : public DeviceBase {
+public:
+    G2Device(const std::shared_ptr<const IDeviceEnumInfo> &info);
+    virtual ~G2Device() noexcept;
+
+    std::vector<std::shared_ptr<IFilter>> createRecommendedPostProcessingFilters(OBSensorType type) override;
+
+private:
+    void init() override;
+    void initSensorList();
+    void initProperties();
+    void initSensorStreamProfile(std::shared_ptr<ISensor> sensor);
+    void fixSensorList();  // fix sensor list according to the depth work mode
+
+private:
+    const uint64_t                                              frameTimeFreq_  = 1000000;
+    uint64_t                                                    deviceTimeFreq_ = 1000000;
+    std::function<std::shared_ptr<IFrameTimestampCalculator>()> videoFrameTimestampCalculatorCreator_;
+};
+
+}  // namespace libobsensor
+
diff --git a/src/device/gemini2/G2DeviceInfo.cpp b/src/device/gemini2/G2DeviceInfo.cpp
new file mode 100644
index 00000000..5aae30d9
--- /dev/null
+++ b/src/device/gemini2/G2DeviceInfo.cpp
@@ -0,0 +1,124 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "G2DeviceInfo.hpp"
+#include "G2Device.hpp"
+#include "G2XLDevice.hpp"
+#include "usb/UsbPortGroup.hpp"
+#include "DevicePids.hpp"
+#include "utils/Utils.hpp"
+#include "exception/ObException.hpp"
+#include "ethernet/NetPortGroup.hpp"
+#include "ethernet/RTSPStreamPort.hpp"
+#include "ethernet/NetDataStreamPort.hpp"
+
+#include <map>
+
+namespace libobsensor {
+
+const std::map<int, std::string> G2DeviceNameMap = { { 0x0670, "Gemini2" }, { 0x0673, "Gemini2 L" }, { 0x0671, "Gemini2 XL" } };
+
+G2DeviceInfo::G2DeviceInfo(const SourcePortInfoList groupedInfoList) {
+    auto firstPortInfo = groupedInfoList.front();
+    if(IS_USB_PORT(firstPortInfo->portType)) {
+        auto portInfo = std::dynamic_pointer_cast<const USBSourcePortInfo>(groupedInfoList.front());
+
+        auto iter = G2DeviceNameMap.find(portInfo->pid);
+        if(iter != G2DeviceNameMap.end()) {
+            name_ = iter->second;
+        }
+        else {
+            name_ = "Gemini2 series device";
+        }
+
+        fullName_ = "Orbbec " + name_;
+
+        pid_                = portInfo->pid;
+        vid_                = portInfo->vid;
+        uid_                = portInfo->uid;
+        deviceSn_           = portInfo->serial;
+        connectionType_     = portInfo->connSpec;
+        sourcePortInfoList_ = groupedInfoList;
+    }
+    else if(IS_NET_PORT(firstPortInfo->portType)) {
+        auto portInfo = std::dynamic_pointer_cast<const NetSourcePortInfo>(groupedInfoList.front());
+
+        auto iter = G2DeviceNameMap.find(portInfo->pid);
+        if(iter != G2DeviceNameMap.end()) {
+            name_ = iter->second;
+        }
+        else {
+            name_ = "Gemini2 series device";
+        }
+
+        fullName_           = "Orbbec " + name_;
+        pid_                = portInfo->pid;
+        vid_                = 0x2BC5;
+        uid_                = portInfo->mac;
+        deviceSn_           = portInfo->serialNumber;
+        connectionType_     = "Ethernet";
+        sourcePortInfoList_ = groupedInfoList;
+    }
+    else {
+        throw invalid_value_exception("Invalid port type");
+    }
+}
+
+G2DeviceInfo::~G2DeviceInfo() noexcept {}
+
+std::shared_ptr<IDevice> G2DeviceInfo::createDevice() const {
+    if(pid_ == 0x0671) {
+        if(IS_NET_PORT(sourcePortInfoList_.front()->portType)) {
+            return std::make_shared<G2XLNetDevice>(shared_from_this());
+        }
+        return std::make_shared<G2XLUSBDevice>(shared_from_this());
+    }
+    return std::make_shared<G2Device>(shared_from_this());
+}
+
+std::vector<std::shared_ptr<IDeviceEnumInfo>> G2DeviceInfo::pickDevices(const SourcePortInfoList infoList) {
+    std::vector<std::shared_ptr<IDeviceEnumInfo>> G2DeviceInfos;
+    auto                                          remainder = FilterUSBPortInfoByPid(infoList, Gemini2DevPids);
+    auto                                          groups    = utils::groupVector<std::shared_ptr<const SourcePortInfo>>(remainder, GroupUSBSourcePortByUrl);
+    auto                                          iter      = groups.begin();
+    while(iter != groups.end()) {
+        if(iter->size() >= 4) {
+            auto info = std::make_shared<G2DeviceInfo>(*iter);
+            G2DeviceInfos.push_back(info);
+        }
+        iter++;
+    }
+
+    return G2DeviceInfos;
+}
+
+std::vector<std::shared_ptr<IDeviceEnumInfo>> G2DeviceInfo::pickNetDevices(const SourcePortInfoList infoList) {
+    std::vector<std::shared_ptr<IDeviceEnumInfo>> gemini2DeviceInfos;
+    auto                                          remainder = FilterNetPortInfoByPid(infoList, Gemini2DevPids);
+    auto                                          groups    = utils::groupVector<std::shared_ptr<const SourcePortInfo>>(remainder, GroupNetSourcePortByMac);
+    auto                                          iter      = groups.begin();
+    while(iter != groups.end()) {
+        if(iter->size() >= 1) {
+            auto portInfo = std::dynamic_pointer_cast<const NetSourcePortInfo>(iter->front());
+            iter->emplace_back(std::make_shared<RTSPStreamPortInfo>(portInfo->address, static_cast<uint16_t>(8888), portInfo->port, OB_STREAM_COLOR,
+                                                                    portInfo->mac, portInfo->serialNumber, portInfo->pid));
+            iter->emplace_back(std::make_shared<RTSPStreamPortInfo>(portInfo->address, static_cast<uint16_t>(8554), portInfo->port, OB_STREAM_DEPTH,
+                                                                    portInfo->mac, portInfo->serialNumber, portInfo->pid));
+            iter->emplace_back(std::make_shared<RTSPStreamPortInfo>(portInfo->address, static_cast<uint16_t>(8555), portInfo->port, OB_STREAM_IR_LEFT,
+                                                                    portInfo->mac, portInfo->serialNumber, portInfo->pid));
+            iter->emplace_back(std::make_shared<RTSPStreamPortInfo>(portInfo->address, static_cast<uint16_t>(8556), portInfo->port, OB_STREAM_IR_RIGHT,
+                                                                    portInfo->mac, portInfo->serialNumber, portInfo->pid));
+            iter->emplace_back(std::make_shared<NetDataStreamPortInfo>(portInfo->address, static_cast<uint16_t>(8900), portInfo->port, portInfo->mac,
+                                                                       portInfo->serialNumber, portInfo->pid));
+
+            auto deviceEnumInfo = std::make_shared<G2DeviceInfo>(*iter);
+            gemini2DeviceInfos.push_back(deviceEnumInfo);
+        }
+        iter++;
+    }
+
+    return gemini2DeviceInfos;
+}
+
+}  // namespace libobsensor
+
diff --git a/src/device/gemini2/G2DeviceInfo.hpp b/src/device/gemini2/G2DeviceInfo.hpp
new file mode 100644
index 00000000..c9313f21
--- /dev/null
+++ b/src/device/gemini2/G2DeviceInfo.hpp
@@ -0,0 +1,26 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include "devicemanager/DeviceEnumInfoBase.hpp"
+
+#include <iostream>
+#include <string>
+#include <vector>
+#include <memory>
+
+namespace libobsensor {
+
+class G2DeviceInfo : public DeviceEnumInfoBase, public std::enable_shared_from_this<G2DeviceInfo> {
+public:
+    G2DeviceInfo(const SourcePortInfoList groupedInfoList);
+    ~G2DeviceInfo() noexcept;
+
+    std::shared_ptr<IDevice> createDevice() const override;
+
+    static std::vector<std::shared_ptr<IDeviceEnumInfo>> pickDevices(const SourcePortInfoList infoList);
+    static std::vector<std::shared_ptr<IDeviceEnumInfo>> pickNetDevices(const SourcePortInfoList infoList);
+};
+
+}  // namespace libobsensor
+
diff --git a/src/device/gemini2/G2FrameTimestampCalculator.cpp b/src/device/gemini2/G2FrameTimestampCalculator.cpp
new file mode 100644
index 00000000..69e46a5c
--- /dev/null
+++ b/src/device/gemini2/G2FrameTimestampCalculator.cpp
@@ -0,0 +1,37 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "G2FrameTimestampCalculator.hpp"
+#include "usb/uvc/UvcTypes.hpp"
+#include "frame/Frame.hpp"
+
+namespace libobsensor {
+
+G2VideoFrameTimestampCalculator::G2VideoFrameTimestampCalculator(IDevice *owner, uint64_t deviceTimeFreq, uint64_t frameTimeFreq)
+    : FrameTimestampCalculatorBaseDeviceTime(owner, deviceTimeFreq, frameTimeFreq) {}
+
+void G2VideoFrameTimestampCalculator::calculate(std::shared_ptr<Frame> frame) {
+    auto srcTimestamp = frame->getTimeStampUsec();
+
+    auto metadata   = frame->getMetadata();
+    auto uvcPayload = reinterpret_cast<const StandardUvcFramePayloadHeader *>(metadata);
+    // merge byte1 and byte2 as int16_t as the timestamp offset
+    auto timestampOffsetUs = (static_cast<int16_t>(uvcPayload->scrSourceClock[2] << 8) | uvcPayload->scrSourceClock[1]) * 100;
+    srcTimestamp += timestampOffsetUs;
+
+    auto rstTimestamp = FrameTimestampCalculatorBaseDeviceTime::calculate(srcTimestamp);
+    frame->setTimeStampUsec(rstTimestamp);
+}
+
+G2LVideoFrameTimestampCalculator::G2LVideoFrameTimestampCalculator(IDevice *owner, uint64_t deviceTimeFreq, uint64_t frameTimeFreq)
+    : FrameTimestampCalculatorBaseDeviceTime(owner, deviceTimeFreq, frameTimeFreq) {}
+
+void G2LVideoFrameTimestampCalculator::calculate(std::shared_ptr<Frame> frame) {
+    auto metadata     = frame->getMetadata();
+    auto uvcPayload   = reinterpret_cast<const StandardUvcFramePayloadHeader *>(metadata);
+    auto srcTimestamp = *reinterpret_cast<const uint32_t *>(uvcPayload->scrSourceClock);
+    auto rstTimestamp = FrameTimestampCalculatorBaseDeviceTime::calculate(srcTimestamp);
+    frame->setTimeStampUsec(rstTimestamp);
+}
+
+}  // namespace libobsensor
diff --git a/src/device/gemini2/G2FrameTimestampCalculator.hpp b/src/device/gemini2/G2FrameTimestampCalculator.hpp
new file mode 100644
index 00000000..bda70f17
--- /dev/null
+++ b/src/device/gemini2/G2FrameTimestampCalculator.hpp
@@ -0,0 +1,24 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include "timestamp/FrameTimestampCalculator.hpp"
+
+namespace libobsensor {
+class G2VideoFrameTimestampCalculator : public FrameTimestampCalculatorBaseDeviceTime {
+public:
+    G2VideoFrameTimestampCalculator(IDevice *owner, uint64_t deviceTimeFreq, uint64_t frameTimeFreq);
+    ~G2VideoFrameTimestampCalculator() = default;
+
+    void calculate(std::shared_ptr<Frame> frame) override;
+};
+
+class G2LVideoFrameTimestampCalculator : public FrameTimestampCalculatorBaseDeviceTime {
+public:
+    G2LVideoFrameTimestampCalculator(IDevice *owner, uint64_t deviceTimeFreq, uint64_t frameTimeFreq);
+    ~G2LVideoFrameTimestampCalculator() = default;
+
+    void calculate(std::shared_ptr<Frame> frame) override;
+};
+}  // namespace libobsensor
diff --git a/src/device/gemini2/G2PropertyAccessors.cpp b/src/device/gemini2/G2PropertyAccessors.cpp
new file mode 100644
index 00000000..4b80b866
--- /dev/null
+++ b/src/device/gemini2/G2PropertyAccessors.cpp
@@ -0,0 +1,153 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "G2PropertyAccessors.hpp"
+#include "frameprocessor/FrameProcessor.hpp"
+#include "sensor/video/DisparityBasedSensor.hpp"
+#include "IDeviceComponent.hpp"
+
+namespace libobsensor {
+
+G2Disp2DepthPropertyAccessor::G2Disp2DepthPropertyAccessor(IDevice *owner)
+    : owner_(owner), hwDisparityToDepthEnabled_(true), currentDepthUnitLevel_(OB_PRECISION_1MM) {}
+
+void G2Disp2DepthPropertyAccessor::setPropertyValue(uint32_t propertyId, const OBPropertyValue &value) {
+    switch(propertyId) {
+    case OB_PROP_SDK_DISPARITY_TO_DEPTH_BOOL: {
+        auto processor = owner_->getComponentT<FrameProcessor>(OB_DEV_COMPONENT_DEPTH_FRAME_PROCESSOR);
+        processor->setPropertyValue(propertyId, value);
+    } break;
+    case OB_PROP_DISPARITY_TO_DEPTH_BOOL: {
+        if(value.intValue == 1 && std::find(hwD2DSupportList_.cbegin(), hwD2DSupportList_.cend(), currentDepthUnitLevel_) == hwD2DSupportList_.end()) {
+            OBPropertyValue precisionLevel;
+            precisionLevel.intValue = hwD2DSupportList_.front();
+            setPropertyValue(OB_PROP_DEPTH_PRECISION_LEVEL_INT, precisionLevel);
+        }
+        auto propertyAccessor = owner_->getComponentT<IBasicPropertyAccessor>(OB_DEV_COMPONENT_MAIN_PROPERTY_ACCESSOR);
+        propertyAccessor->setPropertyValue(propertyId, value);
+        hwDisparityToDepthEnabled_ = static_cast<bool>(value.intValue);
+        markOutputDisparityFrame(!hwDisparityToDepthEnabled_);
+    } break;
+    case OB_PROP_DEPTH_PRECISION_LEVEL_INT: {
+        auto            processor = owner_->getComponentT<FrameProcessor>(OB_DEV_COMPONENT_DEPTH_FRAME_PROCESSOR);
+        OBPropertyValue swDisparityEnable;
+        processor->getPropertyValue(OB_PROP_SDK_DISPARITY_TO_DEPTH_BOOL, &swDisparityEnable);
+        if(swDisparityEnable.intValue == 1) {
+            processor->setPropertyValue(propertyId, value);
+        }
+        else {
+            auto commandPort = owner_->getComponentT<IBasicPropertyAccessor>(OB_DEV_COMPONENT_MAIN_PROPERTY_ACCESSOR);
+            commandPort->setPropertyValue(propertyId, value);
+        }
+
+        // update depth unit
+        auto sensor = owner_->getComponentT<DisparityBasedSensor>(OB_DEV_COMPONENT_DEPTH_SENSOR, false);
+        if(sensor) {
+            auto depthUnit = utils::depthPrecisionLevelToUnit(static_cast<OBDepthPrecisionLevel>(value.intValue));
+            sensor->setDepthUnit(depthUnit);
+        }
+
+        currentDepthUnitLevel_ = value.intValue;
+
+    } break;
+
+    default: {
+        auto commandPort = owner_->getComponentT<IBasicPropertyAccessor>(OB_DEV_COMPONENT_MAIN_PROPERTY_ACCESSOR);
+        commandPort->setPropertyValue(propertyId, value);
+    } break;
+    }
+}
+
+void G2Disp2DepthPropertyAccessor::getPropertyValue(uint32_t propertyId, OBPropertyValue *value) {
+    switch(propertyId) {
+    case OB_PROP_SDK_DISPARITY_TO_DEPTH_BOOL: {
+        auto processor = owner_->getComponentT<FrameProcessor>(OB_DEV_COMPONENT_DEPTH_FRAME_PROCESSOR);
+        processor->getPropertyValue(propertyId, value);
+    } break;
+    case OB_PROP_DISPARITY_TO_DEPTH_BOOL: {
+        value->intValue = hwDisparityToDepthEnabled_;
+    } break;
+    case OB_PROP_DEPTH_PRECISION_LEVEL_INT: {
+        auto            processor = owner_->getComponentT<FrameProcessor>(OB_DEV_COMPONENT_DEPTH_FRAME_PROCESSOR);
+        OBPropertyValue swDisparityEnable;
+        processor->getPropertyValue(OB_PROP_SDK_DISPARITY_TO_DEPTH_BOOL, &swDisparityEnable);
+        if(swDisparityEnable.intValue == 1) {
+            processor->getPropertyValue(propertyId, value);
+        }
+        else {
+            auto commandPort = owner_->getComponentT<IBasicPropertyAccessor>(OB_DEV_COMPONENT_MAIN_PROPERTY_ACCESSOR);
+            commandPort->getPropertyValue(propertyId, value);
+        }
+    } break;
+    default: {
+        auto commandPort = owner_->getComponentT<IBasicPropertyAccessor>(OB_DEV_COMPONENT_MAIN_PROPERTY_ACCESSOR);
+        commandPort->getPropertyValue(propertyId, value);
+    } break;
+    }
+}
+
+void G2Disp2DepthPropertyAccessor::getPropertyRange(uint32_t propertyId, OBPropertyRange *range) {
+    switch(propertyId) {
+    case OB_PROP_SDK_DISPARITY_TO_DEPTH_BOOL: {
+        auto processor = owner_->getComponentT<FrameProcessor>(OB_DEV_COMPONENT_DEPTH_FRAME_PROCESSOR);
+        processor->getPropertyRange(propertyId, range);
+    } break;
+    case OB_PROP_DISPARITY_TO_DEPTH_BOOL: {
+        range->min.intValue  = 0;
+        range->max.intValue  = 1;
+        range->step.intValue = 1;
+        range->def.intValue  = 1;
+        range->cur.intValue  = static_cast<int32_t>(hwDisparityToDepthEnabled_);
+    } break;
+    case OB_PROP_DEPTH_PRECISION_LEVEL_INT: {
+        auto            processor = owner_->getComponentT<FrameProcessor>(OB_DEV_COMPONENT_DEPTH_FRAME_PROCESSOR);
+        OBPropertyValue swDisparityEnable;
+        processor->getPropertyValue(OB_PROP_SDK_DISPARITY_TO_DEPTH_BOOL, &swDisparityEnable);
+        if(swDisparityEnable.intValue == 1) {
+            processor->getPropertyRange(propertyId, range);
+        }
+        else {
+            auto commandPort = owner_->getComponentT<IBasicPropertyAccessor>(OB_DEV_COMPONENT_MAIN_PROPERTY_ACCESSOR);
+            commandPort->getPropertyRange(propertyId, range);
+        }
+    } break;
+    default: {
+        auto commandPort = owner_->getComponentT<IBasicPropertyAccessor>(OB_DEV_COMPONENT_MAIN_PROPERTY_ACCESSOR);
+        commandPort->getPropertyRange(propertyId, range);
+    } break;
+    }
+}
+
+void G2Disp2DepthPropertyAccessor::markOutputDisparityFrame(bool enable) {
+    auto sensor = owner_->getComponentT<DisparityBasedSensor>(OB_DEV_COMPONENT_DEPTH_SENSOR, false);
+    if(sensor) {
+        sensor->markOutputDisparityFrame(enable);
+    }
+}
+
+void G2Disp2DepthPropertyAccessor::setStructureData(uint32_t propertyId, const std::vector<uint8_t> &data) {
+    utils::unusedVar(data);
+    if(propertyId == OB_STRUCT_DEPTH_PRECISION_SUPPORT_LIST) {
+        throw invalid_value_exception("OB_STRUCT_DEPTH_PRECISION_SUPPORT_LIST is read-only");
+    }
+    throw invalid_value_exception(utils::string::to_string() << "unsupported property id:" << propertyId);
+}
+
+const std::vector<uint8_t> &G2Disp2DepthPropertyAccessor::getStructureData(uint32_t propertyId) {
+    if(propertyId == OB_STRUCT_DEPTH_PRECISION_SUPPORT_LIST) {
+        if(hwDisparityToDepthEnabled_) {
+
+            static std::vector<uint8_t> hwD2DSupportListBytes(reinterpret_cast<const uint8_t *>(hwD2DSupportList_.data()),
+                                                              reinterpret_cast<const uint8_t *>(hwD2DSupportList_.data()) + hwD2DSupportList_.size() * 2);
+            return hwD2DSupportListBytes;
+        }
+        else {
+            static std::vector<uint8_t> swD2DSupportListBytes(reinterpret_cast<const uint8_t *>(swD2DSupportList_.data()),
+                                                              reinterpret_cast<const uint8_t *>(swD2DSupportList_.data()) + swD2DSupportList_.size() * 2);
+            return swD2DSupportListBytes;
+        }
+    }
+    throw invalid_value_exception(utils::string::to_string() << "unsupported property id:" << propertyId);
+}
+
+}  // namespace libobsensor
diff --git a/src/device/gemini2/G2PropertyAccessors.hpp b/src/device/gemini2/G2PropertyAccessors.hpp
new file mode 100644
index 00000000..f8139cfe
--- /dev/null
+++ b/src/device/gemini2/G2PropertyAccessors.hpp
@@ -0,0 +1,33 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include "IProperty.hpp"
+#include "IDevice.hpp"
+
+namespace libobsensor {
+class G2Disp2DepthPropertyAccessor : public IBasicPropertyAccessor, public IStructureDataAccessor {
+public:
+    explicit G2Disp2DepthPropertyAccessor(IDevice *owner);
+    virtual ~G2Disp2DepthPropertyAccessor() noexcept = default;
+
+    void setPropertyValue(uint32_t propertyId, const OBPropertyValue &value) override;
+    void getPropertyValue(uint32_t propertyId, OBPropertyValue *value) override;
+    void getPropertyRange(uint32_t propertyId, OBPropertyRange *range) override;
+
+    void                        setStructureData(uint32_t propertyId, const std::vector<uint8_t> &data) override;
+    const std::vector<uint8_t> &getStructureData(uint32_t propertyId) override;
+
+private:
+    void markOutputDisparityFrame(bool enable);
+
+private:
+    IDevice *owner_;
+
+    bool hwDisparityToDepthEnabled_;
+    int32_t                     currentDepthUnitLevel_;
+    const std::vector<uint16_t> hwD2DSupportList_ = { OB_PRECISION_0MM8, OB_PRECISION_0MM4, OB_PRECISION_0MM2 };
+    const std::vector<uint16_t> swD2DSupportList_ = { OB_PRECISION_1MM, OB_PRECISION_0MM8, OB_PRECISION_0MM4, OB_PRECISION_0MM2, OB_PRECISION_0MM1 };
+};
+
+}  // namespace libobsensor
diff --git a/src/device/gemini2/G2StreamProfileFilter.cpp b/src/device/gemini2/G2StreamProfileFilter.cpp
new file mode 100644
index 00000000..79eddd83
--- /dev/null
+++ b/src/device/gemini2/G2StreamProfileFilter.cpp
@@ -0,0 +1,71 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "G2StreamProfileFilter.hpp"
+
+#include "utils/Utils.hpp"
+#include "stream/StreamProfile.hpp"
+#include "exception/ObException.hpp"
+#include "property/InternalProperty.hpp"
+
+namespace libobsensor {
+G2StreamProfileFilter::G2StreamProfileFilter(IDevice *owner) : DeviceComponentBase(owner) {
+    fetchEffectiveStreamProfiles();
+}
+
+static bool isMatch(OBSensorType sensorType, std::shared_ptr<const VideoStreamProfile> videoProfile, OBEffectiveStreamProfile effProfile) {
+    bool isSensorTypeEqual = sensorType == effProfile.sensorType;
+
+    // Compatibility processing, normal mode has IR, but no LeftIR, RightIR; calibration mode has no IR, but has LeftIR, RightIR
+    // IR and LeftIR both use the IR channel, so they are the same. RightIR uses the Depth channel, so RightIR must match accurately
+    if(!isSensorTypeEqual && sensorType != OB_SENSOR_IR_RIGHT && effProfile.sensorType != OB_SENSOR_IR_RIGHT) {
+        isSensorTypeEqual = isIRSensor(sensorType) && isIRSensor(effProfile.sensorType);
+    }
+
+    return isSensorTypeEqual && (videoProfile->getFormat() == effProfile.format) && (videoProfile->getFps() <= effProfile.maxFps)
+           && (videoProfile->getWidth() == effProfile.width) && (videoProfile->getHeight() == effProfile.height);
+}
+
+StreamProfileList G2StreamProfileFilter::filter(const StreamProfileList &profiles) const {
+    StreamProfileList filteredProfiles;
+
+    for(const auto &profile: profiles) {
+        if(!profile->is<VideoStreamProfile>()) {
+            filteredProfiles.push_back(profile);
+            continue;
+        }
+        auto videoProfile = profile->as<VideoStreamProfile>();
+        auto streamType   = profile->getType();
+        auto sensorType   = utils::mapStreamTypeToSensorType(streamType);
+
+        for(auto &effProfile: effectiveStreamProfiles_) {
+            if(isMatch(sensorType, videoProfile, effProfile)) {
+                filteredProfiles.push_back(profile);
+                continue;
+            }
+        }
+    }
+
+    return filteredProfiles;
+}
+void G2StreamProfileFilter::fetchEffectiveStreamProfiles() {
+    auto owner      = getOwner();
+    auto propServer = owner->getPropertyServer();
+
+    std::vector<OBEffectiveStreamProfile> profiles;
+    profiles                 = propServer->getStructureDataListProtoV1_1_T<OBEffectiveStreamProfile, 0>(OB_RAW_DATA_EFFECTIVE_VIDEO_STREAM_PROFILE_LIST);
+    effectiveStreamProfiles_ = profiles;
+    for(auto &profile: profiles) {
+        if(profile.sensorType == OB_SENSOR_COLOR && profile.format == OB_FORMAT_MJPG) {
+            auto nerProfile   = profile;
+            nerProfile.format = OB_FORMAT_RGB;
+            effectiveStreamProfiles_.push_back(nerProfile);
+            nerProfile.format = OB_FORMAT_BGR;
+            effectiveStreamProfiles_.push_back(nerProfile);
+            nerProfile.format = OB_FORMAT_BGRA;
+            effectiveStreamProfiles_.push_back(nerProfile);
+        }
+    }
+}
+
+}  // namespace libobsensor
diff --git a/src/device/gemini2/G2StreamProfileFilter.hpp b/src/device/gemini2/G2StreamProfileFilter.hpp
new file mode 100644
index 00000000..dbfaee05
--- /dev/null
+++ b/src/device/gemini2/G2StreamProfileFilter.hpp
@@ -0,0 +1,24 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include "DeviceComponentBase.hpp"
+#include "IStreamProfile.hpp"
+#include "InternalTypes.hpp"
+
+namespace libobsensor {
+class G2StreamProfileFilter : public DeviceComponentBase, public IStreamProfileFilter {
+public:
+    G2StreamProfileFilter(IDevice *owner);
+    virtual ~G2StreamProfileFilter() noexcept = default;
+
+    StreamProfileList filter(const StreamProfileList &profiles) const override;
+
+private:
+    void fetchEffectiveStreamProfiles();
+
+private:
+    std::vector<OBEffectiveStreamProfile> effectiveStreamProfiles_;
+};
+}  // namespace libobsensor
diff --git a/src/device/gemini2/G2XLDevice.cpp b/src/device/gemini2/G2XLDevice.cpp
new file mode 100644
index 00000000..1a643aa9
--- /dev/null
+++ b/src/device/gemini2/G2XLDevice.cpp
@@ -0,0 +1,1141 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "G2XLDevice.hpp"
+
+#include "DevicePids.hpp"
+#include "InternalTypes.hpp"
+
+#include "Platform.hpp"
+#include "utils/Utils.hpp"
+#include "environment/EnvConfig.hpp"
+#include "usb/uvc/UvcDevicePort.hpp"
+#include "stream/StreamProfileFactory.hpp"
+
+#include "FilterFactory.hpp"
+#include "publicfilters/FormatConverterProcess.hpp"
+#include "publicfilters/IMUCorrector.hpp"
+
+#include "sensor/video/VideoSensor.hpp"
+#include "sensor/video/DisparityBasedSensor.hpp"
+#include "sensor/imu/ImuStreamer.hpp"
+#include "sensor/imu/AccelSensor.hpp"
+#include "sensor/imu/GyroSensor.hpp"
+#include "timestamp/GlobalTimestampFitter.hpp"
+#include "timestamp/DeviceClockSynchronizer.hpp"
+#include "property/VendorPropertyAccessor.hpp"
+#include "property/UvcPropertyAccessor.hpp"
+#include "property/PropertyServer.hpp"
+#include "property/CommonPropertyAccessors.hpp"
+#include "property/FilterPropertyAccessors.hpp"
+#include "property/PrivateFilterPropertyAccessors.hpp"
+#include "monitor/DeviceMonitor.hpp"
+#include "syncconfig/DeviceSyncConfigurator.hpp"
+
+#include "G2AlgParamManager.hpp"
+#include "G2StreamProfileFilter.hpp"
+#include "G2PropertyAccessors.hpp"
+#include "G2DepthWorkModeManager.hpp"
+#include "G2FrameTimestampCalculator.hpp"
+
+#include <algorithm>
+
+#if defined(BUILD_NET_PAL)
+#include "ethernet/RTSPStreamPort.hpp"
+#endif
+
+namespace libobsensor {
+
+static const uint8_t INTERFACE_COLOR    = 0;
+static const uint8_t INTERFACE_LEFT_IR  = 4;
+static const uint8_t INTERFACE_DEPTH    = 2;
+static const uint8_t INTERFACE_RIGHT_IR = 6;
+
+G2XLDeviceBase::G2XLDeviceBase(const std::shared_ptr<const IDeviceEnumInfo> &info) : DeviceBase(info) {}
+G2XLDeviceBase::~G2XLDeviceBase() noexcept {}
+
+void G2XLDeviceBase::init() {
+    fetchDeviceInfo();
+    fetchExtensionInfo();
+
+    auto globalTimestampFilter = std::make_shared<GlobalTimestampFitter>(this);
+    registerComponent(OB_DEV_COMPONENT_GLOBAL_TIMESTAMP_FILTER, globalTimestampFilter);
+
+    auto algParamManager = std::make_shared<G2AlgParamManager>(this);
+    registerComponent(OB_DEV_COMPONENT_ALG_PARAM_MANAGER, algParamManager);
+
+    auto depthWorkModeManager = std::make_shared<G2DepthWorkModeManager>(this);
+    registerComponent(OB_DEV_COMPONENT_DEPTH_WORK_MODE_MANAGER, depthWorkModeManager);
+
+    static const std::vector<OBMultiDeviceSyncMode> supportedSyncModes = {
+        OB_MULTI_DEVICE_SYNC_MODE_FREE_RUN,         OB_MULTI_DEVICE_SYNC_MODE_STANDALONE,          OB_MULTI_DEVICE_SYNC_MODE_PRIMARY,
+        OB_MULTI_DEVICE_SYNC_MODE_SECONDARY_SYNCED, OB_MULTI_DEVICE_SYNC_MODE_SOFTWARE_TRIGGERING, OB_MULTI_DEVICE_SYNC_MODE_HARDWARE_TRIGGERING
+    };
+    auto deviceSyncConfigurator = std::make_shared<DeviceSyncConfiguratorOldProtocol>(this, supportedSyncModes);
+    registerComponent(OB_DEV_COMPONENT_DEVICE_SYNC_CONFIGURATOR, deviceSyncConfigurator);
+    static const std::map<OBMultiDeviceSyncMode, OBSyncMode> syncModeNewToOldMap = {
+        { OB_MULTI_DEVICE_SYNC_MODE_FREE_RUN, OB_SYNC_MODE_CLOSE },  //
+        { OB_MULTI_DEVICE_SYNC_MODE_STANDALONE, OB_SYNC_MODE_STANDALONE },
+        { OB_MULTI_DEVICE_SYNC_MODE_PRIMARY, OB_SYNC_MODE_PRIMARY_MCU_TRIGGER },
+        { OB_MULTI_DEVICE_SYNC_MODE_SECONDARY, OB_SYNC_MODE_PRIMARY_IR_TRIGGER },
+        { OB_MULTI_DEVICE_SYNC_MODE_SECONDARY_SYNCED, OB_SYNC_MODE_PRIMARY_IR_TRIGGER },
+        { OB_MULTI_DEVICE_SYNC_MODE_SOFTWARE_TRIGGERING, OB_SYNC_MODE_PRIMARY },
+        { OB_MULTI_DEVICE_SYNC_MODE_HARDWARE_TRIGGERING, OB_SYNC_MODE_SECONDARY },
+    };
+    static const std::map<OBSyncMode, OBMultiDeviceSyncMode> syncModeOldToNewMap = {
+        { OB_SYNC_MODE_CLOSE, OB_MULTI_DEVICE_SYNC_MODE_FREE_RUN },  //
+        { OB_SYNC_MODE_STANDALONE, OB_MULTI_DEVICE_SYNC_MODE_STANDALONE },
+        { OB_SYNC_MODE_PRIMARY_MCU_TRIGGER, OB_MULTI_DEVICE_SYNC_MODE_PRIMARY },
+        { OB_SYNC_MODE_PRIMARY_IR_TRIGGER, OB_MULTI_DEVICE_SYNC_MODE_SECONDARY_SYNCED },
+        { OB_SYNC_MODE_PRIMARY, OB_MULTI_DEVICE_SYNC_MODE_SOFTWARE_TRIGGERING },
+        { OB_SYNC_MODE_SECONDARY, OB_MULTI_DEVICE_SYNC_MODE_HARDWARE_TRIGGERING },
+    };
+    deviceSyncConfigurator->updateModeAliasMap(syncModeOldToNewMap, syncModeNewToOldMap);
+
+    registerComponent(OB_DEV_COMPONENT_DEVICE_CLOCK_SYNCHRONIZER, [this] {  //
+        return std::make_shared<DeviceClockSynchronizer>(this, deviceTimeFreq_, deviceTimeFreq_);
+    });
+}
+
+std::vector<std::shared_ptr<IFilter>> G2XLDeviceBase::createRecommendedPostProcessingFilters(OBSensorType type) {
+    if(type != OB_SENSOR_DEPTH) {
+        return {};
+    }
+
+    // create depth frame processor first to activate private filters
+    getComponentT<FrameProcessor>(OB_DEV_COMPONENT_DEPTH_FRAME_PROCESSOR, false);
+
+    auto                                  filterFactory = FilterFactory::getInstance();
+    std::vector<std::shared_ptr<IFilter>> depthFilterList;
+
+    if(filterFactory->isFilterCreatorExists("EdgeNoiseRemovalFilter")) {
+        auto enrFilter = filterFactory->createFilter("EdgeNoiseRemovalFilter");
+        enrFilter->enable(false);
+        // todo: set default values
+        depthFilterList.push_back(enrFilter);
+    }
+
+    if(filterFactory->isFilterCreatorExists("SpatialAdvancedFilter")) {
+        auto spatFilter = filterFactory->createFilter("SpatialAdvancedFilter");
+        spatFilter->enable(false);
+        // magnitude, alpha, disp_diff, radius
+        std::vector<std::string> params = { "1", "0.5", "64", "1" };
+        spatFilter->updateConfig(params);
+        depthFilterList.push_back(spatFilter);
+    }
+
+    if(filterFactory->isFilterCreatorExists("TemporalFilter")) {
+        auto tempFilter = filterFactory->createFilter("TemporalFilter");
+        tempFilter->enable(false);
+        // diff_scale, weight
+        std::vector<std::string> params = { "0.1", "0.4" };
+        tempFilter->updateConfig(params);
+        depthFilterList.push_back(tempFilter);
+    }
+
+    if(filterFactory->isFilterCreatorExists("HoleFillingFilter")) {
+        auto hfFilter = filterFactory->createFilter("HoleFillingFilter");
+        hfFilter->enable(false);
+        depthFilterList.push_back(hfFilter);
+    }
+
+    if(filterFactory->isFilterCreatorExists("DisparityTransform")) {
+        auto dtFilter = filterFactory->createFilter("DisparityTransform");
+        dtFilter->enable(true);
+        depthFilterList.push_back(dtFilter);
+    }
+
+    if(filterFactory->isFilterCreatorExists("ThresholdFilter")) {
+        auto ThresholdFilter = filterFactory->createFilter("ThresholdFilter");
+        depthFilterList.push_back(ThresholdFilter);
+    }
+
+    return depthFilterList;
+}
+
+void G2XLDeviceBase::initSensorStreamProfile(std::shared_ptr<ISensor> sensor) {
+    auto streamProfileFilter = getComponentT<IStreamProfileFilter>(OB_DEV_COMPONENT_STREAM_PROFILE_FILTER);
+    sensor->setStreamProfileFilter(streamProfileFilter.get());
+
+    auto        depthWorkModeManager = getComponentT<IDepthWorkModeManager>(OB_DEV_COMPONENT_DEPTH_WORK_MODE_MANAGER);
+    auto        workMode             = depthWorkModeManager->getCurrentDepthWorkMode();
+    std::string workModeName         = workMode.name;
+    auto        sensorType           = sensor->getSensorType();
+    auto        streamProfile        = StreamProfileFactory::getDefaultStreamProfileFromEnvConfig(deviceInfo_->name_, sensorType, workModeName);
+    if(!streamProfile) {
+        // if not found, try to get default stream profile without work mode
+        streamProfile = StreamProfileFactory::getDefaultStreamProfileFromEnvConfig(deviceInfo_->name_, sensorType);
+    }
+    if(streamProfile) {
+        sensor->updateDefaultStreamProfile(streamProfile);
+    }
+
+    // bind params: extrinsics, intrinsics, etc.
+    auto profiles = sensor->getStreamProfileList();
+    {
+        auto algParamManager = getComponentT<IAlgParamManager>(OB_DEV_COMPONENT_ALG_PARAM_MANAGER);
+        algParamManager->bindStreamProfileParams(profiles);
+    }
+
+    LOG_INFO("Sensor {} created! Found {} stream profiles.", sensorType, profiles.size());
+    for(auto &profile: profiles) {
+        LOG_INFO(" - {}", profile);
+    }
+}
+
+G2XLUSBDevice::G2XLUSBDevice(const std::shared_ptr<const IDeviceEnumInfo> &info) : G2XLDeviceBase(info) {
+    init();
+}
+
+G2XLUSBDevice::~G2XLUSBDevice() noexcept {}
+
+void G2XLUSBDevice::init() {
+    initSensorList();
+    initProperties();
+    G2XLDeviceBase::init();
+}
+
+void G2XLUSBDevice::initSensorList() {
+    registerComponent(OB_DEV_COMPONENT_FRAME_PROCESSOR_FACTORY, [this]() {
+        std::shared_ptr<FrameProcessorFactory> factory;
+        TRY_EXECUTE({ factory = std::make_shared<FrameProcessorFactory>(this); })
+        return factory;
+    });
+
+    registerComponent(OB_DEV_COMPONENT_STREAM_PROFILE_FILTER, [this]() { return std::make_shared<G2StreamProfileFilter>(this); });
+
+    auto        platform           = Platform::getInstance();
+    const auto &sourcePortInfoList = enumInfo_->getSourcePortInfoList();
+    auto depthPortInfoIter = std::find_if(sourcePortInfoList.begin(), sourcePortInfoList.end(), [](const std::shared_ptr<const SourcePortInfo> &portInfo) {
+        return portInfo->portType == SOURCE_PORT_USB_UVC && std::dynamic_pointer_cast<const USBSourcePortInfo>(portInfo)->infIndex == INTERFACE_DEPTH;
+    });
+
+    if(depthPortInfoIter != sourcePortInfoList.end()) {
+        auto depthPortInfo = *depthPortInfoIter;
+        registerComponent(
+            OB_DEV_COMPONENT_DEPTH_SENSOR,
+            [this, depthPortInfo]() {
+                auto platform = Platform::getInstance();
+                auto port     = platform->getSourcePort(depthPortInfo);
+                auto sensor   = std::make_shared<DisparityBasedSensor>(this, OB_SENSOR_DEPTH, port);
+
+                std::vector<FormatFilterConfig> formatFilterConfigs = {
+                    { FormatFilterPolicy::REPLACE, OB_FORMAT_MJPG, OB_FORMAT_RVL, nullptr },
+                };
+                sensor->updateFormatFilterConfig(formatFilterConfigs);
+
+                auto frameTimestampCalculator = std::make_shared<G2VideoFrameTimestampCalculator>(this, deviceTimeFreq_, frameTimeFreq_);
+                sensor->setFrameTimestampCalculator(frameTimestampCalculator);
+
+                auto globalFrameTimestampCalculator = std::make_shared<GlobalTimestampCalculator>(this, deviceTimeFreq_, frameTimeFreq_);
+                sensor->setGlobalTimestampCalculator(globalFrameTimestampCalculator);
+
+                auto frameProcessor = getComponentT<FrameProcessor>(OB_DEV_COMPONENT_DEPTH_FRAME_PROCESSOR, false);
+                if(frameProcessor) {
+                    sensor->setFrameProcessor(frameProcessor.get());
+                }
+
+                auto propServer = getPropertyServer();
+
+                propServer->setPropertyValueT<bool>(OB_PROP_DISPARITY_TO_DEPTH_BOOL, true);
+                propServer->setPropertyValueT<bool>(OB_PROP_SDK_DISPARITY_TO_DEPTH_BOOL, false);
+                sensor->markOutputDisparityFrame(false);
+
+                propServer->setPropertyValueT(OB_PROP_DEPTH_PRECISION_LEVEL_INT, OB_PRECISION_1MM);
+                sensor->setDepthUnit(1.0f);
+
+                initSensorStreamProfile(sensor);
+
+                return sensor;
+            },
+            true);
+
+        registerSensorPortInfo(OB_SENSOR_DEPTH, depthPortInfo);
+
+        registerComponent(OB_DEV_COMPONENT_DEPTH_FRAME_PROCESSOR, [this]() {
+            auto factory        = getComponentT<FrameProcessorFactory>(OB_DEV_COMPONENT_FRAME_PROCESSOR_FACTORY);
+            auto frameProcessor = factory->createFrameProcessor(OB_SENSOR_DEPTH);
+            return frameProcessor;
+        });
+
+        // the main property accessor is using the depth port(uvc xu)
+        registerComponent(OB_DEV_COMPONENT_MAIN_PROPERTY_ACCESSOR, [this, depthPortInfo]() {
+            auto platform = Platform::getInstance();
+            auto port     = platform->getSourcePort(depthPortInfo);
+            auto accessor = std::make_shared<VendorPropertyAccessor>(this, port);
+            return accessor;
+        });
+
+        // The device monitor is using the depth port(uvc xu)
+        registerComponent(OB_DEV_COMPONENT_DEVICE_MONITOR, [this, depthPortInfo]() {
+            auto platform   = Platform::getInstance();
+            auto port       = platform->getSourcePort(depthPortInfo);
+            auto devMonitor = std::make_shared<DeviceMonitor>(this, port);
+            return devMonitor;
+        });
+    }
+
+    auto leftIrPortInfoIter = std::find_if(sourcePortInfoList.begin(), sourcePortInfoList.end(), [](const std::shared_ptr<const SourcePortInfo> &portInfo) {
+        return portInfo->portType == SOURCE_PORT_USB_UVC && std::dynamic_pointer_cast<const USBSourcePortInfo>(portInfo)->infIndex == INTERFACE_LEFT_IR;
+    });
+
+    if(leftIrPortInfoIter != sourcePortInfoList.end()) {
+        auto leftIrPortInfo = *leftIrPortInfoIter;
+        registerComponent(
+            OB_DEV_COMPONENT_LEFT_IR_SENSOR,
+            [this, leftIrPortInfo]() {
+                auto platform = Platform::getInstance();
+                auto port     = platform->getSourcePort(leftIrPortInfo);
+                auto sensor   = std::make_shared<VideoSensor>(this, OB_SENSOR_IR_LEFT, port);
+
+                auto frameTimestampCalculator = std::make_shared<G2VideoFrameTimestampCalculator>(this, deviceTimeFreq_, frameTimeFreq_);
+                sensor->setFrameTimestampCalculator(frameTimestampCalculator);
+
+                auto globalFrameTimestampCalculator = std::make_shared<GlobalTimestampCalculator>(this, deviceTimeFreq_, frameTimeFreq_);
+                sensor->setGlobalTimestampCalculator(globalFrameTimestampCalculator);
+
+                auto frameProcessor = getComponentT<FrameProcessor>(OB_DEV_COMPONENT_LEFT_IR_FRAME_PROCESSOR, false);
+                if(frameProcessor) {
+                    sensor->setFrameProcessor(frameProcessor.get());
+                }
+
+                initSensorStreamProfile(sensor);
+
+                return sensor;
+            },
+            true);
+        registerSensorPortInfo(OB_SENSOR_IR_LEFT, leftIrPortInfo);
+
+        registerComponent(OB_DEV_COMPONENT_LEFT_IR_FRAME_PROCESSOR, [this]() {
+            auto factory        = getComponentT<FrameProcessorFactory>(OB_DEV_COMPONENT_FRAME_PROCESSOR_FACTORY);
+            auto frameProcessor = factory->createFrameProcessor(OB_SENSOR_IR_LEFT);
+            return frameProcessor;
+        });
+    }
+
+    auto rightIrPortInfoIter = std::find_if(sourcePortInfoList.begin(), sourcePortInfoList.end(), [](const std::shared_ptr<const SourcePortInfo> &portInfo) {
+        return portInfo->portType == SOURCE_PORT_USB_UVC && std::dynamic_pointer_cast<const USBSourcePortInfo>(portInfo)->infIndex == INTERFACE_RIGHT_IR;
+    });
+    if(rightIrPortInfoIter != sourcePortInfoList.end()) {
+        auto rightIrPortInfo = *rightIrPortInfoIter;
+        registerComponent(
+            OB_DEV_COMPONENT_RIGHT_IR_SENSOR,
+            [this, rightIrPortInfo]() {
+                auto platform = Platform::getInstance();
+                auto port     = platform->getSourcePort(rightIrPortInfo);
+                auto sensor   = std::make_shared<VideoSensor>(this, OB_SENSOR_IR_RIGHT, port);
+
+                auto frameTimestampCalculator = std::make_shared<G2VideoFrameTimestampCalculator>(this, deviceTimeFreq_, frameTimeFreq_);
+                sensor->setFrameTimestampCalculator(frameTimestampCalculator);
+
+                auto globalFrameTimestampCalculator = std::make_shared<GlobalTimestampCalculator>(this, deviceTimeFreq_, frameTimeFreq_);
+                sensor->setGlobalTimestampCalculator(globalFrameTimestampCalculator);
+
+                auto frameProcessor = getComponentT<FrameProcessor>(OB_DEV_COMPONENT_RIGHT_IR_FRAME_PROCESSOR, false);
+                if(frameProcessor) {
+                    sensor->setFrameProcessor(frameProcessor.get());
+                }
+
+                initSensorStreamProfile(sensor);
+                return sensor;
+            },
+            true);
+        registerSensorPortInfo(OB_SENSOR_IR_RIGHT, rightIrPortInfo);
+        registerComponent(OB_DEV_COMPONENT_RIGHT_IR_FRAME_PROCESSOR, [this]() {
+            auto factory        = getComponentT<FrameProcessorFactory>(OB_DEV_COMPONENT_FRAME_PROCESSOR_FACTORY);
+            auto frameProcessor = factory->createFrameProcessor(OB_SENSOR_IR_RIGHT);
+            return frameProcessor;
+        });
+    }
+
+    auto colorPortInfoIter = std::find_if(sourcePortInfoList.begin(), sourcePortInfoList.end(), [](const std::shared_ptr<const SourcePortInfo> &portInfo) {
+        return portInfo->portType == SOURCE_PORT_USB_UVC && std::dynamic_pointer_cast<const USBSourcePortInfo>(portInfo)->infIndex == INTERFACE_COLOR;
+    });
+
+    if(colorPortInfoIter != sourcePortInfoList.end()) {
+        auto colorPortInfo = *colorPortInfoIter;
+        registerComponent(
+            OB_DEV_COMPONENT_COLOR_SENSOR,
+            [this, colorPortInfo]() {
+                auto platform = Platform::getInstance();
+                auto port     = platform->getSourcePort(colorPortInfo);
+                auto sensor   = std::make_shared<VideoSensor>(this, OB_SENSOR_COLOR, port);
+
+                std::vector<FormatFilterConfig> formatFilterConfigs = {
+                    { FormatFilterPolicy::REMOVE, OB_FORMAT_NV12, OB_FORMAT_ANY, nullptr },
+                };
+
+                auto formatConverter = getSensorFrameFilter("FormatConverter", OB_SENSOR_COLOR, false);
+                if(formatConverter) {
+#ifdef WIN32
+                    formatFilterConfigs.push_back({ FormatFilterPolicy::ADD, OB_FORMAT_BGR, OB_FORMAT_RGB, formatConverter });
+#else
+                    formatFilterConfigs.push_back({ FormatFilterPolicy::ADD, OB_FORMAT_MJPG, OB_FORMAT_RGB, formatConverter });
+                    formatFilterConfigs.push_back({ FormatFilterPolicy::ADD, OB_FORMAT_MJPG, OB_FORMAT_BGR, formatConverter });
+                    formatFilterConfigs.push_back({ FormatFilterPolicy::ADD, OB_FORMAT_MJPG, OB_FORMAT_BGRA, formatConverter });
+#endif
+                }
+                sensor->updateFormatFilterConfig(formatFilterConfigs);
+
+                auto frameTimestampCalculator = std::make_shared<G2VideoFrameTimestampCalculator>(this, deviceTimeFreq_, frameTimeFreq_);
+                sensor->setFrameTimestampCalculator(frameTimestampCalculator);
+
+                auto globalFrameTimestampCalculator = std::make_shared<GlobalTimestampCalculator>(this, deviceTimeFreq_, frameTimeFreq_);
+                sensor->setGlobalTimestampCalculator(globalFrameTimestampCalculator);
+
+                auto frameProcessor = getComponentT<FrameProcessor>(OB_DEV_COMPONENT_COLOR_FRAME_PROCESSOR, false);
+                if(frameProcessor) {
+                    sensor->setFrameProcessor(frameProcessor.get());
+                }
+
+                initSensorStreamProfile(sensor);
+
+                return sensor;
+            },
+            true);
+        registerSensorPortInfo(OB_SENSOR_COLOR, colorPortInfo);
+
+        registerComponent(OB_DEV_COMPONENT_COLOR_FRAME_PROCESSOR, [this]() {
+            auto factory        = getComponentT<FrameProcessorFactory>(OB_DEV_COMPONENT_FRAME_PROCESSOR_FACTORY);
+            auto frameProcessor = factory->createFrameProcessor(OB_SENSOR_COLOR);
+            return frameProcessor;
+        });
+    }
+
+    auto imuPortInfoIter = std::find_if(sourcePortInfoList.begin(), sourcePortInfoList.end(), [](const std::shared_ptr<const SourcePortInfo> &portInfo) {
+        return portInfo->portType == SOURCE_PORT_USB_HID;  //
+    });
+
+    if(imuPortInfoIter != sourcePortInfoList.end()) {
+        auto imuPortInfo = *imuPortInfoIter;
+
+        registerComponent(OB_DEV_COMPONENT_IMU_STREAMER, [this, imuPortInfo]() {
+            // the gyro and accel are both on the same port and share the same filter
+            auto platform           = Platform::getInstance();
+            auto port               = platform->getSourcePort(imuPortInfo);
+            auto imuCorrectorFilter = getSensorFrameFilter("IMUCorrector", OB_SENSOR_ACCEL, true);
+
+            imuCorrectorFilter->enable(false);
+            auto dataStreamPort = std::dynamic_pointer_cast<IDataStreamPort>(port);
+            auto imuStreamer    = std::make_shared<ImuStreamer>(this, dataStreamPort, imuCorrectorFilter);
+            return imuStreamer;
+        });
+
+        registerComponent(
+            OB_DEV_COMPONENT_ACCEL_SENSOR,
+            [this, imuPortInfo]() {
+                auto platform             = Platform::getInstance();
+                auto port                 = platform->getSourcePort(imuPortInfo);
+                auto imuStreamer          = getComponentT<ImuStreamer>(OB_DEV_COMPONENT_IMU_STREAMER);
+                auto imuStreamerSharedPtr = imuStreamer.get();
+                auto sensor               = std::make_shared<AccelSensor>(this, port, imuStreamerSharedPtr);
+
+                auto globalFrameTimestampCalculator = std::make_shared<GlobalTimestampCalculator>(this, deviceTimeFreq_, frameTimeFreq_);
+                sensor->setGlobalTimestampCalculator(globalFrameTimestampCalculator);
+
+                initSensorStreamProfile(sensor);
+
+                return sensor;
+            },
+            true);
+        registerSensorPortInfo(OB_SENSOR_ACCEL, imuPortInfo);
+
+        registerComponent(
+            OB_DEV_COMPONENT_GYRO_SENSOR,
+            [this, imuPortInfo]() {
+                auto platform             = Platform::getInstance();
+                auto port                 = platform->getSourcePort(imuPortInfo);
+                auto imuStreamer          = getComponentT<ImuStreamer>(OB_DEV_COMPONENT_IMU_STREAMER);
+                auto imuStreamerSharedPtr = imuStreamer.get();
+                auto sensor               = std::make_shared<GyroSensor>(this, port, imuStreamerSharedPtr);
+
+                auto globalFrameTimestampCalculator = std::make_shared<GlobalTimestampCalculator>(this, deviceTimeFreq_, frameTimeFreq_);
+                sensor->setGlobalTimestampCalculator(globalFrameTimestampCalculator);
+
+                initSensorStreamProfile(sensor);
+
+                return sensor;
+            },
+            true);
+        registerSensorPortInfo(OB_SENSOR_GYRO, imuPortInfo);
+    }
+}
+
+void G2XLUSBDevice::initProperties() {
+    auto propertyServer = std::make_shared<PropertyServer>(this);
+
+    auto d2dPropertyAccessor = std::make_shared<G2Disp2DepthPropertyAccessor>(this);
+    propertyServer->registerProperty(OB_PROP_DISPARITY_TO_DEPTH_BOOL, "rw", "rw", d2dPropertyAccessor);      // hw
+    propertyServer->registerProperty(OB_PROP_SDK_DISPARITY_TO_DEPTH_BOOL, "rw", "rw", d2dPropertyAccessor);  // sw
+    propertyServer->registerProperty(OB_PROP_DEPTH_PRECISION_LEVEL_INT, "rw", "rw", d2dPropertyAccessor);
+    propertyServer->registerProperty(OB_STRUCT_DEPTH_PRECISION_SUPPORT_LIST, "r", "r", d2dPropertyAccessor);
+
+    auto privatePropertyAccessor = std::make_shared<PrivateFilterPropertyAccessor>(this);
+    propertyServer->registerProperty(OB_PROP_DEPTH_SOFT_FILTER_BOOL, "rw", "rw", privatePropertyAccessor);
+    propertyServer->registerProperty(OB_PROP_DEPTH_MAX_DIFF_INT, "rw", "rw", privatePropertyAccessor);
+    propertyServer->registerProperty(OB_PROP_DEPTH_MAX_SPECKLE_SIZE_INT, "rw", "rw", privatePropertyAccessor);
+
+    auto sensors = getSensorTypeList();
+    for(auto &sensor: sensors) {
+        auto  platform       = Platform::getInstance();
+        auto &sourcePortInfo = getSensorPortInfo(sensor);
+        if(sensor == OB_SENSOR_COLOR) {
+            auto uvcPropertyAccessor = std::make_shared<LazyPropertyAccessor>([&sourcePortInfo]() {
+                auto platform = Platform::getInstance();
+                auto port     = platform->getSourcePort(sourcePortInfo);
+                auto accessor = std::make_shared<UvcPropertyAccessor>(port);
+                return accessor;
+            });
+
+            propertyServer->registerProperty(OB_PROP_COLOR_AUTO_EXPOSURE_BOOL, "rw", "rw", uvcPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_COLOR_GAIN_INT, "rw", "rw", uvcPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_COLOR_SATURATION_INT, "rw", "rw", uvcPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_COLOR_AUTO_WHITE_BALANCE_BOOL, "rw", "rw", uvcPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_COLOR_WHITE_BALANCE_INT, "rw", "rw", uvcPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_COLOR_BRIGHTNESS_INT, "rw", "rw", uvcPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_COLOR_SHARPNESS_INT, "rw", "rw", uvcPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_COLOR_CONTRAST_INT, "rw", "rw", uvcPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_COLOR_POWER_LINE_FREQUENCY_INT, "rw", "rw", uvcPropertyAccessor);
+        }
+        else if(sensor == OB_SENSOR_IR_LEFT) {
+            auto uvcPropertyAccessor = std::make_shared<LazyPropertyAccessor>([sourcePortInfo]() {
+                auto platform = Platform::getInstance();
+                auto port     = platform->getSourcePort(sourcePortInfo);
+                auto accessor = std::make_shared<UvcPropertyAccessor>(port);
+                return accessor;
+            });
+            propertyServer->registerProperty(OB_PROP_IR_GAIN_INT, "rw", "rw", uvcPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_IR_AUTO_EXPOSURE_BOOL, "rw", "rw", uvcPropertyAccessor);
+        }
+        else if(sensor == OB_SENSOR_DEPTH) {
+            auto uvcPropertyAccessor = std::make_shared<LazyPropertyAccessor>([&sourcePortInfo]() {
+                auto platform = Platform::getInstance();
+                auto port     = platform->getSourcePort(sourcePortInfo);
+                auto accessor = std::make_shared<UvcPropertyAccessor>(port);
+                return accessor;
+            });
+
+            auto vendorPropertyAccessor = std::make_shared<LazySuperPropertyAccessor>([this, &sourcePortInfo]() {
+                auto platform               = Platform::getInstance();
+                auto port                   = platform->getSourcePort(sourcePortInfo);
+                auto vendorPropertyAccessor = std::make_shared<VendorPropertyAccessor>(this, port);
+                return vendorPropertyAccessor;
+            });
+
+            propertyServer->registerProperty(OB_PROP_IR_EXPOSURE_INT, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_COLOR_EXPOSURE_INT, "rw", "rw", vendorPropertyAccessor);  // using vendor property accessor
+            propertyServer->registerProperty(OB_PROP_LDP_BOOL, "rw", "rw", vendorPropertyAccessor);
+
+            propertyServer->registerProperty(OB_PROP_LASER_BOOL, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_DEPTH_HOLEFILTER_BOOL, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_LDP_STATUS_BOOL, "r", "r", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_DEPTH_ALIGN_HARDWARE_BOOL, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_LASER_POWER_LEVEL_CONTROL_INT, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_LDP_MEASURE_DISTANCE_INT, "r", "r", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_DEPTH_ALIGN_HARDWARE_MODE_INT, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_TIMER_RESET_SIGNAL_BOOL, "w", "w", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_TIMER_RESET_TRIGGER_OUT_ENABLE_BOOL, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->aliasProperty(OB_PROP_SYNC_SIGNAL_TRIGGER_OUT_BOOL, OB_PROP_TIMER_RESET_TRIGGER_OUT_ENABLE_BOOL);
+            propertyServer->registerProperty(OB_PROP_TIMER_RESET_DELAY_US_INT, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_CAPTURE_IMAGE_SIGNAL_BOOL, "w", "w", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_DEPTH_MIRROR_MODULE_STATUS_BOOL, "", "r", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_CAPTURE_IMAGE_FRAME_NUMBER_INT, "rw", "rw", vendorPropertyAccessor);
+
+            propertyServer->registerProperty(OB_STRUCT_VERSION, "", "r", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_STRUCT_DEVICE_TEMPERATURE, "r", "r", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_STRUCT_CURRENT_DEPTH_ALG_MODE, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_STRUCT_DEVICE_SERIAL_NUMBER, "r", "r", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_STRUCT_MULTI_DEVICE_SYNC_CONFIG, "rw", "rw", vendorPropertyAccessor);
+
+            propertyServer->registerProperty(OB_RAW_DATA_EFFECTIVE_VIDEO_STREAM_PROFILE_LIST, "", "r", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_RAW_DATA_DEPTH_ALG_MODE_LIST, "r", "r", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_RAW_DATA_IMU_CALIB_PARAM, "", "r", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_RAW_DATA_DEPTH_CALIB_PARAM, "", "r", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_RAW_DATA_ALIGN_CALIB_PARAM, "", "r", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_RAW_DATA_D2C_ALIGN_SUPPORT_PROFILE_LIST, "", "r", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_SDK_DEPTH_FRAME_UNPACK_BOOL, "", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_IR_CHANNEL_DATA_SOURCE_INT, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_DEPTH_RM_FILTER_BOOL, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_WATCHDOG_BOOL, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_EXTERNAL_SIGNAL_RESET_BOOL, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_LASER_POWER_ACTUAL_LEVEL_INT, "r", "r", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_STRUCT_DEVICE_TIME, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_GYRO_ODR_INT, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_ACCEL_ODR_INT, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_ACCEL_SWITCH_BOOL, "", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_GYRO_SWITCH_BOOL, "", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_GYRO_FULL_SCALE_INT, "", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_ACCEL_FULL_SCALE_INT, "", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_STRUCT_GET_ACCEL_PRESETS_ODR_LIST, "", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_STRUCT_GET_ACCEL_PRESETS_FULL_SCALE_LIST, "", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_STRUCT_GET_GYRO_PRESETS_ODR_LIST, "", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_STRUCT_GET_GYRO_PRESETS_FULL_SCALE_LIST, "", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_DEVICE_USB2_REPEAT_IDENTIFY_BOOL, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_DEVICE_RESET_BOOL, "", "w", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_STOP_DEPTH_STREAM_BOOL, "", "w", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_STOP_IR_STREAM_BOOL, "", "w", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_STOP_COLOR_STREAM_BOOL, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_DEVICE_COMMUNICATION_TYPE_INT, "", "w", vendorPropertyAccessor);
+        }
+        else if(sensor == OB_SENSOR_ACCEL) {
+            auto imuCorrectorFilter = getSensorFrameFilter("IMUCorrector", sensor);
+            if(imuCorrectorFilter) {
+                auto filterStateProperty = std::make_shared<FilterStatePropertyAccessor>(imuCorrectorFilter);
+                propertyServer->registerProperty(OB_PROP_SDK_ACCEL_FRAME_TRANSFORMED_BOOL, "rw", "rw", filterStateProperty);
+            }
+        }
+        else if(sensor == OB_SENSOR_GYRO) {
+            auto imuCorrectorFilter = getSensorFrameFilter("IMUCorrector", sensor);
+            if(imuCorrectorFilter) {
+                auto filterStateProperty = std::make_shared<FilterStatePropertyAccessor>(imuCorrectorFilter);
+                propertyServer->registerProperty(OB_PROP_SDK_GYRO_FRAME_TRANSFORMED_BOOL, "rw", "rw", filterStateProperty);
+            }
+        }
+    }
+
+    propertyServer->aliasProperty(OB_PROP_DEPTH_AUTO_EXPOSURE_BOOL, OB_PROP_IR_AUTO_EXPOSURE_BOOL);
+    propertyServer->aliasProperty(OB_PROP_DEPTH_GAIN_INT, OB_PROP_IR_GAIN_INT);
+    propertyServer->aliasProperty(OB_PROP_DEPTH_EXPOSURE_INT, OB_PROP_IR_EXPOSURE_INT);
+
+    auto heartbeatPropertyAccessor = std::make_shared<HeartbeatPropertyAccessor>(this);
+    propertyServer->registerProperty(OB_PROP_HEARTBEAT_BOOL, "rw", "rw", heartbeatPropertyAccessor);
+
+    auto baseLinePropertyAccessor = std::make_shared<BaselinePropertyAccessor>(this);
+    propertyServer->registerProperty(OB_STRUCT_BASELINE_CALIBRATION_PARAM, "r", "r", baseLinePropertyAccessor);
+
+    registerComponent(OB_DEV_COMPONENT_PROPERTY_SERVER, propertyServer, true);
+
+    BEGIN_TRY_EXECUTE({ propertyServer->setPropertyValueT(OB_PROP_DEVICE_COMMUNICATION_TYPE_INT, OB_COMM_USB); })
+    CATCH_EXCEPTION_AND_EXECUTE({ LOG_ERROR("Set device communication type to ethernet mode failed!"); })
+}
+
+G2XLNetDevice::G2XLNetDevice(const std::shared_ptr<const IDeviceEnumInfo> &info) : G2XLDeviceBase(info) {
+    init();
+}
+G2XLNetDevice::~G2XLNetDevice() noexcept {}
+
+void G2XLNetDevice::init() {
+    initSensorList();
+    initProperties();
+    G2XLDeviceBase::init();
+}
+
+void G2XLNetDevice::initSensorList() {
+    registerComponent(OB_DEV_COMPONENT_FRAME_PROCESSOR_FACTORY, [this]() {
+        std::shared_ptr<FrameProcessorFactory> factory;
+        TRY_EXECUTE({ factory = std::make_shared<FrameProcessorFactory>(this); })
+        return factory;
+    });
+
+    registerComponent(OB_DEV_COMPONENT_STREAM_PROFILE_FILTER, [this]() { return std::make_shared<G2StreamProfileFilter>(this); });
+
+    const auto &sourcePortInfoList = enumInfo_->getSourcePortInfoList();
+    auto depthPortInfoIter = std::find_if(sourcePortInfoList.begin(), sourcePortInfoList.end(), [](const std::shared_ptr<const SourcePortInfo> &portInfo) {
+        return portInfo->portType == SOURCE_PORT_NET_RTSP && std::dynamic_pointer_cast<const RTSPStreamPortInfo>(portInfo)->streamType == OB_STREAM_DEPTH;
+    });
+    if(depthPortInfoIter != sourcePortInfoList.end()) {
+        auto depthPortInfo = *depthPortInfoIter;
+        auto platform      = Platform::getInstance();
+        auto port          = platform->getSourcePort(depthPortInfo);
+
+        registerComponent(
+            OB_DEV_COMPONENT_DEPTH_SENSOR,
+            [this, depthPortInfo]() {
+                auto platform = Platform::getInstance();
+                auto port     = platform->getSourcePort(depthPortInfo);
+                auto sensor   = std::make_shared<DisparityBasedSensor>(this, OB_SENSOR_DEPTH, port);
+
+                std::vector<FormatFilterConfig> formatFilterConfigs = {
+                    { FormatFilterPolicy::REPLACE, OB_FORMAT_MJPG, OB_FORMAT_RVL, nullptr },
+                };
+                sensor->updateFormatFilterConfig(formatFilterConfigs);
+
+                auto frameTimestampCalculator = std::make_shared<FrameTimestampCalculatorDirectly>(this, frameTimeFreq_);
+                sensor->setFrameTimestampCalculator(frameTimestampCalculator);
+
+                auto globalFrameTimestampCalculator = std::make_shared<GlobalTimestampCalculator>(this, deviceTimeFreq_, frameTimeFreq_);
+                sensor->setGlobalTimestampCalculator(globalFrameTimestampCalculator);
+
+                auto frameProcessor = getComponentT<FrameProcessor>(OB_DEV_COMPONENT_DEPTH_FRAME_PROCESSOR, false);
+                if(frameProcessor) {
+                    sensor->setFrameProcessor(frameProcessor.get());
+                }
+
+                auto propServer = getPropertyServer();
+
+                propServer->setPropertyValueT<bool>(OB_PROP_DISPARITY_TO_DEPTH_BOOL, true);
+                propServer->setPropertyValueT<bool>(OB_PROP_SDK_DISPARITY_TO_DEPTH_BOOL, false);
+                sensor->markOutputDisparityFrame(false);
+
+                propServer->setPropertyValueT(OB_PROP_DEPTH_PRECISION_LEVEL_INT, OB_PRECISION_1MM);
+                sensor->setDepthUnit(1.0f);
+
+                initSensorStreamProfile(sensor);
+
+                return sensor;
+            },
+            true);
+
+        registerSensorPortInfo(OB_SENSOR_DEPTH, depthPortInfo);
+
+        registerComponent(OB_DEV_COMPONENT_DEPTH_FRAME_PROCESSOR, [this]() {
+            auto factory        = getComponentT<FrameProcessorFactory>(OB_DEV_COMPONENT_FRAME_PROCESSOR_FACTORY);
+            auto frameProcessor = factory->createFrameProcessor(OB_SENSOR_DEPTH);
+            return frameProcessor;
+        });
+    }
+
+    auto leftIrPortInfoIter = std::find_if(sourcePortInfoList.begin(), sourcePortInfoList.end(), [](const std::shared_ptr<const SourcePortInfo> &portInfo) {
+        return portInfo->portType == SOURCE_PORT_NET_RTSP && std::dynamic_pointer_cast<const RTSPStreamPortInfo>(portInfo)->streamType == OB_STREAM_IR_LEFT;
+    });
+
+    if(leftIrPortInfoIter != sourcePortInfoList.end()) {
+        auto leftIrPortInfo = *leftIrPortInfoIter;
+        registerComponent(
+            OB_DEV_COMPONENT_LEFT_IR_SENSOR,
+            [this, leftIrPortInfo]() {
+                auto platform = Platform::getInstance();
+                auto port     = platform->getSourcePort(leftIrPortInfo);
+                auto sensor   = std::make_shared<VideoSensor>(this, OB_SENSOR_IR_LEFT, port);
+
+                auto frameTimestampCalculator = std::make_shared<FrameTimestampCalculatorDirectly>(this, frameTimeFreq_);
+                sensor->setFrameTimestampCalculator(frameTimestampCalculator);
+
+                auto globalFrameTimestampCalculator = std::make_shared<GlobalTimestampCalculator>(this, deviceTimeFreq_, frameTimeFreq_);
+                sensor->setGlobalTimestampCalculator(globalFrameTimestampCalculator);
+
+                auto frameProcessor = getComponentT<FrameProcessor>(OB_DEV_COMPONENT_LEFT_IR_FRAME_PROCESSOR, false);
+                if(frameProcessor) {
+                    sensor->setFrameProcessor(frameProcessor.get());
+                }
+
+                initSensorStreamProfile(sensor);
+
+                return sensor;
+            },
+            true);
+        registerSensorPortInfo(OB_SENSOR_IR_LEFT, leftIrPortInfo);
+
+        registerComponent(OB_DEV_COMPONENT_LEFT_IR_FRAME_PROCESSOR, [this]() {
+            auto factory        = getComponentT<FrameProcessorFactory>(OB_DEV_COMPONENT_FRAME_PROCESSOR_FACTORY);
+            auto frameProcessor = factory->createFrameProcessor(OB_SENSOR_IR_LEFT);
+            return frameProcessor;
+        });
+    }
+
+    auto rightIrPortInfoIter = std::find_if(sourcePortInfoList.begin(), sourcePortInfoList.end(), [](const std::shared_ptr<const SourcePortInfo> &portInfo) {
+        return portInfo->portType == SOURCE_PORT_NET_RTSP && std::dynamic_pointer_cast<const RTSPStreamPortInfo>(portInfo)->streamType == OB_STREAM_IR_RIGHT;
+    });
+    if(rightIrPortInfoIter != sourcePortInfoList.end()) {
+        auto rightIrPortInfo = *rightIrPortInfoIter;
+        registerComponent(
+            OB_DEV_COMPONENT_RIGHT_IR_SENSOR,
+            [this, rightIrPortInfo]() {
+                auto platform = Platform::getInstance();
+                auto port     = platform->getSourcePort(rightIrPortInfo);
+                auto sensor   = std::make_shared<VideoSensor>(this, OB_SENSOR_IR_RIGHT, port);
+
+                auto frameTimestampCalculator = std::make_shared<FrameTimestampCalculatorDirectly>(this, frameTimeFreq_);
+                sensor->setFrameTimestampCalculator(frameTimestampCalculator);
+
+                auto globalFrameTimestampCalculator = std::make_shared<GlobalTimestampCalculator>(this, deviceTimeFreq_, frameTimeFreq_);
+                sensor->setGlobalTimestampCalculator(globalFrameTimestampCalculator);
+
+                auto frameProcessor = getComponentT<FrameProcessor>(OB_DEV_COMPONENT_RIGHT_IR_FRAME_PROCESSOR, false);
+                if(frameProcessor) {
+                    sensor->setFrameProcessor(frameProcessor.get());
+                }
+
+                initSensorStreamProfile(sensor);
+                return sensor;
+            },
+            true);
+        registerSensorPortInfo(OB_SENSOR_IR_RIGHT, rightIrPortInfo);
+        registerComponent(OB_DEV_COMPONENT_RIGHT_IR_FRAME_PROCESSOR, [this]() {
+            auto factory        = getComponentT<FrameProcessorFactory>(OB_DEV_COMPONENT_FRAME_PROCESSOR_FACTORY);
+            auto frameProcessor = factory->createFrameProcessor(OB_SENSOR_IR_RIGHT);
+            return frameProcessor;
+        });
+    }
+
+    auto colorPortInfoIter = std::find_if(sourcePortInfoList.begin(), sourcePortInfoList.end(), [](const std::shared_ptr<const SourcePortInfo> &portInfo) {
+        return portInfo->portType == SOURCE_PORT_NET_RTSP && std::dynamic_pointer_cast<const RTSPStreamPortInfo>(portInfo)->streamType == OB_STREAM_COLOR;
+    });
+
+    if(colorPortInfoIter != sourcePortInfoList.end()) {
+        auto colorPortInfo = *colorPortInfoIter;
+        registerComponent(
+            OB_DEV_COMPONENT_COLOR_SENSOR,
+            [this, colorPortInfo]() {
+                auto platform = Platform::getInstance();
+                auto port     = platform->getSourcePort(colorPortInfo);
+                auto sensor   = std::make_shared<VideoSensor>(this, OB_SENSOR_COLOR, port);
+
+                std::vector<FormatFilterConfig> formatFilterConfigs = {
+                    { FormatFilterPolicy::REMOVE, OB_FORMAT_NV12, OB_FORMAT_ANY, nullptr },
+                };
+
+                auto formatConverter = getSensorFrameFilter("FormatConverter", OB_SENSOR_COLOR, false);
+                if(formatConverter) {
+#ifdef WIN32
+                    formatFilterConfigs.push_back({ FormatFilterPolicy::ADD, OB_FORMAT_BGR, OB_FORMAT_RGB, formatConverter });
+#else
+                    formatFilterConfigs.push_back({ FormatFilterPolicy::ADD, OB_FORMAT_MJPG, OB_FORMAT_RGB, formatConverter });
+                    formatFilterConfigs.push_back({ FormatFilterPolicy::ADD, OB_FORMAT_MJPG, OB_FORMAT_BGR, formatConverter });
+                    formatFilterConfigs.push_back({ FormatFilterPolicy::ADD, OB_FORMAT_MJPG, OB_FORMAT_BGRA, formatConverter });
+#endif
+                }
+                sensor->updateFormatFilterConfig(formatFilterConfigs);
+
+                auto frameTimestampCalculator = std::make_shared<FrameTimestampCalculatorBaseDeviceTime>(this, deviceTimeFreq_, colorframeTimeFreq_);
+                sensor->setFrameTimestampCalculator(frameTimestampCalculator);
+
+                auto globalFrameTimestampCalculator = std::make_shared<GlobalTimestampCalculator>(this, deviceTimeFreq_, colorframeTimeFreq_);
+                sensor->setGlobalTimestampCalculator(globalFrameTimestampCalculator);
+
+                auto frameProcessor = getComponentT<FrameProcessor>(OB_DEV_COMPONENT_COLOR_FRAME_PROCESSOR, false);
+                if(frameProcessor) {
+                    sensor->setFrameProcessor(frameProcessor.get());
+                }
+
+                initSensorStreamProfile(sensor);
+
+                return sensor;
+            },
+            true);
+        registerSensorPortInfo(OB_SENSOR_COLOR, colorPortInfo);
+
+        registerComponent(OB_DEV_COMPONENT_COLOR_FRAME_PROCESSOR, [this]() {
+            auto factory        = getComponentT<FrameProcessorFactory>(OB_DEV_COMPONENT_FRAME_PROCESSOR_FACTORY);
+            auto frameProcessor = factory->createFrameProcessor(OB_SENSOR_COLOR);
+            return frameProcessor;
+        });
+    }
+
+    auto imuPortInfoIter = std::find_if(sourcePortInfoList.begin(), sourcePortInfoList.end(), [](const std::shared_ptr<const SourcePortInfo> &portInfo) {
+        return portInfo->portType == SOURCE_PORT_NET_VENDOR_STREAM;
+    });
+
+    if(imuPortInfoIter != sourcePortInfoList.end()) {
+        auto imuPortInfo = *imuPortInfoIter;
+
+        registerComponent(OB_DEV_COMPONENT_IMU_STREAMER, [this, imuPortInfo]() {
+            // the gyro and accel are both on the same port and share the same filter
+            auto platform           = Platform::getInstance();
+            auto port               = platform->getSourcePort(imuPortInfo);
+            auto imuCorrectorFilter = getSensorFrameFilter("IMUCorrector", OB_SENSOR_ACCEL, true);
+
+            imuCorrectorFilter->enable(false);
+            auto dataStreamPort = std::dynamic_pointer_cast<IDataStreamPort>(port);
+            auto imuStreamer    = std::make_shared<ImuStreamer>(this, dataStreamPort, imuCorrectorFilter);
+            return imuStreamer;
+        });
+
+        registerComponent(
+            OB_DEV_COMPONENT_ACCEL_SENSOR,
+            [this, imuPortInfo]() {
+                auto platform             = Platform::getInstance();
+                auto port                 = platform->getSourcePort(imuPortInfo);
+                auto imuStreamer          = getComponentT<ImuStreamer>(OB_DEV_COMPONENT_IMU_STREAMER);
+                auto imuStreamerSharedPtr = imuStreamer.get();
+                auto sensor               = std::make_shared<AccelSensor>(this, port, imuStreamerSharedPtr);
+
+                auto globalFrameTimestampCalculator = std::make_shared<GlobalTimestampCalculator>(this, deviceTimeFreq_, frameTimeFreq_);
+                sensor->setGlobalTimestampCalculator(globalFrameTimestampCalculator);
+
+                initSensorStreamProfile(sensor);
+
+                return sensor;
+            },
+            true);
+        registerSensorPortInfo(OB_SENSOR_ACCEL, imuPortInfo);
+
+        registerComponent(
+            OB_DEV_COMPONENT_GYRO_SENSOR,
+            [this, imuPortInfo]() {
+                auto platform             = Platform::getInstance();
+                auto port                 = platform->getSourcePort(imuPortInfo);
+                auto imuStreamer          = getComponentT<ImuStreamer>(OB_DEV_COMPONENT_IMU_STREAMER);
+                auto imuStreamerSharedPtr = imuStreamer.get();
+                auto sensor               = std::make_shared<GyroSensor>(this, port, imuStreamerSharedPtr);
+
+                auto globalFrameTimestampCalculator = std::make_shared<GlobalTimestampCalculator>(this, deviceTimeFreq_, frameTimeFreq_);
+                sensor->setGlobalTimestampCalculator(globalFrameTimestampCalculator);
+
+                initSensorStreamProfile(sensor);
+
+                return sensor;
+            },
+            true);
+        registerSensorPortInfo(OB_SENSOR_GYRO, imuPortInfo);
+    }
+}
+
+void G2XLNetDevice::initProperties() {
+    const auto &sourcePortInfoList = enumInfo_->getSourcePortInfoList();
+    auto        vendorPortInfoIter = std::find_if(sourcePortInfoList.begin(), sourcePortInfoList.end(),
+                                                  [](const std::shared_ptr<const SourcePortInfo> &portInfo) {  //
+                                               return portInfo->portType == SOURCE_PORT_NET_VENDOR;
+                                           });
+    if(vendorPortInfoIter == sourcePortInfoList.end()) {
+        return;
+    }
+
+    auto vendorPortInfo         = *vendorPortInfoIter;
+    auto vendorPropertyAccessor = std::make_shared<LazySuperPropertyAccessor>([this, vendorPortInfo]() {
+        auto platform = Platform::getInstance();
+        auto port     = platform->getSourcePort(vendorPortInfo);
+        auto accessor = std::make_shared<VendorPropertyAccessor>(this, port);
+        return accessor;
+    });
+
+    registerComponent(OB_DEV_COMPONENT_MAIN_PROPERTY_ACCESSOR, [this, vendorPortInfo]() {
+        auto platform = Platform::getInstance();
+        auto port     = platform->getSourcePort(vendorPortInfo);
+        auto accessor = std::make_shared<VendorPropertyAccessor>(this, port);
+        return accessor;
+    });
+
+    registerComponent(OB_DEV_COMPONENT_DEVICE_MONITOR, [this, vendorPortInfo]() {
+        auto platform   = Platform::getInstance();
+        auto port       = platform->getSourcePort(vendorPortInfo);
+        auto devMonitor = std::make_shared<DeviceMonitor>(this, port);
+        return devMonitor;
+    });
+
+    auto propertyServer = std::make_shared<PropertyServer>(this);
+    propertyServer->registerProperty(OB_PROP_COLOR_AUTO_EXPOSURE_BOOL, "rw", "rw", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_PROP_COLOR_GAIN_INT, "rw", "rw", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_PROP_COLOR_SATURATION_INT, "rw", "rw", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_PROP_COLOR_AUTO_WHITE_BALANCE_BOOL, "rw", "rw", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_PROP_COLOR_WHITE_BALANCE_INT, "rw", "rw", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_PROP_COLOR_BRIGHTNESS_INT, "rw", "rw", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_PROP_COLOR_SHARPNESS_INT, "rw", "rw", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_PROP_COLOR_CONTRAST_INT, "rw", "rw", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_PROP_COLOR_POWER_LINE_FREQUENCY_INT, "rw", "rw", vendorPropertyAccessor);
+
+    propertyServer->registerProperty(OB_PROP_IR_GAIN_INT, "rw", "rw", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_PROP_IR_AUTO_EXPOSURE_BOOL, "rw", "rw", vendorPropertyAccessor);
+
+    propertyServer->registerProperty(OB_PROP_IR_EXPOSURE_INT, "rw", "rw", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_PROP_COLOR_EXPOSURE_INT, "rw", "rw", vendorPropertyAccessor);  // using vendor property accessor
+    propertyServer->registerProperty(OB_PROP_LDP_BOOL, "rw", "rw", vendorPropertyAccessor);
+
+    propertyServer->registerProperty(OB_PROP_LASER_BOOL, "rw", "rw", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_PROP_DEPTH_HOLEFILTER_BOOL, "rw", "rw", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_PROP_LDP_STATUS_BOOL, "r", "r", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_PROP_DEPTH_ALIGN_HARDWARE_BOOL, "rw", "rw", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_PROP_LASER_POWER_LEVEL_CONTROL_INT, "rw", "rw", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_PROP_LDP_MEASURE_DISTANCE_INT, "r", "r", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_PROP_DEPTH_ALIGN_HARDWARE_MODE_INT, "rw", "rw", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_PROP_TIMER_RESET_SIGNAL_BOOL, "w", "w", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_PROP_TIMER_RESET_TRIGGER_OUT_ENABLE_BOOL, "rw", "rw", vendorPropertyAccessor);
+    propertyServer->aliasProperty(OB_PROP_SYNC_SIGNAL_TRIGGER_OUT_BOOL, OB_PROP_TIMER_RESET_TRIGGER_OUT_ENABLE_BOOL);
+    propertyServer->registerProperty(OB_PROP_TIMER_RESET_DELAY_US_INT, "rw", "rw", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_PROP_CAPTURE_IMAGE_SIGNAL_BOOL, "rw", "rw", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_PROP_DEPTH_MIRROR_MODULE_STATUS_BOOL, "", "r", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_PROP_CAPTURE_IMAGE_FRAME_NUMBER_INT, "rw", "rw", vendorPropertyAccessor);
+
+    propertyServer->registerProperty(OB_STRUCT_VERSION, "", "r", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_STRUCT_DEVICE_TEMPERATURE, "r", "r", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_STRUCT_CURRENT_DEPTH_ALG_MODE, "rw", "rw", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_STRUCT_DEVICE_SERIAL_NUMBER, "r", "r", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_STRUCT_MULTI_DEVICE_SYNC_CONFIG, "rw", "rw", vendorPropertyAccessor);
+
+    propertyServer->registerProperty(OB_RAW_DATA_EFFECTIVE_VIDEO_STREAM_PROFILE_LIST, "", "r", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_RAW_DATA_DEPTH_ALG_MODE_LIST, "r", "r", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_RAW_DATA_IMU_CALIB_PARAM, "", "r", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_RAW_DATA_DEPTH_CALIB_PARAM, "", "r", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_RAW_DATA_ALIGN_CALIB_PARAM, "", "r", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_RAW_DATA_D2C_ALIGN_SUPPORT_PROFILE_LIST, "", "r", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_PROP_SDK_DEPTH_FRAME_UNPACK_BOOL, "", "rw", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_PROP_IR_CHANNEL_DATA_SOURCE_INT, "rw", "rw", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_PROP_DEPTH_RM_FILTER_BOOL, "rw", "rw", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_PROP_WATCHDOG_BOOL, "rw", "rw", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_PROP_EXTERNAL_SIGNAL_RESET_BOOL, "rw", "rw", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_PROP_LASER_POWER_ACTUAL_LEVEL_INT, "r", "r", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_STRUCT_DEVICE_TIME, "rw", "rw", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_PROP_GYRO_ODR_INT, "rw", "rw", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_PROP_ACCEL_ODR_INT, "rw", "rw", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_PROP_ACCEL_SWITCH_BOOL, "", "rw", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_PROP_GYRO_SWITCH_BOOL, "", "rw", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_PROP_GYRO_FULL_SCALE_INT, "", "rw", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_PROP_ACCEL_FULL_SCALE_INT, "", "rw", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_STRUCT_GET_ACCEL_PRESETS_ODR_LIST, "", "rw", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_STRUCT_GET_ACCEL_PRESETS_FULL_SCALE_LIST, "", "rw", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_STRUCT_GET_GYRO_PRESETS_ODR_LIST, "", "rw", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_STRUCT_GET_GYRO_PRESETS_FULL_SCALE_LIST, "", "rw", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_PROP_DEVICE_USB2_REPEAT_IDENTIFY_BOOL, "rw", "rw", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_PROP_DEVICE_RESET_BOOL, "", "w", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_PROP_STOP_DEPTH_STREAM_BOOL, "", "w", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_PROP_STOP_IR_STREAM_BOOL, "", "w", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_PROP_STOP_COLOR_STREAM_BOOL, "", "w", vendorPropertyAccessor);
+    propertyServer->registerProperty(OB_PROP_DEVICE_COMMUNICATION_TYPE_INT, "", "w", vendorPropertyAccessor);
+
+    auto imuCorrectorFilter = getSensorFrameFilter("IMUCorrector", OB_SENSOR_ACCEL);
+    if(imuCorrectorFilter) {
+        auto filterStateProperty = std::make_shared<FilterStatePropertyAccessor>(imuCorrectorFilter);
+        propertyServer->registerProperty(OB_PROP_SDK_ACCEL_FRAME_TRANSFORMED_BOOL, "rw", "rw", filterStateProperty);
+        propertyServer->registerProperty(OB_PROP_SDK_GYRO_FRAME_TRANSFORMED_BOOL, "rw", "rw", filterStateProperty);
+    }
+    propertyServer->aliasProperty(OB_PROP_DEPTH_AUTO_EXPOSURE_BOOL, OB_PROP_IR_AUTO_EXPOSURE_BOOL);
+    propertyServer->aliasProperty(OB_PROP_DEPTH_GAIN_INT, OB_PROP_IR_GAIN_INT);
+    propertyServer->aliasProperty(OB_PROP_DEPTH_EXPOSURE_INT, OB_PROP_IR_EXPOSURE_INT);
+
+    auto heartbeatPropertyAccessor = std::make_shared<HeartbeatPropertyAccessor>(this);
+    propertyServer->registerProperty(OB_PROP_HEARTBEAT_BOOL, "rw", "rw", heartbeatPropertyAccessor);
+
+    auto baseLinePropertyAccessor = std::make_shared<BaselinePropertyAccessor>(this);
+    propertyServer->registerProperty(OB_STRUCT_BASELINE_CALIBRATION_PARAM, "r", "r", baseLinePropertyAccessor);
+
+    auto d2dPropertyAccessor = std::make_shared<G2Disp2DepthPropertyAccessor>(this);
+    propertyServer->registerProperty(OB_PROP_DISPARITY_TO_DEPTH_BOOL, "rw", "rw", d2dPropertyAccessor);      // hw
+    propertyServer->registerProperty(OB_PROP_SDK_DISPARITY_TO_DEPTH_BOOL, "rw", "rw", d2dPropertyAccessor);  // sw
+    propertyServer->registerProperty(OB_PROP_DEPTH_PRECISION_LEVEL_INT, "rw", "rw", d2dPropertyAccessor);
+    propertyServer->registerProperty(OB_STRUCT_DEPTH_PRECISION_SUPPORT_LIST, "r", "r", d2dPropertyAccessor);
+
+    registerComponent(OB_DEV_COMPONENT_PROPERTY_SERVER, propertyServer, true);
+
+    BEGIN_TRY_EXECUTE({ propertyServer->setPropertyValueT(OB_PROP_DEVICE_COMMUNICATION_TYPE_INT, OB_COMM_NET); })
+    CATCH_EXCEPTION_AND_EXECUTE({ LOG_ERROR("Set device communication type to ethernet mode failed!"); })
+}
+void G2XLNetDevice::initSensorStreamProfile(std::shared_ptr<ISensor> sensor) {
+    auto              sensorType = sensor->getSensorType();
+    auto              streamType = utils::mapSensorTypeToStreamType(sensorType);
+    StreamProfileList streamProfileList;
+    if(streamType == OB_STREAM_DEPTH) {
+        streamProfileList.emplace_back(StreamProfileFactory::createVideoStreamProfile(streamType, OB_FORMAT_Y16, 640, 400, 5));
+        streamProfileList.emplace_back(StreamProfileFactory::createVideoStreamProfile(streamType, OB_FORMAT_Y16, 640, 400, 10));
+        streamProfileList.emplace_back(StreamProfileFactory::createVideoStreamProfile(streamType, OB_FORMAT_Y16, 640, 400, 15));
+        streamProfileList.emplace_back(StreamProfileFactory::createVideoStreamProfile(streamType, OB_FORMAT_Y16, 640, 400, 20));
+        streamProfileList.emplace_back(StreamProfileFactory::createVideoStreamProfile(streamType, OB_FORMAT_Y16, 1280, 800, 5));
+        streamProfileList.emplace_back(StreamProfileFactory::createVideoStreamProfile(streamType, OB_FORMAT_Y16, 1280, 800, 10));
+
+        streamProfileList.emplace_back(StreamProfileFactory::createVideoStreamProfile(streamType, OB_FORMAT_RVL, 640, 400, 5));
+        streamProfileList.emplace_back(StreamProfileFactory::createVideoStreamProfile(streamType, OB_FORMAT_RVL, 640, 400, 10));
+        streamProfileList.emplace_back(StreamProfileFactory::createVideoStreamProfile(streamType, OB_FORMAT_RVL, 640, 400, 15));
+        streamProfileList.emplace_back(StreamProfileFactory::createVideoStreamProfile(streamType, OB_FORMAT_RVL, 640, 400, 20));
+        streamProfileList.emplace_back(StreamProfileFactory::createVideoStreamProfile(streamType, OB_FORMAT_RVL, 1280, 800, 5));
+        streamProfileList.emplace_back(StreamProfileFactory::createVideoStreamProfile(streamType, OB_FORMAT_RVL, 1280, 800, 10));
+    }
+    else if(streamType == OB_STREAM_COLOR) {
+        streamProfileList.emplace_back(StreamProfileFactory::createVideoStreamProfile(streamType, OB_FORMAT_MJPG, 1280, 800, 5));
+        streamProfileList.emplace_back(StreamProfileFactory::createVideoStreamProfile(streamType, OB_FORMAT_MJPG, 1280, 800, 10));
+        streamProfileList.emplace_back(StreamProfileFactory::createVideoStreamProfile(streamType, OB_FORMAT_MJPG, 1280, 800, 15));
+        streamProfileList.emplace_back(StreamProfileFactory::createVideoStreamProfile(streamType, OB_FORMAT_MJPG, 1280, 800, 20));
+        streamProfileList.emplace_back(StreamProfileFactory::createVideoStreamProfile(streamType, OB_FORMAT_MJPG, 1280, 720, 5));
+        streamProfileList.emplace_back(StreamProfileFactory::createVideoStreamProfile(streamType, OB_FORMAT_MJPG, 1280, 720, 10));
+        streamProfileList.emplace_back(StreamProfileFactory::createVideoStreamProfile(streamType, OB_FORMAT_MJPG, 1280, 720, 15));
+        streamProfileList.emplace_back(StreamProfileFactory::createVideoStreamProfile(streamType, OB_FORMAT_MJPG, 1280, 720, 20));
+        streamProfileList.emplace_back(StreamProfileFactory::createVideoStreamProfile(streamType, OB_FORMAT_MJPG, 800, 600, 5));
+        streamProfileList.emplace_back(StreamProfileFactory::createVideoStreamProfile(streamType, OB_FORMAT_MJPG, 800, 600, 10));
+        streamProfileList.emplace_back(StreamProfileFactory::createVideoStreamProfile(streamType, OB_FORMAT_MJPG, 800, 600, 15));
+        streamProfileList.emplace_back(StreamProfileFactory::createVideoStreamProfile(streamType, OB_FORMAT_MJPG, 800, 600, 20));
+        streamProfileList.emplace_back(StreamProfileFactory::createVideoStreamProfile(streamType, OB_FORMAT_MJPG, 640, 400, 5));
+        streamProfileList.emplace_back(StreamProfileFactory::createVideoStreamProfile(streamType, OB_FORMAT_MJPG, 640, 400, 10));
+        streamProfileList.emplace_back(StreamProfileFactory::createVideoStreamProfile(streamType, OB_FORMAT_MJPG, 640, 400, 15));
+        streamProfileList.emplace_back(StreamProfileFactory::createVideoStreamProfile(streamType, OB_FORMAT_MJPG, 640, 400, 20));
+        streamProfileList.emplace_back(StreamProfileFactory::createVideoStreamProfile(streamType, OB_FORMAT_MJPG, 640, 360, 5));
+        streamProfileList.emplace_back(StreamProfileFactory::createVideoStreamProfile(streamType, OB_FORMAT_MJPG, 640, 360, 10));
+        streamProfileList.emplace_back(StreamProfileFactory::createVideoStreamProfile(streamType, OB_FORMAT_MJPG, 640, 360, 15));
+        streamProfileList.emplace_back(StreamProfileFactory::createVideoStreamProfile(streamType, OB_FORMAT_MJPG, 640, 360, 20));
+
+        streamProfileList.emplace_back(StreamProfileFactory::createVideoStreamProfile(streamType, OB_FORMAT_YUYV, 1280, 800, 10));
+        streamProfileList.emplace_back(StreamProfileFactory::createVideoStreamProfile(streamType, OB_FORMAT_YUYV, 1280, 800, 5));
+        streamProfileList.emplace_back(StreamProfileFactory::createVideoStreamProfile(streamType, OB_FORMAT_YUYV, 640, 360, 5));
+        streamProfileList.emplace_back(StreamProfileFactory::createVideoStreamProfile(streamType, OB_FORMAT_YUYV, 640, 360, 10));
+        streamProfileList.emplace_back(StreamProfileFactory::createVideoStreamProfile(streamType, OB_FORMAT_YUYV, 640, 360, 15));
+        streamProfileList.emplace_back(StreamProfileFactory::createVideoStreamProfile(streamType, OB_FORMAT_YUYV, 640, 360, 20));
+        streamProfileList.emplace_back(StreamProfileFactory::createVideoStreamProfile(streamType, OB_FORMAT_YUYV, 640, 400, 5));
+        streamProfileList.emplace_back(StreamProfileFactory::createVideoStreamProfile(streamType, OB_FORMAT_YUYV, 640, 400, 10));
+        streamProfileList.emplace_back(StreamProfileFactory::createVideoStreamProfile(streamType, OB_FORMAT_YUYV, 640, 400, 15));
+        streamProfileList.emplace_back(StreamProfileFactory::createVideoStreamProfile(streamType, OB_FORMAT_YUYV, 640, 400, 20));
+        streamProfileList.emplace_back(StreamProfileFactory::createVideoStreamProfile(streamType, OB_FORMAT_YUYV, 800, 600, 5));
+        streamProfileList.emplace_back(StreamProfileFactory::createVideoStreamProfile(streamType, OB_FORMAT_YUYV, 800, 600, 10));
+        streamProfileList.emplace_back(StreamProfileFactory::createVideoStreamProfile(streamType, OB_FORMAT_YUYV, 800, 600, 15));
+        streamProfileList.emplace_back(StreamProfileFactory::createVideoStreamProfile(streamType, OB_FORMAT_YUYV, 800, 600, 20));
+        streamProfileList.emplace_back(StreamProfileFactory::createVideoStreamProfile(streamType, OB_FORMAT_YUYV, 1280, 720, 5));
+        streamProfileList.emplace_back(StreamProfileFactory::createVideoStreamProfile(streamType, OB_FORMAT_YUYV, 1280, 720, 10));
+    }
+    else if(streamType == OB_STREAM_IR_LEFT) {
+        streamProfileList.emplace_back(StreamProfileFactory::createVideoStreamProfile(streamType, OB_FORMAT_Y8, 1280, 800, 5));
+        streamProfileList.emplace_back(StreamProfileFactory::createVideoStreamProfile(streamType, OB_FORMAT_Y8, 1280, 800, 10));
+        streamProfileList.emplace_back(StreamProfileFactory::createVideoStreamProfile(streamType, OB_FORMAT_Y8, 1280, 800, 15));
+        streamProfileList.emplace_back(StreamProfileFactory::createVideoStreamProfile(streamType, OB_FORMAT_Y8, 1280, 800, 20));
+        streamProfileList.emplace_back(StreamProfileFactory::createVideoStreamProfile(streamType, OB_FORMAT_Y8, 640, 400, 5));
+        streamProfileList.emplace_back(StreamProfileFactory::createVideoStreamProfile(streamType, OB_FORMAT_Y8, 640, 400, 10));
+        streamProfileList.emplace_back(StreamProfileFactory::createVideoStreamProfile(streamType, OB_FORMAT_Y8, 640, 400, 15));
+        streamProfileList.emplace_back(StreamProfileFactory::createVideoStreamProfile(streamType, OB_FORMAT_Y8, 640, 400, 20));
+
+        streamProfileList.emplace_back(StreamProfileFactory::createVideoStreamProfile(streamType, OB_FORMAT_MJPG, 1280, 800, 5));
+        streamProfileList.emplace_back(StreamProfileFactory::createVideoStreamProfile(streamType, OB_FORMAT_MJPG, 1280, 800, 10));
+        streamProfileList.emplace_back(StreamProfileFactory::createVideoStreamProfile(streamType, OB_FORMAT_MJPG, 1280, 800, 15));
+        streamProfileList.emplace_back(StreamProfileFactory::createVideoStreamProfile(streamType, OB_FORMAT_MJPG, 1280, 800, 20));
+        streamProfileList.emplace_back(StreamProfileFactory::createVideoStreamProfile(streamType, OB_FORMAT_MJPG, 640, 400, 5));
+        streamProfileList.emplace_back(StreamProfileFactory::createVideoStreamProfile(streamType, OB_FORMAT_MJPG, 640, 400, 10));
+        streamProfileList.emplace_back(StreamProfileFactory::createVideoStreamProfile(streamType, OB_FORMAT_MJPG, 640, 400, 15));
+        streamProfileList.emplace_back(StreamProfileFactory::createVideoStreamProfile(streamType, OB_FORMAT_MJPG, 640, 400, 20));
+
+        streamProfileList.emplace_back(StreamProfileFactory::createVideoStreamProfile(streamType, OB_FORMAT_Y10, 1280, 800, 5));
+        streamProfileList.emplace_back(StreamProfileFactory::createVideoStreamProfile(streamType, OB_FORMAT_Y10, 1280, 800, 10));
+    }
+    else if(streamType == OB_STREAM_IR_RIGHT) {
+        streamProfileList.emplace_back(StreamProfileFactory::createVideoStreamProfile(streamType, OB_FORMAT_Y8, 1280, 800, 5));
+        streamProfileList.emplace_back(StreamProfileFactory::createVideoStreamProfile(streamType, OB_FORMAT_Y8, 1280, 800, 10));
+        streamProfileList.emplace_back(StreamProfileFactory::createVideoStreamProfile(streamType, OB_FORMAT_Y8, 1280, 800, 15));
+        streamProfileList.emplace_back(StreamProfileFactory::createVideoStreamProfile(streamType, OB_FORMAT_Y8, 1280, 800, 20));
+        streamProfileList.emplace_back(StreamProfileFactory::createVideoStreamProfile(streamType, OB_FORMAT_Y8, 640, 400, 5));
+        streamProfileList.emplace_back(StreamProfileFactory::createVideoStreamProfile(streamType, OB_FORMAT_Y8, 640, 400, 10));
+        streamProfileList.emplace_back(StreamProfileFactory::createVideoStreamProfile(streamType, OB_FORMAT_Y8, 640, 400, 15));
+        streamProfileList.emplace_back(StreamProfileFactory::createVideoStreamProfile(streamType, OB_FORMAT_Y8, 640, 400, 20));
+
+        streamProfileList.emplace_back(StreamProfileFactory::createVideoStreamProfile(streamType, OB_FORMAT_MJPG, 1280, 800, 5));
+        streamProfileList.emplace_back(StreamProfileFactory::createVideoStreamProfile(streamType, OB_FORMAT_MJPG, 1280, 800, 10));
+        streamProfileList.emplace_back(StreamProfileFactory::createVideoStreamProfile(streamType, OB_FORMAT_MJPG, 1280, 800, 15));
+        streamProfileList.emplace_back(StreamProfileFactory::createVideoStreamProfile(streamType, OB_FORMAT_MJPG, 1280, 800, 20));
+        streamProfileList.emplace_back(StreamProfileFactory::createVideoStreamProfile(streamType, OB_FORMAT_MJPG, 640, 400, 5));
+        streamProfileList.emplace_back(StreamProfileFactory::createVideoStreamProfile(streamType, OB_FORMAT_MJPG, 640, 400, 10));
+        streamProfileList.emplace_back(StreamProfileFactory::createVideoStreamProfile(streamType, OB_FORMAT_MJPG, 640, 400, 15));
+        streamProfileList.emplace_back(StreamProfileFactory::createVideoStreamProfile(streamType, OB_FORMAT_MJPG, 640, 400, 20));
+
+        streamProfileList.emplace_back(StreamProfileFactory::createVideoStreamProfile(streamType, OB_FORMAT_Y10, 1280, 800, 5));
+        streamProfileList.emplace_back(StreamProfileFactory::createVideoStreamProfile(streamType, OB_FORMAT_Y10, 1280, 800, 10));
+    }
+    if(!streamProfileList.empty()) {
+        sensor->setStreamProfileList(streamProfileList);
+    }
+    G2XLDeviceBase::initSensorStreamProfile(sensor);
+}
+
+void G2XLNetDevice::fetchDeviceInfo() {
+    auto propServer                   = getPropertyServer();
+    auto version                      = propServer->getStructureDataT<OBVersionInfo>(OB_STRUCT_VERSION);
+    auto deviceInfo                   = std::make_shared<NetDeviceInfo>();
+    auto portInfo                     = enumInfo_->getSourcePortInfoList().front();
+    auto netPortInfo                  = std::dynamic_pointer_cast<const NetSourcePortInfo>(portInfo);
+    deviceInfo->ipAddress_            = netPortInfo->address;
+    deviceInfo_                       = deviceInfo;
+    deviceInfo_->name_                = enumInfo_->getName();
+    deviceInfo_->fwVersion_           = version.firmwareVersion;
+    deviceInfo_->deviceSn_            = version.serialNumber;
+    deviceInfo_->asicName_            = version.depthChip;
+    deviceInfo_->hwVersion_           = version.hardwareVersion;
+    deviceInfo_->type_                = static_cast<uint16_t>(version.deviceType);
+    deviceInfo_->supportedSdkVersion_ = version.sdkVersion;
+    deviceInfo_->pid_                 = enumInfo_->getPid();
+    deviceInfo_->vid_                 = enumInfo_->getVid();
+    deviceInfo_->uid_                 = enumInfo_->getUid();
+    deviceInfo_->connectionType_      = enumInfo_->getConnectionType();
+
+    // remove the prefix "Orbbec " from the device name if contained
+    if(deviceInfo_->name_.find("Orbbec ") == 0) {
+        deviceInfo_->name_ = deviceInfo_->name_.substr(7);
+    }
+    deviceInfo_->fullName_ = "Orbbec " + deviceInfo_->name_;
+
+    // mark the device as a multi-sensor device with same clock at default
+    extensionInfo_["AllSensorsUsingSameClock"] = "true";
+}
+
+}  // namespace libobsensor
+
diff --git a/src/device/gemini2/G2XLDevice.hpp b/src/device/gemini2/G2XLDevice.hpp
new file mode 100644
index 00000000..a56c07ef
--- /dev/null
+++ b/src/device/gemini2/G2XLDevice.hpp
@@ -0,0 +1,62 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include "DeviceBase.hpp"
+#include "IDeviceManager.hpp"
+#include "frameprocessor/FrameProcessor.hpp"
+
+#include <map>
+#include <memory>
+
+namespace libobsensor {
+class G2XLDeviceBase : public DeviceBase {
+public:
+    G2XLDeviceBase(const std::shared_ptr<const IDeviceEnumInfo> &info);
+    virtual ~G2XLDeviceBase() noexcept;
+
+    void init() override;
+
+    std::vector<std::shared_ptr<IFilter>> createRecommendedPostProcessingFilters(OBSensorType type) override;
+
+protected:
+    void initSensorStreamProfile(std::shared_ptr<ISensor> sensor);
+
+protected:
+    uint64_t deviceTimeFreq_ = 1000;
+};
+
+class G2XLUSBDevice : public G2XLDeviceBase {
+public:
+    G2XLUSBDevice(const std::shared_ptr<const IDeviceEnumInfo> &info);
+    virtual ~G2XLUSBDevice() noexcept;
+
+private:
+    void init() override;
+    void initSensorList();
+    void initProperties();
+
+private:
+    const uint64_t frameTimeFreq_ = 1000000;
+};
+
+class G2XLNetDevice : public G2XLDeviceBase {
+public:
+    G2XLNetDevice(const std::shared_ptr<const IDeviceEnumInfo> &info);
+    virtual ~G2XLNetDevice() noexcept;
+
+private:
+    void init() override;
+    void initSensorList();
+    void initProperties();
+    void initSensorStreamProfile(std::shared_ptr<ISensor> sensor);
+
+    void fetchDeviceInfo() override;
+
+private:
+    const uint64_t frameTimeFreq_      = 1000;
+    const uint64_t colorframeTimeFreq_ = 90000;
+};
+
+}  // namespace libobsensor
+
diff --git a/src/device/gemini330/CMakeLists.txt b/src/device/gemini330/CMakeLists.txt
new file mode 100644
index 00000000..9c0b8b85
--- /dev/null
+++ b/src/device/gemini330/CMakeLists.txt
@@ -0,0 +1,27 @@
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+cmake_minimum_required(VERSION 3.5)
+
+target_sources(
+    ${OB_TARGET_DEVICE}
+    PRIVATE ${CMAKE_CURRENT_LIST_DIR}/G330DeviceInfo.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/G330DeviceInfo.hpp
+    ${CMAKE_CURRENT_LIST_DIR}/G330Device.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/G330Device.hpp
+    ${CMAKE_CURRENT_LIST_DIR}/G330MetadataTypes.hpp
+    ${CMAKE_CURRENT_LIST_DIR}/G330MetadataParser.hpp
+    ${CMAKE_CURRENT_LIST_DIR}/G330AlgParamManager.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/G330AlgParamManager.hpp
+    ${CMAKE_CURRENT_LIST_DIR}/G330PresetManager.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/G330PresetManager.hpp
+    ${CMAKE_CURRENT_LIST_DIR}/G330DepthWorkModeManager.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/G330DepthWorkModeManager.hpp
+    ${CMAKE_CURRENT_LIST_DIR}/G330SensorStreamStrategy.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/G330SensorStreamStrategy.hpp
+    ${CMAKE_CURRENT_LIST_DIR}/G330PropertyAccessors.hpp
+    ${CMAKE_CURRENT_LIST_DIR}/G330PropertyAccessors.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/G330FrameTimestampCalculator.hpp
+    ${CMAKE_CURRENT_LIST_DIR}/G330FrameTimestampCalculator.cpp
+)
+
diff --git a/src/device/gemini330/G330AlgParamManager.cpp b/src/device/gemini330/G330AlgParamManager.cpp
new file mode 100644
index 00000000..7cbd0626
--- /dev/null
+++ b/src/device/gemini330/G330AlgParamManager.cpp
@@ -0,0 +1,420 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "G330AlgParamManager.hpp"
+#include "stream/StreamIntrinsicsManager.hpp"
+#include "stream/StreamExtrinsicsManager.hpp"
+#include "stream/StreamProfileFactory.hpp"
+#include "property/InternalProperty.hpp"
+#include "DevicePids.hpp"
+#include "exception/ObException.hpp"
+#include "publicfilters/IMUCorrector.hpp"
+
+#include <vector>
+#include <sstream>
+namespace libobsensor {
+
+bool findBestMatchedCameraParam(const std::vector<OBCameraParam> &cameraParamList, const std::shared_ptr<const VideoStreamProfile> &profile,
+                                OBCameraParam &result) {
+    bool found = false;
+    // match same resolution
+    for(auto &param: cameraParamList) {
+        auto streamType = profile->getType();
+        if((streamType == OB_STREAM_DEPTH || streamType == OB_STREAM_IR || streamType == OB_STREAM_IR_LEFT || streamType == OB_STREAM_IR_RIGHT)
+           && static_cast<uint32_t>(param.depthIntrinsic.width) == profile->getWidth()
+           && static_cast<uint32_t>(param.depthIntrinsic.height) == profile->getHeight()) {
+            found  = true;
+            result = param;
+            break;
+        }
+        else if(streamType == OB_STREAM_COLOR && static_cast<uint32_t>(param.rgbIntrinsic.width) == profile->getWidth()
+                && static_cast<uint32_t>(param.rgbIntrinsic.height) == profile->getHeight()) {
+            found  = true;
+            result = param;
+            break;
+        }
+    }
+
+    if(!found) {
+        // match same ratio
+        float ratio = (float)profile->getWidth() / profile->getHeight();
+        for(auto &param: cameraParamList) {
+            auto streamType = profile->getType();
+            if((streamType == OB_STREAM_DEPTH || streamType == OB_STREAM_IR || streamType == OB_STREAM_IR_LEFT || streamType == OB_STREAM_IR_RIGHT)
+               && (float)param.depthIntrinsic.width / param.depthIntrinsic.height == ratio) {
+                found  = true;
+                result = param;
+                break;
+            }
+            else if(streamType == OB_STREAM_COLOR && (float)param.rgbIntrinsic.width / param.rgbIntrinsic.height == ratio) {
+                found  = true;
+                result = param;
+                break;
+            }
+        }
+    }
+
+    return found;
+}
+
+G330AlgParamManager::G330AlgParamManager(IDevice *owner) : DisparityAlgParamManagerBase(owner) {
+    fetchParamFromDevice();
+    fixD2CParmaList();
+    registerBasicExtrinsics();
+}
+
+void G330AlgParamManager::fetchParamFromDevice() {
+
+    try {
+        auto owner           = getOwner();
+        auto propServer      = owner->getPropertyServer();
+        depthCalibParamList_ = propServer->getStructureDataListProtoV1_1_T<OBDepthCalibrationParam, 1>(OB_RAW_DATA_DEPTH_CALIB_PARAM);
+
+        const auto &depthCalib       = depthCalibParamList_.front();
+        disparityParam_.baseline     = depthCalib.baseline;
+        disparityParam_.zpd          = depthCalib.z0;
+        disparityParam_.fx           = depthCalib.focalPix;
+        disparityParam_.zpps         = depthCalib.z0 / depthCalib.focalPix;
+        disparityParam_.bitSize      = 14;  // low 14 bit
+        disparityParam_.dispIntPlace = 8;
+        disparityParam_.unit         = depthCalib.unit;
+        disparityParam_.dispOffset   = depthCalib.dispOffset;
+        disparityParam_.invalidDisp  = depthCalib.invalidDisp;
+        disparityParam_.packMode     = OB_DISP_PACK_ORIGINAL_NEW;
+        disparityParam_.isDualCamera = true;
+    }
+    catch(const std::exception &e) {
+        LOG_ERROR("Get depth calibration params failed! {}", e.what());
+    }
+
+    try {
+        auto owner           = getOwner();
+        auto propServer      = owner->getPropertyServer();
+        auto cameraParamList = propServer->getStructureDataListProtoV1_1_T<OBCameraParam_Internal_V0, 0>(OB_RAW_DATA_ALIGN_CALIB_PARAM);
+        for(auto &cameraParam: cameraParamList) {
+            OBCameraParam param;
+            param.depthIntrinsic = cameraParam.depthIntrinsic;
+            param.rgbIntrinsic   = cameraParam.rgbIntrinsic;
+            memcpy(&param.depthDistortion, &cameraParam.depthDistortion, sizeof(param.depthDistortion));
+            param.depthDistortion.model = OB_DISTORTION_BROWN_CONRADY;
+            memcpy(&param.rgbDistortion, &cameraParam.rgbDistortion, sizeof(param.rgbDistortion));
+            param.rgbDistortion.model = OB_DISTORTION_BROWN_CONRADY;
+            param.transform           = cameraParam.transform;
+            param.isMirrored          = false;
+            originCalibrationCameraParamList_.emplace_back(param);
+
+            std::stringstream ss;
+            ss << param;
+            LOG_DEBUG("-{}", ss.str());
+        }
+    }
+    catch(const std::exception &e) {
+        LOG_ERROR("Get depth calibration params failed! {}", e.what());
+    }
+
+    try {
+        auto owner            = getOwner();
+        auto propServer       = owner->getPropertyServer();
+        originD2cProfileList_ = propServer->getStructureDataListProtoV1_1_T<OBD2CProfile, 0>(OB_RAW_DATA_D2C_ALIGN_SUPPORT_PROFILE_LIST);
+    }
+    catch(const std::exception &e) {
+        LOG_ERROR("Get depth to color profile list failed! {}", e.what());
+    }
+
+    // imu param
+    std::vector<uint8_t> data;
+    BEGIN_TRY_EXECUTE({
+        auto owner      = getOwner();
+        auto propServer = owner->getPropertyServer();
+        propServer->getRawData(
+            OB_RAW_DATA_IMU_CALIB_PARAM,
+            [&](OBDataTranState state, OBDataChunk *dataChunk) {
+                if(state == DATA_TRAN_STAT_TRANSFERRING) {
+                    data.insert(data.end(), dataChunk->data, dataChunk->data + dataChunk->size);
+                }
+            },
+            PROP_ACCESS_INTERNAL);
+    })
+    CATCH_EXCEPTION_AND_EXECUTE({
+        LOG_ERROR("Get imu calibration params failed!");
+        data.clear();
+    })
+    if(!data.empty()) {
+        imuCalibParam_ = IMUCorrector::parserIMUCalibParamRaw(data.data(), static_cast<uint32_t>(data.size()));
+        LOG_DEBUG("Get imu calibration params success!");
+    }
+    else {
+        LOG_WARN("Get imu calibration params failed! Use default params instead!");
+        imuCalibParam_ = IMUCorrector::getDefaultImuCalibParam();
+    }
+}
+
+void G330AlgParamManager::reFetchDisparityParams() {
+    try {
+        auto owner           = getOwner();
+        auto propServer      = owner->getPropertyServer();
+        depthCalibParamList_ = propServer->getStructureDataListProtoV1_1_T<OBDepthCalibrationParam, 1>(OB_RAW_DATA_DEPTH_CALIB_PARAM);
+
+        const auto &depthCalib       = depthCalibParamList_.front();
+        disparityParam_.baseline     = depthCalib.baseline;
+        disparityParam_.zpd          = depthCalib.z0;
+        disparityParam_.fx           = depthCalib.focalPix;
+        disparityParam_.zpps         = depthCalib.z0 / depthCalib.focalPix;
+        disparityParam_.bitSize      = 14;  // low 14 bit
+        disparityParam_.dispIntPlace = 8;
+        disparityParam_.unit         = depthCalib.unit;
+        disparityParam_.dispOffset   = depthCalib.dispOffset;
+        disparityParam_.invalidDisp  = depthCalib.invalidDisp;
+        disparityParam_.packMode     = OB_DISP_PACK_ORIGINAL_NEW;
+        disparityParam_.isDualCamera = true;
+    }
+    catch(const std::exception &e) {
+        LOG_ERROR("Get depth calibration params failed! {}", e.what());
+    }
+}
+
+void G330AlgParamManager::registerBasicExtrinsics() {
+    auto extrinsicMgr              = StreamExtrinsicsManager::getInstance();
+    auto depthBasicStreamProfile   = StreamProfileFactory::createVideoStreamProfile(OB_STREAM_DEPTH, OB_FORMAT_ANY, OB_WIDTH_ANY, OB_HEIGHT_ANY, OB_FPS_ANY);
+    auto colorBasicStreamProfile   = StreamProfileFactory::createVideoStreamProfile(OB_STREAM_COLOR, OB_FORMAT_ANY, OB_WIDTH_ANY, OB_HEIGHT_ANY, OB_FPS_ANY);
+    auto leftIrBasicStreamProfile  = StreamProfileFactory::createVideoStreamProfile(OB_STREAM_IR_LEFT, OB_FORMAT_ANY, OB_WIDTH_ANY, OB_HEIGHT_ANY, OB_FPS_ANY);
+    auto rightIrBasicStreamProfile = StreamProfileFactory::createVideoStreamProfile(OB_STREAM_IR_RIGHT, OB_FORMAT_ANY, OB_WIDTH_ANY, OB_HEIGHT_ANY, OB_FPS_ANY);
+    auto accelBasicStreamProfile   = StreamProfileFactory::createAccelStreamProfile(OB_ACCEL_FS_2g, OB_SAMPLE_RATE_1_5625_HZ);
+    auto gyroBasicStreamProfile    = StreamProfileFactory::createGyroStreamProfile(OB_GYRO_FS_16dps, OB_SAMPLE_RATE_1_5625_HZ);
+
+    if(!originCalibrationCameraParamList_.empty()) {
+        auto d2cExtrinsic = originCalibrationCameraParamList_.front().transform;
+        extrinsicMgr->registerExtrinsics(depthBasicStreamProfile, colorBasicStreamProfile, d2cExtrinsic);
+    }
+    extrinsicMgr->registerSameExtrinsics(leftIrBasicStreamProfile, depthBasicStreamProfile);
+
+    if(!depthCalibParamList_.empty()) {
+        auto left_to_right     = IdentityExtrinsics;
+        left_to_right.trans[0] = -1.0f * depthCalibParamList_.front().baseline * depthCalibParamList_.front().unit;
+        extrinsicMgr->registerExtrinsics(leftIrBasicStreamProfile, rightIrBasicStreamProfile, left_to_right);
+    }
+
+    const auto &imuCalibParam = getIMUCalibrationParam();
+    double      imuExtr[16]   = { 0 };
+    memcpy(imuExtr, imuCalibParam.singleIMUParams[0].imu_to_cam_extrinsics, sizeof(imuExtr));
+
+    OBExtrinsic imu_to_depth;
+    imu_to_depth.rot[0] = (float)imuExtr[0];
+    imu_to_depth.rot[1] = (float)imuExtr[1];
+
+    imu_to_depth.rot[2]   = (float)imuExtr[2];
+    imu_to_depth.rot[3]   = (float)imuExtr[4];
+    imu_to_depth.rot[4]   = (float)imuExtr[5];
+    imu_to_depth.rot[5]   = (float)imuExtr[6];
+    imu_to_depth.rot[6]   = (float)imuExtr[8];
+    imu_to_depth.rot[7]   = (float)imuExtr[9];
+    imu_to_depth.rot[8]   = (float)imuExtr[10];
+    imu_to_depth.trans[0] = (float)imuExtr[3];
+    imu_to_depth.trans[1] = (float)imuExtr[7];
+    imu_to_depth.trans[2] = (float)imuExtr[11];
+    extrinsicMgr->registerExtrinsics(accelBasicStreamProfile, depthBasicStreamProfile, imu_to_depth);
+    extrinsicMgr->registerSameExtrinsics(gyroBasicStreamProfile, accelBasicStreamProfile);
+
+    basicStreamProfileList_.emplace_back(depthBasicStreamProfile);
+    basicStreamProfileList_.emplace_back(colorBasicStreamProfile);
+    basicStreamProfileList_.emplace_back(leftIrBasicStreamProfile);
+    basicStreamProfileList_.emplace_back(rightIrBasicStreamProfile);
+    basicStreamProfileList_.emplace_back(accelBasicStreamProfile);
+    basicStreamProfileList_.emplace_back(gyroBasicStreamProfile);
+}
+
+typedef struct {
+    uint32_t width;
+    uint32_t height;
+} Resolution;
+
+void G330AlgParamManager::fixD2CParmaList() {
+    std::vector<Resolution> appendColorResolutions = { { 1920, 1080 }, { 1280, 800 }, { 1280, 720 }, { 960, 540 }, { 848, 480 }, { 640, 480 },
+                                                       { 640, 400 },   { 640, 360 },  { 424, 270 },  { 424, 240 }, { 320, 240 }, { 320, 180 } };
+
+    const std::vector<Resolution> depthResolutions = { { 1280, 800 }, { 1280, 720 }, { 848, 480 }, { 640, 480 }, { 640, 400 },
+                                                       { 640, 360 },  { 480, 270 },  { 424, 240 }, { 848, 100 } };
+
+    auto owner      = getOwner();
+    auto deviceInfo = owner->getInfo();
+    auto iter       = std::find(G330LDevPids.begin(), G330LDevPids.end(), deviceInfo->pid_);
+
+    if(iter != G330LDevPids.end()) {
+        appendColorResolutions.push_back({ 480, 270 });
+    }
+
+    if(originD2cProfileList_.empty()) {
+        return;
+    }
+
+    d2cProfileList_ = originD2cProfileList_;
+    for(auto &profile: d2cProfileList_) {
+        profile.alignType = ALIGN_D2C_HW;
+    }
+
+    calibrationCameraParamList_ = originCalibrationCameraParamList_;
+    for(const auto &colorRes: appendColorResolutions) {
+        auto          colorProfile = StreamProfileFactory::createVideoStreamProfile(OB_STREAM_COLOR, OB_FORMAT_UNKNOWN, colorRes.width, colorRes.height, 30);
+        OBCameraParam colorAlignParam;
+        if(!findBestMatchedCameraParam(originCalibrationCameraParamList_, colorProfile, colorAlignParam)) {
+            continue;
+        }
+        OBCameraIntrinsic colorIntrinsic = colorAlignParam.rgbIntrinsic;
+        float             ratio          = (float)colorProfile->getWidth() / colorIntrinsic.width;
+        colorIntrinsic.fx *= ratio;
+        colorIntrinsic.fy *= ratio;
+        colorIntrinsic.cx *= ratio;
+        colorIntrinsic.cy *= ratio;
+        colorIntrinsic.width  = static_cast<int16_t>(colorProfile->getWidth());
+        colorIntrinsic.height = static_cast<int16_t>((float)colorIntrinsic.height * ratio);
+        for(const auto &depthRes: depthResolutions) {
+            auto depthProfile = StreamProfileFactory::createVideoStreamProfile(OB_STREAM_DEPTH, OB_FORMAT_UNKNOWN, depthRes.width, depthRes.height, 30);
+            OBCameraParam depthAlignParam;
+            if(!findBestMatchedCameraParam(originCalibrationCameraParamList_, depthProfile, depthAlignParam)) {
+                continue;
+            }
+            OBCameraIntrinsic depthIntrinsic = depthAlignParam.depthIntrinsic;
+            ratio                            = (float)depthProfile->getWidth() / depthIntrinsic.width;
+            depthIntrinsic.fx *= ratio;
+            depthIntrinsic.fy *= ratio;
+            depthIntrinsic.cx *= ratio;
+            depthIntrinsic.cy *= ratio;
+            depthIntrinsic.width  = static_cast<int16_t>(depthProfile->getWidth());
+            depthIntrinsic.height = static_cast<int16_t>((float)depthIntrinsic.height * ratio);
+
+            auto index = calibrationCameraParamList_.size();
+            calibrationCameraParamList_.push_back({ depthIntrinsic, colorIntrinsic, depthAlignParam.depthDistortion, depthAlignParam.rgbDistortion,
+                                                    depthAlignParam.transform, depthAlignParam.isMirrored });
+
+            OBD2CProfile d2cProfile;
+            d2cProfile.alignType        = ALIGN_D2C_SW;
+            d2cProfile.postProcessParam = { 1.0f, 0, 0, 0, 0 };
+            d2cProfile.colorWidth       = static_cast<int16_t>(colorProfile->getWidth());
+            d2cProfile.colorHeight      = static_cast<int16_t>(colorProfile->getHeight());
+            d2cProfile.depthWidth       = static_cast<int16_t>(depthProfile->getWidth());
+            d2cProfile.depthHeight      = static_cast<int16_t>(depthProfile->getHeight());
+            d2cProfile.paramIndex       = (uint8_t)index;
+            d2cProfileList_.push_back(d2cProfile);
+        }
+    }
+
+    // fix depth intrinsic according to post process param and rgb intrinsic
+    for(auto &profile: d2cProfileList_) {
+        if(profile.alignType != ALIGN_D2C_HW || profile.paramIndex >= calibrationCameraParamList_.size()) {
+            continue;
+        }
+        const auto &cameraParam = calibrationCameraParamList_.at(profile.paramIndex);
+
+        auto colorProfile = StreamProfileFactory::createVideoStreamProfile(OB_STREAM_COLOR, OB_FORMAT_UNKNOWN, profile.colorWidth, profile.colorHeight, 30);
+
+        OBCameraParam fixedCameraParam = cameraParam;
+        OBCameraParam matchedCameraParam;
+        if(!findBestMatchedCameraParam(originCalibrationCameraParamList_, colorProfile, matchedCameraParam)) {
+            continue;
+        }
+        fixedCameraParam.rgbIntrinsic = matchedCameraParam.rgbIntrinsic;
+
+        // scale the rgb(target) intrinsic to match the profile
+        auto ratio = (float)profile.colorWidth / fixedCameraParam.rgbIntrinsic.width;
+        fixedCameraParam.rgbIntrinsic.fx *= ratio;
+        fixedCameraParam.rgbIntrinsic.fy *= ratio;
+        fixedCameraParam.rgbIntrinsic.cx *= ratio;
+        fixedCameraParam.rgbIntrinsic.cy *= ratio;
+        fixedCameraParam.rgbIntrinsic.width  = static_cast<int16_t>((float)fixedCameraParam.rgbIntrinsic.width * ratio);
+        fixedCameraParam.rgbIntrinsic.height = static_cast<int16_t>((float)fixedCameraParam.rgbIntrinsic.height * ratio);
+
+        // Scale the rgb(target) intrinsic parameters by the same factor as the depth intrinsic scale.
+        auto depthRatio = (float)fixedCameraParam.depthIntrinsic.width / profile.depthWidth;
+        fixedCameraParam.rgbIntrinsic.fx *= depthRatio;
+        fixedCameraParam.rgbIntrinsic.fy *= depthRatio;
+        fixedCameraParam.rgbIntrinsic.cx *= depthRatio;
+        fixedCameraParam.rgbIntrinsic.cy *= depthRatio;
+        fixedCameraParam.rgbIntrinsic.width  = static_cast<int16_t>((float)fixedCameraParam.rgbIntrinsic.width * depthRatio);
+        fixedCameraParam.rgbIntrinsic.height = static_cast<int16_t>((float)fixedCameraParam.rgbIntrinsic.height * depthRatio);
+
+        // according to post process param to reverse process the rgb(target) intrinsic
+        fixedCameraParam.rgbIntrinsic.fx     = fixedCameraParam.rgbIntrinsic.fx / profile.postProcessParam.depthScale;
+        fixedCameraParam.rgbIntrinsic.fy     = fixedCameraParam.rgbIntrinsic.fy / profile.postProcessParam.depthScale;
+        fixedCameraParam.rgbIntrinsic.cx     = (fixedCameraParam.rgbIntrinsic.cx - profile.postProcessParam.alignLeft) / profile.postProcessParam.depthScale;
+        fixedCameraParam.rgbIntrinsic.cy     = (fixedCameraParam.rgbIntrinsic.cy - profile.postProcessParam.alignTop) / profile.postProcessParam.depthScale;
+        fixedCameraParam.rgbIntrinsic.width  = profile.depthWidth;
+        fixedCameraParam.rgbIntrinsic.height = profile.depthHeight;
+
+        auto index = calibrationCameraParamList_.size();
+        calibrationCameraParamList_.push_back(fixedCameraParam);
+        // auto oldProfile    = profile;
+        profile.paramIndex = (uint8_t)index;
+
+        // std::stringstream ss;
+        // ss << "Fix align calibration camera params:" << std::endl;
+        // ss << oldProfile << std::endl;
+        // ss << cameraParam.rgbIntrinsic << std::endl;
+        // ss << "to:" << std::endl;
+        // ss << profile << std::endl;
+        // ss << fixedCameraParam.rgbIntrinsic << std::endl;
+        // LOG_INFO("- {}", ss.str());
+    }
+
+    // LOG_DEBUG("Fixed align calibration camera params success! num={}", calibrationCameraParamList_.size());
+    // for(auto &&profile: d2cProfileList_) {
+    //     if(profile.paramIndex >= calibrationCameraParamList_.size()) {
+    //         continue;
+    //     }
+
+    //     std::stringstream ss;
+    //     ss << profile;
+    //     ss << std::endl;
+    //     ss << calibrationCameraParamList_[profile.paramIndex];
+    //     LOG_DEBUG("- {}", ss.str());
+    // }
+}
+
+void G330AlgParamManager::bindIntrinsic(std::vector<std::shared_ptr<const StreamProfile>> streamProfileList) {
+    auto intrinsicMgr = StreamIntrinsicsManager::getInstance();
+    for(const auto &sp: streamProfileList) {
+        if(sp->is<AccelStreamProfile>()) {
+            const auto &imuCalibParam = getIMUCalibrationParam();
+            intrinsicMgr->registerAccelStreamIntrinsics(sp, imuCalibParam.singleIMUParams[0].acc);
+        }
+        else if(sp->is<GyroStreamProfile>()) {
+            const auto &imuCalibParam = getIMUCalibrationParam();
+            intrinsicMgr->registerGyroStreamIntrinsics(sp, imuCalibParam.singleIMUParams[0].gyro);
+        }
+        else {
+            OBCameraIntrinsic  intrinsic  = { 0 };
+            OBCameraDistortion distortion = { 0 };
+            OBCameraParam      param{};
+            auto               vsp = sp->as<VideoStreamProfile>();
+            if(!findBestMatchedCameraParam(originCalibrationCameraParamList_, vsp, param)) {
+                // throw libobsensor::unsupported_operation_exception("Can not find matched camera param!");
+                continue;
+            }
+            switch(sp->getType()) {
+            case OB_STREAM_COLOR:
+                intrinsic  = param.rgbIntrinsic;
+                distortion = param.rgbDistortion;
+                break;
+            case OB_STREAM_DEPTH:
+            case OB_STREAM_IR:
+            case OB_STREAM_IR_LEFT:
+            case OB_STREAM_IR_RIGHT:
+                intrinsic  = param.depthIntrinsic;
+                distortion = param.depthDistortion;
+                break;
+            default:
+                break;
+            }
+            auto ratio = (float)vsp->getWidth() / (float)intrinsic.width;
+            intrinsic.fx *= ratio;
+            intrinsic.fy *= ratio;
+            intrinsic.cx *= ratio;
+            intrinsic.cy *= ratio;
+            intrinsic.width  = static_cast<int16_t>(vsp->getWidth());
+            intrinsic.height = static_cast<int16_t>((float)intrinsic.height * ratio);
+
+            intrinsicMgr->registerVideoStreamIntrinsics(sp, intrinsic);
+            intrinsicMgr->registerVideoStreamDistortion(sp, distortion);
+        }
+    }
+}
+}  // namespace libobsensor
diff --git a/src/device/gemini330/G330AlgParamManager.hpp b/src/device/gemini330/G330AlgParamManager.hpp
new file mode 100644
index 00000000..aed02095
--- /dev/null
+++ b/src/device/gemini330/G330AlgParamManager.hpp
@@ -0,0 +1,32 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include "param/AlgParamManager.hpp"
+
+#include <vector>
+#include <memory>
+
+namespace libobsensor {
+
+class G330AlgParamManager : public DisparityAlgParamManagerBase {
+public:
+    G330AlgParamManager(IDevice *owner);
+    virtual ~G330AlgParamManager() = default;
+
+    void bindIntrinsic(std::vector<std::shared_ptr<const StreamProfile>> streamProfileList) override;
+    void reFetchDisparityParams();
+
+private:
+    void fetchParamFromDevice() override;
+    void registerBasicExtrinsics() override;
+    void fixD2CParmaList();
+
+private:
+    std::vector<OBDepthCalibrationParam> depthCalibParamList_;
+    std::vector<OBCameraParam>           originCalibrationCameraParamList_;
+    std::vector<OBD2CProfile>            originD2cProfileList_;
+};
+
+}  // namespace libobsensor
diff --git a/src/device/gemini330/G330DepthWorkModeManager.cpp b/src/device/gemini330/G330DepthWorkModeManager.cpp
new file mode 100644
index 00000000..405701bb
--- /dev/null
+++ b/src/device/gemini330/G330DepthWorkModeManager.cpp
@@ -0,0 +1,64 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "G330DepthWorkModeManager.hpp"
+#include "property/InternalProperty.hpp"
+#include "logger/Logger.hpp"
+
+namespace libobsensor {
+
+G330DepthWorkModeManager::G330DepthWorkModeManager(IDevice *owner) : DeviceComponentBase(owner) {
+
+    auto propServer = owner->getPropertyServer();
+
+    depthWorkModeList_ = propServer->getStructureDataListProtoV1_1_T<OBDepthWorkMode_Internal, 0>(OB_RAW_DATA_DEPTH_ALG_MODE_LIST);
+    currentWorkMode_   = propServer->getStructureDataProtoV1_1_T<OBDepthWorkMode_Internal, 0>(OB_STRUCT_CURRENT_DEPTH_ALG_MODE);
+}
+
+std::vector<OBDepthWorkMode_Internal> G330DepthWorkModeManager::getDepthWorkModeList() const {
+    return depthWorkModeList_;
+}
+
+const OBDepthWorkMode_Internal &G330DepthWorkModeManager::getCurrentDepthWorkMode() const {
+    return currentWorkMode_;
+}
+
+void G330DepthWorkModeManager::switchDepthWorkMode(const std::string &modeName) {
+    auto iter =
+        std::find_if(depthWorkModeList_.begin(), depthWorkModeList_.end(), [&modeName](const OBDepthWorkMode_Internal &mode) { return modeName == mode.name; });
+
+    if(iter == depthWorkModeList_.end()) {
+        std::string totalNames;
+        std::for_each(depthWorkModeList_.begin(), depthWorkModeList_.end(), [&totalNames](const OBDepthWorkMode_Internal &mode) {
+            if(!totalNames.empty()) {
+                totalNames += ",";
+            }
+            totalNames += mode.name;
+        });
+        throw unsupported_operation_exception("Invalid depth mode: " + modeName + ", support depth work mode list: " + totalNames);
+    }
+
+    OBDepthWorkMode_Internal dstMode = *iter;
+    switchDepthWorkMode(dstMode);
+}
+
+void G330DepthWorkModeManager::switchDepthWorkMode(const OBDepthWorkMode_Internal &targetDepthMode) {
+    auto owner      = getOwner();
+    auto propServer = owner->getPropertyServer();  // get property server first to lock resource to avoid start stream at the same time
+
+    if(owner->hasAnySensorStreamActivated()) {
+        throw unsupported_operation_exception(utils::string::to_string()
+                                              << "Cannot switch depth work mode while any stream is started. Please stop all stream first!");
+    }
+
+    if(strncmp(currentWorkMode_.name, targetDepthMode.name, sizeof(targetDepthMode.name)) == 0) {
+        LOG_DEBUG("switchDepthWorkMode done with same mode: {1}", currentWorkMode_.name, targetDepthMode.name);
+        return;
+    }
+
+    propServer->setStructureDataProtoV1_1_T<OBDepthWorkMode_Internal, 0>(OB_STRUCT_CURRENT_DEPTH_ALG_MODE, targetDepthMode);
+    currentWorkMode_ = targetDepthMode;
+    LOG_DEBUG("switchDepthWorkMode done with mode: {1}", currentWorkMode_.name, targetDepthMode.name);
+}
+
+}  // namespace libobsensor
diff --git a/src/device/gemini330/G330DepthWorkModeManager.hpp b/src/device/gemini330/G330DepthWorkModeManager.hpp
new file mode 100644
index 00000000..e6baf6b2
--- /dev/null
+++ b/src/device/gemini330/G330DepthWorkModeManager.hpp
@@ -0,0 +1,29 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include "IDevice.hpp"
+#include "InternalTypes.hpp"
+#include "IDepthWorkModeManager.hpp"
+#include "DeviceComponentBase.hpp"
+
+namespace libobsensor {
+
+class G330DepthWorkModeManager : public IDepthWorkModeManager, public DeviceComponentBase {
+public:
+    G330DepthWorkModeManager(IDevice *owner);
+    virtual ~G330DepthWorkModeManager() = default;
+
+    std::vector<OBDepthWorkMode_Internal> getDepthWorkModeList() const override;
+    const OBDepthWorkMode_Internal       &getCurrentDepthWorkMode() const override;
+    void                                 switchDepthWorkMode(const std::string &modeName) override;
+
+private:
+    void switchDepthWorkMode(const OBDepthWorkMode_Internal &targetDepthMode);
+
+private:
+    std::vector<OBDepthWorkMode_Internal> depthWorkModeList_;
+    OBDepthWorkMode_Internal              currentWorkMode_;
+};
+
+}  // namespace libobsensor
diff --git a/src/device/gemini330/G330Device.cpp b/src/device/gemini330/G330Device.cpp
new file mode 100644
index 00000000..1d5ca85d
--- /dev/null
+++ b/src/device/gemini330/G330Device.cpp
@@ -0,0 +1,1153 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "G330Device.hpp"
+
+#include "DevicePids.hpp"
+#include "InternalTypes.hpp"
+
+#include "Platform.hpp"
+#include "utils/Utils.hpp"
+#include "environment/EnvConfig.hpp"
+#include "usb/uvc/UvcDevicePort.hpp"
+#include "stream/StreamProfileFactory.hpp"
+#include "sensor/video/VideoSensor.hpp"
+#include "sensor/video/DisparityBasedSensor.hpp"
+#include "sensor/imu/ImuStreamer.hpp"
+#include "sensor/imu/AccelSensor.hpp"
+#include "sensor/imu/GyroSensor.hpp"
+
+#include "FilterFactory.hpp"
+#include "publicfilters/FormatConverterProcess.hpp"
+
+#include "metadata/FrameMetadataParserContainer.hpp"
+#include "timestamp/GlobalTimestampFitter.hpp"
+#include "timestamp/FrameTimestampCalculator.hpp"
+#include "timestamp/DeviceClockSynchronizer.hpp"
+#include "property/VendorPropertyAccessor.hpp"
+#include "property/UvcPropertyAccessor.hpp"
+#include "property/PropertyServer.hpp"
+#include "property/CommonPropertyAccessors.hpp"
+#include "property/FilterPropertyAccessors.hpp"
+#include "property/PrivateFilterPropertyAccessors.hpp"
+#include "monitor/DeviceMonitor.hpp"
+#include "syncconfig/DeviceSyncConfigurator.hpp"
+#include "firmwareupdater/FirmwareUpdater.hpp"
+#include "frameprocessor/FrameProcessor.hpp"
+
+#include "G330MetadataParser.hpp"
+#include "G330MetadataTypes.hpp"
+#include "G330AlgParamManager.hpp"
+#include "G330PresetManager.hpp"
+#include "G330DepthWorkModeManager.hpp"
+#include "G330SensorStreamStrategy.hpp"
+#include "G330PropertyAccessors.hpp"
+#include "G330FrameMetadataParserContainer.hpp"
+
+#include <algorithm>
+
+namespace libobsensor {
+
+constexpr uint8_t  INTERFACE_COLOR        = 4;
+constexpr uint8_t  INTERFACE_DEPTH        = 0;
+constexpr uint16_t GMSL_MAX_CMD_DATA_SIZE = 232;
+
+G330Device::G330Device(const std::shared_ptr<const IDeviceEnumInfo> &info) : DeviceBase(info), isGmslDevice_(info->getConnectionType() == "GMSL2") {
+    init();
+}
+
+G330Device::~G330Device() noexcept {}
+
+void G330Device::init() {
+    if(isGmslDevice_) {
+        LOG_DEBUG("G330Device::init() for GMSL2 device");
+        initSensorListGMSL();
+    }
+    else {
+        initSensorList();
+    }
+    initProperties();
+
+    fetchDeviceInfo();
+    fetchExtensionInfo();
+
+    videoFrameTimestampCalculatorCreator_ = [this]() {
+        auto metadataType = OB_FRAME_METADATA_TYPE_TIMESTAMP;
+        auto iter         = std::find(G330LDevPids.begin(), G330LDevPids.end(), deviceInfo_->pid_);
+        if(iter == G330LDevPids.end()) {
+            metadataType = OB_FRAME_METADATA_TYPE_SENSOR_TIMESTAMP;
+        }
+        return std::make_shared<FrameTimestampCalculatorOverMetadata>(this, metadataType, frameTimeFreq_);
+    };
+
+    auto globalTimestampFilter = std::make_shared<GlobalTimestampFitter>(this);
+    registerComponent(OB_DEV_COMPONENT_GLOBAL_TIMESTAMP_FILTER, globalTimestampFilter);
+
+    auto algParamManager = std::make_shared<G330AlgParamManager>(this);
+    registerComponent(OB_DEV_COMPONENT_ALG_PARAM_MANAGER, algParamManager);
+
+    auto depthWorkModeManager = std::make_shared<G330DepthWorkModeManager>(this);
+    registerComponent(OB_DEV_COMPONENT_DEPTH_WORK_MODE_MANAGER, depthWorkModeManager);
+
+    auto presetManager = std::make_shared<G330PresetManager>(this);
+    registerComponent(OB_DEV_COMPONENT_PRESET_MANAGER, presetManager);
+
+    auto sensorStreamStrategy = std::make_shared<G330SensorStreamStrategy>(this);
+    registerComponent(OB_DEV_COMPONENT_SENSOR_STREAM_STRATEGY, sensorStreamStrategy);
+
+    static const std::vector<OBMultiDeviceSyncMode> supportedSyncModes = {
+        OB_MULTI_DEVICE_SYNC_MODE_FREE_RUN,         OB_MULTI_DEVICE_SYNC_MODE_STANDALONE,          OB_MULTI_DEVICE_SYNC_MODE_PRIMARY,
+        OB_MULTI_DEVICE_SYNC_MODE_SECONDARY_SYNCED, OB_MULTI_DEVICE_SYNC_MODE_SOFTWARE_TRIGGERING, OB_MULTI_DEVICE_SYNC_MODE_HARDWARE_TRIGGERING
+    };
+    auto deviceSyncConfigurator = std::make_shared<DeviceSyncConfigurator>(this, supportedSyncModes);
+    registerComponent(OB_DEV_COMPONENT_DEVICE_SYNC_CONFIGURATOR, deviceSyncConfigurator);
+
+    auto deviceClockSynchronizer = std::make_shared<DeviceClockSynchronizer>(this);
+    registerComponent(OB_DEV_COMPONENT_DEVICE_CLOCK_SYNCHRONIZER, deviceClockSynchronizer);
+
+    registerComponent(OB_DEV_COMPONENT_FRAME_PROCESSOR_FACTORY, [this]() {
+        std::shared_ptr<FrameProcessorFactory> factory;
+        TRY_EXECUTE({ factory = std::make_shared<FrameProcessorFactory>(this); })
+        return factory;
+    });
+
+    registerComponent(OB_DEV_COMPONENT_FIRMWARE_UPDATER, [this]() {
+        std::shared_ptr<FirmwareUpdater> firmwareUpdater;
+        TRY_EXECUTE({ firmwareUpdater = std::make_shared<FirmwareUpdater>(this); })
+        return firmwareUpdater;
+    });
+
+    registerComponent(OB_DEV_COMPONENT_COLOR_FRAME_METADATA_CONTAINER, [this]() {
+        std::shared_ptr<FrameMetadataParserContainer> container;
+        if(isGmslDevice_) {
+            // For GMSL2 device, color frame metadata is always parsed by G330ColorFrameMetadataParserContainer
+            container = std::make_shared<G330ColorFrameMetadataParserContainer>(this);
+            return container;
+        }
+
+        auto        envConfig                = EnvConfig::getInstance();
+        std::string frameMetadataParsingPath = "";
+        envConfig->getStringValue("Device.FrameMetadataParsingPath", frameMetadataParsingPath);
+        if(frameMetadataParsingPath == "ExtensionHeader") {
+            container = std::make_shared<G330ColorFrameMetadataParserContainer>(this);
+        }
+        else {
+            // default parsing path from payload header
+            container = std::make_shared<G330ColorFrameMetadataParserContainerByScr>(this, deviceTimeFreq_, frameTimeFreq_);
+        }
+        return container;
+    });
+
+    registerComponent(OB_DEV_COMPONENT_DEPTH_FRAME_METADATA_CONTAINER, [this]() {
+        std::shared_ptr<FrameMetadataParserContainer> container;
+        if(isGmslDevice_) {
+            // For GMSL2 device, depth frame metadata is always parsed by G330DepthFrameMetadataParserContainer
+            container = std::make_shared<G330DepthFrameMetadataParserContainer>(this);
+            return container;
+        }
+
+        auto        envConfig                = EnvConfig::getInstance();
+        std::string frameMetadataParsingPath = "";
+        envConfig->getStringValue("Device.FrameMetadataParsingPath", frameMetadataParsingPath);
+        if(frameMetadataParsingPath == "ExtensionHeader") {
+            container = std::make_shared<G330DepthFrameMetadataParserContainer>(this);
+        }
+        else {
+            // default parsing path from payload header
+            container = std::make_shared<G330DepthFrameMetadataParserContainerByScr>(this, deviceTimeFreq_, frameTimeFreq_);
+        }
+        return container;
+    });
+}
+
+std::shared_ptr<const StreamProfile> G330Device::loadDefaultStreamProfile(OBSensorType sensorType) {
+    std::shared_ptr<StreamProfile> defaultStreamProfile = nullptr;
+    LOG_DEBUG("loadDefaultStreamProfile: deviceConnectionType:={}", deviceInfo_->connectionType_);
+
+    OBStreamType defStreamType = OB_STREAM_UNKNOWN;
+    int          defFps        = 10;
+    int          defWidth      = 848;
+    int          defHeight     = 480;
+    OBFormat     defFormat     = OB_FORMAT_Y16;
+
+    // USB2.0 default resolution config
+    if(deviceInfo_->connectionType_ == "USB2.1") {
+        LOG_DEBUG("loadDefaultStreamProfile set USB2.1 device default stream profile.");
+        switch(sensorType) {
+        case OB_SENSOR_DEPTH:
+            defStreamType = OB_STREAM_DEPTH;
+            break;
+        case OB_SENSOR_IR_LEFT:
+            defFormat     = OB_FORMAT_Y8;
+            defStreamType = OB_STREAM_IR_LEFT;
+            break;
+        case OB_SENSOR_IR_RIGHT:
+            defFormat     = OB_FORMAT_Y8;
+            defStreamType = OB_STREAM_IR_RIGHT;
+            break;
+        case OB_SENSOR_IR:
+            defFormat     = OB_FORMAT_Y8;
+            defStreamType = OB_STREAM_IR;
+            break;
+        case OB_SENSOR_COLOR: {
+            defFormat     = OB_FORMAT_MJPG;
+            defStreamType = OB_STREAM_COLOR;
+            defWidth      = 1280;
+            defHeight     = 720;
+
+        } break;
+        default:
+            break;
+        }
+    }
+
+    // GMSL2 default resolution config
+    if(deviceInfo_->connectionType_ == "GMSL2") {
+        LOG_DEBUG("loadDefaultStreamProfile set GMSL2 device default stream profile.");
+        defFps = 30;
+        switch(sensorType) {
+        case OB_SENSOR_DEPTH:
+            defStreamType = OB_STREAM_DEPTH;
+            break;
+        case OB_SENSOR_IR_LEFT:
+            defFormat     = OB_FORMAT_Y8;
+            defStreamType = OB_STREAM_IR_LEFT;
+            break;
+        case OB_SENSOR_IR_RIGHT:
+            defFormat     = OB_FORMAT_Y8;
+            defStreamType = OB_STREAM_IR_RIGHT;
+            break;
+        case OB_SENSOR_IR:
+            defFormat     = OB_FORMAT_Y8;
+            defStreamType = OB_STREAM_IR;
+            break;
+        case OB_SENSOR_COLOR: {
+            defFormat     = OB_FORMAT_YUYV;
+            defStreamType = OB_STREAM_COLOR;
+            defWidth      = 1280;
+            defHeight     = 720;
+
+        } break;
+        default:
+            break;
+        }
+    }
+
+    if(defStreamType != OB_STREAM_UNKNOWN) {
+        defaultStreamProfile = StreamProfileFactory::createVideoStreamProfile(defStreamType, defFormat, defWidth, defHeight, defFps);
+        LOG_DEBUG("default profile StreamType:{}, Format:{}, Width:{}, Height:{}, Fps:{}", defStreamType, defFormat, defWidth, defHeight, defFps);
+    }
+
+    return defaultStreamProfile;
+}
+
+void G330Device::initSensorStreamProfile(std::shared_ptr<ISensor> sensor) {
+    auto streamProfile = StreamProfileFactory::getDefaultStreamProfileFromEnvConfig(deviceInfo_->name_, sensor->getSensorType());
+    if(streamProfile) {
+        auto defaultStreamProfile = loadDefaultStreamProfile(sensor->getSensorType());
+        if(defaultStreamProfile != nullptr) {
+            sensor->updateDefaultStreamProfile(defaultStreamProfile);
+        }
+        else {
+            sensor->updateDefaultStreamProfile(streamProfile);
+        }
+    }
+
+    // bind params: extrinsics, intrinsics, etc.
+    auto profiles = sensor->getStreamProfileList();
+    {
+        auto algParamManager = getComponentT<G330AlgParamManager>(OB_DEV_COMPONENT_ALG_PARAM_MANAGER);
+        algParamManager->bindStreamProfileParams(profiles);
+    }
+
+    auto sensorType = sensor->getSensorType();
+    LOG_INFO("Sensor {} created! Found {} stream profiles.", sensorType, profiles.size());
+    for(auto &profile: profiles) {
+        LOG_INFO(" - {}", profile);
+    }
+}
+
+void G330Device::initSensorList() {
+    registerComponent(OB_DEV_COMPONENT_FRAME_PROCESSOR_FACTORY, [this]() {
+        std::shared_ptr<FrameProcessorFactory> factory;
+        TRY_EXECUTE({ factory = std::make_shared<FrameProcessorFactory>(this); })
+        return factory;
+    });
+
+    auto        platform           = Platform::getInstance();
+    const auto &sourcePortInfoList = enumInfo_->getSourcePortInfoList();
+    auto depthPortInfoIter = std::find_if(sourcePortInfoList.begin(), sourcePortInfoList.end(), [](const std::shared_ptr<const SourcePortInfo> &portInfo) {
+        return portInfo->portType == SOURCE_PORT_USB_UVC && std::dynamic_pointer_cast<const USBSourcePortInfo>(portInfo)->infIndex == INTERFACE_DEPTH;
+    });
+
+    if(depthPortInfoIter != sourcePortInfoList.end()) {
+        auto depthPortInfo = *depthPortInfoIter;
+        registerComponent(
+            OB_DEV_COMPONENT_DEPTH_SENSOR,
+            [this, depthPortInfo]() {
+                auto platform = Platform::getInstance();
+                auto port     = platform->getSourcePort(depthPortInfo);
+                auto sensor   = std::make_shared<DisparityBasedSensor>(this, OB_SENSOR_DEPTH, port);
+
+                sensor->updateFormatFilterConfig({ { FormatFilterPolicy::REMOVE, OB_FORMAT_Y8, OB_FORMAT_ANY, nullptr },
+                                                   { FormatFilterPolicy::REMOVE, OB_FORMAT_NV12, OB_FORMAT_ANY, nullptr },
+                                                   { FormatFilterPolicy::REMOVE, OB_FORMAT_BGR, OB_FORMAT_ANY, nullptr },
+                                                   { FormatFilterPolicy::REMOVE, OB_FORMAT_BGRA, OB_FORMAT_ANY, nullptr },
+                                                   { FormatFilterPolicy::REMOVE, OB_FORMAT_BA81, OB_FORMAT_ANY, nullptr },
+                                                   { FormatFilterPolicy::REMOVE, OB_FORMAT_YV12, OB_FORMAT_ANY, nullptr },
+                                                   { FormatFilterPolicy::REMOVE, OB_FORMAT_UYVY, OB_FORMAT_ANY, nullptr },
+                                                   { FormatFilterPolicy::REPLACE, OB_FORMAT_Z16, OB_FORMAT_Y16, nullptr } });
+
+                auto depthMdParserContainer = getComponentT<IFrameMetadataParserContainer>(OB_DEV_COMPONENT_DEPTH_FRAME_METADATA_CONTAINER);
+                sensor->setFrameMetadataParserContainer(depthMdParserContainer.get());
+
+                auto frameTimestampCalculator = videoFrameTimestampCalculatorCreator_();
+                sensor->setFrameTimestampCalculator(frameTimestampCalculator);
+
+                auto globalFrameTimestampCalculator = std::make_shared<GlobalTimestampCalculator>(this, deviceTimeFreq_, frameTimeFreq_);
+                sensor->setGlobalTimestampCalculator(globalFrameTimestampCalculator);
+
+                auto frameProcessor = getComponentT<FrameProcessor>(OB_DEV_COMPONENT_DEPTH_FRAME_PROCESSOR, false);
+                if(frameProcessor) {
+                    sensor->setFrameProcessor(frameProcessor.get());
+                }
+
+                auto propServer = getPropertyServer();
+                auto depthUnit  = propServer->getPropertyValueT<float>(OB_PROP_DEPTH_UNIT_FLEXIBLE_ADJUSTMENT_FLOAT);
+                sensor->setDepthUnit(depthUnit);
+
+                auto hwD2D = propServer->getPropertyValueT<bool>(OB_PROP_DISPARITY_TO_DEPTH_BOOL);
+                sensor->markOutputDisparityFrame(!hwD2D);
+
+                initSensorStreamProfile(sensor);
+
+                sensor->registerStreamStateChangedCallback([&](OBStreamState state, const std::shared_ptr<const StreamProfile> &sp) {
+                    if(state == STREAM_STATE_STREAMING) {
+                        auto algParamManager = getComponentT<G330AlgParamManager>(OB_DEV_COMPONENT_ALG_PARAM_MANAGER);
+                        algParamManager->reFetchDisparityParams();
+                        algParamManager->bindDisparityParam({ sp });
+                    }
+                });
+
+                return sensor;
+            },
+            true);
+
+        registerSensorPortInfo(OB_SENSOR_DEPTH, depthPortInfo);
+
+        registerComponent(OB_DEV_COMPONENT_DEPTH_FRAME_PROCESSOR, [this]() {
+            auto factory        = getComponentT<FrameProcessorFactory>(OB_DEV_COMPONENT_FRAME_PROCESSOR_FACTORY);
+            auto frameProcessor = factory->createFrameProcessor(OB_SENSOR_DEPTH);
+            return frameProcessor;
+        });
+
+        registerComponent(
+            OB_DEV_COMPONENT_LEFT_IR_SENSOR,
+            [this, depthPortInfo]() {
+                auto platform = Platform::getInstance();
+                auto port     = platform->getSourcePort(depthPortInfo);
+                auto sensor   = std::make_shared<VideoSensor>(this, OB_SENSOR_IR_LEFT, port);
+
+                std::vector<FormatFilterConfig> formatFilterConfigs = {
+                    { FormatFilterPolicy::REMOVE, OB_FORMAT_Z16, OB_FORMAT_ANY, nullptr },  //
+                    { FormatFilterPolicy::REMOVE, OB_FORMAT_BA81, OB_FORMAT_ANY, nullptr },
+                    { FormatFilterPolicy::REMOVE, OB_FORMAT_YV12, OB_FORMAT_ANY, nullptr },
+                    { FormatFilterPolicy::REPLACE, OB_FORMAT_NV12, OB_FORMAT_Y12, nullptr },
+                    { FormatFilterPolicy::REMOVE, OB_FORMAT_BGR, OB_FORMAT_ANY, nullptr },
+                    { FormatFilterPolicy::REMOVE, OB_FORMAT_BGRA, OB_FORMAT_ANY, nullptr },
+                };
+
+                auto formatConverter = getSensorFrameFilter("FrameUnpacker", OB_SENSOR_IR_LEFT, false);
+                if(formatConverter) {
+                    formatFilterConfigs.push_back({ FormatFilterPolicy::REPLACE, OB_FORMAT_NV12, OB_FORMAT_Y16, formatConverter });
+                }
+
+                sensor->updateFormatFilterConfig(formatFilterConfigs);
+                auto depthMdParserContainer = getComponentT<IFrameMetadataParserContainer>(OB_DEV_COMPONENT_DEPTH_FRAME_METADATA_CONTAINER);
+                sensor->setFrameMetadataParserContainer(depthMdParserContainer.get());
+
+                auto frameTimestampCalculator = videoFrameTimestampCalculatorCreator_();
+                sensor->setFrameTimestampCalculator(frameTimestampCalculator);
+
+                auto globalFrameTimestampCalculator = std::make_shared<GlobalTimestampCalculator>(this, deviceTimeFreq_, frameTimeFreq_);
+                sensor->setGlobalTimestampCalculator(globalFrameTimestampCalculator);
+
+                auto frameProcessor = getComponentT<FrameProcessor>(OB_DEV_COMPONENT_LEFT_IR_FRAME_PROCESSOR, false);
+                if(frameProcessor) {
+                    sensor->setFrameProcessor(frameProcessor.get());
+                }
+
+                initSensorStreamProfile(sensor);
+
+                return sensor;
+            },
+            true);
+        registerSensorPortInfo(OB_SENSOR_IR_LEFT, depthPortInfo);
+
+        registerComponent(OB_DEV_COMPONENT_LEFT_IR_FRAME_PROCESSOR, [this]() {
+            auto factory        = getComponentT<FrameProcessorFactory>(OB_DEV_COMPONENT_FRAME_PROCESSOR_FACTORY);
+            auto frameProcessor = factory->createFrameProcessor(OB_SENSOR_IR_LEFT);
+            return frameProcessor;
+        });
+
+        registerComponent(
+            OB_DEV_COMPONENT_RIGHT_IR_SENSOR,
+            [this, depthPortInfo]() {
+                auto platform = Platform::getInstance();
+                auto port     = platform->getSourcePort(depthPortInfo);
+                auto sensor   = std::make_shared<VideoSensor>(this, OB_SENSOR_IR_RIGHT, port);
+
+                std::vector<FormatFilterConfig> formatFilterConfigs = {
+                    { FormatFilterPolicy::REMOVE, OB_FORMAT_Z16, OB_FORMAT_ANY, nullptr },   //
+                    { FormatFilterPolicy::REMOVE, OB_FORMAT_Y8, OB_FORMAT_ANY, nullptr },    //
+                    { FormatFilterPolicy::REMOVE, OB_FORMAT_NV12, OB_FORMAT_ANY, nullptr },  //
+                    { FormatFilterPolicy::REMOVE, OB_FORMAT_BGR, OB_FORMAT_ANY, nullptr },
+                    { FormatFilterPolicy::REMOVE, OB_FORMAT_BGRA, OB_FORMAT_ANY, nullptr },
+                    { FormatFilterPolicy::REMOVE, OB_FORMAT_UYVY, OB_FORMAT_ANY, nullptr },  //
+                    { FormatFilterPolicy::REPLACE, OB_FORMAT_BA81, OB_FORMAT_Y8, nullptr },  //
+                    { FormatFilterPolicy::REPLACE, OB_FORMAT_YV12, OB_FORMAT_Y12, nullptr },
+                };
+
+                auto formatConverter = getSensorFrameFilter("FrameUnpacker", OB_SENSOR_IR_RIGHT, false);
+                if(formatConverter) {
+                    formatFilterConfigs.push_back({ FormatFilterPolicy::REPLACE, OB_FORMAT_YV12, OB_FORMAT_Y16, formatConverter });
+                }
+
+                sensor->updateFormatFilterConfig(formatFilterConfigs);
+                auto depthMdParserContainer = getComponentT<IFrameMetadataParserContainer>(OB_DEV_COMPONENT_DEPTH_FRAME_METADATA_CONTAINER);
+                sensor->setFrameMetadataParserContainer(depthMdParserContainer.get());
+
+                auto frameTimestampCalculator = videoFrameTimestampCalculatorCreator_();
+                sensor->setFrameTimestampCalculator(frameTimestampCalculator);
+
+                auto globalFrameTimestampCalculator = std::make_shared<GlobalTimestampCalculator>(this, deviceTimeFreq_, frameTimeFreq_);
+                sensor->setGlobalTimestampCalculator(globalFrameTimestampCalculator);
+
+                auto frameProcessor = getComponentT<FrameProcessor>(OB_DEV_COMPONENT_RIGHT_IR_FRAME_PROCESSOR, false);
+                if(frameProcessor) {
+                    sensor->setFrameProcessor(frameProcessor.get());
+                }
+
+                initSensorStreamProfile(sensor);
+
+                return sensor;
+            },
+            true);
+        registerSensorPortInfo(OB_SENSOR_IR_RIGHT, depthPortInfo);
+
+        registerComponent(OB_DEV_COMPONENT_RIGHT_IR_FRAME_PROCESSOR, [this]() {
+            auto factory        = getComponentT<FrameProcessorFactory>(OB_DEV_COMPONENT_FRAME_PROCESSOR_FACTORY);
+            auto frameProcessor = factory->createFrameProcessor(OB_SENSOR_IR_RIGHT);
+            return frameProcessor;
+        });
+
+        // the main property accessor is using the depth port(uvc xu)
+        registerComponent(OB_DEV_COMPONENT_MAIN_PROPERTY_ACCESSOR, [this, depthPortInfo]() {
+            auto platform      = Platform::getInstance();
+            auto port          = platform->getSourcePort(depthPortInfo);
+            auto uvcDevicePort = std::dynamic_pointer_cast<UvcDevicePort>(port);
+            uvcDevicePort->updateXuUnit(OB_G330_XU_UNIT);  // update xu unit to g330 xu unit
+            auto accessor = std::make_shared<VendorPropertyAccessor>(this, port);
+            return accessor;
+        });
+
+        // The device monitor is using the depth port(uvc xu)
+        registerComponent(OB_DEV_COMPONENT_DEVICE_MONITOR, [this, depthPortInfo]() {
+            auto platform      = Platform::getInstance();
+            auto port          = platform->getSourcePort(depthPortInfo);
+            auto uvcDevicePort = std::dynamic_pointer_cast<UvcDevicePort>(port);
+            uvcDevicePort->updateXuUnit(OB_G330_XU_UNIT);  // update xu unit to g330 xu unit
+            auto devMonitor = std::make_shared<DeviceMonitor>(this, port);
+            return devMonitor;
+        });
+    }
+
+    auto colorPortInfoIter = std::find_if(sourcePortInfoList.begin(), sourcePortInfoList.end(), [](const std::shared_ptr<const SourcePortInfo> &portInfo) {
+        return portInfo->portType == SOURCE_PORT_USB_UVC && std::dynamic_pointer_cast<const USBSourcePortInfo>(portInfo)->infIndex == INTERFACE_COLOR;
+    });
+
+    if(colorPortInfoIter != sourcePortInfoList.end()) {
+        auto colorPortInfo = *colorPortInfoIter;
+        registerComponent(
+            OB_DEV_COMPONENT_COLOR_SENSOR,
+            [this, colorPortInfo]() {
+                auto platform = Platform::getInstance();
+                auto port     = platform->getSourcePort(colorPortInfo);
+                auto sensor   = std::make_shared<VideoSensor>(this, OB_SENSOR_COLOR, port);
+
+                std::vector<FormatFilterConfig> formatFilterConfigs = {
+                    { FormatFilterPolicy::REMOVE, OB_FORMAT_NV12, OB_FORMAT_ANY, nullptr },
+                    { FormatFilterPolicy::REPLACE, OB_FORMAT_BYR2, OB_FORMAT_RW16, nullptr },
+                };
+
+                auto formatConverter = getSensorFrameFilter("FormatConverter", OB_SENSOR_COLOR, false);
+                if(formatConverter) {
+                    formatFilterConfigs.push_back({ FormatFilterPolicy::ADD, OB_FORMAT_YUYV, OB_FORMAT_RGB, formatConverter });
+                    formatFilterConfigs.push_back({ FormatFilterPolicy::ADD, OB_FORMAT_YUYV, OB_FORMAT_RGBA, formatConverter });
+                    formatFilterConfigs.push_back({ FormatFilterPolicy::ADD, OB_FORMAT_YUYV, OB_FORMAT_BGR, formatConverter });
+                    formatFilterConfigs.push_back({ FormatFilterPolicy::ADD, OB_FORMAT_YUYV, OB_FORMAT_BGRA, formatConverter });
+                    formatFilterConfigs.push_back({ FormatFilterPolicy::ADD, OB_FORMAT_YUYV, OB_FORMAT_Y16, formatConverter });
+                    formatFilterConfigs.push_back({ FormatFilterPolicy::ADD, OB_FORMAT_YUYV, OB_FORMAT_Y8, formatConverter });
+                }
+
+                sensor->updateFormatFilterConfig(formatFilterConfigs);
+                auto colorMdParserContainer = getComponentT<IFrameMetadataParserContainer>(OB_DEV_COMPONENT_COLOR_FRAME_METADATA_CONTAINER);
+                sensor->setFrameMetadataParserContainer(colorMdParserContainer.get());
+
+                auto frameTimestampCalculator = videoFrameTimestampCalculatorCreator_();
+                sensor->setFrameTimestampCalculator(frameTimestampCalculator);
+
+                auto globalFrameTimestampCalculator = std::make_shared<GlobalTimestampCalculator>(this, deviceTimeFreq_, frameTimeFreq_);
+                sensor->setGlobalTimestampCalculator(globalFrameTimestampCalculator);
+
+                auto frameProcessor = getComponentT<FrameProcessor>(OB_DEV_COMPONENT_COLOR_FRAME_PROCESSOR, false);
+                if(frameProcessor) {
+                    sensor->setFrameProcessor(frameProcessor.get());
+                }
+
+                initSensorStreamProfile(sensor);
+
+                return sensor;
+            },
+            true);
+        registerSensorPortInfo(OB_SENSOR_COLOR, colorPortInfo);
+
+        registerComponent(OB_DEV_COMPONENT_COLOR_FRAME_PROCESSOR, [this]() {
+            auto factory        = getComponentT<FrameProcessorFactory>(OB_DEV_COMPONENT_FRAME_PROCESSOR_FACTORY);
+            auto frameProcessor = factory->createFrameProcessor(OB_SENSOR_COLOR);
+            return frameProcessor;
+        });
+    }
+
+    auto imuPortInfoIter = std::find_if(sourcePortInfoList.begin(), sourcePortInfoList.end(), [](const std::shared_ptr<const SourcePortInfo> &portInfo) {
+        return portInfo->portType == SOURCE_PORT_USB_HID;  //
+    });
+
+    if(imuPortInfoIter != sourcePortInfoList.end()) {
+        auto imuPortInfo = *imuPortInfoIter;
+
+        registerComponent(OB_DEV_COMPONENT_IMU_STREAMER, [this, imuPortInfo]() {
+            // the gyro and accel are both on the same port and share the same filter
+            auto platform           = Platform::getInstance();
+            auto port               = platform->getSourcePort(imuPortInfo);
+            auto imuCorrectorFilter = getSensorFrameFilter("IMUCorrector", OB_SENSOR_ACCEL, true);
+
+            auto dataStreamPort = std::dynamic_pointer_cast<IDataStreamPort>(port);
+            auto imuStreamer    = std::make_shared<ImuStreamer>(this, dataStreamPort, imuCorrectorFilter);
+            return imuStreamer;
+        });
+
+        registerComponent(
+            OB_DEV_COMPONENT_ACCEL_SENSOR,
+            [this, imuPortInfo]() {
+                auto platform             = Platform::getInstance();
+                auto port                 = platform->getSourcePort(imuPortInfo);
+                auto imuStreamer          = getComponentT<ImuStreamer>(OB_DEV_COMPONENT_IMU_STREAMER);
+                auto imuStreamerSharedPtr = imuStreamer.get();
+                auto sensor               = std::make_shared<AccelSensor>(this, port, imuStreamerSharedPtr);
+
+                auto globalFrameTimestampCalculator = std::make_shared<GlobalTimestampCalculator>(this, deviceTimeFreq_, frameTimeFreq_);
+                sensor->setGlobalTimestampCalculator(globalFrameTimestampCalculator);
+
+                initSensorStreamProfile(sensor);
+
+                return sensor;
+            },
+            true);
+        registerSensorPortInfo(OB_SENSOR_ACCEL, imuPortInfo);
+
+        registerComponent(
+            OB_DEV_COMPONENT_GYRO_SENSOR,
+            [this, imuPortInfo]() {
+                auto platform             = Platform::getInstance();
+                auto port                 = platform->getSourcePort(imuPortInfo);
+                auto imuStreamer          = getComponentT<ImuStreamer>(OB_DEV_COMPONENT_IMU_STREAMER);
+                auto imuStreamerSharedPtr = imuStreamer.get();
+                auto sensor               = std::make_shared<GyroSensor>(this, port, imuStreamerSharedPtr);
+
+                auto globalFrameTimestampCalculator = std::make_shared<GlobalTimestampCalculator>(this, deviceTimeFreq_, frameTimeFreq_);
+                sensor->setGlobalTimestampCalculator(globalFrameTimestampCalculator);
+
+                initSensorStreamProfile(sensor);
+
+                return sensor;
+            },
+            true);
+        registerSensorPortInfo(OB_SENSOR_GYRO, imuPortInfo);
+    }
+}
+
+static const uint8_t GMSL_INTERFACE_DEPTH    = 0;
+static const uint8_t GMSL_INTERFACE_IR       = 2;
+static const uint8_t GMSL_INTERFACE_IR_LEFT  = 2;
+static const uint8_t GMSL_INTERFACE_IR_RIGHT = 3;
+static const uint8_t GMSL_INTERFACE_COLOR    = 4;
+void                 G330Device::initSensorListGMSL() {
+    registerComponent(OB_DEV_COMPONENT_FRAME_PROCESSOR_FACTORY, [this]() {
+        std::shared_ptr<FrameProcessorFactory> factory;
+        TRY_EXECUTE({ factory = std::make_shared<FrameProcessorFactory>(this); })
+        return factory;
+    });
+
+    auto        platform           = Platform::getInstance();
+    const auto &sourcePortInfoList = enumInfo_->getSourcePortInfoList();
+    auto depthPortInfoIter = std::find_if(sourcePortInfoList.begin(), sourcePortInfoList.end(), [](const std::shared_ptr<const SourcePortInfo> &portInfo) {
+        return portInfo->portType == SOURCE_PORT_USB_UVC && std::dynamic_pointer_cast<const USBSourcePortInfo>(portInfo)->infIndex == GMSL_INTERFACE_DEPTH;
+    });
+    if(depthPortInfoIter != sourcePortInfoList.end()) {
+        auto depthPortInfo = *depthPortInfoIter;
+        registerComponent(
+            OB_DEV_COMPONENT_DEPTH_SENSOR,
+            [this, depthPortInfo]() {
+                auto platform = Platform::getInstance();
+                auto port     = platform->getSourcePort(depthPortInfo);
+                auto sensor   = std::make_shared<DisparityBasedSensor>(this, OB_SENSOR_DEPTH, port);
+
+                sensor->updateFormatFilterConfig({ { FormatFilterPolicy::REMOVE, OB_FORMAT_Y8, OB_FORMAT_ANY, nullptr },
+                                                   { FormatFilterPolicy::REMOVE, OB_FORMAT_NV12, OB_FORMAT_ANY, nullptr },
+                                                   { FormatFilterPolicy::REMOVE, OB_FORMAT_MJPG, OB_FORMAT_ANY, nullptr },
+                                                   { FormatFilterPolicy::REMOVE, OB_FORMAT_Y10, OB_FORMAT_ANY, nullptr },
+                                                   { FormatFilterPolicy::REMOVE, OB_FORMAT_Y14, OB_FORMAT_ANY, nullptr },
+                                                   { FormatFilterPolicy::REMOVE, OB_FORMAT_BA81, OB_FORMAT_ANY, nullptr },
+                                                   { FormatFilterPolicy::REMOVE, OB_FORMAT_YV12, OB_FORMAT_ANY, nullptr },
+                                                   { FormatFilterPolicy::REMOVE, OB_FORMAT_UYVY, OB_FORMAT_ANY, nullptr },
+                                                   { FormatFilterPolicy::REMOVE, OB_FORMAT_YUYV, OB_FORMAT_ANY, nullptr },
+                                                   { FormatFilterPolicy::REPLACE, OB_FORMAT_Z16, OB_FORMAT_Y16, nullptr },
+                                                   { FormatFilterPolicy::REMOVE, OB_FORMAT_BGR, OB_FORMAT_ANY, nullptr },
+                                                   { FormatFilterPolicy::REMOVE, OB_FORMAT_BGRA, OB_FORMAT_ANY, nullptr } });
+
+                auto depthMdParserContainer = getComponentT<IFrameMetadataParserContainer>(OB_DEV_COMPONENT_DEPTH_FRAME_METADATA_CONTAINER);
+                sensor->setFrameMetadataParserContainer(depthMdParserContainer.get());
+
+                auto frameTimestampCalculator = videoFrameTimestampCalculatorCreator_();
+                sensor->setFrameTimestampCalculator(frameTimestampCalculator);
+
+                auto globalFrameTimestampCalculator = std::make_shared<GlobalTimestampCalculator>(this, deviceTimeFreq_, frameTimeFreq_);
+                sensor->setGlobalTimestampCalculator(globalFrameTimestampCalculator);
+
+                auto frameProcessor = getComponentT<FrameProcessor>(OB_DEV_COMPONENT_DEPTH_FRAME_PROCESSOR, false);
+                if(frameProcessor) {
+                    sensor->setFrameProcessor(frameProcessor.get());
+                }
+
+                auto propServer = getPropertyServer();
+                auto depthUnit  = propServer->getPropertyValueT<float>(OB_PROP_DEPTH_UNIT_FLEXIBLE_ADJUSTMENT_FLOAT);
+                sensor->setDepthUnit(depthUnit);
+
+                auto hwD2D = propServer->getPropertyValueT<bool>(OB_PROP_DISPARITY_TO_DEPTH_BOOL);
+                sensor->markOutputDisparityFrame(!hwD2D);
+
+                initSensorStreamProfile(sensor);
+
+                sensor->registerStreamStateChangedCallback([&](OBStreamState state, const std::shared_ptr<const StreamProfile> &sp) {
+                    if(state == STREAM_STATE_STREAMING) {
+                        auto algParamManager = getComponentT<G330AlgParamManager>(OB_DEV_COMPONENT_ALG_PARAM_MANAGER);
+                        algParamManager->reFetchDisparityParams();
+                        algParamManager->bindDisparityParam({ sp });
+                    }
+                });
+
+                return sensor;
+            },
+            true);
+
+        registerSensorPortInfo(OB_SENSOR_DEPTH, depthPortInfo);
+
+        registerComponent(OB_DEV_COMPONENT_DEPTH_FRAME_PROCESSOR, [this]() {
+            auto factory        = getComponentT<FrameProcessorFactory>(OB_DEV_COMPONENT_FRAME_PROCESSOR_FACTORY);
+            auto frameProcessor = factory->createFrameProcessor(OB_SENSOR_DEPTH);
+            return frameProcessor;
+        });
+
+        // the main property accessor is using the depth port(uvc xu)
+        registerComponent(OB_DEV_COMPONENT_MAIN_PROPERTY_ACCESSOR, [this, depthPortInfo]() {
+            auto platform      = Platform::getInstance();
+            auto port          = platform->getSourcePort(depthPortInfo);
+            auto uvcDevicePort = std::dynamic_pointer_cast<UvcDevicePort>(port);
+            uvcDevicePort->updateXuUnit(OB_G330_XU_UNIT);  // update xu unit to g330 xu unit
+            auto accessor = std::make_shared<VendorPropertyAccessor>(this, port);
+            accessor->setRawdataTransferPacketSize(GMSL_MAX_CMD_DATA_SIZE);
+            accessor->setStructListDataTransferPacketSize(GMSL_MAX_CMD_DATA_SIZE);
+            return accessor;
+        });
+
+        // The device monitor is using the depth port(uvc xu)
+        registerComponent(OB_DEV_COMPONENT_DEVICE_MONITOR, [this, depthPortInfo]() {
+            auto platform      = Platform::getInstance();
+            auto port          = platform->getSourcePort(depthPortInfo);
+            auto uvcDevicePort = std::dynamic_pointer_cast<UvcDevicePort>(port);
+            uvcDevicePort->updateXuUnit(OB_G330_XU_UNIT);  // update xu unit to g330 xu unit
+            auto devMonitor = std::make_shared<DeviceMonitor>(this, port);
+            return devMonitor;
+        });
+    }
+
+    auto leftIrPortInfoIter = std::find_if(sourcePortInfoList.begin(), sourcePortInfoList.end(), [](const std::shared_ptr<const SourcePortInfo> &portInfo) {
+        return portInfo->portType == SOURCE_PORT_USB_UVC && std::dynamic_pointer_cast<const USBSourcePortInfo>(portInfo)->infIndex == GMSL_INTERFACE_IR_LEFT;
+    });
+    if(leftIrPortInfoIter != sourcePortInfoList.end()) {
+        auto leftIrPortInfo = *leftIrPortInfoIter;
+        registerComponent(
+            OB_DEV_COMPONENT_LEFT_IR_SENSOR,
+            [this, leftIrPortInfo]() {
+                auto platform = Platform::getInstance();
+                auto port     = platform->getSourcePort(leftIrPortInfo);
+                auto sensor   = std::make_shared<VideoSensor>(this, OB_SENSOR_IR_LEFT, port);
+
+                std::vector<FormatFilterConfig> formatFilterConfigs = {
+                    { FormatFilterPolicy::REMOVE, OB_FORMAT_Z16, OB_FORMAT_ANY, nullptr },   //
+                    { FormatFilterPolicy::REMOVE, OB_FORMAT_MJPG, OB_FORMAT_ANY, nullptr },  //
+                    { FormatFilterPolicy::REMOVE, OB_FORMAT_Y10, OB_FORMAT_ANY, nullptr },   //
+                    { FormatFilterPolicy::REMOVE, OB_FORMAT_Y14, OB_FORMAT_ANY, nullptr },   //
+                    { FormatFilterPolicy::REMOVE, OB_FORMAT_BA81, OB_FORMAT_ANY, nullptr },
+                    { FormatFilterPolicy::REMOVE, OB_FORMAT_NV12, OB_FORMAT_ANY, nullptr },
+                    { FormatFilterPolicy::REMOVE, OB_FORMAT_UYVY, OB_FORMAT_ANY, nullptr },
+                    { FormatFilterPolicy::REMOVE, OB_FORMAT_YUYV, OB_FORMAT_ANY, nullptr },
+                    { FormatFilterPolicy::REMOVE, OB_FORMAT_BGR, OB_FORMAT_ANY, nullptr },
+                    { FormatFilterPolicy::REMOVE, OB_FORMAT_BGRA, OB_FORMAT_ANY, nullptr }
+                    // { FormatFilterPolicy::REPLACE, OB_FORMAT_NV12, OB_FORMAT_Y12, nullptr },
+                };
+
+                auto formatConverter = getSensorFrameFilter("FrameUnpacker", OB_SENSOR_IR_LEFT, false);
+                if(formatConverter) {
+                    formatFilterConfigs.push_back({ FormatFilterPolicy::REPLACE, OB_FORMAT_YUYV, OB_FORMAT_Y16, formatConverter });
+                }
+
+                sensor->updateFormatFilterConfig(formatFilterConfigs);
+                auto depthMdParserContainer = getComponentT<IFrameMetadataParserContainer>(OB_DEV_COMPONENT_DEPTH_FRAME_METADATA_CONTAINER);
+                sensor->setFrameMetadataParserContainer(depthMdParserContainer.get());
+
+                auto frameTimestampCalculator = videoFrameTimestampCalculatorCreator_();
+                sensor->setFrameTimestampCalculator(frameTimestampCalculator);
+
+                auto globalFrameTimestampCalculator = std::make_shared<GlobalTimestampCalculator>(this, deviceTimeFreq_, frameTimeFreq_);
+                sensor->setGlobalTimestampCalculator(globalFrameTimestampCalculator);
+
+                auto frameProcessor = getComponentT<FrameProcessor>(OB_DEV_COMPONENT_LEFT_IR_FRAME_PROCESSOR, false);
+                if(frameProcessor) {
+                    sensor->setFrameProcessor(frameProcessor.get());
+                }
+
+                initSensorStreamProfile(sensor);
+
+                return sensor;
+            },
+            true);
+        registerSensorPortInfo(OB_SENSOR_IR_LEFT, leftIrPortInfo);
+
+        registerComponent(OB_DEV_COMPONENT_LEFT_IR_FRAME_PROCESSOR, [this]() {
+            auto factory        = getComponentT<FrameProcessorFactory>(OB_DEV_COMPONENT_FRAME_PROCESSOR_FACTORY);
+            auto frameProcessor = factory->createFrameProcessor(OB_SENSOR_IR_LEFT);
+            return frameProcessor;
+        });
+    }
+
+    auto rightIrPortInfoIter = std::find_if(sourcePortInfoList.begin(), sourcePortInfoList.end(), [](const std::shared_ptr<const SourcePortInfo> &portInfo) {
+        return portInfo->portType == SOURCE_PORT_USB_UVC && std::dynamic_pointer_cast<const USBSourcePortInfo>(portInfo)->infIndex == GMSL_INTERFACE_IR_RIGHT;
+    });
+    if(rightIrPortInfoIter != sourcePortInfoList.end()) {
+        auto rightIrPortInfo = *rightIrPortInfoIter;
+        registerComponent(
+            OB_DEV_COMPONENT_RIGHT_IR_SENSOR,
+            [this, rightIrPortInfo]() {
+                auto platform = Platform::getInstance();
+                auto port     = platform->getSourcePort(rightIrPortInfo);
+                auto sensor   = std::make_shared<VideoSensor>(this, OB_SENSOR_IR_RIGHT, port);
+
+                std::vector<FormatFilterConfig> formatFilterConfigs = { { FormatFilterPolicy::REMOVE, OB_FORMAT_Z16, OB_FORMAT_ANY, nullptr },  //
+                                                                        { FormatFilterPolicy::REMOVE, OB_FORMAT_MJPG, OB_FORMAT_ANY, nullptr },  //
+                                                                        { FormatFilterPolicy::REMOVE, OB_FORMAT_Y10, OB_FORMAT_ANY, nullptr },  //
+                                                                        { FormatFilterPolicy::REMOVE, OB_FORMAT_Y14, OB_FORMAT_ANY, nullptr },  //
+                                                                        { FormatFilterPolicy::REMOVE, OB_FORMAT_BA81, OB_FORMAT_ANY, nullptr },
+                                                                        { FormatFilterPolicy::REMOVE, OB_FORMAT_NV12, OB_FORMAT_ANY, nullptr },
+                                                                        { FormatFilterPolicy::REMOVE, OB_FORMAT_UYVY, OB_FORMAT_ANY, nullptr },
+                                                                        { FormatFilterPolicy::REMOVE, OB_FORMAT_YUYV, OB_FORMAT_ANY, nullptr },
+                                                                        { FormatFilterPolicy::REMOVE, OB_FORMAT_BGR, OB_FORMAT_ANY, nullptr },
+                                                                        { FormatFilterPolicy::REMOVE, OB_FORMAT_BGRA, OB_FORMAT_ANY, nullptr } };
+
+                auto formatConverter = getSensorFrameFilter("FrameUnpacker", OB_SENSOR_IR_RIGHT, false);
+                if(formatConverter) {
+                    formatFilterConfigs.push_back({ FormatFilterPolicy::REPLACE, OB_FORMAT_Y12, OB_FORMAT_Y16, formatConverter });
+                }
+
+                sensor->updateFormatFilterConfig(formatFilterConfigs);
+                auto depthMdParserContainer = getComponentT<IFrameMetadataParserContainer>(OB_DEV_COMPONENT_DEPTH_FRAME_METADATA_CONTAINER);
+                sensor->setFrameMetadataParserContainer(depthMdParserContainer.get());
+
+                auto frameTimestampCalculator = videoFrameTimestampCalculatorCreator_();
+                sensor->setFrameTimestampCalculator(frameTimestampCalculator);
+
+                auto globalFrameTimestampCalculator = std::make_shared<GlobalTimestampCalculator>(this, deviceTimeFreq_, frameTimeFreq_);
+                sensor->setGlobalTimestampCalculator(globalFrameTimestampCalculator);
+
+                auto frameProcessor = getComponentT<FrameProcessor>(OB_DEV_COMPONENT_RIGHT_IR_FRAME_PROCESSOR, false);
+                if(frameProcessor) {
+                    sensor->setFrameProcessor(frameProcessor.get());
+                }
+
+                initSensorStreamProfile(sensor);
+
+                return sensor;
+            },
+            true);
+        registerSensorPortInfo(OB_SENSOR_IR_RIGHT, rightIrPortInfo);
+
+        registerComponent(OB_DEV_COMPONENT_RIGHT_IR_FRAME_PROCESSOR, [this]() {
+            auto factory        = getComponentT<FrameProcessorFactory>(OB_DEV_COMPONENT_FRAME_PROCESSOR_FACTORY);
+            auto frameProcessor = factory->createFrameProcessor(OB_SENSOR_IR_RIGHT);
+            return frameProcessor;
+        });
+    }
+
+    auto colorPortInfoIter = std::find_if(sourcePortInfoList.begin(), sourcePortInfoList.end(), [](const std::shared_ptr<const SourcePortInfo> &portInfo) {
+        return portInfo->portType == SOURCE_PORT_USB_UVC && std::dynamic_pointer_cast<const USBSourcePortInfo>(portInfo)->infIndex == INTERFACE_COLOR;
+    });
+
+    if(colorPortInfoIter != sourcePortInfoList.end()) {
+        auto colorPortInfo = *colorPortInfoIter;
+        registerComponent(
+            OB_DEV_COMPONENT_COLOR_SENSOR,
+            [this, colorPortInfo]() {
+                auto platform = Platform::getInstance();
+                auto port     = platform->getSourcePort(colorPortInfo);
+                auto sensor   = std::make_shared<VideoSensor>(this, OB_SENSOR_COLOR, port);
+
+                std::vector<FormatFilterConfig> formatFilterConfigs = {
+                    { FormatFilterPolicy::REMOVE, OB_FORMAT_NV12, OB_FORMAT_ANY, nullptr },
+                    { FormatFilterPolicy::REMOVE, OB_FORMAT_Z16, OB_FORMAT_ANY, nullptr },
+                    { FormatFilterPolicy::REMOVE, OB_FORMAT_Y14, OB_FORMAT_ANY, nullptr },
+                    { FormatFilterPolicy::REMOVE, OB_FORMAT_MJPG, OB_FORMAT_ANY, nullptr },
+                    { FormatFilterPolicy::REMOVE, OB_FORMAT_Y10, OB_FORMAT_ANY, nullptr },
+                    { FormatFilterPolicy::REMOVE, OB_FORMAT_BA81, OB_FORMAT_ANY, nullptr },
+                    { FormatFilterPolicy::REMOVE, OB_FORMAT_Y8, OB_FORMAT_ANY, nullptr },
+                    { FormatFilterPolicy::REPLACE, OB_FORMAT_BYR2, OB_FORMAT_RW16, nullptr },
+                };
+
+                auto formatConverter = getSensorFrameFilter("FormatConverter", OB_SENSOR_COLOR, false);
+                if(formatConverter) {
+                    formatFilterConfigs.push_back({ FormatFilterPolicy::ADD, OB_FORMAT_YUYV, OB_FORMAT_RGB, formatConverter });
+                    formatFilterConfigs.push_back({ FormatFilterPolicy::ADD, OB_FORMAT_YUYV, OB_FORMAT_RGBA, formatConverter });
+                    formatFilterConfigs.push_back({ FormatFilterPolicy::ADD, OB_FORMAT_YUYV, OB_FORMAT_BGR, formatConverter });
+                    formatFilterConfigs.push_back({ FormatFilterPolicy::ADD, OB_FORMAT_YUYV, OB_FORMAT_BGRA, formatConverter });
+                    formatFilterConfigs.push_back({ FormatFilterPolicy::ADD, OB_FORMAT_YUYV, OB_FORMAT_Y16, formatConverter });
+                    formatFilterConfigs.push_back({ FormatFilterPolicy::ADD, OB_FORMAT_YUYV, OB_FORMAT_Y8, formatConverter });
+                }
+
+                sensor->updateFormatFilterConfig(formatFilterConfigs);
+                auto colorMdParserContainer = getComponentT<IFrameMetadataParserContainer>(OB_DEV_COMPONENT_COLOR_FRAME_METADATA_CONTAINER);
+                sensor->setFrameMetadataParserContainer(colorMdParserContainer.get());
+
+                auto frameTimestampCalculator = videoFrameTimestampCalculatorCreator_();
+                sensor->setFrameTimestampCalculator(frameTimestampCalculator);
+
+                auto globalFrameTimestampCalculator = std::make_shared<GlobalTimestampCalculator>(this, deviceTimeFreq_, frameTimeFreq_);
+                sensor->setGlobalTimestampCalculator(globalFrameTimestampCalculator);
+
+                auto frameProcessor = getComponentT<FrameProcessor>(OB_DEV_COMPONENT_COLOR_FRAME_PROCESSOR, false);
+                if(frameProcessor) {
+                    sensor->setFrameProcessor(frameProcessor.get());
+                }
+
+                initSensorStreamProfile(sensor);
+
+                return sensor;
+            },
+            true);
+        registerSensorPortInfo(OB_SENSOR_COLOR, colorPortInfo);
+
+        registerComponent(OB_DEV_COMPONENT_COLOR_FRAME_PROCESSOR, [this]() {
+            auto factory        = getComponentT<FrameProcessorFactory>(OB_DEV_COMPONENT_FRAME_PROCESSOR_FACTORY);
+            auto frameProcessor = factory->createFrameProcessor(OB_SENSOR_COLOR);
+            return frameProcessor;
+        });
+    }
+
+    auto imuPortInfoIter = std::find_if(sourcePortInfoList.begin(), sourcePortInfoList.end(), [](const std::shared_ptr<const SourcePortInfo> &portInfo) {
+        return portInfo->portType == SOURCE_PORT_USB_HID;  //
+    });
+
+    if(imuPortInfoIter != sourcePortInfoList.end()) {
+        auto imuPortInfo = *imuPortInfoIter;
+
+        registerComponent(OB_DEV_COMPONENT_IMU_STREAMER, [this, imuPortInfo]() {
+            // the gyro and accel are both on the same port and share the same filter
+            auto platform           = Platform::getInstance();
+            auto port               = platform->getSourcePort(imuPortInfo);
+            auto imuCorrectorFilter = getSensorFrameFilter("IMUCorrector", OB_SENSOR_ACCEL, true);
+
+            auto dataStreamPort = std::dynamic_pointer_cast<IDataStreamPort>(port);
+            auto imuStreamer    = std::make_shared<ImuStreamer>(this, dataStreamPort, imuCorrectorFilter);
+            return imuStreamer;
+        });
+
+        registerComponent(
+            OB_DEV_COMPONENT_ACCEL_SENSOR,
+            [this, imuPortInfo]() {
+                auto platform             = Platform::getInstance();
+                auto port                 = platform->getSourcePort(imuPortInfo);
+                auto imuStreamer          = getComponentT<ImuStreamer>(OB_DEV_COMPONENT_IMU_STREAMER);
+                auto imuStreamerSharedPtr = imuStreamer.get();
+                auto sensor               = std::make_shared<AccelSensor>(this, port, imuStreamerSharedPtr);
+
+                auto globalFrameTimestampCalculator = std::make_shared<GlobalTimestampCalculator>(this, deviceTimeFreq_, frameTimeFreq_);
+                sensor->setGlobalTimestampCalculator(globalFrameTimestampCalculator);
+                initSensorStreamProfile(sensor);
+
+                return sensor;
+            },
+            true);
+        registerSensorPortInfo(OB_SENSOR_ACCEL, imuPortInfo);
+
+        registerComponent(
+            OB_DEV_COMPONENT_GYRO_SENSOR,
+            [this, imuPortInfo]() {
+                auto platform             = Platform::getInstance();
+                auto port                 = platform->getSourcePort(imuPortInfo);
+                auto imuStreamer          = getComponentT<ImuStreamer>(OB_DEV_COMPONENT_IMU_STREAMER);
+                auto imuStreamerSharedPtr = imuStreamer.get();
+                auto sensor               = std::make_shared<GyroSensor>(this, port, imuStreamerSharedPtr);
+
+                auto globalFrameTimestampCalculator = std::make_shared<GlobalTimestampCalculator>(this, deviceTimeFreq_, frameTimeFreq_);
+                sensor->setGlobalTimestampCalculator(globalFrameTimestampCalculator);
+
+                initSensorStreamProfile(sensor);
+
+                return sensor;
+            },
+            true);
+        registerSensorPortInfo(OB_SENSOR_GYRO, imuPortInfo);
+    }
+}
+
+void G330Device::initProperties() {
+    auto propertyServer = std::make_shared<PropertyServer>(this);
+
+    auto d2dPropertyAccessor = std::make_shared<G330Disp2DepthPropertyAccessor>(this);
+    propertyServer->registerProperty(OB_PROP_DISPARITY_TO_DEPTH_BOOL, "rw", "rw", d2dPropertyAccessor);      // hw
+    propertyServer->registerProperty(OB_PROP_SDK_DISPARITY_TO_DEPTH_BOOL, "rw", "rw", d2dPropertyAccessor);  // sw
+    propertyServer->registerProperty(OB_PROP_DEPTH_UNIT_FLEXIBLE_ADJUSTMENT_FLOAT, "rw", "rw", d2dPropertyAccessor);
+
+    auto privatePropertyAccessor = std::make_shared<PrivateFilterPropertyAccessor>(this);
+    propertyServer->registerProperty(OB_PROP_DEPTH_SOFT_FILTER_BOOL, "rw", "rw", privatePropertyAccessor);
+    propertyServer->registerProperty(OB_PROP_DEPTH_MAX_DIFF_INT, "rw", "rw", privatePropertyAccessor);
+    propertyServer->registerProperty(OB_PROP_DEPTH_MAX_SPECKLE_SIZE_INT, "rw", "rw", privatePropertyAccessor);
+
+    auto sensors = getSensorTypeList();
+    for(auto &sensor: sensors) {
+        auto  platform       = Platform::getInstance();
+        auto &sourcePortInfo = getSensorPortInfo(sensor);
+        if(sensor == OB_SENSOR_COLOR) {
+            auto uvcPropertyAccessor = std::make_shared<LazyPropertyAccessor>([&sourcePortInfo]() {
+                auto platform = Platform::getInstance();
+                auto port     = platform->getSourcePort(sourcePortInfo);
+                auto accessor = std::make_shared<UvcPropertyAccessor>(port);
+                return accessor;
+            });
+
+            propertyServer->registerProperty(OB_PROP_COLOR_AUTO_EXPOSURE_BOOL, "rw", "rw", uvcPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_COLOR_GAIN_INT, "rw", "rw", uvcPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_COLOR_SATURATION_INT, "rw", "rw", uvcPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_COLOR_AUTO_WHITE_BALANCE_BOOL, "rw", "rw", uvcPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_COLOR_WHITE_BALANCE_INT, "rw", "rw", uvcPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_COLOR_BRIGHTNESS_INT, "rw", "rw", uvcPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_COLOR_SHARPNESS_INT, "rw", "rw", uvcPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_COLOR_CONTRAST_INT, "rw", "rw", uvcPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_COLOR_HUE_INT, "rw", "rw", uvcPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_COLOR_GAMMA_INT, "rw", "rw", uvcPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_COLOR_POWER_LINE_FREQUENCY_INT, "rw", "rw", uvcPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_COLOR_BACKLIGHT_COMPENSATION_INT, "rw", "rw", uvcPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_COLOR_AUTO_EXPOSURE_PRIORITY_INT, "rw", "rw", uvcPropertyAccessor);
+        }
+        else if(sensor == OB_SENSOR_DEPTH) {
+            auto uvcPropertyAccessor = std::make_shared<LazyPropertyAccessor>([&sourcePortInfo]() {
+                auto platform = Platform::getInstance();
+                auto port     = platform->getSourcePort(sourcePortInfo);
+                auto accessor = std::make_shared<UvcPropertyAccessor>(port);
+                return accessor;
+            });
+            propertyServer->registerProperty(OB_PROP_DEPTH_GAIN_INT, "rw", "rw", uvcPropertyAccessor);
+
+            auto vendorPropertyAccessor = std::make_shared<LazySuperPropertyAccessor>([this, &sourcePortInfo]() {
+                auto accessor = getComponentT<IPropertyAccessor>(OB_DEV_COMPONENT_MAIN_PROPERTY_ACCESSOR);
+                return accessor.get();
+            });
+
+            propertyServer->registerProperty(OB_PROP_DEPTH_AUTO_EXPOSURE_BOOL, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_DEPTH_AUTO_EXPOSURE_PRIORITY_INT, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_DEPTH_EXPOSURE_INT, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_COLOR_EXPOSURE_INT, "rw", "rw", vendorPropertyAccessor);  // using vendor property accessor
+            propertyServer->registerProperty(OB_PROP_LDP_BOOL, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_LASER_CONTROL_INT, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_LASER_ALWAYS_ON_BOOL, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_LASER_ON_OFF_PATTERN_INT, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_TEMPERATURE_COMPENSATION_BOOL, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_LDP_STATUS_BOOL, "r", "r", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_DEPTH_ALIGN_HARDWARE_BOOL, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_LASER_POWER_LEVEL_CONTROL_INT, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_LDP_MEASURE_DISTANCE_INT, "r", "r", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_TIMER_RESET_SIGNAL_BOOL, "w", "w", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_TIMER_RESET_TRIGGER_OUT_ENABLE_BOOL, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_TIMER_RESET_DELAY_US_INT, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_SYNC_SIGNAL_TRIGGER_OUT_BOOL, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_CAPTURE_IMAGE_SIGNAL_BOOL, "w", "w", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_CAPTURE_IMAGE_FRAME_NUMBER_INT, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_STRUCT_VERSION, "r", "r", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_STRUCT_DEVICE_TEMPERATURE, "r", "r", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_STRUCT_DEVICE_TIME, "", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_STRUCT_CURRENT_DEPTH_ALG_MODE, "", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_STRUCT_DEVICE_SERIAL_NUMBER, "r", "r", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_STRUCT_ASIC_SERIAL_NUMBER, "r", "r", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_STRUCT_MULTI_DEVICE_SYNC_CONFIG, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_RAW_DATA_DEPTH_CALIB_PARAM, "", "r", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_RAW_DATA_ALIGN_CALIB_PARAM, "", "r", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_RAW_DATA_D2C_ALIGN_SUPPORT_PROFILE_LIST, "", "r", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_STRUCT_DEPTH_HDR_CONFIG, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_STRUCT_COLOR_AE_ROI, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_STRUCT_DEPTH_AE_ROI, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_RAW_DATA_IMU_CALIB_PARAM, "", "rw", vendorPropertyAccessor);
+
+            // todo: add these properties to the frame processor
+            // propertyServer->registerProperty(OB_PROP_SDK_DEPTH_FRAME_UNPACK_BOOL, "rw", "rw", vendorPropertyAccessor);
+
+            propertyServer->registerProperty(OB_PROP_EXTERNAL_SIGNAL_RESET_BOOL, "rw", "rw", vendorPropertyAccessor);
+            // propertyServer->registerProperty(OB_PROP_GPM_BOOL, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_LASER_POWER_ACTUAL_LEVEL_INT, "r", "r", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_STRUCT_DEVICE_TIME, "", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_GYRO_ODR_INT, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_ACCEL_ODR_INT, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_ACCEL_SWITCH_BOOL, "", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_GYRO_SWITCH_BOOL, "", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_GYRO_FULL_SCALE_INT, "", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_ACCEL_FULL_SCALE_INT, "", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_STRUCT_GET_ACCEL_PRESETS_ODR_LIST, "", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_STRUCT_GET_ACCEL_PRESETS_FULL_SCALE_LIST, "", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_STRUCT_GET_GYRO_PRESETS_ODR_LIST, "", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_STRUCT_GET_GYRO_PRESETS_FULL_SCALE_LIST, "", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_IR_BRIGHTNESS_INT, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_RAW_DATA_DEVICE_EXTENSION_INFORMATION, "", "r", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_IR_AE_MAX_EXPOSURE_INT, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_COLOR_AE_MAX_EXPOSURE_INT, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_DISP_SEARCH_RANGE_MODE_INT, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_SLAVE_DEVICE_SYNC_STATUS_BOOL, "r", "r", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_DEVICE_RESET_BOOL, "", "w", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_RAW_DATA_DEPTH_ALG_MODE_LIST, "", "r", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_STRUCT_CURRENT_DEPTH_ALG_MODE, "", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_STOP_IR_STREAM_BOOL, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_STOP_COLOR_STREAM_BOOL, "rw", "rw", vendorPropertyAccessor);
+            propertyServer->registerProperty(OB_PROP_STOP_DEPTH_STREAM_BOOL, "rw", "rw", vendorPropertyAccessor);
+            if(isGmslDevice_) {
+                propertyServer->registerProperty(OB_PROP_DEVICE_REPOWER_BOOL, "w", "w", vendorPropertyAccessor);
+            }
+            else {
+                propertyServer->registerProperty(OB_PROP_DEVICE_USB2_REPEAT_IDENTIFY_BOOL, "rw", "rw", vendorPropertyAccessor);
+            }
+        }
+        else if(sensor == OB_SENSOR_ACCEL) {
+            auto imuCorrectorFilter = getSensorFrameFilter("IMUCorrector", sensor);
+            if(imuCorrectorFilter) {
+                auto filterStateProperty = std::make_shared<FilterStatePropertyAccessor>(imuCorrectorFilter);
+                propertyServer->registerProperty(OB_PROP_SDK_ACCEL_FRAME_TRANSFORMED_BOOL, "rw", "rw", filterStateProperty);
+            }
+        }
+        else if(sensor == OB_SENSOR_GYRO) {
+            auto imuCorrectorFilter = getSensorFrameFilter("IMUCorrector", sensor);
+            if(imuCorrectorFilter) {
+                auto filterStateProperty = std::make_shared<FilterStatePropertyAccessor>(imuCorrectorFilter);
+                propertyServer->registerProperty(OB_PROP_SDK_GYRO_FRAME_TRANSFORMED_BOOL, "rw", "rw", filterStateProperty);
+            }
+        }
+    }
+
+    propertyServer->aliasProperty(OB_PROP_IR_AUTO_EXPOSURE_BOOL, OB_PROP_DEPTH_AUTO_EXPOSURE_BOOL);
+    propertyServer->aliasProperty(OB_PROP_IR_EXPOSURE_INT, OB_PROP_DEPTH_EXPOSURE_INT);
+    propertyServer->aliasProperty(OB_PROP_IR_GAIN_INT, OB_PROP_DEPTH_GAIN_INT);
+
+    auto heartbeatPropertyAccessor = std::make_shared<HeartbeatPropertyAccessor>(this);
+    propertyServer->registerProperty(OB_PROP_HEARTBEAT_BOOL, "rw", "rw", heartbeatPropertyAccessor);
+
+    auto baseLinePropertyAccessor = std::make_shared<BaselinePropertyAccessor>(this);
+    propertyServer->registerProperty(OB_STRUCT_BASELINE_CALIBRATION_PARAM, "r", "r", baseLinePropertyAccessor);
+
+    registerComponent(OB_DEV_COMPONENT_PROPERTY_SERVER, propertyServer, true);
+}
+
+std::vector<std::shared_ptr<IFilter>> G330Device::createRecommendedPostProcessingFilters(OBSensorType type) {
+    auto filterFactory = FilterFactory::getInstance();
+    if(type == OB_SENSOR_DEPTH) {
+        // activate depth frame processor library
+        getComponentT<FrameProcessor>(OB_DEV_COMPONENT_DEPTH_FRAME_PROCESSOR, false);
+
+        std::vector<std::shared_ptr<IFilter>> depthFilterList;
+
+        if(filterFactory->isFilterCreatorExists("DecimationFilter")) {
+            auto decimationFilter = filterFactory->createFilter("DecimationFilter");
+            depthFilterList.push_back(decimationFilter);
+        }
+
+        if(filterFactory->isFilterCreatorExists("HDRMerge")) {
+            auto hdrMergeFilter = filterFactory->createFilter("HDRMerge");
+            depthFilterList.push_back(hdrMergeFilter);
+        }
+
+        if(filterFactory->isFilterCreatorExists("SequenceIdFilter")) {
+            auto sequenceIdFilter = filterFactory->createFilter("SequenceIdFilter");
+            depthFilterList.push_back(sequenceIdFilter);
+        }
+
+        if(filterFactory->isFilterCreatorExists("SpatialAdvancedFilter")) {
+            auto spatFilter = filterFactory->createFilter("SpatialAdvancedFilter");
+            // magnitude, alpha, disp_diff, radius
+            std::vector<std::string> params = { "1", "0.5", "160", "1" };
+            spatFilter->updateConfig(params);
+            depthFilterList.push_back(spatFilter);
+        }
+
+        if(filterFactory->isFilterCreatorExists("TemporalFilter")) {
+            auto tempFilter = filterFactory->createFilter("TemporalFilter");
+            // diff_scale, weight
+            std::vector<std::string> params = { "0.1", "0.4" };
+            tempFilter->updateConfig(params);
+            depthFilterList.push_back(tempFilter);
+        }
+
+        if(filterFactory->isFilterCreatorExists("HoleFillingFilter")) {
+            auto                     hfFilter = filterFactory->createFilter("HoleFillingFilter");
+            std::vector<std::string> params   = { "2" };
+            hfFilter->updateConfig(params);
+            depthFilterList.push_back(hfFilter);
+        }
+
+        if(filterFactory->isFilterCreatorExists("DisparityTransform")) {
+            auto dtFilter = filterFactory->createFilter("DisparityTransform");
+            depthFilterList.push_back(dtFilter);
+        }
+
+        if(filterFactory->isFilterCreatorExists("ThresholdFilter")) {
+            auto ThresholdFilter = filterFactory->createFilter("ThresholdFilter");
+            depthFilterList.push_back(ThresholdFilter);
+        }
+
+        for(size_t i = 0; i < depthFilterList.size(); i++) {
+            auto filter = depthFilterList[i];
+            if(filter->getName() != "DisparityTransform") {
+                filter->enable(false);
+            }
+        }
+        return depthFilterList;
+    }
+    else if(type == OB_SENSOR_COLOR) {
+        // activate color frame processor library
+        getComponentT<FrameProcessor>(OB_DEV_COMPONENT_COLOR_FRAME_PROCESSOR, false);
+
+        std::vector<std::shared_ptr<IFilter>> colorFilterList;
+        if(filterFactory->isFilterCreatorExists("DecimationFilter")) {
+            auto decimationFilter = filterFactory->createFilter("DecimationFilter");
+            decimationFilter->enable(false);
+            colorFilterList.push_back(decimationFilter);
+        }
+        return colorFilterList;
+    }
+
+    return {};
+}
+}  // namespace libobsensor
diff --git a/src/device/gemini330/G330Device.hpp b/src/device/gemini330/G330Device.hpp
new file mode 100644
index 00000000..1e2d2e0a
--- /dev/null
+++ b/src/device/gemini330/G330Device.hpp
@@ -0,0 +1,37 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include "DeviceBase.hpp"
+#include "IDeviceManager.hpp"
+
+#include <map>
+#include <memory>
+
+namespace libobsensor {
+
+class G330Device : public DeviceBase {
+public:
+    G330Device(const std::shared_ptr<const IDeviceEnumInfo> &info);
+    virtual ~G330Device() noexcept;
+
+    std::vector<std::shared_ptr<IFilter>> createRecommendedPostProcessingFilters(OBSensorType type) override;
+
+private:
+    void init() override;
+    void initSensorList();
+    void initSensorListGMSL();
+    void initProperties();
+    void initSensorStreamProfile(std::shared_ptr<ISensor> sensor);
+
+    std::shared_ptr<const StreamProfile> loadDefaultStreamProfile(OBSensorType sensorType);
+
+private:
+    const uint64_t                                              deviceTimeFreq_ = 1000;     // in ms
+    const uint64_t                                              frameTimeFreq_  = 1000000;  // in us
+    std::function<std::shared_ptr<IFrameTimestampCalculator>()> videoFrameTimestampCalculatorCreator_;
+    bool                                                        isGmslDevice_;
+};
+
+}  // namespace libobsensor
+
diff --git a/src/device/gemini330/G330DeviceInfo.cpp b/src/device/gemini330/G330DeviceInfo.cpp
new file mode 100644
index 00000000..48561313
--- /dev/null
+++ b/src/device/gemini330/G330DeviceInfo.cpp
@@ -0,0 +1,80 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "G330DeviceInfo.hpp"
+#include "G330Device.hpp"
+#include "DevicePids.hpp"
+#include "usb/UsbPortGroup.hpp"
+#include "ethernet/NetPortGroup.hpp"
+#include "utils/Utils.hpp"
+
+#include <map>
+
+namespace libobsensor {
+
+const std::map<int, std::string> G300DeviceNameMap = {
+    { 0x06d0, "Gemini 2R" },     { 0x06d1, "Gemini 2RL" },   { 0x0800, "Gemini 335" },   { 0x0801, "Gemini 330" },
+    { 0x0802, "Gemini dm330" },  { 0x0803, "Gemini 336" },   { 0x0804, "Gemini 335L" },  { 0x0805, "Gemini 330L" },
+    { 0x0806, "Gemini dm330L" }, { 0x0807, "Gemini 336L" },  { 0x080B, "Gemini 335Lg" }, { 0x080C, "Gemini 330Lg" },
+    { 0x080D, "Gemini 336Lg" },  { 0x080E, "Gemini 335Le" }, { 0x080F, "Gemini 330Le" }, { 0x0810, "Gemini 336Le" },
+};
+
+G330DeviceInfo::G330DeviceInfo(const SourcePortInfoList groupedInfoList) {
+    auto portInfo = std::dynamic_pointer_cast<const USBSourcePortInfo>(groupedInfoList.front());
+
+    auto iter = G300DeviceNameMap.find(portInfo->pid);
+    if(iter != G300DeviceNameMap.end()) {
+        name_ = iter->second;
+    }
+    else {
+        name_ = "Gemini 300 series device";
+    }
+
+    fullName_ = "Orbbec " + name_;
+
+    pid_                = portInfo->pid;
+    vid_                = portInfo->vid;
+    uid_                = portInfo->uid;
+    deviceSn_           = portInfo->serial;
+    connectionType_     = portInfo->connSpec;
+    sourcePortInfoList_ = groupedInfoList;
+}
+
+G330DeviceInfo::~G330DeviceInfo() noexcept {}
+
+std::shared_ptr<IDevice> G330DeviceInfo::createDevice() const {
+    return std::make_shared<G330Device>(shared_from_this());
+}
+
+std::vector<std::shared_ptr<IDeviceEnumInfo>> G330DeviceInfo::pickDevices(const SourcePortInfoList infoList) {
+    std::vector<std::shared_ptr<IDeviceEnumInfo>> G330DeviceInfos;
+
+    // pick usb device
+    auto remainder = FilterUSBPortInfoByPid(infoList, G330DevPids);
+    auto groups    = utils::groupVector<std::shared_ptr<const SourcePortInfo>>(remainder, GroupUSBSourcePortByUrl);
+    auto iter      = groups.begin();
+    while(iter != groups.end()) {
+        if(iter->size() >= 3) {
+            auto info = std::make_shared<G330DeviceInfo>(*iter);
+            G330DeviceInfos.push_back(info);
+        }
+        iter++;
+    }
+
+    // pick ethernet device
+    remainder = FilterNetPortInfoByPid(infoList, G330DevPids);
+    groups    = utils::groupVector<std::shared_ptr<const SourcePortInfo>>(remainder, GroupNetSourcePortByMac);
+    iter      = groups.begin();
+    while(iter != groups.end()) {
+        if(iter->size() >= 3) {
+            auto info = std::make_shared<G330DeviceInfo>(*iter);
+            G330DeviceInfos.push_back(info);
+        }
+        iter++;
+    }
+
+    return G330DeviceInfos;
+}
+
+}  // namespace libobsensor
+
diff --git a/src/device/gemini330/G330DeviceInfo.hpp b/src/device/gemini330/G330DeviceInfo.hpp
new file mode 100644
index 00000000..12094966
--- /dev/null
+++ b/src/device/gemini330/G330DeviceInfo.hpp
@@ -0,0 +1,25 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include "devicemanager/DeviceEnumInfoBase.hpp"
+
+#include <iostream>
+#include <string>
+#include <vector>
+#include <memory>
+
+namespace libobsensor {
+
+class G330DeviceInfo : public DeviceEnumInfoBase, public std::enable_shared_from_this<G330DeviceInfo> {
+public:
+    G330DeviceInfo(const SourcePortInfoList groupedInfoList);
+    ~G330DeviceInfo() noexcept;
+
+    std::shared_ptr<IDevice> createDevice() const override;
+
+    static std::vector<std::shared_ptr<IDeviceEnumInfo>> pickDevices(const SourcePortInfoList infoList);
+};
+
+}  // namespace libobsensor
+
diff --git a/src/device/gemini330/G330FrameMetadataParserContainer.hpp b/src/device/gemini330/G330FrameMetadataParserContainer.hpp
new file mode 100644
index 00000000..e88fceeb
--- /dev/null
+++ b/src/device/gemini330/G330FrameMetadataParserContainer.hpp
@@ -0,0 +1,148 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include "metadata/FrameMetadataParserContainer.hpp"
+#include "G330MetadataTypes.hpp"
+#include "G330MetadataParser.hpp"
+
+namespace libobsensor {
+
+class G330ColorFrameMetadataParserContainer : public FrameMetadataParserContainer {
+public:
+    G330ColorFrameMetadataParserContainer(IDevice *owner) : FrameMetadataParserContainer(owner) {
+        registerParser(OB_FRAME_METADATA_TYPE_TIMESTAMP, std::make_shared<G330MetadataTimestampParser<G330ColorUvcMetadata>>());
+        registerParser(OB_FRAME_METADATA_TYPE_SENSOR_TIMESTAMP,
+                       std::make_shared<G330ColorMetadataSensorTimestampParser>([](const int64_t &param) { return param * 100; }));
+        registerParser(OB_FRAME_METADATA_TYPE_FRAME_NUMBER, makeStructureMetadataParser(&G330CommonUvcMetadata::frame_counter));
+        // todo: calculate actual fps according exposure and frame rate
+        registerParser(OB_FRAME_METADATA_TYPE_ACTUAL_FRAME_RATE, makeStructureMetadataParser(&G330ColorUvcMetadata::actual_fps));
+
+        registerParser(OB_FRAME_METADATA_TYPE_AUTO_EXPOSURE,
+                       makeStructureMetadataParser(&G330CommonUvcMetadata::bitmap_union_0,
+                                                   [](const int64_t &param) {  //
+                                                       return ((G330ColorUvcMetadata::bitmap_union_0_fields *)&param)->auto_exposure;
+                                                   }));
+        registerParser(OB_FRAME_METADATA_TYPE_EXPOSURE, makeStructureMetadataParser(&G330CommonUvcMetadata::exposure));
+        registerParser(OB_FRAME_METADATA_TYPE_GAIN, makeStructureMetadataParser(&G330ColorUvcMetadata::gain_level));
+        registerParser(OB_FRAME_METADATA_TYPE_AUTO_WHITE_BALANCE, makeStructureMetadataParser(&G330ColorUvcMetadata::auto_white_balance));
+        registerParser(OB_FRAME_METADATA_TYPE_WHITE_BALANCE, makeStructureMetadataParser(&G330ColorUvcMetadata::white_balance));
+        registerParser(OB_FRAME_METADATA_TYPE_BRIGHTNESS, makeStructureMetadataParser(&G330ColorUvcMetadata::brightness));
+        registerParser(OB_FRAME_METADATA_TYPE_CONTRAST, makeStructureMetadataParser(&G330ColorUvcMetadata::contrast));
+        registerParser(OB_FRAME_METADATA_TYPE_SATURATION, makeStructureMetadataParser(&G330ColorUvcMetadata::saturation));
+        registerParser(OB_FRAME_METADATA_TYPE_SHARPNESS, makeStructureMetadataParser(&G330ColorUvcMetadata::sharpness));
+        registerParser(OB_FRAME_METADATA_TYPE_BACKLIGHT_COMPENSATION, makeStructureMetadataParser(&G330ColorUvcMetadata::backlight_compensation));
+        registerParser(OB_FRAME_METADATA_TYPE_GAMMA, makeStructureMetadataParser(&G330ColorUvcMetadata::gamma));
+        registerParser(OB_FRAME_METADATA_TYPE_HUE, makeStructureMetadataParser(&G330ColorUvcMetadata::hue));
+        registerParser(OB_FRAME_METADATA_TYPE_POWER_LINE_FREQUENCY, makeStructureMetadataParser(&G330ColorUvcMetadata::power_line_frequency));
+        registerParser(OB_FRAME_METADATA_TYPE_LOW_LIGHT_COMPENSATION, makeStructureMetadataParser(&G330ColorUvcMetadata::low_light_compensation));
+        registerParser(OB_FRAME_METADATA_TYPE_AE_ROI_LEFT, makeStructureMetadataParser(&G330ColorUvcMetadata::exposure_roi_left));
+        registerParser(OB_FRAME_METADATA_TYPE_AE_ROI_TOP, makeStructureMetadataParser(&G330ColorUvcMetadata::exposure_roi_top));
+        registerParser(OB_FRAME_METADATA_TYPE_AE_ROI_RIGHT, makeStructureMetadataParser(&G330ColorUvcMetadata::exposure_roi_right));
+        registerParser(OB_FRAME_METADATA_TYPE_AE_ROI_BOTTOM, makeStructureMetadataParser(&G330ColorUvcMetadata::exposure_roi_bottom));
+    }
+
+    virtual ~G330ColorFrameMetadataParserContainer() = default;
+};
+
+class G330DepthFrameMetadataParserContainer : public FrameMetadataParserContainer {
+public:
+    G330DepthFrameMetadataParserContainer(IDevice *owner) : FrameMetadataParserContainer(owner) {
+        registerParser(OB_FRAME_METADATA_TYPE_TIMESTAMP, std::make_shared<G330MetadataTimestampParser<G330DepthUvcMetadata>>());
+        registerParser(OB_FRAME_METADATA_TYPE_SENSOR_TIMESTAMP, std::make_shared<G330MetadataSensorTimestampParser>());
+        registerParser(OB_FRAME_METADATA_TYPE_FRAME_NUMBER, makeStructureMetadataParser(&G330DepthUvcMetadata::frame_counter));
+        // todo: calculate actual fps according exposure and frame rate
+        registerParser(OB_FRAME_METADATA_TYPE_ACTUAL_FRAME_RATE, makeStructureMetadataParser(&G330DepthUvcMetadata::actual_fps));
+        registerParser(OB_FRAME_METADATA_TYPE_GAIN, makeStructureMetadataParser(&G330DepthUvcMetadata::gain_level));
+        registerParser(OB_FRAME_METADATA_TYPE_AUTO_EXPOSURE,
+                       makeStructureMetadataParser(&G330CommonUvcMetadata::bitmap_union_0,
+                                                   [](const uint64_t &param) {  //
+                                                       return ((G330ColorUvcMetadata::bitmap_union_0_fields *)&param)->auto_exposure;
+                                                   }));
+        registerParser(OB_FRAME_METADATA_TYPE_EXPOSURE, makeStructureMetadataParser(&G330CommonUvcMetadata::exposure));
+        registerParser(OB_FRAME_METADATA_TYPE_EXPOSURE_PRIORITY, makeStructureMetadataParser(&G330DepthUvcMetadata::exposure_priority));
+        registerParser(OB_FRAME_METADATA_TYPE_LASER_POWER, makeStructureMetadataParser(&G330DepthUvcMetadata::laser_power));
+        registerParser(OB_FRAME_METADATA_TYPE_LASER_POWER_LEVEL, makeStructureMetadataParser(&G330DepthUvcMetadata::laser_power_level));
+        registerParser(OB_FRAME_METADATA_TYPE_LASER_STATUS, makeStructureMetadataParser(&G330DepthUvcMetadata::laser_status));
+        registerParser(OB_FRAME_METADATA_TYPE_AE_ROI_LEFT, makeStructureMetadataParser(&G330DepthUvcMetadata::exposure_roi_left));
+        registerParser(OB_FRAME_METADATA_TYPE_AE_ROI_TOP, makeStructureMetadataParser(&G330DepthUvcMetadata::exposure_roi_top));
+        registerParser(OB_FRAME_METADATA_TYPE_AE_ROI_RIGHT, makeStructureMetadataParser(&G330DepthUvcMetadata::exposure_roi_right));
+        registerParser(OB_FRAME_METADATA_TYPE_AE_ROI_BOTTOM, makeStructureMetadataParser(&G330DepthUvcMetadata::exposure_roi_bottom));
+        registerParser(OB_FRAME_METADATA_TYPE_GPIO_INPUT_DATA, makeStructureMetadataParser(&G330DepthUvcMetadata::gpio_input_data));
+        registerParser(OB_FRAME_METADATA_TYPE_HDR_SEQUENCE_NAME, makeStructureMetadataParser(&G330DepthUvcMetadata::sequence_name));
+        registerParser(OB_FRAME_METADATA_TYPE_HDR_SEQUENCE_SIZE, makeStructureMetadataParser(&G330DepthUvcMetadata::sequence_size));
+        registerParser(OB_FRAME_METADATA_TYPE_HDR_SEQUENCE_INDEX, makeStructureMetadataParser(&G330DepthUvcMetadata::sequence_id));
+    }
+
+    virtual ~G330DepthFrameMetadataParserContainer() = default;
+};
+
+class G330ColorFrameMetadataParserContainerByScr : public FrameMetadataParserContainer {
+public:
+    G330ColorFrameMetadataParserContainerByScr(IDevice *owner, const uint64_t deviceTimeFreq, const uint64_t frameTimeFreq)
+        : FrameMetadataParserContainer(owner) {
+        auto device = getOwner();
+
+        registerParser(OB_FRAME_METADATA_TYPE_TIMESTAMP, std::make_shared<G330PayloadHeadMetadataTimestampParser>(device, deviceTimeFreq, frameTimeFreq));
+        registerParser(OB_FRAME_METADATA_TYPE_SENSOR_TIMESTAMP,
+                       std::make_shared<G330PayloadHeadMetadataColorSensorTimestampParser>(device, deviceTimeFreq, frameTimeFreq));
+        registerParser(OB_FRAME_METADATA_TYPE_GAIN, std::make_shared<G330ColorScrMetadataGainParser>());
+        registerParser(OB_FRAME_METADATA_TYPE_EXPOSURE, std::make_shared<G330ColorScrMetadataExposureParser>());
+        registerParser(OB_FRAME_METADATA_TYPE_ACTUAL_FRAME_RATE, std::make_shared<G330ColorScrMetadataActualFrameRateParser>(device));
+
+        registerParser(OB_FRAME_METADATA_TYPE_AUTO_EXPOSURE, std::make_shared<G330ColorMetadataParser>(device, OB_FRAME_METADATA_TYPE_AUTO_EXPOSURE));
+        registerParser(OB_FRAME_METADATA_TYPE_AUTO_WHITE_BALANCE, std::make_shared<G330ColorMetadataParser>(device, OB_FRAME_METADATA_TYPE_AUTO_WHITE_BALANCE));
+        registerParser(OB_FRAME_METADATA_TYPE_WHITE_BALANCE, std::make_shared<G330ColorMetadataParser>(device, OB_FRAME_METADATA_TYPE_WHITE_BALANCE));
+        registerParser(OB_FRAME_METADATA_TYPE_BRIGHTNESS, std::make_shared<G330ColorMetadataParser>(device, OB_FRAME_METADATA_TYPE_BRIGHTNESS));
+        registerParser(OB_FRAME_METADATA_TYPE_CONTRAST, std::make_shared<G330ColorMetadataParser>(device, OB_FRAME_METADATA_TYPE_CONTRAST));
+        registerParser(OB_FRAME_METADATA_TYPE_SATURATION, std::make_shared<G330ColorMetadataParser>(device, OB_FRAME_METADATA_TYPE_SATURATION));
+        registerParser(OB_FRAME_METADATA_TYPE_SHARPNESS, std::make_shared<G330ColorMetadataParser>(device, OB_FRAME_METADATA_TYPE_SHARPNESS));
+        registerParser(OB_FRAME_METADATA_TYPE_BACKLIGHT_COMPENSATION,
+                       std::make_shared<G330ColorMetadataParser>(device, OB_FRAME_METADATA_TYPE_BACKLIGHT_COMPENSATION));
+        registerParser(OB_FRAME_METADATA_TYPE_GAMMA, std::make_shared<G330ColorMetadataParser>(device, OB_FRAME_METADATA_TYPE_GAMMA));
+        registerParser(OB_FRAME_METADATA_TYPE_HUE, std::make_shared<G330ColorMetadataParser>(device, OB_FRAME_METADATA_TYPE_HUE));
+        registerParser(OB_FRAME_METADATA_TYPE_POWER_LINE_FREQUENCY,
+                       std::make_shared<G330ColorMetadataParser>(device, OB_FRAME_METADATA_TYPE_POWER_LINE_FREQUENCY));
+        registerParser(OB_FRAME_METADATA_TYPE_LOW_LIGHT_COMPENSATION,
+                       std::make_shared<G330ColorMetadataParser>(device, OB_FRAME_METADATA_TYPE_LOW_LIGHT_COMPENSATION));
+        registerParser(OB_FRAME_METADATA_TYPE_AE_ROI_LEFT, std::make_shared<G330ColorMetadataParser>(device, OB_FRAME_METADATA_TYPE_AE_ROI_LEFT));
+        registerParser(OB_FRAME_METADATA_TYPE_AE_ROI_TOP, std::make_shared<G330ColorMetadataParser>(device, OB_FRAME_METADATA_TYPE_AE_ROI_TOP));
+        registerParser(OB_FRAME_METADATA_TYPE_AE_ROI_RIGHT, std::make_shared<G330ColorMetadataParser>(device, OB_FRAME_METADATA_TYPE_AE_ROI_RIGHT));
+        registerParser(OB_FRAME_METADATA_TYPE_AE_ROI_BOTTOM, std::make_shared<G330ColorMetadataParser>(device, OB_FRAME_METADATA_TYPE_AE_ROI_BOTTOM));
+    };
+};
+
+class G330DepthFrameMetadataParserContainerByScr : public FrameMetadataParserContainer {
+public:
+    G330DepthFrameMetadataParserContainerByScr(IDevice *owner, const uint64_t deviceTimeFreq, const uint64_t frameTimeFreq)
+        : FrameMetadataParserContainer(owner) {
+        auto device = getOwner();
+        registerParser(OB_FRAME_METADATA_TYPE_TIMESTAMP, std::make_shared<G330PayloadHeadMetadataTimestampParser>(device, deviceTimeFreq, frameTimeFreq));
+        registerParser(OB_FRAME_METADATA_TYPE_SENSOR_TIMESTAMP,
+                       std::make_shared<G330PayloadHeadMetadataDepthSensorTimestampParser>(device, deviceTimeFreq, frameTimeFreq));
+        registerParser(OB_FRAME_METADATA_TYPE_GAIN, std::make_shared<G330DepthScrMetadataGainParser>());
+        registerParser(OB_FRAME_METADATA_TYPE_EXPOSURE, std::make_shared<G330DepthScrMetadataExposureParser>());
+        registerParser(OB_FRAME_METADATA_TYPE_ACTUAL_FRAME_RATE, std::make_shared<G330DepthScrMetadataActualFrameRateParser>(device));
+
+        // registerParser(OB_FRAME_METADATA_TYPE_EXPOSURE_PRIORITY,
+        // std::make_shared<G330DepthMetadataParser>(device, OB_FRAME_METADATA_TYPE_EXPOSURE_PRIORITY));
+        registerParser(OB_FRAME_METADATA_TYPE_LASER_POWER,
+                       std::make_shared<G330DepthScrMetadataLaserPowerLevelParser>([](const int64_t &param) { return param * 60; }));
+        registerParser(OB_FRAME_METADATA_TYPE_LASER_POWER_LEVEL, std::make_shared<G330DepthScrMetadataLaserPowerLevelParser>());
+        registerParser(OB_FRAME_METADATA_TYPE_LASER_STATUS, std::make_shared<G330DepthScrMetadataLaserStatusParser>());
+        registerParser(OB_FRAME_METADATA_TYPE_HDR_SEQUENCE_INDEX, std::make_shared<G330DepthScrMetadataHDRSequenceIDParser>());
+        registerParser(OB_FRAME_METADATA_TYPE_FRAME_NUMBER,
+                       std::make_shared<G330DepthScrMetadataHDRSequenceIDParser>());  // todo: remove this line after fix hdr merge issue
+        registerParser(OB_FRAME_METADATA_TYPE_HDR_SEQUENCE_NAME, std::make_shared<G330DepthMetadataParser>(device, OB_FRAME_METADATA_TYPE_HDR_SEQUENCE_NAME));
+        registerParser(OB_FRAME_METADATA_TYPE_HDR_SEQUENCE_SIZE,
+                       std::make_shared<G330DepthMetadataParser>(device, OB_FRAME_METADATA_TYPE_HDR_SEQUENCE_SIZE,
+                                                                 [](const int64_t &param) { return param == 0 ? 0 : 2; }));
+        registerParser(OB_FRAME_METADATA_TYPE_AE_ROI_LEFT, std::make_shared<G330DepthMetadataParser>(device, OB_FRAME_METADATA_TYPE_AE_ROI_LEFT));
+        registerParser(OB_FRAME_METADATA_TYPE_AE_ROI_TOP, std::make_shared<G330DepthMetadataParser>(device, OB_FRAME_METADATA_TYPE_AE_ROI_TOP));
+        registerParser(OB_FRAME_METADATA_TYPE_AE_ROI_RIGHT, std::make_shared<G330DepthMetadataParser>(device, OB_FRAME_METADATA_TYPE_AE_ROI_RIGHT));
+        registerParser(OB_FRAME_METADATA_TYPE_AE_ROI_BOTTOM, std::make_shared<G330DepthMetadataParser>(device, OB_FRAME_METADATA_TYPE_AE_ROI_BOTTOM));
+    }
+};
+
+}  // namespace libobsensor
diff --git a/src/device/gemini330/G330FrameTimestampCalculator.cpp b/src/device/gemini330/G330FrameTimestampCalculator.cpp
new file mode 100644
index 00000000..14e1181d
--- /dev/null
+++ b/src/device/gemini330/G330FrameTimestampCalculator.cpp
@@ -0,0 +1,91 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "G330FrameTimestampCalculator.hpp"
+#include "logger/LoggerInterval.hpp"
+#include "InternalTypes.hpp"
+#include "frame/Frame.hpp"
+
+namespace libobsensor {
+G330FrameTimestampCalculatorBaseDeviceTime::G330FrameTimestampCalculatorBaseDeviceTime(IDevice *device, uint64_t deviceTimeFreq, uint64_t frameTimeFreq)
+    : device_(device), deviceTimeFreq_(deviceTimeFreq), frameTimeFreq_(frameTimeFreq) {
+    auto                  propServer = device->getPropertyServer();
+    std::vector<uint32_t> supportedProps;
+    if(propServer->isPropertySupported(OB_PROP_TIMER_RESET_SIGNAL_BOOL, PROP_OP_WRITE, PROP_ACCESS_INTERNAL)) {
+        supportedProps.push_back(OB_PROP_TIMER_RESET_SIGNAL_BOOL);
+    }
+    if(propServer->isPropertySupported(OB_STRUCT_DEVICE_TIME, PROP_OP_WRITE, PROP_ACCESS_INTERNAL)) {
+        supportedProps.push_back(OB_STRUCT_DEVICE_TIME);
+    }
+    if(!supportedProps.empty()) {
+        propServer->registerAccessCallback(supportedProps, [&](uint32_t, const uint8_t *, size_t, PropertyOperationType operationType) {
+            if(operationType == PROP_OP_WRITE) {
+                clear();
+            }
+        });
+    }
+}
+
+void G330FrameTimestampCalculatorBaseDeviceTime::calculate(std::shared_ptr<Frame> frame) {
+    auto srcTimestamp = frame->getTimeStampUsec();
+    auto rstTsp       = calculate(srcTimestamp);
+    frame->setTimeStampUsec(rstTsp);
+}
+
+uint64_t G330FrameTimestampCalculatorBaseDeviceTime::calculate(uint64_t srcTimestamp) {
+    // Conditions that need to update baseDevTime_:
+    // 1. The first frame after opening the stream
+    // 2. The timestamp becomes smaller (the size of the timestamps of the previous and later data frames is reversed), indicating that a timestamp overflow has
+    // occurred or the device clock has been cleared (a small probability may also be caused by abnormal data transmission)
+    // 3. The difference in system time between the arrival of two frames of data is greater than the difference in device timestamps between two frames of
+    // data, indicating that an overflow or clearing occurred during the triggering interval of the previous frame. However, the timestamps of the preceding and
+    // following data frames The size is not reversed, Try to actively update and obtain the device timestamp (but in order to avoid frequent acquisition of
+    // device timestamps due to misjudgments caused by data transmission fluctuations, we set the difference to be greater than prevSrcTspMs /2)
+    // 4. When the last timestamp is less than 50ms, avoid missing judgments
+    // LOG(INFO) << " >>> srcTimeStamp: " << srcTimestamp << " <<< ";
+    // Determine whether the timestamp becomes smaller
+    bool tspDecrease = (srcTimestamp < prevSrcTsp_);
+
+    // Determine whether the data frame timestamp difference is similar to the system timestamp difference
+    uint64_t curHostTsp      = utils::getNowTimesMs();
+    int64_t  srcTspDiffMs    = static_cast<int64_t>((static_cast<double>(srcTimestamp) - prevSrcTsp_) / frameTimeFreq_ * 1000);  // Convert unit to milliseconds
+    int64_t  hostTspDiffMs   = curHostTsp - prevHostTsp_;
+    uint64_t prevSrcTspMs    = static_cast<uint64_t>(static_cast<double>(prevSrcTsp_) / frameTimeFreq_ * 1000);
+    bool     tspDiffAbnormal = ((static_cast<double>(hostTspDiffMs) - srcTspDiffMs) >= prevSrcTspMs / 2);
+
+    if(baseDevTime_ == 0 || ((tspDecrease || tspDiffAbnormal) && (srcTimestamp != 0 || prevSrcTsp_ != 0)) || prevSrcTspMs <= 50) {
+        LOG_DEBUG_INTVL_MS(1000, "updateBaseTimeStamp:");
+        LOG_DEBUG_INTVL_MS(1000, "\tsrcTimestamp={0}, prevSrcTsp_={1}, tspDecrease={2}", srcTimestamp, prevSrcTsp_, tspDecrease);
+        LOG_DEBUG_INTVL_MS(1000, "\tsrcTspDiffMs={0}, hostTspDiffMs={1}, tspDiffAbnormal={2}", srcTspDiffMs, hostTspDiffMs, tspDiffAbnormal);
+
+        {
+            auto propertyServer = device_->getPropertyServer();
+            auto devTime        = propertyServer->getStructureDataT<OBDeviceTime>(OB_STRUCT_DEVICE_TIME);
+            baseDevTime_        = static_cast<uint64_t>((static_cast<double>(devTime.time) + devTime.rtt / 2) / deviceTimeFreq_ * frameTimeFreq_);
+        }
+
+        uint64_t overFlowTimes              = baseDevTime_ / (256 * frameTimeFreq_);
+        uint64_t calculateLeftoverTimestamp = baseDevTime_ - overFlowTimes * (256 * frameTimeFreq_);
+        if(calculateLeftoverTimestamp < srcTimestamp) {
+            baseDevTime_ = (overFlowTimes - 1) * (256 * frameTimeFreq_);
+        }
+        else {
+            baseDevTime_ -= calculateLeftoverTimestamp;
+        }
+    }
+
+    prevHostTsp_       = curHostTsp;
+    prevSrcTsp_        = srcTimestamp;
+    auto outputTsp     = baseDevTime_ + srcTimestamp;
+    auto timestampUsec = static_cast<double>(outputTsp) / frameTimeFreq_ * 1000000;
+    return static_cast<uint64_t>(timestampUsec);
+}
+
+void G330FrameTimestampCalculatorBaseDeviceTime::clear() {
+    prevSrcTsp_  = 0;
+    prevHostTsp_ = 0;
+    baseDevTime_ = 0;
+}
+
+}  // namespace libobsensor
+
diff --git a/src/device/gemini330/G330FrameTimestampCalculator.hpp b/src/device/gemini330/G330FrameTimestampCalculator.hpp
new file mode 100644
index 00000000..ad64de22
--- /dev/null
+++ b/src/device/gemini330/G330FrameTimestampCalculator.hpp
@@ -0,0 +1,32 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include "IFrame.hpp"
+#include "IDevice.hpp"
+
+namespace libobsensor {
+
+class G330FrameTimestampCalculatorBaseDeviceTime : public IFrameTimestampCalculator {
+public:
+    G330FrameTimestampCalculatorBaseDeviceTime(IDevice *device, uint64_t deviceTimeFreq, uint64_t frameTimeFreq);
+
+    virtual ~G330FrameTimestampCalculatorBaseDeviceTime() = default;
+
+    void calculate(std::shared_ptr<Frame> frame) override;
+    void clear() override;
+
+    uint64_t calculate(uint64_t srcTimestamp);
+
+private:
+    IDevice *device_;
+    
+    uint64_t deviceTimeFreq_;
+    uint64_t frameTimeFreq_;
+
+    uint64_t prevSrcTsp_;
+    uint64_t prevHostTsp_;
+    uint64_t baseDevTime_;
+};
+
+}  // namespace libobsensor
diff --git a/src/device/gemini330/G330MetadataParser.hpp b/src/device/gemini330/G330MetadataParser.hpp
new file mode 100644
index 00000000..50ab2ee0
--- /dev/null
+++ b/src/device/gemini330/G330MetadataParser.hpp
@@ -0,0 +1,553 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include <stdint.h>
+#include <algorithm>
+#include <set>
+
+#include "IFrame.hpp"
+#include "G330MetadataTypes.hpp"
+#include "exception/ObException.hpp"
+#include "logger/LoggerInterval.hpp"
+#include "utils/Utils.hpp"
+#include "G330FrameTimestampCalculator.hpp"
+#include "sensor/video/VideoSensor.hpp"
+#include "stream/StreamProfile.hpp"
+
+namespace libobsensor {
+
+template <typename T, typename Field> class StructureMetadataParser : public IFrameMetadataParser {
+public:
+    StructureMetadataParser(Field T::*field, FrameMetadataModifier mod) : field_(field), modifier_(mod){};
+    virtual ~StructureMetadataParser() = default;
+
+    int64_t getValue(const uint8_t *metadata, size_t dataSize) override {
+        if(!isSupported(metadata, dataSize)) {
+            throw unsupported_operation_exception("Current metadata does not contain this structure!");
+        }
+        auto value = static_cast<int64_t>((*reinterpret_cast<const T *>(metadata)).*field_);
+        if(modifier_) {
+            value = modifier_(value);
+        }
+        return value;
+    }
+
+    bool isSupported(const uint8_t *metadata, size_t dataSize) override {
+        (void)metadata;
+        return dataSize >= sizeof(T);
+    }
+
+private:
+    Field T::            *field_;
+    FrameMetadataModifier modifier_;
+};
+
+template <typename T, typename Field>
+std::shared_ptr<StructureMetadataParser<T, Field>> makeStructureMetadataParser(Field T::*field, FrameMetadataModifier mod = nullptr) {
+    return std::make_shared<StructureMetadataParser<T, Field>>(field, mod);
+}
+
+template <typename T> class G330MetadataTimestampParser : public IFrameMetadataParser {
+public:
+    G330MetadataTimestampParser(){};
+    virtual ~G330MetadataTimestampParser() = default;
+
+    int64_t getValue(const uint8_t *metadata, size_t dataSize) override {
+        if(!isSupported(metadata, dataSize)) {
+            LOG_WARN_INTVL("Current metadata does not contain timestamp!");
+            return -1;
+        }
+        auto md = reinterpret_cast<const T *>(metadata);
+        return (int64_t)md->timestamp_sof_sec * 1000000 + md->timestamp_sof_nsec / 1000 - md->timestamp_offset_usec;
+    }
+
+    bool isSupported(const uint8_t *metadata, size_t dataSize) override {
+        (void)metadata;
+        return dataSize >= sizeof(T);
+    }
+};
+
+// for depth and ir sensor
+class G330MetadataSensorTimestampParser : public IFrameMetadataParser {
+public:
+    G330MetadataSensorTimestampParser(){};
+    explicit G330MetadataSensorTimestampParser(FrameMetadataModifier exp_to_usec) : exp_to_usec_(exp_to_usec){};
+    virtual ~G330MetadataSensorTimestampParser() = default;
+
+    int64_t getValue(const uint8_t *metadata, size_t dataSize) override {
+        if(!isSupported(metadata, dataSize)) {
+            LOG_WARN_INTVL("Current metadata does not contain timestamp!");
+            return -1;
+        }
+        auto md          = reinterpret_cast<const G330CommonUvcMetadata *>(metadata);
+        auto exp_in_usec = exp_to_usec_ ? exp_to_usec_(md->exposure) : md->exposure;
+        return (int64_t)md->timestamp_sof_sec * 1000000 + md->timestamp_sof_nsec / 1000 - md->timestamp_offset_usec - exp_in_usec / 2;
+    }
+
+    bool isSupported(const uint8_t *metadata, size_t dataSize) override {
+        (void)metadata;
+        return dataSize >= sizeof(G330CommonUvcMetadata);
+    }
+
+private:
+    FrameMetadataModifier exp_to_usec_ = nullptr;
+};
+
+class G330ColorMetadataSensorTimestampParser : public IFrameMetadataParser {
+public:
+    G330ColorMetadataSensorTimestampParser(){};
+    explicit G330ColorMetadataSensorTimestampParser(FrameMetadataModifier exp_to_usec) : exp_to_usec_(exp_to_usec){};
+    virtual ~G330ColorMetadataSensorTimestampParser() = default;
+
+    int64_t getValue(const uint8_t *metadata, size_t dataSize) override {
+        if(!isSupported(metadata, dataSize)) {
+            LOG_WARN_INTVL("Current metadata does not contain timestamp!");
+            return -1;
+        }
+        auto md = reinterpret_cast<const G330ColorUvcMetadata *>(metadata);
+        // auto exp_in_usec = exp_to_usec_ ? exp_to_usec_(md->exposure) : md->exposure;
+        return (int64_t)md->timestamp_sof_sec * 1000000 + md->timestamp_sof_nsec / 1000 - md->timestamp_offset_usec + md->sensor_timestamp_offset_usec;
+    }
+
+    bool isSupported(const uint8_t *metadata, size_t dataSize) override {
+        utils::unusedVar(metadata);
+        return dataSize >= sizeof(G330CommonUvcMetadata);
+    }
+
+private:
+    FrameMetadataModifier exp_to_usec_ = nullptr;
+};
+
+class G330ScrMetadataParserBase : public IFrameMetadataParser {
+public:
+    G330ScrMetadataParserBase(){};
+    virtual ~G330ScrMetadataParserBase() = default;
+
+    bool isSupported(const uint8_t *metadata, size_t dataSize) override {
+        utils::unusedVar(metadata);
+        return dataSize >= sizeof(StandardUvcFramePayloadHeader::scrSourceClock);
+    }
+};
+
+class G330PayloadHeadMetadataTimestampParser : public G330ScrMetadataParserBase {
+public:
+    G330PayloadHeadMetadataTimestampParser(IDevice *device, uint64_t deviceTimeFreq, uint64_t frameTimeFreq)
+        : device_(device), deviceTimeFreq_(deviceTimeFreq), frameTimeFreq_(frameTimeFreq) {
+        timestampCalculator_ = std::make_shared<G330FrameTimestampCalculatorBaseDeviceTime>(device, deviceTimeFreq_, frameTimeFreq_);
+    }
+    virtual ~G330PayloadHeadMetadataTimestampParser() = default;
+
+    int64_t getValue(const uint8_t *metadata, size_t dataSize) override {
+        if(!isSupported(metadata, dataSize)) {
+            LOG_WARN_INTVL("Current metadata does not contain timestamp!");
+            return -1;
+        }
+        auto     standardUvcMetadata = *(reinterpret_cast<const StandardUvcFramePayloadHeader *>(metadata));
+        uint64_t transformedTimestamp =
+            ((standardUvcMetadata.dwPresentationTime >> 24) & 0xFF) * 1000000 + ((standardUvcMetadata.dwPresentationTime & 0xFFFFFF) << 8) / 1000;
+        auto calculatedTimestamp = timestampCalculator_->calculate(transformedTimestamp);
+
+        return calculatedTimestamp;
+    }
+
+private:
+    IDevice *device_;
+
+    uint64_t deviceTimeFreq_;
+
+    uint64_t frameTimeFreq_;
+
+    std::shared_ptr<G330FrameTimestampCalculatorBaseDeviceTime> timestampCalculator_;
+};
+
+class G330PayloadHeadMetadataColorSensorTimestampParser : public G330PayloadHeadMetadataTimestampParser {
+public:
+    G330PayloadHeadMetadataColorSensorTimestampParser(IDevice *device, uint64_t deviceTimeFreq, uint64_t frameTimeFreq)
+        : G330PayloadHeadMetadataTimestampParser(device, deviceTimeFreq, frameTimeFreq) {}
+    virtual ~G330PayloadHeadMetadataColorSensorTimestampParser() = default;
+
+    int64_t getValue(const uint8_t *metadata, size_t dataSize) override {
+        if(!isSupported(metadata, dataSize)) {
+            LOG_WARN_INTVL("Current metadata does not contain color sensor timestamp!");
+            return -1;
+        }
+
+        auto calculatedTimestamp = G330PayloadHeadMetadataTimestampParser::getValue(metadata, dataSize);
+        // get frame offset,unit 100us
+        auto    standardUvcMetadata = *(reinterpret_cast<const StandardUvcFramePayloadHeader *>(metadata));
+        int16_t frameOffset         = (((standardUvcMetadata.scrSourceClock[1] & 0xF8) >> 3) | ((standardUvcMetadata.scrSourceClock[2] & 0x7F) << 8)) * 100;
+        calculatedTimestamp += frameOffset;
+
+        return calculatedTimestamp;
+    }
+};
+
+class G330ColorScrMetadataExposureParser : public G330ScrMetadataParserBase {
+public:
+    int64_t getValue(const uint8_t *metadata, size_t dataSize) override {
+        if(!isSupported(metadata, dataSize)) {
+            LOG_WARN_INTVL("Current metadata does not contain color exposure!");
+            return -1;
+        }
+        auto     standardUvcMetadata = *(reinterpret_cast<const StandardUvcFramePayloadHeader *>(metadata));
+        uint32_t exposure            = (standardUvcMetadata.scrSourceClock[0] | ((standardUvcMetadata.scrSourceClock[1] & 0x07) << 8));
+
+        return static_cast<int64_t>(exposure);
+    }
+};
+
+class G330ColorScrMetadataActualFrameRateParser : public G330ColorScrMetadataExposureParser {
+public:
+    G330ColorScrMetadataActualFrameRateParser(IDevice *device) : device_(device) {}
+    int64_t getValue(const uint8_t *metadata, size_t dataSize) override {
+        if(!isSupported(metadata, dataSize)) {
+            LOG_WARN_INTVL("Current metadata does not contain color actual frame rate!");
+            return -1;
+        }
+        auto exposure = G330ColorScrMetadataExposureParser::getValue(metadata, dataSize) * 100;  // color exposure unit 100us
+        auto fps      = static_cast<uint32_t>(1000000.f / exposure);
+
+        auto colorSensor              = device_->getComponentT<VideoSensor>(OB_DEV_COMPONENT_COLOR_SENSOR);
+        auto colorActiveStreamProfile = colorSensor->getActivatedStreamProfile();
+        if(!colorActiveStreamProfile) {
+            return -1;
+        }
+        auto colorCurrentStreamProfileFps = colorActiveStreamProfile->as<VideoStreamProfile>()->getFps();
+        return static_cast<int64_t>((std::min)(fps, colorCurrentStreamProfileFps));
+    }
+
+private:
+    IDevice *device_;
+};
+
+class G330ColorScrMetadataGainParser : public G330ScrMetadataParserBase {
+public:
+    int64_t getValue(const uint8_t *metadata, size_t dataSize) override {
+        if(!isSupported(metadata, dataSize)) {
+            LOG_WARN_INTVL("Current metadata does not contain color gain!");
+            return -1;
+        }
+        auto     standardUvcMetadata = *(reinterpret_cast<const StandardUvcFramePayloadHeader *>(metadata));
+        uint16_t gain                = standardUvcMetadata.scrSourceClock[3];
+
+        return static_cast<int64_t>(gain);
+    }
+};
+
+class G330PayloadHeadMetadataDepthSensorTimestampParser : public G330PayloadHeadMetadataTimestampParser {
+public:
+    G330PayloadHeadMetadataDepthSensorTimestampParser(IDevice *device, uint64_t deviceTimeFreq, uint64_t frameTimeFreq)
+        : G330PayloadHeadMetadataTimestampParser(device, deviceTimeFreq, frameTimeFreq) {}
+    virtual ~G330PayloadHeadMetadataDepthSensorTimestampParser() = default;
+
+    int64_t getValue(const uint8_t *metadata, size_t dataSize) override {
+        if(!isSupported(metadata, dataSize)) {
+            LOG_WARN_INTVL("Current metadata does not contain color sensor timestamp!");
+            return -1;
+        }
+
+        auto calculatedTimestamp = G330PayloadHeadMetadataTimestampParser::getValue(metadata, dataSize);
+        // get depth exposure,unit 1us
+        auto     standardUvcMetadata = *(reinterpret_cast<const StandardUvcFramePayloadHeader *>(metadata));
+        uint32_t exposure =
+            standardUvcMetadata.scrSourceClock[0] | (standardUvcMetadata.scrSourceClock[1] << 8) | ((standardUvcMetadata.scrSourceClock[2] & 0x03) << 16);
+        calculatedTimestamp = calculatedTimestamp - (exposure / 2);
+
+        return calculatedTimestamp;
+    }
+};
+
+class G330DepthScrMetadataExposureParser : public G330ScrMetadataParserBase {
+public:
+    int64_t getValue(const uint8_t *metadata, size_t dataSize) override {
+        if(!isSupported(metadata, dataSize)) {
+            LOG_WARN_INTVL("Current metadata does not contain depth exposure!");
+            return -1;
+        }
+        auto     standardUvcMetadata = *(reinterpret_cast<const StandardUvcFramePayloadHeader *>(metadata));
+        uint32_t exposure =
+            standardUvcMetadata.scrSourceClock[0] | (standardUvcMetadata.scrSourceClock[1] << 8) | ((standardUvcMetadata.scrSourceClock[2] & 0x03) << 16);
+
+        return static_cast<int64_t>(exposure);
+    }
+};
+
+class G330DepthScrMetadataActualFrameRateParser : public G330DepthScrMetadataExposureParser {
+public:
+    G330DepthScrMetadataActualFrameRateParser(IDevice *device) : device_(device) {}
+    int64_t getValue(const uint8_t *metadata, size_t dataSize) override {
+        if(!isSupported(metadata, dataSize)) {
+            LOG_WARN_INTVL("Current metadata does not contain depth actual frame rate!");
+            return -1;
+        }
+        auto exposure = G330DepthScrMetadataExposureParser::getValue(metadata, dataSize);
+        auto fps      = static_cast<uint32_t>(1000000.f / exposure);
+
+        static std::vector<DeviceComponentId> sensorComponentIds = { OB_DEV_COMPONENT_DEPTH_SENSOR, OB_DEV_COMPONENT_LEFT_IR_SENSOR,
+                                                                     OB_DEV_COMPONENT_RIGHT_IR_SENSOR };
+
+        StreamProfileList streamProfileList;
+        uint32_t          activatedStreamProfileFps = 0;
+        for(const auto &id: sensorComponentIds) {
+            auto sensor                   = device_->getComponentT<VideoSensor>(id);
+            auto currentStreamProfileList = sensor->getStreamProfileList();
+            auto activeStreamProfile      = sensor->getActivatedStreamProfile();
+            if(!activeStreamProfile) {
+                continue;
+            }
+            else {
+                streamProfileList         = currentStreamProfileList;
+                activatedStreamProfileFps = activeStreamProfile->as<VideoStreamProfile>()->getFps();
+                break;
+            }
+        }
+
+        if(activatedStreamProfileFps == 0) {
+            return -1;
+        }
+
+        std::vector<uint32_t> currentStreamProfileFpsVector;
+        for(const auto &profile: streamProfileList) {
+            auto videoStreamProfile = profile->as<VideoStreamProfile>();
+            if(!videoStreamProfile) {
+                continue;
+            }
+
+            auto curFps = videoStreamProfile->getFps();
+            if(std::find(currentStreamProfileFpsVector.begin(), currentStreamProfileFpsVector.end(), curFps) != currentStreamProfileFpsVector.end()) {
+                continue;
+            }
+
+            currentStreamProfileFpsVector.push_back(curFps);
+        }
+        std::sort(currentStreamProfileFpsVector.begin(), currentStreamProfileFpsVector.end());
+
+        if(fps >= currentStreamProfileFpsVector.back()) {
+            fps = currentStreamProfileFpsVector.back();
+        }
+        else {
+            for(size_t i = 0; i < currentStreamProfileFpsVector.size() - 1; i++) {
+                if(fps < currentStreamProfileFpsVector[i + 1]) {
+                    fps = currentStreamProfileFpsVector[i];
+                    break;
+                }
+            }
+        }
+
+        return static_cast<int64_t>((std::min)(fps, activatedStreamProfileFps));
+    }
+
+private:
+    IDevice *device_;
+};
+
+class G330DepthScrMetadataLaserStatusParser : public G330ScrMetadataParserBase {
+public:
+    int64_t getValue(const uint8_t *metadata, size_t dataSize) override {
+        if(!isSupported(metadata, dataSize)) {
+            LOG_WARN_INTVL("Current metadata does not contain laser status!");
+            return -1;
+        }
+        auto    standardUvcMetadata = *(reinterpret_cast<const StandardUvcFramePayloadHeader *>(metadata));
+        uint8_t laserStatus         = (standardUvcMetadata.scrSourceClock[2] & 0x04) >> 2;
+        return static_cast<int64_t>(laserStatus);
+    }
+};
+
+class G330DepthScrMetadataLaserPowerLevelParser : public G330ScrMetadataParserBase {
+public:
+    G330DepthScrMetadataLaserPowerLevelParser(FrameMetadataModifier modifier = nullptr) : modifier_(modifier) {}
+    int64_t getValue(const uint8_t *metadata, size_t dataSize) override {
+        if(!isSupported(metadata, dataSize)) {
+            LOG_WARN_INTVL("Current metadata does not contain laser power level!");
+            return -1;
+        }
+        auto    standardUvcMetadata = *(reinterpret_cast<const StandardUvcFramePayloadHeader *>(metadata));
+        int64_t laserPowerLevel     = (standardUvcMetadata.scrSourceClock[2] & 0x38) >> 3;
+        if(modifier_) {
+            laserPowerLevel = modifier_(laserPowerLevel);
+        }
+        return laserPowerLevel;
+    }
+
+private:
+    FrameMetadataModifier modifier_;
+};
+
+class G330DepthScrMetadataHDRSequenceIDParser : public G330ScrMetadataParserBase {
+public:
+    int64_t getValue(const uint8_t *metadata, size_t dataSize) override {
+        if(!isSupported(metadata, dataSize)) {
+            LOG_WARN_INTVL("Current metadata does not contain hdr sequence id!");
+            return -1;
+        }
+        auto    standardUvcMetadata = *(reinterpret_cast<const StandardUvcFramePayloadHeader *>(metadata));
+        uint8_t hdrSequenceId       = (standardUvcMetadata.scrSourceClock[2] & 0x40) >> 6;
+        return static_cast<int64_t>(hdrSequenceId);
+    }
+};
+
+class G330DepthScrMetadataGainParser : public G330ScrMetadataParserBase {
+public:
+    int64_t getValue(const uint8_t *metadata, size_t dataSize) override {
+        if(!isSupported(metadata, dataSize)) {
+            LOG_WARN_INTVL("Current metadata does not contain depth gain!");
+            return -1;
+        }
+        auto    standardUvcMetadata = *(reinterpret_cast<const StandardUvcFramePayloadHeader *>(metadata));
+        uint8_t gain                = standardUvcMetadata.scrSourceClock[3];
+        return static_cast<int64_t>(gain);
+    }
+};
+
+class G330MetadataParserBase : public IFrameMetadataParser {
+public:
+    G330MetadataParserBase(IDevice *device, OBFrameMetadataType type, FrameMetadataModifier modifier,
+                           const std::multimap<OBPropertyID, std::vector<OBFrameMetadataType>> metadataTypeIdMap)
+        : device_(device), metadataType_(type), data_(0), modifier_(modifier), initPropertyValue_(true) {
+        for(const auto &item: metadataTypeIdMap) {
+            const std::vector<OBFrameMetadataType> &types = item.second;
+            if(std::find(types.begin(), types.end(), type) != types.end()) {
+                propertyId_ = item.first;
+                break;
+            }
+        }
+
+        auto propertyServer = device->getPropertyServer();
+        propertyServer->registerAccessCallback(propertyId_,
+                                               [this, type](uint32_t propertyId, const uint8_t *data, size_t dataSize, PropertyOperationType operationType) {
+                                                   utils::unusedVar(dataSize);
+                                                   utils::unusedVar(operationType);
+                                                   if(propertyId != static_cast<uint32_t>(propertyId_)) {
+                                                       return;
+                                                   }
+                                                   auto propertyServer = device_->getPropertyServer();
+                                                   auto propertyItem   = propertyServer->getPropertyItem(propertyId_, PROP_ACCESS_USER);
+                                                   if(propertyItem.type == OB_STRUCT_PROPERTY) {
+                                                       data_ = parseStructurePropertyValue(type, propertyId, data);
+                                                   }
+                                                   else {
+                                                       data_ = parsePropertyValue(propertyId, data);
+                                                   }
+                                               });
+    };
+
+    virtual ~G330MetadataParserBase() = default;
+
+    int64_t getValue(const uint8_t *metadata, size_t dataSize) override {
+        if(!isSupported(metadata, dataSize)) {
+            return -1;
+        }
+
+        // first time get value,should sync property value
+        if(initPropertyValue_) {
+            PropertyAccessType accessType     = PROP_ACCESS_USER;
+            auto               propertyServer = device_->getPropertyServer();
+            auto               propertyItem   = propertyServer->getPropertyItem(propertyId_, accessType);
+            if(propertyItem.type == OB_STRUCT_PROPERTY) {
+                auto structValue = propertyServer->getStructureData(propertyId_, accessType);
+                data_            = parseStructurePropertyValue(metadataType_, static_cast<uint32_t>(propertyId_), structValue.data());
+            }
+            else {
+                OBPropertyValue value = {};
+                propertyServer->getPropertyValue(propertyId_, &value, accessType);
+                void *valueData = nullptr;
+                if(propertyItem.type == OB_FLOAT_PROPERTY) {
+                    valueData = &value.floatValue;
+                }
+                else {
+                    valueData = &value.intValue;
+                }
+                data_ = parsePropertyValue(static_cast<uint32_t>(propertyId_), (const uint8_t *)valueData);
+            }
+            initPropertyValue_ = false;
+        }
+
+        if(modifier_) {
+            data_ = modifier_(data_);
+        }
+        return data_;
+    }
+
+    bool isSupported(const uint8_t *metadata, size_t dataSize) override {
+        utils::unusedVar(metadata);
+        utils::unusedVar(dataSize);
+        return true;
+    }
+
+private:
+    int64_t parsePropertyValue(uint32_t propertyId, const uint8_t *data) {
+        int64_t parsedData     = 0;
+        auto    value          = reinterpret_cast<const OBPropertyValue *>(data);
+        auto    propertyServer = device_->getPropertyServer();
+        auto    propertyItem   = propertyServer->getPropertyItem(propertyId, PROP_ACCESS_USER);
+        if(propertyItem.type == OB_INT_PROPERTY || propertyItem.type == OB_BOOL_PROPERTY) {
+            parsedData = static_cast<int64_t>(value->intValue);
+        }
+        else if(propertyItem.type == OB_FLOAT_PROPERTY) {
+            parsedData = static_cast<int64_t>(value->floatValue);
+        }
+
+        return parsedData;
+    }
+
+    int64_t parseStructurePropertyValue(OBFrameMetadataType type, uint32_t propertyId, const uint8_t *data) {
+        int64_t parsedData = 0;
+        if(propertyId == OB_STRUCT_COLOR_AE_ROI || propertyId == OB_STRUCT_DEPTH_AE_ROI) {
+            auto roi = *(reinterpret_cast<const OBRegionOfInterest *>(data));
+            if(type == OB_FRAME_METADATA_TYPE_AE_ROI_LEFT) {
+                parsedData = static_cast<int64_t>(roi.x0_left);
+            }
+            else if(type == OB_FRAME_METADATA_TYPE_AE_ROI_RIGHT) {
+                parsedData = static_cast<int64_t>(roi.x1_right);
+            }
+            else if(type == OB_FRAME_METADATA_TYPE_AE_ROI_TOP) {
+                parsedData = static_cast<int64_t>(roi.y0_top);
+            }
+            else if(type == OB_FRAME_METADATA_TYPE_AE_ROI_BOTTOM) {
+                parsedData = static_cast<int64_t>(roi.y1_bottom);
+            }
+        }
+        else if(propertyId == OB_STRUCT_DEPTH_HDR_CONFIG) {
+            auto hdrConfig = *(reinterpret_cast<const OBHdrConfig *>(data));
+            if(type == OB_FRAME_METADATA_TYPE_HDR_SEQUENCE_NAME) {
+                parsedData = static_cast<int64_t>(hdrConfig.sequence_name);
+            }
+            else if(type == OB_FRAME_METADATA_TYPE_HDR_SEQUENCE_SIZE) {
+                parsedData = static_cast<int64_t>(hdrConfig.enable);
+            }
+        }
+
+        return parsedData;
+    }
+
+private:
+    IDevice *device_;
+
+    OBFrameMetadataType metadataType_;
+
+    OBPropertyID propertyId_;
+
+    int64_t data_;
+
+    FrameMetadataModifier modifier_;
+
+    std::atomic<bool> initPropertyValue_;
+};
+
+class G330ColorMetadataParser : public G330MetadataParserBase {
+public:
+    G330ColorMetadataParser(IDevice *device, OBFrameMetadataType type, FrameMetadataModifier modifier = nullptr)
+        : G330MetadataParserBase(device, type, modifier, initMetadataTypeIdMap(OB_SENSOR_COLOR)) {}
+    virtual ~G330ColorMetadataParser() = default;
+};
+
+class G330DepthMetadataParser : public G330MetadataParserBase {
+public:
+    G330DepthMetadataParser(IDevice *device, OBFrameMetadataType type, FrameMetadataModifier modifier = nullptr)
+        : G330MetadataParserBase(device, type, modifier, initMetadataTypeIdMap(OB_SENSOR_DEPTH)) {}
+    virtual ~G330DepthMetadataParser() = default;
+};
+
+}  // namespace libobsensor
diff --git a/src/device/gemini330/G330MetadataTypes.hpp b/src/device/gemini330/G330MetadataTypes.hpp
new file mode 100644
index 00000000..96befbe6
--- /dev/null
+++ b/src/device/gemini330/G330MetadataTypes.hpp
@@ -0,0 +1,125 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include <stdint.h>
+#include "usb/uvc/UvcTypes.hpp"
+
+namespace libobsensor {
+
+#define G330_UVC_METADATA_SIZE (96 + sizeof(StandardUvcFramePayloadHeader))
+#pragma pack(push, 1)
+struct G330CommonUvcMetadata {
+    StandardUvcFramePayloadHeader uvc_payload_header;
+    uint32_t                      frame_counter;
+    uint32_t                      timestamp_fsin_h32;
+    uint32_t                      timestamp_fsin_l32;
+    uint32_t                      timestamp_sof_sec;
+    uint32_t                      timestamp_sof_nsec;
+    uint32_t                      exposure;
+    uint32_t                      timestamp_sync_in_h32;
+    uint32_t                      timestamp_sync_in_l32;
+    uint32_t                      timestamp_lpps_h32;
+    uint32_t                      timestamp_lpps_l32;
+    uint32_t                      timestamp_offset_h32;
+    uint32_t                      timestamp_offset_l32;
+    uint16_t                      digital_gain;
+    uint16_t                      analog_gain;
+
+    struct bitmap_union_0_fields {
+        uint8_t frame_type : 4;            // depth/disparity/lmono/rmono/YUV422/mjpeg
+        uint8_t pixel_available_bits : 4;  // 8bit/10bit/12bit/16bit
+        uint8_t padding_mode : 2;          // high bit padding/low bit padding/no padding
+        uint8_t auto_exposure : 1;
+        uint8_t timestamp_resync_flag : 1;
+    };
+    uint32_t bitmap_union_0;
+    uint32_t timestamp_offset_usec;
+};
+
+struct G330ColorUvcMetadata : public G330CommonUvcMetadata {
+    uint8_t  low_light_compensation;
+    uint8_t  power_line_frequency;
+    uint16_t gain_level;
+    uint16_t white_balance;
+    uint8_t  actual_fps;
+    uint8_t  manual_white_balance;
+    uint16_t contrast;
+    int16_t  brightness;
+    uint16_t sharpness;
+    uint16_t saturation;
+    uint16_t backlight_compensation;
+    uint16_t auto_white_balance;
+    int16_t  hue;
+    uint16_t gamma;
+    uint16_t exposure_roi_right;
+    uint16_t exposure_roi_left;
+    uint16_t exposure_roi_bottom;
+    uint16_t exposure_roi_top;
+    int32_t  sensor_timestamp_offset_usec;
+};
+
+struct G330DepthUvcMetadata : public G330CommonUvcMetadata {
+    uint16_t height;
+    uint16_t width;
+    uint16_t gain_level;
+    uint16_t white_balance;
+    uint16_t laser_power;
+    uint8_t  laser_power_level;
+    uint8_t  gpio_input_data;
+    uint16_t exposure_roi_right;
+    uint16_t exposure_roi_left;
+    uint16_t exposure_roi_bottom;
+    uint16_t exposure_roi_top;
+    uint16_t led_power;
+    uint8_t  laser_status;
+    uint8_t  exposure_priority;
+    uint8_t  actual_fps;
+    uint8_t  format;
+    uint8_t  sku_id;
+    uint8_t  hw_type;
+    uint8_t  UD0;
+    uint8_t  sequence_name;
+    uint8_t  sequence_id;
+    uint8_t  sequence_size;
+    uint32_t UD1;
+};
+
+#pragma pack(pop)
+
+static_assert(sizeof(G330ColorUvcMetadata) == G330_UVC_METADATA_SIZE, "G330ColorUvcMetadata size mismatch!");
+static_assert(sizeof(G330DepthUvcMetadata) == G330_UVC_METADATA_SIZE, "G330DepthUvcMetadata size mismatch!");
+
+static const std::multimap<OBPropertyID, std::vector<OBFrameMetadataType>> initMetadataTypeIdMap(OBSensorType type) {
+    std::multimap<OBPropertyID, std::vector<OBFrameMetadataType>> map;
+
+    if(type == OB_SENSOR_COLOR) {
+        map.insert({ OB_PROP_COLOR_AUTO_EXPOSURE_BOOL, { OB_FRAME_METADATA_TYPE_AUTO_EXPOSURE } });
+        map.insert({ OB_PROP_COLOR_AUTO_EXPOSURE_PRIORITY_INT, { OB_FRAME_METADATA_TYPE_LOW_LIGHT_COMPENSATION } });
+        map.insert({ OB_PROP_COLOR_AUTO_WHITE_BALANCE_BOOL, { OB_FRAME_METADATA_TYPE_AUTO_WHITE_BALANCE } });
+        map.insert({ OB_PROP_COLOR_WHITE_BALANCE_INT, { OB_FRAME_METADATA_TYPE_WHITE_BALANCE } });
+        map.insert({ OB_PROP_COLOR_BRIGHTNESS_INT, { OB_FRAME_METADATA_TYPE_BRIGHTNESS } });
+        map.insert({ OB_PROP_COLOR_CONTRAST_INT, { OB_FRAME_METADATA_TYPE_CONTRAST } });
+        map.insert({ OB_PROP_COLOR_SATURATION_INT, { OB_FRAME_METADATA_TYPE_SATURATION } });
+        map.insert({ OB_PROP_COLOR_SHARPNESS_INT, { OB_FRAME_METADATA_TYPE_SHARPNESS } });
+        map.insert({ OB_PROP_COLOR_BACKLIGHT_COMPENSATION_INT, { OB_FRAME_METADATA_TYPE_BACKLIGHT_COMPENSATION } });
+        map.insert({ OB_PROP_COLOR_HUE_INT, { OB_FRAME_METADATA_TYPE_HUE } });
+        map.insert({ OB_PROP_COLOR_GAMMA_INT, { OB_FRAME_METADATA_TYPE_GAMMA } });
+        map.insert({ OB_PROP_COLOR_POWER_LINE_FREQUENCY_INT, { OB_FRAME_METADATA_TYPE_POWER_LINE_FREQUENCY } });
+        map.insert({ OB_STRUCT_COLOR_AE_ROI,
+                     { OB_FRAME_METADATA_TYPE_AE_ROI_LEFT, OB_FRAME_METADATA_TYPE_AE_ROI_TOP, OB_FRAME_METADATA_TYPE_AE_ROI_RIGHT,
+                       OB_FRAME_METADATA_TYPE_AE_ROI_BOTTOM } });
+    }
+    else if(type == OB_SENSOR_DEPTH) {
+        map.insert({ OB_PROP_DEPTH_AUTO_EXPOSURE_BOOL, { OB_FRAME_METADATA_TYPE_AUTO_EXPOSURE } });
+        // map.insert({ OB_PROP_DEPTH_AUTO_EXPOSURE_PRIORITY_INT, { OB_FRAME_METADATA_TYPE_EXPOSURE_PRIORITY } });
+        map.insert({ OB_STRUCT_DEPTH_HDR_CONFIG, { OB_FRAME_METADATA_TYPE_HDR_SEQUENCE_NAME, OB_FRAME_METADATA_TYPE_HDR_SEQUENCE_SIZE } });
+        map.insert({ OB_STRUCT_DEPTH_AE_ROI,
+                     { OB_FRAME_METADATA_TYPE_AE_ROI_LEFT, OB_FRAME_METADATA_TYPE_AE_ROI_TOP, OB_FRAME_METADATA_TYPE_AE_ROI_RIGHT,
+                       OB_FRAME_METADATA_TYPE_AE_ROI_BOTTOM } });
+    }
+
+    return map;
+}
+
+}  // namespace libobsensor
diff --git a/src/device/gemini330/G330PresetManager.cpp b/src/device/gemini330/G330PresetManager.cpp
new file mode 100644
index 00000000..2a44bc2a
--- /dev/null
+++ b/src/device/gemini330/G330PresetManager.cpp
@@ -0,0 +1,291 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "G330PresetManager.hpp"
+#include "property/InternalProperty.hpp"
+#include "InternalTypes.hpp"
+#include "exception/ObException.hpp"
+#include "utils/Utils.hpp"
+#include "G330DepthWorkModeManager.hpp"
+
+#include <json/json.h>
+
+namespace libobsensor {
+
+G330PresetManager::G330PresetManager(IDevice *owner) : DeviceComponentBase(owner) {
+    auto depthWorkModeManager = owner->getComponentT<G330DepthWorkModeManager>(OB_DEV_COMPONENT_DEPTH_WORK_MODE_MANAGER);
+    auto depthWorkModeList    = depthWorkModeManager->getDepthWorkModeList();
+
+    for(auto &mode: depthWorkModeList) {
+        availablePresets_.emplace_back(mode.name);
+    }
+
+    if(availablePresets_.size() > 1) {
+        currentPreset_ = availablePresets_[0];
+        depthWorkModeManager->switchDepthWorkMode(currentPreset_.c_str());
+    }
+
+    auto propServer = owner->getPropertyServer();
+
+    propServer->registerAccessCallback(
+        {
+            OB_PROP_LASER_CONTROL_INT,
+            OB_PROP_LASER_POWER_LEVEL_CONTROL_INT,
+            OB_PROP_DEPTH_AUTO_EXPOSURE_BOOL,
+            OB_PROP_IR_AUTO_EXPOSURE_BOOL,
+            OB_PROP_DEPTH_EXPOSURE_INT,
+            OB_PROP_IR_EXPOSURE_INT,
+            OB_PROP_DEPTH_GAIN_INT,
+            OB_PROP_IR_GAIN_INT,
+            OB_PROP_IR_BRIGHTNESS_INT,
+            OB_PROP_COLOR_AUTO_EXPOSURE_BOOL,
+            OB_PROP_COLOR_EXPOSURE_INT,
+            OB_PROP_COLOR_AUTO_WHITE_BALANCE_BOOL,
+            OB_PROP_COLOR_WHITE_BALANCE_INT,
+            OB_PROP_COLOR_GAIN_INT,
+            OB_PROP_COLOR_CONTRAST_INT,
+            OB_PROP_COLOR_SATURATION_INT,
+            OB_PROP_COLOR_SHARPNESS_INT,
+            OB_PROP_COLOR_BRIGHTNESS_INT,
+            OB_PROP_COLOR_HUE_INT,
+            OB_PROP_COLOR_GAMMA_INT,
+            OB_PROP_COLOR_BACKLIGHT_COMPENSATION_INT,
+            OB_PROP_COLOR_POWER_LINE_FREQUENCY_INT,
+        },
+        [&](uint32_t, const uint8_t *, size_t, PropertyOperationType operationType) {
+            if(operationType == PROP_OP_WRITE) {
+                currentPreset_ = "Custom";
+            }
+        });
+    storeCurrentParamsAsCustomPreset("Custom");
+}
+
+void G330PresetManager::loadPreset(const std::string &presetName) {
+    if(std::find(availablePresets_.begin(), availablePresets_.end(), presetName) == availablePresets_.end()) {
+        throw std::invalid_argument("Invalid preset name: " + presetName);
+    }
+
+    // store current parameters to  "Custom"
+    if(currentPreset_ == "Custom") {
+        storeCurrentParamsAsCustomPreset("Custom");
+    }
+
+    auto iter = customPresets_.find(presetName);
+    if(iter != customPresets_.end()) {
+        // Load custom preset
+        loadCustomPreset(iter->first, iter->second);
+    }
+    else {
+        auto owner                = getOwner();
+        auto depthWorkModeManager = owner->getComponentT<G330DepthWorkModeManager>(OB_DEV_COMPONENT_DEPTH_WORK_MODE_MANAGER);
+
+        depthWorkModeManager->switchDepthWorkMode(presetName.c_str());
+        currentPreset_ = presetName;
+    }
+}
+
+const std::string &G330PresetManager::getCurrentPresetName() const {
+    return currentPreset_;
+}
+
+const std::vector<std::string> &G330PresetManager::getAvailablePresetList() const {
+    return availablePresets_;
+}
+
+void G330PresetManager::loadPresetFromJsonData(const std::string &presetName, const std::vector<uint8_t> &jsonData) {
+    Json::Value  root;
+    Json::Reader reader;
+    if(!reader.parse(std::string((const char *)jsonData.data(), jsonData.size()), root)) {
+        throw std::invalid_argument("Invalid JSON data");
+    }
+    // store current parameters to  "Custom"
+    if(currentPreset_ == "Custom") {
+        storeCurrentParamsAsCustomPreset("Custom");
+    }
+    loadPresetFromJsonValue(presetName, root);
+}
+
+void G330PresetManager::loadPresetFromJsonFile(const std::string &filePath) {
+    Json::Value   root;
+    std::ifstream ifs(filePath);
+    ifs >> root;
+    // store current parameters to  "Custom"
+    if(currentPreset_ == "Custom") {
+        storeCurrentParamsAsCustomPreset("Custom");
+    }
+    loadPresetFromJsonValue(filePath, root);
+}
+
+void G330PresetManager::loadPresetFromJsonValue(const std::string &presetName, const Json::Value &root) {
+    G330Preset preset;
+    preset.depthWorkMode              = root["depth_alg_mode"].asString();
+    preset.laserState                 = root["laser_state"].asInt();
+    preset.laserPowerLevel            = root["laser_power_level"].asInt();
+    preset.depthAutoExposure          = root["depth_auto_exposure"].asBool();
+    preset.depthExposureTime          = root["depth_exposure_time"].asInt();
+    preset.depthGain                  = root["depth_gain"].asInt();
+    preset.depthBrightness            = root["target_mean_intensity"].asInt();
+    preset.colorAutoExposure          = root["color_auto_exposure"].asBool();
+    preset.colorExposureTime          = root["color_exposure_time"].asInt();
+    preset.colorAutoWhiteBalance      = root["color_auto_white_balance"].asBool();
+    preset.colorWhiteBalance          = root["color_white_balance"].asInt();
+    preset.colorGain                  = root["color_gain"].asInt();
+    preset.colorContrast              = root["color_contrast"].asInt();
+    preset.colorSaturation            = root["color_saturation"].asInt();
+    preset.colorSharpness             = root["color_sharpness"].asInt();
+    preset.colorBrightness            = root["color_brightness"].asInt();
+    preset.colorHue                   = root["color_hue"].asInt();
+    preset.colorGamma                 = root["color_gamma"].asInt();
+    preset.colorBacklightCompensation = root["color_backlight_compensation"].asBool();
+    preset.colorPowerLineFrequency    = root["color_power_line_frequency"].asInt();
+
+    loadCustomPreset(presetName, preset);
+
+    if(customPresets_.find(presetName) == customPresets_.end()) {
+        availablePresets_.emplace_back(presetName);
+    }
+    customPresets_[presetName] = preset;
+}
+
+Json::Value G330PresetManager::exportSettingsAsPresetJsonValue(const std::string &presetName) {
+    storeCurrentParamsAsCustomPreset(presetName);
+    auto iter = customPresets_.find(presetName);
+    if(iter == customPresets_.end()) {
+        throw std::invalid_argument("Invalid preset name: " + presetName);
+    }
+    auto &preset = iter->second;
+
+    Json::Value root;
+    root["depth_alg_mode"]               = preset.depthWorkMode;
+    root["laser_state"]                  = preset.laserState;
+    root["laser_power_level"]            = preset.laserPowerLevel;
+    root["depth_auto_exposure"]          = preset.depthAutoExposure;
+    root["depth_exposure_time"]          = preset.depthExposureTime;
+    root["depth_gain"]                   = preset.depthGain;
+    root["target_mean_intensity"]        = preset.depthBrightness;
+    root["color_auto_exposure"]          = preset.colorAutoExposure;
+    root["color_exposure_time"]          = preset.colorExposureTime;
+    root["color_auto_white_balance"]     = preset.colorAutoWhiteBalance;
+    root["color_white_balance"]          = preset.colorWhiteBalance;
+    root["color_gain"]                   = preset.colorGain;
+    root["color_contrast"]               = preset.colorContrast;
+    root["color_saturation"]             = preset.colorSaturation;
+    root["color_sharpness"]              = preset.colorSharpness;
+    root["color_brightness"]             = preset.colorBrightness;
+    root["color_hue"]                    = preset.colorHue;
+    root["color_gamma"]                  = preset.colorGamma;
+    root["color_backlight_compensation"] = preset.colorBacklightCompensation;
+    root["color_power_line_frequency"]   = preset.colorPowerLineFrequency;
+
+    return root;
+}
+
+const std::vector<uint8_t> &G330PresetManager::exportSettingsAsPresetJsonData(const std::string &presetName) {
+    auto                      root = exportSettingsAsPresetJsonValue(presetName);
+    Json::StreamWriterBuilder builder;
+    builder.settings_["enableYAMLCompatibility"] = true;
+    builder.settings_["dropNullPlaceholders"]    = true;
+    std::ostringstream oss;
+    builder.newStreamWriter()->write(root, &oss);
+    tmpJsonData_.clear();
+    auto str = oss.str();
+    std::copy(str.begin(), str.end(), std::back_inserter(tmpJsonData_));
+    return tmpJsonData_;
+}
+
+void G330PresetManager::exportSettingsAsPresetJsonFile(const std::string &filePath) {
+    auto root = exportSettingsAsPresetJsonValue(filePath);
+
+    std::ofstream             ofs(filePath);
+    Json::StreamWriterBuilder builder;
+    // builder.settings_["indentation"]             = "    ";
+    builder.settings_["enableYAMLCompatibility"] = true;
+    builder.settings_["dropNullPlaceholders"]    = true;
+    auto writer                                  = builder.newStreamWriter();
+    writer->write(root, &ofs);
+}
+
+template <typename T> void setPropertyValue(IDevice *dev, uint32_t propertyId, T value) {
+    // get and release property server on this scope to avoid handle device resource lock for an extended duration
+    auto propServer = dev->getPropertyServer();
+    return propServer->setPropertyValueT<T>(propertyId, value);
+}
+
+void G330PresetManager::loadCustomPreset(const std::string &presetName, const G330Preset &preset) {
+
+    auto owner = getOwner();
+
+    {
+        auto depthWorkModeManager = owner->getComponentT<G330DepthWorkModeManager>(OB_DEV_COMPONENT_DEPTH_WORK_MODE_MANAGER);
+        depthWorkModeManager->switchDepthWorkMode(preset.depthWorkMode.c_str());
+    }
+
+    setPropertyValue(owner, OB_PROP_LASER_CONTROL_INT, preset.laserState);
+    setPropertyValue(owner, OB_PROP_LASER_POWER_LEVEL_CONTROL_INT, preset.laserPowerLevel);
+    setPropertyValue(owner, OB_PROP_IR_EXPOSURE_INT, preset.depthExposureTime);
+    setPropertyValue(owner, OB_PROP_IR_GAIN_INT, preset.depthGain);
+    setPropertyValue(owner, OB_PROP_DEPTH_AUTO_EXPOSURE_BOOL, (bool)preset.depthAutoExposure);
+    setPropertyValue(owner, OB_PROP_IR_BRIGHTNESS_INT, preset.depthBrightness);
+    setPropertyValue(owner, OB_PROP_COLOR_AUTO_EXPOSURE_BOOL, (bool)preset.colorAutoExposure);
+    if(!preset.colorAutoExposure) {
+        setPropertyValue(owner, OB_PROP_COLOR_EXPOSURE_INT, preset.colorExposureTime);
+        setPropertyValue(owner, OB_PROP_COLOR_GAIN_INT, preset.colorGain);
+    }
+    setPropertyValue(owner, OB_PROP_COLOR_AUTO_WHITE_BALANCE_BOOL, (bool)preset.colorAutoWhiteBalance);
+    if(!preset.colorAutoWhiteBalance) {
+        setPropertyValue(owner, OB_PROP_COLOR_WHITE_BALANCE_INT, preset.colorWhiteBalance);
+    }
+    setPropertyValue(owner, OB_PROP_COLOR_CONTRAST_INT, preset.colorContrast);
+    setPropertyValue(owner, OB_PROP_COLOR_SATURATION_INT, preset.colorSaturation);
+    setPropertyValue(owner, OB_PROP_COLOR_SHARPNESS_INT, preset.colorSharpness);
+    setPropertyValue(owner, OB_PROP_COLOR_BRIGHTNESS_INT, preset.colorBrightness);
+    setPropertyValue(owner, OB_PROP_COLOR_HUE_INT, preset.colorHue);
+    setPropertyValue(owner, OB_PROP_COLOR_GAMMA_INT, preset.colorGamma);
+    setPropertyValue(owner, OB_PROP_COLOR_BACKLIGHT_COMPENSATION_INT, (bool)preset.colorBacklightCompensation);
+    setPropertyValue(owner, OB_PROP_COLOR_POWER_LINE_FREQUENCY_INT, (int)preset.colorPowerLineFrequency);
+
+    currentPreset_ = presetName;
+}
+
+template <typename T> T getPropertyValue(IDevice *dev, uint32_t propertyId) {
+    // get and release property server on this scope to avoid handle device resource lock for an extended duration
+    auto propServer = dev->getPropertyServer();
+    return propServer->getPropertyValueT<T>(propertyId);
+}
+
+void G330PresetManager::storeCurrentParamsAsCustomPreset(const std::string &presetName) {
+    G330Preset preset;
+    auto       owner = getOwner();
+
+    preset.laserState                 = getPropertyValue<int>(owner, OB_PROP_LASER_CONTROL_INT);
+    preset.laserPowerLevel            = getPropertyValue<int>(owner, OB_PROP_LASER_POWER_LEVEL_CONTROL_INT);
+    preset.depthAutoExposure          = getPropertyValue<bool>(owner, OB_PROP_DEPTH_AUTO_EXPOSURE_BOOL);
+    preset.depthExposureTime          = getPropertyValue<int>(owner, OB_PROP_IR_EXPOSURE_INT);
+    preset.depthGain                  = getPropertyValue<int>(owner, OB_PROP_IR_GAIN_INT);
+    preset.depthBrightness            = getPropertyValue<int>(owner, OB_PROP_IR_BRIGHTNESS_INT);
+    preset.colorAutoExposure          = getPropertyValue<bool>(owner, OB_PROP_COLOR_AUTO_EXPOSURE_BOOL);
+    preset.colorExposureTime          = getPropertyValue<int>(owner, OB_PROP_COLOR_EXPOSURE_INT);
+    preset.colorAutoWhiteBalance      = getPropertyValue<bool>(owner, OB_PROP_COLOR_AUTO_WHITE_BALANCE_BOOL);
+    preset.colorWhiteBalance          = getPropertyValue<int>(owner, OB_PROP_COLOR_WHITE_BALANCE_INT);
+    preset.colorGain                  = getPropertyValue<int>(owner, OB_PROP_COLOR_GAIN_INT);
+    preset.colorContrast              = getPropertyValue<int>(owner, OB_PROP_COLOR_CONTRAST_INT);
+    preset.colorSaturation            = getPropertyValue<int>(owner, OB_PROP_COLOR_SATURATION_INT);
+    preset.colorSharpness             = getPropertyValue<int>(owner, OB_PROP_COLOR_SHARPNESS_INT);
+    preset.colorBrightness            = getPropertyValue<int>(owner, OB_PROP_COLOR_BRIGHTNESS_INT);
+    preset.colorHue                   = getPropertyValue<int>(owner, OB_PROP_COLOR_HUE_INT);
+    preset.colorGamma                 = getPropertyValue<int>(owner, OB_PROP_COLOR_GAMMA_INT);
+    preset.colorBacklightCompensation = getPropertyValue<bool>(owner, OB_PROP_COLOR_BACKLIGHT_COMPENSATION_INT);
+    preset.colorPowerLineFrequency    = getPropertyValue<int>(owner, OB_PROP_COLOR_POWER_LINE_FREQUENCY_INT);
+
+    {
+        auto depthWorkModeManager = owner->getComponentT<G330DepthWorkModeManager>(OB_DEV_COMPONENT_DEPTH_WORK_MODE_MANAGER);
+        preset.depthWorkMode      = depthWorkModeManager->getCurrentDepthWorkMode().name;
+    }
+
+    if(customPresets_.find(presetName) == customPresets_.end()) {
+        availablePresets_.emplace_back(presetName);
+    }
+    customPresets_[presetName] = preset;
+}
+
+}  // namespace libobsensor
diff --git a/src/device/gemini330/G330PresetManager.hpp b/src/device/gemini330/G330PresetManager.hpp
new file mode 100644
index 00000000..22041197
--- /dev/null
+++ b/src/device/gemini330/G330PresetManager.hpp
@@ -0,0 +1,86 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include "IDevice.hpp"
+#include "IPresetManager.hpp"
+#include "InternalTypes.hpp"
+#include "DeviceComponentBase.hpp"
+
+#include <map>
+#include <string>
+#include <vector>
+
+namespace Json {
+class Value;  // forward declaration
+}  // namespace Json
+
+namespace libobsensor {
+
+struct G330Preset {
+    // device/global
+    std::string depthWorkMode;
+    int         laserState;
+    int         laserPowerLevel;
+
+    // depth and infrared sensor
+    int depthAutoExposure;
+    int depthExposureTime;
+    int depthGain;
+    int depthBrightness;
+    //    // stream profile
+    //    int depthStreamFormat;
+    //    int depthStreamFrameRate;
+    //    int depthStreamWidth;
+    //    int depthStreamHeight;
+    //    int irStreamFormat;  // infrared stream frame rate and resolution are same as depth stream
+
+    // color sensor
+    int colorAutoExposure;
+    int colorExposureTime;
+    int colorGain;
+    int colorAutoWhiteBalance;
+    int colorWhiteBalance;
+    int colorHue;
+    int colorSaturation;
+    int colorContrast;
+    int colorBrightness;
+    int colorSharpness;
+    int colorGamma;
+    int colorBacklightCompensation;
+    int colorPowerLineFrequency;
+    //    // stream profile
+    //    int colorStreamFormat;
+    //    int colorStreamFrameRate;
+    //    int colorStreamWidth;
+    //    int colorStreamHeight;
+};
+
+class G330PresetManager : public IPresetManager, public DeviceComponentBase {
+public:
+    G330PresetManager(IDevice *owner);
+    ~G330PresetManager() override = default;
+
+    void                            loadPreset(const std::string &presetName) override;
+    const std::string              &getCurrentPresetName() const override;
+    const std::vector<std::string> &getAvailablePresetList() const override;
+    void                            loadPresetFromJsonData(const std::string &presetName, const std::vector<uint8_t> &jsonData) override;
+    void                            loadPresetFromJsonFile(const std::string &filePath) override;
+    const std::vector<uint8_t>     &exportSettingsAsPresetJsonData(const std::string &presetName) override;
+    void                            exportSettingsAsPresetJsonFile(const std::string &filePath) override;
+
+private:
+    void        storeCurrentParamsAsCustomPreset(const std::string &presetName);
+    void        loadCustomPreset(const std::string &presetName, const G330Preset &preset);
+    void        loadPresetFromJsonValue(const std::string &presetName, const Json::Value &root);
+    Json::Value exportSettingsAsPresetJsonValue(const std::string &presetName);
+
+private:
+    std::vector<std::string> availablePresets_;
+    std::string              currentPreset_;
+    std::vector<uint8_t>     tmpJsonData_;
+
+    std::map<std::string, G330Preset> customPresets_;
+};
+
+}  // namespace libobsensor
diff --git a/src/device/gemini330/G330PropertyAccessors.cpp b/src/device/gemini330/G330PropertyAccessors.cpp
new file mode 100644
index 00000000..7cc256d6
--- /dev/null
+++ b/src/device/gemini330/G330PropertyAccessors.cpp
@@ -0,0 +1,122 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "G330PropertyAccessors.hpp"
+#include "frameprocessor/FrameProcessor.hpp"
+#include "sensor/video/DisparityBasedSensor.hpp"
+#include "IDeviceComponent.hpp"
+
+namespace libobsensor {
+
+G330Disp2DepthPropertyAccessor::G330Disp2DepthPropertyAccessor(IDevice *owner) : owner_(owner), hwDisparityToDepthEnabled_(true) {}
+
+void G330Disp2DepthPropertyAccessor::setPropertyValue(uint32_t propertyId, const OBPropertyValue &value) {
+    switch(propertyId) {
+    case OB_PROP_SDK_DISPARITY_TO_DEPTH_BOOL: {
+        auto processor = owner_->getComponentT<FrameProcessor>(OB_DEV_COMPONENT_DEPTH_FRAME_PROCESSOR);
+        processor->setPropertyValue(propertyId, value);
+    } break;
+    case OB_PROP_DISPARITY_TO_DEPTH_BOOL: {
+        auto commandPort = owner_->getComponentT<IBasicPropertyAccessor>(OB_DEV_COMPONENT_MAIN_PROPERTY_ACCESSOR);
+        commandPort->setPropertyValue(propertyId, value);
+        hwDisparityToDepthEnabled_ = static_cast<bool>(value.intValue);
+
+        // update convert output frame as disparity frame
+        markOutputDisparityFrame(!hwDisparityToDepthEnabled_);
+    } break;
+    case OB_PROP_DEPTH_UNIT_FLEXIBLE_ADJUSTMENT_FLOAT: {
+        auto commandPort = owner_->getComponentT<IBasicPropertyAccessor>(OB_DEV_COMPONENT_MAIN_PROPERTY_ACCESSOR);
+        commandPort->setPropertyValue(propertyId, value);
+
+        auto processor = owner_->getComponentT<FrameProcessor>(OB_DEV_COMPONENT_DEPTH_FRAME_PROCESSOR);
+        processor->setPropertyValue(propertyId, value);
+
+        // update depth unit
+        auto sensor          = owner_->getComponentT<ISensor>(OB_DEV_COMPONENT_DEPTH_SENSOR).get();
+        auto disparitySensor = std::dynamic_pointer_cast<DisparityBasedSensor>(sensor);
+        if(disparitySensor) {
+            disparitySensor->setDepthUnit(value.floatValue);
+        }
+
+    } break;
+
+    default: {
+        auto commandPort = owner_->getComponentT<IBasicPropertyAccessor>(OB_DEV_COMPONENT_MAIN_PROPERTY_ACCESSOR);
+        commandPort->setPropertyValue(propertyId, value);
+    } break;
+    }
+}
+
+void G330Disp2DepthPropertyAccessor::getPropertyValue(uint32_t propertyId, OBPropertyValue *value) {
+    switch(propertyId) {
+    case OB_PROP_SDK_DISPARITY_TO_DEPTH_BOOL: {
+        auto processor = owner_->getComponentT<FrameProcessor>(OB_DEV_COMPONENT_DEPTH_FRAME_PROCESSOR);
+        processor->getPropertyValue(propertyId, value);
+    } break;
+    case OB_PROP_DISPARITY_TO_DEPTH_BOOL: {
+        value->intValue = hwDisparityToDepthEnabled_;
+    } break;
+    case OB_PROP_DEPTH_UNIT_FLEXIBLE_ADJUSTMENT_FLOAT: {
+        auto            commandPort = owner_->getComponentT<IBasicPropertyAccessor>(OB_DEV_COMPONENT_MAIN_PROPERTY_ACCESSOR);
+        OBPropertyValue hwDisparityValue;
+        commandPort->getPropertyValue(OB_PROP_DISPARITY_TO_DEPTH_BOOL, &hwDisparityValue);
+        if(hwDisparityValue.intValue == 0) {
+            auto processor = owner_->getComponentT<FrameProcessor>(OB_DEV_COMPONENT_DEPTH_FRAME_PROCESSOR);
+            processor->getPropertyValue(propertyId, value);
+        }
+        else {
+            commandPort->getPropertyValue(propertyId, value);
+        }
+    } break;
+    default: {
+        auto commandPort = owner_->getComponentT<IBasicPropertyAccessor>(OB_DEV_COMPONENT_MAIN_PROPERTY_ACCESSOR);
+        commandPort->getPropertyValue(propertyId, value);
+    } break;
+    }
+}
+
+void G330Disp2DepthPropertyAccessor::getPropertyRange(uint32_t propertyId, OBPropertyRange *range) {
+    switch(propertyId) {
+    case OB_PROP_SDK_DISPARITY_TO_DEPTH_BOOL: {
+        auto processor = owner_->getComponentT<FrameProcessor>(OB_DEV_COMPONENT_DEPTH_FRAME_PROCESSOR);
+        processor->getPropertyRange(propertyId, range);
+    } break;
+    case OB_PROP_DISPARITY_TO_DEPTH_BOOL: {
+        range->min.intValue  = 0;
+        range->max.intValue  = 1;
+        range->step.intValue = 1;
+        range->def.intValue  = 1;
+        range->cur.intValue  = static_cast<int32_t>(hwDisparityToDepthEnabled_);
+    } break;
+    case OB_PROP_DEPTH_UNIT_FLEXIBLE_ADJUSTMENT_FLOAT: {
+        auto            processor = owner_->getComponentT<FrameProcessor>(OB_DEV_COMPONENT_DEPTH_FRAME_PROCESSOR);
+        OBPropertyValue swDisparityEnable;
+        processor->getPropertyValue(OB_PROP_SDK_DISPARITY_TO_DEPTH_BOOL, &swDisparityEnable);
+        if(swDisparityEnable.intValue == 1) {
+            processor->getPropertyRange(propertyId, range);
+        }
+        else {
+            auto commandPort = owner_->getComponentT<IBasicPropertyAccessor>(OB_DEV_COMPONENT_MAIN_PROPERTY_ACCESSOR);
+            commandPort->getPropertyRange(propertyId, range);
+        }
+    } break;
+    default: {
+        auto commandPort = owner_->getComponentT<IBasicPropertyAccessor>(OB_DEV_COMPONENT_MAIN_PROPERTY_ACCESSOR);
+        commandPort->getPropertyRange(propertyId, range);
+    } break;
+    }
+}
+
+void G330Disp2DepthPropertyAccessor::markOutputDisparityFrame(bool enable) {
+    if(!owner_->isComponentExists(OB_DEV_COMPONENT_DEPTH_SENSOR)) {
+        return;
+    }
+
+    auto sensor          = owner_->getComponentT<ISensor>(OB_DEV_COMPONENT_DEPTH_SENSOR).get();
+    auto disparitySensor = std::dynamic_pointer_cast<DisparityBasedSensor>(sensor);
+    if(disparitySensor) {
+        disparitySensor->markOutputDisparityFrame(enable);
+    }
+}
+
+}  // namespace libobsensor
diff --git a/src/device/gemini330/G330PropertyAccessors.hpp b/src/device/gemini330/G330PropertyAccessors.hpp
new file mode 100644
index 00000000..27fb3b35
--- /dev/null
+++ b/src/device/gemini330/G330PropertyAccessors.hpp
@@ -0,0 +1,27 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include "IProperty.hpp"
+#include "IDevice.hpp"
+
+namespace libobsensor {
+class G330Disp2DepthPropertyAccessor : public IBasicPropertyAccessor {
+public:
+    explicit G330Disp2DepthPropertyAccessor(IDevice *owner);
+    virtual ~G330Disp2DepthPropertyAccessor() noexcept = default;
+
+    virtual void setPropertyValue(uint32_t propertyId, const OBPropertyValue &value) override;
+    virtual void getPropertyValue(uint32_t propertyId, OBPropertyValue *value) override;
+    virtual void getPropertyRange(uint32_t propertyId, OBPropertyRange *range) override;
+
+private:
+    void markOutputDisparityFrame(bool enable);
+
+private:
+    IDevice *owner_;
+
+    bool hwDisparityToDepthEnabled_;
+    bool swDisparityToDepthEnabled_;
+};
+}  // namespace libobsensor
diff --git a/src/device/gemini330/G330SensorStreamStrategy.cpp b/src/device/gemini330/G330SensorStreamStrategy.cpp
new file mode 100644
index 00000000..a7613930
--- /dev/null
+++ b/src/device/gemini330/G330SensorStreamStrategy.cpp
@@ -0,0 +1,121 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "G330SensorStreamStrategy.hpp"
+#include "G330DepthWorkModeManager.hpp"
+#include "exception/ObException.hpp"
+#include <vector>
+#include <sstream>
+#include <memory>
+#include <algorithm>
+
+namespace libobsensor {
+
+G330SensorStreamStrategy::G330SensorStreamStrategy(IDevice *owner) : DeviceComponentBase(owner) {}
+
+G330SensorStreamStrategy::~G330SensorStreamStrategy() noexcept {}
+
+void G330SensorStreamStrategy::markStreamActivated(const std::shared_ptr<const StreamProfile> &profile) {
+    std::lock_guard<std::mutex> lock(startedStreamListMutex_);
+    auto                        streamType = profile->getType();
+    auto                        iter       = std::find_if(activatedStreamList_.begin(), activatedStreamList_.end(),
+                                                          [streamType](const std::shared_ptr<const StreamProfile> &sp) { return sp->getType() == streamType; });
+    if(iter != activatedStreamList_.end()) {
+        throw unsupported_operation_exception(utils::string::to_string() << "The " << streamType << " has already been started.");
+    }
+
+    activatedStreamList_.push_back(profile);
+}
+
+void G330SensorStreamStrategy::markStreamDeactivated(const std::shared_ptr<const StreamProfile> &profile) {
+    std::lock_guard<std::mutex> lock(startedStreamListMutex_);
+    auto                        streamType = profile->getType();
+    auto                        iter       = std::find_if(activatedStreamList_.begin(), activatedStreamList_.end(),
+                                                          [streamType](const std::shared_ptr<const StreamProfile> &sp) { return sp->getType() == streamType; });
+    if(iter == activatedStreamList_.end()) {
+        throw unsupported_operation_exception(utils::string::to_string() << "The " << streamType << " has not been started.");
+    }
+    activatedStreamList_.erase(iter);
+}
+
+void G330SensorStreamStrategy::validateStream(const std::shared_ptr<const StreamProfile> &profile) {
+    validateStream(std::vector<std::shared_ptr<const StreamProfile>>{ profile });
+}
+
+void G330SensorStreamStrategy::validateStream(const std::vector<std::shared_ptr<const StreamProfile>> &profiles) {
+    {
+        std::lock_guard<std::mutex> lock(startedStreamListMutex_);
+        for(auto profile: profiles) {
+            auto streamType = profile->getType();
+            auto iter       = std::find_if(activatedStreamList_.begin(), activatedStreamList_.end(),
+                                           [streamType](const std::shared_ptr<const StreamProfile> &sp) { return sp->getType() == streamType; });
+            if(iter != activatedStreamList_.end()) {
+                throw unsupported_operation_exception(utils::string::to_string() << "The " << streamType << " has already been started.");
+            }
+        }
+    }
+    validateDepthAndIrStream(profiles);
+    validatePreset(profiles);
+}
+
+void G330SensorStreamStrategy::validateDepthAndIrStream(const std::vector<std::shared_ptr<const StreamProfile>> &profiles) {
+    std::lock_guard<std::mutex> lock(startedStreamListMutex_);
+    auto                        tempStartedStreamList = activatedStreamList_;
+    for(auto &profile: profiles) {
+        auto streamType = profile->getType();
+        if(streamType != OB_STREAM_DEPTH && streamType != OB_STREAM_IR_LEFT && streamType != OB_STREAM_IR_RIGHT) {
+            continue;
+        }
+        auto vsp  = profile->as<VideoStreamProfile>();
+        auto iter = std::find_if(tempStartedStreamList.begin(), tempStartedStreamList.end(), [vsp](const std::shared_ptr<const StreamProfile> &sp) {
+            auto cmpStreamType = sp->getType();
+            if(cmpStreamType != OB_STREAM_DEPTH && cmpStreamType != OB_STREAM_IR_LEFT && cmpStreamType != OB_STREAM_IR_RIGHT) {
+                return false;
+            }
+            auto cmpVsp = sp->as<VideoStreamProfile>();
+            return cmpVsp->getWidth() != vsp->getWidth() && cmpVsp->getHeight() != vsp->getHeight() && cmpVsp->getFps() != vsp->getFps();
+        });
+        if(iter != tempStartedStreamList.end()) {
+            throw unsupported_operation_exception(utils::string::to_string()
+                                                  << "The depth/ir streams must have the same resolution and frame rate. " << profile);
+        }
+        tempStartedStreamList.push_back(profile);
+    }
+}
+
+void G330SensorStreamStrategy::validatePreset(const std::vector<std::shared_ptr<const StreamProfile>> &profiles) {
+    OBDepthWorkMode_Internal currentDepthMode;
+
+    {
+        auto owner               = getOwner();
+        auto depthWorkModeManager = owner->getComponentT<G330DepthWorkModeManager>(OB_DEV_COMPONENT_DEPTH_WORK_MODE_MANAGER);
+        currentDepthMode          = depthWorkModeManager->getCurrentDepthWorkMode();
+    }
+
+    for(auto profile: profiles) {
+        auto        streamType  = profile->getType();
+        const char *FactoryMode = "Factory Calib";
+        if(strncmp(currentDepthMode.name, FactoryMode, strlen(FactoryMode)) == 0) {
+            switch(streamType) {
+            case OB_STREAM_IR_LEFT:
+            case OB_STREAM_IR_RIGHT: {
+                auto vsp    = profile->as<VideoStreamProfile>();
+                auto width  = vsp->getWidth();
+                auto height = vsp->getHeight();
+                auto format = vsp->getFormat();
+                if(!(((width == 1280 && height == 800) || (width == 640 && height == 400)) && (format == OB_FORMAT_Y12 || format == OB_FORMAT_Y16))) {
+                    throw unsupported_operation_exception("Preset is in Factory Calib mode, only support IR streams at 1280x800@Y12/Y16 and 640x400@Y12/Y16");
+                }
+            } break;
+            case OB_STREAM_DEPTH:
+                throw unsupported_operation_exception("Preset is in Factory Calib mode, dose not support Depth stream");
+                break;
+
+            default:
+                break;
+            }
+        }
+    }
+}
+
+}  // namespace libobsensor
diff --git a/src/device/gemini330/G330SensorStreamStrategy.hpp b/src/device/gemini330/G330SensorStreamStrategy.hpp
new file mode 100644
index 00000000..ea8431c7
--- /dev/null
+++ b/src/device/gemini330/G330SensorStreamStrategy.hpp
@@ -0,0 +1,34 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include "ISensorStreamStrategy.hpp"
+#include "G330DepthWorkModeManager.hpp"
+#include "stream/StreamProfile.hpp"
+#include "exception/ObException.hpp"
+#include "logger/LoggerInterval.hpp"
+#include "DeviceComponentBase.hpp"
+#include <map>
+
+namespace libobsensor {
+
+class G330SensorStreamStrategy : public ISensorStreamStrategy, public DeviceComponentBase {
+public:
+    G330SensorStreamStrategy(IDevice *owner);
+    virtual ~G330SensorStreamStrategy() noexcept;
+
+    void validateStream(const std::shared_ptr<const StreamProfile> &profile) override;
+    void validateStream(const std::vector<std::shared_ptr<const StreamProfile>> &profiles) override;
+    void markStreamActivated(const std::shared_ptr<const StreamProfile> &profile) override;
+    void markStreamDeactivated(const std::shared_ptr<const StreamProfile> &profile) override;
+
+private:
+    void validateDepthAndIrStream(const std::vector<std::shared_ptr<const StreamProfile>> &profiles);
+    void validatePreset(const std::vector<std::shared_ptr<const StreamProfile>> &profiles);
+
+private:
+    std::mutex                                        startedStreamListMutex_;
+    std::vector<std::shared_ptr<const StreamProfile>> activatedStreamList_;
+};
+
+}  // namespace libobsensor
diff --git a/src/device/protocol/CMakeLists.txt b/src/device/protocol/CMakeLists.txt
new file mode 100644
index 00000000..81c031e9
--- /dev/null
+++ b/src/device/protocol/CMakeLists.txt
@@ -0,0 +1,7 @@
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+cmake_minimum_required(VERSION 3.5)
+
+target_sources(${OB_TARGET_DEVICE} PRIVATE ${CMAKE_CURRENT_LIST_DIR}/Protocol.cpp ${CMAKE_CURRENT_LIST_DIR}/Protocol.hpp)
+
diff --git a/src/device/protocol/Protocol.cpp b/src/device/protocol/Protocol.cpp
new file mode 100644
index 00000000..77e260a7
--- /dev/null
+++ b/src/device/protocol/Protocol.cpp
@@ -0,0 +1,426 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "Protocol.hpp"
+#include "logger/Logger.hpp"
+#include "exception/ObException.hpp"
+
+#include <sstream>
+
+namespace libobsensor {
+namespace protocol {
+
+bool checkStatus(HpStatus stat, bool throwException) {
+    std::string retMsg;
+    switch(stat.statusCode) {
+    case HP_STATUS_OK:
+        break;
+    case HP_STATUS_DEVICE_RESPONSE_WARNING:
+        LOG_WARN("Request failed, device response with warning, errorCode: {0}, msg:{1}", stat.respErrorCode, stat.msg);
+        return false;
+    case HP_STATUS_DEVICE_RESPONSE_ERROR:
+        retMsg = std::string("Request failed, device response with error, errorCode: ") + std::to_string(stat.respErrorCode) + ", msg: " + stat.msg;
+        if(throwException) {
+            throw io_exception(retMsg);
+        }
+        else {
+            LOG_ERROR(retMsg);
+            return false;
+        }
+        break;
+    case HP_STATUS_DEVICE_RESPONSE_ERROR_UNKNOWN:
+        if(throwException) {
+            throw io_exception("Request failed, device response with unknown error!");
+        }
+        else {
+            LOG_ERROR("Request failed, device response with unknown error!");
+            return false;
+        }
+        break;
+
+    default:
+        retMsg = std::string("Request failed, statusCode: ") + std::to_string(stat.statusCode) + ", msg: " + stat.msg;
+        if(throwException) {
+            throw io_exception(retMsg);
+        }
+        else {
+            LOG_ERROR(retMsg);
+            return false;
+        }
+        break;
+    }
+    return true;
+}
+
+uint16_t getExpectedRespSize(HpOpCodes opcode) {
+    uint16_t size = 64;
+    if(opcode == OPCODE_GET_STRUCTURE_DATA || opcode == OPCODE_GET_STRUCTURE_DATA_V1_1 || opcode == OPCODE_HEARTBEAT_AND_STATE) {
+        size = 512;
+    }
+    else if(opcode == OPCODE_READ_RAW_DATA || opcode == OPCODE_READ_STRUCT_DATA_LIST_V1_1) {
+        size = 1024;
+    }
+    return size;
+}
+
+HpStatus validateResp(uint8_t *dataBuf, uint16_t dataSize, uint16_t expectedOpcode, uint16_t requestId) {
+    HpStatus    retStatus;
+    RespHeader *header = (RespHeader *)dataBuf;
+
+    if(header->magic != HP_RESPONSE_MAGIC) {
+        std::ostringstream ssMsg;
+        ssMsg << "Device response with bad magic " << std::hex << ", magic=0x" << header->magic << ", expectOpCode=0x" << HP_RESPONSE_MAGIC;
+        retStatus.statusCode    = HP_STATUS_DEVICE_RESPONSE_BAD_MAGIC;
+        retStatus.respErrorCode = HP_RESP_ERROR_UNKNOWN;
+        retStatus.msg           = ssMsg.str();
+        return retStatus;
+    }
+
+    if(header->requestId != requestId) {
+        std::ostringstream ssMsg;
+        ssMsg << "Device response with inconsistent response requestId, cmdId=" << header->requestId << ", requestId=" << requestId;
+        retStatus.statusCode    = HP_STATUS_DEVICE_RESPONSE_WRONG_ID;
+        retStatus.respErrorCode = HP_RESP_ERROR_UNKNOWN;
+        retStatus.msg           = ssMsg.str();
+        return retStatus;
+    }
+
+    if(header->opcode != expectedOpcode) {
+        std::ostringstream ssMsg;
+        ssMsg << "Device response with inconsistent opcode, opcode=" << header->opcode << ", expectedOpcode=" << expectedOpcode;
+        retStatus.statusCode    = HP_STATUS_DEVICE_RESPONSE_WRONG_OPCODE;
+        retStatus.respErrorCode = HP_RESP_ERROR_UNKNOWN;
+        retStatus.msg           = ssMsg.str();
+        return retStatus;
+    }
+
+    uint16_t respDataSize = header->sizeInHalfWords * 2 - sizeof(RespHeader::errorCode);
+    if(respDataSize + HP_RESP_HEADER_SIZE > dataSize) {
+        retStatus.statusCode    = HP_STATUS_DEVICE_RESPONSE_WRONG_DATA_SIZE;
+        retStatus.respErrorCode = HP_RESP_ERROR_UNKNOWN;
+        retStatus.msg           = "Device response with wrong data size";
+        return retStatus;
+    }
+
+    if(header->errorCode == HP_RESP_OK) {
+        retStatus.statusCode    = HP_STATUS_OK;
+        retStatus.respErrorCode = HP_RESP_OK;
+        retStatus.msg           = "";
+        return retStatus;
+    }
+    else if(header->errorCode == HP_RESP_ERROR_UNKNOWN) {
+        retStatus.statusCode    = HP_STATUS_DEVICE_RESPONSE_ERROR_UNKNOWN;
+        retStatus.respErrorCode = (HpRespErrorCode)header->errorCode;
+        retStatus.msg           = "Device response with unknown error";
+        return retStatus;
+    }
+
+    std::string msg = respDataSize > 0 ? (char *)(dataBuf + sizeof(RespHeader)) : "";
+    if(header->errorCode >= 0x8000 && header->errorCode <= 0xfffe) {
+        retStatus.statusCode = HP_STATUS_DEVICE_RESPONSE_WARNING;
+    }
+    else {
+        retStatus.statusCode = HP_STATUS_DEVICE_RESPONSE_ERROR;
+    }
+    retStatus.respErrorCode = (HpRespErrorCode)header->errorCode;
+    retStatus.msg           = msg;
+    return retStatus;
+}
+
+HpStatus execute(const std::shared_ptr<IVendorDataPort> &dataPort, uint8_t *reqData, uint16_t reqDataSize, uint8_t *respData, uint16_t *respDataSize) {
+    HpStatusCode rc = HP_STATUS_OK;
+    HpStatus     hpStatus;
+
+    uint16_t requestId    = ((ReqHeader *)(reqData))->requestId;
+    uint16_t opcode       = ((ReqHeader *)(reqData))->opcode;
+    uint16_t nRetriesLeft = HP_NOT_READY_RETRIES;
+    uint32_t exceptRecLen = getExpectedRespSize(static_cast<HpOpCodes>(opcode));
+
+    while(nRetriesLeft-- > 0)  // loop until device is ready
+    {
+        rc = HP_STATUS_OK;
+        try {
+            *respDataSize = static_cast<uint16_t>(dataPort->sendAndReceive(reqData, static_cast<uint32_t>(reqDataSize), respData, exceptRecLen));
+        }
+        catch(...) {
+            rc = HP_STATUS_CONTROL_TRANSFER_FAILED;
+        }
+
+        if(rc == HP_STATUS_OK) {
+            hpStatus = validateResp(respData, *respDataSize, opcode, requestId);
+
+            if(hpStatus.statusCode != HP_STATUS_DEVICE_RESPONSE_WRONG_ID && hpStatus.respErrorCode != HP_RESP_ERROR_DEVICE_BUSY) {
+                break;
+            }
+        }
+        else {
+            hpStatus.statusCode    = rc;
+            hpStatus.respErrorCode = HP_RESP_ERROR_UNKNOWN;
+            hpStatus.msg           = "Send control transfer failed!";
+            break;
+        }
+
+        // Retry after delay
+        std::this_thread::sleep_for(std::chrono::milliseconds(100));
+    }
+    return hpStatus;
+}
+
+uint16_t generateRequestId() {
+    static uint16_t requestId = 0;
+    requestId++;
+    return requestId;
+}
+
+GetPropertyReq *initGetPropertyReq(uint8_t *dataBuf, uint32_t propertyId) {
+    auto *req                   = reinterpret_cast<GetPropertyReq *>(dataBuf);
+    req->header.magic           = HP_REQUEST_MAGIC;
+    req->header.sizeInHalfWords = 2;
+    req->header.opcode          = OPCODE_GET_PROPERTY;
+    req->header.requestId       = generateRequestId();
+    req->propertyId             = propertyId;
+    return req;
+}
+
+SetPropertyReq *initSetPropertyReq(uint8_t *dataBuf, uint32_t propertyId, uint32_t value) {
+    auto *req                   = reinterpret_cast<SetPropertyReq *>(dataBuf);
+    req->header.magic           = HP_REQUEST_MAGIC;
+    req->header.sizeInHalfWords = 4;
+    req->header.opcode          = OPCODE_SET_PROPERTY;
+    req->header.requestId       = generateRequestId();
+    req->propertyId             = propertyId;
+    req->value                  = value;
+    return req;
+}
+
+GetStructureDataReq *initGetStructureDataReq(uint8_t *dataBuf, uint32_t propertyId) {
+    auto *req                   = reinterpret_cast<GetStructureDataReq *>(dataBuf);
+    req->header.magic           = HP_REQUEST_MAGIC;
+    req->header.sizeInHalfWords = 2;
+    req->header.opcode          = OPCODE_GET_STRUCTURE_DATA;
+
+    req->header.requestId = generateRequestId();
+    req->propertyId       = propertyId;
+    return req;
+}
+
+SetStructureDataReq *initSetStructureDataReq(uint8_t *dataBuf, uint32_t propertyId, const uint8_t *data, uint16_t dataSize) {
+    auto *req                   = reinterpret_cast<SetStructureDataReq *>(dataBuf);
+    req->header.magic           = HP_REQUEST_MAGIC;
+    req->header.sizeInHalfWords = 2 + (dataSize + 1) / 2;
+    req->header.opcode          = OPCODE_SET_STRUCTURE_DATA;
+    req->header.requestId       = generateRequestId();
+    req->propertyId             = propertyId;
+    memcpy(req->data, data, dataSize);
+    return req;
+}
+
+HeartbeatAndStateReq *initHeartbeatAndStateReq(uint8_t *dataBuf) {
+    auto *req                   = reinterpret_cast<HeartbeatAndStateReq *>(dataBuf);
+    req->header.magic           = HP_REQUEST_MAGIC;
+    req->header.sizeInHalfWords = 0;
+    req->header.opcode          = OPCODE_HEARTBEAT_AND_STATE;
+    req->header.requestId       = generateRequestId();
+    return req;
+}
+
+HeartbeatAndStateResp *parseHeartbeatAndStateResp(uint8_t *dataBuf, uint16_t dataSize) {
+    auto *resp = reinterpret_cast<HeartbeatAndStateResp *>(dataBuf);
+    if(dataSize < sizeof(HeartbeatAndStateResp) - 1) {  // may dose'nt have any msg, subtract 1 byte to avoid overflow
+        throw io_exception("Device response with wrong data size");
+    }
+    return resp;
+}
+
+GetPropertyResp *parseGetPropertyResp(uint8_t *dataBuf, uint16_t dataSize) {
+    auto *resp = reinterpret_cast<GetPropertyResp *>(dataBuf);
+    if(dataSize < sizeof(GetPropertyResp)) {
+        throw io_exception("Device response with wrong data size");
+    }
+    return resp;
+}
+
+SetPropertyResp *parseSetPropertyResp(uint8_t *dataBuf, uint16_t dataSize) {
+    auto *resp = reinterpret_cast<SetPropertyResp *>(dataBuf);
+    if(dataSize < sizeof(SetPropertyResp)) {
+        throw io_exception("Device response with wrong data size");
+    }
+    return resp;
+}
+
+GetStructureDataResp *parseGetStructureDataResp(uint8_t *dataBuf, uint16_t dataSize) {
+    auto *resp = reinterpret_cast<GetStructureDataResp *>(dataBuf);
+    if(dataSize < sizeof(GetStructureDataResp)) {
+        throw io_exception("Device response with wrong data size");
+    }
+    return resp;
+}
+
+int16_t getStructureDataSize(const GetStructureDataResp *resp) {
+    return resp->header.sizeInHalfWords * 2 - sizeof(RespHeader::errorCode);
+}
+
+SetStructureDataResp *parseSetStructureDataResp(uint8_t *dataBuf, uint16_t dataSize) {
+    auto *resp = reinterpret_cast<SetStructureDataResp *>(dataBuf);
+    if(dataSize < sizeof(SetStructureDataResp)) {
+        throw io_exception("Device response with wrong data size");
+    }
+    return resp;
+}
+
+GetPropertyReq *initGetCmdVersionReq(uint8_t *dataBuf, uint32_t propertyId) {
+    auto *req                   = reinterpret_cast<GetPropertyReq *>(dataBuf);
+    req->header.magic           = HP_REQUEST_MAGIC;
+    req->header.sizeInHalfWords = 2;
+    req->header.opcode          = OPCODE_GET_COMMAND_VERSION_V1_1;
+    req->header.requestId       = generateRequestId();
+    req->propertyId             = propertyId;
+    return req;
+}
+
+GetCmdVerDataResp *parseGetCmdVerDataResp(uint8_t *dataBuf, uint16_t dataSize) {
+    auto *resp = reinterpret_cast<GetCmdVerDataResp *>(dataBuf);
+    if(dataSize < sizeof(GetCmdVerDataResp)) {
+        throw io_exception("Device response with wrong data size");
+    }
+    return resp;
+}
+
+GetRawDataLengthResp *parseGetRawDataLengthResp(uint8_t *dataBuf, uint16_t dataSize) {
+    auto *resp = reinterpret_cast<GetRawDataLengthResp *>(dataBuf);
+    if(dataSize < sizeof(GetRawDataLengthResp)) {
+        throw io_exception("Device response with wrong data size");
+    }
+    return resp;
+}
+
+ReadRawDataResp *parseReadRawDataResp(uint8_t *dataBuf, uint16_t dataSize) {
+    auto *resp = reinterpret_cast<ReadRawDataResp *>(dataBuf);
+    if(dataSize < sizeof(ReadRawDataResp)) {
+        throw io_exception("Device response with wrong data size");
+    }
+    return resp;
+}
+
+GetStructureDataReqV1_1 *initGetStructureDataReqV1_1(uint8_t *dataBuf, uint32_t propertyId) {
+    auto *req                   = reinterpret_cast<GetStructureDataReqV1_1 *>(dataBuf);
+    req->header.magic           = HP_REQUEST_MAGIC;
+    req->header.sizeInHalfWords = 2;
+    req->header.opcode          = OPCODE_GET_STRUCTURE_DATA_V1_1;
+
+    req->header.requestId = generateRequestId();
+    req->propertyId       = propertyId;
+    return req;
+}
+
+SetStructureDataReqV1_1 *initSetStructureDataReqV1_1(uint8_t *dataBuf, uint32_t propertyId, uint16_t cmdVer, const uint8_t *data, uint16_t dataSize) {
+    auto *req                   = reinterpret_cast<SetStructureDataReqV1_1 *>(dataBuf);
+    req->header.magic           = HP_REQUEST_MAGIC;
+    req->header.sizeInHalfWords = 3 + (dataSize + 1) / 2;
+    req->header.opcode          = OPCODE_SET_STRUCTURE_DATA_V1_1;
+    req->header.requestId       = generateRequestId();
+    req->cmdVer                 = cmdVer;
+    req->propertyId             = propertyId;
+    memcpy(req->data, data, dataSize);
+    return req;
+}
+
+GetStructureDataRespV1_1 *parseGetStructureDataRespV1_1(uint8_t *dataBuf, uint16_t dataSize) {
+    auto *resp = reinterpret_cast<GetStructureDataRespV1_1 *>(dataBuf);
+    if(dataSize < sizeof(GetStructureDataRespV1_1)) {
+        throw io_exception("Device response with wrong data size");
+    }
+    return resp;
+}
+
+SetStructureDataRespV1_1 *parseSetStructureDataRespV1_1(uint8_t *dataBuf, uint16_t dataSize) {
+    auto *resp = reinterpret_cast<SetStructureDataRespV1_1 *>(dataBuf);
+    if(dataSize < sizeof(SetStructureDataRespV1_1)) {
+        throw io_exception("Device response with wrong data size");
+    }
+    return resp;
+}
+
+StartGetStructureDataListResp *parseStartStructureDataListResp(uint8_t *dataBuf, uint16_t dataSize) {
+    auto *resp = reinterpret_cast<StartGetStructureDataListResp *>(dataBuf);
+    if(dataSize < sizeof(StartGetStructureDataListResp)) {
+        throw io_exception("Device response with wrong data size");
+    }
+
+    return resp;
+}
+
+int16_t getStructureDataSizeV1_1(const GetStructureDataRespV1_1 *resp) {
+    return resp->header.sizeInHalfWords * 2 - sizeof(RespHeader::errorCode) - 2;
+}
+
+StartGetStructureDataListReq *initStartGetStructureDataListReq(uint8_t *dataBuf, uint32_t propertyId) {
+    auto *req                   = reinterpret_cast<StartGetStructureDataListReq *>(dataBuf);
+    req->header.magic           = HP_REQUEST_MAGIC;
+    req->header.sizeInHalfWords = 2;
+    req->header.opcode          = OPCODE_INIT_READ_STRUCT_DATA_LIST_V1_1;
+
+    req->header.requestId = generateRequestId();
+    req->propertyId       = propertyId;
+    return req;
+}
+
+GetStructureDataListReq *initGetStructureDataListReq(uint8_t *dataBuf, uint32_t propertyId, uint32_t offset, uint32_t dataSize) {
+    auto *req                   = reinterpret_cast<GetStructureDataListReq *>(dataBuf);
+    req->header.magic           = HP_REQUEST_MAGIC;
+    req->header.sizeInHalfWords = 6;
+    req->header.opcode          = OPCODE_READ_STRUCT_DATA_LIST_V1_1;
+
+    req->header.requestId = generateRequestId();
+    req->propertyId       = propertyId;
+
+    req->offset = offset;
+    req->size   = dataSize;
+    return req;
+}
+
+FinishGetStructureDataListReq *initFinishGetStructureDataListReq(uint8_t *dataBuf, uint32_t propertyId) {
+    auto *req                   = reinterpret_cast<FinishGetStructureDataListReq *>(dataBuf);
+    req->header.magic           = HP_REQUEST_MAGIC;
+    req->header.sizeInHalfWords = 2;
+    req->header.opcode          = OPCODE_FINISH_READ_STRUCT_DATA_LIST_V1_1;
+
+    req->header.requestId = generateRequestId();
+    req->propertyId       = propertyId;
+    return req;
+}
+
+GetPropertyReq *initGetRawDataLengthReq(uint8_t *dataBuf, uint32_t propertyId, uint32_t cmd) {
+    auto *req                   = reinterpret_cast<GetPropertyReq *>(dataBuf);
+    req->header.magic           = HP_REQUEST_MAGIC;
+    req->header.sizeInHalfWords = 2;
+    switch(cmd) {
+    case 0:
+        req->header.opcode = OPCODE_INIT_READ_RAW_DATA;
+        break;
+    case 1:
+        req->header.opcode = OPCODE_FINISH_READ_RAW_DATA;
+        break;
+    }
+
+    req->header.requestId = generateRequestId();
+    req->propertyId       = propertyId;
+    return req;
+}
+
+ReadRawDataReq *initReadRawDataReq(uint8_t *dataBuf, uint32_t propertyId, uint32_t offset, uint32_t size) {
+    auto *req                   = reinterpret_cast<ReadRawDataReq *>(dataBuf);
+    req->header.magic           = HP_REQUEST_MAGIC;
+    req->header.sizeInHalfWords = 6;
+    req->header.opcode          = OPCODE_READ_RAW_DATA;
+    req->header.requestId       = generateRequestId();
+
+    req->propertyId = propertyId;
+    req->offset     = offset;
+    req->size       = size;
+    return req;
+}
+
+}  // namespace protocol
+}  // namespace libobsensor
+
diff --git a/src/device/protocol/Protocol.hpp b/src/device/protocol/Protocol.hpp
new file mode 100644
index 00000000..b3bdd04d
--- /dev/null
+++ b/src/device/protocol/Protocol.hpp
@@ -0,0 +1,287 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include "ISourcePort.hpp"
+#include <sstream>
+
+namespace libobsensor {
+namespace protocol {
+
+// HP mean hardware protocol
+
+#define HP_REQUEST_MAGIC 0x4d47   // MG
+#define HP_RESPONSE_MAGIC 0x4252  // BR
+
+#define HP_REQ_HEADER_SIZE sizeof(ReqHeader)
+#define HP_RESP_HEADER_SIZE sizeof(RespHeader)
+
+#define HP_NOT_READY_RETRIES 2
+
+enum HpOpCodes {
+    OPCODE_GET_PROPERTY        = 1,
+    OPCODE_SET_PROPERTY        = 2,
+    OPCODE_GET_STRUCTURE_DATA  = 3,
+    OPCODE_SET_STRUCTURE_DATA  = 4,
+    OPCODE_HEARTBEAT_AND_STATE = 5,
+
+    OPCODE_INIT_READ_RAW_DATA   = 17,
+    OPCODE_READ_RAW_DATA        = 18,
+    OPCODE_FINISH_READ_RAW_DATA = 19,
+
+    // v1.1 protocol introduction
+    OPCODE_GET_COMMAND_VERSION_V1_1 = 26,  // v1.1 control command version number, determines how the control command parses data content
+    OPCODE_GET_STRUCTURE_DATA_V1_1  = 27,  // v1.1 structure type data reading
+    OPCODE_SET_STRUCTURE_DATA_V1_1  = 28,  // v1.1 Structure type data setting
+
+    OPCODE_INIT_READ_STRUCT_DATA_LIST_V1_1    = 29,    // v1.1 Initialize structure type list data reading
+    OPCODE_READ_STRUCT_DATA_LIST_V1_1         = 30,    // v1.1 Structure type list data reading
+    OPCODE_FINISH_READ_STRUCT_DATA_LIST_V1_1  = 31,    // v1.1 ends structure type list data reading
+    OPCODE_INIT_WRITE_STRUCT_DATA_LIST_V1_1   = 32,    // v1.1 Initialize structure type list data writing
+    OPCODE_WRITE_STRUCT_DATA_LIST_V1_1        = 33,    // v1.1 Structure type list data writing
+    OPCODE_FINISH_WRITE_STRUCT_DATA_LIST_V1_1 = 34,    // v1.1 ends writing structure type list data
+    OPCODE_GET_PROTOCOL_VERSION               = 0xfe,  // Get the protocol version number supported by the firmware
+};
+
+// Command operation hpStatus code -> used for program hpStatus return
+enum HpStatusCode {
+    HP_STATUS_OK = 0,
+
+    HP_STATUS_NO_DEVICE_FOUND,
+    HP_STATUS_CONTROL_TRANSFER_FAILED,  // Transmission error
+    HP_STATUS_DATA_TRANSFER_BUSY,       // Data transfer busy
+
+    // Request error
+    HP_STATUS_REQUEST_DATA_SIZE_ERROR,
+
+    // Device response error
+    HP_STATUS_DEVICE_RESPONSE_BAD_MAGIC,
+    HP_STATUS_DEVICE_RESPONSE_WRONG_ID,
+    HP_STATUS_DEVICE_RESPONSE_WRONG_OPCODE,
+    HP_STATUS_DEVICE_RESPONSE_WRONG_DATA_SIZE,
+    HP_STATUS_DEVICE_RESPONSE_ERROR,            // error code=0x0001~0x7fff
+    HP_STATUS_DEVICE_RESPONSE_WARNING,          // error code=0x8000~0xfffe
+    HP_STATUS_DEVICE_RESPONSE_ERROR_UNKNOWN,    // error code = 0xffff
+    HP_STATUS_DEVICE_RESPONSE_DATA_SIZE_ERROR,  //
+    HP_STATUS_DEVICE_RESPONSE_CMD_VERSION_UNMATCHED,
+    HP_STATUS_UNKNOWN_ERROR = 0xffff,
+};
+
+// Status code returned by device command response -> used for communication between SDK and device
+enum HpRespErrorCode {
+    HP_RESP_OK = 0,
+
+    // error
+    HP_RESP_ERROR_INVALID_REQUEST     = 0x0001,
+    HP_RESP_ERROR_UNSUPPORTED_REQUEST = 0x0002,
+    HP_RESP_ERROR_DEVICE_BUSY         = 0x0003,
+    HP_RESP_ERROR_ACCESS_FORBIDDEN    = 0x0004,
+
+    // warning
+    HP_RESP_WARNING_REPETITIVE_REQUEST = 0x8000,
+
+    // unknown
+    HP_RESP_ERROR_UNKNOWN = 0xffff,
+};
+
+struct HpStatus {
+    HpStatusCode    statusCode    = HP_STATUS_OK;
+    HpRespErrorCode respErrorCode = HP_RESP_OK;
+    std::string     msg;
+};
+
+inline std::ostream &operator<<(std::ostream &os, const HpStatus &s) {
+    return (os << "HpStatusCode: " << s.statusCode << ", respErrorCode: " << s.respErrorCode << ", msg: " << s.msg);
+}
+
+#pragma pack(push, 1)
+typedef struct {
+    uint16_t magic;
+    uint16_t sizeInHalfWords;  // bytes/2
+    uint16_t opcode;
+    uint16_t requestId;
+} ReqHeader;
+
+typedef struct {
+    uint16_t magic;
+    uint16_t sizeInHalfWords;  // bytes/2
+    uint16_t opcode;
+    uint16_t requestId;  // device response requestId same as request requestId, used for matching request and response
+    uint16_t errorCode;
+} RespHeader;
+
+typedef struct {
+    ReqHeader header;
+    uint32_t  propertyId;
+} GetPropertyReq;
+
+typedef struct {
+    int32_t cur;  // int32_t means 4 bytes data, type is depends on propertyId
+    int32_t max;
+    int32_t min;
+    int32_t def;
+    int32_t step;
+} PropertyData;
+
+typedef struct {
+    RespHeader   header;
+    PropertyData data;
+} GetPropertyResp;
+
+typedef struct {
+    ReqHeader header;
+    uint32_t  propertyId;
+    int32_t   value;  // int32_t means 4 bytes data, type is depends on propertyId
+} SetPropertyReq;
+
+typedef struct {
+    RespHeader header;
+} SetPropertyResp;
+
+typedef struct {
+    ReqHeader header;
+    uint32_t  propertyId;
+} GetStructureDataReq;
+
+typedef struct {
+    RespHeader header;
+    uint8_t    data[1];
+} GetStructureDataResp;
+
+typedef struct {
+    ReqHeader header;
+    uint32_t  propertyId;
+    uint8_t   data[1];
+} SetStructureDataReq;
+
+typedef struct {
+    RespHeader header;
+} SetStructureDataResp;
+
+typedef struct {
+    ReqHeader header;
+    uint8_t   data[1];
+} GetCmdVerDataResp;
+
+typedef struct {
+    ReqHeader header;
+    uint32_t  propertyId;
+    uint16_t  cmdVer;
+    uint8_t   data[1];
+} SetStructureDataReqV1_1;
+
+typedef struct {
+    RespHeader header;
+} SetStructureDataRespV1_1;
+
+typedef struct {
+    ReqHeader header;
+    uint32_t  propertyId;
+} GetStructureDataReqV1_1;
+
+typedef struct {
+    RespHeader header;
+    uint16_t   cmdVer;
+    uint8_t    data[1];
+} GetStructureDataRespV1_1;
+
+typedef struct {
+    ReqHeader header;
+    uint32_t  propertyId;
+} StartGetStructureDataListReq;
+
+typedef struct {
+    RespHeader header;
+    uint16_t   cmdVer;
+    uint32_t   dataSize;
+} StartGetStructureDataListResp;
+
+typedef struct {
+    ReqHeader header;
+    uint32_t  propertyId;
+    uint32_t  offset;
+    uint32_t  size;
+} GetStructureDataListReq;
+
+typedef struct {
+    RespHeader header;
+    uint16_t   cmdVer;
+    uint32_t   dataSize;
+} GetStructureDataListResp;
+
+typedef struct {
+    ReqHeader header;
+    uint32_t  propertyId;
+} FinishGetStructureDataListReq;
+
+typedef struct {
+    RespHeader header;
+} FinishGetStructureDataListResp;
+
+typedef struct {
+    ReqHeader header;
+    uint32_t  propertyId;
+    uint32_t  offset;
+    uint32_t  size;
+} ReadRawDataReq;
+
+typedef struct {
+    RespHeader header;
+    uint8_t    data[1];
+} ReadRawDataResp;
+
+typedef struct {
+    RespHeader header;
+    uint32_t   dataSize;
+} GetRawDataLengthResp;
+
+typedef struct {
+    ReqHeader header;
+} HeartbeatAndStateReq;
+
+typedef struct {
+    RespHeader header;
+    uint64_t   state;
+    char       message[1];
+} HeartbeatAndStateResp;
+
+#pragma pack(pop)
+
+GetPropertyReq      *initGetPropertyReq(uint8_t *dataBuf, uint32_t propertyId);
+SetPropertyReq      *initSetPropertyReq(uint8_t *dataBuf, uint32_t propertyId, uint32_t value);
+GetStructureDataReq *initGetStructureDataReq(uint8_t *dataBuf, uint32_t propertyId);
+SetStructureDataReq *initSetStructureDataReq(uint8_t *dataBuf, uint32_t propertyId, const uint8_t *data, uint16_t dataSize);
+GetPropertyReq      *initGetCmdVersionReq(uint8_t *dataBuf, uint32_t propertyId);
+
+GetStructureDataReqV1_1 *initGetStructureDataReqV1_1(uint8_t *dataBuf, uint32_t propertyId);
+SetStructureDataReqV1_1 *initSetStructureDataReqV1_1(uint8_t *dataBuf, uint32_t propertyId, uint16_t cmdVer, const uint8_t *data, uint16_t dataSize);
+
+StartGetStructureDataListReq  *initStartGetStructureDataListReq(uint8_t *dataBuf, uint32_t propertyId);
+GetStructureDataListReq       *initGetStructureDataListReq(uint8_t *dataBuf, uint32_t propertyId, uint32_t offset, uint32_t dataSize);
+FinishGetStructureDataListReq *initFinishGetStructureDataListReq(uint8_t *dataBuf, uint32_t propertyId);
+GetPropertyReq                *initGetRawDataLengthReq(uint8_t *dataBuf, uint32_t propertyId, uint32_t cmd);
+ReadRawDataReq                *initReadRawDataReq(uint8_t *dataBuf, uint32_t propertyId, uint32_t offset, uint32_t size);
+
+HeartbeatAndStateReq *initHeartbeatAndStateReq(uint8_t *dataBuf);
+
+GetPropertyResp               *parseGetPropertyResp(uint8_t *dataBuf, uint16_t dataSize);
+SetPropertyResp               *parseSetPropertyResp(uint8_t *dataBuf, uint16_t dataSize);
+GetStructureDataResp          *parseGetStructureDataResp(uint8_t *dataBuf, uint16_t dataSize);
+int16_t                        getStructureDataSize(const GetStructureDataResp *resp);
+GetStructureDataRespV1_1      *parseGetStructureDataRespV1_1(uint8_t *dataBuf, uint16_t dataSize);
+SetStructureDataRespV1_1      *parseSetStructureDataRespV1_1(uint8_t *dataBuf, uint16_t dataSize);
+int16_t                        getStructureDataSizeV1_1(const GetStructureDataRespV1_1 *resp);
+SetStructureDataResp          *parseSetStructureDataResp(uint8_t *dataBuf, uint16_t dataSize);
+GetCmdVerDataResp             *parseGetCmdVerDataResp(uint8_t *dataBuf, uint16_t dataSize);
+GetRawDataLengthResp          *parseGetRawDataLengthResp(uint8_t *dataBuf, uint16_t dataSize);
+ReadRawDataResp               *parseReadRawDataResp(uint8_t *dataBuf, uint16_t dataSize);
+StartGetStructureDataListResp *parseStartStructureDataListResp(uint8_t *dataBuf, uint16_t dataSize);
+HeartbeatAndStateResp         *parseHeartbeatAndStateResp(uint8_t *dataBuf, uint16_t dataSize);
+
+HpStatus execute(const std::shared_ptr<IVendorDataPort> &dataPort, uint8_t *reqData, uint16_t reqDataSize, uint8_t *respData, uint16_t *respDataSize);
+bool     checkStatus(HpStatus stat, bool throwException = true);
+
+}  // namespace protocol
+}  // namespace libobsensor
+
diff --git a/src/filter/CMakeLists.txt b/src/filter/CMakeLists.txt
new file mode 100644
index 00000000..3a90c097
--- /dev/null
+++ b/src/filter/CMakeLists.txt
@@ -0,0 +1,36 @@
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+cmake_minimum_required(VERSION 3.5)
+
+# add the filter library with the version as the project
+add_library(filter STATIC)
+set_target_properties(filter PROPERTIES VERSION ${PROJECT_VERSION})
+
+# add the source files
+file(GLOB_RECURSE SOURCE_FILES "*.cpp" EXCLUDE unittest)
+file(GLOB_RECURSE HEADERS_FILES "*.hpp" EXCLUDE unittest)
+target_sources(filter PRIVATE ${SOURCE_FILES} ${HEADERS_FILES})
+
+# depedecencies
+target_link_libraries(filter PUBLIC ob::shared ob::core )
+target_include_directories(filter PUBLIC ${OB_PUBLIC_HEADERS_DIR} ${CMAKE_CURRENT_LIST_DIR})
+
+add_subdirectory(${OB_3RDPARTY_DIR}/dylib dylib)
+target_link_libraries(filter PUBLIC dylib::dylib)
+
+add_subdirectory(${OB_3RDPARTY_DIR}/libjpeg libjpeg)
+target_link_libraries(filter PUBLIC libjpeg::libjpeg)
+
+add_subdirectory(${OB_3RDPARTY_DIR}/libyuv libyuv)
+target_link_libraries(filter PUBLIC libyuv::libyuv)
+
+add_library(ob::filter ALIAS filter)
+ob_source_group(ob::filter)
+
+set_target_properties(filter PROPERTIES FOLDER "modules")
+
+if(OB_INSTALL_FILTER_DEV_HEADERS)
+    install(FILES ${CMAKE_CURRENT_LIST_DIR}/privatefilters/PrivFilterTypes.h DESTINATION include/libobsensor/h/)
+endif()
+
diff --git a/src/filter/FilterDecorator.cpp b/src/filter/FilterDecorator.cpp
new file mode 100644
index 00000000..b9b809ca
--- /dev/null
+++ b/src/filter/FilterDecorator.cpp
@@ -0,0 +1,318 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "FilterDecorator.hpp"
+#include "frame/FrameFactory.hpp"
+#include "exception/ObException.hpp"
+#include "logger/LoggerInterval.hpp"
+#include "utils/StringUtils.hpp"
+namespace libobsensor {
+
+const size_t DEFAULT_FRAME_QUEUE_CAPACITY = 10;
+
+FilterExtension::FilterExtension(const std::string &name) : name_(name), enabled_(true), configChanged_(false) {
+    srcFrameQueue_ = std::make_shared<FrameQueue<const Frame>>(DEFAULT_FRAME_QUEUE_CAPACITY);  // todo： read from config file to set the size of frame queue
+    LOG_DEBUG("Filter {} created with frame queue capacity {}", name_, srcFrameQueue_->capacity());
+}
+
+FilterExtension::~FilterExtension() noexcept {
+    reset();
+}
+
+const std::string &FilterExtension::getName() const {
+    return name_;
+}
+
+void FilterExtension::pushFrame(std::shared_ptr<const Frame> frame) {
+    if(!srcFrameQueue_->isStarted()) {
+        srcFrameQueue_->start([&](std::shared_ptr<const Frame> frameToProcess) {
+            std::shared_ptr<Frame> rstFrame;
+            if(enabled_) {
+                checkAndUpdateConfig();
+                BEGIN_TRY_EXECUTE({ rstFrame = process(frameToProcess); })
+                CATCH_EXCEPTION_AND_EXECUTE({  // catch all exceptions to avoid crashing on the inner thread
+                    LOG_WARN("Filter {}: exception caught while processing frame {}#{}, this frame will be dropped", name_, frameToProcess->getType(),
+                             frameToProcess->getNumber());
+                    return;
+                })
+            }
+            else {
+                rstFrame = FrameFactory::createFrameFromOtherFrame(frameToProcess, true);
+            }
+            std::unique_lock<std::mutex> lock(callbackMutex_);
+            if(callback_ && rstFrame) {
+                callback_(rstFrame);
+            }
+        });
+        LOG_DEBUG("Filter {}: start frame queue", name_);
+    }
+    srcFrameQueue_->enqueue(frame);
+}
+
+void FilterExtension::setCallback(FilterCallback cb) {
+    std::unique_lock<std::mutex> lock(callbackMutex_);
+    callback_ = cb;
+}
+
+void FilterExtension::resizeFrameQueue(size_t size) {
+    srcFrameQueue_->resize(size);
+}
+
+void FilterExtension::reset() {
+    srcFrameQueue_->flush();
+    srcFrameQueue_->reset();
+}
+
+void FilterExtension::enable(bool en) {
+    enabled_ = en;
+}
+
+bool FilterExtension::isEnabled() const {
+    return enabled_;
+}
+
+OBFilterConfigValueType parseFilterConfigValueType(const std::string &typeStr) {
+    if(typeStr == "integer" || typeStr == "int" || typeStr == "uint8_t" || typeStr == "uint16_t" || typeStr == "uint32_t" || typeStr == "uint64_t"
+       || typeStr == "size_t" || typeStr == "int8_t" || typeStr == "int16_t" || typeStr == "int32_t" || typeStr == "int64_t" || typeStr == "enum") {
+        return OB_FILTER_CONFIG_VALUE_TYPE_INT;
+    }
+    else if(typeStr == "float" || typeStr == "double") {
+        return OB_FILTER_CONFIG_VALUE_TYPE_FLOAT;
+    }
+    else if(typeStr == "bool" || typeStr == "boolean") {
+        return OB_FILTER_CONFIG_VALUE_TYPE_BOOLEAN;
+    }
+    else {
+        LOG_WARN("Invalid filter config type: {}", typeStr);
+        return OB_FILTER_CONFIG_VALUE_TYPE_INVALID;
+    }
+}
+
+double parseFilterConfigValue(const std::string &valueStr, OBFilterConfigValueType valueType) {
+    if(valueType == OB_FILTER_CONFIG_VALUE_TYPE_INT) {
+        int value;
+        if(!utils::string::cvt2Int(valueStr, value)) {
+            LOG_WARN("Invalid filter config value for int type: {}", valueStr);
+            return 0.0;
+        }
+        return static_cast<double>(value);
+    }
+    else if(valueType == OB_FILTER_CONFIG_VALUE_TYPE_FLOAT) {
+        double value;
+        if(!utils::string::cvt2Double(valueStr, value)) {
+            LOG_WARN("Invalid filter config value for float type: {}", valueStr);
+        }
+        return value;
+    }
+    else if(valueType == OB_FILTER_CONFIG_VALUE_TYPE_BOOLEAN) {
+        bool value;
+        if(!utils::string::cvt2Boolean(valueStr, value)) {
+            LOG_WARN("Invalid filter config value for bool type: {}", valueStr);
+            return 0.0;
+        }
+        return value ? 1.0 : 0.0;
+    }
+
+    LOG_WARN("Invalid filter config value type: {}", valueType);
+    return 0.0;
+}
+
+const std::vector<OBFilterConfigSchemaItem> &FilterExtension::getConfigSchemaVec() {
+    if(!configSchemaVec_.empty()) {
+        return configSchemaVec_;
+    }
+
+    // csv format: name，type， min，max，step，default，description
+    auto              schemaCSV = getConfigSchema();
+    std::stringstream ss(schemaCSV);
+    std::string       itemStr;
+    while(std::getline(ss, itemStr)) {
+        std::vector<std::string> strVec = utils::string::split(itemStr, ",");
+        for(auto &str: strVec) {
+            str = utils::string::clearHeadAndTailSpace(str);
+        }
+        configSchemaStrSplittedVec_.emplace_back(strVec);
+    }
+    for(auto &strVec: configSchemaStrSplittedVec_) {
+        if(strVec.size() < 6) {
+            LOG_WARN("Filter {}: invalid config schema item: {}", name_, itemStr);
+            continue;
+        }
+        OBFilterConfigSchemaItem item;
+        item.name = strVec[0].c_str();
+        item.type = parseFilterConfigValueType(strVec[1]);
+        item.min  = parseFilterConfigValue(strVec[2], item.type);
+        item.max  = parseFilterConfigValue(strVec[3], item.type);
+        item.step = parseFilterConfigValue(strVec[4], item.type);
+        item.def  = parseFilterConfigValue(strVec[5], item.type);
+        if(strVec.size() > 6) {
+            item.desc = strVec[6].c_str();
+        }
+        configSchemaVec_.push_back(item);
+    }
+
+    return configSchemaVec_;
+}
+
+void FilterExtension::setConfigValue(const std::string &configName, double value) {
+    auto schemaVec = getConfigSchemaVec();
+    if(schemaVec.empty()) {
+        throw invalid_value_exception(utils::string::to_string() << "Filter@" << name_ << ": config schema is empty, doesn't have any config value");
+    }
+
+    if(configMap_.empty()) {
+        for(auto &item: schemaVec) {
+            configMap_[item.name] = item.def;
+        }
+    }
+
+    auto it =
+        std::find_if(configSchemaVec_.begin(), configSchemaVec_.end(), [&configName](const OBFilterConfigSchemaItem &item) { return item.name == configName; });
+    if(it == configSchemaVec_.end()) {
+        throw invalid_value_exception(utils::string::to_string() << "Filter@" << name_ << ": config item " << configName << " doesn't exist");
+    }
+    if(value < it->min || value > it->max) {
+        throw invalid_value_exception(utils::string::to_string() << "Filter@" << name_ << ": config item " << configName << " value " << value
+                                                                 << " out of range [" << it->min << ", " << it->max << "]");
+    }
+
+    std::unique_lock<std::mutex> lock(configMutex_);
+    if(configMap_[configName] != value) {
+        configChanged_         = true;
+        configMap_[configName] = value;  // store the value in the map, will be applied in the next process() call
+        LOG_DEBUG("Filter {}: config item {} value set to {}", name_, configName, value);
+    }
+}
+
+void FilterExtension::setConfigValueSync(const std::string &name, double value) {
+    setConfigValue(name, value);
+    checkAndUpdateConfig();
+}
+
+double FilterExtension::getConfigValue(const std::string &configName) {
+    auto schemaVec = getConfigSchemaVec();
+    if(schemaVec.empty()) {
+        throw invalid_value_exception(utils::string::to_string() << "Filter@" << name_ << ": config schema is empty, doesn't have any config value");
+    }
+
+    if(configMap_.empty()) {
+        for(auto &item: schemaVec) {
+            configMap_[item.name] = item.def;
+        }
+    }
+
+    auto it = configMap_.find(configName);
+    if(it == configMap_.end()) {
+        throw invalid_value_exception(utils::string::to_string() << "Filter@" << name_ << ": config item " << configName << " doesn't exist");
+    }
+    return it->second;
+}
+
+OBFilterConfigSchemaItem FilterExtension::getConfigSchemaItem(const std::string &name) {
+    auto                     schemaVec  = getConfigSchemaVec();
+    OBFilterConfigSchemaItem resultItem = {};
+    if(schemaVec.empty()) {
+        return resultItem;
+    }
+
+    for(auto item: schemaVec) {
+        if(item.name == name) {
+            resultItem = item;
+        }
+    }
+
+    return resultItem;
+}
+
+std::string filterConfigValueToString(double value, OBFilterConfigValueType valueType) {
+    if(valueType == OB_FILTER_CONFIG_VALUE_TYPE_INT) {
+        return std::to_string(static_cast<int>(value));
+    }
+    else if(valueType == OB_FILTER_CONFIG_VALUE_TYPE_FLOAT) {
+        // double to string with precision as large as possible
+        std::stringstream ss;
+        ss.precision(std::numeric_limits<double>::max_digits10);
+        ss << value;
+        return ss.str();
+    }
+    else if(valueType == OB_FILTER_CONFIG_VALUE_TYPE_BOOLEAN) {
+        return value ? "1" : "0";
+    }
+    LOG_WARN("Invalid filter config value type: {}", valueType);
+    return "";
+}
+
+void FilterExtension::checkAndUpdateConfig() {
+    if(configChanged_) {
+        std::unique_lock<std::mutex> lock(configMutex_);
+
+        std::vector<std::string> configVec;
+        for(auto &item: configSchemaVec_) {
+            auto it = configMap_.find(item.name);
+            if(it == configMap_.end()) {
+                throw invalid_value_exception(utils::string::to_string() << "Filter@" << name_ << ": config item " << item.name << " doesn't exist");
+            }
+            auto valueStr = filterConfigValueToString(it->second, item.type);
+            configVec.push_back(valueStr);
+        }
+        updateConfig(configVec);
+
+        configChanged_ = false;
+    }
+}
+
+void FilterExtension::updateConfigCache(std::vector<std::string> &params) {
+    auto schemaVec = getConfigSchemaVec();
+    if(schemaVec.empty()) {
+        throw invalid_value_exception(utils::string::to_string() << "Filter@" << name_ << ": config schema is empty, doesn't have any config value");
+    }
+
+    if(schemaVec.size() == params.size()) {
+        for(size_t i = 0; i < schemaVec.size(); i++) {
+            auto name        = schemaVec[i].name;
+            auto type        = schemaVec[i].type;
+            auto value       = parseFilterConfigValue(params[i], type);
+            configMap_[name] = value;
+        }
+    }
+}
+
+FilterDecorator::FilterDecorator(const std::string &name, std::shared_ptr<IFilterBase> baseFilter) : FilterExtension(name), baseFilter_(baseFilter) {}
+
+FilterDecorator::~FilterDecorator() noexcept {
+    reset();
+    LOG_DEBUG("Filter {} destroyed", getName());
+}
+
+void FilterDecorator::updateConfig(std::vector<std::string> &params) {
+    baseFilter_->updateConfig(params);
+    updateConfigCache(params);
+}
+
+const std::string &FilterDecorator::getConfigSchema() const {
+    return baseFilter_->getConfigSchema();
+}
+
+void FilterDecorator::reset() {
+    FilterExtension::reset();
+    baseFilter_->reset();
+    LOG_DEBUG("Filter@{} have been reset", getName());
+}
+
+std::shared_ptr<Frame> FilterDecorator::process(std::shared_ptr<const Frame> frame) {
+    if(!frame) {
+        LOG_WARN("Filter {}: empty frame received, return nullptr", getName());
+        return nullptr;
+    }
+
+    checkAndUpdateConfig();
+
+    std::unique_lock<std::mutex> lock(processMutex_);
+    return baseFilter_->process(frame);
+}
+
+std::shared_ptr<IFilterBase> FilterDecorator::getBaseFilter() const {
+    return baseFilter_;
+}
+
+}  // namespace libobsensor
diff --git a/src/filter/FilterDecorator.hpp b/src/filter/FilterDecorator.hpp
new file mode 100644
index 00000000..0ecab82d
--- /dev/null
+++ b/src/filter/FilterDecorator.hpp
@@ -0,0 +1,76 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include "IFilter.hpp"
+#include "frame/FrameQueue.hpp"
+#include "stream/StreamProfile.hpp"
+#include <atomic>
+#include <memory>
+#include <mutex>
+#include <thread>
+#include <vector>
+#include <map>
+
+namespace libobsensor {
+
+class FilterExtension : public IFilter {
+public:
+    FilterExtension(const std::string &name);
+    virtual ~FilterExtension() noexcept;
+
+    const std::string &getName() const override;
+
+    void enable(bool en) override;
+    bool isEnabled() const override;
+    void reset() override;
+
+    const std::vector<OBFilterConfigSchemaItem> &getConfigSchemaVec() override;
+    void                                         setConfigValue(const std::string &name, double value) override;
+    void                                         setConfigValueSync(const std::string &name, double value) override;
+    double                                       getConfigValue(const std::string &name) override;
+    OBFilterConfigSchemaItem                     getConfigSchemaItem(const std::string &name) override;
+
+    // Asynchronous, output result to callback function
+    void         pushFrame(std::shared_ptr<const Frame> frame) override;
+    void         setCallback(FilterCallback cb) override;
+    virtual void resizeFrameQueue(size_t size) override;
+
+protected:
+    void updateConfigCache(std::vector<std::string> &params);
+    void checkAndUpdateConfig();
+
+private:
+    const std::string name_;
+    std::atomic<bool> enabled_;
+
+    std::mutex     callbackMutex_;
+    FilterCallback callback_;
+
+    std::shared_ptr<FrameQueue<const Frame>> srcFrameQueue_;
+
+    std::mutex                            configMutex_;
+    std::atomic<bool>                     configChanged_;
+    std::map<std::string, double>         configMap_;
+    std::vector<OBFilterConfigSchemaItem> configSchemaVec_;
+    std::vector<std::vector<std::string>> configSchemaStrSplittedVec_;
+};
+
+class FilterDecorator : public FilterExtension {
+public:
+    FilterDecorator(const std::string &name, std::shared_ptr<IFilterBase> baseFilter);
+    virtual ~FilterDecorator() noexcept;
+
+    virtual void                   reset() override;
+    virtual void                   updateConfig(std::vector<std::string> &params) override;
+    virtual const std::string     &getConfigSchema() const override;
+    virtual std::shared_ptr<Frame> process(std::shared_ptr<const Frame> frame) override;
+
+    std::shared_ptr<IFilterBase> getBaseFilter() const;
+
+private:
+    std::mutex                   processMutex_;
+    std::shared_ptr<IFilterBase> baseFilter_;
+};
+
+}  // namespace libobsensor
diff --git a/src/filter/FilterFactory.cpp b/src/filter/FilterFactory.cpp
new file mode 100644
index 00000000..11a7b62e
--- /dev/null
+++ b/src/filter/FilterFactory.cpp
@@ -0,0 +1,73 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "FilterFactory.hpp"
+#include "publicfilters/publicFilterLoader.hpp"
+#include "privatefilters/PrivFilterLoader.hpp"
+#include "utils/PublicTypeHelper.hpp"
+#include "exception/ObException.hpp"
+
+#include <mutex>
+
+namespace libobsensor {
+
+std::mutex                     FilterFactory::instanceMutex_;
+std::weak_ptr<FilterFactory>   FilterFactory::instanceWeakPtr_;
+std::shared_ptr<FilterFactory> FilterFactory::getInstance() {
+    std::unique_lock<std::mutex> lk(instanceMutex_);
+    auto                         instance = instanceWeakPtr_.lock();
+    if(!instance) {
+        instance         = std::shared_ptr<FilterFactory>(new FilterFactory());
+        instanceWeakPtr_ = instance;
+    }
+    return instance;
+}
+
+FilterFactory::FilterFactory() : logger_(Logger::getInstance()) {
+    auto publicFilterCreators  = PublicFilterCreatorLoader::getCreators();
+    auto privateFilterCreators = PrivFilterCreatorLoader::getCreators();
+    filterCreators_.insert(publicFilterCreators.begin(), publicFilterCreators.end());
+    filterCreators_.insert(privateFilterCreators.begin(), privateFilterCreators.end());
+
+    LOG_INFO("Registered {} filter creators", filterCreators_.size());
+    for(auto &creator : filterCreators_) {
+        LOG_INFO(" - {}", creator.first);
+    }
+}
+
+FilterFactory::~FilterFactory() noexcept {}
+
+std::shared_ptr<IFilter> FilterFactory::createFilter(const std::string &filterName) {
+    auto iter = filterCreators_.find(filterName);
+    if(iter == filterCreators_.end()) {
+        throw invalid_value_exception("Invalid filter name, cannot find filter creator for filter name: " + filterName);
+    }
+    return iter->second->create();
+}
+
+std::shared_ptr<IFilter> FilterFactory::createPrivateFilter(const std::string &filterName, const std::string &activationKey) {
+    auto iter = filterCreators_.find(filterName);
+    if(iter == filterCreators_.end()) {
+        throw invalid_value_exception("Invalid filter name, cannot find filter creator for filter name: " + filterName);
+    }
+    auto privFilterCreator = std::dynamic_pointer_cast<IPrivFilterCreator>(iter->second);
+    if(!privFilterCreator) {
+        LOG_WARN("Filter name {} is not a private filter, dose not need activation key to create filter", filterName);
+        return iter->second->create();
+    }
+    return privFilterCreator->create(activationKey);
+}
+
+bool FilterFactory::isFilterCreatorExists(const std::string &filterName) {
+    return filterCreators_.find(filterName) != filterCreators_.end();
+}
+
+std::shared_ptr<IFilterCreator> FilterFactory::getFilterCreator(const std::string &filterName) {
+    auto iter = filterCreators_.find(filterName);
+    if(iter == filterCreators_.end()) {
+        throw invalid_value_exception("Invalid filter name, cannot find filter creator for filter name: " + filterName);
+    }
+    return iter->second;
+}
+
+}  // namespace libobsensor
diff --git a/src/filter/FilterFactory.hpp b/src/filter/FilterFactory.hpp
new file mode 100644
index 00000000..e603d165
--- /dev/null
+++ b/src/filter/FilterFactory.hpp
@@ -0,0 +1,36 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include "IFilter.hpp"
+#include "logger/Logger.hpp"
+#include "privatefilters/PrivFilterLoader.hpp"
+#include <memory>
+#include <mutex>
+
+namespace libobsensor {
+
+class FilterFactory {
+private:
+    FilterFactory();
+
+    static std::mutex                   instanceMutex_;
+    static std::weak_ptr<FilterFactory> instanceWeakPtr_;
+
+public:
+    static std::shared_ptr<FilterFactory> getInstance();
+
+    ~FilterFactory() noexcept;
+
+    std::shared_ptr<IFilter>        createFilter(const std::string &filterName);
+    std::shared_ptr<IFilter>        createPrivateFilter(const std::string &filterName, const std::string &activationKey);
+    std::shared_ptr<IFilterCreator> getFilterCreator(const std::string &filterName);
+    bool                            isFilterCreatorExists(const std::string &filterName);
+
+private:
+    std::map<std::string, std::shared_ptr<IFilterCreator>> filterCreators_;
+
+    std::shared_ptr<Logger> logger_;  // Manages the lifecycle of the logger object.
+};
+
+}  // namespace libobsensor
diff --git a/src/filter/IFilter.hpp b/src/filter/IFilter.hpp
new file mode 100644
index 00000000..b48b8d82
--- /dev/null
+++ b/src/filter/IFilter.hpp
@@ -0,0 +1,91 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include <functional>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "IFrame.hpp"
+#include "IStreamProfile.hpp"
+#include "libobsensor/h/ObTypes.h"
+
+namespace libobsensor {
+
+typedef std::function<void(std::shared_ptr<Frame>)> FilterCallback;
+
+class IFilterBase {
+public:
+    virtual ~IFilterBase() noexcept = default;
+
+    // Config
+    virtual void               updateConfig(std::vector<std::string> &params) = 0;
+    virtual const std::string &getConfigSchema() const                        = 0;
+
+    virtual void reset() = 0;  // Stop thread, clean memory, reset status
+
+    // Synchronize
+    virtual std::shared_ptr<Frame> process(std::shared_ptr<const Frame> frame) = 0;
+};
+
+class IFilterExtension {
+public:
+    virtual const std::string &getName() const = 0;
+
+    virtual void enable(bool en)   = 0;
+    virtual bool isEnabled() const = 0;
+
+    virtual const std::vector<OBFilterConfigSchemaItem> &getConfigSchemaVec()                                      = 0;
+    virtual void                                         setConfigValue(const std::string &name, double value)     = 0;
+    virtual void                                         setConfigValueSync(const std::string &name, double value) = 0;
+    virtual double                                       getConfigValue(const std::string &name)                   = 0;
+    virtual OBFilterConfigSchemaItem                     getConfigSchemaItem(const std::string &name)              = 0;
+
+    // Asynchronous
+    virtual void pushFrame(std::shared_ptr<const Frame> frame) = 0;
+    virtual void setCallback(FilterCallback cb)                = 0;
+
+    virtual void resizeFrameQueue(size_t size) = 0;
+};
+
+class IFilter : public IFilterBase, public IFilterExtension {
+public:
+    virtual ~IFilter() noexcept = default;
+};
+
+class IFilterCreator {
+public:
+    virtual ~IFilterCreator() noexcept = default;
+
+    virtual std::shared_ptr<IFilter> create() = 0;
+};
+
+class IPrivFilterCreator : public IFilterCreator {
+public:
+    ~IPrivFilterCreator() noexcept override                                   = default;
+    std::shared_ptr<IFilter>         create() override                        = 0;
+    virtual std::shared_ptr<IFilter> create(const std::string &activationKey) = 0;
+    virtual const std::string       &getVendorSpecificCode() const            = 0;
+};
+
+}  // namespace libobsensor
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+struct ob_filter_t {
+    std::shared_ptr<libobsensor::IFilter> filter;
+};
+
+struct ob_filter_list_t {
+    std::vector<std::shared_ptr<libobsensor::IFilter>> filterList;
+};
+
+struct ob_filter_config_schema_list_t {
+    std::vector<OBFilterConfigSchemaItem> configSchemaList;
+};
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/src/filter/privatefilters/PrivFilterCppWrapper.cpp b/src/filter/privatefilters/PrivFilterCppWrapper.cpp
new file mode 100644
index 00000000..acec6df4
--- /dev/null
+++ b/src/filter/privatefilters/PrivFilterCppWrapper.cpp
@@ -0,0 +1,75 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "PrivFilterCppWrapper.hpp"
+#include "logger/Logger.hpp"
+#include "exception/ObException.hpp"
+
+namespace libobsensor {
+PrivFilterCppWrapper::PrivFilterCppWrapper(const std::string &filterName, std::shared_ptr<ob_priv_filter_context> filterCtx)
+    : name_(filterName), privFilterCtx_(filterCtx) {
+    ob_error   *error = nullptr;
+    const char *desc  = privFilterCtx_->get_config_schema(privFilterCtx_->filter, &error);
+    if(error) {
+        LOG_WARN("Private filter {} get config schema failed: {}", name_, error->message);
+        delete error;
+        return;
+    }
+    if(desc) {
+        configSchema_ = desc;
+    }
+}
+
+PrivFilterCppWrapper::~PrivFilterCppWrapper() noexcept {
+    reset();
+    LOG_DEBUG("Private filter {} destroyed", name_);
+}
+
+void PrivFilterCppWrapper::updateConfig(std::vector<std::string> &params) {
+    ob_error                 *error = nullptr;
+    std::vector<const char *> c_params;
+    for(auto &p: params) {
+        c_params.push_back(p.c_str());
+    }
+
+    privFilterCtx_->update_config(privFilterCtx_->filter, params.size(), c_params.data(), &error);
+    if(error) {
+        LOG_WARN("Private filter {} update config failed: {}", name_, error->message);
+        delete error;
+    }
+}
+
+const std::string &PrivFilterCppWrapper::getConfigSchema() const {
+    return configSchema_;
+}
+
+void PrivFilterCppWrapper::reset() {
+    ob_error *error = nullptr;
+    privFilterCtx_->reset(privFilterCtx_->filter, &error);
+    if(error) {
+        LOG_WARN("Private filter {} reset failed: {}", name_, error->message);
+        delete error;
+    }
+}
+
+std::shared_ptr<Frame> PrivFilterCppWrapper::process(std::shared_ptr<const Frame> frame) {
+    ob_error              *error   = nullptr;
+    ob_frame              *c_frame = new ob_frame();
+    std::shared_ptr<Frame> resultFrame;
+    c_frame->frame = std::const_pointer_cast<Frame>(frame);
+
+    auto rst_frame = privFilterCtx_->process(privFilterCtx_->filter, c_frame, &error);
+    if(rst_frame) {
+        resultFrame = rst_frame->frame;
+        delete rst_frame;
+    }
+    delete c_frame;
+
+    if(error) {
+        // LOG_WARN("Private filter {} process failed: {}", name_, error->message);
+        throw unrecoverable_exception(std::string(error->message), error->exception_type);
+    }
+    return resultFrame;
+}
+
+}  // namespace libobsensor
diff --git a/src/filter/privatefilters/PrivFilterCppWrapper.hpp b/src/filter/privatefilters/PrivFilterCppWrapper.hpp
new file mode 100644
index 00000000..73ea872d
--- /dev/null
+++ b/src/filter/privatefilters/PrivFilterCppWrapper.hpp
@@ -0,0 +1,32 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "IFilter.hpp"
+#include "frame/FrameQueue.hpp"
+#include <mutex>
+
+extern "C" {
+#include "PrivFilterTypes.h"
+}
+
+namespace libobsensor {
+class PrivFilterCppWrapper : public IFilterBase {
+public:
+    PrivFilterCppWrapper(const std::string &filterName, std::shared_ptr<ob_priv_filter_context> filterCtx);
+    virtual ~PrivFilterCppWrapper() noexcept;
+
+    // Config
+    void               updateConfig(std::vector<std::string> &params) override;
+    const std::string &getConfigSchema() const override;
+
+    void reset() override;  // Stop thread, clean memory, reset status
+
+private:
+    std::shared_ptr<Frame> process(std::shared_ptr<const Frame> frame) override;  // Filter function function, implemented on child class
+
+private:
+    std::string                               name_;
+    std::shared_ptr<ob_priv_filter_context_t> privFilterCtx_;
+    std::string                               configSchema_;
+};
+}  // namespace libobsensor
diff --git a/src/filter/privatefilters/PrivFilterLoader.cpp b/src/filter/privatefilters/PrivFilterLoader.cpp
new file mode 100644
index 00000000..d0817a68
--- /dev/null
+++ b/src/filter/privatefilters/PrivFilterLoader.cpp
@@ -0,0 +1,187 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "PrivFilterLoader.hpp"
+#include "PrivFilterCppWrapper.hpp"
+#include "FilterDecorator.hpp"
+#include "exception/ObException.hpp"
+#include "logger/Logger.hpp"
+#include "utils/Utils.hpp"
+#include "environment/EnvConfig.hpp"
+
+namespace libobsensor {
+
+PrivFilterCreator::PrivFilterCreator(std::shared_ptr<PrivFilterPackageContext> pkgCtx, size_t index) : pkgCtx_(pkgCtx), index_(index) {
+    ob_error *error = nullptr;
+    code_           = pkgCtx_->get_vendor_specific_code(&error);
+    if(error) {
+        std::string errorMsg = "Failed to get filter vendor specific code: " + std::string(error->message);
+        delete error;
+        throw unsupported_operation_exception(errorMsg);
+    }
+}
+
+std::shared_ptr<IFilter> PrivFilterCreator::create() {
+    ob_error *error = nullptr;
+
+    bool activated = pkgCtx_->is_activated(&error);
+    if(error) {
+        std::string errorMsg = "Check if private filter library is activated: " + std::string(error->message);
+        delete error;
+        throw unsupported_operation_exception(errorMsg);
+    }
+
+    if(!activated) {
+        throw unsupported_operation_exception("Private filter library not activated");
+    }
+
+    auto privFilterCtx = pkgCtx_->create_filter(index_, &error);
+
+    if(error) {
+        std::string errorMsg = "Failed to create private filter: " + std::string(error->message);
+        delete error;
+        throw unsupported_operation_exception(errorMsg);
+    }
+
+    auto filterName = pkgCtx_->get_filter_name(index_, &error);
+    if(error) {
+        std::string errorMsg = "Failed to get filter name: " + std::string(error->message);
+        delete error;
+        throw unsupported_operation_exception(errorMsg);
+    }
+
+    auto pkgCtx              = pkgCtx_;  // Pass the pkgCtx to the deleter of shared_ptr to control the lifetime
+    auto privFilterCtxShared = std::shared_ptr<ob_priv_filter_context>(privFilterCtx, [filterName, pkgCtx](ob_priv_filter_context *ctx) {
+        if(ctx) {
+            ob_error *error = nullptr;
+            ctx->destroy(ctx, &error);
+            if(error) {
+                LOG_WARN("Private filter {} destroyed failed: {}", filterName, error->message);
+                delete error;
+            }
+            ctx = nullptr;
+        }
+    });
+
+    auto baseFilter = std::make_shared<PrivFilterCppWrapper>(filterName, privFilterCtxShared);
+    return std::make_shared<FilterDecorator>(filterName, baseFilter);
+}
+
+std::shared_ptr<IFilter> PrivFilterCreator::create(const std::string &activationKey) {
+    ob_error *error = nullptr;
+
+    bool activated = pkgCtx_->is_activated(&error);
+    if(error) {
+        std::string errorMsg = "Check if private filter library is activated: " + std::string(error->message);
+        delete error;
+        throw unsupported_operation_exception(errorMsg);
+    }
+
+    if(!activated) {
+        pkgCtx_->activate(activationKey.c_str(), &error);
+        if(error) {
+            std::string errorMsg = "Failed to activate private filter library: " + std::string(error->message);
+            delete error;
+            throw unsupported_operation_exception(errorMsg);
+        }
+    }
+
+    auto filterName = pkgCtx_->get_filter_name(index_, &error);
+    if(error) {
+        std::string errorMsg = "Failed to get filter name: " + std::string(error->message);
+        delete error;
+        throw unsupported_operation_exception(errorMsg);
+    }
+
+    auto privFilterCtx = pkgCtx_->create_filter(index_, &error);
+    if(error) {
+        std::string errorMsg = "Failed to create private filter: " + std::string(error->message);
+        delete error;
+        throw unsupported_operation_exception(errorMsg);
+    }
+
+    auto pkgCtx              = pkgCtx_;  // Pass the pkgCtx to the deleter of shared_ptr to control the lifetime
+    auto privFilterCtxShared = std::shared_ptr<ob_priv_filter_context>(privFilterCtx, [filterName, pkgCtx](ob_priv_filter_context *ctx) {
+        if(ctx) {
+            ob_error *error = nullptr;
+            ctx->destroy(ctx, &error);
+            if(error) {
+                LOG_WARN("Private filter {} destroyed failed: {}", filterName, error->message);
+                delete error;
+            }
+            ctx = nullptr;
+        }
+    });
+    auto baseFilter          = std::make_shared<PrivFilterCppWrapper>(filterName, privFilterCtxShared);
+    return std::make_shared<FilterDecorator>(filterName, baseFilter);
+}
+
+const std::string &PrivFilterCreator::getVendorSpecificCode() const {
+    return code_;
+}
+
+namespace PrivFilterCreatorLoader {
+
+std::map<std::string, std::shared_ptr<IFilterCreator>> getCreators() {
+    // todo: get filters root dir from config file
+    std::string filtersRootDir = EnvConfig::getExtensionsDirectory() + "/filters/";
+
+    std::map<std::string, std::shared_ptr<IFilterCreator>> filterCreators;
+
+    auto load = [&filterCreators](const std::string &dir, const std::string &packageName) {
+        auto pkgCtx_          = std::make_shared<PrivFilterPackageContext>();
+        pkgCtx_->dir          = dir;
+        pkgCtx_->package_name = packageName;
+        auto fileName         = utils::removeExtensionOfFileName(packageName);
+        fileName              = utils::string::replaceFirst(fileName, "lib", "");
+        try {
+            pkgCtx_->dynamic_library          = std::make_shared<dylib>(dir, fileName);
+            pkgCtx_->get_filter_count         = pkgCtx_->dynamic_library->get_function<size_t(ob_error **)>("ob_get_filter_count");
+            pkgCtx_->get_filter_name          = pkgCtx_->dynamic_library->get_function<const char *(size_t, ob_error **)>("ob_get_filter_name");
+            pkgCtx_->create_filter            = pkgCtx_->dynamic_library->get_function<ob_priv_filter_context *(size_t, ob_error **)>("ob_create_filter");
+            pkgCtx_->get_vendor_specific_code = pkgCtx_->dynamic_library->get_function<const char *(ob_error **)>("ob_priv_filter_get_vendor_specific_code");
+            pkgCtx_->is_activated             = pkgCtx_->dynamic_library->get_function<bool(ob_error **)>("ob_priv_filter_is_activated");
+            pkgCtx_->activate                 = pkgCtx_->dynamic_library->get_function<bool(const char *, ob_error **)>("ob_priv_filter_activate");
+        }
+        catch(const std::exception &e) {
+            LOG_DEBUG("Failed to load private filter library {}: {}", dir + packageName, e.what());
+            return;
+        }
+        ob_error *error       = nullptr;
+        auto      filterCount = pkgCtx_->get_filter_count(&error);
+        if(error) {
+            std::string errorMsg = "Failed to get filter count: " + std::string(error->message);
+            delete error;
+            throw unsupported_operation_exception(errorMsg);
+        }
+
+        for(size_t i = 0; i < filterCount; i++) {
+            auto filterName = pkgCtx_->get_filter_name(i, &error);
+            if(error) {
+                std::string errorMsg = "Failed to get filter name: " + std::string(error->message);
+                delete error;
+                throw unsupported_operation_exception(errorMsg);
+            }
+
+            auto creator               = std::make_shared<PrivFilterCreator>(pkgCtx_, i);
+            filterCreators[filterName] = creator;
+            LOG_DEBUG("Private filter creator created: {}", filterName);
+        }
+    };
+
+    // filter library without dependencies files (single file), can be placed in the root directory
+    utils::forEachFileInDirectory(filtersRootDir, [&](const std::string &fileName) { TRY_EXECUTE({ load(filtersRootDir, fileName); }); });
+
+    // filter library with dependencies files (multiple files), should be placed in a sub directory
+    utils::forEachSubDirInDirectory(filtersRootDir, [&](const std::string &folderName) {
+        auto dir         = filtersRootDir + folderName + "/";
+        auto packageName = folderName;  // the filter lib file name should be the same as the folder name
+        TRY_EXECUTE({ load(dir, packageName); });
+    });
+
+    return filterCreators;
+}
+
+}  // namespace PrivFilterCreatorLoader
+}  // namespace libobsensor
+
diff --git a/src/filter/privatefilters/PrivFilterLoader.hpp b/src/filter/privatefilters/PrivFilterLoader.hpp
new file mode 100644
index 00000000..4f503a74
--- /dev/null
+++ b/src/filter/privatefilters/PrivFilterLoader.hpp
@@ -0,0 +1,52 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include <string>
+#include <memory>
+#include <map>
+#include <dylib.hpp>
+#include "IFilter.hpp"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+#include "PrivFilterTypes.h"
+#ifdef __cplusplus
+}
+#endif
+
+namespace libobsensor {
+
+struct PrivFilterPackageContext {
+    std::string                                   dir;
+    std::string                                   package_name;
+    std::shared_ptr<dylib>                        dynamic_library;
+    pfunc_ob_get_filter_count                     get_filter_count;
+    pfunc_ob_get_filter_name                      get_filter_name;
+    pfunc_ob_create_filter                        create_filter;
+    pfunc_ob_priv_filter_get_vendor_specific_code get_vendor_specific_code;
+    pfunc_ob_priv_filter_is_activated             is_activated;
+    pfunc_ob_priv_filter_activate                 activate;
+};
+
+class PrivFilterCreator : public IPrivFilterCreator {
+public:
+    PrivFilterCreator(std::shared_ptr<PrivFilterPackageContext> pkgCtx, size_t index);
+    ~PrivFilterCreator() override = default;
+
+    std::shared_ptr<IFilter> create() override;
+    std::shared_ptr<IFilter> create(const std::string &activationKey) override;
+    const std::string       &getVendorSpecificCode() const override;
+
+private:
+    std::shared_ptr<PrivFilterPackageContext> pkgCtx_;
+    size_t                                    index_;
+    std::string                               code_;
+};
+
+namespace PrivFilterCreatorLoader {
+std::map<std::string, std::shared_ptr<IFilterCreator>> getCreators();
+}
+
+}  // namespace libobsensor
diff --git a/src/filter/privatefilters/PrivFilterTypes.h b/src/filter/privatefilters/PrivFilterTypes.h
new file mode 100644
index 00000000..5ddb9698
--- /dev/null
+++ b/src/filter/privatefilters/PrivFilterTypes.h
@@ -0,0 +1,154 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include "libobsensor/h/Frame.h"
+
+#include <cstddef>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct ob_priv_filter_t ob_priv_filter;
+typedef struct ob_priv_filter_context_t ob_priv_filter_context;
+
+/**
+ * @brief Function pointer type for the get config schema function of the filter
+ *
+ * @brief The returned string must be a csv format string representing the configuration schema of the filter. The format of the string is:
+ *  <parameter_name>, <parameter_type: int, float, bool>, <minimum_value>, <maximum_value>, <value_step>, <default_value>, <parameter_description>
+ *
+ * @param[in] filter The filter object to get the configuration schema for
+ * @param[out] error Pointer to an error object that will be set if an error occurs
+ *
+ * @return A csv format string representing the configuration schema of the filter
+ */
+typedef const char *(*pfunc_ob_priv_filter_get_config_schema)(const ob_priv_filter *filter, ob_error **error);
+
+/**
+ * @brief Function pointer type for the update config function of the filter
+ *
+ * @attention For users, the passed in argc and argv must match the configuration schema returned by the @ref pfunc_ob_priv_filter_get_config_schema function.
+ *
+ * @param[in] filter The filter object to update the configuration for
+ * @param[in] argc The number of arguments in the argv array
+ * @param[in] argv An array of strings representing the configuration values
+ * @param[out] error Pointer to an error object that will be set if an error occurs
+ */
+typedef void (*pfunc_ob_priv_filter_update_config)(ob_priv_filter *filter, size_t argc, const char **argv, ob_error **error);
+
+/**
+ * @brief Function pointer type for the reset function of the filter
+ * @brief Reset the filter to its initial state (stop threads, clear buffers, etc.)
+ *
+ * @param[in] filter The filter object to reset
+ * @param[out] error Pointer to an error object that will be set if an error occurs
+ */
+typedef void (*pfunc_ob_priv_filter_reset)(ob_priv_filter *filter, ob_error **error);
+
+/**
+ * @brief Function pointer type for the process function of the filter
+ *
+ * @attention Do not modify the frame object passed to the filter process function, the result of the filter process function should be returned as a new frame
+ * object.
+ *
+ * @param[in] filter The filter object to process the frame with
+ * @param[in]  frame The frame to process
+ * @param[out] error Pointer to an error object that will be set if an error occurs
+ *
+ * @return The processed frame
+ */
+typedef ob_frame *(*pfunc_ob_priv_filter_process)(ob_priv_filter *filter, const ob_frame *frame, ob_error **error);
+
+/**
+ * @brief Function pointer type for the destroy function of the filter context object
+ *
+ * @attention The filter developer must ensure that the filter object in the filter context object is destroyed before the filter context object is destroyed.
+ *
+ * @param filter_context[in] The filter context object to destroy
+ * @param error[out] Pointer to an error object that will be set if an error occurs
+ */
+typedef void (*pfunc_ob_priv_filter_context_destroy)(ob_priv_filter_context *filter_context, ob_error **error);
+
+/**
+ * @brief The filter context object is used to store the filter object and the function pointers to the filter functions.
+ *
+ */
+struct ob_priv_filter_context_t {
+    pfunc_ob_priv_filter_context_destroy destroy;  //< Destroy the filter context object
+
+    ob_priv_filter *filter;  //< Pointer to the filter object
+
+    pfunc_ob_priv_filter_reset             reset;              //< Reset the filter to its initial state (stop threads, clear buffers, etc.)
+    pfunc_ob_priv_filter_get_config_schema get_config_schema;  //< Get the configuration schema of the filter
+    pfunc_ob_priv_filter_update_config     update_config;      //< Update the filter's configuration
+    pfunc_ob_priv_filter_process           process;            //< Process a frame through the filter
+};
+
+/**
+ * @brief Function pointer type for the get filter count function
+ *
+ * @param[out] error Pointer to an error object that will be set if an error occurs
+ *
+ * @return The number of filters available within the package (dynamic library)
+ */
+typedef size_t (*pfunc_ob_get_filter_count)(ob_error **error);
+
+/**
+ * @brief Function pointer type for the get filter name function
+ *
+ * @param[in] index The index of the filter to get the name for
+ * @param[out] error Pointer to an error object that will be set if an error occurs
+ *
+ * @return The name of the filter at the given index
+ */
+typedef const char *(*pfunc_ob_get_filter_name)(size_t index, ob_error **error);
+
+/**
+ * @brief Function pointer type to create a new filter object from the filter at the given index
+ *
+ * @param[in] index The index of the filter to create a new object for
+ * @param[out] error Pointer to an error object that will be set if an error occurs
+ *
+ * @return A new filter context object created that is containing the filter object and the function pointers to the filter functions
+ */
+typedef ob_priv_filter_context *(*pfunc_ob_create_filter)(size_t index, ob_error **error);  // Create a new filter object from the filter at the given index
+
+/**
+ * @brief Function pointer type for the get vendor specific code function
+ * @brief For vendor special purpose, the vendor can provide a code to the user to identify the filter package.
+ *
+ * @param[out] error Pointer to an error object that will be set if an error occurs
+ *
+ * @return The vendor specific code of the filter package.
+ */
+typedef const char *(*pfunc_ob_priv_filter_get_vendor_specific_code)(ob_error **error);
+
+/**
+ * @brief Function pointer type for the get activation status function
+ * @brief The activation status is used to determine if the filter package is activated or not. If is not activated, the filter package may reject to create a
+ * filter object and the process function of filter may not effective. If the filter package dose not require activation, the activation status should always
+ * return true.
+ *
+ * @param[out] error Pointer to an error object that will be set if an error occurs
+ *
+ * @return true if the filter package is activated, false otherwise.
+ */
+typedef bool (*pfunc_ob_priv_filter_is_activated)(ob_error **error);
+
+/**
+ * @brief Function pointer type for the activate function
+ * @brief Activate the filter package. The activation key is used to verify the activation request.
+ * @brief The vendor of the filter package have the right to require an activation key to activate the filter package.
+ *
+ * @param[in] activation_key The activation key to activate the filter package.
+ * @param[out] error Pointer to an error object that will be set if an error occurs.
+ *
+ * return true if the activation is successful, false otherwise.
+ */
+typedef bool (*pfunc_ob_priv_filter_activate)(const char *activation_key, ob_error **error);  // activate the filter package.
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/src/filter/publicfilters/Align.cpp b/src/filter/publicfilters/Align.cpp
new file mode 100644
index 00000000..bf59f140
--- /dev/null
+++ b/src/filter/publicfilters/Align.cpp
@@ -0,0 +1,230 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "Align.hpp"
+#include "exception/ObException.hpp"
+#include "logger/LoggerInterval.hpp"
+#include "frame/FrameFactory.hpp"
+#include "frame/FrameMemoryPool.hpp"
+
+namespace libobsensor {
+
+const std::map<OBStreamType, OBFrameType> streamTypeToFrameType = { { OB_STREAM_COLOR, OB_FRAME_COLOR },
+                                                                    { OB_STREAM_DEPTH, OB_FRAME_DEPTH },
+                                                                    { OB_STREAM_IR, OB_FRAME_IR },
+                                                                    { OB_STREAM_IR_LEFT, OB_FRAME_IR_LEFT },
+                                                                    { OB_STREAM_IR_RIGHT, OB_FRAME_IR_RIGHT } };
+
+Align::Align() : align_to_stream_(OB_STREAM_COLOR) {
+    pImpl = new AlignImpl();
+    memset(&from_intrin_, 0, sizeof(OBCameraIntrinsic));
+    memset(&from_disto_, 0, sizeof(OBCameraDistortion));
+    memset(&to_intrin_, 0, sizeof(OBCameraIntrinsic));
+    memset(&to_disto_, 0, sizeof(OBCameraDistortion));
+    memset(&from_to_extrin_, 0, sizeof(OBTransform));
+    depth_unit_mm_         = 1.f;
+    add_target_distortion_ = true;
+    gap_fill_copy_         = false;
+}
+
+Align::~Align() noexcept {
+    reset();
+    if(pImpl) {
+        delete pImpl;
+        pImpl = nullptr;
+    }
+}
+
+void Align::updateConfig(std::vector<std::string> &params) {
+    // AlignType, TargetDistortion, GapFillCopy
+    std::lock_guard<std::recursive_mutex> lock(alignMutex_);
+    if(params.size() != 3) {
+        throw invalid_value_exception("Align config error: params size not match");
+    }
+    try {
+        int align_to_stream = std::stoi(params[0]);
+        if(align_to_stream >= OB_STREAM_IR && align_to_stream <= OB_STREAM_IR_RIGHT) {
+            align_to_stream_ = (OBStreamType)align_to_stream;
+        }
+        add_target_distortion_ = bool(std::stoi(params[1]));
+        gap_fill_copy_         = bool(std::stoi(params[2]));
+    }
+    catch(const std::exception &e) {
+        throw invalid_value_exception("Align config error: " + std::string(e.what()));
+    }
+}
+
+const std::string &Align::getConfigSchema() const {
+    static const std::string schema = "AlignType, integer, 1, 7, 1, 2, aligned to the type of data stream\n"
+                                      "TargetDistortion, boolean, 0, 1, 1, 1, add distortion of the target stream\n"
+                                      "GapFillCopy, boolean, 0, 1, 1, 0, enable gap fill";
+    return schema;
+}
+
+void Align::reset() {
+    pImpl->reset();
+}
+
+std::shared_ptr<Frame> Align::process(std::shared_ptr<const Frame> frame) {
+    std::lock_guard<std::recursive_mutex> lock(alignMutex_);
+    if(!frame->is<FrameSet>()) {
+        LOG_WARN("Invalid frame!");
+        return FrameFactory::createFrameFromOtherFrame(frame, true);
+    }
+
+    auto newFrame = FrameFactory::createFrameFromOtherFrame(frame);
+    auto frames   = newFrame->as<FrameSet>();
+    // get type of align_to_stream_
+    auto existFrame = frames->getFrame(getAlignFrameType());
+    if(!existFrame) {
+        return frames;
+    }
+
+    auto depth = frames->getFrame(OB_FRAME_DEPTH);
+    if(!depth) {
+        LOG_WARN("Invalid depth frame!");
+        return frames;
+    }
+
+    auto depthFormat = depth->getFormat();
+    if(!(depthFormat == OB_FORMAT_Z16 || depthFormat == OB_FORMAT_Y16)) {
+        LOG_WARN("Invalid depth frame!");
+        return frames;
+    }
+
+    depth_unit_mm_ = depth->as<DepthFrame>()->getValueScale();
+
+    // prepare "other" data buffer to vector of Frame
+    std::vector<std::shared_ptr<const Frame>> other_frames;
+    if(align_to_stream_ == OB_STREAM_DEPTH) {  // other to depth
+        uint32_t frameCount = frames->getCount();
+        for(uint32_t i = 0; i < frameCount; i++) {
+            std::shared_ptr<const Frame> item = frames->getFrame(i);
+            if((item->getType() != OB_FRAME_DEPTH) && item->is<VideoFrame>()) {
+                other_frames.push_back(item);
+            }
+        }
+    }
+    else {
+        uint32_t frameCount = frames->getCount();
+        for(uint32_t i = 0; i < frameCount; i++) {
+            std::shared_ptr<const Frame> item = frames->getFrame(i);
+            if((item->getType() == streamTypeToFrameType.at(align_to_stream_))) {
+                other_frames.push_back(item);
+            }
+        }
+    }
+
+    // create aligned buffer and do alignment
+    std::shared_ptr<Frame> aligned_frame = nullptr;
+    if(align_to_stream_ == OB_STREAM_DEPTH) {  // other to depth
+        for(auto from: other_frames) {
+            if(!from) {
+                LOG_ERROR("from is nullptr!");
+                continue;
+            }
+            auto original_profile = from->getStreamProfile()->as<VideoStreamProfile>();
+            auto to_profile       = depth->getStreamProfile()->as<VideoStreamProfile>();
+            auto alignProfile     = createAlignedProfile(original_profile, to_profile);
+
+            aligned_frame = FrameFactory::createVideoFrame(from->getType(), from->getFormat(), alignProfile->getWidth(), alignProfile->getHeight(), 0);
+            if(aligned_frame) {
+                aligned_frame->copyInfoFromOther(from);
+                aligned_frame->setStreamProfile(alignProfile);
+                alignFrames(aligned_frame, from, depth);
+                frames->pushFrame(std::move(aligned_frame));
+            }
+        }
+    }
+    else {
+        auto to = other_frames.front();  // depth to other
+
+        auto original_profile  = depth->getStreamProfile()->as<VideoStreamProfile>();
+        auto to_profile        = to->getStreamProfile()->as<VideoStreamProfile>();
+        auto alignProfile      = createAlignedProfile(original_profile, to_profile);
+
+        aligned_frame = FrameFactory::createVideoFrame(depth->getType(), depth->getFormat(), alignProfile->getWidth(), alignProfile->getHeight(), 0);
+        if(aligned_frame) {
+            aligned_frame->copyInfoFromOther(depth);
+            aligned_frame->setStreamProfile(alignProfile);
+            alignFrames(aligned_frame, depth, to);
+            frames->pushFrame(std::move(aligned_frame));
+        }
+    }
+
+    return frames;
+}
+
+OBFrameType Align::getAlignFrameType() {
+    switch(align_to_stream_) {
+    case OB_STREAM_DEPTH:
+        return OB_FRAME_DEPTH;
+    case OB_STREAM_COLOR:
+        return OB_FRAME_COLOR;
+    case OB_STREAM_IR:
+        return OB_FRAME_IR;
+    case OB_STREAM_IR_LEFT:
+        return OB_FRAME_IR_LEFT;
+    case OB_STREAM_IR_RIGHT:
+        return OB_FRAME_IR_RIGHT;
+    default:
+        return OB_FRAME_UNKNOWN;
+    }
+}
+
+void Align::alignFrames(std::shared_ptr<Frame> aligned, const std::shared_ptr<const Frame> from, const std::shared_ptr<const Frame> to) {
+    if((!from) || (!to) || (!aligned)) {
+        LOG_ERROR_INTVL("Null pointer is unexpected");
+        return;
+    }
+    auto fromProfile = from->getStreamProfile();
+    auto toProfile   = to->getStreamProfile();
+
+    auto fromVideoProfile = fromProfile->as<VideoStreamProfile>();
+    from_intrin_          = fromVideoProfile->getIntrinsic();
+    from_disto_           = fromVideoProfile->getDistortion();
+    auto toVideoProfile   = toProfile->as<VideoStreamProfile>();
+    to_intrin_            = toVideoProfile->getIntrinsic();
+    to_disto_             = toVideoProfile->getDistortion();
+    from_to_extrin_       = fromProfile->getExtrinsicTo(toProfile);
+
+    if(to->getType() == OB_FRAME_DEPTH) {
+        uint8_t *alignedData = reinterpret_cast<uint8_t *>(const_cast<void *>((void *)aligned->getData()));
+        memset(alignedData, 0, aligned->getDataSize());
+        // check if already initialized inside
+        auto depth_other_extrin = toProfile->getExtrinsicTo(fromProfile);
+        pImpl->initialize(to_intrin_, to_disto_, from_intrin_, from_disto_, depth_other_extrin, depth_unit_mm_, add_target_distortion_, gap_fill_copy_);
+        auto depth = reinterpret_cast<const uint16_t *>(to->getData());
+        auto in    = const_cast<const void *>((const void *)from->getData());
+        auto out   = const_cast<void *>((void *)aligned->getData());
+        pImpl->C2D(depth, toVideoProfile->getWidth(), toVideoProfile->getHeight(), in, out, fromVideoProfile->getWidth(), fromVideoProfile->getHeight(),
+                   from->getFormat());
+    }
+    else {
+        uint16_t *alignedData = reinterpret_cast<uint16_t *>(const_cast<void *>((void *)aligned->getData()));
+        memset(alignedData, 0, aligned->getDataSize());
+        pImpl->initialize(from_intrin_, from_disto_, to_intrin_, to_disto_, from_to_extrin_, depth_unit_mm_, add_target_distortion_, gap_fill_copy_);
+        auto in = reinterpret_cast<const uint16_t *>(from->getData());
+        pImpl->D2C(in, fromVideoProfile->getWidth(), fromVideoProfile->getHeight(), alignedData, toVideoProfile->getWidth(), toVideoProfile->getHeight());
+    }
+}
+
+std::shared_ptr<VideoStreamProfile> Align::createAlignedProfile(std::shared_ptr<const VideoStreamProfile> original_profile,
+                                                                std::shared_ptr<const VideoStreamProfile> to_profile) {
+
+    if(align_streams_.first != original_profile.get() || align_streams_.second != to_profile.get()) {
+        auto aligned_profile = original_profile->clone()->as<VideoStreamProfile>();
+        aligned_profile->setWidth(to_profile->getWidth());
+        aligned_profile->setHeight(to_profile->getHeight());
+        aligned_profile->bindIntrinsic(to_profile->getIntrinsic());
+        aligned_profile->bindDistortion(to_profile->getDistortion());
+        aligned_profile->bindSameExtrinsicTo(to_profile);
+        target_stream_profile_ = aligned_profile;
+        align_streams_         = { original_profile.get(), to_profile.get() };
+    }
+
+    return target_stream_profile_;
+}
+
+}  // namespace libobsensor
+
diff --git a/src/filter/publicfilters/Align.hpp b/src/filter/publicfilters/Align.hpp
new file mode 100644
index 00000000..5cd1a90a
--- /dev/null
+++ b/src/filter/publicfilters/Align.hpp
@@ -0,0 +1,58 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include "IFilter.hpp"
+#include "stream/StreamProfile.hpp"
+#include "AlignImpl.hpp"
+
+namespace libobsensor {
+
+/**
+ * @brief Aligh depth to color or vice verse
+ */
+class Align : public IFilterBase {
+public:
+    explicit Align();
+    virtual ~Align() noexcept;
+
+    OBStreamType getAlignToStreamType() {
+        return align_to_stream_;
+    }
+
+    void               updateConfig(std::vector<std::string> &params) override;
+    const std::string &getConfigSchema() const override;
+
+    void reset() override;
+
+private:
+    std::shared_ptr<Frame> process(std::shared_ptr<const Frame> frame) override;
+
+protected:
+    OBFrameType getAlignFrameType();
+
+    void alignFrames(std::shared_ptr<Frame> aligned, const std::shared_ptr<const Frame> from, const std::shared_ptr<const Frame> to);
+
+    std::shared_ptr<VideoStreamProfile> createAlignedProfile(std::shared_ptr<const VideoStreamProfile> original_profile,
+                                                             std::shared_ptr<const VideoStreamProfile> to_profile);
+
+    virtual void resetCache() {};
+
+private:
+    std::pair<const VideoStreamProfile *, const VideoStreamProfile *> align_streams_;
+    std::shared_ptr<VideoStreamProfile>                               target_stream_profile_;
+
+    OBStreamType         align_to_stream_;
+    std::recursive_mutex alignMutex_;
+    AlignImpl           *pImpl;
+    float                depth_unit_mm_;
+    bool                 add_target_distortion_;
+    bool                 gap_fill_copy_;
+    OBCameraIntrinsic    from_intrin_;
+    OBCameraDistortion   from_disto_;
+    OBCameraIntrinsic    to_intrin_;
+    OBCameraDistortion   to_disto_;
+    OBExtrinsic          from_to_extrin_;
+};
+
+}  // namespace libobsensor
diff --git a/src/filter/publicfilters/AlignImpl.cpp b/src/filter/publicfilters/AlignImpl.cpp
new file mode 100644
index 00000000..1f722cbd
--- /dev/null
+++ b/src/filter/publicfilters/AlignImpl.cpp
@@ -0,0 +1,687 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "AlignImpl.hpp"
+#include "logger/Logger.hpp"
+#include "exception/ObException.hpp"
+#include <fstream>
+#include <iostream>
+#include <chrono>
+#include <complex>
+
+namespace libobsensor {
+
+static inline void addDistortion(const OBCameraDistortion &distort_param, const float pt_ud[2], float pt_d[2]) {
+    float k1 = distort_param.k1, k2 = distort_param.k2, k3 = distort_param.k3;
+    float k4 = distort_param.k4, k5 = distort_param.k5, k6 = distort_param.k6;
+    float p1 = distort_param.p1, p2 = distort_param.p2;
+
+    const float r2 = pt_ud[0] * pt_ud[0] + pt_ud[1] * pt_ud[1];
+
+    if((distort_param.model == OB_DISTORTION_BROWN_CONRADY) || (distort_param.model == OB_DISTORTION_BROWN_CONRADY_K6)) {
+        const float r4 = r2 * r2;
+        const float r6 = r4 * r2;
+
+        float k_diff = 1 + k1 * r2 + k2 * r4 + k3 * r6;
+        if(distort_param.model == OB_DISTORTION_BROWN_CONRADY_K6) {
+            k_diff /= (1 + k4 * r2 + k5 * r4 + k6 * r6);
+        }
+
+        const float t_x = p2 * (r2 + 2 * pt_ud[0] * pt_ud[0]) + 2 * p1 * pt_ud[0] * pt_ud[1];
+        const float t_y = p1 * (r2 + 2 * pt_ud[1] * pt_ud[1]) + 2 * p2 * pt_ud[0] * pt_ud[1];
+
+        pt_d[0] = pt_ud[0] * k_diff + t_x;
+        pt_d[1] = pt_ud[1] * k_diff + t_y;
+    }
+    else if(distort_param.model == OB_DISTORTION_KANNALA_BRANDT4) {
+        const double r      = sqrt(r2);
+        const double theta  = atan(r);
+        const double theta2 = theta * theta;
+        const double theta4 = theta2 * theta2;
+        const double theta6 = theta2 * theta4;
+        const double theta8 = theta4 * theta4;
+
+        const double k_diff = theta * (1 + (k1 * theta2) + (k2 * theta4) + (k3 * theta6) + (k4 * theta8));
+
+        pt_d[0] = static_cast<float>(k_diff / r * pt_ud[0]);
+        pt_d[1] = static_cast<float>(k_diff / r * pt_ud[1]);
+    }
+}
+
+static inline void removeDistortion(const OBCameraDistortion &distort_param, const float pt_d[2], float pt_ud[2]) {
+    const float epsilon       = 1e-6f;
+    const int   max_iteration = 20;
+    float       tmp_p_ud[2]   = { pt_d[0], pt_d[1] };
+    memset(pt_ud, 0, sizeof(float) * 2);
+    addDistortion(distort_param, tmp_p_ud, pt_ud);
+
+    pt_ud[0]  = pt_ud[0] - tmp_p_ud[0];
+    pt_ud[1]  = pt_ud[1] - tmp_p_ud[1];
+    int   it  = 0;
+    float err = fabs(tmp_p_ud[0] + pt_ud[0] - pt_d[0]) + fabs(tmp_p_ud[1] + pt_ud[1] - pt_d[1]);
+    while(err > epsilon && it++ < max_iteration) {
+        tmp_p_ud[0] = pt_d[0] - pt_ud[0];
+        tmp_p_ud[1] = pt_d[1] - pt_ud[1];
+        addDistortion(distort_param, tmp_p_ud, pt_ud);
+
+        pt_ud[0] = pt_ud[0] - tmp_p_ud[0];
+        pt_ud[1] = pt_ud[1] - tmp_p_ud[1];
+        err      = fabs(tmp_p_ud[0] + pt_ud[0] - pt_d[0]) + fabs(tmp_p_ud[1] + pt_ud[1] - pt_d[1]);
+    }
+
+    pt_ud[0] = tmp_p_ud[0];
+    pt_ud[1] = tmp_p_ud[1];
+}
+
+const __m128  AlignImpl::POINT_FIVE = _mm_set_ps1(0.5);
+const __m128  AlignImpl::TWO        = _mm_set_ps1(2);
+const __m128i AlignImpl::ZERO       = _mm_setzero_si128();
+const __m128  AlignImpl::ZERO_F     = _mm_set_ps1(0.0);
+
+AlignImpl::AlignImpl() : initialized_(false) {
+    depth_unit_mm_ = 1.0;
+    r2_max_loc_    = 0.0;
+    memset(&depth_intric_, 0, sizeof(OBCameraIntrinsic));
+    memset(&depth_disto_, 0, sizeof(OBCameraDistortion));
+    memset(&rgb_intric_, 0, sizeof(OBCameraIntrinsic));
+    memset(&rgb_disto_, 0, sizeof(OBCameraDistortion));
+}
+
+AlignImpl::~AlignImpl() {
+    clearMatrixCache();
+    initialized_ = false;
+}
+
+void AlignImpl::initialize(OBCameraIntrinsic depth_intrin, OBCameraDistortion depth_disto, OBCameraIntrinsic rgb_intrin, OBCameraDistortion rgb_disto,
+                           OBExtrinsic extrin, float depth_unit_mm, bool add_target_distortion, bool gap_fill_copy) {
+    if(initialized_ && memcmp(&depth_intrin, &depth_intric_, sizeof(OBCameraIntrinsic)) == 0
+       && memcmp(&depth_disto, &depth_disto_, sizeof(OBCameraDistortion)) == 0 && memcmp(&rgb_intrin, &rgb_intric_, sizeof(OBCameraIntrinsic)) == 0
+       && memcmp(&rgb_disto, &rgb_disto_, sizeof(OBCameraDistortion)) == 0 && memcmp(&extrin, &transform_, sizeof(OBExtrinsic)) == 0
+       && depth_unit_mm == depth_unit_mm_ && add_target_distortion == add_target_distortion_ && gap_fill_copy == gap_fill_copy_) {
+        return;
+    }
+    memcpy(&depth_intric_, &depth_intrin, sizeof(OBCameraIntrinsic));
+    memcpy(&depth_disto_, &depth_disto, sizeof(OBCameraDistortion));
+    memcpy(&rgb_intric_, &rgb_intrin, sizeof(OBCameraIntrinsic));
+    memcpy(&rgb_disto_, &rgb_disto, sizeof(OBCameraDistortion));
+    memcpy(&transform_, &extrin, sizeof(OBExtrinsic));
+    add_target_distortion_ = add_target_distortion;
+    // since undistorted depth (whether d2c or c2d) is necessory ...
+    need_to_undistort_depth_ = ((depth_disto.k1 != 0) || (depth_disto.k2 != 0) || (depth_disto.k3 != 0) || (depth_disto.k4 != 0) || (depth_disto.k5 != 0)
+                                || (depth_disto.k6 != 0) || (depth_disto.p1 != 0) || (depth_disto.p2 != 0));
+    depth_unit_mm_           = depth_unit_mm;
+    gap_fill_copy_           = gap_fill_copy;
+    // Translation is related to depth unit.
+    for(int i = 0; i < 3; ++i) {
+        scaled_trans_[i] = transform_.trans[i] / depth_unit_mm_;
+    }
+
+    color_fx_       = _mm_set_ps1(rgb_intric_.fx);
+    color_cx_       = _mm_set_ps1(rgb_intric_.cx);
+    color_fy_       = _mm_set_ps1(rgb_intric_.fy);
+    color_cy_       = _mm_set_ps1(rgb_intric_.cy);
+    color_k1_       = _mm_set_ps1(rgb_disto_.k1);
+    color_k2_       = _mm_set_ps1(rgb_disto_.k2);
+    color_k3_       = _mm_set_ps1(rgb_disto_.k3);
+    color_k4_       = _mm_set_ps1(rgb_disto_.k4);
+    color_k5_       = _mm_set_ps1(rgb_disto_.k5);
+    color_k6_       = _mm_set_ps1(rgb_disto_.k6);
+    color_p1_       = _mm_set_ps1(rgb_disto_.p1);
+    color_p2_       = _mm_set_ps1(rgb_disto_.p2);
+    scaled_trans_1_ = _mm_set_ps1(scaled_trans_[0]);
+    scaled_trans_2_ = _mm_set_ps1(scaled_trans_[1]);
+    scaled_trans_3_ = _mm_set_ps1(scaled_trans_[2]);
+
+    prepareDepthResolution();
+    initialized_ = true;
+}
+
+void AlignImpl::reset() {
+    clearMatrixCache();
+    initialized_ = false;
+}
+
+float polynomial(float x, float a, float b, float c, float d) {
+    return (a * x * x * x + b * x * x + c * x + d);
+}
+
+float binarySearch(float left, float right, float a, float b, float c, float d, float tolerance = 1e-4) {
+    while((right - left) > tolerance) {
+        float mid   = (left + right) / 2.f;
+        float f_mid = polynomial(mid, a, b, c, d);
+        if(fabs(f_mid) < tolerance)
+            return mid;
+        else if(f_mid * polynomial(left, a, b, c, d) < 0)
+            right = mid;
+        else
+            left = mid;
+    }
+    return (left + right) / 2.f;
+}
+
+float estimateInflectionPoint(ob_camera_intrinsic depth_intr, ob_camera_intrinsic rgb_intr, ob_camera_distortion disto) {
+    float result = 0.f;
+    if(OB_DISTORTION_BROWN_CONRADY_K6 == disto.model) {
+        // with k6 distortion model, the denominator (involving k4~k6) should should not be zero
+        // the following solves the polynominal function with binary search
+        // then a inflection point should be labeled there
+        float r2_min = 0.f, r2_max = 0.f;
+        {
+            float               r2[2];
+            ob_camera_intrinsic intrs[] = { depth_intr, rgb_intr };
+            for(int i = 0; i < 2; i++) {
+                ob_camera_intrinsic intr = intrs[i];
+                float               u    = (intr.cx > (intr.width - intr.cx)) ? intr.cx : (intr.width - intr.cx),
+                      v                  = (intr.cy > (intr.height - intr.cy)) ? intr.cy : (intr.height - intr.cy);
+                float x = u / intr.fx, y = v / intr.fy;
+                r2[i] = x * x + y * y;
+            }
+            if(r2[0] > r2[1]) {
+                r2_max = r2[0], r2_min = r2[1];
+            }
+            else {
+                r2_max = r2[1], r2_min = r2[0];
+            }
+        }
+
+        float c = disto.k4, b = disto.k5, a = disto.k6, d = 1.f;
+        float prevX = r2_min;
+        float prevF = polynomial(prevX, a, b, c, d);
+        for(float r2 = prevX + 0.1f; r2 <= r2_max; r2 += 0.1f) {
+            float f = polynomial(r2, a, b, c, d);
+            if(prevF * f <= 0) {
+                result = binarySearch(prevX, r2, a, b, c, d);
+                break;
+            }
+            prevX = r2;
+            prevF = f;
+        }
+    }
+    return result;
+}
+
+void AlignImpl::prepareDepthResolution() {
+    clearMatrixCache();
+
+    // There may be outliers due to possible inflection points of the calibrated K6 distortion curve;
+    if(add_target_distortion_) {
+        r2_max_loc_     = estimateInflectionPoint(depth_intric_, rgb_intric_, rgb_disto_);
+        r2_max_loc_sse_ = _mm_set_ps1(r2_max_loc_);
+    }
+
+    // Prepare LUTs
+    {
+        int                channel   = (gap_fill_copy_ ? 1 : 2);
+        unsigned long long stride    = depth_intric_.width * channel;
+        unsigned long long coeff_num = depth_intric_.height * stride;
+
+        float *rot_coeff1 = new float[coeff_num];
+        float *rot_coeff2 = new float[coeff_num];
+        float *rot_coeff3 = new float[coeff_num];
+
+        for(int i = 0; i < channel; i++) {
+            int mutliplier = (gap_fill_copy_ ? 0 : (i ? 1 : -1));
+            for(int v = 0; v < depth_intric_.height; ++v) {
+                float *dst1 = rot_coeff1 + v * stride + i;
+                float *dst2 = rot_coeff2 + v * stride + i;
+                float *dst3 = rot_coeff3 + v * stride + i;
+                float  y    = (v + mutliplier * 0.5f - depth_intric_.cy) / depth_intric_.fy;
+                for(int u = 0; u < depth_intric_.width; ++u) {
+                    float x = (u + mutliplier * 0.5f - depth_intric_.cx) / depth_intric_.fx;
+
+                    float x_ud = x, y_ud = y;
+                    if(need_to_undistort_depth_) {
+                        float pt_d[2] = { x, y };
+                        float pt_ud[2];
+                        removeDistortion(depth_disto_, pt_d, pt_ud);
+                        x_ud = pt_ud[0];
+                        y_ud = pt_ud[1];
+                    }
+
+                    *dst1 = transform_.rot[0] * x_ud + transform_.rot[1] * y_ud + transform_.rot[2];
+                    *dst2 = transform_.rot[3] * x_ud + transform_.rot[4] * y_ud + transform_.rot[5];
+                    *dst3 = transform_.rot[6] * x_ud + transform_.rot[7] * y_ud + transform_.rot[8];
+                    dst1 += channel;
+                    dst2 += channel;
+                    dst3 += channel;
+                }
+            }
+        }
+
+        rot_coeff_ht_x[std::make_pair(depth_intric_.width, depth_intric_.height)] = rot_coeff1;
+        rot_coeff_ht_y[std::make_pair(depth_intric_.width, depth_intric_.height)] = rot_coeff2;
+        rot_coeff_ht_z[std::make_pair(depth_intric_.width, depth_intric_.height)] = rot_coeff3;
+    }
+}
+
+void AlignImpl::clearMatrixCache() {
+    for(auto item: rot_coeff_ht_x) {
+        if(item.second) {
+            delete[] item.second;
+        }
+    }
+    for(auto item: rot_coeff_ht_y) {
+        if(item.second) {
+            delete[] item.second;
+        }
+    }
+    for(auto item: rot_coeff_ht_z) {
+        if(item.second) {
+            delete[] item.second;
+        }
+    }
+
+    rot_coeff_ht_x.clear();
+    rot_coeff_ht_y.clear();
+    rot_coeff_ht_z.clear();
+}
+
+template <typename T> void fillPixelGap(const int *u, const int *v, const int width, const int height, const T val, T *buffer, bool copy = true) {
+    // point index and output depth buffer should be checked outside
+
+    if(copy) {
+        if((u[0] >= 0) && (u[0] < width) && (v[0] >= 0) && (v[0] < height)) {
+            int pos          = v[0] * width + u[0];
+            buffer[pos]      = val;
+            bool right_valid = (u[0] + 1) < width, bottom_valid = (v[0] + 1) < height;
+            if(right_valid) {
+                if(buffer[pos + 1] > val)
+                    buffer[pos + 1] = val;
+            }
+            if(bottom_valid) {
+                if(buffer[pos + width] > val)
+                    buffer[pos + width] = val;
+            }
+            if(right_valid && bottom_valid) {
+                if(buffer[pos + width + 1] > val)
+                    buffer[pos + width + 1] = val;
+            }
+        }
+    }
+    else {
+        int v0 = v[0] < 0 ? 0 : v[0];
+        int u0 = u[0] < 0 ? 0 : u[0];
+        int v1 = v[1] < (height - 1) ? v[1] : (height - 1);
+        int u1 = u[1] < (width - 1) ? u[1] : (width - 1);
+        for(int vr = v0; vr <= v1; vr++) {
+            for(int ur = u0; ur <= u1; ur++) {
+                int pos = vr * width + ur;
+                if(buffer[pos] > val)
+                    buffer[pos] = val;
+            }
+        }
+    }
+}
+
+void AlignImpl::transferDepth(const float *x, const float *y, const float *z, const int npts, const int point_index, uint16_t *out_depth, int *map) {
+    int nchannels = gap_fill_copy_ ? 1 : 2;
+
+    for(int i = 0; i < npts; i++) {
+
+        int u_rgb[] = { -1, -1 };
+        int v_rgb[] = { -1, -1 };
+
+        uint16_t cur_depth     = 65535;
+        bool     depth_invalid = false;
+        for(int chl = 0; chl < nchannels; chl++) {
+            int k = i + chl * npts;
+            if(z[k] < EPSILON) {
+                depth_invalid = true;
+                break;
+            }
+
+            u_rgb[chl] = static_cast<int>(x[k] + 0.5), v_rgb[chl] = static_cast<int>(y[k] + 0.5);
+
+            if(z[k] < cur_depth)
+                cur_depth = static_cast<uint16_t>(z[k]);
+        }
+
+        if(depth_invalid)
+            continue;
+
+        if(map) {  // coordinates mapping for C2D
+            if((u_rgb[0] >= 0) && (u_rgb[0] < rgb_intric_.width) && (v_rgb[0] >= 0) && (v_rgb[0] < rgb_intric_.height)) {
+                map[2 * (point_index + i)]     = u_rgb[0];
+                map[2 * (point_index + i) + 1] = v_rgb[0];
+            }
+        }
+
+        if(out_depth) {
+            fillPixelGap<uint16_t>(u_rgb, v_rgb, rgb_intric_.width, rgb_intric_.height, cur_depth, out_depth, gap_fill_copy_);
+        }
+    }
+}
+
+void AlignImpl::BMDistortedWithSSE(__m128 &tx, __m128 &ty, const __m128 x2, const __m128 y2, const __m128 r2) {
+    __m128 xy = _mm_mul_ps(tx, ty);
+    __m128 r4 = _mm_mul_ps(r2, r2);
+    __m128 r6 = _mm_mul_ps(r4, r2);
+
+    // float k_jx = k_diff = (1 + k1 * r2 + k2 * r4 + k3 * r6) / (1 + k4 * r2 + k5 * r4 + k6 * r6);
+    __m128 k_jx =
+        _mm_div_ps(_mm_add_ps(_mm_set_ps1(1), _mm_add_ps(_mm_add_ps(_mm_mul_ps(color_k1_, r2), _mm_mul_ps(color_k2_, r4)), _mm_mul_ps(color_k3_, r6))),
+                   _mm_add_ps(_mm_set_ps1(1), _mm_add_ps(_mm_add_ps(_mm_mul_ps(color_k4_, r2), _mm_mul_ps(color_k5_, r4)), _mm_mul_ps(color_k6_, r6))));
+
+    // float x_qx = p2 * (2 * x2 + r2) + 2 * p1 * xy;
+    __m128 x_qx = _mm_add_ps(_mm_mul_ps(color_p2_, _mm_add_ps(_mm_mul_ps(x2, TWO), r2)), _mm_mul_ps(_mm_mul_ps(color_p1_, xy), TWO));
+
+    // float y_qx = p1 * (2 * y2 + r2) + 2 * p2 * xy;
+    __m128 y_qx = _mm_add_ps(_mm_mul_ps(color_p1_, _mm_add_ps(_mm_mul_ps(y2, TWO), r2)), _mm_mul_ps(_mm_mul_ps(color_p2_, xy), TWO));
+
+    // float distx = tx * k_jx + x_qx;
+    tx = _mm_add_ps(_mm_mul_ps(tx, k_jx), x_qx);
+
+    // float disty = ty * k_jx + y_qx;
+    ty = _mm_add_ps(_mm_mul_ps(ty, k_jx), y_qx);
+}
+
+void AlignImpl::KBDistortedWithSSE(__m128 &tx, __m128 &ty, const __m128 r2) {
+    __m128 r = _mm_sqrt_ps(r2);
+
+    // float theta=atan(r)
+    float r_[4]     = { 0 };
+    float theta_[4] = { 0 };
+    _mm_storeu_ps(r_, r);
+
+    theta_[0] = atan(r_[0]);
+    theta_[1] = atan(r_[1]);
+    theta_[2] = atan(r_[2]);
+    theta_[3] = atan(r_[3]);
+
+    __m128 theta  = _mm_loadu_ps(theta_);
+    __m128 theta2 = _mm_mul_ps(theta, theta);
+    __m128 theta3 = _mm_mul_ps(theta, theta2);
+    __m128 theta5 = _mm_mul_ps(theta2, theta3);
+    __m128 theta7 = _mm_mul_ps(theta2, theta5);
+    __m128 theta9 = _mm_mul_ps(theta2, theta7);
+
+    // float theta_jx=theta+k1*theta2+k2*theta4+k3*theta6+k4*theta8
+    __m128 theta_jx =
+        _mm_add_ps(_mm_add_ps(_mm_add_ps(_mm_add_ps(theta, _mm_mul_ps(color_k1_, theta3)), _mm_mul_ps(color_k2_, theta5)), _mm_mul_ps(color_k3_, theta7)),
+                   _mm_mul_ps(color_k4_, theta9));
+
+    // float tx=(theta_jx/r)*tx
+    tx = _mm_mul_ps(_mm_div_ps(theta_jx, r), tx);
+
+    // float ty=(theta_jx/r)*ty
+    ty = _mm_mul_ps(_mm_div_ps(theta_jx, r), ty);
+}
+
+void AlignImpl::distortedWithSSE(__m128 &tx, __m128 &ty, const __m128 x2, const __m128 y2, const __m128 r2) {
+    __m128 xy = _mm_mul_ps(tx, ty);
+    __m128 r4 = _mm_mul_ps(r2, r2);
+    __m128 r6 = _mm_mul_ps(r4, r2);
+
+    // float k_jx = k1 * r2 + k2 * r4 + k3 * r6;
+    __m128 k_jx = _mm_add_ps(_mm_add_ps(_mm_mul_ps(color_k1_, r2), _mm_mul_ps(color_k2_, r4)), _mm_mul_ps(color_k3_, r6));
+
+    // float x_qx = p2 * (2 * x2 + r2) + 2 * p1 * xy;
+    __m128 x_qx_1 = _mm_mul_ps(color_p2_, _mm_add_ps(_mm_mul_ps(x2, TWO), r2));
+    __m128 x_qx_2 = _mm_mul_ps(_mm_mul_ps(color_p1_, xy), TWO);
+    __m128 x_qx   = _mm_add_ps(x_qx_1, x_qx_2);
+
+    // float y_qx = p1 * (2 * y2 + r2) + 2 * p2 * xy;
+    __m128 y_qx_1 = _mm_mul_ps(color_p1_, _mm_add_ps(_mm_mul_ps(y2, TWO), r2));
+    __m128 y_qx_2 = _mm_mul_ps(_mm_mul_ps(color_p2_, xy), TWO);
+    __m128 y_qx   = _mm_add_ps(y_qx_1, y_qx_2);
+
+    // float distx = tx * k_jx + x_qx;
+    __m128 distx_lo = _mm_add_ps(_mm_mul_ps(tx, k_jx), x_qx);
+    // float disty = ty * k_jx + y_qx;
+    __m128 disty_lo = _mm_add_ps(_mm_mul_ps(ty, k_jx), y_qx);
+
+    // tx = tx + distx;
+    // ty = ty + disty;
+    tx = _mm_add_ps(tx, distx_lo);
+    ty = _mm_add_ps(ty, disty_lo);
+}
+
+void AlignImpl::D2CWithoutSSE(const uint16_t *depth_buffer, uint16_t *out_depth, const float *coeff_mat_x, const float *coeff_mat_y, const float *coeff_mat_z,
+                              int *map) {
+
+    int       channel     = (gap_fill_copy_ ? 1 : 2);
+    float    *ptr_coeff_x = (float *)coeff_mat_x;
+    float    *ptr_coeff_y = (float *)coeff_mat_y;
+    float    *ptr_coeff_z = (float *)coeff_mat_z;
+    uint16_t *ptr_depth   = (uint16_t *)depth_buffer;
+
+    for(int v = 0; v < depth_intric_.height; v += 1) {
+        int depth_idx = v * depth_intric_.width;
+        for(int u = 0; u < depth_intric_.width; u += 1) {
+            uint16_t depth = *ptr_depth++;
+            depth_idx++;
+            if(depth < EPSILON) {
+                ptr_coeff_x += channel;
+                ptr_coeff_y += channel;
+                ptr_coeff_z += channel;
+                continue;
+            }
+            // int   u_rgb[] = { -1, -1 };
+            // int   v_rgb[] = { -1, -1 };
+            float pixelx_f[2], pixely_f[2], dst[2];
+
+            bool skip_this_pixel = true;
+            for(int k = 0; k < channel; k++) {
+                float dst_x = depth * (*ptr_coeff_x++) + scaled_trans_[0];
+                float dst_y = depth * (*ptr_coeff_y++) + scaled_trans_[1];
+                dst[k]      = depth * (*ptr_coeff_z++) + scaled_trans_[2];
+
+                float tx = float(dst_x / dst[k]);
+                float ty = float(dst_y / dst[k]);
+
+                if(add_target_distortion_) {
+                    float pt_ud[2] = { tx, ty };
+                    float pt_d[2]  = { 0 };
+                    float r2_cur   = pt_ud[0] * pt_ud[0] + pt_ud[1] * pt_ud[1];
+                    if((OB_DISTORTION_BROWN_CONRADY_K6 == rgb_disto_.model) && (r2_max_loc_ != 0) && (r2_cur > r2_max_loc_)) {
+                        continue;  // break;
+                    }
+                    addDistortion(rgb_disto_, pt_ud, pt_d);
+                    tx = pt_d[0];
+                    ty = pt_d[1];
+                }
+
+                pixelx_f[k]     = tx * rgb_intric_.fx + rgb_intric_.cx;
+                pixely_f[k]     = ty * rgb_intric_.fy + rgb_intric_.cy;
+                skip_this_pixel = false;
+            }
+
+            if(!skip_this_pixel)
+                transferDepth(pixelx_f, pixely_f, dst, 1, depth_idx - 1, out_depth, map);
+        }
+    }
+}
+
+void AlignImpl::D2CWithSSE(const uint16_t *depth_buffer, uint16_t *out_depth, const float *coeff_mat_x, const float *coeff_mat_y, const float *coeff_mat_z,
+                           int *map) {
+
+    int channel = (gap_fill_copy_ ? 1 : 2);
+    for(int i = 0; i < depth_intric_.width * depth_intric_.height; i += 8) {
+        __m128i depth_i16 = _mm_loadu_si128((__m128i *)(depth_buffer + i));
+        __m128i depth_i[] = { _mm_unpacklo_epi16(depth_i16, ZERO), _mm_unpackhi_epi16(depth_i16, ZERO) };
+
+        // transform 8 points each group
+        // int group_idx = i * channel;
+
+        // lower half or higher half 4 points of that group
+        for(int k = 0; k < 2; k++) {
+
+            // int half_idx = group_idx + k * 4 * channel;
+            int half_idx = (i + k * 4) * channel;
+
+            __m128 depth_o, nx, ny;
+            __m128 depth_sse = _mm_cvtepi32_ps(depth_i[k]);
+            float  x[8]      = { 0 };
+            float  y[8]      = { 0 };
+            float  z[8]      = { 0 };
+
+            // center or top-left-and-bottom-right
+            for(int fold = 0; fold < channel; fold++) {
+                // int coeff_idx = half_idx + fold * 2 * channel;
+                int    coeff_idx  = half_idx;
+                float  coeff_x[4] = { coeff_mat_x[coeff_idx + fold], coeff_mat_x[coeff_idx + 1 * channel + fold], coeff_mat_x[coeff_idx + 2 * channel + fold],
+                                      coeff_mat_x[coeff_idx + 3 * channel + fold] };
+                float  coeff_y[4] = { coeff_mat_y[coeff_idx + fold], coeff_mat_y[coeff_idx + 1 * channel + fold], coeff_mat_y[coeff_idx + 2 * channel + fold],
+                                      coeff_mat_y[coeff_idx + 3 * channel + fold] };
+                float  coeff_z[4] = { coeff_mat_z[coeff_idx + fold], coeff_mat_z[coeff_idx + 1 * channel + fold], coeff_mat_z[coeff_idx + 2 * channel + fold],
+                                      coeff_mat_z[coeff_idx + 3 * channel + fold] };
+                __m128 coeff_sse1 = _mm_loadu_ps(coeff_x);
+                __m128 coeff_sse2 = _mm_loadu_ps(coeff_y);
+                __m128 coeff_sse3 = _mm_loadu_ps(coeff_z);
+
+                __m128 X = _mm_add_ps(_mm_mul_ps(depth_sse, coeff_sse1), scaled_trans_1_);
+                __m128 Y = _mm_add_ps(_mm_mul_ps(depth_sse, coeff_sse2), scaled_trans_2_);
+                depth_o  = _mm_add_ps(_mm_mul_ps(depth_sse, coeff_sse3), scaled_trans_3_);
+
+                nx = _mm_div_ps(X, depth_o);
+                ny = _mm_div_ps(Y, depth_o);
+
+                if(add_target_distortion_) {
+                    __m128 x2 = _mm_mul_ps(nx, nx);
+                    __m128 y2 = _mm_mul_ps(ny, ny);
+                    __m128 r2 = _mm_add_ps(x2, y2);
+
+                    __m128 flag = _mm_or_ps(_mm_cmpge_ps(ZERO_F, r2_max_loc_sse_), _mm_cmplt_ps(r2, r2_max_loc_sse_));
+                    switch(rgb_disto_.model) {
+                    case OB_DISTORTION_BROWN_CONRADY:
+                        distortedWithSSE(nx, ny, x2, y2, r2);
+                        break;
+                    case OB_DISTORTION_BROWN_CONRADY_K6:
+                        depth_o = _mm_and_ps(depth_o, flag);
+                        BMDistortedWithSSE(nx, ny, x2, y2, r2);
+                        break;
+                    case OB_DISTORTION_KANNALA_BRANDT4:
+                        KBDistortedWithSSE(nx, ny, r2);
+                        break;
+                    default:
+                        LOG_ERROR("Distortion model not supported yet");
+                        break;
+                    }
+                }
+
+                __m128 pixelx = _mm_add_ps(_mm_mul_ps(nx, color_fx_), color_cx_);
+                __m128 pixely = _mm_add_ps(_mm_mul_ps(ny, color_fy_), color_cy_);
+                _mm_storeu_ps(x + fold * 4, pixelx);
+                _mm_storeu_ps(y + fold * 4, pixely);
+                _mm_storeu_ps(z + fold * 4, depth_o);
+            }
+
+            transferDepth(x, y, z, 4, i + k * 4, out_depth, map);
+        }
+    }
+}
+
+int AlignImpl::D2C(const uint16_t *depth_buffer, int depth_width, int depth_height, uint16_t *out_depth, int color_width, int color_height, int *map,
+                   bool withSSE) {
+    int ret = 0;
+    if(!initialized_ || depth_width != depth_intric_.width || depth_height != depth_intric_.height || color_width != rgb_intric_.width
+       || color_height != rgb_intric_.height) {
+        LOG_ERROR("Not initialized or input parameters don't match");
+        return -1;
+    }
+
+    auto finder_x = rot_coeff_ht_x.find(std::make_pair(depth_width, depth_height));
+    auto finder_y = rot_coeff_ht_y.find(std::make_pair(depth_width, depth_height));
+    auto finder_z = rot_coeff_ht_z.find(std::make_pair(depth_width, depth_height));
+    if((rot_coeff_ht_x.cend() == finder_x) || (rot_coeff_ht_y.cend() == finder_y) || (rot_coeff_ht_z.cend() == finder_z)) {
+        LOG_ERROR("Found a new resolution, but initialization failed!");
+        return -1;
+    }
+
+    if((!depth_buffer) || ((!out_depth && !map))) {
+        LOG_ERROR("Buffer not initialized");
+        return -1;
+    }
+
+    int pixnum = color_width * color_height;
+    if(out_depth) {
+        // init to 1s (depth 0 may be used as other useful date)
+        memset(out_depth, 0xff, pixnum * sizeof(uint16_t));
+    }
+
+    const float *coeff_mat_x = finder_x->second;
+    const float *coeff_mat_y = finder_y->second;
+    const float *coeff_mat_z = finder_z->second;
+
+    if(withSSE) {
+        D2CWithSSE(depth_buffer, out_depth, coeff_mat_x, coeff_mat_y, coeff_mat_z, map);
+    }
+    else {
+        D2CWithoutSSE(depth_buffer, out_depth, coeff_mat_x, coeff_mat_y, coeff_mat_z, map);
+    }
+
+    if(out_depth) {
+        for(int idx = 0; idx < pixnum; idx++) {
+            if(65535 == out_depth[idx]) {
+                out_depth[idx] = 0;
+            }
+        }
+    }
+
+    return ret;
+}
+
+typedef struct {
+    unsigned char byte[3];
+} uint24_t;
+
+int AlignImpl::C2D(const uint16_t *depth_buffer, int depth_width, int depth_height, const void *rgb_buffer, void *out_rgb, int color_width, int color_height,
+                   OBFormat format, bool withSSE) {
+
+    // rgb x-y coordinates for each depth pixel
+    unsigned long long size     = static_cast<unsigned long long>(depth_width) * depth_height * 2;
+    int               *depth_xy = new int[size];
+    memset(depth_xy, -1, size * sizeof(int));
+
+    int ret = -1;
+    if(!D2C(depth_buffer, depth_width, depth_height, nullptr, color_width, color_height, depth_xy, withSSE)) {
+
+        switch(format) {
+        case OB_FORMAT_Y8:
+            memset(out_rgb, 0, depth_width * depth_height * sizeof(uint8_t));
+            mapPixel<uint8_t>(depth_xy, static_cast<const uint8_t *>(rgb_buffer), color_width, color_height, (uint8_t *)out_rgb, depth_width, depth_height);
+            break;
+        case OB_FORMAT_Y16:
+            memset(out_rgb, 0, depth_width * depth_height * sizeof(uint16_t));
+            mapPixel<uint16_t>(depth_xy, static_cast<const uint16_t *>(rgb_buffer), color_width, color_height, (uint16_t *)out_rgb, depth_width, depth_height);
+            break;
+        case OB_FORMAT_RGB:
+        case OB_FORMAT_BGR:
+            memset(out_rgb, 0, depth_width * depth_height * sizeof(uint24_t));
+            mapPixel<uint24_t>(depth_xy, static_cast<const uint24_t *>(rgb_buffer), color_width, color_height, (uint24_t *)out_rgb, depth_width, depth_height);
+            break;
+        case OB_FORMAT_BGRA:
+        case OB_FORMAT_RGBA:
+            memset(out_rgb, 0, depth_width * depth_height * sizeof(uint24_t));
+            mapPixel<uint32_t>(depth_xy, static_cast<const uint32_t *>(rgb_buffer), color_width, color_height, (uint32_t *)out_rgb, depth_width, depth_height);
+            break;
+        case OB_FORMAT_MJPG:
+        case OB_FORMAT_YUYV:
+        default:
+            LOG_ERROR("Unsupported format for C2D conversion yet!");
+            break;
+        }
+
+        ret = 0;
+    }
+    delete[] depth_xy;
+    depth_xy = nullptr;
+
+    return ret;
+}
+
+template <typename T>
+void AlignImpl::mapPixel(const int *map, const T *src_buffer, int src_width, int src_height, T *dst_buffer, int dst_width, int dst_height) {
+    for(int v = 0; v < dst_height; v++) {
+        for(int u = 0; u < dst_width; u++) {
+            int id = v * dst_width + u;
+            int us = map[2 * id], vs = map[2 * id + 1];
+            if((us < 0) || (us > src_width - 1) || (vs < 0) || (vs > src_height - 1))
+                continue;
+            int is         = vs * src_width + us;
+            dst_buffer[id] = src_buffer[is];
+        }
+    }
+}
+
+}  // namespace libobsensor
diff --git a/src/filter/publicfilters/AlignImpl.hpp b/src/filter/publicfilters/AlignImpl.hpp
new file mode 100644
index 00000000..22b8cbe3
--- /dev/null
+++ b/src/filter/publicfilters/AlignImpl.hpp
@@ -0,0 +1,183 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#ifndef D2C_DEPTH_TO_COLOR_IMPL_H
+#define D2C_DEPTH_TO_COLOR_IMPL_H
+
+#include <string>
+#include <utility>
+#include <unordered_map>
+#include <memory>
+#include "libobsensor/h/ObTypes.h"
+
+#if(defined(__ARM_NEON__) || defined(__aarch64__) || defined(__arm__))
+#include "SSE2NEON.h"
+#else
+#include <xmmintrin.h>
+#include <smmintrin.h>
+#endif
+
+namespace libobsensor {
+
+#define EPSILON (1e-6)
+
+struct ResHashFunc {
+    size_t operator()(const std::pair<int, int> &p) const {
+        return (((uint32_t)p.first & 0xFFFF) << 16) | ((uint32_t)p.second & 0xFFFF);
+    }
+};
+
+struct ResComp {
+    bool operator()(const std::pair<int, int> &p1, const std::pair<int, int> &p2) const {
+        return p1.first == p2.first && p1.second == p2.second;
+    }
+};
+
+/**
+ * @brief Implementation of Alignment
+ */
+class AlignImpl {
+public:
+    AlignImpl();
+
+    ~AlignImpl();
+
+    /**
+     * @brief Load parameters and set up LUT
+     * @param[in] depth_intrin intrisics of depth frame
+     * @param[in] depth_disto distortion parameters of depth frame
+     * @param[in] rgb_intrin intrinsics of color frame
+     * @param[in] rgb_disto distortion parameters of color frame
+     * @param[in] depth_to_rgb rotation and translation from depth to color
+     * @param[in] depth_unit_mm depth scale in millimeter
+     * @param[in] add_target_distortion switch to add distortion of the target frame
+     * @param[in] gap_fill_copy switch to fill gaps with copy or nearest-interpolation after alignment
+     *
+     */
+    void initialize(OBCameraIntrinsic depth_intrin, OBCameraDistortion depth_disto, OBCameraIntrinsic rgb_intrin, OBCameraDistortion rgb_disto,
+                    OBExtrinsic depth_to_rgb, float depth_unit_mm, bool add_target_distortion, bool gap_fill_copy);
+
+    /**
+     * @brief Get depth unit in millimeter
+     *
+     * @return float depth scale in millimeter
+     */
+    float getDepthUnit() {
+        return depth_unit_mm_;
+    };
+
+    /**
+     * @brief Prepare LUTs of depth undistortion and rotation
+     */
+    void prepareDepthResolution();
+
+    /**
+     * @brief Clear buffer and de-initialize
+     */
+    void reset();
+
+    /**
+     * @brief       Align depth to color
+     * @param[in]       depth_buffer  data buffer of the depth frame in row-major order
+     * @param[in]       depth_width   width of the depth frame
+     * @param[in]       depth_height  height of the depth frame
+     * @param[out]  out_depth     aligned data buffer in row-major order
+     * @param[in]       color_width   width of the color frame
+     * @param[in]       color_height  height of the color frame
+     * @param[in]       map    coordinate mapping for C2D
+     * @param[in]       withSSE switch to speed up with SSE
+     * @retval  -1  fail
+     * @retval  0   succeed
+     */
+    int D2C(const uint16_t *depth_buffer, int depth_width, int depth_height, uint16_t *out_depth, int color_width, int color_height, int *map = nullptr,
+            bool withSSE = true);
+
+    /**
+     * @brief Align color to depth
+     * @param[in] depth_buffer data buffer of the depth frame in row-major order
+     * @param[in] depth_width  width of the depth frame
+     * @param[in] depth_height height of the depth frame
+     * @param[in] rgb_buffer   data buffer the to-align color frame
+     * @param[out] out_rgb      aligned data buffer of the color frame
+     * @param[in] color_width  width of the to-align color frame
+     * @param[in] color_height height of the to-align color frame
+     * @param[in] format       pixel format of the color fraem
+     * @retval -1 fail
+     * @retval 0 succeed
+     */
+    int C2D(const uint16_t *depth_buffer, int depth_width, int depth_height, const void *rgb_buffer, void *out_rgb, int color_width, int color_height,
+            OBFormat format, bool withSSE = true);
+
+private:
+    void clearMatrixCache();
+
+    void D2CWithoutSSE(const uint16_t *depth_buffer, uint16_t *out_depth, const float *coeff_x, const float *coeff_y, const float *coeff_z, int *map = nullptr);
+    void D2CWithSSE(const uint16_t *depth_buffer, uint16_t *out_depth, const float *coeff_x, const float *coeff_y, const float *coeff_z, int *map = nullptr);
+    /** SSE speed-ed depth to color alignment with different distortion model */
+    void distortedWithSSE(__m128 &nx, __m128 &ny, const __m128 x2, const __m128 y2, const __m128 r2);
+    void KBDistortedWithSSE(__m128 &nx, __m128 &ny, const __m128 r2);
+    void BMDistortedWithSSE(__m128 &nx, __m128 &ny, const __m128 x2, const __m128 y2, const __m128 r2);
+
+    void transferDepth(const float *pixelx, const float *pixely, const float *depth, const int npts, const int point_index, uint16_t *out_depth, int *map);
+
+    /**
+     * @brief               Transfer pixels of the source image buffer to the target
+     * @tparam T            pixel type, like uint8_t, uint16_t, etc.
+     * @param map           coordinate map of the same dimensions as the target
+     * @param src_buffer    the source image buffer
+     * @param src_width     columns of the source image
+     * @param src_height    rows of the source image
+     * @param dst_buffer    the target image buffer
+     * @param dst_width
+     */
+    template <typename T> void mapPixel(const int *map, const T *src_buffer, int src_width, int src_height, T *dst_buffer, int dst_width, int dst_height);
+
+private:
+    bool initialized_;
+
+    /** Linear/Distortion Rotation Coeff hash table */
+    std::unordered_map<std::pair<int, int>, float *, ResHashFunc, ResComp> rot_coeff_ht_x;
+    std::unordered_map<std::pair<int, int>, float *, ResHashFunc, ResComp> rot_coeff_ht_y;
+    std::unordered_map<std::pair<int, int>, float *, ResHashFunc, ResComp> rot_coeff_ht_z;
+
+    float              depth_unit_mm_;          // depth scale
+    bool               add_target_distortion_;  // distort align frame with target coefficent
+    bool               need_to_undistort_depth_;    // undistort depth is necessary
+    bool               gap_fill_copy_;          // filling cracks with copy
+    OBCameraIntrinsic  depth_intric_{};
+    OBCameraIntrinsic  rgb_intric_{};
+    OBCameraDistortion depth_disto_{};
+    OBCameraDistortion rgb_disto_{};
+    OBExtrinsic        transform_{};              // should be depth-to-rgb all the time
+    float              scaled_trans_[3] = { 0 };  // scaled translation
+
+    // possible inflection point of the calibrated K6 distortion curve
+    float r2_max_loc_;
+
+    // members for SSE
+    __m128 color_cx_;
+    __m128 color_cy_;
+    __m128 color_fx_;
+    __m128 color_fy_;
+    __m128 color_k1_;
+    __m128 color_k2_;
+    __m128 color_k3_;
+    __m128 color_k4_;
+    __m128 color_k5_;
+    __m128 color_k6_;
+    __m128 color_p1_;
+    __m128 color_p2_;
+    __m128 scaled_trans_1_;
+    __m128 scaled_trans_2_;
+    __m128 scaled_trans_3_;
+    __m128 r2_max_loc_sse_;
+
+    const static __m128  POINT_FIVE;
+    const static __m128  TWO;
+    const static __m128i ZERO;
+    const static __m128  ZERO_F;
+};
+
+#endif  // D2C_DEPTH_TO_COLOR_IMPL_H
+}  // namespace
+
diff --git a/src/filter/publicfilters/DecimationProcess.cpp b/src/filter/publicfilters/DecimationProcess.cpp
new file mode 100644
index 00000000..24444e98
--- /dev/null
+++ b/src/filter/publicfilters/DecimationProcess.cpp
@@ -0,0 +1,722 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "DecimationProcess.hpp"
+#include "exception/ObException.hpp"
+#include "logger/LoggerInterval.hpp"
+#include "frame/FrameFactory.hpp"
+#include "libobsensor/h/ObTypes.h"
+
+namespace libobsensor {
+
+#define SWAP(a, b)            \
+    {                         \
+        uint16_t temp = (a);  \
+        (a)           = (b);  \
+        (b)           = temp; \
+    }
+
+inline uint16_t median1(uint16_t arr[]) {
+    return arr[0];
+}
+
+inline uint16_t median2(uint16_t arr[]) {
+    if(arr[0] > arr[1])
+        SWAP(arr[0], arr[1]);
+    return arr[0];
+}
+
+inline uint16_t median3(uint16_t arr[]) {
+    if(arr[0] > arr[1])
+        SWAP(arr[0], arr[1]);
+    if(arr[1] > arr[2])
+        SWAP(arr[1], arr[2]);
+    if(arr[0] > arr[1])
+        SWAP(arr[0], arr[1]);
+    return arr[1];
+}
+
+inline uint16_t median4(uint16_t arr[]) {
+    if(arr[0] > arr[1])
+        SWAP(arr[0], arr[1]);
+    if(arr[2] > arr[3])
+        SWAP(arr[2], arr[3]);
+    if(arr[0] > arr[2])
+        SWAP(arr[0], arr[2]);
+    if(arr[1] > arr[3])
+        SWAP(arr[1], arr[3]);
+    if(arr[1] > arr[2])
+        SWAP(arr[1], arr[2]);
+    return arr[1];
+}
+
+inline uint16_t median5(uint16_t arr[]) {
+    if(arr[0] > arr[1])
+        SWAP(arr[0], arr[1]);
+    if(arr[3] > arr[4])
+        SWAP(arr[3], arr[4]);
+    if(arr[0] > arr[2])
+        SWAP(arr[0], arr[2]);
+    if(arr[1] > arr[2])
+        SWAP(arr[1], arr[2]);
+    if(arr[3] > arr[2])
+        SWAP(arr[3], arr[2]);
+    if(arr[4] > arr[2])
+        SWAP(arr[4], arr[2]);
+    if(arr[1] > arr[3])
+        SWAP(arr[1], arr[3]);
+    return arr[2];
+}
+
+inline uint16_t median6(uint16_t arr[]) {
+    if(arr[0] > arr[1])
+        SWAP(arr[0], arr[1]);
+    if(arr[2] > arr[3])
+        SWAP(arr[2], arr[3]);
+    if(arr[4] > arr[5])
+        SWAP(arr[4], arr[5]);
+    if(arr[0] > arr[2])
+        SWAP(arr[0], arr[2]);
+    if(arr[1] > arr[3])
+        SWAP(arr[1], arr[3]);
+    if(arr[2] > arr[4])
+        SWAP(arr[2], arr[4]);
+    if(arr[3] > arr[5])
+        SWAP(arr[3], arr[5]);
+    if(arr[1] > arr[4])
+        SWAP(arr[1], arr[4]);
+    if(arr[3] > arr[4])
+        SWAP(arr[3], arr[4]);
+    return arr[2];
+}
+
+inline uint16_t median7(uint16_t arr[]) {
+    if(arr[0] > arr[5])
+        SWAP(arr[0], arr[5]);
+    if(arr[0] > arr[3])
+        SWAP(arr[0], arr[3]);
+    if(arr[1] > arr[6])
+        SWAP(arr[1], arr[6]);
+    if(arr[2] > arr[4])
+        SWAP(arr[2], arr[4]);
+    if(arr[0] > arr[1])
+        SWAP(arr[0], arr[1]);
+    if(arr[3] > arr[5])
+        SWAP(arr[3], arr[5]);
+    if(arr[2] > arr[6])
+        SWAP(arr[2], arr[6]);
+    if(arr[2] > arr[3])
+        SWAP(arr[2], arr[3]);
+    if(arr[3] > arr[6])
+        SWAP(arr[3], arr[6]);
+    if(arr[4] > arr[5])
+        SWAP(arr[4], arr[5]);
+    if(arr[1] > arr[5])
+        SWAP(arr[1], arr[5]);
+    if(arr[1] > arr[3])
+        SWAP(arr[1], arr[3]);
+    if(arr[3] > arr[4])
+        SWAP(arr[3], arr[4]);
+    return arr[3];
+}
+
+inline uint16_t median8(uint16_t arr[]) {
+    if(arr[0] > arr[1])
+        SWAP(arr[0], arr[1]);
+    if(arr[2] > arr[3])
+        SWAP(arr[2], arr[3]);
+    if(arr[4] > arr[5])
+        SWAP(arr[4], arr[5]);
+    if(arr[6] > arr[7])
+        SWAP(arr[6], arr[7]);
+    if(arr[0] > arr[2])
+        SWAP(arr[0], arr[2]);
+    if(arr[1] > arr[3])
+        SWAP(arr[1], arr[3]);
+    if(arr[4] > arr[6])
+        SWAP(arr[4], arr[6]);
+    if(arr[5] > arr[7])
+        SWAP(arr[5], arr[7]);
+    if(arr[1] > arr[4])
+        SWAP(arr[1], arr[4]);
+    if(arr[3] > arr[6])
+        SWAP(arr[3], arr[6]);
+    if(arr[2] > arr[5])
+        SWAP(arr[2], arr[5]);
+    if(arr[3] > arr[4])
+        SWAP(arr[3], arr[4]);
+    if(arr[2] > arr[6])
+        SWAP(arr[2], arr[6]);
+    if(arr[1] > arr[3])
+        SWAP(arr[1], arr[3]);
+    if(arr[5] > arr[7])
+        SWAP(arr[5], arr[7]);
+    if(arr[3] > arr[5])
+        SWAP(arr[3], arr[5]);
+    if(arr[4] > arr[6])
+        SWAP(arr[4], arr[6]);
+    return arr[3];
+}
+
+inline uint16_t median9(uint16_t arr[]) {
+    if(arr[0] > arr[1])
+        SWAP(arr[0], arr[1]);
+    if(arr[3] > arr[4])
+        SWAP(arr[3], arr[4]);
+    if(arr[6] > arr[7])
+        SWAP(arr[6], arr[7]);
+    if(arr[1] > arr[2])
+        SWAP(arr[1], arr[2]);
+    if(arr[4] > arr[5])
+        SWAP(arr[4], arr[5]);
+    if(arr[7] > arr[8])
+        SWAP(arr[7], arr[8]);
+    if(arr[0] > arr[1])
+        SWAP(arr[0], arr[1]);
+    if(arr[3] > arr[4])
+        SWAP(arr[3], arr[4]);
+    if(arr[6] > arr[7])
+        SWAP(arr[6], arr[7]);
+    if(arr[1] > arr[2])
+        SWAP(arr[1], arr[2]);
+    if(arr[4] > arr[5])
+        SWAP(arr[4], arr[5]);
+    if(arr[7] > arr[8])
+        SWAP(arr[7], arr[8]);
+    arr[3] = arr[0] > arr[3] ? arr[0] : arr[3];
+    arr[5] = arr[5] > arr[8] ? arr[8] : arr[5];
+    if(arr[4] > arr[7])
+        SWAP(arr[4], arr[7]);
+    arr[6] = arr[3] > arr[6] ? arr[3] : arr[6];
+    arr[4] = arr[1] > arr[4] ? arr[1] : arr[4];
+    arr[2] = arr[2] > arr[5] ? arr[5] : arr[2];
+    arr[4] = arr[4] > arr[7] ? arr[7] : arr[4];
+    if(arr[4] > arr[2])
+        SWAP(arr[4], arr[2]);
+    arr[4] = arr[4] > arr[6] ? arr[6] : arr[4];
+    return arr[4];
+}
+
+typedef uint16_t (*MDFUNC)(uint16_t arr[]);
+// 0     1       2        3        4         5        6        7       8       9
+static MDFUNC _mdfunc[] = { 0, median1, median2, median3, median4, median5, median6, median7, median8, median9 };
+
+DecimationFilter::DecimationFilter()
+    : decimation_factor_(2),
+      control_val_(2),
+      patch_size_(2),
+      kernel_size_(patch_size_ * patch_size_),
+      real_width_(0),
+      real_height_(0),
+      padded_width_(0),
+      padded_height_(0),
+      recalc_profile_(false),
+      options_changed_(false) {}
+
+DecimationFilter::~DecimationFilter() noexcept {}
+
+void DecimationFilter::updateConfig(std::vector<std::string> &params) {
+    if(params.size() != 1) {
+        throw invalid_value_exception("DecimationFilter config error: params size not match");
+    }
+    try {
+        uint8_t value = static_cast<uint8_t>(std::stoul(params[0]));
+        if(value >= 1 && value <= 8) {
+            if(value != control_val_) {
+                control_val_       = value;
+                patch_size_        = control_val_;
+                decimation_factor_ = control_val_;
+                kernel_size_       = patch_size_ * patch_size_;
+                options_changed_   = true;
+            }
+        }
+    }
+    catch(const std::exception &e) {
+        throw invalid_value_exception("DecimationFilter config error: " + std::string(e.what()));
+    }
+}
+
+const std::string &DecimationFilter::getConfigSchema() const {
+    // csv format: name，type， min，max，step，default，description
+    static const std::string schema = "decimate, int, 1, 8, 1, 2, value decimate factor";
+    return schema;
+}
+
+void DecimationFilter::reset() {
+    options_changed_ = true;
+    registered_profiles_.clear();
+    source_stream_profile_.reset();
+    target_stream_profile_.reset();
+}
+
+std::shared_ptr<Frame> DecimationFilter::process(std::shared_ptr<const Frame> frame) {
+    if(!frame) {
+        return nullptr;
+    }
+
+    if(frame->is<FrameSet>()) {
+        LOG_WARN_INTVL("The Frame processed by DecimationFilter cannot be FrameSet!");
+        auto outFrame = FrameFactory::createFrameFromOtherFrame(frame, true);
+        return outFrame;
+    }
+
+    if(!isFrameFormatTypeSupported(frame->getFormat())) {
+        LOG_WARN_INTVL("Unsupported decimation filter processing frame format @{}.", frame->getFormat());
+        auto outFrame = FrameFactory::createFrameFromOtherFrame(frame, true);
+        return outFrame;
+    }
+
+    updateOutputProfile(frame);
+
+    OBFormat frameFormat = frame->getFormat();
+    auto     newOutFrame = FrameFactory::createFrameFromStreamProfile(target_stream_profile_);
+
+    newOutFrame->copyInfoFromOther(frame);
+    auto srcVideosFrame = frame->as<VideoFrame>();
+    auto newVideoFrame  = newOutFrame->as<VideoFrame>();
+    if(frame->getType() == OB_FRAME_DEPTH && (frameFormat == OB_FORMAT_Y16 || frameFormat == OB_FORMAT_Z16)) {
+        decimateDepth((uint16_t *)frame->getData(), (uint16_t *)newVideoFrame->getData(), srcVideosFrame->getWidth(), patch_size_);
+    }
+    else {
+        decimateOthers(frameFormat, (void *)frame->getData(), (void *)newVideoFrame->getData(), srcVideosFrame->getWidth(), patch_size_);
+    }
+
+    return newOutFrame;
+}
+
+bool DecimationFilter::isFrameFormatTypeSupported(OBFormat type) {
+    switch(type) {
+    case OB_FORMAT_Y16:
+    case OB_FORMAT_Z16:
+    case OB_FORMAT_Y8:
+    case OB_FORMAT_YUYV:
+    case OB_FORMAT_UYVY:
+    case OB_FORMAT_RGB:
+    case OB_FORMAT_BGR:
+    case OB_FORMAT_RGBA:
+    case OB_FORMAT_BGRA:
+        return true;
+    default:
+        break;
+    }
+
+    return false;
+}
+
+void DecimationFilter::updateOutputProfile(const std::shared_ptr<const Frame> frame) {
+    auto streamProfile = frame->getStreamProfile();
+    if(options_changed_ || streamProfile.get() != source_stream_profile_.get()) {
+        options_changed_       = false;
+        source_stream_profile_ = streamProfile->as<VideoStreamProfile>();
+        const auto pf          = registered_profiles_.find(std::make_tuple(source_stream_profile_.get(), decimation_factor_));
+        if(registered_profiles_.end() != pf) {
+            target_stream_profile_ = pf->second;
+
+            // Update real/padded output frame size based on retrieved input properties
+            real_width_    = (uint16_t)source_stream_profile_->getWidth() / patch_size_;
+            real_height_   = (uint16_t)source_stream_profile_->getHeight() / patch_size_;
+            padded_width_  = (uint16_t)target_stream_profile_->getWidth();
+            padded_height_ = (uint16_t)target_stream_profile_->getHeight();
+        }
+        else {
+            recalc_profile_ = true;
+        }
+    }
+
+    // Build a new target profile for every system/filter change
+    if(recalc_profile_) {
+        auto source_vsp = source_stream_profile_->as<VideoStreamProfile>();
+
+        // recalculate real/padded output frame size based on new input porperties
+        real_width_  = (uint16_t)source_vsp->getWidth() / patch_size_;
+        real_height_ = (uint16_t)source_vsp->getHeight() / patch_size_;
+
+        // The resulted frame dimension will be dividable by 4;
+        padded_width_ = real_width_ + 3;
+        padded_width_ /= 4;
+        padded_width_ *= 4;
+
+        padded_height_ = real_height_ + 3;
+        padded_height_ /= 4;
+        padded_height_ *= 4;
+
+        auto intrinsic   = source_vsp->getIntrinsic();
+        intrinsic.width  = padded_width_;
+        intrinsic.height = padded_height_;
+        intrinsic.fx     = intrinsic.fx / patch_size_;
+        intrinsic.fy     = intrinsic.fy / patch_size_;
+        intrinsic.cx     = intrinsic.cx / patch_size_;
+        intrinsic.cy     = intrinsic.cy / patch_size_;
+
+        target_stream_profile_ = source_vsp->clone()->as<VideoStreamProfile>();
+        target_stream_profile_->setWidth(padded_width_);
+        target_stream_profile_->setHeight(padded_height_);
+        // extrinsic and distortion parameters remain unchanged.
+        target_stream_profile_->bindIntrinsic(intrinsic);
+
+        registered_profiles_[std::make_tuple(source_stream_profile_.get(), decimation_factor_)] = target_stream_profile_;
+
+        recalc_profile_ = false;
+    }
+}
+
+void DecimationFilter::decimateDepth(uint16_t *frame_data_in, uint16_t *frame_data_out, size_t width_in, size_t scale) {
+
+    // construct internal register buf
+    uint16_t  working_kernel[9];
+    uint16_t *pixel_raws[10];  // max scale set 10
+    uint16_t *block_start = const_cast<uint16_t *>(frame_data_in);
+    uint16_t *p{};
+    int       wk_count = 0;
+    int       wk_sum   = 0;
+    MDFUNC    f;
+
+    if(scale == 2 || scale == 3) {
+        // loop through rows
+        for(int j = 0; j < real_height_; j++) {
+
+            for(size_t i = 0; i < scale; i++) {
+                pixel_raws[i] = block_start + (width_in * i);
+                //__builtin_prefetch(pixel_raws[i] + (width_in * scale), 0, 3);
+            }
+
+            // processing row-wisely
+            for(size_t i = 0, chunk_offset = 0; i < real_width_; i++, chunk_offset += scale) {
+                wk_count = 0;
+                // processing kernel
+                for(size_t n = 0; n < scale; ++n) {
+                    p = pixel_raws[n] + chunk_offset;
+                    for(size_t m = 0; m < scale; ++m) {
+                        if(*(p + m)) {
+                            working_kernel[wk_count] = *(p + m);
+                            wk_count++;
+                        }
+                    }
+                }
+
+                if(wk_count == 0)
+                    *frame_data_out++ = 0;
+                else {
+                    f                 = _mdfunc[wk_count];
+                    *frame_data_out++ = f(working_kernel);
+                }
+            }
+
+            // filling right side blanks
+            for(int k = real_width_; k < padded_width_; k++)
+                *frame_data_out++ = 0;
+
+            // move to the start position of next processing block
+            block_start += width_in * scale;
+        }
+    }
+    else {
+
+        for(int j = 0; j < real_height_; j++) {
+
+            for(size_t i = 0; i < scale; i++) {
+                pixel_raws[i] = block_start + (width_in * i);
+            }
+
+            for(size_t i = 0, chunk_offset = 0; i < real_width_; i++, chunk_offset += scale) {
+                wk_sum   = 0;
+                wk_count = 0;
+                for(size_t n = 0; n < scale; ++n) {
+                    p = pixel_raws[n] + chunk_offset;
+                    for(size_t m = 0; m < scale; ++m) {
+                        if(*(p + m)) {
+                            wk_sum += p[m];
+                            ++wk_count;
+                        }
+                    }
+                }
+
+                *frame_data_out++ = (uint16_t)(wk_count == 0 ? 0 : wk_sum / wk_count);
+            }
+
+            for(int k = real_width_; k < padded_width_; k++)
+                *frame_data_out++ = 0;
+
+            block_start += width_in * scale;
+        }
+    }
+    memset(frame_data_out, 0, (padded_height_ - real_height_) * padded_width_ * sizeof(uint16_t));
+}
+
+void DecimationFilter::decimateOthers(OBFormat format, void *frame_data_in, void *frame_data_out, size_t width_in, size_t scale) {
+
+    auto patch_size = scale * scale;
+
+    int wk_sum = 0;
+    // int wk_count = 0;
+
+    switch(format) {
+    case OB_FORMAT_YUYV: {
+        uint8_t *from = (uint8_t *)frame_data_in;
+        uint8_t *p    = nullptr;
+        uint8_t *q    = (uint8_t *)frame_data_out;
+
+        auto w_2  = width_in >> 1;
+        auto rw_2 = real_width_ >> 1;
+        auto pw_2 = padded_width_ >> 1;
+        auto s2   = scale >> 1;
+        bool odd  = (scale & 1);
+        for(int j = 0; j < real_height_; ++j) {
+            for(int i = 0; i < rw_2; ++i) {
+                p      = from + scale * (j * w_2 + i) * 4;
+                wk_sum = 0;
+                for(size_t n = 0; n < scale; ++n) {
+                    for(size_t m = 0; m < scale; ++m)
+                        wk_sum += p[m * 2];
+
+                    p += w_2 * 4;
+                }
+                *q++ = (uint8_t)(wk_sum / patch_size);
+
+                p      = from + scale * (j * w_2 + i) * 4 + 1;
+                wk_sum = 0;
+                for(size_t n = 0; n < scale; ++n) {
+                    for(size_t m = 0; m < s2; ++m)
+                        wk_sum += 2 * p[m * 4];
+
+                    if(odd)
+                        wk_sum += p[s2 * 4];
+
+                    p += w_2 * 4;
+                }
+                *q++ = (uint8_t)(wk_sum / patch_size);
+
+                p      = from + scale * (j * w_2 + i) * 4 + s2 * 4 + (odd ? 2 : 0);
+                wk_sum = 0;
+                for(size_t n = 0; n < scale; ++n) {
+                    for(size_t m = 0; m < scale; ++m)
+                        wk_sum += p[m * 2];
+
+                    p += w_2 * 4;
+                }
+                *q++ = (uint8_t)(wk_sum / patch_size);
+
+                p      = from + scale * (j * w_2 + i) * 4 + 3;
+                wk_sum = 0;
+                for(size_t n = 0; n < scale; ++n) {
+                    for(size_t m = 0; m < s2; ++m)
+                        wk_sum += 2 * p[m * 4];
+
+                    if(odd)
+                        wk_sum += p[s2 * 4];
+
+                    p += w_2 * 4;
+                }
+                *q++ = (uint8_t)(wk_sum / patch_size);
+            }
+
+            for(int i = rw_2; i < pw_2; ++i) {
+                *q++ = 0;
+                *q++ = 0;
+                *q++ = 0;
+                *q++ = 0;
+            }
+        }
+
+        memset(q, 0, (padded_height_ - real_height_) * padded_width_ * sizeof(uint8_t) * 2);
+    } break;
+
+    case OB_FORMAT_UYVY: {
+        uint8_t *from = (uint8_t *)frame_data_in;
+        uint8_t *p    = nullptr;
+        uint8_t *q    = (uint8_t *)frame_data_out;
+
+        auto w_2  = width_in >> 1;
+        auto rw_2 = real_width_ >> 1;
+        auto pw_2 = padded_width_ >> 1;
+        auto s2   = scale >> 1;
+        bool odd  = (scale & 1);
+        for(int j = 0; j < real_height_; ++j) {
+            for(int i = 0; i < rw_2; ++i) {
+                p      = from + scale * (j * w_2 + i) * 4;
+                wk_sum = 0;
+                for(size_t n = 0; n < scale; ++n) {
+                    for(size_t m = 0; m < s2; ++m)
+                        wk_sum += 2 * p[m * 4];
+
+                    if(odd)
+                        wk_sum += p[s2 * 4];
+
+                    p += w_2 * 4;
+                }
+                *q++ = (uint8_t)(wk_sum / patch_size);
+
+                p      = from + scale * (j * w_2 + i) * 4 + 1;
+                wk_sum = 0;
+                for(size_t n = 0; n < scale; ++n) {
+                    for(size_t m = 0; m < scale; ++m)
+                        wk_sum += p[m * 2];
+
+                    p += w_2 * 4;
+                }
+                *q++ = (uint8_t)(wk_sum / patch_size);
+
+                p      = from + scale * (j * w_2 + i) * 4 + 2;
+                wk_sum = 0;
+                for(size_t n = 0; n < scale; ++n) {
+                    for(size_t m = 0; m < s2; ++m)
+                        wk_sum += 2 * p[m * 4];
+
+                    if(odd)
+                        wk_sum += p[s2 * 4];
+
+                    p += w_2 * 4;
+                }
+                *q++ = (uint8_t)(wk_sum / patch_size);
+
+                p      = from + scale * (j * w_2 + i) * 4 + s2 * 4 + (odd ? 3 : 1);
+                wk_sum = 0;
+                for(size_t n = 0; n < scale; ++n) {
+                    for(size_t m = 0; m < scale; ++m)
+                        wk_sum += p[m * 2];
+
+                    p += w_2 * 4;
+                }
+                *q++ = (uint8_t)(wk_sum / patch_size);
+            }
+
+            for(int i = rw_2; i < pw_2; ++i) {
+                *q++ = 0;
+                *q++ = 0;
+                *q++ = 0;
+                *q++ = 0;
+            }
+        }
+
+        memset(q, 0, (padded_height_ - real_height_) * padded_width_ * sizeof(uint8_t) * 2);
+    } break;
+
+    case OB_FORMAT_RGB:
+    case OB_FORMAT_BGR: {
+        uint8_t *from = (uint8_t *)frame_data_in;
+        uint8_t *p    = nullptr;
+        uint8_t *q    = (uint8_t *)frame_data_out;
+        ;
+
+        for(int j = 0; j < real_height_; ++j) {
+            for(int i = 0; i < real_width_; ++i) {
+                for(int k = 0; k < 3; ++k) {
+                    p      = from + scale * (j * width_in + i) * 3 + k;
+                    wk_sum = 0;
+                    for(size_t n = 0; n < scale; ++n) {
+                        for(size_t m = 0; m < scale; ++m)
+                            wk_sum += p[m * 3];
+
+                        p += width_in * 3;
+                    }
+
+                    *q++ = (uint8_t)(wk_sum / patch_size);
+                }
+            }
+
+            for(int i = real_width_; i < padded_width_; ++i) {
+                *q++ = 0;
+                *q++ = 0;
+                *q++ = 0;
+            }
+        }
+
+        memset(q, 0, (padded_height_ - real_height_) * padded_width_ * sizeof(uint8_t) * 3);
+    } break;
+
+    case OB_FORMAT_RGBA:
+    case OB_FORMAT_BGRA: {
+        uint8_t *from = (uint8_t *)frame_data_in;
+        uint8_t *p    = nullptr;
+        uint8_t *q    = (uint8_t *)frame_data_out;
+
+        for(int j = 0; j < real_height_; ++j) {
+            for(int i = 0; i < real_width_; ++i) {
+                for(int k = 0; k < 4; ++k) {
+                    p      = from + scale * (j * width_in + i) * 4 + k;
+                    wk_sum = 0;
+                    for(size_t n = 0; n < scale; ++n) {
+                        for(size_t m = 0; m < scale; ++m)
+                            wk_sum += p[m * 4];
+
+                        p += width_in * 4;
+                    }
+
+                    *q++ = (uint8_t)(wk_sum / patch_size);
+                }
+            }
+
+            for(int i = real_width_; i < padded_width_; ++i) {
+                *q++ = 0;
+                *q++ = 0;
+                *q++ = 0;
+                *q++ = 0;
+            }
+        }
+
+        memset(q, 0, (padded_height_ - real_height_) * padded_width_ * sizeof(uint8_t) * 4);
+
+    } break;
+
+    case OB_FORMAT_Y8: {
+        uint8_t *from = (uint8_t *)frame_data_in;
+        uint8_t *p    = nullptr;
+        uint8_t *q    = (uint8_t *)frame_data_out;
+
+        for(int j = 0; j < real_height_; ++j) {
+            for(int i = 0; i < real_width_; ++i) {
+                p      = from + scale * (j * width_in + i);
+                wk_sum = 0;
+                for(size_t n = 0; n < scale; ++n) {
+                    for(size_t m = 0; m < scale; ++m) {
+                        wk_sum += p[m];
+                    }
+
+                    p += width_in;
+                }
+
+                *q++ = (uint8_t)(wk_sum / patch_size);
+            }
+
+            for(int i = real_width_; i < padded_width_; ++i)
+                *q++ = 0;
+        }
+
+        memset(q, 0, (padded_height_ - real_height_) * padded_width_ * sizeof(uint8_t));
+
+    } break;
+
+    case OB_FORMAT_Y16: {
+        uint16_t *from = (uint16_t *)frame_data_in;
+        uint16_t *p    = nullptr;
+        uint16_t *q    = (uint16_t *)frame_data_out;
+
+        for(int j = 0; j < real_height_; ++j) {
+            for(int i = 0; i < real_width_; ++i) {
+                p      = from + scale * (j * width_in + i);
+                wk_sum = 0;
+                for(size_t n = 0; n < scale; ++n) {
+                    for(size_t m = 0; m < scale; ++m) {
+                        wk_sum += p[m];
+                    }
+                    p += width_in;
+                }
+
+                *q++ = (uint16_t)(wk_sum / patch_size);
+            }
+
+            for(int i = real_width_; i < padded_width_; ++i)
+                *q++ = 0;
+        }
+
+        memset(q, 0, (padded_height_ - real_height_) * padded_width_ * sizeof(uint16_t));
+
+    } break;
+
+    default:
+        break;
+    }
+}
+
+}  // namespace libobsensor
+
diff --git a/src/filter/publicfilters/DecimationProcess.hpp b/src/filter/publicfilters/DecimationProcess.hpp
new file mode 100644
index 00000000..dbf7276d
--- /dev/null
+++ b/src/filter/publicfilters/DecimationProcess.hpp
@@ -0,0 +1,48 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include "IFilter.hpp"
+#include "stream/StreamProfile.hpp"
+#include <mutex>
+#include <map>
+#include <tuple>
+
+namespace libobsensor {
+
+class DecimationFilter : public IFilterBase {
+public:
+    DecimationFilter();
+    virtual ~DecimationFilter() noexcept;
+
+    void               updateConfig(std::vector<std::string> &params) override;
+    const std::string &getConfigSchema() const override;
+    void               reset() override;
+
+private:
+    std::shared_ptr<Frame> process(std::shared_ptr<const Frame> frame) override;
+
+    bool isFrameFormatTypeSupported(OBFormat type);
+    void updateOutputProfile(const std::shared_ptr<const Frame> frame);
+    void decimateDepth(uint16_t *frame_data_in, uint16_t *frame_data_out, size_t width_in, size_t scale);
+    void decimateOthers(OBFormat format, void *frame_data_in, void *frame_data_out, size_t width_in, size_t scale);
+
+protected:
+    std::map<std::tuple<const VideoStreamProfile *, uint8_t>, std::shared_ptr<VideoStreamProfile>> registered_profiles_;
+    std::shared_ptr<const VideoStreamProfile>                                                      source_stream_profile_;
+    std::shared_ptr<VideoStreamProfile>                                                            target_stream_profile_;
+
+    uint8_t  decimation_factor_;
+    uint8_t  control_val_;
+    uint8_t  patch_size_;
+    uint8_t  kernel_size_;
+    uint16_t real_width_;    // Number of rows/columns with real datain the decimated image
+    uint16_t real_height_;   // Correspond to w,h in the reference code
+    uint16_t padded_width_;  // Corresponds to w4/h4 in the reference code
+    uint16_t padded_height_;
+    bool     recalc_profile_;
+    bool     options_changed_;  // Tracking changes imposed by user
+};
+
+}  // namespace libobsensor
+
diff --git a/src/filter/publicfilters/FormatConverterProcess.cpp b/src/filter/publicfilters/FormatConverterProcess.cpp
new file mode 100644
index 00000000..6461629a
--- /dev/null
+++ b/src/filter/publicfilters/FormatConverterProcess.cpp
@@ -0,0 +1,397 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "FormatConverterProcess.hpp"
+#include "exception/ObException.hpp"
+#include "logger/LoggerInterval.hpp"
+#include "frame/FrameFactory.hpp"
+#include "frame/FrameMemoryPool.hpp"
+#include "stream/StreamProfile.hpp"
+#include "libobsensor/h/ObTypes.h"
+#include <libyuv.h>
+#include <turbojpeg.h>
+
+namespace libobsensor {
+
+FormatConverter::FormatConverter() : convertType_(FORMAT_YUYV_TO_RGB) {}
+FormatConverter::~FormatConverter() noexcept {}
+
+void FormatConverter::updateConfig(std::vector<std::string> &params) {
+    if(params.size() != 1) {
+        throw invalid_value_exception("FormatConverter config error: params size not match");
+    }
+    try {
+        int convertType = std::stoi(params[0]);
+        convertType_    = (OBConvertFormat)convertType;
+    }
+    catch(const std::exception &e) {
+        throw invalid_value_exception("FormatConverter config error: " + std::string(e.what()));
+    }
+}
+
+const std::string &FormatConverter::getConfigSchema() const {
+    // csv format: name，type， min，max，step，default，description
+    static const std::string schema = "convertType, int, 0, 17, 1, 0, frame data converter type";
+    return schema;
+}
+
+void FormatConverter::reset() {
+    currentStreamProfile_.reset();
+    tarStreamProfile_.reset();
+}
+
+const std::map<OBConvertFormat, std::pair<OBFormat, OBFormat>> FORMAT_CONVERT_MAP = {
+    { FORMAT_YUYV_TO_RGB, { OB_FORMAT_YUYV, OB_FORMAT_RGB } },   { FORMAT_I420_TO_RGB, { OB_FORMAT_I420, OB_FORMAT_RGB } },
+    { FORMAT_NV21_TO_RGB, { OB_FORMAT_NV21, OB_FORMAT_RGB } },   { FORMAT_NV12_TO_RGB, { OB_FORMAT_NV12, OB_FORMAT_RGB } },
+    { FORMAT_MJPG_TO_I420, { OB_FORMAT_MJPG, OB_FORMAT_I420 } }, { FORMAT_RGB_TO_BGR, { OB_FORMAT_RGB, OB_FORMAT_BGR } },
+    { FORMAT_MJPG_TO_NV21, { OB_FORMAT_MJPG, OB_FORMAT_NV21 } }, { FORMAT_MJPG_TO_RGB, { OB_FORMAT_MJPG, OB_FORMAT_RGB } },
+    { FORMAT_MJPG_TO_BGR, { OB_FORMAT_MJPG, OB_FORMAT_BGR } },   { FORMAT_MJPG_TO_BGRA, { OB_FORMAT_MJPG, OB_FORMAT_BGRA } },
+    { FORMAT_UYVY_TO_RGB, { OB_FORMAT_UYVY, OB_FORMAT_RGB } },   { FORMAT_BGR_TO_RGB, { OB_FORMAT_BGR, OB_FORMAT_RGB } },
+    { FORMAT_MJPG_TO_NV12, { OB_FORMAT_MJPG, OB_FORMAT_NV12 } }, { FORMAT_YUYV_TO_BGR, { OB_FORMAT_YUYV, OB_FORMAT_BGR } },
+    { FORMAT_YUYV_TO_RGBA, { OB_FORMAT_YUYV, OB_FORMAT_RGBA } }, { FORMAT_YUYV_TO_BGRA, { OB_FORMAT_YUYV, OB_FORMAT_BGRA } },
+    { FORMAT_YUYV_TO_Y16, { OB_FORMAT_YUYV, OB_FORMAT_Y16 } },   { FORMAT_YUYV_TO_Y8, { OB_FORMAT_YUYV, OB_FORMAT_Y8 } },
+};
+
+void FormatConverter::setConversion(OBFormat srcFormat, OBFormat dstFormat) {
+    for(auto &item: FORMAT_CONVERT_MAP) {
+        if(item.second.first == srcFormat && item.second.second == dstFormat) {
+            convertType_ = item.first;
+            currentStreamProfile_.reset();
+            tarStreamProfile_.reset();
+            return;
+        }
+    }
+    throw invalid_value_exception("FormatConverter config error: invalid format conversion");
+}
+
+std::shared_ptr<Frame> FormatConverter::process(std::shared_ptr<const Frame> frame) {
+    if(!frame) {
+        return nullptr;
+    }
+
+    auto videoFrame = frame->as<VideoFrame>();
+    int  w          = videoFrame->getWidth();
+    int  h          = videoFrame->getHeight();
+
+    auto streamprofile = frame->getStreamProfile();
+    if(!currentStreamProfile_ || currentStreamProfile_.get() != streamprofile.get()) {
+        currentStreamProfile_ = streamprofile;
+        tarStreamProfile_     = streamprofile->clone();
+        if(FORMAT_CONVERT_MAP.find(convertType_) == FORMAT_CONVERT_MAP.end()) {
+            auto srcFormat = streamprofile->getFormat();
+            auto dstFormat = OB_FORMAT_RGB;
+            for(auto &item: FORMAT_CONVERT_MAP) {
+                if(item.second.first == srcFormat) {
+                    dstFormat = item.second.second;
+                    tarStreamProfile_->setFormat(dstFormat);
+                    break;
+                }
+            }
+        }
+        else {
+            tarStreamProfile_->setFormat(FORMAT_CONVERT_MAP.at(convertType_).second);
+        }
+    }
+
+    auto tarFrame = FrameFactory::createFrameFromStreamProfile(tarStreamProfile_);
+    if(tarFrame == nullptr) {
+        LOG_ERROR_INTVL("Create frame by frame factory failed!");
+        return nullptr;
+    }
+
+    tarFrame->copyInfoFromOther(frame);
+    switch(convertType_) {
+    case FORMAT_YUYV_TO_RGB:
+        yuyvToRgb((uint8_t *)frame->getData(), (uint8_t *)tarFrame->getData(), w, h);
+        break;
+    case FORMAT_YUYV_TO_RGBA:
+        yuyvToRgba((uint8_t *)frame->getData(), (uint8_t *)tarFrame->getData(), w, h);
+        break;
+    case FORMAT_YUYV_TO_BGR:
+        yuyvToBgr((uint8_t *)frame->getData(), (uint8_t *)tarFrame->getData(), w, h);
+        break;
+    case FORMAT_YUYV_TO_BGRA:
+        yuyvToBgra((uint8_t *)frame->getData(), (uint8_t *)tarFrame->getData(), w, h);
+        break;
+    case FORMAT_YUYV_TO_Y16:
+        yuyvToy16((uint8_t *)frame->getData(), (uint8_t *)tarFrame->getData(), w, h);
+        break;
+    case FORMAT_YUYV_TO_Y8:
+        yuyvToy8((uint8_t *)frame->getData(), (uint8_t *)tarFrame->getData(), w, h);
+        break;
+    case FORMAT_UYVY_TO_RGB:
+        uyvyToRgb((uint8_t *)frame->getData(), (uint8_t *)tarFrame->getData(), w, h);
+        break;
+    case FORMAT_I420_TO_RGB:
+        i420ToRgb((uint8_t *)frame->getData(), (uint8_t *)tarFrame->getData(), w, h);
+        break;
+    case FORMAT_NV21_TO_RGB:
+        nv21ToRgb((uint8_t *)frame->getData(), (uint8_t *)tarFrame->getData(), w, h);
+        break;
+    case FORMAT_NV12_TO_RGB:
+        nv12ToRgb((uint8_t *)frame->getData(), (uint8_t *)tarFrame->getData(), w, h);
+        break;
+    case FORMAT_MJPG_TO_I420:
+        mjpgToI420((uint8_t *)frame->getData(), (uint32_t)frame->getDataSize(), (uint8_t *)tarFrame->getData(), w, h);
+        break;
+    case FORMAT_RGB_TO_BGR:
+        exchangeRAndB((uint8_t *)frame->getData(), (uint8_t *)tarFrame->getData(), w, h);
+        break;
+    case FORMAT_BGR_TO_RGB:
+        exchangeRAndB((uint8_t *)frame->getData(), (uint8_t *)tarFrame->getData(), w, h);
+        break;
+    case FORMAT_MJPG_TO_NV21:
+        mjpgToNv21((uint8_t *)frame->getData(), (uint32_t)frame->getDataSize(), (uint8_t *)tarFrame->getData(), w, h);
+        break;
+    case FORMAT_MJPG_TO_RGB:
+        if(!mjpgToRgb((uint8_t *)frame->getData(), (uint32_t)frame->getDataSize(), (uint8_t *)tarFrame->getData(), w, h))
+            return nullptr;
+        break;
+    case FORMAT_MJPG_TO_BGR:
+        mjpgToBgr((uint8_t *)frame->getData(), (uint32_t)frame->getDataSize(), (uint8_t *)tarFrame->getData(), w, h);
+        break;
+    case FORMAT_MJPG_TO_BGRA:
+        mjpegToBgra((uint8_t *)frame->getData(), (uint32_t)frame->getDataSize(), (uint8_t *)tarFrame->getData(), w, h);
+        break;
+    case FORMAT_MJPG_TO_NV12:
+        mjpgToNv12((uint8_t *)frame->getData(), (uint32_t)frame->getDataSize(), (uint8_t *)tarFrame->getData(), w, h);
+        break;
+    default:
+        LOG_WARN_INTVL("Unsupported data format conversion.");
+        return FrameFactory::createFrameFromOtherFrame(frame, true);
+        break;
+    }
+    return tarFrame;
+}
+
+void FormatConverter::yuyvToRgb(uint8_t *src, uint8_t *target, uint32_t width, uint32_t height) {
+    const auto preferSize = width * height * 3 / 2;
+    if(tempDataBuf_ == nullptr || preferSize != tempDataBufSize_) {
+        if(nullptr != tempDataBuf_) {
+            delete[] tempDataBuf_;
+        }
+        tempDataBuf_     = new uint8_t[preferSize];
+        tempDataBufSize_ = preferSize;
+    }
+    uint8_t *yData = tempDataBuf_;
+    uint8_t *uData = tempDataBuf_ + width * height;
+    uint8_t *vData = tempDataBuf_ + width * height * 5 / 4;
+    libyuv::YUY2ToI420(src, width * 2, yData, width, uData, width / 2, vData, width / 2, width, height);
+    libyuv::I420ToRAW(yData, width, uData, width / 2, vData, width / 2, target, width * 3, width, height);
+}
+
+void FormatConverter::yuyvToRgba(uint8_t *src, uint8_t *target, uint32_t width, uint32_t height) {
+    const auto preferSize = width * height * 4;
+    if(tempDataBuf_ == nullptr || preferSize != tempDataBufSize_) {
+        if(nullptr != tempDataBuf_) {
+            delete[] tempDataBuf_;
+        }
+        tempDataBuf_     = new uint8_t[preferSize];
+        tempDataBufSize_ = preferSize;
+    }
+    uint8_t *yData = tempDataBuf_;
+    uint8_t *uData = tempDataBuf_ + width * height;
+    uint8_t *vData = tempDataBuf_ + width * height * 5 / 4;
+    libyuv::YUY2ToI420(src, width * 2, yData, width, uData, width / 2, vData, width / 2, width, height);
+    libyuv::I420ToABGR(yData, width, uData, width / 2, vData, width / 2, target, width * 4, width, height);
+}
+
+void FormatConverter::yuyvToBgr(uint8_t *src, uint8_t *target, uint32_t width, uint32_t height) {
+    const auto preferSize = width * height * 3 / 2;
+    if(tempDataBuf_ == nullptr || preferSize != tempDataBufSize_) {
+        if(nullptr != tempDataBuf_) {
+            delete[] tempDataBuf_;
+        }
+        tempDataBuf_     = new uint8_t[preferSize];
+        tempDataBufSize_ = preferSize;
+    }
+    uint8_t *yData = tempDataBuf_;
+    uint8_t *uData = tempDataBuf_ + width * height;
+    uint8_t *vData = tempDataBuf_ + width * height * 5 / 4;
+    libyuv::YUY2ToI420(src, width * 2, yData, width, uData, width / 2, vData, width / 2, width, height);
+    libyuv::I420ToRGB24(yData, width, uData, width / 2, vData, width / 2, target, width * 3, width, height);
+}
+
+void FormatConverter::yuyvToBgra(uint8_t *src, uint8_t *target, uint32_t width, uint32_t height) {
+    const auto preferSize = width * height * 4;
+    if(tempDataBuf_ == nullptr || preferSize != tempDataBufSize_) {
+        if(nullptr != tempDataBuf_) {
+            delete[] tempDataBuf_;
+        }
+        tempDataBuf_     = new uint8_t[preferSize];
+        tempDataBufSize_ = preferSize;
+    }
+    uint8_t *yData = tempDataBuf_;
+    uint8_t *uData = tempDataBuf_ + width * height;
+    uint8_t *vData = tempDataBuf_ + width * height * 5 / 4;
+    libyuv::YUY2ToI420(src, width * 2, yData, width, uData, width / 2, vData, width / 2, width, height);
+    libyuv::I420ToARGB(yData, width, uData, width / 2, vData, width / 2, target, width * 4, width, height);
+}
+
+void FormatConverter::yuyvToy16(uint8_t *src, uint8_t *target, uint32_t width, uint32_t height) {
+    auto size = width * height;
+    for(uint32_t i = 0; i < size; i += 16) {
+        uint8_t tarArray[32] = {
+            0, src[i * 2],      0, src[i * 2 + 2],  0, src[i * 2 + 4],  0, src[i * 2 + 6],  0, src[i * 2 + 8],  0, src[i * 2 + 10],
+            0, src[i * 2 + 12], 0, src[i * 2 + 14], 0, src[i * 2 + 16], 0, src[i * 2 + 18], 0, src[i * 2 + 20], 0, src[i * 2 + 22],
+            0, src[i * 2 + 24], 0, src[i * 2 + 26], 0, src[i * 2 + 28], 0, src[i * 2 + 30],
+        };
+        memcpy(target + i * 2, tarArray, 32);
+    }
+}
+
+void FormatConverter::yuyvToy8(uint8_t *src, uint8_t *target, uint32_t width, uint32_t height) {
+    auto size = width * height;
+    for(uint32_t i = 0; i < size; i += 16) {
+        target[i]      = src[i * 2];
+        target[i + 1]  = src[i * 2 + 2];
+        target[i + 2]  = src[i * 2 + 4];
+        target[i + 3]  = src[i * 2 + 6];
+        target[i + 4]  = src[i * 2 + 8];
+        target[i + 5]  = src[i * 2 + 10];
+        target[i + 6]  = src[i * 2 + 12];
+        target[i + 7]  = src[i * 2 + 14];
+        target[i + 8]  = src[i * 2 + 16];
+        target[i + 9]  = src[i * 2 + 18];
+        target[i + 10] = src[i * 2 + 20];
+        target[i + 11] = src[i * 2 + 22];
+        target[i + 12] = src[i * 2 + 24];
+        target[i + 13] = src[i * 2 + 26];
+        target[i + 14] = src[i * 2 + 28];
+        target[i + 15] = src[i * 2 + 30];
+    }
+}
+
+void FormatConverter::uyvyToRgb(uint8_t *src, uint8_t *target, uint32_t width, uint32_t height) {
+    const auto preferSize = width * height * 3 / 2;
+    if(tempDataBuf_ == nullptr || preferSize != tempDataBufSize_) {
+        if(nullptr != tempDataBuf_) {
+            delete[] tempDataBuf_;
+        }
+        tempDataBuf_     = new uint8_t[preferSize];
+        tempDataBufSize_ = preferSize;
+    }
+    uint8_t *yData = tempDataBuf_;
+    uint8_t *uData = tempDataBuf_ + width * height;
+    uint8_t *vData = tempDataBuf_ + width * height * 5 / 4;
+    libyuv::UYVYToI420(src, width * 2, yData, width, uData, width / 2, vData, width / 2, width, height);
+    libyuv::I420ToRAW(yData, width, uData, width / 2, vData, width / 2, target, width * 3, width, height);
+}
+
+void FormatConverter::i420ToRgb(uint8_t *src, uint8_t *target, uint32_t width, uint32_t height) {
+    uint8_t *yData = src;
+    uint8_t *uData = src + width * height;
+    uint8_t *vData = src + width * height * 5 / 4;
+    libyuv::I420ToRAW(yData, width, uData, width / 2, vData, width / 2, target, width * 3, width, height);
+}
+
+void FormatConverter::nv21ToRgb(uint8_t *src, uint8_t *target, uint32_t width, uint32_t height) {
+    uint8_t *yData  = src;
+    uint8_t *vuData = src + width * height;
+    libyuv::NV21ToRAW(yData, width, vuData, width, target, width * 3, width, height);
+}
+
+void FormatConverter::nv12ToRgb(uint8_t *src, uint8_t *target, uint32_t width, uint32_t height) {
+    uint8_t *yData  = src;
+    uint8_t *vuData = src + width * height;
+    libyuv::NV12ToRAW(yData, width, vuData, width, target, width * 3, width, height);
+}
+
+void FormatConverter::mjpgToI420(uint8_t *src, uint32_t src_len, uint8_t *target, uint32_t width, uint32_t height) {
+    if(src == nullptr || target == nullptr) {
+        LOG_ERROR_INTVL("FormatConverter mjpegFrame is null or dstFrame is null");
+        return;
+    }
+
+    uint8_t *yData = target;
+    uint8_t *uData = target + width * height;
+    uint8_t *vData = target + width * height * 5 / 4;
+
+    int ret = libyuv::MJPGToI420(src, src_len, yData, width, uData, width / 2, vData, width / 2, width, height, width, height);
+    if(ret != 0) {
+        LOG_ERROR_INTVL("mjpeg to yuv error");
+    }
+}
+
+void FormatConverter::mjpgToNv21(uint8_t *src, uint32_t src_len, uint8_t *target, uint32_t width, uint32_t height) {
+    int ret;
+
+    uint8_t *yData  = target;
+    uint8_t *vuData = target + width * height;
+
+    ret = libyuv::MJPGToNV21(src, src_len, yData, width, vuData, width, width, height, width, height);
+    if(ret != 0) {
+        LOG_ERROR_INTVL("mjpeg to nv21 error");
+    }
+}
+
+void FormatConverter::mjpgToNv12(uint8_t *src, uint32_t src_len, uint8_t *target, uint32_t width, uint32_t height) {
+    int ret;
+
+    uint8_t *yData  = target;
+    uint8_t *vuData = target + width * height;
+
+    ret = libyuv::MJPGToNV12(src, src_len, yData, width, vuData, width, width, height, width, height);
+    if(ret != 0) {
+        LOG_ERROR_INTVL("mjpeg to nv12 error");
+    }
+}
+
+bool FormatConverter::mjpgToRgb(uint8_t *src, uint32_t src_len, uint8_t *target, uint32_t width, uint32_t height) {
+    tjhandle tjHandle;
+    tjHandle = tjInitDecompress();
+    if(tjDecompress2(tjHandle, src, src_len, target, width,
+                     0,  // pitch
+                     height, TJPF_RGB, TJFLAG_FASTDCT | TJFLAG_FASTUPSAMPLE)
+       != 0) {
+        LOG_WARN_INTVL("Failed to decode mjpeg frame to rgb! {}", tjGetErrorStr2(tjHandle));
+        tjDestroy(tjHandle);
+        return false;
+    }
+    tjDestroy(tjHandle);
+    return true;
+}
+
+bool FormatConverter::mjpgToBgr(uint8_t *src, uint32_t src_len, uint8_t *target, uint32_t width, uint32_t height) {
+    tjhandle tjHandle;
+    tjHandle = tjInitDecompress();
+    if(tjDecompress2(tjHandle, src, src_len, target, width,
+                     0,  // pitch
+                     height, TJPF_BGR, TJFLAG_FASTDCT | TJFLAG_FASTUPSAMPLE)
+       != 0) {
+        LOG_WARN_INTVL("Failed to decode mjpeg frame to bgr! {}", tjGetErrorStr2(tjHandle));
+        tjDestroy(tjHandle);
+        return false;
+    }
+    tjDestroy(tjHandle);
+    return true;
+}
+
+void FormatConverter::exchangeRAndB(uint8_t *pucRgb, uint8_t *target, uint32_t width, uint32_t height, uint32_t pixelSize) {
+    if(pucRgb == nullptr || target == nullptr) {
+        return;
+    }
+    for(uint32_t i = 0; i < height; i++) {
+        for(uint32_t j = 0; j < width; j++) {
+            uint8_t tmp1                                      = pucRgb[i * width * pixelSize + j * pixelSize];
+            target[i * width * pixelSize + j * pixelSize]     = pucRgb[i * width * pixelSize + j * pixelSize + 2];
+            target[i * width * pixelSize + j * pixelSize + 1] = pucRgb[i * width * pixelSize + j * pixelSize + 1];
+            target[i * width * pixelSize + j * pixelSize + 2] = tmp1;
+        }
+    }
+}
+
+void FormatConverter::mjpegToBgra(uint8_t *src, uint32_t src_len, uint8_t *target, uint32_t width, uint32_t height) {
+    tjhandle tjHandle;
+    tjHandle = tjInitDecompress();
+    if(tjDecompress2(tjHandle, src, src_len, target, width,
+                     0,  // pitch
+                     height, TJPF_BGRA, TJFLAG_FASTDCT | TJFLAG_FASTUPSAMPLE)
+       != 0) {
+        LOG_WARN_INTVL("Failed to decompress color frame");
+    }
+    tjDestroy(tjHandle);
+}
+
+}  // namespace libobsensor
+
diff --git a/src/filter/publicfilters/FormatConverterProcess.hpp b/src/filter/publicfilters/FormatConverterProcess.hpp
new file mode 100644
index 00000000..e160a2c1
--- /dev/null
+++ b/src/filter/publicfilters/FormatConverterProcess.hpp
@@ -0,0 +1,50 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include "IFilter.hpp"
+#include <mutex>
+
+namespace libobsensor {
+
+class FormatConverter : public IFilterBase {
+public:
+    FormatConverter();
+    virtual ~FormatConverter() noexcept;
+
+    void                   updateConfig(std::vector<std::string> &params) override;
+    const std::string     &getConfigSchema() const override;
+    void                   reset() override;
+    std::shared_ptr<Frame> process(std::shared_ptr<const Frame> frame) override;
+
+    void setConversion(OBFormat srcFormat, OBFormat dstFormat);
+
+private:
+    void yuyvToRgb(uint8_t *src, uint8_t *target, uint32_t width, uint32_t height);
+    void yuyvToRgba(uint8_t *src, uint8_t *target, uint32_t width, uint32_t height);
+    void yuyvToBgr(uint8_t *src, uint8_t *target, uint32_t width, uint32_t height);
+    void yuyvToBgra(uint8_t *src, uint8_t *target, uint32_t width, uint32_t height);
+    void yuyvToy16(uint8_t *src, uint8_t *target, uint32_t width, uint32_t height);
+    void yuyvToy8(uint8_t *src, uint8_t *target, uint32_t width, uint32_t height);
+    void uyvyToRgb(uint8_t *src, uint8_t *target, uint32_t width, uint32_t height);
+    void i420ToRgb(uint8_t *src, uint8_t *target, uint32_t width, uint32_t height);
+    void nv21ToRgb(uint8_t *src, uint8_t *target, uint32_t width, uint32_t height);
+    void nv12ToRgb(uint8_t *src, uint8_t *target, uint32_t width, uint32_t height);
+    void mjpgToI420(uint8_t *src, uint32_t src_len, uint8_t *target, uint32_t width, uint32_t height);
+    void mjpgToNv21(uint8_t *src, uint32_t src_len, uint8_t *target, uint32_t width, uint32_t height);
+    bool mjpgToRgb(uint8_t *src, uint32_t src_len, uint8_t *target, uint32_t width, uint32_t height);
+    bool mjpgToBgr(uint8_t *src, uint32_t src_len, uint8_t *target, uint32_t width, uint32_t height);
+    void exchangeRAndB(uint8_t *pucRgb, uint8_t *target, uint32_t width, uint32_t height, uint32_t pixelSize = 3);
+    void mjpegToBgra(uint8_t *src, uint32_t src_len, uint8_t *target, uint32_t width, uint32_t height);
+    void mjpgToNv12(uint8_t *src, uint32_t src_len, uint8_t *target, uint32_t width, uint32_t height);
+
+protected:
+    std::shared_ptr<const StreamProfile> currentStreamProfile_;
+    std::shared_ptr<StreamProfile>       tarStreamProfile_;
+    OBConvertFormat                      convertType_;
+    uint8_t                             *tempDataBuf_     = nullptr;
+    uint32_t                             tempDataBufSize_ = 0;
+};
+
+}  // namespace libobsensor
+
diff --git a/src/filter/publicfilters/FrameGeometricTransform.cpp b/src/filter/publicfilters/FrameGeometricTransform.cpp
new file mode 100644
index 00000000..891b9f03
--- /dev/null
+++ b/src/filter/publicfilters/FrameGeometricTransform.cpp
@@ -0,0 +1,634 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "FrameGeometricTransform.hpp"
+#include "exception/ObException.hpp"
+#include "logger/LoggerInterval.hpp"
+#include "frame/FrameFactory.hpp"
+#include "libobsensor/h/ObTypes.h"
+#include "utils/CameraParamProcess.hpp"
+#include <libyuv.h>
+#include <turbojpeg.h>
+
+namespace libobsensor {
+
+template <typename T> void imageMirror(const T *src, T *dst, uint32_t width, uint32_t height) {
+    const T *srcPixel;
+    T       *dstPixel = dst;
+    for(uint32_t h = 0; h < height; h++) {
+        srcPixel = src + (h + 1) * width - 1;
+        for(uint32_t w = 0; w < width; w++) {
+            // mirror row
+            *dstPixel = *srcPixel;
+            srcPixel--;
+            dstPixel++;
+        }
+    }
+}
+
+void mirrorRGBImage(const uint8_t *src, uint8_t *dst, uint32_t width, uint32_t height) {
+    const uint8_t *srcPixel;
+    uint8_t       *dstPixel = dst;
+    for(uint32_t h = 0; h < height; h++) {
+        srcPixel = src + (h + 1) * width * 3 - 3;
+        for(uint32_t w = 0; w < width; w++) {
+            // mirror row for each RGB component
+            for(int i = 0; i < 3; i++) {
+                dstPixel[i] = srcPixel[i];
+            }
+            srcPixel -= 3;
+            dstPixel += 3;
+        }
+    }
+}
+
+void mirrorRGBAImage(const uint8_t *src, uint8_t *dst, uint32_t width, uint32_t height) {
+    const uint8_t *srcPixel;
+    uint8_t       *dstPixel = dst;
+    for(uint32_t h = 0; h < height; h++) {
+        srcPixel = src + (h + 1) * width * 4 - 4;
+        for(uint32_t w = 0; w < width; w++) {
+            // mirror row for each RGB component
+            for(int i = 0; i < 4; i++) {
+                dstPixel[i] = srcPixel[i];
+            }
+            srcPixel -= 4;
+            dstPixel += 4;
+        }
+    }
+}
+
+void mirrorYUYVImage(uint8_t *src, uint8_t *dst, int width, int height) {
+    uint8_t *dstPixel = dst;
+    for(int h = 0; h < height; h++) {
+        uint8_t *srcPixel = src + width * 2 * (h + 1) - 4;
+        for(int w = 0; w < width / 2; w++) {
+            *dstPixel       = *(srcPixel + 2);
+            *(dstPixel + 1) = *(srcPixel + 1);
+            *(dstPixel + 2) = *srcPixel;
+            *(dstPixel + 3) = *(srcPixel + 3);
+
+            srcPixel -= 4;
+            dstPixel += 4;
+        }
+    }
+}
+
+template <typename T> void imageFlip(const T *src, T *dst, uint32_t width, uint32_t height) {
+
+    const T *flipSrc = src + (width * height);
+    for(uint32_t h = 0; h < height; h++) {
+        flipSrc -= width;
+        memcpy(dst, flipSrc, width * sizeof(T));
+        dst += width;
+    }
+}
+
+void flipRGBImage(int pixelSize, const uint8_t *src, uint8_t *dst, uint32_t width, uint32_t height) {
+    // const uint32_t pixelSize = 3;  // RGB888 format occupies 3 bytes per pixel
+    const uint32_t rowSize = width * pixelSize;
+
+    for(uint32_t h = 0; h < height; h++) {
+        const uint8_t *flipSrc = src + (height - h - 1) * rowSize;
+        memcpy(dst, flipSrc, rowSize);
+        dst += rowSize;
+    }
+}
+
+// #define imageRotate180 imageFlip
+
+// Rotate 90 degrees clockwise
+template <typename T> void imageRotate90(const T *src, T *dst, uint32_t width, uint32_t height) {
+    const T *srcPixel;
+    T       *dstPixel = dst;
+    for(uint32_t h = 0; h < width; h++) {
+        for(uint32_t w = 0; w < height; w++) {
+            srcPixel  = src + width * (height - w - 1) + h;
+            *dstPixel = *srcPixel;
+            dstPixel++;
+        }
+    }
+}
+
+template <typename T> void imageRotate180(const T *src, T *dst, uint32_t width, uint32_t height) {
+    const T *srcPixel;
+    T       *dstPixel = dst;
+    for(uint32_t h = 0; h < height; h++) {
+        for(uint32_t w = 0; w < width; w++) {
+            srcPixel  = src + width * (height - h - 1) + (width - w - 1);
+            *dstPixel = *srcPixel;
+            dstPixel++;
+        }
+    }
+}
+
+template <typename T> void imageRotate270(const T *src, T *dst, uint32_t width, uint32_t height) {
+    const T *srcPixel;
+    T       *dstPixel = dst;
+    for(uint32_t h = 0; h < width; h++) {
+        for(uint32_t w = 0; w < height; w++) {
+            srcPixel  = src + width * w + (width - h - 1);
+            *dstPixel = *srcPixel;
+            dstPixel++;
+        }
+    }
+}
+
+template <typename T> void imageRotate(const T *src, T *dst, uint32_t width, uint32_t height, uint32_t rotateDegree) {
+    switch(rotateDegree) {
+    case 90:
+        imageRotate90<T>(src, dst, width, height);
+        break;
+    case 180:
+        imageRotate180<T>(src, dst, width, height);
+        break;
+    case 270:
+        imageRotate270<T>(src, dst, width, height);
+        break;
+    default:
+        LOG_WARN_INTVL_THREAD("Unsupported rotate degree!");
+        break;
+    }
+}
+
+template <typename T> void rgbImageRotate90(const uint8_t *src, uint8_t *dst, uint32_t width, uint32_t height, uint32_t pixelSize) {
+    for(uint32_t h = 0; h < width; h++) {
+        for(uint32_t w = 0; w < height; w++) {
+            const uint8_t *srcPixel = src + (height - w - 1) * width * pixelSize + h * pixelSize;
+            uint8_t       *dstPixel = dst + h * height * pixelSize + w * pixelSize;
+            memcpy(dstPixel, srcPixel, pixelSize);
+        }
+    }
+}
+
+template <typename T> void rgbImageRotate180(const uint8_t *src, uint8_t *dst, uint32_t width, uint32_t height, uint32_t pixelSize) {
+    for(uint32_t h = 0; h < height; h++) {
+        for(uint32_t w = 0; w < width; w++) {
+            const uint8_t *srcPixel = src + (height - h - 1) * width * pixelSize + (width - w - 1) * pixelSize;
+            uint8_t       *dstPixel = dst + h * width * pixelSize + w * pixelSize;
+            memcpy(dstPixel, srcPixel, pixelSize);
+        }
+    }
+}
+
+template <typename T> void rgbImageRotate270(const uint8_t *src, uint8_t *dst, uint32_t width, uint32_t height, uint32_t pixelSize) {
+    for(uint32_t h = 0; h < width; h++) {
+        for(uint32_t w = 0; w < height; w++) {
+            const T *srcPixel = src + ((w * width + h) * pixelSize);
+            T       *dstPixel = dst + (((width - h - 1) * height + w) * pixelSize);
+            memcpy(dstPixel, srcPixel, pixelSize * sizeof(T));
+        }
+    }
+}
+
+template <typename T> void rotateRGBImage(const T *src, T *dst, uint32_t width, uint32_t height, uint32_t rotateDegree, uint32_t pixelSize) {
+    switch(rotateDegree) {
+    case 90:
+        rgbImageRotate90<T>(src, dst, width, height, pixelSize);
+        break;
+    case 180:
+        rgbImageRotate180<T>(src, dst, width, height, pixelSize);
+        break;
+    case 270:
+        rgbImageRotate270<T>(src, dst, width, height, pixelSize);
+        break;
+    default:
+        LOG_WARN_INTVL_THREAD("Unsupported rotate degree!");
+        break;
+    }
+}
+
+void yuyvImageRotate(uint8_t *src, uint8_t *dst, uint32_t width, uint32_t height, uint32_t rotateDegree) {
+    libyuv::RotationMode rotationMode;
+    switch(rotateDegree) {
+    case 90:
+        rotationMode = libyuv::kRotate90;
+        break;
+    case 180:
+        rotationMode = libyuv::kRotate180;
+        break;
+    case 270:
+        rotationMode = libyuv::kRotate270;
+        break;
+    default:
+        LOG_WARN_INTVL_THREAD("Unsupported rotate degree!");
+        return;
+    }
+
+    // 1. yuyv to I420, since yuyv is a packed format, only plane format can be rotated; there will be data loss when rotating to plane.
+    uint32_t dst_width    = width;
+    uint32_t dst_height   = height;
+    uint8_t *dst_y        = dst;
+    uint32_t dst_stride_y = dst_width;
+    uint8_t *dst_u        = dst + dst_width * dst_height;
+    uint32_t dst_stride_u = dst_width / 2;
+    uint8_t *dst_v        = dst + dst_width * dst_height + (dst_width * dst_height) / 4;
+    uint32_t dst_stride_v = dst_width / 2;
+    libyuv::YUY2ToI420(src, width * 2, dst_y, dst_stride_y, dst_u, dst_stride_u, dst_v, dst_stride_v, dst_width, dst_height);
+
+    // 2. rotate
+    uint8_t *src_y        = dst_y;
+    uint32_t src_stride_y = dst_stride_y;
+    uint8_t *src_u        = dst_u;
+    uint32_t src_stride_u = dst_stride_u;
+    uint8_t *src_v        = dst_v;
+    uint32_t src_stride_v = dst_stride_v;
+    if(rotationMode != libyuv::kRotate180) {
+        dst_width  = height;
+        dst_height = width;
+    }
+    std::swap(src, dst);
+    dst_y        = dst;
+    dst_stride_y = dst_width;
+    dst_u        = dst + dst_width * dst_height;
+    dst_stride_u = dst_width / 2;
+    dst_v        = dst + dst_width * dst_height + (dst_width * dst_height) / 4;
+    dst_stride_v = dst_width / 2;
+    libyuv::I420Rotate(src_y, src_stride_y, src_u, src_stride_u, src_v, src_stride_v, dst_y, dst_stride_y, dst_u, dst_stride_u, dst_v, dst_stride_v, width,
+                       height, rotationMode);
+
+    // 3.I420 to yuyv
+    src_y        = dst_y;
+    src_stride_y = dst_stride_y;
+    src_u        = dst_u;
+    src_stride_u = dst_stride_u;
+    src_v        = dst_v;
+    src_stride_v = dst_stride_v;
+    std::swap(src, dst);
+    uint8_t *dst_yuy2        = dst;
+    uint32_t dst_stride_yuy2 = dst_width * 2;
+    libyuv::I420ToYUY2(src_y, src_stride_y, src_u, src_stride_u, src_v, src_stride_v, dst_yuy2, dst_stride_yuy2, dst_width, dst_height);
+}
+
+FrameMirror::FrameMirror() {}
+FrameMirror::~FrameMirror() noexcept {}
+
+void FrameMirror::updateConfig(std::vector<std::string> &params) {
+    if(params.size() != 0) {
+        throw unsupported_operation_exception("Frame mirror update config error: unsupported operation.");
+    }
+}
+
+const std::string &FrameMirror::getConfigSchema() const {
+    static const std::string schema = "";  // empty schema
+    return schema;
+}
+
+void FrameMirror::reset() {
+    srcStreamProfile_.reset();
+    rstStreamProfile_.reset();
+}
+
+std::shared_ptr<Frame> FrameMirror::process(std::shared_ptr<const Frame> frame) {
+    if(!frame) {
+        return nullptr;
+    }
+
+    auto outFrame = FrameFactory::createFrameFromOtherFrame(frame);
+    if(frame->is<FrameSet>()) {
+        return outFrame;
+    }
+
+    if(frame->getFormat() != OB_FORMAT_Y16 && frame->getFormat() != OB_FORMAT_Y8 && frame->getFormat() != OB_FORMAT_YUYV && frame->getFormat() != OB_FORMAT_RGB
+       && frame->getFormat() != OB_FORMAT_BGR && frame->getFormat() != OB_FORMAT_RGBA && frame->getFormat() != OB_FORMAT_BGRA) {
+        LOG_WARN_INTVL("FrameMirror unsupported to process this format: {}", frame->getFormat());
+        return outFrame;
+    }
+
+    auto videoFrame      = frame->as<VideoFrame>();
+    bool isMirrorSupport = true;
+    switch(frame->getFormat()) {
+    case OB_FORMAT_Y8:
+        imageMirror<uint8_t>((uint8_t *)videoFrame->getData(), (uint8_t *)outFrame->getData(), videoFrame->getWidth(), videoFrame->getHeight());
+        break;
+    case OB_FORMAT_Y16:
+        imageMirror<uint16_t>((uint16_t *)videoFrame->getData(), (uint16_t *)outFrame->getData(), videoFrame->getWidth(), videoFrame->getHeight());
+        break;
+    case OB_FORMAT_YUYV:
+        if(frame->getType() == OB_FRAME_COLOR) {
+            mirrorYUYVImage((uint8_t *)videoFrame->getData(), (uint8_t *)outFrame->getData(), videoFrame->getWidth(), videoFrame->getHeight());
+        }
+        else {
+            imageMirror<uint32_t>((uint32_t *)videoFrame->getData(), (uint32_t *)outFrame->getData(), videoFrame->getWidth() / 2, videoFrame->getHeight());
+        }
+        break;
+    case OB_FORMAT_RGB:
+    case OB_FORMAT_BGR:
+        mirrorRGBImage((uint8_t *)videoFrame->getData(), (uint8_t *)outFrame->getData(), videoFrame->getWidth(), videoFrame->getHeight());
+        break;
+    case OB_FORMAT_RGBA:
+    case OB_FORMAT_BGRA:
+        mirrorRGBAImage((uint8_t *)videoFrame->getData(), (uint8_t *)outFrame->getData(), videoFrame->getWidth(), videoFrame->getHeight());
+        break;
+    default:
+        isMirrorSupport = false;
+        break;
+    }
+
+    try {
+        if(isMirrorSupport) {
+            auto streampProfile = frame->getStreamProfile();
+            if(!srcStreamProfile_ || srcStreamProfile_ != streampProfile) {
+                srcStreamProfile_          = streampProfile;
+                auto srcVideoStreamProfile = srcStreamProfile_->as<VideoStreamProfile>();
+                auto srcIntrinsic          = srcVideoStreamProfile->getIntrinsic();
+                auto rstIntrinsic          = mirrorOBCameraIntrinsic(srcIntrinsic);
+                auto srcDistortion         = srcVideoStreamProfile->getDistortion();
+                auto rstDistortion         = mirrorOBCameraDistortion(srcDistortion);
+                rstStreamProfile_          = srcVideoStreamProfile->clone()->as<VideoStreamProfile>();
+                rstStreamProfile_->bindIntrinsic(rstIntrinsic);
+                rstStreamProfile_->bindDistortion(rstDistortion);
+
+                OBExtrinsic rstExtrinsic = { {
+                                                 -1,
+                                                 0,
+                                                 0,
+                                                 0,
+                                                 1,
+                                                 0,
+                                                 0,
+                                                 0,
+                                                 1,
+                                             },
+                                             { 0, 0, 0 } };
+                rstStreamProfile_->bindExtrinsicTo(srcStreamProfile_, rstExtrinsic);
+            }
+            outFrame->setStreamProfile(rstStreamProfile_);
+        }
+    }
+    catch(libobsensor_exception &error) {
+        LOG_WARN_INTVL("Frame mirror camera intrinsic conversion failed{0}, exception type: {1}", error.get_message(), error.get_exception_type());
+    }
+
+    return outFrame;
+}
+
+OBCameraIntrinsic FrameMirror::mirrorOBCameraIntrinsic(const OBCameraIntrinsic &src) {
+    auto intrinsic = src;
+    CameraParamProcessor::cameraIntrinsicParamsMirror(&intrinsic);
+    return intrinsic;
+}
+
+OBCameraDistortion FrameMirror::mirrorOBCameraDistortion(const OBCameraDistortion &src) {
+    auto distortion = src;
+    CameraParamProcessor::distortionParamMirror(&distortion);
+    return distortion;
+}
+
+FrameFlip::FrameFlip() {}
+FrameFlip::~FrameFlip() noexcept {}
+
+void FrameFlip::updateConfig(std::vector<std::string> &params) {
+    if(params.size() != 0) {
+        throw unsupported_operation_exception("Frame flip update config error: unsupported operation.");
+    }
+}
+
+const std::string &FrameFlip::getConfigSchema() const {
+    static const std::string schema = "";  // empty schema
+    return schema;
+}
+
+void FrameFlip::reset() {
+    srcStreamProfile_.reset();
+    rstStreamProfile_.reset();
+}
+
+std::shared_ptr<Frame> FrameFlip::process(std::shared_ptr<const Frame> frame) {
+    if(!frame) {
+        return nullptr;
+    }
+
+    auto outFrame = FrameFactory::createFrameFromOtherFrame(frame);
+    if(frame->is<FrameSet>()) {
+        return outFrame;
+    }
+
+    if(frame->getFormat() != OB_FORMAT_Y16 && frame->getFormat() != OB_FORMAT_Y8 && frame->getFormat() != OB_FORMAT_YUYV && frame->getFormat() != OB_FORMAT_BGR
+       && frame->getFormat() != OB_FORMAT_RGB && frame->getFormat() != OB_FORMAT_RGBA && frame->getFormat() != OB_FORMAT_BGRA) {
+        LOG_WARN_INTVL("FrameFlip unsupported to process this format:{}", frame->getFormat());
+        return outFrame;
+    }
+
+    bool isSupportFlip = true;
+    auto videoFrame    = frame->as<VideoFrame>();
+    switch(frame->getFormat()) {
+    case OB_FORMAT_Y8:
+        imageFlip<uint8_t>((uint8_t *)videoFrame->getData(), (uint8_t *)outFrame->getData(), videoFrame->getWidth(), videoFrame->getHeight());
+        break;
+    case OB_FORMAT_YUYV:
+    case OB_FORMAT_Y16:
+        imageFlip<uint16_t>((uint16_t *)videoFrame->getData(), (uint16_t *)outFrame->getData(), videoFrame->getWidth(), videoFrame->getHeight());
+        break;
+    case OB_FORMAT_BGR:
+    case OB_FORMAT_RGB:
+        flipRGBImage(3, (uint8_t *)videoFrame->getData(), (uint8_t *)outFrame->getData(), videoFrame->getWidth(), videoFrame->getHeight());
+        break;
+    case OB_FORMAT_RGBA:
+    case OB_FORMAT_BGRA:
+        flipRGBImage(4, (uint8_t *)videoFrame->getData(), (uint8_t *)outFrame->getData(), videoFrame->getWidth(), videoFrame->getHeight());
+        break;
+    default:
+        isSupportFlip = false;
+        break;
+    }
+
+    try {
+        if(isSupportFlip) {
+            auto streampProfile = frame->getStreamProfile();
+            if(!srcStreamProfile_ || srcStreamProfile_ != streampProfile) {
+                srcStreamProfile_          = streampProfile;
+                auto srcVideoStreamProfile = srcStreamProfile_->as<VideoStreamProfile>();
+                auto srcIntrinsic          = srcVideoStreamProfile->getIntrinsic();
+                auto rstIntrinsic          = flipOBCameraIntrinsic(srcIntrinsic);
+                auto srcDistortion         = srcVideoStreamProfile->getDistortion();
+                auto rstDistortion         = flipOBCameraDistortion(srcDistortion);
+                rstStreamProfile_          = srcVideoStreamProfile->clone()->as<VideoStreamProfile>();
+                rstStreamProfile_->bindIntrinsic(rstIntrinsic);
+                rstStreamProfile_->bindDistortion(rstDistortion);
+
+                OBExtrinsic rstExtrinsic = { { 1, 0, 0, 0, -1, 0, 0, 0, 1 }, { 0, 0, 0 } };
+                rstStreamProfile_->bindExtrinsicTo(srcStreamProfile_, rstExtrinsic);
+            }
+            outFrame->setStreamProfile(rstStreamProfile_);
+        }
+    }
+    catch(libobsensor_exception &error) {
+        LOG_WARN_INTVL("Frame flip camera intrinsic conversion failed{0}, exception type: {1}", error.get_message(), error.get_exception_type());
+    }
+
+    return outFrame;
+}
+
+OBCameraIntrinsic FrameFlip::flipOBCameraIntrinsic(const OBCameraIntrinsic &src) {
+    auto intrinsic = src;
+    CameraParamProcessor::cameraIntrinsicParamsFlip(&intrinsic);
+    return intrinsic;
+}
+
+OBCameraDistortion FrameFlip::flipOBCameraDistortion(const OBCameraDistortion &src) {
+    auto distortion = src;
+    CameraParamProcessor::distortionParamFlip(&distortion);
+    return distortion;
+}
+
+FrameRotate::FrameRotate() {}
+FrameRotate::~FrameRotate() noexcept {}
+
+void FrameRotate::updateConfig(std::vector<std::string> &params) {
+    if(params.size() != 1) {
+        throw invalid_value_exception("Frame rotate config error: params size not match");
+    }
+    try {
+        int rotateDegree = static_cast<int>(std::stoi(params[0]));
+        if(rotateDegree == 0 || rotateDegree == 90 || rotateDegree == 180 || rotateDegree == 270) {
+            std::lock_guard<std::mutex> rotateLock(mtx_);
+            rotateDegree_        = rotateDegree;
+            rotateDegreeUpdated_ = true;
+        }
+    }
+    catch(const std::exception &e) {
+        throw invalid_value_exception("Frame rotate config error: " + std::string(e.what()));
+    }
+}
+
+const std::string &FrameRotate::getConfigSchema() const {
+    // csv format: name，type， min，max，step，default，description
+    static const std::string schema = "rotate, int, 0, 270, 90, 0, frame image rotation angle";
+    return schema;
+}
+
+void FrameRotate::reset() {
+    rotateDegreeUpdated_ = true;
+    srcStreamProfile_.reset();
+    rstStreamProfile_.reset();
+}
+
+std::shared_ptr<Frame> FrameRotate::process(std::shared_ptr<const Frame> frame) {
+    if(!frame) {
+        return nullptr;
+    }
+
+    auto outFrame = FrameFactory::createFrameFromOtherFrame(frame);
+    if(frame->is<FrameSet>()) {
+        return outFrame;
+    }
+
+    if(rotateDegree_ == 0) {
+        return outFrame;
+    }
+
+    if(frame->getFormat() != OB_FORMAT_Y16 && frame->getFormat() != OB_FORMAT_Y8 && frame->getFormat() != OB_FORMAT_YUYV && frame->getFormat() != OB_FORMAT_RGB
+       && frame->getFormat() != OB_FORMAT_BGR && frame->getFormat() != OB_FORMAT_RGBA && frame->getFormat() != OB_FORMAT_BGRA) {
+        LOG_WARN_INTVL("FrameRotate unsupported to process this format: {}", frame->getFormat());
+        return outFrame;
+    }
+
+    std::lock_guard<std::mutex> rotateLock(mtx_);
+    bool                        isSupportRotate = true;
+    auto                        videoFrame      = frame->as<VideoFrame>();
+    switch(frame->getFormat()) {
+    case OB_FORMAT_Y8:
+        imageRotate<uint8_t>((uint8_t *)videoFrame->getData(), (uint8_t *)outFrame->getData(), videoFrame->getWidth(), videoFrame->getHeight(), rotateDegree_);
+        break;
+    case OB_FORMAT_Y16:
+        imageRotate<uint16_t>((uint16_t *)videoFrame->getData(), (uint16_t *)outFrame->getData(), videoFrame->getWidth(), videoFrame->getHeight(),
+                              rotateDegree_);
+        break;
+    case OB_FORMAT_YUYV:
+        // Note: This operation will also modify the data content of the original data frame.
+        yuyvImageRotate((uint8_t *)videoFrame->getData(), (uint8_t *)outFrame->getData(), videoFrame->getWidth(), videoFrame->getHeight(), rotateDegree_);
+        break;
+    case OB_FORMAT_RGB:
+    case OB_FORMAT_BGR:
+        rotateRGBImage<uint8_t>((uint8_t *)videoFrame->getData(), (uint8_t *)outFrame->getData(), videoFrame->getWidth(), videoFrame->getHeight(),
+                                rotateDegree_, 3);
+        break;
+    case OB_FORMAT_RGBA:
+    case OB_FORMAT_BGRA:
+        rotateRGBImage<uint8_t>((uint8_t *)videoFrame->getData(), (uint8_t *)outFrame->getData(), videoFrame->getWidth(), videoFrame->getHeight(),
+                                rotateDegree_, 4);
+        break;
+    default:
+        isSupportRotate = false;
+        break;
+    }
+
+    try {
+        if(isSupportRotate) {
+            auto streampProfile = frame->getStreamProfile();
+            if(!rstStreamProfile_ || !srcStreamProfile_ || srcStreamProfile_ != streampProfile || rotateDegreeUpdated_) {
+                rotateDegreeUpdated_       = false;
+                srcStreamProfile_          = streampProfile;
+                auto srcVideoStreamProfile = srcStreamProfile_->as<VideoStreamProfile>();
+                auto srcIntrinsic          = srcVideoStreamProfile->getIntrinsic();
+                auto rstIntrinsic          = rotateOBCameraIntrinsic(srcIntrinsic, rotateDegree_);
+                auto srcDistortion         = srcVideoStreamProfile->getDistortion();
+                auto rstDistortion         = rotateOBCameraDistortion(srcDistortion, rotateDegree_);
+                auto rstExtrinsic          = rotateOBExtrinsic(rotateDegree_);
+                rstStreamProfile_          = srcVideoStreamProfile->clone()->as<VideoStreamProfile>();
+                rstStreamProfile_->bindIntrinsic(rstIntrinsic);
+                rstStreamProfile_->bindDistortion(rstDistortion);
+                rstStreamProfile_->bindExtrinsicTo(srcStreamProfile_, rstExtrinsic);
+            }
+            if(rotateDegree_ == 90 || rotateDegree_ == 270) {
+                rstStreamProfile_->setWidth(videoFrame->getHeight());
+                rstStreamProfile_->setHeight(videoFrame->getWidth());
+            }
+            outFrame->setStreamProfile(rstStreamProfile_);
+        }
+    }
+    catch(libobsensor_exception &error) {
+        LOG_WARN_INTVL("Frame rotate camera intrinsic conversion failed{0}, exception type: {1}", error.get_message(), error.get_exception_type());
+    }
+
+    return outFrame;
+}
+
+OBCameraIntrinsic FrameRotate::rotateOBCameraIntrinsic(const OBCameraIntrinsic &src, uint32_t rotateDegree) {
+    auto intrinsic = src;
+    if(rotateDegree == 90) {
+        CameraParamProcessor::cameraIntrinsicParamsRotate90(&intrinsic);
+    }
+    else if(rotateDegree == 180) {
+        CameraParamProcessor::cameraIntrinsicParamsRotate180(&intrinsic);
+    }
+    else if(rotateDegree == 270) {
+        CameraParamProcessor::cameraIntrinsicParamsRotate270(&intrinsic);
+    }
+
+    return intrinsic;
+}
+
+OBCameraDistortion FrameRotate::rotateOBCameraDistortion(const OBCameraDistortion &src, uint32_t rotateDegree) {
+    auto distortion = src;
+
+    if(rotateDegree == 90) {
+        CameraParamProcessor::distortionParamRotate90(&distortion);
+    }
+    else if(rotateDegree == 180) {
+        CameraParamProcessor::distortionParamRotate180(&distortion);
+    }
+    else if(rotateDegree == 270) {
+        CameraParamProcessor::distortionParamRotate270(&distortion);
+    }
+
+    return distortion;
+}
+
+OBExtrinsic FrameRotate::rotateOBExtrinsic(uint32_t rotateDegree) {
+    // rotate clockwise
+    if(rotateDegree == 90) {
+        return { { 0, 1, 0, -1, 0, 0, 0, 0, 1 }, { 0, 0, 0 } };
+    }
+    else if(rotateDegree == 180) {
+        return { { -1, 0, 0, 0, -1, 0, 0, 0, 1 }, { 0, 0, 0 } };
+    }
+    else if(rotateDegree == 270) {
+        return { { 0, -1, 0, 1, 0, 0, 0, 0, 1 }, { 0, 0, 0 } };
+    }
+    return { { 1, 0, 0, 0, 1, 0, 0, 0, 1 }, { 0, 0, 0 } };
+}
+
+}  // namespace libobsensor
+
diff --git a/src/filter/publicfilters/FrameGeometricTransform.hpp b/src/filter/publicfilters/FrameGeometricTransform.hpp
new file mode 100644
index 00000000..fce2c60b
--- /dev/null
+++ b/src/filter/publicfilters/FrameGeometricTransform.hpp
@@ -0,0 +1,77 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include "IFilter.hpp"
+#include "stream/StreamProfile.hpp"
+#include <mutex>
+#include <thread>
+#include <atomic>
+
+namespace libobsensor {
+
+class FrameMirror : public IFilterBase {
+public:
+    FrameMirror();
+    virtual ~FrameMirror() noexcept;
+
+    void               updateConfig(std::vector<std::string> &params) override;
+    const std::string &getConfigSchema() const override;
+    void               reset() override;
+
+private:
+    std::shared_ptr<Frame> process(std::shared_ptr<const Frame> frame) override;
+
+    static OBCameraIntrinsic  mirrorOBCameraIntrinsic(const OBCameraIntrinsic &src);
+    static OBCameraDistortion mirrorOBCameraDistortion(const OBCameraDistortion &src);
+
+protected:
+    std::shared_ptr<const StreamProfile> srcStreamProfile_;
+    std::shared_ptr<VideoStreamProfile>  rstStreamProfile_;
+};
+
+class FrameFlip : public IFilterBase {
+public:
+    FrameFlip();
+    virtual ~FrameFlip() noexcept;
+
+    void               updateConfig(std::vector<std::string> &params) override;
+    const std::string &getConfigSchema() const override;
+    void               reset() override;
+
+private:
+    std::shared_ptr<Frame> process(std::shared_ptr<const Frame> frame) override;
+
+    static OBCameraIntrinsic  flipOBCameraIntrinsic(const OBCameraIntrinsic &src);
+    static OBCameraDistortion flipOBCameraDistortion(const OBCameraDistortion &src);
+
+protected:
+    std::shared_ptr<const StreamProfile> srcStreamProfile_;
+    std::shared_ptr<VideoStreamProfile>  rstStreamProfile_;
+};
+
+class FrameRotate : public IFilterBase {
+public:
+    FrameRotate();
+    virtual ~FrameRotate() noexcept;
+
+    void               updateConfig(std::vector<std::string> &params) override;
+    const std::string &getConfigSchema() const override;
+    void               reset() override;
+
+private:
+    std::shared_ptr<Frame> process(std::shared_ptr<const Frame> frame) override;
+
+    static OBCameraIntrinsic  rotateOBCameraIntrinsic(const OBCameraIntrinsic &src, uint32_t rotateDegree);
+    static OBCameraDistortion rotateOBCameraDistortion(const OBCameraDistortion &src, uint32_t rotateDegree);
+    static OBExtrinsic        rotateOBExtrinsic(uint32_t rotateDegree);
+
+protected:
+    std::mutex                           mtx_;
+    uint32_t                             rotateDegree_ = 0;
+    std::atomic<bool>                    rotateDegreeUpdated_;
+    std::shared_ptr<const StreamProfile> srcStreamProfile_;
+    std::shared_ptr<VideoStreamProfile>  rstStreamProfile_;
+};
+}  // namespace libobsensor
+
diff --git a/src/filter/publicfilters/FramePixelValueProcess.cpp b/src/filter/publicfilters/FramePixelValueProcess.cpp
new file mode 100644
index 00000000..887e208b
--- /dev/null
+++ b/src/filter/publicfilters/FramePixelValueProcess.cpp
@@ -0,0 +1,231 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "FramePixelValueProcess.hpp"
+#include "exception/ObException.hpp"
+#include "logger/LoggerInterval.hpp"
+#include "frame/FrameFactory.hpp"
+
+namespace libobsensor {
+
+template <typename T> void imagePixelValueScale(const T *src, T *dst, uint32_t width, uint32_t height, float scale_) {
+    const T *srcPixel = src;
+    T       *dstPixel = dst;
+    for(uint32_t h = 0; h < height; h++) {
+        for(uint32_t w = 0; w < width; w++) {
+            *dstPixel = (T)(*srcPixel * scale_);
+            srcPixel++;
+            dstPixel++;
+        }
+    }
+}
+
+template <typename T> void imagePixelValueOffset(T *src, T *dst, uint32_t width, uint32_t height, int8_t offset) {
+    T *dstPixel = dst;
+    T *srcPixel = src;
+    if(offset > 0) {
+        uint8_t shiftCount = offset;
+        for(uint32_t h = 0; h < height; h++) {
+            for(uint32_t w = 0; w < width; w++) {
+                *dstPixel = *srcPixel >> shiftCount;
+                srcPixel++;
+                dstPixel++;
+            }
+        }
+    }
+    else if(offset < 0) {
+        uint8_t shiftCount = -offset;
+        for(uint32_t h = 0; h < height; h++) {
+            for(uint32_t w = 0; w < width; w++) {
+                *dstPixel = *srcPixel << shiftCount;
+                srcPixel++;
+                dstPixel++;
+            }
+        }
+    }
+}
+
+template <typename T> void imagePixelValueThreshold(T *src, T *dst, uint32_t width, uint32_t height, uint32_t min, uint32_t max) {
+    T *dstPixel = dst;
+    T *srcPixel = src;
+    if(min >= max) {
+        for(uint32_t h = 0; h < height; h++) {
+            for(uint32_t w = 0; w < width; w++) {
+                *dstPixel = 0;
+                srcPixel++;
+                dstPixel++;
+            }
+        }
+    }
+    else {
+        for(uint32_t h = 0; h < height; h++) {
+            for(uint32_t w = 0; w < width; w++) {
+                *dstPixel = (*srcPixel < min) ? 0 : ((*srcPixel > max) ? 0 : *srcPixel);
+                srcPixel++;
+                dstPixel++;
+            }
+        }
+    }
+}
+
+PixelValueScaler::PixelValueScaler() {}
+PixelValueScaler::~PixelValueScaler() noexcept {}
+
+void PixelValueScaler::updateConfig(std::vector<std::string> &params) {
+    if(params.size() != 1) {
+        throw invalid_value_exception("PixelValueScaler config error: params size not match");
+    }
+    try {
+        std::lock_guard<std::mutex> scaleLock(mtx_);
+        scale_ = std::stof(params[0]);
+    }
+    catch(const std::exception &e) {
+        throw invalid_value_exception("PixelValueScaler config error: " + std::string(e.what()));
+    }
+}
+
+const std::string &PixelValueScaler::getConfigSchema() const {
+    // csv format: name，type， min，max，step，default，description
+    static const std::string schema = "scale, float, 0.01, 100.0, 0.01, 1.0, value scale factor";
+    return schema;
+}
+
+std::shared_ptr<Frame> PixelValueScaler::process(std::shared_ptr<const Frame> frame) {
+    if(frame->getType() != OB_FRAME_DEPTH) {
+        LOG_WARN_INTVL("PixelValueScaler unsupported to process this frame type: {}", frame->getType());
+        return FrameFactory::createFrameFromOtherFrame(frame);
+    }
+
+    std::lock_guard<std::mutex> scaleLock(mtx_);
+    auto                        depthFrame = frame->as<DepthFrame>();
+    auto                        outFrame   = FrameFactory::createFrameFromOtherFrame(frame);
+    switch(frame->getFormat()) {
+    case OB_FORMAT_Y16:
+        imagePixelValueScale<uint16_t>((uint16_t *)frame->getData(), (uint16_t *)outFrame->getData(), depthFrame->getWidth(), depthFrame->getHeight(), scale_);
+        break;
+    default:
+        LOG_ERROR_INTVL("PixelValueScaler: unsupported format: {}", frame->getFormat());
+        break;
+    }
+
+    auto outDepthFrame = outFrame->as<DepthFrame>();
+    auto valueScale    = outDepthFrame->getValueScale();
+    outDepthFrame->setValueScale(valueScale * scale_);
+
+    return outFrame;
+}
+
+ThresholdFilter::ThresholdFilter() {}
+ThresholdFilter::~ThresholdFilter() noexcept {}
+
+void ThresholdFilter::updateConfig(std::vector<std::string> &params) {
+    if(params.size() != 2) {
+        throw invalid_value_exception("ThresholdFilter config error: params size not match");
+    }
+    try {
+        std::lock_guard<std::mutex> cutOffLock(mtx_);
+        int                         min = std::stoi(params[0]);
+        if(min >= 0 && min <= 16000) {
+            min_ = min;
+        }
+
+        int max = std::stoi(params[1]);
+        if(max >= 0 && max <= 16000) {
+            max_ = max;
+        }
+    }
+    catch(const std::exception &e) {
+        throw invalid_value_exception("ThresholdFilter config error: " + std::string(e.what()));
+    }
+}
+
+const std::string &ThresholdFilter::getConfigSchema() const {
+    // csv format: name，type， min，max，step，default，description
+    static const std::string schema = "min, int, 0, 16000, 1, 0, min depth range\n"
+                                      "max, int, 0, 16000, 1, 16000, max depth range";
+    return schema;
+}
+
+std::shared_ptr<Frame> ThresholdFilter::process(std::shared_ptr<const Frame> frame) {
+    if(!frame) {
+        return nullptr;
+    }
+
+    std::lock_guard<std::mutex> cutOffLock(mtx_);
+    auto                        videoFrame = frame->as<VideoFrame>();
+    auto                        outFrame   = FrameFactory::createFrameFromOtherFrame(frame);
+    float                       scale      = 1.0f;
+    if(frame->is<DepthFrame>()) {
+        scale = frame->as<DepthFrame>()->getValueScale();
+    }
+
+    if(max_ != 65535) {
+        switch(frame->getFormat()) {
+        case OB_FORMAT_Y16:
+            imagePixelValueThreshold((uint16_t *)frame->getData(), (uint16_t *)outFrame->getData(), videoFrame->getWidth(), videoFrame->getHeight(),
+                                     (uint32_t)(min_ / scale), (uint32_t)(max_ / scale));
+            break;
+        case OB_FORMAT_Y8:
+            imagePixelValueThreshold((uint8_t *)frame->getData(), (uint8_t *)outFrame->getData(), videoFrame->getWidth(), videoFrame->getHeight(),
+                                     (uint32_t)(min_ / scale), (uint32_t)(max_ / scale));
+            break;
+        default:
+            LOG_ERROR_INTVL("ThresholdFilter: unsupported format: {}", frame->getFormat());
+            break;
+        }
+    }
+
+    return outFrame;
+}
+
+PixelValueOffset::PixelValueOffset() {}
+PixelValueOffset::~PixelValueOffset() noexcept {}
+
+void PixelValueOffset::updateConfig(std::vector<std::string> &params) {
+    if(params.size() != 1) {
+        throw invalid_value_exception("PixelValueOffset config error: params size not match");
+    }
+    try {
+        std::lock_guard<std::mutex> offsetLock(mtx_);
+        offset_ = static_cast<int8_t>(std::stoi(params[0]));
+    }
+    catch(const std::exception &e) {
+        throw invalid_value_exception("PixelValueOffset config error: " + std::string(e.what()));
+    }
+}
+
+const std::string &PixelValueOffset::getConfigSchema() const {
+    // csv format: name，type， min，max，step，default，description
+    static const std::string schema = "offset, int, -16, 16, 1, 0, value offset factor";
+    return schema;
+}
+
+std::shared_ptr<Frame> PixelValueOffset::process(std::shared_ptr<const Frame> frame) {
+    if(!frame) {
+        return nullptr;
+    }
+
+    std::lock_guard<std::mutex> offsetLock(mtx_);
+    auto                        videoFrame = frame->as<VideoFrame>();
+    auto                        outFrame   = FrameFactory::createFrameFromOtherFrame(frame);
+    if(offset_ != 0) {
+        switch(frame->getFormat()) {
+        case OB_FORMAT_Y16:
+            imagePixelValueOffset((uint16_t *)frame->getData(), (uint16_t *)outFrame->getData(), videoFrame->getWidth(), videoFrame->getHeight(), offset_);
+            break;
+        case OB_FORMAT_Y8:
+            imagePixelValueOffset((uint8_t *)frame->getData(), (uint8_t *)outFrame->getData(), videoFrame->getWidth(), videoFrame->getHeight(), offset_);
+            break;
+        default:
+            LOG_ERROR_INTVL("PixelValueOffset: unsupported format: {}", frame->getFormat());
+            break;
+        }
+
+        uint8_t bitSize = frame->as<VideoFrame>()->getPixelAvailableBitSize();
+        outFrame->as<VideoFrame>()->setPixelAvailableBitSize(bitSize - offset_);
+    }
+    return outFrame;
+}
+
+}  // namespace libobsensor
+
diff --git a/src/filter/publicfilters/FramePixelValueProcess.hpp b/src/filter/publicfilters/FramePixelValueProcess.hpp
new file mode 100644
index 00000000..421384b5
--- /dev/null
+++ b/src/filter/publicfilters/FramePixelValueProcess.hpp
@@ -0,0 +1,63 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include "IFilter.hpp"
+#include <mutex>
+
+namespace libobsensor {
+
+class PixelValueScaler : public IFilterBase {
+public:
+    PixelValueScaler();
+    ~PixelValueScaler() noexcept override;
+
+    void               updateConfig(std::vector<std::string> &params) override;
+    const std::string &getConfigSchema() const override;
+    void               reset() override {}
+
+private:
+    std::shared_ptr<Frame> process(std::shared_ptr<const Frame> frame) override;
+
+protected:
+    std::mutex mtx_;
+    float      scale_ = 1.0f;
+};
+
+class ThresholdFilter : public IFilterBase {
+public:
+    ThresholdFilter();
+    virtual ~ThresholdFilter() noexcept;
+
+    void               updateConfig(std::vector<std::string> &params) override;
+    const std::string &getConfigSchema() const override;
+    void               reset() override {}
+
+private:
+    std::shared_ptr<Frame> process(std::shared_ptr<const Frame> frame) override;
+
+protected:
+    std::mutex mtx_;
+    uint32_t   min_ = 0;
+    uint32_t   max_ = 16000;
+};
+
+class PixelValueOffset : public IFilterBase {
+public:
+    PixelValueOffset();
+    virtual ~PixelValueOffset() noexcept;
+
+    void               updateConfig(std::vector<std::string> &params) override;
+    const std::string &getConfigSchema() const override;
+    void               reset() override {}
+
+private:
+    std::shared_ptr<Frame> process(std::shared_ptr<const Frame> frame) override;
+
+protected:
+    std::mutex mtx_;
+    int8_t     offset_ = 0;
+};
+
+}  // namespace libobsensor
+
diff --git a/src/filter/publicfilters/HdrMergeProcess.cpp b/src/filter/publicfilters/HdrMergeProcess.cpp
new file mode 100644
index 00000000..8ec3b7a5
--- /dev/null
+++ b/src/filter/publicfilters/HdrMergeProcess.cpp
@@ -0,0 +1,322 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "HdrMergeProcess.hpp"
+#include "exception/ObException.hpp"
+#include "logger/LoggerInterval.hpp"
+#include "frame/FrameFactory.hpp"
+#include "libobsensor/h/ObTypes.h"
+#include "utils/PublicTypeHelper.hpp"
+
+namespace libobsensor {
+
+// avoids returning too old merged frame - frame counter jumps forward
+std::pair<OBFormat, std::vector<uint8_t>> EXP_LUT_;
+
+template <typename T> void generateConfidenceMap(const T *ir, uint8_t *map, int width, int height) {
+    const T *p_ir  = ir;
+    uint8_t *p_map = map;
+    for(int i = 0; i < height; i++) {
+        for(int j = 0; j < width; j++) {
+            *p_map++ = EXP_LUT_[*p_ir++];
+        }
+    }
+}
+
+template <typename T> void triangleWeights(std::vector<uint8_t> &w) {
+    int length = 1 << (sizeof(T) * 8);
+    w.resize(length, 0);
+    int   half  = length >> 1;
+    float slope = 256.f / half;
+    for(int i = 0; i < half; i++) {
+        w[i]              = static_cast<uint8_t>(i * slope);
+        w[length - i - 1] = w[i];
+    }
+}
+
+template <typename T> void mergeFramesUsingIr(uint16_t *new_data, uint16_t *d0, uint16_t *d1, const T *ir0, const T *ir1, int width, int height) {
+    int pix_num = width * height;
+
+    for(int i = 0; i < pix_num; i++) {
+        uint8_t c0 = EXP_LUT_.second[ir0[i]];
+        uint8_t c1 = EXP_LUT_.second[ir1[i]];
+        // new_data[i] = c0 > c1 ? d0[i] : d1[i];
+        uint8_t c = c0, idx = 0;
+        if(c1 > c0) {
+            c   = c1;
+            idx = 1;
+        }
+        if(c) {  // over-staturated or completely dark pixels
+            new_data[i] = idx ? d1[i] : d0[i];
+        }
+    }
+}
+
+void mergeFramesUsingOnlyDepth(uint16_t *new_data, uint16_t *d0, uint16_t *d1, int width, int height) {
+    for(int i = 0; i < width * height; i++) {
+        if(d0[i] && d1[i]) {
+            if(d0[i] == 65535)
+                new_data[i] = d1[i];
+            else
+                new_data[i] = d0[i];
+        }
+        else if(d0[i])
+            new_data[i] = d0[i];
+        else if(d1[i])
+            new_data[i] = d1[i];
+    }
+}
+
+std::shared_ptr<const IRFrame> getIRFrameFromFrameSet(std::shared_ptr<const Frame> frame_fs) {
+    if(!frame_fs->is<FrameSet>()) {
+        return nullptr;
+    }
+
+    auto frameSet = frame_fs->as<FrameSet>();
+    auto irFrame  = frameSet->getFrame(OB_FRAME_IR);
+    if(!irFrame) {
+        irFrame = frameSet->getFrame(OB_FRAME_IR_LEFT);
+        if(!irFrame) {
+            irFrame = frameSet->getFrame(OB_FRAME_IR_RIGHT);
+        }
+    }
+
+    if(irFrame) {
+        return irFrame->as<IRFrame>();
+    }
+
+    return nullptr;
+}
+
+bool checkIRAvailability(std::shared_ptr<const DepthFrame> first_depth, std::shared_ptr<const IRFrame> first_ir, std::shared_ptr<const DepthFrame> second_depth,
+                         std::shared_ptr<const IRFrame> second_ir) {
+
+    if(!first_ir || !second_ir) {
+        return false;
+    }
+
+    if((first_depth->getWidth() != first_ir->getWidth()) || (first_depth->getHeight() != first_ir->getHeight())
+       || (second_ir->getWidth() != first_ir->getWidth()) || (second_ir->getHeight() != first_ir->getHeight())) {
+        return false;
+    }
+
+    try {
+        auto depth_info = first_depth->getMetadataValue(OB_FRAME_METADATA_TYPE_FRAME_NUMBER);
+        auto ir_info    = first_ir->getMetadataValue(OB_FRAME_METADATA_TYPE_FRAME_NUMBER);
+        if(depth_info != ir_info) {
+            return false;
+        }
+
+        depth_info = second_depth->getMetadataValue(OB_FRAME_METADATA_TYPE_FRAME_NUMBER);
+        ir_info    = second_ir->getMetadataValue(OB_FRAME_METADATA_TYPE_FRAME_NUMBER);
+        if(depth_info != ir_info) {
+            return false;
+        }
+
+        depth_info = first_depth->getMetadataValue(OB_FRAME_METADATA_TYPE_HDR_SEQUENCE_INDEX);
+        ir_info    = first_ir->getMetadataValue(OB_FRAME_METADATA_TYPE_HDR_SEQUENCE_INDEX);
+        if(depth_info != ir_info) {
+            return false;
+        }
+
+        depth_info = second_depth->getMetadataValue(OB_FRAME_METADATA_TYPE_HDR_SEQUENCE_INDEX);
+        ir_info    = second_ir->getMetadataValue(OB_FRAME_METADATA_TYPE_HDR_SEQUENCE_INDEX);
+        if(depth_info != ir_info) {
+            return false;
+        }
+    }
+    catch(...) {
+        return false;
+    }
+
+    OBFormat first_ir_format  = first_ir->getFormat();
+    OBFormat second_ir_format = second_ir->getFormat();
+    if(first_ir_format != second_ir_format || (second_ir_format != OB_FORMAT_Y8 && second_ir_format != OB_FORMAT_Y16)) {
+        return false;
+    }
+    return true;
+}
+
+HDRMerge::HDRMerge() {}
+HDRMerge::~HDRMerge() noexcept {}
+
+void HDRMerge::updateConfig(std::vector<std::string> &params) {
+    if(params.size() != 0) {
+        throw unsupported_operation_exception("HDRMerge update config error: unsupported operation.");
+    }
+}
+
+const std::string &HDRMerge::getConfigSchema() const {
+    static const std::string schema = "";
+    return schema;
+}
+
+void HDRMerge::reset() {
+    frames_.clear();
+}
+
+std::shared_ptr<Frame> HDRMerge::process(std::shared_ptr<const Frame> frame) {
+    if(!frame) {
+        return nullptr;
+    }
+
+    std::shared_ptr<const DepthFrame> depthFrame = nullptr;
+    if(frame->is<FrameSet>()) {
+        depthFrame = frame->as<FrameSet>()->getFrame(OB_FRAME_DEPTH)->as<DepthFrame>();
+    }
+    else {
+        depthFrame = frame->as<DepthFrame>();
+    }
+
+    if(!depthFrame) {
+        LOG_WARN_INTVL("No depth frame found, hdrMerge unsupported to process this frame");
+        std::shared_ptr<Frame> outFrame = FrameFactory::createFrameFromOtherFrame(frame, true);
+        return outFrame;
+    }
+    try {
+        auto depthSeqSize = depthFrame->getMetadataValue(OB_FRAME_METADATA_TYPE_HDR_SEQUENCE_SIZE);
+        if(depthSeqSize != 2) {
+            LOG_WARN_INTVL("HDRMerge unsupported to process this frame with sequence size: {}", depthSeqSize);
+            std::shared_ptr<Frame> outFrame = FrameFactory::createFrameFromOtherFrame(frame, true);
+            return outFrame;
+        }
+
+        auto    depth_seq_id = depthFrame->getMetadataValue(OB_FRAME_METADATA_TYPE_HDR_SEQUENCE_INDEX);
+        int64_t frameSize    = static_cast<int64_t>(frames_.size());
+        if(frameSize == depth_seq_id) {
+            frames_[depth_seq_id] = frame;
+        }
+
+        discardDepthMergedFrameIfNeeded(depthFrame);
+
+        if(frames_.size() >= 2) {
+            auto frame_0       = frames_[0];
+            auto depth_frame_0 = frame_0;
+            if(frame_0->is<FrameSet>()) {
+                depth_frame_0 = frame_0->as<FrameSet>()->getFrame(OB_FRAME_DEPTH);
+            }
+            auto frame_0_framenumber = depth_frame_0->getMetadataValue(OB_FRAME_METADATA_TYPE_FRAME_NUMBER);
+
+            auto frame_1       = frames_[1];
+            auto depth_frame_1 = frame_1;
+            if(depth_frame_1->is<FrameSet>()) {
+                depth_frame_1 = depth_frame_1->as<FrameSet>()->getFrame(OB_FRAME_DEPTH);
+            }
+            auto frame_1_framenumber = depth_frame_1->getMetadataValue(OB_FRAME_METADATA_TYPE_FRAME_NUMBER);
+            frames_.clear();
+
+            // two adjancent frames
+            if(1 == frame_1_framenumber - frame_0_framenumber || (frame_1_framenumber == 0 && frame_0_framenumber == 1)) {
+                std::shared_ptr<Frame> new_frame = merge(frame_0, frame_1);
+                if(new_frame) {
+                    depth_merged_frame_ = new_frame;
+                }
+            }
+        }
+    }
+    catch(...) {
+    }
+
+    if(frame->is<FrameSet>() && depth_merged_frame_) {
+        auto outFrame = FrameFactory::createFrameFromOtherFrame(frame);
+        auto frameSet = outFrame->as<FrameSet>();
+        frameSet->pushFrame(std::move(depth_merged_frame_));
+        return outFrame;
+    }
+
+    return depth_merged_frame_;
+}
+
+void HDRMerge::discardDepthMergedFrameIfNeeded(std::shared_ptr<const Frame> frame) {
+    if(depth_merged_frame_) {
+        std::shared_ptr<const DepthFrame> newFrame = nullptr;
+        if(frame->is<FrameSet>()) {
+            newFrame = frame->as<FrameSet>()->getFrame(OB_FRAME_DEPTH)->as<DepthFrame>();
+        }
+        else {
+            newFrame = frame->as<DepthFrame>();
+        }
+
+        auto mergedFrame = depth_merged_frame_->as<DepthFrame>();
+
+        auto merged_counter = depth_merged_frame_->getMetadataValue(OB_FRAME_METADATA_TYPE_FRAME_NUMBER);
+        auto new_counter    = newFrame->getMetadataValue(OB_FRAME_METADATA_TYPE_FRAME_NUMBER);
+        auto counter_diff   = new_counter - merged_counter;
+
+        // counter rest or, previous frame too old or, resolution changed
+        if((counter_diff < 0) || (counter_diff > 4) || (mergedFrame->getWidth() != newFrame->getWidth())
+           || (mergedFrame->getHeight() != newFrame->getHeight())) {
+            depth_merged_frame_ = nullptr;
+        }
+    }
+}
+
+std::shared_ptr<Frame> HDRMerge::merge(std::shared_ptr<const Frame> first_fs, std::shared_ptr<const Frame> second_fs) {
+    std::shared_ptr<const DepthFrame> first_depth  = nullptr;
+    std::shared_ptr<const DepthFrame> second_depth = nullptr;
+    std::shared_ptr<const IRFrame>    first_ir     = nullptr;
+    std::shared_ptr<const IRFrame>    second_ir    = nullptr;
+
+    if(first_fs->is<FrameSet>()) {
+        first_depth = first_fs->as<FrameSet>()->getFrame(OB_FRAME_DEPTH)->as<DepthFrame>();
+    }
+    else {
+        first_depth = first_fs->as<DepthFrame>();
+    }
+    first_ir = getIRFrameFromFrameSet(first_fs);
+
+    if(second_fs->is<FrameSet>()) {
+        second_depth = second_fs->as<FrameSet>()->getFrame(OB_FRAME_DEPTH)->as<DepthFrame>();
+    }
+    else {
+        second_depth = second_fs->as<DepthFrame>();
+    }
+    second_ir = getIRFrameFromFrameSet(second_fs);
+
+    auto width  = first_depth->getWidth();
+    auto height = first_depth->getHeight();
+    if((width != second_depth->getWidth()) || (height != second_depth->getHeight())) {
+        return nullptr;
+    }
+
+    auto newFrame = FrameFactory::createFrameFromStreamProfile(first_depth->getStreamProfile());
+    if(newFrame) {
+        newFrame->copyInfoFromOther(first_depth);
+        auto d0 = (uint16_t *)first_depth->getData();
+        auto d1 = (uint16_t *)second_depth->getData();
+        auto d  = (uint16_t *)newFrame->getData();
+        memset(d, 0, newFrame->getDataSize());
+        if(checkIRAvailability(first_depth, first_ir, second_depth, second_ir)) {
+            OBFormat ir_format = first_ir->getFormat();
+            if((EXP_LUT_.first != ir_format) || (EXP_LUT_.second.empty())) {
+                EXP_LUT_.first = ir_format;
+                if(ir_format == OB_FORMAT_Y8)
+                    triangleWeights<uint8_t>(EXP_LUT_.second);
+                else
+                    triangleWeights<uint16_t>(EXP_LUT_.second);
+            }
+            if(OB_FORMAT_Y8 == ir_format) {
+                if(first_depth->getMetadataValue(OB_FRAME_METADATA_TYPE_EXPOSURE) == first_ir->getMetadataValue(OB_FRAME_METADATA_TYPE_EXPOSURE))
+                    mergeFramesUsingIr<uint8_t>(d, d0, d1, first_ir->getData(), second_ir->getData(), width, height);
+                else
+                    mergeFramesUsingIr<uint8_t>(d, d0, d1, second_ir->getData(), first_ir->getData(), width, height);
+            }
+            else {
+                if(first_depth->getMetadataValue(OB_FRAME_METADATA_TYPE_EXPOSURE) == first_ir->getMetadataValue(OB_FRAME_METADATA_TYPE_EXPOSURE))
+                    mergeFramesUsingIr<uint16_t>(d, d0, d1, (uint16_t *)first_ir->getData(), (uint16_t *)second_ir->getData(), width, height);
+                else
+                    mergeFramesUsingIr<uint16_t>(d, d0, d1, (uint16_t *)second_ir->getData(), (uint16_t *)first_ir->getData(), width, height);
+            }
+
+        }
+        else {
+            mergeFramesUsingOnlyDepth(d, d0, d1, width, height);
+        }
+        return newFrame;
+    }
+
+    return FrameFactory::createFrameFromOtherFrame(first_fs, true);
+}
+
+}  // namespace libobsensor
+
diff --git a/src/filter/publicfilters/HdrMergeProcess.hpp b/src/filter/publicfilters/HdrMergeProcess.hpp
new file mode 100644
index 00000000..e808938e
--- /dev/null
+++ b/src/filter/publicfilters/HdrMergeProcess.hpp
@@ -0,0 +1,31 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include "IFilter.hpp"
+#include <map>
+
+namespace libobsensor {
+
+class HDRMerge : public IFilterBase {
+public:
+    HDRMerge();
+    virtual ~HDRMerge() noexcept;
+
+    void               updateConfig(std::vector<std::string> &params) override;
+    const std::string &getConfigSchema() const override;
+    void               reset() override;
+
+private:
+    std::shared_ptr<Frame> process(std::shared_ptr<const Frame> frame) override;
+
+    void                   discardDepthMergedFrameIfNeeded(std::shared_ptr<const Frame> frame);
+    std::shared_ptr<Frame> merge(std::shared_ptr<const Frame> first_f, std::shared_ptr<const Frame> second_f);
+
+protected:
+    std::map<uint64_t, std::shared_ptr<const Frame>> frames_;
+    std::shared_ptr<Frame>                           depth_merged_frame_;
+};
+
+}  // namespace libobsensor
+
diff --git a/src/filter/publicfilters/IMUCorrector.cpp b/src/filter/publicfilters/IMUCorrector.cpp
new file mode 100644
index 00000000..f81890d5
--- /dev/null
+++ b/src/filter/publicfilters/IMUCorrector.cpp
@@ -0,0 +1,198 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "IMUCorrector.hpp"
+#include "exception/ObException.hpp"
+#include "logger/LoggerInterval.hpp"
+#include "frame/FrameFactory.hpp"
+#include "stream/StreamProfile.hpp"
+#include "InternalTypes.hpp"
+
+namespace libobsensor {
+
+OBIMUCalibrateParams IMUCorrector::parserIMUCalibParamRaw(uint8_t *data, uint32_t size) {
+    auto                 singleIMUParamSize = sizeof(OBSingleIMUParams);
+    uint8_t              paramCount         = static_cast<uint8_t>(size / singleIMUParamSize);
+    OBIMUCalibrateParams params{};
+
+    params.validNum = (paramCount > 3) ? 3 : paramCount;
+
+    for(int i = 0; i < params.validNum; i++) {
+        auto singleParam          = *((OBSingleIMUParams *)(data + (i * singleIMUParamSize)));
+        params.singleIMUParams[i] = singleParam;
+    }
+    return params;
+}
+
+OBIMUCalibrateParams IMUCorrector::getDefaultImuCalibParam() {
+    auto generateDefaultParams = []() {
+        OBIMUCalibrateParams params;
+        const double         IdentityMatrix3x3[9]  = { 1, 0, 0, 0, 1, 0, 0, 0, 1 };
+        const double         IdentityMatrix4x4[16] = { 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1 };
+        memset(&params, 0, sizeof(OBIMUCalibrateParams));
+        memcpy(params.singleIMUParams[0].imu_to_cam_extrinsics, IdentityMatrix4x4, sizeof(IdentityMatrix4x4));
+        memcpy(params.singleIMUParams[0].body_to_gyroscope, IdentityMatrix3x3, sizeof(IdentityMatrix3x3));
+        memcpy(params.singleIMUParams[0].acc_to_gyro_factor, IdentityMatrix3x3, sizeof(IdentityMatrix3x3));
+        memcpy(params.singleIMUParams[0].acc.scaleMisalignment, IdentityMatrix3x3, sizeof(IdentityMatrix3x3));
+        memcpy(params.singleIMUParams[0].gyro.scaleMisalignment, IdentityMatrix3x3, sizeof(IdentityMatrix3x3));
+
+        return params;
+    };
+    static OBIMUCalibrateParams params = generateDefaultParams();
+    return params;
+}
+
+float IMUCorrector::calculateAccelGravity(int16_t accelValue, uint8_t accelFSR) {
+    float sensitivity = 0.f;
+
+    switch(accelFSR) {
+    case OB_ACCEL_FS_2g: /*!< 2g*/
+        sensitivity = ACCEL_MAX / 2.0f;
+        break;
+    case OB_ACCEL_FS_4g: /*!< 4g*/
+        sensitivity = ACCEL_MAX / 4.0f;
+        break;
+    case OB_ACCEL_FS_8g: /*!< 8g*/
+        sensitivity = ACCEL_MAX / 8.0f;
+        break;
+    case OB_ACCEL_FS_16g: /*!< 16g*/
+        sensitivity = ACCEL_MAX / 16.0f;
+        break;
+    }
+
+    return (accelValue / sensitivity);
+}
+
+float IMUCorrector::calculateGyroDPS(int16_t gyroValue, uint8_t gyroFSR) {
+    float sensitivity = 0.f;
+
+    switch(gyroFSR) {
+    case OB_GYRO_FS_16dps: /*!< 16dps*/
+        sensitivity = GYRO_MAX / 16.0f;
+        break;
+    case OB_GYRO_FS_31dps: /*!< 31dps*/
+        sensitivity = GYRO_MAX / 31.0f;
+        break;
+    case OB_GYRO_FS_62dps: /*!< 62dps*/
+        sensitivity = GYRO_MAX / 62.0f;
+        break;
+    case OB_GYRO_FS_125dps: /*!< 125dps*/
+        sensitivity = GYRO_MAX / 125.0f;
+        break;
+    case OB_GYRO_FS_250dps: /*!< 250dps*/
+        sensitivity = GYRO_MAX / 250.0f;
+        break;
+    case OB_GYRO_FS_500dps: /*!< 500dps*/
+        sensitivity = GYRO_MAX / 500.0f;
+        break;
+    case OB_GYRO_FS_1000dps: /*!< 1000dps*/
+        sensitivity = GYRO_MAX / 1000.0f;
+        break;
+    case OB_GYRO_FS_2000dps: /*!< 2000dps*/
+        sensitivity = GYRO_MAX / 2000.0f;
+        break;
+    }
+
+    return (gyroValue / sensitivity);
+}
+
+float IMUCorrector::calculateRegisterTemperature(int16_t tempValue) {
+    float ret = static_cast<float>(tempValue / 132.48 + 25);
+    return ret;
+}
+
+IMUCorrector::IMUCorrector() {}
+
+void IMUCorrector::updateConfig(std::vector<std::string> &params) {
+    if(params.size() != 0) {
+        throw unsupported_operation_exception("IMUCorrector update config error: unsupported operation.");
+    }
+}
+
+const std::string &IMUCorrector::getConfigSchema() const {
+    static const std::string schema = "";
+    return schema;
+}
+
+std::shared_ptr<Frame> IMUCorrector::process(std::shared_ptr<const Frame> frame) {
+    if(frame == nullptr) {
+        return nullptr;
+    }
+
+    auto newFrame = FrameFactory::createFrameFromOtherFrame(frame, true);
+    if(!frame->is<FrameSet>()) {
+        return newFrame;
+    }
+
+    auto frameSet   = newFrame->as<FrameSet>();
+    auto accelFrame = frameSet->getFrame(OB_FRAME_ACCEL);
+    if(accelFrame) {
+        auto sp        = accelFrame->getStreamProfile();
+        auto accelSp   = sp->as<AccelStreamProfile>();
+        auto intrinsic = accelSp->getIntrinsic();
+
+        auto frameData   = (AccelFrame::Data *)accelFrame->getData();
+        frameData->value = correctAccel(frameData->value, &intrinsic);
+    }
+
+    auto gyroFrame = frameSet->getFrame(OB_FRAME_GYRO);
+    if(gyroFrame) {
+        auto sp        = gyroFrame->getStreamProfile();
+        auto gyroSp    = sp->as<GyroStreamProfile>();
+        auto intrinsic = gyroSp->getIntrinsic();
+
+        auto frameData   = (GyroFrame::Data *)gyroFrame->getData();
+        frameData->value = correctGyro(frameData->value, &intrinsic);
+    }
+
+    return newFrame;
+}
+
+OBAccelValue IMUCorrector::correctAccel(const OBAccelValue &accelValue, OBAccelIntrinsic *intrinsic) {
+    double M_acc[3][3];
+    double bias_acc[3];
+
+    for(int i = 0; i < 3; i++) {
+        M_acc[i][0] = intrinsic->scaleMisalignment[3 * i];
+        M_acc[i][1] = intrinsic->scaleMisalignment[3 * i + 1];
+        M_acc[i][2] = intrinsic->scaleMisalignment[3 * i + 2];
+    }
+
+    bias_acc[0] = intrinsic->bias[0];
+    bias_acc[1] = intrinsic->bias[1];
+    bias_acc[2] = intrinsic->bias[2];
+
+    double correctedAccel[3];
+    for(int i = 0; i < 3; i++) {
+        correctedAccel[i] =
+            M_acc[i][0] * (accelValue.x - bias_acc[0]) + M_acc[i][1] * (accelValue.y - bias_acc[1]) + M_acc[i][2] * (accelValue.z - bias_acc[2]);
+    }
+
+    return { static_cast<float>(correctedAccel[0]), static_cast<float>(correctedAccel[1]), static_cast<float>(correctedAccel[2]) };
+}
+
+OBGyroValue IMUCorrector::correctGyro(const OBGyroValue &gyroValue, OBGyroIntrinsic *intrinsic) {
+    double M_gyro[3][3];
+    double bias_gyro[3];
+
+    for(int i = 0; i < 3; i++) {
+        M_gyro[i][0] = intrinsic->scaleMisalignment[3 * i];
+        M_gyro[i][1] = intrinsic->scaleMisalignment[3 * i + 1];
+        M_gyro[i][2] = intrinsic->scaleMisalignment[3 * i + 2];
+    }
+
+    bias_gyro[0] = intrinsic->bias[0];
+    bias_gyro[1] = intrinsic->bias[1];
+    bias_gyro[2] = intrinsic->bias[2];
+
+    double correctedGyro[3];
+    for(int i = 0; i < 3; i++) {
+        correctedGyro[i] =
+            M_gyro[i][0] * (gyroValue.x - bias_gyro[0]) + M_gyro[i][1] * (gyroValue.y - bias_gyro[1]) + M_gyro[i][2] * (gyroValue.z - bias_gyro[2]);
+    }
+
+    return { static_cast<float>(correctedGyro[0]), static_cast<float>(correctedGyro[1]), static_cast<float>(correctedGyro[2]) };
+}
+
+}  // namespace libobsensor
+
diff --git a/src/filter/publicfilters/IMUCorrector.hpp b/src/filter/publicfilters/IMUCorrector.hpp
new file mode 100644
index 00000000..9775de1d
--- /dev/null
+++ b/src/filter/publicfilters/IMUCorrector.hpp
@@ -0,0 +1,42 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include "IFilter.hpp"
+#include "libobsensor/h/ObTypes.h"
+// #include "IProperty.hpp"
+#include "InternalTypes.hpp"
+
+namespace libobsensor {
+
+class IMUCorrector : public IFilterBase {
+public:
+    static OBIMUCalibrateParams parserIMUCalibParamRaw(uint8_t *data, uint32_t size);
+    static OBIMUCalibrateParams getDefaultImuCalibParam();
+    static float                calculateAccelGravity(int16_t accelValue, uint8_t accelFSR);
+    static float                calculateGyroDPS(int16_t gyroValue, uint8_t gyroFSR);
+    static float                calculateRegisterTemperature(int16_t tempValue);
+
+public:
+    IMUCorrector();
+
+    virtual ~IMUCorrector() = default;
+
+    // Config
+    void               updateConfig(std::vector<std::string> &params) override;
+    const std::string &getConfigSchema() const override;
+    void               reset() override {}
+
+private:
+    std::shared_ptr<Frame> process(std::shared_ptr<const Frame> frame) override;
+
+    OBAccelValue correctAccel(const OBAccelValue &accelValue, OBAccelIntrinsic *intrinsic);
+    OBGyroValue  correctGyro(const OBGyroValue &gyroValue, OBGyroIntrinsic *intrinsic);
+
+protected:
+    static constexpr float GYRO_MAX  = 32800 / 0.017453293f;
+    static constexpr float ACCEL_MAX = 32768 / 9.80f;
+};
+
+}  // namespace libobsensor
+
diff --git a/src/filter/publicfilters/IMUFrameReversion.cpp b/src/filter/publicfilters/IMUFrameReversion.cpp
new file mode 100644
index 00000000..808a61dc
--- /dev/null
+++ b/src/filter/publicfilters/IMUFrameReversion.cpp
@@ -0,0 +1,59 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "IMUFrameReversion.hpp"
+#include "frame/Frame.hpp"
+#include "frame/FrameFactory.hpp"
+#include "logger/LoggerInterval.hpp"
+#include "exception/ObException.hpp"
+#include "libobsensor/h/ObTypes.h"
+
+namespace libobsensor {
+
+IMUFrameReversion::IMUFrameReversion() {}
+
+IMUFrameReversion::~IMUFrameReversion() noexcept {}
+
+void IMUFrameReversion::updateConfig(std::vector<std::string> &params) {
+    if(params.size() != 0) {
+        throw unsupported_operation_exception("IMUFrameReversion update config error: unsupported operation.");
+    }
+}
+
+const std::string &IMUFrameReversion::getConfigSchema() const {
+    static const std::string schema = "";
+    return schema;
+}
+
+std::shared_ptr<Frame> IMUFrameReversion::process(std::shared_ptr<const Frame> frame) {
+    if(!frame) {
+        return nullptr;
+    }
+
+    auto newFrame = FrameFactory::createFrameFromOtherFrame(frame, true);
+    if(!frame->is<FrameSet>()) {
+        return newFrame;
+    }
+
+    auto frameSet   = newFrame->as<FrameSet>();
+    auto accelFrame = frameSet->getFrame(OB_FRAME_ACCEL);
+    if(accelFrame) {
+        AccelFrame::Data *frameData = (AccelFrame::Data *)accelFrame->getData();
+        frameData->value.x *= -1;
+        frameData->value.y *= -1;
+        frameData->value.z *= -1;
+    }
+
+    auto gyroFrame = frameSet->getFrame(OB_FRAME_GYRO);
+    if(gyroFrame) {
+        GyroFrame::Data *gyroFrameData = (GyroFrame::Data *)gyroFrame->getData();
+        gyroFrameData->value.x *= -1;
+        gyroFrameData->value.y *= -1;
+        gyroFrameData->value.z *= -1;
+    }
+
+    return newFrame;
+}
+
+}  // namespace libobsensor
+
diff --git a/src/filter/publicfilters/IMUFrameReversion.hpp b/src/filter/publicfilters/IMUFrameReversion.hpp
new file mode 100644
index 00000000..e8036968
--- /dev/null
+++ b/src/filter/publicfilters/IMUFrameReversion.hpp
@@ -0,0 +1,24 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include "IFilter.hpp"
+#include <mutex>
+
+namespace libobsensor {
+
+class IMUFrameReversion : public IFilterBase {
+public:
+    IMUFrameReversion();
+    virtual ~IMUFrameReversion() noexcept;
+
+    void               updateConfig(std::vector<std::string> &params) override;
+    const std::string &getConfigSchema() const override;
+    void               reset() override {}
+
+private:
+    std::shared_ptr<Frame> process(std::shared_ptr<const Frame> frame) override;
+};
+
+}  // namespace libobsensor
+
diff --git a/src/filter/publicfilters/PointCloudProcess.cpp b/src/filter/publicfilters/PointCloudProcess.cpp
new file mode 100644
index 00000000..14773fd8
--- /dev/null
+++ b/src/filter/publicfilters/PointCloudProcess.cpp
@@ -0,0 +1,304 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "PointCloudProcess.hpp"
+#include "exception/ObException.hpp"
+#include "logger/LoggerInterval.hpp"
+#include "frame/FrameFactory.hpp"
+#include "stream/StreamProfile.hpp"
+#include "libobsensor/h/ObTypes.h"
+#include "utils/CoordinateUtil.hpp"
+#include "utils/Utils.hpp"
+
+namespace libobsensor {
+
+PointCloudFilter::PointCloudFilter()
+    : pointFormat_(OB_FORMAT_POINT),
+      positionDataScale_(1.0f),
+      coordinateSystemType_(OB_RIGHT_HAND_COORDINATE_SYSTEM),
+      isColorDataNormalization_(false),
+      tablesDataSize_(0),
+      tablesData_(nullptr) {}
+
+PointCloudFilter::~PointCloudFilter() noexcept {
+    reset();
+}
+
+void PointCloudFilter::reset() {
+    if(formatConverter_) {
+        formatConverter_.reset();
+    }
+    if(tablesData_) {
+        tablesData_.reset();
+        tablesDataSize_ = 0;
+    }
+}
+
+void PointCloudFilter::updateConfig(std::vector<std::string> &params) {
+    if(params.size() != 4) {
+        throw invalid_value_exception("PointCloudFilter config error: params size not match");
+    }
+    try {
+        OBFormat type = (OBFormat)std::stoi(params[0]);
+        if(type != OB_FORMAT_POINT && type != OB_FORMAT_RGB_POINT) {
+            LOG_ERROR("Invalid type, the pointType must be OB_FORMAT_POINT or OB_FORMAT_RGB_POINT");
+        }
+        else {
+            pointFormat_ = type;
+        }
+
+        float scale = std::stof(params[1]);
+        if(scale >= 0.000009 && scale <= 100) {
+            positionDataScale_ = scale;
+        }
+
+        int colorDataNormalizationState = std::stoi(params[2]);
+        isColorDataNormalization_       = colorDataNormalizationState == 0 ? false : true;
+
+        int csType            = std::stoi(params[3]);
+        coordinateSystemType_ = static_cast<OBCoordinateSystemType>(csType);
+    }
+    catch(const std::exception &e) {
+        throw invalid_value_exception("PointCloudFilter config error: " + std::string(e.what()));
+    }
+}
+
+const std::string &PointCloudFilter::getConfigSchema() const {
+    // csv format: name，type， min，max，step，default，description
+    static const std::string schema = "pointFormat, integer, 19, 20, 1, 19, create point type: 19 is OB_FORMAT_POINT; 20 is OB_FORMAT_RGB_POINT\n"
+                                      "coordinateDataScale, float, 0.00000001, 100, 0.00001, 1.0, coordinate data scale\n"
+                                      "colorDataNormalization, integer, 0, 1, 1, 0, color data normal state\n"
+                                      "coordinateSystemType, integer, 0, 1, 1, 1, Coordinate system representation type: 0 is left hand; 1 is right hand\n";
+    return schema;
+}
+
+std::shared_ptr<Frame> PointCloudFilter::createDepthPointCloud(std::shared_ptr<const Frame> frame) {
+    std::shared_ptr<const Frame> depthFrame;
+    if(frame->is<FrameSet>()) {
+        auto frameSet = frame->as<FrameSet>();
+        depthFrame    = frameSet->getFrame(OB_FRAME_DEPTH);
+    }
+    else {
+        depthFrame = frame;
+    }
+
+    if(depthFrame == nullptr) {
+        LOG_ERROR_INTVL("No depth frame found!");
+        return nullptr;
+    }
+
+    auto depthVideoFrame         = depthFrame->as<VideoFrame>();
+    auto depthVideoStreamProfile = depthVideoFrame->getStreamProfile()->as<VideoStreamProfile>();
+    auto depthWidth              = depthVideoFrame->getWidth();
+    auto depthHeight             = depthVideoFrame->getHeight();
+    auto pointDataSize           = depthWidth * depthHeight * sizeof(OBPoint);
+
+    auto pointFrame = FrameFactory::createFrame(OB_FRAME_POINTS, OB_FORMAT_POINT, pointDataSize);
+    if(pointFrame == nullptr) {
+        LOG_ERROR_INTVL("Acquire point cloud frame failed!");
+        return nullptr;
+    }
+
+    auto frameSize = depthWidth * depthHeight * 2;
+    if(tablesData_ && tablesDataSize_ != frameSize) {
+        tablesData_.reset();
+        tablesData_ = nullptr;
+    }
+
+    if(tablesData_ == nullptr) {
+        tablesDataSize_                   = frameSize;
+        tablesData_                       = std::shared_ptr<float>(new float[tablesDataSize_], std::default_delete<float[]>());
+        OBCameraIntrinsic  depthIntrinsic = depthVideoStreamProfile->getIntrinsic();
+        OBCameraDistortion depthDisto     = depthVideoStreamProfile->getDistortion();
+        if(!CoordinateUtil::transformationInitXYTables(depthIntrinsic, depthDisto, reinterpret_cast<float *>(tablesData_.get()), &tablesDataSize_,
+                                                       &xyTables_)) {
+            LOG_ERROR_INTVL("Init transformation coordinate tables failed!");
+            tablesData_.reset();
+            return nullptr;
+        }
+    }
+
+    CoordinateUtil::transformationDepthToPointCloud(&xyTables_, depthFrame->getData(), (void *)pointFrame->getData(), positionDataScale_,
+                                                    coordinateSystemType_);
+
+    float depthValueScale = depthFrame->as<DepthFrame>()->getValueScale();
+    pointFrame->copyInfoFromOther(depthFrame);
+    // Actual coordinate scaling = Depth scaling factor / Set coordinate scaling factor.
+    pointFrame->as<PointsFrame>()->setCoordinateValueScale(depthValueScale / positionDataScale_);
+
+    return pointFrame;
+}
+
+std::shared_ptr<Frame> PointCloudFilter::createRGBDPointCloud(std::shared_ptr<const Frame> frame) {
+    if(!frame->is<FrameSet>()) {
+        LOG_ERROR_INTVL("Input frame is not a frameset, can not convert to pointcloud!");
+        return nullptr;
+    }
+
+    auto frameSet   = frame->as<FrameSet>();
+    auto depthFrame = frameSet->getFrame(OB_FRAME_DEPTH);
+    auto colorFrame = frameSet->getFrame(OB_FRAME_COLOR);
+
+    if(depthFrame == nullptr || colorFrame == nullptr) {
+        LOG_ERROR_INTVL("depth frame or color frame not found in frameset!");
+        return nullptr;
+    }
+
+    auto                       depthVideoFrame         = depthFrame->as<VideoFrame>();
+    auto                       colorVideoFrame         = colorFrame->as<VideoFrame>();
+    auto                       depthVideoStreamProfile = depthVideoFrame->getStreamProfile()->as<VideoStreamProfile>();
+    auto                       colorVideoStreamProfile = colorVideoFrame->getStreamProfile()->as<VideoStreamProfile>();
+    OBPointCloudDistortionType distortionType          = getDistortionType(colorVideoStreamProfile->getDistortion(), depthVideoStreamProfile->getDistortion());
+
+    // How C2D can recognize
+    uint32_t           dstHeight             = depthVideoFrame->getHeight();
+    uint32_t           dstWidth              = depthVideoFrame->getWidth();
+    auto               dstVideoStreamProfile = depthVideoStreamProfile;
+    OBCameraIntrinsic  dstIntrinsic          = dstVideoStreamProfile->getIntrinsic();
+    OBCameraDistortion dstDistortion         = dstVideoStreamProfile->getDistortion();
+
+    // Create an RGBD point cloud frame
+    auto pointFrame = FrameFactory::createFrame(OB_FRAME_POINTS, OB_FORMAT_RGB_POINT, dstWidth * dstHeight * sizeof(OBColorPoint));
+    if(pointFrame == nullptr) {
+        LOG_WARN_INTVL("Acquire point cloud frame failed!");
+        return nullptr;
+    }
+
+    // decode rgb frame
+    if(formatConverter_ == nullptr) {
+        formatConverter_ = std::make_shared<FormatConverter>();
+    }
+
+    std::shared_ptr<const Frame> tarFrame;
+    std::vector<std::string>     params;
+    switch(colorFrame->getFormat()) {
+    case OB_FORMAT_YUYV:
+        // FORMAT_YUYV_TO_RGB
+        params.push_back("0");
+        formatConverter_->updateConfig(params);
+        break;
+    case OB_FORMAT_UYVY:
+        // FORMAT_UYVY_TO_RGB888
+        params.push_back("10");
+        formatConverter_->updateConfig(params);
+        break;
+    case OB_FORMAT_I420:
+        // FORMAT_I420_TO_RGB888
+        params.push_back("1");
+        formatConverter_->updateConfig(params);
+        break;
+    case OB_FORMAT_MJPG:
+        // FORMAT_MJPG_TO_RGB888
+        params.push_back("7");
+        formatConverter_->updateConfig(params);
+        break;
+    case OB_FORMAT_NV21:
+        // FORMAT_NV21_TO_RGB888
+        params.push_back("2");
+        formatConverter_->updateConfig(params);
+        break;
+    case OB_FORMAT_NV12:
+        // FORMAT_NV12_TO_RGB888
+        params.push_back("3");
+        formatConverter_->updateConfig(params);
+        break;
+    case OB_FORMAT_RGB:
+        tarFrame = colorFrame;
+        break;
+    default:
+        throw unsupported_operation_exception("unsupported color format for RgbDepth pointCloud convert!");
+    }
+
+    uint8_t *colorData = nullptr;
+    if(colorFrame->getFormat() != OB_FORMAT_RGB) {
+        tarFrame = formatConverter_->process(colorFrame);
+    }
+
+    if(tarFrame) {
+        colorData = (uint8_t *)tarFrame->getData();
+    }
+    else {
+        LOG_ERROR_INTVL("get rgb data failed!");
+        return nullptr;
+    }
+
+    auto frameSize = dstWidth * dstHeight * 2;
+    if(tablesData_ && tablesDataSize_ != frameSize) {
+        tablesData_.reset();
+        tablesData_ = nullptr;
+    }
+
+    if(tablesData_ == nullptr) {
+        tablesDataSize_ = frameSize;
+        tablesData_     = std::shared_ptr<float>(new float[tablesDataSize_], std::default_delete<float[]>());
+        if(distortionType == OBPointCloudDistortionType::OB_POINT_CLOUD_ZERO_DISTORTION_TYPE) {
+            memset(&dstDistortion, 0, sizeof(OBCameraDistortion));
+        }
+
+        if(distortionType == OBPointCloudDistortionType::OB_POINT_CLOUD_ADD_DISTORTION_TYPE) {
+            if(!CoordinateUtil::transformationInitAddDistortionUVTables(dstIntrinsic, dstDistortion, reinterpret_cast<float *>(tablesData_.get()),
+                                                                        &tablesDataSize_, &xyTables_)) {
+                LOG_ERROR_INTVL("Init add distortion transformation coordinate tables failed!");
+                return nullptr;
+            }
+        }
+        else {
+            if(!CoordinateUtil::transformationInitXYTables(dstIntrinsic, dstDistortion, reinterpret_cast<float *>(tablesData_.get()), &tablesDataSize_,
+                                                           &xyTables_)) {
+                LOG_ERROR_INTVL("Init transformation coordinate tables failed!");
+                return nullptr;
+            }
+        }
+    }
+
+    if(distortionType == OBPointCloudDistortionType::OB_POINT_CLOUD_ADD_DISTORTION_TYPE) {
+        CoordinateUtil::transformationDepthToRGBDPointCloudByUVTables(dstIntrinsic, &xyTables_, depthFrame->getData(), colorData, (void *)pointFrame->getData(),
+                                                                      positionDataScale_, coordinateSystemType_, isColorDataNormalization_);
+    }
+    else {
+        CoordinateUtil::transformationDepthToRGBDPointCloud(&xyTables_, depthFrame->getData(), colorData, (void *)pointFrame->getData(), positionDataScale_,
+                                                            coordinateSystemType_, isColorDataNormalization_);
+    }
+
+    float depthValueScale = depthVideoFrame->as<DepthFrame>()->getValueScale();
+    pointFrame->copyInfoFromOther(depthFrame);
+    // Actual coordinate scaling = Depth scaling factor / Set coordinate scaling factor.
+    pointFrame->as<PointsFrame>()->setCoordinateValueScale(depthValueScale / positionDataScale_);
+    return pointFrame;
+}
+
+std::shared_ptr<Frame> PointCloudFilter::process(std::shared_ptr<const Frame> frame) {
+    if(!frame) {
+        return nullptr;
+    }
+
+    std::shared_ptr<Frame> pointsFrame = nullptr;
+    if(pointFormat_ == OB_FORMAT_POINT) {
+        pointsFrame = createDepthPointCloud(frame);
+    }
+    else {
+        pointsFrame = createRGBDPointCloud(frame);
+    }
+    return pointsFrame;
+}
+
+PointCloudFilter::OBPointCloudDistortionType PointCloudFilter::getDistortionType(OBCameraDistortion colorDistortion, OBCameraDistortion depthDistortion) {
+    OBPointCloudDistortionType type;
+    OBCameraDistortion         zeroDistortion;
+    memset(&zeroDistortion, 0, sizeof(OBCameraDistortion));
+
+    if(memcmp(&colorDistortion, &depthDistortion, sizeof(OBCameraDistortion)) == 0) {
+        type = OBPointCloudDistortionType::OB_POINT_CLOUD_UN_DISTORTION_TYPE;
+    }
+    else if((memcmp(&depthDistortion, &zeroDistortion, sizeof(OBCameraDistortion)) == 0)
+            && (memcmp(&colorDistortion, &zeroDistortion, sizeof(OBCameraDistortion)) != 0)) {
+        type = OBPointCloudDistortionType::OB_POINT_CLOUD_ADD_DISTORTION_TYPE;
+    }
+    else {
+        type = OBPointCloudDistortionType::OB_POINT_CLOUD_ZERO_DISTORTION_TYPE;
+    }
+    return type;
+}
+
+}  // namespace libobsensor
+
diff --git a/src/filter/publicfilters/PointCloudProcess.hpp b/src/filter/publicfilters/PointCloudProcess.hpp
new file mode 100644
index 00000000..e31e9a61
--- /dev/null
+++ b/src/filter/publicfilters/PointCloudProcess.hpp
@@ -0,0 +1,58 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include "IFilter.hpp"
+#include "FormatConverterProcess.hpp"
+#include <mutex>
+
+namespace libobsensor {
+
+class PointCloudFilter : public IFilterBase {
+    enum class OBPointCloudDistortionType {
+        // The depth camera already includes the distortion from the color camera.
+        // When converting to a point cloud, distortion correction is needed.
+        OB_POINT_CLOUD_UN_DISTORTION_TYPE = 0,
+
+        // The depth camera does not include the distortion from the color camera.
+        // When converting to a point cloud, the distortion from the color camera should be added,
+        // and then distortion correction should be performed.
+        OB_POINT_CLOUD_ADD_DISTORTION_TYPE,
+
+        // The depth camera has non-zero distortion parameters, and the color camera also has non-zero distortion parameters.
+        // This might indicate an abnormality in the module parameters. By default, it is assumed that the distortion is zero.
+        OB_POINT_CLOUD_ZERO_DISTORTION_TYPE,
+    };
+
+public:
+    PointCloudFilter();
+    virtual ~PointCloudFilter() noexcept;
+
+    void reset() override;
+
+    void               updateConfig(std::vector<std::string> &params) override;
+    const std::string &getConfigSchema() const override;
+
+private:
+    std::shared_ptr<Frame> createDepthPointCloud(std::shared_ptr<const Frame> frame);
+    std::shared_ptr<Frame> createRGBDPointCloud(std::shared_ptr<const Frame> frame);
+
+    std::shared_ptr<Frame> process(std::shared_ptr<const Frame> frame) override;
+
+    PointCloudFilter::OBPointCloudDistortionType getDistortionType(OBCameraDistortion colorDistortion, OBCameraDistortion depthDistortion);
+
+protected:
+    OBFormat               pointFormat_;
+    float                  positionDataScale_;
+    OBCoordinateSystemType coordinateSystemType_;
+    bool                   isColorDataNormalization_;
+
+    std::shared_ptr<FormatConverter> formatConverter_;
+
+    uint32_t               tablesDataSize_;
+    std::shared_ptr<float> tablesData_;
+    OBXYTables             xyTables_;
+};
+
+}  // namespace libobsensor
+
diff --git a/src/filter/publicfilters/SSE2NEON.h b/src/filter/publicfilters/SSE2NEON.h
new file mode 100644
index 00000000..de633650
--- /dev/null
+++ b/src/filter/publicfilters/SSE2NEON.h
@@ -0,0 +1,9282 @@
+#pragma once
+#ifdef __NEON__
+
+/*
+ * sse2neon is freely redistributable under the MIT License.
+ *
+ * Copyright (c) 2015-2024 SSE2NEON Contributors.
+ *
+ * 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.
+ */
+
+// This header file provides a simple API translation layer
+// between SSE intrinsics to their corresponding Arm/Aarch64 NEON versions
+//
+// Contributors to this work are:
+//   John W. Ratcliff <jratcliffscarab@gmail.com>
+//   Brandon Rowlett <browlett@nvidia.com>
+//   Ken Fast <kfast@gdeb.com>
+//   Eric van Beurden <evanbeurden@nvidia.com>
+//   Alexander Potylitsin <apotylitsin@nvidia.com>
+//   Hasindu Gamaarachchi <hasindu2008@gmail.com>
+//   Jim Huang <jserv@ccns.ncku.edu.tw>
+//   Mark Cheng <marktwtn@gmail.com>
+//   Malcolm James MacLeod <malcolm@gulden.com>
+//   Devin Hussey (easyaspi314) <husseydevin@gmail.com>
+//   Sebastian Pop <spop@amazon.com>
+//   Developer Ecosystem Engineering <DeveloperEcosystemEngineering@apple.com>
+//   Danila Kutenin <danilak@google.com>
+//   François Turban (JishinMaster) <francois.turban@gmail.com>
+//   Pei-Hsuan Hung <afcidk@gmail.com>
+//   Yang-Hao Yuan <yuanyanghau@gmail.com>
+//   Syoyo Fujita <syoyo@lighttransport.com>
+//   Brecht Van Lommel <brecht@blender.org>
+//   Jonathan Hue <jhue@adobe.com>
+//   Cuda Chen <clh960524@gmail.com>
+//   Aymen Qader <aymen.qader@arm.com>
+//   Anthony Roberts <anthony.roberts@linaro.org>
+
+/* Tunable configurations */
+
+/* Enable precise implementation of math operations
+ * This would slow down the computation a bit, but gives consistent result with
+ * x86 SSE. (e.g. would solve a hole or NaN pixel in the rendering result)
+ */
+/* _mm_min|max_ps|ss|pd|sd */
+#ifndef SSE2NEON_PRECISE_MINMAX
+#define SSE2NEON_PRECISE_MINMAX (0)
+#endif
+/* _mm_rcp_ps and _mm_div_ps */
+#ifndef SSE2NEON_PRECISE_DIV
+#define SSE2NEON_PRECISE_DIV (0)
+#endif
+/* _mm_sqrt_ps and _mm_rsqrt_ps */
+#ifndef SSE2NEON_PRECISE_SQRT
+#define SSE2NEON_PRECISE_SQRT (0)
+#endif
+/* _mm_dp_pd */
+#ifndef SSE2NEON_PRECISE_DP
+#define SSE2NEON_PRECISE_DP (0)
+#endif
+
+/* Enable inclusion of windows.h on MSVC platforms
+ * This makes _mm_clflush functional on windows, as there is no builtin.
+ */
+#ifndef SSE2NEON_INCLUDE_WINDOWS_H
+#define SSE2NEON_INCLUDE_WINDOWS_H (0)
+#endif
+
+/* compiler specific definitions */
+#if defined(__GNUC__) || defined(__clang__)
+#pragma push_macro("FORCE_INLINE")
+#pragma push_macro("ALIGN_STRUCT")
+#define FORCE_INLINE static inline __attribute__((always_inline))
+#define ALIGN_STRUCT(x) __attribute__((aligned(x)))
+#define _sse2neon_likely(x) __builtin_expect(!!(x), 1)
+#define _sse2neon_unlikely(x) __builtin_expect(!!(x), 0)
+#elif defined(_MSC_VER)
+#if _MSVC_TRADITIONAL
+#error Using the traditional MSVC preprocessor is not supported! Use /Zc:preprocessor instead.
+#endif
+#ifndef FORCE_INLINE
+#define FORCE_INLINE static inline
+#endif
+#ifndef ALIGN_STRUCT
+#define ALIGN_STRUCT(x) __declspec(align(x))
+#endif
+#define _sse2neon_likely(x) (x)
+#define _sse2neon_unlikely(x) (x)
+#else
+#pragma message("Macro name collisions may happen with unsupported compilers.")
+#endif
+
+
+/* C language does not allow initializing a variable with a function call. */
+#ifdef __cplusplus
+#define _sse2neon_const static const
+#else
+#define _sse2neon_const const
+#endif
+
+#include <stdint.h>
+#include <stdlib.h>
+
+#if defined(_WIN32)
+/* Definitions for _mm_{malloc,free} are provided by <malloc.h>
+ * from both MinGW-w64 and MSVC.
+ */
+#define SSE2NEON_ALLOC_DEFINED
+#endif
+
+/* If using MSVC */
+#ifdef _MSC_VER
+#include <intrin.h>
+#if SSE2NEON_INCLUDE_WINDOWS_H
+#include <processthreadsapi.h>
+#include <windows.h>
+#endif
+
+#if !defined(__cplusplus)
+#error SSE2NEON only supports C++ compilation with this compiler
+#endif
+
+#ifdef SSE2NEON_ALLOC_DEFINED
+#include <malloc.h>
+#endif
+
+#if (defined(_M_AMD64) || defined(__x86_64__)) || \
+    (defined(_M_ARM64) || defined(__arm64__))
+#define SSE2NEON_HAS_BITSCAN64
+#endif
+#endif
+
+#if defined(__GNUC__) || defined(__clang__)
+#define _sse2neon_define0(type, s, body) \
+    __extension__({                      \
+        type _a = (s);                   \
+        body                             \
+    })
+#define _sse2neon_define1(type, s, body) \
+    __extension__({                      \
+        type _a = (s);                   \
+        body                             \
+    })
+#define _sse2neon_define2(type, a, b, body) \
+    __extension__({                         \
+        type _a = (a), _b = (b);            \
+        body                                \
+    })
+#define _sse2neon_return(ret) (ret)
+#else
+#define _sse2neon_define0(type, a, body) [=](type _a) { body }(a)
+#define _sse2neon_define1(type, a, body) [](type _a) { body }(a)
+#define _sse2neon_define2(type, a, b, body) \
+    [](type _a, type _b) { body }((a), (b))
+#define _sse2neon_return(ret) return ret
+#endif
+
+#define _sse2neon_init(...) \
+    {                       \
+        __VA_ARGS__         \
+    }
+
+/* Compiler barrier */
+#if defined(_MSC_VER)
+#define SSE2NEON_BARRIER() _ReadWriteBarrier()
+#else
+#define SSE2NEON_BARRIER()                     \
+    do {                                       \
+        __asm__ __volatile__("" ::: "memory"); \
+        (void) 0;                              \
+    } while (0)
+#endif
+
+/* Memory barriers
+ * __atomic_thread_fence does not include a compiler barrier; instead,
+ * the barrier is part of __atomic_load/__atomic_store's "volatile-like"
+ * semantics.
+ */
+#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)
+#include <stdatomic.h>
+#endif
+
+FORCE_INLINE void _sse2neon_smp_mb(void)
+{
+    SSE2NEON_BARRIER();
+#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L) && \
+    !defined(__STDC_NO_ATOMICS__)
+    atomic_thread_fence(memory_order_seq_cst);
+#elif defined(__GNUC__) || defined(__clang__)
+    __atomic_thread_fence(__ATOMIC_SEQ_CST);
+#else /* MSVC */
+    __dmb(_ARM64_BARRIER_ISH);
+#endif
+}
+
+/* Architecture-specific build options */
+/* FIXME: #pragma GCC push_options is only available on GCC */
+#if defined(__GNUC__)
+#if defined(__arm__) && __ARM_ARCH == 7
+/* According to ARM C Language Extensions Architecture specification,
+ * __ARM_NEON is defined to a value indicating the Advanced SIMD (NEON)
+ * architecture supported.
+ */
+#if !defined(__ARM_NEON) || !defined(__ARM_NEON__)
+#error "You must enable NEON instructions (e.g. -mfpu=neon) to use SSE2NEON."
+#endif
+#if !defined(__clang__)
+#pragma GCC push_options
+#pragma GCC target("fpu=neon")
+#endif
+#elif defined(__aarch64__) || defined(_M_ARM64)
+#if !defined(__clang__) && !defined(_MSC_VER)
+#pragma GCC push_options
+#pragma GCC target("+simd")
+#endif
+#elif __ARM_ARCH == 8
+#if !defined(__ARM_NEON) || !defined(__ARM_NEON__)
+#error \
+    "You must enable NEON instructions (e.g. -mfpu=neon-fp-armv8) to use SSE2NEON."
+#endif
+#if !defined(__clang__) && !defined(_MSC_VER)
+#pragma GCC push_options
+#endif
+#else
+#error \
+    "Unsupported target. Must be either ARMv7-A+NEON or ARMv8-A \
+(you could try setting target explicitly with -march or -mcpu)"
+#endif
+#endif
+
+#include <arm_neon.h>
+#if (!defined(__aarch64__) && !defined(_M_ARM64)) && (__ARM_ARCH == 8)
+#if defined __has_include && __has_include(<arm_acle.h>)
+#include <arm_acle.h>
+#endif
+#endif
+
+/* Apple Silicon cache lines are double of what is commonly used by Intel, AMD
+ * and other Arm microarchitectures use.
+ * From sysctl -a on Apple M1:
+ * hw.cachelinesize: 128
+ */
+#if defined(__APPLE__) && (defined(__aarch64__) || defined(__arm64__))
+#define SSE2NEON_CACHELINE_SIZE 128
+#else
+#define SSE2NEON_CACHELINE_SIZE 64
+#endif
+
+/* Rounding functions require either Aarch64 instructions or libm fallback */
+#if !defined(__aarch64__) && !defined(_M_ARM64)
+#include <math.h>
+#endif
+
+/* On ARMv7, some registers, such as PMUSERENR and PMCCNTR, are read-only
+ * or even not accessible in user mode.
+ * To write or access to these registers in user mode,
+ * we have to perform syscall instead.
+ */
+#if (!defined(__aarch64__) && !defined(_M_ARM64))
+#include <sys/time.h>
+#endif
+
+/* "__has_builtin" can be used to query support for built-in functions
+ * provided by gcc/clang and other compilers that support it.
+ */
+#ifndef __has_builtin /* GCC prior to 10 or non-clang compilers */
+/* Compatibility with gcc <= 9 */
+#if defined(__GNUC__) && (__GNUC__ <= 9)
+#define __has_builtin(x) HAS##x
+#define HAS__builtin_popcount 1
+#define HAS__builtin_popcountll 1
+
+// __builtin_shuffle introduced in GCC 4.7.0
+#if (__GNUC__ >= 5) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7))
+#define HAS__builtin_shuffle 1
+#else
+#define HAS__builtin_shuffle 0
+#endif
+
+#define HAS__builtin_shufflevector 0
+#define HAS__builtin_nontemporal_store 0
+#else
+#define __has_builtin(x) 0
+#endif
+#endif
+
+/**
+ * MACRO for shuffle parameter for _mm_shuffle_ps().
+ * Argument fp3 is a digit[0123] that represents the fp from argument "b"
+ * of mm_shuffle_ps that will be placed in fp3 of result. fp2 is the same
+ * for fp2 in result. fp1 is a digit[0123] that represents the fp from
+ * argument "a" of mm_shuffle_ps that will be places in fp1 of result.
+ * fp0 is the same for fp0 of result.
+ */
+#define _MM_SHUFFLE(fp3, fp2, fp1, fp0) \
+    (((fp3) << 6) | ((fp2) << 4) | ((fp1) << 2) | ((fp0)))
+
+#if __has_builtin(__builtin_shufflevector)
+#define _sse2neon_shuffle(type, a, b, ...) \
+    __builtin_shufflevector(a, b, __VA_ARGS__)
+#elif __has_builtin(__builtin_shuffle)
+#define _sse2neon_shuffle(type, a, b, ...) \
+    __extension__({                        \
+        type tmp = {__VA_ARGS__};          \
+        __builtin_shuffle(a, b, tmp);      \
+    })
+#endif
+
+#ifdef _sse2neon_shuffle
+#define vshuffle_s16(a, b, ...) _sse2neon_shuffle(int16x4_t, a, b, __VA_ARGS__)
+#define vshuffleq_s16(a, b, ...) _sse2neon_shuffle(int16x8_t, a, b, __VA_ARGS__)
+#define vshuffle_s32(a, b, ...) _sse2neon_shuffle(int32x2_t, a, b, __VA_ARGS__)
+#define vshuffleq_s32(a, b, ...) _sse2neon_shuffle(int32x4_t, a, b, __VA_ARGS__)
+#define vshuffle_s64(a, b, ...) _sse2neon_shuffle(int64x1_t, a, b, __VA_ARGS__)
+#define vshuffleq_s64(a, b, ...) _sse2neon_shuffle(int64x2_t, a, b, __VA_ARGS__)
+#endif
+
+/* Rounding mode macros. */
+#define _MM_FROUND_TO_NEAREST_INT 0x00
+#define _MM_FROUND_TO_NEG_INF 0x01
+#define _MM_FROUND_TO_POS_INF 0x02
+#define _MM_FROUND_TO_ZERO 0x03
+#define _MM_FROUND_CUR_DIRECTION 0x04
+#define _MM_FROUND_NO_EXC 0x08
+#define _MM_FROUND_RAISE_EXC 0x00
+#define _MM_FROUND_NINT (_MM_FROUND_TO_NEAREST_INT | _MM_FROUND_RAISE_EXC)
+#define _MM_FROUND_FLOOR (_MM_FROUND_TO_NEG_INF | _MM_FROUND_RAISE_EXC)
+#define _MM_FROUND_CEIL (_MM_FROUND_TO_POS_INF | _MM_FROUND_RAISE_EXC)
+#define _MM_FROUND_TRUNC (_MM_FROUND_TO_ZERO | _MM_FROUND_RAISE_EXC)
+#define _MM_FROUND_RINT (_MM_FROUND_CUR_DIRECTION | _MM_FROUND_RAISE_EXC)
+#define _MM_FROUND_NEARBYINT (_MM_FROUND_CUR_DIRECTION | _MM_FROUND_NO_EXC)
+#define _MM_ROUND_NEAREST 0x0000
+#define _MM_ROUND_DOWN 0x2000
+#define _MM_ROUND_UP 0x4000
+#define _MM_ROUND_TOWARD_ZERO 0x6000
+/* Flush zero mode macros. */
+#define _MM_FLUSH_ZERO_MASK 0x8000
+#define _MM_FLUSH_ZERO_ON 0x8000
+#define _MM_FLUSH_ZERO_OFF 0x0000
+/* Denormals are zeros mode macros. */
+#define _MM_DENORMALS_ZERO_MASK 0x0040
+#define _MM_DENORMALS_ZERO_ON 0x0040
+#define _MM_DENORMALS_ZERO_OFF 0x0000
+
+/* indicate immediate constant argument in a given range */
+#define __constrange(a, b) const
+
+/* A few intrinsics accept traditional data types like ints or floats, but
+ * most operate on data types that are specific to SSE.
+ * If a vector type ends in d, it contains doubles, and if it does not have
+ * a suffix, it contains floats. An integer vector type can contain any type
+ * of integer, from chars to shorts to unsigned long longs.
+ */
+typedef int64x1_t __m64;
+typedef float32x4_t __m128; /* 128-bit vector containing 4 floats */
+// On ARM 32-bit architecture, the float64x2_t is not supported.
+// The data type __m128d should be represented in a different way for related
+// intrinsic conversion.
+#if defined(__aarch64__) || defined(_M_ARM64)
+typedef float64x2_t __m128d; /* 128-bit vector containing 2 doubles */
+#else
+typedef float32x4_t __m128d;
+#endif
+typedef int64x2_t __m128i; /* 128-bit vector containing integers */
+
+// __int64 is defined in the Intrinsics Guide which maps to different datatype
+// in different data model
+#if !(defined(_WIN32) || defined(_WIN64) || defined(__int64))
+#if (defined(__x86_64__) || defined(__i386__))
+#define __int64 long long
+#else
+#define __int64 int64_t
+#endif
+#endif
+
+/* type-safe casting between types */
+
+#define vreinterpretq_m128_f16(x) vreinterpretq_f32_f16(x)
+#define vreinterpretq_m128_f32(x) (x)
+#define vreinterpretq_m128_f64(x) vreinterpretq_f32_f64(x)
+
+#define vreinterpretq_m128_u8(x) vreinterpretq_f32_u8(x)
+#define vreinterpretq_m128_u16(x) vreinterpretq_f32_u16(x)
+#define vreinterpretq_m128_u32(x) vreinterpretq_f32_u32(x)
+#define vreinterpretq_m128_u64(x) vreinterpretq_f32_u64(x)
+
+#define vreinterpretq_m128_s8(x) vreinterpretq_f32_s8(x)
+#define vreinterpretq_m128_s16(x) vreinterpretq_f32_s16(x)
+#define vreinterpretq_m128_s32(x) vreinterpretq_f32_s32(x)
+#define vreinterpretq_m128_s64(x) vreinterpretq_f32_s64(x)
+
+#define vreinterpretq_f16_m128(x) vreinterpretq_f16_f32(x)
+#define vreinterpretq_f32_m128(x) (x)
+#define vreinterpretq_f64_m128(x) vreinterpretq_f64_f32(x)
+
+#define vreinterpretq_u8_m128(x) vreinterpretq_u8_f32(x)
+#define vreinterpretq_u16_m128(x) vreinterpretq_u16_f32(x)
+#define vreinterpretq_u32_m128(x) vreinterpretq_u32_f32(x)
+#define vreinterpretq_u64_m128(x) vreinterpretq_u64_f32(x)
+
+#define vreinterpretq_s8_m128(x) vreinterpretq_s8_f32(x)
+#define vreinterpretq_s16_m128(x) vreinterpretq_s16_f32(x)
+#define vreinterpretq_s32_m128(x) vreinterpretq_s32_f32(x)
+#define vreinterpretq_s64_m128(x) vreinterpretq_s64_f32(x)
+
+#define vreinterpretq_m128i_s8(x) vreinterpretq_s64_s8(x)
+#define vreinterpretq_m128i_s16(x) vreinterpretq_s64_s16(x)
+#define vreinterpretq_m128i_s32(x) vreinterpretq_s64_s32(x)
+#define vreinterpretq_m128i_s64(x) (x)
+
+#define vreinterpretq_m128i_u8(x) vreinterpretq_s64_u8(x)
+#define vreinterpretq_m128i_u16(x) vreinterpretq_s64_u16(x)
+#define vreinterpretq_m128i_u32(x) vreinterpretq_s64_u32(x)
+#define vreinterpretq_m128i_u64(x) vreinterpretq_s64_u64(x)
+
+#define vreinterpretq_f32_m128i(x) vreinterpretq_f32_s64(x)
+#define vreinterpretq_f64_m128i(x) vreinterpretq_f64_s64(x)
+
+#define vreinterpretq_s8_m128i(x) vreinterpretq_s8_s64(x)
+#define vreinterpretq_s16_m128i(x) vreinterpretq_s16_s64(x)
+#define vreinterpretq_s32_m128i(x) vreinterpretq_s32_s64(x)
+#define vreinterpretq_s64_m128i(x) (x)
+
+#define vreinterpretq_u8_m128i(x) vreinterpretq_u8_s64(x)
+#define vreinterpretq_u16_m128i(x) vreinterpretq_u16_s64(x)
+#define vreinterpretq_u32_m128i(x) vreinterpretq_u32_s64(x)
+#define vreinterpretq_u64_m128i(x) vreinterpretq_u64_s64(x)
+
+#define vreinterpret_m64_s8(x) vreinterpret_s64_s8(x)
+#define vreinterpret_m64_s16(x) vreinterpret_s64_s16(x)
+#define vreinterpret_m64_s32(x) vreinterpret_s64_s32(x)
+#define vreinterpret_m64_s64(x) (x)
+
+#define vreinterpret_m64_u8(x) vreinterpret_s64_u8(x)
+#define vreinterpret_m64_u16(x) vreinterpret_s64_u16(x)
+#define vreinterpret_m64_u32(x) vreinterpret_s64_u32(x)
+#define vreinterpret_m64_u64(x) vreinterpret_s64_u64(x)
+
+#define vreinterpret_m64_f16(x) vreinterpret_s64_f16(x)
+#define vreinterpret_m64_f32(x) vreinterpret_s64_f32(x)
+#define vreinterpret_m64_f64(x) vreinterpret_s64_f64(x)
+
+#define vreinterpret_u8_m64(x) vreinterpret_u8_s64(x)
+#define vreinterpret_u16_m64(x) vreinterpret_u16_s64(x)
+#define vreinterpret_u32_m64(x) vreinterpret_u32_s64(x)
+#define vreinterpret_u64_m64(x) vreinterpret_u64_s64(x)
+
+#define vreinterpret_s8_m64(x) vreinterpret_s8_s64(x)
+#define vreinterpret_s16_m64(x) vreinterpret_s16_s64(x)
+#define vreinterpret_s32_m64(x) vreinterpret_s32_s64(x)
+#define vreinterpret_s64_m64(x) (x)
+
+#define vreinterpret_f32_m64(x) vreinterpret_f32_s64(x)
+
+#if defined(__aarch64__) || defined(_M_ARM64)
+#define vreinterpretq_m128d_s32(x) vreinterpretq_f64_s32(x)
+#define vreinterpretq_m128d_s64(x) vreinterpretq_f64_s64(x)
+
+#define vreinterpretq_m128d_u64(x) vreinterpretq_f64_u64(x)
+
+#define vreinterpretq_m128d_f32(x) vreinterpretq_f64_f32(x)
+#define vreinterpretq_m128d_f64(x) (x)
+
+#define vreinterpretq_s64_m128d(x) vreinterpretq_s64_f64(x)
+
+#define vreinterpretq_u32_m128d(x) vreinterpretq_u32_f64(x)
+#define vreinterpretq_u64_m128d(x) vreinterpretq_u64_f64(x)
+
+#define vreinterpretq_f64_m128d(x) (x)
+#define vreinterpretq_f32_m128d(x) vreinterpretq_f32_f64(x)
+#else
+#define vreinterpretq_m128d_s32(x) vreinterpretq_f32_s32(x)
+#define vreinterpretq_m128d_s64(x) vreinterpretq_f32_s64(x)
+
+#define vreinterpretq_m128d_u32(x) vreinterpretq_f32_u32(x)
+#define vreinterpretq_m128d_u64(x) vreinterpretq_f32_u64(x)
+
+#define vreinterpretq_m128d_f32(x) (x)
+
+#define vreinterpretq_s64_m128d(x) vreinterpretq_s64_f32(x)
+
+#define vreinterpretq_u32_m128d(x) vreinterpretq_u32_f32(x)
+#define vreinterpretq_u64_m128d(x) vreinterpretq_u64_f32(x)
+
+#define vreinterpretq_f32_m128d(x) (x)
+#endif
+
+// A struct is defined in this header file called 'SIMDVec' which can be used
+// by applications which attempt to access the contents of an __m128 struct
+// directly.  It is important to note that accessing the __m128 struct directly
+// is bad coding practice by Microsoft: @see:
+// https://learn.microsoft.com/en-us/cpp/cpp/m128
+//
+// However, some legacy source code may try to access the contents of an __m128
+// struct directly so the developer can use the SIMDVec as an alias for it.  Any
+// casting must be done manually by the developer, as you cannot cast or
+// otherwise alias the base NEON data type for intrinsic operations.
+//
+// union intended to allow direct access to an __m128 variable using the names
+// that the MSVC compiler provides.  This union should really only be used when
+// trying to access the members of the vector as integer values.  GCC/clang
+// allow native access to the float members through a simple array access
+// operator (in C since 4.6, in C++ since 4.8).
+//
+// Ideally direct accesses to SIMD vectors should not be used since it can cause
+// a performance hit.  If it really is needed however, the original __m128
+// variable can be aliased with a pointer to this union and used to access
+// individual components.  The use of this union should be hidden behind a macro
+// that is used throughout the codebase to access the members instead of always
+// declaring this type of variable.
+typedef union ALIGN_STRUCT(16) SIMDVec {
+    float m128_f32[4];     // as floats - DON'T USE. Added for convenience.
+    int8_t m128_i8[16];    // as signed 8-bit integers.
+    int16_t m128_i16[8];   // as signed 16-bit integers.
+    int32_t m128_i32[4];   // as signed 32-bit integers.
+    int64_t m128_i64[2];   // as signed 64-bit integers.
+    uint8_t m128_u8[16];   // as unsigned 8-bit integers.
+    uint16_t m128_u16[8];  // as unsigned 16-bit integers.
+    uint32_t m128_u32[4];  // as unsigned 32-bit integers.
+    uint64_t m128_u64[2];  // as unsigned 64-bit integers.
+} SIMDVec;
+
+// casting using SIMDVec
+#define vreinterpretq_nth_u64_m128i(x, n) (((SIMDVec *) &x)->m128_u64[n])
+#define vreinterpretq_nth_u32_m128i(x, n) (((SIMDVec *) &x)->m128_u32[n])
+#define vreinterpretq_nth_u8_m128i(x, n) (((SIMDVec *) &x)->m128_u8[n])
+
+/* SSE macros */
+#define _MM_GET_FLUSH_ZERO_MODE _sse2neon_mm_get_flush_zero_mode
+#define _MM_SET_FLUSH_ZERO_MODE _sse2neon_mm_set_flush_zero_mode
+#define _MM_GET_DENORMALS_ZERO_MODE _sse2neon_mm_get_denormals_zero_mode
+#define _MM_SET_DENORMALS_ZERO_MODE _sse2neon_mm_set_denormals_zero_mode
+
+// Function declaration
+// SSE
+FORCE_INLINE unsigned int _MM_GET_ROUNDING_MODE(void);
+FORCE_INLINE __m128 _mm_move_ss(__m128, __m128);
+FORCE_INLINE __m128 _mm_or_ps(__m128, __m128);
+FORCE_INLINE __m128 _mm_set_ps1(float);
+FORCE_INLINE __m128 _mm_setzero_ps(void);
+// SSE2
+FORCE_INLINE __m128i _mm_and_si128(__m128i, __m128i);
+FORCE_INLINE __m128i _mm_castps_si128(__m128);
+FORCE_INLINE __m128i _mm_cmpeq_epi32(__m128i, __m128i);
+FORCE_INLINE __m128i _mm_cvtps_epi32(__m128);
+FORCE_INLINE __m128d _mm_move_sd(__m128d, __m128d);
+FORCE_INLINE __m128i _mm_or_si128(__m128i, __m128i);
+FORCE_INLINE __m128i _mm_set_epi32(int, int, int, int);
+FORCE_INLINE __m128i _mm_set_epi64x(int64_t, int64_t);
+FORCE_INLINE __m128d _mm_set_pd(double, double);
+FORCE_INLINE __m128i _mm_set1_epi32(int);
+FORCE_INLINE __m128i _mm_setzero_si128(void);
+// SSE4.1
+FORCE_INLINE __m128d _mm_ceil_pd(__m128d);
+FORCE_INLINE __m128 _mm_ceil_ps(__m128);
+FORCE_INLINE __m128d _mm_floor_pd(__m128d);
+FORCE_INLINE __m128 _mm_floor_ps(__m128);
+FORCE_INLINE __m128d _mm_round_pd(__m128d, int);
+FORCE_INLINE __m128 _mm_round_ps(__m128, int);
+// SSE4.2
+FORCE_INLINE uint32_t _mm_crc32_u8(uint32_t, uint8_t);
+
+/* Backwards compatibility for compilers with lack of specific type support */
+
+// Older gcc does not define vld1q_u8_x4 type
+#if defined(__GNUC__) && !defined(__clang__) &&                        \
+    ((__GNUC__ <= 13 && defined(__arm__)) ||                           \
+     (__GNUC__ == 10 && __GNUC_MINOR__ < 3 && defined(__aarch64__)) || \
+     (__GNUC__ <= 9 && defined(__aarch64__)))
+FORCE_INLINE uint8x16x4_t _sse2neon_vld1q_u8_x4(const uint8_t *p)
+{
+    uint8x16x4_t ret;
+    ret.val[0] = vld1q_u8(p + 0);
+    ret.val[1] = vld1q_u8(p + 16);
+    ret.val[2] = vld1q_u8(p + 32);
+    ret.val[3] = vld1q_u8(p + 48);
+    return ret;
+}
+#else
+// Wraps vld1q_u8_x4
+FORCE_INLINE uint8x16x4_t _sse2neon_vld1q_u8_x4(const uint8_t *p)
+{
+    return vld1q_u8_x4(p);
+}
+#endif
+
+#if !defined(__aarch64__) && !defined(_M_ARM64)
+/* emulate vaddv u8 variant */
+FORCE_INLINE uint8_t _sse2neon_vaddv_u8(uint8x8_t v8)
+{
+    const uint64x1_t v1 = vpaddl_u32(vpaddl_u16(vpaddl_u8(v8)));
+    return vget_lane_u8(vreinterpret_u8_u64(v1), 0);
+}
+#else
+// Wraps vaddv_u8
+FORCE_INLINE uint8_t _sse2neon_vaddv_u8(uint8x8_t v8)
+{
+    return vaddv_u8(v8);
+}
+#endif
+
+#if !defined(__aarch64__) && !defined(_M_ARM64)
+/* emulate vaddvq u8 variant */
+FORCE_INLINE uint8_t _sse2neon_vaddvq_u8(uint8x16_t a)
+{
+    uint8x8_t tmp = vpadd_u8(vget_low_u8(a), vget_high_u8(a));
+    uint8_t res = 0;
+    for (int i = 0; i < 8; ++i)
+        res += tmp[i];
+    return res;
+}
+#else
+// Wraps vaddvq_u8
+FORCE_INLINE uint8_t _sse2neon_vaddvq_u8(uint8x16_t a)
+{
+    return vaddvq_u8(a);
+}
+#endif
+
+#if !defined(__aarch64__) && !defined(_M_ARM64)
+/* emulate vaddvq u16 variant */
+FORCE_INLINE uint16_t _sse2neon_vaddvq_u16(uint16x8_t a)
+{
+    uint32x4_t m = vpaddlq_u16(a);
+    uint64x2_t n = vpaddlq_u32(m);
+    uint64x1_t o = vget_low_u64(n) + vget_high_u64(n);
+
+    return vget_lane_u32((uint32x2_t) o, 0);
+}
+#else
+// Wraps vaddvq_u16
+FORCE_INLINE uint16_t _sse2neon_vaddvq_u16(uint16x8_t a)
+{
+    return vaddvq_u16(a);
+}
+#endif
+
+/* Function Naming Conventions
+ * The naming convention of SSE intrinsics is straightforward. A generic SSE
+ * intrinsic function is given as follows:
+ *   _mm_<name>_<data_type>
+ *
+ * The parts of this format are given as follows:
+ * 1. <name> describes the operation performed by the intrinsic
+ * 2. <data_type> identifies the data type of the function's primary arguments
+ *
+ * This last part, <data_type>, is a little complicated. It identifies the
+ * content of the input values, and can be set to any of the following values:
+ * + ps - vectors contain floats (ps stands for packed single-precision)
+ * + pd - vectors contain doubles (pd stands for packed double-precision)
+ * + epi8/epi16/epi32/epi64 - vectors contain 8-bit/16-bit/32-bit/64-bit
+ *                            signed integers
+ * + epu8/epu16/epu32/epu64 - vectors contain 8-bit/16-bit/32-bit/64-bit
+ *                            unsigned integers
+ * + si128 - unspecified 128-bit vector or 256-bit vector
+ * + m128/m128i/m128d - identifies input vector types when they are different
+ *                      than the type of the returned vector
+ *
+ * For example, _mm_setzero_ps. The _mm implies that the function returns
+ * a 128-bit vector. The _ps at the end implies that the argument vectors
+ * contain floats.
+ *
+ * A complete example: Byte Shuffle - pshufb (_mm_shuffle_epi8)
+ *   // Set packed 16-bit integers. 128 bits, 8 short, per 16 bits
+ *   __m128i v_in = _mm_setr_epi16(1, 2, 3, 4, 5, 6, 7, 8);
+ *   // Set packed 8-bit integers
+ *   // 128 bits, 16 chars, per 8 bits
+ *   __m128i v_perm = _mm_setr_epi8(1, 0,  2,  3, 8, 9, 10, 11,
+ *                                  4, 5, 12, 13, 6, 7, 14, 15);
+ *   // Shuffle packed 8-bit integers
+ *   __m128i v_out = _mm_shuffle_epi8(v_in, v_perm); // pshufb
+ */
+
+/* Constants for use with _mm_prefetch. */
+enum _mm_hint {
+    _MM_HINT_NTA = 0, /* load data to L1 and L2 cache, mark it as NTA */
+    _MM_HINT_T0 = 1,  /* load data to L1 and L2 cache */
+    _MM_HINT_T1 = 2,  /* load data to L2 cache only */
+    _MM_HINT_T2 = 3,  /* load data to L2 cache only, mark it as NTA */
+};
+
+// The bit field mapping to the FPCR(floating-point control register)
+typedef struct {
+    uint16_t res0;
+    uint8_t res1 : 6;
+    uint8_t bit22 : 1;
+    uint8_t bit23 : 1;
+    uint8_t bit24 : 1;
+    uint8_t res2 : 7;
+#if defined(__aarch64__) || defined(_M_ARM64)
+    uint32_t res3;
+#endif
+} fpcr_bitfield;
+
+// Takes the upper 64 bits of a and places it in the low end of the result
+// Takes the lower 64 bits of b and places it into the high end of the result.
+FORCE_INLINE __m128 _mm_shuffle_ps_1032(__m128 a, __m128 b)
+{
+    float32x2_t a32 = vget_high_f32(vreinterpretq_f32_m128(a));
+    float32x2_t b10 = vget_low_f32(vreinterpretq_f32_m128(b));
+    return vreinterpretq_m128_f32(vcombine_f32(a32, b10));
+}
+
+// takes the lower two 32-bit values from a and swaps them and places in high
+// end of result takes the higher two 32 bit values from b and swaps them and
+// places in low end of result.
+FORCE_INLINE __m128 _mm_shuffle_ps_2301(__m128 a, __m128 b)
+{
+    float32x2_t a01 = vrev64_f32(vget_low_f32(vreinterpretq_f32_m128(a)));
+    float32x2_t b23 = vrev64_f32(vget_high_f32(vreinterpretq_f32_m128(b)));
+    return vreinterpretq_m128_f32(vcombine_f32(a01, b23));
+}
+
+FORCE_INLINE __m128 _mm_shuffle_ps_0321(__m128 a, __m128 b)
+{
+    float32x2_t a21 = vget_high_f32(
+        vextq_f32(vreinterpretq_f32_m128(a), vreinterpretq_f32_m128(a), 3));
+    float32x2_t b03 = vget_low_f32(
+        vextq_f32(vreinterpretq_f32_m128(b), vreinterpretq_f32_m128(b), 3));
+    return vreinterpretq_m128_f32(vcombine_f32(a21, b03));
+}
+
+FORCE_INLINE __m128 _mm_shuffle_ps_2103(__m128 a, __m128 b)
+{
+    float32x2_t a03 = vget_low_f32(
+        vextq_f32(vreinterpretq_f32_m128(a), vreinterpretq_f32_m128(a), 3));
+    float32x2_t b21 = vget_high_f32(
+        vextq_f32(vreinterpretq_f32_m128(b), vreinterpretq_f32_m128(b), 3));
+    return vreinterpretq_m128_f32(vcombine_f32(a03, b21));
+}
+
+FORCE_INLINE __m128 _mm_shuffle_ps_1010(__m128 a, __m128 b)
+{
+    float32x2_t a10 = vget_low_f32(vreinterpretq_f32_m128(a));
+    float32x2_t b10 = vget_low_f32(vreinterpretq_f32_m128(b));
+    return vreinterpretq_m128_f32(vcombine_f32(a10, b10));
+}
+
+FORCE_INLINE __m128 _mm_shuffle_ps_1001(__m128 a, __m128 b)
+{
+    float32x2_t a01 = vrev64_f32(vget_low_f32(vreinterpretq_f32_m128(a)));
+    float32x2_t b10 = vget_low_f32(vreinterpretq_f32_m128(b));
+    return vreinterpretq_m128_f32(vcombine_f32(a01, b10));
+}
+
+FORCE_INLINE __m128 _mm_shuffle_ps_0101(__m128 a, __m128 b)
+{
+    float32x2_t a01 = vrev64_f32(vget_low_f32(vreinterpretq_f32_m128(a)));
+    float32x2_t b01 = vrev64_f32(vget_low_f32(vreinterpretq_f32_m128(b)));
+    return vreinterpretq_m128_f32(vcombine_f32(a01, b01));
+}
+
+// keeps the low 64 bits of b in the low and puts the high 64 bits of a in the
+// high
+FORCE_INLINE __m128 _mm_shuffle_ps_3210(__m128 a, __m128 b)
+{
+    float32x2_t a10 = vget_low_f32(vreinterpretq_f32_m128(a));
+    float32x2_t b32 = vget_high_f32(vreinterpretq_f32_m128(b));
+    return vreinterpretq_m128_f32(vcombine_f32(a10, b32));
+}
+
+FORCE_INLINE __m128 _mm_shuffle_ps_0011(__m128 a, __m128 b)
+{
+    float32x2_t a11 = vdup_lane_f32(vget_low_f32(vreinterpretq_f32_m128(a)), 1);
+    float32x2_t b00 = vdup_lane_f32(vget_low_f32(vreinterpretq_f32_m128(b)), 0);
+    return vreinterpretq_m128_f32(vcombine_f32(a11, b00));
+}
+
+FORCE_INLINE __m128 _mm_shuffle_ps_0022(__m128 a, __m128 b)
+{
+    float32x2_t a22 =
+        vdup_lane_f32(vget_high_f32(vreinterpretq_f32_m128(a)), 0);
+    float32x2_t b00 = vdup_lane_f32(vget_low_f32(vreinterpretq_f32_m128(b)), 0);
+    return vreinterpretq_m128_f32(vcombine_f32(a22, b00));
+}
+
+FORCE_INLINE __m128 _mm_shuffle_ps_2200(__m128 a, __m128 b)
+{
+    float32x2_t a00 = vdup_lane_f32(vget_low_f32(vreinterpretq_f32_m128(a)), 0);
+    float32x2_t b22 =
+        vdup_lane_f32(vget_high_f32(vreinterpretq_f32_m128(b)), 0);
+    return vreinterpretq_m128_f32(vcombine_f32(a00, b22));
+}
+
+FORCE_INLINE __m128 _mm_shuffle_ps_3202(__m128 a, __m128 b)
+{
+    float32_t a0 = vgetq_lane_f32(vreinterpretq_f32_m128(a), 0);
+    float32x2_t a22 =
+        vdup_lane_f32(vget_high_f32(vreinterpretq_f32_m128(a)), 0);
+    float32x2_t a02 = vset_lane_f32(a0, a22, 1); /* TODO: use vzip ?*/
+    float32x2_t b32 = vget_high_f32(vreinterpretq_f32_m128(b));
+    return vreinterpretq_m128_f32(vcombine_f32(a02, b32));
+}
+
+FORCE_INLINE __m128 _mm_shuffle_ps_1133(__m128 a, __m128 b)
+{
+    float32x2_t a33 =
+        vdup_lane_f32(vget_high_f32(vreinterpretq_f32_m128(a)), 1);
+    float32x2_t b11 = vdup_lane_f32(vget_low_f32(vreinterpretq_f32_m128(b)), 1);
+    return vreinterpretq_m128_f32(vcombine_f32(a33, b11));
+}
+
+FORCE_INLINE __m128 _mm_shuffle_ps_2010(__m128 a, __m128 b)
+{
+    float32x2_t a10 = vget_low_f32(vreinterpretq_f32_m128(a));
+    float32_t b2 = vgetq_lane_f32(vreinterpretq_f32_m128(b), 2);
+    float32x2_t b00 = vdup_lane_f32(vget_low_f32(vreinterpretq_f32_m128(b)), 0);
+    float32x2_t b20 = vset_lane_f32(b2, b00, 1);
+    return vreinterpretq_m128_f32(vcombine_f32(a10, b20));
+}
+
+FORCE_INLINE __m128 _mm_shuffle_ps_2001(__m128 a, __m128 b)
+{
+    float32x2_t a01 = vrev64_f32(vget_low_f32(vreinterpretq_f32_m128(a)));
+    float32_t b2 = vgetq_lane_f32(b, 2);
+    float32x2_t b00 = vdup_lane_f32(vget_low_f32(vreinterpretq_f32_m128(b)), 0);
+    float32x2_t b20 = vset_lane_f32(b2, b00, 1);
+    return vreinterpretq_m128_f32(vcombine_f32(a01, b20));
+}
+
+FORCE_INLINE __m128 _mm_shuffle_ps_2032(__m128 a, __m128 b)
+{
+    float32x2_t a32 = vget_high_f32(vreinterpretq_f32_m128(a));
+    float32_t b2 = vgetq_lane_f32(b, 2);
+    float32x2_t b00 = vdup_lane_f32(vget_low_f32(vreinterpretq_f32_m128(b)), 0);
+    float32x2_t b20 = vset_lane_f32(b2, b00, 1);
+    return vreinterpretq_m128_f32(vcombine_f32(a32, b20));
+}
+
+// For MSVC, we check only if it is ARM64, as every single ARM64 processor
+// supported by WoA has crypto extensions. If this changes in the future,
+// this can be verified via the runtime-only method of:
+// IsProcessorFeaturePresent(PF_ARM_V8_CRYPTO_INSTRUCTIONS_AVAILABLE)
+#if (defined(_M_ARM64) && !defined(__clang__)) || \
+    (defined(__ARM_FEATURE_CRYPTO) &&             \
+     (defined(__aarch64__) || __has_builtin(__builtin_arm_crypto_vmullp64)))
+// Wraps vmull_p64
+FORCE_INLINE uint64x2_t _sse2neon_vmull_p64(uint64x1_t _a, uint64x1_t _b)
+{
+    poly64_t a = vget_lane_p64(vreinterpret_p64_u64(_a), 0);
+    poly64_t b = vget_lane_p64(vreinterpret_p64_u64(_b), 0);
+#if defined(_MSC_VER)
+    __n64 a1 = {a}, b1 = {b};
+    return vreinterpretq_u64_p128(vmull_p64(a1, b1));
+#else
+    return vreinterpretq_u64_p128(vmull_p64(a, b));
+#endif
+}
+#else  // ARMv7 polyfill
+// ARMv7/some A64 lacks vmull_p64, but it has vmull_p8.
+//
+// vmull_p8 calculates 8 8-bit->16-bit polynomial multiplies, but we need a
+// 64-bit->128-bit polynomial multiply.
+//
+// It needs some work and is somewhat slow, but it is still faster than all
+// known scalar methods.
+//
+// Algorithm adapted to C from
+// https://www.workofard.com/2017/07/ghash-for-low-end-cores/, which is adapted
+// from "Fast Software Polynomial Multiplication on ARM Processors Using the
+// NEON Engine" by Danilo Camara, Conrado Gouvea, Julio Lopez and Ricardo Dahab
+// (https://hal.inria.fr/hal-01506572)
+static uint64x2_t _sse2neon_vmull_p64(uint64x1_t _a, uint64x1_t _b)
+{
+    poly8x8_t a = vreinterpret_p8_u64(_a);
+    poly8x8_t b = vreinterpret_p8_u64(_b);
+
+    // Masks
+    uint8x16_t k48_32 = vcombine_u8(vcreate_u8(0x0000ffffffffffff),
+                                    vcreate_u8(0x00000000ffffffff));
+    uint8x16_t k16_00 = vcombine_u8(vcreate_u8(0x000000000000ffff),
+                                    vcreate_u8(0x0000000000000000));
+
+    // Do the multiplies, rotating with vext to get all combinations
+    uint8x16_t d = vreinterpretq_u8_p16(vmull_p8(a, b));  // D = A0 * B0
+    uint8x16_t e =
+        vreinterpretq_u8_p16(vmull_p8(a, vext_p8(b, b, 1)));  // E = A0 * B1
+    uint8x16_t f =
+        vreinterpretq_u8_p16(vmull_p8(vext_p8(a, a, 1), b));  // F = A1 * B0
+    uint8x16_t g =
+        vreinterpretq_u8_p16(vmull_p8(a, vext_p8(b, b, 2)));  // G = A0 * B2
+    uint8x16_t h =
+        vreinterpretq_u8_p16(vmull_p8(vext_p8(a, a, 2), b));  // H = A2 * B0
+    uint8x16_t i =
+        vreinterpretq_u8_p16(vmull_p8(a, vext_p8(b, b, 3)));  // I = A0 * B3
+    uint8x16_t j =
+        vreinterpretq_u8_p16(vmull_p8(vext_p8(a, a, 3), b));  // J = A3 * B0
+    uint8x16_t k =
+        vreinterpretq_u8_p16(vmull_p8(a, vext_p8(b, b, 4)));  // L = A0 * B4
+
+    // Add cross products
+    uint8x16_t l = veorq_u8(e, f);  // L = E + F
+    uint8x16_t m = veorq_u8(g, h);  // M = G + H
+    uint8x16_t n = veorq_u8(i, j);  // N = I + J
+
+    // Interleave. Using vzip1 and vzip2 prevents Clang from emitting TBL
+    // instructions.
+#if defined(__aarch64__)
+    uint8x16_t lm_p0 = vreinterpretq_u8_u64(
+        vzip1q_u64(vreinterpretq_u64_u8(l), vreinterpretq_u64_u8(m)));
+    uint8x16_t lm_p1 = vreinterpretq_u8_u64(
+        vzip2q_u64(vreinterpretq_u64_u8(l), vreinterpretq_u64_u8(m)));
+    uint8x16_t nk_p0 = vreinterpretq_u8_u64(
+        vzip1q_u64(vreinterpretq_u64_u8(n), vreinterpretq_u64_u8(k)));
+    uint8x16_t nk_p1 = vreinterpretq_u8_u64(
+        vzip2q_u64(vreinterpretq_u64_u8(n), vreinterpretq_u64_u8(k)));
+#else
+    uint8x16_t lm_p0 = vcombine_u8(vget_low_u8(l), vget_low_u8(m));
+    uint8x16_t lm_p1 = vcombine_u8(vget_high_u8(l), vget_high_u8(m));
+    uint8x16_t nk_p0 = vcombine_u8(vget_low_u8(n), vget_low_u8(k));
+    uint8x16_t nk_p1 = vcombine_u8(vget_high_u8(n), vget_high_u8(k));
+#endif
+    // t0 = (L) (P0 + P1) << 8
+    // t1 = (M) (P2 + P3) << 16
+    uint8x16_t t0t1_tmp = veorq_u8(lm_p0, lm_p1);
+    uint8x16_t t0t1_h = vandq_u8(lm_p1, k48_32);
+    uint8x16_t t0t1_l = veorq_u8(t0t1_tmp, t0t1_h);
+
+    // t2 = (N) (P4 + P5) << 24
+    // t3 = (K) (P6 + P7) << 32
+    uint8x16_t t2t3_tmp = veorq_u8(nk_p0, nk_p1);
+    uint8x16_t t2t3_h = vandq_u8(nk_p1, k16_00);
+    uint8x16_t t2t3_l = veorq_u8(t2t3_tmp, t2t3_h);
+
+    // De-interleave
+#if defined(__aarch64__)
+    uint8x16_t t0 = vreinterpretq_u8_u64(
+        vuzp1q_u64(vreinterpretq_u64_u8(t0t1_l), vreinterpretq_u64_u8(t0t1_h)));
+    uint8x16_t t1 = vreinterpretq_u8_u64(
+        vuzp2q_u64(vreinterpretq_u64_u8(t0t1_l), vreinterpretq_u64_u8(t0t1_h)));
+    uint8x16_t t2 = vreinterpretq_u8_u64(
+        vuzp1q_u64(vreinterpretq_u64_u8(t2t3_l), vreinterpretq_u64_u8(t2t3_h)));
+    uint8x16_t t3 = vreinterpretq_u8_u64(
+        vuzp2q_u64(vreinterpretq_u64_u8(t2t3_l), vreinterpretq_u64_u8(t2t3_h)));
+#else
+    uint8x16_t t1 = vcombine_u8(vget_high_u8(t0t1_l), vget_high_u8(t0t1_h));
+    uint8x16_t t0 = vcombine_u8(vget_low_u8(t0t1_l), vget_low_u8(t0t1_h));
+    uint8x16_t t3 = vcombine_u8(vget_high_u8(t2t3_l), vget_high_u8(t2t3_h));
+    uint8x16_t t2 = vcombine_u8(vget_low_u8(t2t3_l), vget_low_u8(t2t3_h));
+#endif
+    // Shift the cross products
+    uint8x16_t t0_shift = vextq_u8(t0, t0, 15);  // t0 << 8
+    uint8x16_t t1_shift = vextq_u8(t1, t1, 14);  // t1 << 16
+    uint8x16_t t2_shift = vextq_u8(t2, t2, 13);  // t2 << 24
+    uint8x16_t t3_shift = vextq_u8(t3, t3, 12);  // t3 << 32
+
+    // Accumulate the products
+    uint8x16_t cross1 = veorq_u8(t0_shift, t1_shift);
+    uint8x16_t cross2 = veorq_u8(t2_shift, t3_shift);
+    uint8x16_t mix = veorq_u8(d, cross1);
+    uint8x16_t r = veorq_u8(mix, cross2);
+    return vreinterpretq_u64_u8(r);
+}
+#endif  // ARMv7 polyfill
+
+// C equivalent:
+//   __m128i _mm_shuffle_epi32_default(__m128i a,
+//                                     __constrange(0, 255) int imm) {
+//       __m128i ret;
+//       ret[0] = a[imm        & 0x3];   ret[1] = a[(imm >> 2) & 0x3];
+//       ret[2] = a[(imm >> 4) & 0x03];  ret[3] = a[(imm >> 6) & 0x03];
+//       return ret;
+//   }
+#define _mm_shuffle_epi32_default(a, imm)                                   \
+    vreinterpretq_m128i_s32(vsetq_lane_s32(                                 \
+        vgetq_lane_s32(vreinterpretq_s32_m128i(a), ((imm) >> 6) & 0x3),     \
+        vsetq_lane_s32(                                                     \
+            vgetq_lane_s32(vreinterpretq_s32_m128i(a), ((imm) >> 4) & 0x3), \
+            vsetq_lane_s32(vgetq_lane_s32(vreinterpretq_s32_m128i(a),       \
+                                          ((imm) >> 2) & 0x3),              \
+                           vmovq_n_s32(vgetq_lane_s32(                      \
+                               vreinterpretq_s32_m128i(a), (imm) & (0x3))), \
+                           1),                                              \
+            2),                                                             \
+        3))
+
+// Takes the upper 64 bits of a and places it in the low end of the result
+// Takes the lower 64 bits of a and places it into the high end of the result.
+FORCE_INLINE __m128i _mm_shuffle_epi_1032(__m128i a)
+{
+    int32x2_t a32 = vget_high_s32(vreinterpretq_s32_m128i(a));
+    int32x2_t a10 = vget_low_s32(vreinterpretq_s32_m128i(a));
+    return vreinterpretq_m128i_s32(vcombine_s32(a32, a10));
+}
+
+// takes the lower two 32-bit values from a and swaps them and places in low end
+// of result takes the higher two 32 bit values from a and swaps them and places
+// in high end of result.
+FORCE_INLINE __m128i _mm_shuffle_epi_2301(__m128i a)
+{
+    int32x2_t a01 = vrev64_s32(vget_low_s32(vreinterpretq_s32_m128i(a)));
+    int32x2_t a23 = vrev64_s32(vget_high_s32(vreinterpretq_s32_m128i(a)));
+    return vreinterpretq_m128i_s32(vcombine_s32(a01, a23));
+}
+
+// rotates the least significant 32 bits into the most significant 32 bits, and
+// shifts the rest down
+FORCE_INLINE __m128i _mm_shuffle_epi_0321(__m128i a)
+{
+    return vreinterpretq_m128i_s32(
+        vextq_s32(vreinterpretq_s32_m128i(a), vreinterpretq_s32_m128i(a), 1));
+}
+
+// rotates the most significant 32 bits into the least significant 32 bits, and
+// shifts the rest up
+FORCE_INLINE __m128i _mm_shuffle_epi_2103(__m128i a)
+{
+    return vreinterpretq_m128i_s32(
+        vextq_s32(vreinterpretq_s32_m128i(a), vreinterpretq_s32_m128i(a), 3));
+}
+
+// gets the lower 64 bits of a, and places it in the upper 64 bits
+// gets the lower 64 bits of a and places it in the lower 64 bits
+FORCE_INLINE __m128i _mm_shuffle_epi_1010(__m128i a)
+{
+    int32x2_t a10 = vget_low_s32(vreinterpretq_s32_m128i(a));
+    return vreinterpretq_m128i_s32(vcombine_s32(a10, a10));
+}
+
+// gets the lower 64 bits of a, swaps the 0 and 1 elements, and places it in the
+// lower 64 bits gets the lower 64 bits of a, and places it in the upper 64 bits
+FORCE_INLINE __m128i _mm_shuffle_epi_1001(__m128i a)
+{
+    int32x2_t a01 = vrev64_s32(vget_low_s32(vreinterpretq_s32_m128i(a)));
+    int32x2_t a10 = vget_low_s32(vreinterpretq_s32_m128i(a));
+    return vreinterpretq_m128i_s32(vcombine_s32(a01, a10));
+}
+
+// gets the lower 64 bits of a, swaps the 0 and 1 elements and places it in the
+// upper 64 bits gets the lower 64 bits of a, swaps the 0 and 1 elements, and
+// places it in the lower 64 bits
+FORCE_INLINE __m128i _mm_shuffle_epi_0101(__m128i a)
+{
+    int32x2_t a01 = vrev64_s32(vget_low_s32(vreinterpretq_s32_m128i(a)));
+    return vreinterpretq_m128i_s32(vcombine_s32(a01, a01));
+}
+
+FORCE_INLINE __m128i _mm_shuffle_epi_2211(__m128i a)
+{
+    int32x2_t a11 = vdup_lane_s32(vget_low_s32(vreinterpretq_s32_m128i(a)), 1);
+    int32x2_t a22 = vdup_lane_s32(vget_high_s32(vreinterpretq_s32_m128i(a)), 0);
+    return vreinterpretq_m128i_s32(vcombine_s32(a11, a22));
+}
+
+FORCE_INLINE __m128i _mm_shuffle_epi_0122(__m128i a)
+{
+    int32x2_t a22 = vdup_lane_s32(vget_high_s32(vreinterpretq_s32_m128i(a)), 0);
+    int32x2_t a01 = vrev64_s32(vget_low_s32(vreinterpretq_s32_m128i(a)));
+    return vreinterpretq_m128i_s32(vcombine_s32(a22, a01));
+}
+
+FORCE_INLINE __m128i _mm_shuffle_epi_3332(__m128i a)
+{
+    int32x2_t a32 = vget_high_s32(vreinterpretq_s32_m128i(a));
+    int32x2_t a33 = vdup_lane_s32(vget_high_s32(vreinterpretq_s32_m128i(a)), 1);
+    return vreinterpretq_m128i_s32(vcombine_s32(a32, a33));
+}
+
+#if defined(__aarch64__) || defined(_M_ARM64)
+#define _mm_shuffle_epi32_splat(a, imm) \
+    vreinterpretq_m128i_s32(vdupq_laneq_s32(vreinterpretq_s32_m128i(a), (imm)))
+#else
+#define _mm_shuffle_epi32_splat(a, imm) \
+    vreinterpretq_m128i_s32(            \
+        vdupq_n_s32(vgetq_lane_s32(vreinterpretq_s32_m128i(a), (imm))))
+#endif
+
+// NEON does not support a general purpose permute intrinsic.
+// Shuffle single-precision (32-bit) floating-point elements in a using the
+// control in imm8, and store the results in dst.
+//
+// C equivalent:
+//   __m128 _mm_shuffle_ps_default(__m128 a, __m128 b,
+//                                 __constrange(0, 255) int imm) {
+//       __m128 ret;
+//       ret[0] = a[imm        & 0x3];   ret[1] = a[(imm >> 2) & 0x3];
+//       ret[2] = b[(imm >> 4) & 0x03];  ret[3] = b[(imm >> 6) & 0x03];
+//       return ret;
+//   }
+//
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_shuffle_ps
+#define _mm_shuffle_ps_default(a, b, imm)                                      \
+    vreinterpretq_m128_f32(vsetq_lane_f32(                                     \
+        vgetq_lane_f32(vreinterpretq_f32_m128(b), ((imm) >> 6) & 0x3),         \
+        vsetq_lane_f32(                                                        \
+            vgetq_lane_f32(vreinterpretq_f32_m128(b), ((imm) >> 4) & 0x3),     \
+            vsetq_lane_f32(                                                    \
+                vgetq_lane_f32(vreinterpretq_f32_m128(a), ((imm) >> 2) & 0x3), \
+                vmovq_n_f32(                                                   \
+                    vgetq_lane_f32(vreinterpretq_f32_m128(a), (imm) & (0x3))), \
+                1),                                                            \
+            2),                                                                \
+        3))
+
+// Shuffle 16-bit integers in the low 64 bits of a using the control in imm8.
+// Store the results in the low 64 bits of dst, with the high 64 bits being
+// copied from a to dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_shufflelo_epi16
+#define _mm_shufflelo_epi16_function(a, imm)                                  \
+    _sse2neon_define1(                                                        \
+        __m128i, a, int16x8_t ret = vreinterpretq_s16_m128i(_a);              \
+        int16x4_t lowBits = vget_low_s16(ret);                                \
+        ret = vsetq_lane_s16(vget_lane_s16(lowBits, (imm) & (0x3)), ret, 0);  \
+        ret = vsetq_lane_s16(vget_lane_s16(lowBits, ((imm) >> 2) & 0x3), ret, \
+                             1);                                              \
+        ret = vsetq_lane_s16(vget_lane_s16(lowBits, ((imm) >> 4) & 0x3), ret, \
+                             2);                                              \
+        ret = vsetq_lane_s16(vget_lane_s16(lowBits, ((imm) >> 6) & 0x3), ret, \
+                             3);                                              \
+        _sse2neon_return(vreinterpretq_m128i_s16(ret));)
+
+// Shuffle 16-bit integers in the high 64 bits of a using the control in imm8.
+// Store the results in the high 64 bits of dst, with the low 64 bits being
+// copied from a to dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_shufflehi_epi16
+#define _mm_shufflehi_epi16_function(a, imm)                                   \
+    _sse2neon_define1(                                                         \
+        __m128i, a, int16x8_t ret = vreinterpretq_s16_m128i(_a);               \
+        int16x4_t highBits = vget_high_s16(ret);                               \
+        ret = vsetq_lane_s16(vget_lane_s16(highBits, (imm) & (0x3)), ret, 4);  \
+        ret = vsetq_lane_s16(vget_lane_s16(highBits, ((imm) >> 2) & 0x3), ret, \
+                             5);                                               \
+        ret = vsetq_lane_s16(vget_lane_s16(highBits, ((imm) >> 4) & 0x3), ret, \
+                             6);                                               \
+        ret = vsetq_lane_s16(vget_lane_s16(highBits, ((imm) >> 6) & 0x3), ret, \
+                             7);                                               \
+        _sse2neon_return(vreinterpretq_m128i_s16(ret));)
+
+/* MMX */
+
+//_mm_empty is a no-op on arm
+FORCE_INLINE void _mm_empty(void) {}
+
+/* SSE */
+
+// Add packed single-precision (32-bit) floating-point elements in a and b, and
+// store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_add_ps
+FORCE_INLINE __m128 _mm_add_ps(__m128 a, __m128 b)
+{
+    return vreinterpretq_m128_f32(
+        vaddq_f32(vreinterpretq_f32_m128(a), vreinterpretq_f32_m128(b)));
+}
+
+// Add the lower single-precision (32-bit) floating-point element in a and b,
+// store the result in the lower element of dst, and copy the upper 3 packed
+// elements from a to the upper elements of dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_add_ss
+FORCE_INLINE __m128 _mm_add_ss(__m128 a, __m128 b)
+{
+    float32_t b0 = vgetq_lane_f32(vreinterpretq_f32_m128(b), 0);
+    float32x4_t value = vsetq_lane_f32(b0, vdupq_n_f32(0), 0);
+    // the upper values in the result must be the remnants of <a>.
+    return vreinterpretq_m128_f32(vaddq_f32(a, value));
+}
+
+// Compute the bitwise AND of packed single-precision (32-bit) floating-point
+// elements in a and b, and store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_and_ps
+FORCE_INLINE __m128 _mm_and_ps(__m128 a, __m128 b)
+{
+    return vreinterpretq_m128_s32(
+        vandq_s32(vreinterpretq_s32_m128(a), vreinterpretq_s32_m128(b)));
+}
+
+// Compute the bitwise NOT of packed single-precision (32-bit) floating-point
+// elements in a and then AND with b, and store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_andnot_ps
+FORCE_INLINE __m128 _mm_andnot_ps(__m128 a, __m128 b)
+{
+    return vreinterpretq_m128_s32(
+        vbicq_s32(vreinterpretq_s32_m128(b),
+                  vreinterpretq_s32_m128(a)));  // *NOTE* argument swap
+}
+
+// Average packed unsigned 16-bit integers in a and b, and store the results in
+// dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_avg_pu16
+FORCE_INLINE __m64 _mm_avg_pu16(__m64 a, __m64 b)
+{
+    return vreinterpret_m64_u16(
+        vrhadd_u16(vreinterpret_u16_m64(a), vreinterpret_u16_m64(b)));
+}
+
+// Average packed unsigned 8-bit integers in a and b, and store the results in
+// dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_avg_pu8
+FORCE_INLINE __m64 _mm_avg_pu8(__m64 a, __m64 b)
+{
+    return vreinterpret_m64_u8(
+        vrhadd_u8(vreinterpret_u8_m64(a), vreinterpret_u8_m64(b)));
+}
+
+// Compare packed single-precision (32-bit) floating-point elements in a and b
+// for equality, and store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmpeq_ps
+FORCE_INLINE __m128 _mm_cmpeq_ps(__m128 a, __m128 b)
+{
+    return vreinterpretq_m128_u32(
+        vceqq_f32(vreinterpretq_f32_m128(a), vreinterpretq_f32_m128(b)));
+}
+
+// Compare the lower single-precision (32-bit) floating-point elements in a and
+// b for equality, store the result in the lower element of dst, and copy the
+// upper 3 packed elements from a to the upper elements of dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmpeq_ss
+FORCE_INLINE __m128 _mm_cmpeq_ss(__m128 a, __m128 b)
+{
+    return _mm_move_ss(a, _mm_cmpeq_ps(a, b));
+}
+
+// Compare packed single-precision (32-bit) floating-point elements in a and b
+// for greater-than-or-equal, and store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmpge_ps
+FORCE_INLINE __m128 _mm_cmpge_ps(__m128 a, __m128 b)
+{
+    return vreinterpretq_m128_u32(
+        vcgeq_f32(vreinterpretq_f32_m128(a), vreinterpretq_f32_m128(b)));
+}
+
+// Compare the lower single-precision (32-bit) floating-point elements in a and
+// b for greater-than-or-equal, store the result in the lower element of dst,
+// and copy the upper 3 packed elements from a to the upper elements of dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmpge_ss
+FORCE_INLINE __m128 _mm_cmpge_ss(__m128 a, __m128 b)
+{
+    return _mm_move_ss(a, _mm_cmpge_ps(a, b));
+}
+
+// Compare packed single-precision (32-bit) floating-point elements in a and b
+// for greater-than, and store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmpgt_ps
+FORCE_INLINE __m128 _mm_cmpgt_ps(__m128 a, __m128 b)
+{
+    return vreinterpretq_m128_u32(
+        vcgtq_f32(vreinterpretq_f32_m128(a), vreinterpretq_f32_m128(b)));
+}
+
+// Compare the lower single-precision (32-bit) floating-point elements in a and
+// b for greater-than, store the result in the lower element of dst, and copy
+// the upper 3 packed elements from a to the upper elements of dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmpgt_ss
+FORCE_INLINE __m128 _mm_cmpgt_ss(__m128 a, __m128 b)
+{
+    return _mm_move_ss(a, _mm_cmpgt_ps(a, b));
+}
+
+// Compare packed single-precision (32-bit) floating-point elements in a and b
+// for less-than-or-equal, and store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmple_ps
+FORCE_INLINE __m128 _mm_cmple_ps(__m128 a, __m128 b)
+{
+    return vreinterpretq_m128_u32(
+        vcleq_f32(vreinterpretq_f32_m128(a), vreinterpretq_f32_m128(b)));
+}
+
+// Compare the lower single-precision (32-bit) floating-point elements in a and
+// b for less-than-or-equal, store the result in the lower element of dst, and
+// copy the upper 3 packed elements from a to the upper elements of dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmple_ss
+FORCE_INLINE __m128 _mm_cmple_ss(__m128 a, __m128 b)
+{
+    return _mm_move_ss(a, _mm_cmple_ps(a, b));
+}
+
+// Compare packed single-precision (32-bit) floating-point elements in a and b
+// for less-than, and store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmplt_ps
+FORCE_INLINE __m128 _mm_cmplt_ps(__m128 a, __m128 b)
+{
+    return vreinterpretq_m128_u32(
+        vcltq_f32(vreinterpretq_f32_m128(a), vreinterpretq_f32_m128(b)));
+}
+
+// Compare the lower single-precision (32-bit) floating-point elements in a and
+// b for less-than, store the result in the lower element of dst, and copy the
+// upper 3 packed elements from a to the upper elements of dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmplt_ss
+FORCE_INLINE __m128 _mm_cmplt_ss(__m128 a, __m128 b)
+{
+    return _mm_move_ss(a, _mm_cmplt_ps(a, b));
+}
+
+// Compare packed single-precision (32-bit) floating-point elements in a and b
+// for not-equal, and store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmpneq_ps
+FORCE_INLINE __m128 _mm_cmpneq_ps(__m128 a, __m128 b)
+{
+    return vreinterpretq_m128_u32(vmvnq_u32(
+        vceqq_f32(vreinterpretq_f32_m128(a), vreinterpretq_f32_m128(b))));
+}
+
+// Compare the lower single-precision (32-bit) floating-point elements in a and
+// b for not-equal, store the result in the lower element of dst, and copy the
+// upper 3 packed elements from a to the upper elements of dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmpneq_ss
+FORCE_INLINE __m128 _mm_cmpneq_ss(__m128 a, __m128 b)
+{
+    return _mm_move_ss(a, _mm_cmpneq_ps(a, b));
+}
+
+// Compare packed single-precision (32-bit) floating-point elements in a and b
+// for not-greater-than-or-equal, and store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmpnge_ps
+FORCE_INLINE __m128 _mm_cmpnge_ps(__m128 a, __m128 b)
+{
+    return vreinterpretq_m128_u32(vmvnq_u32(
+        vcgeq_f32(vreinterpretq_f32_m128(a), vreinterpretq_f32_m128(b))));
+}
+
+// Compare the lower single-precision (32-bit) floating-point elements in a and
+// b for not-greater-than-or-equal, store the result in the lower element of
+// dst, and copy the upper 3 packed elements from a to the upper elements of
+// dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmpnge_ss
+FORCE_INLINE __m128 _mm_cmpnge_ss(__m128 a, __m128 b)
+{
+    return _mm_move_ss(a, _mm_cmpnge_ps(a, b));
+}
+
+// Compare packed single-precision (32-bit) floating-point elements in a and b
+// for not-greater-than, and store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmpngt_ps
+FORCE_INLINE __m128 _mm_cmpngt_ps(__m128 a, __m128 b)
+{
+    return vreinterpretq_m128_u32(vmvnq_u32(
+        vcgtq_f32(vreinterpretq_f32_m128(a), vreinterpretq_f32_m128(b))));
+}
+
+// Compare the lower single-precision (32-bit) floating-point elements in a and
+// b for not-greater-than, store the result in the lower element of dst, and
+// copy the upper 3 packed elements from a to the upper elements of dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmpngt_ss
+FORCE_INLINE __m128 _mm_cmpngt_ss(__m128 a, __m128 b)
+{
+    return _mm_move_ss(a, _mm_cmpngt_ps(a, b));
+}
+
+// Compare packed single-precision (32-bit) floating-point elements in a and b
+// for not-less-than-or-equal, and store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmpnle_ps
+FORCE_INLINE __m128 _mm_cmpnle_ps(__m128 a, __m128 b)
+{
+    return vreinterpretq_m128_u32(vmvnq_u32(
+        vcleq_f32(vreinterpretq_f32_m128(a), vreinterpretq_f32_m128(b))));
+}
+
+// Compare the lower single-precision (32-bit) floating-point elements in a and
+// b for not-less-than-or-equal, store the result in the lower element of dst,
+// and copy the upper 3 packed elements from a to the upper elements of dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmpnle_ss
+FORCE_INLINE __m128 _mm_cmpnle_ss(__m128 a, __m128 b)
+{
+    return _mm_move_ss(a, _mm_cmpnle_ps(a, b));
+}
+
+// Compare packed single-precision (32-bit) floating-point elements in a and b
+// for not-less-than, and store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmpnlt_ps
+FORCE_INLINE __m128 _mm_cmpnlt_ps(__m128 a, __m128 b)
+{
+    return vreinterpretq_m128_u32(vmvnq_u32(
+        vcltq_f32(vreinterpretq_f32_m128(a), vreinterpretq_f32_m128(b))));
+}
+
+// Compare the lower single-precision (32-bit) floating-point elements in a and
+// b for not-less-than, store the result in the lower element of dst, and copy
+// the upper 3 packed elements from a to the upper elements of dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmpnlt_ss
+FORCE_INLINE __m128 _mm_cmpnlt_ss(__m128 a, __m128 b)
+{
+    return _mm_move_ss(a, _mm_cmpnlt_ps(a, b));
+}
+
+// Compare packed single-precision (32-bit) floating-point elements in a and b
+// to see if neither is NaN, and store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmpord_ps
+//
+// See also:
+// http://stackoverflow.com/questions/8627331/what-does-ordered-unordered-comparison-mean
+// http://stackoverflow.com/questions/29349621/neon-isnanval-intrinsics
+FORCE_INLINE __m128 _mm_cmpord_ps(__m128 a, __m128 b)
+{
+    // Note: NEON does not have ordered compare builtin
+    // Need to compare a eq a and b eq b to check for NaN
+    // Do AND of results to get final
+    uint32x4_t ceqaa =
+        vceqq_f32(vreinterpretq_f32_m128(a), vreinterpretq_f32_m128(a));
+    uint32x4_t ceqbb =
+        vceqq_f32(vreinterpretq_f32_m128(b), vreinterpretq_f32_m128(b));
+    return vreinterpretq_m128_u32(vandq_u32(ceqaa, ceqbb));
+}
+
+// Compare the lower single-precision (32-bit) floating-point elements in a and
+// b to see if neither is NaN, store the result in the lower element of dst, and
+// copy the upper 3 packed elements from a to the upper elements of dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmpord_ss
+FORCE_INLINE __m128 _mm_cmpord_ss(__m128 a, __m128 b)
+{
+    return _mm_move_ss(a, _mm_cmpord_ps(a, b));
+}
+
+// Compare packed single-precision (32-bit) floating-point elements in a and b
+// to see if either is NaN, and store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmpunord_ps
+FORCE_INLINE __m128 _mm_cmpunord_ps(__m128 a, __m128 b)
+{
+    uint32x4_t f32a =
+        vceqq_f32(vreinterpretq_f32_m128(a), vreinterpretq_f32_m128(a));
+    uint32x4_t f32b =
+        vceqq_f32(vreinterpretq_f32_m128(b), vreinterpretq_f32_m128(b));
+    return vreinterpretq_m128_u32(vmvnq_u32(vandq_u32(f32a, f32b)));
+}
+
+// Compare the lower single-precision (32-bit) floating-point elements in a and
+// b to see if either is NaN, store the result in the lower element of dst, and
+// copy the upper 3 packed elements from a to the upper elements of dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmpunord_ss
+FORCE_INLINE __m128 _mm_cmpunord_ss(__m128 a, __m128 b)
+{
+    return _mm_move_ss(a, _mm_cmpunord_ps(a, b));
+}
+
+// Compare the lower single-precision (32-bit) floating-point element in a and b
+// for equality, and return the boolean result (0 or 1).
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_comieq_ss
+FORCE_INLINE int _mm_comieq_ss(__m128 a, __m128 b)
+{
+    uint32x4_t a_eq_b =
+        vceqq_f32(vreinterpretq_f32_m128(a), vreinterpretq_f32_m128(b));
+    return vgetq_lane_u32(a_eq_b, 0) & 0x1;
+}
+
+// Compare the lower single-precision (32-bit) floating-point element in a and b
+// for greater-than-or-equal, and return the boolean result (0 or 1).
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_comige_ss
+FORCE_INLINE int _mm_comige_ss(__m128 a, __m128 b)
+{
+    uint32x4_t a_ge_b =
+        vcgeq_f32(vreinterpretq_f32_m128(a), vreinterpretq_f32_m128(b));
+    return vgetq_lane_u32(a_ge_b, 0) & 0x1;
+}
+
+// Compare the lower single-precision (32-bit) floating-point element in a and b
+// for greater-than, and return the boolean result (0 or 1).
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_comigt_ss
+FORCE_INLINE int _mm_comigt_ss(__m128 a, __m128 b)
+{
+    uint32x4_t a_gt_b =
+        vcgtq_f32(vreinterpretq_f32_m128(a), vreinterpretq_f32_m128(b));
+    return vgetq_lane_u32(a_gt_b, 0) & 0x1;
+}
+
+// Compare the lower single-precision (32-bit) floating-point element in a and b
+// for less-than-or-equal, and return the boolean result (0 or 1).
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_comile_ss
+FORCE_INLINE int _mm_comile_ss(__m128 a, __m128 b)
+{
+    uint32x4_t a_le_b =
+        vcleq_f32(vreinterpretq_f32_m128(a), vreinterpretq_f32_m128(b));
+    return vgetq_lane_u32(a_le_b, 0) & 0x1;
+}
+
+// Compare the lower single-precision (32-bit) floating-point element in a and b
+// for less-than, and return the boolean result (0 or 1).
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_comilt_ss
+FORCE_INLINE int _mm_comilt_ss(__m128 a, __m128 b)
+{
+    uint32x4_t a_lt_b =
+        vcltq_f32(vreinterpretq_f32_m128(a), vreinterpretq_f32_m128(b));
+    return vgetq_lane_u32(a_lt_b, 0) & 0x1;
+}
+
+// Compare the lower single-precision (32-bit) floating-point element in a and b
+// for not-equal, and return the boolean result (0 or 1).
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_comineq_ss
+FORCE_INLINE int _mm_comineq_ss(__m128 a, __m128 b)
+{
+    return !_mm_comieq_ss(a, b);
+}
+
+// Convert packed signed 32-bit integers in b to packed single-precision
+// (32-bit) floating-point elements, store the results in the lower 2 elements
+// of dst, and copy the upper 2 packed elements from a to the upper elements of
+// dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvt_pi2ps
+FORCE_INLINE __m128 _mm_cvt_pi2ps(__m128 a, __m64 b)
+{
+    return vreinterpretq_m128_f32(
+        vcombine_f32(vcvt_f32_s32(vreinterpret_s32_m64(b)),
+                     vget_high_f32(vreinterpretq_f32_m128(a))));
+}
+
+// Convert packed single-precision (32-bit) floating-point elements in a to
+// packed 32-bit integers, and store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvt_ps2pi
+FORCE_INLINE __m64 _mm_cvt_ps2pi(__m128 a)
+{
+#if (defined(__aarch64__) || defined(_M_ARM64)) || \
+    defined(__ARM_FEATURE_DIRECTED_ROUNDING)
+    return vreinterpret_m64_s32(
+        vget_low_s32(vcvtnq_s32_f32(vrndiq_f32(vreinterpretq_f32_m128(a)))));
+#else
+    return vreinterpret_m64_s32(vcvt_s32_f32(vget_low_f32(
+        vreinterpretq_f32_m128(_mm_round_ps(a, _MM_FROUND_CUR_DIRECTION)))));
+#endif
+}
+
+// Convert the signed 32-bit integer b to a single-precision (32-bit)
+// floating-point element, store the result in the lower element of dst, and
+// copy the upper 3 packed elements from a to the upper elements of dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvt_si2ss
+FORCE_INLINE __m128 _mm_cvt_si2ss(__m128 a, int b)
+{
+    return vreinterpretq_m128_f32(
+        vsetq_lane_f32((float) b, vreinterpretq_f32_m128(a), 0));
+}
+
+// Convert the lower single-precision (32-bit) floating-point element in a to a
+// 32-bit integer, and store the result in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvt_ss2si
+FORCE_INLINE int _mm_cvt_ss2si(__m128 a)
+{
+#if (defined(__aarch64__) || defined(_M_ARM64)) || \
+    defined(__ARM_FEATURE_DIRECTED_ROUNDING)
+    return vgetq_lane_s32(vcvtnq_s32_f32(vrndiq_f32(vreinterpretq_f32_m128(a))),
+                          0);
+#else
+    float32_t data = vgetq_lane_f32(
+        vreinterpretq_f32_m128(_mm_round_ps(a, _MM_FROUND_CUR_DIRECTION)), 0);
+    return (int32_t) data;
+#endif
+}
+
+// Convert packed 16-bit integers in a to packed single-precision (32-bit)
+// floating-point elements, and store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvtpi16_ps
+FORCE_INLINE __m128 _mm_cvtpi16_ps(__m64 a)
+{
+    return vreinterpretq_m128_f32(
+        vcvtq_f32_s32(vmovl_s16(vreinterpret_s16_m64(a))));
+}
+
+// Convert packed 32-bit integers in b to packed single-precision (32-bit)
+// floating-point elements, store the results in the lower 2 elements of dst,
+// and copy the upper 2 packed elements from a to the upper elements of dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvtpi32_ps
+FORCE_INLINE __m128 _mm_cvtpi32_ps(__m128 a, __m64 b)
+{
+    return vreinterpretq_m128_f32(
+        vcombine_f32(vcvt_f32_s32(vreinterpret_s32_m64(b)),
+                     vget_high_f32(vreinterpretq_f32_m128(a))));
+}
+
+// Convert packed signed 32-bit integers in a to packed single-precision
+// (32-bit) floating-point elements, store the results in the lower 2 elements
+// of dst, then convert the packed signed 32-bit integers in b to
+// single-precision (32-bit) floating-point element, and store the results in
+// the upper 2 elements of dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvtpi32x2_ps
+FORCE_INLINE __m128 _mm_cvtpi32x2_ps(__m64 a, __m64 b)
+{
+    return vreinterpretq_m128_f32(vcvtq_f32_s32(
+        vcombine_s32(vreinterpret_s32_m64(a), vreinterpret_s32_m64(b))));
+}
+
+// Convert the lower packed 8-bit integers in a to packed single-precision
+// (32-bit) floating-point elements, and store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvtpi8_ps
+FORCE_INLINE __m128 _mm_cvtpi8_ps(__m64 a)
+{
+    return vreinterpretq_m128_f32(vcvtq_f32_s32(
+        vmovl_s16(vget_low_s16(vmovl_s8(vreinterpret_s8_m64(a))))));
+}
+
+// Convert packed single-precision (32-bit) floating-point elements in a to
+// packed 16-bit integers, and store the results in dst. Note: this intrinsic
+// will generate 0x7FFF, rather than 0x8000, for input values between 0x7FFF and
+// 0x7FFFFFFF.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvtps_pi16
+FORCE_INLINE __m64 _mm_cvtps_pi16(__m128 a)
+{
+    return vreinterpret_m64_s16(
+        vqmovn_s32(vreinterpretq_s32_m128i(_mm_cvtps_epi32(a))));
+}
+
+// Convert packed single-precision (32-bit) floating-point elements in a to
+// packed 32-bit integers, and store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvtps_pi32
+#define _mm_cvtps_pi32(a) _mm_cvt_ps2pi(a)
+
+// Convert packed single-precision (32-bit) floating-point elements in a to
+// packed 8-bit integers, and store the results in lower 4 elements of dst.
+// Note: this intrinsic will generate 0x7F, rather than 0x80, for input values
+// between 0x7F and 0x7FFFFFFF.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvtps_pi8
+FORCE_INLINE __m64 _mm_cvtps_pi8(__m128 a)
+{
+    return vreinterpret_m64_s8(vqmovn_s16(
+        vcombine_s16(vreinterpret_s16_m64(_mm_cvtps_pi16(a)), vdup_n_s16(0))));
+}
+
+// Convert packed unsigned 16-bit integers in a to packed single-precision
+// (32-bit) floating-point elements, and store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvtpu16_ps
+FORCE_INLINE __m128 _mm_cvtpu16_ps(__m64 a)
+{
+    return vreinterpretq_m128_f32(
+        vcvtq_f32_u32(vmovl_u16(vreinterpret_u16_m64(a))));
+}
+
+// Convert the lower packed unsigned 8-bit integers in a to packed
+// single-precision (32-bit) floating-point elements, and store the results in
+// dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvtpu8_ps
+FORCE_INLINE __m128 _mm_cvtpu8_ps(__m64 a)
+{
+    return vreinterpretq_m128_f32(vcvtq_f32_u32(
+        vmovl_u16(vget_low_u16(vmovl_u8(vreinterpret_u8_m64(a))))));
+}
+
+// Convert the signed 32-bit integer b to a single-precision (32-bit)
+// floating-point element, store the result in the lower element of dst, and
+// copy the upper 3 packed elements from a to the upper elements of dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvtsi32_ss
+#define _mm_cvtsi32_ss(a, b) _mm_cvt_si2ss(a, b)
+
+// Convert the signed 64-bit integer b to a single-precision (32-bit)
+// floating-point element, store the result in the lower element of dst, and
+// copy the upper 3 packed elements from a to the upper elements of dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvtsi64_ss
+FORCE_INLINE __m128 _mm_cvtsi64_ss(__m128 a, int64_t b)
+{
+    return vreinterpretq_m128_f32(
+        vsetq_lane_f32((float) b, vreinterpretq_f32_m128(a), 0));
+}
+
+// Copy the lower single-precision (32-bit) floating-point element of a to dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvtss_f32
+FORCE_INLINE float _mm_cvtss_f32(__m128 a)
+{
+    return vgetq_lane_f32(vreinterpretq_f32_m128(a), 0);
+}
+
+// Convert the lower single-precision (32-bit) floating-point element in a to a
+// 32-bit integer, and store the result in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvtss_si32
+#define _mm_cvtss_si32(a) _mm_cvt_ss2si(a)
+
+// Convert the lower single-precision (32-bit) floating-point element in a to a
+// 64-bit integer, and store the result in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvtss_si64
+FORCE_INLINE int64_t _mm_cvtss_si64(__m128 a)
+{
+#if (defined(__aarch64__) || defined(_M_ARM64)) || \
+    defined(__ARM_FEATURE_DIRECTED_ROUNDING)
+    return (int64_t) vgetq_lane_f32(vrndiq_f32(vreinterpretq_f32_m128(a)), 0);
+#else
+    float32_t data = vgetq_lane_f32(
+        vreinterpretq_f32_m128(_mm_round_ps(a, _MM_FROUND_CUR_DIRECTION)), 0);
+    return (int64_t) data;
+#endif
+}
+
+// Convert packed single-precision (32-bit) floating-point elements in a to
+// packed 32-bit integers with truncation, and store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvtt_ps2pi
+FORCE_INLINE __m64 _mm_cvtt_ps2pi(__m128 a)
+{
+    return vreinterpret_m64_s32(
+        vget_low_s32(vcvtq_s32_f32(vreinterpretq_f32_m128(a))));
+}
+
+// Convert the lower single-precision (32-bit) floating-point element in a to a
+// 32-bit integer with truncation, and store the result in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvtt_ss2si
+FORCE_INLINE int _mm_cvtt_ss2si(__m128 a)
+{
+    return vgetq_lane_s32(vcvtq_s32_f32(vreinterpretq_f32_m128(a)), 0);
+}
+
+// Convert packed single-precision (32-bit) floating-point elements in a to
+// packed 32-bit integers with truncation, and store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvttps_pi32
+#define _mm_cvttps_pi32(a) _mm_cvtt_ps2pi(a)
+
+// Convert the lower single-precision (32-bit) floating-point element in a to a
+// 32-bit integer with truncation, and store the result in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvttss_si32
+#define _mm_cvttss_si32(a) _mm_cvtt_ss2si(a)
+
+// Convert the lower single-precision (32-bit) floating-point element in a to a
+// 64-bit integer with truncation, and store the result in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvttss_si64
+FORCE_INLINE int64_t _mm_cvttss_si64(__m128 a)
+{
+    return (int64_t) vgetq_lane_f32(vreinterpretq_f32_m128(a), 0);
+}
+
+// Divide packed single-precision (32-bit) floating-point elements in a by
+// packed elements in b, and store the results in dst.
+// Due to ARMv7-A NEON's lack of a precise division intrinsic, we implement
+// division by multiplying a by b's reciprocal before using the Newton-Raphson
+// method to approximate the results.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_div_ps
+FORCE_INLINE __m128 _mm_div_ps(__m128 a, __m128 b)
+{
+#if (defined(__aarch64__) || defined(_M_ARM64)) && !SSE2NEON_PRECISE_DIV
+    return vreinterpretq_m128_f32(
+        vdivq_f32(vreinterpretq_f32_m128(a), vreinterpretq_f32_m128(b)));
+#else
+    float32x4_t recip = vrecpeq_f32(vreinterpretq_f32_m128(b));
+    recip = vmulq_f32(recip, vrecpsq_f32(recip, vreinterpretq_f32_m128(b)));
+    // Additional Netwon-Raphson iteration for accuracy
+    recip = vmulq_f32(recip, vrecpsq_f32(recip, vreinterpretq_f32_m128(b)));
+    return vreinterpretq_m128_f32(vmulq_f32(vreinterpretq_f32_m128(a), recip));
+#endif
+}
+
+// Divide the lower single-precision (32-bit) floating-point element in a by the
+// lower single-precision (32-bit) floating-point element in b, store the result
+// in the lower element of dst, and copy the upper 3 packed elements from a to
+// the upper elements of dst.
+// Warning: ARMv7-A does not produce the same result compared to Intel and not
+// IEEE-compliant.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_div_ss
+FORCE_INLINE __m128 _mm_div_ss(__m128 a, __m128 b)
+{
+    float32_t value =
+        vgetq_lane_f32(vreinterpretq_f32_m128(_mm_div_ps(a, b)), 0);
+    return vreinterpretq_m128_f32(
+        vsetq_lane_f32(value, vreinterpretq_f32_m128(a), 0));
+}
+
+// Extract a 16-bit integer from a, selected with imm8, and store the result in
+// the lower element of dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_extract_pi16
+#define _mm_extract_pi16(a, imm) \
+    (int32_t) vget_lane_u16(vreinterpret_u16_m64(a), (imm))
+
+// Free aligned memory that was allocated with _mm_malloc.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_free
+#if !defined(SSE2NEON_ALLOC_DEFINED)
+FORCE_INLINE void _mm_free(void *addr)
+{
+    free(addr);
+}
+#endif
+
+FORCE_INLINE uint64_t _sse2neon_get_fpcr(void)
+{
+    uint64_t value;
+#if defined(_MSC_VER)
+    value = _ReadStatusReg(ARM64_FPCR);
+#else
+    __asm__ __volatile__("mrs %0, FPCR" : "=r"(value)); /* read */
+#endif
+    return value;
+}
+
+FORCE_INLINE void _sse2neon_set_fpcr(uint64_t value)
+{
+#if defined(_MSC_VER)
+    _WriteStatusReg(ARM64_FPCR, value);
+#else
+    __asm__ __volatile__("msr FPCR, %0" ::"r"(value));  /* write */
+#endif
+}
+
+// Macro: Get the flush zero bits from the MXCSR control and status register.
+// The flush zero may contain any of the following flags: _MM_FLUSH_ZERO_ON or
+// _MM_FLUSH_ZERO_OFF
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_MM_GET_FLUSH_ZERO_MODE
+FORCE_INLINE unsigned int _sse2neon_mm_get_flush_zero_mode(void)
+{
+    union {
+        fpcr_bitfield field;
+#if defined(__aarch64__) || defined(_M_ARM64)
+        uint64_t value;
+#else
+        uint32_t value;
+#endif
+    } r;
+
+#if defined(__aarch64__) || defined(_M_ARM64)
+    r.value = _sse2neon_get_fpcr();
+#else
+    __asm__ __volatile__("vmrs %0, FPSCR" : "=r"(r.value)); /* read */
+#endif
+
+    return r.field.bit24 ? _MM_FLUSH_ZERO_ON : _MM_FLUSH_ZERO_OFF;
+}
+
+// Macro: Get the rounding mode bits from the MXCSR control and status register.
+// The rounding mode may contain any of the following flags: _MM_ROUND_NEAREST,
+// _MM_ROUND_DOWN, _MM_ROUND_UP, _MM_ROUND_TOWARD_ZERO
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_MM_GET_ROUNDING_MODE
+FORCE_INLINE unsigned int _MM_GET_ROUNDING_MODE(void)
+{
+    union {
+        fpcr_bitfield field;
+#if defined(__aarch64__) || defined(_M_ARM64)
+        uint64_t value;
+#else
+        uint32_t value;
+#endif
+    } r;
+
+#if defined(__aarch64__) || defined(_M_ARM64)
+    r.value = _sse2neon_get_fpcr();
+#else
+    __asm__ __volatile__("vmrs %0, FPSCR" : "=r"(r.value)); /* read */
+#endif
+
+    if (r.field.bit22) {
+        return r.field.bit23 ? _MM_ROUND_TOWARD_ZERO : _MM_ROUND_UP;
+    } else {
+        return r.field.bit23 ? _MM_ROUND_DOWN : _MM_ROUND_NEAREST;
+    }
+}
+
+// Copy a to dst, and insert the 16-bit integer i into dst at the location
+// specified by imm8.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_insert_pi16
+#define _mm_insert_pi16(a, b, imm) \
+    vreinterpret_m64_s16(vset_lane_s16((b), vreinterpret_s16_m64(a), (imm)))
+
+// Load 128-bits (composed of 4 packed single-precision (32-bit) floating-point
+// elements) from memory into dst. mem_addr must be aligned on a 16-byte
+// boundary or a general-protection exception may be generated.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_load_ps
+FORCE_INLINE __m128 _mm_load_ps(const float *p)
+{
+    return vreinterpretq_m128_f32(vld1q_f32(p));
+}
+
+// Load a single-precision (32-bit) floating-point element from memory into all
+// elements of dst.
+//
+//   dst[31:0] := MEM[mem_addr+31:mem_addr]
+//   dst[63:32] := MEM[mem_addr+31:mem_addr]
+//   dst[95:64] := MEM[mem_addr+31:mem_addr]
+//   dst[127:96] := MEM[mem_addr+31:mem_addr]
+//
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_load_ps1
+#define _mm_load_ps1 _mm_load1_ps
+
+// Load a single-precision (32-bit) floating-point element from memory into the
+// lower of dst, and zero the upper 3 elements. mem_addr does not need to be
+// aligned on any particular boundary.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_load_ss
+FORCE_INLINE __m128 _mm_load_ss(const float *p)
+{
+    return vreinterpretq_m128_f32(vsetq_lane_f32(*p, vdupq_n_f32(0), 0));
+}
+
+// Load a single-precision (32-bit) floating-point element from memory into all
+// elements of dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_load1_ps
+FORCE_INLINE __m128 _mm_load1_ps(const float *p)
+{
+    return vreinterpretq_m128_f32(vld1q_dup_f32(p));
+}
+
+// Load 2 single-precision (32-bit) floating-point elements from memory into the
+// upper 2 elements of dst, and copy the lower 2 elements from a to dst.
+// mem_addr does not need to be aligned on any particular boundary.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_loadh_pi
+FORCE_INLINE __m128 _mm_loadh_pi(__m128 a, __m64 const *p)
+{
+    return vreinterpretq_m128_f32(
+        vcombine_f32(vget_low_f32(a), vld1_f32((const float32_t *) p)));
+}
+
+// Load 2 single-precision (32-bit) floating-point elements from memory into the
+// lower 2 elements of dst, and copy the upper 2 elements from a to dst.
+// mem_addr does not need to be aligned on any particular boundary.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_loadl_pi
+FORCE_INLINE __m128 _mm_loadl_pi(__m128 a, __m64 const *p)
+{
+    return vreinterpretq_m128_f32(
+        vcombine_f32(vld1_f32((const float32_t *) p), vget_high_f32(a)));
+}
+
+// Load 4 single-precision (32-bit) floating-point elements from memory into dst
+// in reverse order. mem_addr must be aligned on a 16-byte boundary or a
+// general-protection exception may be generated.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_loadr_ps
+FORCE_INLINE __m128 _mm_loadr_ps(const float *p)
+{
+    float32x4_t v = vrev64q_f32(vld1q_f32(p));
+    return vreinterpretq_m128_f32(vextq_f32(v, v, 2));
+}
+
+// Load 128-bits (composed of 4 packed single-precision (32-bit) floating-point
+// elements) from memory into dst. mem_addr does not need to be aligned on any
+// particular boundary.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_loadu_ps
+FORCE_INLINE __m128 _mm_loadu_ps(const float *p)
+{
+    // for neon, alignment doesn't matter, so _mm_load_ps and _mm_loadu_ps are
+    // equivalent for neon
+    return vreinterpretq_m128_f32(vld1q_f32(p));
+}
+
+// Load unaligned 16-bit integer from memory into the first element of dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_loadu_si16
+FORCE_INLINE __m128i _mm_loadu_si16(const void *p)
+{
+    return vreinterpretq_m128i_s16(
+        vsetq_lane_s16(*(const int16_t *) p, vdupq_n_s16(0), 0));
+}
+
+// Load unaligned 64-bit integer from memory into the first element of dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_loadu_si64
+FORCE_INLINE __m128i _mm_loadu_si64(const void *p)
+{
+    return vreinterpretq_m128i_s64(
+        vcombine_s64(vld1_s64((const int64_t *) p), vdup_n_s64(0)));
+}
+
+// Allocate size bytes of memory, aligned to the alignment specified in align,
+// and return a pointer to the allocated memory. _mm_free should be used to free
+// memory that is allocated with _mm_malloc.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_malloc
+#if !defined(SSE2NEON_ALLOC_DEFINED)
+FORCE_INLINE void *_mm_malloc(size_t size, size_t align)
+{
+    void *ptr;
+    if (align == 1)
+        return malloc(size);
+    if (align == 2 || (sizeof(void *) == 8 && align == 4))
+        align = sizeof(void *);
+    if (!posix_memalign(&ptr, align, size))
+        return ptr;
+    return NULL;
+}
+#endif
+
+// Conditionally store 8-bit integer elements from a into memory using mask
+// (elements are not stored when the highest bit is not set in the corresponding
+// element) and a non-temporal memory hint.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskmove_si64
+FORCE_INLINE void _mm_maskmove_si64(__m64 a, __m64 mask, char *mem_addr)
+{
+    int8x8_t shr_mask = vshr_n_s8(vreinterpret_s8_m64(mask), 7);
+    __m128 b = _mm_load_ps((const float *) mem_addr);
+    int8x8_t masked =
+        vbsl_s8(vreinterpret_u8_s8(shr_mask), vreinterpret_s8_m64(a),
+                vreinterpret_s8_u64(vget_low_u64(vreinterpretq_u64_m128(b))));
+    vst1_s8((int8_t *) mem_addr, masked);
+}
+
+// Conditionally store 8-bit integer elements from a into memory using mask
+// (elements are not stored when the highest bit is not set in the corresponding
+// element) and a non-temporal memory hint.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_m_maskmovq
+#define _m_maskmovq(a, mask, mem_addr) _mm_maskmove_si64(a, mask, mem_addr)
+
+// Compare packed signed 16-bit integers in a and b, and store packed maximum
+// values in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_max_pi16
+FORCE_INLINE __m64 _mm_max_pi16(__m64 a, __m64 b)
+{
+    return vreinterpret_m64_s16(
+        vmax_s16(vreinterpret_s16_m64(a), vreinterpret_s16_m64(b)));
+}
+
+// Compare packed single-precision (32-bit) floating-point elements in a and b,
+// and store packed maximum values in dst. dst does not follow the IEEE Standard
+// for Floating-Point Arithmetic (IEEE 754) maximum value when inputs are NaN or
+// signed-zero values.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_max_ps
+FORCE_INLINE __m128 _mm_max_ps(__m128 a, __m128 b)
+{
+#if SSE2NEON_PRECISE_MINMAX
+    float32x4_t _a = vreinterpretq_f32_m128(a);
+    float32x4_t _b = vreinterpretq_f32_m128(b);
+    return vreinterpretq_m128_f32(vbslq_f32(vcgtq_f32(_a, _b), _a, _b));
+#else
+    return vreinterpretq_m128_f32(
+        vmaxq_f32(vreinterpretq_f32_m128(a), vreinterpretq_f32_m128(b)));
+#endif
+}
+
+// Compare packed unsigned 8-bit integers in a and b, and store packed maximum
+// values in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_max_pu8
+FORCE_INLINE __m64 _mm_max_pu8(__m64 a, __m64 b)
+{
+    return vreinterpret_m64_u8(
+        vmax_u8(vreinterpret_u8_m64(a), vreinterpret_u8_m64(b)));
+}
+
+// Compare the lower single-precision (32-bit) floating-point elements in a and
+// b, store the maximum value in the lower element of dst, and copy the upper 3
+// packed elements from a to the upper element of dst. dst does not follow the
+// IEEE Standard for Floating-Point Arithmetic (IEEE 754) maximum value when
+// inputs are NaN or signed-zero values.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_max_ss
+FORCE_INLINE __m128 _mm_max_ss(__m128 a, __m128 b)
+{
+    float32_t value = vgetq_lane_f32(_mm_max_ps(a, b), 0);
+    return vreinterpretq_m128_f32(
+        vsetq_lane_f32(value, vreinterpretq_f32_m128(a), 0));
+}
+
+// Compare packed signed 16-bit integers in a and b, and store packed minimum
+// values in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_min_pi16
+FORCE_INLINE __m64 _mm_min_pi16(__m64 a, __m64 b)
+{
+    return vreinterpret_m64_s16(
+        vmin_s16(vreinterpret_s16_m64(a), vreinterpret_s16_m64(b)));
+}
+
+// Compare packed single-precision (32-bit) floating-point elements in a and b,
+// and store packed minimum values in dst. dst does not follow the IEEE Standard
+// for Floating-Point Arithmetic (IEEE 754) minimum value when inputs are NaN or
+// signed-zero values.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_min_ps
+FORCE_INLINE __m128 _mm_min_ps(__m128 a, __m128 b)
+{
+#if SSE2NEON_PRECISE_MINMAX
+    float32x4_t _a = vreinterpretq_f32_m128(a);
+    float32x4_t _b = vreinterpretq_f32_m128(b);
+    return vreinterpretq_m128_f32(vbslq_f32(vcltq_f32(_a, _b), _a, _b));
+#else
+    return vreinterpretq_m128_f32(
+        vminq_f32(vreinterpretq_f32_m128(a), vreinterpretq_f32_m128(b)));
+#endif
+}
+
+// Compare packed unsigned 8-bit integers in a and b, and store packed minimum
+// values in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_min_pu8
+FORCE_INLINE __m64 _mm_min_pu8(__m64 a, __m64 b)
+{
+    return vreinterpret_m64_u8(
+        vmin_u8(vreinterpret_u8_m64(a), vreinterpret_u8_m64(b)));
+}
+
+// Compare the lower single-precision (32-bit) floating-point elements in a and
+// b, store the minimum value in the lower element of dst, and copy the upper 3
+// packed elements from a to the upper element of dst. dst does not follow the
+// IEEE Standard for Floating-Point Arithmetic (IEEE 754) minimum value when
+// inputs are NaN or signed-zero values.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_min_ss
+FORCE_INLINE __m128 _mm_min_ss(__m128 a, __m128 b)
+{
+    float32_t value = vgetq_lane_f32(_mm_min_ps(a, b), 0);
+    return vreinterpretq_m128_f32(
+        vsetq_lane_f32(value, vreinterpretq_f32_m128(a), 0));
+}
+
+// Move the lower single-precision (32-bit) floating-point element from b to the
+// lower element of dst, and copy the upper 3 packed elements from a to the
+// upper elements of dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_move_ss
+FORCE_INLINE __m128 _mm_move_ss(__m128 a, __m128 b)
+{
+    return vreinterpretq_m128_f32(
+        vsetq_lane_f32(vgetq_lane_f32(vreinterpretq_f32_m128(b), 0),
+                       vreinterpretq_f32_m128(a), 0));
+}
+
+// Move the upper 2 single-precision (32-bit) floating-point elements from b to
+// the lower 2 elements of dst, and copy the upper 2 elements from a to the
+// upper 2 elements of dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_movehl_ps
+FORCE_INLINE __m128 _mm_movehl_ps(__m128 a, __m128 b)
+{
+#if defined(aarch64__)
+    return vreinterpretq_m128_u64(
+        vzip2q_u64(vreinterpretq_u64_m128(b), vreinterpretq_u64_m128(a)));
+#else
+    float32x2_t a32 = vget_high_f32(vreinterpretq_f32_m128(a));
+    float32x2_t b32 = vget_high_f32(vreinterpretq_f32_m128(b));
+    return vreinterpretq_m128_f32(vcombine_f32(b32, a32));
+#endif
+}
+
+// Move the lower 2 single-precision (32-bit) floating-point elements from b to
+// the upper 2 elements of dst, and copy the lower 2 elements from a to the
+// lower 2 elements of dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_movelh_ps
+FORCE_INLINE __m128 _mm_movelh_ps(__m128 __A, __m128 __B)
+{
+    float32x2_t a10 = vget_low_f32(vreinterpretq_f32_m128(__A));
+    float32x2_t b10 = vget_low_f32(vreinterpretq_f32_m128(__B));
+    return vreinterpretq_m128_f32(vcombine_f32(a10, b10));
+}
+
+// Create mask from the most significant bit of each 8-bit element in a, and
+// store the result in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_movemask_pi8
+FORCE_INLINE int _mm_movemask_pi8(__m64 a)
+{
+    uint8x8_t input = vreinterpret_u8_m64(a);
+#if defined(__aarch64__) || defined(_M_ARM64)
+    static const int8_t shift[8] = {0, 1, 2, 3, 4, 5, 6, 7};
+    uint8x8_t tmp = vshr_n_u8(input, 7);
+    return vaddv_u8(vshl_u8(tmp, vld1_s8(shift)));
+#else
+    // Refer the implementation of `_mm_movemask_epi8`
+    uint16x4_t high_bits = vreinterpret_u16_u8(vshr_n_u8(input, 7));
+    uint32x2_t paired16 =
+        vreinterpret_u32_u16(vsra_n_u16(high_bits, high_bits, 7));
+    uint8x8_t paired32 =
+        vreinterpret_u8_u32(vsra_n_u32(paired16, paired16, 14));
+    return vget_lane_u8(paired32, 0) | ((int) vget_lane_u8(paired32, 4) << 4);
+#endif
+}
+
+// Set each bit of mask dst based on the most significant bit of the
+// corresponding packed single-precision (32-bit) floating-point element in a.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_movemask_ps
+FORCE_INLINE int _mm_movemask_ps(__m128 a)
+{
+    uint32x4_t input = vreinterpretq_u32_m128(a);
+#if defined(__aarch64__) || defined(_M_ARM64)
+    static const int32_t shift[4] = {0, 1, 2, 3};
+    uint32x4_t tmp = vshrq_n_u32(input, 31);
+    return vaddvq_u32(vshlq_u32(tmp, vld1q_s32(shift)));
+#else
+    // Uses the exact same method as _mm_movemask_epi8, see that for details.
+    // Shift out everything but the sign bits with a 32-bit unsigned shift
+    // right.
+    uint64x2_t high_bits = vreinterpretq_u64_u32(vshrq_n_u32(input, 31));
+    // Merge the two pairs together with a 64-bit unsigned shift right + add.
+    uint8x16_t paired =
+        vreinterpretq_u8_u64(vsraq_n_u64(high_bits, high_bits, 31));
+    // Extract the result.
+    return vgetq_lane_u8(paired, 0) | (vgetq_lane_u8(paired, 8) << 2);
+#endif
+}
+
+// Multiply packed single-precision (32-bit) floating-point elements in a and b,
+// and store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mul_ps
+FORCE_INLINE __m128 _mm_mul_ps(__m128 a, __m128 b)
+{
+    return vreinterpretq_m128_f32(
+        vmulq_f32(vreinterpretq_f32_m128(a), vreinterpretq_f32_m128(b)));
+}
+
+// Multiply the lower single-precision (32-bit) floating-point element in a and
+// b, store the result in the lower element of dst, and copy the upper 3 packed
+// elements from a to the upper elements of dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mul_ss
+FORCE_INLINE __m128 _mm_mul_ss(__m128 a, __m128 b)
+{
+    return _mm_move_ss(a, _mm_mul_ps(a, b));
+}
+
+// Multiply the packed unsigned 16-bit integers in a and b, producing
+// intermediate 32-bit integers, and store the high 16 bits of the intermediate
+// integers in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mulhi_pu16
+FORCE_INLINE __m64 _mm_mulhi_pu16(__m64 a, __m64 b)
+{
+    return vreinterpret_m64_u16(vshrn_n_u32(
+        vmull_u16(vreinterpret_u16_m64(a), vreinterpret_u16_m64(b)), 16));
+}
+
+// Compute the bitwise OR of packed single-precision (32-bit) floating-point
+// elements in a and b, and store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_or_ps
+FORCE_INLINE __m128 _mm_or_ps(__m128 a, __m128 b)
+{
+    return vreinterpretq_m128_s32(
+        vorrq_s32(vreinterpretq_s32_m128(a), vreinterpretq_s32_m128(b)));
+}
+
+// Average packed unsigned 8-bit integers in a and b, and store the results in
+// dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_m_pavgb
+#define _m_pavgb(a, b) _mm_avg_pu8(a, b)
+
+// Average packed unsigned 16-bit integers in a and b, and store the results in
+// dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_m_pavgw
+#define _m_pavgw(a, b) _mm_avg_pu16(a, b)
+
+// Extract a 16-bit integer from a, selected with imm8, and store the result in
+// the lower element of dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_m_pextrw
+#define _m_pextrw(a, imm) _mm_extract_pi16(a, imm)
+
+// Copy a to dst, and insert the 16-bit integer i into dst at the location
+// specified by imm8.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=m_pinsrw
+#define _m_pinsrw(a, i, imm) _mm_insert_pi16(a, i, imm)
+
+// Compare packed signed 16-bit integers in a and b, and store packed maximum
+// values in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_m_pmaxsw
+#define _m_pmaxsw(a, b) _mm_max_pi16(a, b)
+
+// Compare packed unsigned 8-bit integers in a and b, and store packed maximum
+// values in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_m_pmaxub
+#define _m_pmaxub(a, b) _mm_max_pu8(a, b)
+
+// Compare packed signed 16-bit integers in a and b, and store packed minimum
+// values in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_m_pminsw
+#define _m_pminsw(a, b) _mm_min_pi16(a, b)
+
+// Compare packed unsigned 8-bit integers in a and b, and store packed minimum
+// values in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_m_pminub
+#define _m_pminub(a, b) _mm_min_pu8(a, b)
+
+// Create mask from the most significant bit of each 8-bit element in a, and
+// store the result in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_m_pmovmskb
+#define _m_pmovmskb(a) _mm_movemask_pi8(a)
+
+// Multiply the packed unsigned 16-bit integers in a and b, producing
+// intermediate 32-bit integers, and store the high 16 bits of the intermediate
+// integers in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_m_pmulhuw
+#define _m_pmulhuw(a, b) _mm_mulhi_pu16(a, b)
+
+// Fetch the line of data from memory that contains address p to a location in
+// the cache hierarchy specified by the locality hint i.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_prefetch
+FORCE_INLINE void _mm_prefetch(char const *p, int i)
+{
+    (void) i;
+#if defined(_MSC_VER)
+    switch (i) {
+    case _MM_HINT_NTA:
+        __prefetch2(p, 1);
+        break;
+    case _MM_HINT_T0:
+        __prefetch2(p, 0);
+        break;
+    case _MM_HINT_T1:
+        __prefetch2(p, 2);
+        break;
+    case _MM_HINT_T2:
+        __prefetch2(p, 4);
+        break;
+    }
+#else
+    switch (i) {
+    case _MM_HINT_NTA:
+        __builtin_prefetch(p, 0, 0);
+        break;
+    case _MM_HINT_T0:
+        __builtin_prefetch(p, 0, 3);
+        break;
+    case _MM_HINT_T1:
+        __builtin_prefetch(p, 0, 2);
+        break;
+    case _MM_HINT_T2:
+        __builtin_prefetch(p, 0, 1);
+        break;
+    }
+#endif
+}
+
+// Compute the absolute differences of packed unsigned 8-bit integers in a and
+// b, then horizontally sum each consecutive 8 differences to produce four
+// unsigned 16-bit integers, and pack these unsigned 16-bit integers in the low
+// 16 bits of dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=m_psadbw
+#define _m_psadbw(a, b) _mm_sad_pu8(a, b)
+
+// Shuffle 16-bit integers in a using the control in imm8, and store the results
+// in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_m_pshufw
+#define _m_pshufw(a, imm) _mm_shuffle_pi16(a, imm)
+
+// Compute the approximate reciprocal of packed single-precision (32-bit)
+// floating-point elements in a, and store the results in dst. The maximum
+// relative error for this approximation is less than 1.5*2^-12.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_rcp_ps
+FORCE_INLINE __m128 _mm_rcp_ps(__m128 in)
+{
+    float32x4_t recip = vrecpeq_f32(vreinterpretq_f32_m128(in));
+    recip = vmulq_f32(recip, vrecpsq_f32(recip, vreinterpretq_f32_m128(in)));
+#if SSE2NEON_PRECISE_DIV
+    // Additional Netwon-Raphson iteration for accuracy
+    recip = vmulq_f32(recip, vrecpsq_f32(recip, vreinterpretq_f32_m128(in)));
+#endif
+    return vreinterpretq_m128_f32(recip);
+}
+
+// Compute the approximate reciprocal of the lower single-precision (32-bit)
+// floating-point element in a, store the result in the lower element of dst,
+// and copy the upper 3 packed elements from a to the upper elements of dst. The
+// maximum relative error for this approximation is less than 1.5*2^-12.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_rcp_ss
+FORCE_INLINE __m128 _mm_rcp_ss(__m128 a)
+{
+    return _mm_move_ss(a, _mm_rcp_ps(a));
+}
+
+// Compute the approximate reciprocal square root of packed single-precision
+// (32-bit) floating-point elements in a, and store the results in dst. The
+// maximum relative error for this approximation is less than 1.5*2^-12.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_rsqrt_ps
+FORCE_INLINE __m128 _mm_rsqrt_ps(__m128 in)
+{
+    float32x4_t out = vrsqrteq_f32(vreinterpretq_f32_m128(in));
+
+    // Generate masks for detecting whether input has any 0.0f/-0.0f
+    // (which becomes positive/negative infinity by IEEE-754 arithmetic rules).
+    const uint32x4_t pos_inf = vdupq_n_u32(0x7F800000);
+    const uint32x4_t neg_inf = vdupq_n_u32(0xFF800000);
+    const uint32x4_t has_pos_zero =
+        vceqq_u32(pos_inf, vreinterpretq_u32_f32(out));
+    const uint32x4_t has_neg_zero =
+        vceqq_u32(neg_inf, vreinterpretq_u32_f32(out));
+
+    out = vmulq_f32(
+        out, vrsqrtsq_f32(vmulq_f32(vreinterpretq_f32_m128(in), out), out));
+#if SSE2NEON_PRECISE_SQRT
+    // Additional Netwon-Raphson iteration for accuracy
+    out = vmulq_f32(
+        out, vrsqrtsq_f32(vmulq_f32(vreinterpretq_f32_m128(in), out), out));
+#endif
+
+    // Set output vector element to infinity/negative-infinity if
+    // the corresponding input vector element is 0.0f/-0.0f.
+    out = vbslq_f32(has_pos_zero, (float32x4_t) pos_inf, out);
+    out = vbslq_f32(has_neg_zero, (float32x4_t) neg_inf, out);
+
+    return vreinterpretq_m128_f32(out);
+}
+
+// Compute the approximate reciprocal square root of the lower single-precision
+// (32-bit) floating-point element in a, store the result in the lower element
+// of dst, and copy the upper 3 packed elements from a to the upper elements of
+// dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_rsqrt_ss
+FORCE_INLINE __m128 _mm_rsqrt_ss(__m128 in)
+{
+    return vsetq_lane_f32(vgetq_lane_f32(_mm_rsqrt_ps(in), 0), in, 0);
+}
+
+// Compute the absolute differences of packed unsigned 8-bit integers in a and
+// b, then horizontally sum each consecutive 8 differences to produce four
+// unsigned 16-bit integers, and pack these unsigned 16-bit integers in the low
+// 16 bits of dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_sad_pu8
+FORCE_INLINE __m64 _mm_sad_pu8(__m64 a, __m64 b)
+{
+    uint64x1_t t = vpaddl_u32(vpaddl_u16(
+        vpaddl_u8(vabd_u8(vreinterpret_u8_m64(a), vreinterpret_u8_m64(b)))));
+    return vreinterpret_m64_u16(
+        vset_lane_u16((int) vget_lane_u64(t, 0), vdup_n_u16(0), 0));
+}
+
+// Macro: Set the flush zero bits of the MXCSR control and status register to
+// the value in unsigned 32-bit integer a. The flush zero may contain any of the
+// following flags: _MM_FLUSH_ZERO_ON or _MM_FLUSH_ZERO_OFF
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_MM_SET_FLUSH_ZERO_MODE
+FORCE_INLINE void _sse2neon_mm_set_flush_zero_mode(unsigned int flag)
+{
+    // AArch32 Advanced SIMD arithmetic always uses the Flush-to-zero setting,
+    // regardless of the value of the FZ bit.
+    union {
+        fpcr_bitfield field;
+#if defined(__aarch64__) || defined(_M_ARM64)
+        uint64_t value;
+#else
+        uint32_t value;
+#endif
+    } r;
+
+#if defined(__aarch64__) || defined(_M_ARM64)
+    r.value = _sse2neon_get_fpcr();
+#else
+    __asm__ __volatile__("vmrs %0, FPSCR" : "=r"(r.value)); /* read */
+#endif
+
+    r.field.bit24 = (flag & _MM_FLUSH_ZERO_MASK) == _MM_FLUSH_ZERO_ON;
+
+#if defined(__aarch64__) || defined(_M_ARM64)
+    _sse2neon_set_fpcr(r.value);
+#else
+    __asm__ __volatile__("vmsr FPSCR, %0" ::"r"(r));        /* write */
+#endif
+}
+
+// Set packed single-precision (32-bit) floating-point elements in dst with the
+// supplied values.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_set_ps
+FORCE_INLINE __m128 _mm_set_ps(float w, float z, float y, float x)
+{
+    float ALIGN_STRUCT(16) data[4] = {x, y, z, w};
+    return vreinterpretq_m128_f32(vld1q_f32(data));
+}
+
+// Broadcast single-precision (32-bit) floating-point value a to all elements of
+// dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_set_ps1
+FORCE_INLINE __m128 _mm_set_ps1(float _w)
+{
+    return vreinterpretq_m128_f32(vdupq_n_f32(_w));
+}
+
+// Macro: Set the rounding mode bits of the MXCSR control and status register to
+// the value in unsigned 32-bit integer a. The rounding mode may contain any of
+// the following flags: _MM_ROUND_NEAREST, _MM_ROUND_DOWN, _MM_ROUND_UP,
+// _MM_ROUND_TOWARD_ZERO
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_MM_SET_ROUNDING_MODE
+FORCE_INLINE void _MM_SET_ROUNDING_MODE(int rounding)
+{
+    union {
+        fpcr_bitfield field;
+#if defined(__aarch64__) || defined(_M_ARM64)
+        uint64_t value;
+#else
+        uint32_t value;
+#endif
+    } r;
+
+#if defined(__aarch64__) || defined(_M_ARM64)
+    r.value = _sse2neon_get_fpcr();
+#else
+    __asm__ __volatile__("vmrs %0, FPSCR" : "=r"(r.value)); /* read */
+#endif
+
+    switch (rounding) {
+    case _MM_ROUND_TOWARD_ZERO:
+        r.field.bit22 = 1;
+        r.field.bit23 = 1;
+        break;
+    case _MM_ROUND_DOWN:
+        r.field.bit22 = 0;
+        r.field.bit23 = 1;
+        break;
+    case _MM_ROUND_UP:
+        r.field.bit22 = 1;
+        r.field.bit23 = 0;
+        break;
+    default:  //_MM_ROUND_NEAREST
+        r.field.bit22 = 0;
+        r.field.bit23 = 0;
+    }
+
+#if defined(__aarch64__) || defined(_M_ARM64)
+    _sse2neon_set_fpcr(r.value);
+#else
+    __asm__ __volatile__("vmsr FPSCR, %0" ::"r"(r));        /* write */
+#endif
+}
+
+// Copy single-precision (32-bit) floating-point element a to the lower element
+// of dst, and zero the upper 3 elements.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_set_ss
+FORCE_INLINE __m128 _mm_set_ss(float a)
+{
+    return vreinterpretq_m128_f32(vsetq_lane_f32(a, vdupq_n_f32(0), 0));
+}
+
+// Broadcast single-precision (32-bit) floating-point value a to all elements of
+// dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_set1_ps
+FORCE_INLINE __m128 _mm_set1_ps(float _w)
+{
+    return vreinterpretq_m128_f32(vdupq_n_f32(_w));
+}
+
+// Set the MXCSR control and status register with the value in unsigned 32-bit
+// integer a.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_setcsr
+// FIXME: _mm_setcsr() implementation supports changing the rounding mode only.
+FORCE_INLINE void _mm_setcsr(unsigned int a)
+{
+    _MM_SET_ROUNDING_MODE(a);
+}
+
+// Get the unsigned 32-bit value of the MXCSR control and status register.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_getcsr
+// FIXME: _mm_getcsr() implementation supports reading the rounding mode only.
+FORCE_INLINE unsigned int _mm_getcsr(void)
+{
+    return _MM_GET_ROUNDING_MODE();
+}
+
+// Set packed single-precision (32-bit) floating-point elements in dst with the
+// supplied values in reverse order.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_setr_ps
+FORCE_INLINE __m128 _mm_setr_ps(float w, float z, float y, float x)
+{
+    float ALIGN_STRUCT(16) data[4] = {w, z, y, x};
+    return vreinterpretq_m128_f32(vld1q_f32(data));
+}
+
+// Return vector of type __m128 with all elements set to zero.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_setzero_ps
+FORCE_INLINE __m128 _mm_setzero_ps(void)
+{
+    return vreinterpretq_m128_f32(vdupq_n_f32(0));
+}
+
+// Shuffle 16-bit integers in a using the control in imm8, and store the results
+// in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_shuffle_pi16
+#ifdef _sse2neon_shuffle
+#define _mm_shuffle_pi16(a, imm)                                       \
+    vreinterpret_m64_s16(vshuffle_s16(                                 \
+        vreinterpret_s16_m64(a), vreinterpret_s16_m64(a), (imm & 0x3), \
+        ((imm >> 2) & 0x3), ((imm >> 4) & 0x3), ((imm >> 6) & 0x3)))
+#else
+#define _mm_shuffle_pi16(a, imm)                                              \
+    _sse2neon_define1(                                                        \
+        __m64, a, int16x4_t ret;                                              \
+        ret = vmov_n_s16(                                                     \
+            vget_lane_s16(vreinterpret_s16_m64(_a), (imm) & (0x3)));          \
+        ret = vset_lane_s16(                                                  \
+            vget_lane_s16(vreinterpret_s16_m64(_a), ((imm) >> 2) & 0x3), ret, \
+            1);                                                               \
+        ret = vset_lane_s16(                                                  \
+            vget_lane_s16(vreinterpret_s16_m64(_a), ((imm) >> 4) & 0x3), ret, \
+            2);                                                               \
+        ret = vset_lane_s16(                                                  \
+            vget_lane_s16(vreinterpret_s16_m64(_a), ((imm) >> 6) & 0x3), ret, \
+            3);                                                               \
+        _sse2neon_return(vreinterpret_m64_s16(ret));)
+#endif
+
+// Perform a serializing operation on all store-to-memory instructions that were
+// issued prior to this instruction. Guarantees that every store instruction
+// that precedes, in program order, is globally visible before any store
+// instruction which follows the fence in program order.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_sfence
+FORCE_INLINE void _mm_sfence(void)
+{
+    _sse2neon_smp_mb();
+}
+
+// Perform a serializing operation on all load-from-memory and store-to-memory
+// instructions that were issued prior to this instruction. Guarantees that
+// every memory access that precedes, in program order, the memory fence
+// instruction is globally visible before any memory instruction which follows
+// the fence in program order.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mfence
+FORCE_INLINE void _mm_mfence(void)
+{
+    _sse2neon_smp_mb();
+}
+
+// Perform a serializing operation on all load-from-memory instructions that
+// were issued prior to this instruction. Guarantees that every load instruction
+// that precedes, in program order, is globally visible before any load
+// instruction which follows the fence in program order.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_lfence
+FORCE_INLINE void _mm_lfence(void)
+{
+    _sse2neon_smp_mb();
+}
+
+// FORCE_INLINE __m128 _mm_shuffle_ps(__m128 a, __m128 b, __constrange(0,255)
+// int imm)
+#ifdef _sse2neon_shuffle
+#define _mm_shuffle_ps(a, b, imm)                                              \
+    __extension__({                                                            \
+        float32x4_t _input1 = vreinterpretq_f32_m128(a);                       \
+        float32x4_t _input2 = vreinterpretq_f32_m128(b);                       \
+        float32x4_t _shuf =                                                    \
+            vshuffleq_s32(_input1, _input2, (imm) & (0x3), ((imm) >> 2) & 0x3, \
+                          (((imm) >> 4) & 0x3) + 4, (((imm) >> 6) & 0x3) + 4); \
+        vreinterpretq_m128_f32(_shuf);                                         \
+    })
+#else  // generic
+#define _mm_shuffle_ps(a, b, imm)                            \
+    _sse2neon_define2(                                       \
+        __m128, a, b, __m128 ret; switch (imm) {             \
+            case _MM_SHUFFLE(1, 0, 3, 2):                    \
+                ret = _mm_shuffle_ps_1032(_a, _b);           \
+                break;                                       \
+            case _MM_SHUFFLE(2, 3, 0, 1):                    \
+                ret = _mm_shuffle_ps_2301(_a, _b);           \
+                break;                                       \
+            case _MM_SHUFFLE(0, 3, 2, 1):                    \
+                ret = _mm_shuffle_ps_0321(_a, _b);           \
+                break;                                       \
+            case _MM_SHUFFLE(2, 1, 0, 3):                    \
+                ret = _mm_shuffle_ps_2103(_a, _b);           \
+                break;                                       \
+            case _MM_SHUFFLE(1, 0, 1, 0):                    \
+                ret = _mm_movelh_ps(_a, _b);                 \
+                break;                                       \
+            case _MM_SHUFFLE(1, 0, 0, 1):                    \
+                ret = _mm_shuffle_ps_1001(_a, _b);           \
+                break;                                       \
+            case _MM_SHUFFLE(0, 1, 0, 1):                    \
+                ret = _mm_shuffle_ps_0101(_a, _b);           \
+                break;                                       \
+            case _MM_SHUFFLE(3, 2, 1, 0):                    \
+                ret = _mm_shuffle_ps_3210(_a, _b);           \
+                break;                                       \
+            case _MM_SHUFFLE(0, 0, 1, 1):                    \
+                ret = _mm_shuffle_ps_0011(_a, _b);           \
+                break;                                       \
+            case _MM_SHUFFLE(0, 0, 2, 2):                    \
+                ret = _mm_shuffle_ps_0022(_a, _b);           \
+                break;                                       \
+            case _MM_SHUFFLE(2, 2, 0, 0):                    \
+                ret = _mm_shuffle_ps_2200(_a, _b);           \
+                break;                                       \
+            case _MM_SHUFFLE(3, 2, 0, 2):                    \
+                ret = _mm_shuffle_ps_3202(_a, _b);           \
+                break;                                       \
+            case _MM_SHUFFLE(3, 2, 3, 2):                    \
+                ret = _mm_movehl_ps(_b, _a);                 \
+                break;                                       \
+            case _MM_SHUFFLE(1, 1, 3, 3):                    \
+                ret = _mm_shuffle_ps_1133(_a, _b);           \
+                break;                                       \
+            case _MM_SHUFFLE(2, 0, 1, 0):                    \
+                ret = _mm_shuffle_ps_2010(_a, _b);           \
+                break;                                       \
+            case _MM_SHUFFLE(2, 0, 0, 1):                    \
+                ret = _mm_shuffle_ps_2001(_a, _b);           \
+                break;                                       \
+            case _MM_SHUFFLE(2, 0, 3, 2):                    \
+                ret = _mm_shuffle_ps_2032(_a, _b);           \
+                break;                                       \
+            default:                                         \
+                ret = _mm_shuffle_ps_default(_a, _b, (imm)); \
+                break;                                       \
+        } _sse2neon_return(ret);)
+#endif
+
+// Compute the square root of packed single-precision (32-bit) floating-point
+// elements in a, and store the results in dst.
+// Due to ARMv7-A NEON's lack of a precise square root intrinsic, we implement
+// square root by multiplying input in with its reciprocal square root before
+// using the Newton-Raphson method to approximate the results.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_sqrt_ps
+FORCE_INLINE __m128 _mm_sqrt_ps(__m128 in)
+{
+#if (defined(__aarch64__) || defined(_M_ARM64)) && !SSE2NEON_PRECISE_SQRT
+    return vreinterpretq_m128_f32(vsqrtq_f32(vreinterpretq_f32_m128(in)));
+#else
+    float32x4_t recip = vrsqrteq_f32(vreinterpretq_f32_m128(in));
+
+    // Test for vrsqrteq_f32(0) -> positive infinity case.
+    // Change to zero, so that s * 1/sqrt(s) result is zero too.
+    const uint32x4_t pos_inf = vdupq_n_u32(0x7F800000);
+    const uint32x4_t div_by_zero =
+        vceqq_u32(pos_inf, vreinterpretq_u32_f32(recip));
+    recip = vreinterpretq_f32_u32(
+        vandq_u32(vmvnq_u32(div_by_zero), vreinterpretq_u32_f32(recip)));
+
+    recip = vmulq_f32(
+        vrsqrtsq_f32(vmulq_f32(recip, recip), vreinterpretq_f32_m128(in)),
+        recip);
+    // Additional Netwon-Raphson iteration for accuracy
+    recip = vmulq_f32(
+        vrsqrtsq_f32(vmulq_f32(recip, recip), vreinterpretq_f32_m128(in)),
+        recip);
+
+    // sqrt(s) = s * 1/sqrt(s)
+    return vreinterpretq_m128_f32(vmulq_f32(vreinterpretq_f32_m128(in), recip));
+#endif
+}
+
+// Compute the square root of the lower single-precision (32-bit) floating-point
+// element in a, store the result in the lower element of dst, and copy the
+// upper 3 packed elements from a to the upper elements of dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_sqrt_ss
+FORCE_INLINE __m128 _mm_sqrt_ss(__m128 in)
+{
+    float32_t value =
+        vgetq_lane_f32(vreinterpretq_f32_m128(_mm_sqrt_ps(in)), 0);
+    return vreinterpretq_m128_f32(
+        vsetq_lane_f32(value, vreinterpretq_f32_m128(in), 0));
+}
+
+// Store 128-bits (composed of 4 packed single-precision (32-bit) floating-point
+// elements) from a into memory. mem_addr must be aligned on a 16-byte boundary
+// or a general-protection exception may be generated.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_store_ps
+FORCE_INLINE void _mm_store_ps(float *p, __m128 a)
+{
+    vst1q_f32(p, vreinterpretq_f32_m128(a));
+}
+
+// Store the lower single-precision (32-bit) floating-point element from a into
+// 4 contiguous elements in memory. mem_addr must be aligned on a 16-byte
+// boundary or a general-protection exception may be generated.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_store_ps1
+FORCE_INLINE void _mm_store_ps1(float *p, __m128 a)
+{
+    float32_t a0 = vgetq_lane_f32(vreinterpretq_f32_m128(a), 0);
+    vst1q_f32(p, vdupq_n_f32(a0));
+}
+
+// Store the lower single-precision (32-bit) floating-point element from a into
+// memory. mem_addr does not need to be aligned on any particular boundary.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_store_ss
+FORCE_INLINE void _mm_store_ss(float *p, __m128 a)
+{
+    vst1q_lane_f32(p, vreinterpretq_f32_m128(a), 0);
+}
+
+// Store the lower single-precision (32-bit) floating-point element from a into
+// 4 contiguous elements in memory. mem_addr must be aligned on a 16-byte
+// boundary or a general-protection exception may be generated.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_store1_ps
+#define _mm_store1_ps _mm_store_ps1
+
+// Store the upper 2 single-precision (32-bit) floating-point elements from a
+// into memory.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_storeh_pi
+FORCE_INLINE void _mm_storeh_pi(__m64 *p, __m128 a)
+{
+    *p = vreinterpret_m64_f32(vget_high_f32(a));
+}
+
+// Store the lower 2 single-precision (32-bit) floating-point elements from a
+// into memory.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_storel_pi
+FORCE_INLINE void _mm_storel_pi(__m64 *p, __m128 a)
+{
+    *p = vreinterpret_m64_f32(vget_low_f32(a));
+}
+
+// Store 4 single-precision (32-bit) floating-point elements from a into memory
+// in reverse order. mem_addr must be aligned on a 16-byte boundary or a
+// general-protection exception may be generated.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_storer_ps
+FORCE_INLINE void _mm_storer_ps(float *p, __m128 a)
+{
+    float32x4_t tmp = vrev64q_f32(vreinterpretq_f32_m128(a));
+    float32x4_t rev = vextq_f32(tmp, tmp, 2);
+    vst1q_f32(p, rev);
+}
+
+// Store 128-bits (composed of 4 packed single-precision (32-bit) floating-point
+// elements) from a into memory. mem_addr does not need to be aligned on any
+// particular boundary.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_storeu_ps
+FORCE_INLINE void _mm_storeu_ps(float *p, __m128 a)
+{
+    vst1q_f32(p, vreinterpretq_f32_m128(a));
+}
+
+// Stores 16-bits of integer data a at the address p.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_storeu_si16
+FORCE_INLINE void _mm_storeu_si16(void *p, __m128i a)
+{
+    vst1q_lane_s16((int16_t *) p, vreinterpretq_s16_m128i(a), 0);
+}
+
+// Stores 64-bits of integer data a at the address p.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_storeu_si64
+FORCE_INLINE void _mm_storeu_si64(void *p, __m128i a)
+{
+    vst1q_lane_s64((int64_t *) p, vreinterpretq_s64_m128i(a), 0);
+}
+
+// Store 64-bits of integer data from a into memory using a non-temporal memory
+// hint.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_stream_pi
+FORCE_INLINE void _mm_stream_pi(__m64 *p, __m64 a)
+{
+    vst1_s64((int64_t *) p, vreinterpret_s64_m64(a));
+}
+
+// Store 128-bits (composed of 4 packed single-precision (32-bit) floating-
+// point elements) from a into memory using a non-temporal memory hint.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_stream_ps
+FORCE_INLINE void _mm_stream_ps(float *p, __m128 a)
+{
+#if __has_builtin(__builtin_nontemporal_store)
+    __builtin_nontemporal_store(a, (float32x4_t *) p);
+#else
+    vst1q_f32(p, vreinterpretq_f32_m128(a));
+#endif
+}
+
+// Subtract packed single-precision (32-bit) floating-point elements in b from
+// packed single-precision (32-bit) floating-point elements in a, and store the
+// results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_sub_ps
+FORCE_INLINE __m128 _mm_sub_ps(__m128 a, __m128 b)
+{
+    return vreinterpretq_m128_f32(
+        vsubq_f32(vreinterpretq_f32_m128(a), vreinterpretq_f32_m128(b)));
+}
+
+// Subtract the lower single-precision (32-bit) floating-point element in b from
+// the lower single-precision (32-bit) floating-point element in a, store the
+// result in the lower element of dst, and copy the upper 3 packed elements from
+// a to the upper elements of dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_sub_ss
+FORCE_INLINE __m128 _mm_sub_ss(__m128 a, __m128 b)
+{
+    return _mm_move_ss(a, _mm_sub_ps(a, b));
+}
+
+// Macro: Transpose the 4x4 matrix formed by the 4 rows of single-precision
+// (32-bit) floating-point elements in row0, row1, row2, and row3, and store the
+// transposed matrix in these vectors (row0 now contains column 0, etc.).
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=MM_TRANSPOSE4_PS
+#define _MM_TRANSPOSE4_PS(row0, row1, row2, row3)         \
+    do {                                                  \
+        float32x4x2_t ROW01 = vtrnq_f32(row0, row1);      \
+        float32x4x2_t ROW23 = vtrnq_f32(row2, row3);      \
+        row0 = vcombine_f32(vget_low_f32(ROW01.val[0]),   \
+                            vget_low_f32(ROW23.val[0]));  \
+        row1 = vcombine_f32(vget_low_f32(ROW01.val[1]),   \
+                            vget_low_f32(ROW23.val[1]));  \
+        row2 = vcombine_f32(vget_high_f32(ROW01.val[0]),  \
+                            vget_high_f32(ROW23.val[0])); \
+        row3 = vcombine_f32(vget_high_f32(ROW01.val[1]),  \
+                            vget_high_f32(ROW23.val[1])); \
+    } while (0)
+
+// according to the documentation, these intrinsics behave the same as the
+// non-'u' versions.  We'll just alias them here.
+#define _mm_ucomieq_ss _mm_comieq_ss
+#define _mm_ucomige_ss _mm_comige_ss
+#define _mm_ucomigt_ss _mm_comigt_ss
+#define _mm_ucomile_ss _mm_comile_ss
+#define _mm_ucomilt_ss _mm_comilt_ss
+#define _mm_ucomineq_ss _mm_comineq_ss
+
+// Return vector of type __m128i with undefined elements.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=mm_undefined_si128
+FORCE_INLINE __m128i _mm_undefined_si128(void)
+{
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wuninitialized"
+#endif
+    __m128i a;
+#if defined(_MSC_VER)
+    a = _mm_setzero_si128();
+#endif
+    return a;
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+}
+
+// Return vector of type __m128 with undefined elements.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_undefined_ps
+FORCE_INLINE __m128 _mm_undefined_ps(void)
+{
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wuninitialized"
+#endif
+    __m128 a;
+#if defined(_MSC_VER)
+    a = _mm_setzero_ps();
+#endif
+    return a;
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+}
+
+// Unpack and interleave single-precision (32-bit) floating-point elements from
+// the high half a and b, and store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_unpackhi_ps
+FORCE_INLINE __m128 _mm_unpackhi_ps(__m128 a, __m128 b)
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+    return vreinterpretq_m128_f32(
+        vzip2q_f32(vreinterpretq_f32_m128(a), vreinterpretq_f32_m128(b)));
+#else
+    float32x2_t a1 = vget_high_f32(vreinterpretq_f32_m128(a));
+    float32x2_t b1 = vget_high_f32(vreinterpretq_f32_m128(b));
+    float32x2x2_t result = vzip_f32(a1, b1);
+    return vreinterpretq_m128_f32(vcombine_f32(result.val[0], result.val[1]));
+#endif
+}
+
+// Unpack and interleave single-precision (32-bit) floating-point elements from
+// the low half of a and b, and store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_unpacklo_ps
+FORCE_INLINE __m128 _mm_unpacklo_ps(__m128 a, __m128 b)
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+    return vreinterpretq_m128_f32(
+        vzip1q_f32(vreinterpretq_f32_m128(a), vreinterpretq_f32_m128(b)));
+#else
+    float32x2_t a1 = vget_low_f32(vreinterpretq_f32_m128(a));
+    float32x2_t b1 = vget_low_f32(vreinterpretq_f32_m128(b));
+    float32x2x2_t result = vzip_f32(a1, b1);
+    return vreinterpretq_m128_f32(vcombine_f32(result.val[0], result.val[1]));
+#endif
+}
+
+// Compute the bitwise XOR of packed single-precision (32-bit) floating-point
+// elements in a and b, and store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_xor_ps
+FORCE_INLINE __m128 _mm_xor_ps(__m128 a, __m128 b)
+{
+    return vreinterpretq_m128_s32(
+        veorq_s32(vreinterpretq_s32_m128(a), vreinterpretq_s32_m128(b)));
+}
+
+/* SSE2 */
+
+// Add packed 16-bit integers in a and b, and store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_add_epi16
+FORCE_INLINE __m128i _mm_add_epi16(__m128i a, __m128i b)
+{
+    return vreinterpretq_m128i_s16(
+        vaddq_s16(vreinterpretq_s16_m128i(a), vreinterpretq_s16_m128i(b)));
+}
+
+// Add packed 32-bit integers in a and b, and store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_add_epi32
+FORCE_INLINE __m128i _mm_add_epi32(__m128i a, __m128i b)
+{
+    return vreinterpretq_m128i_s32(
+        vaddq_s32(vreinterpretq_s32_m128i(a), vreinterpretq_s32_m128i(b)));
+}
+
+// Add packed 64-bit integers in a and b, and store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_add_epi64
+FORCE_INLINE __m128i _mm_add_epi64(__m128i a, __m128i b)
+{
+    return vreinterpretq_m128i_s64(
+        vaddq_s64(vreinterpretq_s64_m128i(a), vreinterpretq_s64_m128i(b)));
+}
+
+// Add packed 8-bit integers in a and b, and store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_add_epi8
+FORCE_INLINE __m128i _mm_add_epi8(__m128i a, __m128i b)
+{
+    return vreinterpretq_m128i_s8(
+        vaddq_s8(vreinterpretq_s8_m128i(a), vreinterpretq_s8_m128i(b)));
+}
+
+// Add packed double-precision (64-bit) floating-point elements in a and b, and
+// store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_add_pd
+FORCE_INLINE __m128d _mm_add_pd(__m128d a, __m128d b)
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+    return vreinterpretq_m128d_f64(
+        vaddq_f64(vreinterpretq_f64_m128d(a), vreinterpretq_f64_m128d(b)));
+#else
+    double *da = (double *) &a;
+    double *db = (double *) &b;
+    double c[2];
+    c[0] = da[0] + db[0];
+    c[1] = da[1] + db[1];
+    return vld1q_f32((float32_t *) c);
+#endif
+}
+
+// Add the lower double-precision (64-bit) floating-point element in a and b,
+// store the result in the lower element of dst, and copy the upper element from
+// a to the upper element of dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_add_sd
+FORCE_INLINE __m128d _mm_add_sd(__m128d a, __m128d b)
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+    return _mm_move_sd(a, _mm_add_pd(a, b));
+#else
+    double *da = (double *) &a;
+    double *db = (double *) &b;
+    double c[2];
+    c[0] = da[0] + db[0];
+    c[1] = da[1];
+    return vld1q_f32((float32_t *) c);
+#endif
+}
+
+// Add 64-bit integers a and b, and store the result in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_add_si64
+FORCE_INLINE __m64 _mm_add_si64(__m64 a, __m64 b)
+{
+    return vreinterpret_m64_s64(
+        vadd_s64(vreinterpret_s64_m64(a), vreinterpret_s64_m64(b)));
+}
+
+// Add packed signed 16-bit integers in a and b using saturation, and store the
+// results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_adds_epi16
+FORCE_INLINE __m128i _mm_adds_epi16(__m128i a, __m128i b)
+{
+    return vreinterpretq_m128i_s16(
+        vqaddq_s16(vreinterpretq_s16_m128i(a), vreinterpretq_s16_m128i(b)));
+}
+
+// Add packed signed 8-bit integers in a and b using saturation, and store the
+// results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_adds_epi8
+FORCE_INLINE __m128i _mm_adds_epi8(__m128i a, __m128i b)
+{
+    return vreinterpretq_m128i_s8(
+        vqaddq_s8(vreinterpretq_s8_m128i(a), vreinterpretq_s8_m128i(b)));
+}
+
+// Add packed unsigned 16-bit integers in a and b using saturation, and store
+// the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_adds_epu16
+FORCE_INLINE __m128i _mm_adds_epu16(__m128i a, __m128i b)
+{
+    return vreinterpretq_m128i_u16(
+        vqaddq_u16(vreinterpretq_u16_m128i(a), vreinterpretq_u16_m128i(b)));
+}
+
+// Add packed unsigned 8-bit integers in a and b using saturation, and store the
+// results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_adds_epu8
+FORCE_INLINE __m128i _mm_adds_epu8(__m128i a, __m128i b)
+{
+    return vreinterpretq_m128i_u8(
+        vqaddq_u8(vreinterpretq_u8_m128i(a), vreinterpretq_u8_m128i(b)));
+}
+
+// Compute the bitwise AND of packed double-precision (64-bit) floating-point
+// elements in a and b, and store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_and_pd
+FORCE_INLINE __m128d _mm_and_pd(__m128d a, __m128d b)
+{
+    return vreinterpretq_m128d_s64(
+        vandq_s64(vreinterpretq_s64_m128d(a), vreinterpretq_s64_m128d(b)));
+}
+
+// Compute the bitwise AND of 128 bits (representing integer data) in a and b,
+// and store the result in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_and_si128
+FORCE_INLINE __m128i _mm_and_si128(__m128i a, __m128i b)
+{
+    return vreinterpretq_m128i_s32(
+        vandq_s32(vreinterpretq_s32_m128i(a), vreinterpretq_s32_m128i(b)));
+}
+
+// Compute the bitwise NOT of packed double-precision (64-bit) floating-point
+// elements in a and then AND with b, and store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_andnot_pd
+FORCE_INLINE __m128d _mm_andnot_pd(__m128d a, __m128d b)
+{
+    // *NOTE* argument swap
+    return vreinterpretq_m128d_s64(
+        vbicq_s64(vreinterpretq_s64_m128d(b), vreinterpretq_s64_m128d(a)));
+}
+
+// Compute the bitwise NOT of 128 bits (representing integer data) in a and then
+// AND with b, and store the result in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_andnot_si128
+FORCE_INLINE __m128i _mm_andnot_si128(__m128i a, __m128i b)
+{
+    return vreinterpretq_m128i_s32(
+        vbicq_s32(vreinterpretq_s32_m128i(b),
+                  vreinterpretq_s32_m128i(a)));  // *NOTE* argument swap
+}
+
+// Average packed unsigned 16-bit integers in a and b, and store the results in
+// dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_avg_epu16
+FORCE_INLINE __m128i _mm_avg_epu16(__m128i a, __m128i b)
+{
+    return (__m128i) vrhaddq_u16(vreinterpretq_u16_m128i(a),
+                                 vreinterpretq_u16_m128i(b));
+}
+
+// Average packed unsigned 8-bit integers in a and b, and store the results in
+// dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_avg_epu8
+FORCE_INLINE __m128i _mm_avg_epu8(__m128i a, __m128i b)
+{
+    return vreinterpretq_m128i_u8(
+        vrhaddq_u8(vreinterpretq_u8_m128i(a), vreinterpretq_u8_m128i(b)));
+}
+
+// Shift a left by imm8 bytes while shifting in zeros, and store the results in
+// dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_bslli_si128
+#define _mm_bslli_si128(a, imm) _mm_slli_si128(a, imm)
+
+// Shift a right by imm8 bytes while shifting in zeros, and store the results in
+// dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_bsrli_si128
+#define _mm_bsrli_si128(a, imm) _mm_srli_si128(a, imm)
+
+// Cast vector of type __m128d to type __m128. This intrinsic is only used for
+// compilation and does not generate any instructions, thus it has zero latency.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_castpd_ps
+FORCE_INLINE __m128 _mm_castpd_ps(__m128d a)
+{
+    return vreinterpretq_m128_s64(vreinterpretq_s64_m128d(a));
+}
+
+// Cast vector of type __m128d to type __m128i. This intrinsic is only used for
+// compilation and does not generate any instructions, thus it has zero latency.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_castpd_si128
+FORCE_INLINE __m128i _mm_castpd_si128(__m128d a)
+{
+    return vreinterpretq_m128i_s64(vreinterpretq_s64_m128d(a));
+}
+
+// Cast vector of type __m128 to type __m128d. This intrinsic is only used for
+// compilation and does not generate any instructions, thus it has zero latency.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_castps_pd
+FORCE_INLINE __m128d _mm_castps_pd(__m128 a)
+{
+    return vreinterpretq_m128d_s32(vreinterpretq_s32_m128(a));
+}
+
+// Cast vector of type __m128 to type __m128i. This intrinsic is only used for
+// compilation and does not generate any instructions, thus it has zero latency.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_castps_si128
+FORCE_INLINE __m128i _mm_castps_si128(__m128 a)
+{
+    return vreinterpretq_m128i_s32(vreinterpretq_s32_m128(a));
+}
+
+// Cast vector of type __m128i to type __m128d. This intrinsic is only used for
+// compilation and does not generate any instructions, thus it has zero latency.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_castsi128_pd
+FORCE_INLINE __m128d _mm_castsi128_pd(__m128i a)
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+    return vreinterpretq_m128d_f64(vreinterpretq_f64_m128i(a));
+#else
+    return vreinterpretq_m128d_f32(vreinterpretq_f32_m128i(a));
+#endif
+}
+
+// Cast vector of type __m128i to type __m128. This intrinsic is only used for
+// compilation and does not generate any instructions, thus it has zero latency.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_castsi128_ps
+FORCE_INLINE __m128 _mm_castsi128_ps(__m128i a)
+{
+    return vreinterpretq_m128_s32(vreinterpretq_s32_m128i(a));
+}
+
+// Invalidate and flush the cache line that contains p from all levels of the
+// cache hierarchy.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_clflush
+#if defined(__APPLE__)
+#include <libkern/OSCacheControl.h>
+#endif
+FORCE_INLINE void _mm_clflush(void const *p)
+{
+    (void) p;
+
+    /* sys_icache_invalidate is supported since macOS 10.5.
+     * However, it does not work on non-jailbroken iOS devices, although the
+     * compilation is successful.
+     */
+#if defined(__APPLE__)
+    sys_icache_invalidate((void *) (uintptr_t) p, SSE2NEON_CACHELINE_SIZE);
+#elif defined(__GNUC__) || defined(__clang__)
+    uintptr_t ptr = (uintptr_t) p;
+    __builtin___clear_cache((char *) ptr,
+                            (char *) ptr + SSE2NEON_CACHELINE_SIZE);
+#elif (_MSC_VER) && SSE2NEON_INCLUDE_WINDOWS_H
+    FlushInstructionCache(GetCurrentProcess(), p, SSE2NEON_CACHELINE_SIZE);
+#endif
+}
+
+// Compare packed 16-bit integers in a and b for equality, and store the results
+// in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmpeq_epi16
+FORCE_INLINE __m128i _mm_cmpeq_epi16(__m128i a, __m128i b)
+{
+    return vreinterpretq_m128i_u16(
+        vceqq_s16(vreinterpretq_s16_m128i(a), vreinterpretq_s16_m128i(b)));
+}
+
+// Compare packed 32-bit integers in a and b for equality, and store the results
+// in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmpeq_epi32
+FORCE_INLINE __m128i _mm_cmpeq_epi32(__m128i a, __m128i b)
+{
+    return vreinterpretq_m128i_u32(
+        vceqq_s32(vreinterpretq_s32_m128i(a), vreinterpretq_s32_m128i(b)));
+}
+
+// Compare packed 8-bit integers in a and b for equality, and store the results
+// in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmpeq_epi8
+FORCE_INLINE __m128i _mm_cmpeq_epi8(__m128i a, __m128i b)
+{
+    return vreinterpretq_m128i_u8(
+        vceqq_s8(vreinterpretq_s8_m128i(a), vreinterpretq_s8_m128i(b)));
+}
+
+// Compare packed double-precision (64-bit) floating-point elements in a and b
+// for equality, and store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmpeq_pd
+FORCE_INLINE __m128d _mm_cmpeq_pd(__m128d a, __m128d b)
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+    return vreinterpretq_m128d_u64(
+        vceqq_f64(vreinterpretq_f64_m128d(a), vreinterpretq_f64_m128d(b)));
+#else
+    // (a == b) -> (a_lo == b_lo) && (a_hi == b_hi)
+    uint32x4_t cmp =
+        vceqq_u32(vreinterpretq_u32_m128d(a), vreinterpretq_u32_m128d(b));
+    uint32x4_t swapped = vrev64q_u32(cmp);
+    return vreinterpretq_m128d_u32(vandq_u32(cmp, swapped));
+#endif
+}
+
+// Compare the lower double-precision (64-bit) floating-point elements in a and
+// b for equality, store the result in the lower element of dst, and copy the
+// upper element from a to the upper element of dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmpeq_sd
+FORCE_INLINE __m128d _mm_cmpeq_sd(__m128d a, __m128d b)
+{
+    return _mm_move_sd(a, _mm_cmpeq_pd(a, b));
+}
+
+// Compare packed double-precision (64-bit) floating-point elements in a and b
+// for greater-than-or-equal, and store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmpge_pd
+FORCE_INLINE __m128d _mm_cmpge_pd(__m128d a, __m128d b)
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+    return vreinterpretq_m128d_u64(
+        vcgeq_f64(vreinterpretq_f64_m128d(a), vreinterpretq_f64_m128d(b)));
+#else
+    uint64_t a0 = (uint64_t) vget_low_u64(vreinterpretq_u64_m128d(a));
+    uint64_t a1 = (uint64_t) vget_high_u64(vreinterpretq_u64_m128d(a));
+    uint64_t b0 = (uint64_t) vget_low_u64(vreinterpretq_u64_m128d(b));
+    uint64_t b1 = (uint64_t) vget_high_u64(vreinterpretq_u64_m128d(b));
+    uint64_t d[2];
+    d[0] = (*(double *) &a0) >= (*(double *) &b0) ? ~UINT64_C(0) : UINT64_C(0);
+    d[1] = (*(double *) &a1) >= (*(double *) &b1) ? ~UINT64_C(0) : UINT64_C(0);
+
+    return vreinterpretq_m128d_u64(vld1q_u64(d));
+#endif
+}
+
+// Compare the lower double-precision (64-bit) floating-point elements in a and
+// b for greater-than-or-equal, store the result in the lower element of dst,
+// and copy the upper element from a to the upper element of dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmpge_sd
+FORCE_INLINE __m128d _mm_cmpge_sd(__m128d a, __m128d b)
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+    return _mm_move_sd(a, _mm_cmpge_pd(a, b));
+#else
+    // expand "_mm_cmpge_pd()" to reduce unnecessary operations
+    uint64_t a0 = (uint64_t) vget_low_u64(vreinterpretq_u64_m128d(a));
+    uint64_t a1 = (uint64_t) vget_high_u64(vreinterpretq_u64_m128d(a));
+    uint64_t b0 = (uint64_t) vget_low_u64(vreinterpretq_u64_m128d(b));
+    uint64_t d[2];
+    d[0] = (*(double *) &a0) >= (*(double *) &b0) ? ~UINT64_C(0) : UINT64_C(0);
+    d[1] = a1;
+
+    return vreinterpretq_m128d_u64(vld1q_u64(d));
+#endif
+}
+
+// Compare packed signed 16-bit integers in a and b for greater-than, and store
+// the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmpgt_epi16
+FORCE_INLINE __m128i _mm_cmpgt_epi16(__m128i a, __m128i b)
+{
+    return vreinterpretq_m128i_u16(
+        vcgtq_s16(vreinterpretq_s16_m128i(a), vreinterpretq_s16_m128i(b)));
+}
+
+// Compare packed signed 32-bit integers in a and b for greater-than, and store
+// the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmpgt_epi32
+FORCE_INLINE __m128i _mm_cmpgt_epi32(__m128i a, __m128i b)
+{
+    return vreinterpretq_m128i_u32(
+        vcgtq_s32(vreinterpretq_s32_m128i(a), vreinterpretq_s32_m128i(b)));
+}
+
+// Compare packed signed 8-bit integers in a and b for greater-than, and store
+// the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmpgt_epi8
+FORCE_INLINE __m128i _mm_cmpgt_epi8(__m128i a, __m128i b)
+{
+    return vreinterpretq_m128i_u8(
+        vcgtq_s8(vreinterpretq_s8_m128i(a), vreinterpretq_s8_m128i(b)));
+}
+
+// Compare packed double-precision (64-bit) floating-point elements in a and b
+// for greater-than, and store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmpgt_pd
+FORCE_INLINE __m128d _mm_cmpgt_pd(__m128d a, __m128d b)
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+    return vreinterpretq_m128d_u64(
+        vcgtq_f64(vreinterpretq_f64_m128d(a), vreinterpretq_f64_m128d(b)));
+#else
+    uint64_t a0 = (uint64_t) vget_low_u64(vreinterpretq_u64_m128d(a));
+    uint64_t a1 = (uint64_t) vget_high_u64(vreinterpretq_u64_m128d(a));
+    uint64_t b0 = (uint64_t) vget_low_u64(vreinterpretq_u64_m128d(b));
+    uint64_t b1 = (uint64_t) vget_high_u64(vreinterpretq_u64_m128d(b));
+    uint64_t d[2];
+    d[0] = (*(double *) &a0) > (*(double *) &b0) ? ~UINT64_C(0) : UINT64_C(0);
+    d[1] = (*(double *) &a1) > (*(double *) &b1) ? ~UINT64_C(0) : UINT64_C(0);
+
+    return vreinterpretq_m128d_u64(vld1q_u64(d));
+#endif
+}
+
+// Compare the lower double-precision (64-bit) floating-point elements in a and
+// b for greater-than, store the result in the lower element of dst, and copy
+// the upper element from a to the upper element of dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmpgt_sd
+FORCE_INLINE __m128d _mm_cmpgt_sd(__m128d a, __m128d b)
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+    return _mm_move_sd(a, _mm_cmpgt_pd(a, b));
+#else
+    // expand "_mm_cmpge_pd()" to reduce unnecessary operations
+    uint64_t a0 = (uint64_t) vget_low_u64(vreinterpretq_u64_m128d(a));
+    uint64_t a1 = (uint64_t) vget_high_u64(vreinterpretq_u64_m128d(a));
+    uint64_t b0 = (uint64_t) vget_low_u64(vreinterpretq_u64_m128d(b));
+    uint64_t d[2];
+    d[0] = (*(double *) &a0) > (*(double *) &b0) ? ~UINT64_C(0) : UINT64_C(0);
+    d[1] = a1;
+
+    return vreinterpretq_m128d_u64(vld1q_u64(d));
+#endif
+}
+
+// Compare packed double-precision (64-bit) floating-point elements in a and b
+// for less-than-or-equal, and store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmple_pd
+FORCE_INLINE __m128d _mm_cmple_pd(__m128d a, __m128d b)
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+    return vreinterpretq_m128d_u64(
+        vcleq_f64(vreinterpretq_f64_m128d(a), vreinterpretq_f64_m128d(b)));
+#else
+    uint64_t a0 = (uint64_t) vget_low_u64(vreinterpretq_u64_m128d(a));
+    uint64_t a1 = (uint64_t) vget_high_u64(vreinterpretq_u64_m128d(a));
+    uint64_t b0 = (uint64_t) vget_low_u64(vreinterpretq_u64_m128d(b));
+    uint64_t b1 = (uint64_t) vget_high_u64(vreinterpretq_u64_m128d(b));
+    uint64_t d[2];
+    d[0] = (*(double *) &a0) <= (*(double *) &b0) ? ~UINT64_C(0) : UINT64_C(0);
+    d[1] = (*(double *) &a1) <= (*(double *) &b1) ? ~UINT64_C(0) : UINT64_C(0);
+
+    return vreinterpretq_m128d_u64(vld1q_u64(d));
+#endif
+}
+
+// Compare the lower double-precision (64-bit) floating-point elements in a and
+// b for less-than-or-equal, store the result in the lower element of dst, and
+// copy the upper element from a to the upper element of dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmple_sd
+FORCE_INLINE __m128d _mm_cmple_sd(__m128d a, __m128d b)
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+    return _mm_move_sd(a, _mm_cmple_pd(a, b));
+#else
+    // expand "_mm_cmpge_pd()" to reduce unnecessary operations
+    uint64_t a0 = (uint64_t) vget_low_u64(vreinterpretq_u64_m128d(a));
+    uint64_t a1 = (uint64_t) vget_high_u64(vreinterpretq_u64_m128d(a));
+    uint64_t b0 = (uint64_t) vget_low_u64(vreinterpretq_u64_m128d(b));
+    uint64_t d[2];
+    d[0] = (*(double *) &a0) <= (*(double *) &b0) ? ~UINT64_C(0) : UINT64_C(0);
+    d[1] = a1;
+
+    return vreinterpretq_m128d_u64(vld1q_u64(d));
+#endif
+}
+
+// Compare packed signed 16-bit integers in a and b for less-than, and store the
+// results in dst. Note: This intrinsic emits the pcmpgtw instruction with the
+// order of the operands switched.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmplt_epi16
+FORCE_INLINE __m128i _mm_cmplt_epi16(__m128i a, __m128i b)
+{
+    return vreinterpretq_m128i_u16(
+        vcltq_s16(vreinterpretq_s16_m128i(a), vreinterpretq_s16_m128i(b)));
+}
+
+// Compare packed signed 32-bit integers in a and b for less-than, and store the
+// results in dst. Note: This intrinsic emits the pcmpgtd instruction with the
+// order of the operands switched.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmplt_epi32
+FORCE_INLINE __m128i _mm_cmplt_epi32(__m128i a, __m128i b)
+{
+    return vreinterpretq_m128i_u32(
+        vcltq_s32(vreinterpretq_s32_m128i(a), vreinterpretq_s32_m128i(b)));
+}
+
+// Compare packed signed 8-bit integers in a and b for less-than, and store the
+// results in dst. Note: This intrinsic emits the pcmpgtb instruction with the
+// order of the operands switched.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmplt_epi8
+FORCE_INLINE __m128i _mm_cmplt_epi8(__m128i a, __m128i b)
+{
+    return vreinterpretq_m128i_u8(
+        vcltq_s8(vreinterpretq_s8_m128i(a), vreinterpretq_s8_m128i(b)));
+}
+
+// Compare packed double-precision (64-bit) floating-point elements in a and b
+// for less-than, and store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmplt_pd
+FORCE_INLINE __m128d _mm_cmplt_pd(__m128d a, __m128d b)
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+    return vreinterpretq_m128d_u64(
+        vcltq_f64(vreinterpretq_f64_m128d(a), vreinterpretq_f64_m128d(b)));
+#else
+    uint64_t a0 = (uint64_t) vget_low_u64(vreinterpretq_u64_m128d(a));
+    uint64_t a1 = (uint64_t) vget_high_u64(vreinterpretq_u64_m128d(a));
+    uint64_t b0 = (uint64_t) vget_low_u64(vreinterpretq_u64_m128d(b));
+    uint64_t b1 = (uint64_t) vget_high_u64(vreinterpretq_u64_m128d(b));
+    uint64_t d[2];
+    d[0] = (*(double *) &a0) < (*(double *) &b0) ? ~UINT64_C(0) : UINT64_C(0);
+    d[1] = (*(double *) &a1) < (*(double *) &b1) ? ~UINT64_C(0) : UINT64_C(0);
+
+    return vreinterpretq_m128d_u64(vld1q_u64(d));
+#endif
+}
+
+// Compare the lower double-precision (64-bit) floating-point elements in a and
+// b for less-than, store the result in the lower element of dst, and copy the
+// upper element from a to the upper element of dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmplt_sd
+FORCE_INLINE __m128d _mm_cmplt_sd(__m128d a, __m128d b)
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+    return _mm_move_sd(a, _mm_cmplt_pd(a, b));
+#else
+    uint64_t a0 = (uint64_t) vget_low_u64(vreinterpretq_u64_m128d(a));
+    uint64_t a1 = (uint64_t) vget_high_u64(vreinterpretq_u64_m128d(a));
+    uint64_t b0 = (uint64_t) vget_low_u64(vreinterpretq_u64_m128d(b));
+    uint64_t d[2];
+    d[0] = (*(double *) &a0) < (*(double *) &b0) ? ~UINT64_C(0) : UINT64_C(0);
+    d[1] = a1;
+
+    return vreinterpretq_m128d_u64(vld1q_u64(d));
+#endif
+}
+
+// Compare packed double-precision (64-bit) floating-point elements in a and b
+// for not-equal, and store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmpneq_pd
+FORCE_INLINE __m128d _mm_cmpneq_pd(__m128d a, __m128d b)
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+    return vreinterpretq_m128d_s32(vmvnq_s32(vreinterpretq_s32_u64(
+        vceqq_f64(vreinterpretq_f64_m128d(a), vreinterpretq_f64_m128d(b)))));
+#else
+    // (a == b) -> (a_lo == b_lo) && (a_hi == b_hi)
+    uint32x4_t cmp =
+        vceqq_u32(vreinterpretq_u32_m128d(a), vreinterpretq_u32_m128d(b));
+    uint32x4_t swapped = vrev64q_u32(cmp);
+    return vreinterpretq_m128d_u32(vmvnq_u32(vandq_u32(cmp, swapped)));
+#endif
+}
+
+// Compare the lower double-precision (64-bit) floating-point elements in a and
+// b for not-equal, store the result in the lower element of dst, and copy the
+// upper element from a to the upper element of dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmpneq_sd
+FORCE_INLINE __m128d _mm_cmpneq_sd(__m128d a, __m128d b)
+{
+    return _mm_move_sd(a, _mm_cmpneq_pd(a, b));
+}
+
+// Compare packed double-precision (64-bit) floating-point elements in a and b
+// for not-greater-than-or-equal, and store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmpnge_pd
+FORCE_INLINE __m128d _mm_cmpnge_pd(__m128d a, __m128d b)
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+    return vreinterpretq_m128d_u64(veorq_u64(
+        vcgeq_f64(vreinterpretq_f64_m128d(a), vreinterpretq_f64_m128d(b)),
+        vdupq_n_u64(UINT64_MAX)));
+#else
+    uint64_t a0 = (uint64_t) vget_low_u64(vreinterpretq_u64_m128d(a));
+    uint64_t a1 = (uint64_t) vget_high_u64(vreinterpretq_u64_m128d(a));
+    uint64_t b0 = (uint64_t) vget_low_u64(vreinterpretq_u64_m128d(b));
+    uint64_t b1 = (uint64_t) vget_high_u64(vreinterpretq_u64_m128d(b));
+    uint64_t d[2];
+    d[0] =
+        !((*(double *) &a0) >= (*(double *) &b0)) ? ~UINT64_C(0) : UINT64_C(0);
+    d[1] =
+        !((*(double *) &a1) >= (*(double *) &b1)) ? ~UINT64_C(0) : UINT64_C(0);
+
+    return vreinterpretq_m128d_u64(vld1q_u64(d));
+#endif
+}
+
+// Compare the lower double-precision (64-bit) floating-point elements in a and
+// b for not-greater-than-or-equal, store the result in the lower element of
+// dst, and copy the upper element from a to the upper element of dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmpnge_sd
+FORCE_INLINE __m128d _mm_cmpnge_sd(__m128d a, __m128d b)
+{
+    return _mm_move_sd(a, _mm_cmpnge_pd(a, b));
+}
+
+// Compare packed double-precision (64-bit) floating-point elements in a and b
+// for not-greater-than, and store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_cmpngt_pd
+FORCE_INLINE __m128d _mm_cmpngt_pd(__m128d a, __m128d b)
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+    return vreinterpretq_m128d_u64(veorq_u64(
+        vcgtq_f64(vreinterpretq_f64_m128d(a), vreinterpretq_f64_m128d(b)),
+        vdupq_n_u64(UINT64_MAX)));
+#else
+    uint64_t a0 = (uint64_t) vget_low_u64(vreinterpretq_u64_m128d(a));
+    uint64_t a1 = (uint64_t) vget_high_u64(vreinterpretq_u64_m128d(a));
+    uint64_t b0 = (uint64_t) vget_low_u64(vreinterpretq_u64_m128d(b));
+    uint64_t b1 = (uint64_t) vget_high_u64(vreinterpretq_u64_m128d(b));
+    uint64_t d[2];
+    d[0] =
+        !((*(double *) &a0) > (*(double *) &b0)) ? ~UINT64_C(0) : UINT64_C(0);
+    d[1] =
+        !((*(double *) &a1) > (*(double *) &b1)) ? ~UINT64_C(0) : UINT64_C(0);
+
+    return vreinterpretq_m128d_u64(vld1q_u64(d));
+#endif
+}
+
+// Compare the lower double-precision (64-bit) floating-point elements in a and
+// b for not-greater-than, store the result in the lower element of dst, and
+// copy the upper element from a to the upper element of dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmpngt_sd
+FORCE_INLINE __m128d _mm_cmpngt_sd(__m128d a, __m128d b)
+{
+    return _mm_move_sd(a, _mm_cmpngt_pd(a, b));
+}
+
+// Compare packed double-precision (64-bit) floating-point elements in a and b
+// for not-less-than-or-equal, and store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmpnle_pd
+FORCE_INLINE __m128d _mm_cmpnle_pd(__m128d a, __m128d b)
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+    return vreinterpretq_m128d_u64(veorq_u64(
+        vcleq_f64(vreinterpretq_f64_m128d(a), vreinterpretq_f64_m128d(b)),
+        vdupq_n_u64(UINT64_MAX)));
+#else
+    uint64_t a0 = (uint64_t) vget_low_u64(vreinterpretq_u64_m128d(a));
+    uint64_t a1 = (uint64_t) vget_high_u64(vreinterpretq_u64_m128d(a));
+    uint64_t b0 = (uint64_t) vget_low_u64(vreinterpretq_u64_m128d(b));
+    uint64_t b1 = (uint64_t) vget_high_u64(vreinterpretq_u64_m128d(b));
+    uint64_t d[2];
+    d[0] =
+        !((*(double *) &a0) <= (*(double *) &b0)) ? ~UINT64_C(0) : UINT64_C(0);
+    d[1] =
+        !((*(double *) &a1) <= (*(double *) &b1)) ? ~UINT64_C(0) : UINT64_C(0);
+
+    return vreinterpretq_m128d_u64(vld1q_u64(d));
+#endif
+}
+
+// Compare the lower double-precision (64-bit) floating-point elements in a and
+// b for not-less-than-or-equal, store the result in the lower element of dst,
+// and copy the upper element from a to the upper element of dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmpnle_sd
+FORCE_INLINE __m128d _mm_cmpnle_sd(__m128d a, __m128d b)
+{
+    return _mm_move_sd(a, _mm_cmpnle_pd(a, b));
+}
+
+// Compare packed double-precision (64-bit) floating-point elements in a and b
+// for not-less-than, and store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmpnlt_pd
+FORCE_INLINE __m128d _mm_cmpnlt_pd(__m128d a, __m128d b)
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+    return vreinterpretq_m128d_u64(veorq_u64(
+        vcltq_f64(vreinterpretq_f64_m128d(a), vreinterpretq_f64_m128d(b)),
+        vdupq_n_u64(UINT64_MAX)));
+#else
+    uint64_t a0 = (uint64_t) vget_low_u64(vreinterpretq_u64_m128d(a));
+    uint64_t a1 = (uint64_t) vget_high_u64(vreinterpretq_u64_m128d(a));
+    uint64_t b0 = (uint64_t) vget_low_u64(vreinterpretq_u64_m128d(b));
+    uint64_t b1 = (uint64_t) vget_high_u64(vreinterpretq_u64_m128d(b));
+    uint64_t d[2];
+    d[0] =
+        !((*(double *) &a0) < (*(double *) &b0)) ? ~UINT64_C(0) : UINT64_C(0);
+    d[1] =
+        !((*(double *) &a1) < (*(double *) &b1)) ? ~UINT64_C(0) : UINT64_C(0);
+
+    return vreinterpretq_m128d_u64(vld1q_u64(d));
+#endif
+}
+
+// Compare the lower double-precision (64-bit) floating-point elements in a and
+// b for not-less-than, store the result in the lower element of dst, and copy
+// the upper element from a to the upper element of dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmpnlt_sd
+FORCE_INLINE __m128d _mm_cmpnlt_sd(__m128d a, __m128d b)
+{
+    return _mm_move_sd(a, _mm_cmpnlt_pd(a, b));
+}
+
+// Compare packed double-precision (64-bit) floating-point elements in a and b
+// to see if neither is NaN, and store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmpord_pd
+FORCE_INLINE __m128d _mm_cmpord_pd(__m128d a, __m128d b)
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+    // Excluding NaNs, any two floating point numbers can be compared.
+    uint64x2_t not_nan_a =
+        vceqq_f64(vreinterpretq_f64_m128d(a), vreinterpretq_f64_m128d(a));
+    uint64x2_t not_nan_b =
+        vceqq_f64(vreinterpretq_f64_m128d(b), vreinterpretq_f64_m128d(b));
+    return vreinterpretq_m128d_u64(vandq_u64(not_nan_a, not_nan_b));
+#else
+    uint64_t a0 = (uint64_t) vget_low_u64(vreinterpretq_u64_m128d(a));
+    uint64_t a1 = (uint64_t) vget_high_u64(vreinterpretq_u64_m128d(a));
+    uint64_t b0 = (uint64_t) vget_low_u64(vreinterpretq_u64_m128d(b));
+    uint64_t b1 = (uint64_t) vget_high_u64(vreinterpretq_u64_m128d(b));
+    uint64_t d[2];
+    d[0] = ((*(double *) &a0) == (*(double *) &a0) &&
+            (*(double *) &b0) == (*(double *) &b0))
+               ? ~UINT64_C(0)
+               : UINT64_C(0);
+    d[1] = ((*(double *) &a1) == (*(double *) &a1) &&
+            (*(double *) &b1) == (*(double *) &b1))
+               ? ~UINT64_C(0)
+               : UINT64_C(0);
+
+    return vreinterpretq_m128d_u64(vld1q_u64(d));
+#endif
+}
+
+// Compare the lower double-precision (64-bit) floating-point elements in a and
+// b to see if neither is NaN, store the result in the lower element of dst, and
+// copy the upper element from a to the upper element of dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmpord_sd
+FORCE_INLINE __m128d _mm_cmpord_sd(__m128d a, __m128d b)
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+    return _mm_move_sd(a, _mm_cmpord_pd(a, b));
+#else
+    uint64_t a0 = (uint64_t) vget_low_u64(vreinterpretq_u64_m128d(a));
+    uint64_t b0 = (uint64_t) vget_low_u64(vreinterpretq_u64_m128d(b));
+    uint64_t a1 = (uint64_t) vget_high_u64(vreinterpretq_u64_m128d(a));
+    uint64_t d[2];
+    d[0] = ((*(double *) &a0) == (*(double *) &a0) &&
+            (*(double *) &b0) == (*(double *) &b0))
+               ? ~UINT64_C(0)
+               : UINT64_C(0);
+    d[1] = a1;
+
+    return vreinterpretq_m128d_u64(vld1q_u64(d));
+#endif
+}
+
+// Compare packed double-precision (64-bit) floating-point elements in a and b
+// to see if either is NaN, and store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmpunord_pd
+FORCE_INLINE __m128d _mm_cmpunord_pd(__m128d a, __m128d b)
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+    // Two NaNs are not equal in comparison operation.
+    uint64x2_t not_nan_a =
+        vceqq_f64(vreinterpretq_f64_m128d(a), vreinterpretq_f64_m128d(a));
+    uint64x2_t not_nan_b =
+        vceqq_f64(vreinterpretq_f64_m128d(b), vreinterpretq_f64_m128d(b));
+    return vreinterpretq_m128d_s32(
+        vmvnq_s32(vreinterpretq_s32_u64(vandq_u64(not_nan_a, not_nan_b))));
+#else
+    uint64_t a0 = (uint64_t) vget_low_u64(vreinterpretq_u64_m128d(a));
+    uint64_t a1 = (uint64_t) vget_high_u64(vreinterpretq_u64_m128d(a));
+    uint64_t b0 = (uint64_t) vget_low_u64(vreinterpretq_u64_m128d(b));
+    uint64_t b1 = (uint64_t) vget_high_u64(vreinterpretq_u64_m128d(b));
+    uint64_t d[2];
+    d[0] = ((*(double *) &a0) == (*(double *) &a0) &&
+            (*(double *) &b0) == (*(double *) &b0))
+               ? UINT64_C(0)
+               : ~UINT64_C(0);
+    d[1] = ((*(double *) &a1) == (*(double *) &a1) &&
+            (*(double *) &b1) == (*(double *) &b1))
+               ? UINT64_C(0)
+               : ~UINT64_C(0);
+
+    return vreinterpretq_m128d_u64(vld1q_u64(d));
+#endif
+}
+
+// Compare the lower double-precision (64-bit) floating-point elements in a and
+// b to see if either is NaN, store the result in the lower element of dst, and
+// copy the upper element from a to the upper element of dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmpunord_sd
+FORCE_INLINE __m128d _mm_cmpunord_sd(__m128d a, __m128d b)
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+    return _mm_move_sd(a, _mm_cmpunord_pd(a, b));
+#else
+    uint64_t a0 = (uint64_t) vget_low_u64(vreinterpretq_u64_m128d(a));
+    uint64_t b0 = (uint64_t) vget_low_u64(vreinterpretq_u64_m128d(b));
+    uint64_t a1 = (uint64_t) vget_high_u64(vreinterpretq_u64_m128d(a));
+    uint64_t d[2];
+    d[0] = ((*(double *) &a0) == (*(double *) &a0) &&
+            (*(double *) &b0) == (*(double *) &b0))
+               ? UINT64_C(0)
+               : ~UINT64_C(0);
+    d[1] = a1;
+
+    return vreinterpretq_m128d_u64(vld1q_u64(d));
+#endif
+}
+
+// Compare the lower double-precision (64-bit) floating-point element in a and b
+// for greater-than-or-equal, and return the boolean result (0 or 1).
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_comige_sd
+FORCE_INLINE int _mm_comige_sd(__m128d a, __m128d b)
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+    return vgetq_lane_u64(vcgeq_f64(a, b), 0) & 0x1;
+#else
+    uint64_t a0 = (uint64_t) vget_low_u64(vreinterpretq_u64_m128d(a));
+    uint64_t b0 = (uint64_t) vget_low_u64(vreinterpretq_u64_m128d(b));
+
+    return (*(double *) &a0 >= *(double *) &b0);
+#endif
+}
+
+// Compare the lower double-precision (64-bit) floating-point element in a and b
+// for greater-than, and return the boolean result (0 or 1).
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_comigt_sd
+FORCE_INLINE int _mm_comigt_sd(__m128d a, __m128d b)
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+    return vgetq_lane_u64(vcgtq_f64(a, b), 0) & 0x1;
+#else
+    uint64_t a0 = (uint64_t) vget_low_u64(vreinterpretq_u64_m128d(a));
+    uint64_t b0 = (uint64_t) vget_low_u64(vreinterpretq_u64_m128d(b));
+
+    return (*(double *) &a0 > *(double *) &b0);
+#endif
+}
+
+// Compare the lower double-precision (64-bit) floating-point element in a and b
+// for less-than-or-equal, and return the boolean result (0 or 1).
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_comile_sd
+FORCE_INLINE int _mm_comile_sd(__m128d a, __m128d b)
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+    return vgetq_lane_u64(vcleq_f64(a, b), 0) & 0x1;
+#else
+    uint64_t a0 = (uint64_t) vget_low_u64(vreinterpretq_u64_m128d(a));
+    uint64_t b0 = (uint64_t) vget_low_u64(vreinterpretq_u64_m128d(b));
+
+    return (*(double *) &a0 <= *(double *) &b0);
+#endif
+}
+
+// Compare the lower double-precision (64-bit) floating-point element in a and b
+// for less-than, and return the boolean result (0 or 1).
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_comilt_sd
+FORCE_INLINE int _mm_comilt_sd(__m128d a, __m128d b)
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+    return vgetq_lane_u64(vcltq_f64(a, b), 0) & 0x1;
+#else
+    uint64_t a0 = (uint64_t) vget_low_u64(vreinterpretq_u64_m128d(a));
+    uint64_t b0 = (uint64_t) vget_low_u64(vreinterpretq_u64_m128d(b));
+
+    return (*(double *) &a0 < *(double *) &b0);
+#endif
+}
+
+// Compare the lower double-precision (64-bit) floating-point element in a and b
+// for equality, and return the boolean result (0 or 1).
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_comieq_sd
+FORCE_INLINE int _mm_comieq_sd(__m128d a, __m128d b)
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+    return vgetq_lane_u64(vceqq_f64(a, b), 0) & 0x1;
+#else
+    uint32x4_t a_not_nan =
+        vceqq_u32(vreinterpretq_u32_m128d(a), vreinterpretq_u32_m128d(a));
+    uint32x4_t b_not_nan =
+        vceqq_u32(vreinterpretq_u32_m128d(b), vreinterpretq_u32_m128d(b));
+    uint32x4_t a_and_b_not_nan = vandq_u32(a_not_nan, b_not_nan);
+    uint32x4_t a_eq_b =
+        vceqq_u32(vreinterpretq_u32_m128d(a), vreinterpretq_u32_m128d(b));
+    uint64x2_t and_results = vandq_u64(vreinterpretq_u64_u32(a_and_b_not_nan),
+                                       vreinterpretq_u64_u32(a_eq_b));
+    return vgetq_lane_u64(and_results, 0) & 0x1;
+#endif
+}
+
+// Compare the lower double-precision (64-bit) floating-point element in a and b
+// for not-equal, and return the boolean result (0 or 1).
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_comineq_sd
+FORCE_INLINE int _mm_comineq_sd(__m128d a, __m128d b)
+{
+    return !_mm_comieq_sd(a, b);
+}
+
+// Convert packed signed 32-bit integers in a to packed double-precision
+// (64-bit) floating-point elements, and store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvtepi32_pd
+FORCE_INLINE __m128d _mm_cvtepi32_pd(__m128i a)
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+    return vreinterpretq_m128d_f64(
+        vcvtq_f64_s64(vmovl_s32(vget_low_s32(vreinterpretq_s32_m128i(a)))));
+#else
+    double a0 = (double) vgetq_lane_s32(vreinterpretq_s32_m128i(a), 0);
+    double a1 = (double) vgetq_lane_s32(vreinterpretq_s32_m128i(a), 1);
+    return _mm_set_pd(a1, a0);
+#endif
+}
+
+// Convert packed signed 32-bit integers in a to packed single-precision
+// (32-bit) floating-point elements, and store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvtepi32_ps
+FORCE_INLINE __m128 _mm_cvtepi32_ps(__m128i a)
+{
+    return vreinterpretq_m128_f32(vcvtq_f32_s32(vreinterpretq_s32_m128i(a)));
+}
+
+// Convert packed double-precision (64-bit) floating-point elements in a to
+// packed 32-bit integers, and store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvtpd_epi32
+FORCE_INLINE __m128i _mm_cvtpd_epi32(__m128d a)
+{
+// vrnd32xq_f64 not supported on clang
+#if defined(__ARM_FEATURE_FRINT) && !defined(__clang__)
+    float64x2_t rounded = vrnd32xq_f64(vreinterpretq_f64_m128d(a));
+    int64x2_t integers = vcvtq_s64_f64(rounded);
+    return vreinterpretq_m128i_s32(
+        vcombine_s32(vmovn_s64(integers), vdup_n_s32(0)));
+#else
+    __m128d rnd = _mm_round_pd(a, _MM_FROUND_CUR_DIRECTION);
+    double d0 = ((double *) &rnd)[0];
+    double d1 = ((double *) &rnd)[1];
+    return _mm_set_epi32(0, 0, (int32_t) d1, (int32_t) d0);
+#endif
+}
+
+// Convert packed double-precision (64-bit) floating-point elements in a to
+// packed 32-bit integers, and store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvtpd_pi32
+FORCE_INLINE __m64 _mm_cvtpd_pi32(__m128d a)
+{
+    __m128d rnd = _mm_round_pd(a, _MM_FROUND_CUR_DIRECTION);
+    double d0 = ((double *) &rnd)[0];
+    double d1 = ((double *) &rnd)[1];
+    int32_t ALIGN_STRUCT(16) data[2] = {(int32_t) d0, (int32_t) d1};
+    return vreinterpret_m64_s32(vld1_s32(data));
+}
+
+// Convert packed double-precision (64-bit) floating-point elements in a to
+// packed single-precision (32-bit) floating-point elements, and store the
+// results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvtpd_ps
+FORCE_INLINE __m128 _mm_cvtpd_ps(__m128d a)
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+    float32x2_t tmp = vcvt_f32_f64(vreinterpretq_f64_m128d(a));
+    return vreinterpretq_m128_f32(vcombine_f32(tmp, vdup_n_f32(0)));
+#else
+    float a0 = (float) ((double *) &a)[0];
+    float a1 = (float) ((double *) &a)[1];
+    return _mm_set_ps(0, 0, a1, a0);
+#endif
+}
+
+// Convert packed signed 32-bit integers in a to packed double-precision
+// (64-bit) floating-point elements, and store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvtpi32_pd
+FORCE_INLINE __m128d _mm_cvtpi32_pd(__m64 a)
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+    return vreinterpretq_m128d_f64(
+        vcvtq_f64_s64(vmovl_s32(vreinterpret_s32_m64(a))));
+#else
+    double a0 = (double) vget_lane_s32(vreinterpret_s32_m64(a), 0);
+    double a1 = (double) vget_lane_s32(vreinterpret_s32_m64(a), 1);
+    return _mm_set_pd(a1, a0);
+#endif
+}
+
+// Convert packed single-precision (32-bit) floating-point elements in a to
+// packed 32-bit integers, and store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvtps_epi32
+// *NOTE*. The default rounding mode on SSE is 'round to even', which ARMv7-A
+// does not support! It is supported on ARMv8-A however.
+FORCE_INLINE __m128i _mm_cvtps_epi32(__m128 a)
+{
+#if defined(__ARM_FEATURE_FRINT)
+    return vreinterpretq_m128i_s32(vcvtq_s32_f32(vrnd32xq_f32(a)));
+#elif (defined(__aarch64__) || defined(_M_ARM64)) || \
+    defined(__ARM_FEATURE_DIRECTED_ROUNDING)
+    switch (_MM_GET_ROUNDING_MODE()) {
+    case _MM_ROUND_NEAREST:
+        return vreinterpretq_m128i_s32(vcvtnq_s32_f32(a));
+    case _MM_ROUND_DOWN:
+        return vreinterpretq_m128i_s32(vcvtmq_s32_f32(a));
+    case _MM_ROUND_UP:
+        return vreinterpretq_m128i_s32(vcvtpq_s32_f32(a));
+    default:  // _MM_ROUND_TOWARD_ZERO
+        return vreinterpretq_m128i_s32(vcvtq_s32_f32(a));
+    }
+#else
+    float *f = (float *) &a;
+    switch (_MM_GET_ROUNDING_MODE()) {
+    case _MM_ROUND_NEAREST: {
+        uint32x4_t signmask = vdupq_n_u32(0x80000000);
+        float32x4_t half = vbslq_f32(signmask, vreinterpretq_f32_m128(a),
+                                     vdupq_n_f32(0.5f)); /* +/- 0.5 */
+        int32x4_t r_normal = vcvtq_s32_f32(vaddq_f32(
+            vreinterpretq_f32_m128(a), half)); /* round to integer: [a + 0.5]*/
+        int32x4_t r_trunc = vcvtq_s32_f32(
+            vreinterpretq_f32_m128(a)); /* truncate to integer: [a] */
+        int32x4_t plusone = vreinterpretq_s32_u32(vshrq_n_u32(
+            vreinterpretq_u32_s32(vnegq_s32(r_trunc)), 31)); /* 1 or 0 */
+        int32x4_t r_even = vbicq_s32(vaddq_s32(r_trunc, plusone),
+                                     vdupq_n_s32(1)); /* ([a] + {0,1}) & ~1 */
+        float32x4_t delta = vsubq_f32(
+            vreinterpretq_f32_m128(a),
+            vcvtq_f32_s32(r_trunc)); /* compute delta: delta = (a - [a]) */
+        uint32x4_t is_delta_half =
+            vceqq_f32(delta, half); /* delta == +/- 0.5 */
+        return vreinterpretq_m128i_s32(
+            vbslq_s32(is_delta_half, r_even, r_normal));
+    }
+    case _MM_ROUND_DOWN:
+        return _mm_set_epi32(floorf(f[3]), floorf(f[2]), floorf(f[1]),
+                             floorf(f[0]));
+    case _MM_ROUND_UP:
+        return _mm_set_epi32(ceilf(f[3]), ceilf(f[2]), ceilf(f[1]),
+                             ceilf(f[0]));
+    default:  // _MM_ROUND_TOWARD_ZERO
+        return _mm_set_epi32((int32_t) f[3], (int32_t) f[2], (int32_t) f[1],
+                             (int32_t) f[0]);
+    }
+#endif
+}
+
+// Convert packed single-precision (32-bit) floating-point elements in a to
+// packed double-precision (64-bit) floating-point elements, and store the
+// results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvtps_pd
+FORCE_INLINE __m128d _mm_cvtps_pd(__m128 a)
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+    return vreinterpretq_m128d_f64(
+        vcvt_f64_f32(vget_low_f32(vreinterpretq_f32_m128(a))));
+#else
+    double a0 = (double) vgetq_lane_f32(vreinterpretq_f32_m128(a), 0);
+    double a1 = (double) vgetq_lane_f32(vreinterpretq_f32_m128(a), 1);
+    return _mm_set_pd(a1, a0);
+#endif
+}
+
+// Copy the lower double-precision (64-bit) floating-point element of a to dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvtsd_f64
+FORCE_INLINE double _mm_cvtsd_f64(__m128d a)
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+    return (double) vgetq_lane_f64(vreinterpretq_f64_m128d(a), 0);
+#else
+    return ((double *) &a)[0];
+#endif
+}
+
+// Convert the lower double-precision (64-bit) floating-point element in a to a
+// 32-bit integer, and store the result in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvtsd_si32
+FORCE_INLINE int32_t _mm_cvtsd_si32(__m128d a)
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+    return (int32_t) vgetq_lane_f64(vrndiq_f64(vreinterpretq_f64_m128d(a)), 0);
+#else
+    __m128d rnd = _mm_round_pd(a, _MM_FROUND_CUR_DIRECTION);
+    double ret = ((double *) &rnd)[0];
+    return (int32_t) ret;
+#endif
+}
+
+// Convert the lower double-precision (64-bit) floating-point element in a to a
+// 64-bit integer, and store the result in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvtsd_si64
+FORCE_INLINE int64_t _mm_cvtsd_si64(__m128d a)
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+    return (int64_t) vgetq_lane_f64(vrndiq_f64(vreinterpretq_f64_m128d(a)), 0);
+#else
+    __m128d rnd = _mm_round_pd(a, _MM_FROUND_CUR_DIRECTION);
+    double ret = ((double *) &rnd)[0];
+    return (int64_t) ret;
+#endif
+}
+
+// Convert the lower double-precision (64-bit) floating-point element in a to a
+// 64-bit integer, and store the result in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvtsd_si64x
+#define _mm_cvtsd_si64x _mm_cvtsd_si64
+
+// Convert the lower double-precision (64-bit) floating-point element in b to a
+// single-precision (32-bit) floating-point element, store the result in the
+// lower element of dst, and copy the upper 3 packed elements from a to the
+// upper elements of dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvtsd_ss
+FORCE_INLINE __m128 _mm_cvtsd_ss(__m128 a, __m128d b)
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+    return vreinterpretq_m128_f32(vsetq_lane_f32(
+        vget_lane_f32(vcvt_f32_f64(vreinterpretq_f64_m128d(b)), 0),
+        vreinterpretq_f32_m128(a), 0));
+#else
+    return vreinterpretq_m128_f32(vsetq_lane_f32((float) ((double *) &b)[0],
+                                                 vreinterpretq_f32_m128(a), 0));
+#endif
+}
+
+// Copy the lower 32-bit integer in a to dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvtsi128_si32
+FORCE_INLINE int _mm_cvtsi128_si32(__m128i a)
+{
+    return vgetq_lane_s32(vreinterpretq_s32_m128i(a), 0);
+}
+
+// Copy the lower 64-bit integer in a to dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvtsi128_si64
+FORCE_INLINE int64_t _mm_cvtsi128_si64(__m128i a)
+{
+    return vgetq_lane_s64(vreinterpretq_s64_m128i(a), 0);
+}
+
+// Copy the lower 64-bit integer in a to dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvtsi128_si64x
+#define _mm_cvtsi128_si64x(a) _mm_cvtsi128_si64(a)
+
+// Convert the signed 32-bit integer b to a double-precision (64-bit)
+// floating-point element, store the result in the lower element of dst, and
+// copy the upper element from a to the upper element of dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvtsi32_sd
+FORCE_INLINE __m128d _mm_cvtsi32_sd(__m128d a, int32_t b)
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+    return vreinterpretq_m128d_f64(
+        vsetq_lane_f64((double) b, vreinterpretq_f64_m128d(a), 0));
+#else
+    double bf = (double) b;
+    return vreinterpretq_m128d_s64(
+        vsetq_lane_s64(*(int64_t *) &bf, vreinterpretq_s64_m128d(a), 0));
+#endif
+}
+
+// Copy the lower 64-bit integer in a to dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvtsi128_si64x
+#define _mm_cvtsi128_si64x(a) _mm_cvtsi128_si64(a)
+
+// Copy 32-bit integer a to the lower elements of dst, and zero the upper
+// elements of dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvtsi32_si128
+FORCE_INLINE __m128i _mm_cvtsi32_si128(int a)
+{
+    return vreinterpretq_m128i_s32(vsetq_lane_s32(a, vdupq_n_s32(0), 0));
+}
+
+// Convert the signed 64-bit integer b to a double-precision (64-bit)
+// floating-point element, store the result in the lower element of dst, and
+// copy the upper element from a to the upper element of dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvtsi64_sd
+FORCE_INLINE __m128d _mm_cvtsi64_sd(__m128d a, int64_t b)
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+    return vreinterpretq_m128d_f64(
+        vsetq_lane_f64((double) b, vreinterpretq_f64_m128d(a), 0));
+#else
+    double bf = (double) b;
+    return vreinterpretq_m128d_s64(
+        vsetq_lane_s64(*(int64_t *) &bf, vreinterpretq_s64_m128d(a), 0));
+#endif
+}
+
+// Copy 64-bit integer a to the lower element of dst, and zero the upper
+// element.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvtsi64_si128
+FORCE_INLINE __m128i _mm_cvtsi64_si128(int64_t a)
+{
+    return vreinterpretq_m128i_s64(vsetq_lane_s64(a, vdupq_n_s64(0), 0));
+}
+
+// Copy 64-bit integer a to the lower element of dst, and zero the upper
+// element.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvtsi64x_si128
+#define _mm_cvtsi64x_si128(a) _mm_cvtsi64_si128(a)
+
+// Convert the signed 64-bit integer b to a double-precision (64-bit)
+// floating-point element, store the result in the lower element of dst, and
+// copy the upper element from a to the upper element of dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvtsi64x_sd
+#define _mm_cvtsi64x_sd(a, b) _mm_cvtsi64_sd(a, b)
+
+// Convert the lower single-precision (32-bit) floating-point element in b to a
+// double-precision (64-bit) floating-point element, store the result in the
+// lower element of dst, and copy the upper element from a to the upper element
+// of dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvtss_sd
+FORCE_INLINE __m128d _mm_cvtss_sd(__m128d a, __m128 b)
+{
+    double d = (double) vgetq_lane_f32(vreinterpretq_f32_m128(b), 0);
+#if defined(__aarch64__) || defined(_M_ARM64)
+    return vreinterpretq_m128d_f64(
+        vsetq_lane_f64(d, vreinterpretq_f64_m128d(a), 0));
+#else
+    return vreinterpretq_m128d_s64(
+        vsetq_lane_s64(*(int64_t *) &d, vreinterpretq_s64_m128d(a), 0));
+#endif
+}
+
+// Convert packed double-precision (64-bit) floating-point elements in a to
+// packed 32-bit integers with truncation, and store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvttpd_epi32
+FORCE_INLINE __m128i _mm_cvttpd_epi32(__m128d a)
+{
+    double a0 = ((double *) &a)[0];
+    double a1 = ((double *) &a)[1];
+    return _mm_set_epi32(0, 0, (int32_t) a1, (int32_t) a0);
+}
+
+// Convert packed double-precision (64-bit) floating-point elements in a to
+// packed 32-bit integers with truncation, and store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvttpd_pi32
+FORCE_INLINE __m64 _mm_cvttpd_pi32(__m128d a)
+{
+    double a0 = ((double *) &a)[0];
+    double a1 = ((double *) &a)[1];
+    int32_t ALIGN_STRUCT(16) data[2] = {(int32_t) a0, (int32_t) a1};
+    return vreinterpret_m64_s32(vld1_s32(data));
+}
+
+// Convert packed single-precision (32-bit) floating-point elements in a to
+// packed 32-bit integers with truncation, and store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvttps_epi32
+FORCE_INLINE __m128i _mm_cvttps_epi32(__m128 a)
+{
+    return vreinterpretq_m128i_s32(vcvtq_s32_f32(vreinterpretq_f32_m128(a)));
+}
+
+// Convert the lower double-precision (64-bit) floating-point element in a to a
+// 32-bit integer with truncation, and store the result in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvttsd_si32
+FORCE_INLINE int32_t _mm_cvttsd_si32(__m128d a)
+{
+    double ret = *((double *) &a);
+    return (int32_t) ret;
+}
+
+// Convert the lower double-precision (64-bit) floating-point element in a to a
+// 64-bit integer with truncation, and store the result in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvttsd_si64
+FORCE_INLINE int64_t _mm_cvttsd_si64(__m128d a)
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+    return vgetq_lane_s64(vcvtq_s64_f64(vreinterpretq_f64_m128d(a)), 0);
+#else
+    double ret = *((double *) &a);
+    return (int64_t) ret;
+#endif
+}
+
+// Convert the lower double-precision (64-bit) floating-point element in a to a
+// 64-bit integer with truncation, and store the result in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvttsd_si64x
+#define _mm_cvttsd_si64x(a) _mm_cvttsd_si64(a)
+
+// Divide packed double-precision (64-bit) floating-point elements in a by
+// packed elements in b, and store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_div_pd
+FORCE_INLINE __m128d _mm_div_pd(__m128d a, __m128d b)
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+    return vreinterpretq_m128d_f64(
+        vdivq_f64(vreinterpretq_f64_m128d(a), vreinterpretq_f64_m128d(b)));
+#else
+    double *da = (double *) &a;
+    double *db = (double *) &b;
+    double c[2];
+    c[0] = da[0] / db[0];
+    c[1] = da[1] / db[1];
+    return vld1q_f32((float32_t *) c);
+#endif
+}
+
+// Divide the lower double-precision (64-bit) floating-point element in a by the
+// lower double-precision (64-bit) floating-point element in b, store the result
+// in the lower element of dst, and copy the upper element from a to the upper
+// element of dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_div_sd
+FORCE_INLINE __m128d _mm_div_sd(__m128d a, __m128d b)
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+    float64x2_t tmp =
+        vdivq_f64(vreinterpretq_f64_m128d(a), vreinterpretq_f64_m128d(b));
+    return vreinterpretq_m128d_f64(
+        vsetq_lane_f64(vgetq_lane_f64(vreinterpretq_f64_m128d(a), 1), tmp, 1));
+#else
+    return _mm_move_sd(a, _mm_div_pd(a, b));
+#endif
+}
+
+// Extract a 16-bit integer from a, selected with imm8, and store the result in
+// the lower element of dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_extract_epi16
+// FORCE_INLINE int _mm_extract_epi16(__m128i a, __constrange(0,8) int imm)
+#define _mm_extract_epi16(a, imm) \
+    vgetq_lane_u16(vreinterpretq_u16_m128i(a), (imm))
+
+// Copy a to dst, and insert the 16-bit integer i into dst at the location
+// specified by imm8.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_insert_epi16
+// FORCE_INLINE __m128i _mm_insert_epi16(__m128i a, int b,
+//                                       __constrange(0,8) int imm)
+#define _mm_insert_epi16(a, b, imm) \
+    vreinterpretq_m128i_s16(        \
+        vsetq_lane_s16((b), vreinterpretq_s16_m128i(a), (imm)))
+
+// Load 128-bits (composed of 2 packed double-precision (64-bit) floating-point
+// elements) from memory into dst. mem_addr must be aligned on a 16-byte
+// boundary or a general-protection exception may be generated.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_load_pd
+FORCE_INLINE __m128d _mm_load_pd(const double *p)
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+    return vreinterpretq_m128d_f64(vld1q_f64(p));
+#else
+    const float *fp = (const float *) p;
+    float ALIGN_STRUCT(16) data[4] = {fp[0], fp[1], fp[2], fp[3]};
+    return vreinterpretq_m128d_f32(vld1q_f32(data));
+#endif
+}
+
+// Load a double-precision (64-bit) floating-point element from memory into both
+// elements of dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_load_pd1
+#define _mm_load_pd1 _mm_load1_pd
+
+// Load a double-precision (64-bit) floating-point element from memory into the
+// lower of dst, and zero the upper element. mem_addr does not need to be
+// aligned on any particular boundary.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_load_sd
+FORCE_INLINE __m128d _mm_load_sd(const double *p)
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+    return vreinterpretq_m128d_f64(vsetq_lane_f64(*p, vdupq_n_f64(0), 0));
+#else
+    const float *fp = (const float *) p;
+    float ALIGN_STRUCT(16) data[4] = {fp[0], fp[1], 0, 0};
+    return vreinterpretq_m128d_f32(vld1q_f32(data));
+#endif
+}
+
+// Load 128-bits of integer data from memory into dst. mem_addr must be aligned
+// on a 16-byte boundary or a general-protection exception may be generated.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_load_si128
+FORCE_INLINE __m128i _mm_load_si128(const __m128i *p)
+{
+    return vreinterpretq_m128i_s32(vld1q_s32((const int32_t *) p));
+}
+
+// Load a double-precision (64-bit) floating-point element from memory into both
+// elements of dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_load1_pd
+FORCE_INLINE __m128d _mm_load1_pd(const double *p)
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+    return vreinterpretq_m128d_f64(vld1q_dup_f64(p));
+#else
+    return vreinterpretq_m128d_s64(vdupq_n_s64(*(const int64_t *) p));
+#endif
+}
+
+// Load a double-precision (64-bit) floating-point element from memory into the
+// upper element of dst, and copy the lower element from a to dst. mem_addr does
+// not need to be aligned on any particular boundary.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_loadh_pd
+FORCE_INLINE __m128d _mm_loadh_pd(__m128d a, const double *p)
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+    return vreinterpretq_m128d_f64(
+        vcombine_f64(vget_low_f64(vreinterpretq_f64_m128d(a)), vld1_f64(p)));
+#else
+    return vreinterpretq_m128d_f32(vcombine_f32(
+        vget_low_f32(vreinterpretq_f32_m128d(a)), vld1_f32((const float *) p)));
+#endif
+}
+
+// Load 64-bit integer from memory into the first element of dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_loadl_epi64
+FORCE_INLINE __m128i _mm_loadl_epi64(__m128i const *p)
+{
+    /* Load the lower 64 bits of the value pointed to by p into the
+     * lower 64 bits of the result, zeroing the upper 64 bits of the result.
+     */
+    return vreinterpretq_m128i_s32(
+        vcombine_s32(vld1_s32((int32_t const *) p), vcreate_s32(0)));
+}
+
+// Load a double-precision (64-bit) floating-point element from memory into the
+// lower element of dst, and copy the upper element from a to dst. mem_addr does
+// not need to be aligned on any particular boundary.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_loadl_pd
+FORCE_INLINE __m128d _mm_loadl_pd(__m128d a, const double *p)
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+    return vreinterpretq_m128d_f64(
+        vcombine_f64(vld1_f64(p), vget_high_f64(vreinterpretq_f64_m128d(a))));
+#else
+    return vreinterpretq_m128d_f32(
+        vcombine_f32(vld1_f32((const float *) p),
+                     vget_high_f32(vreinterpretq_f32_m128d(a))));
+#endif
+}
+
+// Load 2 double-precision (64-bit) floating-point elements from memory into dst
+// in reverse order. mem_addr must be aligned on a 16-byte boundary or a
+// general-protection exception may be generated.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_loadr_pd
+FORCE_INLINE __m128d _mm_loadr_pd(const double *p)
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+    float64x2_t v = vld1q_f64(p);
+    return vreinterpretq_m128d_f64(vextq_f64(v, v, 1));
+#else
+    int64x2_t v = vld1q_s64((const int64_t *) p);
+    return vreinterpretq_m128d_s64(vextq_s64(v, v, 1));
+#endif
+}
+
+// Loads two double-precision from unaligned memory, floating-point values.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_loadu_pd
+FORCE_INLINE __m128d _mm_loadu_pd(const double *p)
+{
+    return _mm_load_pd(p);
+}
+
+// Load 128-bits of integer data from memory into dst. mem_addr does not need to
+// be aligned on any particular boundary.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_loadu_si128
+FORCE_INLINE __m128i _mm_loadu_si128(const __m128i *p)
+{
+    return vreinterpretq_m128i_s32(vld1q_s32((const int32_t *) p));
+}
+
+// Load unaligned 32-bit integer from memory into the first element of dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_loadu_si32
+FORCE_INLINE __m128i _mm_loadu_si32(const void *p)
+{
+    return vreinterpretq_m128i_s32(
+        vsetq_lane_s32(*(const int32_t *) p, vdupq_n_s32(0), 0));
+}
+
+// Multiply packed signed 16-bit integers in a and b, producing intermediate
+// signed 32-bit integers. Horizontally add adjacent pairs of intermediate
+// 32-bit integers, and pack the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_madd_epi16
+FORCE_INLINE __m128i _mm_madd_epi16(__m128i a, __m128i b)
+{
+    int32x4_t low = vmull_s16(vget_low_s16(vreinterpretq_s16_m128i(a)),
+                              vget_low_s16(vreinterpretq_s16_m128i(b)));
+#if defined(__aarch64__) || defined(_M_ARM64)
+    int32x4_t high =
+        vmull_high_s16(vreinterpretq_s16_m128i(a), vreinterpretq_s16_m128i(b));
+
+    return vreinterpretq_m128i_s32(vpaddq_s32(low, high));
+#else
+    int32x4_t high = vmull_s16(vget_high_s16(vreinterpretq_s16_m128i(a)),
+                               vget_high_s16(vreinterpretq_s16_m128i(b)));
+
+    int32x2_t low_sum = vpadd_s32(vget_low_s32(low), vget_high_s32(low));
+    int32x2_t high_sum = vpadd_s32(vget_low_s32(high), vget_high_s32(high));
+
+    return vreinterpretq_m128i_s32(vcombine_s32(low_sum, high_sum));
+#endif
+}
+
+// Conditionally store 8-bit integer elements from a into memory using mask
+// (elements are not stored when the highest bit is not set in the corresponding
+// element) and a non-temporal memory hint. mem_addr does not need to be aligned
+// on any particular boundary.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maskmoveu_si128
+FORCE_INLINE void _mm_maskmoveu_si128(__m128i a, __m128i mask, char *mem_addr)
+{
+    int8x16_t shr_mask = vshrq_n_s8(vreinterpretq_s8_m128i(mask), 7);
+    __m128 b = _mm_load_ps((const float *) mem_addr);
+    int8x16_t masked =
+        vbslq_s8(vreinterpretq_u8_s8(shr_mask), vreinterpretq_s8_m128i(a),
+                 vreinterpretq_s8_m128(b));
+    vst1q_s8((int8_t *) mem_addr, masked);
+}
+
+// Compare packed signed 16-bit integers in a and b, and store packed maximum
+// values in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_max_epi16
+FORCE_INLINE __m128i _mm_max_epi16(__m128i a, __m128i b)
+{
+    return vreinterpretq_m128i_s16(
+        vmaxq_s16(vreinterpretq_s16_m128i(a), vreinterpretq_s16_m128i(b)));
+}
+
+// Compare packed unsigned 8-bit integers in a and b, and store packed maximum
+// values in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_max_epu8
+FORCE_INLINE __m128i _mm_max_epu8(__m128i a, __m128i b)
+{
+    return vreinterpretq_m128i_u8(
+        vmaxq_u8(vreinterpretq_u8_m128i(a), vreinterpretq_u8_m128i(b)));
+}
+
+// Compare packed double-precision (64-bit) floating-point elements in a and b,
+// and store packed maximum values in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_max_pd
+FORCE_INLINE __m128d _mm_max_pd(__m128d a, __m128d b)
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+#if SSE2NEON_PRECISE_MINMAX
+    float64x2_t _a = vreinterpretq_f64_m128d(a);
+    float64x2_t _b = vreinterpretq_f64_m128d(b);
+    return vreinterpretq_m128d_f64(vbslq_f64(vcgtq_f64(_a, _b), _a, _b));
+#else
+    return vreinterpretq_m128d_f64(
+        vmaxq_f64(vreinterpretq_f64_m128d(a), vreinterpretq_f64_m128d(b)));
+#endif
+#else
+    uint64_t a0 = (uint64_t) vget_low_u64(vreinterpretq_u64_m128d(a));
+    uint64_t a1 = (uint64_t) vget_high_u64(vreinterpretq_u64_m128d(a));
+    uint64_t b0 = (uint64_t) vget_low_u64(vreinterpretq_u64_m128d(b));
+    uint64_t b1 = (uint64_t) vget_high_u64(vreinterpretq_u64_m128d(b));
+    uint64_t d[2];
+    d[0] = (*(double *) &a0) > (*(double *) &b0) ? a0 : b0;
+    d[1] = (*(double *) &a1) > (*(double *) &b1) ? a1 : b1;
+
+    return vreinterpretq_m128d_u64(vld1q_u64(d));
+#endif
+}
+
+// Compare the lower double-precision (64-bit) floating-point elements in a and
+// b, store the maximum value in the lower element of dst, and copy the upper
+// element from a to the upper element of dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_max_sd
+FORCE_INLINE __m128d _mm_max_sd(__m128d a, __m128d b)
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+    return _mm_move_sd(a, _mm_max_pd(a, b));
+#else
+    double *da = (double *) &a;
+    double *db = (double *) &b;
+    double c[2] = {da[0] > db[0] ? da[0] : db[0], da[1]};
+    return vreinterpretq_m128d_f32(vld1q_f32((float32_t *) c));
+#endif
+}
+
+// Compare packed signed 16-bit integers in a and b, and store packed minimum
+// values in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_min_epi16
+FORCE_INLINE __m128i _mm_min_epi16(__m128i a, __m128i b)
+{
+    return vreinterpretq_m128i_s16(
+        vminq_s16(vreinterpretq_s16_m128i(a), vreinterpretq_s16_m128i(b)));
+}
+
+// Compare packed unsigned 8-bit integers in a and b, and store packed minimum
+// values in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_min_epu8
+FORCE_INLINE __m128i _mm_min_epu8(__m128i a, __m128i b)
+{
+    return vreinterpretq_m128i_u8(
+        vminq_u8(vreinterpretq_u8_m128i(a), vreinterpretq_u8_m128i(b)));
+}
+
+// Compare packed double-precision (64-bit) floating-point elements in a and b,
+// and store packed minimum values in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_min_pd
+FORCE_INLINE __m128d _mm_min_pd(__m128d a, __m128d b)
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+#if SSE2NEON_PRECISE_MINMAX
+    float64x2_t _a = vreinterpretq_f64_m128d(a);
+    float64x2_t _b = vreinterpretq_f64_m128d(b);
+    return vreinterpretq_m128d_f64(vbslq_f64(vcltq_f64(_a, _b), _a, _b));
+#else
+    return vreinterpretq_m128d_f64(
+        vminq_f64(vreinterpretq_f64_m128d(a), vreinterpretq_f64_m128d(b)));
+#endif
+#else
+    uint64_t a0 = (uint64_t) vget_low_u64(vreinterpretq_u64_m128d(a));
+    uint64_t a1 = (uint64_t) vget_high_u64(vreinterpretq_u64_m128d(a));
+    uint64_t b0 = (uint64_t) vget_low_u64(vreinterpretq_u64_m128d(b));
+    uint64_t b1 = (uint64_t) vget_high_u64(vreinterpretq_u64_m128d(b));
+    uint64_t d[2];
+    d[0] = (*(double *) &a0) < (*(double *) &b0) ? a0 : b0;
+    d[1] = (*(double *) &a1) < (*(double *) &b1) ? a1 : b1;
+    return vreinterpretq_m128d_u64(vld1q_u64(d));
+#endif
+}
+
+// Compare the lower double-precision (64-bit) floating-point elements in a and
+// b, store the minimum value in the lower element of dst, and copy the upper
+// element from a to the upper element of dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_min_sd
+FORCE_INLINE __m128d _mm_min_sd(__m128d a, __m128d b)
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+    return _mm_move_sd(a, _mm_min_pd(a, b));
+#else
+    double *da = (double *) &a;
+    double *db = (double *) &b;
+    double c[2] = {da[0] < db[0] ? da[0] : db[0], da[1]};
+    return vreinterpretq_m128d_f32(vld1q_f32((float32_t *) c));
+#endif
+}
+
+// Copy the lower 64-bit integer in a to the lower element of dst, and zero the
+// upper element.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_move_epi64
+FORCE_INLINE __m128i _mm_move_epi64(__m128i a)
+{
+    return vreinterpretq_m128i_s64(
+        vsetq_lane_s64(0, vreinterpretq_s64_m128i(a), 1));
+}
+
+// Move the lower double-precision (64-bit) floating-point element from b to the
+// lower element of dst, and copy the upper element from a to the upper element
+// of dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_move_sd
+FORCE_INLINE __m128d _mm_move_sd(__m128d a, __m128d b)
+{
+    return vreinterpretq_m128d_f32(
+        vcombine_f32(vget_low_f32(vreinterpretq_f32_m128d(b)),
+                     vget_high_f32(vreinterpretq_f32_m128d(a))));
+}
+
+// Create mask from the most significant bit of each 8-bit element in a, and
+// store the result in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_movemask_epi8
+FORCE_INLINE int _mm_movemask_epi8(__m128i a)
+{
+    // Use increasingly wide shifts+adds to collect the sign bits
+    // together.
+    // Since the widening shifts would be rather confusing to follow in little
+    // endian, everything will be illustrated in big endian order instead. This
+    // has a different result - the bits would actually be reversed on a big
+    // endian machine.
+
+    // Starting input (only half the elements are shown):
+    // 89 ff 1d c0 00 10 99 33
+    uint8x16_t input = vreinterpretq_u8_m128i(a);
+
+    // Shift out everything but the sign bits with an unsigned shift right.
+    //
+    // Bytes of the vector::
+    // 89 ff 1d c0 00 10 99 33
+    // \  \  \  \  \  \  \  \    high_bits = (uint16x4_t)(input >> 7)
+    //  |  |  |  |  |  |  |  |
+    // 01 01 00 01 00 00 01 00
+    //
+    // Bits of first important lane(s):
+    // 10001001 (89)
+    // \______
+    //        |
+    // 00000001 (01)
+    uint16x8_t high_bits = vreinterpretq_u16_u8(vshrq_n_u8(input, 7));
+
+    // Merge the even lanes together with a 16-bit unsigned shift right + add.
+    // 'xx' represents garbage data which will be ignored in the final result.
+    // In the important bytes, the add functions like a binary OR.
+    //
+    // 01 01 00 01 00 00 01 00
+    //  \_ |  \_ |  \_ |  \_ |   paired16 = (uint32x4_t)(input + (input >> 7))
+    //    \|    \|    \|    \|
+    // xx 03 xx 01 xx 00 xx 02
+    //
+    // 00000001 00000001 (01 01)
+    //        \_______ |
+    //                \|
+    // xxxxxxxx xxxxxx11 (xx 03)
+    uint32x4_t paired16 =
+        vreinterpretq_u32_u16(vsraq_n_u16(high_bits, high_bits, 7));
+
+    // Repeat with a wider 32-bit shift + add.
+    // xx 03 xx 01 xx 00 xx 02
+    //     \____ |     \____ |  paired32 = (uint64x1_t)(paired16 + (paired16 >>
+    //     14))
+    //          \|          \|
+    // xx xx xx 0d xx xx xx 02
+    //
+    // 00000011 00000001 (03 01)
+    //        \\_____ ||
+    //         '----.\||
+    // xxxxxxxx xxxx1101 (xx 0d)
+    uint64x2_t paired32 =
+        vreinterpretq_u64_u32(vsraq_n_u32(paired16, paired16, 14));
+
+    // Last, an even wider 64-bit shift + add to get our result in the low 8 bit
+    // lanes. xx xx xx 0d xx xx xx 02
+    //            \_________ |   paired64 = (uint8x8_t)(paired32 + (paired32 >>
+    //            28))
+    //                      \|
+    // xx xx xx xx xx xx xx d2
+    //
+    // 00001101 00000010 (0d 02)
+    //     \   \___ |  |
+    //      '---.  \|  |
+    // xxxxxxxx 11010010 (xx d2)
+    uint8x16_t paired64 =
+        vreinterpretq_u8_u64(vsraq_n_u64(paired32, paired32, 28));
+
+    // Extract the low 8 bits from each 64-bit lane with 2 8-bit extracts.
+    // xx xx xx xx xx xx xx d2
+    //                      ||  return paired64[0]
+    //                      d2
+    // Note: Little endian would return the correct value 4b (01001011) instead.
+    return vgetq_lane_u8(paired64, 0) | ((int) vgetq_lane_u8(paired64, 8) << 8);
+}
+
+// Set each bit of mask dst based on the most significant bit of the
+// corresponding packed double-precision (64-bit) floating-point element in a.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_movemask_pd
+FORCE_INLINE int _mm_movemask_pd(__m128d a)
+{
+    uint64x2_t input = vreinterpretq_u64_m128d(a);
+    uint64x2_t high_bits = vshrq_n_u64(input, 63);
+    return (int) (vgetq_lane_u64(high_bits, 0) |
+                  (vgetq_lane_u64(high_bits, 1) << 1));
+}
+
+// Copy the lower 64-bit integer in a to dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_movepi64_pi64
+FORCE_INLINE __m64 _mm_movepi64_pi64(__m128i a)
+{
+    return vreinterpret_m64_s64(vget_low_s64(vreinterpretq_s64_m128i(a)));
+}
+
+// Copy the 64-bit integer a to the lower element of dst, and zero the upper
+// element.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_movpi64_epi64
+FORCE_INLINE __m128i _mm_movpi64_epi64(__m64 a)
+{
+    return vreinterpretq_m128i_s64(
+        vcombine_s64(vreinterpret_s64_m64(a), vdup_n_s64(0)));
+}
+
+// Multiply the low unsigned 32-bit integers from each packed 64-bit element in
+// a and b, and store the unsigned 64-bit results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mul_epu32
+FORCE_INLINE __m128i _mm_mul_epu32(__m128i a, __m128i b)
+{
+    // vmull_u32 upcasts instead of masking, so we downcast.
+    uint32x2_t a_lo = vmovn_u64(vreinterpretq_u64_m128i(a));
+    uint32x2_t b_lo = vmovn_u64(vreinterpretq_u64_m128i(b));
+    return vreinterpretq_m128i_u64(vmull_u32(a_lo, b_lo));
+}
+
+// Multiply packed double-precision (64-bit) floating-point elements in a and b,
+// and store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mul_pd
+FORCE_INLINE __m128d _mm_mul_pd(__m128d a, __m128d b)
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+    return vreinterpretq_m128d_f64(
+        vmulq_f64(vreinterpretq_f64_m128d(a), vreinterpretq_f64_m128d(b)));
+#else
+    double *da = (double *) &a;
+    double *db = (double *) &b;
+    double c[2];
+    c[0] = da[0] * db[0];
+    c[1] = da[1] * db[1];
+    return vld1q_f32((float32_t *) c);
+#endif
+}
+
+// Multiply the lower double-precision (64-bit) floating-point element in a and
+// b, store the result in the lower element of dst, and copy the upper element
+// from a to the upper element of dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=mm_mul_sd
+FORCE_INLINE __m128d _mm_mul_sd(__m128d a, __m128d b)
+{
+    return _mm_move_sd(a, _mm_mul_pd(a, b));
+}
+
+// Multiply the low unsigned 32-bit integers from a and b, and store the
+// unsigned 64-bit result in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mul_su32
+FORCE_INLINE __m64 _mm_mul_su32(__m64 a, __m64 b)
+{
+    return vreinterpret_m64_u64(vget_low_u64(
+        vmull_u32(vreinterpret_u32_m64(a), vreinterpret_u32_m64(b))));
+}
+
+// Multiply the packed signed 16-bit integers in a and b, producing intermediate
+// 32-bit integers, and store the high 16 bits of the intermediate integers in
+// dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mulhi_epi16
+FORCE_INLINE __m128i _mm_mulhi_epi16(__m128i a, __m128i b)
+{
+    /* FIXME: issue with large values because of result saturation */
+    // int16x8_t ret = vqdmulhq_s16(vreinterpretq_s16_m128i(a),
+    // vreinterpretq_s16_m128i(b)); /* =2*a*b */ return
+    // vreinterpretq_m128i_s16(vshrq_n_s16(ret, 1));
+    int16x4_t a3210 = vget_low_s16(vreinterpretq_s16_m128i(a));
+    int16x4_t b3210 = vget_low_s16(vreinterpretq_s16_m128i(b));
+    int32x4_t ab3210 = vmull_s16(a3210, b3210); /* 3333222211110000 */
+    int16x4_t a7654 = vget_high_s16(vreinterpretq_s16_m128i(a));
+    int16x4_t b7654 = vget_high_s16(vreinterpretq_s16_m128i(b));
+    int32x4_t ab7654 = vmull_s16(a7654, b7654); /* 7777666655554444 */
+    uint16x8x2_t r =
+        vuzpq_u16(vreinterpretq_u16_s32(ab3210), vreinterpretq_u16_s32(ab7654));
+    return vreinterpretq_m128i_u16(r.val[1]);
+}
+
+// Multiply the packed unsigned 16-bit integers in a and b, producing
+// intermediate 32-bit integers, and store the high 16 bits of the intermediate
+// integers in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mulhi_epu16
+FORCE_INLINE __m128i _mm_mulhi_epu16(__m128i a, __m128i b)
+{
+    uint16x4_t a3210 = vget_low_u16(vreinterpretq_u16_m128i(a));
+    uint16x4_t b3210 = vget_low_u16(vreinterpretq_u16_m128i(b));
+    uint32x4_t ab3210 = vmull_u16(a3210, b3210);
+#if defined(__aarch64__) || defined(_M_ARM64)
+    uint32x4_t ab7654 =
+        vmull_high_u16(vreinterpretq_u16_m128i(a), vreinterpretq_u16_m128i(b));
+    uint16x8_t r = vuzp2q_u16(vreinterpretq_u16_u32(ab3210),
+                              vreinterpretq_u16_u32(ab7654));
+    return vreinterpretq_m128i_u16(r);
+#else
+    uint16x4_t a7654 = vget_high_u16(vreinterpretq_u16_m128i(a));
+    uint16x4_t b7654 = vget_high_u16(vreinterpretq_u16_m128i(b));
+    uint32x4_t ab7654 = vmull_u16(a7654, b7654);
+    uint16x8x2_t r =
+        vuzpq_u16(vreinterpretq_u16_u32(ab3210), vreinterpretq_u16_u32(ab7654));
+    return vreinterpretq_m128i_u16(r.val[1]);
+#endif
+}
+
+// Multiply the packed 16-bit integers in a and b, producing intermediate 32-bit
+// integers, and store the low 16 bits of the intermediate integers in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mullo_epi16
+FORCE_INLINE __m128i _mm_mullo_epi16(__m128i a, __m128i b)
+{
+    return vreinterpretq_m128i_s16(
+        vmulq_s16(vreinterpretq_s16_m128i(a), vreinterpretq_s16_m128i(b)));
+}
+
+// Compute the bitwise OR of packed double-precision (64-bit) floating-point
+// elements in a and b, and store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=mm_or_pd
+FORCE_INLINE __m128d _mm_or_pd(__m128d a, __m128d b)
+{
+    return vreinterpretq_m128d_s64(
+        vorrq_s64(vreinterpretq_s64_m128d(a), vreinterpretq_s64_m128d(b)));
+}
+
+// Compute the bitwise OR of 128 bits (representing integer data) in a and b,
+// and store the result in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_or_si128
+FORCE_INLINE __m128i _mm_or_si128(__m128i a, __m128i b)
+{
+    return vreinterpretq_m128i_s32(
+        vorrq_s32(vreinterpretq_s32_m128i(a), vreinterpretq_s32_m128i(b)));
+}
+
+// Convert packed signed 16-bit integers from a and b to packed 8-bit integers
+// using signed saturation, and store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_packs_epi16
+FORCE_INLINE __m128i _mm_packs_epi16(__m128i a, __m128i b)
+{
+    return vreinterpretq_m128i_s8(
+        vcombine_s8(vqmovn_s16(vreinterpretq_s16_m128i(a)),
+                    vqmovn_s16(vreinterpretq_s16_m128i(b))));
+}
+
+// Convert packed signed 32-bit integers from a and b to packed 16-bit integers
+// using signed saturation, and store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_packs_epi32
+FORCE_INLINE __m128i _mm_packs_epi32(__m128i a, __m128i b)
+{
+    return vreinterpretq_m128i_s16(
+        vcombine_s16(vqmovn_s32(vreinterpretq_s32_m128i(a)),
+                     vqmovn_s32(vreinterpretq_s32_m128i(b))));
+}
+
+// Convert packed signed 16-bit integers from a and b to packed 8-bit integers
+// using unsigned saturation, and store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_packus_epi16
+FORCE_INLINE __m128i _mm_packus_epi16(const __m128i a, const __m128i b)
+{
+    return vreinterpretq_m128i_u8(
+        vcombine_u8(vqmovun_s16(vreinterpretq_s16_m128i(a)),
+                    vqmovun_s16(vreinterpretq_s16_m128i(b))));
+}
+
+// Pause the processor. This is typically used in spin-wait loops and depending
+// on the x86 processor typical values are in the 40-100 cycle range. The
+// 'yield' instruction isn't a good fit because it's effectively a nop on most
+// Arm cores. Experience with several databases has shown has shown an 'isb' is
+// a reasonable approximation.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_pause
+FORCE_INLINE void _mm_pause(void)
+{
+#if defined(_MSC_VER)
+    __isb(_ARM64_BARRIER_SY);
+#else
+    __asm__ __volatile__("isb\n");
+#endif
+}
+
+// Compute the absolute differences of packed unsigned 8-bit integers in a and
+// b, then horizontally sum each consecutive 8 differences to produce two
+// unsigned 16-bit integers, and pack these unsigned 16-bit integers in the low
+// 16 bits of 64-bit elements in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_sad_epu8
+FORCE_INLINE __m128i _mm_sad_epu8(__m128i a, __m128i b)
+{
+    uint16x8_t t = vpaddlq_u8(vabdq_u8((uint8x16_t) a, (uint8x16_t) b));
+    return vreinterpretq_m128i_u64(vpaddlq_u32(vpaddlq_u16(t)));
+}
+
+// Set packed 16-bit integers in dst with the supplied values.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_set_epi16
+FORCE_INLINE __m128i _mm_set_epi16(short i7,
+                                   short i6,
+                                   short i5,
+                                   short i4,
+                                   short i3,
+                                   short i2,
+                                   short i1,
+                                   short i0)
+{
+    int16_t ALIGN_STRUCT(16) data[8] = {i0, i1, i2, i3, i4, i5, i6, i7};
+    return vreinterpretq_m128i_s16(vld1q_s16(data));
+}
+
+// Set packed 32-bit integers in dst with the supplied values.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_set_epi32
+FORCE_INLINE __m128i _mm_set_epi32(int i3, int i2, int i1, int i0)
+{
+    int32_t ALIGN_STRUCT(16) data[4] = {i0, i1, i2, i3};
+    return vreinterpretq_m128i_s32(vld1q_s32(data));
+}
+
+// Set packed 64-bit integers in dst with the supplied values.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_set_epi64
+FORCE_INLINE __m128i _mm_set_epi64(__m64 i1, __m64 i2)
+{
+    return _mm_set_epi64x(vget_lane_s64(i1, 0), vget_lane_s64(i2, 0));
+}
+
+// Set packed 64-bit integers in dst with the supplied values.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_set_epi64x
+FORCE_INLINE __m128i _mm_set_epi64x(int64_t i1, int64_t i2)
+{
+    return vreinterpretq_m128i_s64(
+        vcombine_s64(vcreate_s64(i2), vcreate_s64(i1)));
+}
+
+// Set packed 8-bit integers in dst with the supplied values.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_set_epi8
+FORCE_INLINE __m128i _mm_set_epi8(signed char b15,
+                                  signed char b14,
+                                  signed char b13,
+                                  signed char b12,
+                                  signed char b11,
+                                  signed char b10,
+                                  signed char b9,
+                                  signed char b8,
+                                  signed char b7,
+                                  signed char b6,
+                                  signed char b5,
+                                  signed char b4,
+                                  signed char b3,
+                                  signed char b2,
+                                  signed char b1,
+                                  signed char b0)
+{
+    int8_t ALIGN_STRUCT(16)
+        data[16] = {(int8_t) b0,  (int8_t) b1,  (int8_t) b2,  (int8_t) b3,
+                    (int8_t) b4,  (int8_t) b5,  (int8_t) b6,  (int8_t) b7,
+                    (int8_t) b8,  (int8_t) b9,  (int8_t) b10, (int8_t) b11,
+                    (int8_t) b12, (int8_t) b13, (int8_t) b14, (int8_t) b15};
+    return (__m128i) vld1q_s8(data);
+}
+
+// Set packed double-precision (64-bit) floating-point elements in dst with the
+// supplied values.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_set_pd
+FORCE_INLINE __m128d _mm_set_pd(double e1, double e0)
+{
+    double ALIGN_STRUCT(16) data[2] = {e0, e1};
+#if defined(__aarch64__) || defined(_M_ARM64)
+    return vreinterpretq_m128d_f64(vld1q_f64((float64_t *) data));
+#else
+    return vreinterpretq_m128d_f32(vld1q_f32((float32_t *) data));
+#endif
+}
+
+// Broadcast double-precision (64-bit) floating-point value a to all elements of
+// dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_set_pd1
+#define _mm_set_pd1 _mm_set1_pd
+
+// Copy double-precision (64-bit) floating-point element a to the lower element
+// of dst, and zero the upper element.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_set_sd
+FORCE_INLINE __m128d _mm_set_sd(double a)
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+    return vreinterpretq_m128d_f64(vsetq_lane_f64(a, vdupq_n_f64(0), 0));
+#else
+    return _mm_set_pd(0, a);
+#endif
+}
+
+// Broadcast 16-bit integer a to all elements of dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_set1_epi16
+FORCE_INLINE __m128i _mm_set1_epi16(short w)
+{
+    return vreinterpretq_m128i_s16(vdupq_n_s16(w));
+}
+
+// Broadcast 32-bit integer a to all elements of dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_set1_epi32
+FORCE_INLINE __m128i _mm_set1_epi32(int _i)
+{
+    return vreinterpretq_m128i_s32(vdupq_n_s32(_i));
+}
+
+// Broadcast 64-bit integer a to all elements of dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_set1_epi64
+FORCE_INLINE __m128i _mm_set1_epi64(__m64 _i)
+{
+    return vreinterpretq_m128i_s64(vdupq_lane_s64(_i, 0));
+}
+
+// Broadcast 64-bit integer a to all elements of dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_set1_epi64x
+FORCE_INLINE __m128i _mm_set1_epi64x(int64_t _i)
+{
+    return vreinterpretq_m128i_s64(vdupq_n_s64(_i));
+}
+
+// Broadcast 8-bit integer a to all elements of dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_set1_epi8
+FORCE_INLINE __m128i _mm_set1_epi8(signed char w)
+{
+    return vreinterpretq_m128i_s8(vdupq_n_s8(w));
+}
+
+// Broadcast double-precision (64-bit) floating-point value a to all elements of
+// dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_set1_pd
+FORCE_INLINE __m128d _mm_set1_pd(double d)
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+    return vreinterpretq_m128d_f64(vdupq_n_f64(d));
+#else
+    return vreinterpretq_m128d_s64(vdupq_n_s64(*(int64_t *) &d));
+#endif
+}
+
+// Set packed 16-bit integers in dst with the supplied values in reverse order.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_setr_epi16
+FORCE_INLINE __m128i _mm_setr_epi16(short w0,
+                                    short w1,
+                                    short w2,
+                                    short w3,
+                                    short w4,
+                                    short w5,
+                                    short w6,
+                                    short w7)
+{
+    int16_t ALIGN_STRUCT(16) data[8] = {w0, w1, w2, w3, w4, w5, w6, w7};
+    return vreinterpretq_m128i_s16(vld1q_s16((int16_t *) data));
+}
+
+// Set packed 32-bit integers in dst with the supplied values in reverse order.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_setr_epi32
+FORCE_INLINE __m128i _mm_setr_epi32(int i3, int i2, int i1, int i0)
+{
+    int32_t ALIGN_STRUCT(16) data[4] = {i3, i2, i1, i0};
+    return vreinterpretq_m128i_s32(vld1q_s32(data));
+}
+
+// Set packed 64-bit integers in dst with the supplied values in reverse order.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_setr_epi64
+FORCE_INLINE __m128i _mm_setr_epi64(__m64 e1, __m64 e0)
+{
+    return vreinterpretq_m128i_s64(vcombine_s64(e1, e0));
+}
+
+// Set packed 8-bit integers in dst with the supplied values in reverse order.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_setr_epi8
+FORCE_INLINE __m128i _mm_setr_epi8(signed char b0,
+                                   signed char b1,
+                                   signed char b2,
+                                   signed char b3,
+                                   signed char b4,
+                                   signed char b5,
+                                   signed char b6,
+                                   signed char b7,
+                                   signed char b8,
+                                   signed char b9,
+                                   signed char b10,
+                                   signed char b11,
+                                   signed char b12,
+                                   signed char b13,
+                                   signed char b14,
+                                   signed char b15)
+{
+    int8_t ALIGN_STRUCT(16)
+        data[16] = {(int8_t) b0,  (int8_t) b1,  (int8_t) b2,  (int8_t) b3,
+                    (int8_t) b4,  (int8_t) b5,  (int8_t) b6,  (int8_t) b7,
+                    (int8_t) b8,  (int8_t) b9,  (int8_t) b10, (int8_t) b11,
+                    (int8_t) b12, (int8_t) b13, (int8_t) b14, (int8_t) b15};
+    return (__m128i) vld1q_s8(data);
+}
+
+// Set packed double-precision (64-bit) floating-point elements in dst with the
+// supplied values in reverse order.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_setr_pd
+FORCE_INLINE __m128d _mm_setr_pd(double e1, double e0)
+{
+    return _mm_set_pd(e0, e1);
+}
+
+// Return vector of type __m128d with all elements set to zero.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_setzero_pd
+FORCE_INLINE __m128d _mm_setzero_pd(void)
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+    return vreinterpretq_m128d_f64(vdupq_n_f64(0));
+#else
+    return vreinterpretq_m128d_f32(vdupq_n_f32(0));
+#endif
+}
+
+// Return vector of type __m128i with all elements set to zero.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_setzero_si128
+FORCE_INLINE __m128i _mm_setzero_si128(void)
+{
+    return vreinterpretq_m128i_s32(vdupq_n_s32(0));
+}
+
+// Shuffle 32-bit integers in a using the control in imm8, and store the results
+// in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_shuffle_epi32
+// FORCE_INLINE __m128i _mm_shuffle_epi32(__m128i a,
+//                                        __constrange(0,255) int imm)
+#if defined(_sse2neon_shuffle)
+#define _mm_shuffle_epi32(a, imm)                                            \
+    __extension__({                                                          \
+        int32x4_t _input = vreinterpretq_s32_m128i(a);                       \
+        int32x4_t _shuf =                                                    \
+            vshuffleq_s32(_input, _input, (imm) & (0x3), ((imm) >> 2) & 0x3, \
+                          ((imm) >> 4) & 0x3, ((imm) >> 6) & 0x3);           \
+        vreinterpretq_m128i_s32(_shuf);                                      \
+    })
+#else  // generic
+#define _mm_shuffle_epi32(a, imm)                           \
+    _sse2neon_define1(                                      \
+        __m128i, a, __m128i ret; switch (imm) {             \
+            case _MM_SHUFFLE(1, 0, 3, 2):                   \
+                ret = _mm_shuffle_epi_1032(_a);             \
+                break;                                      \
+            case _MM_SHUFFLE(2, 3, 0, 1):                   \
+                ret = _mm_shuffle_epi_2301(_a);             \
+                break;                                      \
+            case _MM_SHUFFLE(0, 3, 2, 1):                   \
+                ret = _mm_shuffle_epi_0321(_a);             \
+                break;                                      \
+            case _MM_SHUFFLE(2, 1, 0, 3):                   \
+                ret = _mm_shuffle_epi_2103(_a);             \
+                break;                                      \
+            case _MM_SHUFFLE(1, 0, 1, 0):                   \
+                ret = _mm_shuffle_epi_1010(_a);             \
+                break;                                      \
+            case _MM_SHUFFLE(1, 0, 0, 1):                   \
+                ret = _mm_shuffle_epi_1001(_a);             \
+                break;                                      \
+            case _MM_SHUFFLE(0, 1, 0, 1):                   \
+                ret = _mm_shuffle_epi_0101(_a);             \
+                break;                                      \
+            case _MM_SHUFFLE(2, 2, 1, 1):                   \
+                ret = _mm_shuffle_epi_2211(_a);             \
+                break;                                      \
+            case _MM_SHUFFLE(0, 1, 2, 2):                   \
+                ret = _mm_shuffle_epi_0122(_a);             \
+                break;                                      \
+            case _MM_SHUFFLE(3, 3, 3, 2):                   \
+                ret = _mm_shuffle_epi_3332(_a);             \
+                break;                                      \
+            case _MM_SHUFFLE(0, 0, 0, 0):                   \
+                ret = _mm_shuffle_epi32_splat(_a, 0);       \
+                break;                                      \
+            case _MM_SHUFFLE(1, 1, 1, 1):                   \
+                ret = _mm_shuffle_epi32_splat(_a, 1);       \
+                break;                                      \
+            case _MM_SHUFFLE(2, 2, 2, 2):                   \
+                ret = _mm_shuffle_epi32_splat(_a, 2);       \
+                break;                                      \
+            case _MM_SHUFFLE(3, 3, 3, 3):                   \
+                ret = _mm_shuffle_epi32_splat(_a, 3);       \
+                break;                                      \
+            default:                                        \
+                ret = _mm_shuffle_epi32_default(_a, (imm)); \
+                break;                                      \
+        } _sse2neon_return(ret);)
+#endif
+
+// Shuffle double-precision (64-bit) floating-point elements using the control
+// in imm8, and store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_shuffle_pd
+#ifdef _sse2neon_shuffle
+#define _mm_shuffle_pd(a, b, imm8)                                            \
+    vreinterpretq_m128d_s64(                                                  \
+        vshuffleq_s64(vreinterpretq_s64_m128d(a), vreinterpretq_s64_m128d(b), \
+                      imm8 & 0x1, ((imm8 & 0x2) >> 1) + 2))
+#else
+#define _mm_shuffle_pd(a, b, imm8)                                     \
+    _mm_castsi128_pd(_mm_set_epi64x(                                   \
+        vgetq_lane_s64(vreinterpretq_s64_m128d(b), (imm8 & 0x2) >> 1), \
+        vgetq_lane_s64(vreinterpretq_s64_m128d(a), imm8 & 0x1)))
+#endif
+
+// FORCE_INLINE __m128i _mm_shufflehi_epi16(__m128i a,
+//                                          __constrange(0,255) int imm)
+#if defined(_sse2neon_shuffle)
+#define _mm_shufflehi_epi16(a, imm)                                           \
+    __extension__({                                                           \
+        int16x8_t _input = vreinterpretq_s16_m128i(a);                        \
+        int16x8_t _shuf =                                                     \
+            vshuffleq_s16(_input, _input, 0, 1, 2, 3, ((imm) & (0x3)) + 4,    \
+                          (((imm) >> 2) & 0x3) + 4, (((imm) >> 4) & 0x3) + 4, \
+                          (((imm) >> 6) & 0x3) + 4);                          \
+        vreinterpretq_m128i_s16(_shuf);                                       \
+    })
+#else  // generic
+#define _mm_shufflehi_epi16(a, imm) _mm_shufflehi_epi16_function((a), (imm))
+#endif
+
+// FORCE_INLINE __m128i _mm_shufflelo_epi16(__m128i a,
+//                                          __constrange(0,255) int imm)
+#if defined(_sse2neon_shuffle)
+#define _mm_shufflelo_epi16(a, imm)                                  \
+    __extension__({                                                  \
+        int16x8_t _input = vreinterpretq_s16_m128i(a);               \
+        int16x8_t _shuf = vshuffleq_s16(                             \
+            _input, _input, ((imm) & (0x3)), (((imm) >> 2) & 0x3),   \
+            (((imm) >> 4) & 0x3), (((imm) >> 6) & 0x3), 4, 5, 6, 7); \
+        vreinterpretq_m128i_s16(_shuf);                              \
+    })
+#else  // generic
+#define _mm_shufflelo_epi16(a, imm) _mm_shufflelo_epi16_function((a), (imm))
+#endif
+
+// Shift packed 16-bit integers in a left by count while shifting in zeros, and
+// store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_sll_epi16
+FORCE_INLINE __m128i _mm_sll_epi16(__m128i a, __m128i count)
+{
+    uint64_t c = vreinterpretq_nth_u64_m128i(count, 0);
+    if (_sse2neon_unlikely(c & ~15))
+        return _mm_setzero_si128();
+
+    int16x8_t vc = vdupq_n_s16((int16_t) c);
+    return vreinterpretq_m128i_s16(vshlq_s16(vreinterpretq_s16_m128i(a), vc));
+}
+
+// Shift packed 32-bit integers in a left by count while shifting in zeros, and
+// store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_sll_epi32
+FORCE_INLINE __m128i _mm_sll_epi32(__m128i a, __m128i count)
+{
+    uint64_t c = vreinterpretq_nth_u64_m128i(count, 0);
+    if (_sse2neon_unlikely(c & ~31))
+        return _mm_setzero_si128();
+
+    int32x4_t vc = vdupq_n_s32((int32_t) c);
+    return vreinterpretq_m128i_s32(vshlq_s32(vreinterpretq_s32_m128i(a), vc));
+}
+
+// Shift packed 64-bit integers in a left by count while shifting in zeros, and
+// store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_sll_epi64
+FORCE_INLINE __m128i _mm_sll_epi64(__m128i a, __m128i count)
+{
+    uint64_t c = vreinterpretq_nth_u64_m128i(count, 0);
+    if (_sse2neon_unlikely(c & ~63))
+        return _mm_setzero_si128();
+
+    int64x2_t vc = vdupq_n_s64((int64_t) c);
+    return vreinterpretq_m128i_s64(vshlq_s64(vreinterpretq_s64_m128i(a), vc));
+}
+
+// Shift packed 16-bit integers in a left by imm8 while shifting in zeros, and
+// store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_slli_epi16
+FORCE_INLINE __m128i _mm_slli_epi16(__m128i a, int imm)
+{
+    if (_sse2neon_unlikely(imm & ~15))
+        return _mm_setzero_si128();
+    return vreinterpretq_m128i_s16(
+        vshlq_s16(vreinterpretq_s16_m128i(a), vdupq_n_s16(imm)));
+}
+
+// Shift packed 32-bit integers in a left by imm8 while shifting in zeros, and
+// store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_slli_epi32
+FORCE_INLINE __m128i _mm_slli_epi32(__m128i a, int imm)
+{
+    if (_sse2neon_unlikely(imm & ~31))
+        return _mm_setzero_si128();
+    return vreinterpretq_m128i_s32(
+        vshlq_s32(vreinterpretq_s32_m128i(a), vdupq_n_s32(imm)));
+}
+
+// Shift packed 64-bit integers in a left by imm8 while shifting in zeros, and
+// store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_slli_epi64
+FORCE_INLINE __m128i _mm_slli_epi64(__m128i a, int imm)
+{
+    if (_sse2neon_unlikely(imm & ~63))
+        return _mm_setzero_si128();
+    return vreinterpretq_m128i_s64(
+        vshlq_s64(vreinterpretq_s64_m128i(a), vdupq_n_s64(imm)));
+}
+
+// Shift a left by imm8 bytes while shifting in zeros, and store the results in
+// dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_slli_si128
+#define _mm_slli_si128(a, imm)                                              \
+    _sse2neon_define1(                                                      \
+        __m128i, a, int8x16_t ret;                                          \
+        if (_sse2neon_unlikely(imm == 0)) ret = vreinterpretq_s8_m128i(_a); \
+        else if (_sse2neon_unlikely((imm) & ~15)) ret = vdupq_n_s8(0);      \
+        else ret = vextq_s8(vdupq_n_s8(0), vreinterpretq_s8_m128i(_a),      \
+                            ((imm <= 0 || imm > 15) ? 0 : (16 - imm)));     \
+        _sse2neon_return(vreinterpretq_m128i_s8(ret));)
+
+// Compute the square root of packed double-precision (64-bit) floating-point
+// elements in a, and store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_sqrt_pd
+FORCE_INLINE __m128d _mm_sqrt_pd(__m128d a)
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+    return vreinterpretq_m128d_f64(vsqrtq_f64(vreinterpretq_f64_m128d(a)));
+#else
+    double a0 = sqrt(((double *) &a)[0]);
+    double a1 = sqrt(((double *) &a)[1]);
+    return _mm_set_pd(a1, a0);
+#endif
+}
+
+// Compute the square root of the lower double-precision (64-bit) floating-point
+// element in b, store the result in the lower element of dst, and copy the
+// upper element from a to the upper element of dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_sqrt_sd
+FORCE_INLINE __m128d _mm_sqrt_sd(__m128d a, __m128d b)
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+    return _mm_move_sd(a, _mm_sqrt_pd(b));
+#else
+    return _mm_set_pd(((double *) &a)[1], sqrt(((double *) &b)[0]));
+#endif
+}
+
+// Shift packed 16-bit integers in a right by count while shifting in sign bits,
+// and store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_sra_epi16
+FORCE_INLINE __m128i _mm_sra_epi16(__m128i a, __m128i count)
+{
+    int64_t c = vgetq_lane_s64(count, 0);
+    if (_sse2neon_unlikely(c & ~15))
+        return _mm_cmplt_epi16(a, _mm_setzero_si128());
+    return vreinterpretq_m128i_s16(
+        vshlq_s16((int16x8_t) a, vdupq_n_s16((int) -c)));
+}
+
+// Shift packed 32-bit integers in a right by count while shifting in sign bits,
+// and store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_sra_epi32
+FORCE_INLINE __m128i _mm_sra_epi32(__m128i a, __m128i count)
+{
+    int64_t c = vgetq_lane_s64(count, 0);
+    if (_sse2neon_unlikely(c & ~31))
+        return _mm_cmplt_epi32(a, _mm_setzero_si128());
+    return vreinterpretq_m128i_s32(
+        vshlq_s32((int32x4_t) a, vdupq_n_s32((int) -c)));
+}
+
+// Shift packed 16-bit integers in a right by imm8 while shifting in sign
+// bits, and store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_srai_epi16
+FORCE_INLINE __m128i _mm_srai_epi16(__m128i a, int imm)
+{
+    const int count = (imm & ~15) ? 15 : imm;
+    return (__m128i) vshlq_s16((int16x8_t) a, vdupq_n_s16(-count));
+}
+
+// Shift packed 32-bit integers in a right by imm8 while shifting in sign bits,
+// and store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_srai_epi32
+// FORCE_INLINE __m128i _mm_srai_epi32(__m128i a, __constrange(0,255) int imm)
+#define _mm_srai_epi32(a, imm)                                                \
+    _sse2neon_define0(                                                        \
+        __m128i, a, __m128i ret; if (_sse2neon_unlikely((imm) == 0)) {        \
+            ret = _a;                                                         \
+        } else if (_sse2neon_likely(0 < (imm) && (imm) < 32)) {               \
+            ret = vreinterpretq_m128i_s32(                                    \
+                vshlq_s32(vreinterpretq_s32_m128i(_a), vdupq_n_s32(-(imm)))); \
+        } else {                                                              \
+            ret = vreinterpretq_m128i_s32(                                    \
+                vshrq_n_s32(vreinterpretq_s32_m128i(_a), 31));                \
+        } _sse2neon_return(ret);)
+
+// Shift packed 16-bit integers in a right by count while shifting in zeros, and
+// store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_srl_epi16
+FORCE_INLINE __m128i _mm_srl_epi16(__m128i a, __m128i count)
+{
+    uint64_t c = vreinterpretq_nth_u64_m128i(count, 0);
+    if (_sse2neon_unlikely(c & ~15))
+        return _mm_setzero_si128();
+
+    int16x8_t vc = vdupq_n_s16(-(int16_t) c);
+    return vreinterpretq_m128i_u16(vshlq_u16(vreinterpretq_u16_m128i(a), vc));
+}
+
+// Shift packed 32-bit integers in a right by count while shifting in zeros, and
+// store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_srl_epi32
+FORCE_INLINE __m128i _mm_srl_epi32(__m128i a, __m128i count)
+{
+    uint64_t c = vreinterpretq_nth_u64_m128i(count, 0);
+    if (_sse2neon_unlikely(c & ~31))
+        return _mm_setzero_si128();
+
+    int32x4_t vc = vdupq_n_s32(-(int32_t) c);
+    return vreinterpretq_m128i_u32(vshlq_u32(vreinterpretq_u32_m128i(a), vc));
+}
+
+// Shift packed 64-bit integers in a right by count while shifting in zeros, and
+// store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_srl_epi64
+FORCE_INLINE __m128i _mm_srl_epi64(__m128i a, __m128i count)
+{
+    uint64_t c = vreinterpretq_nth_u64_m128i(count, 0);
+    if (_sse2neon_unlikely(c & ~63))
+        return _mm_setzero_si128();
+
+    int64x2_t vc = vdupq_n_s64(-(int64_t) c);
+    return vreinterpretq_m128i_u64(vshlq_u64(vreinterpretq_u64_m128i(a), vc));
+}
+
+// Shift packed 16-bit integers in a right by imm8 while shifting in zeros, and
+// store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_srli_epi16
+#define _mm_srli_epi16(a, imm)                                                \
+    _sse2neon_define0(                                                        \
+        __m128i, a, __m128i ret; if (_sse2neon_unlikely((imm) & ~15)) {       \
+            ret = _mm_setzero_si128();                                        \
+        } else {                                                              \
+            ret = vreinterpretq_m128i_u16(                                    \
+                vshlq_u16(vreinterpretq_u16_m128i(_a), vdupq_n_s16(-(imm)))); \
+        } _sse2neon_return(ret);)
+
+// Shift packed 32-bit integers in a right by imm8 while shifting in zeros, and
+// store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_srli_epi32
+// FORCE_INLINE __m128i _mm_srli_epi32(__m128i a, __constrange(0,255) int imm)
+#define _mm_srli_epi32(a, imm)                                                \
+    _sse2neon_define0(                                                        \
+        __m128i, a, __m128i ret; if (_sse2neon_unlikely((imm) & ~31)) {       \
+            ret = _mm_setzero_si128();                                        \
+        } else {                                                              \
+            ret = vreinterpretq_m128i_u32(                                    \
+                vshlq_u32(vreinterpretq_u32_m128i(_a), vdupq_n_s32(-(imm)))); \
+        } _sse2neon_return(ret);)
+
+// Shift packed 64-bit integers in a right by imm8 while shifting in zeros, and
+// store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_srli_epi64
+#define _mm_srli_epi64(a, imm)                                                \
+    _sse2neon_define0(                                                        \
+        __m128i, a, __m128i ret; if (_sse2neon_unlikely((imm) & ~63)) {       \
+            ret = _mm_setzero_si128();                                        \
+        } else {                                                              \
+            ret = vreinterpretq_m128i_u64(                                    \
+                vshlq_u64(vreinterpretq_u64_m128i(_a), vdupq_n_s64(-(imm)))); \
+        } _sse2neon_return(ret);)
+
+// Shift a right by imm8 bytes while shifting in zeros, and store the results in
+// dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_srli_si128
+#define _mm_srli_si128(a, imm)                                         \
+    _sse2neon_define1(                                                 \
+        __m128i, a, int8x16_t ret;                                     \
+        if (_sse2neon_unlikely((imm) & ~15)) ret = vdupq_n_s8(0);      \
+        else ret = vextq_s8(vreinterpretq_s8_m128i(_a), vdupq_n_s8(0), \
+                            (imm > 15 ? 0 : imm));                     \
+        _sse2neon_return(vreinterpretq_m128i_s8(ret));)
+
+// Store 128-bits (composed of 2 packed double-precision (64-bit) floating-point
+// elements) from a into memory. mem_addr must be aligned on a 16-byte boundary
+// or a general-protection exception may be generated.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_store_pd
+FORCE_INLINE void _mm_store_pd(double *mem_addr, __m128d a)
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+    vst1q_f64((float64_t *) mem_addr, vreinterpretq_f64_m128d(a));
+#else
+    vst1q_f32((float32_t *) mem_addr, vreinterpretq_f32_m128d(a));
+#endif
+}
+
+// Store the lower double-precision (64-bit) floating-point element from a into
+// 2 contiguous elements in memory. mem_addr must be aligned on a 16-byte
+// boundary or a general-protection exception may be generated.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_store_pd1
+FORCE_INLINE void _mm_store_pd1(double *mem_addr, __m128d a)
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+    float64x1_t a_low = vget_low_f64(vreinterpretq_f64_m128d(a));
+    vst1q_f64((float64_t *) mem_addr,
+              vreinterpretq_f64_m128d(vcombine_f64(a_low, a_low)));
+#else
+    float32x2_t a_low = vget_low_f32(vreinterpretq_f32_m128d(a));
+    vst1q_f32((float32_t *) mem_addr,
+              vreinterpretq_f32_m128d(vcombine_f32(a_low, a_low)));
+#endif
+}
+
+// Store the lower double-precision (64-bit) floating-point element from a into
+// memory. mem_addr does not need to be aligned on any particular boundary.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=mm_store_sd
+FORCE_INLINE void _mm_store_sd(double *mem_addr, __m128d a)
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+    vst1_f64((float64_t *) mem_addr, vget_low_f64(vreinterpretq_f64_m128d(a)));
+#else
+    vst1_u64((uint64_t *) mem_addr, vget_low_u64(vreinterpretq_u64_m128d(a)));
+#endif
+}
+
+// Store 128-bits of integer data from a into memory. mem_addr must be aligned
+// on a 16-byte boundary or a general-protection exception may be generated.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_store_si128
+FORCE_INLINE void _mm_store_si128(__m128i *p, __m128i a)
+{
+    vst1q_s32((int32_t *) p, vreinterpretq_s32_m128i(a));
+}
+
+// Store the lower double-precision (64-bit) floating-point element from a into
+// 2 contiguous elements in memory. mem_addr must be aligned on a 16-byte
+// boundary or a general-protection exception may be generated.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#expand=9,526,5601&text=_mm_store1_pd
+#define _mm_store1_pd _mm_store_pd1
+
+// Store the upper double-precision (64-bit) floating-point element from a into
+// memory.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_storeh_pd
+FORCE_INLINE void _mm_storeh_pd(double *mem_addr, __m128d a)
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+    vst1_f64((float64_t *) mem_addr, vget_high_f64(vreinterpretq_f64_m128d(a)));
+#else
+    vst1_f32((float32_t *) mem_addr, vget_high_f32(vreinterpretq_f32_m128d(a)));
+#endif
+}
+
+// Store 64-bit integer from the first element of a into memory.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_storel_epi64
+FORCE_INLINE void _mm_storel_epi64(__m128i *a, __m128i b)
+{
+    vst1_u64((uint64_t *) a, vget_low_u64(vreinterpretq_u64_m128i(b)));
+}
+
+// Store the lower double-precision (64-bit) floating-point element from a into
+// memory.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_storel_pd
+FORCE_INLINE void _mm_storel_pd(double *mem_addr, __m128d a)
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+    vst1_f64((float64_t *) mem_addr, vget_low_f64(vreinterpretq_f64_m128d(a)));
+#else
+    vst1_f32((float32_t *) mem_addr, vget_low_f32(vreinterpretq_f32_m128d(a)));
+#endif
+}
+
+// Store 2 double-precision (64-bit) floating-point elements from a into memory
+// in reverse order. mem_addr must be aligned on a 16-byte boundary or a
+// general-protection exception may be generated.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_storer_pd
+FORCE_INLINE void _mm_storer_pd(double *mem_addr, __m128d a)
+{
+    float32x4_t f = vreinterpretq_f32_m128d(a);
+    _mm_store_pd(mem_addr, vreinterpretq_m128d_f32(vextq_f32(f, f, 2)));
+}
+
+// Store 128-bits (composed of 2 packed double-precision (64-bit) floating-point
+// elements) from a into memory. mem_addr does not need to be aligned on any
+// particular boundary.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_storeu_pd
+FORCE_INLINE void _mm_storeu_pd(double *mem_addr, __m128d a)
+{
+    _mm_store_pd(mem_addr, a);
+}
+
+// Store 128-bits of integer data from a into memory. mem_addr does not need to
+// be aligned on any particular boundary.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_storeu_si128
+FORCE_INLINE void _mm_storeu_si128(__m128i *p, __m128i a)
+{
+    vst1q_s32((int32_t *) p, vreinterpretq_s32_m128i(a));
+}
+
+// Store 32-bit integer from the first element of a into memory. mem_addr does
+// not need to be aligned on any particular boundary.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_storeu_si32
+FORCE_INLINE void _mm_storeu_si32(void *p, __m128i a)
+{
+    vst1q_lane_s32((int32_t *) p, vreinterpretq_s32_m128i(a), 0);
+}
+
+// Store 128-bits (composed of 2 packed double-precision (64-bit) floating-point
+// elements) from a into memory using a non-temporal memory hint. mem_addr must
+// be aligned on a 16-byte boundary or a general-protection exception may be
+// generated.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_stream_pd
+FORCE_INLINE void _mm_stream_pd(double *p, __m128d a)
+{
+#if __has_builtin(__builtin_nontemporal_store)
+    __builtin_nontemporal_store(a, (__m128d *) p);
+#elif defined(__aarch64__) || defined(_M_ARM64)
+    vst1q_f64(p, vreinterpretq_f64_m128d(a));
+#else
+    vst1q_s64((int64_t *) p, vreinterpretq_s64_m128d(a));
+#endif
+}
+
+// Store 128-bits of integer data from a into memory using a non-temporal memory
+// hint. mem_addr must be aligned on a 16-byte boundary or a general-protection
+// exception may be generated.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_stream_si128
+FORCE_INLINE void _mm_stream_si128(__m128i *p, __m128i a)
+{
+#if __has_builtin(__builtin_nontemporal_store)
+    __builtin_nontemporal_store(a, p);
+#else
+    vst1q_s64((int64_t *) p, vreinterpretq_s64_m128i(a));
+#endif
+}
+
+// Store 32-bit integer a into memory using a non-temporal hint to minimize
+// cache pollution. If the cache line containing address mem_addr is already in
+// the cache, the cache will be updated.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_stream_si32
+FORCE_INLINE void _mm_stream_si32(int *p, int a)
+{
+    vst1q_lane_s32((int32_t *) p, vdupq_n_s32(a), 0);
+}
+
+// Store 64-bit integer a into memory using a non-temporal hint to minimize
+// cache pollution. If the cache line containing address mem_addr is already in
+// the cache, the cache will be updated.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_stream_si64
+FORCE_INLINE void _mm_stream_si64(__int64 *p, __int64 a)
+{
+    vst1_s64((int64_t *) p, vdup_n_s64((int64_t) a));
+}
+
+// Subtract packed 16-bit integers in b from packed 16-bit integers in a, and
+// store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_sub_epi16
+FORCE_INLINE __m128i _mm_sub_epi16(__m128i a, __m128i b)
+{
+    return vreinterpretq_m128i_s16(
+        vsubq_s16(vreinterpretq_s16_m128i(a), vreinterpretq_s16_m128i(b)));
+}
+
+// Subtract packed 32-bit integers in b from packed 32-bit integers in a, and
+// store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_sub_epi32
+FORCE_INLINE __m128i _mm_sub_epi32(__m128i a, __m128i b)
+{
+    return vreinterpretq_m128i_s32(
+        vsubq_s32(vreinterpretq_s32_m128i(a), vreinterpretq_s32_m128i(b)));
+}
+
+// Subtract packed 64-bit integers in b from packed 64-bit integers in a, and
+// store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_sub_epi64
+FORCE_INLINE __m128i _mm_sub_epi64(__m128i a, __m128i b)
+{
+    return vreinterpretq_m128i_s64(
+        vsubq_s64(vreinterpretq_s64_m128i(a), vreinterpretq_s64_m128i(b)));
+}
+
+// Subtract packed 8-bit integers in b from packed 8-bit integers in a, and
+// store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_sub_epi8
+FORCE_INLINE __m128i _mm_sub_epi8(__m128i a, __m128i b)
+{
+    return vreinterpretq_m128i_s8(
+        vsubq_s8(vreinterpretq_s8_m128i(a), vreinterpretq_s8_m128i(b)));
+}
+
+// Subtract packed double-precision (64-bit) floating-point elements in b from
+// packed double-precision (64-bit) floating-point elements in a, and store the
+// results in dst.
+//  https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=mm_sub_pd
+FORCE_INLINE __m128d _mm_sub_pd(__m128d a, __m128d b)
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+    return vreinterpretq_m128d_f64(
+        vsubq_f64(vreinterpretq_f64_m128d(a), vreinterpretq_f64_m128d(b)));
+#else
+    double *da = (double *) &a;
+    double *db = (double *) &b;
+    double c[2];
+    c[0] = da[0] - db[0];
+    c[1] = da[1] - db[1];
+    return vld1q_f32((float32_t *) c);
+#endif
+}
+
+// Subtract the lower double-precision (64-bit) floating-point element in b from
+// the lower double-precision (64-bit) floating-point element in a, store the
+// result in the lower element of dst, and copy the upper element from a to the
+// upper element of dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_sub_sd
+FORCE_INLINE __m128d _mm_sub_sd(__m128d a, __m128d b)
+{
+    return _mm_move_sd(a, _mm_sub_pd(a, b));
+}
+
+// Subtract 64-bit integer b from 64-bit integer a, and store the result in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_sub_si64
+FORCE_INLINE __m64 _mm_sub_si64(__m64 a, __m64 b)
+{
+    return vreinterpret_m64_s64(
+        vsub_s64(vreinterpret_s64_m64(a), vreinterpret_s64_m64(b)));
+}
+
+// Subtract packed signed 16-bit integers in b from packed 16-bit integers in a
+// using saturation, and store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_subs_epi16
+FORCE_INLINE __m128i _mm_subs_epi16(__m128i a, __m128i b)
+{
+    return vreinterpretq_m128i_s16(
+        vqsubq_s16(vreinterpretq_s16_m128i(a), vreinterpretq_s16_m128i(b)));
+}
+
+// Subtract packed signed 8-bit integers in b from packed 8-bit integers in a
+// using saturation, and store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_subs_epi8
+FORCE_INLINE __m128i _mm_subs_epi8(__m128i a, __m128i b)
+{
+    return vreinterpretq_m128i_s8(
+        vqsubq_s8(vreinterpretq_s8_m128i(a), vreinterpretq_s8_m128i(b)));
+}
+
+// Subtract packed unsigned 16-bit integers in b from packed unsigned 16-bit
+// integers in a using saturation, and store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_subs_epu16
+FORCE_INLINE __m128i _mm_subs_epu16(__m128i a, __m128i b)
+{
+    return vreinterpretq_m128i_u16(
+        vqsubq_u16(vreinterpretq_u16_m128i(a), vreinterpretq_u16_m128i(b)));
+}
+
+// Subtract packed unsigned 8-bit integers in b from packed unsigned 8-bit
+// integers in a using saturation, and store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_subs_epu8
+FORCE_INLINE __m128i _mm_subs_epu8(__m128i a, __m128i b)
+{
+    return vreinterpretq_m128i_u8(
+        vqsubq_u8(vreinterpretq_u8_m128i(a), vreinterpretq_u8_m128i(b)));
+}
+
+#define _mm_ucomieq_sd _mm_comieq_sd
+#define _mm_ucomige_sd _mm_comige_sd
+#define _mm_ucomigt_sd _mm_comigt_sd
+#define _mm_ucomile_sd _mm_comile_sd
+#define _mm_ucomilt_sd _mm_comilt_sd
+#define _mm_ucomineq_sd _mm_comineq_sd
+
+// Return vector of type __m128d with undefined elements.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_undefined_pd
+FORCE_INLINE __m128d _mm_undefined_pd(void)
+{
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wuninitialized"
+#endif
+    __m128d a;
+#if defined(_MSC_VER)
+    a = _mm_setzero_pd();
+#endif
+    return a;
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+}
+
+// Unpack and interleave 16-bit integers from the high half of a and b, and
+// store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_unpackhi_epi16
+FORCE_INLINE __m128i _mm_unpackhi_epi16(__m128i a, __m128i b)
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+    return vreinterpretq_m128i_s16(
+        vzip2q_s16(vreinterpretq_s16_m128i(a), vreinterpretq_s16_m128i(b)));
+#else
+    int16x4_t a1 = vget_high_s16(vreinterpretq_s16_m128i(a));
+    int16x4_t b1 = vget_high_s16(vreinterpretq_s16_m128i(b));
+    int16x4x2_t result = vzip_s16(a1, b1);
+    return vreinterpretq_m128i_s16(vcombine_s16(result.val[0], result.val[1]));
+#endif
+}
+
+// Unpack and interleave 32-bit integers from the high half of a and b, and
+// store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_unpackhi_epi32
+FORCE_INLINE __m128i _mm_unpackhi_epi32(__m128i a, __m128i b)
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+    return vreinterpretq_m128i_s32(
+        vzip2q_s32(vreinterpretq_s32_m128i(a), vreinterpretq_s32_m128i(b)));
+#else
+    int32x2_t a1 = vget_high_s32(vreinterpretq_s32_m128i(a));
+    int32x2_t b1 = vget_high_s32(vreinterpretq_s32_m128i(b));
+    int32x2x2_t result = vzip_s32(a1, b1);
+    return vreinterpretq_m128i_s32(vcombine_s32(result.val[0], result.val[1]));
+#endif
+}
+
+// Unpack and interleave 64-bit integers from the high half of a and b, and
+// store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_unpackhi_epi64
+FORCE_INLINE __m128i _mm_unpackhi_epi64(__m128i a, __m128i b)
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+    return vreinterpretq_m128i_s64(
+        vzip2q_s64(vreinterpretq_s64_m128i(a), vreinterpretq_s64_m128i(b)));
+#else
+    int64x1_t a_h = vget_high_s64(vreinterpretq_s64_m128i(a));
+    int64x1_t b_h = vget_high_s64(vreinterpretq_s64_m128i(b));
+    return vreinterpretq_m128i_s64(vcombine_s64(a_h, b_h));
+#endif
+}
+
+// Unpack and interleave 8-bit integers from the high half of a and b, and store
+// the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_unpackhi_epi8
+FORCE_INLINE __m128i _mm_unpackhi_epi8(__m128i a, __m128i b)
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+    return vreinterpretq_m128i_s8(
+        vzip2q_s8(vreinterpretq_s8_m128i(a), vreinterpretq_s8_m128i(b)));
+#else
+    int8x8_t a1 =
+        vreinterpret_s8_s16(vget_high_s16(vreinterpretq_s16_m128i(a)));
+    int8x8_t b1 =
+        vreinterpret_s8_s16(vget_high_s16(vreinterpretq_s16_m128i(b)));
+    int8x8x2_t result = vzip_s8(a1, b1);
+    return vreinterpretq_m128i_s8(vcombine_s8(result.val[0], result.val[1]));
+#endif
+}
+
+// Unpack and interleave double-precision (64-bit) floating-point elements from
+// the high half of a and b, and store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_unpackhi_pd
+FORCE_INLINE __m128d _mm_unpackhi_pd(__m128d a, __m128d b)
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+    return vreinterpretq_m128d_f64(
+        vzip2q_f64(vreinterpretq_f64_m128d(a), vreinterpretq_f64_m128d(b)));
+#else
+    return vreinterpretq_m128d_s64(
+        vcombine_s64(vget_high_s64(vreinterpretq_s64_m128d(a)),
+                     vget_high_s64(vreinterpretq_s64_m128d(b))));
+#endif
+}
+
+// Unpack and interleave 16-bit integers from the low half of a and b, and store
+// the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_unpacklo_epi16
+FORCE_INLINE __m128i _mm_unpacklo_epi16(__m128i a, __m128i b)
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+    return vreinterpretq_m128i_s16(
+        vzip1q_s16(vreinterpretq_s16_m128i(a), vreinterpretq_s16_m128i(b)));
+#else
+    int16x4_t a1 = vget_low_s16(vreinterpretq_s16_m128i(a));
+    int16x4_t b1 = vget_low_s16(vreinterpretq_s16_m128i(b));
+    int16x4x2_t result = vzip_s16(a1, b1);
+    return vreinterpretq_m128i_s16(vcombine_s16(result.val[0], result.val[1]));
+#endif
+}
+
+// Unpack and interleave 32-bit integers from the low half of a and b, and store
+// the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_unpacklo_epi32
+FORCE_INLINE __m128i _mm_unpacklo_epi32(__m128i a, __m128i b)
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+    return vreinterpretq_m128i_s32(
+        vzip1q_s32(vreinterpretq_s32_m128i(a), vreinterpretq_s32_m128i(b)));
+#else
+    int32x2_t a1 = vget_low_s32(vreinterpretq_s32_m128i(a));
+    int32x2_t b1 = vget_low_s32(vreinterpretq_s32_m128i(b));
+    int32x2x2_t result = vzip_s32(a1, b1);
+    return vreinterpretq_m128i_s32(vcombine_s32(result.val[0], result.val[1]));
+#endif
+}
+
+// Unpack and interleave 64-bit integers from the low half of a and b, and store
+// the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_unpacklo_epi64
+FORCE_INLINE __m128i _mm_unpacklo_epi64(__m128i a, __m128i b)
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+    return vreinterpretq_m128i_s64(
+        vzip1q_s64(vreinterpretq_s64_m128i(a), vreinterpretq_s64_m128i(b)));
+#else
+    int64x1_t a_l = vget_low_s64(vreinterpretq_s64_m128i(a));
+    int64x1_t b_l = vget_low_s64(vreinterpretq_s64_m128i(b));
+    return vreinterpretq_m128i_s64(vcombine_s64(a_l, b_l));
+#endif
+}
+
+// Unpack and interleave 8-bit integers from the low half of a and b, and store
+// the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_unpacklo_epi8
+FORCE_INLINE __m128i _mm_unpacklo_epi8(__m128i a, __m128i b)
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+    return vreinterpretq_m128i_s8(
+        vzip1q_s8(vreinterpretq_s8_m128i(a), vreinterpretq_s8_m128i(b)));
+#else
+    int8x8_t a1 = vreinterpret_s8_s16(vget_low_s16(vreinterpretq_s16_m128i(a)));
+    int8x8_t b1 = vreinterpret_s8_s16(vget_low_s16(vreinterpretq_s16_m128i(b)));
+    int8x8x2_t result = vzip_s8(a1, b1);
+    return vreinterpretq_m128i_s8(vcombine_s8(result.val[0], result.val[1]));
+#endif
+}
+
+// Unpack and interleave double-precision (64-bit) floating-point elements from
+// the low half of a and b, and store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_unpacklo_pd
+FORCE_INLINE __m128d _mm_unpacklo_pd(__m128d a, __m128d b)
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+    return vreinterpretq_m128d_f64(
+        vzip1q_f64(vreinterpretq_f64_m128d(a), vreinterpretq_f64_m128d(b)));
+#else
+    return vreinterpretq_m128d_s64(
+        vcombine_s64(vget_low_s64(vreinterpretq_s64_m128d(a)),
+                     vget_low_s64(vreinterpretq_s64_m128d(b))));
+#endif
+}
+
+// Compute the bitwise XOR of packed double-precision (64-bit) floating-point
+// elements in a and b, and store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_xor_pd
+FORCE_INLINE __m128d _mm_xor_pd(__m128d a, __m128d b)
+{
+    return vreinterpretq_m128d_s64(
+        veorq_s64(vreinterpretq_s64_m128d(a), vreinterpretq_s64_m128d(b)));
+}
+
+// Compute the bitwise XOR of 128 bits (representing integer data) in a and b,
+// and store the result in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_xor_si128
+FORCE_INLINE __m128i _mm_xor_si128(__m128i a, __m128i b)
+{
+    return vreinterpretq_m128i_s32(
+        veorq_s32(vreinterpretq_s32_m128i(a), vreinterpretq_s32_m128i(b)));
+}
+
+/* SSE3 */
+
+// Alternatively add and subtract packed double-precision (64-bit)
+// floating-point elements in a to/from packed elements in b, and store the
+// results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_addsub_pd
+FORCE_INLINE __m128d _mm_addsub_pd(__m128d a, __m128d b)
+{
+    _sse2neon_const __m128d mask = _mm_set_pd(1.0f, -1.0f);
+#if defined(__aarch64__) || defined(_M_ARM64)
+    return vreinterpretq_m128d_f64(vfmaq_f64(vreinterpretq_f64_m128d(a),
+                                             vreinterpretq_f64_m128d(b),
+                                             vreinterpretq_f64_m128d(mask)));
+#else
+    return _mm_add_pd(_mm_mul_pd(b, mask), a);
+#endif
+}
+
+// Alternatively add and subtract packed single-precision (32-bit)
+// floating-point elements in a to/from packed elements in b, and store the
+// results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=addsub_ps
+FORCE_INLINE __m128 _mm_addsub_ps(__m128 a, __m128 b)
+{
+    _sse2neon_const __m128 mask = _mm_setr_ps(-1.0f, 1.0f, -1.0f, 1.0f);
+#if (defined(__aarch64__) || defined(_M_ARM64)) || \
+    defined(__ARM_FEATURE_FMA) /* VFPv4+ */
+    return vreinterpretq_m128_f32(vfmaq_f32(vreinterpretq_f32_m128(a),
+                                            vreinterpretq_f32_m128(mask),
+                                            vreinterpretq_f32_m128(b)));
+#else
+    return _mm_add_ps(_mm_mul_ps(b, mask), a);
+#endif
+}
+
+// Horizontally add adjacent pairs of double-precision (64-bit) floating-point
+// elements in a and b, and pack the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_hadd_pd
+FORCE_INLINE __m128d _mm_hadd_pd(__m128d a, __m128d b)
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+    return vreinterpretq_m128d_f64(
+        vpaddq_f64(vreinterpretq_f64_m128d(a), vreinterpretq_f64_m128d(b)));
+#else
+    double *da = (double *) &a;
+    double *db = (double *) &b;
+    double c[] = {da[0] + da[1], db[0] + db[1]};
+    return vreinterpretq_m128d_u64(vld1q_u64((uint64_t *) c));
+#endif
+}
+
+// Horizontally add adjacent pairs of single-precision (32-bit) floating-point
+// elements in a and b, and pack the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_hadd_ps
+FORCE_INLINE __m128 _mm_hadd_ps(__m128 a, __m128 b)
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+    return vreinterpretq_m128_f32(
+        vpaddq_f32(vreinterpretq_f32_m128(a), vreinterpretq_f32_m128(b)));
+#else
+    float32x2_t a10 = vget_low_f32(vreinterpretq_f32_m128(a));
+    float32x2_t a32 = vget_high_f32(vreinterpretq_f32_m128(a));
+    float32x2_t b10 = vget_low_f32(vreinterpretq_f32_m128(b));
+    float32x2_t b32 = vget_high_f32(vreinterpretq_f32_m128(b));
+    return vreinterpretq_m128_f32(
+        vcombine_f32(vpadd_f32(a10, a32), vpadd_f32(b10, b32)));
+#endif
+}
+
+// Horizontally subtract adjacent pairs of double-precision (64-bit)
+// floating-point elements in a and b, and pack the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_hsub_pd
+FORCE_INLINE __m128d _mm_hsub_pd(__m128d _a, __m128d _b)
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+    float64x2_t a = vreinterpretq_f64_m128d(_a);
+    float64x2_t b = vreinterpretq_f64_m128d(_b);
+    return vreinterpretq_m128d_f64(
+        vsubq_f64(vuzp1q_f64(a, b), vuzp2q_f64(a, b)));
+#else
+    double *da = (double *) &_a;
+    double *db = (double *) &_b;
+    double c[] = {da[0] - da[1], db[0] - db[1]};
+    return vreinterpretq_m128d_u64(vld1q_u64((uint64_t *) c));
+#endif
+}
+
+// Horizontally subtract adjacent pairs of single-precision (32-bit)
+// floating-point elements in a and b, and pack the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_hsub_ps
+FORCE_INLINE __m128 _mm_hsub_ps(__m128 _a, __m128 _b)
+{
+    float32x4_t a = vreinterpretq_f32_m128(_a);
+    float32x4_t b = vreinterpretq_f32_m128(_b);
+#if defined(__aarch64__) || defined(_M_ARM64)
+    return vreinterpretq_m128_f32(
+        vsubq_f32(vuzp1q_f32(a, b), vuzp2q_f32(a, b)));
+#else
+    float32x4x2_t c = vuzpq_f32(a, b);
+    return vreinterpretq_m128_f32(vsubq_f32(c.val[0], c.val[1]));
+#endif
+}
+
+// Load 128-bits of integer data from unaligned memory into dst. This intrinsic
+// may perform better than _mm_loadu_si128 when the data crosses a cache line
+// boundary.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_lddqu_si128
+#define _mm_lddqu_si128 _mm_loadu_si128
+
+// Load a double-precision (64-bit) floating-point element from memory into both
+// elements of dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_loaddup_pd
+#define _mm_loaddup_pd _mm_load1_pd
+
+// Duplicate the low double-precision (64-bit) floating-point element from a,
+// and store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_movedup_pd
+FORCE_INLINE __m128d _mm_movedup_pd(__m128d a)
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+    return vreinterpretq_m128d_f64(
+        vdupq_laneq_f64(vreinterpretq_f64_m128d(a), 0));
+#else
+    return vreinterpretq_m128d_u64(
+        vdupq_n_u64(vgetq_lane_u64(vreinterpretq_u64_m128d(a), 0)));
+#endif
+}
+
+// Duplicate odd-indexed single-precision (32-bit) floating-point elements
+// from a, and store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_movehdup_ps
+FORCE_INLINE __m128 _mm_movehdup_ps(__m128 a)
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+    return vreinterpretq_m128_f32(
+        vtrn2q_f32(vreinterpretq_f32_m128(a), vreinterpretq_f32_m128(a)));
+#elif defined(_sse2neon_shuffle)
+    return vreinterpretq_m128_f32(vshuffleq_s32(
+        vreinterpretq_f32_m128(a), vreinterpretq_f32_m128(a), 1, 1, 3, 3));
+#else
+    float32_t a1 = vgetq_lane_f32(vreinterpretq_f32_m128(a), 1);
+    float32_t a3 = vgetq_lane_f32(vreinterpretq_f32_m128(a), 3);
+    float ALIGN_STRUCT(16) data[4] = {a1, a1, a3, a3};
+    return vreinterpretq_m128_f32(vld1q_f32(data));
+#endif
+}
+
+// Duplicate even-indexed single-precision (32-bit) floating-point elements
+// from a, and store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_moveldup_ps
+FORCE_INLINE __m128 _mm_moveldup_ps(__m128 a)
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+    return vreinterpretq_m128_f32(
+        vtrn1q_f32(vreinterpretq_f32_m128(a), vreinterpretq_f32_m128(a)));
+#elif defined(_sse2neon_shuffle)
+    return vreinterpretq_m128_f32(vshuffleq_s32(
+        vreinterpretq_f32_m128(a), vreinterpretq_f32_m128(a), 0, 0, 2, 2));
+#else
+    float32_t a0 = vgetq_lane_f32(vreinterpretq_f32_m128(a), 0);
+    float32_t a2 = vgetq_lane_f32(vreinterpretq_f32_m128(a), 2);
+    float ALIGN_STRUCT(16) data[4] = {a0, a0, a2, a2};
+    return vreinterpretq_m128_f32(vld1q_f32(data));
+#endif
+}
+
+/* SSSE3 */
+
+// Compute the absolute value of packed signed 16-bit integers in a, and store
+// the unsigned results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_abs_epi16
+FORCE_INLINE __m128i _mm_abs_epi16(__m128i a)
+{
+    return vreinterpretq_m128i_s16(vabsq_s16(vreinterpretq_s16_m128i(a)));
+}
+
+// Compute the absolute value of packed signed 32-bit integers in a, and store
+// the unsigned results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_abs_epi32
+FORCE_INLINE __m128i _mm_abs_epi32(__m128i a)
+{
+    return vreinterpretq_m128i_s32(vabsq_s32(vreinterpretq_s32_m128i(a)));
+}
+
+// Compute the absolute value of packed signed 8-bit integers in a, and store
+// the unsigned results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_abs_epi8
+FORCE_INLINE __m128i _mm_abs_epi8(__m128i a)
+{
+    return vreinterpretq_m128i_s8(vabsq_s8(vreinterpretq_s8_m128i(a)));
+}
+
+// Compute the absolute value of packed signed 16-bit integers in a, and store
+// the unsigned results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_abs_pi16
+FORCE_INLINE __m64 _mm_abs_pi16(__m64 a)
+{
+    return vreinterpret_m64_s16(vabs_s16(vreinterpret_s16_m64(a)));
+}
+
+// Compute the absolute value of packed signed 32-bit integers in a, and store
+// the unsigned results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_abs_pi32
+FORCE_INLINE __m64 _mm_abs_pi32(__m64 a)
+{
+    return vreinterpret_m64_s32(vabs_s32(vreinterpret_s32_m64(a)));
+}
+
+// Compute the absolute value of packed signed 8-bit integers in a, and store
+// the unsigned results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_abs_pi8
+FORCE_INLINE __m64 _mm_abs_pi8(__m64 a)
+{
+    return vreinterpret_m64_s8(vabs_s8(vreinterpret_s8_m64(a)));
+}
+
+// Concatenate 16-byte blocks in a and b into a 32-byte temporary result, shift
+// the result right by imm8 bytes, and store the low 16 bytes in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_alignr_epi8
+#if defined(__GNUC__) && !defined(__clang__)
+#define _mm_alignr_epi8(a, b, imm)                                            \
+    __extension__({                                                           \
+        uint8x16_t _a = vreinterpretq_u8_m128i(a);                            \
+        uint8x16_t _b = vreinterpretq_u8_m128i(b);                            \
+        __m128i ret;                                                          \
+        if (_sse2neon_unlikely((imm) & ~31))                                  \
+            ret = vreinterpretq_m128i_u8(vdupq_n_u8(0));                      \
+        else if (imm >= 16)                                                   \
+            ret = _mm_srli_si128(a, imm >= 16 ? imm - 16 : 0);                \
+        else                                                                  \
+            ret =                                                             \
+                vreinterpretq_m128i_u8(vextq_u8(_b, _a, imm < 16 ? imm : 0)); \
+        ret;                                                                  \
+    })
+
+#else
+#define _mm_alignr_epi8(a, b, imm)                                          \
+    _sse2neon_define2(                                                      \
+        __m128i, a, b, uint8x16_t __a = vreinterpretq_u8_m128i(_a);         \
+        uint8x16_t __b = vreinterpretq_u8_m128i(_b); __m128i ret;           \
+        if (_sse2neon_unlikely((imm) & ~31)) ret =                          \
+            vreinterpretq_m128i_u8(vdupq_n_u8(0));                          \
+        else if (imm >= 16) ret =                                           \
+            _mm_srli_si128(_a, imm >= 16 ? imm - 16 : 0);                   \
+        else ret =                                                          \
+            vreinterpretq_m128i_u8(vextq_u8(__b, __a, imm < 16 ? imm : 0)); \
+        _sse2neon_return(ret);)
+
+#endif
+
+// Concatenate 8-byte blocks in a and b into a 16-byte temporary result, shift
+// the result right by imm8 bytes, and store the low 8 bytes in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_alignr_pi8
+#define _mm_alignr_pi8(a, b, imm)                                           \
+    _sse2neon_define2(                                                      \
+        __m64, a, b, __m64 ret; if (_sse2neon_unlikely((imm) >= 16)) {      \
+            ret = vreinterpret_m64_s8(vdup_n_s8(0));                        \
+        } else {                                                            \
+            uint8x8_t tmp_low;                                              \
+            uint8x8_t tmp_high;                                             \
+            if ((imm) >= 8) {                                               \
+                const int idx = (imm) -8;                                   \
+                tmp_low = vreinterpret_u8_m64(_a);                          \
+                tmp_high = vdup_n_u8(0);                                    \
+                ret = vreinterpret_m64_u8(vext_u8(tmp_low, tmp_high, idx)); \
+            } else {                                                        \
+                const int idx = (imm);                                      \
+                tmp_low = vreinterpret_u8_m64(_b);                          \
+                tmp_high = vreinterpret_u8_m64(_a);                         \
+                ret = vreinterpret_m64_u8(vext_u8(tmp_low, tmp_high, idx)); \
+            }                                                               \
+        } _sse2neon_return(ret);)
+
+// Horizontally add adjacent pairs of 16-bit integers in a and b, and pack the
+// signed 16-bit results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_hadd_epi16
+FORCE_INLINE __m128i _mm_hadd_epi16(__m128i _a, __m128i _b)
+{
+    int16x8_t a = vreinterpretq_s16_m128i(_a);
+    int16x8_t b = vreinterpretq_s16_m128i(_b);
+#if defined(__aarch64__) || defined(_M_ARM64)
+    return vreinterpretq_m128i_s16(vpaddq_s16(a, b));
+#else
+    return vreinterpretq_m128i_s16(
+        vcombine_s16(vpadd_s16(vget_low_s16(a), vget_high_s16(a)),
+                     vpadd_s16(vget_low_s16(b), vget_high_s16(b))));
+#endif
+}
+
+// Horizontally add adjacent pairs of 32-bit integers in a and b, and pack the
+// signed 32-bit results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_hadd_epi32
+FORCE_INLINE __m128i _mm_hadd_epi32(__m128i _a, __m128i _b)
+{
+    int32x4_t a = vreinterpretq_s32_m128i(_a);
+    int32x4_t b = vreinterpretq_s32_m128i(_b);
+#if defined(__aarch64__) || defined(_M_ARM64)
+    return vreinterpretq_m128i_s32(vpaddq_s32(a, b));
+#else
+    return vreinterpretq_m128i_s32(
+        vcombine_s32(vpadd_s32(vget_low_s32(a), vget_high_s32(a)),
+                     vpadd_s32(vget_low_s32(b), vget_high_s32(b))));
+#endif
+}
+
+// Horizontally add adjacent pairs of 16-bit integers in a and b, and pack the
+// signed 16-bit results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_hadd_pi16
+FORCE_INLINE __m64 _mm_hadd_pi16(__m64 a, __m64 b)
+{
+    return vreinterpret_m64_s16(
+        vpadd_s16(vreinterpret_s16_m64(a), vreinterpret_s16_m64(b)));
+}
+
+// Horizontally add adjacent pairs of 32-bit integers in a and b, and pack the
+// signed 32-bit results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_hadd_pi32
+FORCE_INLINE __m64 _mm_hadd_pi32(__m64 a, __m64 b)
+{
+    return vreinterpret_m64_s32(
+        vpadd_s32(vreinterpret_s32_m64(a), vreinterpret_s32_m64(b)));
+}
+
+// Horizontally add adjacent pairs of signed 16-bit integers in a and b using
+// saturation, and pack the signed 16-bit results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_hadds_epi16
+FORCE_INLINE __m128i _mm_hadds_epi16(__m128i _a, __m128i _b)
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+    int16x8_t a = vreinterpretq_s16_m128i(_a);
+    int16x8_t b = vreinterpretq_s16_m128i(_b);
+    return vreinterpretq_s64_s16(
+        vqaddq_s16(vuzp1q_s16(a, b), vuzp2q_s16(a, b)));
+#else
+    int32x4_t a = vreinterpretq_s32_m128i(_a);
+    int32x4_t b = vreinterpretq_s32_m128i(_b);
+    // Interleave using vshrn/vmovn
+    // [a0|a2|a4|a6|b0|b2|b4|b6]
+    // [a1|a3|a5|a7|b1|b3|b5|b7]
+    int16x8_t ab0246 = vcombine_s16(vmovn_s32(a), vmovn_s32(b));
+    int16x8_t ab1357 = vcombine_s16(vshrn_n_s32(a, 16), vshrn_n_s32(b, 16));
+    // Saturated add
+    return vreinterpretq_m128i_s16(vqaddq_s16(ab0246, ab1357));
+#endif
+}
+
+// Horizontally add adjacent pairs of signed 16-bit integers in a and b using
+// saturation, and pack the signed 16-bit results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_hadds_pi16
+FORCE_INLINE __m64 _mm_hadds_pi16(__m64 _a, __m64 _b)
+{
+    int16x4_t a = vreinterpret_s16_m64(_a);
+    int16x4_t b = vreinterpret_s16_m64(_b);
+#if defined(__aarch64__) || defined(_M_ARM64)
+    return vreinterpret_s64_s16(vqadd_s16(vuzp1_s16(a, b), vuzp2_s16(a, b)));
+#else
+    int16x4x2_t res = vuzp_s16(a, b);
+    return vreinterpret_s64_s16(vqadd_s16(res.val[0], res.val[1]));
+#endif
+}
+
+// Horizontally subtract adjacent pairs of 16-bit integers in a and b, and pack
+// the signed 16-bit results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_hsub_epi16
+FORCE_INLINE __m128i _mm_hsub_epi16(__m128i _a, __m128i _b)
+{
+    int16x8_t a = vreinterpretq_s16_m128i(_a);
+    int16x8_t b = vreinterpretq_s16_m128i(_b);
+#if defined(__aarch64__) || defined(_M_ARM64)
+    return vreinterpretq_m128i_s16(
+        vsubq_s16(vuzp1q_s16(a, b), vuzp2q_s16(a, b)));
+#else
+    int16x8x2_t c = vuzpq_s16(a, b);
+    return vreinterpretq_m128i_s16(vsubq_s16(c.val[0], c.val[1]));
+#endif
+}
+
+// Horizontally subtract adjacent pairs of 32-bit integers in a and b, and pack
+// the signed 32-bit results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_hsub_epi32
+FORCE_INLINE __m128i _mm_hsub_epi32(__m128i _a, __m128i _b)
+{
+    int32x4_t a = vreinterpretq_s32_m128i(_a);
+    int32x4_t b = vreinterpretq_s32_m128i(_b);
+#if defined(__aarch64__) || defined(_M_ARM64)
+    return vreinterpretq_m128i_s32(
+        vsubq_s32(vuzp1q_s32(a, b), vuzp2q_s32(a, b)));
+#else
+    int32x4x2_t c = vuzpq_s32(a, b);
+    return vreinterpretq_m128i_s32(vsubq_s32(c.val[0], c.val[1]));
+#endif
+}
+
+// Horizontally subtract adjacent pairs of 16-bit integers in a and b, and pack
+// the signed 16-bit results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_hsub_pi16
+FORCE_INLINE __m64 _mm_hsub_pi16(__m64 _a, __m64 _b)
+{
+    int16x4_t a = vreinterpret_s16_m64(_a);
+    int16x4_t b = vreinterpret_s16_m64(_b);
+#if defined(__aarch64__) || defined(_M_ARM64)
+    return vreinterpret_m64_s16(vsub_s16(vuzp1_s16(a, b), vuzp2_s16(a, b)));
+#else
+    int16x4x2_t c = vuzp_s16(a, b);
+    return vreinterpret_m64_s16(vsub_s16(c.val[0], c.val[1]));
+#endif
+}
+
+// Horizontally subtract adjacent pairs of 32-bit integers in a and b, and pack
+// the signed 32-bit results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=mm_hsub_pi32
+FORCE_INLINE __m64 _mm_hsub_pi32(__m64 _a, __m64 _b)
+{
+    int32x2_t a = vreinterpret_s32_m64(_a);
+    int32x2_t b = vreinterpret_s32_m64(_b);
+#if defined(__aarch64__) || defined(_M_ARM64)
+    return vreinterpret_m64_s32(vsub_s32(vuzp1_s32(a, b), vuzp2_s32(a, b)));
+#else
+    int32x2x2_t c = vuzp_s32(a, b);
+    return vreinterpret_m64_s32(vsub_s32(c.val[0], c.val[1]));
+#endif
+}
+
+// Horizontally subtract adjacent pairs of signed 16-bit integers in a and b
+// using saturation, and pack the signed 16-bit results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_hsubs_epi16
+FORCE_INLINE __m128i _mm_hsubs_epi16(__m128i _a, __m128i _b)
+{
+    int16x8_t a = vreinterpretq_s16_m128i(_a);
+    int16x8_t b = vreinterpretq_s16_m128i(_b);
+#if defined(__aarch64__) || defined(_M_ARM64)
+    return vreinterpretq_m128i_s16(
+        vqsubq_s16(vuzp1q_s16(a, b), vuzp2q_s16(a, b)));
+#else
+    int16x8x2_t c = vuzpq_s16(a, b);
+    return vreinterpretq_m128i_s16(vqsubq_s16(c.val[0], c.val[1]));
+#endif
+}
+
+// Horizontally subtract adjacent pairs of signed 16-bit integers in a and b
+// using saturation, and pack the signed 16-bit results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_hsubs_pi16
+FORCE_INLINE __m64 _mm_hsubs_pi16(__m64 _a, __m64 _b)
+{
+    int16x4_t a = vreinterpret_s16_m64(_a);
+    int16x4_t b = vreinterpret_s16_m64(_b);
+#if defined(__aarch64__) || defined(_M_ARM64)
+    return vreinterpret_m64_s16(vqsub_s16(vuzp1_s16(a, b), vuzp2_s16(a, b)));
+#else
+    int16x4x2_t c = vuzp_s16(a, b);
+    return vreinterpret_m64_s16(vqsub_s16(c.val[0], c.val[1]));
+#endif
+}
+
+// Vertically multiply each unsigned 8-bit integer from a with the corresponding
+// signed 8-bit integer from b, producing intermediate signed 16-bit integers.
+// Horizontally add adjacent pairs of intermediate signed 16-bit integers,
+// and pack the saturated results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maddubs_epi16
+FORCE_INLINE __m128i _mm_maddubs_epi16(__m128i _a, __m128i _b)
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+    uint8x16_t a = vreinterpretq_u8_m128i(_a);
+    int8x16_t b = vreinterpretq_s8_m128i(_b);
+    int16x8_t tl = vmulq_s16(vreinterpretq_s16_u16(vmovl_u8(vget_low_u8(a))),
+                             vmovl_s8(vget_low_s8(b)));
+    int16x8_t th = vmulq_s16(vreinterpretq_s16_u16(vmovl_u8(vget_high_u8(a))),
+                             vmovl_s8(vget_high_s8(b)));
+    return vreinterpretq_m128i_s16(
+        vqaddq_s16(vuzp1q_s16(tl, th), vuzp2q_s16(tl, th)));
+#else
+    // This would be much simpler if x86 would choose to zero extend OR sign
+    // extend, not both. This could probably be optimized better.
+    uint16x8_t a = vreinterpretq_u16_m128i(_a);
+    int16x8_t b = vreinterpretq_s16_m128i(_b);
+
+    // Zero extend a
+    int16x8_t a_odd = vreinterpretq_s16_u16(vshrq_n_u16(a, 8));
+    int16x8_t a_even = vreinterpretq_s16_u16(vbicq_u16(a, vdupq_n_u16(0xff00)));
+
+    // Sign extend by shifting left then shifting right.
+    int16x8_t b_even = vshrq_n_s16(vshlq_n_s16(b, 8), 8);
+    int16x8_t b_odd = vshrq_n_s16(b, 8);
+
+    // multiply
+    int16x8_t prod1 = vmulq_s16(a_even, b_even);
+    int16x8_t prod2 = vmulq_s16(a_odd, b_odd);
+
+    // saturated add
+    return vreinterpretq_m128i_s16(vqaddq_s16(prod1, prod2));
+#endif
+}
+
+// Vertically multiply each unsigned 8-bit integer from a with the corresponding
+// signed 8-bit integer from b, producing intermediate signed 16-bit integers.
+// Horizontally add adjacent pairs of intermediate signed 16-bit integers, and
+// pack the saturated results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maddubs_pi16
+FORCE_INLINE __m64 _mm_maddubs_pi16(__m64 _a, __m64 _b)
+{
+    uint16x4_t a = vreinterpret_u16_m64(_a);
+    int16x4_t b = vreinterpret_s16_m64(_b);
+
+    // Zero extend a
+    int16x4_t a_odd = vreinterpret_s16_u16(vshr_n_u16(a, 8));
+    int16x4_t a_even = vreinterpret_s16_u16(vand_u16(a, vdup_n_u16(0xff)));
+
+    // Sign extend by shifting left then shifting right.
+    int16x4_t b_even = vshr_n_s16(vshl_n_s16(b, 8), 8);
+    int16x4_t b_odd = vshr_n_s16(b, 8);
+
+    // multiply
+    int16x4_t prod1 = vmul_s16(a_even, b_even);
+    int16x4_t prod2 = vmul_s16(a_odd, b_odd);
+
+    // saturated add
+    return vreinterpret_m64_s16(vqadd_s16(prod1, prod2));
+}
+
+// Multiply packed signed 16-bit integers in a and b, producing intermediate
+// signed 32-bit integers. Shift right by 15 bits while rounding up, and store
+// the packed 16-bit integers in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mulhrs_epi16
+FORCE_INLINE __m128i _mm_mulhrs_epi16(__m128i a, __m128i b)
+{
+    // Has issues due to saturation
+    // return vreinterpretq_m128i_s16(vqrdmulhq_s16(a, b));
+
+    // Multiply
+    int32x4_t mul_lo = vmull_s16(vget_low_s16(vreinterpretq_s16_m128i(a)),
+                                 vget_low_s16(vreinterpretq_s16_m128i(b)));
+    int32x4_t mul_hi = vmull_s16(vget_high_s16(vreinterpretq_s16_m128i(a)),
+                                 vget_high_s16(vreinterpretq_s16_m128i(b)));
+
+    // Rounding narrowing shift right
+    // narrow = (int16_t)((mul + 16384) >> 15);
+    int16x4_t narrow_lo = vrshrn_n_s32(mul_lo, 15);
+    int16x4_t narrow_hi = vrshrn_n_s32(mul_hi, 15);
+
+    // Join together
+    return vreinterpretq_m128i_s16(vcombine_s16(narrow_lo, narrow_hi));
+}
+
+// Multiply packed signed 16-bit integers in a and b, producing intermediate
+// signed 32-bit integers. Truncate each intermediate integer to the 18 most
+// significant bits, round by adding 1, and store bits [16:1] to dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mulhrs_pi16
+FORCE_INLINE __m64 _mm_mulhrs_pi16(__m64 a, __m64 b)
+{
+    int32x4_t mul_extend =
+        vmull_s16((vreinterpret_s16_m64(a)), (vreinterpret_s16_m64(b)));
+
+    // Rounding narrowing shift right
+    return vreinterpret_m64_s16(vrshrn_n_s32(mul_extend, 15));
+}
+
+// Shuffle packed 8-bit integers in a according to shuffle control mask in the
+// corresponding 8-bit element of b, and store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_shuffle_epi8
+FORCE_INLINE __m128i _mm_shuffle_epi8(__m128i a, __m128i b)
+{
+    int8x16_t tbl = vreinterpretq_s8_m128i(a);   // input a
+    uint8x16_t idx = vreinterpretq_u8_m128i(b);  // input b
+    uint8x16_t idx_masked =
+        vandq_u8(idx, vdupq_n_u8(0x8F));  // avoid using meaningless bits
+#if defined(__aarch64__) || defined(_M_ARM64)
+    return vreinterpretq_m128i_s8(vqtbl1q_s8(tbl, idx_masked));
+#elif defined(__GNUC__)
+    int8x16_t ret;
+    // %e and %f represent the even and odd D registers
+    // respectively.
+    __asm__ __volatile__(
+        "vtbl.8  %e[ret], {%e[tbl], %f[tbl]}, %e[idx]\n"
+        "vtbl.8  %f[ret], {%e[tbl], %f[tbl]}, %f[idx]\n"
+        : [ret] "=&w"(ret)
+        : [tbl] "w"(tbl), [idx] "w"(idx_masked));
+    return vreinterpretq_m128i_s8(ret);
+#else
+    // use this line if testing on aarch64
+    int8x8x2_t a_split = {vget_low_s8(tbl), vget_high_s8(tbl)};
+    return vreinterpretq_m128i_s8(
+        vcombine_s8(vtbl2_s8(a_split, vget_low_u8(idx_masked)),
+                    vtbl2_s8(a_split, vget_high_u8(idx_masked))));
+#endif
+}
+
+// Shuffle packed 8-bit integers in a according to shuffle control mask in the
+// corresponding 8-bit element of b, and store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_shuffle_pi8
+FORCE_INLINE __m64 _mm_shuffle_pi8(__m64 a, __m64 b)
+{
+    const int8x8_t controlMask =
+        vand_s8(vreinterpret_s8_m64(b), vdup_n_s8((int8_t) (0x1 << 7 | 0x07)));
+    int8x8_t res = vtbl1_s8(vreinterpret_s8_m64(a), controlMask);
+    return vreinterpret_m64_s8(res);
+}
+
+// Negate packed 16-bit integers in a when the corresponding signed
+// 16-bit integer in b is negative, and store the results in dst.
+// Element in dst are zeroed out when the corresponding element
+// in b is zero.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_sign_epi16
+FORCE_INLINE __m128i _mm_sign_epi16(__m128i _a, __m128i _b)
+{
+    int16x8_t a = vreinterpretq_s16_m128i(_a);
+    int16x8_t b = vreinterpretq_s16_m128i(_b);
+
+    // signed shift right: faster than vclt
+    // (b < 0) ? 0xFFFF : 0
+    uint16x8_t ltMask = vreinterpretq_u16_s16(vshrq_n_s16(b, 15));
+    // (b == 0) ? 0xFFFF : 0
+#if defined(__aarch64__) || defined(_M_ARM64)
+    int16x8_t zeroMask = vreinterpretq_s16_u16(vceqzq_s16(b));
+#else
+    int16x8_t zeroMask = vreinterpretq_s16_u16(vceqq_s16(b, vdupq_n_s16(0)));
+#endif
+
+    // bitwise select either a or negative 'a' (vnegq_s16(a) equals to negative
+    // 'a') based on ltMask
+    int16x8_t masked = vbslq_s16(ltMask, vnegq_s16(a), a);
+    // res = masked & (~zeroMask)
+    int16x8_t res = vbicq_s16(masked, zeroMask);
+    return vreinterpretq_m128i_s16(res);
+}
+
+// Negate packed 32-bit integers in a when the corresponding signed
+// 32-bit integer in b is negative, and store the results in dst.
+// Element in dst are zeroed out when the corresponding element
+// in b is zero.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_sign_epi32
+FORCE_INLINE __m128i _mm_sign_epi32(__m128i _a, __m128i _b)
+{
+    int32x4_t a = vreinterpretq_s32_m128i(_a);
+    int32x4_t b = vreinterpretq_s32_m128i(_b);
+
+    // signed shift right: faster than vclt
+    // (b < 0) ? 0xFFFFFFFF : 0
+    uint32x4_t ltMask = vreinterpretq_u32_s32(vshrq_n_s32(b, 31));
+
+    // (b == 0) ? 0xFFFFFFFF : 0
+#if defined(__aarch64__) || defined(_M_ARM64)
+    int32x4_t zeroMask = vreinterpretq_s32_u32(vceqzq_s32(b));
+#else
+    int32x4_t zeroMask = vreinterpretq_s32_u32(vceqq_s32(b, vdupq_n_s32(0)));
+#endif
+
+    // bitwise select either a or negative 'a' (vnegq_s32(a) equals to negative
+    // 'a') based on ltMask
+    int32x4_t masked = vbslq_s32(ltMask, vnegq_s32(a), a);
+    // res = masked & (~zeroMask)
+    int32x4_t res = vbicq_s32(masked, zeroMask);
+    return vreinterpretq_m128i_s32(res);
+}
+
+// Negate packed 8-bit integers in a when the corresponding signed
+// 8-bit integer in b is negative, and store the results in dst.
+// Element in dst are zeroed out when the corresponding element
+// in b is zero.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_sign_epi8
+FORCE_INLINE __m128i _mm_sign_epi8(__m128i _a, __m128i _b)
+{
+    int8x16_t a = vreinterpretq_s8_m128i(_a);
+    int8x16_t b = vreinterpretq_s8_m128i(_b);
+
+    // signed shift right: faster than vclt
+    // (b < 0) ? 0xFF : 0
+    uint8x16_t ltMask = vreinterpretq_u8_s8(vshrq_n_s8(b, 7));
+
+    // (b == 0) ? 0xFF : 0
+#if defined(__aarch64__) || defined(_M_ARM64)
+    int8x16_t zeroMask = vreinterpretq_s8_u8(vceqzq_s8(b));
+#else
+    int8x16_t zeroMask = vreinterpretq_s8_u8(vceqq_s8(b, vdupq_n_s8(0)));
+#endif
+
+    // bitwise select either a or negative 'a' (vnegq_s8(a) return negative 'a')
+    // based on ltMask
+    int8x16_t masked = vbslq_s8(ltMask, vnegq_s8(a), a);
+    // res = masked & (~zeroMask)
+    int8x16_t res = vbicq_s8(masked, zeroMask);
+
+    return vreinterpretq_m128i_s8(res);
+}
+
+// Negate packed 16-bit integers in a when the corresponding signed 16-bit
+// integer in b is negative, and store the results in dst. Element in dst are
+// zeroed out when the corresponding element in b is zero.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_sign_pi16
+FORCE_INLINE __m64 _mm_sign_pi16(__m64 _a, __m64 _b)
+{
+    int16x4_t a = vreinterpret_s16_m64(_a);
+    int16x4_t b = vreinterpret_s16_m64(_b);
+
+    // signed shift right: faster than vclt
+    // (b < 0) ? 0xFFFF : 0
+    uint16x4_t ltMask = vreinterpret_u16_s16(vshr_n_s16(b, 15));
+
+    // (b == 0) ? 0xFFFF : 0
+#if defined(__aarch64__) || defined(_M_ARM64)
+    int16x4_t zeroMask = vreinterpret_s16_u16(vceqz_s16(b));
+#else
+    int16x4_t zeroMask = vreinterpret_s16_u16(vceq_s16(b, vdup_n_s16(0)));
+#endif
+
+    // bitwise select either a or negative 'a' (vneg_s16(a) return negative 'a')
+    // based on ltMask
+    int16x4_t masked = vbsl_s16(ltMask, vneg_s16(a), a);
+    // res = masked & (~zeroMask)
+    int16x4_t res = vbic_s16(masked, zeroMask);
+
+    return vreinterpret_m64_s16(res);
+}
+
+// Negate packed 32-bit integers in a when the corresponding signed 32-bit
+// integer in b is negative, and store the results in dst. Element in dst are
+// zeroed out when the corresponding element in b is zero.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_sign_pi32
+FORCE_INLINE __m64 _mm_sign_pi32(__m64 _a, __m64 _b)
+{
+    int32x2_t a = vreinterpret_s32_m64(_a);
+    int32x2_t b = vreinterpret_s32_m64(_b);
+
+    // signed shift right: faster than vclt
+    // (b < 0) ? 0xFFFFFFFF : 0
+    uint32x2_t ltMask = vreinterpret_u32_s32(vshr_n_s32(b, 31));
+
+    // (b == 0) ? 0xFFFFFFFF : 0
+#if defined(__aarch64__) || defined(_M_ARM64)
+    int32x2_t zeroMask = vreinterpret_s32_u32(vceqz_s32(b));
+#else
+    int32x2_t zeroMask = vreinterpret_s32_u32(vceq_s32(b, vdup_n_s32(0)));
+#endif
+
+    // bitwise select either a or negative 'a' (vneg_s32(a) return negative 'a')
+    // based on ltMask
+    int32x2_t masked = vbsl_s32(ltMask, vneg_s32(a), a);
+    // res = masked & (~zeroMask)
+    int32x2_t res = vbic_s32(masked, zeroMask);
+
+    return vreinterpret_m64_s32(res);
+}
+
+// Negate packed 8-bit integers in a when the corresponding signed 8-bit integer
+// in b is negative, and store the results in dst. Element in dst are zeroed out
+// when the corresponding element in b is zero.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_sign_pi8
+FORCE_INLINE __m64 _mm_sign_pi8(__m64 _a, __m64 _b)
+{
+    int8x8_t a = vreinterpret_s8_m64(_a);
+    int8x8_t b = vreinterpret_s8_m64(_b);
+
+    // signed shift right: faster than vclt
+    // (b < 0) ? 0xFF : 0
+    uint8x8_t ltMask = vreinterpret_u8_s8(vshr_n_s8(b, 7));
+
+    // (b == 0) ? 0xFF : 0
+#if defined(__aarch64__) || defined(_M_ARM64)
+    int8x8_t zeroMask = vreinterpret_s8_u8(vceqz_s8(b));
+#else
+    int8x8_t zeroMask = vreinterpret_s8_u8(vceq_s8(b, vdup_n_s8(0)));
+#endif
+
+    // bitwise select either a or negative 'a' (vneg_s8(a) return negative 'a')
+    // based on ltMask
+    int8x8_t masked = vbsl_s8(ltMask, vneg_s8(a), a);
+    // res = masked & (~zeroMask)
+    int8x8_t res = vbic_s8(masked, zeroMask);
+
+    return vreinterpret_m64_s8(res);
+}
+
+/* SSE4.1 */
+
+// Blend packed 16-bit integers from a and b using control mask imm8, and store
+// the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_blend_epi16
+// FORCE_INLINE __m128i _mm_blend_epi16(__m128i a, __m128i b,
+//                                      __constrange(0,255) int imm)
+#define _mm_blend_epi16(a, b, imm)                                      \
+    _sse2neon_define2(                                                  \
+        __m128i, a, b,                                                  \
+        const uint16_t _mask[8] =                                       \
+            _sse2neon_init(((imm) & (1 << 0)) ? (uint16_t) -1 : 0x0,    \
+                           ((imm) & (1 << 1)) ? (uint16_t) -1 : 0x0,    \
+                           ((imm) & (1 << 2)) ? (uint16_t) -1 : 0x0,    \
+                           ((imm) & (1 << 3)) ? (uint16_t) -1 : 0x0,    \
+                           ((imm) & (1 << 4)) ? (uint16_t) -1 : 0x0,    \
+                           ((imm) & (1 << 5)) ? (uint16_t) -1 : 0x0,    \
+                           ((imm) & (1 << 6)) ? (uint16_t) -1 : 0x0,    \
+                           ((imm) & (1 << 7)) ? (uint16_t) -1 : 0x0);   \
+        uint16x8_t _mask_vec = vld1q_u16(_mask);                        \
+        uint16x8_t __a = vreinterpretq_u16_m128i(_a);                   \
+        uint16x8_t __b = vreinterpretq_u16_m128i(_b); _sse2neon_return( \
+            vreinterpretq_m128i_u16(vbslq_u16(_mask_vec, __b, __a)));)
+
+// Blend packed double-precision (64-bit) floating-point elements from a and b
+// using control mask imm8, and store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_blend_pd
+#define _mm_blend_pd(a, b, imm)                                              \
+    _sse2neon_define2(                                                       \
+        __m128d, a, b,                                                       \
+        const uint64_t _mask[2] =                                            \
+            _sse2neon_init(((imm) & (1 << 0)) ? ~UINT64_C(0) : UINT64_C(0),  \
+                           ((imm) & (1 << 1)) ? ~UINT64_C(0) : UINT64_C(0)); \
+        uint64x2_t _mask_vec = vld1q_u64(_mask);                             \
+        uint64x2_t __a = vreinterpretq_u64_m128d(_a);                        \
+        uint64x2_t __b = vreinterpretq_u64_m128d(_b); _sse2neon_return(      \
+            vreinterpretq_m128d_u64(vbslq_u64(_mask_vec, __b, __a)));)
+
+// Blend packed single-precision (32-bit) floating-point elements from a and b
+// using mask, and store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_blend_ps
+FORCE_INLINE __m128 _mm_blend_ps(__m128 _a, __m128 _b, const char imm8)
+{
+    const uint32_t ALIGN_STRUCT(16)
+        data[4] = {((imm8) & (1 << 0)) ? UINT32_MAX : 0,
+                   ((imm8) & (1 << 1)) ? UINT32_MAX : 0,
+                   ((imm8) & (1 << 2)) ? UINT32_MAX : 0,
+                   ((imm8) & (1 << 3)) ? UINT32_MAX : 0};
+    uint32x4_t mask = vld1q_u32(data);
+    float32x4_t a = vreinterpretq_f32_m128(_a);
+    float32x4_t b = vreinterpretq_f32_m128(_b);
+    return vreinterpretq_m128_f32(vbslq_f32(mask, b, a));
+}
+
+// Blend packed 8-bit integers from a and b using mask, and store the results in
+// dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_blendv_epi8
+FORCE_INLINE __m128i _mm_blendv_epi8(__m128i _a, __m128i _b, __m128i _mask)
+{
+    // Use a signed shift right to create a mask with the sign bit
+    uint8x16_t mask =
+        vreinterpretq_u8_s8(vshrq_n_s8(vreinterpretq_s8_m128i(_mask), 7));
+    uint8x16_t a = vreinterpretq_u8_m128i(_a);
+    uint8x16_t b = vreinterpretq_u8_m128i(_b);
+    return vreinterpretq_m128i_u8(vbslq_u8(mask, b, a));
+}
+
+// Blend packed double-precision (64-bit) floating-point elements from a and b
+// using mask, and store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_blendv_pd
+FORCE_INLINE __m128d _mm_blendv_pd(__m128d _a, __m128d _b, __m128d _mask)
+{
+    uint64x2_t mask =
+        vreinterpretq_u64_s64(vshrq_n_s64(vreinterpretq_s64_m128d(_mask), 63));
+#if defined(__aarch64__) || defined(_M_ARM64)
+    float64x2_t a = vreinterpretq_f64_m128d(_a);
+    float64x2_t b = vreinterpretq_f64_m128d(_b);
+    return vreinterpretq_m128d_f64(vbslq_f64(mask, b, a));
+#else
+    uint64x2_t a = vreinterpretq_u64_m128d(_a);
+    uint64x2_t b = vreinterpretq_u64_m128d(_b);
+    return vreinterpretq_m128d_u64(vbslq_u64(mask, b, a));
+#endif
+}
+
+// Blend packed single-precision (32-bit) floating-point elements from a and b
+// using mask, and store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_blendv_ps
+FORCE_INLINE __m128 _mm_blendv_ps(__m128 _a, __m128 _b, __m128 _mask)
+{
+    // Use a signed shift right to create a mask with the sign bit
+    uint32x4_t mask =
+        vreinterpretq_u32_s32(vshrq_n_s32(vreinterpretq_s32_m128(_mask), 31));
+    float32x4_t a = vreinterpretq_f32_m128(_a);
+    float32x4_t b = vreinterpretq_f32_m128(_b);
+    return vreinterpretq_m128_f32(vbslq_f32(mask, b, a));
+}
+
+// Round the packed double-precision (64-bit) floating-point elements in a up
+// to an integer value, and store the results as packed double-precision
+// floating-point elements in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_ceil_pd
+FORCE_INLINE __m128d _mm_ceil_pd(__m128d a)
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+    return vreinterpretq_m128d_f64(vrndpq_f64(vreinterpretq_f64_m128d(a)));
+#else
+    double *f = (double *) &a;
+    return _mm_set_pd(ceil(f[1]), ceil(f[0]));
+#endif
+}
+
+// Round the packed single-precision (32-bit) floating-point elements in a up to
+// an integer value, and store the results as packed single-precision
+// floating-point elements in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_ceil_ps
+FORCE_INLINE __m128 _mm_ceil_ps(__m128 a)
+{
+#if (defined(__aarch64__) || defined(_M_ARM64)) || \
+    defined(__ARM_FEATURE_DIRECTED_ROUNDING)
+    return vreinterpretq_m128_f32(vrndpq_f32(vreinterpretq_f32_m128(a)));
+#else
+    float *f = (float *) &a;
+    return _mm_set_ps(ceilf(f[3]), ceilf(f[2]), ceilf(f[1]), ceilf(f[0]));
+#endif
+}
+
+// Round the lower double-precision (64-bit) floating-point element in b up to
+// an integer value, store the result as a double-precision floating-point
+// element in the lower element of dst, and copy the upper element from a to the
+// upper element of dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_ceil_sd
+FORCE_INLINE __m128d _mm_ceil_sd(__m128d a, __m128d b)
+{
+    return _mm_move_sd(a, _mm_ceil_pd(b));
+}
+
+// Round the lower single-precision (32-bit) floating-point element in b up to
+// an integer value, store the result as a single-precision floating-point
+// element in the lower element of dst, and copy the upper 3 packed elements
+// from a to the upper elements of dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_ceil_ss
+FORCE_INLINE __m128 _mm_ceil_ss(__m128 a, __m128 b)
+{
+    return _mm_move_ss(a, _mm_ceil_ps(b));
+}
+
+// Compare packed 64-bit integers in a and b for equality, and store the results
+// in dst
+FORCE_INLINE __m128i _mm_cmpeq_epi64(__m128i a, __m128i b)
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+    return vreinterpretq_m128i_u64(
+        vceqq_u64(vreinterpretq_u64_m128i(a), vreinterpretq_u64_m128i(b)));
+#else
+    // ARMv7 lacks vceqq_u64
+    // (a == b) -> (a_lo == b_lo) && (a_hi == b_hi)
+    uint32x4_t cmp =
+        vceqq_u32(vreinterpretq_u32_m128i(a), vreinterpretq_u32_m128i(b));
+    uint32x4_t swapped = vrev64q_u32(cmp);
+    return vreinterpretq_m128i_u32(vandq_u32(cmp, swapped));
+#endif
+}
+
+// Sign extend packed 16-bit integers in a to packed 32-bit integers, and store
+// the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvtepi16_epi32
+FORCE_INLINE __m128i _mm_cvtepi16_epi32(__m128i a)
+{
+    return vreinterpretq_m128i_s32(
+        vmovl_s16(vget_low_s16(vreinterpretq_s16_m128i(a))));
+}
+
+// Sign extend packed 16-bit integers in a to packed 64-bit integers, and store
+// the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvtepi16_epi64
+FORCE_INLINE __m128i _mm_cvtepi16_epi64(__m128i a)
+{
+    int16x8_t s16x8 = vreinterpretq_s16_m128i(a);     /* xxxx xxxx xxxx 0B0A */
+    int32x4_t s32x4 = vmovl_s16(vget_low_s16(s16x8)); /* 000x 000x 000B 000A */
+    int64x2_t s64x2 = vmovl_s32(vget_low_s32(s32x4)); /* 0000 000B 0000 000A */
+    return vreinterpretq_m128i_s64(s64x2);
+}
+
+// Sign extend packed 32-bit integers in a to packed 64-bit integers, and store
+// the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvtepi32_epi64
+FORCE_INLINE __m128i _mm_cvtepi32_epi64(__m128i a)
+{
+    return vreinterpretq_m128i_s64(
+        vmovl_s32(vget_low_s32(vreinterpretq_s32_m128i(a))));
+}
+
+// Sign extend packed 8-bit integers in a to packed 16-bit integers, and store
+// the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvtepi8_epi16
+FORCE_INLINE __m128i _mm_cvtepi8_epi16(__m128i a)
+{
+    int8x16_t s8x16 = vreinterpretq_s8_m128i(a);    /* xxxx xxxx xxxx DCBA */
+    int16x8_t s16x8 = vmovl_s8(vget_low_s8(s8x16)); /* 0x0x 0x0x 0D0C 0B0A */
+    return vreinterpretq_m128i_s16(s16x8);
+}
+
+// Sign extend packed 8-bit integers in a to packed 32-bit integers, and store
+// the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvtepi8_epi32
+FORCE_INLINE __m128i _mm_cvtepi8_epi32(__m128i a)
+{
+    int8x16_t s8x16 = vreinterpretq_s8_m128i(a);      /* xxxx xxxx xxxx DCBA */
+    int16x8_t s16x8 = vmovl_s8(vget_low_s8(s8x16));   /* 0x0x 0x0x 0D0C 0B0A */
+    int32x4_t s32x4 = vmovl_s16(vget_low_s16(s16x8)); /* 000D 000C 000B 000A */
+    return vreinterpretq_m128i_s32(s32x4);
+}
+
+// Sign extend packed 8-bit integers in the low 8 bytes of a to packed 64-bit
+// integers, and store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvtepi8_epi64
+FORCE_INLINE __m128i _mm_cvtepi8_epi64(__m128i a)
+{
+    int8x16_t s8x16 = vreinterpretq_s8_m128i(a);      /* xxxx xxxx xxxx xxBA */
+    int16x8_t s16x8 = vmovl_s8(vget_low_s8(s8x16));   /* 0x0x 0x0x 0x0x 0B0A */
+    int32x4_t s32x4 = vmovl_s16(vget_low_s16(s16x8)); /* 000x 000x 000B 000A */
+    int64x2_t s64x2 = vmovl_s32(vget_low_s32(s32x4)); /* 0000 000B 0000 000A */
+    return vreinterpretq_m128i_s64(s64x2);
+}
+
+// Zero extend packed unsigned 16-bit integers in a to packed 32-bit integers,
+// and store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvtepu16_epi32
+FORCE_INLINE __m128i _mm_cvtepu16_epi32(__m128i a)
+{
+    return vreinterpretq_m128i_u32(
+        vmovl_u16(vget_low_u16(vreinterpretq_u16_m128i(a))));
+}
+
+// Zero extend packed unsigned 16-bit integers in a to packed 64-bit integers,
+// and store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvtepu16_epi64
+FORCE_INLINE __m128i _mm_cvtepu16_epi64(__m128i a)
+{
+    uint16x8_t u16x8 = vreinterpretq_u16_m128i(a);     /* xxxx xxxx xxxx 0B0A */
+    uint32x4_t u32x4 = vmovl_u16(vget_low_u16(u16x8)); /* 000x 000x 000B 000A */
+    uint64x2_t u64x2 = vmovl_u32(vget_low_u32(u32x4)); /* 0000 000B 0000 000A */
+    return vreinterpretq_m128i_u64(u64x2);
+}
+
+// Zero extend packed unsigned 32-bit integers in a to packed 64-bit integers,
+// and store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvtepu32_epi64
+FORCE_INLINE __m128i _mm_cvtepu32_epi64(__m128i a)
+{
+    return vreinterpretq_m128i_u64(
+        vmovl_u32(vget_low_u32(vreinterpretq_u32_m128i(a))));
+}
+
+// Zero extend packed unsigned 8-bit integers in a to packed 16-bit integers,
+// and store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvtepu8_epi16
+FORCE_INLINE __m128i _mm_cvtepu8_epi16(__m128i a)
+{
+    uint8x16_t u8x16 = vreinterpretq_u8_m128i(a);    /* xxxx xxxx HGFE DCBA */
+    uint16x8_t u16x8 = vmovl_u8(vget_low_u8(u8x16)); /* 0H0G 0F0E 0D0C 0B0A */
+    return vreinterpretq_m128i_u16(u16x8);
+}
+
+// Zero extend packed unsigned 8-bit integers in a to packed 32-bit integers,
+// and store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvtepu8_epi32
+FORCE_INLINE __m128i _mm_cvtepu8_epi32(__m128i a)
+{
+    uint8x16_t u8x16 = vreinterpretq_u8_m128i(a);      /* xxxx xxxx xxxx DCBA */
+    uint16x8_t u16x8 = vmovl_u8(vget_low_u8(u8x16));   /* 0x0x 0x0x 0D0C 0B0A */
+    uint32x4_t u32x4 = vmovl_u16(vget_low_u16(u16x8)); /* 000D 000C 000B 000A */
+    return vreinterpretq_m128i_u32(u32x4);
+}
+
+// Zero extend packed unsigned 8-bit integers in the low 8 bytes of a to packed
+// 64-bit integers, and store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvtepu8_epi64
+FORCE_INLINE __m128i _mm_cvtepu8_epi64(__m128i a)
+{
+    uint8x16_t u8x16 = vreinterpretq_u8_m128i(a);      /* xxxx xxxx xxxx xxBA */
+    uint16x8_t u16x8 = vmovl_u8(vget_low_u8(u8x16));   /* 0x0x 0x0x 0x0x 0B0A */
+    uint32x4_t u32x4 = vmovl_u16(vget_low_u16(u16x8)); /* 000x 000x 000B 000A */
+    uint64x2_t u64x2 = vmovl_u32(vget_low_u32(u32x4)); /* 0000 000B 0000 000A */
+    return vreinterpretq_m128i_u64(u64x2);
+}
+
+// Conditionally multiply the packed double-precision (64-bit) floating-point
+// elements in a and b using the high 4 bits in imm8, sum the four products, and
+// conditionally store the sum in dst using the low 4 bits of imm8.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_dp_pd
+FORCE_INLINE __m128d _mm_dp_pd(__m128d a, __m128d b, const int imm)
+{
+    // Generate mask value from constant immediate bit value
+    const int64_t bit0Mask = imm & 0x01 ? UINT64_MAX : 0;
+    const int64_t bit1Mask = imm & 0x02 ? UINT64_MAX : 0;
+#if !SSE2NEON_PRECISE_DP
+    const int64_t bit4Mask = imm & 0x10 ? UINT64_MAX : 0;
+    const int64_t bit5Mask = imm & 0x20 ? UINT64_MAX : 0;
+#endif
+    // Conditional multiplication
+#if !SSE2NEON_PRECISE_DP
+    __m128d mul = _mm_mul_pd(a, b);
+    const __m128d mulMask =
+        _mm_castsi128_pd(_mm_set_epi64x(bit5Mask, bit4Mask));
+    __m128d tmp = _mm_and_pd(mul, mulMask);
+#else
+#if defined(__aarch64__) || defined(_M_ARM64)
+    double d0 = (imm & 0x10) ? vgetq_lane_f64(vreinterpretq_f64_m128d(a), 0) *
+                                   vgetq_lane_f64(vreinterpretq_f64_m128d(b), 0)
+                             : 0;
+    double d1 = (imm & 0x20) ? vgetq_lane_f64(vreinterpretq_f64_m128d(a), 1) *
+                                   vgetq_lane_f64(vreinterpretq_f64_m128d(b), 1)
+                             : 0;
+#else
+    double d0 = (imm & 0x10) ? ((double *) &a)[0] * ((double *) &b)[0] : 0;
+    double d1 = (imm & 0x20) ? ((double *) &a)[1] * ((double *) &b)[1] : 0;
+#endif
+    __m128d tmp = _mm_set_pd(d1, d0);
+#endif
+    // Sum the products
+#if defined(__aarch64__) || defined(_M_ARM64)
+    double sum = vpaddd_f64(vreinterpretq_f64_m128d(tmp));
+#else
+    double sum = *((double *) &tmp) + *(((double *) &tmp) + 1);
+#endif
+    // Conditionally store the sum
+    const __m128d sumMask =
+        _mm_castsi128_pd(_mm_set_epi64x(bit1Mask, bit0Mask));
+    __m128d res = _mm_and_pd(_mm_set_pd1(sum), sumMask);
+    return res;
+}
+
+// Conditionally multiply the packed single-precision (32-bit) floating-point
+// elements in a and b using the high 4 bits in imm8, sum the four products,
+// and conditionally store the sum in dst using the low 4 bits of imm.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_dp_ps
+FORCE_INLINE __m128 _mm_dp_ps(__m128 a, __m128 b, const int imm)
+{
+    float32x4_t elementwise_prod = _mm_mul_ps(a, b);
+
+#if defined(__aarch64__) || defined(_M_ARM64)
+    /* shortcuts */
+    if (imm == 0xFF) {
+        return _mm_set1_ps(vaddvq_f32(elementwise_prod));
+    }
+
+    if ((imm & 0x0F) == 0x0F) {
+        if (!(imm & (1 << 4)))
+            elementwise_prod = vsetq_lane_f32(0.0f, elementwise_prod, 0);
+        if (!(imm & (1 << 5)))
+            elementwise_prod = vsetq_lane_f32(0.0f, elementwise_prod, 1);
+        if (!(imm & (1 << 6)))
+            elementwise_prod = vsetq_lane_f32(0.0f, elementwise_prod, 2);
+        if (!(imm & (1 << 7)))
+            elementwise_prod = vsetq_lane_f32(0.0f, elementwise_prod, 3);
+
+        return _mm_set1_ps(vaddvq_f32(elementwise_prod));
+    }
+#endif
+
+    float s = 0.0f;
+
+    if (imm & (1 << 4))
+        s += vgetq_lane_f32(elementwise_prod, 0);
+    if (imm & (1 << 5))
+        s += vgetq_lane_f32(elementwise_prod, 1);
+    if (imm & (1 << 6))
+        s += vgetq_lane_f32(elementwise_prod, 2);
+    if (imm & (1 << 7))
+        s += vgetq_lane_f32(elementwise_prod, 3);
+
+    const float32_t res[4] = {
+        (imm & 0x1) ? s : 0.0f,
+        (imm & 0x2) ? s : 0.0f,
+        (imm & 0x4) ? s : 0.0f,
+        (imm & 0x8) ? s : 0.0f,
+    };
+    return vreinterpretq_m128_f32(vld1q_f32(res));
+}
+
+// Extract a 32-bit integer from a, selected with imm8, and store the result in
+// dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_extract_epi32
+// FORCE_INLINE int _mm_extract_epi32(__m128i a, __constrange(0,4) int imm)
+#define _mm_extract_epi32(a, imm) \
+    vgetq_lane_s32(vreinterpretq_s32_m128i(a), (imm))
+
+// Extract a 64-bit integer from a, selected with imm8, and store the result in
+// dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_extract_epi64
+// FORCE_INLINE __int64 _mm_extract_epi64(__m128i a, __constrange(0,2) int imm)
+#define _mm_extract_epi64(a, imm) \
+    vgetq_lane_s64(vreinterpretq_s64_m128i(a), (imm))
+
+// Extract an 8-bit integer from a, selected with imm8, and store the result in
+// the lower element of dst. FORCE_INLINE int _mm_extract_epi8(__m128i a,
+// __constrange(0,16) int imm)
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_extract_epi8
+#define _mm_extract_epi8(a, imm) vgetq_lane_u8(vreinterpretq_u8_m128i(a), (imm))
+
+// Extracts the selected single-precision (32-bit) floating-point from a.
+// FORCE_INLINE int _mm_extract_ps(__m128 a, __constrange(0,4) int imm)
+#define _mm_extract_ps(a, imm) vgetq_lane_s32(vreinterpretq_s32_m128(a), (imm))
+
+// Round the packed double-precision (64-bit) floating-point elements in a down
+// to an integer value, and store the results as packed double-precision
+// floating-point elements in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_floor_pd
+FORCE_INLINE __m128d _mm_floor_pd(__m128d a)
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+    return vreinterpretq_m128d_f64(vrndmq_f64(vreinterpretq_f64_m128d(a)));
+#else
+    double *f = (double *) &a;
+    return _mm_set_pd(floor(f[1]), floor(f[0]));
+#endif
+}
+
+// Round the packed single-precision (32-bit) floating-point elements in a down
+// to an integer value, and store the results as packed single-precision
+// floating-point elements in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_floor_ps
+FORCE_INLINE __m128 _mm_floor_ps(__m128 a)
+{
+#if (defined(__aarch64__) || defined(_M_ARM64)) || \
+    defined(__ARM_FEATURE_DIRECTED_ROUNDING)
+    return vreinterpretq_m128_f32(vrndmq_f32(vreinterpretq_f32_m128(a)));
+#else
+    float *f = (float *) &a;
+    return _mm_set_ps(floorf(f[3]), floorf(f[2]), floorf(f[1]), floorf(f[0]));
+#endif
+}
+
+// Round the lower double-precision (64-bit) floating-point element in b down to
+// an integer value, store the result as a double-precision floating-point
+// element in the lower element of dst, and copy the upper element from a to the
+// upper element of dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_floor_sd
+FORCE_INLINE __m128d _mm_floor_sd(__m128d a, __m128d b)
+{
+    return _mm_move_sd(a, _mm_floor_pd(b));
+}
+
+// Round the lower single-precision (32-bit) floating-point element in b down to
+// an integer value, store the result as a single-precision floating-point
+// element in the lower element of dst, and copy the upper 3 packed elements
+// from a to the upper elements of dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_floor_ss
+FORCE_INLINE __m128 _mm_floor_ss(__m128 a, __m128 b)
+{
+    return _mm_move_ss(a, _mm_floor_ps(b));
+}
+
+// Copy a to dst, and insert the 32-bit integer i into dst at the location
+// specified by imm8.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_insert_epi32
+// FORCE_INLINE __m128i _mm_insert_epi32(__m128i a, int b,
+//                                       __constrange(0,4) int imm)
+#define _mm_insert_epi32(a, b, imm) \
+    vreinterpretq_m128i_s32(        \
+        vsetq_lane_s32((b), vreinterpretq_s32_m128i(a), (imm)))
+
+// Copy a to dst, and insert the 64-bit integer i into dst at the location
+// specified by imm8.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_insert_epi64
+// FORCE_INLINE __m128i _mm_insert_epi64(__m128i a, __int64 b,
+//                                       __constrange(0,2) int imm)
+#define _mm_insert_epi64(a, b, imm) \
+    vreinterpretq_m128i_s64(        \
+        vsetq_lane_s64((b), vreinterpretq_s64_m128i(a), (imm)))
+
+// Copy a to dst, and insert the lower 8-bit integer from i into dst at the
+// location specified by imm8.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_insert_epi8
+// FORCE_INLINE __m128i _mm_insert_epi8(__m128i a, int b,
+//                                      __constrange(0,16) int imm)
+#define _mm_insert_epi8(a, b, imm) \
+    vreinterpretq_m128i_s8(vsetq_lane_s8((b), vreinterpretq_s8_m128i(a), (imm)))
+
+// Copy a to tmp, then insert a single-precision (32-bit) floating-point
+// element from b into tmp using the control in imm8. Store tmp to dst using
+// the mask in imm8 (elements are zeroed out when the corresponding bit is set).
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=insert_ps
+#define _mm_insert_ps(a, b, imm8)                                            \
+    _sse2neon_define2(                                                       \
+        __m128, a, b,                                                        \
+        float32x4_t tmp1 =                                                   \
+            vsetq_lane_f32(vgetq_lane_f32(_b, (imm8 >> 6) & 0x3),            \
+                           vreinterpretq_f32_m128(_a), 0);                   \
+        float32x4_t tmp2 =                                                   \
+            vsetq_lane_f32(vgetq_lane_f32(tmp1, 0),                          \
+                           vreinterpretq_f32_m128(_a), ((imm8 >> 4) & 0x3)); \
+        const uint32_t data[4] =                                             \
+            _sse2neon_init(((imm8) & (1 << 0)) ? UINT32_MAX : 0,             \
+                           ((imm8) & (1 << 1)) ? UINT32_MAX : 0,             \
+                           ((imm8) & (1 << 2)) ? UINT32_MAX : 0,             \
+                           ((imm8) & (1 << 3)) ? UINT32_MAX : 0);            \
+        uint32x4_t mask = vld1q_u32(data);                                   \
+        float32x4_t all_zeros = vdupq_n_f32(0);                              \
+                                                                             \
+        _sse2neon_return(vreinterpretq_m128_f32(                             \
+            vbslq_f32(mask, all_zeros, vreinterpretq_f32_m128(tmp2))));)
+
+// Compare packed signed 32-bit integers in a and b, and store packed maximum
+// values in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_max_epi32
+FORCE_INLINE __m128i _mm_max_epi32(__m128i a, __m128i b)
+{
+    return vreinterpretq_m128i_s32(
+        vmaxq_s32(vreinterpretq_s32_m128i(a), vreinterpretq_s32_m128i(b)));
+}
+
+// Compare packed signed 8-bit integers in a and b, and store packed maximum
+// values in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_max_epi8
+FORCE_INLINE __m128i _mm_max_epi8(__m128i a, __m128i b)
+{
+    return vreinterpretq_m128i_s8(
+        vmaxq_s8(vreinterpretq_s8_m128i(a), vreinterpretq_s8_m128i(b)));
+}
+
+// Compare packed unsigned 16-bit integers in a and b, and store packed maximum
+// values in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_max_epu16
+FORCE_INLINE __m128i _mm_max_epu16(__m128i a, __m128i b)
+{
+    return vreinterpretq_m128i_u16(
+        vmaxq_u16(vreinterpretq_u16_m128i(a), vreinterpretq_u16_m128i(b)));
+}
+
+// Compare packed unsigned 32-bit integers in a and b, and store packed maximum
+// values in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_max_epu32
+FORCE_INLINE __m128i _mm_max_epu32(__m128i a, __m128i b)
+{
+    return vreinterpretq_m128i_u32(
+        vmaxq_u32(vreinterpretq_u32_m128i(a), vreinterpretq_u32_m128i(b)));
+}
+
+// Compare packed signed 32-bit integers in a and b, and store packed minimum
+// values in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_min_epi32
+FORCE_INLINE __m128i _mm_min_epi32(__m128i a, __m128i b)
+{
+    return vreinterpretq_m128i_s32(
+        vminq_s32(vreinterpretq_s32_m128i(a), vreinterpretq_s32_m128i(b)));
+}
+
+// Compare packed signed 8-bit integers in a and b, and store packed minimum
+// values in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_min_epi8
+FORCE_INLINE __m128i _mm_min_epi8(__m128i a, __m128i b)
+{
+    return vreinterpretq_m128i_s8(
+        vminq_s8(vreinterpretq_s8_m128i(a), vreinterpretq_s8_m128i(b)));
+}
+
+// Compare packed unsigned 16-bit integers in a and b, and store packed minimum
+// values in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_min_epu16
+FORCE_INLINE __m128i _mm_min_epu16(__m128i a, __m128i b)
+{
+    return vreinterpretq_m128i_u16(
+        vminq_u16(vreinterpretq_u16_m128i(a), vreinterpretq_u16_m128i(b)));
+}
+
+// Compare packed unsigned 32-bit integers in a and b, and store packed minimum
+// values in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_max_epu32
+FORCE_INLINE __m128i _mm_min_epu32(__m128i a, __m128i b)
+{
+    return vreinterpretq_m128i_u32(
+        vminq_u32(vreinterpretq_u32_m128i(a), vreinterpretq_u32_m128i(b)));
+}
+
+// Horizontally compute the minimum amongst the packed unsigned 16-bit integers
+// in a, store the minimum and index in dst, and zero the remaining bits in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_minpos_epu16
+FORCE_INLINE __m128i _mm_minpos_epu16(__m128i a)
+{
+    __m128i dst;
+    uint16_t min, idx = 0;
+#if defined(__aarch64__) || defined(_M_ARM64)
+    // Find the minimum value
+    min = vminvq_u16(vreinterpretq_u16_m128i(a));
+
+    // Get the index of the minimum value
+    static const uint16_t idxv[] = {0, 1, 2, 3, 4, 5, 6, 7};
+    uint16x8_t minv = vdupq_n_u16(min);
+    uint16x8_t cmeq = vceqq_u16(minv, vreinterpretq_u16_m128i(a));
+    idx = vminvq_u16(vornq_u16(vld1q_u16(idxv), cmeq));
+#else
+    // Find the minimum value
+    __m64 tmp;
+    tmp = vreinterpret_m64_u16(
+        vmin_u16(vget_low_u16(vreinterpretq_u16_m128i(a)),
+                 vget_high_u16(vreinterpretq_u16_m128i(a))));
+    tmp = vreinterpret_m64_u16(
+        vpmin_u16(vreinterpret_u16_m64(tmp), vreinterpret_u16_m64(tmp)));
+    tmp = vreinterpret_m64_u16(
+        vpmin_u16(vreinterpret_u16_m64(tmp), vreinterpret_u16_m64(tmp)));
+    min = vget_lane_u16(vreinterpret_u16_m64(tmp), 0);
+    // Get the index of the minimum value
+    int i;
+    for (i = 0; i < 8; i++) {
+        if (min == vgetq_lane_u16(vreinterpretq_u16_m128i(a), 0)) {
+            idx = (uint16_t) i;
+            break;
+        }
+        a = _mm_srli_si128(a, 2);
+    }
+#endif
+    // Generate result
+    dst = _mm_setzero_si128();
+    dst = vreinterpretq_m128i_u16(
+        vsetq_lane_u16(min, vreinterpretq_u16_m128i(dst), 0));
+    dst = vreinterpretq_m128i_u16(
+        vsetq_lane_u16(idx, vreinterpretq_u16_m128i(dst), 1));
+    return dst;
+}
+
+// Compute the sum of absolute differences (SADs) of quadruplets of unsigned
+// 8-bit integers in a compared to those in b, and store the 16-bit results in
+// dst. Eight SADs are performed using one quadruplet from b and eight
+// quadruplets from a. One quadruplet is selected from b starting at on the
+// offset specified in imm8. Eight quadruplets are formed from sequential 8-bit
+// integers selected from a starting at the offset specified in imm8.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mpsadbw_epu8
+FORCE_INLINE __m128i _mm_mpsadbw_epu8(__m128i a, __m128i b, const int imm)
+{
+    uint8x16_t _a, _b;
+
+    switch (imm & 0x4) {
+    case 0:
+        // do nothing
+        _a = vreinterpretq_u8_m128i(a);
+        break;
+    case 4:
+        _a = vreinterpretq_u8_u32(vextq_u32(vreinterpretq_u32_m128i(a),
+                                            vreinterpretq_u32_m128i(a), 1));
+        break;
+    default:
+#if defined(__GNUC__) || defined(__clang__)
+        __builtin_unreachable();
+#elif defined(_MSC_VER)
+        __assume(0);
+#endif
+        break;
+    }
+
+    switch (imm & 0x3) {
+    case 0:
+        _b = vreinterpretq_u8_u32(
+            vdupq_n_u32(vgetq_lane_u32(vreinterpretq_u32_m128i(b), 0)));
+        break;
+    case 1:
+        _b = vreinterpretq_u8_u32(
+            vdupq_n_u32(vgetq_lane_u32(vreinterpretq_u32_m128i(b), 1)));
+        break;
+    case 2:
+        _b = vreinterpretq_u8_u32(
+            vdupq_n_u32(vgetq_lane_u32(vreinterpretq_u32_m128i(b), 2)));
+        break;
+    case 3:
+        _b = vreinterpretq_u8_u32(
+            vdupq_n_u32(vgetq_lane_u32(vreinterpretq_u32_m128i(b), 3)));
+        break;
+    default:
+#if defined(__GNUC__) || defined(__clang__)
+        __builtin_unreachable();
+#elif defined(_MSC_VER)
+        __assume(0);
+#endif
+        break;
+    }
+
+    int16x8_t c04, c15, c26, c37;
+    uint8x8_t low_b = vget_low_u8(_b);
+    c04 = vreinterpretq_s16_u16(vabdl_u8(vget_low_u8(_a), low_b));
+    uint8x16_t _a_1 = vextq_u8(_a, _a, 1);
+    c15 = vreinterpretq_s16_u16(vabdl_u8(vget_low_u8(_a_1), low_b));
+    uint8x16_t _a_2 = vextq_u8(_a, _a, 2);
+    c26 = vreinterpretq_s16_u16(vabdl_u8(vget_low_u8(_a_2), low_b));
+    uint8x16_t _a_3 = vextq_u8(_a, _a, 3);
+    c37 = vreinterpretq_s16_u16(vabdl_u8(vget_low_u8(_a_3), low_b));
+#if defined(__aarch64__) || defined(_M_ARM64)
+    // |0|4|2|6|
+    c04 = vpaddq_s16(c04, c26);
+    // |1|5|3|7|
+    c15 = vpaddq_s16(c15, c37);
+
+    int32x4_t trn1_c =
+        vtrn1q_s32(vreinterpretq_s32_s16(c04), vreinterpretq_s32_s16(c15));
+    int32x4_t trn2_c =
+        vtrn2q_s32(vreinterpretq_s32_s16(c04), vreinterpretq_s32_s16(c15));
+    return vreinterpretq_m128i_s16(vpaddq_s16(vreinterpretq_s16_s32(trn1_c),
+                                              vreinterpretq_s16_s32(trn2_c)));
+#else
+    int16x4_t c01, c23, c45, c67;
+    c01 = vpadd_s16(vget_low_s16(c04), vget_low_s16(c15));
+    c23 = vpadd_s16(vget_low_s16(c26), vget_low_s16(c37));
+    c45 = vpadd_s16(vget_high_s16(c04), vget_high_s16(c15));
+    c67 = vpadd_s16(vget_high_s16(c26), vget_high_s16(c37));
+
+    return vreinterpretq_m128i_s16(
+        vcombine_s16(vpadd_s16(c01, c23), vpadd_s16(c45, c67)));
+#endif
+}
+
+// Multiply the low signed 32-bit integers from each packed 64-bit element in
+// a and b, and store the signed 64-bit results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mul_epi32
+FORCE_INLINE __m128i _mm_mul_epi32(__m128i a, __m128i b)
+{
+    // vmull_s32 upcasts instead of masking, so we downcast.
+    int32x2_t a_lo = vmovn_s64(vreinterpretq_s64_m128i(a));
+    int32x2_t b_lo = vmovn_s64(vreinterpretq_s64_m128i(b));
+    return vreinterpretq_m128i_s64(vmull_s32(a_lo, b_lo));
+}
+
+// Multiply the packed 32-bit integers in a and b, producing intermediate 64-bit
+// integers, and store the low 32 bits of the intermediate integers in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mullo_epi32
+FORCE_INLINE __m128i _mm_mullo_epi32(__m128i a, __m128i b)
+{
+    return vreinterpretq_m128i_s32(
+        vmulq_s32(vreinterpretq_s32_m128i(a), vreinterpretq_s32_m128i(b)));
+}
+
+// Convert packed signed 32-bit integers from a and b to packed 16-bit integers
+// using unsigned saturation, and store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_packus_epi32
+FORCE_INLINE __m128i _mm_packus_epi32(__m128i a, __m128i b)
+{
+    return vreinterpretq_m128i_u16(
+        vcombine_u16(vqmovun_s32(vreinterpretq_s32_m128i(a)),
+                     vqmovun_s32(vreinterpretq_s32_m128i(b))));
+}
+
+// Round the packed double-precision (64-bit) floating-point elements in a using
+// the rounding parameter, and store the results as packed double-precision
+// floating-point elements in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_round_pd
+FORCE_INLINE __m128d _mm_round_pd(__m128d a, int rounding)
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+    switch (rounding) {
+    case (_MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC):
+        return vreinterpretq_m128d_f64(vrndnq_f64(vreinterpretq_f64_m128d(a)));
+    case (_MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC):
+        return _mm_floor_pd(a);
+    case (_MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC):
+        return _mm_ceil_pd(a);
+    case (_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC):
+        return vreinterpretq_m128d_f64(vrndq_f64(vreinterpretq_f64_m128d(a)));
+    default:  //_MM_FROUND_CUR_DIRECTION
+        return vreinterpretq_m128d_f64(vrndiq_f64(vreinterpretq_f64_m128d(a)));
+    }
+#else
+    double *v_double = (double *) &a;
+
+    if (rounding == (_MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC) ||
+        (rounding == _MM_FROUND_CUR_DIRECTION &&
+         _MM_GET_ROUNDING_MODE() == _MM_ROUND_NEAREST)) {
+        double res[2], tmp;
+        for (int i = 0; i < 2; i++) {
+            tmp = (v_double[i] < 0) ? -v_double[i] : v_double[i];
+            double roundDown = floor(tmp);  // Round down value
+            double roundUp = ceil(tmp);     // Round up value
+            double diffDown = tmp - roundDown;
+            double diffUp = roundUp - tmp;
+            if (diffDown < diffUp) {
+                /* If it's closer to the round down value, then use it */
+                res[i] = roundDown;
+            } else if (diffDown > diffUp) {
+                /* If it's closer to the round up value, then use it */
+                res[i] = roundUp;
+            } else {
+                /* If it's equidistant between round up and round down value,
+                 * pick the one which is an even number */
+                double half = roundDown / 2;
+                if (half != floor(half)) {
+                    /* If the round down value is odd, return the round up value
+                     */
+                    res[i] = roundUp;
+                } else {
+                    /* If the round up value is odd, return the round down value
+                     */
+                    res[i] = roundDown;
+                }
+            }
+            res[i] = (v_double[i] < 0) ? -res[i] : res[i];
+        }
+        return _mm_set_pd(res[1], res[0]);
+    } else if (rounding == (_MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC) ||
+               (rounding == _MM_FROUND_CUR_DIRECTION &&
+                _MM_GET_ROUNDING_MODE() == _MM_ROUND_DOWN)) {
+        return _mm_floor_pd(a);
+    } else if (rounding == (_MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC) ||
+               (rounding == _MM_FROUND_CUR_DIRECTION &&
+                _MM_GET_ROUNDING_MODE() == _MM_ROUND_UP)) {
+        return _mm_ceil_pd(a);
+    }
+    return _mm_set_pd(v_double[1] > 0 ? floor(v_double[1]) : ceil(v_double[1]),
+                      v_double[0] > 0 ? floor(v_double[0]) : ceil(v_double[0]));
+#endif
+}
+
+// Round the packed single-precision (32-bit) floating-point elements in a using
+// the rounding parameter, and store the results as packed single-precision
+// floating-point elements in dst.
+// software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_round_ps
+FORCE_INLINE __m128 _mm_round_ps(__m128 a, int rounding)
+{
+#if (defined(__aarch64__) || defined(_M_ARM64)) || \
+    defined(__ARM_FEATURE_DIRECTED_ROUNDING)
+    switch (rounding) {
+    case (_MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC):
+        return vreinterpretq_m128_f32(vrndnq_f32(vreinterpretq_f32_m128(a)));
+    case (_MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC):
+        return _mm_floor_ps(a);
+    case (_MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC):
+        return _mm_ceil_ps(a);
+    case (_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC):
+        return vreinterpretq_m128_f32(vrndq_f32(vreinterpretq_f32_m128(a)));
+    default:  //_MM_FROUND_CUR_DIRECTION
+        return vreinterpretq_m128_f32(vrndiq_f32(vreinterpretq_f32_m128(a)));
+    }
+#else
+    float *v_float = (float *) &a;
+
+    if (rounding == (_MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC) ||
+        (rounding == _MM_FROUND_CUR_DIRECTION &&
+         _MM_GET_ROUNDING_MODE() == _MM_ROUND_NEAREST)) {
+        uint32x4_t signmask = vdupq_n_u32(0x80000000);
+        float32x4_t half = vbslq_f32(signmask, vreinterpretq_f32_m128(a),
+                                     vdupq_n_f32(0.5f)); /* +/- 0.5 */
+        int32x4_t r_normal = vcvtq_s32_f32(vaddq_f32(
+            vreinterpretq_f32_m128(a), half)); /* round to integer: [a + 0.5]*/
+        int32x4_t r_trunc = vcvtq_s32_f32(
+            vreinterpretq_f32_m128(a)); /* truncate to integer: [a] */
+        int32x4_t plusone = vreinterpretq_s32_u32(vshrq_n_u32(
+            vreinterpretq_u32_s32(vnegq_s32(r_trunc)), 31)); /* 1 or 0 */
+        int32x4_t r_even = vbicq_s32(vaddq_s32(r_trunc, plusone),
+                                     vdupq_n_s32(1)); /* ([a] + {0,1}) & ~1 */
+        float32x4_t delta = vsubq_f32(
+            vreinterpretq_f32_m128(a),
+            vcvtq_f32_s32(r_trunc)); /* compute delta: delta = (a - [a]) */
+        uint32x4_t is_delta_half =
+            vceqq_f32(delta, half); /* delta == +/- 0.5 */
+        return vreinterpretq_m128_f32(
+            vcvtq_f32_s32(vbslq_s32(is_delta_half, r_even, r_normal)));
+    } else if (rounding == (_MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC) ||
+               (rounding == _MM_FROUND_CUR_DIRECTION &&
+                _MM_GET_ROUNDING_MODE() == _MM_ROUND_DOWN)) {
+        return _mm_floor_ps(a);
+    } else if (rounding == (_MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC) ||
+               (rounding == _MM_FROUND_CUR_DIRECTION &&
+                _MM_GET_ROUNDING_MODE() == _MM_ROUND_UP)) {
+        return _mm_ceil_ps(a);
+    }
+    return _mm_set_ps(v_float[3] > 0 ? floorf(v_float[3]) : ceilf(v_float[3]),
+                      v_float[2] > 0 ? floorf(v_float[2]) : ceilf(v_float[2]),
+                      v_float[1] > 0 ? floorf(v_float[1]) : ceilf(v_float[1]),
+                      v_float[0] > 0 ? floorf(v_float[0]) : ceilf(v_float[0]));
+#endif
+}
+
+// Round the lower double-precision (64-bit) floating-point element in b using
+// the rounding parameter, store the result as a double-precision floating-point
+// element in the lower element of dst, and copy the upper element from a to the
+// upper element of dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_round_sd
+FORCE_INLINE __m128d _mm_round_sd(__m128d a, __m128d b, int rounding)
+{
+    return _mm_move_sd(a, _mm_round_pd(b, rounding));
+}
+
+// Round the lower single-precision (32-bit) floating-point element in b using
+// the rounding parameter, store the result as a single-precision floating-point
+// element in the lower element of dst, and copy the upper 3 packed elements
+// from a to the upper elements of dst. Rounding is done according to the
+// rounding[3:0] parameter, which can be one of:
+//     (_MM_FROUND_TO_NEAREST_INT |_MM_FROUND_NO_EXC) // round to nearest, and
+//     suppress exceptions
+//     (_MM_FROUND_TO_NEG_INF |_MM_FROUND_NO_EXC)     // round down, and
+//     suppress exceptions
+//     (_MM_FROUND_TO_POS_INF |_MM_FROUND_NO_EXC)     // round up, and suppress
+//     exceptions
+//     (_MM_FROUND_TO_ZERO |_MM_FROUND_NO_EXC)        // truncate, and suppress
+//     exceptions _MM_FROUND_CUR_DIRECTION // use MXCSR.RC; see
+//     _MM_SET_ROUNDING_MODE
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_round_ss
+FORCE_INLINE __m128 _mm_round_ss(__m128 a, __m128 b, int rounding)
+{
+    return _mm_move_ss(a, _mm_round_ps(b, rounding));
+}
+
+// Load 128-bits of integer data from memory into dst using a non-temporal
+// memory hint. mem_addr must be aligned on a 16-byte boundary or a
+// general-protection exception may be generated.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_stream_load_si128
+FORCE_INLINE __m128i _mm_stream_load_si128(__m128i *p)
+{
+#if __has_builtin(__builtin_nontemporal_store)
+    return __builtin_nontemporal_load(p);
+#else
+    return vreinterpretq_m128i_s64(vld1q_s64((int64_t *) p));
+#endif
+}
+
+// Compute the bitwise NOT of a and then AND with a 128-bit vector containing
+// all 1's, and return 1 if the result is zero, otherwise return 0.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_test_all_ones
+FORCE_INLINE int _mm_test_all_ones(__m128i a)
+{
+    return (uint64_t) (vgetq_lane_s64(a, 0) & vgetq_lane_s64(a, 1)) ==
+           ~(uint64_t) 0;
+}
+
+// Compute the bitwise AND of 128 bits (representing integer data) in a and
+// mask, and return 1 if the result is zero, otherwise return 0.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_test_all_zeros
+FORCE_INLINE int _mm_test_all_zeros(__m128i a, __m128i mask)
+{
+    int64x2_t a_and_mask =
+        vandq_s64(vreinterpretq_s64_m128i(a), vreinterpretq_s64_m128i(mask));
+    return !(vgetq_lane_s64(a_and_mask, 0) | vgetq_lane_s64(a_and_mask, 1));
+}
+
+// Compute the bitwise AND of 128 bits (representing integer data) in a and
+// mask, and set ZF to 1 if the result is zero, otherwise set ZF to 0. Compute
+// the bitwise NOT of a and then AND with mask, and set CF to 1 if the result is
+// zero, otherwise set CF to 0. Return 1 if both the ZF and CF values are zero,
+// otherwise return 0.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=mm_test_mix_ones_zero
+// Note: Argument names may be wrong in the Intel intrinsics guide.
+FORCE_INLINE int _mm_test_mix_ones_zeros(__m128i a, __m128i mask)
+{
+    uint64x2_t v = vreinterpretq_u64_m128i(a);
+    uint64x2_t m = vreinterpretq_u64_m128i(mask);
+
+    // find ones (set-bits) and zeros (clear-bits) under clip mask
+    uint64x2_t ones = vandq_u64(m, v);
+    uint64x2_t zeros = vbicq_u64(m, v);
+
+    // If both 128-bit variables are populated (non-zero) then return 1.
+    // For comparision purposes, first compact each var down to 32-bits.
+    uint32x2_t reduced = vpmax_u32(vqmovn_u64(ones), vqmovn_u64(zeros));
+
+    // if folding minimum is non-zero then both vars must be non-zero
+    return (vget_lane_u32(vpmin_u32(reduced, reduced), 0) != 0);
+}
+
+// Compute the bitwise AND of 128 bits (representing integer data) in a and b,
+// and set ZF to 1 if the result is zero, otherwise set ZF to 0. Compute the
+// bitwise NOT of a and then AND with b, and set CF to 1 if the result is zero,
+// otherwise set CF to 0. Return the CF value.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_testc_si128
+FORCE_INLINE int _mm_testc_si128(__m128i a, __m128i b)
+{
+    int64x2_t s64 =
+        vbicq_s64(vreinterpretq_s64_m128i(b), vreinterpretq_s64_m128i(a));
+    return !(vgetq_lane_s64(s64, 0) | vgetq_lane_s64(s64, 1));
+}
+
+// Compute the bitwise AND of 128 bits (representing integer data) in a and b,
+// and set ZF to 1 if the result is zero, otherwise set ZF to 0. Compute the
+// bitwise NOT of a and then AND with b, and set CF to 1 if the result is zero,
+// otherwise set CF to 0. Return 1 if both the ZF and CF values are zero,
+// otherwise return 0.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_testnzc_si128
+#define _mm_testnzc_si128(a, b) _mm_test_mix_ones_zeros(a, b)
+
+// Compute the bitwise AND of 128 bits (representing integer data) in a and b,
+// and set ZF to 1 if the result is zero, otherwise set ZF to 0. Compute the
+// bitwise NOT of a and then AND with b, and set CF to 1 if the result is zero,
+// otherwise set CF to 0. Return the ZF value.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_testz_si128
+FORCE_INLINE int _mm_testz_si128(__m128i a, __m128i b)
+{
+    int64x2_t s64 =
+        vandq_s64(vreinterpretq_s64_m128i(a), vreinterpretq_s64_m128i(b));
+    return !(vgetq_lane_s64(s64, 0) | vgetq_lane_s64(s64, 1));
+}
+
+/* SSE4.2 */
+
+static const uint16_t ALIGN_STRUCT(16) _sse2neon_cmpestr_mask16b[8] = {
+    0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80,
+};
+static const uint8_t ALIGN_STRUCT(16) _sse2neon_cmpestr_mask8b[16] = {
+    0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80,
+    0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80,
+};
+
+/* specify the source data format */
+#define _SIDD_UBYTE_OPS 0x00 /* unsigned 8-bit characters */
+#define _SIDD_UWORD_OPS 0x01 /* unsigned 16-bit characters */
+#define _SIDD_SBYTE_OPS 0x02 /* signed 8-bit characters */
+#define _SIDD_SWORD_OPS 0x03 /* signed 16-bit characters */
+
+/* specify the comparison operation */
+#define _SIDD_CMP_EQUAL_ANY 0x00     /* compare equal any: strchr */
+#define _SIDD_CMP_RANGES 0x04        /* compare ranges */
+#define _SIDD_CMP_EQUAL_EACH 0x08    /* compare equal each: strcmp */
+#define _SIDD_CMP_EQUAL_ORDERED 0x0C /* compare equal ordered */
+
+/* specify the polarity */
+#define _SIDD_POSITIVE_POLARITY 0x00
+#define _SIDD_MASKED_POSITIVE_POLARITY 0x20
+#define _SIDD_NEGATIVE_POLARITY 0x10 /* negate results */
+#define _SIDD_MASKED_NEGATIVE_POLARITY \
+    0x30 /* negate results only before end of string */
+
+/* specify the output selection in _mm_cmpXstri */
+#define _SIDD_LEAST_SIGNIFICANT 0x00
+#define _SIDD_MOST_SIGNIFICANT 0x40
+
+/* specify the output selection in _mm_cmpXstrm */
+#define _SIDD_BIT_MASK 0x00
+#define _SIDD_UNIT_MASK 0x40
+
+/* Pattern Matching for C macros.
+ * https://github.com/pfultz2/Cloak/wiki/C-Preprocessor-tricks,-tips,-and-idioms
+ */
+
+/* catenate */
+#define SSE2NEON_PRIMITIVE_CAT(a, ...) a##__VA_ARGS__
+#define SSE2NEON_CAT(a, b) SSE2NEON_PRIMITIVE_CAT(a, b)
+
+#define SSE2NEON_IIF(c) SSE2NEON_PRIMITIVE_CAT(SSE2NEON_IIF_, c)
+/* run the 2nd parameter */
+#define SSE2NEON_IIF_0(t, ...) __VA_ARGS__
+/* run the 1st parameter */
+#define SSE2NEON_IIF_1(t, ...) t
+
+#define SSE2NEON_COMPL(b) SSE2NEON_PRIMITIVE_CAT(SSE2NEON_COMPL_, b)
+#define SSE2NEON_COMPL_0 1
+#define SSE2NEON_COMPL_1 0
+
+#define SSE2NEON_DEC(x) SSE2NEON_PRIMITIVE_CAT(SSE2NEON_DEC_, x)
+#define SSE2NEON_DEC_1 0
+#define SSE2NEON_DEC_2 1
+#define SSE2NEON_DEC_3 2
+#define SSE2NEON_DEC_4 3
+#define SSE2NEON_DEC_5 4
+#define SSE2NEON_DEC_6 5
+#define SSE2NEON_DEC_7 6
+#define SSE2NEON_DEC_8 7
+#define SSE2NEON_DEC_9 8
+#define SSE2NEON_DEC_10 9
+#define SSE2NEON_DEC_11 10
+#define SSE2NEON_DEC_12 11
+#define SSE2NEON_DEC_13 12
+#define SSE2NEON_DEC_14 13
+#define SSE2NEON_DEC_15 14
+#define SSE2NEON_DEC_16 15
+
+/* detection */
+#define SSE2NEON_CHECK_N(x, n, ...) n
+#define SSE2NEON_CHECK(...) SSE2NEON_CHECK_N(__VA_ARGS__, 0, )
+#define SSE2NEON_PROBE(x) x, 1,
+
+#define SSE2NEON_NOT(x) SSE2NEON_CHECK(SSE2NEON_PRIMITIVE_CAT(SSE2NEON_NOT_, x))
+#define SSE2NEON_NOT_0 SSE2NEON_PROBE(~)
+
+#define SSE2NEON_BOOL(x) SSE2NEON_COMPL(SSE2NEON_NOT(x))
+#define SSE2NEON_IF(c) SSE2NEON_IIF(SSE2NEON_BOOL(c))
+
+#define SSE2NEON_EAT(...)
+#define SSE2NEON_EXPAND(...) __VA_ARGS__
+#define SSE2NEON_WHEN(c) SSE2NEON_IF(c)(SSE2NEON_EXPAND, SSE2NEON_EAT)
+
+/* recursion */
+/* deferred expression */
+#define SSE2NEON_EMPTY()
+#define SSE2NEON_DEFER(id) id SSE2NEON_EMPTY()
+#define SSE2NEON_OBSTRUCT(...) __VA_ARGS__ SSE2NEON_DEFER(SSE2NEON_EMPTY)()
+#define SSE2NEON_EXPAND(...) __VA_ARGS__
+
+#define SSE2NEON_EVAL(...) \
+    SSE2NEON_EVAL1(SSE2NEON_EVAL1(SSE2NEON_EVAL1(__VA_ARGS__)))
+#define SSE2NEON_EVAL1(...) \
+    SSE2NEON_EVAL2(SSE2NEON_EVAL2(SSE2NEON_EVAL2(__VA_ARGS__)))
+#define SSE2NEON_EVAL2(...) \
+    SSE2NEON_EVAL3(SSE2NEON_EVAL3(SSE2NEON_EVAL3(__VA_ARGS__)))
+#define SSE2NEON_EVAL3(...) __VA_ARGS__
+
+#define SSE2NEON_REPEAT(count, macro, ...)                         \
+    SSE2NEON_WHEN(count)                                           \
+    (SSE2NEON_OBSTRUCT(SSE2NEON_REPEAT_INDIRECT)()(                \
+        SSE2NEON_DEC(count), macro,                                \
+        __VA_ARGS__) SSE2NEON_OBSTRUCT(macro)(SSE2NEON_DEC(count), \
+                                              __VA_ARGS__))
+#define SSE2NEON_REPEAT_INDIRECT() SSE2NEON_REPEAT
+
+#define SSE2NEON_SIZE_OF_byte 8
+#define SSE2NEON_NUMBER_OF_LANES_byte 16
+#define SSE2NEON_SIZE_OF_word 16
+#define SSE2NEON_NUMBER_OF_LANES_word 8
+
+#define SSE2NEON_COMPARE_EQUAL_THEN_FILL_LANE(i, type)                         \
+    mtx[i] = vreinterpretq_m128i_##type(vceqq_##type(                          \
+        vdupq_n_##type(vgetq_lane_##type(vreinterpretq_##type##_m128i(b), i)), \
+        vreinterpretq_##type##_m128i(a)));
+
+#define SSE2NEON_FILL_LANE(i, type) \
+    vec_b[i] =                      \
+        vdupq_n_##type(vgetq_lane_##type(vreinterpretq_##type##_m128i(b), i));
+
+#define PCMPSTR_RANGES(a, b, mtx, data_type_prefix, type_prefix, size,        \
+                       number_of_lanes, byte_or_word)                         \
+    do {                                                                      \
+        SSE2NEON_CAT(                                                         \
+            data_type_prefix,                                                 \
+            SSE2NEON_CAT(size,                                                \
+                         SSE2NEON_CAT(x, SSE2NEON_CAT(number_of_lanes, _t)))) \
+        vec_b[number_of_lanes];                                               \
+        __m128i mask = SSE2NEON_IIF(byte_or_word)(                            \
+            vreinterpretq_m128i_u16(vdupq_n_u16(0xff)),                       \
+            vreinterpretq_m128i_u32(vdupq_n_u32(0xffff)));                    \
+        SSE2NEON_EVAL(SSE2NEON_REPEAT(number_of_lanes, SSE2NEON_FILL_LANE,    \
+                                      SSE2NEON_CAT(type_prefix, size)))       \
+        for (int i = 0; i < number_of_lanes; i++) {                           \
+            mtx[i] = SSE2NEON_CAT(vreinterpretq_m128i_u,                      \
+                                  size)(SSE2NEON_CAT(vbslq_u, size)(          \
+                SSE2NEON_CAT(vreinterpretq_u,                                 \
+                             SSE2NEON_CAT(size, _m128i))(mask),               \
+                SSE2NEON_CAT(vcgeq_, SSE2NEON_CAT(type_prefix, size))(        \
+                    vec_b[i],                                                 \
+                    SSE2NEON_CAT(                                             \
+                        vreinterpretq_,                                       \
+                        SSE2NEON_CAT(type_prefix,                             \
+                                     SSE2NEON_CAT(size, _m128i(a))))),        \
+                SSE2NEON_CAT(vcleq_, SSE2NEON_CAT(type_prefix, size))(        \
+                    vec_b[i],                                                 \
+                    SSE2NEON_CAT(                                             \
+                        vreinterpretq_,                                       \
+                        SSE2NEON_CAT(type_prefix,                             \
+                                     SSE2NEON_CAT(size, _m128i(a)))))));      \
+        }                                                                     \
+    } while (0)
+
+#define PCMPSTR_EQ(a, b, mtx, size, number_of_lanes)                         \
+    do {                                                                     \
+        SSE2NEON_EVAL(SSE2NEON_REPEAT(number_of_lanes,                       \
+                                      SSE2NEON_COMPARE_EQUAL_THEN_FILL_LANE, \
+                                      SSE2NEON_CAT(u, size)))                \
+    } while (0)
+
+#define SSE2NEON_CMP_EQUAL_ANY_IMPL(type)                                     \
+    static int _sse2neon_cmp_##type##_equal_any(__m128i a, int la, __m128i b, \
+                                                int lb)                       \
+    {                                                                         \
+        __m128i mtx[16];                                                      \
+        PCMPSTR_EQ(a, b, mtx, SSE2NEON_CAT(SSE2NEON_SIZE_OF_, type),          \
+                   SSE2NEON_CAT(SSE2NEON_NUMBER_OF_LANES_, type));            \
+        return SSE2NEON_CAT(                                                  \
+            _sse2neon_aggregate_equal_any_,                                   \
+            SSE2NEON_CAT(                                                     \
+                SSE2NEON_CAT(SSE2NEON_SIZE_OF_, type),                        \
+                SSE2NEON_CAT(x, SSE2NEON_CAT(SSE2NEON_NUMBER_OF_LANES_,       \
+                                             type))))(la, lb, mtx);           \
+    }
+
+#define SSE2NEON_CMP_RANGES_IMPL(type, data_type, us, byte_or_word)            \
+    static int _sse2neon_cmp_##us##type##_ranges(__m128i a, int la, __m128i b, \
+                                                 int lb)                       \
+    {                                                                          \
+        __m128i mtx[16];                                                       \
+        PCMPSTR_RANGES(                                                        \
+            a, b, mtx, data_type, us, SSE2NEON_CAT(SSE2NEON_SIZE_OF_, type),   \
+            SSE2NEON_CAT(SSE2NEON_NUMBER_OF_LANES_, type), byte_or_word);      \
+        return SSE2NEON_CAT(                                                   \
+            _sse2neon_aggregate_ranges_,                                       \
+            SSE2NEON_CAT(                                                      \
+                SSE2NEON_CAT(SSE2NEON_SIZE_OF_, type),                         \
+                SSE2NEON_CAT(x, SSE2NEON_CAT(SSE2NEON_NUMBER_OF_LANES_,        \
+                                             type))))(la, lb, mtx);            \
+    }
+
+#define SSE2NEON_CMP_EQUAL_ORDERED_IMPL(type)                                  \
+    static int _sse2neon_cmp_##type##_equal_ordered(__m128i a, int la,         \
+                                                    __m128i b, int lb)         \
+    {                                                                          \
+        __m128i mtx[16];                                                       \
+        PCMPSTR_EQ(a, b, mtx, SSE2NEON_CAT(SSE2NEON_SIZE_OF_, type),           \
+                   SSE2NEON_CAT(SSE2NEON_NUMBER_OF_LANES_, type));             \
+        return SSE2NEON_CAT(                                                   \
+            _sse2neon_aggregate_equal_ordered_,                                \
+            SSE2NEON_CAT(                                                      \
+                SSE2NEON_CAT(SSE2NEON_SIZE_OF_, type),                         \
+                SSE2NEON_CAT(x,                                                \
+                             SSE2NEON_CAT(SSE2NEON_NUMBER_OF_LANES_, type))))( \
+            SSE2NEON_CAT(SSE2NEON_NUMBER_OF_LANES_, type), la, lb, mtx);       \
+    }
+
+static int _sse2neon_aggregate_equal_any_8x16(int la, int lb, __m128i mtx[16])
+{
+    int res = 0;
+    int m = (1 << la) - 1;
+    uint8x8_t vec_mask = vld1_u8(_sse2neon_cmpestr_mask8b);
+    uint8x8_t t_lo = vtst_u8(vdup_n_u8(m & 0xff), vec_mask);
+    uint8x8_t t_hi = vtst_u8(vdup_n_u8(m >> 8), vec_mask);
+    uint8x16_t vec = vcombine_u8(t_lo, t_hi);
+    for (int j = 0; j < lb; j++) {
+        mtx[j] = vreinterpretq_m128i_u8(
+            vandq_u8(vec, vreinterpretq_u8_m128i(mtx[j])));
+        mtx[j] = vreinterpretq_m128i_u8(
+            vshrq_n_u8(vreinterpretq_u8_m128i(mtx[j]), 7));
+        int tmp = _sse2neon_vaddvq_u8(vreinterpretq_u8_m128i(mtx[j])) ? 1 : 0;
+        res |= (tmp << j);
+    }
+    return res;
+}
+
+static int _sse2neon_aggregate_equal_any_16x8(int la, int lb, __m128i mtx[16])
+{
+    int res = 0;
+    int m = (1 << la) - 1;
+    uint16x8_t vec =
+        vtstq_u16(vdupq_n_u16(m), vld1q_u16(_sse2neon_cmpestr_mask16b));
+    for (int j = 0; j < lb; j++) {
+        mtx[j] = vreinterpretq_m128i_u16(
+            vandq_u16(vec, vreinterpretq_u16_m128i(mtx[j])));
+        mtx[j] = vreinterpretq_m128i_u16(
+            vshrq_n_u16(vreinterpretq_u16_m128i(mtx[j]), 15));
+        int tmp = _sse2neon_vaddvq_u16(vreinterpretq_u16_m128i(mtx[j])) ? 1 : 0;
+        res |= (tmp << j);
+    }
+    return res;
+}
+
+/* clang-format off */
+#define SSE2NEON_GENERATE_CMP_EQUAL_ANY(prefix) \
+    prefix##IMPL(byte) \
+    prefix##IMPL(word)
+/* clang-format on */
+
+SSE2NEON_GENERATE_CMP_EQUAL_ANY(SSE2NEON_CMP_EQUAL_ANY_)
+
+static int _sse2neon_aggregate_ranges_16x8(int la, int lb, __m128i mtx[16])
+{
+    int res = 0;
+    int m = (1 << la) - 1;
+    uint16x8_t vec =
+        vtstq_u16(vdupq_n_u16(m), vld1q_u16(_sse2neon_cmpestr_mask16b));
+    for (int j = 0; j < lb; j++) {
+        mtx[j] = vreinterpretq_m128i_u16(
+            vandq_u16(vec, vreinterpretq_u16_m128i(mtx[j])));
+        mtx[j] = vreinterpretq_m128i_u16(
+            vshrq_n_u16(vreinterpretq_u16_m128i(mtx[j]), 15));
+        __m128i tmp = vreinterpretq_m128i_u32(
+            vshrq_n_u32(vreinterpretq_u32_m128i(mtx[j]), 16));
+        uint32x4_t vec_res = vandq_u32(vreinterpretq_u32_m128i(mtx[j]),
+                                       vreinterpretq_u32_m128i(tmp));
+#if defined(__aarch64__) || defined(_M_ARM64)
+        int t = vaddvq_u32(vec_res) ? 1 : 0;
+#else
+        uint64x2_t sumh = vpaddlq_u32(vec_res);
+        int t = vgetq_lane_u64(sumh, 0) + vgetq_lane_u64(sumh, 1);
+#endif
+        res |= (t << j);
+    }
+    return res;
+}
+
+static int _sse2neon_aggregate_ranges_8x16(int la, int lb, __m128i mtx[16])
+{
+    int res = 0;
+    int m = (1 << la) - 1;
+    uint8x8_t vec_mask = vld1_u8(_sse2neon_cmpestr_mask8b);
+    uint8x8_t t_lo = vtst_u8(vdup_n_u8(m & 0xff), vec_mask);
+    uint8x8_t t_hi = vtst_u8(vdup_n_u8(m >> 8), vec_mask);
+    uint8x16_t vec = vcombine_u8(t_lo, t_hi);
+    for (int j = 0; j < lb; j++) {
+        mtx[j] = vreinterpretq_m128i_u8(
+            vandq_u8(vec, vreinterpretq_u8_m128i(mtx[j])));
+        mtx[j] = vreinterpretq_m128i_u8(
+            vshrq_n_u8(vreinterpretq_u8_m128i(mtx[j]), 7));
+        __m128i tmp = vreinterpretq_m128i_u16(
+            vshrq_n_u16(vreinterpretq_u16_m128i(mtx[j]), 8));
+        uint16x8_t vec_res = vandq_u16(vreinterpretq_u16_m128i(mtx[j]),
+                                       vreinterpretq_u16_m128i(tmp));
+        int t = _sse2neon_vaddvq_u16(vec_res) ? 1 : 0;
+        res |= (t << j);
+    }
+    return res;
+}
+
+#define SSE2NEON_CMP_RANGES_IS_BYTE 1
+#define SSE2NEON_CMP_RANGES_IS_WORD 0
+
+/* clang-format off */
+#define SSE2NEON_GENERATE_CMP_RANGES(prefix)             \
+    prefix##IMPL(byte, uint, u, prefix##IS_BYTE)         \
+    prefix##IMPL(byte, int, s, prefix##IS_BYTE)          \
+    prefix##IMPL(word, uint, u, prefix##IS_WORD)         \
+    prefix##IMPL(word, int, s, prefix##IS_WORD)
+/* clang-format on */
+
+SSE2NEON_GENERATE_CMP_RANGES(SSE2NEON_CMP_RANGES_)
+
+#undef SSE2NEON_CMP_RANGES_IS_BYTE
+#undef SSE2NEON_CMP_RANGES_IS_WORD
+
+static int _sse2neon_cmp_byte_equal_each(__m128i a, int la, __m128i b, int lb)
+{
+    uint8x16_t mtx =
+        vceqq_u8(vreinterpretq_u8_m128i(a), vreinterpretq_u8_m128i(b));
+    int m0 = (la < lb) ? 0 : ((1 << la) - (1 << lb));
+    int m1 = 0x10000 - (1 << la);
+    int tb = 0x10000 - (1 << lb);
+    uint8x8_t vec_mask, vec0_lo, vec0_hi, vec1_lo, vec1_hi;
+    uint8x8_t tmp_lo, tmp_hi, res_lo, res_hi;
+    vec_mask = vld1_u8(_sse2neon_cmpestr_mask8b);
+    vec0_lo = vtst_u8(vdup_n_u8(m0), vec_mask);
+    vec0_hi = vtst_u8(vdup_n_u8(m0 >> 8), vec_mask);
+    vec1_lo = vtst_u8(vdup_n_u8(m1), vec_mask);
+    vec1_hi = vtst_u8(vdup_n_u8(m1 >> 8), vec_mask);
+    tmp_lo = vtst_u8(vdup_n_u8(tb), vec_mask);
+    tmp_hi = vtst_u8(vdup_n_u8(tb >> 8), vec_mask);
+
+    res_lo = vbsl_u8(vec0_lo, vdup_n_u8(0), vget_low_u8(mtx));
+    res_hi = vbsl_u8(vec0_hi, vdup_n_u8(0), vget_high_u8(mtx));
+    res_lo = vbsl_u8(vec1_lo, tmp_lo, res_lo);
+    res_hi = vbsl_u8(vec1_hi, tmp_hi, res_hi);
+    res_lo = vand_u8(res_lo, vec_mask);
+    res_hi = vand_u8(res_hi, vec_mask);
+
+    int res = _sse2neon_vaddv_u8(res_lo) + (_sse2neon_vaddv_u8(res_hi) << 8);
+    return res;
+}
+
+static int _sse2neon_cmp_word_equal_each(__m128i a, int la, __m128i b, int lb)
+{
+    uint16x8_t mtx =
+        vceqq_u16(vreinterpretq_u16_m128i(a), vreinterpretq_u16_m128i(b));
+    int m0 = (la < lb) ? 0 : ((1 << la) - (1 << lb));
+    int m1 = 0x100 - (1 << la);
+    int tb = 0x100 - (1 << lb);
+    uint16x8_t vec_mask = vld1q_u16(_sse2neon_cmpestr_mask16b);
+    uint16x8_t vec0 = vtstq_u16(vdupq_n_u16(m0), vec_mask);
+    uint16x8_t vec1 = vtstq_u16(vdupq_n_u16(m1), vec_mask);
+    uint16x8_t tmp = vtstq_u16(vdupq_n_u16(tb), vec_mask);
+    mtx = vbslq_u16(vec0, vdupq_n_u16(0), mtx);
+    mtx = vbslq_u16(vec1, tmp, mtx);
+    mtx = vandq_u16(mtx, vec_mask);
+    return _sse2neon_vaddvq_u16(mtx);
+}
+
+#define SSE2NEON_AGGREGATE_EQUAL_ORDER_IS_UBYTE 1
+#define SSE2NEON_AGGREGATE_EQUAL_ORDER_IS_UWORD 0
+
+#define SSE2NEON_AGGREGATE_EQUAL_ORDER_IMPL(size, number_of_lanes, data_type)  \
+    static int _sse2neon_aggregate_equal_ordered_##size##x##number_of_lanes(   \
+        int bound, int la, int lb, __m128i mtx[16])                            \
+    {                                                                          \
+        int res = 0;                                                           \
+        int m1 = SSE2NEON_IIF(data_type)(0x10000, 0x100) - (1 << la);          \
+        uint##size##x8_t vec_mask = SSE2NEON_IIF(data_type)(                   \
+            vld1_u##size(_sse2neon_cmpestr_mask##size##b),                     \
+            vld1q_u##size(_sse2neon_cmpestr_mask##size##b));                   \
+        uint##size##x##number_of_lanes##_t vec1 = SSE2NEON_IIF(data_type)(     \
+            vcombine_u##size(vtst_u##size(vdup_n_u##size(m1), vec_mask),       \
+                             vtst_u##size(vdup_n_u##size(m1 >> 8), vec_mask)), \
+            vtstq_u##size(vdupq_n_u##size(m1), vec_mask));                     \
+        uint##size##x##number_of_lanes##_t vec_minusone = vdupq_n_u##size(-1); \
+        uint##size##x##number_of_lanes##_t vec_zero = vdupq_n_u##size(0);      \
+        for (int j = 0; j < lb; j++) {                                         \
+            mtx[j] = vreinterpretq_m128i_u##size(vbslq_u##size(                \
+                vec1, vec_minusone, vreinterpretq_u##size##_m128i(mtx[j])));   \
+        }                                                                      \
+        for (int j = lb; j < bound; j++) {                                     \
+            mtx[j] = vreinterpretq_m128i_u##size(                              \
+                vbslq_u##size(vec1, vec_minusone, vec_zero));                  \
+        }                                                                      \
+        unsigned SSE2NEON_IIF(data_type)(char, short) *ptr =                   \
+            (unsigned SSE2NEON_IIF(data_type)(char, short) *) mtx;             \
+        for (int i = 0; i < bound; i++) {                                      \
+            int val = 1;                                                       \
+            for (int j = 0, k = i; j < bound - i && k < bound; j++, k++)       \
+                val &= ptr[k * bound + j];                                     \
+            res += val << i;                                                   \
+        }                                                                      \
+        return res;                                                            \
+    }
+
+/* clang-format off */
+#define SSE2NEON_GENERATE_AGGREGATE_EQUAL_ORDER(prefix) \
+    prefix##IMPL(8, 16, prefix##IS_UBYTE)               \
+    prefix##IMPL(16, 8, prefix##IS_UWORD)
+/* clang-format on */
+
+SSE2NEON_GENERATE_AGGREGATE_EQUAL_ORDER(SSE2NEON_AGGREGATE_EQUAL_ORDER_)
+
+#undef SSE2NEON_AGGREGATE_EQUAL_ORDER_IS_UBYTE
+#undef SSE2NEON_AGGREGATE_EQUAL_ORDER_IS_UWORD
+
+/* clang-format off */
+#define SSE2NEON_GENERATE_CMP_EQUAL_ORDERED(prefix) \
+    prefix##IMPL(byte)                              \
+    prefix##IMPL(word)
+/* clang-format on */
+
+SSE2NEON_GENERATE_CMP_EQUAL_ORDERED(SSE2NEON_CMP_EQUAL_ORDERED_)
+
+#define SSE2NEON_CMPESTR_LIST                          \
+    _(CMP_UBYTE_EQUAL_ANY, cmp_byte_equal_any)         \
+    _(CMP_UWORD_EQUAL_ANY, cmp_word_equal_any)         \
+    _(CMP_SBYTE_EQUAL_ANY, cmp_byte_equal_any)         \
+    _(CMP_SWORD_EQUAL_ANY, cmp_word_equal_any)         \
+    _(CMP_UBYTE_RANGES, cmp_ubyte_ranges)              \
+    _(CMP_UWORD_RANGES, cmp_uword_ranges)              \
+    _(CMP_SBYTE_RANGES, cmp_sbyte_ranges)              \
+    _(CMP_SWORD_RANGES, cmp_sword_ranges)              \
+    _(CMP_UBYTE_EQUAL_EACH, cmp_byte_equal_each)       \
+    _(CMP_UWORD_EQUAL_EACH, cmp_word_equal_each)       \
+    _(CMP_SBYTE_EQUAL_EACH, cmp_byte_equal_each)       \
+    _(CMP_SWORD_EQUAL_EACH, cmp_word_equal_each)       \
+    _(CMP_UBYTE_EQUAL_ORDERED, cmp_byte_equal_ordered) \
+    _(CMP_UWORD_EQUAL_ORDERED, cmp_word_equal_ordered) \
+    _(CMP_SBYTE_EQUAL_ORDERED, cmp_byte_equal_ordered) \
+    _(CMP_SWORD_EQUAL_ORDERED, cmp_word_equal_ordered)
+
+enum {
+#define _(name, func_suffix) name,
+    SSE2NEON_CMPESTR_LIST
+#undef _
+};
+typedef int (*cmpestr_func_t)(__m128i a, int la, __m128i b, int lb);
+static cmpestr_func_t _sse2neon_cmpfunc_table[] = {
+#define _(name, func_suffix) _sse2neon_##func_suffix,
+    SSE2NEON_CMPESTR_LIST
+#undef _
+};
+
+FORCE_INLINE int _sse2neon_sido_negative(int res, int lb, int imm8, int bound)
+{
+    switch (imm8 & 0x30) {
+    case _SIDD_NEGATIVE_POLARITY:
+        res ^= 0xffffffff;
+        break;
+    case _SIDD_MASKED_NEGATIVE_POLARITY:
+        res ^= (1 << lb) - 1;
+        break;
+    default:
+        break;
+    }
+
+    return res & ((bound == 8) ? 0xFF : 0xFFFF);
+}
+
+FORCE_INLINE int _sse2neon_clz(unsigned int x)
+{
+#ifdef _MSC_VER
+    unsigned long cnt = 0;
+    if (_BitScanReverse(&cnt, x))
+        return 31 - cnt;
+    return 32;
+#else
+    return x != 0 ? __builtin_clz(x) : 32;
+#endif
+}
+
+FORCE_INLINE int _sse2neon_ctz(unsigned int x)
+{
+#ifdef _MSC_VER
+    unsigned long cnt = 0;
+    if (_BitScanForward(&cnt, x))
+        return cnt;
+    return 32;
+#else
+    return x != 0 ? __builtin_ctz(x) : 32;
+#endif
+}
+
+FORCE_INLINE int _sse2neon_ctzll(unsigned long long x)
+{
+#ifdef _MSC_VER
+    unsigned long cnt;
+#if defined(SSE2NEON_HAS_BITSCAN64)
+    if (_BitScanForward64(&cnt, x))
+        return (int) (cnt);
+#else
+    if (_BitScanForward(&cnt, (unsigned long) (x)))
+        return (int) cnt;
+    if (_BitScanForward(&cnt, (unsigned long) (x >> 32)))
+        return (int) (cnt + 32);
+#endif /* SSE2NEON_HAS_BITSCAN64 */
+    return 64;
+#else /* assume GNU compatible compilers */
+    return x != 0 ? __builtin_ctzll(x) : 64;
+#endif
+}
+
+#define SSE2NEON_MIN(x, y) (x) < (y) ? (x) : (y)
+
+#define SSE2NEON_CMPSTR_SET_UPPER(var, imm) \
+    const int var = (imm & 0x01) ? 8 : 16
+
+#define SSE2NEON_CMPESTRX_LEN_PAIR(a, b, la, lb) \
+    int tmp1 = la ^ (la >> 31);                  \
+    la = tmp1 - (la >> 31);                      \
+    int tmp2 = lb ^ (lb >> 31);                  \
+    lb = tmp2 - (lb >> 31);                      \
+    la = SSE2NEON_MIN(la, bound);                \
+    lb = SSE2NEON_MIN(lb, bound)
+
+// Compare all pairs of character in string a and b,
+// then aggregate the result.
+// As the only difference of PCMPESTR* and PCMPISTR* is the way to calculate the
+// length of string, we use SSE2NEON_CMP{I,E}STRX_GET_LEN to get the length of
+// string a and b.
+#define SSE2NEON_COMP_AGG(a, b, la, lb, imm8, IE)                  \
+    SSE2NEON_CMPSTR_SET_UPPER(bound, imm8);                        \
+    SSE2NEON_##IE##_LEN_PAIR(a, b, la, lb);                        \
+    int r2 = (_sse2neon_cmpfunc_table[imm8 & 0x0f])(a, la, b, lb); \
+    r2 = _sse2neon_sido_negative(r2, lb, imm8, bound)
+
+#define SSE2NEON_CMPSTR_GENERATE_INDEX(r2, bound, imm8)          \
+    return (r2 == 0) ? bound                                     \
+                     : ((imm8 & 0x40) ? (31 - _sse2neon_clz(r2)) \
+                                      : _sse2neon_ctz(r2))
+
+#define SSE2NEON_CMPSTR_GENERATE_MASK(dst)                                     \
+    __m128i dst = vreinterpretq_m128i_u8(vdupq_n_u8(0));                       \
+    if (imm8 & 0x40) {                                                         \
+        if (bound == 8) {                                                      \
+            uint16x8_t tmp = vtstq_u16(vdupq_n_u16(r2),                        \
+                                       vld1q_u16(_sse2neon_cmpestr_mask16b));  \
+            dst = vreinterpretq_m128i_u16(vbslq_u16(                           \
+                tmp, vdupq_n_u16(-1), vreinterpretq_u16_m128i(dst)));          \
+        } else {                                                               \
+            uint8x16_t vec_r2 =                                                \
+                vcombine_u8(vdup_n_u8(r2), vdup_n_u8(r2 >> 8));                \
+            uint8x16_t tmp =                                                   \
+                vtstq_u8(vec_r2, vld1q_u8(_sse2neon_cmpestr_mask8b));          \
+            dst = vreinterpretq_m128i_u8(                                      \
+                vbslq_u8(tmp, vdupq_n_u8(-1), vreinterpretq_u8_m128i(dst)));   \
+        }                                                                      \
+    } else {                                                                   \
+        if (bound == 16) {                                                     \
+            dst = vreinterpretq_m128i_u16(                                     \
+                vsetq_lane_u16(r2 & 0xffff, vreinterpretq_u16_m128i(dst), 0)); \
+        } else {                                                               \
+            dst = vreinterpretq_m128i_u8(                                      \
+                vsetq_lane_u8(r2 & 0xff, vreinterpretq_u8_m128i(dst), 0));     \
+        }                                                                      \
+    }                                                                          \
+    return dst
+
+// Compare packed strings in a and b with lengths la and lb using the control
+// in imm8, and returns 1 if b did not contain a null character and the
+// resulting mask was zero, and 0 otherwise.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmpestra
+FORCE_INLINE int _mm_cmpestra(__m128i a,
+                              int la,
+                              __m128i b,
+                              int lb,
+                              const int imm8)
+{
+    int lb_cpy = lb;
+    SSE2NEON_COMP_AGG(a, b, la, lb, imm8, CMPESTRX);
+    return !r2 & (lb_cpy > bound);
+}
+
+// Compare packed strings in a and b with lengths la and lb using the control in
+// imm8, and returns 1 if the resulting mask was non-zero, and 0 otherwise.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmpestrc
+FORCE_INLINE int _mm_cmpestrc(__m128i a,
+                              int la,
+                              __m128i b,
+                              int lb,
+                              const int imm8)
+{
+    SSE2NEON_COMP_AGG(a, b, la, lb, imm8, CMPESTRX);
+    return r2 != 0;
+}
+
+// Compare packed strings in a and b with lengths la and lb using the control
+// in imm8, and store the generated index in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmpestri
+FORCE_INLINE int _mm_cmpestri(__m128i a,
+                              int la,
+                              __m128i b,
+                              int lb,
+                              const int imm8)
+{
+    SSE2NEON_COMP_AGG(a, b, la, lb, imm8, CMPESTRX);
+    SSE2NEON_CMPSTR_GENERATE_INDEX(r2, bound, imm8);
+}
+
+// Compare packed strings in a and b with lengths la and lb using the control
+// in imm8, and store the generated mask in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmpestrm
+FORCE_INLINE __m128i
+_mm_cmpestrm(__m128i a, int la, __m128i b, int lb, const int imm8)
+{
+    SSE2NEON_COMP_AGG(a, b, la, lb, imm8, CMPESTRX);
+    SSE2NEON_CMPSTR_GENERATE_MASK(dst);
+}
+
+// Compare packed strings in a and b with lengths la and lb using the control in
+// imm8, and returns bit 0 of the resulting bit mask.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmpestro
+FORCE_INLINE int _mm_cmpestro(__m128i a,
+                              int la,
+                              __m128i b,
+                              int lb,
+                              const int imm8)
+{
+    SSE2NEON_COMP_AGG(a, b, la, lb, imm8, CMPESTRX);
+    return r2 & 1;
+}
+
+// Compare packed strings in a and b with lengths la and lb using the control in
+// imm8, and returns 1 if any character in a was null, and 0 otherwise.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmpestrs
+FORCE_INLINE int _mm_cmpestrs(__m128i a,
+                              int la,
+                              __m128i b,
+                              int lb,
+                              const int imm8)
+{
+    (void) a;
+    (void) b;
+    (void) lb;
+    SSE2NEON_CMPSTR_SET_UPPER(bound, imm8);
+    return la <= (bound - 1);
+}
+
+// Compare packed strings in a and b with lengths la and lb using the control in
+// imm8, and returns 1 if any character in b was null, and 0 otherwise.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmpestrz
+FORCE_INLINE int _mm_cmpestrz(__m128i a,
+                              int la,
+                              __m128i b,
+                              int lb,
+                              const int imm8)
+{
+    (void) a;
+    (void) b;
+    (void) la;
+    SSE2NEON_CMPSTR_SET_UPPER(bound, imm8);
+    return lb <= (bound - 1);
+}
+
+#define SSE2NEON_CMPISTRX_LENGTH(str, len, imm8)                         \
+    do {                                                                 \
+        if (imm8 & 0x01) {                                               \
+            uint16x8_t equal_mask_##str =                                \
+                vceqq_u16(vreinterpretq_u16_m128i(str), vdupq_n_u16(0)); \
+            uint8x8_t res_##str = vshrn_n_u16(equal_mask_##str, 4);      \
+            uint64_t matches_##str =                                     \
+                vget_lane_u64(vreinterpret_u64_u8(res_##str), 0);        \
+            len = _sse2neon_ctzll(matches_##str) >> 3;                   \
+        } else {                                                         \
+            uint16x8_t equal_mask_##str = vreinterpretq_u16_u8(          \
+                vceqq_u8(vreinterpretq_u8_m128i(str), vdupq_n_u8(0)));   \
+            uint8x8_t res_##str = vshrn_n_u16(equal_mask_##str, 4);      \
+            uint64_t matches_##str =                                     \
+                vget_lane_u64(vreinterpret_u64_u8(res_##str), 0);        \
+            len = _sse2neon_ctzll(matches_##str) >> 2;                   \
+        }                                                                \
+    } while (0)
+
+#define SSE2NEON_CMPISTRX_LEN_PAIR(a, b, la, lb) \
+    int la, lb;                                  \
+    do {                                         \
+        SSE2NEON_CMPISTRX_LENGTH(a, la, imm8);   \
+        SSE2NEON_CMPISTRX_LENGTH(b, lb, imm8);   \
+    } while (0)
+
+// Compare packed strings with implicit lengths in a and b using the control in
+// imm8, and returns 1 if b did not contain a null character and the resulting
+// mask was zero, and 0 otherwise.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmpistra
+FORCE_INLINE int _mm_cmpistra(__m128i a, __m128i b, const int imm8)
+{
+    SSE2NEON_COMP_AGG(a, b, la, lb, imm8, CMPISTRX);
+    return !r2 & (lb >= bound);
+}
+
+// Compare packed strings with implicit lengths in a and b using the control in
+// imm8, and returns 1 if the resulting mask was non-zero, and 0 otherwise.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmpistrc
+FORCE_INLINE int _mm_cmpistrc(__m128i a, __m128i b, const int imm8)
+{
+    SSE2NEON_COMP_AGG(a, b, la, lb, imm8, CMPISTRX);
+    return r2 != 0;
+}
+
+// Compare packed strings with implicit lengths in a and b using the control in
+// imm8, and store the generated index in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmpistri
+FORCE_INLINE int _mm_cmpistri(__m128i a, __m128i b, const int imm8)
+{
+    SSE2NEON_COMP_AGG(a, b, la, lb, imm8, CMPISTRX);
+    SSE2NEON_CMPSTR_GENERATE_INDEX(r2, bound, imm8);
+}
+
+// Compare packed strings with implicit lengths in a and b using the control in
+// imm8, and store the generated mask in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmpistrm
+FORCE_INLINE __m128i _mm_cmpistrm(__m128i a, __m128i b, const int imm8)
+{
+    SSE2NEON_COMP_AGG(a, b, la, lb, imm8, CMPISTRX);
+    SSE2NEON_CMPSTR_GENERATE_MASK(dst);
+}
+
+// Compare packed strings with implicit lengths in a and b using the control in
+// imm8, and returns bit 0 of the resulting bit mask.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmpistro
+FORCE_INLINE int _mm_cmpistro(__m128i a, __m128i b, const int imm8)
+{
+    SSE2NEON_COMP_AGG(a, b, la, lb, imm8, CMPISTRX);
+    return r2 & 1;
+}
+
+// Compare packed strings with implicit lengths in a and b using the control in
+// imm8, and returns 1 if any character in a was null, and 0 otherwise.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmpistrs
+FORCE_INLINE int _mm_cmpistrs(__m128i a, __m128i b, const int imm8)
+{
+    (void) b;
+    SSE2NEON_CMPSTR_SET_UPPER(bound, imm8);
+    int la;
+    SSE2NEON_CMPISTRX_LENGTH(a, la, imm8);
+    return la <= (bound - 1);
+}
+
+// Compare packed strings with implicit lengths in a and b using the control in
+// imm8, and returns 1 if any character in b was null, and 0 otherwise.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cmpistrz
+FORCE_INLINE int _mm_cmpistrz(__m128i a, __m128i b, const int imm8)
+{
+    (void) a;
+    SSE2NEON_CMPSTR_SET_UPPER(bound, imm8);
+    int lb;
+    SSE2NEON_CMPISTRX_LENGTH(b, lb, imm8);
+    return lb <= (bound - 1);
+}
+
+// Compares the 2 signed 64-bit integers in a and the 2 signed 64-bit integers
+// in b for greater than.
+FORCE_INLINE __m128i _mm_cmpgt_epi64(__m128i a, __m128i b)
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+    return vreinterpretq_m128i_u64(
+        vcgtq_s64(vreinterpretq_s64_m128i(a), vreinterpretq_s64_m128i(b)));
+#else
+    return vreinterpretq_m128i_s64(vshrq_n_s64(
+        vqsubq_s64(vreinterpretq_s64_m128i(b), vreinterpretq_s64_m128i(a)),
+        63));
+#endif
+}
+
+// Starting with the initial value in crc, accumulates a CRC32 value for
+// unsigned 16-bit integer v, and stores the result in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_crc32_u16
+FORCE_INLINE uint32_t _mm_crc32_u16(uint32_t crc, uint16_t v)
+{
+#if defined(__aarch64__) && defined(__ARM_FEATURE_CRC32)
+    __asm__ __volatile__("crc32ch %w[c], %w[c], %w[v]\n\t"
+                         : [c] "+r"(crc)
+                         : [v] "r"(v));
+#elif ((__ARM_ARCH == 8) && defined(__ARM_FEATURE_CRC32)) || \
+    (defined(_M_ARM64) && !defined(__clang__))
+    crc = __crc32ch(crc, v);
+#else
+    crc = _mm_crc32_u8(crc, v & 0xff);
+    crc = _mm_crc32_u8(crc, (v >> 8) & 0xff);
+#endif
+    return crc;
+}
+
+// Starting with the initial value in crc, accumulates a CRC32 value for
+// unsigned 32-bit integer v, and stores the result in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_crc32_u32
+FORCE_INLINE uint32_t _mm_crc32_u32(uint32_t crc, uint32_t v)
+{
+#if defined(__aarch64__) && defined(__ARM_FEATURE_CRC32)
+    __asm__ __volatile__("crc32cw %w[c], %w[c], %w[v]\n\t"
+                         : [c] "+r"(crc)
+                         : [v] "r"(v));
+#elif ((__ARM_ARCH == 8) && defined(__ARM_FEATURE_CRC32)) || \
+    (defined(_M_ARM64) && !defined(__clang__))
+    crc = __crc32cw(crc, v);
+#else
+    crc = _mm_crc32_u16(crc, v & 0xffff);
+    crc = _mm_crc32_u16(crc, (v >> 16) & 0xffff);
+#endif
+    return crc;
+}
+
+// Starting with the initial value in crc, accumulates a CRC32 value for
+// unsigned 64-bit integer v, and stores the result in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_crc32_u64
+FORCE_INLINE uint64_t _mm_crc32_u64(uint64_t crc, uint64_t v)
+{
+#if defined(__aarch64__) && defined(__ARM_FEATURE_CRC32)
+    __asm__ __volatile__("crc32cx %w[c], %w[c], %x[v]\n\t"
+                         : [c] "+r"(crc)
+                         : [v] "r"(v));
+#elif (defined(_M_ARM64) && !defined(__clang__))
+    crc = __crc32cd((uint32_t) crc, v);
+#else
+    crc = _mm_crc32_u32((uint32_t) (crc), v & 0xffffffff);
+    crc = _mm_crc32_u32((uint32_t) (crc), (v >> 32) & 0xffffffff);
+#endif
+    return crc;
+}
+
+// Starting with the initial value in crc, accumulates a CRC32 value for
+// unsigned 8-bit integer v, and stores the result in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_crc32_u8
+FORCE_INLINE uint32_t _mm_crc32_u8(uint32_t crc, uint8_t v)
+{
+#if defined(__aarch64__) && defined(__ARM_FEATURE_CRC32)
+    __asm__ __volatile__("crc32cb %w[c], %w[c], %w[v]\n\t"
+                         : [c] "+r"(crc)
+                         : [v] "r"(v));
+#elif ((__ARM_ARCH == 8) && defined(__ARM_FEATURE_CRC32)) || \
+    (defined(_M_ARM64) && !defined(__clang__))
+    crc = __crc32cb(crc, v);
+#else
+    crc ^= v;
+#if defined(__ARM_FEATURE_CRYPTO)
+    // Adapted from: https://mary.rs/lab/crc32/
+    // Barrent reduction
+    uint64x2_t orig =
+        vcombine_u64(vcreate_u64((uint64_t) (crc) << 24), vcreate_u64(0x0));
+    uint64x2_t tmp = orig;
+
+    // Polynomial P(x) of CRC32C
+    uint64_t p = 0x105EC76F1;
+    // Barrett Reduction (in bit-reflected form) constant mu_{64} = \lfloor
+    // 2^{64} / P(x) \rfloor = 0x11f91caf6
+    uint64_t mu = 0x1dea713f1;
+
+    // Multiply by mu_{64}
+    tmp = _sse2neon_vmull_p64(vget_low_u64(tmp), vcreate_u64(mu));
+    // Divide by 2^{64} (mask away the unnecessary bits)
+    tmp =
+        vandq_u64(tmp, vcombine_u64(vcreate_u64(0xFFFFFFFF), vcreate_u64(0x0)));
+    // Multiply by P(x) (shifted left by 1 for alignment reasons)
+    tmp = _sse2neon_vmull_p64(vget_low_u64(tmp), vcreate_u64(p));
+    // Subtract original from result
+    tmp = veorq_u64(tmp, orig);
+
+    // Extract the 'lower' (in bit-reflected sense) 32 bits
+    crc = vgetq_lane_u32(vreinterpretq_u32_u64(tmp), 1);
+#else  // Fall back to the generic table lookup approach
+    // Adapted from: https://create.stephan-brumme.com/crc32/
+    // Apply half-byte comparision algorithm for the best ratio between
+    // performance and lookup table.
+
+    // The lookup table just needs to store every 16th entry
+    // of the standard look-up table.
+    static const uint32_t crc32_half_byte_tbl[] = {
+        0x00000000, 0x105ec76f, 0x20bd8ede, 0x30e349b1, 0x417b1dbc, 0x5125dad3,
+        0x61c69362, 0x7198540d, 0x82f63b78, 0x92a8fc17, 0xa24bb5a6, 0xb21572c9,
+        0xc38d26c4, 0xd3d3e1ab, 0xe330a81a, 0xf36e6f75,
+    };
+
+    crc = (crc >> 4) ^ crc32_half_byte_tbl[crc & 0x0F];
+    crc = (crc >> 4) ^ crc32_half_byte_tbl[crc & 0x0F];
+#endif
+#endif
+    return crc;
+}
+
+/* AES */
+
+#if !defined(__ARM_FEATURE_CRYPTO) && (!defined(_M_ARM64) || defined(__clang__))
+/* clang-format off */
+#define SSE2NEON_AES_SBOX(w)                                           \
+    {                                                                  \
+        w(0x63), w(0x7c), w(0x77), w(0x7b), w(0xf2), w(0x6b), w(0x6f), \
+        w(0xc5), w(0x30), w(0x01), w(0x67), w(0x2b), w(0xfe), w(0xd7), \
+        w(0xab), w(0x76), w(0xca), w(0x82), w(0xc9), w(0x7d), w(0xfa), \
+        w(0x59), w(0x47), w(0xf0), w(0xad), w(0xd4), w(0xa2), w(0xaf), \
+        w(0x9c), w(0xa4), w(0x72), w(0xc0), w(0xb7), w(0xfd), w(0x93), \
+        w(0x26), w(0x36), w(0x3f), w(0xf7), w(0xcc), w(0x34), w(0xa5), \
+        w(0xe5), w(0xf1), w(0x71), w(0xd8), w(0x31), w(0x15), w(0x04), \
+        w(0xc7), w(0x23), w(0xc3), w(0x18), w(0x96), w(0x05), w(0x9a), \
+        w(0x07), w(0x12), w(0x80), w(0xe2), w(0xeb), w(0x27), w(0xb2), \
+        w(0x75), w(0x09), w(0x83), w(0x2c), w(0x1a), w(0x1b), w(0x6e), \
+        w(0x5a), w(0xa0), w(0x52), w(0x3b), w(0xd6), w(0xb3), w(0x29), \
+        w(0xe3), w(0x2f), w(0x84), w(0x53), w(0xd1), w(0x00), w(0xed), \
+        w(0x20), w(0xfc), w(0xb1), w(0x5b), w(0x6a), w(0xcb), w(0xbe), \
+        w(0x39), w(0x4a), w(0x4c), w(0x58), w(0xcf), w(0xd0), w(0xef), \
+        w(0xaa), w(0xfb), w(0x43), w(0x4d), w(0x33), w(0x85), w(0x45), \
+        w(0xf9), w(0x02), w(0x7f), w(0x50), w(0x3c), w(0x9f), w(0xa8), \
+        w(0x51), w(0xa3), w(0x40), w(0x8f), w(0x92), w(0x9d), w(0x38), \
+        w(0xf5), w(0xbc), w(0xb6), w(0xda), w(0x21), w(0x10), w(0xff), \
+        w(0xf3), w(0xd2), w(0xcd), w(0x0c), w(0x13), w(0xec), w(0x5f), \
+        w(0x97), w(0x44), w(0x17), w(0xc4), w(0xa7), w(0x7e), w(0x3d), \
+        w(0x64), w(0x5d), w(0x19), w(0x73), w(0x60), w(0x81), w(0x4f), \
+        w(0xdc), w(0x22), w(0x2a), w(0x90), w(0x88), w(0x46), w(0xee), \
+        w(0xb8), w(0x14), w(0xde), w(0x5e), w(0x0b), w(0xdb), w(0xe0), \
+        w(0x32), w(0x3a), w(0x0a), w(0x49), w(0x06), w(0x24), w(0x5c), \
+        w(0xc2), w(0xd3), w(0xac), w(0x62), w(0x91), w(0x95), w(0xe4), \
+        w(0x79), w(0xe7), w(0xc8), w(0x37), w(0x6d), w(0x8d), w(0xd5), \
+        w(0x4e), w(0xa9), w(0x6c), w(0x56), w(0xf4), w(0xea), w(0x65), \
+        w(0x7a), w(0xae), w(0x08), w(0xba), w(0x78), w(0x25), w(0x2e), \
+        w(0x1c), w(0xa6), w(0xb4), w(0xc6), w(0xe8), w(0xdd), w(0x74), \
+        w(0x1f), w(0x4b), w(0xbd), w(0x8b), w(0x8a), w(0x70), w(0x3e), \
+        w(0xb5), w(0x66), w(0x48), w(0x03), w(0xf6), w(0x0e), w(0x61), \
+        w(0x35), w(0x57), w(0xb9), w(0x86), w(0xc1), w(0x1d), w(0x9e), \
+        w(0xe1), w(0xf8), w(0x98), w(0x11), w(0x69), w(0xd9), w(0x8e), \
+        w(0x94), w(0x9b), w(0x1e), w(0x87), w(0xe9), w(0xce), w(0x55), \
+        w(0x28), w(0xdf), w(0x8c), w(0xa1), w(0x89), w(0x0d), w(0xbf), \
+        w(0xe6), w(0x42), w(0x68), w(0x41), w(0x99), w(0x2d), w(0x0f), \
+        w(0xb0), w(0x54), w(0xbb), w(0x16)                             \
+    }
+#define SSE2NEON_AES_RSBOX(w)                                          \
+    {                                                                  \
+        w(0x52), w(0x09), w(0x6a), w(0xd5), w(0x30), w(0x36), w(0xa5), \
+        w(0x38), w(0xbf), w(0x40), w(0xa3), w(0x9e), w(0x81), w(0xf3), \
+        w(0xd7), w(0xfb), w(0x7c), w(0xe3), w(0x39), w(0x82), w(0x9b), \
+        w(0x2f), w(0xff), w(0x87), w(0x34), w(0x8e), w(0x43), w(0x44), \
+        w(0xc4), w(0xde), w(0xe9), w(0xcb), w(0x54), w(0x7b), w(0x94), \
+        w(0x32), w(0xa6), w(0xc2), w(0x23), w(0x3d), w(0xee), w(0x4c), \
+        w(0x95), w(0x0b), w(0x42), w(0xfa), w(0xc3), w(0x4e), w(0x08), \
+        w(0x2e), w(0xa1), w(0x66), w(0x28), w(0xd9), w(0x24), w(0xb2), \
+        w(0x76), w(0x5b), w(0xa2), w(0x49), w(0x6d), w(0x8b), w(0xd1), \
+        w(0x25), w(0x72), w(0xf8), w(0xf6), w(0x64), w(0x86), w(0x68), \
+        w(0x98), w(0x16), w(0xd4), w(0xa4), w(0x5c), w(0xcc), w(0x5d), \
+        w(0x65), w(0xb6), w(0x92), w(0x6c), w(0x70), w(0x48), w(0x50), \
+        w(0xfd), w(0xed), w(0xb9), w(0xda), w(0x5e), w(0x15), w(0x46), \
+        w(0x57), w(0xa7), w(0x8d), w(0x9d), w(0x84), w(0x90), w(0xd8), \
+        w(0xab), w(0x00), w(0x8c), w(0xbc), w(0xd3), w(0x0a), w(0xf7), \
+        w(0xe4), w(0x58), w(0x05), w(0xb8), w(0xb3), w(0x45), w(0x06), \
+        w(0xd0), w(0x2c), w(0x1e), w(0x8f), w(0xca), w(0x3f), w(0x0f), \
+        w(0x02), w(0xc1), w(0xaf), w(0xbd), w(0x03), w(0x01), w(0x13), \
+        w(0x8a), w(0x6b), w(0x3a), w(0x91), w(0x11), w(0x41), w(0x4f), \
+        w(0x67), w(0xdc), w(0xea), w(0x97), w(0xf2), w(0xcf), w(0xce), \
+        w(0xf0), w(0xb4), w(0xe6), w(0x73), w(0x96), w(0xac), w(0x74), \
+        w(0x22), w(0xe7), w(0xad), w(0x35), w(0x85), w(0xe2), w(0xf9), \
+        w(0x37), w(0xe8), w(0x1c), w(0x75), w(0xdf), w(0x6e), w(0x47), \
+        w(0xf1), w(0x1a), w(0x71), w(0x1d), w(0x29), w(0xc5), w(0x89), \
+        w(0x6f), w(0xb7), w(0x62), w(0x0e), w(0xaa), w(0x18), w(0xbe), \
+        w(0x1b), w(0xfc), w(0x56), w(0x3e), w(0x4b), w(0xc6), w(0xd2), \
+        w(0x79), w(0x20), w(0x9a), w(0xdb), w(0xc0), w(0xfe), w(0x78), \
+        w(0xcd), w(0x5a), w(0xf4), w(0x1f), w(0xdd), w(0xa8), w(0x33), \
+        w(0x88), w(0x07), w(0xc7), w(0x31), w(0xb1), w(0x12), w(0x10), \
+        w(0x59), w(0x27), w(0x80), w(0xec), w(0x5f), w(0x60), w(0x51), \
+        w(0x7f), w(0xa9), w(0x19), w(0xb5), w(0x4a), w(0x0d), w(0x2d), \
+        w(0xe5), w(0x7a), w(0x9f), w(0x93), w(0xc9), w(0x9c), w(0xef), \
+        w(0xa0), w(0xe0), w(0x3b), w(0x4d), w(0xae), w(0x2a), w(0xf5), \
+        w(0xb0), w(0xc8), w(0xeb), w(0xbb), w(0x3c), w(0x83), w(0x53), \
+        w(0x99), w(0x61), w(0x17), w(0x2b), w(0x04), w(0x7e), w(0xba), \
+        w(0x77), w(0xd6), w(0x26), w(0xe1), w(0x69), w(0x14), w(0x63), \
+        w(0x55), w(0x21), w(0x0c), w(0x7d)                             \
+    }
+/* clang-format on */
+
+/* X Macro trick. See https://en.wikipedia.org/wiki/X_Macro */
+#define SSE2NEON_AES_H0(x) (x)
+static const uint8_t _sse2neon_sbox[256] = SSE2NEON_AES_SBOX(SSE2NEON_AES_H0);
+static const uint8_t _sse2neon_rsbox[256] = SSE2NEON_AES_RSBOX(SSE2NEON_AES_H0);
+#undef SSE2NEON_AES_H0
+
+/* x_time function and matrix multiply function */
+#if !defined(__aarch64__) && !defined(_M_ARM64)
+#define SSE2NEON_XT(x) (((x) << 1) ^ ((((x) >> 7) & 1) * 0x1b))
+#define SSE2NEON_MULTIPLY(x, y)                                  \
+    (((y & 1) * x) ^ ((y >> 1 & 1) * SSE2NEON_XT(x)) ^           \
+     ((y >> 2 & 1) * SSE2NEON_XT(SSE2NEON_XT(x))) ^              \
+     ((y >> 3 & 1) * SSE2NEON_XT(SSE2NEON_XT(SSE2NEON_XT(x)))) ^ \
+     ((y >> 4 & 1) * SSE2NEON_XT(SSE2NEON_XT(SSE2NEON_XT(SSE2NEON_XT(x))))))
+#endif
+
+// In the absence of crypto extensions, implement aesenc using regular NEON
+// intrinsics instead. See:
+// https://www.workofard.com/2017/01/accelerated-aes-for-the-arm64-linux-kernel/
+// https://www.workofard.com/2017/07/ghash-for-low-end-cores/ and
+// for more information.
+FORCE_INLINE __m128i _mm_aesenc_si128(__m128i a, __m128i RoundKey)
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+    static const uint8_t shift_rows[] = {
+        0x0, 0x5, 0xa, 0xf, 0x4, 0x9, 0xe, 0x3,
+        0x8, 0xd, 0x2, 0x7, 0xc, 0x1, 0x6, 0xb,
+    };
+    static const uint8_t ror32by8[] = {
+        0x1, 0x2, 0x3, 0x0, 0x5, 0x6, 0x7, 0x4,
+        0x9, 0xa, 0xb, 0x8, 0xd, 0xe, 0xf, 0xc,
+    };
+
+    uint8x16_t v;
+    uint8x16_t w = vreinterpretq_u8_m128i(a);
+
+    /* shift rows */
+    w = vqtbl1q_u8(w, vld1q_u8(shift_rows));
+
+    /* sub bytes */
+    // Here, we separate the whole 256-bytes table into 4 64-bytes tables, and
+    // look up each of the table. After each lookup, we load the next table
+    // which locates at the next 64-bytes. In the meantime, the index in the
+    // table would be smaller than it was, so the index parameters of
+    // `vqtbx4q_u8()` need to be added the same constant as the loaded tables.
+    v = vqtbl4q_u8(_sse2neon_vld1q_u8_x4(_sse2neon_sbox), w);
+    // 'w-0x40' equals to 'vsubq_u8(w, vdupq_n_u8(0x40))'
+    v = vqtbx4q_u8(v, _sse2neon_vld1q_u8_x4(_sse2neon_sbox + 0x40), w - 0x40);
+    v = vqtbx4q_u8(v, _sse2neon_vld1q_u8_x4(_sse2neon_sbox + 0x80), w - 0x80);
+    v = vqtbx4q_u8(v, _sse2neon_vld1q_u8_x4(_sse2neon_sbox + 0xc0), w - 0xc0);
+
+    /* mix columns */
+    w = (v << 1) ^ (uint8x16_t) (((int8x16_t) v >> 7) & 0x1b);
+    w ^= (uint8x16_t) vrev32q_u16((uint16x8_t) v);
+    w ^= vqtbl1q_u8(v ^ w, vld1q_u8(ror32by8));
+
+    /* add round key */
+    return vreinterpretq_m128i_u8(w) ^ RoundKey;
+
+#else /* ARMv7-A implementation for a table-based AES */
+#define SSE2NEON_AES_B2W(b0, b1, b2, b3)                 \
+    (((uint32_t) (b3) << 24) | ((uint32_t) (b2) << 16) | \
+     ((uint32_t) (b1) << 8) | (uint32_t) (b0))
+// muliplying 'x' by 2 in GF(2^8)
+#define SSE2NEON_AES_F2(x) ((x << 1) ^ (((x >> 7) & 1) * 0x011b /* WPOLY */))
+// muliplying 'x' by 3 in GF(2^8)
+#define SSE2NEON_AES_F3(x) (SSE2NEON_AES_F2(x) ^ x)
+#define SSE2NEON_AES_U0(p) \
+    SSE2NEON_AES_B2W(SSE2NEON_AES_F2(p), p, p, SSE2NEON_AES_F3(p))
+#define SSE2NEON_AES_U1(p) \
+    SSE2NEON_AES_B2W(SSE2NEON_AES_F3(p), SSE2NEON_AES_F2(p), p, p)
+#define SSE2NEON_AES_U2(p) \
+    SSE2NEON_AES_B2W(p, SSE2NEON_AES_F3(p), SSE2NEON_AES_F2(p), p)
+#define SSE2NEON_AES_U3(p) \
+    SSE2NEON_AES_B2W(p, p, SSE2NEON_AES_F3(p), SSE2NEON_AES_F2(p))
+
+    // this generates a table containing every possible permutation of
+    // shift_rows() and sub_bytes() with mix_columns().
+    static const uint32_t ALIGN_STRUCT(16) aes_table[4][256] = {
+        SSE2NEON_AES_SBOX(SSE2NEON_AES_U0),
+        SSE2NEON_AES_SBOX(SSE2NEON_AES_U1),
+        SSE2NEON_AES_SBOX(SSE2NEON_AES_U2),
+        SSE2NEON_AES_SBOX(SSE2NEON_AES_U3),
+    };
+#undef SSE2NEON_AES_B2W
+#undef SSE2NEON_AES_F2
+#undef SSE2NEON_AES_F3
+#undef SSE2NEON_AES_U0
+#undef SSE2NEON_AES_U1
+#undef SSE2NEON_AES_U2
+#undef SSE2NEON_AES_U3
+
+    uint32_t x0 = _mm_cvtsi128_si32(a);  // get a[31:0]
+    uint32_t x1 =
+        _mm_cvtsi128_si32(_mm_shuffle_epi32(a, 0x55));  // get a[63:32]
+    uint32_t x2 =
+        _mm_cvtsi128_si32(_mm_shuffle_epi32(a, 0xAA));  // get a[95:64]
+    uint32_t x3 =
+        _mm_cvtsi128_si32(_mm_shuffle_epi32(a, 0xFF));  // get a[127:96]
+
+    // finish the modulo addition step in mix_columns()
+    __m128i out = _mm_set_epi32(
+        (aes_table[0][x3 & 0xff] ^ aes_table[1][(x0 >> 8) & 0xff] ^
+         aes_table[2][(x1 >> 16) & 0xff] ^ aes_table[3][x2 >> 24]),
+        (aes_table[0][x2 & 0xff] ^ aes_table[1][(x3 >> 8) & 0xff] ^
+         aes_table[2][(x0 >> 16) & 0xff] ^ aes_table[3][x1 >> 24]),
+        (aes_table[0][x1 & 0xff] ^ aes_table[1][(x2 >> 8) & 0xff] ^
+         aes_table[2][(x3 >> 16) & 0xff] ^ aes_table[3][x0 >> 24]),
+        (aes_table[0][x0 & 0xff] ^ aes_table[1][(x1 >> 8) & 0xff] ^
+         aes_table[2][(x2 >> 16) & 0xff] ^ aes_table[3][x3 >> 24]));
+
+    return _mm_xor_si128(out, RoundKey);
+#endif
+}
+
+// Perform one round of an AES decryption flow on data (state) in a using the
+// round key in RoundKey, and store the result in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_aesdec_si128
+FORCE_INLINE __m128i _mm_aesdec_si128(__m128i a, __m128i RoundKey)
+{
+#if defined(__aarch64__)
+    static const uint8_t inv_shift_rows[] = {
+        0x0, 0xd, 0xa, 0x7, 0x4, 0x1, 0xe, 0xb,
+        0x8, 0x5, 0x2, 0xf, 0xc, 0x9, 0x6, 0x3,
+    };
+    static const uint8_t ror32by8[] = {
+        0x1, 0x2, 0x3, 0x0, 0x5, 0x6, 0x7, 0x4,
+        0x9, 0xa, 0xb, 0x8, 0xd, 0xe, 0xf, 0xc,
+    };
+
+    uint8x16_t v;
+    uint8x16_t w = vreinterpretq_u8_m128i(a);
+
+    // inverse shift rows
+    w = vqtbl1q_u8(w, vld1q_u8(inv_shift_rows));
+
+    // inverse sub bytes
+    v = vqtbl4q_u8(_sse2neon_vld1q_u8_x4(_sse2neon_rsbox), w);
+    v = vqtbx4q_u8(v, _sse2neon_vld1q_u8_x4(_sse2neon_rsbox + 0x40), w - 0x40);
+    v = vqtbx4q_u8(v, _sse2neon_vld1q_u8_x4(_sse2neon_rsbox + 0x80), w - 0x80);
+    v = vqtbx4q_u8(v, _sse2neon_vld1q_u8_x4(_sse2neon_rsbox + 0xc0), w - 0xc0);
+
+    // inverse mix columns
+    // multiplying 'v' by 4 in GF(2^8)
+    w = (v << 1) ^ (uint8x16_t) (((int8x16_t) v >> 7) & 0x1b);
+    w = (w << 1) ^ (uint8x16_t) (((int8x16_t) w >> 7) & 0x1b);
+    v ^= w;
+    v ^= (uint8x16_t) vrev32q_u16((uint16x8_t) w);
+
+    w = (v << 1) ^ (uint8x16_t) (((int8x16_t) v >> 7) &
+                                 0x1b);  // muliplying 'v' by 2 in GF(2^8)
+    w ^= (uint8x16_t) vrev32q_u16((uint16x8_t) v);
+    w ^= vqtbl1q_u8(v ^ w, vld1q_u8(ror32by8));
+
+    // add round key
+    return vreinterpretq_m128i_u8(w) ^ RoundKey;
+
+#else /* ARMv7-A NEON implementation */
+    /* FIXME: optimized for NEON */
+    uint8_t i, e, f, g, h, v[4][4];
+    uint8_t *_a = (uint8_t *) &a;
+    for (i = 0; i < 16; ++i) {
+        v[((i / 4) + (i % 4)) % 4][i % 4] = _sse2neon_rsbox[_a[i]];
+    }
+
+    // inverse mix columns
+    for (i = 0; i < 4; ++i) {
+        e = v[i][0];
+        f = v[i][1];
+        g = v[i][2];
+        h = v[i][3];
+
+        v[i][0] = SSE2NEON_MULTIPLY(e, 0x0e) ^ SSE2NEON_MULTIPLY(f, 0x0b) ^
+                  SSE2NEON_MULTIPLY(g, 0x0d) ^ SSE2NEON_MULTIPLY(h, 0x09);
+        v[i][1] = SSE2NEON_MULTIPLY(e, 0x09) ^ SSE2NEON_MULTIPLY(f, 0x0e) ^
+                  SSE2NEON_MULTIPLY(g, 0x0b) ^ SSE2NEON_MULTIPLY(h, 0x0d);
+        v[i][2] = SSE2NEON_MULTIPLY(e, 0x0d) ^ SSE2NEON_MULTIPLY(f, 0x09) ^
+                  SSE2NEON_MULTIPLY(g, 0x0e) ^ SSE2NEON_MULTIPLY(h, 0x0b);
+        v[i][3] = SSE2NEON_MULTIPLY(e, 0x0b) ^ SSE2NEON_MULTIPLY(f, 0x0d) ^
+                  SSE2NEON_MULTIPLY(g, 0x09) ^ SSE2NEON_MULTIPLY(h, 0x0e);
+    }
+
+    return vreinterpretq_m128i_u8(vld1q_u8((uint8_t *) v)) ^ RoundKey;
+#endif
+}
+
+// Perform the last round of an AES encryption flow on data (state) in a using
+// the round key in RoundKey, and store the result in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_aesenclast_si128
+FORCE_INLINE __m128i _mm_aesenclast_si128(__m128i a, __m128i RoundKey)
+{
+#if defined(__aarch64__)
+    static const uint8_t shift_rows[] = {
+        0x0, 0x5, 0xa, 0xf, 0x4, 0x9, 0xe, 0x3,
+        0x8, 0xd, 0x2, 0x7, 0xc, 0x1, 0x6, 0xb,
+    };
+
+    uint8x16_t v;
+    uint8x16_t w = vreinterpretq_u8_m128i(a);
+
+    // shift rows
+    w = vqtbl1q_u8(w, vld1q_u8(shift_rows));
+
+    // sub bytes
+    v = vqtbl4q_u8(_sse2neon_vld1q_u8_x4(_sse2neon_sbox), w);
+    v = vqtbx4q_u8(v, _sse2neon_vld1q_u8_x4(_sse2neon_sbox + 0x40), w - 0x40);
+    v = vqtbx4q_u8(v, _sse2neon_vld1q_u8_x4(_sse2neon_sbox + 0x80), w - 0x80);
+    v = vqtbx4q_u8(v, _sse2neon_vld1q_u8_x4(_sse2neon_sbox + 0xc0), w - 0xc0);
+
+    // add round key
+    return vreinterpretq_m128i_u8(v) ^ RoundKey;
+
+#else /* ARMv7-A implementation */
+    uint8_t v[16] = {
+        _sse2neon_sbox[vgetq_lane_u8(vreinterpretq_u8_m128i(a), 0)],
+        _sse2neon_sbox[vgetq_lane_u8(vreinterpretq_u8_m128i(a), 5)],
+        _sse2neon_sbox[vgetq_lane_u8(vreinterpretq_u8_m128i(a), 10)],
+        _sse2neon_sbox[vgetq_lane_u8(vreinterpretq_u8_m128i(a), 15)],
+        _sse2neon_sbox[vgetq_lane_u8(vreinterpretq_u8_m128i(a), 4)],
+        _sse2neon_sbox[vgetq_lane_u8(vreinterpretq_u8_m128i(a), 9)],
+        _sse2neon_sbox[vgetq_lane_u8(vreinterpretq_u8_m128i(a), 14)],
+        _sse2neon_sbox[vgetq_lane_u8(vreinterpretq_u8_m128i(a), 3)],
+        _sse2neon_sbox[vgetq_lane_u8(vreinterpretq_u8_m128i(a), 8)],
+        _sse2neon_sbox[vgetq_lane_u8(vreinterpretq_u8_m128i(a), 13)],
+        _sse2neon_sbox[vgetq_lane_u8(vreinterpretq_u8_m128i(a), 2)],
+        _sse2neon_sbox[vgetq_lane_u8(vreinterpretq_u8_m128i(a), 7)],
+        _sse2neon_sbox[vgetq_lane_u8(vreinterpretq_u8_m128i(a), 12)],
+        _sse2neon_sbox[vgetq_lane_u8(vreinterpretq_u8_m128i(a), 1)],
+        _sse2neon_sbox[vgetq_lane_u8(vreinterpretq_u8_m128i(a), 6)],
+        _sse2neon_sbox[vgetq_lane_u8(vreinterpretq_u8_m128i(a), 11)],
+    };
+
+    return vreinterpretq_m128i_u8(vld1q_u8(v)) ^ RoundKey;
+#endif
+}
+
+// Perform the last round of an AES decryption flow on data (state) in a using
+// the round key in RoundKey, and store the result in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_aesdeclast_si128
+FORCE_INLINE __m128i _mm_aesdeclast_si128(__m128i a, __m128i RoundKey)
+{
+#if defined(__aarch64__)
+    static const uint8_t inv_shift_rows[] = {
+        0x0, 0xd, 0xa, 0x7, 0x4, 0x1, 0xe, 0xb,
+        0x8, 0x5, 0x2, 0xf, 0xc, 0x9, 0x6, 0x3,
+    };
+
+    uint8x16_t v;
+    uint8x16_t w = vreinterpretq_u8_m128i(a);
+
+    // inverse shift rows
+    w = vqtbl1q_u8(w, vld1q_u8(inv_shift_rows));
+
+    // inverse sub bytes
+    v = vqtbl4q_u8(_sse2neon_vld1q_u8_x4(_sse2neon_rsbox), w);
+    v = vqtbx4q_u8(v, _sse2neon_vld1q_u8_x4(_sse2neon_rsbox + 0x40), w - 0x40);
+    v = vqtbx4q_u8(v, _sse2neon_vld1q_u8_x4(_sse2neon_rsbox + 0x80), w - 0x80);
+    v = vqtbx4q_u8(v, _sse2neon_vld1q_u8_x4(_sse2neon_rsbox + 0xc0), w - 0xc0);
+
+    // add round key
+    return vreinterpretq_m128i_u8(v) ^ RoundKey;
+
+#else /* ARMv7-A NEON implementation */
+    /* FIXME: optimized for NEON */
+    uint8_t v[4][4];
+    uint8_t *_a = (uint8_t *) &a;
+    for (int i = 0; i < 16; ++i) {
+        v[((i / 4) + (i % 4)) % 4][i % 4] = _sse2neon_rsbox[_a[i]];
+    }
+
+    return vreinterpretq_m128i_u8(vld1q_u8((uint8_t *) v)) ^ RoundKey;
+#endif
+}
+
+// Perform the InvMixColumns transformation on a and store the result in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_aesimc_si128
+FORCE_INLINE __m128i _mm_aesimc_si128(__m128i a)
+{
+#if defined(__aarch64__)
+    static const uint8_t ror32by8[] = {
+        0x1, 0x2, 0x3, 0x0, 0x5, 0x6, 0x7, 0x4,
+        0x9, 0xa, 0xb, 0x8, 0xd, 0xe, 0xf, 0xc,
+    };
+    uint8x16_t v = vreinterpretq_u8_m128i(a);
+    uint8x16_t w;
+
+    // multiplying 'v' by 4 in GF(2^8)
+    w = (v << 1) ^ (uint8x16_t) (((int8x16_t) v >> 7) & 0x1b);
+    w = (w << 1) ^ (uint8x16_t) (((int8x16_t) w >> 7) & 0x1b);
+    v ^= w;
+    v ^= (uint8x16_t) vrev32q_u16((uint16x8_t) w);
+
+    // multiplying 'v' by 2 in GF(2^8)
+    w = (v << 1) ^ (uint8x16_t) (((int8x16_t) v >> 7) & 0x1b);
+    w ^= (uint8x16_t) vrev32q_u16((uint16x8_t) v);
+    w ^= vqtbl1q_u8(v ^ w, vld1q_u8(ror32by8));
+    return vreinterpretq_m128i_u8(w);
+
+#else /* ARMv7-A NEON implementation */
+    uint8_t i, e, f, g, h, v[4][4];
+    vst1q_u8((uint8_t *) v, vreinterpretq_u8_m128i(a));
+    for (i = 0; i < 4; ++i) {
+        e = v[i][0];
+        f = v[i][1];
+        g = v[i][2];
+        h = v[i][3];
+
+        v[i][0] = SSE2NEON_MULTIPLY(e, 0x0e) ^ SSE2NEON_MULTIPLY(f, 0x0b) ^
+                  SSE2NEON_MULTIPLY(g, 0x0d) ^ SSE2NEON_MULTIPLY(h, 0x09);
+        v[i][1] = SSE2NEON_MULTIPLY(e, 0x09) ^ SSE2NEON_MULTIPLY(f, 0x0e) ^
+                  SSE2NEON_MULTIPLY(g, 0x0b) ^ SSE2NEON_MULTIPLY(h, 0x0d);
+        v[i][2] = SSE2NEON_MULTIPLY(e, 0x0d) ^ SSE2NEON_MULTIPLY(f, 0x09) ^
+                  SSE2NEON_MULTIPLY(g, 0x0e) ^ SSE2NEON_MULTIPLY(h, 0x0b);
+        v[i][3] = SSE2NEON_MULTIPLY(e, 0x0b) ^ SSE2NEON_MULTIPLY(f, 0x0d) ^
+                  SSE2NEON_MULTIPLY(g, 0x09) ^ SSE2NEON_MULTIPLY(h, 0x0e);
+    }
+
+    return vreinterpretq_m128i_u8(vld1q_u8((uint8_t *) v));
+#endif
+}
+
+// Assist in expanding the AES cipher key by computing steps towards generating
+// a round key for encryption cipher using data from a and an 8-bit round
+// constant specified in imm8, and store the result in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_aeskeygenassist_si128
+//
+// Emits the Advanced Encryption Standard (AES) instruction aeskeygenassist.
+// This instruction generates a round key for AES encryption. See
+// https://kazakov.life/2017/11/01/cryptocurrency-mining-on-ios-devices/
+// for details.
+FORCE_INLINE __m128i _mm_aeskeygenassist_si128(__m128i a, const int rcon)
+{
+#if defined(__aarch64__)
+    uint8x16_t _a = vreinterpretq_u8_m128i(a);
+    uint8x16_t v = vqtbl4q_u8(_sse2neon_vld1q_u8_x4(_sse2neon_sbox), _a);
+    v = vqtbx4q_u8(v, _sse2neon_vld1q_u8_x4(_sse2neon_sbox + 0x40), _a - 0x40);
+    v = vqtbx4q_u8(v, _sse2neon_vld1q_u8_x4(_sse2neon_sbox + 0x80), _a - 0x80);
+    v = vqtbx4q_u8(v, _sse2neon_vld1q_u8_x4(_sse2neon_sbox + 0xc0), _a - 0xc0);
+
+    uint32x4_t v_u32 = vreinterpretq_u32_u8(v);
+    uint32x4_t ror_v = vorrq_u32(vshrq_n_u32(v_u32, 8), vshlq_n_u32(v_u32, 24));
+    uint32x4_t ror_xor_v = veorq_u32(ror_v, vdupq_n_u32(rcon));
+
+    return vreinterpretq_m128i_u32(vtrn2q_u32(v_u32, ror_xor_v));
+
+#else /* ARMv7-A NEON implementation */
+    uint32_t X1 = _mm_cvtsi128_si32(_mm_shuffle_epi32(a, 0x55));
+    uint32_t X3 = _mm_cvtsi128_si32(_mm_shuffle_epi32(a, 0xFF));
+    for (int i = 0; i < 4; ++i) {
+        ((uint8_t *) &X1)[i] = _sse2neon_sbox[((uint8_t *) &X1)[i]];
+        ((uint8_t *) &X3)[i] = _sse2neon_sbox[((uint8_t *) &X3)[i]];
+    }
+    return _mm_set_epi32(((X3 >> 8) | (X3 << 24)) ^ rcon, X3,
+                         ((X1 >> 8) | (X1 << 24)) ^ rcon, X1);
+#endif
+}
+#undef SSE2NEON_AES_SBOX
+#undef SSE2NEON_AES_RSBOX
+
+#if defined(__aarch64__)
+#undef SSE2NEON_XT
+#undef SSE2NEON_MULTIPLY
+#endif
+
+#else /* __ARM_FEATURE_CRYPTO */
+// Implements equivalent of 'aesenc' by combining AESE (with an empty key) and
+// AESMC and then manually applying the real key as an xor operation. This
+// unfortunately means an additional xor op; the compiler should be able to
+// optimize this away for repeated calls however. See
+// https://blog.michaelbrase.com/2018/05/08/emulating-x86-aes-intrinsics-on-armv8-a
+// for more details.
+FORCE_INLINE __m128i _mm_aesenc_si128(__m128i a, __m128i b)
+{
+    return vreinterpretq_m128i_u8(veorq_u8(
+        vaesmcq_u8(vaeseq_u8(vreinterpretq_u8_m128i(a), vdupq_n_u8(0))),
+        vreinterpretq_u8_m128i(b)));
+}
+
+// Perform one round of an AES decryption flow on data (state) in a using the
+// round key in RoundKey, and store the result in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_aesdec_si128
+FORCE_INLINE __m128i _mm_aesdec_si128(__m128i a, __m128i RoundKey)
+{
+    return vreinterpretq_m128i_u8(veorq_u8(
+        vaesimcq_u8(vaesdq_u8(vreinterpretq_u8_m128i(a), vdupq_n_u8(0))),
+        vreinterpretq_u8_m128i(RoundKey)));
+}
+
+// Perform the last round of an AES encryption flow on data (state) in a using
+// the round key in RoundKey, and store the result in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_aesenclast_si128
+FORCE_INLINE __m128i _mm_aesenclast_si128(__m128i a, __m128i RoundKey)
+{
+    return _mm_xor_si128(vreinterpretq_m128i_u8(vaeseq_u8(
+                             vreinterpretq_u8_m128i(a), vdupq_n_u8(0))),
+                         RoundKey);
+}
+
+// Perform the last round of an AES decryption flow on data (state) in a using
+// the round key in RoundKey, and store the result in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_aesdeclast_si128
+FORCE_INLINE __m128i _mm_aesdeclast_si128(__m128i a, __m128i RoundKey)
+{
+    return vreinterpretq_m128i_u8(
+        veorq_u8(vaesdq_u8(vreinterpretq_u8_m128i(a), vdupq_n_u8(0)),
+                 vreinterpretq_u8_m128i(RoundKey)));
+}
+
+// Perform the InvMixColumns transformation on a and store the result in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_aesimc_si128
+FORCE_INLINE __m128i _mm_aesimc_si128(__m128i a)
+{
+    return vreinterpretq_m128i_u8(vaesimcq_u8(vreinterpretq_u8_m128i(a)));
+}
+
+// Assist in expanding the AES cipher key by computing steps towards generating
+// a round key for encryption cipher using data from a and an 8-bit round
+// constant specified in imm8, and store the result in dst."
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_aeskeygenassist_si128
+FORCE_INLINE __m128i _mm_aeskeygenassist_si128(__m128i a, const int rcon)
+{
+    // AESE does ShiftRows and SubBytes on A
+    uint8x16_t u8 = vaeseq_u8(vreinterpretq_u8_m128i(a), vdupq_n_u8(0));
+
+#ifndef _MSC_VER
+    uint8x16_t dest = {
+        // Undo ShiftRows step from AESE and extract X1 and X3
+        u8[0x4], u8[0x1], u8[0xE], u8[0xB],  // SubBytes(X1)
+        u8[0x1], u8[0xE], u8[0xB], u8[0x4],  // ROT(SubBytes(X1))
+        u8[0xC], u8[0x9], u8[0x6], u8[0x3],  // SubBytes(X3)
+        u8[0x9], u8[0x6], u8[0x3], u8[0xC],  // ROT(SubBytes(X3))
+    };
+    uint32x4_t r = {0, (unsigned) rcon, 0, (unsigned) rcon};
+    return vreinterpretq_m128i_u8(dest) ^ vreinterpretq_m128i_u32(r);
+#else
+    // We have to do this hack because MSVC is strictly adhering to the CPP
+    // standard, in particular C++03 8.5.1 sub-section 15, which states that
+    // unions must be initialized by their first member type.
+
+    // As per the Windows ARM64 ABI, it is always little endian, so this works
+    __n128 dest{
+        ((uint64_t) u8.n128_u8[0x4] << 0) | ((uint64_t) u8.n128_u8[0x1] << 8) |
+            ((uint64_t) u8.n128_u8[0xE] << 16) |
+            ((uint64_t) u8.n128_u8[0xB] << 24) |
+            ((uint64_t) u8.n128_u8[0x1] << 32) |
+            ((uint64_t) u8.n128_u8[0xE] << 40) |
+            ((uint64_t) u8.n128_u8[0xB] << 48) |
+            ((uint64_t) u8.n128_u8[0x4] << 56),
+        ((uint64_t) u8.n128_u8[0xC] << 0) | ((uint64_t) u8.n128_u8[0x9] << 8) |
+            ((uint64_t) u8.n128_u8[0x6] << 16) |
+            ((uint64_t) u8.n128_u8[0x3] << 24) |
+            ((uint64_t) u8.n128_u8[0x9] << 32) |
+            ((uint64_t) u8.n128_u8[0x6] << 40) |
+            ((uint64_t) u8.n128_u8[0x3] << 48) |
+            ((uint64_t) u8.n128_u8[0xC] << 56)};
+
+    dest.n128_u32[1] = dest.n128_u32[1] ^ rcon;
+    dest.n128_u32[3] = dest.n128_u32[3] ^ rcon;
+
+    return dest;
+#endif
+}
+#endif
+
+/* Others */
+
+// Perform a carry-less multiplication of two 64-bit integers, selected from a
+// and b according to imm8, and store the results in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_clmulepi64_si128
+FORCE_INLINE __m128i _mm_clmulepi64_si128(__m128i _a, __m128i _b, const int imm)
+{
+    uint64x2_t a = vreinterpretq_u64_m128i(_a);
+    uint64x2_t b = vreinterpretq_u64_m128i(_b);
+    switch (imm & 0x11) {
+    case 0x00:
+        return vreinterpretq_m128i_u64(
+            _sse2neon_vmull_p64(vget_low_u64(a), vget_low_u64(b)));
+    case 0x01:
+        return vreinterpretq_m128i_u64(
+            _sse2neon_vmull_p64(vget_high_u64(a), vget_low_u64(b)));
+    case 0x10:
+        return vreinterpretq_m128i_u64(
+            _sse2neon_vmull_p64(vget_low_u64(a), vget_high_u64(b)));
+    case 0x11:
+        return vreinterpretq_m128i_u64(
+            _sse2neon_vmull_p64(vget_high_u64(a), vget_high_u64(b)));
+    default:
+        abort();
+    }
+}
+
+FORCE_INLINE unsigned int _sse2neon_mm_get_denormals_zero_mode(void)
+{
+    union {
+        fpcr_bitfield field;
+#if defined(__aarch64__) || defined(_M_ARM64)
+        uint64_t value;
+#else
+        uint32_t value;
+#endif
+    } r;
+
+#if defined(__aarch64__) || defined(_M_ARM64)
+    r.value = _sse2neon_get_fpcr();
+#else
+    __asm__ __volatile__("vmrs %0, FPSCR" : "=r"(r.value)); /* read */
+#endif
+
+    return r.field.bit24 ? _MM_DENORMALS_ZERO_ON : _MM_DENORMALS_ZERO_OFF;
+}
+
+// Count the number of bits set to 1 in unsigned 32-bit integer a, and
+// return that count in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_popcnt_u32
+FORCE_INLINE int _mm_popcnt_u32(unsigned int a)
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+#if __has_builtin(__builtin_popcount)
+    return __builtin_popcount(a);
+#elif defined(_MSC_VER)
+    return _CountOneBits(a);
+#else
+    return (int) vaddlv_u8(vcnt_u8(vcreate_u8((uint64_t) a)));
+#endif
+#else
+    uint32_t count = 0;
+    uint8x8_t input_val, count8x8_val;
+    uint16x4_t count16x4_val;
+    uint32x2_t count32x2_val;
+
+    input_val = vld1_u8((uint8_t *) &a);
+    count8x8_val = vcnt_u8(input_val);
+    count16x4_val = vpaddl_u8(count8x8_val);
+    count32x2_val = vpaddl_u16(count16x4_val);
+
+    vst1_u32(&count, count32x2_val);
+    return count;
+#endif
+}
+
+// Count the number of bits set to 1 in unsigned 64-bit integer a, and
+// return that count in dst.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_popcnt_u64
+FORCE_INLINE int64_t _mm_popcnt_u64(uint64_t a)
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+#if __has_builtin(__builtin_popcountll)
+    return __builtin_popcountll(a);
+#elif defined(_MSC_VER)
+    return _CountOneBits64(a);
+#else
+    return (int64_t) vaddlv_u8(vcnt_u8(vcreate_u8(a)));
+#endif
+#else
+    uint64_t count = 0;
+    uint8x8_t input_val, count8x8_val;
+    uint16x4_t count16x4_val;
+    uint32x2_t count32x2_val;
+    uint64x1_t count64x1_val;
+
+    input_val = vld1_u8((uint8_t *) &a);
+    count8x8_val = vcnt_u8(input_val);
+    count16x4_val = vpaddl_u8(count8x8_val);
+    count32x2_val = vpaddl_u16(count16x4_val);
+    count64x1_val = vpaddl_u32(count32x2_val);
+    vst1_u64(&count, count64x1_val);
+    return count;
+#endif
+}
+
+FORCE_INLINE void _sse2neon_mm_set_denormals_zero_mode(unsigned int flag)
+{
+    // AArch32 Advanced SIMD arithmetic always uses the Flush-to-zero setting,
+    // regardless of the value of the FZ bit.
+    union {
+        fpcr_bitfield field;
+#if defined(__aarch64__) || defined(_M_ARM64)
+        uint64_t value;
+#else
+        uint32_t value;
+#endif
+    } r;
+
+#if defined(__aarch64__) || defined(_M_ARM64)
+    r.value = _sse2neon_get_fpcr();
+#else
+    __asm__ __volatile__("vmrs %0, FPSCR" : "=r"(r.value)); /* read */
+#endif
+
+    r.field.bit24 = (flag & _MM_DENORMALS_ZERO_MASK) == _MM_DENORMALS_ZERO_ON;
+
+#if defined(__aarch64__) || defined(_M_ARM64)
+    _sse2neon_set_fpcr(r.value);
+#else
+    __asm__ __volatile__("vmsr FPSCR, %0" ::"r"(r));        /* write */
+#endif
+}
+
+// Return the current 64-bit value of the processor's time-stamp counter.
+// https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=rdtsc
+FORCE_INLINE uint64_t _rdtsc(void)
+{
+#if defined(__aarch64__) || defined(_M_ARM64)
+    uint64_t val;
+
+    /* According to ARM DDI 0487F.c, from Armv8.0 to Armv8.5 inclusive, the
+     * system counter is at least 56 bits wide; from Armv8.6, the counter
+     * must be 64 bits wide.  So the system counter could be less than 64
+     * bits wide and it is attributed with the flag 'cap_user_time_short'
+     * is true.
+     */
+#if defined(_MSC_VER)
+    val = _ReadStatusReg(ARM64_SYSREG(3, 3, 14, 0, 2));
+#else
+    __asm__ __volatile__("mrs %0, cntvct_el0" : "=r"(val));
+#endif
+
+    return val;
+#else
+    uint32_t pmccntr, pmuseren, pmcntenset;
+    // Read the user mode Performance Monitoring Unit (PMU)
+    // User Enable Register (PMUSERENR) access permissions.
+    __asm__ __volatile__("mrc p15, 0, %0, c9, c14, 0" : "=r"(pmuseren));
+    if (pmuseren & 1) {  // Allows reading PMUSERENR for user mode code.
+        __asm__ __volatile__("mrc p15, 0, %0, c9, c12, 1" : "=r"(pmcntenset));
+        if (pmcntenset & 0x80000000UL) {  // Is it counting?
+            __asm__ __volatile__("mrc p15, 0, %0, c9, c13, 0" : "=r"(pmccntr));
+            // The counter is set up to count every 64th cycle
+            return (uint64_t) (pmccntr) << 6;
+        }
+    }
+
+    // Fallback to syscall as we can't enable PMUSERENR in user mode.
+    struct timeval tv;
+    gettimeofday(&tv, NULL);
+    return (uint64_t) (tv.tv_sec) * 1000000 + tv.tv_usec;
+#endif
+}
+
+#if defined(__GNUC__) || defined(__clang__)
+#pragma pop_macro("ALIGN_STRUCT")
+#pragma pop_macro("FORCE_INLINE")
+#endif
+
+#if defined(__GNUC__) && !defined(__clang__)
+#pragma GCC pop_options
+#endif
+
+#endif
+
diff --git a/src/filter/publicfilters/SequenceIdProcess.cpp b/src/filter/publicfilters/SequenceIdProcess.cpp
new file mode 100644
index 00000000..662d8596
--- /dev/null
+++ b/src/filter/publicfilters/SequenceIdProcess.cpp
@@ -0,0 +1,77 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "SequenceIdProcess.hpp"
+#include "exception/ObException.hpp"
+#include "logger/LoggerInterval.hpp"
+#include "frame/FrameFactory.hpp"
+#include "libobsensor/h/ObTypes.h"
+
+namespace libobsensor {
+
+SequenceIdFilter::SequenceIdFilter() {}
+SequenceIdFilter::~SequenceIdFilter() noexcept {}
+
+void SequenceIdFilter::updateConfig(std::vector<std::string> &params) {
+    if(params.size() != 1) {
+        throw invalid_value_exception("SequenceIdFilter config error: params size not match");
+    }
+    try {
+
+        int select_sequence_id = std::stoi(params[0]);
+        if(select_sequence_id >= -1 && select_sequence_id <= 1) {
+            if(select_sequence_id != selectedID_) {
+                std::lock_guard<std::recursive_mutex> lk(valueUpdateMutex_);
+                selectedID_ = select_sequence_id;
+            }
+        }
+    }
+    catch(const std::exception &e) {
+        throw invalid_value_exception("SequenceIdFilter config error: " + std::string(e.what()));
+    }
+}
+
+const std::string &SequenceIdFilter::getConfigSchema() const {
+    // csv format: name，type， min，max，step，default，description
+    static const std::string schema = "sequenceid, integer, -1, 1, 1, 0, frame data sequence id value";
+    return schema;
+}
+
+void SequenceIdFilter::reset() {
+    std::lock_guard<std::recursive_mutex> lk(valueUpdateMutex_);
+    recentFrames_.clear();
+}
+
+std::shared_ptr<Frame> SequenceIdFilter::process(std::shared_ptr<const Frame> frame) {
+    if(!frame) {
+        return nullptr;
+    }
+
+    auto outFrame = FrameFactory::createFrameFromOtherFrame(frame, true);
+    if(outFrame->is<FrameSet>()) {
+        LOG_WARN_INTVL("The Frame processed by SequenceIdFilter cannot be FrameSet!");
+        return outFrame;
+    }
+
+    int64_t seq = selectedID_ == -1 ? 1 : 0;
+    TRY_EXECUTE({ seq = outFrame->getMetadataValue(OB_FRAME_METADATA_TYPE_HDR_SEQUENCE_INDEX); });
+    OBFrameType type = outFrame->getType();
+    auto        key  = std::make_pair(seq, type);
+
+    std::lock_guard<std::recursive_mutex> lk(valueUpdateMutex_);
+    // should filter but the current frame id does not matched
+    if((selectedID_ != -1) && seq != selectedID_) {
+        key.first = (seq == 0) ? 1 : 0;
+        if(recentFrames_[key]) {
+            outFrame = recentFrames_[key];
+        }
+    }
+    else {
+        recentFrames_[key] = outFrame;
+    }
+    // should not filter, or the current frame id matches
+    return outFrame;
+}
+
+}  // namespace libobsensor
+
diff --git a/src/filter/publicfilters/SequenceIdProcess.hpp b/src/filter/publicfilters/SequenceIdProcess.hpp
new file mode 100644
index 00000000..2f2e012b
--- /dev/null
+++ b/src/filter/publicfilters/SequenceIdProcess.hpp
@@ -0,0 +1,33 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include "IFilter.hpp"
+#include <mutex>
+#include <map>
+
+namespace libobsensor {
+
+class SequenceIdFilter : public IFilterBase {
+public:
+    SequenceIdFilter();
+    virtual ~SequenceIdFilter() noexcept;
+
+    void               updateConfig(std::vector<std::string> &params) override;
+    const std::string &getConfigSchema() const override;
+    void               reset() override;
+
+private:
+    std::shared_ptr<Frame> process(std::shared_ptr<const Frame> frame) override;
+
+protected:
+    std::recursive_mutex valueUpdateMutex_;
+
+    // selected id; 0 for all
+    int32_t selectedID_ = 0;
+
+    std::map<std::pair<int64_t, OBFrameType>, std::shared_ptr<Frame>> recentFrames_;
+};
+
+}  // namespace libobsensor
+
diff --git a/src/filter/publicfilters/publicFilterLoader.cpp b/src/filter/publicfilters/publicFilterLoader.cpp
new file mode 100644
index 00000000..1b5a327f
--- /dev/null
+++ b/src/filter/publicfilters/publicFilterLoader.cpp
@@ -0,0 +1,47 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "publicFilterLoader.hpp"
+#include "FramePixelValueProcess.hpp"
+#include "HdrMergeProcess.hpp"
+#include "SequenceIdProcess.hpp"
+#include "DecimationProcess.hpp"
+#include "IMUFrameReversion.hpp"
+#include "FormatConverterProcess.hpp"
+#include "FrameGeometricTransform.hpp"
+#include "PointCloudProcess.hpp"
+#include "IMUCorrector.hpp"
+#include "Align.hpp"
+#include "FilterDecorator.hpp"
+
+namespace libobsensor {
+publicFilterCreator::publicFilterCreator(std::function<std::shared_ptr<IFilter>()> creatorFunc) : creatorFunc_(creatorFunc) {}
+
+std::shared_ptr<IFilter> publicFilterCreator::create() {
+    return creatorFunc_();
+}
+
+namespace PublicFilterCreatorLoader {
+
+#define ADD_FILTER_CREATOR(name)                                       \
+    { #name, std::make_shared<publicFilterCreator>([]() {              \
+          auto basefilter = std::make_shared<name>();                  \
+          return std::make_shared<FilterDecorator>(#name, basefilter); \
+      }) }
+
+std::map<std::string, std::shared_ptr<IFilterCreator>> getCreators() {
+    static std::map<std::string, std::shared_ptr<IFilterCreator>> filterCreators = {
+        ADD_FILTER_CREATOR(PixelValueScaler),  ADD_FILTER_CREATOR(ThresholdFilter),
+        ADD_FILTER_CREATOR(PixelValueOffset),  ADD_FILTER_CREATOR(HDRMerge),
+        ADD_FILTER_CREATOR(SequenceIdFilter),  ADD_FILTER_CREATOR(DecimationFilter),
+        ADD_FILTER_CREATOR(IMUFrameReversion), ADD_FILTER_CREATOR(FormatConverter),
+        ADD_FILTER_CREATOR(FrameMirror),       ADD_FILTER_CREATOR(FrameFlip),
+        ADD_FILTER_CREATOR(FrameRotate),       ADD_FILTER_CREATOR(PointCloudFilter),
+        ADD_FILTER_CREATOR(IMUCorrector),      ADD_FILTER_CREATOR(Align),
+    };
+
+    return filterCreators;
+}
+
+}  // namespace PublicFilterCreatorLoader
+}  // namespace libobsensor
diff --git a/src/filter/publicfilters/publicFilterLoader.hpp b/src/filter/publicfilters/publicFilterLoader.hpp
new file mode 100644
index 00000000..6a714dd9
--- /dev/null
+++ b/src/filter/publicfilters/publicFilterLoader.hpp
@@ -0,0 +1,28 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include <map>
+#include "IFilter.hpp"
+#include <functional>
+
+namespace libobsensor {
+
+class publicFilterCreator : public IFilterCreator {
+public:
+    static std::map<std::string, std::shared_ptr<IFilterCreator>> getPublicFilterCreators();
+public:
+    publicFilterCreator(std::function<std::shared_ptr<IFilter>()> creatorFunc);
+
+    virtual ~publicFilterCreator() = default;
+
+    std::shared_ptr<IFilter> create() override;
+private:
+    std::function<std::shared_ptr<IFilter>()> creatorFunc_;
+};
+
+namespace PublicFilterCreatorLoader {
+    std::map<std::string, std::shared_ptr<IFilterCreator>> getCreators();
+}
+
+}  // namespace libobsensor
diff --git a/src/impl/Advanced.cpp b/src/impl/Advanced.cpp
new file mode 100644
index 00000000..c1223efa
--- /dev/null
+++ b/src/impl/Advanced.cpp
@@ -0,0 +1,193 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "libobsensor/h/Advanced.h"
+
+#include "ImplTypes.hpp"
+
+#include "IDepthWorkModeManager.hpp"
+#include "IPresetManager.hpp"
+#include "IDevice.hpp"
+#include "IDeviceComponent.hpp"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+ob_depth_work_mode ob_device_get_current_depth_work_mode(const ob_device *device, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(device);
+    auto               workModeMgr = device->device->getComponentT<libobsensor::IDepthWorkModeManager>(libobsensor::OB_DEV_COMPONENT_DEPTH_WORK_MODE_MANAGER);
+    auto               checksum    = workModeMgr->getCurrentDepthWorkMode();
+    ob_depth_work_mode work_mode;
+    memcpy(work_mode.checksum, checksum.checksum, sizeof(checksum.checksum));
+    memcpy(work_mode.name, checksum.name, sizeof(work_mode.name));
+    return work_mode;
+}
+HANDLE_EXCEPTIONS_AND_RETURN({}, device)
+
+const char *ob_device_get_current_depth_work_mode_name(const ob_device *device, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(device);
+    auto               workModeMgr = device->device->getComponentT<libobsensor::IDepthWorkModeManager>(libobsensor::OB_DEV_COMPONENT_DEPTH_WORK_MODE_MANAGER);
+    auto               &checksum    = workModeMgr->getCurrentDepthWorkMode();
+    return checksum.name;
+}
+HANDLE_EXCEPTIONS_AND_RETURN({}, device)
+
+ob_status ob_device_switch_depth_work_mode(ob_device *device, const ob_depth_work_mode *work_mode, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(device);
+    VALIDATE_NOT_NULL(work_mode);
+
+    auto workModeMgr = device->device->getComponentT<libobsensor::IDepthWorkModeManager>(libobsensor::OB_DEV_COMPONENT_DEPTH_WORK_MODE_MANAGER);
+    workModeMgr->switchDepthWorkMode(work_mode->name);
+    return OB_STATUS_OK;
+}
+HANDLE_EXCEPTIONS_AND_RETURN(OB_STATUS_ERROR, device, work_mode)
+
+ob_status ob_device_switch_depth_work_mode_by_name(ob_device *device, const char *mode_name, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(device);
+    VALIDATE_NOT_NULL(mode_name);
+
+    auto workModeMgr = device->device->getComponentT<libobsensor::IDepthWorkModeManager>(libobsensor::OB_DEV_COMPONENT_DEPTH_WORK_MODE_MANAGER);
+    workModeMgr->switchDepthWorkMode(mode_name);
+    return OB_STATUS_OK;
+}
+HANDLE_EXCEPTIONS_AND_RETURN(OB_STATUS_ERROR, device, mode_name)
+
+ob_depth_work_mode_list *ob_device_get_depth_work_mode_list(const ob_device *device, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(device);
+
+    auto workModeMgr   = device->device->getComponentT<libobsensor::IDepthWorkModeManager>(libobsensor::OB_DEV_COMPONENT_DEPTH_WORK_MODE_MANAGER);
+    auto workModeList  = workModeMgr->getDepthWorkModeList();
+    auto impl          = new ob_depth_work_mode_list();
+    impl->workModeList = workModeList;
+    return impl;
+}
+HANDLE_EXCEPTIONS_AND_RETURN(nullptr, device)
+
+uint32_t ob_depth_work_mode_list_get_count(const ob_depth_work_mode_list *work_mode_list, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(work_mode_list);
+    return static_cast<uint32_t>(work_mode_list->workModeList.size());
+}
+HANDLE_EXCEPTIONS_AND_RETURN(0, work_mode_list)
+
+ob_depth_work_mode ob_depth_work_mode_list_get_item(const ob_depth_work_mode_list *work_mode_list, uint32_t index, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(work_mode_list);
+    VALIDATE_UNSIGNED_INDEX(index, work_mode_list->workModeList.size());
+    auto               workMode = work_mode_list->workModeList.at(index);
+    ob_depth_work_mode impl;
+    memcpy(impl.checksum, workMode.checksum, sizeof(workMode.checksum));
+    memcpy(impl.name, workMode.name, sizeof(workMode.name));
+    return impl;
+}
+HANDLE_EXCEPTIONS_AND_RETURN({}, work_mode_list, index)
+
+void ob_delete_depth_work_mode_list(ob_depth_work_mode_list *work_mode_list, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(work_mode_list);
+    delete work_mode_list;
+}
+HANDLE_EXCEPTIONS_NO_RETURN(work_mode_list)
+
+const char *ob_device_get_current_preset_name(const ob_device *device, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(device);
+    auto presetMgr = device->device->getComponentT<libobsensor::IPresetManager>(libobsensor::OB_DEV_COMPONENT_PRESET_MANAGER);
+    return presetMgr->getCurrentPresetName().c_str();
+}
+HANDLE_EXCEPTIONS_AND_RETURN(nullptr, device)
+
+void ob_device_load_preset(ob_device *device, const char *preset_name, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(device);
+    VALIDATE_NOT_NULL(preset_name);
+
+    auto presetMgr = device->device->getComponentT<libobsensor::IPresetManager>(libobsensor::OB_DEV_COMPONENT_PRESET_MANAGER);
+
+    presetMgr->loadPreset(preset_name);
+}
+HANDLE_EXCEPTIONS_NO_RETURN(device, preset_name)
+
+void ob_device_load_preset_from_json_file(ob_device *device, const char *json_file_path, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(device);
+    VALIDATE_NOT_NULL(json_file_path);
+
+    auto presetMgr = device->device->getComponentT<libobsensor::IPresetManager>(libobsensor::OB_DEV_COMPONENT_PRESET_MANAGER);
+    presetMgr->loadPresetFromJsonFile(json_file_path);
+}
+HANDLE_EXCEPTIONS_NO_RETURN(device, json_file_path)
+
+void ob_device_load_preset_from_json_data(ob_device *device, const char *presetName, const uint8_t *data, uint32_t size, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(device);
+    VALIDATE_NOT_NULL(data);
+
+    auto                 presetMgr = device->device->getComponentT<libobsensor::IPresetManager>(libobsensor::OB_DEV_COMPONENT_PRESET_MANAGER);
+    std::vector<uint8_t> vecData(data, data + size);
+    presetMgr->loadPresetFromJsonData(presetName, vecData);
+}
+HANDLE_EXCEPTIONS_NO_RETURN(device, data)
+
+void ob_device_export_current_settings_as_preset_json_file(ob_device *device, const char *json_file_path, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(device);
+    VALIDATE_NOT_NULL(json_file_path);
+
+    auto presetMgr = device->device->getComponentT<libobsensor::IPresetManager>(libobsensor::OB_DEV_COMPONENT_PRESET_MANAGER);
+    presetMgr->exportSettingsAsPresetJsonFile(json_file_path);
+}
+HANDLE_EXCEPTIONS_NO_RETURN(device, json_file_path)
+
+void ob_device_export_current_settings_as_preset_json_data(ob_device *device, const char *presetName, const uint8_t **data, uint32_t *dataSize,
+                                                           ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(device);
+
+    auto        presetMgr = device->device->getComponentT<libobsensor::IPresetManager>(libobsensor::OB_DEV_COMPONENT_PRESET_MANAGER);
+    const auto &jsonData  = presetMgr->exportSettingsAsPresetJsonData(presetName);
+    *data                 = (const uint8_t *)jsonData.data();
+    *dataSize             = (uint32_t)jsonData.size();
+}
+HANDLE_EXCEPTIONS_NO_RETURN(device, presetName)
+
+ob_device_preset_list *ob_device_get_available_preset_list(const ob_device *device, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(device);
+    auto impl = new ob_device_preset_list();
+
+    auto presetMgr = device->device->getComponentT<libobsensor::IPresetManager>(libobsensor::OB_DEV_COMPONENT_PRESET_MANAGER, false);
+    if(presetMgr) {
+        auto presetList  = presetMgr->getAvailablePresetList();
+        impl->presetList = presetList;
+    }
+
+    return impl;
+}
+HANDLE_EXCEPTIONS_AND_RETURN(nullptr, device)
+
+void ob_delete_preset_list(ob_device_preset_list *preset_list, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(preset_list);
+    delete preset_list;
+}
+HANDLE_EXCEPTIONS_NO_RETURN(preset_list)
+
+uint32_t ob_device_preset_list_get_count(const ob_device_preset_list *preset_list, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(preset_list);
+    return static_cast<uint32_t>(preset_list->presetList.size());
+}
+HANDLE_EXCEPTIONS_AND_RETURN(0, preset_list)
+
+const char *ob_device_preset_list_get_name(const ob_device_preset_list *preset_list, uint32_t index, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(preset_list);
+    VALIDATE_UNSIGNED_INDEX(index, preset_list->presetList.size());
+    return preset_list->presetList.at(index).c_str();
+}
+HANDLE_EXCEPTIONS_AND_RETURN(nullptr, preset_list, index)
+
+bool ob_device_preset_list_has_preset(const ob_device_preset_list *preset_list, const char *preset_name, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(preset_list);
+    VALIDATE_NOT_NULL(preset_name);
+    for(auto &name: preset_list->presetList) {
+        if(name == preset_name) {
+            return true;
+        }
+    }
+    return false;
+}
+HANDLE_EXCEPTIONS_AND_RETURN(false, preset_list, preset_name)
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/src/impl/Context.cpp b/src/impl/Context.cpp
new file mode 100644
index 00000000..4066d827
--- /dev/null
+++ b/src/impl/Context.cpp
@@ -0,0 +1,120 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "libobsensor/h/Context.h"
+
+#include "ImplTypes.hpp"
+#include "logger/Logger.hpp"
+#include "context/Context.hpp"
+#include "environment/EnvConfig.hpp"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+ob_context *ob_create_context(ob_error **error) BEGIN_API_CALL {
+    auto ctx      = libobsensor::Context::getInstance();
+    auto impl     = new ob_context();
+    impl->context = ctx;
+    return impl;
+}
+NO_ARGS_HANDLE_EXCEPTIONS_AND_RETURN(nullptr)
+
+ob_context *ob_create_context_with_config(const char *config_path, ob_error **error) BEGIN_API_CALL {
+    auto ctx      = libobsensor::Context::getInstance(config_path);
+    auto impl     = new ob_context();
+    impl->context = ctx;
+    return impl;
+}
+NO_ARGS_HANDLE_EXCEPTIONS_AND_RETURN(nullptr)
+
+void ob_delete_context(ob_context *context, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(context);
+    delete context;
+}
+HANDLE_EXCEPTIONS_NO_RETURN(context)
+
+ob_device_list *ob_query_device_list(ob_context *context, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(context);
+    auto deviceMgr    = context->context->getDeviceManager();
+    auto devListImpl  = new ob_device_list();
+    devListImpl->list = deviceMgr->getDeviceInfoList();
+    return devListImpl;
+}
+HANDLE_EXCEPTIONS_AND_RETURN(nullptr, context)
+
+void ob_enable_net_device_enumeration(ob_context *context, bool enable, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(context);
+    auto deviceMgr = context->context->getDeviceManager();
+    deviceMgr->enableNetDeviceEnumeration(enable);
+}
+HANDLE_EXCEPTIONS_NO_RETURN(context, enable)
+
+ob_device *ob_create_net_device(ob_context *context, const char *address, uint16_t port, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(context);
+    auto deviceMgr  = context->context->getDeviceManager();
+    auto device     = deviceMgr->createNetDevice(address, port);
+    auto devImpl    = new ob_device();
+    devImpl->device = device;
+    return devImpl;
+}
+HANDLE_EXCEPTIONS_AND_RETURN(nullptr, context, address, port)
+
+void ob_set_device_changed_callback(ob_context *context, ob_device_changed_callback callback, void *user_data, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(context);
+    auto deviceMgr = context->context->getDeviceManager();
+    deviceMgr->setDeviceChangedCallback([callback, user_data](std::vector<std::shared_ptr<const libobsensor::IDeviceEnumInfo>> removed,
+                                                              std::vector<std::shared_ptr<const libobsensor::IDeviceEnumInfo>> added) {
+        auto removedImpl  = new ob_device_list();
+        removedImpl->list = removed;
+        auto addedImpl    = new ob_device_list();
+        addedImpl->list   = added;
+        callback(removedImpl, addedImpl, user_data);
+    });
+}
+HANDLE_EXCEPTIONS_NO_RETURN(context, callback, user_data)
+
+void ob_enable_device_clock_sync(ob_context *context, uint64_t repeat_interval_msec, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(context);
+    auto deviceMgr = context->context->getDeviceManager();
+    deviceMgr->enableDeviceClockSync(repeat_interval_msec);
+}
+HANDLE_EXCEPTIONS_NO_RETURN(context, repeat_interval_msec)
+
+void ob_free_idle_memory(ob_context *context, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(context);
+    auto frameMemPool = context->context->getFrameMemoryPool();
+    frameMemPool->freeIdleMemory();
+}
+HANDLE_EXCEPTIONS_NO_RETURN(context)
+
+void ob_set_logger_severity(ob_log_severity severity, ob_error **error) BEGIN_API_CALL {
+    libobsensor::Logger::setLogSeverity(severity);
+}
+HANDLE_EXCEPTIONS_NO_RETURN(severity)
+
+void ob_set_logger_to_file(ob_log_severity severity, const char *directory, ob_error **error) BEGIN_API_CALL {
+    libobsensor::Logger::setFileLogConfig(severity, directory);
+}
+HANDLE_EXCEPTIONS_NO_RETURN(severity, directory)
+
+void ob_set_logger_to_callback(ob_log_severity severity, ob_log_callback callback, void *user_data, ob_error **error) BEGIN_API_CALL {
+    libobsensor::Logger::setLogCallback(severity, [callback, user_data](ob_log_severity severity, const std::string logMsg) {  //
+        callback(severity, logMsg.c_str(), user_data);
+    });
+}
+HANDLE_EXCEPTIONS_NO_RETURN(severity, callback, user_data)
+
+void ob_set_logger_to_console(ob_log_severity severity, ob_error **error) BEGIN_API_CALL {
+    libobsensor::Logger::setConsoleLogSeverity(severity);
+}
+HANDLE_EXCEPTIONS_NO_RETURN(severity)
+
+void ob_set_extensions_directory(const char *directory, ob_error **error) BEGIN_API_CALL {
+    libobsensor::EnvConfig::setExtensionsDirectory(directory);
+}
+HANDLE_EXCEPTIONS_NO_RETURN(directory)
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/src/impl/Device.cpp b/src/impl/Device.cpp
new file mode 100644
index 00000000..b905750d
--- /dev/null
+++ b/src/impl/Device.cpp
@@ -0,0 +1,538 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "libobsensor/h/Device.h"
+
+#include "ImplTypes.hpp"
+#include "exception/ObException.hpp"
+
+#include "IDeviceManager.hpp"
+#include "IProperty.hpp"
+#include "IDevice.hpp"
+#include "IDeviceMonitor.hpp"
+#include "IAlgParamManager.hpp"
+#include "component/timestamp/GlobalTimestampFitter.hpp"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void ob_delete_device_list(ob_device_list *list, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(list);
+    delete list;
+}
+HANDLE_EXCEPTIONS_NO_RETURN(list)
+
+uint32_t ob_device_list_get_count(const ob_device_list *list, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(list);
+    return static_cast<uint32_t>(list->list.size());
+}
+HANDLE_EXCEPTIONS_AND_RETURN(0, list)
+
+const char *ob_device_list_get_device_name(const ob_device_list *list, uint32_t index, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(list);
+    VALIDATE_UNSIGNED_INDEX(index, list->list.size());
+    auto &info = list->list[index];
+    return info->getFullName().c_str();
+}
+HANDLE_EXCEPTIONS_AND_RETURN(nullptr, list, index)
+
+int ob_device_list_get_device_pid(const ob_device_list *list, uint32_t index, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(list);
+    VALIDATE_UNSIGNED_INDEX(index, list->list.size());
+    auto &info = list->list[index];
+    return info->getPid();
+}
+HANDLE_EXCEPTIONS_AND_RETURN(0, list, index)
+
+int ob_device_list_get_device_vid(const ob_device_list *list, uint32_t index, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(list);
+    VALIDATE_UNSIGNED_INDEX(index, list->list.size());
+    auto &info = list->list[index];
+    return info->getVid();
+}
+HANDLE_EXCEPTIONS_AND_RETURN(0, list, index)
+
+const char *ob_device_list_get_device_uid(const ob_device_list *list, uint32_t index, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(list);
+    VALIDATE_UNSIGNED_INDEX(index, list->list.size());
+    auto &info = list->list[index];
+    return info->getUid().c_str();
+}
+HANDLE_EXCEPTIONS_AND_RETURN(nullptr, list, index)
+
+const char *ob_device_list_get_device_serial_number(const ob_device_list *list, uint32_t index, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(list);
+    VALIDATE_UNSIGNED_INDEX(index, list->list.size());
+    auto &info = list->list[index];
+    return info->getDeviceSn().c_str();
+}
+HANDLE_EXCEPTIONS_AND_RETURN(nullptr, list, index)
+
+const char *ob_device_list_get_device_connection_type(const ob_device_list *list, uint32_t index, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(list);
+    VALIDATE_UNSIGNED_INDEX(index, list->list.size());
+    auto &info = list->list[index];
+    return info->getConnectionType().c_str();
+}
+HANDLE_EXCEPTIONS_AND_RETURN(nullptr, list, index)
+
+const char *ob_device_list_get_device_ip_address(const ob_device_list *list, uint32_t index, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(list);
+    VALIDATE_UNSIGNED_INDEX(index, list->list.size());
+    auto &info = list->list[index];
+    if(std::string(info->getConnectionType()) != "Ethernet") {
+        LOG_WARN("get ipAddress() failed! Only valid for Ethernet devices.");
+        return "0.0.0.0";
+    }
+
+    auto sourcePort    = info->getSourcePortInfoList().front();
+    auto netSourcePort = std::dynamic_pointer_cast<const libobsensor::NetSourcePortInfo>(sourcePort);
+    return netSourcePort->address.c_str();
+}
+HANDLE_EXCEPTIONS_AND_RETURN(nullptr, list, index)
+
+ob_device *ob_device_list_get_device(const ob_device_list *list, uint32_t index, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(list);
+    VALIDATE_UNSIGNED_INDEX(index, list->list.size());
+    auto &info      = list->list[index];
+    auto  deviceMgr = info->getDeviceManager();
+    auto  device    = deviceMgr->createDevice(info);
+
+    auto impl    = new ob_device();
+    impl->device = device;
+    return impl;
+}
+HANDLE_EXCEPTIONS_AND_RETURN(nullptr, list, index)
+
+ob_device *ob_device_list_get_device_by_serial_number(const ob_device_list *list, const char *serial_number, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(list);
+    VALIDATE_NOT_NULL(serial_number);
+    for(auto &info: list->list) {
+        if(info->getDeviceSn() == serial_number) {
+            auto deviceMgr = info->getDeviceManager();
+            auto device    = deviceMgr->createDevice(info);
+            auto impl      = new ob_device();
+            impl->device   = device;
+            return impl;
+        }
+    }
+    throw libobsensor::invalid_value_exception("Device not found by serial number: " + std::string(serial_number));
+}
+HANDLE_EXCEPTIONS_AND_RETURN(nullptr, list, serial_number)
+
+ob_device *ob_device_list_get_device_by_uid(const ob_device_list *list, const char *uid, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(list);
+    VALIDATE_NOT_NULL(uid);
+    for(auto &info: list->list) {
+        auto deviceUid = info->getUid();
+        if(deviceUid == uid
+#if defined(__linux__)
+           // For linux platform, the usb device uid is like "bus-port-dev", try to rm the dev part to match the uid
+           || deviceUid.substr(0, deviceUid.find_last_of('-')) == uid
+#endif
+        ) {
+            auto deviceMgr = info->getDeviceManager();
+            auto device    = deviceMgr->createDevice(info);
+            auto impl      = new ob_device();
+            impl->device   = device;
+            return impl;
+        }
+    }
+    throw libobsensor::invalid_value_exception("Device not found by UID: " + std::string(uid));
+}
+HANDLE_EXCEPTIONS_AND_RETURN(nullptr, list, uid)
+
+void ob_delete_device(ob_device *device, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(device);
+    delete device;
+}
+HANDLE_EXCEPTIONS_NO_RETURN(device)
+
+ob_sensor_list *ob_device_get_sensor_list(const ob_device *device, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(device);
+    auto impl         = new ob_sensor_list();
+    impl->device      = device->device;
+    impl->sensorTypes = device->device->getSensorTypeList();
+    return impl;
+}
+HANDLE_EXCEPTIONS_AND_RETURN(nullptr, device)
+
+ob_sensor *ob_device_get_sensor(ob_device *device, ob_sensor_type type, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(device);
+    auto sensorTypelist = device->device->getSensorTypeList();
+    auto iter           = std::find(sensorTypelist.begin(), sensorTypelist.end(), type);
+    if(iter == sensorTypelist.end()) {
+        throw libobsensor::invalid_value_exception("Sensor not found by type: " + std::to_string(type));
+    }
+    auto impl    = new ob_sensor();
+    impl->device = device->device;
+    impl->type   = type;
+    return impl;
+}
+HANDLE_EXCEPTIONS_AND_RETURN(nullptr, device, type)
+
+void ob_device_set_int_property(ob_device *device, ob_property_id property_id, int32_t value, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(device);
+    auto propServer = device->device->getPropertyServer();
+    propServer->setPropertyValueT(property_id, value, libobsensor::PROP_ACCESS_USER);
+}
+HANDLE_EXCEPTIONS_NO_RETURN(device, property_id, value)
+
+int32_t ob_device_get_int_property(ob_device *device, ob_property_id property_id, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(device);
+    auto propServer = device->device->getPropertyServer();
+    return propServer->getPropertyValueT<int32_t>(property_id, libobsensor::PROP_ACCESS_USER);
+}
+HANDLE_EXCEPTIONS_AND_RETURN(0, device, property_id)
+
+ob_int_property_range ob_device_get_int_property_range(ob_device *device, ob_property_id property_id, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(device);
+    auto propServer = device->device->getPropertyServer();
+    auto range      = propServer->getPropertyRangeT<int32_t>(property_id, libobsensor::PROP_ACCESS_USER);
+    return { range.cur, range.max, range.min, range.step, range.def };
+}
+HANDLE_EXCEPTIONS_AND_RETURN(ob_int_property_range(), device, property_id)
+
+void ob_device_set_float_property(ob_device *device, ob_property_id property_id, float value, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(device);
+    auto propServer = device->device->getPropertyServer();
+    propServer->setPropertyValueT(property_id, value, libobsensor::PROP_ACCESS_USER);
+}
+HANDLE_EXCEPTIONS_NO_RETURN(device, property_id, value)
+
+float ob_device_get_float_property(ob_device *device, ob_property_id property_id, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(device);
+    auto propServer = device->device->getPropertyServer();
+    return propServer->getPropertyValueT<float>(property_id, libobsensor::PROP_ACCESS_USER);
+}
+HANDLE_EXCEPTIONS_AND_RETURN(0.0f, device, property_id)
+
+ob_float_property_range ob_device_get_float_property_range(ob_device *device, ob_property_id property_id, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(device);
+    auto propServer = device->device->getPropertyServer();
+    auto range      = propServer->getPropertyRangeT<float>(property_id, libobsensor::PROP_ACCESS_USER);
+    return { range.cur, range.max, range.min, range.step, range.def };
+}
+HANDLE_EXCEPTIONS_AND_RETURN(ob_float_property_range(), device, property_id)
+
+void ob_device_set_bool_property(ob_device *device, ob_property_id property_id, bool value, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(device);
+    auto propServer = device->device->getPropertyServer();
+    propServer->setPropertyValueT(property_id, value, libobsensor::PROP_ACCESS_USER);
+}
+HANDLE_EXCEPTIONS_NO_RETURN(device, property_id, value)
+
+bool ob_device_get_bool_property(ob_device *device, ob_property_id property_id, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(device);
+    auto propServer = device->device->getPropertyServer();
+    return propServer->getPropertyValueT<bool>(property_id, libobsensor::PROP_ACCESS_USER);
+}
+HANDLE_EXCEPTIONS_AND_RETURN(false, device, property_id)
+
+ob_bool_property_range ob_device_get_bool_property_range(ob_device *device, ob_property_id property_id, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(device);
+    auto propServer = device->device->getPropertyServer();
+    auto range      = propServer->getPropertyRangeT<bool>(property_id, libobsensor::PROP_ACCESS_USER);
+    return { range.cur, range.max, range.min, range.step, range.def };
+}
+HANDLE_EXCEPTIONS_AND_RETURN(ob_bool_property_range(), device, property_id)
+
+void ob_device_set_structured_data(ob_device *device, ob_property_id property_id, const uint8_t *data, uint32_t data_size, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(device);
+    auto                 propServer = device->device->getPropertyServer();
+    std::vector<uint8_t> dataVec(data, data + data_size);
+    propServer->setStructureData(property_id, dataVec, libobsensor::PROP_ACCESS_USER);
+}
+HANDLE_EXCEPTIONS_NO_RETURN(device, property_id, data, data_size)
+
+void ob_device_get_structured_data(ob_device *device, ob_property_id property_id, uint8_t *data, uint32_t *data_size, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(device);
+    auto  propServer   = device->device->getPropertyServer();
+    auto &firmwareData = propServer->getStructureData(property_id, libobsensor::PROP_ACCESS_USER);
+
+    memcpy(data, firmwareData.data(), firmwareData.size());
+    *data_size = static_cast<uint32_t>(firmwareData.size());
+}
+HANDLE_EXCEPTIONS_NO_RETURN(device, property_id, data, data_size)
+
+void ob_device_get_raw_data(ob_device *device, ob_property_id property_id, ob_get_data_callback cb, void *user_data, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(device);
+    auto propServer = device->device->getPropertyServer();
+    propServer->getRawData(
+        property_id,
+        [=](OBDataTranState state, OBDataChunk *dataChunk) {
+            if(cb) {
+                cb(state, dataChunk, user_data);
+            }
+        },
+        libobsensor::PROP_ACCESS_USER);
+}
+HANDLE_EXCEPTIONS_NO_RETURN(device, property_id, user_data)
+
+uint32_t ob_device_get_supported_property_count(const ob_device *device, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(device);
+    auto propServer = device->device->getPropertyServer();
+    return static_cast<int>(propServer->getAvailableProperties(libobsensor::PROP_ACCESS_USER).size());
+}
+HANDLE_EXCEPTIONS_AND_RETURN(0, device)
+
+ob_property_item ob_device_get_supported_property_item(const ob_device *device, uint32_t index, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(device);
+    auto propServer = device->device->getPropertyServer();
+    auto properties = propServer->getAvailableProperties(libobsensor::PROP_ACCESS_USER);
+    VALIDATE_UNSIGNED_INDEX(index, properties.size());
+    return properties.at(index);
+}
+HANDLE_EXCEPTIONS_AND_RETURN(ob_property_item(), device, index)
+
+bool ob_device_is_property_supported(const ob_device *device, ob_property_id property_id, ob_permission_type permission, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(device);
+    auto operationType = libobsensor::PROP_OP_READ_WRITE;
+    if(permission == OB_PERMISSION_READ) {
+        operationType = libobsensor::PROP_OP_READ;
+    }
+    else if(permission == OB_PERMISSION_WRITE) {
+        operationType = libobsensor::PROP_OP_WRITE;
+    }
+
+    auto propServer = device->device->getPropertyServer();
+    return propServer->isPropertySupported(property_id, operationType, libobsensor::PROP_ACCESS_USER);
+}
+HANDLE_EXCEPTIONS_AND_RETURN(false, device, property_id, permission)
+
+bool ob_device_is_global_timestamp_supported(const ob_device *device, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(device);
+    return device->device->isComponentExists(libobsensor::OB_DEV_COMPONENT_GLOBAL_TIMESTAMP_FILTER);
+}
+HANDLE_EXCEPTIONS_AND_RETURN(false, device)
+
+void ob_device_enable_global_timestamp(ob_device *device, bool enable, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(device);
+    auto globalTimestampFilter = device->device->getComponentT<libobsensor::GlobalTimestampFitter>(libobsensor::OB_DEV_COMPONENT_GLOBAL_TIMESTAMP_FILTER);
+    globalTimestampFilter->enable(enable);
+}
+HANDLE_EXCEPTIONS_NO_RETURN(device, enable)
+
+void ob_device_update_firmware(ob_device *device, const char *path, ob_device_fw_update_callback callback, bool async, void *user_data,
+                               ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(device);
+    VALIDATE_NOT_NULL(path);
+    VALIDATE_NOT_NULL(callback);
+    auto data = libobsensor::utils::readFile(path);
+
+    device->device->updateFirmware(
+        data,
+        [callback, user_data](ob_fw_update_state status, const char *message, uint8_t percent) {  //
+            callback(status, message, percent, user_data);
+        },
+        async);
+}
+HANDLE_EXCEPTIONS_NO_RETURN(device, path, callback, async, user_data)
+
+void ob_device_update_firmware_from_data(ob_device *device, const uint8_t *data, uint32_t data_size, ob_device_fw_update_callback callback, bool async,
+                                         void *user_data, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(device);
+    VALIDATE_NOT_NULL(data);
+    VALIDATE_NOT_NULL(callback);
+    auto dataVec = std::vector<uint8_t>(data, data + data_size);
+    device->device->updateFirmware(
+        dataVec,
+        [callback, user_data](ob_fw_update_state status, const char *message, uint8_t percent) {  //
+            callback(status, message, percent, user_data);
+        },
+        async);
+}
+HANDLE_EXCEPTIONS_NO_RETURN(device, data, data_size, callback, async, user_data)
+
+void ob_device_reboot(ob_device *device, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(device);
+    device->device->reboot();
+}
+HANDLE_EXCEPTIONS_NO_RETURN(device)
+
+ob_device_state ob_device_get_device_state(const ob_device *device, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(device);
+
+    auto devMonitor = device->device->getComponentT<libobsensor::IDeviceMonitor>(libobsensor::OB_DEV_COMPONENT_DEVICE_MONITOR);
+    return devMonitor->getCurrentDeviceState();
+}
+HANDLE_EXCEPTIONS_AND_RETURN(0, device)
+
+void ob_device_set_state_changed_callback(ob_device *device, ob_device_state_callback callback, void *user_data, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(device);
+    VALIDATE_NOT_NULL(callback);
+    auto devMonitor = device->device->getComponentT<libobsensor::IDeviceMonitor>(libobsensor::OB_DEV_COMPONENT_DEVICE_MONITOR);
+    devMonitor->registerStateChangedCallback([callback, user_data](OBDeviceState state, const std::string &message) {  //
+        callback(state, message.c_str(), user_data);
+    });
+}
+HANDLE_EXCEPTIONS_NO_RETURN(device, callback, user_data)
+
+void ob_device_enable_heartbeat(ob_device *device, bool enable, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(device);
+    auto devMonitor = device->device->getComponentT<libobsensor::IDeviceMonitor>(libobsensor::OB_DEV_COMPONENT_DEVICE_MONITOR);
+
+    if(enable) {
+        devMonitor->enableHeartbeat();
+    }
+    else {
+        devMonitor->disableHeartbeat();
+    }
+}
+HANDLE_EXCEPTIONS_NO_RETURN(device, enable)
+
+void ob_device_send_and_receive_data(ob_device *device, const uint8_t *send_data, uint32_t send_data_size, uint8_t *receive_data, uint32_t *receive_data_size,
+                                     ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(device);
+    VALIDATE_NOT_NULL(send_data);
+    VALIDATE_NOT_NULL(receive_data);
+    VALIDATE_NOT_NULL(receive_data_size);
+
+    auto devMonitor = device->device->getComponentT<libobsensor::IDeviceMonitor>(libobsensor::OB_DEV_COMPONENT_DEVICE_MONITOR);
+    devMonitor->sendAndReceiveData(send_data, send_data_size, receive_data, receive_data_size);
+}
+HANDLE_EXCEPTIONS_NO_RETURN(device, send_data, send_data_size, receive_data, receive_data_size)
+
+ob_device_info *ob_device_get_device_info(const ob_device *device, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(device);
+    auto info  = device->device->getInfo();
+    auto impl  = new ob_device_info();
+    impl->info = info;
+    return impl;
+}
+HANDLE_EXCEPTIONS_AND_RETURN(nullptr, device)
+
+void ob_delete_device_info(ob_device_info *info, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(info);
+    delete info;
+}
+HANDLE_EXCEPTIONS_NO_RETURN(info)
+
+const char *ob_device_info_get_name(const ob_device_info *info, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(info);
+    return info->info->fullName_.c_str();
+}
+HANDLE_EXCEPTIONS_AND_RETURN(nullptr, info)
+
+int ob_device_info_get_pid(const ob_device_info *info, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(info);
+    return info->info->pid_;
+}
+HANDLE_EXCEPTIONS_AND_RETURN(0, info)
+
+int ob_device_info_get_vid(const ob_device_info *info, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(info);
+    return info->info->vid_;
+}
+HANDLE_EXCEPTIONS_AND_RETURN(0, info)
+
+const char *ob_device_info_get_uid(const ob_device_info *info, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(info);
+    return info->info->uid_.c_str();
+}
+HANDLE_EXCEPTIONS_AND_RETURN(nullptr, info)
+
+const char *ob_device_info_get_serial_number(const ob_device_info *info, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(info);
+    return info->info->deviceSn_.c_str();
+}
+HANDLE_EXCEPTIONS_AND_RETURN(nullptr, info)
+
+const char *ob_device_info_get_firmware_version(const ob_device_info *info, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(info);
+    return info->info->fwVersion_.c_str();
+}
+HANDLE_EXCEPTIONS_AND_RETURN(nullptr, info)
+
+const char *ob_device_info_get_hardware_version(const ob_device_info *info, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(info);
+    return info->info->hwVersion_.c_str();
+}
+HANDLE_EXCEPTIONS_AND_RETURN(nullptr, info)
+
+const char *ob_device_info_get_connection_type(const ob_device_info *info, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(info);
+    return info->info->connectionType_.c_str();
+}
+HANDLE_EXCEPTIONS_AND_RETURN(nullptr, info)
+
+const char *ob_device_info_get_ip_address(const ob_device_info *info, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(info);
+    auto netDeviceInfo = std::static_pointer_cast<const libobsensor::NetDeviceInfo>(info->info);
+    if(!netDeviceInfo) {
+        throw libobsensor::invalid_value_exception("Not a network device");
+    }
+    return netDeviceInfo->ipAddress_.c_str();
+}
+HANDLE_EXCEPTIONS_AND_RETURN(nullptr, info)
+
+const char *ob_device_info_get_supported_min_sdk_version(const ob_device_info *info, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(info);
+    return info->info->supportedSdkVersion_.c_str();
+}
+HANDLE_EXCEPTIONS_AND_RETURN(nullptr, info)
+
+const char *ob_device_info_get_asicName(const ob_device_info *info, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(info);
+    return info->info->asicName_.c_str();
+}
+HANDLE_EXCEPTIONS_AND_RETURN(nullptr, info)
+
+ob_device_type ob_device_info_get_device_type(const ob_device_info *info, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(info);
+    return static_cast<ob_device_type>(info->info->type_);
+}
+HANDLE_EXCEPTIONS_AND_RETURN(OB_DEVICE_TYPE_UNKNOWN, info)
+
+bool ob_device_is_extension_info_exist(const ob_device *device, const char *info_key, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(device);
+    VALIDATE_NOT_NULL(info_key);
+    return device->device->isExtensionInfoExists(info_key);
+}
+HANDLE_EXCEPTIONS_AND_RETURN(false, device, info_key)
+
+const char *ob_device_get_extension_info(const ob_device *device, const char *info_key, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(device);
+    VALIDATE_NOT_NULL(info_key);
+    const auto &extensionInfo = device->device->getExtensionInfo(info_key);
+    if(extensionInfo.empty()) {
+        return nullptr;
+    }
+    return extensionInfo.c_str();
+}
+HANDLE_EXCEPTIONS_AND_RETURN("", device, info_key)
+
+ob_camera_param_list *ob_device_get_calibration_camera_param_list(ob_device *device, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(device);
+    auto algParamManager         = device->device->getComponentT<libobsensor::IAlgParamManager>(libobsensor::OB_DEV_COMPONENT_ALG_PARAM_MANAGER, false);
+    auto calibrationCameraParams = algParamManager->getCalibrationCameraParamList();
+    auto impl                    = new ob_camera_param_list();
+    impl->paramList              = calibrationCameraParams;
+    return impl;
+}
+HANDLE_EXCEPTIONS_AND_RETURN(nullptr, device)
+
+uint32_t ob_camera_param_list_get_count(ob_camera_param_list *list, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(list);
+    return static_cast<uint32_t>(list->paramList.size());
+}
+HANDLE_EXCEPTIONS_AND_RETURN(0, list)
+
+ob_camera_param ob_camera_param_list_get_param(ob_camera_param_list *list, uint32_t index, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(list);
+    VALIDATE_UNSIGNED_INDEX(index, list->paramList.size());
+
+    return list->paramList.at(index);
+}
+HANDLE_EXCEPTIONS_AND_RETURN(ob_camera_param(), list, index)
+
+void ob_delete_camera_param_list(ob_camera_param_list *list, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(list);
+    delete list;
+}
+HANDLE_EXCEPTIONS_NO_RETURN(list)
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/src/impl/Error.cpp b/src/impl/Error.cpp
new file mode 100644
index 00000000..6fcddbd7
--- /dev/null
+++ b/src/impl/Error.cpp
@@ -0,0 +1,58 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "libobsensor/h/Error.h"
+#include <string.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+ob_error *ob_create_error(ob_status status, const char *message, const char *function, const char *args, ob_exception_type exception_type) {
+    ob_error *error = new ob_error;
+    error->status   = status;
+
+    auto message_size = strlen(message) + 1;
+    memcpy(error->message, message, message_size > 256 ? 256 : message_size);
+
+    auto function_size = strlen(function) + 1;
+    memcpy(error->function, function, function_size > 256 ? 256 : function_size);
+
+    auto args_size = strlen(args) + 1;
+    memcpy(error->args, args, args_size > 256 ? 256 : args_size);
+
+    error->exception_type = exception_type;
+
+    return error;
+}
+
+ob_status ob_error_get_status(const ob_error *error) {
+    return error ? error->status : OB_STATUS_OK;
+}
+
+const char *ob_error_get_message(const ob_error *error) {
+    return error ? error->message : nullptr;
+}
+
+const char *ob_error_get_function(const ob_error *error) {
+    return error ? error->function : nullptr;
+}
+
+const char *ob_error_get_args(const ob_error *error) {
+    return error ? error->args : nullptr;
+}
+
+ob_exception_type ob_error_get_exception_type(const ob_error *error) {
+    return error ? error->exception_type : OB_EXCEPTION_TYPE_UNKNOWN;
+}
+
+void ob_delete_error(ob_error *error) {
+    if(error) {
+        delete error;
+        error = nullptr;
+    }
+}
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/src/impl/Filter.cpp b/src/impl/Filter.cpp
new file mode 100644
index 00000000..d27a0d02
--- /dev/null
+++ b/src/impl/Filter.cpp
@@ -0,0 +1,188 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "libobsensor/h/Filter.h"
+
+#include "ImplTypes.hpp"
+#include "FilterFactory.hpp"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+ob_filter *ob_create_filter(const char *name, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(name);
+    auto filterFactory = libobsensor::FilterFactory::getInstance();
+    auto filter        = filterFactory->createFilter(name);
+    auto filterImpl    = new ob_filter();
+    filterImpl->filter = filter;
+    return filterImpl;
+}
+HANDLE_EXCEPTIONS_AND_RETURN(nullptr, name)
+
+const char *ob_filter_get_name(const ob_filter *filter, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(filter);
+    return filter->filter->getName().c_str();
+}
+HANDLE_EXCEPTIONS_AND_RETURN(nullptr, filter)
+
+const char *ob_filter_get_vendor_specific_code(const char *name, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(name);
+    auto filterFactory        = libobsensor::FilterFactory::getInstance();
+    auto filterCreator        = filterFactory->getFilterCreator(name);
+    auto privateFilterCreator = std::dynamic_pointer_cast<libobsensor::IPrivFilterCreator>(filterCreator);
+    if(privateFilterCreator == nullptr) {
+        return nullptr;
+    }
+    const auto &code = privateFilterCreator->getVendorSpecificCode();
+    return code.c_str();
+}
+HANDLE_EXCEPTIONS_AND_RETURN(nullptr, name)
+
+ob_filter *ob_create_private_filter(const char *name, const char *activation_key, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(name);
+    VALIDATE_NOT_NULL(activation_key);
+    auto filterFactory = libobsensor::FilterFactory::getInstance();
+    auto filter        = filterFactory->createPrivateFilter(name, activation_key);
+    auto filterImpl    = new ob_filter();
+    filterImpl->filter = filter;
+    return filterImpl;
+}
+HANDLE_EXCEPTIONS_AND_RETURN(nullptr, name, activation_key)
+
+void ob_delete_filter(ob_filter *filter, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(filter);
+    delete filter;
+}
+HANDLE_EXCEPTIONS_NO_RETURN(filter)
+
+const char *ob_filter_get_config_schema(const ob_filter *filter, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(filter);
+    auto &configSchema = filter->filter->getConfigSchema();
+    return configSchema.c_str();
+}
+HANDLE_EXCEPTIONS_AND_RETURN(nullptr, filter)
+
+ob_filter_config_schema_list *ob_filter_get_config_schema_list(const ob_filter *filter, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(filter);
+    auto &configSchemaList = filter->filter->getConfigSchemaVec();
+    auto  impl             = new ob_filter_config_schema_list();
+    impl->configSchemaList = configSchemaList;
+    return impl;
+}
+HANDLE_EXCEPTIONS_AND_RETURN(nullptr, filter)
+
+void ob_delete_filter_config_schema_list(ob_filter_config_schema_list *config_schema_list, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(config_schema_list);
+    delete config_schema_list;
+}
+HANDLE_EXCEPTIONS_NO_RETURN(config_schema_list)
+
+uint32_t ob_filter_config_schema_list_get_count(const ob_filter_config_schema_list *config_schema_list, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(config_schema_list);
+    return static_cast<uint32_t>(config_schema_list->configSchemaList.size());
+}
+HANDLE_EXCEPTIONS_AND_RETURN(0, config_schema_list)
+
+ob_filter_config_schema_item ob_filter_config_schema_list_get_item(const ob_filter_config_schema_list *config_schema_list, uint32_t index,
+                                                                   ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(config_schema_list);
+    VALIDATE_UNSIGNED_INDEX(index, config_schema_list->configSchemaList.size());
+    auto &configSchema = config_schema_list->configSchemaList.at(index);
+    return configSchema;
+}
+HANDLE_EXCEPTIONS_AND_RETURN({}, config_schema_list, index)
+
+void ob_filter_update_config(ob_filter *filter, uint8_t argc, const char **argv, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(filter);
+    std::vector<std::string> args(argv, argv + argc);
+    filter->filter->updateConfig(args);
+}
+HANDLE_EXCEPTIONS_NO_RETURN(filter, argc, argv)
+
+double ob_filter_get_config_value(const ob_filter *filter, const char *config_name, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(filter);
+    VALIDATE_NOT_NULL(config_name);
+    return filter->filter->getConfigValue(config_name);
+}
+HANDLE_EXCEPTIONS_AND_RETURN(0, filter, config_name)
+
+void ob_filter_set_config_value(ob_filter *filter, const char *config_name, double value, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(filter);
+    VALIDATE_NOT_NULL(config_name);
+    filter->filter->setConfigValue(config_name, value);
+}
+HANDLE_EXCEPTIONS_NO_RETURN(filter, config_name, value)
+
+void ob_filter_reset(ob_filter *filter, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(filter);
+    filter->filter->reset();
+}
+HANDLE_EXCEPTIONS_NO_RETURN(filter)
+
+void ob_filter_enable(ob_filter *filter, bool enable, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(filter);
+    filter->filter->enable(enable);
+}
+HANDLE_EXCEPTIONS_NO_RETURN(filter, enable)
+
+bool ob_filter_is_enabled(const ob_filter *filter, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(filter);
+    return filter->filter->isEnabled();
+}
+HANDLE_EXCEPTIONS_AND_RETURN(false, filter)
+
+ob_frame *ob_filter_process(ob_filter *filter, const ob_frame *frame, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(filter);
+    VALIDATE_NOT_NULL(frame);
+    auto result = filter->filter->process(frame->frame);
+    if(result == nullptr) {
+        return nullptr;
+    }
+    auto frameImpl   = new ob_frame();
+    frameImpl->frame = result;
+    return frameImpl;
+}
+HANDLE_EXCEPTIONS_AND_RETURN(nullptr, filter, frame)
+
+void ob_filter_set_callback(ob_filter *filter, ob_filter_callback callback, void *user_data, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(filter);
+    filter->filter->setCallback([callback, user_data](std::shared_ptr<libobsensor::Frame> frame) {
+        auto frameImpl   = new ob_frame();
+        frameImpl->frame = std::move(frame);
+        callback(frameImpl, user_data);
+    });
+}
+HANDLE_EXCEPTIONS_NO_RETURN(filter, callback, user_data)
+
+void ob_filter_push_frame(ob_filter *filter, const ob_frame *frame, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(filter);
+    VALIDATE_NOT_NULL(frame);
+    filter->filter->pushFrame(frame->frame);
+}
+HANDLE_EXCEPTIONS_NO_RETURN(filter, frame)
+
+uint32_t ob_filter_list_get_count(const ob_filter_list *filter_list, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(filter_list);
+    return static_cast<uint32_t>(filter_list->filterList.size());
+}
+HANDLE_EXCEPTIONS_AND_RETURN(0, filter_list)
+
+ob_filter *ob_filter_list_get_filter(const ob_filter_list *filter_list, uint32_t index, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(filter_list);
+    auto filter        = filter_list->filterList.at(index);
+    auto filterImpl    = new ob_filter();
+    filterImpl->filter = filter;
+    return filterImpl;
+}
+HANDLE_EXCEPTIONS_AND_RETURN(nullptr, filter_list, index)
+
+void ob_delete_filter_list(ob_filter_list *filter_list, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(filter_list);
+    delete filter_list;
+}
+HANDLE_EXCEPTIONS_NO_RETURN(filter_list)
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/src/impl/Frame.cpp b/src/impl/Frame.cpp
new file mode 100644
index 00000000..e65da8b4
--- /dev/null
+++ b/src/impl/Frame.cpp
@@ -0,0 +1,531 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "libobsensor/h/Frame.h"
+
+#include "ImplTypes.hpp"
+#include "exception/ObException.hpp"
+#include "frame/FrameFactory.hpp"
+
+#include "IFrame.hpp"
+#include "ISensor.hpp"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+ob_frame *ob_create_frame(ob_frame_type frame_type, ob_format format, uint32_t data_size, ob_error **error) BEGIN_API_CALL {
+    auto innerFrame  = libobsensor::FrameFactory::createFrame(frame_type, format, data_size);
+    auto frameImpl   = new ob_frame();
+    frameImpl->frame = innerFrame;
+    return frameImpl;
+}
+HANDLE_EXCEPTIONS_AND_RETURN(nullptr, frame_type, format, data_size)
+
+ob_frame *ob_create_frame_from_other_frame(const ob_frame *other_frame, bool should_copy_data, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(other_frame);
+    auto innerFrame  = libobsensor::FrameFactory::createFrameFromOtherFrame(other_frame->frame, should_copy_data);
+    auto frameImpl   = new ob_frame();
+    frameImpl->frame = innerFrame;
+    return frameImpl;
+}
+HANDLE_EXCEPTIONS_AND_RETURN(nullptr, other_frame, should_copy_data)
+
+ob_frame *ob_create_frame_from_stream_profile(const ob_stream_profile *stream_profile, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(stream_profile);
+    auto innerFrame  = libobsensor::FrameFactory::createFrameFromStreamProfile(stream_profile->profile);
+    auto frameImpl   = new ob_frame();
+    frameImpl->frame = innerFrame;
+    return frameImpl;
+}
+HANDLE_EXCEPTIONS_AND_RETURN(nullptr, stream_profile)
+
+ob_frame *ob_create_video_frame(ob_frame_type frame_type, ob_format format, uint32_t width, uint32_t height, uint32_t stride_bytes,
+                                ob_error **error) BEGIN_API_CALL {
+
+    auto innerFrame = libobsensor::FrameFactory::createVideoFrame(frame_type, format, width, height, stride_bytes);
+    if(innerFrame == nullptr) {
+        LOG_ERROR("User custom frame create failed!");
+        return nullptr;
+    }
+
+    auto frameImpl   = new ob_frame();
+    frameImpl->frame = innerFrame;
+
+    return frameImpl;
+}
+HANDLE_EXCEPTIONS_AND_RETURN(nullptr, frame_type, format, width, height, stride_bytes)
+
+ob_frame *ob_create_frame_from_buffer(ob_frame_type frame_type, ob_format format, uint8_t *buffer, uint32_t buffer_size,
+                                      ob_frame_destroy_callback *buffer_destroy_cb, void *buffer_destroy_context, ob_error **error) BEGIN_API_CALL {
+    auto innerFrame = libobsensor::FrameFactory::createFrameFromUserBuffer(
+        frame_type, format, buffer, buffer_size, [buffer_destroy_cb, buffer, buffer_destroy_context]() { buffer_destroy_cb(buffer, buffer_destroy_context); });
+
+    auto frameImpl   = new ob_frame();
+    frameImpl->frame = innerFrame;
+
+    return frameImpl;
+}
+HANDLE_EXCEPTIONS_AND_RETURN(nullptr, frame_type, format, buffer, buffer_size, buffer_destroy_cb, buffer_destroy_context)
+
+ob_frame *ob_create_video_frame_from_buffer(ob_frame_type frame_type, ob_format format, uint32_t width, uint32_t height, uint32_t stride_bytes, uint8_t *buffer,
+                                            uint32_t buffer_size, ob_frame_destroy_callback *buffer_destroy_cb, void *buffer_destroy_context,
+                                            ob_error **error) BEGIN_API_CALL {
+    auto innerFrame = libobsensor::FrameFactory::createVideoFrameFromUserBuffer(
+        frame_type, format, width, height, stride_bytes, buffer, buffer_size,
+        [buffer_destroy_cb, buffer, buffer_destroy_context]() { buffer_destroy_cb(buffer, buffer_destroy_context); });
+
+    auto frameImpl   = new ob_frame();
+    frameImpl->frame = innerFrame;
+
+    return frameImpl;
+}
+HANDLE_EXCEPTIONS_AND_RETURN(nullptr, frame_type, format, width, height, stride_bytes, buffer, buffer_size, buffer_destroy_cb, buffer_destroy_context)
+
+ob_frame *ob_create_frameset(ob_error **error) BEGIN_API_CALL {
+    auto innerFrameSet = libobsensor::FrameFactory::createFrameSet();
+    if(innerFrameSet == nullptr) {
+        return nullptr;
+    }
+
+    auto frameImpl   = new ob_frame();
+    frameImpl->frame = innerFrameSet;
+
+    return frameImpl;
+}
+NO_ARGS_HANDLE_EXCEPTIONS_AND_RETURN(nullptr)
+
+void ob_frame_add_ref(const ob_frame *frame, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(frame);
+    auto unConstFrame = const_cast<ob_frame *>(frame);
+    unConstFrame->refCnt += 1;
+}
+HANDLE_EXCEPTIONS_NO_RETURN(frame)
+
+void ob_delete_frame(const ob_frame *frame, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(frame);
+    auto unConstFrame = const_cast<ob_frame *>(frame);
+    if(unConstFrame->refCnt > 1) {
+        unConstFrame->refCnt -= 1;
+        return;
+    }
+    delete frame;
+}
+HANDLE_EXCEPTIONS_NO_RETURN(frame)
+
+void ob_frame_copy_info(const ob_frame *src_frame, ob_frame *dst_frame, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(src_frame);
+    VALIDATE_NOT_NULL(dst_frame);
+    dst_frame->frame->copyInfoFromOther(src_frame->frame);
+}
+HANDLE_EXCEPTIONS_NO_RETURN(src_frame, dst_frame)
+
+uint64_t ob_frame_get_index(const ob_frame *frame, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(frame);
+    return frame->frame->getNumber();
+}
+HANDLE_EXCEPTIONS_AND_RETURN(uint64_t(0), frame)
+
+uint32_t ob_video_frame_get_width(const ob_frame *frame, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(frame);
+    if(!frame->frame->is<libobsensor::VideoFrame>()) {
+        throw libobsensor::unsupported_operation_exception("It's not a video frame!");
+    }
+    return frame->frame->as<libobsensor::VideoFrame>()->getWidth();
+}
+HANDLE_EXCEPTIONS_AND_RETURN(uint32_t(0), frame)
+
+uint32_t ob_video_frame_get_height(const ob_frame *frame, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(frame);
+    if(!frame->frame->is<libobsensor::VideoFrame>()) {
+        throw libobsensor::unsupported_operation_exception("It's not a video frame!");
+    }
+    return frame->frame->as<libobsensor::VideoFrame>()->getHeight();
+}
+HANDLE_EXCEPTIONS_AND_RETURN(uint32_t(0), frame)
+
+ob_format ob_frame_get_format(const ob_frame *frame, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(frame);
+    return frame->frame->getFormat();
+}
+HANDLE_EXCEPTIONS_AND_RETURN(OB_FORMAT_UNKNOWN, frame)
+
+ob_frame_type ob_frame_get_type(const ob_frame *frame, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(frame);
+    return frame->frame->getType();
+}
+HANDLE_EXCEPTIONS_AND_RETURN(OB_FRAME_VIDEO, frame)
+
+uint64_t ob_frame_get_timestamp_us(const ob_frame *frame, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(frame);
+    return frame->frame->getTimeStampUsec();
+}
+HANDLE_EXCEPTIONS_AND_RETURN(uint64_t(0), frame)
+
+uint64_t ob_frame_get_system_timestamp_us(const ob_frame *frame, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(frame);
+    return frame->frame->getSystemTimeStampUsec();
+}
+HANDLE_EXCEPTIONS_AND_RETURN(uint64_t(0), frame)
+
+void ob_frame_set_timestamp_from_system_time(ob_frame *frame, uint64_t system_timestamp_us, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(frame);
+    auto innerFrame = frame->frame;
+    innerFrame->setSystemTimeStampUsec(system_timestamp_us);
+}
+HANDLE_EXCEPTIONS_NO_RETURN(frame)
+
+uint64_t ob_frame_get_global_timestamp_us(const ob_frame *frame, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(frame);
+    return frame->frame->getGlobalTimeStampUsec();
+}
+HANDLE_EXCEPTIONS_AND_RETURN(uint64_t(0), frame)
+
+void ob_frame_set_system_timestamp_us(ob_frame *frame, uint64_t timestamp_us, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(frame);
+    auto innerFrame = frame->frame;
+    innerFrame->setSystemTimeStampUsec(timestamp_us);
+}
+HANDLE_EXCEPTIONS_NO_RETURN(frame)
+
+void ob_frame_set_timestamp_us(ob_frame *frame, uint64_t timestamp_us, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(frame);
+    auto innerFrame = frame->frame;
+    innerFrame->setTimeStampUsec(timestamp_us);
+}
+HANDLE_EXCEPTIONS_NO_RETURN(frame)
+
+float ob_depth_frame_get_value_scale(const ob_frame *frame, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(frame);
+    auto depthFrame = frame->frame->as<libobsensor::DepthFrame>();
+    return depthFrame->getValueScale();
+}
+HANDLE_EXCEPTIONS_AND_RETURN(-1.0f, frame)
+
+void ob_depth_frame_set_value_scale(ob_frame *frame, float value_scale, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(frame);
+    auto depthFrame = frame->frame->as<libobsensor::DepthFrame>();
+    depthFrame->setValueScale(value_scale);
+}
+HANDLE_EXCEPTIONS_NO_RETURN(frame)
+
+float ob_points_frame_get_coordinate_value_scale(const ob_frame *frame, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(frame);
+    auto pointsFrame = frame->frame->as<libobsensor::PointsFrame>();
+    return pointsFrame->getCoordinateValueScale();
+}
+HANDLE_EXCEPTIONS_AND_RETURN(-1.0f, frame)
+
+uint8_t *ob_frame_get_data(const ob_frame *frame, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(frame);
+    return const_cast<uint8_t *>(frame->frame->getData());
+}
+HANDLE_EXCEPTIONS_AND_RETURN(nullptr, frame)
+
+void ob_frame_update_data(ob_frame *frame, const uint8_t *data, uint32_t data_size, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(frame);
+    VALIDATE_NOT_NULL(data);
+    auto innerFrame = frame->frame;
+    innerFrame->updateData(data, data_size);
+}
+HANDLE_EXCEPTIONS_NO_RETURN(frame, data, data_size)
+
+uint32_t ob_frame_get_data_size(const ob_frame *frame, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(frame);
+    return (uint32_t)frame->frame->getDataSize();
+}
+HANDLE_EXCEPTIONS_AND_RETURN(uint32_t(0), frame)
+
+uint8_t *ob_frame_get_metadata(const ob_frame *frame, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(frame);
+    return const_cast<uint8_t *>(frame->frame->getMetadata());
+}
+HANDLE_EXCEPTIONS_AND_RETURN(nullptr, frame)
+
+uint32_t ob_frame_get_metadata_size(const ob_frame *frame, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(frame);
+    return (uint32_t)frame->frame->getMetadataSize();
+}
+HANDLE_EXCEPTIONS_AND_RETURN(uint32_t(0), frame)
+
+void ob_frame_update_metadata(ob_frame *frame, const uint8_t *metadata, uint32_t metadata_size, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(frame);
+    VALIDATE_NOT_NULL(metadata);
+    auto innerFrame = frame->frame;
+    innerFrame->updateMetadata(metadata, metadata_size);
+}
+HANDLE_EXCEPTIONS_NO_RETURN(frame, metadata_size)
+
+bool ob_frame_has_metadata(const ob_frame *frame, ob_frame_metadata_type type, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(frame);
+    return frame->frame->hasMetadata(type);
+}
+HANDLE_EXCEPTIONS_AND_RETURN(false, frame)
+
+int64_t ob_frame_get_metadata_value(const ob_frame *frame, ob_frame_metadata_type type, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(frame);
+    return frame->frame->as<libobsensor::VideoFrame>()->getMetadataValue(type);
+}
+HANDLE_EXCEPTIONS_AND_RETURN(-1, frame)
+
+ob_stream_profile *ob_frame_get_stream_profile(const ob_frame *frame, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(frame);
+    auto innerProfile = frame->frame->getStreamProfile();
+    if(!innerProfile) {
+        return nullptr;
+    }
+    auto impl     = new ob_stream_profile();
+    impl->profile = innerProfile;
+    return impl;
+}
+HANDLE_EXCEPTIONS_AND_RETURN(nullptr, frame)
+
+void ob_frame_set_stream_profile(ob_frame *frame, const ob_stream_profile *stream_profile, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(frame);
+    VALIDATE_NOT_NULL(stream_profile);
+    auto innerFrame   = frame->frame;
+    auto innerProfile = stream_profile->profile;
+    innerFrame->setStreamProfile(innerProfile);
+}
+HANDLE_EXCEPTIONS_NO_RETURN(frame, stream_profile)
+
+ob_sensor *ob_frame_get_sensor(const ob_frame *frame, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(frame);
+    auto innerProfile = frame->frame->getStreamProfile();
+    if(!innerProfile) {
+        throw libobsensor::invalid_value_exception("Frame has no owner stream profile!");
+    }
+
+    auto lazySensor = innerProfile->getOwner();
+    if(!lazySensor) {
+        throw libobsensor::invalid_value_exception("Frame has no owner sensor!");
+    }
+
+    std::shared_ptr<libobsensor::IDevice> device;
+    try {
+        device = lazySensor->device->shared_from_this();
+    }
+    catch(...) {
+        throw libobsensor::wrong_api_call_sequence_exception("The device of the frame has been released!");
+    }
+
+    auto sensorImpl    = new ob_sensor();
+    sensorImpl->device = device;
+    sensorImpl->type   = lazySensor->sensorType;
+    return sensorImpl;
+}
+HANDLE_EXCEPTIONS_AND_RETURN(nullptr, frame)
+
+ob_device *ob_frame_get_device(const ob_frame *frame, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(frame);
+    auto innerProfile = frame->frame->getStreamProfile();
+    if(!innerProfile) {
+        throw libobsensor::invalid_value_exception("Frame has no owner stream profile!");
+    }
+
+    auto lazySensor = innerProfile->getOwner();
+    if(!lazySensor) {
+        throw libobsensor::invalid_value_exception("Frame has no owner sensor!");
+    }
+
+    std::shared_ptr<libobsensor::IDevice> device;
+    try {
+        device = lazySensor->device->shared_from_this();
+    }
+    catch(...) {
+        throw libobsensor::wrong_api_call_sequence_exception("The device of the frame has been released!");
+    }
+
+    auto deviceImpl    = new ob_device();
+    deviceImpl->device = device;
+    return deviceImpl;
+}
+HANDLE_EXCEPTIONS_AND_RETURN(nullptr, frame)
+
+ob_pixel_type ob_video_frame_get_pixel_type(const ob_frame *frame, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(frame);
+    return frame->frame->as<libobsensor::VideoFrame>()->getPixelType();
+}
+HANDLE_EXCEPTIONS_AND_RETURN(OB_PIXEL_UNKNOWN, frame)
+
+void ob_video_frame_set_pixel_type(ob_frame *frame, ob_pixel_type pixel_type, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(frame);
+    frame->frame->as<libobsensor::VideoFrame>()->setPixelType(pixel_type);
+}
+HANDLE_EXCEPTIONS_NO_RETURN(frame)
+
+uint8_t ob_video_frame_get_pixel_available_bit_size(const ob_frame *frame, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(frame);
+    return frame->frame->as<libobsensor::VideoFrame>()->getPixelAvailableBitSize();
+}
+HANDLE_EXCEPTIONS_AND_RETURN(uint8_t(0), frame)
+
+void ob_video_frame_set_pixel_available_bit_size(ob_frame *frame, uint8_t bit_size, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(frame);
+    frame->frame->as<libobsensor::VideoFrame>()->setPixelAvailableBitSize(bit_size);
+}
+HANDLE_EXCEPTIONS_NO_RETURN(frame)
+
+ob_sensor_type ob_ir_frame_get_data_source(const ob_frame *frame, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(frame);
+    auto type = frame->frame->as<libobsensor::VideoFrame>()->getType();
+    if(type == OB_FRAME_IR) {
+        return OB_SENSOR_IR;
+    }
+    if(type == OB_FRAME_IR_LEFT) {
+        return OB_SENSOR_IR_LEFT;
+    }
+    if(type == OB_FRAME_IR_RIGHT) {
+        return OB_SENSOR_IR_RIGHT;
+    }
+    throw libobsensor::invalid_value_exception("invalid ir frame type type: " + std::to_string(type));
+}
+HANDLE_EXCEPTIONS_AND_RETURN(OB_SENSOR_UNKNOWN, frame)
+
+ob_accel_value ob_accel_frame_get_value(const ob_frame *frame, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(frame);
+    if(!frame->frame->is<libobsensor::AccelFrame>()) {
+        throw libobsensor::unsupported_operation_exception("It's not a accel frame!");
+    }
+    return frame->frame->as<libobsensor::AccelFrame>()->value();
+}
+HANDLE_EXCEPTIONS_AND_RETURN(ob_accel_value(), frame)
+
+float ob_accel_frame_get_temperature(const ob_frame *frame, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(frame);
+    if(!frame->frame->is<libobsensor::AccelFrame>()) {
+        throw libobsensor::unsupported_operation_exception("It's not a accel frame!");
+    }
+    return frame->frame->as<libobsensor::AccelFrame>()->temperature();
+}
+HANDLE_EXCEPTIONS_AND_RETURN(0.0f, frame)
+
+ob_gyro_value ob_gyro_frame_get_value(const ob_frame *frame, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(frame);
+    if(!frame->frame->is<libobsensor::GyroFrame>()) {
+        throw libobsensor::unsupported_operation_exception("It's not a gyro frame!");
+    }
+    return frame->frame->as<libobsensor::GyroFrame>()->value();
+}
+HANDLE_EXCEPTIONS_AND_RETURN(ob_gyro_value(), frame)
+
+float ob_gyro_frame_get_temperature(const ob_frame *frame, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(frame);
+    if(!frame->frame->is<libobsensor::GyroFrame>()) {
+        throw libobsensor::unsupported_operation_exception("It's not a gyro frame!");
+    }
+    return frame->frame->as<libobsensor::GyroFrame>()->temperature();
+}
+HANDLE_EXCEPTIONS_AND_RETURN(0.0f, frame)
+
+uint32_t ob_frameset_get_count(const ob_frame *frameset, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(frameset);
+    if(!frameset->frame->is<libobsensor::FrameSet>()) {
+        throw libobsensor::unsupported_operation_exception("It's not a frameset!");
+    }
+    return frameset->frame->as<libobsensor::FrameSet>()->getCount();
+}
+HANDLE_EXCEPTIONS_AND_RETURN(uint32_t(0), frameset)
+
+ob_frame *ob_frameset_get_depth_frame(const ob_frame *frameset, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(frameset);
+    if(!frameset->frame->is<libobsensor::FrameSet>()) {
+        throw libobsensor::unsupported_operation_exception("It's not a frameset!");
+    }
+    auto innerFrame = frameset->frame->as<libobsensor::FrameSet>()->getFrame(OB_FRAME_DEPTH);
+    if(innerFrame == nullptr) {
+        return nullptr;
+    }
+    auto impl   = new ob_frame();
+    impl->frame = std::const_pointer_cast<libobsensor::Frame>(innerFrame);  // todo: it's not safe to cast const to non-const, fix it;
+    return impl;
+}
+HANDLE_EXCEPTIONS_AND_RETURN(nullptr, frameset)
+
+ob_frame *ob_frameset_get_color_frame(const ob_frame *frameset, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(frameset);
+    if(!frameset->frame->is<libobsensor::FrameSet>()) {
+        throw libobsensor::unsupported_operation_exception("It's not a frameset!");
+    }
+    auto innerFrame = frameset->frame->as<libobsensor::FrameSet>()->getFrame(OB_FRAME_COLOR);
+    if(innerFrame == nullptr) {
+        return nullptr;
+    }
+    auto impl   = new ob_frame();
+    impl->frame = std::const_pointer_cast<libobsensor::Frame>(innerFrame);  // todo: it's not safe to cast const to non-const, fix it;
+    return impl;
+}
+HANDLE_EXCEPTIONS_AND_RETURN(nullptr, frameset)
+
+ob_frame *ob_frameset_get_ir_frame(const ob_frame *frameset, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(frameset);
+    if(!frameset->frame->is<libobsensor::FrameSet>()) {
+        throw libobsensor::unsupported_operation_exception("It's not a frameset!");
+    }
+    auto innerFrame = frameset->frame->as<libobsensor::FrameSet>()->getFrame(OB_FRAME_IR);
+    if(innerFrame == nullptr) {
+        return nullptr;
+    }
+    auto impl   = new ob_frame();
+    impl->frame = std::const_pointer_cast<libobsensor::Frame>(innerFrame);  // todo: it's not safe to cast const to non-const, fix it;
+    return impl;
+}
+HANDLE_EXCEPTIONS_AND_RETURN(nullptr, frameset)
+
+ob_frame *ob_frameset_get_points_frame(const ob_frame *frameset, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(frameset);
+    if(!frameset->frame->is<libobsensor::FrameSet>()) {
+        throw libobsensor::unsupported_operation_exception("It's not a frameset!");
+    }
+    auto innerFrame = frameset->frame->as<libobsensor::FrameSet>()->getFrame(OB_FRAME_POINTS);
+    if(innerFrame == nullptr) {
+        return nullptr;
+    }
+    auto impl   = new ob_frame();
+    impl->frame = std::const_pointer_cast<libobsensor::Frame>(innerFrame);  // todo: it's not safe to cast const to non-const, fix it;
+    return impl;
+}
+HANDLE_EXCEPTIONS_AND_RETURN(nullptr, frameset)
+
+ob_frame *ob_frameset_get_frame(const ob_frame *frameset, ob_frame_type frame_type, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(frameset);
+    if(!frameset->frame->is<libobsensor::FrameSet>()) {
+        throw libobsensor::unsupported_operation_exception("It's not a frameset!");
+    }
+    auto innerFrame = frameset->frame->as<libobsensor::FrameSet>()->getFrame(frame_type);
+    if(innerFrame == nullptr) {
+        return nullptr;
+    }
+    auto impl   = new ob_frame();
+    impl->frame = std::const_pointer_cast<libobsensor::Frame>(innerFrame);  // todo: it's not safe to cast const to non-const, fix it
+    return impl;
+}
+HANDLE_EXCEPTIONS_AND_RETURN(nullptr, frameset)
+
+ob_frame *ob_frameset_get_frame_by_index(const ob_frame *frameset, uint32_t index, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(frameset);
+    if(!frameset->frame->is<libobsensor::FrameSet>()) {
+        throw libobsensor::unsupported_operation_exception("It's not a frameset!");
+    }
+    auto innerFrame = frameset->frame->as<libobsensor::FrameSet>()->getFrame(index);
+    if(innerFrame == nullptr) {
+        return nullptr;
+    }
+    auto impl   = new ob_frame();
+    impl->frame = std::const_pointer_cast<libobsensor::Frame>(innerFrame);  // todo: it's not safe to cast const to non-const, fix it
+    return impl;
+}
+HANDLE_EXCEPTIONS_AND_RETURN(nullptr, frameset)
+
+void ob_frameset_push_frame(ob_frame *frameset, const ob_frame *frame, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(frameset);
+    VALIDATE_NOT_NULL(frame);
+    auto innerFrameSet = frameset->frame->as<libobsensor::FrameSet>();
+    auto innerFrame    = frame->frame;
+    innerFrameSet->pushFrame(std::move(innerFrame));
+}
+HANDLE_EXCEPTIONS_NO_RETURN(frameset, frame)
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/src/impl/ImplTypes.cpp b/src/impl/ImplTypes.cpp
new file mode 100644
index 00000000..eda780bf
--- /dev/null
+++ b/src/impl/ImplTypes.cpp
@@ -0,0 +1,44 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "ImplTypes.hpp"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+ob_error *ob_create_error_internal(ob_status status, const char *what, const char *name, const char *args, ob_exception_type type) {
+    ob_error *e = new ob_error();
+    e->status   = status;
+    strcpy(e->message, what);
+    strcpy(e->function, name);
+    strcpy(e->args, args);
+    e->exception_type = type;
+    return e;
+}
+
+void translate_exception(const char *name, std::string args, ob_error **result) {
+    try {
+        throw;
+    }
+    catch(const libobsensor::libobsensor_exception &e) {
+        if(result) {
+            *result = ob_create_error_internal(OB_STATUS_ERROR, e.what(), name, args.c_str(), e.get_exception_type());
+        }
+    }
+    catch(const std::exception &e) {
+        if(result) {
+            *result = ob_create_error_internal(OB_STATUS_ERROR, e.what(), name, args.c_str(), OB_EXCEPTION_STD_EXCEPTION);
+        }
+    }
+    catch(...) {
+        if(result) {
+            *result = ob_create_error_internal(OB_STATUS_ERROR, "unknown error", name, args.c_str(), OB_EXCEPTION_TYPE_UNKNOWN);
+        }
+    }
+}
+
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/src/impl/ImplTypes.hpp b/src/impl/ImplTypes.hpp
new file mode 100644
index 00000000..d2e86762
--- /dev/null
+++ b/src/impl/ImplTypes.hpp
@@ -0,0 +1,57 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include "libobsensor/h/ObTypes.h"
+
+#include "frame/Frame.hpp"
+#include "stream/StreamProfile.hpp"
+#include "ISensor.hpp"
+#include "IDevice.hpp"
+
+#include "utils/Utils.hpp"
+
+namespace libobsensor {
+class Context;
+}
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void translate_exception(const char *name, std::string args, ob_error **result);
+
+#ifdef __cplusplus
+}
+#endif
+
+#define BEGIN_API_CALL try
+#define NOEXCEPT_RETURN(...)                                                     \
+    catch(...) {                                                                 \
+        std::ostringstream ss;                                                   \
+        libobsensor::utils::string::ArgsToStream(ss, #__VA_ARGS__, __VA_ARGS__); \
+        return translate_exception(__FUNCTION__, ss.str());                      \
+    }
+#define HANDLE_EXCEPTIONS_NO_RETURN(...)                                         \
+    catch(...) {                                                                 \
+        std::ostringstream ss;                                                   \
+        libobsensor::utils::string::ArgsToStream(ss, #__VA_ARGS__, __VA_ARGS__); \
+        translate_exception(__FUNCTION__, ss.str(), error);                      \
+    }
+#define NO_ARGS_HANDLE_EXCEPTIONS_NO_RETURN(...)      \
+    catch(...) {                                      \
+        translate_exception(__FUNCTION__, "", error); \
+    }
+#define HANDLE_EXCEPTIONS_AND_RETURN(R, ...)                                     \
+    catch(...) {                                                                 \
+        std::ostringstream ss;                                                   \
+        libobsensor::utils::string::ArgsToStream(ss, #__VA_ARGS__, __VA_ARGS__); \
+        translate_exception(__FUNCTION__, ss.str(), error);                      \
+        return R;                                                                \
+    }
+#define NO_ARGS_HANDLE_EXCEPTIONS_AND_RETURN(R)       \
+    catch(...) {                                      \
+        translate_exception(__FUNCTION__, "", error); \
+        return R;                                     \
+    }
+
diff --git a/src/impl/MultipleDevices.cpp b/src/impl/MultipleDevices.cpp
new file mode 100644
index 00000000..00066a50
--- /dev/null
+++ b/src/impl/MultipleDevices.cpp
@@ -0,0 +1,83 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "libobsensor/h/MultipleDevices.h"
+
+#include "ImplTypes.hpp"
+#include "IDevice.hpp"
+#include "IDeviceSyncConfigurator.hpp"
+#include "IDeviceClockSynchronizer.hpp"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+uint16_t ob_device_get_supported_multi_device_sync_mode_bitmap(const ob_device *device, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(device);
+
+    auto configurator = device->device->getComponentT<libobsensor::IDeviceSyncConfigurator>(libobsensor::OB_DEV_COMPONENT_DEVICE_SYNC_CONFIGURATOR);
+    return configurator->getSupportedSyncModeBitmap();
+}
+HANDLE_EXCEPTIONS_AND_RETURN(0, device)
+
+void ob_device_set_multi_device_sync_config(ob_device *device, const ob_multi_device_sync_config *config, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(device);
+    VALIDATE_NOT_NULL(config);
+
+    auto configurator = device->device->getComponentT<libobsensor::IDeviceSyncConfigurator>(libobsensor::OB_DEV_COMPONENT_DEVICE_SYNC_CONFIGURATOR);
+    configurator->setSyncConfig(*config);
+}
+HANDLE_EXCEPTIONS_AND_RETURN(, device)
+
+ob_multi_device_sync_config ob_device_get_multi_device_sync_config(const ob_device *device, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(device);
+
+    auto configurator = device->device->getComponentT<libobsensor::IDeviceSyncConfigurator>(libobsensor::OB_DEV_COMPONENT_DEVICE_SYNC_CONFIGURATOR);
+    return configurator->getSyncConfig();
+}
+HANDLE_EXCEPTIONS_AND_RETURN({}, device)
+
+void ob_device_trigger_capture(ob_device *device, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(device);
+
+    auto configurator = device->device->getComponentT<libobsensor::IDeviceSyncConfigurator>(libobsensor::OB_DEV_COMPONENT_DEVICE_SYNC_CONFIGURATOR);
+    configurator->triggerCapture();
+}
+HANDLE_EXCEPTIONS_AND_RETURN(, device)
+
+void ob_device_set_timestamp_reset_config(ob_device *device, const ob_device_timestamp_reset_config *config, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(device);
+    VALIDATE_NOT_NULL(config);
+
+    auto configurator = device->device->getComponentT<libobsensor::IDeviceClockSynchronizer>(libobsensor::OB_DEV_COMPONENT_DEVICE_CLOCK_SYNCHRONIZER);
+    configurator->setTimestampResetConfig(*config);
+}
+HANDLE_EXCEPTIONS_AND_RETURN(, device)
+
+ob_device_timestamp_reset_config ob_device_get_timestamp_reset_config(ob_device *device, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(device);
+
+    auto configurator = device->device->getComponentT<libobsensor::IDeviceClockSynchronizer>(libobsensor::OB_DEV_COMPONENT_DEVICE_CLOCK_SYNCHRONIZER);
+    return configurator->getTimestampResetConfig();
+}
+HANDLE_EXCEPTIONS_AND_RETURN({}, device)
+
+void ob_device_timestamp_reset(ob_device *device, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(device);
+
+    auto configurator = device->device->getComponentT<libobsensor::IDeviceClockSynchronizer>(libobsensor::OB_DEV_COMPONENT_DEVICE_CLOCK_SYNCHRONIZER);
+    configurator->timestampReset();
+}
+HANDLE_EXCEPTIONS_AND_RETURN(, device)
+
+void ob_device_timer_sync_with_host(ob_device *device, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(device);
+
+    auto configurator = device->device->getComponentT<libobsensor::IDeviceClockSynchronizer>(libobsensor::OB_DEV_COMPONENT_DEVICE_CLOCK_SYNCHRONIZER);
+    configurator->timerSyncWithHost();
+}
+HANDLE_EXCEPTIONS_AND_RETURN(, device)
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/src/impl/Pipeline.cpp b/src/impl/Pipeline.cpp
new file mode 100644
index 00000000..07ddc519
--- /dev/null
+++ b/src/impl/Pipeline.cpp
@@ -0,0 +1,269 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "libobsensor/h/Pipeline.h"
+
+#include "ImplTypes.hpp"
+#include "exception/ObException.hpp"
+#include "utils/Utils.hpp"
+#include "pipeline/Pipeline.hpp"
+#include "pipeline/Config.hpp"
+#include "context/Context.hpp"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+ob_pipeline *ob_create_pipeline(ob_error **error) BEGIN_API_CALL {
+    auto ctx        = libobsensor::Context::getInstance();
+    auto devMgr     = ctx->getDeviceManager();
+    auto deviceList = devMgr->getDeviceInfoList();
+    if(deviceList.empty()) {
+        throw libobsensor::camera_disconnected_exception("No device found");
+    }
+    const auto &devInfo  = deviceList.front();
+    auto        dev      = devMgr->createDevice(devInfo);
+    auto        pipeline = std::make_shared<libobsensor::Pipeline>(dev);
+
+    auto impl      = new ob_pipeline();
+    impl->pipeline = pipeline;
+    return impl;
+}
+NO_ARGS_HANDLE_EXCEPTIONS_AND_RETURN(nullptr)
+
+ob_pipeline *ob_create_pipeline_with_device(const ob_device *dev, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(dev);
+    auto pipeline = std::make_shared<libobsensor::Pipeline>(dev->device);
+
+    auto impl      = new ob_pipeline();
+    impl->pipeline = pipeline;
+    return impl;
+}
+HANDLE_EXCEPTIONS_AND_RETURN(nullptr, dev)
+
+void ob_delete_pipeline(ob_pipeline *pipeline, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(pipeline);
+    delete pipeline;
+}
+HANDLE_EXCEPTIONS_NO_RETURN(pipeline)
+
+void ob_pipeline_start(ob_pipeline *pipeline, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(pipeline);
+    pipeline->pipeline->start();
+}
+HANDLE_EXCEPTIONS_NO_RETURN(pipeline)
+
+void ob_pipeline_start_with_config(ob_pipeline *pipeline, const ob_config *config, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(pipeline);
+    if(!config) {
+        ob_pipeline_start(pipeline, error);
+    }
+    else {
+        VALIDATE_NOT_NULL(config);
+        pipeline->pipeline->start(config->config);
+    }
+}
+HANDLE_EXCEPTIONS_NO_RETURN(pipeline)
+
+void ob_pipeline_start_with_callback(ob_pipeline *pipeline, const ob_config *config, ob_frameset_callback callback, void *user_data,
+                                     ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(pipeline);
+    if(!config) {
+        ob_pipeline_start(pipeline, error);
+    }
+    else {
+        VALIDATE_NOT_NULL(config);
+        pipeline->pipeline->start(config->config, [callback, user_data](std::shared_ptr<const libobsensor::Frame> frame) {
+            auto impl   = new ob_frame();
+            impl->frame = std::const_pointer_cast<libobsensor::Frame>(frame);  // todo: it's not safe to cast const to non-const, fix it
+            callback(impl, user_data);
+        });
+    }
+}
+HANDLE_EXCEPTIONS_NO_RETURN(pipeline)
+
+void ob_pipeline_stop(ob_pipeline *pipeline, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(pipeline);
+    pipeline->pipeline->stop();
+}
+HANDLE_EXCEPTIONS_NO_RETURN(pipeline)
+
+ob_config *ob_pipeline_get_config(const ob_pipeline *pipeline, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(pipeline);
+    auto config    = new ob_config();
+    config->config = std::const_pointer_cast<libobsensor::Config>(pipeline->pipeline->getConfig());  // todo: it's not safe to cast const to non-const, fix it
+    return config;
+}
+HANDLE_EXCEPTIONS_AND_RETURN(nullptr, pipeline)
+
+void ob_pipeline_switch_config(ob_pipeline *pipeline, ob_config *config, ob_error **error) BEGIN_API_CALL {
+    pipeline->pipeline->switchConfig(config->config);
+}
+HANDLE_EXCEPTIONS_NO_RETURN(pipeline)
+
+ob_frame *ob_pipeline_wait_for_frameset(ob_pipeline *pipeline, uint32_t timeout_ms, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(pipeline);
+    auto frame = pipeline->pipeline->waitForFrame(timeout_ms);
+    if(!frame) {
+        return nullptr;
+    }
+    auto impl   = new ob_frame();
+    impl->frame = std::const_pointer_cast<libobsensor::Frame>(frame);  // todo: it's not safe to cast const to non-const, fix it
+    return impl;
+}
+HANDLE_EXCEPTIONS_AND_RETURN(nullptr, pipeline)
+
+ob_device *ob_pipeline_get_device(const ob_pipeline *pipeline, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(pipeline);
+    auto device  = pipeline->pipeline->getDevice();
+    auto impl    = new ob_device();
+    impl->device = device;
+    return impl;
+}
+HANDLE_EXCEPTIONS_AND_RETURN(nullptr, pipeline)
+
+ob_stream_profile_list *ob_pipeline_get_stream_profile_list(const ob_pipeline *pipeline, ob_sensor_type sensorType, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(pipeline);
+    auto device       = pipeline->pipeline->getDevice();
+    auto sensor       = device->getSensor(sensorType);
+    auto profiles     = sensor->getStreamProfileList();
+    auto impl         = new ob_stream_profile_list();
+    impl->profileList = profiles;
+    return impl;
+}
+HANDLE_EXCEPTIONS_AND_RETURN(nullptr, pipeline)
+
+void ob_pipeline_enable_frame_sync(ob_pipeline *pipeline, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(pipeline);
+    pipeline->pipeline->enableFrameSync();
+}
+HANDLE_EXCEPTIONS_NO_RETURN(pipeline)
+
+void ob_pipeline_disable_frame_sync(ob_pipeline *pipeline, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(pipeline);
+    pipeline->pipeline->disableFrameSync();
+}
+HANDLE_EXCEPTIONS_NO_RETURN(pipeline)
+
+ob_stream_profile_list *ob_get_d2c_depth_profile_list(const ob_pipeline *pipeline, const ob_stream_profile *color_profile, ob_align_mode align_mode,
+                                                      ob_error **error) BEGIN_API_CALL {
+    auto innerProfiles = pipeline->pipeline->getD2CDepthProfileList(color_profile->profile, align_mode);
+    auto impl          = new ob_stream_profile_list();
+    impl->profileList  = innerProfiles;
+    return impl;
+}
+HANDLE_EXCEPTIONS_AND_RETURN(nullptr, pipeline)
+
+ob_camera_param ob_pipeline_get_camera_param(ob_pipeline *pipeline, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(pipeline);
+    return pipeline->pipeline->getCameraParam();
+}
+HANDLE_EXCEPTIONS_AND_RETURN(ob_camera_param(), pipeline)
+
+ob_camera_param ob_pipeline_get_camera_param_with_profile(ob_pipeline *pipeline, uint32_t colorWidth, uint32_t colorHeight, uint32_t depthWidth,
+                                                          uint32_t depthHeight, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(pipeline);
+    return pipeline->pipeline->getCameraParam(colorWidth, colorHeight, depthWidth, depthHeight);
+}
+HANDLE_EXCEPTIONS_AND_RETURN(ob_camera_param(), pipeline, colorWidth, colorHeight, depthWidth, depthHeight)
+
+ob_calibration_param ob_pipeline_get_calibration_param(ob_pipeline *pipeline, ob_config *config, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(pipeline);
+    return pipeline->pipeline->getCalibrationParam(config ? config->config : nullptr);
+}
+HANDLE_EXCEPTIONS_AND_RETURN(ob_calibration_param(), pipeline, config)
+
+ob_config *ob_create_config(ob_error **error) BEGIN_API_CALL {
+    auto config    = new ob_config();
+    config->config = std::make_shared<libobsensor::Config>();
+    return config;
+}
+NO_ARGS_HANDLE_EXCEPTIONS_AND_RETURN(nullptr)
+
+void ob_delete_config(ob_config *config, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(config);
+    delete config;
+}
+HANDLE_EXCEPTIONS_NO_RETURN(config)
+
+void ob_config_enable_stream_with_stream_profile(ob_config *config, const ob_stream_profile *profile, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(config);
+    VALIDATE_NOT_NULL(profile);
+    config->config->enableStream(profile->profile);
+}
+HANDLE_EXCEPTIONS_NO_RETURN(config, profile)
+
+void ob_config_enable_stream(ob_config *config, ob_stream_type stream_type, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(config);
+    config->config->enableStream(stream_type);
+}
+HANDLE_EXCEPTIONS_NO_RETURN(config, stream_type)
+
+void ob_config_enable_all_stream(ob_config *config, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(config);
+    for(int i = 0; i < OB_STREAM_TYPE_COUNT; i++) {
+        config->config->enableStream(static_cast<ob_stream_type>(i));
+    }
+}
+HANDLE_EXCEPTIONS_NO_RETURN(config)
+
+void ob_config_enable_video_stream(ob_config *config, ob_stream_type stream_type, uint32_t width, uint32_t height, uint32_t fps, ob_format format,
+                                   ob_error **error) BEGIN_API_CALL {
+    config->config->enableVideoStream(stream_type, width, height, fps, format);
+}
+HANDLE_EXCEPTIONS_NO_RETURN(config, stream_type, width, height, fps, format)
+
+void ob_config_enable_accel_stream(ob_config *config, ob_accel_full_scale_range full_scale_range, ob_accel_sample_rate sample_rate,
+                                   ob_error **error) BEGIN_API_CALL {
+    config->config->enableAccelStream(full_scale_range, sample_rate);
+}
+HANDLE_EXCEPTIONS_NO_RETURN(config, full_scale_range, sample_rate)
+
+void ob_config_enable_gyro_stream(ob_config *config, ob_gyro_full_scale_range full_scale_range, ob_gyro_sample_rate sample_rate,
+                                  ob_error **error) BEGIN_API_CALL {
+    config->config->enableGyroStream(full_scale_range, sample_rate);
+}
+HANDLE_EXCEPTIONS_NO_RETURN(config, full_scale_range, sample_rate)
+
+ob_stream_profile_list *ob_config_get_enabled_stream_profile_list(const ob_config *config, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(config);
+    auto profiles     = config->config->getEnabledStreamProfileList();
+    auto impl         = new ob_stream_profile_list();
+    impl->profileList = profiles;
+    return impl;
+}
+HANDLE_EXCEPTIONS_AND_RETURN(nullptr, config)
+
+void ob_config_disable_stream(ob_config *config, ob_stream_type type, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(config);
+    config->config->disableStream(type);
+}
+HANDLE_EXCEPTIONS_NO_RETURN(config, type)
+
+void ob_config_disable_all_stream(ob_config *config, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(config);
+    config->config->disableAllStream();
+}
+HANDLE_EXCEPTIONS_NO_RETURN(config)
+
+void ob_config_set_align_mode(ob_config *config, ob_align_mode mode, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(config);
+    config->config->setAlignMode(mode);
+}
+HANDLE_EXCEPTIONS_NO_RETURN(config, mode)
+
+void ob_config_set_depth_scale_after_align_require(ob_config *config, bool enable, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(config);
+    config->config->setDepthScaleAfterAlignRequire(enable);
+}
+HANDLE_EXCEPTIONS_NO_RETURN(config, enable)
+
+void ob_config_set_frame_aggregate_output_mode(ob_config *config, ob_frame_aggregate_output_mode mode, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(config);
+    config->config->setFrameAggregateOutputMode(mode);
+}
+HANDLE_EXCEPTIONS_NO_RETURN(config, mode)
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/src/impl/Sensor.cpp b/src/impl/Sensor.cpp
new file mode 100644
index 00000000..20d037ae
--- /dev/null
+++ b/src/impl/Sensor.cpp
@@ -0,0 +1,122 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "libobsensor/h/Sensor.h"
+
+#include "ImplTypes.hpp"
+#include "exception/ObException.hpp"
+
+#include "ISensor.hpp"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+ob_sensor_type ob_sensor_get_type(const ob_sensor *sensor, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(sensor);
+    return sensor->type;
+}
+HANDLE_EXCEPTIONS_AND_RETURN(OB_SENSOR_UNKNOWN, sensor)
+
+ob_stream_profile_list *ob_sensor_get_stream_profile_list(const ob_sensor *sensor, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(sensor);
+    auto internalSensor = sensor->device->getSensor(sensor->type);
+    auto spList         = internalSensor->getStreamProfileList();
+
+    auto impl         = new ob_stream_profile_list();
+    impl->profileList = spList;
+    return impl;
+}
+HANDLE_EXCEPTIONS_AND_RETURN(nullptr, sensor)
+
+void ob_sensor_start(ob_sensor *sensor, const ob_stream_profile *profile, ob_frame_callback callback, void *user_data, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(sensor);
+    VALIDATE_NOT_NULL(profile);
+    VALIDATE_NOT_NULL(callback);
+    auto internalSensor = sensor->device->getSensor(sensor->type);
+    internalSensor->start(profile->profile, [callback, user_data](std::shared_ptr<const libobsensor::Frame> frame) {
+        auto implFrame   = new ob_frame();
+        implFrame->frame = std::const_pointer_cast<libobsensor::Frame>(frame);  // todo: this is a hack，need to fix
+        callback(implFrame, user_data);
+    });
+}
+HANDLE_EXCEPTIONS_NO_RETURN(sensor, profile, callback, user_data)
+
+void ob_sensor_stop(ob_sensor *sensor, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(sensor);
+    auto internalSensor = sensor->device->getSensor(sensor->type);
+    internalSensor->stop();
+}
+HANDLE_EXCEPTIONS_NO_RETURN(sensor)
+
+void ob_sensor_switch_profile(ob_sensor *sensor, ob_stream_profile *profile, ob_error **error) BEGIN_API_CALL {
+    auto innerSensor = sensor->device->getSensor(sensor->type);
+    if(innerSensor->isStreamActivated()) {
+        throw libobsensor::invalid_value_exception("sensor stream is not started!");
+    }
+    innerSensor->stop();
+    innerSensor->start(profile->profile, innerSensor->getFrameCallback());
+}
+HANDLE_EXCEPTIONS_NO_RETURN(sensor)
+
+ob_filter_list *ob_sensor_create_recommended_filter_list(const ob_sensor *sensor, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(sensor);
+    auto filterList  = sensor->device->createRecommendedPostProcessingFilters(sensor->type);
+    auto impl        = new ob_filter_list();
+    impl->filterList = filterList;
+    return impl;
+}
+HANDLE_EXCEPTIONS_AND_RETURN(nullptr, sensor)
+
+void ob_delete_sensor_list(ob_sensor_list *sensor_list, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(sensor_list);
+    delete sensor_list;
+}
+HANDLE_EXCEPTIONS_NO_RETURN(sensor_list)
+
+uint32_t ob_sensor_list_get_count(const ob_sensor_list *sensor_list, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(sensor_list);
+    return static_cast<uint32_t>(sensor_list->sensorTypes.size());
+}
+HANDLE_EXCEPTIONS_AND_RETURN(0, sensor_list)
+
+ob_sensor_type ob_sensor_list_get_sensor_type(const ob_sensor_list *sensor_list, uint32_t index, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(sensor_list);
+    VALIDATE_UNSIGNED_INDEX(index, sensor_list->sensorTypes.size());
+    return sensor_list->sensorTypes[index];
+}
+HANDLE_EXCEPTIONS_AND_RETURN(OB_SENSOR_UNKNOWN, sensor_list, index)
+
+ob_sensor *ob_sensor_list_get_sensor_by_type(const ob_sensor_list *sensor_list, ob_sensor_type sensorType, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(sensor_list);
+    for(auto &item: sensor_list->sensorTypes) {
+        if(item == sensorType) {
+            auto implSensor    = new ob_sensor();
+            implSensor->device = sensor_list->device;
+            implSensor->type   = item;
+            return implSensor;
+        }
+    }
+    throw libobsensor::invalid_value_exception("Sensor type not found in sensor list");
+}
+HANDLE_EXCEPTIONS_AND_RETURN(nullptr, sensor_list, sensorType)
+
+ob_sensor *ob_sensor_list_get_sensor(const ob_sensor_list *sensor_list, uint32_t index, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(sensor_list);
+    VALIDATE_UNSIGNED_INDEX(index, sensor_list->sensorTypes.size());
+    auto implSensor    = new ob_sensor();
+    implSensor->device = sensor_list->device;
+    implSensor->type   = sensor_list->sensorTypes[index];
+    return implSensor;
+}
+HANDLE_EXCEPTIONS_AND_RETURN(nullptr, sensor_list, index)
+
+void ob_delete_sensor(ob_sensor *sensor, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(sensor);
+    delete sensor;
+}
+HANDLE_EXCEPTIONS_NO_RETURN(sensor)
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/src/impl/StreamProfile.cpp b/src/impl/StreamProfile.cpp
new file mode 100644
index 00000000..d30e573a
--- /dev/null
+++ b/src/impl/StreamProfile.cpp
@@ -0,0 +1,383 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "libobsensor/h/StreamProfile.h"
+
+#include "ImplTypes.hpp"
+#include "exception/ObException.hpp"
+#include "context/Context.hpp"
+#include "stream/StreamProfile.hpp"
+#include "stream/StreamProfileFactory.hpp"
+
+#include "IStreamProfile.hpp"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+ob_stream_profile *ob_create_stream_profile(ob_stream_type type, ob_format format, ob_error **error) BEGIN_API_CALL {
+    auto profile         = libobsensor::StreamProfileFactory::createStreamProfile(type, format);
+    auto profileImpl     = new ob_stream_profile();
+    profileImpl->profile = profile;
+    return profileImpl;
+}
+HANDLE_EXCEPTIONS_AND_RETURN(nullptr, type, format)
+
+ob_stream_profile *ob_create_video_stream_profile(ob_stream_type type, ob_format format, uint32_t width, uint32_t height, uint32_t fps,
+                                                  ob_error **error) BEGIN_API_CALL {
+    auto profile         = libobsensor::StreamProfileFactory::createVideoStreamProfile(type, format, width, height, fps);
+    auto profileImpl     = new ob_stream_profile();
+    profileImpl->profile = profile;
+    return profileImpl;
+}
+HANDLE_EXCEPTIONS_AND_RETURN(nullptr, type, format, width, height, fps)
+
+ob_stream_profile *ob_create_accel_stream_profile(ob_accel_full_scale_range full_scale_range, ob_accel_sample_rate sample_rate,
+                                                  ob_error **error) BEGIN_API_CALL {
+    auto profile         = libobsensor::StreamProfileFactory::createAccelStreamProfile(full_scale_range, sample_rate);
+    auto profileImpl     = new ob_stream_profile();
+    profileImpl->profile = profile;
+    return profileImpl;
+}
+HANDLE_EXCEPTIONS_AND_RETURN(nullptr, full_scale_range, sample_rate)
+
+ob_stream_profile *ob_create_gyro_stream_profile(ob_gyro_full_scale_range full_scale_range, ob_gyro_sample_rate sample_rate, ob_error **error) BEGIN_API_CALL {
+    auto profile         = libobsensor::StreamProfileFactory::createGyroStreamProfile(full_scale_range, sample_rate);
+    auto profileImpl     = new ob_stream_profile();
+    profileImpl->profile = profile;
+    return profileImpl;
+}
+HANDLE_EXCEPTIONS_AND_RETURN(nullptr, full_scale_range, sample_rate)
+
+ob_stream_profile *ob_create_stream_profile_from_other_stream_profile(const ob_stream_profile *srcProfile, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(srcProfile);
+    auto sp              = srcProfile->profile->clone();
+    auto profileImpl     = new ob_stream_profile();
+    profileImpl->profile = sp;
+    return profileImpl;
+}
+HANDLE_EXCEPTIONS_AND_RETURN(nullptr, srcProfile)
+
+ob_stream_profile *ob_create_stream_profile_with_new_format(const ob_stream_profile *profile, ob_format new_format, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(profile);
+    auto sp              = profile->profile->clone(new_format);
+    auto profileImpl     = new ob_stream_profile();
+    profileImpl->profile = sp;
+    return profileImpl;
+}
+HANDLE_EXCEPTIONS_AND_RETURN(nullptr, profile, new_format)
+
+ob_format ob_stream_profile_get_format(const ob_stream_profile *profile, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(profile);
+    return profile->profile->getFormat();
+}
+HANDLE_EXCEPTIONS_AND_RETURN(OB_FORMAT_UNKNOWN, profile)
+
+void ob_stream_profile_set_format(ob_stream_profile *profile, ob_format format, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(profile);
+    auto noneConstProfile = std::const_pointer_cast<libobsensor::StreamProfile>(profile->profile);
+    noneConstProfile->setFormat(format);
+}
+HANDLE_EXCEPTIONS_NO_RETURN(profile, format)
+
+ob_stream_type ob_stream_profile_get_type(const ob_stream_profile *profile, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(profile);
+    return profile->profile->getType();
+}
+HANDLE_EXCEPTIONS_AND_RETURN(OB_STREAM_UNKNOWN, profile)
+
+void ob_stream_profile_set_type(const ob_stream_profile *profile, ob_stream_type type, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(profile);
+    auto noneConstProfile = std::const_pointer_cast<libobsensor::StreamProfile>(profile->profile);
+    noneConstProfile->setType(type);
+}
+HANDLE_EXCEPTIONS_NO_RETURN(profile, type)
+
+ob_extrinsic ob_stream_profile_get_extrinsic_to(const ob_stream_profile *source, ob_stream_profile *target, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(source);
+    VALIDATE_NOT_NULL(target);
+    return source->profile->getExtrinsicTo(target->profile);
+}
+HANDLE_EXCEPTIONS_AND_RETURN(ob_extrinsic(), source, target)
+
+void ob_stream_profile_set_extrinsic_to(ob_stream_profile *source, const ob_stream_profile *target, ob_extrinsic extrinsic, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(source);
+    VALIDATE_NOT_NULL(target);
+    auto noneConstProfile = std::const_pointer_cast<libobsensor::StreamProfile>(source->profile);
+    noneConstProfile->bindExtrinsicTo(target->profile, extrinsic);
+}
+HANDLE_EXCEPTIONS_NO_RETURN(source, target /*, extrinsic*/)  // TODO: add ob_extrinsic operator<<
+
+uint32_t ob_video_stream_profile_get_fps(const ob_stream_profile *profile, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(profile);
+    if(!profile->profile->is<libobsensor::VideoStreamProfile>()) {
+        throw libobsensor::unsupported_operation_exception("It's not a video stream profile!");
+    }
+    auto videoProfile = profile->profile->as<libobsensor::VideoStreamProfile>();
+    return videoProfile->getFps();
+}
+HANDLE_EXCEPTIONS_AND_RETURN(0, profile)
+
+uint32_t ob_video_stream_profile_get_width(const ob_stream_profile *profile, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(profile);
+    if(!profile->profile->is<libobsensor::VideoStreamProfile>()) {
+        throw libobsensor::unsupported_operation_exception("It's not a video stream profile!");
+    }
+    auto videoProfile = profile->profile->as<libobsensor::VideoStreamProfile>();
+    return videoProfile->getWidth();
+}
+HANDLE_EXCEPTIONS_AND_RETURN(0, profile)
+
+OB_EXPORT void ob_video_stream_profile_set_width(ob_stream_profile *profile, uint32_t width, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(profile);
+    VALIDATE_GE(width, 1);
+    if(!profile->profile->is<libobsensor::VideoStreamProfile>()) {
+        throw libobsensor::unsupported_operation_exception("It's not a video stream profile!");
+    }
+    auto videoProfile          = profile->profile->as<libobsensor::VideoStreamProfile>();
+    auto noneConstVideoProfile = std::const_pointer_cast<libobsensor::VideoStreamProfile>(videoProfile);
+    noneConstVideoProfile->setWidth(width);
+}
+HANDLE_EXCEPTIONS_NO_RETURN(profile, width)
+
+uint32_t ob_video_stream_profile_get_height(const ob_stream_profile *profile, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(profile);
+    if(!profile->profile->is<libobsensor::VideoStreamProfile>()) {
+        throw libobsensor::unsupported_operation_exception("It's not a video stream profile!");
+    }
+    auto videoProfile = profile->profile->as<libobsensor::VideoStreamProfile>();
+    return videoProfile->getHeight();
+}
+HANDLE_EXCEPTIONS_AND_RETURN(0, profile)
+
+void ob_video_stream_profile_set_height(ob_stream_profile *profile, uint32_t height, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(profile);
+    VALIDATE_GE(height, 1);
+    if(!profile->profile->is<libobsensor::VideoStreamProfile>()) {
+        throw libobsensor::unsupported_operation_exception("It's not a video stream profile!");
+    }
+    auto videoProfile          = profile->profile->as<libobsensor::VideoStreamProfile>();
+    auto noneConstVideoProfile = std::const_pointer_cast<libobsensor::VideoStreamProfile>(videoProfile);
+    noneConstVideoProfile->setHeight(height);
+}
+HANDLE_EXCEPTIONS_NO_RETURN(profile, height)
+
+ob_camera_intrinsic ob_video_stream_profile_get_intrinsic(const ob_stream_profile *profile, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(profile);
+    if(!profile->profile->is<libobsensor::VideoStreamProfile>()) {
+        throw libobsensor::unsupported_operation_exception("It's not a video stream profile!");
+    }
+    auto videoProfile = profile->profile->as<libobsensor::VideoStreamProfile>();
+    return videoProfile->getIntrinsic();
+}
+HANDLE_EXCEPTIONS_AND_RETURN(ob_camera_intrinsic(), profile)
+
+void ob_video_stream_profile_set_intrinsic(ob_stream_profile *profile, ob_camera_intrinsic intrinsic, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(profile);
+    if(!profile->profile->is<libobsensor::VideoStreamProfile>()) {
+        throw libobsensor::unsupported_operation_exception("It's not a video stream profile!");
+    }
+    auto noneConstProfile = std::const_pointer_cast<libobsensor::StreamProfile>(profile->profile);
+    auto videoProfile     = noneConstProfile->as<libobsensor::VideoStreamProfile>();
+    videoProfile->bindIntrinsic(intrinsic);
+}
+HANDLE_EXCEPTIONS_NO_RETURN(profile /*, intrinsic*/)  // TODO: add ob_camera_intrinsic operator<<
+
+ob_camera_distortion ob_video_stream_profile_get_distortion(const ob_stream_profile *profile, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(profile);
+    if(!profile->profile->is<libobsensor::VideoStreamProfile>()) {
+        throw libobsensor::unsupported_operation_exception("It's not a video stream profile!");
+    }
+    auto videoProfile = profile->profile->as<libobsensor::VideoStreamProfile>();
+    return videoProfile->getDistortion();
+}
+HANDLE_EXCEPTIONS_AND_RETURN(ob_camera_distortion(), profile)
+
+void ob_video_stream_profile_set_distortion(ob_stream_profile *profile, ob_camera_distortion distortion, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(profile);
+    if(!profile->profile->is<libobsensor::VideoStreamProfile>()) {
+        throw libobsensor::unsupported_operation_exception("It's not a video stream profile!");
+    }
+    auto noneConstProfile = std::const_pointer_cast<libobsensor::StreamProfile>(profile->profile);
+    auto videoProfile     = noneConstProfile->as<libobsensor::VideoStreamProfile>();
+    videoProfile->bindDistortion(distortion);
+}
+HANDLE_EXCEPTIONS_NO_RETURN(profile /*, distortion*/)  // TODO: add ob_camera_distortion operator<<
+
+ob_disparity_param ob_disparity_based_stream_profile_get_disparity_param(const ob_stream_profile *profile, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(profile);
+    if(!profile->profile->is<libobsensor::DisparityBasedStreamProfile>()) {
+        throw libobsensor::unsupported_operation_exception("It's not a disparity based stream profile!");
+    }
+    auto disparityProfile = profile->profile->as<libobsensor::DisparityBasedStreamProfile>();
+    return disparityProfile->getDisparityParam();
+}
+HANDLE_EXCEPTIONS_AND_RETURN(ob_disparity_param(), profile)
+
+void ob_disparity_based_stream_profile_set_disparity_param(ob_stream_profile *profile, ob_disparity_param disparity_param, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(profile);
+    if(!profile->profile->is<libobsensor::DisparityBasedStreamProfile>()) {
+        throw libobsensor::unsupported_operation_exception("It's not a disparity based stream profile!");
+    }
+    auto noneConstProfile = std::const_pointer_cast<libobsensor::StreamProfile>(profile->profile);
+    auto videoProfile     = noneConstProfile->as<libobsensor::DisparityBasedStreamProfile>();
+    videoProfile->bindDisparityParam(disparity_param);
+}
+HANDLE_EXCEPTIONS_NO_RETURN(profile /*,disparity_param*/)
+
+ob_accel_full_scale_range ob_accel_stream_profile_get_full_scale_range(const ob_stream_profile *profile, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(profile);
+    if(!profile->profile->is<libobsensor::AccelStreamProfile>()) {
+        throw libobsensor::unsupported_operation_exception("It's not an accel stream profile!");
+    }
+    auto accelProfile = profile->profile->as<libobsensor::AccelStreamProfile>();
+    return accelProfile->getFullScaleRange();
+}
+HANDLE_EXCEPTIONS_AND_RETURN(ob_accel_full_scale_range(), profile)
+
+ob_accel_sample_rate ob_accel_stream_profile_get_sample_rate(const ob_stream_profile *profile, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(profile);
+    if(!profile->profile->is<libobsensor::AccelStreamProfile>()) {
+        throw libobsensor::unsupported_operation_exception("It's not an accel stream profile!");
+    }
+    auto accelProfile = profile->profile->as<libobsensor::AccelStreamProfile>();
+    return accelProfile->getSampleRate();
+}
+HANDLE_EXCEPTIONS_AND_RETURN(ob_accel_sample_rate(), profile)
+
+ob_accel_intrinsic ob_accel_stream_profile_get_intrinsic(const ob_stream_profile *profile, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(profile);
+    if(!profile->profile->is<libobsensor::AccelStreamProfile>()) {
+        throw libobsensor::unsupported_operation_exception("It's not an accel stream profile!");
+    }
+    auto accelProfile = profile->profile->as<libobsensor::AccelStreamProfile>();
+    return accelProfile->getIntrinsic();
+}
+HANDLE_EXCEPTIONS_AND_RETURN(ob_accel_intrinsic(), profile)
+
+void ob_accel_stream_profile_set_intrinsic(ob_stream_profile *profile, ob_accel_intrinsic intrinsic, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(profile);
+    if(!profile->profile->is<libobsensor::AccelStreamProfile>()) {
+        throw libobsensor::unsupported_operation_exception("It's not an accel stream profile!");
+    }
+    auto noneConstProfile = std::const_pointer_cast<libobsensor::StreamProfile>(profile->profile);
+    auto accelProfile     = noneConstProfile->as<libobsensor::AccelStreamProfile>();
+    accelProfile->bindIntrinsic(intrinsic);
+}
+HANDLE_EXCEPTIONS_NO_RETURN(profile /*, intrinsic*/)  // TODO: add ob_accel_intrinsic operator<<
+
+ob_gyro_full_scale_range ob_gyro_stream_profile_get_full_scale_range(const ob_stream_profile *profile, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(profile);
+    if(!profile->profile->is<libobsensor::GyroStreamProfile>()) {
+        throw libobsensor::unsupported_operation_exception("It's not a gyro stream profile!");
+    }
+    auto gyroProfile = profile->profile->as<libobsensor::GyroStreamProfile>();
+    return gyroProfile->getFullScaleRange();
+}
+HANDLE_EXCEPTIONS_AND_RETURN(ob_gyro_full_scale_range(), profile)
+
+ob_gyro_sample_rate ob_gyro_stream_profile_get_sample_rate(const ob_stream_profile *profile, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(profile);
+    if(!profile->profile->is<libobsensor::GyroStreamProfile>()) {
+        throw libobsensor::unsupported_operation_exception("It's not a gyro stream profile!");
+    }
+    auto gyroProfile = profile->profile->as<libobsensor::GyroStreamProfile>();
+    return gyroProfile->getSampleRate();
+}
+HANDLE_EXCEPTIONS_AND_RETURN(ob_gyro_sample_rate(), profile)
+
+ob_gyro_intrinsic ob_gyro_stream_get_intrinsic(const ob_stream_profile *profile, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(profile);
+    if(!profile->profile->is<libobsensor::GyroStreamProfile>()) {
+        throw libobsensor::unsupported_operation_exception("It's not a gyro stream profile!");
+    }
+    auto gyroProfile = profile->profile->as<libobsensor::GyroStreamProfile>();
+    return gyroProfile->getIntrinsic();
+}
+HANDLE_EXCEPTIONS_AND_RETURN(ob_gyro_intrinsic(), profile)
+
+void ob_gyro_stream_set_intrinsic(ob_stream_profile *profile, ob_gyro_intrinsic intrinsic, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(profile);
+    if(!profile->profile->is<libobsensor::GyroStreamProfile>()) {
+        throw libobsensor::unsupported_operation_exception("It's not a gyro stream profile!");
+    }
+    auto noneConstProfile = std::const_pointer_cast<libobsensor::StreamProfile>(profile->profile);
+    auto gyroProfile      = noneConstProfile->as<libobsensor::GyroStreamProfile>();
+    gyroProfile->bindIntrinsic(intrinsic);
+}
+HANDLE_EXCEPTIONS_NO_RETURN(profile /*, intrinsic*/)  // TODO: add ob_gyro_intrinsic operator<<
+
+ob_stream_profile *ob_stream_profile_list_get_video_stream_profile(const ob_stream_profile_list *profile_list, int width, int height, ob_format format, int fps,
+                                                                   ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(profile_list);
+    auto matchedProfileList = libobsensor::matchVideoStreamProfile(profile_list->profileList, width, height, fps, format);
+    if(matchedProfileList.empty()) {
+        throw libobsensor::invalid_value_exception("Invalid input, No matched video stream profile found!");
+    }
+    auto profileImpl     = new ob_stream_profile();
+    profileImpl->profile = matchedProfileList[0];
+    return profileImpl;
+}
+HANDLE_EXCEPTIONS_AND_RETURN(nullptr, profile_list, width, height, format, fps)
+
+ob_stream_profile *ob_stream_profile_list_get_accel_stream_profile(const ob_stream_profile_list *profile_list, ob_accel_full_scale_range full_scale_range,
+                                                                   ob_accel_sample_rate sample_rate, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(profile_list);
+    auto matchedProfileList = libobsensor::matchAccelStreamProfile(profile_list->profileList, full_scale_range, sample_rate);
+    if(matchedProfileList.empty()) {
+        throw libobsensor::invalid_value_exception("Invalid input, No matched accel stream profile found!");
+    }
+    auto profileImpl     = new ob_stream_profile();
+    profileImpl->profile = matchedProfileList[0];
+    return profileImpl;
+}
+HANDLE_EXCEPTIONS_AND_RETURN(nullptr, profile_list, full_scale_range, sample_rate)
+
+ob_stream_profile *ob_stream_profile_list_get_gyro_stream_profile(const ob_stream_profile_list *profile_list, ob_gyro_full_scale_range full_scale_range,
+                                                                  ob_gyro_sample_rate sample_rate, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(profile_list);
+    auto matchedProfileList = libobsensor::matchGyroStreamProfile(profile_list->profileList, full_scale_range, sample_rate);
+    if(matchedProfileList.empty()) {
+        throw libobsensor::invalid_value_exception("Invalid input, No matched accel stream profile found!");
+    }
+    auto profileImpl     = new ob_stream_profile();
+    profileImpl->profile = matchedProfileList[0];
+    return profileImpl;
+}
+HANDLE_EXCEPTIONS_AND_RETURN(nullptr, profile_list, full_scale_range, sample_rate)
+
+ob_stream_profile *ob_stream_profile_list_get_profile(const ob_stream_profile_list *profile_list, int index, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(profile_list);
+    auto innerProfiles = profile_list->profileList;
+    if(index < 0 || static_cast<size_t>(index) >= innerProfiles.size()) {
+        throw libobsensor::invalid_value_exception("ob_stream_profile_list_get_profile: index out of range!");
+    }
+    auto innerProfile    = innerProfiles[index];
+    auto profileImpl     = new ob_stream_profile();
+    profileImpl->profile = innerProfile;
+    return profileImpl;
+}
+HANDLE_EXCEPTIONS_AND_RETURN(nullptr, profile_list, index)
+
+uint32_t ob_stream_profile_list_get_count(const ob_stream_profile_list *profile_list, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(profile_list);
+    auto innerProfiles = profile_list->profileList;
+    return (uint32_t)innerProfiles.size();
+}
+HANDLE_EXCEPTIONS_AND_RETURN(0, profile_list)
+
+void ob_delete_stream_profile_list(const ob_stream_profile_list *profile_list, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(profile_list);
+    delete profile_list;
+}
+HANDLE_EXCEPTIONS_NO_RETURN(profile_list)
+
+void ob_delete_stream_profile(const ob_stream_profile *profile, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(profile);
+    delete profile;
+}
+HANDLE_EXCEPTIONS_NO_RETURN(profile)
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/src/impl/TypeHelper.cpp b/src/impl/TypeHelper.cpp
new file mode 100644
index 00000000..47b80dcd
--- /dev/null
+++ b/src/impl/TypeHelper.cpp
@@ -0,0 +1,55 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "libobsensor/h/TypeHelper.h"
+
+#include "ImplTypes.hpp"
+#include "utils/Utils.hpp"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+const char* ob_format_type_to_string(OBFormat type){
+    return libobsensor::utils::obFormatToStr(type).c_str();
+}
+
+const char* ob_frame_type_to_string(OBFrameType type){
+    return libobsensor::utils::obFrameToStr(type).c_str();
+}
+
+const char *ob_format_to_string(OBFormat format) {
+    return libobsensor::utils::obFormatToStr(format).c_str();
+}
+
+const char* ob_stream_type_to_string(OBStreamType type){
+    return libobsensor::utils::obStreamToStr(type).c_str();
+}
+
+const char* ob_sensor_type_to_string(OBSensorType type){
+    return libobsensor::utils::obSensorToStr(type).c_str();
+}
+
+const char* ob_imu_rate_type_to_string(OBIMUSampleRate type){
+    return libobsensor::utils::obImuRateToStr(type).c_str();
+}
+
+const char* ob_gyro_range_type_to_string(OBGyroFullScaleRange type){
+    return libobsensor::utils::GyroFullScaleRangeToStr(type).c_str();
+}
+
+const char* ob_accel_range_type_to_string(OBAccelFullScaleRange type){
+    return libobsensor::utils::AccelFullScaleRangeToStr(type).c_str();
+}
+
+const char* ob_meta_data_type_to_string(OBFrameMetadataType type){
+    return libobsensor::utils::MetaDataToStr(type).c_str();
+}
+
+OBStreamType ob_sensor_type_to_stream_type(OBSensorType type){
+    return libobsensor::utils::mapSensorTypeToStreamType(type);
+}
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/src/impl/Utils.cpp b/src/impl/Utils.cpp
new file mode 100644
index 00000000..0f236b41
--- /dev/null
+++ b/src/impl/Utils.cpp
@@ -0,0 +1,239 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "libobsensor/h/Utils.h"
+#include "libobsensor/ObSensor.hpp"
+#include "exception/ObException.hpp"
+#include "exception/ObException.hpp"
+#include "utils/CoordinateUtil.hpp"
+#include "frame/FrameFactory.hpp"
+#include "FilterFactory.hpp"
+#include "ImplTypes.hpp"
+
+#ifdef __cplusplus
+extern "C" {
+ #endif
+
+bool ob_calibration_3d_to_3d(const ob_calibration_param calibration_param, const ob_point3f source_point3f,
+                                              const ob_sensor_type source_sensor_type, const ob_sensor_type target_sensor_type, ob_point3f *target_point3f,
+                                              ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(target_point3f);
+    // If the source and target are the same, no transformation is needed
+    if(target_sensor_type == source_sensor_type) 
+    {
+        *target_point3f = source_point3f;
+        return true;
+    }
+    OBExtrinsic     extrinsic;
+    memcpy(&extrinsic, &calibration_param.extrinsics[source_sensor_type][target_sensor_type], sizeof(OBExtrinsic));
+
+    return libobsensor::CoordinateUtil::transformation3dTo3d(source_point3f, extrinsic, target_point3f);
+}
+HANDLE_EXCEPTIONS_AND_RETURN(false, calibration_param, source_point3f, source_sensor_type, target_sensor_type, target_point3f)
+
+bool ob_transformation_3d_to_3d(const OBPoint3f source_point3f, OBExtrinsic extrinsic, OBPoint3f *target_point3f, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(target_point3f);
+    return libobsensor::CoordinateUtil::transformation3dTo3d(source_point3f, extrinsic, target_point3f);
+}
+HANDLE_EXCEPTIONS_AND_RETURN(false, source_point3f, extrinsic, target_point3f)
+
+bool ob_calibration_2d_to_3d(const ob_calibration_param calibration_param, const ob_point2f source_point2f,
+                                              const float source_depth_pixel_value, const ob_sensor_type source_sensor_type,
+                                              const ob_sensor_type target_sensor_type, ob_point3f *target_point3f, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(target_point3f);
+    OBExtrinsic     extrinsic;
+    OBCameraIntrinsic  sourceIntrinsic;
+    memcpy(&extrinsic, &calibration_param.extrinsics[source_sensor_type][target_sensor_type], sizeof(OBExtrinsic));
+
+    // Depending on the source sensor type, copy the corresponding intrinsic data
+    if(OB_SENSOR_DEPTH == source_sensor_type) {
+        memcpy(&sourceIntrinsic, &calibration_param.intrinsics[OB_SENSOR_DEPTH], sizeof(OBCameraIntrinsic));
+    } else if(OB_SENSOR_COLOR == source_sensor_type) {
+        memcpy(&sourceIntrinsic, &calibration_param.intrinsics[OB_SENSOR_COLOR], sizeof(OBCameraIntrinsic)); 
+    } else {
+        return false;
+    }
+    return libobsensor::CoordinateUtil::transformation2dTo3d(sourceIntrinsic, source_point2f, source_depth_pixel_value, extrinsic, target_point3f);
+}
+HANDLE_EXCEPTIONS_AND_RETURN(false, calibration_param, source_point2f, source_depth_pixel_value, source_sensor_type, target_sensor_type, target_point3f)
+
+bool ob_transformation_2d_to_3d(const OBPoint2f source_point2f, const float source_depth_pixel_value, const OBCameraIntrinsic source_intrinsic, 
+                                         OBExtrinsic extrinsic, OBPoint3f *target_point3f, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(target_point3f);
+    return libobsensor::CoordinateUtil::transformation2dTo3d(source_intrinsic, source_point2f, source_depth_pixel_value, extrinsic, target_point3f);
+}
+HANDLE_EXCEPTIONS_AND_RETURN(false, source_point2f, source_depth_pixel_value, source_intrinsic, extrinsic, target_point3f)
+
+bool ob_calibration_3d_to_2d(const ob_calibration_param calibration_param, const ob_point3f source_point3f,
+                                              const ob_sensor_type source_sensor_type, const ob_sensor_type target_sensor_type, ob_point2f *target_point2f,
+                                              ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(target_point2f);
+    OBExtrinsic     extrinsic;
+    OBCameraIntrinsic  sourceIntrinsic; 
+    OBCameraDistortion depthDistortion;
+
+    memcpy(&extrinsic, &calibration_param.extrinsics[source_sensor_type][target_sensor_type], sizeof(OBExtrinsic));
+    // Depending on the source sensor type, copy the corresponding intrinsic data
+    if(OB_SENSOR_DEPTH == source_sensor_type) {
+        memcpy(&sourceIntrinsic, &calibration_param.intrinsics[OB_SENSOR_DEPTH], sizeof(OBCameraIntrinsic));
+        memcpy(&depthDistortion, &calibration_param.distortion[OB_SENSOR_DEPTH], sizeof(OBCameraDistortion));
+    } else if(OB_SENSOR_COLOR == source_sensor_type) {
+        memcpy(&sourceIntrinsic, &calibration_param.intrinsics[OB_SENSOR_COLOR], sizeof(OBCameraIntrinsic)); 
+        memcpy(&depthDistortion, &calibration_param.distortion[OB_SENSOR_COLOR], sizeof(OBCameraDistortion));
+    } else {
+        return false;
+    }
+
+    return libobsensor::CoordinateUtil::transformation3dTo2d(source_point3f, sourceIntrinsic, depthDistortion, extrinsic, target_point2f);
+}
+HANDLE_EXCEPTIONS_AND_RETURN(false, calibration_param, source_point3f, source_sensor_type, target_sensor_type, target_point2f)
+
+bool ob_transformation_3d_to_2d(const OBPoint3f source_point3f, const OBCameraIntrinsic target_intrinsic, const OBCameraDistortion target_distortion,
+                                          OBExtrinsic extrinsic, OBPoint2f *target_point2f, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(target_point2f);
+    return libobsensor::CoordinateUtil::transformation3dTo2d(source_point3f, target_intrinsic, target_distortion, extrinsic, target_point2f);
+}
+HANDLE_EXCEPTIONS_AND_RETURN(false, source_point3f, target_intrinsic, target_distortion, extrinsic, target_point2f)
+
+
+bool ob_calibration_2d_to_2d(const ob_calibration_param calibration_param, const ob_point2f source_point2f,
+                                              const float source_depth_pixel_value, const ob_sensor_type source_sensor_type,
+                                              const ob_sensor_type target_sensor_type, ob_point2f *target_point2f,
+                                               ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(target_point2f);
+    OBExtrinsic     extrinsic;
+    OBCameraIntrinsic  sourceIntrinsic; 
+    OBCameraIntrinsic  targetIntrinsic; 
+    OBCameraDistortion sourceDistortion;
+    OBCameraDistortion targetDistortion;
+
+    memcpy(&extrinsic, &calibration_param.extrinsics[source_sensor_type][target_sensor_type], sizeof(OBExtrinsic));
+    // Depending on the source sensor type, copy the corresponding intrinsic data
+    if(OB_SENSOR_DEPTH == source_sensor_type) {
+        memcpy(&sourceIntrinsic, &calibration_param.intrinsics[OB_SENSOR_DEPTH], sizeof(OBCameraIntrinsic));
+        memcpy(&sourceDistortion, &calibration_param.distortion[OB_SENSOR_DEPTH], sizeof(OBCameraDistortion));
+    } else if(OB_SENSOR_COLOR == source_sensor_type) {
+        memcpy(&sourceIntrinsic, &calibration_param.intrinsics[OB_SENSOR_COLOR], sizeof(OBCameraIntrinsic)); 
+        memcpy(&sourceDistortion, &calibration_param.distortion[OB_SENSOR_COLOR], sizeof(OBCameraDistortion));
+    } else {
+        return false;
+    }
+
+    // Depending on the target sensor type, copy the corresponding intrinsic data
+    if(OB_SENSOR_DEPTH == target_sensor_type) {
+        memcpy(&targetIntrinsic, &calibration_param.intrinsics[OB_SENSOR_DEPTH], sizeof(OBCameraIntrinsic));
+        memcpy(&targetDistortion, &calibration_param.distortion[OB_SENSOR_DEPTH], sizeof(OBCameraDistortion));
+    } else if(OB_SENSOR_COLOR == target_sensor_type) {
+        memcpy(&targetIntrinsic, &calibration_param.intrinsics[OB_SENSOR_COLOR], sizeof(OBCameraIntrinsic)); 
+        memcpy(&targetDistortion, &calibration_param.distortion[OB_SENSOR_COLOR], sizeof(OBCameraDistortion));
+    } else {
+        return false;
+    }
+
+    return libobsensor::CoordinateUtil::transformation2dTo2d(sourceIntrinsic, sourceDistortion, source_point2f, 
+                        source_depth_pixel_value, targetIntrinsic, targetDistortion, extrinsic, target_point2f );
+}
+HANDLE_EXCEPTIONS_AND_RETURN(false, calibration_param, source_point2f, source_depth_pixel_value, source_sensor_type, target_sensor_type, target_point2f)
+
+bool ob_transformation_2d_to_2d(const OBPoint2f source_point2f, const float source_depth_pixel_value, const OBCameraIntrinsic source_intrinsic,
+                            const OBCameraDistortion source_distortion, const OBCameraIntrinsic target_intrinsic, const OBCameraDistortion target_distortion,
+                            OBExtrinsic extrinsic, OBPoint2f *target_point2f, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(target_point2f);
+    return libobsensor::CoordinateUtil::transformation2dTo2d(source_intrinsic, source_distortion, source_point2f, 
+                        source_depth_pixel_value, target_intrinsic, target_distortion, extrinsic, target_point2f );
+}
+HANDLE_EXCEPTIONS_AND_RETURN(false, source_point2f, source_depth_pixel_value, source_intrinsic, source_distortion, target_intrinsic, target_distortion, extrinsic, target_point2f)
+
+ob_frame *transformation_depth_frame_to_color_camera(ob_device *device, ob_frame *depth_frame, uint32_t target_color_camera_width,
+                                                                      uint32_t target_color_camera_height, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(device);
+    VALIDATE_NOT_NULL(device->device);
+    VALIDATE_NOT_NULL(depth_frame );
+    VALIDATE_NOT_NULL(depth_frame->frame);
+
+    VALIDATE_NOT_EQUAL(target_color_camera_width, 0);
+    VALIDATE_NOT_EQUAL(target_color_camera_height, 0);
+
+    //Get the color sensor from the device to get the streamprofile matching the target width/height.
+    auto sensor     = device->device->getSensor(OB_SENSOR_COLOR);    
+    auto profileList = sensor->getStreamProfileList();
+    auto matchedProfileList = matchVideoStreamProfile(profileList, target_color_camera_width, target_color_camera_height, OB_FPS_ANY, OB_FORMAT_ANY);
+    if(matchedProfileList.empty()) {
+         throw std::runtime_error("Error:No matched color stream profile");
+    }
+   
+    //Create a color frame from the streamprofile 
+    auto colorFrame =  libobsensor::FrameFactory::createFrameFromStreamProfile(matchedProfileList[0]);
+    
+    //Create frameset and put colorframe and depthframe in it
+    auto frameset = libobsensor::FrameFactory::createFrameSet();
+    frameset->pushFrame(colorFrame);
+    frameset->pushFrame(depth_frame->frame);  
+
+    //The process frameset gets the resultFrameSet
+    auto filterFactory = libobsensor::FilterFactory::getInstance();
+    auto filter        = filterFactory->createFilter("Align");    
+    filter->setConfigValue("AlignType", static_cast<double>(OB_STREAM_COLOR));
+    auto resultFrameSet = filter->process(frameset);
+
+    //Take out the depth frame from frameset
+    if(!resultFrameSet->is<libobsensor::FrameSet>()) {
+        throw libobsensor::unsupported_operation_exception("Error: not a frameset");
+    }
+    auto resultFrame = resultFrameSet->as<libobsensor::FrameSet>()->getFrame(OB_FRAME_DEPTH);
+    if(resultFrame == nullptr) {
+        return nullptr;
+    }
+    auto obframe   = new ob_frame();
+    obframe->frame = std::const_pointer_cast<libobsensor::Frame>(resultFrame);  
+    return obframe;
+}
+HANDLE_EXCEPTIONS_AND_RETURN(nullptr, device, depth_frame, target_color_camera_width, target_color_camera_height)
+
+bool transformation_init_xy_tables(const ob_calibration_param calibration_param, const ob_sensor_type sensor_type, float *data,
+                                                    uint32_t *data_size, ob_xy_tables *xy_tables, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(data);
+    VALIDATE_NOT_NULL(data_size);
+    VALIDATE_NOT_NULL(xy_tables);
+
+    OBCameraIntrinsic  sourceIntrinsic; 
+    OBCameraDistortion depthDistortion;
+
+    // Depending on the source sensor type, copy the corresponding intrinsic data
+    if(OB_SENSOR_DEPTH == sensor_type) {
+        memcpy(&sourceIntrinsic, &calibration_param.intrinsics[OB_SENSOR_DEPTH], sizeof(OBCameraIntrinsic));
+        memcpy(&depthDistortion, &calibration_param.distortion[OB_SENSOR_DEPTH], sizeof(OBCameraDistortion));
+    } else if(OB_SENSOR_COLOR == sensor_type) {
+        memcpy(&sourceIntrinsic, &calibration_param.intrinsics[OB_SENSOR_COLOR], sizeof(OBCameraIntrinsic)); 
+        memcpy(&depthDistortion, &calibration_param.distortion[OB_SENSOR_COLOR], sizeof(OBCameraDistortion));
+    } else {
+        return false;
+    }
+    return libobsensor::CoordinateUtil::transformationInitXYTables(sourceIntrinsic, depthDistortion, data, data_size, xy_tables);
+}
+HANDLE_EXCEPTIONS_AND_RETURN(false, calibration_param, sensor_type, data, data_size, xy_tables)
+
+void transformation_depth_to_pointcloud(ob_xy_tables *xy_tables, const void *depth_image_data, void *pointcloud_data,
+                                                         ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(xy_tables);
+    VALIDATE_NOT_NULL(depth_image_data);
+    VALIDATE_NOT_NULL(pointcloud_data);
+
+    return libobsensor::CoordinateUtil::transformationDepthToPointCloud(xy_tables, depth_image_data, pointcloud_data);
+}
+HANDLE_EXCEPTIONS_NO_RETURN(xy_tables, depth_image_data, pointcloud_data)
+
+void transformation_depth_to_rgbd_pointcloud(ob_xy_tables *xy_tables, const void *depth_image_data, const void *color_image_data,
+                                                              void *pointcloud_data, ob_error **error) BEGIN_API_CALL {
+    VALIDATE_NOT_NULL(xy_tables);
+    VALIDATE_NOT_NULL(depth_image_data);
+    VALIDATE_NOT_NULL(color_image_data);    
+    VALIDATE_NOT_NULL(pointcloud_data);
+
+    return libobsensor::CoordinateUtil::transformationDepthToRGBDPointCloud(xy_tables, depth_image_data, color_image_data, pointcloud_data);
+}
+HANDLE_EXCEPTIONS_NO_RETURN(xy_tables, depth_image_data, pointcloud_data)
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/src/impl/Version.cpp b/src/impl/Version.cpp
new file mode 100644
index 00000000..0617d35c
--- /dev/null
+++ b/src/impl/Version.cpp
@@ -0,0 +1,35 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "libobsensor/h/Version.h"
+
+#include "ImplTypes.hpp"
+#include "environment/Version.hpp"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int ob_get_version() {
+    return OB_LIB_VERSION;
+}
+
+int ob_get_major_version() {
+    return OB_LIB_MAJOR_VERSION;
+}
+
+int ob_get_minor_version() {
+    return OB_LIB_MINOR_VERSION;
+}
+
+int ob_get_patch_version() {
+    return OB_LIB_PATCH_VERSION;
+}
+
+const char *ob_get_stage_version() {
+    return OB_LIB_STAGE_VERSION;
+}
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/src/pipeline/CMakeLists.txt b/src/pipeline/CMakeLists.txt
new file mode 100644
index 00000000..f52e0f62
--- /dev/null
+++ b/src/pipeline/CMakeLists.txt
@@ -0,0 +1,21 @@
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+cmake_minimum_required(VERSION 3.5)
+
+# add the pipeline library with version number
+add_library(pipeline STATIC)
+set_target_properties(pipeline PROPERTIES VERSION ${PROJECT_VERSION})
+
+# add the pipeline library sources
+file(GLOB_RECURSE SOURCE_FILES "*.cpp" EXCLUDE unittest)
+file(GLOB_RECURSE HEADERS_FILES "*.hpp" EXCLUDE unittest)
+target_sources(pipeline PRIVATE ${SOURCE_FILES} ${HEADERS_FILES})
+
+target_link_libraries(pipeline PUBLIC ob::device)
+target_include_directories(pipeline PUBLIC  ${OB_PUBLIC_HEADERS_DIR} ${CMAKE_CURRENT_LIST_DIR})
+
+add_library(ob::pipeline ALIAS pipeline)
+ob_source_group(ob::pipeline)
+set_target_properties(pipeline PROPERTIES FOLDER "modules")
+
diff --git a/src/pipeline/Config.cpp b/src/pipeline/Config.cpp
new file mode 100644
index 00000000..4be1c225
--- /dev/null
+++ b/src/pipeline/Config.cpp
@@ -0,0 +1,138 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "Config.hpp"
+#include "logger/Logger.hpp"
+#include "stream/StreamProfileFactory.hpp"
+#include <algorithm>
+
+namespace libobsensor {
+
+void Config::enableStream(std::shared_ptr<const StreamProfile> prf) {
+    auto iter = std::find_if(enabledStreamProfileList_.begin(), enabledStreamProfileList_.end(),
+                             [prf](const std::shared_ptr<const StreamProfile> &p) { return p->getType() == prf->getType(); });
+    if(iter != enabledStreamProfileList_.end()) {
+        enabledStreamProfileList_.erase(iter);
+    }
+    enabledStreamProfileList_.push_back(prf);
+}
+
+void Config::enableStream(OBStreamType type) {
+    auto prf = StreamProfileFactory::createStreamProfile(type);
+    enableStream(prf);
+}
+
+void Config::enableVideoStream(OBStreamType type, uint32_t width, uint32_t height, uint32_t fps, OBFormat format) {
+    auto prf = StreamProfileFactory::createVideoStreamProfile(type, format, width, height, fps);
+    enableStream(prf);
+}
+void Config::enableAccelStream(OBAccelFullScaleRange fullScaleRange, ob_accel_sample_rate sampleRate) {
+    auto prf = StreamProfileFactory::createAccelStreamProfile(fullScaleRange, sampleRate);
+    enableStream(prf);
+}
+
+void Config::enableGyroStream(OBGyroFullScaleRange fullScaleRange, ob_gyro_sample_rate sampleRate) {
+    auto prf = StreamProfileFactory::createGyroStreamProfile(fullScaleRange, sampleRate);
+    enableStream(prf);
+}
+
+void Config::disableStream(OBStreamType type) {
+    auto prfIter = enabledStreamProfileList_.begin();
+    while(prfIter != enabledStreamProfileList_.end()) {
+        if((*prfIter)->getType() == type) {
+            enabledStreamProfileList_.erase(prfIter);
+            break;
+        }
+        else {
+            prfIter++;
+        }
+    }
+}
+
+StreamProfileList Config::getEnabledStreamProfileList() const {
+    return enabledStreamProfileList_;
+}
+
+std::shared_ptr<const StreamProfile> Config::getEnabledStreamProfile(OBStreamType type) const {
+    for(auto prf: enabledStreamProfileList_) {
+        if(prf->getType() == type) {
+            return prf;
+        }
+    }
+    return nullptr;
+}
+
+void Config::setAlignMode(OBAlignMode mode) {
+    alignMode_ = mode;
+}
+
+OBAlignMode Config::getAlignMode() const {
+    return alignMode_;
+}
+
+void Config::setDepthScaleAfterAlignRequire(bool enable) {
+    depthScaleRequire_ = enable;
+}
+
+bool Config::getDepthScaleAfterAlignRequire() const {
+    return depthScaleRequire_;
+}
+
+void Config::disableAllStream() {
+    enabledStreamProfileList_.clear();
+}
+
+void Config::setFrameAggregateOutputMode(OBFrameAggregateOutputMode mode) {
+    frameAggregateOutputMode_ = mode;
+}
+
+OBFrameAggregateOutputMode Config::getFrameAggregateOutputMode() const {
+    return frameAggregateOutputMode_;
+}
+
+bool Config::operator==(const Config &cmp) const {
+    if(cmp.alignMode_ != alignMode_ || cmp.depthScaleRequire_ != depthScaleRequire_
+       || cmp.enabledStreamProfileList_.size() != enabledStreamProfileList_.size()) {
+        return false;
+    }
+
+    for(const auto &sp: enabledStreamProfileList_) {
+        bool found = false;
+        for(const auto &cmpSp: cmp.enabledStreamProfileList_) {
+            if(sp.get() == cmpSp.get()) {
+                found = true;
+                break;
+            }
+        }
+
+        if(!found) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+bool Config::operator!=(const Config &cmp) const {
+    return !operator==(cmp);
+}
+
+std::shared_ptr<Config> Config::clone() const {
+    auto config                       = std::make_shared<Config>();
+    config->alignMode_                = alignMode_;
+    config->depthScaleRequire_        = depthScaleRequire_;
+    config->enabledStreamProfileList_ = enabledStreamProfileList_;
+    config->frameAggregateOutputMode_ = frameAggregateOutputMode_;
+    return config;
+}
+
+bool Config::isStreamEnabled(OBStreamType type) const {
+    for(auto sp: enabledStreamProfileList_) {
+        if(sp->getType() == type) {
+            return true;
+        }
+    }
+    return false;
+}
+
+}  // namespace libobsensor
diff --git a/src/pipeline/Config.hpp b/src/pipeline/Config.hpp
new file mode 100644
index 00000000..dae2c8a2
--- /dev/null
+++ b/src/pipeline/Config.hpp
@@ -0,0 +1,49 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include "stream/StreamProfile.hpp"
+#include <libobsensor/h/ObTypes.h>
+#include <vector>
+#include <memory>
+
+namespace libobsensor {
+
+class Config {
+public:
+    Config()           = default;
+    ~Config() noexcept = default;
+
+    void enableStream(std::shared_ptr<const StreamProfile> prf);
+    void enableStream(OBStreamType type);
+    void enableVideoStream(OBStreamType type, uint32_t width, uint32_t height, uint32_t fps, OBFormat format);
+    void enableAccelStream(OBAccelFullScaleRange fullScaleRange, OBAccelSampleRate sampleRate);
+    void enableGyroStream(OBGyroFullScaleRange fullScaleRange, OBGyroSampleRate sampleRate);
+
+    void disableStream(OBStreamType type);
+    void disableAllStream();
+
+    bool                                 isStreamEnabled(OBStreamType type) const;
+    StreamProfileList                    getEnabledStreamProfileList() const;
+    std::shared_ptr<const StreamProfile> getEnabledStreamProfile(OBStreamType type) const;
+
+    void        setAlignMode(OBAlignMode mode);
+    OBAlignMode getAlignMode() const;
+    void        setDepthScaleAfterAlignRequire(bool enable);
+    bool        getDepthScaleAfterAlignRequire() const;
+
+    void                       setFrameAggregateOutputMode(OBFrameAggregateOutputMode mode);
+    OBFrameAggregateOutputMode getFrameAggregateOutputMode() const;
+
+    bool operator==(const Config &cmp) const;
+    bool operator!=(const Config &cmp) const;
+
+    std::shared_ptr<Config> clone() const;
+
+private:
+    StreamProfileList          enabledStreamProfileList_;
+    OBAlignMode                alignMode_{ ALIGN_DISABLE };
+    bool                       depthScaleRequire_        = true;
+    OBFrameAggregateOutputMode frameAggregateOutputMode_ = OB_FRAME_AGGREGATE_OUTPUT_ANY_SITUATION;
+};
+}  // namespace libobsensor
diff --git a/src/pipeline/FrameAggregator.cpp b/src/pipeline/FrameAggregator.cpp
new file mode 100644
index 00000000..819d648c
--- /dev/null
+++ b/src/pipeline/FrameAggregator.cpp
@@ -0,0 +1,303 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+// #pragma once
+#include "FrameAggregator.hpp"
+#include "frame/FrameFactory.hpp"
+#include "logger/Logger.hpp"
+#include "utils/PublicTypeHelper.hpp"
+
+#include <thread>
+
+namespace libobsensor {
+
+#define MAX_FRAME_DELAY 0.5f  // 0.3s max delay diff + 0.1s max frame gap
+#define MAX_NORMAL_MODE_QUEUE_SIZE 3
+
+typedef std::map<OBFrameType, SourceFrameQueue>::iterator FrameQueuePair;
+
+const std::map<OBStreamType, OBFrameType> STREAM_FRAME_TYPE_MAP = {
+    { OB_STREAM_COLOR, OB_FRAME_COLOR },     { OB_STREAM_DEPTH, OB_FRAME_DEPTH },        { OB_STREAM_IR, OB_FRAME_IR },
+    { OB_STREAM_IR_LEFT, OB_FRAME_IR_LEFT }, { OB_STREAM_IR_RIGHT, OB_FRAME_IR_RIGHT },  { OB_STREAM_ACCEL, OB_FRAME_ACCEL },
+    { OB_STREAM_GYRO, OB_FRAME_GYRO },       { OB_STREAM_RAW_PHASE, OB_FRAME_RAW_PHASE }
+};
+
+uint64_t getFrameTimestampMsec(const std::shared_ptr<const Frame> &frame, FrameSyncMode syncMode) {
+    if(syncMode == FrameSyncModeSyncAccordingSystemTimestamp) {
+        return frame->getSystemTimeStampUsec() / 1000;
+    }
+    return frame->getTimeStampUsec() / 1000;
+}
+
+FrameAggregator::FrameAggregator()
+    : frameSyncMode_(FrameSyncModeDisable),
+      miniTimeStamp_(0),
+      frameAggregateOutputMode_(OB_FRAME_AGGREGATE_OUTPUT_ANY_SITUATION),
+      frameCnt_(0),
+      withColorFrame_(false),
+      matchingRateFirst_(true) {}
+
+FrameAggregator::~FrameAggregator() noexcept {
+    reset();
+}
+
+void FrameAggregator::updateConfig(std::shared_ptr<const Config> config, const bool matchingRateFirst) {
+    std::unique_lock<std::recursive_mutex> lk(srcFrameQueueMutex_);
+    frameAggregateOutputMode_ = config->getFrameAggregateOutputMode();
+    matchingRateFirst_        = matchingRateFirst;
+    reset();
+    auto profiles = config->getEnabledStreamProfileList();
+    for(auto &profile: profiles) {
+        float fps = 0;
+        if(profile->is<const VideoStreamProfile>()) {
+            auto videoProfile = profile->as<const VideoStreamProfile>();
+            fps               = (float)videoProfile->getFps();
+        }
+        else if(profile->is<const AccelStreamProfile>()) {
+            auto accelStreamProfile = profile->as<const AccelStreamProfile>();
+            fps                     = utils::mapIMUSampleRateToValue(accelStreamProfile->getSampleRate());
+        }
+        else if(profile->is<const GyroStreamProfile>()) {
+            auto gyroStreamProfile = profile->as<const GyroStreamProfile>();
+            fps                    = utils::mapIMUSampleRateToValue(gyroStreamProfile->getSampleRate());
+        }
+
+        float maxSyncQueueSize = fps * MAX_FRAME_DELAY + 1;
+        maxSyncQueueSize += ((maxSyncQueueSize - (int)maxSyncQueueSize) > 0 ? 1 : 0);
+        auto halfTspGap = static_cast<uint32_t>(500.0f / fps + 0.5);  // +0.5 to complete rounding
+        srcFrameQueueMap_.insert(
+            { STREAM_FRAME_TYPE_MAP.find(profile->getType())->second, { std::queue<std::shared_ptr<const Frame>>(), (uint32_t)maxSyncQueueSize, halfTspGap } });
+    }
+}
+
+void FrameAggregator::pushFrame(std::shared_ptr<const Frame> frame) {
+    std::unique_lock<std::recursive_mutex> lk(srcFrameQueueMutex_);
+    withEmptyQueue_ = false;
+    // auto tmp = frame->getSystemTimeStamp();
+    // LOG_INFO("Type: {}, AggFrameTimeStamp: {}", frame->getType(), frame->getSystemTimeStamp());
+    auto frameType = frame->getType();
+    for(auto &item: srcFrameQueueMap_) {
+        if(item.first == frameType) {
+            item.second.queue.push(frame);
+            uint32_t maxQueueSize_ = frameSyncMode_ == FrameSyncModeDisable ? MAX_NORMAL_MODE_QUEUE_SIZE : item.second.maxSyncQueueSize_;
+            // auto size = item.second.queue.size();
+            // LOG_INFO("Type: {}, queueSize: {}", frame->getType(), size);
+            if(item.second.queue.size() >= maxQueueSize_) {
+                withOverflowQueue_          = true;
+                withOverflowQueueFrameType_ = frameType;
+            }
+
+            auto timestamp = getFrameTimestampMsec(frame, frameSyncMode_);
+            if(srcFrameQueueMap_.size() > 1 && frameSyncMode_ && (srcFrameQueueMap_.size() == 2 || !matchingRateFirst_)
+               && (miniTimeStamp_ == 0 || timestamp < miniTimeStamp_)) {
+                miniTimeStamp_          = timestamp;
+                miniTimeStampFrameType_ = frameType;
+            }
+        }
+        else if(item.second.queue.empty()) {
+            withEmptyQueue_ = true;
+        }
+    }
+    tryAggregator();
+}
+
+void sortFrameMap(std::map<OBFrameType, SourceFrameQueue> &frameMap, std::vector<FrameQueuePair> &frameVec, FrameSyncMode frameSyncMode) {
+    // Sort srcFrameQueueMap_ so that the pair with the queue having the smallest timestamp at the front is placed first.
+    auto iter = frameMap.begin();
+    while(iter != frameMap.end()) {
+        if(!iter->second.queue.empty()) {
+            frameVec.push_back(iter);
+        }
+        iter++;
+    }
+    std::sort(frameVec.begin(), frameVec.end(), [frameSyncMode](const FrameQueuePair &x, const FrameQueuePair &y) {
+        auto xTsp = getFrameTimestampMsec(x->second.queue.front(), frameSyncMode);
+        auto yTsp = getFrameTimestampMsec(y->second.queue.front(), frameSyncMode);
+        return xTsp < yTsp;
+    });
+}
+
+void FrameAggregator::tryAggregator() {
+    std::unique_lock<std::recursive_mutex> lk(srcFrameQueueMutex_);
+    while(!withEmptyQueue_ || withOverflowQueue_) {
+        frameCnt_       = 0;
+        withColorFrame_ = false;
+        auto frameSet   = FrameFactory::createFrameSet();
+        if(!frameSet) {
+            std::this_thread::sleep_for(std::chrono::milliseconds(100));  // Wait for 100ms and then try again to see if the request can succeed.
+            continue;
+        }
+        if(srcFrameQueueMap_.size() > 1 && frameSyncMode_) {
+            if(matchingRateFirst_ && srcFrameQueueMap_.size() != 2) {  // Match rate priority
+                std::vector<FrameQueuePair> frameVector;
+                sortFrameMap(srcFrameQueueMap_, frameVector, frameSyncMode_);  // Sort srcFrameQueueMap_
+                auto refIter       = frameVector.begin();
+                auto refTsp        = getFrameTimestampMsec((*refIter)->second.queue.front(), frameSyncMode_);
+                auto refHalfTspGap = (*refIter)->second.halfTspGap;
+                for(auto &item: frameVector) {
+                    auto    &tarFrame      = item->second.queue.front();
+                    auto     tarHalfTspGap = item->second.halfTspGap;
+                    uint32_t tspHalfGap    = tarHalfTspGap < refHalfTspGap ? tarHalfTspGap : refHalfTspGap;
+
+                    auto tarTsp = getFrameTimestampMsec(tarFrame, frameSyncMode_);
+                    if(tarTsp - refTsp > tspHalfGap) {
+                        break;
+                    }
+                    refTsp        = tarTsp;  // After dequeuing, save the current reference timestamp to use as a reference for the next loop.
+                    refHalfTspGap = tarHalfTspGap;
+                    frameSet->pushFrame(std::move(tarFrame));
+                    frameCnt_++;
+                    if(item->first == OB_FRAME_COLOR) {
+                        withColorFrame_ = true;
+                    }
+                    item->second.queue.pop();
+                    if(withOverflowQueue_ && item->first == withOverflowQueueFrameType_) {
+                        withOverflowQueue_ = false;
+                    }
+                    if(!withEmptyQueue_ && item->second.queue.empty()) {
+                        withEmptyQueue_ = true;
+                    }
+                }
+            }
+            else {  // Match precision priority
+                uint64_t    newMiniTimeStamp_          = 0;
+                OBFrameType newMiniTimeStampFrameType_ = miniTimeStampFrameType_;
+                // Synchronous matching
+                auto refIter       = srcFrameQueueMap_.find(miniTimeStampFrameType_);
+                auto refTsp        = getFrameTimestampMsec(refIter->second.queue.front(), frameSyncMode_);
+                auto refHalfTspGap = refIter->second.halfTspGap;
+                for(auto &item: srcFrameQueueMap_) {
+                    if(!item.second.queue.empty()) {
+                        auto    &tarFrame      = item.second.queue.front();
+                        auto     tarHalfTspGap = item.second.halfTspGap;
+                        uint32_t tspHalfGap    = tarHalfTspGap < refHalfTspGap ? tarHalfTspGap : refHalfTspGap;
+                        auto     tarTsp        = getFrameTimestampMsec(tarFrame, frameSyncMode_);
+                        if(tarTsp - refTsp <= tspHalfGap) {
+                            frameSet->pushFrame(std::move(tarFrame));
+                            frameCnt_++;
+                            if(item.first == OB_FRAME_COLOR) {
+                                withColorFrame_ = true;
+                            }
+                            item.second.queue.pop();
+                            if(withOverflowQueue_ && item.first == withOverflowQueueFrameType_) {
+                                withOverflowQueue_ = false;
+                            }
+                        }
+                    }
+
+                    if(item.second.queue.empty()) {
+                        withEmptyQueue_ = true;
+                        continue;
+                    }
+
+                    auto tsp = getFrameTimestampMsec(item.second.queue.front(), frameSyncMode_);
+                    if(newMiniTimeStamp_ == 0 || newMiniTimeStamp_ > tsp) {
+                        newMiniTimeStamp_          = tsp;
+                        newMiniTimeStampFrameType_ = item.second.queue.front()->getType();
+                    }
+                }
+                miniTimeStamp_          = newMiniTimeStamp_;
+                miniTimeStampFrameType_ = newMiniTimeStampFrameType_;
+            }
+        }
+        else {
+            // Asynchronous matching
+            for(auto &item: srcFrameQueueMap_) {
+                if(!withEmptyQueue_ || item.second.queue.size() >= MAX_NORMAL_MODE_QUEUE_SIZE - 1) {
+                    auto &srcFrame = item.second.queue.front();
+                    frameSet->pushFrame(std::move(srcFrame));
+                    item.second.queue.pop();
+                    frameCnt_++;
+                    if(item.first == OB_FRAME_COLOR) {
+                        withColorFrame_ = true;
+                    }
+                }
+            }
+            withEmptyQueue_    = true;
+            withOverflowQueue_ = false;
+        }
+        // test code:
+        // auto        depthFrame = frameSet->getFrame(OB_FRAME_DEPTH);
+        // auto        colorFrame = frameSet->getFrame(OB_FRAME_COLOR);
+        // auto        irFrame    = frameSet->getFrame(OB_FRAME_IR);
+        // std::string msg;
+        // if(depthFrame) {
+        //     msg = msg + " | depthFrame tsp=" + std::to_string(depthFrame->getTimeStamp());
+        // }
+        // if(irFrame) {
+        //     msg = msg + " | irFrame tsp=" + std::to_string(irFrame->getTimeStamp());
+        // }
+        // if(colorFrame) {
+        //     msg = msg + " | colorFrame tsp=" + std::to_string(colorFrame->getTimeStamp());
+        // }
+        // if(depthFrame && irFrame) {
+        //     msg = msg + " | depth-ir diff=" + std::to_string((int64_t)depthFrame->getTimeStamp() - (int64_t)irFrame->getTimeStamp());
+        // }
+        // if(depthFrame && colorFrame) {
+        //     msg = msg + " | depth-color diff=" + std::to_string((int64_t)depthFrame->getTimeStamp() - (int64_t)colorFrame->getTimeStamp());
+        // }
+        // if(frameSyncMode_){
+        //     LOG_WARN(msg;
+        // }
+        outputFrameset(frameSet);
+    }
+}
+
+void FrameAggregator::outputFrameset(std::shared_ptr<const FrameSet> frameSet) {
+    if(frameSet != nullptr) {
+        if(srcFrameQueueMap_.size() == 1 || frameAggregateOutputMode_ == OB_FRAME_AGGREGATE_OUTPUT_ANY_SITUATION) {
+            FrameSetCallbackFunc_(frameSet);
+        }
+        else if(frameAggregateOutputMode_ == OB_FRAME_AGGREGATE_OUTPUT_COLOR_FRAME_REQUIRE && withColorFrame_) {
+            FrameSetCallbackFunc_(frameSet);
+        }
+        else if(frameAggregateOutputMode_ == OB_FRAME_AGGREGATE_OUTPUT_ALL_TYPE_FRAME_REQUIRE && frameCnt_ == srcFrameQueueMap_.size()) {
+            FrameSetCallbackFunc_(frameSet);
+        }
+    }
+}
+
+void FrameAggregator::enableFrameSync(FrameSyncMode mode) {
+    if(frameSyncMode_ != mode) {
+        std::unique_lock<std::recursive_mutex> lk(srcFrameQueueMutex_);
+        frameSyncMode_ = mode;
+        clearAllFrameQueue();
+    }
+}
+
+void FrameAggregator::setCallback(FrameCallback callback) {
+    FrameSetCallbackFunc_ = callback;
+}
+
+void FrameAggregator::clearAllFrameQueue() {
+    std::unique_lock<std::recursive_mutex> lk(srcFrameQueueMutex_);
+    for(auto &item: srcFrameQueueMap_) {
+        auto &queue = item.second.queue;
+        while(!queue.empty()) {
+            queue.pop();
+        }
+    }
+    miniTimeStamp_     = 0;
+    withOverflowQueue_ = false;
+}
+
+void FrameAggregator::reset() {
+    std::unique_lock<std::recursive_mutex> lk(srcFrameQueueMutex_);
+    clearAllFrameQueue();
+    srcFrameQueueMap_.clear();
+}
+
+void FrameAggregator::clearFrameQueue(OBFrameType frameType) {
+    std::unique_lock<std::recursive_mutex> lk(srcFrameQueueMutex_);
+    for(auto &item: srcFrameQueueMap_) {
+        if(frameType == item.first) {
+            auto &queue = item.second.queue;
+            while(!queue.empty()) {
+                queue.pop();
+            }
+            break;
+        }
+    }
+}
+
+}  // namespace libobsensor
diff --git a/src/pipeline/FrameAggregator.hpp b/src/pipeline/FrameAggregator.hpp
new file mode 100644
index 00000000..e4bef701
--- /dev/null
+++ b/src/pipeline/FrameAggregator.hpp
@@ -0,0 +1,63 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+// #include "core/frame/process/FrameProcessingBlock.hpp"
+#include "libobsensor/h/ObTypes.h"
+#include "frame/Frame.hpp"
+#include "Config.hpp"
+
+#include <map>
+#include <queue>
+#include <mutex>
+#include <memory>
+#include <algorithm>
+
+namespace libobsensor {
+
+struct SourceFrameQueue {
+    std::queue<std::shared_ptr<const Frame>> queue;
+    uint32_t                                 maxSyncQueueSize_;
+    uint32_t                                 halfTspGap;
+};
+
+enum FrameSyncMode {
+    FrameSyncModeDisable,
+    FrameSyncModeSyncAccordingFrameTimestamp,
+    FrameSyncModeSyncAccordingSystemTimestamp,
+};
+class FrameAggregator {
+public:
+public:
+    FrameAggregator();
+    ~FrameAggregator() noexcept;
+
+    void updateConfig(std::shared_ptr<const Config> config, const bool matchingRateFirst);
+    void pushFrame(std::shared_ptr<const Frame> frame);
+    void enableFrameSync(FrameSyncMode mode);
+    void setCallback(FrameCallback callback);
+
+    void clearFrameQueue(OBFrameType frameType);
+    void clearAllFrameQueue();
+
+private:
+    void outputFrameset(std::shared_ptr<const FrameSet> frameSet);
+    void reset();
+    void tryAggregator();
+
+private:
+    FrameSyncMode                           frameSyncMode_;
+    std::map<OBFrameType, SourceFrameQueue> srcFrameQueueMap_;
+    std::recursive_mutex                    srcFrameQueueMutex_;
+    FrameCallback                           FrameSetCallbackFunc_;
+    uint64_t                                miniTimeStamp_;
+    OBFrameType                             miniTimeStampFrameType_;
+    bool                                    withOverflowQueue_;
+    OBFrameType                             withOverflowQueueFrameType_;
+    bool                                    withEmptyQueue_;
+    OBFrameAggregateOutputMode              frameAggregateOutputMode_;
+    uint32_t                                frameCnt_;
+    bool                                    withColorFrame_;
+    bool                                    matchingRateFirst_;
+};
+}  // namespace libobsensor
diff --git a/src/pipeline/IPipeline.hpp b/src/pipeline/IPipeline.hpp
new file mode 100644
index 00000000..18f79288
--- /dev/null
+++ b/src/pipeline/IPipeline.hpp
@@ -0,0 +1,26 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include <atomic>
+#include <memory>
+
+namespace libobsensor {
+class Pipeline;
+class Config;
+}  // namespace libobsensor
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+struct ob_pipeline_t {
+    std::shared_ptr<libobsensor::Pipeline> pipeline;
+};
+
+struct ob_config_t {
+    std::shared_ptr<libobsensor::Config> config;
+};
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/src/pipeline/Pipeline.cpp b/src/pipeline/Pipeline.cpp
new file mode 100644
index 00000000..8c434ad0
--- /dev/null
+++ b/src/pipeline/Pipeline.cpp
@@ -0,0 +1,581 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "Pipeline.hpp"
+
+#include "DevicePids.hpp"
+#include "context/Context.hpp"
+#include "stream/StreamProfileFactory.hpp"
+#include "logger/LoggerInterval.hpp"
+#include "logger/LoggerHelper.hpp"
+#include "utils/Utils.hpp"
+#include "IAlgParamManager.hpp"
+#include "frameprocessor/FrameProcessor.hpp"
+
+#include <cmath>
+#include <algorithm>
+
+namespace libobsensor {
+Pipeline::Pipeline(std::shared_ptr<IDevice> dev) : device_(dev), config_(nullptr), streamState_(STREAM_STATE_STOPPED), pipelineCallback_(nullptr) {
+    LOG_DEBUG("Pipeline init ...");
+    auto sensorTypeList = device_->getSensorTypeList();
+    if(sensorTypeList.empty()) {
+        throw std::runtime_error("This device has no valid sensor!");
+    }
+
+    loadFrameQueueSizeConfig();
+
+    outputFrameQueue_ = std::make_shared<FrameQueue<const Frame>>(maxFrameQueueSize_);
+    frameAggregator_  = std::make_shared<FrameAggregator>();
+    frameAggregator_->setCallback([&](std::shared_ptr<const Frame> frame) { outputFrame(frame); });
+
+    TRY_EXECUTE(enableFrameSync());
+
+    auto deviceInfo = device_->getInfo();
+    LOG_INFO("Pipeline created with device: {{name: {0}, sn: {1}}}, @0x{2:X}", deviceInfo->name_, deviceInfo->deviceSn_, (uint64_t)this);
+}
+
+Pipeline::~Pipeline() noexcept {
+    LOG_DEBUG("Pipeline deInit start!");
+
+    if(streamState_ == STREAM_STATE_STARTING || streamState_ == STREAM_STATE_STREAMING) {
+        TRY_EXECUTE(stop());
+    }
+
+    outputFrameQueue_->reset();
+    LOG_INFO("Pipeline destroyed! @0x{:X}", (uint64_t)this);
+}
+
+void Pipeline::applyConfig(std::shared_ptr<const Config> cfg) {
+    if(!cfg) {
+        loadDefaultConfig();
+        return;
+    }
+    config_ = checkAndSetConfig(cfg);
+    checkHardwareD2CConfig();
+}
+
+void Pipeline::switchConfig(std::shared_ptr<const Config> cfg) {
+    if(!cfg) {
+        throw libobsensor::invalid_value_exception("Null pointer config!");
+    }
+
+    if(config_ && *cfg == *config_) {
+        LOG_INFO("Noting will be execute due to pipeline config have no been changed!");
+        return;
+    }
+
+    bool restartRequired = streamState_ == STREAM_STATE_STREAMING || streamState_ == STREAM_STATE_STARTING;
+    if(restartRequired) {
+        stopStream();
+        std::unique_lock<std::mutex> lk(streamMutex_);
+        start(cfg);
+    }
+    else {
+        std::unique_lock<std::mutex> lk(streamMutex_);
+        applyConfig(cfg);
+    }
+}
+
+void Pipeline::loadDefaultConfig() {
+    auto config = std::make_shared<Config>();
+
+    auto envConfig      = EnvConfig::getInstance();
+    auto sensorTypeList = device_->getSensorTypeList();
+
+    bool loaded = false;
+    for(auto &sensorType: sensorTypeList) {
+        auto        sensorTypeName = utils::obSensorToStr(sensorType);
+        std::string nodeName       = std::string("Pipeline.Stream.") + sensorTypeName;
+        if(!envConfig->isNodeContained(nodeName)) {
+            continue;
+        }
+
+        std::shared_ptr<const StreamProfile> profile;
+
+        bool UseDefaultStreamProfile = true;
+        envConfig->getBooleanValue(nodeName + ".UseDefaultStreamProfile", UseDefaultStreamProfile);
+        if(!UseDefaultStreamProfile) {
+            profile = StreamProfileFactory::getStreamProfileFromEnvConfig(nodeName, sensorType);
+        }
+
+        if(profile) {
+            config->enableStream(profile);
+        }
+        else {
+            auto streamType = utils::mapSensorTypeToStreamType(sensorType);
+            config->enableStream(streamType);
+        }
+        loaded = true;
+    }
+
+    if(!loaded) {
+        if(std::find(sensorTypeList.begin(), sensorTypeList.end(), OB_SENSOR_DEPTH) != sensorTypeList.end()) {
+            config->enableStream(OB_STREAM_DEPTH);
+        }
+        if(std::find(sensorTypeList.begin(), sensorTypeList.end(), OB_SENSOR_COLOR) != sensorTypeList.end()) {
+            config->enableStream(OB_STREAM_COLOR);
+        }
+    }
+    config_ = checkAndSetConfig(config);
+}
+
+void Pipeline::loadFrameQueueSizeConfig() {
+    auto envConfig = EnvConfig::getInstance();
+
+    envConfig->getIntValue("Memory.PipelineFrameQueueSize", maxFrameQueueSize_);
+    if(maxFrameQueueSize_ <= 0) {
+        LOG_WARN("Read xml config:pipeline frame queue size is invalid!");
+        maxFrameQueueSize_ = 10;
+    }
+
+    LOG_DEBUG("loadFrameQueueSizeConfig() config queue size: {}", maxFrameQueueSize_);
+}
+
+StreamProfileList Pipeline::getEnabledStreamProfileList() {
+    if(!config_) {
+        return {};
+    }
+    return config_->getEnabledStreamProfileList();
+}
+
+std::shared_ptr<Config> Pipeline::checkAndSetConfig(std::shared_ptr<const Config> cfg) {
+    LOG_DEBUG("Check and set config start!");
+    std::shared_ptr<Config> config = cfg->clone();
+    config->disableAllStream();
+    const auto enabledStreamProfiles = cfg->getEnabledStreamProfileList();
+    for(auto sp: enabledStreamProfiles) {
+        auto streamType = sp->getType();
+        auto sensorType = utils::mapStreamTypeToSensorType(streamType);
+        auto sensor     = device_->getSensor(sensorType);
+        if(!sensor) {
+            throw invalid_value_exception(utils::string::to_string() << "No matched sensor found for:" << sensorType);
+        }
+        auto sensorSpList = sensor->getStreamProfileList();
+        if(sensorType == OB_SENSOR_ACCEL) {
+            auto profile            = sp->as<AccelStreamProfile>();
+            auto matchedProfileList = matchAccelStreamProfile(sensorSpList, profile->getFullScaleRange(), profile->getSampleRate());
+            if(matchedProfileList.empty()) {
+                throw invalid_value_exception(utils::string::to_string() << "No matched profile found for:" << sp);
+            }
+            config->enableStream(matchedProfileList.front());
+        }
+        else if(sensorType == OB_SENSOR_GYRO) {
+            auto profile            = sp->as<GyroStreamProfile>();
+            auto matchedProfileList = matchGyroStreamProfile(sensorSpList, profile->getFullScaleRange(), profile->getSampleRate());
+            if(matchedProfileList.empty()) {
+                throw invalid_value_exception(utils::string::to_string() << "No matched profile found for:" << sp);
+            }
+            config->enableStream(matchedProfileList.front());
+        }
+        else {
+            auto profile            = sp->as<VideoStreamProfile>();
+            auto matchedProfileList = matchVideoStreamProfile(sensorSpList, profile->getWidth(), profile->getHeight(), profile->getFps(), profile->getFormat());
+            if(matchedProfileList.empty()) {
+                throw invalid_value_exception(utils::string::to_string() << "No matched profile found for: " << sp);
+            }
+            config->enableStream(matchedProfileList.front());
+        }
+    }
+    LOG_INFO("Check and set config done!");
+    return config;
+}
+
+void Pipeline::start(std::shared_ptr<const Config> cfg) {
+    LOG_DEBUG("Pipeline start() start!");
+
+    applyConfig(cfg);
+
+    if(config_->isStreamEnabled(OB_STREAM_DEPTH) || config_->isStreamEnabled(OB_STREAM_COLOR)) {
+        configAlignMode();
+    }
+
+    frameAggregator_->updateConfig(config_, true);
+
+    streamState_ = STREAM_STATE_STARTING;
+    BEGIN_TRY_EXECUTE({ startStream(); })
+    CATCH_EXCEPTION_AND_EXECUTE({
+        stop();
+        throw;
+    })
+
+    LOG_INFO("Pipeline start done!");
+}
+
+void Pipeline::start(std::shared_ptr<const Config> cfg, FrameCallback callback) {
+    pipelineCallback_ = callback;
+    start(cfg);
+}
+
+std::shared_ptr<const Config> Pipeline::getConfig() {
+    if(!config_) {
+        loadDefaultConfig();
+    }
+    return config_;
+}
+
+void Pipeline::startStream() {
+    LOG_INFO("Try to start streams!");
+
+    outputFrameQueue_->reset();  // reset output frame queue before restart streams
+
+    auto spList = config_->getEnabledStreamProfileList();
+    for(const auto &sp: spList) {
+        auto streamType = sp->getType();
+        auto sensorType = utils::mapStreamTypeToSensorType(streamType);
+        auto sensor     = device_->getSensor(sensorType);
+        if(!sensor) {
+            throw std::runtime_error("No sensor matched!");
+        }
+        sensor->start(sp, [&](std::shared_ptr<const Frame> frame) { onFrameCallback(frame); });
+
+        LOG_DEBUG("Sensor stream started, sensorType={}", sensor->getSensorType());
+    }
+    LOG_INFO("Start streams done!");
+}
+
+void Pipeline::onFrameCallback(std::shared_ptr<const Frame> frame) {
+    std::unique_lock<std::mutex> lk(streamMutex_);
+    if(streamState_ != STREAM_STATE_STOPPED && streamState_ != STREAM_STATE_STOPPING) {
+        if(streamState_ == STREAM_STATE_STARTING) {
+            streamState_ = STREAM_STATE_STREAMING;
+        }
+        frameAggregator_->pushFrame(frame);
+    }
+    auto frameType = frame->getType();
+    LOG_INTVL(LOG_INTVL_OBJECT_TAG + std::to_string(frameType), DEF_MIN_LOG_INTVL, spdlog::level::debug, "Frame received on pipeline! type={}", frameType);
+}
+
+void Pipeline::outputFrame(std::shared_ptr<const Frame> frame) {
+    LOG_FREQ_CALC(DEBUG, 5000, "Pipeline streaming... frameset output rate={freq}fps", streamState_);
+    if(streamState_ == STREAM_STATE_STREAMING) {
+        if(pipelineCallback_ != nullptr) {
+            pipelineCallback_(frame);
+            return;
+        }
+
+        if(outputFrameQueue_->fulled()) {
+            LOG_WARN_INTVL("Output frameset queue is full, drop oldest frameset!");
+            outputFrameQueue_->dequeue();
+        }
+        outputFrameQueue_->enqueue(std::move(frame));
+    }
+}
+
+std::shared_ptr<const Frame> Pipeline::waitForFrame(uint32_t timeout_ms) {
+    auto frame = outputFrameQueue_->dequeue(timeout_ms);
+    if(!frame) {
+        LOG_WARN_INTVL("Wait for frame timeout, you can try to increase the wait time! current timeout={}", timeout_ms);
+        return nullptr;
+    }
+    return frame;
+}
+
+void Pipeline::stopStream() {
+    LOG_INFO("Try to stop streams!");
+    if(!config_) {
+        LOG_WARN("The config is null!");
+        return;
+    }
+
+    auto cfgStreams = config_->getEnabledStreamProfileList();
+    auto streamIter = cfgStreams.end();
+    while(cfgStreams.size()) {
+        streamIter--;
+        auto streamType = (*streamIter)->getType();
+        auto sensorType = utils::mapStreamTypeToSensorType(streamType);
+        auto sensor     = device_->getSensor(sensorType);
+        TRY_EXECUTE({ sensor->stop(); })
+        LOG_INFO("Sensor stream stopped, sensorType={}", sensor->getSensorType());
+        if(streamIter == cfgStreams.begin()) {
+            break;
+        }
+    }
+
+    LOG_INFO("Stop streams done!");
+}
+
+void Pipeline::stop() {
+    LOG_INFO("Try to stop pipeline!");
+    if(streamState_ != STREAM_STATE_STOPPED) {
+        stopStream();
+    }
+
+    if(config_ && (config_->isStreamEnabled(OB_STREAM_DEPTH) || config_->isStreamEnabled(OB_STREAM_COLOR))) {
+        resetAlignMode();
+    }
+    if(frameAggregator_) {
+        frameAggregator_->clearAllFrameQueue();
+    }
+    enableHardwareD2C(false);
+
+    // flush output frame queue
+    outputFrameQueue_->flush();
+
+    // clear callback
+    pipelineCallback_ = nullptr;
+
+    streamState_ = STREAM_STATE_STOPPED;
+    LOG_INFO("Stop pipeline done!");
+}
+
+std::shared_ptr<IDevice> Pipeline::getDevice() {
+    if(device_) {
+        return device_;
+    }
+    return nullptr;
+}
+
+void Pipeline::configAlignMode() {
+    // todo: implement this function
+    // if(!config_) {
+    //     return;
+    // }
+    // auto alignMode = config_->getAlignMode();
+    // device_->configAlignMode(config_);
+}
+
+void Pipeline::resetAlignMode() {
+    // todo: implement this function
+    // if(device_) {
+    //     device_->resetAlignMode();
+    // }
+}
+
+StreamProfileList Pipeline::getD2CDepthProfileList(std::shared_ptr<const StreamProfile> colorProfile, OBAlignMode alignMode) {
+    StreamProfileList d2cDepthProfileList;
+    d2cDepthProfileList.clear();
+    if(!device_) {
+        return d2cDepthProfileList;
+    }
+
+    auto algParamManager         = device_->getComponentT<IAlgParamManager>(OB_DEV_COMPONENT_ALG_PARAM_MANAGER, false);
+    auto d2cProfileList          = algParamManager->getD2CProfileList();
+    auto colorVideoStreamProfile = colorProfile->as<VideoStreamProfile>();
+    auto depthSensor             = device_->getSensor(OB_SENSOR_DEPTH);
+    auto depthProfiles           = depthSensor->getStreamProfileList();
+    if(alignMode == ALIGN_DISABLE) {
+        return depthProfiles;
+    }
+
+    for(const auto &sp: d2cProfileList) {
+        if(colorVideoStreamProfile->getWidth() == sp.colorWidth && colorVideoStreamProfile->getHeight() == sp.colorHeight) {
+            for(auto profile: depthProfiles) {
+                auto depthProfile = profile->as<VideoStreamProfile>();
+                auto width        = depthProfile->getWidth();
+                auto height       = depthProfile->getHeight();
+                if(sp.depthWidth == width && sp.depthHeight == height
+                   && ((alignMode == ALIGN_D2C_HW_MODE && (sp.alignType & ALIGN_D2C_HW)) || (alignMode == ALIGN_D2C_SW_MODE && (sp.alignType & ALIGN_D2C_SW))))
+
+                {
+                    d2cDepthProfileList.push_back(depthProfile);
+                }
+            }
+        }
+    }
+
+    return d2cDepthProfileList;
+}
+
+OBCameraParam Pipeline::getCameraParam() {
+    OBCameraParam curCameraParam = {};
+    if(!device_ || !config_) {
+        return curCameraParam;
+    }
+
+    auto colorStreamProfile = config_->getEnabledStreamProfile(OB_STREAM_COLOR);
+    auto depthStreamProfile = config_->getEnabledStreamProfile(OB_STREAM_DEPTH);
+    if(!colorStreamProfile || !depthStreamProfile) {
+        return curCameraParam;
+    }
+
+    curCameraParam.rgbIntrinsic    = colorStreamProfile->as<VideoStreamProfile>()->getIntrinsic();
+    curCameraParam.rgbDistortion   = colorStreamProfile->as<VideoStreamProfile>()->getDistortion();
+    curCameraParam.depthIntrinsic  = depthStreamProfile->as<VideoStreamProfile>()->getIntrinsic();
+    curCameraParam.depthDistortion = depthStreamProfile->as<VideoStreamProfile>()->getDistortion();
+    curCameraParam.transform       = depthStreamProfile->getExtrinsicTo(colorStreamProfile);
+
+    return curCameraParam;
+}
+
+OBCameraParam Pipeline::getCameraParam(uint32_t colorWidth, uint32_t colorHeight, uint32_t depthWidth, uint32_t depthHeight) {
+    OBCameraParam curCameraParam = {};
+    if(!device_) {
+        return curCameraParam;
+    }
+    auto colorSensor = device_->getSensor(OB_SENSOR_COLOR);
+    if(!colorSensor) {
+        throw invalid_value_exception(utils::string::to_string() << "No matched color sensor found");
+    }
+    auto depthSensor = device_->getSensor(OB_SENSOR_DEPTH);
+    if(!depthSensor) {
+        throw invalid_value_exception(utils::string::to_string() << "No matched depth sensor found");
+    }
+
+    auto colorSensorSpList       = colorSensor->getStreamProfileList();
+    auto matchedColorProfileList = matchVideoStreamProfile(colorSensorSpList, colorWidth, colorHeight, OB_FPS_ANY, OB_FORMAT_ANY);
+    if(matchedColorProfileList.empty()) {
+        throw invalid_value_exception(utils::string::to_string() << "No matched color profile found");
+    }
+    auto colorStreamProfile = matchedColorProfileList.front();
+
+    auto depthSensorSpList       = depthSensor->getStreamProfileList();
+    auto matchedDepthProfileList = matchVideoStreamProfile(depthSensorSpList, depthWidth, depthHeight, OB_FPS_ANY, OB_FORMAT_ANY);
+    if(matchedDepthProfileList.empty()) {
+        throw invalid_value_exception(utils::string::to_string() << "No matched depth profile found");
+    }
+    auto depthStreamProfile = matchedDepthProfileList.front();
+
+    curCameraParam.rgbIntrinsic    = colorStreamProfile->getIntrinsic();
+    curCameraParam.rgbDistortion   = colorStreamProfile->getDistortion();
+    curCameraParam.depthIntrinsic  = depthStreamProfile->getIntrinsic();
+    curCameraParam.depthDistortion = depthStreamProfile->getDistortion();
+    curCameraParam.transform       = depthStreamProfile->getExtrinsicTo(colorStreamProfile);
+
+    return curCameraParam;
+}
+
+OBCalibrationParam Pipeline::getCalibrationParam(std::shared_ptr<Config> cfg) {
+    OBCalibrationParam calibrationParam = {};
+    if(!device_ || !cfg) {
+        return calibrationParam;
+    }
+
+    // convert stream profile on config to real stream profile on sensors
+    auto config = checkAndSetConfig(cfg);
+
+    memset(calibrationParam.intrinsics, 0, sizeof(OBCameraIntrinsic) * OB_SENSOR_TYPE_COUNT);
+    memset(calibrationParam.distortion, 0, sizeof(OBCameraDistortion) * OB_SENSOR_TYPE_COUNT);
+    for(int i = 0; i < OB_SENSOR_TYPE_COUNT; i++) {
+        for(int j = 0; j < OB_SENSOR_TYPE_COUNT; j++) {
+            float rot[9] = { 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f };
+            memset(calibrationParam.extrinsics[i][j].trans, 0, sizeof(float) * 3);
+            memcpy(calibrationParam.extrinsics[i][j].rot, rot, sizeof(float) * 9);
+        }
+    }
+
+    // Intrinsic (cameras only)
+    for(int i = 0; i < OB_SENSOR_TYPE_COUNT; i++) {
+        auto sensorType = static_cast<OBSensorType>(i);
+        if(!device_->isSensorExists(sensorType)) {
+            continue;
+        }
+        auto streamType = utils::mapSensorTypeToStreamType(sensorType);
+        if(streamType == OB_STREAM_ACCEL || streamType == OB_STREAM_GYRO) {
+            continue;
+        }
+
+        auto streamProfile = config->getEnabledStreamProfile(streamType);
+        if(!streamProfile) {
+            auto sensor = device_->getSensor(sensorType);
+            auto spList = sensor->getStreamProfileList();
+            if(spList.empty()) {
+                continue;
+            }
+            streamProfile = spList.front();
+        }
+        auto intrinsic  = streamProfile->as<VideoStreamProfile>()->getIntrinsic();
+        auto distortion = streamProfile->as<VideoStreamProfile>()->getDistortion();
+        memcpy(&calibrationParam.intrinsics[sensorType], &intrinsic, sizeof(OBCameraIntrinsic));
+        memcpy(&calibrationParam.distortion[sensorType], &distortion, sizeof(OBCameraDistortion));
+    }
+
+    // Extrinsic
+    for(int source = 0; source < OB_SENSOR_TYPE_COUNT; source++) {
+        for(int target = 0; target < OB_SENSOR_TYPE_COUNT; target++) {
+            if(source == target) {
+                continue;
+            }
+
+            auto sourceSensorType = static_cast<OBSensorType>(source);
+            auto targetSensorType = static_cast<OBSensorType>(target);
+            if(!device_->isSensorExists(sourceSensorType) || !device_->isSensorExists(targetSensorType)) {
+                continue;
+            }
+
+            auto                                 sourceStreamType = utils::mapSensorTypeToStreamType(sourceSensorType);
+            auto                                 targetStreamType = utils::mapSensorTypeToStreamType(targetSensorType);
+            std::shared_ptr<const StreamProfile> sourceStreamProfile;
+            std::shared_ptr<const StreamProfile> targetStreamProfile;
+
+            sourceStreamProfile = config->getEnabledStreamProfile(sourceStreamType);
+            if(!sourceStreamProfile) {
+                auto sensor = device_->getSensor(sourceSensorType);
+                auto spList = sensor->getStreamProfileList();
+                if(spList.empty()) {
+                    continue;
+                }
+                sourceStreamProfile = spList.front();
+            }
+            targetStreamProfile = config->getEnabledStreamProfile(targetStreamType);
+            if(!targetStreamProfile) {
+                auto sensor = device_->getSensor(targetSensorType);
+                auto spList = sensor->getStreamProfileList();
+                if(spList.empty()) {
+                    continue;
+                }
+                targetStreamProfile = spList.front();
+            }
+
+            auto sourceToTargetExtrinsic = sourceStreamProfile->getExtrinsicTo(targetStreamProfile);
+            memcpy(&calibrationParam.extrinsics[source][target], &sourceToTargetExtrinsic, sizeof(OBExtrinsic));
+            auto targetToSourceExtrinsic = targetStreamProfile->getExtrinsicTo(sourceStreamProfile);
+            memcpy(&calibrationParam.extrinsics[target][source], &targetToSourceExtrinsic, sizeof(OBExtrinsic));
+        }
+    }
+
+    return calibrationParam;
+}
+
+void Pipeline::enableFrameSync() {
+    if(device_->getExtensionInfo("AllSensorsUsingSameClock") == "true") {
+        frameAggregator_->enableFrameSync(FrameSyncModeSyncAccordingFrameTimestamp);
+    }
+    else {
+        LOG_WARN("Frame sync is not supported for sensors with different clocks! Use system timestamp instead, the accuracy may be lower!");
+        frameAggregator_->enableFrameSync(FrameSyncModeSyncAccordingSystemTimestamp);
+    }
+}
+
+void Pipeline::disableFrameSync() {
+    frameAggregator_->enableFrameSync(FrameSyncModeDisable);
+}
+
+void Pipeline::checkHardwareD2CConfig() {
+    auto frameProcessor      = device_->getComponentT<FrameProcessor>(OB_DEV_COMPONENT_DEPTH_FRAME_PROCESSOR, false);
+    auto depthFrameProcessor = std::dynamic_pointer_cast<DepthFrameProcessor>(frameProcessor.get());
+    if(!depthFrameProcessor) {
+        return;
+    }
+
+    if(config_->getAlignMode() != ALIGN_D2C_HW_MODE) {
+        enableHardwareD2C(false);
+        return;
+    }
+
+    auto algParamManager = device_->getComponentT<IAlgParamManager>(OB_DEV_COMPONENT_ALG_PARAM_MANAGER, false);
+    auto colorProfile    = config_->getEnabledStreamProfile(OB_STREAM_COLOR);
+    auto depthProfile    = config_->getEnabledStreamProfile(OB_STREAM_DEPTH);
+    if(algParamManager && colorProfile && depthProfile) {
+        auto colorVideoStreamProfile = colorProfile->as<VideoStreamProfile>();
+        auto depthVideoStreamProfile = depthProfile->as<VideoStreamProfile>();
+        auto calibrationCameraParams = algParamManager->getCalibrationCameraParamList();
+        auto d2cProfileList          = algParamManager->getD2CProfileList();
+        depthFrameProcessor->setHardwareD2CProcessParams(colorVideoStreamProfile->getWidth(), colorVideoStreamProfile->getHeight(),
+                                                         depthVideoStreamProfile->getWidth(), depthVideoStreamProfile->getHeight(), calibrationCameraParams,
+                                                         d2cProfileList);
+        enableHardwareD2C(true);
+    }
+}
+
+void Pipeline::enableHardwareD2C(bool enable) {
+    auto frameProcessor      = device_->getComponentT<FrameProcessor>(OB_DEV_COMPONENT_DEPTH_FRAME_PROCESSOR, false);
+    auto depthFrameProcessor = std::dynamic_pointer_cast<DepthFrameProcessor>(frameProcessor.get());
+    if(!depthFrameProcessor) {
+        return;
+    }
+    depthFrameProcessor->enableHardwareD2CProcess(enable);
+}
+
+}  // namespace libobsensor
+
diff --git a/src/pipeline/Pipeline.hpp b/src/pipeline/Pipeline.hpp
new file mode 100644
index 00000000..05200f14
--- /dev/null
+++ b/src/pipeline/Pipeline.hpp
@@ -0,0 +1,73 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include "IPipeline.hpp"
+#include "IDevice.hpp"
+#include "IFrame.hpp"
+#include "frame/FrameQueue.hpp"
+#include "Config.hpp"
+#include "FrameAggregator.hpp"
+
+namespace libobsensor {
+class Config;
+class Pipeline {
+public:
+    Pipeline(std::shared_ptr<IDevice> dev);
+    virtual ~Pipeline() noexcept;
+
+    void                         start(std::shared_ptr<const Config> cfg = nullptr);
+    void                         start(std::shared_ptr<const Config> cfg, FrameCallback callback);
+    StreamProfileList            getEnabledStreamProfileList();
+    void                         stop();
+    std::shared_ptr<IDevice>     getDevice();
+    std::shared_ptr<const Frame> waitForFrame(uint32_t timeout_ms = 1000);
+
+    StreamProfileList getD2CDepthProfileList(std::shared_ptr<const StreamProfile> colorProfile, OBAlignMode alignMode);
+
+    OBCameraParam getCameraParam();
+    OBCameraParam getCameraParam(uint32_t colorWidth, uint32_t colorHeight, uint32_t depthWidth, uint32_t depthHeight);
+    OBCalibrationParam getCalibrationParam(std::shared_ptr<Config> cfg);
+
+    void enableFrameSync();
+    void disableFrameSync();
+
+    std::shared_ptr<const Config> getConfig();
+    void switchConfig(std::shared_ptr<const Config> cfg);
+private:
+    inline void startStream();
+    inline void stopStream();
+
+    void onFrameCallback(std::shared_ptr<const Frame> frame);
+    void outputFrame(std::shared_ptr<const Frame> frame);
+
+    void loadDefaultConfig();
+    void loadFrameQueueSizeConfig();
+
+    void configAlignMode();
+    void resetAlignMode();
+
+    void                    applyConfig(std::shared_ptr<const Config> cfg);
+    std::shared_ptr<Config> checkAndSetConfig(std::shared_ptr<const Config> cfg);
+
+    void checkHardwareD2CConfig();
+
+    void enableHardwareD2C(bool enable);
+
+private:
+    std::shared_ptr<IDevice>      device_;
+    std::shared_ptr<const Config> config_;
+
+    OBStreamState streamState_;
+    std::mutex    streamMutex_;
+
+    std::shared_ptr<FrameQueue<const Frame>> outputFrameQueue_;
+    FrameCallback                            pipelineCallback_;
+
+    std::shared_ptr<FrameAggregator> frameAggregator_;
+
+    int maxFrameQueueSize_ = 10;
+};
+
+}  // namespace libobsensor
+
diff --git a/src/platform/CMakeLists.txt b/src/platform/CMakeLists.txt
new file mode 100644
index 00000000..aac8f140
--- /dev/null
+++ b/src/platform/CMakeLists.txt
@@ -0,0 +1,38 @@
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+cmake_minimum_required(VERSION 3.5)
+
+set(OB_TARGET_PAL platform)
+add_library(${OB_TARGET_PAL} STATIC)
+set_target_properties(${OB_TARGET_PAL} PROPERTIES VERSION ${PROJECT_VERSION})
+
+target_sources(${OB_TARGET_PAL} PRIVATE ${CMAKE_CURRENT_LIST_DIR}/Platform.cpp ${CMAKE_CURRENT_LIST_DIR}/Platform.hpp)
+target_link_libraries(${OB_TARGET_PAL} PUBLIC ob::shared ob::core)
+target_include_directories(${OB_TARGET_PAL} PUBLIC ${OB_PUBLIC_HEADERS_DIR} ${CMAKE_CURRENT_LIST_DIR})
+
+if(OB_BUILD_USB_PAL)
+    add_subdirectory(usb)
+    add_subdirectory(${OB_3RDPARTY_DIR}/libusb libusb)
+    target_link_libraries(${OB_TARGET_PAL} PUBLIC libusb::libusb)
+
+    if(NOT OB_BUILD_WIN32)
+        add_subdirectory(${OB_3RDPARTY_DIR}/libuvc libuvc)
+        target_link_libraries(${OB_TARGET_PAL} PUBLIC libuvc::libuvc)
+    endif()
+elseif(OB_BUILD_GMSL_PAL)
+    add_subdirectory(usb)
+endif()
+
+
+if(OB_BUILD_NET_PAL)
+    add_subdirectory(ethernet)
+    add_subdirectory(${OB_3RDPARTY_DIR}/live555 live555)
+    target_link_libraries(${OB_TARGET_PAL} PUBLIC live555::live555)
+endif()
+
+add_library(ob::platform ALIAS ${OB_TARGET_PAL})
+ob_source_group(ob::platform)
+
+set_target_properties(${OB_TARGET_PAL} PROPERTIES FOLDER "modules")
+
diff --git a/src/platform/IDeviceWatcher.hpp b/src/platform/IDeviceWatcher.hpp
new file mode 100644
index 00000000..c0fa2352
--- /dev/null
+++ b/src/platform/IDeviceWatcher.hpp
@@ -0,0 +1,25 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include <functional>
+#include <string>
+
+namespace libobsensor {
+
+typedef enum {
+    OB_DEVICE_REMOVED,
+    OB_DEVICE_ARRIVAL,
+} OBDeviceChangedType;
+
+typedef std::function<void(OBDeviceChangedType changeType, std::string devUid)> deviceChangedCallback;
+
+class IDeviceWatcher {
+public:
+    virtual ~IDeviceWatcher() noexcept = default;
+
+    virtual void start(deviceChangedCallback callback) = 0;
+    virtual void stop()                                = 0;
+};
+
+}  // namespace libobsensor
diff --git a/src/platform/IPal.hpp b/src/platform/IPal.hpp
new file mode 100644
index 00000000..e7f0c90f
--- /dev/null
+++ b/src/platform/IPal.hpp
@@ -0,0 +1,27 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include "ISourcePort.hpp"
+#include "IDeviceWatcher.hpp"
+
+namespace libobsensor {
+
+class IPal {
+public:
+    virtual ~IPal() noexcept = default;
+
+    virtual SourcePortInfoList              querySourcePortInfos()                               = 0;
+    virtual std::shared_ptr<ISourcePort>    getSourcePort(std::shared_ptr<const SourcePortInfo>) = 0;
+    virtual std::shared_ptr<IDeviceWatcher> createDeviceWatcher() const                          = 0;
+};
+
+#if defined(BUILD_USB_PAL)
+std::shared_ptr<IPal> createUsbPal();
+#endif
+
+#if defined(BUILD_NET_PAL)
+std::shared_ptr<IPal> createNetPal();
+#endif
+}  // namespace libobsensor
diff --git a/src/platform/ISourcePort.hpp b/src/platform/ISourcePort.hpp
new file mode 100644
index 00000000..c0c83119
--- /dev/null
+++ b/src/platform/ISourcePort.hpp
@@ -0,0 +1,140 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include <memory>
+#include <vector>
+#include <string>
+
+#include "libobsensor/h/ObTypes.h"
+#include "IFrame.hpp"
+#include "IStreamProfile.hpp"
+
+namespace libobsensor {
+enum SourcePortType {
+    SOURCE_PORT_USB_VENDOR = 0x00,
+    SOURCE_PORT_USB_UVC,
+    SOURCE_PORT_USB_MULTI_UVC,
+    SOURCE_PORT_USB_HID,
+    SOURCE_PORT_NET_VENDOR = 0x10,
+    SOURCE_PORT_NET_VENDOR_STREAM,
+    SOURCE_PORT_NET_RTSP,
+    SOURCE_PORT_IPC_VENDOR,  // Inter-process communication port
+    SOURCE_PORT_UNKNOWN = 0xff,
+};
+
+#define IS_USB_PORT(type) ((type) >= SOURCE_PORT_USB_VENDOR && (type) <= SOURCE_PORT_USB_HID)
+#define IS_NET_PORT(type) ((type) >= SOURCE_PORT_NET_VENDOR && (type) <= SOURCE_PORT_NET_RTSP)
+
+struct SourcePortInfo {
+    SourcePortInfo(SourcePortType portType) : portType(portType) {}
+    virtual ~SourcePortInfo() noexcept                                      = default;
+    virtual bool equal(std::shared_ptr<const SourcePortInfo> cmpInfo) const = 0;
+
+    SourcePortType portType;
+};
+
+struct NetSourcePortInfo : public SourcePortInfo {
+    NetSourcePortInfo(SourcePortType portType, std::string address, uint16_t port, std::string mac, std::string serialNumber, uint32_t pid)
+        : SourcePortInfo(portType), address(address), port(port), mac(mac), serialNumber(serialNumber), pid(pid) {}
+
+    ~NetSourcePortInfo() noexcept override = default;
+
+    bool equal(std::shared_ptr<const SourcePortInfo> cmpInfo) const override {
+        if(cmpInfo->portType != portType) {
+            return false;
+        }
+        auto netCmpInfo = std::dynamic_pointer_cast<const NetSourcePortInfo>(cmpInfo);
+        return (address == netCmpInfo->address) && (port == netCmpInfo->port) && (mac == netCmpInfo->mac) && (serialNumber == netCmpInfo->serialNumber)
+               && (pid == netCmpInfo->pid);
+    }
+
+    std::string address;
+    uint16_t    port;
+    std::string mac;
+    std::string serialNumber;
+    uint32_t    pid;
+};
+
+struct ShmStreamPortInfo : public SourcePortInfo {  // shared memory stream port
+    ShmStreamPortInfo(SourcePortType portType, std::string shmName, int32_t blockSize, int32_t blockCount)
+        : SourcePortInfo(portType), shmName(shmName), blockSize(blockSize), blockCount(blockCount) {}
+    ~ShmStreamPortInfo() noexcept override = default;
+    virtual bool equal(std::shared_ptr<const SourcePortInfo> cmpInfo) const override {
+        if(cmpInfo->portType != portType) {
+            return false;
+        }
+        auto netCmpInfo = std::dynamic_pointer_cast<const ShmStreamPortInfo>(cmpInfo);
+        return (shmName == netCmpInfo->shmName) && (blockSize == netCmpInfo->blockSize) && (blockCount == netCmpInfo->blockCount);
+    };
+
+    std::string shmName;
+    int32_t     blockSize;
+    int32_t     blockCount;
+};
+
+struct USBSourcePortInfo : public SourcePortInfo {
+    USBSourcePortInfo(): SourcePortInfo(SOURCE_PORT_USB_VENDOR) {};
+    explicit USBSourcePortInfo(SourcePortType type) : SourcePortInfo(type) {}
+    ~USBSourcePortInfo() noexcept override = default;
+
+    bool equal(std::shared_ptr<const SourcePortInfo> cmpInfo) const override {
+        if(cmpInfo->portType != portType) {
+            return false;
+        }
+        auto netCmpInfo = std::dynamic_pointer_cast<const USBSourcePortInfo>(cmpInfo);
+        return (url == netCmpInfo->url) && (vid == netCmpInfo->vid) && (pid == netCmpInfo->pid) && (infUrl == netCmpInfo->infUrl)
+               && (infIndex == netCmpInfo->infIndex) && (infName == netCmpInfo->infName) && (hubId == netCmpInfo->hubId);
+    };
+
+    std::string url;  // usb device url
+    std::string uid;
+    uint16_t    vid = 0;  // usb device vid
+    uint16_t    pid = 0;  // usb device pid
+    std::string serial;   // usb device serial number
+    std::string connSpec;
+
+    std::string infUrl;        // interface url(interface uid)
+    uint8_t     infIndex = 0;  // interface index
+    std::string infName;       // interface name
+    std::string hubId;         // hub id
+};
+
+typedef std::vector<std::shared_ptr<const SourcePortInfo>> SourcePortInfoList;
+
+class ISourcePort {
+public:
+    virtual ~ISourcePort() noexcept = default;
+
+    virtual std::shared_ptr<const SourcePortInfo> getSourcePortInfo() const = 0;
+};
+
+// for vendor command
+class IVendorDataPort : virtual public ISourcePort {  // Virtual inheritance solves diamond inheritance problem
+public:
+    ~IVendorDataPort() noexcept override = default;
+
+    virtual uint32_t sendAndReceive(const uint8_t *sendData, uint32_t sendLen, uint8_t *recvData, uint32_t exceptedRecvLen) = 0;
+};
+
+// for imu data stream
+class IDataStreamPort : virtual public ISourcePort {  // Virtual inheritance solves diamond inheritance problem
+public:
+    ~IDataStreamPort() noexcept override = default;
+
+    virtual void startStream(MutableFrameCallback callback) = 0;
+    virtual void stopStream()                               = 0;
+};
+
+// for video data stream: depth, color, ir, etc.
+class IVideoStreamPort : virtual public ISourcePort {  // Virtual inheritance solves diamond inheritance problem
+public:
+    ~IVideoStreamPort() noexcept override = default;
+
+    virtual StreamProfileList getStreamProfileList()                                                                   = 0;
+    virtual void              startStream(std::shared_ptr<const StreamProfile> profile, MutableFrameCallback callback) = 0;
+    virtual void              stopStream(std::shared_ptr<const StreamProfile> profile)                                 = 0;
+    virtual void              stopAllStream()                                                                          = 0;
+};
+}  // namespace libobsensor
+
diff --git a/src/platform/Platform.cpp b/src/platform/Platform.cpp
new file mode 100644
index 00000000..a8920afa
--- /dev/null
+++ b/src/platform/Platform.cpp
@@ -0,0 +1,118 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "Platform.hpp"
+#include "exception/ObException.hpp"
+
+namespace libobsensor {
+
+std::mutex              Platform::instanceMutex_;
+std::weak_ptr<Platform> Platform::instanceWeakPtr_;
+
+std::shared_ptr<Platform> Platform::getInstance() {
+    std::lock_guard<std::mutex> lock(instanceMutex_);
+    auto                        instance = instanceWeakPtr_.lock();
+    if(!instance) {
+        instance         = std::shared_ptr<Platform>(new Platform());
+        instanceWeakPtr_ = instance;
+    }
+    return instance;
+}
+
+Platform::Platform() {
+#if defined(BUILD_USB_PAL)
+    auto usbPal = createUsbPal();
+    palMap_.insert(std::make_pair("usb", usbPal));
+#endif
+
+#if defined(BUILD_NET_PAL)
+    auto netPal = createNetPal();
+    palMap_.insert(std::make_pair("net", netPal));
+#endif
+}
+
+std::shared_ptr<ISourcePort> Platform::getSourcePort(std::shared_ptr<const SourcePortInfo> portInfo) {
+    if(IS_USB_PORT(portInfo->portType)) {
+        return getUsbSourcePort(portInfo);
+    }
+    else if(IS_NET_PORT(portInfo->portType)) {
+        return getNetSourcePort(portInfo);
+    }
+    else {
+        throw pal_exception("Invalid port type!");
+    }
+}
+
+std::shared_ptr<IDeviceWatcher> Platform::createUsbDeviceWatcher() const {
+    auto pal = palMap_.find("usb");
+    if(pal == palMap_.end()) {
+        throw pal_exception("Usb pal is not exist, please check the build config that you have enabled BUILD_USB_PAL");
+    }
+    return pal->second->createDeviceWatcher();
+}
+
+SourcePortInfoList Platform::queryUsbSourcePortInfos() {
+    auto pal = palMap_.find("usb");
+    if(pal == palMap_.end()) {
+        throw pal_exception("Usb pal is not exist, please check the build config that you have enabled BUILD_USB_PAL");
+    }
+    return pal->second->querySourcePortInfos();
+}
+
+std::shared_ptr<ISourcePort> Platform::getUsbSourcePort(std::shared_ptr<const SourcePortInfo> portInfo) {
+    auto pal = palMap_.find("usb");
+    if(pal == palMap_.end()) {
+        throw pal_exception("Usb pal is not exist, please check the build config that you have enabled BUILD_USB_PAL");
+    }
+    return pal->second->getSourcePort(portInfo);
+}
+
+SourcePortInfoList Platform::queryNetSourcePort() {
+    auto pal = palMap_.find("net");
+    if(pal == palMap_.end()) {
+        throw pal_exception("Net pal is not exist, please check the build config that you have enabled BUILD_NET_PAL");
+    }
+    return pal->second->querySourcePortInfos();
+}
+
+std::shared_ptr<IDeviceWatcher> Platform::createNetDeviceWatcher() {
+    auto pal = palMap_.find("net");
+    if(pal == palMap_.end()) {
+        throw pal_exception("Net pal is not exist, please check the build config that you have enabled BUILD_NET_PAL");
+    }
+    return pal->second->createDeviceWatcher();
+}
+
+std::shared_ptr<ISourcePort> Platform::getNetSourcePort(std::shared_ptr<const SourcePortInfo> portInfo) {
+    auto pal = palMap_.find("net");
+    if(pal == palMap_.end()) {
+        throw pal_exception("Net pal is not exist, please check the build config that you have enabled BUILD_NET_PAL");
+    }
+    return pal->second->getSourcePort(portInfo);
+}
+
+SourcePortInfoList Platform::queryGmslSourcePort() {
+    auto pal = palMap_.find("gmsl");
+    if(pal == palMap_.end()) {
+        throw pal_exception("Gmsl pal is not exist, please check the build config that you have enabled BUILD_GMSL_PAL");
+    }
+    return pal->second->querySourcePortInfos();
+}
+
+std::shared_ptr<ISourcePort> Platform::getGmslSourcePort(std::shared_ptr<const SourcePortInfo> portInfo) {
+    auto pal = palMap_.find("gmsl");
+    if(pal == palMap_.end()) {
+        throw pal_exception("Gmsl pal is not exist, please check the build config that you have enabled BUILD_GMSL_PAL");
+    }
+    return pal->second->getSourcePort(portInfo);
+}
+
+std::shared_ptr<IDeviceWatcher> Platform::createGmslDeviceWatcher() {
+    auto pal = palMap_.find("gmsl");
+    if(pal == palMap_.end()) {
+        throw pal_exception("Gmsl pal is not exist, please check the build config that you have enabled BUILD_GMSL_PAL");
+    }
+    return pal->second->createDeviceWatcher();
+}
+
+}  // namespace libobsensor
diff --git a/src/platform/Platform.hpp b/src/platform/Platform.hpp
new file mode 100644
index 00000000..f5e70cf9
--- /dev/null
+++ b/src/platform/Platform.hpp
@@ -0,0 +1,47 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include "ISourcePort.hpp"
+#include "IDeviceWatcher.hpp"
+#include "IPal.hpp"
+
+#include <mutex>
+#include <map>
+#include <memory>
+
+namespace libobsensor {
+
+class Platform {
+private:
+    Platform();
+
+    static std::mutex              instanceMutex_;
+    static std::weak_ptr<Platform> instanceWeakPtr_;
+
+public:
+    static std::shared_ptr<Platform> getInstance();
+
+    ~Platform() noexcept = default;
+
+    std::shared_ptr<ISourcePort> getSourcePort(std::shared_ptr<const SourcePortInfo> portInfo);
+
+    SourcePortInfoList              queryUsbSourcePortInfos();
+    std::shared_ptr<ISourcePort>    getUsbSourcePort(std::shared_ptr<const SourcePortInfo> portInfo);
+    std::shared_ptr<IDeviceWatcher> createUsbDeviceWatcher() const;
+
+    SourcePortInfoList              queryNetSourcePort();
+    std::shared_ptr<ISourcePort>    getNetSourcePort(std::shared_ptr<const SourcePortInfo> portInfo);
+    std::shared_ptr<IDeviceWatcher> createNetDeviceWatcher();
+
+    SourcePortInfoList              queryGmslSourcePort();
+    std::shared_ptr<ISourcePort>    getGmslSourcePort(std::shared_ptr<const SourcePortInfo> portInfo);
+    std::shared_ptr<IDeviceWatcher> createGmslDeviceWatcher();
+
+private:
+    std::map<std::string, std::shared_ptr<IPal>> palMap_;
+};
+
+}  // namespace libobsensor
+
diff --git a/src/platform/ethernet/CMakeLists.txt b/src/platform/ethernet/CMakeLists.txt
new file mode 100644
index 00000000..15758931
--- /dev/null
+++ b/src/platform/ethernet/CMakeLists.txt
@@ -0,0 +1,16 @@
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+cmake_minimum_required(VERSION 3.5)
+
+file(GLOB_RECURSE _cpp_files "${CMAKE_CURRENT_LIST_DIR}/*.cpp")
+file(GLOB_RECURSE _head_files "${CMAKE_CURRENT_LIST_DIR}/*.hpp")
+
+foreach(_file IN ITEMS ${_cpp_files})
+    target_sources(${OB_TARGET_PAL} PRIVATE "${_file}")
+endforeach()
+
+foreach(_file IN ITEMS ${_head_files})
+    target_sources(${OB_TARGET_PAL} PRIVATE "${_file}")
+endforeach()
+
diff --git a/src/platform/ethernet/EthernetPal.cpp b/src/platform/ethernet/EthernetPal.cpp
new file mode 100644
index 00000000..763a6a83
--- /dev/null
+++ b/src/platform/ethernet/EthernetPal.cpp
@@ -0,0 +1,137 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "EthernetPal.hpp"
+#include "exception/ObException.hpp"
+#include "utils/Utils.hpp"
+
+namespace libobsensor {
+
+const uint16_t DEFAULT_CMD_PORT                     = 8090;
+const uint16_t DEVICE_WATCHER_POLLING_INTERVAL_MSEC = 5000;
+
+NetDeviceWatcher::~NetDeviceWatcher() noexcept {
+    if(!stopWatch_) {
+        stop();
+    }
+}
+
+void NetDeviceWatcher::start(deviceChangedCallback callback) {
+    callback_          = callback;
+    stopWatch_         = false;
+    deviceWatchThread_ = std::thread([&]() {
+        std::mutex                   mutex;
+        std::unique_lock<std::mutex> lock(mutex);
+        while(!stopWatch_) {
+            auto list    = GVCPClient::instance().queryNetDeviceList();
+            auto added   = utils::subtract_sets(list, netDevInfoList_);
+            auto removed = utils::subtract_sets(netDevInfoList_, list);
+            for(auto &&info: removed) {
+                callback_(OB_DEVICE_REMOVED, info.mac);
+            }
+            for(auto &&info: added) {
+                callback_(OB_DEVICE_ARRIVAL, info.mac);
+            }
+
+            netDevInfoList_ = list;
+            condVar_.wait_for(lock, std::chrono::milliseconds(DEVICE_WATCHER_POLLING_INTERVAL_MSEC), [&]() { return stopWatch_; });
+        }
+    });
+}
+
+void NetDeviceWatcher::stop() {
+    stopWatch_ = true;
+    condVar_.notify_all();
+    if(deviceWatchThread_.joinable()) {
+        deviceWatchThread_.join();
+    }
+}
+
+std::shared_ptr<ISourcePort> EthernetPal::getSourcePort(std::shared_ptr<const SourcePortInfo> portInfo) {
+    std::unique_lock<std::mutex> lock(sourcePortMapMutex_);
+    std::shared_ptr<ISourcePort> port;
+    // clear expired weak_ptr
+    for(auto it = sourcePortMap_.begin(); it != sourcePortMap_.end();) {
+        if(it->second.expired()) {
+            it = sourcePortMap_.erase(it);
+        }
+        else {
+            ++it;
+        }
+    }
+
+    // check if the port already exists in the map
+    for(const auto &pair: sourcePortMap_) {
+        if(pair.first == portInfo) {
+            port = pair.second.lock();
+            if(port != nullptr) {
+                return port;
+            }
+        }
+    }
+
+    const auto &portType = portInfo->portType;
+    switch(portType) {
+    case SOURCE_PORT_NET_VENDOR:
+        port = std::make_shared<VendorNetDataPort>(std::dynamic_pointer_cast<const NetSourcePortInfo>(portInfo));
+        break;
+    case SOURCE_PORT_NET_VENDOR_STREAM:
+        port = std::make_shared<NetDataStreamPort>(std::dynamic_pointer_cast<const NetDataStreamPortInfo>(portInfo));
+        break;
+    case SOURCE_PORT_NET_RTSP:
+        port = std::make_shared<RTSPStreamPort>(std::dynamic_pointer_cast<const RTSPStreamPortInfo>(portInfo));
+        break;
+    default:
+        throw invalid_value_exception("Invalid port type!");
+    }
+    sourcePortMap_.insert(std::make_pair(portInfo, port));
+    return port;
+}
+
+SourcePortInfoList EthernetPal::querySourcePortInfos() {
+    auto infos = GVCPClient::instance().queryNetDeviceList();
+
+    auto added         = utils::subtract_sets(infos, netDeviceInfoList_);
+    auto removed       = utils::subtract_sets(netDeviceInfoList_, infos);
+    netDeviceInfoList_ = infos;
+
+    // Only re-query port information for newly online devices
+    for(auto &&info: added) {
+        sourcePortInfoList_.push_back(std::make_shared<NetSourcePortInfo>(SOURCE_PORT_NET_VENDOR, info.ip, DEFAULT_CMD_PORT, info.mac, info.sn, info.pid));
+    }
+
+    // Delete devices that have been offline from the list
+    for(auto &&info: removed) {
+        auto iter = sourcePortInfoList_.begin();
+        while(iter != sourcePortInfoList_.end()) {
+            auto item = std::dynamic_pointer_cast<const NetSourcePortInfo>(*iter);
+            if(item->address == info.ip && item->mac == info.mac && item->serialNumber == info.sn) {
+                iter = sourcePortInfoList_.erase(iter);
+            }
+            else {
+                ++iter;
+            }
+        }
+    }
+    return sourcePortInfoList_;
+}
+
+std::shared_ptr<IDeviceWatcher> EthernetPal::createDeviceWatcher() const {
+    return std::make_shared<NetDeviceWatcher>();
+}
+
+std::shared_ptr<IPal> createNetPal() {
+    return std::make_shared<EthernetPal>();
+}
+
+bool EthernetPal::changeNetDeviceIpConfig(std::string ipAddress, const OBNetIpConfig &config) {
+    utils::unusedVar(ipAddress);
+    utils::unusedVar(config);
+#ifdef _WIN32
+    return GVCPClient::instance().changeNetDeviceIpConfig(ipAddress, config);
+#else
+    return false;
+#endif
+}
+}  // namespace libobsensor
+
diff --git a/src/platform/ethernet/EthernetPal.hpp b/src/platform/ethernet/EthernetPal.hpp
new file mode 100644
index 00000000..6c010331
--- /dev/null
+++ b/src/platform/ethernet/EthernetPal.hpp
@@ -0,0 +1,55 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include "IPal.hpp"
+#include "IDeviceWatcher.hpp"
+#include "ISourcePort.hpp"
+#include "VendorNetDataPort.hpp"
+#include "RTSPStreamPort.hpp"
+#include "NetDataStreamPort.hpp"
+#include "gige/GVCPClient.hpp"
+
+#include <vector>
+#include <map>
+
+namespace libobsensor {
+
+typedef std::vector<std::shared_ptr<NetSourcePortInfo>> NetSourcePortList;
+
+class NetDeviceWatcher : public IDeviceWatcher {
+public:
+    virtual ~NetDeviceWatcher() noexcept;
+    virtual void start(deviceChangedCallback callback) override;
+    virtual void stop() override;
+
+private:
+    deviceChangedCallback       callback_;
+    std::thread                 deviceWatchThread_;
+    bool                        stopWatch_ = false;
+    std::vector<GVCPDeviceInfo> netDevInfoList_;
+    std::condition_variable     condVar_;
+};
+
+class EthernetPal : public IPal {
+public:
+    EthernetPal() {}
+    ~EthernetPal() = default;
+
+    std::shared_ptr<ISourcePort>    getSourcePort(std::shared_ptr<const SourcePortInfo>) override;
+    SourcePortInfoList              querySourcePortInfos() override;
+    std::shared_ptr<IDeviceWatcher> createDeviceWatcher() const override;
+
+    static bool changeNetDeviceIpConfig(std::string ip, const OBNetIpConfig &config);
+
+private:
+    std::vector<GVCPDeviceInfo> netDeviceInfoList_;
+    SourcePortInfoList          sourcePortInfoList_;
+
+    std::mutex                                                                  sourcePortMapMutex_;
+    std::map<std::shared_ptr<const SourcePortInfo>, std::weak_ptr<ISourcePort>> sourcePortMap_;
+};
+
+}  // namespace libobsensor
+
diff --git a/src/platform/ethernet/NetDataStreamPort.cpp b/src/platform/ethernet/NetDataStreamPort.cpp
new file mode 100644
index 00000000..51caa5e0
--- /dev/null
+++ b/src/platform/ethernet/NetDataStreamPort.cpp
@@ -0,0 +1,88 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "NetDataStreamPort.hpp"
+#include "logger/Logger.hpp"
+#include "exception/ObException.hpp"
+#include "frame/FrameFactory.hpp"
+#include "utils/Utils.hpp"
+
+namespace libobsensor {
+
+NetDataStreamPort::NetDataStreamPort(std::shared_ptr<const NetDataStreamPortInfo> portInfo) : portInfo_(portInfo), isStreaming_(false) {}
+
+NetDataStreamPort::~NetDataStreamPort() noexcept{
+    isStreaming_ = false;
+    if(readDataThread_.joinable()) {
+        readDataThread_.join();
+    }
+
+    if(tcpClient_) {
+        tcpClient_.reset();
+    }
+}
+
+void NetDataStreamPort::startStream(MutableFrameCallback callback) {
+    if(isStreaming_) {
+        throw wrong_api_call_sequence_exception("NetDataStreamPort::startStream() called when streaming");
+    }
+    callback_        = callback;
+    auto netPortInfo = std::const_pointer_cast<NetDataStreamPortInfo>(portInfo_);
+    tcpClient_       = std::make_shared<VendorTCPClient>(netPortInfo->address, netPortInfo->port);
+
+    isStreaming_    = true;
+    readDataThread_ = std::thread(&NetDataStreamPort::readData, this);
+}
+
+void NetDataStreamPort::stopStream() {
+    if(!isStreaming_) {
+        throw wrong_api_call_sequence_exception("NetDataStreamPort::stopStream() called when not streaming");
+    }
+
+    isStreaming_ = false;
+    if(readDataThread_.joinable()) {
+        readDataThread_.join();
+    }
+
+    if(tcpClient_) {
+        tcpClient_.reset();
+    }
+}
+
+void NetDataStreamPort::readData() {
+    const int              PACK_SIZE     = 248;
+    int                    dataRecvdSize = 0;
+    int                    readSize      = 0;
+    std::shared_ptr<Frame> frame;
+    uint8_t               *data = nullptr;
+    while(isStreaming_) {
+        if(!frame) {
+            frame         = FrameFactory::createFrame(OB_FRAME_UNKNOWN, OB_FORMAT_UNKNOWN, PACK_SIZE);
+            data          = frame->getDataMutable();
+            dataRecvdSize = 0;
+        }
+
+        BEGIN_TRY_EXECUTE({ readSize = tcpClient_->read(data + dataRecvdSize, PACK_SIZE - dataRecvdSize); })
+        CATCH_EXCEPTION_AND_EXECUTE({
+            LOG_WARN("read data failed!");
+            readSize = -1;
+        })
+
+        if(readSize < 0) {
+            dataRecvdSize = 0;
+        }
+        else {
+            dataRecvdSize += readSize;
+        }
+
+        if(PACK_SIZE == dataRecvdSize && isStreaming_) {
+            auto realtime = utils::getNowTimesUs();
+            frame->setSystemTimeStampUsec(realtime);
+            callback_(frame);
+            frame.reset();
+        }
+    }
+}
+
+}  // namespace libobsensor
+
diff --git a/src/platform/ethernet/NetDataStreamPort.hpp b/src/platform/ethernet/NetDataStreamPort.hpp
new file mode 100644
index 00000000..c70ad864
--- /dev/null
+++ b/src/platform/ethernet/NetDataStreamPort.hpp
@@ -0,0 +1,53 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include "ISourcePort.hpp"
+#include "ethernet/socket/VendorTCPClient.hpp"
+#include <set>
+#include <thread>
+#include <mutex>
+
+namespace libobsensor {
+
+struct NetDataStreamPortInfo : public NetSourcePortInfo {
+    NetDataStreamPortInfo(std::string address, uint16_t port, uint16_t vendorPort, std::string mac = "unknown", std::string serialNumber = "unknown",
+                          uint32_t pid = 0)
+        : NetSourcePortInfo(SOURCE_PORT_NET_VENDOR_STREAM, address, port, mac, serialNumber, pid), vendorPort(vendorPort) {}
+
+    virtual bool equal(std::shared_ptr<const SourcePortInfo> cmpInfo) const {
+        if(cmpInfo->portType != portType) {
+            return false;
+        }
+        auto netCmpInfo = std::dynamic_pointer_cast<const NetDataStreamPortInfo>(cmpInfo);
+        return (address == netCmpInfo->address) && (port == netCmpInfo->port) && (vendorPort == netCmpInfo->vendorPort);
+    };
+
+    uint16_t vendorPort;
+};
+
+class NetDataStreamPort : public IDataStreamPort {
+public:
+    NetDataStreamPort(std::shared_ptr<const NetDataStreamPortInfo> portInfo);
+    virtual ~NetDataStreamPort() noexcept;
+    std::shared_ptr<const SourcePortInfo> getSourcePortInfo() const override {
+        return portInfo_;
+    }
+
+    void startStream(MutableFrameCallback callback) override;
+    void stopStream() override;
+
+public:
+    void readData();
+
+private:
+    std::shared_ptr<const NetDataStreamPortInfo> portInfo_;
+    bool                                         isStreaming_;
+
+    std::shared_ptr<VendorTCPClient> tcpClient_;
+    std::thread                      readDataThread_;
+
+    MutableFrameCallback callback_;
+};
+
+}  // namespace libobsensor
diff --git a/src/platform/ethernet/NetPortGroup.cpp b/src/platform/ethernet/NetPortGroup.cpp
new file mode 100644
index 00000000..84225170
--- /dev/null
+++ b/src/platform/ethernet/NetPortGroup.cpp
@@ -0,0 +1,12 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "NetPortGroup.hpp"
+
+namespace libobsensor {
+bool GroupNetSourcePortByMac(const std::shared_ptr<const SourcePortInfo> &port0, const std::shared_ptr<const SourcePortInfo> &port1) {
+    auto netPort0 = std::dynamic_pointer_cast<const NetSourcePortInfo>(port0);
+    auto netPort1 = std::dynamic_pointer_cast<const NetSourcePortInfo>(port1);
+    return netPort0->mac == netPort1->mac;
+}
+}  // namespace libobsensor
diff --git a/src/platform/ethernet/NetPortGroup.hpp b/src/platform/ethernet/NetPortGroup.hpp
new file mode 100644
index 00000000..f62db8fb
--- /dev/null
+++ b/src/platform/ethernet/NetPortGroup.hpp
@@ -0,0 +1,30 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include "ISourcePort.hpp"
+
+#include <memory>
+#include <vector>
+#include <algorithm>
+
+namespace libobsensor {
+
+bool GroupNetSourcePortByMac(const std::shared_ptr<const SourcePortInfo> &port0, const std::shared_ptr<const SourcePortInfo> &port1);
+
+template <typename T>
+std::vector<std::shared_ptr<const SourcePortInfo>> FilterNetPortInfoByPid(const std::vector<T> &devInfos, const std::vector<uint16_t> &pids) {
+    std::vector<std::shared_ptr<const SourcePortInfo>> outDeviceInfos;
+    for(auto &item: devInfos) {
+        if(IS_NET_PORT(item->portType)) {
+            auto dev  = std::dynamic_pointer_cast<const NetSourcePortInfo>(item);
+            auto iter = std::find(pids.begin(), pids.end(), dev->pid);
+            if(iter == pids.end()) {
+                continue;
+            }
+            outDeviceInfos.push_back(item);
+        }
+    }
+    return outDeviceInfos;
+}
+}  // namespace libobsensor
diff --git a/src/platform/ethernet/RTSPStreamPort.cpp b/src/platform/ethernet/RTSPStreamPort.cpp
new file mode 100644
index 00000000..11f9650a
--- /dev/null
+++ b/src/platform/ethernet/RTSPStreamPort.cpp
@@ -0,0 +1,133 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "RTSPStreamPort.hpp"
+#include "logger/Logger.hpp"
+#include "utils/Utils.hpp"
+#include "exception/ObException.hpp"
+#include "stream/StreamProfileFactory.hpp"
+
+#include <map>
+namespace libobsensor {
+std::string mapFormatToString(OBFormat format) {
+    static std::map<OBFormat, std::string> formatToStringMap = {
+        { OB_FORMAT_YUYV, "yuyv" }, { OB_FORMAT_YUY2, "yuyv" }, { OB_FORMAT_UYVY, "uyvy" }, { OB_FORMAT_NV12, "nv12" }, { OB_FORMAT_NV21, "nv21" },
+        { OB_FORMAT_MJPG, "mjpg" }, { OB_FORMAT_H264, "h264" }, { OB_FORMAT_H265, "h265" }, { OB_FORMAT_Y16, "y16" },   { OB_FORMAT_Y8, "y8" },
+        { OB_FORMAT_Y10, "y10" },   { OB_FORMAT_Y11, "y11" },   { OB_FORMAT_Y12, "y12" },   { OB_FORMAT_GRAY, "y8" },   { OB_FORMAT_HEVC, "h265" },
+        { OB_FORMAT_I420, "i420" }, { OB_FORMAT_RLE, "rle" },   { OB_FORMAT_RGB, "rgb" },   { OB_FORMAT_BGR, "bgr" },   { OB_FORMAT_Y14, "y14" },
+        { OB_FORMAT_BGRA, "bgra" }, { OB_FORMAT_RGBA, "rgba" }, { OB_FORMAT_RVL, "rvl" },   { OB_FORMAT_BYR2, "byr2" }, { OB_FORMAT_RW16, "rw16" },
+    };
+    return formatToStringMap[format];
+}
+
+std::string mapStreamTypeToString(OBStreamType streamType) {
+    static std::map<OBStreamType, std::string> streamTypeToStringMap = {
+        { OB_STREAM_IR, "ir" },           { OB_STREAM_DEPTH, "depth" },       { OB_STREAM_COLOR, "color" },
+        { OB_STREAM_IR_LEFT, "ir_left" }, { OB_STREAM_IR_RIGHT, "ir_right" },
+    };
+    return streamTypeToStringMap[streamType];
+}
+
+RTSPStreamPort::RTSPStreamPort(std::shared_ptr<const RTSPStreamPortInfo> portInfo)
+    : portInfo_(portInfo), destroy_(0), streamStarted_(false), currentRtspClient_(nullptr) {
+    taskScheduler_ = BasicTaskScheduler::createNew();
+    live555Env_    = ObUsageEnvironment::createNew(*taskScheduler_);
+}
+
+RTSPStreamPort::~RTSPStreamPort() noexcept {
+
+    // 1. Turn off the flow and close the rtsp client
+    TRY_EXECUTE(stopAllStream());  // try stop all stream
+
+    // 2. Release the scheduler
+    delete taskScheduler_;
+    taskScheduler_ = NULL;
+
+    // 3. live555 env release
+    live555Env_->reclaim();
+    live555Env_ = NULL;
+}
+
+StreamProfileList RTSPStreamPort::getStreamProfileList() {
+    return {};  // retuen empty list since the stream profile will be fetched via vendor specific command on the device bussiness layer
+}
+
+void RTSPStreamPort::startStream(std::shared_ptr<const StreamProfile> profile, MutableFrameCallback callback) {
+    if(streamStarted_) {
+        LOG_WARN("Stream already started!");
+    }
+    else {
+        BEGIN_TRY_EXECUTE({
+            createClient(profile, callback);
+            currentRtspClient_->startStream();
+        })
+        CATCH_EXCEPTION_AND_EXECUTE({
+            closeClient();
+            throw;
+        })
+        streamStarted_ = true;
+        LOG_DEBUG("Stream started!");
+    }
+}
+void RTSPStreamPort::stopStream(std::shared_ptr<const StreamProfile> profile) {
+    utils::unusedVar(profile);
+    stopStream();
+}
+
+void RTSPStreamPort::stopAllStream() {
+    // Currently RTSPStreamPort only supports one data stream
+    stopStream();
+}
+
+void RTSPStreamPort::stopStream() {
+    if(streamStarted_) {
+        BEGIN_TRY_EXECUTE({ currentRtspClient_->stopStream(); })
+        CATCH_EXCEPTION_AND_EXECUTE({
+            closeClient();
+            streamStarted_ = false;
+            throw;
+        })
+        closeClient();
+        streamStarted_ = false;
+        LOG_DEBUG("Stream stoped!");
+    }
+    else {
+        LOG_WARN("Stream have not been started!");
+    }
+}
+
+void RTSPStreamPort::createClient(std::shared_ptr<const StreamProfile> profile, MutableFrameCallback callback) {
+    destroy_              = 0;
+    eventLoopThread_      = std::thread([&]() { live555Env_->taskScheduler().doEventLoop(&destroy_); });
+    currentStreamProfile_ = profile;
+    auto vsp              = currentStreamProfile_->as<VideoStreamProfile>();
+
+    std::string formatStr = std::to_string(vsp->getWidth()) + "_" + std::to_string(vsp->getHeight()) + "_" + std::to_string(vsp->getFps()) + "_"
+                            + mapFormatToString(vsp->getFormat());
+    std::string url =
+        std::string("rtsp://") + portInfo_->address + ":" + std::to_string(portInfo_->port) + "/" + mapStreamTypeToString(vsp->getType()) + "/" + formatStr;
+    currentRtspClient_ = ObRTSPClient::createNew(profile, *live555Env_, url.c_str(), callback, 1);
+    LOG_DEBUG("ObRTSPClient created! url={}", url);
+}
+
+void RTSPStreamPort::closeClient() {
+    destroy_ = 1;
+    if(eventLoopThread_.joinable()) {
+        eventLoopThread_.join();
+    }
+    std::string url = "";
+    if(currentRtspClient_) {
+        url = currentRtspClient_->url();
+        // The transaction thread needs to be closed before the client is closed, otherwise it will crash occasionally.
+        Medium::close(currentRtspClient_);
+        currentRtspClient_ = nullptr;
+    }
+    LOG_DEBUG("ObRTSPClient close!  url={}", url);
+}
+
+std::shared_ptr<const SourcePortInfo> RTSPStreamPort::getSourcePortInfo() const {
+    return portInfo_;
+}
+
+}  // namespace libobsensor
+
diff --git a/src/platform/ethernet/RTSPStreamPort.hpp b/src/platform/ethernet/RTSPStreamPort.hpp
new file mode 100644
index 00000000..9677786e
--- /dev/null
+++ b/src/platform/ethernet/RTSPStreamPort.hpp
@@ -0,0 +1,63 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include "ISourcePort.hpp"
+#include "ethernet/rtsp/ObRTSPClient.hpp"
+#include "ethernet/rtsp/ObRTPSink.hpp"
+#include "ethernet/rtsp/ObUsageEnvironment.hpp"
+#include "ethernet/VendorNetDataPort.hpp"
+
+#include <string>
+#include <memory>
+#include <thread>
+
+namespace libobsensor {
+struct RTSPStreamPortInfo : public NetSourcePortInfo {
+    RTSPStreamPortInfo(std::string address, uint16_t port, uint16_t vendorPort, OBStreamType streamType, std::string mac = "unknown",
+                       std::string serialNumber = "unknown", uint32_t pid = 0)
+        : NetSourcePortInfo(SOURCE_PORT_NET_RTSP, address, port, mac, serialNumber, pid), vendorPort(vendorPort), streamType(streamType) {}
+
+    virtual bool equal(std::shared_ptr<const SourcePortInfo> cmpInfo) const override {
+        if(cmpInfo->portType != portType) {
+            return false;
+        }
+        auto netCmpInfo = std::dynamic_pointer_cast<const RTSPStreamPortInfo>(cmpInfo);
+        return (address == netCmpInfo->address) && (port == netCmpInfo->port) && (vendorPort == netCmpInfo->vendorPort)
+               && (streamType == netCmpInfo->streamType);
+    };
+
+    uint16_t     vendorPort;
+    OBStreamType streamType;
+};
+
+class RTSPStreamPort : public IVideoStreamPort {
+public:
+    RTSPStreamPort(std::shared_ptr<const RTSPStreamPortInfo> portInfo);
+    virtual ~RTSPStreamPort() noexcept;
+
+    virtual StreamProfileList                     getStreamProfileList() override;
+    virtual void                                  startStream(std::shared_ptr<const StreamProfile> profile, MutableFrameCallback callback) override;
+    virtual void                                  stopStream(std::shared_ptr<const StreamProfile> profile) override;
+    virtual void                                  stopAllStream() override;
+    virtual std::shared_ptr<const SourcePortInfo> getSourcePortInfo() const override;
+
+private:
+    void stopStream();
+    void createClient(std::shared_ptr<const StreamProfile> profile, MutableFrameCallback callback);
+    void closeClient();
+
+private:
+    std::shared_ptr<const RTSPStreamPortInfo> portInfo_;
+    TaskScheduler                            *taskScheduler_;
+    UsageEnvironment                         *live555Env_;
+    std::thread                               eventLoopThread_;
+    char                                      destroy_;
+    bool                                      streamStarted_;
+
+    ObRTSPClient                        *currentRtspClient_;
+    std::shared_ptr<const StreamProfile> currentStreamProfile_;
+    StreamProfileList                    streamProfileList_;
+};
+}  // namespace libobsensor
+
diff --git a/src/platform/ethernet/VendorNetDataPort.cpp b/src/platform/ethernet/VendorNetDataPort.cpp
new file mode 100644
index 00000000..187553ae
--- /dev/null
+++ b/src/platform/ethernet/VendorNetDataPort.cpp
@@ -0,0 +1,34 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "VendorNetDataPort.hpp"
+
+#include "utils/Utils.hpp"
+#include "logger/Logger.hpp"
+
+namespace libobsensor {
+#define OB_VENDOR_CMD_RECV_LEN 1024
+VendorNetDataPort::VendorNetDataPort(std::shared_ptr<const NetSourcePortInfo> portInfo) : portInfo_(portInfo) {
+    auto noConstPortInfo = std::const_pointer_cast<const NetSourcePortInfo>(portInfo);
+    tcpClient_           = std::make_shared<VendorTCPClient>(noConstPortInfo->address, noConstPortInfo->port);
+}
+
+VendorNetDataPort::~VendorNetDataPort() noexcept {}
+
+uint32_t VendorNetDataPort::sendAndReceive(const uint8_t *sendData, uint32_t sendLen, uint8_t *recvData, uint32_t exceptedRecvLen) {
+    utils::unusedVar(exceptedRecvLen);
+    tcpClient_->write(sendData, sendLen);
+    int recvd = tcpClient_->read(recvData, OB_VENDOR_CMD_RECV_LEN);
+    if(recvd < 0) {
+        LOG_ERROR("Failed to read data from tcp client, error_code: {}", recvd);
+        return 0;
+    }
+    return static_cast<uint32_t>(recvd);
+}
+
+std::shared_ptr<const SourcePortInfo> VendorNetDataPort::getSourcePortInfo() const {
+    return portInfo_;
+}
+
+}  // namespace libobsensor
+
diff --git a/src/platform/ethernet/VendorNetDataPort.hpp b/src/platform/ethernet/VendorNetDataPort.hpp
new file mode 100644
index 00000000..79b6fff0
--- /dev/null
+++ b/src/platform/ethernet/VendorNetDataPort.hpp
@@ -0,0 +1,24 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include "ISourcePort.hpp"
+#include "ethernet/socket/VendorTCPClient.hpp"
+
+namespace libobsensor {
+
+class VendorNetDataPort : public IVendorDataPort {
+public:
+    VendorNetDataPort(std::shared_ptr<const NetSourcePortInfo> portInfo);
+    virtual ~VendorNetDataPort() noexcept;
+
+    std::shared_ptr<const SourcePortInfo> getSourcePortInfo() const override;
+    uint32_t sendAndReceive(const uint8_t *sendData, uint32_t sendLen, uint8_t *recvData, uint32_t exceptedRecvLen) override;
+
+private:
+    std::shared_ptr<VendorTCPClient>         tcpClient_;
+    std::shared_ptr<const NetSourcePortInfo> portInfo_;
+};
+
+}  // namespace libobsensor
diff --git a/src/platform/ethernet/gige/GVCPClient.cpp b/src/platform/ethernet/gige/GVCPClient.cpp
new file mode 100644
index 00000000..44394448
--- /dev/null
+++ b/src/platform/ethernet/gige/GVCPClient.cpp
@@ -0,0 +1,552 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#if(defined(WIN32) || defined(_WIN32) || defined(WINCE))
+#define _WINSOCK_DEPRECATED_NO_WARNINGS disable
+#include <winsock2.h>
+#include <ws2tcpip.h>
+#include <iphlpapi.h>
+#pragma comment(lib, "Iphlpapi.lib")
+#else
+#include <netdb.h>
+#include <ifaddrs.h>
+#include <net/if.h>
+#include <sys/time.h>
+#endif
+
+#include <thread>
+#include <algorithm>
+
+#include "GVCPClient.hpp"
+#include "exception/ObException.hpp"
+
+#include "logger/LoggerInterval.hpp"
+#include "logger/LoggerHelper.hpp"
+#include "utils/StringUtils.hpp"
+
+namespace libobsensor {
+
+GVCPClient::GVCPClient() {
+#if(defined(WIN32) || defined(_WIN32) || defined(WINCE))
+    WSADATA wsaData;
+    if(WSAStartup(MAKEWORD(2, 2), &wsaData)) {
+        throw libobsensor::invalid_value_exception(utils::string::to_string() << "Failed to initialize WinSock! err_code=" << GET_LAST_ERROR());
+    }
+#endif
+    openClientSockets();
+}
+
+GVCPClient::~GVCPClient() {
+    std::lock_guard<std::mutex> lck(queryMtx_);
+#if(defined(WIN32) || defined(_WIN32) || defined(WINCE))
+    WSACleanup();
+#endif
+    closeClientSockets();
+}
+
+std::vector<GVCPDeviceInfo> GVCPClient::queryNetDeviceList() {
+    std::lock_guard<std::mutex> lck(queryMtx_);
+    devInfoList_.clear();
+
+    checkAndUpdateSockets();
+    std::vector<std::thread> threads;
+    for(int i = 0; i < sockCount_; ++i) {
+        auto func = std::bind(&GVCPClient::sendGVCPDiscovery, this, socks_[i]);
+        threads.emplace_back(func, socks_[i]);
+    }
+
+    for(auto &thread: threads) {
+        thread.join();
+    }
+
+    // devInfoList_ remove duplication
+    if(!devInfoList_.empty()) {
+        auto iter = devInfoList_.begin();
+        while(iter != devInfoList_.end()) {
+            auto it = std::find_if(iter + 1, devInfoList_.end(), [&](const GVCPDeviceInfo &other) { return *iter == other; });
+            if(it != devInfoList_.end()) {
+                devInfoList_.erase(it);
+                continue;
+            }
+            iter++;
+        }
+    }
+
+    LOG_TRACE("queryNetDevice completed ({}):", devInfoList_.size());
+    for(auto &&info: devInfoList_) {
+        // LOG_INFO("\t-mac:{}, ip:{}, sn:{}, pid:0x{:04x}", info.mac, info.ip, info.sn, info.pid);
+        LOG_INTVL(LOG_INTVL_OBJECT_TAG + "queryNetDevice", DEF_MIN_LOG_INTVL, spdlog::level::debug, "\t- mac:{}, ip:{}, sn:{}, pid:0x{:04x}", info.mac, info.ip,
+                  info.sn, info.pid);
+    }
+    return devInfoList_;
+}
+
+bool GVCPClient::changeNetDeviceIpConfig(std::string mac, const OBNetIpConfig &config) {
+    std::lock_guard<std::mutex> lck(queryMtx_);
+
+    std::vector<std::thread> threads;
+
+    for(int i = 0; i < sockCount_; ++i) {
+        auto func = std::bind(&GVCPClient::sendGVCPForceIP, this, socks_[i], mac, config);
+        threads.emplace_back(func, socks_[i]);
+    }
+
+    for(auto &thread: threads) {
+        thread.join();
+    }
+    LOG_INFO("change net device ip config completed. mac:{}", mac);
+    return true;
+}
+
+int GVCPClient::openClientSockets() {
+#if(defined(WIN32) || defined(_WIN32) || defined(WINCE))
+    DWORD                       rv, size;
+    PIP_ADAPTER_ADDRESSES       adapter_addresses, aa;
+    PIP_ADAPTER_UNICAST_ADDRESS ua;
+
+    rv = GetAdaptersAddresses(AF_INET, GAA_FLAG_INCLUDE_PREFIX, NULL, NULL, &size);
+    if(rv != ERROR_BUFFER_OVERFLOW) {
+        fprintf(stderr, "GetAdaptersAddresses() failed...");
+        return -1;
+    }
+    adapter_addresses = (PIP_ADAPTER_ADDRESSES)malloc(size);
+
+    rv = GetAdaptersAddresses(AF_INET, GAA_FLAG_INCLUDE_PREFIX, NULL, adapter_addresses, &size);
+    if(rv != ERROR_SUCCESS) {
+        fprintf(stderr, "GetAdaptersAddresses() failed...");
+        free(adapter_addresses);
+        return -1;
+    }
+
+    int index = 0;
+
+    for(aa = adapter_addresses; aa != NULL; aa = aa->Next) {
+        for(ua = aa->FirstUnicastAddress; ua != NULL; ua = ua->Next) {
+            SOCKADDR_IN addrSrv;
+            addrSrv            = *(SOCKADDR_IN *)ua->Address.lpSockaddr;
+            addrSrv.sin_family = AF_INET;
+            addrSrv.sin_port   = htons(0);
+            auto ipStr         = inet_ntoa(addrSrv.sin_addr);
+            if(strncmp(ipStr, "169.254", 7) == 0 || strcmp(ipStr, "127.0.0.1") == 0) {
+                continue;
+            }
+            socks_[index++] = openClientSocket(addrSrv);
+        }
+    }
+    sockCount_ = index;
+#else
+    struct ifaddrs *ifaddr, *ifa;
+    int             family, s, n;
+    char            host[NI_MAXHOST];
+
+    if(getifaddrs(&ifaddr) == -1) {
+        perror("getifaddrs");
+        exit(EXIT_FAILURE);
+    }
+
+    int index = 0;
+
+    for(ifa = ifaddr, n = 0; ifa != NULL; ifa = ifa->ifa_next, n++) {
+        if(ifa->ifa_addr == NULL)
+            continue;
+
+        family = ifa->ifa_addr->sa_family;
+
+        if(family == AF_INET) {
+            s = getnameinfo(ifa->ifa_addr, sizeof(struct sockaddr_in), host, NI_MAXHOST, NULL, 0, NI_NUMERICHOST);
+            if(s != 0) {
+                LOG_TRACE("getnameinfo() failed: {}", gai_strerror(s));
+                exit(EXIT_FAILURE);
+            }
+
+            SOCKADDR_IN addrSrv;
+            addrSrv            = *(SOCKADDR_IN *)ifa->ifa_addr;
+            addrSrv.sin_family = AF_INET;
+            addrSrv.sin_port   = htons(0);
+            auto ipStr         = inet_ntoa(addrSrv.sin_addr);
+            if(strcmp(ipStr, "127.0.0.1") == 0) {
+                continue;
+            }
+            ipAddressStrSet_.insert(ipStr);
+            socks_[index++] = openClientSocket(addrSrv);
+        }
+    }
+    sockCount_ = index;
+    freeifaddrs(ifaddr);
+#endif
+
+    return sockCount_;
+}
+
+void GVCPClient::closeClientSockets() {
+    for(int i = 0; i < sockCount_; i++) {
+        closesocket(socks_[i]);
+    }
+}
+
+SOCKET GVCPClient::openClientSocket(SOCKADDR_IN addr) {
+    // Create socket
+    SOCKET sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
+    if(sock == INVALID_SOCKET) {
+        throw libobsensor::invalid_value_exception(utils::string::to_string() << "Failed to create socket! err_code=" << GET_LAST_ERROR());
+    }
+
+    // Set broadcast options
+    int bBroadcast = 1;
+#if(defined(WIN32) || defined(_WIN32) || defined(WINCE))
+    int err = setsockopt(sock, SOL_SOCKET, SO_BROADCAST, (char *)&bBroadcast, sizeof(bBroadcast));
+#else
+    // int     err = setsockopt(sock, SOL_SOCKET, SO_BROADCAST | SO_REUSEADDR, (char *)&bBroadcast, sizeof(bBroadcast));
+    int err = setsockopt(sock, SOL_SOCKET, SO_BROADCAST, (char *)&bBroadcast, sizeof(bBroadcast));
+    if(err == SOCKET_ERROR) {
+        throw libobsensor::invalid_value_exception(utils::string::to_string() << "Failed to set socket boardcast option! err_code=" << GET_LAST_ERROR());
+    }
+    err = setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (char *)&bBroadcast, sizeof(bBroadcast));
+    if(err == SOCKET_ERROR) {
+        throw libobsensor::invalid_value_exception(utils::string::to_string() << "Failed to set socket reuseaddr option! err_code=" << GET_LAST_ERROR());
+    }
+#endif
+
+// Set receive timeout options
+#if(defined(WIN32) || defined(_WIN32) || defined(WINCE))
+    uint32_t dwTimeout = 5000;
+#else
+    TIMEVAL dwTimeout;
+    dwTimeout.tv_sec  = 5;
+    dwTimeout.tv_usec = 0;
+#endif
+    err = setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, (char *)&dwTimeout, sizeof(dwTimeout));
+    if(err == SOCKET_ERROR) {
+        throw libobsensor::invalid_value_exception(utils::string::to_string() << "Failed to set socket timeout option! err_code=" << GET_LAST_ERROR());
+    }
+
+#if(defined(__linux__) || defined(OS_IOS) || defined(OS_MACOS) || defined(__ANDROID__))
+    addr.sin_addr.s_addr = inet_addr("0.0.0.0");
+#endif
+    LOG_INTVL(LOG_INTVL_OBJECT_TAG + "GVCP bind", MAX_LOG_INTERVAL, spdlog::level::debug, "bind {}:{}", inet_ntoa(addr.sin_addr), ntohs(addr.sin_port));
+    err = bind(sock, (SOCKADDR *)&addr, sizeof(SOCKADDR));
+    if(err == SOCKET_ERROR) {
+        return 0;
+    }
+
+    return sock;
+}
+
+void GVCPClient::sendGVCPDiscovery(SOCKET sock) {
+    LOG_TRACE("send gvcp discovery {}", sock);
+    gvcp_discover_cmd discoverCmd;
+    gvcp_discover_ack discoverAck;
+
+    SOCKADDR_IN destAddr;
+    destAddr.sin_family      = AF_INET;
+    destAddr.sin_addr.s_addr = INADDR_BROADCAST;  // Broadcast address
+    destAddr.sin_port        = htons(GVCP_PORT);
+
+    // device discovery
+    gvcp_cmd_header cmdHeader;
+    cmdHeader.cMsgKeyCode = GVCP_VERSION;
+    cmdHeader.cFlag       = GVCP_DISCOVERY_FLAGS;
+    cmdHeader.wCmd        = htons(GVCP_DISCOVERY_CMD);
+    cmdHeader.wLen        = htons(0);
+    cmdHeader.wReqID      = htons(1);
+
+    discoverCmd.header = cmdHeader;
+
+    ////Get local ip
+    // struct sockaddr_in addr;
+    // socklen_t addrLen = sizeof(addr);
+
+    ////Get the address information of the socket
+    // if(getsockname(sock, (struct sockaddr *)&addr, &addrLen) == 0) {
+    // LOG_INFO("cur addr {}:{}", inet_ntoa(addr.sin_addr), ntohs(addr.sin_port));
+    // }
+
+    // send data
+    int err = sendto(sock, (const char *)&discoverCmd, sizeof(discoverCmd), 0, (SOCKADDR *)&destAddr, sizeof(destAddr));
+    if(err == SOCKET_ERROR) {
+        LOG_INTVL(LOG_INTVL_OBJECT_TAG + "GVCP sendto", MAX_LOG_INTERVAL, spdlog::level::debug, "sendto failed with error:{}", GET_LAST_ERROR());
+    }
+    // LOG_INFO("sendto get info with error:{}", GET_LAST_ERROR());
+    char recvBuf[1024];
+    memset(recvBuf, 0, sizeof(recvBuf));
+
+    int res;
+    int failedCount = 100;
+    do {
+        struct timeval timeout;
+        timeout.tv_sec  = 1;
+        timeout.tv_usec = 0;
+
+        int    nfds = 0;
+        fd_set readfs;
+        FD_ZERO(&readfs);
+        nfds = static_cast<int>(sock) + 1;
+        FD_SET(sock, &readfs);
+
+        res = select(nfds, &readfs, 0, 0, &timeout);
+        if(res > 0) {
+            if(FD_ISSET(sock, &readfs)) {
+                // Receive data
+                SOCKADDR_IN srcAddr;
+                socklen_t   srcAddrLen = sizeof(srcAddr);
+
+                err = recvfrom(sock, recvBuf, sizeof(recvBuf), 0, (SOCKADDR *)&srcAddr, &srcAddrLen);
+                if(err == SOCKET_ERROR) {
+                    LOG_INTVL(LOG_INTVL_OBJECT_TAG + "GVCP recvfrom", DEF_MIN_LOG_INTVL, spdlog::level::err, "recvfrom failed with error: {}",
+                              GET_LAST_ERROR());
+
+                    if(failedCount-- < 0) {
+                        LOG_WARN("GVCP recvfrom failed!!!");
+                        break;
+                    }
+                }
+
+                // Parse response data
+                gvcp_ack_header ackHeader = {};
+                memcpy(&ackHeader, recvBuf, sizeof(gvcp_ack_header));
+
+                uint16_t status = ntohs(ackHeader.wStatus);
+                uint16_t ack    = ntohs(ackHeader.wAck);
+                uint16_t len    = ntohs(ackHeader.wLen);
+                uint16_t reqID  = ntohs(ackHeader.wReqID);
+
+                LOG_INTVL(LOG_INTVL_OBJECT_TAG + "GVCP get info", DEF_MIN_LOG_INTVL, spdlog::level::info, "{}, {}, {}, {}", status, ack, len, reqID);
+
+                discoverAck.header = ackHeader;
+
+                if(status == GEV_STATUS_SUCCESS && ack == GVCP_DISCOVERY_ACK && reqID == GVCP_REQUEST_ID) {
+                    gvcp_ack_payload ackPayload = {};
+                    memcpy(&ackPayload, recvBuf + sizeof(gvcp_ack_header), sizeof(gvcp_ack_payload));
+
+                    auto specVer  = ntohl(ackPayload.dwSpecVer);
+                    auto devMode  = ntohl(ackPayload.dwDevMode);
+                    auto supIpSet = ntohl(ackPayload.dwSupIpSet);
+                    auto curIpSet = ntohl(ackPayload.dwCurIpSet);
+                    auto curPID   = ntohl(ackPayload.dwPID);
+
+                    // Get Mac address
+                    char macStr[18];
+                    sprintf(macStr, "%02X:%02X:%02X:%02X:%02X:%02X", ackPayload.Mac[2], ackPayload.Mac[3], ackPayload.Mac[4], ackPayload.Mac[5],
+                            ackPayload.Mac[6], ackPayload.Mac[7]);
+
+                    // Read CurIP field
+                    uint32_t curIP = *((uint32_t *)&ackPayload.CurIP[12]);
+                    char     curIPStr[INET_ADDRSTRLEN];
+                    inet_ntop(AF_INET, &curIP, curIPStr, INET_ADDRSTRLEN);
+
+                    // Read the SubMask field
+                    uint32_t subMask = *((uint32_t *)&ackPayload.SubMask[12]);
+                    char     subMaskStr[INET_ADDRSTRLEN];
+                    inet_ntop(AF_INET, &subMask, subMaskStr, INET_ADDRSTRLEN);
+
+                    // Read the Gateway field
+                    uint32_t gateway = *((uint32_t *)&ackPayload.Gateway[12]);
+                    char     gatewayStr[INET_ADDRSTRLEN];
+                    inet_ntop(AF_INET, &gateway, gatewayStr, INET_ADDRSTRLEN);
+
+                    // LOG_INFO("{},{}, {},{}, {},{}, {}, {}, {}, {}, {}, {}, {}, {}, {}", specVer, devMode, macStr, supIpSet, curIpSet, curPID, curIPStr,
+                    //          subMaskStr, gatewayStr, ackPayload.szFacName, ackPayload.szModelName, ackPayload.szDevVer, ackPayload.szFacInfo,
+                    //          ackPayload.szSerial, ackPayload.szUserName);
+
+                    LOG_INTVL(LOG_INTVL_OBJECT_TAG + "GVCP get ack info", DEF_MIN_LOG_INTVL, spdlog::level::info,
+                              "{},{}, {},{}, {},{}, {}, {}, {}, {}, {}, {}, {}, {}, {}", specVer, devMode, std::string(macStr), supIpSet, curIpSet, curPID,
+                              std::string(curIPStr), std::string(subMaskStr), std::string(gatewayStr), std::string(ackPayload.szFacName),
+                              std::string(ackPayload.szModelName), std::string(ackPayload.szDevVer), std::string(ackPayload.szFacInfo),
+                              std::string(ackPayload.szSerial), std::string(ackPayload.szUserName));
+
+                    discoverAck.payload = ackPayload;
+
+                    // Filter non-Orbbec devices
+                    if(strcmp(ackPayload.szFacName, "Orbbec") != 0)
+                        continue;
+
+                    GVCPDeviceInfo info;
+                    info.mac     = macStr;
+                    info.ip      = curIPStr;
+                    info.mask    = subMaskStr;
+                    info.gateway = gatewayStr;
+                    info.sn      = ackPayload.szSerial;
+                    info.name    = ackPayload.szModelName;
+                    info.pid     = curPID;
+                    // info.manufacturer = ackPayload.szFacName;
+                    // info.version      = ackPayload.szDevVer;
+
+                    std::lock_guard<std::mutex> lock(devInfoListMtx_);
+                    devInfoList_.push_back(info);
+                }
+            }
+            FD_SET(sock, &readfs);
+        }
+    } while(res > 0);
+    // LOG_INFO("finish gvcp discovery {}", sock);
+}
+
+void GVCPClient::sendGVCPForceIP(SOCKET sock, std::string mac, const OBNetIpConfig &config) {
+    gvcp_forceip_cmd forceIPCmd;
+    // gvcp_forceip_ack forceIPAck;
+
+    SOCKADDR_IN destAddr;
+    destAddr.sin_family      = AF_INET;
+    destAddr.sin_addr.s_addr = INADDR_BROADCAST;  // Broadcast address
+    destAddr.sin_port        = htons(GVCP_PORT);
+
+    gvcp_cmd_header cmdHeader = {};
+    cmdHeader.cMsgKeyCode     = GVCP_VERSION;
+    cmdHeader.cFlag           = GVCP_FORCEIP_FLAGS;
+    cmdHeader.wCmd            = htons(GVCP_FORCEIP_CMD);
+    cmdHeader.wLen            = htons(sizeof(gvcp_forceip_payload));
+    cmdHeader.wReqID          = htons(1);
+
+    forceIPCmd.header = cmdHeader;
+
+    gvcp_forceip_payload payload = {};
+    sscanf(mac.c_str(), "%hhx:%hhx:%hhx:%hhx:%hhx:%hhx", &payload.Mac[2], &payload.Mac[3], &payload.Mac[4], &payload.Mac[5], &payload.Mac[6], &payload.Mac[7]);
+    // memcpy(&payload.Mac[2], &discoverAck.payload.Mac[2], 6);
+
+    // The IP to be modified
+    // char m_szLocalIp[32];
+    // strcpy(m_szLocalIp, config.address);
+    // char m_szLocalMask[32];
+    // strcpy(m_szLocalMask, config.mask);
+    // char m_szLocalGateway[32];
+    // strcpy(m_szLocalGateway, config.gateway);
+
+    //*((uint32_t *)&payload.CurIP[12])   = inet_addr(m_szLocalIp);       //last 4 byte
+    //*((uint32_t *)&payload.SubMask[12]) = inet_addr(m_szLocalMask);     //last 4 byte
+    //*((uint32_t *)&payload.Gateway[12]) = inet_addr(m_szLocalGateway);  //last 4 byte
+
+    memcpy(payload.CurIP, config.address, 4);
+    memcpy(payload.SubMask, config.mask, 4);
+    memcpy(payload.Gateway, config.gateway, 4);
+
+    forceIPCmd.payload = payload;
+
+    // send data
+    int err = sendto(sock, (const char *)&forceIPCmd, sizeof(forceIPCmd), 0, (SOCKADDR *)&destAddr, sizeof(destAddr));
+    if(err == SOCKET_ERROR) {
+        LOG_TRACE("sendto failed with error: {}", GET_LAST_ERROR());
+    }
+}
+
+void GVCPClient::checkAndUpdateSockets() {
+#if(defined(WIN32) || defined(_WIN32) || defined(WINCE))
+    DWORD                       rv, size;
+    PIP_ADAPTER_ADDRESSES       adapter_addresses, aa;
+    PIP_ADAPTER_UNICAST_ADDRESS ua;
+
+    rv = GetAdaptersAddresses(AF_INET, GAA_FLAG_INCLUDE_PREFIX, NULL, NULL, &size);
+    if(rv != ERROR_BUFFER_OVERFLOW) {
+        LOG_ERROR("GetAdaptersAddresses() failed...");
+        return;
+    }
+    adapter_addresses = (PIP_ADAPTER_ADDRESSES)malloc(size);
+
+    rv = GetAdaptersAddresses(AF_INET, GAA_FLAG_INCLUDE_PREFIX, NULL, adapter_addresses, &size);
+    if(rv != ERROR_SUCCESS) {
+        LOG_ERROR("GetAdaptersAddresses() failed...");
+        free(adapter_addresses);
+        return;
+    }
+
+    int index = sockCount_;
+
+    for(aa = adapter_addresses; aa != NULL; aa = aa->Next) {
+        for(ua = aa->FirstUnicastAddress; ua != NULL; ua = ua->Next) {
+            SOCKADDR_IN addrSrv;
+            addrSrv            = *(SOCKADDR_IN *)ua->Address.lpSockaddr;
+            addrSrv.sin_family = AF_INET;
+            addrSrv.sin_port   = htons(0);
+            std::string ipStr  = inet_ntoa(addrSrv.sin_addr);
+
+            if(strncmp(ipStr.c_str(), "169.254", 7) == 0 || strcmp(ipStr.c_str(), "127.0.0.1") == 0) {
+                continue;
+            }
+
+            bool found = false;
+            for(auto sock: socks_) {
+                if(sock == 0) {
+                    continue;
+                }
+
+                SOCKADDR_IN addr;
+                socklen_t   addrLen = sizeof(addr);
+                if(getsockname(sock, (struct sockaddr *)&addr, &addrLen) == 0) {
+                    std::string sockIp = inet_ntoa(addr.sin_addr);
+                    if(ipStr == sockIp) {
+                        found = true;
+                        break;
+                    }
+                }
+                else {
+                    LOG_INFO("get socket ip addr failed,{}", ipStr);
+                }
+            }
+
+            if(!found) {
+                auto socketFd = openClientSocket(addrSrv);
+                if(socketFd != 0) {
+                    socks_[index++] = socketFd;
+                    LOG_INFO("new ip segment found,new ip addr:{}", ipStr);
+                }
+            }
+        }
+    }
+    sockCount_ = index;
+#else
+    struct ifaddrs *ifaddr, *ifa;
+    int             family, s, n;
+    char            host[NI_MAXHOST];
+
+    if(getifaddrs(&ifaddr) == -1) {
+        perror("getifaddrs");
+        exit(EXIT_FAILURE);
+    }
+
+    int index = sockCount_;
+
+    for(ifa = ifaddr, n = 0; ifa != NULL; ifa = ifa->ifa_next, n++) {
+        if(ifa->ifa_addr == NULL)
+            continue;
+
+        family = ifa->ifa_addr->sa_family;
+
+        if(family == AF_INET) {
+            s = getnameinfo(ifa->ifa_addr, sizeof(struct sockaddr_in), host, NI_MAXHOST, NULL, 0, NI_NUMERICHOST);
+            if(s != 0) {
+                LOG_TRACE("getnameinfo() failed: {}", gai_strerror(s));
+                exit(EXIT_FAILURE);
+            }
+
+            SOCKADDR_IN addrSrv;
+            addrSrv            = *(SOCKADDR_IN *)ifa->ifa_addr;
+            addrSrv.sin_family = AF_INET;
+            addrSrv.sin_port   = htons(0);
+            std::string ipStr  = inet_ntoa(addrSrv.sin_addr);
+            if(strcmp(ipStr.c_str(), "127.0.0.1") == 0) {
+                continue;
+            }
+
+            bool found = false;
+            for(auto sockIp: ipAddressStrSet_) {
+                if(ipStr == sockIp) {
+                    found = true;
+                    break;
+                }
+            }
+
+            if(!found) {
+                closeClientSockets();
+                index           = 0;
+                socks_[index++] = openClientSocket(addrSrv);
+                ipAddressStrSet_.insert(ipStr);
+                LOG_INFO("new ip segment found,new ip addr:{}", ipStr);
+            }
+        }
+    }
+    sockCount_ = index;
+    freeifaddrs(ifaddr);
+#endif
+}
+
+}  // namespace libobsensor
+
diff --git a/src/platform/ethernet/gige/GVCPClient.hpp b/src/platform/ethernet/gige/GVCPClient.hpp
new file mode 100644
index 00000000..5b66a7c8
--- /dev/null
+++ b/src/platform/ethernet/gige/GVCPClient.hpp
@@ -0,0 +1,142 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include "libobsensor/h/ObTypes.h"
+#include "ethernet/socket/SocketTypes.hpp"
+
+#include <vector>
+#include <string>
+#include <mutex>
+#include <set>
+
+namespace libobsensor {
+
+
+#define GVCP_VERSION 0x42  // GVCP protocol version number
+#define GVCP_DISCOVERY_FLAGS 0x11
+#define GVCP_FORCEIP_FLAGS 0x01
+#define GVCP_PORT 3956  // GVCP protocol port number
+#define GVCP_REQUEST_ID 0x0001
+#define GEV_STATUS_SUCCESS 0x0000
+
+#define GVCP_DISCOVERY_CMD 0x0002
+#define GVCP_DISCOVERY_ACK 0x0003
+#define GVCP_FORCEIP_CMD 0x0004
+#define GVCP_FORCEIP_ACK 0x0005
+
+#pragma pack(push, 1)
+struct gvcp_cmd_header {
+    uint8_t  cMsgKeyCode;  // 0x42
+    uint8_t  cFlag;        // 0x11 allow broadcast ack;ack required
+    uint16_t wCmd;         // discovery_cmd=2;FORCEIP_CMD = 4;READREG_CMD=0x80
+    uint16_t wLen;         // payload length
+    uint16_t wReqID;       // request id = 1;READREG id=12345
+};
+
+struct gvcp_forceip_payload {
+    uint8_t Mac[8];       // last 6 byte
+    uint8_t CurIP[16];    // last 4 byte
+    uint8_t SubMask[16];  // last 4 byte
+    uint8_t Gateway[16];  // last 4 byte
+};
+
+struct gvcp_ack_header {
+    uint16_t wStatus;  // success=0;
+    uint16_t wAck;     // discover_ack=3;forceip_ack=5;READREG_ACK=0x81
+    uint16_t wLen;
+    uint16_t wReqID;
+};
+
+// Note: Big-endian mode
+struct gvcp_ack_payload {
+    uint32_t dwSpecVer;
+    uint32_t dwDevMode;
+    uint8_t  Mac[8];  // last 6 byte
+    uint32_t dwSupIpSet;
+    uint32_t dwCurIpSet;
+    // uint8 unused1[12];
+    uint8_t  CurIP[16];        // last 4 byte
+    uint8_t  SubMask[16];      // last 4 byte
+    uint8_t  Gateway[16];      // last 4 byte
+    char     szFacName[32];    // first
+    char     szModelName[28];  // first
+    uint32_t dwPID;
+    char     szDevVer[32];
+    char     szFacInfo[48];
+    char     szSerial[16];
+    char     szUserName[16];
+};
+
+struct gvcp_discover_cmd {
+    struct gvcp_cmd_header header;
+};
+struct gvcp_discover_ack {
+    struct gvcp_ack_header  header;
+    struct gvcp_ack_payload payload;
+};
+struct gvcp_forceip_cmd {
+    struct gvcp_cmd_header      header;
+    struct gvcp_forceip_payload payload;
+};
+struct gvcp_forceip_ack {
+    struct gvcp_ack_header header;
+};
+#pragma pack(pop)
+
+struct GVCPDeviceInfo {
+    std::string mac     = "unknown";
+    std::string ip      = "unknown";
+    std::string mask    = "unknown";
+    std::string gateway = "unknown";
+    std::string sn      = "unknown";
+    std::string name    = "unknown";
+    uint32_t    pid     = 0;
+    // std::string version      = "";
+    // std::string manufacturer = "";
+
+    virtual bool operator==(const GVCPDeviceInfo &other) const {
+        return other.mac == mac && other.sn == sn && other.ip == ip;
+    }
+    virtual ~GVCPDeviceInfo() {}
+};
+
+#define MAX_SOCKETS 32
+
+class GVCPClient {
+public:
+    ~GVCPClient();
+
+    std::vector<GVCPDeviceInfo> queryNetDeviceList();
+    bool                       changeNetDeviceIpConfig(std::string mac, const OBNetIpConfig &config);
+
+    static GVCPClient &instance() {
+        static GVCPClient instance;
+        return instance;
+    }
+
+private:
+    GVCPClient();
+    int    openClientSockets();
+    void   closeClientSockets();
+    SOCKET openClientSocket(SOCKADDR_IN addr);
+    void   sendGVCPDiscovery(SOCKET sock);
+    void   sendGVCPForceIP(SOCKET sock, std::string mac, const OBNetIpConfig &config);
+
+    //
+    void checkAndUpdateSockets();
+
+private:
+    SOCKET                     socks_[MAX_SOCKETS];
+    int                        sockCount_ = 0;
+    std::vector<GVCPDeviceInfo> devInfoList_;
+    std::mutex                 queryMtx_;
+    std::mutex                 devInfoListMtx_;
+
+#ifndef WIN32
+    std::set<std::string> ipAddressStrSet_;
+#endif
+};
+
+
+}  // namespace libobsensor
diff --git a/src/platform/ethernet/rtsp/ObRTPSink.cpp b/src/platform/ethernet/rtsp/ObRTPSink.cpp
new file mode 100644
index 00000000..7be60ba7
--- /dev/null
+++ b/src/platform/ethernet/rtsp/ObRTPSink.cpp
@@ -0,0 +1,277 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "ObRTPSink.hpp"
+
+#include "H264VideoRTPSource.hh"
+
+#include "logger/Logger.hpp"
+#include "utils/Utils.hpp"
+#include "frame/FrameFactory.hpp"
+#include "stream/StreamProfile.hpp"
+
+#include <vector>
+#include <map>
+#include <string>
+#include <algorithm>
+
+namespace libobsensor {
+
+#define H264_NAL_SPS 7  // Sequence parameter set
+#define H264_NAL_PPS 8  // Picture parameter set
+
+#define H265_NAL_VPS 32  // Video Parameter Set
+#define H265_NAL_SPS 33  // Sequence parameter set
+#define H265_NAL_PPS 34  // Picture parameter set
+
+#pragma pack(2)
+typedef struct {
+    uint64_t frameCounter;  // Frame number
+    uint16_t extentionLen;  // Extended data length, default is 0
+    uint64_t timestamp;     // timestamp
+    uint32_t width;         // Frame pixel width
+    uint32_t height;        // Frame pixel height
+} OBNetworkFrameHeader;
+#pragma pack()
+
+const std::vector<std::string> OBVendorCodecs = {
+    "OB_FMT_Y16", "OB_FMT_Y8", "OB_FMT_Y10", "OB_FMT_RVL", "OB_FMT_MJPEG", "YUYV",
+};
+
+bool isOBVendorCodec(const std::string &codec) {
+    return std::find(OBVendorCodecs.begin(), OBVendorCodecs.end(), codec) != OBVendorCodecs.end();
+}
+
+const std::map<std::string, OBFormat> CodecToFormatMap = {
+    { "H264", OB_FORMAT_H264 },    { "H265", OB_FORMAT_H265 },      { "JPEG", OB_FORMAT_MJPG },      { "OB_FMT_Y16", OB_FORMAT_Y16 },
+    { "OB_FMT_Y8", OB_FORMAT_Y8 }, { "OB_FMT_Y10", OB_FORMAT_Y10 }, { "OB_FMT_RVL", OB_FORMAT_RVL }, { "OB_FMT_MJPEG", OB_FORMAT_MJPG },
+};
+
+OBFormat codecToOBFormat(const std::string &codec) {
+    auto it = CodecToFormatMap.find(codec);
+    if(it != CodecToFormatMap.end()) {
+        return it->second;
+    }
+    return OB_FORMAT_UNKNOWN;
+}
+
+ObRTPSink *ObRTPSink::createNew(std::shared_ptr<const StreamProfile> streamProfile, UsageEnvironment &env, MediaSubsession &subsession,
+                                MutableFrameCallback callback, char const *streamId) {
+    return new ObRTPSink(streamProfile, env, subsession, callback, streamId);
+}
+
+ObRTPSink::ObRTPSink(std::shared_ptr<const StreamProfile> streamProfile, UsageEnvironment &env, MediaSubsession &subsession, MutableFrameCallback callback,
+                     char const *streamId)
+    : MediaSink(env),
+      subsession_(subsession),
+      frameCallback_(callback),
+      streamProfile_(streamProfile),
+      frameCount_(0),
+      destroy_(false),
+      currentBuffer_(nullptr) {
+    streamId_ = strDup(streamId);
+    envir() << "ObRTPSink created! streamId = " << streamId_ << "\n";
+
+    auto     frame       = std::make_shared<ObRTPBuffer>(MAX_FRAME_DATA_SIZE);
+    auto     frameBuffer = frame->getBuffer();
+    uint32_t headerSize  = 0;
+
+    // Load vps/pps/sps into the frame header
+    if(strcmp(subsession_.codecName(), "H264") == 0) {
+        unsigned int  nalUnitNum;
+        SPropRecord  *pSPropRecord;
+        unsigned char nalUnitStartCode[4] = { 0, 0, 0, 1 };
+
+        pSPropRecord = parseSPropParameterSets(subsession_.fmtp_spropparametersets(), nalUnitNum);
+        for(unsigned int i = 0; i < nalUnitNum; i++) {
+            memcpy(frameBuffer + headerSize, &nalUnitStartCode[0], 4);
+            headerSize += 4;
+            memcpy(frameBuffer + headerSize, pSPropRecord[i].sPropBytes, pSPropRecord[i].sPropLength);
+            headerSize += pSPropRecord[i].sPropLength;
+        }
+
+        memcpy(frameBuffer + headerSize, &nalUnitStartCode[0], 4);
+        headerSize += 4;
+        frame->setHeaderSize(headerSize);
+        delete[] pSPropRecord;
+    }
+    else if(strcmp(subsession_.codecName(), "H265") == 0) {
+        SPropRecord *sPropRecords[3];
+        unsigned     numSPropRecords[3];
+        sPropRecords[0] = parseSPropParameterSets(subsession_.fmtp_spropvps(), numSPropRecords[0]);
+        sPropRecords[1] = parseSPropParameterSets(subsession_.fmtp_spropsps(), numSPropRecords[1]);
+        sPropRecords[2] = parseSPropParameterSets(subsession_.fmtp_sproppps(), numSPropRecords[2]);
+
+        unsigned char nalUnitStartCode[4] = { 0, 0, 0, 1 };
+
+        for(uint8_t i = 0; i < 3; i++) {
+            for(uint32_t j = 0; j < numSPropRecords[i]; j++) {
+                memcpy(frameBuffer + headerSize, &nalUnitStartCode[0], 4);
+                headerSize += 4;
+                memcpy(frameBuffer + headerSize, sPropRecords[i][j].sPropBytes, sPropRecords[i][j].sPropLength);
+                headerSize += sPropRecords[i][j].sPropLength;
+            }
+            delete[] sPropRecords[i];
+        }
+        memcpy(frameBuffer + headerSize, &nalUnitStartCode[0], 4);
+        headerSize += 4;
+        frame->setHeaderSize(headerSize);
+    }
+    // else: header size is 0
+
+    std::unique_lock<std::mutex> lk(reclaimedRTPBufferMutex_);
+    for(uint8_t i = 0; i < MAX_FRAME_NUM - 1; i++) {
+        auto newFrame = frame->cloneAndCopyHeader();
+        reclaimedRTPBufferQueue_.push(newFrame);
+    }
+    reclaimedRTPBufferQueue_.push(frame);
+
+    outputFrameThread_ = std::thread(&ObRTPSink::outputFrameFunc, this);
+}
+
+ObRTPSink::~ObRTPSink() noexcept {
+    envir() << "ObRTPSink destructor! streamId = " << streamId_ << "\n";
+    frameCallback_ = nullptr;
+    destroy_       = true;
+    frameAvailableCv_.notify_all();
+    delete[] streamId_;
+    if(outputFrameThread_.joinable()) {
+        outputFrameThread_.join();
+    }
+}
+
+void ObRTPSink::afterGettingFrame(void *clientData, unsigned frameSize, unsigned numTruncatedBytes, struct timeval presentationTime,
+                                  unsigned durationInMicroseconds) {
+    ObRTPSink *sink = (ObRTPSink *)clientData;
+    sink->afterGettingFrame(frameSize, numTruncatedBytes, presentationTime, durationInMicroseconds);
+}
+
+void ObRTPSink::afterGettingFrame(unsigned frameSize, unsigned numTruncatedBytes, struct timeval presentationTime, unsigned /*duration in microseconds*/) {
+    utils::unusedVar(numTruncatedBytes);
+
+    do {
+        if(strcmp(subsession_.codecName(), "H264") == 0) {
+            auto recv = currentBuffer_->getRecvdDataBuffer();
+            if((recv[0] & 0x1f) == H264_NAL_SPS || (recv[0] & 0x1f) == H264_NAL_PPS) {  // SPS(7) or PPS(8)
+                break;
+            }
+        }
+        else if(strcmp(subsession_.codecName(), "H265") == 0) {
+            auto recv = currentBuffer_->getRecvdDataBuffer();
+            if(((recv[0] & 0x7f) >> 1) == H265_NAL_VPS || ((recv[0] & 0x7f) >> 1) == H265_NAL_SPS || ((recv[0] & 0x7f) >> 1) == H265_NAL_PPS) {
+                break;
+            }
+        }
+
+        currentBuffer_->setRecvdDataSize(frameSize);
+        currentBuffer_->setCodecName(subsession_.codecName());
+        currentBuffer_->setSequenceNumber(frameCount_);
+        auto tsp = subsession_.getNormalPlayTime(presentationTime);
+        currentBuffer_->setTimestamp(static_cast<uint64_t>(tsp));
+
+        {
+            std::unique_lock<std::mutex> lk(outputRTPBufferQueueMutex_);
+            outputRTPBufferQueue_.push(currentBuffer_);
+            currentBuffer_.reset();
+        }
+        frameAvailableCv_.notify_all();
+        frameCount_++;
+    } while(0);
+
+    // Then continue, to request the next frame of data:
+    continuePlaying();
+}
+
+Boolean ObRTPSink::continuePlaying() {
+    if(fSource == NULL || frameCallback_ == NULL) {
+        return False;
+    }
+
+    if(!currentBuffer_) {
+        std::unique_lock<std::mutex> lk(reclaimedRTPBufferMutex_);
+        if(!reclaimedRTPBufferQueue_.empty()) {
+            currentBuffer_ = reclaimedRTPBufferQueue_.front();
+            reclaimedRTPBufferQueue_.pop();
+        }
+    }
+
+    if(!currentBuffer_) {
+        // Actively drop frames
+        std::unique_lock<std::mutex> lk(outputRTPBufferQueueMutex_);
+        if(!outputRTPBufferQueue_.empty()) {
+            currentBuffer_ = outputRTPBufferQueue_.front();
+            outputRTPBufferQueue_.pop();
+            LOG_WARN("Drop output-frame to receive new frame due to reclaimed-frame queue is empty: devTsp={}", currentBuffer_->getTimestamp());
+        }
+    }
+
+    // Request the next frame of data from our input source.  "afterGettingFrame()" will get called later, when it arrives:
+    fSource->getNextFrame(currentBuffer_->getRecvdDataBuffer(), MAX_FRAME_DATA_SIZE - currentBuffer_->getStaticHeaderSize(), afterGettingFrame, this,
+                          onSourceClosure, this);
+    return true;
+}
+
+void ObRTPSink::outputFrameFunc() {
+    while(!destroy_) {
+        std::shared_ptr<ObRTPBuffer> output;
+        {
+            std::unique_lock<std::mutex> lk(outputRTPBufferQueueMutex_);
+            frameAvailableCv_.wait(lk, [&]() { return !outputRTPBufferQueue_.empty() || destroy_; });
+            if(destroy_) {
+                break;
+            }
+            output = outputRTPBufferQueue_.front();
+            outputRTPBufferQueue_.pop();
+        }
+
+        if(!output) {
+            continue;
+        }
+
+        auto codecName = output->getCodecName();
+        auto format    = codecToOBFormat(codecName);
+
+        do {
+            if(format != streamProfile_->getFormat()) {
+                LOG_ERROR("Received frame format is not same as required");
+                break;
+            }
+
+            TRY_EXECUTE({
+                auto frame = FrameFactory::createFrameFromStreamProfile(streamProfile_);
+
+                uint32_t frameOffset = 0;
+                if(isOBVendorCodec(codecName)) {
+                    frameOffset = sizeof(OBNetworkFrameHeader);
+                    output->setDynamicHeaderSize(sizeof(OBNetworkFrameHeader));
+                    auto header = output->getDynamicHeader<OBNetworkFrameHeader>();
+                    frame->setTimeStampUsec(header->timestamp);
+                    frame->setSystemTimeStampUsec(utils::getNowTimesUs());
+                    frame->setNumber(header->frameCounter);
+                }
+                else {
+                    frame->setTimeStampUsec(output->getTimestamp());
+                    frame->setSystemTimeStampUsec(utils::getNowTimesUs());
+                    frame->setNumber(output->getSequenceNumber());
+                }
+
+                if(output->getStaticHeaderSize() > 0) {
+                    frame->updateData(output->getBuffer(), output->getRecvdDataSize() + output->getStaticHeaderSize());
+                }
+                else {
+                    frame->updateData(output->getRecvdDataBuffer() + frameOffset, output->getRecvdDataSize() - frameOffset);
+                }
+
+                frameCallback_(frame);
+            });
+        } while(0);
+
+        {
+            std::unique_lock<std::mutex> lk(reclaimedRTPBufferMutex_);
+            reclaimedRTPBufferQueue_.push(output);
+        }
+    }
+}
+
+}  // namespace libobsensor
+
diff --git a/src/platform/ethernet/rtsp/ObRTPSink.hpp b/src/platform/ethernet/rtsp/ObRTPSink.hpp
new file mode 100644
index 00000000..b75f468d
--- /dev/null
+++ b/src/platform/ethernet/rtsp/ObRTPSink.hpp
@@ -0,0 +1,165 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include "IFrame.hpp"
+#include "IStreamProfile.hpp"
+#include "exception/ObException.hpp"
+
+#include "liveMedia.hh"
+#include "BasicUsageEnvironment.hh"
+
+#include <queue>
+#include <atomic>
+#include <mutex>
+#include <thread>
+#include <condition_variable>
+
+namespace libobsensor {
+
+class ObRTPBuffer {
+public:
+    ObRTPBuffer(uint32_t maxDataSize)
+        : bufferSize_(maxDataSize), sequenceNumber_(0), timestamp_(0), staticHeaderSize_(0), recvdDataSize_(0), dynamicHeaderSize_(0) {
+        buffer_ = new uint8_t[maxDataSize];
+    }
+
+    ~ObRTPBuffer() {
+        delete[] buffer_;
+    }
+
+    void setSequenceNumber(uint64_t seq) {
+        sequenceNumber_ = seq;
+    }
+
+    uint64_t getSequenceNumber() const {
+        return sequenceNumber_;
+    }
+
+    void setTimestamp(uint64_t ts) {
+        timestamp_ = ts;
+    }
+
+    uint64_t getTimestamp() const {
+        return timestamp_;
+    }
+
+    void setCodecName(const std::string &name) {
+        codecName_ = name;
+    }
+
+    const std::string &getCodecName() const {
+        return codecName_;
+    }
+
+    uint8_t *getBuffer() const {
+        return buffer_;
+    }
+
+    uint32_t getBufferSize() const {
+        return bufferSize_;
+    }
+
+    void setHeaderSize(uint32_t size) {
+        staticHeaderSize_ = size;
+    }
+
+    void setDynamicHeaderSize(uint32_t size) {
+        dynamicHeaderSize_ = size;
+    }
+
+    void setRecvdDataSize(uint32_t size) {
+        recvdDataSize_ = size;
+    }
+
+    uint32_t getRecvdDataSize() const {
+        return recvdDataSize_;
+    }
+
+    template <typename T> T *getStaticHeader() const {
+        if(staticHeaderSize_ < sizeof(T)) {
+            throw invalid_value_exception("Header size is too small to cast to type T");
+        }
+        return reinterpret_cast<T *>(buffer_);
+    }
+
+    uint32_t getStaticHeaderSize() const {
+        return staticHeaderSize_;
+    }
+
+    template <typename T> T *getDynamicHeader() const {
+        if(dynamicHeaderSize_ < sizeof(T)) {
+            throw invalid_value_exception("Custom header size is too small to cast to type T");
+        }
+        return reinterpret_cast<T *>(buffer_ + staticHeaderSize_);
+    }
+
+    uint8_t *getRecvdDataBuffer(uint16_t offset = 0) const {
+        return buffer_ + staticHeaderSize_ + offset;
+    }
+
+    std::shared_ptr<ObRTPBuffer> cloneAndCopyHeader() {
+        auto frame = std::make_shared<ObRTPBuffer>(bufferSize_);
+        memcpy(frame->getBuffer(), buffer_, staticHeaderSize_);
+        frame->setHeaderSize(staticHeaderSize_);
+        return frame;
+    }
+
+private:
+    uint8_t *buffer_;
+    uint32_t bufferSize_;
+
+    uint64_t    sequenceNumber_;
+    uint64_t    timestamp_;
+    std::string codecName_;
+    uint32_t    staticHeaderSize_;
+    uint32_t    recvdDataSize_;  // size of data received = dataSize_ + dynamicHeaderSize_
+    uint32_t    dynamicHeaderSize_;
+};
+
+class ObRTPSink : public MediaSink {
+public:
+    static ObRTPSink *createNew(std::shared_ptr<const StreamProfile> streamProfile,
+                                UsageEnvironment    &env,
+                                MediaSubsession     &subsession,  // identifies the kind of data that's being received
+                                MutableFrameCallback callback,
+                                char const          *streamId = NULL);  // identifies the stream itself (optional)
+
+    virtual ~ObRTPSink() noexcept;
+
+protected:
+    ObRTPSink(std::shared_ptr<const StreamProfile> streamProfile, UsageEnvironment &env, MediaSubsession &subsession, MutableFrameCallback callback, char const *streamId = NULL);
+
+private:
+    static void afterGettingFrame(void *clientData, unsigned frameSize, unsigned numTruncatedBytes, struct timeval presentationTime,
+                                  unsigned durationInMicroseconds);
+    void        afterGettingFrame(unsigned frameSize, unsigned numTruncatedBytes, struct timeval presentationTime, unsigned durationInMicroseconds);
+
+private:
+    // redefined virtual functions:
+    virtual Boolean continuePlaying();
+    void            outputFrameFunc();
+
+private:
+    MediaSubsession                     &subsession_;
+    char                                *streamId_;
+    MutableFrameCallback                 frameCallback_;
+    std::shared_ptr<const StreamProfile> streamProfile_;
+    uint64_t                             frameCount_;
+    std::atomic<bool>                    destroy_;
+
+    std::queue<std::shared_ptr<ObRTPBuffer>> reclaimedRTPBufferQueue_;
+    std::mutex                               reclaimedRTPBufferMutex_;
+    std::queue<std::shared_ptr<ObRTPBuffer>> outputRTPBufferQueue_;
+    std::mutex                               outputRTPBufferQueueMutex_;
+    std::condition_variable                  frameAvailableCv_;
+    std::shared_ptr<ObRTPBuffer>             currentBuffer_;
+
+    const uint8_t  MAX_FRAME_NUM       = 4;
+    const uint32_t MAX_FRAME_DATA_SIZE = 3 * 3840 * 2160;
+
+    std::thread outputFrameThread_;
+};
+
+}  // namespace libobsensor
+
diff --git a/src/platform/ethernet/rtsp/ObRTSPClient.cpp b/src/platform/ethernet/rtsp/ObRTSPClient.cpp
new file mode 100644
index 00000000..a9ab7292
--- /dev/null
+++ b/src/platform/ethernet/rtsp/ObRTSPClient.cpp
@@ -0,0 +1,365 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "ObRTSPClient.hpp"
+#include "exception/ObException.hpp"
+
+#include "logger/Logger.hpp"
+#include "utils/Utils.hpp"
+
+#include <chrono>
+
+namespace libobsensor {
+
+#define WAIT_CMD_RESPONES(timeout)                                                                                              \
+    {                                                                                                                           \
+        if(!commandCv_.wait_for(lk, std::chrono::milliseconds(timeout), [&]() { return commandState_ != CMD_WAITING_RESP; })) { \
+            commandState_ = CMD_TIMEOUT;                                                                                        \
+        }                                                                                                                       \
+    }
+
+// A function that outputs a string that identifies each stream (for debugging output).  Modify this if you wish:
+UsageEnvironment &operator<<(UsageEnvironment &env, const RTSPClient &rtspClient) {
+    return env << "[URL:\"" << rtspClient.url() << "\"]: ";
+}
+
+// A function that outputs a string that identifies each subsession (for debugging output).  Modify this if you wish:
+UsageEnvironment &operator<<(UsageEnvironment &env, const MediaSubsession &subsession) {
+    return env << subsession.mediumName() << "/" << subsession.codecName();
+}
+
+ObRTSPClient *ObRTSPClient::createNew(std::shared_ptr<const StreamProfile> profile, UsageEnvironment &env, char const *rtspURL, MutableFrameCallback callback, int verbosityLevel,
+                                      portNumBits tunnelOverHTTPPortNum, int socketNumToServer) {
+    return new ObRTSPClient(profile, env, rtspURL, callback, verbosityLevel, tunnelOverHTTPPortNum, socketNumToServer);
+}
+
+ObRTSPClient::ObRTSPClient(std::shared_ptr<const StreamProfile> profile, UsageEnvironment &env, char const *rtspURL, MutableFrameCallback callback,
+                           int verbosityLevel, portNumBits tunnelOverHTTPPortNum, int socketNumToServer)
+    : RTSPClient(env, rtspURL, verbosityLevel, "Open-Orbbec-SDK", tunnelOverHTTPPortNum, socketNumToServer), profile_(profile), frameCallback_(callback) {
+    envir() << "ObRTSPClient created! rtspURL = " << url();
+}
+
+ObRTSPClient::~ObRTSPClient() noexcept {
+    TRY_EXECUTE(stopStream());
+
+    // Ensure that the taskScheduler eventLoop thread is closed before performing the following operations
+
+    clearSinks();  // Closing the stream might cause an exception; sinks need to be cleared again
+    if(mediaSession_ != nullptr) {
+        // We also need to delete "session", and unschedule "streamTimerTask_" (if set)
+        if(streamTimerTask_ != NULL) {
+            envir().taskScheduler().unscheduleDelayedTask(streamTimerTask_);
+        }
+        Medium::close(mediaSession_);
+        mediaSession_ = nullptr;
+    }
+    if(curSubsessionIter_ != nullptr) {
+        delete curSubsessionIter_;
+        curSubsessionIter_ = nullptr;
+    }
+
+    envir() << "ObRTSPClient destructor! rtspURL = " << url();
+}
+
+void ObRTSPClient::startStream() {
+    std::unique_lock<std::recursive_mutex> lk(commandMutex_);
+    commandState_ = CMD_WAITING_RESP;
+
+    DESCRIBE();  // The SETUP and PLAY steps will be completed sequentially in each response function
+
+    WAIT_CMD_RESPONES(RTSP_RESPONSE_TIMEOUT_MS);
+    if(commandState_ != CMD_DONE) {
+        if(commandState_ == CMD_TIMEOUT && !errorMsg_.length()) {
+            errorMsg_ = utils::string::to_string() << "Wait command respones failed! Timeout! state=" << std::to_string(RTSPState_);
+        }
+        std::string msg = errorMsg_;
+
+        if(RTSPState_ >= RTSP_SETUP) {
+            TRY_EXECUTE(stopStream());
+        }
+
+        throw libobsensor::camera_disconnected_exception(msg);
+    }
+
+    envir() << "ObRTSPClient stream started! rtspURL = " << url() << "\n";
+}
+
+void ObRTSPClient::stopStream() {
+    if(RTSPState_ == RTSP_PLAY) {
+        std::unique_lock<std::recursive_mutex> lk(commandMutex_);
+        commandState_ = CMD_WAITING_RESP;
+
+        TEARDOWN();
+
+        WAIT_CMD_RESPONES(RTSP_RESPONSE_TIMEOUT_TEARDOWN_MS);
+        if(commandState_ != CMD_DONE) {
+            if(commandState_ == CMD_TIMEOUT && !errorMsg_.length()) {
+                errorMsg_ = utils::string::to_string() << "Wait command respones failed! Timeout! state=TEARDOWN";
+            }
+            throw libobsensor::camera_disconnected_exception(errorMsg_);
+        }
+        envir() << "ObRTSPClient: stream stoped! rtspURL = " << url() << "\n";
+    }
+}
+
+void ObRTSPClient::DESCRIBE() {
+    RTSPState_ = RTSP_DESCRIBE;
+    envir() << url() << ": Send describe command to get SDP, to create medea session\n";
+    sendDescribeCommand(cmdResponseHandlerDESCRIBE);
+}
+
+void ObRTSPClient::cmdResponseHandlerDESCRIBE(RTSPClient *rtspClient, int resultCode, char *resultString) {
+    ObRTSPClient *obRtspClient = (ObRTSPClient *)rtspClient;
+    if(obRtspClient->RTSPState_ == RTSP_DESCRIBE && obRtspClient->commandState_ != CMD_TIMEOUT) {
+        do {
+            UsageEnvironment &env = rtspClient->envir();  // alias
+
+            if(resultCode != 0) {
+                obRtspClient->commandState_ = CMD_RESP_WITH_ERROR;
+                obRtspClient->errorMsg_     = utils::string::to_string() << rtspClient->url() << ": Failed to get a SDP description";
+                obRtspClient->commandCv_.notify_all();
+                break;
+            }
+
+            env << *rtspClient << "Got a SDP description:\n" << resultString;
+
+            // Create a media session object from this SDP description:
+            char *const sdpDescription  = resultString;
+            obRtspClient->mediaSession_ = MediaSession::createNew(env, sdpDescription);
+
+            if(obRtspClient->mediaSession_ == NULL) {
+                obRtspClient->commandState_ = CMD_RESP_WITH_ERROR;
+                obRtspClient->errorMsg_     = utils::string::to_string()
+                                          << rtspClient->url() << ": Failed to create a MediaSession object from the SDP description: " << env.getResultMsg();
+                obRtspClient->commandCv_.notify_all();
+                break;
+            }
+            else if(!obRtspClient->mediaSession_->hasSubsessions()) {
+                obRtspClient->commandState_ = CMD_RESP_WITH_ERROR;
+                obRtspClient->errorMsg_ = utils::string::to_string() << rtspClient->url() << ": This session has no media subsessions (i.e., no \"m=\" lines)";
+                obRtspClient->commandCv_.notify_all();
+                break;
+            }
+            obRtspClient->SETUP();
+        } while(0);
+    }
+    delete[] resultString;
+}
+
+void ObRTSPClient::SETUP() {
+    RTSPState_         = RTSP_SETUP;
+    curSubsessionIter_ = new MediaSubsessionIterator(*mediaSession_);
+    setupNextSubsession();
+}
+
+void ObRTSPClient::setupNextSubsession() {
+    if((curSubsession_ = curSubsessionIter_->next()) != NULL) {
+        if(!curSubsession_->initiate()) {
+            commandState_ = CMD_RESP_WITH_ERROR;
+            errorMsg_     = utils::string::to_string() << "Failed to initiate the \"" << curSubsession_->mediumName() << "/" << curSubsession_->codecName()
+                                                   << "\" subsession: " << envir().getResultMsg() << "\n";
+            commandCv_.notify_all();
+        }
+        else {
+            envir() << this << "Initiated the \"" << *curSubsession_ << "\" subsession (";
+            if(curSubsession_->rtcpIsMuxed()) {
+                envir() << "client port " << curSubsession_->clientPortNum();
+            }
+            else {
+                envir() << "client ports " << curSubsession_->clientPortNum() << "-" << curSubsession_->clientPortNum() + 1;
+            }
+            envir() << ")\n";
+
+            envir() << url() << ": Setup the \"" << *curSubsession_->mediumName() << "/" << *curSubsession_->codecName() << "\" subsession \n";
+            sendSetupCommand(*curSubsession_, cmdResponseHandlerSETUP, False, RTP_STREAMING_OVER_TCP);
+        }
+    }
+    else {
+        PLAY();
+    }
+}
+
+void ObRTSPClient::cmdResponseHandlerSETUP(RTSPClient *rtspClient, int resultCode, char *resultString) {
+    ObRTSPClient *obRtspClient = (ObRTSPClient *)rtspClient;
+    if(obRtspClient->RTSPState_ == RTSP_SETUP && obRtspClient->commandState_ != CMD_TIMEOUT) {
+        do {
+            UsageEnvironment     &env           = rtspClient->envir();           // alias
+            MutableFrameCallback &frameCallback = obRtspClient->frameCallback_;  // alias
+            MediaSubsession      *subsession    = obRtspClient->curSubsession_;  // alias
+            if(resultCode != 0) {
+                obRtspClient->commandState_ = CMD_RESP_WITH_ERROR;
+                obRtspClient->errorMsg_     = utils::string::to_string() << rtspClient->url() << ": Failed to set up the \"" << *subsession->mediumName() << "/"
+                                                                     << *subsession->codecName() << "\" subsession: " << resultString << "";
+                obRtspClient->commandCv_.notify_all();
+                break;
+            }
+            // Having successfully setup the curSubsession, create a data sink for it.
+            // (This will prepare the data sink to receive data; the actual flow of data from the client won't start happening until later,
+            // after we've sent a RTSP "PLAY" command.)
+            subsession->sink = ObRTPSink::createNew(obRtspClient->profile_, env, *subsession, frameCallback, rtspClient->url());
+            if(subsession->sink == NULL) {
+                obRtspClient->commandState_ = CMD_RESP_WITH_ERROR;
+                obRtspClient->errorMsg_     = utils::string::to_string()
+                                          << rtspClient->url() << ": Failed to create a data sink for the \"" << *subsession->mediumName() << "/"
+                                          << *subsession->codecName() << "\" subsession: " << env.getResultMsg();
+                obRtspClient->commandCv_.notify_all();
+                break;
+            }
+            env << *rtspClient << "Created a data sink for the \"" << *subsession << "\" subsession\n";
+            subsession->miscPtr = rtspClient;  // a hack to let curSubsession handler functions get the "RTSPClient" from the curSubsession
+            // Also set a handler to be called if a RTCP "BYE" arrives for this subsession:
+            if(subsession->rtcpInstance() != NULL) {
+                subsession->rtcpInstance()->setByeWithReasonHandler(subsessionByeHandler, subsession);
+            }
+            subsession->sink->startPlaying(*(subsession->readSource()), subsessionAfterPlayingHandler, subsession);
+            obRtspClient->setupNextSubsession();
+        } while(0);
+    }
+    delete[] resultString;
+}
+
+void ObRTSPClient::PLAY() {
+    // PLAY
+    RTSPState_ = RTSP_PLAY;
+
+    if(mediaSession_->absStartTime() != NULL) {
+        // Special case: The stream is indexed by 'absolute' time, so send an appropriate "PLAY" command:
+        envir() << url() << ": Play! MediaSession=" << mediaSession_ << "\n";
+        sendPlayCommand(*mediaSession_, cmdResponseHandlerPLAY, mediaSession_->absStartTime(), mediaSession_->absEndTime());
+        duration_ = 0.0;
+    }
+    else {
+        duration_ = mediaSession_->playEndTime() - mediaSession_->playStartTime();
+        envir() << url() << ": Play! MediaSession=" << mediaSession_ << ", duration=" << duration_ << "\n";
+        sendPlayCommand(*mediaSession_, cmdResponseHandlerPLAY);
+    }
+}
+
+void ObRTSPClient::cmdResponseHandlerPLAY(RTSPClient *rtspClient, int resultCode, char *resultString) {
+    ObRTSPClient *obRtspClient = (ObRTSPClient *)rtspClient;
+
+    if(obRtspClient->RTSPState_ == RTSP_PLAY && obRtspClient->commandState_ != CMD_TIMEOUT) {
+        if(resultCode != 0) {
+            obRtspClient->commandState_ = CMD_RESP_WITH_ERROR;
+            obRtspClient->errorMsg_     = utils::string::to_string() << "[URL:\"" << rtspClient->url() << "\"]: "
+                                                                 << "Failed to start playing session: " << resultString << "\n";
+            obRtspClient->commandCv_.notify_all();
+        }
+        else {
+            UsageEnvironment &env = rtspClient->envir();  // alias
+            // Set a timer to be handled at the end of the stream's expected duration_ (if the stream does not already signal its end
+            // using a RTCP "BYE").  This is optional.  If, instead, you want to keep the stream active - e.g., so you can later
+            // 'seek' back within it and do another RTSP "PLAY" - then you can omit this code.
+            // (Alternatively, if you don't want to receive the entire stream, you could set this timer for some shorter value.)
+            if(obRtspClient->duration_ > 0) {
+                const double delaySlop = 0.1;  // number of seconds extra to delay, after the stream's expected duration_.  (This is optional.)
+                obRtspClient->duration_ += delaySlop;
+                unsigned uSecsToDelay          = (unsigned)(obRtspClient->duration_ * 1000000);
+                obRtspClient->streamTimerTask_ = env.taskScheduler().scheduleDelayedTask(uSecsToDelay, (TaskFunc *)streamStopEventHandler, rtspClient);
+            }
+            env << *rtspClient << "Started playing session";
+            if(obRtspClient->duration_ > 0) {
+                env << " (for up to " << obRtspClient->duration_ << " seconds)";
+            }
+            env << "...\n";
+            // Stream opened successfully
+            obRtspClient->commandState_ = CMD_DONE;
+            obRtspClient->commandCv_.notify_all();
+        }
+    }
+    delete[] resultString;
+}
+
+void ObRTSPClient::TEARDOWN() {
+    RTSPState_ = RTSP_TEARDOWN;
+    envir() << url() << ": Send TEARDOWN command to stop stream\n";
+    sendTeardownCommand(*mediaSession_, cmdResponseHandlerTEARDOWN);
+}
+
+void ObRTSPClient::cmdResponseHandlerTEARDOWN(RTSPClient *rtspClient, int resultCode, char *resultString) {
+    UsageEnvironment &env          = rtspClient->envir();  // alias
+    ObRTSPClient     *obRtspClient = (ObRTSPClient *)rtspClient;
+    if(obRtspClient->RTSPState_ == RTSP_TEARDOWN && obRtspClient->commandState_ != CMD_TIMEOUT) {
+        obRtspClient->commandState_ = CMD_DONE;
+        obRtspClient->commandCv_.notify_all();
+    }
+    if(resultString != nullptr) {
+        env << "TEARDOWN response with: " << resultString << ", code=" << resultCode << "\n";
+        delete[] resultString;
+    }
+}
+
+void ObRTSPClient::clearSinks() {
+    // Clear the sinks bound to each subsession
+    if(mediaSession_ != nullptr) {
+        MediaSubsessionIterator subsessionIter(*mediaSession_);
+        MediaSubsession        *subsession;
+
+        while((subsession = subsessionIter.next()) != NULL) {
+            if(subsession->sink != NULL) {
+                Medium::close(subsession->sink);  // Stop event scheduling; the sink will be destructed, and stopPlaying will be called during its destruction
+                subsession->sink = NULL;
+
+                if(subsession->rtcpInstance() != NULL) {
+                    subsession->rtcpInstance()->setByeHandler(NULL, NULL);  // in case the server sends a RTCP "BYE" while handling "TEARDOWN"
+                }
+            }
+        }
+    }
+}
+
+void ObRTSPClient::subsessionAfterPlayingHandler(void *clientData) {
+    MediaSubsession *subsession   = (MediaSubsession *)clientData;
+    ObRTSPClient    *obRtspClient = (ObRTSPClient *)(subsession->miscPtr);
+    if(obRtspClient->RTSPState_ != RTSP_TEARDOWN) {
+        TRY_EXECUTE(obRtspClient->stopStream());
+    }
+}
+
+void ObRTSPClient::subsessionByeHandler(void *clientData, char const *reason) {
+    MediaSubsession  *subsession   = (MediaSubsession *)clientData;
+    ObRTSPClient     *obRtspClient = (ObRTSPClient *)subsession->miscPtr;
+    UsageEnvironment &env          = obRtspClient->envir();  // alias
+
+    env << *obRtspClient << "Received RTCP \"BYE\"";
+    if(reason != NULL) {
+        env << " (reason:\"" << reason << "\")";
+        delete[](char *)reason;
+    }
+    env << " on \"" << *subsession << "\" subsession\n";
+
+    // Begin by closing this subsession's stream:
+    Medium::close(subsession->sink);
+    subsession->sink = NULL;
+
+    // Next, check whether *all* subsessions' streams have now been closed:
+    MediaSession           &session = subsession->parentSession();
+    MediaSubsessionIterator subsessionIter(session);
+    while((subsession = subsessionIter.next()) != NULL) {
+        if(subsession->sink != NULL)
+            return;  // this subsession is still active
+    }
+
+    {
+        if(obRtspClient->RTSPState_ == RTSP_PLAY && obRtspClient->commandState_ == CMD_WAITING_RESP) {
+            obRtspClient->errorMsg_     = "RTSP-PLAY Failed! Received RTCP\"BYE\"";
+            obRtspClient->commandState_ = CMD_RESP_WITH_ERROR;
+            obRtspClient->commandCv_.notify_all();
+        }
+    }
+
+    if(obRtspClient->RTSPState_ != RTSP_TEARDOWN) {
+        TRY_EXECUTE(obRtspClient->stopStream());
+    }
+}
+
+void ObRTSPClient::streamStopEventHandler(void *clientData) {
+    auto rtspClient = (ObRTSPClient *)clientData;
+    rtspClient->envir() << "Stream stop event occur";
+    rtspClient->streamTimerTask_ = NULL;
+    // stop the stream:
+    TRY_EXECUTE(rtspClient->stopStream());
+}
+
+}  // namespace libobsensor
+
diff --git a/src/platform/ethernet/rtsp/ObRTSPClient.hpp b/src/platform/ethernet/rtsp/ObRTSPClient.hpp
new file mode 100644
index 00000000..8c5140fb
--- /dev/null
+++ b/src/platform/ethernet/rtsp/ObRTSPClient.hpp
@@ -0,0 +1,95 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include "liveMedia.hh"
+#include "BasicUsageEnvironment.hh"
+#include "ObRTPSink.hpp"
+#include <string>
+#include <mutex>
+#include <condition_variable>
+
+namespace libobsensor {
+
+const static uint16_t RTSP_RESPONSE_TIMEOUT_MS          = 12000;
+const static uint16_t RTSP_RESPONSE_TIMEOUT_TEARDOWN_MS = 2000;
+const static bool     RTP_STREAMING_OVER_TCP            = true;
+
+enum CommandState {
+    CMD_RESP_WITH_ERROR = -2,
+    CMD_TIMEOUT         = -1,
+    CMD_WAITING_RESP    = 0,
+    CMD_DONE            = 1,
+};
+
+enum RTSPState {
+    RTSP_DESCRIBE = 0,
+    RTSP_SETUP,
+    RTSP_PLAY,
+    RTSP_TEARDOWN,
+};
+
+class ObRTSPClient : public RTSPClient {
+public:
+    static ObRTSPClient *createNew(std::shared_ptr<const StreamProfile> profile, UsageEnvironment &env, char const *rtspURL, MutableFrameCallback callback, int verbosityLevel = 0,
+                                   portNumBits tunnelOverHTTPPortNum = 0, int socketNumToServer = -1);
+
+    virtual ~ObRTSPClient() noexcept;
+
+public:
+    void startStream();
+    void stopStream();
+
+protected:
+    ObRTSPClient(std::shared_ptr<const StreamProfile> profile, UsageEnvironment &env, char const *rtspURL, MutableFrameCallback callback, int verbosityLevel = 0, portNumBits tunnelOverHTTPPortNum = 0,
+                 int socketNumToServer = -1);
+
+private:
+    void DESCRIBE();
+    // DESCRIBE command response, parse SDP, create media session
+    static void cmdResponseHandlerDESCRIBE(RTSPClient *rtspClient, int resultCode, char *resultString);
+
+    void SETUP();
+    void setupNextSubsession();
+    // SETUP command response, complete the creation of Subsession (create and bind sink)
+    static void cmdResponseHandlerSETUP(RTSPClient *rtspClient, int resultCode, char *resultString);
+
+    void PLAY();
+    // PLAY command response, if the stream has a certain duration, create a scheduled task to close the stream
+    static void cmdResponseHandlerPLAY(RTSPClient *rtspClient, int resultCode, char *resultString);
+
+    void TEARDOWN();
+    // TEARDOWN response
+    static void cmdResponseHandlerTEARDOWN(RTSPClient *rtspClient, int resultCode, char *resultString);
+
+    // Other event handler functions:
+    static void subsessionAfterPlayingHandler(void *clientData);  // called when a stream's subsession (e.g., audio or video substream) ends
+    static void subsessionByeHandler(void *clientData, char const *reason);
+    // called when a RTCP "BYE" is received for a subsession
+    static void streamStopEventHandler(void *clientData);
+    // called at the end of a stream's expected duration (if the stream has not already signaled its end using a RTCP "BYE")
+
+private:
+    void clearSinks();
+
+private:
+    std::shared_ptr<const StreamProfile> profile_;
+    MutableFrameCallback frameCallback_;
+
+    std::string                 errorMsg_;
+    CommandState                commandState_;
+    std::recursive_mutex        commandMutex_;
+    std::condition_variable_any commandCv_;
+
+    RTSPState RTSPState_;
+
+    MediaSession            *mediaSession_      = nullptr;
+    MediaSubsession         *curSubsession_     = nullptr;
+    MediaSubsessionIterator *curSubsessionIter_ = nullptr;
+
+    double    duration_;
+    TaskToken streamTimerTask_ = NULL;
+};
+
+}  // namespace libobsensor
+
diff --git a/src/platform/ethernet/rtsp/ObUsageEnvironment.cpp b/src/platform/ethernet/rtsp/ObUsageEnvironment.cpp
new file mode 100644
index 00000000..9b3501bc
--- /dev/null
+++ b/src/platform/ethernet/rtsp/ObUsageEnvironment.cpp
@@ -0,0 +1,88 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "ObUsageEnvironment.hpp"
+
+#include "logger/Logger.hpp"
+
+namespace libobsensor {
+
+ObUsageEnvironment::ObUsageEnvironment(TaskScheduler &taskScheduler) : BasicUsageEnvironment(taskScheduler), destroy_(false), newLog_(false) {
+    outputLogThread_ = std::thread(&ObUsageEnvironment::outputLog, this);
+}
+
+ObUsageEnvironment::~ObUsageEnvironment() {
+    destroy_ = true;
+    newLogCv_.notify_all();
+    outputLogThread_.join();
+}
+
+ObUsageEnvironment *ObUsageEnvironment::createNew(TaskScheduler &taskScheduler) {
+    return new ObUsageEnvironment(taskScheduler);
+}
+
+void ObUsageEnvironment::outputLog() {
+    while(!destroy_) {
+        std::unique_lock<std::mutex> lk(mutex_);
+        newLogCv_.wait(lk, [&]() { return newLog_ || destroy_; });
+        newLogCv_.wait_for(lk, std::chrono::microseconds(100), [&]() {
+            bool exit = !newLog_ || destroy_;
+            newLog_   = false;
+            return exit;
+        });
+
+        if(logMsg_.length() && !destroy_) {
+            LOG_DEBUG(logMsg_);
+            logMsg_.clear();
+        }
+    }
+}
+
+UsageEnvironment &ObUsageEnvironment::operator<<(char const *str) {
+    std::unique_lock<std::mutex> lk(mutex_);
+    if(str == nullptr) {
+        logMsg_ += "(NULL)";  // sanity check
+    }
+    else {
+        logMsg_ += str;
+    }
+    newLog_ = true;
+    newLogCv_.notify_all();
+    return dynamic_cast<UsageEnvironment &>(*this);
+}
+
+UsageEnvironment &ObUsageEnvironment::operator<<(int i) {
+    std::unique_lock<std::mutex> lk(mutex_);
+    logMsg_ += std::to_string(i);
+    newLog_ = true;
+    newLogCv_.notify_all();
+    return dynamic_cast<UsageEnvironment &>(*this);
+}
+
+UsageEnvironment &ObUsageEnvironment::operator<<(unsigned u) {
+    std::unique_lock<std::mutex> lk(mutex_);
+    logMsg_ += std::to_string(u);
+    newLog_ = true;
+    newLogCv_.notify_all();
+    return dynamic_cast<UsageEnvironment &>(*this);
+}
+
+UsageEnvironment &ObUsageEnvironment::operator<<(double d) {
+    std::unique_lock<std::mutex> lk(mutex_);
+    logMsg_ += std::to_string(d);
+    newLog_ = true;
+    newLogCv_.notify_all();
+    return dynamic_cast<UsageEnvironment &>(*this);
+}
+
+UsageEnvironment &ObUsageEnvironment::operator<<(void *p) {
+    std::unique_lock<std::mutex> lk(mutex_);
+    logMsg_ += std::to_string((uint64_t)p);
+    newLog_ = true;
+    newLogCv_.notify_all();
+    return dynamic_cast<UsageEnvironment &>(*this);
+}
+
+
+}  // namespace libobsensor
+
diff --git a/src/platform/ethernet/rtsp/ObUsageEnvironment.hpp b/src/platform/ethernet/rtsp/ObUsageEnvironment.hpp
new file mode 100644
index 00000000..8b1e753a
--- /dev/null
+++ b/src/platform/ethernet/rtsp/ObUsageEnvironment.hpp
@@ -0,0 +1,49 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include "BasicUsageEnvironment.hh"
+#include "liveMedia.hh"
+
+#include <mutex>
+#include <condition_variable>
+#include <thread>
+#include <string>
+
+namespace libobsensor {
+
+/**
+ * @brief ObUsageEnvironment Override the log output of BasicUsageEnvironment
+ *
+ */
+class ObUsageEnvironment : public BasicUsageEnvironment {
+public:
+    static ObUsageEnvironment *createNew(TaskScheduler &taskScheduler);
+
+    // virtual UsageEnvironment &operator<<(const std::string str);
+
+    virtual UsageEnvironment &operator<<(char const *str) override;
+    virtual UsageEnvironment &operator<<(int i) override;
+    virtual UsageEnvironment &operator<<(unsigned u) override;
+    virtual UsageEnvironment &operator<<(double d) override;
+    virtual UsageEnvironment &operator<<(void *p) override;
+
+protected:
+    ObUsageEnvironment(TaskScheduler &taskScheduler);
+    // called only by "createNew()" (or subclass constructors)
+    virtual ~ObUsageEnvironment();
+
+private:
+    void outputLog();
+
+private:
+    std::thread             outputLogThread_;
+    std::string             logMsg_;
+    std::mutex              mutex_;
+    std::condition_variable newLogCv_;
+    bool                    destroy_;
+    bool                    newLog_;
+};
+
+}  // namespace libobsensor
+
diff --git a/src/platform/ethernet/socket/SocketTypes.hpp b/src/platform/ethernet/socket/SocketTypes.hpp
new file mode 100644
index 00000000..4aad0995
--- /dev/null
+++ b/src/platform/ethernet/socket/SocketTypes.hpp
@@ -0,0 +1,39 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#if(defined(WIN32) || defined(_WIN32) || defined(WINCE))
+#include <winsock2.h>
+#include <WS2tcpip.h>
+#else
+#include <sys/time.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/ioctl.h>
+#include <arpa/inet.h>
+#include <unistd.h>
+#include <errno.h>
+#define SOCKET int
+#define SOCKADDR sockaddr
+#define SOCKADDR_IN sockaddr_in
+#define SOCKET_ERROR (-1)
+#define INVALID_SOCKET (-1)
+#define TIMEVAL timeval
+#define SD_BOTH SHUT_RDWR
+#define closesocket close
+#define ioctlsocket ioctl
+#define TIMEVAL timeval
+#define SD_BOTH SHUT_RDWR
+#endif
+
+namespace libobsensor {
+
+
+#if(defined(WIN32) || defined(_WIN32) || defined(WINCE))
+#define GET_LAST_ERROR() WSAGetLastError()
+#else
+#define GET_LAST_ERROR() errno
+#endif
+
+
+}  // namespace libobsensor
+
diff --git a/src/platform/ethernet/socket/VendorTCPClient.cpp b/src/platform/ethernet/socket/VendorTCPClient.cpp
new file mode 100644
index 00000000..b5d2cb8a
--- /dev/null
+++ b/src/platform/ethernet/socket/VendorTCPClient.cpp
@@ -0,0 +1,220 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "VendorTCPClient.hpp"
+#include "logger/Logger.hpp"
+#include "utils/Utils.hpp"
+#include "exception/ObException.hpp"
+
+#include <thread>
+
+namespace libobsensor {
+
+VendorTCPClient::VendorTCPClient(std::string address, uint16_t port, uint32_t connectTimeout, uint32_t commTimeout)
+    : address_(address), port_(port), socketFd_(INVALID_SOCKET), flushed_(false), CONNECT_TIMEOUT_MS(connectTimeout), COMM_TIMEOUT_MS(commTimeout) {
+#if(defined(WIN32) || defined(_WIN32) || defined(WINCE))
+    WSADATA wsaData;
+    int     rst = WSAStartup(MAKEWORD(2, 2), &wsaData);
+    if(rst != 0) {
+        throw libobsensor::invalid_value_exception(utils::string::to_string() << "Failed to load Winsock! err_code=" << GET_LAST_ERROR());
+    }
+#endif
+// Due to network configuration changes causing socket connection pipeline errors, macOS throws a SIGPIPE exception to the application, leading to a crash (this does not occur on Linux). This exception needs to be filtered out.
+#if(defined(OS_IOS) || defined(OS_MACOS))
+    signal(SIGPIPE, SIG_IGN);
+#endif
+    socketConnect();
+}
+
+VendorTCPClient::~VendorTCPClient() noexcept{
+    socketClose();
+#if(defined(WIN32) || defined(_WIN32) || defined(WINCE))
+    WSACleanup();
+#endif
+}
+
+void VendorTCPClient::socketConnect() {
+    int rst;
+    socketFd_ = socket(AF_INET, SOCK_STREAM, 0);  // ipv4, tcp(Streaming)
+    if(socketFd_ == INVALID_SOCKET) {
+        throw libobsensor::io_exception(utils::string::to_string() << "create socket failed! err_code=" << GET_LAST_ERROR());
+    }
+
+#if(defined(WIN32) || defined(_WIN32) || defined(WINCE))
+    uint32_t commTimeout = COMM_TIMEOUT_MS;
+#else
+    TIMEVAL commTimeout;
+    commTimeout.tv_sec  = COMM_TIMEOUT_MS / 1000;
+    commTimeout.tv_usec = COMM_TIMEOUT_MS % 1000 * 1000;
+#endif
+
+    setsockopt(socketFd_, SOL_SOCKET, SO_SNDTIMEO, (char *)&commTimeout, sizeof(commTimeout));  // Send timeout limit
+    setsockopt(socketFd_, SOL_SOCKET, SO_RCVTIMEO, (char *)&commTimeout, sizeof(commTimeout));  // Receive timeout limit
+
+    // Adjust the window size to resolve the network retransmission issue at any frame rate @LingYi
+    // Adjust the window size
+    // int sendBufSize = 1024 * 1024 * 2;  // 2MB
+    // rst = setsockopt(socketFd_, SOL_SOCKET, SO_SNDBUF, (char*)&sendBufSize, sizeof(sendBufSize));
+    // Receive window size
+    // int recvBufSize = 1024 * 1024 * 2;  // 2MB
+    // rst = setsockopt(socketFd_, SOL_SOCKET, SO_RCVBUF, (char*)&recvBufSize, sizeof(recvBufSize));
+
+    unsigned long mode = 1;  // non-blocking mode
+    // Set to non-blocking; handle connect timeout
+    rst = ioctlsocket(socketFd_, FIONBIO, &mode);
+    if(rst < 0) {
+        throw libobsensor::invalid_value_exception(utils::string::to_string() << "VendorTCPClient: ioctlsocket to non-blocking mode failed! addr=" << address_
+                                                                              << ", port=" << port_ << ", err_code=" << GET_LAST_ERROR());
+    }
+
+    struct sockaddr_in serverAddr;
+    serverAddr.sin_family = AF_INET;                                       // ipv4
+    serverAddr.sin_port   = htons(port_);                                  // convert uint16_t from host to network byte sequence
+    if(inet_pton(AF_INET, address_.c_str(), &serverAddr.sin_addr) <= 0) {  // address string to sin_addr
+        throw libobsensor::invalid_value_exception("Invalid address!");
+    }
+
+    rst = connect(socketFd_, (struct sockaddr *)&serverAddr, sizeof(serverAddr));
+    if(rst < 0) {
+        rst = GET_LAST_ERROR();
+#if(defined(WIN32) || defined(_WIN32) || defined(WINCE))
+        if(rst != WSAEWOULDBLOCK) {
+#else
+        if(rst != EINPROGRESS) {  // EINPROGRESS due to non-blocking mode
+#endif
+            throw libobsensor::invalid_value_exception(utils::string::to_string() << "VendorTCPClient: Connect to server failed! addr=" << address_
+                                                                                  << ", port=" << port_ << ", err_code=" << rst);
+        }
+    }
+
+    TIMEVAL connTimeout;
+#if(defined(OS_IOS) || defined(OS_MACOS) || defined(__ANDROID__))
+    connTimeout.tv_sec  = 0;
+    connTimeout.tv_usec = 100000;  // 100ms
+#else
+    connTimeout.tv_sec  = CONNECT_TIMEOUT_MS / 1000;
+    connTimeout.tv_usec = CONNECT_TIMEOUT_MS % 1000 * 1000;
+#endif
+
+    fd_set write, err;
+    FD_ZERO(&write);
+    FD_ZERO(&err);
+    FD_SET(socketFd_, &write);
+    FD_SET(socketFd_, &err);
+
+#if(defined(OS_IOS) || defined(OS_MACOS) || defined(__ANDROID__))
+    // Since the traditional `fcntl` cannot be used on iOS to set socketFd as non-blocking, leading to select blocking, reduce connTimeout and use polling to avoid the issue.
+    bool status = false;
+    int  retry  = 5;
+    do {
+        // check if the socket is ready
+        rst    = select(0, NULL, &write, &err, &connTimeout);
+        status = FD_ISSET(socketFd_, &write);
+    } while(!status && retry-- > 0);
+
+    if(!status) {
+        throw libobsensor::invalid_value_exception(utils::string::to_string() << "VendorTCPClient: Connect to server failed! addr=" << address_
+                                                                              << ", port=" << port_ << ", err=socket is not ready & timeout");
+    }
+#else
+    // check if the socket is ready
+    rst = select(0, NULL, &write, &err, &connTimeout);
+    if(!FD_ISSET(socketFd_, &write)) {
+        throw libobsensor::invalid_value_exception(utils::string::to_string() << "VendorTCPClient: Connect to server failed! addr=" << address_
+                                                                              << ", port=" << port_ << ", err=socket is not ready & timeout");
+    }
+#endif
+
+    // Restore to blocking mode
+    mode = 0;  // blocking mode
+    rst  = ioctlsocket(socketFd_, FIONBIO, &mode);
+    if(rst < 0) {
+        throw libobsensor::invalid_value_exception(utils::string::to_string() << "VendorTCPClient: ioctlsocket to blocking mode failed! addr=" << address_
+                                                                              << ", port=" << port_ << ", err_code=" << GET_LAST_ERROR());
+    }
+    LOG_DEBUG("TCP client socket created!, addr={0}, port={1}, socket={2}", address_, port_, socketFd_);
+}
+
+void VendorTCPClient::socketClose() {
+    if(socketFd_ > 0) {
+        auto rst = closesocket(socketFd_);
+        if(rst < 0) {
+            LOG_ERROR("close socket failed! socket={0}, err_code={1}", socketFd_, GET_LAST_ERROR());
+        }
+    }
+    LOG_DEBUG("TCP client socket closed! socket={}", socketFd_);
+    socketFd_ = INVALID_SOCKET;
+}
+
+void VendorTCPClient::socketReconnect() {
+    LOG_INFO("TCP client socket reconnecting...");
+    socketClose();
+    socketConnect();
+}
+
+int VendorTCPClient::read(uint8_t *data, const uint32_t dataLen) {
+    uint8_t retry = 2;
+    while(retry-- && !flushed_) {
+        int rst = recv(socketFd_, (char *)data, dataLen, 0);
+        if(rst < 0) {
+            rst = GET_LAST_ERROR();
+#if(defined(WIN32) || defined(_WIN32) || defined(WINCE))
+            if((rst == WSAECONNRESET || rst == WSAENOTCONN || rst == WSAETIMEDOUT) && retry >= 1) {
+#else
+            if((rst == EAGAIN || rst == EWOULDBLOCK) && retry >= 1) {
+                std::this_thread::sleep_for(std::chrono::milliseconds(100));
+            }
+            else if(rst == ENOTCONN && retry >= 1) {
+#endif
+                socketReconnect();
+                return -1;
+            }
+            else {
+                throw libobsensor::io_exception(utils::string::to_string() << "VendorTCPClient read data failed! socket=" << socketFd_ << ", err_code=" << rst);
+            }
+        }
+        else {
+            return rst;
+        }
+    }
+
+    return -1;
+}
+
+void VendorTCPClient::write(const uint8_t *data, const uint32_t dataLen) {
+    uint8_t retry = 2;
+    while(retry-- && !flushed_) {
+        int rst = send(socketFd_, (const char *)data, dataLen, 0);
+        if(rst < 0) {
+            rst = GET_LAST_ERROR();
+#if(defined(WIN32) || defined(_WIN32) || defined(WINCE))
+            if((rst == WSAECONNRESET || rst == WSAENOTCONN || rst == WSAETIMEDOUT) && retry >= 1) {
+#else
+            if((rst == EAGAIN || rst == EWOULDBLOCK) && retry >= 1) {
+                std::this_thread::sleep_for(std::chrono::milliseconds(100));
+            }
+            else if(rst == ENOTCONN && retry >= 1) {
+#endif
+                socketReconnect();
+            }
+            else {
+                throw libobsensor::io_exception(utils::string::to_string()
+                                                << "VendorTCPClient write data failed! socket=" << socketFd_ << ", err_code=" << rst);
+            }
+            continue;
+        }
+        break;
+    }
+}
+
+void VendorTCPClient::flush() {
+    if(socketFd_) {
+        flushed_ = true;
+        shutdown(socketFd_, SD_BOTH);
+        socketClose();
+    }
+}
+
+
+}  // namespace libobsensor
+
diff --git a/src/platform/ethernet/socket/VendorTCPClient.hpp b/src/platform/ethernet/socket/VendorTCPClient.hpp
new file mode 100644
index 00000000..b1dee6c0
--- /dev/null
+++ b/src/platform/ethernet/socket/VendorTCPClient.hpp
@@ -0,0 +1,35 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include "SocketTypes.hpp"
+#include <string>
+
+namespace libobsensor {
+
+class VendorTCPClient {
+public:
+    VendorTCPClient(std::string address, uint16_t port, uint32_t connectTimeout = 2000, uint32_t commTimeout = 5000);
+    ~VendorTCPClient() noexcept;
+
+    int  read(uint8_t *data, const uint32_t dataLen);
+    void write(const uint8_t *data, const uint32_t dataLen);
+
+    void flush();
+
+private:
+    void socketConnect();
+    void socketClose();
+    void socketReconnect();
+
+private:
+    const std::string address_;
+    const uint16_t    port_;
+    SOCKET            socketFd_;
+    bool              flushed_;
+    uint32_t          CONNECT_TIMEOUT_MS   = 2000;
+    uint32_t          COMM_TIMEOUT_MS      = 5000;
+};
+
+}  // namespace libobsensor
+
diff --git a/src/platform/usb/CMakeLists.txt b/src/platform/usb/CMakeLists.txt
new file mode 100644
index 00000000..61de79e6
--- /dev/null
+++ b/src/platform/usb/CMakeLists.txt
@@ -0,0 +1,13 @@
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+cmake_minimum_required(VERSION 3.5)
+
+add_subdirectory(pal)
+add_subdirectory(enumerator)
+add_subdirectory(uvc)
+add_subdirectory(hid)
+add_subdirectory(vendor)
+
+target_sources(${OB_TARGET_PAL} PRIVATE ${CMAKE_CURRENT_LIST_DIR}/UsbPortGroup.hpp ${CMAKE_CURRENT_LIST_DIR}/UsbPortGroup.cpp)
+
diff --git a/src/platform/usb/UsbPortGroup.cpp b/src/platform/usb/UsbPortGroup.cpp
new file mode 100644
index 00000000..de476e35
--- /dev/null
+++ b/src/platform/usb/UsbPortGroup.cpp
@@ -0,0 +1,26 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "UsbPortGroup.hpp"
+
+namespace libobsensor {
+bool GroupUSBSourcePortBySN(const std::shared_ptr<const SourcePortInfo> &port0, const std::shared_ptr<const SourcePortInfo> &port1) {
+    auto usbPort0 = std::dynamic_pointer_cast<const USBSourcePortInfo>(port0);
+    auto usbPort1 = std::dynamic_pointer_cast<const USBSourcePortInfo>(port1);
+
+    return usbPort0->serial == usbPort1->serial;
+}
+
+bool GroupUSBSourcePortByUID(const std::shared_ptr<const SourcePortInfo> &port0, const std::shared_ptr<const SourcePortInfo> &port1) {
+    auto usbPort0 = std::dynamic_pointer_cast<const USBSourcePortInfo>(port0);
+    auto usbPort1 = std::dynamic_pointer_cast<const USBSourcePortInfo>(port1);
+    return usbPort0->uid == usbPort1->uid;
+}
+
+bool GroupUSBSourcePortByUrl(const std::shared_ptr<const SourcePortInfo> &port0, const std::shared_ptr<const SourcePortInfo> &port1) {
+    auto usbPort0 = std::dynamic_pointer_cast<const USBSourcePortInfo>(port0);
+    auto usbPort1 = std::dynamic_pointer_cast<const USBSourcePortInfo>(port1);
+    return usbPort0->url == usbPort1->url;
+}
+
+}  // namespace libobsensor
diff --git a/src/platform/usb/UsbPortGroup.hpp b/src/platform/usb/UsbPortGroup.hpp
new file mode 100644
index 00000000..c23eb5fd
--- /dev/null
+++ b/src/platform/usb/UsbPortGroup.hpp
@@ -0,0 +1,28 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "ISourcePort.hpp"
+#include <functional>
+#include <algorithm>
+namespace libobsensor {
+
+bool GroupUSBSourcePortBySN(const std::shared_ptr<const SourcePortInfo> &port0, const std::shared_ptr<const SourcePortInfo> &port1);
+bool GroupUSBSourcePortByUrl(const std::shared_ptr<const SourcePortInfo> &port0, const std::shared_ptr<const SourcePortInfo> &port1);
+
+template <typename T>
+std::vector<std::shared_ptr<const SourcePortInfo>> FilterUSBPortInfoByPid(const std::vector<T> &devInfos, const std::vector<uint16_t> &pids) {
+    std::vector<std::shared_ptr<const SourcePortInfo>> outDeviceInfos;
+    for(auto &item: devInfos) {
+        if(IS_USB_PORT(item->portType)) {
+            auto dev  = std::dynamic_pointer_cast<const USBSourcePortInfo>(item);
+            auto iter = std::find(pids.begin(), pids.end(), dev->pid);
+            if(iter == pids.end()) {
+                continue;
+            }
+            outDeviceInfos.push_back(item);
+        }
+    }
+    return outDeviceInfos;
+}
+
+}  // namespace libobsensor
diff --git a/src/platform/usb/enumerator/CMakeLists.txt b/src/platform/usb/enumerator/CMakeLists.txt
new file mode 100644
index 00000000..4228156e
--- /dev/null
+++ b/src/platform/usb/enumerator/CMakeLists.txt
@@ -0,0 +1,17 @@
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+cmake_minimum_required(VERSION 3.5)
+
+
+file (GLOB _cpp_files "${CMAKE_CURRENT_LIST_DIR}/*.cpp")
+file (GLOB _head_files "${CMAKE_CURRENT_LIST_DIR}/*.hpp")
+
+
+foreach(_file IN ITEMS ${_cpp_files})
+        target_sources(${OB_TARGET_PAL} PRIVATE "${_file}")
+endforeach()
+
+foreach(_file IN ITEMS ${_head_files})
+        target_sources(${OB_TARGET_PAL} PRIVATE "${_file}")
+endforeach()
diff --git a/src/platform/usb/enumerator/IUsbEnumerator.hpp b/src/platform/usb/enumerator/IUsbEnumerator.hpp
new file mode 100644
index 00000000..09f30bc0
--- /dev/null
+++ b/src/platform/usb/enumerator/IUsbEnumerator.hpp
@@ -0,0 +1,61 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include <string>
+#include <sstream>
+#include <vector>
+#include <mutex>
+
+namespace libobsensor {
+
+struct UsbInterfaceInfo {
+    std::string url;
+    std::string uid;
+    std::string hubId;
+    uint16_t    vid = 0;
+    uint16_t    pid = 0;
+    std::string serial;
+    uint16_t    conn_spec = 0;
+
+    uint8_t     infIndex         = 0;
+    uint8_t     infNameDescIndex = 0;  // iInterface (index of string description of interface)
+    std::string infName;
+    std::string infUrl;  // to distinguish between different pins of the same device
+    uint8_t     cls = 0;
+
+    operator std::string() {
+        std::stringstream s;
+
+        s << "vid- " << std::hex << vid << "\npid- " << std::hex << pid << "\ninfIndex- " << (uint32_t)infIndex << "\nusb specification- " << std::hex
+          << (uint16_t)conn_spec << std::dec << "\nuid- " << uid;
+
+        return s.str();
+    }
+};
+
+inline bool operator==(const UsbInterfaceInfo &a, const UsbInterfaceInfo &b) {
+    return (a.vid == b.vid) && (a.pid == b.pid) && (a.infIndex == b.infIndex) && (a.uid == b.uid) && (a.infUrl == b.infUrl);
+}
+
+class IUsbDevice {
+public:
+    virtual ~IUsbDevice() = default;
+};
+
+class IUsbEnumerator {
+private:
+    static std::weak_ptr<IUsbEnumerator> instanceWeakPtr_;
+    static std::mutex                    instanceMutex_;
+
+public:
+    static std::shared_ptr<IUsbEnumerator> getInstance();
+
+    virtual ~IUsbEnumerator() = default;
+
+    virtual const std::vector<UsbInterfaceInfo> &queryUsbInterfaces()                     = 0;
+    virtual std::shared_ptr<IUsbDevice>          openUsbDevice(const std::string &devUrl) = 0;
+};
+
+}  // namespace libobsensor
diff --git a/src/platform/usb/enumerator/UsbEnumeratorLibusb.cpp b/src/platform/usb/enumerator/UsbEnumeratorLibusb.cpp
new file mode 100644
index 00000000..f625ca0d
--- /dev/null
+++ b/src/platform/usb/enumerator/UsbEnumeratorLibusb.cpp
@@ -0,0 +1,520 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#ifndef __ANDROID__
+
+#include "UsbEnumeratorLibusb.hpp"
+
+#include "logger/Logger.hpp"
+#include "logger/LoggerInterval.hpp"
+#include "utils/Utils.hpp"
+#include "exception/ObException.hpp"
+
+namespace libobsensor {
+
+std::string getDevicePath(libusb_device *device) {
+#ifdef WIN32
+    auto path = libusb_get_windows_path(device);
+    if(!path) {
+        return "";
+    }
+    return path;
+#else
+    auto usb_bus = std::to_string(libusb_get_bus_number(device));
+
+    // As per the USB 3.0 specs, the current maximum limit for the depth is 7.
+    const auto        max_usb_depth            = 8;
+    uint8_t           usb_ports[max_usb_depth] = {};
+    std::stringstream port_path;
+    auto              port_count = libusb_get_port_numbers(device, usb_ports, max_usb_depth);
+    auto              usb_dev    = std::to_string(libusb_get_device_address(device));
+
+    for(int i = 0; i < port_count; ++i) {
+        port_path << std::to_string(usb_ports[i]) << (((i + 1) < port_count) ? "." : "");
+    }
+
+    return usb_bus + "-" + port_path.str() + "-" + usb_dev;
+#endif
+}
+
+std::string getDeviceHubID(const std::string &devicePath) {
+    auto sstart = devicePath.find_first_of('-');
+    auto send   = devicePath.find_last_of('-');
+    if(sstart == std::string::npos || send == std::string::npos || sstart + 1 > send - 1) {
+        return devicePath.substr(0, sstart);
+    }
+    std::string object = devicePath.substr(sstart + 1, send - sstart - 1);
+    auto        ssend  = object.find_last_of('.');
+    if(ssend == std::string::npos) {
+        return devicePath.substr(0, sstart);
+    }
+    else {
+        return devicePath.substr(0, sstart) + "-" + object.substr(0, ssend);
+    }
+}
+
+#ifdef WIN32
+/*
+ *  	0x01516fe8 "\\\\?\\USB#VID_2BC5&PID_0633#6&3436DA6F&1&2#{A5DCBF10-6530-11D2-901F-00C04FB951ED}"
+ *    0x0152e920 "\\\\?\\USB#VID_2BC5&PID_0532#USB#{A5DCBF10-6530-11D2-901F-00C04FB951ED}"
+ */
+// Parse the following USB path format = \?usb#vid_vvvv&pid_pppp&mi_ii#aaaaaaaaaaaaaaaa#{gggggggg-gggg-gggg-gggg-gggggggggggg}
+// vvvv = USB vendor ID represented in 4 hexadecimal characters.
+// pppp = USB product ID represented in 4 hexadecimal characters.
+// ii = USB interface number.
+// aaaaaaaaaaaaaaaa = unique Windows-generated string based on things such as the physical USB port address and/or interface number.
+// gggggggg-gggg-gggg-gggg-gggggggggggg = device interface GUID assigned in the driver or driver INF file and is used to link applications to device with
+// specific drivers loaded.
+std::string getDeviceUidByWin(const std::string &devicePath) {
+    auto name   = utils::string::toLower(devicePath);
+    auto tokens = utils::string::tokenize(name, '#');
+    if(tokens.empty() || (tokens[0] != R"(\\?\usb)" && tokens[0] != R"(\\?\hid)"))
+        return "";  // Not a USB device
+    if(tokens.size() < 3) {
+        LOG_ERROR("malformed usb device path: {}", name);
+        return "";
+    }
+
+    auto ids = utils::string::tokenize(tokens[2], '&');
+    if(ids.empty()) {
+        LOG_ERROR("malformed id string: {}", tokens[2]);
+        return "";
+    }
+
+    if(ids.size() == 1) {
+        std::string TempId = tokens[2];
+        if(TempId.length() >= 11) {
+            return tokens[2];
+        }
+    }
+
+    if(ids.size() > 2) {
+        // uid = ids[1];
+        return utils::string::remove(tokens[2], "&");
+    }
+
+    return "";
+}
+
+std::string getDeviceUidByWinDeviceID(const std::string &deviceID) {
+    auto name   = utils::string::toLower(deviceID);
+    auto tokens = utils::string::tokenize(name, '\\');
+    if(tokens.empty() || tokens[0] != R"(usb)")
+        return "";  // Not a USB device
+    if(tokens.size() < 3) {
+        LOG_ERROR("malformed usb device path: {}", name);
+        return "";
+    }
+
+    auto ids = utils::string::tokenize(tokens[2], '&');
+    if(ids.empty()) {
+        LOG_ERROR("malformed id string: {}", tokens[2]);
+        return "";
+    }
+
+    if(ids.size() > 2)
+        return ids[1];
+    return "";
+}
+
+std::string getDeviceHubIdByWin(const std::string &devicePath) {
+    auto name   = utils::string::toLower(devicePath);
+    auto tokens = utils::string::tokenize(name, '#');
+    if(tokens.empty() || (tokens[0] != R"(\\?\usb)" && tokens[0] != R"(\\?\hid)"))
+        return "";  // Not a USB device
+    if(tokens.size() < 3) {
+        LOG_ERROR("malformed usb device path: {}", name);
+        return "";
+    }
+    return tokens[2];
+}
+#endif
+
+bool findSN2Toupper(const std::string &src, std::string &dst) {
+    auto name   = utils::string::toLower(src);
+    auto tokens = utils::string::tokenize(name, '#');
+    if(tokens.empty() || (tokens[0] != R"(\\?\usb)" && tokens[0] != R"(\\?\hid)"))
+        return false;  // Not a USB device
+    if(tokens.size() < 3) {
+        return false;
+    }
+
+    if(tokens[2].find("&") != std::string::npos) {
+        return false;
+    }
+
+    if(tokens[2].length() < 11) {
+        return false;
+    }
+
+    dst = utils::string::toUpper(tokens[2]);
+    return true;
+}
+
+std::string getStringDesc(libusb_device_handle *deviceHandle, uint8_t descIndex) {
+    if(descIndex == 0) {
+        throw invalid_value_exception("Invalid descriptor index");
+    }
+
+    char str[256];
+    auto rst = libusb_get_string_descriptor_ascii(deviceHandle, descIndex, reinterpret_cast<unsigned char *>(str), 256);  // get length
+    if(rst < 0) {
+        LOG_ERROR("Failed to get string descriptor: error={}", libusb_strerror(rst));
+        return "";
+    }
+    str[rst] = '\0';
+    return std::string(str);
+}
+
+// Get the sub-devices of a composite device.
+std::vector<UsbInterfaceInfo> queryInterfaces(libusb_device *device, libusb_device_descriptor desc) {
+#ifdef WIN32
+    std::string    hub_id;
+    libusb_device *parent_dev = libusb_get_parent(device);
+    if(parent_dev != nullptr) {
+        auto hub_dev_path = libusb_get_windows_path(parent_dev);
+        if(hub_dev_path) {
+            hub_id = getDeviceHubIdByWin(hub_dev_path);
+        }
+        // LOG_ERROR("hubid = " << hub_id;
+    }
+#endif
+
+    std::vector<UsbInterfaceInfo> rv;
+    for(uint8_t c = 0; c < desc.bNumConfigurations; ++c) {
+        libusb_config_descriptor *config = nullptr;
+        auto                      ret    = libusb_get_config_descriptor(device, c, &config);
+        if(LIBUSB_SUCCESS != ret) {
+            LOG_WARN("Failed to read USB config descriptor: error={}", ret);
+            continue;
+        }
+
+        for(uint8_t i = 0; i < config->bNumInterfaces; ++i) {
+            auto inf = config->interface[i];
+
+            if(inf.altsetting->bInterfaceClass == LIBUSB_CLASS_VIDEO && inf.altsetting->bInterfaceSubClass == 2) {
+                // 2 is for streaming interface class of video class
+                continue;
+            }
+
+            if(inf.altsetting->bInterfaceClass == LIBUSB_CLASS_APPLICATION || inf.altsetting->bInterfaceClass == LIBUSB_CLASS_HUB) {
+                continue;
+            }
+
+            UsbInterfaceInfo info{};
+            info.url = getDevicePath(device);
+            if(info.url.empty()) {
+                continue;
+            }
+            info.cls = inf.altsetting->bInterfaceClass;
+
+#ifdef WIN32
+            if(info.cls == LIBUSB_CLASS_HID) {
+                auto sub_composite_device_id = libusb_get_sub_composite_device_id(device, i);
+                if(sub_composite_device_id != nullptr) {
+                    info.uid = getDeviceUidByWinDeviceID(sub_composite_device_id);
+                }
+                auto interface_path = libusb_get_interface_path(device, i);
+                if(interface_path != nullptr) {
+                    info.infUrl = interface_path;
+                }
+            }
+            else {
+                auto interface_path = libusb_get_interface_path(device, i);
+                if(interface_path != nullptr) {
+                    info.infUrl = interface_path;
+                    info.uid    = getDeviceUidByWin(interface_path);
+                }
+                else if(config->bNumInterfaces == 1) {  // Non-composite equipment
+                    auto dev_path = libusb_get_windows_path(device);
+                    info.infUrl   = dev_path;
+                    if(dev_path != nullptr) {
+                        info.uid = getDeviceUidByWin(dev_path);
+                    }
+                }
+            }
+            info.hubId = hub_id;
+#else
+            info.infUrl = info.url + "." + std::to_string(i);
+
+            info.uid   = info.url;
+            info.hubId = getDeviceHubID(info.url);
+#endif
+
+            info.conn_spec        = static_cast<UsbSpec>(desc.bcdUSB);
+            info.vid              = desc.idVendor;
+            info.pid              = desc.idProduct;
+            info.infIndex         = inf.altsetting->bInterfaceNumber;
+            info.infNameDescIndex = inf.altsetting->iInterface;
+
+            rv.push_back(info);
+        }
+
+        libusb_free_config_descriptor(config);
+    }
+    return rv;
+}
+
+UsbDeviceLibusb::UsbDeviceLibusb(libusb_context *libusbCtx, std::shared_ptr<libusb_device_handle> handle) : libusbCtx_(libusbCtx), handle_(handle) {}
+
+libusb_device_handle *UsbDeviceLibusb::getLibusbDeviceHandle() const {
+    return handle_.get();
+}
+
+libusb_context *UsbDeviceLibusb::getLibusbContext() const {
+    return libusbCtx_;
+}
+
+libusb_endpoint_descriptor UsbDeviceLibusb::getEndpointDesc(int interfaceIndex, libusb_endpoint_transfer_type transferType,
+                                                            libusb_endpoint_direction direction) const {
+    libusb_device_handle    *handle = getLibusbDeviceHandle();
+    libusb_device           *device = libusb_get_device(handle);
+    libusb_device_descriptor desc;
+    auto                     ret = libusb_get_device_descriptor(device, &desc);
+    if(ret != LIBUSB_SUCCESS) {
+        throw io_exception(utils::string::to_string() << "Failed to read USB device descriptor: error=" << libusb_strerror(ret));
+    }
+
+    libusb_endpoint_descriptor ep    = { 0 };
+    bool                       found = false;
+    for(uint8_t c = 0; c < desc.bNumConfigurations; ++c) {
+        libusb_config_descriptor *config = nullptr;
+        ret                              = libusb_get_config_descriptor(device, c, &config);
+        if(ret != LIBUSB_SUCCESS) {
+            LOG_WARN("Failed to read USB config descriptor: error={}", libusb_strerror(ret));
+        }
+
+        if(config->bNumInterfaces <= interfaceIndex) {
+            continue;
+        }
+
+        auto inf = config->interface[interfaceIndex].altsetting;
+
+        for(uint8_t i = 0; i < inf->bNumEndpoints; ++i) {
+            ep = inf->endpoint[i];
+            if((ep.bmAttributes & LIBUSB_TRANSFER_TYPE_MASK) == transferType && (ep.bEndpointAddress & LIBUSB_ENDPOINT_DIR_MASK) == direction) {
+                found = true;
+                break;
+            }
+        }
+        libusb_free_config_descriptor(config);
+    }
+    if(!found) {
+        throw io_exception("Can not find interface to get endpoint address");
+    }
+    return ep;
+}
+
+std::weak_ptr<IUsbEnumerator> IUsbEnumerator::instanceWeakPtr_;
+std::mutex                    IUsbEnumerator::instanceMutex_;
+
+std::shared_ptr<IUsbEnumerator> IUsbEnumerator::getInstance() {
+    std::lock_guard<std::mutex> lock(instanceMutex_);
+    auto                        instance = instanceWeakPtr_.lock();
+    if(!instance) {
+        instance         = std::shared_ptr<UsbEnumeratorLibusb>(new UsbEnumeratorLibusb());
+        instanceWeakPtr_ = instance;
+    }
+    return instance;
+}
+
+UsbEnumeratorLibusb::UsbEnumeratorLibusb() {
+#ifdef __ANDROID__
+    auto rc = libusb_set_option(ctx_, LIBUSB_OPTION_WEAK_AUTHORITY, NULL);
+    if(rc != LIBUSB_SUCCESS) {
+        LOG_ERROR("libusb set option LIBUSB_OPTION_WEAK_AUTHORITY failed!");
+        throw std::runtime_error("libusb set option LIBUSB_OPTION_WEAK_AUTHORITY failed");
+    }
+#endif
+
+    auto sts = libusb_init(&libusbCtx_);
+    if(sts != LIBUSB_SUCCESS) {
+        LOG_ERROR("libusb_init failed");
+    }
+
+    startEventHandleThread();
+    LOG_DEBUG("UsbEnumeratorLibusb created");
+}
+
+UsbEnumeratorLibusb::~UsbEnumeratorLibusb() noexcept {
+    stopEventHandleThread();
+    libusb_exit(libusbCtx_);
+    LOG_DEBUG("UsbEnumeratorLibusb destroyed");
+}
+
+const std::vector<UsbInterfaceInfo> &UsbEnumeratorLibusb::queryUsbInterfaces() {
+    std::vector<UsbInterfaceInfo> tempInfoList;
+    libusb_device               **devList;
+    auto                          count = libusb_get_device_list(libusbCtx_, &devList);
+    for(ssize_t i = 0; i < count; ++i) {
+        auto                     device = devList[i];
+        libusb_device_descriptor desc{};
+        auto                     ret = libusb_get_device_descriptor(device, &desc);
+        if(ret != LIBUSB_SUCCESS) {
+            LOG_DEBUG("Failed to read USB device descriptor: error={}", libusb_strerror(ret));
+            continue;
+        }
+
+        if(desc.idVendor != ORBBEC_USB_VID) {  // filter out non-orbbec devices
+            continue;
+        }
+
+        // todo: remove interface info from devInterfaceList_ when device is removed
+        auto path  = getDevicePath(device);
+        bool found = false;
+        for(auto devInfoIter = devInterfaceList_.begin(); devInfoIter != devInterfaceList_.end();) {
+            if(devInfoIter->url == path) {
+                tempInfoList.push_back(*devInfoIter);
+                found = true;
+            }
+            ++devInfoIter;
+        }
+        if(found) {
+            continue;
+        }
+
+        libusb_device_handle *handle = nullptr;
+        auto                  rst    = libusb_open(device, &handle);
+        if(rst != LIBUSB_SUCCESS) {
+            LOG_WARN("Failed to open USB device: error={}", libusb_strerror(rst));
+            continue;
+        }
+
+        std::string serial;
+        try {
+            serial = getStringDesc(handle, desc.iSerialNumber);
+        }
+        catch(const std::exception &e) {
+            LOG_ERROR("Failed to query USB device serial number: {}", e.what());
+            serial = "";
+        }
+
+        auto infs = queryInterfaces(device, desc);
+        for(auto &inf: infs) {
+#ifdef WIN32
+            if(serial.empty()) {
+                std::string toupperSNStr;
+                if(findSN2Toupper(inf.url, toupperSNStr)) {
+                    serial = toupperSNStr;
+                }
+            }
+#endif
+            inf.serial  = serial;
+            inf.infName = getStringDesc(handle, inf.infNameDescIndex);
+            tempInfoList.push_back(inf);
+        }
+
+        libusb_close(handle);
+    }
+
+    libusb_free_device_list(devList, 1);
+
+    LOG_DEBUG("queryUsbInterfaces done!");
+
+    devInterfaceList_ = tempInfoList;
+    return devInterfaceList_;
+}
+
+std::shared_ptr<IUsbDevice> UsbEnumeratorLibusb::openUsbDevice(const std::string &devUrl) {
+    uint8_t retry = 1;
+    do {
+        std::shared_ptr<libusb_device_handle> devHandle;
+        BEGIN_TRY_EXECUTE({ devHandle = openLibusbDevice(devUrl); })
+        CATCH_EXCEPTION_AND_EXECUTE({ continue; })
+        auto dev = std::make_shared<UsbDeviceLibusb>(libusbCtx_, devHandle);
+        return dev;
+    } while(retry--);
+
+    if(retry == 0) {
+        throw io_exception(utils::string::to_string() << "Can not open device: " << devUrl);
+    }
+
+    return nullptr;
+}
+
+void UsbEnumeratorLibusb::startEventHandleThread() {
+    LOG_DEBUG("UsbContext::startEventHandler()");
+    libusbEventHandlerExit_   = 0;
+    libusbEventHandlerThread_ = std::thread([&]() {
+        while(!libusbEventHandlerExit_) {
+            auto rc = libusb_handle_events_completed(libusbCtx_, &libusbEventHandlerExit_);
+            if(rc != LIBUSB_SUCCESS) {
+                LOG_WARN_INTVL("libusb_handle_events_completed failed: {}", libusb_strerror(rc));
+            }
+        }
+    });
+}
+
+void UsbEnumeratorLibusb::stopEventHandleThread() {
+    LOG_DEBUG("UsbContext::stopEventHandler()");
+    libusbEventHandlerExit_ = 1;
+    libusb_interrupt_event_handler(libusbCtx_);
+    if(libusbEventHandlerThread_.joinable()) {
+        libusbEventHandlerThread_.join();
+    }
+}
+
+std::shared_ptr<libusb_device_handle> UsbEnumeratorLibusb::openLibusbDevice(const std::string &devUrl) {
+    std::shared_ptr<libusb_device_handle> devHandle;
+    std::unique_lock<std::mutex>          lock(libusbDeviceHandleMutex_);
+
+    // check expired weak_ptr
+    for(auto iter = libusbDeviceHandles_.begin(); iter != libusbDeviceHandles_.end();) {
+        auto handle = iter->second.lock();
+        if(!handle) {
+            iter = libusbDeviceHandles_.erase(iter);
+            continue;
+        }
+        if(iter->first == devUrl) {
+            devHandle = handle;
+            // break; // do not break, continue to check and clear expired weak_ptr
+        }
+        iter++;
+    }
+
+    if(devHandle) {
+        return devHandle;
+    }
+
+    // open device handle
+
+    libusb_device **devList = nullptr;
+    auto            count   = libusb_get_device_list(libusbCtx_, &devList);
+    if(count <= 0) {
+        throw invalid_value_exception(utils::string::to_string() << "Get device list return 0, can not open device: " << devUrl);
+    }
+
+    for(int i = 0; i < count; i++) {
+        libusb_device *device = devList[i];
+        auto           path   = getDevicePath(device);
+        if(path == devUrl) {
+            libusb_device_handle *handle = nullptr;
+            auto                  rst    = libusb_open(device, &handle);
+            if(rst != LIBUSB_SUCCESS) {
+                libusb_free_device_list(devList, 1);
+
+                throw invalid_value_exception(utils::string::to_string() << "Open device failed: " << libusb_strerror(rst));
+            }
+
+            devHandle = std::shared_ptr<libusb_device_handle>(handle, [this, devUrl](libusb_device_handle *handle) {
+                std::unique_lock<std::mutex> lock(libusbDeviceHandleMutex_);
+                libusb_close(handle);
+                libusbDeviceHandles_.erase(devUrl);
+            });
+
+            libusbDeviceHandles_[devUrl] = devHandle;
+            break;
+        }
+    }
+
+    libusb_free_device_list(devList, 1);
+
+    if(!devHandle) {
+        throw invalid_value_exception(utils::string::to_string() << "Can not open device: " << devUrl);
+    }
+
+    return devHandle;
+}
+
+}  // namespace libobsensor
+#endif  // __ANDROID__
diff --git a/src/platform/usb/enumerator/UsbEnumeratorLibusb.hpp b/src/platform/usb/enumerator/UsbEnumeratorLibusb.hpp
new file mode 100644
index 00000000..12057bd9
--- /dev/null
+++ b/src/platform/usb/enumerator/UsbEnumeratorLibusb.hpp
@@ -0,0 +1,61 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+
+#ifndef __ANDROID__
+
+#include "UsbTypes.hpp"
+
+#include <memory>
+#include <vector>
+#include <thread>
+#include <mutex>
+
+#include <libusb.h>
+#include "IUsbEnumerator.hpp"
+
+namespace libobsensor {
+
+class UsbDeviceLibusb : public IUsbDevice {
+public:
+    UsbDeviceLibusb(libusb_context *libusbCtx, std::shared_ptr<libusb_device_handle> handle);
+    virtual ~UsbDeviceLibusb() noexcept = default;
+
+    libusb_device_handle *getLibusbDeviceHandle() const;
+    libusb_context *getLibusbContext() const;
+    libusb_endpoint_descriptor getEndpointDesc(int interfaceIndex, libusb_endpoint_transfer_type transferType, libusb_endpoint_direction direction) const;
+
+private:
+    libusb_context                       *libusbCtx_;
+    std::shared_ptr<libusb_device_handle> handle_;
+};
+
+class UsbEnumeratorLibusb : public IUsbEnumerator {
+public:
+    UsbEnumeratorLibusb();
+    ~UsbEnumeratorLibusb() noexcept;
+
+    const std::vector<UsbInterfaceInfo> &queryUsbInterfaces() override;
+
+    std::shared_ptr<IUsbDevice> openUsbDevice(const std::string &devUrl) override;
+
+private:
+    void                                  startEventHandleThread();
+    void                                  stopEventHandleThread();
+    std::shared_ptr<libusb_device_handle> openLibusbDevice(const std::string &devUrl);
+
+private:
+    std::vector<UsbInterfaceInfo> devInterfaceList_;
+
+    libusb_context *libusbCtx_;
+    std::thread     libusbEventHandlerThread_;
+    int             libusbEventHandlerExit_ = 0;
+
+    std::mutex                                                 libusbDeviceHandleMutex_;
+    std::map<std::string, std::weak_ptr<libusb_device_handle>> libusbDeviceHandles_;
+};
+
+}  // namespace libobsensor
+
+#endif  // __ANDROID__
diff --git a/src/platform/usb/enumerator/UsbTypes.cpp b/src/platform/usb/enumerator/UsbTypes.cpp
new file mode 100644
index 00000000..84f89f9e
--- /dev/null
+++ b/src/platform/usb/enumerator/UsbTypes.cpp
@@ -0,0 +1,39 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "UsbTypes.hpp"
+#include <libusb.h>
+namespace libobsensor {
+
+const std::map<UsbSpec, std::string> usb_spec_names = {
+    { usb_undefined, "USB" },  { usb1_type, "USB1.0" }, { usb1_1_type, "USB1.1" }, { usb2_type, "USB2.0" },
+    { usb2_1_type, "USB2.1" }, { usb3_type, "USB3.0" }, { usb3_1_type, "USB3.1" }, { usb3_2_type, "USB3.2" }
+};
+std::string usbSpecToString(UsbSpec spec) {
+    if(spec == gmsl2_type) {
+        return "GMSL2";
+    }
+    std::string name = "USB";
+    auto        it   = usb_spec_names.find(spec);
+    if(it != usb_spec_names.end()) {
+        name = it->second;
+    }
+    return name;
+}
+
+SourcePortType cvtUsbClassToPortType(uint8_t cls) {
+    switch(static_cast<libusb_class_code>(cls)) {
+    case LIBUSB_CLASS_HID:
+        return SOURCE_PORT_USB_HID;
+    case LIBUSB_CLASS_VIDEO:
+        return SOURCE_PORT_USB_UVC;
+    case LIBUSB_CLASS_VENDOR_SPEC:
+        return SOURCE_PORT_USB_VENDOR;
+    default:
+        break;
+    }
+    return SOURCE_PORT_UNKNOWN;
+}
+
+}  // namespace libobsensor
+
diff --git a/src/platform/usb/enumerator/UsbTypes.hpp b/src/platform/usb/enumerator/UsbTypes.hpp
new file mode 100644
index 00000000..f45463b4
--- /dev/null
+++ b/src/platform/usb/enumerator/UsbTypes.hpp
@@ -0,0 +1,60 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include "ISourcePort.hpp"
+
+// #include <libusb.h>
+
+#include <map>
+#include <sstream>
+
+#define ORBBEC_USB_VID 0x2BC5
+
+namespace libobsensor {
+typedef enum {
+    OB_USB_CLASS_UNSPECIFIED          = 0x00,
+    OB_USB_CLASS_AUDIO                = 0x01,
+    OB_USB_CLASS_COM                  = 0x02,
+    OB_USB_CLASS_HID                  = 0x03,
+    OB_USB_CLASS_PID                  = 0x05,
+    OB_USB_CLASS_IMAGE                = 0x06,
+    OB_USB_CLASS_PRINTER              = 0x07,
+    OB_USB_CLASS_MASS_STORAGE         = 0x08,
+    OB_USB_CLASS_HUB                  = 0x09,
+    OB_USB_CLASS_CDC_DATA             = 0x0A,
+    OB_USB_CLASS_SMART_CARD           = 0x0B,
+    OB_USB_CLASS_CONTENT_SECURITY     = 0x0D,
+    OB_USB_CLASS_VIDEO                = 0x0E,
+    OB_USB_CLASS_PHDC                 = 0x0F,
+    OB_USB_CLASS_AV                   = 0x10,
+    OB_USB_CLASS_BILLBOARD            = 0x11,
+    OB_USB_CLASS_DIAGNOSTIC_DEVICE    = 0xDC,
+    OB_USB_CLASS_WIRELESS_CONTROLLER  = 0xE0,
+    OB_USB_CLASS_MISCELLANEOUS        = 0xEF,
+    OB_USB_CLASS_APPLICATION_SPECIFIC = 0xFE,
+    OB_USB_CLASS_VENDOR_SPECIFIC      = 0xFF
+} UsbClass;
+
+typedef enum { OB_USB_ENDPOINT_DIRECTION_WRITE = 0, OB_USB_ENDPOINT_DIRECTION_READ = 0x80 } EndpointDirection;
+
+// Binary-coded decimal represent the USB specification to which the UVC device
+// complies
+typedef enum {
+    usb_undefined = 0,
+    usb1_type     = 0x0100,
+    usb1_1_type   = 0x0110,
+    usb2_type     = 0x0200,
+    usb2_1_type   = 0x0210,
+    usb3_type     = 0x0300,
+    usb3_1_type   = 0x0310,
+    usb3_2_type   = 0x0320,
+    gmsl2_type    = 0x2000,
+} UsbSpec;
+
+std::string usbSpecToString(UsbSpec spec);
+
+SourcePortType cvtUsbClassToPortType(uint8_t cls);
+
+}  // namespace libobsensor
diff --git a/src/platform/usb/hid/CMakeLists.txt b/src/platform/usb/hid/CMakeLists.txt
new file mode 100644
index 00000000..670bc989
--- /dev/null
+++ b/src/platform/usb/hid/CMakeLists.txt
@@ -0,0 +1,13 @@
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+cmake_minimum_required(VERSION 3.5)
+
+target_sources(${OB_TARGET_PAL} PRIVATE "${CMAKE_CURRENT_LIST_DIR}/HidDevicePort.cpp")
+target_sources(${OB_TARGET_PAL} PRIVATE "${CMAKE_CURRENT_LIST_DIR}/HidDevicePort.hpp")
+
+if(OB_BUILD_GMSL_PAL AND OB_BUILD_LINUX)
+    target_sources(${OB_TARGET_PAL} PRIVATE "${CMAKE_CURRENT_LIST_DIR}/HidDevicePortGmsl.hpp")
+    target_sources(${OB_TARGET_PAL} PRIVATE "${CMAKE_CURRENT_LIST_DIR}/HidDevicePortGmsl.cpp")
+endif()
+
diff --git a/src/platform/usb/hid/HidDevicePort.cpp b/src/platform/usb/hid/HidDevicePort.cpp
new file mode 100644
index 00000000..1d164d66
--- /dev/null
+++ b/src/platform/usb/hid/HidDevicePort.cpp
@@ -0,0 +1,101 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "HidDevicePort.hpp"
+
+#include "frame/FrameFactory.hpp"
+#include "logger/Logger.hpp"
+#include "logger/LoggerInterval.hpp"
+#include "utils/Utils.hpp"
+#include "usb/enumerator/UsbEnumeratorLibusb.hpp"
+
+namespace libobsensor {
+HidDevicePort::HidDevicePort(const std::shared_ptr<IUsbDevice> &usbDevice, std::shared_ptr<const USBSourcePortInfo> portInfo)
+    : portInfo_(portInfo), usbDevice_(usbDevice), isStreaming_(false), frameQueue_(10) {
+
+    auto libusbDevice = std::dynamic_pointer_cast<UsbDeviceLibusb>(usbDevice_);
+    auto epDesc       = libusbDevice->getEndpointDesc(portInfo->infIndex, LIBUSB_ENDPOINT_TRANSFER_TYPE_INTERRUPT, LIBUSB_ENDPOINT_IN);
+    endpointAddress_  = epDesc.bEndpointAddress;
+    maxPacketSize_    = epDesc.wMaxPacketSize;
+
+    auto libusbDevHandle = libusbDevice->getLibusbDeviceHandle();
+    if(libusb_kernel_driver_active(libusbDevHandle, portInfo->infIndex) == 1) {
+        auto res = libusb_detach_kernel_driver(libusbDevHandle, portInfo->infIndex);
+        if(res != LIBUSB_SUCCESS) {
+            throw io_exception("detach kernel driver failed, error: " + std::string(libusb_strerror(res)));
+        }
+    }
+    auto res = libusb_claim_interface(libusbDevHandle, portInfo->infIndex);
+    if(res != LIBUSB_SUCCESS) {
+        throw io_exception("claim interface failed, error: " + std::string(libusb_strerror(res)));
+    }
+    LOG_DEBUG("HidDevicePort::HidDevicePort done");
+}
+
+HidDevicePort::~HidDevicePort() noexcept {
+    if(isStreaming_) {
+        frameQueue_.stop();
+        stopStream();
+    }
+
+    auto libusbDevice    = std::dynamic_pointer_cast<UsbDeviceLibusb>(usbDevice_);
+    auto libusbDevHandle = libusbDevice->getLibusbDeviceHandle();
+
+    auto res = libusb_release_interface(libusbDevHandle, portInfo_->infIndex);
+    if(res != LIBUSB_SUCCESS) {
+        LOG_WARN("release interface failed, error: {}", libusb_strerror(res));
+    }
+    if(libusb_kernel_driver_active(libusbDevHandle, portInfo_->infIndex) == 1) {
+        res = libusb_attach_kernel_driver(libusbDevHandle, portInfo_->infIndex);
+        if(res != LIBUSB_SUCCESS) {
+            LOG_WARN("attach kernel driver failed, error: {}", libusb_strerror(res));
+        }
+    }
+    LOG_DEBUG("HidDevicePort::~HidDevicePort done");
+}
+
+void HidDevicePort::startStream(MutableFrameCallback callback) {
+    if(isStreaming_) {
+        throw wrong_api_call_sequence_exception("HidDevicePort::startStream() called while streaming");
+    }
+    isStreaming_ = true;
+    frameQueue_.start(callback);
+
+    streamThread_ = std::thread([this]() {
+        auto libusbDevice    = std::dynamic_pointer_cast<UsbDeviceLibusb>(usbDevice_);
+        auto libusbDevHandle = libusbDevice->getLibusbDeviceHandle();
+        while(isStreaming_) {
+            auto frame = FrameFactory::createFrame(OB_FRAME_UNKNOWN, OB_FORMAT_UNKNOWN, maxPacketSize_);
+            int  transferred;
+            auto res = libusb_interrupt_transfer(libusbDevHandle, endpointAddress_, frame->getDataMutable(), static_cast<int>(frame->getDataSize()),
+                                                 &transferred, 1000);
+            if(res != LIBUSB_SUCCESS && isStreaming_) {
+                LOG_WARN_INTVL(utils::string::to_string() << "interrupt transfer failed, error: " << libusb_strerror(res));
+                continue;
+            }
+            auto realtime = utils::getNowTimesUs();
+            frame->setSystemTimeStampUsec(realtime);
+            frameQueue_.enqueue(frame);
+        }
+    });
+    LOG_DEBUG("HidDevicePort::startStream done");
+}
+
+void HidDevicePort::stopStream() {
+    if(!isStreaming_) {
+        throw wrong_api_call_sequence_exception("HidDevicePort::stopStream() called while not streaming");
+    }
+    isStreaming_ = false;
+
+    streamThread_.join();
+    frameQueue_.flush();
+
+    LOG_DEBUG("HidDevicePort::stopStream done");
+}
+
+std::shared_ptr<const SourcePortInfo> HidDevicePort::getSourcePortInfo() const {
+    return portInfo_;
+}
+
+}  // namespace libobsensor
+
diff --git a/src/platform/usb/hid/HidDevicePort.hpp b/src/platform/usb/hid/HidDevicePort.hpp
new file mode 100644
index 00000000..79040c69
--- /dev/null
+++ b/src/platform/usb/hid/HidDevicePort.hpp
@@ -0,0 +1,34 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include "ISourcePort.hpp"
+#include "frame/FrameQueue.hpp"
+#include "usb/enumerator/IUsbEnumerator.hpp"
+
+namespace libobsensor {
+
+class HidDevicePort : public IDataStreamPort {
+public:
+    HidDevicePort(const std::shared_ptr<IUsbDevice> &usbDevice, std::shared_ptr<const USBSourcePortInfo> portInfo);
+    ~HidDevicePort() noexcept override;
+
+    void startStream(MutableFrameCallback callback) override;
+    void stopStream() override;
+
+    std::shared_ptr<const SourcePortInfo> getSourcePortInfo() const override;
+
+private:
+    std::shared_ptr<const USBSourcePortInfo> portInfo_;
+    std::shared_ptr<IUsbDevice>              usbDevice_;
+    uint8_t                                  endpointAddress_;
+    uint16_t                                 maxPacketSize_;
+
+    std::atomic_bool  isStreaming_;
+    FrameQueue<Frame> frameQueue_;
+
+    std::thread streamThread_;
+};
+
+}  // namespace libobsensor
+
diff --git a/src/platform/usb/hid/HidDevicePortGmsl.cpp b/src/platform/usb/hid/HidDevicePortGmsl.cpp
new file mode 100644
index 00000000..3f80ad45
--- /dev/null
+++ b/src/platform/usb/hid/HidDevicePortGmsl.cpp
@@ -0,0 +1,301 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "HidDevicePortGmsl.hpp"
+#include "usb/uvc/ObV4lGmslHostProtocolTypes.hpp"
+
+#include "logger/Logger.hpp"
+#include "utils/Utils.hpp"
+#include "exception/ObException.hpp"
+#include "frame/FrameFactory.hpp"
+
+#include <fcntl.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <errno.h>
+#include <string.h>
+#include <sys/ioctl.h>
+
+#include <linux/uvcvideo.h>
+#include <linux/videodev2.h>
+#include <linux/usb/video.h>
+
+#include <iostream>
+#include <thread>
+#include <chrono>
+#include <random>
+
+namespace libobsensor {
+
+const int IMU_FRAME_MAX_NUM  = 9;  // 5;
+const int IMU_RETRY_READ_NUM = 30;
+const int POLL_INTERVAL      = 10;  // poll interval time
+
+/**
+ * cal: 1*1000/fps * (IMU_FRAME_MAX_NUM-4)
+ */
+int calculateImuPollInterval(int mImuReadFps) {
+    int delayTime = 0;
+    delayTime     = (1000 / mImuReadFps) * (IMU_FRAME_MAX_NUM - 4);
+    LOG_DEBUG("calculateImuPollInterval:{}, mImuReadFps:{}", delayTime, mImuReadFps);
+    if(delayTime < 5)
+        delayTime = 5;
+
+    // LOG_DEBUG("-calculateImuPollInterval-2: {} ", delayTime );
+    return delayTime;
+}
+
+/**
+ * 500HZ
+ * 1*1000/fps * (IMU_FRAME_MAX_NUM-1) -10ms
+ */
+int calculateImuPollInterval500HZ(int mImuReadFps) {
+    int delayTime = 0;
+    delayTime     = (1000 / mImuReadFps) * (IMU_FRAME_MAX_NUM - 1) - 10;
+    LOG_DEBUG("calculateImuPollInterval500HZ:{}, mImuReadFps:{}", delayTime, mImuReadFps);
+    if(delayTime < 5)
+        delayTime = 5;
+
+    // LOG_DEBUG("-calculateImuPollInterval-2: {} ", delayTime );
+    return delayTime;
+}
+
+void imuSleepMs(int mSleepMs) {
+    // utils::sleepMs(mSleepMs);
+    std::this_thread::sleep_for(std::chrono::milliseconds(mSleepMs));
+}
+
+HidDevicePortGmsl::HidDevicePortGmsl(std::shared_ptr<const USBSourcePortInfo> portInfo) : portInfo_(portInfo), isStreaming_(false), frameQueue_(10) {
+    imu_fd_ = open(portInfo_->infName.c_str(), O_RDWR);
+    if(imu_fd_ < 0) {
+        throw pal_exception(utils::string::to_string() << "HidDevicePortGmsl() openDev failed, errno: " << errno << " " << strerror(errno));
+    }
+    LOG_DEBUG("HidDevicePortGmsl() imu_fd_:{}", imu_fd_);
+}
+
+HidDevicePortGmsl::~HidDevicePortGmsl() noexcept {
+    LOG_DEBUG("~HidDevicePortGmsl()");
+    stopStream();
+    if(imu_fd_ >= 0) {
+        close(imu_fd_);
+    }
+    imuSleepMs(100);  // sleep 100ms to wait backend release resource
+    LOG_DEBUG("HidDevicePortGmsl destroyed");
+}
+
+std::shared_ptr<const SourcePortInfo> HidDevicePortGmsl::getSourcePortInfo() const {
+    return portInfo_;
+}
+
+void HidDevicePortGmsl::startStream(MutableFrameCallback callback) {
+    LOG_DEBUG("Try to start stream");
+    imuRetryReadNum = IMU_RETRY_READ_NUM;  // default 10
+    imuReadFps      = 200;                 // default 200Hz
+    imuPollInterval = 25;                  // default 25ms
+
+    if(isStreaming_) {
+        throw wrong_api_call_sequence_exception("HidDevicePort::startStream() called while streaming");
+    }
+    isStreaming_ = true;
+    frameQueue_.start(callback);
+
+    // init poll thread
+    pollThread_ = std::thread([this]() {
+        while(true) {
+            if(!isStreaming_) {
+                break;
+            }
+            if(imuRetryReadNum > 0) {
+                imuReadFps      = getImuFps();
+                imuPollInterval = (imuReadFps >= 500) ? 5 : calculateImuPollInterval(imuReadFps);
+                LOG_DEBUG("get current imuReadFps:{}, imuPollInterval:{}ms, imuRetryReadNum:{} ", imuReadFps, imuPollInterval, imuRetryReadNum);
+                imuRetryReadNum--;
+            }
+            imuSleepMs(imuPollInterval);
+            pollData();
+        }
+    });
+    LOG_DEBUG("HidDevicePortGmsl::startCapture done");
+}
+
+void HidDevicePortGmsl::stopStream() {
+    if(!isStreaming_) {
+        LOG_WARN("stopStream() called while not streaming");
+        return;
+    }
+    LOG_DEBUG("stopCapture start");
+    isStreaming_ = false;
+    if(pollThread_.joinable()) {
+        pollThread_.join();
+    }
+    LOG_DEBUG("release frameQueue");
+    frameQueue_.flush();
+    LOG_DEBUG("frameQueue_.flush");
+    frameQueue_.reset();
+    LOG_DEBUG("stopCapture done");
+}
+
+// Original imu data, software packaging method, needs to be calculated on the sdk side
+typedef struct {
+    uint8_t  reportId;    // Firmware fixed transmission 1
+    uint8_t  sampleRate;  // OB_SAMPLE_RATE
+    uint8_t  groupLen;    // sizeof(OBImuOriginData)
+    uint8_t  groupCount;  // How many frames of data are in a packet.
+    uint32_t reserved;    // reserve
+} OBImuHeader;
+
+typedef struct {
+    int16_t  groupId;  // The number of groups in a pack
+    int16_t  accelX;
+    int16_t  accelY;
+    int16_t  accelZ;
+    int16_t  gyroX;
+    int16_t  gyroY;
+    int16_t  gyroZ;
+    int16_t  temperature;
+    uint32_t timestamp[2];
+} OBImuOriginData;
+
+typedef struct {
+    OBImuHeader     imuHeader;                        // imuHeader
+    OBImuOriginData imuFrameData[IMU_FRAME_MAX_NUM];  // OBImuOriginData
+    uint32_t        reserved;                         // Reserved
+} OBImuOrigMsg;
+
+void HidDevicePortGmsl::pollData() {
+    int groupCount = 0;
+    // LOG_DEBUG("HidDevicePortGmsl::pollData start...");
+    auto frame = FrameFactory::createFrame(OB_FRAME_UNKNOWN, OB_FORMAT_UNKNOWN, sizeof(OBImuOrigMsg));
+
+    OBImuOrigMsg *imuOrigFrameMsg = reinterpret_cast<OBImuOrigMsg *>(frame->getDataMutable());
+    memset(imuOrigFrameMsg, 0, sizeof(OBImuOrigMsg));
+    imuOrigFrameMsg->imuHeader.reportId   = 1;
+    imuOrigFrameMsg->imuHeader.sampleRate = 200;
+    imuOrigFrameMsg->imuHeader.groupLen   = sizeof(OBImuOriginData);
+    imuOrigFrameMsg->imuHeader.groupCount = 1;
+    imuOrigFrameMsg->imuHeader.reserved   = 0;
+    imuOrigFrameMsg->reserved             = 0;
+
+    uint8_t imuFrameMaxSize = sizeof(OBImuOriginData) * (IMU_FRAME_MAX_NUM) + sizeof(i2c_msg_header_t) + sizeof(uint16_t);
+    auto                 bufferSize      = std::max(sizeof(i2c_msg_t), static_cast<size_t>(imuFrameMaxSize));
+    std::vector<uint8_t> databuf(bufferSize, 0);
+    int                  size = getImuData(databuf.data());
+
+    if(size < 0) {
+        LOG_ERROR("read getImuData failed! ret:{} \n", size);
+        return;
+    }
+
+    auto *mOriginI2CMsg = reinterpret_cast<i2c_msg_t *>(&databuf[0]);
+    int   mOnceReadLen  = mOriginI2CMsg->header.len;
+    // LOG_DEBUG("-read imu data header.len: {}", mOnceReadLen );
+
+    if((mOriginI2CMsg->body.res == 0x00) && (mOnceReadLen > 8)) {
+        groupCount = (mOnceReadLen - 8) / sizeof(OBImuOriginData);
+        // LOG_DEBUG("-read imu data groupCount:{}, header.len:{}, imuPollInterval:{}ms ", groupCount, mOnceReadLen, imuPollInterval);
+
+        if(groupCount > 0) {
+            imuOrigFrameMsg->imuHeader.groupCount = groupCount;
+            int imuOriginHeaderOffset             = sizeof(i2c_msg_header_t) + 2 /*res*/;
+
+            auto *tmp = reinterpret_cast<imu_origin_data_t *>(&databuf[imuOriginHeaderOffset]);
+
+#if 0  // for test debug
+            LOG_DEBUG("-> group_id: {}  ", tmp->group_id);
+            LOG_DEBUG("-> accel_x:  {}  ", tmp->accel_x);
+            LOG_DEBUG("-> accel_y:  {}  ", tmp->accel_y);
+            LOG_DEBUG("-> accel_z:  {}  ", tmp->accel_z);
+            LOG_DEBUG("-> gyro_x:   {}  ", tmp->gyro_x);
+            LOG_DEBUG("-> gyro_y:   {}  ", tmp->gyro_y);
+            LOG_DEBUG("-> gyro_z:   {}  ", tmp->gyro_z);
+            LOG_DEBUG("-> temp:     {}  ", tmp->temp);
+            LOG_DEBUG("-> timestamp[0]: {}  ", tmp->timestamp[0]);
+            LOG_DEBUG("-> timestamp[1]: {}  \n", tmp->timestamp[1]);
+#endif
+
+            memcpy(imuOrigFrameMsg->imuFrameData, tmp, sizeof(imu_origin_data_t) * groupCount);
+
+#if 0  // for test debug
+            for(int i=0; i< groupCount; i++) {
+                LOG_DEBUG("->{} groupId: {}  ", i, imuOrigFrameMsg.imuFrameData[i].groupId);
+                LOG_DEBUG("->{} accelX:  {}  ", i, imuOrigFrameMsg.imuFrameData[i].accelX);
+                LOG_DEBUG("->{} accelY:  {}  ", i, imuOrigFrameMsg.imuFrameData[i].accelY);
+                LOG_DEBUG("->{} accelZ:  {}  ", i, imuOrigFrameMsg.imuFrameData[i].accelZ);
+                LOG_DEBUG("->{} gyroX:   {}  ", i, imuOrigFrameMsg.imuFrameData[i].gyroX);
+                LOG_DEBUG("->{} gyroY:   {}  ", i, imuOrigFrameMsg.imuFrameData[i].gyroY);
+                LOG_DEBUG("->{} gyroZ:   {}  ", i, imuOrigFrameMsg.imuFrameData[i].gyroZ);
+                LOG_DEBUG("->{} temperature:  {}  ", i, imuOrigFrameMsg.imuFrameData[i].temperature);
+                LOG_DEBUG("->{} timestamp[0]: {}  ", i, imuOrigFrameMsg.imuFrameData[i].timestamp[0]);
+                LOG_DEBUG("->{} timestamp[1]: {}  \n", i, imuOrigFrameMsg.imuFrameData[i].timestamp[1]);
+            }
+#endif
+            auto realtime = utils::getNowTimesUs();
+            frame->setSystemTimeStampUsec(realtime);
+            frameQueue_.enqueue(frame);
+        }
+        else {
+            LOG_DEBUG("read imu data groupCount is 0 ");
+        }
+    }
+}
+
+int HidDevicePortGmsl::getImuFps() {
+    int      ret  = 0;
+    uint32_t size = 0;
+
+    v4l2_ext_controls ctrls;
+    v4l2_ext_control  ctrl;
+    memset(&ctrls, 0, sizeof(ctrls));
+    memset(&ctrl, 0, sizeof(ctrl));
+    ctrls.ctrl_class = V4L2_CTRL_CLASS_CAMERA;
+    ctrls.controls   = &ctrl;
+    ctrls.count      = 1;
+
+    ctrl.id    = ORBBEC_CAMERA_CID_GET_IMU_FPS;
+    ctrl.size  = 4;
+    ctrl.p_u32 = &size;
+    {
+        std::unique_lock<std::mutex> lk(mMultiThreadI2CMutex);
+        ret = xioctlGmsl(imu_fd_, VIDIOC_G_EXT_CTRLS, &ctrls);
+    }
+    if(ret < 0) {
+        LOG_ERROR("{}:{} ioctl failed on getdate errno:{}, strerror:{} \n ", __FILE__, __LINE__, errno, strerror(errno));
+        return -1;
+    }
+
+    if((size == 0) || (size < 50)) {
+        size = 200;  // default 200HZ
+    }
+
+    return size;
+}
+
+int HidDevicePortGmsl::getImuData(uint8_t *data) {
+    int               ret = 0;
+    v4l2_ext_controls ctrls;
+    v4l2_ext_control  ctrl;
+    memset(&ctrls, 0, sizeof(ctrls));
+    memset(&ctrl, 0, sizeof(ctrl));
+    ctrls.ctrl_class = V4L2_CTRL_CLASS_CAMERA;
+    ctrls.controls   = &ctrl;
+    ctrls.count      = 1;
+
+    ctrl.id   = G2R_CAMERA_CID_GET_IMU_DATA;
+    int size  = sizeof(OBImuOriginData) * (IMU_FRAME_MAX_NUM) + sizeof(i2c_msg_header_t) + sizeof(uint16_t);
+    ctrl.size = size;
+    ctrl.p_u8 = data;
+
+    {
+        std::unique_lock<std::mutex> lk(mMultiThreadI2CMutex);
+        ret = xioctlGmsl(imu_fd_, VIDIOC_G_EXT_CTRLS, &ctrls);
+    }
+
+    if(ret < 0) {
+        LOG_ERROR("{}:{} ioctl failed on getdate :{}\n ", __FILE__, __LINE__, strerror(errno));
+        return -1;
+    }
+    return 0;
+}
+
+}  // namespace libobsensor
+
diff --git a/src/platform/usb/hid/HidDevicePortGmsl.hpp b/src/platform/usb/hid/HidDevicePortGmsl.hpp
new file mode 100644
index 00000000..0d8e905a
--- /dev/null
+++ b/src/platform/usb/hid/HidDevicePortGmsl.hpp
@@ -0,0 +1,52 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include "ISourcePort.hpp"
+
+#include "frame/Frame.hpp"
+#include "frame/FrameQueue.hpp"
+
+#include <cstdio>
+#include <cstdlib>
+#include <condition_variable>
+#include <chrono>
+#include <cstring>
+#include <string>
+#include <thread>
+#include <set>
+
+namespace libobsensor {
+
+class HidDevicePortGmsl : public IDataStreamPort {
+public:
+    HidDevicePortGmsl(std::shared_ptr<const USBSourcePortInfo> portInfo);
+    virtual ~HidDevicePortGmsl() noexcept;
+
+    void startStream(MutableFrameCallback callback) override;
+    void stopStream() override;
+
+    std::shared_ptr<const SourcePortInfo> getSourcePortInfo() const override;
+
+private:
+    void pollData();
+    int  getImuData(uint8_t *data);
+    int  getImuFps();
+
+private:
+    int imu_fd_;
+
+    std::shared_ptr<const USBSourcePortInfo> portInfo_;
+    std::atomic_bool                         isStreaming_;
+    MutableFrameCallback                     frameCallback_;
+    FrameQueue<Frame>                        frameQueue_;
+
+    std::thread pollThread_;
+
+    std::atomic_int imuRetryReadNum;
+    std::atomic_int imuReadFps;
+    std::atomic_int imuPollInterval;
+};
+
+}  // namespace libobsensor
+
diff --git a/src/platform/usb/pal/CMakeLists.txt b/src/platform/usb/pal/CMakeLists.txt
new file mode 100644
index 00000000..09863950
--- /dev/null
+++ b/src/platform/usb/pal/CMakeLists.txt
@@ -0,0 +1,20 @@
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+cmake_minimum_required(VERSION 3.5)
+
+if(OB_BUILD_WIN32)
+    add_subdirectory(win)
+endif()
+
+if(OB_BUILD_LINUX)
+	add_subdirectory(linux)
+endif()
+
+if(OB_BUILD_MACOS)
+	add_subdirectory(mac)
+endif()
+
+if(OB_BUILD_ANDROID)
+	add_subdirectory(android)
+endif()
diff --git a/src/platform/usb/pal/android/AndroidUsbDeviceManager.cpp b/src/platform/usb/pal/android/AndroidUsbDeviceManager.cpp
new file mode 100644
index 00000000..1f573b26
--- /dev/null
+++ b/src/platform/usb/pal/android/AndroidUsbDeviceManager.cpp
@@ -0,0 +1,380 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "AndroidUsbDeviceManager.hpp"
+
+#include <memory>
+#include <vector>
+
+#include "core/Context.hpp"
+#include "usb/enumerator/DeviceLibusb.hpp"
+#include "pal/android/AndroidUsbPal.hpp"
+#include "logger/Logger.hpp"
+#include "exception/ObException.hpp"
+#include "utility/StringUtils.hpp"
+
+namespace libobsensor {
+
+AndroidUsbDeviceManager::AndroidUsbDeviceManager() : jObjDeviceWatcher_(nullptr), gJVM_(nullptr) {
+    usbCtx_ = std::make_shared<UsbContext>();
+}
+
+AndroidUsbDeviceManager::~AndroidUsbDeviceManager() {
+    if(gJVM_ == nullptr) {
+        LOG_INFO("Destroyed");
+        return;
+    }
+
+    JNIEnv *env        = nullptr;
+    int     envStatus  = gJVM_->GetEnv((void **)&env, JNI_VERSION_1_6);
+    bool    needDetach = false;
+    if(envStatus == JNI_EDETACHED) {
+        if(gJVM_->AttachCurrentThread(&env, NULL) != 0) {
+            LOG_ERROR("JNI error attach current thread");
+        }
+        needDetach = true;
+    }
+
+    std::vector<std::string> devUrlList;
+    {
+        std::lock_guard<std::recursive_mutex> lk(mutex_);
+        for(auto it = deviceHandleMap_.begin(); it != deviceHandleMap_.end(); it++) {
+            devUrlList.push_back((*it).first);
+        }
+    }
+    for(const std::string &devUrl: devUrlList) {
+        LOG_WARN("~AndroidUsbDeviceManager try closeUsbDevice: %s", devUrl.c_str());
+        closeUsbDevice(devUrl);
+    }
+
+    if(jObjDeviceWatcher_ != nullptr && env != nullptr) {
+        jclass   clsDeviceWatcher  = env->GetObjectClass(jObjDeviceWatcher_);
+        jfieldID fieldNativeHandle = env->GetFieldID(clsDeviceWatcher, "mNativeHandle", "J");
+        jlong    nativeHandle      = env->GetLongField(jObjDeviceWatcher_, fieldNativeHandle);
+        if(reinterpret_cast<long>(this) == nativeHandle) {
+            env->SetLongField(jObjDeviceWatcher_, fieldNativeHandle, 0);
+        }
+
+        env->DeleteGlobalRef(jObjDeviceWatcher_);
+        jObjDeviceWatcher_ = nullptr;
+    }
+
+    if(needDetach) {
+        gJVM_->DetachCurrentThread();
+    }
+
+    gJVM_ = nullptr;
+    LOG_INFO("Destroyed");
+}
+
+void AndroidUsbDeviceManager::onDeviceChanged(OBDeviceChangedType changedType, const UsbInterfaceInfo &usbDevInfo) {
+    std::lock_guard<std::recursive_mutex> lk(mutex_);
+    LOG_DEBUG("AndroidUsbDeviceManager::notify");
+    if(changedType == OB_DEVICE_ARRIVAL) {
+        LOG_DEBUG("Device Arrival event occurred");
+        deviceInfoList_.push_back(usbDevInfo);
+    }
+    else {
+        LOG_DEBUG("Device Removed event occurred");
+        auto tarDevIter = std::find_if(deviceInfoList_.begin(), deviceInfoList_.end(), [=](const UsbInterfaceInfo &devInfoItem) {
+            //
+            return devInfoItem == usbDevInfo;
+        });
+        if(tarDevIter != deviceInfoList_.end()) {
+            deviceInfoList_.erase(tarDevIter);
+        }
+    }
+
+    if(callback_) {
+        callback_(changedType, usbDevInfo.uid);  // TODO: Change to a URL callback
+    }
+}
+
+std::vector<UsbInterfaceInfo> AndroidUsbDeviceManager::getDeviceInfoList() {
+    std::lock_guard<std::recursive_mutex> lk(mutex_);
+    return deviceInfoList_;
+}
+
+void AndroidUsbDeviceManager::start(deviceChangedCallback callback) {
+    std::lock_guard<std::recursive_mutex> lk(mutex_);
+    callback_ = callback;
+    // for(const auto &deviceInfo: deviceInfoList_) {
+    //     callback_(OB_DEVICE_ARRIVAL, deviceInfo.uid); // TODO: Change to a URL callback
+    // }
+}
+
+void AndroidUsbDeviceManager::stop() {
+    std::lock_guard<std::recursive_mutex> lk(mutex_);
+    callback_ = nullptr;
+}
+
+std::shared_ptr<UsbDevice> AndroidUsbDeviceManager::openUsbDevice(const std::string &devUrl) {
+    std::lock_guard<std::recursive_mutex> lk(mutex_);
+    // TODO: Add device list validation
+    auto deviceHandleIter = deviceHandleMap_.find(devUrl);
+    if(deviceHandleIter != deviceHandleMap_.end()) {
+        AndroidUsbDeviceHandle *handle = &deviceHandleIter->second;
+        handle->ref++;
+        return std::make_shared<UsbDeviceLibusb>(shared_from_this(), handle->device, handle->deviceHandle, handle->desc, usbCtx_, devUrl);
+    }
+    else {
+        if(!gJVM_) {
+            throw libobsensor::pal_exception("AndroidUsbDeviceManager::openUsbDevice gJVM_ is uninitialized!", OB_EXCEPTION_TYPE_PLATFORM);
+        }
+        JNIEnv *env;
+        int     envStatus  = gJVM_->GetEnv((void **)&env, JNI_VERSION_1_6);
+        bool    needDetach = false;
+        if(envStatus == JNI_EDETACHED) {
+            if(gJVM_->AttachCurrentThread(&env, NULL) != 0) {
+                LOG_ERROR("JNI error attach current thread");
+                return nullptr;
+            }
+            needDetach = true;
+        }
+
+        jclass    jClsDeviceWatcher = env->GetObjectClass(jObjDeviceWatcher_);
+        jmethodID midOpenUsbDevice  = env->GetMethodID(jClsDeviceWatcher, "openUsbDevice", "(I)I");
+        if(!midOpenUsbDevice) {
+            LOG_ERROR("OpenUsbDevice GetMethodID not found!");
+            if(needDetach) {
+                gJVM_->DetachCurrentThread();
+            }
+            return nullptr;
+        }
+        int uid = 0;
+        Stringutils::string::cvt2Int(devUrl, uid);
+        jint fileDsc = env->CallIntMethod(jObjDeviceWatcher_, midOpenUsbDevice, uid);  // TODO: Change to URL
+        if(needDetach) {
+            gJVM_->DetachCurrentThread();
+        }
+
+        AndroidUsbDeviceHandle newHandle;
+        newHandle.url = devUrl;
+        newHandle.fd  = (intptr_t)fileDsc;
+        auto ret      = libusb_wrap_sys_device(usbCtx_->get(), (intptr_t)fileDsc, &newHandle.deviceHandle);
+        if(ret < 0) {
+            throw libobsensor::pal_exception("libusb_wrap_sys_device wrap failed!", OB_EXCEPTION_TYPE_IO);
+        }
+        newHandle.device = libusb_get_device(newHandle.deviceHandle);
+        libusb_ref_device(newHandle.device);
+        libusb_get_device_descriptor(newHandle.device, &newHandle.desc);
+        newHandle.ref = 1;
+        deviceHandleMap_.insert({ devUrl, newHandle });
+        return std::make_shared<UsbDeviceLibusb>(shared_from_this(), newHandle.device, newHandle.deviceHandle, newHandle.desc, usbCtx_, devUrl);
+    }
+}
+
+void AndroidUsbDeviceManager::closeUsbDevice(const std::string &devUrl) {
+    std::lock_guard<std::recursive_mutex> lk(mutex_);
+    auto                                  deviceHandleIter = deviceHandleMap_.find(devUrl);
+    if(deviceHandleIter != deviceHandleMap_.end()) {
+        deviceHandleIter->second.ref--;
+        if(deviceHandleIter->second.ref <= 0) {
+            JNIEnv *env;
+            int     envStatus  = gJVM_->GetEnv((void **)&env, JNI_VERSION_1_6);
+            bool    needDetach = false;
+            if(envStatus == JNI_EDETACHED) {
+                if(gJVM_->AttachCurrentThread(&env, NULL) != 0) {
+                    LOG_ERROR("JNI error attach current thread");
+                    return;
+                }
+                needDetach = true;
+            }
+            jclass    jClsDeviceWatcher = env->GetObjectClass(jObjDeviceWatcher_);
+            jmethodID midCloseUsbDevice = env->GetMethodID(jClsDeviceWatcher, "closeUsbDevice", "(I)V");
+            if(!midCloseUsbDevice) {
+                LOG_ERROR("CloseUsbDevice GetMethodID not found!");
+                if(needDetach) {
+                    gJVM_->DetachCurrentThread();
+                }
+                return;
+            }
+            libusb_unref_device(deviceHandleIter->second.device);
+            libusb_close(deviceHandleIter->second.deviceHandle);
+            int uid = 0;
+            Stringutils::string::cvt2Int(devUrl, uid);
+            env->CallVoidMethod(jObjDeviceWatcher_, midCloseUsbDevice, uid);  // TODO: Change to URL
+            if(needDetach) {
+                gJVM_->DetachCurrentThread();
+            }
+            deviceHandleMap_.erase(deviceHandleIter);
+        }
+    }
+}
+
+void AndroidUsbDeviceManager::registerDeviceWatcher(JNIEnv *env, jclass typeDeviceWatcher, jobject jDeviceWatcher) {
+    if(nullptr != jObjDeviceWatcher_) {
+        return;
+    }
+
+    std::unique_lock<std::mutex> lk(jvmMutex_);
+    if(nullptr != jObjDeviceWatcher_) {
+        return;
+    }
+
+    jfieldID fieldNativeHandle = env->GetFieldID(typeDeviceWatcher, "mNativeHandle", "J");
+    env->SetLongField(jDeviceWatcher, fieldNativeHandle, reinterpret_cast<long>(this));
+
+    JavaVM *vm  = nullptr;
+    auto    ret = env->GetJavaVM(&vm);
+    if(JNI_OK == ret) {
+        gJVM_              = vm;
+        jObjDeviceWatcher_ = env->NewGlobalRef(jDeviceWatcher);
+    }
+    else {
+        LOG_ERROR("registerDeviceWatcher register JavaVM failed. GetJavaVm failed. ret: %d", ret);
+    }
+}
+
+void AndroidUsbDeviceManager::addUsbDevice(JNIEnv *env, jobject usbDevInfo) {
+    libobsensor::UsbInterfaceInfo usbDeviceInfo;
+    jclass                        jcUsbDevInfo = env->GetObjectClass(usbDevInfo);
+    jfieldID                      jfUid        = env->GetFieldID(jcUsbDevInfo, "mUid", "I");
+    jfieldID                      jfVid        = env->GetFieldID(jcUsbDevInfo, "mVid", "I");
+    jfieldID                      jfPid        = env->GetFieldID(jcUsbDevInfo, "mPid", "I");
+    jfieldID                      jfMiId       = env->GetFieldID(jcUsbDevInfo, "mMiId", "I");
+    jfieldID                      jfSerialNum  = env->GetFieldID(jcUsbDevInfo, "mSerialNum", "Ljava/lang/String;");
+    jfieldID                      jfCls        = env->GetFieldID(jcUsbDevInfo, "mCls", "I");
+    usbDeviceInfo.uid                          = libobsensor::StringUtils::convert2String((int)env->GetIntField(usbDevInfo, jfUid));
+    usbDeviceInfo.url                          = usbDeviceInfo.uid;  // TODO: Use the actual URL
+    usbDeviceInfo.vid                          = env->GetIntField(usbDevInfo, jfVid);
+    usbDeviceInfo.pid                          = env->GetIntField(usbDevInfo, jfPid);
+    usbDeviceInfo.infIndex                     = env->GetIntField(usbDevInfo, jfMiId);
+    jstring jsSerialNum                        = (jstring)env->GetObjectField(usbDevInfo, jfSerialNum);
+    if(jsSerialNum != nullptr) {
+        const char *szSerial = env->GetStringUTFChars(jsSerialNum, JNI_FALSE);
+        if(szSerial) {
+            usbDeviceInfo.serial = std::string(szSerial);
+            env->ReleaseStringUTFChars(jsSerialNum, szSerial);
+        }
+    }
+    usbDeviceInfo.cls    = static_cast<libobsensor::UsbClass>(env->GetIntField(usbDevInfo, jfCls));
+    usbDeviceInfo.infUrl = libobsensor::StringUtils::convert2String(usbDeviceInfo.uid) + libobsensor::StringUtils::convert2String(usbDeviceInfo.infIndex);
+    onDeviceChanged(libobsensor::OB_DEVICE_ARRIVAL, usbDeviceInfo);
+}
+
+void AndroidUsbDeviceManager::removeUsbDevice(JNIEnv *env, jobject usbDevInfo) {
+    libobsensor::UsbInterfaceInfo usbDeviceInfo;
+    jclass                        jcUsbDevInfo = env->GetObjectClass(usbDevInfo);
+    jfieldID                      jfUid        = env->GetFieldID(jcUsbDevInfo, "mUid", "I");
+    jfieldID                      jfVid        = env->GetFieldID(jcUsbDevInfo, "mVid", "I");
+    jfieldID                      jfPid        = env->GetFieldID(jcUsbDevInfo, "mPid", "I");
+    jfieldID                      jfMiId       = env->GetFieldID(jcUsbDevInfo, "mMiId", "I");
+    jfieldID                      jfSerialNum  = env->GetFieldID(jcUsbDevInfo, "mSerialNum", "Ljava/lang/String;");
+    jfieldID                      jfCls        = env->GetFieldID(jcUsbDevInfo, "mCls", "I");
+    usbDeviceInfo.uid                          = libobsensor::StringUtils::convert2String((int)env->GetIntField(usbDevInfo, jfUid));
+    usbDeviceInfo.url                          = usbDeviceInfo.uid;  // TODO: Use the real URL
+    usbDeviceInfo.vid                          = env->GetIntField(usbDevInfo, jfVid);
+    usbDeviceInfo.pid                          = env->GetIntField(usbDevInfo, jfPid);
+    usbDeviceInfo.infIndex                     = env->GetIntField(usbDevInfo, jfMiId);
+    jstring jsSerialNum                        = (jstring)env->GetObjectField(usbDevInfo, jfSerialNum);
+    if(jsSerialNum != nullptr) {
+        const char *szSerial = env->GetStringUTFChars(jsSerialNum, JNI_FALSE);
+        if(szSerial) {
+            usbDeviceInfo.serial = std::string(szSerial);
+            env->ReleaseStringUTFChars(jsSerialNum, szSerial);
+        }
+    }
+    usbDeviceInfo.cls    = static_cast<libobsensor::UsbClass>(env->GetIntField(usbDevInfo, jfCls));
+    usbDeviceInfo.infUrl = libobsensor::StringUtils::convert2String(usbDeviceInfo.uid) + libobsensor::StringUtils::convert2String(usbDeviceInfo.infIndex);
+    onDeviceChanged(libobsensor::OB_DEVICE_REMOVED, usbDeviceInfo);
+}
+
+}  // namespace libobsensor
+
+static inline void throw_error(JNIEnv *env, const char *function_name, const char *message) {
+    std::string strFunction = (function_name ? std::string(function_name) : "");
+    std::string strMessage  = (message ? std::string(message) : "");
+    std::string errorMsg    = strFunction + "(), " + strMessage;
+    jclass      cls         = env->FindClass("com/orbbec/obsensor/OBException");
+    if(nullptr == cls) {
+        LOG_ERROR("throw_error failed. not found class: com/orbbec/obsensor/OBException. function_name: %s, errorMsg: %s", function_name, message);
+        return;
+    }
+    env->ThrowNew(cls, errorMsg.c_str());
+}
+
+/*
+ * Class:     com_orbbec_internal_DeviceWatcher
+ * Method:    nRegisterClassObj
+ * Signature: (Lcom/orbbec/internal/IDeviceWatcher;)V
+ */
+extern "C" JNIEXPORT void JNICALL Java_com_orbbec_internal_DeviceWatcher_nRegisterClassObj(JNIEnv *env, jclass typeDeviceWatcher, jobject jDeviceWatcher) {
+    if(!libobsensor::Context::isInstanceExist()) {
+        throw_error(env, "nRegisterClassObj", "Error invalid state. Must create instance of OBContext/ob::Context/ob_context before nRegisterClassObj");
+    }
+    auto AndroidUsbPal = std::dynamic_pointer_cast<libobsensor::AndroidUsbPal>(libobsensor::Context::getInstance()->getDeviceManager()->getObPal());
+    AndroidUsbPal->getAndroidUsbManager()->registerDeviceWatcher(env, typeDeviceWatcher, jDeviceWatcher);
+}
+
+/*
+ * Class:     com_orbbec_internal_DeviceWatcher
+ * Method:    nAddUsbDevice
+ * Signature: (Lcom/orbbec/internal/UsbInterfaceInfo;)V
+ */
+extern "C" JNIEXPORT void JNICALL Java_com_orbbec_internal_DeviceWatcher_nAddUsbDevice(JNIEnv *env, jobject jDeviceWatcher, jobject usbDevInfo) {
+    jclass   clsDeviceWatcher  = env->GetObjectClass(jDeviceWatcher);
+    jfieldID fieldNativeHandle = env->GetFieldID(clsDeviceWatcher, "mNativeHandle", "J");
+    jlong    nativeHandle      = env->GetLongField(jDeviceWatcher, fieldNativeHandle);
+    if(0 == nativeHandle) {
+        throw_error(env, "nAddUsbDevice", "mNativeHandle=0, invalid pointer");
+    }
+    auto androidUsbManager = reinterpret_cast<libobsensor::AndroidUsbDeviceManager *>(nativeHandle);
+
+    try {
+        androidUsbManager->addUsbDevice(env, usbDevInfo);
+    }
+    catch(libobsensor::libobsensor_exception &e) {
+        throw_error(env, "nAddUsbDevice", e.get_message());
+    }
+}
+
+/*
+ * Class:     com_orbbec_internal_DeviceWatcher
+ * Method:    nRemoveUsbDevice
+ * Signature: (Lcom/orbbec/internal/UsbInterfaceInfo;)V
+ */
+extern "C" JNIEXPORT void JNICALL Java_com_orbbec_internal_DeviceWatcher_nRemoveUsbDevice(JNIEnv *env, jobject jDeviceWatcher, jobject usbDevInfo) {
+    jclass   clsDeviceWatcher  = env->GetObjectClass(jDeviceWatcher);
+    jfieldID fieldNativeHandle = env->GetFieldID(clsDeviceWatcher, "mNativeHandle", "J");
+    jlong    nativeHandle      = env->GetLongField(jDeviceWatcher, fieldNativeHandle);
+    if(0 == nativeHandle) {
+        throw_error(env, "nRemovedUsbDevice", "mNativeHandle=0, invalid pointer");
+    }
+    auto androidUsbManager = reinterpret_cast<libobsensor::AndroidUsbDeviceManager *>(nativeHandle);
+
+    try {
+        androidUsbManager->removeUsbDevice(env, usbDevInfo);
+    }
+    catch(libobsensor::libobsensor_exception &e) {
+        throw_error(env, "nRemoveUsbDevice", e.get_message());
+    }
+}
+
+// For API 2.0 TODO ljf++ Further adaptation will be done when API 2.0 is available
+// extern "C" JNIEXPORT void JNICALL Java_com_orbbec_obsensor2_DeviceWatcher_nAddUsbDevice(JNIEnv *env, jclass type, jobject usbDevInfo) {
+//    if (!libobsensor::Context::isInstanceExist()) {
+//        throw_error(env, "nAddUsbDevice", "libobsensor::Context is not instance yet.");
+//    }
+//    auto obContext = libobsensor::Context::getInstance();
+//    auto androidUsbManager = std::dynamic_pointer_cast<libobsensor::AndroidUsbPal>(obContext->getDeviceManager()->getObPal())->getAndroidUsbManager();
+//    try {
+//        androidUsbManager->addUsbDevice(env, usbDevInfo);
+//    } catch (libobsensor::libobsensor_exception &e) {
+//        throw_error(env, "nAddUsbDevice", e.get_message());
+//    }
+//}
+//
+// extern "C" JNIEXPORT void JNICALL Java_com_orbbec_obsensor2_DeviceWatcher_nRemoveUsbDevice(JNIEnv *env, jclass type, jobject usbDevInfo) {
+//    if (!libobsensor::Context::isInstanceExist()) {
+//        throw_error(env, "nRemoveUsbDevice", "libobsensor::Context is not instance yet.");
+//    }
+//    auto obContext = libobsensor::Context::getInstance();
+//    auto androidUsbManager = std::dynamic_pointer_cast<libobsensor::AndroidUsbPal>(obContext->getDeviceManager()->getObPal())->getAndroidUsbManager();
+//    try {
+//        androidUsbManager->removeUsbDevice(env, usbDevInfo);
+//    } catch (libobsensor::libobsensor_exception &e) {
+//        throw_error(env, "nRemoveUsbDevice", e.get_message());
+//    }
+//}
+
diff --git a/src/platform/usb/pal/android/AndroidUsbDeviceManager.hpp b/src/platform/usb/pal/android/AndroidUsbDeviceManager.hpp
new file mode 100644
index 00000000..9e6f622f
--- /dev/null
+++ b/src/platform/usb/pal/android/AndroidUsbDeviceManager.hpp
@@ -0,0 +1,59 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include "IPal.hpp"
+#include "usb/enumerator/Device.hpp"
+#include "usb/enumerator/ContextLibusb.hpp"
+
+#include <string>
+#include <map>
+#include <memory>
+#include <jni.h>
+
+namespace libobsensor {
+
+struct AndroidUsbDeviceHandle {
+    std::string              url = "";
+    intptr_t                 fd  = NULL;
+    libusb_device_descriptor desc;
+    libusb_device           *device       = nullptr;
+    libusb_device_handle    *deviceHandle = nullptr;
+
+    uint16_t ref = 0;
+};
+
+class AndroidUsbDeviceManager : public IDeviceWatcher, public std::enable_shared_from_this<AndroidUsbDeviceManager> {
+public:
+    AndroidUsbDeviceManager();
+    ~AndroidUsbDeviceManager();
+
+    virtual void               start(deviceChangedCallback callback) override;
+    virtual void               stop() override;
+    void                          onDeviceChanged(OBDeviceChangedType changeType_, const UsbInterfaceInfo &usbDevInfo);
+    std::vector<UsbInterfaceInfo> getDeviceInfoList();
+
+    std::shared_ptr<UsbDevice> openUsbDevice(const std::string &devUrl);
+    void                       closeUsbDevice(const std::string &devUrl);
+
+    void addUsbDevice(JNIEnv *env, jobject usbDevInfo);
+
+    void removeUsbDevice(JNIEnv *env, jobject usbDevInfo);
+
+    void registerDeviceWatcher(JNIEnv *env, jclass typeDeviceWatcher, jobject jDeviceWatcher);
+
+private:
+    std::recursive_mutex                          mutex_;
+    deviceChangedCallback                         callback_ = nullptr;
+    std::vector<UsbInterfaceInfo>                 deviceInfoList_;
+    std::shared_ptr<UsbContext>                   usbCtx_;
+    std::map<std::string, AndroidUsbDeviceHandle> deviceHandleMap_;
+
+    std::mutex       jvmMutex_;
+    JavaVM          *gJVM_;
+    volatile jobject jObjDeviceWatcher_;
+};
+
+}  // namespace libobsensor
+
diff --git a/src/platform/usb/pal/android/AndroidUsbPal.cpp b/src/platform/usb/pal/android/AndroidUsbPal.cpp
new file mode 100644
index 00000000..c3dc03ea
--- /dev/null
+++ b/src/platform/usb/pal/android/AndroidUsbPal.cpp
@@ -0,0 +1,183 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "AndroidUsbPal.hpp"
+
+#if defined(BUILD_USB_PAL)
+#include <pal/android/AndroidUsbDeviceManager.hpp>
+#include "usb/vendor/VendorUsbDevicePort.hpp"
+#include "usb/uvc/ObLibuvcDevicePort.hpp"
+#include <usb/hid/HidDevicePort.hpp>
+#include "usb/uvc/rawPhaseConverter/MSDEConverterDevice.hpp"
+#include "logger/Logger.hpp"
+#include "exception/ObException.hpp"
+#endif
+
+#if defined(BUILD_NET_PAL)
+#include "ethernet/Ethernet.hpp"
+#endif
+
+namespace libobsensor {
+
+AndroidUsbPal::AndroidUsbPal() {
+#if defined(BUILD_USB_PAL)
+    androidUsbManager_ = std::make_shared<AndroidUsbDeviceManager>();
+#endif
+}
+AndroidUsbPal::~AndroidUsbPal() noexcept {
+#if defined(BUILD_USB_PAL)
+    androidUsbManager_ = nullptr;
+#endif
+};
+
+std::shared_ptr<ISourcePort> AndroidUsbPal::getSourcePort(std::shared_ptr<const SourcePortInfo> portInfo) {
+    std::unique_lock<std::mutex> lock(sourcePortMapMutex_);
+    std::shared_ptr<ISourcePort> port;
+
+    // clear expired weak_ptr
+    for(auto it = sourcePortMap_.begin(); it != sourcePortMap_.end();) {
+        if(it->second.expired()) {
+            it = sourcePortMap_.erase(it);
+        }
+        else {
+            ++it;
+        }
+    }
+
+    // check if the port already exists in the map
+    for(const auto &pair: sourcePortMap_) {
+        if(pair.first->equal(portInfo)) {
+            port = pair.second.lock();
+            if(port != nullptr) {
+                return port;
+            }
+        }
+    }
+
+    switch(portInfo->portType) {
+#if defined(BUILD_USB_PAL)
+    case SOURCE_PORT_USB_VENDOR: {
+        auto usbDev = androidUsbManager_->openUsbDevice(std::dynamic_pointer_cast<const USBSourcePortInfo>(portInfo)->url);
+        if(usbDev == nullptr) {
+            throw libobsensor::camera_disconnected_exception("usbEnumerator openUsbDevice failed!");
+        }
+        port = std::make_shared<VendorUsbDevicePort>(usbDev, std::dynamic_pointer_cast<const USBSourcePortInfo>(portInfo));
+        break;
+    }
+    case SOURCE_PORT_USB_UVC: {
+        auto usbDev = androidUsbManager_->openUsbDevice(std::dynamic_pointer_cast<const USBSourcePortInfo>(portInfo)->url);
+        if(usbDev == nullptr) {
+            throw libobsensor::camera_disconnected_exception("usbEnumerator openUsbDevice failed!");
+        }
+        port = std::make_shared<ObLibuvcDevicePort>(usbDev, std::dynamic_pointer_cast<const USBSourcePortInfo>(portInfo));
+        break;
+    }
+    case SOURCE_PORT_USB_HID: {
+        auto usbDev = androidUsbManager_->openUsbDevice(std::dynamic_pointer_cast<const USBSourcePortInfo>(portInfo)->url);
+        if(usbDev == nullptr) {
+            throw libobsensor::camera_disconnected_exception("usbEnumerator openUsbDevice failed!");
+        }
+        port = std::make_shared<HidDevicePort>(usbDev, std::dynamic_pointer_cast<const USBSourcePortInfo>(portInfo));
+        break;
+    }
+#endif
+
+#if defined(BUILD_NET_PAL)
+    case SOURCE_PORT_NET_VENDOR:
+        port = std::make_shared<VendorNetDataPort>(std::dynamic_pointer_cast<const NetSourcePortInfo>(portInfo));
+        break;
+    case SOURCE_PORT_NET_RTSP:
+        port = std::make_shared<RTSPStreamPort>(std::dynamic_pointer_cast<const RTSPStreamPortInfo>(portInfo));
+        break;
+    case SOURCE_PORT_NET_VENDOR_STREAM:
+        port = std::make_shared<NetDataStreamPort>(std::dynamic_pointer_cast<const NetDataStreamPortInfo>(portInfo));
+        break;
+#endif
+    default:
+        throw libobsensor::invalid_value_exception("unsupported source port type!");
+        break;
+    }
+    if(port != nullptr) {
+        sourcePortMap_.insert(std::make_pair(portInfo, port));
+    }
+    return port;
+}
+
+#if defined(BUILD_USB_PAL)
+std::shared_ptr<IDeviceWatcher> AndroidUsbPal::createDeviceWatcher() const {
+    LOG_INFO("Create AndroidUsbDeviceManager!");
+    return androidUsbManager_;
+}
+
+SourcePortInfoList AndroidUsbPal::querySourcePortInfos() {
+    SourcePortInfoList portInfoList;
+
+    const auto &usbInfoList = androidUsbManager_->getDeviceInfoList();
+    for(const auto &info: usbInfoList) {
+        auto portInfo      = std::make_shared<USBSourcePortInfo>(cvtUsbClassToPortType(info.cls));
+        portInfo->url      = info.url;
+        portInfo->uid      = info.uid;
+        portInfo->vid      = info.vid;
+        portInfo->pid      = info.pid;
+        portInfo->serial   = info.serial;
+        portInfo->connSpec = usb_spec_names.find(info.conn_spec)->second;
+        portInfo->infUrl   = info.infUrl;
+        portInfo->infIndex = info.infIndex;
+        portInfo->infName  = info.infName;
+        // portInfo->hubId    = info.hubId;
+
+        portInfoList.push_back(portInfo);
+    }
+    return portInfoList;
+}
+
+std::shared_ptr<ISourcePort> AndroidUsbPal::createOpenNIDevicePort(std::shared_ptr<const SourcePortInfo> portInfo) {
+    if(portInfo->portType == SOURCE_PORT_USB_VENDOR) {
+        auto usbDev = androidUsbManager_->openUsbDevice(std::dynamic_pointer_cast<const USBSourcePortInfo>(portInfo)->url);
+        if(usbDev == nullptr) {
+            throw libobsensor::camera_disconnected_exception("usbEnumerator openUsbDevice failed!");
+        }
+        return std::make_shared<OpenNIDevicePortLinux>(usbDev, std::dynamic_pointer_cast<const USBSourcePortInfo>(portInfo));
+    }
+
+    return nullptr;
+}
+
+std::shared_ptr<ISourcePort> AndroidUsbPal::createRawPhaseConverterDevicePort(RawPhaseConverterPortType type, std::shared_ptr<const SourcePortInfo> portInfo) {
+    switch(type) {
+    case RAW_PHASE_CONVERTER_MSDE: {
+        std::unique_lock<std::mutex> lock(sourcePortMapMutex_);
+        std::shared_ptr<ISourcePort> port;
+        auto                         it = sourcePortMap_.find(portInfo);
+        if(it != sourcePortMap_.end()) {
+            port = it->second.lock();
+            if(port != nullptr) {
+                return port;
+            }
+        }
+        auto usbDev = androidUsbManager_->openUsbDevice(std::dynamic_pointer_cast<const USBSourcePortInfo>(portInfo)->url);
+        if(usbDev == nullptr) {
+            throw libobsensor::camera_disconnected_exception("usbEnumerator create UnpackDevicePort failed!");
+        }
+        port = std::make_shared<MSDEConverterDevice>(usbDev, std::dynamic_pointer_cast<const USBSourcePortInfo>(portInfo));
+        if(port != nullptr) {
+            sourcePortMap_.insert(std::make_pair(portInfo, port));
+        }
+        return port;
+    }
+    }
+    return nullptr;
+}
+
+std::shared_ptr<ISourcePort> AndroidUsbPal::createMultiUvcDevicePort(std::shared_ptr<const SourcePortInfo> portInfo) {
+    auto usbDev = androidUsbManager_->openUsbDevice(std::dynamic_pointer_cast<const USBSourcePortInfo>(portInfo)->url);
+    if(usbDev == nullptr) {
+        throw libobsensor::camera_disconnected_exception("usbEnumerator openUsbDevice failed!");
+    }
+    return std::make_shared<ObMultiUvcDevice>(usbDev, std::dynamic_pointer_cast<const USBSourcePortInfo>(portInfo));
+}
+
+#endif
+
+}  // namespace libobsensor
+
diff --git a/src/platform/usb/pal/android/AndroidUsbPal.hpp b/src/platform/usb/pal/android/AndroidUsbPal.hpp
new file mode 100644
index 00000000..ef7af959
--- /dev/null
+++ b/src/platform/usb/pal/android/AndroidUsbPal.hpp
@@ -0,0 +1,42 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include "IPal.hpp"
+
+#include <memory>
+
+#if defined(BUILD_USB_PAL)
+#include <pal/android/AndroidUsbDeviceManager.hpp>
+#endif
+
+namespace libobsensor {
+
+class AndroidUsbPal : public IPal {
+public:
+    AndroidUsbPal();
+    virtual ~AndroidUsbPal() noexcept;
+
+    virtual std::shared_ptr<ISourcePort> getSourcePort(std::shared_ptr<const SourcePortInfo> portInfo) override;
+
+#if defined(BUILD_USB_PAL)
+    virtual std::shared_ptr<IDeviceWatcher> createDeviceWatcher() const override;
+    virtual SourcePortInfoList              querySourcePortInfos() override;
+    virtual std::shared_ptr<ISourcePort>    createOpenNIDevicePort(std::shared_ptr<const SourcePortInfo>) override;
+    virtual std::shared_ptr<ISourcePort>    createMultiUvcDevicePort(std::shared_ptr<const SourcePortInfo> portInfo) override;
+    virtual std::shared_ptr<ISourcePort>    createRawPhaseConverterDevicePort(RawPhaseConverterPortType type, std::shared_ptr<const SourcePortInfo>) override;
+#endif
+
+    std::shared_ptr<AndroidUsbDeviceManager> getAndroidUsbManager() {
+        return androidUsbManager_;
+    }
+
+private:
+    std::shared_ptr<AndroidUsbDeviceManager>                                    androidUsbManager_;
+    std::mutex                                                                  sourcePortMapMutex_;
+    std::map<std::shared_ptr<const SourcePortInfo>, std::weak_ptr<ISourcePort>> sourcePortMap_;
+};
+
+}  // namespace libobsensor
+
diff --git a/src/platform/usb/pal/android/CMakeLists.txt b/src/platform/usb/pal/android/CMakeLists.txt
new file mode 100644
index 00000000..b9335259
--- /dev/null
+++ b/src/platform/usb/pal/android/CMakeLists.txt
@@ -0,0 +1,23 @@
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+cmake_minimum_required(VERSION 3.5)
+
+file(GLOB _src_files
+    AndroidUsbPal.cpp
+    AndroidUsbPal.hpp
+)
+
+if(BUILD_USB_PAL)
+    file(GLOB _usb_src_files
+        AndroidUsbDeviceManager.cpp
+        AndroidUsbDeviceManager.hpp
+    )
+    list(APPEND _src_files ${_usb_src_files})
+endif()
+
+foreach(_file IN ITEMS ${_src_files})
+    target_sources(${OB_TARGET_PAL} PRIVATE "${_file}")
+endforeach()
+
+
diff --git a/src/platform/usb/pal/linux/CMakeLists.txt b/src/platform/usb/pal/linux/CMakeLists.txt
new file mode 100644
index 00000000..a92f036f
--- /dev/null
+++ b/src/platform/usb/pal/linux/CMakeLists.txt
@@ -0,0 +1,46 @@
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+cmake_minimum_required(VERSION 3.5)
+
+
+file (GLOB _cpp_files "${CMAKE_CURRENT_LIST_DIR}/*.cpp")
+file (GLOB _head_files "${CMAKE_CURRENT_LIST_DIR}/*.hpp")
+
+
+foreach(_file IN ITEMS ${_cpp_files})
+        target_sources(${OB_TARGET_PAL} PRIVATE "${_file}")
+endforeach()
+
+foreach(_file IN ITEMS ${_head_files})
+        target_sources(${OB_TARGET_PAL} PRIVATE "${_file}")
+endforeach()
+
+
+# if (LIBUSB_1_LIBRARIES AND LIBUSB_1_INCLUDE_DIRS)
+#   # in cache already
+#   set(LIBUSB_FOUND TRUE)
+#   set(LIBUSB_1_FOUND TRUE)
+
+# else (LIBUSB_1_LIBRARIES AND LIBUSB_1_INCLUDE_DIRS)
+#   find_path(LIBUSB_1_INCLUDE_DIR
+#             NAMES libusb-1.0/libusb.h
+# 	    PATHS /usr/include /usr/local/include /opt/local/include /sw/include
+# 	    PATH_SUFFIXES libusb-1.0)
+
+#   find_library(LIBUSB_1_LIBRARY
+#                NAMES usb-1.0
+# 	       PATHS /usr/lib /usr/local/lib /opt/local/lib /sw/lib)
+
+#   set(LIBUSB_1_INCLUDE_DIRS ${LIBUSB_1_INCLUDE_DIR}/libusb-1.0/)
+#   set(LIBUSB_1_LIBRARIES ${LIBUSB_1_LIBRARY})
+
+#   include(FindPackageHandleStandardArgs)
+#   find_package_handle_standard_args(LIBUSB_1 DEFAULT_MSG LIBUSB_1_LIBRARY LIBUSB_1_INCLUDE_DIR)
+
+#   # show the LIBUSB_1_INCLUDE_DIRS and LIBUSB_1_LIBRARIES variables only in the advanced view
+#   mark_as_advanced(LIBUSB_1_INCLUDE_DIRS LIBUSB_1_LIBRARIES)
+# endif (LIBUSB_1_LIBRARIES AND LIBUSB_1_INCLUDE_DIRS)
+
+# include_directories(${LIBUSB_1_INCLUDE_DIRS})
+
diff --git a/src/platform/usb/pal/linux/LinuxUsbPal.cpp b/src/platform/usb/pal/linux/LinuxUsbPal.cpp
new file mode 100644
index 00000000..98b79c61
--- /dev/null
+++ b/src/platform/usb/pal/linux/LinuxUsbPal.cpp
@@ -0,0 +1,293 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "LinuxUsbPal.hpp"
+
+#include "logger/Logger.hpp"
+#include "exception/ObException.hpp"
+#include "environment/EnvConfig.hpp"
+
+#include "usb/hid/HidDevicePort.hpp"
+#include "usb/hid/HidDevicePortGmsl.hpp"
+#include "usb/vendor/VendorUsbDevicePort.hpp"
+#include "usb/uvc/ObLibuvcDevicePort.hpp"
+#include "usb/uvc/ObV4lUvcDevicePort.hpp"
+#include "usb/uvc/ObV4lGmslDevicePort.hpp"
+#include "usb/enumerator/UsbEnumeratorLibusb.hpp"
+
+#include <cctype>  // std::tolower
+#include <chrono>
+#include <algorithm>
+
+namespace libobsensor {
+
+const std::vector<uint16_t> FemtoMegaDevPids = {
+    0x0669,  // Femto Mega
+    0x06c0,  // Femto Mega i
+};
+
+template <class T> static bool isMatchDeviceByPid(uint16_t pid, T &pids) {
+    return std::any_of(pids.begin(), pids.end(), [pid](uint16_t pid_) { return pid_ == pid; });
+}
+
+int deviceArrivalCallback(libusb_context *ctx, libusb_device *device, libusb_hotplug_event event, void *user_data);
+int deviceRemovedCallback(libusb_context *ctx, libusb_device *device, libusb_hotplug_event event, void *user_data);
+class LibusbDeviceWatcher : public IDeviceWatcher {
+public:
+    LibusbDeviceWatcher() = default;
+    ~LibusbDeviceWatcher() noexcept override {
+        TRY_EXECUTE(stop());
+        // libusb_exit();
+    }
+    void start(deviceChangedCallback callback) override {
+        callback_ = callback;
+        auto rc   = libusb_hotplug_register_callback(NULL, LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED, 0, 0x2BC5, LIBUSB_HOTPLUG_MATCH_ANY, LIBUSB_HOTPLUG_MATCH_ANY,
+                                                     deviceArrivalCallback, this, &hp[0]);
+        if(LIBUSB_SUCCESS != rc) {
+            LOG_WARN("register libusb hotplug failed!");
+        }
+        rc = libusb_hotplug_register_callback(NULL, LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT, 0, 0x2BC5, LIBUSB_HOTPLUG_MATCH_ANY, LIBUSB_HOTPLUG_MATCH_ANY,
+                                              deviceRemovedCallback, this, &hp[1]);
+        if(LIBUSB_SUCCESS != rc) {
+            LOG_WARN("register libusb hotplug failed!");
+        }
+    }
+
+    void stop() override {
+        libusb_hotplug_deregister_callback(NULL, hp[0]);
+        libusb_hotplug_deregister_callback(NULL, hp[1]);
+    }
+
+    static bool hasCapability() {
+        return libusb_has_capability(LIBUSB_CAP_HAS_HOTPLUG);
+    }
+
+private:
+    libusb_hotplug_callback_handle hp[2];
+    deviceChangedCallback          callback_;
+
+    friend int deviceArrivalCallback(libusb_context *ctx, libusb_device *device, libusb_hotplug_event event, void *user_data);
+    friend int deviceRemovedCallback(libusb_context *ctx, libusb_device *device, libusb_hotplug_event event, void *user_data);
+};
+
+std::string parseDevicePath(libusb_device *usbDevice) {
+    auto usb_bus = std::to_string(libusb_get_bus_number(usbDevice));
+    // As per the USB 3.0 specs, the current maximum limit for the depth is 7.
+    const auto               max_usb_depth            = 8;
+    uint8_t                  usb_ports[max_usb_depth] = {};
+    std::stringstream        port_path;
+    auto                     port_count = libusb_get_port_numbers(usbDevice, usb_ports, max_usb_depth);
+    auto                     usb_dev    = std::to_string(libusb_get_device_address(usbDevice));
+    libusb_device_descriptor dev_desc{};
+    auto                     r = libusb_get_device_descriptor(usbDevice, &dev_desc);
+    (void)r;
+    for(int i = 0; i < port_count; ++i) {
+        port_path << std::to_string(usb_ports[i]) << (((i + 1) < port_count) ? "." : "");
+    }
+    return usb_bus + "-" + port_path.str() + "-" + usb_dev;
+}
+
+int deviceArrivalCallback(libusb_context *ctx, libusb_device *device, libusb_hotplug_event event, void *user_data) {
+    (void)ctx;
+    (void)event;
+    auto watcher = (LibusbDeviceWatcher *)user_data;
+    LOG_DEBUG("Device arrival event occurred");
+    watcher->callback_(OB_DEVICE_ARRIVAL, parseDevicePath(device));
+    return 0;
+}
+
+int deviceRemovedCallback(libusb_context *ctx, libusb_device *device, libusb_hotplug_event event, void *user_data) {
+    (void)ctx;
+    (void)event;
+    auto watcher = (LibusbDeviceWatcher *)user_data;
+    LOG_DEBUG("Device removed event occurred");
+    watcher->callback_(OB_DEVICE_REMOVED, parseDevicePath(device));
+    return 0;
+}
+
+std::shared_ptr<IPal> createUsbPal() {
+    return std::make_shared<LinuxUsbPal>();
+}
+
+LinuxUsbPal::LinuxUsbPal() {
+#if defined(BUILD_USB_PAL)
+    usbEnumerator_ = IUsbEnumerator::getInstance();
+    loadXmlConfig();
+#endif
+}
+
+LinuxUsbPal::~LinuxUsbPal() noexcept {}
+
+std::shared_ptr<ISourcePort> LinuxUsbPal::getSourcePort(std::shared_ptr<const SourcePortInfo> portInfo) {
+    std::unique_lock<std::mutex> lock(sourcePortMapMutex_);
+    std::shared_ptr<ISourcePort> port;
+
+    // clear expired weak_ptr
+    for(auto it = sourcePortMap_.begin(); it != sourcePortMap_.end();) {
+        if(it->second.expired()) {
+            it = sourcePortMap_.erase(it);
+        }
+        else {
+            ++it;
+        }
+    }
+
+    // check if the port already exists in the map
+    for(const auto &pair: sourcePortMap_) {
+        if(pair.first->equal(portInfo)) {
+            port = pair.second.lock();
+            if(port != nullptr) {
+                return port;
+            }
+        }
+    }
+
+    switch(portInfo->portType) {
+    case SOURCE_PORT_USB_VENDOR: {
+        auto url    = std::dynamic_pointer_cast<const USBSourcePortInfo>(portInfo)->url;
+        auto usbDev = usbEnumerator_->openUsbDevice(url);
+        if(usbDev == nullptr) {
+            throw libobsensor::camera_disconnected_exception("usbEnumerator openUsbDevice failed!");
+        }
+        port = std::make_shared<VendorUsbDevicePort>(usbDev, std::dynamic_pointer_cast<const USBSourcePortInfo>(portInfo));
+        LOG_DEBUG("Vendor device have been create! url: {}", url);
+        break;
+    }
+    case SOURCE_PORT_USB_UVC: {
+        auto usbPortInfo = std::dynamic_pointer_cast<const USBSourcePortInfo>(portInfo);
+        auto backend     = uvcBackendType_;
+        if(isMatchDeviceByPid(usbPortInfo->pid, FemtoMegaDevPids)) {  // if the device is femto mega, force to use v4l2
+            backend = UVC_BACKEND_TYPE_V4L2;
+        }
+        if(usbPortInfo->connSpec == "GMSL2") {
+            LOG_DEBUG("check GMSL2 device! force to use v4l2 backend!");
+            backend = UVC_BACKEND_TYPE_V4L2;
+        }
+        if(backend == UVC_BACKEND_TYPE_AUTO) {
+            backend = UVC_BACKEND_TYPE_LIBUVC;
+            if(ObV4lUvcDevicePort::isContainedMetadataDevice(usbPortInfo)) {
+                backend = UVC_BACKEND_TYPE_V4L2;
+            }
+        }
+        if(backend == UVC_BACKEND_TYPE_V4L2) {
+            if(ObV4lGmslDevicePort::isGmslDeviceForPlatformNvidia(usbPortInfo)) {
+                port = std::make_shared<ObV4lGmslDevicePort>(usbPortInfo);
+                LOG_DEBUG("GMSL device have been create with V4L2 backend! dev: {}, inf: {}", usbPortInfo->url, usbPortInfo->infUrl);
+            }
+            else {
+                port = std::make_shared<ObV4lUvcDevicePort>(usbPortInfo);
+                LOG_DEBUG("UVC device have been create with V4L2 backend! dev: {}, inf: {}", usbPortInfo->url, usbPortInfo->infUrl);
+            }
+        }
+        else {
+            auto usbDev = usbEnumerator_->openUsbDevice(std::dynamic_pointer_cast<const USBSourcePortInfo>(portInfo)->url);
+            if(usbDev == nullptr) {
+                throw libobsensor::camera_disconnected_exception("usbEnumerator openUsbDevice failed!");
+            }
+            port = std::make_shared<ObLibuvcDevicePort>(usbDev, std::dynamic_pointer_cast<const USBSourcePortInfo>(portInfo));
+            LOG_DEBUG("UVC device have been create with LibUVC backend! dev: {}, inf: {}", usbPortInfo->url, usbPortInfo->infUrl);
+        }
+        break;
+    }
+    case SOURCE_PORT_USB_HID: {
+        auto usbPortInfo = std::dynamic_pointer_cast<const USBSourcePortInfo>(portInfo);
+        if(ObV4lGmslDevicePort::isGmslDeviceForPlatformNvidia(usbPortInfo)) {
+            port = std::make_shared<HidDevicePortGmsl>(usbPortInfo);
+            LOG_DEBUG("GMSL device have been create with HID backend! dev: {}, inf: {}", usbPortInfo->url, usbPortInfo->infUrl);
+        }
+        else {
+            auto usbDev = usbEnumerator_->openUsbDevice(std::dynamic_pointer_cast<const USBSourcePortInfo>(portInfo)->url);
+            if(usbDev == nullptr) {
+                throw libobsensor::camera_disconnected_exception("usbEnumerator openUsbDevice failed!");
+            }
+            port = std::make_shared<HidDevicePort>(usbDev, std::dynamic_pointer_cast<const USBSourcePortInfo>(portInfo));
+            LOG_DEBUG("HID device have been create with HID backend! dev: {}, inf: {}", usbPortInfo->url, usbPortInfo->infUrl);
+        }
+        break;
+    }
+
+    default:
+        throw libobsensor::invalid_value_exception("unsupported source port type!");
+        break;
+    }
+    if(port != nullptr) {
+        sourcePortMap_.insert(std::make_pair(portInfo, port));
+    }
+    return port;
+}
+
+std::shared_ptr<IDeviceWatcher> LinuxUsbPal::createDeviceWatcher() const {
+    LOG_INFO("Create PollingDeviceWatcher!");
+
+    if(LibusbDeviceWatcher::hasCapability()) {
+        return std::make_shared<LibusbDeviceWatcher>();
+    }
+    LOG_WARN("Libusb is not available, return nullptr!");
+    return nullptr;
+}
+
+SourcePortInfoList LinuxUsbPal::querySourcePortInfos() {
+    SourcePortInfoList portInfoList;
+
+    const auto &interfaceInfoList = usbEnumerator_->queryUsbInterfaces();
+    for(const auto &info: interfaceInfoList) {
+        auto portInfo      = std::make_shared<USBSourcePortInfo>(cvtUsbClassToPortType(info.cls));
+        portInfo->url      = info.url;
+        portInfo->uid      = info.uid;
+        portInfo->vid      = info.vid;
+        portInfo->pid      = info.pid;
+        portInfo->serial   = info.serial;
+        portInfo->connSpec = usbSpecToString(static_cast<UsbSpec>(info.conn_spec));
+        portInfo->infUrl   = info.infUrl;
+        portInfo->infIndex = info.infIndex;
+        portInfo->infName  = info.infName;
+        portInfo->hubId    = info.hubId;
+
+        portInfoList.push_back(portInfo);
+    }
+
+#if defined(BUILD_GMSL_PAL)
+    const auto &usbInfoList1 = ObV4lGmslDevicePort::queryDevicesInfo();
+    if(usbInfoList1.size() > 0) {
+        for(const auto &info: usbInfoList1) {
+            auto portInfo      = std::make_shared<USBSourcePortInfo>(cvtUsbClassToPortType(info.cls));
+            portInfo->url      = info.url;
+            portInfo->uid      = info.uid;
+            portInfo->vid      = info.vid;
+            portInfo->pid      = info.pid;
+            portInfo->serial   = info.serial;
+            portInfo->connSpec = usbSpecToString(static_cast<UsbSpec>(info.conn_spec));
+            portInfo->infUrl   = info.infUrl;
+            portInfo->infIndex = info.infIndex;
+            portInfo->infName  = info.infName;
+            portInfo->hubId    = info.hubId;
+            portInfoList.push_back(portInfo);
+        }
+    }
+#endif
+    return portInfoList;
+}
+
+void LinuxUsbPal::loadXmlConfig() {
+    auto        envConfig = EnvConfig::getInstance();
+    std::string backend   = "";
+
+    if(envConfig->getStringValue("Device.LinuxUVCBackend", backend)) {
+        if(backend == "V4L2") {
+            uvcBackendType_ = UVC_BACKEND_TYPE_V4L2;
+        }
+        else if(backend == "LibUVC") {
+            uvcBackendType_ = UVC_BACKEND_TYPE_LIBUVC;
+        }
+        else {
+            uvcBackendType_ = UVC_BACKEND_TYPE_AUTO;
+        }
+    }
+    else {
+        uvcBackendType_ = UVC_BACKEND_TYPE_AUTO;
+    }
+    LOG_DEBUG("Uvc backend have been set to {}", static_cast<int>(uvcBackendType_));
+}
+
+}  // namespace libobsensor
+
diff --git a/src/platform/usb/pal/linux/LinuxUsbPal.hpp b/src/platform/usb/pal/linux/LinuxUsbPal.hpp
new file mode 100644
index 00000000..808f14f6
--- /dev/null
+++ b/src/platform/usb/pal/linux/LinuxUsbPal.hpp
@@ -0,0 +1,49 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include "IPal.hpp"
+#include "logger/Logger.hpp"
+#include "exception/ObException.hpp"
+#include "logger/Logger.hpp"
+#include "exception/ObException.hpp"
+
+#include <iostream>
+#include <vector>
+#include <map>
+
+#include "usb/enumerator/IUsbEnumerator.hpp"
+namespace libobsensor {
+
+class LinuxUsbPal : public IPal {
+public:
+    LinuxUsbPal();
+    ~LinuxUsbPal() noexcept override;
+
+    std::shared_ptr<ISourcePort> getSourcePort(std::shared_ptr<const SourcePortInfo> portInfo) override;
+
+public:
+    std::shared_ptr<IDeviceWatcher> createDeviceWatcher() const override;
+    SourcePortInfoList              querySourcePortInfos() override;
+
+private:
+    void loadXmlConfig();
+
+    std::shared_ptr<IUsbEnumerator> usbEnumerator_;
+
+    typedef enum {
+        UVC_BACKEND_TYPE_AUTO,  // if support v4l2 metadata, use v4l2, else use libusb. default is auto
+        UVC_BACKEND_TYPE_LIBUVC,
+        UVC_BACKEND_TYPE_V4L2,
+    } UvcBackendType;
+
+    UvcBackendType uvcBackendType_ = UVC_BACKEND_TYPE_LIBUVC;
+
+private:
+    std::mutex                                                                  sourcePortMapMutex_;
+    std::map<std::shared_ptr<const SourcePortInfo>, std::weak_ptr<ISourcePort>> sourcePortMap_;
+};
+
+}  // namespace libobsensor
+
diff --git a/src/platform/usb/pal/mac/CMakeLists.txt b/src/platform/usb/pal/mac/CMakeLists.txt
new file mode 100644
index 00000000..6550286d
--- /dev/null
+++ b/src/platform/usb/pal/mac/CMakeLists.txt
@@ -0,0 +1,20 @@
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+cmake_minimum_required(VERSION 3.5)
+
+
+file (GLOB _cpp_files "${CMAKE_CURRENT_LIST_DIR}/*.cpp")
+file (GLOB _head_files "${CMAKE_CURRENT_LIST_DIR}/*.hpp")
+
+
+foreach(_file IN ITEMS ${_cpp_files})
+        target_sources(${OB_TARGET_PAL} PRIVATE "${_file}")
+endforeach()
+
+foreach(_file IN ITEMS ${_head_files})
+        target_sources(${OB_TARGET_PAL} PRIVATE "${_file}")
+endforeach()
+
+
+
diff --git a/src/platform/usb/pal/mac/MacUsbPal.cpp b/src/platform/usb/pal/mac/MacUsbPal.cpp
new file mode 100644
index 00000000..3246da79
--- /dev/null
+++ b/src/platform/usb/pal/mac/MacUsbPal.cpp
@@ -0,0 +1,217 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "MacUsbPal.hpp"
+
+#include "logger/Logger.hpp"
+#include "exception/ObException.hpp"
+#include "environment/EnvConfig.hpp"
+
+#include "usb/hid/HidDevicePort.hpp"
+#include "usb/hid/HidDevicePortGmsl.hpp"
+#include "usb/vendor/VendorUsbDevicePort.hpp"
+#include "usb/uvc/ObLibuvcDevicePort.hpp"
+#include "usb/enumerator/UsbEnumeratorLibusb.hpp"
+
+#include <cctype>  // std::tolower
+#include <chrono>
+#include <algorithm>
+
+namespace libobsensor {
+
+const std::vector<uint16_t> FemtoMegaDevPids = {
+    0x0669,  // Femto Mega
+    0x06c0,  // Femto Mega i
+};
+
+template <class T> static bool isMatchDeviceByPid(uint16_t pid, T &pids) {
+    return std::any_of(pids.begin(), pids.end(), [pid](uint16_t pid_) { return pid_ == pid; });
+}
+
+int deviceArrivalCallback(libusb_context *ctx, libusb_device *device, libusb_hotplug_event event, void *user_data);
+int deviceRemovedCallback(libusb_context *ctx, libusb_device *device, libusb_hotplug_event event, void *user_data);
+class LibusbDeviceWatcher : public IDeviceWatcher {
+public:
+    LibusbDeviceWatcher() = default;
+    ~LibusbDeviceWatcher() noexcept override {
+        TRY_EXECUTE(stop());
+        // libusb_exit();
+    }
+    void start(deviceChangedCallback callback) override {
+        callback_ = callback;
+        auto rc   = libusb_hotplug_register_callback(NULL, LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED, 0, 0x2BC5, LIBUSB_HOTPLUG_MATCH_ANY, LIBUSB_HOTPLUG_MATCH_ANY,
+                                                     deviceArrivalCallback, this, &hp[0]);
+        if(LIBUSB_SUCCESS != rc) {
+            LOG_WARN("register libusb hotplug failed!");
+        }
+        rc = libusb_hotplug_register_callback(NULL, LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT, 0, 0x2BC5, LIBUSB_HOTPLUG_MATCH_ANY, LIBUSB_HOTPLUG_MATCH_ANY,
+                                              deviceRemovedCallback, this, &hp[1]);
+        if(LIBUSB_SUCCESS != rc) {
+            LOG_WARN("register libusb hotplug failed!");
+        }
+    }
+
+    void stop() override {
+        libusb_hotplug_deregister_callback(NULL, hp[0]);
+        libusb_hotplug_deregister_callback(NULL, hp[1]);
+    }
+
+    static bool hasCapability() {
+        return libusb_has_capability(LIBUSB_CAP_HAS_HOTPLUG);
+    }
+
+private:
+    libusb_hotplug_callback_handle hp[2];
+    deviceChangedCallback          callback_;
+
+    friend int deviceArrivalCallback(libusb_context *ctx, libusb_device *device, libusb_hotplug_event event, void *user_data);
+    friend int deviceRemovedCallback(libusb_context *ctx, libusb_device *device, libusb_hotplug_event event, void *user_data);
+};
+
+std::string parseDevicePath(libusb_device *usbDevice) {
+    auto usb_bus = std::to_string(libusb_get_bus_number(usbDevice));
+    // As per the USB 3.0 specs, the current maximum limit for the depth is 7.
+    const auto               max_usb_depth            = 8;
+    uint8_t                  usb_ports[max_usb_depth] = {};
+    std::stringstream        port_path;
+    auto                     port_count = libusb_get_port_numbers(usbDevice, usb_ports, max_usb_depth);
+    auto                     usb_dev    = std::to_string(libusb_get_device_address(usbDevice));
+    libusb_device_descriptor dev_desc{};
+    auto                     r = libusb_get_device_descriptor(usbDevice, &dev_desc);
+    (void)r;
+    for(int i = 0; i < port_count; ++i) {
+        port_path << std::to_string(usb_ports[i]) << (((i + 1) < port_count) ? "." : "");
+    }
+    return usb_bus + "-" + port_path.str() + "-" + usb_dev;
+}
+
+int deviceArrivalCallback(libusb_context *ctx, libusb_device *device, libusb_hotplug_event event, void *user_data) {
+    (void)ctx;
+    (void)event;
+    auto watcher = (LibusbDeviceWatcher *)user_data;
+    LOG_DEBUG("Device arrival event occurred");
+    watcher->callback_(OB_DEVICE_ARRIVAL, parseDevicePath(device));
+    return 0;
+}
+
+int deviceRemovedCallback(libusb_context *ctx, libusb_device *device, libusb_hotplug_event event, void *user_data) {
+    (void)ctx;
+    (void)event;
+    auto watcher = (LibusbDeviceWatcher *)user_data;
+    LOG_DEBUG("Device removed event occurred");
+    watcher->callback_(OB_DEVICE_REMOVED, parseDevicePath(device));
+    return 0;
+}
+
+std::shared_ptr<IPal> createUsbPal() {
+    return std::make_shared<MacUsbPal>();
+}
+
+MacUsbPal::MacUsbPal() {
+#if defined(BUILD_USB_PAL)
+    usbEnumerator_ = IUsbEnumerator::getInstance();
+#endif
+}
+
+MacUsbPal::~MacUsbPal() noexcept {}
+
+std::shared_ptr<ISourcePort> MacUsbPal::getSourcePort(std::shared_ptr<const SourcePortInfo> portInfo) {
+    std::unique_lock<std::mutex> lock(sourcePortMapMutex_);
+    std::shared_ptr<ISourcePort> port;
+
+    // clear expired weak_ptr
+    for(auto it = sourcePortMap_.begin(); it != sourcePortMap_.end();) {
+        if(it->second.expired()) {
+            it = sourcePortMap_.erase(it);
+        }
+        else {
+            ++it;
+        }
+    }
+
+    // check if the port already exists in the map
+    for(const auto &pair: sourcePortMap_) {
+        if(pair.first->equal(portInfo)) {
+            port = pair.second.lock();
+            if(port != nullptr) {
+                return port;
+            }
+        }
+    }
+
+    switch(portInfo->portType) {
+    case SOURCE_PORT_USB_VENDOR: {
+        auto url    = std::dynamic_pointer_cast<const USBSourcePortInfo>(portInfo)->url;
+        auto usbDev = usbEnumerator_->openUsbDevice(url);
+        if(usbDev == nullptr) {
+            throw libobsensor::camera_disconnected_exception("usbEnumerator openUsbDevice failed!");
+        }
+        port = std::make_shared<VendorUsbDevicePort>(usbDev, std::dynamic_pointer_cast<const USBSourcePortInfo>(portInfo));
+        LOG_DEBUG("Vendor device have been create! url: {}", url);
+        break;
+    }
+    case SOURCE_PORT_USB_UVC: {
+        auto usbPortInfo = std::dynamic_pointer_cast<const USBSourcePortInfo>(portInfo);
+        auto usbDev = usbEnumerator_->openUsbDevice(std::dynamic_pointer_cast<const USBSourcePortInfo>(portInfo)->url);
+        if(usbDev == nullptr) {
+            throw libobsensor::camera_disconnected_exception("usbEnumerator openUsbDevice failed!");
+        }
+        port = std::make_shared<ObLibuvcDevicePort>(usbDev, std::dynamic_pointer_cast<const USBSourcePortInfo>(portInfo));
+        LOG_DEBUG("UVC device have been create with LibUVC backend! dev: {}, inf: {}", usbPortInfo->url, usbPortInfo->infUrl);
+        break;
+    }
+    case SOURCE_PORT_USB_HID: {
+        auto usbPortInfo = std::dynamic_pointer_cast<const USBSourcePortInfo>(portInfo);
+        auto usbDev = usbEnumerator_->openUsbDevice(std::dynamic_pointer_cast<const USBSourcePortInfo>(portInfo)->url);
+        if(usbDev == nullptr) {
+            throw libobsensor::camera_disconnected_exception("usbEnumerator openUsbDevice failed!");
+        }
+        port = std::make_shared<HidDevicePort>(usbDev, std::dynamic_pointer_cast<const USBSourcePortInfo>(portInfo));
+        LOG_DEBUG("HID device have been create with HID backend! dev: {}, inf: {}", usbPortInfo->url, usbPortInfo->infUrl);
+        break;
+    }
+
+    default:
+        throw libobsensor::invalid_value_exception("unsupported source port type!");
+        break;
+    }
+    if(port != nullptr) {
+        sourcePortMap_.insert(std::make_pair(portInfo, port));
+    }
+    return port;
+}
+
+std::shared_ptr<IDeviceWatcher> MacUsbPal::createDeviceWatcher() const {
+    LOG_INFO("Create PollingDeviceWatcher!");
+
+    if(LibusbDeviceWatcher::hasCapability()) {
+        return std::make_shared<LibusbDeviceWatcher>();
+    }
+    LOG_WARN("Libusb is not available, return nullptr!");
+    return nullptr;
+}
+
+SourcePortInfoList MacUsbPal::querySourcePortInfos() {
+    SourcePortInfoList portInfoList;
+
+    const auto &interfaceInfoList = usbEnumerator_->queryUsbInterfaces();
+    for(const auto &info: interfaceInfoList) {
+        auto portInfo      = std::make_shared<USBSourcePortInfo>(cvtUsbClassToPortType(info.cls));
+        portInfo->url      = info.url;
+        portInfo->uid      = info.uid;
+        portInfo->vid      = info.vid;
+        portInfo->pid      = info.pid;
+        portInfo->serial   = info.serial;
+        portInfo->connSpec = usbSpecToString(static_cast<UsbSpec>(info.conn_spec));
+        portInfo->infUrl   = info.infUrl;
+        portInfo->infIndex = info.infIndex;
+        portInfo->infName  = info.infName;
+        portInfo->hubId    = info.hubId;
+
+        portInfoList.push_back(portInfo);
+    }
+    return portInfoList;
+}
+
+}  // namespace libobsensor
+
diff --git a/src/platform/usb/pal/mac/MacUsbPal.hpp b/src/platform/usb/pal/mac/MacUsbPal.hpp
new file mode 100644
index 00000000..3f3a1fe7
--- /dev/null
+++ b/src/platform/usb/pal/mac/MacUsbPal.hpp
@@ -0,0 +1,37 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include "IPal.hpp"
+#include "logger/Logger.hpp"
+#include "exception/ObException.hpp"
+#include "logger/Logger.hpp"
+#include "exception/ObException.hpp"
+
+#include <iostream>
+#include <vector>
+#include <map>
+
+#include "usb/enumerator/IUsbEnumerator.hpp"
+namespace libobsensor {
+
+class MacUsbPal : public IPal {
+public:
+    MacUsbPal();
+    ~MacUsbPal() noexcept override;
+
+    std::shared_ptr<ISourcePort> getSourcePort(std::shared_ptr<const SourcePortInfo> portInfo) override;
+
+public:
+    std::shared_ptr<IDeviceWatcher> createDeviceWatcher() const override;
+    SourcePortInfoList              querySourcePortInfos() override;
+
+private:
+    std::shared_ptr<IUsbEnumerator> usbEnumerator_;
+    std::mutex                                                                  sourcePortMapMutex_;
+    std::map<std::shared_ptr<const SourcePortInfo>, std::weak_ptr<ISourcePort>> sourcePortMap_;
+};
+
+}  // namespace libobsensor
+
diff --git a/src/platform/usb/pal/win/CMakeLists.txt b/src/platform/usb/pal/win/CMakeLists.txt
new file mode 100644
index 00000000..319cccd3
--- /dev/null
+++ b/src/platform/usb/pal/win/CMakeLists.txt
@@ -0,0 +1,13 @@
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+cmake_minimum_required(VERSION 3.5)
+
+file(GLOB PAL_SOURCES ${CMAKE_CURRENT_LIST_DIR}/WinUsbPal.*)
+
+if (OB_BUILD_USB_PAL)
+    list(APPEND PAL_SOURCES ${CMAKE_CURRENT_LIST_DIR}/WinUsbPal.cpp)
+    list(APPEND PAL_SOURCES ${CMAKE_CURRENT_LIST_DIR}/WinUsbPal.hpp)
+endif ()
+
+target_sources(${OB_TARGET_PAL} PRIVATE ${PAL_SOURCES})
diff --git a/src/platform/usb/pal/win/WinUsbPal.cpp b/src/platform/usb/pal/win/WinUsbPal.cpp
new file mode 100644
index 00000000..9459d826
--- /dev/null
+++ b/src/platform/usb/pal/win/WinUsbPal.cpp
@@ -0,0 +1,458 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "WinUsbPal.hpp"
+
+#if(_MSC_FULL_VER < 180031101)
+#error At least Visual Studio 2013 Update 4 is required to compile this backend
+#endif
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <Windows.h>
+
+#include <dbt.h>
+#include <mfapi.h>
+#include <ks.h>
+#pragma comment(lib, "mf.lib")
+#pragma comment(lib, "mfreadwrite")
+#pragma comment(lib, "mfplat.lib")
+#pragma comment(lib, "mfreadwrite.lib")
+#pragma comment(lib, "mfuuid.lib")
+
+#include <cctype>  //Std::tolower
+#include <chrono>
+#include <memory>
+#include <sstream>
+
+#include "usb/uvc/WmfUvcDevicePort.hpp"
+#include "usb/hid/HidDevicePort.hpp"
+#include "usb/vendor/VendorUsbDevicePort.hpp"
+
+#include "logger/Logger.hpp"
+#include "exception/ObException.hpp"
+#include "utils/Utils.hpp"
+
+constexpr GUID     GUID_DEVINTERFACE_USB_DEVICE = { 0xA5DCBF10, 0x6530, 0x11D2, { 0x90, 0x1F, 0x00, 0xC0, 0x4F, 0xB9, 0x51, 0xED } };
+constexpr uint16_t PID_BOOTLOADER_UVC           = 0x0501;
+namespace libobsensor {
+
+class WinUsbDeviceWatcher : public IDeviceWatcher {
+public:
+    WinUsbDeviceWatcher(const IPal *backend);
+    ~WinUsbDeviceWatcher() noexcept override;
+
+    void start(deviceChangedCallback callback) override;
+    void stop() override;
+
+private:
+    void                    run();
+    static LRESULT CALLBACK onWinEvent(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam);
+    static bool             registerDeviceInterfaceToHwnd(HWND hWnd);
+
+private:
+    std::thread eventThread_;
+    std::mutex  mutex_;
+    struct extra_data {
+        const IPal           *backend_;
+        deviceChangedCallback callback_;
+        bool                  stopped_;
+        HWND                  hWnd;
+        HDEVNOTIFY            hDevNotifyHW;
+        HDEVNOTIFY            hDevNotifyUVC;
+        HDEVNOTIFY            hDevNotifySensor;
+        HDEVNOTIFY            hDevNotifyHID;
+        HDEVNOTIFY            hDevNotifyUSB;
+        HDEVNOTIFY            hDevNotifyOpenNI;
+    } extraData_;
+};
+
+std::vector<std::string> stringSplit(const std::string &string, char separator) {
+    std::vector<std::string> tokens;
+    std::string::size_type   i1 = 0;
+    while(true) {
+        auto i2 = string.find(separator, i1);
+        if(i2 == std::string::npos) {
+            tokens.push_back(string.substr(i1));
+            return tokens;
+        }
+        tokens.push_back(string.substr(i1, i2 - i1));
+        i1 = i2 + 1;
+    }
+}
+
+bool parseSymbolicLink(const std::string &symbolicLink, uint16_t &vid, uint16_t &pid, uint16_t &mi, std::string &uid, std::string &device_guid) {
+    auto lowerStr = utils::string::toLower(symbolicLink);
+    auto tokens   = stringSplit(lowerStr, '#');
+    if(tokens.empty() || (tokens[0] != R"(\\?\usb)" && tokens[0] != R"(\\?\hid)"))
+        return false;  // Not a USB device
+    if(tokens.size() < 3) {
+        return false;
+    }
+
+    auto ids = stringSplit(tokens[1], '&');
+    if(ids[0].size() != 8 || ids[0].substr(0, 4) != "vid_" || !(std::istringstream(ids[0].substr(4, 4)) >> std::hex >> vid)) {
+        return false;
+    }
+    if(ids[1].size() != 8 || ids[1].substr(0, 4) != "pid_" || !(std::istringstream(ids[1].substr(4, 4)) >> std::hex >> pid)) {
+        return false;
+    }
+    if(ids.size() > 2 && (ids[2].size() != 5 || ids[2].substr(0, 3) != "mi_" || !(std::istringstream(ids[2].substr(3, 2)) >> mi))) {
+        return false;
+    }
+    ids = stringSplit(tokens[2], '&');
+    if(ids.empty()) {
+        return false;
+    }
+
+    if(ids.size() > 2)
+        uid = ids[1];
+    else
+        uid = "";
+
+    if(tokens.size() >= 3)
+        device_guid = tokens[3];
+
+    return true;
+}
+
+std::shared_ptr<IPal> createUsbPal() {
+    return std::make_shared<WinUsbPal>();
+}
+
+WinUsbPal::WinUsbPal() {
+    LOG_DEBUG("WinUsbPal init ...");
+    // when using COINIT_APARTMENTTHREADED, calling _pISensor->SetEventSink(NULL) to stop sensor can take several seconds
+    CoInitializeEx(nullptr, COINIT_MULTITHREADED);
+    MFStartup(MF_VERSION, MFSTARTUP_NOSOCKET);
+
+    usbEnumerator_ = IUsbEnumerator::getInstance();
+    LOG_DEBUG("WinUsbPal created!");
+}
+
+WinUsbPal::~WinUsbPal() noexcept {
+    TRY_EXECUTE({
+        MFShutdown();
+        CoUninitialize();
+    });
+    LOG_DEBUG("WinUsbPal destroyed!");
+}
+
+std::shared_ptr<ISourcePort> WinUsbPal::getSourcePort(std::shared_ptr<const SourcePortInfo> portInfo) {
+    std::unique_lock<std::mutex> lock(sourcePortMapMutex_);
+    std::shared_ptr<ISourcePort> port;
+
+    // clear expired weak_ptr
+    for(auto it = sourcePortMap_.begin(); it != sourcePortMap_.end();) {
+        if(it->second.expired()) {
+            it = sourcePortMap_.erase(it);
+        }
+        else {
+            ++it;
+        }
+    }
+
+    // check if the port already exists in the map
+    for(const auto &pair: sourcePortMap_) {
+        if(pair.first == portInfo) {
+            port = pair.second.lock();
+            if(port != nullptr) {
+                return port;
+            }
+        }
+    }
+
+    switch(portInfo->portType) {
+    case SOURCE_PORT_USB_VENDOR: {
+        auto usbDev = usbEnumerator_->openUsbDevice(std::dynamic_pointer_cast<const USBSourcePortInfo>(portInfo)->url);
+        if(usbDev == nullptr) {
+            throw libobsensor::camera_disconnected_exception("usbEnumerator openUsbDevice failed!");
+        }
+        port = std::make_shared<VendorUsbDevicePort>(usbDev, std::dynamic_pointer_cast<const USBSourcePortInfo>(portInfo));
+        break;
+    }
+    case SOURCE_PORT_USB_UVC:
+        port = std::make_shared<WmfUvcDevicePort>(std::dynamic_pointer_cast<const USBSourcePortInfo>(portInfo));
+        break;
+    case SOURCE_PORT_USB_HID: {
+        auto usbPortInfo = std::dynamic_pointer_cast<const USBSourcePortInfo>(portInfo);
+        auto usbDev      = usbEnumerator_->openUsbDevice(std::dynamic_pointer_cast<const USBSourcePortInfo>(portInfo)->url);
+        if(usbDev == nullptr) {
+            throw libobsensor::camera_disconnected_exception("usbEnumerator openUsbDevice failed!");
+        }
+        port = std::make_shared<HidDevicePort>(usbDev, std::dynamic_pointer_cast<const USBSourcePortInfo>(portInfo));
+
+        break;
+    }
+    default:
+        throw libobsensor::invalid_value_exception("unsupported source port type!");
+    }
+
+    sourcePortMap_.insert(std::make_pair(portInfo, port));
+    return port;
+}
+
+std::shared_ptr<IDeviceWatcher> WinUsbPal::createDeviceWatcher() const {
+    LOG_DEBUG("Create WinUsbDeviceWatcher!");
+    return std::make_shared<WinUsbDeviceWatcher>(this);
+}
+
+SourcePortInfoList WinUsbPal::querySourcePortInfos() {
+    SourcePortInfoList portInfoList;
+
+    auto action = [&](const UsbInterfaceInfo &info, IMFActivate *) {
+        UsbSpec     usbSpec;
+        std::string hubId, serial, url;
+        if(getUsbDescriptors(info.vid, info.pid, info.uid, hubId, usbSpec, serial, url)) {
+            auto portInfo      = std::make_shared<USBSourcePortInfo>();
+            portInfo->portType = SOURCE_PORT_USB_UVC;
+            portInfo->url      = url;
+            portInfo->uid      = info.uid;
+            portInfo->vid      = info.vid;
+            portInfo->pid      = info.pid;
+            portInfo->serial   = serial;
+            portInfo->connSpec = usbSpecToString(static_cast<UsbSpec>(usbSpec));
+            portInfo->infUrl   = info.infUrl;
+            portInfo->infIndex = info.infIndex;
+            portInfo->infName  = info.infName;
+            portInfo->hubId    = hubId;
+
+            portInfoList.push_back(portInfo);
+        }
+    };
+
+    WmfUvcDevicePort::foreachUvcDevice(action);
+
+    const auto &usbInfoList = usbEnumerator_->queryUsbInterfaces();
+    for(const auto &info: usbInfoList) {
+        if(info.vid == 0x2bc5 && (info.cls == OB_USB_CLASS_HID || info.cls == OB_USB_CLASS_VENDOR_SPECIFIC)) {
+            // 1. Filter non orbbec devices 2. Filter uvc class
+            auto portInfo      = std::make_shared<USBSourcePortInfo>();
+            portInfo->portType = info.cls == OB_USB_CLASS_HID ? SOURCE_PORT_USB_HID : SOURCE_PORT_USB_VENDOR;
+            portInfo->url      = info.url;
+            portInfo->uid      = info.uid;
+            portInfo->vid      = info.vid;
+            portInfo->pid      = info.pid;
+            portInfo->serial   = info.serial;
+            portInfo->connSpec = usbSpecToString(static_cast<UsbSpec>(info.conn_spec));
+            portInfo->infUrl   = info.infUrl;
+            portInfo->infIndex = info.infIndex;
+            portInfo->infName  = info.infName;
+            portInfo->hubId    = info.hubId;
+
+            if(portInfo->infUrl.empty()) {
+                LOG_WARN("Found a usb port without interface url! drop it!(device url={} interface index={})", info.url,
+                         static_cast<uint32_t>(portInfo->infIndex));
+                break;
+            }
+            portInfoList.push_back(portInfo);
+        }
+    }
+    return portInfoList;
+}
+
+WinUsbDeviceWatcher::WinUsbDeviceWatcher(const IPal *backend) {
+    extraData_.backend_ = backend;
+    extraData_.stopped_ = true;
+}
+
+WinUsbDeviceWatcher::~WinUsbDeviceWatcher() noexcept {
+    WinUsbDeviceWatcher::stop();
+}
+
+void WinUsbDeviceWatcher::start(deviceChangedCallback callback) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    if(!extraData_.stopped_)
+        throw wrong_api_call_sequence_exception("Cannot start a running device_watcher");
+    extraData_.stopped_  = false;
+    extraData_.callback_ = std::move(callback);
+    eventThread_         = std::thread([this]() { run(); });
+}
+
+void WinUsbDeviceWatcher::stop() {
+    std::lock_guard<std::mutex> lock(mutex_);
+    if(!extraData_.stopped_) {
+        extraData_.stopped_ = true;
+        if(eventThread_.joinable())
+            eventThread_.join();
+    }
+}
+
+void WinUsbDeviceWatcher::run() {
+    WNDCLASS windowClass      = {};
+    LPCWSTR  winClassName     = TEXT("OBMINWINAPP");
+    windowClass.lpfnWndProc   = &onWinEvent;
+    windowClass.lpszClassName = winClassName;
+    UnregisterClass(winClassName, nullptr);
+
+    if(!RegisterClass(&windowClass))
+        LOG_WARN("RegisterClass failed.");
+
+    extraData_.hWnd = CreateWindow(winClassName, nullptr, 0, 0, 0, 0, 0, HWND_MESSAGE, nullptr, nullptr, &extraData_);
+    if(!extraData_.hWnd)
+        throw wrong_api_call_sequence_exception("CreateWindow failed");
+
+    MSG msg;
+
+    while(!extraData_.stopped_) {
+        if(PeekMessage(&msg, extraData_.hWnd, 0, 0, PM_REMOVE)) {
+            TranslateMessage(&msg);
+            DispatchMessage(&msg);
+        }
+        else  // Yield CPU resources, as this is required for connect/disconnect events only
+            std::this_thread::sleep_for(std::chrono::milliseconds(1));
+    }
+
+    // UnregisterDeviceNotification(extraData_.hDevNotifyHW);
+    UnregisterDeviceNotification(extraData_.hDevNotifyUVC);
+    UnregisterDeviceNotification(extraData_.hDevNotifySensor);
+    UnregisterDeviceNotification(extraData_.hDevNotifyHID);
+    UnregisterDeviceNotification(extraData_.hDevNotifyUSB);
+    UnregisterDeviceNotification(extraData_.hDevNotifyOpenNI);
+    DestroyWindow(extraData_.hWnd);
+}
+
+std::string wideCharToUTF8(const wchar_t *wStr) {
+    int size = WideCharToMultiByte(CP_UTF8, 0, wStr, -1, nullptr, 0, nullptr, nullptr);
+    if(size <= 0) {
+        return "";
+    }
+    std::string result(size - 1, '\0');
+    if(WideCharToMultiByte(CP_UTF8, 0, wStr, -1, &result[0], size, nullptr, nullptr) != size) {
+        return "";
+    }
+    return result;
+}
+
+LRESULT CALLBACK WinUsbDeviceWatcher::onWinEvent(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) {
+    LRESULT lRet = 1;
+    switch(message) {
+    case WM_CREATE:
+        SetWindowLongPtr(hWnd, GWLP_USERDATA, reinterpret_cast<LONG_PTR>(reinterpret_cast<CREATESTRUCT *>(lParam)->lpCreateParams));
+        if(!registerDeviceInterfaceToHwnd(hWnd)) {
+            auto watcherExtraData      = reinterpret_cast<extra_data *>(GetWindowLongPtr(hWnd, GWLP_USERDATA));
+            watcherExtraData->stopped_ = true;
+        }
+        break;
+
+    case WM_QUIT: {
+        auto watcherExtraData      = reinterpret_cast<extra_data *>(GetWindowLongPtr(hWnd, GWLP_USERDATA));
+        watcherExtraData->stopped_ = true;
+        break;
+    }
+    case WM_DEVICECHANGE: {
+        if(wParam == DBT_DEVICEARRIVAL || wParam == DBT_DEVICEREMOVECOMPLETE) {
+            uint16_t    vid = 0;
+            uint16_t    pid;
+            uint16_t    mi;
+            std::string uid;
+            std::string device_guid;
+            auto        devIntf      = reinterpret_cast<PDEV_BROADCAST_DEVICEINTERFACE>(lParam);
+            std::string symbolicLink = wideCharToUTF8(devIntf->dbcc_name);
+            if(parseSymbolicLink(symbolicLink, vid, pid, mi, uid, device_guid) && vid == 0x2bc5) {
+                auto watcherExtraData = reinterpret_cast<extra_data *>(GetWindowLongPtr(hWnd, GWLP_USERDATA));
+                symbolicLink          = utils::string::toUpper(symbolicLink);
+                if(wParam == DBT_DEVICEARRIVAL) {
+                    LOG_DEBUG("Device arrival event occurred! symbolicLink={}", symbolicLink);
+                    if(devIntf->dbcc_classguid != GUID_DEVINTERFACE_USB_DEVICE || PID_BOOTLOADER_UVC == pid) {
+                        watcherExtraData->callback_(OB_DEVICE_ARRIVAL, symbolicLink);
+                    }
+                }
+                else if(wParam == DBT_DEVICEREMOVECOMPLETE) {
+                    LOG_DEBUG("Device removed event occurred! symbolicLink={}", symbolicLink);
+                    if(devIntf->dbcc_classguid == GUID_DEVINTERFACE_USB_DEVICE) {
+                        watcherExtraData->callback_(OB_DEVICE_REMOVED, symbolicLink);
+                    }
+                }
+            }
+        }
+        break;
+    }
+
+    default:
+        // Send all other messages on to the default windows handler.
+        lRet = DefWindowProc(hWnd, message, wParam, lParam);
+        break;
+    }
+
+    return lRet;
+}
+
+bool WinUsbDeviceWatcher::registerDeviceInterfaceToHwnd(HWND hWnd) {
+    auto data = reinterpret_cast<extra_data *>(GetWindowLongPtr(hWnd, GWLP_USERDATA));
+
+    //===========================register HWmonitor events==============================
+    const GUID                    classGuid = { 0x175695cd, 0x30d9, 0x4f87, 0x8b, 0xe3, 0x5a, 0x82, 0x70, 0xf4, 0x9a, 0x31 };
+    DEV_BROADCAST_DEVICEINTERFACE devBroadcastDeviceInterface;
+    devBroadcastDeviceInterface.dbcc_size       = sizeof(DEV_BROADCAST_DEVICEINTERFACE);
+    devBroadcastDeviceInterface.dbcc_devicetype = DBT_DEVTYP_DEVICEINTERFACE;
+    devBroadcastDeviceInterface.dbcc_classguid  = classGuid;
+    devBroadcastDeviceInterface.dbcc_reserved   = 0;
+
+    data->hDevNotifyHW = RegisterDeviceNotification(hWnd, &devBroadcastDeviceInterface, DEVICE_NOTIFY_WINDOW_HANDLE);
+    if(data->hDevNotifyHW == nullptr) {
+        UnregisterDeviceNotification(data->hDevNotifyHW);
+        LOG_WARN("Register HW events Failed!");
+        return false;
+    }
+
+    //===========================register UVC events==============================
+    DEV_BROADCAST_DEVICEINTERFACE di = { 0 };
+    di.dbcc_size                     = sizeof(di);
+    di.dbcc_devicetype               = DBT_DEVTYP_DEVICEINTERFACE;
+    di.dbcc_classguid                = KSCATEGORY_CAPTURE;
+
+    data->hDevNotifyUVC = RegisterDeviceNotification(hWnd, &di, DEVICE_NOTIFY_WINDOW_HANDLE);
+    if(data->hDevNotifyUVC == nullptr) {
+        UnregisterDeviceNotification(data->hDevNotifyUVC);
+        LOG_WARN("Register UVC events Failed!");
+        return false;
+    }
+
+    //===========================register UVC sensor camera events==============================
+    DEV_BROADCAST_DEVICEINTERFACE di_sensor = { 0 };
+    di_sensor.dbcc_size                     = sizeof(di_sensor);
+    di_sensor.dbcc_devicetype               = DBT_DEVTYP_DEVICEINTERFACE;
+    di_sensor.dbcc_classguid                = KSCATEGORY_SENSOR_CAMERA;
+
+    data->hDevNotifySensor = RegisterDeviceNotification(hWnd, &di_sensor, DEVICE_NOTIFY_WINDOW_HANDLE);
+    if(data->hDevNotifySensor == nullptr) {
+        UnregisterDeviceNotification(data->hDevNotifySensor);
+        LOG_WARN("Register UVC events Failed!");
+        return false;
+    }
+
+    //===========================register HID sensor camera events==============================
+    static constexpr GUID GUID_DEVINTERFACE_HID = { 0x4d1e55b2, 0xf16f, 0x11cf, { 0x88, 0xcb, 0x00, 0x11, 0x11, 0x00, 0x00, 0x30 } };
+
+    DEV_BROADCAST_DEVICEINTERFACE hid_sensor = { 0 };
+    hid_sensor.dbcc_size                     = sizeof(hid_sensor);
+    hid_sensor.dbcc_devicetype               = DBT_DEVTYP_DEVICEINTERFACE;
+    hid_sensor.dbcc_classguid                = GUID_DEVINTERFACE_HID;
+
+    data->hDevNotifyHID = RegisterDeviceNotification(hWnd, &hid_sensor, DEVICE_NOTIFY_WINDOW_HANDLE);
+    if(data->hDevNotifyHID == nullptr) {
+        UnregisterDeviceNotification(data->hDevNotifyHID);
+        LOG_WARN("Register hid events Failed!");
+        return false;
+    }
+
+    //===========================register usb device events==============================
+    DEV_BROADCAST_DEVICEINTERFACE devBroadcastUsbDeviceInterface;
+    devBroadcastUsbDeviceInterface.dbcc_size       = sizeof(DEV_BROADCAST_DEVICEINTERFACE);
+    devBroadcastUsbDeviceInterface.dbcc_devicetype = DBT_DEVTYP_DEVICEINTERFACE;
+    devBroadcastUsbDeviceInterface.dbcc_classguid  = GUID_DEVINTERFACE_USB_DEVICE;
+    devBroadcastUsbDeviceInterface.dbcc_reserved   = 0;
+
+    data->hDevNotifyUSB = RegisterDeviceNotification(hWnd, &devBroadcastUsbDeviceInterface, DEVICE_NOTIFY_WINDOW_HANDLE);
+    if(data->hDevNotifyUSB == nullptr) {
+        UnregisterDeviceNotification(data->hDevNotifyUSB);
+        LOG_WARN("Register HW events Failed!");
+        return false;
+    }
+
+    return true;
+}
+
+}  // namespace libobsensor
+
diff --git a/src/platform/usb/pal/win/WinUsbPal.hpp b/src/platform/usb/pal/win/WinUsbPal.hpp
new file mode 100644
index 00000000..110a7154
--- /dev/null
+++ b/src/platform/usb/pal/win/WinUsbPal.hpp
@@ -0,0 +1,30 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include "IPal.hpp"
+#include <map>
+
+#include "usb/enumerator/IUsbEnumerator.hpp"
+
+namespace libobsensor {
+
+class WinUsbPal : public IPal, public std::enable_shared_from_this<WinUsbPal> {
+public:
+    WinUsbPal();
+    virtual ~WinUsbPal() noexcept override;
+
+    std::shared_ptr<ISourcePort>    getSourcePort(std::shared_ptr<const SourcePortInfo> portInfo) override;
+    std::shared_ptr<IDeviceWatcher> createDeviceWatcher() const override;
+    SourcePortInfoList              querySourcePortInfos() override;
+
+private:
+    std::shared_ptr<IUsbEnumerator> usbEnumerator_;
+
+private:
+    std::mutex                                                                  sourcePortMapMutex_;
+    std::map<std::shared_ptr<const SourcePortInfo>, std::weak_ptr<ISourcePort>> sourcePortMap_;
+};
+
+}  // namespace libobsensor
+
diff --git a/src/platform/usb/uvc/CMakeLists.txt b/src/platform/usb/uvc/CMakeLists.txt
new file mode 100644
index 00000000..7ecdcdfe
--- /dev/null
+++ b/src/platform/usb/uvc/CMakeLists.txt
@@ -0,0 +1,27 @@
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+cmake_minimum_required(VERSION 3.5)
+
+if(OB_BUILD_WIN32)
+    target_sources(${OB_TARGET_PAL} PRIVATE "${CMAKE_CURRENT_LIST_DIR}/WmfUvcDevicePort.cpp")
+    target_sources(${OB_TARGET_PAL} PRIVATE "${CMAKE_CURRENT_LIST_DIR}/WmfUvcDevicePort.hpp")
+    target_sources(${OB_TARGET_PAL} PRIVATE "${CMAKE_CURRENT_LIST_DIR}/WinHelpers.hpp")
+    target_sources(${OB_TARGET_PAL} PRIVATE "${CMAKE_CURRENT_LIST_DIR}/WinHelpers.cpp")
+
+else()
+    target_sources(${OB_TARGET_PAL} PRIVATE "${CMAKE_CURRENT_LIST_DIR}/UvcTypes.hpp")
+    target_sources(${OB_TARGET_PAL} PRIVATE "${CMAKE_CURRENT_LIST_DIR}/ObLibuvcDevicePort.cpp")
+    target_sources(${OB_TARGET_PAL} PRIVATE "${CMAKE_CURRENT_LIST_DIR}/ObLibuvcDevicePort.hpp")
+
+    if(OB_BUILD_LINUX)
+        target_sources(${OB_TARGET_PAL} PRIVATE "${CMAKE_CURRENT_LIST_DIR}/ObV4lUvcDevicePort.hpp")
+        target_sources(${OB_TARGET_PAL} PRIVATE "${CMAKE_CURRENT_LIST_DIR}/ObV4lUvcDevicePort.cpp")
+        if(OB_BUILD_GMSL_PAL)
+            target_sources(${OB_TARGET_PAL} PRIVATE "${CMAKE_CURRENT_LIST_DIR}/ObV4lGmslDevicePort.hpp")
+            target_sources(${OB_TARGET_PAL} PRIVATE "${CMAKE_CURRENT_LIST_DIR}/ObV4lGmslDevicePort.cpp")
+            target_sources(${OB_TARGET_PAL} PRIVATE "${CMAKE_CURRENT_LIST_DIR}/ObV4lGmslHostProtocolTypes.hpp")
+        endif()
+    endif()
+endif()
+
diff --git a/src/platform/usb/uvc/ObLibuvcDevicePort.cpp b/src/platform/usb/uvc/ObLibuvcDevicePort.cpp
new file mode 100644
index 00000000..4fdbd12f
--- /dev/null
+++ b/src/platform/usb/uvc/ObLibuvcDevicePort.cpp
@@ -0,0 +1,604 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "ObLibuvcDevicePort.hpp"
+#include "UvcTypes.hpp"
+#include "logger/Logger.hpp"
+#include "exception/ObException.hpp"
+#include "utils/Utils.hpp"
+#include "utils/PublicTypeHelper.hpp"
+#include "frame/FrameFactory.hpp"
+#include "stream/StreamProfileFactory.hpp"
+#include "stream/StreamProfile.hpp"
+#include "usb/enumerator/UsbEnumeratorLibusb.hpp"
+
+#include <utlist.h>
+#include <libuvc/libuvc_internal.h>
+#include <algorithm>
+
+#define UVC_AE_MODE_D0_MANUAL (1 << 0)
+#define UVC_AE_MODE_D1_AUTO (1 << 1)
+#define UVC_AE_MODE_D2_SP (1 << 2)
+#define UVC_AE_MODE_D3_AP (1 << 3)
+
+#ifdef __ANDROID__
+#include "pal/android/AndroidUsbDeviceManager.hpp"
+#endif
+
+namespace libobsensor {
+using utils::fourCc2Int;
+const std::map<uint32_t, uvc_frame_format> fourccToUvcFormatMap = {
+    { fourCc2Int('U', 'Y', 'V', 'Y'), UVC_FRAME_FORMAT_UYVY }, { fourCc2Int('Y', 'U', 'Y', '2'), UVC_FRAME_FORMAT_YUYV },
+    { fourCc2Int('N', 'V', '1', '2'), UVC_FRAME_FORMAT_NV12 }, { fourCc2Int('I', '4', '2', '0'), UVC_FRAME_FORMAT_I420 },
+    { fourCc2Int('N', 'V', '2', '1'), UVC_FRAME_FORMAT_NV21 }, { fourCc2Int('M', 'J', 'P', 'G'), UVC_FRAME_FORMAT_MJPEG },
+    { fourCc2Int('H', '2', '6', '4'), UVC_FRAME_FORMAT_H264 }, { fourCc2Int('H', 'E', 'V', 'C'), UVC_FRAME_FORMAT_HEVC },
+    { fourCc2Int('Y', '8', ' ', ' '), UVC_FRAME_FORMAT_Y8 },   { fourCc2Int('Y', '1', '0', ' '), UVC_FRAME_FORMAT_Y10 },
+    { fourCc2Int('Y', '1', '1', ' '), UVC_FRAME_FORMAT_Y11 },  { fourCc2Int('Y', '1', '2', ' '), UVC_FRAME_FORMAT_Y12 },
+    { fourCc2Int('Y', '1', '4', ' '), UVC_FRAME_FORMAT_Y14 },  { fourCc2Int('Y', '1', '6', ' '), UVC_FRAME_FORMAT_Y16 },
+    { fourCc2Int('R', 'V', 'L', ' '), UVC_FRAME_FORMAT_RVL },  { fourCc2Int('Z', '1', '6', ' '), UVC_FRAME_FORMAT_Z16 },
+    { fourCc2Int('Y', 'V', '1', '2'), UVC_FRAME_FORMAT_YV12 }, { fourCc2Int('B', 'A', '8', '1'), UVC_FRAME_FORMAT_BA81 },
+};
+
+uvc_frame_format fourCC2UvcFormat(int32_t fourccCode) {
+    uvc_frame_format uvcFormat = UVC_FRAME_FORMAT_UNKNOWN;
+    std::find_if(fourccToUvcFormatMap.begin(), fourccToUvcFormatMap.end(), [&](const std::pair<uint32_t, uvc_frame_format> sf) {
+        if(static_cast<uint32_t>(fourccCode) == sf.first) {
+            uvcFormat = sf.second;
+            return true;
+        }
+        return false;
+    });
+    return uvcFormat;
+}
+
+ObLibuvcDevicePort::ObLibuvcDevicePort(std::shared_ptr<IUsbDevice> usbDev, std::shared_ptr<const USBSourcePortInfo> portInfo)
+    : usbDev_(usbDev), portInfo_(portInfo) {
+    auto libusbDev       = std::dynamic_pointer_cast<UsbDeviceLibusb>(usbDev_);
+    auto libusbCtx       = libusbDev->getLibusbContext();
+    auto libusbDevHandle = libusbDev->getLibusbDeviceHandle();
+    uvc_init(&uvcCtx_, libusbCtx);
+    uvcDev_          = (uvc_device_t *)malloc(sizeof(*uvcDev_));
+    uvcDev_->ctx     = uvcCtx_;
+    uvcDev_->ref     = 0;
+    uvcDev_->usb_dev = libusb_get_device(libusbDevHandle);
+
+    auto res = uvc_open(uvcDev_, portInfo->infIndex, &uvcDevHandle_, libusbDevHandle);
+    if(res < 0) {
+        LOG_WARN("uvc_open  path={} already opened", portInfo->infUrl);
+        std::stringstream ss;
+        ss << "uvc_open  path=" << portInfo->infUrl << " failed,return res" << res;
+        LOG_WARN("uvc_open  path={0} failed,return res:${1}", portInfo->infUrl, res);
+        throw std::runtime_error(ss.str());
+    }
+    else {
+        LOG_DEBUG("uvc_open success");
+    }
+}
+
+ObLibuvcDevicePort::~ObLibuvcDevicePort() noexcept {
+    LOG_DEBUG("~ObLibuvcDevicePort");
+    stopAllStream();
+
+    // free(uvcDev_); // free in uvc_exit()
+    uvc_close(uvcDevHandle_);
+    uvc_exit(uvcCtx_);
+
+    LOG_INFO("uvc_close done.");
+    LOG_INFO("~ObLibuvcDevicePort done");
+}
+
+void ObLibuvcDevicePort::startStream(std::shared_ptr<const StreamProfile> profile, libobsensor::MutableFrameCallback callback) {
+    LOG_DEBUG("ObLibuvcDevicePort::startStream()...");
+    bool       foundProfile       = false;
+    uvcProfile selectedUvcProfile = { 0 };
+    auto       uvcProfiles        = queryAvailableUvcProfile();
+    auto       videoProfile       = std::dynamic_pointer_cast<const VideoStreamProfile>(profile);
+    for(auto &&pf: uvcProfiles) {
+        auto obFormat = utils::uvcFourccToOBFormat(pf.fourcc);
+        if(utils::uvcFourccToOBFormat(pf.fourcc) == OB_FORMAT_UNKNOWN) {
+            continue;
+        }
+        if((videoProfile->getFormat() == obFormat) && (videoProfile->getFps() == pf.fps) && (videoProfile->getHeight() == pf.height)
+           && (videoProfile->getWidth() == pf.width)) {
+            foundProfile       = true;
+            selectedUvcProfile = pf;
+            break;
+        }
+    }
+    LOG_DEBUG("playProfile: infIndex={0}, selected_format.width={1}, height={2}, format={3}", (uint32_t)portInfo_->infIndex, videoProfile->getWidth(),
+              videoProfile->getHeight(), videoProfile->getFormat());
+
+    if(!foundProfile) {
+        throw std::runtime_error("Failed to find supported format!");
+    }
+
+    // libusb_clear_halt(uvcDevHandle_->usb_devh, selectedUvcProfile.endpointAddress);
+
+    uvc_stream_ctrl_t ctrl;
+    auto              res = uvc_get_stream_ctrl_format_size(uvcDevHandle_, &ctrl, fourCC2UvcFormat(selectedUvcProfile.fourcc), videoProfile->getWidth(),
+                                                            videoProfile->getHeight(), videoProfile->getFps());
+    if(res < 0) {
+        LOG_ERROR("uvc_get_stream_ctrl_format_size failed!");
+        throw std::runtime_error("uvc_get_stream_ctrl_format_size failed!");
+    }
+
+    uvc_stream_handle_t *uvcStreamHandle = nullptr;
+    uvc_error_t          ret             = uvc_stream_open_ctrl(uvcDevHandle_, &uvcStreamHandle, &ctrl);
+    if(ret != UVC_SUCCESS) {
+        throw std::runtime_error("uvc_stream_open_ctrl failed!");
+    }
+
+    {
+        std::unique_lock<std::mutex> lock(streamMutex_);
+        int32_t                      bufNum = LIBUVC_NUM_TRANSFER_BUFS;
+        if((profile->getFormat() == OB_FORMAT_MJPG || videoProfile->getFormat() == OB_FORMAT_Y8) && videoProfile->getFps() <= LIBUVC_TRANSFER_LOW_FRAME_SIZE) {
+            bufNum = LIBUVC_NUM_TRANSFER_LOW_FRAME_BUFS;
+        }
+        auto obStreamHandle = std::make_shared<OBUvcStreamHandle>(videoProfile, callback, uvcStreamHandle);
+        // std::shared_ptr<OBUvcStreamHandle>(new OBUvcStreamHandle(profile, callback, uvcStreamHandle));
+        streamHandles_.push_back(obStreamHandle);
+        uvcStreamHandle->actual_transfer_buff_num = bufNum;
+        ret                                       = uvc_stream_start(uvcStreamHandle, ObLibuvcDevicePort::onFrameCallback, obStreamHandle.get(), 0);
+    }
+
+    if(ret == UVC_ERROR_NO_MEM) {
+        for(uint32_t i = 0; i < uvcStreamHandle->actual_transfer_buff_num; i++) {
+            if(uvcStreamHandle->transfers[i] != nullptr) {
+                free(uvcStreamHandle->transfers[i]->buffer);
+                libusb_free_transfer(uvcStreamHandle->transfers[i]);
+                uvcStreamHandle->transfers[i] = nullptr;
+            }
+        }
+        std::unique_lock<std::mutex> lock(streamMutex_);
+        streamHandles_.erase(streamHandles_.end() - 1);
+        throw std::runtime_error("uvc_stream_start failed with err_code=UVC_ERROR_NO_MEM, try to increase the usbfs buffer size!");
+    }
+
+    if(ret != UVC_SUCCESS) {
+        std::unique_lock<std::mutex> lock(streamMutex_);
+        streamHandles_.erase(streamHandles_.end() - 1);
+        uvc_stream_close(uvcStreamHandle);
+        throw std::runtime_error("uvc_stream_start failed!");
+    }
+
+    LOG_DEBUG("ObLibuvcDevicePort::startStream() done");
+}
+
+void ObLibuvcDevicePort::stopStream(std::shared_ptr<const StreamProfile> profile) {
+
+    LOG_DEBUG("ObLibuvcDevicePort::stopStream()...");
+    std::unique_lock<std::mutex> lock(streamMutex_);
+    auto                         videoProfile = std::dynamic_pointer_cast<const VideoStreamProfile>(profile);
+    auto                         it           = std::find_if(streamHandles_.begin(), streamHandles_.end(), [&](const std::shared_ptr<OBUvcStreamHandle> sh) {
+        return (videoProfile->getFormat() == sh->profile->getFormat()) && (videoProfile->getFps() == sh->profile->getFps())
+               && (videoProfile->getHeight() == sh->profile->getHeight()) && (videoProfile->getWidth() == sh->profile->getWidth());
+    });
+    if(it == streamHandles_.end()) {
+        LOG_DEBUG("can not find match stream handle.");
+        return;
+    }
+
+    uvc_stream_handle_t *uvcStreamHandle = (*it)->streamHandle;
+    auto                 endpointAddr    = uvcStreamHandle->stream_if->bEndpointAddress;
+#ifdef OS_MACOS
+    libusb_clear_halt(uvcDevHandle_->usb_devh, endpointAddr);
+#endif
+    uvc_stream_stop(uvcStreamHandle);
+    uvc_stream_close(uvcStreamHandle);
+
+#ifndef OS_MACOS
+    libusb_clear_halt(uvcDevHandle_->usb_devh, endpointAddr);
+#endif
+
+    streamHandles_.erase(it);
+    LOG_DEBUG("ObLibuvcDevicePort::stopStream() done");
+}
+
+void ObLibuvcDevicePort::stopAllStream() {
+    std::unique_lock<std::mutex> lock(streamMutex_);
+    if(streamHandles_.empty()) {
+        return;
+    }
+    for(auto &&sh: streamHandles_) {
+        uvc_stream_handle_t *uvcStreamHandle = sh->streamHandle;
+        auto                 endpointAddr    = uvcStreamHandle->stream_if->bEndpointAddress;
+        uvc_stream_stop(uvcStreamHandle);
+        uvc_stream_close(uvcStreamHandle);
+        auto ret = libusb_clear_halt(uvcDevHandle_->usb_devh, endpointAddr);
+        if(ret != LIBUSB_SUCCESS) {
+            LOG_ERROR("libusb_clear_halt failed, error code={}", ret);
+        }
+    }
+    streamHandles_.clear();
+    LOG_DEBUG("ObLibuvcDevicePort::stopAllStream() done");
+}
+
+bool ObLibuvcDevicePort::getPu(uint32_t propertyId, int32_t &value) {
+    std::lock_guard<std::recursive_mutex> lock(ctrlMutex_);
+    int                                   unit    = 0;
+    int                                   control = obPropToUvcCS(static_cast<OBPropertyID>(propertyId), unit);
+    value                                         = getCtrl(UVC_GET_CUR, control, unit);
+    value                                         = uvcCtrlValueTranslate(UVC_GET_CUR, static_cast<OBPropertyID>(propertyId), value);
+
+    return true;
+}
+
+bool ObLibuvcDevicePort::setPu(uint32_t propertyId, int32_t value) {
+    std::lock_guard<std::recursive_mutex> lock(ctrlMutex_);
+    int                                   unit;
+    int                                   control = obPropToUvcCS(static_cast<OBPropertyID>(propertyId), unit);
+    value                                         = uvcCtrlValueTranslate(UVC_SET_CUR, static_cast<OBPropertyID>(propertyId), value);
+    setCtrl(UVC_SET_CUR, control, unit, value);
+    LOG_DEBUG("ObLibuvcDevicePort::setPu() propertyId = {} value = ", propertyId, value);
+    return true;
+}
+
+UvcControlRange ObLibuvcDevicePort::getPuRange(uint32_t propertyId) {
+    std::lock_guard<std::recursive_mutex> lock(ctrlMutex_);
+    int                                   unit = 0;
+    int                                   min, max, step, def;
+
+    int control = obPropToUvcCS(static_cast<OBPropertyID>(propertyId), unit);
+    if(propertyId == OB_PROP_COLOR_AUTO_EXPOSURE_PRIORITY_INT || propertyId == OB_PROP_COLOR_AUTO_EXPOSURE_BOOL
+       || propertyId == OB_PROP_COLOR_AUTO_WHITE_BALANCE_BOOL) {
+        min  = 0;
+        max  = 1;
+        step = 1;
+    }
+    else {
+        min = getCtrl(UVC_GET_MIN, control, unit);
+        min = uvcCtrlValueTranslate(UVC_GET_MIN, static_cast<OBPropertyID>(propertyId), min);
+
+        max = getCtrl(UVC_GET_MAX, control, unit);
+        max = uvcCtrlValueTranslate(UVC_GET_MAX, static_cast<OBPropertyID>(propertyId), max);
+
+        step = getCtrl(UVC_GET_RES, control, unit);
+        step = uvcCtrlValueTranslate(UVC_GET_RES, static_cast<OBPropertyID>(propertyId), step);
+    }
+
+    if(propertyId == OB_PROP_COLOR_AUTO_EXPOSURE_PRIORITY_INT) {
+        def = 0;
+    }
+    else {
+        def = getCtrl(UVC_GET_DEF, control, unit);
+        def = uvcCtrlValueTranslate(UVC_GET_DEF, static_cast<OBPropertyID>(propertyId), def);
+    }
+
+    LOG_DEBUG("getPuRange unit={0}, propertyId={1}, min={2}, max={3}, step={4}, def={5}", unit, propertyId, min, max, step, def);
+    if(step == min) {
+        step = 1;
+    }
+    UvcControlRange result(min, max, step, def);
+
+    return result;
+}
+
+bool ObLibuvcDevicePort::setXu(uint8_t ctrl, const uint8_t *data, uint32_t len) {
+    std::lock_guard<std::recursive_mutex> lock(ctrlMutex_);
+    auto                                  recv = uvc_set_ctrl(uvcDevHandle_, xuUnit_.unit, ctrl, const_cast<uint8_t *>(data), len);
+    if(recv <= 0) {
+        LOG_ERROR("setXu failed, error code={}", recv);
+        return false;
+    }
+    return true;
+}
+
+bool ObLibuvcDevicePort::getXu(uint8_t ctrl, uint8_t *data, uint32_t *len) {
+    std::lock_guard<std::recursive_mutex> lock(ctrlMutex_);
+    switch((ObVendorXuCtrlId)ctrl) {
+    case OB_VENDOR_XU_CTRL_ID_512:
+        *len = 512;
+        break;
+    case OB_VENDOR_XU_CTRL_ID_64:
+        *len = 64;
+        break;
+
+    case OB_VENDOR_XU_CTRL_ID_1024:
+        *len = 1024;
+        break;
+    default:
+        return false;
+    }
+    int recv = uvc_get_ctrl(uvcDevHandle_, xuUnit_.unit, ctrl, data, *len, UVC_GET_CUR);
+    *len     = recv;
+    if(recv <= 0) {
+        LOG_ERROR("getXu failed, error code={}", recv);
+        return false;
+    }
+    return true;
+}
+
+uint32_t ObLibuvcDevicePort::sendAndReceive(const uint8_t *sendData, uint32_t sendLen, uint8_t *recvData, uint32_t exceptedRecvLen) {
+    std::lock_guard<std::recursive_mutex> lock(ctrlMutex_);
+
+    uint8_t ctrl = OB_VENDOR_XU_CTRL_ID_64;
+
+    auto alignDataLen = sendLen;
+    if(alignDataLen <= 64) {
+        ctrl         = OB_VENDOR_XU_CTRL_ID_64;
+        alignDataLen = 64;
+    }
+    else if(alignDataLen > 512) {
+        ctrl         = OB_VENDOR_XU_CTRL_ID_1024;
+        alignDataLen = 1024;
+    }
+    else {
+        ctrl         = OB_VENDOR_XU_CTRL_ID_512;
+        alignDataLen = 512;
+    }
+
+    if(!setXu(ctrl, sendData, alignDataLen)) {
+        return 0;
+    }
+
+    ctrl = OB_VENDOR_XU_CTRL_ID_512;
+    if(exceptedRecvLen <= 64) {
+        ctrl = OB_VENDOR_XU_CTRL_ID_64;
+    }
+    else if(exceptedRecvLen > 512) {
+        ctrl = OB_VENDOR_XU_CTRL_ID_1024;
+    }
+    else {
+        ctrl = OB_VENDOR_XU_CTRL_ID_512;
+    }
+
+    if(!getXu(ctrl, recvData, &exceptedRecvLen)) {
+        return 0;
+    }
+    return exceptedRecvLen;
+}
+
+StreamProfileList ObLibuvcDevicePort::getStreamProfileList() {
+    StreamProfileList results;
+
+    auto uvcProfiles = queryAvailableUvcProfile();
+    for(auto &&pf: uvcProfiles) {
+        auto obFormat = utils::uvcFourccToOBFormat(pf.fourcc);
+        if(obFormat == OB_FORMAT_UNKNOWN) {
+            continue;
+        }
+        // FIXME:
+        auto sp = std::make_shared<VideoStreamProfile>(std::shared_ptr<LazySensor>(), OB_STREAM_VIDEO, obFormat, pf.width, pf.height, pf.fps);
+        results.push_back(sp);
+    }
+    return results;
+}
+
+int32_t ObLibuvcDevicePort::uvcCtrlValueTranslate(uvc_req_code action, OBPropertyID propertyId, int32_t value) const {
+    LOG_DEBUG("ObLibuvcDevicePort::uvcCtrlValueTranslate propertyId={0}, action={1}, value={2}", action, propertyId, value);
+    // Value may be translated according to action/propertyId value
+    int32_t translated_value = value;
+
+    switch(action) {
+    case UVC_GET_CUR:  // Translating from UVC 1.5 Spec up to RS
+        if(propertyId == OB_PROP_COLOR_AUTO_EXPOSURE_BOOL) {
+            auto res = getCtrl(UVC_GET_RES, UVC_CT_AE_MODE_CONTROL, uvc_get_input_terminals(uvcDevHandle_)->bTerminalID);
+            LOG_DEBUG("UVC_GET_CUR:getAERes:{}.", res);
+            if(res & UVC_AE_MODE_D0_MANUAL) {
+                translated_value = (value == UVC_AE_MODE_D0_MANUAL) ? 0 : 1;
+                LOG_DEBUG("UVC_AE_MODE_D0_MANUAL:translated_value:{},value:{}.", translated_value, value);
+            }
+            else if(res & UVC_AE_MODE_D1_AUTO) {
+                translated_value = (value == UVC_AE_MODE_D1_AUTO) ? 1 : 0;
+                LOG_DEBUG("UVC_AE_MODE_D1_AUTO:translated_value:{},value:{}.", translated_value, value);
+            }
+            else {
+                LOG_DEBUG("UVC_GET_CUR:ae res mode is invalid.");
+            }
+        }
+        break;
+
+    case UVC_SET_CUR:  // Translating from RS down to UVC 1.5 Spec
+        if(propertyId == OB_PROP_COLOR_AUTO_EXPOSURE_BOOL) {
+            auto res = getCtrl(UVC_GET_RES, UVC_CT_AE_MODE_CONTROL, uvc_get_input_terminals(uvcDevHandle_)->bTerminalID);
+            LOG_DEBUG("UVC_SET_CUR: getAERes:{}.", res);
+            if(res & UVC_AE_MODE_D0_MANUAL) {
+                auto autoValue   = (res & (~UVC_AE_MODE_D0_MANUAL));
+                translated_value = value ? autoValue : UVC_AE_MODE_D0_MANUAL;
+                LOG_DEBUG("UVC_AE_MODE_D0_MANUAL:translated_value:{},value:{}.", translated_value, value);
+            }
+            else if(res & UVC_AE_MODE_D1_AUTO) {
+                auto manualValue = (res & (~UVC_AE_MODE_D1_AUTO));
+                translated_value = value ? UVC_AE_MODE_D1_AUTO : manualValue;
+                LOG_DEBUG("UVC_AE_MODE_D1_AUTO:translated_value:{},value:{}.", translated_value, value);
+            }
+            else {
+                LOG_DEBUG("UVC_SET_CUR:ae res mode is invalid.");
+            }
+        }
+        break;
+
+    case UVC_GET_MIN:
+        if(propertyId == OB_PROP_COLOR_AUTO_EXPOSURE_BOOL) {
+            translated_value = 0;  // Hardcoded MIN value
+        }
+        break;
+
+    case UVC_GET_MAX:
+        if(propertyId == OB_PROP_COLOR_AUTO_EXPOSURE_BOOL) {
+            translated_value = 1;  // Hardcoded MAX value
+        }
+        break;
+
+    case UVC_GET_RES:
+        if(propertyId == OB_PROP_COLOR_AUTO_EXPOSURE_BOOL) {
+            translated_value = 1;  // Hardcoded RES (step) value
+        }
+        break;
+
+    case UVC_GET_DEF:
+        if(propertyId == OB_PROP_COLOR_AUTO_EXPOSURE_BOOL) {
+            translated_value = 1;  // Hardcoded DEF value
+        }
+        break;
+
+    default:
+        throw std::runtime_error("Unsupported action translation");
+    }
+    return translated_value;
+}
+
+void ObLibuvcDevicePort::onFrameCallback(uvc_frame *frame, void *userPtr) {
+    TRY_EXECUTE({
+        OBUvcStreamHandle *handle     = (OBUvcStreamHandle *)userPtr;
+        auto               rawframe   = FrameFactory::createFrameFromStreamProfile(handle->profile);
+        auto               videoFrame = rawframe->as<VideoFrame>();
+
+        videoFrame->updateData(static_cast<const uint8_t *>(frame->data), frame->data_bytes);
+
+        auto payload_header_bytes = frame->payload_header_bytes > 12 ? 12 : frame->payload_header_bytes;
+        videoFrame->updateMetadata(static_cast<const uint8_t *>(frame->payload_header), payload_header_bytes);
+        auto metadata_bytes = frame->metadata_bytes > 255 ? 255 : frame->metadata_bytes;
+        videoFrame->appendMetadata(static_cast<const uint8_t *>(frame->metadata), metadata_bytes);
+
+        auto realtime = std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::system_clock::now().time_since_epoch()).count();
+        videoFrame->setSystemTimeStampUsec(realtime);
+        videoFrame->setTimeStampUsec(frame->pts);
+        videoFrame->setNumber(frame->sequence);
+
+        handle->callback(videoFrame);
+    });
+}
+
+int32_t ObLibuvcDevicePort::getCtrl(uvc_req_code action, uint8_t control, uint8_t unit) const {
+    unsigned char buffer[4] = { 0 };
+    int32_t       ret       = 0;
+
+    uint32_t transferred;
+
+    transferred = uvc_get_ctrl(uvcDevHandle_, unit, control, buffer, sizeof(buffer), action);
+
+    if(control == UVC_PU_BRIGHTNESS_CONTROL || control == UVC_PU_HUE_CONTROL) {
+        ret = (short)SW_TO_SHORT(buffer);
+        return ret;
+    }
+
+    switch(transferred) {
+    case sizeof(uint8_t):
+        ret = *(int32_t *)buffer;
+        break;
+    case sizeof(uint16_t):
+        ret = SW_TO_SHORT(buffer);
+        break;
+    case sizeof(uint32_t):
+        ret = DW_TO_INT(buffer);
+        break;
+    default:
+        throw std::runtime_error("unsupported length");
+    }
+
+    return ret;
+}
+
+int ObLibuvcDevicePort::obPropToUvcCS(OBPropertyID propertyId, int &unit) const {
+
+    unit = uvc_get_processing_units(uvcDevHandle_)->bUnitID;
+
+    switch(propertyId) {
+    case OB_PROP_COLOR_BACKLIGHT_COMPENSATION_INT:
+        return UVC_PU_BACKLIGHT_COMPENSATION_CONTROL;
+    case OB_PROP_COLOR_BRIGHTNESS_INT:
+        return UVC_PU_BRIGHTNESS_CONTROL;
+    case OB_PROP_COLOR_CONTRAST_INT:
+        return UVC_PU_CONTRAST_CONTROL;
+    case OB_PROP_COLOR_EXPOSURE_INT:
+        unit = uvc_get_input_terminals(uvcDevHandle_)->bTerminalID;
+        return UVC_CT_EXPOSURE_TIME_ABSOLUTE_CONTROL;
+    case OB_PROP_COLOR_GAIN_INT:
+        return UVC_PU_GAIN_CONTROL;
+    case OB_PROP_COLOR_GAMMA_INT:
+        return UVC_PU_GAMMA_CONTROL;
+    case OB_PROP_COLOR_HUE_INT:
+        return UVC_PU_HUE_CONTROL;
+    case OB_PROP_COLOR_SATURATION_INT:
+        return UVC_PU_SATURATION_CONTROL;
+    case OB_PROP_COLOR_SHARPNESS_INT:
+        return UVC_PU_SHARPNESS_CONTROL;
+    case OB_PROP_COLOR_WHITE_BALANCE_INT:
+        return UVC_PU_WHITE_BALANCE_TEMPERATURE_CONTROL;
+    case OB_PROP_COLOR_AUTO_EXPOSURE_BOOL:
+        unit = uvc_get_input_terminals(uvcDevHandle_)->bTerminalID;
+        return UVC_CT_AE_MODE_CONTROL;  // Automatic gain/exposure control
+    case OB_PROP_COLOR_AUTO_WHITE_BALANCE_BOOL:
+        return UVC_PU_WHITE_BALANCE_TEMPERATURE_AUTO_CONTROL;
+    case OB_PROP_COLOR_POWER_LINE_FREQUENCY_INT:
+        return UVC_PU_POWER_LINE_FREQUENCY_CONTROL;
+    case OB_PROP_COLOR_AUTO_EXPOSURE_PRIORITY_INT:
+        unit = uvc_get_input_terminals(uvcDevHandle_)->bTerminalID;
+        return UVC_CT_AE_PRIORITY_CONTROL;
+    case OB_PROP_COLOR_ROLL_INT:
+        unit = uvc_get_input_terminals(uvcDevHandle_)->bTerminalID;
+        return UVC_CT_ROLL_ABSOLUTE_CONTROL;
+    case OB_PROP_COLOR_FOCUS_INT:
+        unit = uvc_get_input_terminals(uvcDevHandle_)->bTerminalID;
+        return UVC_CT_FOCUS_ABSOLUTE_CONTROL;
+    default:
+        throw pal_exception(utils::string::to_string() << "invalid propertyId : " << propertyId);
+    }
+}
+
+void ObLibuvcDevicePort::setCtrl(uvc_req_code action, uint8_t control, uint8_t unit, int32_t value) const {
+    (void)action;
+    unsigned char buffer[4];
+    INT_TO_DW(value, buffer);
+
+    uint32_t transferred;
+    transferred = uvc_set_ctrl(uvcDevHandle_, unit, control, buffer, sizeof(int32_t));
+    (void)transferred;
+}
+
+std::vector<ObLibuvcDevicePort::uvcProfile> ObLibuvcDevicePort::queryAvailableUvcProfile() const {
+    std::vector<uvcProfile> rv;
+
+    uvc_streaming_interface_t *stream_if;
+    DL_FOREACH(uvcDevHandle_->info->stream_ifs, stream_if) {
+        uvc_format_desc_t *fmt_desc;
+        // LOG(INFO)<<"stream_if.interfaceNumber ="<<(int)(stream_if->bInterfaceNumber);
+
+        DL_FOREACH(stream_if->format_descs, fmt_desc) {
+            uvc_frame_desc_t *frame_desc;
+            switch(fmt_desc->bDescriptorSubtype) {
+            case UVC_VS_FORMAT_UNCOMPRESSED:
+            case UVC_VS_FORMAT_MJPEG:
+            case UVC_VS_FORMAT_FRAME_BASED:
+
+                DL_FOREACH(fmt_desc->frame_descs, frame_desc) {
+                    uint32_t *interval_ptr;
+
+                    uvcProfile uvcFormat{};
+                    uvcFormat.width  = (uint32_t)frame_desc->wWidth;
+                    uvcFormat.height = (uint32_t)frame_desc->wHeight;
+                    uvcFormat.fourcc = fourCc2Int(fmt_desc->fourccFormat[0], fmt_desc->fourccFormat[1], fmt_desc->fourccFormat[2], fmt_desc->fourccFormat[3]);
+
+                    uvcFormat.interfaceNumber = stream_if->bInterfaceNumber;
+                    uvcFormat.endpointAddress = stream_if->bEndpointAddress;
+                    if(frame_desc->intervals) {
+                        for(interval_ptr = frame_desc->intervals; *interval_ptr; ++interval_ptr) {
+                            uvcFormat.fps = 10000000 / *interval_ptr;
+                            rv.push_back(uvcFormat);
+                        }
+                    }
+                }
+            default:
+                break;
+            }
+        }
+    }
+
+    return rv;
+}
+
+std::shared_ptr<const SourcePortInfo> ObLibuvcDevicePort::getSourcePortInfo() const {
+    return portInfo_;
+}
+
+#ifdef __ANDROID__
+std::string ObLibuvcDevicePort::getUsbConnectType() {
+    libusb_device_descriptor desc;
+    auto                     ret = libusb_get_device_descriptor(uvcDev_->usb_dev, &desc);
+    return usb_spec_names.find(UsbSpec(desc.bcdUSB))->second;
+}
+#endif
+
+}  // namespace libobsensor
+
diff --git a/src/platform/usb/uvc/ObLibuvcDevicePort.hpp b/src/platform/usb/uvc/ObLibuvcDevicePort.hpp
new file mode 100644
index 00000000..aeee790c
--- /dev/null
+++ b/src/platform/usb/uvc/ObLibuvcDevicePort.hpp
@@ -0,0 +1,92 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include "libobsensor/h/ObTypes.h"
+
+#include "UvcTypes.hpp"
+#include "UvcDevicePort.hpp"
+#include "stream/StreamProfile.hpp"
+#include "usb/enumerator/IUsbEnumerator.hpp"
+
+#include <libuvc/libuvc.h>
+#include <libusb.h>
+#include <cstdio>
+#include <cstdlib>
+#include <atomic>
+#include <chrono>
+#include <cstring>
+#include <string>
+#include <thread>
+
+namespace libobsensor {
+
+class ObLibuvcDevicePort : public UvcDevicePort {
+private:
+    struct OBUvcStreamHandle {
+        OBUvcStreamHandle(std::shared_ptr<const VideoStreamProfile> &profile_, std::function<void(std::shared_ptr<Frame>)> callback_,
+                          uvc_stream_handle_t *streamHandle_)
+            : profile(profile_), callback(std::move(callback_)), streamHandle(streamHandle_) {}
+        std::shared_ptr<const VideoStreamProfile>   profile;
+        std::function<void(std::shared_ptr<Frame>)> callback;
+        uvc_stream_handle_t                        *streamHandle;
+    };
+
+    typedef struct {
+        uint32_t width;
+        uint32_t height;
+        uint32_t fourcc;  // format fourcc code
+        uint32_t fps;
+        uint8_t  interfaceNumber;
+        uint8_t  endpointAddress;
+    } uvcProfile;
+
+public:
+    ObLibuvcDevicePort(std::shared_ptr<IUsbDevice> usbDev, std::shared_ptr<const USBSourcePortInfo> portInfo);
+    ~ObLibuvcDevicePort() noexcept override;
+
+    StreamProfileList getStreamProfileList() override;
+    void              startStream(std::shared_ptr<const StreamProfile> profile, MutableFrameCallback callback) override;
+    void              stopStream(std::shared_ptr<const StreamProfile> profile) override;
+    void              stopAllStream() override;
+
+    uint32_t sendAndReceive(const uint8_t *sendData, uint32_t sendLen, uint8_t *recvData, uint32_t exceptedRecvLen) override;
+
+    bool            getPu(uint32_t propertyId, int32_t &value) override;
+    bool            setPu(uint32_t propertyId, int32_t value) override;
+    UvcControlRange getPuRange(uint32_t propertyId) override;
+
+    std::shared_ptr<const SourcePortInfo> getSourcePortInfo() const override;
+
+private:
+    virtual bool getXu(uint8_t ctrl, uint8_t *data, uint32_t *len);
+    virtual bool setXu(uint8_t ctrl, const uint8_t *data, uint32_t len);
+
+#ifdef __ANDROID__
+    virtual std::string getUsbConnectType() override;
+#endif
+
+private:
+    int32_t                 uvcCtrlValueTranslate(uvc_req_code action, OBPropertyID propertyId, int32_t value) const;
+    static void             onFrameCallback(uvc_frame *frame, void *user_ptr);
+    std::vector<uvcProfile> queryAvailableUvcProfile() const;
+
+    int     obPropToUvcCS(OBPropertyID propertyId, int &unit) const;
+    int32_t getCtrl(uvc_req_code action, uint8_t control, uint8_t unit) const;
+    void    setCtrl(uvc_req_code action, uint8_t control, uint8_t unit, int32_t value) const;
+
+private:
+    std::shared_ptr<IUsbDevice>              usbDev_;
+    std::shared_ptr<const USBSourcePortInfo> portInfo_;
+
+    uvc_context_t       *uvcCtx_;
+    uvc_device_t        *uvcDev_;
+    uvc_device_handle_t *uvcDevHandle_;
+
+    std::recursive_mutex ctrlMutex_;
+
+    std::mutex                                      streamMutex_;
+    std::vector<std::shared_ptr<OBUvcStreamHandle>> streamHandles_;
+};
+
+}  // namespace libobsensor
diff --git a/src/platform/usb/uvc/ObV4lGmslDevicePort.cpp b/src/platform/usb/uvc/ObV4lGmslDevicePort.cpp
new file mode 100644
index 00000000..a868e923
--- /dev/null
+++ b/src/platform/usb/uvc/ObV4lGmslDevicePort.cpp
@@ -0,0 +1,1876 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include <fcntl.h>
+#include <unistd.h>
+#include <limits.h>
+#include <dirent.h>
+#include <sys/ioctl.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/sysmacros.h>
+
+#include <list>
+#include <regex>
+
+#include <linux/media.h>
+#include <linux/videodev2.h>
+
+#include "ObV4lUvcDevicePort.hpp"
+#include "ObV4lGmslDevicePort.hpp"
+#include "ObV4lGmslHostProtocolTypes.hpp"
+#include "libobsensor/h/Property.h"
+#include "utils/Utils.hpp"
+#include "logger/Logger.hpp"
+#include "exception/ObException.hpp"
+#include "frame/FrameFactory.hpp"
+
+#include <iostream>
+#include <chrono>
+#include <ctime>
+#include <fstream>
+#include <string>
+
+#if 0
+//for mutil-device-sync
+#include <iostream>
+#include <unistd.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#endif
+
+namespace libobsensor {
+
+#define USE_MEMORY_MMAP true
+std::mutex mMultiThreadI2CMutex;
+
+static std::map<uint32_t, uint32_t> v4lFourccMapGmsl = {
+    { 0x47524559, 0x59382020 }, /*'GREY' to 'Y8  '*/
+    { 0x48455643, 0x48323635 }, /*'HEVC' to 'H265'*/
+};
+
+int xioctlGmsl(int fh, unsigned long request, void *arg) {
+    int ret   = 0;
+    int retry = 5;
+    do {
+        ret = ioctl(fh, request, arg);
+    } while(ret < 0 && (errno == EINTR || errno == EAGAIN) && retry--);
+    return ret;
+}
+
+int         devPid    = 0;
+std::string devSn     = "";
+std::string devAsicSn = "";
+
+int getPidSn(const std::string &dev_name, void *data) {
+    int ret = 0, fd = -1;
+    LOG_DEBUG("-Entry get_pid_sn dev_name:{}", dev_name);
+
+    VALIDATE_NOT_NULL(data);
+    fd = open(dev_name.c_str(), O_RDWR);
+    if(fd < 0) {
+        LOG_DEBUG("GMSL Mipi device get_pid_sn could not be open");
+        return fd;
+    }
+    else {
+        LOG_DEBUG("Entry get_pid_sn dev_name  fd:{}", fd);
+    }
+
+    v4l2_ext_controls ctrls;
+    v4l2_ext_control  ctrl;
+    memset(&ctrls, 0, sizeof(ctrls));
+    memset(&ctrl, 0, sizeof(ctrl));
+    ctrls.ctrl_class = V4L2_CTRL_CLASS_CAMERA;
+    ctrls.count      = 1;
+    ctrls.controls   = &ctrl;
+
+    ctrl.id   = G2R_CAMERA_CID_GET_PID_SN;
+    ctrl.size = 34;
+    ctrl.p_u8 = reinterpret_cast<uint8_t *>(data);
+
+    ret = xioctlGmsl(fd, VIDIOC_G_EXT_CTRLS, &ctrls);
+    if(ret < 0) {
+        LOG_ERROR("%s:%d ioctl failed on getdata erron:{} strerror:{} \n ", __FILE__, __LINE__, errno, strerror(errno));  // printf err message
+        return -1;
+    }
+    return 0;
+}
+
+int getGmslDeviceInfoFromFW(const std::string &dev_name, void *data) {
+    int ret = 0, fd = -1;
+    // LOG_DEBUG("-Entry get_pid_sn dev_name:{}", dev_name);
+
+    VALIDATE_NOT_NULL(data);
+    fd = open(dev_name.c_str(), O_RDWR);
+    if(fd < 0) {
+        LOG_DEBUG("GMSL Mipi device get_pid_sn could not be open");
+        return fd;
+    }
+
+    v4l2_ext_controls ctrls;
+    v4l2_ext_control  ctrl;
+    memset(&ctrls, 0, sizeof(ctrls));
+    memset(&ctrl, 0, sizeof(ctrl));
+    ctrls.ctrl_class = V4L2_CTRL_CLASS_CAMERA;
+    ctrls.count      = 1;
+    ctrls.controls   = &ctrl;
+
+    ctrl.id   = G2R_CAMERA_CID_GET_PID_SN;
+    ctrl.size = sizeof(orbbec_device_info);  // 34;
+    ctrl.p_u8 = reinterpret_cast<uint8_t *>(data);
+
+    ret = xioctlGmsl(fd, VIDIOC_G_EXT_CTRLS, &ctrls);
+    if(ret < 0) {
+        LOG_DEBUG("ioctl failed on getGmslDeviceInfoFromFW-pid-vid from videox strerror:{}", strerror(errno));  // printf err message
+        ret = -1;
+    }
+    close(fd);
+    return ret;
+}
+
+enum class Platform { Unknown, Orin, Xavier };
+
+Platform DetectPlatform() {
+    std::ifstream file("/proc/version");
+    std::string   line;
+    if(!file.is_open()) {
+        std::cerr << "Failed to open /proc/version" << std::endl;
+        return Platform::Unknown;
+    }
+    if(std::getline(file, line)) {
+        // Assume the version string starts with "Linux version ", followed by the version number
+        // Check for the "-tegra" suffix and other identifiers that may be included in the version number
+        if(line.find("5.15.136-tegra") != std::string::npos) {
+            return Platform::Orin;
+        }
+        else if(line.find("5.10.104-tegra") != std::string::npos) {
+            return Platform::Xavier;
+        }
+        // You can add more conditions to check for other versions or platforms if needed
+    }
+    return Platform::Unknown;
+}
+
+//--------------------------------------------------------------------------------------------
+// GMSL MIPI & firmware I2C protocol end
+static const uint8_t INTERFACE_DEPTH    = 0;
+static const uint8_t INTERFACE_COLOR    = 4;
+static const uint8_t INTERFACE_IR       = 2;
+static const uint8_t INTERFACE_IR_LEFT  = 2;
+static const uint8_t INTERFACE_IR_RIGHT = 3;
+
+//--------------------------------------------------------------------------------------------
+v4l2_capability getV4l2DeviceCapabilitiesGmsl(const std::string &dev_name) {
+    // RAII to handle exceptions
+    v4l2_capability cap = {};
+    memset(&cap, 0, sizeof(cap));
+    std::unique_ptr<int, std::function<void(int *)>> fd(new int(open(dev_name.c_str(), O_RDWR | O_NONBLOCK, 0)), [](int *d) {
+        if(d && (*d)) {
+            ::close(*d);
+        }
+        delete d;
+    });
+
+    if(*fd < 0) {
+        LOG_ERROR("getV4l2DeviceCapabilitiesGmsl: Cannot open {}", dev_name);
+        return cap;
+    }
+
+    if(xioctlGmsl(*fd, VIDIOC_QUERYCAP, &cap) < 0) {
+        if(errno == EINVAL) {
+            LOG_ERROR("getV4l2DeviceCapabilitiesGmsl {} is no V4L2 device", dev_name);
+        }
+        else {
+            LOG_ERROR("getV4l2DeviceCapabilitiesGmsl  xioctlGmsl(VIDIOC_QUERYCAP) failed!");
+        }
+    }
+    return cap;
+}
+
+int checkVideoIndex(const std::string &dev_name) {
+    static std::regex video_dev_index("\\d+$");
+    std::smatch       match;
+    uint8_t           video_index{};
+    if(std::regex_search(dev_name, match, video_dev_index)) {
+        video_index = static_cast<uint8_t>(std::stoi(match[0]));
+    }
+    else {
+        LOG_ERROR("Unresolved Video4Linux device pattern:  name device is not support!  dev_name:{}", dev_name);
+        return -1;
+    }
+    return video_index;
+}
+
+std::vector<std::shared_ptr<V4lDeviceInfoGmsl>> ObV4lGmslDevicePort::queryRelatedDevices(std::shared_ptr<const USBSourcePortInfo> portInfo) {
+    std::vector<std::shared_ptr<V4lDeviceInfoGmsl>> devs;
+    DIR                                            *dir = opendir("/sys/class/video4linux");
+    if(!dir) {
+        LOG_DEBUG("Failed to open /sys/class/video4linux, possibly no device connected");
+        return devs;
+    }
+
+    int min_node = 0, max_node = 0;
+
+    std::string portInfo_streamType = portInfo->uid.substr(portInfo->uid.find_last_of('-') + 1);
+    // int portInfo_streamType_int = std::stoi(portInfo_streamType);
+
+    int portinfo_videoIndex = checkVideoIndex(portInfo->infName);
+
+    min_node = portinfo_videoIndex;
+    max_node = portinfo_videoIndex + 1;
+
+    struct dirent *entry;
+    while((entry = readdir(dir))) {
+        std::string name = entry->d_name;
+        if(name == "." || name == ".." || name.find("video") == std::string::npos) {
+            continue;
+        }
+        LOG_DEBUG("Found video4linux: {}", name);
+        int tmp_videoIndex = checkVideoIndex(name);
+        LOG_DEBUG("Found video4linux-tmp_videoIndex: {}", tmp_videoIndex);
+        // if(tmp_videoIndex<portinfo_videoIndex)
+        //     continue;
+
+        if((tmp_videoIndex < min_node) || (tmp_videoIndex > max_node))
+            continue;
+
+        std::string path = "/sys/class/video4linux/" + name;
+        std::string realPath{};
+        char        buf[PATH_MAX] = { 0 };
+        if(realpath(path.c_str(), buf)) {
+            realPath = buf;
+            if(realPath.find("virtual") != std::string::npos) {
+                continue;
+            }
+        }
+        try {
+            std::string busNum = "1", devNum = "0", devPath = "/dev/video";
+            std::string devname = "/dev/" + name;
+            struct stat st      = {};
+            if(stat(devname.c_str(), &st) < 0) {
+                LOG_DEBUG("Cannot identify {}", devname);
+                continue;
+            }
+
+            if(!S_ISCHR(st.st_mode)) {
+                LOG_DEBUG("{} is no device", devname);
+                continue;
+            }
+
+            // Search directory and up to three parent directories to find busnum/devnum
+            std::ostringstream ss;
+            ss << "/sys/dev/char/" << major(st.st_rdev) << ":" << minor(st.st_rdev) << "/device/";
+            auto             searchPath         = ss.str();
+            auto             validPath          = false;
+            static const int MAX_DEV_PARENT_DIR = 10;
+            for(int i = 0; i < MAX_DEV_PARENT_DIR; i++) {
+                std::ifstream busnum(searchPath + "busnum");
+                std::ifstream devnum(searchPath + "devnum");
+                std::ifstream devpath(searchPath + "devpath");
+                if(busnum.good() && devnum.good() && devpath.good()) {
+                    busnum >> busNum;
+                    devnum >> devNum;
+                    devpath >> devPath;
+                    validPath = true;
+                }
+                busnum.close();
+                devnum.close();
+                devpath.close();
+                if(validPath) {
+                    break;
+                }
+                searchPath += "../";
+            }
+            // auto url = busNum + "-" + devPath + "-" + devNum;
+            // auto url = "usb://06d0:2bc5/1/0";
+            // LOG_DEBUG("----------------------vid: {0}, pid: {1}, portInfo->vid: {2}, portInfo->pid: {3}", vid, pid, portInfo->vid, portInfo->pid);
+            //  if(portInfo->vid == vid && portInfo->pid == pid) && portInfo->infIndex == mi && portInfo->url == url)
+            {
+
+                // Find the USB specification (USB2/3) type from the underlying device
+                // Use device mapping obtained in previous step to traverse node tree
+                // and extract the required descriptors
+                // Traverse from
+                /// sys/devices/pci0000:00/0000:00:xx.0/ABC/M-N/3-6:1.0/video4linux/video0
+                // to
+                /// sys/devices/pci0000:00/0000:00:xx.0/ABC/M-N/version
+                auto info  = std::make_shared<V4lDeviceInfoGmsl>();
+                info->name = devname;
+                info->cap  = getV4l2DeviceCapabilitiesGmsl(devname);
+                devs.push_back(info);
+            }
+        }
+        catch(std::exception &e) {
+            LOG_DEBUG("Failed to parse v4l device info: {}", e.what());
+        }
+    }
+    closedir(dir);
+    if(devs.empty()) {
+        LOG_DEBUG("No v4l device found for port: {}", portInfo->infUrl);
+    }
+
+    // sort by video#num, because the metadata device is always found after the video device for the same uvc device
+    std::sort(devs.begin(), devs.end(), [](const std::shared_ptr<V4lDeviceInfoGmsl> &a, const std::shared_ptr<V4lDeviceInfoGmsl> &b) {
+        int numA = std::stoi(a->name.substr(10));
+        int numB = std::stoi(b->name.substr(10));
+        return numA < numB;
+    });
+    return devs;
+}
+
+bool ObV4lGmslDevicePort::isContainedMetadataDevice(std::shared_ptr<const USBSourcePortInfo> portInfo) {
+    auto devs = queryRelatedDevices(portInfo);
+    for(auto &dev: devs) {
+        if(dev->cap.device_caps & V4L2_CAP_META_CAPTURE) {
+            return true;
+        }
+    }
+    return true;  // for test
+}
+
+void foreachProfileGmsl(std::vector<std::shared_ptr<V4lDeviceHandleGmsl>>                                              deviceHandles,
+                        std::function<bool(std::shared_ptr<V4lDeviceHandleGmsl>, std::shared_ptr<VideoStreamProfile>)> func) {
+    bool quit        = false;
+    int  mStreamType = OB_STREAM_VIDEO;
+    for(auto &devHandle: deviceHandles) {
+        if(quit) {
+            break;
+        }
+        // enum format
+        v4l2_fmtdesc pixel_format = {};
+        pixel_format.type         = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+        while(!quit && xioctlGmsl(devHandle->fd, VIDIOC_ENUM_FMT, &pixel_format) == 0) {
+
+            v4l2_frmsizeenum frame_size = {};
+            frame_size.pixel_format     = pixel_format.pixelformat;
+            uint32_t fourcc             = (const utils::big_endian<int> &)pixel_format.pixelformat;
+
+            if(pixel_format.pixelformat == 0) {
+                // unsupported format fourcc maybe in pixel_format.description
+                LOG_DEBUG("Unrecognizable pixel-format {}", (char *)pixel_format.description);
+                std::string description = std::string((const char *)pixel_format.description);
+                std::size_t index       = description.find('-');
+                if(index == std::string::npos) {
+                    ++pixel_format.index;
+                    continue;
+                }
+                description = description.substr(0, index);
+                // hex string to decimal
+                try {
+                    int descriptionFourcc = std::stoi(description, 0, 16);
+                    fourcc                = (const utils::big_endian<int> &)descriptionFourcc;
+                    LOG_DEBUG("Unrecognizable pixel-format {} with fourcc: {}", (char *)pixel_format.description, fourcc);
+                }
+                catch(std::exception &e) {
+                    LOG_DEBUG("Unrecognizable pixel-format {}: Failed to parse description:{}", (char *)pixel_format.description, e.what());
+                    ++pixel_format.index;
+                    continue;
+                }
+            }
+            else {
+                LOG_DEBUG("Recognized pixel-format {}, pixel_format.pixelformat: 0x{:0x}, fourcc:0x{:0x} ", (char *)pixel_format.description,
+                          pixel_format.pixelformat, fourcc);
+            }
+
+            if(v4lFourccMapGmsl.count(fourcc)) {
+                fourcc = v4lFourccMapGmsl.at(fourcc);
+            }
+
+            // enum format params
+            while(!quit && xioctlGmsl(devHandle->fd, VIDIOC_ENUM_FRAMESIZES, &frame_size) == 0) {
+                v4l2_frmivalenum frame_interval = {};
+                frame_interval.pixel_format     = pixel_format.pixelformat;
+                frame_interval.width            = frame_size.discrete.width;
+                frame_interval.height           = frame_size.discrete.height;
+
+                while(!quit && xioctlGmsl(devHandle->fd, VIDIOC_ENUM_FRAMEINTERVALS, &frame_interval) == 0) {
+                    if(frame_interval.type == V4L2_FRMIVAL_TYPE_DISCRETE) {
+                        if(frame_interval.discrete.numerator != 0) {
+                            auto format = utils::uvcFourccToOBFormat(fourcc);
+                            if(format != OB_FORMAT_UNKNOWN) {
+                                auto width  = frame_size.discrete.width;
+                                auto height = frame_size.discrete.height;
+                                auto fps    = static_cast<float>(frame_interval.discrete.denominator) / static_cast<float>(frame_interval.discrete.numerator);
+                                // LOG_DEBUG("-devHandle->fd:{0}, -format:{1}, width:{2}, heigh:{3}, fps:{4}, mStreamType:{5}, fdPnum:{6}", devHandle->fd,
+                                // format, width, height, fps, mStreamType, fdPnum );
+                                // auto profile = std::make_shared<VideoStreamProfile>(OB_STREAM_VIDEO, format, width, height, fps);
+                                auto profile = std::make_shared<VideoStreamProfile>(std::shared_ptr<LazySensor>(), mStreamType, format, width, height, fps);
+                                if(fourcc != 0) {
+                                    quit = func(devHandle, profile);
+                                }
+                            }
+                        }
+                    }
+                    ++frame_interval.index;
+                }
+                ++frame_size.index;
+            }
+            ++pixel_format.index;
+        }
+    }
+}
+
+uint32_t CIDFromOBPropertyIDGmsl(uint32_t id) {
+    switch(id) {
+    case OB_PROP_COLOR_BACKLIGHT_COMPENSATION_INT:
+        return V4L2_CID_BACKLIGHT_COMPENSATION;
+    case OB_PROP_COLOR_BRIGHTNESS_INT:
+        return V4L2_CID_BRIGHTNESS;
+    case OB_PROP_COLOR_CONTRAST_INT:
+        return V4L2_CID_CONTRAST;
+    case OB_PROP_COLOR_EXPOSURE_INT:
+        return V4L2_CID_EXPOSURE_ABSOLUTE;
+    case OB_PROP_COLOR_GAIN_INT:
+        return V4L2_CID_GAIN;
+    case OB_PROP_COLOR_GAMMA_INT:
+        return V4L2_CID_GAMMA;
+    case OB_PROP_COLOR_HUE_INT:
+        return V4L2_CID_HUE;
+    case OB_PROP_COLOR_SATURATION_INT:
+        return V4L2_CID_SATURATION;
+    case OB_PROP_COLOR_SHARPNESS_INT:
+        return V4L2_CID_SHARPNESS;
+    case OB_PROP_COLOR_WHITE_BALANCE_INT:
+        return V4L2_CID_WHITE_BALANCE_TEMPERATURE;
+    case OB_PROP_COLOR_AUTO_EXPOSURE_BOOL:
+        return V4L2_CID_EXPOSURE_AUTO;  // Automatic gain/exposure control
+    case OB_PROP_COLOR_AUTO_WHITE_BALANCE_BOOL:
+        return V4L2_CID_AUTO_WHITE_BALANCE;
+    case OB_PROP_COLOR_POWER_LINE_FREQUENCY_INT:
+        return V4L2_CID_POWER_LINE_FREQUENCY;
+    case OB_PROP_COLOR_AUTO_EXPOSURE_PRIORITY_INT:
+        return V4L2_CID_EXPOSURE_AUTO_PRIORITY;
+    case OB_PROP_COLOR_ROLL_INT:
+        return V4L2_CID_ROTATE;
+    case OB_PROP_COLOR_FOCUS_INT:
+        return V4L2_CID_FOCUS_ABSOLUTE;
+    default:
+        std::stringstream ss;
+        ss << "no v4l2 cid for option option" << id;
+        LOG_ERROR(ss.str());
+        return 0;
+    }
+}
+
+std::string fourccToStringGmsl(uint32_t id) {
+    uint32_t device_fourcc = id;
+    char     fourcc_buff[sizeof(device_fourcc) + 1];
+    std::memcpy(fourcc_buff, &device_fourcc, sizeof(device_fourcc));
+    fourcc_buff[sizeof(device_fourcc)] = 0;
+    return fourcc_buff;
+}
+
+ObV4lGmslDevicePort::ObV4lGmslDevicePort(std::shared_ptr<const USBSourcePortInfo> portInfo) : portInfo_(portInfo) {
+    LOG_DEBUG("-Entry ObV4lGmslDevicePort-");
+
+    auto devs = queryRelatedDevices(portInfo_);
+    if(devs.empty()) {
+        throw camera_disconnected_exception("No v4l device found for port: " + portInfo_->infUrl);
+    }
+
+    std::shared_ptr<V4lDeviceHandleGmsl> devHandle = nullptr;
+    auto                                 iter      = devs.begin();
+    while(iter != devs.end()) {
+        if(((*iter)->cap.device_caps & V4L2_CAP_META_CAPTURE) && devHandle != nullptr) {
+            // LOG_DEBUG("-V4L2_CAP_META_CAPTURE-1-");
+            devHandle->metadataInfo = *iter;
+            devHandle->metadataFd   = -1;
+            auto fd                 = open(devHandle->metadataInfo->name.c_str(), O_RDWR | O_NONBLOCK, 0);
+            if(fd < 0) {
+                LOG_ERROR("Failed to open metadata dev: {}", devHandle->metadataInfo->name);
+                continue;
+            }
+            LOG_DEBUG("Opened metadata dev:{}, fd:{}", devHandle->metadataInfo->name, fd);
+            devHandle->metadataFd = fd;
+        }
+        else {
+            // LOG_DEBUG("-V4L2_CAP_CAPTURE-2-");
+            devHandle       = std::make_shared<V4lDeviceHandleGmsl>();
+            devHandle->info = *iter;
+            devHandle->fd   = -1;
+            // devHandle->info->name = "/dev/video1";  //for test use.
+            int fd = open(devHandle->info->name.c_str(), O_RDWR | O_NONBLOCK, 0);
+            if(fd < 0) {
+                throw io_exception("Failed to open: " + devHandle->info->name);
+            }
+            devHandle->fd = fd;
+            LOG_DEBUG("Opened video device:{}, fd:{}", devHandle->info->name, fd);
+            deviceHandles_.push_back(devHandle);
+        }
+        iter++;
+    }
+    if(deviceHandles_.empty()) {
+        throw camera_disconnected_exception("No v4l device found for port: " + portInfo_->infUrl);
+    }
+
+    LOG_DEBUG("V4L device port created for {} with {} v4l2 device", portInfo_->infUrl, deviceHandles_.size());
+}
+
+ObV4lGmslDevicePort::~ObV4lGmslDevicePort() noexcept {
+    LOG_DEBUG("Entry ~ObV4lGmslDevicePort");
+    try {
+        stopAllStream();
+    }
+    catch(const std::exception &ex) {
+        LOG_ERROR(ex.what());
+    }
+    LOG_DEBUG("~ObV4lGmslDevicePort() deviceHandles_.size:{}", deviceHandles_.size());
+    for(auto &devHandle: deviceHandles_) {
+        if(devHandle->fd >= 0) {
+            close(devHandle->fd);
+        }
+        if(devHandle->metadataFd >= 0) {
+            close(devHandle->metadataFd);
+        }
+        if(devHandle->stopPipeFd[0] >= 0) {
+            close(devHandle->stopPipeFd[0]);
+        }
+        if(devHandle->stopPipeFd[1] >= 0) {
+            close(devHandle->stopPipeFd[1]);
+        }
+        // other resources are created on startStream and should be cleaned up on stopStream/stopAllStream
+    }
+    LOG_DEBUG("Leave ~ObV4lGmslDevicePort");
+}
+
+//------------------------------------------------------------------------------------------------------------------------------
+// Crop depth map function
+void cropDepthImage(const uint8_t *src, uint8_t *dst, int srcWidth, int srcHeight, int cropRitght, int cropBottom) {
+    assert(src != nullptr && dst != nullptr);
+    int cropWidth  = srcWidth - cropRitght;
+    int cropHeight = srcHeight - cropBottom;
+    assert(srcWidth >= cropWidth && srcHeight >= cropHeight);
+
+    // LOG_DEBUG("--->cropWidth:{}, cropHeight:{}, cropRitght:{}, cropBottom:{} \n", cropWidth, cropHeight, cropRitght, cropBottom);
+
+    // Calculate the number of pixels per row of the source and destination images (in bytes)
+    // const size_t srcBytesPerRow = srcWidth *sizeof(uint8_t);
+    const size_t dstBytesPerRow = cropWidth * sizeof(uint8_t);
+
+    // Iterate through each line of the image and copy the pixels to the destination buffer
+    for(int y = 0; y < cropHeight; y++) {
+        // Calculate the source and destination pointers of the current row
+        const uint8_t *srcRow = src + y * srcWidth;
+        uint8_t       *dstRow = dst + y * cropWidth;
+
+        // Copy the pixels of the current row (except the rightmost 32 columns)
+        // memcpy(dstRow, srcRow, dstBytesPerRow);
+        std::memcpy(dstRow, srcRow, dstBytesPerRow);
+    }
+}
+
+// Crop depth map function
+void cropDepthImage16(const uint16_t *src, uint16_t *dst, int srcWidth, int srcHeight, int cropRitght, int cropBottom) {
+    assert(src != nullptr && dst != nullptr);
+    int cropWidth  = srcWidth - cropRitght;
+    int cropHeight = srcHeight - cropBottom;
+    assert(srcWidth >= cropWidth && srcHeight >= cropHeight);
+
+    // LOG_DEBUG("--->>>cropWidth:%d, cropHeight:%d, cropRitght:%d, cropBottom:%d\n", cropWidth, cropHeight, cropRitght, cropBottom);
+
+    // Calculate the number of pixels per row of the source and destination images (in bytes)
+    // const size_t srcBytesPerRow = srcWidth *sizeof(uint16_t);
+    const size_t dstBytesPerRow = cropWidth * sizeof(uint16_t);
+
+    // Iterate through each line of the image and copy the pixels to the destination buffer
+    for(int y = 0; y < cropHeight; y++) {
+        // Calculate the source and destination pointers of the current row
+        const uint16_t *srcRow = src + y * srcWidth;
+        uint16_t       *dstRow = dst + y * cropWidth;
+
+        // Copy the pixels of the current row (except the rightmost 32 columns)
+        // memcpy(dstRow, srcRow, dstBytesPerRow);
+        std::memcpy(dstRow, srcRow, dstBytesPerRow);
+    }
+}
+
+// Assume buf is a pointer to data and size is the size of the data (in bytes)
+void writeBufferToFile(const char *buf, std::size_t size, const std::string &filename) {
+    std::ofstream file(filename, std::ios::out | std::ios::binary);  // Open the file in binary mode
+
+    if(!file.is_open()) {
+        // If the file fails to open, throw an exception or handle the error
+        throw std::runtime_error("Unable to open the file: " + filename);
+    }
+
+    // Write the data in buf to the file
+    file.write(buf, size);
+
+    // close file
+    file.close();
+}
+
+void ObV4lGmslDevicePort::captureLoop(std::shared_ptr<V4lDeviceHandleGmsl> devHandle) {
+    int metadataBufferIndex = -1;
+    int colorFrameNum       = 0;  // color drop 1~3 frame -> fix color green screen issue.
+    try {
+        int max_fd = std::max({ devHandle->fd, devHandle->metadataFd, devHandle->stopPipeFd[0], devHandle->stopPipeFd[1] });
+
+        if(devHandle->metadataFd >= 0) {
+            v4l2_buffer buf = {};
+            memset(&buf, 0, sizeof(buf));
+            buf.type   = LOCAL_V4L2_BUF_TYPE_META_CAPTURE_GMSL;
+            buf.memory = USE_MEMORY_MMAP ? V4L2_MEMORY_MMAP : V4L2_MEMORY_USERPTR;
+            xioctlGmsl(devHandle->metadataFd, VIDIOC_QBUF, &buf);
+        }
+
+        if(devHandle->fd >= 0) {
+            v4l2_buffer buf = {};
+            memset(&buf, 0, sizeof(buf));
+            buf.type   = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+            buf.memory = USE_MEMORY_MMAP ? V4L2_MEMORY_MMAP : V4L2_MEMORY_USERPTR;
+            xioctlGmsl(devHandle->fd, VIDIOC_QBUF, &buf);
+        }
+
+        while(devHandle->isCapturing) {
+            struct timeval remaining = { 0, 500000 };  // 500ms
+            fd_set         fds{};
+            FD_ZERO(&fds);
+            if(devHandle->fd >= 0) {
+                FD_SET(devHandle->fd, &fds);
+            }
+            if(devHandle->metadataFd >= 0) {
+                FD_SET(devHandle->metadataFd, &fds);
+            }
+            if(devHandle->stopPipeFd[0] >= 0) {
+                FD_SET(devHandle->stopPipeFd[0], &fds);
+            }
+            if(devHandle->stopPipeFd[1] >= 0) {
+                FD_SET(devHandle->stopPipeFd[1], &fds);
+            }
+            int val = select(max_fd + 1, &fds, nullptr, nullptr, &remaining);
+            if(val < 0) {
+                if(errno == EINTR) {
+                    LOG_DEBUG("select interrupted: {}", strerror(errno));
+                }
+                else {
+                    LOG_DEBUG("select failed: {}", strerror(errno));
+                }
+                continue;
+            }
+            else if(val == 0) {
+                // Handle timeout situations
+                continue;
+            }
+
+            if(FD_ISSET(devHandle->stopPipeFd[0], &fds) || FD_ISSET(devHandle->stopPipeFd[1], &fds)) {
+                if(!devHandle->isCapturing) {
+                    LOG_DEBUG("V4L stream is closed: {}", devHandle->info->name);
+                }
+                else {
+                    LOG_ERROR("Stop pipe was signalled during streaming: {}", devHandle->info->name);
+                }
+                break;
+            }
+
+            if(devHandle->metadataFd >= 0 && FD_ISSET(devHandle->metadataFd, &fds)) {
+                FD_CLR(devHandle->metadataFd, &fds);
+                v4l2_buffer buf = { 0 };
+                memset(&buf, 0, sizeof(buf));
+                buf.type   = LOCAL_V4L2_BUF_TYPE_META_CAPTURE_GMSL;
+                buf.memory = USE_MEMORY_MMAP ? V4L2_MEMORY_MMAP : V4L2_MEMORY_USERPTR;
+                if(xioctlGmsl(devHandle->metadataFd, VIDIOC_DQBUF, &buf) < 0) {
+                    LOG_DEBUG("VIDIOC_DQBUF failed, {}, {}", strerror(errno), devHandle->metadataInfo->name);
+                }
+
+                if((buf.bytesused) && (!(buf.flags & V4L2_BUF_FLAG_ERROR))) {
+                    devHandle->metadataBuffers[buf.index].actual_length = buf.bytesused;
+                    devHandle->metadataBuffers[buf.index].sequence      = buf.sequence;
+                    metadataBufferIndex                                 = buf.index;
+                    // LOG_DEBUG("captureLoop-metadata devname:{}, buf.sequence:{}, buf.bytesused:{}, buf.index:{}", devHandle->info->name, buf.sequence,
+                    // buf.bytesused, buf.index);
+                }
+
+                if(devHandle->isCapturing) {
+                    if(xioctlGmsl(devHandle->metadataFd, VIDIOC_QBUF, &buf) < 0) {
+                        LOG_ERROR("devHandle->metadataFd VIDIOC_QBUF, errno: {0}, {1}, {3}", strerror(errno), errno, __LINE__);
+                    }
+                }
+            }
+
+            if(FD_ISSET(devHandle->fd, &fds)) {
+                FD_CLR(devHandle->fd, &fds);
+                v4l2_buffer buf = {};
+                memset(&buf, 0, sizeof(buf));
+                buf.type   = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+                buf.memory = USE_MEMORY_MMAP ? V4L2_MEMORY_MMAP : V4L2_MEMORY_USERPTR;
+                // reader buffer
+                if(xioctlGmsl(devHandle->fd, VIDIOC_DQBUF, &buf) < 0) {
+                    LOG_DEBUG("VIDIOC_DQBUF failed, {}, {}", strerror(errno), devHandle->metadataInfo->name);
+                }
+
+                // LOG_DEBUG("captureLoop-buf.index:{}, buf.sequence:{}, buf.length:{}, buf.flags:{} ", buf.index, buf.sequence, buf.length, buf.flags);
+                // if( (buf.bytesused) && (buf.flags&V4L2_BUF_FLAG_DONE) )
+                if((buf.bytesused) && (!(buf.flags & V4L2_BUF_FLAG_ERROR))) {
+                    TRY_EXECUTE({
+                        auto rawframe   = FrameFactory::createFrameFromStreamProfile(devHandle->profile);
+                        auto videoFrame = rawframe->as<VideoFrame>();
+                        if((DetectPlatform() == Platform::Xavier) || (DetectPlatform() == Platform::Orin)) {
+                            handleSpecialResolution(devHandle, devHandle->buffers[buf.index].ptr, buf.bytesused, videoFrame);
+                        }
+                        else {
+                            videoFrame->updateData(devHandle->buffers[buf.index].ptr, buf.bytesused);
+                        }
+
+                        if(metadataBufferIndex >= 0) {
+                            // temp fix orbbecviewer metadata view flash issue. reason:Occasional missing of one frame in metadata data.
+                            auto &metaBuf                = devHandle->metadataBuffers[metadataBufferIndex];
+                            auto  uvc_payload_header     = metaBuf.ptr;
+                            auto  uvc_payload_header_len = metaBuf.actual_length;
+                            videoFrame->updateMetadata(static_cast<const uint8_t *>(uvc_payload_header), 12);
+                            videoFrame->appendMetadata(static_cast<const uint8_t *>(uvc_payload_header), uvc_payload_header_len);
+
+                            if(uvc_payload_header_len >= sizeof(StandardUvcFramePayloadHeader)) {
+                                auto payloadHeader = (StandardUvcFramePayloadHeader *)uvc_payload_header;
+                                videoFrame->setTimeStampUsec(payloadHeader->dwPresentationTime);
+                            }
+
+                            auto realtime = std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::system_clock::now().time_since_epoch()).count();
+                            videoFrame->setSystemTimeStampUsec(realtime);
+                            // videoFrame->setNumber(buf.sequence);
+                            // for debug use. it is not necessary
+                            // auto metaFrameCount=*(uint32_t *)(uvc_payload_header);
+                            // LOG_DEBUG("read metaFrameCount:{}", metaFrameCount);
+
+                            // fix frame index zero issue.
+                            videoFrame->setNumber(devHandle->loopFrameIndex);
+                            // LOG_DEBUG("set loopFrameIndex:{}", devHandle->loopFrameIndex);
+
+                            if(devHandle->profile->getType() == OB_STREAM_COLOR) {
+                                if(colorFrameNum >= 3) {
+                                    devHandle->frameCallback(videoFrame);
+                                }
+                                else {
+                                    colorFrameNum++;
+                                    LOG_DEBUG("captureLoop colorFrameNum<3 drop. colorFrameNum:{}", colorFrameNum);
+                                }
+                            }
+                            else {
+                                devHandle->frameCallback(videoFrame);
+                            }
+                            devHandle->loopFrameIndex++;
+                        }
+                    });
+                }
+
+                if(devHandle->isCapturing) {
+                    if(xioctlGmsl(devHandle->fd, VIDIOC_QBUF, &buf) < 0) {
+                        LOG_ERROR(" VIDIOC_QBUF, strerrno:{}, errno:{}", strerror(errno), errno);
+                    }
+                }
+            }
+        }
+    }
+    catch(const std::exception &ex) {
+        LOG_ERROR(ex.what());
+    }
+}
+
+void ObV4lGmslDevicePort::handleSpecialResolution(std::shared_ptr<V4lDeviceHandleGmsl> devHandle, const uint8_t *srcData, uint32_t srcSize,
+                                                  std::shared_ptr<VideoFrame> videoFrame) {
+    // LOG_DEBUG("-Entry handleSpecialResolution");
+    VALIDATE_NOT_NULL(devHandle);
+    // handle 848x480; 848x100; 424x240, 480x270 resolution
+    auto width      = devHandle->profile->getWidth();
+    auto height     = devHandle->profile->getHeight();
+    auto streamType = devHandle->profile->getType();
+    if((width % 424) == 0 || (width == 480 && height == 270)) {
+        int originalWidth  = width;
+        int originalHeight = height;
+        int paddedWidth    = 0;
+        int paddedHeight   = 0;
+        int trimRight      = 0;
+        int trimBottom     = 0;
+
+        if(streamType == OB_STREAM_IR_LEFT || streamType == OB_STREAM_IR_RIGHT || streamType == OB_STREAM_IR) {
+            if(originalWidth == 848) {
+                paddedWidth = (originalWidth + 48);
+            }
+            else if(originalWidth == 424) {
+                paddedWidth = (originalWidth + 24);
+            }
+            else if((originalWidth == 480) && (originalHeight == 270)) {
+                paddedWidth = (originalWidth + 32);
+            }
+
+            paddedHeight = originalHeight;
+
+            // Calculate the number of pixels to fill
+            trimRight  = paddedWidth - originalWidth;
+            trimBottom = paddedHeight - originalHeight;
+            // LOG_DEBUG("-SpecialResolution paddedWidth:{}, paddedHeight:{}, trimRight:{}, trimBottom:{}", paddedWidth, paddedHeight, trimRight, trimBottom);
+            try {
+                cropDepthImage(srcData, videoFrame->getDataMutable(), paddedWidth, paddedHeight, trimRight, trimBottom);
+                videoFrame->setDataSize(originalWidth * originalHeight);
+                return;
+            }
+            catch(const std::exception &e) {
+                std::cerr << "Error: " << e.what() << std::endl;
+            }
+        }
+        else if((streamType == OB_STREAM_DEPTH || streamType == OB_STREAM_COLOR) && height != 270)  // Depth OR Color
+        {
+            if(originalWidth == 848) {
+                paddedWidth = (originalWidth + 16);
+            }
+            else if(originalWidth == 424) {
+                paddedWidth = (originalWidth + 24);
+            }
+            paddedHeight = originalHeight;
+
+            // Calculate the number of pixels to fill
+            trimRight  = paddedWidth - originalWidth;
+            trimBottom = paddedHeight - originalHeight;
+            // LOG_DEBUG("-SpecialResolution paddedWidth:{}, paddedHeight:{}, trimRight:{}, trimBottom:{}", paddedWidth, paddedHeight, trimRight, trimBottom);
+
+            try {
+                cropDepthImage16(reinterpret_cast<const uint16_t *>(srcData), reinterpret_cast<uint16_t *>(videoFrame->getDataMutable()), paddedWidth,
+                                 paddedHeight, trimRight, trimBottom);
+                videoFrame->setDataSize(originalWidth * originalHeight * 2);
+                return;
+            }
+            catch(const std::exception &e) {
+                // Handle exceptions
+                std::cerr << "Error: " << e.what() << std::endl;
+            }
+        }
+    }
+    videoFrame->updateData(srcData, srcSize);
+}
+
+StreamProfileList ObV4lGmslDevicePort::getStreamProfileList() {
+    StreamProfileList profileList;
+    foreachProfileGmsl(deviceHandles_, [&profileList](std::shared_ptr<V4lDeviceHandleGmsl> devHandle, std::shared_ptr<VideoStreamProfile> profile) {
+        utils::unusedVar(devHandle);
+        profileList.push_back(profile);
+        return false;  // false means continue
+    });
+    return profileList;
+}
+
+uint32_t phaseProfileFormatToFourccGmsl(std::shared_ptr<const VideoStreamProfile> profile) {
+    int      formatFourcc    = 0;
+    OBFormat format          = profile->getFormat();
+    auto     foundFormatIter = std::find_if(v4lFourccMapGmsl.begin(), v4lFourccMapGmsl.end(),
+                                            [&](const std::pair<uint32_t, uint32_t> &item) { return item.second == utils::obFormatToUvcFourcc(format); });
+    if(foundFormatIter != v4lFourccMapGmsl.end()) {
+        return (const utils::big_endian<int> &)(foundFormatIter->first);
+    }
+
+    formatFourcc = utils::obFormatToUvcFourcc(format);
+    if(formatFourcc == 0) {
+        LOG_ERROR("unsupported format {}", profile->getFormat());
+        return 0;
+    }
+
+    return (const utils::big_endian<int> &)(formatFourcc);
+}
+
+void ObV4lGmslDevicePort::startStream(std::shared_ptr<const StreamProfile> profile, MutableFrameCallback callback) {
+    std::shared_ptr<V4lDeviceHandleGmsl> devHandle    = nullptr;
+    auto                                 videoProfile = profile->as<VideoStreamProfile>();
+    foreachProfileGmsl(deviceHandles_, [&](std::shared_ptr<V4lDeviceHandleGmsl> handle, std::shared_ptr<VideoStreamProfile> prof) {
+        if(prof->getWidth() == videoProfile->getWidth() && prof->getHeight() == videoProfile->getHeight() && prof->getFps() == videoProfile->getFps()
+           && prof->getFormat() == videoProfile->getFormat()) {
+            devHandle = handle;
+            return true;
+        }
+        return false;
+    });
+    if(!devHandle) {
+        throw pal_exception("No v4l device found for profile: width=" + std::to_string(videoProfile->getWidth())
+                            + ", height=" + std::to_string(videoProfile->getHeight()) + ", fps=" + std::to_string(videoProfile->getFps())
+                            + ", format=" + std::to_string(videoProfile->getFormat()));
+    }
+    if(devHandle->isCapturing) {
+        pal_exception("V4l device is already capturing");
+    }
+
+    if(devHandle->metadataFd >= 0) {
+        v4l2_format fmt = {};
+        fmt.type        = LOCAL_V4L2_BUF_TYPE_META_CAPTURE_GMSL;
+        if(xioctlGmsl(devHandle->metadataFd, VIDIOC_G_FMT, &fmt) < 0) {
+            throw io_exception("Failed to get metadata format! " + devHandle->metadataInfo->name + ", " + strerror(errno));
+        }
+        if(fmt.type != LOCAL_V4L2_BUF_TYPE_META_CAPTURE_GMSL) {
+            throw io_exception("Invalid metadata type!" + devHandle->metadataInfo->name + ", " + strerror(errno));
+        }
+
+        const std::vector<uint32_t> requires_formats   = { LOCAL_V4L2_META_FMT_D4XX_GMSL, V4L2_META_FMT_UVC };
+        bool                        set_format_success = false;
+
+        fmt.fmt.pix.width       = 1482175047;
+        fmt.fmt.pix.height      = 96;
+        fmt.fmt.pix.pixelformat = 0;
+
+        if(xioctlGmsl(devHandle->metadataFd, VIDIOC_S_FMT, &fmt) >= 0) {
+            LOG_DEBUG("-metadata-Set metadata format to {}", fmt.fmt.pix.pixelformat);
+            set_format_success = true;
+        }
+
+        if(!set_format_success) {
+            throw io_exception("Failed to set metadata format!" + devHandle->metadataInfo->name + ", " + strerror(errno));
+        }
+
+        struct v4l2_requestbuffers req = { 0 };
+        req.count                      = MAX_BUFFER_COUNT_GMSL;
+        req.type                       = LOCAL_V4L2_BUF_TYPE_META_CAPTURE_GMSL;
+        req.memory                     = USE_MEMORY_MMAP ? V4L2_MEMORY_MMAP : V4L2_MEMORY_USERPTR;
+        if(xioctlGmsl(devHandle->metadataFd, VIDIOC_REQBUFS, &req) < 0) {
+            throw io_exception("Failed to request metadata buffers!" + devHandle->metadataInfo->name + ", " + strerror(errno));
+        }
+        for(uint32_t i = 0; i < req.count && i < MAX_BUFFER_COUNT_GMSL; i++) {
+            struct v4l2_buffer buf = {};
+            memset(&buf, 0, sizeof(buf));
+            buf.type   = LOCAL_V4L2_BUF_TYPE_META_CAPTURE_GMSL;
+            buf.memory = USE_MEMORY_MMAP ? V4L2_MEMORY_MMAP : V4L2_MEMORY_USERPTR;
+            buf.index  = i;  // only one buffer
+            if(xioctlGmsl(devHandle->metadataFd, VIDIOC_QUERYBUF, &buf) < 0) {
+                throw io_exception("Failed to query metadata buffer!" + devHandle->metadataInfo->name + ", " + strerror(errno));
+            }
+
+            if(USE_MEMORY_MMAP) {
+                devHandle->metadataBuffers[i].ptr = (uint8_t *)mmap(NULL, buf.length, PROT_READ | PROT_WRITE, MAP_SHARED, devHandle->metadataFd, buf.m.offset);
+                devHandle->metadataBuffers[i].length = buf.length;
+                if(devHandle->metadataBuffers[i].ptr == MAP_FAILED) {
+                    LOG_ERROR(" mmap, errnoStr:{}, errno:{}, line:{} ", strerror(errno), errno, __LINE__);
+                }
+            }
+            else {
+                uint8_t  md_extra         = (LOCAL_V4L2_BUF_TYPE_META_CAPTURE_GMSL == buf.type) ? MAX_META_DATA_SIZE : 0;
+                uint32_t _length          = buf.length + md_extra;
+                devHandle->buffers[i].ptr = static_cast<uint8_t *>(malloc(_length));
+                ;
+                devHandle->buffers[i].length = _length;
+                if(!devHandle->buffers[i].ptr) {
+                    LOG_ERROR(" User_p allocation failed!, errnoStr:{}, errno:{}, line:{} ", strerror(errno), errno, __LINE__);
+                }
+                memset(devHandle->buffers[i].ptr, 0, _length);
+            }
+
+            if(xioctlGmsl(devHandle->metadataFd, VIDIOC_QBUF, &buf) < 0) {
+                LOG_ERROR(" VIDIOC_QBUF, errnoStr:{}, errno:{}, line:{} ", strerror(errno), errno, __LINE__);
+            }
+        }
+
+        LOG_DEBUG("-metadata-VIDIOC_STREAMON---");
+        v4l2_buf_type bufType = LOCAL_V4L2_BUF_TYPE_META_CAPTURE_GMSL;
+        if(xioctlGmsl(devHandle->metadataFd, VIDIOC_STREAMON, &bufType) < 0) {
+            throw io_exception("Failed to stream on metadata!" + devHandle->metadataInfo->name + ", " + strerror(errno));
+        }
+    }
+
+    if(devHandle->fd >= 0) {
+        v4l2_format fmt    = {};
+        fmt.type           = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+        fmt.fmt.pix.width  = videoProfile->getWidth();
+        fmt.fmt.pix.height = videoProfile->getHeight();
+        // fmt.fmt.pix.field       = V4L2_FIELD_NONE;
+        fmt.fmt.pix.field       = V4L2_FIELD_INTERLACED;
+        fmt.fmt.pix.pixelformat = phaseProfileFormatToFourccGmsl(videoProfile);
+
+        if(xioctlGmsl(devHandle->fd, VIDIOC_S_FMT, &fmt) < 0) {
+            throw io_exception("Failed to set format!" + devHandle->info->name + ", " + strerror(errno));
+        }
+        if(xioctlGmsl(devHandle->fd, VIDIOC_G_FMT, &fmt) < 0) {
+            throw io_exception("Failed to get format!" + devHandle->info->name + ", " + strerror(errno));
+        }
+        LOG_DEBUG("Video node was successfully configured to {0} format, fd {1}, name: {2}", fourccToStringGmsl(fmt.fmt.pix.pixelformat), devHandle->fd,
+                  devHandle->info->name);
+
+#if 0
+        struct v4l2_streamparm streamparm={};
+        memset(&streamparm, 0x00, sizeof(struct v4l2_streamparm));
+        streamparm.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+        if(xioctlGmsl(devHandle->fd, VIDIOC_G_PARM, &streamparm) < 0) {
+            LOG_ERROR(" VIDIOC_G_PARM, errno:{}({}), line:{}", strerror(errno), errno, __LINE__);
+        }
+
+        LOG_DEBUG("Camera ouput format: ( {} x {} )  stride: {}, imagesize: {}, frate: {} / {}", fmt.fmt.pix.width, fmt.fmt.pix.height, fmt.fmt.pix.bytesperline,
+                fmt.fmt.pix.sizeimage, streamparm.parm.capture.timeperframe.denominator, streamparm.parm.capture.timeperframe.numerator);
+#endif
+
+#if 1
+        v4l2_streamparm streamparm                       = {};
+        streamparm.type                                  = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+        streamparm.parm.capture.timeperframe.numerator   = 1;
+        streamparm.parm.capture.timeperframe.denominator = videoProfile->getFps();
+        if(xioctlGmsl(devHandle->fd, VIDIOC_S_PARM, &streamparm) < 0) {
+            throw io_exception("Failed to set streamparm!" + devHandle->info->name + ", " + strerror(errno));
+        }
+        if(xioctlGmsl(devHandle->fd, VIDIOC_G_PARM, &streamparm) < 0) {
+            throw io_exception("Failed to get streamparm!" + devHandle->info->name + ", " + strerror(errno));
+        }
+#endif
+
+        struct v4l2_requestbuffers req = {};
+        req.count                      = MAX_BUFFER_COUNT_GMSL;
+        req.type                       = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+        req.memory                     = USE_MEMORY_MMAP ? V4L2_MEMORY_MMAP : V4L2_MEMORY_USERPTR;
+        if(xioctlGmsl(devHandle->fd, VIDIOC_REQBUFS, &req) < 0) {
+            throw io_exception("Failed to request buffers!" + devHandle->info->name + ", " + strerror(errno));
+        }
+        for(uint32_t i = 0; i < req.count && i < MAX_BUFFER_COUNT_GMSL; i++) {
+            struct v4l2_buffer buf = {};
+            memset(&buf, 0, sizeof(buf));
+            buf.type   = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+            buf.memory = USE_MEMORY_MMAP ? V4L2_MEMORY_MMAP : V4L2_MEMORY_USERPTR;
+            buf.index  = i;
+            if(xioctlGmsl(devHandle->fd, VIDIOC_QUERYBUF, &buf) < 0) {
+                throw io_exception("Failed to query buffer!" + devHandle->info->name + ", " + strerror(errno));
+            }
+
+            if(USE_MEMORY_MMAP) {
+                devHandle->buffers[i].ptr    = (uint8_t *)mmap(NULL, buf.length, PROT_READ | PROT_WRITE, MAP_SHARED, devHandle->fd, buf.m.offset);
+                devHandle->buffers[i].length = buf.length;
+                if(devHandle->buffers[i].ptr == MAP_FAILED) {
+                    LOG_ERROR(" mmap, errnoStr:{}, errno:{}, line:{} ", strerror(errno), errno, __LINE__);
+                }
+            }
+            else {
+                uint8_t  md_extra            = (V4L2_BUF_TYPE_VIDEO_CAPTURE == buf.type) ? MAX_META_DATA_SIZE : 0;
+                uint32_t _length             = buf.length + md_extra;
+                devHandle->buffers[i].ptr    = static_cast<uint8_t *>(malloc(_length));
+                devHandle->buffers[i].length = _length;
+
+                if(!devHandle->buffers[i].ptr) {
+                    LOG_ERROR(" User_p allocation failed!, errnoStr:{}, errno:{}, line:{} ", strerror(errno), errno, __LINE__);
+                }
+                memset(devHandle->buffers[i].ptr, 0, _length);
+
+                buf.m.userptr = reinterpret_cast<unsigned long>(devHandle->buffers[i].ptr);
+            }
+
+            if(xioctlGmsl(devHandle->fd, VIDIOC_QBUF, &buf) < 0) {
+                LOG_ERROR(" VIDIOC_QBUF, errnoStr:{}, errno:{}, line:{} ", strerror(errno), errno, __LINE__);
+            }
+        }
+
+        devHandle->profile = videoProfile;  // fix stoptream no streamoff issue. when streamon exception.
+
+        std::this_thread::sleep_for(std::chrono::milliseconds(10));
+        v4l2_buf_type                bufType = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+        std::unique_lock<std::mutex> lk(mMultiThreadI2CMutex);
+        if(xioctlGmsl(devHandle->fd, VIDIOC_STREAMON, &bufType) < 0) {
+            throw io_exception("Failed to stream on!" + devHandle->info->name + ", " + strerror(errno));
+        }
+        lk.unlock();
+        LOG_DEBUG("-VIDIOC_STREAMON success-");
+    }
+
+    if(pipe(devHandle->stopPipeFd) < 0) {
+        throw io_exception("Failed to create stop pipe!" + devHandle->info->name + ", " + strerror(errno));
+    }
+
+    devHandle->isCapturing   = true;
+    devHandle->profile       = videoProfile;
+    devHandle->frameCallback = callback;
+    devHandle->captureThread = std::make_shared<std::thread>([this, devHandle]() { captureLoop(devHandle); });
+
+    LOG_DEBUG("-Leave startStream-");
+}
+
+void ObV4lGmslDevicePort::stopStream(std::shared_ptr<const StreamProfile> profile) {
+    LOG_INFO("-Entry stopStream-");
+    if(deviceHandles_.empty()) {
+        LOG_DEBUG("-deviceHandles_.empty-");
+        return;
+    }
+
+    auto clearUp = [](std::shared_ptr<V4lDeviceHandleGmsl> devHandle) {
+        // cleanup
+        for(uint32_t i = 0; i < MAX_BUFFER_COUNT_GMSL; i++) {
+            if(devHandle->buffers[i].ptr) {
+                if(USE_MEMORY_MMAP) {
+                    munmap(devHandle->buffers[i].ptr, devHandle->buffers[i].length);
+                    devHandle->buffers[i].ptr    = nullptr;
+                    devHandle->buffers[i].length = 0;
+                    // LOG_DEBUG("-munmap-video devHandle->buffers[{}]", i);
+                }
+                else {
+                    free(devHandle->buffers[i].ptr);
+                    devHandle->buffers[i].ptr    = nullptr;
+                    devHandle->buffers[i].length = 0;
+                }
+            }
+            if(devHandle->metadataBuffers[i].ptr) {
+                if(USE_MEMORY_MMAP) {
+                    munmap(devHandle->metadataBuffers[i].ptr, devHandle->metadataBuffers[i].length);
+                    devHandle->metadataBuffers[i].ptr    = nullptr;
+                    devHandle->metadataBuffers[i].length = 0;
+                    // LOG_DEBUG("-munmap-metadata devHandle->metadataBuffers[{}]", i);
+                }
+                else {
+                    free(devHandle->metadataBuffers[i].ptr);
+                    devHandle->metadataBuffers[i].ptr    = nullptr;
+                    devHandle->metadataBuffers[i].length = 0;
+                }
+            }
+        }
+        if(devHandle->stopPipeFd[0] >= 0) {
+            close(devHandle->stopPipeFd[0]);
+            devHandle->stopPipeFd[0] = -1;
+        }
+
+        if(devHandle->stopPipeFd[1] >= 0) {
+            close(devHandle->stopPipeFd[1]);
+            devHandle->stopPipeFd[1] = -1;
+        }
+    };
+
+    auto videoProfile = profile->as<VideoStreamProfile>();
+    for(auto &devHandle: deviceHandles_) {
+        if(!devHandle->profile || !(*devHandle->profile == *videoProfile)) {
+            LOG_DEBUG("-deviceHandles devHandle->profile:{}, profile:{}, continue...", devHandle->profile, profile);
+            continue;
+        }
+        LOG_DEBUG("-deviceHandles- devHandle->isCapturing:{}, devHandle->profile:{}, profile:{}", devHandle->isCapturing, devHandle->profile, profile);
+
+        devHandle->isCapturing = false;
+        // signal the capture loop to stop
+        if(devHandle->stopPipeFd[1] >= 0) {
+            char buff[1] = { 0 };
+            auto ret     = write(devHandle->stopPipeFd[1], buff, 1);
+            if(ret < 0) {
+                LOG_ERROR("Failed to write to stop pipe, errnoStr:{}, errno:{}, line:{} ", strerror(errno), errno, __LINE__);
+            }
+        }
+
+        // wait for the capture loop to stop
+        if(devHandle->captureThread && devHandle->captureThread->joinable()) {
+            devHandle->captureThread->join();
+        }
+        if(devHandle->captureThread)
+            devHandle->captureThread.reset();
+
+        v4l2_buf_type                type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+        std::unique_lock<std::mutex> lk(mMultiThreadI2CMutex);
+        if(xioctlGmsl(devHandle->fd, VIDIOC_STREAMOFF, &type) < 0) {
+            clearUp(devHandle);
+            throw io_exception("Failed to stream off!" + devHandle->info->name + ", " + strerror(errno));
+        }
+        lk.unlock();
+        LOG_DEBUG("-VIDIOC_STREAMOFF success-");
+
+        clearUp(devHandle);
+
+        struct v4l2_requestbuffers req = {};
+        req.count                      = 0;
+        req.type                       = type;
+        req.memory                     = USE_MEMORY_MMAP ? V4L2_MEMORY_MMAP : V4L2_MEMORY_USERPTR;
+        if(xioctlGmsl(devHandle->fd, VIDIOC_REQBUFS, &req) < 0) {
+            throw io_exception("Failed to request buffers!" + devHandle->info->name + ", " + strerror(errno));
+        }
+
+        if(devHandle->metadataFd >= 0) {
+            type = LOCAL_V4L2_BUF_TYPE_META_CAPTURE_GMSL;
+            if(xioctlGmsl(devHandle->metadataFd, VIDIOC_STREAMOFF, &type) < 0) {
+                throw io_exception("Failed to stream off metadata!" + devHandle->metadataInfo->name + ", " + strerror(errno));
+            }
+            LOG_DEBUG("-VIDIOC_STREAMOFF metadata success-");
+
+            req.count  = 0;
+            req.type   = type;
+            req.memory = USE_MEMORY_MMAP ? V4L2_MEMORY_MMAP : V4L2_MEMORY_USERPTR;
+            if(xioctlGmsl(devHandle->metadataFd, VIDIOC_REQBUFS, &req) < 0) {
+                throw io_exception("Failed to request metadata buffers!" + devHandle->metadataInfo->name + ", " + strerror(errno));
+            }
+        }
+    }
+    LOG_INFO("-Leave stopStream-");
+}
+
+void ObV4lGmslDevicePort::stopAllStream() {
+    LOG_DEBUG("-Entry stopAllStream-");
+    for(auto &devHandle: deviceHandles_) {
+        if(devHandle->isCapturing) {
+            BEGIN_TRY_EXECUTE({ stopStream(devHandle->profile); })
+            CATCH_EXCEPTION_AND_EXECUTE({
+                LOG_WARN("Failed to stop stream for {}", devHandle->info->name);
+                devHandle->isCapturing = false;
+                if(devHandle->captureThread && devHandle->captureThread->joinable()) {
+                    devHandle->captureThread->join();
+                }
+                devHandle->captureThread.reset();
+            })
+        }
+    }
+    LOG_DEBUG("-Leave stopAllStream-");
+}
+
+std::shared_ptr<const SourcePortInfo> ObV4lGmslDevicePort::getSourcePortInfo() const {
+    return portInfo_;
+}
+
+#define BASE_WAIT_RESPONSE_TIME_MS 1
+uint32_t ObV4lGmslDevicePort::sendAndReceive(const uint8_t *send, uint32_t sendLen, uint8_t *recv, uint32_t exceptedRecvLen) {
+    std::unique_lock<std::mutex> lk(mMultiThreadI2CMutex);
+    if(!sendData(send, sendLen)) {
+        return -1;
+    }
+    utils::sleepMs(BASE_WAIT_RESPONSE_TIME_MS);
+    if(!recvData(recv, &exceptedRecvLen)) {
+        return -1;
+    }
+    return exceptedRecvLen;
+}
+
+bool ObV4lGmslDevicePort::sendData(const uint8_t *data, const uint32_t dataLen) {
+    VALIDATE_NOT_NULL(data);
+
+    uint16_t opcode, nId = 0;
+    // , halfWordSize = 0, magic = 0;
+    uint32_t propertyId = 0, alignDataLen = 0, alignI2CDataLen = 0, ctrl = 0;
+    uint8_t  mI2cPackDataLen = 0;
+    // , mI2cPackLen = 0;
+    bool ret = false;
+
+    // LOG_DEBUG("-Entry sendData-dataLen:{} ", dataLen);
+    if(alignDataLen >= OB_GMSL_FW_I2C_DATA_LEN_CUR_MAX) {
+        alignDataLen = OB_GMSL_FW_I2C_DATA_LEN_CUR_MAX;
+    }
+    else {
+        alignDataLen = dataLen;
+    }
+
+    {
+        opcode = ((ProtocolHeader *)(data))->opcode;
+        nId    = ((ProtocolHeader *)(data))->nId;
+        // halfWordSize = ((ProtocolHeader *)(data))->halfWordSize;
+        // magic        = ((ProtocolHeader *)(data))->magic;
+        // LOG_DEBUG("------------------------------------------------------------------------");
+
+        uint8_t *pDataBuf = ((uint8_t *)(data)) + sizeof(ProtocolHeader);
+        propertyId        = *(uint32_t *)pDataBuf;
+        // LOG_DEBUG("sendData opcode:{}, nId:{}, halfWordSize:{}, magic:0x{:0x}, PropertyId:{}", opcode, nId, halfWordSize, magic, propertyId);
+
+        mI2cPackDataLen = dataLen - sizeof(ProtocolHeader);  //-sizeof(uint16_t);
+                                                             // mI2cPackLen     = mI2cPackDataLen + sizeof(i2c_msg_header_t);
+        // LOG_DEBUG("sendData mI2cPackDataLen:{}, alignDataLen:{}, mI2cPackLen:{} ", mI2cPackDataLen, alignDataLen, mI2cPackLen);
+
+#if 0
+        mData0 = propertyId & 0x000000FF;
+        mData1 = (propertyId >> 8) & 0x000000FF;
+        mData2 = (propertyId >> 16) & 0x000000FF;
+        mData3 = (propertyId >> 24) & 0x000000FF;
+        LOG_DEBUG("sendData 1data-PropertyId mData0:{}, mData1:{}, mData2:{}, mData3:{} ", mData0, mData1, mData2, mData3);
+        LOG_DEBUG("sendData 2data-PropertyId data0:{}, data1:{}, data2:{}, data3:{} ", pDataBuf[0], pDataBuf[1], pDataBuf[2], pDataBuf[3]);
+#endif
+
+        // LOG_DEBUG("--------------------------------------------------------------------------");
+        {
+            alignI2CDataLen = alignDataLen - 2;  // cal i2c_msg_t len
+            // LOG_DEBUG("sendData alignI2CDataLen:{} ", alignI2CDataLen);
+            i2c_msg_t send_i2c_pack_msg;
+            memset(&send_i2c_pack_msg, 0, sizeof(i2c_msg_t));
+            send_i2c_pack_msg.header.len   = alignI2CDataLen;  // G2R_GET_VERSION_CMD_LEN;
+            send_i2c_pack_msg.header.code  = opcode;           // G2R_GET_VERSION_CMD_CODE;
+            send_i2c_pack_msg.header.index = nId;              // inde++;
+            // memcpy(send_i2c_pack_msg._data, pDataBuf, mI2cPackDataLen);
+            std::memcpy(send_i2c_pack_msg._data, pDataBuf, mI2cPackDataLen);
+
+            if((mI2cPackDataLen <= 2) && (mI2cPackDataLen > 0)) {
+                propertyId = *(uint16_t *)send_i2c_pack_msg._data;
+                // LOG_DEBUG("sendData PropertyId:{} ", propertyId);
+                // LOG_DEBUG("sendData 04data-PropertyId dat0:{}, data1:{} ", send_i2c_pack_msg._data[0], send_i2c_pack_msg._data[1]);
+            }
+            else if(mI2cPackDataLen >= 4) {
+                propertyId = *(uint32_t *)send_i2c_pack_msg._data;
+                // LOG_DEBUG("sendData PropertyId:{} ", propertyId);
+                // LOG_DEBUG("sendData 4data-PropertyId dat0:{}, data1:{}, data2:{}, data3:{} ", send_i2c_pack_msg._data[0], send_i2c_pack_msg._data[1],
+                // send_i2c_pack_msg._data[2], send_i2c_pack_msg._data[3]);
+            }
+
+            if(propertyId == 202) {  // OB_PROP_DEVICE_REPOWER_BOOL
+                int value = *(uint8_t *)(send_i2c_pack_msg._data + 4);
+                LOG_DEBUG("sendData value:{} ", value);
+                if(value == 1) {
+                    // LOG_DEBUG("sendData PropertyId:{} -not need read i2c response status. handle resetGmslDriver.", propertyId);
+                    resetGmslDriver();
+                    return true;
+                }
+                else if(value == 0) {
+                    LOG_DEBUG("sendData PropertyId:{} -do not anything! -value:{} ", propertyId, value);
+                    return true;
+                }
+                else {
+                    LOG_ERROR("NOT support param!");
+                }
+            }
+            // LOG_DEBUG("--------------------------------------------------------------------------");
+
+            // alignDataLen = OB_GMSL_FW_I2C_DATA_LEN_CUR_MAX;  //252; //172;  GMSL I2C read 252 bytes/per
+            ctrl = G2R_CAMERA_CID_SET_DATA;
+            ret  = setXuExt(ctrl, (uint8_t *)(&send_i2c_pack_msg), alignI2CDataLen);
+            // LOG_DEBUG("-Leave ObV4lGmslDevicePort::sendData ret:{} ", ret);
+            return ret;
+            // return setXuExt(ctrl, data, alignDataLen);
+        }
+    }
+
+    // LOG_DEBUG("-Leave ObV4lGmslDevicePort::sendData ret:{} ", ret);
+    return ret;
+}
+
+bool ObV4lGmslDevicePort::recvData(uint8_t *data, uint32_t *dataLen) {
+
+    // LOG_DEBUG("-Entry recvData-dataLen:{0}", *dataLen);
+    uint32_t ctrl = 0;
+
+    VALIDATE_NOT_NULL(data);
+    VALIDATE_NOT_NULL(dataLen);
+
+    if(*dataLen <= OB_GMSL_FW_I2C_DATA_LEN_16) {
+        *dataLen = OB_GMSL_FW_I2C_DATA_LEN_16;
+    }
+    else if((*dataLen > OB_GMSL_FW_I2C_DATA_LEN_16) && (*dataLen <= OB_GMSL_FW_I2C_DATA_LEN_32)) {
+        *dataLen = OB_GMSL_FW_I2C_DATA_LEN_32;
+    }
+    else if((*dataLen > OB_GMSL_FW_I2C_DATA_LEN_32) && (*dataLen <= OB_GMSL_FW_I2C_DATA_LEN_64)) {
+        *dataLen = OB_GMSL_FW_I2C_DATA_LEN_64;
+    }
+    else if((*dataLen > OB_GMSL_FW_I2C_DATA_LEN_64) && (*dataLen <= OB_GMSL_FW_I2C_DATA_LEN_128)) {
+        *dataLen = OB_GMSL_FW_I2C_DATA_LEN_128;
+    }
+    else if((*dataLen > OB_GMSL_FW_I2C_DATA_LEN_128) && (*dataLen <= OB_GMSL_FW_I2C_DATA_LEN_192)) {
+        *dataLen = OB_GMSL_FW_I2C_DATA_LEN_192;
+    }
+    else if((*dataLen > OB_GMSL_FW_I2C_DATA_LEN_192) && (*dataLen <= OB_GMSL_FW_I2C_DATA_LEN_256)) {
+        *dataLen = OB_GMSL_FW_I2C_DATA_LEN_CUR_MAX;
+    }
+    else if((*dataLen > OB_GMSL_FW_I2C_DATA_LEN_256) && (*dataLen <= OB_GMSL_FW_I2C_DATA_LEN_512)) {
+        *dataLen = OB_GMSL_FW_I2C_DATA_LEN_CUR_MAX;
+    }
+    else if(*dataLen > OB_GMSL_FW_I2C_DATA_LEN_512) {
+        *dataLen = OB_GMSL_FW_I2C_DATA_LEN_CUR_MAX;
+    }
+    else {
+        *dataLen = OB_GMSL_FW_I2C_DATA_LEN_CUR_MAX;
+    }
+
+    // LOG_DEBUG("-PuRaw send read data *dataLen:{}", *dataLen);
+    // note fw read data len
+    {
+        //*dataLen = OB_GMSL_FW_I2C_DATA_LEN_CUR_MAX;
+        // setPuRaw(G2R_CAMERA_CID_SET_DATA_LEN, G2R_GET_VERSION_DATA_LEN);
+        *dataLen += 10;  //*dataLen(real data len) + packhead(8) +propid(2)
+        // LOG_DEBUG("-PuRaw send read data cal(*dataLen+10) real *dataLen:{}", *dataLen);
+        setPuRaw(G2R_CAMERA_CID_SET_DATA_LEN, *dataLen);
+        ctrl = G2R_CAMERA_CID_GET_DATA;
+    }
+
+    return getXuExt(ctrl, data, dataLen);
+}
+
+bool ObV4lGmslDevicePort::setPu(uint32_t propertyId, int32_t value) {
+    auto fd = deviceHandles_.front()->fd;
+    // LOG_DEBUG("-Entry ObV4lGmslDevicePort::setPu propertyId={}, value:{}, devNode:{}", propertyId, value, deviceHandles_[getPuDevIndex()]->info->name);
+    // LOG_DEBUG("-Entry ObV4lGmslDevicePort::setPu propertyId={}, value:{}, devNode-front():{}", propertyId, value, deviceHandles_.front()->info->name);
+
+#if 0
+    int num=deviceHandles_.size();
+    for(int i=0;i<num;i++) {
+        LOG_DEBUG("getPu deviceHandles_[i]->info->name:{}", deviceHandles_[i]->info->name);
+    }
+#endif
+
+    // auto  fd  = deviceHandles_.front()->fd;
+    auto cid = CIDFromOBPropertyIDGmsl(propertyId);
+    // LOG_DEBUG("Entry ObV4lGmslDevicePort::setPu propertyId={}, cid={}, value:{} ", propertyId, cid, value);
+
+    struct v4l2_control control = { cid, value };
+    if(OB_PROP_COLOR_AUTO_EXPOSURE_BOOL == propertyId) {
+        control.value = value ? V4L2_EXPOSURE_AUTO : V4L2_EXPOSURE_MANUAL;
+    }
+
+    // Set value
+    {
+        std::unique_lock<std::mutex> lk(mMultiThreadI2CMutex);
+        if(xioctlGmsl(fd, VIDIOC_S_CTRL, &control) < 0) {
+            LOG_ERROR("set {0} xioctlGmsl(VIDIOC_S_CTRL) failed, {1}", propertyId, strerror(errno));
+            return false;
+        }
+    }
+
+    // LOG_DEBUG("Leave ObV4lGmslDevicePort::setPu Success! propertyId={}, cid={}, value:{} ", propertyId, cid, value);
+    return true;
+}
+
+bool ObV4lGmslDevicePort::getPu(uint32_t propertyId, int32_t &value) {
+    auto fd = deviceHandles_.front()->fd;
+
+    // LOG_DEBUG("-Entry ObV4lGmslDevicePort::getPu propertyId={}, devNode:{}", propertyId, deviceHandles_.front()->info->name);
+
+#if 0
+    int num=deviceHandles_.size();
+    for(int i=0;i<num;i++) {
+        LOG_DEBUG("getPu deviceHandles_[i]->info->name:{}", deviceHandles_[i]->info->name);
+    }
+#endif
+
+    // auto  fd  = deviceHandles_.front()->fd;
+    auto cid = CIDFromOBPropertyIDGmsl(propertyId);
+    // LOG_DEBUG("Entry ObV4lGmslDevicePort::getPu propertyId={}, cid={} ", propertyId, cid);
+
+    struct v4l2_control control = { cid, 0 };
+
+    {
+        std::unique_lock<std::mutex> lk(mMultiThreadI2CMutex);
+        if(xioctlGmsl(fd, VIDIOC_G_CTRL, &control) < 0) {
+            LOG_ERROR("get {0} xioctlGmsl(VIDIOC_G_CTRL) failed, {1}", propertyId, strerror(errno));
+            return false;
+        }
+    }
+
+    if(OB_PROP_COLOR_AUTO_EXPOSURE_BOOL == propertyId) {
+        control.value = (V4L2_EXPOSURE_MANUAL == control.value) ? 0 : 1;
+    }
+    value = control.value;
+    // LOG_DEBUG("Leave ObV4lGmslDevicePort getPu Success! propertyId={}, value: {} ", propertyId, value);
+
+    return true;
+}
+
+UvcControlRange ObV4lGmslDevicePort::getPuRange(uint32_t propertyId) {
+    auto fd = deviceHandles_.front()->fd;
+    // LOG_DEBUG("-Entry ObV4lGmslDevicePort::getPuRange propertyId={}, devNode:{}", propertyId, deviceHandles_.front()->info->name);
+
+#if 0
+    int num=deviceHandles_.size();
+    for(int i=0;i<num;i++) {
+        LOG_DEBUG("getPuRange deviceHandles_[i]->info->name:{}", deviceHandles_[i]->info->name);
+    }
+#endif
+
+    // auto fd = deviceHandles_.front()->fd;
+    // LOG_DEBUG("Leave ObV4lGmslDevicePort::getPuRange deviceHandles_.front()->info->name:{} \n", deviceHandles_.front()->info->name );
+    if(propertyId == OB_PROP_COLOR_AUTO_EXPOSURE_PRIORITY_INT || propertyId == OB_PROP_COLOR_AUTO_EXPOSURE_BOOL
+       || propertyId == OB_PROP_COLOR_AUTO_WHITE_BALANCE_BOOL) {
+        int             min        = 0;
+        int             max        = 1;
+        int             step       = 1;
+        int             defaultVal = 0;
+        UvcControlRange range(min, max, step, defaultVal);
+        return range;
+    }
+    struct v4l2_queryctrl query = {};
+    query.id                    = CIDFromOBPropertyIDGmsl(propertyId);
+    // LOG_DEBUG("--->query.id:{} \n", query.id );
+    {
+        std::unique_lock<std::mutex> lk(mMultiThreadI2CMutex);
+        if(xioctlGmsl(fd, VIDIOC_QUERYCTRL, &query) < 0) {
+            query.minimum = query.maximum = 0;
+        }
+    }
+
+    UvcControlRange range(query.minimum, query.maximum, query.step, query.default_value);
+    // LOG_DEBUG("Leave ObV4lGmslDevicePort::getPuRange propertyId:{}, query.minimum:{}, query.maximum:{}, query.step:{}, query.default_value:{} ", propertyId,
+    //           query.minimum, query.maximum, query.step, query.default_value);
+    return range;
+}
+
+bool ObV4lGmslDevicePort::setPuRaw(uint32_t propertyId, int32_t value) {
+    // LOG_DEBUG("-Entry ObV4lGmslDevicePort::setPuRaw---cid={0} value:{1}", propertyId, value);
+
+    auto fd  = deviceHandles_.front()->fd;
+    auto cid = propertyId;
+
+    // LOG_DEBUG("---Entry ObV4lGmslDevicePort::setPuRaw---cid={0} ", cid);
+    struct v4l2_control control = { cid, value };
+    // Set value
+    if(xioctlGmsl(fd, VIDIOC_S_CTRL, &control) < 0) {
+        LOG_ERROR("set {0} xioctlGmsl(VIDIOC_S_CTRL) failed, {1}", cid, strerror(errno));
+        return false;
+    }
+    // LOG_DEBUG("---Leave ObV4lGmslDevicePort::setPuRaw-cid={}", propertyId);
+    return true;
+}
+
+bool ObV4lGmslDevicePort::setXuExt(uint32_t ctrl, const uint8_t *data, uint32_t len) {
+    VALIDATE_NOT_NULL(data);
+    (void)len;
+    auto fd  = deviceHandles_.front()->fd;
+    auto cid = ctrl;  // CIDFromOBPropertyID(ctrl);
+
+    // i2c_msg_t *msg        = (i2c_msg_t *)data;
+    // uint32_t   propertyId = *(uint32_t *)msg->_data;
+    // LOG_DEBUG("-Entry setXuExt PropertyId:{}, len:{}, ctrl:{}", propertyId, ctrl, len);
+
+    if(G2R_CAMERA_CID_SET_DATA == ctrl) {
+        // struct v4l2_ext_control xctrl { cid, G2R_RW_DATA_LEN, 0, 0 };
+        struct v4l2_ext_control xctrl {
+            cid, G2R_RW_DATA_LEN, 0, 0
+        };
+        xctrl.p_u8 = const_cast<uint8_t *>(data);
+
+#if 0
+        struct v4l2_ext_control xctrl{ cid, uint32_t(len), 0, 0 };
+        switch(len) {
+        case 1:
+            xctrl.value = *(reinterpret_cast<const uint8_t *>(data));
+            break;
+        case 2:
+            xctrl.value = *reinterpret_cast<const uint16_t *>(data);
+            break;//TODO check signed/unsigned
+        case 4:
+            xctrl.value = *reinterpret_cast<const int32_t *>(data);
+            break;
+        case 8:
+            xctrl.value64 = *reinterpret_cast<const int64_t *>(data);
+            break;
+        default:
+            xctrl.p_u8 = const_cast<uint8_t *>(data);//TODO aggregate initialization with union
+        }
+#endif
+
+        if(ctrl == OB_PROP_COLOR_AUTO_EXPOSURE_BOOL)
+            xctrl.value = xctrl.value ? V4L2_EXPOSURE_APERTURE_PRIORITY : V4L2_EXPOSURE_MANUAL;
+
+        // Extract the control group from the underlying control query
+        v4l2_ext_controls ctrls_block{ xctrl.id & 0xffff0000, 1, 0, 0, 0, &xctrl };
+
+        // LOG_DEBUG("Entry v4l_mipi_device::set_xu  ctrls_block: " << ctrls_block);
+        // LOG_DEBUG("ctrls_block.ctrl_class:{} ctrls_block.count:{} ctrls_block.request_fd:{} ", ctrls_block.ctrl_class, ctrls_block.count,
+        // ctrls_block.request_fd);
+
+        int retVal = xioctlGmsl(fd, VIDIOC_S_EXT_CTRLS, &ctrls_block);
+        if(retVal < 0) {
+            LOG_DEBUG("--->>> set_xu---NG---");
+            if(errno == EIO || errno == EAGAIN)  // TODO: Log?
+                return false;
+
+            throw io_exception("set ctrl:" + std::to_string(ctrl) + "xioctlGmsl(VIDIOC_S_EXT_CTRLS) failed! err:" + strerror(errno));
+        }
+    }
+
+    // LOG_DEBUG("-Leave ObV4lGmslDevicePort::setXuExt");
+    return true;
+}
+
+bool ObV4lGmslDevicePort::getXuExt(uint32_t ctrl, uint8_t *data, uint32_t *len) {
+
+    // LOG_DEBUG("-Entry ObV4lGmslDevicePort::getXuExt-ctrl:{}, *len:{} ", ctrl, *len);
+
+    VALIDATE_NOT_NULL(data);
+    VALIDATE_NOT_NULL(len);
+    auto                    fd  = deviceHandles_.front()->fd;
+    auto                    cid = ctrl;  // CIDFromOBPropertyID(ctrl);
+    struct v4l2_ext_control control {
+        cid, G2R_RW_DATA_LEN, 0, 0
+    };
+    std::vector<uint8_t> dataRecvBuf(MAX_I2C_PACKET_SIZE, 0);
+    control.p_u8 = dataRecvBuf.data();
+    v4l2_ext_controls ext{ control.id & 0xffff0000, 1, 0, 0, 0, &control };
+
+    const int MAX_TRIES       = 30;
+    const int TRY_INTERVAL_MS = 10;
+    int       tries           = 0;
+    while(++tries < MAX_TRIES) {
+        std::fill(dataRecvBuf.begin(), dataRecvBuf.end(), 0);
+        int ret = xioctlGmsl(fd, VIDIOC_G_EXT_CTRLS, &ext);
+        if(ret < 0) {
+            utils::sleepMs(TRY_INTERVAL_MS);
+            // exception is thrown if the ioctl fails twice
+            continue;
+        }
+
+        if(ctrl == OB_PROP_COLOR_AUTO_EXPOSURE_BOOL)
+            control.value = (V4L2_EXPOSURE_MANUAL == control.value) ? 0 : 1;
+
+        if(*len < sizeof(__s64)) {
+            memcpy(data, (void *)(&control.value), *len);
+        }
+        else if(ctrl == G2R_CAMERA_CID_GET_DATA) {
+            auto *pRecvDataBuf = reinterpret_cast<i2c_msg_t *>(&dataRecvBuf[0]);
+            // LOG_DEBUG("--------------------------------------------------------------------------");
+            // LOG_DEBUG("recvData resp code:  {} ", std::to_string(pRecvDataBuf->header.code));
+            // LOG_DEBUG("recvData resp index: {} ", std::to_string(pRecvDataBuf->header.index));
+            // LOG_DEBUG("recvData resp len:   {} ", std::to_string(pRecvDataBuf->header.len));
+            // LOG_DEBUG("recvData resp res:   {} ", std::to_string(pRecvDataBuf->body.res));
+            // LOG_DEBUG("--------------------------------------------------------------------------");
+
+            uint16_t readRespDataSize = (pRecvDataBuf->header.len - sizeof(pRecvDataBuf->header) - sizeof(pRecvDataBuf->body.res));
+            // handle  pRecvDataBuf->header.len==0 status exception
+            if((pRecvDataBuf->header.len == 0) || (pRecvDataBuf->header.code == 0) || (pRecvDataBuf->header.len == 65535) || (pRecvDataBuf->header.len > 248)) {
+                readRespDataSize = 0;
+                // LOG_DEBUG("I2C read data err!. pRecvDataBuf->header.len:{}, pRecvDataBuf->header.code:{}, tries:{}",
+                // std::to_string(pRecvDataBuf->header.len),
+                //           std::to_string(pRecvDataBuf->header.code), tries);
+
+                utils::sleepMs(TRY_INTERVAL_MS * (tries > 10 ? 10 : tries));
+
+                continue;
+            }
+
+            // repeat pack usb protocolHeader
+            ProtocolMsg usbProtocolMsg;
+            memset(&usbProtocolMsg, 0, sizeof(usbProtocolMsg));
+            usbProtocolMsg.header.opcode       = pRecvDataBuf->header.code;
+            usbProtocolMsg.header.nId          = pRecvDataBuf->header.index;  // return I2C resp index
+            usbProtocolMsg.header.magic        = 0x4252;                      // HP_RESPONSE_MAGIC;
+            usbProtocolMsg.buf.data.resp.res   = pRecvDataBuf->body.res;
+            usbProtocolMsg.header.halfWordSize = (readRespDataSize + sizeof(usbProtocolMsg.buf.data.resp.res) + 1) / sizeof(uint16_t);
+            usbProtocolMsg.buf.len             = readRespDataSize + sizeof(usbProtocolMsg.buf.data.resp.res);
+
+            // LOG_DEBUG("cal readRespDataSize: {} ", readRespDataSize);
+            // LOG_DEBUG("cal usbProtocolMsg.header.halfWordSize: {} ", std::to_string(usbProtocolMsg.header.halfWordSize));
+            // LOG_DEBUG("cal readRespDataSize:    {} ", readRespDataSize);
+            // LOG_DEBUG("cal recal usbProtocolMsg.buf.len:    {}", std::to_string(usbProtocolMsg.buf.len));
+
+            // check handle  pRecvDataBuf->header.len==0 status exception
+            if(readRespDataSize > 0) {
+                // memcpy(usbProtocolMsg.buf.data.resp.data, pRecvDataBuf->body.data, readRespDataSize);
+                std::memcpy(usbProtocolMsg.buf.data.resp.data, pRecvDataBuf->body.data, readRespDataSize);
+            }
+            else {
+                LOG_TRACE("get read I2C dataSize=0 or dataSize error! readRespDataSize:{}", readRespDataSize);
+            }
+            // memcpy(usbProtocolMsg.buf.data.resp.data, pRecvDataBuf->body.data, readRespDataSize);
+            // std::memcpy(usbProtocolMsg.buf.data.resp.data, pRecvDataBuf->body.data, readRespDataSize);
+
+            *len = sizeof(usbProtocolMsg.header) + usbProtocolMsg.buf.len + sizeof(usbProtocolMsg.buf.len);
+            // LOG_DEBUG("-copy_usbProtocolMsg *len: {}", *len);
+            std::memcpy(data, &usbProtocolMsg, *len);
+#if 0
+            if(usbProtocolMsg.header.opcode==3){
+                uint16_t respMsgDataOffset = sizeof(usbProtocolMsg.header) + sizeof(usbProtocolMsg.buf.data.resp.res);
+                LOG_DEBUG("-----------------------------------------------------");
+                auto *tmp3 = reinterpret_cast<VersionInfoTypeDef*>(data+respMsgDataOffset);
+                LOG_DEBUG("---> firmware_version: {} ", tmp3->firmware_version );
+                LOG_DEBUG("---> system_version: {} ", tmp3->system_version );
+                LOG_DEBUG("---> sdk_version: {} ", tmp3->sdk_version );
+                LOG_DEBUG("---> depth_chip: {} ", tmp3->depth_chip );
+                LOG_DEBUG("---> system_chip: {} ", tmp3->system_chip );
+                LOG_DEBUG("---> serial_number: {} ", tmp3->serial_number );
+                LOG_DEBUG("---> deviceName: {} ", tmp3->deviceName );
+                LOG_DEBUG("---> device_type: {} ", std::to_string( tmp3->device_type) );
+            }
+#endif
+        }
+        // LOG_DEBUG("Leave ObV4lGmslDevicePort::getXuExt--ctrl:{} ", ctrl);
+        return true;
+    }
+
+    // sending error on ioctl failure
+    if(errno == EIO || errno == EAGAIN) {
+        return false;
+    }
+    throw io_exception("set ctrl:" + std::to_string(ctrl) + "xioctlGmsl(VIDIOC_G_EXT_CTRLS) failed! err:" + strerror(errno)
+                       + " tries:" + std::to_string(tries));
+}
+
+// reset firmware cmd to driver. driver reset gmsl9295/9296 & firmware.
+// gmsl9295/9296 power on/off is controlled by driver.
+int ObV4lGmslDevicePort::resetGmslDriver() {
+    LOG_DEBUG("-Entry ObV4lGmslDevicePort::rebootFirmware");
+    auto fd = deviceHandles_.front()->fd;
+
+    struct v4l2_ext_control control {};
+    memset(&control, 0, sizeof(control));
+    control.id    = G2R_CAMERA_CID_RESET_POWER;
+    control.value = 1;
+    if(xioctlGmsl(fd, VIDIOC_S_CTRL, &control) < 0) {
+        LOG_ERROR("xioctlGmsl(G2R_CAMERA_CID_RESET_POWER) with control_id={} failed!", G2R_CAMERA_CID_RESET_POWER);
+        return -1;
+    }
+    LOG_DEBUG("-Leave ObV4lGmslDevicePort::rebootFirmware");
+    return 0;
+}
+
+// bus_info:platform:tegra-capture-vi:0
+#define GMSL_MIPI_DEVICE_TAG "platform:tegra-capture-vi"
+bool is_gmsl_mipi_device(const std::string bus_info) {
+    return bus_info.find(GMSL_MIPI_DEVICE_TAG) != std::string::npos;
+}
+
+bool isGmslMipiDeviceForNvidia(std::shared_ptr<const USBSourcePortInfo> portInfo) {
+    return (portInfo->hubId.find(GMSL_MIPI_DEVICE_TAG) != std::string::npos) && (portInfo->connSpec == "GMSL2");
+}
+
+bool ObV4lGmslDevicePort::isGmslDeviceForPlatformNvidia(std::shared_ptr<const USBSourcePortInfo> portInfo) {
+    return isGmslMipiDeviceForNvidia(portInfo);
+}
+
+void getV4lDeviceBusInfo(const std::string &dev_name, std::string &bus_info, std::string &card) {
+    struct v4l2_capability vcap;
+    int                    fd = -1;
+
+    fd = open(dev_name.c_str(), O_RDWR);
+    if(fd < 0) {
+        LOG_DEBUG("Mipi device capability could not be grabbed");
+        return;
+    }
+
+    memset(&vcap, 0, sizeof(vcap));
+    if(xioctlGmsl(fd, VIDIOC_QUERYCAP, &vcap) < 0) {
+        struct media_device_info mdi;
+        memset(&mdi, 0, sizeof(mdi));
+        if(xioctlGmsl(fd, MEDIA_IOC_DEVICE_INFO, &mdi) >= 0) {
+            if(mdi.bus_info[0])
+                bus_info = mdi.bus_info;
+            else
+                bus_info = std::string("platform:") + mdi.driver;
+
+            if(mdi.model[0])
+                card = mdi.model;
+            else
+                card = mdi.driver;
+
+            LOG_DEBUG("-bus_info:{}, card:{}", bus_info, card);
+        }
+    }
+    else {
+        bus_info           = reinterpret_cast<const char *>(vcap.bus_info);
+        card               = reinterpret_cast<const char *>(vcap.card);
+        std::string driver = reinterpret_cast<const char *>(vcap.driver);
+
+#if 0
+        LOG_DEBUG("VIDIOC_QUERYCAP driver:{} ", driver);
+        LOG_DEBUG("VIDIOC_QUERYCAP version:{} ", vcap.version);
+        LOG_DEBUG("VIDIOC_QUERYCAP capabilities:{} ", vcap.capabilities);
+        LOG_DEBUG("VIDIOC_QUERYCAP device_caps:{} ", vcap.device_caps);
+        LOG_DEBUG("VIDIOC_QUERYCAP bus_info:{} ", bus_info);
+        LOG_DEBUG("VIDIOC_QUERYCAP card:{} ", card);
+#endif
+    }
+
+    close(fd);
+}
+
+int file_exists(const char *filename) {
+    return (access(filename, F_OK) != -1);
+}
+
+std::vector<std::string> getVideoPaths(std::vector<std::string> &video_paths) {
+    video_paths.resize(0);
+
+    // Enumerate all subdevices present on the system
+    DIR *dir = opendir("/sys/class/video4linux");
+    if(!dir) {
+        LOG_DEBUG("Cannot access /sys/class/video4linux");
+        return video_paths;
+    }
+    while(dirent *entry = readdir(dir)) {
+        std::string name = entry->d_name;
+        if(name == "." || name == "..")
+            continue;
+
+        // Resolve a pathname to ignore virtual video devices and  sub-devices
+        static const std::regex video_dev_pattern("(\\/video\\d+)$");
+
+        std::string path = "/sys/class/video4linux/" + name;
+        std::string real_path{};
+        char        buff[PATH_MAX] = { 0 };
+        if(realpath(path.c_str(), buff) != nullptr) {
+            real_path = std::string(buff);
+            if(real_path.find("virtual") != std::string::npos)
+                continue;
+            if(!std::regex_search(real_path, video_dev_pattern)) {
+                continue;
+            }
+        }
+
+        if(real_path.empty()) {
+            continue;
+        }
+
+        video_paths.push_back(real_path);
+    }
+    closedir(dir);
+
+    if(video_paths.size() > 0) {
+        std::sort(video_paths.begin(), video_paths.end(), [](const std::string &first, const std::string &second) {
+            // getting videoXX
+            std::string first_video  = first.substr(first.find_last_of('/') + 1);
+            std::string second_video = second.substr(second.find_last_of('/') + 1);
+
+            // getting the index XX from videoXX
+            std::stringstream first_index(first_video.substr(first_video.find_first_of("0123456789")));
+            std::stringstream second_index(second_video.substr(second_video.find_first_of("0123456789")));
+            int               left_id = 0, right_id = 0;
+            first_index >> left_id;
+            second_index >> right_id;
+            return left_id < right_id;
+        });
+    }
+    return video_paths;
+}
+
+bool isUsbDevicePath(const std::string &video_path) {
+    static const std::regex uvc_pattern("(\\/usb\\d+\\/)\\w+");  // Locate UVC device path pattern ../usbX/...
+    return std::regex_search(video_path, uvc_pattern);
+}
+
+const std::vector<UsbInterfaceInfo> ObV4lGmslDevicePort::queryDevicesInfo() {
+    std::vector<std::string> video_paths;
+    getVideoPaths(video_paths);
+    if(video_paths.empty()) {
+        return {};
+    }
+
+    std::vector<UsbInterfaceInfo> devInfoList;
+
+    for(auto &&video_path: video_paths) {
+        if(isUsbDevicePath(video_path)) {
+            continue;
+        }
+
+        auto name    = video_path.substr(video_path.find_last_of('/') + 1);  // from "/sys/class/video4linux/videoX" to get "videoX"
+        auto devName = "/dev/" + name;
+
+        std::string bus_info, card;
+        getV4lDeviceBusInfo(devName, bus_info, card);
+
+        struct orbbec_device_info devInfo;
+        memset(&devInfo, 0, sizeof(orbbec_device_info));
+        int res = getGmslDeviceInfoFromFW(devName, &devInfo);
+        if(res != 0) {
+            LOG_DEBUG("getGmslDeviceInfoFromFW failed! devName:{}", devName);
+            continue;
+        }
+
+        UsbInterfaceInfo info{};
+        info.vid              = GMSL_VID_ORBBEC;
+        info.pid              = devInfo.pid;
+        info.infName          = devName;
+        info.infUrl           = video_path;
+        info.infNameDescIndex = 0;  // unsupported
+        info.serial           = reinterpret_cast<char *>(devInfo.sn);
+        info.hubId            = bus_info;
+        info.url              = "gmsl2://" + std::to_string(info.pid) + ":" + std::to_string(info.vid) + "/1/" + std::to_string(devInfo.cam_num);
+        info.uid              = "gmsl2-" + std::to_string(devInfo.cam_num);
+        info.conn_spec        = gmsl2_type;
+        info.cls              = OB_USB_CLASS_VIDEO;  // borrowed from usb
+        if(devInfo.video_type == ORB_MUX_PAD_DEPTH) {
+            info.infIndex = INTERFACE_DEPTH;
+        }
+        else if(devInfo.video_type == ORB_MUX_PAD_RGB) {
+            info.infIndex = INTERFACE_COLOR;
+        }
+        else if(devInfo.video_type == ORB_MUX_PAD_IR_L) {
+            info.infIndex = INTERFACE_IR_LEFT;
+        }
+        else if(devInfo.video_type == ORB_MUX_PAD_IR_R) {
+            info.infIndex = INTERFACE_IR_RIGHT;
+        }
+        else {
+            continue;
+            LOG_DEBUG("Unsupported video type:{}", devInfo.video_type);
+        }
+        devInfoList.push_back(info);
+        LOG_DEBUG("Gmsl video port found! devName:{}, infName:{}", devName, info.infName);
+
+        if(info.infIndex == INTERFACE_DEPTH) {
+            UsbInterfaceInfo imuInfo = info;
+            imuInfo.cls              = OB_USB_CLASS_HID;  // borrowed from usb
+            imuInfo.infName          = "/dev/v4l-subdev" + std::to_string(devInfo.sub_num);
+            devInfoList.push_back(imuInfo);
+            LOG_DEBUG("Gmsl hid device found! devName:{}, infName:{}", devName, imuInfo.infName);
+        }
+    }
+
+    LOG_DEBUG("video queryDevicesInfo devInfoList.size():{}", devInfoList.size());
+    LOG_DEBUG("queryDevicesInfo done!");
+    return devInfoList;
+}
+}  // namespace libobsensor
diff --git a/src/platform/usb/uvc/ObV4lGmslDevicePort.hpp b/src/platform/usb/uvc/ObV4lGmslDevicePort.hpp
new file mode 100644
index 00000000..8bf31123
--- /dev/null
+++ b/src/platform/usb/uvc/ObV4lGmslDevicePort.hpp
@@ -0,0 +1,161 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include <array>
+#include <string>
+#include <thread>
+#include <sys/mman.h>
+
+#include "UvcDevicePort.hpp"
+#include "usb/enumerator/IUsbEnumerator.hpp"
+#include "frame/Frame.hpp"
+
+#include <linux/uvcvideo.h>
+#include <linux/videodev2.h>
+#include <linux/usb/video.h>
+
+#if 0
+
+#ifdef V4L2_META_FMT_UVC
+constexpr bool metadata_node = true;
+#else
+
+constexpr bool metadata_node = false;
+
+// Providing missing parts from videodev2.h
+// V4L2_META_FMT_UVC >> V4L2_CAP_META_CAPTURE is also defined, but the opposite does not hold
+#define V4L2_META_FMT_UVC v4l2_fourcc('U', 'V', 'C', 'H') /* UVC Payload Header */
+
+#ifndef V4L2_CAP_META_CAPTURE
+#define V4L2_CAP_META_CAPTURE 0x00800000 /* Specified in kernel header v4.16 */
+#endif                                   // V4L2_CAP_META_CAPTURE
+
+#endif  // V4L2_META_FMT_UVC
+
+#endif
+
+namespace libobsensor {
+
+static const uint16_t GMSL_VID_ORBBEC = 0x2BC5;
+static const uint16_t GMSL_PID_G335L  = 0x080B;  // 0x06D0;  // D457 dev
+
+static const std::string GMSL_SN_DEFAULT      = "0123456789";
+static const std::string GMSL_ASIC_SN_DEFAULT = "12345";
+
+static const uint32_t MAX_META_DATA_SIZE_GMSL = 255;
+static const uint32_t MAX_BUFFER_COUNT_GMSL   = 8;  // 4; //v4l3_buf default 4 buf. opt to 4->8
+// static const uint32_t LOCAL_V4L2_META_FMT_D4XX_GMSL = v4l2_fourcc('D', '4', 'X', 'X'); // borrows from videodev2.h, using for getting extention metadata
+static const uint32_t LOCAL_V4L2_META_FMT_D4XX_GMSL = v4l2_fourcc('G', '2', 'X', 'X');  // borrows from videodev2.h, using for getting extention metadata
+
+#define LOCAL_V4L2_BUF_TYPE_META_CAPTURE_GMSL ((v4l2_buf_type)13)
+
+// #define OB_GMSL_FW_I2C_DATA_LEN_CUR_MAX (256-16) //248 //246 //128 //160 //172 //192 //208 //224 //240 //246 //252  //fw max_read_len is 252
+// #define OB_GMSL_FW_I2C_DATA_LEN_CUR_MAX   //246 //128 //160 //172 //192 //208 //224 //240 //246 //252  //fw max_read_len is 252
+
+typedef enum {
+    OB_GMSL_FW_I2C_DATA_LEN_16  = 16,
+    OB_GMSL_FW_I2C_DATA_LEN_32  = 32,
+    OB_GMSL_FW_I2C_DATA_LEN_64  = 64,
+    OB_GMSL_FW_I2C_DATA_LEN_128 = 128,
+    OB_GMSL_FW_I2C_DATA_LEN_192 = 192,
+    OB_GMSL_FW_I2C_DATA_LEN_256 = 256,
+    OB_GMSL_FW_I2C_DATA_LEN_512 = 512,
+} ObGmslFwI2CDataLen;
+
+typedef enum {
+    OB_GMSL_GET_FIRMWARE_DATA_CTRL_ID = 1,
+} ObGmslGetFwDataCtrId;
+
+#pragma pack(push, 1)
+struct V4L2UvcMetaHeaderGmsl {
+    uint64_t ns;   // system timestamp of the payload in nanoseconds
+    uint16_t sof;  // USB Frame Number
+    // the rest of the meta buffer is the UVC Payload Header
+};
+#pragma pack(pop)
+
+struct V4L2FrameBufferGmsl {
+    ~V4L2FrameBufferGmsl() {
+        if(ptr != nullptr) {
+            munmap(ptr, length);
+            ptr = nullptr;
+        }
+    }
+    uint32_t length        = 0;
+    uint32_t actual_length = 0;
+    uint32_t sequence      = 0;
+    uint8_t *ptr           = nullptr;
+};
+
+struct V4lDeviceInfoGmsl {
+    std::string     name;
+    v4l2_capability cap;  // capabilities
+};
+
+struct V4lDeviceHandleGmsl {
+    std::shared_ptr<V4lDeviceInfoGmsl>                     info;
+    int                                                    fd;
+    std::array<V4L2FrameBufferGmsl, MAX_BUFFER_COUNT_GMSL> buffers;
+
+    std::shared_ptr<V4lDeviceInfoGmsl>                     metadataInfo;
+    int                                                    metadataFd;
+    std::array<V4L2FrameBufferGmsl, MAX_BUFFER_COUNT_GMSL> metadataBuffers;
+
+    MutableFrameCallback                      frameCallback;
+    std::shared_ptr<const VideoStreamProfile> profile = nullptr;
+
+    int                          stopPipeFd[2] = { -1, -1 };  // pipe to signal the capture thread to stop
+    std::shared_ptr<std::thread> captureThread = nullptr;
+    std::atomic<bool>            isCapturing   = { false };
+    std::atomic<std::uint64_t>   loopFrameIndex = { 0 };
+};
+
+class ObV4lGmslDevicePort : public UvcDevicePort {
+public:
+    explicit ObV4lGmslDevicePort(std::shared_ptr<const USBSourcePortInfo> portInfo);
+    ~ObV4lGmslDevicePort() noexcept override;
+
+    StreamProfileList getStreamProfileList() override;
+
+    void startStream(std::shared_ptr<const StreamProfile> profile, MutableFrameCallback callback) override;
+    void stopStream(std::shared_ptr<const StreamProfile> profile) override;
+    void stopAllStream() override;
+
+    uint32_t sendAndReceive(const uint8_t *sendData, uint32_t sendLen, uint8_t *recvData, uint32_t exceptedRecvLen) override;
+
+    bool            getPu(uint32_t propertyId, int32_t &value) override;
+    bool            setPu(uint32_t propertyId, int32_t value) override;
+    UvcControlRange getPuRange(uint32_t propertyId) override;
+
+    virtual std::shared_ptr<const SourcePortInfo>          getSourcePortInfo() const override;
+    static std::vector<std::shared_ptr<V4lDeviceInfoGmsl>> queryRelatedDevices(std::shared_ptr<const USBSourcePortInfo> portInfo);
+    static bool                                            isContainedMetadataDevice(std::shared_ptr<const USBSourcePortInfo> portInfo);
+    static bool                                            isGmslDeviceForPlatformNvidia(std::shared_ptr<const USBSourcePortInfo> portInfo);
+
+    static const std::vector<UsbInterfaceInfo> queryDevicesInfo();
+
+protected:
+    int resetGmslDriver();
+
+private:
+    static void captureLoop(std::shared_ptr<V4lDeviceHandleGmsl> deviceHandle);
+
+    bool setPuRaw(uint32_t propertyId, int32_t value);
+
+    bool sendData(const uint8_t *data, uint32_t dataLen);
+    bool recvData(uint8_t *data, uint32_t *dataLen);
+    bool getXuExt(uint32_t ctrl, uint8_t *data, uint32_t *len);
+    bool setXuExt(uint32_t ctrl, const uint8_t *data, uint32_t len);
+
+    static void handleSpecialResolution(std::shared_ptr<V4lDeviceHandleGmsl> devHandle, const uint8_t *srcData, uint32_t srcSize,
+                                        std::shared_ptr<VideoFrame> videoFrame);
+
+private:
+    std::shared_ptr<const USBSourcePortInfo>          portInfo_ = nullptr;
+    std::vector<std::shared_ptr<V4lDeviceHandleGmsl>> deviceHandles_;
+};
+
+}  // namespace libobsensor
+
diff --git a/src/platform/usb/uvc/ObV4lGmslHostProtocolTypes.hpp b/src/platform/usb/uvc/ObV4lGmslHostProtocolTypes.hpp
new file mode 100644
index 00000000..5b981477
--- /dev/null
+++ b/src/platform/usb/uvc/ObV4lGmslHostProtocolTypes.hpp
@@ -0,0 +1,299 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include <errno.h>
+#include <string.h>
+#include <math.h>
+#include <stdint.h>
+#include <unistd.h>
+
+#include <iostream>
+#include <thread>
+#include <fcntl.h>
+#include <sys/ioctl.h>
+#include <sys/fcntl.h>
+
+#include <linux/uvcvideo.h>
+#include <linux/videodev2.h>
+#include <linux/usb/video.h>
+
+#include "libobsensor/h/ObTypes.h"
+
+#include <mutex>
+#include <condition_variable>
+
+namespace libobsensor {
+//----------------------------------------------------------------------------
+// GMSL MIPI & V4L2 CMD protocol code
+#define DS5_DEPTH_STREAM_DT 0x4000
+#define DS5_CAMERA_CID_BASE (V4L2_CTRL_CLASS_CAMERA | DS5_DEPTH_STREAM_DT)
+
+#define V4L2_EXT_SENSOR_MODE_ID 0x009a4001
+#define V4L2_EXT_TRIG_PIN_ID 0x009a4002
+#define V4L2_EXT_TRIG_MODE_ID 0x009a4002
+
+#define G2R_CAMERA_CID_HWMC_R (DS5_CAMERA_CID_BASE + 9)
+#define G2R_CAMERA_CID_HWMC_W (DS5_CAMERA_CID_BASE + 32)
+#define G2R_CAMERA_CID_SET_DATA (DS5_CAMERA_CID_BASE + 33)
+#define G2R_CAMERA_CID_GET_VERSION_DATA (DS5_CAMERA_CID_BASE + 34)
+#define G2R_CAMERA_CID_GET_IMU_STOCK (DS5_CAMERA_CID_BASE + 35)
+#define G2R_CAMERA_CID_GET_IMU_DATA (DS5_CAMERA_CID_BASE + 36)
+#define G2R_CAMERA_CID_SET_IMU (DS5_CAMERA_CID_BASE + 37)
+#define ORBBEC_CAMERA_CID_GET_IMU_FPS (DS5_CAMERA_CID_BASE + 37)
+
+#define G2R_CAMERA_CID_SET_DATA_LEN (DS5_CAMERA_CID_BASE + 38)
+#define G2R_CAMERA_CID_GET_DATA (DS5_CAMERA_CID_BASE + 39)
+
+#define G2R_CAMERA_CID_SET_GPIO (DS5_CAMERA_CID_BASE + 40)
+#define G2R_CAMERA_CID_RESET_POWER (DS5_CAMERA_CID_BASE + 41)
+#define G2R_CAMERA_CID_GET_PID_SN (DS5_CAMERA_CID_BASE + 42)
+
+#define G2R_SET_IMU_LEN 2
+#define G2R_GET_IMU_DATA_LEN 34
+#define G2R_GET_IMU_STOCK_LEN 14
+
+#define G2R_GET_VERSION_DATA_LEN 172
+#define G2R_RW_DATA_LEN 256
+
+#define G2R_GET_VERSION_CMD_CODE 3
+#define G2R_GET_VERSION_CMD_LEN 8
+
+//-------------------------------------------------------------------------------------------
+// IMU
+#define SENSOR_PROPERTY_GYRO_SWITCH_BOOL 2019
+#define SENSOR_PROPERTY_ACCEL_SWITCH_BOOL 2020
+#define SENSOR_PROPERTY_GYRO_ODR_INT 2021
+#define SENSOR_PROPERTY_ACCEL_ODR_INT 2022
+#define SENSOR_PROPERTY_GYRO_FULL_SCALE_INT 2023
+#define SENSOR_PROPERTY_ACCEL_FULL_SCALE_INT 2024
+
+typedef enum {
+    PROTOCOL_IMU_ODR_1_5625_HZ = 1,
+    PROTOCOL_IMU_ODR_3_125_HZ,
+    PROTOCOL_IMU_ODR_6_25_HZ,
+    PROTOCOL_IMU_ODR_12_5_HZ,
+    PROTOCOL_IMU_ODR_25_HZ,
+    PROTOCOL_IMU_ODR_50_HZ,
+    PROTOCOL_IMU_ODR_100_HZ,
+    PROTOCOL_IMU_ODR_200_HZ,
+    PROTOCOL_IMU_ODR_500_HZ,
+    PROTOCOL_IMU_ODR_1_KHZ,
+    PROTOCOL_IMU_ODR_2_KHZ,
+    PROTOCOL_IMU_ODR_4_KHZ,
+    PROTOCOL_IMU_ODR_8_KHZ,
+    PROTOCOL_IMU_ODR_16_KHZ,
+    PROTOCOL_IMU_ODR_32_KHZ,
+    PROTOCOL_IMU_ODR_MAX,
+} PROTOCOL_IMU_ODR_EM;
+
+typedef enum {
+    PROTOCOL_GYRO_FS_16dps = 1,
+    PROTOCOL_GYRO_FS_31dps,
+    PROTOCOL_GYRO_FS_62dps,
+    PROTOCOL_GYRO_FS_125dps,
+    PROTOCOL_GYRO_FS_250dps,
+    PROTOCOL_GYRO_FS_500dps,
+    PROTOCOL_GYRO_FS_1000dps,
+    PROTOCOL_GYRO_FS_2000dps,
+    PROTOCOL_GYRO_FS_MAX,
+} PROTOCOL_GYRO_FS_EM;
+
+typedef enum {
+    PROTOCOL_ACCEL_FS_2g = 1,
+    PROTOCOL_ACCEL_FS_4g,
+    PROTOCOL_ACCEL_FS_8g,
+    PROTOCOL_ACCEL_FS_16g,
+    PROTOCOL_ACCEL_FS_MAX,
+} PROTOCOL_ACCEL_FS_EM;
+
+typedef struct _imu_origin_data_t {
+    int16_t  group_id;
+    int16_t  accel_x;
+    int16_t  accel_y;
+    int16_t  accel_z;
+    int16_t  gyro_x;
+    int16_t  gyro_y;
+    int16_t  gyro_z;
+    int16_t  temp;
+    uint32_t timestamp[2];
+} imu_origin_data_t;
+//-------------------------------------------------------------------------------------------
+
+//-------------------------------------------------------------------------------------------
+// USB pack protocol
+#define MAX_PACKET_SIZE_GMSL 256 - 6
+
+#pragma pack(push, 1)
+typedef struct {
+    uint16_t magic;
+    uint16_t halfWordSize;  // After removing the header, the remaining data's byte size divided by 2 -> halfwordSize
+    uint16_t opcode;
+    uint16_t nId;
+} ProtocolHeader;
+
+typedef struct {
+    uint16_t res;
+    uint8_t  data[MAX_PACKET_SIZE_GMSL - 2];
+} ProtocolResp;
+
+typedef struct __attribute__((__packed__)) {
+    union {
+        uint8_t      _data[MAX_PACKET_SIZE_GMSL];
+        ProtocolResp resp;
+    } data;
+
+    uint16_t len;
+} ProtocolBuf;
+
+typedef struct __attribute__((__packed__)) {
+    ProtocolHeader header;
+    ProtocolBuf    buf;
+} ProtocolMsg;
+
+#pragma pack(pop)
+
+// static ProtocolMsg request, response;
+//-------------------------------------------------------------------------------------------
+
+struct device_info {
+    uint16_t pid;
+    char     sn[16];
+    char     asic_sn[16];
+};
+
+//----------------------------------------------------
+struct orbbec_device_info {
+    uint16_t vid;
+    uint16_t pid;
+    uint8_t  sn[16];
+    uint8_t  asic_sn[16];
+    uint16_t video_type;
+    uint16_t sub_num;
+    uint32_t cam_num;
+};
+// Enumeration of video_type
+enum orb_mux_pad {
+    ORB_MUX_PAD_EXTERNAL,  // external
+    ORB_MUX_PAD_DEPTH,
+    ORB_MUX_PAD_IR_L,
+    ORB_MUX_PAD_IR_R,
+    ORB_MUX_PAD_RGB,
+    ORB_MUX_PAD_COUNT,
+};
+//----------------------------------------------------
+
+//-------------------------------------------------------------------------------------------
+/*
+static imu_map_t imu_accel_odr_map[] = {
+    {PROTOCOL_IMU_ODR_500_HZ, IMU_ACCEL_ODR_500HZ, 500},
+    //{PROTOCOL_IMU_ODR_1_5625_HZ, IMU_ACCEL_ODR_1HZ5625},
+    //{PROTOCOL_IMU_ODR_3_125_HZ, IMU_ACCEL_ODR_3HZ125},
+    //{PROTOCOL_IMU_ODR_6_25_HZ, IMU_ACCEL_ODR_6HZ25},
+    //{PROTOCOL_IMU_ODR_12_5_HZ, IMU_ACCEL_ODR_12HZ5},
+    //{PROTOCOL_IMU_ODR_25_HZ, IMU_ACCEL_ODR_25HZ},
+    {PROTOCOL_IMU_ODR_50_HZ, IMU_ACCEL_ODR_50HZ, 50},
+    {PROTOCOL_IMU_ODR_100_HZ, IMU_ACCEL_ODR_100HZ, 100},
+    {PROTOCOL_IMU_ODR_200_HZ, IMU_ACCEL_ODR_200HZ, 200},
+    {PROTOCOL_IMU_ODR_1_KHZ, IMU_ACCEL_ODR_1KHZ, 1000},
+    //{PROTOCOL_IMU_ODR_2_KHZ, IMU_ACCEL_ODR_2KHZ},
+    //{PROTOCOL_IMU_ODR_4_KHZ, IMU_ACCEL_ODR_4KHZ},
+    //{PROTOCOL_IMU_ODR_8_KHZ, IMU_ACCEL_ODR_8KHZ},
+    //{PROTOCOL_IMU_ODR_16_KHZ, IMU_ACCEL_ODR_16KHZ},
+    //{PROTOCOL_IMU_ODR_32_KHZ, IMU_ACCEL_ODR_32KHZ},
+};
+
+static imu_map_t imu_gyro_odr_map[] = {
+    {PROTOCOL_IMU_ODR_500_HZ, IMU_GYRO_ODR_500HZ, 500},
+    //{PROTOCOL_IMU_ODR_12_5_HZ, IMU_GYRO_ODR_12HZ5},
+    //{PROTOCOL_IMU_ODR_25_HZ, IMU_GYRO_ODR_25HZ},
+    {PROTOCOL_IMU_ODR_50_HZ, IMU_GYRO_ODR_50HZ, 50},
+    {PROTOCOL_IMU_ODR_100_HZ, IMU_GYRO_ODR_100HZ, 100},
+    {PROTOCOL_IMU_ODR_200_HZ, IMU_GYRO_ODR_200HZ, 200},
+    {PROTOCOL_IMU_ODR_1_KHZ, IMU_GYRO_ODR_1KHZ, 1000},
+    //{PROTOCOL_IMU_ODR_2_KHZ, IMU_GYRO_ODR_2KHZ},
+    //{PROTOCOL_IMU_ODR_4_KHZ, IMU_GYRO_ODR_4KHZ},
+    //{PROTOCOL_IMU_ODR_8_KHZ, IMU_GYRO_ODR_8KHZ},
+    //{PROTOCOL_IMU_ODR_16_KHZ, IMU_GYRO_ODR_16KHZ},
+    //{PROTOCOL_IMU_ODR_32_KHZ, IMU_GYRO_ODR_32KHZ},
+};
+
+static imu_map_t imu_accel_fs_map[] = {
+    //{PROTOCOL_ACCEL_FS_2g, IMU_ACCEL_FS_SEL_2g},
+    {PROTOCOL_ACCEL_FS_4g, IMU_ACCEL_FS_SEL_4g, 4},
+    //{PROTOCOL_ACCEL_FS_8g, IMU_ACCEL_FS_SEL_8g},
+    //{PROTOCOL_ACCEL_FS_16g, IMU_ACCEL_FS_SEL_16g},
+};
+
+static imu_map_t imu_gyro_fs_map[] = {
+    //{PROTOCOL_GYRO_FS_16dps, IMU_GYRO_FS_SEL_15DPS625},
+    //{PROTOCOL_GYRO_FS_31dps, IMU_GYRO_FS_SEL_31DPS25},
+    //{PROTOCOL_GYRO_FS_62dps, IMU_GYRO_FS_SEL_62DPS5},
+    //{PROTOCOL_GYRO_FS_125dps, IMU_GYRO_FS_SEL_125DPS},
+    //{PROTOCOL_GYRO_FS_250dps, IMU_GYRO_FS_SEL_250DPS, 250},
+    //{PROTOCOL_GYRO_FS_500dps, IMU_GYRO_FS_SEL_500DPS},
+    {PROTOCOL_GYRO_FS_1000dps, IMU_GYRO_FS_SEL_1000DPS, 1000},
+    //{PROTOCOL_GYRO_FS_2000dps, IMU_GYRO_FS_SEL_2000DPS},
+};
+*/
+//-------------------------------------------------------------------------------------------
+
+//-------------------------------------------------------------------------------------------
+// GMSL MIPI & firmware I2C protocol
+#define MAX_I2C_PACKET_SIZE 256
+#define MAX_I2C_PACKET_HEADER 6
+#define MAX_I2C_PACKET_SEND_DATA_MAX_SIZE (MAX_I2C_PACKET_SIZE - MAX_I2C_PACKET_HEADER)
+#define MAX_I2C_PACKET_RECV_DATA_MAX_SIZE (MAX_I2C_PACKET_SIZE - MAX_I2C_PACKET_HEADER - 2)
+
+#define CUR_I2C_PACKET_SIZE (256 - 16 - 2 - 2) - 4              // 232 //246 //128 //160 //172 //192 //208 //224 //240 //246 //252  //fw max_read_len is 252
+#define OB_GMSL_FW_I2C_DATA_LEN_CUR_MAX (256 - 16 - 2 - 2) - 4  // 232 //246 //128 //160 //172 //192 //208 //224 //240 //246 //252  //fw max_read_len is 252
+
+struct orbbec_header {
+    uint16_t len;
+    uint16_t code;
+    uint16_t index;
+};
+
+struct orbbec_cmd {
+    struct orbbec_header header;
+    uint8_t              _data[MAX_I2C_PACKET_SIZE];
+};
+
+typedef struct __attribute__((__packed__)) {
+    uint16_t len;
+    uint16_t code;
+    uint16_t index;
+} i2c_msg_header_t;
+
+typedef struct __attribute__((__packed__)) {
+    uint16_t res;
+    uint8_t  data[MAX_I2C_PACKET_RECV_DATA_MAX_SIZE];
+} i2c_msg_body_t;
+
+typedef struct __attribute__((__packed__)) {
+    i2c_msg_header_t header;
+    union {
+        uint8_t        _data[MAX_I2C_PACKET_SEND_DATA_MAX_SIZE];
+        i2c_msg_body_t body;
+    };
+} i2c_msg_t;
+// i2c_msg_t req, resp;
+
+typedef struct __attribute__((__packed__)) {
+    char     firmware_version[16];
+    char     system_version[16];
+    char     sdk_version[16];
+    char     depth_chip[16];
+    char     system_chip[16];
+    char     serial_number[16];
+    uint32_t device_type;
+    char     deviceName[16];
+    char     reseverd[48];
+} VersionInfoTypeDef;
+//-------------------------------------------------------------------------------------------
+
+extern std::mutex mMultiThreadI2CMutex;
+extern int        xioctlGmsl(int fh, unsigned long request, void *arg);
+
+}  // namespace libobsensor
diff --git a/src/platform/usb/uvc/ObV4lUvcDevicePort.cpp b/src/platform/usb/uvc/ObV4lUvcDevicePort.cpp
new file mode 100644
index 00000000..870a13e2
--- /dev/null
+++ b/src/platform/usb/uvc/ObV4lUvcDevicePort.cpp
@@ -0,0 +1,1016 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include <fcntl.h>
+#include <unistd.h>
+#include <limits>
+#include <algorithm>
+#include <dirent.h>
+#include <sys/ioctl.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/sysmacros.h>
+
+#include "ObV4lUvcDevicePort.hpp"
+
+#include "logger/Logger.hpp"
+#include "exception/ObException.hpp"
+#include "utils/Utils.hpp"
+#include "stream/StreamProfile.hpp"
+#include "utils/PublicTypeHelper.hpp"
+#include "frame/FrameFactory.hpp"
+#include "stream/StreamProfileFactory.hpp"
+
+namespace libobsensor {
+
+#define USE_MEMORY_MMAP true
+
+static std::map<uint32_t, uint32_t> v4lFourccMap = {
+    { 0x47524559, 0x59382020 }, /* 'GREY' to 'Y8  ' */
+    { 0x48455643, 0x48323635 }, /* 'HEVC' to 'H265' */
+};
+
+int xioctl(int fh, unsigned long request, void *arg) {
+    int ret   = 0;
+    int retry = 5;
+    do {
+        ret = ioctl(fh, request, arg);
+    } while(ret < 0 && (errno == EINTR || errno == EAGAIN) && retry--);
+    return ret;
+}
+
+v4l2_capability getV4l2DeviceCapabilities(const std::string &dev_name) {
+    // RAII to handle exceptions
+    v4l2_capability cap = {};
+    memset(&cap, 0, sizeof(cap));
+    std::unique_ptr<int, std::function<void(int *)>> fd(new int(open(dev_name.c_str(), O_RDWR | O_NONBLOCK, 0)), [](int *d) {
+        if(d && (*d)) {
+            ::close(*d);
+        }
+        delete d;
+    });
+
+    if(*fd < 0) {
+        LOG_ERROR("getV4l2DeviceCapabilities: Cannot open {}", dev_name);
+        return cap;
+    }
+
+    if(xioctl(*fd, VIDIOC_QUERYCAP, &cap) < 0) {
+        if(errno == EINVAL) {
+            LOG_ERROR("getV4l2DeviceCapabilities {} is no V4L2 device", dev_name);
+        }
+        else {
+            LOG_ERROR("getV4l2DeviceCapabilities  xioctl(VIDIOC_QUERYCAP) failed!");
+        }
+    }
+    return cap;
+}
+
+std::vector<std::shared_ptr<V4lDeviceInfo>> ObV4lUvcDevicePort::queryRelatedDevices(std::shared_ptr<const USBSourcePortInfo> portInfo) {
+    std::vector<std::shared_ptr<V4lDeviceInfo>> devs;
+    DIR                                        *dir = opendir("/sys/class/video4linux");
+    if(!dir) {
+        LOG_DEBUG("Failed to open /sys/class/video4linux, possibly no device connected");
+        return devs;
+    }
+
+    struct dirent *entry;
+    while((entry = readdir(dir))) {
+        std::string name = entry->d_name;
+        if(name == "." || name == ".." || name.find("video") == std::string::npos) {
+            continue;
+        }
+        LOG_DEBUG("Found video4linux: {}", name);
+        std::string path = "/sys/class/video4linux/" + name;
+        std::string realPath{};
+        char        buf[PATH_MAX] = { 0 };
+        if(realpath(path.c_str(), buf)) {
+            realPath = buf;
+            if(realPath.find("virtual") != std::string::npos) {
+                continue;
+            }
+        }
+        try {
+            uint16_t    vid, pid, mi;
+            std::string busNum, devNum, devPath;
+            std::string devname = "/dev/" + name;
+            struct stat st      = {};
+            if(stat(devname.c_str(), &st) < 0) {
+                LOG_DEBUG("Cannot identify {}", devname);
+                continue;
+            }
+
+            if(!S_ISCHR(st.st_mode)) {
+                LOG_DEBUG("{} is no device", devname);
+                continue;
+            }
+
+            // Search directory and up to three parent directories to find busnum/devnum
+            std::ostringstream ss;
+            ss << "/sys/dev/char/" << major(st.st_rdev) << ":" << minor(st.st_rdev) << "/device/";
+            auto             searchPath         = ss.str();
+            auto             validPath          = false;
+            static const int MAX_DEV_PARENT_DIR = 10;
+            for(int i = 0; i < MAX_DEV_PARENT_DIR; i++) {
+                std::ifstream busnum(searchPath + "busnum");
+                std::ifstream devnum(searchPath + "devnum");
+                std::ifstream devpath(searchPath + "devpath");
+                if(busnum.good() && devnum.good() && devpath.good()) {
+                    busnum >> busNum;
+                    devnum >> devNum;
+                    devpath >> devPath;
+                    validPath = true;
+                }
+                busnum.close();
+                devnum.close();
+                devpath.close();
+                if(validPath) {
+                    break;
+                }
+                searchPath += "../";
+            }
+            if(!validPath) {
+                LOG_DEBUG("Cannot find busnum/devnum for {}", devname);
+                continue;
+            }
+            std::string modalias;
+            if(!(std::ifstream("/sys/class/video4linux/" + name + "/device/modalias") >> modalias)) {
+                LOG_DEBUG("Failed to read modalias");
+                continue;
+            }
+            if(modalias.size() < 14 || modalias.substr(0, 5) != "usb:v" || modalias[9] != 'p') {
+                LOG_DEBUG("Not a usb format modalias");
+                continue;
+            }
+            if(!(std::istringstream(modalias.substr(5, 4)) >> std::hex >> vid)) {
+                LOG_DEBUG("Failed to read vendor ID");
+                continue;
+            }
+            if(!(std::istringstream(modalias.substr(10, 4)) >> std::hex >> pid)) {
+                LOG_DEBUG("Failed to read product ID");
+                continue;
+            }
+            if(!(std::ifstream("/sys/class/video4linux/" + name + "/device/bInterfaceNumber") >> std::hex >> mi)) {
+                LOG_DEBUG("Failed to read interface number");
+                continue;
+            }
+            auto url = busNum + "-" + devPath + "-" + devNum;
+            if(portInfo->vid == vid && portInfo->pid == pid && portInfo->infIndex == mi && portInfo->url == url) {
+
+                // Find the USB specification (USB2/3) type from the underlying device
+                // Use device mapping obtained in previous step to traverse node tree
+                // and extract the required descriptors
+                // Traverse from
+                // /sys/devices/pci0000:00/0000:00:xx.0/ABC/M-N/3-6:1.0/video4linux/video0
+                // to
+                // /sys/devices/pci0000:00/0000:00:xx.0/ABC/M-N/version
+                auto info  = std::make_shared<V4lDeviceInfo>();
+                info->name = devname;
+                info->cap  = getV4l2DeviceCapabilities(devname);
+                devs.push_back(info);
+            }
+        }
+        catch(std::exception &e) {
+            LOG_DEBUG("Failed to parse v4l device info: {}", e.what());
+        }
+    }
+    closedir(dir);
+    if(devs.empty()) {
+        LOG_DEBUG("No v4l device found for port: {}", portInfo->infUrl);
+    }
+
+    // sort by video#num, because the metadata device is always found after the video device for the same uvc device
+    std::sort(devs.begin(), devs.end(), [](const std::shared_ptr<V4lDeviceInfo> &a, const std::shared_ptr<V4lDeviceInfo> &b) {
+        int numA = std::stoi(a->name.substr(10));
+        int numB = std::stoi(b->name.substr(10));
+        return numA < numB;
+    });
+    return devs;
+}
+
+bool ObV4lUvcDevicePort::isContainedMetadataDevice(std::shared_ptr<const USBSourcePortInfo> portInfo) {
+    auto devs = queryRelatedDevices(portInfo);
+    for(auto &dev: devs) {
+        if(dev->cap.device_caps & V4L2_CAP_META_CAPTURE) {
+            return true;
+        }
+    }
+    return false;
+}
+
+void foreachProfile(std::vector<std::shared_ptr<V4lDeviceHandle>>                                              deviceHandles,
+                    std::function<bool(std::shared_ptr<V4lDeviceHandle>, std::shared_ptr<VideoStreamProfile>)> func) {
+    bool quit = false;
+    for(auto &devHandle: deviceHandles) {
+        if(quit) {
+            break;
+        }
+        // enum format
+        v4l2_fmtdesc pixel_format = {};
+        pixel_format.type         = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+        while(!quit && xioctl(devHandle->fd, VIDIOC_ENUM_FMT, &pixel_format) == 0) {
+            v4l2_frmsizeenum frame_size = {};
+            frame_size.pixel_format     = pixel_format.pixelformat;
+            uint32_t fourcc             = (const utils::big_endian<int> &)pixel_format.pixelformat;
+
+            if(pixel_format.pixelformat == 0) {
+                // unsupported format fourcc maybe in pixel_format.description
+                LOG_DEBUG("Unrecognizable pixel-format {}", (char *)pixel_format.description);
+                std::string description = std::string((const char *)pixel_format.description);
+                std::size_t index       = description.find('-');
+                if(index == std::string::npos) {
+                    ++pixel_format.index;
+                    continue;
+                }
+                description = description.substr(0, index);
+                // hex string to decimal
+                try {
+                    int descriptionFourcc = std::stoi(description, 0, 16);
+                    fourcc                = (const utils::big_endian<int> &)descriptionFourcc;
+                    LOG_DEBUG("Unrecognizable pixel-format {} with fourcc: {}", (char *)pixel_format.description, fourcc);
+                }
+                catch(std::exception &e) {
+                    LOG_DEBUG("Unrecognizable pixel-format {}: Failed to parse description:{}", (char *)pixel_format.description, e.what());
+                    ++pixel_format.index;
+                    continue;
+                }
+            }
+            else {
+                LOG_DEBUG("Recognized pixel-format {}, pixel_format.pixelformat: 0x{:0x}, fourcc:0x{:0x} ", (char *)pixel_format.description,
+                          pixel_format.pixelformat, fourcc);
+            }
+
+            if(v4lFourccMap.count(fourcc)) {
+                fourcc = v4lFourccMap.at(fourcc);
+            }
+
+            // enum format params
+            while(!quit && xioctl(devHandle->fd, VIDIOC_ENUM_FRAMESIZES, &frame_size) == 0) {
+                v4l2_frmivalenum frame_interval = {};
+                frame_interval.pixel_format     = pixel_format.pixelformat;
+                frame_interval.width            = frame_size.discrete.width;
+                frame_interval.height           = frame_size.discrete.height;
+                while(!quit && xioctl(devHandle->fd, VIDIOC_ENUM_FRAMEINTERVALS, &frame_interval) == 0) {
+                    if(frame_interval.type == V4L2_FRMIVAL_TYPE_DISCRETE) {
+                        if(frame_interval.discrete.numerator != 0) {
+                            auto format = utils::uvcFourccToOBFormat(fourcc);
+                            if(format != OB_FORMAT_UNKNOWN) {
+                                auto width   = frame_size.discrete.width;
+                                auto height  = frame_size.discrete.height;
+                                auto fps     = static_cast<float>(frame_interval.discrete.denominator) / static_cast<float>(frame_interval.discrete.numerator);
+                                auto profile = std::make_shared<VideoStreamProfile>(std::shared_ptr<LazySensor>(), OB_STREAM_VIDEO, format, width, height, fps);
+                                if(fourcc != 0) {
+                                    quit = func(devHandle, profile);
+                                }
+                            }
+                        }
+                    }
+                    ++frame_interval.index;
+                }
+                ++frame_size.index;
+            }
+            ++pixel_format.index;
+        }
+    }
+}
+
+uint32_t CIDFromOBPropertyID(OBPropertyID id) {
+    switch(id) {
+    case OB_PROP_COLOR_BACKLIGHT_COMPENSATION_INT:
+        return V4L2_CID_BACKLIGHT_COMPENSATION;
+    case OB_PROP_COLOR_BRIGHTNESS_INT:
+        return V4L2_CID_BRIGHTNESS;
+    case OB_PROP_COLOR_CONTRAST_INT:
+        return V4L2_CID_CONTRAST;
+    case OB_PROP_COLOR_EXPOSURE_INT:
+        return V4L2_CID_EXPOSURE_ABSOLUTE;
+    case OB_PROP_COLOR_GAIN_INT:
+        return V4L2_CID_GAIN;
+    case OB_PROP_COLOR_GAMMA_INT:
+        return V4L2_CID_GAMMA;
+    case OB_PROP_COLOR_HUE_INT:
+        return V4L2_CID_HUE;
+    case OB_PROP_COLOR_SATURATION_INT:
+        return V4L2_CID_SATURATION;
+    case OB_PROP_COLOR_SHARPNESS_INT:
+        return V4L2_CID_SHARPNESS;
+    case OB_PROP_COLOR_WHITE_BALANCE_INT:
+        return V4L2_CID_WHITE_BALANCE_TEMPERATURE;
+    case OB_PROP_COLOR_AUTO_EXPOSURE_BOOL:
+        return V4L2_CID_EXPOSURE_AUTO;  // Automatic gain/exposure control
+    case OB_PROP_COLOR_AUTO_WHITE_BALANCE_BOOL:
+        return V4L2_CID_AUTO_WHITE_BALANCE;
+    case OB_PROP_COLOR_POWER_LINE_FREQUENCY_INT:
+        return V4L2_CID_POWER_LINE_FREQUENCY;
+    case OB_PROP_COLOR_AUTO_EXPOSURE_PRIORITY_INT:
+        return V4L2_CID_EXPOSURE_AUTO_PRIORITY;
+    case OB_PROP_COLOR_ROLL_INT:
+        return V4L2_CID_ROTATE;
+    case OB_PROP_COLOR_FOCUS_INT:
+        return V4L2_CID_FOCUS_ABSOLUTE;
+    default:
+        std::stringstream ss;
+        ss << "no v4l2 cid for option option" << id;
+        LOG_ERROR(ss.str());
+        return 0;
+    }
+}
+
+std::string fourccToString(uint32_t id) {
+    uint32_t device_fourcc = id;
+    char     fourcc_buff[sizeof(device_fourcc) + 1];
+    std::memcpy(fourcc_buff, &device_fourcc, sizeof(device_fourcc));
+    fourcc_buff[sizeof(device_fourcc)] = 0;
+    return fourcc_buff;
+}
+
+ObV4lUvcDevicePort::ObV4lUvcDevicePort(std::shared_ptr<const USBSourcePortInfo> portInfo) : portInfo_(portInfo) {
+    auto devs = queryRelatedDevices(portInfo_);
+    if(devs.empty()) {
+        throw libobsensor::camera_disconnected_exception("No v4l device found for port: " + portInfo_->infUrl);
+    }
+
+    std::shared_ptr<V4lDeviceHandle> devHandle = nullptr;
+    auto                             iter      = devs.begin();
+    while(iter != devs.end()) {
+        if(((*iter)->cap.device_caps & V4L2_CAP_META_CAPTURE) && devHandle != nullptr) {
+            devHandle->metadataInfo = *iter;
+            auto fd                 = open(devHandle->metadataInfo->name.c_str(), O_RDWR | O_NONBLOCK, 0);
+            if(fd < 0) {
+                LOG_ERROR("Failed to open metadata dev: {}", devHandle->metadataInfo->name);
+                continue;
+            }
+            LOG_DEBUG("Opened metadata dev: {}", devHandle->info->name);
+            devHandle->metadataFd = fd;
+        }
+        else {
+            devHandle             = std::make_shared<V4lDeviceHandle>();
+            devHandle->metadataFd = -1;
+            devHandle->info       = *iter;
+            auto fd               = open(devHandle->info->name.c_str(), O_RDWR | O_NONBLOCK, 0);
+            if(fd < 0) {
+                throw libobsensor::io_exception("Failed to open: " + devHandle->info->name);
+            }
+            devHandle->fd = fd;
+            LOG_DEBUG("Opened: {}", devHandle->info->name);
+            deviceHandles_.push_back(devHandle);
+        }
+        iter++;
+    }
+    if(deviceHandles_.empty()) {
+        throw libobsensor::camera_disconnected_exception("No v4l device found for port: " + portInfo_->infUrl);
+    }
+
+    LOG_DEBUG("V4L device port created for {} with {} v4l2 device", portInfo_->infUrl, deviceHandles_.size());
+}
+
+ObV4lUvcDevicePort::~ObV4lUvcDevicePort() noexcept {
+    try {
+        stopAllStream();
+    }
+    catch(const std::exception &ex) {
+        LOG_ERROR(ex.what());
+    }
+    for(auto &devHandle: deviceHandles_) {
+        if(devHandle->fd >= 0) {
+            close(devHandle->fd);
+        }
+        if(devHandle->metadataFd >= 0) {
+            close(devHandle->metadataFd);
+        }
+        if(devHandle->stopPipeFd[0] >= 0) {
+            close(devHandle->stopPipeFd[0]);
+        }
+        if(devHandle->stopPipeFd[1] >= 0) {
+            close(devHandle->stopPipeFd[1]);
+        }
+        // other resources are created on startStream and should be cleaned up on stopStream/stopAllStream
+    }
+}
+
+void ObV4lUvcDevicePort::captureLoop(std::shared_ptr<V4lDeviceHandle> devHandle) {
+    int metadataBufferIndex = -1;
+    try {
+
+        int max_fd = std::max({ devHandle->fd, devHandle->metadataFd, devHandle->stopPipeFd[0], devHandle->stopPipeFd[1] });
+
+        if(devHandle->metadataFd >= 0) {
+            v4l2_buffer buf = {};
+            buf.type        = LOCAL_V4L2_BUF_TYPE_META_CAPTURE;
+            buf.memory      = V4L2_MEMORY_MMAP;
+            xioctl(devHandle->metadataFd, VIDIOC_QBUF, &buf);
+        }
+
+        if(devHandle->fd >= 0) {
+            v4l2_buffer buf = {};
+            buf.type        = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+            buf.memory      = V4L2_MEMORY_MMAP;
+            xioctl(devHandle->fd, VIDIOC_QBUF, &buf);
+        }
+
+        while(devHandle->isCapturing) {
+            fd_set fds{};
+            FD_ZERO(&fds);
+            if(devHandle->fd >= 0) {
+                FD_SET(devHandle->fd, &fds);
+            }
+            if(devHandle->metadataFd >= 0) {
+                FD_SET(devHandle->metadataFd, &fds);
+            }
+            if(devHandle->stopPipeFd[0] >= 0) {
+                FD_SET(devHandle->stopPipeFd[0], &fds);
+            }
+            if(devHandle->stopPipeFd[1] >= 0) {
+                FD_SET(devHandle->stopPipeFd[1], &fds);
+            }
+            struct timeval remaining = { 0, 500000 };  // 500ms
+            int            val       = select(max_fd + 1, &fds, nullptr, nullptr, &remaining);
+            if(val < 0) {
+                if(errno == EINTR) {
+                    LOG_DEBUG("select interrupted: {}", strerror(errno));
+                }
+                else {
+                    LOG_DEBUG("select failed: {}", strerror(errno));
+                }
+                continue;
+            }
+
+            if(FD_ISSET(devHandle->stopPipeFd[0], &fds) || FD_ISSET(devHandle->stopPipeFd[1], &fds)) {
+                if(!devHandle->isCapturing) {
+                    LOG_DEBUG("V4L stream is closed: {}", devHandle->info->name);
+                }
+                else {
+                    LOG_ERROR("Stop pipe was signalled during streaming: {}", devHandle->info->name);
+                }
+                break;
+            }
+
+            if(devHandle->metadataFd >= 0 && FD_ISSET(devHandle->metadataFd, &fds)) {
+                FD_CLR(devHandle->metadataFd, &fds);
+                v4l2_buffer buf = {};
+                buf.type        = LOCAL_V4L2_BUF_TYPE_META_CAPTURE;
+                buf.memory      = V4L2_MEMORY_MMAP;
+                if(xioctl(devHandle->metadataFd, VIDIOC_DQBUF, &buf) < 0) {
+                    LOG_DEBUG("VIDIOC_DQBUF failed, {}, {}", strerror(errno), devHandle->metadataInfo->name);
+                }
+                if(buf.bytesused) {
+                    devHandle->metadataBuffers[buf.index].actual_length = buf.bytesused;
+                    devHandle->metadataBuffers[buf.index].sequence      = buf.sequence;
+                    metadataBufferIndex                                 = buf.index;
+                }
+
+                if(devHandle->isCapturing) {
+                    xioctl(devHandle->metadataFd, VIDIOC_QBUF, &buf);
+                }
+            }
+
+            if(FD_ISSET(devHandle->fd, &fds)) {
+                FD_CLR(devHandle->fd, &fds);
+                v4l2_buffer buf = {};
+                buf.type        = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+                buf.memory      = V4L2_MEMORY_MMAP;
+                // reader buffer
+                if(xioctl(devHandle->fd, VIDIOC_DQBUF, &buf) < 0) {
+                    LOG_DEBUG("VIDIOC_DQBUF failed, {}, {}", strerror(errno), devHandle->info->name);
+                }
+
+                if(buf.bytesused) {
+                    TRY_EXECUTE({
+                        auto timestamp = (double)buf.timestamp.tv_sec * 1000.f + (double)buf.timestamp.tv_usec / 1000.f;
+                        (void)timestamp;
+
+                        auto rawframe   = FrameFactory::createFrameFromStreamProfile(devHandle->profile);
+                        auto videoFrame = rawframe->as<VideoFrame>();
+                        videoFrame->updateData(static_cast<const uint8_t *>(devHandle->buffers[buf.index].ptr), buf.bytesused);
+                        if(metadataBufferIndex >= 0 && devHandle->metadataBuffers[metadataBufferIndex].sequence == buf.sequence) {
+                            auto uvc_payload_header     = devHandle->metadataBuffers[metadataBufferIndex].ptr + sizeof(V4L2UvcMetaHeader);
+                            auto uvc_payload_header_len = devHandle->metadataBuffers[metadataBufferIndex].actual_length - sizeof(V4L2UvcMetaHeader);
+                            if(uvc_payload_header_len >= sizeof(StandardUvcFramePayloadHeader)) {
+                                auto payloadHeader = (StandardUvcFramePayloadHeader *)uvc_payload_header;
+                                videoFrame->appendMetadata(static_cast<const uint8_t *>(uvc_payload_header), uvc_payload_header_len);
+                                videoFrame->setTimeStampUsec(payloadHeader->dwPresentationTime);
+                            }
+                        }
+
+                        auto realtime = std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::system_clock::now().time_since_epoch()).count();
+                        videoFrame->setSystemTimeStampUsec(realtime);
+                        videoFrame->setNumber(buf.sequence);
+                        devHandle->frameCallback(videoFrame);
+                    })
+                }
+
+                if(devHandle->isCapturing) {
+                    xioctl(devHandle->fd, VIDIOC_QBUF, &buf);
+                }
+            }
+        }
+    }
+    catch(const std::exception &ex) {
+        LOG_ERROR(ex.what());
+    }
+}
+
+StreamProfileList ObV4lUvcDevicePort::getStreamProfileList() {
+    StreamProfileList profileList;
+    foreachProfile(deviceHandles_, [&profileList](std::shared_ptr<V4lDeviceHandle> devHandle, std::shared_ptr<VideoStreamProfile> profile) {
+        (void)devHandle;
+        profileList.push_back(profile);
+        return false;  // false means continue
+    });
+    return profileList;
+}
+
+uint32_t phaseProfileFormatToFourcc(std::shared_ptr<const VideoStreamProfile> profile) {
+    int      formatFourcc    = 0;
+    OBFormat format          = profile->getFormat();
+    auto     foundFormatIter = std::find_if(v4lFourccMap.begin(), v4lFourccMap.end(),
+                                            [&](const std::pair<uint32_t, uint32_t> &item) { return item.second == utils::obFormatToUvcFourcc(format); });
+    if(foundFormatIter != v4lFourccMap.end()) {
+        return (const utils::big_endian<int> &)(foundFormatIter->first);
+    }
+
+    formatFourcc = utils::obFormatToUvcFourcc(format);
+    if(formatFourcc == 0) {
+        LOG_ERROR("unsupported format {}", profile->getFormat());
+        return 0;
+    }
+
+    return (const utils::big_endian<int> &)(formatFourcc);
+}
+
+void ObV4lUvcDevicePort::startStream(std::shared_ptr<const StreamProfile> profile, MutableFrameCallback callback) {
+    std::shared_ptr<V4lDeviceHandle> devHandle    = nullptr;
+    auto                             videoProfile = profile->as<VideoStreamProfile>();
+    foreachProfile(deviceHandles_, [&](std::shared_ptr<V4lDeviceHandle> handle, std::shared_ptr<VideoStreamProfile> prof) {
+        if(prof->getWidth() == videoProfile->getWidth() && prof->getHeight() == videoProfile->getHeight() && prof->getFps() == videoProfile->getFps()
+           && prof->getFormat() == videoProfile->getFormat()) {
+            devHandle = handle;
+            return true;
+        }
+        return false;
+    });
+    if(!devHandle) {
+        throw libobsensor::pal_exception("No v4l device found for profile: width=" + std::to_string(videoProfile->getWidth())
+                                         + ", height=" + std::to_string(videoProfile->getHeight()) + ", fps=" + std::to_string(videoProfile->getFps())
+                                         + ", format=" + std::to_string(videoProfile->getFormat()));
+    }
+    if(devHandle->isCapturing) {
+        throw libobsensor::pal_exception("V4l device is already capturing");
+    }
+
+    if(devHandle->metadataFd >= 0) {
+        v4l2_format fmt = {};
+        fmt.type        = LOCAL_V4L2_BUF_TYPE_META_CAPTURE;
+        if(xioctl(devHandle->metadataFd, VIDIOC_G_FMT, &fmt) < 0) {
+            throw libobsensor::io_exception("Failed to get metadata format! " + devHandle->metadataInfo->name + ", " + strerror(errno));
+        }
+        if(fmt.type != LOCAL_V4L2_BUF_TYPE_META_CAPTURE) {
+            throw libobsensor::io_exception("Invalid metadata type!" + devHandle->metadataInfo->name + ", " + strerror(errno));
+        }
+
+        const std::vector<uint32_t> requires_formats   = { LOCAL_V4L2_META_FMT_D4XX, V4L2_META_FMT_UVC };
+        bool                        set_format_success = false;
+        for(auto required_format: requires_formats) {
+            memcpy(fmt.fmt.raw_data, &required_format, sizeof(required_format));
+            if(xioctl(devHandle->metadataFd, VIDIOC_S_FMT, &fmt) >= 0) {
+                LOG_DEBUG("Set metadata format to {}", fourccToString(required_format));
+                set_format_success = true;
+                break;
+            }
+        }
+        if(!set_format_success) {
+            throw libobsensor::io_exception("Failed to set metadata format!" + devHandle->metadataInfo->name + ", " + strerror(errno));
+        }
+
+        struct v4l2_requestbuffers req = {};
+        req.count                      = MAX_BUFFER_COUNT;
+        req.type                       = LOCAL_V4L2_BUF_TYPE_META_CAPTURE;
+        req.memory                     = V4L2_MEMORY_MMAP;
+        if(xioctl(devHandle->metadataFd, VIDIOC_REQBUFS, &req) < 0) {
+            throw libobsensor::io_exception("Failed to request metadata buffers!" + devHandle->metadataInfo->name + ", " + strerror(errno));
+        }
+        for(uint32_t i = 0; i < req.count && i < MAX_BUFFER_COUNT; i++) {
+            struct v4l2_buffer buf = {};
+            buf.type               = LOCAL_V4L2_BUF_TYPE_META_CAPTURE;
+            buf.memory             = V4L2_MEMORY_MMAP;
+            buf.index              = i;  // only one buffer
+            if(xioctl(devHandle->metadataFd, VIDIOC_QUERYBUF, &buf) < 0) {
+                throw libobsensor::io_exception("Failed to query metadata buffer!" + devHandle->metadataInfo->name + ", " + strerror(errno));
+            }
+            devHandle->metadataBuffers[i].ptr    = (uint8_t *)mmap(NULL, buf.length, PROT_READ | PROT_WRITE, MAP_SHARED, devHandle->metadataFd, buf.m.offset);
+            devHandle->metadataBuffers[i].length = buf.length;
+        }
+
+        v4l2_buf_type bufType = LOCAL_V4L2_BUF_TYPE_META_CAPTURE;
+        if(xioctl(devHandle->metadataFd, VIDIOC_STREAMON, &bufType) < 0) {
+            throw libobsensor::io_exception("Failed to stream on metadata!" + devHandle->metadataInfo->name + ", " + strerror(errno));
+        }
+    }
+
+    v4l2_format fmt         = {};
+    fmt.type                = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+    fmt.fmt.pix.width       = videoProfile->getWidth();
+    fmt.fmt.pix.height      = videoProfile->getHeight();
+    fmt.fmt.pix.field       = V4L2_FIELD_NONE;
+    fmt.fmt.pix.pixelformat = phaseProfileFormatToFourcc(videoProfile);
+    if(xioctl(devHandle->fd, VIDIOC_S_FMT, &fmt) < 0) {
+        throw libobsensor::io_exception("Failed to set format!" + devHandle->info->name + ", " + strerror(errno));
+    }
+    if(xioctl(devHandle->fd, VIDIOC_G_FMT, &fmt) < 0) {
+        throw libobsensor::io_exception("Failed to get format!" + devHandle->info->name + ", " + strerror(errno));
+    }
+    LOG_DEBUG("Video node was successfully configured to {0} format, fd {1}", fourccToString(fmt.fmt.pix.pixelformat), devHandle->fd);
+
+    v4l2_streamparm streamparm                       = {};
+    streamparm.type                                  = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+    streamparm.parm.capture.timeperframe.numerator   = 1;
+    streamparm.parm.capture.timeperframe.denominator = videoProfile->getFps();
+    if(xioctl(devHandle->fd, VIDIOC_S_PARM, &streamparm) < 0) {
+        throw libobsensor::io_exception("Failed to set streamparm!" + devHandle->info->name + ", " + strerror(errno));
+    }
+    if(xioctl(devHandle->fd, VIDIOC_G_PARM, &streamparm) < 0) {
+        throw libobsensor::io_exception("Failed to get streamparm!" + devHandle->info->name + ", " + strerror(errno));
+    }
+
+    struct v4l2_requestbuffers req = {};
+    req.count                      = MAX_BUFFER_COUNT;
+    req.type                       = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+    req.memory                     = V4L2_MEMORY_MMAP;
+    if(xioctl(devHandle->fd, VIDIOC_REQBUFS, &req) < 0) {
+        throw libobsensor::io_exception("Failed to request buffers!" + devHandle->info->name + ", " + strerror(errno));
+    }
+    for(uint32_t i = 0; i < req.count && i < MAX_BUFFER_COUNT; i++) {
+        struct v4l2_buffer buf = {};
+        buf.type               = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+        buf.memory             = V4L2_MEMORY_MMAP;
+        buf.index              = i;
+        if(xioctl(devHandle->fd, VIDIOC_QUERYBUF, &buf) < 0) {
+            throw libobsensor::io_exception("Failed to query buffer!" + devHandle->info->name + ", " + strerror(errno));
+        }
+        devHandle->buffers[i].ptr    = (uint8_t *)mmap(NULL, buf.length, PROT_READ | PROT_WRITE, MAP_SHARED, devHandle->fd, buf.m.offset);
+        devHandle->buffers[i].length = buf.length;
+    }
+
+    v4l2_buf_type bufType = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+    if(xioctl(devHandle->fd, VIDIOC_STREAMON, &bufType) < 0) {
+        throw libobsensor::io_exception("Failed to stream on!" + devHandle->info->name + ", " + strerror(errno));
+    }
+
+    if(pipe(devHandle->stopPipeFd) < 0) {
+        throw libobsensor::io_exception("Failed to create stop pipe!" + devHandle->info->name + ", " + strerror(errno));
+    }
+
+    devHandle->isCapturing   = true;
+    devHandle->profile       = videoProfile;
+    devHandle->frameCallback = callback;
+    devHandle->captureThread = std::make_shared<std::thread>([devHandle]() { captureLoop(devHandle); });
+}
+
+void ObV4lUvcDevicePort::stopStream(std::shared_ptr<const StreamProfile> profile) {
+    if(deviceHandles_.empty()) {
+        return;
+    }
+
+    auto clearUp = [](std::shared_ptr<V4lDeviceHandle> devHandle) {
+        // cleanup
+        for(uint32_t i = 0; i < MAX_BUFFER_COUNT; i++) {
+            if(devHandle->buffers[i].ptr) {
+                munmap(devHandle->buffers[i].ptr, devHandle->buffers[i].length);
+                devHandle->buffers[i].ptr    = nullptr;
+                devHandle->buffers[i].length = 0;
+            }
+            if(devHandle->metadataBuffers[i].ptr) {
+                munmap(devHandle->metadataBuffers[i].ptr, devHandle->metadataBuffers[i].length);
+                devHandle->metadataBuffers[i].ptr    = nullptr;
+                devHandle->metadataBuffers[i].length = 0;
+            }
+        }
+        if(devHandle->stopPipeFd[0] >= 0) {
+            close(devHandle->stopPipeFd[0]);
+            devHandle->stopPipeFd[0] = -1;
+        }
+
+        if(devHandle->stopPipeFd[1] >= 0) {
+            close(devHandle->stopPipeFd[1]);
+            devHandle->stopPipeFd[1] = -1;
+        }
+    };
+    auto videoProfile = profile->as<VideoStreamProfile>();
+    for(auto &devHandle: deviceHandles_) {
+        if(!devHandle->profile || !(*devHandle->profile == *videoProfile) || !devHandle->isCapturing) {
+            continue;
+        }
+
+        devHandle->isCapturing = false;
+        // signal the capture loop to stop
+        char    buff[1] = { 0 };
+        ssize_t ret     = write(devHandle->stopPipeFd[1], buff, 1);
+        if(ret < 0) {
+            clearUp(devHandle);
+            throw libobsensor::io_exception("Failed to write stop pipe " + std::string(strerror(errno)));
+        }
+
+        // wait for the capture loop to stop
+        if(devHandle->captureThread && devHandle->captureThread->joinable()) {
+            devHandle->captureThread->join();
+        }
+        devHandle->captureThread.reset();
+
+        v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+        if(xioctl(devHandle->fd, VIDIOC_STREAMOFF, &type) < 0) {
+            clearUp(devHandle);
+            throw libobsensor::io_exception("Failed to stream off!" + devHandle->info->name + ", " + strerror(errno));
+        }
+
+        clearUp(devHandle);
+
+        struct v4l2_requestbuffers req = {};
+        req.count                      = 0;
+        req.type                       = type;
+        req.memory                     = V4L2_MEMORY_MMAP;
+        if(xioctl(devHandle->fd, VIDIOC_REQBUFS, &req) < 0) {
+            throw libobsensor::io_exception("Failed to request buffers!" + devHandle->info->name + ", " + strerror(errno));
+        }
+
+        if(devHandle->metadataFd >= 0) {
+            type = LOCAL_V4L2_BUF_TYPE_META_CAPTURE;
+            if(xioctl(devHandle->metadataFd, VIDIOC_STREAMOFF, &type) < 0) {
+                throw libobsensor::io_exception("Failed to stream off metadata!" + devHandle->metadataInfo->name + ", " + strerror(errno));
+            }
+            req.count  = 0;
+            req.type   = type;
+            req.memory = V4L2_MEMORY_MMAP;
+            if(xioctl(devHandle->metadataFd, VIDIOC_REQBUFS, &req) < 0) {
+                throw libobsensor::io_exception("Failed to request metadata buffers!" + devHandle->metadataInfo->name + ", " + strerror(errno));
+            }
+        }
+    }
+}
+
+void ObV4lUvcDevicePort::stopAllStream() {
+    for(auto &devHandle: deviceHandles_) {
+        if(devHandle->isCapturing) {
+            BEGIN_TRY_EXECUTE({ stopStream(devHandle->profile); })
+            CATCH_EXCEPTION_AND_EXECUTE({
+                LOG_WARN("Failed to stop stream for {}", devHandle->info->name);
+                devHandle->isCapturing = false;
+                if(devHandle->captureThread && devHandle->captureThread->joinable()) {
+                    devHandle->captureThread->join();
+                }
+                devHandle->captureThread.reset();
+            })
+        }
+    }
+}
+uint32_t ObV4lUvcDevicePort::sendAndReceive(const uint8_t *sendData, uint32_t sendLen, uint8_t *recvData, uint32_t exceptedRecvLen) {
+    std::lock_guard<std::recursive_mutex> lock(ctrlMutex_);
+    uint8_t                               ctrl = OB_VENDOR_XU_CTRL_ID_64;
+
+    auto alignDataLen = sendLen;
+    if(alignDataLen <= 64) {
+        ctrl         = OB_VENDOR_XU_CTRL_ID_64;
+        alignDataLen = 64;
+    }
+    else if(alignDataLen > 512) {
+        ctrl         = OB_VENDOR_XU_CTRL_ID_1024;
+        alignDataLen = 1024;
+    }
+    else {
+        ctrl         = OB_VENDOR_XU_CTRL_ID_512;
+        alignDataLen = 512;
+    }
+
+    if(!setXu(ctrl, sendData, alignDataLen)) {
+        return 0;
+    }
+
+    ctrl = OB_VENDOR_XU_CTRL_ID_512;
+    if(exceptedRecvLen <= 64) {
+        ctrl = OB_VENDOR_XU_CTRL_ID_64;
+    }
+    else if(exceptedRecvLen > 512) {
+        ctrl = OB_VENDOR_XU_CTRL_ID_1024;
+    }
+    else {
+        ctrl = OB_VENDOR_XU_CTRL_ID_512;
+    }
+
+    if(!getXu(ctrl, recvData, &exceptedRecvLen)) {
+        return 0;
+    }
+    return exceptedRecvLen;
+}
+
+bool ObV4lUvcDevicePort::getPu(uint32_t propertyId, int32_t &value) {
+    std::lock_guard<std::recursive_mutex> lock(ctrlMutex_);
+    auto                                  fd      = deviceHandles_.front()->fd;
+    auto                                  cid     = CIDFromOBPropertyID(static_cast<OBPropertyID>(propertyId));
+    struct v4l2_control                   control = { cid, 0 };
+    if(xioctl(fd, VIDIOC_G_CTRL, &control) < 0) {
+        LOG_ERROR("get {0} xioctl(VIDIOC_G_CTRL) failed, {1}", propertyId, strerror(errno));
+        return false;
+    }
+
+    if(OB_PROP_COLOR_AUTO_EXPOSURE_BOOL == propertyId) {
+        control.value = (V4L2_EXPOSURE_MANUAL == control.value) ? 0 : 1;
+    }
+    value = control.value;
+
+    return true;
+}
+
+bool ObV4lUvcDevicePort::setPu(uint32_t propertyId, int32_t value) {
+    std::lock_guard<std::recursive_mutex> lock(ctrlMutex_);
+    auto                                  fd      = deviceHandles_.front()->fd;
+    auto                                  cid     = CIDFromOBPropertyID(static_cast<OBPropertyID>(propertyId));
+    struct v4l2_control                   control = { cid, value };
+    if(OB_PROP_COLOR_AUTO_EXPOSURE_BOOL == propertyId) {
+        control.value = value ? V4L2_EXPOSURE_AUTO : V4L2_EXPOSURE_MANUAL;
+    }
+    // We chose not to protect the subscribe / unsubscribe with mutex due to performance reasons,
+    // we prefer returning on timeout (and let the retry mechanism try again if exist) than blocking the main thread on every set command
+
+    // RAII to handle unsubscribe in case of exceptions
+    std::unique_ptr<uint32_t, std::function<void(uint32_t *)>> unsubscriber(new uint32_t(control.id), [this](const uint32_t *id) {
+        if(id) {
+            // `unsubscribe_from_ctrl_event()` may throw so we first release the memory allocated and than call it.
+            auto local_id = *id;
+            delete id;
+            unsubscribeFromCtrlEvent(local_id);
+        }
+    });
+    subscribeToCtrlEvent(control.id);
+    // Set value
+    if(xioctl(fd, VIDIOC_S_CTRL, &control) < 0) {
+        LOG_ERROR("set {0} xioctl(VIDIOC_S_CTRL) failed, {1}", propertyId, strerror(errno));
+        return false;
+    }
+
+    if(!pendForCtrlStatusEvent()) {
+        return false;
+    }
+    return true;
+}
+
+UvcControlRange ObV4lUvcDevicePort::getXuRange(uint8_t control, int len) {
+    std::lock_guard<std::recursive_mutex> lock(ctrlMutex_);
+    auto                                  fd = deviceHandles_.front()->fd;
+    UvcControlRange                       range;
+    struct uvc_xu_control_query           xquery {};
+    memset(&xquery, 0, sizeof(xquery));
+    __u16 size   = 0;
+    xquery.query = UVC_GET_LEN;
+    xquery.size  = 2;  // size seems to always be 2 for the LEN query, but
+                       // doesn't seem to be documented. Use result for size
+    // in all future queries of the same control number
+    xquery.selector = control;
+    xquery.unit     = xuUnit_.unit;
+    xquery.data     = (__u8 *)&size;
+    if(xioctl(fd, UVCIOC_CTRL_QUERY, &xquery) < 0) {
+        LOG_ERROR("xioctl(VIDIOC_QUERY_EXT_CTRL) failed!");
+    }
+    VALIDATE(size <= len);
+    std::vector<uint8_t> buf;
+    auto                 buf_size = std::max((size_t)len, sizeof(__u32));
+    buf.resize(buf_size);
+
+    xquery.query    = UVC_GET_MIN;
+    xquery.size     = size;
+    xquery.selector = control;
+    xquery.unit     = xuUnit_.unit;
+    xquery.data     = buf.data();
+    if(-1 == xioctl(fd, UVCIOC_CTRL_QUERY, &xquery)) {
+        LOG_ERROR("xioctl(UVC_GET_MIN) failed!");
+    }
+    range.min.resize(buf_size);
+    std::copy(buf.begin(), buf.end(), range.min.begin());
+
+    xquery.query    = UVC_GET_MAX;
+    xquery.size     = size;
+    xquery.selector = control;
+    xquery.unit     = xuUnit_.unit;
+    xquery.data     = buf.data();
+    if(-1 == xioctl(fd, UVCIOC_CTRL_QUERY, &xquery)) {
+        LOG_ERROR("xioctl(UVC_GET_MAX) failed!");
+    }
+    range.max.resize(buf_size);
+    std::copy(buf.begin(), buf.end(), range.max.begin());
+
+    xquery.query    = UVC_GET_DEF;
+    xquery.size     = size;
+    xquery.selector = control;
+    xquery.unit     = xuUnit_.unit;
+    xquery.data     = buf.data();
+    if(-1 == xioctl(fd, UVCIOC_CTRL_QUERY, &xquery)) {
+        LOG_ERROR("xioctl(UVC_GET_DEF) failed!");
+    }
+    // def means default
+    range.def.resize(buf_size);
+    std::copy(buf.begin(), buf.end(), range.def.begin());
+
+    xquery.query    = UVC_GET_RES;
+    xquery.size     = size;
+    xquery.selector = control;
+    xquery.unit     = xuUnit_.unit;
+    xquery.data     = buf.data();
+    if(-1 == xioctl(fd, UVCIOC_CTRL_QUERY, &xquery)) {
+        LOG_ERROR("xioctl(UVC_GET_CUR) failed!");
+    }
+    range.step.resize(buf_size);
+    std::copy(buf.begin(), buf.end(), range.step.begin());
+
+    return range;
+}
+
+UvcControlRange ObV4lUvcDevicePort::getPuRange(uint32_t propertyId) {
+    std::lock_guard<std::recursive_mutex> lock(ctrlMutex_);
+    auto                                  fd = deviceHandles_.front()->fd;
+    if(propertyId == OB_PROP_COLOR_AUTO_EXPOSURE_PRIORITY_INT || propertyId == OB_PROP_COLOR_AUTO_EXPOSURE_BOOL
+       || propertyId == OB_PROP_COLOR_AUTO_WHITE_BALANCE_BOOL) {
+        int             min        = 0;
+        int             max        = 1;
+        int             step       = 1;
+        int             defaultVal = 0;
+        UvcControlRange range(min, max, step, defaultVal);
+        return range;
+    }
+    struct v4l2_queryctrl query = {};
+    query.id                    = CIDFromOBPropertyID(static_cast<OBPropertyID>(propertyId));
+    VALIDATE_GE(fd, 0);
+    if(xioctl(fd, VIDIOC_QUERYCTRL, &query) < 0) {
+        query.minimum = query.maximum = 0;
+    }
+    UvcControlRange range(query.minimum, query.maximum, query.step, query.default_value);
+    return range;
+}
+
+std::shared_ptr<const SourcePortInfo> ObV4lUvcDevicePort::getSourcePortInfo() const {
+    return portInfo_;
+}
+
+bool ObV4lUvcDevicePort::getXu(uint8_t ctrl, uint8_t *data, uint32_t *len) {
+    std::lock_guard<std::recursive_mutex> lock(ctrlMutex_);
+    VALIDATE_NOT_NULL(data);
+    VALIDATE_NOT_NULL(len);
+    auto fd = deviceHandles_.front()->fd;
+    memset(data, 0, *len);
+    struct uvc_xu_control_query query = { static_cast<uint8_t>(xuUnit_.unit), ctrl, UVC_GET_CUR, static_cast<uint16_t>(*len), const_cast<uint8_t *>(data) };
+    if(xioctl(fd, UVCIOC_CTRL_QUERY, &query) < 0) {
+        LOG_ERROR("get xu failed, errno: {}", strerror(errno));
+        return false;
+    }
+
+    return true;
+}
+
+bool ObV4lUvcDevicePort::setXu(uint8_t ctrl, const uint8_t *data, uint32_t len) {
+    std::lock_guard<std::recursive_mutex> lock(ctrlMutex_);
+    VALIDATE_NOT_NULL(data);
+    auto                        fd    = deviceHandles_.front()->fd;
+    struct uvc_xu_control_query query = { static_cast<uint8_t>(xuUnit_.unit), ctrl, UVC_SET_CUR, static_cast<uint16_t>(len), const_cast<uint8_t *>(data) };
+    if(xioctl(fd, UVCIOC_CTRL_QUERY, &query) < 0) {
+        LOG_ERROR("set xu failed, errno: {}", strerror(errno));
+        return false;
+    }
+    return true;
+}
+
+void ObV4lUvcDevicePort::subscribeToCtrlEvent(uint32_t ctrl_id) const {
+    auto                           fd = deviceHandles_.front()->fd;
+    struct v4l2_event_subscription event_subscription {};
+    event_subscription.flags = V4L2_EVENT_SUB_FL_ALLOW_FEEDBACK;
+    event_subscription.type  = V4L2_EVENT_CTRL;
+    event_subscription.id    = ctrl_id;
+    memset(event_subscription.reserved, 0, sizeof(event_subscription.reserved));
+    if(xioctl(fd, VIDIOC_SUBSCRIBE_EVENT, &event_subscription) < 0) {
+        LOG_ERROR("xioctl(VIDIOC_SUBSCRIBE_EVENT) with control_id={} failed!", ctrl_id);
+    }
+}
+
+void ObV4lUvcDevicePort::unsubscribeFromCtrlEvent(uint32_t ctrl_id) const {
+    auto                           fd = deviceHandles_.front()->fd;
+    struct v4l2_event_subscription event_subscription {};
+    event_subscription.flags = V4L2_EVENT_SUB_FL_ALLOW_FEEDBACK;
+    event_subscription.type  = V4L2_EVENT_CTRL;
+    event_subscription.id    = ctrl_id;
+    memset(event_subscription.reserved, 0, sizeof(event_subscription.reserved));
+    if(xioctl(fd, VIDIOC_UNSUBSCRIBE_EVENT, &event_subscription) < 0) {
+        LOG_ERROR("xioctl(VIDIOC_UNSUBSCRIBE_EVENT) with control_id={} failed!", ctrl_id);
+    }
+}
+
+bool ObV4lUvcDevicePort::pendForCtrlStatusEvent() const {
+    auto              fd = deviceHandles_.front()->fd;
+    struct v4l2_event event {};
+    memset(&event, 0, sizeof(event));
+    // Poll registered events and verify that set control event raised (wait max of 10 * 2 = 20 [ms])
+    static int MAX_POLL_RETRIES = 10;
+    for(int i = 0; i < MAX_POLL_RETRIES && event.type != V4L2_EVENT_CTRL; i++) {
+        if(xioctl(fd, VIDIOC_DQEVENT, &event) < 0) {
+            std::this_thread::sleep_for(std::chrono::milliseconds(2));
+        }
+    }
+    return event.type == V4L2_EVENT_CTRL;
+}
+
+}  // namespace libobsensor
diff --git a/src/platform/usb/uvc/ObV4lUvcDevicePort.hpp b/src/platform/usb/uvc/ObV4lUvcDevicePort.hpp
new file mode 100644
index 00000000..4ca4b79b
--- /dev/null
+++ b/src/platform/usb/uvc/ObV4lUvcDevicePort.hpp
@@ -0,0 +1,121 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include <array>
+#include <string>
+#include <thread>
+#include <mutex>
+#include <sys/mman.h>
+
+#include "UvcDevicePort.hpp"
+#include "stream/StreamProfile.hpp"
+
+#include <linux/uvcvideo.h>
+#include <linux/videodev2.h>
+#include <linux/usb/video.h>
+
+#ifdef V4L2_META_FMT_UVC
+constexpr bool metadata_node = true;
+#else
+
+constexpr bool metadata_node = false;
+
+// Providing missing parts from videodev2.h
+// V4L2_META_FMT_UVC >> V4L2_CAP_META_CAPTURE is also defined, but the opposite does not hold
+#define V4L2_META_FMT_UVC v4l2_fourcc('U', 'V', 'C', 'H') /* UVC Payload Header */
+
+#ifndef V4L2_CAP_META_CAPTURE
+#define V4L2_CAP_META_CAPTURE 0x00800000 /* Specified in kernel header v4.16 */
+#endif                                   // V4L2_CAP_META_CAPTURE
+
+#endif  // V4L2_META_FMT_UVC
+
+namespace libobsensor {
+
+static const uint32_t MAX_META_DATA_SIZE       = 255;
+static const uint32_t MAX_BUFFER_COUNT         = 4;
+static const uint32_t LOCAL_V4L2_META_FMT_D4XX = v4l2_fourcc('D', '4', 'X', 'X');  // borrows from videodev2.h, using for getting extention metadata
+#define LOCAL_V4L2_BUF_TYPE_META_CAPTURE ((v4l2_buf_type)13)
+
+#pragma pack(push, 1)
+struct V4L2UvcMetaHeader {
+    uint64_t ns;   // system timestamp of the payload in nanoseconds
+    uint16_t sof;  // USB Frame Number
+    // the rest of the meta buffer is the UVC Payload Header
+};
+#pragma pack(pop)
+
+struct V4L2FrameBuffer {
+    ~V4L2FrameBuffer() {
+        if(ptr != nullptr) {
+            munmap(ptr, length);
+            ptr = nullptr;
+        }
+    }
+    uint32_t length        = 0;
+    uint32_t actual_length = 0;
+    uint32_t sequence      = 0;
+    uint8_t *ptr           = nullptr;
+};
+
+struct V4lDeviceInfo {
+    std::string     name;
+    v4l2_capability cap;  // capabilities
+};
+
+struct V4lDeviceHandle {
+    std::shared_ptr<V4lDeviceInfo>                info;
+    int                                           fd = -1;
+    std::array<V4L2FrameBuffer, MAX_BUFFER_COUNT> buffers;
+
+    std::shared_ptr<V4lDeviceInfo>                metadataInfo;
+    int                                           metadataFd = -1;
+    std::array<V4L2FrameBuffer, MAX_BUFFER_COUNT> metadataBuffers;
+
+    MutableFrameCallback                      frameCallback;
+    std::shared_ptr<const VideoStreamProfile> profile = nullptr;
+
+    int                          stopPipeFd[2] = { -1, -1 };  // pipe to signal the capture thread to stop
+    std::shared_ptr<std::thread> captureThread = nullptr;
+    std::atomic<bool>            isCapturing   = { false };
+};
+
+class ObV4lUvcDevicePort : public UvcDevicePort {
+public:
+    explicit ObV4lUvcDevicePort(std::shared_ptr<const USBSourcePortInfo> portInfo);
+    ~ObV4lUvcDevicePort() noexcept override;
+
+    virtual std::shared_ptr<const SourcePortInfo> getSourcePortInfo() const override;
+
+    StreamProfileList getStreamProfileList() override;
+
+    void startStream(std::shared_ptr<const StreamProfile> profile, MutableFrameCallback callback) override;
+    void stopStream(std::shared_ptr<const StreamProfile> profile) override;
+    void stopAllStream() override;
+
+    bool            getPu(uint32_t propertyId, int32_t &value) override;
+    bool            setPu(uint32_t propertyId, int32_t value) override;
+    UvcControlRange getPuRange(uint32_t propertyId) override;
+    uint32_t        sendAndReceive(const uint8_t *sendData, uint32_t sendLen, uint8_t *recvData, uint32_t exceptedRecvLen) override;
+
+    static std::vector<std::shared_ptr<V4lDeviceInfo>> queryRelatedDevices(std::shared_ptr<const USBSourcePortInfo> portInfo);
+    static bool                                        isContainedMetadataDevice(std::shared_ptr<const USBSourcePortInfo> portInfo);
+
+private:
+    static void     captureLoop(std::shared_ptr<V4lDeviceHandle> deviceHandle);
+    bool            getXu(uint8_t ctrl, uint8_t *data, uint32_t *len);
+    bool            setXu(uint8_t ctrl, const uint8_t *data, uint32_t len);
+    UvcControlRange getXuRange(uint8_t control, int len);
+    bool            pendForCtrlStatusEvent() const;
+    void            subscribeToCtrlEvent(uint32_t ctrl_id) const;
+    void            unsubscribeFromCtrlEvent(uint32_t ctrl_id) const;
+
+private:
+    std::shared_ptr<const USBSourcePortInfo>      portInfo_ = nullptr;
+    std::vector<std::shared_ptr<V4lDeviceHandle>> deviceHandles_;
+    std::recursive_mutex                          ctrlMutex_;
+};
+
+}  // namespace libobsensor
+
diff --git a/src/platform/usb/uvc/UvcDevicePort.hpp b/src/platform/usb/uvc/UvcDevicePort.hpp
new file mode 100644
index 00000000..9fff53d4
--- /dev/null
+++ b/src/platform/usb/uvc/UvcDevicePort.hpp
@@ -0,0 +1,64 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include "ISourcePort.hpp"
+#include "UvcTypes.hpp"
+#include "usb/enumerator/UsbTypes.hpp"
+#include "libobsensor/h/Property.h"
+
+namespace libobsensor {
+
+#undef min
+#undef max
+struct UvcControlRange {
+    UvcControlRange() {}
+
+    UvcControlRange(int32_t in_min, int32_t in_max, int32_t in_step, int32_t in_def) {
+        populate_raw_data(min, in_min);
+        populate_raw_data(max, in_max);
+        populate_raw_data(step, in_step);
+        populate_raw_data(def, in_def);
+    }
+    UvcControlRange(std::vector<uint8_t> in_min, std::vector<uint8_t> in_max, std::vector<uint8_t> in_step, std::vector<uint8_t> in_def) {
+        min  = in_min;
+        max  = in_max;
+        step = in_step;
+        def  = in_def;
+    }
+    std::vector<uint8_t> min;
+    std::vector<uint8_t> max;
+    std::vector<uint8_t> step;
+    std::vector<uint8_t> def;
+
+private:
+    static void populate_raw_data(std::vector<uint8_t> &vec, int32_t value) {
+        vec.resize(sizeof(value));
+        auto data = reinterpret_cast<const uint8_t *>(&value);
+        std::copy(data, data + sizeof(value), vec.data());
+    }
+};
+
+class UvcDevicePort : public IVideoStreamPort, public IVendorDataPort {
+public:
+    virtual bool         getPu(uint32_t propertyId, int32_t &value) = 0;
+    virtual bool         setPu(uint32_t propertyId, int32_t value)  = 0;
+    virtual UvcControlRange getPuRange(uint32_t propertyId)            = 0;
+
+    ~UvcDevicePort() noexcept override = default;
+
+    virtual void updateXuUnit(const ObExtensionUnit &xuUnit) {
+        xuUnit_ = xuUnit;
+    };
+
+#ifdef __ANDROID__
+    virtual std::string getUsbConnectType() = 0;
+#endif
+
+protected:
+    ObExtensionUnit xuUnit_ = OB_COMMON_XU_UNIT;
+};
+
+}  // namespace libobsensor
+
diff --git a/src/platform/usb/uvc/UvcTypes.hpp b/src/platform/usb/uvc/UvcTypes.hpp
new file mode 100644
index 00000000..399d22b8
--- /dev/null
+++ b/src/platform/usb/uvc/UvcTypes.hpp
@@ -0,0 +1,75 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include <map>
+#include <vector>
+#include <functional>
+
+#if !defined(WIN32) && defined(BUILD_USB_PAL)
+#include <libuvc/libuvc.h>
+#endif
+namespace libobsensor {
+
+#define LIBUVC_NUM_TRANSFER_LOW_FRAME_BUFS 20
+#define LIBUVC_TRANSFER_LOW_FRAME_SIZE 10
+
+#define LIBUVC_XFER_BUF_SIZE (16 * 1024 * 1024)
+#define LIBUVC_XFER_META_BUF_SIZE (4 * 1024)
+
+#pragma pack(push, 1)
+struct StandardUvcFramePayloadHeader {
+    uint8_t  bHeaderLength;
+    uint8_t  bmHeaderInfo;
+    uint32_t dwPresentationTime;
+    uint8_t  scrSourceClock[6];
+};
+
+struct UvcMetadata {
+    StandardUvcFramePayloadHeader header;
+    uint8_t                       metadata[1];
+};
+
+#pragma pack(pop)
+#define UVC_PAYLOAD_HEADER_SRC_LENGTH (6)
+#define UVC_PAYLOAD_HEADER_SRC_OFFSET (6)
+
+template <typename T> T as(const std::vector<uint8_t> &data, size_t index) {
+    T rv = 0;
+    for(int i = 0; i < sizeof(T); i++) {
+        rv += data[index + i] << (i * 8);
+    }
+    return rv;
+}
+
+#define XU_MAX_DATA_LENGTH 1024
+typedef enum {
+    OB_VENDOR_XU_CTRL_ID_512  = 1,
+    OB_VENDOR_XU_CTRL_ID_64   = 2,
+    OB_VENDOR_XU_CTRL_ID_1024 = 3,
+} ObVendorXuCtrlId;
+
+struct Guid {
+    uint32_t data1;
+    uint16_t data2, data3;
+    uint8_t  data4[8];
+};
+
+// subdevice and node fields are assigned by Host driver; unit and GUID are
+// hard-coded in camera firmware
+struct ObExtensionUnit {
+    // int     subdevice;
+    uint8_t unit;
+    // int     node;
+    Guid id;
+};
+const ObExtensionUnit OB_COMMON_XU_UNIT = { 4, { 0xA55751A1, 0xF3C5, 0x4A5E, { 0x8D, 0x5A, 0x68, 0x54, 0xB8, 0xFA, 0x27, 0x16 } } };
+const ObExtensionUnit OB_G330_XU_UNIT    = { 3, { 0xC9606CCB, 0x594C, 0x4D25, { 0xaf, 0x47, 0xcc, 0xc4, 0x96, 0x43, 0x59, 0x95 } } };
+// RGB - Sonix (Jarvis)
+// const ObExtensionUnit OB_COMMON_VENDOR_XU = { 3, { 0x28F03370, 0x6311, 0x4A2E, { 0xBA, 0x2C, 0x68, 0x90, 0xEB, 0x33, 0x40, 0x16 } } };
+
+enum PowerState { kD0, kD3 };
+
+}  // namespace libobsensor
+
diff --git a/src/platform/usb/uvc/WinHelpers.cpp b/src/platform/usb/uvc/WinHelpers.cpp
new file mode 100644
index 00000000..29ce46de
--- /dev/null
+++ b/src/platform/usb/uvc/WinHelpers.cpp
@@ -0,0 +1,761 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#if(_MSC_FULL_VER < 180031101)
+#error At least Visual Studio 2013 Update 4 is required to compile this backend
+#endif
+
+#include "WinHelpers.hpp"
+
+#include "exception/ObException.hpp"
+#include "logger/Logger.hpp"
+#include "utils/Utils.hpp"
+
+#include <Cfgmgr32.h>
+#include <Sddl.h>
+#include <SetupAPI.h>
+#include <Windows.h>
+#include <atlstr.h>
+#include <comdef.h>
+#include <regex>
+#include <string>
+#include <algorithm>
+#include <usbioctl.h>
+#include <winioctl.h>
+
+#pragma comment(lib, "cfgmgr32.lib")
+#pragma comment(lib, "setupapi.lib")
+
+#include <initguid.h>
+
+// https://docs.microsoft.com/en-us/windows-hardware/drivers/usbcon/supported-usb-classes#microsoft-provided-usb-device-class-drivers
+
+DEFINE_GUID(GUID_DEVINTERFACE_IMAGE_WIN10, 0x6bdd1fc6L, 0x810f, 0x11d0, 0xbe, 0xc7, 0x08, 0x00, 0x2b, 0xe2, 0x09, 0x2f);
+DEFINE_GUID(GUID_DEVINTERFACE_CAMERA_WIN10, 0xca3e7ab9, 0xb4c3, 0x4ae6, 0x82, 0x51, 0x57, 0x9e, 0xf9, 0x33, 0x89, 0x0f);
+
+#define CREATE_MUTEX_RETRY_NUM (5)
+
+namespace libobsensor {
+
+template <typename T> size_t vector_bytes_size(const typename std::vector<T> &vec) {
+    static_assert((std::is_arithmetic<T>::value), "vector_bytes_size requires numeric type for input data");
+    return sizeof(T) * vec.size();
+}
+
+std::string wcharToString(const wchar_t *wText) {
+    DWORD dwNum = WideCharToMultiByte(CP_UTF8, NULL, wText, -1, nullptr, 0, nullptr, FALSE);  // Application of WideCharToMultiByte
+    char *psText;  // psText is a temporary char* array used as an intermediate variable for assignment to std::string
+    psText = new char[dwNum];
+    WideCharToMultiByte(CP_UTF8, NULL, wText, -1, psText, dwNum, NULL, FALSE);  // Reuse of WideCharToMultiByte
+    std::string szDst = psText;                                                 // std::string assignment
+    delete[] psText;                                                            // Clearing psText
+    return szDst;
+}
+
+std::string hr_to_string(HRESULT hr) {
+    _com_error        err(hr);
+    std::wstring      errorMessage = (err.ErrorMessage()) ? err.ErrorMessage() : L"";
+    std::stringstream ss;
+    ss << "HResult 0x" << std::hex << hr << ": \"" << wcharToString(errorMessage.c_str()) << "\"";
+    return ss.str();
+}
+
+typedef ULONG(__stdcall *fnRtlGetVersion)(PRTL_OSVERSIONINFOW lpVersionInformation);
+
+bool is_win10_redstone2() {
+    RTL_OSVERSIONINFOEXW verInfo = { 0 };
+    verInfo.dwOSVersionInfoSize  = sizeof(verInfo);
+    static auto RtlGetVersion    = reinterpret_cast<fnRtlGetVersion>(GetProcAddress(GetModuleHandleW(L"ntdll.dll"), "RtlGetVersion"));
+    if(RtlGetVersion != nullptr && RtlGetVersion(reinterpret_cast<PRTL_OSVERSIONINFOW>(&verInfo)) == 0) {
+        return verInfo.dwMajorVersion >= 0x0A && verInfo.dwBuildNumber >= 15063;
+    }
+    else
+        return false;
+}
+
+bool check(const char *call, HRESULT hr, bool to_throw) {
+    if(SUCCEEDED(hr)) {
+        return true;
+    }
+
+    std::string descr = utils::string::to_string() << call << " returned: " << hr_to_string(hr);
+    if(to_throw) {
+        LOG_ERROR(descr);
+        throw pal_exception(descr);
+    }
+    LOG_DEBUG(descr);
+    return false;
+}
+
+std::string win_to_utf(const WCHAR *s) {
+    auto len = WideCharToMultiByte(CP_UTF8, 0, s, -1, nullptr, 0, nullptr, nullptr);
+    if(len == 0)
+        throw std::runtime_error(utils::string::to_string() << "WideCharToMultiByte(...) returned 0 and GetLastError() is " << GetLastError());
+
+    std::string buffer(len - 1, ' ');
+    len = WideCharToMultiByte(CP_UTF8, 0, s, -1, &buffer[0], static_cast<int>(buffer.size()) + 1, nullptr, nullptr);
+    if(len == 0)
+        throw std::runtime_error(utils::string::to_string() << "WideCharToMultiByte(...) returned 0 and GetLastError() is " << GetLastError());
+
+    return buffer;
+}
+
+std::vector<std::string> tokenize(std::string string, char separator) {
+    std::vector<std::string> tokens;
+    std::string::size_type   i1 = 0;
+    while(true) {
+        auto i2 = string.find(separator, i1);
+        if(i2 == std::string::npos) {
+            tokens.push_back(string.substr(i1));
+            return tokens;
+        }
+        tokens.push_back(string.substr(i1, i2 - i1));
+        i1 = i2 + 1;
+    }
+}
+
+// Parse the following USB path format = \?usb#vid_vvvv&pid_pppp&mi_ii#aaaaaaaaaaaaaaaa#{gggggggg-gggg-gggg-gggg-gggggggggggg}
+// vvvv = USB vendor ID represented in 4 hexadecimal characters.
+// pppp = USB product ID represented in 4 hexadecimal characters.
+// ii = USB interface number.
+// aaaaaaaaaaaaaaaa = unique Windows-generated string based on things such as the physical USB port address and/or interface number.
+// gggggggg-gggg-gggg-gggg-gggggggggggg = device interface GUID assigned in the driver or driver INF file and is used to link applications to device with
+// specific drivers loaded.
+bool parse_usb_path_multiple_interface(uint16_t &vid, uint16_t &pid, uint16_t &mi, std::string &unique_id, const std::string &path, std::string &device_guid) {
+    auto name   = utils::string::toLower(path);
+    auto tokens = tokenize(name, '#');
+    if(tokens.size() < 1 || (tokens[0] != R"(\\?\usb)" && tokens[0] != R"(\\?\hid)"))
+        return false;  // Not a USB device
+    if(tokens.size() < 3) {
+        LOG_ERROR("malformed usb device path: {}", name);
+        return false;
+    }
+
+    auto ids = tokenize(tokens[1], '&');
+    if(ids[0].size() != 8 || ids[0].substr(0, 4) != "vid_" || !(std::istringstream(ids[0].substr(4, 4)) >> std::hex >> vid)) {
+        LOG_ERROR("malformed vid string: {}", tokens[1]);
+        return false;
+    }
+
+    if(ids[1].size() != 8 || ids[1].substr(0, 4) != "pid_" || !(std::istringstream(ids[1].substr(4, 4)) >> std::hex >> pid)) {
+        LOG_ERROR("malformed pid string: {}", tokens[1]);
+        return false;
+    }
+
+    if(ids.size() > 2 && (ids[2].size() != 5 || ids[2].substr(0, 3) != "mi_" || !(std::istringstream(ids[2].substr(3, 2)) >> mi))) {
+        LOG_ERROR("malformed mi string {}", tokens[1]);
+        return false;
+    }
+
+    ids = tokenize(tokens[2], '&');
+    if(ids.size() == 0) {
+        LOG_ERROR("malformed id string: {}", tokens[2]);
+        return false;
+    }
+
+    if(ids.size() > 2)
+        unique_id = ids[1];
+    else
+        unique_id = "";
+
+    if(tokens.size() >= 3)
+        device_guid = tokens[3];
+
+    return true;
+}
+
+// Parse the following USB path format = \?usb#vid_vvvv&pid_pppp#ssss#{gggggggg-gggg-gggg-gggg-gggggggggggg}
+// vvvv = USB vendor ID represented in 4 hexadecimal characters.
+// pppp = USB product ID represented in 4 hexadecimal characters.
+// ssss = USB serial string represented in n characters.
+// gggggggg-gggg-gggg-gggg-gggggggggggg = device interface GUID assigned in the driver or driver INF file and is used to link applications to device with
+// specific drivers loaded.
+bool parse_usb_path_single_interface(uint16_t &vid, uint16_t &pid, std::string &serial, const std::string &path) {
+    auto name   = utils::string::toLower(path);
+    auto tokens = tokenize(name, '#');
+    if(tokens.empty() || (tokens[0] != R"(\\?\usb)" && tokens[0] != R"(\\?\hid)"))
+        return false;  // Not a USB device
+    if(tokens.size() < 3) {
+        LOG_ERROR("malformed usb device path: {}", name);
+        return false;
+    }
+
+    auto ids = tokenize(tokens[1], '&');
+    if(ids[0].size() != 8 || ids[0].substr(0, 4) != "vid_" || !(std::istringstream(ids[0].substr(4, 4)) >> std::hex >> vid)) {
+        LOG_ERROR("malformed vid string: {}", tokens[1]);
+        return false;
+    }
+
+    if(ids[1].size() != 8 || ids[1].substr(0, 4) != "pid_" || !(std::istringstream(ids[1].substr(4, 4)) >> std::hex >> pid)) {
+        LOG_ERROR("malformed pid string: {}", tokens[1]);
+        return false;
+    }
+
+    serial = tokens[2];
+
+    return true;
+}
+
+bool parse_usb_path_from_device_id(uint16_t &vid, uint16_t &pid, uint16_t &mi, std::string &unique_id, const std::string &device_id) {
+    auto name   = utils::string::toLower(device_id);
+    auto tokens = tokenize(name, '\\');
+    if(tokens.size() < 1 || tokens[0] != R"(usb)")
+        return false;  // Not a USB device
+
+    auto ids = tokenize(tokens[1], '&');
+
+    if(ids.size() < 3) {
+        LOG_ERROR("incomplete device id");
+        return false;
+    }
+
+    if(ids[0].size() != 8 || ids[0].substr(0, 4) != "vid_" || !(std::istringstream(ids[0].substr(4, 4)) >> std::hex >> vid)) {
+        LOG_ERROR("malformed vid string: {}", tokens[1]);
+        return false;
+    }
+
+    if(ids[1].size() != 8 || ids[1].substr(0, 4) != "pid_" || !(std::istringstream(ids[1].substr(4, 4)) >> std::hex >> pid)) {
+        LOG_ERROR("malformed pid string: {}", tokens[1]);
+        return false;
+    }
+
+    if(ids[2].size() != 5 || ids[2].substr(0, 3) != "mi_" || !(std::istringstream(ids[2].substr(3, 2)) >> mi)) {
+        LOG_ERROR("malformed mi string: {}", tokens[1]);
+        return false;
+    }
+
+    ids = tokenize(tokens[2], '&');
+    if(ids.size() < 2) {
+        LOG_ERROR("malformed id string: {}", tokens[2]);
+        return false;
+    }
+    unique_id = ids[1];
+    return true;
+}
+
+/*
+UvcInfo.location example :
+
+"   \\\\.\\USB#VID_05E3&PID_0608#5&1e7d8db7&0&5#{f18a0e88-c30c-11d0-8815-00a0c906bed8} 2"
+"\\\\.\\USB#VID_05E3&PID_0608#5&1e7d8db7&0&5#{f18a0e88-c30c-11d0-8815-00a0c906bed8} 1"
+"\\\\.\\USB#VID_05E3&PID_0608#5&1e7d8db7&0&5#{f18a0e88-c30c-11d0-8815-00a0c906bed8} 1"
+
+"\\\\.\\USB#VID_05E3&PID_0608#5&1e7d8db7&0&1#{f18a0e88-c30c-11d0-8815-00a0c906bed8} 2"
+"\\\\.\\USB#VID_05E3&PID_0608#5&1e7d8db7&0&1#{f18a0e88-c30c-11d0-8815-00a0c906bed8} 1"
+"\\\\.\\USB # VID_05E3&PID_0608 # 5&1e7d8db7&0&1 # {f18a0e88-c30c-11d0-8815-00a0c906bed8} 1"
+
+*/
+
+bool parse_hubid_from_location(const std::string location, std::string &hubuid) {
+    auto name   = utils::string::toLower(location);
+    auto tokens = tokenize(name, '#');
+    if(tokens.empty())
+        return false;  // Not a USB device
+    if(tokens.size() < 3) {
+        LOG_ERROR("malformed usb device path: {}", name);
+        return false;
+    }
+    hubuid = tokens[2];
+
+    return true;
+}
+
+bool handle_node(const std::wstring &targetKey, HANDLE h, ULONG index) {
+    USB_NODE_CONNECTION_DRIVERKEY_NAME key;
+    key.ConnectionIndex = index;
+
+    if(!DeviceIoControl(h, IOCTL_USB_GET_NODE_CONNECTION_DRIVERKEY_NAME, &key, sizeof(key), &key, sizeof(key), nullptr, nullptr)) {
+        return false;
+    }
+
+    if(key.ActualLength < sizeof(key))
+        return false;
+
+    auto alloc = std::malloc(key.ActualLength);
+    if(!alloc)
+        throw std::bad_alloc();
+
+    auto pKey = std::shared_ptr<USB_NODE_CONNECTION_DRIVERKEY_NAME>(reinterpret_cast<USB_NODE_CONNECTION_DRIVERKEY_NAME *>(alloc), std::free);
+
+    pKey->ConnectionIndex = index;
+    if(DeviceIoControl(h, IOCTL_USB_GET_NODE_CONNECTION_DRIVERKEY_NAME, pKey.get(), key.ActualLength, pKey.get(), key.ActualLength, nullptr, nullptr)) {
+        // std::wcout << pKey->DriverKeyName << std::endl;
+        if(targetKey == pKey->DriverKeyName) {
+            return true;
+        }
+        else
+            return false;
+    }
+
+    return false;
+}
+
+std::wstring get_path(HANDLE h, ULONG index) {
+    // get name length
+    USB_NODE_CONNECTION_NAME name;
+    name.ConnectionIndex = index;
+    if(!DeviceIoControl(h, IOCTL_USB_GET_NODE_CONNECTION_NAME, &name, sizeof(name), &name, sizeof(name), nullptr, nullptr)) {
+        return std::wstring(L"");
+    }
+
+    // alloc space
+    if(name.ActualLength < sizeof(name))
+        return std::wstring(L"");
+    auto alloc = std::malloc(name.ActualLength);
+    auto pName = std::shared_ptr<USB_NODE_CONNECTION_NAME>(reinterpret_cast<USB_NODE_CONNECTION_NAME *>(alloc), std::free);
+
+    // get name
+    pName->ConnectionIndex = index;
+    if(DeviceIoControl(h, IOCTL_USB_GET_NODE_CONNECTION_NAME, pName.get(), name.ActualLength, pName.get(), name.ActualLength, nullptr, nullptr)) {
+        return std::wstring(pName->NodeName);
+    }
+
+    return std::wstring(L"");
+}
+
+std::tuple<std::string, UsbSpec> handle_usb_hub(const std::wstring &targetKey, const std::wstring &path) {
+    auto res = std::make_tuple(std::string(""), UsbSpec::usb_undefined);
+
+    if(path.empty())
+        return res;
+    std::wstring fullPath = L"\\\\.\\" + path;
+
+    HANDLE h = CreateFile(fullPath.c_str(), GENERIC_WRITE, FILE_SHARE_WRITE, nullptr, OPEN_EXISTING, 0, nullptr);
+    if(h == INVALID_HANDLE_VALUE)
+        return res;
+    auto h_gc = std::shared_ptr<void>(h, CloseHandle);
+
+    USB_NODE_INFORMATION info{};
+    if(!DeviceIoControl(h, IOCTL_USB_GET_NODE_INFORMATION, &info, sizeof(info), &info, sizeof(info), nullptr, nullptr))
+        return res;
+
+    // for each port on the hub
+    for(ULONG i = 1; i <= info.u.HubInformation.HubDescriptor.bNumberOfPorts; ++i) {
+        // allocate something or other
+        char                                buf[sizeof(USB_NODE_CONNECTION_INFORMATION_EX)] = { 0 };
+        PUSB_NODE_CONNECTION_INFORMATION_EX pConInfo                                        = reinterpret_cast<PUSB_NODE_CONNECTION_INFORMATION_EX>(buf);
+
+        // get info about port i
+        pConInfo->ConnectionIndex = i;
+        if(!DeviceIoControl(h, IOCTL_USB_GET_NODE_CONNECTION_INFORMATION_EX, pConInfo, sizeof(buf), pConInfo, sizeof(buf), nullptr, nullptr)) {
+            continue;
+        }
+
+        // check if device is connected
+        if(pConInfo->ConnectionStatus != DeviceConnected) {
+            continue;  // almost assuredly silently. I think this flag gets set for any port without a device
+        }
+
+        // if connected, handle correctly, setting the location info if the device is found
+        if(pConInfo->DeviceIsHub)
+            res = handle_usb_hub(targetKey, get_path(h, i));  // Invoke recursion to traverse USB hubs chain
+        else {
+            if(handle_node(targetKey, h, i))  // exit condition
+            {
+                return std::make_tuple(win_to_utf(fullPath.c_str()) + " " + std::to_string(i), static_cast<UsbSpec>(pConInfo->DeviceDescriptor.bcdUSB));
+            }
+        }
+
+        if(std::string("") != std::get<0>(res))
+            return res;
+    }
+
+    return res;
+}
+
+// Provides Port Id and the USB Specification (USB type)
+bool getUsbDescriptors(uint16_t device_vid, uint16_t device_pid, const std::string &device_uid, std::string &hubuid, UsbSpec &spec, std::string &serial,
+                       std::string &url) {
+    SP_DEVINFO_DATA   devInfo = { sizeof(SP_DEVINFO_DATA) };
+    std::vector<GUID> guids   = { GUID_DEVINTERFACE_IMAGE_WIN10, GUID_DEVINTERFACE_CAMERA_WIN10 };
+
+    for(auto guid: guids) {
+        // Build a device info represent all imaging devices
+        HDEVINFO device_info = SetupDiGetClassDevsEx(static_cast<const GUID *>(&guid), nullptr, nullptr, DIGCF_PRESENT, nullptr, nullptr, nullptr);
+
+        // Add automatic destructor to the device info
+        auto di = std::shared_ptr<void>(device_info, SetupDiDestroyDeviceInfoList);
+
+        if(device_info == INVALID_HANDLE_VALUE) {
+            return false;
+        }
+
+        // Enumerate all imaging devices
+        for(int member_index = 0;; ++member_index) {
+            SP_DEVICE_INTERFACE_DATA interfaceData = { sizeof(SP_DEVICE_INTERFACE_DATA) };
+            unsigned long            buf_size      = 0;
+
+            // Get device information element from the device information set
+            if(SetupDiEnumDeviceInfo(device_info, member_index, &devInfo) == FALSE) {
+                if(GetLastError() == ERROR_NO_MORE_ITEMS)
+                    break;  // stop when none left
+                continue;   // silently ignore other errors
+            }
+
+            // Get the buffer size required to hold this device instance ID
+            if(CM_Get_Device_ID_Size(&buf_size, devInfo.DevInst, 0) != CR_SUCCESS) {
+                LOG_ERROR("CM_Get_Device_ID_Size failed");
+                return false;
+            }
+
+            std::vector<WCHAR> pInstID(buf_size + 1);
+
+            // Get the device ID of current device
+            if(CM_Get_Device_ID(devInfo.DevInst, pInstID.data(), (ULONG)vector_bytes_size(pInstID), 0) != CR_SUCCESS) {
+                LOG_ERROR("CM_Get_Device_ID failed");
+                return false;
+            }
+
+            // Check if this is our device
+            uint16_t    usb_vid, usb_pid, usb_mi;
+            std::string usb_unique_id;
+            if(!parse_usb_path_from_device_id(usb_vid, usb_pid, usb_mi, usb_unique_id, std::string(win_to_utf(pInstID.data()))))
+                continue;
+            if(usb_vid != device_vid || usb_pid != device_pid || /* usb_mi != device->mi || */ usb_unique_id != device_uid)
+                continue;
+
+            // Get parent (composite device) instance
+            DEVINST instance;
+            if(CM_Get_Parent(&instance, devInfo.DevInst, 0) != CR_SUCCESS) {
+                LOG_ERROR("CM_Get_Parent failed");
+                return false;
+            }
+
+            // Get the buffer size required to hold the parent (composite) device instance ID
+            if(CM_Get_Device_ID_Size(&buf_size, instance, 0) != CR_SUCCESS) {
+                LOG_ERROR("CM_Get_Device_ID_Size failed");
+                return false;
+            }
+
+            std::vector<WCHAR> pInstID2(buf_size + 1);
+
+            if(CM_Get_Device_ID(instance, pInstID2.data(), ULONG(vector_bytes_size(pInstID2)), 0) != CR_SUCCESS) {
+                LOG_ERROR("CM_Get_Device_ID failed");
+                return false;
+            }
+
+            // Upgrade to DEVINFO_DATA for SetupDiGetDeviceRegistryProperty
+            device_info = SetupDiGetClassDevs(nullptr, pInstID2.data(), nullptr, DIGCF_PRESENT | DIGCF_DEVICEINTERFACE | DIGCF_ALLCLASSES);
+
+            // Add automatic destructor to the device info
+            di = std::shared_ptr<void>(device_info, SetupDiDestroyDeviceInfoList);
+
+            if(device_info == INVALID_HANDLE_VALUE) {
+                LOG_ERROR("SetupDiGetClassDevs failed");
+                return false;
+            }
+
+            interfaceData = { sizeof(SP_DEVICE_INTERFACE_DATA) };
+            if(SetupDiEnumDeviceInterfaces(device_info, nullptr, &GUID_DEVINTERFACE_USB_DEVICE, 0, &interfaceData) == FALSE) {
+                LOG_ERROR("SetupDiEnumDeviceInterfaces failed");
+                return false;
+            }
+
+            // get the SP_DEVICE_INTERFACE_DETAIL_DATA object, and also grab the SP_DEVINFO_DATA object for the device
+            buf_size = 0;
+            SetupDiGetDeviceInterfaceDetail(device_info, &interfaceData, nullptr, 0, &buf_size, nullptr);
+            if(GetLastError() != ERROR_INSUFFICIENT_BUFFER) {
+                LOG_ERROR("SetupDiGetDeviceInterfaceDetail failed");
+                return false;
+            }
+
+            std::vector<BYTE>                detail_data_buff(buf_size);
+            SP_DEVICE_INTERFACE_DETAIL_DATA *detail_data = reinterpret_cast<SP_DEVICE_INTERFACE_DETAIL_DATA *>(detail_data_buff.data());
+
+            detail_data->cbSize         = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA);
+            SP_DEVINFO_DATA parent_data = { sizeof(SP_DEVINFO_DATA) };
+            if(!SetupDiGetDeviceInterfaceDetail(device_info, &interfaceData, detail_data, ULONG(vector_bytes_size(detail_data_buff)), nullptr, &parent_data)) {
+                LOG_ERROR("SetupDiGetDeviceInterfaceDetail failed");
+                return false;
+            }
+
+            uint16_t    vid = 0;
+            uint16_t    pid = 0;
+            uint16_t    mi  = 0;
+            std::string uid, devGuid;
+            std::string path = win_to_utf(detail_data->DevicePath);
+            url              = utils::string::toUpper(path);
+
+            /* Parse the following USB path format = \?usb#vid_vvvv&pid_pppp&mi_ii#aaaaaaaaaaaaaaaa#{gggggggg-gggg-gggg-gggg-gggggggggggg} */
+            parse_usb_path_multiple_interface(vid, pid, mi, uid, path, devGuid);
+            if(uid.empty()) {
+                /* Parse the following USB path format = \?usb#vid_vvvv&pid_pppp#ssss#{gggggggg - gggg - gggg - gggg - gggggggggggg} */
+                parse_usb_path_single_interface(vid, pid, serial, path);
+                serial = utils::string::toUpper(serial);
+            }
+
+            // get driver key for composite device
+            buf_size = 0;
+            SetupDiGetDeviceRegistryProperty(device_info, &parent_data, SPDRP_DRIVER, nullptr, nullptr, 0, &buf_size);
+            if(GetLastError() != ERROR_INSUFFICIENT_BUFFER) {
+                LOG_ERROR("SetupDiGetDeviceRegistryProperty failed in an unexpected manner");
+                return false;
+            }
+
+            std::vector<BYTE> driver_key(buf_size);
+
+            if(!SetupDiGetDeviceRegistryProperty(device_info, &parent_data, SPDRP_DRIVER, nullptr, driver_key.data(), (DWORD)vector_bytes_size(driver_key),
+                                                 nullptr)) {
+                LOG_ERROR("SetupDiGetDeviceRegistryProperty failed");
+                return false;
+            }
+
+            // contains composite device key
+            std::wstring targetKey(reinterpret_cast<const wchar_t *>(driver_key.data()));
+
+            // recursively check all hubs, searching for composite device
+            for(int i = 0;; i++) {
+                std::wstringstream buf;
+                buf << "\\\\.\\HCD" << i;
+                std::wstring hcd = buf.str();
+
+                // grab handle
+                HANDLE h    = CreateFile(hcd.c_str(), GENERIC_WRITE | GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, nullptr, OPEN_EXISTING, 0, nullptr);
+                auto   h_gc = std::shared_ptr<void>(h, CloseHandle);
+                if(h == INVALID_HANDLE_VALUE) {
+                    LOG_ERROR("CreateFile failed");
+                    break;
+                }
+                else {
+                    USB_ROOT_HUB_NAME name;
+
+                    // get required space
+                    if(!DeviceIoControl(h, IOCTL_USB_GET_ROOT_HUB_NAME, nullptr, 0, &name, sizeof(name), nullptr, nullptr)) {
+                        LOG_ERROR("DeviceIoControl failed");
+                        return false;  // alt: fail silently and hope its on a different root hub
+                    }
+
+                    std::vector<char>  name_buff(name.ActualLength);
+                    USB_ROOT_HUB_NAME *pName = reinterpret_cast<USB_ROOT_HUB_NAME *>(name_buff.data());
+
+                    // get name
+                    if(!DeviceIoControl(h, IOCTL_USB_GET_ROOT_HUB_NAME, nullptr, 0, pName, (DWORD)vector_bytes_size(name_buff), nullptr, nullptr)) {
+                        LOG_ERROR("DeviceIoControl failed");
+                        return false;  // alt: fail silently and hope its on a different root hub
+                    }
+
+                    // return location if device is connected under this root hub, also provide the port USB spec/speed
+                    auto usb_res = handle_usb_hub(targetKey, std::wstring(pName->RootHubName));
+                    if(std::get<0>(usb_res) != "") {
+
+                        parse_hubid_from_location(std::get<0>(usb_res), hubuid);
+                        // LOG_ERROR("uvc hubid = " << hubuid;
+                        spec = std::get<1>(usb_res);
+                        return true;
+                    }
+                }
+            }
+        }
+    }
+
+    LOG_ERROR("could not find camera in windows device tree");
+    return false;
+}
+
+bool get_id(DEVINST devinst, std::string *p_out_str) {
+    ULONG cch_required = 0;
+    if(CM_Get_Device_ID_Size(&cch_required, devinst, 0) != CR_SUCCESS)
+        return false;
+
+    if(p_out_str) {
+        std::vector<WCHAR> buf(cch_required + 1);
+        if(CM_Get_Device_ID(devinst, buf.data(), cch_required, 0) != CR_SUCCESS)
+            return false;
+        *p_out_str = win_to_utf(buf.data());
+    }
+
+    return true;
+}
+
+std::string getId(DEVINST devinst) {
+    std::string id;
+    get_id(devinst, &id);
+    return id;
+}
+
+std::string cm_node::get_id() const {
+    return getId(get());
+}
+
+std::string cm_node::get_uid() const {
+    uint16_t    vid, pid, mi;
+    std::string uid;
+    if(!parse_usb_path_from_device_id(vid, pid, mi, uid, get_id()))
+        return std::string();
+    return uid;
+}
+
+/*
+    Convert a device path:
+        \\?\HID#VID_8086&PID_0B4D&MI_05#7&24fd3503&0&0000#{c317c286-c468-4288-9975-d4c4587c442c}\{560421A4-2F8D-47A0-A6D8-4110C6B2A202}
+    to an instance ID:
+        HID\VID_8086&PID_0B4D&MI_05\7&217e81dc&0&0000
+    which can then be used to get a DEVINST from the config manager.
+
+    Returns an empty string on failure.
+*/
+std::wstring instance_id_from_device_path(LPCWSTR path) {
+    if(wcsncmp(path, L"\\\\?\\", 4))
+        return std::wstring();
+    std::wstring inst_id(path + 4);
+    // Remove the last "#{...}" part, and replace all '#' with '\' on the way:
+    for(auto x = inst_id.find(L'#'); x != std::wstring::npos; x = inst_id.find(L'#', x + 1)) {
+        if(inst_id[x + 1] == L'{') {
+            inst_id.resize(x);
+            break;
+        }
+        inst_id.replace(x, 1, 1, L'\\');
+    }
+    return inst_id;
+}
+
+/* static */ cm_node cm_node::root() {
+    DEVINST devinst;
+    if(CM_Locate_DevNode(&devinst, nullptr, CM_LOCATE_DEVNODE_NORMAL) != CR_SUCCESS)
+        return cm_node();
+    return cm_node(devinst);
+}
+
+/* static */ cm_node cm_node::from_instance_id(std::wstring const &inst_id) {
+    DEVINST devinst;
+    if(CM_Locate_DevNode(&devinst, const_cast<DEVINSTID>(inst_id.data()), CM_LOCATE_DEVNODE_PHANTOM) != CR_SUCCESS)
+        return cm_node();
+    return cm_node(devinst);
+}
+
+cm_node cm_node::from_device_path(LPCWSTR device_path) {
+    std::wstring instance_id = instance_id_from_device_path(device_path);
+    return from_instance_id(instance_id);
+}
+
+cm_node cm_node::get_parent() const {
+    DEVINST parent;
+    if(CM_Get_Parent(&parent, get(), 0) != CR_SUCCESS)
+        return cm_node();
+    return cm_node(parent);
+}
+
+cm_node cm_node::get_child() const {
+    DEVINST child;
+    if(CM_Get_Child(&child, get(), 0) != CR_SUCCESS)
+        return cm_node();
+    return cm_node(child);
+}
+
+cm_node cm_node::get_sibling() const {
+    DEVINST sibling;
+    if(CM_Get_Sibling(&sibling, get(), 0) != CR_SUCCESS)
+        return cm_node();
+    return cm_node(sibling);
+}
+
+std::string cm_node::get_property(DEVPROPKEY const &property) const {
+    DEVPROPTYPE type;
+    ULONG       cb = 0;
+    auto        rv = CM_Get_DevNode_Property(get(), &property, &type, nullptr, &cb, 0);
+    if(rv != CR_BUFFER_SMALL)
+        return std::string();
+    if(type != DEVPROP_TYPE_STRING)
+        return std::string();
+    std::wstring str;
+    str.reserve(cb);
+    if(CM_Get_DevNode_Property(get(), &property, &type, (PBYTE)str.data(), &cb, 0) != CR_SUCCESS)
+        return std::string();
+    return win_to_utf(str.data());
+}
+
+#define MAX_HANDLES 64
+
+event_base::event_base(HANDLE handle) : _handle(handle) {}
+
+event_base::~event_base() noexcept {
+    if(_handle != nullptr) {
+        CloseHandle(_handle);
+        _handle = nullptr;
+    }
+}
+
+bool event_base::set() {
+    if(_handle == nullptr)
+        return false;
+    SetEvent(_handle);
+    return true;
+}
+
+bool event_base::wait(DWORD timeout) const {
+    if(_handle == nullptr)
+        return false;
+
+    return WaitForSingleObject(_handle, timeout) == WAIT_OBJECT_0;  // Return true only if object was signaled
+}
+
+event_base *event_base::wait(const std::vector<event_base *> &events, bool waitAll, int timeout) {
+    if(events.size() > MAX_HANDLES)
+        return nullptr;  // WaitForMultipleObjects doesn't support waiting on more then 64 handles
+
+    HANDLE handles[MAX_HANDLES];
+    auto   i = 0;
+    for(auto &event: events) {
+        handles[i] = event->get_handle();
+        ++i;
+    }
+    auto res = WaitForMultipleObjects(static_cast<DWORD>(events.size()), handles, waitAll, timeout);
+    if(res < (WAIT_OBJECT_0 + events.size())) {
+        return events[res - WAIT_OBJECT_0];
+    }
+    else {
+        return nullptr;
+    }
+}
+
+event_base *event_base::wait_all(const std::vector<event_base *> &events, int timeout) {
+    return wait(events, true, timeout);
+}
+
+event_base *event_base::wait_any(const std::vector<event_base *> &events, int timeout) {
+    return wait(events, false, timeout);
+}
+
+bool manual_reset_event::reset() const {
+    if(_handle == nullptr)
+        return false;
+    return ResetEvent(_handle) != 0;
+}
+
+manual_reset_event::manual_reset_event() : event_base(CreateEvent(nullptr, FALSE, FALSE, nullptr)) {}
+
+auto_reset_event::auto_reset_event() : event_base(CreateEvent(nullptr, FALSE, FALSE, nullptr)) {}
+
+PSECURITY_DESCRIPTOR make_allow_all_security_descriptor() {
+    const WCHAR *pszStringSecurityDescriptor;
+    pszStringSecurityDescriptor = L"D:(A;;GA;;;WD)(A;;GA;;;AN)S:(ML;;NW;;;ME)";
+    PSECURITY_DESCRIPTOR pSecDesc;
+    if(!ConvertStringSecurityDescriptorToSecurityDescriptor(pszStringSecurityDescriptor, SDDL_REVISION_1, &pSecDesc, nullptr))
+        return nullptr;
+
+    return pSecDesc;
+}
+
+winapi_error::winapi_error(const char *message) : runtime_error(generate_message(message).c_str()) {}
+
+std::string winapi_error::generate_message(const std::string &message) {
+    std::stringstream ss;
+    ss << message << " Last Error: " << last_error_string(GetLastError()) << std::endl;
+    return ss.str();
+}
+
+std::string winapi_error::last_error_string(DWORD lastError) {
+    // TODO: Error handling
+    LPSTR  messageBuffer = nullptr;
+    size_t size          = FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, nullptr, lastError,
+                                          MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), reinterpret_cast<LPSTR>(&messageBuffer), 0, nullptr);
+
+    std::string message(messageBuffer, size);
+
+    LocalFree(messageBuffer);
+
+    return message;
+}
+
+}  // namespace libobsensor
+
diff --git a/src/platform/usb/uvc/WinHelpers.hpp b/src/platform/usb/uvc/WinHelpers.hpp
new file mode 100644
index 00000000..1dbe9dd6
--- /dev/null
+++ b/src/platform/usb/uvc/WinHelpers.hpp
@@ -0,0 +1,169 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+
+#ifndef NOMINMAX
+#define NOMINMAX
+#endif
+
+#include "usb/enumerator/UsbTypes.hpp"
+
+#include <string>
+#include <vector>
+
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+#include <cfgmgr32.h>
+
+#pragma comment(lib, "cfgmgr32.lib")
+#pragma comment(lib, "setupapi.lib")
+
+#define WAIT_FOR_MUTEX_TIME_OUT (5000)
+
+namespace libobsensor {
+
+
+#define CHECK_HR(x) check(#x, x);
+#define LOG_HR(x) check(#x, x, false);
+
+std::string wcharToString(const wchar_t *wText);
+
+bool check(const char *call, HRESULT hr, bool to_throw = true);
+
+std::string win_to_utf(const WCHAR *s);
+
+bool is_win10_redstone2();
+
+std::vector<std::string> tokenize(std::string string, char separator);
+
+bool parse_usb_path_multiple_interface(uint16_t &vid, uint16_t &pid, uint16_t &mi, std::string &uid, const std::string &path, std::string &device_guid);
+bool parse_usb_path_single_interface(uint16_t &vid, uint16_t &pid, std::string &serial, const std::string &path);
+bool getUsbDescriptors(uint16_t device_vid, uint16_t device_pid, const std::string &device_uid, std::string &location, UsbSpec &spec, std::string &serial,
+                       std::string &url);
+
+
+/*
+    Configuration Management (CM) tree node.
+    See https://docs.microsoft.com/en-gb/windows/win32/api/cfgmgr32/
+
+    A basic wrapper around DEVINST and the functionality we need around it, for ease of use.
+*/
+class cm_node {
+    DEVINST _devinst;
+
+public:
+    cm_node() : _devinst(0) {}
+    cm_node(DEVINST devinst) : _devinst(devinst) {}
+
+    static cm_node from_instance_id(std::wstring const &instance_id);
+    static cm_node from_device_path(LPCWSTR device_path);
+    static cm_node root();
+
+    DEVINST get() const {
+        return _devinst;
+    }
+    bool valid() const {
+        return get() != 0;
+    }
+
+    operator DEVINST() const {
+        return _devinst;
+    }
+
+    operator DEVINST *() {
+        return &_devinst;
+    }
+    operator DEVINST const *() const {
+        return &_devinst;
+    }
+
+    std::string get_id() const;
+    std::string get_uid() const;
+
+    cm_node get_parent() const;
+    cm_node get_sibling() const;
+    cm_node get_child() const;
+
+    std::string get_property(DEVPROPKEY const &property) const;
+
+    /*
+        Iterate through all nodes (children, grandchildren, etc.) under this one.
+        A parent is visited before any children.
+        An action (function) is run for each, which can return false to stop iteration:
+
+        cm_node::root().foreach_node(
+                [&]( cm_node device, size_t depth ) -> bool
+                {
+                    ...
+                } );
+
+        Returns whether iteration was stopped. False if the whole tree was finished.
+    */
+    template <class F> bool foreach_node(F fn, size_t depth = 1) {
+        auto node = get_child();
+        while(node.valid()) {
+            if(!fn(node, depth))
+                return true;
+            if(node.foreach_node(fn, depth + 1))
+                return true;
+            node = node.get_sibling();
+        }
+        return false;
+    }
+};
+
+class event_base {
+public:
+    virtual ~event_base() noexcept;
+    virtual bool set();
+    virtual bool wait(DWORD timeout) const;
+
+    static event_base *wait(const std::vector<event_base *> &events, bool waitAll, int timeout);
+    static event_base *wait_any(const std::vector<event_base *> &events, int timeout);
+    static event_base *wait_all(const std::vector<event_base *> &events, int timeout);
+
+    HANDLE get_handle() const {
+        return _handle;
+    }
+
+protected:
+    explicit event_base(HANDLE handle);
+
+    HANDLE _handle;
+
+private:
+    event_base() = delete;
+
+    // Disallow copy:
+    event_base(const event_base &)            = delete;
+    event_base &operator=(const event_base &) = delete;
+};
+
+class auto_reset_event : public event_base {
+public:
+    auto_reset_event();
+};
+
+class manual_reset_event : public event_base {
+public:
+    manual_reset_event();
+
+    bool reset() const;
+};
+
+enum create_and_open_status { Mutex_Succeed, Mutex_TotalFailure, Mutex_AlreadyExist };
+
+
+class winapi_error : public std::runtime_error {
+public:
+    explicit winapi_error(const char *message);
+
+    static std::string last_error_string(DWORD lastError);
+    static std::string generate_message(const std::string &message);
+};
+
+}  // namespace libobsensor
+
diff --git a/src/platform/usb/uvc/WmfUvcDevicePort.cpp b/src/platform/usb/uvc/WmfUvcDevicePort.cpp
new file mode 100644
index 00000000..36c97226
--- /dev/null
+++ b/src/platform/usb/uvc/WmfUvcDevicePort.cpp
@@ -0,0 +1,1150 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#if(_MSC_FULL_VER < 180031101)
+#error At least Visual Studio 2013 Update 4 is required to compile this backend
+#endif
+
+#include <ntverp.h>
+#if VER_PRODUCTBUILD <= 9600  //(WinSDK 8.1)
+#ifdef ENFORCE_METADATA
+#error( "libobsensor Error!: Featuring UVC Metadata requires WinSDK 10.0.10586.0. \
+ Install the required toolset to proceed. Alternatively, uncheck ENFORCE_METADATA propertyId in CMake GUI tool")
+#else
+#pragma message("\nlibobsensor Notification: Featuring UVC Metadata requires WinSDK 10.0.10586.0 toolset. \
+The library will be compiled without the metadata support!\n")
+#endif  // ENFORCE_METADATA
+#else
+#define METADATA_SUPPORT
+#endif  // (WinSDK 8.1)
+
+#ifndef NOMINMAX
+#define NOMINMAX
+#endif
+
+#define DEVICE_ID_MAX_SIZE 256
+#define WAIT_STREAM_TIMEOUT_MSEC 3000
+
+#include "exception/ObException.hpp"
+#include "logger/Logger.hpp"
+#include "utils/Utils.hpp"
+#include "WmfUvcDevicePort.hpp"
+#include "frame/FrameFactory.hpp"
+#include "stream/StreamProfileFactory.hpp"
+
+#include <algorithm>
+#include <cassert>
+#include <vector>
+#include <chrono>
+#include <cmath>
+#include <limits>
+
+#include <Shlwapi.h>
+#include <Mferror.h>
+#include <vidcap.h>
+#include <ksmedia.h>  // Metadata Extension
+
+#pragma comment(lib, "Shlwapi.lib")
+#pragma comment(lib, "mf.lib")
+#pragma comment(lib, "mfplat.lib")
+#pragma comment(lib, "mfreadwrite.lib")
+#pragma comment(lib, "mfuuid.lib")
+
+#define did_guid MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_SYMBOLIC_LINK
+
+#define DEVICE_NOT_READY_ERROR _HRESULT_TYPEDEF_(0x80070015L)
+
+#define MAX_PINS 5
+#define type_guid MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_GUID
+
+namespace libobsensor {
+
+// convert to standard fourcc codes
+const std::unordered_map<uint32_t, uint32_t> fourcc_map = {
+    { 0x59382020, 0x47524559 }, /* 'GREY' from 'Y8  ' */
+    { 0x52573130, 0x70524141 }, /* 'pRAA' from 'RW10'.*/
+    { 0x32000000, 0x47524559 }, /* 'GREY' from 'L8  ' */
+    { 0x50000000, 0x5a313620 }, /* 'Z16'  from 'D16 ' */
+    { 0x52415738, 0x47524559 }, /* 'GREY' from 'RAW8' */
+    { 0x52573136, 0x42595232 }  /* 'RW16' from 'BYR2' */
+};
+
+int exposure_value_to_exponent(int val) {  // exp-unit: 0.1ms
+    return (int)(log((double)val / 10000.0) / log(2.0));
+}
+
+int exposure_exponent_to_value(int exponent) {
+    return (int)(pow(2.0, (double)exponent) * 10000);
+}
+
+#ifdef METADATA_SUPPORT
+
+#pragma pack(push, 1)
+struct ms_proprietary_md_blob {
+    // These fields are identical in layout and content with the standard UVC header
+    uint32_t timestamp;
+    uint8_t  source_clock[6];
+    // MS internal
+    uint8_t reserved[6];
+};
+
+struct ms_metadata_header {
+    KSCAMERA_METADATA_ITEMHEADER ms_header;
+    ms_proprietary_md_blob       ms_blobs[2];  // The blobs content is identical
+};
+#pragma pack(pop)
+
+constexpr uint8_t ms_header_size = sizeof(ms_metadata_header);
+
+// uint32_t tempTime = 0;
+
+size_t try_read_metadata(IMFSample *pSample, UvcMetadata *metadata) {
+    CComPtr<IUnknown>      spUnknown;
+    CComPtr<IMFAttributes> spSample;
+    HRESULT                hr = S_OK;
+
+    CHECK_HR(hr = pSample->QueryInterface(IID_PPV_ARGS(&spSample)));
+    LOG_HR(hr = spSample->GetUnknown(MFSampleExtension_CaptureMetadata, IID_PPV_ARGS(&spUnknown)));
+
+    if(SUCCEEDED(hr)) {
+        CComPtr<IMFAttributes>        spMetadata;
+        CComPtr<IMFMediaBuffer>       spBuffer;
+        PKSCAMERA_METADATA_ITEMHEADER pMetadata       = nullptr;
+        DWORD                         dwMaxLength     = 0;
+        DWORD                         dwCurrentLength = 0;
+
+        CHECK_HR(hr = spUnknown->QueryInterface(IID_PPV_ARGS(&spMetadata)));
+        if(spMetadata == nullptr)
+            return false;
+
+        hr = spMetadata->GetUnknown(MF_CAPTURE_METADATA_FRAME_RAWSTREAM, IID_PPV_ARGS(&spBuffer));
+        LOG_HR(hr);
+        if(spBuffer == nullptr || FAILED(hr))
+            return false;
+
+        CHECK_HR(hr = spBuffer->Lock(reinterpret_cast<BYTE **>(&pMetadata), &dwMaxLength, &dwCurrentLength));
+
+        if(nullptr == pMetadata)  // Bail, no data.
+            return 0;
+
+        if(pMetadata->MetadataId != MetadataId_UsbVideoHeader)  // Wrong metadata type, bail.
+            return 0;
+
+        // Microsoft converts the standard UVC (12-byte) header into MS proprietary 40-bytes struct(ms_metadata_header)
+        // Therefore we revert it to the original structure for uniform handling
+        static constexpr uint8_t md_length_max = 0xff;  // Metadata for Bulk endpoints is limited to 255 bytes by design
+        auto                     md_raw        = reinterpret_cast<byte *>(pMetadata);
+        auto                    *ms_md_hdr     = reinterpret_cast<ms_metadata_header *>(md_raw);
+
+        size_t extraDataSize = 0;
+        if(ms_md_hdr->ms_header.Size > 0) {
+            metadata->header.dwPresentationTime = ms_md_hdr->ms_blobs[0].timestamp;
+            memcpy(metadata->header.scrSourceClock, ms_md_hdr->ms_blobs[0].source_clock, sizeof(metadata->header.scrSourceClock));
+            extraDataSize = static_cast<uint8_t>(ms_md_hdr->ms_header.Size - ms_header_size);  // md_payload_size
+            if(extraDataSize > md_length_max) {
+                extraDataSize = md_length_max;
+            }
+            memcpy(metadata->metadata, md_raw + ms_header_size, extraDataSize);
+        }
+
+        // auto showUvcData = ( byte* )uvc_hdr;
+        // for ( int i = 0; i < metadataSize + uvcHeaderSize; i++ ) {
+        //    printf( "0x%.2x ", showUvcData[ i ] );
+        //    if ( i % 16 == 15 ) {
+        //        printf( "\n" );
+        //    }
+        //}
+        // printf( "\n\n" );
+
+        /*std::cout << "def Time=" << uvc_hdr->timesTamp - tempTime << std::endl;
+        tempTime = uvc_hdr->timesTamp;*/
+        // std::cout << "uvc_hdr->timesTamp" << uvc_hdr->timesTamp << std::endl;
+
+        return extraDataSize;
+    }
+    else
+        return 0;
+}
+#endif  // METADATA_SUPPORT
+
+bool WmfUvcDevicePort::isConnected(std::shared_ptr<const USBSourcePortInfo> info) {
+    auto result = false;
+    foreachUvcDevice([&](const UsbInterfaceInfo &devInfo, IMFActivate *) {
+        if(devInfo.infUrl == info->infUrl) {
+            result = true;
+        }
+    });
+    return result;
+}
+
+struct pu_control {
+    uint32_t propertyId;
+    long     ksProperty;
+    bool     enable_auto;
+};
+
+static const pu_control pu_controls[] = { { OB_PROP_COLOR_BRIGHTNESS_INT, KSPROPERTY_VIDEOPROCAMP_BRIGHTNESS },
+                                          { OB_PROP_COLOR_CONTRAST_INT, KSPROPERTY_VIDEOPROCAMP_CONTRAST },
+                                          { OB_PROP_COLOR_HUE_INT, KSPROPERTY_VIDEOPROCAMP_HUE },
+                                          { OB_PROP_COLOR_SATURATION_INT, KSPROPERTY_VIDEOPROCAMP_SATURATION },
+                                          { OB_PROP_COLOR_SHARPNESS_INT, KSPROPERTY_VIDEOPROCAMP_SHARPNESS },
+                                          { OB_PROP_COLOR_GAMMA_INT, KSPROPERTY_VIDEOPROCAMP_GAMMA },
+                                          { OB_PROP_COLOR_WHITE_BALANCE_INT, KSPROPERTY_VIDEOPROCAMP_WHITEBALANCE },
+                                          { OB_PROP_COLOR_AUTO_WHITE_BALANCE_BOOL, KSPROPERTY_VIDEOPROCAMP_WHITEBALANCE, true },
+                                          { OB_PROP_COLOR_BACKLIGHT_COMPENSATION_INT, KSPROPERTY_VIDEOPROCAMP_BACKLIGHT_COMPENSATION },
+                                          { OB_PROP_COLOR_GAIN_INT, KSPROPERTY_VIDEOPROCAMP_GAIN },
+                                          { OB_PROP_COLOR_POWER_LINE_FREQUENCY_INT, KSPROPERTY_VIDEOPROCAMP_POWERLINE_FREQUENCY } };
+
+// Camera Terminal controls will be handled with  PU propertyId transport and handling mechanism
+static const pu_control ct_controls[] = {
+    { OB_PROP_COLOR_ROLL_INT, KSPROPERTY_CAMERACONTROL_ROLL },
+    { OB_PROP_COLOR_AUTO_EXPOSURE_PRIORITY_INT, KSPROPERTY_CAMERACONTROL_AUTO_EXPOSURE_PRIORITY },
+    { OB_PROP_COLOR_FOCUS_INT, KSPROPERTY_CAMERACONTROL_FOCUS },
+};
+
+bool WmfUvcDevicePort::getPu(uint32_t propertyId, int32_t &retValue) {
+    std::lock_guard<std::recursive_mutex> lock(deviceMutex_);
+    if(powerState_ != kD0) {
+        setPowerStateD0();
+    }
+    long val = 0, flags = 0;
+    if((propertyId == OB_PROP_COLOR_EXPOSURE_INT) || (propertyId == OB_PROP_COLOR_AUTO_EXPOSURE_BOOL)) {
+        auto hr = getCameraControl()->Get(CameraControl_Exposure, &val, &flags);
+        if(hr == DEVICE_NOT_READY_ERROR)
+            return false;
+
+        retValue = (propertyId == OB_PROP_COLOR_EXPOSURE_INT) ? exposure_exponent_to_value(val) : (flags == CameraControl_Flags_Auto);
+        CHECK_HR(hr);
+        return true;
+    }
+
+    for(auto &pu: pu_controls) {
+        if(propertyId == pu.propertyId) {
+            auto hr = getVideoProc()->Get(pu.ksProperty, &val, &flags);
+            if(hr == DEVICE_NOT_READY_ERROR)
+                return false;
+
+            retValue = (pu.enable_auto) ? (flags == VideoProcAmp_Flags_Auto) : val;
+
+            CHECK_HR(hr);
+            return true;
+        }
+    }
+
+    for(auto &ct: ct_controls) {
+        if(propertyId == ct.propertyId) {
+            auto hr = getCameraControl()->Get(ct.ksProperty, &val, &flags);
+            if(hr == DEVICE_NOT_READY_ERROR)
+                return false;
+
+            retValue = val;
+
+            CHECK_HR(hr);
+            return true;
+        }
+    }
+
+    throw std::runtime_error(utils::string::to_string() << "Unsupported control - " << propertyId);
+}
+
+bool WmfUvcDevicePort::setPu(uint32_t propertyId, int32_t tarValue) {
+    std::lock_guard<std::recursive_mutex> lock(deviceMutex_);
+    if(powerState_ != kD0) {
+        setPowerStateD0();
+    }
+    if(propertyId == OB_PROP_COLOR_EXPOSURE_INT) {
+        auto hr = getCameraControl()->Set(CameraControl_Exposure, exposure_value_to_exponent(tarValue), CameraControl_Flags_Manual);
+        if(hr == DEVICE_NOT_READY_ERROR)
+            return false;
+
+        CHECK_HR(hr);
+        return true;
+    }
+    if(propertyId == OB_PROP_COLOR_AUTO_EXPOSURE_BOOL) {
+        if(tarValue) {
+            auto hr = getCameraControl()->Set(CameraControl_Exposure, 0, CameraControl_Flags_Auto);
+            if(hr == DEVICE_NOT_READY_ERROR)
+                return false;
+
+            CHECK_HR(hr);
+        }
+        else {
+            long min, max, step, def, caps;
+            auto hr = getCameraControl()->GetRange(CameraControl_Exposure, &min, &max, &step, &def, &caps);
+            if(hr == DEVICE_NOT_READY_ERROR)
+                return false;
+
+            CHECK_HR(hr);
+
+            hr = getCameraControl()->Set(CameraControl_Exposure, def, CameraControl_Flags_Manual);
+            if(hr == DEVICE_NOT_READY_ERROR)
+                return false;
+
+            CHECK_HR(hr);
+        }
+        return true;
+    }
+
+    for(auto &pu: pu_controls) {
+        if(propertyId == pu.propertyId) {
+            if(pu.enable_auto) {
+                if(tarValue) {
+                    auto hr = getVideoProc()->Set(pu.ksProperty, 0, VideoProcAmp_Flags_Auto);
+                    if(hr == DEVICE_NOT_READY_ERROR)
+                        return false;
+
+                    CHECK_HR(hr);
+                }
+                else {
+                    long min, max, step, def, caps;
+                    auto hr = getVideoProc()->GetRange(pu.ksProperty, &min, &max, &step, &def, &caps);
+                    if(hr == DEVICE_NOT_READY_ERROR)
+                        return false;
+
+                    CHECK_HR(hr);
+
+                    hr = getVideoProc()->Set(pu.ksProperty, def, VideoProcAmp_Flags_Manual);
+                    if(hr == DEVICE_NOT_READY_ERROR)
+                        return false;
+
+                    CHECK_HR(hr);
+                }
+            }
+            else {
+                auto hr = getVideoProc()->Set(pu.ksProperty, tarValue, VideoProcAmp_Flags_Manual);
+                if(hr == DEVICE_NOT_READY_ERROR)
+                    return false;
+
+                CHECK_HR(hr);
+            }
+            return true;
+        }
+    }
+    for(auto &ct: ct_controls) {
+        if(propertyId == ct.propertyId) {
+            if(ct.enable_auto) {
+                if(tarValue) {
+                    auto hr = getCameraControl()->Set(ct.ksProperty, 0, CameraControl_Flags_Auto);
+                    if(hr == DEVICE_NOT_READY_ERROR)
+                        return false;
+
+                    CHECK_HR(hr);
+                }
+                else {
+                    long min, max, step, def, caps;
+                    auto hr = getCameraControl()->GetRange(ct.ksProperty, &min, &max, &step, &def, &caps);
+                    if(hr == DEVICE_NOT_READY_ERROR)
+                        return false;
+
+                    CHECK_HR(hr);
+
+                    hr = getCameraControl()->Set(ct.ksProperty, def, CameraControl_Flags_Manual);
+                    if(hr == DEVICE_NOT_READY_ERROR)
+                        return false;
+
+                    CHECK_HR(hr);
+                }
+            }
+            else {
+                auto hr = getCameraControl()->Set(ct.ksProperty, tarValue, CameraControl_Flags_Manual);
+                if(hr == DEVICE_NOT_READY_ERROR)
+                    return false;
+
+                CHECK_HR(hr);
+            }
+            return true;
+        }
+    }
+    throw std::runtime_error(utils::string::to_string() << "Unsupported control - " << propertyId);
+}
+
+UvcControlRange WmfUvcDevicePort::getPuRange(uint32_t propertyId) {
+    std::lock_guard<std::recursive_mutex> lock(deviceMutex_);
+    if(powerState_ != kD0) {
+        setPowerStateD0();
+    }
+
+    if(propertyId == OB_PROP_COLOR_AUTO_EXPOSURE_BOOL || propertyId == OB_PROP_COLOR_AUTO_WHITE_BALANCE_BOOL) {
+        static const int32_t min = 0, max = 1, step = 1, def = 1;
+        UvcControlRange      result(min, max, step, def);
+        return result;
+    }
+
+    long minVal = 0, maxVal = 0, steppingDelta = 0, defVal = 0, capsFlag = 0;
+    if(propertyId == OB_PROP_COLOR_EXPOSURE_INT) {
+        CHECK_HR(getCameraControl()->GetRange(CameraControl_Exposure, &minVal, &maxVal, &steppingDelta, &defVal, &capsFlag));
+        long min = exposure_exponent_to_value(minVal);
+        long max = exposure_exponent_to_value(maxVal);
+        long def = exposure_exponent_to_value(defVal);
+
+        UvcControlRange result(min, max, steppingDelta, def);
+        return result;
+    }
+    for(auto &pu: pu_controls) {
+        if(propertyId == pu.propertyId) {
+            CHECK_HR(getVideoProc()->GetRange(pu.ksProperty, &minVal, &maxVal, &steppingDelta, &defVal, &capsFlag));
+            UvcControlRange result(minVal, maxVal, steppingDelta, defVal);
+            return result;
+        }
+    }
+    for(auto &ct: ct_controls) {
+        if(propertyId == ct.propertyId) {
+            if(propertyId == OB_PROP_COLOR_AUTO_EXPOSURE_PRIORITY_INT) {
+                minVal        = 0;
+                maxVal        = 1;
+                steppingDelta = 1;
+                defVal        = 0;
+            }
+            else {
+                CHECK_HR(getCameraControl()->GetRange(ct.ksProperty, &minVal, &maxVal, &steppingDelta, &defVal, &capsFlag));
+            }
+            UvcControlRange result(minVal, maxVal, steppingDelta, defVal);
+            return result;
+        }
+    }
+    throw std::runtime_error("unsupported control");
+}
+
+uint32_t WmfUvcDevicePort::sendAndReceive(const uint8_t *sendData, uint32_t sendLen, uint8_t *recvData, uint32_t exceptedRecvLen) {
+    std::lock_guard<std::recursive_mutex> lock(deviceMutex_);
+    // checkConnection();
+    if(powerState_ != kD0) {
+        setPowerStateD0();
+    }
+    if(xuKsControl_ == nullptr) {
+        initXu();
+    }
+
+    // sendData
+    uint8_t ctrl         = OB_VENDOR_XU_CTRL_ID_64;
+    auto    alignDataLen = sendLen;
+    if(alignDataLen <= 64) {
+        ctrl         = OB_VENDOR_XU_CTRL_ID_64;
+        alignDataLen = 64;
+    }
+    else if(alignDataLen > 512) {
+        ctrl         = OB_VENDOR_XU_CTRL_ID_1024;
+        alignDataLen = 1024;
+    }
+    else {
+        ctrl         = OB_VENDOR_XU_CTRL_ID_512;
+        alignDataLen = 512;
+    }
+
+    if(!setXu(ctrl, sendData, alignDataLen)) {
+        LOG_ERROR("setXu failed!");
+        return 0;
+    }
+
+    // receiveData
+    ctrl             = OB_VENDOR_XU_CTRL_ID_512;
+    uint32_t recvLen = exceptedRecvLen;
+    if(exceptedRecvLen <= 64) {
+        ctrl    = OB_VENDOR_XU_CTRL_ID_64;
+        recvLen = 64;
+    }
+    else if(exceptedRecvLen > 512) {
+        ctrl    = OB_VENDOR_XU_CTRL_ID_1024;
+        recvLen = 1024;
+    }
+    else {
+        ctrl    = OB_VENDOR_XU_CTRL_ID_512;
+        recvLen = 512;
+    }
+    if(!getXu(ctrl, recvData, &recvLen)) {
+        LOG_ERROR("getXu failed!");
+        return 0;
+    }
+    return recvLen;
+}
+
+// std::string wcharToString(wchar_t *wchar) {
+//     wchar_t *wText = wchar;
+//     DWORD    dwNum = WideCharToMultiByte(CP_OEMCP, NULL, wText, -1, NULL, 0, NULL, FALSE);  // Usage of WideCharToMultiByte
+//     char *   psText;  // psText is a temporary char* array used as an intermediate variable for assignment to std::string
+//     psText = new char[dwNum];
+//     WideCharToMultiByte(CP_OEMCP, NULL, wText, -1, psText, dwNum, NULL, FALSE);  // Reuse of WideCharToMultiByte
+//     std::string szDst = psText;                                                  // std::string assignment
+//     delete[] psText;                                                             // Clearing psText
+//     return szDst;
+// }
+
+void WmfUvcDevicePort::queryXuNodeId(const CComPtr<IKsTopologyInfo> &topologyInfo) {
+    std::lock_guard<std::recursive_mutex> lock(deviceMutex_);
+    DWORD                                 nNodes = 0;
+    check("get_NumNodes", topologyInfo->get_NumNodes(&nNodes));
+    for(DWORD i = 0; i < nNodes; i++) {
+        GUID nodeType;
+        CHECK_HR(topologyInfo->get_NodeType(i, &nodeType))
+        if(nodeType == KSNODETYPE_DEV_SPECIFIC) {
+            xuNodeId_ = static_cast<int>(i);
+        }
+
+        // DWORD cbName = 0;
+        // auto  hr     = topologyInfo->get_NodeName( i, NULL, 0, &cbName );
+        // if ( hr == __HRESULT_FROM_WIN32( ERROR_MORE_DATA ) ) {
+        //     if ( cbName > sizeof( WCHAR ) ) {
+        //         WCHAR* nodeName = new WCHAR[ cbName / sizeof( WCHAR ) ];
+        //         if ( nodeName == NULL ) {
+        //             hr = E_OUTOFMEMORY;
+        //         }
+        //         else {
+        //             hr = topologyInfo->get_NodeName( i, nodeName, cbName, &cbName );
+
+        //              LOG_INFO("IKsTopologyInfo->node@{}, name={}", i, wcharToString(nodeName));
+        //             delete[] nodeName;
+        //         }
+        //     }
+        // }
+    }
+}
+
+void WmfUvcDevicePort::initXu() {
+    std::lock_guard<std::recursive_mutex> lock(deviceMutex_);
+    if(powerState_ != kD0) {
+        setPowerStateD0();
+    }
+    // Attempt to retrieve IKsControl
+    CComPtr<IKsTopologyInfo> ks_topology_info = nullptr;
+    CHECK_HR(deviceSource_->QueryInterface(__uuidof(IKsTopologyInfo), reinterpret_cast<void **>(&ks_topology_info)));
+
+    // Query Xu Node Id
+    queryXuNodeId(ks_topology_info);
+
+    // KSNODETYPE_VIDEO_STREAMING
+    CComPtr<IUnknown> unknown = nullptr;
+    CHECK_HR(ks_topology_info->CreateNodeInstance(xuNodeId_, IID_IUnknown, reinterpret_cast<LPVOID *>(&unknown)));
+
+    CHECK_HR(unknown->QueryInterface(__uuidof(IKsControl), reinterpret_cast<void **>(&xuKsControl_)));
+    if(xuKsControl_ == nullptr) {
+        throw std::runtime_error("Extension control can not be initialized!");
+    }
+}
+
+bool WmfUvcDevicePort::setXu(uint8_t ctrl, const uint8_t *data, uint32_t len) {
+    std::lock_guard<std::recursive_mutex> lock(deviceMutex_);
+    if(powerState_ != kD0) {
+        setPowerStateD0();
+    }
+    KSP_NODE node;
+    memset(&node, 0, sizeof(KSP_NODE));
+    node.Property.Set   = reinterpret_cast<const GUID &>(xuUnit_.id);
+    node.Property.Id    = ctrl;
+    node.Property.Flags = KSPROPERTY_TYPE_SET | KSPROPERTY_TYPE_TOPOLOGY;
+    node.NodeId         = xuNodeId_;
+
+    ULONG bytes_received = 0;
+    addTimeoutBarrier("setXu");
+
+    // The library will first use the GET_LEN command to obtain the protocol data length and then send the data of the corresponding length based on the GET_LEN return value.
+    // Therefore, when len < GET_LEN(), an error will be returned; when len > GET_LEN(), only the first GET_LEN() bytes of data will be sent.
+    auto hr = xuKsControl_->KsProperty(reinterpret_cast<PKSPROPERTY>(&node), sizeof(KSP_NODE), (void *)data, len, &bytes_received);
+
+    removeTimeoutBarrier();
+    return LOG_HR(hr);
+}
+
+bool WmfUvcDevicePort::getXu(uint8_t ctrl, uint8_t *data, uint32_t *len) {
+    std::lock_guard<std::recursive_mutex> lock(deviceMutex_);
+    if(powerState_ != kD0) {
+        setPowerStateD0();
+    }
+
+    KSP_NODE node;
+    memset(&node, 0, sizeof(KSP_NODE));
+    node.Property.Set   = reinterpret_cast<const GUID &>(xuUnit_.id);
+    node.Property.Id    = ctrl;
+    node.Property.Flags = KSPROPERTY_TYPE_GET | KSPROPERTY_TYPE_TOPOLOGY;
+    node.NodeId         = xuNodeId_;
+
+    ULONG bytes_received = 0;
+    addTimeoutBarrier("getXu");
+
+    // The library will first use the GET_LEN command to get the protocol data length, and the data length that the device can return must be less than or equal to GET_LEN().
+    // If XU_MAX_DATA_LENGTH < GET_LEN(), an error will be returned.
+    auto hr = xuKsControl_->KsProperty(reinterpret_cast<PKSPROPERTY>(&node), sizeof(node), data, XU_MAX_DATA_LENGTH, &bytes_received);
+    *len    = bytes_received;
+
+    removeTimeoutBarrier();
+    return LOG_HR(hr);
+}
+
+void WmfUvcDevicePort::foreachUvcDevice(const USBDeviceInfoEnumCallback &action) {
+    for(const auto &attributes_params_set: attributes_params) {
+        CComPtr<IMFAttributes> pAttributes = nullptr;
+        CHECK_HR(MFCreateAttributes(&pAttributes, 1));
+        for(auto attribute_params: attributes_params_set) {
+            CHECK_HR(pAttributes->SetGUID(attribute_params.first, attribute_params.second));
+        }
+
+        IMFActivate **ppDevices;
+        UINT32        numDevices;
+        CHECK_HR(MFEnumDeviceSources(pAttributes, &ppDevices, &numDevices));
+
+        for(UINT32 i = 0; i < numDevices; ++i) {
+            CComPtr<IMFActivate> pDevice;
+            *&pDevice = ppDevices[i];
+
+            WCHAR *wchar_name = nullptr;
+            UINT32 length;
+            CHECK_HR(pDevice->GetAllocatedString(MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_SYMBOLIC_LINK, &wchar_name, &length));
+            auto symbolicLink = win_to_utf(wchar_name);
+            CoTaskMemFree(wchar_name);
+
+            pDevice->GetAllocatedString(MF_DEVSOURCE_ATTRIBUTE_FRIENDLY_NAME, &wchar_name, &length);
+            auto friendlyName = win_to_utf(wchar_name);
+            //    LOG_DEBUG("device friendly name: "
+            //              << friendlyName;
+            CoTaskMemFree(wchar_name);
+
+            uint16_t    vid, pid, infIndex;
+            std::string uid, guid;
+            if(parse_usb_path_multiple_interface(vid, pid, infIndex, uid, symbolicLink, guid) && vid == ORBBEC_USB_VID) {
+                UsbInterfaceInfo info;
+                // info.url = ""
+                info.uid      = uid;
+                info.vid      = vid;
+                info.pid      = pid;
+                info.infIndex = (uint8_t)infIndex;
+                info.infUrl   = utils::string::toUpper(symbolicLink);
+                info.infName  = friendlyName;
+                TRY_EXECUTE({ action(info, ppDevices[i]); });
+            }
+        }
+        safe_release(pAttributes);
+        CoTaskMemFree(ppDevices);
+    }
+}
+
+WmfUvcDevicePort::WmfUvcDevicePort(std::shared_ptr<const USBSourcePortInfo> portInfo) : portInfo_(portInfo), xuKsControl_(nullptr), xuNodeId_(0) {
+    if(!isConnected(portInfo)) {
+        throw std::runtime_error("Camera not connected!");
+    }
+
+    BEGIN_TRY_EXECUTE({
+        UsbSpec     deviceUsbSpec;
+        std::string location;
+        std::string deviceSerial;
+        std::string url;
+        if(!getUsbDescriptors(portInfo->vid, portInfo->pid, portInfo->uid, location, deviceUsbSpec, deviceSerial, url)) {
+            LOG_WARN("Could not retrieve USB descriptor for device {0:x}:{1:x} , url:{2}", portInfo->vid, portInfo->pid, portInfo->url);
+        }
+    })
+    CATCH_EXCEPTION_AND_EXECUTE({ LOG_WARN("Accessing USB info failed for{0:x}:{1:x} , url:{2}", portInfo->vid, portInfo->pid, portInfo->url); })
+
+    foreachUvcDevice([&](const UsbInterfaceInfo &devInfo, IMFActivate *device) {
+        if(devInfo.infUrl == portInfo->infUrl && device) {
+            deviceId_.resize(DEVICE_ID_MAX_SIZE);
+            CHECK_HR(device->GetString(did_guid, const_cast<LPWSTR>(deviceId_.c_str()), static_cast<UINT32>(deviceId_.size()), nullptr));
+        }
+    });
+    initTimeoutThread();
+}
+
+WmfUvcDevicePort::~WmfUvcDevicePort() noexcept {
+    std::lock_guard<std::recursive_mutex> lock(deviceMutex_);
+    terminateTimeoutThread();
+    TRY_EXECUTE({
+        if(isStarted_) {
+            stopAllStream();
+            // flush(MF_SOURCE_READER_ALL_STREAMS);
+        }
+        if(powerState_ != kD3) {
+            setPowerStateD3();
+        }
+        safe_release(deviceAttrs_);
+        safe_release(readerAttrs_);
+        if(xuKsControl_ != nullptr) {
+            safe_release(xuKsControl_);
+            xuKsControl_ = nullptr;
+        }
+    });
+}
+
+void WmfUvcDevicePort::initTimeoutThread() {
+    timeoutThreadRun_ = true;
+    timeoutThread_    = std::thread([&]() {
+        while(timeoutThreadRun_) {
+            std::unique_lock<std::mutex> lk(timeoutMutex_);
+            if(!timeoutCondition_.wait_for(lk, std::chrono::seconds(10), [&]() { return !(timeoutThreadRun_ && hasTimeoutBarrier_); })) {
+                if(!timeoutMsg_.empty()) {
+                    LOG_ERROR("Catch timeout event.{}", timeoutMsg_);
+                }
+            }
+
+            timeoutCondition_.wait(lk, [&]() { return !(timeoutThreadRun_ && !hasTimeoutBarrier_); });
+        }
+    });
+}
+
+void WmfUvcDevicePort::terminateTimeoutThread() {
+    {
+        std::unique_lock<std::mutex> lk(timeoutMutex_);
+        timeoutThreadRun_  = false;
+        hasTimeoutBarrier_ = false;
+        timeoutMsg_        = "";
+        timeoutCondition_.notify_all();
+    }
+    timeoutThread_.join();
+}
+
+void WmfUvcDevicePort::addTimeoutBarrier(std::string msg) {
+    std::unique_lock<std::mutex> lk(timeoutMutex_);
+    hasTimeoutBarrier_ = true;
+    timeoutMsg_        = msg;
+    timeoutCondition_.notify_all();
+}
+
+void WmfUvcDevicePort::removeTimeoutBarrier() {
+    std::unique_lock<std::mutex> lk(timeoutMutex_);
+    hasTimeoutBarrier_ = false;
+    timeoutMsg_        = "";
+    timeoutCondition_.notify_all();
+}
+
+std::shared_ptr<const SourcePortInfo> WmfUvcDevicePort::getSourcePortInfo() const {
+    return portInfo_;
+}
+
+CComPtr<IMFAttributes> WmfUvcDevicePort::createDeviceAttrs() {
+    CComPtr<IMFAttributes> device_attrs = nullptr;
+
+    CHECK_HR(MFCreateAttributes(&device_attrs, 2));
+    CHECK_HR(device_attrs->SetGUID(MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE, type_guid));
+    CHECK_HR(device_attrs->SetString(did_guid, deviceId_.c_str()));
+    return device_attrs;
+}
+
+CComPtr<IMFAttributes> WmfUvcDevicePort::createReaderAttrs() {
+    CComPtr<IMFAttributes> reader_attrs = nullptr;
+    CHECK_HR(MFCreateAttributes(&reader_attrs, 3));
+    CHECK_HR(reader_attrs->SetUINT32(MF_SOURCE_READER_DISCONNECT_MEDIASOURCE_ON_SHUTDOWN, FALSE));
+    CHECK_HR(reader_attrs->SetUINT32(MF_READWRITE_ENABLE_HARDWARE_TRANSFORMS, TRUE));
+    // for convert to rgb or rgba
+    CHECK_HR(reader_attrs->SetUINT32(MF_SOURCE_READER_ENABLE_ADVANCED_VIDEO_PROCESSING, TRUE));
+    CHECK_HR(reader_attrs->SetUINT32(MF_XVP_DISABLE_FRC, TRUE));
+
+    CHECK_HR(reader_attrs->SetUnknown(MF_SOURCE_READER_ASYNC_CALLBACK, static_cast<IUnknown *>(this)));
+    return reader_attrs;
+}
+
+void WmfUvcDevicePort::setPowerStateD0() {
+    std::lock_guard<std::recursive_mutex> lock(deviceMutex_);
+    if(powerState_ == kD0) {
+        return;
+    }
+    if(!deviceAttrs_) {
+        deviceAttrs_ = createDeviceAttrs();
+    }
+
+    if(!readerAttrs_) {
+        readerAttrs_ = createReaderAttrs();
+    }
+
+    // enable source
+    CHECK_HR(MFCreateDeviceSource(deviceAttrs_, &deviceSource_));
+    LOG_HR(deviceSource_->QueryInterface(__uuidof(IAMCameraControl), reinterpret_cast<void **>(&cameraControl_)));
+    LOG_HR(deviceSource_->QueryInterface(__uuidof(IAMVideoProcAmp), reinterpret_cast<void **>(&videoProc_)));
+
+    // enable reader
+    CHECK_HR(MFCreateSourceReaderFromMediaSource(deviceSource_, readerAttrs_, &streamReader_));
+    // CHECK_HR(streamReader_->SetStreamSelection(static_cast<DWORD>(MF_SOURCE_READER_ALL_STREAMS), TRUE));
+    powerState_ = kD0;
+}
+
+void WmfUvcDevicePort::setPowerStateD3() {
+    std::lock_guard<std::recursive_mutex> lock(deviceMutex_);
+    if(powerState_ == kD3) {
+        return;
+    }
+    safe_release(cameraControl_);
+    safe_release(videoProc_);
+    // safe_release(streamReader_);
+    streamReader_.Reset();
+
+    if(deviceSource_ != nullptr) {
+        deviceSource_->Shutdown();  // Failure to call Shutdown can result in memory leak
+        safe_release(deviceSource_);
+    }
+
+    if(xuKsControl_ != nullptr) {
+        safe_release(xuKsControl_);
+        xuKsControl_ = nullptr;
+    }
+
+    streams_.clear();
+    powerState_ = kD3;
+}
+
+void WmfUvcDevicePort::reloadSourceAndReader() {
+    std::lock_guard<std::recursive_mutex> lock(deviceMutex_);
+    if(powerState_ != kD3) {
+        setPowerStateD3();
+    }
+    std::this_thread::sleep_for(std::chrono::milliseconds(20));
+    setPowerStateD0();
+}
+
+StreamProfileList WmfUvcDevicePort::getStreamProfileList() {
+    if(profileList_.empty()) {
+        std::lock_guard<std::recursive_mutex> lock(deviceMutex_);
+        checkConnection();
+        bool recoveryD3 = false;
+        if(powerState_ != kD0) {
+            setPowerStateD0();
+            recoveryD3 = true;
+        }
+        foreachProfile([&](const MFProfile &mfp, CComPtr<IMFMediaType> media_type, bool &quit) {
+            utils::unusedVar(media_type);
+            utils::unusedVar(quit);
+            profileList_.push_back(mfp.profile);
+            if(mfp.profile->getFormat() == OB_FORMAT_NV12) {
+                std::shared_ptr<StreamProfile> sp         = mfp.profile;
+                auto                           bgrProfile = sp->clone(OB_FORMAT_BGR)->as<VideoStreamProfile>();
+                profileList_.push_back(bgrProfile);
+                auto bgraProfile = sp->clone(OB_FORMAT_BGRA)->as<VideoStreamProfile>();
+                profileList_.push_back(bgraProfile);
+            }
+        });
+        if(recoveryD3) {
+            setPowerStateD3();
+        }
+    }
+    return profileList_;
+}
+
+void WmfUvcDevicePort::foreachProfile(std::function<void(const MFProfile &profile, CComPtr<IMFMediaType> media_type, bool &quit)> action) const {
+    bool                  quit       = false;
+    CComPtr<IMFMediaType> pMediaType = nullptr;
+    for(unsigned int index = 0; index < MAX_PINS; ++index) {
+        for(auto k = 0;; k++) {
+            auto hr = streamReader_->GetNativeMediaType(index, k, &pMediaType.p);
+            if(FAILED(hr) || pMediaType == nullptr) {
+                safe_release(pMediaType);
+                if(hr != MF_E_NO_MORE_TYPES)  // An object ran out of media types to suggest therefore the requested chain of streaming objects cannot be
+                                              // completed
+                    check("streamReader_->GetNativeMediaType(index, k, &pMediaType.p)", hr, false);
+
+                break;
+            }
+
+            GUID subtype;
+            CHECK_HR(pMediaType->GetGUID(MF_MT_SUBTYPE, &subtype));
+
+            uint32_t width  = 0;
+            uint32_t height = 0;
+
+            CHECK_HR(MFGetAttributeSize(pMediaType, MF_MT_FRAME_SIZE, &width, &height));
+
+            FrameRate frameRateMin;
+            FrameRate frameRateMax;
+
+            CHECK_HR(MFGetAttributeRatio(pMediaType, MF_MT_FRAME_RATE_RANGE_MIN, &frameRateMin.numerator, &frameRateMin.denominator));
+            CHECK_HR(MFGetAttributeRatio(pMediaType, MF_MT_FRAME_RATE_RANGE_MAX, &frameRateMax.numerator, &frameRateMax.denominator));
+
+            if(static_cast<float>(frameRateMax.numerator) / frameRateMax.denominator < static_cast<float>(frameRateMin.numerator) / frameRateMin.denominator) {
+                std::swap(frameRateMax, frameRateMin);
+            }
+            auto currFps = static_cast<uint16_t>(frameRateMax.numerator / frameRateMax.denominator);
+
+            uint32_t device_fourcc = reinterpret_cast<const utils::big_endian<uint32_t> &>(subtype.Data1);
+
+            auto format = utils::uvcFourccToOBFormat(device_fourcc);
+            if(format != OB_FORMAT_UNKNOWN) {
+                std::shared_ptr<StreamProfile> sp = StreamProfileFactory::createVideoStreamProfile(OB_STREAM_VIDEO, format, width, height, currFps);
+                sp->setIndex(static_cast<uint8_t>(index));
+
+                MFProfile mfp;
+                mfp.index    = index;
+                mfp.min_rate = frameRateMin;
+                mfp.max_rate = frameRateMax;
+                mfp.profile  = sp->as<VideoStreamProfile>();
+
+                action(mfp, pMediaType, quit);
+            }
+
+            safe_release(pMediaType);
+            // safe_release(spOutputMediaType);
+
+            if(quit)
+                return;
+        }
+    }
+}
+
+void WmfUvcDevicePort::playProfile(std::shared_ptr<const VideoStreamProfile> profile, MutableFrameCallback callback) {
+    std::lock_guard<std::recursive_mutex> lock(deviceMutex_);
+    bool                                  found = false;
+    foreachProfile([&](const MFProfile &mfp, CComPtr<IMFMediaType> media_type, bool &quit) {
+        if(mfp.profile->getWidth() != profile->getWidth() || mfp.profile->getHeight() != profile->getHeight() || mfp.profile->getFps() != profile->getFps()) {
+            return;
+        }
+
+        if((profile->getFormat() == OB_FORMAT_BGR || profile->getFormat() == OB_FORMAT_BGRA) && mfp.profile->getFormat() == OB_FORMAT_NV12) {
+            CComPtr<IMFMediaType> spOutputMediaType = nullptr;
+            // Create Output Media type
+            {
+                Microsoft::WRL::ComPtr<IMFSourceReaderEx> spSourceReaderEx;
+                CHECK_HR(streamReader_.As(&spSourceReaderEx));
+                DWORD dwStreamFlags = 0;
+                CHECK_HR(spSourceReaderEx->SetNativeMediaType(mfp.index, media_type, &dwStreamFlags));
+                CHECK_HR(MFCreateMediaType(&spOutputMediaType));
+                CHECK_HR(media_type->CopyAllItems(spOutputMediaType));
+                if(profile->getFormat() == OB_FORMAT_BGR) {
+                    CHECK_HR(spOutputMediaType->SetGUID(MF_MT_SUBTYPE, MFVideoFormat_RGB24));  // the actual format is BGR24
+                }
+                else if(profile->getFormat() == OB_FORMAT_BGRA) {
+                    CHECK_HR(spOutputMediaType->SetGUID(MF_MT_SUBTYPE, MFVideoFormat_ARGB32));  // the actual format is BGRA32
+                }
+                media_type = spOutputMediaType;
+            }
+        }
+        else if(mfp.profile->getFormat() != profile->getFormat()) {
+            return;
+        }
+
+        auto hr = streamReader_->SetCurrentMediaType(mfp.index, nullptr, media_type);
+        if(SUCCEEDED(hr) && media_type) {
+            for(unsigned int i = 0; i < 5; ++i) {
+                auto &stream = streams_[mfp.index];
+                if((mfp.index == i) || (stream.callback))
+                    continue;
+
+                streamReader_->SetStreamSelection(i, FALSE);
+            }
+
+            CHECK_HR(streamReader_->SetStreamSelection(mfp.index, TRUE));
+            {
+                std::lock_guard<std::mutex> lock(streamsMutex_);
+                auto                       &stream = streams_[mfp.index];  // Characteristic of std::map: if the key does not exist, it will be automatically created
+                if(streams_[mfp.index].streaming) {
+                    throw std::runtime_error("Camera already streaming via this stream index!");
+                }
+                stream.profile   = profile;
+                stream.callback  = callback;
+                stream.streaming = true;
+                stream.hasStarted.reset();
+                stream.frameCounter = 0;
+
+                isStarted_        = true;
+                readSampleResult_ = S_OK;
+                CHECK_HR(streamReader_->ReadSample(mfp.index, 0, nullptr, nullptr, nullptr, nullptr));
+            }
+
+            if(streams_[mfp.index].hasStarted.wait(WAIT_STREAM_TIMEOUT_MSEC)) {
+                check("streamReader_->ReadSample(...)", readSampleResult_);
+            }
+            else {
+                LOG_WARN("First frame took more than {}ms to arrive!", WAIT_STREAM_TIMEOUT_MSEC);
+            }
+
+            found = true;
+            quit  = true;
+            return;
+        }
+        else {
+            throw std::runtime_error("Could not set Media Type. Device may be locked");
+        }
+    });
+    if(!found)
+        throw std::runtime_error("Stream profile not found!");
+}
+
+IAMVideoProcAmp *WmfUvcDevicePort::getVideoProc() const {
+    if(powerState_ != kD0)
+        throw std::runtime_error("Device must be powered to query video_proc!");
+    if(!videoProc_.p)
+        throw std::runtime_error("The device does not support adjusting the qualities of an incoming video signal, such as brightness, contrast, hue, "
+                                 "saturation, gamma, and sharpness.");
+    return videoProc_.p;
+}
+
+IAMCameraControl *WmfUvcDevicePort::getCameraControl() const {
+    if(powerState_ != kD0)
+        throw std::runtime_error("Device must be powered to query camera_control!");
+    if(!cameraControl_.p)
+        throw std::runtime_error("The device does not support camera settings such as zoom, pan, aperture adjustment, or shutter speed.");
+    return cameraControl_.p;
+}
+
+void WmfUvcDevicePort::startStream(std::shared_ptr<const StreamProfile> profile, MutableFrameCallback callback) {
+    std::lock_guard<std::recursive_mutex> lock(deviceMutex_);
+    checkConnection();
+    if(powerState_ != kD0) {
+        setPowerStateD0();
+    }
+    auto videoFrame = profile->as<VideoStreamProfile>();
+    BEGIN_TRY_EXECUTE({ playProfile(videoFrame, callback); })
+    CATCH_EXCEPTION_AND_EXECUTE({
+        LOG_WARN("Retry to start stream!");
+        TRY_EXECUTE(stopAllStream());
+        reloadSourceAndReader();
+        playProfile(videoFrame, callback);
+    })
+}
+
+void WmfUvcDevicePort::stopStream(std::shared_ptr<const StreamProfile> profile) {
+    std::lock_guard<std::recursive_mutex> lock(deviceMutex_);
+    bool                                  isStarted = false;  // Will reassign values based on whether there are still streams in the output state
+    for(auto &item: streams_) {
+        auto &stream = item.second;
+        if(stream.profile == profile && stream.streaming) {
+            stream.streaming = false;
+            stream.isFlushed.reset();
+            BEGIN_TRY_EXECUTE(flush(item.first))
+            CATCH_EXCEPTION_AND_EXECUTE({
+                setPowerStateD3();
+                throw;  // rethrow
+            })
+            if(isConnected(portInfo_) && !stream.isFlushed.wait(WAIT_STREAM_TIMEOUT_MSEC)) {
+                LOG_WARN("Wait for flush more than {}ms!", WAIT_STREAM_TIMEOUT_MSEC);
+            }
+        }
+        if(stream.streaming) {
+            isStarted = true;  // There are other streams still open
+        }
+    }
+    checkConnection();
+    isStarted_ = isStarted;
+    if(!isStarted_ && powerState_ != kD3) {
+        setPowerStateD3();
+    }
+}
+
+void WmfUvcDevicePort::stopAllStream() {
+    std::lock_guard<std::recursive_mutex> lock(deviceMutex_);
+    checkConnection();
+    isStarted_ = false;
+    for(auto &item: streams_) {
+        auto &stream     = item.second;
+        stream.streaming = false;
+        stream.isFlushed.reset();
+        flush(item.first);
+        if(!stream.isFlushed.wait(WAIT_STREAM_TIMEOUT_MSEC)) {
+            LOG_WARN("Wait for flush more than {}ms!", WAIT_STREAM_TIMEOUT_MSEC);
+        }
+    }
+    if(powerState_ != kD3) {
+        setPowerStateD3();
+    }
+}
+
+// ReSharper disable once CppMemberFunctionMayBeConst
+void WmfUvcDevicePort::flush(int index) {
+    std::lock_guard<std::recursive_mutex> lock(deviceMutex_);  // flush is synchronous
+    if(isConnected(portInfo_)) {
+        if(streamReader_ != nullptr) {
+            CHECK_HR(streamReader_->Flush(index));  // flush will also close the stream
+        }
+    }
+}
+
+void WmfUvcDevicePort::checkConnection() const {
+    if(!isConnected(portInfo_)) {
+        throw std::runtime_error("Camera is no longer connected!");
+    }
+}
+
+STDMETHODIMP WmfUvcDevicePort::QueryInterface(REFIID iid, void **ppv) {
+#pragma warning(push)
+#pragma warning(disable : 4838)
+    static const QITAB qit[] = {
+        QITABENT(WmfUvcDevicePort, IMFSourceReaderCallback),
+        { nullptr },
+    };
+    return QISearch(this, qit, iid, ppv);
+#pragma warning(pop)
+};
+
+STDMETHODIMP_(ULONG) WmfUvcDevicePort::AddRef() {
+    return InterlockedIncrement(&refCount_);
+}
+
+STDMETHODIMP_(ULONG) WmfUvcDevicePort::Release() {
+    ULONG count = InterlockedDecrement(&refCount_);
+    // if(count <= 0) {
+    //     delete this;
+    // }
+    return count;
+}
+
+STDMETHODIMP WmfUvcDevicePort::OnReadSample(HRESULT hrStatus, DWORD streamIndex, DWORD /*dwStreamFlags*/, LONGLONG /*llTimestamp*/, IMFSample *sample) {
+    if(streamReader_) {
+        if(FAILED(hrStatus)) {
+            readSampleResult_ = hrStatus;
+        }
+        {
+            std::lock_guard<std::mutex> lock(streamsMutex_);
+            auto                       &stream = streams_[streamIndex];
+            stream.hasStarted.set();
+
+            if(!stream.streaming || !isStarted_) {
+                return S_OK;
+            }
+        }
+        LOG_HR(streamReader_->ReadSample(streamIndex, 0, nullptr, nullptr, nullptr, nullptr));  // Trigger the acquisition of the next frame of data
+
+        if(sample) {
+            CComPtr<IMFMediaBuffer> buffer = nullptr;
+            if(SUCCEEDED(sample->GetBufferByIndex(0, &buffer))) {
+                byte *byte_buffer = nullptr;
+                DWORD max_length{}, current_length{};
+                if(SUCCEEDED(buffer->Lock(&byte_buffer, &max_length, &current_length))) {
+                    std::lock_guard<std::mutex> lock(streamsMutex_);
+                    auto                       &stream = streams_[streamIndex];
+                    std::shared_ptr<VideoFrame> videoFrame;
+                    TRY_EXECUTE({
+                        auto frame = FrameFactory::createFrameFromStreamProfile(stream.profile);
+                        videoFrame = frame->as<VideoFrame>();
+                        videoFrame->updateData(byte_buffer, current_length);
+
+                        stream.frameCounter++;
+                        videoFrame->setNumber(stream.frameCounter);
+
+                        auto realtime = utils::getNowTimesUs();
+                        videoFrame->setSystemTimeStampUsec(realtime);
+                    });
+
+#ifdef METADATA_SUPPORT
+                    TRY_EXECUTE({
+                        auto metadata                     = videoFrame->getMetadataMutable();
+                        auto uvcMetadata                  = reinterpret_cast<UvcMetadata *>(metadata);
+                        uvcMetadata->header.bHeaderLength = 12;
+                        uvcMetadata->header.bmHeaderInfo  = 0;  // not used
+                        auto metadataExtraSize            = try_read_metadata(sample, uvcMetadata);
+                        /*LOG( INFO ) << "metadataSize=" << ( int )metadataSize;
+                        for ( int i = 0; i < metadataSize; i++ ) {
+                            printf( "0x%02x ", metadata[ i ] );
+                            if ( i % 16 == 15 ) {
+                                printf( "\n" );
+                            }
+                        }
+                        printf( "\n\n" );*/
+                        videoFrame->setTimeStampUsec(uvcMetadata->header.dwPresentationTime);
+                        videoFrame->setMetadataSize(uvcMetadata->header.bHeaderLength + metadataExtraSize);
+                    });
+#endif
+
+                    TRY_EXECUTE({ stream.callback(videoFrame); });
+                    buffer->Unlock();
+                }
+            }
+        }
+    }
+
+    return S_OK;
+}
+
+STDMETHODIMP WmfUvcDevicePort::OnEvent(DWORD /*sidx*/, IMFMediaEvent * /*event*/) {
+    return S_OK;
+}
+
+STDMETHODIMP WmfUvcDevicePort::OnFlush(DWORD streamIndex) {
+    streamReader_->SetStreamSelection(streamIndex, false);
+    auto &stream = streams_[streamIndex];
+    stream.isFlushed.set();
+    return S_OK;
+}
+
+}  // namespace libobsensor
+
diff --git a/src/platform/usb/uvc/WmfUvcDevicePort.hpp b/src/platform/usb/uvc/WmfUvcDevicePort.hpp
new file mode 100644
index 00000000..81a311b9
--- /dev/null
+++ b/src/platform/usb/uvc/WmfUvcDevicePort.hpp
@@ -0,0 +1,164 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include "UvcDevicePort.hpp"
+#include "stream/StreamProfile.hpp"
+#include "usb/enumerator/IUsbEnumerator.hpp"
+
+#include "WinHelpers.hpp"
+
+#include <mfapi.h>
+#include <Ks.h>
+#include <atlcomcli.h>
+#include <ksproxy.h>
+#include <mfidl.h>
+#include <mfreadwrite.h>
+#include <vidcap.h>
+#include <wrl.h>
+
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+
+#include <mutex>
+#include <atomic>
+
+static const std::vector<std::vector<std::pair<GUID, GUID>>> attributes_params = {
+    { { MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE, MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_GUID },
+      { MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_CATEGORY, KSCATEGORY_SENSOR_CAMERA } },
+    { { MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE, MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_GUID } },
+};
+
+namespace libobsensor {
+
+class WinUsbPal;
+
+struct StreamObject {
+    bool                                      streaming = false;
+    manual_reset_event                        isFlushed;
+    manual_reset_event                        hasStarted;
+    std::shared_ptr<const VideoStreamProfile> profile = nullptr;
+    uint32_t                                  frameCounter;
+    MutableFrameCallback                      callback = nullptr;
+};
+
+typedef std::function<void(const UsbInterfaceInfo &, IMFActivate *)> USBDeviceInfoEnumCallback;
+
+typedef struct FrameRate {
+    unsigned int denominator;
+    unsigned int numerator;
+} FrameRate;
+
+typedef struct MFProfile {
+    uint32_t                            index;
+    FrameRate                           min_rate;
+    FrameRate                           max_rate;
+    std::shared_ptr<VideoStreamProfile> profile;
+} MFProfile;
+
+template <class T> static void safe_release(T &ppT) {
+    if(ppT) {
+        ppT.Release();
+        ppT = NULL;
+    }
+}
+
+class WmfUvcDevicePort : public std::enable_shared_from_this<WmfUvcDevicePort>,
+                         public UvcDevicePort,
+                         public Microsoft::WRL::RuntimeClass<Microsoft::WRL::RuntimeClassFlags<Microsoft::WRL::ClassicCom>, IMFSourceReaderCallback> {
+public:
+    explicit WmfUvcDevicePort(std::shared_ptr<const USBSourcePortInfo> portInfo);
+    ~WmfUvcDevicePort() noexcept override;
+    std::shared_ptr<const SourcePortInfo> getSourcePortInfo(void) const override;
+    StreamProfileList                     getStreamProfileList() override;
+    void                                  startStream(std::shared_ptr<const StreamProfile> profile, MutableFrameCallback callback) override;
+    void                                  stopStream(std::shared_ptr<const StreamProfile> profile) override;
+    void                                  stopAllStream() override;
+
+    bool            getPu(uint32_t propertyId, int32_t &value) override;
+    bool            setPu(uint32_t propertyId, int32_t value) override;
+    UvcControlRange getPuRange(uint32_t propertyId) override;
+
+    uint32_t sendAndReceive(const uint8_t* sendData, uint32_t sendLen, uint8_t* recvData, uint32_t exceptedRecvLen) override;
+
+    static bool isConnected(std::shared_ptr<const USBSourcePortInfo> info);
+    static void foreachUvcDevice(const USBDeviceInfoEnumCallback &action);
+
+private:
+    IAMVideoProcAmp  *getVideoProc() const;
+    IAMCameraControl *getCameraControl() const;
+
+    void initXu();
+    bool getXu(uint8_t ctrl, uint8_t *data, uint32_t *len);
+    bool setXu(uint8_t ctrl, const uint8_t *data, uint32_t len);
+
+private:
+    friend class SourceReaderCallback;
+
+    void                   playProfile(std::shared_ptr<const VideoStreamProfile> profile, MutableFrameCallback callback);
+    void                   flush(int index);
+    void                   checkConnection() const;
+    CComPtr<IMFAttributes> createDeviceAttrs();
+    CComPtr<IMFAttributes> createReaderAttrs();
+    void                   foreachProfile(std::function<void(const MFProfile &profile, CComPtr<IMFMediaType> media_type, bool &quit)> action) const;
+
+    void setPowerStateD0();  // create device source and source reader
+    void setPowerStateD3();  // release device source and source reader
+    void reloadSourceAndReader();
+
+    void queryXuNodeId(const CComPtr<IKsTopologyInfo> &topologyInfo);
+
+    void initTimeoutThread();
+    void terminateTimeoutThread();
+    void addTimeoutBarrier(std::string msg);
+    void removeTimeoutBarrier();
+
+private:
+    std::recursive_mutex deviceMutex_;
+
+    std::shared_ptr<const USBSourcePortInfo> portInfo_;
+    PowerState                               powerState_ = kD3;
+
+    CComPtr<IMFMediaSource>                 deviceSource_ = nullptr;
+    CComPtr<IMFAttributes>                  deviceAttrs_  = nullptr;
+    Microsoft::WRL::ComPtr<IMFSourceReader> streamReader_;
+    CComPtr<IMFAttributes>                  readerAttrs_ = nullptr;
+
+    CComPtr<IAMCameraControl> cameraControl_ = nullptr;
+    CComPtr<IAMVideoProcAmp>  videoProc_     = nullptr;
+    CComPtr<IKsControl>       xuKsControl_;
+    int                       xuNodeId_;
+
+    HRESULT readSampleResult_ = S_OK;
+
+    std::map<uint32_t, StreamObject> streams_;  // <index, StreamObj>
+    std::mutex                       streamsMutex_;
+
+    std::atomic<bool> isStarted_ = { false };
+    std::wstring      deviceId_;
+
+    StreamProfileList profileList_;
+
+    std::string             timeoutMsg_;
+    std::mutex              timeoutMutex_;
+    std::condition_variable timeoutCondition_;
+    std::thread             timeoutThread_;
+    std::atomic_bool        timeoutThreadRun_;
+    std::atomic_bool        hasTimeoutBarrier_;
+
+public:
+    STDMETHODIMP QueryInterface(REFIID iid, void **ppv) override;
+    STDMETHODIMP_(ULONG) AddRef() override;
+    STDMETHODIMP_(ULONG) Release() override;
+    STDMETHODIMP OnReadSample(HRESULT /*hrStatus*/, DWORD dwStreamIndex, DWORD /*dwStreamFlags*/, LONGLONG /*llTimestamp*/, IMFSample *sample) override;
+    STDMETHODIMP OnEvent(DWORD /*sidx*/, IMFMediaEvent * /*event*/) override;
+    STDMETHODIMP OnFlush(DWORD) override;
+
+private:
+    long refCount_ = 1;
+};
+
+}  // namespace libobsensor
+
diff --git a/src/platform/usb/vendor/CMakeLists.txt b/src/platform/usb/vendor/CMakeLists.txt
new file mode 100644
index 00000000..ae0a28b8
--- /dev/null
+++ b/src/platform/usb/vendor/CMakeLists.txt
@@ -0,0 +1,16 @@
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+cmake_minimum_required(VERSION 3.5)
+
+
+file (GLOB _cpp_files "${CMAKE_CURRENT_LIST_DIR}/*.cpp")
+file (GLOB _head_files "${CMAKE_CURRENT_LIST_DIR}/*.hpp")
+
+foreach(_file IN ITEMS ${_cpp_files})
+        target_sources(${OB_TARGET_PAL} PRIVATE "${_file}")
+endforeach()
+
+foreach(_file IN ITEMS ${_head_files})
+        target_sources(${OB_TARGET_PAL} PRIVATE "${_file}")
+endforeach()
diff --git a/src/platform/usb/vendor/VendorUsbDevicePort.cpp b/src/platform/usb/vendor/VendorUsbDevicePort.cpp
new file mode 100644
index 00000000..2b2696f4
--- /dev/null
+++ b/src/platform/usb/vendor/VendorUsbDevicePort.cpp
@@ -0,0 +1,76 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "VendorUsbDevicePort.hpp"
+
+#include "logger/Logger.hpp"
+#include <iomanip>
+#include <sstream>
+#include <algorithm>
+
+#include "utils/Utils.hpp"
+#include "exception/ObException.hpp"
+#include "usb/enumerator/UsbEnumeratorLibusb.hpp"
+
+namespace libobsensor {
+
+VendorUsbDevicePort::VendorUsbDevicePort(const std::shared_ptr<IUsbDevice> &usbDevice, std::shared_ptr<const USBSourcePortInfo> portInfo)
+    : portInfo_(portInfo), usbDev_(usbDevice) {}
+
+VendorUsbDevicePort::~VendorUsbDevicePort() noexcept = default;
+
+uint32_t VendorUsbDevicePort::sendAndReceive(const uint8_t *sendData, uint32_t sendLen, uint8_t *recvData, uint32_t exceptedRecvLen) {
+    std::unique_lock<std::mutex> lock(mutex_);
+    auto                         libusbDevice = std::dynamic_pointer_cast<UsbDeviceLibusb>(usbDev_);
+    auto                         transferred  = libusb_control_transfer(libusbDevice->getLibusbDeviceHandle(),  //
+                                                                        0x40, 0, 0, 0,                          //
+                                                                        const_cast<uint8_t *>(sendData),        //
+                                                                        static_cast<uint16_t>(sendLen),         //
+                                                                        5000);
+    if(transferred != static_cast<int>(sendLen)) {
+        if(transferred >= 0) {
+            LOG_ERROR("Failed to send data to device. Sent: {}, Transferred: {}", sendLen, transferred);
+        }
+        else {
+            LOG_ERROR("Failed to send data to device. Error: {}", libusb_strerror(transferred));
+        }
+        return 0;
+    }
+    transferred = libusb_control_transfer(libusbDevice->getLibusbDeviceHandle(),   //
+                                          0xc0, 0, 0, 0,                           //
+                                          recvData,                                //
+                                          static_cast<uint16_t>(exceptedRecvLen),  //
+                                          5000);
+    if(transferred < 0) {
+        LOG_ERROR("Failed to receive data from device. Error: {}", libusb_strerror(transferred));
+        return 0;
+    }
+    return transferred;
+}
+
+bool VendorUsbDevicePort::readFromBulkEndPoint(std::vector<uint8_t> &data) {
+    utils::unusedVar(data);
+    std::unique_lock<std::mutex> lock(mutex_);
+    return false;
+}
+
+bool VendorUsbDevicePort::writeToBulkEndPoint(std::vector<uint8_t> &data) {
+    utils::unusedVar(data);
+    std::unique_lock<std::mutex> lock(mutex_);
+    return false;
+}
+
+std::shared_ptr<const SourcePortInfo> VendorUsbDevicePort::getSourcePortInfo() const {
+    return portInfo_;
+}
+
+#ifdef __ANDROID__
+std::string VendorUsbDevicePort::getUsbConnectType() {
+    auto                     libusbDev = std::static_pointer_cast<UsbDeviceLibusb>(usbDev_);
+    libusb_device_descriptor desc;
+    auto                     ret = libusb_get_device_descriptor(libusbDev->getDevice(), &desc);
+    return usb_spec_names.find(UsbSpec(desc.bcdUSB))->second;
+}
+#endif
+
+}  // namespace libobsensor
diff --git a/src/platform/usb/vendor/VendorUsbDevicePort.hpp b/src/platform/usb/vendor/VendorUsbDevicePort.hpp
new file mode 100644
index 00000000..5832f0ef
--- /dev/null
+++ b/src/platform/usb/vendor/VendorUsbDevicePort.hpp
@@ -0,0 +1,33 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include "ISourcePort.hpp"
+#include "usb/enumerator/IUsbEnumerator.hpp"
+#include <mutex>
+namespace libobsensor {
+
+class VendorUsbDevicePort : public IVendorDataPort {
+public:
+    VendorUsbDevicePort(const std::shared_ptr<IUsbDevice> &usbDevice, std::shared_ptr<const USBSourcePortInfo> portInfo);
+    ~VendorUsbDevicePort() noexcept override;
+
+    uint32_t sendAndReceive(const uint8_t *sendData, uint32_t sendLen, uint8_t *recvData, uint32_t exceptedRecvLen) override;
+
+    virtual bool readFromBulkEndPoint(std::vector<uint8_t> &data);  // bulk transfer
+    virtual bool writeToBulkEndPoint(std::vector<uint8_t> &data);   // bulk transfer
+
+    std::shared_ptr<const SourcePortInfo> getSourcePortInfo() const override;
+
+#ifdef __ANDROID__
+    virtual std::string getUsbConnectType();
+#endif
+
+protected:
+    std::mutex                               mutex_;
+    std::shared_ptr<const USBSourcePortInfo> portInfo_;
+    std::shared_ptr<IUsbDevice>              usbDev_;
+};
+
+}  // namespace libobsensor
+
diff --git a/src/shared/CMakeLists.txt b/src/shared/CMakeLists.txt
new file mode 100644
index 00000000..925e3078
--- /dev/null
+++ b/src/shared/CMakeLists.txt
@@ -0,0 +1,27 @@
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+cmake_minimum_required(VERSION 3.5)
+
+# add the shared library with version number
+add_library(shared STATIC)
+
+# add the shared library sources
+file(GLOB_RECURSE SOURCE_FILES "*.cpp" EXCLUDE unittest)
+file(GLOB_RECURSE HEADERS_FILES "*.hpp" EXCLUDE unittest)
+target_sources(shared PRIVATE ${SOURCE_FILES} ${HEADERS_FILES})
+
+add_subdirectory(${OB_3RDPARTY_DIR}/spdlog spdlog)
+target_link_libraries(shared PUBLIC spdlog::spdlog)
+target_include_directories(shared PUBLIC ${OB_PUBLIC_HEADERS_DIR} ${CMAKE_CURRENT_LIST_DIR})
+
+add_subdirectory(${OB_3RDPARTY_DIR}/tinyxml2 tinyxml2)
+target_link_libraries(shared PUBLIC tinyxml2::tinyxml2)
+
+add_subdirectory(environment)
+target_link_libraries(shared PUBLIC ob::env_config_rc)
+
+add_library(ob::shared ALIAS shared)
+ob_source_group(ob::shared)
+set_target_properties(shared PROPERTIES FOLDER "modules")
+
diff --git a/src/shared/InternalTypes.hpp b/src/shared/InternalTypes.hpp
new file mode 100644
index 00000000..717ca4f2
--- /dev/null
+++ b/src/shared/InternalTypes.hpp
@@ -0,0 +1,184 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include <stdint.h>
+#include <stdbool.h>
+
+#pragma pack(push, 1)
+
+/**
+ *@brief device version information
+ */
+typedef struct {
+    char    firmwareVersion[16];   ///< Such as: 1.2.18
+    char    hardwareVersion[16];   ///< Such as: 1.0.18
+    char    sdkVersion[16];        ///< The lowest supported SDK version number, SDK version number: 2.3.2 (major.minor.revision)
+    char    depthChip[16];         ///< Such as：mx6000, mx6600
+    char    systemChip[16];        ///< Such as：ar9201
+    char    serialNumber[16];      ///< serial number
+    int32_t deviceType;            ///< 1:Monocular 2:binocular 3:tof. enumeration value
+    char    deviceName[16];        ///< device name，such as: astra+
+    char    subSystemVersion[16];  ///< For example，such as：Femto’s MCU firmware version 1.0.23
+    char    reserved[32];          ///< Reserved
+} OBVersionInfo;
+
+/**
+ *@brief device time
+ */
+typedef struct {
+    uint64_t time;  ///< sdk->dev: timing time; dev->sdk: current time of device;
+    uint64_t rtt;   ///< sdk->dev: command round-trip time, the device sets the time to time+rtt/2 after receiving it; dev->sdk: reserved; unit: ms
+} OBDeviceTime, ob_device_time;
+
+/**
+ *@brief Post-process parameters after depth align to color
+ *
+ */
+typedef struct {
+    float   depthScale;   // Depth frame scaling ratio
+    int16_t alignLeft;    // Depth aligned to left after Color
+    int16_t alignTop;     // Depth aligned to the top after Color
+    int16_t alignRight;   // Depth aligned to right after Color
+    int16_t alignBottom;  // Depth aligned to the bottom after Color
+} OBD2CPostProcessParam, ob_d2c_post_process_param;
+
+typedef enum {
+    ALIGN_UNSUPPORTED    = 0,
+    ALIGN_D2C_HW         = 1,
+    ALIGN_D2C_SW         = 2,
+    ALIGN_D2C_HW_SW_BOTH = 3,
+} OBAlignSupportedType,
+    ob_align_supported_type;
+
+/**
+ *@brief Supported depth align color profile
+ *
+ */
+typedef struct {
+    uint16_t              colorWidth;
+    uint16_t              colorHeight;
+    uint16_t              depthWidth;
+    uint16_t              depthHeight;
+    uint8_t               alignType;
+    uint8_t               paramIndex;
+    OBD2CPostProcessParam postProcessParam;
+} OBD2CProfile, ob_d2c_supported_profile_info;
+
+typedef struct {
+    uint32_t depthMode;    ///< Monocular/Binocular
+    float    baseline;     ///< baseline distance
+    float    z0;           ///< Calibration distance
+    float    focalPix;     ///< Focal length used for depth calculation or focal length f after rectify
+    float    unit;         ///< Unit x1 mm, such as: unit=0.25, means 0.25*1mm=0.25mm
+    float    dispOffset;   ///< Parallax offset, real parallax = chip output parallax + disp_offset
+    int32_t  invalidDisp;  ///< Invalid parallax, usually 0; when the chip min_disp is not equal to 0 or -128, the invalid parallax is no longer equal to 0
+} OBDepthCalibrationParam;
+
+typedef enum {
+    OB_DISP_PACK_ORIGINAL     = 0,  // MX6000 Parallax
+    OB_DISP_PACK_OPENNI       = 1,  // OpenNI disparity
+    OB_DISP_PACK_ORIGINAL_NEW = 2,  // MX6600 Parallax
+    OB_DISP_PACK_GEMINI2XL    = 3,  // Gemini2XL parallax
+} OBDisparityPackMode;
+
+/**
+ *@brief Structure for distortion parameters
+ */
+typedef struct {
+    float k1;  ///< Radial distortion factor 1
+    float k2;  ///< Radial distortion factor 2
+    float k3;  ///< Radial distortion factor 3
+    float k4;  ///< Radial distortion factor 4
+    float k5;  ///< Radial distortion factor 5
+    float k6;  ///< Radial distortion factor 6
+    float p1;  ///< Tangential distortion factor 1
+    float p2;  ///< Tangential distortion factor 2
+} OBCameraDistortion_Internal;
+
+typedef struct {
+    OBCameraIntrinsic           depthIntrinsic;   ///< Depth camera internal parameters
+    OBCameraIntrinsic           rgbIntrinsic;     ///< Color camera internal parameters
+    OBCameraDistortion_Internal depthDistortion;  ///< Depth camera distortion parameters
+
+    OBCameraDistortion_Internal rgbDistortion;  ///< Distortion parameters for color camera
+    OBD2CTransform              transform;      ///< Rotation/transformation matrix
+} OBCameraParam_Internal_V0;
+
+typedef struct {
+    uint8_t  checksum[16];  ///< The camera depth mode corresponds to the hash binary array
+    char     name[32];      ///< name
+    uint32_t optionCode;    // OBDepthModeOptionCode
+} OBDepthWorkMode_Internal;
+
+typedef enum {
+    NORMAL                             = 0,           // Normal mode, no special processing required
+    MX6600_RIGHT_IR_FROM_DEPTH_CHANNEL = 2,           // Gemini2 calibration mode, right IR data goes through the depth channel
+    RIGHT_IR_NO_FROM_DEPTH_CHANNEL     = 4,           // Gemini2XL, right IR goes to the right IR channel
+    INVALID                            = 0xffffffff,  // Invalid value
+} OBDepthModeOptionCode;
+
+// Orbbec Magnetometer model
+typedef struct {
+    double referenceTemp;    ///< Reference temperature
+    double tempSlope[9];     ///< Temperature slope (linear thermal drift coefficient)
+    double misalignment[9];  ///< Misalignment matrix
+    double softIron[9];      ///< Soft iron effect matrix
+    double scale[3];         ///< Scale vector
+    double hardIron[3];      ///< Hard iron bias
+} OBMagnetometerIntrinsic;
+
+// Single IMU parameters
+typedef struct {
+    char                    name[12];                   /// ＜ imu name
+    uint16_t                version;                    ///< IMU calibration library version number
+    uint16_t                imuModel;                   ///< IMU model
+    double                  body_to_gyroscope[9];       ///< Rotation from body coordinate system to gyroscope coordinate system
+    double                  acc_to_gyro_factor[9];      ///< Influence factor of accelerometer measurements on gyroscope measurements
+    OBAccelIntrinsic        acc;                        ///< Accelerometer model
+    OBGyroIntrinsic         gyro;                       ///< Gyroscope model
+    OBMagnetometerIntrinsic mag;                        ///< Magnetometer model
+    double                  timeshift_cam_to_imu;       ///< Time offset between camera and IMU
+    double                  imu_to_cam_extrinsics[16];  ///< Extrinsic parameters from IMU to Cam(Depth)
+} OBSingleIMUParams;
+
+// IMU Calibration Parameters
+typedef struct {
+    uint8_t           validNum;            ///< Number of valid IMUs
+    OBSingleIMUParams singleIMUParams[3];  ///< Array of single IMU parameter models
+} OBIMUCalibrateParams;
+
+/**
+ *@brief List of resolutions supported by the device in the current camera depth mode
+ *
+ */
+typedef struct {
+    OBSensorType sensorType;  ///< sensor type
+    OBFormat     format;      ///< Image format
+    uint32_t     width;       ///< image width
+    uint32_t     height;      ///< Image height
+    uint32_t     maxFps;      ///< Maximum supported frame rate
+} OBEffectiveStreamProfile, ob_effective_stream_profile;
+
+typedef struct {
+    uint16_t sensorType;  // enum value of OBSensorType
+    union Profile {
+        struct Video {  // This structure is used for Color, IR, and Depth
+            uint32_t width;
+            uint32_t height;
+            uint32_t fps;
+            uint32_t formatFourcc;  // Example: {'Y', 'U', 'Y', 'V'} // fourcc is a common concept in UVC
+        } video;
+        struct Accel {                // This structure is used for Accel
+            uint16_t fullScaleRange;  // enum value of OBAccelFullScaleRange
+            uint16_t sampleRate;      // enum value of OBAccelSampleRate
+        } accel;
+        struct Gyro {                 // This structure is used for Gyro
+            uint16_t fullScaleRange;  // enum value of OBGyroFullScaleRange
+            uint16_t sampleRate;      // enum value of OBGyroSampleRate
+        } gyro;
+    } profile;
+} OBInternalStreamProfile;
+
+#pragma pack(pop)
diff --git a/src/shared/environment/.gitignore b/src/shared/environment/.gitignore
new file mode 100644
index 00000000..dc96b555
--- /dev/null
+++ b/src/shared/environment/.gitignore
@@ -0,0 +1 @@
+Version.hpp
\ No newline at end of file
diff --git a/src/shared/environment/CMakeLists.txt b/src/shared/environment/CMakeLists.txt
new file mode 100644
index 00000000..fe9f26f2
--- /dev/null
+++ b/src/shared/environment/CMakeLists.txt
@@ -0,0 +1,27 @@
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+include(${OB_3RDPARTY_DIR}/cmrc/src/cmake_resource.cmake)
+
+cmrc_add_resource_library(
+    env_config_rc
+    NAMESPACE
+    ob
+    WHENCE
+    ./
+    PREFIX
+    config
+    ./OrbbecSDKConfig.xml
+)
+
+add_library(ob::env_config_rc ALIAS env_config_rc)
+set_target_properties(env_config_rc PROPERTIES FOLDER "dependencies")
+
+configure_file(${CMAKE_CURRENT_LIST_DIR}/Version.hpp.in ${CMAKE_CURRENT_LIST_DIR}/Version.hpp)
+
+if(OB_IS_MAIN_PROJECT)
+    install(FILES ${CMAKE_CURRENT_LIST_DIR}/OrbbecSDKConfig.xml DESTINATION shared)
+    install(FILES ${CMAKE_CURRENT_LIST_DIR}/OrbbecSDKConfig.md DESTINATION shared)
+    install(FILES ${CMAKE_CURRENT_LIST_DIR}/OrbbecSDKConfig.xml DESTINATION bin)
+    install(FILES ${CMAKE_CURRENT_LIST_DIR}/OrbbecSDKConfig.md DESTINATION bin)
+endif()
diff --git a/src/shared/environment/EnvConfig.cpp b/src/shared/environment/EnvConfig.cpp
new file mode 100644
index 00000000..1ccffb90
--- /dev/null
+++ b/src/shared/environment/EnvConfig.cpp
@@ -0,0 +1,115 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "EnvConfig.hpp"
+#include "utils/Utils.hpp"
+#include "exception/ObException.hpp"
+#include <cmrc/cmrc.hpp>
+CMRC_DECLARE(ob);
+
+namespace libobsensor {
+
+std::mutex               EnvConfig::instanceMutex_;
+std::weak_ptr<EnvConfig> EnvConfig::instanceWeakPtr_;
+
+std::shared_ptr<EnvConfig> EnvConfig::getInstance(const std::string &configFilePath) {
+    std::unique_lock<std::mutex> lock(instanceMutex_);
+    auto                         ctxInstance = instanceWeakPtr_.lock();
+    if(!ctxInstance) {
+        ctxInstance      = std::shared_ptr<EnvConfig>(new EnvConfig(configFilePath));
+        instanceWeakPtr_ = ctxInstance;
+    }
+    return ctxInstance;
+}
+
+#ifdef __ANDROID__
+constexpr const char *defaultConfigFile = "/sdcard/orbbec/OrbbecSDKConfig.xml";
+#else
+constexpr const char *defaultConfigFile = "./OrbbecSDKConfig.xml";
+#endif
+
+EnvConfig::EnvConfig(const std::string &configFile) {
+    // add external config file
+    auto extConfigFile = configFile;
+    if(extConfigFile.empty()) {
+        extConfigFile = defaultConfigFile;
+    }
+    if(utils::fileExists(extConfigFile.c_str())) {
+        TRY_EXECUTE({
+            auto xmlReader = std::make_shared<XmlReader>(extConfigFile);
+            xmlReaders_.push_back(xmlReader);
+        });
+    }
+
+    // add default config file (binary resource compiled into the library via [cmrc](https://github.com/vector-of-bool/cmrc))
+    auto fs           = cmrc::ob::get_filesystem();
+    auto def_xml      = fs.open("config/OrbbecSDKConfig.xml");
+    auto defXmlReader = std::make_shared<XmlReader>(def_xml.begin(), def_xml.size());
+    xmlReaders_.push_back(defXmlReader);
+}
+
+bool EnvConfig::isNodeContained(const std::string &nodePathName) {
+    for(auto xmlReader: xmlReaders_) {
+        if(xmlReader->isNodeContained(nodePathName)) {
+            return true;
+        }
+    }
+    return false;
+}
+
+bool EnvConfig::getIntValue(const std::string &nodePathName, int &t) {
+    for(auto xmlReader: xmlReaders_) {
+        if(xmlReader->getIntValue(nodePathName, t)) {
+            return true;
+        }
+    }
+    return false;
+}
+
+bool EnvConfig::getBooleanValue(const std::string &nodePathName, bool &t) {
+    for(auto xmlReader: xmlReaders_) {
+        if(xmlReader->getBooleanValue(nodePathName, t)) {
+            return true;
+        }
+    }
+    return false;
+}
+
+bool EnvConfig::getFloatValue(const std::string &nodePathName, float &t) {
+    for(auto xmlReader: xmlReaders_) {
+        if(xmlReader->getFloatValue(nodePathName, t)) {
+            return true;
+        }
+    }
+    return false;
+}
+
+bool EnvConfig::getDoubleValue(const std::string &nodePathName, double &t) {
+    for(auto xmlReader: xmlReaders_) {
+        if(xmlReader->getDoubleValue(nodePathName, t)) {
+            return true;
+        }
+    }
+    return false;
+}
+
+bool EnvConfig::getStringValue(const std::string &nodePathName, std::string &t) {
+    for(auto xmlReader: xmlReaders_) {
+        if(xmlReader->getStringValue(nodePathName, t)) {
+            return true;
+        }
+    }
+    return false;
+}
+
+std::string EnvConfig::extensionsDir_ = "./extensions";
+
+const std::string &EnvConfig::getExtensionsDirectory() {
+    return extensionsDir_;
+}
+
+void EnvConfig::setExtensionsDirectory(const std::string &dir) {
+    extensionsDir_ = dir;
+}
+
+}  // namespace libobsensor
diff --git a/src/shared/environment/EnvConfig.hpp b/src/shared/environment/EnvConfig.hpp
new file mode 100644
index 00000000..9922828d
--- /dev/null
+++ b/src/shared/environment/EnvConfig.hpp
@@ -0,0 +1,40 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include "xml/XmlReader.hpp"
+#include "libobsensor/h/ObTypes.h"
+#include <string>
+
+namespace libobsensor {
+
+class EnvConfig {
+
+    explicit EnvConfig(const std::string &configFilePath);
+
+    static std::mutex               instanceMutex_;
+    static std::weak_ptr<EnvConfig> instanceWeakPtr_;
+
+    static std::string extensionsDir_;
+
+public:
+    static std::shared_ptr<EnvConfig> getInstance(const std::string &configFilePath = "");
+
+    ~EnvConfig() noexcept = default;
+
+    bool isNodeContained(const std::string &nodePathName);
+    bool getIntValue(const std::string &nodePathName, int &t);
+    bool getBooleanValue(const std::string &nodePathName, bool &t);
+    bool getFloatValue(const std::string &nodePathName, float &t);
+    bool getDoubleValue(const std::string &nodePathName, double &t);
+    bool getStringValue(const std::string &nodePathName, std::string &t);
+
+    static const std::string &getExtensionsDirectory();
+    static void               setExtensionsDirectory(const std::string &dir);
+
+private:
+    std::vector<std::shared_ptr<XmlReader>> xmlReaders_;
+};
+
+}  // namespace libobsensor
+
diff --git a/src/shared/environment/OrbbecSDKConfig.md b/src/shared/environment/OrbbecSDKConfig.md
new file mode 100644
index 00000000..df1a7f98
--- /dev/null
+++ b/src/shared/environment/OrbbecSDKConfig.md
@@ -0,0 +1,222 @@
+# Orbbec SDK Configuration File Introduction (OrbbecSDKConfig_v1.0.xml)
+
+The Orbbec SDK configuration file is an XML file that defines the global configuration of the Orbbec SDK.
+
+Upon initialization, the SDK Context will load a configuration file and apply as global configurations. If you have your own configuration file, you can specify it by entering the file path when calling the Context constructor. If you don't provide a path (or input an empty string), the SDK will look for a file named `OrbbecSDKConfig.xml` in the working directory. If neither the specified file nor the default file is found, the SDK will revert to using the built-in default configuration file.
+
+## Log Configuration
+
+Log configuration mainly sets the Log level, the Log level output to the console, the Log level output to a file, configures the path for saving Log files, sets the size of each Log file, and sets the number of Log files.
+
+```cpp
+    <Log>
+        <!--Log output level, int type, optional values: 0-DEBUG, 1-INFO, 2-WARN, 3-ERROR, 4-FATAL, 5-OFF-->
+        <!--Log level configuration execution priority: 0. Application code configuration > 1. Detailed configuration of configuration file (file & console configuration) > 2. Global configuration of configuration file > 3. SDK code default configuration (file: 0, terminal: 1)-->
+        <!--Global log output level-->
+        <LogLevel>0</LogLevel>
+        <!--File log output level-->
+        <FileLogLevel>0</FileLogLevel>
+        <!--Console log output level-->
+        <ConsoleLogLevel>1</ConsoleLogLevel>
+        <!--Default log output file path, string type. If this item is not configured, the default path will be used: Win/Linux: "./Log"; Android: "/sdcard/Orbbec/Log"-->
+        <!--<OutputDir>./log</OutputDir>-->
+        <!--Default log output file size, int type, unit: MB-->
+        <MaxFileSize>100</MaxFileSize>
+        <!--Default log output file number (circular overwrite), int type-->
+        <MaxFileNum>3</MaxFileNum>
+        <!--Log asynchronous output, changing to asynchronous output can reduce the blocking time of printing logs, but some logs may be lost when the program exits abnormally; true-enable, false-disable (default)-->
+        <Async>false</Async>
+    </Log>
+```
+
+## Memory Configuration
+
+```cpp
+    <Memory>
+        <!--Enable memory pool to reuse frame memory, avoid frequent memory allocation and release. true-enable, false-disable)-->
+        <EnableMemoryPool> true </EnableMemoryPool>
+        <!--Maximum memory size of all data frames, int type, unit: MB, minimum 100MB-->
+        <MaxFrameBufferSize> 2048 </MaxFrameBufferSize>
+        <!--Frame buffer queue size in pipeline-->
+        <PipelineFrameQueueSize>10</PipelineFrameQueueSize>
+        <!--Frame buffer queue size in internal processing unit-->
+        <FrameProcessingBlockQueueSize>10</FrameProcessingBlockQueueSize>
+    </Memory>
+```
+
+**Notes**
+
+1. The default size of the memory pool is 2GB (2048MB).
+```cpp
+        <MaxFrameBufferSize> 2048 </MaxFrameBufferSize>
+```
+2. The default number of frame buffere queue in the Pipeline is 10. If the host machine processes slowly, the SDK will buffer up to 10 frames internally, which may affect the delay time in retrieving frames by the user. If the delay is significant, you can reduce the number of buffers.
+```cpp
+        <PipelineFrameQueueSize>10</PipelineFrameQueueSize>
+```
+
+3. The default number of queues in the internal processing unit (Processing unit) is 10. If the host machine processes slowly, the SDK will buffer up to 10 frames internally, which may affect the delay time in retrieving frames by the user. If the delay is significant, you can reduce the number of queues.
+```cpp
+        <FrameProcessingBlockQueueSize>10</FrameProcessingBlockQueueSize>
+```
+
+## Global Timestamp
+
+Based on the device's timestamp and considering data transmission delays, the timestamp is converted to the system timestamp dimension through linear regression. It can be used to synchronize timestamps of multiple different devices. The implementation plan is as follows:
+
+1. Global timestamp fitter: Regularly obtain the device timestamp and the current system timestamp, and calculate the fitting equation parameters using a linear regression method.
+2. Global timestamp converter: Convert the data frame timestamp unit to the same unit as the device timestamp, then calculate the overflow times according to the device timestamp to convert to a 64-bit timestamp, and then convert to a global timestamp according to the fitting parameters output by the global timestamp fitter.
+
+```cpp
+    <Misc>
+        <GlobalTimestampFitterEnable>true</GlobalTimestampFitterEnable>
+        <!--Global timestamp fitter refresh interval, unit: milliseconds, default value: 1000, minimum value: 100, it is recommended not to be greater than 1000 -->
+        <GlobalTimestampFitterInterval>1000</GlobalTimestampFitterInterval>
+        <!--Global timestamp fitter queue size, default value: 100, minimum value: 20 -->
+        <GlobalTimestampFitterQueueSize>100</GlobalTimestampFitterQueueSize>
+    </Misc>
+```
+
+1. By default, the device time is obtained every eight seconds to update the global timestamp fitter.
+```cpp
+        <GlobalTimestampFitterInterval>1000</GlobalTimestampFitterInterval>
+```
+
+2. The default queue size of the global timestamp fitter is 10.
+```cpp
+        <GlobalTimestampFitterQueueSize>100</GlobalTimestampFitterQueueSize>
+```
+
+**Notes**
+
+1. The global timestamp mainly supports the Gemini 330 series. Gemini 2, Gemini 2L, Femto Mega, and Femto Bolt are also supported but not thoroughly tested. If there are stability issues with these devices, the global timestamp function can be turned off.
+```cpp
+        <GlobalTimestampFitterEnable>false</GlobalTimestampFitterEnable>
+```
+
+## Pipeline Configuration
+
+```cpp
+    <!--Default working configuration of pipeline-->
+    <Pipeline>
+        <Stream>
+            <Depth>
+                <!--Use default stream profile, bool type, true: use default stream profile, false: use specified stream profile in the configuration file-->
+                <UseDefaultStreamProfile>true</UseDefaultStreamProfile>
+            </Depth>
+            <Color>
+                <UseDefaultStreamProfile>true</UseDefaultStreamProfile>
+            </Color>
+            <!--If you need to open other streams, you can refer to the above format to add configuration-->
+        </Stream>
+        <!--Image alignment, int type, optional values: 0 disable, 1 hardware d2c alignment, 2 software d2c alignment-->
+        <AlignMode>0</AlignMode>
+        <!--Frame synchronization output between different data streams, bool type, true-enable frame synchronization, false-disable frame synchronization-->
+        <FrameSync>false</FrameSync>
+    </Pipeline>
+```
+
+1. Pipeline primarily sets which video streams to enable. By default, only Depth and Color streams are enabled. You can add to enable IR streams, left IR, and right IR as follows.
+```cpp
+<!--If you need to open other streams, you can refer to the above format to add configuration-->
+            <IR>
+                <UseDefaultStreamProfile>true</UseDefaultStreamProfile>
+            </IR>
+            <LeftIR>
+                <UseDefaultStreamProfile>true</UseDefaultStreamProfile>
+            </LeftIR>
+            <RightIR>
+                <UseDefaultStreamProfile>true</UseDefaultStreamProfile>
+            </RightIR>
+```
+2. Pipeline can set D2C, such as hardware D2C and software D2C. Some devices do not support hardware D2C, such as Femto Bolt. If you need to use various different types of devices, it is recommended to set this in the user code based on the device type.
+```cpp
+  <AlignMode>0</AlignMode>
+```
+3. Pipeline can set frame synchronization. Enabling frame synchronization will match Depth, Color, and other video frames based on the timestamp and output them as FrameSet within the Pipeline.
+```cpp
+        <FrameSync>false</FrameSync>
+```
+
+## Device Configuration
+
+```cpp
+    <!--Default configuration of data streams for different types of devices-->
+    <Device>
+        <EnumerateNetDevice>false</EnumerateNetDevice>
+        <!--UVC Backend select on Linux; optional values: Auto, V4L2, LibUVC; Auto is the default value-->
+        <LinuxUVCBackend>LibUVC</LinuxUVCBackend>
+
+            <!--Gemini 335 config-->
+        <Gemini335>
+	        <!--Whether to enable heartbeat by default-->
+	        <DefaultHeartBeat>0</DefaultHeartBeat>
+
+			<Depth>
+			    <!--Number of retries for open stream failures, 0 means no retries-->
+				<StreamFailedRetry>0</StreamFailedRetry>
+				<!--Open flow waits for the timeout period of the first frame of data, after which the open flow will fail-->
+				<MaxStartStreamDelayMs>5000</MaxStartStreamDelayMs>
+				<!--The number of data stream restarts due to abnormal interruption, 0 means no restart-->
+				<StreamInterruptedRestart>0</StreamInterruptedRestart>
+				<!--The maximum frame interval time, if this value is exceeded, it will be judged that the stream is interrupted-->
+				<MaxFrameIntervalMs>2000</MaxFrameIntervalMs>
+                <!--The resolution width is enabled by default, int type-->
+                <Width>848</Width>
+                <!--High resolution is enabled by default, int type-->
+                <Height>480</Height>
+                <!--The frame rate of the resolution enabled by default, int type-->
+                <FPS>30</FPS>
+                <Format>Y16</Format>
+            </Depth>
+            <Color>
+                <!--The resolution width is enabled by default, int type-->
+                <Width>1280</Width>
+                <!--High resolution is enabled by default, int type-->
+                <Height>720</Height>
+                <!--The frame rate of the resolution enabled by default, int type-->
+                <FPS>30</FPS>
+                <Format>MJPG</Format>
+            </Color>
+            <IR>
+                <!--The resolution width is enabled by default, int type-->
+                <Width>848</Width>
+                <!--High resolution is enabled by default, int type-->
+                <Height>480</Height>
+                <!--The frame rate of the resolution enabled by default, int type-->
+                <FPS>30</FPS>
+                <Format>Y8</Format>
+            </IR>
+			<LeftIR>
+                <!--The resolution width is enabled by default, int type-->
+                <Width>848</Width>
+                <!--High resolution is enabled by default, int type-->
+                <Height>480</Height>
+                <!--The frame rate of the resolution enabled by default, int type-->
+                <FPS>30</FPS>
+                <Format>Y8</Format>
+            </LeftIR>
+			<RightIR>
+                <!--The resolution width is enabled by default, int type-->
+                <Width>848</Width>
+                <!--High resolution is enabled by default, int type-->
+                <Height>480</Height>
+                <!--The frame rate of the resolution enabled by default, int type-->
+                <FPS>30</FPS>
+                <Format>Y8</Format>
+            </RightIR>
+        </Gemini335>
+    </Device>
+```
+
+1. Set whether to enumerate network devices. Femto Mega and Gemini 2 XL support network functions. If you need to use the network functions of these two devices, you can set this to true.
+```cpp
+        <EnumerateNetDevice>false</EnumerateNetDevice>
+```
+
+2. Set whether to use LibUVC or V4L2 to receive data on Linux or ARM. V4L2 is not supported by all devices, and we recommend using LibUVC. The Gemini 330 series devices support V4L2, but kernel patches are needed to obtain Metadata data.
+```cpp
+        <LinuxUVCBackend>LibUVC</LinuxUVCBackend>
+```
+
+3. Set the resolution, frame rate, and data format.
\ No newline at end of file
diff --git a/src/shared/environment/OrbbecSDKConfig.xml b/src/shared/environment/OrbbecSDKConfig.xml
new file mode 100644
index 00000000..2699ee28
--- /dev/null
+++ b/src/shared/environment/OrbbecSDKConfig.xml
@@ -0,0 +1,3054 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Config>
+    <!-- Configuration file standard version. If you are not an SDK developer, please do not modify
+    it, otherwise the configuration function may fail. -->
+    <ConfigStandardVersion>1.1</ConfigStandardVersion>
+
+    <Log>
+        <!-- Log output level, int type, optional values: 0-DEBUG, 1-INFO, 2-WARN, 3-ERROR, 4-FATAL,
+        5-OFF -->
+        <!-- File log output level -->
+        <FileLogLevel>5</FileLogLevel>
+        <!-- Console log output level -->
+        <ConsoleLogLevel>3</ConsoleLogLevel>
+        <!-- Default log output file path, string type. If this item is not configured, the default
+        path will be used: Win/Linux: "./Log"; Android: "/sdcard/orbbec/Log" -->
+        <!-- <OutputDir>./log</OutputDir> -->
+        <!-- Default log output file size, int type, unit: MB -->
+        <MaxFileSize>100</MaxFileSize>
+        <!-- Default log output file number (circular overwrite), int type -->
+        <MaxFileNum>3</MaxFileNum>
+        <!-- Log asynchronous output, changing to asynchronous output can reduce the blocking time
+        of printing logs, but some logs may be lost when the program exits abnormally; true-enable,
+        false-disable (default) -->
+        <Async>false</Async>
+    </Log>
+
+    <Memory>
+        <!-- Enable memory pool to reuse frame memory, avoid frequent memory allocation and release.
+        true-enable, false-disable) -->
+        <EnableMemoryPool>true</EnableMemoryPool>
+        <!-- Maximum memory size of all data frames, int type, unit: MB, minimum 100MB -->
+        <MaxFrameBufferSize>2048</MaxFrameBufferSize>
+        <!-- Frame buffer queue size in pipeline -->
+        <PipelineFrameQueueSize>10</PipelineFrameQueueSize>
+        <!-- Frame buffer queue size in internal processing unit -->
+        <FrameProcessingBlockQueueSize>10</FrameProcessingBlockQueueSize>
+    </Memory>
+
+    <Misc>
+        <GlobalTimestampFitterEnable>false</GlobalTimestampFitterEnable>
+        <!-- Global timestamp fitter refresh interval, unit: milliseconds, default value: 1000,
+        minimum value: 100, it is recommended not to be greater than 1000 -->
+        <GlobalTimestampFitterInterval>1000</GlobalTimestampFitterInterval>
+        <!-- Global timestamp fitter queue size, default value: 100, minimum value: 20 -->
+        <GlobalTimestampFitterQueueSize>100</GlobalTimestampFitterQueueSize>
+    </Misc>
+
+    <!-- Default working configuration of pipeline -->
+    <Pipeline>
+        <Stream>
+            <Depth>
+                <!-- Use default stream profile, bool type, true： use default stream profile,
+                false：use specified stream profile in the configuration file -->
+                <UseDefaultStreamProfile>true</UseDefaultStreamProfile>
+            </Depth>
+            <Color>
+                <UseDefaultStreamProfile>true</UseDefaultStreamProfile>
+                <![CDATA[
+                    <!--  Set UseDefaultStreamProfile to false to use the specified stream profile in the configuration file -->
+                    <UseDefaultStreamProfile>false</UseDefaultStreamProfile>
+                    <!-- Width of the resolution, int type -->
+                    <Width>1920</Width>
+                    <!-- Height of the resolution, int type -->
+                    <Height>1080</Height>
+                    <!-- Frame rate, int type -->
+                    <FPS>30</FPS>
+                    <!-- frame format -->
+                    <Format>MJPG</Format>
+                ]]>
+            </Color>
+            <!-- If you need to open other streams, you can refer to the above configuration to add -->
+        </Stream>
+        <!-- Image alignment, int type, optional values: 0 disable, 1 hardware d2c alignment, 2
+        software d2c alignment -->
+        <AlignMode>0</AlignMode>
+        <!-- Frame synchronization output between different data streams, bool type, true-enable
+        frame synchronization, false-disable frame synchronization -->
+        <FrameSync>false</FrameSync>
+    </Pipeline>
+
+    <!-- Default configuration of data streams for different types of devices -->
+    <Device>
+        <!-- Whether to enumerate network devices, bool type, true-enable, false-disable (default) -->
+        <EnumerateNetDevice>false</EnumerateNetDevice>
+
+        <!-- UVC Backend select on Linux; optional values: Auto, V4L2, LibUVC; Auto is the default
+        value -->
+        <LinuxUVCBackend>LibUVC</LinuxUVCBackend>
+
+        <!-- Frame metadata parsing path; optinal values: PayloadHeader, ExtensionHeader-->
+        <FrameMetadataParsingPath>ExtensionHeader</FrameMetadataParsingPath>
+
+        <!-- The device corresponding to Astra adv is astra+ -->
+        <AstraAdv>
+            <Depth>
+                <!-- The width of the default resolution, int type -->
+                <Width>640</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>480</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>30</FPS>
+                <!-- Default frame format -->
+                <Format>Y16</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+                <!-- Profile filter, you can configure unwanted resolution, format, frame rate
+                related profile, use '|' to add multiple options, the filter is not turned on by
+                default -->
+                <![CDATA[
+                <ProfileFilter>
+					<profile>
+						<Width>640</Width>
+						<Height>480</Height>
+						<FPS>30|10</FPS>
+						<Format>Y11|Y16</Format>
+					</profile>
+					<profile>
+						<Width>1280</Width>
+						<Height>1024</Height>
+					</profile>
+				</ProfileFilter>
+                ]]>
+            </Depth>
+            <Color>
+                <!-- The width of the default resolution, int type -->
+                <Width>640</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>480</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>30</FPS>
+                <!-- Default frame format -->
+                <Format>MJPG</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+            </Color>
+            <IR>
+                <!-- The width of the default resolution, int type -->
+                <Width>640</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>480</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>30</FPS>
+                <!-- Default frame format -->
+                <Format>Y16</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+            </IR>
+        </AstraAdv>
+
+        <Femto>
+            <Depth>
+                <!-- The width of the default resolution, int type -->
+                <Width>640</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>480</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>30</FPS>
+                <!-- Default frame format -->
+                <Format>Y16</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+            </Depth>
+            <Color>
+                <!-- The width of the default resolution, int type -->
+                <Width>640</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>480</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>30</FPS>
+                <!-- Default frame format -->
+                <Format>MJPG</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+            </Color>
+            <IR>
+                <!-- The width of the default resolution, int type -->
+                <Width>640</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>480</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>30</FPS>
+                <!-- Default frame format -->
+                <Format>Y16</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+            </IR>
+        </Femto>
+
+        <FemtoW>
+            <Depth>
+                <!-- The width of the default resolution, int type -->
+                <Width>640</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>480</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>30</FPS>
+                <!-- Default frame format -->
+                <Format>Y16</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+            </Depth>
+            <Color>
+                <!-- The width of the default resolution, int type -->
+                <Width>640</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>480</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>30</FPS>
+                <!-- Default frame format -->
+                <Format>MJPG</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+            </Color>
+            <IR>
+                <!-- The width of the default resolution, int type -->
+                <Width>640</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>480</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>30</FPS>
+                <!-- Default frame format -->
+                <Format>Y16</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+            </IR>
+        </FemtoW>
+
+        <FemtoLive>
+            <Depth>
+                <!-- The width of the default resolution, int type -->
+                <Width>640</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>480</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>30</FPS>
+                <!-- Default frame format -->
+                <Format>Y16</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+            </Depth>
+            <Color>
+                <!-- The width of the default resolution, int type -->
+                <Width>640</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>480</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>30</FPS>
+                <!-- Default frame format -->
+                <Format>MJPG</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+            </Color>
+            <IR>
+                <!-- The width of the default resolution, int type -->
+                <Width>640</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>480</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>30</FPS>
+                <!-- Default frame format -->
+                <Format>Y16</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+            </IR>
+        </FemtoLive>
+
+        <FemtoMega>
+            <Depth>
+                <!-- The width of the default resolution, int type -->
+                <Width>640</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>576</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>30</FPS>
+                <!-- Default frame format -->
+                <Format>Y16</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+                <!-- The maximum open-flow delay, unit: ms; if the first frame of data is not
+                received after the open-flow exceeds this time, the open-flow will be considered as
+                a failure -->
+                <MaxStartStreamDelayMs>5000</MaxStartStreamDelayMs>
+                <!-- Stream interruption restart, 0 does not restart, >=1 consecutive restart
+                attempts -->
+                <StreamInterruptedRestart>0</StreamInterruptedRestart>
+                <!-- The maximum frame interval time, unit: ms; if no new data frame is received
+                beyond the maximum interval time, the stream is considered to be interrupted -->
+                <MaxFrameIntervalMs>5000</MaxFrameIntervalMs>
+            </Depth>
+
+            <Color>
+                <!-- The width of the default resolution, int type -->
+                <Width>1920</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>1080</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>30</FPS>
+                <!-- Default frame format -->
+                <Format>MJPG</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+                <!-- The maximum open-flow delay, unit: ms; if the first frame of data is not
+                received after the open-flow exceeds this time, the open-flow will be considered as
+                a failure -->
+                <MaxStartStreamDelayMs>5000</MaxStartStreamDelayMs>
+                <!-- Stream interruption restart, 0 does not restart, >=1 consecutive restart
+                attempts -->
+                <StreamInterruptedRestart>0</StreamInterruptedRestart>
+                <!-- The maximum frame interval time, unit: ms; if no new data frame is received
+                beyond the maximum interval time, the stream is considered to be interrupted -->
+                <MaxFrameIntervalMs>5000</MaxFrameIntervalMs>
+            </Color>
+
+            <IR>
+                <!-- The width of the default resolution, int type -->
+                <Width>640</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>576</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>30</FPS>
+                <!-- Default frame format -->
+                <Format>Y16</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+                <!-- The maximum open-flow delay, unit: ms; if the first frame of data is not
+                received after the open-flow exceeds this time, the open-flow will be considered as
+                a failure -->
+                <MaxStartStreamDelayMs>5000</MaxStartStreamDelayMs>
+                <!-- Stream interruption restart, 0 does not restart, >=1 consecutive restart
+                attempts -->
+                <StreamInterruptedRestart>0</StreamInterruptedRestart>
+                <!-- The maximum frame interval time, unit: ms; if no new data frame is received
+                beyond the maximum interval time, the stream is considered to be interrupted -->
+                <MaxFrameIntervalMs>5000</MaxFrameIntervalMs>
+            </IR>
+        </FemtoMega>
+
+        <FemtoMegai>
+            <Depth>
+                <!-- The width of the default resolution, int type -->
+                <Width>640</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>576</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>30</FPS>
+                <!-- Default frame format -->
+                <Format>Y16</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+                <!-- The maximum open-flow delay, unit: ms; if the first frame of data is not
+                received after the open-flow exceeds this time, the open-flow will be considered as
+                a failure -->
+                <MaxStartStreamDelayMs>5000</MaxStartStreamDelayMs>
+                <!-- Stream interruption restart, 0 does not restart, >=1 consecutive restart
+                attempts -->
+                <StreamInterruptedRestart>0</StreamInterruptedRestart>
+                <!-- The maximum frame interval time, unit: ms; if no new data frame is received
+                beyond the maximum interval time, the stream is considered to be interrupted -->
+                <MaxFrameIntervalMs>5000</MaxFrameIntervalMs>
+            </Depth>
+
+            <Color>
+                <!-- The width of the default resolution, int type -->
+                <Width>1920</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>1080</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>30</FPS>
+                <!-- Default frame format -->
+                <Format>MJPG</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+                <!-- The maximum open-flow delay, unit: ms; if the first frame of data is not
+                received after the open-flow exceeds this time, the open-flow will be considered as
+                a failure -->
+                <MaxStartStreamDelayMs>5000</MaxStartStreamDelayMs>
+                <!-- Stream interruption restart, 0 does not restart, >=1 consecutive restart
+                attempts -->
+                <StreamInterruptedRestart>0</StreamInterruptedRestart>
+                <!-- The maximum frame interval time, unit: ms; if no new data frame is received
+                beyond the maximum interval time, the stream is considered to be interrupted -->
+                <MaxFrameIntervalMs>5000</MaxFrameIntervalMs>
+            </Color>
+
+            <IR>
+                <!-- The width of the default resolution, int type -->
+                <Width>640</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>576</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>30</FPS>
+                <!-- Default frame format -->
+                <Format>Y16</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+                <!-- The maximum open-flow delay, unit: ms; if the first frame of data is not
+                received after the open-flow exceeds this time, the open-flow will be considered as
+                a failure -->
+                <MaxStartStreamDelayMs>5000</MaxStartStreamDelayMs>
+                <!-- Stream interruption restart, 0 does not restart, >=1 consecutive restart
+                attempts -->
+                <StreamInterruptedRestart>0</StreamInterruptedRestart>
+                <!-- The maximum frame interval time, unit: ms; if no new data frame is received
+                beyond the maximum interval time, the stream is considered to be interrupted -->
+                <MaxFrameIntervalMs>5000</MaxFrameIntervalMs>
+            </IR>
+        </FemtoMegai>
+
+        <FemtoBolt>
+            <Depth>
+                <!-- The width of the default resolution, int type -->
+                <Width>640</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>576</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>30</FPS>
+                <!-- Default frame format -->
+                <Format>Y16</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+                <!-- The maximum open-flow delay, unit: ms; if the first frame of data is not
+                received after the open-flow exceeds this time, the open-flow will be considered as
+                a failure -->
+                <MaxStartStreamDelayMs>5000</MaxStartStreamDelayMs>
+                <!-- Stream interruption restart, 0 does not restart, >=1 consecutive restart
+                attempts -->
+                <StreamInterruptedRestart>0</StreamInterruptedRestart>
+                <!-- The maximum frame interval time, unit: ms; if no new data frame is received
+                beyond the maximum interval time, the stream is considered to be interrupted -->
+                <MaxFrameIntervalMs>5000</MaxFrameIntervalMs>
+            </Depth>
+
+            <Color>
+                <!-- The width of the default resolution, int type -->
+                <Width>1920</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>1080</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>30</FPS>
+                <!-- Default frame format -->
+                <Format>MJPG</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+                <!-- The maximum open-flow delay, unit: ms; if the first frame of data is not
+                received after the open-flow exceeds this time, the open-flow will be considered as
+                a failure -->
+                <MaxStartStreamDelayMs>5000</MaxStartStreamDelayMs>
+                <!-- Stream interruption restart, 0 does not restart, >=1 consecutive restart
+                attempts -->
+                <StreamInterruptedRestart>0</StreamInterruptedRestart>
+                <!-- The maximum frame interval time, unit: ms; if no new data frame is received
+                beyond the maximum interval time, the stream is considered to be interrupted -->
+                <MaxFrameIntervalMs>5000</MaxFrameIntervalMs>
+            </Color>
+
+            <IR>
+                <!-- The width of the default resolution, int type -->
+                <Width>640</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>576</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>30</FPS>
+                <!-- Default frame format -->
+                <Format>Y16</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+                <!-- The maximum open-flow delay, unit: ms; if the first frame of data is not
+                received after the open-flow exceeds this time, the open-flow will be considered as
+                a failure -->
+                <MaxStartStreamDelayMs>5000</MaxStartStreamDelayMs>
+                <!-- Stream interruption restart, 0 does not restart, >=1 consecutive restart
+                attempts -->
+                <StreamInterruptedRestart>0</StreamInterruptedRestart>
+                <!-- The maximum frame interval time, unit: ms; if no new data frame is received
+                beyond the maximum interval time, the stream is considered to be interrupted -->
+                <MaxFrameIntervalMs>5000</MaxFrameIntervalMs>
+            </IR>
+        </FemtoBolt>
+
+        <DaBai>
+            <Depth>
+                <!-- The width of the default resolution, int type -->
+                <Width>640</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>400</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>30</FPS>
+                <!-- Default frame format -->
+                <Format>Y11</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+            </Depth>
+            <Color>
+                <!-- The width of the default resolution, int type -->
+                <Width>640</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>480</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>30</FPS>
+                <!-- Default frame format -->
+                <Format>MJPG</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+            </Color>
+            <IR>
+                <!-- The width of the default resolution, int type -->
+                <Width>640</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>400</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>30</FPS>
+                <!-- Default frame format -->
+                <Format>Y10</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+            </IR>
+        </DaBai>
+
+        <DaBaiPro>
+            <Depth>
+                <!-- The width of the default resolution, int type -->
+                <Width>640</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>400</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>30</FPS>
+                <!-- Default frame format -->
+                <Format>Y11</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+            </Depth>
+            <IR>
+                <!-- The width of the default resolution, int type -->
+                <Width>640</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>400</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>30</FPS>
+                <!-- Default frame format -->
+                <Format>Y10</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+            </IR>
+        </DaBaiPro>
+
+        <DaBaiDCW>
+            <Depth>
+                <!-- The width of the default resolution, int type -->
+                <Width>640</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>360</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>30</FPS>
+                <!-- Default frame format -->
+                <Format>Y11</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+            </Depth>
+            <Color>
+                <!-- The width of the default resolution, int type -->
+                <Width>640</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>360</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>30</FPS>
+                <!-- Default frame format -->
+                <Format>MJPG</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+            </Color>
+            <IR>
+                <!-- The width of the default resolution, int type -->
+                <Width>640</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>480</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>30</FPS>
+                <!-- Default frame format -->
+                <Format>Y10</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+            </IR>
+        </DaBaiDCW>
+
+        <DaBaiDCW2>
+            <!--  Depth Filter Params -->
+            <!--
+            <DepthFilterDDOConfig>./Openni_device.json</DepthFilterDDOConfig>
+			 -->
+            <Depth>
+                <!-- The width of the default resolution, int type -->
+                <Width>640</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>400</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>15</FPS>
+                <!-- Default frame format -->
+                <Format>Y11</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+            </Depth>
+            <Color>
+                <!-- The width of the default resolution, int type -->
+                <Width>640</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>480</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>15</FPS>
+                <!-- Default frame format -->
+                <Format>MJPG</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+            </Color>
+            <IR>
+                <!-- The width of the default resolution, int type -->
+                <Width>640</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>400</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>15</FPS>
+                <!-- Default frame format -->
+                <Format>Y10</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+            </IR>
+        </DaBaiDCW2>
+        <GeminiEW>
+            <Depth>
+                <!-- The width of the default resolution, int type -->
+                <Width>640</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>400</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>15</FPS>
+                <!-- Default frame format -->
+                <Format>Y11</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+                <ProfileFilter>
+                    <profile>
+                        <FPS>30</FPS>
+                    </profile>
+                </ProfileFilter>
+            </Depth>
+            <Color>
+                <!-- The width of the default resolution, int type -->
+                <Width>640</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>480</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>15</FPS>
+                <!-- Default frame format -->
+                <Format>MJPG</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+            </Color>
+            <IR>
+                <!-- The width of the default resolution, int type -->
+                <Width>640</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>400</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>15</FPS>
+                <!-- Default frame format -->
+                <Format>Y10</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+                <ProfileFilter>
+                    <profile>
+                        <FPS>30</FPS>
+                    </profile>
+                </ProfileFilter>
+            </IR>
+        </GeminiEW>
+        <DaBaiMax>
+            <Depth>
+                <!-- The width of the default resolution, int type -->
+                <Width>640</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>320</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>10</FPS>
+                <!-- Default frame format -->
+                <Format>Y12</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+            </Depth>
+            <Color>
+                <!-- The width of the default resolution, int type -->
+                <Width>640</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>480</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>25</FPS>
+                <!-- Default frame format -->
+                <Format>MJPG</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+            </Color>
+            <IR>
+                <!-- The width of the default resolution, int type -->
+                <Width>640</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>400</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>10</FPS>
+                <!-- Default frame format -->
+                <Format>Y10</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+            </IR>
+        </DaBaiMax>
+        <DaBaiMaxPro>
+            <Depth>
+                <!-- The width of the default resolution, int type -->
+                <Width>640</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>400</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>10</FPS>
+                <!-- Default frame format -->
+                <Format>Y12</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+            </Depth>
+            <Color>
+                <!-- The width of the default resolution, int type -->
+                <Width>640</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>480</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>25</FPS>
+                <!-- Default frame format -->
+                <Format>MJPG</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+            </Color>
+            <IR>
+                <!-- The width of the default resolution, int type -->
+                <Width>640</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>400</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>10</FPS>
+                <!-- Default frame format -->
+                <Format>Y10</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+            </IR>
+        </DaBaiMaxPro>
+        <GeminiUW>
+            <Depth>
+                <!-- The width of the default resolution, int type -->
+                <Width>640</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>400</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>10</FPS>
+                <!-- Default frame format -->
+                <Format>Y12</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+            </Depth>
+            <Color>
+                <!-- The width of the default resolution, int type -->
+                <Width>640</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>480</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>25</FPS>
+                <!-- Default frame format -->
+                <Format>MJPG</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+            </Color>
+            <IR>
+                <!-- The width of the default resolution, int type -->
+                <Width>640</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>400</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>10</FPS>
+                <!-- Default frame format -->
+                <Format>Y10</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+            </IR>
+        </GeminiUW>
+        <DaBaiDW>
+            <Depth>
+                <!-- The width of the default resolution, int type -->
+                <Width>640</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>480</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>30</FPS>
+                <!-- Default frame format -->
+                <Format>Y11</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+            </Depth>
+            <IR>
+                <!-- The width of the default resolution, int type -->
+                <Width>640</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>480</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>30</FPS>
+                <!-- Default frame format -->
+                <Format>Y10</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+            </IR>
+        </DaBaiDW>
+
+        <DaBaiDW2>
+            <Depth>
+                <!-- The width of the default resolution, int type -->
+                <Width>640</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>400</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>15</FPS>
+                <!-- Default frame format -->
+                <Format>Y11</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+            </Depth>
+            <IR>
+                <!-- The width of the default resolution, int type -->
+                <Width>640</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>400</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>15</FPS>
+                <!-- Default frame format -->
+                <Format>Y10</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+            </IR>
+        </DaBaiDW2>
+        <GeminiEWLite>
+            <Depth>
+                <!-- The width of the default resolution, int type -->
+                <Width>640</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>400</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>15</FPS>
+                <!-- Default frame format -->
+                <Format>Y11</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+            </Depth>
+            <IR>
+                <!-- The width of the default resolution, int type -->
+                <Width>640</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>400</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>15</FPS>
+                <!-- Default frame format -->
+                <Format>Y10</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+            </IR>
+        </GeminiEWLite>
+        <DaBaiDC1>
+            <Depth>
+                <!-- The width of the default resolution, int type -->
+                <Width>640</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>400</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>30</FPS>
+                <!-- Default frame format -->
+                <Format>Y11</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+            </Depth>
+            <Color>
+                <!-- The width of the default resolution, int type -->
+                <Width>640</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>480</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>30</FPS>
+                <!-- Default frame format -->
+                <Format>MJPG</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+            </Color>
+            <IR>
+                <!-- The width of the default resolution, int type -->
+                <Width>640</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>400</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>30</FPS>
+                <!-- Default frame format -->
+                <Format>Y10</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+            </IR>
+        </DaBaiDC1>
+
+        <DaBaiD1>
+            <Depth>
+                <!-- The width of the default resolution, int type -->
+                <Width>640</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>400</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>30</FPS>
+                <!-- Default frame format -->
+                <Format>Y11</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+            </Depth>
+            <IR>
+                <!-- The width of the default resolution, int type -->
+                <Width>640</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>400</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>30</FPS>
+                <!-- Default frame format -->
+                <Format>Y10</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+            </IR>
+        </DaBaiD1>
+
+        <AstraMini>
+            <Depth>
+                <!-- The width of the default resolution, int type -->
+                <Width>640</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>480</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>30</FPS>
+                <!-- Default frame format -->
+                <Format>Y11</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+            </Depth>
+            <Color>
+                <!-- The width of the default resolution, int type -->
+                <Width>640</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>480</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>30</FPS>
+                <!-- Default frame format -->
+                <Format>UYVY</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+            </Color>
+            <IR>
+                <!-- The width of the default resolution, int type -->
+                <Width>640</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>480</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>30</FPS>
+                <!-- Default frame format -->
+                <Format>Y10</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+            </IR>
+        </AstraMini>
+
+        <AstraMiniS>
+            <Depth>
+                <!-- The width of the default resolution, int type -->
+                <Width>640</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>480</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>30</FPS>
+                <!-- Default frame format -->
+                <Format>Y11</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+            </Depth>
+            <Color>
+                <!-- The width of the default resolution, int type -->
+                <Width>640</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>480</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>30</FPS>
+                <!-- Default frame format -->
+                <Format>UYVY</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+            </Color>
+            <IR>
+                <!-- The width of the default resolution, int type -->
+                <Width>640</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>480</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>30</FPS>
+                <!-- Default frame format -->
+                <Format>Y10</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+            </IR>
+        </AstraMiniS>
+
+        <AstraMiniPro>
+            <Depth>
+                <!-- The width of the default resolution, int type -->
+                <Width>640</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>480</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>30</FPS>
+                <!-- Default frame format -->
+                <Format>Y11</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+            </Depth>
+            <Color>
+                <!-- The width of the default resolution, int type -->
+                <Width>640</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>480</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>30</FPS>
+                <!-- Default frame format -->
+                <Format>UYVY</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+            </Color>
+            <IR>
+                <!-- The width of the default resolution, int type -->
+                <Width>640</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>480</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>30</FPS>
+                <!-- Default frame format -->
+                <Format>Y10</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+            </IR>
+        </AstraMiniPro>
+
+        <AstraMiniSPro>
+            <Depth>
+                <!-- The width of the default resolution, int type -->
+                <Width>640</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>480</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>30</FPS>
+                <!-- Default frame format -->
+                <Format>Y11</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+            </Depth>
+            <Color>
+                <!-- The width of the default resolution, int type -->
+                <Width>640</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>480</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>30</FPS>
+                <!-- Default frame format -->
+                <Format>UYVY</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+            </Color>
+            <IR>
+                <!-- The width of the default resolution, int type -->
+                <Width>640</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>480</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>30</FPS>
+                <!-- Default frame format -->
+                <Format>Y10</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+            </IR>
+        </AstraMiniSPro>
+
+        <AstraStereoSU3>
+            <Depth>
+                <!-- The width of the default resolution, int type -->
+                <Width>640</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>400</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>30</FPS>
+                <!-- Default frame format -->
+                <Format>Y11</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+            </Depth>
+            <Color>
+                <!-- The width of the default resolution, int type -->
+                <Width>640</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>480</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>30</FPS>
+                <!-- Default frame format -->
+                <Format>MJPG</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+            </Color>
+            <IR>
+                <!-- The width of the default resolution, int type -->
+                <Width>640</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>400</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>30</FPS>
+                <!-- Default frame format -->
+                <Format>Y10</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+            </IR>
+        </AstraStereoSU3>
+
+        <SV1301S_U3>
+            <Depth>
+                <!-- The width of the default resolution, int type -->
+                <Width>640</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>400</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>30</FPS>
+                <!-- Default frame format -->
+                <Format>Y11</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+            </Depth>
+            <Color>
+                <!-- The width of the default resolution, int type -->
+                <Width>640</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>480</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>30</FPS>
+                <!-- Default frame format -->
+                <Format>MJPG</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+            </Color>
+            <IR>
+                <!-- The width of the default resolution, int type -->
+                <Width>640</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>400</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>30</FPS>
+                <!-- Default frame format -->
+                <Format>Y10</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+            </IR>
+        </SV1301S_U3>
+        <SL1000S_U3>
+            <Depth>
+                <!-- The width of the default resolution, int type -->
+                <Width>640</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>400</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>30</FPS>
+                <!-- Default frame format -->
+                <Format>Y11</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+            </Depth>
+            <Color>
+                <!-- The width of the default resolution, int type -->
+                <Width>640</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>480</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>30</FPS>
+                <!-- Default frame format -->
+                <Format>MJPG</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+            </Color>
+            <IR>
+                <!-- The width of the default resolution, int type -->
+                <Width>640</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>400</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>30</FPS>
+                <!-- Default frame format -->
+                <Format>Y10</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+            </IR>
+        </SL1000S_U3>
+
+        <Astra>
+            <Depth>
+                <!-- The width of the default resolution, int type -->
+                <Width>640</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>480</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>30</FPS>
+                <!-- Default frame format -->
+                <Format>Y11</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+            </Depth>
+            <Color>
+                <!-- The width of the default resolution, int type -->
+                <Width>640</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>480</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>30</FPS>
+                <!-- Default frame format -->
+                <Format>UYVY</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+            </Color>
+            <IR>
+                <!-- The width of the default resolution, int type -->
+                <Width>640</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>480</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>30</FPS>
+                <!-- Default frame format -->
+                <Format>Y10</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+            </IR>
+        </Astra>
+
+        <AstraProPlus>
+            <Depth>
+                <!-- The width of the default resolution, int type -->
+                <Width>640</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>480</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>30</FPS>
+                <!-- Default frame format -->
+                <Format>Y11</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+            </Depth>
+            <Color>
+                <!-- The width of the default resolution, int type -->
+                <Width>640</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>480</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>30</FPS>
+                <!-- Default frame format -->
+                <Format>MJPG</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+            </Color>
+            <IR>
+                <!-- The width of the default resolution, int type -->
+                <Width>640</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>480</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>30</FPS>
+                <!-- Default frame format -->
+                <Format>Y10</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+            </IR>
+        </AstraProPlus>
+
+        <AstraEmbeddedS>
+            <Depth>
+                <!-- The width of the default resolution, int type -->
+                <Width>640</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>400</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>30</FPS>
+                <!-- Default frame format -->
+                <Format>Y11</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+            </Depth>
+            <Color>
+                <!-- The width of the default resolution, int type -->
+                <Width>640</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>480</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>30</FPS>
+                <!-- Default frame format -->
+                <Format>MJPG</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+            </Color>
+            <IR>
+                <!-- The width of the default resolution, int type -->
+                <Width>640</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>400</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>30</FPS>
+                <!-- Default frame format -->
+                <Format>Y10</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+            </IR>
+        </AstraEmbeddedS>
+
+        <Deeyea>
+            <Depth>
+                <!-- The width of the default resolution, int type -->
+                <Width>640</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>400</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>30</FPS>
+                <!-- Default frame format -->
+                <Format>Y11</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+            </Depth>
+            <Color>
+                <!-- The width of the default resolution, int type -->
+                <Width>640</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>480</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>30</FPS>
+                <!-- Default frame format -->
+                <Format>MJPG</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+            </Color>
+            <IR>
+                <!-- The width of the default resolution, int type -->
+                <Width>640</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>400</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>30</FPS>
+                <!-- Default frame format -->
+                <Format>Y10</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+            </IR>
+        </Deeyea>
+        <SL1502P_U2>
+            <Depth>
+                <!-- The width of the default resolution, int type -->
+                <Width>480</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>640</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>30</FPS>
+                <!-- Default frame format -->
+                <Format>Y11</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+            </Depth>
+            <Color>
+                <!-- The width of the default resolution, int type -->
+                <Width>640</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>480</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>30</FPS>
+                <!-- Default frame format -->
+                <Format>MJPG</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+            </Color>
+            <IR>
+                <!-- The width of the default resolution, int type -->
+                <Width>480</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>640</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>30</FPS>
+                <!-- Default frame format -->
+                <Format>Y10</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+            </IR>
+        </SL1502P_U2>
+        <GeminiE>
+            <Depth>
+                <!-- The width of the default resolution, int type -->
+                <Width>640</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>360</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>30</FPS>
+                <!-- Default frame format -->
+                <Format>Y11</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+            </Depth>
+            <Color>
+                <!-- The width of the default resolution, int type -->
+                <Width>640</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>360</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>30</FPS>
+                <!-- Default frame format -->
+                <Format>MJPG</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+            </Color>
+            <IR>
+                <!-- The width of the default resolution, int type -->
+                <Width>640</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>480</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>30</FPS>
+                <!-- Default frame format -->
+                <Format>Y10</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+            </IR>
+        </GeminiE>
+        <GeminiELite>
+            <Depth>
+                <!-- The width of the default resolution, int type -->
+                <Width>640</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>480</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>30</FPS>
+                <!-- Default frame format -->
+                <Format>Y11</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+            </Depth>
+            <IR>
+                <!-- The width of the default resolution, int type -->
+                <Width>640</Width>
+                <!-- The height of the default resolution, int type -->
+                <Height>480</Height>
+                <!-- Default frame rate, int type -->
+                <FPS>30</FPS>
+                <!-- Default frame format -->
+                <Format>Y10</Format>
+                <!-- Whether to retry after open stream failure, 0 means no retry, >=1 retry and how
+                many times to retry -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+            </IR>
+        </GeminiELite>
+        <!-- Gemini2 config -->
+        <Gemini2>
+            <!-- Whether to enable heartbeat by default -->
+            <DefaultHeartBeat>0</DefaultHeartBeat>
+            <!-- Whether to enable firmware upgrade foolproof by default, only internal version
+            supports -->
+            <FirmwareUpgradeFoolproof>1</FirmwareUpgradeFoolproof>
+            <!--  Depth Filter Params -->
+            <!--
+            <DepthFilterDDOConfig>./Gemini2_v1.0.json</DepthFilterDDOConfig>
+			 -->
+
+            <!-- TODO lumiaozi It is cumbersome to consider the recommended configuration in
+            different camera depth modes -->
+            <!-- TODO lumiaozi have to consider the uncorresponding resolutions in different camera
+            depth modes -->
+            <Depth>
+                <!-- Number of retries for open stream failures, 0 means no retries -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+                <!-- Open flow waits for the timeout period of the first frame of data, after which
+                the open flow will fail -->
+                <MaxStartStreamDelayMs>5000</MaxStartStreamDelayMs>
+                <!-- The number of data stream restarts due to abnormal interruption, 0 means no
+                restart -->
+                <StreamInterruptedRestart>0</StreamInterruptedRestart>
+                <!-- The maximum frame interval time, if this value is exceeded, it will be judged
+                that the stream is interrupted -->
+                <MaxFrameIntervalMs>2000</MaxFrameIntervalMs>
+                <!-- The resolution width is enabled by default, int type -->
+                <Width>1280</Width>
+                <!-- High resolution is enabled by default, int type -->
+                <Height>800</Height>
+                <!-- The frame rate of the resolution enabled by default, int type -->
+                <FPS>30</FPS>
+                <Format>RLE</Format>
+            </Depth>
+            <Color>
+                <!-- The resolution width is enabled by default, int type -->
+                <Width>1280</Width>
+                <!-- High resolution is enabled by default, int type -->
+                <Height>720</Height>
+                <!-- The frame rate of the resolution enabled by default, int type -->
+                <FPS>30</FPS>
+                <Format>MJPG</Format>
+            </Color>
+            <IR>
+                <!-- The resolution width is enabled by default, int type -->
+                <Width>1280</Width>
+                <!-- High resolution is enabled by default, int type -->
+                <Height>800</Height>
+                <!-- The frame rate of the resolution enabled by default, int type -->
+                <FPS>30</FPS>
+                <Format>Y8</Format>
+            </IR>
+            <LeftIR>
+                <!-- The resolution width is enabled by default, int type -->
+                <Width>1280</Width>
+                <!-- High resolution is enabled by default, int type -->
+                <Height>800</Height>
+                <!-- The frame rate of the resolution enabled by default, int type -->
+                <FPS>30</FPS>
+                <Format>Y8</Format>
+            </LeftIR>
+            <RightIR>
+                <!-- The resolution width is enabled by default, int type -->
+                <Width>1280</Width>
+                <!-- High resolution is enabled by default, int type -->
+                <Height>800</Height>
+                <!-- The frame rate of the resolution enabled by default, int type -->
+                <FPS>30</FPS>
+                <Format>Y8</Format>
+            </RightIR>
+            <!-- Configurations in different camera depth modes -->
+            <!-- Deep working mode: Unbinned Dense Default -->
+            <UnbinnedDenseDefault>
+                <!-- You can configure the default resolution corresponding to the sensor in the
+                current mode here, if not configured, then use the Device node to correspond to the
+                default resolution of the sensor -->
+            </UnbinnedDenseDefault>
+            <!-- Deep working mode: Unbinned Sparse Default -->
+            <UnbinnedSparseDefault>
+                <!-- You can configure the default resolution corresponding to the sensor in the
+                current mode here, if not configured, then use the Device node to correspond to the
+                default resolution of the sensor -->
+            </UnbinnedSparseDefault>
+            <!-- Deep working mode: Binned Sparse Default -->
+            <BinnedSparseDefault>
+                <!-- You can configure the default resolution corresponding to the sensor in the
+                current mode here, if not configured, then use the Device node to correspond to the
+                default resolution of the sensor -->
+                <Depth>
+                    <!-- The resolution width is enabled by default, int type -->
+                    <Width>640</Width>
+                    <!-- High resolution is enabled by default, int type -->
+                    <Height>400</Height>
+                    <!-- The frame rate of the resolution enabled by default, int type -->
+                    <FPS>30</FPS>
+                    <Format>RLE</Format>
+                </Depth>
+                <IR>
+                    <!-- The resolution width is enabled by default, int type -->
+                    <Width>640</Width>
+                    <!-- High resolution is enabled by default, int type -->
+                    <Height>400</Height>
+                    <!-- The frame rate of the resolution enabled by default, int type -->
+                    <FPS>30</FPS>
+                    <Format>Y8</Format>
+                </IR>
+            </BinnedSparseDefault>
+            <!--  Deep working mode: Obstacle Avoidance -->
+            <ObstacleAvoidance>
+                <Depth>
+                    <!-- The resolution width is enabled by default, int type -->
+                    <Width>640</Width>
+                    <!-- High resolution is enabled by default, int type -->
+                    <Height>400</Height>
+                    <!-- The frame rate of the resolution enabled by default, int type -->
+                    <FPS>15</FPS>
+                    <Format>RLE</Format>
+                </Depth>
+            </ObstacleAvoidance>
+            <FactoryCalibration>
+                <Color>
+                    <!-- The resolution width is enabled by default, int type -->
+                    <Width>1920</Width>
+                    <!-- High resolution is enabled by default, int type -->
+                    <Height>1080</Height>
+                    <!-- The frame rate of the resolution enabled by default, int type -->
+                    <FPS>30</FPS>
+                    <Format>MJPG</Format>
+                </Color>
+                <LeftIR>
+                    <!-- The resolution width is enabled by default, int type -->
+                    <Width>1280</Width>
+                    <!-- High resolution is enabled by default, int type -->
+                    <Height>800</Height>
+                    <!-- The frame rate of the resolution enabled by default, int type -->
+                    <FPS>30</FPS>
+                    <Format>Y10</Format>
+                </LeftIR>
+                <RightIR>
+                    <!-- The resolution width is enabled by default, int type -->
+                    <Width>1280</Width>
+                    <!-- High resolution is enabled by default, int type -->
+                    <Height>800</Height>
+                    <!-- The frame rate of the resolution enabled by default, int type -->
+                    <FPS>30</FPS>
+                    <Format>Y10</Format>
+                </RightIR>
+
+            </FactoryCalibration>
+            <In-sceneCalibration>
+                <Color>
+                    <!-- The resolution width is enabled by default, int type -->
+                    <Width>1920</Width>
+                    <!-- High resolution is enabled by default, int type -->
+                    <Height>1080</Height>
+                    <!-- The frame rate of the resolution enabled by default, int type -->
+                    <FPS>30</FPS>
+                    <Format>MJPG</Format>
+                </Color>
+                <LeftIR>
+                    <!-- The resolution width is enabled by default, int type -->
+                    <Width>1280</Width>
+                    <!-- High resolution is enabled by default, int type -->
+                    <Height>800</Height>
+                    <!-- The frame rate of the resolution enabled by default, int type -->
+                    <FPS>30</FPS>
+                    <Format>Y8</Format>
+                </LeftIR>
+                <RightIR>
+                    <!-- The resolution width is enabled by default, int type -->
+                    <Width>1280</Width>
+                    <!-- High resolution is enabled by default, int type -->
+                    <Height>800</Height>
+                    <!-- The frame rate of the resolution enabled by default, int type -->
+                    <FPS>30</FPS>
+                    <Format>Y8</Format>
+                </RightIR>
+            </In-sceneCalibration>
+        </Gemini2>
+
+        <!-- DaBaiDCL config -->
+        <DaBaiDCL>
+            <!-- Whether to enable heartbeat by default -->
+            <DefaultHeartBeat>0</DefaultHeartBeat>
+            <!-- Whether to enable firmware upgrade foolproof by default, only internal version
+            supports -->
+            <FirmwareUpgradeFoolproof>1</FirmwareUpgradeFoolproof>
+
+            <!-- TODO lumiaozi It is cumbersome to consider the recommended configuration in
+            different camera depth modes -->
+            <!-- TODO lumiaozi have to consider the uncorresponding resolutions in different camera
+            depth modes -->
+            <Depth>
+                <!-- Number of retries for open stream failures, 0 means no retries -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+                <!-- Open flow waits for the timeout period of the first frame of data, after which
+                the open flow will fail -->
+                <MaxStartStreamDelayMs>5000</MaxStartStreamDelayMs>
+                <!-- The number of data stream restarts due to abnormal interruption, 0 means no
+                restart -->
+                <StreamInterruptedRestart>0</StreamInterruptedRestart>
+                <!-- The maximum frame interval time, if this value is exceeded, it will be judged
+                that the stream is interrupted -->
+                <MaxFrameIntervalMs>2000</MaxFrameIntervalMs>
+                <!-- The resolution width is enabled by default, int type -->
+                <Width>1280</Width>
+                <!-- High resolution is enabled by default, int type -->
+                <Height>800</Height>
+                <!-- The frame rate of the resolution enabled by default, int type -->
+                <FPS>30</FPS>
+                <Format>RLE</Format>
+            </Depth>
+            <Color>
+                <!-- The resolution width is enabled by default, int type -->
+                <Width>1280</Width>
+                <!-- High resolution is enabled by default, int type -->
+                <Height>720</Height>
+                <!-- The frame rate of the resolution enabled by default, int type -->
+                <FPS>30</FPS>
+                <Format>MJPG</Format>
+            </Color>
+            <IR>
+                <!-- The resolution width is enabled by default, int type -->
+                <Width>1280</Width>
+                <!-- High resolution is enabled by default, int type -->
+                <Height>800</Height>
+                <!-- The frame rate of the resolution enabled by default, int type -->
+                <FPS>30</FPS>
+                <Format>Y8</Format>
+            </IR>
+            <LeftIR>
+                <!-- The resolution width is enabled by default, int type -->
+                <Width>1280</Width>
+                <!-- High resolution is enabled by default, int type -->
+                <Height>800</Height>
+                <!-- The frame rate of the resolution enabled by default, int type -->
+                <FPS>30</FPS>
+                <Format>Y8</Format>
+            </LeftIR>
+            <RightIR>
+                <!-- The resolution width is enabled by default, int type -->
+                <Width>1280</Width>
+                <!-- High resolution is enabled by default, int type -->
+                <Height>800</Height>
+                <!-- The frame rate of the resolution enabled by default, int type -->
+                <FPS>30</FPS>
+                <Format>Y8</Format>
+            </RightIR>
+
+            <!-- Configurations in different camera depth modes -->
+            <HighAccuracyMode>
+                <Depth>
+                    <!-- The resolution width is enabled by default, int type -->
+                    <Width>640</Width>
+                    <!-- High resolution is enabled by default, int type -->
+                    <Height>400</Height>
+                    <!-- The frame rate of the resolution enabled by default, int type -->
+                    <FPS>30</FPS>
+                    <Format>Y16</Format>
+                </Depth>
+                <IR>
+                    <!-- The resolution width is enabled by default, int type -->
+                    <Width>640</Width>
+                    <!-- High resolution is enabled by default, int type -->
+                    <Height>400</Height>
+                    <!-- The frame rate of the resolution enabled by default, int type -->
+                    <FPS>30</FPS>
+                    <Format>Y8</Format>
+                </IR>
+            </HighAccuracyMode>
+            <FactoryCalibration>
+                <Color>
+                    <!-- The resolution width is enabled by default, int type -->
+                    <Width>1920</Width>
+                    <!-- High resolution is enabled by default, int type -->
+                    <Height>1080</Height>
+                    <!-- The frame rate of the resolution enabled by default, int type -->
+                    <FPS>30</FPS>
+                    <Format>MJPG</Format>
+                </Color>
+                <LeftIR>
+                    <!-- The resolution width is enabled by default, int type -->
+                    <Width>1280</Width>
+                    <!-- High resolution is enabled by default, int type -->
+                    <Height>800</Height>
+                    <!-- The frame rate of the resolution enabled by default, int type -->
+                    <FPS>30</FPS>
+                    <Format>Y10</Format>
+                </LeftIR>
+                <RightIR>
+                    <!-- The resolution width is enabled by default, int type -->
+                    <Width>1280</Width>
+                    <!-- High resolution is enabled by default, int type -->
+                    <Height>800</Height>
+                    <!-- The frame rate of the resolution enabled by default, int type -->
+                    <FPS>30</FPS>
+                    <Format>Y10</Format>
+                </RightIR>
+
+            </FactoryCalibration>
+            <In-sceneCalibration>
+                <Color>
+                    <!-- The resolution width is enabled by default, int type -->
+                    <Width>1920</Width>
+                    <!-- High resolution is enabled by default, int type -->
+                    <Height>1080</Height>
+                    <!-- The frame rate of the resolution enabled by default, int type -->
+                    <FPS>30</FPS>
+                    <Format>MJPG</Format>
+                </Color>
+                <LeftIR>
+                    <!-- The resolution width is enabled by default, int type -->
+                    <Width>1280</Width>
+                    <!-- High resolution is enabled by default, int type -->
+                    <Height>800</Height>
+                    <!-- The frame rate of the resolution enabled by default, int type -->
+                    <FPS>30</FPS>
+                    <Format>Y8</Format>
+                </LeftIR>
+                <RightIR>
+                    <!-- The resolution width is enabled by default, int type -->
+                    <Width>1280</Width>
+                    <!-- High resolution is enabled by default, int type -->
+                    <Height>800</Height>
+                    <!-- The frame rate of the resolution enabled by default, int type -->
+                    <FPS>30</FPS>
+                    <Format>Y8</Format>
+                </RightIR>
+            </In-sceneCalibration>
+        </DaBaiDCL>
+        <!-- Gemini2L config -->
+        <Gemini2L>
+            <!-- Whether to enable heartbeat by default -->
+            <DefaulHeartBeat>0</DefaulHeartBeat>
+
+            <Depth>
+                <!-- Number of retries for open stream failures, 0 means no retries -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+                <!-- Open flow waits for the timeout period of the first frame of data, after which
+                the open flow will fail -->
+                <MaxStartStreamDelayMs>5000</MaxStartStreamDelayMs>
+                <!-- The number of data stream restarts due to abnormal interruption, 0 means no
+                restart -->
+                <StreamInterruptedRestart>0</StreamInterruptedRestart>
+                <!-- The maximum frame interval time, if this value is exceeded, it will be judged
+                that the stream is interrupted -->
+                <MaxFrameIntervalMs>2000</MaxFrameIntervalMs>
+                <!-- The resolution width is enabled by default, int type -->
+                <Width>1280</Width>
+                <!-- High resolution is enabled by default, int type -->
+                <Height>800</Height>
+                <!-- The frame rate of the resolution enabled by default, int type -->
+                <FPS>30</FPS>
+                <Format>RLE</Format>
+            </Depth>
+            <Color>
+                <!-- The resolution width is enabled by default, int type -->
+                <Width>1280</Width>
+                <!-- High resolution is enabled by default, int type -->
+                <Height>720</Height>
+                <!-- The frame rate of the resolution enabled by default, int type -->
+                <FPS>30</FPS>
+                <!-- The frame rate of the resolution enabled by default, int type -->
+                <Format>MJPG</Format>
+                <!-- Number of retries for open stream failures, 0 means no retries -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+            </Color>
+            <IR>
+                <!-- The resolution width is enabled by default, int type -->
+                <Width>1280</Width>
+                <!-- High resolution is enabled by default, int type -->
+                <Height>800</Height>
+                <!-- The frame rate of the resolution enabled by default, int type -->
+                <FPS>30</FPS>
+                <!-- The frame rate of the resolution enabled by default, int type -->
+                <Format>Y8</Format>
+                <!-- Number of retries for open stream failures, 0 means no retries -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+            </IR>
+            <LeftIR>
+                <!-- The resolution width is enabled by default, int type -->
+                <Width>1280</Width>
+                <!-- High resolution is enabled by default, int type -->
+                <Height>800</Height>
+                <!-- The frame rate of the resolution enabled by default, int type -->
+                <FPS>30</FPS>
+                <Format>Y8</Format>
+                <!-- Number of retries for open stream failures, 0 means no retries -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+            </LeftIR>
+            <RightIR>
+                <!-- The resolution width is enabled by default, int type -->
+                <Width>1280</Width>
+                <!-- High resolution is enabled by default, int type -->
+                <Height>800</Height>
+                <!-- The frame rate of the resolution enabled by default, int type -->
+                <FPS>30</FPS>
+                <Format>Y8</Format>
+                <!-- Number of retries for open stream failures, 0 means no retries -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+            </RightIR>
+
+            <!-- Configurations in different camera depth modes -->
+            <BinnedSparseDefault>
+                <Depth>
+                    <!-- The resolution width is enabled by default, int type -->
+                    <Width>640</Width>
+                    <!-- High resolution is enabled by default, int type -->
+                    <Height>400</Height>
+                    <!-- The frame rate of the resolution enabled by default, int type -->
+                    <FPS>30</FPS>
+                    <Format>RLE</Format>
+                    <!-- Number of retries for open stream failures, 0 means no retries -->
+                    <StreamFailedRetry>0</StreamFailedRetry>
+                </Depth>
+                <IR>
+                    <!-- The resolution width is enabled by default, int type -->
+                    <Width>640</Width>
+                    <!-- High resolution is enabled by default, int type -->
+                    <Height>400</Height>
+                    <!-- The frame rate of the resolution enabled by default, int type -->
+                    <FPS>30</FPS>
+                    <Format>Y8</Format>
+                    <!-- Number of retries for open stream failures, 0 means no retries -->
+                    <StreamFailedRetry>0</StreamFailedRetry>
+                </IR>
+            </BinnedSparseDefault>
+            <FactoryCalibration>
+                <Color>
+                    <!-- The resolution width is enabled by default, int type -->
+                    <Width>1920</Width>
+                    <!-- High resolution is enabled by default, int type -->
+                    <Height>1080</Height>
+                    <!-- The frame rate of the resolution enabled by default, int type -->
+                    <FPS>30</FPS>
+                    <Format>MJPG</Format>
+                    <!-- Number of retries for open stream failures, 0 means no retries -->
+                    <StreamFailedRetry>0</StreamFailedRetry>
+                </Color>
+                <LeftIR>
+                    <!-- The resolution width is enabled by default, int type -->
+                    <Width>1280</Width>
+                    <!-- High resolution is enabled by default, int type -->
+                    <Height>800</Height>
+                    <!-- The frame rate of the resolution enabled by default, int type -->
+                    <FPS>30</FPS>
+                    <Format>Y10</Format>
+                    <!-- Number of retries for open stream failures, 0 means no retries -->
+                    <StreamFailedRetry>0</StreamFailedRetry>
+                </LeftIR>
+                <RightIR>
+                    <!-- The resolution width is enabled by default, int type -->
+                    <Width>1280</Width>
+                    <!-- High resolution is enabled by default, int type -->
+                    <Height>800</Height>
+                    <!-- The frame rate of the resolution enabled by default, int type -->
+                    <FPS>30</FPS>
+                    <Format>Y10</Format>
+                    <!-- Number of retries for open stream failures, 0 means no retries -->
+                    <StreamFailedRetry>0</StreamFailedRetry>
+                </RightIR>
+
+            </FactoryCalibration>
+            <In-sceneCalibration>
+                <Color>
+                    <!-- The resolution width is enabled by default, int type -->
+                    <Width>1920</Width>
+                    <!-- High resolution is enabled by default, int type -->
+                    <Height>1080</Height>
+                    <!-- The frame rate of the resolution enabled by default, int type -->
+                    <FPS>30</FPS>
+                    <Format>MJPG</Format>
+                    <!-- Number of retries for open stream failures, 0 means no retries -->
+                    <StreamFailedRetry>0</StreamFailedRetry>
+                </Color>
+                <LeftIR>
+                    <!-- The resolution width is enabled by default, int type -->
+                    <Width>1280</Width>
+                    <!-- High resolution is enabled by default, int type -->
+                    <Height>800</Height>
+                    <!-- The frame rate of the resolution enabled by default, int type -->
+                    <FPS>30</FPS>
+                    <Format>Y8</Format>
+                    <!-- Number of retries for open stream failures, 0 means no retries -->
+                    <StreamFailedRetry>0</StreamFailedRetry>
+                </LeftIR>
+                <RightIR>
+                    <!-- The resolution width is enabled by default, int type -->
+                    <Width>1280</Width>
+                    <!-- High resolution is enabled by default, int type -->
+                    <Height>800</Height>
+                    <!-- The frame rate of the resolution enabled by default, int type -->
+                    <FPS>30</FPS>
+                    <Format>Y8</Format>
+                    <!-- Number of retries for open stream failures, 0 means no retries -->
+                    <StreamFailedRetry>0</StreamFailedRetry>
+                </RightIR>
+            </In-sceneCalibration>
+        </Gemini2L>
+        <!-- Astra2 config -->
+        <Astra2>
+            <!-- Whether to enable heartbeat by default -->
+            <DefaulHeartBeat>0</DefaulHeartBeat>
+
+            <!-- TODO lumiaozi It is cumbersome to consider the recommended configuration in
+            different camera depth modes -->
+            <!-- TODO lumiaozi have to consider the uncorresponding resolutions in different camera
+            depth modes -->
+            <Depth>
+                <!-- Number of retries for open stream failures, 0 means no retries -->
+                <StreamFailedRetry>2</StreamFailedRetry>
+                <!-- Open flow waits for the timeout period of the first frame of data, after which
+                the open flow will fail -->
+                <MaxStartStreamDelayMs>10000</MaxStartStreamDelayMs>
+                <!-- The number of data stream restarts due to abnormal interruption, 0 means no
+                restart -->
+                <StreamInterruptedRestart>2</StreamInterruptedRestart>
+                <!-- The maximum frame interval time, if this value is exceeded, it will be judged
+                that the stream is interrupted -->
+                <MaxFrameIntervalMs>2000</MaxFrameIntervalMs>
+                <!-- The resolution width is enabled by default, int type -->
+                <Width>800</Width>
+                <!-- High resolution is enabled by default, int type -->
+                <Height>600</Height>
+                <!-- The frame rate of the resolution enabled by default, int type -->
+                <FPS>30</FPS>
+                <Format>RLE</Format>
+            </Depth>
+            <Color>
+                <!-- The resolution width is enabled by default, int type -->
+                <Width>1280</Width>
+                <!-- High resolution is enabled by default, int type -->
+                <Height>720</Height>
+                <!-- The frame rate of the resolution enabled by default, int type -->
+                <FPS>30</FPS>
+                <Format>MJPG</Format>
+            </Color>
+            <IR>
+                <!-- The resolution width is enabled by default, int type -->
+                <Width>800</Width>
+                <!-- High resolution is enabled by default, int type -->
+                <Height>600</Height>
+                <!-- The frame rate of the resolution enabled by default, int type -->
+                <FPS>30</FPS>
+                <Format>Y8</Format>
+            </IR>
+            <!-- Configurations in different camera depth modes -->
+            <HighResolution>
+                <Depth>
+                    <!-- The resolution width is enabled by default, int type -->
+                    <Width>1600</Width>
+                    <!-- High resolution is enabled by default, int type -->
+                    <Height>1200</Height>
+                    <!-- The frame rate of the resolution enabled by default, int type -->
+                    <FPS>30</FPS>
+                    <Format>RLE</Format>
+                </Depth>
+                <Color>
+                    <!-- The resolution width is enabled by default, int type -->
+                    <Width>1280</Width>
+                    <!-- High resolution is enabled by default, int type -->
+                    <Height>720</Height>
+                    <!-- The frame rate of the resolution enabled by default, int type -->
+                    <FPS>30</FPS>
+                    <Format>MJPG</Format>
+                </Color>
+                <IR>
+                    <!-- The resolution width is enabled by default, int type -->
+                    <Width>800</Width>
+                    <!-- High resolution is enabled by default, int type -->
+                    <Height>600</Height>
+                    <!-- The frame rate of the resolution enabled by default, int type -->
+                    <FPS>30</FPS>
+                    <Format>Y8</Format>
+                </IR>
+            </HighResolution>
+            <ClassicResolution>
+                <Depth>
+                    <!-- The resolution width is enabled by default, int type -->
+                    <Width>640</Width>
+                    <!-- High resolution is enabled by default, int type -->
+                    <Height>480</Height>
+                    <!-- The frame rate of the resolution enabled by default, int type -->
+                    <FPS>30</FPS>
+                    <Format>RLE</Format>
+                </Depth>
+                <Color>
+                    <!-- The resolution width is enabled by default, int type -->
+                    <Width>1280</Width>
+                    <!-- High resolution is enabled by default, int type -->
+                    <Height>720</Height>
+                    <!-- The frame rate of the resolution enabled by default, int type -->
+                    <FPS>30</FPS>
+                    <Format>MJPG</Format>
+                </Color>
+                <IR>
+                    <!-- The resolution width is enabled by default, int type -->
+                    <Width>640</Width>
+                    <!-- High resolution is enabled by default, int type -->
+                    <Height>480</Height>
+                    <!-- The frame rate of the resolution enabled by default, int type -->
+                    <FPS>30</FPS>
+                    <Format>Y8</Format>
+                </IR>
+            </ClassicResolution>
+        </Astra2>
+        <!--  Gemini2VL config -->
+        <Gemini2VL>
+            <!-- Whether to enable heartbeat by default -->
+            <DefaulHeartBeat>0</DefaulHeartBeat>
+
+            <Color>
+                <!-- The resolution width is enabled by default, int type -->
+                <Width>1280</Width>
+                <!-- High resolution is enabled by default, int type -->
+                <Height>800</Height>
+                <!-- The frame rate of the resolution enabled by default, int type -->
+                <FPS>30</FPS>
+                <Format>MJPG</Format>
+                <!-- Number of retries for open stream failures, 0 means no retries -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+            </Color>
+            <LeftIR>
+                <!-- The resolution width is enabled by default, int type -->
+                <Width>1280</Width>
+                <!-- High resolution is enabled by default, int type -->
+                <Height>800</Height>
+                <!-- The frame rate of the resolution enabled by default, int type -->
+                <FPS>30</FPS>
+                <Format>Y8</Format>
+                <!-- Number of retries for open stream failures, 0 means no retries -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+            </LeftIR>
+            <RightIR>
+                <!-- The resolution width is enabled by default, int type -->
+                <Width>1280</Width>
+                <!-- High resolution is enabled by default, int type -->
+                <Height>800</Height>
+                <!-- The frame rate of the resolution enabled by default, int type -->
+                <FPS>30</FPS>
+                <Format>Y8</Format>
+                <!-- Number of retries for open stream failures, 0 means no retries -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+            </RightIR>
+
+            <!-- Configurations in different camera depth modes -->
+            <BinnedSparseStereoImaging>
+                <Color>
+                    <!-- The resolution width is enabled by default, int type -->
+                    <Width>1280</Width>
+                    <!-- High resolution is enabled by default, int type -->
+                    <Height>800</Height>
+                    <!-- The frame rate of the resolution enabled by default, int type -->
+                    <FPS>30</FPS>
+                    <Format>MJPG</Format>
+                    <!-- Number of retries for open stream failures, 0 means no retries -->
+                    <StreamFailedRetry>0</StreamFailedRetry>
+                </Color>
+                <LeftIR>
+                    <!-- The resolution width is enabled by default, int type -->
+                    <Width>640</Width>
+                    <!-- High resolution is enabled by default, int type -->
+                    <Height>400</Height>
+                    <!-- The frame rate of the resolution enabled by default, int type -->
+                    <FPS>30</FPS>
+                    <Format>Y8</Format>
+                    <!-- Number of retries for open stream failures, 0 means no retries -->
+                    <StreamFailedRetry>0</StreamFailedRetry>
+                </LeftIR>
+                <RightIR>
+                    <!-- The resolution width is enabled by default, int type -->
+                    <Width>640</Width>
+                    <!-- High resolution is enabled by default, int type -->
+                    <Height>400</Height>
+                    <!-- The frame rate of the resolution enabled by default, int type -->
+                    <FPS>30</FPS>
+                    <Format>Y8</Format>
+                    <!-- Number of retries for open stream failures, 0 means no retries -->
+                    <StreamFailedRetry>0</StreamFailedRetry>
+                </RightIR>
+            </BinnedSparseStereoImaging>
+            <FactoryCalibration>
+                <Color>
+                    <!-- The resolution width is enabled by default, int type -->
+                    <Width>1920</Width>
+                    <!-- High resolution is enabled by default, int type -->
+                    <Height>1080</Height>
+                    <!-- The frame rate of the resolution enabled by default, int type -->
+                    <FPS>30</FPS>
+                    <Format>MJPG</Format>
+                    <!-- Number of retries for open stream failures, 0 means no retries -->
+                    <StreamFailedRetry>0</StreamFailedRetry>
+                </Color>
+                <LeftIR>
+                    <!-- The resolution width is enabled by default, int type -->
+                    <Width>1280</Width>
+                    <!-- High resolution is enabled by default, int type -->
+                    <Height>800</Height>
+                    <!-- The frame rate of the resolution enabled by default, int type -->
+                    <FPS>30</FPS>
+                    <Format>Y10</Format>
+                    <!-- Number of retries for open stream failures, 0 means no retries -->
+                    <StreamFailedRetry>0</StreamFailedRetry>
+                </LeftIR>
+                <RightIR>
+                    <!-- The resolution width is enabled by default, int type -->
+                    <Width>1280</Width>
+                    <!-- High resolution is enabled by default, int type -->
+                    <Height>800</Height>
+                    <!-- The frame rate of the resolution enabled by default, int type -->
+                    <FPS>30</FPS>
+                    <Format>Y10</Format>
+                    <!-- Number of retries for open stream failures, 0 means no retries -->
+                    <StreamFailedRetry>0</StreamFailedRetry>
+                </RightIR>
+
+            </FactoryCalibration>
+            <In-sceneCalibration>
+                <Color>
+                    <!-- The resolution width is enabled by default, int type -->
+                    <Width>1920</Width>
+                    <!-- High resolution is enabled by default, int type -->
+                    <Height>1080</Height>
+                    <!-- The frame rate of the resolution enabled by default, int type -->
+                    <FPS>30</FPS>
+                    <Format>MJPG</Format>
+                    <!-- Number of retries for open stream failures, 0 means no retries -->
+                    <StreamFailedRetry>0</StreamFailedRetry>
+                </Color>
+                <LeftIR>
+                    <!-- The resolution width is enabled by default, int type -->
+                    <Width>1280</Width>
+                    <!-- High resolution is enabled by default, int type -->
+                    <Height>800</Height>
+                    <!-- The frame rate of the resolution enabled by default, int type -->
+                    <FPS>30</FPS>
+                    <Format>Y8</Format>
+                    <!-- Number of retries for open stream failures, 0 means no retries -->
+                    <StreamFailedRetry>0</StreamFailedRetry>
+                </LeftIR>
+                <RightIR>
+                    <!-- The resolution width is enabled by default, int type -->
+                    <Width>1280</Width>
+                    <!-- High resolution is enabled by default, int type -->
+                    <Height>800</Height>
+                    <!-- The frame rate of the resolution enabled by default, int type -->
+                    <FPS>30</FPS>
+                    <Format>Y8</Format>
+                    <!-- Number of retries for open stream failures, 0 means no retries -->
+                    <StreamFailedRetry>0</StreamFailedRetry>
+                </RightIR>
+            </In-sceneCalibration>
+        </Gemini2VL>
+        <!--  Gemini2XL config -->
+        <Gemini2XL>
+            <!-- Whether to enable heartbeat by default -->
+            <DefaulHeartBeat>0</DefaulHeartBeat>
+
+            <Depth>
+                <!-- Number of retries for open stream failures, 0 means no retries -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+                <!-- Open flow waits for the timeout period of the first frame of data, after which
+                the open flow will fail -->
+                <MaxStartStreamDelayMs>5000</MaxStartStreamDelayMs>
+                <!-- The number of data stream restarts due to abnormal interruption, 0 means no
+                restart -->
+                <StreamInterruptedRestart>5</StreamInterruptedRestart>
+                <!-- The maximum frame interval time, if this value is exceeded, it will be judged
+                that the stream is interrupted -->
+                <MaxFrameIntervalMs>5000</MaxFrameIntervalMs>
+                <!-- The resolution width is enabled by default, int type -->
+                <Width>1280</Width>
+                <!-- High resolution is enabled by default, int type -->
+                <Height>800</Height>
+                <!-- The frame rate of the resolution enabled by default, int type -->
+                <FPS>10</FPS>
+                <Format>RVL</Format>
+            </Depth>
+            <Color>
+                <!-- The resolution width is enabled by default, int type -->
+                <Width>1280</Width>
+                <!-- High resolution is enabled by default, int type -->
+                <Height>800</Height>
+                <!-- The frame rate of the resolution enabled by default, int type -->
+                <FPS>10</FPS>
+                <Format>MJPG</Format>
+                <!-- Number of retries for open stream failures, 0 means no retries -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+                <!-- The number of data stream restarts due to abnormal interruption, 0 means no
+                restart -->
+                <StreamInterruptedRestart>5</StreamInterruptedRestart>
+                <!-- The maximum frame interval time, if this value is exceeded, it will be judged
+                that the stream is interrupted -->
+                <MaxFrameIntervalMs>5000</MaxFrameIntervalMs>
+            </Color>
+            <LeftIR>
+                <!-- The resolution width is enabled by default, int type -->
+                <Width>1280</Width>
+                <!-- High resolution is enabled by default, int type -->
+                <Height>800</Height>
+                <!-- The frame rate of the resolution enabled by default, int type -->
+                <FPS>10</FPS>
+                <Format>Y8</Format>
+                <!-- Number of retries for open stream failures, 0 means no retries -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+                <!-- The number of data stream restarts due to abnormal interruption, 0 means no
+                restart -->
+                <StreamInterruptedRestart>5</StreamInterruptedRestart>
+                <!-- The maximum frame interval time, if this value is exceeded, it will be judged
+                that the stream is interrupted -->
+                <MaxFrameIntervalMs>5000</MaxFrameIntervalMs>
+            </LeftIR>
+            <RightIR>
+                <!-- The resolution width is enabled by default, int type -->
+                <Width>1280</Width>
+                <!-- High resolution is enabled by default, int type -->
+                <Height>800</Height>
+                <!-- The frame rate of the resolution enabled by default, int type -->
+                <FPS>10</FPS>
+                <Format>Y8</Format>
+                <!-- Number of retries for open stream failures, 0 means no retries -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+                <!-- The number of data stream restarts due to abnormal interruption, 0 means no
+                restart -->
+                <StreamInterruptedRestart>5</StreamInterruptedRestart>
+                <!-- The maximum frame interval time, if this value is exceeded, it will be judged
+                that the stream is interrupted -->
+                <MaxFrameIntervalMs>5000</MaxFrameIntervalMs>
+            </RightIR>
+            <Accel>
+                <!-- The number of data stream restarts due to abnormal interruption, 0 means no
+                restart -->
+                <StreamInterruptedRestart>5</StreamInterruptedRestart>
+                <!-- The maximum frame interval time, if this value is exceeded, it will be judged
+                that the stream is interrupted -->
+                <MaxFrameIntervalMs>5000</MaxFrameIntervalMs>
+            </Accel>
+            <Gyro>
+                <!-- The number of data stream restarts due to abnormal interruption, 0 means no
+                restart -->
+                <StreamInterruptedRestart>5</StreamInterruptedRestart>
+                <!-- The maximum frame interval time, if this value is exceeded, it will be judged
+                that the stream is interrupted -->
+                <MaxFrameIntervalMs>5000</MaxFrameIntervalMs>
+            </Gyro>
+
+            <!-- Configurations in different camera depth modes -->
+            <BinnedSparseDefault>
+                <Color>
+                    <!-- The resolution width is enabled by default, int type -->
+                    <Width>1280</Width>
+                    <!-- High resolution is enabled by default, int type -->
+                    <Height>800</Height>
+                    <!-- The frame rate of the resolution enabled by default, int type -->
+                    <FPS>20</FPS>
+                    <Format>MJPG</Format>
+                    <!-- Number of retries for open stream failures, 0 means no retries -->
+                    <StreamFailedRetry>0</StreamFailedRetry>
+                    <!-- The number of data stream restarts due to abnormal interruption, 0 means no
+                    restart -->
+                    <StreamInterruptedRestart>5</StreamInterruptedRestart>
+                    <!-- The maximum frame interval time, if this value is exceeded, it will be
+                    judged that the stream is interrupted -->
+                    <MaxFrameIntervalMs>5000</MaxFrameIntervalMs>
+                </Color>
+                <Depth>
+                    <!-- The resolution width is enabled by default, int type -->
+                    <Width>640</Width>
+                    <!-- High resolution is enabled by default, int type -->
+                    <Height>400</Height>
+                    <!-- The frame rate of the resolution enabled by default, int type -->
+                    <FPS>20</FPS>
+                    <Format>RVL</Format>
+                    <!-- Number of retries for open stream failures, 0 means no retries -->
+                    <StreamFailedRetry>0</StreamFailedRetry>
+                    <!-- The number of data stream restarts due to abnormal interruption, 0 means no
+                    restart -->
+                    <StreamInterruptedRestart>5</StreamInterruptedRestart>
+                    <!-- The maximum frame interval time, if this value is exceeded, it will be
+                    judged that the stream is interrupted -->
+                    <MaxFrameIntervalMs>5000</MaxFrameIntervalMs>
+                </Depth>
+                <LeftIR>
+                    <!-- The resolution width is enabled by default, int type -->
+                    <Width>640</Width>
+                    <!-- High resolution is enabled by default, int type -->
+                    <Height>400</Height>
+                    <!-- The frame rate of the resolution enabled by default, int type -->
+                    <FPS>20</FPS>
+                    <Format>Y8</Format>
+                    <!-- Number of retries for open stream failures, 0 means no retries -->
+                    <StreamFailedRetry>0</StreamFailedRetry>
+                    <!-- The number of data stream restarts due to abnormal interruption, 0 means no
+                    restart -->
+                    <StreamInterruptedRestart>5</StreamInterruptedRestart>
+                    <!-- The maximum frame interval time, if this value is exceeded, it will be
+                    judged that the stream is interrupted -->
+                    <MaxFrameIntervalMs>5000</MaxFrameIntervalMs>
+                </LeftIR>
+                <RightIR>
+                    <!-- The resolution width is enabled by default, int type -->
+                    <Width>640</Width>
+                    <!-- High resolution is enabled by default, int type -->
+                    <Height>400</Height>
+                    <!-- The frame rate of the resolution enabled by default, int type -->
+                    <FPS>20</FPS>
+                    <Format>Y8</Format>
+                    <!-- Number of retries for open stream failures, 0 means no retries -->
+                    <StreamFailedRetry>0</StreamFailedRetry>
+                    <!-- The number of data stream restarts due to abnormal interruption, 0 means no
+                    restart -->
+                    <StreamInterruptedRestart>5</StreamInterruptedRestart>
+                    <!-- The maximum frame interval time, if this value is exceeded, it will be
+                    judged that the stream is interrupted -->
+                    <MaxFrameIntervalMs>5000</MaxFrameIntervalMs>
+                </RightIR>
+            </BinnedSparseDefault>
+            <FactoryCalibration>
+                <Color>
+                    <!-- The resolution width is enabled by default, int type -->
+                    <Width>1280</Width>
+                    <!-- High resolution is enabled by default, int type -->
+                    <Height>800</Height>
+                    <!-- The frame rate of the resolution enabled by default, int type -->
+                    <FPS>10</FPS>
+                    <Format>MJPG</Format>
+                    <!-- Number of retries for open stream failures, 0 means no retries -->
+                    <StreamFailedRetry>0</StreamFailedRetry>
+                    <!-- The number of data stream restarts due to abnormal interruption, 0 means no
+                    restart -->
+                    <StreamInterruptedRestart>5</StreamInterruptedRestart>
+                    <!-- The maximum frame interval time, if this value is exceeded, it will be
+                    judged that the stream is interrupted -->
+                    <MaxFrameIntervalMs>5000</MaxFrameIntervalMs>
+                </Color>
+                <LeftIR>
+                    <!-- The resolution width is enabled by default, int type -->
+                    <Width>1280</Width>
+                    <!-- High resolution is enabled by default, int type -->
+                    <Height>800</Height>
+                    <!-- The frame rate of the resolution enabled by default, int type -->
+                    <FPS>10</FPS>
+                    <Format>Y10</Format>
+                    <!-- Number of retries for open stream failures, 0 means no retries -->
+                    <StreamFailedRetry>0</StreamFailedRetry>
+                    <!-- The number of data stream restarts due to abnormal interruption, 0 means no
+                    restart -->
+                    <StreamInterruptedRestart>5</StreamInterruptedRestart>
+                    <!-- The maximum frame interval time, if this value is exceeded, it will be
+                    judged that the stream is interrupted -->
+                    <MaxFrameIntervalMs>5000</MaxFrameIntervalMs>
+                </LeftIR>
+                <RightIR>
+                    <!-- The resolution width is enabled by default, int type -->
+                    <Width>1280</Width>
+                    <!-- High resolution is enabled by default, int type -->
+                    <Height>800</Height>
+                    <!-- The frame rate of the resolution enabled by default, int type -->
+                    <FPS>10</FPS>
+                    <Format>Y10</Format>
+                    <!-- Number of retries for open stream failures, 0 means no retries -->
+                    <StreamFailedRetry>0</StreamFailedRetry>
+                    <!-- The number of data stream restarts due to abnormal interruption, 0 means no
+                    restart -->
+                    <StreamInterruptedRestart>5</StreamInterruptedRestart>
+                    <!-- The maximum frame interval time, if this value is exceeded, it will be
+                    judged that the stream is interrupted -->
+                    <MaxFrameIntervalMs>5000</MaxFrameIntervalMs>
+                </RightIR>
+            </FactoryCalibration>
+            <In-sceneCalibration>
+                <Color>
+                    <!-- The resolution width is enabled by default, int type -->
+                    <Width>1280</Width>
+                    <!-- High resolution is enabled by default, int type -->
+                    <Height>800</Height>
+                    <!-- The frame rate of the resolution enabled by default, int type -->
+                    <FPS>10</FPS>
+                    <Format>MJPG</Format>
+                    <!-- Number of retries for open stream failures, 0 means no retries -->
+                    <StreamFailedRetry>0</StreamFailedRetry>
+                    <!-- The number of data stream restarts due to abnormal interruption, 0 means no
+                    restart -->
+                    <StreamInterruptedRestart>5</StreamInterruptedRestart>
+                    <!-- The maximum frame interval time, if this value is exceeded, it will be
+                    judged that the stream is interrupted -->
+                    <MaxFrameIntervalMs>5000</MaxFrameIntervalMs>
+                </Color>
+                <LeftIR>
+                    <!-- The resolution width is enabled by default, int type -->
+                    <Width>1280</Width>
+                    <!-- High resolution is enabled by default, int type -->
+                    <Height>800</Height>
+                    <!-- The frame rate of the resolution enabled by default, int type -->
+                    <FPS>10</FPS>
+                    <Format>Y8</Format>
+                    <!-- Number of retries for open stream failures, 0 means no retries -->
+                    <StreamFailedRetry>0</StreamFailedRetry>
+                    <!-- The number of data stream restarts due to abnormal interruption, 0 means no
+                    restart -->
+                    <StreamInterruptedRestart>5</StreamInterruptedRestart>
+                    <!-- The maximum frame interval time, if this value is exceeded, it will be
+                    judged that the stream is interrupted -->
+                    <MaxFrameIntervalMs>5000</MaxFrameIntervalMs>
+                </LeftIR>
+                <RightIR>
+                    <!-- The resolution width is enabled by default, int type -->
+                    <Width>1280</Width>
+                    <!-- High resolution is enabled by default, int type -->
+                    <Height>800</Height>
+                    <!-- The frame rate of the resolution enabled by default, int type -->
+                    <FPS>10</FPS>
+                    <Format>Y8</Format>
+                    <!-- Number of retries for open stream failures, 0 means no retries -->
+                    <StreamFailedRetry>0</StreamFailedRetry>
+                    <!-- The number of data stream restarts due to abnormal interruption, 0 means no
+                    restart -->
+                    <StreamInterruptedRestart>5</StreamInterruptedRestart>
+                    <!-- The maximum frame interval time, if this value is exceeded, it will be
+                    judged that the stream is interrupted -->
+                    <MaxFrameIntervalMs>5000</MaxFrameIntervalMs>
+                </RightIR>
+            </In-sceneCalibration>
+        </Gemini2XL>
+
+        <!-- Gemini2R config -->
+        <Gemini335>
+            <!-- Whether to enable heartbeat by default -->
+            <DefaultHeartBeat>0</DefaultHeartBeat>
+            <!-- Whether to enable firmware upgrade foolproof by default, only internal version
+            supports -->
+            <FirmwareUpgradeFoolproof>1</FirmwareUpgradeFoolproof>
+
+            <!--  Depth Filter Params -->
+            <!--
+            <DepthFilterDDOConfig>./Gemini2_v1.0.json</DepthFilterDDOConfig>
+			 -->
+            <Depth>
+                <!-- Number of retries for open stream failures, 0 means no retries -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+                <!-- Open flow waits for the timeout period of the first frame of data, after which
+                the open flow will fail -->
+                <MaxStartStreamDelayMs>5000</MaxStartStreamDelayMs>
+                <!-- The number of data stream restarts due to abnormal interruption, 0 means no
+                restart -->
+                <StreamInterruptedRestart>0</StreamInterruptedRestart>
+                <!-- The maximum frame interval time, if this value is exceeded, it will be judged
+                that the stream is interrupted -->
+                <MaxFrameIntervalMs>2000</MaxFrameIntervalMs>
+                <!-- The resolution width is enabled by default, int type -->
+                <Width>848</Width>
+                <!-- High resolution is enabled by default, int type -->
+                <Height>480</Height>
+                <!-- The frame rate of the resolution enabled by default, int type -->
+                <FPS>30</FPS>
+                <Format>Y16</Format>
+            </Depth>
+            <Color>
+                <!-- The resolution width is enabled by default, int type -->
+                <Width>1280</Width>
+                <!-- High resolution is enabled by default, int type -->
+                <Height>720</Height>
+                <!-- The frame rate of the resolution enabled by default, int type -->
+                <FPS>30</FPS>
+                <Format>MJPG</Format>
+            </Color>
+            <IR>
+                <!-- The resolution width is enabled by default, int type -->
+                <Width>848</Width>
+                <!-- High resolution is enabled by default, int type -->
+                <Height>480</Height>
+                <!-- The frame rate of the resolution enabled by default, int type -->
+                <FPS>30</FPS>
+                <Format>Y8</Format>
+            </IR>
+            <LeftIR>
+                <!-- The resolution width is enabled by default, int type -->
+                <Width>848</Width>
+                <!-- High resolution is enabled by default, int type -->
+                <Height>480</Height>
+                <!-- The frame rate of the resolution enabled by default, int type -->
+                <FPS>30</FPS>
+                <Format>Y8</Format>
+            </LeftIR>
+            <RightIR>
+                <!-- The resolution width is enabled by default, int type -->
+                <Width>848</Width>
+                <!-- High resolution is enabled by default, int type -->
+                <Height>480</Height>
+                <!-- The frame rate of the resolution enabled by default, int type -->
+                <FPS>30</FPS>
+                <Format>Y8</Format>
+            </RightIR>
+        </Gemini335>
+        <!-- Gemini2RL config -->
+        <Gemini335L>
+            <!-- Whether to enable heartbeat by default -->
+            <DefaultHeartBeat>0</DefaultHeartBeat>
+            <!-- Whether to enable firmware upgrade foolproof by default, only internal version
+            supports -->
+            <FirmwareUpgradeFoolproof>1</FirmwareUpgradeFoolproof>
+
+            <!--  Depth Filter Params -->
+            <!--
+            <DepthFilterDDOConfig>./Gemini2_v1.0.json</DepthFilterDDOConfig>
+			 -->
+            <Depth>
+                <!-- Number of retries for open stream failures, 0 means no retries -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+                <!-- Open flow waits for the timeout period of the first frame of data, after which
+                the open flow will fail -->
+                <MaxStartStreamDelayMs>5000</MaxStartStreamDelayMs>
+                <!-- The number of data stream restarts due to abnormal interruption, 0 means no
+                restart -->
+                <StreamInterruptedRestart>0</StreamInterruptedRestart>
+                <!-- The maximum frame interval time, if this value is exceeded, it will be judged
+                that the stream is interrupted -->
+                <MaxFrameIntervalMs>2000</MaxFrameIntervalMs>
+                <!-- The resolution width is enabled by default, int type -->
+                <Width>848</Width>
+                <!-- High resolution is enabled by default, int type -->
+                <Height>480</Height>
+                <!-- The frame rate of the resolution enabled by default, int type -->
+                <FPS>30</FPS>
+                <Format>Y16</Format>
+            </Depth>
+            <Color>
+                <!-- The resolution width is enabled by default, int type -->
+                <Width>1280</Width>
+                <!-- High resolution is enabled by default, int type -->
+                <Height>720</Height>
+                <!-- The frame rate of the resolution enabled by default, int type -->
+                <FPS>30</FPS>
+                <Format>MJPG</Format>
+            </Color>
+            <IR>
+                <!-- The resolution width is enabled by default, int type -->
+                <Width>848</Width>
+                <!-- High resolution is enabled by default, int type -->
+                <Height>480</Height>
+                <!-- The frame rate of the resolution enabled by default, int type -->
+                <FPS>30</FPS>
+                <Format>Y8</Format>
+            </IR>
+            <LeftIR>
+                <!-- The resolution width is enabled by default, int type -->
+                <Width>848</Width>
+                <!-- High resolution is enabled by default, int type -->
+                <Height>480</Height>
+                <!-- The frame rate of the resolution enabled by default, int type -->
+                <FPS>30</FPS>
+                <Format>Y8</Format>
+            </LeftIR>
+            <RightIR>
+                <!-- The resolution width is enabled by default, int type -->
+                <Width>848</Width>
+                <!-- High resolution is enabled by default, int type -->
+                <Height>480</Height>
+                <!-- The frame rate of the resolution enabled by default, int type -->
+                <FPS>30</FPS>
+                <Format>Y8</Format>
+            </RightIR>
+        </Gemini335L>
+
+        <!-- Gemini335Lg config -->
+        <Gemini335Lg>
+            <!-- Whether to enable heartbeat by default -->
+            <DefaultHeartBeat>0</DefaultHeartBeat>
+            <!-- Whether to enable firmware upgrade foolproof by default, only internal version
+            supports -->
+            <FirmwareUpgradeFoolproof>1</FirmwareUpgradeFoolproof>
+            <Depth>
+                <!-- Number of retries for open stream failures, 0 means no retries -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+                <!-- Open flow waits for the timeout period of the first frame of data, after which
+                the open flow will fail -->
+                <MaxStartStreamDelayMs>5000</MaxStartStreamDelayMs>
+                <!-- The number of data stream restarts due to abnormal interruption, 0 means no
+                restart -->
+                <StreamInterruptedRestart>0</StreamInterruptedRestart>
+                <!-- The maximum frame interval time, if this value is exceeded, it will be judged
+                that the stream is interrupted -->
+                <MaxFrameIntervalMs>2000</MaxFrameIntervalMs>
+                <!-- The resolution width is enabled by default, int type -->
+                <Width>848</Width>
+                <!-- High resolution is enabled by default, int type -->
+                <Height>480</Height>
+                <!-- The frame rate of the resolution enabled by default, int type -->
+                <FPS>30</FPS>
+                <Format>Y16</Format>
+            </Depth>
+            <Color>
+                <!-- The resolution width is enabled by default, int type -->
+                <Width>1280</Width>
+                <!-- High resolution is enabled by default, int type -->
+                <Height>720</Height>
+                <!-- The frame rate of the resolution enabled by default, int type -->
+                <FPS>30</FPS>
+                <Format>MJPG</Format>
+            </Color>
+            <IR>
+                <!-- The resolution width is enabled by default, int type -->
+                <Width>848</Width>
+                <!-- High resolution is enabled by default, int type -->
+                <Height>480</Height>
+                <!-- The frame rate of the resolution enabled by default, int type -->
+                <FPS>30</FPS>
+                <Format>Y8</Format>
+            </IR>
+            <LeftIR>
+                <!-- The resolution width is enabled by default, int type -->
+                <Width>848</Width>
+                <!-- High resolution is enabled by default, int type -->
+                <Height>480</Height>
+                <!-- The frame rate of the resolution enabled by default, int type -->
+                <FPS>30</FPS>
+                <Format>Y8</Format>
+            </LeftIR>
+            <RightIR>
+                <!-- The resolution width is enabled by default, int type -->
+                <Width>848</Width>
+                <!-- High resolution is enabled by default, int type -->
+                <Height>480</Height>
+                <!-- The frame rate of the resolution enabled by default, int type -->
+                <FPS>30</FPS>
+                <Format>Y8</Format>
+            </RightIR>
+        </Gemini335Lg>
+        <!-- Gemini 336 config -->
+        <Gemini336>
+            <!-- Whether to enable heartbeat by default -->
+            <DefaultHeartBeat>0</DefaultHeartBeat>
+            <!-- Whether to enable firmware upgrade foolproof by default, only internal version
+            supports -->
+            <FirmwareUpgradeFoolproof>1</FirmwareUpgradeFoolproof>
+
+            <!--  Depth Filter Params -->
+            <!--
+            <DepthFilterDDOConfig>./Gemini2_v1.0.json</DepthFilterDDOConfig>
+			 -->
+            <Depth>
+                <!-- Number of retries for open stream failures, 0 means no retries -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+                <!-- Open flow waits for the timeout period of the first frame of data, after which
+                the open flow will fail -->
+                <MaxStartStreamDelayMs>5000</MaxStartStreamDelayMs>
+                <!-- The number of data stream restarts due to abnormal interruption, 0 means no
+                restart -->
+                <StreamInterruptedRestart>0</StreamInterruptedRestart>
+                <!-- The maximum frame interval time, if this value is exceeded, it will be judged
+                that the stream is interrupted -->
+                <MaxFrameIntervalMs>2000</MaxFrameIntervalMs>
+                <!-- The resolution width is enabled by default, int type -->
+                <Width>848</Width>
+                <!-- High resolution is enabled by default, int type -->
+                <Height>480</Height>
+                <!-- The frame rate of the resolution enabled by default, int type -->
+                <FPS>30</FPS>
+                <Format>Y16</Format>
+            </Depth>
+            <Color>
+                <!-- The resolution width is enabled by default, int type -->
+                <Width>1280</Width>
+                <!-- High resolution is enabled by default, int type -->
+                <Height>720</Height>
+                <!-- The frame rate of the resolution enabled by default, int type -->
+                <FPS>30</FPS>
+                <Format>MJPG</Format>
+            </Color>
+            <IR>
+                <!-- The resolution width is enabled by default, int type -->
+                <Width>848</Width>
+                <!-- High resolution is enabled by default, int type -->
+                <Height>480</Height>
+                <!-- The frame rate of the resolution enabled by default, int type -->
+                <FPS>30</FPS>
+                <Format>Y8</Format>
+            </IR>
+            <LeftIR>
+                <!-- The resolution width is enabled by default, int type -->
+                <Width>848</Width>
+                <!-- High resolution is enabled by default, int type -->
+                <Height>480</Height>
+                <!-- The frame rate of the resolution enabled by default, int type -->
+                <FPS>30</FPS>
+                <Format>Y8</Format>
+            </LeftIR>
+            <RightIR>
+                <!-- The resolution width is enabled by default, int type -->
+                <Width>848</Width>
+                <!-- High resolution is enabled by default, int type -->
+                <Height>480</Height>
+                <!-- The frame rate of the resolution enabled by default, int type -->
+                <FPS>30</FPS>
+                <Format>Y8</Format>
+            </RightIR>
+        </Gemini336>
+        <!-- Gemini 336L config -->
+        <Gemini336L>
+            <!-- Whether to enable heartbeat by default -->
+            <DefaultHeartBeat>0</DefaultHeartBeat>
+            <!-- Whether to enable firmware upgrade foolproof by default, only internal version
+            supports -->
+            <FirmwareUpgradeFoolproof>1</FirmwareUpgradeFoolproof>
+
+            <!--  Depth Filter Params -->
+            <!--
+            <DepthFilterDDOConfig>./Gemini2_v1.0.json</DepthFilterDDOConfig>
+			 -->
+            <Depth>
+                <!-- Number of retries for open stream failures, 0 means no retries -->
+                <StreamFailedRetry>0</StreamFailedRetry>
+                <!-- Open flow waits for the timeout period of the first frame of data, after which
+                the open flow will fail -->
+                <MaxStartStreamDelayMs>5000</MaxStartStreamDelayMs>
+                <!-- The number of data stream restarts due to abnormal interruption, 0 means no
+                restart -->
+                <StreamInterruptedRestart>0</StreamInterruptedRestart>
+                <!-- The maximum frame interval time, if this value is exceeded, it will be judged
+                that the stream is interrupted -->
+                <MaxFrameIntervalMs>2000</MaxFrameIntervalMs>
+                <!-- The resolution width is enabled by default, int type -->
+                <Width>848</Width>
+                <!-- High resolution is enabled by default, int type -->
+                <Height>480</Height>
+                <!-- The frame rate of the resolution enabled by default, int type -->
+                <FPS>30</FPS>
+                <Format>Y16</Format>
+            </Depth>
+            <Color>
+                <!-- The resolution width is enabled by default, int type -->
+                <Width>1280</Width>
+                <!-- High resolution is enabled by default, int type -->
+                <Height>720</Height>
+                <!-- The frame rate of the resolution enabled by default, int type -->
+                <FPS>30</FPS>
+                <Format>MJPG</Format>
+            </Color>
+            <IR>
+                <!-- The resolution width is enabled by default, int type -->
+                <Width>848</Width>
+                <!-- High resolution is enabled by default, int type -->
+                <Height>480</Height>
+                <!-- The frame rate of the resolution enabled by default, int type -->
+                <FPS>30</FPS>
+                <Format>Y8</Format>
+            </IR>
+            <LeftIR>
+                <!-- The resolution width is enabled by default, int type -->
+                <Width>848</Width>
+                <!-- High resolution is enabled by default, int type -->
+                <Height>480</Height>
+                <!-- The frame rate of the resolution enabled by default, int type -->
+                <FPS>30</FPS>
+                <Format>Y8</Format>
+            </LeftIR>
+            <RightIR>
+                <!-- The resolution width is enabled by default, int type -->
+                <Width>848</Width>
+                <!-- High resolution is enabled by default, int type -->
+                <Height>480</Height>
+                <!-- The frame rate of the resolution enabled by default, int type -->
+                <FPS>30</FPS>
+                <Format>Y8</Format>
+            </RightIR>
+        </Gemini336L>
+        <!-- Gemini 215 config -->
+        <Gemini215>
+            <!-- Whether to enable heartbeat by default -->
+            <DefaultHeartBeat>0</DefaultHeartBeat>
+            <!-- Whether to enable firmware upgrade foolproof by default, only internal version
+            supports -->
+            <FirmwareUpgradeFoolproof>1</FirmwareUpgradeFoolproof>
+            <Depth>
+                <!-- The resolution width is enabled by default, int type -->
+                <Width>1280</Width>
+                <!-- High resolution is enabled by default, int type -->
+                <Height>800</Height>
+                <!-- The frame rate of the resolution enabled by default, int type -->
+                <FPS>15</FPS>
+                <Format>Y16</Format>
+                <ProfileFilter>
+                    <profile>
+                        <Format>Y8</Format>
+                    </profile>
+                </ProfileFilter>
+            </Depth>
+            <Color>
+                <!-- The resolution width is enabled by default, int type -->
+                <Width>1280</Width>
+                <!-- High resolution is enabled by default, int type -->
+                <Height>720</Height>
+                <!-- The frame rate of the resolution enabled by default, int type -->
+                <FPS>15</FPS>
+                <Format>MJPG</Format>
+            </Color>
+            <IR>
+                <!-- The resolution width is enabled by default, int type -->
+                <Width>1280</Width>
+                <!-- High resolution is enabled by default, int type -->
+                <Height>800</Height>
+                <!-- The frame rate of the resolution enabled by default, int type -->
+                <FPS>15</FPS>
+                <Format>Y8</Format>
+            </IR>
+            <LeftIR>
+                <!-- The resolution width is enabled by default, int type -->
+                <Width>1280</Width>
+                <!-- High resolution is enabled by default, int type -->
+                <Height>800</Height>
+                <!-- The frame rate of the resolution enabled by default, int type -->
+                <FPS>15</FPS>
+                <Format>Y8</Format>
+            </LeftIR>
+            <RightIR>
+                <!-- The resolution width is enabled by default, int type -->
+                <Width>1280</Width>
+                <!-- High resolution is enabled by default, int type -->
+                <Height>800</Height>
+                <!-- The frame rate of the resolution enabled by default, int type -->
+                <FPS>15</FPS>
+                <Format>Y16</Format>
+                <ProfileFilter>
+                    <profile>
+                        <Format>Y8</Format>
+                    </profile>
+                </ProfileFilter>
+            </RightIR>
+        </Gemini215>
+        <!-- Gemini 210 config -->
+        <Gemini210>
+            <!-- Whether to enable heartbeat by default -->
+            <DefaultHeartBeat>0</DefaultHeartBeat>
+            <!-- Whether to enable firmware upgrade foolproof by default, only internal version
+            supports -->
+            <FirmwareUpgradeFoolproof>1</FirmwareUpgradeFoolproof>
+            <Depth>
+                <!-- The resolution width is enabled by default, int type -->
+                <Width>1280</Width>
+                <!-- High resolution is enabled by default, int type -->
+                <Height>800</Height>
+                <!-- The frame rate of the resolution enabled by default, int type -->
+                <FPS>15</FPS>
+                <Format>Y16</Format>
+                <ProfileFilter>
+                    <profile>
+                        <Format>Y8</Format>
+                    </profile>
+                </ProfileFilter>
+            </Depth>
+            <Color>
+                <!-- The resolution width is enabled by default, int type -->
+                <Width>1280</Width>
+                <!-- High resolution is enabled by default, int type -->
+                <Height>720</Height>
+                <!-- The frame rate of the resolution enabled by default, int type -->
+                <FPS>15</FPS>
+                <Format>MJPG</Format>
+            </Color>
+            <IR>
+                <!-- The resolution width is enabled by default, int type -->
+                <Width>1280</Width>
+                <!-- High resolution is enabled by default, int type -->
+                <Height>800</Height>
+                <!-- The frame rate of the resolution enabled by default, int type -->
+                <FPS>15</FPS>
+                <Format>Y8</Format>
+            </IR>
+            <LeftIR>
+                <!-- The resolution width is enabled by default, int type -->
+                <Width>1280</Width>
+                <!-- High resolution is enabled by default, int type -->
+                <Height>800</Height>
+                <!-- The frame rate of the resolution enabled by default, int type -->
+                <FPS>15</FPS>
+                <Format>Y8</Format>
+            </LeftIR>
+            <RightIR>
+                <!-- The resolution width is enabled by default, int type -->
+                <Width>1280</Width>
+                <!-- High resolution is enabled by default, int type -->
+                <Height>800</Height>
+                <!-- The frame rate of the resolution enabled by default, int type -->
+                <FPS>15</FPS>
+                <Format>Y16</Format>
+                <ProfileFilter>
+                    <profile>
+                        <Format>Y8</Format>
+                    </profile>
+                </ProfileFilter>
+            </RightIR>
+        </Gemini210>
+    </Device>
+</Config>
\ No newline at end of file
diff --git a/src/shared/environment/Version.hpp.in b/src/shared/environment/Version.hpp.in
new file mode 100644
index 00000000..d54578e2
--- /dev/null
+++ b/src/shared/environment/Version.hpp.in
@@ -0,0 +1,31 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// clang-format off
+#define OB_LIB_MAJOR_VERSION ${PROJECT_VERSION_MAJOR}
+#define OB_LIB_MINOR_VERSION ${PROJECT_VERSION_MINOR}
+#define OB_LIB_PATCH_VERSION ${PROJECT_VERSION_PATCH}
+
+#ifndef OB_LIB_STAGE_VERSION
+#define OB_LIB_STAGE_VERSION "open-source-beta"
+#endif
+
+#ifndef STRINGIFY
+#define STRINGIFY(arg) #arg
+#endif
+#ifndef VAR_ARG_STRING
+#define VAR_ARG_STRING(arg) STRINGIFY(arg)
+#endif
+
+#define OB_LIB_VERSION (((OB_LIB_MAJOR_VERSION)*10000) + ((OB_LIB_MINOR_VERSION)*100) + (OB_LIB_PATCH_VERSION))
+#define OB_LIB_VERSION_STR (VAR_ARG_STRING(OB_LIB_MAJOR_VERSION.OB_LIB_MINOR_VERSION.OB_LIB_PATCH_VERSION))
+// clang-format on
+#ifdef __cplusplus
+}
+#endif
diff --git a/src/shared/exception/ObException.cpp b/src/shared/exception/ObException.cpp
new file mode 100644
index 00000000..3a1e9bb5
--- /dev/null
+++ b/src/shared/exception/ObException.cpp
@@ -0,0 +1,10 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "ObException.hpp"
+#include "logger/Logger.hpp"
+namespace libobsensor{
+recoverable_exception::recoverable_exception(const std::string &msg, ob_exception_type exception_type) noexcept : libobsensor_exception(msg, exception_type) {
+    LOG_WARN(msg);
+}
+}  // namespace ob
diff --git a/src/shared/exception/ObException.hpp b/src/shared/exception/ObException.hpp
new file mode 100644
index 00000000..ce9eb6b0
--- /dev/null
+++ b/src/shared/exception/ObException.hpp
@@ -0,0 +1,212 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include <string>
+#include <exception>
+#include <typeinfo>
+#include "logger/Logger.hpp"
+
+#ifdef _WIN32
+#define __FILENAME__ (strrchr(__FILE__, '\\') ? strrchr(__FILE__, '\\') + 1 : __FILE__)
+#else
+#define __FILENAME__ (strrchr(__FILE__, '/') ? strrchr(__FILE__, '/') + 1 : __FILE__)
+#endif
+
+namespace libobsensor {
+class libobsensor_exception : public std::exception {
+public:
+    const char *get_message() const noexcept {
+        return _msg.c_str();
+    }
+
+    ob_exception_type get_exception_type() const noexcept {
+        return _exception_type;
+    }
+
+    const char *what() const noexcept override {
+        return _msg.c_str();
+    }
+
+public:
+    libobsensor_exception(const std::string &msg, ob_exception_type exception_type) noexcept : _msg(msg), _exception_type(exception_type) {}
+
+private:
+    std::string       _msg;
+    ob_exception_type _exception_type;
+};
+
+class recoverable_exception : public libobsensor_exception {
+public:
+    recoverable_exception(const std::string &msg, ob_exception_type exception_type) noexcept;
+};
+
+class unrecoverable_exception : public libobsensor_exception {
+public:
+    unrecoverable_exception(const std::string &msg, ob_exception_type exception_type) noexcept : libobsensor_exception(msg, exception_type) {
+        LOG_WARN(msg);
+    }
+};
+
+class io_exception : public unrecoverable_exception {
+public:
+    io_exception(const std::string &msg) noexcept : unrecoverable_exception(msg, OB_EXCEPTION_TYPE_IO) {}
+};
+
+class memory_exception : public unrecoverable_exception {
+public:
+    memory_exception(const std::string &msg) noexcept : unrecoverable_exception(msg, OB_EXCEPTION_TYPE_MEMORY) {}
+};
+
+class camera_disconnected_exception : public unrecoverable_exception {
+public:
+    camera_disconnected_exception(const std::string &msg) noexcept : unrecoverable_exception(msg, OB_EXCEPTION_TYPE_CAMERA_DISCONNECTED) {}
+};
+
+class pal_exception : public unrecoverable_exception {
+public:
+    pal_exception(const std::string &msg) noexcept : unrecoverable_exception(msg, OB_EXCEPTION_TYPE_PLATFORM) {}
+};
+
+class invalid_value_exception : public recoverable_exception {
+public:
+    invalid_value_exception(const std::string &msg) noexcept : recoverable_exception(msg, OB_EXCEPTION_TYPE_INVALID_VALUE) {}
+};
+
+class unsupported_operation_exception : public recoverable_exception {
+public:
+    unsupported_operation_exception(const std::string &msg) noexcept : recoverable_exception(msg, OB_EXCEPTION_TYPE_UNSUPPORTED_OPERATION) {}
+};
+class wrong_api_call_sequence_exception : public recoverable_exception {
+public:
+    wrong_api_call_sequence_exception(const std::string &msg) noexcept : recoverable_exception(msg, OB_EXCEPTION_TYPE_WRONG_API_CALL_SEQUENCE) {}
+};
+
+class not_implemented_exception : public recoverable_exception {
+public:
+    not_implemented_exception(const std::string &msg) noexcept : recoverable_exception(msg, OB_EXCEPTION_TYPE_NOT_IMPLEMENTED) {}
+};
+
+#define BEGIN_TRY_EXECUTE(statement) \
+    try {                            \
+        statement;                   \
+    }
+
+#define CATCH_EXCEPTION                                                                                                                                      \
+    catch(const libobsensor::libobsensor_exception &e) {                                                                                                     \
+        LOG_WARN("Execute failure! A libobsensor_exception has occurred!\n - where: {0}({1}):{2}\n - msg: {3}\n - type: {4}", __FILENAME__, __LINE__,        \
+                 __FUNCTION__, e.get_message(), typeid(e).name());                                                                                           \
+    }                                                                                                                                                        \
+    catch(const std::exception &e) {                                                                                                                         \
+        LOG_WARN("Execute failure! A std::exception has occurred!\n - where: {0}({1}):{2}\n - msg: {3}\n - type: {4}", __FILENAME__, __LINE__, __FUNCTION__, \
+                 e.what(), typeid(e).name());                                                                                                                \
+    }                                                                                                                                                        \
+    catch(...) {                                                                                                                                             \
+        LOG_WARN("Execute failure! An unknown exception has occurred!\n - where: {0}({1}):{2}", __FILENAME__, __LINE__, __FUNCTION__);                       \
+    }
+
+#define CATCH_EXCEPTION_AND_EXECUTE(statement)                                                                                                               \
+    catch(const libobsensor::libobsensor_exception &e) {                                                                                                     \
+        LOG_WARN("Execute failure! A libobsensor_exception has occurred!\n - where: {0}({1}):{2}\n - msg: {3}\n - type: {4}", __FILENAME__, __LINE__,        \
+                 __FUNCTION__, e.get_message(), typeid(e).name());                                                                                           \
+        statement;                                                                                                                                           \
+    }                                                                                                                                                        \
+    catch(const std::exception &e) {                                                                                                                         \
+        LOG_WARN("Execute failure! A std::exception has occurred!\n - where: {0}({1}):{2}\n - msg: {3}\n - type: {4}", __FILENAME__, __LINE__, __FUNCTION__, \
+                 e.what(), typeid(e).name());                                                                                                                \
+        statement;                                                                                                                                           \
+    }                                                                                                                                                        \
+    catch(...) {                                                                                                                                             \
+        LOG_WARN("Execute failure! An unknown exception has occurred!\n - where: {0}({1}):{2}", __FILENAME__, __LINE__, __FUNCTION__);                       \
+        statement;                                                                                                                                           \
+    }
+
+#define CATCH_EXCEPTION_AND_LOG(severity, ...) CATCH_EXCEPTION_AND_EXECUTE(LOG_##severity(__VA_ARGS__))
+
+#define TRY_EXECUTE(statement)   \
+    BEGIN_TRY_EXECUTE(statement) \
+    CATCH_EXCEPTION
+
+#define VALIDATE(ARG)                                                             \
+    if(!(ARG)) {                                                                  \
+        throw std::logic_error("Invalid value passed for argument \"" #ARG "\""); \
+    }
+
+#define VALIDATE_NOT_NULL(ARG)                                             \
+    if(!(ARG)) {                                                           \
+        std::string msg = "NULL pointer passed for argument \"" #ARG "\""; \
+        LOG_WARN(msg);                                                     \
+        throw std::logic_error(msg);                                       \
+    }
+
+#define VALIDATE_EQUAL(ARG, CMP)                                            \
+    if(ARG != CMP) {                                                        \
+        std::string msg = "Invalid value passed for argument \"" #ARG "\""; \
+        LOG_WARN(msg);                                                      \
+        throw std::logic_error(msg);                                        \
+    }
+
+#define VALIDATE_NOT_EQUAL(ARG, CMP)                                        \
+    if(ARG == CMP) {                                                        \
+        std::string msg = "Invalid value passed for argument \"" #ARG "\""; \
+        LOG_WARN(msg);                                                      \
+        throw std::logic_error(msg);                                        \
+    }
+
+#define VALIDATE_ENUM(ARG, COUNT)                                         \
+    if(!(((ARG) >= 0) && ((ARG) < (COUNT)))) {                            \
+        std::string msg = "Invalid enum value for argument \"" #ARG "\""; \
+        LOG_WARN(msg);                                                    \
+        throw std::logic_error(msg);                                      \
+    }
+
+#define VALIDATE_LE(ARG, MAX)                                                           \
+    if((ARG) >= (MAX)) {                                                                \
+        std::string msg = "Value not less than \"" #MAX "\" for argument \"" #ARG "\""; \
+        LOG_WARN(msg);                                                                  \
+        throw std::logic_error(msg);                                                    \
+    }
+
+#define VALIDATE_GE(ARG, MIN)                                                              \
+    if((ARG) <= (MIN)) {                                                                   \
+        std::string msg = "Value not greater than \"" #MIN "\" for argument \"" #ARG "\""; \
+        LOG_WARN(msg);                                                                     \
+        throw std::logic_error(msg);                                                       \
+    }
+
+#define VALIDATE_NOT_LE(ARG, MIN)                                                   \
+    if((ARG) < (MIN)) {                                                             \
+        std::string msg = "Value less than \"" #MIN "\" for argument \"" #ARG "\""; \
+        LOG_WARN(msg);                                                              \
+        throw std::logic_error(msg);                                                \
+    }
+
+#define VALIDATE_NOT_GE(ARG, MAX)                                                      \
+    if((ARG) > (MAX)) {                                                                \
+        std::string msg = "Value greater than \"" #MAX "\" for argument \"" #ARG "\""; \
+        LOG_WARN(msg);                                                                 \
+        throw std::logic_error(msg);                                                   \
+    }
+
+#define VALIDATE_RANGE(ARG, MIN, MAX)                                     \
+    if((ARG) < (MIN) || (ARG) > (MAX)) {                                  \
+        std::string msg = "Out of range value for argument \"" #ARG "\""; \
+        LOG_WARN(msg);                                                    \
+        throw std::logic_error(msg);                                      \
+    }
+
+#define VALIDATE_INDEX(ARG, COUNT)                                         \
+    if((ARG) < 0 || (ARG) >= (COUNT)) {                                    \
+        std::string msg = "Invalid index value for argument \"" #ARG "\""; \
+        LOG_WARN(msg);                                                     \
+        throw std::logic_error(msg);                                       \
+    }
+
+#define VALIDATE_UNSIGNED_INDEX(ARG, COUNT)                                \
+    if((ARG) >= (COUNT)) {                                                 \
+        std::string msg = "Invalid index value for argument \"" #ARG "\""; \
+        LOG_WARN(msg);                                                     \
+        throw std::logic_error(msg);                                       \
+    }
+}  // namespace libobsensor
diff --git a/src/shared/logger/LogCallbackSink.hpp b/src/shared/logger/LogCallbackSink.hpp
new file mode 100644
index 00000000..e6774b1c
--- /dev/null
+++ b/src/shared/logger/LogCallbackSink.hpp
@@ -0,0 +1,59 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+// Purpose: Defines a custom sink for spdlog that allows for a callback to be called when a log is received.
+#pragma once
+
+#include <spdlog/details/null_mutex.h>
+#include <spdlog/sinks/base_sink.h>
+#include <spdlog/details/synchronous_factory.h>
+
+#include <mutex>
+#include <functional>
+#include <string>
+
+namespace spdlog {
+typedef std::function<void(level::level_enum logLevel, std::string msg)> log_callback_t;
+
+namespace sinks {
+template <typename Mutex> class callback_sink : public base_sink<Mutex> {
+public:
+    explicit callback_sink(log_callback_t callback) : callback_(callback) {}
+    callback_sink(const callback_sink &)            = delete;
+    callback_sink &operator=(const callback_sink &) = delete;
+
+protected:
+    void sink_it_(const details::log_msg &msg) override {
+        if(callback_) {
+            memory_buf_t formatted;
+            base_sink<Mutex>::formatter_->format(msg, formatted);
+            callback_(msg.level, std::string(formatted.data(), formatted.size()));
+        }
+    }
+    void flush_() override {
+        // noting to do
+    }
+    log_callback_t callback_;
+};
+
+using callback_sink_mt = callback_sink<std::mutex>;
+using callback_sink_st = callback_sink<details::null_mutex>;
+
+}  // namespace sinks
+
+template <typename Factory = spdlog::synchronous_factory>
+inline std::shared_ptr<logger> callback_logger_mt(const std::string &logger_name, log_callback_t callback) {
+    auto callback_logger = Factory::template create<sinks::callback_sink_mt>(logger_name, callback);
+    callback_logger->set_level(level::off);
+    return callback_logger;
+}
+
+template <typename Factory = spdlog::synchronous_factory>
+inline std::shared_ptr<logger> callback_logger_st(const std::string &logger_name, log_callback_t callback) {
+    auto callback_logger = Factory::template create<sinks::callback_sink_st>(logger_name, callback);
+    callback_logger->set_level(level::off);
+    return callback_logger;
+}
+
+}  // namespace spdlog
+
diff --git a/src/shared/logger/Logger.cpp b/src/shared/logger/Logger.cpp
new file mode 100644
index 00000000..d7cc80d9
--- /dev/null
+++ b/src/shared/logger/Logger.cpp
@@ -0,0 +1,363 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "Logger.hpp"
+#include "LoggerHelper.hpp"
+#include "LoggerInterval.hpp"
+
+#include "exception/ObException.hpp"
+#include "environment/EnvConfig.hpp"
+
+#include "LogCallbackSink.hpp"
+#ifdef __ANDROID__
+#include <spdlog/sinks/android_sink.h>
+#else
+#include <spdlog/sinks/stdout_color_sinks.h>
+#endif
+#include <spdlog/sinks/rotating_file_sink.h>
+#include <spdlog/async_logger.h>
+#include <spdlog/async.h>
+#include "spdlog/pattern_formatter.h"
+
+#include <map>
+
+std::map<std::string, std::shared_ptr<ObLogIntvlRecord>> logIntvlRecordMap;
+std::mutex                                               logIntvlRecordMapMtx;
+std::atomic<bool>                                        logIntvlRecordMapDestroyed(false);
+
+namespace libobsensor {
+
+const std::map<OBLogSeverity, spdlog::level::level_enum> OBLogSeverityToSpdlogLevel = {
+#ifdef _DEBUG
+    { OB_LOG_SEVERITY_DEBUG, spdlog::level::level_enum::trace },
+#else
+    { OB_LOG_SEVERITY_DEBUG, spdlog::level::level_enum::debug },
+#endif
+    { OB_LOG_SEVERITY_INFO, spdlog::level::level_enum::info },   { OB_LOG_SEVERITY_WARN, spdlog::level::level_enum::warn },
+    { OB_LOG_SEVERITY_ERROR, spdlog::level::level_enum::err },   { OB_LOG_SEVERITY_FATAL, spdlog::level::level_enum::critical },
+    { OB_LOG_SEVERITY_OFF, spdlog::level::level_enum::off },
+};
+
+const std::map<spdlog::level::level_enum, OBLogSeverity> SpdlogLevelToOBLogSeverity = {
+    { spdlog::level::level_enum::trace, OB_LOG_SEVERITY_DEBUG }, { spdlog::level::level_enum::debug, OB_LOG_SEVERITY_DEBUG },
+    { spdlog::level::level_enum::info, OB_LOG_SEVERITY_INFO },   { spdlog::level::level_enum::warn, OB_LOG_SEVERITY_WARN },
+    { spdlog::level::level_enum::err, OB_LOG_SEVERITY_ERROR },   { spdlog::level::level_enum::critical, OB_LOG_SEVERITY_FATAL },
+    { spdlog::level::level_enum::off, OB_LOG_SEVERITY_OFF },
+};
+
+#ifdef __ANDROID__
+const char *OB_DEFAULT_LOG_FILE_PATH = "/sdcard/Orbbec/Log/";
+#else
+const char *OB_DEFAULT_LOG_FILE_PATH = "Log/";
+#endif
+
+const OBLogSeverity OB_DEFAULT_LOG_SEVERITY  = OB_LOG_SEVERITY_INFO;
+const std::string   OB_DEFAULT_LOG_FMT       = "[%m/%d %H:%M:%S.%f][%l][%t][%s:%#] %v";
+const uint64_t      OB_DEFAULT_MAX_FILE_SIZE = 1024 * 1024 * 100;
+const uint16_t      OB_DEFAULT_MAX_FILE_NUM  = 3;
+const std::string   OB_DEFAULT_LOG_FILE_NAME = "OrbbecSDK.log.txt";
+
+struct Logger::LoggerConfig {
+    bool          loadFileLogSeverityFromEnvConfig = true;
+    OBLogSeverity fileLogSeverity                  = OB_LOG_SEVERITY_DEBUG;
+
+    bool        loadFileLogPathFromEnvConfig = true;
+    std::string fileLogOutputDir             = OB_DEFAULT_LOG_FILE_PATH;
+    std::string fileLogFileName              = OB_DEFAULT_LOG_FILE_NAME;
+    uint64_t    fileLogMaxFileSize           = OB_DEFAULT_MAX_FILE_SIZE;
+    uint64_t    fileLogMaxFileNum            = OB_DEFAULT_MAX_FILE_NUM;
+
+    bool          loadConsoleLogSeverityFromEnvConfig = true;
+    OBLogSeverity consoleLogSeverity                  = OB_DEFAULT_LOG_SEVERITY;
+
+    bool          loadCallbackLogSeverityFromEnvConfig = true;
+    OBLogSeverity callbackLogSeverity                  = OB_DEFAULT_LOG_SEVERITY;
+    LogCallback   logCallback                          = nullptr;
+
+    bool async = false;
+};
+
+Logger::LoggerConfig    Logger::config_;
+std::mutex              Logger::instanceMutex_;
+std::weak_ptr<Logger>   Logger::instanceWeakPtr_;
+std::shared_ptr<Logger> Logger::getInstance() {
+    std::lock_guard<std::mutex> lock(instanceMutex_);
+    auto                        instance = instanceWeakPtr_.lock();
+    if(!instance) {
+        instance         = std::shared_ptr<Logger>(new Logger());
+        instanceWeakPtr_ = instance;
+    }
+    return instance;
+}
+
+Logger::Logger() : spdlogRegistry_(spdlog::details::registry::instance_ptr()) {
+    spdlog::set_pattern(OB_DEFAULT_LOG_FMT);
+
+    std::lock_guard<std::mutex> lock(logIntvlRecordMapMtx);
+    logIntvlRecordMapDestroyed = false;
+    loadEnvConfig();
+    createConsoleSink();
+    createFileSink();
+    createCallbackSink();
+    updateDefaultSpdLogger();
+}
+
+Logger::~Logger() noexcept {
+    {
+        std::lock_guard<std::mutex> lock(logIntvlRecordMapMtx);
+        logIntvlRecordMapDestroyed = true;
+        for(auto &it: logIntvlRecordMap) {
+            it.second->flush();
+            it.second.reset();
+        }
+        logIntvlRecordMap.clear();
+    }
+
+    spdlog::set_default_logger(std::make_shared<spdlog::logger>("EmptySinksLogger"));
+
+    if(consoleSink_) {
+        consoleSink_->flush();
+        consoleSink_.reset();
+    }
+    if(fileSink_) {
+        fileSink_->flush();
+        fileSink_.reset();
+    }
+
+    if(callbackSink_) {
+        callbackSink_->flush();
+        callbackSink_.reset();
+    }
+
+    spdlogRegistry_.reset();
+}
+
+void Logger::createFileSink() {
+    if(fileSink_) {
+        fileSink_->flush();
+        fileSink_.reset();
+    }
+    if(config_.fileLogSeverity != OB_LOG_SEVERITY_OFF) {
+        auto  path     = config_.fileLogOutputDir + "/" + config_.fileLogFileName;
+        auto &fileSize = config_.fileLogMaxFileSize;
+        auto &fileNum  = config_.fileLogMaxFileNum;
+        try {
+            fileSink_ = std::make_shared<spdlog::sinks::rotating_file_sink_mt>(path, fileSize, fileNum);
+        }
+        catch(const std::exception &e) {
+            LOG_ERROR("Error creating file sink for logger! {}", e.what());
+            fileSink_ = nullptr;
+        }
+        catch(...) {
+            LOG_ERROR("Unknown error creating file sink for logger! path:{}", path);
+            fileSink_ = nullptr;
+        }
+        if(fileSink_) {
+            auto fileLogLevel = OBLogSeverityToSpdlogLevel.find(config_.fileLogSeverity)->second;
+            fileSink_->set_level(fileLogLevel);
+        }
+    }
+}
+
+void Logger::createConsoleSink() {
+    if(consoleSink_) {
+        consoleSink_->flush();
+        consoleSink_.reset();
+    }
+    if(config_.consoleLogSeverity != OB_LOG_SEVERITY_OFF) {
+        if(!consoleSink_) {
+#ifdef __ANDROID__
+            consoleSink_ = std::make_shared<spdlog::sinks::android_sink_mt>("OrbbecSDK");
+#else
+            consoleSink_ = std::make_shared<spdlog::sinks::stdout_color_sink_mt>();
+#endif
+        }
+        auto consoleLogLevel = OBLogSeverityToSpdlogLevel.find(config_.consoleLogSeverity)->second;
+        consoleSink_->set_level(consoleLogLevel);
+    }
+}
+
+void Logger::createCallbackSink() {
+    if(callbackSink_) {
+        callbackSink_->flush();
+        callbackSink_.reset();
+    }
+    if(config_.logCallback != nullptr && config_.callbackLogSeverity != OB_LOG_SEVERITY_OFF) {
+        if(!callbackSink_) {
+            callbackSink_ = std::make_shared<spdlog::sinks::callback_sink_mt>([](spdlog::level::level_enum logLevel, std::string msg) {
+                if(config_.logCallback) {
+                    config_.logCallback(SpdlogLevelToOBLogSeverity.find(logLevel)->second, msg);
+                }
+            });
+        }
+        auto callbackLogLevel = OBLogSeverityToSpdlogLevel.find(config_.callbackLogSeverity)->second;
+        callbackSink_->set_level(callbackLogLevel);
+    }
+}
+
+void Logger::updateDefaultSpdLogger() {
+    std::vector<spdlog::sink_ptr> sinks;
+    if(consoleSink_) {
+        sinks.push_back(consoleSink_);
+    }
+    if(fileSink_) {
+        sinks.push_back(fileSink_);
+    }
+    if(callbackSink_) {
+        sinks.push_back(callbackSink_);
+    }
+
+    std::shared_ptr<spdlog::logger> spdLogger;
+    if(config_.async) {
+        spdlog::init_thread_pool(1024, 1);  // queue with 1k items and 1 threads, multiple threads will cause the log output order to be disordered
+
+        // Asynchronous logger
+        spdLogger = std::make_shared<spdlog::async_logger>("OrbbecSDK", sinks.begin(), sinks.end(),  //
+                                                           spdlog::thread_pool(), spdlog::async_overflow_policy::block);
+
+        spdlog::flush_every(std::chrono::seconds(1));  // Set to flush the log every 1 second
+    }
+    else {
+        // Synchronize logger
+        spdLogger = std::make_shared<spdlog::logger>("OrbbecSDK", sinks.begin(), sinks.end());
+    }
+
+    spdlog::set_default_logger(spdLogger);
+    spdlog::set_level(spdlog::level::trace);  // Set the logger log level (here set to trace, the actual output will be output according to the sink's log
+                                              // level)
+    spdlog::flush_on(spdlog::level::trace);   // Set the flush log level (immediately output logs when receiving logs greater than or equal to this level)
+    spdlog::set_pattern(OB_DEFAULT_LOG_FMT);
+}
+
+void Logger::loadEnvConfig() {
+    auto envConfig       = EnvConfig::getInstance();
+    int  globalLogLevel  = -1;
+    int  fileLogLevel    = -1;
+    int  consoleLogLevel = -1;
+    if(!envConfig->getIntValue("Log.LogLevel", globalLogLevel)) {
+        globalLogLevel = OB_DEFAULT_LOG_SEVERITY;
+    }
+    if(!envConfig->getIntValue("Log.FileLogLevel", fileLogLevel) && globalLogLevel >= OB_LOG_SEVERITY_DEBUG) {
+        fileLogLevel = globalLogLevel;
+    }
+    if(!envConfig->getIntValue("Log.ConsoleLogLevel", consoleLogLevel) && globalLogLevel >= OB_LOG_SEVERITY_DEBUG) {
+        consoleLogLevel = globalLogLevel;
+    }
+
+    if(config_.loadFileLogSeverityFromEnvConfig && fileLogLevel >= OB_LOG_SEVERITY_DEBUG) {
+        config_.fileLogSeverity = (OBLogSeverity)fileLogLevel;
+    }
+
+    if(config_.loadConsoleLogSeverityFromEnvConfig && consoleLogLevel >= OB_LOG_SEVERITY_DEBUG) {
+        config_.consoleLogSeverity = (OBLogSeverity)consoleLogLevel;
+    }
+
+    std::string dir;
+    envConfig->getStringValue("Log.OutputDir", dir);
+    if(dir.empty()) {
+        dir = OB_DEFAULT_LOG_FILE_PATH;
+    }
+
+    std::string fileName;
+    envConfig->getStringValue("Log.FileName", fileName);
+    if(fileName.empty()) {
+        fileName = OB_DEFAULT_LOG_FILE_NAME;
+    }
+
+    int maxFileSize = 0;
+    envConfig->getIntValue("Log.MaxFileSize", maxFileSize);
+    maxFileSize = maxFileSize * 1024 * 1024;  // MB to Byte
+    if(maxFileSize == 0) {
+        maxFileSize = OB_DEFAULT_MAX_FILE_SIZE;
+    }
+
+    int maxFileNum = 0;
+    envConfig->getIntValue("Log.MaxFileNum", maxFileNum);
+    if(maxFileNum == 0) {
+        maxFileNum = OB_DEFAULT_MAX_FILE_NUM;
+    }
+
+    if(config_.loadFileLogPathFromEnvConfig) {
+        config_.fileLogOutputDir = dir;
+
+        config_.fileLogFileName = fileName;
+
+        config_.fileLogMaxFileSize = maxFileSize;
+
+        config_.fileLogMaxFileNum = maxFileNum;
+    }
+    bool async = false;
+    if(envConfig->getBooleanValue("Log.Async", async)) {
+        config_.async = async;
+    }
+}
+
+void Logger::setLogSeverity(OBLogSeverity severity) {
+    config_.loadFileLogSeverityFromEnvConfig     = false;
+    config_.fileLogSeverity                      = severity;
+    config_.loadConsoleLogSeverityFromEnvConfig  = false;
+    config_.consoleLogSeverity                   = severity;
+    config_.loadCallbackLogSeverityFromEnvConfig = false;
+    config_.callbackLogSeverity                  = severity;
+
+    std::lock_guard<std::mutex> lock(instanceMutex_);
+    auto                        instance = instanceWeakPtr_.lock();
+    if(instance) {
+        instance->createFileSink();
+        instance->createConsoleSink();
+        instance->createCallbackSink();
+        instance->updateDefaultSpdLogger();
+    }
+}
+
+void Logger::setConsoleLogSeverity(OBLogSeverity severity) {
+    config_.loadConsoleLogSeverityFromEnvConfig = false;
+    config_.consoleLogSeverity                  = severity;
+
+    std::lock_guard<std::mutex> lock(instanceMutex_);
+    auto                        instance = instanceWeakPtr_.lock();
+    if(instance) {
+        instance->createConsoleSink();
+        instance->updateDefaultSpdLogger();
+    }
+}
+
+void Logger::setFileLogConfig(OBLogSeverity severity, const std::string &directory, uint32_t maxFileSize, uint32_t maxFileNum) {
+    config_.loadFileLogSeverityFromEnvConfig = false;
+    config_.fileLogSeverity                  = severity;
+    config_.loadFileLogPathFromEnvConfig     = false;
+    config_.fileLogOutputDir                 = directory;
+    config_.fileLogMaxFileSize               = maxFileSize * 1024 * 1024;  // MB to Byte
+    config_.fileLogMaxFileNum                = maxFileNum;
+    if(directory.empty()) {
+        config_.fileLogOutputDir = OB_DEFAULT_LOG_FILE_PATH;
+    }
+    if(maxFileSize == 0) {
+        config_.fileLogMaxFileSize = OB_DEFAULT_MAX_FILE_SIZE;
+    }
+    if(maxFileNum == 0) {
+        config_.fileLogMaxFileNum = OB_DEFAULT_MAX_FILE_NUM;
+    }
+
+    std::lock_guard<std::mutex> lock(instanceMutex_);
+    auto                        instance = instanceWeakPtr_.lock();
+    if(instance) {
+        instance->createFileSink();
+        instance->updateDefaultSpdLogger();
+    }
+}
+
+void Logger::setLogCallback(OBLogSeverity severity, LogCallback logCallback) {
+    config_.loadCallbackLogSeverityFromEnvConfig = false;
+    config_.callbackLogSeverity                  = severity;
+    config_.logCallback                          = logCallback;
+
+    std::lock_guard<std::mutex> lock(instanceMutex_);
+    auto                        instance = instanceWeakPtr_.lock();
+    if(instance) {
+        instance->createCallbackSink();
+        instance->updateDefaultSpdLogger();
+    }
+}
+
+}  // namespace libobsensor
diff --git a/src/shared/logger/Logger.hpp b/src/shared/logger/Logger.hpp
new file mode 100644
index 00000000..59095576
--- /dev/null
+++ b/src/shared/logger/Logger.hpp
@@ -0,0 +1,82 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+
+#ifdef _DEBUG
+#define SPDLOG_ACTIVE_LEVEL SPDLOG_LEVEL_TRACE
+#else
+#define SPDLOG_ACTIVE_LEVEL SPDLOG_LEVEL_DEBUG
+#endif
+
+#ifdef _WIN32
+#ifndef SPDLOG_WCHAR_TO_UTF8_SUPPORT
+#define SPDLOG_WCHAR_TO_UTF8_SUPPORT
+#endif
+#endif
+
+// Debug trace information, only valid when compiled into debug version
+#define LOG_TRACE(...) SPDLOG_LOGGER_TRACE(spdlog::default_logger(), __VA_ARGS__)
+
+// Debugging information, for SDK developers, provides SDK internal running process and status information
+#define LOG_DEBUG(...) SPDLOG_LOGGER_DEBUG(spdlog::default_logger(), __VA_ARGS__)
+
+// General information, facing users, providing SDK running status and call result information
+#define LOG_INFO(...) SPDLOG_LOGGER_INFO(spdlog::default_logger(), __VA_ARGS__)
+
+// Warning information (such as: memory usage reaches the maximum limit, cache queue is full, system memory is about to be exhausted, etc.)
+#define LOG_WARN(...) SPDLOG_LOGGER_WARN(spdlog::default_logger(), __VA_ARGS__)
+
+// Error information (such as: user parameter error, device error calling sequence, device offline and unresponsive, etc.)
+#define LOG_ERROR(...) SPDLOG_LOGGER_ERROR(spdlog::default_logger(), __VA_ARGS__)
+
+// Fatal error message (for example: insufficient system memory prevents normal operation)
+#define LOG_FATAL(...) SPDLOG_LOGGER_CRITICAL(spdlog::default_logger(), __VA_ARGS__)
+
+#include <atomic>
+#include <string>
+#include <memory>
+#include <spdlog/spdlog.h>
+#include <spdlog/fmt/ostr.h>
+#include <libobsensor/h/ObTypes.h>
+#include "utils/PublicTypeHelper.hpp"
+
+namespace libobsensor {
+typedef std::function<void(OBLogSeverity severity, const std::string &logMsg)> LogCallback;
+
+class Logger {
+
+private:
+    Logger();
+
+    static std::mutex            instanceMutex_;
+    static std::weak_ptr<Logger> instanceWeakPtr_;
+
+    struct LoggerConfig;
+    static LoggerConfig config_;
+
+public:
+    static std::shared_ptr<Logger> getInstance();
+
+    ~Logger() noexcept;
+
+    static void setLogSeverity(OBLogSeverity severity);
+    static void setConsoleLogSeverity(OBLogSeverity severity);
+    static void setFileLogConfig(OBLogSeverity severity, const std::string &directory = "", uint32_t maxFileSize = 0, uint32_t maxFileNum = 0);
+    static void setLogCallback(OBLogSeverity severity, LogCallback callback);
+
+private:
+    void loadEnvConfig();
+    void createConsoleSink();
+    void createFileSink();
+    void createCallbackSink();
+    void updateDefaultSpdLogger();
+
+private:
+    spdlog::sink_ptr consoleSink_;
+    spdlog::sink_ptr fileSink_;
+    spdlog::sink_ptr callbackSink_;
+
+    std::shared_ptr<spdlog::details::registry> spdlogRegistry_;  // handle spdlog registry instance to control it's life cycle
+};
+}  // namespace libobsensor
diff --git a/src/shared/logger/LoggerHelper.hpp b/src/shared/logger/LoggerHelper.hpp
new file mode 100644
index 00000000..9ffa85a6
--- /dev/null
+++ b/src/shared/logger/LoggerHelper.hpp
@@ -0,0 +1,52 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include "Logger.hpp"
+#include <map>
+#include <mutex>
+#include <string>
+
+struct ObLogRecord {
+    uint32_t count;
+    uint64_t lastTime;
+};
+
+#define LOG_FREQ_CALC_OBJECT_TAG std::string(__FILE__) + std::to_string(__LINE__) + std::to_string((uint64_t)this)
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wgnu-zero-variadic-macro-arguments"
+#endif
+
+#define VA_ARGS(...) , ##__VA_ARGS__
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+// Count the call frequency and then output the log
+#define LOG_FREQ_CALC(level, duration, msg, ...)                                                                                           \
+    do {                                                                                                                                   \
+        static std::map<std::string, std::shared_ptr<ObLogRecord>> logIntvlRecordMap_;                                                     \
+        static std::mutex                                          mtx;                                                                    \
+        std::unique_lock<std::mutex>                               logLock(mtx);                                                           \
+        auto                                                       iter = logIntvlRecordMap_.find(LOG_FREQ_CALC_OBJECT_TAG);               \
+        uint64_t now = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count(); \
+        if(iter == logIntvlRecordMap_.end()) {                                                                                             \
+            auto record      = std::make_shared<ObLogRecord>();                                                                            \
+            record->count    = 0;                                                                                                          \
+            record->lastTime = now;                                                                                                        \
+            logIntvlRecordMap_.insert(std::make_pair(LOG_FREQ_CALC_OBJECT_TAG, record));                                                   \
+            iter = logIntvlRecordMap_.find(LOG_FREQ_CALC_OBJECT_TAG);                                                                      \
+        }                                                                                                                                  \
+        iter->second->count++;                                                                                                             \
+        if(now - iter->second->lastTime > duration) {                                                                                      \
+            float       freq   = iter->second->count / ((now - iter->second->lastTime) / 1000.0f);                                         \
+            std::string outMsg = msg;                                                                                                      \
+            outMsg.replace(outMsg.find("{freq}"), 6, std::to_string(freq));                                                                \
+            LOG_##level(outMsg VA_ARGS(__VA_ARGS__));                                                                                      \
+            iter->second->count    = 0;                                                                                                    \
+            iter->second->lastTime = now;                                                                                                  \
+        }                                                                                                                                  \
+    } while(0)
+
diff --git a/src/shared/logger/LoggerInterval.hpp b/src/shared/logger/LoggerInterval.hpp
new file mode 100644
index 00000000..5e5ae425
--- /dev/null
+++ b/src/shared/logger/LoggerInterval.hpp
@@ -0,0 +1,246 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include "Logger.hpp"
+#include <spdlog/common.h>
+#include <spdlog/fmt/fmt.h>
+#include <spdlog/fmt/chrono.h>
+#include <map>
+#include <sstream>
+#include <string>
+#include <thread>
+#include <mutex>
+#include <ctime>
+
+#define LOG_RECORD_MAP_SIZE_LIMIT 500  // Maximum number of log entries
+#define MAX_LOG_INTERVAL 60 * 1000     // Maximum log output interval: 60000ms
+#define DEF_MIN_LOG_INTVL 3000         // Default minimum log output interval: 3000ms
+#define LOG_INTVL_OBJECT_TAG std::string(__FILE__) + std::to_string(__LINE__) + std::to_string((uint64_t)this)
+
+struct ObLogIntvlRecord {
+    uint32_t                              count;
+    uint64_t                              interval;
+    std::chrono::system_clock::time_point lastInvokeTime;
+    std::chrono::system_clock::time_point lastLogTime;
+    std::thread                           invokeThread;
+    std::mutex                            mtx;
+    std::condition_variable               cv;
+    void                                  flush() {
+        cv.notify_all();
+        if(invokeThread.joinable()) {
+            invokeThread.join();
+        }
+    }
+    ~ObLogIntvlRecord() {
+        flush();
+    }
+};
+
+extern std::atomic<bool>                                        logIntvlRecordMapDestroyed;
+extern std::map<std::string, std::shared_ptr<ObLogIntvlRecord>> logIntvlRecordMap;
+extern std::mutex                                               logIntvlRecordMapMtx;
+
+template <typename... Args>
+void log_intvl_invoke(std::shared_ptr<ObLogIntvlRecord> record, uint64_t minIntvlMsec, spdlog::source_loc src_loc, spdlog::level::level_enum level,
+                      std::string fmt, Args &&...args) {
+    std::unique_lock<std::mutex> lock(record->mtx);
+    record->cv.wait_for(lock, std::chrono::milliseconds(record->interval));
+    if(record->count > 0) {
+        auto     nowTime  = std::chrono::system_clock::now();
+        uint64_t duration = std::chrono::duration_cast<std::chrono::milliseconds>(nowTime - record->lastInvokeTime).count();
+
+        char   timestampStr[100];
+        time_t timestamp = std::chrono::duration_cast<std::chrono::seconds>(record->lastLogTime.time_since_epoch()).count();
+        std::strftime(timestampStr, sizeof(timestampStr), "%H:%M:%S", std::localtime(&timestamp));
+
+        auto us    = std::chrono::duration_cast<std::chrono::microseconds>(record->lastLogTime.time_since_epoch()).count() % 1000000;
+        auto usStr = fmt::format("{:06d}", us);
+
+        fmt = fmt + " [**" + std::to_string(record->count) + " logs in " + std::to_string(duration) + "ms, last: " + timestampStr + "." + usStr.data() + "**]";
+        spdlog::default_logger_raw()->log(src_loc, level, fmt, std::forward<Args>(args)...);
+
+        uint64_t avgInterval = duration / record->count;
+        if(avgInterval < record->interval) {  // Reduce log output frequency
+            record->interval *= 2;
+            if(record->interval > MAX_LOG_INTERVAL) {
+                record->interval = MAX_LOG_INTERVAL;
+            }
+        }
+        else {
+            avgInterval = minIntvlMsec;  // Restore log output frequency
+        }
+
+        record->lastInvokeTime = nowTime;
+        record->count          = 0;
+    }
+}
+
+// Control log output at intervals; when log_intvl is called repeatedly within the interval time, only one log entry is output
+// When log_intvl is called frequently in succession, the log output frequency will decrease (intervals will lengthen) until the maximum interval, MAX_INTERVAL, is reached
+template <typename... Args>
+void log_intvl(std::shared_ptr<ObLogIntvlRecord> record, uint64_t minIntvlMsec, spdlog::source_loc src_loc, spdlog::level::level_enum level, std::string fmt,
+               Args &&...args) {
+    if(minIntvlMsec == 0) {
+        spdlog::default_logger_raw()->log(src_loc, level, fmt, std::forward<Args>(args)...);
+    }
+    else {
+        std::unique_lock<std::mutex> lock(record->mtx);
+        auto                         nowTime = std::chrono::system_clock::now();
+        record->lastLogTime                  = nowTime;
+        record->count++;
+        uint64_t duration           = std::chrono::duration_cast<std::chrono::milliseconds>(nowTime - record->lastInvokeTime).count();
+        bool     zeroLastInvokeTime = record->lastInvokeTime.time_since_epoch() == std::chrono::system_clock::duration::zero();
+        if(duration > record->interval || zeroLastInvokeTime) {
+            if(!zeroLastInvokeTime) {
+                uint64_t avgInterval = duration / record->count;
+                if(avgInterval < record->interval) {  // Reduce the log output frequency
+                    record->interval *= 2;
+                    if(record->interval > MAX_LOG_INTERVAL) {
+                        record->interval = MAX_LOG_INTERVAL;
+                    }
+                }
+                else {
+                    record->interval = minIntvlMsec;  // Restore the log output frequency
+                }
+
+                if(record->count > 1) {
+                    fmt = fmt + " [**" + std::to_string(record->count) + " logs in " + std::to_string(duration) + "ms**]";
+                }
+            }
+
+            spdlog::default_logger_raw()->log(src_loc, level, fmt, std::forward<Args>(args)...);
+            record->count          = 0;
+            record->lastInvokeTime = nowTime;
+            lock.unlock();
+            if(record->invokeThread.joinable())  // Notify the thread to exit (resources will be automatically released after the thread exits)
+            {
+                record->cv.notify_all();
+                record->invokeThread.join();
+            }
+        }
+        else if(record->count == 1) {
+            lock.unlock();
+            if(record->invokeThread.joinable()) {
+                record->invokeThread.join();
+            }
+            auto func            = std::bind(std::move(log_intvl_invoke<Args &...>), record, minIntvlMsec, src_loc, level, fmt, std::forward<Args>(args)...);
+            record->invokeThread = std::thread(func);
+        }
+    }
+}
+
+// Control the log output interval in milliseconds; 0 means no control
+#define LOG_INTVL(tag, minIntvlMsec, level, ...)                                                                                                            \
+    do {                                                                                                                                                    \
+        std::unique_lock<std::mutex> logIntvlRecordMapLock(logIntvlRecordMapMtx);                                                                           \
+        if(logIntvlRecordMapDestroyed) {                                                                                                                    \
+            break;                                                                                                                                          \
+        }                                                                                                                                                   \
+        if(logIntvlRecordMap.size() > LOG_RECORD_MAP_SIZE_LIMIT) {                                                                                          \
+            LOG_WARN("logIntvlRecordMap size {} > {}, clear it!", logIntvlRecordMap.size(), LOG_RECORD_MAP_SIZE_LIMIT);                                     \
+            auto nowTime = std::chrono::system_clock::now();                                                                                                \
+            for(auto logIntvlRecordMapIter = logIntvlRecordMap.begin(); logIntvlRecordMapIter != logIntvlRecordMap.end();) {                                \
+                uint64_t duration = std::chrono::duration_cast<std::chrono::milliseconds>(nowTime - logIntvlRecordMapIter->second->lastInvokeTime).count(); \
+                if(logIntvlRecordMapIter->second->count == 0 && duration > logIntvlRecordMapIter->second->interval) {                                       \
+                    logIntvlRecordMapIter = logIntvlRecordMap.erase(logIntvlRecordMapIter);                                                                 \
+                }                                                                                                                                           \
+                else {                                                                                                                                      \
+                    logIntvlRecordMapIter++;                                                                                                                \
+                }                                                                                                                                           \
+            }                                                                                                                                               \
+        }                                                                                                                                                   \
+        auto logIntvlRecordMapIter = logIntvlRecordMap.find(tag);                                                                                           \
+        if(logIntvlRecordMapIter == logIntvlRecordMap.end()) {                                                                                              \
+            auto record      = std::make_shared<ObLogIntvlRecord>();                                                                                        \
+            record->count    = 0;                                                                                                                           \
+            record->interval = minIntvlMsec;                                                                                                                \
+            logIntvlRecordMap.insert(std::make_pair(tag, record));                                                                                          \
+            logIntvlRecordMapIter = logIntvlRecordMap.find(tag);                                                                                            \
+        }                                                                                                                                                   \
+        log_intvl(logIntvlRecordMapIter->second, minIntvlMsec, spdlog::source_loc{ __FILE__, __LINE__, SPDLOG_FUNCTION }, level, __VA_ARGS__);              \
+    } while(0)
+
+#define LOG_INTVL_ON_THREAD(minIntvlMsec, level, ...)                                  \
+    do {                                                                               \
+        std::stringstream ss;                                                          \
+        ss << std::this_thread::get_id();                                              \
+        std::string tag = std::string(__FILE__) + std::to_string(__LINE__) + ss.str(); \
+        LOG_INTVL(tag, minIntvlMsec, level, __VA_ARGS__);                              \
+    } while(0)
+
+// The LOG_XXX_INTVL macro can only be used within class member functions because it uses the `this` pointer as a tag (log output interval control is bound to a specific object)
+// The LOG_XXX_INTVL_THREAD macro uses the current thread ID as a tag and can be used in class member functions and regular functions (log output interval control is bound to a specific thread)
+// It is recommended to prioritize the use of the LOG_XXX_INTVL macro, since log outputs from the same place where the same object exists are called in different threads (e.g., VideoSensor's raw frame data callback)
+#if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_TRACE
+#define LOG_TRACE_INTVL(...) LOG_INTVL(LOG_INTVL_OBJECT_TAG, DEF_MIN_LOG_INTVL, spdlog::level::trace, __VA_ARGS__)
+#define LOG_TRACE_INTVL_THREAD(...) LOG_INTVL_ON_THREAD(DEF_MIN_LOG_INTVL, spdlog::level::trace, __VA_ARGS__)
+#define LOG_TRACE_INTVL_MS(minIntvlMsec, ...) LOG_INTVL(LOG_INTVL_OBJECT_TAG, minIntvlMsec, spdlog::level::trace, __VA_ARGS__)
+#define LOG_TRACE_INTVL_THREAD_MS(minIntvlMsec, ...) LOG_INTVL_ON_THREAD(minIntvlMsec, spdlog::level::trace, __VA_ARGS__)
+#else
+#define LOG_TRACE_INTVL(...)
+#define LOG_TRACE_INTVL_THREAD(...)
+#define LOG_TRACE_INTVL_MS(...)
+#define LOG_TRACE_INTVL_THREAD_MS(...)
+#endif
+
+#if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_DEBUG
+#define LOG_DEBUG_INTVL(...) LOG_INTVL(LOG_INTVL_OBJECT_TAG, DEF_MIN_LOG_INTVL, spdlog::level::debug, __VA_ARGS__)
+#define LOG_DEBUG_INTVL_THREAD(...) LOG_INTVL_ON_THREAD(DEF_MIN_LOG_INTVL, spdlog::level::debug, __VA_ARGS__)
+#define LOG_DEBUG_INTVL_MS(minIntvlMsec, ...) LOG_INTVL(LOG_INTVL_OBJECT_TAG, minIntvlMsec, spdlog::level::debug, __VA_ARGS__)
+#define LOG_DEBUG_INTVL_THREAD_MS(minIntvlMsec, ...) LOG_INTVL_ON_THREAD(minIntvlMsec, spdlog::level::debug, __VA_ARGS__)
+#else
+#define LOG_DEBUG_INTVL(...)
+#define LOG_DEBUG_INTVL_THREAD(...)
+#define LOG_DEBUG_INTVL_MS(...)
+#define LOG_DEBUG_INTVL_THREAD_MS(...)
+#endif
+
+#if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_INFO
+#define LOG_INFO_INTVL(...) LOG_INTVL(LOG_INTVL_OBJECT_TAG, DEF_MIN_LOG_INTVL, spdlog::level::info, __VA_ARGS__)
+#define LOG_INFO_INTVL_THREAD(...) LOG_INTVL_ON_THREAD(DEF_MIN_LOG_INTVL, spdlog::level::info, __VA_ARGS__)
+#define LOG_INFO_INTVL_MS(minIntvlMsec, ...) LOG_INTVL(LOG_INTVL_OBJECT_TAG, minIntvlMsec, spdlog::level::info, __VA_ARGS__)
+#define LOG_INFO_INTVL_THREAD_MS(minIntvlMsec, ...) LOG_INTVL_ON_THREAD(minIntvlMsec, spdlog::level::info, __VA_ARGS__)
+#else
+#define LOG_INFO_INTVL(...)
+#define LOG_INFO_INTVL_THREAD(...)
+#define LOG_INFO_INTVL_MS(...)
+#define LOG_INFO_INTVL_THREAD_MS(...)
+#endif
+
+#if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_WARN
+#define LOG_WARN_INTVL(...) LOG_INTVL(LOG_INTVL_OBJECT_TAG, DEF_MIN_LOG_INTVL, spdlog::level::warn, __VA_ARGS__)
+#define LOG_WARN_INTVL_THREAD(...) LOG_INTVL_ON_THREAD(DEF_MIN_LOG_INTVL, spdlog::level::warn, __VA_ARGS__)
+#define LOG_WARN_INTVL_MS(minIntvlMsec, ...) LOG_INTVL(LOG_INTVL_OBJECT_TAG, minIntvlMsec, spdlog::level::warn, __VA_ARGS__)
+#define LOG_WARN_INTVL_THREAD_MS(minIntvlMsec, ...) LOG_INTVL_ON_THREAD(minIntvlMsec, spdlog::level::warn, __VA_ARGS__)
+#else
+#define LOG_WARN_INTVL(...)
+#define LOG_WARN_INTVL_THREAD(...)
+#define LOG_WARN_INTVL_MS(...)
+#define LOG_WARN_INTVL_THREAD_MS(...)
+#endif
+
+#if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_ERROR
+#define LOG_ERROR_INTVL(...) LOG_INTVL(LOG_INTVL_OBJECT_TAG, DEF_MIN_LOG_INTVL, spdlog::level::err, __VA_ARGS__)
+#define LOG_ERROR_INTVL_THREAD(...) LOG_INTVL_ON_THREAD(DEF_MIN_LOG_INTVL, spdlog::level::err, __VA_ARGS__)
+#define LOG_ERROR_INTVL_MS(minIntvlMsec, ...) LOG_INTVL(LOG_INTVL_OBJECT_TAG, minIntvlMsec, spdlog::level::err, __VA_ARGS__)
+#define LOG_ERROR_INTVL_THREAD_MS(minIntvlMsec, ...) LOG_INTVL_ON_THREAD(minIntvlMsec, spdlog::level::err, __VA_ARGS__)
+#else
+#define LOG_ERROR_INTVL(...)
+#define LOG_ERROR_INTVL_THREAD(...)
+#define LOG_ERROR_INTVL_MS(...)
+#define LOG_ERROR_INTVL_THREAD_MS(...)
+#endif
+
+#if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_CRITICAL
+#define LOG_FATAL_INTVL(...) LOG_INTVL(LOG_INTVL_OBJECT_TAG, DEF_MIN_LOG_INTVL, spdlog::level::critical, __VA_ARGS__)
+#define LOG_FATAL_INTVL_THREAD(...) LOG_INTVL_ON_THREAD(DEF_MIN_LOG_INTVL, spdlog::level::critical, __VA_ARGS__)
+#define LOG_FATAL_INTVL_MS(minIntvlMsec, ...) LOG_INTVL(LOG_INTVL_OBJECT_TAG, minIntvlMsec, spdlog::level::critical, __VA_ARGS__)
+#define LOG_FATAL_INTVL_THREAD_MS(minIntvlMsec, ...) LOG_INTVL_ON_THREAD(minIntvlMsec, spdlog::level::critical, __VA_ARGS__)
+#else
+#define LOG_FATAL_INTVL(...)
+#define LOG_FATAL_INTVL_THREAD(...)
+#define LOG_FATAL_INTVL_MS(minIntvlMsec, ...)
+#define LOG_FATAL_INTVL_THREAD_MS(minIntvlMsec, ...)
+#endif
diff --git a/src/shared/utils/BufferParser.hpp b/src/shared/utils/BufferParser.hpp
new file mode 100644
index 00000000..d899b0af
--- /dev/null
+++ b/src/shared/utils/BufferParser.hpp
@@ -0,0 +1,35 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include "exception/ObException.hpp"
+#include "PublicTypeHelper.hpp"
+#include <vector>
+#include <type_traits>
+
+namespace libobsensor {
+template <typename T> std::vector<T> parseBuffer(const uint8_t *data, const uint16_t dataSize) {
+    if(dataSize <= 4) {
+        throw invalid_value_exception(utils::string::to_string() << "Data size error, must large than 4! size=" << dataSize);
+    }
+
+    uint16_t itemSize = *(uint16_t *)(data);
+    if(itemSize < sizeof(T)) {
+        throw invalid_value_exception(utils::string::to_string() << "itemSize less than sizeof(T)! itemSize=" << itemSize);
+    }
+
+    uint16_t itemNum = *(uint16_t *)(data + 2);
+    if(itemNum <= 0) {
+        throw invalid_value_exception(utils::string::to_string() << "itemNum error! itemNum=" << itemNum);
+    }
+
+    std::vector<T> outputVec;
+    outputVec.reserve(itemNum);
+    for(uint16_t i = 0; i < itemNum; i++) {
+        T item;
+        memcpy(&item, data + 4 + i * itemSize, sizeof(T));
+        outputVec.emplace_back(std::move(item));
+    }
+    return outputVec;
+}
+}  // namespace libobsensor
diff --git a/src/shared/utils/CameraParamProcess.cpp b/src/shared/utils/CameraParamProcess.cpp
new file mode 100644
index 00000000..37446b93
--- /dev/null
+++ b/src/shared/utils/CameraParamProcess.cpp
@@ -0,0 +1,233 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "CameraParamProcess.hpp"
+
+namespace libobsensor {
+void CameraParamProcessor::cameraIntrinsicParamsMirror(OBCameraIntrinsic *intrinsic) {
+    intrinsic->cx = (float)1.0 * intrinsic->width - intrinsic->cx - 1;
+}
+
+void CameraParamProcessor::distortionParamMirror(OBCameraDistortion *distort) {
+    distort->p2 *= -1.0;
+}
+
+void CameraParamProcessor::d2cTransformParamsMirror(OBD2CTransform *transform) {
+    // In the rotation matrix, invert r1, r2, r3, and r6
+    transform->rot[1] *= -1.0;
+    transform->rot[2] *= -1.0;
+    transform->rot[3] *= -1.0;
+    transform->rot[6] *= -1.0;
+    // Invert tx in the translation vector
+    (transform->trans)[0] *= -1.0;
+}
+
+void CameraParamProcessor::cameraIntrinsicParamsFlip(OBCameraIntrinsic *intrinsic) {
+    intrinsic->cy = (float)1.0 * intrinsic->height - intrinsic->cy - 1;
+}
+
+void CameraParamProcessor::distortionParamFlip(OBCameraDistortion *distort) {
+    distort->p1 *= -1.0;
+}
+
+void CameraParamProcessor::d2cTransformParamsFlip(OBD2CTransform *transform) {
+    transform->rot[1] *= -1.0;
+    transform->rot[3] *= -1.0;
+    transform->rot[5] *= -1.0;
+    transform->rot[7] *= -1.0;
+    (transform->trans)[1] *= -1.0;
+}
+
+void CameraParamProcessor::mirrorCameraParam(OBCameraParam *cameraParam) {
+    CameraParamProcessor::cameraIntrinsicParamsMirror(&cameraParam->rgbIntrinsic);
+    CameraParamProcessor::cameraIntrinsicParamsMirror(&cameraParam->depthIntrinsic);
+
+    CameraParamProcessor::distortionParamMirror(&cameraParam->rgbDistortion);
+    CameraParamProcessor::distortionParamMirror(&cameraParam->depthDistortion);
+
+    CameraParamProcessor::d2cTransformParamsMirror(&cameraParam->transform);
+}
+
+void CameraParamProcessor::flipCameraParam(OBCameraParam *cameraParam) {
+    CameraParamProcessor::cameraIntrinsicParamsFlip(&cameraParam->rgbIntrinsic);
+    CameraParamProcessor::cameraIntrinsicParamsFlip(&cameraParam->depthIntrinsic);
+
+    CameraParamProcessor::distortionParamFlip(&cameraParam->rgbDistortion);
+    CameraParamProcessor::distortionParamFlip(&cameraParam->depthDistortion);
+
+    CameraParamProcessor::d2cTransformParamsFlip(&cameraParam->transform);
+}
+
+void CameraParamProcessor::cameraIntrinsicParamsRotate90(OBCameraIntrinsic *intrinsic) {
+    auto tmp      = intrinsic->fx;
+    intrinsic->fx = intrinsic->fy;
+    intrinsic->fy = tmp;
+    tmp           = intrinsic->cx;
+    intrinsic->cx = (float)1.0 * intrinsic->height - intrinsic->cy - 1;
+    intrinsic->cy = tmp;
+
+    int16_t resTmp    = intrinsic->width;
+    intrinsic->width  = intrinsic->height;
+    intrinsic->height = resTmp;
+}
+
+void CameraParamProcessor::distortionParamRotate90(OBCameraDistortion *distort) {
+    float tmp   = distort->p1;
+    distort->p1 = distort->p2;
+    distort->p2 = (float)-1.0 * tmp;
+}
+
+void CameraParamProcessor::d2cTransformParamsRotate90(OBD2CTransform *transform) {
+    OBD2CTransform src;
+    memcpy(&src, transform, sizeof(OBD2CTransform));
+    transform->rot[0]   = src.rot[4];
+    transform->rot[1]   = -1.0f * src.rot[3];
+    transform->rot[2]   = -1.0f * src.rot[5];
+    transform->rot[3]   = -1.0f * src.rot[1];
+    transform->rot[4]   = src.rot[0];
+    transform->rot[5]   = src.rot[2];
+    transform->rot[6]   = -1.0f * src.rot[7];
+    transform->rot[7]   = src.rot[6];
+    transform->trans[0] = -1.0f * src.trans[1];
+    transform->trans[1] = src.trans[0];
+}
+
+void CameraParamProcessor::cameraIntrinsicParamsRotate180(OBCameraIntrinsic *intrinsic) {
+    intrinsic->cx = (float)1.0 * intrinsic->width - intrinsic->cx - 1;
+    intrinsic->cy = (float)1.0 * intrinsic->height - intrinsic->cy - 1;
+}
+
+void CameraParamProcessor::distortionParamRotate180(OBCameraDistortion *distort) {
+    distort->p1 *= -1.0;
+    distort->p2 *= -1.0;
+}
+
+void CameraParamProcessor::d2cTransformParamsRotate180(OBD2CTransform *transform) {
+    transform->rot[2] *= -1.0;
+    transform->rot[5] *= -1.0;
+    transform->rot[6] *= -1.0;
+    transform->rot[7] *= -1.0;
+    (transform->trans)[0] *= -1.0;
+    (transform->trans)[1] *= -1.0;
+}
+
+void CameraParamProcessor::cameraIntrinsicParamsRotate270(OBCameraIntrinsic *intrinsic) {
+    auto tmp      = intrinsic->fx;
+    intrinsic->fx = intrinsic->fy;
+    intrinsic->fy = tmp;
+
+    tmp           = intrinsic->cy;
+    intrinsic->cy = (float)1.0 * intrinsic->width - intrinsic->cx - 1;
+    intrinsic->cx = tmp;
+
+    int16_t resTmp    = intrinsic->width;
+    intrinsic->width  = intrinsic->height;
+    intrinsic->height = resTmp;
+}
+
+void CameraParamProcessor::distortionParamRotate270(OBCameraDistortion *distort) {
+    float tmp   = distort->p1;
+    distort->p1 = (float)-1.0 * distort->p2;
+    distort->p2 = tmp;
+}
+
+void CameraParamProcessor::d2cTransformParamsRotate270(OBD2CTransform *transform) {
+    OBD2CTransform src;
+    memcpy(&src, transform, sizeof(OBD2CTransform));
+    transform->rot[0] = src.rot[4];
+    transform->rot[1] = -1.0f * src.rot[3];
+    transform->rot[2] = src.rot[5];
+    transform->rot[3] = -1.0f * src.rot[1];
+    transform->rot[4] = src.rot[0];
+    transform->rot[5] = -1.0f * src.rot[2];
+    transform->rot[6] *= src.rot[7];
+    transform->rot[7] *= -1.0f * src.rot[6];
+    transform->trans[0] = src.trans[1];
+    transform->trans[1] = -1.0f * src.trans[0];
+}
+
+void CameraParamProcessor::rotateCameraParam(OBCameraParam *cameraParam, int rotateAngle) {
+    // TODO: Change the values to enumerations
+    switch(rotateAngle) {
+    case 90: {
+        CameraParamProcessor::cameraIntrinsicParamsRotate90(&cameraParam->rgbIntrinsic);
+        CameraParamProcessor::cameraIntrinsicParamsRotate90(&cameraParam->depthIntrinsic);
+        CameraParamProcessor::distortionParamRotate90(&cameraParam->rgbDistortion);
+        CameraParamProcessor::distortionParamRotate90(&cameraParam->depthDistortion);
+        CameraParamProcessor::d2cTransformParamsRotate90(&cameraParam->transform);
+    } break;
+
+    case 180: {
+        CameraParamProcessor::cameraIntrinsicParamsRotate180(&cameraParam->rgbIntrinsic);
+        CameraParamProcessor::cameraIntrinsicParamsRotate180(&cameraParam->depthIntrinsic);
+        CameraParamProcessor::distortionParamRotate180(&cameraParam->rgbDistortion);
+        CameraParamProcessor::distortionParamRotate180(&cameraParam->depthDistortion);
+        CameraParamProcessor::d2cTransformParamsRotate180(&cameraParam->transform);
+    } break;
+
+    case 270: {
+        CameraParamProcessor::cameraIntrinsicParamsRotate270(&cameraParam->rgbIntrinsic);
+        CameraParamProcessor::cameraIntrinsicParamsRotate270(&cameraParam->depthIntrinsic);
+        CameraParamProcessor::distortionParamRotate270(&cameraParam->rgbDistortion);
+        CameraParamProcessor::distortionParamRotate270(&cameraParam->depthDistortion);
+        CameraParamProcessor::d2cTransformParamsRotate270(&cameraParam->transform);
+    } break;
+    }
+}
+
+OBExtrinsic CameraParamProcessor::multiplyExtrinsic(const OBExtrinsic &extrinsic1, const OBExtrinsic &extrinsic2) {
+    OBExtrinsic resultExtrinsic;
+
+    // Multiply rotation matrices
+    for(int i = 0; i < 3; i++) {
+        for(int j = 0; j < 3; j++) {
+            resultExtrinsic.rot[i * 3 + j] = extrinsic1.rot[i * 3] * extrinsic2.rot[j] + extrinsic1.rot[i * 3 + 1] * extrinsic2.rot[j + 3]
+                                             + extrinsic1.rot[i * 3 + 2] * extrinsic2.rot[j + 6];
+        }
+    }
+
+    // Calculate the translation vector
+    resultExtrinsic.trans[0] = extrinsic1.rot[0] * extrinsic2.trans[0] +  //
+                               extrinsic1.rot[1] * extrinsic2.trans[1] +  //
+                               extrinsic1.rot[2] * extrinsic2.trans[2] +  //
+                               extrinsic1.trans[0];
+
+    resultExtrinsic.trans[1] = extrinsic1.rot[3] * extrinsic2.trans[0] +  //
+                               extrinsic1.rot[4] * extrinsic2.trans[1] +  //
+                               extrinsic1.rot[5] * extrinsic2.trans[2] +  //
+                               extrinsic1.trans[1];
+
+    resultExtrinsic.trans[2] = extrinsic1.rot[6] * extrinsic2.trans[0] +  //
+                               extrinsic1.rot[7] * extrinsic2.trans[1] +  //
+                               extrinsic1.rot[8] * extrinsic2.trans[2] +  //
+                               extrinsic1.trans[2];
+
+    return resultExtrinsic;
+}
+
+OBExtrinsic CameraParamProcessor::inverseExtrinsic(const OBExtrinsic &extrinsic) {
+    OBExtrinsic invExtrinsic;
+
+    // Transpose the rotation matrix
+    invExtrinsic.rot[0] = extrinsic.rot[0];
+    invExtrinsic.rot[1] = extrinsic.rot[3];
+    invExtrinsic.rot[2] = extrinsic.rot[6];
+    invExtrinsic.rot[3] = extrinsic.rot[1];
+    invExtrinsic.rot[4] = extrinsic.rot[4];
+    invExtrinsic.rot[5] = extrinsic.rot[7];
+    invExtrinsic.rot[6] = extrinsic.rot[2];
+    invExtrinsic.rot[7] = extrinsic.rot[5];
+    invExtrinsic.rot[8] = extrinsic.rot[8];
+
+    // Calculate the inverse translation vector
+    float invRot[9] = { invExtrinsic.rot[0], invExtrinsic.rot[1], invExtrinsic.rot[2], invExtrinsic.rot[3], invExtrinsic.rot[4],
+                        invExtrinsic.rot[5], invExtrinsic.rot[6], invExtrinsic.rot[7], invExtrinsic.rot[8] };
+
+    invExtrinsic.trans[0] = -invRot[0] * extrinsic.trans[0] - invRot[1] * extrinsic.trans[1] - invRot[2] * extrinsic.trans[2];
+    invExtrinsic.trans[1] = -invRot[3] * extrinsic.trans[0] - invRot[4] * extrinsic.trans[1] - invRot[5] * extrinsic.trans[2];
+    invExtrinsic.trans[2] = -invRot[6] * extrinsic.trans[0] - invRot[7] * extrinsic.trans[1] - invRot[8] * extrinsic.trans[2];
+
+    return invExtrinsic;
+}
+
+}  // namespace libobsensor
diff --git a/src/shared/utils/CameraParamProcess.hpp b/src/shared/utils/CameraParamProcess.hpp
new file mode 100644
index 00000000..da727367
--- /dev/null
+++ b/src/shared/utils/CameraParamProcess.hpp
@@ -0,0 +1,55 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include <string.h>
+#include <vector>
+#include <memory>
+#include "libobsensor/h/ObTypes.h"
+
+namespace libobsensor {
+
+const OBExtrinsic IdentityExtrinsics = { {
+                                             1,
+                                             0,
+                                             0,
+                                             0,
+                                             1,
+                                             0,
+                                             0,
+                                             0,
+                                             1,
+                                         },
+                                         { 0, 0, 0 } };
+
+class CameraParamProcessor {
+public:
+    static void cameraIntrinsicParamsMirror(OBCameraIntrinsic *intrinsic);
+    static void distortionParamMirror(OBCameraDistortion *distort);
+    static void d2cTransformParamsMirror(OBD2CTransform *transform);
+
+    static void cameraIntrinsicParamsFlip(OBCameraIntrinsic *intrinsic);
+    static void distortionParamFlip(OBCameraDistortion *distort);
+    static void d2cTransformParamsFlip(OBD2CTransform *transform);
+
+    static void cameraIntrinsicParamsRotate90(OBCameraIntrinsic *intrinsic);
+    static void distortionParamRotate90(OBCameraDistortion *distort);
+    static void d2cTransformParamsRotate90(OBD2CTransform *transform);
+
+    static void cameraIntrinsicParamsRotate180(OBCameraIntrinsic *intrinsic);
+    static void distortionParamRotate180(OBCameraDistortion *distort);
+    static void d2cTransformParamsRotate180(OBD2CTransform *transform);
+
+    static void cameraIntrinsicParamsRotate270(OBCameraIntrinsic *intrinsic);
+    static void distortionParamRotate270(OBCameraDistortion *distort);
+    static void d2cTransformParamsRotate270(OBD2CTransform *transform);
+
+    static void mirrorCameraParam(OBCameraParam *cameraParam);
+    static void flipCameraParam(OBCameraParam *cameraParam);
+    static void rotateCameraParam(OBCameraParam *cameraParam, int rotateAngle);
+
+    static OBExtrinsic multiplyExtrinsic(const OBExtrinsic &extrinsic1, const OBExtrinsic &extrinsic2);
+    static OBExtrinsic inverseExtrinsic(const OBExtrinsic &extrinsic);
+};
+}  // namespace libobsensor
diff --git a/src/shared/utils/CoordinateUtil.cpp b/src/shared/utils/CoordinateUtil.cpp
new file mode 100644
index 00000000..eda5cf50
--- /dev/null
+++ b/src/shared/utils/CoordinateUtil.cpp
@@ -0,0 +1,706 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "CoordinateUtil.hpp"
+#include "logger/Logger.hpp"
+#include "logger/LoggerInterval.hpp"
+
+#include <cmath>
+
+namespace libobsensor {
+static bool judgeTransformValid(OBD2CTransform cameraRotParam) {
+    // Orthogonality of rotation matrix
+    // r1 .*r2 = 0 ;
+    float r1r2 = cameraRotParam.rot[0] * cameraRotParam.rot[3] + cameraRotParam.rot[1] * cameraRotParam.rot[4] + cameraRotParam.rot[2] * cameraRotParam.rot[5];
+
+    float r1r3 =
+        cameraRotParam.rot[0] * cameraRotParam.rot[6] + cameraRotParam.rot[1] * cameraRotParam.rot[7] + cameraRotParam.rot[2] * cameraRotParam.rot[8];
+
+    if(fabsf(r1r2) < EPS && fabs(r1r3) < EPS) {
+        return true;
+    }
+    return false;
+}
+
+static bool judgeIntrinsicValid(OBCameraIntrinsic param) {
+    if(param.width == 0 || param.height == 0) {
+        return false;
+    }
+
+    if((param.fx < 1.0f) || (param.fy < 1.0f )||(param.cx < 1.0f) || (param.cy <1.0f)) {
+        return false;
+    }
+    if((param.fx > FMAX) || (param.fy > FMAX) | (param.cx > FMAX) || (param.cy > FMAX)) {
+        return false;
+    }
+
+    return true;
+}
+
+static bool undistortIterativeUnproject(const OBCameraIntrinsic intrinsic, const OBCameraDistortion disto, const OBPoint2f pixel, OBPoint2f *xy) {
+    double r2, r4, r6;
+    double x = 0;
+    double y = 0;
+    double kr_inv, xd, yd, dx, dy;
+    xd = (pixel.x - intrinsic.cx) / intrinsic.fx;
+    yd = (pixel.y - intrinsic.cy) / intrinsic.fy;
+
+    x               = xd;
+    y               = yd;
+    double bestErr = 99999;
+    int valid          = 1;
+
+    // if(disto.model == OB_DISTORTION_BROWN_CONRADY) {
+    {
+
+        for(int i = 0; i < 20; i++) {
+            // Iterate to remove distortion
+            r2     = x * x + y * y;
+            r4     = r2 * r2;
+            r6     = r4 * r2;
+            kr_inv = (1 + disto.k4 * r2 + disto.k5 * r4 + disto.k6 * r6) / (1 + disto.k1 * r2 + disto.k2 * r4 + disto.k3 * r6);
+            dx     = disto.p1 * 2 * x * y + disto.p2 * (r2 + 2 * x * x);
+            dy     = disto.p2 * 2 * x * y + disto.p1 * (r2 + 2 * y * y);
+            x      = (xd - dx) * kr_inv;
+            y      = (yd - dy) * kr_inv;
+
+            // Add distortion to distortion-free points,
+            // double a1, a2, a3, cdist, icdist2;
+            double a1, a2, a3, cdist;
+            double xd0, yd0;
+            r2            = x * x + y * y;
+            r4            = r2 * r2;
+            r6            = r4 * r2;
+            a1            = 2 * x * y;
+            a2            = r2 + 2 * x * x;
+            a3            = r2 + 2 * y * y;
+            cdist         = (1 + disto.k1 * r2 + disto.k2 * r4 + disto.k3 * r6) / (1 + disto.k4 * r2 + disto.k5 * r4 + disto.k6 * r6);
+            xd0           = x * cdist + disto.p1 * a1 + disto.p2 * a2;
+            yd0           = y * cdist + disto.p1 * a3 + disto.p2 * a1;
+            double x_proj = xd0 * intrinsic.fx + intrinsic.cx;
+            double y_proj = yd0 * intrinsic.fy + intrinsic.cy;
+            double error  = sqrt(pow(x_proj - pixel.x, 2) + pow(y_proj - pixel.y, 2));
+
+            if(error > bestErr)
+                break;
+
+            bestErr = error;
+
+            if(error < 0.01) {
+                break;
+            }
+        }
+    }
+
+    if(bestErr > 0.5) {
+        valid = 0;
+        xy->x     = (float)xd;
+        xy->y     = (float)yd;
+        return valid;
+    }
+
+     xy->x = (float)x, xy->y = (float)y;
+    return valid;
+}
+
+
+void calculateInverseMatrix(OBD2CTransform srcTrans, OBD2CTransform *dstTrans) {
+
+    dstTrans->rot[0] = srcTrans.rot[0];
+    dstTrans->rot[1] = srcTrans.rot[3];
+    dstTrans->rot[2] = srcTrans.rot[6];
+    dstTrans->rot[3] = srcTrans.rot[1];
+    dstTrans->rot[4] = srcTrans.rot[4];
+    dstTrans->rot[5] = srcTrans.rot[7];
+    dstTrans->rot[6] = srcTrans.rot[2];
+    dstTrans->rot[7] = srcTrans.rot[5];
+    dstTrans->rot[8] = srcTrans.rot[8];
+
+    dstTrans->trans[0] = -(dstTrans->rot[0] * srcTrans.trans[0] + dstTrans->rot[1] * srcTrans.trans[1] + dstTrans->rot[2] * srcTrans.trans[2]);
+    dstTrans->trans[1] = -(dstTrans->rot[3] * srcTrans.trans[0] + dstTrans->rot[4] * srcTrans.trans[1] + dstTrans->rot[5] * srcTrans.trans[2]);
+    dstTrans->trans[2] = -(dstTrans->rot[6] * srcTrans.trans[0] + dstTrans->rot[7] * srcTrans.trans[1] + dstTrans->rot[8] * srcTrans.trans[2]);
+}
+
+bool isPixelValid(const OBPoint2f curr, const OBPoint2f start, const OBPoint2f end) {
+    bool valid1 = end.x >= start.x && end.x >= curr.x && curr.x >= start.x;
+    bool valid2 = end.x <= start.x && end.x <= curr.x && curr.x <= start.x;
+    bool valid3 = end.y >= start.y && end.y >= curr.y && curr.y >= start.y;
+    bool valid4 = end.y <= start.y && end.y <= curr.y && curr.y <= start.y;
+    return (valid1 || valid2) && (valid3 || valid4);
+}
+
+void nextPixel(OBPoint2f &curr, const OBPoint2f start, const OBPoint2f end) {
+    if(fabsf(end.x - start.x) < EPS) {
+        curr.y = end.y > curr.y ? curr.y + 1 : curr.y - 1;
+    }
+    else {
+        float slope = (end.y - start.y) / (end.x - start.x);
+
+        if(fabs(end.x - curr.x) > fabs(end.y - curr.y)) {
+            curr.x = end.x > curr.x ? curr.x + 1 : curr.x - 1;
+            curr.y = end.y - slope * (end.x - curr.x);
+        }
+        else {
+            curr.y = end.y > curr.y ? curr.y + 1 : curr.y - 1;
+            curr.x = end.x - ((end.y - curr.y) / slope);
+        }
+    }
+}
+
+static void project3dPointToPixelWithDistortion(const OBCameraIntrinsic intrinsic, const OBCameraDistortion distortion, OBPoint3f point, OBPoint2f *pixel, int &valid) {
+    double x = point.x / point.z;
+    double y = point.y / point.z;
+
+    valid     = 1;
+    double xd = x, yd = y;
+    //if k1 >0, we need to take image distortion into accout when projecting onto an image
+    if(fabsf(distortion.k1) > EPS || fabsf(distortion.k2) > EPS) {
+        if(distortion.model == OB_DISTORTION_BROWN_CONRADY){
+            double a1, a2, a3, cdist;
+            double r2, r4, r6;
+            r2    = x * x + y * y;
+            r4    = r2 * r2;
+            r6    = r4 * r2;
+            a1    = 2 * x * y;
+            a2    = r2 + 2 * x * x;
+            a3    = r2 + 2 * y * y;
+            cdist = (1 + distortion.k1 * r2 + distortion.k2 * r4 + distortion.k3 * r6) / (1 + distortion.k4 * r2 + distortion.k5 * r4 + distortion.k6 * r6);
+            xd    = x * cdist + distortion.p1 * a1 + distortion.p2 * a2;
+            yd    = y * cdist + distortion.p1 * a3 + distortion.p2 * a1;
+        }
+    }
+
+    pixel->x = (float)xd * intrinsic.fx + intrinsic.cx;
+    pixel->y = (float)yd * intrinsic.fy + intrinsic.cy;
+
+    if(pixel->x > intrinsic.width - 1 || pixel->y > intrinsic.height - 1) {
+        valid = 0;
+    }
+    if(pixel->x < 0 || pixel->y < 0) {
+        valid = 0;
+    }
+
+}
+
+bool CoordinateUtil::transformation3dTo3d(const OBPoint3f sourcePoint3f, OBD2CTransform transSourceToTarget, OBPoint3f *targetPoint3f) {
+    // step 1: parameter validity judgment
+    if(!judgeTransformValid(transSourceToTarget)) {
+        return false;
+    }
+
+    if(fabsf(sourcePoint3f.z) < EPS) {
+        return false;
+    }
+
+    // step 2: Calculate conversion relationship
+   // R *X + t
+    float rx =
+        transSourceToTarget.rot[0] * sourcePoint3f.x + transSourceToTarget.rot[1] * sourcePoint3f.y + transSourceToTarget.rot[2] * sourcePoint3f.z;
+    float ry =
+        transSourceToTarget.rot[3] * sourcePoint3f.x + transSourceToTarget.rot[4] * sourcePoint3f.y + transSourceToTarget.rot[5] * sourcePoint3f.z;
+    float rz =
+        transSourceToTarget.rot[6] * sourcePoint3f.x + transSourceToTarget.rot[7] * sourcePoint3f.y + transSourceToTarget.rot[8] * sourcePoint3f.z;
+
+    (*targetPoint3f).x = rx + transSourceToTarget.trans[0];
+    (*targetPoint3f).y = ry + transSourceToTarget.trans[1];
+    (*targetPoint3f).z = rz + transSourceToTarget.trans[2];
+
+    return true;
+}
+
+bool CoordinateUtil::transformation2dTo3d(const OBCameraIntrinsic sourceIntrinsic, const OBPoint2f sourcePoint2f, const float sourceDepthPixelValue,
+                                          OBD2CTransform transSourceToTarget, OBPoint3f *targetPoint3f) {
+    // step 1: parameter validity judgment
+    if(!judgeIntrinsicValid(sourceIntrinsic)) {
+        return false;
+    }
+
+    if(!judgeTransformValid(transSourceToTarget)) {
+        return false;
+    }
+
+    // sourcePoint2f is the pixel coordinates of the image, or sub-pixel coordinates
+    if(sourcePoint2f.x < 0 || sourcePoint2f.y < 0) {
+        return false;
+    }
+
+    if(sourcePoint2f.x > (sourceIntrinsic.width - 1) || sourcePoint2f.y > (sourceIntrinsic.height - 1)) {
+        return false;
+    }
+
+    // step 2: Convert 2D to 3D point
+    OBPoint3f source_3f;
+    source_3f.z = sourceDepthPixelValue;  // Assignment in z direction
+    // Convert 2d to 3d (same as converting point cloud)
+    source_3f.x = sourceDepthPixelValue * (sourcePoint2f.x - sourceIntrinsic.cx) / sourceIntrinsic.fx;
+    source_3f.y = sourceDepthPixelValue * (sourcePoint2f.y - sourceIntrinsic.cy) / sourceIntrinsic.fy;
+
+    // step 3: Convert the 3D point under the source coordinates to the target camera coordinates
+    bool ret = transformation3dTo3d(source_3f, transSourceToTarget, targetPoint3f);
+
+    return ret;
+}
+
+bool CoordinateUtil::transformation2dTo3d(const OBCameraIntrinsic sourceIntrinsic, const OBCameraDistortion sourceDistortion, const OBPoint2f sourcePoint2f,
+                                                      const float sourceDepthPixelValue, OBD2CTransform transSourceToTarget,
+                                                      OBPoint3f *targetPoint3f) {
+  // step 1: parameter validity judgment
+    if(!judgeIntrinsicValid(sourceIntrinsic)) {
+        return false;
+    }
+
+    if(!judgeTransformValid(transSourceToTarget)) {
+        return false;
+    }
+
+    // sourcePoint2f is the pixel coordinates of the image, or sub-pixel coordinates
+    if(sourcePoint2f.x < 0 || sourcePoint2f.y < 0) {
+        return false;
+    }
+
+    if(sourcePoint2f.x > (sourceIntrinsic.width - 1) || sourcePoint2f.y > (sourceIntrinsic.height - 1)) {
+        return false;
+    }
+
+    // step 2: Convert 2D to 3D point
+    OBPoint3f source_3f;
+    source_3f.z = sourceDepthPixelValue;  // Assignment in z direction
+    // Convert 2d to 3d (same as converting point cloud)
+    OBPoint2f pointUnitFocalPlane;
+    bool      valid = undistortIterativeUnproject(sourceIntrinsic, sourceDistortion, sourcePoint2f, &pointUnitFocalPlane);
+
+    if(valid == false) {
+        return false;
+    }
+
+    source_3f.x = pointUnitFocalPlane.x * source_3f.z;
+    source_3f.y = pointUnitFocalPlane.y * source_3f.z;
+
+    // step 3: Convert the 3D point under the source to the target camera coordinates
+    bool ret = transformation3dTo3d(source_3f, transSourceToTarget, targetPoint3f);
+
+    return ret;
+}
+
+bool CoordinateUtil::transformation3dTo2d(const OBPoint3f sourcePoint3f, const OBCameraIntrinsic targetIntrinsic, const OBCameraDistortion targetDistortion,
+                                          OBD2CTransform transSourceToTarget, OBPoint2f *targetPoint2f) {
+
+    // step 1: Convert the 3D point under the source to the target camera coordinates
+    OBPoint3f targetPoint3f;
+    bool ret = transformation3dTo3d(sourcePoint3f, transSourceToTarget, &targetPoint3f);
+    if(!ret) {
+        return ret;
+    }
+
+    // step 2: Convert the 3D point under the target camera coordinates to a 2D point
+    int valid = 1;
+    project3dPointToPixelWithDistortion(targetIntrinsic, targetDistortion, targetPoint3f, targetPoint2f, valid);
+
+    return valid;
+}
+
+bool CoordinateUtil::transformation2dTo2d(const OBCameraIntrinsic sourceIntrinsic, const OBCameraDistortion sourceDistortion, const OBPoint2f sourcePoint2f,
+                                          const float sourceDepthPixelValue, const OBCameraIntrinsic targetIntrinsic,
+                                          const OBCameraDistortion targetDistortion,OBD2CTransform transSourceToTarget, OBPoint2f *targetPoint2f) {
+
+    // step 1: First convert the 2d of the source into the 3d of the target.
+    OBPoint3f targetPoint3f;
+    bool      ret = transformation2dTo3d(sourceIntrinsic, sourceDistortion, sourcePoint2f, sourceDepthPixelValue, transSourceToTarget, &targetPoint3f);
+    if(!ret) {
+        return ret;
+    }
+
+    // step 2: Convert the 3D point under the target camera coordinates to the 2D point under the image
+    int valid = 1;
+    project3dPointToPixelWithDistortion(targetIntrinsic, targetDistortion, targetPoint3f, targetPoint2f, valid);
+
+    return valid;
+}
+
+bool CoordinateUtil::transformationColor2dToDepth2d(const OBCameraIntrinsic colorIntrinsic, const OBCameraDistortion colorDistortion,
+                                                    const OBPoint2f colorPixel, uint16_t *depthMap, float depthScaleMm, const OBCameraIntrinsic depthIntrinsic,
+                                                    const OBCameraDistortion depthDistortion, OBD2CTransform transDepthToColor,
+                                                    OBD2CTransform transColorToDepth, OBPoint2f *depthPixel) {
+
+    float depthRangeMm[2] = { 60.f, 16000.f };
+    OBPoint2f nearPixelDepth, farthestPixelDepth;
+    bool   nearValid = 0, farthestValid = 0;
+
+    //color pixel to depth pixel when z= depthRangeMm[0]
+    nearValid = transformation2dTo2d(colorIntrinsic, colorDistortion, colorPixel, depthRangeMm[0], depthIntrinsic, depthDistortion, transColorToDepth,
+                                  &nearPixelDepth);
+    if(!nearValid) {
+        if(nearPixelDepth.x< 0) {
+            nearPixelDepth.x = 0;
+        }
+        if(nearPixelDepth.y <0) {
+            nearPixelDepth.y = 0;
+        }
+        if(nearPixelDepth.x > depthIntrinsic.width -1) {
+            nearPixelDepth.x = (float)depthIntrinsic.width - 1;
+        }
+        if(nearPixelDepth.y > depthIntrinsic.height - 1) {
+            nearPixelDepth.y = (float)depthIntrinsic.height - 1;
+        }
+    }
+
+    // color pixel to depth pixel when z= depthRangeMm[1]
+    farthestValid = transformation2dTo2d(colorIntrinsic, colorDistortion, colorPixel, depthRangeMm[1], depthIntrinsic, depthDistortion, transColorToDepth,
+                                  &farthestPixelDepth);
+    if(!farthestValid) {
+        if(farthestPixelDepth.x < 0) {
+            farthestPixelDepth.x = 0;
+        }
+        if(farthestPixelDepth.y < 0) {
+            farthestPixelDepth.y = 0;
+        }
+        if(farthestPixelDepth.x > depthIntrinsic.width - 1) {
+            farthestPixelDepth.x = (float)depthIntrinsic.width - 1;
+        }
+        if(farthestPixelDepth.y > depthIntrinsic.height - 1) {
+            farthestPixelDepth.y = (float)depthIntrinsic.height - 1;
+        }
+    }
+
+    // search along line for the depth pixel that it's projected pixel is the closest to the input pixel
+    float minDist = std::numeric_limits<float>::max();
+    for(OBPoint2f curPixel = nearPixelDepth; isPixelValid(curPixel, nearPixelDepth, farthestPixelDepth);
+        nextPixel(curPixel, nearPixelDepth, farthestPixelDepth)) {
+
+        int x     = (int)curPixel.x;
+        int y     = (int)curPixel.y;
+        int index =  y* depthIntrinsic.width + x;
+
+        if(depthMap[index] == 0)
+            continue;
+
+        float depth = depthScaleMm * depthMap[index];
+
+        // depth pixel to color pixel
+        OBPoint2f curColorPixel{};
+        transformation2dTo2d(depthIntrinsic, depthDistortion, curPixel, depth, colorIntrinsic, colorDistortion, transDepthToColor, &curColorPixel);
+        float errDist = (float)(pow((curColorPixel.x - colorPixel.x), 2) + pow((curColorPixel.y - colorPixel.y), 2));
+        if(errDist < minDist) {
+            minDist     = errDist;
+            depthPixel->x = curPixel.x;
+            depthPixel->y = curPixel.y;
+        }
+    }
+
+    return true;
+}
+    // std::shared_ptr<Frame> CoordinateUtil::transformationDepthFrameToColorCamera(std::shared_ptr<IDevice> device, std::shared_ptr<Frame> depthFrame,
+// uint32_t targetColorCameraWidth, uint32_t targetColorCameraHeight) {
+// auto absDevice = std::dynamic_pointer_cast<AbstractDevice>(device);
+// if(absDevice == nullptr) {
+// throw std::runtime_error("Device is invalid!");
+// }
+//
+// auto cameraParamList = absDevice->getCalibrationCameraParamList();
+// if(cameraParamList.empty()) {
+// LOG_WARN("Get calibration param failed,cameraParamList is empty!");
+// return nullptr;
+// }
+//
+// auto profileInfo =
+// absDevice->getSupportedProfileInfo(targetColorCameraWidth, targetColorCameraHeight, depthFrame->getWidth(), depthFrame->getHeight(), ALIGN_D2C_SW_MODE);
+// if(!profileInfo.valid()) {
+// LOG_ERROR("Input invalid");
+// return nullptr;
+// }
+//
+// auto cameraParam = cameraParamList[profileInfo.paramIndex];
+// auto depthWidth = depthFrame->getWidth();
+// auto depthHeight = depthFrame->getHeight();
+////Since the default parameters stored in the module may not match the current image state, for example, the MX6600 project parameters are calibrated in the
+///mirrored state, but the output image is non-mirrored, so the parameters need to be processed.
+// cameraParam = absDevice->preProcessCameraParam(cameraParam);
+////soft D2C filter
+// auto d2cFilter = std::make_shared<D2CFilter>();
+// d2cFilter->setCameraParam(cameraParam);
+// OBD2CAlignParam alignParam = absDevice->getD2CAlignParam();
+// d2cFilter->setD2CAlignParam(&alignParam);
+// d2cFilter->setColorSize(targetColorCameraWidth, targetColorCameraHeight);
+//
+////post process filter
+// auto postProcessFilter = std::make_shared<PostProcessFilter>();
+// postProcessFilter->setPostProcessParam(profileInfo.postProcessParam);
+// postProcessFilter->setDepthScaleRequire(true);
+// postProcessFilter->setDepthSize(depthWidth, depthHeight);
+//
+// depthFrame = d2cFilter->process(depthFrame);
+// if(depthFrame == nullptr) {
+// LOG_ERROR("D2C process failed.");
+// return nullptr;
+// }
+//
+// bool isParamTransform = absDevice->getCameraParamTransformState();
+// cameraParam = absDevice->transformCameraParamToD2CDstParam(cameraParam, profileInfo.postProcessParam, targetColorCameraWidth, targetColorCameraHeight,
+// depthWidth, depthHeight); cameraParam = CameraParamProcessor::postProcessCameraParam(profileInfo.postProcessParam, cameraParam, isParamTransform,
+// ALIGN_D2C_SW_MODE,targetColorCameraWidth, targetColorCameraHeight, depthWidth, depthHeight, true);
+// postProcessFilter->setTargetIntrinsic(cameraParam.depthIntrinsic);
+//
+// depthFrame = postProcessFilter->process(depthFrame);
+// if(depthFrame == nullptr) {
+// LOG_ERROR("Post process failed.");
+// return nullptr;
+// }
+//
+// return depthFrame;
+// }
+
+bool CoordinateUtil::transformationInitXYTables(const OBCameraIntrinsic intrinsic, const OBCameraDistortion distortion, float *data, uint32_t *dataSize,
+                                                OBXYTables *xyTables) {
+    // step 1: parameter validity judgment
+    if(!judgeIntrinsicValid(intrinsic)) {
+        return false;
+    }
+
+    int width  = intrinsic.width;
+    int height = intrinsic.height;
+
+    size_t tableSize = (size_t)(width * height);
+    if(data == NULL)  // If no external memory is requested, an error will be reported
+    {
+        (*dataSize) = 2 * (uint32_t)tableSize;
+        return false;
+    }
+    else {
+        // If the externally requested memory size is not enough, an error will be reported.
+        if(*dataSize < 2 * tableSize) {
+            LOG_ERROR("Unexpected xy table size {}, should be larger or equal than {}.", int(*dataSize), int(2 * tableSize));
+            return false;
+        }
+
+        xyTables->width  = width;
+        xyTables->height = height;
+        xyTables->xTable = data;
+        xyTables->yTable = data + tableSize;
+
+        OBPoint2f point2d;
+        OBPoint2f outPoint2d;
+        for(int y = 0, idx = 0; y < height; y++) {
+            point2d.y = (float)y;
+            for(int x = 0; x < width; x++, idx++) {
+                point2d.x = (float)x;
+
+                // pixel to point without distortion on the unit focal plane
+                if(!undistortIterativeUnproject(intrinsic, distortion, point2d, &outPoint2d)) {
+                    // x table value of NAN marks invalid
+                    xyTables->xTable[idx] = NAN;
+                    // set y table value to 0 to speed up SSE implementation
+                    xyTables->yTable[idx] = 0.f;
+                }
+                else {
+                    xyTables->xTable[idx] = outPoint2d.x;
+                    xyTables->yTable[idx] = outPoint2d.y;
+                }
+            }
+        }
+        (*dataSize) = 2 * (uint32_t)tableSize;
+    }
+    return true;
+}
+
+bool CoordinateUtil::transformationInitAddDistortionUVTables(const OBCameraIntrinsic intrinsic, const OBCameraDistortion distortion, float *data,
+                                                             uint32_t *dataSize, OBXYTables *uvTables) {
+    int                width     = intrinsic.width;
+    int                height    = intrinsic.height;
+
+    size_t tableSize = (size_t)(width * height);
+    if(data == NULL)  // If no external memory is requested, an error will be reported
+    {
+        (*dataSize) = 2 * (uint32_t)tableSize;
+        return false;
+    }
+    else {
+        // If the externally requested memory size is not enough, an error will be reported.
+        if(*dataSize < 2 * tableSize) {
+            LOG_ERROR("Unexpected xy table size {}, should be larger or equal than {}.", int(*dataSize), int(2 * tableSize));
+            return false;
+        }
+
+        // data and ob_xy_tables_t share memory
+        uvTables->width  = width;
+        uvTables->height = height;
+        uvTables->xTable = data;
+        uvTables->yTable = data + tableSize;
+
+        for(int row = 0, idx = 0; row < height; row++) {
+            double y = ((double)row - intrinsic.cy) / intrinsic.fy;
+            for(int col = 0; col < width; col++, idx++) {
+                double x = ((double)col - intrinsic.cx) / intrinsic.fx;
+
+                double xd = x, yd = y;
+                if(distortion.model == OB_DISTORTION_BROWN_CONRADY) {
+                     // Add distortion, only supports Brown model, k2, k3, k6 model, KB is not supported
+                     // double a1, a2, a3, cdist, icdist2;
+                     double a1, a2, a3, cdist;
+                     double r2, r4, r6;
+                     r2    = x * x + y * y;
+                     r4    = r2 * r2;
+                     r6    = r4 * r2;
+                     a1    = 2 * x * y;
+                     a2    = r2 + 2 * x * x;
+                     a3    = r2 + 2 * y * y;
+                     cdist = (1 + distortion.k1 * r2 + distortion.k2 * r4 + distortion.k3 * r6)
+                             / (1 + distortion.k4 * r2 + distortion.k5 * r4 + distortion.k6 * r6);
+                     xd = x * cdist + distortion.p1 * a1 + distortion.p2 * a2;
+                     yd = y * cdist + distortion.p1 * a3 + distortion.p2 * a1;
+                }
+
+                float x_proj = (float)xd * intrinsic.fx + intrinsic.cx;
+                float y_proj = (float)yd * intrinsic.fy + intrinsic.cy;
+
+                // Determine whether the point after adding distortion exceeds the image range. If it exceeds, the point is invalid.
+                if(x_proj < 0 || x_proj > (width - 1) || y_proj < 0 || y_proj > (height - 1)) {
+                    // Invalid data output
+                    // x table value of NAN marks invalid
+                    uvTables->xTable[idx] = NAN;
+                    // set y table value to 0 to speed up SSE implementation
+                    uvTables->yTable[idx] = 0.f;
+                }
+                else  // Valid data output
+                {
+                    uvTables->xTable[idx] = x_proj;
+                    uvTables->yTable[idx] = y_proj;
+                }
+            }
+        }
+        (*dataSize) = 2 * (uint32_t)tableSize;
+    }
+    return true;
+}
+
+void CoordinateUtil::transformationDepthToPointCloud(OBXYTables *xyTables, const void *depthImageData, void *pointCloudData, float positionDataScale,
+                                                     OBCoordinateSystemType type) {
+    const uint16_t *imageData = (const uint16_t *)depthImageData;
+    float          *xyzData   = (float *)pointCloudData;
+    float           x, y, z;
+    int             coordinateSystemCoefficient = type == OB_LEFT_HAND_COORDINATE_SYSTEM ? -1 : 1;
+
+    for(int i = 0; i < xyTables->width * xyTables->height; i++) {
+        float x_tab = xyTables->xTable[i];
+
+        uint16_t depthValue = imageData[i];
+        if(!std::isnan(x_tab) && depthValue != 65535) {
+            z = (float)depthValue;
+            x = x_tab * (float)z;
+            y = xyTables->yTable[i] * (float)z * coordinateSystemCoefficient;
+
+            z *= positionDataScale;
+            x *= positionDataScale;
+            y *= positionDataScale;
+        }
+        else {
+            x = 0.0;
+            y = 0.0;
+            z = 0.0;
+        }
+
+        xyzData[3 * i + 0] = x;
+        xyzData[3 * i + 1] = y;
+        xyzData[3 * i + 2] = z;
+    }
+}
+
+void CoordinateUtil::transformationDepthToRGBDPointCloud(OBXYTables *xyTables, const void *depthImageData, const void *colorImageData, void *pointCloudData,
+                                                         float positionDataScale, OBCoordinateSystemType type, bool colorDataNormalization) {
+    const uint16_t *dImageData = (const uint16_t *)depthImageData;
+    const uint8_t  *cImageData = (const uint8_t *)colorImageData;
+    float          *xyzrgbData = (float *)pointCloudData;
+    float           x, y, z;
+    float           r, g, b;
+    int             coordinateSystemCoefficient = type == OB_LEFT_HAND_COORDINATE_SYSTEM ? -1 : 1;
+    float           colorDivCoeff               = colorDataNormalization ? 255.0f : 1.0f;
+
+    for(int i = 0; i < xyTables->width * xyTables->height; i++) {
+        float x_tab = xyTables->xTable[i];
+
+        uint16_t depthValue = dImageData[i];
+        if(!std::isnan(x_tab) && depthValue != 65535) {
+            z = (float)depthValue;
+            x = x_tab * (float)z;
+            y = xyTables->yTable[i] * (float)z * coordinateSystemCoefficient;
+
+            z *= positionDataScale;
+            x *= positionDataScale;
+            y *= positionDataScale;
+
+            r = cImageData[3 * i + 0] / colorDivCoeff;
+            g = cImageData[3 * i + 1] / colorDivCoeff;
+            b = cImageData[3 * i + 2] / colorDivCoeff;
+        }
+        else {
+            x = 0.0;
+            y = 0.0;
+            z = 0.0;
+            r = 0.0;
+            g = 0.0;
+            b = 0.0;
+        }
+
+        xyzrgbData[6 * i + 0] = x;
+        xyzrgbData[6 * i + 1] = y;
+        xyzrgbData[6 * i + 2] = z;
+        xyzrgbData[6 * i + 3] = r;
+        xyzrgbData[6 * i + 4] = g;
+        xyzrgbData[6 * i + 5] = b;
+    }
+}
+
+void CoordinateUtil::transformationDepthToRGBDPointCloudByUVTables(const OBCameraIntrinsic rgbIntrinsic, OBXYTables *uvTables, const void *depthImageData,
+                                                                   const void *colorImageData, void *pointCloudData, float positionDataScale,
+                                                                   OBCoordinateSystemType type, bool colorDataNormalization) {
+    const uint16_t *dImageData = (const uint16_t *)depthImageData;
+    const uint8_t  *cImageData = (const uint8_t *)colorImageData;
+    float          *xyzrgbData = (float *)pointCloudData;
+    float           x, y, z;
+    float           r, g, b;
+    int             coordinateSystemCoefficient = type == OB_LEFT_HAND_COORDINATE_SYSTEM ? -1 : 1;
+    float           colorDivCoeff               = colorDataNormalization ? 255.0f : 1.0f;
+
+    for(int i = 0; i < uvTables->width * uvTables->height; i++) {
+        // int u_tab = (int)uvTables->xTable[i];
+        // int v_tab = (int)uvTables->yTable[i];
+
+        int xValue = i % uvTables->width;
+        int yValue = i / uvTables->width;
+
+        uint16_t depthValue = dImageData[i];
+        if(!std::isnan(uvTables->xTable[i]) && depthValue != 65535) {
+            z = (float)depthValue;
+            x = ((xValue - rgbIntrinsic.cx) / rgbIntrinsic.fx) * (float)z;
+            y = ((yValue - rgbIntrinsic.cy) / rgbIntrinsic.fy) * (float)z * coordinateSystemCoefficient;
+
+            z *= positionDataScale;
+            x *= positionDataScale;
+            y *= positionDataScale;
+
+            int u_rgb   = (int)round(uvTables->xTable[i]);
+            int v_rgb   = (int)round(uvTables->yTable[i]);
+            int idx_rgb = v_rgb * uvTables->width + u_rgb;
+
+            r = cImageData[3 * idx_rgb + 0] / colorDivCoeff;
+            g = cImageData[3 * idx_rgb + 1] / colorDivCoeff;
+            b = cImageData[3 * idx_rgb + 2] / colorDivCoeff;
+        }
+        else {
+            x = (int)0.0;
+            y = (int)0.0;
+            z = 0.0;
+            r = 0.0;
+            g = 0.0;
+            b = 0.0;
+        }
+
+        xyzrgbData[6 * i + 0] = (float)x;
+        xyzrgbData[6 * i + 1] = (float)y;
+        xyzrgbData[6 * i + 2] = z;
+        xyzrgbData[6 * i + 3] = r;
+        xyzrgbData[6 * i + 4] = g;
+        xyzrgbData[6 * i + 5] = b;
+    }
+}
+
+}  // namespace libobsensor
diff --git a/src/shared/utils/CoordinateUtil.hpp b/src/shared/utils/CoordinateUtil.hpp
new file mode 100644
index 00000000..be2467fe
--- /dev/null
+++ b/src/shared/utils/CoordinateUtil.hpp
@@ -0,0 +1,61 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include "libobsensor/h/ObTypes.h"
+// #include "core/device/IDevice.hpp"
+// #include "core/frame/Frame.hpp"
+#include <memory>
+#include <cmath>
+
+namespace libobsensor {
+#define EPS 1e-4
+#define FMAX 1e4
+
+class CoordinateUtil {
+public:
+    static bool transformation3dTo3d(const OBPoint3f sourcePoint3f, OBD2CTransform transSourceToTarget, OBPoint3f *targetPoint3f);
+
+    static bool transformation2dTo3d(const OBCameraIntrinsic sourceIntrinsic, const OBPoint2f sourcePoint2f, const float sourceDepthPixelValue,
+                                     OBD2CTransform transSourceToTarget, OBPoint3f *targetPoint3f);
+
+    static bool transformation2dTo3d(const OBCameraIntrinsic sourceIntrinsic, const OBCameraDistortion sourceDistortion,
+                                                   const OBPoint2f sourcePoint2f,const float sourceDepthPixelValue,
+                                                 const OBD2CTransform transSourceToTarget, OBPoint3f *targetPoint3f);
+
+    static bool transformation3dTo2d(const OBPoint3f sourcePoint3f, const OBCameraIntrinsic targetIntrinsic, const OBCameraDistortion targetDistortion,
+                                     OBD2CTransform transSourceToTarget, OBPoint2f *targetPoint2f);
+
+    static bool transformation2dTo2d(const OBCameraIntrinsic sourceIntrinsic, const OBCameraDistortion sourceDistortion, const OBPoint2f sourcePoint2f,
+                                     const float sourceDepthPixelValue, const OBCameraIntrinsic targetIntrinsic, const OBCameraDistortion targetDistortion,
+                                     OBD2CTransform transSourceToTarget, OBPoint2f *targetPoint2f);
+
+    static bool transformationColor2dToDepth2d(const OBCameraIntrinsic colorIntrinsic, const OBCameraDistortion colorDistortion, const OBPoint2f colorPixel,
+                                               uint16_t *depthMap, float depthScaleMm, const OBCameraIntrinsic depthIntrinsic,
+                                               const OBCameraDistortion depthDistortion, OBD2CTransform transDepthToColor, OBD2CTransform transColorToDepth,
+                                               OBPoint2f *depthPixel);
+
+    /*static std::shared_ptr<Frame> transformationDepthFrameToColorCamera(std::shared_ptr<IDevice> device, std::shared_ptr<Frame> depthFrame,
+    uint32_t targetColorCameraWidth, uint32_t targetColorCameraHeight);*/
+
+    // The memory of data needs to be applied externally. During initialization, the size of the external application is data_size, for example, datasize =
+    // 1920*1080 *2 (1920*1080 means image resolution, 2 means there are two luts, The coordinates of x and y respectively)
+    static bool transformationInitXYTables(const OBCameraIntrinsic intrinsic, const OBCameraDistortion distortion, float *data, uint32_t *dataSize,
+                                           OBXYTables *xyTables);
+
+    static bool transformationInitAddDistortionUVTables(const OBCameraIntrinsic intrinsic, const OBCameraDistortion distortion, float *data, uint32_t *dataSize,
+                                                        OBXYTables *uvTables);
+
+    static void transformationDepthToPointCloud(OBXYTables *xyTables, const void *depthImageData, void *pointCloudData, float positionDataScale = 1.0f,
+                                                OBCoordinateSystemType type = OB_RIGHT_HAND_COORDINATE_SYSTEM);
+
+    static void transformationDepthToRGBDPointCloud(OBXYTables *xyTables, const void *depthImageData, const void *colorImageData, void *pointCloudData,
+                                                    float positionDataScale = 1.0f, OBCoordinateSystemType type = OB_RIGHT_HAND_COORDINATE_SYSTEM,
+                                                    bool colorDataNormalization = false);
+
+    static void transformationDepthToRGBDPointCloudByUVTables(const OBCameraIntrinsic rgbIntrinsic, OBXYTables *uvTables, const void *depthImageData,
+                                                              const void *colorImageData, void *pointCloudData, float positionDataScale = 1.0f,
+                                                              OBCoordinateSystemType type                   = OB_RIGHT_HAND_COORDINATE_SYSTEM,
+                                                              bool                   colorDataNormalization = false);
+};
+}  // namespace libobsensor
diff --git a/src/shared/utils/FileUtils.cpp b/src/shared/utils/FileUtils.cpp
new file mode 100644
index 00000000..3dfaa68b
--- /dev/null
+++ b/src/shared/utils/FileUtils.cpp
@@ -0,0 +1,237 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "FileUtils.hpp"
+
+#include <cstring>
+#include <cstdlib>
+#include <memory>
+#include <limits>
+
+#ifdef WIN32
+#include <direct.h>
+#include <wchar.h>
+#include <io.h>
+#include <Windows.h>
+#include <locale>
+#include <codecvt>
+#else
+#include <sys/stat.h>
+#include <unistd.h>
+#include <dirent.h>
+#endif
+
+#include "logger/Logger.hpp"
+
+namespace libobsensor {
+namespace utils {
+
+bool fileExists(const char *file) {
+#ifdef WIN32
+    return (_access(file, 0) == 0);
+#else
+    return (access(file, 0) == 0);
+#endif
+}
+
+bool checkDir(const char *dir) {
+#ifdef WIN32
+    return (_access(dir, 0) == 0);
+#else
+    return (access(dir, 0) == 0);
+#endif
+}
+
+int mkDirs(const char *dir) {
+    size_t i, len;
+    char   str[512];
+    int    error = 0;
+
+#ifdef WIN32
+    // Use snprintf to ensure the string is copied safely
+    snprintf(str, sizeof(str), "%s", dir);
+    len = strlen(str);
+    for(i = 0; i < len; i++) {
+        if(str[i] == '/' || str[i] == '\\') {
+            str[i] = '\0';
+            if(_access(str, 0) != 0) {
+                error = _mkdir(str);
+                if(error != 0) {
+                    return error;
+                }
+            }
+            str[i] = '/';
+        }
+    }
+    if(len > 0 && _access(str, 0) != 0) {
+        error = _mkdir(str);
+    }
+    return error;
+#else
+    // Use snprintf to ensure the string is copied securely
+    snprintf(str, sizeof(str), "%s", dir);
+    len = strlen(str);
+    umask(0000);
+    for(i = 0; i < len; i++) {
+        if(i > 0 && str[i] == '/') {
+            str[i] = '\0';
+            if(access(str, 0) != 0) {
+                error = mkdir(str, 0755);
+                if(error != 0) {
+                    return error;
+                }
+            }
+            str[i] = '/';
+        }
+    }
+    if(len > 0 && access(str, 0) != 0) {
+        error = mkdir(str, 0755);
+    }
+    return error;
+#endif
+}
+
+std::string getCurrentWorkDirectory() {
+#ifdef WIN32
+    const DWORD size = GetCurrentDirectoryA(0, nullptr);
+    std::string pathStr;
+    pathStr.resize(size - 1);
+    GetCurrentDirectoryA(size, &pathStr[0]);
+    return pathStr;
+#else
+    char cwd[PATH_MAX] = {};
+    if(getcwd(cwd, sizeof(cwd)) != nullptr) {
+        return cwd;
+    }
+    else {
+        perror("getcwd() error");
+        return "";
+    }
+#endif
+}
+
+std::string joinPaths(const std::string &parent, const std::string &fileName) {
+    char separator = '/';
+#ifdef WIN32
+    separator = '\\';
+#endif
+    std::string rst = parent;
+    if(!parent.empty() && parent.back() != separator) {
+        rst += separator;
+    }
+
+    return rst + fileName;
+}
+
+std::vector<uint8_t> readFile(const std::string &filePath) {
+    auto pFile = fopen(filePath.c_str(), "rb");
+    if(nullptr == pFile) {
+        LOG_WARN("open file failed. filePath: {}", filePath);
+        return {};
+    }
+
+    // obtain file size:
+    fseek(pFile, 0, SEEK_END);
+    auto lSize = ftell(pFile);
+    rewind(pFile);
+
+    if(lSize <= 0) {
+        fclose(pFile);
+        return {};
+    }
+
+    std::vector<uint8_t> data(lSize);
+    auto                 result = fread(data.data(), 1, lSize, pFile);
+
+    if(result != static_cast<size_t>(lSize)) {
+        int errCode = ferror(pFile);
+        if(0 != errCode) {
+            LOG_WARN("Read file failed. filePath: {}, errorCode: {}", filePath, errCode);
+            fclose(pFile);
+            return {};
+        }
+    }
+
+    fclose(pFile);
+    return data;
+}
+
+void forEachFileInDirectory(const std::string &directory, const std::function<void(const std::string &)> &callback) {
+#ifdef WIN32
+    std::wstring_convert<std::codecvt_utf8<wchar_t>> converter;
+    std::wstring                                     wdir = converter.from_bytes(directory);
+    WIN32_FIND_DATAW                                 findData;
+    HANDLE                                           hFind = FindFirstFileW((wdir + L"\\*").c_str(), &findData);
+    if(hFind == INVALID_HANDLE_VALUE) {
+        return;
+    }
+    do {
+        if(findData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
+            continue;
+        }
+        else {
+            std::string fileName = converter.to_bytes(findData.cFileName);
+            callback(fileName);
+        }
+    } while(FindNextFileW(hFind, &findData));
+    FindClose(hFind);
+#else
+    DIR           *dir;
+    struct dirent *ent;
+    dir = opendir(directory.c_str());
+    if(dir != nullptr) {
+        while((ent = readdir(dir)) != nullptr) {
+            if(ent->d_type == DT_REG) {
+                callback(ent->d_name);
+            }
+        }
+        closedir(dir);
+    }
+#endif
+}
+
+void forEachSubDirInDirectory(const std::string &directory, const std::function<void(const std::string &)> &callback) {
+#ifdef WIN32
+    std::wstring_convert<std::codecvt_utf8<wchar_t>> converter;
+    std::wstring                                     wdir = converter.from_bytes(directory);
+    WIN32_FIND_DATAW                                 findData;
+    HANDLE                                           hFind = FindFirstFileW((wdir + L"\\*").c_str(), &findData);
+    if(hFind == INVALID_HANDLE_VALUE) {
+        return;
+    }
+    do {
+        if(findData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
+            if(wcscmp(findData.cFileName, L".") != 0 && wcscmp(findData.cFileName, L"..") != 0) {
+                std::string subDir = converter.to_bytes(findData.cFileName);
+                callback(subDir);
+            }
+        }
+    } while(FindNextFileW(hFind, &findData));
+    FindClose(hFind);
+#else
+    DIR           *dir;
+    struct dirent *ent;
+    if((dir = opendir(directory.c_str())) != nullptr) {
+        while((ent = readdir(dir)) != NULL) {
+            if(ent->d_type == DT_DIR) {
+                if(strcmp(ent->d_name, ".") != 0 && strcmp(ent->d_name, "..") != 0) {
+                    callback(ent->d_name);
+                }
+            }
+        }
+        closedir(dir);
+    }
+#endif
+}
+
+std::string removeExtensionOfFileName(const std::string &fileName) {
+    size_t pos = fileName.find_last_of(".");
+    if(pos == std::string::npos) {
+        return fileName;
+    }
+    return fileName.substr(0, pos);
+}
+
+}  // namespace utils
+}  // namespace libobsensor
+
diff --git a/src/shared/utils/FileUtils.hpp b/src/shared/utils/FileUtils.hpp
new file mode 100644
index 00000000..838ead05
--- /dev/null
+++ b/src/shared/utils/FileUtils.hpp
@@ -0,0 +1,26 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include <string>
+#include <functional>
+#include <vector>
+#include <cstdint>
+
+namespace libobsensor {
+namespace utils {
+bool        fileExists(const char *file);
+bool        checkDir(const char *dir);
+int         mkDirs(const char *dir);
+std::string getCurrentWorkDirectory();
+std::string joinPaths(const std::string &parent, const std::string &fileName);
+std::vector<uint8_t> readFile(const std::string &filePath);
+void forEachFileInDirectory(const std::string &directory, const std::function<void(const std::string &)> &callback);
+void forEachSubDirInDirectory(const std::string &directory, const std::function<void(const std::string &)> &callback);
+std::string removeExtensionOfFileName(const std::string &fileName);
+
+std::string makeRealPath(const std::string &path);
+
+}  // namespace utils
+}  // namespace libobsensor
+
diff --git a/src/shared/utils/PublicTypeHelper.cpp b/src/shared/utils/PublicTypeHelper.cpp
new file mode 100644
index 00000000..5d34eb7b
--- /dev/null
+++ b/src/shared/utils/PublicTypeHelper.cpp
@@ -0,0 +1,675 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "PublicTypeHelper.hpp"
+#include "exception/ObException.hpp"
+
+#include <map>
+#include <algorithm>
+
+namespace libobsensor {
+namespace utils {
+
+float getBytesPerPixel(OBFormat format) {
+    float bytesPerPixel = 0.f;
+    switch(format) {
+    case OB_FORMAT_Y8:
+    case OB_FORMAT_BA81:
+        bytesPerPixel = 1.f;
+        break;
+    case OB_FORMAT_Y10:
+        bytesPerPixel = 10.f / 8.f;
+        break;
+    case OB_FORMAT_Y11:
+        bytesPerPixel = 11.f / 8.f;
+        break;
+    case OB_FORMAT_Y12:
+    case OB_FORMAT_NV12:
+    case OB_FORMAT_YV12:
+        bytesPerPixel = 12.f / 8.f;
+        break;
+    case OB_FORMAT_Y14:
+        bytesPerPixel = 14.f / 8.f;
+        break;
+    case OB_FORMAT_NV21:
+    case OB_FORMAT_I420:
+        bytesPerPixel = 1.5f;
+        break;
+    case OB_FORMAT_Y16:
+    case OB_FORMAT_Z16:
+    case OB_FORMAT_YUYV:
+    case OB_FORMAT_UYVY:
+    case OB_FORMAT_BYR2:
+    case OB_FORMAT_RW16:
+        bytesPerPixel = 2.f;
+        break;
+    case OB_FORMAT_RGB:
+    case OB_FORMAT_BGR:
+        bytesPerPixel = 3.f;
+        break;
+    case OB_FORMAT_RGBA:
+    case OB_FORMAT_BGRA:
+        bytesPerPixel = 4.f;
+        break;
+    case OB_FORMAT_POINT:
+        bytesPerPixel = 12.f;
+        break;
+    case OB_FORMAT_RGB_POINT:
+        bytesPerPixel = 24.f;
+        break;
+    default:
+        throw invalid_value_exception("Unsupported image format or invalid encoding detected. Unable to determine the byte-per-pixel value.");
+        break;
+    }
+
+    return bytesPerPixel;
+}
+
+uint32_t calcDefaultStrideBytes(OBFormat format, uint32_t width) {
+    float bytesPerPixel = 1;
+
+    switch(format) {
+    case OB_FORMAT_MJPG:
+    case OB_FORMAT_H264:
+    case OB_FORMAT_H265:
+    case OB_FORMAT_HEVC:
+        bytesPerPixel = 1;
+        break;
+    case OB_FORMAT_RLE:
+    case OB_FORMAT_RVL:
+        bytesPerPixel = 2;
+        break;
+    default:  // assume planar format
+        bytesPerPixel = getBytesPerPixel(format);
+        break;
+    }
+
+    uint32_t stride        = (uint32_t)(width * bytesPerPixel + 0.5);
+    return stride;
+}
+
+uint32_t calcVideoFrameMaxDataSize(OBFormat format, uint32_t width, uint32_t height) {
+    uint32_t maxFrameDataSize = height * width * 3;
+    switch(format) {
+    case OB_FORMAT_MJPG:
+        maxFrameDataSize = height * width * 2;
+        break;
+    case OB_FORMAT_H264:
+    case OB_FORMAT_H265:
+    case OB_FORMAT_HEVC:
+        maxFrameDataSize = height * width;
+        break;
+    case OB_FORMAT_RLE:
+    case OB_FORMAT_RVL:
+        maxFrameDataSize = height * width * 2;
+        break;
+    default:  // assume planar format
+        maxFrameDataSize = height * calcDefaultStrideBytes(format, width);
+        break;
+    }
+    return maxFrameDataSize;
+}
+
+OBFrameType mapStreamTypeToFrameType(OBStreamType type) {
+    switch(type) {
+    case OB_STREAM_VIDEO:
+        return OB_FRAME_VIDEO;
+    case OB_STREAM_IR:
+        return OB_FRAME_IR;
+    case OB_STREAM_COLOR:
+        return OB_FRAME_COLOR;
+    case OB_STREAM_DEPTH:
+        return OB_FRAME_DEPTH;
+    case OB_STREAM_ACCEL:
+        return OB_FRAME_ACCEL;
+    case OB_STREAM_GYRO:
+        return OB_FRAME_GYRO;
+    case OB_STREAM_IR_LEFT:
+        return OB_FRAME_IR_LEFT;
+    case OB_STREAM_IR_RIGHT:
+        return OB_FRAME_IR_RIGHT;
+    case OB_STREAM_RAW_PHASE:
+        return OB_FRAME_RAW_PHASE;
+    default:
+        break;
+    }
+    return OB_FRAME_UNKNOWN;
+}
+
+OBStreamType mapFrameTypeToStreamType(OBFrameType type) {
+    switch(type) {
+    case OB_FRAME_VIDEO:
+        return OB_STREAM_VIDEO;
+    case OB_FRAME_IR:
+        return OB_STREAM_IR;
+    case OB_FRAME_COLOR:
+        return OB_STREAM_COLOR;
+    case OB_FRAME_DEPTH:
+        return OB_STREAM_DEPTH;
+    case OB_FRAME_ACCEL:
+        return OB_STREAM_ACCEL;
+    case OB_FRAME_GYRO:
+        return OB_STREAM_GYRO;
+    case OB_FRAME_IR_LEFT:
+        return OB_STREAM_IR_LEFT;
+    case OB_FRAME_IR_RIGHT:
+        return OB_STREAM_IR_RIGHT;
+    case OB_FRAME_RAW_PHASE:
+        return OB_STREAM_RAW_PHASE;
+    default:
+        break;
+    }
+    return OB_STREAM_UNKNOWN;
+}
+
+OBStreamType mapSensorTypeToStreamType(OBSensorType type) {
+    switch(type) {
+    case OB_SENSOR_IR:
+        return OB_STREAM_IR;
+    case OB_SENSOR_COLOR:
+        return OB_STREAM_COLOR;
+    case OB_SENSOR_DEPTH:
+        return OB_STREAM_DEPTH;
+    case OB_SENSOR_ACCEL:
+        return OB_STREAM_ACCEL;
+    case OB_SENSOR_GYRO:
+        return OB_STREAM_GYRO;
+    case OB_SENSOR_IR_LEFT:
+        return OB_STREAM_IR_LEFT;
+    case OB_SENSOR_IR_RIGHT:
+        return OB_STREAM_IR_RIGHT;
+    case OB_SENSOR_RAW_PHASE:
+        return OB_STREAM_RAW_PHASE;
+    default:
+        break;
+    }
+    return OB_STREAM_UNKNOWN;
+}
+
+OBSensorType mapStreamTypeToSensorType(OBStreamType type) {
+    switch(type) {
+    case OB_STREAM_IR:
+        return OB_SENSOR_IR;
+    case OB_STREAM_COLOR:
+        return OB_SENSOR_COLOR;
+    case OB_STREAM_DEPTH:
+        return OB_SENSOR_DEPTH;
+    case OB_STREAM_ACCEL:
+        return OB_SENSOR_ACCEL;
+    case OB_STREAM_GYRO:
+        return OB_SENSOR_GYRO;
+    case OB_STREAM_IR_LEFT:
+        return OB_SENSOR_IR_LEFT;
+    case OB_STREAM_IR_RIGHT:
+        return OB_SENSOR_IR_RIGHT;
+    case OB_STREAM_RAW_PHASE:
+        return OB_SENSOR_RAW_PHASE;
+    default:
+        break;
+    }
+    return OB_SENSOR_UNKNOWN;
+}
+
+const std::map<uint32_t, OBFormat> fourccToOBFormat = {
+    { fourCc2Int('U', 'Y', 'V', 'Y'), OB_FORMAT_UYVY }, { fourCc2Int('Y', 'U', 'Y', '2'), OB_FORMAT_YUYV }, { fourCc2Int('Y', 'U', 'Y', 'V'), OB_FORMAT_YUYV },
+    { fourCc2Int('N', 'V', '1', '2'), OB_FORMAT_NV12 }, { fourCc2Int('N', 'V', '2', '1'), OB_FORMAT_NV21 }, { fourCc2Int('M', 'J', 'P', 'G'), OB_FORMAT_MJPG },
+    { fourCc2Int('H', '2', '6', '4'), OB_FORMAT_H264 }, { fourCc2Int('H', '2', '6', '5'), OB_FORMAT_H265 }, { fourCc2Int('Y', '1', '2', ' '), OB_FORMAT_Y12 },
+    { fourCc2Int('Y', '1', '6', ' '), OB_FORMAT_Y16 },  { fourCc2Int('G', 'R', 'A', 'Y'), OB_FORMAT_GRAY }, { fourCc2Int('Y', '1', '1', ' '), OB_FORMAT_Y11 },
+    { fourCc2Int('Y', '8', ' ', ' '), OB_FORMAT_Y8 },   { fourCc2Int('Y', '1', '0', ' '), OB_FORMAT_Y10 },  { fourCc2Int('H', 'E', 'V', 'C'), OB_FORMAT_HEVC },
+    { fourCc2Int('Y', '1', '4', ' '), OB_FORMAT_Y14 },  { fourCc2Int('I', '4', '2', '0'), OB_FORMAT_I420 }, { fourCc2Int('Z', '1', '6', ' '), OB_FORMAT_Z16 },
+    { fourCc2Int('Y', 'V', '1', '2'), OB_FORMAT_YV12 }, { fourCc2Int('B', 'A', '8', '1'), OB_FORMAT_BA81 }, { fourCc2Int('B', 'Y', 'R', '2'), OB_FORMAT_BYR2 },
+    { fourCc2Int('R', 'W', '1', '6'), OB_FORMAT_RW16 },
+};
+
+OBFormat uvcFourccToOBFormat(uint32_t fourcc) {
+    auto it = fourccToOBFormat.find(fourcc);
+    if(it != fourccToOBFormat.end()) {
+        return it->second;
+    }
+    return OB_FORMAT_UNKNOWN;
+}
+
+uint32_t obFormatToUvcFourcc(OBFormat format) {
+    auto it = std::find_if(fourccToOBFormat.begin(), fourccToOBFormat.end(), [format](const std::pair<uint32_t, OBFormat> &p) { return p.second == format; });
+    if(it != fourccToOBFormat.end()) {
+        return it->first;
+    }
+    return 0;
+}
+
+float mapIMUSampleRateToValue(OBIMUSampleRate rate) {
+    switch(rate) {
+    case OB_SAMPLE_RATE_1_5625_HZ:
+        return 1.5625f;
+    case OB_SAMPLE_RATE_3_125_HZ:
+        return 3.125f;
+    case OB_SAMPLE_RATE_6_25_HZ:
+        return 6.25f;
+    case OB_SAMPLE_RATE_12_5_HZ:
+        return 12.5f;
+    case OB_SAMPLE_RATE_25_HZ:
+        return 25.f;
+    case OB_SAMPLE_RATE_50_HZ:
+        return 50.f;
+    case OB_SAMPLE_RATE_100_HZ:
+        return 100.f;
+    case OB_SAMPLE_RATE_200_HZ:
+        return 200.f;
+    case OB_SAMPLE_RATE_500_HZ:
+        return 500.f;
+    case OB_SAMPLE_RATE_1_KHZ:
+        return 1000.f;
+    case OB_SAMPLE_RATE_2_KHZ:
+        return 2000.f;
+    case OB_SAMPLE_RATE_4_KHZ:
+        return 4000.f;
+    case OB_SAMPLE_RATE_8_KHZ:
+        return 8000.f;
+    case OB_SAMPLE_RATE_16_KHZ:
+        return 16000.f;
+    case OB_SAMPLE_RATE_32_KHZ:
+        return 32000.f;
+    default:
+        return 0.f;
+    }
+}
+
+// type to string map
+const std::map<OBSensorType, std::string> Sensor_Str_Map = {
+    { OB_SENSOR_IR, "IR" },           { OB_SENSOR_COLOR, "Color" },    { OB_SENSOR_DEPTH, "Depth" },      { OB_SENSOR_ACCEL, "Accel" },
+    { OB_SENSOR_GYRO, "Gyro" },       { OB_SENSOR_IR_LEFT, "LeftIR" }, { OB_SENSOR_IR_RIGHT, "RightIR" }, { OB_SENSOR_RAW_PHASE, "RawPhase" },
+    { OB_SENSOR_UNKNOWN, "Unknown" },
+};
+
+const std::map<OBFrameType, std::string> Frame_Str_Map = { { OB_FRAME_UNKNOWN, "Unknown frame type" },
+                                                           { OB_FRAME_VIDEO, "Video" },
+                                                           { OB_FRAME_IR, "IR" },
+                                                           { OB_FRAME_COLOR, "Color" },
+                                                           { OB_FRAME_DEPTH, "Depth" },
+                                                           { OB_FRAME_ACCEL, "Accel" },
+                                                           { OB_FRAME_SET, "SET" },
+                                                           { OB_FRAME_POINTS, "Points" },
+                                                           { OB_FRAME_GYRO, "Gyro" },
+                                                           { OB_FRAME_IR_LEFT, "Left IR" },
+                                                           { OB_FRAME_IR_RIGHT, "Right IR" },
+                                                           { OB_FRAME_RAW_PHASE, "RawPhase" } };
+
+const std::map<OBStreamType, std::string> Stream_Str_Map = {
+    { OB_STREAM_UNKNOWN, "Unknown" },   { OB_STREAM_VIDEO, "Video" },       { OB_STREAM_IR, "IR" },     { OB_STREAM_COLOR, "Color" },
+    { OB_STREAM_DEPTH, "Depth" },       { OB_STREAM_ACCEL, "Accel" },       { OB_STREAM_GYRO, "Gyro" }, { OB_STREAM_IR_LEFT, "Left IR" },
+    { OB_STREAM_IR_RIGHT, "Right IR" }, { OB_STREAM_RAW_PHASE, "RawPhase" }
+};
+
+const std::map<OBIMUSampleRate, std::string> ImuRate_Str_Map = { { OB_SAMPLE_RATE_UNKNOWN, "UNKNOWN" },   { OB_SAMPLE_RATE_1_5625_HZ, "1_5625_HZ" },
+                                                                 { OB_SAMPLE_RATE_3_125_HZ, "3_125_HZ" }, { OB_SAMPLE_RATE_6_25_HZ, "6_25_HZ" },
+                                                                 { OB_SAMPLE_RATE_12_5_HZ, "12_5_HZ" },   { OB_SAMPLE_RATE_25_HZ, "25_HZ" },
+                                                                 { OB_SAMPLE_RATE_50_HZ, "50_HZ" },       { OB_SAMPLE_RATE_100_HZ, "100_HZ" },
+                                                                 { OB_SAMPLE_RATE_200_HZ, "200_HZ" },     { OB_SAMPLE_RATE_500_HZ, "500_HZ" },
+                                                                 { OB_SAMPLE_RATE_1_KHZ, "1_KHZ" },       { OB_SAMPLE_RATE_2_KHZ, "2_KHZ" },
+                                                                 { OB_SAMPLE_RATE_4_KHZ, "4_KHZ" },       { OB_SAMPLE_RATE_8_KHZ, "8_KHZ" },
+                                                                 { OB_SAMPLE_RATE_16_KHZ, "16_KHZ" },     { OB_SAMPLE_RATE_32_KHZ, "32_KHZ" } };
+
+const std::map<OBGyroFullScaleRange, std::string> GyroFullScaleRange_STR_MAP = { { OB_GYRO_FS_UNKNOWN, "Unknown" }, { OB_GYRO_FS_16dps, "16dps" },
+                                                                                 { OB_GYRO_FS_31dps, "31dps" },     { OB_GYRO_FS_62dps, "62dps" },
+                                                                                 { OB_GYRO_FS_125dps, "125dps" },   { OB_GYRO_FS_250dps, "250dps" },
+                                                                                 { OB_GYRO_FS_500dps, "500dps" },   { OB_GYRO_FS_1000dps, "1000dps" },
+                                                                                 { OB_GYRO_FS_2000dps, "2000dps" } };
+
+const std::map<OBAccelFullScaleRange, std::string> AccelFullScaleRange_Str_Map = {
+    { OB_ACCEL_FS_UNKNOWN, "Unknown" }, { OB_ACCEL_FS_2g, "2g" }, { OB_ACCEL_FS_4g, "4g" }, { OB_ACCEL_FS_8g, "8g" }, { OB_ACCEL_FS_16g, "16g" }
+};
+
+const std::map<OBFormat, std::string> Format_Str_Map = {
+    { OB_FORMAT_YUYV, "YUYV" },   { OB_FORMAT_YUY2, "YUY2" },
+    { OB_FORMAT_UYVY, "UYVY" },   { OB_FORMAT_NV12, "NV12" },
+    { OB_FORMAT_NV21, "NV21" },   { OB_FORMAT_MJPG, "MJPG" },
+    { OB_FORMAT_H264, "H264" },   { OB_FORMAT_H265, "H265" },
+    { OB_FORMAT_Y16, "Y16" },     { OB_FORMAT_Y8, "Y8" },
+    { OB_FORMAT_Y10, "Y10" },     { OB_FORMAT_Y11, "Y11" },
+    { OB_FORMAT_Y12, "Y12" },     { OB_FORMAT_GRAY, "GRAY" },
+    { OB_FORMAT_HEVC, "HEVC" },   { OB_FORMAT_I420, "I420" },
+    { OB_FORMAT_ACCEL, "ACCEL" }, { OB_FORMAT_GYRO, "GYRO" },
+    { OB_FORMAT_POINT, "POINT" }, { OB_FORMAT_RGB_POINT, "RGB_POINT" },
+    { OB_FORMAT_RLE, "RLE" },     { OB_FORMAT_RGB, "RGB" },
+    { OB_FORMAT_BGR, "BGR" },     { OB_FORMAT_Y14, "Y14" },
+    { OB_FORMAT_BGRA, "BGRA" },   { OB_FORMAT_COMPRESSED, "COMPRESSED" },
+    { OB_FORMAT_RVL, "RVL" },     { OB_FORMAT_Z16, "Z16" },
+    { OB_FORMAT_YV12, "YV12" },   { OB_FORMAT_BA81, "BA81" },
+    { OB_FORMAT_RGBA, "RGBA" },   { OB_FORMAT_BYR2, "BYR2" },
+    { OB_FORMAT_RW16, "RW16" },   { OB_FORMAT_UNKNOWN, "UNKNOWN" },
+};
+
+std::map<OBFrameMetadataType, std::string> Metadata_Str_Map = { { OB_FRAME_METADATA_TYPE_TIMESTAMP, "Timestamp" },
+                                                                { OB_FRAME_METADATA_TYPE_SENSOR_TIMESTAMP, "Sensor Timestamp" },
+                                                                { OB_FRAME_METADATA_TYPE_FRAME_NUMBER, "Frame Number" },
+                                                                { OB_FRAME_METADATA_TYPE_AUTO_EXPOSURE, "Auto Exposure" },
+                                                                { OB_FRAME_METADATA_TYPE_EXPOSURE, "Exposure" },
+                                                                { OB_FRAME_METADATA_TYPE_GAIN, "Gain" },
+                                                                { OB_FRAME_METADATA_TYPE_AUTO_WHITE_BALANCE, "Auto White Balance" },
+                                                                { OB_FRAME_METADATA_TYPE_WHITE_BALANCE, "White Balance" },
+                                                                { OB_FRAME_METADATA_TYPE_BRIGHTNESS, "Brightness" },
+                                                                { OB_FRAME_METADATA_TYPE_CONTRAST, "Contrast" },
+                                                                { OB_FRAME_METADATA_TYPE_SATURATION, "Saturation" },
+                                                                { OB_FRAME_METADATA_TYPE_SHARPNESS, "Sharpness" },
+                                                                { OB_FRAME_METADATA_TYPE_BACKLIGHT_COMPENSATION, "Backlight Compensation" },
+                                                                { OB_FRAME_METADATA_TYPE_HUE, "Hue" },
+                                                                { OB_FRAME_METADATA_TYPE_GAMMA, "Gamma" },
+                                                                { OB_FRAME_METADATA_TYPE_POWER_LINE_FREQUENCY, "Power Line Frequency" },
+                                                                { OB_FRAME_METADATA_TYPE_LOW_LIGHT_COMPENSATION, "Low Light Compensation" },
+                                                                { OB_FRAME_METADATA_TYPE_MANUAL_WHITE_BALANCE, "Manual White Balance" },
+                                                                { OB_FRAME_METADATA_TYPE_ACTUAL_FRAME_RATE, "Actual Frame Rate" },
+                                                                { OB_FRAME_METADATA_TYPE_FRAME_RATE, "Frame Rate" },
+                                                                { OB_FRAME_METADATA_TYPE_AE_ROI_LEFT, "AE ROI Left" },
+                                                                { OB_FRAME_METADATA_TYPE_AE_ROI_TOP, "AE ROI Top" },
+                                                                { OB_FRAME_METADATA_TYPE_AE_ROI_RIGHT, "AE ROI Right" },
+                                                                { OB_FRAME_METADATA_TYPE_AE_ROI_BOTTOM, "AE ROI Bottom" },
+                                                                { OB_FRAME_METADATA_TYPE_EXPOSURE_PRIORITY, "Exposure Priority" },
+                                                                { OB_FRAME_METADATA_TYPE_HDR_SEQUENCE_NAME, "HDR Sequence Name" },
+                                                                { OB_FRAME_METADATA_TYPE_HDR_SEQUENCE_SIZE, "HDR Sequence Size" },
+                                                                { OB_FRAME_METADATA_TYPE_HDR_SEQUENCE_INDEX, "HDR Sequence Index" },
+                                                                { OB_FRAME_METADATA_TYPE_LASER_POWER, "Laser Power" },
+                                                                { OB_FRAME_METADATA_TYPE_LASER_POWER_LEVEL, "Laser Power Level" },
+                                                                { OB_FRAME_METADATA_TYPE_LASER_STATUS, "Laser Status" },
+                                                                { OB_FRAME_METADATA_TYPE_GPIO_INPUT_DATA, "GPIO Input Data" } };
+
+// type to string
+const std::string &obFormatToStr(OBFormat type) {
+    auto it = Format_Str_Map.find(type);
+    if(it == Format_Str_Map.end()) {
+        throw invalid_value_exception("Unregistered stream type");
+    }
+    return it->second;
+}
+
+const std::string &obFrameToStr(OBFrameType type) {
+    auto it = Frame_Str_Map.find(type);
+    if(it == Frame_Str_Map.end()) {
+        throw invalid_value_exception("Unregistered frame type");
+    }
+    return it->second;
+}
+
+const std::string &obStreamToStr(OBStreamType type) {
+    auto it = Stream_Str_Map.find(type);
+    if(it == Stream_Str_Map.end()) {
+        throw invalid_value_exception("Unregistered stream type");
+    }
+    return it->second;
+}
+
+const std::string &obSensorToStr(OBSensorType type) {
+    auto it = Sensor_Str_Map.find(type);
+    if(it == Sensor_Str_Map.end()) {
+        throw invalid_value_exception("Unregistered sensor type");
+    }
+    return it->second;
+}
+
+const std::string &obImuRateToStr(OBIMUSampleRate type) {
+    auto it = ImuRate_Str_Map.find(type);
+    if(it == ImuRate_Str_Map.end()) {
+        throw invalid_value_exception("Unregistered imu rate type");
+    }
+    return it->second;
+}
+
+const std::string &GyroFullScaleRangeToStr(OBGyroFullScaleRange type) {
+    auto it = GyroFullScaleRange_STR_MAP.find(type);
+    if(it == GyroFullScaleRange_STR_MAP.end()) {
+        throw invalid_value_exception("Unregistered gyro full scale range name");
+    }
+    return it->second;
+}
+
+const std::string &AccelFullScaleRangeToStr(OBAccelFullScaleRange type) {
+    auto it = AccelFullScaleRange_Str_Map.find(type);
+    if(it == AccelFullScaleRange_Str_Map.end()) {
+        throw invalid_value_exception("Unregistered acc full scale range name");
+    }
+    return it->second;
+}
+
+const std::string &MetaDataToStr(OBFrameMetadataType type) {
+    auto it = Metadata_Str_Map.find(type);
+    if(it == Metadata_Str_Map.end()) {
+        throw invalid_value_exception("Unregistered metadata name");
+    }
+    return it->second;
+}
+
+// string to type
+OBFormat strToOBFormat(const std::string str) {
+    for(auto it = Format_Str_Map.begin(); it != Format_Str_Map.end(); ++it) {
+        if(it->second == str) {
+            return it->first;
+        }
+    }
+    throw invalid_value_exception("Unregistered format type");
+}
+
+OBFrameType strToOBFrame(const std::string str) {
+    for(auto it = Frame_Str_Map.begin(); it != Frame_Str_Map.end(); ++it) {
+        if(it->second == str) {
+            return it->first;
+        }
+    }
+    throw invalid_value_exception("Unregistered frame type");
+}
+
+OBStreamType strToOBStream(const std::string str) {
+    for(auto it = Stream_Str_Map.begin(); it != Stream_Str_Map.end(); ++it) {
+        if(it->second == str) {
+            return it->first;
+        }
+    }
+    throw invalid_value_exception("Unregistered stream type");
+}
+
+OBSensorType strToOBSensor(const std::string str) {
+    for(auto it = Sensor_Str_Map.begin(); it != Sensor_Str_Map.end(); ++it) {
+        if(it->second == str) {
+            return it->first;
+        }
+    }
+    throw invalid_value_exception("Unregistered sensor type");
+}
+
+OBIMUSampleRate strToObImuRate(const std::string str) {
+    for(auto it = ImuRate_Str_Map.begin(); it != ImuRate_Str_Map.end(); ++it) {
+        if(it->second == str) {
+            return it->first;
+        }
+    }
+    throw invalid_value_exception("Unregistered Imu rate type");
+}
+
+OBGyroFullScaleRange strToGyroFullScaleRange(const std::string str) {
+    for(auto it = GyroFullScaleRange_STR_MAP.begin(); it != GyroFullScaleRange_STR_MAP.end(); ++it) {
+        if(it->second == str) {
+            return it->first;
+        }
+    }
+    throw invalid_value_exception("Unregistered gyro full scale range type");
+}
+
+OBAccelFullScaleRange strToAccelFullScaleRange(const std::string str) {
+    for(auto it = AccelFullScaleRange_Str_Map.begin(); it != AccelFullScaleRange_Str_Map.end(); ++it) {
+        if(it->second == str) {
+            return it->first;
+        }
+    }
+    throw invalid_value_exception("Unregistered accel full scale range type");
+}
+
+float depthPrecisionLevelToUnit(OBDepthPrecisionLevel precision) {
+    switch(precision) {
+    case OB_PRECISION_1MM:
+        return 1.0f;
+    case OB_PRECISION_0MM8:
+        return 0.8f;
+    case OB_PRECISION_0MM4:
+        return 0.4f;
+    case OB_PRECISION_0MM1:
+        return 0.1f;
+    case OB_PRECISION_0MM2:
+        return 0.2f;
+    case OB_PRECISION_0MM5:
+        return 0.5f;
+    case OB_PRECISION_0MM05:
+        return 0.05f;
+    default:
+        break;
+    }
+    throw invalid_value_exception("Unregistered depth precision level");
+}
+
+bool areAlmostEqual(float a, float b, float epsilon = 1e-5f) {
+    return std::abs(a - b) < epsilon;
+}
+OBDepthPrecisionLevel depthUnitToPrecisionLevel(float unit) {
+    if(areAlmostEqual(1.0f, unit)) {
+        return OB_PRECISION_1MM;
+    }
+    else if(areAlmostEqual(0.8f, unit)) {
+        return OB_PRECISION_0MM8;
+    }
+    else if(areAlmostEqual(0.4f, unit)) {
+        return OB_PRECISION_0MM4;
+    }
+    else if(areAlmostEqual(0.1f, unit)) {
+        return OB_PRECISION_0MM1;
+    }
+    else if(areAlmostEqual(0.2f, unit)) {
+        return OB_PRECISION_0MM2;
+    }
+    else if(areAlmostEqual(0.5f, unit)) {
+        return OB_PRECISION_0MM5;
+    }
+    else if(areAlmostEqual(0.05f, unit)) {
+        return OB_PRECISION_0MM05;
+    }
+    throw invalid_value_exception("Unsupported unit to depth precision level");
+}
+
+}  // namespace utils
+}  // namespace libobsensor
+
+std::ostream &operator<<(std::ostream &os, const OBFormat &type) {
+    os << libobsensor::utils::obFormatToStr(type);
+    return os;
+}
+
+std::ostream &operator<<(std::ostream &os, const OBFrameType &type) {
+    os << libobsensor::utils::obFrameToStr(type);
+    return os;
+}
+
+std::ostream &operator<<(std::ostream &os, const OBStreamType &type) {
+    os << libobsensor::utils::obStreamToStr(type);
+    return os;
+}
+
+std::ostream &operator<<(std::ostream &os, const OBSensorType &type) {
+    os << libobsensor::utils::obSensorToStr(type);
+    return os;
+}
+
+std::ostream &operator<<(std::ostream &os, const OBIMUSampleRate &type) {
+    os << libobsensor::utils::obImuRateToStr(type);
+    return os;
+}
+
+std::ostream &operator<<(std::ostream &os, const OBGyroFullScaleRange &type) {
+    os << libobsensor::utils::GyroFullScaleRangeToStr(type);
+    return os;
+}
+
+std::ostream &operator<<(std::ostream &os, const OBAccelFullScaleRange &type) {
+    os << libobsensor::utils::AccelFullScaleRangeToStr(type);
+    return os;
+}
+
+std::ostream &operator<<(std::ostream &os, const OBCameraParam &params) {
+    os << "{\n"
+       << "depthIntrinsic:{ fx:" << params.depthIntrinsic.fx << ",fy:" << params.depthIntrinsic.fy << ",cx:" << params.depthIntrinsic.cx
+       << ",cy:" << params.depthIntrinsic.cy << ",width:" << params.depthIntrinsic.width << ",height:" << params.depthIntrinsic.height << "}\n"
+       << "rgbIntrinsic:{ fx:" << params.rgbIntrinsic.fx << ",fy:" << params.rgbIntrinsic.fy << ",cx:" << params.rgbIntrinsic.cx
+       << ",cy:" << params.rgbIntrinsic.cy << ",width:" << params.rgbIntrinsic.width << ",height:" << params.rgbIntrinsic.height << "}\n"
+       << "depthDistortion:{ model:" << params.depthDistortion.model << ",k1:" << params.depthDistortion.k1 << ",k2:" << params.depthDistortion.k2
+       << ",k3:" << params.depthDistortion.k3 << ",k4:" << params.depthDistortion.k4 << ",k5:" << params.depthDistortion.k5
+       << ",k6:" << params.depthDistortion.k6 << ",p1:" << params.depthDistortion.p1 << ",p2:" << params.depthDistortion.p2 << "}\n"
+       << "rgbDistortion:{ model:" << params.rgbDistortion.model << ",k1:" << params.rgbDistortion.k1 << ",k2:" << params.rgbDistortion.k2
+       << ",k3:" << params.rgbDistortion.k3 << ",k4:" << params.rgbDistortion.k4 << ",k5:" << params.rgbDistortion.k5 << ",k6:" << params.rgbDistortion.k6
+       << ",p1:" << params.rgbDistortion.p1 << ",p2:" << params.rgbDistortion.p2 << "}\n"
+       << "transform: rot:[" << params.transform.rot[0] << "," << params.transform.rot[1] << "," << params.transform.rot[2] << "," << params.transform.rot[3]
+       << "," << params.transform.rot[4] << "," << params.transform.rot[5] << "," << params.transform.rot[6] << "," << params.transform.rot[7] << ","
+       << params.transform.rot[8] << "],trans:" << params.transform.trans[0] << "," << params.transform.trans[1] << "," << params.transform.trans[2] << "}\n"
+       << "isMirror:" << params.isMirrored << "\n"
+       << "}";
+    return os;
+}
+
+std::ostream &operator<<(std::ostream &os, const OBCalibrationParam &type) {    
+     os << "{\n"
+        << "intrinsics:[ { cx:" << type.intrinsics[0].cx << ", cy" << type.intrinsics[0].cy << ", fx" << type.intrinsics[0].fx << ", fy" << type.intrinsics[0].fy << ", width" << type.intrinsics[0].width << ", height" << type.intrinsics[0].height << "},\n"
+        << " { cx:" << type.intrinsics[1].cx << ", cy" << type.intrinsics[1].cy << ", fx" << type.intrinsics[1].fx << ", fy" << type.intrinsics[1].fy << ", width" << type.intrinsics[1].width << ", height" << type.intrinsics[1].height << "},\n"
+        << " { cx:" << type.intrinsics[2].cx << ", cy" << type.intrinsics[2].cy << ", fx" << type.intrinsics[2].fx << ", fy" << type.intrinsics[2].fy << ", width" << type.intrinsics[2].width << ", height" << type.intrinsics[2].height << "},\n"
+        << " { cx:" << type.intrinsics[3].cx << ", cy" << type.intrinsics[3].cy << ", fx" << type.intrinsics[3].fx << ", fy" << type.intrinsics[3].fy << ", width" << type.intrinsics[3].width << ", height" << type.intrinsics[3].height << "},\n"
+        << " { cx:" << type.intrinsics[4].cx << ", cy" << type.intrinsics[4].cx << ", fx" << type.intrinsics[4].fx << ", fy" << type.intrinsics[4].fy << ", width" << type.intrinsics[4].width << ", height" << type.intrinsics[4].height << "},\n"
+        << " { cx:" << type.intrinsics[5].cx << ", cy" << type.intrinsics[5].cy << ", fx" << type.intrinsics[5].fx << ", fy" << type.intrinsics[5].fy << ", width" << type.intrinsics[5].width << ", height" << type.intrinsics[5].height << "},\n"
+        << " { cx:" << type.intrinsics[6].cx << ", cy" << type.intrinsics[6].cy << ", fx" << type.intrinsics[6].fx << ", fy" << type.intrinsics[6].fy << ", width" << type.intrinsics[6].width << ", height" << type.intrinsics[6].height << "},\n"
+        << " { cx:" << type.intrinsics[7].cx << ", cy" << type.intrinsics[7].cy << ", fx" << type.intrinsics[7].fx << ", fy" << type.intrinsics[7].fy << ", width" << type.intrinsics[7].width << ", height" << type.intrinsics[7].height << "},\n"
+        << " { cx:" << type.intrinsics[8].cx << ", cy" << type.intrinsics[8].cy << ", fx" << type.intrinsics[8].fx << ", fy" << type.intrinsics[8].fy << ", width" << type.intrinsics[8].width << ", height" << type.intrinsics[8].height << "},\n"
+        << "]\n"
+        << "distortion:[ { model:" << type.distortion[0].model << ", k1:" << type.distortion[0].k1 << ", k2:" << type.distortion[0].k2 << ", k3:" << type.distortion[0].k3 << ", k4:" << type.distortion[0].k4 << ", k5:" << type.distortion[0].k5 << ", k6:" << type.distortion[0].k6 << ", p1:" << type.distortion[0].p1 << ", p2:" << type.distortion[0].p2 << "},\n"
+        << " { model:" << type.distortion[1].model << ", k1:" << type.distortion[1].k1 << ", k2:" << type.distortion[1].k2 << ", k3:" << type.distortion[1].k3 << ", k4:" << type.distortion[1].k4 << ", k5:" << type.distortion[1].k5 << ", k6:" << type.distortion[1].k6 << ", p1:" << type.distortion[1].p1 << ", p2:" << type.distortion[1].p2 << "},\n"
+        << " { model:" << type.distortion[2].model << ", k1:" << type.distortion[2].k1 << ", k2:" << type.distortion[2].k2 << ", k3:" << type.distortion[2].k3 << ", k4:" << type.distortion[2].k4 << ", k5:" << type.distortion[2].k5 << ", k6:" << type.distortion[2].k6 << ", p1:" << type.distortion[2].p1 << ", p2:" << type.distortion[2].p2 << "},\n"
+        << " { model:" << type.distortion[3].model << ", k1:" << type.distortion[3].k1 << ", k2:" << type.distortion[3].k2 << ", k3:" << type.distortion[3].k3 << ", k4:" << type.distortion[3].k4 << ", k5:" << type.distortion[3].k5 << ", k6:" << type.distortion[3].k6 << ", p1:" << type.distortion[3].p1 << ", p2:" << type.distortion[3].p2 << "},\n"
+        << " { model:" << type.distortion[4].model << ", k1:" << type.distortion[4].k1 << ", k2:" << type.distortion[4].k2 << ", k3:" << type.distortion[4].k3 << ", k4:" << type.distortion[4].k4 << ", k5:" << type.distortion[4].k5 << ", k6:" << type.distortion[4].k6 << ", p1:" << type.distortion[4].p1 << ", p2:" << type.distortion[4].p2 << "},\n"
+        << " { model:" << type.distortion[5].model << ", k1:" << type.distortion[5].k1 << ", k2:" << type.distortion[5].k2 << ", k3:" << type.distortion[5].k3 << ", k4:" << type.distortion[5].k4 << ", k5:" << type.distortion[5].k5 << ", k6:" << type.distortion[5].k6 << ", p1:" << type.distortion[5].p1 << ", p2:" << type.distortion[5].p2<<  "},\n"
+        << " { model:" << type.distortion[6].model << ", k1:" << type.distortion[6].k1 << ", k2:" << type.distortion[6].k2 << ", k3:" << type.distortion[6].k3 << ", k4:" << type.distortion[6].k4 << ", k5:" << type.distortion[6].k5 << ", k6:" << type.distortion[6].k6 << ", p1:" << type.distortion[6].p1 << ", p2:" << type.distortion[6].p2 << "},\n"
+        << " { model:" << type.distortion[7].model << ", k1:" << type.distortion[7].k1 << ", k2:" << type.distortion[7].k2 << ", k3:" << type.distortion[7].k3 << ", k4:" << type.distortion[7].k4 << ", k5:" << type.distortion[7].k5 << ", k6:" << type.distortion[7].k6 << ", p1:" << type.distortion[7].p1 << ", p2:" << type.distortion[7].p2 << "},\n"
+        << " { model:" << type.distortion[8].model << ", k1:" << type.distortion[8].k1 << ", k2:" << type.distortion[8].k2 << ", k3:" << type.distortion[8].k3 << ", k4:" << type.distortion[8].k4 << ", k5:" << type.distortion[8].k5 << ", k6:" << type.distortion[8].k6 << ", p1:" << type.distortion[8].p1 << ", p2:" << type.distortion[8].p2 << "},\n"    
+        << "]\n"
+        << "extrinsics:[ ]\n"
+        << "}\n";
+
+    return os;
+}
+
+std::ostream &operator<<(std::ostream &os, const OBPoint3f &type) {    
+    os << "{\n"
+       << "x:" << type.x << ", y:" << type.y << ", z:" << type.z << "\n"
+       << "}\n";
+    return os;
+}
+
+std::ostream &operator<<(std::ostream &os, const OBExtrinsic &type) {    
+    os << "{\n"
+       << "rot:[ " << type.rot[0] << ", " << type.rot[1] << ", " << type.rot[2] << ", " << type.rot[3] << ", " << type.rot[4] << ", " << type.rot[5] << ", " << type.rot[6] << ", " << type.rot[7] << ", " << type.rot[8] << "]\n"
+       << "trans:[ " << type.trans[0] << ", " << type.trans[1] << ", " << type.trans[2] << "]\n"
+       << "}\n";
+    return os;
+}
+
+std::ostream &operator<<(std::ostream &os, const OBPoint2f &type) {    
+    os << "{\n"
+       << "x:" << type.x << ", y:" << type.y << "\n"
+       << "}\n";
+    return os;
+}
+
+std::ostream &operator<<(std::ostream &os, const OBCameraIntrinsic &type) {    
+    os << "{\n"
+       << "cx:" << type.cx << ", cy:" << type.cy << ", fx:" << type.fx << ", fy:" << type.fy << ", width:" << type.width << ", height:" << type.height << "\n"
+       << "}\n";
+    return os;
+}
+
+std::ostream &operator<<(std::ostream &os, const OBCameraDistortion &type) {    
+    os << "{\n"
+       << "model:" << type.model << ", k1:" << type.k1 << ", k2:" << type.k2 << ", k3:" << type.k3 << ", k4:" << type.k4 << ", k5:" << type.k5 << ", k6:" << type.k6 << ", p1:" << type.p1 << ", p2:" << type.p2 << "\n"
+       << "}\n";
+    return os;
+}
+
diff --git a/src/shared/utils/PublicTypeHelper.hpp b/src/shared/utils/PublicTypeHelper.hpp
new file mode 100644
index 00000000..404b3e44
--- /dev/null
+++ b/src/shared/utils/PublicTypeHelper.hpp
@@ -0,0 +1,67 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include "libobsensor/h/ObTypes.h"
+#include <iostream>
+
+namespace libobsensor {
+namespace utils {
+float    getBytesPerPixel(OBFormat format);
+uint32_t calcDefaultStrideBytes(OBFormat format, uint32_t width);
+uint32_t calcVideoFrameMaxDataSize(OBFormat format, uint32_t width, uint32_t height);
+
+OBFrameType  mapStreamTypeToFrameType(OBStreamType type);
+OBStreamType mapFrameTypeToStreamType(OBFrameType type);
+OBStreamType mapSensorTypeToStreamType(OBSensorType type);
+OBSensorType mapStreamTypeToSensorType(OBStreamType type);
+
+template <typename T> uint32_t fourCc2Int(const T a, const T b, const T c, const T d) {
+    static_assert((std::is_integral<T>::value), "fourcc supports integral built-in types only");
+    return ((static_cast<uint32_t>(a) << 24) | (static_cast<uint32_t>(b) << 16) | (static_cast<uint32_t>(c) << 8) | (static_cast<uint32_t>(d) << 0));
+}
+OBFormat uvcFourccToOBFormat(uint32_t fourcc);
+uint32_t obFormatToUvcFourcc(OBFormat format);
+
+float mapIMUSampleRateToValue(OBIMUSampleRate rate);
+
+const std::string &obFormatToStr(OBFormat type);
+const std::string &obFrameToStr(OBFrameType type);
+const std::string &obStreamToStr(OBStreamType type);
+const std::string &obSensorToStr(OBSensorType type);
+const std::string &obImuRateToStr(OBIMUSampleRate type);
+const std::string &GyroFullScaleRangeToStr(OBGyroFullScaleRange range);
+const std::string &AccelFullScaleRangeToStr(OBAccelFullScaleRange params);
+const std::string &MetaDataToStr(OBFrameMetadataType params);
+
+OBFormat              strToOBFormat(const std::string str);
+OBFrameType           strToOBFrame(const std::string str);
+OBStreamType          strToOBStream(const std::string str);
+OBSensorType          strToOBSensor(const std::string str);
+OBIMUSampleRate       strToObImuRate(const std::string str);
+OBGyroFullScaleRange  strToGyroFullScaleRange(const std::string str);
+OBAccelFullScaleRange strToAccelFullScaleRange(const std::string str);
+
+float                 depthPrecisionLevelToUnit(OBDepthPrecisionLevel precision);
+OBDepthPrecisionLevel depthUnitToPrecisionLevel(float unit);
+
+}  // namespace utils
+}  // namespace libobsensor
+
+std::ostream &operator<<(std::ostream &os, const OBFormat &type);
+std::ostream &operator<<(std::ostream &os, const OBFrameType &type);
+std::ostream &operator<<(std::ostream &os, const OBStreamType &type);
+std::ostream &operator<<(std::ostream &os, const OBSensorType &type);
+std::ostream &operator<<(std::ostream &os, const OBIMUSampleRate &type);  // also for accel
+std::ostream &operator<<(std::ostream &os, const OBGyroFullScaleRange &type);
+std::ostream &operator<<(std::ostream &os, const OBAccelFullScaleRange &type);
+std::ostream &operator<<(std::ostream &os, const OBCameraParam &params);
+std::ostream &operator<<(std::ostream &os, const OBCalibrationParam &type);
+std::ostream &operator<<(std::ostream &os, const OBPoint3f &type);
+std::ostream &operator<<(std::ostream &os, const OBExtrinsic &type);
+std::ostream &operator<<(std::ostream &os, const OBPoint2f &type);
+std::ostream &operator<<(std::ostream &os, const OBCameraIntrinsic &type);
+std::ostream &operator<<(std::ostream &os, const OBCameraDistortion &type);
+
+
diff --git a/src/shared/utils/StringUtils.cpp b/src/shared/utils/StringUtils.cpp
new file mode 100644
index 00000000..1c75a021
--- /dev/null
+++ b/src/shared/utils/StringUtils.cpp
@@ -0,0 +1,181 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "StringUtils.hpp"
+#include "Utils.hpp"
+#include <algorithm>
+#include <locale>
+#include <cstring>
+#include <cstdlib>
+
+namespace libobsensor {
+namespace utils {
+namespace string {
+
+std::vector<std::string> tokenize(const std::string &s, const char separator) {
+
+    std::vector<std::string> ret;
+    if(!s.empty()) {
+        std::istringstream stream(s);
+        std::string        str;
+        while(getline(stream, str, separator)) {
+            ret.push_back(str);
+        }
+    }
+    return ret;
+}
+
+std::vector<std::string> split(const std::string &s, const std::string &separator) {
+    std::vector<std::string> res;
+    if("" == s)
+        return res;
+    char *strs = new char[s.length() + 1];
+    strcpy(strs, s.c_str());
+
+    char *d = new char[separator.length() + 1];
+    strcpy(d, separator.c_str());
+
+    char *p = strtok(strs, d);
+    while(p) {
+        std::string str = p;
+        res.push_back(str);
+        p = strtok(NULL, d);
+    }
+    delete[] strs;
+    delete[] d;
+    return res;
+}
+
+std::string remove(const std::string &s, const std::string &rm) {
+    auto        strSplitVec = split(s, rm);
+    std::string outStr      = "";
+    for(auto &str: strSplitVec) {
+        outStr += str;
+    }
+    return outStr;
+}
+
+std::string removeSpace(const std::string &s) {
+    std::string outStr = s;
+    outStr.erase(std::remove(outStr.begin(), outStr.end(), ' '), outStr.end());
+    return outStr;
+}
+
+std::string replace(const std::string &s, const std::string &src, const std::string &rep) {
+    std::string outStr = s;
+    auto        place  = outStr.find(src);
+    while(place < outStr.length()) {
+        outStr = outStr.replace(place, rep.length(), rep);
+        place  = outStr.find(src);
+    }
+    return outStr;
+}
+
+std::string replaceFirst(const std::string &s, const std::string &src, const std::string &rep) {
+    std::string outStr = s;
+    auto        place  = outStr.find(src);
+    if(place < outStr.length()) {
+        outStr = outStr.replace(place, src.length(), rep);
+    }
+    return outStr;
+}
+
+std::string toLower(const std::string &s) {
+    std::string outStr = s;
+    for(auto &c: outStr) {
+        if(c >= 'A' && c <= 'Z') {
+            c = c - 'A' + 'a';
+        }
+    }
+    return outStr;
+}
+
+std::string toUpper(const std::string &s) {
+    std::string outStr = s;
+    for(auto &c: outStr) {
+        if(c >= 'a' && c <= 'z') {
+            c = c - 'a' + 'A';
+        }
+    }
+    return outStr;
+}
+
+std::string clearHeadAndTailSpace(const std::string &str) {
+    std::string temp = str;
+    if(temp.empty()) {
+        return temp;
+    }
+    temp.erase(0, temp.find_first_not_of(" "));
+    temp.erase(temp.find_last_not_of(" ") + 1);
+    return temp;
+}
+
+bool cvt2Boolean(const std::string &string, bool &dst) {
+    if(!string.empty()) {
+        std::string loweredCaseValue = toLower(string);
+        bool        result           = false;
+        if(!(std::istringstream(loweredCaseValue) >> std::boolalpha >> result)) {
+            std::string tempStr = clearHeadAndTailSpace(string);
+            if(tempStr.size() != 1) {
+                return false;
+            }
+            else {
+                if(*tempStr.c_str() >= '0' && *tempStr.c_str() <= '1') {
+                    dst = static_cast<bool>(std::atoi(tempStr.c_str()));
+                    return true;
+                }
+                else {
+                    return false;
+                }
+            }
+        }
+        dst = result;
+        return true;
+    }
+    return false;
+}
+
+bool cvt2Int(const std::string &string, int &dst) {
+    std::string temp = clearHeadAndTailSpace(string);
+    if(!temp.empty()) {
+        if(temp.size() == 1) {
+            if(*temp.c_str() >= '0' && *temp.c_str() <= '9') {
+                dst = std::atoi(temp.c_str());
+                return true;
+            }
+            else {
+                return false;
+            }
+        }
+        else {
+            dst = std::atoi(temp.c_str());
+            return std::to_string(dst).size() == temp.size();
+        }
+    }
+    return false;
+}
+
+bool cvt2Float(const std::string &string, float &dst) {
+    if(!string.empty()) {
+        char *nptr;
+        dst              = std::strtof(string.c_str(), &nptr);
+        std::string temp = clearHeadAndTailSpace(nptr);
+        return temp.empty();
+    }
+    return false;
+}
+
+bool cvt2Double(const std::string &string, double &dst) {
+    if(!string.empty()) {
+        char *nptr;
+        dst              = std::strtod(string.c_str(), &nptr);
+        std::string temp = clearHeadAndTailSpace(nptr);
+        return temp.empty();
+    }
+    return false;
+}
+
+}  // namespace string
+}  // namespace utils
+}  // namespace libobsensor
+
diff --git a/src/shared/utils/StringUtils.hpp b/src/shared/utils/StringUtils.hpp
new file mode 100644
index 00000000..86d2a89e
--- /dev/null
+++ b/src/shared/utils/StringUtils.hpp
@@ -0,0 +1,95 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include <sstream>
+#include <string>
+#include <vector>
+#include <iostream>
+
+namespace libobsensor {
+namespace utils {
+namespace string {
+
+struct to_string {
+    std::ostringstream            ss;
+    template <class T> to_string &operator<<(const T &val) {
+        ss << val;
+        return *this;
+    }
+    operator std::string() const {
+        return ss.str();
+    }
+};
+
+template <typename T> class isStreamable {
+    template <typename S> static auto test(const S *t) -> decltype(std::cout << **t);
+    static auto                       test(...) -> std::false_type;
+
+public:
+    enum { value = !std::is_same<decltype(test((T *)0)), std::false_type>::value };
+};
+
+template <class T, bool S> struct ArgsStreamer {
+    void streamArg(std::ostream &out, const T &val, bool last) {
+        out << ':' << val << (last ? " " : ", ");
+    }
+};
+
+template <class T> struct ArgsStreamer<T *, true> {
+    void streamArg(std::ostream &out, T *val, bool last) {
+        out << ':';  // If pointer not null, stream its content
+        if(val)
+            out << *val;
+        else
+            out << "nullptr";
+        out << (last ? "" : ", ");
+    }
+};
+
+template <class T> struct ArgsStreamer<T *, false> {
+    void streamArg(std::ostream &out, T *val, bool last) {
+        out << ':';  // If pointer is not null, stream the pointer
+        if(val)
+            out << (int *)val;  // Go through (int*) to avoid dumping the content of char*
+        else
+            out << "nullptr";
+        out << (last ? "" : ", ");
+    }
+};
+
+template <class T> void ArgsToStream(std::ostream &out, const char *names, const T &last) {
+    out << names;
+    ArgsStreamer<T, isStreamable<T>::value> s;
+    s.streamArg(out, last, true);
+}
+
+template <class T, class... U> void ArgsToStream(std::ostream &out, const char *names, const T &first, const U &...rest) {
+    while(*names && *names != ',')
+        out << *names++;
+    ArgsStreamer<T, isStreamable<T>::value> s;
+    s.streamArg(out, first, false);
+    while(*names && (*names == ',' || isspace(*names)))
+        ++names;
+    ArgsToStream(out, names, rest...);
+}
+
+std::vector<std::string> tokenize(const std::string &s, char separator = ',');
+std::vector<std::string> split(const std::string &s, const std::string &separator);
+std::string              remove(const std::string &s, const std::string &rm);
+std::string              removeSpace(const std::string &s);
+std::string              replace(const std::string &s, const std::string &src, const std::string &rep);
+std::string              replaceFirst(const std::string &s, const std::string &src, const std::string &rep);
+std::string              toLower(const std::string &s);
+std::string              toUpper(const std::string &s);
+
+std::string clearHeadAndTailSpace(const std::string &string);
+bool        cvt2Int(const std::string &string, int &dst);
+bool        cvt2Float(const std::string &string, float &dst);
+bool        cvt2Double(const std::string &string, double &dst);
+bool        cvt2Boolean(const std::string &string, bool &dst);
+}  // namespace string
+}  // namespace utils
+}  // namespace libobsensor
+
diff --git a/src/shared/utils/Utils.cpp b/src/shared/utils/Utils.cpp
new file mode 100644
index 00000000..96dee40c
--- /dev/null
+++ b/src/shared/utils/Utils.cpp
@@ -0,0 +1,60 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "Utils.hpp"
+
+#ifdef WIN32
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+#else
+#include <unistd.h>
+#endif
+
+#include <chrono>
+#include <logger/Logger.hpp>
+
+namespace libobsensor {
+namespace utils {
+
+    uint64_t getNowTimesMs() {
+        return std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count();
+    }
+    uint64_t getNowTimesUs() {
+        return std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::system_clock::now().time_since_epoch()).count();
+    }
+
+    void sleepMs(uint64_t msec) {
+#ifdef WIN32
+        Sleep((DWORD)msec);
+#else
+        usleep((useconds_t)(msec * 1000));
+#endif
+    }
+
+    bool checkJpgImageData(const uint8_t *data, size_t dataLen) {
+        bool validImage = dataLen >= 2 && data[0] == 0xFF && data[1] == 0xD8;
+        if(validImage) {
+            // To resolve misjudgments caused by the MJPG data tail (0xFF 0xD9) not being arranged according to the standard MJPG format due to alignment and
+            // other issues
+            size_t startIndex = dataLen - 1;
+            size_t endIndex   = startIndex - 10;
+            for(size_t index = startIndex; index > endIndex && index > 0; index--) {
+                if(data[index] != 0x00) {
+                    if(data[index] == 0xD9 && data[index - 1] == 0xFF) {
+                        validImage = true;
+                    }
+                    else {
+                        LOG_DEBUG("check mjpg end flag failed:data[index]:{0},data[index - 1]:{1}", data[index], data[index - 1]);
+                        validImage = false;
+                    }
+                    break;
+                }
+            }
+        }
+        return validImage;
+    }
+
+}  // namespace utils
+}  // namespace libobsensor
diff --git a/src/shared/utils/Utils.hpp b/src/shared/utils/Utils.hpp
new file mode 100644
index 00000000..da1d71e6
--- /dev/null
+++ b/src/shared/utils/Utils.hpp
@@ -0,0 +1,81 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include <stdint.h>
+#include <vector>
+#include <memory>
+#include <algorithm>
+
+// Include all the headers in the utils directory for convenience
+#include "StringUtils.hpp"
+#include "FileUtils.hpp"
+#include "PublicTypeHelper.hpp"
+
+namespace libobsensor {
+namespace utils {
+
+uint64_t getNowTimesMs();
+uint64_t getNowTimesUs();
+void     sleepMs(uint64_t msec);
+
+#pragma pack(push, 1)
+template <class T> class big_endian {
+    T be_value;
+
+public:
+    operator T() const {
+        T le_value = 0;
+        for(unsigned int i = 0; i < sizeof(T); ++i)
+            reinterpret_cast<char *>(&le_value)[i] = reinterpret_cast<const char *>(&be_value)[sizeof(T) - i - 1];
+        return le_value;
+    }
+};
+#pragma pack(pop)
+
+template <typename T> void unusedVar(T &var) {
+    (void)var;
+}
+
+template <class T> std::vector<std::shared_ptr<T>> subtract_sets(const std::vector<std::shared_ptr<T>> &first, const std::vector<std::shared_ptr<T>> &second) {
+    std::vector<std::shared_ptr<T>> results;
+    std::for_each(first.begin(), first.end(), [&](std::shared_ptr<T> data) {
+        if(std::find_if(second.begin(), second.end(), [&](std::shared_ptr<T> new_dev) { return *data == *new_dev; }) == second.end()) {
+            results.push_back(data);
+        }
+    });
+    return results;
+}
+
+template <class T> std::vector<T> subtract_sets(const std::vector<T> &first, const std::vector<T> &second) {
+    std::vector<T> results;
+    std::for_each(first.begin(), first.end(), [&](T data) {
+        if(std::find_if(second.begin(), second.end(), [&](T new_dev) { return data == new_dev; }) == second.end()) {
+            results.push_back(data);
+        }
+    });
+    return results;
+}
+
+template <typename T> std::vector<std::vector<T>> groupVector(const std::vector<T> &vec, std::function<bool(const T &elm0, const T &elm1)> compareFunc) {
+    std::vector<std::vector<T>> group;
+    for(const auto &elm0: vec) {
+        auto itVec = group.begin();
+        while(itVec != group.end()) {
+            if(compareFunc(elm0, itVec->front())) {
+                itVec->push_back(elm0);
+                break;
+            }
+            itVec++;
+        }
+        if(itVec == group.end()) {
+            group.push_back(std::vector<T>({ elm0 }));
+        }
+    }
+    return group;
+}
+
+bool checkJpgImageData(const uint8_t *data, size_t dataLen);
+}  // namespace utils
+}  // namespace libobsensor
diff --git a/src/shared/xml/XmlReader.cpp b/src/shared/xml/XmlReader.cpp
new file mode 100644
index 00000000..71d083bf
--- /dev/null
+++ b/src/shared/xml/XmlReader.cpp
@@ -0,0 +1,173 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "XmlReader.hpp"
+#include "tinyxml2.hpp"
+
+#include "logger/Logger.hpp"
+#include "exception/ObException.hpp"
+#include "utils/Utils.hpp"
+
+namespace libobsensor {
+XmlReader::XmlReader(const std::string& filePath) {
+    doc_ = std::make_shared<XMLDocument>();
+    if(filePath.empty()) {
+        throw invalid_value_exception("XmlReader::XmlReader: filePath is empty!");
+    }
+
+    if(!utils::fileExists(filePath.c_str())) {
+        throw invalid_value_exception("XmlReader::XmlReader: file not exist!");
+    }
+
+    auto rc = doc_->LoadFile(filePath.c_str());
+    if(rc != 0) {
+        throw invalid_value_exception(utils::string::to_string() << "XmlReader::XmlReader: load file failed!, rc=" << rc);
+    }
+
+    rootXMLElement_ = doc_->RootElement();
+    if(!rootXMLElement_) {
+        throw invalid_value_exception("XmlReader::XmlReader: root element is null!");
+    }
+}
+
+XmlReader::XmlReader(const char *buffer, size_t size) {
+    doc_ = std::make_shared<XMLDocument>();
+
+    if(!buffer || size == 0) {
+        throw invalid_value_exception("XmlReader::XmlReader: buffer is null or size is 0!");
+    }
+
+    auto rc = doc_->Parse(buffer, size);
+    if(rc != 0) {
+        throw invalid_value_exception(utils::string::to_string() << "XmlReader::XmlReader: parse buffer failed!, rc=" << rc);
+    }
+
+    rootXMLElement_ = doc_->RootElement();
+    if(!rootXMLElement_) {
+        throw invalid_value_exception("XmlReader::XmlReader: root element is null!");
+    }
+}
+
+XMLElement *XmlReader::getRootElement() const {
+    return rootXMLElement_;
+}
+
+bool XmlReader::getTextOfLeafNode(const std::string &nodePathName, std::string &text) {
+    std::string errorMessage;
+    if(nodePathName.empty()) {
+        return false;
+    }
+    auto NodeList        = utils::string::split(nodePathName, ".");
+    auto rootXMLElement  = rootXMLElement_;
+    auto ChildrenElement = rootXMLElement_;
+    for(size_t i = 0; i < NodeList.size(); ++i) {
+        libobsensor::XMLElement *childrenElement = nullptr;
+        childrenElement                          = rootXMLElement->FirstChildElement(NodeList[i].c_str());
+        if(!childrenElement) {
+            return false;
+        }
+        if(i < NodeList.size() - 1) {
+            rootXMLElement = childrenElement;
+        }
+        if(i == NodeList.size() - 1) {
+            ChildrenElement = childrenElement;
+        }
+    }
+
+    if(ChildrenElement == rootXMLElement_) {
+        return false;
+    }
+
+    if(!ChildrenElement->FirstChild() || !ChildrenElement->FirstChild()->ToText()) {
+        return false;
+    }
+    text = ChildrenElement->GetText();
+    return true;
+}
+
+bool XmlReader::isNodeContained(const std::string &nodePathName) {
+    if (nodePathName.empty()) {
+        return false;
+    }
+    auto nodeList = utils::string::split(nodePathName, ".");
+    if(nodeList.empty()) {
+        return false;
+    }
+
+    XMLElement *currentElement = rootXMLElement_;
+    for (const auto &nodeName : nodeList) {
+        currentElement = currentElement->FirstChildElement(nodeName.c_str());
+        if (!currentElement) {
+            return false;
+        }
+    }
+    return true;
+}
+
+bool XmlReader::getBooleanValue(const std::string &nodePathName, bool &t) {
+    std::string text;
+    bool        status = getTextOfLeafNode(nodePathName, text);
+    if(!status) {
+        return false;
+    }
+    status = utils::string::cvt2Boolean(text, t);
+    if(!status) {
+        return false;
+    }
+    return true;
+}
+
+bool XmlReader::getIntValue(const std::string &nodePathName, int &t) {
+    std::string text;
+    bool        status = getTextOfLeafNode(nodePathName, text);
+    if(!status) {
+        return false;
+    }
+    status = utils::string::cvt2Int(text, t);
+    if(!status) {
+        return false;
+    }
+    return true;
+}
+
+bool XmlReader::getFloatValue(const std::string &nodePathName, float &t) {
+    std::string text;
+    bool        status = getTextOfLeafNode(nodePathName, text);
+    if(!status) {
+        return false;
+    }
+    status = utils::string::cvt2Float(text, t);
+    if(!status) {
+        return false;
+    }
+    return true;
+}
+
+bool XmlReader::getDoubleValue(const std::string &nodePathName, double &t) {
+    std::string text;
+    bool        status = getTextOfLeafNode(nodePathName, text);
+    if(!status) {
+        return false;
+    }
+    status = utils::string::cvt2Double(text, t);
+    if(!status) {
+        return false;
+    }
+    return true;
+}
+
+bool XmlReader::getStringValue(const std::string &nodePathName, std::string &t) {
+    std::string text;
+    bool        status = getTextOfLeafNode(nodePathName, text);
+    if(!status) {
+        return false;
+    }
+    text = utils::string::clearHeadAndTailSpace(text);
+    if(text.empty()) {
+        return false;
+    }
+    t = text;
+    return true;
+}
+
+}  // namespace libobsensor
diff --git a/src/shared/xml/XmlReader.hpp b/src/shared/xml/XmlReader.hpp
new file mode 100644
index 00000000..69d8e536
--- /dev/null
+++ b/src/shared/xml/XmlReader.hpp
@@ -0,0 +1,59 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+//
+// Created by zyb on 2020/9/16.
+//
+
+#pragma once
+
+#include <libobsensor/h/ObTypes.h>
+
+#include <stdarg.h>
+#include <algorithm>
+#include <memory>
+#include <mutex>
+#include <vector>
+#include <map>
+
+namespace libobsensor {
+class XMLDocument;
+class XMLElement;
+class XMLAttribute;
+class XMLComment;
+class XMLText;
+class XMLDeclaration;
+class XMLUnknown;
+class XMLPrinter;
+class XmlReader final {
+
+public:
+    explicit XmlReader(const std::string& filePath);
+    XmlReader(const char *buffer, size_t size);
+
+    ~XmlReader() noexcept = default;
+
+private:
+    bool loadConfigFile(const std::string &filePath);
+    bool loadConfigFromBuffer(const char *buffer, size_t size);
+
+public:
+    bool        isNodeContained(const std::string &nodePathName);
+    bool        getIntValue(const std::string &nodePathName, int &t);
+    bool        getBooleanValue(const std::string &nodePathName, bool &t);
+    bool        getFloatValue(const std::string &nodePathName, float &t);
+    bool        getDoubleValue(const std::string &nodePathName, double &t);
+    bool        getStringValue(const std::string &nodePathName, std::string &t);
+    XMLElement *getRootElement() const;
+
+private:
+    bool getTextOfLeafNode(const std::string &nodePathName, std::string &t);
+
+private:
+    std::shared_ptr<XMLDocument> doc_;
+
+private:
+    XMLElement *rootXMLElement_;
+};
+}  // namespace libobsensor
+
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
new file mode 100644
index 00000000..5d9d5a74
--- /dev/null
+++ b/tests/CMakeLists.txt
@@ -0,0 +1,13 @@
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+cmake_minimum_required(VERSION 3.5)
+
+file(GLOB subdirectories RELATIVE ${CMAKE_CURRENT_LIST_DIR} "*")
+
+foreach(subdir ${subdirectories})
+    if(IS_DIRECTORY ${CMAKE_CURRENT_LIST_DIR}/${subdir})
+        add_subdirectory(${subdir})
+    endif()
+endforeach()
+
diff --git a/tests/align_test/CMakeLists.txt b/tests/align_test/CMakeLists.txt
new file mode 100644
index 00000000..c5ae412a
--- /dev/null
+++ b/tests/align_test/CMakeLists.txt
@@ -0,0 +1,10 @@
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+cmake_minimum_required(VERSION 3.5)
+
+add_executable(align_test align_test.cpp ${OB_PROJECT_ROOT_DIR}/src/filter/publicfilters/AlignImpl.hpp ../../src/filter/publicfilters/AlignImpl.cpp)
+target_include_directories(align_test PRIVATE ${OB_PROJECT_ROOT_DIR}/src/filter/publicfilters/)
+target_link_libraries(align_test PRIVATE ob::OrbbecSDK ob::shared)
+set_target_properties(align_test PROPERTIES FOLDER "tests")
+
diff --git a/tests/align_test/align_test.cpp b/tests/align_test/align_test.cpp
new file mode 100644
index 00000000..c3fd78f9
--- /dev/null
+++ b/tests/align_test/align_test.cpp
@@ -0,0 +1,372 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include "AlignImpl.hpp"
+
+#include <iostream>
+#include <fstream>
+#include <regex>
+
+#include <map>
+#include <sstream>
+#include <string>
+
+// Data structure to hold the sections, keys, and values
+using IniSection = std::map<std::string, std::string>;
+using IniData    = std::map<std::string, IniSection>;
+
+// Function to trim whitespace from the beginning and end of a string
+std::string trim(const std::string &str) {
+    const char *whitespace = " \t\n\r";
+    size_t      start      = str.find_first_not_of(whitespace);
+    size_t      end        = str.find_last_not_of(whitespace);
+    return (start == std::string::npos) ? "" : str.substr(start, end - start + 1);
+}
+
+// Function to parse an INI file
+IniData parseIniFile(const std::string &filename) {
+    IniData       iniData;
+    std::ifstream file(filename);
+    std::string   line;
+    std::string   currentSection;
+
+    if(!file.is_open()) {
+        std::cerr << "Could not open file: " << filename << std::endl;
+        return iniData;
+    }
+
+    while(std::getline(file, line)) {
+        line = trim(line);
+
+        // Skip empty lines or comments
+        if(line.empty() || line[0] == ';' || line[0] == '#')
+            continue;
+
+        // Handle sections [section]
+        if(line[0] == '[' && line.back() == ']') {
+            currentSection = line.substr(1, line.size() - 2);
+            currentSection = trim(currentSection);
+        }
+        // Handle key-value pairs key=value
+        else {
+            size_t equalsPos = line.find('=');
+            if(equalsPos != std::string::npos) {
+                std::string key              = trim(line.substr(0, equalsPos));
+                std::string value            = trim(line.substr(equalsPos + 1));
+                iniData[currentSection][key] = value;
+            }
+        }
+    }
+
+    file.close();
+    return iniData;
+}
+
+// Function to display parsed INI data
+void displayIniData(const IniData &iniData) {
+    for(const auto &section: iniData) {
+        std::cout << "[" << section.first << "]" << std::endl;
+        for(const auto &pair: section.second) {
+            std::cout << pair.first << "=" << pair.second << std::endl;
+        }
+    }
+}
+
+int parse_bolt_data(char *filename, OBCameraIntrinsic &depth_intr, OBCameraIntrinsic &color_intr, OBCameraDistortion &depth_disto, OBCameraDistortion &color_disto,
+                    OBTransform &trans) {
+    IniData inidata = parseIniFile(filename);
+    color_disto.k1  = static_cast<float>(std::atof(inidata["ColorDistortion"]["k1"].c_str()));
+    color_disto.k2  = static_cast<float>(std::atof(inidata["ColorDistortion"]["k2"].c_str()));
+    color_disto.k3  = static_cast<float>(std::atof(inidata["ColorDistortion"]["k3"].c_str()));
+    color_disto.k4  = static_cast<float>(std::atof(inidata["ColorDistortion"]["k4"].c_str()));
+    color_disto.k5  = static_cast<float>(std::atof(inidata["ColorDistortion"]["k5"].c_str()));
+    color_disto.k6  = static_cast<float>(std::atof(inidata["ColorDistortion"]["k6"].c_str()));
+    color_disto.p1  = static_cast<float>(std::atof(inidata["ColorDistortion"]["p1"].c_str()));
+    color_disto.p2  = static_cast<float>(std::atof(inidata["ColorDistortion"]["p2"].c_str()));
+    color_disto.model   = OBCameraDistortionModel::OB_DISTORTION_BROWN_CONRADY_K6;
+    color_intr.fx   = static_cast<float>(std::atof(inidata["ColorIntrinsic"]["fx"].c_str()));
+    color_intr.fy   = static_cast<float>(std::atof(inidata["ColorIntrinsic"]["fy"].c_str()));
+    color_intr.cx   = static_cast<float>(std::atof(inidata["ColorIntrinsic"]["cx"].c_str()));
+    color_intr.cy   = static_cast<float>(std::atof(inidata["ColorIntrinsic"]["cy"].c_str()));
+    color_intr.width   = static_cast<int16_t>(std::atof(inidata["ColorIntrinsic"]["width"].c_str()));
+    color_intr.height   = static_cast<int16_t>(std::atof(inidata["ColorIntrinsic"]["height"].c_str()));
+    depth_disto.k1  = static_cast<float>(std::atof(inidata["DepthDistortion"]["k1"].c_str()));
+    depth_disto.k2  = static_cast<float>(std::atof(inidata["DepthDistortion"]["k2"].c_str()));
+    depth_disto.k3  = static_cast<float>(std::atof(inidata["DepthDistortion"]["k3"].c_str()));
+    depth_disto.k4  = static_cast<float>(std::atof(inidata["DepthDistortion"]["k4"].c_str()));
+    depth_disto.k5  = static_cast<float>(std::atof(inidata["DepthDistortion"]["k5"].c_str()));
+    depth_disto.k6  = static_cast<float>(std::atof(inidata["DepthDistortion"]["k6"].c_str()));
+    depth_disto.p1  = static_cast<float>(std::atof(inidata["DepthDistortion"]["p1"].c_str()));
+    depth_disto.p2  = static_cast<float>(std::atof(inidata["DepthDistortion"]["p2"].c_str()));
+    depth_disto.model   = OBCameraDistortionModel::OB_DISTORTION_BROWN_CONRADY_K6;
+    depth_intr.fx       = static_cast<float>(std::atof(inidata["DepthIntrinsic"]["fx"].c_str()));
+    depth_intr.fy       = static_cast<float>(std::atof(inidata["DepthIntrinsic"]["fy"].c_str()));
+    depth_intr.cx       = static_cast<float>(std::atof(inidata["DepthIntrinsic"]["cx"].c_str()));
+    depth_intr.cy       = static_cast<float>(std::atof(inidata["DepthIntrinsic"]["cy"].c_str()));
+    depth_intr.width    = static_cast<int16_t>(std::atof(inidata["DepthIntrinsic"]["width"].c_str()));
+    depth_intr.height   = static_cast<int16_t>(std::atof(inidata["DepthIntrinsic"]["height"].c_str()));
+
+    for(size_t i = 0; i < 9; i++) {
+        std::string key = "rot" + std::to_string(i);
+        float       tmp = static_cast<float>(std::atof(inidata["D2CTransformParam"][key].c_str()));
+        trans.rot[i]    = tmp;
+    }
+    for(size_t i = 0; i < 3; i++) {
+        std::string key = "trans" + std::to_string(i);
+        float       tmp = static_cast<float>(std::atof(inidata["D2CTransformParam"][key].c_str()));
+        trans.trans[i]    = tmp;
+    }
+
+    return 0;
+}
+
+#define RESOLUTION std::pair<int, int>
+#define INTRINSIC_MAP std::unordered_map<RESOLUTION, OBCameraIntrinsic, libobsensor::ResHashFunc, libobsensor::ResComp>
+
+int parse_obviewer_data(char *filename, OBCameraIntrinsic &depth_intr, OBCameraIntrinsic &color_intr, OBCameraDistortion &depth_disto,
+                        OBCameraDistortion &color_disto, OBTransform &trans) {
+    std::ifstream file(filename);
+    if(!file.is_open()) {
+        std::cerr << "Error opening file." << std::endl;
+        return 1;
+    }
+
+    std::string line;
+
+    const std::string numberPattern = R"([+-]?\d+\.?\d*[eE]?[+-]?\d*)";
+
+    // Define regular expressions for each type of line
+    std::regex extrinsicRotationRegex(
+        R"(rotation:(-?\d+\.\d+) (-?\d+\.\d+) (-?\d+\.\d+) (-?\d+\.\d+) (-?\d+\.\d+) (-?\d+\.\d+) (-?\d+\.\d+) (-?\d+\.\d+) (-?\d+\.\d+))");
+    // Define regular expressions for each type of line using the number pattern
+    std::regex intrinsicRegex(R"(fx:()" + numberPattern + R"() fy:()" + numberPattern + R"() cx:()" + numberPattern + R"() cy:()" + numberPattern
+                              + R"() width:(\d+) height:(\d+))");
+
+    std::regex distortionRegex(R"(k1:()" + numberPattern + R"() k2:()" + numberPattern + R"() k3:()" + numberPattern + R"() k4:()" + numberPattern + R"() k5:()"
+                               + numberPattern + R"() k6:()" + numberPattern + R"() p1:()" + numberPattern + R"() p2:()" + numberPattern + R"())");
+
+    std::regex extrinsicTranslationRegex(R"(translation:()" + numberPattern + R"( )()" + numberPattern + R"( )()" + numberPattern + R"())");
+
+    while(std::getline(file, line)) {
+        std::smatch match;
+
+        // Match color intrinsic parameters
+        if(std::regex_search(line, match, intrinsicRegex) && line.find("Color Intrinsic") != std::string::npos) {
+            color_intr = { std::stof(match[1]), std::stof(match[2]),          std::stof(match[3]),
+                           std::stof(match[4]), int16_t(std::stoi(match[5])), int16_t(std::stoi(match[6])) };
+        }
+
+        // Match depth intrinsic parameters
+        else if(std::regex_search(line, match, intrinsicRegex) && line.find("Depth Intrinsic") != std::string::npos) {
+            depth_intr = { std::stof(match[1]), std::stof(match[2]),          std::stof(match[3]),
+                           std::stof(match[4]), int16_t(std::stoi(match[5])), int16_t(std::stoi(match[6])) };
+        }
+
+        // Match color distortion parameters
+        else if(std::regex_search(line, match, distortionRegex) && line.find("Color Distortion") != std::string::npos) {
+            color_disto = { std::stof(match[1]), std::stof(match[2]), std::stof(match[3]),
+                            std::stof(match[4]), std::stof(match[5]), std::stof(match[6]),
+                            std::stof(match[7]), std::stof(match[8]), OBCameraDistortionModel::OB_DISTORTION_BROWN_CONRADY };
+        }
+
+        // Match depth distortion parameters
+        else if(std::regex_search(line, match, distortionRegex) && line.find("Depth Distortion") != std::string::npos) {
+            depth_disto = { std::stof(match[1]), std::stof(match[2]), std::stof(match[3]),
+                            std::stof(match[4]), std::stof(match[5]), std::stof(match[6]),
+                            std::stof(match[7]), std::stof(match[8]), OBCameraDistortionModel::OB_DISTORTION_BROWN_CONRADY };
+        }
+
+        // Match depth to color rotation parameters
+        else if(std::regex_search(line, match, extrinsicRotationRegex)) {
+            for(int i = 0; i < 9; ++i) {
+                trans.rot[i] = std::stof(match[1 + i]);
+            }
+        }
+
+        // Match depth to color translation parameters
+        else if(std::regex_search(line, match, extrinsicTranslationRegex)) {
+            for(int i = 0; i < 3; ++i) {
+                trans.trans[i] = std::stof(match[1 + i]);
+            }
+        }
+    }
+
+    file.close();
+    return 0;
+}
+
+int parse_oblog_data(char *filename, INTRINSIC_MAP &depth_intr_map, INTRINSIC_MAP &color_intr_map, OBCameraDistortion &depth_disto,
+    OBCameraDistortion &color_disto, OBTransform &trans) {
+
+    std::ifstream file(filename);
+    if(!file.is_open()) {
+        std::cerr << "Error opening file." << std::endl;
+        return 1;
+    }
+
+    std::string line;
+
+    const std::string numberPattern = R"([+-]?\d+\.?\d*[eE]?[+-]?\d*)";
+
+    // Define regular expressions for each type of line
+    std::regex intrinsicRegex(R"(cx: ()" + numberPattern + R"(), cy: ()" + numberPattern + R"(), fx: ()" + numberPattern + R"(), fy: ()" + numberPattern
+                              + R"(), width: (\d+), height: (\d+))");
+
+    std::regex distortionRegex(R"(k1: ()" + numberPattern + R"(), k2: ()" + numberPattern + R"(), k3: ()" + numberPattern + R"(), k4: ()" + numberPattern + R"(), k5: ()"
+                               + numberPattern + R"(), k6: ()" + numberPattern + R"(), p1: ()" + numberPattern + R"(), p2: ()" + numberPattern + R"())");
+
+    std::regex extrinsicRegex(R"(rot: \[()" + numberPattern + R"(), ()" + numberPattern + R"(), ()" + numberPattern + R"(), ()"
+        + numberPattern + R"(), ()" + numberPattern + R"(), ()" + numberPattern + R"(), ()"
+        + numberPattern + R"(), ()" + numberPattern + R"(), ()" + numberPattern + R"()\], trans: \[()"
+        + numberPattern + R"(), ()" + numberPattern + R"(), ()" + numberPattern + R"()\])");
+
+    while(std::getline(file, line)) {
+        printf("%s\n", line.c_str());
+        std::smatch match;
+
+        // Match color intrinsic parameters
+        if(std::regex_search(line, match, intrinsicRegex) && line.find("rgbIntrinsic") != std::string::npos) {
+            OBCameraIntrinsic color_intr = { std::stof(match[1]), std::stof(match[2]),          std::stof(match[3]),
+                           std::stof(match[4]), int16_t(std::stoi(match[5])), int16_t(std::stoi(match[6])) };
+            color_intr_map[RESOLUTION(color_intr.width, color_intr.height)] = color_intr;
+        }
+
+        // Match depth intrinsic parameters
+        else if(std::regex_search(line, match, intrinsicRegex) && line.find("depthIntrinsic") != std::string::npos) {
+            OBCameraIntrinsic depth_intr = { std::stof(match[1]), std::stof(match[2]),          std::stof(match[3]),
+                           std::stof(match[4]), int16_t(std::stoi(match[5])), int16_t(std::stoi(match[6])) };
+            depth_intr_map[RESOLUTION(depth_intr.width, depth_intr.height)] = depth_intr;
+        }
+
+        // Match color distortion parameters
+        else if(std::regex_search(line, match, distortionRegex) && line.find("rgbDistortion") != std::string::npos) {
+            color_disto = { std::stof(match[1]), std::stof(match[2]), std::stof(match[3]),
+                            std::stof(match[4]), std::stof(match[5]), std::stof(match[6]),
+                            std::stof(match[7]), std::stof(match[8]), OBCameraDistortionModel::OB_DISTORTION_BROWN_CONRADY };
+        }
+
+        // Match depth distortion parameters
+        else if(std::regex_search(line, match, distortionRegex) && line.find("depthDistortion") != std::string::npos) {
+            depth_disto = { std::stof(match[1]), std::stof(match[2]), std::stof(match[3]),
+                            std::stof(match[4]), std::stof(match[5]), std::stof(match[6]),
+                            std::stof(match[7]), std::stof(match[8]), OBCameraDistortionModel::OB_DISTORTION_BROWN_CONRADY };
+        }
+
+        // Match depth to color rotation parameters
+        else if(std::regex_search(line, match, extrinsicRegex)) {
+            for(int i = 0; i < 9; ++i) {
+                trans.rot[i] = std::stof(match[1 + i]);
+            }
+            for(int i = 0; i < 3; ++i) {
+                trans.trans[i] = std::stof(match[1 + 9 + i]);
+            }
+        }
+    }
+
+    file.close();
+    return 0;
+
+}
+
+int main__(int argc, char *argv[]) {
+    if(argc < 4) {
+        std::cerr << "Usage: %s <param_file> <depth_image_file> <color_image_file>" << std::endl;
+        return -1;
+    }
+
+    INTRINSIC_MAP  depth_intr, color_intr;
+    OBCameraDistortion depth_disto, color_disto;
+    OBTransform        transform;
+    if(0 != parse_oblog_data(argv[1], depth_intr, color_intr, depth_disto, color_disto, transform)) {
+        std::cerr << "Parse parameter file error." << std::endl;
+        return -1;
+    }
+
+    return 0;
+}
+
+int main(int argc, char *argv[]) {
+    if(argc < 4) {
+        std::cerr << "Usage: %s <param_file> <depth_image_file> <color_image_file>" << std::endl;
+        return -1;
+    }
+
+    OBCameraIntrinsic  depth_intr, color_intr;
+    OBCameraDistortion depth_disto, color_disto;
+    OBTransform        transform;
+
+    bool bIni = false;
+    { 
+        std::string tmp = std::string(argv[1]);
+        if (tmp.length() >= 4) {
+            bIni = tmp.substr(tmp.length() - 4) == ".ini";
+        }
+    }
+
+    if((bIni && parse_bolt_data(argv[1], depth_intr, color_intr, depth_disto, color_disto, transform))
+        || (0 != parse_obviewer_data(argv[1], depth_intr, color_intr, depth_disto, color_disto, transform))) {
+        std::cerr << "Parse parameter file error." << std::endl;
+        return -1;
+    }
+    libobsensor::AlignImpl *impl = new libobsensor::AlignImpl();
+    impl->initialize(depth_intr, depth_disto, color_intr, color_disto, transform, 1, true, true);
+
+    ob_error *err = nullptr;
+
+    FILE *depth_file = fopen(argv[2], "rb");
+    if(!depth_file) {
+        *err = { ob_status::OB_STATUS_ERROR, "read file error", "fopen", *argv[2], ob_exception_type::OB_EXCEPTION_TYPE_IO };
+        std::cerr << err->message << std::endl;
+        return -1;
+    }
+
+    uint32_t  depth_size = depth_intr.width * depth_intr.height * sizeof(uint16_t);
+    uint16_t *depth_data = (uint16_t *)malloc(depth_size);
+    fread(depth_data, depth_size, 1, depth_file);
+    //for(int i = 0; i < depth_intr.width * depth_intr.height; i++) {
+    //    depth_data[i] = _byteswap_ushort(depth_data[i]);
+    //}
+    uint32_t  aligned_depth_size = color_intr.width * color_intr.height * sizeof(uint16_t);
+    uint16_t *aligned_depth_data = (uint16_t *)malloc(aligned_depth_size);
+    //if(0 == impl->D2C(depth_data, depth_intr.width, depth_intr.height, aligned_depth_data, color_intr.width, color_intr.height, nullptr, true)) {
+    if(0 == impl->D2C(depth_data, depth_intr.width, depth_intr.height, aligned_depth_data, color_intr.width, color_intr.height, nullptr, false)) {
+        char nname[256];
+        sprintf(nname, "%s_filtered.raw", argv[2]);
+        FILE *fp = fopen(nname, "wb");
+        if(fp) {
+            fwrite(aligned_depth_data, 1, aligned_depth_size, fp);
+            fclose(fp);
+        }
+    }
+    free(aligned_depth_data);
+
+    FILE *color_file = fopen(argv[3], "rb");
+    if(!color_file) {
+        *err = { ob_status::OB_STATUS_ERROR, "read file error", "fopen", *argv[3], ob_exception_type::OB_EXCEPTION_TYPE_IO };
+        std::cerr << err->message << std::endl;
+        return -1;
+    }
+    uint32_t color_size = color_intr.width * color_intr.height * sizeof(uint8_t) * 3;
+    uint8_t *color_data = (uint8_t *)malloc(color_size);
+    fread(color_data, color_size, 1, color_file);
+    uint32_t aligned_color_size = depth_intr.width * depth_intr.height * sizeof(uint8_t) * 3;
+    uint8_t *aligned_color_data = (uint8_t *)malloc(aligned_color_size);
+    if(0 == impl->C2D(depth_data, depth_intr.width, depth_intr.height, color_data, aligned_color_data, color_intr.width, color_intr.height, OB_FORMAT_RGB, false)) {
+        char nname[256];
+        sprintf(nname, "%s_filtered.raw", argv[3]);
+        FILE *fp = fopen(nname, "wb");
+        if(fp) {
+            fwrite(aligned_color_data, 1, aligned_color_size, fp);
+            fclose(fp);
+        }
+    }
+
+    free(depth_data);
+    free(color_data);
+    free(aligned_color_data);
+
+    delete impl;
+    impl = nullptr;
+    return 0;
+}
+
diff --git a/tests/frame_test/CMakeLists.txt b/tests/frame_test/CMakeLists.txt
new file mode 100644
index 00000000..8ff09ee3
--- /dev/null
+++ b/tests/frame_test/CMakeLists.txt
@@ -0,0 +1,9 @@
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+cmake_minimum_required(VERSION 3.5)
+
+add_executable(frame_test frame_test.cpp)
+target_link_libraries(frame_test PRIVATE ob::OrbbecSDK)
+set_target_properties(frame_test PROPERTIES FOLDER "tests")
+
diff --git a/tests/frame_test/frame_test.cpp b/tests/frame_test/frame_test.cpp
new file mode 100644
index 00000000..28ff64e9
--- /dev/null
+++ b/tests/frame_test/frame_test.cpp
@@ -0,0 +1,47 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+extern "C" {
+#include <libobsensor/h/Frame.h>
+#include <libobsensor/h/Filter.h>
+#include <libobsensor/h/Error.h>
+}
+
+#include <iostream>
+
+void check_ob_error(ob_error **err) {
+    if(*err) {
+        std::cerr << "Error: " << ob_error_get_message(*err) << std::endl;
+        ob_delete_error(*err);
+        exit(-1);
+    }
+    *err = nullptr;
+}
+
+int main() {
+    ob_error *err   = nullptr;
+    auto      frame = ob_create_video_frame(OB_FRAME_DEPTH, OB_FORMAT_Y16, 640, 480, OB_DEFAULT_STRIDE_BYTES, &err);
+    check_ob_error(&err);
+
+    auto data = ob_frame_get_data(frame, &err);
+    check_ob_error(&err);
+    std::cout << "Data pointer: " << (uint64_t)data << std::endl;
+
+    auto data_size = ob_frame_get_data_size(frame, &err);
+    check_ob_error(&err);
+    std::cout << "Data size: " << data_size << std::endl;
+
+    auto filter = ob_create_filter("NoiseRemovalFilter", &err);
+    check_ob_error(&err);
+
+    auto config_schema = ob_filter_get_config_schema(filter, &err);
+    check_ob_error(&err);
+    std::cout << "NoiseRemovalFilter Config schema: \n" << config_schema << std::endl;
+
+    ob_delete_filter(filter, &err);
+    check_ob_error(&err);
+
+    ob_delete_frame(frame, &err);
+    check_ob_error(&err);
+    return 0;
+}
diff --git a/tests/hdr_test/CMakeLists.txt b/tests/hdr_test/CMakeLists.txt
new file mode 100644
index 00000000..7fdd602b
--- /dev/null
+++ b/tests/hdr_test/CMakeLists.txt
@@ -0,0 +1,10 @@
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+cmake_minimum_required(VERSION 3.5)
+
+add_executable(hdr_test hdr_test.cpp)
+target_include_directories(hdr_test PRIVATE ${OB_PROJECT_ROOT_DIR}/src/filter/public_filters/)
+target_link_libraries(hdr_test PRIVATE ob::OrbbecSDK ob::shared)
+set_target_properties(hdr_test PROPERTIES FOLDER "tests")
+
diff --git a/tests/hdr_test/hdr_test.cpp b/tests/hdr_test/hdr_test.cpp
new file mode 100644
index 00000000..05f4c109
--- /dev/null
+++ b/tests/hdr_test/hdr_test.cpp
@@ -0,0 +1,205 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include <iostream>
+#include <fstream>
+#include <regex>
+#include <string>
+#include <chrono>
+
+template <typename T>
+int loadFile(char *filename, uint32_t num_element, T* data, bool swap_endianess) {
+    if(!filename || !data) {
+        throw std::string("Null pointer.");
+    }
+
+    FILE *file = fopen(filename, "rb");
+    if(!file) {
+        throw std::string("Read file error: ").append(filename);
+    }
+
+    fread(data, sizeof(T), num_element, file);
+    if(swap_endianess) {
+		for(size_t i = 0; i < num_element; i++) {
+			data[i] = static_cast<T>(_byteswap_ushort(static_cast<uint16_t>(data[i])));
+		}
+    }
+
+    return 0;
+}
+
+void mergeFramesUsingOnlyDepth(uint16_t *new_data, uint16_t *d0, uint16_t *d1, int width, int height) {
+    for(int i = 0; i < width * height; i++) {
+        if(d0[i] && d1[i]) {
+            if(d0[i] == 65535)
+                new_data[i] = d1[i];
+            else
+                new_data[i] = d0[i];
+        }
+        else if(d0[i])
+            new_data[i] = d0[i];
+        else if(d1[i])
+            new_data[i] = d1[i];
+    }
+}
+
+template <typename T>
+void triangleWeights(float* w) {
+    if(!w)
+        return;
+    int   length = 1 << (sizeof(T) * 8); 
+    int   half   = length / 2;
+    memset(w, 0, sizeof(float) * length);
+    for(int i = 0; i < length; i++) {
+        *w++ = i < half ? (1.f * i / half) : (2 - 1.f * i / half);
+    }
+}
+
+template <typename T>
+void censusStd(const T* ir, int width, int height, uint8_t* std, uint8_t ws = 7) {
+    int ws_2 = ws / 2;
+    int thresh = 10;
+    memset(std, 0, sizeof(uint8_t) * width * height);
+
+    for(int v = ws_2; v < height - ws_2; v++) {
+        int      row_start_idx = v * width + ws_2;
+        const T *p_ir_center   = ir + row_start_idx;
+        uint8_t *p_std         = std + row_start_idx;
+
+        for(int u = ws_2; u < width - ws_2; u++) {
+			uint8_t  count         = 0;
+
+            const T *p_ir_row = p_ir_center - ws_2 * width - ws_2;
+            for(int wv = -ws_2; wv < ws_2; wv+=1) {
+                const T *p_ir_col = p_ir_row;
+                for(int wu = -ws_2; wu < ws_2; wu+=1) {
+                    if((*p_ir_col - *p_ir_center < -thresh) || (*p_ir_col - *p_ir_center > thresh))
+                        count++;
+					p_ir_col++;
+                }
+                p_ir_row += width;
+            }
+
+            p_ir_center++;
+            *p_std++ = count;
+        }
+    }
+}
+
+float EXP_LUT[256];
+bool  LUT_Inited = false;
+float s_global = 256.f / (7 * 7);
+
+template <typename T> void generateConfidenceMap(const T *ir, uint8_t *map, int width, int height, uint8_t ws = 7) {
+    std::cout << ws;
+
+    if (!LUT_Inited) {
+		triangleWeights<uint8_t>(EXP_LUT);
+    }
+
+    //uint8_t *std_w = (uint8_t *)malloc(width * height * sizeof(uint8_t));
+    //memset(std_w, 0, width * height * sizeof(uint8_t));
+    //censusStd<uint8_t>(ir, width, height, std_w, ws);
+
+    const uint8_t *p_ir = ir;
+    //uint8_t       *p_std = std_w;
+    uint8_t *      p_map = map;
+
+    for(int i = 0; i < height; i++) {
+        for(int j = 0; j < width; j++) {
+            float exp                 = EXP_LUT[*p_ir++];
+            //*p_map++ = static_cast<uint8_t>(exp * (*p_std++) * s_global);
+            *p_map++ = static_cast<uint8_t>(exp * 255);
+        }
+    }
+
+    //free(std_w);
+}
+
+void mergeFramesUsingIr(uint16_t *new_data, uint16_t *d0, uint16_t *d1, uint8_t* first_ir,
+                        uint8_t *second_ir, int width, int height) {
+    int      pix_num     = width * height;
+    int      map_size    = sizeof(uint8_t) * pix_num;
+    uint8_t *confidence0 = (uint8_t *)malloc(map_size);
+    uint8_t *confidence1 = (uint8_t *)malloc(map_size);
+    if(!confidence0 || !confidence1) {
+        return;
+    }
+    memset(confidence0, 0, sizeof(uint8_t) * pix_num);
+    memset(confidence1, 0, sizeof(uint8_t) * pix_num);
+
+	generateConfidenceMap<uint8_t>(first_ir, confidence0, width, height);
+	generateConfidenceMap<uint8_t>(second_ir, confidence1, width, height);
+
+    for(int i = 0; i < pix_num; i++) {
+        new_data[i] = confidence0[i] > confidence1[i] ? d0[i] : d1[i];
+    }
+    free(confidence0);
+    free(confidence1);
+}
+
+template<typename T>
+void saveImage(T* data, int element_num, char name[]) {
+	FILE *fp = fopen(name, "wb");
+	if(fp) {
+		fwrite(data, sizeof(T), element_num, fp);
+		fclose(fp);
+	}
+    else {
+        throw std::string("Open file error: ").append(name);
+    }
+}
+
+int main(int argc, char *argv[]) try{
+    if(argc < 7) {
+        throw std::string("Usage: %s width heght exp0 exp1 depth0 depth1 [ir0] [ir1]");
+    }
+
+    int width = std::atoi(argv[1]), height = std::atoi(argv[2]), exp0 = std::atoi(argv[3]), exp1 = std::atoi(argv[4]);
+    std::cout << exp0 << exp1 << std::endl;
+    int pix_num = width * height;
+    int depth_size = pix_num * sizeof(uint16_t);
+    int ir_size    = pix_num * sizeof(uint8_t);
+
+    uint16_t *depth0 = (uint16_t *)malloc(depth_size), *depth1 = (uint16_t*)malloc(depth_size);
+    uint8_t *ir0 = (uint8_t *)malloc(ir_size), *ir1 = (uint8_t*)malloc(ir_size);
+    loadFile<uint16_t>(argv[5], pix_num, depth0, true);
+    loadFile<uint16_t>(argv[6], pix_num, depth1, true);
+    loadFile<uint8_t>(argv[7], pix_num, ir0, false);
+    loadFile<uint8_t>(argv[8], pix_num, ir1, false);
+
+    uint16_t *depth_output = (uint16_t *)malloc(depth_size);
+    memset(depth_output, 0, depth_size);
+
+    mergeFramesUsingOnlyDepth(depth_output, depth0, depth1, width, height);
+
+	char nname[256];
+	sprintf(nname, "%s_depthonly.raw", argv[5]);
+    saveImage<uint16_t>(depth_output, pix_num, nname);
+
+    std::chrono::steady_clock::time_point start, end;
+    for(size_t i = 0; i < 100; i++) {
+        start = std::chrono::high_resolution_clock::now();
+		mergeFramesUsingIr(depth_output, depth0, depth1, ir0, ir1, width, height);
+        end = std::chrono::high_resolution_clock::now();
+        std::chrono::microseconds d = std::chrono::duration_cast<std::chrono::microseconds>(end - start);
+        std::cout << d.count() << std::endl;
+    }
+	sprintf(nname, "%s_withir.raw", argv[5]);
+    saveImage<uint16_t>(depth_output, pix_num, nname);
+
+    free(depth0);
+    free(depth1);
+    free(ir0);
+    free(ir1);
+    free(depth_output);
+
+    return 0;
+}
+catch (const std::string& e)
+{
+    std::cerr << e << std::endl;
+    exit(-1);
+}
+
+
diff --git a/tests/total_test/CMakeLists.txt b/tests/total_test/CMakeLists.txt
new file mode 100644
index 00000000..a044a838
--- /dev/null
+++ b/tests/total_test/CMakeLists.txt
@@ -0,0 +1,9 @@
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+cmake_minimum_required(VERSION 3.5)
+
+add_executable(total_test total_test.cpp)
+target_link_libraries(total_test PRIVATE ob::OrbbecSDK)
+set_target_properties(total_test PROPERTIES FOLDER "tests")
+
diff --git a/tests/total_test/total_test.cpp b/tests/total_test/total_test.cpp
new file mode 100644
index 00000000..e50ce011
--- /dev/null
+++ b/tests/total_test/total_test.cpp
@@ -0,0 +1,228 @@
+// Copyright (c) Orbbec Inc. All Rights Reserved.
+// Licensed under the MIT License.
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include <libobsensor/h/Error.h>
+#include <libobsensor/h/Context.h>
+#include <libobsensor/h/Device.h>
+#include <libobsensor/h/Sensor.h>
+#include <libobsensor/h/Frame.h>
+#include <libobsensor/h/StreamProfile.h>
+
+#include <windows.h>
+
+// helper function to check for errors and exit if there is one
+void check_ob_error(ob_error **err) {
+    if(*err) {
+        const char *error_message = ob_error_get_message(*err);
+        fprintf(stderr, "Error: %s\n", error_message);
+        ob_delete_error(*err);
+        exit(-1);
+    }
+    *err = NULL;
+}
+
+void printf_device_list(ob_device_list *device_list) {
+    ob_error *err = NULL;
+
+    uint32_t count = ob_device_list_get_count(device_list, &err);
+    check_ob_error(&err);
+
+    for(uint32_t i = 0; i < count; i++) {
+        const char *name = ob_device_list_get_device_name(device_list, i, &err);
+        check_ob_error(&err);
+
+        const char *serial_number = ob_device_list_get_device_serial_number(device_list, i, &err);
+        check_ob_error(&err);
+
+        int pid = ob_device_list_get_device_pid(device_list, i, &err);
+        check_ob_error(&err);
+
+        int vid = ob_device_list_get_device_vid(device_list, i, &err);
+        check_ob_error(&err);
+
+        const char *uid = ob_device_list_get_device_uid(device_list, i, &err);
+        check_ob_error(&err);
+
+        const char *connection_type = ob_device_list_get_device_connection_type(device_list, i, &err);
+        check_ob_error(&err);
+
+        printf("device#%d:\n \tname: %s\n \tserial_number: %s\n \tpid: %d\n \tvid: %d\n \tuid: %s\n \tconnection_type: %s\n", i, name, serial_number, pid, vid,
+               uid, connection_type);
+    }
+}
+
+void printf_device_info(ob_device_info *device_info) {
+    ob_error *err = NULL;
+
+    const char *name = ob_device_info_get_name(device_info, &err);
+    check_ob_error(&err);
+
+    const char *serial_number = ob_device_info_get_serial_number(device_info, &err);
+    check_ob_error(&err);
+
+    int pid = ob_device_info_get_pid(device_info, &err);
+    check_ob_error(&err);
+
+    int vid = ob_device_info_get_vid(device_info, &err);
+    check_ob_error(&err);
+
+    const char *uid = ob_device_info_get_uid(device_info, &err);
+    check_ob_error(&err);
+
+    const char *connection_type = ob_device_info_get_connection_type(device_info, &err);
+    check_ob_error(&err);
+
+    const char *fw_version = ob_device_info_get_firmware_version(device_info, &err);
+    check_ob_error(&err);
+
+    const char *hw_version = ob_device_info_get_hardware_version(device_info, &err);
+    check_ob_error(&err);
+
+    const char *min_sdk_ver = ob_device_info_get_supported_min_sdk_version(device_info, &err);
+    check_ob_error(&err);
+
+    printf("device:\n \tname: %s\n \tserial_number: %s\n \tpid: %d\n \tvid: %d\n \tuid: %s\n \tconnection_type: %s\n \tfw_version: %s\n \thw_version: %s\n "
+           "\tmin_sdk_ver: %s\n",
+           name, serial_number, pid, vid, uid, connection_type, fw_version, hw_version, min_sdk_ver);
+}
+
+void printf_sensor_list(ob_sensor_list *sensor_list) {
+    ob_error *err = NULL;
+
+    uint32_t count = ob_sensor_list_get_count(sensor_list, &err);
+    check_ob_error(&err);
+
+    printf("sensor_list:\n");
+    for(uint32_t i = 0; i < count; i++) {
+        ob_sensor_type type = ob_sensor_list_get_sensor_type(sensor_list, i, &err);
+        check_ob_error(&err);
+        printf("\tsensor#%d: type: %d\n", i, type);
+    }
+}
+
+void printf_stream_profile_list(const ob_stream_profile_list *stream_profile_list) {
+    ob_error *err = NULL;
+
+    uint32_t count = ob_stream_profile_list_get_count(stream_profile_list, &err);
+    check_ob_error(&err);
+
+    printf("stream_profile_list:\n");
+    for(uint32_t i = 0; i < count; i++) {
+        const ob_stream_profile *stream_profile = ob_stream_profile_list_get_profile(stream_profile_list, i, &err);
+        check_ob_error(&err);
+
+        uint32_t width = ob_video_stream_profile_get_width(stream_profile, &err);
+        check_ob_error(&err);
+
+        uint32_t height = ob_video_stream_profile_get_height(stream_profile, &err);
+        check_ob_error(&err);
+
+        uint32_t fps = ob_video_stream_profile_get_fps(stream_profile, &err);
+        check_ob_error(&err);
+
+        ob_format format = ob_stream_profile_get_format(stream_profile, &err);
+        check_ob_error(&err);
+
+        ob_delete_stream_profile(stream_profile, &err);
+        check_ob_error(&err);
+
+        printf("\tstream_profile#%d: width: %d, height: %d, fps: %d, format: %d\n", i, width, height, fps, format);
+    }
+}
+
+void sensor_frame_callback(ob_frame *frame, void *user_data) {
+    ob_error *err   = NULL;
+    uint64_t  index = ob_frame_get_index(frame, &err);
+    check_ob_error(&err);
+
+    uint32_t width = ob_video_frame_get_width(frame, &err);
+    check_ob_error(&err);
+
+    uint32_t height = ob_video_frame_get_height(frame, &err);
+    check_ob_error(&err);
+
+    ob_format format = ob_frame_get_format(frame, &err);
+    check_ob_error(&err);
+
+    uint32_t size = ob_frame_get_data_size(frame, &err);
+    check_ob_error(&err);
+
+    const uint8_t *data = ob_frame_get_data(frame, &err);
+    check_ob_error(&err);
+
+    ob_delete_frame(frame, &err);
+    check_ob_error(&err);
+
+    char *str = (char *)user_data;
+    printf("%s: frame#%lld: width: %d, height: %d, format: %d, size: %d, dataPtr: %p\n", str, index, width, height, format, size, data);
+}
+
+int main() {
+    // define the error pointer to handle errors
+    ob_error *err = NULL;
+
+    // set the logger to console with debug severity
+    ob_set_logger_to_console(OB_LOG_SEVERITY_DEBUG, &err);
+    check_ob_error(&err);
+
+    // create a context
+    ob_context *ctx = ob_create_context(&err);
+    check_ob_error(&err);
+
+    ob_device_list *device_list = ob_query_device_list(ctx, &err);
+    check_ob_error(&err);
+
+    printf_device_list(device_list);
+
+    ob_device *device = ob_device_list_get_device(device_list, 0, &err);
+    check_ob_error(&err);
+
+    ob_device_info *device_info = ob_device_get_device_info(device, &err);
+    check_ob_error(&err);
+
+    printf_device_info(device_info);
+
+    ob_sensor_list *sensor_list = ob_device_get_sensor_list(device, &err);
+    check_ob_error(&err);
+
+    printf_sensor_list(sensor_list);
+
+    ob_sensor *sensor = ob_sensor_list_get_sensor_by_type(sensor_list, OB_SENSOR_COLOR, &err);
+    check_ob_error(&err);
+
+    const ob_stream_profile_list *stream_profile_list = ob_sensor_get_stream_profile_list(sensor, &err);
+    check_ob_error(&err);
+
+    printf_stream_profile_list(stream_profile_list);
+
+    const ob_stream_profile *stream_profile = ob_stream_profile_list_get_profile(stream_profile_list, 0, &err);
+    check_ob_error(&err);
+
+    ob_sensor_start(sensor, stream_profile, sensor_frame_callback, "hello, world", &err);
+    check_ob_error(&err);
+
+    // sleep for 5 seconds
+    Sleep(5000);
+
+    ob_sensor_stop(sensor, &err);
+    check_ob_error(&err);
+
+    ob_delete_stream_profile_list(stream_profile_list, &err);
+    check_ob_error(&err);
+
+    ob_delete_sensor_list(sensor_list, &err);
+    check_ob_error(&err);
+
+    ob_delete_device_info(device_info, &err);
+    check_ob_error(&err);
+
+    ob_delete_device_list(device_list, &err);
+    check_ob_error(&err);
+
+    // delete the context
+    ob_delete_context(ctx, &err);
+    check_ob_error(&err);
+}
diff --git a/tools/CMakeLists.txt b/tools/CMakeLists.txt
new file mode 100644
index 00000000..042b5aa6
--- /dev/null
+++ b/tools/CMakeLists.txt
@@ -0,0 +1,4 @@
+# Copyright (c) Orbbec Inc. All Rights Reserved.
+# Licensed under the MIT License.
+
+
diff --git a/wrappers/README.md b/wrappers/README.md
new file mode 100644
index 00000000..bf8ea88b
--- /dev/null
+++ b/wrappers/README.md
@@ -0,0 +1,21 @@
+# Orbbec SDK Wrappers
+
+## Introduction
+
+  The Orbbec SDK Wrappers provide a range of solutions to seamlessly integrate Orbbec 3D cameras into various development environments. These wrappers support multiple programming languages and frameworks, making it easier for developers to work with Orbbec devices in their preferred ecosystem. 
+
+## 1. ROS
+
+  Orbbec ROS SDK is a wrapper for Orbbec SDK that supports ROS Kinetic, Melodic, and Noetic distributions. It enables smooth integration of Orbbec 3D cameras into ROS projects.[https://github.com/orbbec/OrbbecSDK_ROS1](https://github.com/orbbec/OrbbecSDK_ROS1).
+
+## 2. ROS2
+
+  Orbbec SDK ROS 2 is a wrapper for the Orbbec 3D camera that provides seamless integration with the ROS 2 environment. It supports ROS 2 Foxy, Humble, and Jazzy distributions.[https://github.com/orbbec/OrbbecSDK_ROS2](https://github.com/orbbec/OrbbecSDK_ROS2).
+
+## 3. Python
+
+  This project provides Python bindings for the Orbbec SDK, allowing developers to interface with Orbbec devices in Python.[https://github.com/orbbec/pyorbbecsdk](https://github.com/orbbec/pyorbbecsdk).
+
+## 4. K4A
+
+  This is a wrapper  for the Orbbec SDK for  K4A, It allowing users to develop applications using the K4A API and access Orbbec cameras. Additionally, users can replace the native K4A library in their application with this library without any code changes.[https://github.com/orbbec/OrbbecSDK-K4A-Wrapper](https://github.com/orbbec/OrbbecSDK-K4A-Wrapper).